diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
new file mode 100644
index 0000000..46b6302
--- /dev/null
+++ b/include/CMakeLists.txt
@@ -0,0 +1,13 @@
+add_library(mockturtle INTERFACE)
+target_include_directories(mockturtle SYSTEM INTERFACE ${PROJECT_SOURCE_DIR}/include)
+target_link_libraries(mockturtle INTERFACE kitty lorina parallel_hashmap percy json bill libabcesop)
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9)
+target_link_libraries(mockturtle INTERFACE stdc++fs)
+endif()
+
+if(ENABLE_ABC)
+target_link_libraries(mockturtle INTERFACE ${PROJECT_SOURCE_DIR}/lib/abc_static/libabc.a)
+target_link_libraries(mockturtle INTERFACE dl)
+target_compile_definitions(mockturtle INTERFACE ENABLE_ABC)
+endif()
diff --git a/include/mockturtle/algorithms/aig_balancing.hpp b/include/mockturtle/algorithms/aig_balancing.hpp
new file mode 100644
index 0000000..cf5a475
--- /dev/null
+++ b/include/mockturtle/algorithms/aig_balancing.hpp
@@ -0,0 +1,482 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aig_balancing.hpp
+  \brief Balances the AIG to reduce the depth
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <vector>
+#include <random>
+#include <algorithm>
+
+#include "cleanup.hpp"
+#include "../networks/aig.hpp"
+#include "../traits.hpp"
+#include "../views/depth_view.hpp"
+#include "../views/fanout_view.hpp"
+
+namespace mockturtle
+{
+
+struct aig_balancing_params
+{
+  /*! \brief Minimizes the number of levels. */
+  bool minimize_levels{ true };
+
+  /*! \brief Use fast version, it may not find some area optimizations. */
+  bool fast_mode{ true };
+};
+
+namespace detail
+{
+
+template<class Ntk>
+class aig_balance_impl
+{
+public:
+  static constexpr size_t storage_init_size = 30;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  using storage_t = std::vector<std::vector<signal>>;
+
+public:
+  aig_balance_impl( Ntk& ntk, aig_balancing_params const& ps )
+      : ntk( ntk ), ps( ps ), storage( storage_init_size )
+  {
+  }
+
+  void run()
+  {
+    ntk.clear_values();
+
+    for ( auto i = 0; i < storage_init_size; ++i )
+      storage[i].reserve( 10 );
+
+    /* balance every CO */
+    ntk.foreach_co( [&]( auto const& f ) {
+      balance_rec( ntk.get_node( f ), 0 );
+    } );
+  }
+
+private:
+  signal balance_rec( node const& n, uint32_t level )
+  {
+    if ( ntk.is_ci( n ) )
+      return ntk.make_signal( n );
+
+    /* node has been replaced in a previous recursion */
+    if ( ntk.is_dead( n ) || ntk.value( n ) > 0 )
+    {
+      return ntk.make_signal( find_substituted_node( n ) );
+    }
+
+    if ( level >= storage.size() )
+    {
+      storage.emplace_back( std::vector<signal>() );
+      storage.back().reserve( 10 );
+    }
+
+    /* collect leaves of the AND tree */
+    collect_leaves( n, storage[level] );
+
+    if ( storage[level].size() == 0 )
+    {
+      ntk.substitute_node( n, ntk.get_constant( false ) );
+      return ntk.get_constant( false );
+    }
+
+    /* recur over the leaves */
+    for ( auto& f : storage[level] )
+    {
+      signal new_signal = balance_rec( ntk.get_node( f ), level + 1 );
+      f = new_signal ^ ntk.is_complemented( f );
+    }
+
+    assert( storage[level].size() > 1 );
+
+    /* sort by decreasing level */
+    std::stable_sort( storage[level].begin(), storage[level].end(), [this]( auto const& a, auto const& b ) {
+      return ntk.level( ntk.get_node( a ) ) > ntk.level( ntk.get_node( b ) );
+    } );
+
+    /* mark TFI cone of n */
+    ntk.incr_trav_id();
+    mark_tfi( ntk.make_signal( n ), true );
+
+    /* generate the AND tree */
+    while ( storage[level].size() > 1 )
+    {
+      /* explore multiple possibilities to find logic sharing */
+      if ( ps.fast_mode )
+      {
+        if ( ps.minimize_levels )
+          pick_nodes_fast( storage[level], find_left_most_at_level( storage[level] ) );
+        else
+          pick_nodes_area_fast( storage[level] );
+      }
+      else
+      {
+        if ( ps.minimize_levels )
+          pick_nodes( storage[level], find_left_most_at_level( storage[level] ) );
+        else
+          pick_nodes_area( storage[level] );
+      }
+
+      /* pop the two selected nodes to create the new AND gate */
+      signal child1 = storage[level].back();
+      storage[level].pop_back();
+      signal child2 = storage[level].back();
+      storage[level].pop_back();
+      signal new_sig = ntk.create_and( child1, child2 );
+
+      /* update level for AND node */
+      update_level( ntk.get_node( new_sig ) );
+
+      /* insert the new node back */
+      insert_node_sorted( storage[level], new_sig );
+    }
+
+    signal root = storage[level][0];
+
+    /* replace if new */
+    if ( n != ntk.get_node( root ) )
+    {
+      ntk.substitute_node_no_restrash( n, root );
+    }
+
+    /* remember the substitution and the new node as already balanced */
+    ntk.set_value( n, ntk.node_to_index( ntk.get_node( root ) ) );
+    ntk.set_value( ntk.get_node( root ), ntk.node_to_index( ntk.get_node( root ) ) );
+
+    /* clean leaves storage */
+    storage[level].clear();
+
+    return root;
+  }
+
+  void collect_leaves( node const& n, std::vector<signal>& leaves )
+  {
+    ntk.incr_trav_id();
+
+    int ret = collect_leaves_rec( ntk.make_signal( n ), leaves, true );
+
+    /* check for constant false */
+    if ( ret < 0 )
+    {
+      leaves.clear();
+    }
+  }
+
+  int collect_leaves_rec( signal const& f, std::vector<signal>& leaves, bool is_root )
+  {
+    node n = ntk.get_node( f );
+
+    /* check if already visited */
+    if ( ntk.visited( n ) == ntk.trav_id() )
+    {
+      for ( signal const& s : leaves )
+      {
+        if ( ntk.get_node( s ) != n )
+          continue;
+
+        if ( s == f )
+          return 1;   /* same polarity: duplicate */
+        else
+          return -1;  /* opposite polarity: const0 */
+      }
+
+      return 0;
+    }
+
+    /* set as leaf if signal is complemented or is a CI or has a multiple fanout */
+    if ( !is_root && ( ntk.is_complemented( f ) || ntk.is_ci( n ) || ntk.fanout_size( n ) > 1 ) )
+    {
+      leaves.push_back( f );
+      ntk.set_visited( n, ntk.trav_id() );
+      return 0;
+    }
+
+    int ret = 0;
+    ntk.foreach_fanin( n, [&]( auto const& child ) {
+      ret |= collect_leaves_rec( child, leaves, false );
+    } );
+
+    return ret;
+  }
+
+  size_t find_left_most_at_level( std::vector<signal> const& leaves )
+  {
+    size_t pointer = leaves.size() - 1;
+    uint32_t current_level = ntk.level( ntk.get_node( leaves[leaves.size() - 2] ) );
+
+    while ( pointer > 0 )
+    {
+      if ( ntk.level( ntk.get_node( leaves[pointer - 1] ) ) > current_level )
+        break;
+
+      --pointer;
+    }
+
+    assert( ntk.level( ntk.get_node( leaves[pointer] ) ) == current_level );
+    return pointer;
+  }
+
+  inline void pick_nodes( std::vector<signal>& leaves, size_t left_most )
+  {
+    size_t right_most = leaves.size() - 2;
+
+    if ( ntk.level( ntk.get_node( leaves[leaves.size() - 1] ) ) == ntk.level( ntk.get_node( leaves[leaves.size() - 2] ) ) )
+      right_most = left_most;
+
+    for ( size_t right_pointer = leaves.size() - 1; right_pointer > right_most; --right_pointer )
+    {
+      assert( left_most < right_pointer );
+
+      size_t left_pointer = right_pointer;
+      while ( left_pointer-- > left_most )
+      {
+        /* select if node exists */
+        std::optional<signal> pnode = ntk.has_and( leaves[right_pointer], leaves[left_pointer] );
+        if ( pnode.has_value() )
+        {
+          /* already present in TFI */
+          if ( ntk.visited( ntk.get_node( *pnode ) ) == ntk.trav_id() )
+          {
+            continue;
+          }
+
+          if ( leaves[right_pointer] != leaves[leaves.size() - 1] )
+            std::swap( leaves[right_pointer], leaves[leaves.size() - 1] );
+          if ( leaves[left_pointer] != leaves[leaves.size() - 2] )
+            std::swap( leaves[left_pointer], leaves[leaves.size() - 2] );
+          break;
+        }
+      }
+    }
+  }
+
+  inline void pick_nodes_fast( std::vector<signal>& leaves, size_t left_most )
+  {
+    size_t left_pointer = leaves.size() - 1;
+    while ( left_pointer-- > left_most )
+    {
+      /* select if node exists */
+      std::optional<signal> pnode = ntk.has_and( leaves.back(), leaves[left_pointer] );
+      if ( pnode.has_value() )
+      {
+        /* already present in TFI */
+        if ( ntk.visited( ntk.get_node( *pnode ) ) == ntk.trav_id() )
+        {
+          continue;
+        }
+
+        if ( leaves[left_pointer] != leaves[leaves.size() - 2] )
+          std::swap( leaves[left_pointer], leaves[leaves.size() - 2] );
+        break;
+      }
+    }
+  }
+
+  inline void pick_nodes_area( std::vector<signal>& leaves )
+  {
+    for ( size_t right_pointer = leaves.size() - 1; right_pointer > 0; --right_pointer )
+    {
+      size_t left_pointer = right_pointer;
+      while ( left_pointer-- > 0 )
+      {
+        /* select if node exists */
+        std::optional<signal> pnode = ntk.has_and( leaves[right_pointer], leaves[left_pointer] );
+        if ( pnode.has_value() )
+        {
+          /* already present in TFI */
+          if ( ntk.visited( ntk.get_node( *pnode ) ) == ntk.trav_id() )
+          {
+            continue;
+          }
+
+          if ( leaves[right_pointer] != leaves[leaves.size() - 1] )
+            std::swap( leaves[right_pointer], leaves[leaves.size() - 1] );
+          if ( leaves[left_pointer] != leaves[leaves.size() - 2] )
+            std::swap( leaves[left_pointer], leaves[leaves.size() - 2] );
+          break;
+        }
+      }
+    }
+  }
+
+  inline void pick_nodes_area_fast( std::vector<signal>& leaves )
+  {
+    size_t left_pointer = leaves.size() - 1;
+    while ( left_pointer-- > 0 )
+    {
+      /* select if node exists */
+      std::optional<signal> pnode = ntk.has_and( leaves.back(), leaves[left_pointer] );
+      if ( pnode.has_value() )
+      {
+        /* already present in TFI */
+        if ( ntk.visited( ntk.get_node( *pnode ) ) == ntk.trav_id() )
+        {
+          continue;
+        }
+
+        if ( leaves[left_pointer] != leaves[leaves.size() - 2] )
+          std::swap( leaves[left_pointer], leaves[leaves.size() - 2] );
+        break;
+      }
+    }
+  }
+
+  void insert_node_sorted( std::vector<signal>& leaves, signal const& f )
+  {
+    node n = ntk.get_node( f );
+
+    /* check uniqueness */
+    for ( auto const& s : leaves )
+    {
+      if ( s == f )
+        return;
+    }
+
+    leaves.push_back( f );
+    for ( size_t i = leaves.size() - 1; i > 0; --i )
+    {
+      auto& s2 = leaves[i - 1];
+
+      if ( ntk.level( ntk.get_node( s2 ) ) < ntk.level( n ) )
+      {
+        std::swap( s2, leaves[i] );
+      }
+      else
+      {
+        break;
+      }
+    }
+  }
+
+  void update_level( node const& n )
+  {
+    uint32_t l = 0;
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      l = std::max( l, ntk.level( ntk.get_node( f ) ) );
+    } );
+
+    ntk.set_level( n, l + 1 );
+  }
+
+  node find_substituted_node( node n )
+  {
+    while ( ntk.is_dead( n ) )
+      n = ntk.index_to_node( ntk.value( n ) );
+    
+    return n;
+  }
+
+  void mark_tfi( signal const& f, bool is_root )
+  {
+    node n = ntk.get_node( f );
+
+    /* check if already visited */
+    if ( ntk.visited( n ) == ntk.trav_id() )
+      return;
+
+    ntk.set_visited( n, ntk.trav_id() );
+
+    /* set as leaf if signal is complemented or is a CI or has a multiple fanout */
+    if ( !is_root && ( ntk.is_complemented( f ) || ntk.is_ci( n ) || ntk.fanout_size( n ) > 1 ) )
+    {
+      return;
+    }
+
+    ntk.foreach_fanin( n, [&]( auto const& child ) {
+      mark_tfi( child, false );
+    } );
+  }
+
+private:
+  Ntk& ntk;
+  aig_balancing_params const& ps;
+
+  storage_t storage;
+};
+
+} /* namespace detail */
+
+/*! \brief AIG balancing.
+ *
+ * This method balance the AIG to reduce the
+ * depth. Level minimization can be turned off.
+ * In this case, balancing tries to reconstruct
+ * AND trees such that logic sharing is maximized.
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `node_to_index`
+ * - `get_constant`
+ * - `create_pi`
+ * - `create_po`
+ * - `create_not`
+ * - `is_complemented`
+ * - `foreach_node`
+ * - `foreach_pi`
+ * - `foreach_po`
+ * - `clone_node`
+ * - `is_pi`
+ * - `is_constant`
+ * - `has_and`
+ */
+template<class Ntk>
+void aig_balance( Ntk& ntk, aig_balancing_params const& ps = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_clone_node_v<Ntk>, "Ntk does not implement the clone_node method" );
+  static_assert( has_create_pi_v<Ntk>, "Ntk does not implement the create_pi method" );
+  static_assert( has_create_po_v<Ntk>, "Ntk does not implement the create_po method" );
+  static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_has_and_v<Ntk>, "Ntk does not implement the has_and method" );
+
+  fanout_view<Ntk> f_ntk{ ntk };
+  depth_view<fanout_view<Ntk>> d_ntk{ f_ntk };
+
+  detail::aig_balance_impl p( d_ntk, ps );
+  p.run();
+
+  ntk = cleanup_dangling( ntk );
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aig_resub.hpp b/include/mockturtle/algorithms/aig_resub.hpp
new file mode 100644
index 0000000..e59a730
--- /dev/null
+++ b/include/mockturtle/algorithms/aig_resub.hpp
@@ -0,0 +1,986 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aig_resub.hpp
+  \brief Resubstitution
+
+  \author Alessandro Tempia Calvino
+  \author Eleonora Testa
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../networks/aig.hpp"
+#include "../utils/index_list.hpp"
+#include "../utils/truth_table_utils.hpp"
+#include "resubstitution.hpp"
+#include "resyn_engines/xag_resyn.hpp"
+
+namespace mockturtle
+{
+
+struct aig_resub_stats
+{
+  /*! \brief Accumulated runtime for const-resub */
+  stopwatch<>::duration time_resubC{ 0 };
+
+  /*! \brief Accumulated runtime for zero-resub */
+  stopwatch<>::duration time_resub0{ 0 };
+
+  /*! \brief Accumulated runtime for collecting unate divisors. */
+  stopwatch<>::duration time_collect_unate_divisors{ 0 };
+
+  /*! \brief Accumulated runtime for one-resub */
+  stopwatch<>::duration time_resub1{ 0 };
+
+  /*! \brief Accumulated runtime for 12-resub. */
+  stopwatch<>::duration time_resub12{ 0 };
+
+  /*! \brief Accumulated runtime for collecting unate divisors. */
+  stopwatch<>::duration time_collect_binate_divisors{ 0 };
+
+  /*! \brief Accumulated runtime for two-resub. */
+  stopwatch<>::duration time_resub2{ 0 };
+
+  /*! \brief Accumulated runtime for three-resub. */
+  stopwatch<>::duration time_resub3{ 0 };
+
+  /*! \brief Number of accepted constant resubsitutions */
+  uint32_t num_const_accepts{ 0 };
+
+  /*! \brief Number of accepted zero resubsitutions */
+  uint32_t num_div0_accepts{ 0 };
+
+  /*! \brief Number of accepted one resubsitutions */
+  uint64_t num_div1_accepts{ 0 };
+
+  /*! \brief Number of accepted single AND-resubsitutions */
+  uint64_t num_div1_and_accepts{ 0 };
+
+  /*! \brief Number of accepted single OR-resubsitutions */
+  uint64_t num_div1_or_accepts{ 0 };
+
+  /*! \brief Number of accepted two resubsitutions using triples of unate divisors */
+  uint64_t num_div12_accepts{ 0 };
+
+  /*! \brief Number of accepted single 2AND-resubsitutions */
+  uint64_t num_div12_2and_accepts{ 0 };
+
+  /*! \brief Number of accepted single 2OR-resubsitutions */
+  uint64_t num_div12_2or_accepts{ 0 };
+
+  /*! \brief Number of accepted two resubsitutions */
+  uint64_t num_div2_accepts{ 0 };
+
+  /*! \brief Number of accepted double AND-OR-resubsitutions */
+  uint64_t num_div2_and_or_accepts{ 0 };
+
+  /*! \brief Number of accepted double OR-AND-resubsitutions */
+  uint64_t num_div2_or_and_accepts{ 0 };
+
+  /*! \brief Number of accepted three resubsitutions */
+  uint64_t num_div3_accepts{ 0 };
+
+  /*! \brief Number of accepted AND-2OR-resubsitutions */
+  uint64_t num_div3_and_2or_accepts{ 0 };
+
+  /*! \brief Number of accepted OR-2AND-resubsitutions */
+  uint64_t num_div3_or_2and_accepts{ 0 };
+
+  void report() const
+  {
+    std::cout << "[i] kernel: aig_resub_functor\n";
+    std::cout << fmt::format( "[i]     constant-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_const_accepts, to_seconds( time_resubC ) );
+    std::cout << fmt::format( "[i]            0-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_div0_accepts, to_seconds( time_resub0 ) );
+    std::cout << fmt::format( "[i]            collect unate divisors                           ({:>5.2f} secs)\n", to_seconds( time_collect_unate_divisors ) );
+    std::cout << fmt::format( "[i]            1-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_div1_accepts, to_seconds( time_resub1 ) );
+    std::cout << fmt::format( "[i]           12-resub {:6d} = {:6d} 2AND    + {:6d} 2OR     ({:>5.2f} secs)\n",
+                              num_div12_accepts, num_div12_2and_accepts, num_div12_2or_accepts, to_seconds( time_resub12 ) );
+    std::cout << fmt::format( "[i]            collect binate divisors                          ({:>5.2f} secs)\n", to_seconds( time_collect_binate_divisors ) );
+    std::cout << fmt::format( "[i]            2-resub {:6d} = {:6d} AND-OR  + {:6d} OR-AND  ({:>5.2f} secs)\n",
+                              num_div2_accepts, num_div2_and_or_accepts, num_div2_or_and_accepts, to_seconds( time_resub2 ) );
+    std::cout << fmt::format( "[i]            3-resub {:6d} = {:6d} AND-2OR + {:6d} OR-2AND ({:>5.2f} secs)\n",
+                              num_div3_accepts, num_div3_and_2or_accepts, num_div3_or_2and_accepts, to_seconds( time_resub3 ) );
+    std::cout << fmt::format( "[i]            total   {:6d}\n",
+                              ( num_const_accepts + num_div0_accepts + num_div1_accepts + num_div12_accepts + num_div2_accepts + num_div3_accepts ) );
+  }
+}; /* aig_resub_stats */
+
+template<typename Ntk, typename Simulator, typename TT>
+struct aig_resub_functor
+{
+public:
+  using node = aig_network::node;
+  using signal = aig_network::signal;
+  using stats = aig_resub_stats;
+
+  struct unate_divisors
+  {
+    using signal = typename aig_network::signal;
+
+    std::vector<signal> positive_divisors;
+    std::vector<signal> negative_divisors;
+    std::vector<signal> next_candidates;
+
+    void clear()
+    {
+      positive_divisors.clear();
+      negative_divisors.clear();
+      next_candidates.clear();
+    }
+  };
+
+  struct binate_divisors
+  {
+    using signal = typename aig_network::signal;
+
+    std::vector<signal> positive_divisors0;
+    std::vector<signal> positive_divisors1;
+    std::vector<signal> negative_divisors0;
+    std::vector<signal> negative_divisors1;
+
+    void clear()
+    {
+      positive_divisors0.clear();
+      positive_divisors1.clear();
+      negative_divisors0.clear();
+      negative_divisors1.clear();
+    }
+  };
+
+public:
+  explicit aig_resub_functor( Ntk& ntk, Simulator const& sim, std::vector<node> const& divs, uint32_t num_divs, stats& st )
+      : ntk( ntk ), sim( sim ), divs( divs ), num_divs( num_divs ), st( st )
+  {
+  }
+
+  std::optional<signal> operator()( node const& root, TT care, uint32_t max_depth, uint32_t max_inserts, uint32_t num_mffc, uint32_t& last_gain )
+  {
+    (void)care;
+    assert( is_const0( ~care ) );
+
+    /* consider constants */
+    auto g = call_with_stopwatch( st.time_resubC, [&]() {
+      return resub_const( root );
+    } );
+    if ( g )
+    {
+      ++st.num_const_accepts;
+      last_gain = num_mffc;
+      return g; /* accepted resub */
+    }
+
+    /* consider equal nodes */
+    g = call_with_stopwatch( st.time_resub0, [&]() {
+      return resub_div0( root, max_depth );
+    } );
+    if ( g )
+    {
+      ++st.num_div0_accepts;
+      last_gain = num_mffc;
+      return g; /* accepted resub */
+    }
+
+    if ( max_inserts == 0 || num_mffc == 1 )
+      return std::nullopt;
+
+    /* collect level one divisors */
+    call_with_stopwatch( st.time_collect_unate_divisors, [&]() {
+      collect_unate_divisors( root, max_depth );
+    } );
+
+    /* consider equal nodes */
+    g = call_with_stopwatch( st.time_resub1, [&]() {
+      return resub_div1( root, max_depth );
+    } );
+    if ( g )
+    {
+      ++st.num_div1_accepts;
+      last_gain = num_mffc - 1;
+      return g; /* accepted resub */
+    }
+
+    if ( max_inserts == 1 || num_mffc == 2 )
+      return std::nullopt;
+
+    /* consider triples */
+    g = call_with_stopwatch( st.time_resub12, [&]() { return resub_div12( root, max_depth ); } );
+    if ( g )
+    {
+      ++st.num_div12_accepts;
+      last_gain = num_mffc - 2;
+      return g; /* accepted resub */
+    }
+
+    /* collect level two divisors */
+    call_with_stopwatch( st.time_collect_binate_divisors, [&]() {
+      collect_binate_divisors( root, max_depth );
+    } );
+
+    /* consider two nodes */
+    g = call_with_stopwatch( st.time_resub2, [&]() { return resub_div2( root, max_depth ); } );
+    if ( g )
+    {
+      ++st.num_div2_accepts;
+      last_gain = num_mffc - 2;
+      return g; /* accepted resub */
+    }
+
+    if ( max_inserts == 2 || num_mffc == 3 )
+      return std::nullopt;
+
+    /* consider three nodes */
+    g = call_with_stopwatch( st.time_resub3, [&]() { return resub_div3( root, max_depth ); } );
+    if ( g )
+    {
+      ++st.num_div3_accepts;
+      last_gain = num_mffc - 3;
+      return g; /* accepted resub */
+    }
+
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_const( node const& root ) const
+  {
+    auto const tt = sim.get_tt( ntk.make_signal( root ) );
+    if ( tt == sim.get_tt( ntk.get_constant( false ) ) )
+    {
+      return sim.get_phase( root ) ? ntk.get_constant( true ) : ntk.get_constant( false );
+    }
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_div0( node const& root, uint32_t max_depth ) const
+  {
+    (void)max_depth;
+    auto const tt = sim.get_tt( ntk.make_signal( root ) );
+    for ( auto i = 0u; i < num_divs; ++i )
+    {
+      auto const d = divs.at( i );
+      if ( tt != sim.get_tt( ntk.make_signal( d ) ) )
+        continue; /* next */
+
+      assert( ntk.level( d ) <= max_depth );
+      return ( sim.get_phase( d ) ^ sim.get_phase( root ) ) ? !ntk.make_signal( d ) : ntk.make_signal( d );
+    }
+
+    return std::nullopt;
+  }
+
+  void collect_unate_divisors( node const& root, uint32_t max_depth )
+  {
+    udivs.clear();
+
+    auto const& tt = sim.get_tt( ntk.make_signal( root ) );
+    for ( auto i = 0u; i < num_divs; ++i )
+    {
+      auto const d = divs.at( i );
+
+      if ( ntk.level( d ) > max_depth - 1 )
+        continue;
+
+      auto const& tt_d = sim.get_tt( ntk.make_signal( d ) );
+
+      /* check positive containment */
+      if ( kitty::implies( tt_d, tt ) )
+      {
+        udivs.positive_divisors.emplace_back( ntk.make_signal( d ) );
+        continue;
+      }
+
+      /* check negative containment */
+      if ( kitty::implies( tt, tt_d ) )
+      {
+        udivs.negative_divisors.emplace_back( ntk.make_signal( d ) );
+        continue;
+      }
+
+      if ( true ) // ( ps.fix_bug )
+      {
+        /* unreachable case */
+        // if ( kitty::implies( ~tt_d, tt ) )
+        // {
+        //   udivs.positive_divisors.emplace_back( !ntk.make_signal( d ) );
+        //   continue;
+        // }
+        if ( kitty::implies( tt, ~tt_d ) )
+        {
+          udivs.negative_divisors.emplace_back( !ntk.make_signal( d ) );
+          continue;
+        }
+      }
+
+      udivs.next_candidates.emplace_back( ntk.make_signal( d ) );
+    }
+  }
+
+  std::optional<signal> resub_div1( node const& root, uint32_t max_depth )
+  {
+    (void)max_depth;
+    auto const& tt = sim.get_tt( ntk.make_signal( root ) );
+
+    /* check for positive unate divisors */
+    for ( auto i = 0u; i < udivs.positive_divisors.size(); ++i )
+    {
+      auto const& s0 = udivs.positive_divisors.at( i );
+
+      for ( auto j = i + 1; j < udivs.positive_divisors.size(); ++j )
+      {
+        auto const& s1 = udivs.positive_divisors.at( j );
+
+        auto const& tt_s0 = sim.get_tt( s0 );
+        auto const& tt_s1 = sim.get_tt( s1 );
+
+        if ( ( tt_s0 | tt_s1 ) == tt )
+        {
+          ++st.num_div1_or_accepts;
+          auto const l = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+          auto const r = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+          assert( ntk.level( ntk.get_node( l ) ) <= max_depth - 1 && ntk.level( ntk.get_node( r ) ) <= max_depth - 1 );
+          return sim.get_phase( root ) ? !ntk.create_or( l, r ) : ntk.create_or( l, r );
+        }
+      }
+    }
+
+    /* check for negative unate divisors */
+    for ( auto i = 0u; i < udivs.negative_divisors.size(); ++i )
+    {
+      auto const& s0 = udivs.negative_divisors.at( i );
+
+      for ( auto j = i + 1; j < udivs.negative_divisors.size(); ++j )
+      {
+        auto const& s1 = udivs.negative_divisors.at( j );
+
+        auto const& tt_s0 = sim.get_tt( s0 );
+        auto const& tt_s1 = sim.get_tt( s1 );
+
+        if ( ( tt_s0 & tt_s1 ) == tt )
+        {
+          ++st.num_div1_and_accepts;
+          auto const l = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+          auto const r = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+          assert( ntk.level( ntk.get_node( l ) ) <= max_depth - 1 && ntk.level( ntk.get_node( r ) ) <= max_depth - 1 );
+          return sim.get_phase( root ) ? !ntk.create_and( l, r ) : ntk.create_and( l, r );
+        }
+      }
+    }
+
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_div12( node const& root, uint32_t max_depth )
+  {
+    auto const s = ntk.make_signal( root );
+    auto const& tt = sim.get_tt( s );
+
+    /* check positive unate divisors */
+    for ( auto i = 0u; i < udivs.positive_divisors.size(); ++i )
+    {
+      auto const s0 = udivs.positive_divisors.at( i );
+
+      for ( auto j = i + 1; j < udivs.positive_divisors.size(); ++j )
+      {
+        auto const s1 = udivs.positive_divisors.at( j );
+
+        for ( auto k = j + 1; k < udivs.positive_divisors.size(); ++k )
+        {
+          auto const s2 = udivs.positive_divisors.at( k );
+
+          auto const& tt_s0 = sim.get_tt( s0 );
+          auto const& tt_s1 = sim.get_tt( s1 );
+          auto const& tt_s2 = sim.get_tt( s2 );
+
+          if ( ( tt_s0 | tt_s1 | tt_s2 ) == tt )
+          {
+            auto const max_level = std::max( { ntk.level( ntk.get_node( s0 ) ),
+                                               ntk.level( ntk.get_node( s1 ) ),
+                                               ntk.level( ntk.get_node( s2 ) ) } );
+            assert( max_level <= max_depth - 1 );
+
+            signal max = s0;
+            signal min0 = s1;
+            signal min1 = s2;
+            if ( ntk.level( ntk.get_node( s1 ) ) == max_level )
+            {
+              max = s1;
+              min0 = s0;
+              min1 = s2;
+            }
+            else if ( ntk.level( ntk.get_node( s2 ) ) == max_level )
+            {
+              max = s2;
+              min0 = s0;
+              min1 = s1;
+            }
+
+            if ( ntk.level( ntk.get_node( min0 ) ) > max_level - 2 || ntk.level( ntk.get_node( min1 ) ) > max_level - 2 )
+              continue;
+
+            auto const a = sim.get_phase( ntk.get_node( max ) ) ? !max : max;
+            auto const b = sim.get_phase( ntk.get_node( min0 ) ) ? !min0 : min0;
+            auto const c = sim.get_phase( ntk.get_node( min1 ) ) ? !min1 : min1;
+
+            ++st.num_div12_2or_accepts;
+            return sim.get_phase( root ) ? !ntk.create_or( a, ntk.create_or( b, c ) ) : ntk.create_or( a, ntk.create_or( b, c ) );
+          }
+        }
+      }
+    }
+
+    /* check negative unate divisors */
+    for ( auto i = 0u; i < udivs.positive_divisors.size(); ++i )
+    {
+      auto const s0 = udivs.positive_divisors.at( i );
+
+      for ( auto j = i + 1; j < udivs.positive_divisors.size(); ++j )
+      {
+        auto const s1 = udivs.positive_divisors.at( j );
+
+        for ( auto k = j + 1; k < udivs.positive_divisors.size(); ++k )
+        {
+          auto const s2 = udivs.positive_divisors.at( k );
+
+          auto const& tt_s0 = sim.get_tt( s0 );
+          auto const& tt_s1 = sim.get_tt( s1 );
+          auto const& tt_s2 = sim.get_tt( s2 );
+
+          if ( ( tt_s0 & tt_s1 & tt_s2 ) == tt )
+          {
+            auto const max_level = std::max( { ntk.level( ntk.get_node( s0 ) ),
+                                               ntk.level( ntk.get_node( s1 ) ),
+                                               ntk.level( ntk.get_node( s2 ) ) } );
+            assert( max_level <= max_depth - 1 );
+
+            signal max = s0;
+            signal min0 = s1;
+            signal min1 = s2;
+            if ( ntk.level( ntk.get_node( s1 ) ) == max_level )
+            {
+              max = s1;
+              min0 = s0;
+              min1 = s2;
+            }
+            else if ( ntk.level( ntk.get_node( s2 ) ) == max_level )
+            {
+              max = s2;
+              min0 = s0;
+              min1 = s1;
+            }
+
+            if ( ntk.level( ntk.get_node( min0 ) ) > max_level - 2 || ntk.level( ntk.get_node( min1 ) ) > max_level - 2 )
+              continue;
+
+            auto const a = sim.get_phase( ntk.get_node( max ) ) ? !max : max;
+            auto const b = sim.get_phase( ntk.get_node( min0 ) ) ? !min0 : min0;
+            auto const c = sim.get_phase( ntk.get_node( min1 ) ) ? !min1 : min1;
+
+            ++st.num_div12_2and_accepts;
+            return sim.get_phase( root ) ? !ntk.create_and( a, ntk.create_and( b, c ) ) : ntk.create_and( a, ntk.create_and( b, c ) );
+          }
+        }
+      }
+    }
+
+    return std::nullopt;
+  }
+
+  void collect_binate_divisors( node const& root, uint32_t max_depth )
+  {
+    bdivs.clear();
+
+    auto const& tt = sim.get_tt( ntk.make_signal( root ) );
+    for ( auto i = 0u; i < udivs.next_candidates.size(); ++i )
+    {
+      auto const& s0 = udivs.next_candidates.at( i );
+      if ( ntk.level( ntk.get_node( s0 ) ) > max_depth - 2 )
+        continue;
+
+      for ( auto j = i + 1; j < udivs.next_candidates.size(); ++j )
+      {
+        auto const& s1 = udivs.next_candidates.at( j );
+        if ( ntk.level( ntk.get_node( s1 ) ) > max_depth - 2 )
+          continue;
+
+        if ( bdivs.positive_divisors0.size() < 500 ) // ps.max_divisors2
+        {
+          auto const& tt_s0 = sim.get_tt( s0 );
+          auto const& tt_s1 = sim.get_tt( s1 );
+          if ( kitty::implies( tt_s0 & tt_s1, tt ) )
+          {
+            bdivs.positive_divisors0.emplace_back( s0 );
+            bdivs.positive_divisors1.emplace_back( s1 );
+          }
+
+          if ( kitty::implies( ~tt_s0 & tt_s1, tt ) )
+          {
+            bdivs.positive_divisors0.emplace_back( !s0 );
+            bdivs.positive_divisors1.emplace_back( s1 );
+          }
+
+          if ( kitty::implies( tt_s0 & ~tt_s1, tt ) )
+          {
+            bdivs.positive_divisors0.emplace_back( s0 );
+            bdivs.positive_divisors1.emplace_back( !s1 );
+          }
+
+          if ( kitty::implies( ~tt_s0 & ~tt_s1, tt ) )
+          {
+            bdivs.positive_divisors0.emplace_back( !s0 );
+            bdivs.positive_divisors1.emplace_back( !s1 );
+          }
+        }
+
+        if ( bdivs.negative_divisors0.size() < 500 ) // ps.max_divisors2
+        {
+          auto const& tt_s0 = sim.get_tt( s0 );
+          auto const& tt_s1 = sim.get_tt( s1 );
+          if ( kitty::implies( tt, tt_s0 & tt_s1 ) )
+          {
+            bdivs.negative_divisors0.emplace_back( s0 );
+            bdivs.negative_divisors1.emplace_back( s1 );
+          }
+
+          if ( kitty::implies( tt, ~tt_s0 & tt_s1 ) )
+          {
+            bdivs.negative_divisors0.emplace_back( !s0 );
+            bdivs.negative_divisors1.emplace_back( s1 );
+          }
+
+          if ( kitty::implies( tt, tt_s0 & ~tt_s1 ) )
+          {
+            bdivs.negative_divisors0.emplace_back( s0 );
+            bdivs.negative_divisors1.emplace_back( !s1 );
+          }
+
+          if ( kitty::implies( tt, ~tt_s0 & ~tt_s1 ) )
+          {
+            bdivs.negative_divisors0.emplace_back( !s0 );
+            bdivs.negative_divisors1.emplace_back( !s1 );
+          }
+        }
+      }
+    }
+  }
+
+  std::optional<signal> resub_div2( node const& root, uint32_t max_depth )
+  {
+    (void)max_depth;
+    auto const s = ntk.make_signal( root );
+    auto const& tt = sim.get_tt( s );
+
+    /* check positive unate divisors */
+    for ( const auto& s0 : udivs.positive_divisors )
+    {
+      auto const& tt_s0 = sim.get_tt( s0 );
+
+      for ( auto j = 0u; j < bdivs.positive_divisors0.size(); ++j )
+      {
+        auto const s1 = bdivs.positive_divisors0.at( j );
+        auto const s2 = bdivs.positive_divisors1.at( j );
+
+        auto const& tt_s1 = sim.get_tt( s1 );
+        auto const& tt_s2 = sim.get_tt( s2 );
+
+        auto const a = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+        auto const b = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+        auto const c = sim.get_phase( ntk.get_node( s2 ) ) ? !s2 : s2;
+
+        if ( ( tt_s0 | ( tt_s1 & tt_s2 ) ) == tt )
+        {
+          ++st.num_div2_or_and_accepts;
+          assert( ntk.level( ntk.get_node( a ) ) <= max_depth - 1 );
+          assert( ntk.level( ntk.get_node( b ) ) <= max_depth - 2 && ntk.level( ntk.get_node( c ) ) <= max_depth - 2 );
+          return sim.get_phase( root ) ? !ntk.create_or( a, ntk.create_and( b, c ) ) : ntk.create_or( a, ntk.create_and( b, c ) );
+        }
+      }
+    }
+
+    /* check negative unate divisors */
+    for ( const auto& s0 : udivs.negative_divisors )
+    {
+      auto const& tt_s0 = sim.get_tt( s0 );
+
+      for ( auto j = 0u; j < bdivs.negative_divisors0.size(); ++j )
+      {
+        auto const s1 = bdivs.negative_divisors0.at( j );
+        auto const s2 = bdivs.negative_divisors1.at( j );
+
+        auto const& tt_s1 = sim.get_tt( s1 );
+        auto const& tt_s2 = sim.get_tt( s2 );
+
+        auto const a = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+        auto const b = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+        auto const c = sim.get_phase( ntk.get_node( s2 ) ) ? !s2 : s2;
+
+        if ( ( tt_s0 | ( tt_s1 & tt_s2 ) ) == tt )
+        {
+          ++st.num_div2_or_and_accepts;
+          assert( ntk.level( ntk.get_node( a ) ) <= max_depth - 1 );
+          assert( ntk.level( ntk.get_node( b ) ) <= max_depth - 2 && ntk.level( ntk.get_node( c ) ) <= max_depth - 2 );
+          return sim.get_phase( root ) ? !ntk.create_and( a, ntk.create_or( b, c ) ) : ntk.create_and( a, ntk.create_or( b, c ) );
+        }
+      }
+    }
+
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_div3( node const& root, uint32_t max_depth )
+  {
+    (void)max_depth;
+    auto const s = ntk.make_signal( root );
+    auto const& tt = sim.get_tt( s );
+
+    for ( auto i = 0u; i < bdivs.positive_divisors0.size(); ++i )
+    {
+      auto const s0 = bdivs.positive_divisors0.at( i );
+      auto const s1 = bdivs.positive_divisors1.at( i );
+
+      for ( auto j = i + 1; j < bdivs.positive_divisors0.size(); ++j )
+      {
+        auto const s2 = bdivs.positive_divisors0.at( j );
+        auto const s3 = bdivs.positive_divisors1.at( j );
+
+        auto const& tt_s0 = sim.get_tt( s0 );
+        auto const& tt_s1 = sim.get_tt( s1 );
+        auto const& tt_s2 = sim.get_tt( s2 );
+        auto const& tt_s3 = sim.get_tt( s3 );
+
+        if ( ( ( tt_s0 | tt_s1 ) & ( tt_s2 | tt_s3 ) ) == tt )
+        {
+          auto const a = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+          auto const b = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+          auto const c = sim.get_phase( ntk.get_node( s2 ) ) ? !s2 : s2;
+          auto const d = sim.get_phase( ntk.get_node( s3 ) ) ? !s3 : s3;
+
+          ++st.num_div3_and_2or_accepts;
+          assert( ntk.level( ntk.get_node( a ) ) <= max_depth - 2 && ntk.level( ntk.get_node( b ) ) <= max_depth - 2 );
+          assert( ntk.level( ntk.get_node( c ) ) <= max_depth - 2 && ntk.level( ntk.get_node( d ) ) <= max_depth - 2 );
+          return sim.get_phase( root ) ? !ntk.create_and( ntk.create_or( a, b ), ntk.create_or( c, d ) ) : ntk.create_and( ntk.create_or( a, b ), ntk.create_or( c, d ) );
+        }
+      }
+    }
+
+    for ( auto i = 0u; i < bdivs.negative_divisors0.size(); ++i )
+    {
+      auto const s0 = bdivs.negative_divisors0.at( i );
+      auto const s1 = bdivs.negative_divisors1.at( i );
+
+      for ( auto j = i + 1; j < bdivs.negative_divisors0.size(); ++j )
+      {
+        auto const s2 = bdivs.negative_divisors0.at( j );
+        auto const s3 = bdivs.negative_divisors1.at( j );
+
+        auto const& tt_s0 = sim.get_tt( s0 );
+        auto const& tt_s1 = sim.get_tt( s1 );
+        auto const& tt_s2 = sim.get_tt( s2 );
+        auto const& tt_s3 = sim.get_tt( s3 );
+
+        if ( ( ( tt_s0 & tt_s1 ) | ( tt_s2 & tt_s3 ) ) == tt )
+        {
+          auto const a = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+          auto const b = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+          auto const c = sim.get_phase( ntk.get_node( s2 ) ) ? !s2 : s2;
+          auto const d = sim.get_phase( ntk.get_node( s3 ) ) ? !s3 : s3;
+
+          ++st.num_div3_or_2and_accepts;
+          assert( ntk.level( ntk.get_node( a ) ) <= max_depth - 2 && ntk.level( ntk.get_node( b ) ) <= max_depth - 2 );
+          assert( ntk.level( ntk.get_node( c ) ) <= max_depth - 2 && ntk.level( ntk.get_node( d ) ) <= max_depth - 2 );
+          return sim.get_phase( root ) ? !ntk.create_or( ntk.create_and( a, b ), ntk.create_and( c, d ) ) : ntk.create_or( ntk.create_and( a, b ), ntk.create_and( c, d ) );
+        }
+      }
+    }
+
+    return std::nullopt;
+  }
+
+private:
+  Ntk& ntk;
+  Simulator const& sim;
+  std::vector<node> const& divs;
+  uint32_t const num_divs;
+  stats& st;
+
+  unate_divisors udivs;
+  binate_divisors bdivs;
+}; /* aig_resub_functor */
+
+struct aig_resyn_resub_stats
+{
+  /*! \brief Time for finding dependency function. */
+  stopwatch<>::duration time_compute_function{ 0 };
+
+  /*! \brief Number of found solutions. */
+  uint32_t num_success{ 0 };
+
+  /*! \brief Number of times that no solution can be found. */
+  uint32_t num_fail{ 0 };
+
+  void report() const
+  {
+    fmt::print( "[i]     <ResubFn: aig_resyn_functor>\n" );
+    fmt::print( "[i]         #solution = {:6d}\n", num_success );
+    fmt::print( "[i]         #invoke   = {:6d}\n", num_success + num_fail );
+    fmt::print( "[i]         engine time: {:>5.2f} secs\n", to_seconds( time_compute_function ) );
+  }
+}; /* aig_resyn_resub_stats */
+
+/*! \brief Interfacing resubstitution functor with AIG resynthesis engines for `window_based_resub_engine`.
+ */
+template<typename Ntk, typename Simulator, typename TTcare, typename ResynEngine = xag_resyn_decompose<typename Simulator::truthtable_t, aig_resyn_static_params_for_win_resub<Ntk>>>
+struct aig_resyn_functor
+{
+public:
+  using node = aig_network::node;
+  using signal = aig_network::signal;
+  using stats = aig_resyn_resub_stats;
+  using TT = typename ResynEngine::truth_table_t;
+
+  static_assert( std::is_same_v<TT, typename Simulator::truthtable_t>, "truth table type of the simulator does not match" );
+
+public:
+  explicit aig_resyn_functor( Ntk& ntk, Simulator const& sim, std::vector<node> const& divs, uint32_t num_divs, stats& st )
+      : ntk( ntk ), sim( sim ), tts( ntk ), divs( divs ), st( st )
+  {
+    assert( divs.size() == num_divs );
+    (void)num_divs;
+    div_signals.reserve( divs.size() );
+  }
+
+  std::optional<signal> operator()( node const& root, TTcare care, uint32_t required, uint32_t max_inserts, uint32_t potential_gain, uint32_t& real_gain )
+  {
+    (void)required;
+    TT target = sim.get_tt( sim.get_phase( root ) ? !ntk.make_signal( root ) : ntk.make_signal( root ) );
+    TT care_transformed = target.construct();
+    care_transformed = care;
+
+    typename ResynEngine::stats st_eng;
+    ResynEngine engine( st_eng );
+    for ( auto const& d : divs )
+    {
+      div_signals.emplace_back( sim.get_phase( d ) ? !ntk.make_signal( d ) : ntk.make_signal( d ) );
+      tts[d] = sim.get_tt( ntk.make_signal( d ) );
+    }
+
+    auto const res = call_with_stopwatch( st.time_compute_function, [&]() {
+      return engine( target, care_transformed, std::begin( divs ), std::end( divs ), tts, std::min( potential_gain - 1, max_inserts ) );
+    } );
+    if ( res )
+    {
+      ++st.num_success;
+      signal ret;
+      real_gain = potential_gain - ( *res ).num_gates();
+      insert( ntk, div_signals.begin(), div_signals.end(), *res, [&]( signal const& s ) { ret = s; } );
+      return ret;
+    }
+    else
+    {
+      ++st.num_fail;
+      return std::nullopt;
+    }
+  }
+
+private:
+  Ntk& ntk;
+  Simulator const& sim;
+  unordered_node_map<TT, Ntk> tts;
+  std::vector<node> const& divs;
+  std::vector<signal> div_signals;
+  stats& st;
+}; /* aig_resyn_functor */
+
+template<class Ntk>
+void aig_resubstitution( Ntk& ntk, resubstitution_params const& ps = {}, resubstitution_stats* pst = nullptr )
+{
+  /* TODO: check if basetype of ntk is aig */
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the has_size method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the has substitute_node method" );
+  static_assert( has_value_v<Ntk>, "Ntk does not implement the has_value method" );
+  static_assert( has_visited_v<Ntk>, "Ntk does not implement the has_visited method" );
+
+  using resub_view_t = fanout_view<depth_view<Ntk>>;
+  depth_view<Ntk> depth_view{ ntk };
+  resub_view_t resub_view{ depth_view };
+
+  if ( ps.max_pis == 8 )
+  {
+    using truthtable_t = kitty::static_truth_table<8u>;
+    using truthtable_dc_t = kitty::dynamic_truth_table;
+    using resub_impl_t = detail::resubstitution_impl<resub_view_t, typename detail::window_based_resub_engine<resub_view_t, truthtable_t, truthtable_dc_t, aig_resub_functor<resub_view_t, typename detail::window_simulator<resub_view_t, truthtable_t>, truthtable_dc_t>>>;
+
+    resubstitution_stats st;
+    typename resub_impl_t::engine_st_t engine_st;
+    typename resub_impl_t::collector_st_t collector_st;
+
+    resub_impl_t p( resub_view, ps, st, engine_st, collector_st );
+    p.run();
+
+    if ( ps.verbose )
+    {
+      st.report();
+      collector_st.report();
+      engine_st.report();
+    }
+
+    if ( pst )
+    {
+      *pst = st;
+    }
+  }
+  else
+  {
+    using truthtable_t = kitty::dynamic_truth_table;
+    using truthtable_dc_t = kitty::dynamic_truth_table;
+    using resub_impl_t = detail::resubstitution_impl<resub_view_t, typename detail::window_based_resub_engine<resub_view_t, truthtable_t, truthtable_dc_t, aig_resub_functor<resub_view_t, typename detail::window_simulator<resub_view_t, truthtable_t>, truthtable_dc_t>>>;
+
+    resubstitution_stats st;
+    typename resub_impl_t::engine_st_t engine_st;
+    typename resub_impl_t::collector_st_t collector_st;
+
+    resub_impl_t p( resub_view, ps, st, engine_st, collector_st );
+    p.run();
+
+    if ( ps.verbose )
+    {
+      st.report();
+      collector_st.report();
+      engine_st.report();
+    }
+
+    if ( pst )
+    {
+      *pst = st;
+    }
+  }
+}
+
+/*! \brief AIG-specific resubstitution algorithm.
+ *
+ * This algorithms iterates over each node, creates a
+ * reconvergence-driven cut, and attempts to re-express the node's
+ * function using existing nodes from the cut.  Node which are no
+ * longer used (including nodes in their transitive fanins) can then
+ * be removed.  The objective is to reduce the size of the network as
+ * much as possible while maintaining the global input-output
+ * functionality.
+ *
+ * **Required network functions:**
+ *
+ * - `clear_values`
+ * - `fanout_size`
+ * - `foreach_fanin`
+ * - `foreach_fanout`
+ * - `foreach_gate`
+ * - `foreach_node`
+ * - `get_constant`
+ * - `get_node`
+ * - `is_complemented`
+ * - `is_pi`
+ * - `level`
+ * - `make_signal`
+ * - `set_value`
+ * - `set_visited`
+ * - `size`
+ * - `substitute_node`
+ * - `value`
+ * - `visited`
+ *
+ * \param ntk A network type derived from aig_network
+ * \param ps Resubstitution parameters
+ * \param pst Resubstitution statistics
+ */
+template<class Ntk>
+void aig_resubstitution2( Ntk& ntk, resubstitution_params const& ps = {}, resubstitution_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( std::is_same_v<typename Ntk::base_type, aig_network>, "Network type is not aig_network" );
+
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the has_size method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the has substitute_node method" );
+  static_assert( has_value_v<Ntk>, "Ntk does not implement the has_value method" );
+  static_assert( has_visited_v<Ntk>, "Ntk does not implement the has_visited method" );
+  static_assert( has_level_v<Ntk>, "Ntk does not implement the level method" );
+  static_assert( has_foreach_fanout_v<Ntk>, "Ntk does not implement the foreach_fanout method" );
+
+  using truthtable_t = kitty::dynamic_truth_table;
+  using truthtable_dc_t = kitty::dynamic_truth_table;
+  using functor_t = aig_resyn_functor<Ntk, detail::window_simulator<Ntk, truthtable_t>, truthtable_dc_t>;
+
+  using resub_impl_t = detail::resubstitution_impl<Ntk, detail::window_based_resub_engine<Ntk, truthtable_t, truthtable_dc_t, functor_t>>;
+
+  resubstitution_stats st;
+  typename resub_impl_t::engine_st_t engine_st;
+  typename resub_impl_t::collector_st_t collector_st;
+
+  resub_impl_t p( ntk, ps, st, engine_st, collector_st );
+  p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+    collector_st.report();
+    engine_st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/akers_synthesis.hpp b/include/mockturtle/algorithms/akers_synthesis.hpp
new file mode 100644
index 0000000..187d924
--- /dev/null
+++ b/include/mockturtle/algorithms/akers_synthesis.hpp
@@ -0,0 +1,880 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file akers_synthesis.hpp
+  \brief Akers synthesis
+
+  \author Alessandro Tempia Calvino
+  \author Eleonora Testa
+  \author Heinz Riener
+  \author Marcel Walter
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <bitset>
+#include <cassert>
+#include <iterator>
+#include <map>
+#include <set>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include <kitty/bit_operations.hpp>
+#include <kitty/constructors.hpp>
+#include <kitty/cube.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+
+#include "../traits.hpp"
+
+namespace mockturtle
+{
+
+/* cube operators needed from Kitty :
+- & (bitwise and )
+- is_subset_of
+- is_const0
+*/
+
+inline kitty::cube operator&( kitty::cube a, kitty::cube b )
+{
+  assert( a.num_literals() == b.num_literals() );
+  kitty::cube c;
+  for ( auto h = 0; h < a.num_literals(); h++ )
+  {
+    c.add_literal( h, a.get_bit( h ) & b.get_bit( h ) );
+  }
+  return c;
+}
+
+inline bool is_subset_of( kitty::cube a, kitty::cube b )
+{
+  assert( a.num_literals() == b.num_literals() );
+  for ( auto h = 0; h < a.num_literals(); h++ )
+  {
+    if ( ( a.get_bit( h ) == 1 ) && ( b.get_bit( h ) == 1 ) )
+      continue;
+    else if ( ( a.get_bit( h ) == 1 ) && ( b.get_bit( h ) == 0 ) )
+      return false;
+  }
+  return true;
+}
+
+inline bool all_zeros( kitty::cube a )
+{
+  for ( auto g = 0; g < a.num_literals(); g++ )
+  {
+    if ( a.get_bit( g ) == 0 )
+      continue;
+    else
+      return false;
+  }
+  return true;
+}
+
+class unitized_table
+{
+public:
+  using row_t = kitty::cube;
+
+  unitized_table( const std::string& columns )
+      : columns( columns )
+  {
+  }
+
+  row_t create_row() const
+  {
+    row_t r( 0, ( 1 << columns.size() ) - 1 );
+    // for ( auto i = 0u; i < columns.size(); i++ )
+    // r.add_literal( i, 1 );
+    return r;
+  }
+
+  row_t create_mask() const
+  {
+    row_t r( ( 1 << columns.size() ) - 1, ( 1 << columns.size() ) - 1 );
+    // for ( auto i = 0u; i < columns.size(); i++ )
+    // r.add_literal( i, 0 );
+    return r;
+  }
+
+  void add_row( const row_t& row )
+  {
+    rows.push_back( row );
+  }
+
+  void reduce()
+  {
+    auto progress{ true };
+
+    while ( progress )
+    {
+      progress = reduce_columns();
+      progress = progress || reduce_rows();
+    }
+  }
+
+  friend std::ostream& operator<<( std::ostream& os, const unitized_table& table );
+
+  inline std::vector<row_t>::const_iterator begin() const
+  {
+    return rows.begin();
+  }
+
+  inline std::vector<row_t>::const_iterator end() const
+  {
+    return rows.end();
+  }
+
+  inline int operator[]( unsigned index ) const
+  {
+    return (int)(unsigned char)columns[index];
+  }
+
+  inline bool is_opposite( unsigned c1, unsigned c2 ) const
+  {
+    const auto _n1 = columns[c1];
+    const auto _n2 = columns[c2];
+
+    const auto n1 = std::min( _n1, _n2 );
+    const auto n2 = std::max( _n1, _n2 );
+
+    return ( n1 == 0x30 && n2 == 0x31 ) || ( ( n1 + 0x20 ) == n2 );
+  }
+
+  inline auto num_columns() const
+  {
+    return columns.size();
+  }
+
+  int add_gate( const std::set<unsigned>& gate )
+  {
+    assert( gate.size() == 3u );
+
+    auto it = gate.begin();
+    const auto c1 = *it++;
+    const auto c2 = *it++;
+    const auto c3 = *it;
+
+    for ( auto& r : rows )
+    {
+      const auto bi1 = r.get_bit( c1 );
+      const auto bi2 = r.get_bit( c2 );
+      const auto bi3 = r.get_bit( c3 );
+
+      r.add_literal( r.num_literals(), ( bi1 && bi2 ) || ( bi1 && bi3 ) || ( bi2 && bi3 ) );
+    }
+
+    auto ret = (int)next_gate_id;
+    columns.push_back( next_gate_id++ );
+    return ret;
+  }
+
+  unsigned count_essential_ones( bool skip_last_column = true ) const
+  {
+    auto count = 0u;
+    auto end = columns.size();
+    if ( skip_last_column )
+    {
+      --end;
+    }
+
+    for ( auto column = 0u; column < end; ++column )
+    {
+      std::vector<row_t> one_rows;
+
+      /* find rows with a 1 at column */
+      for ( const auto& row : rows )
+      {
+        if ( row.get_bit( column ) )
+        {
+          auto rt = row;
+          rt.clear_bit( column );
+          one_rows.push_back( rt );
+        }
+      }
+
+      /* find essential rows */
+      for ( auto i = 0u; i < one_rows.size(); ++i )
+      {
+        for ( auto j = 0u; j < one_rows.size(); ++j )
+        {
+          if ( i == j )
+          {
+            continue;
+          }
+          if ( all_zeros( one_rows[i] & one_rows[j] ) )
+          {
+            ++count; /* entry i is essential in column */
+            break;
+          }
+        }
+      }
+    }
+
+    return count;
+  }
+
+private:
+  bool reduce_rows()
+  {
+    std::vector<unsigned> to_be_removed;
+
+    for ( auto i = 0u; i < rows.size(); ++i )
+    {
+      for ( auto j = i + 1u; j < rows.size(); ++j )
+      {
+        if ( rows[i] == rows[j] )
+        {
+          to_be_removed.push_back( i );
+        }
+        else
+        {
+          if ( is_subset_of( rows[i], rows[j] ) )
+          {
+            to_be_removed.push_back( j );
+          }
+          if ( is_subset_of( rows[j], rows[i] ) )
+          {
+            to_be_removed.push_back( i );
+          }
+        }
+      }
+    }
+
+    std::stable_sort( to_be_removed.begin(), to_be_removed.end() );
+    to_be_removed.erase( std::unique( to_be_removed.begin(), to_be_removed.end() ), to_be_removed.end() );
+
+    std::reverse( std::begin( to_be_removed ), std::end( to_be_removed ) );
+
+    for ( auto index : to_be_removed )
+    {
+      rows.erase( rows.begin() + index );
+    }
+    return !to_be_removed.empty();
+  }
+
+  bool reduce_columns()
+  {
+    std::vector<unsigned> to_be_removed;
+
+    auto mask = create_mask();
+
+    for ( auto c = 0u; c < columns.size(); ++c )
+    {
+      mask.clear_bit( c );
+      auto can_be_removed = true;
+
+      /* pretend column c is removed */
+      for ( auto i = 0u; i < rows.size(); ++i )
+      {
+        for ( auto j = i + 1u; j < rows.size(); ++j )
+        {
+          const auto result = ( rows[i] & rows[j] ) & mask;
+          if ( all_zeros( result ) )
+          {
+            can_be_removed = false;
+            break;
+          }
+        }
+
+        if ( !can_be_removed )
+        {
+          break;
+        }
+      }
+
+      if ( can_be_removed )
+      {
+        to_be_removed.push_back( c );
+      }
+      else
+      {
+        mask.set_bit( c );
+      }
+    }
+
+    /* remove columns */
+    std::reverse( to_be_removed.begin(), to_be_removed.end() );
+
+    for ( auto index : to_be_removed )
+    {
+      columns.erase( columns.begin() + index );
+
+      for ( auto& row : rows )
+      {
+        erase_bit( row, index );
+      }
+    }
+
+    return !to_be_removed.empty();
+  }
+
+  void erase_bit( row_t& row, unsigned pos ) const
+  {
+    for ( auto i = pos + 1; i < unsigned( row.num_literals() ); ++i )
+    {
+      if ( row.get_bit( i ) == 1 )
+        row.set_bit( i - 1u );
+      else
+        row.clear_bit( i - 1u );
+    }
+    row.remove_literal( row.num_literals() - 1u );
+  }
+
+public:
+  std::string columns;
+
+  std::vector<row_t> rows;
+
+  unsigned char next_gate_id = 'z' + 0x21;
+};
+
+inline std::ostream& operator<<( std::ostream& os, const unitized_table& table )
+{
+  os << table.columns << std::endl;
+
+  for ( const auto& row : table.rows )
+  {
+    std::string buffer;
+    std::bitset<32> to_print;
+    for ( auto i = 0; i < row.num_literals(); i++ )
+      to_print[i] = row.get_bit( i );
+    buffer = to_print.to_string();
+    std::string reversed = buffer;
+    std::reverse( reversed.begin(), reversed.end() );
+    os << reversed << std::endl;
+  }
+
+  return os;
+}
+
+inline bool operator==( unitized_table const& table, unitized_table const& original_table )
+{
+  if ( table.rows.size() != original_table.rows.size() )
+    return false;
+  for ( auto x = 0u; x < table.rows.size(); x++ )
+  {
+    if ( table.rows[x] == original_table.rows[x] )
+      continue;
+    else
+      return false;
+  }
+
+  return true;
+}
+
+namespace detail
+{
+template<typename Ntk, typename LeavesIterator>
+class akers_synthesis_impl
+{
+public:
+  akers_synthesis_impl( Ntk ntk, kitty::dynamic_truth_table const& func, kitty::dynamic_truth_table const& care, LeavesIterator begin, LeavesIterator end )
+      : ntk( ntk ),
+        func( func ),
+        care( care ),
+        begin( begin ),
+        end( end )
+  {
+  }
+
+public:
+  signal<Ntk> run()
+  {
+    auto table = create_unitized_table();
+    return synthesize( table );
+  }
+
+private:
+  unitized_table create_unitized_table()
+  {
+    const unsigned int num_vars = func.num_vars();
+
+    /* create column names */
+    std::string columns;
+
+    for ( auto i = 0u; i < num_vars; ++i )
+    {
+      columns += 'a' + i;
+    }
+    for ( auto i = 0u; i < num_vars; ++i )
+    {
+      columns += 'A' + i;
+    }
+    columns += '0';
+    columns += '1';
+
+    unitized_table table( columns );
+
+    /* add rows */
+    for ( auto pos = 0u; pos < care.num_bits(); pos++ )
+    {
+      auto half = std::bitset<16>( pos );
+      auto row = table.create_row();
+      /* copy the values */
+      for ( auto i = 0u; i < num_vars; ++i )
+      {
+        if ( half[i] == 0 )
+        {
+          row.clear_bit( i );
+          row.set_bit( i + num_vars );
+        }
+        else
+        {
+          row.set_bit( i );
+          row.clear_bit( i + num_vars );
+        }
+      }
+      row.clear_bit( num_vars << 1 );
+      row.set_bit( ( num_vars << 1 ) + 1 );
+
+      if ( !kitty::get_bit( func, pos ) )
+      {
+        for ( auto i = 0; i < row.num_literals(); ++i )
+        {
+          if ( row.get_bit( i ) == 0 )
+          {
+            row.set_bit( i );
+          }
+          else
+          {
+            row.clear_bit( i );
+          }
+        }
+      }
+      table.add_row( row );
+    }
+    table.reduce();
+
+    return table;
+  }
+
+  std::set<std::set<unsigned>> find_gates_for_column( const unitized_table& table, unsigned column ) const
+  {
+    std::vector<unitized_table::row_t> one_rows;
+    std::vector<bool> matrix;
+    /* find rows with a 1 at column */
+
+    for ( const auto& row : table )
+    {
+      if ( row.get_bit( column ) )
+      {
+        auto rt = row;
+        rt.clear_bit( column );
+        one_rows.push_back( rt );
+      }
+    }
+
+    /* find essential rows */
+    for ( auto i = 0u; i < one_rows.size(); ++i )
+    {
+      for ( auto j = 0u; j < one_rows.size(); ++j )
+      {
+        if ( i == j )
+        {
+          continue;
+        }
+        if ( all_zeros( one_rows[i] & one_rows[j] ) )
+        {
+          for ( auto k = 0; k < one_rows[i].num_literals(); ++k )
+            matrix.push_back( one_rows[i].get_bit( k ) );
+          break;
+        }
+      }
+    }
+    return clauses_to_products_enumerative( table, column, matrix );
+  }
+
+  std::set<unsigned> find_gate_for_table( unitized_table& table )
+  {
+
+    std::map<std::set<unsigned>, unsigned> gates;
+    std::vector<std::set<unsigned>> random_gates;
+    auto g_count = 0u;
+
+    for ( auto c = 0u; c < table.num_columns(); ++c )
+    {
+      for ( const auto& g : find_gates_for_column( table, c ) )
+      {
+        assert( g.size() == 3u );
+        gates[g]++;
+        g_count++;
+      }
+    }
+
+    if ( gates.empty() )
+    {
+      reduce++;
+      return find_gate_for_table_brute_force( table );
+    }
+    if ( gates.size() == previous_size )
+    {
+      reduce++;
+      return find_gate_for_table_brute_force( table );
+    }
+
+    assert( !gates.empty() );
+    reduce = 0;
+    previous_size = gates.size();
+    using pair_t = decltype( gates )::value_type;
+
+    for ( auto f = 0u; f < g_count; f++ )
+    {
+      auto pr = std::max_element( std::begin( gates ), std::end( gates ), []( const pair_t& p1, const pair_t& p2 ) { return p1.second < p2.second; } );
+      random_gates.push_back( pr->first );
+      gates.erase( pr->first );
+      if ( gates.size() == 0 )
+        break;
+    }
+
+    auto this_table = table;
+    for ( auto f = 0u; f < random_gates.size(); f++ )
+    {
+      table.add_gate( random_gates[f] );
+      table.reduce();
+      if ( ( table.rows.size() != this_table.rows.size() ) || ( table.columns.size() != this_table.columns.size() - 1 ) )
+      {
+        table = this_table;
+        return random_gates[f];
+      }
+      table = this_table;
+    }
+
+    reduce++;
+    return random_gates[0u];
+  }
+
+  std::set<unsigned> find_gate_for_table_brute_force( const unitized_table& table ) const
+  {
+    auto best_count_iter = std::numeric_limits<unsigned>::max();
+    std::set<unsigned> best_gate_iter;
+
+    std::vector<unsigned> numbers( table.num_columns() );
+    std::iota( numbers.begin(), numbers.end(), 0u );
+
+    for ( auto i = 0u; i < table.num_columns(); i++ )
+    {
+      for ( auto j = i + 1u; j < table.num_columns(); j++ )
+      {
+        for ( auto k = j + 1u; k < table.num_columns(); k++ )
+        {
+          std::set<unsigned> gate;
+          gate.insert( numbers[i] );
+          gate.insert( numbers[j] );
+          gate.insert( numbers[k] );
+
+          auto table_copy = table;
+          table_copy.add_gate( gate );
+
+          const auto new_count = table_copy.count_essential_ones();
+          if ( new_count < best_count_iter )
+          {
+            best_count_iter = new_count;
+            best_gate_iter = gate;
+          }
+        }
+      }
+    }
+    return best_gate_iter;
+  }
+
+  signal<Ntk> synthesize( unitized_table& table )
+  {
+
+    std::unordered_map<int, signal<Ntk>> c_to_f;
+
+    c_to_f[0x30] = ntk.get_constant( false );
+    c_to_f[0x31] = ntk.get_constant( true );
+
+    for ( auto i = 0u; i < func.num_vars(); ++i )
+    {
+      auto pi = *begin++; // should take the leaves values
+      c_to_f[0x41 + i] = !pi;
+      c_to_f[0x61 + i] = pi;
+    }
+
+    auto last_gate_id = 0;
+
+    while ( table.num_columns() )
+    {
+      auto gate = find_gate_for_table( table );
+
+      auto it = gate.begin();
+      const auto f1 = *it++;
+      const auto f2 = *it++;
+      const auto f3 = *it;
+
+      last_gate_id = table.add_gate( gate );
+
+      c_to_f[last_gate_id] = ntk.create_maj( c_to_f[table[f1]], c_to_f[table[f2]], c_to_f[table[f3]] );
+
+      if ( reduce == 0 )
+        table.reduce();
+    }
+
+    if ( ntk.node_to_index( ntk.get_node( c_to_f[last_gate_id] ) ) == 0 )
+      return ntk.get_constant( 0 ^ ntk.is_complemented( c_to_f[last_gate_id] ) );
+
+    return c_to_f[last_gate_id];
+  }
+
+  std::vector<std::vector<int>> create_gates( const unitized_table& table )
+  {
+    const auto num_vars = func.num_vars();
+    std::vector<int> count( table.columns.size(), 0 );
+    auto best_count = 0;
+
+    std::vector<std::vector<int>> gates;
+
+    for ( auto c = 0u; c < table.columns.size(); ++c )
+    {
+      for ( const auto& row : table )
+      {
+        best_count++;
+        if ( row.get_bit( c ) == 0 )
+        {
+          count[c]++;
+        }
+      }
+    }
+
+    auto best_column = 0u;
+
+    for ( auto c = 0u; c < count.size(); ++c )
+    {
+      if ( count[c] < best_count )
+      {
+        best_column = c;
+        best_count = count[c];
+      }
+    }
+
+    auto icx = 0;
+    auto name = table.columns[best_column];
+    if ( islower( name ) )
+      icx = name - 'a';
+    else if ( isupper( name ) )
+      icx = name - 'A' + num_vars;
+    else if ( name == '0' )
+      icx = num_vars * 2;
+    else
+      icx = num_vars * 2 + 1;
+
+    std::vector<int> best_c;
+
+    best_c.push_back( icx );
+    gates.push_back( best_c );
+
+    for ( const auto& row : table )
+    {
+
+      if ( row.get_bit( best_column ) == 0 )
+      {
+        std::vector<int> gate1;
+        for ( auto c = 0u; c < table.num_columns(); ++c )
+        {
+          if ( c == best_column )
+            continue;
+          if ( row.get_bit( c ) == 1 )
+          {
+            unsigned icx;
+            auto name = table.columns[c];
+            if ( islower( name ) )
+              icx = name - 'a';
+            else if ( isupper( name ) )
+              icx = name - 'A' + num_vars;
+            else if ( name == '0' )
+              icx = num_vars * 2;
+            else
+              icx = num_vars * 2 + 1;
+            gate1.push_back( icx );
+          }
+        }
+        gates.push_back( gate1 );
+      }
+    }
+    std::vector<int> g;
+    g.push_back( num_vars );
+
+    gates.push_back( g );
+    return gates;
+  }
+
+  std::set<std::set<unsigned>> clauses_to_products_enumerative( const unitized_table& table, unsigned column,
+                                                                const std::vector<bool>& matrix ) const
+  {
+    std::set<std::set<unsigned>> products;
+
+    const auto num_columns = table.num_columns();
+    const auto num_rows = matrix.size() / num_columns;
+
+    for ( auto i = 0u; i < num_columns; ++i )
+    {
+      if ( table.is_opposite( column, i ) )
+      {
+        continue;
+      }
+      if ( column == i )
+        continue;
+      for ( auto j = i + 1u; j < num_columns; ++j )
+      {
+        if ( table.is_opposite( i, j ) || table.is_opposite( column, j ) )
+        {
+          continue;
+        }
+        if ( column == j )
+          continue;
+        auto found = true;
+        std::size_t offset = 0u;
+        for ( auto r = 0u; r < num_rows; ++r, offset += num_columns )
+        {
+          if ( !matrix[offset + i] && !matrix[offset + j] )
+          {
+            found = false;
+            break;
+          }
+        }
+
+        if ( found )
+        {
+          std::set<unsigned> product;
+          product.insert( i );
+          product.insert( j );
+          product.insert( column );
+          assert( product.size() == 3 );
+          products.insert( product );
+        }
+      }
+    }
+
+    return products;
+  }
+
+private:
+  Ntk ntk;
+  kitty::dynamic_truth_table const& func;
+  kitty::dynamic_truth_table const& care;
+  LeavesIterator begin;
+  LeavesIterator end;
+
+  unsigned reduce{ 0 };
+  std::size_t previous_size{ 0 };
+};
+
+} // namespace detail
+
+/*! \brief Performs Akers majority-3 synthesis inside network.
+ *
+ * Note that the number of variables in `func` and `care` must be the same.
+ * Also the distance between `begin` and `end` must equal the number of
+ * variables in `func`.
+ *
+ * **Required network functions:**
+ * - `create_maj`
+ *
+ * \param ntk Network
+ * \param func Function as truth table
+ * \param care Care set of the function (as truth table)
+ * \param begin Begin iterator to child signals
+ * \param end End iterator to child signals
+ * \return Signal that realizes function in terms of child signals
+ */
+template<typename Ntk, typename LeavesIterator>
+signal<Ntk> akers_synthesis( Ntk& ntk, kitty::dynamic_truth_table const& func, kitty::dynamic_truth_table const& care, LeavesIterator begin, LeavesIterator end )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_maj_v<Ntk>, "Ntk does not implement the create_maj method" );
+
+  assert( func.num_vars() == care.num_vars() );
+  assert( std::distance( begin, end ) == func.num_vars() );
+
+  auto pi = begin;
+
+  if ( is_const0( func ) )
+    return ntk.get_constant( 0 );
+  auto tt_1 = unary_not( func );
+  if ( is_const0( tt_1 ) )
+    return ntk.get_constant( 1 );
+
+  for ( auto i = 0u; i < func.num_vars(); i++ )
+  {
+    create_nth_var( tt_1, i );
+    auto it = *pi++;
+    if ( tt_1 == func )
+    {
+      return it;
+    }
+    tt_1 = unary_not( tt_1 );
+    if ( tt_1 == func )
+    {
+      return !it;
+    }
+  }
+
+  detail::akers_synthesis_impl<Ntk, LeavesIterator> tt( ntk, func, care, begin, end );
+  return tt.run();
+}
+
+/*! \brief Performs Akers majority-3 synthesis to create network.
+ *
+ * Note that the number of variables in `func` and `care` must be the same.
+ * The function will create a network with as many primary inputs as number of
+ * variables in `func` and a single output.
+ *
+ * **Required network functions:**
+ * - `create_pi`
+ * - `create_po`
+ * - `create_maj`
+ *
+ * \param func Function as truth table
+ * \param care Care set of the function (as truth table)
+ * \return A network that realizes the function
+ */
+template<typename Ntk>
+Ntk akers_synthesis( kitty::dynamic_truth_table const& func, kitty::dynamic_truth_table const& care )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_pi_v<Ntk>, "Ntk does not implement the create_pi method" );
+  static_assert( has_create_po_v<Ntk>, "Ntk does not implement the create_po method" );
+
+  Ntk ntk;
+  std::vector<signal<Ntk>> pis;
+
+  for ( auto i = 0u; i < func.num_vars(); ++i )
+  {
+    pis.push_back( ntk.create_pi() );
+  }
+
+  const auto f = akers_synthesis( ntk, func, care, pis.begin(), pis.end() );
+  ntk.create_po( f );
+  return ntk;
+}
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/aqfp_assumptions.hpp b/include/mockturtle/algorithms/aqfp/aqfp_assumptions.hpp
new file mode 100644
index 0000000..b8f22e3
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/aqfp_assumptions.hpp
@@ -0,0 +1,138 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aqfp_assumptions.hpp
+  \brief Technology assumptions for AQFP
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+namespace mockturtle
+{
+
+/*! \brief More realistic AQFP technology assumptions. */
+struct aqfp_assumptions_realistic
+{
+  /*! \brief Whether CIs and COs need to be path-balanced. */
+  bool balance_cios{ false };
+
+  /*! \brief Ignores the complementations of COs because they can be merged into register inputs. */
+  bool ignore_co_negation{ true };
+
+  /*! \brief Number of phases per clock cycle (for phase alignment).
+   *
+   * Each CO (a node with external reference) must be scheduled at a level being a multiple of
+   * `num_phases` (i.e., an imaginary CO node should be placed at a level `num_phases * k + 1`).
+   */
+  uint32_t num_phases{ 4u };
+
+  /*! \brief The maximum number of fanouts a splitter/buffer can have. */
+  uint32_t splitter_capacity{ 3u };
+
+  /*! \brief The maximum number of fanouts a mega splitter can have. */
+  //uint32_t mega_splitter_capacity{ 7u };
+
+  /*! \brief The maximum number of fanouts a CI can have. */
+  uint32_t ci_capacity{ 1u }; // simplicity
+  //uint32_t ci_capacity{ 2u }; // best possible
+
+  /*! \brief The phase offsets (after a change in register input) when new register output is available.
+   *
+   * Assumes that the register inputs (D and E) are scheduled at phase 0 (i.e., the last phase of
+   * the previous clock cycle), a new state is available to be taken at these numbers of phases
+   * afterwards.
+   *
+   * An ascending order is assumed. At least one element should be given.
+   *
+   * Each CI must be scheduled at a level `num_phases * k + ci_phases[i]` (for any `i`; for any
+   * integer `k >= 0` when `balance_cios = false`, or `k=0` otherwise).
+   */
+  std::vector<uint32_t> ci_phases{ { 4u } }; // simplicity
+  //std::vector<uint32_t> ci_phases{ { 3u, 4u, 5u } }; // best possible
+
+  /*! \brief Maximum phase-skip (in consideration of clock skew). */
+  uint32_t max_phase_skip{ 4u };
+};
+
+/*! \brief AQFP technology assumptions.
+ *
+ * POs count toward the fanout sizes and always have to be branched.
+ * If PIs need to be balanced, then they must also need to be branched.
+ */
+struct aqfp_assumptions_legacy
+{
+  /*! \brief Whether PIs need to be branched with splitters. */
+  bool branch_pis{ true };
+
+  /*! \brief Whether PIs need to be path-balanced. */
+  bool balance_pis{ false };
+
+  /*! \brief Whether POs need to be path-balanced. */
+  bool balance_pos{ false };
+
+  /*! \brief The maximum number of fanouts each splitter (buffer) can have. */
+  uint32_t splitter_capacity{ 3u };
+};
+
+using aqfp_assumptions = aqfp_assumptions_legacy;
+
+/* Temporary helper function to bridge old and new code. */
+inline aqfp_assumptions_realistic legacy_to_realistic( aqfp_assumptions_legacy const& legacy )
+{
+  aqfp_assumptions_realistic realistic;
+
+  if ( !legacy.branch_pis )
+  {
+    realistic.ci_capacity = std::numeric_limits<uint32_t>::max();
+  }
+  else
+  {
+    realistic.ci_capacity = 1u;
+  }
+
+  if ( legacy.balance_pis && legacy.balance_pos )
+  {
+    realistic.balance_cios = true;
+  }
+  else if ( !legacy.balance_pis && !legacy.balance_pos )
+  {
+    realistic.balance_cios = false;
+  }
+  else
+  {
+    std::cerr << "[e] Cannot convert this combinaiton of assumptions.\n";
+  }
+
+  realistic.splitter_capacity = legacy.splitter_capacity;
+  realistic.num_phases = 1u; // no phase alignment
+  realistic.ci_phases = {0u}; // PIs at level 0
+  realistic.max_phase_skip = std::numeric_limits<uint32_t>::max(); // no clock skew issue
+  return realistic;
+}
+
+} // namespace mockturtle
diff --git a/include/mockturtle/algorithms/aqfp/aqfp_cleanup.hpp b/include/mockturtle/algorithms/aqfp/aqfp_cleanup.hpp
new file mode 100644
index 0000000..c269b3f
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/aqfp_cleanup.hpp
@@ -0,0 +1,160 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aqfp_cleanup.hpp
+  \brief Buffered network cleanup and types conversion
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <vector>
+
+#include "../../networks/buffered.hpp"
+#include "../../utils/node_map.hpp"
+#include "../../views/topo_view.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Buffered cleanup dangling.
+ *
+ * This function implements `cleanup_dangling` for buffered networks.
+ *
+ * \param ntk buffered network type
+ */
+template<class Ntk>
+Ntk cleanup_dangling_buffered( Ntk const& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( is_buffered_network_type_v<Ntk>, "Ntk is not a buffered network type" );
+  static_assert( has_is_buf_v<Ntk>, "Ntk does not implement the is_buf method" );
+  static_assert( has_create_buf_v<Ntk>, "Ntk does not implement the create_buf method" );
+
+  using signal = typename Ntk::signal;
+
+  Ntk res;
+  node_map<signal, Ntk> old2new( ntk );
+
+  old2new[ntk.get_constant( false )] = res.get_constant( false );
+  if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+  {
+    old2new[ntk.get_constant( true )] = res.get_constant( true );
+  }
+
+  ntk.foreach_pi( [&]( auto const& n ) {
+    old2new[n] = res.create_pi();
+  } );
+
+  topo_view topo{ ntk };
+  topo.foreach_node( [&]( auto const& n ) {
+    if ( ntk.is_pi( n ) || ntk.is_constant( n ) )
+      return;
+
+    std::vector<signal> children;
+
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      children.push_back( old2new[f] ^ ntk.is_complemented( f ) );
+    } );
+
+    signal f;
+    if ( ntk.is_buf( n ) )
+    {
+      f = res.create_buf( children[0] );
+    }
+    else
+    {
+      f = res.clone_node( ntk, n, children );
+    }
+
+    old2new[n] = f;
+  } );
+
+  ntk.foreach_po( [&]( auto const& f ) {
+    if ( ntk.is_complemented( f ) )
+      res.create_po( res.create_not( old2new[f] ) );
+    else
+      res.create_po( old2new[f] );
+  } );
+
+  return res;
+}
+
+/*! \brief Converts a `buffered_mig_network` to a `buffered_aqfp_network`.
+ *
+ * This function converts a `buffered_mig_network` to a `buffered_aqfp_network`.
+ *
+ * \param ntk `buffered_mig_network`
+ */
+buffered_aqfp_network convert_buffered_mig_to_aqfp( buffered_mig_network const& ntk )
+{
+  using signal = typename buffered_aqfp_network::signal;
+
+  buffered_aqfp_network res;
+  node_map<signal, buffered_mig_network> old2new( ntk );
+
+  old2new[ntk.get_constant( false )] = res.get_constant( false );
+
+  ntk.foreach_pi( [&]( auto const& n ) {
+    old2new[n] = res.create_pi();
+  } );
+
+  topo_view topo{ ntk };
+  topo.foreach_node( [&]( auto const& n ) {
+    if ( ntk.is_pi( n ) || ntk.is_constant( n ) )
+      return;
+
+    std::vector<signal> children;
+
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      children.push_back( old2new[f] ^ ntk.is_complemented( f ) );
+    } );
+
+    signal f;
+    if ( ntk.is_buf( n ) )
+    {
+      f = res.create_buf( children[0] );
+    }
+    else
+    {
+      f = res.create_maj( children[0], children[1], children[2] );
+    }
+
+    old2new[n] = f;
+  } );
+
+  ntk.foreach_po( [&]( auto const& f ) {
+    if ( ntk.is_complemented( f ) )
+      res.create_po( res.create_not( old2new[f] ) );
+    else
+      res.create_po( old2new[f] );
+  } );
+
+  return res;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/aqfp_db.hpp b/include/mockturtle/algorithms/aqfp/aqfp_db.hpp
new file mode 100644
index 0000000..301800e
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/aqfp_db.hpp
@@ -0,0 +1,450 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aqfp_db.hpp
+  \brief AQFP DAG database
+
+  \author Dewmini Sudara Marakkalage
+*/
+
+#pragma once
+
+#include <map>
+#include <unordered_map>
+#include <vector>
+
+#include <kitty/kitty.hpp>
+
+#include "detail/dag.hpp"
+#include "detail/dag_cost.hpp"
+#include "detail/npn_cache.hpp"
+
+namespace mockturtle
+{
+
+template<typename T>
+T bitwise_majority( const T& a, const T& b, const T& c )
+{
+  return ( a & b ) | ( c & ( a | b ) );
+}
+
+template<typename T>
+T bitwise_majority( const T& a, const T& b, const T& c, const T& d, const T& e )
+{
+  return ( a & b & c ) | ( a & b & d ) | ( a & b & e ) | ( a & c & d ) | ( a & c & e ) |
+         ( a & d & e ) | ( b & c & d ) | ( b & c & e ) | ( b & d & e ) | ( c & d & e );
+}
+
+/*! \brief Returns the level of input with index `input_idx` from level configuration `lvl_cfg`. */
+inline uint32_t level_of_input( uint64_t lvl_cfg, uint32_t input_idx )
+{
+  return ( lvl_cfg >> ( 8u * input_idx ) ) & 0xff;
+}
+
+/*! \brief Returns the vector representation of the level configuration `lvl_cfg`. */
+inline std::vector<uint32_t> lvl_cfg_to_vec( uint64_t lvl_cfg, uint32_t num_leaves )
+{
+  std::vector<uint32_t> res( num_leaves );
+  for ( auto i = 0u; i < num_leaves; i++ )
+  {
+    res[i] = level_of_input( lvl_cfg, i );
+  }
+  return res;
+}
+
+/*! \brief  Returns the level configuration for levels represented by `levels`. */
+inline uint64_t lvl_cfg_from_vec( std::vector<uint32_t> levels )
+{
+  uint64_t res = 0u;
+  for ( auto i = 0u; i < levels.size(); i++ )
+  {
+    res |= ( levels[i] << ( 8u * i ) );
+  }
+  return res;
+}
+
+/*! \brief A class to represent an AQFP exact synthesis database. */
+template<typename Ntk = aqfp_dag<>>
+class aqfp_db
+{
+
+public:
+  struct replacement
+  {
+    double cost;
+    Ntk ntk;
+    std::vector<uint32_t> input_levels; // input levels
+    std::vector<uint32_t> input_perm;   // input permutation so that ntk compute the npn-class
+  };
+
+  aqfp_db(
+      const std::unordered_map<uint32_t, double>& gate_costs = { { 3u, 6.0 }, { 5u, 10.0 } },
+      const std::unordered_map<uint32_t, double>& splitters = { { 1u, 2.0 }, { 4u, 2.0 } } )
+      : gate_costs( gate_costs ), splitters( splitters ), db( get_default_db() ), cc( gate_costs, splitters )
+  {
+  }
+
+  aqfp_db( const std::unordered_map<uint64_t, std::map<uint64_t, replacement>>& db,
+           const std::unordered_map<uint32_t, double>& gate_costs = { { 3u, 6.0 }, { 5u, 10.0 } },
+           const std::unordered_map<uint32_t, double>& splitters = { { 1u, 2.0 }, { 4u, 2.0 } } )
+      : gate_costs( gate_costs ), splitters( splitters ), db( db ), cc( gate_costs, splitters )
+  {
+  }
+
+  using gate_info = std::vector<uint32_t>;                                               // fanin list with lsb denoting the inversion
+  using mig_structure = std::tuple<std::vector<gate_info>, std::vector<uint32_t>, bool>; // (gates, levels, output inverted flag);
+
+  template<typename ComparisonFn>
+  mig_structure get_best_replacement( uint64_t f, std::vector<uint32_t> _levels, std::vector<bool> _is_const, ComparisonFn&& comparison_fn )
+  {
+    /* find the npn class for the function */
+    auto tmp = npndb( f );
+    auto& npntt = std::get<0>( tmp );
+    auto& npnperm = std::get<2>( tmp );
+
+    if ( db[npntt].empty() )
+    {
+      assert( false );
+      return { {}, {}, false };
+    }
+
+    /* map input levels */
+    std::vector<uint32_t> levels( _levels.size() );
+    std::vector<bool> is_const( _levels.size() );
+    for ( auto i = 0u; i < levels.size(); i++ )
+    {
+      levels[i] = _levels[npnperm[i]];
+      is_const[i] = _is_const[npnperm[i]];
+    }
+
+    double best_cost = std::numeric_limits<double>::infinity();
+    uint32_t best_lev = std::numeric_limits<uint32_t>::max();
+    replacement best = db[npntt].begin()->second;
+    uint32_t best_ind = 0;
+
+    uint32_t temp_ind = 0;
+    for ( auto it = db[npntt].begin(); it != db[npntt].end(); it++ )
+    {
+      const auto& lvl_cfg = it->first;
+      const auto& r = it->second;
+
+      uint32_t max_lev = 0u;
+      for ( auto i = 0u; i < levels.size(); i++ )
+      {
+        auto temp = levels[i] + level_of_input( lvl_cfg, i );
+        max_lev = std::max( max_lev, temp );
+      }
+      uint32_t buffer_count = 0u;
+      for ( auto i = 0u; i < levels.size(); i++ )
+      {
+        if ( !is_const[i] )
+        {
+          auto temp = levels[i] + level_of_input( lvl_cfg, i );
+          buffer_count += ( max_lev - temp );
+        }
+      }
+
+      double cost = buffer_count * splitters.at( 1u ) + r.cost;
+
+      if ( comparison_fn( { cost, max_lev }, { best_cost, best_lev } ) )
+      {
+        best_cost = cost;
+        best_lev = max_lev;
+        best = r;
+        best_ind = temp_ind;
+      }
+      temp_ind++;
+    }
+
+    usage_stats[{ npntt, best_ind }]++;
+    return compute_replacement_structure( best, f );
+  }
+
+  /*! \brief Load database from input stream `is`. */
+  void load_db( std::istream& is, uint32_t version = 1u )
+  {
+    load_db( is, db, version );
+  }
+
+  /*! \brief Load database from input stream `is`. */
+  template<typename T>
+  static void load_db( std::istream& is, T& db, uint32_t version = 1u )
+  {
+    std::string line;
+
+    std::getline( is, line );
+    uint32_t num_func = std::stoul( line );
+
+    for ( auto func = 0u; func < num_func; func++ )
+    {
+      uint32_t N = 4;
+      if ( version > 1u )
+      {
+        std::getline( is, line );
+        N = std::stoul( line );
+      }
+
+      std::getline( is, line );
+      uint64_t npn = std::stoul( line, 0, 16 );
+
+      std::getline( is, line );
+      uint32_t num_entries = std::stoul( line );
+
+      for ( auto j = 0u; j < num_entries; j++ )
+      {
+        std::getline( is, line );
+        uint64_t lvl_cfg = std::stoul( line, 0, 16 );
+        auto levels = lvl_cfg_to_vec( lvl_cfg, N );
+
+        std::getline( is, line );
+        double cost = std::stod( line );
+
+        std::getline( is, line );
+        Ntk ntk( line );
+
+        std::vector<uint32_t> perm( N );
+        for ( int i = 0; i < N; i++ )
+        {
+          uint32_t t;
+          is >> t;
+          perm[i] = t;
+        }
+        std::getline( is, line ); // ignore the current line end
+
+        lvl_cfg = lvl_cfg_from_vec( levels );
+
+        if ( !db[npn].count( lvl_cfg ) || db[npn][lvl_cfg].cost > cost )
+        {
+          db[npn][lvl_cfg] = { cost, ntk, levels, perm };
+        }
+      }
+    }
+  }
+
+  void print_usage_state( std::ostream& os )
+  {
+    os << "printing stats\n";
+    for ( auto& x : usage_stats )
+    {
+      os << fmt::format( "{}, {}, {}\n", x.first.first, x.first.second, x.second );
+    }
+    os << "printing stats done\n";
+  }
+
+  template<typename Fn>
+  void for_each_db_entry( Fn&& func )
+  {
+    for ( const auto& [npn_class, entries_for_npn_class] : db )
+    {
+      for ( const auto& [depth_config, replacement] : entries_for_npn_class )
+      {
+        func( npn_class, compute_replacement_structure( replacement, npn_class ), replacement.cost );
+      }
+    }
+  }
+
+private:
+  std::unordered_map<uint32_t, double> gate_costs;
+  std::unordered_map<uint32_t, double> splitters;
+  std::unordered_map<uint64_t, std::map<uint64_t, replacement>> db;
+  std::map<std::pair<uint64_t, uint32_t>, uint32_t> usage_stats;
+  dag_aqfp_cost_and_depths<Ntk> cc;
+  npn_cache npndb;
+
+  std::pair<bool, std::vector<uint32_t>> inverter_config_for_func( const std::vector<uint64_t>& input_tt, const Ntk& net, uint64_t func )
+  {
+    uint32_t num_inputs = net.input_slots.size();
+    if ( net.zero_input != 0 )
+    {
+      num_inputs--;
+    }
+
+    std::vector<uint64_t> tt( net.nodes.size(), input_tt[0] );
+    auto input_ind = 1u;
+
+    auto tmp_input_slots = net.input_slots;
+    std::stable_sort( tmp_input_slots.begin(), tmp_input_slots.end() );
+    assert( tmp_input_slots == net.input_slots );
+
+    for ( auto i : net.input_slots )
+    {
+      if ( i != (int)net.zero_input )
+      {
+        tt[i] = input_tt[input_ind++];
+      }
+    }
+
+    auto shift = 0u;
+    for ( auto i = 0u; i < net.num_gates(); i++ )
+    {
+      shift += ( net.nodes[i].size() - 1 );
+    }
+
+    const auto n_gates = net.num_gates();
+    std::vector<uint32_t> res( n_gates );
+
+    for ( auto inv_config_itr = 0ul; inv_config_itr < ( 1ul << shift ); inv_config_itr++ )
+    {
+      auto inv_config = inv_config_itr;
+
+      for ( auto i = n_gates; i > 0; i-- )
+      {
+        const auto& n = net.nodes[i - 1];
+
+        const auto n_fanin = n.size();
+        const auto shift = n_fanin - 1;
+        const auto mask = ( 1 << shift ) - 1;
+        const auto ith_gate_config = ( inv_config & mask );
+
+        res[i - 1] = ith_gate_config;
+
+        // only consider half the inverter configurations, the other half is covered by output inversion
+        if ( n_fanin == 3u )
+        {
+          tt[i - 1] = bitwise_majority(
+              ( ith_gate_config & 1 ) ? ~tt[n[0]] : tt[n[0]],
+              ( ith_gate_config & 2 ) ? ~tt[n[1]] : tt[n[1]],
+              tt[n[2]] );
+        }
+        else
+        {
+          tt[i - 1] = bitwise_majority(
+              ( ith_gate_config & 1 ) ? ~tt[n[0]] : tt[n[0]],
+              ( ith_gate_config & 2 ) ? ~tt[n[1]] : tt[n[1]],
+              ( ith_gate_config & 4 ) ? ~tt[n[2]] : tt[n[2]],
+              ( ith_gate_config & 8 ) ? ~tt[n[3]] : tt[n[3]],
+              tt[n[4]] );
+        }
+        inv_config >>= shift;
+      }
+
+      if ( ( func & 0xffff ) == ( tt[0] & 0xffff ) )
+      {
+        return { false, res };
+      }
+      if ( ( ~func & 0xffff ) == ( tt[0] & 0xffff ) )
+      {
+        return { true, res };
+      }
+    }
+
+    assert( false );
+    return {};
+  }
+
+  mig_structure compute_replacement_structure( const replacement& rep, uint64_t func )
+  {
+    std::vector<uint32_t> levs( 4u );
+    for ( auto i = 0u; i < 4u; i++ )
+    {
+      levs[i] = rep.input_levels[rep.input_perm[i]];
+    }
+
+    auto [new_cost, gate_levels] = cc( rep.ntk, levs );
+    (void)new_cost;
+
+    auto [npntt, npn_inv, npnperm] = npndb( func );
+
+    std::vector<uint32_t> ind = { 0u, 1u, 2u, 3u };
+
+    std::vector<uint32_t> ind_func_from_npn = {
+        ind[npnperm[0]],
+        ind[npnperm[1]],
+        ind[npnperm[2]],
+        ind[npnperm[3]] };
+
+    std::vector<uint32_t> ind_func_from_dag = {
+        ind_func_from_npn[rep.input_perm[0]],
+        ind_func_from_npn[rep.input_perm[1]],
+        ind_func_from_npn[rep.input_perm[2]],
+        ind_func_from_npn[rep.input_perm[3]] };
+
+    auto input_perm = ind_func_from_dag;
+
+    std::vector<uint64_t> input_tt = {
+        0xaaaaUL,
+        0xccccUL,
+        0xf0f0UL,
+        0xff00UL };
+
+    std::vector<uint64_t> input_perm_tt = {
+        0x0000UL,
+        input_tt[input_perm[0]],
+        input_tt[input_perm[1]],
+        input_tt[input_perm[2]],
+        input_tt[input_perm[3]] };
+
+    auto [output_inv, inverter_config] = inverter_config_for_func( input_perm_tt, rep.ntk, func );
+
+    std::vector<gate_info> gates{ {}, {}, {}, {}, {} };
+    std::vector<uint32_t> depths{ 0u, 0u, 0u, 0u, 0u };
+
+    std::map<uint32_t, uint32_t> sigmap;
+
+    std::vector<uint32_t> inputs;
+    auto i = 0u;
+    for ( auto x : rep.ntk.input_slots )
+    {
+      if ( x == rep.ntk.zero_input )
+      {
+        sigmap[x] = 0u;
+      }
+      else
+      {
+        sigmap[x] = input_perm[i++] + 1;
+      }
+      depths[sigmap[x]] = gate_levels[x];
+    }
+
+    for ( auto i = rep.ntk.num_gates(); i > 0; i-- )
+    {
+      auto j = i - 1;
+      sigmap[j] = rep.ntk.num_gates() + 4u - j;
+
+      gates.push_back( {} );
+      assert( gates.size() == sigmap[j] + 1 );
+      depths.push_back( gate_levels[j] );
+
+      auto type = inverter_config[j];
+      auto& node = rep.ntk.nodes[j];
+      for ( auto k = 0u; k < node.size(); k++ )
+      {
+        auto new_fanin_id = sigmap[node[k]];
+        auto new_fanin_inv = ( type & ( 1u << k ) ) > 0;
+        gates[sigmap[j]].push_back( ( new_fanin_id << 1 ) | ( new_fanin_inv ? 1u : 0u ) );
+      }
+    }
+
+    return { gates, depths, output_inv };
+  }
+
+  static std::unordered_map<uint64_t, std::map<uint64_t, replacement>> get_default_db()
+  {
+    return {};
+  }
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/aqfp_fanout_resyn.hpp b/include/mockturtle/algorithms/aqfp/aqfp_fanout_resyn.hpp
new file mode 100644
index 0000000..d9b41d2
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/aqfp_fanout_resyn.hpp
@@ -0,0 +1,172 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aqfp_fanout_resyn.hpp
+  \brief AQFP fanout resynthesis strategy
+
+  \author Dewmini Sudara Marakkalage
+*/
+
+#pragma once
+
+#include <type_traits>
+#include <vector>
+
+#include "../../traits.hpp"
+#include "aqfp_assumptions.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief A callback to determine the fanout levels.
+ *
+ * This is intended to be used with AQFP networks. Levels are determined assuming that
+ * a nearly-balanced splitter tree is used for each the considered fanout net.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+     aqfp_assumptions assume = { false, false, true, 4u };
+     aqfp_fanout_resyn fanout_resyn{ assume };
+
+     std::unordered_map<uint32_t, double> gate_costs = { { 3u, 6.0 }, { 5u, 10.0 } };
+     std::unordered_map<uint32_t, double> splitters = { { 1u, 2.0 }, { assume.splitter_capacity, 2.0 } };
+     aqfp_node_resyn_param ps{ assume, splitters, aqfp_node_resyn_strategy::delay };
+
+     aqfp_db<> db( gate_costs, splitters );
+     db.load_db( ... ); // from an input-stream (e.g., std::ifstream or std::stringstream)
+
+     aqfp_node_resyn node_resyn( db, ps );
+
+     klut_network src_ntk = ...;
+     aqfp_network dst_ntk;
+     auto res = aqfp_resynthesis( dst_ntk, src_ntk, node_resyn, fanout_resyn );
+
+   \endverbatim
+ */
+struct aqfp_fanout_resyn
+{
+  /*! \brief Default constructor.
+   *
+   * \param assume AQFP synthesis assumptions (only the fields `splitter_capacity` and `branch_pis` will be used)
+   */
+  aqfp_fanout_resyn( const aqfp_assumptions& assume )
+      : splitter_capacity{ assume.splitter_capacity }, branch_pis{ assume.branch_pis } {}
+
+  /*! \brief Determine the relative levels of fanouts of a node assuming a nearly balanced splitter tree.
+   *
+   * \param ntk_src Source network with `depth()` and `level()` member functions.
+   * \param n Node in `ntk_src` for which the fanout levels are to be determined.
+   * \param fanouts_n Fanout nodes of `n` in `ntk_dest`.
+   * \param ntk_dest Destination network which is being synthesized as an AQFP network.
+   * \param f The signal in `ntk_dest` that correspond to source node `n`.
+   * \param level_f The level of `f` in `ntk_dest`.
+   * \param fanout_node_fn Callback with arguments (source network node, level in destination network).
+   * \param fanout_co_fn Callback with arguments (index of the combinational output, level in destination network).
+   */
+  template<typename NtkSrc, typename FOutsSrc, typename NtkDest, typename FanoutNodeCallback, typename FanoutPoCallback>
+  void operator()( const NtkSrc& ntk_src, node<NtkSrc> n, FOutsSrc& fanouts_n, const NtkDest& ntk_dest, signal<NtkDest> f, uint32_t level_f,
+                   FanoutNodeCallback&& fanout_node_fn, FanoutPoCallback&& fanout_co_fn )
+  {
+    static_assert( has_depth_v<NtkSrc>,
+                   "The source network does not provide a method named depth()." );
+    static_assert( has_level_v<NtkSrc>,
+                   "The source network does not provide a method named level(node)." );
+    static_assert( std::is_invocable_v<FanoutNodeCallback, node<NtkSrc>, uint32_t>,
+                   "FanoutNodeCallback is not callable with arguments (node, level)" );
+    static_assert( std::is_invocable_v<FanoutPoCallback, uint32_t, uint32_t>,
+                   "FanoutNodeCallback is not callable with arguments (index, level)" );
+
+    if ( ntk_src.fanout_size( n ) == 0 )
+      return;
+
+    auto offsets = balanced_splitter_tree_offsets( ntk_src.fanout_size( n ) );
+
+    std::stable_sort( fanouts_n.begin(), fanouts_n.end(), [&]( auto f1, auto f2 ) { return ( ntk_src.depth() - ntk_src.level( f1 ) ) > ( ntk_src.depth() - ntk_src.level( f2 ) ) ||
+                                                                                    ( ( ntk_src.depth() - ntk_src.level( f1 ) ) == ( ntk_src.depth() - ntk_src.level( f2 ) ) && ( f1 < f2 ) ); } );
+
+    auto n_dest = ntk_dest.get_node( f );
+    auto no_splitters = ntk_dest.is_constant( n_dest ) || ( !branch_pis && ntk_dest.is_ci( n_dest ) );
+
+    uint32_t foind = 0u;
+    for ( auto fo : fanouts_n )
+    {
+      fanout_node_fn( fo, no_splitters ? level_f : level_f + offsets[foind] );
+      foind++;
+    }
+
+    // remaining fanouts are either combinational outputs (primary outputs or register inputs)
+    for ( auto i = foind; i < ntk_src.fanout_size( n ); i++ )
+    {
+      auto co_index = i - foind;
+      fanout_co_fn( co_index, no_splitters ? level_f : level_f + offsets[foind] );
+      foind++;
+    }
+  }
+
+private:
+  uint32_t splitter_capacity;
+  bool branch_pis;
+
+  /*! \brief Determines the relative levels of the fanouts of a balanced splitter tree with `num_fanouts` many fanouts. */
+  std::vector<uint32_t> balanced_splitter_tree_offsets( uint32_t num_fanouts )
+  {
+    if ( num_fanouts == 1u )
+    {
+      return { 0u };
+    }
+
+    // to get the minimum level, choose the splitters with max fanout size
+
+    uint32_t num_splitters = 1u;
+    uint32_t num_levels = 1u;
+    uint32_t num_leaves = splitter_capacity;
+
+    while ( num_leaves < num_fanouts )
+    {
+      num_splitters += num_leaves;
+      num_leaves *= splitter_capacity;
+      num_levels += 1u;
+    }
+
+    // we need at least `num_levels` levels, but we might not need all
+    std::vector<uint32_t> result( num_fanouts, num_levels );
+    uint32_t i = 0u;
+    while ( num_leaves >= num_fanouts + ( splitter_capacity - 1 ) )
+    {
+      num_splitters--;
+      num_leaves -= ( splitter_capacity - 1 );
+      result[i++]--;
+    }
+
+    return result;
+  };
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/aqfp_legalization.hpp b/include/mockturtle/algorithms/aqfp/aqfp_legalization.hpp
new file mode 100644
index 0000000..9de5920
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/aqfp_legalization.hpp
@@ -0,0 +1,331 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aqfp_legalization.hpp
+  \brief Legalization + buffer optimization flow for AQFP networks
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <random>
+#include <vector>
+
+#include "../../networks/aqfp.hpp"
+#include "../../networks/buffered.hpp"
+#include "../../networks/mig.hpp"
+#include "../../utils/stopwatch.hpp"
+#include "../../views/depth_view.hpp"
+#include "../cleanup.hpp"
+#include "aqfp_assumptions.hpp"
+#include "aqfp_rebuild.hpp"
+#include "aqfp_retiming.hpp"
+#include "buffer_insertion.hpp"
+
+namespace mockturtle
+{
+
+struct aqfp_legalization_params
+{
+  aqfp_legalization_params()
+  {
+    aqfp_assumptions_ps.branch_pis = true;
+    aqfp_assumptions_ps.balance_pis = true;
+    aqfp_assumptions_ps.balance_pos = true;
+  }
+
+  /*! \brief legalization mode. */
+  enum
+  {
+    better,
+    portfolio
+  } legalization_mode = portfolio;
+
+  /*! \brief AQFP technology assumptions. */
+  aqfp_assumptions_legacy aqfp_assumptions_ps{};
+
+  /*! \brief Max number of optimization rounds (zero performs only insertion)*/
+  uint32_t optimization_rounds{ 10 };
+
+  /*! \brief Maximum chunk size for chunk optimization. */
+  uint32_t max_chunk_size{ 100 };
+
+  /*! \brief Maximum number of iterations for optimization using retiming. */
+  uint32_t retime_iterations{ 250 };
+
+  /*! \brief Enable optimization of splitters using retiming. */
+  bool retime_splitters{ true };
+
+  /*! \brief Enables the randomization of topological order. */
+  bool topological_randomization{ true };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+};
+
+struct aqfp_legalization_stats
+{
+  /*! \brief Number of Josephson Junctions (JJs). */
+  uint32_t num_jjs{ 0 };
+
+  /*! \brief Number of buffers and splitters. */
+  uint32_t num_bufs{ 0 };
+
+  /*! \brief Depth of the circuit. */
+  uint32_t depth{ 0 };
+
+  /*! \brief Total number of optimization rounds. */
+  uint32_t rounds_total{ 0 };
+
+  /*! \brief Time insertion. */
+  stopwatch<>::duration time_insertion{ 0 };
+
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  void report() const
+  {
+    std::cout << fmt::format( "[i] JJs    = {:7d}\t B/S     = {:7d}\t Depth = {:5d}\n", num_jjs, num_bufs, depth );
+    std::cout << fmt::format( "[i] Rounds = {:7d}\t Time Insertion = {:>5.2f} secs\t Total Runtime = {:>5.2f} secs\n", rounds_total, to_seconds( time_insertion ), to_seconds( time_total ) );
+  }
+};
+
+namespace detail
+{
+
+template<class Ntk>
+class aqfp_legalization_impl
+{
+public:
+  explicit aqfp_legalization_impl( Ntk const& ntk, aqfp_legalization_params const& ps, aqfp_legalization_stats& st )
+      : _ntk( ntk ), _ps( ps ), _st( st )
+  {
+  }
+
+public:
+  buffered_aqfp_network run()
+  {
+    stopwatch t( _st.time_total );
+    _st.rounds_total = 0;
+
+    /* convert the initial circuit as an AQFP network */
+    aqfp_network aqfp_start = cleanup_dangling<Ntk, aqfp_network>( _ntk );
+    /* creates buffer_insertion instance for scheduling (can be reused) */
+    buffer_insertion_params insertion_ps;
+    insertion_ps.optimization_effort = buffer_insertion_params::none;
+    insertion_ps.assume = legacy_to_realistic( _ps.aqfp_assumptions_ps );
+    buffer_insertion buf_inst( aqfp_start, insertion_ps );
+
+    bool retiming_backward_first = false;
+
+    /* Starndard flow: insertion + optimization */
+    if ( _ps.legalization_mode == aqfp_legalization_params::better )
+    {
+      buffered_aqfp_network buffered_aqfp = aqfp_buffer_insertion( buf_inst, retiming_backward_first );
+      buffered_aqfp_network aqfp_res = aqfp_buffer_optimize( buffered_aqfp, retiming_backward_first );
+      compute_stats( aqfp_res );
+      return aqfp_res;
+    }
+
+    /* Portfolio flow: 2 insertions + 2 optimizations */
+    buffered_aqfp_network buffered_aqfp_alap = aqfp_buffer_insertion( buf_inst, retiming_backward_first, true );
+    buffered_aqfp_network aqfp_res_alap = aqfp_buffer_optimize( buffered_aqfp_alap, retiming_backward_first );
+
+    buffered_aqfp_network buffered_aqfp_asap = aqfp_buffer_insertion( buf_inst, retiming_backward_first, false );
+    buffered_aqfp_network aqfp_res_asap = aqfp_buffer_optimize( buffered_aqfp_asap, retiming_backward_first );
+
+    buffered_aqfp_network aqfp_res;
+    if ( aqfp_res_alap.size() < aqfp_res_asap.size() )
+    {
+      aqfp_res = aqfp_res_alap;
+    }
+    else
+    {
+      aqfp_res = aqfp_res_asap;
+    }
+
+    compute_stats( aqfp_res );
+    return aqfp_res;
+  }
+
+private:
+  buffered_aqfp_network aqfp_buffer_insertion( buffer_insertion<aqfp_network>& buf_inst, bool& direction, bool is_alap = false )
+  {
+    stopwatch t( _st.time_insertion );
+
+    if ( _ps.legalization_mode == aqfp_legalization_params::portfolio )
+    {
+      if ( is_alap )
+      {
+        buf_inst.set_scheduling_policy( buffer_insertion_params::ALAP_depth );
+      }
+      else
+      {
+        buf_inst.set_scheduling_policy( buffer_insertion_params::ASAP_depth );
+      }
+    }
+    else if ( _ps.legalization_mode == aqfp_legalization_params::better )
+    {
+      buf_inst.set_scheduling_policy( buffer_insertion_params::better_depth );
+    }
+
+    buffered_aqfp_network buffered_aqfp;
+    buf_inst.run( buffered_aqfp );
+    direction = buf_inst.is_scheduled_ASAP();
+
+    return buffered_aqfp;
+  }
+
+  buffered_aqfp_network aqfp_buffer_optimize( buffered_aqfp_network& start, bool direction )
+  {
+    if ( _ps.optimization_rounds == 0 )
+      return start;
+
+    /* retiming params */
+    aqfp_retiming_params aps;
+    aps.aqfp_assumptions_ps = _ps.aqfp_assumptions_ps;
+    aps.backwards_first = direction;
+    aps.iterations = _ps.retime_iterations;
+    aps.retime_splitters = _ps.retime_splitters;
+
+    /* chunk movement params */
+    buffer_insertion_params buf_ps;
+    buf_ps.scheduling = buffer_insertion_params::provided;
+    buf_ps.optimization_effort = buffer_insertion_params::until_sat;
+    buf_ps.max_chunk_size = _ps.max_chunk_size;
+    buf_ps.assume = legacy_to_realistic( _ps.aqfp_assumptions_ps );
+
+    aqfp_reconstruct_params reconstruct_ps;
+    aqfp_reconstruct_stats reconstruct_st;
+    reconstruct_ps.buffer_insertion_ps = buf_ps;
+
+    /* aqfp network */
+    buffered_aqfp_network buffered_aqfp;
+
+    /* first retiming */
+    {
+      auto buf_aqfp_ret = aqfp_retiming( start, aps );
+      buffered_aqfp = buf_aqfp_ret;
+    }
+
+    /* repeat loop */
+    uint32_t iterations = _ps.optimization_rounds;
+    aps.det_randomization = _ps.topological_randomization;
+    std::default_random_engine rng( 111 );
+    while ( iterations-- > 0 )
+    {
+      uint32_t size_previous = buffered_aqfp.size();
+
+      /* chunk movement */
+      auto buf_aqfp_chunk = aqfp_reconstruct( buffered_aqfp, reconstruct_ps, &reconstruct_st );
+
+      /* retiming */
+      aps.seed = rng();
+      auto buf_aqfp_ret = aqfp_retiming( buf_aqfp_chunk, aps );
+
+      _st.rounds_total++;
+
+      if ( buf_aqfp_ret.size() >= size_previous )
+        break;
+
+      buffered_aqfp = buf_aqfp_ret;
+    }
+
+    return buffered_aqfp;
+  }
+
+  void compute_stats( buffered_aqfp_network const& buffered_aqfp )
+  {
+    _st.depth = depth_view<buffered_aqfp_network>( buffered_aqfp ).depth();
+    _st.num_bufs = 0;
+    _st.num_jjs = 0;
+
+    buffered_aqfp.foreach_node( [&]( auto const& n ) {
+      if ( buffered_aqfp.is_pi( n ) || buffered_aqfp.is_constant( n ) )
+        return;
+      if ( buffered_aqfp.is_buf( n ) )
+      {
+        _st.num_jjs += 2;
+        _st.num_bufs++;
+      }
+      else
+      {
+        _st.num_jjs += 6;
+      }
+    } );
+  }
+
+private:
+  Ntk const& _ntk;
+  aqfp_legalization_params const& _ps;
+  aqfp_legalization_stats& _st;
+};
+
+} /* namespace detail */
+
+/*! \brief AQFP legalization.
+ *
+ * This function returns an optimized AQFP circuit
+ * derived from the input one by inserting buffer
+ * and splitter elements and optimizing their number.
+ *
+ * Parameters can be used to set the B/S insertion and
+ * optimization.
+ *
+ * \param ntk Boolean network as an MIG or AQFP network
+ * \param ps AQFP legalization parameters
+ */
+template<class Ntk>
+buffered_aqfp_network aqfp_legalization( Ntk const& ntk, aqfp_legalization_params const& ps = {}, aqfp_legalization_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( std::is_same_v<typename Ntk::base_type, mig_network> || std::is_same_v<typename Ntk::base_type, aqfp_network>, "Ntk in not an MIG or AQFP network type" );
+
+  aqfp_legalization_stats st;
+
+  detail::aqfp_legalization_impl p( ntk, ps, st );
+  auto res = p.run();
+
+  if ( ps.verbose )
+    st.report();
+
+  if ( pst )
+    *pst = st;
+
+  return res;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/aqfp_node_resyn.hpp b/include/mockturtle/algorithms/aqfp/aqfp_node_resyn.hpp
new file mode 100644
index 0000000..4cfe6f3
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/aqfp_node_resyn.hpp
@@ -0,0 +1,253 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aqfp_node_resyn.hpp
+  \brief AQFP node resynthesis strategy
+
+  \author Dewmini Sudara Marakkalage
+*/
+
+#pragma once
+
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+
+#include "../../traits.hpp"
+#include "aqfp_assumptions.hpp"
+#include "aqfp_db.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Strategy for resynthesizing a node. */
+enum class aqfp_node_resyn_strategy
+{
+  area, /*!< choose the database entry that gives the minimum area and break ties uing the delay */
+  delay /*!< choose the database entry that gives the minimum delay and break ties uing the cost */
+};
+
+/*! \brief AQFP node re-synthesis parameters. */
+struct aqfp_node_resyn_param
+{
+  aqfp_assumptions assume = { false, false, true, 4u };
+  std::unordered_map<uint32_t, double> splitters = { { 1u, 2.0 }, { 4u, 2.0 } };
+  aqfp_node_resyn_strategy strategy = aqfp_node_resyn_strategy::area;
+};
+
+/*! \brief A callback to re-synthesize a node in an AQFP network.
+ *
+ * A suitable AQFP sub-graph structure for a given node will be chosen from
+ * a database of AQFP structures.
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+     aqfp_assumptions assume = { false, false, true, 4u };
+     aqfp_fanout_resyn fanout_resyn{ assume };
+
+     std::unordered_map<uint32_t, double> gate_costs = { { 3u, 6.0 }, { 5u, 10.0 } };
+     std::unordered_map<uint32_t, double> splitters = { { 1u, 2.0 }, { assume.splitter_capacity, 2.0 } };
+     aqfp_node_resyn_param ps{ assume, splitters, aqfp_node_resyn_strategy::delay };
+
+     aqfp_db<> db( gate_costs, splitters );
+     db.load_db( ... ); // from an input-stream (e.g., std::ifstream or std::stringstream)
+
+     aqfp_node_resyn node_resyn( db, ps );
+
+     klut_network src_ntk = ...;
+     aqfp_network dst_ntk;
+     auto res = aqfp_resynthesis( dst_ntk, src_ntk, node_resyn, fanout_resyn );
+
+   \endverbatim
+ */
+struct aqfp_node_resyn
+{
+
+  /*! \brief Default constructor.
+   *
+   * \param db AQFP database.
+   * \param ps AQFP note re-synthesis parameters.
+   */
+  aqfp_node_resyn( aqfp_db<>& db, const aqfp_node_resyn_param& ps ) : params( ps ), db( db )
+  {
+    /*! must provide the cost of a simple buffer with one output */
+    assert( ps.splitters.count( 1u ) > 0 );
+    /*! must provide the cost of a splitter with the maximum capacity */
+    assert( ps.splitters.count( ps.assume.splitter_capacity ) > 0 );
+  }
+
+  /*! Re-synthesize a given node as a sub-graph in an AQFP network.
+   *
+   * \param ntk_dest AQFP network that is being synthesized.
+   * \param f Function computed by the source node that is being re-synthesized.
+   * \param leaves_begin Iterator (begin) for the leaves of the source node.
+   * \param leaves_end Iterator (end) for the leaves of the source node.
+   * \param level_update_callback Callback with parameters (new node, level of the new node).
+   * \param resyn_performed_callback Callback with the signal that correspond to the source node and its level.
+   */
+  template<typename NtkDest, typename TruthTable, typename LeavesIterator, typename LevelUpdateCallback, typename ResynPerformedCallback>
+  void operator()( NtkDest& ntk_dest, const TruthTable& f, LeavesIterator leaves_begin, LeavesIterator leaves_end,
+                   LevelUpdateCallback&& level_update_callback, ResynPerformedCallback&& resyn_performed_callback )
+  {
+    static_assert( std::is_invocable_v<LevelUpdateCallback, node<NtkDest>, uint32_t>,
+                   "LevelUpdateCallback must be callable with arguments of types (node<NtkDest>, level)" );
+    static_assert( std::is_invocable_v<ResynPerformedCallback, signal<NtkDest>, uint32_t>,
+                   "ResynPerformedCallback must be callable with arguments of type (signal<NtkDest>, level)" );
+
+    std::vector<signal<NtkDest>> leaves;
+    std::vector<uint32_t> leaf_levels;
+    std::vector<bool> leaf_no_splitters;
+    for ( auto it = leaves_begin; it != leaves_end; it++ )
+    {
+      auto leaf = std::get<0>( *it );
+      auto leaf_level = std::get<1>( *it );
+
+      leaves.push_back( leaf );
+      leaf_levels.push_back( leaf_level );
+      leaf_no_splitters.push_back( ntk_dest.is_constant( ntk_dest.get_node( leaf ) ) || ( ntk_dest.is_ci( ntk_dest.get_node( leaf ) ) && !params.assume.branch_pis ) );
+    }
+
+    // should not have more than 4 fanin nodes
+    assert( leaves.size() <= 4u );
+
+    // if less than 4 fanins, add dummy inputs
+    while ( leaves.size() < 4u )
+    {
+      leaves.push_back( ntk_dest.get_constant( false ) );
+      leaf_levels.push_back( 0u );
+      leaf_no_splitters.push_back( true );
+    }
+
+    auto tt = kitty::extend_to( f, 4u );
+
+    auto new_n = ntk_dest.get_constant( false );
+    auto n_lev = 0u;
+    switch ( tt._bits[0] )
+    {
+    case 0x0000u:
+      new_n = ntk_dest.get_constant( false );
+      break;
+    case 0xffffu:
+      new_n = ntk_dest.get_constant( true );
+      break;
+    case 0x5555u:
+      new_n = !leaves[0];
+      n_lev = leaf_levels[0];
+      break;
+    case 0xaaaau:
+      new_n = leaves[0];
+      n_lev = leaf_levels[0];
+      break;
+    case 0x3333u:
+      new_n = !leaves[1];
+      n_lev = leaf_levels[1];
+      break;
+    case 0xccccu:
+      new_n = leaves[1];
+      n_lev = leaf_levels[1];
+      break;
+    case 0x0f0fu:
+      new_n = !leaves[2];
+      n_lev = leaf_levels[2];
+      break;
+    case 0xf0f0u:
+      new_n = leaves[2];
+      n_lev = leaf_levels[2];
+      break;
+    case 0x00ffu:
+      new_n = !leaves[3];
+      n_lev = leaf_levels[3];
+      break;
+    case 0xff00u:
+      new_n = leaves[3];
+      n_lev = leaf_levels[3];
+      break;
+    default:
+      auto [mig, depths, output_inv] = db.get_best_replacement(
+          tt._bits[0], leaf_levels, leaf_no_splitters,
+          [&]( const std::pair<double, uint32_t>& f, const std::pair<double, uint32_t>& s ) {
+            if ( params.strategy == aqfp_node_resyn_strategy::area )
+            {
+              return ( f.first < s.first || ( f.first == s.first && f.second < s.second ) );
+            }
+            else
+            {
+              assert( params.strategy == aqfp_node_resyn_strategy::delay );
+              return ( f.second < s.second || ( f.second == s.second && f.first < s.first ) );
+            }
+          } );
+
+      std::vector<signal<NtkDest>> sig_map( mig.size() );
+      std::vector<uint32_t> lev_map( mig.size() );
+
+      sig_map[0] = ntk_dest.get_constant( false );
+      lev_map[0] = 0u;
+      for ( auto i = 1u; i <= 4u; i++ )
+      {
+        sig_map[i] = leaves[i - 1];
+        lev_map[i] = leaf_levels[i - 1];
+      }
+      for ( auto i = 5u; i < mig.size(); i++ )
+      {
+        std::vector<signal<NtkDest>> fanin;
+        for ( auto fin : mig[i] )
+        {
+          const auto fin_inv = ( ( fin & 1u ) == 1u );
+          const auto fin_id = ( fin >> 1 );
+          fanin.push_back( fin_inv ? !sig_map[fin_id] : sig_map[fin_id] );
+        }
+        sig_map[i] = ntk_dest.create_maj( fanin );
+        lev_map[i] = 0u;
+
+        const auto node_i = ntk_dest.get_node( sig_map[i] );
+        if ( !( ntk_dest.is_constant( node_i ) || ntk_dest.is_ci( node_i ) ) )
+        {
+          for ( auto fin : mig[i] )
+          {
+            const auto fin_id = ( fin >> 1u );
+            const auto lev_dif = ( depths[fin_id] > depths[i] ) ? depths[fin_id] - depths[i] : 1u;
+            lev_map[i] = std::max( lev_map[i], lev_map[fin_id] + lev_dif );
+          }
+        }
+
+        level_update_callback( ntk_dest.get_node( sig_map[i] ), lev_map[i] );
+      }
+      n_lev = lev_map[mig.size() - 1];
+      new_n = output_inv ? !sig_map[mig.size() - 1] : sig_map[mig.size() - 1];
+    }
+
+    resyn_performed_callback( new_n, n_lev );
+  }
+
+private:
+  aqfp_node_resyn_param params;
+  aqfp_db<>& db;
+};
+
+} // namespace mockturtle
diff --git a/include/mockturtle/algorithms/aqfp/aqfp_rebuild.hpp b/include/mockturtle/algorithms/aqfp/aqfp_rebuild.hpp
new file mode 100644
index 0000000..880d7c2
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/aqfp_rebuild.hpp
@@ -0,0 +1,280 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aqfp_rebuild.hpp
+  \brief Rebuilds buffer-splitter tree in AQFP networks
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <list>
+#include <random>
+#include <vector>
+
+#include "../../networks/buffered.hpp"
+#include "../../networks/generic.hpp"
+#include "../../utils/node_map.hpp"
+#include "../../utils/stopwatch.hpp"
+#include "../../views/depth_view.hpp"
+#include "aqfp_assumptions.hpp"
+#include "aqfp_cleanup.hpp"
+#include "buffer_insertion.hpp"
+#include "buffer_verification.hpp"
+
+namespace mockturtle
+{
+
+struct aqfp_reconstruct_params
+{
+  /*! \brief AQFP buffer insertion parameters. */
+  buffer_insertion_params buffer_insertion_ps{};
+
+  /*! \brief Randomize topological order. */
+  bool det_randomization{ false };
+
+  /*! \brief Seed for random selection of splitters to relocate. */
+  std::default_random_engine::result_type seed{ 1 };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+};
+
+struct aqfp_reconstruct_stats
+{
+  /*! \brief Number of buffers and splitters after reconstruction. */
+  uint32_t num_buffers{ 0 };
+
+  /*! \brief Total runtime */
+  stopwatch<>::duration total_time{ 0 };
+
+  /*! \brief Report stats */
+  void report()
+  {
+    std::cout << fmt::format( "[i] Buffers = {}\t Total time = {}\n", num_buffers, to_seconds( total_time ) );
+  }
+};
+
+namespace detail
+{
+
+class aqfp_reconstruct_impl
+{
+public:
+  using node = typename aqfp_network::node;
+  using signal = typename aqfp_network::signal;
+
+public:
+  explicit aqfp_reconstruct_impl( buffered_aqfp_network const& ntk, aqfp_reconstruct_params const& ps, aqfp_reconstruct_stats& st )
+      : _ntk( ntk ), _ps( ps ), _st( st ), _topo_order()
+  {
+  }
+
+  buffered_aqfp_network run()
+  {
+    stopwatch( _st.total_time );
+
+    /* save the level of each node */
+    depth_view ntk_level{ _ntk };
+
+    /* create a network removing the splitter trees */
+    aqfp_network clean_ntk;
+    node_map<signal, buffered_aqfp_network> old2new( _ntk );
+    remove_splitter_trees( clean_ntk, old2new );
+
+    /* compute the node level on the new network */
+    node_map<uint32_t, aqfp_network> levels( clean_ntk );
+    _ntk.foreach_gate( [&]( auto const& n ) {
+      levels[old2new[n]] = ntk_level.level( n );
+    } );
+
+    uint32_t max_po_level = 0;
+    clean_ntk.foreach_po( [&]( auto const& f ){
+      uint32_t spl = std::ceil( std::log( clean_ntk.fanout_size( clean_ntk.get_node( f ) ) ) / std::log( _ps.buffer_insertion_ps.assume.splitter_capacity ) );
+      max_po_level = std::max( max_po_level, levels[f] + spl );
+    });
+    std::vector<uint32_t> po_levels;
+    for ( auto i = 0u; i < _ntk.num_pos(); ++i )
+    {
+      po_levels.emplace_back( max_po_level + 1 );
+    }
+
+    /* recompute splitter trees and return the new buffered network */
+    buffered_aqfp_network res;
+    buffer_insertion buf_inst( clean_ntk, levels, po_levels, _ps.buffer_insertion_ps );
+    _st.num_buffers = buf_inst.run( res );
+    return res;
+  }
+
+private:
+  void remove_splitter_trees( aqfp_network& res, node_map<signal, buffered_aqfp_network>& old2new )
+  {
+    topo_sorting();
+
+    old2new[_ntk.get_constant( false )] = res.get_constant( false );
+    _ntk.foreach_pi( [&]( auto const& n ) {
+      old2new[n] = res.create_pi();
+    } );
+
+    for ( auto const& n : _topo_order )
+    {
+      if ( _ntk.is_pi( n ) || _ntk.is_constant( n ) )
+        continue;
+
+      std::vector<signal> children;
+      _ntk.foreach_fanin( n, [&]( auto const& f ) {
+        children.push_back( old2new[f] ^ _ntk.is_complemented( f ) );
+      } );
+
+      if ( _ntk.is_buf( n ) )
+      {
+        old2new[n] = children[0];
+      }
+      else if ( children.size() == 3 )
+      {
+        old2new[n] = res.create_maj( children[0], children[1], children[2] );
+      }
+      else
+      {
+        old2new[n] = res.create_maj( children );
+      }
+    }
+
+    _ntk.foreach_po( [&]( auto const& f ) {
+      res.create_po( old2new[f] ^ _ntk.is_complemented( f ) );
+    } );
+  }
+
+  void topo_sorting()
+  {
+    _ntk.incr_trav_id();
+    _ntk.incr_trav_id();
+    _topo_order.reserve( _ntk.size() );
+
+    seed = _ps.seed;
+
+    /* constants and PIs */
+    const auto c0 = _ntk.get_node( _ntk.get_constant( false ) );
+    _topo_order.push_back( c0 );
+    _ntk.set_visited( c0, _ntk.trav_id() );
+
+    if ( const auto c1 = _ntk.get_node( _ntk.get_constant( true ) ); _ntk.visited( c1 ) != _ntk.trav_id() )
+    {
+      _topo_order.push_back( c1 );
+      _ntk.set_visited( c1, _ntk.trav_id() );
+    }
+
+    _ntk.foreach_ci( [&]( auto const& n ) {
+      if ( _ntk.visited( n ) != _ntk.trav_id() )
+      {
+        _topo_order.push_back( n );
+        _ntk.set_visited( n, _ntk.trav_id() );
+      }
+    } );
+
+    _ntk.foreach_co( [&]( auto const& f ) {
+      /* node was already visited */
+      if ( _ntk.visited( _ntk.get_node( f ) ) == _ntk.trav_id() )
+        return;
+
+      topo_sorting_rec( _ntk.get_node( f ) );
+    } );
+  }
+
+  void topo_sorting_rec( node const& n )
+  {
+    /* is permanently marked? */
+    if ( _ntk.visited( n ) == _ntk.trav_id() )
+      return;
+
+    /* ensure that the node is not temporarily marked */
+    assert( _ntk.visited( n ) != _ntk.trav_id() - 1 );
+
+    /* mark node temporarily */
+    _ntk.set_visited( n, _ntk.trav_id() - 1 );
+
+    /* mark children */
+    if ( !_ps.det_randomization )
+    {
+      _ntk.foreach_fanin( n, [this]( signal const& f ) {
+        topo_sorting_rec( _ntk.get_node( f ) );
+      } );
+    }
+    else
+    {
+      std::vector<node> fanins;
+      _ntk.foreach_fanin( n, [this, &fanins]( signal const& f ) {
+        fanins.push_back( _ntk.get_node( f ) );
+      } );
+      std::shuffle( fanins.begin(), fanins.end(), std::default_random_engine( seed++ ) );
+
+      for ( node const& g : fanins )
+        topo_sorting_rec( g );
+    }
+
+    /* mark node n permanently */
+    _ntk.set_visited( n, _ntk.trav_id() );
+
+    /* visit node */
+    _topo_order.push_back( n );
+  }
+
+private:
+  buffered_aqfp_network const& _ntk;
+  aqfp_reconstruct_params const& _ps;
+  aqfp_reconstruct_stats& _st;
+
+  std::vector<node> _topo_order;
+  std::default_random_engine::result_type seed{ 1 };
+};
+
+} /* namespace detail */
+
+/*! \brief Rebuilds buffer/splitter trees in an AQFP network.
+ *
+ * This function rebuilds buffer/splitter trees in an AQFP network.
+ *
+ * \param ntk Buffered AQFP network
+ */
+buffered_aqfp_network aqfp_reconstruct( buffered_aqfp_network const& ntk, aqfp_reconstruct_params const& ps = {}, aqfp_reconstruct_stats* pst = nullptr )
+{
+  aqfp_reconstruct_stats st;
+
+  detail::aqfp_reconstruct_impl p( ntk, ps, st );
+  auto res = p.run();
+
+  if ( pst )
+    *pst = st;
+
+  if ( ps.verbose )
+    st.report();
+
+  return res;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/aqfp_resynthesis.hpp b/include/mockturtle/algorithms/aqfp/aqfp_resynthesis.hpp
new file mode 100644
index 0000000..0021f41
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/aqfp_resynthesis.hpp
@@ -0,0 +1,378 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aqfp_resynthesis.hpp
+  \brief Resynthesis of path balanced networks
+
+  \author Dewmini Sudara Marakkalage
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <iostream>
+#include <unordered_map>
+
+#include <fmt/format.h>
+
+#include "../../traits.hpp"
+#include "../../utils/node_map.hpp"
+#include "../../utils/stopwatch.hpp"
+#include "../../views/depth_view.hpp"
+#include "../../views/topo_view.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for aqfp_resynthesis.
+ *
+ * The data structure `aqfp_resynthesis_params` holds configurable parameters
+ * with default arguments for `node_resynthesis`.
+ */
+struct aqfp_resynthesis_params
+{
+  bool verbose{ false };
+};
+
+/*! \brief Statistics of aqfp_resynthesis.
+ *
+ * The data structure `aqfp_resynthesis_stats` holds data collected during AQFP re-synthesis.
+ */
+struct aqfp_resynthesis_stats
+{
+  stopwatch<>::duration time_total{ 0 };
+
+  void report() const
+  {
+    std::cout << fmt::format( "[i] total time = {:>8.2f} secs\n", to_seconds( time_total ) );
+  }
+};
+
+/*! \brief Results of aqfp_resynthesis.
+ *
+ * The data structure `aqfp_resynthesis_result` holds the resulting level assignment of nodes
+ * and the level of the critical primary output.
+ */
+template<typename NtkDest>
+struct aqfp_resynthesis_result
+{
+  std::unordered_map<node<NtkDest>, uint32_t> node_level;
+  std::unordered_map<node<NtkDest>, uint32_t> po_level;
+
+  uint32_t critical_po_level()
+  {
+    return max_element( po_level.begin(), po_level.end(), [&]( auto n1, auto n2 ) { return n1.second < n2.second; } )
+        ->second;
+  }
+};
+
+namespace detail
+{
+
+/*! \brief Implementation of the AQFP re-synthesis algorithm. */
+template<typename NtkDest, typename NtkSrc, typename NodeResynFn, typename FanoutResynFn>
+class aqfp_resynthesis_impl
+{
+public:
+  aqfp_resynthesis_impl(
+      NtkDest& ntk_dest,
+      NtkSrc const& ntk_src,
+      NodeResynFn&& node_resyn_fn,
+      FanoutResynFn&& fanout_resyn_fn,
+      aqfp_resynthesis_params const& ps,
+      aqfp_resynthesis_stats& st )
+      : ntk_dest( ntk_dest ),
+        ntk_src( ntk_src ),
+        node_resyn_fn( node_resyn_fn ),
+        fanout_resyn_fn( fanout_resyn_fn ),
+        ps( ps ),
+        st( st )
+  {
+  }
+
+  aqfp_resynthesis_result<NtkDest> run()
+  {
+    stopwatch t( st.time_total );
+
+    node_map<signal<NtkDest>, NtkSrc> node2new( ntk_src );
+    node_map<uint32_t, NtkSrc> level_of_src_node( ntk_src );
+
+    std::unordered_map<node<NtkDest>, uint32_t> level_of_node;
+    std::unordered_map<node<NtkDest>, uint32_t> po_level_of_node;
+    std::map<std::pair<node<NtkSrc>, node<NtkSrc>>, uint32_t> level_for_fanout;
+
+    std::unordered_map<node<NtkSrc>, std::vector<node<NtkSrc>>> fanouts;
+    ntk_src.foreach_gate( [&]( auto n ) { ntk_src.foreach_fanin( n, [&]( auto fi ) { fanouts[ntk_src.get_node( fi )].push_back( n ); } ); } );
+
+    depth_view ntk_depth{ ntk_src };
+    topo_view ntk_topo{ ntk_depth };
+
+    /* map constants */
+    auto c0 = ntk_dest.get_constant( false );
+    node2new[ntk_src.get_node( ntk_src.get_constant( false ) )] = c0;
+    level_of_node[ntk_dest.get_node( c0 )] = 0u;
+
+    if ( ntk_src.get_node( ntk_src.get_constant( true ) ) != ntk_src.get_node( ntk_src.get_constant( false ) ) )
+    {
+      auto c1 = ntk_dest.get_constant( true );
+      node2new[ntk_src.get_node( ntk_src.get_constant( true ) )] = c1;
+      level_of_node[ntk_dest.get_node( c1 )] = 0u;
+    }
+
+    /* map primary inputs */
+    ntk_src.foreach_pi( [&]( auto n ) {
+      auto pi = ntk_dest.create_pi();
+      node2new[n] = pi;
+      level_of_node[ntk_dest.get_node( pi )] = 0u;
+
+      if constexpr ( has_has_name_v<NtkSrc> && has_get_name_v<NtkSrc> && has_set_name_v<NtkDest> )
+      {
+        if ( ntk_src.has_name( ntk_src.make_signal( n ) ) )
+          ntk_dest.set_name( node2new[n], ntk_src.get_name( ntk_src.make_signal( n ) ) );
+      }
+
+      /* synthesize fanout net of `n`*/
+      auto fanout_node_callback = [&]( const auto& f, const auto& level ) {
+        level_for_fanout[{ n, f }] = level;
+      };
+
+      auto fanout_po_callback = [&]( const auto& index, const auto& level ) {
+        (void)index;
+        auto node = ntk_dest.get_node(node2new[n]);
+        po_level_of_node[node] = std::max(po_level_of_node[node], level);
+      };
+
+      fanout_resyn_fn( ntk_topo, n, fanouts[n], ntk_dest, node2new[n], 0u, fanout_node_callback, fanout_po_callback ); } );
+
+    /* map register outputs */
+    if constexpr ( has_foreach_ro_v<NtkSrc> && has_create_ro_v<NtkDest> )
+    {
+      ntk_src.foreach_ro( [&]( auto n, auto i ) {
+        auto ro = ntk_dest.create_ro();
+        node2new[n] = ro;
+        level_of_node[ntk_dest.get_node( ro )] = 0u;
+
+        ntk_dest.set_register( i, ntk_src.register_at( i ) );
+        if constexpr ( has_has_name_v<NtkSrc> && has_get_name_v<NtkSrc> && has_set_name_v<NtkDest> )
+        {
+          if ( ntk_src.has_name( ntk_src.make_signal( n ) ) )
+            ntk_dest.set_name( node2new[n], ntk_src.get_name( ntk_src.make_signal( n ) ) );
+        }
+
+        auto fanout_node_callback = [&]( const auto& f, const auto& level ) {
+          level_for_fanout[{ n, f }] = level;
+        };
+
+        auto fanout_po_callback = [&]( const auto& index, const auto& level ) {
+          (void)index;
+          auto node = ntk_dest.get_node(node2new[n]);
+          po_level_of_node[node] = std::max(po_level_of_node[node], level);
+        };
+
+        fanout_resyn_fn( ntk_topo, n, fanouts[n], ntk_dest, node2new[n], 0u, fanout_node_callback, fanout_po_callback ); } );
+    }
+
+    /* map nodes */
+    ntk_topo.foreach_node( [&]( auto n ) {
+      if ( ntk_topo.is_constant( n ) || ntk_topo.is_ci( n ) )
+        return;
+
+      /* synthesize node `n` */
+      std::vector<std::pair<signal<NtkDest>, uint32_t>> children;
+      ntk_topo.foreach_fanin( n, [&]( auto const& f ) {
+        children.push_back( { ntk_topo.is_complemented( f ) ? ntk_dest.create_not( node2new[f] ) : node2new[f], level_for_fanout[{ ntk_topo.get_node( f ), n }] } );
+      } );
+
+      auto performed_resyn = false;
+
+      auto level_update_callback =
+          [&]( const auto& n, uint32_t level ) {
+            if ( !level_of_node.count( n ) )
+            {
+              level_of_node[n] = level;
+            }
+          };
+
+      auto resyn_performed_callback =
+          [&]( const auto& f, auto new_level ) {
+            node2new[n] = f;
+            level_of_src_node[n] = new_level;
+
+            if constexpr ( has_has_name_v<NtkSrc> && has_get_name_v<NtkSrc> && has_set_name_v<NtkDest> )
+            {
+              if ( ntk_topo.has_name( ntk_topo.make_signal( n ) ) )
+                ntk_dest.set_name( f, ntk_topo.get_name( ntk_topo.make_signal( n ) ) );
+            }
+
+            performed_resyn = true;
+          };
+
+      node_resyn_fn( ntk_dest, ntk_topo.node_function( n ), children.begin(), children.end(), level_update_callback, resyn_performed_callback );
+
+      if ( !performed_resyn )
+      {
+        fmt::print( "[e] could not perform resynthesis for node {} in node_resynthesis\n", ntk_topo.node_to_index( n ) );
+        std::abort();
+      }
+
+      /* synthesize fanout net of `n` */
+      auto fanout_node_callback = [&]( const auto& f, const auto& level ) {
+        level_for_fanout[{ n, f }] = std::max(level_for_fanout[{n, f}], level);
+      };
+
+      auto fanout_po_callback = [&]( const auto& index, const auto& level ) {
+        (void)index;
+        auto node = ntk_dest.get_node(node2new[n]);
+        po_level_of_node[node] = std::max(po_level_of_node[node], level);
+      };
+
+      fanout_resyn_fn( ntk_topo, n, fanouts[n], ntk_dest, node2new[n], level_of_src_node[n], fanout_node_callback, fanout_po_callback ); } );
+
+    /* map primary outputs */
+    ntk_src.foreach_po( [&]( auto const& f, auto index ) {
+      (void)index;
+
+      auto const o = ntk_src.is_complemented( f ) ? ntk_dest.create_not( node2new[f] ) : node2new[f];
+      ntk_dest.create_po( o );
+
+      assert(ntk_dest.is_constant(ntk_dest.get_node(o)) || po_level_of_node.count(ntk_dest.get_node(o)) > 0);
+      assert(ntk_dest.is_constant(ntk_dest.get_node(o)) || po_level_of_node.at(ntk_dest.get_node(o)) >= level_of_node.at(ntk_dest.get_node(o)));
+
+      if constexpr ( has_has_output_name_v<NtkSrc> && has_get_output_name_v<NtkSrc> && has_set_output_name_v<NtkDest> )
+      {
+        if ( ntk_src.has_output_name( index ) )
+        {
+          ntk_dest.set_output_name( index, ntk_src.get_output_name( index ) );
+        }
+      } } );
+
+    /* map register inputs */
+    if constexpr ( has_foreach_ri_v<NtkSrc> && has_create_ri_v<NtkDest> )
+    {
+      ntk_src.foreach_ri( [&]( auto const& f, auto index ) {
+        (void)index;
+
+        auto const o = ntk_src.is_complemented( f ) ? ntk_dest.create_not( node2new[f] ) : node2new[f];
+        ntk_dest.create_ri( o );
+
+        if constexpr ( has_has_output_name_v<NtkSrc> && has_get_output_name_v<NtkSrc> && has_set_output_name_v<NtkDest> )
+        {
+          if ( ntk_src.has_output_name( index ) )
+          {
+            ntk_dest.set_output_name( index + ntk_src.num_pos(), ntk_src.get_output_name( index + ntk_src.num_pos() ) );
+          }
+        } } );
+    }
+
+    return { level_of_node, po_level_of_node };
+  }
+
+private:
+  NtkDest& ntk_dest;
+  NtkSrc const& ntk_src;
+  NodeResynFn&& node_resyn_fn;
+  FanoutResynFn&& fanout_resyn_fn;
+  aqfp_resynthesis_params const& ps;
+  aqfp_resynthesis_stats& st;
+};
+
+} /* namespace detail */
+
+/*! \brief Re-synthesize a given source network as a path-balanced AQFP network.
+ *
+ * The algorithm outputs an AQFP network with level assignments to its nodes and combinational outputs.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+     aqfp_assumptions assume = { false, false, true, 4u };
+     aqfp_fanout_resyn fanout_resyn{ assume };
+
+     std::unordered_map<uint32_t, double> gate_costs = { { 3u, 6.0 }, { 5u, 10.0 } };
+     std::unordered_map<uint32_t, double> splitters = { { 1u, 2.0 }, { assume.splitter_capacity, 2.0 } };
+     aqfp_node_resyn_param ps{ assume, splitters, aqfp_node_resyn_strategy::delay };
+
+     aqfp_db<> db( gate_costs, splitters );
+     db.load_db( ... ); // from an input-stream (e.g., std::ifstream or std::stringstream)
+
+     aqfp_node_resyn node_resyn( db, ps );
+
+     klut_network src_ntk = ...;
+     aqfp_network dst_ntk;
+     auto res = aqfp_resynthesis( dst_ntk, src_ntk, node_resyn, fanout_resyn );
+
+   \endverbatim
+ */
+template<class NtkDest, class NtkSrc, class NodeResynFn, class FanoutResynFn>
+aqfp_resynthesis_result<NtkDest> aqfp_resynthesis(
+    NtkDest& ntk_dest,
+    NtkSrc const& ntk_src,
+    NodeResynFn&& node_resyn_fn,
+    FanoutResynFn&& fanout_resyn_fn,
+    aqfp_resynthesis_params const& ps = { false },
+    aqfp_resynthesis_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<NtkSrc>, "NtkSrc is not a network type" );
+  static_assert( is_network_type_v<NtkDest>, "NtkDest is not a network type" );
+
+  static_assert( has_get_node_v<NtkSrc>, "NtkSrc does not implement the get_node method" );
+  static_assert( has_get_constant_v<NtkSrc>, "NtkSrc does not implement the get_constant method" );
+  static_assert( has_foreach_pi_v<NtkSrc>, "NtkSrc does not implement the foreach_pi method" );
+  static_assert( has_foreach_node_v<NtkSrc>, "NtkSrc does not implement the foreach_node method" );
+  static_assert( has_is_constant_v<NtkSrc>, "NtkSrc does not implement the is_constant method" );
+  static_assert( has_is_pi_v<NtkSrc>, "NtkSrc does not implement the is_pi method" );
+  static_assert( has_is_complemented_v<NtkSrc>, "NtkSrc does not implement the is_complemented method" );
+  static_assert( has_foreach_fanin_v<NtkSrc>, "NtkSrc does not implement the foreach_fanin method" );
+  static_assert( has_node_function_v<NtkSrc>, "NtkSrc does not implement the node_function method" );
+  static_assert( has_foreach_po_v<NtkSrc>, "NtkSrc does not implement the foreach_po method" );
+
+  static_assert( has_get_constant_v<NtkDest>, "NtkDest does not implement the get_constant method" );
+  static_assert( has_create_pi_v<NtkDest>, "NtkDest does not implement the create_pi method" );
+  static_assert( has_create_not_v<NtkDest>, "NtkDest does not implement the create_not method" );
+  static_assert( has_create_po_v<NtkDest>, "NtkDest does not implement the create_po method" );
+
+  aqfp_resynthesis_stats st;
+
+  detail::aqfp_resynthesis_impl<NtkDest, NtkSrc, NodeResynFn, FanoutResynFn> p( ntk_dest, ntk_src, node_resyn_fn, fanout_resyn_fn, ps, st );
+  auto result = p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+
+  return result;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/aqfp_retiming.hpp b/include/mockturtle/algorithms/aqfp/aqfp_retiming.hpp
new file mode 100644
index 0000000..65abffb
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/aqfp_retiming.hpp
@@ -0,0 +1,681 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aqfp_retiming.hpp
+  \brief Retiming for AQFP networks
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <random>
+#include <vector>
+
+#include "../../networks/buffered.hpp"
+#include "../../networks/generic.hpp"
+#include "../../networks/klut.hpp"
+#include "../../utils/node_map.hpp"
+#include "../../utils/stopwatch.hpp"
+#include "../../views/choice_view.hpp"
+#include "../../views/fanout_view.hpp"
+#include "../../views/topo_view.hpp"
+#include "../retiming.hpp"
+#include "aqfp_assumptions.hpp"
+#include "aqfp_rebuild.hpp"
+
+namespace mockturtle
+{
+
+struct aqfp_retiming_params
+{
+  /*! \brief AQFP technology assumptions. */
+  aqfp_assumptions aqfp_assumptions_ps{};
+
+  /*! \brief Max number of iterations */
+  uint32_t iterations{ UINT32_MAX };
+
+  /*! \brief Enable splitter retiming. */
+  bool retime_splitters{ true };
+
+  /*! \brief Order of retiming is backward first. */
+  bool backwards_first{ true };
+
+  /*! \brief Adds an additional try for retiming */
+  uint32_t additional_try_iterations{ 1 };
+
+  /*! \brief Forward retiming only. */
+  bool forward_only{ false };
+
+  /*! \brief Backward retiming only. */
+  bool backward_only{ false };
+
+  /*! \brief Random seed. */
+  std::default_random_engine::result_type seed{ 1 };
+
+  /*! \brief Randomize the network. */
+  bool det_randomization{ false };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+};
+
+struct aqfp_retiming_stats
+{
+  /*! \brief Initial number of buffers/splitters. */
+  uint32_t buffers_pre{ 0 };
+
+  /*! \brief Number of buffers/splitters after the algorithm. */
+  uint32_t buffers_post{ 0 };
+
+  /*! \brief Total iterations. */
+  uint32_t rounds_total{ 0 };
+
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  void report() const
+  {
+    std::cout << fmt::format( "[i] Initial B/S   = {:7d}\t Final B/S   = {:7d}\n", buffers_pre, buffers_post );
+    std::cout << fmt::format( "[i] Total rounds  = {:7d}\n", rounds_total );
+    std::cout << fmt::format( "[i] Total runtime = {:>5.2f} secs\n", to_seconds( time_total ) );
+  }
+};
+
+namespace detail
+{
+
+template<class Ntk>
+class aqfp_retiming_impl
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  using signal_g = typename generic_network::signal;
+  using classes_t = std::vector<std::vector<node>>;
+
+public:
+  explicit aqfp_retiming_impl( Ntk& ntk, aqfp_retiming_params const& ps, aqfp_retiming_stats& st )
+      : _ntk( ntk ), _ps( ps ), _st( st )
+  {
+  }
+
+public:
+  Ntk run()
+  {
+    stopwatch t( _st.time_total );
+
+    retime_params rps;
+    std::default_random_engine::result_type seed = _ps.seed;
+
+    _st.buffers_pre = get_stats( _ntk );
+
+    Ntk ntk = _ntk;
+    uint32_t additional_try = _ps.additional_try_iterations;
+
+    if ( _ps.aqfp_assumptions_ps.splitter_capacity != 2 )
+      rps.iterations = 1;
+
+    buffer_insertion_params buf_ps;
+    buf_ps.assume = legacy_to_realistic( _ps.aqfp_assumptions_ps );
+    buf_ps.scheduling = buffer_insertion_params::provided;
+    buf_ps.optimization_effort = buffer_insertion_params::none;
+    aqfp_reconstruct_params reconstruct_ps;
+    aqfp_reconstruct_stats reconstruct_st;
+    reconstruct_ps.buffer_insertion_ps = buf_ps;
+    reconstruct_ps.det_randomization = _ps.det_randomization;
+
+    /* retiming first direction pass */
+    rps.forward_only = !_ps.backwards_first;
+    rps.backward_only = _ps.backwards_first;
+    uint32_t i = _ps.iterations;
+
+    if ( ( _ps.backwards_first && !_ps.forward_only ) || ( !_ps.backwards_first && !_ps.backward_only ) )
+    {
+      while ( i-- > 0 )
+      {
+        auto net = to_generic( ntk, seed, !_ps.backwards_first );
+        auto num_registers_before = net.num_registers();
+
+        retime( net, rps );
+
+        if ( net.num_registers() >= num_registers_before )
+        {
+          if ( additional_try-- == 0 )
+            break;
+        }
+        else if ( additional_try )
+        {
+          additional_try = _ps.additional_try_iterations;
+        }
+
+        ntk = to_buffered( net );
+        ++_st.rounds_total;
+      }
+    }
+
+    /* retiming second direction pass */
+    rps.forward_only = _ps.backwards_first;
+    rps.backward_only = !_ps.backwards_first;
+    i = _ps.iterations;
+    additional_try = _ps.additional_try_iterations;
+
+    if ( ( !_ps.backwards_first && !_ps.forward_only ) || ( _ps.backwards_first && !_ps.backward_only ) )
+    {
+      while ( i-- > 0 )
+      {
+        auto net = to_generic( ntk, seed, _ps.backwards_first );
+        auto num_registers_before = net.num_registers();
+
+        retime( net, rps );
+
+        if ( net.num_registers() >= num_registers_before )
+        {
+          if ( additional_try-- == 0 )
+            break;
+        }
+        else if ( additional_try )
+        {
+          additional_try = _ps.additional_try_iterations;
+        }
+        ntk = to_buffered( net );
+        ++_st.rounds_total;
+      }
+    }
+
+    auto res = aqfp_reconstruct( ntk, reconstruct_ps, &reconstruct_st );
+    _st.buffers_post = reconstruct_st.num_buffers;
+    return res;
+  }
+
+private:
+  uint32_t get_stats( Ntk& ntk )
+  {
+    uint32_t bs_count = 0;
+    ntk.foreach_node( [&]( auto const& n ) {
+      if ( ntk.is_buf( n ) )
+        ++bs_count;
+    } );
+
+    return bs_count;
+  }
+
+  generic_network to_generic( Ntk& ntk, std::default_random_engine::result_type& seed, bool forward )
+  {
+    node_map<signal_g, Ntk> old2new( ntk );
+    generic_network res;
+
+    old2new[ntk.get_constant( false )] = res.get_constant( false );
+    if ( ntk.get_node( ntk.get_constant( true ) ) != ntk.get_node( ntk.get_constant( false ) ) )
+    {
+      old2new[ntk.get_constant( true )] = res.get_constant( true );
+    }
+    ntk.foreach_pi( [&]( auto const& n ) {
+      old2new[n] = res.create_pi();
+    } );
+
+    /* suppose network is in topological order */
+    if ( _ps.retime_splitters && _ps.aqfp_assumptions_ps.splitter_capacity != 2 )
+    {
+      select_retimeable_elements_random( ntk, seed, forward );
+    }
+    else
+    {
+      select_buffers( ntk );
+    }
+
+    create_generic_network( ntk, res, old2new );
+
+    return res;
+  }
+
+  Ntk to_buffered( generic_network const& ntk )
+  {
+    node_map<signal, generic_network> old2new( ntk );
+    Ntk res;
+
+    old2new[ntk.get_constant( false )] = res.get_constant( false );
+    if ( ntk.get_node( ntk.get_constant( true ) ) != ntk.get_node( ntk.get_constant( false ) ) )
+    {
+      old2new[ntk.get_constant( true )] = res.get_constant( true );
+    }
+    ntk.foreach_pi( [&]( auto const& n ) {
+      old2new[n] = res.create_pi();
+    } );
+
+    topo_view topo{ ntk };
+
+    topo.foreach_node( [&]( auto const& n ) {
+      if ( ntk.is_pi( n ) || ntk.is_constant( n ) )
+        return true;
+
+      /* remove not represented nodes */
+      if ( ntk.is_box_input( n ) || ntk.is_box_output( n ) || ntk.is_po( n ) )
+      {
+        signal children;
+        ntk.foreach_fanin( n, [&]( auto const& f ) {
+          children = old2new[f];
+        } );
+
+        old2new[n] = children;
+        return true;
+      }
+
+      std::vector<signal> children;
+
+      ntk.foreach_fanin( n, [&]( auto const& f ) {
+        children.push_back( old2new[f] );
+      } );
+
+      signal f;
+
+      if ( ntk.fanin_size( n ) >= 3 )
+      {
+        if constexpr ( has_create_maj_odd_v<Ntk> )
+        {
+          if ( ntk.fanin_size( n ) > 3 )
+            f = res.create_maj( children );
+          else
+            f = res.create_maj( children[0], children[1], children[2] );
+        }
+        else
+        {
+          f = res.create_maj( children[0], children[1], children[2] );
+        }
+      }
+      else if ( ntk.fanin_size( n ) == 1 && ntk.node_function( n )._bits[0] == 0x1 )
+      {
+        /* not */
+        assert( children.size() == 1 );
+        f = !children[0];
+      }
+      else
+      {
+        /* buffer */
+        /* not balanced PIs */
+        if ( !_ps.aqfp_assumptions_ps.balance_pis && ( res.is_pi( res.get_node( children[0] ) ) || res.is_constant( res.get_node( children[0] ) ) ) )
+          f = children[0];
+        else
+          f = res.create_buf( children[0] );
+      }
+
+      old2new[n] = f;
+      return true;
+    } );
+
+    ntk.foreach_po( [&]( auto const& f ) {
+      res.create_po( old2new[f] );
+    } );
+
+    return res;
+  }
+
+  void select_retimeable_elements_random( Ntk& ntk, std::default_random_engine::result_type& seed, bool forward )
+  {
+    fanout_view fntk{ ntk };
+
+    ntk.clear_values();
+
+    /* select buffers and splitters to retime as soon as found some */
+    ntk.incr_trav_id();
+    ntk.foreach_node( [&]( auto const& n ) {
+      if ( ntk.is_pi( n ) || ntk.is_constant( n ) )
+        return true;
+
+      if ( ntk.is_buf( n ) )
+      {
+        if ( ntk.fanout_size( n ) == 1 )
+        {
+          if ( forward )
+          {
+            fntk.foreach_fanout( n, [&]( auto const& f ) {
+              if ( !ntk.is_buf( f ) || ntk.fanout_size( f ) != 1 )
+                ntk.set_visited( n, ntk.trav_id() );
+            } );
+          }
+          else
+          {
+            ntk.foreach_fanin( n, [&]( auto const& f ) {
+              if ( ntk.visited( ntk.get_node( f ) ) != ntk.trav_id() || !ntk.is_buf( ntk.get_node( f ) ) || ntk.fanout_size( ntk.get_node( f ) ) != 1 )
+                ntk.set_visited( n, ntk.trav_id() );
+            } );
+          }
+        }
+        else if ( ntk.visited( n ) != ntk.trav_id() || ntk.value( n ) > 0 )
+        {
+          int free_spots;
+          if ( ntk.value( n ) > 0 )
+          {
+            free_spots = rec_fetch_root( ntk, n ); /* aparently useless */
+            if ( free_spots == 0 )
+              return true;
+          }
+          else
+          {
+            free_spots = _ps.aqfp_assumptions_ps.splitter_capacity - ntk.fanout_size( n );
+          }
+
+          int total_fanout = 0;
+          std::vector<node> fanout_splitters;
+
+          /* select retimeable splitters */
+          fntk.foreach_fanout( n, [&]( auto const f ) {
+            if ( ntk.is_buf( f ) && ntk.fanout_size( f ) > 1 && free_spots >= ntk.fanout_size( f ) - 1 )
+            {
+              fanout_splitters.push_back( f );
+              total_fanout += ntk.fanout_size( f ) - 1;
+            }
+          } );
+
+          /* check if they are all retimeable together */
+          if ( free_spots >= total_fanout )
+          {
+            for ( auto f : fanout_splitters )
+            {
+              ntk.set_value( f, free_spots - total_fanout );
+              ntk.set_visited( f, ntk.trav_id() );
+            }
+            rec_update_root( ntk, n, free_spots - total_fanout );
+            return true;
+          }
+          /* select one randomly */
+          std::default_random_engine gen( seed++ );
+          std::uniform_int_distribution<uint32_t> dist( 0ul, fanout_splitters.size() - 1 );
+          auto index = dist( gen );
+          ntk.set_value( fanout_splitters[index], free_spots - ntk.fanout_size( fanout_splitters[index] ) + 1 );
+          ntk.set_visited( fanout_splitters[index], ntk.trav_id() );
+          rec_update_root( ntk, n, free_spots - ntk.fanout_size( fanout_splitters[index] ) + 1 );
+        }
+      }
+      return true;
+    } );
+  }
+
+  void create_generic_network( Ntk& ntk, generic_network& res, node_map<signal_g, Ntk>& old2new )
+  {
+    ntk.foreach_node( [&]( auto const& n ) {
+      if ( ntk.is_pi( n ) || ntk.is_constant( n ) )
+        return true;
+
+      std::vector<signal_g> children;
+
+      ntk.foreach_fanin( n, [&]( auto const& f ) {
+        if ( ntk.is_complemented( f ) )
+          children.push_back( res.create_not( old2new[f] ) );
+        else
+          children.push_back( old2new[f] );
+      } );
+
+      if ( ntk.is_buf( n ) && ntk.visited( n ) == ntk.trav_id() )
+      {
+        auto const in_register = res.create_box_input( children[0] );
+        auto const node_register = res.create_register( in_register );
+        auto const node_register_out = res.create_box_output( node_register );
+        old2new[n] = node_register_out;
+      }
+      else
+      {
+        const auto f = res.create_node( children, ntk.node_function( n ) );
+        old2new[n] = f;
+      }
+
+      return true;
+    } );
+
+    ntk.foreach_po( [&]( auto const& f ) {
+      if ( ntk.is_complemented( f ) )
+        res.create_po( res.create_not( old2new[f] ) );
+      else
+        res.create_po( old2new[f] );
+    } );
+  }
+
+  void forward_compatibility( Ntk& ntk, choice_view<Ntk>& choice_ntk )
+  {
+    ntk.foreach_node( [&]( auto const n ) {
+      if ( ntk.is_pi( n ) || ntk.is_constant( n ) )
+        return;
+
+      /* assign classes */
+      unsigned value = 0;
+      ntk.foreach_fanin( n, [&]( auto const f ) {
+        if ( ntk.value( ntk.get_node( f ) ) )
+        {
+          if ( value )
+            choice_ntk.add_choice( value, ntk.value( ntk.get_node( f ) ) );
+          else
+            value = ntk.value( ntk.get_node( f ) );
+        }
+      } );
+
+      /* propagate classes */
+      if ( ntk.visited( n ) != ntk.trav_id() && !ntk.value( n ) )
+        ntk.set_value( n, value );
+    } );
+  }
+
+  void backward_compatibility( Ntk& ntk, choice_view<Ntk>& choice_ntk, fanout_view<Ntk>& fntk )
+  {
+    std::vector<node> topo_order;
+    topo_order.reserve( ntk.size() );
+    ntk.foreach_node( [&]( auto const n ) {
+      if ( ntk.is_pi( n ) || ntk.is_constant( n ) )
+        return;
+
+      topo_order.push_back( n );
+    } );
+
+    for ( auto it = topo_order.rbegin(); it != topo_order.rend(); ++it )
+    {
+      /* assign classes */
+      unsigned value = 0;
+      fntk.foreach_fanout( *it, [&]( auto const f ) {
+        if ( ntk.value( f ) )
+        {
+          if ( value )
+            choice_ntk.add_choice( value, ntk.value( f ) );
+          else
+            value = ntk.value( f );
+        }
+      } );
+
+      /* propagate classes */
+      if ( ntk.visited( *it ) != ntk.trav_id() && !ntk.value( *it ) )
+        ntk.set_value( *it, value );
+    }
+  }
+
+  classes_t create_classes( choice_view<Ntk>& choice_ntk )
+  {
+    classes_t classes;
+    choice_ntk.foreach_node( [&]( auto const n ) {
+      if ( choice_ntk.is_pi( n ) || choice_ntk.is_constant( n ) )
+        return;
+      /* create unique classes */
+      if ( choice_ntk.value( n ) == n )
+      {
+        std::vector<node> comp_class;
+        choice_ntk.foreach_choice( n, [&]( auto const& f ) {
+          comp_class.push_back( f );
+          choice_ntk.set_value( f, 0 );
+          return true;
+        } );
+        classes.push_back( comp_class );
+      }
+    } );
+
+    std::stable_sort( classes.begin(), classes.end(), [&]( std::vector<node> const& a, std::vector<node> const& b ) { return a.size() > b.size(); } );
+
+    return classes;
+  }
+
+  uint32_t rec_fetch_root( Ntk& ntk, node const n )
+  {
+    uint32_t value;
+
+    if ( ntk.visited( n ) != ntk.trav_id() )
+      return ntk.value( n );
+
+    ntk.foreach_fanin( n, [&]( auto const f ) {
+      auto g = ntk.get_node( f );
+      if ( !ntk.is_buf( g ) || ntk.fanout_size( g ) == 1 )
+        value = ntk.value( n );
+      else
+        value = rec_fetch_root( ntk, g );
+    } );
+
+    return value;
+  }
+
+  void rec_update_root( Ntk& ntk, node const n, uint32_t const update )
+  {
+    if ( !ntk.is_buf( n ) || ntk.fanout_size( n ) == 1 )
+      return;
+
+    ntk.set_value( n, update );
+
+    if ( ntk.visited( n ) != ntk.trav_id() )
+      return;
+
+    ntk.foreach_fanin( n, [&]( auto const f ) {
+      rec_update_root( ntk, ntk.get_node( f ), update );
+    } );
+  }
+
+  void select_buffers( Ntk& ntk )
+  {
+    ntk.incr_trav_id();
+    ntk.foreach_node( [&]( auto const& n ) {
+      if ( ntk.is_buf( n ) && ntk.fanout_size( n ) == 1 )
+        ntk.set_visited( n, ntk.trav_id() );
+    } );
+  }
+
+  Ntk create_supersplitters()
+  {
+    Ntk res;
+    node_map<signal, Ntk> old2new( _ntk );
+
+    old2new[_ntk.get_constant( false )] = res.get_constant( false );
+    if ( _ntk.get_node( _ntk.get_constant( true ) ) != _ntk.get_node( _ntk.get_constant( false ) ) )
+    {
+      old2new[_ntk.get_constant( true )] = res.get_constant( true );
+    }
+    _ntk.foreach_pi( [&]( auto const& n ) {
+      old2new[n] = res.create_pi();
+    } );
+
+    _ntk.foreach_node( [&]( auto const& n ) {
+      if ( _ntk.is_pi( n ) || _ntk.is_constant( n ) )
+        return;
+
+      std::vector<signal> children;
+
+      _ntk.foreach_fanin( n, [&]( auto const& f ) {
+        children.push_back( old2new[f] ^ _ntk.is_complemented( f ) );
+      } );
+
+      signal f;
+      if ( _ntk.is_buf( n ) )
+      {
+        uint32_t supersplitter = res.value( res.get_node( children[0] ) );
+        if ( !supersplitter )
+        {
+          bool is_complemented = res.is_complemented( children[0] );
+          f = res.create_buf( children[0] ^ is_complemented );
+          res.set_value( res.get_node( children[0] ), res.node_to_index( res.get_node( f ) ) );
+          f = f ^ is_complemented;
+        }
+        else
+        {
+          f = res.make_signal( res.index_to_node( supersplitter ) ) ^ res.is_complemented( children[0] );
+        }
+      }
+      else
+      {
+        f = res.clone_node( _ntk, n, children );
+      }
+      old2new[n] = f;
+    } );
+
+    _ntk.foreach_po( [&]( auto const& f ) {
+      if ( _ntk.is_complemented( f ) )
+        res.create_po( res.create_not( old2new[f] ) );
+      else
+        res.create_po( old2new[f] );
+    } );
+
+    return res;
+  }
+
+private:
+  Ntk& _ntk;
+  aqfp_retiming_params const& _ps;
+  aqfp_retiming_stats& _st;
+};
+
+} /* namespace detail */
+
+/*! \brief AQFP retiming.
+ *
+ * This function applies a retiming-based approach
+ * for splitters and buffers minimization.
+ *
+ * \param ntk Buffered network
+ * \param ps AQFP retiming params
+ */
+template<class Ntk>
+Ntk aqfp_retiming( Ntk& ntk, aqfp_retiming_params const& ps = {}, aqfp_retiming_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_complemented_v<Ntk>, "NtkDest does not implement the is_complemented method" );
+  static_assert( is_buffered_network_type_v<Ntk>, "BufNtk is not a buffered network type" );
+  static_assert( has_is_buf_v<Ntk>, "BufNtk does not implement the is_buf method" );
+  static_assert( has_create_buf_v<Ntk>, "BufNtk does not implement the create_buf method" );
+
+  aqfp_retiming_stats st;
+
+  detail::aqfp_retiming_impl p( ntk, ps, st );
+  auto res = p.run();
+
+  if ( ps.verbose )
+    st.report();
+
+  if ( pst )
+    *pst = st;
+
+  return res;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/buffer_insertion.hpp b/include/mockturtle/algorithms/aqfp/buffer_insertion.hpp
new file mode 100644
index 0000000..3251aa8
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/buffer_insertion.hpp
@@ -0,0 +1,1980 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file buffer_insertion.hpp
+  \brief Insert buffers and splitters for the AQFP technology
+
+  \author Siang-Yun (Sonia) Lee
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include "../../traits.hpp"
+#include "../../utils/node_map.hpp"
+#include "../../views/fanout_view.hpp"
+#include "../../views/topo_view.hpp"
+#include "aqfp_assumptions.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <limits>
+#include <list>
+#include <set>
+#include <string>
+#include <vector>
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for (AQFP) buffer insertion.
+ */
+struct buffer_insertion_params
+{
+  /*! \brief Technology assumptions. */
+  aqfp_assumptions_realistic assume;
+
+  /*! \brief The scheduling strategy to get the initial depth assignment.
+   * - `provided` = An initial level assignment is given in the constructor, thus
+   * no scheduling is performed. It is the user's responsibility to ensure that
+   * the provided assignment is legal.
+   * - `ASAP` = Classical As-Soon-As-Possible scheduling
+   * - `ASAP_depth` = As-Soon-As-Possible scheduling with depth optimality
+   * - `ALAP` = ASAP (to obtain depth) followed by As-Late-As-Possible scheduling
+   * - `ALAP_depth` = As-Late-As-Possible scheduling with depth optimality
+   * - `better` = ASAP followed by ALAP, then count buffers for both assignments
+   * and choose the better one
+   * - `better_depth` = ALAP_depth followed by ASAP_depth, then count buffers for both assignments
+   * and choose the better one
+   */
+  enum scheduling_policy
+  {
+    provided,
+    ASAP,
+    ASAP_depth,
+    ALAP,
+    ALAP_depth,
+    better,
+    better_depth
+  } scheduling = ASAP;
+
+  /*! \brief The level of optimization effort.
+   * - `none` = No optimization
+   * - `one_pass` = Try to form a chunk starting from each gate, once
+   * for all gates
+   * - `until_sat` = Iterate over all gates until no more beneficial
+   * chunk movement can be found
+   * - `optimal` = Use an SMT solver to find the global optimal
+   */
+  enum
+  {
+    none,
+    one_pass,
+    until_sat,
+    optimal
+  } optimization_effort = none;
+
+  /*! \brief The maximum size of a chunk. */
+  uint32_t max_chunk_size{ 100u };
+};
+
+/*! \brief Insert buffers and splitters for the AQFP technology.
+ *
+ * In the AQFP technology, (1) logic gates can only have one fanout. If more than one
+ * fanout is needed, a splitter has to be inserted in between, which also
+ * takes one clocking phase (counted towards the network depth). (2) All fanins of
+ * a logic gate have to arrive at the same time (be at the same level). If one
+ * fanin path is shorter, buffers have to be inserted to balance it.
+ * Buffers and splitters are essentially the same component in this technology.
+ *
+ * With a given level assignment to all gates in the network, the minimum number of
+ * buffers needed is determined. This class implements algorithms to count such
+ * "irredundant buffers" and to insert them to obtain a buffered network. Moreover,
+ * as buffer optimization is essentially a problem of obtaining a good level assignment,
+ * this class also implements algorithms to obtain an initial, legal assignment using
+ * scheduling algorithms and to further adjust and optimize it.
+ *
+ * This class provides two easy-to-use top-level functions which wrap all the above steps
+ * together: `run` and `dry_run`. In addition, the following interfaces are kept for
+ * more fine-grained usage:
+ * - Query the current level assignment (`level`, `depth`)
+ * - Count irredundant buffers based on the current level assignment (`count_buffers`,
+ * `num_buffers`)
+ * - Optimize buffer count by scheduling (`schedule`, `ASAP`, `ALAP`) and by adjusting
+ * the level assignment with chunked movement (`optimize`)
+ * - Dump the resulting network into a network type which provides representation for
+ * buffers (`dump_buffered_network`)
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      mig_network mig = ...
+
+      buffer_insertion_params ps;
+      ps.scheduling = buffer_insertion_params::ALAP;
+      ps.optimization_effort = buffer_insertion_params::one_pass;
+
+      buffer_insertion buffering( mig, ps );
+      buffered_mig_network buffered_mig;
+      auto const num_buffers = buffering.run( buffered_mig );
+
+      std::cout << num_buffers << std::endl;
+      assert( verify_aqfp_buffer( buffered_mig, ps.assume ) );
+      write_verilog( buffered_mig, "buffered.v" );
+   \endverbatim
+ *
+ * **Required network functions:**
+ * - `foreach_node`
+ * - `foreach_gate`
+ * - `foreach_pi`
+ * - `foreach_po`
+ * - `foreach_fanin`
+ * - `is_pi`
+ * - `is_constant`
+ * - `get_node`
+ * - `fanout_size`
+ * - `size`
+ * - `set_visited`
+ * - `set_value`
+ *
+ */
+template<typename Ntk>
+class buffer_insertion
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  explicit buffer_insertion( Ntk const& ntk, buffer_insertion_params const& ps = {} )
+      : _ntk( ntk ), _ps( ps ), _levels( _ntk ), _po_levels( _ntk.num_pos(), 0u ), _timeframes( _ntk ), _fanouts( _ntk ), _num_buffers( _ntk )
+  {
+    static_assert( !is_buffered_network_type_v<Ntk>, "Ntk is already buffered" );
+    static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+    static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+    static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+    static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+    static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+    static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+    static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+
+    assert( _ps.scheduling != buffer_insertion_params::provided );
+
+    // checks for assumptions
+    assert( _ps.assume.ci_phases.size() > 0 );
+    assert( _ps.assume.ignore_co_negation ); // consideration of CO negation is too complicated and neglected for now
+  }
+
+  explicit buffer_insertion( Ntk const& ntk, node_map<uint32_t, Ntk> const& levels, std::vector<uint32_t> const& po_levels, buffer_insertion_params const& ps = {} )
+      : _ntk( ntk ), _ps( ps ), _levels( levels ), _po_levels( po_levels ), _timeframes( _ntk ), _fanouts( _ntk ), _num_buffers( _ntk )
+  {
+    static_assert( !is_buffered_network_type_v<Ntk>, "Ntk is already buffered" );
+    static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+    static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+    static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+    static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+    static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+    static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+    static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+
+    assert( _ps.scheduling == buffer_insertion_params::provided );
+    assert( _po_levels.size() == _ntk.num_pos() );
+  }
+
+  /*! \brief Insert buffers and obtain a buffered network.
+   *
+   * \param bufntk An empty network of an appropriate buffered network type to
+   * to store the buffer-insertion result
+   * \return The number of buffers in the resulting network
+   */
+  template<class BufNtk>
+  uint32_t run( BufNtk& bufntk )
+  {
+    dry_run();
+    dump_buffered_network( bufntk );
+    return num_buffers();
+  }
+
+  /*! \brief Insert buffers and obtain a buffered network.
+   *
+   * It is suggested to write the `pi_levels` information into a dumped file
+   * for easier recovery of the scheduled phase assignment.
+   *
+   * \param bufntk An empty network of an appropriate buffered network type to
+   * to store the buffer-insertion result
+   * \param pi_lvls A vector which will store the PI level assignment (it is
+   * recommended to store this information together with the buffered network)
+   * \return The number of buffers in the resulting network
+   */
+  template<class BufNtk>
+  uint32_t run( BufNtk& bufntk, std::vector<uint32_t>& pi_lvls )
+  {
+    dry_run();
+    dump_buffered_network( bufntk );
+    pi_lvls = pi_levels();
+    return num_buffers();
+  }
+
+  /*! \brief Count the number of buffers without dumping the result into a buffered network.
+   *
+   * This function saves some runtime for dumping the resulting network and
+   * allows users to experiment on the algorithms with new network types whose
+   * corresponding buffered_network are not implemented yet.
+   *
+   * `pLevels` and `pPOLevels` can be used to create another `buffer_insertion` instance of
+   * the same state (current schedule), which also define a unique buffered network. (Set
+   * `ps.scheduling = provided` and `ps.optimization_effort = none`)
+   *
+   * \return The number of buffers in the resulting network
+   */
+  uint32_t dry_run()
+  {
+    schedule();
+    optimize();
+    count_buffers();
+    return num_buffers();
+  }
+
+#pragma region Query
+  node_map<uint32_t, Ntk> const& levels() const
+  {
+    return _levels;
+  }
+
+  /*! \brief Level of node `n` considering buffer/splitter insertion. */
+  uint32_t level( node const& n ) const
+  {
+    assert( n < _ntk.size() );
+    return _levels[n];
+  }
+
+  std::vector<uint32_t> const& po_levels() const
+  {
+    return _po_levels;
+  }
+
+  /*! \brief Level of the `idx`-th PO (imaginary dummy PO node, not counted in depth). */
+  uint32_t po_level( uint32_t idx ) const
+  {
+    assert( idx < _ntk.num_pos() );
+    return _po_levels[idx];
+  }
+
+  std::vector<uint32_t> pi_levels() const
+  {
+    std::vector<uint32_t> lvls;
+    _ntk.foreach_pi( [&]( auto n ){
+      lvls.emplace_back( _levels[n] );
+    } );
+    return lvls;
+  }
+
+  /*! \brief Network depth considering AQFP buffers/splitters.
+   *
+   * Should be equal to `max( po_level(i) - 1 )`.
+   *
+   * This is the number of phases from the previous-stage register to the
+   * next-stage register, including the depth of the previous-stage register
+   * (i.e., from one register input to the next register input).
+   */
+  uint32_t depth() const
+  {
+    return _depth;
+  }
+
+  /*! \brief The total number of buffers in the network under the current
+   * level assignment. */
+  uint32_t num_buffers() const
+  {
+    assert( !_outdated && "Please call `count_buffers()` first." );
+
+    uint32_t count = 0u;
+    _ntk.foreach_node( [&]( auto const& n ) {
+      if ( !_ntk.is_constant( n ) )
+        count += num_buffers( n );
+    } );
+    return count;
+  }
+
+  /*! \brief The number of buffers between `n` and all of its fanouts under
+   * the current level assignment. */
+  uint32_t num_buffers( node const& n ) const
+  {
+    assert( !_outdated && "Please call `count_buffers()` first." );
+    return _num_buffers[n];
+  }
+
+  /*! \brief The chosen schedule is ASAP */
+  bool is_scheduled_ASAP() const
+  {
+    return _is_scheduled_ASAP;
+  }
+#pragma endregion
+
+#pragma region Count buffers
+  /*! \brief Count the number of buffers needed at the fanout of each gate
+   * according to the current level assignment.
+   *
+   * This function must be called after level (re-)assignment and before
+   * querying `num_buffers`.
+   */
+  void count_buffers()
+  {
+    if ( _outdated )
+    {
+      update_fanout_info();
+    }
+
+    _ntk.foreach_node( [&]( auto const& n ) {
+      if ( !_ntk.is_constant( n ) )
+        _num_buffers[n] = count_buffers( n );
+    } );
+  }
+
+private:
+  uint32_t count_buffers( node const& n ) const
+  {
+    assert( !_outdated && "Please call `update_fanout_info()` first." );
+    auto const& fo_infos = _fanouts[n];
+
+    if ( _ntk.fanout_size( n ) == 0u ) /* dangling */
+    {
+      if ( !_ntk.is_pi( n ) )
+        std::cerr << "[w] node " << n << " (which is not a PI) is dangling.\n";
+      return 0u;
+    }
+
+    if ( _ntk.fanout_size( n ) == 1u ) /* single fanout */
+    {
+      assert( fo_infos.size() == 1u );
+      return fo_infos.front().relative_depth - 1u;
+    }
+
+    if ( _ps.assume.ci_capacity > 1 && _ntk.is_pi( n ) )
+    {
+      if ( fo_infos.size() == 1u )
+      {
+        assert( fo_infos.front().relative_depth == 1u );
+        return 0u;
+      }
+    }
+
+    assert( fo_infos.size() > 1u );
+    auto it = fo_infos.begin();
+    uint32_t count = it->num_edges - it->fanouts.size() - it->extrefs.size();
+    uint32_t rd = it->relative_depth;
+    for ( ++it; it != fo_infos.end(); ++it )
+    {
+      count += it->num_edges - it->fanouts.size() - it->extrefs.size() + it->relative_depth - rd - 1;
+      rd = it->relative_depth;
+    }
+
+    return count;
+  }
+
+  /* (Upper bound on) the additional depth caused by a balanced splitter tree at the output of node `n`. */
+  uint32_t num_splitter_levels( node const& n ) const
+  {
+    assert( n < _ntk.size() );
+    if ( _ntk.is_pi( n ) )
+    {
+      if ( _ntk.fanout_size( n ) > _ps.assume.ci_capacity )
+        return std::ceil( std::log( _ntk.fanout_size( n ) - _ps.assume.ci_capacity + 1 ) / std::log( _ps.assume.splitter_capacity ) );
+      else
+        return 0u;
+    }
+    return std::ceil( std::log( _ntk.fanout_size( n ) ) / std::log( _ps.assume.splitter_capacity ) );
+  }
+
+  /* Update fanout_information of all nodes */
+  void update_fanout_info()
+  {
+    _fanouts.reset();
+
+    _ntk.foreach_gate( [&]( auto const& n ) {
+      _ntk.foreach_fanin( n, [&]( auto const& fi ) {
+        auto const ni = _ntk.get_node( fi );
+        if ( !_ntk.is_constant( ni ) )
+          insert_fanout( ni, n );
+      } );
+    } );
+
+    _ntk.foreach_po( [&]( auto const& f, auto i ){
+      insert_extref( _ntk.get_node( f ), i );
+    } );
+
+    _ntk.foreach_node( [&]( auto const& n ) {
+      if ( !_ntk.is_constant( n ) )
+        count_edges( n );
+    } );
+
+    _outdated = false;
+  }
+
+  /* Update the fanout_information of a node */
+  template<bool verify = false>
+  bool update_fanout_info( node const& n )
+  {
+    std::vector<node> fos;
+    std::vector<uint32_t> extrefs;
+    for ( auto it = _fanouts[n].begin(); it != _fanouts[n].end(); ++it )
+    {
+      if ( it->fanouts.size() )
+      {
+        for ( auto it2 = it->fanouts.begin(); it2 != it->fanouts.end(); ++it2 )
+          fos.push_back( *it2 );
+      }
+      if ( it->extrefs.size() )
+      {
+        for ( auto it2 = it->extrefs.begin(); it2 != it->extrefs.end(); ++it2 )
+          extrefs.push_back( *it2 );
+      }
+    }
+
+    _fanouts[n].clear();
+    for ( auto& fo : fos )
+      insert_fanout( n, fo );
+    for ( auto& po : extrefs )
+      insert_extref( n, po );
+
+    return count_edges<verify>( n );
+  }
+
+  void insert_fanout( node const& n, node const& fanout )
+  {
+    assert( _levels[fanout] > _levels[n] );
+    auto const rd = _levels[fanout] - _levels[n];
+    auto& fo_infos = _fanouts[n];
+    for ( auto it = fo_infos.begin(); it != fo_infos.end(); ++it )
+    {
+      if ( it->relative_depth == rd )
+      {
+        it->fanouts.push_back( fanout );
+        ++it->num_edges;
+        return;
+      }
+      else if ( it->relative_depth > rd )
+      {
+        fo_infos.insert( it, { rd, { fanout }, {}, 1u } );
+        return;
+      }
+    }
+    fo_infos.push_back( { rd, { fanout }, {}, 1u } );
+  }
+
+  void insert_extref( node const& n, uint32_t idx )
+  {
+    assert( _po_levels[idx] > _levels[n] );
+    auto const rd = _po_levels[idx] - _levels[n];
+    auto& fo_infos = _fanouts[n];
+    for ( auto it = fo_infos.begin(); it != fo_infos.end(); ++it )
+    {
+      if ( it->relative_depth == rd )
+      {
+        it->extrefs.push_back( idx );
+        ++it->num_edges;
+        return;
+      }
+      else if ( it->relative_depth > rd )
+      {
+        fo_infos.insert( it, { rd, {}, {idx}, 1u } );
+        return;
+      }
+    }
+    fo_infos.push_back( { rd, {}, {idx}, 1u } );
+  }
+
+  template<bool verify = false>
+  bool count_edges( node const& n )
+  {
+    auto& fo_infos = _fanouts[n];
+
+    if ( fo_infos.size() == 0u || ( fo_infos.size() == 1u && fo_infos.front().num_edges == 1u ) )
+    {
+      return true;
+    }
+
+    if ( _ntk.is_pi( n ) && _ps.assume.ci_capacity > 1 )
+    {
+      if ( fo_infos.front().relative_depth > 1u )
+        fo_infos.push_front( { 1u, {}, {}, 0u } );
+    }
+    else
+    {
+      assert( fo_infos.front().relative_depth > 1u );
+      fo_infos.push_front( { 1u, {}, {}, 0u } );
+    }
+
+    auto it = fo_infos.end();
+    --it;
+    uint32_t splitters;
+    while ( it != fo_infos.begin() )
+    {
+      splitters = num_splitters( it->num_edges );
+      auto rd = it->relative_depth;
+      --it;
+      if ( it->relative_depth < rd - 1 && splitters > 1 )
+      {
+        it = fo_infos.insert( ++it, { rd - 1, {}, {}, splitters } );
+      }
+      else
+      {
+        it->num_edges += splitters;
+      }
+    }
+
+    assert( fo_infos.front().relative_depth == 1u );
+    if constexpr ( verify )
+    {
+      return _ntk.is_pi( n ) ? fo_infos.front().num_edges <= _ps.assume.ci_capacity : fo_infos.front().num_edges == 1u;
+    }
+    else
+    {
+      assert( _ntk.is_pi( n ) ? fo_infos.front().num_edges <= _ps.assume.ci_capacity : fo_infos.front().num_edges == 1u );
+      return true;
+    }
+  }
+
+  /* Return the number of splitters needed in one level lower */
+  uint32_t num_splitters( uint32_t const& num_fanouts ) const
+  {
+    return std::ceil( float( num_fanouts ) / float( _ps.assume.splitter_capacity ) );
+  }
+#pragma endregion
+
+#pragma region Initial level assignment
+public:
+  void set_scheduling_policy( buffer_insertion_params::scheduling_policy p )
+  {
+    _ps.scheduling = p;
+  }
+
+  /*! \brief Obtain the initial level assignment using the specified scheduling policy */
+  void schedule()
+  {
+    if ( _ps.scheduling == buffer_insertion_params::provided )
+    {
+      _ntk.foreach_po( [&]( auto const& f, auto i ) {
+        assert( _po_levels[i] > _levels[f] );
+        _depth = std::max( _depth, _po_levels[i] - 1 );
+      } );
+      assert( _depth % _ps.assume.num_phases == 0 );
+      return;
+    }
+
+    if ( _ps.scheduling == buffer_insertion_params::better_depth || _ps.scheduling == buffer_insertion_params::ASAP_depth || _ps.scheduling == buffer_insertion_params::ALAP_depth )
+    {
+      fanout_view<Ntk> f_ntk{ _ntk };
+      /* Optimum-depth ALAP scheduling */
+      ALAP_depth( f_ntk );
+      count_buffers();
+      auto const num_buf_ALAP_depth = num_buffers();
+
+      if ( _ps.scheduling == buffer_insertion_params::ALAP_depth )
+        return;
+
+      /* Optimum-depth ALAP scheduling: no balanced trees */
+      ASAP_depth( f_ntk, false );
+      count_buffers();
+      auto const num_buf_ASAP_depth = num_buffers();
+
+      if ( _ps.scheduling == buffer_insertion_params::ASAP_depth )
+        return;
+
+      /* Revert to optimum-depth ALAP scheduling if better */
+      if ( num_buf_ALAP_depth < num_buf_ASAP_depth )
+      {
+        ALAP_depth( f_ntk );
+      }
+      return;
+    }
+
+    ASAP();
+    if ( _ps.scheduling == buffer_insertion_params::ALAP )
+    {
+      ALAP();
+    }
+    else if ( _ps.scheduling == buffer_insertion_params::better )
+    {
+      count_buffers();
+      auto num_buf_ASAP = num_buffers();
+      ALAP();
+      count_buffers();
+      if ( num_buffers() > num_buf_ASAP )
+      {
+        ASAP();
+      }
+    }
+  }
+
+  /*! \brief ASAP scheduling */
+  void ASAP()
+  {
+    _depth = 0;
+    _levels.reset( 0 );
+    _ntk.incr_trav_id();
+
+    _ntk.foreach_po( [&]( auto const& f, auto i ) {
+      auto const no = _ntk.get_node( f );
+      _po_levels[i] = compute_levels_ASAP( no ) + num_splitter_levels( no ) + 1;
+      if ( ( _po_levels[i] - 1 ) % _ps.assume.num_phases != 0 ) // phase alignment
+      {
+        _po_levels[i] += _ps.assume.num_phases - ( ( _po_levels[i] - 1 ) % _ps.assume.num_phases );
+      }
+      _depth = std::max( _depth, _po_levels[i] - 1 );
+    } );
+    assert( _depth % _ps.assume.num_phases == 0 );
+
+    if ( _ps.assume.balance_cios )
+    {
+      _ntk.foreach_po( [&]( auto const& f, auto i ) {
+        (void)f;
+        _po_levels[i] = _depth + 1;
+      } );
+    }
+
+    /* dangling PIs */
+    _ntk.foreach_pi( [&]( auto const& n ){
+      if ( _ntk.visited( n ) != _ntk.trav_id() )
+        _levels[n] = _ps.assume.ci_phases[0];
+    } );
+
+    _outdated = true;
+    _is_scheduled_ASAP = true;
+  }
+
+  /*! \brief ASAP optimal-depth scheduling
+   *
+   * ASAP_depth should follow right after ALAP_depth (i.e., initialization).
+   *
+   * \param try_regular tries to insert balanced trees when sufficient slack.
+   */
+  void ASAP_depth( fanout_view<Ntk> const& f_ntk, bool try_regular )
+  {
+    node_map<uint32_t, Ntk> mobility( _ntk, std::numeric_limits<uint32_t>::max() );
+
+    if ( !_ps.assume.balance_cios )
+    {
+      _ntk.foreach_po( [&]( auto const& f, auto i ) {
+        (void)f;
+        _po_levels[i] = 0;
+      } );
+    }
+
+    _ntk.foreach_pi( [&]( auto const& n ) {
+      if ( !_ntk.is_constant( n ) )
+      {
+        mobility[n] = _levels[n] - _ps.assume.ci_phases[0];
+        compute_mobility_ASAP( f_ntk, n, mobility, try_regular );
+      }
+    } );
+
+    _ntk.foreach_gate( [&]( auto const& n ) {
+      compute_mobility_ASAP( f_ntk, n, mobility, try_regular );
+    } );
+
+    if ( !_ps.assume.balance_cios )
+    {
+      _ntk.foreach_po( [&]( auto const& f, auto i ) {
+        if ( _po_levels[i] == 0 )
+        {
+          assert( _ntk.is_constant( _ntk.get_node( f ) ) );
+          _po_levels[i] = 1;
+        }
+        else if ( ( _po_levels[i] - 1 ) % _ps.assume.num_phases != 0 ) // phase alignment
+        {
+          _po_levels[i] += _ps.assume.num_phases - ( ( _po_levels[i] - 1 ) % _ps.assume.num_phases );
+        }
+        _depth = std::max( _depth, _po_levels[i] - 1 );
+      } );
+      assert( _depth % _ps.assume.num_phases == 0 );
+    }
+
+    _outdated = true;
+    _is_scheduled_ASAP = true;
+  }
+
+  /*! \brief ALAP scheduling.
+   *
+   * ALAP should follow right after ASAP (i.e., initialization) without other optimization in between.
+   */
+  void ALAP()
+  {
+    assert( _depth % _ps.assume.num_phases == 0 );
+    _levels.reset( 0 );
+    _ntk.incr_trav_id();
+
+    _ntk.foreach_po( [&]( auto const& f, auto i ) {
+      _po_levels[i] = _depth + 1;
+      const auto n = _ntk.get_node( f );
+
+      if ( !_ntk.is_constant( n ) && _ntk.visited( n ) != _ntk.trav_id() )
+      {
+        _levels[n] = _depth - num_splitter_levels( n );
+        compute_levels_ALAP( n );
+      }
+    } );
+
+    /* dangling PIs */
+    _ntk.foreach_pi( [&]( auto const& n ){
+      if ( _ntk.visited( n ) != _ntk.trav_id() )
+        _levels[n] = _ps.assume.ci_phases[0];
+    } );
+
+    _outdated = true;
+    _is_scheduled_ASAP = false;
+  }
+
+  /*! \brief ALAP depth-optimal sheduling */
+  void ALAP_depth( fanout_view<Ntk> const& f_ntk )
+  {
+    _levels.reset( 0 );
+    topo_view<Ntk> topo_ntk{ _ntk };
+
+    /* compute ALAP */
+    _depth = std::numeric_limits<uint32_t>::max() - 1;
+    uint32_t min_level = std::numeric_limits<uint32_t>::max() - 1;
+    topo_ntk.foreach_node_reverse( [&]( auto const& n ) {
+      if ( !_ntk.is_constant( n ) && _ntk.fanout_size( n ) > 0 )
+      {
+        compute_levels_ALAP_depth( f_ntk, n );
+        min_level = std::min( min_level, _levels[n] );
+      }
+    } );
+
+    /* move everything down by `delta` */
+    uint32_t delta = min_level;
+    /* phase alignment for PO: depth % num_phases = 0 */
+    if ( ( _depth - delta ) % _ps.assume.num_phases != 0 )
+    {
+      delta -= _ps.assume.num_phases - ( ( _depth - delta ) % _ps.assume.num_phases );
+    }
+
+    /* level of the lowest PI >= ci_phases[0] */
+    while ( min_level - delta < _ps.assume.ci_phases[0] )
+    {
+      delta -= _ps.assume.num_phases;
+    }
+    /* move PIs down to an acceptable level */
+    if ( _ps.assume.balance_cios )
+    {
+      _ntk.foreach_pi( [&]( auto const& n ) {
+        if ( _ntk.fanout_size( n ) == 0 )
+        {
+          _levels[n] = _ps.assume.ci_phases[0];
+        }
+        else if ( !_ntk.is_constant( n ) )
+        {
+          _levels[n] = _levels[n] - delta;
+          for ( auto rit = _ps.assume.ci_phases.rbegin(); rit != _ps.assume.ci_phases.rend(); ++rit )
+          {
+            if ( *rit <= _levels[n] )
+            {
+              _levels[n] = *rit;
+              return;
+            }
+          }
+          assert( false );
+        }
+      } );
+    }
+    else
+    {
+      _ntk.foreach_pi( [&]( auto const& n ) {
+        if ( _ntk.fanout_size( n ) == 0 )
+        {
+          _levels[n] = _ps.assume.ci_phases[0];
+        }
+        else if ( !_ntk.is_constant( n ) )
+        {
+          _levels[n] = _levels[n] - delta;
+          while ( !is_acceptable_ci_lvl( _levels[n] ) )
+          {
+            assert( _levels[n] > 0 );
+            --_levels[n];
+          }
+        }
+      } );
+    }
+
+    _ntk.foreach_gate( [&]( auto const& n ) {
+      _levels[n] = _levels[n] - delta;
+    } );
+    _depth -= delta;
+    assert( _depth % _ps.assume.num_phases == 0 );
+    if ( _ps.assume.balance_cios )
+    {
+      _ntk.foreach_po( [&]( auto const& f, auto i ) {
+        (void)f;
+        _po_levels[i] = _depth + 1;
+      } );
+    }
+    else
+    {
+      _ntk.foreach_po( [&]( auto const& f, auto i ) {
+        if ( _ntk.is_constant( _ntk.get_node( f ) ) )
+          _po_levels[i] = 1;
+        else
+        {
+          _po_levels[i] = _levels[f] + num_splitter_levels( _ntk.get_node( f ) );
+          if ( _po_levels[i] % _ps.assume.num_phases > 0 )
+            _po_levels[i] += _ps.assume.num_phases - ( _po_levels[i] % _ps.assume.num_phases );
+          ++_po_levels[i];
+        }
+      } );
+    }
+
+    _outdated = true;
+    _is_scheduled_ASAP = false;
+  }
+
+private:
+  uint32_t compute_levels_ASAP( node const& n )
+  {
+    if ( _ntk.visited( n ) == _ntk.trav_id() )
+    {
+      return _levels[n];
+    }
+    _ntk.set_visited( n, _ntk.trav_id() );
+
+    if ( _ntk.is_constant( n ) )
+    {
+      return _levels[n] = 0;
+    }
+    else if ( _ntk.is_pi( n ) )
+    {
+      return _levels[n] = _ps.assume.ci_phases[0];
+    }
+
+    uint32_t level{ 0 };
+    _ntk.foreach_fanin( n, [&]( auto const& fi ) {
+      auto const ni = _ntk.get_node( fi );
+      if ( !_ntk.is_constant( ni ) )
+      {
+        auto fi_level = compute_levels_ASAP( ni ) + num_splitter_levels( ni );
+        level = std::max( level, fi_level );
+      }
+    } );
+
+    return _levels[n] = level + 1;
+  }
+
+  bool is_acceptable_ci_lvl( uint32_t lvl ) const
+  {
+    if ( _ps.assume.balance_cios )
+    {
+      for ( auto const& p : _ps.assume.ci_phases )
+      {
+        if ( lvl == p )
+          return true;
+      }
+      return false;
+    }
+    else
+    {
+      for ( auto const& p : _ps.assume.ci_phases )
+      {
+        // for example, if num_phases = 4, ci_phases = {5},
+        // then lvl = 1 will not be acceptable, but lvl = 5 or lvl = 9 will
+        if ( lvl % _ps.assume.num_phases == p % _ps.assume.num_phases && lvl >= p )
+          return true;
+      }
+      return false;
+    }
+  }
+
+  void compute_levels_ALAP( node const& n )
+  {
+    _ntk.set_visited( n, _ntk.trav_id() );
+
+    if ( _ntk.is_pi( n ) )
+    {
+      if ( _ps.assume.balance_cios )
+      {
+        for ( auto rit = _ps.assume.ci_phases.rbegin(); rit != _ps.assume.ci_phases.rend(); ++rit )
+        {
+          if ( *rit <= _levels[n] )
+          {
+            _levels[n] = *rit;
+            return;
+          }
+        }
+        assert( false );
+      }
+      else
+      {
+        while ( !is_acceptable_ci_lvl( _levels[n] ) )
+        {
+          assert( _levels[n] > 0 );
+          --_levels[n];
+        }
+      }
+      return;
+    }
+
+    _ntk.foreach_fanin( n, [&]( auto const& fi ) {
+      auto const ni = _ntk.get_node( fi );
+      if ( !_ntk.is_constant( ni ) )
+      {
+        assert( _levels[n] > num_splitter_levels( ni ) );
+        auto fi_level = _levels[n] - num_splitter_levels( ni ) - 1;
+        if ( _ntk.visited( ni ) != _ntk.trav_id() || _levels[ni] > fi_level )
+        {
+          _levels[ni] = fi_level;
+          compute_levels_ALAP( ni );
+        }
+      }
+    } );
+  }
+
+  void compute_levels_ALAP_depth( fanout_view<Ntk> const& ntk, node const& n )
+  {
+    std::vector<uint32_t> level_assignment;
+    level_assignment.reserve( ntk.fanout_size( n ) );
+
+    /* if node is a PO, add levels */
+    for ( auto i = ntk.fanout( n ).size(); i < ntk.fanout_size( n ); ++i )
+      level_assignment.push_back( _depth + 1 );
+
+    /* get fanout levels */
+    ntk.foreach_fanout( n, [&]( auto const& f ) {
+      level_assignment.push_back( _levels[f] );
+    } );
+
+    /* sort by descending order of levels */
+    std::stable_sort( level_assignment.begin(), level_assignment.end(), std::greater<uint32_t>() );
+
+    /* simulate splitter tree reconstruction */
+    uint32_t nodes_in_level = 0;
+    uint32_t last_level = level_assignment.front();
+    for ( int const l : level_assignment )
+    {
+      if ( l == last_level )
+      {
+        ++nodes_in_level;
+      }
+      else
+      {
+        /* update splitters */
+        for ( auto i = 0; ( i < last_level - l ) && ( nodes_in_level != 1 ); ++i )
+          nodes_in_level = std::ceil( float( nodes_in_level ) / float( _ps.assume.splitter_capacity ) );
+
+        ++nodes_in_level;
+        last_level = l;
+      }
+    }
+
+    /* search for a feasible level for node n */
+    --last_level;
+    if ( _ntk.is_pi( n ) )
+    {
+      while ( nodes_in_level > _ps.assume.ci_capacity )
+      {
+        nodes_in_level = std::ceil( float( nodes_in_level ) / float( _ps.assume.splitter_capacity ) );
+        --last_level;
+      }
+    }
+    else
+    {
+      while ( nodes_in_level > 1 )
+      {
+        nodes_in_level = std::ceil( float( nodes_in_level ) / float( _ps.assume.splitter_capacity ) );
+        --last_level;
+      }
+    }
+
+    _levels[n] = last_level;
+  }
+
+  void compute_mobility_ASAP( fanout_view<Ntk> const& ntk, node const& n, node_map<uint32_t, Ntk>& mobility, bool try_regular )
+  {
+    assert( mobility[n] <= _levels[n] );
+    /* commit ASAP scheduling */
+    uint32_t level_n = _levels[n] - mobility[n];
+    _levels[n] = level_n;
+
+    /* try to fit a balanced tree */
+    if ( try_regular )
+    {
+      uint32_t fo_level = num_splitter_levels( n );
+      bool valid = true;
+      ntk.foreach_fanout( n, [&]( auto const& f ) {
+        if ( level_n + fo_level + 1 > _levels[f] )
+          valid = false;
+        return valid;
+      } );
+
+      if ( valid )
+      {
+        ntk.foreach_fanout( n, [&]( auto const& f ) {
+          mobility[f] = std::min( mobility[f], _levels[f] - level_n - fo_level - 1 );
+        } );
+        return;
+      }
+    }
+
+    /* keep current splitter structure, selecting the mobility based on the buffers */
+    std::vector<std::array<uint32_t, 3>> level_assignment;
+    level_assignment.reserve( _ntk.fanout_size( n ) );
+
+    /* if node is a PO, add levels */
+    if ( ntk.fanout( n ).size() < ntk.fanout_size( n ) )
+    {
+      ntk.foreach_po( [&]( auto const& f, auto i ){
+        if ( ntk.get_node( f ) == n )
+          level_assignment.push_back( { i, _depth + 1, 0 } );
+      } );
+      assert( level_assignment.size() == ntk.fanout_size( n ) - ntk.fanout( n ).size() );
+    }
+
+    /* get fanout levels */
+    ntk.foreach_fanout( n, [&]( auto const& f ) {
+      level_assignment.push_back( { ntk.node_to_index( f ), _levels[f], 0 } );
+    } );
+
+    /* dangling PI */
+    if ( level_assignment.empty() )
+    {
+      return;
+    }
+
+    /* sort by descending order of levels */
+    std::stable_sort( level_assignment.begin(), level_assignment.end(), []( auto const& a, auto const& b ) {
+      return a[1] > b[1];
+    } );
+
+    /* simulate splitter tree reconstruction */
+    uint32_t nodes_in_level = 0;
+    uint32_t nodes_in_last_level = _ps.assume.splitter_capacity;
+    uint32_t last_level = level_assignment.front()[1];
+    for ( auto i = 0; i < level_assignment.size(); ++i )
+    {
+      uint32_t l = level_assignment[i][1];
+      if ( l == last_level )
+      {
+        ++nodes_in_level;
+      }
+      else
+      {
+        /* update splitters */
+        uint32_t mobility_update = 0;
+        for ( auto j = 0; j < last_level - l; ++j )
+        {
+          if ( nodes_in_level == 1 )
+          {
+            ++mobility_update;
+          }
+          nodes_in_level = std::ceil( float( nodes_in_level ) / float( _ps.assume.splitter_capacity ) );
+        }
+
+        if ( mobility_update )
+        {
+          for ( auto j = 0; j < i; ++j )
+            level_assignment[j][2] += mobility_update;
+        }
+
+        ++nodes_in_level;
+        last_level = l;
+      }
+    }
+
+    /* search a feasible level for node n */
+    uint32_t mobility_update = 0;
+    for ( auto i = level_n + 1; i < last_level; ++i )
+    {
+      if ( nodes_in_level == 1 || ( _ntk.is_pi( n ) && nodes_in_level <= _ps.assume.ci_capacity ) )
+        ++mobility_update;
+      nodes_in_level = std::ceil( float( nodes_in_level ) / float( _ps.assume.splitter_capacity ) );
+    }
+
+    /* update mobilities */
+    for ( auto const& v : level_assignment )
+    {
+      if ( v[1] != _depth + 1 )
+      {
+        mobility[v[0]] = std::min( mobility[v[0]], v[2] + mobility_update );
+      }
+    }
+
+    /* update po_level, if possible */
+    if ( !_ps.assume.balance_cios )
+    {
+      for ( auto const& v : level_assignment )
+      {
+        if ( v[1] == _depth + 1 )
+        {
+          _po_levels[v[0]] = std::max( _po_levels[v[0]], _depth + 1 - v[2] - mobility_update );
+        }
+        else
+        {
+          break;
+        }
+      }
+    }
+  }
+#pragma endregion
+
+#pragma region Dump buffered network
+public:
+  /*! \brief Dump buffered network
+   *
+   * After level assignment, (optimization), and buffer counting, this method
+   * can be called to dump the resulting buffered network.
+   */
+  template<class BufNtk>
+  void dump_buffered_network( BufNtk& bufntk ) const
+  {
+    static_assert( is_buffered_network_type_v<BufNtk>, "BufNtk is not a buffered network type" );
+    static_assert( has_is_buf_v<BufNtk>, "BufNtk does not implement the is_buf method" );
+    static_assert( has_create_buf_v<BufNtk>, "BufNtk does not implement the create_buf method" );
+    assert( !_outdated && "Please call `count_buffers()` first." );
+
+    using buf_signal = typename BufNtk::signal;
+    using fanout_tree = std::vector<std::list<buf_signal>>;
+
+    node_map<buf_signal, Ntk> node_to_signal( _ntk );
+    node_map<fanout_tree, Ntk> buffers( _ntk );
+
+    /* constants */
+    node_to_signal[_ntk.get_constant( false )] = bufntk.get_constant( false );
+    buffers[_ntk.get_constant( false )].emplace_back( 1, bufntk.get_constant( false ) );
+    if ( _ntk.get_node( _ntk.get_constant( false ) ) != _ntk.get_node( _ntk.get_constant( true ) ) )
+    {
+      node_to_signal[_ntk.get_constant( true )] = bufntk.get_constant( true );
+      buffers[_ntk.get_constant( true )].emplace_back( 1, bufntk.get_constant( true ) );
+    }
+
+    /* PIs */
+    _ntk.foreach_pi( [&]( auto const& n ) {
+      node_to_signal[n] = bufntk.create_pi();
+      create_buffer_chain( bufntk, buffers, n, node_to_signal[n] );
+    } );
+
+    /* gates: assume topological order */
+    _ntk.foreach_gate( [&]( auto const& n ) {
+      std::vector<buf_signal> children;
+      _ntk.foreach_fanin( n, [&]( auto const& fi ) {
+        buf_signal s;
+        if ( _ntk.is_constant( _ntk.get_node( fi ) ) )
+          s = node_to_signal[fi];
+        else
+          s = get_buffer_at_relative_depth( bufntk, buffers[fi], _levels[n] - _levels[fi] - 1 );
+        children.push_back( _ntk.is_complemented( fi ) ? !s : s );
+      } );
+      node_to_signal[n] = bufntk.clone_node( _ntk, n, children );
+      create_buffer_chain( bufntk, buffers, n, node_to_signal[n] );
+    } );
+
+    /* POs */
+    _ntk.foreach_po( [&]( auto const& f, auto i ) {
+      buf_signal s;
+      if ( _ntk.is_constant( _ntk.get_node( f ) ) )
+        s = node_to_signal[f];
+      else
+        s = get_buffer_at_relative_depth( bufntk, buffers[f], _po_levels[i] - _levels[f] - 1 );
+      assert( _ps.assume.ignore_co_negation );
+      bufntk.create_po( _ntk.is_complemented( f ) ? !s : s );
+    } );
+
+    assert( bufntk.size() - bufntk.num_pis() - bufntk.num_gates() - 1 == num_buffers() );
+  }
+
+private:
+  template<class BufNtk, typename Buffers>
+  void create_buffer_chain( BufNtk& bufntk, Buffers& buffers, node const& n, typename BufNtk::signal const& s ) const
+  {
+    if ( _ntk.fanout_size( n ) == 0 )
+      return; /* dangling */
+
+    assert( _fanouts[n].size() > 0u );
+    buffers[n].resize( _fanouts[n].back().relative_depth );
+    auto& fot = buffers[n];
+    fot[0].push_back( s );
+    for ( auto i = 1u; i < fot.size(); ++i )
+    {
+      fot[i].push_back( bufntk.create_buf( fot[i-1].back() ) );
+    }
+  }
+
+  template<class BufNtk, typename FOT>
+  typename BufNtk::signal get_buffer_at_relative_depth( BufNtk& bufntk, FOT& fot, uint32_t rd ) const
+  {
+    typename BufNtk::signal b = fot[rd].back();
+    if ( rd == 0 && bufntk.is_pi( bufntk.get_node( b ) ) )
+    {
+      assert( bufntk.fanout_size( bufntk.get_node( b ) ) < _ps.assume.ci_capacity );
+      return b;
+    }
+    if ( bufntk.fanout_size( bufntk.get_node( b ) ) == _ps.assume.splitter_capacity )
+    {
+      assert( rd > 0 );
+      typename BufNtk::signal b_lower = get_buffer_at_relative_depth( bufntk, fot, rd - 1 );
+      b = bufntk.create_buf( b_lower );
+      fot[rd].push_back( b );
+    }
+    return b;
+  }
+#pragma endregion
+
+#pragma region Post-dump optimization
+public:
+template<class BufNtk>
+uint32_t remove_buffer_chains( BufNtk& ntk ) const
+{
+  static_assert( is_buffered_network_type_v<BufNtk>, "BufNtk is not a buffered network" );
+
+  uint32_t max_chain = 0;
+  ntk.incr_trav_id();
+  ntk.foreach_po( [&]( auto f ){
+    remove_buffer_chains_rec( ntk, ntk.get_node( f ), 0, max_chain );
+  } );
+  return max_chain;
+}
+
+private:
+template<class BufNtk>
+std::pair<uint32_t, typename BufNtk::node> remove_buffer_chains_rec( BufNtk& ntk, typename BufNtk::node n, typename BufNtk::node parent, uint32_t& max_chain ) const
+{
+  if ( ntk.visited( n ) == ntk.trav_id() )
+    return std::make_pair( 0, n );
+  ntk.set_visited( n, ntk.trav_id() );
+  if ( ntk.is_pi( n ) )
+    return std::make_pair( 0, n );
+
+  if ( ntk.is_buf( n ) )
+  {
+    // splitter
+    if ( ntk.fanout_size( n ) > 1 )
+    {
+      ntk.foreach_fanin( n, [&]( auto f ){
+        remove_buffer_chains_rec( ntk, ntk.get_node( f ), n, max_chain );
+      } );
+      return std::make_pair( 0, n );
+    }
+
+    // single-output buffer: can be part of a chain to be removed
+    std::pair<uint32_t, typename BufNtk::node> ret;
+    ntk.foreach_fanin( n, [&]( auto f ){
+      auto [count, origin] = remove_buffer_chains_rec( ntk, ntk.get_node( f ), n, max_chain );
+      if ( count % _ps.assume.num_phases == _ps.assume.num_phases - 1 )
+      {
+        // TODO: take care of complementation
+        if ( parent != 0 )
+        {
+          ntk.replace_in_node( parent, n, ntk.make_signal( origin ) );
+          ntk.take_out_node( n );
+        }
+        else
+        {
+          ntk.replace_in_outputs( n, ntk.make_signal( origin ) );
+          ntk.take_out_node( n );
+        }
+        max_chain = std::max( count + 1, max_chain );
+      }
+      ret = std::make_pair( count + 1, origin );
+    } );
+    return ret;
+  }
+
+  // gate
+  ntk.foreach_fanin( n, [&]( auto f ){
+    remove_buffer_chains_rec( ntk, ntk.get_node( f ), n, max_chain );
+  } );
+  return std::make_pair( 0, n );
+}
+#pragma endregion
+
+public:
+  /*! \brief Optimize with chunked movement using the specified optimization policy. */
+  void optimize()
+  {
+    if ( _ps.optimization_effort == buffer_insertion_params::none )
+    {
+      return;
+    }
+    //else if ( _ps.optimization_effort == buffer_insertion_params::optimal )
+    //{
+    //  if constexpr ( has_get_network_name_v<Ntk> )
+    //    optimize_with_smt( _ntk.get_network_name() );
+    //  else
+    //    optimize_with_smt( "" );
+    //  return;
+    //}
+
+    if ( _outdated )
+    {
+      update_fanout_info();
+    }
+
+    bool updated;
+    do
+    {
+      updated = find_and_move_chunks();
+    } while ( updated && _ps.optimization_effort == buffer_insertion_params::until_sat );
+    single_gate_movement();
+  }
+
+#pragma region Chunked movement
+private:
+  struct io_interface
+  {
+    node c; // chunk node
+    node o; // outside node
+  };
+
+  struct po_interface
+  {
+    node c; // chunk node
+    uint32_t o; // PO index
+  };
+
+  struct chunk
+  {
+    uint32_t id;
+    std::vector<node> members{};
+    std::vector<io_interface> input_interfaces{};
+    std::vector<io_interface> output_interfaces{};
+    std::vector<po_interface> po_interfaces{};
+    int32_t slack{ std::numeric_limits<int32_t>::max() };
+    int32_t benefits{ 0 };
+  };
+
+  bool is_ignored( node const& n ) const
+  {
+    return _ntk.is_constant( n );
+  }
+
+  bool is_fixed( node const& n ) const
+  {
+    return _ps.assume.balance_cios && _ps.assume.ci_phases.size() == 1 && _ntk.is_pi( n );
+  }
+
+  bool find_and_move_chunks()
+  {
+    bool updated = false;
+    count_buffers();
+    uint32_t num_buffers_before = num_buffers();
+    _start_id = _ntk.trav_id();
+
+    _ntk.foreach_node( [&]( auto const& n ) {
+      if ( is_ignored( n ) || is_fixed( n ) || _ntk.visited( n ) > _start_id /* belongs to a chunk */ )
+      {
+        return true;
+      }
+
+      _ntk.incr_trav_id();
+      chunk c{ _ntk.trav_id() };
+      recruit( n, c );
+      if ( c.members.size() > _ps.max_chunk_size )
+      {
+        return true; /* skip */
+      }
+      cleanup_interfaces( c );
+
+      auto moved = analyze_chunk_down( c );
+      if ( !moved )
+        moved = analyze_chunk_up( c );
+      updated |= moved;
+      return true;
+    } );
+
+    count_buffers();
+    assert( num_buffers() <= num_buffers_before );
+    return updated && num_buffers() < num_buffers_before;
+  }
+
+  void single_gate_movement()
+  {
+    _ntk.foreach_node( [&]( auto const& n ) {
+      if ( is_ignored( n ) || is_fixed( n ) )
+        return;
+
+      _ntk.incr_trav_id();
+      chunk c{ _ntk.trav_id() };
+      c.members.emplace_back( n );
+      _ntk.foreach_fanin( n, [&]( auto const& fi ) {
+        auto const ni = _ntk.get_node( fi );
+        if ( !is_ignored( ni )  )
+          c.input_interfaces.push_back( { n, ni } );
+      } );
+      auto const& fanout_info = _fanouts[n];
+      for ( auto it = fanout_info.begin(); it != fanout_info.end(); ++it )
+      {
+        for ( auto it2 = it->fanouts.begin(); it2 != it->fanouts.end(); ++it2 )
+          c.output_interfaces.push_back( { n, *it2 } );
+        for ( auto it2 = it->extrefs.begin(); it2 != it->extrefs.end(); ++it2 )
+          c.po_interfaces.push_back( { n, *it2 } );
+      }
+
+      if ( !analyze_chunk_down( c ) )
+        analyze_chunk_up( c );
+    } );
+  }
+
+  void recruit( node const& n, chunk& c )
+  {
+    if ( _ntk.visited( n ) == c.id )
+      return;
+
+    assert( _ntk.visited( n ) <= _start_id );
+    assert( !is_fixed( n ) );
+    assert( !is_ignored( n ) );
+
+    _ntk.set_visited( n, c.id );
+    c.members.emplace_back( n );
+    recruit_fanins( n, c );
+    recruit_fanouts( n, c );
+  }
+
+  void recruit_fanins( node const& n, chunk& c )
+  {
+    _ntk.foreach_fanin( n, [&]( auto const& fi ) {
+      auto const ni = _ntk.get_node( fi );
+      if ( !is_ignored( ni ) && _ntk.visited( ni ) != c.id )
+      {
+        if ( is_fixed( ni ) )
+          c.input_interfaces.push_back( { n, ni } );
+        else if ( are_close( ni, n ) )
+          recruit( ni, c );
+        else
+          c.input_interfaces.push_back( { n, ni } );
+      }
+    } );
+  }
+
+  void recruit_fanouts( node const& n, chunk& c )
+  {
+    auto const& fanout_info = _fanouts[n];
+    if ( fanout_info.size() == 0 ) /* dangling */
+      return;
+
+    auto it = fanout_info.begin();
+    if ( _ntk.fanout_size( n ) == 1 ) /* single fanout */
+    {
+      assert( fanout_info.size() == 1 );
+      if ( it->fanouts.size() == 1 ) /* single gate fanout */
+      {
+        if ( it->relative_depth == 1 )
+          recruit( it->fanouts.front(), c );
+        else
+          c.output_interfaces.push_back( { n, it->fanouts.front() } );
+      }
+      else /* single PO fanout */
+      {
+        assert( it->extrefs.size() == 1 );
+        c.po_interfaces.push_back( { n, it->extrefs.front() } );
+      }
+      return;
+    }
+
+    for ( ; it != fanout_info.end(); ++it )
+    {
+      for ( auto it2 = it->extrefs.begin(); it2 != it->extrefs.end(); ++it2 )
+        c.po_interfaces.push_back( { n, *it2 } );
+    }
+    it = fanout_info.begin();
+
+    if ( _ps.assume.ci_capacity > 1 && _ntk.is_pi( n ) )
+    {
+      if ( it->relative_depth == 1 )
+      {
+        for ( auto it2 = it->fanouts.begin(); it2 != it->fanouts.end(); ++it2 )
+          recruit( *it2, c );
+        it++;
+      }
+      if ( it->relative_depth == 2 && fanout_info.front().num_edges == _ps.assume.ci_capacity )
+      {
+        assert( fanout_info.front().relative_depth == 1 );
+        for ( auto it2 = it->fanouts.begin(); it2 != it->fanouts.end(); ++it2 )
+          recruit( *it2, c );
+        it++;
+      }
+      for ( ; it != fanout_info.end(); ++it )
+      {
+        for ( auto it2 = it->fanouts.begin(); it2 != it->fanouts.end(); ++it2 )
+        {
+          if ( _ntk.visited( *it2 ) != c.id )
+            c.output_interfaces.push_back( { n, *it2 } );
+        }
+      }
+      return;
+    }
+
+    for ( ; it != fanout_info.end(); ++it )
+    {
+      for ( auto it2 = it->fanouts.begin(); it2 != it->fanouts.end(); ++it2 )
+      {
+        if ( it->relative_depth == 2 )
+          recruit( *it2, c );
+        else if ( _ntk.visited( *it2 ) != c.id )
+          c.output_interfaces.push_back( { n, *it2 } );
+      }
+    }
+  }
+
+  bool are_close( node const& ni, node const& n )
+  {
+    auto const& fanout_info = _fanouts[ni];
+
+    if ( _ps.assume.ci_capacity > 1 && _ntk.is_pi( ni ) )
+    {
+      auto const& front_fanouts = fanout_info.front().fanouts;
+      if ( fanout_info.front().relative_depth == 1 )
+      {
+        if ( std::find( front_fanouts.begin(), front_fanouts.end(), n ) != front_fanouts.end() )
+          return true;
+        if ( fanout_info.front().num_edges < _ps.assume.ci_capacity )
+          return false;
+      }
+      else if ( _ntk.fanout_size( ni ) <= _ps.assume.ci_capacity )
+        return false;
+      assert( fanout_info.size() > 1 );
+    }
+
+    if ( fanout_info.size() == 1 && fanout_info.front().relative_depth == 1 )
+    {
+      assert( fanout_info.front().fanouts.front() == n );
+      return true;
+    }
+    if ( fanout_info.size() > 1 )
+    {
+      auto it = fanout_info.begin();
+      it++;
+      if ( it->relative_depth > 2 )
+        return false;
+      for ( auto it2 = it->fanouts.begin(); it2 != it->fanouts.end(); ++it2 )
+      {
+        if ( *it2 == n )
+          return true;
+      }
+    }
+    return false;
+  }
+
+  void cleanup_interfaces( chunk& c )
+  {
+    for ( int i = 0; i < c.input_interfaces.size(); ++i )
+    {
+      if ( _ntk.visited( c.input_interfaces[i].o ) == c.id )
+      {
+        c.input_interfaces.erase( c.input_interfaces.begin() + i );
+        --i;
+      }
+    }
+    for ( int i = 0; i < c.output_interfaces.size(); ++i )
+    {
+      if ( _ntk.visited( c.output_interfaces[i].o ) == c.id )
+      {
+        c.output_interfaces.erase( c.output_interfaces.begin() + i );
+        --i;
+      }
+    }
+  }
+
+  bool analyze_chunk_down( chunk c )
+  {
+    count_buffers();
+    auto buffers_before = num_buffers();
+
+    std::set<node> marked_oi;
+    for ( auto oi : c.output_interfaces )
+    {
+      if ( marked_oi.find( oi.c ) == marked_oi.end() )
+      {
+        marked_oi.insert( oi.c );
+        --c.benefits;
+      }
+    }
+
+    for ( auto ii : c.input_interfaces )
+    {
+      auto const rd = _levels[ii.c] - _levels[ii.o];
+      auto const lowest = lowest_spot( ii.o );
+      if ( rd <= lowest )
+      {
+        c.slack = 0;
+        break;
+      }
+      c.slack = std::min( c.slack, int32_t( rd - lowest ) );
+      pseudo_move( ii.o, ii.c, rd, lowest );
+      if ( _fanouts[ii.o].back().relative_depth == rd && _fanouts[ii.o].back().num_edges == 0 ) // `ii.c` is the last highest fanout of `ii.o`
+      {
+        ++c.benefits;
+      }
+    }
+
+    if ( c.po_interfaces.size() > 0 )
+    {
+      if ( !_ps.assume.balance_cios && c.slack >= _ps.assume.num_phases )
+      {
+        c.slack -= c.slack % _ps.assume.num_phases;
+      }
+      else
+      {
+        for ( auto poi : c.po_interfaces )
+        {
+          if ( marked_oi.find( poi.c ) == marked_oi.end() )
+            --c.benefits;
+        }
+      }
+    }
+
+    std::vector<node> pi_members;
+    for ( auto m : c.members )
+    {
+      if ( _ntk.is_pi( m ) )
+      {
+        pi_members.emplace_back( m );
+        c.slack = std::min( c.slack, int32_t( _levels[m] ) );
+      }
+    }
+    if ( pi_members.size() > 0 )
+    {
+      while ( c.slack > 0 )
+      {
+        bool ok = true;
+        for ( auto m : pi_members )
+        {
+          if ( _levels[m] < c.slack || !is_acceptable_ci_lvl( _levels[m] - c.slack ) )
+          {
+            ok = false;
+            break;
+          }
+        }
+        if ( !ok )
+          --c.slack;
+        else
+          break;
+      }
+    }
+
+    if ( c.benefits > 0 && c.slack > 0 )
+    {
+      bool legal = true;
+
+      for ( auto m : c.members )
+        _levels[m] -= c.slack;
+      if ( !_ps.assume.balance_cios && c.slack >= _ps.assume.num_phases )
+      {
+        for ( auto poi : c.po_interfaces )
+          _po_levels[poi.o] -= c.slack;
+      }
+      for ( auto m : c.members )
+        update_fanout_info( m );
+      for ( auto ii : c.input_interfaces )
+        legal &= update_fanout_info<true>( ii.o );
+
+      _outdated = true;
+      if ( legal )
+        count_buffers();
+      if ( !legal || num_buffers() >= buffers_before )
+      {
+        /* UNDO */
+        for ( auto m : c.members )
+          _levels[m] += c.slack;
+        if ( !_ps.assume.balance_cios && c.slack >= _ps.assume.num_phases )
+        {
+          for ( auto poi : c.po_interfaces )
+            _po_levels[poi.o] += c.slack;
+        }
+        for ( auto m : c.members )
+          update_fanout_info( m );
+        for ( auto ii : c.input_interfaces )
+          update_fanout_info( ii.o );
+        _outdated = true;
+        return false;
+      }
+
+      _start_id = _ntk.trav_id();
+      return true;
+    }
+    else
+    {
+      /* reset fanout_infos of input_interfaces because num_edges may be modified by pseudo_move */
+      for ( auto ii : c.input_interfaces )
+        update_fanout_info( ii.o );
+      _outdated = true;
+      return false;
+    }
+  }
+
+  /* relative_depth of the lowest available spot in the fanout tree of n */
+  uint32_t lowest_spot( node const& n ) const
+  {
+    auto const& fanout_info = _fanouts[n];
+    assert( fanout_info.size() );
+
+    auto it = fanout_info.begin();
+    uint32_t rd_prev = 1;
+    uint32_t num_splitters_prev = 1;
+    if ( _ntk.is_pi( n ) && _ps.assume.ci_capacity > 1 )
+    {
+      if ( it->num_edges <= _ps.assume.ci_capacity )
+        return 1;
+      else
+        num_splitters_prev = _ps.assume.ci_capacity - it->fanouts.size() - it->extrefs.size();
+    }
+    else if ( fanout_info.size() == 1 ) // single fanout
+    {
+      return 1;
+    }
+    
+    ++it; // skip the first splitter at rd=1
+    for ( ; it != fanout_info.end(); ++it )
+    {
+      if ( it->relative_depth > rd_prev + 1 ) // level skip => must not full
+      {
+        return rd_prev + 1;
+      }
+      else if ( it->num_edges == _ps.assume.splitter_capacity * num_splitters_prev ) // full layer
+      {
+        num_splitters_prev = it->num_edges - it->fanouts.size() - it->extrefs.size();
+        rd_prev = it->relative_depth;
+      }
+      else
+      {
+        return it->relative_depth;
+      }
+    }
+    // all full
+    return fanout_info.back().relative_depth + 1;
+  }
+
+  /* move `no`, which is a fanout of `n`, from `from_rd` to `to_rd` */
+  void pseudo_move( node const& n, node const& no, uint32_t from_rd, uint32_t to_rd )
+  {
+    assert( from_rd > to_rd );
+    auto& fanout_info = _fanouts[n];
+    auto it = fanout_info.begin();
+    for ( ; it != fanout_info.end(); ++it )
+    {
+      if ( it->relative_depth == to_rd )
+      {
+        ++it->num_edges;
+        it->fanouts.push_back( no );
+        break;
+      }
+      else if ( it->relative_depth > to_rd )
+      {
+        fanout_info.insert( it, {to_rd, {no}, {}, 2} );
+        break;
+      }
+    }
+    for ( ; it != fanout_info.end(); ++it )
+    {
+      if ( it->relative_depth == from_rd )
+      {
+        --it->num_edges;
+        for ( auto it2 = it->fanouts.begin(); it2 != it->fanouts.end(); ++it2 )
+        {
+          if ( *it2 == no )
+          {
+            it->fanouts.erase( it2 );
+            return;
+          }
+        }
+        assert( false );
+      }
+    }
+    assert( false );
+  }
+
+  bool analyze_chunk_up( chunk c )
+  {
+    for ( auto ii : c.input_interfaces )
+    {
+      if ( _fanouts[ii.o].back().relative_depth == _levels[ii.c] - _levels[ii.o] ) // is highest fanout
+        --c.benefits;
+    }
+
+    std::set<node> marked_oi;
+    for ( auto oi : c.output_interfaces )
+    {
+      if ( marked_oi.find( oi.c ) == marked_oi.end() )
+      {
+        marked_oi.insert( oi.c );
+        ++c.benefits;
+      }
+      auto const& fanout_info = _fanouts[oi.c];
+      if ( fanout_info.size() == 1 ) /* single fanout */
+        c.slack = std::min( c.slack, int32_t( fanout_info.front().relative_depth - 1 ) );
+      else
+        c.slack = std::min( c.slack, int32_t( _levels[oi.o] - _levels[oi.c] - 2 ) );
+    }
+
+    std::vector<uint32_t> po_to_move;
+    if ( c.po_interfaces.size() > 0 )
+    {
+      for ( auto poi : c.po_interfaces )
+      {
+        if ( _levels[poi.c] + num_splitter_levels( poi.c ) + c.slack >= _po_levels[poi.o] )
+        {
+          if ( _ps.assume.balance_cios )
+            c.slack = std::min( c.slack, int32_t( _po_levels[poi.o] - _levels[poi.c] - num_splitter_levels( poi.c ) - 1 ) );
+          else
+          {
+            c.slack = std::min( c.slack, int32_t( _depth + 1 - _po_levels[poi.o] ) );
+            po_to_move.emplace_back( poi.o );
+          }
+        }
+        else
+        {
+          if ( marked_oi.find( poi.c ) == marked_oi.end() )
+            ++c.benefits;
+        }
+      }
+    }
+
+    if ( c.benefits <= 0 || c.slack <= 0 )
+      return false;
+
+    std::vector<node> pi_members;
+    for ( auto m : c.members )
+    {
+      if ( _ntk.is_pi( m ) )
+        pi_members.emplace_back( m );
+    }
+    if ( pi_members.size() > 0 )
+    {
+      while ( c.slack > 0 )
+      {
+        bool ok = true;
+        for ( auto m : pi_members )
+        {
+          if ( !is_acceptable_ci_lvl( _levels[m] + c.slack ) )
+          {
+            ok = false;
+            break;
+          }
+        }
+        if ( !ok )
+          --c.slack;
+        else
+          break;
+      }
+    }
+    if ( po_to_move.size() > 0 )
+      c.slack -= c.slack % _ps.assume.num_phases;
+
+    if ( c.benefits > 0 && c.slack > 0 )
+    {
+      count_buffers();
+      bool legal = true;
+      auto buffers_before = num_buffers();
+
+      for ( auto m : c.members )
+        _levels[m] += c.slack;
+      for ( auto po : po_to_move )
+        _po_levels[po] += c.slack;
+      for ( auto m : c.members )
+        legal &= update_fanout_info<true>( m );
+      for ( auto ii : c.input_interfaces )
+        legal &= update_fanout_info<true>( ii.o );
+
+      _outdated = true;
+      if ( legal )
+        count_buffers();
+      if ( !legal || num_buffers() >= buffers_before )
+      {
+        /* UNDO */
+        for ( auto m : c.members )
+          _levels[m] -= c.slack;
+        for ( auto po : po_to_move )
+          _po_levels[po] -= c.slack;
+        for ( auto m : c.members )
+          update_fanout_info( m );
+        for ( auto ii : c.input_interfaces )
+          update_fanout_info( ii.o );
+        _outdated = true;
+        return false;
+      }
+
+      _start_id = _ntk.trav_id();
+      return true;
+    }
+    else
+    {
+      return false;
+    }
+  }
+#pragma endregion
+
+#pragma region Global optimal by SMT
+private:
+//#include "optimal_buffer_insertion.hpp"
+#pragma endregion
+
+private:
+  struct fanout_information
+  {
+    uint32_t relative_depth{ 0u };
+    std::list<node> fanouts;
+    std::list<uint32_t> extrefs; // IDs of POs (as in `_ntk.foreach_po`)
+    uint32_t num_edges{ 0u };
+  };
+  using fanouts_by_level = std::list<fanout_information>;
+
+  Ntk const& _ntk;
+  buffer_insertion_params _ps;
+  bool _outdated{ true };
+  bool _is_scheduled_ASAP{ true };
+
+  /* The following data structures uniquely define the state (i.e. schedule) of the algorithm/flow.
+     The rest (`_fanouts` and `_num_buffers`) are computed from these by calling `count_buffers()`. */
+  node_map<uint32_t, Ntk> _levels;
+  std::vector<uint32_t> _po_levels; // imaginary node, must be at `num_phases * k + 1`
+  uint32_t _depth{ 0u };
+
+  /* Guarantees on `_fanouts` (when not `_outdated`):
+   * - Sum of `_fanouts[n][l].fanouts.length() + _fanouts[n][l].extrefs.length()` over all `l`s
+   *   should be equal to `ntk.fanout_size( n )`.
+   * - If having only one fanout: `_fanouts[n].size() == 1`.
+   * - If having multiple fanouts: `_fanouts[n]` must have at least two elements,
+   *   and the first element must have `relative_depth == 1` and `num_edges == 1`.
+   * - If `ci_capacity > 1`, `_fanouts[PI].size()` may be 1.
+   */
+  node_map<fanouts_by_level, Ntk> _fanouts;
+  node_map<uint32_t, Ntk> _num_buffers;
+
+  node_map<std::pair<uint32_t, uint32_t>, Ntk> _timeframes; // only for SMT; the most extreme min/max
+  uint32_t _start_id; // for chunked movement
+}; /* buffer_insertion */
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/buffer_verification.hpp b/include/mockturtle/algorithms/aqfp/buffer_verification.hpp
new file mode 100644
index 0000000..ca899c8
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/buffer_verification.hpp
@@ -0,0 +1,292 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file buffer_verification.hpp
+  \brief Verify buffered networks according to AQFP constraints
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../../traits.hpp"
+#include "../../utils/node_map.hpp"
+#include "../../views/depth_view.hpp"
+#include "aqfp_assumptions.hpp"
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+template<class Ntk>
+void schedule_fanin_cone( Ntk& ntk, typename Ntk::node const& n, uint32_t l )
+{
+  if ( ntk.visited( n ) == ntk.trav_id() )
+    return;
+  ntk.set_visited( n, ntk.trav_id() );
+  ntk.set_level( n, l );
+
+  ntk.foreach_fanin( n, [&]( auto const& fi ) {
+    schedule_fanin_cone( ntk, ntk.get_node( fi ), l - 1 );
+  } );
+}
+
+template<class Ntk>
+uint32_t recompute_level( Ntk& ntk, typename Ntk::node const& n )
+{
+  if ( ntk.visited( n ) == ntk.trav_id() )
+    return ntk.level( n );
+  ntk.set_visited( n, ntk.trav_id() );
+
+  uint32_t max_fi_level{ 0u };
+  ntk.foreach_fanin( n, [&]( auto const& fi ) {
+    max_fi_level = std::max( max_fi_level, recompute_level( ntk, ntk.get_node( fi ) ) );
+  } );
+  ntk.set_level( n, max_fi_level + 1 );
+  return max_fi_level + 1;
+}
+
+} // namespace detail
+
+/*! \brief Find a reasonable level assignment for a buffered network given PI levels.
+ *
+ * \param ntk Buffered network
+ * \param pi_levels Levels of PIs
+ * \return Level assignment to all nodes
+ */
+template<class Ntk>
+node_map<uint32_t, Ntk> schedule_buffered_network_with_PI_levels( Ntk const& ntk, std::vector<uint32_t> const& pi_levels )
+{
+  assert( pi_levels.size() == ntk.num_pis() );
+
+  using node = typename Ntk::node;
+  node_map<uint32_t, Ntk> levels( ntk );
+  depth_view dv{ ntk };
+
+  ntk.incr_trav_id();
+  ntk.set_visited( ntk.get_node( ntk.get_constant( false ) ), ntk.trav_id() );
+  ntk.foreach_pi( [&]( auto const& n, auto i ) {
+    ntk.set_visited( n, ntk.trav_id() );
+    dv.set_level( n, pi_levels[i] );
+  } );
+
+  ntk.foreach_po( [&]( auto const& f ){
+    detail::recompute_level( dv, ntk.get_node( f ) );
+  });
+
+  ntk.foreach_node( [&]( auto const& n ) {
+    levels[n] = dv.level( n );
+  } );
+
+  return levels;
+}
+
+/*! \brief Verify a buffered network according to AQFP assumptions with provided level assignment.
+ *
+ * \param ntk Buffered network
+ * \param ps AQFP assumptions
+ * \param levels Level assignment for all nodes
+ * \return Whether `ntk` is path-balanced and properly-branched
+ */
+template<class Ntk>
+bool verify_aqfp_buffer( Ntk const& ntk, aqfp_assumptions_legacy const& ps, node_map<uint32_t, Ntk> const& levels )
+{
+  static_assert( is_buffered_network_type_v<Ntk>, "Ntk is not a buffered network" );
+  static_assert( has_is_buf_v<Ntk>, "Ntk does not implement the is_buf method" );
+  bool legal = true;
+
+  /* fanout branching */
+  ntk.foreach_node( [&]( auto const& n ) {
+    if ( ntk.is_constant( n ) )
+      return true;
+    if ( !ps.branch_pis && ntk.is_pi( n ) )
+      return true;
+
+    if ( ntk.is_buf( n ) )
+      legal &= ( ntk.fanout_size( n ) <= ps.splitter_capacity );
+    else /* logic gate */
+      legal &= ( ntk.fanout_size( n ) <= 1 );
+
+    return true;
+  } );
+
+  /* path balancing */
+  ntk.foreach_node( [&]( auto const& n ) {
+    ntk.foreach_fanin( n, [&]( auto const& fi ) {
+      auto ni = ntk.get_node( fi );
+      if ( !ntk.is_constant( ni ) && ( ps.balance_pis || !ntk.is_pi( ni ) ) )
+        legal &= ( levels[ni] == levels[n] - 1 );
+      assert( legal );
+    } );
+  } );
+
+  if ( ps.balance_pis )
+  {
+    ntk.foreach_pi( [&]( auto const& n ) {
+      legal &= ( levels[n] == 0 );
+    } );
+  }
+
+  if ( ps.balance_pos )
+  {
+    uint32_t depth{ 0u };
+    ntk.foreach_po( [&]( auto const& f ) {
+      auto n = ntk.get_node( f );
+      if ( !ntk.is_constant( n ) && ( ps.balance_pis || !ntk.is_pi( n ) ) )
+      {
+        if ( depth == 0u )
+          depth = levels[n];
+        else
+          legal &= ( levels[n] == depth );
+      }
+    } );
+  }
+
+  return legal;
+}
+
+/*! \brief Verify a buffered network according to AQFP assumptions with provided level assignment.
+ *
+ * \param ntk Buffered network
+ * \param ps AQFP assumptions
+ * \param levels Level assignment for all nodes
+ * \return Whether `ntk` is path-balanced and properly-branched
+ */
+template<class Ntk>
+bool verify_aqfp_buffer( Ntk const& ntk, aqfp_assumptions_realistic const& ps, node_map<uint32_t, Ntk> const& levels )
+{
+  static_assert( is_buffered_network_type_v<Ntk>, "Ntk is not a buffered network" );
+  static_assert( has_is_buf_v<Ntk>, "Ntk does not implement the is_buf method" );
+  bool legal = true;
+
+  /* fanout branching */
+  ntk.foreach_node( [&]( auto const& n ) {
+    if ( ntk.is_constant( n ) )
+      return;
+    if ( ntk.is_pi( n ) )
+    {
+      legal &= ( ntk.fanout_size( n ) <= ps.ci_capacity );
+    }
+    else if ( ntk.is_buf( n ) )
+    {
+      legal &= ( ntk.fanout_size( n ) <= ps.splitter_capacity );
+    }
+    else /* logic gate */
+    {
+      legal &= ( ntk.fanout_size( n ) <= 1 );
+    }
+    assert( legal );
+  } );
+
+  /* path balancing */
+  ntk.foreach_node( [&]( auto const& n ) {
+    ntk.foreach_fanin( n, [&]( auto const& fi ) {
+      auto ni = ntk.get_node( fi );
+      if ( !ntk.is_constant( ni ) )
+        legal &= ( levels[ni] == levels[n] - 1 );
+      assert( legal );
+    } );
+  } );
+
+  if ( ps.balance_cios )
+  {
+    auto const check_pi_fn = [&]( uint32_t level ){
+      for ( auto const& p : ps.ci_phases )
+      {
+        if ( level == p )
+          return true;
+      }
+      return false;
+    };
+
+    ntk.foreach_pi( [&]( auto const& n ) {
+      legal &= check_pi_fn( levels[n] );
+      assert( legal );
+    } );
+
+    uint32_t depth{ 0u };
+    ntk.foreach_po( [&]( auto const& f ) {
+      auto n = ntk.get_node( f );
+      if ( !ntk.is_constant( n ) )
+      {
+        if ( depth == 0u )
+          depth = levels[n];
+        else
+          legal &= ( levels[n] == depth );
+        assert( legal );
+      }
+    } );
+    legal &= ( depth % ps.num_phases == 0 );
+    assert( legal );
+  }
+  else
+  {
+    auto const check_pi_fn = [&]( uint32_t level ){
+      for ( auto const& p : ps.ci_phases )
+      {
+        if ( level >= p && ( level - p ) % ps.num_phases == 0 )
+          return true;
+      }
+      return false;
+    };
+
+    ntk.foreach_pi( [&]( auto const& n ) {
+      legal &= check_pi_fn( levels[n] );
+      assert( legal );
+    } );
+
+    ntk.foreach_po( [&]( auto const& f ) {
+      auto n = ntk.get_node( f );
+      if ( !ntk.is_constant( n ) )
+      {
+        legal &= ( levels[n] % ps.num_phases == 0 );
+        assert( legal );
+      }
+    } );
+  }
+
+  // TODO: max_phase_skip
+
+  return legal;
+}
+
+/*! \brief Verify a buffered network according to AQFP assumptions with provided PI level assignment.
+ *
+ * \param ntk Buffered network
+ * \param ps AQFP assumptions
+ * \param pi_levels Levels of PIs
+ * \return Whether `ntk` is path-balanced, phase-aligned, and properly-branched
+ */
+template<class Ntk, typename Asmp = aqfp_assumptions>
+bool verify_aqfp_buffer( Ntk const& ntk, Asmp const& ps, std::vector<uint32_t> const& pi_levels )
+{
+  auto const levels = schedule_buffered_network_with_PI_levels( ntk, pi_levels );
+  return verify_aqfp_buffer( ntk, ps, levels );
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/detail/dag.hpp b/include/mockturtle/algorithms/aqfp/detail/dag.hpp
new file mode 100644
index 0000000..e35bc9d
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/detail/dag.hpp
@@ -0,0 +1,159 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file dag.hpp
+  \brief AQFP DAG data structure
+
+  \author Dewmini Sudara Marakkalage
+*/
+
+#pragma once
+
+#include <sstream>
+#include <vector>
+
+#include <fmt/format.h>
+
+namespace mockturtle
+{
+
+/*! \brief Represents a single-output connected Partial DAG or DAG.
+ *
+ * A partial DAG is a network with majority gates where some gates may have unconnected fanin slots.
+ * A DAG is a network with majority gates obtained from a partial DAG by specifying which
+ * unconnected fanin slots connect to the same primary input.
+ * Optionally, a DAG may designate which fanin slots are connected the constant 0.
+ * Unlike logic networks elsewhere in mockturtle, gates are numbered from 0 starting from the top gate.
+ */
+template<typename NodeT = int>
+struct aqfp_dag
+{
+  using node_type = NodeT;
+
+  std::vector<std::vector<NodeT>> nodes; // fanins of nodes
+  std::vector<NodeT> input_slots;        // identifiers of the input slots (bundles of fanins where the inputs will be connected)
+  NodeT zero_input = 0;                  // id of the input slot that is connected to constant 0
+
+  aqfp_dag( const std::vector<std::vector<NodeT>>& nodes = {}, const std::vector<NodeT>& input_slots = {}, node_type zero_input = {} )
+      : nodes( nodes ), input_slots( input_slots ), zero_input( zero_input ) {}
+
+  aqfp_dag( const std::string& str )
+  {
+    decode_from_string( str );
+  }
+
+  /*! \brief Compare to logical networks for equality. */
+  bool operator==( const aqfp_dag& rhs ) const
+  {
+    if ( nodes.size() != rhs.nodes.size() )
+      return false;
+
+    for ( auto i = 0u; i < nodes.size(); i++ )
+    {
+      auto x1 = nodes[i];
+      auto x2 = rhs.nodes[i];
+      std::stable_sort( x1.begin(), x1.end() );
+      std::stable_sort( x2.begin(), x2.end() );
+      if ( x1 != x2 )
+        return false;
+    }
+
+    auto y1 = input_slots;
+    auto y2 = rhs.input_slots;
+    std::stable_sort( y1.begin(), y1.end() );
+    std::stable_sort( y2.begin(), y2.end() );
+    if ( y1 != y2 )
+      return false;
+
+    if ( zero_input != rhs.zero_input )
+      return false;
+
+    return true;
+  }
+
+  /*! \brief Return the number of majority gates. */
+  uint32_t num_gates() const
+  {
+    return nodes.size() - input_slots.size();
+  }
+
+  /*! \brief Decode a string representation of a DAG into a DAG.
+   *
+   * Format: ng ni zi k0 g0f0 g0f1 .. g0fk0 k1 g1f0 g1f1 .. g1fk1 ....
+   * ng := num gates, ni := num inputs, zi := zero input, ki := num fanin of i-th gate, gifj = j-th fanin of i-th gate
+   */
+  void decode_from_string( const std::string& str )
+  {
+    std::istringstream iss( str );
+    auto ng = 0u;
+    auto ni = 0u;
+    auto zi = 0u;
+
+    iss >> ng >> ni >> zi;
+    zero_input = zi;
+
+    std::vector<uint32_t> level( ng + ni, 0u );
+    for ( auto i = 0u; i < ng; i++ )
+    {
+      auto nf = 0u;
+      iss >> nf;
+
+      nodes.push_back( {} );
+
+      for ( auto j = 0u; j < nf; j++ )
+      {
+        auto t = 0u;
+        iss >> t;
+        nodes[i].push_back( t );
+      }
+    }
+
+    for ( auto i = 0u; i < ni; i++ )
+    {
+      nodes.push_back( {} );
+      input_slots.push_back( nodes.size() - 1 );
+    }
+  }
+
+  /*! \brief Encode a DAG as a string.
+   *
+   * Format: ng ni zi k0 g0f0 g0f1 .. g0fk0 k1 g1f0 g1f1 .. g1fk1 ....
+   * ng := num gates, ni := num inputs, zi := zero input, ki := num fanin of i-th gate, gifj = j-th fanin of i-th gate
+   */
+  std::string encode_as_string() const
+  {
+    std::stringstream ss;
+    ss << num_gates() << " " << input_slots.size() << " " << zero_input;
+    for ( auto i = 0u; i < num_gates(); i++ )
+    {
+      ss << fmt::format( " {} {}", nodes[i].size(), fmt::join( nodes[i], " " ) );
+    }
+
+    return ss.str();
+  }
+};
+
+} // namespace mockturtle
diff --git a/include/mockturtle/algorithms/aqfp/detail/dag_cost.hpp b/include/mockturtle/algorithms/aqfp/detail/dag_cost.hpp
new file mode 100644
index 0000000..7c9de61
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/detail/dag_cost.hpp
@@ -0,0 +1,508 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file dag_cost.hpp
+  \brief Cost computing functions for AQFP DAG structures
+
+  \author Dewmini Sudara Marakkalage
+*/
+
+#pragma once
+
+#include <limits>
+#include <unordered_map>
+#include <vector>
+
+#include "../../../properties/aqfpcost.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Cost function for dag structures that compute the gate cost. */
+template<typename Ntk>
+class dag_gate_cost
+{
+public:
+  dag_gate_cost( const std::unordered_map<uint32_t, double>& gate_costs ) : gate_costs( gate_costs ) {}
+
+  double operator()( const Ntk& net )
+  {
+    double res = 0.0;
+
+    for ( const auto& node : net.nodes )
+    {
+      if ( !node.empty() )
+        res += gate_costs.at( node.size() );
+    }
+
+    return res;
+  }
+
+private:
+  std::unordered_map<uint32_t, double> gate_costs;
+};
+
+/*! \brief Cost function for dag structures that compute the gate and path balancing cost. */
+template<typename Ntk>
+class dag_aqfp_cost
+{
+public:
+  static constexpr double IMPOSSIBLE = std::numeric_limits<double>::infinity();
+
+  using depth_config_t = uint64_t;
+
+  dag_aqfp_cost( const std::unordered_map<uint32_t, double>& gate_costs, const std::unordered_map<uint32_t, double>& splitters )
+      : simp_cc( gate_costs ), fanout_cc( splitters ) {}
+
+  /*! \brief Compute cost assuming all primary inputs are at the same depth. */
+  double operator()( const Ntk& orig_net )
+  {
+    net = orig_net;
+    fanout = std::vector<std::vector<typename Ntk::node_type>>( net.nodes.size() );
+    minlev = std::vector<uint32_t>( net.nodes.size() );
+    maxlev = std::vector<uint32_t>( net.nodes.size() );
+    curlev = std::vector<uint32_t>( net.nodes.size() );
+
+    compute_fanouts( net, fanout );
+    compute_min_levels( net, fanout, minlev );
+
+    // perform depth bounded search
+    double cost = IMPOSSIBLE;
+
+    auto lastlev = *( std::max_element( minlev.begin(), minlev.end() ) );
+    while ( true )
+    {
+      compute_max_levels( net, fanout, maxlev, lastlev );
+
+      // fix levels for the root and the inputs
+      maxlev[0] = 0;
+      for ( auto f : net.input_slots )
+      {
+        if ( f != net.zero_input )
+        {
+          minlev[f] = lastlev;
+        }
+      }
+
+      // check different level configurations for the other gates and compute the cost for buffers and splitters
+      cost = compute_best_cost( 1u, 0.0 );
+
+      if ( cost < IMPOSSIBLE )
+      {
+        break;
+      }
+
+      lastlev++;
+    }
+
+    // add the gate costs
+    cost += simp_cc( net );
+
+    return cost;
+  }
+
+protected:
+  dag_gate_cost<Ntk> simp_cc;
+  fanout_net_cost fanout_cc;
+
+  Ntk net;
+  std::vector<std::vector<typename Ntk::node_type>> fanout;
+  std::vector<uint32_t> minlev;
+  std::vector<uint32_t> maxlev;
+  std::vector<uint32_t> curlev;
+
+  template<typename FanOutT>
+  void compute_fanouts( const Ntk& net, FanOutT& fanout )
+  {
+    for ( auto i = 0u; i < net.nodes.size(); i++ )
+    {
+      for ( auto&& f : net.nodes[i] )
+      {
+        if ( net.zero_input != f )
+        {
+          fanout[f].push_back( i );
+        }
+      }
+    }
+  }
+
+  template<typename FanOutT, typename MinLevT>
+  void compute_min_levels( const Ntk& net, const FanOutT& fanout, MinLevT& minlev )
+  {
+    for ( auto i = 0u; i < net.nodes.size(); i++ )
+    {
+      if ( fanout[i].size() == 0u )
+      {
+        minlev[i] = 0u;
+      }
+      else
+      {
+        auto critical_fo = *( std::max_element( fanout[i].begin(), fanout[i].end(),
+                                                [&]( auto x, auto y ) { return ( minlev[x] < minlev[y] ); } ) );
+        minlev[i] = 1 + minlev[critical_fo];
+        if ( fanout[i].size() > 1 )
+        {
+          minlev[i]++;
+        }
+      }
+    }
+  }
+
+  template<typename FanOutT, typename MaxLevT>
+  void compute_max_levels( const Ntk& net, const FanOutT& fanout, MaxLevT& maxlev, uint32_t lastlev )
+  {
+    for ( auto& f : net.input_slots )
+    {
+      if ( f != net.zero_input )
+      {
+        maxlev[f] = lastlev;
+      }
+      else
+      {
+        maxlev[f] = std::numeric_limits<uint32_t>::max();
+      }
+    }
+
+    for ( auto i = net.num_gates(); i > 0u; i-- )
+    {
+      maxlev[i - 1] = std::numeric_limits<uint32_t>::max();
+      for ( auto f : net.nodes[i - 1] )
+      {
+        auto t = maxlev[f] - 1;
+        if ( fanout[f].size() > 1 )
+        {
+          t--;
+        }
+        if ( t < maxlev[i - 1] )
+        {
+          maxlev[i - 1] = t;
+        }
+      }
+    }
+  }
+
+  double cost_for_node_if_in_level( uint32_t lev, std::vector<typename Ntk::node_type> fanouts )
+  {
+    std::vector<uint32_t> rellev;
+    for ( auto fo : fanouts )
+    {
+      rellev.push_back( lev - curlev[fo] );
+    }
+    std::stable_sort( rellev.begin(), rellev.end() );
+
+    return fanout_cc( rellev );
+  }
+
+  double compute_best_cost( uint32_t current_gid, double cost_so_far )
+  {
+    if ( net.num_gates() == current_gid )
+    {
+      for ( auto f : net.input_slots )
+      {
+        if ( ( f == net.zero_input ) || fanout[f].empty() )
+        {
+          continue;
+        }
+
+        cost_so_far += cost_for_node_if_in_level( maxlev[f], fanout[f] );
+
+        if ( cost_so_far >= IMPOSSIBLE )
+        {
+          return IMPOSSIBLE;
+        }
+      }
+
+      return cost_so_far;
+    }
+
+    auto result = IMPOSSIBLE;
+    for ( auto lev = minlev[current_gid]; lev <= maxlev[current_gid]; lev++ )
+    {
+      auto cost = cost_for_node_if_in_level( lev, fanout[current_gid] );
+      if ( cost >= IMPOSSIBLE )
+      {
+        continue;
+      }
+      curlev[current_gid] = lev;
+      auto temp = compute_best_cost( current_gid + 1, cost_so_far + cost );
+      if ( temp < result )
+      {
+        result = temp;
+      }
+    }
+
+    return result;
+  }
+};
+
+/*! \brief Compute cost together with the depth assignment to nodes for a given input depth configuration. */
+template<typename Ntk>
+class dag_aqfp_cost_and_depths : public dag_aqfp_cost<Ntk>
+{
+public:
+  static constexpr double IMPOSSIBLE = std::numeric_limits<double>::infinity();
+
+  using dag_aqfp_cost<Ntk>::simp_cc;
+  using dag_aqfp_cost<Ntk>::fanout_cc;
+  using dag_aqfp_cost<Ntk>::net;
+  using dag_aqfp_cost<Ntk>::fanout;
+  using dag_aqfp_cost<Ntk>::minlev;
+  using dag_aqfp_cost<Ntk>::maxlev;
+  using dag_aqfp_cost<Ntk>::curlev;
+  using dag_aqfp_cost<Ntk>::compute_fanouts;
+  using dag_aqfp_cost<Ntk>::compute_min_levels;
+  using dag_aqfp_cost<Ntk>::compute_max_levels;
+  using dag_aqfp_cost<Ntk>::cost_for_node_if_in_level;
+
+  dag_aqfp_cost_and_depths( const std::unordered_map<uint32_t, double>& gate_costs, const std::unordered_map<uint32_t, double>& splitters )
+      : dag_aqfp_cost<Ntk>( gate_costs, splitters ) {}
+
+  std::pair<double, std::vector<uint32_t>> operator()( const Ntk& orig_net, const std::vector<uint32_t>& input_depths )
+  {
+    net = orig_net;
+    fanout = std::vector<std::vector<typename Ntk::node_type>>( net.nodes.size() );
+    minlev = std::vector<uint32_t>( net.nodes.size() );
+    maxlev = std::vector<uint32_t>( net.nodes.size() );
+    curlev = std::vector<uint32_t>( net.nodes.size() );
+
+    compute_fanouts( net, fanout );
+    compute_min_levels( net, fanout, minlev );
+    compute_max_levels( net, fanout, maxlev, input_depths );
+
+    uint32_t ind = 0u;
+
+    // fix levels for the root and the inputs
+    maxlev[0] = 0;
+    ind = 0u;
+    for ( auto f : net.input_slots )
+    {
+      if ( f != net.zero_input )
+      {
+        minlev[f] = input_depths[ind++];
+      }
+    }
+
+    // check different level configurations for the other gates and compute the cost for buffers and splitters
+    auto [cost, levels] = compute_best_cost_and_levels( 1u, 0.0 );
+
+    // add the gate costs
+    cost += simp_cc( net );
+
+    return { cost, levels };
+  }
+
+private:
+  template<typename FanOutT, typename MaxLevT>
+  void compute_max_levels( const Ntk& net, const FanOutT& fanout, MaxLevT& maxlev, std::vector<uint32_t> input_depths )
+  {
+    uint32_t ind = 0u;
+    for ( auto& f : net.input_slots )
+    {
+      if ( f != net.zero_input )
+      {
+        maxlev[f] = input_depths[ind++];
+      }
+      else
+      {
+        maxlev[f] = std::numeric_limits<uint32_t>::max();
+      }
+    }
+
+    for ( auto i = net.num_gates(); i > 0u; i-- )
+    {
+      maxlev[i - 1] = std::numeric_limits<uint32_t>::max();
+      for ( auto f : net.nodes[i - 1] )
+      {
+        auto t = maxlev[f] - 1;
+        if ( fanout[f].size() > 1 )
+        {
+          t--;
+        }
+        if ( t < maxlev[i - 1] )
+        {
+          maxlev[i - 1] = t;
+        }
+      }
+    }
+  }
+
+  std::tuple<double, std::vector<uint32_t>> compute_best_cost_and_levels( uint32_t current_gid, double cost_so_far )
+  {
+    if ( net.num_gates() == current_gid )
+    {
+      for ( auto f : net.input_slots )
+      {
+        if ( ( f == net.zero_input ) || fanout[f].empty() )
+        {
+          continue;
+        }
+
+        curlev[f] = maxlev[f];
+        cost_so_far += cost_for_node_if_in_level( maxlev[f], fanout[f] );
+
+        if ( cost_so_far >= IMPOSSIBLE )
+        {
+          return { IMPOSSIBLE, {} };
+        }
+      }
+
+      return { cost_so_far, curlev };
+    }
+
+    double res_cost = IMPOSSIBLE;
+    std::vector<uint32_t> res_lev = {};
+    for ( auto lev = minlev[current_gid]; lev <= maxlev[current_gid]; lev++ )
+    {
+      auto cost = cost_for_node_if_in_level( lev, fanout[current_gid] );
+      if ( cost >= IMPOSSIBLE )
+      {
+        continue;
+      }
+      curlev[current_gid] = lev;
+      auto [temp_cost, temp_lev] = compute_best_cost_and_levels( current_gid + 1, cost_so_far + cost );
+      if ( temp_cost < res_cost )
+      {
+        res_cost = temp_cost;
+        res_lev = temp_lev;
+      }
+    }
+
+    return { res_cost, res_lev };
+  }
+};
+
+/*! \brief Compute costs for different input depth configurations. */
+template<typename Ntk>
+class dag_aqfp_cost_all_configs : public dag_aqfp_cost<Ntk>
+{
+public:
+  static constexpr double IMPOSSIBLE = std::numeric_limits<double>::infinity();
+
+  using depth_config_t = uint64_t; // each byte encodes a depth of a primary input
+
+  using dag_aqfp_cost<Ntk>::simp_cc;
+  using dag_aqfp_cost<Ntk>::fanout_cc;
+  using dag_aqfp_cost<Ntk>::net;
+  using dag_aqfp_cost<Ntk>::fanout;
+  using dag_aqfp_cost<Ntk>::minlev;
+  using dag_aqfp_cost<Ntk>::maxlev;
+  using dag_aqfp_cost<Ntk>::curlev;
+  using dag_aqfp_cost<Ntk>::compute_fanouts;
+  using dag_aqfp_cost<Ntk>::compute_min_levels;
+  using dag_aqfp_cost<Ntk>::compute_max_levels;
+  using dag_aqfp_cost<Ntk>::cost_for_node_if_in_level;
+
+  dag_aqfp_cost_all_configs( const std::unordered_map<uint32_t, double>& gate_costs, const std::unordered_map<uint32_t, double>& splitters )
+      : dag_aqfp_cost<Ntk>( gate_costs, splitters ) {}
+
+  std::unordered_map<depth_config_t, double> operator()( const Ntk& orig_net )
+  {
+    std::unordered_map<depth_config_t, double> config_cost;
+    net = orig_net;
+    fanout = std::vector<std::vector<typename Ntk::node_type>>( net.nodes.size() );
+    minlev = std::vector<uint32_t>( net.nodes.size() );
+    maxlev = std::vector<uint32_t>( net.nodes.size() );
+    curlev = std::vector<uint32_t>( net.nodes.size() );
+
+    compute_fanouts( net, fanout );
+    compute_min_levels( net, fanout, minlev );
+
+    auto lastlev = *( std::max_element( minlev.begin(), minlev.end() ) );
+    while ( true )
+    {
+      compute_max_levels( net, fanout, maxlev, lastlev );
+
+      // fix levels for the root and the inputs
+      maxlev[0] = 0;
+
+      // check different level configurations for the other gates and compute the cost for buffers and splitters
+      compute_best_costs_for_all_configs( 1u, 0.0, config_cost );
+
+      if ( config_cost.size() > 0 )
+      {
+        break;
+      }
+
+      lastlev++;
+    }
+
+    double cost_for_gates = simp_cc( net );
+
+    for ( auto it = config_cost.begin(); it != config_cost.end(); it++ )
+    {
+      it->second += cost_for_gates;
+    }
+
+    return config_cost;
+  }
+
+private:
+  void compute_best_costs_for_all_configs( uint32_t current_gid, double cost_so_far, std::unordered_map<depth_config_t, double>& config_cost )
+  {
+    if ( net.nodes.size() == current_gid )
+    {
+      depth_config_t depth_config = 0u;
+      uint32_t ind = 0;
+      for ( auto f : net.input_slots )
+      {
+        if ( f == net.zero_input )
+        {
+          continue;
+        }
+
+        depth_config |= ( curlev[f] << ( 8 * ind ) );
+        ind++;
+      }
+
+      if ( !config_cost.count( depth_config ) )
+      {
+        config_cost[depth_config] = IMPOSSIBLE;
+      }
+
+      config_cost[depth_config] = std::min( config_cost[depth_config], cost_so_far );
+      return;
+    }
+
+    if ( net.zero_input == (typename Ntk::node_type)current_gid )
+    {
+      compute_best_costs_for_all_configs( current_gid + 1, cost_so_far, config_cost );
+      return;
+    }
+
+    for ( auto lev = minlev[current_gid]; lev <= maxlev[current_gid]; lev++ )
+    {
+      auto cost = cost_for_node_if_in_level( lev, fanout[current_gid] );
+      if ( cost >= IMPOSSIBLE )
+      {
+        continue;
+      }
+      curlev[current_gid] = lev;
+      compute_best_costs_for_all_configs( current_gid + 1, cost_so_far + cost, config_cost );
+    }
+  }
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/detail/dag_gen.hpp b/include/mockturtle/algorithms/aqfp/detail/dag_gen.hpp
new file mode 100644
index 0000000..4ad384e
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/detail/dag_gen.hpp
@@ -0,0 +1,389 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file dag_gen.hpp
+  \brief AQFP DAG generation
+
+  \author Dewmini Sudara Marakkalage
+*/
+
+#pragma once
+
+#include <iostream>
+#include <limits>
+#include <mutex>
+#include <queue>
+#include <set>
+#include <stack>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include <fmt/format.h>
+
+#include "dag.hpp"
+#include "dag_util.hpp"
+#include "partial_dag.hpp"
+
+namespace mockturtle
+{
+
+using part = std::multiset<int>;
+using partition = std::multiset<part>;
+using partition_set = std::set<partition>;
+
+struct dag_generator_params
+{
+
+  uint32_t max_gates;      // max number of gates allowed
+  uint32_t max_levels;     // max number of gate levels
+  uint32_t max_num_in;     // max number of primary input slots (including the constant)
+  uint32_t max_num_fanout; // max number of fanouts per gate
+  uint32_t max_width;      // max number of gates in any given level
+
+  std::vector<uint32_t> allowed_num_fanins;                  // the types of allowed majority gates
+  std::unordered_map<uint32_t, uint32_t> max_gates_of_fanin; // max number of gates allowed for each type
+
+  uint32_t verbose;
+
+  dag_generator_params() : max_gates( std::numeric_limits<uint32_t>::max() ),
+                           max_levels( std::numeric_limits<uint32_t>::max() ),
+                           max_num_in( std::numeric_limits<uint32_t>::max() ),
+                           max_num_fanout( std::numeric_limits<uint32_t>::max() ),
+                           max_width( std::numeric_limits<uint32_t>::max() ),
+                           allowed_num_fanins( { 3u } ),
+                           max_gates_of_fanin( { { 3u, std::numeric_limits<uint32_t>::max() } } ),
+                           verbose( 0u ) {}
+};
+
+/*! \brief Generate all DAGs derived from a given partial DAG. */
+template<typename NodeT = int>
+class dags_from_partial_dag
+{
+  using PartialNtk = aqfp_partial_dag<NodeT>;
+  using Ntk = aqfp_dag<NodeT>;
+
+public:
+  dags_from_partial_dag( uint32_t max_num_in, uint32_t max_num_fanout ) : max_num_in( max_num_in ), max_num_fanout( max_num_fanout ) {}
+
+  std::vector<Ntk> operator()( const PartialNtk& net )
+  {
+    std::vector<NodeT> leaves = net.last_layer_leaves;
+    leaves.insert( leaves.end(), net.other_leaves.begin(), net.other_leaves.end() );
+    std::stable_sort( leaves.begin(), leaves.end() );
+
+    auto max_counts = net.max_equal_fanins();
+
+    auto partitions = partition_gen( leaves, max_counts, max_num_in + 1, max_num_fanout );
+
+    std::vector<Ntk> result;
+    for ( auto p : partitions )
+    {
+      auto new_net = get_dag_for_partition( net, p );
+
+      if ( net.input_slots.size() <= max_num_in )
+      {
+        result.push_back( new_net );
+      }
+
+      int i = 0;
+      for ( auto it = p.begin(); it != p.end(); )
+      {
+        auto temp_net = new_net;
+        temp_net.zero_input = new_net.input_slots[i];
+        result.push_back( temp_net );
+        auto c = p.count( *it );
+        i += c;
+        std::advance( it, c );
+      }
+    }
+
+    return result;
+  }
+
+private:
+  uint32_t max_num_in;
+  uint32_t max_num_fanout;
+  detail::partition_generator<NodeT> partition_gen;
+
+  /**
+   * \brief Compute the DAG obtained from partial DAG `orig` by combining slots
+   * according to partitions `p`.
+   */
+  Ntk get_dag_for_partition( const PartialNtk& orig, const partition& p )
+  {
+    auto net = orig.copy_without_leaves();
+    std::for_each( p.begin(), p.end(), [&net]( const auto& q ) { net.add_leaf_node( q ); } );
+    return std::move( net );
+  }
+};
+
+#if !__clang__ || __clang_major__ > 10
+
+/*! \brief Generate all DAGs satisfying the parameters. */
+template<typename NodeT = int>
+class dag_generator
+{
+  using PartialNtk = aqfp_partial_dag<NodeT>;
+
+public:
+  dag_generator( const dag_generator_params& params, uint32_t num_threads = 1u ) : params( params ), num_threads( num_threads ) {}
+
+  template<typename Fn>
+  void for_each_dag( Fn&& callback )
+  {
+    if ( params.verbose > 0u )
+    {
+      std::cerr << fmt::format( "Generating partial dags.\n" );
+    }
+
+    generate_all_partial_dags();
+
+    if ( params.verbose > 0u )
+    {
+      std::cerr << fmt::format( "Generated {} partial dags.\n", partial_dags.size() );
+      std::cerr << fmt::format( "Generating dags in {} threads...\n", num_threads );
+    }
+
+    std::vector<std::thread> threads;
+    std::mutex mu;
+    for ( auto i = 0u; i < num_threads; i++ )
+    {
+      threads.emplace_back(
+          [&]( auto id ) {
+            dags_from_partial_dag<NodeT> dag_from_pdag( params.max_num_in, params.max_num_fanout );
+            while ( true )
+            {
+              mu.lock();
+              if ( partial_dags.empty() )
+              {
+                mu.unlock();
+                return;
+              }
+              auto p = partial_dags.front();
+              partial_dags.pop();
+              mu.unlock();
+              auto dags = dag_from_pdag( p );
+              for ( const auto& dag : dags )
+              {
+                callback( dag, id );
+              }
+            }
+          },
+          i );
+    }
+
+    for ( auto i = 0u; i < num_threads; i++ )
+    {
+      threads[i].join();
+    }
+  }
+
+private:
+  dag_generator_params params;
+  uint32_t num_threads;
+
+  std::queue<PartialNtk> partial_dags;
+
+  detail::partition_generator<NodeT> partition_gen;
+  detail::partition_extender<NodeT> partition_ext;
+  detail::sublist_generator<NodeT> sublist_gen;
+
+  void generate_all_partial_dags()
+  {
+    std::stack<PartialNtk> stk;
+
+    for ( auto&& fin : params.allowed_num_fanins )
+    {
+      if ( params.max_gates_of_fanin.at( fin ) > 0 )
+      {
+        auto root = PartialNtk::get_root( fin );
+        stk.push( root );
+      }
+    }
+
+    while ( !stk.empty() )
+    {
+      auto res = stk.top();
+      stk.pop();
+
+      partial_dags.push( res );
+
+      if ( params.max_levels > res.num_levels )
+      {
+        auto ext = get_layer_extension( res );
+        for ( const auto& e : ext )
+        {
+          stk.push( e );
+        }
+      }
+    }
+  }
+
+  /*! \brief Extend the current aqfp logical network by one more level. */
+  std::vector<PartialNtk> get_layer_extension( const PartialNtk& net )
+  {
+    std::vector<PartialNtk> result;
+
+    auto max_counts = net.max_equal_fanins();
+
+    auto last_options = sublist_gen( net.last_layer_leaves );
+    auto other_options = sublist_gen( net.other_leaves );
+
+    auto last_counts = detail::get_frequencies( net.last_layer_leaves );
+    auto other_counts = detail::get_frequencies( net.other_leaves );
+
+    auto net_without_leaves = net.copy_without_leaves();
+
+    /* Consider all different ways of choosing a non-empty subset of last layer slots */
+    for ( auto&& last : last_options )
+    {
+      if ( last.empty() )
+        continue;
+
+      /* Remaining slots in the last layer */
+      auto last_counts_cpy = last_counts;
+      for ( auto&& e : last )
+      {
+        last_counts_cpy[e]--;
+      }
+
+      /* Consider all different ways of choosing a subset of other layer slots */
+      for ( auto&& other : other_options )
+      {
+
+        /* Remaining slots in the other layers */
+        auto other_counts_cpy = other_counts;
+        for ( auto&& e : other )
+        {
+          other_counts_cpy[e]--;
+        }
+
+        /* Compute the new set of other leaves for all resulting partial DAGs */
+        std::vector<int> other_leaves_new;
+        for ( auto it = last_counts_cpy.begin(); it != last_counts_cpy.end(); it++ )
+        {
+          for ( auto i = 0u; i < it->second; i++ )
+          {
+            other_leaves_new.push_back( it->first );
+          }
+        }
+        for ( auto it = other_counts_cpy.begin(); it != other_counts_cpy.end(); it++ )
+        {
+          for ( auto i = 0u; i < it->second; i++ )
+          {
+            other_leaves_new.push_back( it->first );
+          }
+        }
+
+        if ( params.max_gates == 0 || params.max_gates > net_without_leaves.num_gates() )
+        {
+          auto max_gates = params.max_gates > 0u ? params.max_gates - net_without_leaves.num_gates() : 0u;
+          auto last_layers_partitions = partition_gen( last, max_counts, max_gates, params.max_num_fanout );
+
+          for ( auto p : last_layers_partitions )
+          {
+            auto extensions = partition_ext( other, p, max_counts, params.max_num_fanout );
+            for ( auto q : extensions )
+            {
+              auto temp = get_next_partial_dags( net_without_leaves, q, other_leaves_new );
+              for ( auto&& r : temp )
+              {
+                r.num_levels++;
+                result.push_back( r );
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /*! \brief Compute the partial DAGs obtained by combining the slots of `orig` as indicated by
+   *  partitioning 'p'.
+   */
+  std::vector<PartialNtk> get_next_partial_dags( const PartialNtk& orig, const partition& p, const std::vector<int>& other_leaves )
+  {
+    auto max_allowed_of_fanin = params.max_gates_of_fanin;
+    for ( auto it = orig.num_gates_of_fanin.begin(); it != orig.num_gates_of_fanin.end(); it++ )
+    {
+      assert( max_allowed_of_fanin[it->first] >= it->second );
+      max_allowed_of_fanin[it->first] -= it->second;
+    }
+
+    std::vector<part> q( p.begin(), p.end() );
+
+    /* For each part in partition 'p', consider gates of different number of fanins to connect. */
+    auto res = add_node_recur( orig, q, 0, max_allowed_of_fanin );
+
+    for ( auto&& net : res )
+    {
+      net.other_leaves = other_leaves;
+    }
+
+    return res;
+  }
+
+  /*! \brief Recursively consider gates with different number of fanins for different parts in partition `p`. */
+  std::vector<PartialNtk> add_node_recur( const PartialNtk& orig, const std::vector<part>& p, uint32_t ind, std::unordered_map<uint32_t, uint32_t>& max_allowed_of_fanin )
+  {
+    if ( ind == p.size() )
+    {
+      return { orig };
+    }
+
+    std::vector<PartialNtk> res;
+
+    /* Decide what fanin gate to use for part in partition 'p' at index 'ind'. */
+    for ( auto&& fin : params.allowed_num_fanins )
+    {
+      if ( max_allowed_of_fanin[fin] == 0 )
+      {
+        continue;
+      }
+      max_allowed_of_fanin[fin]--;
+
+      auto temp = add_node_recur( orig, p, ind + 1, max_allowed_of_fanin );
+
+      for ( const auto& t : temp )
+      {
+        auto net = t.copy_with_last_layer_leaves();
+        net.add_internal_node( fin, p[ind], true );
+        res.push_back( net );
+      }
+
+      max_allowed_of_fanin[fin]++;
+    }
+
+    return res;
+  }
+};
+
+#endif
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/detail/dag_util.hpp b/include/mockturtle/algorithms/aqfp/detail/dag_util.hpp
new file mode 100644
index 0000000..ec4b95c
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/detail/dag_util.hpp
@@ -0,0 +1,316 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file dag_util.hpp
+  \brief Utilities for DAG generation
+
+  \author Dewmini Sudara Marakkalage
+*/
+
+#pragma once
+
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <vector>
+
+#include "../../../utils/hash_functions.hpp"
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+/*! \brief Computes and returns the frequency map for a given collection of elements.
+ *  Use std::map instead of std::unordered_map because we use it as a key in a hash-table so the order is important to compute the hash
+ */
+template<typename ElemT>
+inline std::map<ElemT, uint32_t> get_frequencies( const std::vector<ElemT>& elems )
+{
+  std::map<ElemT, uint32_t> elem_counts;
+  std::for_each( elems.begin(), elems.end(), [&elem_counts]( auto e ) { elem_counts[e]++; } );
+  return elem_counts;
+}
+
+template<typename ElemT>
+class partition_generator
+{
+  using part = std::multiset<ElemT>;
+  using partition = std::multiset<part>;
+  using partition_set = std::set<partition>;
+
+  using inner_cache_key_t = std::vector<ElemT>;
+  using inner_cache_t = std::unordered_map<inner_cache_key_t, partition_set, hash<inner_cache_key_t>>;
+
+  using outer_cache_key_t = std::tuple<std::vector<uint32_t>, uint32_t, uint32_t>;
+  using outer_cache_t = std::unordered_map<outer_cache_key_t, inner_cache_t, hash<outer_cache_key_t>>;
+
+public:
+  /*! \brief Computes and returns a set of partitions for a given list of elements
+   * such that no part contains any element `e` more than `max_counts[e]` times.
+   */
+  partition_set operator()(
+      std::vector<int> elems,
+      const std::vector<uint32_t>& max_counts = {},
+      uint32_t max_parts = 0,
+      uint32_t max_part_size = 0 )
+  {
+    _elems = elems;
+    _max_counts = max_counts;
+    _max_parts = max_parts;
+    _max_part_size = max_part_size;
+
+    const outer_cache_key_t key = { _max_counts, _max_parts, _max_part_size };
+    partition_cache = outer_cache.insert( { key, inner_cache_t() } ).first;
+
+    return get_all_partitions();
+  }
+
+private:
+  outer_cache_t outer_cache;
+
+  typename outer_cache_t::iterator partition_cache;
+  std::vector<ElemT> _elems;
+  std::vector<uint32_t> _max_counts;
+  uint32_t _max_parts;
+  uint32_t _max_part_size;
+
+  partition_set get_all_partitions()
+  {
+    if ( _elems.size() == 0 )
+    {
+      return { {} }; // return the empty partition.
+    }
+
+    inner_cache_key_t key = _elems;
+    if ( partition_cache->second.count( key ) )
+    {
+      return partition_cache->second.at( key );
+    }
+
+    partition_set result;
+
+    auto last = _elems.back();
+    _elems.pop_back();
+
+    auto temp = get_all_partitions();
+
+    for ( auto&& t : temp )
+    {
+      partition cpy;
+
+      // take 'last' in its own partition
+      cpy = t;
+
+      if ( _max_parts == 0u || _max_parts > cpy.size() )
+      {
+        cpy.insert( { last } );
+        result.insert( cpy );
+      }
+
+      // add 'last' to one of the existing partitions
+      for ( auto it = t.begin(); it != t.end(); )
+      {
+        if ( _max_counts.empty() || it->count( last ) < _max_counts[last] )
+        {
+
+          if ( _max_part_size == 0 || _max_part_size > it->size() )
+          {
+            cpy = t;
+            auto elem_it = cpy.find( *it );
+            auto cpy_elem = *elem_it;
+            cpy_elem.insert( last );
+            cpy.erase( elem_it );
+            cpy.insert( cpy_elem );
+            result.insert( cpy );
+          }
+        }
+
+        std::advance( it, t.count( *it ) );
+      }
+    }
+
+    return ( partition_cache->second[key] = result );
+  }
+};
+
+template<typename ElemT>
+class partition_extender
+{
+  using part = std::multiset<ElemT>;
+  using partition = std::multiset<part>;
+  using partition_set = std::set<partition>;
+
+  using inner_cache_key_t = std::vector<ElemT>;
+  using inner_cache_t = std::unordered_map<inner_cache_key_t, partition_set, hash<inner_cache_key_t>>;
+
+  using outer_cache_key_t = std::tuple<partition, std::vector<uint32_t>, uint32_t>;
+  using outer_cache_t = std::map<outer_cache_key_t, inner_cache_t>;
+
+public:
+  /*! \brief Compute a list of different partitions that can be obtained by adding elements
+   * in `elems` to the parts of `base` such that no part contains any element `e` more than
+   * `max_counts[e]` times
+   */
+  partition_set operator()( std::vector<ElemT> elems, partition base, const std::vector<uint32_t>& max_counts, uint32_t max_part_size = 0 )
+  {
+    _elems = elems;
+    _base = base;
+    _max_counts = max_counts;
+    _max_part_size = max_part_size;
+
+    const outer_cache_key_t key = { _base, _max_counts, _max_part_size };
+    partition_cache = outer_cache.insert( { key, inner_cache_t() } ).first;
+
+    return extend_partitions();
+  }
+
+private:
+  outer_cache_t outer_cache;
+
+  typename outer_cache_t::iterator partition_cache;
+  std::vector<ElemT> _elems;
+  partition _base;
+  std::vector<uint32_t> _max_counts;
+  uint32_t _max_part_size;
+
+  partition_set extend_partitions()
+  {
+    if ( _elems.size() == 0 )
+    {
+      return { _base };
+    }
+
+    inner_cache_key_t key = _elems;
+    if ( partition_cache->second.count( key ) )
+    {
+      return partition_cache->second.at( key );
+    }
+
+    partition_set result;
+
+    auto last = _elems.back();
+    _elems.pop_back();
+
+    auto temp = extend_partitions();
+    for ( auto&& t : temp )
+    {
+      partition cpy;
+
+      for ( auto it = t.begin(); it != t.end(); )
+      {
+        if ( it->count( last ) < _max_counts.at( last ) )
+        {
+
+          if ( _max_part_size == 0 || _max_part_size > it->size() )
+          {
+            cpy = t;
+            auto elem_it = cpy.find( *it );
+            auto cpy_elem = *elem_it;
+            cpy_elem.insert( last );
+            cpy.erase( elem_it );
+            cpy.insert( cpy_elem );
+            result.insert( cpy );
+          }
+        }
+
+        std::advance( it, t.count( *it ) );
+      }
+    }
+
+    return ( partition_cache->second[key] = result );
+  }
+};
+
+template<typename ElemT>
+struct sublist_generator
+{
+  using sub_list_cache_key_t = std::map<ElemT, uint32_t>;
+
+public:
+  /**
+   * \brief Given a list of elements `elems`, generate all sub lists of those elements.
+   * Ex: if `elems` = [1, 2, 2, 3], this will generate the following lists:
+   * [0], [1], [1, 2], [1, 2, 2], [1, 2, 2, 3], [1, 2, 3], [1, 3], [2], [2, 2], [2, 2, 3], [2, 3], and [3].
+   */
+  std::set<std::vector<ElemT>> operator()( std::vector<ElemT> elems )
+  {
+    elem_counts = get_frequencies( elems );
+    return get_sub_lists_recur();
+  }
+
+private:
+  std::unordered_map<sub_list_cache_key_t, std::set<std::vector<ElemT>>, hash<sub_list_cache_key_t>> sub_list_cache;
+  std::map<ElemT, uint32_t> elem_counts;
+
+  std::set<std::vector<ElemT>> get_sub_lists_recur()
+  {
+    if ( elem_counts.size() == 0u )
+    {
+      return { {} };
+    }
+
+    sub_list_cache_key_t key = elem_counts;
+    if ( !sub_list_cache.count( key ) )
+    {
+      auto last = std::prev( elem_counts.end() );
+      auto last_elem = last->first;
+      auto last_count = last->second;
+      elem_counts.erase( last );
+
+      std::set<std::vector<int>> result;
+
+      std::vector<int> t;
+      for ( auto i = last_count; i > 0; --i )
+      {
+        t.push_back( last_elem );
+        result.insert( t ); // insert a copy of t, and note that t is already sorted.
+      }
+
+      auto temp = get_sub_lists_recur();
+
+      for ( std::vector<int> t : temp )
+      {
+        result.insert( t );
+        for ( auto i = last_count; i > 0; --i )
+        {
+          t.push_back( last_elem );
+          std::stable_sort( t.begin(), t.end() );
+          result.insert( t );
+        }
+      }
+
+      sub_list_cache[key] = result;
+    }
+
+    return sub_list_cache[key];
+  }
+};
+
+} // namespace detail
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/detail/db_builder.hpp b/include/mockturtle/algorithms/aqfp/detail/db_builder.hpp
new file mode 100644
index 0000000..7676d1f
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/detail/db_builder.hpp
@@ -0,0 +1,319 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file db_builder.hpp
+  \brief Builder class for AQFP DAG database
+
+  \author Dewmini Sudara Marakkalage
+*/
+
+#pragma once
+
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <unordered_map>
+#include <vector>
+
+#include <kitty/kitty.hpp>
+
+#include "../aqfp_db.hpp"
+#include "dag.hpp"
+#include "dag_cost.hpp"
+#include "npn_cache.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief A class to help the generation of AQFP database in an incremental manner. */
+template<typename Ntk = aqfp_dag<>>
+class aqfp_db_builder
+{
+  using db_type = aqfp_db<Ntk>;
+  using replacement = typename db_type::replacement;
+
+public:
+  aqfp_db_builder(
+      const std::unordered_map<uint32_t, double>& gate_costs = { { 3u, 6.0 }, { 5u, 10.0 } },
+      const std::unordered_map<uint32_t, double>& splitters = { { 1u, 2.0 }, { 4u, 2.0 } } )
+      : gate_costs( gate_costs ), splitters( splitters ), cc( gate_costs, splitters ) {}
+
+  db_type build()
+  {
+    return db_type( db, gate_costs, splitters );
+  }
+
+  /*! \brief Update the database with a rusult for network `net`. */
+  void update( const Ntk& ntk, const std::unordered_map<uint64_t, double>& cost_config, uint32_t N = 4u )
+  {
+    std::vector<uint64_t> input_tt = { 0x0000UL, 0xaaaaUL, 0xccccUL, 0xf0f0UL, 0xff00UL };
+    auto fs = all_functions_from_dag( input_tt, ntk );
+
+    std::unordered_set<uint64_t> npn;
+    for ( auto f : fs )
+    {
+      auto tmp = npndb( f );
+
+      auto& npntt = std::get<0>( tmp );
+      auto& npnperm = std::get<2>( tmp );
+
+      if ( npn.count( npntt ) ) // already processed
+      {
+        continue;
+      }
+      npn.insert( npntt );
+
+      std::vector<uint32_t> revperm( N );
+      for ( uint32_t i = 0; i < N; i++ )
+      {
+        revperm[npnperm[i]] = i;
+      }
+
+      for ( auto it = cost_config.begin(); it != cost_config.end(); it++ )
+      {
+        auto& lvl_cfg = it->first;
+        auto& cost = it->second;
+        std::vector<uint32_t> new_levels = { level_of_input( lvl_cfg, npnperm[0] ),
+                                             level_of_input( lvl_cfg, npnperm[1] ),
+                                             level_of_input( lvl_cfg, npnperm[2] ),
+                                             level_of_input( lvl_cfg, npnperm[3] ) };
+        assert( new_levels.size() == N );
+        auto new_lvl_cfg = lvl_cfg_from_vec( new_levels );
+
+        if ( !db[npntt].count( new_lvl_cfg ) || db[npntt][new_lvl_cfg].cost > cost )
+        {
+          db[npntt][new_lvl_cfg] = { cost, ntk, new_levels, revperm };
+        }
+      }
+    }
+  }
+
+  /*! Filter database configurations that are "covered" by other configurations. */
+  void remove_redundant( bool verbose = false )
+  {
+    for ( auto i = db.begin(); i != db.end(); i++ )
+    {
+      auto& npn = i->first;
+      auto& configs = i->second;
+
+      std::map<uint64_t, replacement> good_configs;
+      for ( auto it = configs.begin(); it != configs.end(); it++ )
+      {
+        bool ok = true;
+
+        uint32_t N = it->second.input_levels.size();
+
+        for ( auto jt = configs.begin(); jt != configs.end(); jt++ )
+        {
+          if ( jt->first == it->first )
+          {
+            continue;
+          }
+
+          /* check whether there exist input-wise smaller level config */
+          bool jt_smaller_to_it = true;
+          for ( auto j = 0; j < N; j++ )
+          {
+            if ( level_of_input( jt->first, j ) > level_of_input( it->first, j ) )
+            {
+              jt_smaller_to_it = false;
+              break;
+            }
+          }
+          if ( jt_smaller_to_it )
+          {
+            double extra_buff_cost = 0;
+            for ( auto j = 0; j < N; j++ )
+            {
+              extra_buff_cost += splitters.at( 1u ) * ( level_of_input( it->first, j ) - level_of_input( jt->first, j ) );
+            }
+            if ( extra_buff_cost + jt->second.cost <= it->second.cost )
+            {
+              if ( verbose )
+              {
+                std::cerr << fmt::format( "[aqfp_db] configuration {:04x} already covered by {:04x} [{} {} {}].\n",
+                                          it->first, jt->first, it->second.cost, jt->second.cost, extra_buff_cost );
+              }
+              ok = false;
+              break;
+            }
+          }
+        }
+        if ( ok )
+        {
+          good_configs[it->first] = it->second;
+        }
+      }
+      db[npn] = good_configs;
+    }
+  }
+
+  /*! \brief Save database to the output stream `os`. */
+  void save_db_to_file( std::ostream& os, bool hardcode = false )
+  {
+    if ( !hardcode )
+    {
+      /* output the database in plain-text encoding */
+
+      /* number of functions */
+      os << fmt::format( "{}\n", db.size() );
+      for ( auto i = db.begin(); i != db.end(); i++ )
+      {
+        /* npn class */
+        auto& k = i->first;
+
+        auto& m = i->second;
+        os << fmt::format( "{:04x}\n", k );
+
+        /* number of entries for the npn class */
+        os << fmt::format( "{}\n", m.size() );
+        for ( auto it = m.begin(); it != m.end(); it++ )
+        {
+          auto& lvl_cfg = it->first;
+          auto& r = it->second;
+
+          os << fmt::format( "{:08x}\n", lvl_cfg );
+          os << fmt::format( "{}\n", r.cost );
+          os << fmt::format( "{}\n", r.ntk.encode_as_string() );
+          os << fmt::format( "{}\n", fmt::join( r.input_perm, " " ) );
+        }
+      }
+
+      return;
+    }
+
+    /* output the database encoded as an initializer list */
+
+    os << "{\n";
+    for ( auto i = db.begin(); i != db.end(); i++ )
+    {
+      os << fmt::format( "\t{{ 0x{:04x}, {{\n", i->first );
+
+      for ( auto j = i->second.begin(); j != i->second.end(); j++ )
+      {
+        os << fmt::format( "\t\t\t\t{{ 0x{:08x}, ", j->first );
+        os << fmt::format( "{{ {}, {{ \"{}\" }}, {{ {} }}, {{ {} }} }} }},\n",
+                           j->second.cost,
+                           j->second.ntk.encode_as_string(),
+                           fmt::join( j->second.input_levels, ", " ),
+                           fmt::join( j->second.input_perm, ", " ) );
+      }
+
+      os << "\t\t}\n\t},\n";
+    }
+    os << "}\n";
+  }
+
+  /*! \brief Load database from input stream `is`. */
+  void load_db( std::istream& is )
+  {
+    aqfp_db<Ntk>::load_db( is, db );
+  }
+
+private:
+  std::unordered_map<uint32_t, double> gate_costs;
+  std::unordered_map<uint32_t, double> splitters;
+  std::unordered_map<uint64_t, std::map<uint64_t, replacement>> db;
+  dag_aqfp_cost_and_depths<Ntk> cc;
+  npn_cache npndb;
+
+  /*! \brief Compute all functions synthesizable from `net` if input slots are assigned the truthtables in `input_tt`. */
+  std::unordered_set<uint64_t> all_functions_from_dag( const std::vector<uint64_t>& input_tt, const Ntk& net )
+  {
+    // static_assert( N == 4u, "Template parameter N must be equal to 4 in the current implementation" );
+
+    uint32_t num_inputs = net.input_slots.size();
+    if ( net.zero_input != 0 )
+    {
+      num_inputs--;
+    }
+
+    std::unordered_set<uint64_t> res;
+
+    std::vector<uint64_t> tt( net.nodes.size(), input_tt[0] );
+    auto input_ind = 1u;
+
+    auto tmp_input_slots = net.input_slots;
+    std::stable_sort( tmp_input_slots.begin(), tmp_input_slots.end() );
+    assert( tmp_input_slots == net.input_slots );
+
+    for ( auto i : net.input_slots )
+    {
+      if ( i != (int)net.zero_input )
+      {
+        tt[i] = input_tt[input_ind++];
+      }
+    }
+
+    auto shift = 0u;
+    for ( auto i = 0u; i < net.num_gates(); i++ )
+    {
+      shift += ( net.nodes[i].size() - 1 );
+    }
+
+    const auto n_gates = net.num_gates();
+
+    for ( auto inv_config_itr = 0ul; inv_config_itr < ( 1ul << shift ); inv_config_itr++ )
+    {
+      auto inv_config = inv_config_itr;
+
+      for ( auto i = n_gates; i > 0; i-- )
+      {
+        const auto& n = net.nodes[i - 1];
+
+        const auto n_fanin = n.size();
+        const auto shift = n_fanin - 1;
+        const auto mask = ( 1 << shift ) - 1;
+        const auto ith_gate_config = ( inv_config & mask );
+
+        // only consider half the inverter configurations, the other half is covered by output inversion
+        if ( n_fanin == 3u )
+        {
+          tt[i - 1] = bitwise_majority(
+              ( ith_gate_config & 1 ) ? ~tt[n[0]] : tt[n[0]],
+              ( ith_gate_config & 2 ) ? ~tt[n[1]] : tt[n[1]],
+              tt[n[2]] );
+        }
+        else
+        {
+          tt[i - 1] = bitwise_majority(
+              ( ith_gate_config & 1 ) ? ~tt[n[0]] : tt[n[0]],
+              ( ith_gate_config & 2 ) ? ~tt[n[1]] : tt[n[1]],
+              ( ith_gate_config & 4 ) ? ~tt[n[2]] : tt[n[2]],
+              ( ith_gate_config & 8 ) ? ~tt[n[3]] : tt[n[3]],
+              tt[n[4]] );
+        }
+        inv_config >>= shift;
+      }
+
+      res.insert( tt[0] & 0xffff );
+    }
+
+    return res;
+  }
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/detail/db_utils.hpp b/include/mockturtle/algorithms/aqfp/detail/db_utils.hpp
new file mode 100644
index 0000000..adfa9b3
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/detail/db_utils.hpp
@@ -0,0 +1,278 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file db_utils.hpp
+  \brief Utility functions for creating the DAGs, costs, and final AQFP databases
+
+  \author Dewmini Sudara Marakkalage
+*/
+
+#pragma once
+
+#include <atomic>
+#include <iostream>
+#include <thread>
+
+#include <kitty/kitty.hpp>
+
+#include "dag.hpp"
+#include "dag_cost.hpp"
+#include "dag_gen.hpp"
+#include "db_builder.hpp"
+
+namespace mockturtle
+{
+
+inline void generate_aqfp_dags( const mockturtle::dag_generator_params& params, const std::string& file_prefix, uint32_t num_threads )
+{
+  auto t0 = std::chrono::high_resolution_clock::now();
+
+  std::vector<std::ofstream> os;
+  for ( auto i = 0u; i < num_threads; i++ )
+  {
+    auto file_path = fmt::format( "{}_{:02d}.txt", file_prefix, i );
+    os.emplace_back( file_path );
+    assert( os[i].is_open() );
+  }
+
+  auto gen = mockturtle::dag_generator<int>( params, num_threads );
+
+  std::atomic<uint32_t> count = 0u;
+  std::vector<std::atomic<uint64_t>> counts_inp( 6u );
+
+  gen.for_each_dag( [&]( const auto& net, uint32_t thread_id ) {
+    counts_inp[net.input_slots.size()]++;
+
+    os[thread_id] << fmt::format( "{}\n", net.encode_as_string() );
+
+    if ( (++count) % 100000 == 0u )
+    {
+      auto t1 = std::chrono::high_resolution_clock::now();
+      auto d1 = std::chrono::duration_cast<std::chrono::milliseconds>( t1 - t0 );
+
+      std::cerr << fmt::format( "Number of DAGs generated {:10d}\nTime so far in seconds {:9.3f}\n", count, d1.count() / 1000.0 );
+    } } );
+
+  for ( auto& file : os )
+  {
+    file.close();
+  }
+
+  auto t2 = std::chrono::high_resolution_clock::now();
+  auto d2 = std::chrono::duration_cast<std::chrono::milliseconds>( t2 - t0 );
+  std::cerr << fmt::format( "Number of DAGs generated {:10d}\nTime elapsed in seconds {:9.3f}\n", count, d2.count() / 1000.0 );
+
+  std::cerr << fmt::format( "Number of DAGs of different input counts: [3 -> {},  4 -> {}, 5 -> {}]\n", counts_inp[3u], counts_inp[4u], counts_inp[5u] );
+}
+
+inline void compute_aqfp_dag_costs( const std::unordered_map<uint32_t, double>& gate_costs, const std::unordered_map<uint32_t, double>& splitters,
+                                    const std::string& dag_file_prefix, const std::string& cost_file_prefix, uint32_t num_threads )
+{
+  auto t0 = std::chrono::high_resolution_clock::now();
+
+  std::vector<std::thread> threads;
+
+  std::atomic<uint64_t> count = 0u;
+
+  for ( auto i = 0u; i < num_threads; i++ )
+  {
+    threads.emplace_back(
+        [&]( auto id ) {
+          std::ifstream is( fmt::format( "{}_{:02d}.txt", dag_file_prefix, id ) );
+          assert( is.is_open() );
+
+          std::ofstream os( fmt::format( "{}_{:02d}.txt", cost_file_prefix, id ) );
+          assert( os.is_open() );
+          mockturtle::dag_aqfp_cost_all_configs<mockturtle::aqfp_dag<>> cc( gate_costs, splitters );
+
+          std::string temp;
+          while ( getline( is, temp ) )
+          {
+            if ( temp.length() > 0 )
+            {
+              mockturtle::aqfp_dag<> net( temp );
+              auto costs = cc( net );
+
+              os << costs.size() << std::endl;
+              for ( auto it = costs.begin(); it != costs.end(); it++ )
+              {
+                os << fmt::format( "{:08x} {}\n", it->first, it->second );
+              }
+
+              if ( ( ++count ) % 100000u == 0u )
+              {
+                auto t1 = std::chrono::high_resolution_clock::now();
+                auto d1 = std::chrono::duration_cast<std::chrono::milliseconds>( t1 - t0 );
+
+                std::cerr << fmt::format( "Number of DAGs processed {:10d}\nTime so far in seconds {:9.3f}\n", count, d1.count() / 1000.0 );
+              }
+            }
+          }
+
+          is.close();
+          os.close();
+        },
+        i );
+  }
+
+  for ( auto& t : threads )
+  {
+    t.join();
+  }
+
+  auto t2 = std::chrono::high_resolution_clock::now();
+  auto d2 = std::chrono::duration_cast<std::chrono::milliseconds>( t2 - t0 );
+  std::cerr << fmt::format( "Number of DAGs processed {:10d}\nTime elapsed in seconds {:9.3f}\n", count, d2.count() / 1000.0 );
+}
+
+inline void generate_aqfp_db( const std::unordered_map<uint32_t, double>& gate_costs, const std::unordered_map<uint32_t, double>& splitters,
+                              const std::string& dag_file_prefix, const std::string& cost_file_prefix, const std::string& db_file_prefix, uint32_t num_threads )
+{
+  auto t0 = std::chrono::high_resolution_clock::now();
+
+  std::vector<std::thread> threads;
+
+  std::atomic<uint64_t> count = 0u;
+
+  for ( auto i = 0u; i < num_threads; i++ )
+  {
+    threads.emplace_back(
+        [&]( auto id ) {
+          std::ifstream ds( fmt::format( "{}_{:02d}.txt", dag_file_prefix, id ) );
+          std::ifstream cs( fmt::format( "{}_{:02d}.txt", cost_file_prefix, id ) );
+
+          mockturtle::aqfp_db_builder<> db( gate_costs, splitters );
+          uint64_t local_count = 0u;
+
+          std::string dag;
+          while ( std::getline( ds, dag ) )
+          {
+            uint32_t num_configs;
+            cs >> num_configs;
+
+            std::unordered_map<uint64_t, double> configs;
+
+            std::string config_str;
+            uint64_t config;
+            double cost;
+
+            for ( auto j = 0u; j < num_configs; j++ )
+            {
+              cs >> config_str;
+              cs >> cost;
+              config = std::stoul( config_str, 0, 16 );
+              configs[config] = cost;
+            }
+
+            mockturtle::aqfp_dag<> ntk( dag );
+            if ( ntk.input_slots.size() < 5u || ( ntk.input_slots.size() == 5u && ntk.zero_input != 0 ) )
+            {
+              db.update( ntk, configs );
+            }
+
+            if ( ( ++count ) % 10000 == 0u )
+            {
+              auto t1 = std::chrono::high_resolution_clock::now();
+              auto d1 = std::chrono::duration_cast<std::chrono::milliseconds>( t1 - t0 );
+
+              std::cerr << fmt::format( "Number of DAGs processed {:10d}\nTime so far in seconds {:9.3f}\n", count, d1.count() / 1000.0 );
+            }
+
+            if ( ( ++local_count ) % 10000 == 0u )
+            {
+              db.remove_redundant();
+
+              std::ofstream os_tmp( fmt::format( "{}_{:02d}.txt", db_file_prefix, id ) );
+              assert( os_tmp.is_open() );
+              db.save_db_to_file( os_tmp );
+              os_tmp.close();
+            }
+          }
+
+          db.remove_redundant();
+
+          std::ofstream os( fmt::format( "{}_{:02d}.txt", db_file_prefix, id ) );
+          assert( os.is_open() );
+          db.save_db_to_file( os );
+          os.close();
+        },
+        i );
+  }
+
+  for ( auto& t : threads )
+  {
+    t.join();
+  }
+
+  mockturtle::aqfp_db_builder<> db( gate_costs, splitters );
+  for ( auto i = 0u; i < num_threads; i++ )
+  {
+    std::ifstream is( fmt::format( "{}_{:02d}.txt", db_file_prefix, i ) );
+    assert( is.is_open() );
+    db.load_db( is );
+    is.close();
+  }
+
+  db.remove_redundant();
+
+  std::ofstream os_final( fmt::format( "{}.txt", db_file_prefix ) );
+  assert( os_final.is_open() );
+  db.save_db_to_file( os_final );
+  os_final.close();
+
+  std::ofstream os_final_init_list( fmt::format( "{}_as_initializer_list.txt", db_file_prefix ) );
+  assert( os_final_init_list.is_open() );
+  db.save_db_to_file( os_final_init_list, true );
+  os_final_init_list.close();
+
+  auto t2 = std::chrono::high_resolution_clock::now();
+  auto d2 = std::chrono::duration_cast<std::chrono::milliseconds>( t2 - t0 );
+  std::cerr << fmt::format( "Number of DAGs processed {:10d}\nTime elapsed in seconds {:9.3f}\n", count, d2.count() / 1000.0 );
+}
+
+inline void generate_aqfp_db(
+    const mockturtle::dag_generator_params& params,
+    const std::unordered_map<uint32_t, double>& gate_costs,
+    const std::unordered_map<uint32_t, double>& splitters,
+    const std::string& file_prefix,
+    uint32_t num_threads )
+{
+  std::cerr << "Generating DAGs ...\n";
+  auto dag_file_prefix = fmt::format( "{}_dags", file_prefix );
+  generate_aqfp_dags( params, dag_file_prefix, num_threads );
+
+  std::cerr << "Computing costs ...\n";
+  auto cost_file_prefix = fmt::format( "{}_costs", file_prefix );
+  compute_aqfp_dag_costs( gate_costs, splitters, dag_file_prefix, cost_file_prefix, num_threads );
+
+  std::cerr << "Generating the database ...\n";
+  auto db_file_prefix = fmt::format( "{}_db", file_prefix );
+  generate_aqfp_db( gate_costs, splitters, dag_file_prefix, cost_file_prefix, db_file_prefix, num_threads );
+
+  std::cerr << "Generation completed!";
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/detail/npn_cache.hpp b/include/mockturtle/algorithms/aqfp/detail/npn_cache.hpp
new file mode 100644
index 0000000..612fd96
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/detail/npn_cache.hpp
@@ -0,0 +1,89 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file npn_cache.hpp
+  \brief Cached NPN class computation
+
+  \author Dewmini Sudara Marakkalage
+*/
+
+#pragma once
+
+#include <tuple>
+#include <vector>
+
+#include <kitty/kitty.hpp>
+
+namespace mockturtle
+{
+
+/*! \brief Cache for mapping an N-input truthtable to the corresponding NPN class and the associated NPN transformation. */
+class npn_cache
+{
+  using npn_info = std::tuple<uint64_t, uint32_t, std::vector<uint8_t>>;
+
+public:
+  npn_cache() : arr( 1ul << ( 1ul << 4u ) ), has( 1ul << ( 1ul << 4u ), false )
+  {
+  }
+
+  npn_info operator()( uint64_t tt, uint32_t num_inputs = 4u )
+  {
+    if ( num_inputs == 4u )
+    {
+      if ( has[tt] )
+      {
+        return arr[tt];
+      }
+
+      kitty::dynamic_truth_table dtt( num_inputs );
+      dtt._bits[0] = tt;
+      auto tmp = kitty::exact_npn_canonization( dtt );
+
+      has[tt] = true;
+      return ( arr[tt] = { std::get<0>( tmp )._bits[0] & 0xffff, std::get<1>( tmp ), std::get<2>( tmp ) } );
+    }
+
+    if ( cache.count( tt ) )
+    {
+      return cache[tt];
+    }
+
+    kitty::dynamic_truth_table dtt( num_inputs );
+    dtt._bits[0] = tt;
+    auto tmp = kitty::exact_npn_canonization( dtt );
+
+    return ( arr[tt] = { std::get<0>( tmp )._bits[0] & 0xffff, std::get<1>( tmp ), std::get<2>( tmp ) } );
+  }
+
+private:
+  std::vector<npn_info> arr;
+  std::vector<bool> has;
+
+  std::unordered_map<uint64_t, npn_info> cache;
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/detail/partial_dag.hpp b/include/mockturtle/algorithms/aqfp/detail/partial_dag.hpp
new file mode 100644
index 0000000..6c714ed
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/detail/partial_dag.hpp
@@ -0,0 +1,243 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file partial_dag.hpp
+  \brief AQFP partial DAG data structure
+
+  \author Dewmini Sudara Marakkalage
+*/
+
+#pragma once
+
+#include <sstream>
+#include <vector>
+
+#include <fmt/format.h>
+
+#include "dag.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief A class for constructing DAG structures in an incremental manner. */
+template<typename NodeT = int>
+struct aqfp_partial_dag : public aqfp_dag<NodeT>
+{
+  using node_type = NodeT;
+
+  using aqfp_dag<node_type>::nodes;
+  using aqfp_dag<node_type>::input_slots;
+  using aqfp_dag<node_type>::zero_input;
+  using aqfp_dag<node_type>::num_gates;
+
+  uint32_t num_levels = 0u; // current number of levels
+
+  std::unordered_map<uint32_t, uint32_t> num_gates_of_fanin;
+  std::vector<uint32_t> node_num_fanin;     // number of fanins of each node
+  std::vector<node_type> last_layer_leaves; // remaining fanin slots in the last layer
+  std::vector<node_type> other_leaves;      // remaining fanin slots of the other layers
+
+  aqfp_partial_dag(
+      const std::vector<std::vector<NodeT>>& nodes = {},
+      const std::vector<NodeT>& input_slots = {},
+      node_type zero_input = {},
+      uint32_t num_levels = 0u,
+      const std::unordered_map<uint32_t, uint32_t>& num_gates_of_fanin = {},
+      const std::vector<uint32_t>& node_num_fanin = {},
+      const std::vector<node_type>& last_layer_leaves = {},
+      const std::vector<node_type>& other_leaves = {} )
+      : aqfp_dag<node_type>( nodes, input_slots, zero_input ),
+        num_levels( num_levels ),
+        num_gates_of_fanin( num_gates_of_fanin ),
+        node_num_fanin( node_num_fanin ),
+        last_layer_leaves( last_layer_leaves ),
+        other_leaves( other_leaves ) {}
+
+  aqfp_partial_dag( const std::string& str )
+  {
+    decode_from_string( str );
+  }
+
+  /*! \brief Decode a string representation of a DAG into a DAG.
+   *
+   * Format: ng ni zi k0 g0f0 g0f1 .. g0fk0 k1 g1f0 g1f1 .. g1fk1 ....
+   * ng := num gates, ni := num inputs, zi := zero input, ki := num fanin of i-th gate, gifj = j-th fanin of i-th gate
+   */
+  void decode_from_string( const std::string& str )
+  {
+    num_levels = 0;
+
+    std::istringstream iss( str );
+    auto ng = 0u;
+    auto ni = 0u;
+    auto zi = 0u;
+
+    iss >> ng >> ni >> zi;
+    zero_input = zi;
+
+    std::vector<uint32_t> level( ng + ni, 0u );
+    level[0u] = 1u;
+    for ( auto i = 0u; i < ng; i++ )
+    {
+      auto nf = 0u;
+      iss >> nf;
+
+      num_gates_of_fanin[nf]++;
+      node_num_fanin.push_back( nf );
+      nodes.push_back( {} );
+
+      for ( auto j = 0u; j < nf; j++ )
+      {
+        auto t = 0u;
+        iss >> t;
+        nodes[i].push_back( t );
+        level[t] = std::max( level[t], level[i] + 1 );
+      }
+    }
+
+    num_levels = *std::max_element( level.begin(), level.end() );
+
+    for ( auto i = 0u; i < ni; i++ )
+    {
+      nodes.push_back( {} );
+      node_num_fanin.push_back( 0 );
+      input_slots.push_back( nodes.size() - 1 );
+    }
+  }
+
+  /*! \brief Returns a map with maximum number of equal fanins that a gate may have without that gate being redundant.
+   *
+   * A 3-input majority gate may not have any equal fanins as it would simplify otherwise.
+   * A 5-input majoirty gate may have up to 2 equal fanins but if it had more, then it would simplify.
+   */
+  std::vector<uint32_t> max_equal_fanins() const
+  {
+    std::vector<uint32_t> res( num_gates() );
+    for ( auto i = 0u; i < num_gates(); i++ )
+    {
+      res[i] = node_num_fanin[i] / 2;
+    }
+    return res;
+  }
+
+  /*! \brief Add "fanin" as a fanin of "node". */
+  void add_fanin( NodeT node, NodeT fanin )
+  {
+    nodes[node].push_back( fanin );
+  }
+
+  /*! \brief Adds a new node with "num_fanin" fanins that is connected to "fanouts".
+   *
+   * Optionally, it can be specified as a last layer node if at least one of its fanouts previously belonged to
+   * the last layer.
+   */
+  uint32_t add_internal_node( uint32_t num_fanin = 3u, const std::multiset<NodeT>& fanouts = {}, bool is_in_last_layer = true )
+  {
+    uint32_t node_id = nodes.size();
+    nodes.push_back( {} );
+
+    assert( node_id == node_num_fanin.size() );
+
+    num_gates_of_fanin[num_fanin]++;
+    node_num_fanin.push_back( num_fanin );
+
+    for ( auto&& fo : fanouts )
+    {
+      add_fanin( fo, node_id );
+    }
+
+    if ( is_in_last_layer )
+    {
+      for ( auto slot = 0u; slot < num_fanin; slot++ )
+      {
+        last_layer_leaves.push_back( node_id );
+      }
+    }
+
+    return node_id;
+  }
+
+  /*! \brief Adds a new input node connected to "fanouts". */
+  uint32_t add_leaf_node( const std::multiset<NodeT>& fanouts = {} )
+  {
+    auto input_slot = add_internal_node( 0u, fanouts, false );
+    input_slots.push_back( input_slot );
+    return input_slot;
+  }
+
+  /*! \brief Make a copy  with empty last_layer_leaves and other_leaves. */
+  aqfp_partial_dag copy_without_leaves() const
+  {
+    aqfp_partial_dag res{
+        nodes,
+        input_slots,
+        zero_input,
+
+        num_levels,
+
+        num_gates_of_fanin,
+        node_num_fanin,
+        {},
+        {},
+    };
+
+    return res;
+  }
+
+  /*! \brief Make a copy  with empty other_leaves. */
+  aqfp_partial_dag copy_with_last_layer_leaves() const
+  {
+    aqfp_partial_dag res{
+        nodes,
+        input_slots,
+        zero_input,
+
+        num_levels,
+
+        num_gates_of_fanin,
+        node_num_fanin,
+        last_layer_leaves,
+        {},
+    };
+
+    return res;
+  }
+
+  /*! \brief Create a aqfp_partial_dag with a single gate of a given number of fanins. */
+  static aqfp_partial_dag get_root( uint32_t num_fanin )
+  {
+    aqfp_partial_dag net;
+
+    net.num_levels = 1u;
+
+    std::multiset<NodeT> fanouts = {};
+    net.add_internal_node( num_fanin, fanouts, true );
+
+    return net;
+  }
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/mig_algebraic_rewriting_splitters.hpp b/include/mockturtle/algorithms/aqfp/mig_algebraic_rewriting_splitters.hpp
new file mode 100644
index 0000000..cb4ca49
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/mig_algebraic_rewriting_splitters.hpp
@@ -0,0 +1,407 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mig_algebraic_rewriting_splitters.hpp
+  \brief MIG algebraric rewriting with fanout size limitation
+
+  \author Mathias Soeken
+  \author Eleonora Testa
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../../utils/stopwatch.hpp"
+#include "../../views/fanout_view.hpp"
+#include "../../views/topo_view.hpp"
+#include "../mig_algebraic_rewriting.hpp"
+
+#include <iostream>
+#include <optional>
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+template<class Ntk>
+class mig_algebraic_depth_rewriting_splitter_impl
+{
+public:
+  mig_algebraic_depth_rewriting_splitter_impl( Ntk& ntk, mig_algebraic_depth_rewriting_params const& ps, mig_algebraic_depth_rewriting_stats& st )
+      : ntk( ntk ), ps( ps ), st( st )
+  {
+  }
+
+  void run()
+  {
+    stopwatch t( st.time_total );
+
+    switch ( ps.strategy )
+    {
+    case mig_algebraic_depth_rewriting_params::dfs:
+      run_dfs();
+      break;
+    case mig_algebraic_depth_rewriting_params::selective:
+      run_selective();
+      break;
+    case mig_algebraic_depth_rewriting_params::aggressive:
+      run_aggressive();
+      break;
+    }
+  }
+
+private:
+  void run_dfs()
+  {
+    ntk.foreach_po( [this]( auto po ) {
+      const auto driver = ntk.get_node( po );
+      if ( ntk.level( driver ) < ntk.depth() )
+        return;
+      topo_view topo{ ntk, po };
+      topo.foreach_node( [this]( auto n ) {
+        mark_critical_paths();
+        reduce_depth( n );
+        return true;
+      } );
+    } );
+  }
+
+  void run_selective()
+  {
+    uint32_t counter{ 0 };
+    while ( true )
+    {
+      mark_critical_paths();
+
+      topo_view topo{ ntk };
+      topo.foreach_node( [this, &counter]( auto n ) {
+        if ( ntk.fanout_size( n ) == 0 || ntk.value( n ) == 0 )
+          return;
+        if ( reduce_depth( n ) )
+        {
+          mark_critical_paths();
+        }
+        else
+        {
+          ++counter;
+        }
+      } );
+
+      if ( counter > ntk.size() )
+        break;
+    }
+  }
+
+  void run_aggressive()
+  {
+    uint32_t counter{ 0 }, init_size{ ntk.size() };
+    while ( true )
+    {
+      topo_view topo{ ntk };
+      topo.foreach_node( [this, &counter]( auto n ) {
+        if ( ntk.fanout_size( n ) == 0 )
+          return;
+
+        if ( !reduce_depth( n ) )
+        {
+          ++counter;
+        }
+      } );
+
+      if ( ntk.size() > ps.overhead * init_size )
+        break;
+      if ( counter > ntk.size() )
+        break;
+    }
+  }
+
+private:
+  bool reduce_depth( node<Ntk> const& n )
+  {
+
+    if ( !ntk.is_maj( n ) )
+      return false;
+
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    if ( !ntk.is_maj( ntk.get_node( ocs[2] ) ) )
+      return false;
+
+    if ( ntk.fanout_size( ntk.get_node( ocs[2] ) ) != 1 )
+      return false;
+
+    /* depth of last child must be (significantly) higher than depth of second child */
+    if ( ntk.level( ntk.get_node( ocs[2] ) ) <= ntk.level( ntk.get_node( ocs[1] ) ) + 1 )
+      return false;
+
+    /* child must have single fanout, if no area overhead is allowed */
+    if ( !ps.allow_area_increase && ntk.fanout_size( ntk.get_node( ocs[2] ) ) != 1 )
+      return false;
+
+    /* get children of last child */
+    auto ocs2 = ordered_children( ntk.get_node( ocs[2] ) );
+
+    /* depth of last grand-child must be higher than depth of second grand-child */
+    if ( ntk.level( ntk.get_node( ocs2[2] ) ) == ntk.level( ntk.get_node( ocs2[1] ) ) )
+      return false;
+
+    /* propagate inverter if necessary */
+    if ( ntk.is_complemented( ocs[2] ) )
+    {
+      ocs2[0] = !ocs2[0];
+      ocs2[1] = !ocs2[1];
+      ocs2[2] = !ocs2[2];
+    }
+
+    auto index = 0;
+
+    if ( auto cand = associativity_candidate( ocs[0], ocs[1], ocs2[0], ocs2[1], ocs2[2] ); cand )
+    {
+      const auto& [x, y, z, u, assoc] = *cand;
+
+      signal<Ntk> third;
+      if ( assoc )
+      {
+        third = u;
+      }
+      else
+        third = x;
+
+      auto h = ntk.create_maj( x, y, u );
+      auto opt = ntk.create_maj( z, third, h );
+
+      if ( ntk.fanout_size( ntk.get_node( opt ) ) < 1 ) // opt does not exists
+      {
+        if ( ( ntk.fanout_size( ntk.get_node( h ) ) == 5 ) || ( ntk.fanout_size( ntk.get_node( h ) ) >= 17 ) || ( ntk.fanout_size( ntk.get_node( h ) ) == 2 ) ) // it would mean the depth is actually increased
+        {
+          ntk.take_out_node( ntk.get_node( opt ) );
+          return true;
+        }
+      }
+
+      ntk.substitute_node( n, opt );
+      ntk.update_levels();
+      return true;
+    }
+
+    /* distributivity */
+    if ( ps.allow_area_increase )
+    {
+      auto s1 = ntk.create_maj( ocs[0], ocs[1], ocs2[0] );
+
+      auto s2 = ntk.create_maj( ocs[0], ocs[1], ocs2[1] );
+      if ( ntk.fanout_size( ntk.get_node( s2 ) ) < 1 )
+      {
+        index = ntk.node_to_index( ntk.get_node( ocs[0] ) );
+        if ( ( !ntk.is_pi( ntk.get_node( ocs[0] ) ) ) && ( index != 0 ) ) //&& ( ntk.is_on_critical_path( ntk.get_node( ocs[0] ) ) ) )
+        {
+          if ( ( ntk.fanout_size( ntk.get_node( ocs[0] ) ) == 5 ) || ( ntk.fanout_size( ntk.get_node( ocs[0] ) ) >= 17 ) || ( ntk.fanout_size( ntk.get_node( ocs[0] ) ) == 2 ) ) // it would mean the depth is actually increased
+          {
+            if ( ntk.fanout_size( ntk.get_node( s1 ) ) < 1 )
+              ntk.take_out_node( ntk.get_node( s1 ) );
+            ntk.take_out_node( ntk.get_node( s2 ) );
+            return true;
+          }
+        }
+
+        index = ntk.node_to_index( ntk.get_node( ocs[1] ) );
+        if ( ( !ntk.is_pi( ntk.get_node( ocs[1] ) ) ) && ( index != 0 ) )
+        {
+          if ( ( ntk.fanout_size( ntk.get_node( ocs[1] ) ) == 5 ) || ( ntk.fanout_size( ntk.get_node( ocs[1] ) ) >= 17 ) || ( ntk.fanout_size( ntk.get_node( ocs[1] ) ) == 2 ) ) // it would mean the depth is actually increased
+          {
+            if ( ntk.fanout_size( ntk.get_node( s1 ) ) < 1 )
+              ntk.take_out_node( ntk.get_node( s1 ) );
+            ntk.take_out_node( ntk.get_node( s2 ) );
+            return true;
+          }
+        }
+      }
+
+      auto opt = ntk.create_maj( ocs2[2], s1, s2 );
+
+      if ( ( ntk.fanout_size( ntk.get_node( s1 ) ) == 5 ) || ( ntk.fanout_size( ntk.get_node( s1 ) ) >= 17 ) || ( ntk.fanout_size( ntk.get_node( s1 ) ) == 2 ) ) // it would mean the depth is actually increased
+      {
+        if ( ntk.fanout_size( ntk.get_node( s2 ) ) == 1 )
+          ntk.take_out_node( ntk.get_node( s2 ) );
+        if ( ntk.fanout_size( ntk.get_node( opt ) ) < 1 )
+          ntk.take_out_node( ntk.get_node( opt ) );
+        return true;
+      }
+      if ( ( ntk.fanout_size( ntk.get_node( s2 ) ) == 5 ) || ( ntk.fanout_size( ntk.get_node( s2 ) ) >= 17 ) || ( ntk.fanout_size( ntk.get_node( s2 ) ) == 2 ) ) // it would mean the depth is actually increased
+      {
+        if ( ntk.fanout_size( ntk.get_node( s1 ) ) == 1 )
+          ntk.take_out_node( ntk.get_node( s1 ) );
+        if ( ntk.fanout_size( ntk.get_node( opt ) ) < 1 )
+          ntk.take_out_node( ntk.get_node( opt ) );
+        return true;
+      }
+      if ( ( ntk.fanout_size( ntk.get_node( opt ) ) == 4 ) || ( ntk.fanout_size( ntk.get_node( opt ) ) >= 16 ) || ( ntk.fanout_size( ntk.get_node( opt ) ) == 1 ) ) // it would mean the depth is actually increased
+      {
+        if ( ntk.fanout_size( ntk.get_node( s1 ) ) == 1 )
+          ntk.take_out_node( ntk.get_node( s1 ) );
+        if ( ntk.fanout_size( ntk.get_node( s2 ) ) == 1 )
+          ntk.take_out_node( ntk.get_node( s2 ) );
+        return true;
+      }
+      ntk.substitute_node( n, opt );
+      ntk.update_levels();
+    }
+    return true;
+  }
+
+  using candidate_t = std::tuple<signal<Ntk>, signal<Ntk>, signal<Ntk>, signal<Ntk>, bool>;
+  std::optional<candidate_t> associativity_candidate( signal<Ntk> const& v, signal<Ntk> const& w, signal<Ntk> const& x, signal<Ntk> const& y, signal<Ntk> const& z ) const
+  {
+    if ( v.index == x.index )
+    {
+      return candidate_t{ w, y, z, v, v.complement == x.complement };
+    }
+    if ( v.index == y.index )
+    {
+      return candidate_t{ w, x, z, v, v.complement == y.complement };
+    }
+    if ( w.index == x.index )
+    {
+      return candidate_t{ v, y, z, w, w.complement == x.complement };
+    }
+    if ( w.index == y.index )
+    {
+      return candidate_t{ v, x, z, w, w.complement == y.complement };
+    }
+
+    return std::nullopt;
+  }
+
+  std::array<signal<Ntk>, 3> ordered_children( node<Ntk> const& n ) const
+  {
+    std::array<signal<Ntk>, 3> children;
+    ntk.foreach_fanin( n, [&children]( auto const& f, auto i ) { children[i] = f; } );
+    std::stable_sort( children.begin(), children.end(), [this]( auto const& c1, auto const& c2 ) {
+      return ntk.level( ntk.get_node( c1 ) ) < ntk.level( ntk.get_node( c2 ) );
+    } );
+    return children;
+  }
+
+  void mark_critical_path( node<Ntk> const& n )
+  {
+    if ( ntk.is_pi( n ) || ntk.is_constant( n ) || ntk.value( n ) )
+      return;
+
+    const auto level = ntk.level( n );
+    ntk.set_value( n, 1 );
+    ntk.foreach_fanin( n, [this, level]( auto const& f ) {
+      if ( ntk.level( ntk.get_node( f ) ) == level - 1 )
+      {
+        mark_critical_path( ntk.get_node( f ) );
+      }
+    } );
+  }
+
+  void mark_critical_paths()
+  {
+    ntk.clear_values();
+    ntk.foreach_po( [this]( auto const& f ) {
+      if ( ntk.level( ntk.get_node( f ) ) == ntk.depth() )
+      {
+        mark_critical_path( ntk.get_node( f ) );
+      }
+    } );
+  }
+
+private:
+  Ntk& ntk;
+  mig_algebraic_depth_rewriting_params const& ps;
+  mig_algebraic_depth_rewriting_stats& st;
+}; // namespace detail
+
+} // namespace detail
+
+/*! \brief Majority algebraic depth rewriting.
+ *
+ * This algorithm tries to rewrite a network with majority gates for depth
+ * optimization using the associativity and distributivity rule in
+ * majority-of-3 logic.  It can be applied to networks other than MIGs, but
+ * only considers pairs of nodes which both implement the majority-of-3
+ * function.
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `level`
+ * - `update_levels`
+ * - `create_maj`
+ * - `substitute_node`
+ * - `foreach_node`
+ * - `foreach_po`
+ * - `foreach_fanin`
+ * - `is_maj`
+ * - `clear_values`
+ * - `set_value`
+ * - `value`
+ * - `fanout_size`
+ *
+   \verbatim embed:rst
+
+  .. note::
+
+      The implementation of this algorithm was heavily inspired by an
+      implementation from Luca Amarù.
+   \endverbatim
+ */
+template<class Ntk>
+void mig_algebraic_depth_rewriting_splitters( Ntk& ntk, mig_algebraic_depth_rewriting_params const& ps = {}, mig_algebraic_depth_rewriting_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_level_v<Ntk>, "Ntk does not implement the level method" );
+  static_assert( has_create_maj_v<Ntk>, "Ntk does not implement the create_maj method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the substitute_node method" );
+  static_assert( has_update_levels_v<Ntk>, "Ntk does not implement the update_levels method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_is_maj_v<Ntk>, "Ntk does not implement the is_maj method" );
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_value_v<Ntk>, "Ntk does not implement the value method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+
+  mig_algebraic_depth_rewriting_stats st;
+  detail::mig_algebraic_depth_rewriting_splitter_impl<Ntk> p( ntk, ps, st );
+  p.run();
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/mig_resub_splitters.hpp b/include/mockturtle/algorithms/aqfp/mig_resub_splitters.hpp
new file mode 100644
index 0000000..5cf7224
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/mig_resub_splitters.hpp
@@ -0,0 +1,581 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mig_resub_splitters.hpp
+  \brief Modified MIG resubstitution to consider splitters in AQFP
+
+  \author Heinz Riener
+  \author Eleonora Testa
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../../networks/mig.hpp"
+#include "../../utils/truth_table_utils.hpp"
+#include "../resubstitution.hpp"
+
+#include <kitty/kitty.hpp>
+
+namespace mockturtle
+{
+
+struct mig_resub_splitters_stats
+{
+  /*! \brief Accumulated runtime for const-resub */
+  stopwatch<>::duration time_resubC{ 0 };
+
+  /*! \brief Accumulated runtime for zero-resub */
+  stopwatch<>::duration time_resub0{ 0 };
+
+  /*! \brief Accumulated runtime for collecting unate divisors. */
+  stopwatch<>::duration time_collect_unate_divisors{ 0 };
+
+  /*! \brief Accumulated runtime for one-resub */
+  stopwatch<>::duration time_resub1{ 0 };
+
+  /*! \brief Accumulated runtime for relevance resub */
+  stopwatch<>::duration time_resubR{ 0 };
+
+  /*! \brief Number of accepted constant resubsitutions */
+  uint32_t num_const_accepts{ 0 };
+
+  /*! \brief Number of accepted zero resubsitutions */
+  uint32_t num_div0_accepts{ 0 };
+
+  /*! \brief Number of accepted one resubsitutions */
+  uint64_t num_div1_accepts{ 0 };
+
+  /*! \brief Number of accepted relevance resubsitutions */
+  uint32_t num_divR_accepts{ 0 };
+
+  void report() const
+  {
+    std::cout << "[i] kernel: mig_resub_splitters_functor\n";
+    std::cout << fmt::format( "[i]     constant-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_const_accepts, to_seconds( time_resubC ) );
+    std::cout << fmt::format( "[i]            0-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_div0_accepts, to_seconds( time_resub0 ) );
+    std::cout << fmt::format( "[i]            R-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_divR_accepts, to_seconds( time_resubR ) );
+    std::cout << fmt::format( "[i]            collect unate divisors                           ({:>5.2f} secs)\n", to_seconds( time_collect_unate_divisors ) );
+    std::cout << fmt::format( "[i]            1-resub {:6d} = {:6d} MAJ                      ({:>5.2f} secs)\n",
+                              num_div1_accepts, num_div1_accepts, to_seconds( time_resub1 ) );
+    std::cout << fmt::format( "[i]            total   {:6d}\n",
+                              ( num_const_accepts + num_div0_accepts + num_divR_accepts + num_div1_accepts ) );
+  }
+}; /* mig_resub_splitters_stats */
+
+template<typename Ntk, typename Simulator, typename TT>
+struct mig_resub_splitters_functor
+{
+public:
+  using node = mig_network::node;
+  using signal = mig_network::signal;
+  using stats = mig_resub_splitters_stats;
+
+  struct unate_divisors
+  {
+    std::vector<signal> positive_divisors0;
+    std::vector<signal> positive_divisors1;
+    std::vector<signal> negative_divisors0;
+    std::vector<signal> negative_divisors1;
+    std::vector<signal> next_candidates;
+
+    void clear()
+    {
+      positive_divisors0.clear();
+      positive_divisors1.clear();
+      negative_divisors0.clear();
+      negative_divisors1.clear();
+      next_candidates.clear();
+    }
+  };
+
+public:
+  explicit mig_resub_splitters_functor( Ntk& ntk, Simulator const& sim, std::vector<node> const& divs, uint32_t num_divs, stats& st )
+      : ntk( ntk ), sim( sim ), divs( divs ), num_divs( num_divs ), st( st )
+  {
+  }
+
+  std::optional<signal> operator()( node const& root, TT care, uint32_t required, uint32_t max_inserts, uint32_t num_mffc, uint32_t& last_gain )
+  {
+    (void)care;
+    assert( is_const0( ~care ) );
+
+    /* consider constants */
+    auto g = call_with_stopwatch( st.time_resubC, [&]() {
+      return resub_const( root, required );
+    } );
+    if ( g )
+    {
+      ++st.num_const_accepts;
+      last_gain = num_mffc;
+      return g; /* accepted resub */
+    }
+
+    /* consider equal nodes */
+    g = call_with_stopwatch( st.time_resub0, [&]() {
+      return resub_div0( root, required );
+    } );
+    if ( g )
+    {
+      ++st.num_div0_accepts;
+      last_gain = num_mffc;
+      return g; /* accepted resub */
+    }
+
+    /* consider relevance optimization */
+    g = call_with_stopwatch( st.time_resubR, [&]() {
+      return resub_divR( root, required );
+    } );
+    if ( g )
+    {
+      ++st.num_divR_accepts;
+      last_gain = num_mffc;
+      return g; /* accepted resub */
+    }
+
+    if ( max_inserts == 0 || num_mffc == 1 )
+      return std::nullopt;
+
+    /* collect level one divisors */
+    call_with_stopwatch( st.time_collect_unate_divisors, [&]() {
+      collect_unate_divisors( root, required );
+    } );
+
+    /* consider equal nodes */
+    g = call_with_stopwatch( st.time_resub1, [&]() {
+      return resub_div1( root, required );
+    } );
+    if ( g )
+    {
+      ++st.num_div1_accepts;
+      last_gain = num_mffc - 1;
+      return g; /* accepted resub */
+    }
+
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_const( node const& root, uint32_t required ) const
+  {
+    (void)required;
+    auto const tt = sim.get_tt( ntk.make_signal( root ) );
+    if ( tt == sim.get_tt( ntk.get_constant( false ) ) )
+    {
+      return sim.get_phase( root ) ? ntk.get_constant( true ) : ntk.get_constant( false );
+    }
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_div0( node const& root, uint32_t required ) const
+  {
+    (void)required;
+    auto const tt = sim.get_tt( ntk.make_signal( root ) );
+    for ( auto i = 0u; i < num_divs; ++i )
+    {
+      auto const d = divs.at( i );
+      if ( !ntk.is_pi( d ) )
+      {
+        if ( ( ntk.fanout_size( d ) == 4 ) || ( ntk.fanout_size( d ) >= 16 ) || ( ntk.fanout_size( d ) == 1 ) ) // it would mean the depth is actually increased
+          continue;
+        auto fanout = ntk.fanout_size( root );
+        if ( ( ntk.fanout_size( d ) < 4 ) && ( ntk.fanout_size( d ) + fanout > 4 ) )
+          continue;
+        else if ( ( ntk.fanout_size( d ) < 16 ) && ( ntk.fanout_size( d ) > 4 ) && ( ntk.fanout_size( d ) + fanout > 16 ) )
+          continue;
+      }
+
+      if ( tt != sim.get_tt( ntk.make_signal( d ) ) )
+        continue; /* next */
+
+      return ( sim.get_phase( d ) ^ sim.get_phase( root ) ) ? !ntk.make_signal( d ) : ntk.make_signal( d );
+    }
+
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_divR( node const& root, uint32_t required )
+  {
+    (void)required;
+
+    std::vector<signal> fs;
+    ntk.foreach_fanin( root, [&]( const auto& f ) {
+      fs.emplace_back( f );
+    } );
+
+    for ( auto i = 0u; i < divs.size(); ++i )
+    {
+      auto const& d0 = divs.at( i );
+
+      if ( !ntk.is_pi( d0 ) )
+      {
+        if ( ( ntk.fanout_size( d0 ) == 4 ) || ( ntk.fanout_size( d0 ) >= 16 ) || ( ntk.fanout_size( d0 ) == 1 ) ) // it would mean the depth is actually increased
+          continue;
+      }
+
+      auto const& s = ntk.make_signal( d0 );
+      auto const& tt = sim.get_tt( s );
+
+      if ( d0 == root )
+        break;
+
+      auto const tt0 = sim.get_tt( fs[0] );
+      auto const tt1 = sim.get_tt( fs[1] );
+      auto const tt2 = sim.get_tt( fs[2] );
+
+      if ( ntk.get_node( fs[0] ) != d0 && ntk.fanout_size( ntk.get_node( fs[0] ) ) == 1 && can_replace_majority_fanin( tt0, tt1, tt2, tt ) )
+      {
+        auto const b = sim.get_phase( ntk.get_node( fs[1] ) ) ? !fs[1] : fs[1];
+        auto const c = sim.get_phase( ntk.get_node( fs[2] ) ) ? !fs[2] : fs[2];
+
+        return sim.get_phase( root ) ? !ntk.create_maj( sim.get_phase( d0 ) ? !s : s, b, c ) : ntk.create_maj( sim.get_phase( d0 ) ? !s : s, b, c );
+      }
+      else if ( ntk.get_node( fs[1] ) != d0 && ntk.fanout_size( ntk.get_node( fs[1] ) ) == 1 && can_replace_majority_fanin( tt1, tt0, tt2, tt ) )
+      {
+        auto const a = sim.get_phase( ntk.get_node( fs[0] ) ) ? !fs[0] : fs[0];
+        auto const c = sim.get_phase( ntk.get_node( fs[2] ) ) ? !fs[2] : fs[2];
+
+        return sim.get_phase( root ) ? !ntk.create_maj( sim.get_phase( d0 ) ? !s : s, a, c ) : ntk.create_maj( sim.get_phase( d0 ) ? !s : s, a, c );
+      }
+      else if ( ntk.get_node( fs[2] ) != d0 && ntk.fanout_size( ntk.get_node( fs[2] ) ) == 1 && can_replace_majority_fanin( tt2, tt0, tt1, tt ) )
+      {
+        auto const a = sim.get_phase( ntk.get_node( fs[0] ) ) ? !fs[0] : fs[0];
+        auto const b = sim.get_phase( ntk.get_node( fs[1] ) ) ? !fs[1] : fs[1];
+
+        return sim.get_phase( root ) ? !ntk.create_maj( sim.get_phase( d0 ) ? !s : s, a, b ) : ntk.create_maj( sim.get_phase( d0 ) ? !s : s, a, b );
+      }
+      else if ( ntk.get_node( fs[0] ) != d0 && ntk.fanout_size( ntk.get_node( fs[0] ) ) == 1 && can_replace_majority_fanin( ~tt0, tt1, tt2, tt ) )
+      {
+        auto const b = sim.get_phase( ntk.get_node( fs[1] ) ) ? !fs[1] : fs[1];
+        auto const c = sim.get_phase( ntk.get_node( fs[2] ) ) ? !fs[2] : fs[2];
+
+        return sim.get_phase( root ) ? !ntk.create_maj( sim.get_phase( d0 ) ? s : !s, b, c ) : ntk.create_maj( sim.get_phase( d0 ) ? s : !s, b, c );
+      }
+      else if ( ntk.get_node( fs[1] ) != d0 && ntk.fanout_size( ntk.get_node( fs[1] ) ) == 1 && can_replace_majority_fanin( ~tt1, tt0, tt2, tt ) )
+      {
+        auto const a = sim.get_phase( ntk.get_node( fs[0] ) ) ? !fs[0] : fs[0];
+        auto const c = sim.get_phase( ntk.get_node( fs[2] ) ) ? !fs[2] : fs[2];
+
+        return sim.get_phase( root ) ? !ntk.create_maj( sim.get_phase( d0 ) ? s : !s, a, c ) : ntk.create_maj( sim.get_phase( d0 ) ? s : !s, a, c );
+      }
+      else if ( ntk.get_node( fs[2] ) != d0 && ntk.fanout_size( ntk.get_node( fs[2] ) ) == 1 && can_replace_majority_fanin( ~tt2, tt0, tt1, tt ) )
+      {
+        auto const a = sim.get_phase( ntk.get_node( fs[0] ) ) ? !fs[0] : fs[0];
+        auto const b = sim.get_phase( ntk.get_node( fs[1] ) ) ? !fs[1] : fs[1];
+
+        return sim.get_phase( root ) ? !ntk.create_maj( sim.get_phase( d0 ) ? s : !s, a, b ) : ntk.create_maj( sim.get_phase( d0 ) ? s : !s, a, b );
+      }
+    }
+
+    return std::nullopt;
+  }
+
+  void collect_unate_divisors( node const& root, uint32_t required )
+  {
+    udivs.clear();
+
+    auto const& tt = sim.get_tt( ntk.make_signal( root ) );
+    for ( auto i = 0u; i < num_divs; ++i )
+    {
+      auto const d0 = divs.at( i );
+      if ( ntk.level( d0 ) > required - 1 )
+        continue;
+
+      for ( auto j = i + 1; j < num_divs; ++j )
+      {
+        auto const d1 = divs.at( j );
+        if ( ntk.level( d1 ) > required - 1 )
+          continue;
+
+        auto const& tt_s0 = sim.get_tt( ntk.make_signal( d0 ) );
+        auto const& tt_s1 = sim.get_tt( ntk.make_signal( d1 ) );
+
+        /* Boolean filtering rule for MAJ-3 */
+        if ( kitty::ternary_majority( tt_s0, tt_s1, tt ) == tt )
+        {
+          udivs.positive_divisors0.emplace_back( ntk.make_signal( d0 ) );
+          udivs.positive_divisors1.emplace_back( ntk.make_signal( d1 ) );
+          continue;
+        }
+
+        if ( kitty::ternary_majority( ~tt_s0, tt_s1, tt ) == tt )
+        {
+          udivs.negative_divisors0.emplace_back( ntk.make_signal( d0 ) );
+          udivs.negative_divisors1.emplace_back( ntk.make_signal( d1 ) );
+          continue;
+        }
+
+        if ( std::find( udivs.next_candidates.begin(), udivs.next_candidates.end(), ntk.make_signal( d1 ) ) == udivs.next_candidates.end() )
+          udivs.next_candidates.emplace_back( ntk.make_signal( d1 ) );
+      }
+
+      if ( std::find( udivs.next_candidates.begin(), udivs.next_candidates.end(), ntk.make_signal( d0 ) ) == udivs.next_candidates.end() )
+        udivs.next_candidates.emplace_back( ntk.make_signal( d0 ) );
+    }
+  }
+
+  std::optional<signal> resub_div1( node const& root, uint32_t required )
+  {
+    (void)required;
+    auto const& tt = sim.get_tt( ntk.make_signal( root ) );
+
+    /* check for positive unate divisors */
+    for ( auto i = 0u; i < udivs.positive_divisors0.size(); ++i )
+    {
+      auto const s0 = udivs.positive_divisors0.at( i );
+      auto const s1 = udivs.positive_divisors1.at( i );
+
+      if ( !ntk.is_pi( ntk.get_node( s0 ) ) )
+      {
+        if ( ( ntk.fanout_size( ntk.get_node( s0 ) ) == 4 ) || ( ntk.fanout_size( ntk.get_node( s0 ) ) >= 16 ) || ( ntk.fanout_size( ntk.get_node( s0 ) ) == 1 ) ) // it would mean the depth is actually increased
+          continue;
+      }
+      if ( !ntk.is_pi( ntk.get_node( s1 ) ) )
+      {
+        if ( ( ntk.fanout_size( ntk.get_node( s1 ) ) == 4 ) || ( ntk.fanout_size( ntk.get_node( s1 ) ) >= 16 ) || ( ntk.fanout_size( ntk.get_node( s1 ) ) == 1 ) ) // it would mean the depth is actually increased
+          continue;
+      }
+
+      for ( auto j = i + 1; j < udivs.positive_divisors0.size(); ++j )
+      {
+        auto s2 = udivs.positive_divisors0.at( j );
+        if ( !ntk.is_pi( ntk.get_node( s2 ) ) )
+        {
+          if ( ( ntk.fanout_size( ntk.get_node( s2 ) ) == 4 ) || ( ntk.fanout_size( ntk.get_node( s2 ) ) >= 16 ) || ( ntk.fanout_size( ntk.get_node( s2 ) ) == 1 ) ) // it would mean the depth is actually increased
+            continue;
+        }
+
+        auto const& tt_s0 = sim.get_tt( s0 );
+        auto const& tt_s1 = sim.get_tt( s1 );
+        auto tt_s2 = sim.get_tt( s2 );
+
+        if ( kitty::ternary_majority( tt_s0, tt_s1, tt_s2 ) == tt )
+        {
+          // ++st.num_div1_maj_accepts;
+          auto const a = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+          auto const b = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+          auto const c = sim.get_phase( ntk.get_node( s2 ) ) ? !s2 : s2;
+          auto e = ntk.create_maj( a, b, c );
+          if ( ( ntk.fanout_size( ntk.get_node( e ) ) == 2 ) || ( ntk.fanout_size( ntk.get_node( e ) ) == 5 ) || ( ntk.fanout_size( ntk.get_node( e ) ) > 16 ) )
+          {
+            continue;
+          }
+          else
+            return sim.get_phase( root ) ? !e : e;
+        }
+
+        s2 = udivs.positive_divisors1.at( j );
+        if ( !ntk.is_pi( ntk.get_node( s2 ) ) )
+        {
+          if ( ( ntk.fanout_size( ntk.get_node( s2 ) ) == 4 ) || ( ntk.fanout_size( ntk.get_node( s2 ) ) >= 16 ) || ( ntk.fanout_size( ntk.get_node( s2 ) ) == 1 ) )
+            continue;
+        }
+        tt_s2 = sim.get_tt( s2 );
+
+        if ( kitty::ternary_majority( tt_s0, tt_s1, tt_s2 ) == tt )
+        {
+          // ++st.num_div1_maj_accepts;
+          auto const a = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+          auto const b = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+          auto const c = sim.get_phase( ntk.get_node( s2 ) ) ? !s2 : s2;
+          auto e = ntk.create_maj( a, b, c );
+          if ( ( ntk.fanout_size( ntk.get_node( e ) ) == 2 ) || ( ntk.fanout_size( ntk.get_node( e ) ) == 5 ) || ( ntk.fanout_size( ntk.get_node( e ) ) > 16 ) )
+            continue;
+          else
+            return sim.get_phase( root ) ? !e : e;
+        }
+      }
+    }
+
+    /* check for negative unate divisors */
+    for ( auto i = 0u; i < udivs.negative_divisors0.size(); ++i )
+    {
+      auto const s0 = udivs.negative_divisors0.at( i );
+      if ( !ntk.is_pi( ntk.get_node( s0 ) ) )
+      {
+        if ( ( ntk.fanout_size( ntk.get_node( s0 ) ) == 4 ) || ( ntk.fanout_size( ntk.get_node( s0 ) ) >= 16 ) || ( ntk.fanout_size( ntk.get_node( s0 ) ) == 1 ) ) // it would mean the depth is actually increased
+          continue;
+      }
+      auto const s1 = udivs.negative_divisors1.at( i );
+      if ( !ntk.is_pi( ntk.get_node( s1 ) ) )
+      {
+        if ( ( ntk.fanout_size( ntk.get_node( s1 ) ) == 4 ) || ( ntk.fanout_size( ntk.get_node( s1 ) ) >= 16 ) || ( ntk.fanout_size( ntk.get_node( s1 ) ) == 1 ) ) // it would mean the depth is actually increased
+          continue;
+      }
+
+      for ( auto j = i + 1; j < udivs.negative_divisors0.size(); ++j )
+      {
+        auto s2 = udivs.negative_divisors0.at( j );
+        if ( !ntk.is_pi( ntk.get_node( s2 ) ) )
+        {
+          if ( ( ntk.fanout_size( ntk.get_node( s2 ) ) == 4 ) || ( ntk.fanout_size( ntk.get_node( s2 ) ) >= 16 ) || ( ntk.fanout_size( ntk.get_node( s2 ) ) == 1 ) )
+            continue;
+        }
+
+        auto const& tt_s0 = sim.get_tt( s0 );
+        auto const& tt_s1 = sim.get_tt( s1 );
+        auto tt_s2 = sim.get_tt( s2 );
+
+        if ( kitty::ternary_majority( ~tt_s0, tt_s1, tt_s2 ) == tt )
+        {
+          // ++st.num_div1_maj_accepts;
+          auto const a = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+          auto const b = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+          auto const c = sim.get_phase( ntk.get_node( s2 ) ) ? !s2 : s2;
+          auto e = ntk.create_maj( !a, b, c );
+          if ( ( ntk.fanout_size( ntk.get_node( e ) ) == 2 ) || ( ntk.fanout_size( ntk.get_node( e ) ) == 5 ) || ( ntk.fanout_size( ntk.get_node( e ) ) > 16 ) )
+            continue;
+          else
+            return sim.get_phase( root ) ? !e : e;
+        }
+
+        s2 = udivs.negative_divisors1.at( j );
+        if ( !ntk.is_pi( ntk.get_node( s2 ) ) )
+        {
+          if ( ( ntk.fanout_size( ntk.get_node( s2 ) ) == 4 ) || ( ntk.fanout_size( ntk.get_node( s2 ) ) >= 16 ) || ( ntk.fanout_size( ntk.get_node( s2 ) ) == 1 ) )
+            continue;
+        }
+        tt_s2 = sim.get_tt( s2 );
+
+        if ( kitty::ternary_majority( ~tt_s0, tt_s1, tt_s2 ) == tt )
+        {
+          // ++st.num_div1_maj_accepts;
+          auto const a = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+          auto const b = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+          auto const c = sim.get_phase( ntk.get_node( s2 ) ) ? !s2 : s2;
+          auto e = ntk.create_maj( !a, b, c );
+          if ( ( ntk.fanout_size( ntk.get_node( e ) ) == 2 ) || ( ntk.fanout_size( ntk.get_node( e ) ) == 5 ) || ( ntk.fanout_size( ntk.get_node( e ) ) > 16 ) )
+            continue;
+          else
+            return sim.get_phase( root ) ? !e : e;
+        }
+      }
+    }
+
+    return std::nullopt;
+  }
+
+private:
+  Ntk& ntk;
+  Simulator const& sim;
+  std::vector<node> const& divs;
+  uint32_t const num_divs;
+  stats& st;
+
+  unate_divisors udivs;
+}; /* mig_resub_functor */
+
+template<typename Ntk>
+bool substitute_and_update_fn( Ntk& ntk, typename Ntk::node const& n, typename Ntk::signal const& g )
+{
+  ntk.substitute_node( n, g );
+  ntk.update_levels();
+  ntk.update_fanout();
+  return true;
+};
+
+template<class Ntk, class NodeCostFn>
+void mig_resubstitution_splitters( depth_view<Ntk, NodeCostFn>& ntk, resubstitution_params const& ps = {}, resubstitution_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( std::is_same_v<typename Ntk::base_type, mig_network>, "Network type is not mig_network" );
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the has_size method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the has substitute_node method" );
+  static_assert( has_value_v<Ntk>, "Ntk does not implement the has_value method" );
+  static_assert( has_visited_v<Ntk>, "Ntk does not implement the has_visited method" );
+
+  using resub_view_t = fanout_view<depth_view<Ntk, NodeCostFn>>;
+  resub_view_t resub_view{ ntk };
+
+  if ( ps.max_pis == 8 )
+  {
+    using truthtable_t = kitty::static_truth_table<8>;
+    using truthtable_dc_t = kitty::dynamic_truth_table;
+    using functor_t = mig_resub_splitters_functor<resub_view_t, typename detail::window_simulator<resub_view_t, truthtable_t>, truthtable_dc_t>;
+    using resub_impl_t = detail::resubstitution_impl<resub_view_t, typename detail::window_based_resub_engine<resub_view_t, truthtable_t, truthtable_dc_t, functor_t>>;
+
+    resubstitution_stats st;
+    typename resub_impl_t::engine_st_t engine_st;
+    typename resub_impl_t::collector_st_t collector_st;
+
+    resub_impl_t p( resub_view, ps, st, engine_st, collector_st );
+    p.run( substitute_and_update_fn<resub_view_t> );
+
+    if ( ps.verbose )
+    {
+      st.report();
+      collector_st.report();
+      engine_st.report();
+    }
+
+    if ( pst )
+    {
+      *pst = st;
+    }
+  }
+  else
+  {
+    using truthtable_t = kitty::dynamic_truth_table;
+    using truthtable_dc_t = kitty::dynamic_truth_table;
+    using functor_t = mig_resub_splitters_functor<resub_view_t, typename detail::window_simulator<resub_view_t, truthtable_t>, truthtable_dc_t>;
+    using resub_impl_t = detail::resubstitution_impl<resub_view_t, typename detail::window_based_resub_engine<resub_view_t, truthtable_t, truthtable_dc_t, functor_t>>;
+
+    resubstitution_stats st;
+    typename resub_impl_t::engine_st_t engine_st;
+    typename resub_impl_t::collector_st_t collector_st;
+
+    resub_impl_t p( resub_view, ps, st, engine_st, collector_st );
+    p.run( substitute_and_update_fn<resub_view_t> );
+
+    if ( ps.verbose )
+    {
+      st.report();
+      collector_st.report();
+      engine_st.report();
+    }
+
+    if ( pst )
+    {
+      *pst = st;
+    }
+  }
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/aqfp/optimal_buffer_insertion.hpp b/include/mockturtle/algorithms/aqfp/optimal_buffer_insertion.hpp
new file mode 100644
index 0000000..859f681
--- /dev/null
+++ b/include/mockturtle/algorithms/aqfp/optimal_buffer_insertion.hpp
@@ -0,0 +1,563 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file optimal_buffer_insertion.hpp
+  \brief Global-optimal buffer insertion for AQFP using SMT
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+// NOTE: This file is included inside the class `mockturtle::buffer_insertion`
+// It should not be included anywhere else.
+
+#pragma region Compute timeframe for SMT solving
+  /*! \brief Compute the earliest and latest possible timeframe by eager ASAP and ALAP */
+  uint32_t compute_timeframe( uint32_t max_depth )
+  {
+    // TODO: Consider max_depth % _ps.assume.num_phases == 0 constraint
+    _timeframes.reset( std::make_pair( 0, 0 ) );
+    uint32_t min_depth{ 0 };
+
+    _ntk.incr_trav_id();
+    _ntk.foreach_po( [&]( auto const& f ) {
+      auto const no = _ntk.get_node( f );
+      auto clevel = compute_levels_ASAP_eager( no ) + ( _ntk.fanout_size( no ) > 1 ? 1 : 0 );
+      min_depth = std::max( min_depth, clevel );
+    } );
+
+    _ntk.incr_trav_id();
+    _ntk.foreach_po( [&]( auto const& f ) {
+      const auto n = _ntk.get_node( f );
+      if ( !_ntk.is_constant( n ) && _ntk.visited( n ) != _ntk.trav_id() )
+      {
+        _timeframes[n].second = max_depth - ( _ntk.fanout_size( n ) > 1 ? 1 : 0 );
+        compute_levels_ALAP_eager( n );
+      }
+    } );
+
+    return min_depth;
+  }
+
+  uint32_t compute_levels_ASAP_eager( node const& n )
+  {
+    if ( _ntk.visited( n ) == _ntk.trav_id() )
+    {
+      return _timeframes[n].first;
+    }
+    _ntk.set_visited( n, _ntk.trav_id() );
+
+    if ( _ntk.is_constant( n ) )
+    {
+      return _timeframes[n].first = 0;
+    }
+    if ( _ntk.is_pi( n ) )
+    {
+      return _timeframes[n].first = _ps.assume.ci_phases[0];
+    }
+
+    uint32_t level{ 0 };
+    _ntk.foreach_fanin( n, [&]( auto const& fi ) {
+      auto const ni = _ntk.get_node( fi );
+      if ( !_ntk.is_constant( ni ) )
+      {
+        level = std::max( level, compute_levels_ASAP_eager( ni ) + ( _ntk.fanout_size( ni ) > 1 ? 1 : 0 ) );
+      }
+    } );
+
+    return _timeframes[n].first = level + 1;
+  }
+
+  void compute_levels_ALAP_eager( node const& n )
+  {
+    _ntk.set_visited( n, _ntk.trav_id() );
+
+    _ntk.foreach_fanin( n, [&]( auto const& fi ) {
+      auto const ni = _ntk.get_node( fi );
+      if ( !_ntk.is_constant( ni ) )
+      {
+        if ( _ps.assume.balance_cios && _ntk.is_pi( ni ) )
+        {
+          assert( _timeframes[n].second > _ps.assume.ci_phases[0] );
+          _timeframes[ni].second = _ps.assume.ci_phases[0];
+        }
+        else
+        {
+          assert( _timeframes[n].second > num_splitter_levels( ni ) );
+          auto fi_level = _timeframes[n].second - ( _ntk.fanout_size( ni ) > 1 ? 2 : 1 );
+          if ( _ntk.visited( ni ) != _ntk.trav_id() || _timeframes[ni].second > fi_level )
+          {
+            _timeframes[ni].second = fi_level;
+            compute_levels_ALAP_eager( ni );
+          }
+        }
+      }
+    } );
+  }
+#pragma
+
+#if __GNUC__ == 7
+
+void optimize_with_smt( std::string name = "" )
+{}
+
+#else
+
+void optimize_with_smt( std::string name = "" )
+{
+  std::ofstream os( "model_" + name + ".smt2", std::ofstream::out );
+  dump_smt_model( os );
+  os.close();
+  std::string command = "z3 -v:1 model_" + name + ".smt2 &> sol_" + name + ".txt";
+  std::system( command.c_str() );
+  parse_z3_result( "sol_" + name + ".txt" );
+  return;
+}
+
+// ILP formulation
+void dump_smt_model( std::ostream& os = std::cout )
+{
+  os << "(set-logic QF_LIA)\n";
+  /* hard assumptions to bound the number of variables */
+  uint32_t const max_depth = depth(); // + 3;
+  uint32_t const max_relative_depth = max_depth;
+  count_buffers();
+  uint32_t const upper_bound = num_buffers();
+  uint32_t const min_depth = compute_timeframe( max_depth );
+
+  /* depth variable */
+  if ( _ps.assume.balance_pos ) /* depth is a variable */
+  {
+    os << fmt::format( "(declare-const depth Int)\n" );
+    assert( min_depth <= max_depth );
+    os << fmt::format( "(assert (<= depth {}))\n", max_depth );
+    os << fmt::format( "(assert (>= depth {}))\n", min_depth );
+  }
+
+  /* declare variables for the level of each node */
+  std::vector<std::string> level_vars;
+  if ( _ps.assume.branch_pis && !_ps.assume.balance_pis )
+  {
+    /* Only if we branch but not balance PIs, they are free variables as gates */
+    _ntk.foreach_pi( [&]( auto const& n ) {
+      level_vars.emplace_back( fmt::format( "l{}", n ) );
+      os << fmt::format( "(declare-const l{} Int)\n", n );
+      if ( _ps.assume.balance_pos )
+        os << fmt::format( "(assert (<= l{} depth))\n", n );
+      assert( _timeframes[n].second <= max_depth );
+      os << fmt::format( "(assert (<= l{} {}))\n", n, _timeframes[n].second );
+      os << fmt::format( "(assert (>= l{} 0))\n", n );
+    } );
+  }
+
+  _ntk.foreach_gate( [&]( auto const& n ) {
+    level_vars.emplace_back( fmt::format( "l{}", n ) );
+    os << fmt::format( "(declare-const l{} Int)\n", n );
+    if ( _ps.assume.balance_pos )
+      os << fmt::format( "(assert (<= l{} depth))\n", n );
+    assert( _timeframes[n].first >= 1 && _timeframes[n].second <= max_depth && _timeframes[n].first <= _timeframes[n].second );
+    os << fmt::format( "(assert (>= l{} {}))\n", n, _timeframes[n].first );
+    os << fmt::format( "(assert (<= l{} {}))\n", n, _timeframes[n].second );
+  } );
+
+  /* constraints for each gate's fanout */
+  std::vector<std::string> bufs;
+  if ( _ps.assume.branch_pis )
+  {
+    /* If PIs are balanced, they are always at level 0 so we don't have variables for them */
+    if ( _ps.assume.balance_pis )
+    {
+      _ntk.foreach_pi( [&]( auto const& n ) {
+        smt_constraints_balanced_pis( os, n, max_depth );
+        bufs.emplace_back( fmt::format( "bufs{}", n ) );
+      } );
+    }
+    else
+    {
+      _ntk.foreach_pi( [&]( auto const& n ) {
+        smt_constraints( os, n, max_depth );
+        bufs.emplace_back( fmt::format( "bufs{}", n ) );
+      } );
+    }
+  }
+  _ntk.foreach_gate( [&]( auto const& n ) {
+    smt_constraints( os, n, max_depth );
+    bufs.emplace_back( fmt::format( "bufs{}", n ) );
+  } );
+
+  os << "\n(declare-const total Int)\n";
+  os << fmt::format( "(assert (= total (+ {})))\n", fmt::join( bufs, " " ) );
+  os << fmt::format( "(assert (<= total {}))\n", upper_bound );
+  os << "(minimize total)\n(check-sat)\n";
+  if ( _ps.assume.balance_pos )
+    os << "(get-value (total depth))\n";
+  else
+    os << "(get-value (total))\n";
+  os << fmt::format( "(get-value ({}))\n(exit)\n", fmt::join( level_vars, " " ) );
+}
+
+void smt_constraints_balanced_pis( std::ostream& os, node const& n, uint32_t const& max_depth )
+{
+  os << fmt::format( "\n;constraints for node {}\n", n );
+  os << fmt::format( "(declare-const bufs{} Int)\n", n );
+  /* special cases */
+  if ( _ntk.fanout_size( n ) == 0 ) /* dangling */
+  {
+    os << fmt::format( "(assert (= bufs{} 0))\n", n );
+    return;
+  }
+  else if ( _ntk.fanout_size( n ) == 1 )
+  {
+    /* single fanout: only sequencing constraint */
+    if ( _external_ref_count[n] > 0 )
+    {
+      if ( _ps.assume.balance_pos )
+      {
+        os << fmt::format( "(assert (= bufs{} depth))\n", n );
+      }
+      else
+      {
+        os << fmt::format( "(assert (= bufs{} 0))\n", n );
+      }
+    }
+    else
+    {
+      node const& no = _fanouts[n].front().fanouts.front();
+      os << fmt::format( "(assert (= bufs{} (- l{} 1)))\n", n, no );
+    }
+    return;
+  }
+  else if ( _ntk.fanout_size( n ) <= _ps.assume.splitter_capacity )
+  {
+    /* only one splitter is needed */
+
+    /* sequencing */
+    std::vector<node> fos;
+    foreach_fanout( n, [&]( auto const& no ) {
+      os << fmt::format( "(assert (>= l{} 2))\n", no );
+      fos.emplace_back( no );
+    } );
+
+    if ( _external_ref_count[n] > 0 && _ps.assume.balance_pos )
+    {
+      os << fmt::format( "(assert (= bufs{} depth))\n", n );
+    }
+    else
+    {
+      if ( fos.size() == 0 ) /* not balance PO; have multiple PO refs */
+      {
+        os << fmt::format( "(assert (= bufs{} 1))\n", n );
+      }
+      else if ( fos.size() == 1 ) /* not balance PO; have one gate fanout and PO ref(s) */
+      {
+        os << fmt::format( "(assert (= bufs{} (- l{} 1)))\n", n, fos[0] );
+      }
+      else if ( fos.size() >= 2 )
+      {
+        os << fmt::format( "(declare-const g{}maxfo Int)\n", n ); /* the max level of fanouts */
+
+        /* bound it -- just to hint the solver; should not matter if we have optimization objective */
+        if ( _ps.assume.balance_pos )
+          os << fmt::format( "(assert (<= g{}maxfo depth))\n", n );
+        else
+          os << fmt::format( "(assert (<= g{}maxfo {}))\n", n, max_depth );
+
+        /* taking the max (lower bounded by the max) */
+        for ( auto const& no : fos )
+          os << fmt::format( "(assert (>= g{}maxfo l{}))\n", n, no );
+
+        os << fmt::format( "(assert (= bufs{} (- g{}maxfo 1)))\n", n, n );
+      }
+    }
+    return;
+  }
+
+  /* sequencing & range constraints */
+  foreach_fanout( n, [&]( auto const& no ) {
+    os << fmt::format( "(assert (>= l{} 2))\n", no );
+  } );
+
+  /* PO branching */
+  if ( _external_ref_count[n] > 0 )
+  {
+    os << fmt::format( "(assert (>= depth {}))\n", num_splitter_levels( n ) );
+  }
+
+  /* max possible relative depth */
+  uint32_t highest_fanout = 0;
+  if ( _external_ref_count[n] > 0 && _ps.assume.balance_pos )
+  {
+    highest_fanout = max_depth + 1;
+  }
+  else
+  {
+    foreach_fanout( n, [&]( auto const& no ) {
+      highest_fanout = std::max( highest_fanout, _timeframes[no].second );
+    } );
+  }
+  uint32_t max_relative_depth = highest_fanout;
+
+  uint32_t l = max_relative_depth;
+  bool add_po_refs = false;
+  if ( _external_ref_count[n] > 0 && _ps.assume.balance_pos )
+  {
+    add_po_refs = true;
+    os << fmt::format( "(assert (<= depth {}))\n", l - 1 );
+  }
+
+  /* initial case */
+  os << fmt::format( "(declare-const g{}e{} Int)\n", n, l ); // edges at relative depth l
+  os << fmt::format( "(assert (= g{}e{} (+", n, l );
+  foreach_fanout( n, [&]( auto const& no ) {
+    os << fmt::format( " (ite (= l{} {}) 1 0)", no, l );
+  } );
+  if ( add_po_refs )
+    os << fmt::format( " (ite (= depth {}) {} 0)", l - 1, _external_ref_count[n] );
+  os << ")))\n";
+
+  /* general case */
+  for ( --l; l > 0; --l )
+  {
+    os << fmt::format( "(declare-const g{}b{} Int)\n", n, l ); // buffers at relative depth l
+    /* g{n}b{l} = ceil( g{n}e{l+1} / s_b ) --> s_b * ( g{n}b{l} - 1 ) < g{n}e{l+1} <= s_b * g{n}b{l} */
+    os << fmt::format( "(assert (< (* {} (- g{}b{} 1)) g{}e{}))\n", _ps.assume.splitter_capacity, n, l, n, l + 1 );
+    os << fmt::format( "(assert (<= g{}e{} (* {} g{}b{})))\n", n, l + 1, _ps.assume.splitter_capacity, n, l );
+
+    os << fmt::format( "(declare-const g{}e{} Int)\n", n, l ); // edges at relative depth l
+    os << fmt::format( "(assert (= g{}e{} (+", n, l );
+    foreach_fanout( n, [&]( auto const& no ) {
+      os << fmt::format( " (ite (= l{} {}) 1 0)", no, l );
+    } );
+    if ( add_po_refs )
+      os << fmt::format( " (ite (= depth {}) {} 0)", l - 1, _external_ref_count[n] );
+    os << fmt::format( " g{}b{})))\n", n, l );
+  }
+
+  /* end of loop */
+  os << fmt::format( "(assert (= g{}e1 1))\n", n ); // legal
+  os << fmt::format( "(assert (= bufs{} (+", n );
+  for ( l = max_relative_depth - 1; l > 0; --l )
+  {
+    os << fmt::format( " g{}b{}", n, l );
+  }
+  os << ")))\n";
+}
+
+void smt_constraints( std::ostream& os, node const& n, uint32_t const& max_depth )
+{
+  os << fmt::format( "\n;constraints for node {}\n", n );
+  os << fmt::format( "(declare-const bufs{} Int)\n", n );
+  /* special cases */
+  if ( _ntk.fanout_size( n ) == 0 ) /* dangling */
+  {
+    os << fmt::format( "(assert (= bufs{} 0))\n", n );
+    return;
+  }
+  else if ( _ntk.fanout_size( n ) == 1 )
+  {
+    /* single fanout: only sequencing constraint */
+    if ( _external_ref_count[n] > 0 )
+    {
+      if ( _ps.assume.balance_pos )
+      {
+        os << fmt::format( "(assert (= bufs{} (- depth l{})))\n", n, n );
+      }
+      else
+      {
+        os << fmt::format( "(assert (= bufs{} 0))\n", n );
+      }
+    }
+    else
+    {
+      node const& no = _fanouts[n].front().fanouts.front();
+      os << fmt::format( "(assert (> l{} l{}))\n", no, n );
+      os << fmt::format( "(assert (= bufs{} (- l{} l{} 1)))\n", n, no, n );
+    }
+    return;
+  }
+  else if ( _ntk.fanout_size( n ) <= _ps.assume.splitter_capacity )
+  {
+    /* only one splitter is needed */
+
+    /* sequencing */
+    std::vector<node> fos;
+    foreach_fanout( n, [&]( auto const& no ) {
+      os << fmt::format( "(assert (>= l{} (+ l{} 2)))\n", no, n );
+      fos.emplace_back( no );
+    } );
+
+    if ( _external_ref_count[n] > 0 && _ps.assume.balance_pos )
+    {
+      os << fmt::format( "(assert (> depth l{}))\n", n );
+      os << fmt::format( "(assert (= bufs{} (- depth l{})))\n", n, n );
+    }
+    else
+    {
+      if ( fos.size() == 0 ) /* not balance PO; have multiple PO refs */
+      {
+        os << fmt::format( "(assert (= bufs{} 1))\n", n );
+      }
+      else if ( fos.size() == 1 ) /* not balance PO; have one gate fanout and PO ref(s) */
+      {
+        os << fmt::format( "(assert (= bufs{} (- l{} l{} 1)))\n", n, fos[0], n );
+      }
+      else if ( fos.size() >= 2 )
+      {
+        os << fmt::format( "(declare-const g{}maxfo Int)\n", n ); /* the max level of fanouts */
+
+        /* bound it -- just to hint the solver; should not matter if we have optimization objective */
+        if ( _ps.assume.balance_pos )
+          os << fmt::format( "(assert (<= g{}maxfo depth))\n", n );
+        else
+          os << fmt::format( "(assert (<= g{}maxfo {}))\n", n, max_depth );
+
+        /* taking the max (lower bounded by the max) */
+        for ( auto const& no : fos )
+          os << fmt::format( "(assert (>= g{}maxfo l{}))\n", n, no );
+
+        os << fmt::format( "(assert (= bufs{} (- g{}maxfo l{} 1)))\n", n, n, n );
+      }
+    }
+    return;
+  }
+
+  /* max possible relative depth */
+  uint32_t highest_fanout = 0;
+  if ( _external_ref_count[n] > 0 && _ps.assume.balance_pos )
+  {
+    highest_fanout = max_depth + 1;
+  }
+  else
+  {
+    foreach_fanout( n, [&]( auto const& no ) {
+      highest_fanout = std::max( highest_fanout, _timeframes[no].second );
+    } );
+  }
+  uint32_t max_relative_depth = highest_fanout - _timeframes[n].first;
+
+  /* sequencing & range constraints */
+  foreach_fanout( n, [&]( auto const& no ) {
+    os << fmt::format( "(assert (<= l{} (+ l{} {})))\n", no, n, max_relative_depth );
+    os << fmt::format( "(assert (>= l{} (+ l{} 2)))\n", no, n );
+  } );
+
+  /* PO branching */
+  if ( _external_ref_count[n] > 0 && _ps.assume.balance_pos )
+  {
+    os << fmt::format( "(assert (>= depth (+ l{} {})))\n", n, num_splitter_levels( n ) );
+  }
+
+  uint32_t l = max_relative_depth;
+  bool add_po_refs = false;
+  if ( _external_ref_count[n] > 0 && _ps.assume.balance_pos )
+  {
+    add_po_refs = true;
+    os << fmt::format( "(assert (<= depth (+ l{} {})))\n", n, l - 1 );
+  }
+
+  /* initial case */
+  os << fmt::format( "(declare-const g{}e{} Int)\n", n, l ); // edges at relative depth l
+  os << fmt::format( "(assert (= g{}e{} (+", n, l );
+  foreach_fanout( n, [&]( auto const& no ) {
+    os << fmt::format( " (ite (= (- l{} l{}) {}) 1 0)", no, n, l );
+  } );
+  if ( add_po_refs )
+    os << fmt::format( " (ite (= (+ l{} {}) depth) {} 0)", n, l - 1, _external_ref_count[n] );
+  os << ")))\n";
+
+  /* general case */
+  for ( --l; l > 0; --l )
+  {
+    os << fmt::format( "(declare-const g{}b{} Int)\n", n, l ); // buffers at relative depth l
+    /* g{n}b{l} = ceil( g{n}e{l+1} / s_b ) --> s_b * ( g{n}b{l} - 1 ) < g{n}e{l+1} <= s_b * g{n}b{l} */
+    os << fmt::format( "(assert (< (* {} (- g{}b{} 1)) g{}e{}))\n", _ps.assume.splitter_capacity, n, l, n, l + 1 );
+    os << fmt::format( "(assert (<= g{}e{} (* {} g{}b{})))\n", n, l + 1, _ps.assume.splitter_capacity, n, l );
+
+    os << fmt::format( "(declare-const g{}e{} Int)\n", n, l ); // edges at relative depth l
+    os << fmt::format( "(assert (= g{}e{} (+", n, l );
+    foreach_fanout( n, [&]( auto const& no ) {
+      os << fmt::format( " (ite (= (- l{} l{}) {}) 1 0)", no, n, l );
+    } );
+    if ( add_po_refs )
+      os << fmt::format( " (ite (= (+ l{} {}) depth) {} 0)", n, l - 1, _external_ref_count[n] );
+    os << fmt::format( " g{}b{})))\n", n, l );
+  }
+
+  /* end of loop */
+  os << fmt::format( "(assert (= g{}e1 1))\n", n ); // legal
+  os << fmt::format( "(assert (= bufs{} (+", n );
+  for ( l = max_relative_depth - 1; l > 0; --l )
+  {
+    os << fmt::format( " g{}b{}", n, l );
+  }
+  os << ")))\n";
+}
+
+template<class Fn>
+void foreach_fanout( node const& n, Fn&& fn )
+{
+  for ( auto it1 = _fanouts[n].begin(); it1 != _fanouts[n].end(); ++it1 )
+  {
+    for ( auto it2 = it1->fanouts.begin(); it2 != it1->fanouts.end(); ++it2 )
+    {
+      fn( *it2 );
+    }
+  }
+}
+
+void parse_z3_result( std::string filename )
+{
+  std::ifstream fin( filename, std::ifstream::in );
+  assert( fin.is_open() );
+
+  /* parsing */
+  std::string line;
+  do
+  {
+    std::getline( fin, line ); /* first line: "sat" */
+  } while ( line != "sat" );
+  assert( line == "sat" );
+  std::getline( fin, line ); /* second line: "((total <>)" */
+  uint32_t total = std::stoi( line.substr( 8, line.find_first_of( ')' ) - 8 ) );
+  std::cout << "[i] total = " << total;
+  if ( _ps.assume.balance_pos )
+  {
+    std::getline( fin, line ); /* third line: " (depth <>))" */
+    uint32_t depth = std::stoi( line.substr( 8, line.find_first_of( ')' ) - 8 ) );
+    std::cout << ", depth = " << depth;
+  }
+  std::cout << "\n";
+
+  while ( std::getline( fin, line ) ) /* remaining lines: "((l<> <>)" or " (l<> <>)" or " (l<> <>))" */
+  {
+    line = line.substr( line.find( 'l' ) + 1 );
+    uint32_t n = std::stoi( line.substr( 0, line.find( ' ' ) ) );
+    line = line.substr( line.find( ' ' ) + 1 );
+    _levels[n] = std::stoi( line.substr( 0, line.find_first_of( ')' ) ) );
+  }
+  adjust_depth();
+}
+
+#endif
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/balancing.hpp b/include/mockturtle/algorithms/balancing.hpp
new file mode 100644
index 0000000..0ba4c92
--- /dev/null
+++ b/include/mockturtle/algorithms/balancing.hpp
@@ -0,0 +1,446 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file balancing.hpp
+  \brief Cut-based depth-optimization
+
+  \author Alessandro Tempia Calvino
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <limits>
+#include <memory>
+#include <optional>
+#include <utility>
+#include <vector>
+
+#include <fmt/format.h>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/properties.hpp>
+
+#include "../utils/cost_functions.hpp"
+#include "../utils/node_map.hpp"
+#include "../utils/progress_bar.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../views/depth_view.hpp"
+#include "../views/mapping_view.hpp"
+#include "../views/topo_view.hpp"
+#include "balancing/esop_balancing.hpp"
+#include "balancing/sop_balancing.hpp"
+#include "balancing/utils.hpp"
+#include "cleanup.hpp"
+#include "cut_enumeration.hpp"
+#include "lut_mapper.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for balancing.
+ */
+struct balancing_params
+{
+  /*! \brief Cut enumeration params. */
+  cut_enumeration_params cut_enumeration_ps;
+
+  /*! \brief Optimize only on critical path. */
+  bool only_on_critical_path{ false };
+
+  /*! \brief Show progress. */
+  bool progress{ false };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+};
+
+/*! \brief Statistics for balancing.
+ */
+struct balancing_stats
+{
+  /*! \brief Total run-time. */
+  stopwatch<>::duration time_total{};
+
+  /*! \brief Cut enumeration run-time. */
+  cut_enumeration_stats cut_enumeration_st;
+
+  /*! \brief Prints report. */
+  void report() const
+  {
+    fmt::print( "[i] total time             = {:>5.2f} secs\n", to_seconds( time_total ) );
+    fmt::print( "[i] Cut enumeration stats\n" );
+    cut_enumeration_st.report();
+  }
+};
+
+namespace detail
+{
+
+template<class Ntk, class CostFn>
+struct balancing_impl
+{
+  balancing_impl( Ntk const& ntk, rebalancing_function_t<Ntk> const& rebalancing_fn, balancing_params const& ps, balancing_stats& st )
+      : ntk_( ntk ),
+        rebalancing_fn_( rebalancing_fn ),
+        ps_( ps ),
+        st_( st )
+  {
+  }
+
+  Ntk run()
+  {
+    Ntk dest;
+    node_map<arrival_time_pair<Ntk>, Ntk> old_to_new( ntk_ );
+
+    /* input arrival times and mapping */
+    old_to_new[ntk_.get_constant( false )] = { dest.get_constant( false ), 0u };
+    if ( ntk_.get_node( ntk_.get_constant( false ) ) != ntk_.get_node( ntk_.get_constant( true ) ) )
+    {
+      old_to_new[ntk_.get_constant( true )] = { dest.get_constant( true ), 0u };
+    }
+    ntk_.foreach_pi( [&]( auto const& n ) {
+      old_to_new[n] = { dest.create_pi(), 0u };
+    } );
+
+    std::shared_ptr<depth_view<Ntk, CostFn>> depth_ntk;
+    if ( ps_.only_on_critical_path )
+    {
+      depth_ntk = std::make_shared<depth_view<Ntk, CostFn>>( ntk_ );
+    }
+
+    stopwatch<> t( st_.time_total );
+    const auto cuts = cut_enumeration<Ntk, true>( ntk_, ps_.cut_enumeration_ps, &st_.cut_enumeration_st );
+
+    uint32_t current_level{};
+    const auto size = ntk_.size();
+    progress_bar pbar{ ntk_.size(), "balancing |{0}| node = {1:>4} / " + std::to_string( size ) + "   current level = {2}", ps_.progress };
+    topo_view<Ntk>{ ntk_ }.foreach_node( [&]( auto const& n, auto index ) {
+      pbar( index, index, current_level );
+
+      if ( ntk_.is_constant( n ) || ntk_.is_pi( n ) )
+      {
+        return;
+      }
+
+      if ( ps_.only_on_critical_path && !depth_ntk->is_on_critical_path( n ) )
+      {
+        std::vector<signal<Ntk>> children;
+        ntk_.foreach_fanin( n, [&]( auto const& f ) {
+          const auto f_best = old_to_new[f].f;
+          children.push_back( ntk_.is_complemented( f ) ? dest.create_not( f_best ) : f_best );
+        } );
+        old_to_new[n] = { dest.clone_node( ntk_, n, children ), depth_ntk->level( n ) };
+        return;
+      }
+
+      arrival_time_pair<Ntk> best{ {}, std::numeric_limits<uint32_t>::max() };
+      uint32_t best_size{};
+      for ( auto& cut : cuts.cuts( ntk_.node_to_index( n ) ) )
+      {
+        if ( cut->size() == 1u || kitty::is_const0( cuts.truth_table( *cut ) ) )
+        {
+          continue;
+        }
+
+        std::vector<arrival_time_pair<Ntk>> arrival_times( cut->size() );
+        std::transform( cut->begin(), cut->end(), arrival_times.begin(), [&]( auto leaf ) { return old_to_new[ntk_.index_to_node( leaf )]; } );
+
+        rebalancing_fn_( dest, cuts.truth_table( *cut ), arrival_times, best.level, best_size, [&]( arrival_time_pair<Ntk> const& cand, uint32_t cand_size ) {
+          if ( cand.level < best.level || ( cand.level == best.level && cand_size < best_size ) )
+          {
+            best = cand;
+            best_size = cand_size;
+          }
+        } );
+      }
+      old_to_new[n] = best;
+      current_level = std::max( current_level, best.level );
+    } );
+
+    ntk_.foreach_po( [&]( auto const& f ) {
+      const auto s = old_to_new[f].f;
+      dest.create_po( ntk_.is_complemented( f ) ? dest.create_not( s ) : s );
+    } );
+
+    return cleanup_dangling( dest );
+  }
+
+private:
+  Ntk const& ntk_;
+  rebalancing_function_t<Ntk> const& rebalancing_fn_;
+  balancing_params const& ps_;
+  balancing_stats& st_;
+};
+
+template<class Ntk>
+struct balancing_decomp_impl
+{
+  balancing_decomp_impl( mapping_view<Ntk, true> const& ntk, rebalancing_function_t<Ntk> const& rebalancing_fn )
+      : ntk_( ntk ),
+        rebalancing_fn_( rebalancing_fn )
+  {
+  }
+
+  Ntk run()
+  {
+    Ntk dest;
+    node_map<arrival_time_pair<Ntk>, Ntk> old_to_new( ntk_ );
+
+    /* input arrival times and mapping */
+    old_to_new[ntk_.get_constant( false )] = { dest.get_constant( false ), 0u };
+    if ( ntk_.get_node( ntk_.get_constant( false ) ) != ntk_.get_node( ntk_.get_constant( true ) ) )
+    {
+      old_to_new[ntk_.get_constant( true )] = { dest.get_constant( true ), 0u };
+    }
+
+    ntk_.foreach_pi( [&]( auto const& n ) {
+      old_to_new[n] = { dest.create_pi(), 0u };
+    } );
+
+    if constexpr ( has_foreach_ro_v<Ntk> )
+    {
+      ntk_.foreach_ro( [&]( auto const& n ) {
+        old_to_new[n] = { dest.create_ro(), 0u };
+      } );
+    }
+
+    topo_view<Ntk>{ ntk_ }.foreach_node( [&]( auto const& n, auto index ) {
+      if ( ntk_.is_constant( n ) || ntk_.is_ci( n ) )
+      {
+        return;
+      }
+
+      if ( !ntk_.is_cell_root( n ) )
+      {
+        return;
+      }
+
+      std::vector<arrival_time_pair<Ntk>> arrival_times;
+      ntk_.foreach_cell_fanin( n, [&]( auto const& leaf, uint32_t ctr ) {
+        arrival_times.push_back( old_to_new[ntk_.index_to_node( leaf )] );
+      } );
+
+      kitty::dynamic_truth_table tt = ntk_.cell_function( n );
+
+      rebalancing_fn_( dest, tt, arrival_times, UINT32_MAX, UINT32_MAX, [&]( arrival_time_pair<Ntk> cand, uint32_t cand_size ) {
+        (void)cand_size;
+        old_to_new[n] = cand;
+      } );
+    } );
+
+    ntk_.foreach_po( [&]( auto const& f ) {
+      const auto s = old_to_new[f].f;
+      dest.create_po( ntk_.is_complemented( f ) ? dest.create_not( s ) : s );
+    } );
+
+    if constexpr ( has_foreach_ri_v<Ntk> )
+    {
+      ntk_.foreach_ri( [&]( auto const& f ) {
+        const auto s = old_to_new[f].f;
+        dest.create_ri( ntk_.is_complemented( f ) ? dest.create_not( s ) : s );
+      } );
+    }
+
+    return dest;
+  }
+
+private:
+  mapping_view<Ntk, true> const& ntk_;
+  rebalancing_function_t<Ntk> const& rebalancing_fn_;
+};
+
+} // namespace detail
+
+/*! Balancing of a logic network
+ *
+ * This function implements a dynamic-programming and cut-enumeration based
+ * balancing algorithm.  It returns a new network of the same type and performs
+ * generic balancing by providing a rebalancing function.
+ *
+ * The template parameter `CostFn` is only used to compute the critical paths,
+ * when the `only_on_critical_path` parameter is assigned true.  Note that the
+ * size for rewriting candidates is computed by the rebalancing function and
+ * may not correspond to the cost given by CostFn.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      const auto aig = ...;
+
+      sop_rebalancing<aig_network> balance_fn;
+      balancing_params ps;
+      ps.cut_enumeration_ps.cut_size = 6u;
+      const auto balanced_aig = balancing( aig, {balance_fn}, ps );
+   \endverbatim
+ */
+template<class Ntk, class CostFn = unit_cost<Ntk>>
+Ntk balancing( Ntk const& ntk, rebalancing_function_t<Ntk> const& rebalancing_fn = {}, balancing_params const& ps = {}, balancing_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+  static_assert( has_create_pi_v<Ntk>, "Ntk does not implement the create_pi method" );
+  static_assert( has_create_po_v<Ntk>, "Ntk does not implement the create_po method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+
+  balancing_stats st;
+  const auto dest = detail::balancing_impl<Ntk, CostFn>{ ntk, rebalancing_fn, ps, st }.run();
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  return dest;
+}
+
+/*! \brief SOP balancing of a logic network
+ *
+ * This function implements an LUT-based SOP balancing algorithm.
+ * It returns a new network of the same type and performs
+ * generic balancing by providing a rebalancing function.
+ *
+ */
+template<class Ntk>
+Ntk sop_balancing( Ntk const& ntk, lut_map_params const& ps = {}, lut_map_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+  static_assert( has_create_pi_v<Ntk>, "Ntk does not implement the create_pi method" );
+  static_assert( has_create_po_v<Ntk>, "Ntk does not implement the create_po method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+
+  lut_map_params mps;
+  mps = ps;
+  mps.sop_balancing = true;
+  mps.esop_balancing = false;
+  mps.verbose = false;
+  lut_map_stats st;
+
+  /* perform SOP-driven mapping */
+  mapping_view<Ntk, true> map_ntk{ ntk };
+  lut_map_inplace<decltype( map_ntk ), true>( map_ntk, mps, &st );
+
+  /* decompose mapping */
+  sop_rebalancing<Ntk> balance_fn;
+  balance_fn.both_phases_ = true;
+  const auto dest = call_with_stopwatch( st.time_total, [&]() {
+    return detail::balancing_decomp_impl<Ntk>{ map_ntk, balance_fn }.run();
+  } );
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  return dest;
+}
+
+/*! \brief ESOP balancing of a logic network
+ *
+ * This function implements an LUT-based ESOP balancing algorithm.
+ * It returns a new network of the same type and performs
+ * generic balancing by providing a rebalancing function.
+ *
+ */
+template<class Ntk>
+Ntk esop_balancing( Ntk const& ntk, lut_map_params const& ps = {}, lut_map_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+  static_assert( has_create_pi_v<Ntk>, "Ntk does not implement the create_pi method" );
+  static_assert( has_create_po_v<Ntk>, "Ntk does not implement the create_po method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+
+  lut_map_params mps;
+  mps = ps;
+  mps.esop_balancing = true;
+  mps.sop_balancing = false;
+  mps.verbose = false;
+  lut_map_stats st;
+
+  /* perform ESOP-driven mapping */
+  mapping_view<Ntk, true> map_ntk{ ntk };
+  lut_map_inplace<decltype( map_ntk ), true>( map_ntk, mps, &st );
+
+  /* decompose mapping */
+  esop_rebalancing<Ntk> balance_fn;
+  balance_fn.both_phases = true;
+  const auto dest = call_with_stopwatch( st.time_total, [&]() {
+    return detail::balancing_decomp_impl<Ntk>{ map_ntk, balance_fn }.run();
+  } );
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  return dest;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/balancing/esop_balancing.hpp b/include/mockturtle/algorithms/balancing/esop_balancing.hpp
new file mode 100644
index 0000000..af717c8
--- /dev/null
+++ b/include/mockturtle/algorithms/balancing/esop_balancing.hpp
@@ -0,0 +1,305 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file esop_balancing.hpp
+  \brief ESOP-based balancing engine for `balancing` algorithm
+
+  \author Alessandro Tempia Calvino
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <queue>
+#include <tuple>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <kitty/cube.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/esop.hpp>
+#include <kitty/hash.hpp>
+#include <kitty/operations.hpp>
+#include <kitty/spp.hpp>
+
+#include "../../traits.hpp"
+#include "../../utils/stopwatch.hpp"
+#include "../balancing.hpp"
+#include "../exorcism.hpp"
+#include "utils.hpp"
+
+namespace mockturtle
+{
+
+template<class Ntk>
+struct esop_rebalancing
+{
+  void operator()( Ntk& dest, kitty::dynamic_truth_table const& function, std::vector<arrival_time_pair<Ntk>> const& inputs, uint32_t best_level, uint32_t best_cost, rebalancing_function_callback_t<Ntk> const& callback ) const
+  {
+    bool inverted = false;
+    auto [and_terms, max_level, num_and_gates] = create_function( dest, function, inputs, inverted );
+
+    /* Try with MUX decomposition */
+    if ( mux_optimization )
+    {
+      const auto index = std::distance( inputs.begin(), std::max_element( inputs.begin(), inputs.end(), []( auto const& a1, auto const& a2 ) { return a1.level < a2.level; } ) );
+
+      bool inverted0 = false, inverted1 = false;
+      auto [and_terms0, max_level0, num_and_gates0] = create_function( dest, kitty::cofactor0( function, static_cast<uint8_t>( index ) ), inputs, inverted0 );
+      auto [and_terms1, max_level1, num_and_gates1] = create_function( dest, kitty::cofactor1( function, static_cast<uint8_t>( index ) ), inputs, inverted1 );
+
+      const auto max_level_mux = std::max( max_level0, max_level1 ) + 1u;
+
+      if ( max_level_mux < max_level && max_level_mux < best_level )
+      {
+        callback( { dest.create_ite( inputs[index].f,
+                                     balanced_xor_tree( dest, and_terms1 ).f ^ inverted1,
+                                     balanced_xor_tree( dest, and_terms0 ).f ^ inverted0 ),
+                                     max_level_mux },
+                                     num_and_gates0 + num_and_gates1 + 1u );
+        return;
+      }
+    }
+
+    arrival_time_pair<Ntk> cand = balanced_xor_tree( dest, and_terms );
+    if ( cand.level < best_level || ( cand.level == best_level && num_and_gates < best_cost ) )
+    {
+      cand.f = cand.f ^ inverted;
+      callback( cand, num_and_gates );
+    }
+  }
+
+private:
+  std::tuple<arrival_time_queue<Ntk>, uint32_t, uint32_t> create_function( Ntk& dest, kitty::dynamic_truth_table const& func, std::vector<arrival_time_pair<Ntk>> const& arrival_times, bool& inverted ) const
+  {
+    if ( spp_optimization )
+    {
+      return create_function_from_spp( dest, func, arrival_times, inverted );
+    }
+    else
+    {
+      return create_function_from_esop( dest, func, arrival_times, inverted );
+    }
+  }
+
+  std::tuple<arrival_time_queue<Ntk>, uint32_t, uint32_t> create_function_from_esop( Ntk& dest, kitty::dynamic_truth_table const& func, std::vector<arrival_time_pair<Ntk>> const& arrival_times, bool& inverted ) const
+  {
+    const auto esop = create_sop_form( func, inverted );
+
+    stopwatch<> t_tree( time_tree_balancing );
+    arrival_time_queue<Ntk> and_terms;
+    uint32_t max_level{};
+    uint32_t num_and_gates{};
+    for ( auto const& cube : esop )
+    {
+      arrival_time_queue<Ntk> product_queue;
+      for ( auto i = 0u; i < func.num_vars(); ++i )
+      {
+        if ( cube.get_mask( i ) )
+        {
+          const auto [f, l] = arrival_times[i];
+          product_queue.push( { cube.get_bit( i ) ? f : dest.create_not( f ), l } );
+        }
+      }
+      if ( product_queue.size() )
+      {
+        num_and_gates += static_cast<uint32_t>( product_queue.size() ) - 1u;
+      }
+      arrival_time_pair<Ntk> and_res = balanced_and_tree( dest, product_queue );
+      and_terms.push( and_res );
+      max_level = std::max( max_level, and_res.level );
+    }
+    return { and_terms, max_level, num_and_gates };
+  }
+
+  std::tuple<arrival_time_queue<Ntk>, uint32_t, uint32_t> create_function_from_spp( Ntk& dest, kitty::dynamic_truth_table const& func, std::vector<arrival_time_pair<Ntk>> const& arrival_times, bool& inverted ) const
+  {
+    const auto esop = create_sop_form( func, inverted );
+    const auto [spp, sums] = kitty::simple_spp( esop, func.num_vars() );
+
+    stopwatch<> t_tree( time_tree_balancing );
+    arrival_time_queue<Ntk> and_terms;
+    uint32_t max_level{};
+    uint32_t num_and_gates{};
+    for ( auto const& cube : spp )
+    {
+      arrival_time_queue<Ntk> product_queue;
+      for ( auto i = 0u; i < func.num_vars(); ++i )
+      {
+        if ( cube.get_mask( i ) )
+        {
+          const auto [f, l] = arrival_times[i];
+          product_queue.push( { cube.get_bit( i ) ? f : dest.create_not( f ), l } );
+        }
+      }
+      for ( auto i = 0u; i < sums.size(); ++i )
+      {
+        if ( cube.get_mask( func.num_vars() + i ) )
+        {
+          std::vector<signal<Ntk>> xor_terms;
+          uint32_t xor_level{};
+          for ( auto j = 0u; j < func.num_vars(); ++j )
+          {
+            if ( ( sums[i] >> j ) & 1 )
+            {
+              const auto [f, l] = arrival_times[j];
+              xor_terms.push_back( f );
+              xor_level = std::max( xor_level, l );
+            }
+          }
+          const auto f = dest.create_nary_xor( xor_terms );
+          product_queue.push( { cube.get_bit( func.num_vars() + i ) ? f : dest.create_not( f ), xor_level } );
+        }
+      }
+      if ( product_queue.size() )
+      {
+        num_and_gates += static_cast<uint32_t>( product_queue.size() ) - 1u;
+      }
+      arrival_time_pair<Ntk> and_res = balanced_and_tree( dest, product_queue );
+      and_terms.push( and_res );
+      max_level = std::max( max_level, and_res.level );
+    }
+    return { and_terms, max_level, num_and_gates };
+  }
+
+  arrival_time_pair<Ntk> balanced_and_tree( Ntk& dest, arrival_time_queue<Ntk>& queue ) const
+  {
+    if ( queue.empty() )
+    {
+      return { dest.get_constant( true ), 0u };
+    }
+
+    while ( queue.size() > 1u )
+    {
+      auto [s1, l1] = queue.top();
+      queue.pop();
+      auto [s2, l2] = queue.top();
+      queue.pop();
+      const auto s = dest.create_and( s1, s2 );
+      const auto l = std::max( l1, l2 ) + 1;
+      queue.push( { s, l } );
+    }
+    return queue.top();
+  }
+
+  arrival_time_pair<Ntk> balanced_xor_tree( Ntk& dest, arrival_time_queue<Ntk>& queue ) const
+  {
+    if ( queue.empty() )
+    {
+      return { dest.get_constant( true ), 0u };
+    }
+
+    while ( queue.size() > 1u )
+    {
+      auto [s1, l1] = queue.top();
+      queue.pop();
+      auto [s2, l2] = queue.top();
+      queue.pop();
+      const auto s = dest.create_xor( s1, s2 );
+      const auto l = std::max( l1, l2 ) + 1;
+      queue.push( { s, l } );
+    }
+    return queue.top();
+  }
+
+  std::vector<kitty::cube> create_sop_form( kitty::dynamic_truth_table const& func, bool& inverted ) const
+  {
+    stopwatch<> t( time_sop );
+    inverted = false;
+
+    if ( auto it = sop_hash_.find( func ); it != sop_hash_.end() )
+    {
+      sop_cache_hits++;
+      return it->second;
+    }
+
+    if ( both_phases )
+    {
+      if ( auto it = sop_hash_.find( ~func ); it != sop_hash_.end() )
+      {
+        inverted = true;
+        sop_cache_hits++;
+        return it->second;
+      }
+    }
+
+    sop_cache_misses++;
+    std::vector<kitty::cube> sop = mockturtle::exorcism( func );
+
+    if ( both_phases )
+    {
+      std::vector<kitty::cube> n_sop = mockturtle::exorcism( ~func );
+
+      if ( n_sop.size() < sop.size() )
+      {
+        inverted = true;
+        return sop_hash_[~func] = n_sop;
+      }
+      else if ( n_sop.size() == sop.size() )
+      {
+        /* compute literal cost */
+        uint32_t lit = 0, n_lit = 0;
+        for ( auto const& c : sop )
+        {
+          lit += c.num_literals();
+        }
+        for ( auto const& c : n_sop )
+        {
+          n_lit += c.num_literals();
+        }
+
+        if ( n_lit < lit )
+        {
+          inverted = true;
+          return sop_hash_[~func] = n_sop;
+        }
+      }
+    }
+
+    return sop_hash_[func] = sop;
+  }
+
+private:
+  mutable std::unordered_map<kitty::dynamic_truth_table, std::vector<kitty::cube>, kitty::hash<kitty::dynamic_truth_table>> sop_hash_;
+
+public:
+  bool both_phases{ false };
+  bool spp_optimization{ false };
+  bool mux_optimization{ false };
+
+public:
+  mutable uint32_t sop_cache_hits{};
+  mutable uint32_t sop_cache_misses{};
+
+  mutable stopwatch<>::duration time_sop{};
+  mutable stopwatch<>::duration time_tree_balancing{};
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/balancing/sop_balancing.hpp b/include/mockturtle/algorithms/balancing/sop_balancing.hpp
new file mode 100644
index 0000000..0b808ea
--- /dev/null
+++ b/include/mockturtle/algorithms/balancing/sop_balancing.hpp
@@ -0,0 +1,201 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file sop_balancing.hpp
+  \brief SOP-based balancing engine for `balancing` algorithm
+
+  \author Alessandro Tempia Calvino
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <queue>
+#include <tuple>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <kitty/cube.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/hash.hpp>
+#include <kitty/isop.hpp>
+#include <kitty/operations.hpp>
+
+#include "../../traits.hpp"
+#include "../../utils/stopwatch.hpp"
+#include "../balancing.hpp"
+#include "utils.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief SOP rebalancing function
+ *
+ * This class can be used together with the generic `balancing` function.  It
+ * converts each cut function into an SOP and then performs weight-oriented
+ * tree balancing on the AND terms and the outer OR function.
+ */
+template<class Ntk>
+struct sop_rebalancing
+{
+  void operator()( Ntk& dest, kitty::dynamic_truth_table const& function, std::vector<arrival_time_pair<Ntk>> const& inputs, uint32_t best_level, uint32_t best_cost, rebalancing_function_callback_t<Ntk> const& callback ) const
+  {
+    bool inverted = false;
+    auto [and_terms, num_and_gates] = create_function( dest, function, inputs, inverted );
+    const auto num_gates = num_and_gates + ( and_terms.empty() ? 0u : static_cast<uint32_t>( and_terms.size() ) - 1u );
+    arrival_time_pair<Ntk> cand = balanced_tree( dest, and_terms, false );
+
+    if ( cand.level < best_level || ( cand.level == best_level && num_gates < best_cost ) )
+    {
+      cand.f = cand.f ^ inverted;
+      callback( cand, num_gates );
+    }
+  }
+
+private:
+  std::pair<arrival_time_queue<Ntk>, uint32_t> create_function( Ntk& dest, kitty::dynamic_truth_table const& func, std::vector<arrival_time_pair<Ntk>> const& arrival_times, bool& inverted ) const
+  {
+    const auto sop = create_sop_form( func, inverted );
+
+    stopwatch<> t_tree( time_tree_balancing );
+    arrival_time_queue<Ntk> and_terms;
+    uint32_t num_and_gates{};
+    for ( auto const& cube : sop )
+    {
+      arrival_time_queue<Ntk> product_queue;
+      for ( auto i = 0u; i < func.num_vars(); ++i )
+      {
+        if ( cube.get_mask( i ) )
+        {
+          const auto [f, l] = arrival_times[i];
+          product_queue.push( { cube.get_bit( i ) ? f : dest.create_not( f ), l } );
+        }
+      }
+      if ( !product_queue.empty() )
+      {
+        num_and_gates += static_cast<uint32_t>( product_queue.size() ) - 1u;
+      }
+      and_terms.push( balanced_tree( dest, product_queue ) );
+    }
+    return { and_terms, num_and_gates };
+  }
+
+  arrival_time_pair<Ntk> balanced_tree( Ntk& dest, arrival_time_queue<Ntk>& queue, bool _and = true ) const
+  {
+    if ( queue.empty() )
+    {
+      return { dest.get_constant( true ), 0u };
+    }
+
+    while ( queue.size() > 1u )
+    {
+      auto [s1, l1] = queue.top();
+      queue.pop();
+      auto [s2, l2] = queue.top();
+      queue.pop();
+      const auto s = _and ? dest.create_and( s1, s2 ) : dest.create_or( s1, s2 );
+      const auto l = std::max( l1, l2 ) + 1;
+      queue.push( { s, l } );
+    }
+    return queue.top();
+  }
+
+  std::vector<kitty::cube> create_sop_form( kitty::dynamic_truth_table const& func, bool& inverted ) const
+  {
+    stopwatch<> t( time_sop );
+    inverted = false;
+
+    if ( auto it = sop_hash_.find( func ); it != sop_hash_.end() )
+    {
+      sop_cache_hits++;
+      return it->second;
+    }
+
+    if ( both_phases_ )
+    {
+      if ( auto it = sop_hash_.find( ~func ); it != sop_hash_.end() )
+      {
+        inverted = true;
+        sop_cache_hits++;
+        return it->second;
+      }
+    }
+
+    sop_cache_misses++;
+    std::vector<kitty::cube> sop = kitty::isop( func );
+
+    if ( both_phases_ )
+    {
+      std::vector<kitty::cube> n_sop = kitty::isop( ~func );
+
+      if ( n_sop.size() < sop.size() )
+      {
+        inverted = true;
+        return sop_hash_[~func] = n_sop;
+      }
+      else if ( n_sop.size() == sop.size() )
+      {
+        /* compute literal cost */
+        uint32_t lit = 0, n_lit = 0;
+        for ( auto const& c : sop )
+        {
+          lit += c.num_literals();
+        }
+        for ( auto const& c : n_sop )
+        {
+          n_lit += c.num_literals();
+        }
+
+        if ( n_lit < lit )
+        {
+          inverted = true;
+          return sop_hash_[~func] = n_sop;
+        }
+      }
+    }
+
+    return sop_hash_[func] = sop;
+  }
+
+private:
+  mutable std::unordered_map<kitty::dynamic_truth_table, std::vector<kitty::cube>, kitty::hash<kitty::dynamic_truth_table>> sop_hash_;
+
+public:
+  bool both_phases_{ false };
+
+public:
+  mutable uint32_t sop_cache_hits{};
+  mutable uint32_t sop_cache_misses{};
+
+  mutable stopwatch<>::duration time_sop{};
+  mutable stopwatch<>::duration time_tree_balancing{};
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/balancing/utils.hpp b/include/mockturtle/algorithms/balancing/utils.hpp
new file mode 100644
index 0000000..57b569f
--- /dev/null
+++ b/include/mockturtle/algorithms/balancing/utils.hpp
@@ -0,0 +1,80 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file utils.hpp
+  \brief Balancing data types
+
+  \author Alessandro Tempia Calvino
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <queue>
+
+#include "../../traits.hpp"
+
+namespace mockturtle
+{
+
+template<class Ntk>
+struct arrival_time_pair
+{
+  signal<Ntk> f;
+  uint32_t level;
+};
+
+/*! \brief Callback function for `rebalancing_function_t`.
+ *
+ * This callback is used in the rebalancing function to announce a new candidate that
+ * could be used for replacement in the main balancing algorithm.  Using a callback
+ * makes it possible to account for situations in which none, a single, or multiple
+ * candidates are generated.
+ *
+ * The callback returns a pair composed of the output signal of the replacement
+ * candidate and the level of the new candidate.  Ideally, the rebalancing function
+ * should not call the callback with candidates that a worse level.
+ */
+template<class Ntk>
+using rebalancing_function_callback_t = std::function<void( arrival_time_pair<Ntk> const&, uint32_t )>;
+
+template<class Ntk>
+using rebalancing_function_t = std::function<void( Ntk&, kitty::dynamic_truth_table const&, std::vector<arrival_time_pair<Ntk>> const&, uint32_t, uint32_t, rebalancing_function_callback_t<Ntk> const& )>;
+
+template<class Ntk>
+struct arrival_time_compare
+{
+  bool operator()( arrival_time_pair<Ntk> const& p1, arrival_time_pair<Ntk> const& p2 ) const
+  {
+    return p1.level > p2.level;
+  }
+};
+
+template<class Ntk>
+using arrival_time_queue = std::priority_queue<arrival_time_pair<Ntk>, std::vector<arrival_time_pair<Ntk>>, arrival_time_compare<Ntk>>;
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/bi_decomposition.hpp b/include/mockturtle/algorithms/bi_decomposition.hpp
new file mode 100644
index 0000000..2e5b512
--- /dev/null
+++ b/include/mockturtle/algorithms/bi_decomposition.hpp
@@ -0,0 +1,171 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file bi_decomposition.hpp
+  \brief BI decomposition
+
+  \author Eleonora Testa
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include "../traits.hpp"
+
+#include <kitty/constructors.hpp>
+#include <kitty/decomposition.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/operators.hpp>
+#include <kitty/print.hpp>
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+template<class Ntk>
+class bi_decomposition_impl
+{
+public:
+  bi_decomposition_impl( Ntk& ntk, kitty::dynamic_truth_table const& func, kitty::dynamic_truth_table const& dc, std::vector<signal<Ntk>> const& children )
+      : _ntk( ntk ),
+        remainder( func ),
+        dc_remainder( dc ),
+        pis( children ) {}
+
+  signal<Ntk> run()
+  {
+    /* bi_decomposition */
+    if ( kitty::is_const0( binary_and( remainder, dc_remainder ) ) )
+    {
+      return _ntk.get_constant( false );
+    }
+    else if ( kitty::is_const0( binary_and( ~remainder, dc_remainder ) ) )
+    {
+      return _ntk.get_constant( true );
+    }
+    else
+    {
+      for ( auto h = 0u; h < remainder.num_vars(); h++ )
+      {
+        auto var = remainder.construct();
+        kitty::create_nth_var( var, h );
+        if ( binary_and( remainder, dc_remainder ) == binary_and( var, dc_remainder ) )
+        {
+          return pis[h];
+        }
+        else if ( binary_and( remainder, dc_remainder ) == binary_and( ~var, dc_remainder ) )
+        {
+          return _ntk.create_not( pis[h] );
+        }
+      }
+    }
+
+    auto bi_dec = kitty::is_bi_decomposable_mc( remainder, dc_remainder );
+    auto res = std::get<1>( bi_dec );
+
+    remainder = std::get<2>( bi_dec )[0];
+    dc_remainder = std::get<2>( bi_dec )[1];
+    const auto right = run();
+
+    remainder = std::get<2>( bi_dec )[2];
+    dc_remainder = std::get<2>( bi_dec )[3];
+    const auto left = run();
+
+    if ( res == kitty::bi_decomposition::and_ )
+    {
+      return _ntk.create_and( left, right );
+    }
+    else if ( res == kitty::bi_decomposition::or_ )
+    {
+      return _ntk.create_or( left, right );
+    }
+    else if ( res == kitty::bi_decomposition::weak_and_ )
+    {
+      return _ntk.create_and( left, right );
+    }
+    else if ( res == kitty::bi_decomposition::weak_or_ )
+    {
+      return _ntk.create_or( left, right );
+    }
+    else if ( res == kitty::bi_decomposition::xor_ )
+    {
+      return _ntk.create_xor( left, right );
+    }
+    else
+    {
+      assert( false );
+      return signal<Ntk>();
+    }
+  }
+
+private:
+  Ntk& _ntk;
+  kitty::dynamic_truth_table remainder;
+  kitty::dynamic_truth_table dc_remainder;
+  std::vector<signal<Ntk>> pis;
+};
+
+} // namespace detail
+
+/*! \brief Bi decomposition
+ *
+ * This function applies bi-decomposition on a truth table inside the network.
+ *
+ * Note that the number of variables in `func` and `care` must be the same.
+ * The function will create a network composed on two-input gates with as many primary inputs as the number of
+ * variables in `func` and a single output.
+ *
+ * **Required network functions:**
+ * - `create_and`
+ * - `create_or`
+ * - `create_xor`
+ * - `create_not`
+ *
+ * \param func Function as truth table
+ * \param care Care set of the function (as truth table)
+ * \return An internal signal of the network
+ */
+
+template<class Ntk>
+signal<Ntk> bi_decomposition( Ntk& ntk, kitty::dynamic_truth_table const& func, kitty::dynamic_truth_table const& care, std::vector<signal<Ntk>> const& children )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+  static_assert( has_create_and_v<Ntk>, "Ntk does not implement the create_and method" );
+  static_assert( has_create_or_v<Ntk>, "Ntk does not implement the create_or method" );
+  static_assert( has_create_xor_v<Ntk>, "Ntk does not implement the create_xor method" );
+
+  detail::bi_decomposition_impl<Ntk> impl( ntk, func, care, children );
+  return impl.run();
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/cell_window.hpp b/include/mockturtle/algorithms/cell_window.hpp
new file mode 100644
index 0000000..6e855ab
--- /dev/null
+++ b/include/mockturtle/algorithms/cell_window.hpp
@@ -0,0 +1,509 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cell_window.hpp
+  \brief Windowing in mapped network
+
+  \author Bruno Schmitt
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <array>
+#include <memory>
+#include <optional>
+#include <unordered_set>
+#include <vector>
+
+#include <parallel_hashmap/phmap.h>
+
+#include "../networks/detail/foreach.hpp"
+#include "../traits.hpp"
+#include "../utils/algorithm.hpp"
+#include "../utils/node_map.hpp"
+#include "../utils/stopwatch.hpp"
+
+template<>
+struct std::hash<std::array<uint64_t, 2>>
+{
+  auto operator()( std::array<uint64_t, 2> const& key ) const
+  {
+    std::hash<uint64_t> hasher;
+    return hasher( key[0] ) * 31 + hasher( key[1] );
+  }
+};
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+template<class Ntk>
+class cell_window_storage
+{
+public:
+  cell_window_storage( Ntk const& ntk ) : _cell_refs( ntk ),
+                                          _cell_parents( ntk )
+  {
+    if ( ntk.get_node( ntk.get_constant( true ) ) != ntk.get_node( ntk.get_constant( false ) ) )
+    {
+      _num_constants++;
+    }
+
+    _nodes.reserve( _max_gates >> 1 );
+    _gates.reserve( _max_gates );
+  }
+
+  phmap::flat_hash_set<node<Ntk>> _nodes;   /* cell roots in current window */
+  phmap::flat_hash_set<node<Ntk>> _gates;   /* gates in current window */
+  phmap::flat_hash_set<node<Ntk>> _leaves;  /* leaves of current window */
+  phmap::flat_hash_set<signal<Ntk>> _roots; /* roots of current window */
+
+  std::array<uint64_t, 2> _window_mask;
+  phmap::flat_hash_set<std::array<uint64_t, 2>> _window_hash;
+
+  node_map<uint32_t, Ntk> _cell_refs;                  /* ref counts for cells */
+  node_map<std::vector<node<Ntk>>, Ntk> _cell_parents; /* parent cells */
+
+  std::vector<node<Ntk>> _index_to_node;
+  phmap::flat_hash_map<node<Ntk>, uint32_t> _node_to_index;
+
+  uint32_t _num_constants{ 1u };
+  uint32_t _max_gates{};
+  bool _has_mapping{ true };
+};
+
+} // namespace detail
+
+template<class Ntk>
+class cell_window : public Ntk
+{
+public:
+  using storage = typename std::shared_ptr<detail::cell_window_storage<Ntk>>;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+public:
+  cell_window( Ntk const& ntk, uint32_t max_gates = 64 )
+      : Ntk( ntk ),
+        _storage( std::make_shared<detail::cell_window_storage<Ntk>>( ntk ) )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_is_cell_root_v<Ntk>, "Ntk does not implement the is_cell_root method" );
+    static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+    static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+    static_assert( has_foreach_cell_fanin_v<Ntk>, "Ntk does not implement the foreach_cell_fanin method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_incr_trav_id_v<Ntk>, "Ntk does not implement the incr_trav_id method" );
+    static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+    static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+    static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+    static_assert( has_has_mapping_v<Ntk>, "Ntk does not implement the has_mapping method" );
+
+    assert( Ntk::has_mapping() );
+    _storage->_max_gates = max_gates;
+  }
+
+  bool compute_window_for( node const& pivot )
+  {
+    init_cell_refs();
+
+    // print_time<> pt;
+    assert( Ntk::is_cell_root( pivot ) );
+
+    // reset old window
+    _storage->_nodes.clear();
+    _storage->_gates.clear();
+
+    std::vector<node> gates;
+    gates.reserve( _storage->_max_gates );
+    collect_mffc( pivot, gates );
+    add_node( pivot, gates );
+
+    if ( gates.size() > _storage->_max_gates )
+    {
+      assert( false );
+    }
+
+    std::optional<node> next;
+    while ( ( next = find_next_pivot() ) )
+    {
+      gates.clear();
+      collect_mffc( *next, gates );
+
+      if ( _storage->_gates.size() + gates.size() > _storage->_max_gates )
+      {
+        break;
+      }
+      add_node( *next, gates );
+    }
+
+    find_leaves_and_roots();
+    set_indexes();
+
+    return _storage->_window_hash.insert( _storage->_window_mask ).second;
+  }
+
+  uint32_t num_pis() const
+  {
+    return _storage->_leaves.size();
+  }
+
+  uint32_t num_pos() const
+  {
+    return _storage->_roots.size();
+  }
+
+  uint32_t num_gates() const
+  {
+    return _storage->_gates.size();
+  }
+
+  uint32_t num_cells() const
+  {
+    return _storage->_nodes.size();
+  }
+
+  uint32_t size() const
+  {
+    return _storage->_num_constants + _storage->_leaves.size() + _storage->_gates.size();
+  }
+
+  bool is_pi( node const& n ) const
+  {
+    return _storage->_leaves.count( n );
+  }
+
+  bool is_cell_root( node const& n ) const
+  {
+    return _storage->_nodes.count( n );
+  }
+
+  uint32_t node_to_index( node const& n ) const
+  {
+    return _storage->_node_to_index.at( n );
+  }
+
+  node index_to_node( uint32_t index ) const
+  {
+    return _storage->_index_to_node[index];
+  }
+
+  bool has_mapping() const
+  {
+    return _storage->_has_mapping;
+  }
+
+  void clear_mapping()
+  {
+    _storage->_has_mapping = false;
+    for ( auto const& n : _storage->_nodes )
+    {
+      Ntk::remove_from_mapping( n );
+    }
+    _storage->_nodes.clear();
+  }
+
+  template<typename LeavesIterator>
+  void add_to_mapping( node const& n, LeavesIterator begin, LeavesIterator end )
+  {
+    _storage->_has_mapping = true;
+    _storage->_nodes.insert( n );
+    Ntk::add_to_mapping( n, begin, end );
+  }
+
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->_leaves.begin(), _storage->_leaves.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->_roots.begin(), _storage->_roots.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->_gates.begin(), _storage->_gates.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->_index_to_node.begin(), _storage->_index_to_node.end(), fn );
+  }
+
+private:
+  void init_cell_refs()
+  {
+    _storage->_cell_refs.reset();
+    _storage->_cell_parents.reset();
+
+    /* initial ref counts for cells */
+    Ntk::foreach_gate( [&]( auto const& n ) {
+      if ( Ntk::is_cell_root( n ) )
+      {
+        Ntk::foreach_cell_fanin( n, [&]( auto const& n2 ) {
+          _storage->_cell_refs[n2]++;
+          _storage->_cell_parents[n2].push_back( n );
+        } );
+    } } );
+    Ntk::foreach_po( [&]( auto const& f ) {
+      _storage->_cell_refs[f]++;
+    } );
+  }
+
+  void collect_mffc( node const& pivot, std::vector<node>& gates )
+  {
+    Ntk::incr_trav_id();
+    collect_gates( pivot, gates );
+    const auto it = std::remove_if( gates.begin(), gates.end(), [&]( auto const& g ) { return _storage->_gates.count( g ); } );
+    gates.erase( it, gates.end() );
+  }
+
+  void collect_gates( node const& pivot, std::vector<node>& gates )
+  {
+    assert( !Ntk::is_pi( pivot ) );
+
+    Ntk::set_visited( Ntk::get_node( Ntk::get_constant( false ) ), Ntk::trav_id() );
+    Ntk::set_visited( Ntk::get_node( Ntk::get_constant( true ) ), Ntk::trav_id() );
+
+    Ntk::foreach_cell_fanin( pivot, [this]( auto const& n ) {
+      Ntk::set_visited( n, Ntk::trav_id() );
+    } );
+
+    collect_gates_rec( pivot, gates );
+  }
+
+  void collect_gates_rec( node const& n, std::vector<node>& gates )
+  {
+    if ( Ntk::visited( n ) == Ntk::trav_id() )
+      return;
+    if ( Ntk::is_constant( n ) || Ntk::is_pi( n ) )
+      return;
+
+    Ntk::set_visited( n, Ntk::trav_id() );
+    Ntk::foreach_fanin( n, [&]( auto const& f ) {
+      collect_gates_rec( Ntk::get_node( f ), gates );
+    } );
+    gates.push_back( n );
+  }
+
+  void add_node( node const& pivot, std::vector<node> const& gates )
+  {
+    /*std::cout << "add_node(" << pivot << ", { ";
+    for ( auto const& g : gates ) {
+      std::cout << g << " ";
+    }
+    std::cout << "})\n";*/
+    _storage->_nodes.insert( pivot );
+    std::copy( gates.begin(), gates.end(), std::insert_iterator( _storage->_gates, _storage->_gates.begin() ) );
+  }
+
+  std::optional<node> find_next_pivot()
+  {
+    /* deref */
+    for ( auto const& n : _storage->_nodes )
+    {
+      Ntk::foreach_cell_fanin( n, [&]( auto const& n2 ) {
+        _storage->_cell_refs[n2]--;
+      } );
+    }
+
+    std::vector<node> candidates;
+    std::unordered_set<node> inputs;
+
+    do
+    {
+      for ( auto const& n : _storage->_nodes )
+      {
+        Ntk::foreach_cell_fanin( n, [&]( auto const& n2 ) {
+          if ( !_storage->_nodes.count( n2 ) && !Ntk::is_pi( n2 ) && !_storage->_cell_refs[n2] )
+          {
+            candidates.push_back( n2 );
+            inputs.insert( n2 );
+          }
+        } );
+      }
+
+      if ( !candidates.empty() )
+      {
+        const auto best = max_element_unary(
+            candidates.begin(), candidates.end(),
+            [&]( auto const& cand ) {
+              auto cnt{ 0 };
+              this->foreach_cell_fanin( cand, [&]( auto const& n2 ) {
+                cnt += inputs.count( n2 );
+              } );
+              return cnt;
+            },
+            -1 );
+        candidates[0] = *best;
+        break;
+      }
+
+      for ( auto const& n : _storage->_nodes )
+      {
+        Ntk::foreach_cell_fanin( n, [&]( auto const& n2 ) {
+          if ( !_storage->_nodes.count( n2 ) && !Ntk::is_pi( n2 ) )
+          {
+            candidates.push_back( n2 );
+            inputs.insert( n2 );
+          }
+        } );
+      }
+
+      for ( auto const& n : _storage->_nodes )
+      {
+        if ( _storage->_cell_refs[n] == 0 )
+          continue;
+        if ( _storage->_cell_refs[n] >= 5 )
+          continue;
+        if ( _storage->_cell_refs[n] == 1 && _storage->_cell_parents[n].size() == 1 && !_storage->_nodes.count( _storage->_cell_parents[n].front() ) )
+        {
+          candidates.clear();
+          candidates.push_back( _storage->_cell_parents[n].front() );
+          break;
+        }
+        std::copy_if( _storage->_cell_parents[n].begin(), _storage->_cell_parents[n].end(),
+                      std::back_inserter( candidates ),
+                      [&]( auto const& g ) {
+                        return !_storage->_nodes.count( g );
+                      } );
+      }
+
+      if ( !candidates.empty() )
+      {
+        const auto best = max_element_unary(
+            candidates.begin(), candidates.end(),
+            [&]( auto const& cand ) {
+              auto cnt{ 0 };
+              this->foreach_cell_fanin( cand, [&]( auto const& n2 ) {
+                cnt += inputs.count( n2 );
+              } );
+              return cnt;
+            },
+            -1 );
+        candidates[0] = *best;
+      }
+    } while ( false );
+
+    /* ref */
+    for ( auto const& n : _storage->_nodes )
+    {
+      Ntk::foreach_cell_fanin( n, [&]( auto const& n2 ) {
+        _storage->_cell_refs[n2]++;
+      } );
+    }
+
+    if ( candidates.empty() )
+    {
+      return std::nullopt;
+    }
+    else
+    {
+      return candidates.front();
+    }
+  }
+
+  void find_leaves_and_roots()
+  {
+    _storage->_leaves.clear();
+    _storage->_window_mask[0] = 0u;
+    for ( auto const& g : _storage->_gates )
+    {
+      Ntk::foreach_fanin( g, [&]( auto const& f ) {
+        auto const child = Ntk::get_node( f );
+        if ( !_storage->_gates.count( child ) )
+        {
+          _storage->_leaves.insert( child );
+          _storage->_window_mask[0] |= UINT64_C( 1 ) << ( Ntk::node_to_index( child ) % 64 );
+        }
+      } );
+    }
+
+    _storage->_roots.clear();
+    _storage->_window_mask[1] = 0u;
+    for ( auto const& n : _storage->_nodes )
+    {
+      Ntk::foreach_cell_fanin( n, [&]( auto const& n2 ) {
+        _storage->_cell_refs[n2]--;
+      } );
+    }
+    for ( auto const& n : _storage->_nodes )
+    {
+      if ( _storage->_cell_refs[n] )
+      {
+        _storage->_roots.insert( Ntk::make_signal( n ) );
+        _storage->_window_mask[1] |= UINT64_C( 1 ) << ( Ntk::node_to_index( n ) % 64 );
+      }
+    }
+    for ( auto const& n : _storage->_nodes )
+    {
+      Ntk::foreach_cell_fanin( n, [&]( auto const& n2 ) {
+        _storage->_cell_refs[n2]++;
+      } );
+    }
+  }
+
+  void set_indexes()
+  {
+    _storage->_index_to_node.resize( _storage->_num_constants + _storage->_leaves.size() + _storage->_gates.size() );
+    _storage->_node_to_index.clear();
+
+    _storage->_node_to_index[_storage->_index_to_node[0] = Ntk::get_node( Ntk::get_constant( false ) )] = 0;
+
+    if ( _storage->_num_constants == 2u )
+    {
+      _storage->_node_to_index[_storage->_index_to_node[1] = Ntk::get_node( Ntk::get_constant( true ) )] = 1;
+    }
+
+    auto idx = _storage->_num_constants;
+    for ( auto const& n : _storage->_leaves )
+    {
+      _storage->_node_to_index[_storage->_index_to_node[idx] = n] = idx;
+      ++idx;
+    }
+    for ( auto const& n : _storage->_gates )
+    {
+      _storage->_node_to_index[_storage->_index_to_node[idx] = n] = idx;
+      ++idx;
+    }
+
+    assert( _storage->_index_to_node.size() == idx );
+  }
+
+private:
+  std::shared_ptr<detail::cell_window_storage<Ntk>> _storage;
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/circuit_validator.hpp b/include/mockturtle/algorithms/circuit_validator.hpp
new file mode 100644
index 0000000..45f0afc
--- /dev/null
+++ b/include/mockturtle/algorithms/circuit_validator.hpp
@@ -0,0 +1,799 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file circuit_validator.hpp
+  \brief Validate potential circuit optimization choices with SAT.
+
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../networks/events.hpp"
+#include "../utils/index_list.hpp"
+#include "../utils/node_map.hpp"
+#include "cnf.hpp"
+
+#include <bill/sat/interface/abc_bsat2.hpp>
+#include <bill/sat/interface/common.hpp>
+#include <bill/sat/interface/glucose.hpp>
+#include <bill/sat/interface/z3.hpp>
+
+namespace mockturtle
+{
+
+struct validator_params
+{
+  /*! \brief Maximum number of clauses of the SAT solver. (incremental CNF construction) */
+  uint32_t max_clauses{ 1000 };
+
+  /*! \brief Whether to consider ODC, and how many levels. 0 = No consideration. -1 = Consider TFO until PO. */
+  int32_t odc_levels{ 0 };
+
+  /*! \brief Conflict limit of the SAT solver. */
+  uint32_t conflict_limit{ 1000 };
+
+  /*! \brief Seed for randomized solving. */
+  uint32_t random_seed{ 0 };
+};
+
+template<class Ntk, bill::solvers Solver = bill::solvers::glucose_41, bool use_pushpop = false, bool randomize = false, bool use_odc = false>
+class circuit_validator
+{
+public:
+  static constexpr bool use_odc_ = use_odc;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  using add_clause_fn_t = std::function<void( std::vector<bill::lit_type> const& )>;
+
+  enum gate_type
+  {
+    AND,
+    XOR,
+    MAJ,
+    MUX
+  };
+
+  explicit circuit_validator( Ntk const& ntk, validator_params const& ps = {} )
+      : ntk( ntk ), ps( ps ), literals( ntk ), constructed( ntk ), num_invoke( 0u ), cex( ntk.num_pis() )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+    static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+    static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+    static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+    static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_is_and_v<Ntk>, "Ntk does not implement the is_and method" );
+    static_assert( has_is_xor_v<Ntk>, "Ntk does not implement the is_xor method" );
+    static_assert( has_is_xor3_v<Ntk>, "Ntk does not implement the is_xor3 method" );
+    static_assert( has_is_maj_v<Ntk>, "Ntk does not implement the is_maj method" );
+
+    if constexpr ( use_pushpop )
+    {
+#if defined( BILL_HAS_Z3 )
+      static_assert( Solver == bill::solvers::z3 || Solver == bill::solvers::bsat2, "Solver does not support push/pop" );
+#else
+      static_assert( Solver == bill::solvers::bsat2, "Solver does not support push/pop" );
+#endif
+    }
+    if constexpr ( randomize )
+    {
+#if defined( BILL_HAS_Z3 )
+      static_assert( Solver == bill::solvers::z3 || Solver == bill::solvers::bsat2, "Solver does not support set_random" );
+#else
+      static_assert( Solver == bill::solvers::bsat2, "Solver does not support set_random" );
+#endif
+    }
+    if constexpr ( use_odc )
+    {
+      static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+      static_assert( has_visited_v<Ntk>, "Ntk does not implement the visited method" );
+      static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+      static_assert( has_foreach_fanout_v<Ntk>, "Ntk does not implement the foreach_fanout method" );
+    }
+
+    add_event = ntk.events().register_add_event( [&]( node const& n ) {
+      (void)n;
+      literals.resize();
+    } );
+
+    /* constants are mapped to var 0 */
+    literals[ntk.get_constant( false )] = bill::lit_type( 0, bill::lit_type::polarities::positive );
+    if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+    {
+      literals[ntk.get_constant( true )] = bill::lit_type( 0, bill::lit_type::polarities::negative );
+    }
+
+    /* first indexes (starting from 1) are for PIs */
+    ntk.foreach_pi( [&]( auto const& n, auto i ) {
+      literals[n] = bill::lit_type( i + 1, bill::lit_type::polarities::positive );
+    } );
+
+    restart();
+  }
+
+  ~circuit_validator()
+  {
+    ntk.events().release_add_event( add_event );
+  }
+
+  /*! \brief Set ODC levels */
+  void set_odc_levels( uint32_t odc_levels )
+  {
+    ps.odc_levels = odc_levels;
+  }
+
+  /*! \brief Validate functional equivalence of signals `f` and `d`. */
+  std::optional<bool> validate( signal const& f, signal const& d )
+  {
+    if ( !constructed.has( d ) && !ntk.is_pi( ntk.get_node( d ) ) && !ntk.is_constant( ntk.get_node( d ) ) )
+    {
+      construct( ntk.get_node( d ) );
+    }
+    auto const res = validate( ntk.get_node( f ), lit_not_cond( literals[d], ntk.is_complemented( f ) ^ ntk.is_complemented( d ) ) );
+    if ( solver.num_clauses() > ps.max_clauses && num_invoke >= MIN_NUM_INVOKE )
+    {
+      restart();
+    }
+    return res;
+  }
+
+  /*! \brief Validate functional equivalence of node `root` and signal `d`. */
+  std::optional<bool> validate( node const& root, signal const& d )
+  {
+    if ( !constructed.has( d ) && !ntk.is_pi( ntk.get_node( d ) ) && !ntk.is_constant( ntk.get_node( d ) ) )
+    {
+      construct( ntk.get_node( d ) );
+    }
+    auto const res = validate( root, lit_not_cond( literals[d], ntk.is_complemented( d ) ) );
+    if ( solver.num_clauses() > ps.max_clauses && num_invoke >= MIN_NUM_INVOKE )
+    {
+      restart();
+    }
+    return res;
+  }
+
+  /*! \brief Validate functional equivalence of signal `f` with a circuit represented by an index_list.
+   *
+   * \param id_list The index_list representing a circuit.
+   * \param divs Existing nodes in the network, serving as PIs of `id_list`.
+   * \param inverted Whether to validate equivalence or inverse equivalence.
+   */
+  template<class index_list_type>
+  std::optional<bool> validate( signal const& f, std::vector<node> const& divs, index_list_type const& id_list, bool inverted = false )
+  {
+    return validate( ntk.get_node( f ), divs.begin(), divs.end(), id_list, inverted ^ ntk.is_complemented( f ) );
+  }
+
+  /*! \brief Validate functional equivalence of node `root` with an index_list. */
+  template<class index_list_type>
+  std::optional<bool> validate( node const& root, std::vector<node> const& divs, index_list_type const& id_list, bool inverted = false )
+  {
+    return validate( root, divs.begin(), divs.end(), id_list, inverted );
+  }
+
+  /*! \brief Validate functional equivalence of signal `f` with an index_list. */
+  template<class iterator_type, class index_list_type>
+  std::optional<bool> validate( signal const& f, iterator_type divs_begin, iterator_type divs_end, index_list_type const& id_list, bool inverted = false )
+  {
+    return validate( ntk.get_node( f ), divs_begin, divs_end, id_list, inverted ^ ntk.is_complemented( f ) );
+  }
+
+  /*! \brief Validate functional equivalence of node `root` with an index_list. */
+  template<class iterator_type, class index_list_type>
+  std::optional<bool> validate( node const& root, iterator_type divs_begin, iterator_type divs_end, index_list_type const& id_list, bool inverted = false )
+  {
+    static_assert( std::is_same_v<index_list_type, mig_index_list> ||
+                   std::is_same_v<index_list_type, xag_index_list<true>> ||
+                   std::is_same_v<index_list_type, xag_index_list<false>> ||
+                   std::is_same_v<index_list_type, muxig_index_list>, "Unknown type of index list" );
+    assert( uint64_t( std::distance( divs_begin, divs_end ) ) == id_list.num_pis() && "Size of the provided divisor list does not match number of PIs of the index list" );
+    assert( id_list.num_pos() == 1u && "Index list must have exactly one PO" );
+
+    if ( !constructed.has( root ) && !ntk.is_pi( root ) && !ntk.is_constant( root ) )
+    {
+      construct( root );
+    }
+
+    std::vector<bill::lit_type> lits;
+    lits.reserve( id_list.num_pis() + id_list.num_gates() + 1 );
+    lits.emplace_back( literals[ntk.get_constant( false )] );
+    for ( auto it = divs_begin; it != divs_end; ++it )
+    {
+      if ( !constructed.has( *it ) && !ntk.is_pi( *it ) && !ntk.is_constant( *it ) )
+      {
+        construct( *it );
+      }
+      lits.emplace_back( literals[*it] );
+    }
+
+    if constexpr ( use_pushpop )
+    {
+      push();
+    }
+
+    if constexpr ( std::is_same_v<index_list_type, xag_index_list<true>> || std::is_same_v<index_list_type, xag_index_list<false>> )
+    {
+      id_list.foreach_gate( [&]( uint32_t id_lit0, uint32_t id_lit1 ) {
+        uint32_t const node_pos0 = id_lit0 >> 1;
+        uint32_t const node_pos1 = id_lit1 >> 1;
+        assert( node_pos0 < lits.size() );
+        assert( node_pos1 < lits.size() );
+        lits.emplace_back( add_clauses_for_2input_gate( lit_not_cond( lits[node_pos0], id_lit0 & 0x1 ), lit_not_cond( lits[node_pos1], id_lit1 & 0x1 ), std::nullopt, id_lit0 < id_lit1 ? AND : XOR ) );
+      } );
+    }
+    if constexpr ( std::is_same_v<index_list_type, mig_index_list> )
+    {
+      id_list.foreach_gate( [&]( uint32_t id_lit0, uint32_t id_lit1, uint32_t id_lit2 ) {
+        uint32_t const node_pos0 = id_lit0 >> 1;
+        uint32_t const node_pos1 = id_lit1 >> 1;
+        uint32_t const node_pos2 = id_lit2 >> 1;
+        assert( node_pos0 < lits.size() );
+        assert( node_pos1 < lits.size() );
+        assert( node_pos2 < lits.size() );
+        lits.emplace_back( add_clauses_for_3input_gate( lit_not_cond( lits[node_pos0], id_lit0 & 0x1 ), lit_not_cond( lits[node_pos1], id_lit1 & 0x1 ), lit_not_cond( lits[node_pos2], id_lit2 & 0x1 ), std::nullopt, MAJ ) );
+      } );
+    }
+    if constexpr ( std::is_same_v<index_list_type, muxig_index_list> )
+    {
+      id_list.foreach_gate( [&]( uint32_t id_lit0, uint32_t id_lit1, uint32_t id_lit2 ) {
+        uint32_t const node_pos0 = id_lit0 >> 1;
+        uint32_t const node_pos1 = id_lit1 >> 1;
+        uint32_t const node_pos2 = id_lit2 >> 1;
+        assert( node_pos0 < lits.size() );
+        assert( node_pos1 < lits.size() );
+        assert( node_pos2 < lits.size() );
+        lits.emplace_back( add_clauses_for_3input_gate( lit_not_cond( lits[node_pos0], id_lit0 & 0x1 ), lit_not_cond( lits[node_pos1], id_lit1 & 0x1 ), lit_not_cond( lits[node_pos2], id_lit2 & 0x1 ), std::nullopt, MUX ) );
+      } );
+    }
+
+    bill::lit_type lit_out;
+    id_list.foreach_po( [&]( uint32_t id_lit ) {
+      lit_out = lit_not_cond( lits[id_lit >> 1], ( id_lit & 0x1 ) ^ inverted );
+    } );
+
+    auto const res = validate( root, lit_out );
+
+    if constexpr ( use_pushpop )
+    {
+      pop();
+    }
+
+    if ( solver.num_clauses() > ps.max_clauses && num_invoke >= MIN_NUM_INVOKE )
+    {
+      restart();
+    }
+
+    return res;
+  }
+
+  /*! \brief Validate whether signal `f` is a constant of `value`. */
+  std::optional<bool> validate( signal const& f, bool value )
+  {
+    return validate( ntk.get_node( f ), value ^ ntk.is_complemented( f ) );
+  }
+
+  /*! \brief Validate whether node `root` is a constant of `value`. */
+  std::optional<bool> validate( node const& root, bool value )
+  {
+    if ( !constructed.has( root ) && !ntk.is_pi( root ) && !ntk.is_constant( root ) )
+    {
+      construct( root );
+    }
+
+    std::optional<bool> res;
+    if constexpr ( use_odc )
+    {
+      if ( ps.odc_levels != 0 )
+      {
+        if constexpr ( use_pushpop )
+        {
+          push();
+        }
+        res = solve( { build_odc_window( root, ~literals[root] ), lit_not_cond( literals[root], value ) } );
+        if constexpr ( use_pushpop )
+        {
+          pop();
+        }
+      }
+      else
+      {
+        res = solve( { lit_not_cond( literals[root], value ) } );
+      }
+    }
+    else
+    {
+      res = solve( { lit_not_cond( literals[root], value ) } );
+    }
+
+    if ( solver.num_clauses() > ps.max_clauses && num_invoke >= MIN_NUM_INVOKE )
+    {
+      restart();
+    }
+    return res;
+  }
+
+  /*! \brief Generate pattern(s) for signal `f` to be `value`, optionally blocking several known patterns.
+   *
+   * Requires `use_pushpop = true`, which is only supported for `bsat2` and `z3`. If `bsat2` is used,
+   * and if the network has more than 2048 PIs, the `BUFFER_SIZE` in `lib/bill/sat/interface/abc_bsat2.hpp`
+   * has to be increased to at least `ntk.num_pis()`.
+   *
+   * If `block_patterns` and the returned vector are both empty, `f` is validated to be a constant of `!value`.
+   *
+   * \param block_patterns Patterns to be blocked in the solver. (Will not generate any of them.)
+   * \param num_patterns Number of patterns to be generated, if possible. (The size of the result may be smaller than this number, but never larger.)
+   */
+  template<bool enabled = use_pushpop, typename = std::enable_if_t<enabled>>
+  std::vector<std::vector<bool>> generate_pattern( signal const& f, bool value, std::vector<std::vector<bool>> const& block_patterns = {}, uint32_t num_patterns = 1u )
+  {
+    return generate_pattern( ntk.get_node( f ), value ^ ntk.is_complemented( f ), block_patterns, num_patterns );
+  }
+
+  /*! \brief Generate pattern(s) for node `root` to be `value`, optionally blocking several known patterns. */
+  template<bool enabled = use_pushpop, typename = std::enable_if_t<enabled>>
+  std::vector<std::vector<bool>> generate_pattern( node const& root, bool value, std::vector<std::vector<bool>> const& block_patterns = {}, uint32_t num_patterns = 1u )
+  {
+    if ( !constructed.has( root ) && !ntk.is_pi( root ) && !ntk.is_constant( root ) )
+    {
+      construct( root );
+    }
+
+    push();
+
+    for ( auto const& pattern : block_patterns )
+    {
+      block_pattern( pattern );
+    }
+
+    std::vector<bill::lit_type> assumptions( { lit_not_cond( literals[root], !value ) } );
+    if constexpr ( use_odc )
+    {
+      if ( ps.odc_levels != 0 )
+      {
+        assumptions.emplace_back( build_odc_window( root, ~literals[root] ) );
+      }
+    }
+
+    std::optional<bool> res;
+    std::vector<std::vector<bool>> generated;
+    for ( auto i = 0u; i < num_patterns; ++i )
+    {
+      res = solve( assumptions );
+
+      if ( !res || *res ) /* timeout or UNSAT */
+      {
+        break;
+      }
+      else /* SAT */
+      {
+        generated.emplace_back( cex );
+        block_pattern( cex );
+      }
+    }
+
+    pop();
+    if ( solver.num_clauses() > ps.max_clauses && num_invoke >= MIN_NUM_INVOKE )
+    {
+      restart();
+    }
+    return generated;
+  }
+
+  /*! \brief Update CNF clauses.
+   *
+   * This function should be called when the function of one or more nodes
+   * has been modified (typically when utilizing ODCs).
+   */
+  void update()
+  {
+    restart();
+  }
+
+private:
+  void restart()
+  {
+    num_invoke = 0u;
+    solver.restart();
+    if constexpr ( randomize )
+    {
+      solver.set_random_phase( ps.random_seed );
+    }
+
+    constructed.reset();
+
+    solver.add_variables( ntk.num_pis() + 1 );
+    solver.add_clause( { ~literals[ntk.get_constant( false )] } );
+
+    if constexpr ( has_EXCDC_interface_v<Ntk> )
+    {
+      ntk.add_EXCDC_clauses( solver );
+    }
+
+    if constexpr ( has_EXODC_interface_v<Ntk> )
+    {
+      if ( ps.odc_levels == -1 )
+      {
+        po_lits_link.clear();
+        typename Ntk::base_type oec_ntk;
+        ntk.build_oe_miter( oec_ntk );
+
+        std::vector<bill::lit_type> po_lits;
+        ntk.foreach_po( [&]( auto const& f ) {
+          if ( !ntk.is_pi( ntk.get_node( f ) ) && !constructed.has( f ) )
+          {
+            construct( ntk.get_node( f ) );
+          }
+          po_lits.emplace_back( lit_not_cond( literals[f], ntk.is_complemented( f ) ) );
+          po_lits_link.emplace_back( solver.add_variable(), bill::lit_type::polarities::positive );
+        });
+
+
+        /* OEC */
+        assert( oec_ntk.num_pis() == ntk.num_pos() * 2 && oec_ntk.num_pos() == 1 );
+        node_map<bill::lit_type, typename Ntk::base_type> oe_lits( oec_ntk );
+        oe_lits[oec_ntk.get_constant( false )] = bill::lit_type( 0, bill::lit_type::polarities::positive );
+        if ( oec_ntk.get_node( oec_ntk.get_constant( false ) ) != oec_ntk.get_node( oec_ntk.get_constant( true ) ) )
+        {
+          oe_lits[oec_ntk.get_constant( true )] = bill::lit_type( 0, bill::lit_type::polarities::negative );
+        }
+        oec_ntk.foreach_pi( [&]( auto const& n, auto i ) {
+          oe_lits[n] = i < ntk.num_pos() ? po_lits[i] : po_lits_link[i - ntk.num_pos()];
+        } );
+
+        oec_ntk.foreach_gate( [&]( auto const& n ){
+          oe_lits[n] = bill::lit_type( solver.add_variable(), bill::lit_type::polarities::positive );
+        });
+
+        auto out_lits = generate_cnf<typename Ntk::base_type, bill::lit_type>( oec_ntk, add_clause_fn, oe_lits );
+        solver.add_clause( {out_lits[0]} );
+      }
+    }
+  }
+
+  bill::lit_type construct( node const& n )
+  {
+    assert( !constructed.has( n ) && !ntk.is_pi( n ) && !ntk.is_constant( n ) );
+    if constexpr ( use_pushpop )
+    {
+      if ( between_push_pop )
+      {
+        tmp.emplace_back( n );
+      }
+    }
+
+    std::vector<bill::lit_type> child_lits;
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      if ( !constructed.has( f ) && !ntk.is_pi( ntk.get_node( f ) ) && !ntk.is_constant( ntk.get_node( f ) ) )
+      {
+        construct( ntk.get_node( f ) );
+      }
+      child_lits.push_back( lit_not_cond( literals[f], ntk.is_complemented( f ) ) );
+    } );
+    bill::lit_type node_lit = literals[n] = bill::lit_type( solver.add_variable(), bill::lit_type::polarities::positive );
+    constructed[n] = true;
+
+    if ( ntk.is_and( n ) )
+    {
+      detail::on_and<add_clause_fn_t>( node_lit, child_lits[0], child_lits[1], add_clause_fn );
+    }
+    else if ( ntk.is_xor( n ) )
+    {
+      detail::on_xor<add_clause_fn_t>( node_lit, child_lits[0], child_lits[1], add_clause_fn );
+    }
+    else if ( ntk.is_xor3( n ) )
+    {
+      detail::on_xor3<add_clause_fn_t>( node_lit, child_lits[0], child_lits[1], child_lits[2], add_clause_fn );
+    }
+    else if ( ntk.is_maj( n ) )
+    {
+      detail::on_maj<add_clause_fn_t>( node_lit, child_lits[0], child_lits[1], child_lits[2], add_clause_fn );
+    }
+    else if ( ntk.is_ite( n ) )
+    {
+      detail::on_ite<add_clause_fn_t>( node_lit, child_lits[0], child_lits[1], child_lits[2], add_clause_fn );
+    }
+    return node_lit;
+  }
+
+  void push()
+  {
+    solver.push();
+    between_push_pop = true;
+    tmp.clear();
+  }
+
+  void pop()
+  {
+    solver.pop();
+    for ( auto& n : tmp )
+    {
+      constructed.erase( n );
+    }
+    between_push_pop = false;
+  }
+
+  bill::lit_type add_clauses_for_2input_gate( bill::lit_type a, bill::lit_type b, std::optional<bill::lit_type> c = std::nullopt, gate_type type = AND )
+  {
+    assert( type == AND || type == XOR );
+
+    auto nlit = c ? *c : bill::lit_type( solver.add_variable(), bill::lit_type::polarities::positive );
+    if ( type == AND )
+    {
+      detail::on_and<add_clause_fn_t>( nlit, a, b, add_clause_fn );
+    }
+    else if ( type == XOR )
+    {
+      detail::on_xor<add_clause_fn_t>( nlit, a, b, add_clause_fn );
+    }
+
+    return nlit;
+  }
+
+  bill::lit_type add_clauses_for_3input_gate( bill::lit_type a, bill::lit_type b, bill::lit_type c, std::optional<bill::lit_type> d = std::nullopt, gate_type type = MAJ )
+  {
+    assert( type == MAJ || type == XOR || type == MUX );
+
+    auto nlit = d ? *d : bill::lit_type( solver.add_variable(), bill::lit_type::polarities::positive );
+    if ( type == MAJ )
+    {
+      detail::on_maj<add_clause_fn_t>( nlit, a, b, c, add_clause_fn );
+    }
+    else if ( type == XOR )
+    {
+      detail::on_xor3<add_clause_fn_t>( nlit, a, b, c, add_clause_fn );
+    }
+    else if ( type == MUX )
+    {
+      detail::on_ite<add_clause_fn_t>( nlit, a, b, c, add_clause_fn );
+    }
+
+    return nlit;
+  }
+
+  std::optional<bool> solve( std::vector<bill::lit_type> assumptions )
+  {
+    ++num_invoke;
+    auto const res = solver.solve( assumptions, ps.conflict_limit );
+
+    if ( res == bill::result::states::satisfiable )
+    {
+      auto model = solver.get_model().model();
+      for ( auto i = 0u; i < ntk.num_pis(); ++i )
+      {
+        cex.at( i ) = model.at( i + 1 ) == bill::lbool_type::true_;
+      }
+
+      if constexpr ( has_EXCDC_interface_v<Ntk> )
+      {
+        assert( !ntk.pattern_is_EXCDC( cex ) );
+      }
+      return false;
+    }
+    else if ( res == bill::result::states::unsatisfiable )
+    {
+      return true;
+    }
+    else
+    {
+      return std::nullopt; /* timeout or something wrong */
+    }
+  }
+
+  std::optional<bool> validate( node const& root, bill::lit_type const& lit )
+  {
+    if ( !constructed.has( root ) && !ntk.is_pi( root ) && !ntk.is_constant( root ) )
+    {
+      construct( root );
+    }
+
+    std::optional<bool> res;
+    if constexpr ( use_odc )
+    {
+      if ( ps.odc_levels != 0 )
+      {
+        if constexpr ( use_pushpop )
+        {
+          push();
+        }
+        res = solve( { build_odc_window( root, lit ) } );
+        if constexpr ( use_pushpop )
+        {
+          pop();
+        }
+      }
+      else
+      {
+        auto nlit = bill::lit_type( solver.add_variable(), bill::lit_type::polarities::positive );
+        solver.add_clause( { literals[root], lit, nlit } );
+        solver.add_clause( { ~( literals[root] ), ~lit, nlit } );
+        res = solve( { ~nlit } );
+      }
+    }
+    else
+    {
+      auto nlit = bill::lit_type( solver.add_variable(), bill::lit_type::polarities::positive );
+      solver.add_clause( { literals[root], lit, nlit } );
+      solver.add_clause( { ~( literals[root] ), ~lit, nlit } );
+      res = solve( { ~nlit } );
+    }
+
+    return res;
+  }
+
+  void block_pattern( std::vector<bool> const& pattern )
+  {
+    assert( pattern.size() == ntk.num_pis() );
+    std::vector<bill::lit_type> clause;
+    ntk.foreach_pi( [&]( auto const& n, auto i ) {
+      clause.emplace_back( lit_not_cond( literals[n], pattern[i] ) );
+    } );
+    solver.add_clause( clause );
+  }
+
+private:
+  template<bool enabled = use_odc, typename = std::enable_if_t<enabled>>
+  bill::lit_type build_odc_window( node const& root, bill::lit_type const& lit )
+  {
+    /* literals for the duplicated fanout cone */
+    unordered_node_map<bill::lit_type, Ntk> lits( ntk );
+    /* miter literals that should be empty */
+    std::vector<bill::lit_type> miter;
+
+    lits[root] = lit;
+    ntk.incr_trav_id();
+    make_lit_fanout_cone_rec( root, lits, miter, 1 );
+    ntk.incr_trav_id();
+    duplicate_fanout_cone_rec( root, lits, 1 );
+
+    if constexpr ( has_EXODC_interface_v<Ntk> )
+    {
+      if ( ps.odc_levels == -1 )
+      {
+        assert( miter.size() == 0 );
+        auto assump = bill::lit_type( solver.add_variable(), bill::lit_type::polarities::positive );
+        ntk.foreach_po( [&]( auto const& f, auto i ) {
+          auto dup_po_lit = lit_not_cond( lits.has( ntk.get_node( f ) ) ? lits[f] : literals[f], ntk.is_complemented( f ) );
+          solver.add_clause( {~assump, ~po_lits_link[i], dup_po_lit} );
+          solver.add_clause( {~assump, po_lits_link[i], ~dup_po_lit} );
+        } );
+        return assump;
+      }
+    }
+
+    /* miter for POs */
+    ntk.foreach_po( [&]( auto const& f ) {
+      if ( !lits.has( ntk.get_node( f ) ) )
+        return true; /* PO not in TFO, skip */
+      add_miter_clauses( ntk.get_node( f ), lits, miter );
+      return true; /* next */
+    } );
+
+    assert( miter.size() > 0 && "no fanout node at distance odc_levels and there is no PO in TFO cone (possibly due to a dangling cone)" );
+    auto assump = bill::lit_type( solver.add_variable(), bill::lit_type::polarities::positive );
+    miter.emplace_back( ~assump );
+    solver.add_clause( miter );
+    return assump;
+  }
+
+  template<bool enabled = use_odc, typename = std::enable_if_t<enabled>>
+  void duplicate_fanout_cone_rec( node const& n, unordered_node_map<bill::lit_type, Ntk> const& lits, int32_t level )
+  {
+    ntk.foreach_fanout( n, [&]( auto const& fo ) {
+      if ( ntk.visited( fo ) == ntk.trav_id() )
+        return true; /* skip */
+      ntk.set_visited( fo, ntk.trav_id() );
+
+      std::vector<bill::lit_type> l_fi;
+      ntk.foreach_fanin( fo, [&]( auto const& fi ) {
+        if ( !constructed.has( fi ) && !ntk.is_pi( ntk.get_node( fi ) ) && !ntk.is_constant( ntk.get_node( fi ) ) )
+        {
+          construct( ntk.get_node( fi ) );
+        }
+        l_fi.emplace_back( lit_not_cond( lits.has( ntk.get_node( fi ) ) ? lits[fi] : literals[fi], ntk.is_complemented( fi ) ) );
+      } );
+      if ( l_fi.size() == 2u )
+      {
+        assert( ntk.is_and( fo ) || ntk.is_xor( fo ) );
+        add_clauses_for_2input_gate( l_fi[0], l_fi[1], lits[fo], ntk.is_and( fo ) ? AND : XOR );
+      }
+      else
+      {
+        assert( l_fi.size() == 3u );
+        assert( ntk.is_maj( fo ) || ntk.is_xor3( fo ) );
+        add_clauses_for_3input_gate( l_fi[0], l_fi[1], l_fi[2], lits[fo], ntk.is_maj( fo ) ? MAJ : XOR );
+      }
+
+      if ( level == ps.odc_levels )
+        return true;
+
+      duplicate_fanout_cone_rec( fo, lits, level + 1 );
+      return true; /* next */
+    } );
+  }
+
+  template<bool enabled = use_odc, typename = std::enable_if_t<enabled>>
+  void make_lit_fanout_cone_rec( node const& n, unordered_node_map<bill::lit_type, Ntk>& lits, std::vector<bill::lit_type>& miter, int32_t level )
+  {
+    ntk.foreach_fanout( n, [&]( auto const& fo ) {
+      if ( ntk.visited( fo ) == ntk.trav_id() )
+        return true; /* skip */
+      ntk.set_visited( fo, ntk.trav_id() );
+
+      if ( !constructed.has( fo ) )
+      {
+        construct( fo );
+      }
+
+      lits[fo] = bill::lit_type( solver.add_variable(), bill::lit_type::polarities::positive );
+
+      if ( level == ps.odc_levels )
+      {
+        add_miter_clauses( fo, lits, miter );
+        return true;
+      }
+
+      make_lit_fanout_cone_rec( fo, lits, miter, level + 1 );
+      return true; /* next */
+    } );
+  }
+
+  template<bool enabled = use_odc, typename = std::enable_if_t<enabled>>
+  void add_miter_clauses( node const& n, unordered_node_map<bill::lit_type, Ntk> const& lits, std::vector<bill::lit_type>& miter )
+  {
+    assert( constructed.has( n ) && literals[n] != literals[ntk.get_constant( false )] );
+    miter.emplace_back( add_clauses_for_2input_gate( literals[n], lits[n], std::nullopt, XOR ) );
+  }
+
+private:
+  Ntk const& ntk;
+
+  validator_params ps;
+
+  node_map<bill::lit_type, Ntk> literals;
+  unordered_node_map<bool, Ntk> constructed;
+  bill::solver<Solver> solver;
+  add_clause_fn_t add_clause_fn = [&]( auto const& clause ) { solver.add_clause( clause ); };
+
+  static const uint32_t MIN_NUM_INVOKE = 20u;
+  uint32_t num_invoke;
+
+  bool between_push_pop = false;
+  std::vector<node> tmp;
+
+  std::shared_ptr<typename network_events<Ntk>::add_event_type> add_event;
+
+  std::vector<bill::lit_type> po_lits_link;
+
+public:
+  std::vector<bool> cex;
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/cleanup.hpp b/include/mockturtle/algorithms/cleanup.hpp
new file mode 100644
index 0000000..766d677
--- /dev/null
+++ b/include/mockturtle/algorithms/cleanup.hpp
@@ -0,0 +1,657 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cleanup.hpp
+  \brief Cleans up networks
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../networks/crossed.hpp"
+#include "../traits.hpp"
+#include "../utils/node_map.hpp"
+#include "../views/topo_view.hpp"
+
+#include <kitty/operations.hpp>
+
+#include <iostream>
+#include <type_traits>
+#include <vector>
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+template<typename NtkSrc, typename NtkDest, typename LeavesIterator>
+void cleanup_dangling_impl( NtkSrc const& ntk, NtkDest& dest, LeavesIterator begin, LeavesIterator end, node_map<signal<NtkDest>, NtkSrc>& old_to_new )
+{
+  /* constants */
+  old_to_new[ntk.get_constant( false )] = dest.get_constant( false );
+  if ( ntk.get_node( ntk.get_constant( true ) ) != ntk.get_node( ntk.get_constant( false ) ) )
+  {
+    old_to_new[ntk.get_constant( true )] = dest.get_constant( true );
+  }
+
+  /* create inputs in the same order */
+  auto it = begin;
+  ntk.foreach_pi( [&]( auto node ) {
+    old_to_new[node] = *it++;
+  } );
+  if constexpr ( has_foreach_ro_v<NtkSrc> )
+  {
+    ntk.foreach_ro( [&]( auto node ) {
+      old_to_new[node] = *it++;
+    } );
+  }
+  assert( it == end );
+  (void)end;
+
+  /* foreach node in topological order */
+  topo_view topo{ ntk };
+  topo.foreach_node( [&]( auto node ) {
+    if ( ntk.is_constant( node ) || ntk.is_ci( node ) )
+      return;
+
+    /* collect children */
+    std::vector<signal<NtkDest>> children;
+    ntk.foreach_fanin( node, [&]( auto child, auto ) {
+      const auto f = old_to_new[child];
+      if ( ntk.is_complemented( child ) )
+      {
+        children.push_back( dest.create_not( f ) );
+      }
+      else
+      {
+        children.push_back( f );
+      }
+    } );
+
+    /* clone node */
+    if constexpr ( std::is_same_v<NtkSrc, NtkDest> )
+    {
+      old_to_new[node] = dest.clone_node( ntk, node, children );
+    }
+    else
+    {
+      do
+      {
+        if constexpr ( has_is_and_v<NtkSrc> )
+        {
+          static_assert( has_create_and_v<NtkDest>, "NtkDest cannot create AND gates" );
+          if ( ntk.is_and( node ) )
+          {
+            old_to_new[node] = dest.create_and( children[0], children[1] );
+            break;
+          }
+        }
+        if constexpr ( has_is_or_v<NtkSrc> )
+        {
+          static_assert( has_create_or_v<NtkDest>, "NtkDest cannot create OR gates" );
+          if ( ntk.is_or( node ) )
+          {
+            old_to_new[node] = dest.create_or( children[0], children[1] );
+            break;
+          }
+        }
+        if constexpr ( has_is_xor_v<NtkSrc> )
+        {
+          static_assert( has_create_xor_v<NtkDest>, "NtkDest cannot create XOR gates" );
+          if ( ntk.is_xor( node ) )
+          {
+            old_to_new[node] = dest.create_xor( children[0], children[1] );
+            break;
+          }
+        }
+        if constexpr ( has_is_maj_v<NtkSrc> )
+        {
+          static_assert( has_create_maj_v<NtkDest>, "NtkDest cannot create MAJ gates" );
+          if ( ntk.is_maj( node ) )
+          {
+            old_to_new[node] = dest.create_maj( children[0], children[1], children[2] );
+            break;
+          }
+        }
+        if constexpr ( has_is_ite_v<NtkSrc> )
+        {
+          static_assert( has_create_ite_v<NtkDest>, "NtkDest cannot create ITE gates" );
+          if ( ntk.is_ite( node ) )
+          {
+            old_to_new[node] = dest.create_ite( children[0], children[1], children[2] );
+            break;
+          }
+        }
+        if constexpr ( has_is_xor3_v<NtkSrc> )
+        {
+          static_assert( has_create_xor3_v<NtkDest>, "NtkDest cannot create XOR3 gates" );
+          if ( ntk.is_xor3( node ) )
+          {
+            old_to_new[node] = dest.create_xor3( children[0], children[1], children[2] );
+            break;
+          }
+        }
+        if constexpr ( has_is_nary_and_v<NtkSrc> )
+        {
+          static_assert( has_create_nary_and_v<NtkDest>, "NtkDest cannot create n-ary AND gates" );
+          if ( ntk.is_nary_and( node ) )
+          {
+            old_to_new[node] = dest.create_nary_and( children );
+            break;
+          }
+        }
+        if constexpr ( has_is_nary_or_v<NtkSrc> )
+        {
+          static_assert( has_create_nary_or_v<NtkDest>, "NtkDest cannot create n-ary OR gates" );
+          if ( ntk.is_nary_or( node ) )
+          {
+            old_to_new[node] = dest.create_nary_or( children );
+            break;
+          }
+        }
+        if constexpr ( has_is_nary_xor_v<NtkSrc> )
+        {
+          static_assert( has_create_nary_xor_v<NtkDest>, "NtkDest cannot create n-ary XOR gates" );
+          if ( ntk.is_nary_xor( node ) )
+          {
+            old_to_new[node] = dest.create_nary_xor( children );
+            break;
+          }
+        }
+        if constexpr ( has_is_not_v<NtkSrc> )
+        {
+          static_assert( has_create_not_v<NtkDest>, "NtkDest cannot create NOT gates" );
+          if ( ntk.is_not( node ) )
+          {
+            old_to_new[node] = dest.create_not( children[0] );
+            break;
+          }
+        }
+        if constexpr ( has_is_buf_v<NtkSrc> )
+        {
+          static_assert( has_create_buf_v<NtkDest>, "NtkDest cannot create buffers" );
+          if ( ntk.is_buf( node ) )
+          {
+            old_to_new[node] = dest.create_buf( children[0] );
+            break;
+          }
+        }
+        if constexpr ( has_is_function_v<NtkSrc> )
+        {
+          static_assert( has_create_node_v<NtkDest>, "NtkDest cannot create arbitrary function gates" );
+          old_to_new[node] = dest.create_node( children, ntk.node_function( node ) );
+          break;
+        }
+        std::cerr << "[e] something went wrong, could not copy node " << ntk.node_to_index( node ) << "\n";
+      } while ( false );
+    }
+
+    /* copy name */
+    if constexpr ( has_has_name_v<NtkSrc> && has_get_name_v<NtkSrc> && has_set_name_v<NtkDest> )
+    {
+      auto const s = ntk.make_signal( node );
+      if ( ntk.has_name( s ) )
+      {
+        dest.set_name( old_to_new[node], ntk.get_name( s ) );
+      }
+      if ( ntk.has_name( !s ) )
+      {
+        dest.set_name( !old_to_new[node], ntk.get_name( !s ) );
+      }
+    }
+  } );
+}
+
+template<typename NtkSrc, typename NtkDest, typename LeavesIterator>
+void cleanup_dangling_with_crossings_impl( NtkSrc const& ntk, NtkDest& dest, LeavesIterator begin, LeavesIterator end, node_map<signal<NtkDest>, NtkSrc>& old_to_new )
+{
+  /* constants */
+  old_to_new[ntk.get_constant( false )] = dest.get_constant( false );
+  if ( ntk.get_node( ntk.get_constant( true ) ) != ntk.get_node( ntk.get_constant( false ) ) )
+  {
+    old_to_new[ntk.get_constant( true )] = dest.get_constant( true );
+  }
+
+  /* create inputs in the same order */
+  auto it = begin;
+  ntk.foreach_pi( [&]( auto node ) {
+    old_to_new[node] = *it++;
+  } );
+  if constexpr ( has_foreach_ro_v<NtkSrc> )
+  {
+    ntk.foreach_ro( [&]( auto node ) {
+      old_to_new[node] = *it++;
+    } );
+  }
+  assert( it == end );
+  (void)end;
+
+  /* foreach node in topological order */
+  topo_view topo{ ntk };
+  topo.foreach_node( [&]( auto node ) {
+    if ( ntk.is_constant( node ) || ntk.is_ci( node ) )
+      return;
+
+    /* collect children */
+    std::vector<signal<NtkDest>> children;
+    ntk.foreach_fanin( node, [&]( auto const& f ) {
+      if ( ntk.is_crossing( ntk.get_node( f ) ) )
+        children.push_back( ntk.is_second( f ) ? dest.make_second( old_to_new[f] ) : old_to_new[f] );
+      else
+        children.push_back( old_to_new[f] );
+    } );
+
+    /* clone node */
+    if ( ntk.is_crossing( node ) )
+    {
+      assert( children.size() == 2 );
+      old_to_new[node] = dest.create_crossing( children[0], children[1] ).first;
+    }
+    else
+    {
+      old_to_new[node] = dest.clone_node( ntk, node, children );
+    }
+
+    /* copy name */
+    if constexpr ( has_has_name_v<NtkSrc> && has_get_name_v<NtkSrc> && has_set_name_v<NtkDest> )
+    {
+      auto const s = ntk.make_signal( node );
+      if ( ntk.has_name( s ) )
+      {
+        dest.set_name( old_to_new[node], ntk.get_name( s ) );
+      }
+      if ( ntk.has_name( !s ) )
+      {
+        dest.set_name( !old_to_new[node], ntk.get_name( !s ) );
+      }
+    }
+  } );
+}
+
+template<typename Ntk, typename LeavesIterator>
+void cleanup_luts_impl( Ntk const& ntk, Ntk& dest, LeavesIterator begin, LeavesIterator end, node_map<signal<Ntk>, Ntk>& old_to_new )
+{
+  /* constants */
+  old_to_new[ntk.get_constant( false )] = dest.get_constant( false );
+  if ( ntk.get_node( ntk.get_constant( true ) ) != ntk.get_node( ntk.get_constant( false ) ) )
+  {
+    old_to_new[ntk.get_constant( true )] = dest.get_constant( true );
+  }
+
+  /* create inputs in the same order */
+  auto it = begin;
+  ntk.foreach_pi( [&]( auto node ) {
+    old_to_new[node] = *it++;
+  } );
+  if constexpr ( has_foreach_ro_v<Ntk> )
+  {
+    ntk.foreach_ro( [&]( auto node ) {
+      old_to_new[node] = *it++;
+    } );
+  }
+  assert( it == end );
+  (void)end;
+
+  /* iterate through nodes */
+  topo_view topo{ ntk };
+  topo.foreach_node( [&]( auto const& n ) {
+    if ( ntk.is_constant( n ) || ntk.is_ci( n ) )
+      return; /* continue */
+
+    auto func = ntk.node_function( n );
+
+    /* constant propagation */
+    ntk.foreach_fanin( n, [&]( auto const& f, auto i ) {
+      if ( dest.is_constant( old_to_new[f] ) )
+      {
+        if ( dest.constant_value( old_to_new[f] ) != ntk.is_complemented( f ) )
+        {
+          kitty::cofactor1_inplace( func, i );
+        }
+        else
+        {
+          kitty::cofactor0_inplace( func, i );
+        }
+      }
+    } );
+
+    const auto support = kitty::min_base_inplace( func );
+    auto new_func = kitty::shrink_to( func, static_cast<unsigned int>( support.size() ) );
+
+    std::vector<signal<Ntk>> children;
+    if ( auto var = support.begin(); var != support.end() )
+    {
+      ntk.foreach_fanin( n, [&]( auto const& f, auto i ) {
+        if ( *var == i )
+        {
+          auto const& new_f = old_to_new[f];
+          children.push_back( ntk.is_complemented( f ) ? dest.create_not( new_f ) : new_f );
+          if ( ++var == support.end() )
+          {
+            return false;
+          }
+        }
+        return true;
+      } );
+    }
+
+    if ( new_func.num_vars() == 0u )
+    {
+      old_to_new[n] = dest.get_constant( !kitty::is_const0( new_func ) );
+    }
+    else if ( new_func.num_vars() == 1u )
+    {
+      old_to_new[n] = *( new_func.begin() ) == 0b10 ? children.front() : dest.create_not( children.front() );
+    }
+    else
+    {
+      old_to_new[n] = dest.create_node( children, new_func );
+    }
+
+    if constexpr ( has_has_name_v<Ntk> && has_get_name_v<Ntk> && has_set_name_v<Ntk> )
+    {
+      auto const s = ntk.make_signal( n );
+      if ( ntk.has_name( s ) )
+      {
+        dest.set_name( old_to_new[n], ntk.get_name( s ) );
+      }
+      if ( ntk.has_name( !s ) )
+      {
+        dest.set_name( !old_to_new[n], ntk.get_name( !s ) );
+      }
+    }
+  } );
+}
+
+template<typename NtkSrc, typename NtkDest>
+void clone_inputs( NtkSrc const& ntk, NtkDest& dest, std::vector<signal<NtkDest>>& cis, bool remove_dangling_PIs = false )
+{
+  /* network name */
+  if constexpr ( has_get_network_name_v<NtkSrc> && has_set_network_name_v<NtkDest> )
+  {
+    dest.set_network_name( ntk.get_network_name() );
+  }
+
+  /* PIs & PI names */
+  ntk.foreach_pi( [&]( auto n ) {
+    if ( remove_dangling_PIs && ntk.fanout_size( n ) == 0 )
+    {
+      cis.push_back( dest.get_constant( false ) );
+    }
+    else
+    {
+      cis.push_back( dest.create_pi() );
+      if constexpr ( has_has_name_v<NtkSrc> && has_get_name_v<NtkSrc> && has_set_name_v<NtkDest> )
+      {
+        auto const s = ntk.make_signal( n );
+        if ( ntk.has_name( s ) )
+        {
+          dest.set_name( cis.back(), ntk.get_name( s ) );
+        }
+        if ( ntk.has_name( !s ) )
+        {
+          dest.set_name( !cis.back(), ntk.get_name( !s ) );
+        }
+      }
+    }
+  } );
+
+  /* ROs & RO names & register information */
+  if constexpr ( has_foreach_ro_v<NtkSrc> && has_create_ro_v<NtkDest> )
+  {
+    ntk.foreach_ro( [&]( auto const& n, auto i ) {
+      cis.push_back( dest.create_ro() );
+      if constexpr ( has_has_name_v<NtkSrc> && has_get_name_v<NtkSrc> && has_set_name_v<NtkDest> )
+      {
+        auto const s = ntk.make_signal( n );
+        if ( ntk.has_name( s ) )
+        {
+          dest.set_name( cis.back(), ntk.get_name( s ) );
+        }
+        if ( ntk.has_name( !s ) )
+        {
+          dest.set_name( !cis.back(), ntk.get_name( !s ) );
+        }
+      }
+      dest.set_register( i, ntk.register_at( i ) );
+    } );
+  }
+}
+
+template<typename NtkSrc, typename NtkDest>
+void clone_outputs( NtkSrc const& ntk, NtkDest& dest, node_map<signal<NtkDest>, NtkSrc> const& old_to_new, bool remove_redundant_POs = false )
+{
+  /* POs */
+  ntk.foreach_po( [&]( auto const& po ) {
+    auto const f = old_to_new[po];
+    auto const n = dest.get_node( f );
+    if ( remove_redundant_POs && ( dest.is_pi( n ) || dest.is_constant( n ) ) )
+    {
+      return;
+    }
+    dest.create_po( ntk.is_complemented( po ) ? dest.create_not( f ) : f );
+  } );
+
+  /* RIs */
+  if constexpr ( has_foreach_ri_v<NtkSrc> && has_create_ri_v<NtkDest> )
+  {
+    ntk.foreach_ri( [&]( auto const& f ) {
+      dest.create_ri( ntk.is_complemented( f ) ? dest.create_not( old_to_new[f] ) : old_to_new[f] );
+    } );
+  }
+
+  /* CO names */
+  if constexpr ( has_has_output_name_v<NtkSrc> && has_get_output_name_v<NtkSrc> && has_set_output_name_v<NtkDest> )
+  {
+    ntk.foreach_co( [&]( auto co, auto index ) {
+      (void)co;
+      if ( ntk.has_output_name( index ) )
+      {
+        dest.set_output_name( index, ntk.get_output_name( index ) );
+      }
+    } );
+  }
+}
+
+} // namespace detail
+
+template<typename NtkSrc, typename NtkDest, typename LeavesIterator>
+std::vector<signal<NtkDest>> cleanup_dangling( NtkSrc const& ntk, NtkDest& dest, LeavesIterator begin, LeavesIterator end )
+{
+  static_assert( is_network_type_v<NtkSrc>, "NtkSrc is not a network type" );
+  static_assert( is_network_type_v<NtkDest>, "NtkDest is not a network type" );
+
+  static_assert( has_get_node_v<NtkSrc>, "NtkSrc does not implement the get_node method" );
+  static_assert( has_get_constant_v<NtkSrc>, "NtkSrc does not implement the get_constant method" );
+  static_assert( has_foreach_pi_v<NtkSrc>, "NtkSrc does not implement the foreach_pi method" );
+  static_assert( has_is_pi_v<NtkSrc>, "NtkSrc does not implement the is_pi method" );
+  static_assert( has_is_constant_v<NtkSrc>, "NtkSrc does not implement the is_constant method" );
+  static_assert( has_is_complemented_v<NtkSrc>, "NtkSrc does not implement the is_complemented method" );
+  static_assert( has_foreach_po_v<NtkSrc>, "NtkSrc does not implement the foreach_po method" );
+
+  static_assert( has_get_constant_v<NtkDest>, "NtkDest does not implement the get_constant method" );
+  static_assert( has_create_not_v<NtkDest>, "NtkDest does not implement the create_not method" );
+  static_assert( has_clone_node_v<NtkDest>, "NtkDest does not implement the clone_node method" );
+
+  node_map<signal<NtkDest>, NtkSrc> old_to_new( ntk );
+  detail::cleanup_dangling_impl( ntk, dest, begin, end, old_to_new );
+  std::vector<signal<NtkDest>> fs;
+
+  /* create outputs in the same order */
+  ntk.foreach_po( [&]( auto po ) {
+    const auto f = old_to_new[po];
+    fs.push_back( ntk.is_complemented( po ) ? dest.create_not( f ) : f );
+  } );
+  if constexpr ( has_foreach_ri_v<NtkSrc> )
+  {
+    ntk.foreach_ri( [&]( auto ri ) {
+      const auto f = old_to_new[ri];
+      fs.push_back( ntk.is_complemented( ri ) ? dest.create_not( f ) : f );
+    } );
+  }
+
+  return fs;
+}
+
+/*! \brief Cleans up dangling nodes.
+ *
+ * This method reconstructs a network and omits all dangling nodes. If the flag
+ * `remove_dangling_PIs` is true, dangling PIs are also omitted. If the flag
+ * `remove_redundant_POs` is true, redundant POs, i.e. POs connected to a PI or
+ * constant, are also omitted. The network types of the source and destination
+ * network are the same.
+ *
+   \verbatim embed:rst
+
+   .. note::
+
+      This method returns the cleaned up network as a return value.  It does
+      *not* modify the input network.
+   \endverbatim
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `node_to_index`
+ * - `get_constant`
+ * - `create_pi`
+ * - `create_po`
+ * - `create_not`
+ * - `is_complemented`
+ * - `foreach_node`
+ * - `foreach_pi`
+ * - `foreach_po`
+ * - `clone_node`
+ * - `is_pi`
+ * - `is_constant`
+ */
+template<class NtkSrc, class NtkDest = NtkSrc>
+[[nodiscard]] NtkDest cleanup_dangling( NtkSrc const& ntk, bool remove_dangling_PIs = false, bool remove_redundant_POs = false )
+{
+  static_assert( is_network_type_v<NtkSrc>, "NtkSrc is not a network type" );
+  static_assert( is_network_type_v<NtkDest>, "NtkDest is not a network type" );
+  static_assert( has_get_node_v<NtkSrc>, "NtkSrc does not implement the get_node method" );
+  static_assert( has_node_to_index_v<NtkSrc>, "NtkSrc does not implement the node_to_index method" );
+  static_assert( has_get_constant_v<NtkSrc>, "NtkSrc does not implement the get_constant method" );
+  static_assert( has_foreach_node_v<NtkSrc>, "NtkSrc does not implement the foreach_node method" );
+  static_assert( has_foreach_pi_v<NtkSrc>, "NtkSrc does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<NtkSrc>, "NtkSrc does not implement the foreach_po method" );
+  static_assert( has_is_pi_v<NtkSrc>, "NtkSrc does not implement the is_pi method" );
+  static_assert( has_is_constant_v<NtkSrc>, "NtkSrc does not implement the is_constant method" );
+  static_assert( has_clone_node_v<NtkDest>, "NtkDest does not implement the clone_node method" );
+  static_assert( has_create_pi_v<NtkDest>, "NtkDest does not implement the create_pi method" );
+  static_assert( has_create_po_v<NtkDest>, "NtkDest does not implement the create_po method" );
+  static_assert( has_create_not_v<NtkDest>, "NtkDest does not implement the create_not method" );
+  static_assert( has_is_complemented_v<NtkSrc>, "NtkDest does not implement the is_complemented method" );
+
+  NtkDest dest;
+
+  std::vector<signal<NtkDest>> cis;
+  detail::clone_inputs( ntk, dest, cis, remove_dangling_PIs );
+
+  node_map<signal<NtkDest>, NtkSrc> old_to_new( ntk );
+  if constexpr ( is_crossed_network_type_v<NtkSrc> )
+  {
+    detail::cleanup_dangling_with_crossings_impl( ntk, dest, cis.begin(), cis.end(), old_to_new );
+  }
+  else
+  {
+    detail::cleanup_dangling_impl( ntk, dest, cis.begin(), cis.end(), old_to_new );
+  }
+
+  detail::clone_outputs( ntk, dest, old_to_new, remove_redundant_POs );
+
+  return dest;
+}
+
+/*! \brief Cleans up LUT nodes.
+ *
+ * This method reconstructs a LUT network and optimizes LUTs when they do not
+ * depend on all their fanin, or when some of the fanin are constant inputs.
+ *
+ * Constant gate inputs will be propagated.
+ *
+   \verbatim embed:rst
+
+   .. note::
+
+      This method returns the cleaned up network as a return value.  It does
+      *not* modify the input network.
+   \endverbatim
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `get_constant`
+ * - `foreach_pi`
+ * - `foreach_po`
+ * - `foreach_node`
+ * - `foreach_fanin`
+ * - `create_pi`
+ * - `create_po`
+ * - `create_node`
+ * - `create_not`
+ * - `is_constant`
+ * - `is_pi`
+ * - `is_complemented`
+ * - `node_function`
+ */
+template<class Ntk>
+[[nodiscard]] Ntk cleanup_luts( Ntk const& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_create_pi_v<Ntk>, "Ntk does not implement the create_pi method" );
+  static_assert( has_create_po_v<Ntk>, "Ntk does not implement the create_po method" );
+  static_assert( has_create_node_v<Ntk>, "Ntk does not implement the create_node method" );
+  static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_constant_value_v<Ntk>, "Ntk does not implement the constant_value method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_node_function_v<Ntk>, "Ntk does not implement the node_function method" );
+
+  Ntk dest;
+
+  std::vector<signal<Ntk>> cis;
+  detail::clone_inputs( ntk, dest, cis );
+
+  node_map<signal<Ntk>, Ntk> old_to_new( ntk );
+  detail::cleanup_luts_impl( ntk, dest, cis.begin(), cis.end(), old_to_new );
+
+  detail::clone_outputs( ntk, dest, old_to_new );
+
+  return dest;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/cnf.hpp b/include/mockturtle/algorithms/cnf.hpp
new file mode 100644
index 0000000..4a825d6
--- /dev/null
+++ b/include/mockturtle/algorithms/cnf.hpp
@@ -0,0 +1,507 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cnf.hpp
+  \brief CNF generation methods
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <optional>
+#include <vector>
+
+#include <bill/sat/interface/common.hpp>
+#include <bill/sat/interface/types.hpp>
+#include <fmt/format.h>
+#include <kitty/cnf.hpp>
+#include <kitty/constructors.hpp>
+
+#include "../traits.hpp"
+#include "../utils/node_map.hpp"
+
+namespace mockturtle
+{
+
+inline constexpr uint32_t make_lit( uint32_t var, bool is_complemented = false )
+{
+  return ( var << 1 ) | ( is_complemented ? 1 : 0 );
+}
+
+inline constexpr uint32_t lit_not( uint32_t lit )
+{
+  return lit ^ 0x1;
+}
+
+inline bill::lit_type lit_not( bill::lit_type lit )
+{
+  return ~lit;
+}
+
+inline constexpr uint32_t lit_not_cond( uint32_t lit, bool cond )
+{
+  return cond ? lit ^ 0x1 : lit;
+}
+
+inline bill::lit_type lit_not_cond( bill::lit_type lit, bool cond )
+{
+  return cond ? ~lit : lit;
+}
+
+namespace detail
+{
+
+/* c = a & b */
+template<class ClauseFn>
+inline void on_and( uint32_t c, uint32_t a, uint32_t b, ClauseFn const& fn )
+{
+  fn( { a, lit_not( c ) } );
+  fn( { b, lit_not( c ) } );
+  fn( { lit_not( a ), lit_not( b ), c } );
+}
+
+/* c = a & b */
+template<class ClauseFn>
+inline void on_and( bill::lit_type c, bill::lit_type a, bill::lit_type b, ClauseFn const& fn )
+{
+  fn( { a, ~c } );
+  fn( { b, ~c } );
+  fn( { ~a, ~b, c } );
+}
+
+/* c = a | b */
+template<class ClauseFn>
+inline void on_or( uint32_t c, uint32_t a, uint32_t b, ClauseFn const& fn )
+{
+  fn( { lit_not( a ), c } );
+  fn( { lit_not( b ), c } );
+  fn( { a, b, lit_not( c ) } );
+}
+
+/* c = a | b */
+template<class ClauseFn>
+inline void on_or( bill::lit_type c, bill::lit_type a, bill::lit_type b, ClauseFn const& fn )
+{
+  fn( { ~a, c } );
+  fn( { ~b, c } );
+  fn( { a, b, ~c } );
+}
+
+/* c = a ^ b */
+template<class ClauseFn>
+inline void on_xor( uint32_t c, uint32_t a, uint32_t b, ClauseFn const& fn )
+{
+  fn( { lit_not( a ), lit_not( b ), lit_not( c ) } );
+  fn( { lit_not( a ), b, c } );
+  fn( { a, lit_not( b ), c } );
+  fn( { a, b, lit_not( c ) } );
+}
+
+/* c = a ^ b */
+template<class ClauseFn>
+inline void on_xor( bill::lit_type c, bill::lit_type a, bill::lit_type b, ClauseFn const& fn )
+{
+  fn( { ~a, ~b, ~c } );
+  fn( { ~a, b, c } );
+  fn( { a, ~b, c } );
+  fn( { a, b, ~c } );
+}
+
+/* d = <abc> */
+template<class ClauseFn>
+inline void on_maj( uint32_t d, uint32_t a, uint32_t b, uint32_t c, ClauseFn const& fn )
+{
+  fn( { lit_not( a ), lit_not( b ), d } );
+  fn( { lit_not( a ), lit_not( c ), d } );
+  fn( { lit_not( b ), lit_not( c ), d } );
+  fn( { a, b, lit_not( d ) } );
+  fn( { a, c, lit_not( d ) } );
+  fn( { b, c, lit_not( d ) } );
+}
+
+/* d = <abc> */
+template<class ClauseFn>
+inline void on_maj( bill::lit_type d, bill::lit_type a, bill::lit_type b, bill::lit_type c, ClauseFn const& fn )
+{
+  fn( { ~a, ~b, d } );
+  fn( { ~a, ~c, d } );
+  fn( { ~b, ~c, d } );
+  fn( { a, b, ~d } );
+  fn( { a, c, ~d } );
+  fn( { b, c, ~d } );
+}
+
+/* d = a ^ b ^ c */
+template<class ClauseFn>
+inline void on_xor3( uint32_t d, uint32_t a, uint32_t b, uint32_t c, ClauseFn const& fn )
+{
+  fn( { lit_not( a ), b, c, d } );
+  fn( { a, lit_not( b ), c, d } );
+  fn( { a, b, lit_not( c ), d } );
+  fn( { a, b, c, lit_not( d ) } );
+  fn( { a, lit_not( b ), lit_not( c ), lit_not( d ) } );
+  fn( { lit_not( a ), b, lit_not( c ), lit_not( d ) } );
+  fn( { lit_not( a ), lit_not( b ), c, lit_not( d ) } );
+  fn( { lit_not( a ), lit_not( b ), lit_not( c ), d } );
+}
+
+/* d = a ^ b ^ c */
+template<class ClauseFn>
+inline void on_xor3( bill::lit_type d, bill::lit_type a, bill::lit_type b, bill::lit_type c, ClauseFn const& fn )
+{
+  fn( { ~a, b, c, d } );
+  fn( { a, ~b, c, d } );
+  fn( { a, b, ~c, d } );
+  fn( { a, b, c, ~d } );
+  fn( { a, ~b, ~c, ~d } );
+  fn( { ~a, b, ~c, ~d } );
+  fn( { ~a, ~b, c, ~d } );
+  fn( { ~a, ~b, ~c, d } );
+}
+
+/* d = a ? b : c */
+template<class ClauseFn>
+inline void on_ite( uint32_t d, uint32_t a, uint32_t b, uint32_t c, ClauseFn const& fn )
+{
+  fn( { lit_not( a ), lit_not( b ), d } );
+  fn( { lit_not( a ), b, lit_not( d ) } );
+  fn( { a, lit_not( c ), d } );
+  fn( { a, c, lit_not( d ) } );
+}
+
+/* d = a ? b : c */
+template<class ClauseFn>
+inline void on_ite( bill::lit_type d, bill::lit_type a, bill::lit_type b, bill::lit_type c, ClauseFn const& fn )
+{
+  fn( { ~a, ~b, d } );
+  fn( { ~a, b, ~d } );
+  fn( { a, ~c, d } );
+  fn( { a, c, ~d } );
+}
+
+/* general case */
+template<class ClauseFn>
+inline void on_function( uint32_t f, std::vector<uint32_t> const& child_lits, kitty::dynamic_truth_table const& function, ClauseFn const& fn )
+{
+  const auto cnf = kitty::cnf_characteristic( function );
+
+  auto lits = child_lits;
+  lits.push_back( f );
+  for ( auto const& cube : cnf )
+  {
+    std::vector<uint32_t> clause;
+    for ( auto i = 0u; i < lits.size(); ++i )
+    {
+      if ( cube.get_mask( i ) )
+      {
+        clause.push_back( lit_not_cond( lits[i], !cube.get_bit( i ) ) );
+      }
+    }
+    fn( clause );
+  }
+}
+
+/* general case */
+template<class ClauseFn>
+inline void on_function( bill::lit_type f, std::vector<bill::lit_type> const& child_lits, kitty::dynamic_truth_table const& function, ClauseFn const& fn )
+{
+  const auto cnf = kitty::cnf_characteristic( function );
+
+  auto lits = child_lits;
+  lits.push_back( f );
+  for ( auto const& cube : cnf )
+  {
+    bill::result::clause_type clause;
+    for ( auto i = 0u; i < lits.size(); ++i )
+    {
+      if ( cube.get_mask( i ) )
+      {
+        clause.push_back( cube.get_bit( i ) ? lits[i] : ~lits[i] );
+      }
+    }
+    fn( clause );
+  }
+}
+
+} // namespace detail
+
+/*! \brief Clause callback function for generate_cnf. */
+template<class lit_t>
+using clause_callback_t = std::function<void( std::vector<lit_t> const& )>;
+
+/*! \brief Create a default node literal map.
+ *
+ * In the default map, constants are mapped to variable `0` (literal `1` for
+ * constant-1 and literal `0` for constant-0).  Then each primary input is
+ * mapped to variables `1, ..., n`.  Then the next variables are assigned to
+ * each gate in order, unless `gate_offset` is overridden which will be used for
+ * the next variable id.  Therefore, this function can be used to create two
+ * independent sets of node literals for two networks, but keep the same indexes
+ * for the primary inputs.
+ */
+template<class Ntk, typename lit_t = uint32_t>
+node_map<lit_t, Ntk> node_literals( Ntk const& ntk, std::optional<uint32_t> const& gate_offset = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_num_pis_v<Ntk>, "Ntk does not implement the num_pis method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+
+  node_map<lit_t, Ntk> node_lits( ntk );
+
+  if constexpr ( std::is_same<lit_t, uint32_t>::value )
+  {
+    /* constants are mapped to var 0 */
+    node_lits[ntk.get_constant( false )] = make_lit( 0 );
+    if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+    {
+      node_lits[ntk.get_constant( true )] = make_lit( 0, true );
+    }
+
+    /* first indexes (starting from 1) are for PIs */
+    ntk.foreach_pi( [&]( auto const& n, auto i ) {
+      node_lits[n] = make_lit( i + 1 );
+    } );
+
+    /* compute literals for nodes */
+    uint32_t next_var = gate_offset ? *gate_offset : ntk.num_pis() + 1;
+    ntk.foreach_gate( [&]( auto const& n ) {
+      node_lits[n] = make_lit( next_var++ );
+    } );
+  }
+  else if constexpr ( std::is_same<lit_t, bill::lit_type>::value )
+  {
+    /* constants are mapped to var 0 */
+    node_lits[ntk.get_constant( false )] = bill::lit_type( 0, bill::lit_type::polarities::positive );
+    if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+    {
+      node_lits[ntk.get_constant( true )] = bill::lit_type( 0, bill::lit_type::polarities::negative );
+    }
+
+    /* first indexes (starting from 1) are for PIs */
+    ntk.foreach_pi( [&]( auto const& n, auto i ) {
+      node_lits[n] = bill::lit_type( i + 1, bill::lit_type::polarities::positive );
+    } );
+
+    /* compute literals for nodes */
+    uint32_t next_var = gate_offset ? *gate_offset : ntk.num_pis() + 1;
+    ntk.foreach_gate( [&]( auto const& n ) {
+      node_lits[n] = bill::lit_type( next_var++, bill::lit_type::polarities::positive );
+    } );
+  }
+
+  return node_lits;
+}
+
+namespace detail
+{
+
+template<class Ntk, typename lit_t>
+class generate_cnf_impl
+{
+public:
+  generate_cnf_impl( Ntk const& ntk, clause_callback_t<lit_t> const& fn, std::optional<node_map<lit_t, Ntk>> const& node_lits )
+      : ntk_( ntk ),
+        fn_( fn ),
+        node_lits_( node_lits ? *node_lits : node_literals<Ntk, lit_t>( ntk ) )
+  {
+  }
+
+  std::vector<lit_t> run()
+  {
+    /* unit clause for constant-0 */
+    fn_( { lit_not( node_lits_[ntk_.get_constant( false )] ) } );
+
+    /* compute clauses for nodes */
+    ntk_.foreach_gate( [&]( auto const& n ) {
+      std::vector<lit_t> child_lits;
+      ntk_.foreach_fanin( n, [&]( auto const& f ) {
+        child_lits.push_back( lit_not_cond( node_lits_[f], ntk_.is_complemented( f ) ) );
+      } );
+      lit_t node_lit = node_lits_[n];
+
+      if constexpr ( has_is_and_v<Ntk> )
+      {
+        if ( ntk_.is_and( n ) )
+        {
+          detail::on_and( node_lit, child_lits[0], child_lits[1], fn_ );
+          return true;
+        }
+      }
+
+      if constexpr ( has_is_or_v<Ntk> )
+      {
+        if ( ntk_.is_or( n ) )
+        {
+          detail::on_or( node_lit, child_lits[0], child_lits[1], fn_ );
+          return true;
+        }
+      }
+
+      if constexpr ( has_is_xor_v<Ntk> )
+      {
+        if ( ntk_.is_xor( n ) )
+        {
+          detail::on_xor( node_lit, child_lits[0], child_lits[1], fn_ );
+          return true;
+        }
+      }
+
+      if constexpr ( has_is_maj_v<Ntk> )
+      {
+        if ( ntk_.is_maj( n ) )
+        {
+          detail::on_maj( node_lit, child_lits[0], child_lits[1], child_lits[2], fn_ );
+          return true;
+        }
+      }
+
+      if constexpr ( has_is_ite_v<Ntk> )
+      {
+        if ( ntk_.is_ite( n ) )
+        {
+          detail::on_ite( node_lit, child_lits[0], child_lits[1], child_lits[2], fn_ );
+          return true;
+        }
+      }
+
+      if constexpr ( has_is_xor3_v<Ntk> )
+      {
+        if ( ntk_.is_xor3( n ) )
+        {
+          detail::on_xor3( node_lit, child_lits[0], child_lits[1], child_lits[2], fn_ );
+          return true;
+        }
+      }
+
+      if constexpr ( has_is_nary_and_v<Ntk> )
+      {
+        if ( ntk_.is_nary_and( n ) )
+        {
+          fmt::print( "[e] nary-AND not yet supported in generate_cnf" );
+          std::abort();
+        }
+      }
+
+      if constexpr ( has_is_nary_or_v<Ntk> )
+      {
+        if ( ntk_.is_nary_or( n ) )
+        {
+          fmt::print( "[e] nary-OR not yet supported in generate_cnf" );
+          std::abort();
+        }
+      }
+      if constexpr ( has_is_nary_xor_v<Ntk> )
+      {
+        if ( ntk_.is_nary_xor( n ) )
+        {
+          fmt::print( "[e] nary-XOR not yet supported in generate_cnf" );
+          std::abort();
+        }
+      }
+
+      /* general case */
+      detail::on_function( node_lit, child_lits, ntk_.node_function( n ), fn_ );
+      return true;
+    } );
+
+    std::vector<lit_t> output_lits;
+    ntk_.foreach_po( [&]( auto const& f ) {
+      output_lits.push_back( lit_not_cond( node_lits_[f], ntk_.is_complemented( f ) ) );
+    } );
+
+    return output_lits;
+  }
+
+private:
+  Ntk const& ntk_;
+  clause_callback_t<lit_t> const& fn_;
+
+  node_map<lit_t, Ntk> node_lits_;
+};
+
+} // namespace detail
+
+/*! \brief Generates CNF for a logic network.
+ *
+ * This function generates a CNF for a logic network using the Tseytin encoding
+ * for regular gates and ISOP-based CNF generation for arbitrary node functions.
+ *
+ * Input to the function are the network `ntk` and a clause callback function
+ * `fn`.  For each clause that is generated, `fn` is called.  A clause is
+ * represented as a vector of literals `std::vector<uint32_t>`, following the
+ * customary literal convention, i.e., for a variable `v` its positive literal
+ * is `2 * v` and its negative literal is `2 * v + 1`.  The third optional
+ * parameter can be used to pass an alternative mapping of nodes to literals.
+ * If none is given, it uses the default literal map created with the
+ * `node_literals` function.
+ *
+ * The return value of the function is a vector with a literal for each primary
+ * output in the network, following the same order as the primary outputs have
+ * been created.
+ *
+ * \param ntk Logic network
+ * \param fn Clause creation function
+ * \param node_lits (optional) custom node literal map
+ */
+template<class Ntk>
+std::vector<uint32_t> generate_cnf( Ntk const& ntk, clause_callback_t<uint32_t> const& fn, std::optional<node_map<uint32_t, Ntk>> const& node_lits = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_node_function_v<Ntk>, "Ntk does not implement the node_function method" );
+  static_assert( has_fanin_size_v<Ntk>, "Ntk does not implement the fanin_size method" );
+
+  detail::generate_cnf_impl<Ntk, uint32_t> impl( ntk, fn, node_lits );
+  return impl.run();
+}
+
+template<class Ntk, typename lit_t = bill::lit_type>
+std::vector<lit_t> generate_cnf( Ntk const& ntk, clause_callback_t<lit_t> const& fn, std::optional<node_map<lit_t, Ntk>> const& node_lits = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_node_function_v<Ntk>, "Ntk does not implement the node_function method" );
+  static_assert( has_fanin_size_v<Ntk>, "Ntk does not implement the fanin_size method" );
+
+  detail::generate_cnf_impl<Ntk, lit_t> impl( ntk, fn, node_lits );
+  return impl.run();
+}
+
+} // namespace mockturtle
diff --git a/include/mockturtle/algorithms/collapse_mapped.hpp b/include/mockturtle/algorithms/collapse_mapped.hpp
new file mode 100644
index 0000000..7107bdd
--- /dev/null
+++ b/include/mockturtle/algorithms/collapse_mapped.hpp
@@ -0,0 +1,463 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file collapse_mapped.hpp
+  \brief Collapses mapped network into k-LUT network
+
+  \author Alessandro Tempia Calvino
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <iterator>
+#include <optional>
+#include <unordered_map>
+
+#include "../traits.hpp"
+#include "../utils/node_map.hpp"
+#include "../utils/window_utils.hpp"
+#include "../views/color_view.hpp"
+#include "../views/fanout_view.hpp"
+#include "../views/topo_view.hpp"
+#include "../views/window_view.hpp"
+#include "simulation.hpp"
+
+#include <kitty/dynamic_truth_table.hpp>
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+template<class NtkDest, class NtkSource>
+class collapse_mapped_network_impl
+{
+public:
+  collapse_mapped_network_impl( NtkSource const& ntk )
+      : ntk( ntk )
+  {
+  }
+
+  void run( NtkDest& dest )
+  {
+    node_map<signal<NtkDest>, NtkSource> node_to_signal( ntk );
+
+    /* special map for output drivers to perform some optimizations */
+    enum class driver_type
+    {
+      none,
+      pos,
+      neg,
+      mixed
+    };
+    node_map<driver_type, NtkSource> node_driver_type( ntk, driver_type::none );
+
+    /* opposites are filled for nodes with mixed driver types, since they have
+       two nodes in the network. */
+    std::unordered_map<node<NtkSource>, signal<NtkDest>> opposites;
+
+    /* initial driver types */
+    ntk.foreach_po( [&]( auto const& f ) {
+      switch ( node_driver_type[f] )
+      {
+      case driver_type::none:
+        node_driver_type[f] = ntk.is_complemented( f ) ? driver_type::neg : driver_type::pos;
+        break;
+      case driver_type::pos:
+        node_driver_type[f] = ntk.is_complemented( f ) ? driver_type::mixed : driver_type::pos;
+        break;
+      case driver_type::neg:
+        node_driver_type[f] = ntk.is_complemented( f ) ? driver_type::neg : driver_type::mixed;
+        break;
+      case driver_type::mixed:
+      default:
+        break;
+      }
+    } );
+
+    /* it could be that internal nodes also point to an output driver node */
+    ntk.foreach_node( [&]( auto const n ) {
+      if ( ntk.is_constant( n ) || ntk.is_pi( n ) || !ntk.is_cell_root( n ) )
+        return;
+
+      ntk.foreach_cell_fanin( n, [&]( auto fanin ) {
+        if ( node_driver_type[fanin] == driver_type::neg )
+        {
+          node_driver_type[fanin] = driver_type::mixed;
+        }
+      } );
+    } );
+
+    /* constants */
+    auto add_constant_to_map = [&]( bool value ) {
+      const auto n = ntk.get_node( ntk.get_constant( value ) );
+      switch ( node_driver_type[n] )
+      {
+      default:
+      case driver_type::none:
+      case driver_type::pos:
+        node_to_signal[n] = dest.get_constant( value );
+        break;
+
+      case driver_type::neg:
+        node_to_signal[n] = dest.get_constant( !value );
+        break;
+
+      case driver_type::mixed:
+        node_to_signal[n] = dest.get_constant( value );
+        opposites[n] = dest.get_constant( !value );
+        break;
+      }
+    };
+
+    add_constant_to_map( false );
+    if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+    {
+      add_constant_to_map( true );
+    }
+
+    /* primary inputs */
+    ntk.foreach_pi( [&]( auto n ) {
+      signal<NtkDest> dest_signal;
+      switch ( node_driver_type[n] )
+      {
+      default:
+      case driver_type::none:
+      case driver_type::pos:
+        dest_signal = dest.create_pi();
+        node_to_signal[n] = dest_signal;
+        break;
+
+      case driver_type::neg:
+        dest_signal = dest.create_pi();
+        node_to_signal[n] = dest.create_not( dest_signal );
+        break;
+
+      case driver_type::mixed:
+        dest_signal = dest.create_pi();
+        node_to_signal[n] = dest_signal;
+        opposites[n] = dest.create_not( node_to_signal[n] );
+        break;
+      }
+
+      if constexpr ( has_has_name_v<NtkSource> && has_get_name_v<NtkSource> && has_set_name_v<NtkDest> )
+      {
+        if ( ntk.has_name( ntk.make_signal( n ) ) )
+          dest.set_name( dest_signal, ntk.get_name( ntk.make_signal( n ) ) );
+      }
+    } );
+
+    /* ROs & RO names & register information */
+    if constexpr ( has_foreach_ro_v<NtkSource> && has_create_ro_v<NtkDest> )
+    {
+      std::vector<signal<NtkDest>> cis;
+      ntk.foreach_ro( [&]( auto const& n, auto i ) {
+        cis.push_back( dest.create_ro() );
+        if constexpr ( has_has_name_v<NtkSource> && has_get_name_v<NtkSource> && has_set_name_v<NtkDest> )
+        {
+          auto const s = ntk.make_signal( n );
+          if ( ntk.has_name( s ) )
+          {
+            dest.set_name( cis.back(), ntk.get_name( s ) );
+          }
+          if ( ntk.has_name( !s ) )
+          {
+            dest.set_name( !cis.back(), ntk.get_name( !s ) );
+          }
+        }
+        dest.set_register( i, ntk.register_at( i ) );
+      } );
+
+      auto it = std::begin( cis );
+      if constexpr ( has_foreach_ro_v<NtkSource> )
+      {
+        ntk.foreach_ro( [&]( auto n ) {
+          node_to_signal[n] = *it++;
+        } );
+      }
+    }
+    
+    fanout_view<NtkSource> fanout_ntk{ ntk };
+    fanout_ntk.clear_visited();
+    color_view<fanout_view<NtkSource>> color_ntk{ fanout_ntk };
+
+    /* nodes */
+    topo_view topo{ ntk };
+    topo.foreach_node( [&]( auto n ) {
+      if ( ntk.is_constant( n ) || ntk.is_ci( n ) || !ntk.is_cell_root( n ) )
+        return;
+
+      std::vector<signal<NtkDest>> children;
+      ntk.foreach_cell_fanin( n, [&]( auto fanin ) {
+        children.push_back( node_to_signal[fanin] );
+      } );
+
+      kitty::dynamic_truth_table tt;
+
+      if constexpr ( has_cell_function_v<NtkSource> )
+      {
+        tt = ntk.cell_function( n );
+      }
+      else
+      {
+        /* compute function constructing a window */
+        std::vector<node<NtkSource>> roots{ n };
+        std::vector<node<NtkSource>> leaves;
+
+        ntk.foreach_cell_fanin( n, [&]( auto fanin ) {
+          leaves.push_back( fanin );
+        } );
+
+        std::vector<node<NtkSource>> gates{ collect_nodes( color_ntk, leaves, roots ) };
+        window_view window_ntk{ color_ntk, leaves, roots, gates };
+
+        using Ntk = mockturtle::window_view<mockturtle::color_view<mockturtle::fanout_view<NtkSource>>>;
+        default_simulator<kitty::dynamic_truth_table> sim( window_ntk.num_pis() );
+        unordered_node_map<kitty::dynamic_truth_table, Ntk> node_to_value( window_ntk );
+
+        simulate_nodes( window_ntk, node_to_value, sim );
+
+        tt = node_to_value[n];
+      }
+
+      switch ( node_driver_type[n] )
+      {
+      default:
+      case driver_type::none:
+      case driver_type::pos:
+        node_to_signal[n] = dest.create_node( children, tt );
+        break;
+
+      case driver_type::neg:
+        node_to_signal[n] = dest.create_node( children, ~tt );
+        break;
+
+      case driver_type::mixed:
+        node_to_signal[n] = dest.create_node( children, tt );
+        opposites[n] = dest.create_node( children, ~tt );
+        break;
+      }
+    } );
+
+    /* outputs */
+    ntk.foreach_po( [&]( auto const& f, auto index ) {
+      (void)index;
+
+      if ( ntk.is_complemented( f ) && node_driver_type[f] == driver_type::mixed )
+      {
+        dest.create_po( opposites[ntk.get_node( f )] );
+      }
+      else
+      {
+        dest.create_po( node_to_signal[f] );
+      }
+
+      if constexpr ( has_has_output_name_v<NtkSource> && has_get_output_name_v<NtkSource> && has_set_output_name_v<NtkDest> )
+      {
+        if ( ntk.has_output_name( index ) )
+        {
+          dest.set_output_name( index, ntk.get_output_name( index ) );
+        }
+      }
+    } );
+
+    /* RIs */
+    if constexpr ( has_foreach_ri_v<NtkSource> && has_create_ri_v<NtkDest> )
+    {
+      ntk.foreach_ri( [&]( auto const& f ) {
+        dest.create_ri( ntk.is_complemented( f ) ? dest.create_not( node_to_signal[f] ) : node_to_signal[f] );
+      } );
+    }
+
+    /* CO names */
+    if constexpr ( has_has_output_name_v<NtkSource> && has_get_output_name_v<NtkSource> && has_set_output_name_v<NtkDest> )
+    {
+      ntk.foreach_co( [&]( auto co, auto index ) {
+        (void)co;
+        if ( ntk.has_output_name( index ) )
+        {
+          dest.set_output_name( index, ntk.get_output_name( index ) );
+        }
+      } );
+    }
+  }
+
+private:
+  NtkSource const& ntk;
+};
+
+} /* namespace detail */
+
+/*! \brief Collapse mapped network into k-LUT network.
+ *
+ * Collapses a mapped network into a k-LUT network.  In the mapped network each
+ * cell is represented in terms of a collection of nodes from the subject graph.
+ * This method creates a new network in which each cell is represented by a
+ * single node.
+ *
+ * This function performs some optimizations with respect to possible output
+ * complementations in the subject graph:
+ *
+ * - If an output driver is only used in positive form, nothing changes
+ * - If an output driver is only used in complemented form, the cell function
+ *   of the node is negated.
+ * - If an output driver is used in both forms, two nodes will be created for
+ *   the mapped node.
+ *
+ * **Required network functions for parameter ntk (type NtkSource):**
+ * - `has_mapping`
+ * - `get_constant`
+ * - `get_node`
+ * - `foreach_pi`
+ * - `foreach_po`
+ * - `foreach_node`
+ * - `foreach_cell_fanin`
+ * - `is_constant`
+ * - `is_pi`
+ * - `is_cell_root`
+ * - `cell_function`
+ * - `is_complemented`
+ *
+ * **Required network functions for return value (type NtkDest):**
+ * - `get_constant`
+ * - `create_pi`
+ * - `create_node`
+ * - `create_not`
+ */
+template<class NtkDest, class NtkSource>
+std::optional<NtkDest> collapse_mapped_network( NtkSource const& ntk )
+{
+  static_assert( is_network_type_v<NtkSource>, "NtkSource is not a network type" );
+  static_assert( is_network_type_v<NtkDest>, "NtkDest is not a network type" );
+
+  static_assert( has_has_mapping_v<NtkSource>, "NtkSource does not implement the has_mapping method" );
+  static_assert( has_num_gates_v<NtkSource>, "NtkSource does not implement the num_gates method" );
+  static_assert( has_get_constant_v<NtkSource>, "NtkSource does not implement the get_constant method" );
+  static_assert( has_get_node_v<NtkSource>, "NtkSource does not implement the get_node method" );
+  static_assert( has_foreach_pi_v<NtkSource>, "NtkSource does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<NtkSource>, "NtkSource does not implement the foreach_po method" );
+  static_assert( has_foreach_node_v<NtkSource>, "NtkSource does not implement the foreach_node method" );
+  static_assert( has_foreach_cell_fanin_v<NtkSource>, "NtkSource does not implement the foreach_cell_fanin method" );
+  static_assert( has_is_constant_v<NtkSource>, "NtkSource does not implement the is_constant method" );
+  static_assert( has_is_pi_v<NtkSource>, "NtkSource does not implement the is_pi method" );
+  static_assert( has_is_cell_root_v<NtkSource>, "NtkSource does not implement the is_cell_root method" );
+  static_assert( has_is_complemented_v<NtkSource>, "NtkSource does not implement the is_complemented method" );
+
+  static_assert( has_get_constant_v<NtkDest>, "NtkDest does not implement the get_constant method" );
+  static_assert( has_create_pi_v<NtkDest>, "NtkDest does not implement the create_pi method" );
+  static_assert( has_create_node_v<NtkDest>, "NtkDest does not implement the create_node method" );
+  static_assert( has_create_not_v<NtkDest>, "NtkDest does not implement the create_not method" );
+
+  if ( !ntk.has_mapping() && ntk.num_gates() > 0 )
+  {
+    return std::nullopt;
+  }
+  else
+  {
+    detail::collapse_mapped_network_impl<NtkDest, NtkSource> p( ntk );
+    NtkDest dest;
+    p.run( dest );
+    return dest;
+  }
+}
+
+/*! \brief Collapse mapped network into k-LUT network.
+ *
+ * Collapses a mapped network into a k-LUT network.  In the mapped network each
+ * cell is represented in terms of a collection of nodes from the subject graph.
+ * This method creates a new network in which each cell is represented by a
+ * single node.
+ *
+ * This function performs some optimizations with respect to possible output
+ * complementations in the subject graph:
+ *
+ * - If an output driver is only used in positive form, nothing changes
+ * - If an output driver is only used in complemented form, the cell function
+ *   of the node is negated.
+ * - If an output driver is used in both forms, two nodes will be created for
+ *   the mapped node.
+ *
+ * **Required network functions for parameter ntk (type NtkSource):**
+ * - `has_mapping`
+ * - `get_constant`
+ * - `get_node`
+ * - `foreach_pi`
+ * - `foreach_po`
+ * - `foreach_node`
+ * - `foreach_cell_fanin`
+ * - `is_constant`
+ * - `is_pi`
+ * - `is_cell_root`
+ * - `cell_function`
+ * - `is_complemented`
+ *
+ * **Required network functions for return value (type NtkDest):**
+ * - `get_constant`
+ * - `create_pi`
+ * - `create_node`
+ * - `create_not`
+ */
+template<class NtkDest, class NtkSource>
+bool collapse_mapped_network( NtkDest& dest, NtkSource const& ntk )
+{
+  static_assert( is_network_type_v<NtkSource>, "NtkSource is not a network type" );
+  static_assert( is_network_type_v<NtkDest>, "NtkDest is not a network type" );
+
+  static_assert( has_has_mapping_v<NtkSource>, "NtkSource does not implement the has_mapping method" );
+  static_assert( has_num_gates_v<NtkSource>, "NtkSource does not implement the num_gates method" );
+  static_assert( has_get_constant_v<NtkSource>, "NtkSource does not implement the get_constant method" );
+  static_assert( has_get_node_v<NtkSource>, "NtkSource does not implement the get_node method" );
+  static_assert( has_foreach_pi_v<NtkSource>, "NtkSource does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<NtkSource>, "NtkSource does not implement the foreach_po method" );
+  static_assert( has_foreach_node_v<NtkSource>, "NtkSource does not implement the foreach_node method" );
+  static_assert( has_foreach_cell_fanin_v<NtkSource>, "NtkSource does not implement the foreach_cell_fanin method" );
+  static_assert( has_is_constant_v<NtkSource>, "NtkSource does not implement the is_constant method" );
+  static_assert( has_is_pi_v<NtkSource>, "NtkSource does not implement the is_pi method" );
+  static_assert( has_is_cell_root_v<NtkSource>, "NtkSource does not implement the is_cell_root method" );
+  static_assert( has_is_complemented_v<NtkSource>, "NtkSource does not implement the is_complemented method" );
+
+  static_assert( has_get_constant_v<NtkDest>, "NtkDest does not implement the get_constant method" );
+  static_assert( has_create_pi_v<NtkDest>, "NtkDest does not implement the create_pi method" );
+  static_assert( has_create_node_v<NtkDest>, "NtkDest does not implement the create_node method" );
+  static_assert( has_create_not_v<NtkDest>, "NtkDest does not implement the create_not method" );
+
+  if ( !ntk.has_mapping() && ntk.num_gates() > 0 )
+  {
+    return false;
+  }
+  else
+  {
+    detail::collapse_mapped_network_impl<NtkDest, NtkSource> p( ntk );
+    p.run( dest );
+    return true;
+  }
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/cover_to_graph.hpp b/include/mockturtle/algorithms/cover_to_graph.hpp
new file mode 100644
index 0000000..63864cd
--- /dev/null
+++ b/include/mockturtle/algorithms/cover_to_graph.hpp
@@ -0,0 +1,306 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cover_to_graph.hpp
+  \brief transforms a cover data structure into another network type
+
+  \author Andrea Costamagna
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../networks/cover.hpp"
+
+#include <iostream>
+#include <iterator>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+template<class Ntk>
+struct signals_connector
+{
+  signals_connector()
+  {
+    signals.reserve( 10000u );
+  }
+  void insert( signal<Ntk> signal_ntk, uint64_t node_index )
+  {
+    signals[node_index] = signal_ntk;
+  }
+
+  std::unordered_map<uint64_t, signal<Ntk>> signals;
+};
+
+/*! \brief cover_to_graph_converter
+ * This data type is equipped with the main operations involved in the cover to graph conversion.
+ * Given a cover network its features are mapped into the corresponding ones of a graph using the
+ * signals_connector for storing the signal of the new network associated to the node index in the cover one.
+ * The mapping is performed by the convert method, which must be called explicitly to perform the mapping.
+ */
+template<class Ntk>
+class cover_to_graph_converter
+{
+
+  using type_cover_signals = std::vector<uint64_t>;
+
+public:
+  cover_to_graph_converter( Ntk& ntk, const cover_network& cover_ntk )
+      : _ntk( ntk ),
+        _cover_ntk( cover_ntk )
+  {
+  }
+
+#pragma region recursive functions
+  /*! \brief recursive_or
+   * If only one signal is presented the function returns the signal itself.
+   * If two signals are presented the function returns their disjunction.
+   * In all other cases recursively split the input signals into two subsets of size differing by at most one.
+   * These two will give rise to a unique output, which is the OR of two signals coming from the two subgraphs.
+   * The problem of finding the network of each subgraph presents the same structure as the original problem.
+   * Therefore, recursion can be performed.
+   */
+  signal<Ntk> recursive_or( const std::vector<signal<Ntk>>& signals )
+  {
+    if ( signals.size() == 0u )
+    {
+      std::cerr << "signals size is zero in recursive or\n";
+      return _ntk.get_constant( 0 );
+    }
+    else if ( signals.size() == 1u )
+    {
+      return signals[0];
+    }
+    else if ( signals.size() == 2u )
+    {
+      signal<Ntk> signal_out = _ntk.create_or( signals[0], signals[1] );
+      return signal_out;
+    }
+    else
+    {
+      std::size_t const half_size = signals.size() / 2;
+      std::vector<signal<Ntk>> vector_l( signals.begin(), signals.begin() + half_size );
+      std::vector<signal<Ntk>> vector_r( signals.begin() + half_size, signals.end() );
+
+      return _ntk.create_or( recursive_or( vector_l ), recursive_or( vector_r ) );
+    }
+  }
+
+  /*! \brief recursive_and
+   * If only one signal is presented the function returns the signal itself.
+   * If two signals are presented the function returns their conjunction.
+   * In all other cases recursively split the input signals into two subsets of size differing by at most one.
+   * These two will give rise to a unique output, which is the AND of two signals coming from the two subgraphs.
+   * The problem of finding the network of each subgraph presents the same structure as the original problem.
+   * Therefore, recursion can be performed.
+   */
+  signal<Ntk> recursive_and( std::vector<signal<Ntk>> const& signals )
+  {
+    if ( signals.size() == 0u )
+    {
+      std::cerr << "signals size is zero in recursive and\n";
+      return _ntk.get_constant( 0 );
+    }
+    else if ( signals.size() == 1u )
+    {
+      return signals[0];
+    }
+    else if ( signals.size() == 2u )
+    {
+      signal<Ntk> signal_out = _ntk.create_and( signals[0], signals[1] );
+      return signal_out;
+    }
+    else
+    {
+      std::size_t const half_size = signals.size() / 2;
+      std::vector<signal<Ntk>> vector_l( signals.begin(), signals.begin() + half_size );
+      std::vector<signal<Ntk>> vector_r( signals.begin() + half_size, signals.end() );
+      return _ntk.create_and( recursive_and( vector_l ), recursive_and( vector_r ) );
+    }
+  }
+#pragma endregion
+
+  /*! \brief convert_cube_to_graph
+   * Given a node, a cube stored into it and the boolean type associated to the SOP/POS, all children are scanned.
+   * Unless the cube is independent of the value of the children ( don't care ), the signal is stored in a vector.
+   * Finally, depending on the bit value of the cube, the signal influencing the cover or their negation are used
+   * to create the subgraph. This create the products/sums in the SOP/POS.
+   */
+#pragma region converter functions
+  signal<Ntk> convert_cube_to_graph( const mockturtle::cover_storage_node& Nde, const kitty::cube& cb, const bool& is_sop )
+  {
+    std::vector<signal<Ntk>> signals;
+
+    for ( auto j = 0u; j < Nde.children.size(); j++ )
+    {
+      if ( cb.get_mask( j ) == 1 )
+      {
+        if ( cb.get_bit( j ) == 1 )
+        {
+          signals.emplace_back( ( is_sop ) ? _connector.signals[Nde.children[j].index] : !_connector.signals[Nde.children[j].index] );
+        }
+        else
+        {
+          signals.emplace_back( ( is_sop ) ? !_connector.signals[Nde.children[j].index] : _connector.signals[Nde.children[j].index] );
+        }
+      }
+    }
+
+    return is_sop ? recursive_and( signals ) : recursive_or( signals );
+  }
+
+  /*! \brief convert_node_to_graph
+   * This helper function receives as input a node, storing the cover information.
+   * This information corresponds to a vector of cubes and to a boolean determining whether
+   * the cubes represent the ON set or the OFF set.
+   * Each cube is mapped into a subgraph and the output signals are collected in a vector, corresponding to the
+   * products/sums of the SOP/POS.
+   * Depending on the boolean, the SOP/POS is finally performed using the recursive OR/AND.
+   */
+  signal<Ntk> convert_node_to_graph( const mockturtle::cover_storage_node& Nde )
+  {
+    auto& cbs = _cover_ntk._storage->data.covers[Nde.data[1].h1].first;
+
+    std::vector<signal<Ntk>> signals_internal;
+    bool is_sop = _cover_ntk._storage->data.covers[Nde.data[1].h1].second;
+
+    for ( auto const& cb : cbs )
+    {
+      signals_internal.emplace_back( convert_cube_to_graph( Nde, cb, is_sop ) );
+    }
+
+    return ( is_sop ? recursive_or( signals_internal ) : recursive_and( signals_internal ) );
+  }
+
+  Ntk get_network()
+  {
+    return _ntk;
+  }
+
+  /*! \brief convert
+   * This method combines the helper functions and performs the mapping of a cover network into the desired graph.
+   */
+  void run()
+  {
+    /* convert the pi */
+    for ( auto const& inpt : _cover_ntk._storage->inputs )
+    {
+      _connector.insert( _ntk.create_pi(), inpt );
+    }
+
+    /* convert the nodes */
+    for ( auto const& nde : _cover_ntk._storage->nodes )
+    {
+      uint64_t index = _cover_ntk._storage->hash[nde];
+      bool condition1 = ( std::find( _cover_ntk._storage->inputs.begin(), _cover_ntk._storage->inputs.end(), index ) != _cover_ntk._storage->inputs.end() );
+      bool condition2 = nde.data[1].h1 == 0 || nde.data[1].h1 == 1;
+
+      /* convert only the nodes that are neither inputs nor constants */
+      if ( !condition1 && !condition2 )
+      {
+        _connector.insert( convert_node_to_graph( nde ), _cover_ntk._storage->hash[nde] );
+      } /* convert separately the constant 0 */
+      else if ( nde.data[1].h1 == 0 )
+      {
+        _connector.insert( _ntk.get_constant( false ), _cover_ntk._storage->hash[nde] );
+      } /* convert separately the constant 1 */
+      else if ( nde.data[1].h1 == 1 )
+      {
+        _connector.insert( _ntk.get_constant( true ), _cover_ntk._storage->hash[nde] );
+      }
+    }
+
+    /* convert the outputs */
+    for ( const auto& outpt : _cover_ntk._storage->outputs )
+    {
+      _ntk.create_po( _connector.signals[outpt.index] );
+    }
+  }
+
+private:
+  Ntk& _ntk;
+  cover_network const& _cover_ntk;
+  signals_connector<Ntk> _connector;
+};
+
+} /* namespace detail */
+
+/*! \brief Inline convert a `cover_network` into another network type.
+ *
+ * **Required network functions:**
+ * - `create_and`
+ * - `create_or`
+ * - `create_buf`
+ * - `create_not`
+ *
+ * \param cover_ntk Input network of type `cover_network`.
+ * \param ntk Output network of type `Ntk`.
+ */
+template<class Ntk>
+void convert_cover_to_graph( Ntk& ntk, const cover_network& cover_ntk )
+{
+  static_assert( has_create_and_v<Ntk>, "NtkDest does not implement the create_not method" );
+  static_assert( has_create_or_v<Ntk>, "NtkDest does not implement the create_po method" );
+  static_assert( has_create_buf_v<Ntk>, "NtkDest does not implement the create_not method" );
+  static_assert( has_create_not_v<Ntk>, "NtkDest does not implement the create_not method" );
+
+  detail::cover_to_graph_converter<Ntk> converter( ntk, cover_ntk );
+  converter.run();
+}
+
+/*! \brief Out-of-place convert a `cover_network` into another network type.
+ *
+ * **Required network functions:**
+ * - `create_and`
+ * - `create_or`
+ * - `create_buf`
+ * - `create_not`
+ *
+ * \param cover_ntk Input network of type `cover_network`.
+ * \return ntk Output network of type `Ntk`.
+ */
+template<class Ntk>
+Ntk convert_cover_to_graph( const cover_network& cover_ntk )
+{
+  static_assert( has_create_and_v<Ntk>, "NtkDest does not implement the create_not method" );
+  static_assert( has_create_or_v<Ntk>, "NtkDest does not implement the create_po method" );
+  static_assert( has_create_buf_v<Ntk>, "NtkDest does not implement the create_not method" );
+  static_assert( has_create_not_v<Ntk>, "NtkDest does not implement the create_not method" );
+
+  Ntk ntk;
+  detail::cover_to_graph_converter<Ntk> converter( ntk, cover_ntk );
+  converter.run();
+  return converter.get_network();
+}
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/cut_enumeration.hpp b/include/mockturtle/algorithms/cut_enumeration.hpp
new file mode 100644
index 0000000..89a4dcf
--- /dev/null
+++ b/include/mockturtle/algorithms/cut_enumeration.hpp
@@ -0,0 +1,1840 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cut_enumeration.hpp
+  \brief Cut enumeration
+
+  \author Alessandro Tempia Calvino
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Sahand Kashani-Akhavan
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <array>
+#include <cassert>
+#include <cstdint>
+#include <iostream>
+#include <optional>
+#include <vector>
+
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+
+#include <fmt/format.h>
+
+#include "../traits.hpp"
+#include "../utils/cuts.hpp"
+#include "../utils/mixed_radix.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../utils/truth_table_cache.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for cut_enumeration.
+ *
+ * The data structure `cut_enumeration_params` holds configurable parameters
+ * with default arguments for `cut_enumeration`.
+ */
+struct cut_enumeration_params
+{
+  /*! \brief Maximum number of leaves for a cut. */
+  uint32_t cut_size{ 4u };
+
+  /*! \brief Maximum number of cuts for a node. */
+  uint32_t cut_limit{ 25u };
+
+  /*! \brief Maximum number of fan-ins for a node. */
+  uint32_t fanin_limit{ 10u };
+
+  /*! \brief Prune cuts by removing don't cares. */
+  bool minimize_truth_table{ false };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+
+  /*! \brief Be very verbose. */
+  bool very_verbose{ false };
+};
+
+struct cut_enumeration_stats
+{
+  /*! \brief Total time. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Time for truth table computation. */
+  stopwatch<>::duration time_truth_table{ 0 };
+
+  /*! \brief Prints report. */
+  void report() const
+  {
+    std::cout << fmt::format( "[i] total time       = {:>5.2f} secs\n", to_seconds( time_total ) );
+    std::cout << fmt::format( "[i] truth table time = {:>5.2f} secs\n", to_seconds( time_truth_table ) );
+  }
+};
+
+static constexpr uint32_t max_cut_size = 16;
+
+template<bool ComputeTruth, typename T = empty_cut_data>
+struct cut_data;
+
+template<typename T>
+struct cut_data<true, T>
+{
+  uint32_t func_id;
+  T data;
+};
+
+template<typename T>
+struct cut_data<false, T>
+{
+  T data;
+};
+
+template<bool ComputeTruth, typename T>
+using cut_type = cut<max_cut_size, cut_data<ComputeTruth, T>>;
+
+/* forward declarations */
+/*! \cond PRIVATE */
+template<typename Ntk, bool ComputeTruth, typename CutData>
+struct network_cuts;
+
+template<typename Ntk, bool ComputeTruth = false, typename CutData = empty_cut_data>
+network_cuts<Ntk, ComputeTruth, CutData> cut_enumeration( Ntk const& ntk, cut_enumeration_params const& ps = {}, cut_enumeration_stats* pst = nullptr );
+
+/* function to update a cut */
+template<typename CutData>
+struct cut_enumeration_update_cut
+{
+  template<typename Cut, typename NetworkCuts, typename Ntk>
+  static void apply( Cut& cut, NetworkCuts const& cuts, Ntk const& ntk, node<Ntk> const& n )
+  {
+    (void)cut;
+    (void)cuts;
+    (void)ntk;
+    (void)n;
+  }
+};
+
+namespace detail
+{
+template<typename Ntk, bool ComputeTruth, typename CutData>
+class cut_enumeration_impl;
+}
+/*! \endcond */
+
+/*! \brief Cut database for a network.
+ *
+ * The function `cut_enumeration` returns an instance of type `network_cuts`
+ * which contains a cut database and can be queried to return all cuts of a
+ * node, or the function of a cut (if it was computed).
+ *
+ * An instance of type `network_cuts` can only be constructed from the
+ * `cut_enumeration` algorithm.
+ */
+template<typename Ntk, bool ComputeTruth, typename CutData>
+struct network_cuts
+{
+public:
+  static constexpr uint32_t max_cut_num = 26;
+  using cut_t = cut_type<ComputeTruth, CutData>;
+  using cut_set_t = cut_set<cut_t, max_cut_num>; // std::vector<cut_t> // cut_type = cut<max_cut_size, cut_data<ComputeTruth, T>>;
+  static constexpr bool compute_truth = ComputeTruth;
+
+private:
+  explicit network_cuts( uint32_t size ) : _cuts( size )
+  {
+    kitty::dynamic_truth_table zero( 0u ), proj( 1u );
+    kitty::create_nth_var( proj, 0u );
+
+    _truth_tables.insert( zero );
+    _truth_tables.insert( proj );
+  }
+
+public:
+  /*! \brief Returns the cut set of a node */
+  cut_set_t& cuts( uint32_t node_index ) { return _cuts[node_index]; }
+
+  /*! \brief Returns the cut set of a node */
+  cut_set_t const& cuts( uint32_t node_index ) const { return _cuts[node_index]; }
+
+  /*! \brief Returns the truth table of a cut */
+  template<bool enabled = ComputeTruth, typename = std::enable_if_t<std::is_same_v<Ntk, Ntk> && enabled>>
+  auto truth_table( cut_t const& cut ) const
+  {
+    return _truth_tables[cut->func_id];
+  }
+
+  /*! \brief Returns the total number of tuples that were tried to be merged */
+  auto total_tuples() const
+  {
+    return _total_tuples;
+  }
+
+  /*! \brief Returns the total number of cuts in the database. */
+  auto total_cuts() const
+  {
+    return _total_cuts;
+  }
+
+  /*! \brief Returns the number of nodes for which cuts are computed */
+  auto nodes_size() const
+  {
+    return _cuts.size();
+  }
+
+  /* compute positions of leave indices in cut `sub` (subset) with respect to
+   * leaves in cut `sup` (super set).
+   *
+   * Example:
+   *   compute_truth_table_support( {1, 3, 6}, {0, 1, 2, 3, 6, 7} ) = {1, 3, 4}
+   */
+  std::vector<uint8_t> compute_truth_table_support( cut_t const& sub, cut_t const& sup ) const
+  {
+    std::vector<uint8_t> support;
+    support.reserve( sub.size() );
+
+    auto itp = sup.begin();
+    for ( auto i : sub )
+    {
+      itp = std::find( itp, sup.end(), i );
+      support.push_back( static_cast<uint8_t>( std::distance( sup.begin(), itp ) ) );
+    }
+
+    return support;
+  }
+
+  /*! \brief Inserts a truth table into the truth table cache.
+   *
+   * This message can be used when manually adding or modifying cuts from the
+   * cut sets.
+   *
+   * \param tt Truth table to add
+   * \return Literal id from the truth table store
+   */
+  uint32_t insert_truth_table( kitty::dynamic_truth_table const& tt )
+  {
+    return _truth_tables.insert( tt );
+  }
+
+private:
+  template<typename _Ntk, bool _ComputeTruth, typename _CutData>
+  friend class detail::cut_enumeration_impl;
+
+  template<typename _Ntk, bool _ComputeTruth, typename _CutData>
+  friend network_cuts<_Ntk, _ComputeTruth, _CutData> cut_enumeration( _Ntk const& ntk, cut_enumeration_params const& ps, cut_enumeration_stats* pst );
+
+private:
+  void add_zero_cut( uint32_t index )
+  {
+    auto& cut = _cuts[index].add_cut( &index, &index ); /* fake iterator for emptyness */
+
+    if constexpr ( ComputeTruth )
+    {
+      cut->func_id = 0;
+    }
+  }
+
+  void add_unit_cut( uint32_t index )
+  {
+    auto& cut = _cuts[index].add_cut( &index, &index + 1 );
+
+    if constexpr ( ComputeTruth )
+    {
+      cut->func_id = 2;
+    }
+  }
+
+private:
+  /* compressed representation of cuts */
+  std::vector<cut_set_t> _cuts;
+
+  /* cut truth tables */
+  truth_table_cache<kitty::dynamic_truth_table> _truth_tables;
+
+  /* statistics */
+  uint32_t _total_tuples{};
+  std::size_t _total_cuts{};
+};
+
+/*! \cond PRIVATE */
+namespace detail
+{
+
+template<typename Ntk, bool ComputeTruth, typename CutData>
+class cut_enumeration_impl
+{
+public:
+  using cut_t = typename network_cuts<Ntk, ComputeTruth, CutData>::cut_t;
+  using cut_set_t = typename network_cuts<Ntk, ComputeTruth, CutData>::cut_set_t;
+
+  explicit cut_enumeration_impl( Ntk const& ntk, cut_enumeration_params const& ps, cut_enumeration_stats& st, network_cuts<Ntk, ComputeTruth, CutData>& cuts )
+      : ntk( ntk ),
+        ps( ps ),
+        st( st ),
+        cuts( cuts )
+  {
+    assert( ps.cut_limit < cuts.max_cut_num && "cut_limit exceeds the compile-time limit for the maximum number of cuts" );
+  }
+
+public:
+  void run()
+  {
+    stopwatch t( st.time_total );
+
+    ntk.foreach_node( [this]( auto node ) {
+      const auto index = ntk.node_to_index( node );
+
+      if ( ps.very_verbose )
+      {
+        std::cout << fmt::format( "[i] compute cut for node at index {}\n", index );
+      }
+
+      if ( ntk.is_constant( node ) )
+      {
+        cuts.add_zero_cut( index );
+      }
+      else if ( ntk.is_ci( node ) )
+      {
+        cuts.add_unit_cut( index );
+      }
+      else
+      {
+        if constexpr ( Ntk::min_fanin_size == 2 && Ntk::max_fanin_size == 2 )
+        {
+          merge_cuts2( index );
+        }
+        else
+        {
+          merge_cuts( index );
+        }
+      }
+    } );
+  }
+
+private:
+  uint32_t compute_truth_table( uint32_t index, std::vector<cut_t const*> const& vcuts, cut_t& res )
+  {
+    stopwatch t( st.time_truth_table );
+
+    std::vector<kitty::dynamic_truth_table> tt( vcuts.size() );
+    auto i = 0;
+    for ( auto const& cut : vcuts )
+    {
+      tt[i] = kitty::extend_to( cuts._truth_tables[( *cut )->func_id], res.size() );
+      const auto supp = cuts.compute_truth_table_support( *cut, res );
+      kitty::expand_inplace( tt[i], supp );
+      ++i;
+    }
+
+    auto tt_res = ntk.compute( ntk.index_to_node( index ), tt.begin(), tt.end() );
+
+    if ( ps.minimize_truth_table )
+    {
+      const auto support = kitty::min_base_inplace( tt_res );
+      if ( support.size() != res.size() )
+      {
+        auto tt_res_shrink = shrink_to( tt_res, static_cast<unsigned>( support.size() ) );
+        std::vector<uint32_t> leaves_before( res.begin(), res.end() );
+        std::vector<uint32_t> leaves_after( support.size() );
+
+        auto it_support = support.begin();
+        auto it_leaves = leaves_after.begin();
+        while ( it_support != support.end() )
+        {
+          *it_leaves++ = leaves_before[*it_support++];
+        }
+        res.set_leaves( leaves_after.begin(), leaves_after.end() );
+        return cuts._truth_tables.insert( tt_res_shrink );
+      }
+    }
+
+    return cuts._truth_tables.insert( tt_res );
+  }
+
+  void merge_cuts2( uint32_t index )
+  {
+    const auto fanin = 2;
+
+    uint32_t pairs{ 1 };
+    ntk.foreach_fanin( ntk.index_to_node( index ), [this, &pairs]( auto child, auto i ) {
+      lcuts[i] = &cuts.cuts( ntk.node_to_index( ntk.get_node( child ) ) );
+      pairs *= static_cast<uint32_t>( lcuts[i]->size() );
+    } );
+    lcuts[2] = &cuts.cuts( index );
+    auto& rcuts = *lcuts[fanin];
+    rcuts.clear();
+
+    cut_t new_cut;
+
+    std::vector<cut_t const*> vcuts( fanin );
+
+    cuts._total_tuples += pairs;
+    for ( auto const& c1 : *lcuts[0] )
+    {
+      for ( auto const& c2 : *lcuts[1] )
+      {
+        if ( !c1->merge( *c2, new_cut, ps.cut_size ) )
+        {
+          continue;
+        }
+
+        if ( rcuts.is_dominated( new_cut ) )
+        {
+          continue;
+        }
+
+        if constexpr ( ComputeTruth )
+        {
+          vcuts[0] = c1;
+          vcuts[1] = c2;
+          new_cut->func_id = compute_truth_table( index, vcuts, new_cut );
+        }
+
+        cut_enumeration_update_cut<CutData>::apply( new_cut, cuts, ntk, index );
+
+        rcuts.insert( new_cut );
+      }
+    }
+
+    /* limit the maximum number of cuts */
+    rcuts.limit( ps.cut_limit - 1 );
+
+    cuts._total_cuts += rcuts.size();
+
+    if ( rcuts.size() > 1 || ( *rcuts.begin() )->size() > 1 )
+    {
+      cuts.add_unit_cut( index );
+    }
+  }
+
+  void merge_cuts( uint32_t index )
+  {
+    uint32_t pairs{ 1 };
+    std::vector<uint32_t> cut_sizes;
+    ntk.foreach_fanin( ntk.index_to_node( index ), [this, &pairs, &cut_sizes]( auto child, auto i ) {
+      lcuts[i] = &cuts.cuts( ntk.node_to_index( ntk.get_node( child ) ) );
+      cut_sizes.push_back( static_cast<uint32_t>( lcuts[i]->size() ) );
+      pairs *= cut_sizes.back();
+    } );
+
+    const auto fanin = cut_sizes.size();
+    lcuts[fanin] = &cuts.cuts( index );
+
+    auto& rcuts = *lcuts[fanin];
+
+    if ( fanin > 1 && fanin <= ps.fanin_limit )
+    {
+      rcuts.clear();
+
+      cut_t new_cut, tmp_cut;
+
+      std::vector<cut_t const*> vcuts( fanin );
+
+      cuts._total_tuples += pairs;
+      foreach_mixed_radix_tuple( cut_sizes.begin(), cut_sizes.end(), [&]( auto begin, auto end ) {
+        auto it = vcuts.begin();
+        auto i = 0u;
+        while ( begin != end )
+        {
+          *it++ = &( ( *lcuts[i++] )[*begin++] );
+        }
+
+        if ( !vcuts[0]->merge( *vcuts[1], new_cut, ps.cut_size ) )
+        {
+          return true; /* continue */
+        }
+
+        for ( i = 2; i < fanin; ++i )
+        {
+          tmp_cut = new_cut;
+          if ( !vcuts[i]->merge( tmp_cut, new_cut, ps.cut_size ) )
+          {
+            return true; /* continue */
+          }
+        }
+
+        if ( rcuts.is_dominated( new_cut ) )
+        {
+          return true; /* continue */
+        }
+
+        if constexpr ( ComputeTruth )
+        {
+          new_cut->func_id = compute_truth_table( index, vcuts, new_cut );
+        }
+
+        cut_enumeration_update_cut<CutData>::apply( new_cut, cuts, ntk, ntk.index_to_node( index ) );
+
+        rcuts.insert( new_cut );
+
+        return true;
+      } );
+
+      /* limit the maximum number of cuts */
+      rcuts.limit( ps.cut_limit - 1 );
+    }
+    else if ( fanin == 1 )
+    {
+      rcuts.clear();
+
+      for ( auto const& cut : *lcuts[0] )
+      {
+        cut_t new_cut = *cut;
+
+        if constexpr ( ComputeTruth )
+        {
+          new_cut->func_id = compute_truth_table( index, { cut }, new_cut );
+        }
+
+        cut_enumeration_update_cut<CutData>::apply( new_cut, cuts, ntk, ntk.index_to_node( index ) );
+
+        rcuts.insert( new_cut );
+      }
+
+      /* limit the maximum number of cuts */
+      rcuts.limit( ps.cut_limit - 1 );
+    }
+
+    cuts._total_cuts += static_cast<uint32_t>( rcuts.size() );
+
+    cuts.add_unit_cut( index );
+  }
+
+private:
+  Ntk const& ntk;
+  cut_enumeration_params const& ps;
+  cut_enumeration_stats& st;
+  network_cuts<Ntk, ComputeTruth, CutData>& cuts;
+
+  std::array<cut_set_t*, Ntk::max_fanin_size + 1> lcuts;
+};
+} /* namespace detail */
+/*! \endcond */
+
+/*! \brief Cut enumeration.
+ *
+ * This function implements the cut enumeration algorithm.  The algorithm
+ * traverses all nodes in topological order and computes a node's cuts based
+ * on its fanins' cuts.  Dominated cuts are filtered and are not added to the
+ * cut set.  For each node a unit cut is added to the end of each cut set.
+ *
+ * The template parameter `ComputeTruth` controls whether truth tables should
+ * be computed for each cut.  Computing truth tables slows down the execution
+ * time of the algorithm.
+ *
+ * The number of computed cuts is controlled via the `cut_limit` parameter.
+ * To decide which cuts are collected in each node's cut set, cuts are sorted.
+ * Unit cuts do not participate in the sorting and are always added to the end
+ * of each cut set.
+ *
+ * The algorithm can be configured by specifying the template argument `CutData`
+ * which holds the application specific data assigned to each cut.  Examples
+ * on how to specify custom cost functions for sorting cuts based on the
+ * application specific cut data can be found in the files contained in the
+ * directory `include/mockturtle/algorithms/cut_enumeration`.
+ *
+ * **Required network functions:**
+ * - `is_constant`
+ * - `is_ci`
+ * - `size`
+ * - `get_node`
+ * - `node_to_index`
+ * - `foreach_node`
+ * - `foreach_fanin`
+ * - `compute` for `kitty::dynamic_truth_table` (if `ComputeTruth` is true)
+ *
+   \verbatim embed:rst
+
+   .. warning::
+
+      This algorithm expects the nodes in the network to be in topological
+      order.  If the network does not guarantee a topological order of nodes
+      one can wrap the network parameter in a ``topo_view`` view.
+
+   .. note::
+
+      The implementation of this algorithm was heavily inspired buy cut
+      enumeration implementations in ABC.
+   \endverbatim
+ */
+template<typename Ntk, bool ComputeTruth, typename CutData>
+network_cuts<Ntk, ComputeTruth, CutData> cut_enumeration( Ntk const& ntk, cut_enumeration_params const& ps, cut_enumeration_stats* pst )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_ci_v<Ntk>, "Ntk does not implement the is_ci method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( !ComputeTruth || has_compute_v<Ntk, kitty::dynamic_truth_table>, "Ntk does not implement the compute method for kitty::dynamic_truth_table" );
+
+  cut_enumeration_stats st;
+  network_cuts<Ntk, ComputeTruth, CutData> res( ntk.size() );
+  detail::cut_enumeration_impl<Ntk, ComputeTruth, CutData> p( ntk, ps, st, res );
+  p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+  if ( pst )
+  {
+    *pst = st;
+  }
+
+  return res;
+}
+
+/* forward declarations */
+/*! \cond PRIVATE */
+template<typename Ntk, uint32_t NumVars, bool ComputeTruth, typename CutData>
+struct fast_network_cuts;
+
+template<typename Ntk, uint32_t NumVars, bool ComputeTruth = false, typename CutData = empty_cut_data>
+fast_network_cuts<Ntk, NumVars, ComputeTruth, CutData> fast_cut_enumeration( Ntk const& ntk, cut_enumeration_params const& ps = {}, cut_enumeration_stats* pst = nullptr );
+
+namespace detail
+{
+template<typename Ntk, uint32_t NumVars, bool ComputeTruth, typename CutData>
+class fast_cut_enumeration_impl;
+}
+/*! \endcond */
+
+/*! \brief Cut database for a network.
+ *
+ * The function `cut_enumeration` returns an instance of type `fast_network_cuts`
+ * which contains a cut database and can be queried to return all cuts of a
+ * node, or the function of a cut (if it was computed).
+ *
+ * Comparing to `network_cuts`, it uses static truth tables instead of
+ * dynamic truth tables to speed-up the truth table computation.
+ *
+ * An instance of type `fast_network_cuts` can only be constructed from the
+ * `fast_cut_enumeration` algorithm.
+ */
+template<typename Ntk, uint32_t NumVars, bool ComputeTruth, typename CutData>
+struct fast_network_cuts
+{
+public:
+  static constexpr uint32_t max_cut_num = 50;
+  using cut_t = cut_type<ComputeTruth, CutData>;
+  using cut_set_t = cut_set<cut_t, max_cut_num>;
+  static constexpr bool compute_truth = ComputeTruth;
+
+private:
+  explicit fast_network_cuts( uint32_t size ) : _cuts( size )
+  {
+    kitty::static_truth_table<NumVars> zero, proj;
+    kitty::create_nth_var( proj, 0u );
+
+    _truth_tables.insert( zero );
+    _truth_tables.insert( proj );
+  }
+
+public:
+  /*! \brief Returns the cut set of a node */
+  cut_set_t& cuts( uint32_t node_index ) { return _cuts[node_index]; }
+
+  /*! \brief Returns the cut set of a node */
+  cut_set_t const& cuts( uint32_t node_index ) const { return _cuts[node_index]; }
+
+  /*! \brief Returns the truth table of a cut */
+  template<bool enabled = ComputeTruth, typename = std::enable_if_t<std::is_same_v<Ntk, Ntk> && enabled>>
+  auto truth_table( cut_t const& cut ) const
+  {
+    return _truth_tables[cut->func_id];
+  }
+
+  /*! \brief Returns the total number of tuples that were tried to be merged */
+  auto total_tuples() const
+  {
+    return _total_tuples;
+  }
+
+  /*! \brief Returns the total number of cuts in the database. */
+  auto total_cuts() const
+  {
+    return _total_cuts;
+  }
+
+  /*! \brief Returns the number of nodes for which cuts are computed */
+  auto nodes_size() const
+  {
+    return _cuts.size();
+  }
+
+  /* compute positions of leave indices in cut `sub` (subset) with respect to
+   * leaves in cut `sup` (super set).
+   *
+   * Example:
+   *   compute_truth_table_support( {1, 3, 6}, {0, 1, 2, 3, 6, 7} ) = {1, 3, 4}
+   */
+  std::vector<uint8_t> compute_truth_table_support( cut_t const& sub, cut_t const& sup ) const
+  {
+    std::vector<uint8_t> support;
+    support.reserve( sub.size() );
+
+    auto itp = sup.begin();
+    for ( auto i : sub )
+    {
+      itp = std::find( itp, sup.end(), i );
+      support.push_back( static_cast<uint8_t>( std::distance( sup.begin(), itp ) ) );
+    }
+
+    return support;
+  }
+
+  /*! \brief Inserts a truth table into the truth table cache.
+   *
+   * This message can be used when manually adding or modifying cuts from the
+   * cut sets.
+   *
+   * \param tt Truth table to add
+   * \return Literal id from the truth table store
+   */
+  uint32_t insert_truth_table( kitty::static_truth_table<NumVars> const& tt )
+  {
+    return _truth_tables.insert( tt );
+  }
+
+private:
+  template<typename _Ntk, uint32_t _NumVars, bool _ComputeTruth, typename _CutData>
+  friend class detail::fast_cut_enumeration_impl;
+
+  template<typename _Ntk, uint32_t _NumVars, bool _ComputeTruth, typename _CutData>
+  friend fast_network_cuts<_Ntk, _NumVars, _ComputeTruth, _CutData> fast_cut_enumeration( _Ntk const& ntk, cut_enumeration_params const& ps, cut_enumeration_stats* pst );
+
+private:
+  void add_zero_cut( uint32_t index )
+  {
+    auto& cut = _cuts[index].add_cut( &index, &index ); /* fake iterator for emptyness */
+
+    if constexpr ( ComputeTruth )
+    {
+      cut->func_id = 0;
+    }
+  }
+
+  void add_unit_cut( uint32_t index )
+  {
+    auto& cut = _cuts[index].add_cut( &index, &index + 1 );
+
+    if constexpr ( ComputeTruth )
+    {
+      cut->func_id = 2;
+    }
+  }
+
+private:
+  /* compressed representation of cuts */
+  std::vector<cut_set_t> _cuts;
+
+  /* cut truth tables */
+  truth_table_cache<kitty::static_truth_table<NumVars>> _truth_tables;
+
+  /* statistics */
+  uint32_t _total_tuples{};
+  std::size_t _total_cuts{};
+};
+
+/*! \cond PRIVATE */
+namespace detail
+{
+
+template<typename Ntk, uint32_t NumVars, bool ComputeTruth, typename CutData>
+class fast_cut_enumeration_impl
+{
+public:
+  using cut_t = typename fast_network_cuts<Ntk, NumVars, ComputeTruth, CutData>::cut_t;
+  using cut_set_t = typename fast_network_cuts<Ntk, NumVars, ComputeTruth, CutData>::cut_set_t;
+
+  explicit fast_cut_enumeration_impl( Ntk const& ntk, cut_enumeration_params const& ps, cut_enumeration_stats& st, fast_network_cuts<Ntk, NumVars, ComputeTruth, CutData>& cuts )
+      : ntk( ntk ),
+        ps( ps ),
+        st( st ),
+        cuts( cuts )
+  {
+    assert( ps.cut_limit < cuts.max_cut_num && "cut_limit exceeds the compile-time limit for the maximum number of cuts" );
+  }
+
+public:
+  void run()
+  {
+    stopwatch t( st.time_total );
+
+    ntk.foreach_node( [this]( auto node ) {
+      const auto index = ntk.node_to_index( node );
+
+      if ( ps.very_verbose )
+      {
+        std::cout << fmt::format( "[i] compute cut for node at index {}\n", index );
+      }
+
+      if ( ntk.is_constant( node ) )
+      {
+        cuts.add_zero_cut( index );
+      }
+      else if ( ntk.is_ci( node ) )
+      {
+        cuts.add_unit_cut( index );
+      }
+      else
+      {
+        if constexpr ( Ntk::min_fanin_size == 2 && Ntk::max_fanin_size == 2 )
+        {
+          merge_cuts2( index );
+        }
+        else
+        {
+          merge_cuts( index );
+        }
+      }
+    } );
+  }
+
+private:
+  uint32_t compute_truth_table( uint32_t index, std::vector<cut_t const*> const& vcuts, cut_t& res )
+  {
+    stopwatch t( st.time_truth_table );
+
+    std::vector<kitty::static_truth_table<NumVars>> tt( vcuts.size() );
+    auto i = 0;
+    for ( auto const& cut : vcuts )
+    {
+      tt[i] = cuts._truth_tables[( *cut )->func_id];
+      const auto supp = cuts.compute_truth_table_support( *cut, res );
+      kitty::expand_inplace( tt[i], supp );
+      ++i;
+    }
+
+    auto tt_res = ntk.compute( ntk.index_to_node( index ), tt.begin(), tt.end() );
+
+    if ( ps.minimize_truth_table )
+    {
+      const auto support = kitty::min_base_inplace( tt_res );
+      if ( support.size() != res.size() )
+      {
+        std::vector<uint32_t> leaves_before( res.begin(), res.end() );
+        std::vector<uint32_t> leaves_after( support.size() );
+
+        auto it_support = support.begin();
+        auto it_leaves = leaves_after.begin();
+        while ( it_support != support.end() )
+        {
+          *it_leaves++ = leaves_before[*it_support++];
+        }
+        res.set_leaves( leaves_after.begin(), leaves_after.end() );
+      }
+    }
+
+    return cuts._truth_tables.insert( tt_res );
+  }
+
+  void merge_cuts2( uint32_t index )
+  {
+    const auto fanin = 2;
+
+    uint32_t pairs{ 1 };
+    ntk.foreach_fanin( ntk.index_to_node( index ), [this, &pairs]( auto child, auto i ) {
+      lcuts[i] = &cuts.cuts( ntk.node_to_index( ntk.get_node( child ) ) );
+      pairs *= static_cast<uint32_t>( lcuts[i]->size() );
+    } );
+    lcuts[2] = &cuts.cuts( index );
+    auto& rcuts = *lcuts[fanin];
+    rcuts.clear();
+
+    cut_t new_cut;
+
+    std::vector<cut_t const*> vcuts( fanin );
+
+    cuts._total_tuples += pairs;
+    for ( auto const& c1 : *lcuts[0] )
+    {
+      for ( auto const& c2 : *lcuts[1] )
+      {
+        if ( !c1->merge( *c2, new_cut, NumVars ) )
+        {
+          continue;
+        }
+
+        if ( rcuts.is_dominated( new_cut ) )
+        {
+          continue;
+        }
+
+        if constexpr ( ComputeTruth )
+        {
+          vcuts[0] = c1;
+          vcuts[1] = c2;
+          new_cut->func_id = compute_truth_table( index, vcuts, new_cut );
+        }
+
+        cut_enumeration_update_cut<CutData>::apply( new_cut, cuts, ntk, index );
+
+        rcuts.insert( new_cut );
+      }
+    }
+
+    /* limit the maximum number of cuts */
+    rcuts.limit( ps.cut_limit - 1 );
+
+    cuts._total_cuts += rcuts.size();
+
+    if ( rcuts.size() > 1 || ( *rcuts.begin() )->size() > 1 )
+    {
+      cuts.add_unit_cut( index );
+    }
+  }
+
+  void merge_cuts( uint32_t index )
+  {
+    uint32_t pairs{ 1 };
+    std::vector<uint32_t> cut_sizes;
+    ntk.foreach_fanin( ntk.index_to_node( index ), [this, &pairs, &cut_sizes]( auto child, auto i ) {
+      lcuts[i] = &cuts.cuts( ntk.node_to_index( ntk.get_node( child ) ) );
+      cut_sizes.push_back( static_cast<uint32_t>( lcuts[i]->size() ) );
+      pairs *= cut_sizes.back();
+    } );
+
+    const auto fanin = cut_sizes.size();
+    lcuts[fanin] = &cuts.cuts( index );
+
+    auto& rcuts = *lcuts[fanin];
+
+    if ( fanin > 1 && fanin <= ps.fanin_limit )
+    {
+      rcuts.clear();
+
+      cut_t new_cut, tmp_cut;
+
+      std::vector<cut_t const*> vcuts( fanin );
+
+      cuts._total_tuples += pairs;
+      foreach_mixed_radix_tuple( cut_sizes.begin(), cut_sizes.end(), [&]( auto begin, auto end ) {
+        auto it = vcuts.begin();
+        auto i = 0u;
+        while ( begin != end )
+        {
+          *it++ = &( ( *lcuts[i++] )[*begin++] );
+        }
+
+        if ( !vcuts[0]->merge( *vcuts[1], new_cut, NumVars ) )
+        {
+          return true; /* continue */
+        }
+
+        for ( i = 2; i < fanin; ++i )
+        {
+          tmp_cut = new_cut;
+          if ( !vcuts[i]->merge( tmp_cut, new_cut, NumVars ) )
+          {
+            return true; /* continue */
+          }
+        }
+
+        if ( rcuts.is_dominated( new_cut ) )
+        {
+          return true; /* continue */
+        }
+
+        if constexpr ( ComputeTruth )
+        {
+          new_cut->func_id = compute_truth_table( index, vcuts, new_cut );
+        }
+
+        cut_enumeration_update_cut<CutData>::apply( new_cut, cuts, ntk, ntk.index_to_node( index ) );
+
+        rcuts.insert( new_cut );
+
+        return true;
+      } );
+
+      /* limit the maximum number of cuts */
+      rcuts.limit( ps.cut_limit - 1 );
+    }
+    else if ( fanin == 1 )
+    {
+      rcuts.clear();
+
+      for ( auto const& cut : *lcuts[0] )
+      {
+        cut_t new_cut = *cut;
+
+        if constexpr ( ComputeTruth )
+        {
+          new_cut->func_id = compute_truth_table( index, { cut }, new_cut );
+        }
+
+        cut_enumeration_update_cut<CutData>::apply( new_cut, cuts, ntk, ntk.index_to_node( index ) );
+
+        rcuts.insert( new_cut );
+      }
+
+      /* limit the maximum number of cuts */
+      rcuts.limit( ps.cut_limit - 1 );
+    }
+
+    cuts._total_cuts += static_cast<uint32_t>( rcuts.size() );
+
+    cuts.add_unit_cut( index );
+  }
+
+private:
+  Ntk const& ntk;
+  cut_enumeration_params const& ps;
+  cut_enumeration_stats& st;
+  fast_network_cuts<Ntk, NumVars, ComputeTruth, CutData>& cuts;
+
+  std::array<cut_set_t*, Ntk::max_fanin_size + 1> lcuts;
+};
+} /* namespace detail */
+/*! \endcond */
+
+/*! \brief Fast cut enumeration.
+ *
+ * This function implements the cut enumeration algorithm.  The algorithm
+ * traverses all nodes in topological order and computes a node's cuts based
+ * on its fanins' cuts.  Dominated cuts are filtered and are not added to the
+ * cut set.  For each node a unit cut is added to the end of each cut set.
+ *
+ * The template parameter `ComputeTruth` controls whether truth tables should
+ * be computed for each cut.  Computing truth tables slows down the execution
+ * time of the algorithm.
+ *
+ * The cut size is controlled using the template parameter `NumVars` instead
+ * of the `cut_size` parameter as in `cut_enumeration`.
+ *
+ * Comparing to `cut_enumeration`, it uses static truth tables instead of
+ * dynamic truth tables to speed-up the truth table computation.
+ *
+ * The number of computed cuts is controlled via the `cut_limit` parameter.
+ * To decide which cuts are collected in each node's cut set, cuts are sorted.
+ * Unit cuts do not participate in the sorting and are always added to the end
+ * of each cut set.
+ *
+ * The algorithm can be configured by specifying the template argument `CutData`
+ * which holds the application specific data assigned to each cut.  Examples
+ * on how to specify custom cost functions for sorting cuts based on the
+ * application specific cut data can be found in the files contained in the
+ * directory `include/mockturtle/algorithms/cut_enumeration`.
+ *
+ * **Required network functions:**
+ * - `is_constant`
+ * - `is_ci`
+ * - `size`
+ * - `get_node`
+ * - `node_to_index`
+ * - `foreach_node`
+ * - `foreach_fanin`
+ * - `compute` for `kitty::static_truth_table` (if `ComputeTruth` is true)
+ *
+   \verbatim embed:rst
+
+   .. warning::
+
+      This algorithm expects the nodes in the network to be in topological
+      order.  If the network does not guarantee a topological order of nodes
+      one can wrap the network parameter in a ``topo_view`` view.
+
+   .. note::
+
+      The implementation of this algorithm was heavily inspired by cut
+      enumeration implementations in ABC.
+   \endverbatim
+ */
+template<typename Ntk, uint32_t NumVars, bool ComputeTruth, typename CutData>
+fast_network_cuts<Ntk, NumVars, ComputeTruth, CutData> fast_cut_enumeration( Ntk const& ntk, cut_enumeration_params const& ps, cut_enumeration_stats* pst )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_ci_v<Ntk>, "Ntk does not implement the is_ci method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( !ComputeTruth || has_compute_v<Ntk, kitty::dynamic_truth_table>, "Ntk does not implement the compute method for kitty::dynamic_truth_table" );
+
+  cut_enumeration_stats st;
+  fast_network_cuts<Ntk, NumVars, ComputeTruth, CutData> res( ntk.size() );
+  detail::fast_cut_enumeration_impl<Ntk, NumVars, ComputeTruth, CutData> p( ntk, ps, st, res );
+  p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+  if ( pst )
+  {
+    *pst = st;
+  }
+
+  return res;
+}
+
+/* forward declarations */
+/*! \cond PRIVATE */
+template<typename Ntk, uint32_t NumVars, bool ComputeTruth, typename CutData>
+struct dynamic_network_cuts;
+
+namespace detail
+{
+template<typename Ntk, uint32_t NumVars, bool ComputeTruth, typename CutData>
+class dynamic_cut_enumeration_impl;
+}
+/*! \endcond */
+
+/*! \brief Dynamic cut database for a network.
+ *
+ * Struct `dynamic_network_cuts` contains a cut database and can be queried
+ * to return all cuts of a node, or the function of a cut (if it was computed).
+ *
+ * Comparing to `network_cuts`, it supports dynamic allocation of cuts for
+ * networks in expansion. Moreover, it uses static truth tables instead of
+ * dynamic truth tables to speed-up the truth table computation.
+ *
+ * An instance of type `dynamic_network_cuts` can only be constructed from the
+ * `dynamic_cut_enumeration_impl` algorithm.
+ */
+template<typename Ntk, uint32_t NumVars, bool ComputeTruth, typename CutData>
+struct dynamic_network_cuts
+{
+public:
+  static constexpr uint32_t max_cut_num = 16u;
+  using cut_t = cut_type<ComputeTruth, CutData>;
+  using cut_set_t = cut_set<cut_t, max_cut_num>;
+  static constexpr bool compute_truth = ComputeTruth;
+
+public:
+  explicit dynamic_network_cuts( uint32_t size ) : _cuts( size )
+  {
+    kitty::static_truth_table<NumVars> zero, proj;
+    kitty::create_nth_var( proj, 0u );
+
+    _truth_tables.insert( zero );
+    _truth_tables.insert( proj );
+  }
+
+public:
+  /*! \brief Returns the cut set of a node */
+  cut_set_t& cuts( uint32_t node_index )
+  {
+    if ( node_index >= _cuts.size() )
+      _cuts.resize( node_index + 1 );
+
+    return _cuts[node_index];
+  }
+
+  /*! \brief Returns the cut set of a node */
+  cut_set_t const& cuts( uint32_t node_index ) const
+  {
+    assert( node_index < _cuts.size() );
+    return _cuts[node_index];
+  }
+
+  /*! \brief Returns the truth table of a cut */
+  template<bool enabled = ComputeTruth, typename = std::enable_if_t<std::is_same_v<Ntk, Ntk> && enabled>>
+  auto truth_table( cut_t const& cut ) const
+  {
+    return _truth_tables[cut->func_id];
+  }
+
+  /*! \brief Returns the total number of tuples that were tried to be merged */
+  auto total_tuples() const
+  {
+    return _total_tuples;
+  }
+
+  /*! \brief Returns the total number of cuts in the database. */
+  auto total_cuts() const
+  {
+    return _total_cuts;
+  }
+
+  /*! \brief Returns the number of nodes for which cuts are computed */
+  auto nodes_size() const
+  {
+    return _cuts.size();
+  }
+
+  /* compute positions of leave indices in cut `sub` (subset) with respect to
+   * leaves in cut `sup` (super set).
+   *
+   * Example:
+   *   compute_truth_table_support( {1, 3, 6}, {0, 1, 2, 3, 6, 7} ) = {1, 3, 4}
+   */
+  std::vector<uint8_t> compute_truth_table_support( cut_t const& sub, cut_t const& sup ) const
+  {
+    std::vector<uint8_t> support;
+    support.reserve( sub.size() );
+
+    auto itp = sup.begin();
+    for ( auto i : sub )
+    {
+      itp = std::find( itp, sup.end(), i );
+      support.push_back( static_cast<uint8_t>( std::distance( sup.begin(), itp ) ) );
+    }
+
+    return support;
+  }
+
+  /*! \brief Inserts a truth table into the truth table cache.
+   *
+   * This message can be used when manually adding or modifying cuts from the
+   * cut sets.
+   *
+   * \param tt Truth table to add
+   * \return Literal id from the truth table store
+   */
+  uint32_t insert_truth_table( kitty::static_truth_table<NumVars> const& tt )
+  {
+    return _truth_tables.insert( tt );
+  }
+
+private:
+  template<typename _Ntk, uint32_t _NumVars, bool _ComputeTruth, typename _CutData>
+  friend class detail::dynamic_cut_enumeration_impl;
+
+private:
+  void add_zero_cut( uint32_t index )
+  {
+    auto& cut = _cuts[index].add_cut( &index, &index ); /* fake iterator for emptyness */
+
+    if constexpr ( ComputeTruth )
+    {
+      cut->func_id = 0;
+    }
+  }
+
+  void add_unit_cut( uint32_t index )
+  {
+    auto& cut = _cuts[index].add_cut( &index, &index + 1 );
+
+    if constexpr ( ComputeTruth )
+    {
+      cut->func_id = 2;
+    }
+  }
+
+  void clear_cut_set( uint32_t index )
+  {
+    _cuts[index].clear();
+  }
+
+private:
+  /* compressed representation of cuts */
+  std::deque<cut_set_t> _cuts;
+
+  /* cut truth tables */
+  truth_table_cache<kitty::static_truth_table<NumVars>> _truth_tables;
+
+  /* statistics */
+  uint32_t _total_tuples{};
+  std::size_t _total_cuts{};
+};
+
+/*! \cond PRIVATE */
+namespace detail
+{
+template<typename Ntk, uint32_t NumVars, bool ComputeTruth, typename CutData>
+class dynamic_cut_enumeration_impl
+{
+public:
+  using cut_t = typename dynamic_network_cuts<Ntk, NumVars, ComputeTruth, CutData>::cut_t;
+  using cut_set_t = typename dynamic_network_cuts<Ntk, NumVars, ComputeTruth, CutData>::cut_set_t;
+
+  explicit dynamic_cut_enumeration_impl( Ntk const& ntk, cut_enumeration_params const& ps, cut_enumeration_stats& st, dynamic_network_cuts<Ntk, NumVars, ComputeTruth, CutData>& cuts )
+      : ntk( ntk ),
+        ps( ps ),
+        st( st ),
+        cuts( cuts )
+  {
+    assert( ps.cut_limit < cuts.max_cut_num && "cut_limit exceeds the compile-time limit for the maximum number of cuts" );
+  }
+
+public:
+  void run()
+  {
+    stopwatch t( st.time_total );
+
+    ntk.foreach_node( [this]( auto node ) {
+      const auto index = ntk.node_to_index( node );
+
+      if ( ps.very_verbose )
+      {
+        std::cout << fmt::format( "[i] compute cut for node at index {}\n", index );
+      }
+
+      if ( ntk.is_constant( node ) )
+      {
+        cuts.add_zero_cut( index );
+      }
+      else if ( ntk.is_ci( node ) )
+      {
+        cuts.add_unit_cut( index );
+      }
+      else
+      {
+        if constexpr ( Ntk::min_fanin_size == 2 && Ntk::max_fanin_size == 2 )
+        {
+          merge_cuts2( index );
+        }
+        else
+        {
+          merge_cuts( index );
+        }
+      }
+    } );
+  }
+
+  void compute_cuts( node<Ntk> const& n )
+  {
+    const auto index = ntk.node_to_index( n );
+
+    if ( cuts.cuts( index ).size() > 0 )
+      return;
+
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      compute_cuts( ntk.get_node( f ) );
+    } );
+
+    if constexpr ( Ntk::min_fanin_size == 2 && Ntk::max_fanin_size == 2 )
+    {
+      merge_cuts2( index );
+    }
+    else
+    {
+      merge_cuts( index );
+    }
+  }
+
+  void init_cuts()
+  {
+    cuts.add_zero_cut( ntk.node_to_index( ntk.get_node( ntk.get_constant( false ) ) ) );
+    if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+      cuts.add_zero_cut( ntk.node_to_index( ntk.get_node( ntk.get_constant( true ) ) ) );
+    ntk.foreach_ci( [&]( auto const& n ) {
+      cuts.add_unit_cut( ntk.node_to_index( n ) );
+    } );
+  }
+
+  void clear_cuts( node<Ntk> const& n )
+  {
+    const auto index = ntk.node_to_index( n );
+    if ( cuts.cuts( index ).size() == 0 )
+      return;
+
+    cuts.clear_cut_set( index );
+  }
+
+private:
+  inline bool fast_support_minimization( kitty::static_truth_table<NumVars> const& tt, cut_t& res )
+  {
+    uint32_t support = 0u;
+    uint32_t support_size = 0u;
+    for ( uint32_t i = 0u; i < tt.num_vars(); ++i )
+    {
+      if ( kitty::has_var( tt, i ) )
+      {
+        support |= 1u << i;
+        ++support_size;
+      }
+    }
+
+    /* has not minimized support? */
+    if ( ( support & ( support + 1u ) ) != 0u )
+    {
+      return false;
+    }
+
+    /* variables not in the support are the most significative */
+    if ( support_size != res.size() )
+    {
+      std::vector<uint32_t> leaves( res.begin(), res.begin() + support_size );
+      res.set_leaves( leaves.begin(), leaves.end() );
+    }
+
+    return true;
+  }
+
+  uint32_t compute_truth_table( uint32_t index, std::vector<cut_t const*> const& vcuts, cut_t& res )
+  {
+    stopwatch t( st.time_truth_table );
+
+    std::vector<kitty::static_truth_table<NumVars>> tt( vcuts.size() );
+    auto i = 0;
+    for ( auto const& cut : vcuts )
+    {
+      tt[i] = cuts._truth_tables[( *cut )->func_id];
+      const auto supp = cuts.compute_truth_table_support( *cut, res );
+      kitty::expand_inplace( tt[i], supp );
+      ++i;
+    }
+
+    auto tt_res = ntk.compute( ntk.index_to_node( index ), tt.begin(), tt.end() );
+
+    if ( ps.minimize_truth_table && !fast_support_minimization( tt_res, res ) )
+    {
+      const auto support = kitty::min_base_inplace( tt_res );
+      if ( support.size() != res.size() )
+      {
+        std::vector<uint32_t> leaves_before( res.begin(), res.end() );
+        std::vector<uint32_t> leaves_after( support.size() );
+
+        auto it_support = support.begin();
+        auto it_leaves = leaves_after.begin();
+        while ( it_support != support.end() )
+        {
+          *it_leaves++ = leaves_before[*it_support++];
+        }
+        res.set_leaves( leaves_after.begin(), leaves_after.end() );
+      }
+    }
+
+    return cuts._truth_tables.insert( tt_res );
+  }
+
+  void merge_cuts2( uint32_t index )
+  {
+    const auto fanin = 2;
+
+    uint32_t pairs{ 1 };
+    ntk.foreach_fanin( ntk.index_to_node( index ), [this, &pairs]( auto child, auto i ) {
+      lcuts[i] = &cuts.cuts( ntk.node_to_index( ntk.get_node( child ) ) );
+      pairs *= static_cast<uint32_t>( lcuts[i]->size() );
+    } );
+    lcuts[2] = &cuts.cuts( index );
+    auto& rcuts = *lcuts[fanin];
+    rcuts.clear();
+
+    cut_t new_cut;
+
+    std::vector<cut_t const*> vcuts( fanin );
+
+    cuts._total_tuples += pairs;
+    for ( auto const& c1 : *lcuts[0] )
+    {
+      for ( auto const& c2 : *lcuts[1] )
+      {
+        if ( !c1->merge( *c2, new_cut, NumVars ) )
+        {
+          continue;
+        }
+
+        if ( rcuts.is_dominated( new_cut ) )
+        {
+          continue;
+        }
+
+        if constexpr ( ComputeTruth )
+        {
+          vcuts[0] = c1;
+          vcuts[1] = c2;
+          new_cut->func_id = compute_truth_table( index, vcuts, new_cut );
+        }
+
+        cut_enumeration_update_cut<CutData>::apply( new_cut, cuts, ntk, index );
+
+        rcuts.insert( new_cut );
+      }
+    }
+
+    /* limit the maximum number of cuts */
+    rcuts.limit( ps.cut_limit );
+
+    cuts._total_cuts += rcuts.size();
+
+    if ( rcuts.size() > 1 || ( *rcuts.begin() )->size() > 1 )
+    {
+      cuts.add_unit_cut( index );
+    }
+  }
+
+  void merge_cuts( uint32_t index )
+  {
+    uint32_t pairs{ 1 };
+    std::vector<uint32_t> cut_sizes;
+    ntk.foreach_fanin( ntk.index_to_node( index ), [this, &pairs, &cut_sizes]( auto child, auto i ) {
+      lcuts[i] = &cuts.cuts( ntk.node_to_index( ntk.get_node( child ) ) );
+      cut_sizes.push_back( static_cast<uint32_t>( lcuts[i]->size() ) );
+      pairs *= cut_sizes.back();
+    } );
+
+    const auto fanin = cut_sizes.size();
+    lcuts[fanin] = &cuts.cuts( index );
+
+    auto& rcuts = *lcuts[fanin];
+
+    if ( fanin > 1 && fanin <= ps.fanin_limit )
+    {
+      rcuts.clear();
+
+      cut_t new_cut, tmp_cut;
+
+      std::vector<cut_t const*> vcuts( fanin );
+
+      cuts._total_tuples += pairs;
+      foreach_mixed_radix_tuple( cut_sizes.begin(), cut_sizes.end(), [&]( auto begin, auto end ) {
+        auto it = vcuts.begin();
+        auto i = 0u;
+        while ( begin != end )
+        {
+          *it++ = &( ( *lcuts[i++] )[*begin++] );
+        }
+
+        if ( !vcuts[0]->merge( *vcuts[1], new_cut, NumVars ) )
+        {
+          return true; /* continue */
+        }
+
+        for ( i = 2; i < fanin; ++i )
+        {
+          tmp_cut = new_cut;
+          if ( !vcuts[i]->merge( tmp_cut, new_cut, NumVars ) )
+          {
+            return true; /* continue */
+          }
+        }
+
+        if ( rcuts.is_dominated( new_cut ) )
+        {
+          return true; /* continue */
+        }
+
+        if constexpr ( ComputeTruth )
+        {
+          new_cut->func_id = compute_truth_table( index, vcuts, new_cut );
+        }
+
+        cut_enumeration_update_cut<CutData>::apply( new_cut, cuts, ntk, ntk.index_to_node( index ) );
+
+        rcuts.insert( new_cut );
+
+        return true;
+      } );
+
+      /* limit the maximum number of cuts */
+      rcuts.limit( ps.cut_limit );
+    }
+    else if ( fanin == 1 )
+    {
+      rcuts.clear();
+
+      for ( auto const& cut : *lcuts[0] )
+      {
+        cut_t new_cut = *cut;
+
+        if constexpr ( ComputeTruth )
+        {
+          new_cut->func_id = compute_truth_table( index, { cut }, new_cut );
+        }
+
+        cut_enumeration_update_cut<CutData>::apply( new_cut, cuts, ntk, ntk.index_to_node( index ) );
+
+        rcuts.insert( new_cut );
+      }
+
+      /* limit the maximum number of cuts */
+      rcuts.limit( ps.cut_limit );
+    }
+
+    cuts._total_cuts += static_cast<uint32_t>( rcuts.size() );
+
+    cuts.add_unit_cut( index );
+  }
+
+private:
+  Ntk const& ntk;
+  cut_enumeration_params const& ps;
+  cut_enumeration_stats& st;
+  dynamic_network_cuts<Ntk, NumVars, ComputeTruth, CutData>& cuts;
+
+  std::array<cut_set_t*, Ntk::max_fanin_size + 1> lcuts;
+};
+} /* namespace detail */
+/*! \endcond */
+
+// This function expects to receive a network where nodes are sorted in
+// topological order. Cuts are represented as a 64-bit bit vector where each bit
+// determines whether a given node exists in the cut.
+
+/*! \brief Cut enumeration.
+ *
+ * This function implements a generic fast cut enumeration algorithm for graphs
+ * containing at most 64 nodes. It is generic as it supports graphs in which
+ * nodes can have variable fan-in. Speed and space-efficiency are achieved by
+ * representing cuts as 64-bit bit vectors, i.e. each bit represents whether or
+ * not a node is in a cut. Cut-set union and domination operations then
+ * transform into bitwise operations that can be performed in a few clock cycles
+ * each.
+ *
+ * Like the larger cut_enumeration algorithm, this algorithm traverses all nodes
+ * in topological order and computes a node's cuts based on its fanins' cuts.
+ * Dominated cuts are filtered and are not added to the cut set. For each node a
+ * unit cut is added to the end of each cut set.
+ *
+ * This function computes all cuts of the network (i.e. the number of generated
+ * cuts is not bounded). Though the number of cuts cannot be bounded, their size
+ * can be bound by passing a `cut_size` argument to the function.
+ *
+ * **Required network functions:**
+ * - `fanin_size`
+ * - `foreach_fanin`
+ * - `foreach_gate`
+ * - `foreach_ci`
+ * - `get_node`
+ * - `node_to_index`
+ * - `size`
+ *
+ * Note that this algorithm *only* works for graphs with at most 64 nodes.
+ * However, since we cannot know the size of a graph at compile-time, this
+ * function returns the results wrapped in an std::optional.
+ *
+   \verbatim embed:rst
+
+   .. warning::
+
+      This algorithm expects the nodes in the network to be in topological
+      order.  If the network does not guarantee a topological order of nodes one
+      can wrap the network parameter in a ``topo_view`` view.
+   \endverbatim
+ */
+template<typename Ntk>
+std::optional<std::vector<std::vector<uint64_t>>>
+fast_small_cut_enumeration( Ntk const& ntk, const uint8_t cut_size = 4 )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  // You cannot check whether a graph is topologically sorted at compile-time,
+  // but the is_topologically_sorted_v<Ntk> template is used inside the
+  // topo_view class to determine whether the input graph should just be copied
+  // as it is already topologically-sorted, or whether the graph's topological
+  // order is to be computed.
+  // static_assert( is_topologically_sorted_v<Ntk>, "Ntk is not a topologically-sorted network" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_foreach_ci_v<Ntk>, "Ntk does not implement the foreach_ci method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+
+  // Max 64 nodes, so 8 bits are enough for indices.
+  using node_idx_t = uint8_t;
+  using cut_t = uint64_t;
+  using cut_set_t = std::vector<cut_t>;
+  using cut_sets_t = std::vector<cut_set_t>;
+
+  // It is not possible to know the size of a network at compile-time, so I will
+  // return a boolean flag stating whether the cut-sets returned by this
+  // function are valid or not.
+  constexpr node_idx_t max_nodes = 64;
+  if ( ntk.size() > max_nodes )
+  {
+    return std::nullopt;
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Final cut-sets to be computed /////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////
+
+  // size() returns the number of nodes including constants, PIs, and dead
+  // nodes, so no need to allocate +1 memory slots like in the lecture notes
+  // to explicitly represent constants.
+  // By definition of the vector constructor, each cut-set is initialized to {}.
+  cut_sets_t cut_sets( ntk.size() );
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Helper functions //////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////
+
+  auto set_bit = [](
+                     node_idx_t idx ) {
+    return static_cast<cut_t>( 1 ) << idx;
+  };
+
+  // Algorithm for counting #1 bits in a uint64_t. It is efficient as it only
+  // iterates as many times as the bit count to avoid always performing 64
+  // iterations. Inspired from the following threads:
+  // http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetNaive
+  // https://stackoverflow.com/questions/8871204/count-number-of-1s-in-binary-representation
+  auto bit_cnt = [](
+                     cut_t n ) {
+    uint8_t count = 0;
+
+    while ( n > 0 )
+    {
+      count = count + 1;
+      n = n & ( n - 1 );
+    }
+
+    return count;
+  };
+
+  // Operation to perform on each n-tuple. In the cut generation algorithm this
+  // involves computing a new cut from the fan-in nodes' selected cuts, checking
+  // whether an existing cut dominates it, and if not, adding it to the cutset
+  // of the current node.
+  auto visit_n_tuple = [&cut_sets, &bit_cnt, &cut_size](
+                           // Node for which we are computing the cut.
+                           node_idx_t node_idx,
+                           // Fan-in of the current node.
+                           std::vector<node_idx_t> const& fanin_idx,
+                           // Index of the cut to choose from the given fan-in node.
+                           std::vector<node_idx_t> const& cut_idx ) {
+    // Compute new cut.
+    cut_t C = 0;
+    for ( auto i = 0U; i < fanin_idx.size(); i++ )
+    {
+      C |= cut_sets.at( fanin_idx[i] ).at( cut_idx[i] );
+    }
+
+    // Restrict cut sizes if too large.
+    if ( bit_cnt( C ) > cut_size )
+    {
+      return;
+    }
+
+    // Don't add new cut if existing cut dominates it. A cut C' dominates
+    // another cut C if C' is a subset of C. Being a subset means that C' has at
+    // most the same bits set as C, but no more bits.
+    //
+    // So if we AND their bitsets together, we can see what they have in common,
+    // then we can XOR this with C' original bits to see if C' has any bit
+    // active that C does not.
+    //
+    //   C' = 0b 00110
+    //   C  = 0b 01010 AND
+    //        --------
+    //        0b 00010
+    //   C' = 0b 00110 XOR
+    //        --------
+    //        0b 00100 => C' does NOT dominate C as it contains a node that C does not.
+    for ( auto C_prime : cut_sets.at( node_idx ) )
+    {
+      cut_t shared_nodes = C_prime & C;
+      cut_t C_prime_extra_nodes = shared_nodes ^ C_prime;
+
+      bool C_prime_dominates_C = C_prime_extra_nodes == 0;
+      if ( C_prime_dominates_C )
+      {
+        return;
+      }
+    }
+
+    cut_sets.at( node_idx ).push_back( C );
+  };
+
+  // Enumerates cuts of a given node. The inputs of the node can have variable
+  // fan-in, so the cut-sets they have could have different sizes. We therefore
+  // cannot use N nested for-loops to perform a cross product of the fan-in cuts
+  // since we don't know the cut-set sizes in advance. We instead use the
+  // mixed-radix n-tuple generation algorithm in TAOCP, Vol 4A, algorithm M.
+  auto cut_enumeration_node = [&cut_sets, &visit_n_tuple](
+                                  Ntk const& ntk,
+                                  node<Ntk> const& node ) {
+    node_idx_t node_idx = ntk.node_to_index( node );
+
+    // Index of the node's fan-ins.
+    std::vector<node_idx_t> fanin_idx;
+
+    // Number of cuts of a given fan-in node ("radix" in TAOCP, Vol 4A, Algorithm M).
+    std::vector<size_t> cut_set_size; // radix (m[n-1], ... , m[0]) in TAOCP
+
+    // Index of a cut of a given fan-in node ("value" in TAOCP, Vol 4A, Algorithm M).
+    std::vector<node_idx_t> cut_idx; // value (a[n-1], ... , a[0]) in TAOCP
+
+    // We start by initializing the indices of the fan-in nodes' cuts and their
+    // radix. Need to get the the index of the fan-in nodes for this so we can
+    // query their number of cuts.
+    ntk.foreach_fanin(
+        node,
+        [&]( auto sig ) {
+          auto fanin_node = ntk.get_node( sig );
+          auto fanin_node_idx = ntk.node_to_index( fanin_node );
+
+          fanin_idx.push_back( fanin_node_idx );
+          // Radix of the given fan-in is determined by the number of cuts it has.
+          cut_set_size.push_back( cut_sets.at( fanin_node_idx ).size() );
+          // Start counting from (0, 0, ... , 0)
+          cut_idx.push_back( 0 );
+        } );
+
+    // Fan-in = number of cut-sets we must perform a cross-product over.
+    auto const num_cut_sets = ntk.fanin_size( node );
+
+    uint8_t j = 0;
+    while ( j != num_cut_sets )
+    {
+      visit_n_tuple( node_idx, fanin_idx, cut_idx );
+
+      // Mixed-radix n-tuple generation algorithm. Adding 1 to the n-tuple.
+      j = 0;
+      while ( ( j != num_cut_sets ) && ( cut_idx.at( j ) == cut_set_size.at( j ) - 1 ) )
+      {
+        cut_idx.at( j ) = 0;
+        j += 1;
+      }
+      if ( j != num_cut_sets )
+      {
+        cut_idx.at( j ) += 1;
+      }
+    }
+  };
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Main algorithm ////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////
+
+  // Primary inputs only have themselves as their cut-set.
+  ntk.foreach_ci(
+      [&]( auto node ) {
+        auto const idx = ntk.node_to_index( node );
+        cut_sets.at( idx ) = { set_bit( idx ) };
+      } );
+
+  // Going through remaining gates (excluding constants and primary inputs).
+  ntk.foreach_gate(
+      [&]( auto node ) {
+        // Technically don't need to do this as vectors are constructed with zero
+        // length, but we leave it for clarity.
+        auto const idx = ntk.node_to_index( node );
+        cut_sets.at( idx ) = {};
+
+        // Internally uses TAOCP Vol 4A algorithm M, mixed-radix n-tuple
+        // generation, to enumerate the cross-product of the node's fan-in
+        // cut-sets.
+        cut_enumeration_node( ntk, node );
+
+        cut_sets.at( idx ).push_back( set_bit( idx ) );
+      } );
+
+  return cut_sets;
+}
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/cut_enumeration/cnf_cut.hpp b/include/mockturtle/algorithms/cut_enumeration/cnf_cut.hpp
new file mode 100644
index 0000000..17ce75d
--- /dev/null
+++ b/include/mockturtle/algorithms/cut_enumeration/cnf_cut.hpp
@@ -0,0 +1,109 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cnf_cut.hpp
+  \brief Cut enumeration for CNF mapping
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <iomanip>
+#include <iostream>
+
+#include "../cut_enumeration.hpp"
+
+#include <kitty/cnf.hpp>
+
+namespace mockturtle
+{
+
+/*! \brief Cut for CNF mapping applications.
+
+  This cut type uses the clause count in the CNF encoding of the cut function
+  as cost function.  It requires truth table computation during cut enumeration
+  or LUT mapping in order to work.
+*/
+struct cut_enumeration_cnf_cut
+{
+  uint32_t delay{ 0 };
+  float flow{ 0 };
+  float cost{ 0 };
+};
+
+template<bool ComputeTruth>
+bool operator<( cut_type<ComputeTruth, cut_enumeration_cnf_cut> const& c1, cut_type<ComputeTruth, cut_enumeration_cnf_cut> const& c2 )
+{
+  constexpr auto eps{ 0.005f };
+  if ( c1->data.flow < c2->data.flow - eps )
+    return true;
+  if ( c1->data.flow > c2->data.flow + eps )
+    return false;
+  if ( c1->data.delay < c2->data.delay )
+    return true;
+  if ( c1->data.delay > c2->data.delay )
+    return false;
+  return c1.size() < c2.size();
+}
+
+template<>
+struct cut_enumeration_update_cut<cut_enumeration_cnf_cut>
+{
+  template<typename Cut, typename NetworkCuts, typename Ntk>
+  static void apply( Cut& cut, NetworkCuts const& cuts, Ntk const& ntk, node<Ntk> const& n )
+  {
+    uint32_t delay{ 0 };
+    auto tt = cuts.truth_table( cut );
+    auto cnf = kitty::cnf_characteristic( tt );
+    cut->data.cost = cnf;
+    float flow = cut.size() < 2 ? 0.0f : 1.0f;
+
+    for ( auto leaf : cut )
+    {
+      const auto& best_leaf_cut = cuts.cuts( leaf )[0];
+      delay = std::max( delay, best_leaf_cut->data.delay );
+      flow += best_leaf_cut->data.flow;
+    }
+
+    cut->data.delay = 1 + delay;
+    cut->data.flow = flow / ntk.fanout_size( n );
+  }
+};
+
+template<int MaxLeaves>
+std::ostream& operator<<( std::ostream& os, cut<MaxLeaves, cut_data<false, cut_enumeration_cnf_cut>> const& c )
+{
+  os << "{ ";
+  std::copy( c.begin(), c.end(), std::ostream_iterator<uint32_t>( os, " " ) );
+  os << "}, D = " << std::setw( 3 ) << c->data.delay << " A = " << c->data.flow;
+  return os;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/cut_enumeration/exact_map_cut.hpp b/include/mockturtle/algorithms/cut_enumeration/exact_map_cut.hpp
new file mode 100644
index 0000000..2404bf2
--- /dev/null
+++ b/include/mockturtle/algorithms/cut_enumeration/exact_map_cut.hpp
@@ -0,0 +1,100 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file exact_map_cut.hpp
+  \brief Cut enumeration for mapping with exact synthesis
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <iomanip>
+#include <iostream>
+#include <vector>
+
+#include "../cut_enumeration.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Cut implementation for graph mapping with a complete database */
+struct cut_enumeration_exact_map_cut
+{
+  uint32_t delay{ 0 };
+  float flow{ 0 };
+  uint8_t match_index{ 0 };
+  bool ignore{ false };
+};
+
+template<bool ComputeTruth>
+bool operator<( cut_type<ComputeTruth, cut_enumeration_exact_map_cut> const& c1, cut_type<ComputeTruth, cut_enumeration_exact_map_cut> const& c2 )
+{
+  constexpr auto eps{ 0.005f };
+  if ( c1->data.flow < c2->data.flow - eps )
+    return true;
+  if ( c1->data.flow > c2->data.flow + eps )
+    return false;
+  if ( c1->data.delay < c2->data.delay )
+    return true;
+  if ( c1->data.delay > c2->data.delay )
+    return false;
+  return c1.size() < c2.size();
+}
+
+template<>
+struct cut_enumeration_update_cut<cut_enumeration_exact_map_cut>
+{
+  template<typename Cut, typename NetworkCuts, typename Ntk>
+  static void apply( Cut& cut, NetworkCuts const& cuts, Ntk const& ntk, node<Ntk> const& n )
+  {
+    uint32_t delay{ 0 };
+    float flow = 1.0f;
+
+    for ( auto leaf : cut )
+    {
+      const auto& best_leaf_cut = cuts.cuts( leaf )[0];
+      delay = std::max( delay, best_leaf_cut->data.delay );
+      flow += best_leaf_cut->data.flow;
+    }
+
+    cut->data.delay = 1 + delay;
+    cut->data.flow = flow / ntk.fanout_size( n );
+  }
+};
+
+template<int MaxLeaves>
+std::ostream& operator<<( std::ostream& os, cut<MaxLeaves, cut_data<false, cut_enumeration_exact_map_cut>> const& c )
+{
+  os << "{ ";
+  std::copy( c.begin(), c.end(), std::ostream_iterator<uint32_t>( os, " " ) );
+  os << "}, D = " << std::setw( 3 ) << c->data.delay << " A = " << c->data.flow;
+  return os;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/cut_enumeration/gia_cut.hpp b/include/mockturtle/algorithms/cut_enumeration/gia_cut.hpp
new file mode 100644
index 0000000..9ad0126
--- /dev/null
+++ b/include/mockturtle/algorithms/cut_enumeration/gia_cut.hpp
@@ -0,0 +1,82 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file gia_cut.hpp
+  \brief Cut enumeration as in giaCut.c
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+
+#include "../cut_enumeration.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Cut implementation based on ABC's giaCut.c
+
+  See <a href="https://github.com/berkeley-abc/abc/blob/master/src/aig/gia/giaCut.c">giaCut.c</a> in ABC's repository.
+*/
+struct cut_enumeration_gia_cut
+{
+  uint32_t num_tree_leaves;
+};
+
+template<bool ComputeTruth>
+bool operator<( cut_type<ComputeTruth, cut_enumeration_gia_cut> const& c1, cut_type<ComputeTruth, cut_enumeration_gia_cut> const& c2 )
+{
+  if ( c1->data.num_tree_leaves < c2->data.num_tree_leaves )
+  {
+    return true;
+  }
+  if ( c1->data.num_tree_leaves > c2->data.num_tree_leaves )
+  {
+    return false;
+  }
+  return c1.size() < c2.size();
+}
+
+template<>
+struct cut_enumeration_update_cut<cut_enumeration_gia_cut>
+{
+  template<typename Cut, typename NetworkCuts, typename Ntk>
+  static void apply( Cut& cut, NetworkCuts const& cuts, Ntk const& ntk, node<Ntk> const& n )
+  {
+    (void)n;
+    (void)cuts;
+    cut->data.num_tree_leaves = std::count_if( cut.begin(), cut.end(),
+                                               [&ntk]( auto index ) {
+                                                 return ntk.fanout_size( index ) == 1;
+                                               } );
+  }
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/cut_enumeration/mf_cut.hpp b/include/mockturtle/algorithms/cut_enumeration/mf_cut.hpp
new file mode 100644
index 0000000..ebaee4b
--- /dev/null
+++ b/include/mockturtle/algorithms/cut_enumeration/mf_cut.hpp
@@ -0,0 +1,102 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mf_cut.hpp
+  \brief Cut enumeration for MF mapping (see giaMf.c)
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <iomanip>
+#include <iostream>
+
+#include "../cut_enumeration.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Cut implementation based on ABC's giaMf.c
+
+  See <a href="https://github.com/berkeley-abc/abc/blob/master/src/aig/gia/giaMf.c">giaMf.c</a> in ABC's repository.
+*/
+struct cut_enumeration_mf_cut
+{
+  uint32_t delay{ 0 };
+  float flow{ 0 };
+  float cost{ 0 };
+};
+
+template<bool ComputeTruth>
+bool operator<( cut_type<ComputeTruth, cut_enumeration_mf_cut> const& c1, cut_type<ComputeTruth, cut_enumeration_mf_cut> const& c2 )
+{
+  constexpr auto eps{ 0.005f };
+  if ( c1->data.flow < c2->data.flow - eps )
+    return true;
+  if ( c1->data.flow > c2->data.flow + eps )
+    return false;
+  if ( c1->data.delay < c2->data.delay )
+    return true;
+  if ( c1->data.delay > c2->data.delay )
+    return false;
+  return c1.size() < c2.size();
+}
+
+template<>
+struct cut_enumeration_update_cut<cut_enumeration_mf_cut>
+{
+  template<typename Cut, typename NetworkCuts, typename Ntk>
+  static void apply( Cut& cut, NetworkCuts const& cuts, Ntk const& ntk, node<Ntk> const& n )
+  {
+    uint32_t delay{ 0 };
+    float flow = cut->data.cost = cut.size() < 2 ? 0.0f : 1.0f;
+
+    for ( auto leaf : cut )
+    {
+      const auto& best_leaf_cut = cuts.cuts( leaf )[0];
+      delay = std::max( delay, best_leaf_cut->data.delay );
+      flow += best_leaf_cut->data.flow;
+    }
+
+    cut->data.delay = 1 + delay;
+    cut->data.flow = flow / ntk.fanout_size( n );
+  }
+};
+
+template<int MaxLeaves>
+std::ostream& operator<<( std::ostream& os, cut<MaxLeaves, cut_data<false, cut_enumeration_mf_cut>> const& c )
+{
+  os << "{ ";
+  std::copy( c.begin(), c.end(), std::ostream_iterator<uint32_t>( os, " " ) );
+  os << "}, D = " << std::setw( 3 ) << c->data.delay << " A = " << c->data.flow;
+  return os;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/cut_enumeration/rewrite_cut.hpp b/include/mockturtle/algorithms/cut_enumeration/rewrite_cut.hpp
new file mode 100644
index 0000000..04a8226
--- /dev/null
+++ b/include/mockturtle/algorithms/cut_enumeration/rewrite_cut.hpp
@@ -0,0 +1,88 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file rewrite_cut.hpp
+  \brief Cut enumeration for rewriting
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <iomanip>
+#include <iostream>
+#include <vector>
+
+#include "../cut_enumeration.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Cut implementation for rewrite */
+struct cut_enumeration_rewrite_cut
+{
+  uint32_t cost;
+};
+
+template<bool ComputeTruth>
+bool operator<( cut_type<ComputeTruth, cut_enumeration_rewrite_cut> const& c1, cut_type<ComputeTruth, cut_enumeration_rewrite_cut> const& c2 )
+{
+  if ( c1->data.cost < c2->data.cost )
+    return true;
+  if ( c1->data.cost > c2->data.cost )
+    return false;
+  return c1.size() < c2.size();
+}
+
+template<>
+struct cut_enumeration_update_cut<cut_enumeration_rewrite_cut>
+{
+  template<typename Cut, typename NetworkCuts, typename Ntk>
+  static void apply( Cut& cut, NetworkCuts const& cuts, Ntk const& ntk, node<Ntk> const& n )
+  {
+    uint32_t value = 0;
+
+    for ( auto leaf : cut )
+    {
+      value += ( ntk.fanout_size( ntk.index_to_node( leaf ) ) == 1 ) ? 1u : 0u;
+    }
+
+    cut->data.cost = value;
+  }
+};
+
+template<int MaxLeaves>
+std::ostream& operator<<( std::ostream& os, cut<MaxLeaves, cut_data<false, cut_enumeration_rewrite_cut>> const& c )
+{
+  os << "{ ";
+  std::copy( c.begin(), c.end(), std::ostream_iterator<uint32_t>( os, " " ) );
+  os << "}, C = " << std::setw( 3 ) << c->data.cost;
+  return os;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/cut_enumeration/spectr_cut.hpp b/include/mockturtle/algorithms/cut_enumeration/spectr_cut.hpp
new file mode 100644
index 0000000..d14dfac
--- /dev/null
+++ b/include/mockturtle/algorithms/cut_enumeration/spectr_cut.hpp
@@ -0,0 +1,197 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file spectr_cut.hpp
+  \brief Cut enumeration based on spectral properties of a function
+
+  \author Giulia Meuli
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <iomanip>
+#include <iostream>
+#include <map>
+#include <vector>
+
+#include "../../utils/cuts.hpp"
+#include "../cut_enumeration.hpp"
+#include "../lut_mapping.hpp"
+#include <kitty/constructors.hpp>
+#include <kitty/spectral.hpp>
+#include <kitty/static_truth_table.hpp>
+
+namespace mockturtle
+{
+
+/*! \brief Cut based on spectral properties.
+
+  This cut type uses the number of non-zero coefficients in the cut function as
+  cost function.  It requires truth table computation during cut enumeration
+  or LUT mapping in order to work.
+*/
+struct cut_enumeration_spectr_cut
+{
+  uint32_t delay{ 0u };
+  float flow{ 0.0f };
+  float cost{ 0.0f };
+};
+
+template<bool ComputeTruth>
+bool operator<( cut_type<ComputeTruth, cut_enumeration_spectr_cut> const& c1, cut_type<ComputeTruth, cut_enumeration_spectr_cut> const& c2 )
+{
+  constexpr auto eps{ 0.005f };
+
+  if ( c1.size() == c2.size() )
+  {
+    if ( c1->data.cost < c2->data.cost )
+      return true;
+    if ( c1->data.cost > c2->data.cost )
+      return false;
+  }
+  if ( c1.size() > c2.size() && c1->data.cost < c2->data.cost )
+  {
+    return false;
+  }
+  if ( c1.size() < c2.size() && c1->data.cost > c2->data.cost )
+  {
+    return true;
+  }
+  if ( c1->data.flow < c2->data.flow - eps )
+    return true;
+  if ( c1->data.flow > c2->data.flow + eps )
+    return false;
+  if ( c1->data.delay < c2->data.delay )
+    return true;
+  if ( c1->data.delay > c2->data.delay )
+    return false;
+  return c1.size() > c2.size();
+}
+
+template<>
+struct lut_mapping_update_cuts<cut_enumeration_spectr_cut>
+{
+
+  template<typename Ntk>
+  static void grow_xor_cut( Ntk const& ntk, node<Ntk> const& n, std::map<uint32_t, std::vector<uint32_t>>& node_to_cut )
+  {
+    ntk.foreach_fanin( n, [&]( auto ch ) {
+      auto ch_node = ntk.get_node( ch );
+      if ( ntk.is_xor( ch_node ) )
+      {
+        auto leaves_ch = node_to_cut[ch_node];
+
+        if ( leaves_ch.size() + node_to_cut[n].size() < max_cut_size )
+        {
+          node_to_cut[n].insert( node_to_cut[n].end(), leaves_ch.begin(), leaves_ch.end() );
+        }
+        else
+        {
+          node_to_cut[n].push_back( ch_node );
+        }
+      }
+      else
+      {
+        node_to_cut[n].push_back( ch_node );
+      }
+    } );
+
+    std::stable_sort( node_to_cut[n].begin(), node_to_cut[n].end() );
+    node_to_cut[n].erase( unique( node_to_cut[n].begin(), node_to_cut[n].end() ), node_to_cut[n].end() );
+  }
+
+  template<typename NetworkCuts, typename Ntk>
+  static void apply( NetworkCuts& cuts, Ntk const& ntk )
+  {
+
+    std::map<uint32_t, std::vector<uint32_t>> node_to_cut;
+
+    topo_view<Ntk>( ntk ).foreach_node( [&]( auto n ) {
+      if ( ntk.is_xor( n ) )
+      {
+        const auto index = ntk.node_to_index( n );
+        auto& cut_set = cuts.cuts( index );
+
+        /* clear the cut set of the node */
+        cut_set.clear();
+
+        /* add an empty cut and modify its leaves */
+        grow_xor_cut( ntk, n, node_to_cut );
+
+        auto& my_cut = cut_set.add_cut( node_to_cut[n].begin(), node_to_cut[n].end() );
+
+        assert( node_to_cut[n].size() <= 16 );
+        /* set to zero cost */
+        my_cut->data.cost = 0u;
+
+        /* crate cut truth table */
+        kitty::dynamic_truth_table tt( node_to_cut[n].size() );
+        kitty::create_parity( tt );
+        my_cut->func_id = cuts.insert_truth_table( tt );
+      }
+    } );
+  }
+};
+
+template<>
+struct cut_enumeration_update_cut<cut_enumeration_spectr_cut>
+{
+  template<typename Cut, typename NetworkCuts, typename Ntk>
+  static void apply( Cut& cut, NetworkCuts const& cuts, Ntk const& ntk, node<Ntk> const& n )
+  {
+    uint32_t delay{ 0 };
+
+    auto tt = cuts.truth_table( cut );
+    auto spectrum = kitty::rademacher_walsh_spectrum( tt );
+    cut->data.cost = std::count_if( spectrum.begin(), spectrum.end(), []( auto s ) { return s != 0; } );
+
+    float flow = cut.size() < 2 ? 0.0f : 1.0f;
+    for ( auto leaf : cut )
+    {
+      const auto& best_leaf_cut = cuts.cuts( leaf )[0];
+      delay = std::max( delay, best_leaf_cut->data.delay );
+      flow += best_leaf_cut->data.flow;
+    }
+
+    cut->data.delay = 1 + delay;
+    cut->data.flow = flow / ntk.fanout_size( n );
+  }
+};
+
+template<int MaxLeaves>
+std::ostream& operator<<( std::ostream& os, cut<MaxLeaves, cut_data<false, cut_enumeration_spectr_cut>> const& c )
+{
+  os << "{ ";
+  std::copy( c.begin(), c.end(), std::ostream_iterator<uint32_t>( os, " " ) );
+  os << "}, D = " << std::setw( 3 ) << c->data.delay << " A = " << c->data.flow;
+  return os;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/cut_enumeration/tech_map_cut.hpp b/include/mockturtle/algorithms/cut_enumeration/tech_map_cut.hpp
new file mode 100644
index 0000000..4702a66
--- /dev/null
+++ b/include/mockturtle/algorithms/cut_enumeration/tech_map_cut.hpp
@@ -0,0 +1,100 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file tech_map_cut.hpp
+  \brief Cut enumeration for technology mapping
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <iomanip>
+#include <iostream>
+#include <vector>
+
+#include "../cut_enumeration.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Cut implementation for technology mapping */
+struct cut_enumeration_tech_map_cut
+{
+  uint32_t delay{ 0 };
+  float flow{ 0 };
+  uint8_t match_index{ 0 };
+  bool ignore{ false };
+};
+
+template<bool ComputeTruth>
+bool operator<( cut_type<ComputeTruth, cut_enumeration_tech_map_cut> const& c1, cut_type<ComputeTruth, cut_enumeration_tech_map_cut> const& c2 )
+{
+  constexpr auto eps{ 0.005f };
+  if ( c1.size() < c2.size() )
+    return true;
+  if ( c1.size() > c2.size() )
+    return false;
+  if ( c1->data.delay < c2->data.delay )
+    return true;
+  if ( c1->data.delay > c2->data.delay )
+    return false;
+  return c1->data.flow < c2->data.flow - eps;
+}
+
+template<>
+struct cut_enumeration_update_cut<cut_enumeration_tech_map_cut>
+{
+  template<typename Cut, typename NetworkCuts, typename Ntk>
+  static void apply( Cut& cut, NetworkCuts const& cuts, Ntk const& ntk, node<Ntk> const& n )
+  {
+    uint32_t delay{ 0 };
+    float flow = 1.0f;
+
+    for ( auto leaf : cut )
+    {
+      const auto& best_leaf_cut = cuts.cuts( leaf )[0];
+      delay = std::max( delay, best_leaf_cut->data.delay );
+      flow += best_leaf_cut->data.flow;
+    }
+
+    cut->data.delay = 1 + delay;
+    cut->data.flow = flow / ntk.fanout_size( n );
+  }
+};
+
+template<int MaxLeaves>
+std::ostream& operator<<( std::ostream& os, cut<MaxLeaves, cut_data<false, cut_enumeration_tech_map_cut>> const& c )
+{
+  os << "{ ";
+  std::copy( c.begin(), c.end(), std::ostream_iterator<uint32_t>( os, " " ) );
+  os << "}, D = " << std::setw( 3 ) << c->data.delay << " A = " << c->data.flow;
+  return os;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/cut_rewriting.hpp b/include/mockturtle/algorithms/cut_rewriting.hpp
new file mode 100644
index 0000000..85b1bb8
--- /dev/null
+++ b/include/mockturtle/algorithms/cut_rewriting.hpp
@@ -0,0 +1,870 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cut_rewriting.hpp
+  \brief Cut rewriting
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <iomanip>
+#include <iostream>
+#include <mockturtle/utils/debugging_utils.hpp>
+#include <optional>
+#include <set>
+#include <type_traits>
+#include <vector>
+
+#include "../networks/klut.hpp"
+#include "../networks/mig.hpp"
+#include "../traits.hpp"
+#include "../utils/cost_functions.hpp"
+#include "../utils/node_map.hpp"
+#include "../utils/progress_bar.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../views/cut_view.hpp"
+#include "../views/depth_view.hpp"
+#include "../views/fanout_view.hpp"
+#include "cleanup.hpp"
+#include "cut_enumeration.hpp"
+#include "detail/mffc_utils.hpp"
+#include "dont_cares.hpp"
+
+#include <fmt/format.h>
+#include <kitty/print.hpp>
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for cut_rewriting.
+ *
+ * The data structure `cut_rewriting_params` holds configurable parameters with
+ * default arguments for `cut_rewriting`.
+ */
+struct cut_rewriting_params
+{
+  cut_rewriting_params()
+  {
+    cut_enumeration_ps.cut_size = 6;
+    cut_enumeration_ps.cut_limit = 12;
+    cut_enumeration_ps.minimize_truth_table = true;
+  }
+
+  /*! \brief Cut enumeration parameters. */
+  cut_enumeration_params cut_enumeration_ps{};
+
+  /*! \brief Allow zero-gain substitutions. */
+  bool allow_zero_gain{ false };
+
+  /*! \brief Use don't cares for optimization. */
+  bool use_dont_cares{ false };
+
+  /*! \brief Candidate selection strategy. */
+  enum
+  {
+    minimize_weight,
+    greedy
+  } candidate_selection_strategy = minimize_weight;
+
+  /*! \brief Minimum candidate cut size */
+  uint32_t min_cand_cut_size{ 3u };
+
+  /*! \brief Minimum candidate cut size override (in conflict graph) */
+  std::optional<uint32_t> min_cand_cut_size_override{};
+
+  /*! \brief If true, candidates are only accepted if they do not increase logic level of node. */
+  bool preserve_depth{ false };
+
+  /*! \brief Show progress. */
+  bool progress{ false };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+
+  /*! \brief Be very verbose. */
+  bool very_verbose{ false };
+};
+
+/*! \brief Statistics for cut_rewriting.
+ *
+ * The data structure `cut_rewriting_stats` provides data collected by running
+ * `cut_rewriting`.
+ */
+struct cut_rewriting_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Runtime for cut enumeration. */
+  stopwatch<>::duration time_cuts{ 0 };
+
+  /*! \brief Accumulated runtime for rewriting. */
+  stopwatch<>::duration time_rewriting{ 0 };
+
+  /*! \brief Runtime to find minimal independent set. */
+  stopwatch<>::duration time_mis{ 0 };
+
+  void report( bool show_time_mis = true ) const
+  {
+    fmt::print( "[i] total time     = {:>5.2f} secs\n", to_seconds( time_total ) );
+    fmt::print( "[i] cut enum. time = {:>5.2f} secs\n", to_seconds( time_cuts ) );
+    fmt::print( "[i] rewriting time = {:>5.2f} secs\n", to_seconds( time_rewriting ) );
+    if ( show_time_mis )
+    {
+      fmt::print( "[i] ind. set time  = {:>5.2f} secs\n", to_seconds( time_mis ) );
+    }
+  }
+};
+
+namespace detail
+{
+
+class graph
+{
+public:
+  auto add_vertex( uint32_t weight )
+  {
+    auto index = _weights.size();
+    _weights.emplace_back( weight );
+    _adjacent.emplace_back();
+    ++_num_vertices;
+    return index;
+  }
+
+  void add_edge( uint32_t v1, uint32_t v2 )
+  {
+    if ( v1 == v2 )
+      return;
+    if ( _adjacent[v1].count( v2 ) )
+      return;
+
+    _adjacent[v1].insert( v2 );
+    _adjacent[v2].insert( v1 );
+    ++_num_edges;
+  }
+
+  void remove_vertex( uint32_t vertex )
+  {
+    assert( _weights[vertex] != -1 );
+    _weights[vertex] = -1;
+
+    _num_edges -= _adjacent[vertex].size();
+
+    for ( auto w : _adjacent[vertex] )
+    {
+      _adjacent[w].erase( vertex );
+    }
+    _adjacent[vertex].clear();
+
+    --_num_vertices;
+  }
+
+  bool has_vertex( uint32_t vertex ) const
+  {
+    return _weights[vertex] >= 0;
+  }
+
+  template<typename Fn>
+  void foreach_adjacent( uint32_t vertex, Fn&& fn ) const
+  {
+    std::for_each( _adjacent[vertex].begin(), _adjacent[vertex].end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_vertex( Fn&& fn ) const
+  {
+    for ( auto i = 0u; i < _weights.size(); ++i )
+    {
+      if ( has_vertex( i ) )
+      {
+        fn( i );
+      }
+    }
+  }
+
+  auto degree( uint32_t vertex ) const { return _adjacent[vertex].size(); }
+  auto weight( uint32_t vertex ) const { return _weights[vertex]; }
+  auto gwmin_value( uint32_t vertex ) const { return (double)weight( vertex ) / ( degree( vertex ) + 1 ); }
+  auto gwmax_value( uint32_t vertex ) const { return (double)weight( vertex ) / ( degree( vertex ) * ( degree( vertex ) + 1 ) ); }
+
+  auto num_vertices() const { return _num_vertices; }
+  auto num_edges() const { return _num_edges; }
+
+private:
+  uint32_t _num_vertices{ 0u };
+  std::size_t _num_edges{ 0u };
+
+  std::vector<std::set<uint32_t>> _adjacent;
+
+  std::vector<int32_t> _weights; /* degree = -1 means vertex is removed */
+};
+
+inline std::vector<uint32_t> maximum_weighted_independent_set_gwmin( graph& g )
+{
+  std::vector<uint32_t> mwis;
+
+  std::vector<uint32_t> vertices( g.num_vertices() );
+  std::iota( vertices.begin(), vertices.end(), 0 );
+
+  std::stable_sort( vertices.begin(), vertices.end(), [&g]( auto v, auto w ) {
+    const auto value_v = g.gwmin_value( v );
+    const auto value_w = g.gwmin_value( w );
+    return value_v > value_w || ( value_v == value_w && g.degree( v ) > g.degree( w ) );
+  } );
+
+  for ( auto i : vertices )
+  {
+    if ( !g.has_vertex( i ) )
+      continue;
+
+    /* add vertex to independent set, then remove it and all its neighbors */
+    mwis.emplace_back( i );
+    std::vector<uint32_t> neighbors;
+    g.foreach_adjacent( i, [&]( auto v ) { neighbors.emplace_back( v ); } );
+    g.remove_vertex( i );
+
+    for ( auto v : neighbors )
+    {
+      g.remove_vertex( v );
+    }
+  }
+
+  return mwis;
+}
+
+inline std::vector<uint32_t> maximal_weighted_independent_set( graph& g )
+{
+  std::vector<uint32_t> mwis;
+
+  auto num_vertices = g.num_vertices();
+  for ( auto i = 0u; i < num_vertices; ++i )
+  {
+    if ( !g.has_vertex( i ) )
+      continue;
+
+    /* add vertex to independent set, then remove it and all its neighbors */
+    mwis.emplace_back( i );
+    std::vector<uint32_t> neighbors;
+    g.foreach_adjacent( i, [&]( auto v ) { neighbors.emplace_back( v ); } );
+    g.remove_vertex( i );
+
+    for ( auto v : neighbors )
+    {
+      g.remove_vertex( v );
+    }
+  }
+
+  return mwis;
+}
+
+struct cut_enumeration_cut_rewriting_cut
+{
+  int32_t gain{ -1 };
+};
+
+template<typename Ntk, bool ComputeTruth>
+std::tuple<graph, std::vector<std::pair<node<Ntk>, uint32_t>>> network_cuts_graph( Ntk const& ntk, network_cuts<Ntk, ComputeTruth, cut_enumeration_cut_rewriting_cut> const& cuts, cut_rewriting_params const& ps )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_clear_visited_v<Ntk>, "Ntk does not implement the clear_visited method" );
+
+  graph g;
+
+  using cut_addr = std::pair<node<Ntk>, uint32_t>;
+  std::vector<std::vector<cut_addr>> conflicts( cuts.nodes_size() );
+  std::vector<cut_addr> vertex_to_cut_addr;
+  std::vector<std::vector<uint32_t>> cut_addr_to_vertex( cuts.nodes_size() );
+
+  ntk.clear_visited();
+
+  ntk.foreach_node( [&]( auto const& n, auto index ) {
+    if ( index >= cuts.nodes_size() || ntk.is_constant( n ) || ntk.is_pi( n ) )
+      return;
+
+    if ( mffc_size( ntk, n ) == 1 )
+      return;
+
+    const auto& set = cuts.cuts( ntk.node_to_index( n ) );
+
+    auto cctr{ 0u };
+    for ( auto const& cut : set )
+    {
+      if ( ps.min_cand_cut_size_override )
+      {
+        if ( cut->size() < *ps.min_cand_cut_size_override )
+          continue;
+      }
+      else if ( cut->size() < ps.min_cand_cut_size )
+        continue;
+
+      if ( ( *cut )->data.gain < ( ps.allow_zero_gain ? 0 : 1 ) )
+        continue;
+
+      std::vector<node<Ntk>> leaves;
+      for ( auto leaf_index : *cut )
+      {
+        leaves.push_back( ntk.index_to_node( leaf_index ) );
+      }
+      cut_view<Ntk> dcut( ntk, leaves, ntk.make_signal( n ) );
+      dcut.foreach_gate( [&]( auto const& n2 ) {
+        // if ( dcut.is_constant( n2 ) || dcut.is_pi( n2 ) )
+        //   return;
+        conflicts[ntk.node_to_index( n2 )].emplace_back( n, cctr );
+      } );
+
+      auto v = g.add_vertex( ( *cut )->data.gain );
+      assert( v == vertex_to_cut_addr.size() );
+      vertex_to_cut_addr.emplace_back( n, cctr );
+      cut_addr_to_vertex[ntk.node_to_index( n )].emplace_back( static_cast<uint32_t>( v ) );
+
+      ++cctr;
+    }
+  } );
+
+  for ( auto n = 0u; n < conflicts.size(); ++n )
+  {
+    for ( auto j = 1u; j < conflicts[n].size(); ++j )
+    {
+      for ( auto i = 0u; i < j; ++i )
+      {
+        const auto [n1, c1] = conflicts[n][i];
+        const auto [n2, c2] = conflicts[n][j];
+
+        if ( cut_addr_to_vertex[ntk.node_to_index( n1 )][c1] != cut_addr_to_vertex[ntk.node_to_index( n2 )][c2] )
+        {
+          g.add_edge( cut_addr_to_vertex[ntk.node_to_index( n1 )][c1], cut_addr_to_vertex[ntk.node_to_index( n2 )][c2] );
+        }
+      }
+    }
+  }
+
+  return { g, vertex_to_cut_addr };
+}
+
+template<class Ntk, class RewritingFn, class Iterator, class = void>
+struct has_rewrite_with_dont_cares : std::false_type
+{
+};
+
+template<class Ntk, class RewritingFn, class Iterator>
+struct has_rewrite_with_dont_cares<Ntk,
+                                   RewritingFn, Iterator,
+                                   std::void_t<decltype( std::declval<RewritingFn>()( std::declval<Ntk&>(),
+                                                                                      std::declval<kitty::dynamic_truth_table>(),
+                                                                                      std::declval<kitty::dynamic_truth_table>(),
+                                                                                      std::declval<Iterator const&>(),
+                                                                                      std::declval<Iterator const&>(),
+                                                                                      std::declval<void( signal<Ntk> )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk, class RewritingFn, class Iterator>
+inline constexpr bool has_rewrite_with_dont_cares_v = has_rewrite_with_dont_cares<Ntk, RewritingFn, Iterator>::value;
+
+template<class Ntk, class RewritingFn, class NodeCostFn>
+class cut_rewriting_with_compatibility_graph_impl
+{
+public:
+  cut_rewriting_with_compatibility_graph_impl( Ntk& ntk, RewritingFn&& rewriting_fn, cut_rewriting_params const& ps, cut_rewriting_stats& st, NodeCostFn const& cost_fn )
+      : ntk( ntk ),
+        rewriting_fn( rewriting_fn ),
+        ps( ps ),
+        st( st ),
+        cost_fn( cost_fn ) {}
+
+  void run()
+  {
+    stopwatch t( st.time_total );
+
+    /* enumerate cuts */
+    const auto cuts = call_with_stopwatch( st.time_cuts, [&]() { return cut_enumeration<Ntk, true, cut_enumeration_cut_rewriting_cut>( ntk, ps.cut_enumeration_ps ); } );
+
+    /* for cost estimation we use reference counters initialized by the fanout size */
+    ntk.clear_values();
+    ntk.foreach_node( [&]( auto const& n ) {
+      ntk.set_value( n, ntk.fanout_size( n ) );
+    } );
+
+    /* store best replacement for each cut */
+    node_map<std::vector<signal<Ntk>>, Ntk> best_replacements( ntk );
+
+    /* iterate over all original nodes in the network */
+    const auto size = ntk.size();
+    auto max_total_gain = 0u;
+    progress_bar pbar{ ntk.size(), "cut_rewriting |{0}| node = {1:>4}@{2:>2} / " + std::to_string( size ) + "   comm. gain = {3}", ps.progress };
+    ntk.foreach_node( [&]( auto const& n, auto index ) {
+      /* stop once all original nodes were visited */
+      if ( index >= size )
+        return false;
+
+      /* do not iterate over constants or PIs */
+      if ( ntk.is_constant( n ) || ntk.is_pi( n ) )
+        return true;
+
+      /* skip cuts with small MFFC */
+      if ( mffc_size( ntk, n ) == 1 )
+        return true;
+
+      /* foreach cut */
+      for ( auto& cut : cuts.cuts( ntk.node_to_index( n ) ) )
+      {
+        /* skip trivial cuts */
+        if ( cut->size() < ps.min_cand_cut_size )
+          continue;
+
+        const auto tt = cuts.truth_table( *cut );
+        assert( cut->size() == static_cast<unsigned>( tt.num_vars() ) );
+
+        pbar( index, ntk.node_to_index( n ), best_replacements[n].size(), max_total_gain );
+
+        std::vector<signal<Ntk>> children;
+        for ( auto l : *cut )
+        {
+          children.push_back( ntk.make_signal( ntk.index_to_node( l ) ) );
+        }
+
+        int32_t value = recursive_deref<Ntk, NodeCostFn>( ntk, n );
+        {
+          stopwatch t( st.time_rewriting );
+          int32_t best_gain{ -1 };
+
+          const auto on_signal = [&]( auto const& f_new ) {
+            auto [v, contains] = recursive_ref_contains( ntk.get_node( f_new ), n );
+            recursive_deref<Ntk, NodeCostFn>( ntk, ntk.get_node( f_new ) );
+
+            int32_t gain = contains ? -1 : value - v;
+
+            if ( gain > 0 || ( ps.allow_zero_gain && gain == 0 ) )
+            {
+              if ( best_gain == -1 )
+              {
+                ( *cut )->data.gain = best_gain = gain;
+                best_replacements[n].push_back( f_new );
+              }
+              else if ( gain > best_gain )
+              {
+                ( *cut )->data.gain = best_gain = gain;
+                best_replacements[n].back() = f_new;
+              }
+            }
+
+            return true;
+          };
+
+          if ( ps.use_dont_cares )
+          {
+            if constexpr ( has_rewrite_with_dont_cares_v<Ntk, RewritingFn, decltype( children.begin() )> )
+            {
+              std::vector<node<Ntk>> pivots;
+              for ( auto const& c : children )
+              {
+                pivots.push_back( ntk.get_node( c ) );
+              }
+              rewriting_fn( ntk, cuts.truth_table( *cut ), satisfiability_dont_cares( ntk, pivots ), children.begin(), children.end(), on_signal );
+            }
+            else
+            {
+              rewriting_fn( ntk, cuts.truth_table( *cut ), children.begin(), children.end(), on_signal );
+            }
+          }
+          else
+          {
+            rewriting_fn( ntk, cuts.truth_table( *cut ), children.begin(), children.end(), on_signal );
+          }
+
+          if ( best_gain > 0 )
+          {
+            max_total_gain += best_gain;
+          }
+        }
+
+        recursive_ref<Ntk, NodeCostFn>( ntk, n );
+      }
+
+      return true;
+    } );
+
+    stopwatch t2( st.time_mis );
+    auto [g, map] = network_cuts_graph( ntk, cuts, ps );
+
+    if ( ps.very_verbose )
+    {
+      std::cout << "[i] replacement dependency graph has " << g.num_vertices() << " vertices and " << g.num_edges() << " edges\n";
+    }
+
+    const auto is = ( ps.candidate_selection_strategy == cut_rewriting_params::minimize_weight ) ? maximum_weighted_independent_set_gwmin( g ) : maximal_weighted_independent_set( g );
+
+    if ( ps.very_verbose )
+    {
+      std::cout << "[i] size of independent set is " << is.size() << "\n";
+    }
+
+    for ( const auto v : is )
+    {
+      const auto v_node = map[v].first;
+      const auto v_cut = map[v].second;
+
+      if ( ps.very_verbose )
+      {
+        std::cout << "[i] try to rewrite cut #" << v_cut << " in node #" << ntk.node_to_index( v_node ) << "\n";
+      }
+
+      if ( best_replacements[v_node].empty() )
+        continue;
+
+      const auto replacement = best_replacements[v_node][v_cut];
+
+      if ( ntk.is_constant( ntk.get_node( replacement ) ) || v_node == ntk.get_node( replacement ) )
+        continue;
+
+      if ( ps.very_verbose )
+      {
+        std::cout << "[i] optimize cut #" << v_cut << " in node #" << ntk.node_to_index( v_node ) << " and replace with node " << ntk.node_to_index( ntk.get_node( replacement ) ) << "\n";
+      }
+
+      ntk.substitute_node( v_node, replacement );
+    }
+  }
+
+private:
+  std::pair<int32_t, bool> recursive_ref_contains( node<Ntk> const& n, node<Ntk> const& repl )
+  {
+    /* terminate? */
+    if ( ntk.is_constant( n ) || ntk.is_pi( n ) )
+      return { 0, false };
+
+    /* recursively collect nodes */
+    int32_t value = cost_fn( ntk, n );
+    bool contains = ( n == repl );
+    ntk.foreach_fanin( n, [&]( auto const& s ) {
+      contains = contains || ( ntk.get_node( s ) == repl );
+      if ( ntk.incr_value( ntk.get_node( s ) ) == 0 )
+      {
+        const auto [v, c] = recursive_ref_contains( ntk.get_node( s ), repl );
+        value += v;
+        contains = contains || c;
+      }
+    } );
+    return { value, contains };
+  }
+
+private:
+  Ntk& ntk;
+  RewritingFn&& rewriting_fn;
+  cut_rewriting_params const& ps;
+  cut_rewriting_stats& st;
+  NodeCostFn cost_fn;
+};
+
+} /* namespace detail */
+
+/*! \brief In-place cut rewriting algorithm with compatibility graph.
+ *
+ * This algorithm enumerates cut of a network and then tries to rewrite the cut
+ * in terms of gates of the same network.  The rewritten structures are added
+ * to the network, and if they lead to area improvement, will be used as new
+ * parts of the logic.  The resulting network therefore has a lot of dangling
+ * nodes from unsuccessful candidates, which can be removed by calling
+ * `cleanup_dangling` after the rewriting algorithm.
+ *
+ * The rewriting function must be of type `NtkDest::signal(NtkDest&,
+ * kitty::dynamic_truth_table const&, LeavesIterator, LeavesIterator)` where
+ * `LeavesIterator` can be dereferenced to a `NtkDest::signal`.  The last two
+ * parameters compose an iterator pair where the distance matches the number of
+ * variables of the truth table that is passed as second parameter.  There are
+ * some rewriting algorithms in the folder
+ * `mockturtle/algorithms/node_resynthesis`, since the resynthesis functions
+ * have the same signature.
+ *
+ * In contrast to node resynthesis, cut rewriting uses the same type for the
+ * input and output network.  Consequently, the algorithm does not return a
+ * new network but applies changes in-place to the input network.
+ *
+ * **Required network functions:**
+ * - `fanout_size`
+ * - `foreach_node`
+ * - `foreach_fanin`
+ * - `is_constant`
+ * - `is_pi`
+ * - `clear_values`
+ * - `incr_value`
+ * - `decr_value`
+ * - `set_value`
+ * - `node_to_index`
+ * - `index_to_node`
+ * - `substitute_node`
+ * - `make_signal`
+ *
+ * \param ntk Network (will be modified)
+ * \param rewriting_fn Rewriting function
+ * \param ps Rewriting params
+ * \param pst Rewriting statistics
+ * \param cost_fn Node cost function (a functor with signature `uint32_t(Ntk const&, node<Ntk> const&)`)
+ */
+template<class Ntk, class RewritingFn, class NodeCostFn = unit_cost<Ntk>>
+void cut_rewriting_with_compatibility_graph( Ntk& ntk, RewritingFn&& rewriting_fn, cut_rewriting_params const& ps = {}, cut_rewriting_stats* pst = nullptr, NodeCostFn const& cost_fn = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_incr_value_v<Ntk>, "Ntk does not implement the incr_value method" );
+  static_assert( has_decr_value_v<Ntk>, "Ntk does not implement the decr_value method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the substitute_node method" );
+  static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+
+  cut_rewriting_stats st;
+  if constexpr ( std::is_same_v<typename Ntk::base_type, klut_network> )
+  {
+    detail::cut_rewriting_with_compatibility_graph_impl<Ntk, RewritingFn, NodeCostFn> p( ntk, rewriting_fn, ps, st, cost_fn );
+    p.run();
+  }
+  else
+  {
+    fanout_view_params fvps;
+    fvps.update_on_delete = false;
+    fanout_view<Ntk> ntk_fo{ ntk, fvps };
+    detail::cut_rewriting_with_compatibility_graph_impl<fanout_view<Ntk>, RewritingFn, NodeCostFn> p( ntk_fo, rewriting_fn, ps, st, cost_fn );
+    p.run();
+  }
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+namespace detail
+{
+
+template<class NtkDest, class Ntk, class RewritingFn, class NodeCostFn>
+struct cut_rewriting_impl
+{
+  cut_rewriting_impl( Ntk const& ntk, RewritingFn const& rewriting_fn, cut_rewriting_params const& ps, cut_rewriting_stats& st )
+      : ntk_( ntk ),
+        rewriting_fn_( rewriting_fn ),
+        ps_( ps ),
+        st_( st ) {}
+
+  NtkDest run()
+  {
+    stopwatch t( st_.time_total );
+
+    /* initial node map */
+    node_map<signal<Ntk>, Ntk> old2new( ntk_ );
+    Ntk res;
+    old2new[ntk_.get_constant( false )] = res.get_constant( false );
+    if ( ntk_.get_node( ntk_.get_constant( true ) ) != ntk_.get_node( ntk_.get_constant( false ) ) )
+    {
+      old2new[ntk_.get_constant( true )] = res.get_constant( true );
+    }
+    ntk_.foreach_pi( [&]( auto const& n ) {
+      old2new[n] = res.create_pi();
+    } );
+
+    /* enumerate cuts */
+    const auto cuts = call_with_stopwatch( st_.time_cuts, [&]() { return cut_enumeration<Ntk, true, cut_enumeration_cut_rewriting_cut>( ntk_, ps_.cut_enumeration_ps ); } );
+
+    /* for cost estimation we use reference counters initialized by the fanout size */
+    initialize_values_with_fanout( ntk_ );
+
+    /* original cost */
+    const auto orig_cost = costs<Ntk, NodeCostFn>( ntk_ );
+
+    progress_bar pbar{ ntk_.num_gates(), "cut_rewriting |{0}| node = {1:>4} / " + std::to_string( ntk_.num_gates() ) + "   original cost = " + std::to_string( orig_cost ), ps_.progress };
+    ntk_.foreach_gate( [&]( auto const& n, auto i ) {
+      pbar( i, i );
+
+      /* nothing to optimize? */
+      int32_t value = mffc_size<Ntk, NodeCostFn>( ntk_, n );
+      if ( value == 1 )
+      {
+        std::vector<signal<Ntk>> children( ntk_.fanin_size( n ) );
+        ntk_.foreach_fanin( n, [&]( auto const& f, auto i ) {
+          children[i] = ntk_.is_complemented( f ) ? res.create_not( old2new[f] ) : old2new[f];
+        } );
+
+        old2new[n] = res.clone_node( ntk_, n, children );
+      }
+      else
+      {
+        /* foreach cut */
+        int32_t best_gain = -1;
+        signal<Ntk> best_signal;
+        for ( auto& cut : cuts.cuts( ntk_.node_to_index( n ) ) )
+        {
+          /* skip small enough cuts */
+          if ( cut->size() == 1 || cut->size() < ps_.min_cand_cut_size )
+            continue;
+
+          const auto tt = cuts.truth_table( *cut );
+          assert( cut->size() == static_cast<unsigned>( tt.num_vars() ) );
+
+          std::vector<signal<Ntk>> children( cut->size() );
+          auto ctr = 0u;
+          for ( auto l : *cut )
+          {
+            children[ctr++] = old2new[ntk_.index_to_node( l )];
+          }
+
+          const auto on_signal = [&]( auto const& f_new ) {
+            auto value2 = recursive_ref<Ntk, NodeCostFn>( res, res.get_node( f_new ) );
+            recursive_deref<Ntk, NodeCostFn>( res, res.get_node( f_new ) );
+            int32_t gain = value - value2;
+
+            if ( ( gain > 0 || ( ps_.allow_zero_gain && gain == 0 ) ) && gain > best_gain )
+            {
+              if constexpr ( has_level_v<Ntk> )
+              {
+                if ( !ps_.preserve_depth || res.level( res.get_node( f_new ) ) <= ntk_.level( n ) )
+                {
+                  best_gain = gain;
+                  best_signal = f_new;
+                }
+              }
+              else
+              {
+                best_gain = gain;
+                best_signal = f_new;
+              }
+            }
+
+            return true;
+          };
+          stopwatch<> t( st_.time_rewriting );
+          rewriting_fn_( res, cuts.truth_table( *cut ), children.begin(), children.end(), on_signal );
+        }
+
+        if ( best_gain == -1 )
+        {
+          std::vector<signal<Ntk>> children( ntk_.fanin_size( n ) );
+          ntk_.foreach_fanin( n, [&]( auto const& f, auto i ) {
+            children[i] = ntk_.is_complemented( f ) ? res.create_not( old2new[f] ) : old2new[f];
+          } );
+
+          old2new[n] = res.clone_node( ntk_, n, children );
+        }
+        else
+        {
+          old2new[n] = best_signal;
+        }
+      }
+
+      recursive_ref<Ntk, NodeCostFn>( res, res.get_node( old2new[n] ) );
+    } );
+
+    /* create POs */
+    ntk_.foreach_po( [&]( auto const& f ) {
+      res.create_po( ntk_.is_complemented( f ) ? res.create_not( old2new[f] ) : old2new[f] );
+    } );
+
+    mockturtle::print(res);
+    NtkDest ret = cleanup_dangling<NtkDest>( res );
+
+    /* new costs */
+    return costs<NtkDest, NodeCostFn>( ret ) > orig_cost ? static_cast<NtkDest>( ntk_ ) : ret;
+  }
+
+private:
+  Ntk const& ntk_;
+  RewritingFn const& rewriting_fn_;
+  cut_rewriting_params const& ps_;
+  cut_rewriting_stats& st_;
+};
+
+} // namespace detail
+
+/*! \brief Cut rewriting algorithm.
+ *
+ * This algorithm enumerates cut of a network and then tries to rewrite the cut
+ * in terms of gates of the same network.  The rewritten structures are added
+ * to the network, and if they lead to area improvement, will be used as new
+ * parts of the logic.
+ *
+ * The rewriting function must be of type `NtkDest::signal(NtkDest&,
+ * kitty::dynamic_truth_table const&, LeavesIterator, LeavesIterator)` where
+ * `LeavesIterator` can be dereferenced to a `NtkDest::signal`.  The last two
+ * parameters compose an iterator pair where the distance matches the number of
+ * variables of the truth table that is passed as second parameter.  There are
+ * some rewriting algorithms in the folder
+ * `mockturtle/algorithms/node_resynthesis`, since the resynthesis functions
+ * have the same signature.
+ *
+ * In contrast to node resynthesis, cut rewriting uses the same type for the
+ * input and output network.
+ *
+ * \param ntk Network
+ * \param rewriting_fn Rewriting function
+ * \param ps Rewriting params
+ * \param pst Rewriting statistics
+ */
+template<class Ntk, class RewritingFn, class NodeCostFn = unit_cost<Ntk>>
+Ntk cut_rewriting( Ntk const& ntk, RewritingFn const& rewriting_fn = {}, cut_rewriting_params const& ps = {}, cut_rewriting_stats* pst = nullptr )
+{
+  cut_rewriting_stats st;
+  const auto result = [&]() {
+    if ( ps.preserve_depth )
+    {
+      depth_view<Ntk, NodeCostFn> depth_ntk{ ntk };
+      return detail::cut_rewriting_impl<Ntk, depth_view<Ntk, NodeCostFn>, RewritingFn, NodeCostFn>( depth_ntk, rewriting_fn, ps, st ).run();
+    }
+    else
+    {
+      return detail::cut_rewriting_impl<Ntk, Ntk, RewritingFn, NodeCostFn>( ntk, rewriting_fn, ps, st ).run();
+    }
+  }();
+
+  if ( ps.verbose )
+  {
+    st.report( false );
+  }
+  if ( pst )
+  {
+    *pst = st;
+  }
+
+  ntk.clear_values();
+  return result;
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/decomposition.hpp b/include/mockturtle/algorithms/decomposition.hpp
new file mode 100644
index 0000000..541de0b
--- /dev/null
+++ b/include/mockturtle/algorithms/decomposition.hpp
@@ -0,0 +1,301 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file decomposition.hpp
+  \brief Shannon and Davio decomposition
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <unordered_map>
+#include <vector>
+
+#include "../traits.hpp"
+#include "node_resynthesis/null.hpp"
+
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/hash.hpp>
+#include <kitty/operations.hpp>
+#include <kitty/operators.hpp>
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+template<class Ntk, class SynthesisFn>
+class shannon_decomposition_impl
+{
+public:
+  shannon_decomposition_impl( Ntk& ntk, kitty::dynamic_truth_table const& func, std::vector<uint32_t> const& vars, std::vector<signal<Ntk>> const& children, SynthesisFn const& resyn )
+      : ntk_( ntk ),
+        func_( func ),
+        vars_( vars ),
+        pis_( children ),
+        resyn_( resyn )
+  {
+    cache_.insert( { func.construct(), ntk_.get_constant( false ) } );
+
+    for ( auto i = 0u; i < pis_.size(); ++i )
+    {
+      auto var = func.construct();
+      kitty::create_nth_var( var, i );
+      cache_.insert( { func.construct(), pis_[i] } );
+    }
+  }
+
+  signal<Ntk> run()
+  {
+    return decompose( 0u, func_ );
+  }
+
+private:
+  signal<Ntk> decompose( uint32_t var_index, kitty::dynamic_truth_table const& func )
+  {
+    /* cache lookup... */
+    auto it = cache_.find( func );
+    if ( it != cache_.end() )
+    {
+      return it->second;
+    }
+
+    /* ...and for the complement */
+    it = cache_.find( ~func );
+    if ( it != cache_.end() )
+    {
+      return ntk_.create_not( it->second );
+    }
+
+    signal<Ntk> f;
+    if ( var_index == vars_.size() )
+    {
+      auto copy = func;
+      const auto support = kitty::min_base_inplace( copy );
+      const auto small_func = kitty::shrink_to( copy, static_cast<unsigned int>( support.size() ) );
+      std::vector<signal<Ntk>> small_pis( support.size() );
+      for ( auto i = 0u; i < support.size(); ++i )
+      {
+        small_pis[i] = pis_[support[i]];
+      }
+      resyn_( ntk_, small_func, small_pis.begin(), small_pis.end(), [&]( auto const& _f ) {
+        f = _f;
+        return false;
+      } );
+    }
+    else
+    {
+      /* decompose */
+      const auto f0 = decompose( var_index + 1, kitty::cofactor0( func, vars_[var_index] ) );
+      const auto f1 = decompose( var_index + 1, kitty::cofactor1( func, vars_[var_index] ) );
+      f = ntk_.create_ite( pis_[vars_[var_index]], f1, f0 );
+    }
+    cache_.insert( { func, f } );
+    return f;
+  }
+
+private:
+  Ntk& ntk_;
+  kitty::dynamic_truth_table func_;
+  std::vector<uint32_t> vars_;
+  std::vector<signal<Ntk>> const& pis_;
+  SynthesisFn const& resyn_;
+  std::unordered_map<kitty::dynamic_truth_table, signal<Ntk>, kitty::hash<kitty::dynamic_truth_table>> cache_;
+};
+
+template<class Ntk, class SynthesisFn>
+class davio_decomposition_impl
+{
+public:
+  davio_decomposition_impl( Ntk& ntk, bool polarity, kitty::dynamic_truth_table const& func, std::vector<uint32_t> const& vars, std::vector<signal<Ntk>> const& children, SynthesisFn const& resyn )
+      : ntk_( ntk ),
+        polarity_( polarity ),
+        func_( func ),
+        pis_( children ),
+        vars_( vars ),
+        resyn_( resyn )
+  {
+    cache_.insert( { func.construct(), ntk_.get_constant( false ) } );
+
+    for ( auto i = 0u; i < pis_.size(); ++i )
+    {
+      auto var = func.construct();
+      kitty::create_nth_var( var, i );
+      cache_.insert( { func.construct(), pis_[i] } );
+    }
+  }
+
+  signal<Ntk> run()
+  {
+    return decompose( 0u, func_ );
+  }
+
+private:
+  signal<Ntk> decompose( uint32_t var_index, kitty::dynamic_truth_table const& func )
+  {
+    /* cache lookup... */
+    auto it = cache_.find( func );
+    if ( it != cache_.end() )
+    {
+      return it->second;
+    }
+
+    /* ...and for the complement */
+    it = cache_.find( ~func );
+    if ( it != cache_.end() )
+    {
+      return ntk_.create_not( it->second );
+    }
+
+    signal<Ntk> f;
+    if ( var_index == vars_.size() )
+    {
+      auto copy = func;
+      const auto support = kitty::min_base_inplace( copy );
+      const auto small_func = kitty::shrink_to( copy, static_cast<unsigned int>( support.size() ) );
+      std::vector<signal<Ntk>> small_pis( support.size() );
+      for ( auto i = 0u; i < support.size(); ++i )
+      {
+        small_pis[i] = pis_[support[i]];
+      }
+      resyn_( ntk_, small_func, small_pis.begin(), small_pis.end(), [&]( auto const& _f ) {
+        f = _f;
+        return false;
+      } );
+    }
+    else
+    {
+      /* decompose */
+      const auto f0 = decompose( var_index + 1, kitty::cofactor0( func, vars_[var_index] ) );
+      const auto f1 = decompose( var_index + 1, kitty::cofactor1( func, vars_[var_index] ) );
+
+      if ( polarity_ )
+      {
+        f = ntk_.create_xor( f0, ntk_.create_and( pis_[vars_[var_index]], ntk_.create_xor( f0, f1 ) ) );
+      }
+      else
+      {
+        f = ntk_.create_xor( f1, ntk_.create_and( ntk_.create_not( pis_[vars_[var_index]] ), ntk_.create_xor( f0, f1 ) ) );
+      }
+    }
+    cache_.insert( { func, f } );
+    return f;
+  }
+
+private:
+  Ntk& ntk_;
+  bool polarity_;
+  kitty::dynamic_truth_table func_;
+  std::vector<signal<Ntk>> const& pis_;
+  std::vector<uint32_t> const& vars_;
+  SynthesisFn const& resyn_;
+  std::unordered_map<kitty::dynamic_truth_table, signal<Ntk>, kitty::hash<kitty::dynamic_truth_table>> cache_;
+};
+
+} // namespace detail
+
+/*! \brief Shannon decomposition
+ *
+ * This function applies Shannon decomposition on an input truth table and
+ * constructs a network based.  The variable ordering can be specified as
+ * an input.  If not all variables are specified, the remaining co-factors
+ * are synthesizes using the resynthesis function.
+ *
+ * **Required network functions:**
+ * - `create_not`
+ * - `create_ite`
+ * - `get_constant`
+ */
+template<class Ntk, class SynthesisFn = null_resynthesis<Ntk>>
+signal<Ntk> shannon_decomposition( Ntk& ntk, kitty::dynamic_truth_table const& func, std::vector<uint32_t> const& vars, std::vector<signal<Ntk>> const& children, SynthesisFn const& resyn = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+  static_assert( has_create_ite_v<Ntk>, "Ntk does not implement the create_ite method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+
+  detail::shannon_decomposition_impl<Ntk, SynthesisFn> impl( ntk, func, vars, children, resyn );
+  return impl.run();
+}
+
+/*! \brief Positive Davio decomposition
+ *
+ * This function applies positive Davio decomposition on an input truth table and
+ * constructs a network based.  The variable ordering can be specified as
+ * an input.  If not all variables are specified, the remaining co-factors
+ * are synthesizes using the resynthesis function.
+ *
+ * **Required network functions:**
+ * - `create_not`
+ * - `create_and`
+ * - `create_xor`
+ * - `get_constant`
+ */
+template<class Ntk, class SynthesisFn = null_resynthesis<Ntk>>
+signal<Ntk> positive_davio_decomposition( Ntk& ntk, kitty::dynamic_truth_table const& func, std::vector<uint32_t> const& vars, std::vector<signal<Ntk>> const& children, SynthesisFn const& resyn = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+  static_assert( has_create_and_v<Ntk>, "Ntk does not implement the create_ite method" );
+  static_assert( has_create_xor_v<Ntk>, "Ntk does not implement the create_ite method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+
+  detail::davio_decomposition_impl<Ntk, SynthesisFn> impl( ntk, true, func, vars, children, resyn );
+  return impl.run();
+}
+
+/*! \brief Negative Davio decomposition
+ *
+ * This function applies positive Davio decomposition on an input truth table and
+ * constructs a network based.  The variable ordering can be specified as
+ * an input.  If not all variables are specified, the remaining co-factors
+ * are synthesizes using the resynthesis function.
+ *
+ * **Required network functions:**
+ * - `create_not`
+ * - `create_and`
+ * - `create_xor`
+ * - `get_constant`
+ */
+template<class Ntk, class SynthesisFn = null_resynthesis<Ntk>>
+signal<Ntk> negative_davio_decomposition( Ntk& ntk, kitty::dynamic_truth_table const& func, std::vector<uint32_t> const& vars, std::vector<signal<Ntk>> const& children, SynthesisFn const& resyn = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+  static_assert( has_create_and_v<Ntk>, "Ntk does not implement the create_ite method" );
+  static_assert( has_create_xor_v<Ntk>, "Ntk does not implement the create_ite method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+
+  detail::davio_decomposition_impl<Ntk, SynthesisFn> impl( ntk, false, func, vars, children, resyn );
+  return impl.run();
+}
+
+} // namespace mockturtle
diff --git a/include/mockturtle/algorithms/detail/database_generator.hpp b/include/mockturtle/algorithms/detail/database_generator.hpp
new file mode 100644
index 0000000..49414c0
--- /dev/null
+++ b/include/mockturtle/algorithms/detail/database_generator.hpp
@@ -0,0 +1,96 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file database_generator.hpp
+  \brief Utility class to generate a database in form of a logic
+         network from functions.
+
+  \author Heinz Riener
+*/
+
+#pragma once
+
+#include <kitty/print.hpp>
+#include <kitty/properties.hpp>
+
+#include <vector>
+
+namespace mockturtle::detail
+{
+
+struct database_generator_params
+{
+  uint32_t num_vars{ 4u };
+  bool multiple_candidates{ false };
+  bool verbose{ false };
+}; /* database_generator_param */
+
+template<typename Ntk, typename ResynFn>
+class database_generator
+{
+public:
+  using signal = mockturtle::signal<Ntk>;
+
+public:
+  explicit database_generator( Ntk& ntk, ResynFn const& resyn, database_generator_params const& ps )
+      : ntk( ntk ), resyn( resyn ), ps( ps )
+  {
+    for ( auto i = 0u; i < ps.num_vars; ++i )
+    {
+      pis.emplace_back( ntk.create_pi() );
+    }
+  }
+
+  void add_function( kitty::dynamic_truth_table tt )
+  {
+    /* normalize the function first if necessary */
+    if ( !kitty::is_normal( tt ) )
+    {
+      tt = ~tt;
+    }
+
+    /* resynthesize the function and add it to the database */
+    resyn( ntk, tt, std::begin( pis ), std::end( pis ),
+           [&]( const signal& s ) {
+             if ( ps.verbose )
+             {
+               std::cout << "[i] function: ";
+               kitty::print_binary( tt );
+               std::cout << " stored at PO #" << ntk.num_pos() << std::endl;
+             }
+             ntk.create_po( s );
+             return ps.multiple_candidates;
+           } );
+  }
+
+  Ntk& ntk;
+  ResynFn const& resyn;
+  database_generator_params const& ps;
+
+  std::vector<signal> pis;
+}; /* database_generator */
+
+} // namespace mockturtle::detail
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/detail/mffc_utils.hpp b/include/mockturtle/algorithms/detail/mffc_utils.hpp
new file mode 100644
index 0000000..94da045
--- /dev/null
+++ b/include/mockturtle/algorithms/detail/mffc_utils.hpp
@@ -0,0 +1,135 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mffc_utils.hpp
+  \brief Utility functions for DAG-aware reference counting and
+         MFFC-size computation
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+
+#include "../../traits.hpp"
+#include "../../utils/cost_functions.hpp"
+
+namespace mockturtle::detail
+{
+
+template<class Ntk>
+void initialize_values_with_fanout( Ntk& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+
+  ntk.clear_values();
+  ntk.foreach_node( [&]( auto const& n ) {
+    ntk.set_value( n, ntk.fanout_size( n ) );
+  } );
+}
+
+template<typename Ntk, typename TermCond, class NodeCostFn = unit_cost<Ntk>>
+uint32_t recursive_deref( Ntk const& ntk, node<Ntk> const& n, TermCond const& terminate )
+{
+  /* terminate? */
+  if ( terminate( n ) )
+    return 0;
+
+  /* recursively collect nodes */
+  uint32_t value = NodeCostFn{}( ntk, n );
+  ntk.foreach_fanin( n, [&]( auto const& s ) {
+    if ( ntk.decr_value( ntk.get_node( s ) ) == 0 )
+    {
+      value += recursive_deref<Ntk, TermCond, NodeCostFn>( ntk, ntk.get_node( s ), terminate );
+    }
+  } );
+  return value;
+}
+
+template<typename Ntk, typename TermCond, class NodeCostFn = unit_cost<Ntk>>
+uint32_t recursive_ref( Ntk const& ntk, node<Ntk> const& n, TermCond const& terminate )
+{
+  /* terminate? */
+  if ( terminate( n ) )
+    return 0;
+
+  /* recursively collect nodes */
+  uint32_t value = NodeCostFn{}( ntk, n );
+  ntk.foreach_fanin( n, [&]( auto const& s ) {
+    if ( ntk.incr_value( ntk.get_node( s ) ) == 0 )
+    {
+      value += recursive_ref<Ntk, TermCond, NodeCostFn>( ntk, ntk.get_node( s ), terminate );
+    }
+  } );
+  return value;
+}
+
+template<typename Ntk, typename LeavesIterator, class NodeCostFn = unit_cost<Ntk>>
+uint32_t recursive_deref( Ntk const& ntk, node<Ntk> const& n, LeavesIterator begin, LeavesIterator end )
+{
+  const auto terminate = [&]( auto const& n ) { return std::find( begin, end, n ) != end; };
+  return recursive_deref<Ntk, decltype( terminate ), NodeCostFn>( ntk, n, terminate );
+}
+
+template<typename Ntk, typename LeavesIterator, class NodeCostFn = unit_cost<Ntk>>
+uint32_t recursive_ref( Ntk const& ntk, node<Ntk> const& n, LeavesIterator begin, LeavesIterator end )
+{
+  const auto terminate = [&]( auto const& n ) { return std::find( begin, end, n ) != end; };
+  return recursive_ref<Ntk, decltype( terminate ), NodeCostFn>( ntk, n, terminate );
+}
+
+template<typename Ntk, class NodeCostFn = unit_cost<Ntk>>
+uint32_t recursive_deref( Ntk const& ntk, node<Ntk> const& n )
+{
+  const auto terminate = [&]( auto const& n ) { return ntk.is_constant( n ) || ntk.is_pi( n ); };
+  return recursive_deref<Ntk, decltype( terminate ), NodeCostFn>( ntk, n, terminate );
+}
+
+template<typename Ntk, class NodeCostFn = unit_cost<Ntk>>
+uint32_t recursive_ref( Ntk const& ntk, node<Ntk> const& n )
+{
+  const auto terminate = [&]( auto const& n ) { return ntk.is_constant( n ) || ntk.is_pi( n ); };
+  return recursive_ref<Ntk, decltype( terminate ), NodeCostFn>( ntk, n, terminate );
+}
+
+template<typename Ntk, class NodeCostFn = unit_cost<Ntk>>
+uint32_t mffc_size( Ntk const& ntk, node<Ntk> const& n )
+{
+  auto v1 = recursive_deref<Ntk, NodeCostFn>( ntk, n );
+  auto v2 = recursive_ref<Ntk, NodeCostFn>( ntk, n );
+  assert( v1 == v2 );
+  (void)v2;
+  return v1;
+}
+
+} /* namespace mockturtle::detail */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/detail/minmc_xags.hpp b/include/mockturtle/algorithms/detail/minmc_xags.hpp
new file mode 100644
index 0000000..4575564
--- /dev/null
+++ b/include/mockturtle/algorithms/detail/minmc_xags.hpp
@@ -0,0 +1,198 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file minmc_xags.hpp
+  \brief Optimum MC XAGs up to 5 variables
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <tuple>
+#include <vector>
+
+namespace mockturtle::detail
+{
+
+// These circuits are based on Cryptology ePrint Archive: Report 2015/848
+// Meltem Sönmez Turan and Rene Péralta:
+// The Multiplicative Complexity of Boolean Functions on Four and Five Variables
+
+// These circuits have been resynthesized to match the affine representative
+// in kitty::hybrid_exact_spectral_canonization
+
+// The original (and partly revised) networks are kept in the legacy namespace
+// below
+
+// clang-format off
+static std::vector<std::vector<std::tuple<uint32_t, uint64_t, std::vector<uint32_t>, std::string>>> minmc_xags = {
+  {{0, 0x0, {1 << 8 | 0, 0}, "0"}},
+  {{0, 0x0, {1 << 8 | 0, 0}, "0"}},
+  {{0, 0x0, {1 << 8 | 0, 0},                 "0"},
+   {1, 0x8, {1 << 16 | 1 << 8 | 2, 2, 4, 6}, "(ab)"}},
+  {{0, 0x00, {1 << 8 | 0, 0},                        "0"},
+   {2, 0x88, {1 << 16 | 1 << 8 | 2, 2, 4, 6},        "(ab)"},
+   {1, 0x80, {2 << 16 | 1 << 8 | 3, 2, 4, 6, 8, 10}, "(abc)"}},
+  {{0, 0x0000, {1 << 8 | 0, 0},                                                "0"},
+   {1, 0x8000, {3 << 16 | 1 << 8 | 4, 2, 4, 6, 8, 10, 12, 14},                 "(abcd)"},
+   {2, 0x8080, {2 << 16 | 1 << 8 | 3, 2, 4, 6, 8, 10},                         "(abc)"},
+   {3, 0x0888, {4 << 16 | 1 << 8 | 4, 2, 4, 6, 10, 8, 12, 14, 10, 16},         "[(abcd)(ab)]"},
+   {4, 0x8888, {1 << 16 | 1 << 8 | 2, 2, 4, 6},                                "(ab)"},
+   {5, 0x2a80, {3 << 16 | 1 << 8 | 4, 4, 6, 10, 8, 2, 12, 14},                 "[(abc)(ad)]"},
+   {6, 0xf888, {5 << 16 | 1 << 8 | 4, 2, 4, 6, 8, 10, 12, 14, 10, 16, 12, 18}, "[(abcd)(ab)(cd)]"},
+   {7, 0x7888, {3 << 16 | 1 << 8 | 4, 2, 4, 6, 8, 12, 10, 14},                 "[(ab)(cd)]"}},
+  {{ 0, 0x00000000, {1 << 8 | 0, 0},                                                                                                             "0"},
+   { 1, 0x80000000, {4 << 16 | 1 << 8 | 5, 2, 4, 6, 8, 12, 14, 10, 16, 18},                                                                      "(abcde)"},
+   { 2, 0x80008000, {3 << 16 | 1 << 8 | 4, 2, 4, 6, 8, 10, 12, 14},                                                                              "(abcd)"},
+   { 3, 0x00808080, {5 << 16 | 1 << 8 | 5, 2, 4, 6, 12, 8, 14, 10, 16, 18, 14, 20},                                                              "[(abcde)(abc)]"},
+   { 4, 0x80808080, {2 << 16 | 1 << 8 | 3, 2, 4, 6, 8, 10},                                                                                      "(abc)"},
+   { 5, 0x08888000, {4 << 16 | 1 << 8 | 5, 2, 4, 6, 8, 14, 10, 12, 16, 18},                                                                      "[(abcd)(abe)]"},
+   { 6, 0xaa2a2a80, {7 << 16 | 1 << 8 | 5, 4, 6, 12, 8, 2, 14, 8, 16, 18, 2, 10, 20, 22, 16, 24},                                                "[(abc)(ad)(ae)(ade)(abcde)]"},
+   { 7, 0x88080808, {6 << 16 | 1 << 8 | 5, 2, 4, 6, 12, 8, 14, 10, 16, 18, 12, 20, 14, 22},                                                      "[(abcde)(abc)(ab)]"},
+   { 8, 0x2888a000, {4 << 16 | 1 << 8 | 5, 4, 10, 6, 8, 14, 12, 2, 16, 18},                                                                      "[(acd)(abe)]"},
+   { 9, 0xf7788000, {8 << 16 | 1 << 8 | 5, 6, 8, 2, 4, 12, 10, 8, 6, 18, 10, 20, 14, 16, 22, 24, 10, 26},                                        "[(abcd)(abe)(ce)(de)(cde)]"},
+   {10, 0xa8202020, {5 << 16 | 1 << 8 | 5, 8, 10, 12, 6, 4, 14, 16, 6, 2, 18, 20},                                                               "[(ac)(abc)(abde)]"},
+   {11, 0x08880888, {4 << 16 | 1 << 8 | 4, 2, 4, 6, 10, 8, 12, 14, 10, 16},                                                                      "[(abcd)(ab)]"},
+   {12, 0xbd686868, {8 << 16 | 1 << 8 | 5, 8, 10, 12, 4, 2, 14, 4, 6, 16, 6, 18, 2, 20, 22, 24, 12, 26},                                         "[(ab)(ac)(bc)(abc)(de)(ade)(abcde)]"},
+   {13, 0xaa808080, {6 << 16 | 1 << 8 | 5, 4, 6, 8, 10, 12, 14, 14, 12, 18, 16, 2, 20, 22},                                                      "[(abcde)(abc)(ade)]"},
+   {14, 0x7e686868, {9 << 16 | 1 << 8 | 5, 8, 10, 12, 4, 12, 2, 14, 16, 2, 6, 18, 6, 20, 14, 22, 24, 26, 12, 28},                                "[(ab)(ac)(bc)(abc)(ade)(bde)(cde)(abcde)]"},
+   {15, 0x2208a208, {7 << 16 | 1 << 8 | 5, 2, 4, 6, 12, 10, 14, 14, 8, 18, 12, 16, 2, 20, 22, 24},                                               "[(ab)(abc)(ad)(abcde)]"},
+   {16, 0x08888888, {5 << 16 | 1 << 8 | 5, 2, 4, 6, 12, 8, 14, 10, 16, 18, 12, 20},                                                              "[(abcde)(ab)]"},
+   {17, 0x88888888, {1 << 16 | 1 << 8 | 2, 2, 4, 6},                                                                                             "(ab)"},
+   {18, 0xea404040, {5 << 16 | 1 << 8 | 5, 4, 6, 8, 10, 14, 12, 2, 16, 18, 12, 20},                                                              "[(abc)(ade)(bc)]"},
+   {19, 0x2a802a80, {3 << 16 | 1 << 8 | 4, 4, 6, 10, 8, 2, 12, 14},                                                                              "[(abc)(ad)]"},
+   {20, 0x73d28c88, {9 << 16 | 1 << 8 | 5, 2, 4, 10, 4, 14, 12, 8, 16, 18, 10, 6, 2, 20, 22, 18, 12, 26, 24, 28},                                "[(ab)(bd)(abd)(bcd)(abcd)(ae)(ce)(de)(ade)(cde)]"},
+   {21, 0xea808080, {6 << 16 | 1 << 8 | 5, 4, 6, 12, 2, 8, 10, 16, 2, 14, 18, 20, 2, 22},                                                        "[(bcde)(abc)(ade)]"},
+   {22, 0xa28280a0, {6 << 16 | 1 << 8 | 5, 6, 8, 12, 10, 4, 2, 14, 16, 18, 6, 2, 20, 22},                                                        "[(ac)(acd)(abcd)(ae)(abe)]"},
+   {23, 0x13284c88, {8 << 16 | 1 << 8 | 5, 2, 6, 12, 2, 4, 14, 12, 8, 16, 10, 20, 4, 18, 22, 24, 16, 26},                                        "[(ab)(bd)(abd)(abcd)(ace)(de)]"},
+   {24, 0xa2220888, {5 << 16 | 1 << 8 | 5, 6, 8, 4, 12, 14, 4, 16, 10, 2, 18, 20},                                                               "[(ab)(abcd)(ae)]"},
+   {25, 0xaae6da80, {12 << 16 | 1 << 8 | 5, 4, 6, 12, 10, 4, 2, 14, 16, 18, 12, 20, 6, 10, 22, 24, 6, 26, 2, 8, 28, 30, 18, 32, 12, 34},         "[(abc)(ad)(cd)(ae)(be)(ade)(bde)(cde)(abcde)]"},
+   {26, 0x58d87888, {9 << 16 | 1 << 8 | 5, 2, 4, 8, 2, 6, 14, 16, 6, 10, 18, 12, 6, 20, 2, 22, 24, 26, 16, 28},                                  "[(ab)(cd)(ce)(ace)(cde)(abcde)]"},
+   {27, 0x8c88ac28, {8 << 16 | 1 << 8 | 5, 6, 10, 12, 4, 2, 14, 4, 8, 16, 6, 18, 2, 20, 22, 24, 18, 26},                                         "[(ab)(ac)(bd)(abd)(bcd)(ace)(abcde)]"},
+   {28, 0x8880f880, {7 << 16 | 1 << 8 | 5, 2, 4, 12, 6, 8, 14, 10, 16, 18, 12, 6, 20, 22, 16, 24},                                               "[(abc)(abd)(cd)(cde)(abcde)]"},
+   {29, 0x9ee8e888, {11 << 16 | 1 << 8 | 5, 2, 4, 12, 6, 14, 8, 10, 16, 6, 8, 20, 18, 10, 2, 24, 4, 26, 18, 22, 28, 30, 12, 32},                 "[(ab)(acd)(bcd)(ace)(bce)(ade)(bde)(cde)(abcde)]"},
+   {30, 0x4268c268, {9 << 16 | 1 << 8 | 5, 4, 6, 10, 12, 8, 4, 16, 12, 14, 2, 18, 20, 22, 6, 2, 24, 26, 12, 28},                                 "[(ab)(ac)(bc)(abc)(ad)(abcde)]"},
+   {31, 0x16704c80, {7 << 16 | 1 << 8 | 5, 2, 10, 12, 4, 8, 14, 2, 4, 18, 10, 6, 20, 22, 16, 24},                                                "[(abc)(bd)(ce)(ade)]"},
+   {32, 0x78888888, {4 << 16 | 1 << 8 | 5, 6, 8, 10, 12, 2, 4, 16, 14, 18},                                                                      "[(ab)(cde)]"},
+   {33, 0x4966bac0, {10 << 16 | 1 << 8 | 5, 2, 8, 4, 6, 12, 10, 14, 2, 16, 18, 10, 6, 12, 8, 24, 4, 22, 26, 28, 20, 30},                         "[(bc)(ad)(cd)(acd)(abcd)(ae)(be)(bce)(de)(ade)]"},
+   {34, 0x372840a0, {9 << 16 | 1 << 8 | 5, 2, 4, 12, 2, 6, 14, 4, 6, 18, 16, 20, 10, 12, 8, 22, 24, 26, 16, 28},                                 "[(ac)(acd)(bcd)(abcd)(abe)(de)]"},
+   {35, 0x5208d288, {7 << 16 | 1 << 8 | 5, 2, 4, 10, 12, 14, 8, 6, 2, 16, 18, 14, 12, 22, 20, 24},                                               "[(ab)(ad)(cd)(abce)]"},
+   {36, 0x7ca00428, {10 << 16 | 1 << 8 | 5, 8, 2, 4, 12, 10, 14, 10, 2, 18, 14, 8, 20, 6, 4, 22, 2, 24, 26, 28, 16, 30},                         "[(ab)(ac)(bd)(acd)(bcd)(abcd)(abe)(cde)]"},
+   {37, 0xf8880888, {5 << 16 | 1 << 8 | 5, 2, 4, 12, 10, 6, 14, 8, 16, 18, 12, 20},                                                              "[(ab)(abcd)(cde)]"},
+   {38, 0x2ec0ae40, {8 << 16 | 1 << 8 | 5, 8, 6, 4, 12, 14, 8, 2, 16, 10, 18, 20, 14, 4, 22, 24, 18, 26},                                        "[(bc)(abc)(ad)(bd)(abd)(abce)]"},
+   {39, 0xf888f888, {5 << 16 | 1 << 8 | 4, 2, 4, 6, 8, 10, 12, 14, 10, 16, 12, 18},                                                              "[(abcd)(ab)(cd)]"},
+   {40, 0x58362ec0, {11 << 16 | 1 << 8 | 5, 6, 10, 10, 8, 14, 12, 4, 2, 16, 18, 20, 8, 2, 22, 24, 6, 12, 4, 26, 28, 30, 20, 32},                 "[(bc)(ad)(bd)(abd)(ae)(be)(ce)(ace)(bce)(abcde)]"},
+   {41, 0x0eb8f6c0, {13 << 16 | 1 << 8 | 5, 6, 10, 2, 8, 14, 10, 12, 2, 16, 18, 14, 4, 22, 8, 20, 4, 12, 6, 28, 26, 24, 30, 32, 12, 34, 22, 36}, "[(bc)(ad)(bd)(cd)(acd)(abe)(ce)(abcde)]"},
+   {42, 0x567cea40, {10 << 16 | 1 << 8 | 5, 2, 8, 10, 12, 14, 4, 16, 2, 6, 18, 20, 10, 6, 4, 22, 24, 20, 12, 28, 26, 30},                        "[(bc)(abc)(ad)(be)(ce)(abcde)]"},
+   {43, 0xf8887888, {6 << 16 | 1 << 8 | 5, 2, 4, 6, 8, 12, 14, 10, 16, 18, 12, 20, 14, 22},                                                      "[(abcde)(ab)(cd)]"},
+   {44, 0x78887888, {3 << 16 | 1 << 8 | 4, 2, 4, 6, 8, 12, 10, 14},                                                                              "[(ab)(cd)]"},
+   {45, 0xe72890a0, {8 << 16 | 1 << 8 | 5, 4, 10, 12, 6, 2, 14, 8, 4, 6, 18, 20, 10, 8, 22, 24, 16, 26},                                         "[(ac)(cd)(bcd)(abe)(de)]"},
+   {46, 0x268cea40, {6 << 16 | 1 << 8 | 5, 4, 6, 12, 8, 2, 14, 4, 10, 16, 12, 20, 18, 22},                                                       "[(bc)(abc)(ad)(be)]"},
+   {47, 0x6248eac0, {7 << 16 | 1 << 8 | 5, 2, 8, 6, 12, 14, 10, 2, 16, 18, 6, 4, 20, 22, 12, 24},                                                "[(bc)(ad)(abcd)(abe)]"}}
+};
+// clang-format on
+
+namespace legacy
+{
+
+// These circuits are based on Cryptology ePrint Archive: Report 2015/848
+// Meltem Sönmez Turan and Rene Péralta:
+// The Multiplicative Complexity of Boolean Functions on Four and Five Variables
+
+// clang-format off
+static std::vector<std::vector<std::tuple<uint32_t, uint64_t, std::vector<uint32_t>, std::string>>> minmc_xags = {
+  {{0, 0x0, {1 << 8 | 0, 0}, "0"}},
+  {{0, 0x0, {1 << 8 | 0, 0}, "0"}},
+  {{0, 0x0, {1 << 8 | 0, 0},                 "0"},
+   {1, 0x8, {1 << 16 | 1 << 8 | 2, 2, 4, 6}, "(ab)"}},
+  {{0, 0x00, {1 << 8 | 0, 0},                        "0"},
+   {2, 0x88, {1 << 16 | 1 << 8 | 2, 2, 4, 6},        "(ab)"},
+   {1, 0x80, {2 << 16 | 1 << 8 | 3, 2, 4, 6, 8, 10}, "(abc)"}},
+  {{0, 0x0000, {1 << 8 | 0, 0},                                                "0"},
+   {1, 0x8000, {3 << 16 | 1 << 8 | 4, 2, 4, 6, 8, 10, 12, 14},                 "(abcd)"},
+   {2, 0x8080, {2 << 16 | 1 << 8 | 3, 2, 4, 6, 8, 10},                         "(abc)"},
+   {3, 0x0888, {4 << 16 | 1 << 8 | 4, 2, 4, 6, 10, 8, 12, 14, 10, 16},         "[(abcd)(ab)]"},
+   {4, 0x8888, {1 << 16 | 1 << 8 | 2, 2, 4, 6},                                "(ab)"},
+   {5, 0x2a80, {3 << 16 | 1 << 8 | 4, 4, 6, 10, 8, 2, 12, 14},                 "[(abc)(ad)]"},
+   {6, 0xf888, {5 << 16 | 1 << 8 | 4, 2, 4, 6, 8, 10, 12, 14, 10, 16, 12, 18}, "[(abcd)(ab)(cd)]"},
+   {7, 0x7888, {3 << 16 | 1 << 8 | 4, 2, 4, 6, 8, 12, 10, 14},                 "[(ab)(cd)]"}},
+  {{ 0, 0x00000000, {1 << 8 | 0, 0},                                                                                                                           "0"},
+   { 1, 0x80000000, {4 << 16 | 1 << 8 | 5, 2, 4, 6, 8, 12, 14, 10, 16, 18},                                                                                    "(abcde)"},
+   { 2, 0x80008000, {3 << 16 | 1 << 8 | 4, 2, 4, 6, 8, 10, 12, 14},                                                                                            "(abcd)"},
+   { 3, 0x00808080, {5 << 16 | 1 << 8 | 5, 2, 4, 6, 12, 8, 14, 10, 16, 18, 14, 20},                                                                            "[(abcde)(abc)]"},
+   { 4, 0x80808080, {2 << 16 | 1 << 8 | 3, 2, 4, 6, 8, 10},                                                                                                    "(abc)"},
+   { 5, 0x40808080, {4 << 16 | 1 << 8 | 5, 4, 6, 8, 10, 14, 2, 12, 16, 18},                                                                                    "[(bcde)(abc)]"},
+   { 6, 0x22080808, {7 << 16 | 1 << 8 | 5, 4, 6, 8, 10, 12, 14, 14, 12, 18, 4, 20, 16, 2, 22, 24},                                                             "[(abcde)(abc)(ade)(ab)]"},
+   { 7, 0x88080808, {6 << 16 | 1 << 8 | 5, 2, 4, 6, 12, 8, 14, 10, 16, 18, 12, 20, 14, 22},                                                                    "[(abcde)(abc)(ab)]"},
+   { 8, 0x2a808080, {4 << 16 | 1 << 8 | 5, 4, 6, 8, 10, 14, 12, 2, 16, 18},                                                                                    "[(abc)(ade)]"},
+   { 9, 0x15808080, {6 << 16 | 1 << 8 | 5, 4, 6, 12, 2, 8, 10, 16, 2, 14, 18, 20, 18, 22},                                                                     "[(bcde)(abc)(ade)(de)]"},
+   {10, 0xc8080808, {5 << 16 | 1 << 8 | 5, 8, 10, 12, 2, 6, 14, 16, 2, 4, 18, 20},                                                                             "[(bcde)(ab)(abc)]"},
+   {11, 0x08880888, {4 << 16 | 1 << 8 | 4, 2, 4, 6, 10, 8, 12, 14, 10, 16},                                                                                    "[(abcd)(ab)]"},
+   {12, 0x95404040, {8 << 16 | 1 << 8 | 5, 4, 6, 8, 10, 12, 14, 16, 12, 18, 14, 2, 20, 22, 12, 24, 14, 26},                                                    "[(abcde)(abc)(ade)(de)(bc)]"},
+   {13, 0xaa808080, {6 << 16 | 1 << 8 | 5, 4, 6, 8, 10, 12, 14, 14, 12, 18, 16, 2, 20, 22},                                                                    "[(abcde)(abc)(ade)]"},
+   {14, 0x6a404040, {7 << 16 | 1 << 8 | 5, 4, 6, 8, 10, 12, 14, 16, 12, 18, 14, 2, 20, 22, 12, 24},                                                            "[(abcde)(abc)(ade)(bc)]"},
+   {15, 0xaa802a80, {6 << 16 | 1 << 8 | 5, 4, 6, 2, 8, 10, 14, 16, 2, 12, 18, 20, 14, 22},                                                                     "[(abcde)(abc)(ad)]"},
+   {16, 0x08888888, {5 << 16 | 1 << 8 | 5, 2, 4, 6, 12, 8, 14, 10, 16, 18, 12, 20},                                                                            "[(abcde)(ab)]"},
+   {17, 0x88888888, {1 << 16 | 1 << 8 | 2, 2, 4, 6},                                                                                                           "(ab)"},
+   {18, 0xea404040, {5 << 16 | 1 << 8 | 5, 4, 6, 8, 10, 14, 12, 2, 16, 18, 12, 20},                                                                            "[(abc)(ade)(bc)]"},
+   {19, 0x2a802a80, {3 << 16 | 1 << 8 | 4, 4, 6, 10, 8, 2, 12, 14},                                                                                            "[(abc)(ad)]"},
+   {20, 0x37080808, {6 << 16 | 1 << 8 | 5, 8, 10, 12, 2, 6, 14, 16, 2, 4, 18, 20, 12, 22},                                                                     "[(bcde)(abc)(ab)(de)]"},
+   {21, 0xea808080, {6 << 16 | 1 << 8 | 5, 4, 6, 12, 2, 8, 10, 16, 2, 14, 18, 20, 2, 22},                                                                      "[(bcde)(abc)(ade)]"},
+   {22, 0x8c804c80, {5 << 16 | 1 << 8 | 5, 8, 10, 12, 2, 6, 14, 16, 8, 4, 18, 20},                                                                             "[(bcde)(bd)(abc)]"},
+   {23, 0xea802a80, {8 << 16 | 1 << 8 | 5, 6, 4, 6, 12, 14, 6, 16, 8, 10, 16, 20, 2, 19, 22, 24, 2, 26},                                                       "[(bcde)(abc)(ad)]"},
+   {24, 0x7f008000, {4 << 16 | 1 << 8 | 5, 2, 4, 6, 12, 14, 10, 8, 16, 18},                                                                                    "[(abcd)(de)]"},
+   {25, 0x96704c80, {12 << 16 | 1 << 8 | 5, 10, 8, 12, 2, 10, 14, 16, 6, 6, 4, 8, 20, 22, 2, 4, 24, 26, 12, 18, 28, 22, 16, 32, 30, 34},                       "[(abcde)(abc)(ade)(ce)(bd)]"},
+   {26, 0x77080808, {7 << 16 | 1 << 8 | 5, 2, 4, 6, 12, 8, 10, 14, 16, 18, 12, 20, 14, 22, 16, 24},                                                            "[(abcde)(abc)(ab)(de)]"},
+   {27, 0x66804c80, {8 << 16 | 1 << 8 | 5, 6, 4, 12, 2, 6, 14, 16, 8, 2, 8, 10, 20, 22, 4, 18, 24, 26},                                                        "[(abcde)(abc)(ade)(bd)]"},
+   {28, 0xa6408c40, {9 << 16 | 1 << 8 | 5, 4, 6, 8, 6, 14, 2, 2, 10, 18, 4, 8, 20, 22, 16, 12, 24, 26, 22, 28},                                                "[(abcde)(abc)(ade)(bd)(bc)]"},
+   {29, 0xff808080, {6 << 16 | 1 << 8 | 5, 2, 4, 6, 12, 8, 10, 14, 16, 18, 14, 20, 16, 22},                                                                    "[(abcde)(abc)(de)]"},
+   {30, 0x7808f808, {7 << 16 | 1 << 8 | 5, 2, 4, 8, 10, 12, 14, 16, 12, 18, 8, 6, 20, 22, 12, 24},                                                             "[(abcde)(abc)(ab)(cd)]"},
+   {31, 0xe6804c80, {6 << 16 | 1 << 8 | 5, 4, 6, 8, 10, 14, 12, 2, 16, 4, 8, 20, 18, 22},                                                                      "[(abc)(ade)(bd)]"},
+   {32, 0x7f808080, {4 << 16 | 1 << 8 | 5, 2, 4, 6, 12, 8, 10, 16, 14, 18},                                                                                    "[(abc)(de)]"},
+   {33, 0xd6704c80, {10 << 16 | 1 << 8 | 5, 4, 6, 12, 2, 8, 10, 16, 12, 14, 18, 10, 4, 8, 6, 22, 24, 26, 16, 28, 20, 30},                                      "[(bcde)(abc)(ade)(ce)(bd)]"},
+   {34, 0x1a702a80, {7 << 16 | 1 << 8 | 5, 8, 10, 12, 2, 4, 14, 16, 10, 6, 18, 2, 8, 22, 20, 24},                                                              "[(bcde)(abc)(ad)(ce)]"},
+   {35, 0xb8887888, {5 << 16 | 1 << 8 | 5, 6, 8, 10, 12, 14, 2, 4, 16, 18, 12, 20},                                                                            "[(bcde)(ab)(cd)]"},
+   {36, 0xd9804c80, {7 << 16 | 1 << 8 | 5, 8, 10, 12, 2, 4, 6, 16, 12, 14, 18, 4, 8, 22, 20, 24},                                                              "[(bcde)(abc)(ade)(bd)(de)]"},
+   {37, 0xbf808080, {5 << 16 | 1 << 8 | 5, 4, 6, 8, 10, 14, 2, 12, 16, 18, 14, 20},                                                                            "[(bcde)(abc)(de)]"},
+   {38, 0x3808f808, {7 << 16 | 1 << 8 | 5, 4, 8, 10, 12, 2, 4, 16, 14, 18, 8, 6, 20, 22, 16, 24},                                                              "[(bcde)(abc)(ab)(cd)]"},
+   {39, 0xf888f888, {5 << 16 | 1 << 8 | 4, 2, 4, 6, 8, 10, 12, 14, 10, 16, 12, 18},                                                                            "[(abcd)(ab)(cd)]"},
+   {40, 0xa9b08c40, {15 << 16 | 1 << 8 | 5, 8, 4, 6, 4, 10, 4, 14, 16, 18, 12, 16, 2, 10, 8, 24, 14, 26, 2, 2, 8, 30, 14, 28, 32, 34, 22, 20, 36, 38, 30, 40}, "[(abcde)(abc)(ade)(de)(ce)(bd)(bc)]"},
+   {41, 0x56b08c40, {13 << 16 | 1 << 8 | 5, 8, 2, 2, 12, 14, 4, 10, 8, 6, 2, 6, 4, 22, 2, 10, 24, 26, 20, 6, 28, 30, 18, 16, 32, 34, 26, 36},                  "[(abcde)(abc)(ade)(ce)(bd)(bc)]"},
+   {42, 0x664c2a80, {11 << 16 | 1 << 8 | 5, 8, 2, 6, 12, 14, 8, 8, 6, 18, 4, 4, 10, 22, 6, 20, 24, 26, 2, 16, 28, 30, 22, 32},                                 "[(abcde)(abc)(ad)(be)]"},
+   {43, 0xf8887888, {6 << 16 | 1 << 8 | 5, 2, 4, 6, 8, 12, 14, 10, 16, 18, 12, 20, 14, 22},                                                                    "[(abcde)(ab)(cd)]"},
+   {44, 0x78887888, {3 << 16 | 1 << 8 | 4, 2, 4, 6, 8, 12, 10, 14},                                                                                            "[(ab)(cd)]"},
+   {45, 0xd6b08c40, {8 << 16 | 1 << 8 | 5, 2, 10, 12, 4, 6, 2, 6, 16, 18, 8, 14, 20, 6, 10, 24, 22, 26},                                                       "[(abc)(ade)(bc)(bd)(ce)]"},
+   {46, 0xe64c2a80, {5 << 16 | 1 << 8 | 5, 4, 6, 12, 8, 2, 14, 4, 10, 18, 16, 20},                                                                             "[(abc)(ad)(be)]"},
+   {47, 0x7c704c80, {10 << 16 | 1 << 8 | 5, 8, 10, 12, 2, 6, 4, 16, 2, 18, 12, 14, 20, 22, 8, 4, 24, 6, 10, 28, 26, 30},                                       "[(bcde)(abc)(bd)(ce)]"}}
+};
+// clang-format on
+
+} // namespace legacy
+
+} /* namespace mockturtle::detail */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/detail/resub_utils.hpp b/include/mockturtle/algorithms/detail/resub_utils.hpp
new file mode 100644
index 0000000..9db62ab
--- /dev/null
+++ b/include/mockturtle/algorithms/detail/resub_utils.hpp
@@ -0,0 +1,782 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file resub_utils.hpp
+  \brief Utility classes for the resubstitution framework
+
+  class `node_mffc_inside`, class `window_simulator` (originally `simulator`),
+  and class `default_resub_functor` moved from resubstitution.hpp
+
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <iostream>
+#include <optional>
+#include <vector>
+
+#include <kitty/constructors.hpp>
+
+namespace mockturtle::experimental::detail
+{
+
+struct divisor_collector_params
+{
+  /*! \brief Maximum number of nodes to be collected in the transitive fanin cone. */
+  uint32_t max_num_tfi{ std::numeric_limits<uint32_t>::max() };
+
+  /*! \brief Maximum number of nodes to collect (in total). */
+  uint32_t max_num_collect{ std::numeric_limits<uint32_t>::max() };
+
+  /*! \brief Maximum fanout size when considering a node in the "wings". */
+  uint32_t max_fanouts{ std::numeric_limits<uint32_t>::max() };
+
+  /*! \brief Maximum level when considering a node in the "wings".
+   *
+   * The network should be wrapped with `depth_view` for this parameter
+   * to be in effect.
+   */
+  uint32_t max_level{ std::numeric_limits<uint32_t>::max() };
+};
+
+/*! \brief Implements helper functions for collecting divisors/supported nodes. */
+template<typename Ntk>
+class divisor_collector
+{
+public:
+  using node = typename Ntk::node;
+
+  divisor_collector( Ntk const& ntk, divisor_collector_params ps = {} )
+      : ntk( ntk ), ps( ps )
+  {
+    static_assert( has_foreach_fanout_v<Ntk>, "Ntk does not implement the foreach_fanout method (please wrap with fanout_view)" );
+    static_assert( has_incr_trav_id_v<Ntk>, "Ntk does not implement the incr_trav_id method" );
+    static_assert( has_trav_id_v<Ntk>, "Ntk does not implement the trav_id method" );
+    static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+    static_assert( has_visited_v<Ntk>, "Ntk does not implement the visited method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+    assert( ps.max_num_collect >= ps.max_num_tfi );
+  }
+
+  void set_max_level( uint32_t max_level )
+  {
+    ps.max_level = max_level;
+  }
+
+  /*! \brief Collect nodes in the transitive fanin cone of root until leaves in a topological order.
+   *
+   * `root` itself is included and will be the last element.
+   * Constant node(s) is not collected.
+   * Leaves are not collected.
+   *
+   * \param root The root node
+   * \param leaves The leaf nodes forming a cut supporting the root node
+   * \param tfi The container where TFI nodes are collected
+   */
+  void collect_tfi( node const& root, std::vector<node> const& leaves, std::vector<node>& tfi )
+  {
+    ntk.incr_trav_id();
+    for ( const auto& l : leaves )
+    {
+      ntk.set_visited( l, ntk.trav_id() );
+    }
+    collect_tfi_rec( root, tfi );
+  }
+
+  /*! \brief Collect nodes in the TFI (BFS) and wings.
+   *
+   * Constant node(s) is not collected.
+   * Any node in the TFO of root is not collected.
+   * Collects TFI nodes with breadth-first search until PIs (unbounded)
+   * or until the limit on `max_num_tfi` exceeds, and then collects "wings"
+   * nodes until the limit on `max_num_collect` exceeds.
+   * Collected nodes are in a topological order, with `root` itself being the last element.
+   *
+   * \param root The root node
+   * \param collected The container where TFI and "wings" nodes are collected
+   */
+  void collect_tfi_and_wings( node const& root, std::vector<node>& collected )
+  {
+    collect_tfi_bfs( root, collected );
+    std::reverse( collected.begin(), collected.end() ); /* now in topo order */
+    collected.pop_back();                               /* remove `root` */
+
+    /* note: we cannot use range-based loop here because we push to the vector in the loop */
+    for ( auto i = 0u; i < collected.size(); ++i )
+    {
+      if ( !collect_wings( root, collected.at( i ), collected ) )
+      {
+        break;
+      }
+    }
+
+    collected.emplace_back( root );
+    return;
+  }
+
+  /*! \brief Collect all nodes that are supported by the leaves until the root (TFI + wings).
+   *
+   * Constant node(s) is not collected.
+   * Leaves are not collected.
+   * Any node in the TFO of root is not collected.
+   * Collected nodes are in a topological order, with `root` itself being the last element.
+   *
+   * \param root The root node
+   * \param leaves The leaf nodes forming a cut supporting the root node
+   * \param supported The container where supported nodes are collected
+   */
+  void collect_supported_nodes( node const& root, std::vector<node> const& leaves, std::vector<node>& supported )
+  {
+    /* collect TFI nodes until (excluding) leaves */
+    collect_tfi( root, leaves, supported );
+    supported.pop_back(); /* remove `root` */
+
+    if ( supported.size() > ps.max_num_tfi )
+    {
+      return;
+    }
+
+    /* collect "wings" */
+    for ( auto const& l : leaves )
+    {
+      if ( !collect_wings( root, l, supported ) )
+      {
+        supported.emplace_back( root );
+        return;
+      }
+    }
+
+    /* note: we cannot use range-based loop here because we push to the vector in the loop */
+    for ( auto i = 0u; i < supported.size(); ++i )
+    {
+      if ( !collect_wings( root, supported.at( i ), supported ) )
+      {
+        break;
+      }
+    }
+
+    supported.emplace_back( root );
+    return;
+  }
+
+private:
+  void collect_tfi_rec( node const& n, std::vector<node>& tfi )
+  {
+    /* collect until leaves and skip visited nodes */
+    if ( ntk.visited( n ) == ntk.trav_id() )
+    {
+      return;
+    }
+    ntk.set_visited( n, ntk.trav_id() );
+
+    /* collect in topological order -- lower nodes first */
+    ntk.foreach_fanin( n, [&]( const auto& f ) {
+      collect_tfi_rec( ntk.get_node( f ), tfi );
+    } );
+
+    if ( !ntk.is_constant( n ) )
+    {
+      tfi.emplace_back( n );
+    }
+  }
+
+  /*! \brief Collect nodes in the transitive fanin cone of root with breadth-first search.
+   *
+   * `root` itself is included and will be the first element.
+   * Constant node(s) is not collected.
+   * Collects until PIs (unbounded) or until the limit on `max_num_tfi` exceeds.
+   * Collected nodes are NOT in a topological order.
+   *
+   * \param root The root node
+   * \param tfi The container where TFI nodes are collected
+   */
+  void collect_tfi_bfs( node const& root, std::vector<node>& tfi )
+  {
+    ntk.incr_trav_id();
+    assert( tfi.size() == 0 );
+    tfi.reserve( ps.max_num_tfi );
+    tfi.emplace_back( root );
+    ntk.set_visited( root, ntk.trav_id() );
+    ntk.set_visited( ntk.get_node( ntk.get_constant( false ) ), ntk.trav_id() ); /* don't collect constant node */
+    uint32_t i{ 0 };
+    while ( i < tfi.size() && tfi.size() < ps.max_num_tfi )
+    {
+      node const& n = tfi.at( i++ );
+      ntk.foreach_fanin( n, [&]( const auto& f ) {
+        node const& ni = ntk.get_node( f );
+        if ( ntk.visited( ni ) != ntk.trav_id() )
+        {
+          tfi.emplace_back( ni );
+          ntk.set_visited( ni, ntk.trav_id() );
+        }
+      } );
+    }
+  }
+
+  /*\return Whether to continue collecting */
+  bool collect_wings( node const& root, node const& n, std::vector<node>& supported )
+  {
+    if ( ntk.fanout_size( n ) > ps.max_fanouts )
+    {
+      return true;
+    }
+
+    /* if the fanout has all fanins in the set, add it */
+    ntk.foreach_fanout( n, [&]( node const& p ) {
+      if ( ntk.visited( p ) == ntk.trav_id() )
+      {
+        return true; /* next fanout */
+      }
+
+      if constexpr ( has_level_v<Ntk> )
+      {
+        if ( ntk.level( p ) > ps.max_level )
+        {
+          return true; /* next fanout */
+        }
+      }
+
+      bool all_fanins_visited = true;
+      ntk.foreach_fanin( p, [&]( const auto& g ) {
+        if ( ntk.visited( ntk.get_node( g ) ) != ntk.trav_id() )
+        {
+          all_fanins_visited = false;
+          return false; /* terminate fanin-loop */
+        }
+        return true; /* next fanin */
+      } );
+
+      if ( !all_fanins_visited )
+      {
+        return true; /* next fanout */
+      }
+
+      bool has_root_as_child = false;
+      ntk.foreach_fanin( p, [&]( const auto& g ) {
+        if ( ntk.get_node( g ) == root )
+        {
+          has_root_as_child = true;
+          return false; /* terminate fanin-loop */
+        }
+        return true; /* next fanin */
+      } );
+
+      if ( has_root_as_child )
+      {
+        return true; /* next fanout */
+      }
+
+      supported.emplace_back( p );
+      ntk.set_visited( p, ntk.trav_id() );
+
+      /* quit fanout-loop if there are too many nodes collected */
+      return supported.size() < ps.max_num_collect;
+    } );
+    return supported.size() < ps.max_num_collect;
+  }
+
+private:
+  Ntk const& ntk;
+  divisor_collector_params ps;
+}; /* divisor_collector */
+
+template<typename Ntk, typename TT>
+class window_simulator
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  explicit window_simulator( Ntk const& ntk, std::vector<TT>& tts, uint32_t num_pis )
+      : ntk( ntk ), tts( tts ), node_to_id( ntk ), num_pis( num_pis )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+    static_assert( has_fanin_size_v<Ntk>, "Ntk does not implement the fanin_size method" );
+    static_assert( has_compute_v<Ntk, TT>, "Ntk does not implement the compute method for TT" );
+    assert( ntk.get_node( ntk.get_constant( false ) ) == ntk.get_node( ntk.get_constant( true ) ) && "network types whose constant nodes are different are not supported" );
+
+    tts.resize( num_pis + 1 );
+    auto tt = kitty::create<TT>( num_pis );
+    tts[0] = tt;
+    node_to_id[ntk.get_constant( false )] = 0;
+
+    for ( auto i = 0u; i < num_pis; ++i )
+    {
+      kitty::create_nth_var( tt, i );
+      tts[i + 1] = tt;
+    }
+  }
+
+  /*! \brief Simulates a window in a network.
+   *
+   * Every node in `nodes` must have all of its fanins either in `leaves`, or in
+   * `nodes` and precedes it (i.e., supported and in a topological order).
+   *
+   * After simulation, `tts` contains:
+   * - `tts[0]` is the constant-zero truth table
+   * - `tts[1]` to `tts[num_pis]` are the projection functions (primary inputs)
+   * - `tts[num_pis + 1 + i]` is the truth table for the node `nodes[i]`
+   */
+  std::vector<TT>& simulate( std::vector<node> const& leaves, std::vector<node> const& nodes )
+  {
+    node_to_id.resize();
+    assert( leaves.size() <= num_pis );
+    for ( auto i = 0u; i < leaves.size(); ++i )
+    {
+      node_to_id[leaves[i]] = i + 1;
+    }
+
+    tts.resize( num_pis + 1 );
+    for ( auto const& n : nodes )
+    {
+      ntk.foreach_fanin( n, [&]( auto const& f, auto i ) {
+        assert( node_to_id.has( f ) && node_to_id[f] < tts.size() && "some node in `nodes` has a fanin outside of `nodes` and `leaves`, or `nodes` is not in a topological order" );
+        fanin_values[i] = tts[node_to_id[f]];
+      } );
+      node_to_id[n] = tts.size();
+      tts.emplace_back( ntk.compute( n, std::begin( fanin_values ), std::begin( fanin_values ) + ntk.fanin_size( n ) ) );
+    }
+
+    assert( tts.size() == num_pis + 1 + nodes.size() );
+    return tts;
+  }
+
+private:
+  Ntk const& ntk;
+  std::vector<TT>& tts;
+  incomplete_node_map<uint32_t, Ntk> node_to_id;
+  std::array<TT, Ntk::max_fanin_size> fanin_values;
+  uint32_t num_pis;
+}; /* window_simulator */
+
+} /* namespace mockturtle::experimental::detail */
+
+namespace mockturtle::detail
+{
+
+/* based on abcRefs.c */
+template<typename Ntk>
+class node_mffc_inside
+{
+public:
+  using node = typename Ntk::node;
+
+public:
+  explicit node_mffc_inside( Ntk const& ntk )
+      : ntk( ntk )
+  {
+    static_assert( has_incr_fanout_size_v<Ntk>, "Ntk does not implement the incr_fanout_size method" );
+    static_assert( has_decr_fanout_size_v<Ntk>, "Ntk does not implement the decr_fanout_size method" );
+    static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+    static_assert( has_incr_trav_id_v<Ntk>, "Ntk does not implement the incr_trav_id method" );
+    static_assert( has_trav_id_v<Ntk>, "Ntk does not implement the trav_id method" );
+    static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+    static_assert( has_visited_v<Ntk>, "Ntk does not implement the visited method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  }
+
+  template<typename Fn>
+  int32_t call_on_mffc_and_count( node const& n, std::vector<node> const& leaves, Fn&& fn )
+  {
+    /* increment the fanout counters for the leaves */
+    for ( const auto& l : leaves )
+      ntk.incr_fanout_size( l );
+
+    /* dereference the node */
+    auto count1 = node_deref_rec( n );
+
+    /* call `fn` on MFFC nodes */
+    ntk.incr_trav_id();
+    node_mffc_cone_rec( n, true, fn );
+
+    /* reference it back */
+    auto count2 = node_ref_rec( n );
+    (void)count2;
+    assert( count1 == count2 );
+
+    for ( const auto& l : leaves )
+      ntk.decr_fanout_size( l );
+
+    return count1;
+  }
+
+  int32_t run( node const& n, std::vector<node> const& leaves, std::vector<node>& inside )
+  {
+    inside.clear();
+    return call_on_mffc_and_count( n, leaves, [&inside]( node const& m ) { inside.emplace_back( m ); } );
+  }
+
+private:
+  /* ! \brief Dereference the node's MFFC */
+  int32_t node_deref_rec( node const& n )
+  {
+    if ( ntk.is_pi( n ) )
+      return 0;
+
+    int32_t counter = 1;
+    ntk.foreach_fanin( n, [&]( const auto& f ) {
+      auto const& p = ntk.get_node( f );
+
+      ntk.decr_fanout_size( p );
+      if ( ntk.fanout_size( p ) == 0 )
+      {
+        counter += node_deref_rec( p );
+      }
+    } );
+
+    return counter;
+  }
+
+  /* ! \brief Reference the node's MFFC */
+  int32_t node_ref_rec( node const& n )
+  {
+    if ( ntk.is_pi( n ) )
+      return 0;
+
+    int32_t counter = 1;
+    ntk.foreach_fanin( n, [&]( const auto& f ) {
+      auto const& p = ntk.get_node( f );
+
+      auto v = ntk.fanout_size( p );
+      ntk.incr_fanout_size( p );
+      if ( v == 0 )
+      {
+        counter += node_ref_rec( p );
+      }
+    } );
+
+    return counter;
+  }
+
+  template<typename Fn>
+  void node_mffc_cone_rec( node const& n, bool top_most, Fn&& fn )
+  {
+    /* skip visited nodes */
+    if ( ntk.visited( n ) == ntk.trav_id() )
+    {
+      return;
+    }
+    ntk.set_visited( n, ntk.trav_id() );
+
+    if ( !top_most && ( ntk.is_pi( n ) || ntk.fanout_size( n ) > 0 ) )
+    {
+      return;
+    }
+
+    /* recurse on children */
+    ntk.foreach_fanin( n, [&]( const auto& f ) {
+      node_mffc_cone_rec( ntk.get_node( f ), false, fn );
+    } );
+
+    /* collect the internal nodes */
+    fn( n );
+  }
+
+private:
+  Ntk const& ntk;
+}; /* node_mffc_inside */
+
+template<typename Ntk, typename TT>
+class window_simulator
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  using truthtable_t = TT;
+
+  explicit window_simulator( Ntk const& ntk, uint32_t num_divisors, uint32_t max_pis )
+      : ntk( ntk ), num_divisors( num_divisors ), tts( num_divisors + 1 ), node_to_index( ntk.size(), 0u ), phase( ntk.size(), false )
+  {
+    auto tt = kitty::create<truthtable_t>( max_pis );
+    tts[0] = tt;
+
+    for ( auto i = 0u; i < tt.num_vars(); ++i )
+    {
+      kitty::create_nth_var( tt, i );
+      tts[i + 1] = tt;
+    }
+  }
+
+  void resize()
+  {
+    if ( ntk.size() > node_to_index.size() )
+    {
+      node_to_index.resize( ntk.size(), 0u );
+    }
+    if ( ntk.size() > phase.size() )
+    {
+      phase.resize( ntk.size(), false );
+    }
+  }
+
+  void assign( node const& n, uint32_t index )
+  {
+    assert( n < node_to_index.size() );
+    assert( index < num_divisors + 1 );
+    node_to_index[n] = index;
+  }
+
+  truthtable_t get_tt( signal const& s ) const
+  {
+    auto const tt = tts.at( node_to_index.at( ntk.get_node( s ) ) );
+    return ntk.is_complemented( s ) ? ~tt : tt;
+  }
+
+  void set_tt( uint32_t index, truthtable_t const& tt )
+  {
+    tts[index] = tt;
+  }
+
+  void normalize( std::vector<node> const& nodes )
+  {
+    for ( const auto& n : nodes )
+    {
+      assert( n < phase.size() );
+      assert( n < node_to_index.size() );
+
+      if ( n == 0 )
+      {
+        return;
+      }
+
+      auto& tt = tts[node_to_index.at( n )];
+      if ( kitty::get_bit( tt, 0 ) )
+      {
+        tt = ~tt;
+        phase[n] = true;
+      }
+      else
+      {
+        phase[n] = false;
+      }
+    }
+  }
+
+  bool get_phase( node const& n ) const
+  {
+    assert( n < phase.size() );
+    return phase.at( n );
+  }
+
+private:
+  Ntk const& ntk;
+  uint32_t num_divisors;
+
+  std::vector<truthtable_t> tts;
+  std::vector<uint32_t> node_to_index;
+  std::vector<bool> phase;
+}; /* window_simulator */
+
+struct default_resub_functor_stats
+{
+  /*! \brief Accumulated runtime for const-resub */
+  stopwatch<>::duration time_resubC{ 0 };
+
+  /*! \brief Accumulated runtime for zero-resub */
+  stopwatch<>::duration time_resub0{ 0 };
+
+  /*! \brief Number of accepted constant resubsitutions */
+  uint32_t num_const_accepts{ 0 };
+
+  /*! \brief Number of accepted zero resubsitutions */
+  uint32_t num_div0_accepts{ 0 };
+
+  void report() const
+  {
+    std::cout << "[i] kernel: default_resub_functor\n";
+    std::cout << fmt::format( "[i]     constant-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_const_accepts, to_seconds( time_resubC ) );
+    std::cout << fmt::format( "[i]            0-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_div0_accepts, to_seconds( time_resub0 ) );
+    std::cout << fmt::format( "[i]            total   {:6d}\n",
+                              ( num_const_accepts + num_div0_accepts ) );
+  }
+};
+
+/*! \brief A window-based resub functor which is basically doing functional reduction (fraig). */
+template<typename Ntk, typename Simulator, typename TT>
+class default_resub_functor
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  using stats = default_resub_functor_stats;
+
+  explicit default_resub_functor( Ntk const& ntk, Simulator const& sim, std::vector<node> const& divs, uint32_t num_divs, default_resub_functor_stats& st )
+      : ntk( ntk ), sim( sim ), divs( divs ), num_divs( num_divs ), st( st )
+  {
+  }
+
+  std::optional<signal> operator()( node const& root, TT care, uint32_t required, uint32_t max_inserts, uint32_t num_mffc, uint32_t& last_gain ) const
+  {
+    /* The default resubstitution functor does not insert any gates
+       and consequently does not use the argument `max_inserts`. Other
+       functors, however, make use of this argument. */
+    (void)care;
+    (void)max_inserts;
+    assert( kitty::is_const0( ~care ) );
+
+    /* consider constants */
+    auto g = call_with_stopwatch( st.time_resubC, [&]() {
+      return resub_const( root, required );
+    } );
+    if ( g )
+    {
+      ++st.num_const_accepts;
+      last_gain = num_mffc;
+      return g; /* accepted resub */
+    }
+
+    /* consider equal nodes */
+    g = call_with_stopwatch( st.time_resub0, [&]() {
+      return resub_div0( root, required );
+    } );
+    if ( g )
+    {
+      ++st.num_div0_accepts;
+      last_gain = num_mffc;
+      return g; /* accepted resub */
+    }
+
+    return std::nullopt;
+  }
+
+private:
+  std::optional<signal> resub_const( node const& root, uint32_t required ) const
+  {
+    (void)required;
+    auto const tt = sim.get_tt( ntk.make_signal( root ) );
+    if ( tt == sim.get_tt( ntk.get_constant( false ) ) )
+    {
+      return sim.get_phase( root ) ? ntk.get_constant( true ) : ntk.get_constant( false );
+    }
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_div0( node const& root, uint32_t required ) const
+  {
+    (void)required;
+    auto const tt = sim.get_tt( ntk.make_signal( root ) );
+    for ( const auto& d : divs )
+    {
+      if ( root == d )
+      {
+        break;
+      }
+
+      if ( tt != sim.get_tt( ntk.make_signal( d ) ) )
+      {
+        continue; /* next */
+      }
+
+      return ( sim.get_phase( d ) ^ sim.get_phase( root ) ) ? !ntk.make_signal( d ) : ntk.make_signal( d );
+    }
+
+    return std::nullopt;
+  }
+
+private:
+  Ntk const& ntk;
+  Simulator const& sim;
+  std::vector<node> const& divs;
+  uint32_t num_divs;
+  stats& st;
+}; /* default_resub_functor */
+
+template<typename Ntk, typename node>
+void update_node_level_once( Ntk& ntk, node const& n, bool first_node )
+{
+  uint32_t curr_level = ntk.level( n );
+
+  uint32_t max_level = 0;
+  ntk.foreach_fanin( n, [&]( const auto& f ) {
+    auto const p = ntk.get_node( f );
+    auto const fanin_level = ntk.level( p );
+    if ( fanin_level > max_level )
+    {
+      max_level = fanin_level;
+    }
+  } );
+  ++max_level;
+
+  if ( curr_level != max_level )
+  {
+    ntk.set_level( n, max_level );
+
+    /* update only one more level */
+    if ( first_node )
+    {
+      ntk.foreach_fanout( n, [&]( const auto& p ) {
+        update_node_level_once( ntk, p, false );
+      } );
+    }
+  }
+}
+
+/*! \brief Register an `on_modified` event that lazily updates node levels.
+ *
+ * This is a trick learnt from ABC's implementation and is used in
+ * enumeration-based resubstitution algorithms. It only updates the level of
+ * the modified node and its fanout nodes. The update is not propagated to
+ * the fanouts' fanouts, thus being fast but inaccurate.
+ *
+ * This method can be called in the constructor of an algorithm's implementation
+ * class. Note that its return value should be stored and
+ * `release_lazy_level_update_events` should then be called in the destructor
+ * of the class.
+ */
+template<class Ntk, typename event_t = std::shared_ptr<typename network_events<Ntk>::modified_event_type>>
+event_t register_lazy_level_update_events( Ntk& ntk )
+{
+  static_assert( has_foreach_fanout_v<Ntk>, "Ntk does not have fanout interface." );
+  using node = typename Ntk::node;
+
+  auto const update_level_of_existing_node = [&]( node const& n, const auto& old_children ) {
+    (void)old_children;
+    ntk.resize_levels();
+    update_node_level_once( ntk, n, true );
+  };
+
+  return ntk.events().register_modified_event( update_level_of_existing_node );
+}
+
+template<class Ntk, typename event_t = std::shared_ptr<typename network_events<Ntk>::modified_event_type>>
+void release_lazy_level_update_events( Ntk& ntk, event_t& event )
+{
+  ntk.events().release_modified_event( event );
+}
+
+} /* namespace mockturtle::detail */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/detail/switching_activity.hpp b/include/mockturtle/algorithms/detail/switching_activity.hpp
new file mode 100644
index 0000000..c5df29c
--- /dev/null
+++ b/include/mockturtle/algorithms/detail/switching_activity.hpp
@@ -0,0 +1,70 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file switching_activity.hpp
+  \brief Utility to compute the switching activity
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <vector>
+
+#include "../simulation.hpp"
+
+#include <kitty/bit_operations.hpp>
+#include <kitty/partial_truth_table.hpp>
+
+namespace mockturtle::detail
+{
+
+/*! \brief Switching Activity.
+ *
+ * This function computes the switching activity for each node
+ * in the network by performing random simulation.
+ *
+ * \param ntk Network
+ * \param simulation_size Number of simulation bits
+ */
+template<typename Ntk>
+std::vector<float> switching_activity( Ntk const& ntk, unsigned simulation_size = 2048 )
+{
+  std::vector<float> sw_map( ntk.size() );
+  partial_simulator sim( ntk.num_pis(), simulation_size );
+
+  auto tts = simulate_nodes<kitty::partial_truth_table, Ntk, partial_simulator>( ntk, sim );
+
+  ntk.foreach_node( [&]( auto const& n ) {
+    float ones = static_cast<float>( kitty::count_ones( tts[n] ) );
+    float activity = 2.0 * ones / simulation_size * ( simulation_size - ones ) / simulation_size;
+    sw_map[ntk.node_to_index( n )] = activity;
+  } );
+
+  return sw_map;
+}
+
+} // namespace mockturtle::detail
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/dont_cares.hpp b/include/mockturtle/algorithms/dont_cares.hpp
new file mode 100644
index 0000000..0e03d54
--- /dev/null
+++ b/include/mockturtle/algorithms/dont_cares.hpp
@@ -0,0 +1,358 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file dont_cares.hpp
+  \brief Compute don't cares
+
+  \author Eleonora Testa
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include "../algorithms/cnf.hpp"
+#include "../algorithms/reconv_cut.hpp"
+#include "../algorithms/simulation.hpp"
+#include "../traits.hpp"
+#include "../utils/include/percy.hpp"
+#include "../utils/node_map.hpp"
+#include "../views/color_view.hpp"
+#include "../views/fanout_view.hpp"
+#include "../views/topo_view.hpp"
+#include "../views/window_view.hpp"
+
+#include <fmt/format.h>
+#include <kitty/bit_operations.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+
+namespace mockturtle
+{
+
+/*! \brief Computes satisfiability don't cares of a set of nodes.
+ *
+ * This function returns an under approximation of input assignments that
+ * cannot occur on a given set of nodes in a network.  They may therefore be
+ * used as don't care conditions.
+ *
+ * \param ntk Network
+ * \param leaves Set of nodes
+ * \param max_tfi_inputs Maximum number of inputs in the transitive fanin.
+ */
+template<class Ntk>
+kitty::dynamic_truth_table satisfiability_dont_cares( Ntk const& ntk, std::vector<node<Ntk>> const& leaves, uint64_t max_tfi_inputs = 16u )
+{
+  reconvergence_driven_cut_parameters ps;
+  ps.max_leaves = max_tfi_inputs;
+  reconvergence_driven_cut_statistics st;
+
+  detail::reconvergence_driven_cut_impl<Ntk, false, false> cuts( ntk, ps, st );
+  auto const extended_leaves = cuts.run( leaves ).first;
+
+  fanout_view<Ntk> fanout_ntk{ ntk };
+  fanout_ntk.clear_visited();
+  color_view<Ntk> color_ntk{ fanout_ntk };
+
+  std::vector<node<Ntk>> gates{ collect_nodes( color_ntk, extended_leaves, leaves ) };
+  window_view window_ntk{ color_ntk, extended_leaves, leaves, gates };
+
+  default_simulator<kitty::dynamic_truth_table> sim( window_ntk.num_pis() );
+  const auto tts = simulate_nodes<kitty::dynamic_truth_table>( window_ntk, sim );
+
+  /* first create care and then invert */
+  kitty::dynamic_truth_table care( static_cast<uint32_t>( leaves.size() ) );
+  for ( auto i = 0u; i < ( 1u << window_ntk.num_pis() ); ++i )
+  {
+    uint32_t entry{ 0u };
+    for ( auto j = 0u; j < leaves.size(); ++j )
+    {
+      entry |= kitty::get_bit( tts[leaves[j]], i ) << j;
+    }
+    kitty::set_bit( care, entry );
+  }
+  return ~care;
+}
+
+/*! \brief Computes observability don't cares of a node.
+ *
+ * This function returns input assignments for which a change of the
+ * node's value cannot be observed at any of the roots.  They may
+ * therefore be used as don't care conditions.
+ *
+ * \param ntk Network
+ * \param node A node in the ntk
+ * \param leaves Set of leave nodes
+ * \param roots Set of root nodes
+ */
+template<class Ntk>
+kitty::dynamic_truth_table observability_dont_cares( Ntk const& ntk, node<Ntk> const& n, std::vector<node<Ntk>> const& leaves, std::vector<node<Ntk>> const& roots )
+{
+  fanout_view<Ntk> fanout_ntk{ ntk };
+  fanout_ntk.clear_visited();
+  color_view<Ntk> color_ntk{ fanout_ntk };
+
+  std::vector<node<Ntk>> gates{ collect_nodes( color_ntk, leaves, roots ) };
+  window_view window_ntk{ color_ntk, leaves, roots, gates };
+
+  default_simulator<kitty::dynamic_truth_table> sim( window_ntk.num_pis() );
+  unordered_node_map<kitty::dynamic_truth_table, Ntk> node_to_value0( ntk );
+  unordered_node_map<kitty::dynamic_truth_table, Ntk> node_to_value1( ntk );
+
+  node_to_value0[n] = sim.compute_constant( ntk.constant_value( ntk.get_node( ntk.get_constant( false ) ) ) );
+  simulate_nodes( ntk, node_to_value0, sim );
+
+  node_to_value1[n] = ~sim.compute_constant( ntk.constant_value( ntk.get_node( ntk.get_constant( false ) ) ) );
+  simulate_nodes( ntk, node_to_value1, sim );
+
+  kitty::dynamic_truth_table care( static_cast<uint32_t>( leaves.size() ) );
+  for ( const auto& r : roots )
+  {
+    care |= node_to_value0[r] ^ node_to_value1[r];
+  }
+  return ~care;
+}
+
+namespace detail
+{
+
+template<class Ntk, class Container>
+void clearTFO_rec( Ntk const& ntk, Container& tts, node<Ntk> const& n, std::set<node<Ntk>>& roots, int level )
+{
+  if ( ntk.visited( n ) == ntk.trav_id() ) /* visited */
+  {
+    return;
+  }
+  ntk.set_visited( n, ntk.trav_id() );
+
+  tts.erase( n );
+
+  if ( level == 0 )
+  {
+    roots.insert( n );
+    return;
+  }
+
+  ntk.foreach_fanout( n, [&]( auto const& fo ) {
+    clearTFO_rec( ntk, tts, fo, roots, level - 1 );
+  } );
+}
+
+template<class Ntk, class Container>
+void simulate_TFO_rec( Ntk const& ntk, node<Ntk> const& n, partial_simulator const& sim, Container& tts, int level )
+{
+  if ( ntk.visited( n ) == ntk.trav_id() ) /* visited */
+  {
+    return;
+  }
+  ntk.set_visited( n, ntk.trav_id() );
+
+  if ( !tts.has( n ) )
+  {
+    simulate_node<Ntk>( ntk, n, tts, sim );
+  }
+  else
+  {
+    assert( tts[n].num_bits() == sim.num_bits() );
+  }
+
+  if ( level == 0 )
+  {
+    return;
+  }
+
+  ntk.foreach_fanout( n, [&]( auto const& fo ) {
+    simulate_TFO_rec( ntk, fo, sim, tts, level - 1 );
+  } );
+}
+
+} /* namespace detail */
+
+/*! \brief Compute the observability don't care patterns in a partial_simulator with respect to a node.
+ *
+ * A pattern is unobservable w.r.t. a node `n` if under this input assignment,
+ * replacing `n` with `!n` does not affect the value of any primary output or
+ * any leaf node of `levels` levels of transitive fanout cone.
+ *
+ * Return value: a `partial_truth_table` with the same length as `sim.num_bits()`.
+ * A `1` in it corresponds to an unobservable pattern.
+ *
+ * \param sim The `partial_simulator` containing the patterns to be tested.
+ * \param tts Stores the simulation signatures of each node. Can be empty or incomplete.
+ * \param levels Level of transitive fanout to consider. -1 = consider until PO.
+ */
+template<class Ntk, class Container = unordered_node_map<kitty::partial_truth_table, Ntk>>
+kitty::partial_truth_table observability_dont_cares( Ntk const& ntk, node<Ntk> const& n, partial_simulator const& sim, Container& tts, int levels = -1 )
+{
+  std::set<node<Ntk>> roots;
+  unordered_node_map<kitty::partial_truth_table, Ntk> tts_roots( ntk );
+
+  /* Make sure n is up-to-date and record its truth table. */
+  if ( !tts.has( n ) || tts[n].num_bits() != sim.num_bits() )
+  {
+    simulate_node<Ntk>( ntk, n, tts, sim );
+  }
+  auto const tt_n = tts[n];
+
+  /* Clear (mark) TFO nodes and collect roots (leaves). */
+  ntk.incr_trav_id();
+  detail::clearTFO_rec( ntk, tts, n, roots, levels );
+  ntk.foreach_po( [&]( auto const& f ) {
+    if ( ntk.visited( ntk.get_node( f ) ) == ntk.trav_id() ) /* PO is in TFO */
+    {
+      roots.insert( ntk.get_node( f ) );
+    }
+  } );
+
+  /* Simulate the negated version and collect TTs of roots. */
+  tts[n] = ~tt_n;
+  ntk.incr_trav_id();
+  detail::simulate_TFO_rec( ntk, n, sim, tts, levels );
+  for ( const auto& r : roots )
+  {
+    tts_roots[r] = tts[r];
+  }
+
+  /* Revert the negation and simulate again */
+  tts[n] = tt_n;
+  ntk.incr_trav_id();
+  detail::clearTFO_rec( ntk, tts, n, roots, levels );
+  ntk.incr_trav_id();
+  detail::simulate_TFO_rec( ntk, n, sim, tts, levels );
+
+  kitty::partial_truth_table care( sim.num_bits() );
+  for ( const auto& r : roots )
+  {
+    assert( tts[r].num_bits() == sim.num_bits() );
+    care |= tts[r] ^ tts_roots[r];
+  }
+
+  if constexpr ( has_EXODC_interface_v<Ntk> )
+  {
+    if ( levels == -1 )
+    {
+      for ( auto i = 0u; i < sim.num_bits(); ++i )
+      {
+        if ( kitty::get_bit( care, i ) )
+        {
+          kitty::cube pat1, pat2;
+          ntk.foreach_po( [&]( auto const& f, auto po_index )
+          {
+            if ( ntk.visited( ntk.get_node( f ) ) == ntk.trav_id() ) /* PO is in TFO */
+            {
+              pat1.set_mask( po_index );
+              pat2.set_mask( po_index );
+              assert( tts[f].num_bits() == sim.num_bits() );
+              assert( tts_roots[f].num_bits() == sim.num_bits() );
+              if ( kitty::get_bit( tts[f], i ) ^ ntk.is_complemented( f ) )
+                pat1.set_bit( po_index );
+              if ( kitty::get_bit( tts_roots[f], i ) ^ ntk.is_complemented( f ) )
+                pat2.set_bit( po_index );
+            }
+          });
+
+          if ( ntk.are_observably_equivalent( pat1, pat2 ) )
+          {
+            kitty::clear_bit( care, i );
+          }
+        }
+      }
+    }
+  }
+
+  return ~care;
+}
+
+/*! \brief Check if a pattern is observable with respect to a node.
+ *
+ * A pattern is unobservable w.r.t. a node `n` if under this input assignment,
+ * replacing `n` with `!n` does not affect the value of any primary output or
+ * any leaf node of `levels` levels of transitive fanout cone.
+ *
+ * \param levels Level of transitive fanout to consider. -1 = consider until PO.
+ */
+template<class Ntk>
+bool pattern_is_observable( Ntk const& ntk, node<Ntk> const& n, std::vector<bool> const& pattern, int levels = -1 )
+{
+  partial_simulator sim( ntk.num_pis(), 0 );
+  sim.add_pattern( pattern );
+  unordered_node_map<kitty::partial_truth_table, Ntk> tts( ntk );
+
+  auto const care = observability_dont_cares( ntk, n, sim, tts, levels );
+  return !kitty::is_const0( care );
+}
+
+/*! \brief SAT-based satisfiability don't cares checker
+ *
+ * Initialize this class with a network and then call `is_dont_care` on a node
+ * to check whether the given assignment is a satisfiability don't care.
+ *
+ * The assignment is assumed to be directly at the inputs of the gate, not
+ * taking into account possible complemented fanins.
+ */
+template<class Ntk>
+struct satisfiability_dont_cares_checker
+{
+  explicit satisfiability_dont_cares_checker( Ntk const& ntk )
+      : ntk_( ntk ),
+        literals_( node_literals( ntk ) )
+  {
+    init();
+  }
+
+  bool is_dont_care( node<Ntk> const& n, std::vector<bool> const& assignment )
+  {
+    if ( ntk_.fanin_size( n ) != assignment.size() )
+      return false;
+
+    std::vector<pabc::lit> assumptions( assignment.size() );
+    ntk_.foreach_fanin( n, [&]( auto const& f, auto i ) {
+      assumptions[i] = lit_not_cond( literals_[ntk_.get_node( f )], assignment[i] == ntk_.is_complemented( f ) );
+    } );
+
+    return solver_.solve( &assumptions[0], &assumptions[0] + assumptions.size(), 0 ) == percy::failure;
+  }
+
+private:
+  void init()
+  {
+    generate_cnf<Ntk>(
+        ntk_, [&]( auto const& clause ) {
+          solver_.add_clause( clause );
+        },
+        literals_ );
+  }
+
+private:
+  Ntk const& ntk_;
+  percy::bsat_wrapper solver_;
+  node_map<uint32_t, Ntk> literals_;
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/dsd_decomposition.hpp b/include/mockturtle/algorithms/dsd_decomposition.hpp
new file mode 100644
index 0000000..66bbaf6
--- /dev/null
+++ b/include/mockturtle/algorithms/dsd_decomposition.hpp
@@ -0,0 +1,238 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file dsd_decomposition.hpp
+  \brief DSD decomposition
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include "../traits.hpp"
+
+#include <fmt/format.h>
+#include <kitty/constructors.hpp>
+#include <kitty/decomposition.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/operators.hpp>
+#include <kitty/print.hpp>
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for dsd_decomposition */
+struct dsd_decomposition_params
+{
+  /*! \brief Apply XOR decomposition. */
+  bool with_xor{ true };
+};
+
+namespace detail
+{
+
+template<class Ntk, class Fn>
+class dsd_decomposition_impl
+{
+public:
+  dsd_decomposition_impl( Ntk& ntk, kitty::dynamic_truth_table const& func, std::vector<signal<Ntk>> const& children, Fn&& on_prime, dsd_decomposition_params const& ps )
+      : _ntk( ntk ),
+        remainder( func ),
+        pis( children ),
+        _on_prime( on_prime ),
+        _ps( ps )
+  {
+    for ( auto i = 0u; i < func.num_vars(); ++i )
+    {
+      if ( kitty::has_var( func, i ) )
+      {
+        support.push_back( i );
+      }
+    }
+  }
+
+  signal<Ntk> run()
+  {
+    /* terminal cases */
+    if ( kitty::is_const0( remainder ) )
+    {
+      return _ntk.get_constant( false );
+    }
+    if ( kitty::is_const0( ~remainder ) )
+    {
+      return _ntk.get_constant( true );
+    }
+
+    /* projection case */
+    if ( support.size() == 1u )
+    {
+      auto var = remainder.construct();
+      kitty::create_nth_var( var, support.front() );
+      if ( remainder == var )
+      {
+        return pis[support.front()];
+      }
+      else
+      {
+        if ( remainder != ~var )
+        {
+          fmt::print( "remainder = {}, vars = {}\n", kitty::to_binary( remainder ), remainder.num_vars() );
+          assert( false );
+        }
+        assert( remainder == ~var );
+        return _ntk.create_not( pis[support.front()] );
+      }
+    }
+
+    /* try top decomposition */
+    for ( auto var : support )
+    {
+      if ( auto res = kitty::is_top_decomposable( remainder, var, &remainder, _ps.with_xor );
+           res != kitty::top_decomposition::none )
+      {
+        /* remove var from support, pis do not change */
+        support.erase( std::remove( support.begin(), support.end(), var ), support.end() );
+        const auto right = run();
+
+        switch ( res )
+        {
+        default:
+          assert( false );
+        case kitty::top_decomposition::and_:
+          return _ntk.create_and( pis[var], right );
+        case kitty::top_decomposition::or_:
+          return _ntk.create_or( pis[var], right );
+        case kitty::top_decomposition::lt_:
+          return _ntk.create_lt( pis[var], right );
+        case kitty::top_decomposition::le_:
+          return _ntk.create_le( pis[var], right );
+        case kitty::top_decomposition::xor_:
+          return _ntk.create_xor( pis[var], right );
+        }
+      }
+    }
+
+    /* try bottom decomposition */
+    for ( auto j = 1u; j < support.size(); ++j )
+    {
+      for ( auto i = 0u; i < j; ++i )
+      {
+        if ( auto res = kitty::is_bottom_decomposable( remainder, support[i], support[j], &remainder, _ps.with_xor );
+             res != kitty::bottom_decomposition::none )
+        {
+          /* update pis based on decomposition type */
+          switch ( res )
+          {
+          default:
+            assert( false );
+          case kitty::bottom_decomposition::and_:
+            pis[support[i]] = _ntk.create_and( pis[support[i]], pis[support[j]] );
+            break;
+          case kitty::bottom_decomposition::or_:
+            pis[support[i]] = _ntk.create_or( pis[support[i]], pis[support[j]] );
+            break;
+          case kitty::bottom_decomposition::lt_:
+            pis[support[i]] = _ntk.create_lt( pis[support[i]], pis[support[j]] );
+            break;
+          case kitty::bottom_decomposition::le_:
+            pis[support[i]] = _ntk.create_le( pis[support[i]], pis[support[j]] );
+            break;
+          case kitty::bottom_decomposition::xor_:
+            pis[support[i]] = _ntk.create_xor( pis[support[i]], pis[support[j]] );
+            break;
+          }
+
+          /* remove var from support */
+          support.erase( support.begin() + j );
+
+          return run();
+        }
+      }
+    }
+
+    /* cannot decompose anymore */
+    std::vector<signal<Ntk>> new_pis;
+    for ( auto var : support )
+    {
+      new_pis.push_back( pis[var] );
+    }
+    auto prime_large = remainder;
+    kitty::min_base_inplace( prime_large );
+    auto prime = kitty::shrink_to( prime_large, static_cast<unsigned int>( support.size() ) );
+    return _on_prime( prime, new_pis );
+  }
+
+private:
+  Ntk& _ntk;
+  kitty::dynamic_truth_table remainder;
+  std::vector<uint8_t> support;
+  std::vector<signal<Ntk>> pis;
+  Fn&& _on_prime;
+  dsd_decomposition_params const& _ps;
+};
+
+} // namespace detail
+
+/*! \brief DSD decomposition
+ *
+ * This function applies DSD decomposition on an input truth table and
+ * constructs a network based on all possible decompositions.  If the truth
+ * table is only partially decomposable, then the remaining *prime function*
+ * is returned back to the caller using the call back `on_prime` together with
+ * the computed primary inputs for that remainder.
+ *
+ * The `on_prime` function must be of type `NtkDest::signal(
+ * kitty::dynamic_truth_table const&, std::vector<NtkDest::signal> const&)`.
+ *
+ * **Required network functions:**
+ * - `create_not`
+ * - `create_and`
+ * - `create_or`
+ * - `create_lt`
+ * - `create_le`
+ * - `create_xor`
+ */
+template<class Ntk, class Fn>
+signal<Ntk> dsd_decomposition( Ntk& ntk, kitty::dynamic_truth_table const& func, std::vector<signal<Ntk>> const& children, Fn&& on_prime, dsd_decomposition_params const& ps = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+  static_assert( has_create_and_v<Ntk>, "Ntk does not implement the create_and method" );
+  static_assert( has_create_or_v<Ntk>, "Ntk does not implement the create_or method" );
+  static_assert( has_create_lt_v<Ntk>, "Ntk does not implement the create_lt method" );
+  static_assert( has_create_le_v<Ntk>, "Ntk does not implement the create_le method" );
+  static_assert( has_create_xor_v<Ntk>, "Ntk does not implement the create_xor method" );
+
+  detail::dsd_decomposition_impl<Ntk, Fn> impl( ntk, func, children, on_prime, ps );
+  return impl.run();
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/emap.hpp b/include/mockturtle/algorithms/emap.hpp
new file mode 100644
index 0000000..055d9b2
--- /dev/null
+++ b/include/mockturtle/algorithms/emap.hpp
@@ -0,0 +1,5972 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2024  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file emap.hpp
+  \brief An extended technology mapper
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <chrono>
+#include <cstdint>
+#include <limits>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/hash.hpp>
+#include <kitty/static_truth_table.hpp>
+
+#include <fmt/format.h>
+#include <parallel_hashmap/phmap.h>
+
+#include "../networks/aig.hpp"
+#include "../networks/block.hpp"
+#include "../networks/klut.hpp"
+#include "../utils/cuts.hpp"
+#include "../utils/node_map.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../utils/tech_library.hpp"
+#include "../views/binding_view.hpp"
+#include "../views/cell_view.hpp"
+#include "../views/choice_view.hpp"
+#include "../views/topo_view.hpp"
+#include "cleanup.hpp"
+#include "cut_enumeration.hpp"
+#include "detail/mffc_utils.hpp"
+#include "detail/switching_activity.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for emap.
+ *
+ * The data structure `emap_params` holds configurable parameters
+ * with default arguments for `emap`.
+ */
+struct emap_params
+{
+  emap_params()
+  {
+    cut_enumeration_ps.cut_limit = 16;
+    cut_enumeration_ps.minimize_truth_table = true;
+  }
+
+  /*! \brief Parameters for cut enumeration
+   *
+   * The default cut limit is 16.
+   * The maximum cut limit is 19.
+   * By default, truth table minimization
+   * is performed.
+   */
+  cut_enumeration_params cut_enumeration_ps{};
+
+  /*! \brief Do area-oriented mapping. */
+  bool area_oriented_mapping{ false };
+
+  /*! \brief Maps using multi-output gates */
+  bool map_multioutput{ false };
+
+  /*! \brief Matching mode
+   *
+   * Boolean uses Boolean matching (up to 6-input cells),
+   * Structural uses pattern matching for fully-DSD cells,
+   * Hybrid combines the two.
+   */
+  enum matching_mode_t
+  {
+    boolean,
+    structural,
+    hybrid
+  } matching_mode = hybrid;
+
+  /*! \brief Target required time (for each PO). */
+  double required_time{ 0.0f };
+
+  /*! \brief Required time relaxation in percentage (10 = 10%). */
+  double relax_required{ 0.0f };
+
+  /*! \brief Custom input arrival times. */
+  std::vector<double> arrival_times{};
+
+  /*! \brief Custom output required times. */
+  std::vector<double> required_times{};
+
+  /*! \brief Number of rounds for area flow optimization. */
+  uint32_t area_flow_rounds{ 3u };
+
+  /*! \brief Number of rounds for exact area optimization. */
+  uint32_t ela_rounds{ 2u };
+
+  /*! \brief Number of rounds for exact switching power optimization. */
+  uint32_t eswp_rounds{ 0u };
+
+  /*! \brief Number of patterns for switching activity computation. */
+  uint32_t switching_activity_patterns{ 2048u };
+
+  /*! \brief Compute area-oriented alternative matches */
+  bool use_match_alternatives{ true };
+
+  /*! \brief Remove the cuts that are contained in others */
+  bool remove_dominated_cuts{ false };
+
+  /*! \brief Remove overlapping multi-output cuts */
+  bool remove_overlapping_multicuts{ false };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+};
+
+/*! \brief Statistics for emap.
+ *
+ * The data structure `emap_stats` provides data collected by running
+ * `emap`.
+ */
+struct emap_stats
+{
+  /*! \brief Area result. */
+  double area{ 0 };
+  /*! \brief Worst delay result. */
+  double delay{ 0 };
+  /*! \brief Power result. */
+  double power{ 0 };
+  /*! \brief Power result. */
+  uint32_t inverters{ 0 };
+
+  /*! \brief Mapped multi-output gates. */
+  uint32_t multioutput_gates{ 0 };
+
+  /*! \brief Runtime for multi-output matching. */
+  stopwatch<>::duration time_multioutput{ 0 };
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Cut enumeration stats. */
+  cut_enumeration_stats cut_enumeration_st{};
+
+  /*! \brief Delay and area stats for each round. */
+  std::vector<std::string> round_stats{};
+
+  /*! \brief Mapping error. */
+  bool mapping_error{ false };
+
+  void report() const
+  {
+    for ( auto const& stat : round_stats )
+    {
+      std::cout << stat;
+    }
+    std::cout << fmt::format( "[i] Area = {:>5.2f}; Delay = {:>5.2f};", area, delay );
+    if ( power != 0 )
+      std::cout << fmt::format( " Power = {:>5.2f};\n", power );
+    else
+      std::cout << "\n";
+    if ( multioutput_gates )
+    {
+      std::cout << fmt::format( "[i] Multi-output gates   = {:>5}\n", multioutput_gates );
+      std::cout << fmt::format( "[i] Multi-output runtime = {:>5.2f} secs\n", to_seconds( time_multioutput ) );
+    }
+    std::cout << fmt::format( "[i] Total runtime        = {:>5.2f} secs\n", to_seconds( time_total ) );
+  }
+};
+
+namespace detail
+{
+
+#pragma region cut set
+template<unsigned NInputs>
+struct cut_enumeration_emap_cut
+{
+  /* stats */
+  uint32_t delay;
+  float flow;
+  bool ignore;
+
+  /* pattern index for structural matching*/
+  uint32_t pattern_index;
+
+  /* function */
+  kitty::static_truth_table<6> function;
+
+  /* list of supergates matching the cut for positive and negative output phases */
+  std::array<std::vector<supergate<NInputs>> const*, 2> supergates;
+  /* input negations, 0: pos, 1: neg */
+  std::array<uint16_t, 2> negations;
+};
+
+struct cut_enumeration_emap_multi_cut
+{
+  /* stats */
+  uint64_t id{ 0 };
+};
+
+enum class emap_cut_sort_type
+{
+  DELAY = 0,
+  DELAY2 = 1,
+  AREA = 2,
+  AREA2 = 3,
+  NONE = 4
+};
+
+template<typename CutType, uint32_t MaxCuts>
+class emap_cut_set
+{
+public:
+  /*! \brief Standard constructor.
+   */
+  emap_cut_set()
+  {
+    clear();
+  }
+
+  /*! \brief Assignment operator.
+   */
+  emap_cut_set& operator=( emap_cut_set const& other )
+  {
+    if ( this != &other )
+    {
+      _pcend = _pend = _pcuts.begin();
+      _set_limit = other._set_limit;
+
+      auto it = other.begin();
+      while ( it != other.end() )
+      {
+        **_pend++ = **it++;
+        ++_pcend;
+      }
+    }
+
+    return *this;
+  }
+
+  /*! \brief Clears a cut set.
+   */
+  void clear()
+  {
+    _pcend = _pend = _pcuts.begin();
+    auto pit = _pcuts.begin();
+    for ( auto& c : _cuts )
+    {
+      *pit++ = &c;
+    }
+  }
+
+  /*! \brief Sets the cut limit.
+   */
+  void set_cut_limit( uint32_t limit )
+  {
+    _set_limit = std::min( MaxCuts, limit );
+  }
+
+  /*! \brief Adds a cut to the end of the set.
+   *
+   * This function should only be called to create a set of cuts which is known
+   * to be sorted and irredundant (i.e., no cut in the set dominates another
+   * cut).
+   *
+   * \param begin Begin iterator to leaf indexes
+   * \param end End iterator (exclusive) to leaf indexes
+   * \return Reference to the added cut
+   */
+  template<typename Iterator>
+  CutType& add_cut( Iterator begin, Iterator end )
+  {
+    assert( _pend != _pcuts.end() );
+
+    auto& cut = **_pend++;
+    cut.set_leaves( begin, end );
+
+    ++_pcend;
+    return cut;
+  }
+
+  /*! \brief Appends a cut to the end of the set.
+   *
+   * This function should only be called to create a set of cuts which is known
+   * to be sorted and irredundant (i.e., no cut in the set dominates another
+   * cut).
+   *
+   * \param cut Cut to insert
+   */
+  void append_cut( CutType const& cut )
+  {
+    assert( _pend != _pcuts.end() );
+
+    **_pend++ = cut;
+    ++_pcend;
+  }
+
+  /*! \brief Checks whether cut is dominates by any cut in the set.
+   *
+   * \param cut Cut outside of the set
+   */
+  bool is_dominated( CutType const& cut ) const
+  {
+    return std::find_if( _pcuts.begin(), _pcend, [&cut]( auto const* other ) { return other->dominates( cut ); } ) != _pcend;
+  }
+
+  static bool sort_delay( CutType const& c1, CutType const& c2 )
+  {
+    constexpr auto eps{ 0.005f };
+    if ( !c1->ignore && c2->ignore )
+      return true;
+    if ( c1->ignore && !c2->ignore )
+      return false;
+    if ( c1->delay < c2->delay - eps )
+      return true;
+    if ( c1->delay > c2->delay + eps )
+      return false;
+    if ( c1->flow < c2->flow - eps )
+      return true;
+    if ( c1->flow > c2->flow + eps )
+      return false;
+    return c1.size() < c2.size();
+  }
+
+  static bool sort_delay2( CutType const& c1, CutType const& c2 )
+  {
+    constexpr auto eps{ 0.005f };
+    if ( !c1->ignore && c2->ignore )
+      return true;
+    if ( c1->ignore && !c2->ignore )
+      return false;
+    if ( c1.size() < c2.size() )
+      return true;
+    if ( c1.size() > c2.size() )
+      return false;
+    if ( c1->delay < c2->delay - eps )
+      return true;
+    if ( c1->delay > c2->delay + eps )
+      return false;
+    return c1->flow < c2->flow - eps;
+  }
+
+  static bool sort_area( CutType const& c1, CutType const& c2 )
+  {
+    constexpr auto eps{ 0.005f };
+    if ( !c1->ignore && c2->ignore )
+      return true;
+    if ( c1->ignore && !c2->ignore )
+      return false;
+    if ( c1->flow < c2->flow - eps )
+      return true;
+    if ( c1->flow > c2->flow + eps )
+      return false;
+    if ( c1.size() < c2.size() )
+      return true;
+    if ( c1.size() > c2.size() )
+      return false;
+    return c1->delay < c2->delay - eps;
+  }
+
+  static bool sort_area2( CutType const& c1, CutType const& c2 )
+  {
+    constexpr auto eps{ 0.005f };
+    if ( !c1->ignore && c2->ignore )
+      return true;
+    if ( c1->ignore && !c2->ignore )
+      return false;
+    if ( c1->flow < c2->flow - eps )
+      return true;
+    if ( c1->flow > c2->flow + eps )
+      return false;
+    if ( c1->delay < c2->delay - eps )
+      return true;
+    if ( c1->delay > c2->delay + eps )
+      return false;
+    return c1.size() < c2.size();
+  }
+
+  /*! \brief Compare two cuts using sorting functions.
+   *
+   * This method compares two cuts using a sorting function.
+   *
+   * \param cut1 first cut.
+   * \param cut2 second cut.
+   * \param sort sorting function.
+   */
+  static bool compare( CutType const& cut1, CutType const& cut2, emap_cut_sort_type sort = emap_cut_sort_type::NONE )
+  {
+    if ( sort == emap_cut_sort_type::DELAY )
+    {
+      return sort_delay( cut1, cut2 );
+    }
+    else if ( sort == emap_cut_sort_type::DELAY2 )
+    {
+      return sort_delay2( cut1, cut2 );
+    }
+    else if ( sort == emap_cut_sort_type::AREA )
+    {
+      return sort_area( cut1, cut2 );
+    }
+    else if ( sort == emap_cut_sort_type::AREA2 )
+    {
+      return sort_area2( cut1, cut2 );
+    }
+    else
+    {
+      return false;
+    }
+  }
+
+  /*! \brief Inserts a cut into a set without checking dominance.
+   *
+   * This method will insert a cut into a set and maintain an order.  This
+   * method doesn't remove the cuts that are dominated by `cut`.
+   *
+   * If `cut` is dominated by any of the cuts in the set, it will still be
+   * inserted.  The caller is responsible to check whether `cut` is dominated
+   * before inserting it into the set.
+   *
+   * \param cut Cut to insert.
+   * \param sort Cut prioritization function.
+   */
+  void simple_insert( CutType const& cut, emap_cut_sort_type sort = emap_cut_sort_type::NONE )
+  {
+    /* insert cut in a sorted way */
+    typename std::array<CutType*, MaxCuts>::iterator ipos = _pcuts.begin();
+
+    bool limit_reached = std::distance( _pcuts.begin(), _pend ) >= _set_limit;
+
+    /* do not insert if worst than set_limit */
+    if ( limit_reached )
+    {
+      if ( sort == emap_cut_sort_type::AREA && !sort_area( cut, **( ipos + _set_limit - 1 ) ) )
+      {
+        return;
+      }
+      else if ( sort != emap_cut_sort_type::AREA )
+      {
+        return;
+      }
+    }
+
+    if ( sort == emap_cut_sort_type::NONE )
+    {
+      ipos = _pend;
+    }
+    else /* AREA */
+    {
+      ipos = std::upper_bound( _pcuts.begin(), _pend, &cut, []( auto a, auto b ) { return sort_area( *a, *b ); } );
+    }
+
+    /* check for redundant cut */
+    typename std::array<CutType*, MaxCuts>::iterator jpos = ipos;
+    if ( cut->ignore )
+    {
+      while ( jpos != _pcuts.begin() )
+      {
+        --jpos;
+        if ( ( *jpos )->size() < cut.size() )
+          break;
+        if ( ( *jpos )->signature() == cut.signature() && std::equal( cut.begin(), cut.end(), ( *jpos )->begin() ) )
+          return;
+      }
+    }
+    else if ( ipos != _pcuts.begin() )
+    {
+      if ( ( *( ipos - 1 ) )->signature() == cut.signature() && std::equal( cut.begin(), cut.end(), ( *( ipos - 1 ) )->begin() ) )
+      {
+        return;
+      }
+    }
+
+    /* too many cuts, we need to remove one */
+    if ( _pend == _pcuts.end() || limit_reached )
+    {
+      /* cut to be inserted is worse than all the others, return */
+      if ( ipos == _pend )
+      {
+        return;
+      }
+      else
+      {
+        /* remove last cut */
+        --_pend;
+        --_pcend;
+      }
+    }
+
+    /* copy cut */
+    auto& icut = *_pend;
+    icut->set_leaves( cut.begin(), cut.end() );
+    icut->data() = cut.data();
+
+    if ( ipos != _pend )
+    {
+      auto it = _pend;
+      while ( it > ipos )
+      {
+        std::swap( *it, *( it - 1 ) );
+        --it;
+      }
+    }
+
+    /* update iterators */
+    _pcend++;
+    _pend++;
+  }
+
+  /*! \brief Inserts a cut into a set.
+   *
+   * This method will insert a cut into a set and maintain an order.  Before the
+   * cut is inserted into the correct position, it will remove all cuts that are
+   * dominated by `cut`. Variable `skip0` tell to skip the dominance check on
+   * cut zero.
+   *
+   * If `cut` is dominated by any of the cuts in the set, it will still be
+   * inserted.  The caller is responsible to check whether `cut` is dominated
+   * before inserting it into the set.
+   *
+   * \param cut Cut to insert.
+   * \param skip0 Skip dominance check on cut zero.
+   * \param sort Cut prioritization function.
+   */
+  void insert( CutType const& cut, bool skip0 = false, emap_cut_sort_type sort = emap_cut_sort_type::NONE )
+  {
+    auto begin = _pcuts.begin();
+
+    if ( skip0 && _pend != _pcuts.begin() )
+      ++begin;
+
+    /* remove elements that are dominated by new cut */
+    _pcend = _pend = std::stable_partition( begin, _pend, [&cut]( auto const* other ) { return !cut.dominates( *other ); } );
+
+    /* insert cut in a sorted way */
+    simple_insert( cut, sort );
+  }
+
+  /*! \brief Replaces a cut of the set.
+   *
+   * This method replaces the cut at position `index` in the set by `cut`
+   * and maintains the cuts order. The function does not check whether
+   * index is in the valid range.
+   *
+   * \param index Index of the cut to replace.
+   * \param cut Cut to insert.
+   */
+  void replace( uint32_t index, CutType const& cut )
+  {
+    *_pcuts[index] = cut;
+  }
+
+  /*! \brief Begin iterator (constant).
+   *
+   * The iterator will point to a cut pointer.
+   */
+  auto begin() const { return _pcuts.begin(); }
+
+  /*! \brief End iterator (constant). */
+  auto end() const { return _pcend; }
+
+  /*! \brief Begin iterator (mutable).
+   *
+   * The iterator will point to a cut pointer.
+   */
+  auto begin() { return _pcuts.begin(); }
+
+  /*! \brief End iterator (mutable). */
+  auto end() { return _pend; }
+
+  /*! \brief Number of cuts in the set. */
+  auto size() const { return _pcend - _pcuts.begin(); }
+
+  /*! \brief Returns reference to cut at index.
+   *
+   * This function does not return the cut pointer but dereferences it and
+   * returns a reference.  The function does not check whether index is in the
+   * valid range.
+   *
+   * \param index Index
+   */
+  auto const& operator[]( uint32_t index ) const { return *_pcuts[index]; }
+
+  /*! \brief Returns the best cut, i.e., the first cut.
+   */
+  auto const& best() const { return *_pcuts[0]; }
+
+  /*! \brief Updates the best cut.
+   *
+   * This method will set the cut at index `index` to be the best cut.  All
+   * cuts before `index` will be moved one position higher.
+   *
+   * \param index Index of new best cut
+   */
+  void update_best( uint32_t index )
+  {
+    auto* best = _pcuts[index];
+    for ( auto i = index; i > 0; --i )
+    {
+      _pcuts[i] = _pcuts[i - 1];
+    }
+    _pcuts[0] = best;
+  }
+
+  /*! \brief Resize the cut set, if it is too large.
+   *
+   * This method will resize the cut set to `size` only if the cut set has more
+   * than `size` elements.  Otherwise, the size will remain the same.
+   */
+  void limit( uint32_t size )
+  {
+    if ( std::distance( _pcuts.begin(), _pend ) > static_cast<long>( size ) )
+    {
+      _pcend = _pend = _pcuts.begin() + size;
+    }
+  }
+
+  /*! \brief Prints a cut set. */
+  friend std::ostream& operator<<( std::ostream& os, emap_cut_set const& set )
+  {
+    for ( auto const& c : set )
+    {
+      os << *c << "\n";
+    }
+    return os;
+  }
+
+  /*! \brief Returns if the cut set contains already `cut`. */
+  bool is_contained( CutType const& cut )
+  {
+    typename std::array<CutType*, MaxCuts>::iterator ipos = _pcuts.begin();
+
+    while ( ipos != _pend )
+    {
+      if ( ( *ipos )->signature() == cut.signature() && std::equal( cut.begin(), cut.end(), ( *ipos )->begin() ) )
+        return true;
+      ++ipos;
+    }
+
+    return false;
+  }
+
+private:
+  std::array<CutType, MaxCuts> _cuts;
+  std::array<CutType*, MaxCuts> _pcuts;
+  typename std::array<CutType*, MaxCuts>::const_iterator _pcend{ _pcuts.begin() };
+  typename std::array<CutType*, MaxCuts>::iterator _pend{ _pcuts.begin() };
+  uint32_t _set_limit{ MaxCuts };
+};
+#pragma endregion
+
+#pragma region Hashing
+template<uint32_t max_multioutput_cut_size>
+struct emap_triple_hash
+{
+  inline uint64_t operator()( const std::array<uint32_t, max_multioutput_cut_size>& p ) const
+  {
+    uint64_t seed = hash_block( p[0] );
+
+    for ( uint32_t i = 1; i < max_multioutput_cut_size; ++i )
+    {
+      hash_combine( seed, hash_block( p[i] ) );
+    }
+
+    return seed;
+  }
+};
+#pragma endregion
+
+template<unsigned NInputs>
+struct best_gate_emap
+{
+  supergate<NInputs> const* gate;
+  double arrival;
+  float area;
+  float flow;
+  unsigned phase : 16;
+  unsigned cut : 12;
+  unsigned size : 4;
+};
+
+template<unsigned NInputs>
+struct node_match_emap
+{
+  /* best gate match for positive and negative output phases */
+  supergate<NInputs> const* best_gate[2];
+  /* alternative best gate for positibe and negative output phase */
+  best_gate_emap<NInputs> best_alternative[2];
+  /* fanin pin phases for both output phases */
+  uint16_t phase[2];
+  /* best cut index for both phases */
+  uint16_t best_cut[2];
+  /* node is mapped using only one phase */
+  bool same_match;
+  /* node is mapped to a multi-output gate */
+  bool multioutput_match[2];
+
+  /* arrival time at node output */
+  double arrival[2];
+  /* required time at node output */
+  double required[2];
+  /* area of the best matches */
+  float area[2];
+
+  /* number of references in the cover 0: pos, 1: neg */
+  uint32_t map_refs[2];
+  /* references estimation */
+  float est_refs[2];
+  /* area flow */
+  float flows[2];
+};
+
+template<class Ntk, unsigned CutSize, unsigned NInputs, classification_type Configuration>
+class emap_impl
+{
+private:
+  union multi_match_data
+  {
+    uint64_t data{ 0 };
+    struct
+    {
+      uint64_t in_tfi : 1;
+      uint64_t cut_index : 31;
+      uint64_t node_index : 32;
+    };
+  };
+  union multioutput_info
+  {
+    uint32_t data;
+    struct
+    {
+      unsigned index : 29;
+      unsigned lowest_index : 1;
+      unsigned highest_index : 1;
+      unsigned has_info : 1;
+    };
+  };
+
+public:
+  static constexpr float epsilon = 0.0005;
+  static constexpr uint32_t max_cut_num = 20;
+  using cut_t = cut<CutSize, cut_enumeration_emap_cut<NInputs>>;
+  using cut_set_t = emap_cut_set<cut_t, max_cut_num>;
+  using cut_merge_t = typename std::array<cut_set_t*, Ntk::max_fanin_size + 1>;
+  using fanin_cut_t = typename std::array<cut_t const*, Ntk::max_fanin_size>;
+  using support_t = typename std::array<uint8_t, CutSize>;
+  using TT = kitty::static_truth_table<6>;
+  using truth_compute_t = typename std::array<TT, CutSize>;
+  using node_match_t = std::vector<node_match_emap<NInputs>>;
+  using klut_map = std::unordered_map<uint32_t, std::array<signal<klut_network>, 2>>;
+  using block_map = std::unordered_map<uint32_t, std::array<signal<block_network>, 2>>;
+
+  static constexpr uint32_t max_multioutput_cut_size = 3;
+  static constexpr uint32_t max_multioutput_output_size = 2;
+  using multi_cuts_t = fast_network_cuts<Ntk, max_multioutput_cut_size, true, cut_enumeration_emap_multi_cut>;
+  using multi_cut_t = typename multi_cuts_t::cut_t;
+  using multi_leaves_set_t = std::array<uint32_t, max_multioutput_cut_size>;
+  using multi_output_set_t = std::vector<multi_match_data>;
+  using multi_hash_t = phmap::flat_hash_map<multi_leaves_set_t, multi_output_set_t, emap_triple_hash<max_multioutput_cut_size>>;
+  using multi_match_t = std::array<multi_match_data, max_multioutput_output_size>;
+  using multi_cut_set_t = std::vector<std::array<cut_t, max_multioutput_output_size>>;
+  using multi_single_matches_t = std::vector<multi_match_t>;
+  using multi_matches_t = std::vector<std::vector<multi_match_t>>;
+
+  using clock = typename std::chrono::steady_clock;
+  using time_point = typename clock::time_point;
+
+public:
+  explicit emap_impl( Ntk const& ntk, tech_library<NInputs, Configuration> const& library, emap_params const& ps, emap_stats& st )
+      : ntk( ntk ),
+        library( library ),
+        ps( ps ),
+        st( st ),
+        node_match( ntk.size() ),
+        node_tuple_match( ntk.size() ),
+        switch_activity( ps.eswp_rounds ? switching_activity( ntk, ps.switching_activity_patterns ) : std::vector<float>( 0 ) ),
+        cuts( ntk.size() )
+  {
+    std::memset( node_tuple_match.data(), 0, sizeof( multioutput_info ) * ntk.size() );
+    std::tie( lib_inv_area, lib_inv_delay, lib_inv_id ) = library.get_inverter_info();
+    std::tie( lib_buf_area, lib_buf_delay, lib_buf_id ) = library.get_buffer_info();
+    tmp_visited.reserve( 100 );
+  }
+
+  explicit emap_impl( Ntk const& ntk, tech_library<NInputs, Configuration> const& library, std::vector<float> const& switch_activity, emap_params const& ps, emap_stats& st )
+      : ntk( ntk ),
+        library( library ),
+        ps( ps ),
+        st( st ),
+        node_match( ntk.size() ),
+        node_tuple_match( ntk.size() ),
+        switch_activity( switch_activity ),
+        cuts( ntk.size() )
+  {
+    std::memset( node_tuple_match.data(), 0, sizeof( multioutput_info ) * ntk.size() );
+    std::tie( lib_inv_area, lib_inv_delay, lib_inv_id ) = library.get_inverter_info();
+    std::tie( lib_buf_area, lib_buf_delay, lib_buf_id ) = library.get_buffer_info();
+    tmp_visited.reserve( 100 );
+  }
+
+  cell_view<block_network> run_block()
+  {
+    time_begin = clock::now();
+
+    auto [res, old2new] = initialize_block_network();
+
+    /* multi-output initialization */
+    if ( ps.map_multioutput && ps.matching_mode != emap_params::structural )
+    {
+      compute_multioutput_match();
+    }
+
+    /* compute and save topological order */
+    init_topo_order();
+
+    /* init arrival time */
+    if ( !init_arrivals() )
+      return res;
+
+    /* search for large matches */
+    if ( ps.matching_mode == emap_params::structural || CutSize > 6 )
+    {
+      if ( !compute_struct_match() )
+      {
+        return res;
+      }
+    }
+
+    /* compute cuts, matches, and initial mapping */
+    if ( !ps.area_oriented_mapping )
+    {
+      if ( !compute_mapping_match<false>() )
+      {
+        return res;
+      }
+    }
+    else
+    {
+      if ( !compute_mapping_match<true>() )
+      {
+        return res;
+      }
+    }
+
+    /* run area recovery */
+    if ( !improve_mapping() )
+      return res;
+
+    /* insert buffers for POs driven by PIs */
+    insert_buffers();
+
+    /* generate the output network */
+    finalize_cover_block( res, old2new );
+    st.time_total = ( clock::now() - time_begin );
+
+    return res;
+  }
+
+  binding_view<klut_network> run_klut()
+  {
+    time_begin = clock::now();
+
+    auto [res, old2new] = initialize_map_network();
+
+    /* multi-output initialization */
+    if ( ps.map_multioutput && ps.matching_mode != emap_params::structural )
+    {
+      compute_multioutput_match();
+    }
+
+    /* compute and save topological order */
+    init_topo_order();
+
+    /* init arrival time */
+    if ( !init_arrivals() )
+      return res;
+
+    /* search for large matches */
+    if ( ps.matching_mode == emap_params::structural || CutSize > 6 )
+    {
+      if ( !compute_struct_match() )
+      {
+        return res;
+      }
+    }
+
+    /* compute cuts, matches, and initial mapping */
+    if ( !ps.area_oriented_mapping )
+    {
+      if ( !compute_mapping_match<false>() )
+      {
+        return res;
+      }
+    }
+    else
+    {
+      if ( !compute_mapping_match<true>() )
+      {
+        return res;
+      }
+    }
+
+    /* run area recovery */
+    if ( !improve_mapping() )
+      return res;
+
+    /* insert buffers for POs driven by PIs */
+    insert_buffers();
+
+    /* generate the output network */
+    finalize_cover( res, old2new );
+    st.time_total = ( clock::now() - time_begin );
+
+    return res;
+  }
+
+  binding_view<klut_network> run_node_map()
+  {
+    time_begin = clock::now();
+
+    auto [res, old2new] = initialize_map_network();
+
+    /* [i] multi-output support is currently not implemented */
+
+    /* compute and save topological order */
+    init_topo_order();
+
+    /* init arrival time */
+    if ( !init_arrivals() )
+      return res;
+
+    /* compute cuts, matches, and initial mapping */
+    if ( !ps.area_oriented_mapping )
+    {
+      if ( !compute_mapping_match_node<false>() )
+      {
+        return res;
+      }
+    }
+    else
+    {
+      if ( !compute_mapping_match_node<true>() )
+      {
+        return res;
+      }
+    }
+
+    /* run area recovery */
+    if ( !improve_mapping() )
+      return res;
+
+    /* insert buffers for POs driven by PIs */
+    insert_buffers();
+
+    /* generate the output network */
+    finalize_cover( res, old2new );
+    st.time_total = ( clock::now() - time_begin );
+
+    return res;
+  }
+
+private:
+  bool improve_mapping()
+  {
+    /* compute mapping using global area flow */
+    uint32_t i = 0;
+    while ( i++ < ps.area_flow_rounds )
+    {
+      if ( !compute_mapping<true>() )
+      {
+        return false;
+      }
+    }
+
+    /* compute mapping using exact area */
+    i = 0;
+    compute_required_time( true );
+    while ( i++ < ps.ela_rounds )
+    {
+      if ( !compute_mapping_exact_reversed<false>() )
+      {
+        return false;
+      }
+    }
+
+    /* compute mapping using exact switching activity estimation */
+    i = 0;
+    while ( i++ < ps.eswp_rounds )
+    {
+      if ( !compute_mapping_exact_reversed<true>() )
+      {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+#pragma region Core
+  template<bool DO_AREA>
+  bool compute_mapping_match()
+  {
+    bool warning_box = false;
+
+    for ( auto const& n : topo_order )
+    {
+      auto const index = ntk.node_to_index( n );
+
+      if ( !compute_matches_node<DO_AREA>( n, warning_box ) )
+      {
+        continue;
+      }
+
+      /* load multi-output cuts and data */
+      if ( ps.map_multioutput && node_tuple_match[index].has_info )
+      {
+        match_multi_add_cuts( n );
+      }
+
+      /* match positive phase */
+      match_phase<DO_AREA>( n, 0u );
+
+      /* match negative phase */
+      match_phase<DO_AREA>( n, 1u );
+
+      /* try to drop one phase */
+      match_drop_phase<DO_AREA, false>( n );
+
+      /* select alternative matches to use */
+      select_alternatives<DO_AREA>( n );
+
+      /* try multi-output matches */
+      if constexpr ( DO_AREA )
+      {
+        if ( ps.map_multioutput && node_tuple_match[index].highest_index )
+        {
+          if ( match_multioutput<DO_AREA>( n ) )
+            multi_node_update<DO_AREA>( n );
+        }
+      }
+    }
+
+    double area_old = area;
+    bool success = set_mapping_refs_and_req<DO_AREA, false>();
+
+    if ( warning_box )
+    {
+      std::cerr << "[i] MAP WARNING: not mapped don't touch gates are treated as sequential black boxes\n";
+    }
+
+    /* round stats */
+    if ( ps.verbose )
+    {
+      std::stringstream stats{};
+      float area_gain = 0.0f;
+
+      if ( iteration != 1 )
+        area_gain = float( ( area_old - area ) / area_old * 100 );
+
+      if constexpr ( DO_AREA )
+      {
+        stats << fmt::format( "[i] AreaFlow : Delay = {:>12.2f}  Area = {:>12.2f}  Gain = {:>5.2f} %  Inverters = {:>5}  Time = {:>5.2f}\n", delay, area, area_gain, inv, to_seconds( clock::now() - time_begin ) );
+      }
+      else
+      {
+        stats << fmt::format( "[i] Delay    : Delay = {:>12.2f}  Area = {:>12.2f}  Gain = {:>5.2f} %  Inverters = {:>5}  Time = {:>5.2f}\n", delay, area, area_gain, inv, to_seconds( clock::now() - time_begin ) );
+      }
+      st.round_stats.push_back( stats.str() );
+    }
+
+    return success;
+  }
+
+  template<bool DO_AREA>
+  inline bool compute_matches_node( node<Ntk> const& n, bool& warning_box )
+  {
+    auto const index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+
+    node_data.est_refs[0] = node_data.est_refs[1] = static_cast<double>( ntk.fanout_size( n ) );
+    node_data.map_refs[0] = node_data.map_refs[1] = 0;
+    node_data.required[0] = node_data.required[1] = std::numeric_limits<float>::max();
+
+    if ( ntk.is_constant( n ) )
+    {
+      /* all terminals have flow 0.0 */
+      node_data.flows[0] = node_data.flows[1] = 0.0f;
+      node_data.best_alternative[0].flow = node_data.best_alternative[1].flow = 0.0f;
+      node_data.arrival[0] = node_data.arrival[1] = 0.0f;
+      node_data.best_alternative[0].arrival = node_data.best_alternative[1].arrival = 0.0f;
+      /* skip if cuts have been computed before */
+      if ( cuts[index].size() == 0 )
+      {
+        add_zero_cut( index );
+        match_constants( index );
+      }
+      return false;
+    }
+    else if ( ntk.is_pi( n ) )
+    {
+      node_data.flows[0] = 0.0f;
+      node_data.best_alternative[0].flow = 0.0f;
+      /* PIs have the negative phase implemented with an inverter */
+      node_data.flows[1] = lib_inv_area / node_data.est_refs[1];
+      node_data.best_alternative[1].flow = lib_inv_area / node_data.est_refs[1];
+      /* skip if cuts have been computed before */
+      if ( cuts[index].size() == 0 )
+      {
+        add_unit_cut( index );
+      }
+      return false;
+    }
+
+    if ( ps.matching_mode == emap_params::structural )
+      return true;
+
+    /* don't touch box */
+    if constexpr ( has_is_dont_touch_v<Ntk> )
+    {
+      if ( ntk.is_dont_touch( n ) )
+      {
+        warning_box |= initialize_box( n );
+        return false;
+      }
+    }
+
+    /* compute cuts for node */
+    if constexpr ( Ntk::min_fanin_size == 2 && Ntk::max_fanin_size == 2 )
+    {
+      merge_cuts2<DO_AREA>( n );
+    }
+    else
+    {
+      merge_cuts<DO_AREA>( n );
+    }
+
+    return true;
+  }
+
+  template<bool DO_AREA>
+  void merge_cuts2( node<Ntk> const& n )
+  {
+    static constexpr uint32_t max_cut_size = CutSize > 6 ? 6 : CutSize;
+
+    auto index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+    emap_cut_sort_type sort = emap_cut_sort_type::AREA;
+
+    /* compute cuts */
+    const auto fanin = 2;
+    ntk.foreach_fanin( ntk.index_to_node( index ), [this]( auto child, auto i ) {
+      lcuts[i] = &cuts[ntk.node_to_index( ntk.get_node( child ) )];
+    } );
+    lcuts[2] = &cuts[index];
+    auto& rcuts = *lcuts[fanin];
+
+    /* move pre-computed structural cuts to a temporary cutset */
+    bool reinsert_cuts = false;
+    if ( rcuts.size() )
+    {
+      temp_cuts.clear();
+      for ( auto& cut : rcuts )
+      {
+        if ( ( *cut )->ignore )
+          continue;
+        recompute_cut_data( *cut, n );
+        temp_cuts.simple_insert( *cut );
+        reinsert_cuts = true;
+      }
+      rcuts.clear();
+    }
+
+    /* set cut limit for run-time optimization*/
+    rcuts.set_cut_limit( ps.cut_enumeration_ps.cut_limit );
+
+    cut_t new_cut;
+    new_cut->pattern_index = 0;
+    fanin_cut_t vcuts;
+
+    for ( auto const& c1 : *lcuts[0] )
+    {
+      /* skip cuts of pattern matching */
+      if ( ( *c1 )->pattern_index > 1 )
+        continue;
+      vcuts[0] = c1;
+
+      for ( auto const& c2 : *lcuts[1] )
+      {
+        /* skip cuts of pattern matching */
+        if ( ( *c2 )->pattern_index > 1 )
+          continue;
+
+        if ( !c1->merge( *c2, new_cut, max_cut_size ) )
+        {
+          continue;
+        }
+
+        if ( ps.remove_dominated_cuts && rcuts.is_dominated( new_cut ) )
+        {
+          continue;
+        }
+
+        /* compute function */
+        vcuts[1] = c2;
+        compute_truth_table( index, vcuts, fanin, new_cut );
+
+        /* match cut and compute data */
+        compute_cut_data( new_cut, n );
+
+        if ( ps.remove_dominated_cuts )
+          rcuts.insert( new_cut, false, sort );
+        else
+          rcuts.simple_insert( new_cut, sort );
+      }
+    }
+
+    if ( reinsert_cuts )
+    {
+      for ( auto const& cut : temp_cuts )
+      {
+        rcuts.simple_insert( *cut, sort );
+      }
+    }
+
+    cuts_total += rcuts.size();
+
+    /* limit the maximum number of cuts */
+    rcuts.limit( ps.cut_enumeration_ps.cut_limit );
+
+    /* add trivial cut */
+    if ( rcuts.size() > 1 || ( *rcuts.begin() )->size() > 1 )
+    {
+      add_unit_cut( index );
+    }
+  }
+
+  template<bool DO_AREA>
+  void merge_cuts( node<Ntk> const& n )
+  {
+    static constexpr uint32_t max_cut_size = CutSize > 6 ? 6 : CutSize;
+
+    auto index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+    emap_cut_sort_type sort = emap_cut_sort_type::AREA;
+    cut_t best_cut;
+
+    /* compute cuts */
+    std::vector<uint32_t> cut_sizes;
+    ntk.foreach_fanin( ntk.index_to_node( index ), [this, &cut_sizes]( auto child, auto i ) {
+      lcuts[i] = &cuts[ntk.node_to_index( ntk.get_node( child ) )];
+      cut_sizes.push_back( static_cast<uint32_t>( lcuts[i]->size() ) );
+    } );
+    const auto fanin = cut_sizes.size();
+    lcuts[fanin] = &cuts[index];
+    auto& rcuts = *lcuts[fanin];
+
+    /* set cut limit for run-time optimization*/
+    rcuts.set_cut_limit( ps.cut_enumeration_ps.cut_limit );
+    fanin_cut_t vcuts;
+
+    if ( fanin > 1 && fanin <= ps.cut_enumeration_ps.fanin_limit )
+    {
+      cut_t new_cut, tmp_cut;
+
+      foreach_mixed_radix_tuple( cut_sizes.begin(), cut_sizes.end(), [&]( auto begin, auto end ) {
+        auto it = vcuts.begin();
+        auto i = 0u;
+        while ( begin != end )
+        {
+          *it++ = &( ( *lcuts[i++] )[*begin++] );
+        }
+
+        if ( !vcuts[0]->merge( *vcuts[1], new_cut, max_cut_size ) )
+        {
+          return true; /* continue */
+        }
+
+        for ( i = 2; i < fanin; ++i )
+        {
+          tmp_cut = new_cut;
+          if ( !vcuts[i]->merge( tmp_cut, new_cut, max_cut_size ) )
+          {
+            return true; /* continue */
+          }
+        }
+
+        if ( ps.remove_dominated_cuts && rcuts.is_dominated( new_cut ) )
+        {
+          return true; /* continue */
+        }
+
+        compute_truth_table( index, vcuts, fanin, new_cut );
+
+        /* match cut and compute data */
+        compute_cut_data( new_cut, n );
+
+        if ( ps.remove_dominated_cuts )
+          rcuts.insert( new_cut, false, sort );
+        else
+          rcuts.simple_insert( new_cut, sort );
+
+        return true;
+      } );
+
+      /* limit the maximum number of cuts */
+      rcuts.limit( ps.cut_enumeration_ps.cut_limit );
+    }
+    else if ( fanin == 1 )
+    {
+      for ( auto const& cut : *lcuts[0] )
+      {
+        cut_t new_cut = *cut;
+        vcuts[0] = cut;
+
+        compute_truth_table( index, vcuts, fanin, new_cut );
+
+        /* match cut and compute data */
+        compute_cut_data( new_cut, n );
+
+        if ( ps.remove_dominated_cuts )
+          rcuts.insert( new_cut, false, sort );
+        else
+          rcuts.simple_insert( new_cut, sort );
+      }
+
+      /* limit the maximum number of cuts */
+      rcuts.limit( ps.cut_enumeration_ps.cut_limit );
+    }
+
+    cuts_total += rcuts.size();
+
+    add_unit_cut( index );
+  }
+
+  bool compute_struct_match()
+  {
+    if ( ps.matching_mode == emap_params::boolean )
+      return true;
+
+    /* compatible only with AIGs */
+    if constexpr ( !is_aig_network_type_v<Ntk> )
+    {
+      if ( ps.matching_mode == emap_params::structural )
+      {
+        std::cerr << "[e] MAP ERROR: structural library works only with AIGs\n";
+        return false;
+      }
+      return true;
+    }
+
+    /* no large gates identified */
+    if ( library.num_structural_gates() == 0 )
+    {
+      if ( ps.matching_mode == emap_params::structural )
+      {
+        std::cerr << "[e] MAP ERROR: structural library is empty\n";
+        return false;
+      }
+      return true;
+    }
+
+    bool warning_box = false;
+    for ( auto const& n : topo_order )
+    {
+      auto const index = ntk.node_to_index( n );
+      auto& node_data = node_match[index];
+
+      if ( ntk.is_constant( n ) )
+      {
+        add_zero_cut( index );
+        match_constants( index );
+        continue;
+      }
+      else if ( ntk.is_pi( n ) )
+      {
+        add_unit_cut( index );
+        continue;
+      }
+
+      /* don't touch box */
+      if constexpr ( has_is_dont_touch_v<Ntk> )
+      {
+        if ( ntk.is_dont_touch( n ) )
+        {
+          add_unit_cut( index );
+          continue;
+        }
+      }
+
+      /* compute cuts for node */
+      merge_cuts_structural( n );
+    }
+
+    if ( warning_box )
+    {
+      std::cerr << "[i] MAP WARNING: not mapped don't touch gates are treated as sequential black boxes\n";
+    }
+
+    /* round stats */
+    if ( ps.verbose )
+    {
+      st.round_stats.push_back( fmt::format( "[i] SCuts    : Cuts  = {:>12d}  Time = {:>12.2f}\n", cuts_total, to_seconds( clock::now() - time_begin ) ) );
+    }
+
+    return true;
+  }
+
+  void merge_cuts_structural( node<Ntk> const& n )
+  {
+    auto index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+    emap_cut_sort_type sort = emap_cut_sort_type::AREA;
+
+    /* compute cuts */
+    const auto fanin = 2;
+    std::array<uint32_t, 2> children_phase;
+    ntk.foreach_fanin( ntk.index_to_node( index ), [&]( auto child, auto i ) {
+      lcuts[i] = &cuts[ntk.node_to_index( ntk.get_node( child ) )];
+      children_phase[i] = ntk.is_complemented( child ) ? 1 : 0;
+    } );
+    lcuts[2] = &cuts[index];
+    auto& rcuts = *lcuts[fanin];
+
+    /* set cut limit for run-time optimization*/
+    rcuts.set_cut_limit( ps.cut_enumeration_ps.cut_limit );
+
+    cut_t new_cut;
+    std::vector<cut_t const*> vcuts( fanin );
+
+    for ( auto const& c1 : *lcuts[0] )
+    {
+      for ( auto const& c2 : *lcuts[1] )
+      {
+        /* filter large cuts */
+        if ( c1->size() + c2->size() > CutSize || c1->size() + c2->size() > NInputs )
+          continue;
+        /* filter cuts involving constants */
+        if ( ( *c1 )->pattern_index == 0 || ( *c2 )->pattern_index == 0 )
+          continue;
+
+        vcuts[0] = c1;
+        vcuts[1] = c2;
+        uint32_t pattern_id1 = ( ( *c1 )->pattern_index << 1 ) | children_phase[0];
+        uint32_t pattern_id2 = ( ( *c2 )->pattern_index << 1 ) | children_phase[1];
+        if ( pattern_id1 > pattern_id2 )
+        {
+          std::swap( vcuts[0], vcuts[1] );
+          std::swap( pattern_id1, pattern_id2 );
+        }
+
+        uint32_t new_pattern = library.get_pattern_id( pattern_id1, pattern_id2 );
+
+        /* pattern not matched */
+        if ( new_pattern == UINT32_MAX )
+          continue;
+
+        create_structural_cut( new_cut, vcuts, new_pattern, pattern_id1, pattern_id2 );
+
+        if ( ps.remove_dominated_cuts && rcuts.is_dominated( new_cut ) )
+          continue;
+
+        /* match cut and compute data */
+        compute_cut_data_structural( new_cut, n );
+
+        if ( ps.remove_dominated_cuts )
+          rcuts.insert( new_cut, false, sort );
+        else
+          rcuts.simple_insert( new_cut, sort );
+      }
+    }
+
+    cuts_total += rcuts.size();
+
+    /* limit the maximum number of cuts */
+    rcuts.limit( ps.cut_enumeration_ps.cut_limit );
+
+    /* add trivial cut */
+    if ( rcuts.size() > 1 || ( *rcuts.begin() )->size() > 1 )
+    {
+      add_unit_cut( index );
+    }
+  }
+
+  template<bool DO_AREA>
+  bool compute_mapping_match_node()
+  {
+    for ( auto const& n : topo_order )
+    {
+      auto const index = ntk.node_to_index( n );
+      auto& node_data = node_match[index];
+
+      node_data.best_gate[0] = node_data.best_gate[1] = nullptr;
+      node_data.same_match = 0;
+      node_data.multioutput_match[0] = node_data.multioutput_match[1] = false;
+      node_data.required[0] = node_data.required[1] = std::numeric_limits<float>::max();
+      node_data.map_refs[0] = node_data.map_refs[1] = 0;
+      node_data.est_refs[0] = node_data.est_refs[1] = static_cast<float>( ntk.fanout_size( n ) );
+
+      if ( ntk.is_constant( n ) )
+      {
+        /* all terminals have flow 0 */
+        node_data.flows[0] = node_data.flows[1] = 0.0f;
+        node_data.arrival[0] = node_data.arrival[1] = 0.0f;
+        add_zero_cut( index );
+        match_constants( index );
+        continue;
+      }
+      else if ( ntk.is_pi( n ) )
+      {
+        /* all terminals have flow 0 */
+        node_data.flows[0] = 0.0f;
+        /* PIs have the negative phase implemented with an inverter */
+        node_data.flows[1] = lib_inv_area / node_data.est_refs[1];
+        add_unit_cut( index );
+        continue;
+      }
+
+      /* compute the node mapping */
+      add_node_cut<DO_AREA>( n );
+
+      /* match positive phase */
+      match_phase<DO_AREA>( n, 0u );
+
+      /* match negative phase */
+      match_phase<DO_AREA>( n, 1u );
+
+      /* try to drop one phase */
+      match_drop_phase<DO_AREA, false>( n );
+
+      /* select alternative matches to use */
+      select_alternatives<DO_AREA>( n );
+    }
+    double area_old = area;
+    bool success = set_mapping_refs_and_req<DO_AREA, false>();
+
+    /* round stats */
+    if ( ps.verbose )
+    {
+      std::stringstream stats{};
+      float area_gain = 0.0f;
+
+      if ( iteration != 1 )
+        area_gain = float( ( area_old - area ) / area_old * 100 );
+
+      if constexpr ( DO_AREA )
+      {
+        stats << fmt::format( "[i] AreaFlow : Delay = {:>12.2f}  Area = {:>12.2f}  Gain = {:>5.2f} %  Inverters = {:>5}  Time = {:>5.2f}\n", delay, area, area_gain, inv, to_seconds( clock::now() - time_begin ) );
+      }
+      else
+      {
+        stats << fmt::format( "[i] Delay    : Delay = {:>12.2f}  Area = {:>12.2f}  Gain = {:>5.2f} %  Inverters = {:>5}  Time = {:>5.2f}\n", delay, area, area_gain, inv, to_seconds( clock::now() - time_begin ) );
+      }
+      st.round_stats.push_back( stats.str() );
+    }
+
+    return success;
+  }
+
+  template<bool DO_AREA>
+  void add_node_cut( node<Ntk> const& n )
+  {
+    auto index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+    auto& rcuts = &cuts[index];
+
+    std::vector<uint32_t> fanin_indexes;
+    fanin_indexes.reserve( Ntk::max_fanin_size );
+
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      fanin_indexes.push_back( ntk.node_to_index( ntk.get_node( f ) ) );
+    } );
+
+    assert( fanin_indexes.size() <= CutSize );
+
+    cut_t new_cut = rcuts.add_cut( fanin_indexes.begin(), fanin_indexes.end() );
+    new_cut->function = kitty::extend_to<6>( ntk.node_function( n ) );
+
+    /* match cut and compute data */
+    compute_cut_data( new_cut, n );
+
+    ++cuts_total;
+  }
+
+  template<bool DO_AREA>
+  bool compute_mapping()
+  {
+    for ( auto const& n : topo_order )
+    {
+      uint32_t index = ntk.node_to_index( n );
+
+      /* reset mapping */
+      node_match[index].map_refs[0] = node_match[index].map_refs[1] = 0u;
+
+      if ( ntk.is_constant( n ) )
+        continue;
+      if ( ntk.is_pi( n ) )
+      {
+        node_match[index].flows[1] = lib_inv_area / node_match[index].est_refs[1];
+        node_match[index].best_alternative[1].flow = lib_inv_area / node_match[index].est_refs[1];
+        continue;
+      }
+
+      /* don't touch box */
+      if constexpr ( has_is_dont_touch_v<Ntk> )
+      {
+        if ( ntk.is_dont_touch( n ) )
+        {
+          if constexpr ( has_has_binding_v<Ntk> )
+          {
+            propagate_data_forward_white_box( n );
+          }
+          continue;
+        }
+      }
+
+      /* match positive phase */
+      match_phase<DO_AREA>( n, 0u );
+
+      /* match negative phase */
+      match_phase<DO_AREA>( n, 1u );
+
+      /* try to drop one phase */
+      match_drop_phase<DO_AREA, false>( n );
+
+      /* try a multi-output match */
+      if constexpr ( DO_AREA )
+      {
+        if ( ps.map_multioutput && node_tuple_match[index].highest_index )
+        {
+          bool multi_success = match_multioutput<DO_AREA>( n );
+          if ( multi_success )
+            multi_node_update<DO_AREA>( n );
+        }
+      }
+
+      assert( node_match[index].arrival[0] < node_match[index].required[0] + epsilon );
+      assert( node_match[index].arrival[1] < node_match[index].required[1] + epsilon );
+    }
+
+    double area_old = area;
+    bool success = set_mapping_refs_and_req<DO_AREA, false>();
+
+    /* round stats */
+    if ( ps.verbose )
+    {
+      std::stringstream stats{};
+      float area_gain = 0.0f;
+
+      if ( iteration != 1 )
+        area_gain = float( ( area_old - area ) / area_old * 100 );
+
+      if constexpr ( DO_AREA )
+      {
+        stats << fmt::format( "[i] AreaFlow : Delay = {:>12.2f}  Area = {:>12.2f}  Gain = {:>5.2f} %  Inverters = {:>5}  Time = {:>5.2f}\n", delay, area, area_gain, inv, to_seconds( clock::now() - time_begin ) );
+      }
+      else
+      {
+        stats << fmt::format( "[i] Delay    : Delay = {:>12.2f}  Area = {:>12.2f}  Gain = {:>5.2f} %  Inverters = {:>5}  Time = {:>5.2f}\n", delay, area, area_gain, inv, to_seconds( clock::now() - time_begin ) );
+      }
+      st.round_stats.push_back( stats.str() );
+    }
+
+    return success;
+  }
+
+  template<bool SwitchActivity>
+  bool compute_mapping_exact_reversed()
+  {
+    for ( auto it = topo_order.rbegin(); it != topo_order.rend(); ++it )
+    {
+      if ( ntk.is_constant( *it ) || ntk.is_pi( *it ) )
+        continue;
+
+      const auto index = ntk.node_to_index( *it );
+      auto& node_data = node_match[index];
+
+      /* skip not mapped nodes */
+      if ( !node_data.map_refs[0] && !node_data.map_refs[1] )
+        continue;
+
+      /* don't touch box */
+      if constexpr ( has_is_dont_touch_v<Ntk> )
+      {
+        node<Ntk> n = ntk.index_to_node( index );
+        if ( ntk.is_dont_touch( n ) )
+        {
+          if constexpr ( has_has_binding_v<Ntk> )
+          {
+            propagate_data_backward_white_box( n );
+          }
+          continue;
+        }
+      }
+
+      /* recursively deselect the best cut shared between
+       * the two phases if in use in the cover */
+      uint8_t use_phase = node_data.best_gate[0] != nullptr ? 0 : 1;
+      double old_required = -1;
+      if ( node_data.same_match )
+      {
+        auto const& best_cut = cuts[index][node_data.best_cut[use_phase]];
+        cut_deref<SwitchActivity>( best_cut, *it, use_phase );
+
+        /* propagate required time over the output inverter if present */
+        if ( node_data.map_refs[use_phase ^ 1] > 0 )
+        {
+          old_required = node_data.required[use_phase];
+          node_data.required[use_phase] = std::min( node_data.required[use_phase], node_data.required[use_phase ^ 1] - lib_inv_delay );
+        }
+      }
+      else if ( !node_data.map_refs[0] || !node_data.map_refs[1] )
+      {
+        use_phase = node_data.map_refs[0] ? 0 : 1;
+        auto const& best_cut = cuts[index][node_data.best_cut[use_phase]];
+        cut_deref<SwitchActivity>( best_cut, *it, use_phase );
+        node_data.same_match = true;
+      }
+
+      /* match positive phase */
+      match_phase_exact<SwitchActivity>( *it, 0u );
+
+      /* match negative phase */
+      match_phase_exact<SwitchActivity>( *it, 1u );
+
+      /* restore required time */
+      if ( old_required > 0 )
+      {
+        node_data.required[use_phase] = old_required;
+      }
+
+      /* try to drop one phase */
+      match_drop_phase<true, true, SwitchActivity>( *it );
+
+      /* try a multi-output match */ /* TODO: fix the required time*/
+      if ( ps.map_multioutput && node_tuple_match[index].lowest_index )
+      {
+        bool mapped = match_multioutput_exact<SwitchActivity>( *it, true );
+
+        /* propagate required time for the selected gates */
+        if ( mapped )
+        {
+          match_multioutput_propagate_required( *it );
+        }
+        else
+        {
+          match_propagate_required( index );
+        }
+      }
+      else
+      {
+        match_propagate_required( index );
+      }
+    }
+
+    double area_old = area;
+
+    propagate_arrival_times();
+
+    /* round stats */
+    if ( ps.verbose )
+    {
+      float area_gain = float( ( area_old - area ) / area_old * 100 );
+      std::stringstream stats{};
+      if constexpr ( SwitchActivity )
+        stats << fmt::format( "[i] Switching: Delay = {:>12.2f}  Area = {:>12.2f}  Gain = {:>5.2f} %  Inverters = {:>5}  Time = {:>5.2f}\n", delay, area, area_gain, inv, to_seconds( clock::now() - time_begin ) );
+      else
+        stats << fmt::format( "[i] Area Rev : Delay = {:>12.2f}  Area = {:>12.2f}  Gain = {:>5.2f} %  Inverters = {:>5}  Time = {:>5.2f}\n", delay, area, area_gain, inv, to_seconds( clock::now() - time_begin ) );
+      st.round_stats.push_back( stats.str() );
+    }
+
+    return true;
+  }
+
+  inline void match_propagate_required( uint32_t index )
+  {
+    /* don't touch box */
+    if constexpr ( has_is_dont_touch_v<Ntk> )
+    {
+      node<Ntk> n = ntk.index_to_node( index );
+      if ( ntk.is_dont_touch( n ) )
+      {
+        if constexpr ( has_has_binding_v<Ntk> )
+        {
+          propagate_data_backward_white_box( n );
+        }
+        return;
+      }
+    }
+
+    auto& node_data = node_match[index];
+
+    /* propagate required time through the leaves */
+    unsigned use_phase = node_data.best_gate[0] == nullptr ? 1u : 0u;
+    unsigned other_phase = use_phase ^ 1;
+
+    assert( node_data.best_gate[0] != nullptr || node_data.best_gate[1] != nullptr );
+    // assert( node_data.map_refs[0] || node_data.map_refs[1] );
+
+    /* propagate required time over the output inverter if present */
+    if ( node_data.same_match && node_data.map_refs[use_phase ^ 1] > 0 )
+    {
+      node_data.required[use_phase] = std::min( node_data.required[use_phase], node_data.required[other_phase] - lib_inv_delay );
+    }
+
+    if ( node_data.map_refs[0] )
+      assert( node_data.arrival[0] < node_data.required[0] + epsilon );
+    if ( node_data.map_refs[1] )
+      assert( node_data.arrival[1] < node_data.required[1] + epsilon );
+
+    if ( node_data.same_match || node_data.map_refs[use_phase] > 0 )
+    {
+      auto ctr = 0u;
+      auto const& best_cut = cuts[index][node_data.best_cut[use_phase]];
+      auto const& supergate = node_data.best_gate[use_phase];
+      for ( auto leaf : best_cut )
+      {
+        auto phase = ( node_data.phase[use_phase] >> ctr ) & 1;
+        node_match[leaf].required[phase] = std::min( node_match[leaf].required[phase], node_data.required[use_phase] - supergate->tdelay[ctr] );
+        ++ctr;
+      }
+    }
+
+    if ( !node_data.same_match && node_data.map_refs[other_phase] > 0 )
+    {
+      auto ctr = 0u;
+      auto const& best_cut = cuts[index][node_data.best_cut[other_phase]];
+      auto const& supergate = node_data.best_gate[other_phase];
+      for ( auto leaf : best_cut )
+      {
+        auto phase = ( node_data.phase[other_phase] >> ctr ) & 1;
+        node_match[leaf].required[phase] = std::min( node_match[leaf].required[phase], node_data.required[other_phase] - supergate->tdelay[ctr] );
+        ++ctr;
+      }
+    }
+  }
+
+  template<bool ELA>
+  bool set_mapping_refs()
+  {
+    /* compute the current worst delay and update the mapping refs */
+    delay = 0.0f;
+    ntk.foreach_po( [this]( auto s ) {
+      const auto index = ntk.node_to_index( ntk.get_node( s ) );
+
+      if ( ntk.is_complemented( s ) )
+        delay = std::max( delay, node_match[index].arrival[1] );
+      else
+        delay = std::max( delay, node_match[index].arrival[0] );
+
+      if constexpr ( !ELA )
+      {
+        if ( ntk.is_complemented( s ) )
+          node_match[index].map_refs[1]++;
+        else
+          node_match[index].map_refs[0]++;
+      }
+    } );
+
+    /* compute current area and update mapping refs in top-down order */
+    area = 0.0f;
+    inv = 0;
+    for ( auto it = topo_order.rbegin(); it != topo_order.rend(); ++it )
+    {
+      const auto index = ntk.node_to_index( *it );
+      auto& node_data = node_match[index];
+
+      /* skip constants and PIs */
+      if ( ntk.is_constant( *it ) )
+      {
+        if ( node_data.map_refs[0] || node_data.map_refs[1] )
+        {
+          /* if used and not available in the library launch a mapping error */
+          if ( node_data.best_gate[0] == nullptr && node_data.best_gate[1] == nullptr )
+          {
+            std::cerr << "[e] MAP ERROR: technology library does not contain constant gates, impossible to perform mapping" << std::endl;
+            st.mapping_error = true;
+            return false;
+          }
+        }
+        continue;
+      }
+      else if ( ntk.is_pi( *it ) )
+      {
+        if ( node_match[index].map_refs[1] > 0u )
+        {
+          /* Add inverter area over the negated fanins */
+          area += lib_inv_area;
+          ++inv;
+        }
+        continue;
+      }
+
+      /* continue if not referenced in the cover */
+      if ( !node_match[index].map_refs[0] && !node_match[index].map_refs[1] )
+        continue;
+
+      /* don't touch box */
+      if constexpr ( has_is_dont_touch_v<Ntk> )
+      {
+        if ( ntk.is_dont_touch( *it ) )
+        {
+          set_mapping_refs_dont_touch<ELA>( *it );
+          continue;
+        }
+      }
+
+      unsigned use_phase = node_data.best_gate[0] == nullptr ? 1u : 0u;
+
+      if ( node_data.best_gate[use_phase] == nullptr )
+      {
+        /* Library is not complete, mapping is not possible */
+        std::cerr << "[e] MAP ERROR: technology library is not complete, impossible to perform mapping" << std::endl;
+        st.mapping_error = true;
+        return false;
+      }
+
+      if ( node_data.same_match || node_data.map_refs[use_phase] > 0 )
+      {
+        if constexpr ( !ELA )
+        {
+          auto const& best_cut = cuts[index][node_data.best_cut[use_phase]];
+          auto ctr = 0u;
+
+          for ( auto const leaf : best_cut )
+          {
+            if ( ( node_data.phase[use_phase] >> ctr++ ) & 1 )
+              node_match[leaf].map_refs[1]++;
+            else
+              node_match[leaf].map_refs[0]++;
+          }
+        }
+        area += node_data.area[use_phase];
+        if ( node_data.same_match && node_data.map_refs[use_phase ^ 1] > 0 )
+        {
+          if ( iteration < ps.area_flow_rounds )
+          {
+            ++node_data.map_refs[use_phase];
+          }
+          area += lib_inv_area;
+          ++inv;
+        }
+      }
+
+      /* invert the phase */
+      use_phase = use_phase ^ 1;
+
+      /* if both phases are implemented and used */
+      if ( !node_data.same_match && node_data.map_refs[use_phase] > 0 )
+      {
+        if constexpr ( !ELA )
+        {
+          auto const& best_cut = cuts[index][node_data.best_cut[use_phase]];
+
+          auto ctr = 0u;
+          for ( auto const leaf : best_cut )
+          {
+            if ( ( node_data.phase[use_phase] >> ctr++ ) & 1 )
+              node_match[leaf].map_refs[1]++;
+            else
+              node_match[leaf].map_refs[0]++;
+          }
+        }
+        area += node_data.area[use_phase];
+      }
+    }
+
+    ++iteration;
+
+    if constexpr ( ELA )
+    {
+      return true;
+    }
+
+    /* blend estimated references */
+    float const coef = 1.0f / ( ( iteration + 1.0f ) * ( iteration + 1.0f ) );
+    for ( auto i = 0u; i < ntk.size(); ++i )
+    {
+      node_match[i].est_refs[0] = std::max( 1.0f, coef * node_match[i].est_refs[0] + ( 1 - coef ) * node_match[i].map_refs[0] );
+      node_match[i].est_refs[1] = std::max( 1.0f, coef * node_match[i].est_refs[1] + ( 1 - coef ) * node_match[i].map_refs[1] );
+    }
+
+    return true;
+  }
+
+  template<bool DO_AREA, bool ELA>
+  bool set_mapping_refs_and_req()
+  {
+    for ( auto i = 0u; i < node_match.size(); ++i )
+    {
+      node_match[i].required[0] = node_match[i].required[1] = std::numeric_limits<float>::max();
+    }
+
+    /* compute the current worst delay and update the mapping refs */
+    delay = 0.0f;
+    ntk.foreach_po( [this]( auto s ) {
+      const auto index = ntk.node_to_index( ntk.get_node( s ) );
+
+      if ( ntk.is_complemented( s ) )
+        delay = std::max( delay, node_match[index].arrival[1] );
+      else
+        delay = std::max( delay, node_match[index].arrival[0] );
+
+      if constexpr ( !ELA )
+      {
+        if ( ntk.is_complemented( s ) )
+          node_match[index].map_refs[1]++;
+        else
+          node_match[index].map_refs[0]++;
+      }
+    } );
+
+    set_output_required_time( iteration == 0 );
+
+    /* compute current area and update mapping refs in top-down order */
+    area = 0.0f;
+    inv = 0;
+    for ( auto it = topo_order.rbegin(); it != topo_order.rend(); ++it )
+    {
+      const auto index = ntk.node_to_index( *it );
+      auto& node_data = node_match[index];
+
+      /* skip constants and PIs */
+      if ( ntk.is_constant( *it ) )
+      {
+        if ( node_match[index].map_refs[0] || node_match[index].map_refs[1] )
+        {
+          /* if used and not available in the library launch a mapping error */
+          if ( node_data.best_gate[0] == nullptr && node_data.best_gate[1] == nullptr )
+          {
+            std::cerr << "[e] MAP ERROR: technology library does not contain constant gates, impossible to perform mapping" << std::endl;
+            st.mapping_error = true;
+            return false;
+          }
+        }
+        continue;
+      }
+      else if ( ntk.is_pi( *it ) )
+      {
+        if ( node_match[index].map_refs[1] > 0u )
+        {
+          /* Add inverter area over the negated fanins */
+          area += lib_inv_area;
+          ++inv;
+        }
+        continue;
+      }
+
+      /* continue if not referenced in the cover */
+      if ( !node_match[index].map_refs[0] && !node_match[index].map_refs[1] )
+        continue;
+
+      /* don't touch box */
+      if constexpr ( has_is_dont_touch_v<Ntk> )
+      {
+        if ( ntk.is_dont_touch( *it ) )
+        {
+          set_mapping_refs_dont_touch<ELA>( *it );
+          continue;
+        }
+      }
+
+      /* refine best matches with alternatives */
+      if constexpr ( !DO_AREA )
+      {
+        if ( ps.use_match_alternatives )
+          refine_best_matches( *it );
+      }
+
+      unsigned use_phase = node_data.best_gate[0] == nullptr ? 1u : 0u;
+      if ( node_data.best_gate[use_phase] == nullptr )
+      {
+        /* Library is not complete, mapping is not possible */
+        std::cerr << "[e] MAP ERROR: technology library is not complete, impossible to perform mapping" << std::endl;
+        st.mapping_error = true;
+        return false;
+      }
+
+      if ( node_data.same_match || node_data.map_refs[use_phase] > 0 )
+      {
+        if constexpr ( !ELA )
+        {
+          auto const& best_cut = cuts[index][node_data.best_cut[use_phase]];
+          auto ctr = 0u;
+
+          for ( auto const leaf : best_cut )
+          {
+            if ( ( node_data.phase[use_phase] >> ctr++ ) & 1 )
+              node_match[leaf].map_refs[1]++;
+            else
+              node_match[leaf].map_refs[0]++;
+          }
+        }
+        area += node_data.area[use_phase];
+        if ( node_data.same_match && node_data.map_refs[use_phase ^ 1] > 0 )
+        {
+          if ( iteration < ps.area_flow_rounds )
+          {
+            ++node_data.map_refs[use_phase];
+          }
+          area += lib_inv_area;
+          ++inv;
+        }
+      }
+
+      /* invert the phase */
+      use_phase = use_phase ^ 1;
+
+      /* if both phases are implemented and used */
+      if ( !node_data.same_match && node_data.map_refs[use_phase] > 0 )
+      {
+        if constexpr ( !ELA )
+        {
+          auto const& best_cut = cuts[index][node_data.best_cut[use_phase]];
+
+          auto ctr = 0u;
+          for ( auto const leaf : best_cut )
+          {
+            if ( ( node_data.phase[use_phase] >> ctr++ ) & 1 )
+              node_match[leaf].map_refs[1]++;
+            else
+              node_match[leaf].map_refs[0]++;
+          }
+        }
+        area += node_data.area[use_phase];
+      }
+
+      if ( !ps.area_oriented_mapping )
+      {
+        match_propagate_required( index );
+      }
+    }
+
+    ++iteration;
+
+    if constexpr ( ELA )
+    {
+      return true;
+    }
+
+    /* blend estimated references */
+    float const coef = 1.0f / ( ( iteration + 1.0f ) * ( iteration + 1.0f ) );
+    for ( auto i = 0u; i < ntk.size(); ++i )
+    {
+      node_match[i].est_refs[0] = std::max( 1.0f, coef * node_match[i].est_refs[0] + ( 1 - coef ) * node_match[i].map_refs[0] );
+      node_match[i].est_refs[1] = std::max( 1.0f, coef * node_match[i].est_refs[1] + ( 1 - coef ) * node_match[i].map_refs[1] );
+    }
+
+    return true;
+  }
+
+  template<bool ELA>
+  inline void set_mapping_refs_dont_touch( node<Ntk> const& n )
+  {
+    if constexpr ( !ELA )
+    {
+      /* reference node */
+      ntk.foreach_fanin( n, [&]( auto const& f ) {
+        uint32_t leaf = ntk.node_to_index( ntk.get_node( f ) );
+        uint8_t phase = ntk.is_complemented( f ) ? 1 : 0;
+        node_match[leaf].map_refs[phase]++;
+      } );
+    }
+
+    const auto index = ntk.node_to_index( n );
+
+    if constexpr ( has_has_binding_v<Ntk> )
+    {
+      /* increase area */
+      area += node_match[index].area[0];
+      if ( node_match[index].map_refs[1] )
+      {
+        if ( iteration < ps.area_flow_rounds )
+        {
+          ++node_match[index].map_refs[0];
+        }
+        area += lib_inv_area;
+        ++inv;
+      }
+    }
+  }
+
+  void set_output_required_time( bool warning )
+  {
+    double required = delay;
+    /* relax delay constraints */
+    if ( iteration == 0 && ps.required_time == 0.0f && ps.required_times.empty() && ps.relax_required > 0.0f )
+    {
+      required *= ( 100.0 + ps.relax_required ) / 100.0;
+    }
+
+    /* Global target time constraint */
+    if ( ps.required_times.empty() )
+    {
+      if ( ps.required_time != 0.0f )
+      {
+        if ( ps.required_time < delay - epsilon )
+        {
+          if ( warning )
+            std::cerr << fmt::format( "[i] MAP WARNING: cannot meet the target required time of {:.2f}", ps.required_time ) << std::endl;
+        }
+        else
+        {
+          required = ps.required_time;
+        }
+      }
+
+      /* set the required time at POs */
+      ntk.foreach_po( [&]( auto const& s ) {
+        const auto index = ntk.node_to_index( ntk.get_node( s ) );
+        if ( ntk.is_complemented( s ) )
+          node_match[index].required[1] = required;
+        else
+          node_match[index].required[0] = required;
+      } );
+
+      return;
+    }
+
+    /* Output-specific target time constraint */
+    ntk.foreach_po( [&]( auto const& s, uint32_t i ) {
+      const auto index = ntk.node_to_index( ntk.get_node( s ) );
+      uint8_t phase = ntk.is_complemented( s ) ? 1 : 0;
+      if ( node_match[index].arrival[phase] > ps.required_times[i] + epsilon )
+      {
+        /* maintain the same delay */
+        node_match[index].required[phase] = node_match[index].arrival[phase];
+        if ( warning )
+          std::cerr << fmt::format( "[i] MAP WARNING: cannot meet the target required time of {:.2f} at output {}", ps.required_times[i], i ) << std::endl;
+      }
+      else
+      {
+        node_match[index].required[phase] = ps.required_times[i];
+      }
+    } );
+  }
+
+  void compute_required_time( bool exit_early = false )
+  {
+    for ( auto i = 0u; i < node_match.size(); ++i )
+    {
+      node_match[i].required[0] = node_match[i].required[1] = std::numeric_limits<float>::max();
+    }
+
+    /* return if mapping is area oriented */
+    if ( ps.area_oriented_mapping )
+      return;
+
+    set_output_required_time( iteration == 1 );
+
+    if ( exit_early )
+      return;
+
+    /* propagate required time to the PIs */
+    for ( auto it = topo_order.rbegin(); it != topo_order.rend(); ++it )
+    {
+      if ( ntk.is_pi( *it ) || ntk.is_constant( *it ) )
+        break;
+
+      const auto index = ntk.node_to_index( *it );
+
+      if ( !node_match[index].map_refs[0] && !node_match[index].map_refs[1] )
+        continue;
+
+      match_propagate_required( index );
+    }
+  }
+
+  void propagate_arrival_times()
+  {
+    area = 0.0f;
+    inv = 0;
+    for ( auto const& n : topo_order )
+    {
+      auto index = ntk.node_to_index( n );
+      auto& node_data = node_match[index];
+
+      /* measure area */
+      if ( ntk.is_constant( n ) )
+      {
+        continue;
+      }
+      else if ( ntk.is_pi( n ) )
+      {
+        if ( node_data.map_refs[1] > 0u )
+        {
+          /* Add inverter area over the negated fanins */
+          area += lib_inv_area;
+          ++inv;
+        }
+        continue;
+      }
+
+      /* reset required time */
+      node_data.required[0] = std::numeric_limits<float>::max();
+      node_data.required[1] = std::numeric_limits<float>::max();
+
+      /* don't touch box */
+      if constexpr ( has_is_dont_touch_v<Ntk> )
+      {
+        node<Ntk> n = ntk.index_to_node( index );
+        if ( ntk.is_dont_touch( n ) )
+        {
+          if constexpr ( has_has_binding_v<Ntk> )
+          {
+            propagate_data_forward_white_box( n );
+            if ( node_match[index].map_refs[0] || node_match[index].map_refs[1] )
+              area += node_data.area[0];
+            if ( node_data.map_refs[1] )
+            {
+              area += lib_inv_area;
+              ++inv;
+            }
+          }
+          continue;
+        }
+      }
+
+      uint8_t use_phase = node_data.best_gate[0] != nullptr ? 0 : 1;
+
+      /* compute arrival of use_phase */
+      supergate<NInputs> const* best_gate = node_data.best_gate[use_phase];
+      double worst_arrival = 0;
+      uint16_t best_phase = node_data.phase[use_phase];
+      auto ctr = 0u;
+      for ( auto l : cuts[index][node_data.best_cut[use_phase]] )
+      {
+        double arrival_pin = node_match[l].arrival[( best_phase >> ctr ) & 1] + best_gate->tdelay[ctr];
+        worst_arrival = std::max( worst_arrival, arrival_pin );
+        ++ctr;
+      }
+
+      node_data.arrival[use_phase] = worst_arrival;
+
+      /* compute area */
+      if ( node_data.map_refs[use_phase] > 0 || ( node_data.same_match && ( node_match[index].map_refs[0] || node_match[index].map_refs[1] ) ) )
+      {
+        area += node_data.area[use_phase];
+        if ( node_data.same_match && node_data.map_refs[use_phase ^ 1] > 0 )
+        {
+          area += lib_inv_area;
+          ++inv;
+        }
+      }
+
+      /* compute arrival of the other phase */
+      use_phase ^= 1;
+      if ( node_data.same_match )
+      {
+        node_data.arrival[use_phase] = worst_arrival + lib_inv_delay;
+        continue;
+      }
+
+      assert( node_data.best_gate[use_phase] != nullptr );
+
+      best_gate = node_data.best_gate[use_phase];
+      worst_arrival = 0;
+      best_phase = node_data.phase[use_phase];
+      ctr = 0u;
+      for ( auto l : cuts[index][node_data.best_cut[use_phase]] )
+      {
+        double arrival_pin = node_match[l].arrival[( best_phase >> ctr ) & 1] + best_gate->tdelay[ctr];
+        worst_arrival = std::max( worst_arrival, arrival_pin );
+        ++ctr;
+      }
+
+      node_data.arrival[use_phase] = worst_arrival;
+
+      if ( node_data.map_refs[use_phase] > 0 )
+      {
+        area += node_data.area[use_phase];
+      }
+    }
+
+    /* compute the current worst delay */
+    delay = 0.0f;
+    ntk.foreach_po( [this]( auto s ) {
+      const auto index = ntk.node_to_index( ntk.get_node( s ) );
+
+      if ( ntk.is_complemented( s ) )
+        delay = std::max( delay, node_match[index].arrival[1] );
+      else
+        delay = std::max( delay, node_match[index].arrival[0] );
+    } );
+
+    /* return if mapping is area oriented */
+    ++iteration;
+    if ( ps.area_oriented_mapping )
+      return;
+
+    /* set the required time at POs */
+    ntk.foreach_po( [&]( auto const& s ) {
+      const auto index = ntk.node_to_index( ntk.get_node( s ) );
+      if ( ntk.is_complemented( s ) )
+        node_match[index].required[1] = delay;
+      else
+        node_match[index].required[0] = delay;
+    } );
+  }
+
+  void propagate_arrival_node( node<Ntk> const& n )
+  {
+    uint32_t index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+    uint8_t use_phase = node_data.best_gate[0] != nullptr ? 0 : 1;
+
+    /* compute arrival of use_phase */
+    supergate<NInputs> const* best_gate = node_data.best_gate[use_phase];
+    double worst_arrival = 0;
+    uint16_t best_phase = node_data.phase[use_phase];
+    auto ctr = 0u;
+    for ( auto l : cuts[index][node_data.best_cut[use_phase]] )
+    {
+      double arrival_pin = node_match[l].arrival[( best_phase >> ctr ) & 1] + best_gate->tdelay[ctr];
+      worst_arrival = std::max( worst_arrival, arrival_pin );
+      ++ctr;
+    }
+    node_data.arrival[use_phase] = worst_arrival;
+
+    /* compute arrival of the other phase */
+    use_phase ^= 1;
+    if ( node_data.same_match )
+    {
+      node_data.arrival[use_phase] = worst_arrival + lib_inv_delay;
+      return;
+    }
+
+    assert( node_data.best_gate[0] != nullptr );
+
+    best_gate = node_data.best_gate[use_phase];
+    worst_arrival = 0;
+    best_phase = node_data.phase[use_phase];
+    ctr = 0u;
+    for ( auto l : cuts[index][node_data.best_cut[use_phase]] )
+    {
+      double arrival_pin = node_match[l].arrival[( best_phase >> ctr ) & 1] + best_gate->tdelay[ctr];
+      worst_arrival = std::max( worst_arrival, arrival_pin );
+      ++ctr;
+    }
+
+    node_data.arrival[use_phase] = worst_arrival;
+  }
+
+  template<bool DO_AREA>
+  void match_phase( node<Ntk> const& n, uint8_t phase )
+  {
+    auto index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+    uint32_t cut_index = 0u;
+
+    node_data.best_gate[phase] = nullptr;
+    node_data.arrival[phase] = std::numeric_limits<float>::max();
+    node_data.flows[phase] = std::numeric_limits<float>::max();
+    node_data.area[phase] = std::numeric_limits<float>::max();
+    uint32_t best_size = UINT32_MAX;
+
+    best_gate_emap<NInputs>& gA = node_data.best_alternative[phase];
+    gA.gate = nullptr;
+    gA.arrival = std::numeric_limits<float>::max();
+    gA.flow = std::numeric_limits<float>::max();
+    uint32_t best_sizeA = UINT32_MAX;
+
+    /* unmap multioutput */
+    node_data.multioutput_match[phase] = false;
+
+    /* foreach cut */
+    for ( auto& cut : cuts[index] )
+    {
+      /* trivial cuts or not matched cuts */
+      if ( ( *cut )->ignore )
+      {
+        ++cut_index;
+        continue;
+      }
+
+      auto const& supergates = ( *cut )->supergates;
+      auto const negation = ( *cut )->negations[phase];
+
+      if ( supergates[phase] == nullptr )
+      {
+        ++cut_index;
+        continue;
+      }
+
+      /* match each gate and take the best one */
+      for ( auto const& gate : *supergates[phase] )
+      {
+        uint16_t gate_polarity = gate.polarity ^ negation;
+        double worst_arrival = 0.0f;
+        double worst_arrivalA = 0.0f;
+        float area_local = gate.area;
+        float area_localA = gate.area;
+
+        auto ctr = 0u;
+        for ( auto l : *cut )
+        {
+          uint8_t leaf_phase = ( gate_polarity >> ctr ) & 1;
+
+          double arrival_pinA = node_match[l].best_alternative[leaf_phase].arrival + gate.tdelay[ctr];
+          worst_arrivalA = std::max( worst_arrivalA, arrival_pinA );
+
+          // if constexpr ( DO_AREA )
+          // {
+          //   if ( worst_arrivalA > node_data.required[phase] + epsilon || worst_arrivalA >= std::numeric_limits<float>::max() )
+          //     break;
+          // }
+
+          double arrival_pin = node_match[l].arrival[leaf_phase] + gate.tdelay[ctr];
+          worst_arrival = std::max( worst_arrival, arrival_pin );
+
+          area_local += node_match[l].flows[leaf_phase];
+          area_localA += node_match[l].best_alternative[leaf_phase].flow;
+          ++ctr;
+        }
+
+        bool skip = false;
+        if constexpr ( DO_AREA )
+        {
+          if ( ctr < cut->size() )
+            continue;
+          if ( worst_arrival > node_data.required[phase] + epsilon || worst_arrival >= std::numeric_limits<float>::max() )
+            skip = true;
+        }
+
+        if ( !skip && compare_map<DO_AREA>( worst_arrival, node_data.arrival[phase], area_local, node_data.flows[phase], cut->size(), best_size ) )
+        {
+          node_data.best_gate[phase] = &gate;
+          node_data.arrival[phase] = worst_arrival;
+          node_data.flows[phase] = area_local;
+          node_data.best_cut[phase] = cut_index;
+          node_data.area[phase] = gate.area;
+          node_data.phase[phase] = gate_polarity;
+          best_size = cut->size();
+        }
+
+        /* compute the alternative */
+        if ( compare_map<!DO_AREA>( worst_arrivalA, gA.arrival, area_localA, gA.flow, cut->size(), best_sizeA ) )
+        {
+          gA.gate = &gate;
+          gA.arrival = worst_arrivalA;
+          gA.area = gate.area;
+          gA.flow = area_localA;
+          gA.phase = gate_polarity;
+          gA.cut = cut_index;
+          best_sizeA = cut->size();
+          gA.size = cut->size();
+        }
+      }
+
+      ++cut_index;
+    }
+  }
+
+  template<bool SwitchActivity>
+  void match_phase_exact( node<Ntk> const& n, uint8_t phase )
+  {
+    double best_arrival = std::numeric_limits<float>::max();
+    float best_exact_area = std::numeric_limits<float>::max();
+    float best_area = std::numeric_limits<float>::max();
+    uint32_t best_size = UINT32_MAX;
+    uint8_t best_cut = 0u;
+    uint16_t best_phase = 0u;
+    uint8_t cut_index = 0u;
+    auto index = ntk.node_to_index( n );
+
+    auto& node_data = node_match[index];
+    supergate<NInputs> const* best_gate = node_data.best_gate[phase];
+
+    /* unmap multioutput */
+    if ( node_data.multioutput_match[phase] )
+    {
+      /* dereference multi-output */
+      if ( !node_data.same_match && best_gate != nullptr && node_data.map_refs[phase] )
+      {
+        auto const& cut = multi_cut_set[node_data.best_cut[phase]][0];
+        cut_deref<SwitchActivity>( cut, n, phase );
+      }
+      best_gate = nullptr;
+      node_data.multioutput_match[phase] = false;
+    }
+
+    /* recompute best match info */
+    if ( best_gate != nullptr )
+    {
+      /* if cut is implemented, remove it from the cover */
+      if ( !node_data.same_match && node_data.map_refs[phase] )
+      {
+        auto const& cut = cuts[index][node_data.best_cut[phase]];
+        cut_deref<SwitchActivity>( cut, n, phase );
+      }
+    }
+
+    /* foreach cut */
+    for ( auto& cut : cuts[index] )
+    {
+      /* trivial cuts or not matched cuts */
+      if ( ( *cut )->ignore )
+      {
+        ++cut_index;
+        continue;
+      }
+
+      auto const& supergates = ( *cut )->supergates;
+      auto const negation = ( *cut )->negations[phase];
+
+      if ( supergates[phase] == nullptr )
+      {
+        ++cut_index;
+        continue;
+      }
+
+      /* match each gate and take the best one */
+      for ( auto const& gate : *supergates[phase] )
+      {
+        uint16_t gate_polarity = gate.polarity ^ negation;
+        double worst_arrival = 0.0f;
+
+        auto ctr = 0u;
+        for ( auto l : *cut )
+        {
+          double arrival_pin = node_match[l].arrival[( gate_polarity >> ctr ) & 1] + gate.tdelay[ctr];
+          worst_arrival = std::max( worst_arrival, arrival_pin );
+          ++ctr;
+        }
+
+        if ( worst_arrival > node_data.required[phase] + epsilon || worst_arrival >= std::numeric_limits<float>::max() )
+          continue;
+
+        node_data.phase[phase] = gate_polarity;
+        node_data.area[phase] = gate.area;
+        float area_exact = cut_measure_mffc<SwitchActivity>( *cut, n, phase );
+
+        if ( compare_map<true>( worst_arrival, best_arrival, area_exact, best_exact_area, cut->size(), best_size ) )
+        {
+          best_arrival = worst_arrival;
+          best_exact_area = area_exact;
+          best_area = gate.area;
+          best_size = cut->size();
+          best_cut = cut_index;
+          best_phase = gate_polarity;
+          best_gate = &gate;
+        }
+      }
+
+      ++cut_index;
+    }
+
+    node_data.flows[phase] = best_exact_area;
+    node_data.arrival[phase] = best_arrival;
+    node_data.area[phase] = best_area;
+    node_data.best_cut[phase] = best_cut;
+    node_data.phase[phase] = best_phase;
+    node_data.best_gate[phase] = best_gate;
+
+    if ( !node_data.same_match && node_data.map_refs[phase] )
+    {
+      best_exact_area = cut_ref<SwitchActivity>( cuts[index][best_cut], n, phase );
+    }
+  }
+
+  template<bool DO_AREA, bool ELA, bool SwitchActivity = false>
+  void match_drop_phase( node<Ntk> const& n )
+  {
+    auto index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+
+    /* compute arrival adding an inverter to the other match phase */
+    double worst_arrival_npos = node_data.arrival[1] + lib_inv_delay;
+    double worst_arrival_nneg = node_data.arrival[0] + lib_inv_delay;
+    bool use_zero = false;
+    bool use_one = false;
+
+    /* only one phase is matched */
+    if ( node_data.best_gate[0] == nullptr )
+    {
+      set_match_complemented_phase( index, 1, worst_arrival_npos );
+      if constexpr ( ELA )
+      {
+        if ( node_data.map_refs[0] || node_data.map_refs[1] )
+          cut_ref<false>( cuts[index][node_data.best_cut[1]], n, 1 );
+      }
+      return;
+    }
+    else if ( node_data.best_gate[1] == nullptr )
+    {
+      set_match_complemented_phase( index, 0, worst_arrival_nneg );
+      if constexpr ( ELA )
+      {
+        if ( node_data.map_refs[0] || node_data.map_refs[1] )
+          cut_ref<false>( cuts[index][node_data.best_cut[0]], n, 0 );
+      }
+      return;
+    }
+
+    /* try to use only one match to cover both phases */
+    if constexpr ( !DO_AREA )
+    {
+      /* if arrival improves matching the other phase and inserting an inverter */
+      if ( worst_arrival_npos < node_data.arrival[0] + epsilon )
+      {
+        use_one = true;
+      }
+      if ( worst_arrival_nneg < node_data.arrival[1] + epsilon )
+      {
+        use_zero = true;
+      }
+    }
+    else
+    {
+      /* check if both phases + inverter meet the required time */
+      use_zero = worst_arrival_nneg < ( node_data.required[1] + epsilon );
+      use_one = worst_arrival_npos < ( node_data.required[0] + epsilon );
+    }
+
+    /* condition on not used phases, evaluate a substitution during exact area recovery */
+    if constexpr ( ELA )
+    {
+      if ( node_data.map_refs[0] == 0 || node_data.map_refs[1] == 0 )
+      {
+        /* select the used match */
+        auto phase = 0;
+        auto nphase = 0;
+        if ( node_data.map_refs[0] == 0 )
+        {
+          phase = 1;
+          use_one = true;
+          use_zero = false;
+        }
+        else
+        {
+          nphase = 1;
+          use_one = false;
+          use_zero = true;
+        }
+        /* select the not used match instead if it leads to area improvement and doesn't violate the required time */
+        if ( node_data.arrival[nphase] + lib_inv_delay < node_data.required[phase] + epsilon )
+        {
+          auto size_phase = cuts[index][node_data.best_cut[phase]].size();
+          auto size_nphase = cuts[index][node_data.best_cut[nphase]].size();
+
+          if ( compare_map<DO_AREA>( node_data.arrival[nphase] + lib_inv_delay, node_data.arrival[phase], node_data.flows[nphase] + lib_inv_area, node_data.flows[phase], size_nphase, size_phase ) )
+          {
+            /* invert the choice */
+            use_zero = !use_zero;
+            use_one = !use_one;
+          }
+        }
+      }
+    }
+
+    if ( ( !use_zero && !use_one ) )
+    {
+      /* use both phases */
+      node_data.flows[0] = node_data.flows[0] / node_data.est_refs[0];
+      node_data.flows[1] = node_data.flows[1] / node_data.est_refs[1];
+      node_data.same_match = false;
+      return;
+    }
+
+    /* use area flow as a tiebreaker */
+    if ( use_zero && use_one )
+    {
+      auto size_zero = cuts[index][node_data.best_cut[0]].size();
+      auto size_one = cuts[index][node_data.best_cut[1]].size();
+
+      if constexpr ( ELA )
+      {
+        if ( !node_data.same_match )
+        {
+          /* both phases were implemented --> evaluate substitution */
+          cut_deref<false>( cuts[index][node_data.best_cut[0]], n, 0 );
+          node_data.flows[1] = cut_deref<false>( cuts[index][node_data.best_cut[1]], n, 1 );
+          node_data.flows[0] = cut_ref<false>( cuts[index][node_data.best_cut[0]], n, 0 );
+          cut_ref<false>( cuts[index][node_data.best_cut[1]], n, 1 );
+        }
+        /* evaluate based on inverter cost */
+        if constexpr ( !SwitchActivity )
+        {
+          use_zero = lib_inv_area < node_data.flows[1] + epsilon;
+          use_one = lib_inv_area < node_data.flows[0] + epsilon;
+        }
+
+        if ( use_one && use_zero )
+        {
+          if ( compare_map<DO_AREA>( worst_arrival_nneg, worst_arrival_npos, node_data.flows[0], node_data.flows[1], size_zero, size_one ) )
+            use_one = false;
+          else
+            use_zero = false;
+        }
+        else if ( !use_one && !use_zero && node_data.same_match )
+        {
+          node_data.same_match = false;
+          cut_ref<false>( cuts[index][node_data.best_cut[0]], n, 0 );
+          cut_ref<false>( cuts[index][node_data.best_cut[1]], n, 1 );
+          return;
+        }
+      }
+      else
+      {
+        /* compare flows by looking at the most convinient and referenced */
+        if ( node_data.flows[0] / node_data.est_refs[0] + lib_inv_area < node_data.flows[1] / node_data.est_refs[1] + epsilon )
+        {
+          use_one = false;
+        }
+        else if ( node_data.flows[1] / node_data.est_refs[1] + lib_inv_area < node_data.flows[0] / node_data.est_refs[0] + epsilon )
+        {
+          use_zero = false;
+        }
+        else
+        {
+          /* delay the decision on what to keep --> wait for better estimations */
+          node_data.flows[0] = node_data.flows[0] / node_data.est_refs[0];
+          node_data.flows[1] = node_data.flows[1] / node_data.est_refs[1];
+          node_data.same_match = false;
+          return;
+        }
+      }
+    }
+
+    if ( use_zero )
+    {
+      if constexpr ( ELA )
+      {
+        /* set cut references */
+        if ( !node_data.same_match )
+        {
+          /* dereference the negative phase cut if in use */
+          if ( node_data.map_refs[1] > 0 )
+            cut_deref<false>( cuts[index][node_data.best_cut[1]], n, 1 );
+          /* reference the positive cut if not in use before */
+          if ( node_data.map_refs[0] == 0 && node_data.map_refs[1] > 0 )
+            cut_ref<false>( cuts[index][node_data.best_cut[0]], n, 0 );
+        }
+        else if ( node_data.map_refs[0] || node_data.map_refs[1] )
+          cut_ref<false>( cuts[index][node_data.best_cut[0]], n, 0 );
+      }
+      set_match_complemented_phase( index, 0, worst_arrival_nneg );
+    }
+    else
+    {
+      if constexpr ( ELA )
+      {
+        /* set cut references */
+        if ( !node_data.same_match )
+        {
+          /* dereference the positive phase cut if in use */
+          if ( node_data.map_refs[0] > 0 )
+            cut_deref<false>( cuts[index][node_data.best_cut[0]], n, 0 );
+          /* reference the negative cut if not in use before */
+          if ( node_data.map_refs[1] == 0 && node_data.map_refs[0] > 0 )
+            cut_ref<false>( cuts[index][node_data.best_cut[1]], n, 1 );
+        }
+        else if ( node_data.map_refs[0] || node_data.map_refs[1] )
+          cut_ref<false>( cuts[index][node_data.best_cut[1]], n, 1 );
+      }
+      set_match_complemented_phase( index, 1, worst_arrival_npos );
+    }
+  }
+
+  inline void set_match_complemented_phase( uint32_t index, uint8_t phase, double worst_arrival_n )
+  {
+    auto& node_data = node_match[index];
+    auto phase_n = phase ^ 1;
+    node_data.same_match = true;
+    node_data.best_gate[phase_n] = nullptr;
+    node_data.best_cut[phase_n] = node_data.best_cut[phase];
+    node_data.phase[phase_n] = node_data.phase[phase];
+    node_data.arrival[phase_n] = worst_arrival_n;
+    node_data.area[phase_n] = node_data.area[phase];
+    node_data.flows[phase_n] = ( node_data.flows[phase] + lib_inv_area ) / node_data.est_refs[phase_n];
+    node_data.flows[phase] = node_data.flows[phase] / node_data.est_refs[phase];
+  }
+
+  template<bool DO_AREA>
+  inline void select_alternatives( node<Ntk> const& n )
+  {
+    if constexpr ( DO_AREA )
+      return;
+
+    if ( !ps.use_match_alternatives )
+      return;
+
+    auto index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+
+    best_gate_emap<NInputs>& g0 = node_data.best_alternative[0];
+    best_gate_emap<NInputs>& g1 = node_data.best_alternative[1];
+    float g0flow = g0.flow / node_data.est_refs[0];
+    float g1flow = g1.flow / node_data.est_refs[1];
+
+    /* process for best area */ /* removed check on required since this is executed only during a delay pass */
+    if ( g0.gate != nullptr && g0flow + lib_inv_area < g1flow + epsilon )
+    {
+      g1 = g0;
+      g1.gate = nullptr;
+      g1.arrival += lib_inv_delay;
+      g1.flow = ( g1.flow + lib_inv_area ) / node_data.est_refs[1];
+      g0.flow = g0flow;
+      return;
+    }
+    else if ( g1.gate != nullptr && g1flow + lib_inv_area < g0flow + epsilon )
+    {
+      g0 = g1;
+      g0.gate = nullptr;
+      g0.arrival += lib_inv_delay;
+      g0.flow = ( g0.flow + lib_inv_area ) / node_data.est_refs[0];
+      g1.flow = g1flow;
+      return;
+    }
+
+    g0.flow = g0flow;
+    g1.flow = g1flow;
+  }
+
+  inline void refine_best_matches( node<Ntk> const& n )
+  {
+    auto index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+
+    /* evaluate to change the best matches with the best alternative */
+    best_gate_emap<NInputs>& g0 = node_data.best_alternative[0];
+    best_gate_emap<NInputs>& g1 = node_data.best_alternative[1];
+
+    if ( node_data.map_refs[0] && node_data.map_refs[1] )
+    {
+      if ( node_data.same_match )
+      {
+        /* pick best implementation between the two alternatives */
+        unsigned best_match_phase = node_data.best_gate[0] == nullptr ? 1 : 0;
+        unsigned use_phase = g0.gate == nullptr ? 1 : 0;
+        if ( g0.gate != nullptr && g1.gate != nullptr )
+        {
+          if ( g0.arrival > node_data.required[0] + epsilon || g1.arrival > node_data.required[1] + epsilon )
+            return;
+
+          refine_best_matches_copy_refinement( n, 0, false );
+          refine_best_matches_copy_refinement( n, 1, false );
+          node_data.same_match = false;
+          return;
+        }
+        else
+        {
+          best_gate_emap<NInputs>& gUse = node_data.best_alternative[use_phase];
+          if ( gUse.arrival > node_data.required[use_phase] + epsilon || gUse.arrival + lib_inv_delay > node_data.required[use_phase ^ 1] + epsilon )
+          {
+            return;
+          }
+          refine_best_matches_copy_refinement( n, use_phase, true );
+          return;
+        }
+      }
+      else
+      {
+        /* not same match: evaluate both zero and one phase */
+        if ( g0.gate != nullptr && g0.arrival < node_data.required[0] + epsilon )
+        {
+          node_data.same_match = false;
+          refine_best_matches_copy_refinement( n, 0, g1.gate == nullptr && g0.arrival + lib_inv_delay < node_data.required[1] + epsilon );
+        }
+        if ( g1.gate != nullptr && g1.arrival < node_data.required[1] + epsilon )
+        {
+          node_data.same_match = false;
+          refine_best_matches_copy_refinement( n, 1, g0.gate == nullptr && g1.arrival + lib_inv_delay < node_data.required[0] + epsilon );
+        }
+      }
+    }
+    else if ( node_data.map_refs[0] )
+    {
+      if ( g0.gate != nullptr && g0.arrival < node_data.required[0] + epsilon )
+      {
+        node_data.same_match = false;
+        refine_best_matches_copy_refinement( n, 0, false );
+      }
+      else if ( g0.gate == nullptr && g1.arrival + lib_inv_delay < node_data.required[0] + epsilon )
+      {
+        refine_best_matches_copy_refinement( n, 1, true );
+      }
+    }
+    else
+    {
+      if ( g1.gate != nullptr && g1.arrival < node_data.required[1] + epsilon )
+      {
+        node_data.same_match = false;
+        refine_best_matches_copy_refinement( n, 1, false );
+      }
+      else if ( g1.gate == nullptr && g0.arrival + lib_inv_delay < node_data.required[1] + epsilon )
+      {
+        refine_best_matches_copy_refinement( n, 0, true );
+      }
+    }
+  }
+
+  inline void refine_best_matches_copy_refinement( node<Ntk> const& n, unsigned phase, bool both_phases )
+  {
+    auto index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+    best_gate_emap<NInputs>& bg = node_data.best_alternative[phase];
+
+    node_data.best_gate[phase] = bg.gate;
+    node_data.phase[phase] = bg.phase;
+    node_data.best_cut[phase] = bg.cut;
+    node_data.arrival[phase] = bg.arrival;
+    node_data.area[phase] = bg.area;
+    node_data.flows[phase] = bg.flow;
+
+    if ( !both_phases )
+      return;
+
+    node_data.same_match = true;
+    phase ^= 1;
+    node_data.best_gate[phase] = nullptr;
+    node_data.phase[phase] = bg.phase;
+    node_data.best_cut[phase] = bg.cut;
+    node_data.arrival[phase] = bg.arrival + lib_inv_delay;
+    node_data.area[phase] = bg.area;
+    node_data.flows[phase] = ( bg.flow * node_data.est_refs[phase ^ 1] + lib_inv_area ) / node_data.est_refs[phase];
+  }
+
+  bool initialize_box( node<Ntk> const& n )
+  {
+    uint32_t index = ntk.node_to_index( n );
+
+    if ( cuts[index].size() == 0 )
+      add_unit_cut( index );
+
+    auto& node_data = node_match[index];
+    node_data.same_match = true;
+
+    /* if it has mapping data propagate the delays and measure the data */
+    if constexpr ( has_has_binding_v<Ntk> )
+    {
+      propagate_data_forward_white_box( n );
+      return false;
+    }
+
+    /* consider as a black box */
+    node_data.flows[0] = 0.0f;
+    node_data.flows[1] = lib_inv_area / node_data.est_ref[1];
+    node_data.arrival[0] = 0.0f;
+    node_data.arrival[1] = lib_inv_delay;
+    node_data.area[0] = node_data.area[1] = 0;
+
+    return true;
+  }
+
+  void propagate_data_forward_white_box( node<Ntk> const& n )
+  {
+    uint32_t index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+    auto const& gate = ntk.get_binding( n );
+
+    /* propagate arrival time */
+    double arrival = 0;
+    ntk.foreach_fanin( n, [&]( auto const& f, auto i ) {
+      uint32_t f_index = ntk.node_to_index( ntk.get_node( f ) );
+      uint8_t phase = ntk.is_complemented( f ) ? 1 : 0;
+      double propagation_delay = std::max( gate.pins[i].rise_block_delay, gate.pins[i].fall_block_delay );
+      arrival = std::max( arrival, node_match[f_index].arrival[phase] + propagation_delay );
+    } );
+
+    /* set data */
+    node_data.arrival[0] = arrival;
+    node_data.arrival[1] = arrival + lib_inv_delay;
+    node_data.area[0] = node_data.area[1] = gate.area;
+    node_data.flows[1] = ( node_data.flows[0] + lib_inv_area ) / node_data.est_refs[1];
+    node_data.flows[0] = node_data.area[0] / node_data.est_refs[0];
+  }
+
+  void propagate_data_backward_white_box( node<Ntk> const& n )
+  {
+    uint32_t index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+    auto const& gate = ntk.get_binding( n );
+
+    assert( node_data.map_refs[0] || node_data.map_refs[1] );
+
+    /* propagate required time over the output inverter if present */
+    if ( node_data.map_refs[1] > 0 )
+    {
+      node_data.required[0] = std::min( node_data.required[0], node_data.required[1] - lib_inv_delay );
+    }
+
+    if ( node_data.map_refs[0] )
+      assert( node_data.arrival[0] < node_data.required[0] + epsilon );
+    if ( node_data.map_refs[1] )
+      assert( node_data.arrival[1] < node_data.required[1] + epsilon );
+
+    ntk.foreach_fanin( n, [&]( auto const& f, auto i ) {
+      uint32_t f_index = ntk.node_to_index( ntk.get_node( f ) );
+      uint8_t phase = ntk.is_complemented( f ) ? 1 : 0;
+      double propagation_delay = std::max( gate.pins[i].rise_block_delay, gate.pins[i].fall_block_delay );
+      node_match[f_index].required[phase] = std::min( node_match[f_index].required[phase], node_data.required[0] - propagation_delay );
+    } );
+  }
+
+  void match_constants( uint32_t index )
+  {
+    auto& node_data = node_match[index];
+
+    kitty::static_truth_table<6> zero_tt;
+    auto const supergates_zero = library.get_supergates( zero_tt );
+    auto const supergates_one = library.get_supergates( ~zero_tt );
+
+    /* Not available in the library */
+    if ( supergates_zero == nullptr && supergates_one == nullptr )
+    {
+      return;
+    }
+    /* if only one is available, the other is obtained using an inverter */
+    if ( supergates_zero != nullptr )
+    {
+      node_data.best_gate[0] = &( ( *supergates_zero )[0] );
+      node_data.arrival[0] = node_data.best_gate[0]->tdelay[0];
+      node_data.area[0] = node_data.best_gate[0]->area;
+      node_data.phase[0] = 0;
+    }
+    if ( supergates_one != nullptr )
+    {
+      node_data.best_gate[1] = &( ( *supergates_one )[0] );
+      node_data.arrival[1] = node_data.best_gate[1]->tdelay[0];
+      node_data.area[1] = node_data.best_gate[1]->area;
+      node_data.phase[1] = 0;
+    }
+    else
+    {
+      node_data.same_match = true;
+      node_data.arrival[1] = node_data.arrival[0] + lib_inv_delay;
+      node_data.area[1] = node_data.area[0] + lib_inv_area;
+      node_data.phase[1] = 1;
+    }
+    if ( supergates_zero == nullptr )
+    {
+      node_data.same_match = true;
+      node_data.arrival[0] = node_data.arrival[1] + lib_inv_delay;
+      node_data.area[0] = node_data.area[1] + lib_inv_area;
+      node_data.phase[0] = 1;
+    }
+  }
+
+  template<bool DO_AREA>
+  bool match_multioutput( node<Ntk> const& n )
+  {
+    /* extract outputs tuple */
+    uint32_t index = ntk.node_to_index( n );
+    multi_match_t const& tuple_data = multi_node_match[node_tuple_match[index].index][0];
+
+    /* get the cut */
+    auto const& cut0 = cuts[tuple_data[0].node_index][tuple_data[0].cut_index];
+
+    /* local values storage */
+    std::array<double, max_multioutput_output_size> arrival;
+    std::array<float, max_multioutput_output_size> area_flow;
+    std::array<float, max_multioutput_output_size> area;
+    std::array<uint8_t, max_multioutput_output_size> phase;
+    std::array<uint16_t, max_multioutput_output_size> pin_phase;
+    std::array<double, max_multioutput_output_size> est_refs;
+    std::array<uint32_t, max_multioutput_output_size> cut_index;
+    bool mapped_multioutput = false;
+
+    uint8_t iteration_phase = cut0->supergates[0] == nullptr ? 1 : 0;
+
+    /* iterate for each possible match */
+    for ( auto i = 0; i < cut0->supergates[iteration_phase]->size(); ++i )
+    {
+      /* store local validity and comparison info */
+      bool valid = true;
+      bool is_best = true;
+      bool respects_required = true;
+      double old_flow_sum = 0;
+
+      /* iterate for each output of the multi-output gate */
+      for ( auto j = 0; j < max_multioutput_output_size; ++j )
+      {
+        uint32_t node_index = tuple_data[j].node_index;
+        cut_index[j] = tuple_data[j].cut_index;
+        auto& node_data = node_match[node_index];
+        auto const& cut = cuts[node_index][cut_index[j]];
+        uint8_t phase_inverted = cut->supergates[0] == nullptr ? 1 : 0;
+        supergate<NInputs> const& gate = ( *( cut->supergates[phase_inverted] ) )[i];
+
+        /* protection on complicated duplicated nodes to remap to multioutput */
+        if ( !node_data.same_match )
+          return false;
+
+        /* get the output phase */
+        pin_phase[j] = gate.polarity;
+        phase[j] = ( gate.polarity >> NInputs ) ^ phase_inverted;
+
+        /* compute arrival */
+        arrival[j] = 0.0;
+        auto ctr = 0u;
+        for ( auto l : cut )
+        {
+          double arrival_pin = node_match[l].arrival[( gate.polarity >> ctr ) & 1] + gate.tdelay[ctr];
+          arrival[j] = std::max( arrival[j], arrival_pin );
+          ++ctr;
+        }
+
+        /* check required time: same_match is true */
+        if constexpr ( DO_AREA )
+        {
+          if ( arrival[j] > node_data.required[phase[j]] + epsilon )
+          {
+            valid = false;
+            break;
+          }
+          if ( arrival[j] + lib_inv_delay > node_data.required[phase[j] ^ 1] + epsilon )
+          {
+            valid = false;
+            break;
+          }
+        }
+
+        /* check required time of the current solution */
+        if ( node_data.arrival[phase[j]] > node_data.required[phase[j]] )
+          respects_required = false;
+        if ( node_data.same_match && node_data.arrival[phase[j] ^ 1] > node_data.required[phase[j] ^ 1] )
+          respects_required = false;
+
+        /* compute area flow */
+        if ( j == 0 || !node_data.multioutput_match[0] )
+        {
+          uint8_t current_phase = node_data.best_gate[0] == nullptr ? 1 : 0;
+          old_flow_sum += node_data.flows[current_phase];
+        }
+        uint8_t old_phase = node_data.phase[phase[j]];
+        node_data.phase[phase[j]] = gate.polarity;
+        area[j] = gate.area;
+        area_flow[j] = gate.area + cut_leaves_flow( cut, n, phase[j] );
+        node_data.phase[phase[j]] = old_phase;
+
+        /* current version may lead to delay increase */
+        est_refs[j] = node_data.est_refs[phase[j]];
+      }
+
+      /* not better than individual gates */
+      if ( !valid )
+        continue;
+
+      if constexpr ( !DO_AREA )
+      {
+        if ( !is_best )
+          continue;
+      }
+
+      /* combine evaluation for precise area flow estimantion */
+      /* compute equation AF(n) = ( Area(G) + |roots| * SUM_{l in leaves} AF(l) ) / SUM_{p in roots} est_refs( p ) */
+      float flow_sum_pos = 0, flow_sum_neg;
+      float combined_est_refs = 0;
+      for ( auto j = 0; j < max_multioutput_output_size; ++j )
+      {
+        flow_sum_pos += area_flow[j];
+        combined_est_refs += est_refs[j];
+      }
+      flow_sum_neg = flow_sum_pos;
+      flow_sum_pos /= combined_est_refs;
+
+      /* not better than individual gates */
+      if ( respects_required && ( flow_sum_pos > old_flow_sum + epsilon ) )
+        continue;
+
+      mapped_multioutput = true;
+      flow_sum_neg = ( flow_sum_neg + lib_inv_area ) / combined_est_refs;
+
+      /* commit multi-output gate */
+      for ( uint32_t j = 0; j < max_multioutput_output_size; ++j )
+      {
+        uint32_t node_index = tuple_data[j].node_index;
+        auto& node_data = node_match[node_index];
+        auto const& cut = cuts[node_index][cut_index[j]];
+        uint8_t phase_inverted = cut->supergates[0] == nullptr ? 1 : 0;
+        supergate<NInputs> const& gate = ( *( cut->supergates[phase_inverted] ) )[i];
+
+        uint8_t mapped_phase = phase[j];
+        node_data.multioutput_match[mapped_phase] = true;
+
+        node_data.best_gate[mapped_phase] = &gate;
+        node_data.best_cut[mapped_phase] = cut_index[j];
+        node_data.phase[mapped_phase] = pin_phase[j];
+        node_data.arrival[mapped_phase] = arrival[j];
+        node_data.area[mapped_phase] = area[j]; /* partial area contribution */
+        node_data.flows[mapped_phase] = flow_sum_pos;
+
+        assert( node_data.arrival[mapped_phase] < node_data.required[mapped_phase] + epsilon );
+
+        /* select opposite phase */
+        mapped_phase ^= 1;
+        node_data.multioutput_match[mapped_phase] = true;
+        node_data.best_gate[mapped_phase] = nullptr;
+        node_data.best_cut[mapped_phase] = cut_index[j];
+        node_data.phase[mapped_phase] = pin_phase[j];
+        node_data.arrival[mapped_phase] = arrival[j] + lib_inv_delay;
+        node_data.area[mapped_phase] = area[j]; /* partial area contribution */
+        node_data.flows[mapped_phase] = flow_sum_neg;
+
+        assert( node_data.arrival[mapped_phase] < node_data.required[mapped_phase] + epsilon );
+      }
+    }
+
+    return mapped_multioutput;
+  }
+
+  template<bool SwitchActivity>
+  bool match_multioutput_exact( node<Ntk> const& n, bool last_round )
+  {
+    /* extract outputs tuple */
+    uint32_t index = ntk.node_to_index( n );
+    multi_match_t const& tuple_data = multi_node_match[node_tuple_match[index].index][0];
+
+    /* local values storage */
+    std::array<float, max_multioutput_output_size> best_exact_area;
+
+    for ( int j = max_multioutput_output_size - 1; j >= 0; --j )
+    {
+      /* protection on complicated duplicated nodes to remap to multioutput */
+      if ( !node_match[tuple_data[j].node_index].same_match )
+        return false;
+    }
+
+    /* if one of the outputs is not referenced, do not use multi-output gate */
+    if ( last_round )
+    {
+      for ( uint32_t j = 0; j < max_multioutput_output_size; ++j )
+      {
+        uint32_t node_index = tuple_data[j].node_index;
+        if ( !node_match[node_index].map_refs[0] && !node_match[node_index].map_refs[1] )
+        {
+          return false;
+        }
+      }
+    }
+
+    /* if "same match" and used in the cover dereference the leaves (reverse topo order) */
+    for ( int j = max_multioutput_output_size - 1; j >= 0; --j )
+    {
+      uint32_t node_index = tuple_data[j].node_index;
+      uint8_t selected_phase = node_match[node_index].best_gate[0] == nullptr ? 1 : 0;
+
+      if ( node_match[node_index].map_refs[0] || node_match[node_index].map_refs[1] )
+      {
+        /* match is always single output here */
+        auto const& cut = cuts[node_index][node_match[node_index].best_cut[0]];
+        uint8_t use_phase = node_match[node_index].best_gate[0] != nullptr ? 0 : 1;
+        best_exact_area[j] = cut_deref<SwitchActivity>( cut, ntk.index_to_node( node_index ), use_phase );
+
+        /* mapping a non referenced phase */
+        if ( node_match[node_index].map_refs[selected_phase] == 0 )
+          best_exact_area[j] += lib_inv_area;
+      }
+    }
+
+    /* perform mapping */
+    bool mapped_multioutput = false;
+    mapped_multioutput = match_multioutput_exact_core<SwitchActivity>( tuple_data, best_exact_area );
+
+    /* if "same match" and used in the cover reference the leaves (topo order) */
+    for ( auto j = 0; j < max_multioutput_output_size; ++j )
+    {
+      uint32_t node_index = tuple_data[j].node_index;
+
+      if ( node_match[node_index].map_refs[0] || node_match[node_index].map_refs[1] )
+      {
+        uint8_t use_phase = node_match[node_index].best_gate[0] != nullptr ? 0 : 1;
+        auto const& best_cut = cuts[node_index][node_match[node_index].best_cut[use_phase]];
+        cut_ref<SwitchActivity>( best_cut, ntk.index_to_node( node_index ), use_phase );
+      }
+    }
+
+    return mapped_multioutput;
+  }
+
+  template<bool SwitchActivity>
+  inline bool match_multioutput_exact_core( multi_match_t const& tuple_data, std::array<float, max_multioutput_output_size>& best_exact_area )
+  {
+    /* get the cut representative */
+    auto const& cut0 = cuts[tuple_data[0].node_index][tuple_data[0].cut_index];
+
+    /* local values storage */
+    std::array<double, max_multioutput_output_size> arrival;
+    std::array<float, max_multioutput_output_size> area_exact;
+    std::array<float, max_multioutput_output_size> area;
+    std::array<uint8_t, max_multioutput_output_size> phase;
+    std::array<uint16_t, max_multioutput_output_size> pin_phase;
+    std::array<uint32_t, max_multioutput_output_size> cut_index;
+
+    uint8_t iteration_phase = cut0->supergates[0] == nullptr ? 1 : 0;
+
+    bool mapped_multioutput = false;
+
+    /* iterate for each possible match */
+    for ( auto i = 0; i < cut0->supergates[iteration_phase]->size(); ++i )
+    {
+      /* store local validity and comparison info */
+      bool valid = true;
+      bool is_best = true;
+      bool respects_required = true;
+      uint32_t it_counter = 0;
+
+      /* iterate for each output of the multi-output gate (reverse topo order) */
+      for ( int j = max_multioutput_output_size - 1; j >= 0; --j )
+      {
+        uint32_t node_index = tuple_data[j].node_index;
+        cut_index[j] = tuple_data[j].cut_index;
+        auto& node_data = node_match[node_index];
+        auto const& cut = cuts[node_index][cut_index[j]];
+        uint8_t phase_inverted = cut->supergates[0] == nullptr ? 1 : 0;
+        supergate<NInputs> const& gate = ( *( cut->supergates[phase_inverted] ) )[i];
+        ++it_counter;
+
+        /* get the output phase and area */
+        pin_phase[j] = gate.polarity;
+        phase[j] = ( gate.polarity >> NInputs ) ^ phase_inverted;
+        area[j] = gate.area;
+
+        /* compute arrival */
+        arrival[j] = 0.0;
+        auto ctr = 0u;
+        for ( auto l : cut )
+        {
+          double arrival_pin = node_match[l].arrival[( gate.polarity >> ctr ) & 1] + gate.tdelay[ctr];
+          arrival[j] = std::max( arrival[j], arrival_pin );
+          ++ctr;
+        }
+
+        /* check required time */
+        if ( arrival[j] > node_data.required[phase[j]] + epsilon )
+        {
+          valid = false;
+          break;
+        }
+        if ( arrival[j] + lib_inv_delay > node_data.required[phase[j] ^ 1] + epsilon )
+        {
+          valid = false;
+          break;
+        }
+
+        /* check required time of current solution */
+        if ( node_data.arrival[phase[j]] > node_data.required[phase[j]] )
+          respects_required = false;
+        if ( node_data.arrival[phase[j] ^ 1] > node_data.required[phase[j] ^ 1] )
+          respects_required = false;
+
+        /* compute exact area for match: needed only for the first node (leaves are shared) */
+        if ( it_counter == 1 )
+        {
+          auto old_phase = node_data.phase[phase[j]];
+          auto old_area = node_data.area[phase[j]];
+          node_data.phase[phase[j]] = pin_phase[j];
+          node_data.area[phase[j]] = area[j];
+          area_exact[j] = cut_measure_mffc<SwitchActivity>( cut, ntk.index_to_node( node_index ), phase[j] );
+          node_data.phase[phase[j]] = old_phase;
+          node_data.area[phase[j]] = old_area;
+        }
+        else
+        {
+          area_exact[j] = area[j];
+        }
+
+        /* Add output inverter cost if mapping a non referenced phase */
+        if ( node_data.map_refs[phase[j]] == 0 && node_data.map_refs[phase[j] ^ 1] > 0 )
+        {
+          area_exact[j] += lib_inv_area;
+        }
+      }
+
+      /* check quality: TODO add output inverter in the cost if necessary */
+      float best_exact_area_total = 0;
+      float area_exact_total = 0;
+      for ( auto j = 0; j < max_multioutput_output_size; ++j )
+      {
+        best_exact_area_total += best_exact_area[j];
+        area_exact_total += area_exact[j];
+      }
+
+      /* not better than individual gates */
+      if ( !valid || ( area_exact_total > best_exact_area_total - epsilon && respects_required ) )
+      {
+        continue;
+      }
+
+      mapped_multioutput = true;
+
+      /* commit multi-output gate (topo order) */
+      for ( uint32_t j = 0; j < max_multioutput_output_size; ++j )
+      {
+        uint32_t node_index = tuple_data[j].node_index;
+        auto& node_data = node_match[node_index];
+        auto const& cut = cuts[node_index][cut_index[j]];
+        uint8_t phase_inverted = cut->supergates[0] == nullptr ? 1 : 0;
+        supergate<NInputs> const& gate = ( *( cut->supergates[phase_inverted] ) )[i];
+
+        uint8_t mapped_phase = phase[j];
+        best_exact_area[j] = area_exact[j];
+
+        if ( node_data.map_refs[phase[j]] == 0 && node_data.map_refs[phase[j] ^ 1] > 0 )
+        {
+          best_exact_area[j] += lib_inv_area;
+        }
+
+        /* write data */
+        node_data.multioutput_match[mapped_phase] = true;
+        node_data.best_gate[mapped_phase] = &gate;
+        node_data.best_cut[mapped_phase] = cut_index[j];
+        node_data.phase[mapped_phase] = pin_phase[j];
+        node_data.arrival[mapped_phase] = arrival[j];
+        node_data.area[mapped_phase] = area[j]; /* partial area contribution */
+
+        node_data.flows[mapped_phase] = area_exact[j]; /* partial exact area contribution */
+        /* select opposite phase */
+        mapped_phase ^= 1;
+        node_data.multioutput_match[mapped_phase] = true;
+        node_data.best_gate[mapped_phase] = nullptr;
+        node_data.best_cut[mapped_phase] = cut_index[j];
+        node_data.phase[mapped_phase] = pin_phase[j];
+        node_data.arrival[mapped_phase] = arrival[j] + lib_inv_delay;
+        node_data.area[mapped_phase] = area[j]; /* partial area contribution */
+        node_data.flows[mapped_phase] = area_exact[j];
+
+        assert( node_data.arrival[mapped_phase] < node_data.required[mapped_phase] + epsilon );
+      }
+    }
+
+    return mapped_multioutput;
+  }
+
+  template<bool DO_AREA>
+  void multi_node_update( node<Ntk> const& n )
+  {
+    uint32_t check_index = ntk.node_to_index( n );
+    multi_match_t const& tuple_data = multi_node_match[node_tuple_match[ntk.node_to_index( n )].index][0];
+    uint64_t signature = 0;
+
+    /* check if a node is in TFI: there is a path of length > 1 */
+    bool in_tfi = false;
+    node<Ntk> min_node = n;
+    for ( auto j = 0; j < max_multioutput_output_size - 1; ++j )
+    {
+      if ( tuple_data[j].in_tfi )
+      {
+        min_node = ntk.index_to_node( tuple_data[j].node_index );
+        in_tfi = true;
+        signature |= UINT64_C( 1 ) << ( tuple_data[j].node_index & 0x3f );
+      }
+    }
+
+    if ( !in_tfi )
+      return;
+
+    /* recompute data in between: should I mark the leaves? (not necessary under some assumptions) */
+    ntk.incr_trav_id();
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      /* TODO: this recursion works as it is for a maximum multioutput value of 2 */
+      multi_node_update_rec<DO_AREA>( ntk.get_node( f ), min_node + 1, signature );
+    } );
+  }
+
+  template<bool DO_AREA>
+  void multi_node_update_rec( node<Ntk> const& n, uint32_t min_index, uint64_t& signature )
+  {
+    uint32_t index = ntk.node_to_index( n );
+
+    if ( index < min_index )
+      return;
+    if ( ntk.visited( n ) == ntk.trav_id() )
+      return;
+
+    ntk.set_visited( n, ntk.trav_id() );
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      multi_node_update_rec<DO_AREA>( ntk.get_node( f ), min_index, signature );
+    } );
+
+    /* update the node if uses an updated leaf */
+    auto& node_data = node_match[index];
+    bool leaf_used = multi_node_update_cut_check( index, signature, 0 );
+
+    if ( !node_data.same_match )
+      leaf_used |= multi_node_update_cut_check( index, signature, 1 );
+
+    if ( !leaf_used )
+      return;
+
+    signature |= UINT64_C( 1 ) << ( index & 0x3f );
+
+    /* avoid cycles by recomputing arrival times for multi-output gates or decomposing them */
+    if ( node_data.same_match && node_data.multioutput_match[0] )
+    {
+      propagate_arrival_node( n );
+      /* check required time */
+      if ( node_data.arrival[0] < node_data.required[0] + epsilon && node_data.arrival[1] < node_data.required[1] + epsilon )
+        return;
+    }
+
+    /* match positive phase */
+    match_phase<DO_AREA>( n, 0u );
+
+    /* match negative phase */
+    match_phase<DO_AREA>( n, 1u );
+
+    /* try to drop one phase */
+    match_drop_phase<DO_AREA, false>( n );
+
+    assert( node_data.arrival[0] < node_data.required[0] + epsilon );
+    assert( node_data.arrival[1] < node_data.required[1] + epsilon );
+  }
+
+  template<bool SwitchActivity>
+  void multi_node_update_exact( node<Ntk> const& n )
+  {
+    uint32_t check_index = ntk.node_to_index( n );
+    multi_match_t const& tuple_data = multi_node_match[node_tuple_match[ntk.node_to_index( n )].index][0];
+    uint64_t signature = 0;
+
+    /* check if a node is in TFI: there is a path of length > 1 */
+    bool in_tfi = false;
+    node<Ntk> min_node = n;
+    for ( auto j = 0; j < max_multioutput_output_size - 1; ++j )
+    {
+      if ( tuple_data[j].in_tfi )
+      {
+        min_node = ntk.index_to_node( tuple_data[j].node_index );
+        in_tfi = true;
+        signature |= UINT64_C( 1 ) << ( tuple_data[j].node_index & 0x3f );
+      }
+    }
+
+    if ( !in_tfi )
+      return;
+
+    /* recompute data in between: should I mark the leaves? (not necessary under some assumptions) */
+    ntk.incr_trav_id();
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      /* TODO: this recursion works as it is for a maximum multioutput value of 2 */
+      multi_node_update_exact_rec<SwitchActivity>( ntk.get_node( f ), min_node + 1, signature );
+    } );
+  }
+
+  template<bool SwitchActivity>
+  void multi_node_update_exact_rec( node<Ntk> const& n, uint32_t min_index, uint64_t& signature )
+  {
+    uint32_t index = ntk.node_to_index( n );
+
+    if ( index < min_index )
+      return;
+    if ( ntk.visited( n ) == ntk.trav_id() )
+      return;
+
+    ntk.set_visited( n, ntk.trav_id() );
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      multi_node_update_exact_rec<SwitchActivity>( ntk.get_node( f ), min_index, signature );
+    } );
+
+    /* update the node if uses an updated leaf */
+    auto& node_data = node_match[index];
+    bool leaf_used = multi_node_update_cut_check( index, signature, 0 );
+
+    if ( !node_data.same_match )
+      leaf_used |= multi_node_update_cut_check( index, signature, 1 );
+
+    if ( !leaf_used )
+      return;
+
+    signature |= UINT64_C( 1 ) << ( index & 0x3f );
+
+    assert( !node_data.multioutput_match[0] );
+    assert( !node_data.multioutput_match[1] );
+
+    if ( node_data.same_match && ( node_data.map_refs[0] || node_data.map_refs[1] ) )
+    {
+      uint8_t use_phase = node_data.best_gate[0] != nullptr ? 0 : 1;
+      auto const& best_cut = cuts[index][node_data.best_cut[use_phase]];
+      cut_deref<SwitchActivity>( best_cut, n, use_phase );
+    }
+
+    /* match positive phase */
+    match_phase_exact<SwitchActivity>( n, 0u );
+
+    /* match negative phase */
+    match_phase_exact<SwitchActivity>( n, 1u );
+
+    /* try to drop one phase */
+    match_drop_phase<true, true>( n );
+
+    assert( node_data.arrival[0] < std::numeric_limits<float>::max() );
+    assert( node_data.arrival[1] < std::numeric_limits<float>::max() );
+  }
+
+  inline void match_multioutput_propagate_required( node<Ntk> const& n )
+  {
+    /* extract outputs tuple */
+    uint32_t index = ntk.node_to_index( n );
+    multi_match_t const& tuple_data = multi_node_match[node_tuple_match[index].index][0];
+
+    for ( int j = max_multioutput_output_size - 1; j >= 0; --j )
+    {
+      const auto node_index = tuple_data[j].node_index;
+      match_propagate_required( node_index );
+    }
+  }
+
+  void match_multi_add_cuts( node<Ntk> const& n )
+  {
+    /* assume a single cut (current version) */
+    uint32_t index = ntk.node_to_index( n );
+    multi_match_t& matches = multi_node_match[node_tuple_match[index].index][0];
+
+    /* find the corresponding cut */
+    uint32_t cut_p = 0;
+    while ( matches[cut_p].node_index != index )
+      ++cut_p;
+
+    assert( cut_p < matches.size() );
+    uint32_t cut_index = matches[cut_p].cut_index;
+    auto& cut = multi_cut_set[cut_index][cut_p];
+    auto single_cut = multi_cut_set[cut_index][cut_p];
+    auto& rcuts = cuts[index];
+
+    /* not enough space in the data structure: abort */
+    if ( rcuts.size() == max_cut_num )
+    {
+      match_multi_add_cuts_remove_entry( matches );
+      return;
+    }
+
+    /* insert single cut variation if unique (for delay preservation) */
+    if ( !rcuts.is_contained( single_cut ) )
+    {
+      single_cut->pattern_index = 0;
+      compute_cut_data( single_cut, ntk.index_to_node( index ) );
+      rcuts.append_cut( single_cut );
+
+      /* not enough space in the data structure: abort */
+      if ( rcuts.size() == max_cut_num )
+      {
+        rcuts.limit( rcuts.size() - 1 );
+        match_multi_add_cuts_remove_entry( matches );
+        return;
+      }
+    }
+
+    /* add multi-output cut */
+    uint32_t num_cuts_pre = rcuts.size();
+    cut->ignore = true;
+    rcuts.append_cut( cut );
+
+    uint32_t num_cuts_after = rcuts.size();
+    assert( num_cuts_after == num_cuts_pre + 1 );
+
+    rcuts.limit( num_cuts_pre );
+
+    /* update tuple data */
+    matches[cut_p].cut_index = num_cuts_pre;
+  }
+
+  inline void match_multi_add_cuts_remove_entry( multi_match_t const& matches )
+  {
+    /* reset matches */
+    for ( multi_match_data const& entry : matches )
+    {
+      node_tuple_match[entry.node_index].data = 0;
+    }
+  }
+
+  inline bool multi_node_update_cut_check( uint32_t index, uint64_t signature, uint8_t phase )
+  {
+    auto const& cut = cuts[index][node_match[index].best_cut[phase]];
+
+    if ( ( signature & cut.signature() ) > 0 )
+      return true;
+
+    return false;
+  }
+#pragma endregion
+
+#pragma region Mapping utils
+  inline double cut_leaves_flow( cut_t const& cut, node<Ntk> const& n, uint8_t phase )
+  {
+    double flow{ 0.0f };
+    auto const& node_data = node_match[ntk.node_to_index( n )];
+
+    uint8_t ctr = 0u;
+    for ( auto leaf : cut )
+    {
+      uint8_t leaf_phase = ( node_data.phase[phase] >> ctr++ ) & 1;
+      flow += node_match[leaf].flows[leaf_phase];
+    }
+
+    return flow;
+  }
+
+  template<bool SwitchActivity>
+  float cut_ref( cut_t const& cut, node<Ntk> const& n, uint8_t phase )
+  {
+    auto const& node_data = node_match[ntk.node_to_index( n )];
+    float count;
+
+    if constexpr ( SwitchActivity )
+      count = switch_activity[ntk.node_to_index( n )];
+    else
+      count = node_data.area[phase];
+
+    /* don't touch box */
+    if constexpr ( has_is_dont_touch_v<Ntk> )
+    {
+      if ( ntk.is_dont_touch( n ) )
+      {
+        return count;
+      }
+    }
+
+    uint8_t ctr = 0;
+    for ( auto leaf : cut )
+    {
+      /* compute leaf phase using the current gate */
+      uint8_t leaf_phase = ( node_data.phase[phase] >> ctr++ ) & 1;
+
+      if ( ntk.is_constant( ntk.index_to_node( leaf ) ) )
+      {
+        continue;
+      }
+      else if ( ntk.is_pi( ntk.index_to_node( leaf ) ) )
+      {
+        /* reference PIs, add inverter cost for negative phase */
+        if ( leaf_phase == 1u )
+        {
+          if ( node_match[leaf].map_refs[1]++ == 0u )
+          {
+            if constexpr ( SwitchActivity )
+              count += switch_activity[leaf];
+            else
+              count += lib_inv_area;
+          }
+        }
+        else
+        {
+          ++node_match[leaf].map_refs[0];
+        }
+        continue;
+      }
+
+      if ( node_match[leaf].same_match )
+      {
+        /* Recursive referencing if leaf was not referenced */
+        if ( !node_match[leaf].map_refs[0] && !node_match[leaf].map_refs[1] )
+        {
+          auto const& best_cut = cuts[leaf][node_match[leaf].best_cut[leaf_phase]];
+          count += cut_ref<SwitchActivity>( best_cut, ntk.index_to_node( leaf ), leaf_phase );
+        }
+
+        /* Add inverter area if not present yet and leaf node is implemented in the opposite phase */
+        if ( node_match[leaf].map_refs[leaf_phase]++ == 0u && node_match[leaf].best_gate[leaf_phase] == nullptr )
+        {
+          if constexpr ( SwitchActivity )
+            count += switch_activity[leaf];
+          else
+            count += lib_inv_area;
+        }
+      }
+      else
+      {
+        if ( node_match[leaf].map_refs[leaf_phase]++ == 0u )
+        {
+          auto const& best_cut = cuts[leaf][node_match[leaf].best_cut[leaf_phase]];
+          count += cut_ref<SwitchActivity>( best_cut, ntk.index_to_node( leaf ), leaf_phase );
+        }
+      }
+    }
+    return count;
+  }
+
+  template<bool SwitchActivity>
+  float cut_deref( cut_t const& cut, node<Ntk> const& n, uint8_t phase )
+  {
+    auto const& node_data = node_match[ntk.node_to_index( n )];
+    float count;
+
+    if constexpr ( SwitchActivity )
+      count = switch_activity[ntk.node_to_index( n )];
+    else
+      count = node_data.area[phase];
+
+    /* don't touch box */
+    if constexpr ( has_is_dont_touch_v<Ntk> )
+    {
+      if ( ntk.is_dont_touch( n ) )
+      {
+        return count;
+      }
+    }
+
+    uint8_t ctr = 0;
+    for ( auto leaf : cut )
+    {
+      /* compute leaf phase using the current gate */
+      uint8_t leaf_phase = ( node_data.phase[phase] >> ctr++ ) & 1;
+
+      if ( ntk.is_constant( ntk.index_to_node( leaf ) ) )
+      {
+        continue;
+      }
+      else if ( ntk.is_pi( ntk.index_to_node( leaf ) ) )
+      {
+        /* dereference PIs, add inverter cost for negative phase */
+        if ( leaf_phase == 1u )
+        {
+          if ( --node_match[leaf].map_refs[1] == 0u )
+          {
+            if constexpr ( SwitchActivity )
+              count += switch_activity[leaf];
+            else
+              count += lib_inv_area;
+          }
+        }
+        else
+        {
+          --node_match[leaf].map_refs[0];
+        }
+        continue;
+      }
+
+      if ( node_match[leaf].same_match )
+      {
+        /* Add inverter area if it is used only by the current gate and leaf node is implemented in the opposite phase */
+        if ( --node_match[leaf].map_refs[leaf_phase] == 0u && node_match[leaf].best_gate[leaf_phase] == nullptr )
+        {
+          if constexpr ( SwitchActivity )
+            count += switch_activity[leaf];
+          else
+            count += lib_inv_area;
+        }
+        /* Recursive dereferencing */
+        if ( !node_match[leaf].map_refs[0] && !node_match[leaf].map_refs[1] )
+        {
+          auto const& best_cut = cuts[leaf][node_match[leaf].best_cut[leaf_phase]];
+          count += cut_deref<SwitchActivity>( best_cut, ntk.index_to_node( leaf ), leaf_phase );
+        }
+      }
+      else
+      {
+        if ( --node_match[leaf].map_refs[leaf_phase] == 0u )
+        {
+          auto const& best_cut = cuts[leaf][node_match[leaf].best_cut[leaf_phase]];
+          count += cut_deref<SwitchActivity>( best_cut, ntk.index_to_node( leaf ), leaf_phase );
+        }
+      }
+    }
+    return count;
+  }
+
+  template<bool SwitchActivity>
+  float cut_measure_mffc( cut_t const& cut, node<Ntk> const& n, uint8_t phase )
+  {
+    tmp_visited.clear();
+
+    float count = cut_ref_visit<SwitchActivity>( cut, n, phase );
+
+    /* dereference visited */
+    for ( auto s : tmp_visited )
+    {
+      uint32_t leaf = s >> 1;
+      --node_match[leaf].map_refs[s & 1];
+    }
+
+    return count;
+  }
+
+  template<bool SwitchActivity>
+  float cut_ref_visit( cut_t const& cut, node<Ntk> const& n, uint8_t phase )
+  {
+    auto const& node_data = node_match[ntk.node_to_index( n )];
+    float count;
+
+    if constexpr ( SwitchActivity )
+      count = switch_activity[ntk.node_to_index( n )];
+    else
+      count = node_data.area[phase];
+
+    /* don't touch box */
+    if constexpr ( has_is_dont_touch_v<Ntk> )
+    {
+      if ( ntk.is_dont_touch( n ) )
+      {
+        return count;
+      }
+    }
+
+    uint8_t ctr = 0;
+    for ( auto leaf : cut )
+    {
+      /* compute leaf phase using the current gate */
+      uint8_t leaf_phase = ( node_data.phase[phase] >> ctr++ ) & 1;
+
+      if ( ntk.is_constant( ntk.index_to_node( leaf ) ) )
+      {
+        continue;
+      }
+
+      /* add to visited */
+      tmp_visited.push_back( ( static_cast<uint64_t>( leaf ) << 1 ) | leaf_phase );
+
+      if ( ntk.is_pi( ntk.index_to_node( leaf ) ) )
+      {
+        /* reference PIs, add inverter cost for negative phase */
+        if ( leaf_phase == 1u )
+        {
+          if ( node_match[leaf].map_refs[1]++ == 0u )
+          {
+            if constexpr ( SwitchActivity )
+              count += switch_activity[leaf];
+            else
+              count += lib_inv_area;
+          }
+        }
+        else
+        {
+          ++node_match[leaf].map_refs[0];
+        }
+        continue;
+      }
+
+      if ( node_match[leaf].same_match )
+      {
+        /* Recursive referencing if leaf was not referenced */
+        if ( !node_match[leaf].map_refs[0] && !node_match[leaf].map_refs[1] )
+        {
+          auto const& best_cut = cuts[leaf][node_match[leaf].best_cut[leaf_phase]];
+          count += cut_ref_visit<SwitchActivity>( best_cut, ntk.index_to_node( leaf ), leaf_phase );
+        }
+
+        /* Add inverter area if not present yet and leaf node is implemented in the opposite phase */
+        if ( node_match[leaf].map_refs[leaf_phase]++ == 0u && node_match[leaf].best_gate[leaf_phase] == nullptr )
+        {
+          if constexpr ( SwitchActivity )
+            count += switch_activity[leaf];
+          else
+            count += lib_inv_area;
+        }
+      }
+      else
+      {
+        if ( node_match[leaf].map_refs[leaf_phase]++ == 0u )
+        {
+          auto const& best_cut = cuts[leaf][node_match[leaf].best_cut[leaf_phase]];
+          count += cut_ref_visit<SwitchActivity>( best_cut, ntk.index_to_node( leaf ), leaf_phase );
+        }
+      }
+    }
+    return count;
+  }
+#pragma endregion
+
+#pragma region Initialize and dump the mapped network
+  void insert_buffers()
+  {
+    if ( lib_buf_id != UINT32_MAX )
+    {
+      double area_old = area;
+      bool buffers = false;
+
+      ntk.foreach_po( [&]( auto const& f ) {
+        auto const& n = ntk.get_node( f );
+        if ( !ntk.is_constant( n ) && ntk.is_pi( n ) && !ntk.is_complemented( f ) )
+        {
+          area += lib_buf_area;
+          delay = std::max( delay, node_match[ntk.node_to_index( n )].arrival[0] + lib_inv_delay );
+          buffers = true;
+        }
+      } );
+
+      /* round stats */
+      if ( ps.verbose && buffers )
+      {
+        std::stringstream stats{};
+        float area_gain = 0.0f;
+
+        area_gain = float( ( area_old - area ) / area_old * 100 );
+
+        stats << fmt::format( "[i] Buffering: Delay = {:>12.2f}  Area = {:>12.2f}  Gain = {:>5.2f} %  Inverters = {:>5}  Time = {:>5.2f}\n", delay, area, area_gain, inv, to_seconds( clock::now() - time_begin ) );
+        st.round_stats.push_back( stats.str() );
+      }
+    }
+  }
+
+  std::pair<binding_view<klut_network>, klut_map> initialize_map_network()
+  {
+    binding_view<klut_network> dest( library.get_gates() );
+    klut_map old2new;
+
+    old2new[ntk.node_to_index( ntk.get_node( ntk.get_constant( false ) ) )][0] = dest.get_constant( false );
+    old2new[ntk.node_to_index( ntk.get_node( ntk.get_constant( false ) ) )][1] = dest.get_constant( true );
+
+    ntk.foreach_pi( [&]( auto const& n ) {
+      old2new[ntk.node_to_index( n )][0] = dest.create_pi();
+    } );
+    return { dest, old2new };
+  }
+
+  std::pair<cell_view<block_network>, block_map> initialize_block_network()
+  {
+    cell_view<block_network> dest( library.get_cells() );
+    block_map old2new;
+
+    old2new[ntk.node_to_index( ntk.get_node( ntk.get_constant( false ) ) )][0] = dest.get_constant( false );
+    old2new[ntk.node_to_index( ntk.get_node( ntk.get_constant( false ) ) )][1] = dest.get_constant( true );
+
+    ntk.foreach_pi( [&]( auto const& n ) {
+      old2new[ntk.node_to_index( n )][0] = dest.create_pi();
+    } );
+    return { dest, old2new };
+  }
+
+  void init_topo_order()
+  {
+    topo_order.reserve( ntk.size() );
+
+    if ( multi_node_match.size() > 0 )
+    {
+      multi_init_topo_order();
+      return;
+    }
+
+    topo_view<Ntk>( ntk ).foreach_node( [this]( auto n ) {
+      topo_order.push_back( n );
+    } );
+  }
+
+  bool init_arrivals()
+  {
+    if ( ps.required_times.size() && ps.required_times.size() != ntk.num_pos() )
+    {
+      std::cerr << "[e] MAP ERROR: required time vector does not match the output size of the network" << std::endl;
+      st.mapping_error = true;
+      return false;
+    }
+
+    if ( ps.arrival_times.empty() )
+    {
+      ntk.foreach_pi( [&]( auto const& n ) {
+        auto& node_data = node_match[ntk.node_to_index( n )];
+        node_data.arrival[0] = node_data.best_alternative[0].arrival = 0;
+        node_data.arrival[1] = node_data.best_alternative[1].arrival = lib_inv_delay;
+      } );
+      return true;
+    }
+
+    if ( ps.arrival_times.size() != ntk.num_pis() )
+    {
+      std::cerr << "[e] MAP ERROR: arrival time vector does not match the input size of the network" << std::endl;
+      st.mapping_error = true;
+      return false;
+    }
+
+    ntk.foreach_pi( [&]( auto const& n, uint32_t i ) {
+      auto& node_data = node_match[ntk.node_to_index( n )];
+      node_data.arrival[0] = node_data.best_alternative[0].arrival = ps.arrival_times[i];
+      node_data.arrival[1] = node_data.best_alternative[1].arrival = ps.arrival_times[i] + lib_inv_delay;
+    } );
+
+    return true;
+  }
+
+  void finalize_cover( binding_view<klut_network>& res, klut_map& old2new )
+  {
+    uint32_t multioutput_count = 0;
+
+    for ( auto const& n : topo_order )
+    {
+      auto index = ntk.node_to_index( n );
+      auto const& node_data = node_match[index];
+
+      /* add inverter at PI if needed */
+      if ( ntk.is_constant( n ) )
+      {
+        if ( node_data.best_gate[0] == nullptr && node_data.best_gate[1] == nullptr )
+          continue;
+      }
+      else if ( ntk.is_pi( n ) )
+      {
+        if ( node_data.map_refs[1] > 0 )
+        {
+          old2new[index][1] = res.create_not( old2new[n][0] );
+          res.add_binding( res.get_node( old2new[index][1] ), lib_inv_id );
+        }
+        continue;
+      }
+
+      /* continue if cut is not in the cover */
+      if ( !node_data.map_refs[0] && !node_data.map_refs[1] )
+        continue;
+
+      /* don't touch box */
+      if constexpr ( has_is_dont_touch_v<Ntk> )
+      {
+        if ( ntk.is_dont_touch( n ) )
+        {
+          clone_box( res, old2new, index );
+          continue;
+        }
+      }
+
+      unsigned phase = ( node_data.best_gate[0] != nullptr ) ? 0 : 1;
+
+      /* add used cut */
+      if ( node_data.same_match || node_data.map_refs[phase] > 0 )
+      {
+        create_lut_for_gate( res, old2new, index, phase );
+
+        /* add inverted version if used */
+        if ( node_data.same_match && node_data.map_refs[phase ^ 1] > 0 )
+        {
+          old2new[index][phase ^ 1] = res.create_not( old2new[index][phase] );
+          res.add_binding( res.get_node( old2new[index][phase ^ 1] ), lib_inv_id );
+        }
+
+        /* count multioutput gates */
+        if ( ps.map_multioutput && node_tuple_match[index].lowest_index && node_data.multioutput_match[phase] )
+        {
+          ++multioutput_count;
+        }
+      }
+
+      phase = phase ^ 1;
+      /* add the optional other match if used */
+      if ( !node_data.same_match && node_data.map_refs[phase] > 0 )
+      {
+        create_lut_for_gate( res, old2new, index, phase );
+
+        /* count multioutput gates */
+        if ( ps.map_multioutput && node_tuple_match[index].lowest_index && node_data.multioutput_match[phase] )
+        {
+          ++multioutput_count;
+        }
+      }
+
+      st.multioutput_gates = multioutput_count;
+    }
+
+    /* create POs */
+    ntk.foreach_po( [&]( auto const& f ) {
+      if ( ntk.is_complemented( f ) )
+      {
+        res.create_po( old2new[ntk.node_to_index( ntk.get_node( f ) )][1] );
+      }
+      else if ( !ntk.is_constant( ntk.get_node( f ) ) && ntk.is_pi( ntk.get_node( f ) ) && lib_buf_id != UINT32_MAX )
+      {
+        /* create buffers for POs */
+        static uint64_t _buf = 0x2;
+        kitty::dynamic_truth_table tt_buf( 1 );
+        kitty::create_from_words( tt_buf, &_buf, &_buf + 1 );
+        const auto buf = res.create_node( { old2new[ntk.node_to_index( ntk.get_node( f ) )][0] }, tt_buf );
+        res.create_po( buf );
+        res.add_binding( res.get_node( buf ), lib_buf_id );
+      }
+      else
+      {
+        res.create_po( old2new[ntk.node_to_index( ntk.get_node( f ) )][0] );
+      }
+    } );
+
+    /* write final results */
+    st.area = area;
+    st.delay = delay;
+    if ( ps.eswp_rounds )
+      st.power = compute_switching_power();
+  }
+
+  void finalize_cover_block( cell_view<block_network>& res, block_map& old2new )
+  {
+    uint32_t multioutput_count = 0;
+
+    /* get standard cells */
+    std::vector<standard_cell> const& lib = res.get_library();
+
+    /* get translation ID from GENLIB to STD_CELL */
+    std::vector<uint32_t> genlib_to_cell( library.get_gates().size() );
+    for ( standard_cell const& cell : lib )
+    {
+      for ( gate const& g : cell.gates )
+      {
+        genlib_to_cell[g.id] = cell.id;
+      }
+    }
+
+    for ( auto const& n : topo_order )
+    {
+      auto index = ntk.node_to_index( n );
+      auto const& node_data = node_match[index];
+
+      /* add inverter at PI if needed */
+      if ( ntk.is_constant( n ) )
+      {
+        if ( node_data.best_gate[0] == nullptr && node_data.best_gate[1] == nullptr )
+          continue;
+      }
+      else if ( ntk.is_pi( n ) )
+      {
+        if ( node_data.map_refs[1] > 0 )
+        {
+          old2new[index][1] = res.create_not( old2new[n][0] );
+          res.add_cell( res.get_node( old2new[index][1] ), genlib_to_cell[lib_inv_id] );
+        }
+        continue;
+      }
+
+      /* continue if cut is not in the cover */
+      if ( !node_data.map_refs[0] && !node_data.map_refs[1] )
+        continue;
+
+      /* don't touch box */
+      if constexpr ( has_is_dont_touch_v<Ntk> )
+      {
+        if ( ntk.is_dont_touch( n ) )
+        {
+          clone_box2( res, old2new, index, genlib_to_cell );
+          continue;
+        }
+      }
+
+      unsigned phase = ( node_data.best_gate[0] != nullptr ) ? 0 : 1;
+
+      /* add used cut */
+      if ( node_data.same_match || node_data.map_refs[phase] > 0 )
+      {
+        /* create multioutput gates */
+        if ( ps.map_multioutput && node_data.multioutput_match[phase] )
+        {
+          assert( node_data.same_match == true );
+
+          if ( node_tuple_match[index].has_info && node_tuple_match[index].lowest_index )
+          {
+            ++multioutput_count;
+            create_block_for_gate( res, old2new, index, phase, genlib_to_cell );
+          }
+          continue;
+        }
+
+        create_lut_for_gate2( res, old2new, index, phase, genlib_to_cell );
+
+        /* add inverted version if used */
+        if ( node_data.same_match && node_data.map_refs[phase ^ 1] > 0 )
+        {
+          old2new[index][phase ^ 1] = res.create_not( old2new[index][phase] );
+          res.add_cell( res.get_node( old2new[index][phase ^ 1] ), genlib_to_cell[lib_inv_id] );
+        }
+      }
+
+      phase = phase ^ 1;
+      /* add the optional other match if used */
+      if ( !node_data.same_match && node_data.map_refs[phase] > 0 )
+      {
+        assert( !ps.map_multioutput || !node_data.multioutput_match[phase] );
+        create_lut_for_gate2( res, old2new, index, phase, genlib_to_cell );
+      }
+    }
+
+    /* create POs */
+    ntk.foreach_po( [&]( auto const& f ) {
+      if ( ntk.is_complemented( f ) )
+      {
+        res.create_po( old2new[ntk.node_to_index( ntk.get_node( f ) )][1] );
+      }
+      else if ( !ntk.is_constant( ntk.get_node( f ) ) && ntk.is_pi( ntk.get_node( f ) ) && lib_buf_id != UINT32_MAX )
+      {
+        /* create buffers for POs */
+        static uint64_t _buf = 0x2;
+        kitty::dynamic_truth_table tt_buf( 1 );
+        kitty::create_from_words( tt_buf, &_buf, &_buf + 1 );
+        const auto buf = res.create_node( { old2new[ntk.node_to_index( ntk.get_node( f ) )][0] }, tt_buf );
+        res.create_po( buf );
+        res.add_cell( res.get_node( buf ), genlib_to_cell[lib_buf_id] );
+      }
+      else
+      {
+        res.create_po( old2new[ntk.node_to_index( ntk.get_node( f ) )][0] );
+      }
+    } );
+
+    /* write final results */
+    st.area = area;
+    st.delay = delay;
+    st.multioutput_gates = multioutput_count;
+    if ( ps.eswp_rounds )
+      st.power = compute_switching_power();
+  }
+
+  void create_lut_for_gate( binding_view<klut_network>& res, klut_map& old2new, uint32_t index, unsigned phase )
+  {
+    auto const& node_data = node_match[index];
+    auto const& best_cut = cuts[index][node_data.best_cut[phase]];
+    auto const& gate = node_data.best_gate[phase]->root;
+
+    /* permutate and negate to obtain the matched gate truth table */
+    std::vector<signal<klut_network>> children( gate->num_vars );
+
+    auto ctr = 0u;
+    for ( auto l : best_cut )
+    {
+      if ( ctr >= gate->num_vars )
+        break;
+      children[node_data.best_gate[phase]->permutation[ctr]] = old2new[l][( node_data.phase[phase] >> ctr ) & 1];
+      ++ctr;
+    }
+
+    if ( !gate->is_super )
+    {
+      /* create the node */
+      auto f = res.create_node( children, gate->function );
+      res.add_binding( res.get_node( f ), gate->root->id );
+
+      /* add the node in the data structure */
+      old2new[index][phase] = f;
+    }
+    else
+    {
+      /* supergate, create sub-gates */
+      auto f = create_lut_for_gate_rec( res, *gate, children );
+
+      /* add the node in the data structure */
+      old2new[index][phase] = f;
+    }
+  }
+
+  signal<klut_network> create_lut_for_gate_rec( binding_view<klut_network>& res, composed_gate<NInputs> const& gate, std::vector<signal<klut_network>> const& children )
+  {
+    std::vector<signal<klut_network>> children_local( gate.fanin.size() );
+
+    auto i = 0u;
+    for ( auto const fanin : gate.fanin )
+    {
+      if ( fanin->root == nullptr )
+      {
+        /* terminal condition */
+        children_local[i] = children[fanin->id];
+      }
+      else
+      {
+        children_local[i] = create_lut_for_gate_rec( res, *fanin, children );
+      }
+      ++i;
+    }
+
+    auto f = res.create_node( children_local, gate.root->function );
+    res.add_binding( res.get_node( f ), gate.root->id );
+    return f;
+  }
+
+  void create_lut_for_gate2( cell_view<block_network>& res, block_map& old2new, uint32_t index, unsigned phase, std::vector<uint32_t> const& genlib_to_cell )
+  {
+    auto const& node_data = node_match[index];
+    auto const& best_cut = cuts[index][node_data.best_cut[phase]];
+    auto const& gate = node_data.best_gate[phase]->root;
+
+    /* permutate and negate to obtain the matched gate truth table */
+    std::vector<signal<block_network>> children( gate->num_vars );
+
+    auto ctr = 0u;
+    for ( auto l : best_cut )
+    {
+      if ( ctr >= gate->num_vars )
+        break;
+      children[node_data.best_gate[phase]->permutation[ctr]] = old2new[l][( node_data.phase[phase] >> ctr ) & 1];
+      ++ctr;
+    }
+
+    if ( !gate->is_super )
+    {
+      /* create the node */
+      auto f = res.create_node( children, gate->function );
+      res.add_cell( res.get_node( f ), genlib_to_cell.at( gate->root->id ) );
+
+      /* add the node in the data structure */
+      old2new[index][phase] = f;
+    }
+    else
+    {
+      /* supergate, create sub-gates */
+      auto f = create_lut_for_gate2_rec( res, *gate, children, genlib_to_cell );
+
+      /* add the node in the data structure */
+      old2new[index][phase] = f;
+    }
+  }
+
+  signal<block_network> create_lut_for_gate2_rec( cell_view<block_network>& res, composed_gate<NInputs> const& gate, std::vector<signal<block_network>> const& children, std::vector<uint32_t> const& genlib_to_cell )
+  {
+    std::vector<signal<block_network>> children_local( gate.fanin.size() );
+
+    auto i = 0u;
+    for ( auto const fanin : gate.fanin )
+    {
+      if ( fanin->root == nullptr )
+      {
+        /* terminal condition */
+        children_local[i] = children[fanin->id];
+      }
+      else
+      {
+        children_local[i] = create_lut_for_gate2_rec( res, *fanin, children, genlib_to_cell );
+      }
+      ++i;
+    }
+
+    auto f = res.create_node( children_local, gate.root->function );
+    res.add_cell( res.get_node( f ), genlib_to_cell.at( gate.root->id ) );
+    return f;
+  }
+
+  void create_block_for_gate( cell_view<block_network>& res, block_map& old2new, uint32_t index, unsigned phase, std::vector<uint32_t> const& genlib_to_cell )
+  {
+    std::vector<standard_cell> const& lib = res.get_library();
+    composed_gate<NInputs> const* local_gate = node_match[index].best_gate[phase]->root;
+    standard_cell const& cell = lib[genlib_to_cell.at( local_gate->root->id )];
+
+    assert( !local_gate->is_super );
+    auto const& best_cut = cuts[index][node_match[index].best_cut[phase]];
+
+    /* permutate and negate to obtain the matched gate truth table */
+    std::vector<signal<block_network>> children( cell.gates.front().num_vars );
+
+    /* output negations have already been assigned by the mapper */
+    auto ctr = 0u;
+    for ( auto l : best_cut )
+    {
+      if ( ctr >= local_gate->num_vars )
+        break;
+      children[node_match[index].best_gate[phase]->permutation[ctr]] = old2new[l][( node_match[index].phase[phase] >> ctr ) & 1];
+      ++ctr;
+    }
+
+    multi_match_t const& tuple_data = multi_node_match[node_tuple_match[index].index][0];
+    std::vector<uint32_t> outputs;
+    std::vector<kitty::dynamic_truth_table> functions;
+
+    /* re-order outputs to match the ones of the cell */
+    for ( gate const& g : cell.gates )
+    {
+      /* find the correct node */
+      for ( auto j = 0; j < max_multioutput_output_size; ++j )
+      {
+        uint32_t node_index = tuple_data[j].node_index;
+        assert( node_match[node_index].same_match );
+        uint8_t node_phase = node_match[node_index].best_gate[0] != nullptr ? 0 : 1;
+        assert( node_match[node_index].multioutput_match[node_phase] );
+
+        gate const* node_gate = node_match[node_index].best_gate[node_phase]->root->root;
+
+        /* wrong output */
+        if ( node_gate->id != g.id )
+          continue;
+
+        outputs.push_back( node_index );
+        functions.push_back( g.function );
+      }
+    }
+
+    assert( outputs.size() == cell.gates.size() );
+
+    /* create the block */
+    auto f = res.create_node( children, functions );
+    res.add_cell( res.get_node( f ), genlib_to_cell.at( local_gate->root->id ) );
+
+    for ( uint32_t s : outputs )
+    {
+      /* add inverted version if used */
+      uint8_t node_phase = node_match[s].best_gate[0] != nullptr ? 0 : 1;
+      assert( node_match[s].same_match );
+
+      /* add the node in the data structure */
+      old2new[s][node_phase] = f;
+
+      if ( node_match[s].map_refs[node_phase ^ 1] > 0 )
+      {
+        old2new[s][node_phase ^ 1] = res.create_not( f );
+        res.add_cell( res.get_node( old2new[s][node_phase ^ 1] ), genlib_to_cell.at( lib_inv_id ) );
+      }
+
+      f = res.next_output_pin( f );
+    }
+  }
+
+  void clone_box( binding_view<klut_network>& res, klut_map& old2new, uint32_t index )
+  {
+    node<Ntk> n = ntk.index_to_node( index );
+    std::vector<signal<klut_network>> children;
+
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      children.push_back( old2new[ntk.get_node( f )][ntk.is_complemented( f ) ? 1 : 0] );
+    } );
+
+    /* create the node */
+    auto const& tt = ntk.node_function( n );
+    auto f = res.create_node( children, tt );
+
+    /* add the node in the data structure */
+    old2new[index][0] = f;
+    if ( node_match[index].map_refs[1] )
+    {
+      old2new[index][1] = res.create_not( f );
+      res.add_binding( res.get_node( old2new[index][1] ), lib_inv_id );
+    }
+
+    if constexpr ( has_has_binding_v<Ntk> )
+    {
+      if ( ntk.has_binding( n ) )
+        res.add_binding( res.get_node( f ), ntk.get_binding_index( n ) );
+    }
+  }
+
+  void clone_box2( cell_view<block_network>& res, klut_map& old2new, uint32_t index, std::vector<uint32_t> const& genlib_to_cell )
+  {
+    node<Ntk> n = ntk.index_to_node( index );
+    std::vector<signal<block_network>> children;
+
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      children.push_back( old2new[ntk.get_node( f )][ntk.is_complemented( f ) ? 1 : 0] );
+    } );
+
+    /* check if multi-output */
+    std::vector<standard_cell> const& lib = res.get_library();
+    if constexpr ( has_has_binding_v<Ntk> )
+    {
+      bool is_multioutput = false;
+      if ( ntk.has_binding( n ) )
+      {
+        uint32_t cell_id = genlib_to_cell.at( ntk.get_binding_index( n ) );
+        if ( lib.at( cell_id ).gates.size() > 1 )
+          is_multioutput = true;
+      }
+
+      /* create the multioutput node (partially dangling) */
+      if ( is_multioutput )
+      {
+        standard_cell const& cell = lib.at( genlib_to_cell.at( ntk.get_binding_index( n ) ) );
+        std::vector<kitty::dynamic_truth_table> functions;
+        for ( auto const& g : cell.gates )
+        {
+          functions.push_back( g.function );
+        }
+
+        auto f = res.create_node( children, functions );
+
+        /* find and connect the correct pin */
+        for ( auto const& g : cell.gates )
+        {
+          if ( g.id == cell.id )
+            break;
+          res.next_output_pin( f );
+        }
+
+        old2new[index][0] = f;
+        res.add_cell( res.get_node( f ), cell.id );
+        if ( node_match[index].map_refs[1] )
+        {
+          old2new[index][1] = res.create_not( f );
+          res.add_cell( res.get_node( old2new[index][1] ), genlib_to_cell.at( lib_inv_id ) );
+        }
+        return;
+      }
+    }
+
+    /* create the single-output node */
+    auto const& tt = ntk.node_function( n );
+    auto f = res.create_node( children, tt );
+
+    /* add the node in the data structure */
+    old2new[index][0] = f;
+    if ( node_match[index].map_refs[1] )
+    {
+      old2new[index][1] = res.create_not( f );
+      res.add_cell( res.get_node( old2new[index][1] ), genlib_to_cell.at( lib_inv_id ) );
+    }
+
+    if constexpr ( has_has_binding_v<Ntk> )
+    {
+      if ( ntk.has_binding( n ) )
+        res.add_cell( res.get_node( f ), genlib_to_cell.at( ntk.get_binding_index( n ) ) );
+    }
+  }
+#pragma endregion
+
+#pragma region Cuts and matching utils
+  void compute_cut_data( cut_t& cut, node<Ntk> const& n )
+  {
+    cut->delay = std::numeric_limits<uint32_t>::max();
+    cut->flow = std::numeric_limits<float>::max();
+    cut->ignore = false;
+
+    if ( cut.size() > NInputs || cut.size() > 6 )
+    {
+      /* Ignore cuts too big to be mapped using the library */
+      cut->ignore = true;
+      return;
+    }
+
+    const auto tt = cut->function;
+    const kitty::static_truth_table<6> fe = kitty::extend_to<6>( tt );
+    auto fe_canon = fe;
+
+    uint16_t negations_pos = 0;
+    uint16_t negations_neg = 0;
+
+    /* match positive polarity */
+    if constexpr ( Configuration == classification_type::p_configurations )
+    {
+      auto canon = kitty::exact_n_canonization_support( fe, cut.size() );
+      fe_canon = std::get<0>( canon );
+      negations_pos = std::get<1>( canon );
+    }
+
+    auto const supergates_pos = library.get_supergates( fe_canon );
+
+    /* match negative polarity */
+    if constexpr ( Configuration == classification_type::p_configurations )
+    {
+      auto canon = kitty::exact_n_canonization_support( ~fe, cut.size() );
+      fe_canon = std::get<0>( canon );
+      negations_neg = std::get<1>( canon );
+    }
+    else
+    {
+      fe_canon = ~fe;
+    }
+
+    auto const supergates_neg = library.get_supergates( fe_canon );
+
+    if ( supergates_pos != nullptr || supergates_neg != nullptr )
+    {
+      cut->supergates = { supergates_pos, supergates_neg };
+      cut->negations = { negations_pos, negations_neg };
+    }
+    else
+    {
+      /* Ignore not matched cuts */
+      cut->ignore = true;
+      return;
+    }
+
+    /* compute cut cost based on LUT area */
+    recompute_cut_data( cut, n );
+  }
+
+  void compute_cut_data_structural( cut_t& cut, node<Ntk> const& n )
+  {
+    cut->delay = std::numeric_limits<uint32_t>::max();
+    cut->flow = std::numeric_limits<float>::max();
+    cut->ignore = false;
+
+    assert( cut.size() <= NInputs );
+
+    const auto supergates_pos = library.get_supergates_pattern( cut->pattern_index, false );
+    const auto supergates_neg = library.get_supergates_pattern( cut->pattern_index, true );
+
+    if ( supergates_pos != nullptr || supergates_neg != nullptr )
+    {
+      cut->supergates = { supergates_pos, supergates_neg };
+    }
+    else
+    {
+      /* Ignore not matched cuts */
+      cut->ignore = true;
+      return;
+    }
+
+    /* compute cut cost based on LUT area */
+    recompute_cut_data( cut, n );
+  }
+
+  void recompute_cut_data( cut_t& cut, node<Ntk> const& n )
+  {
+    /* compute cut cost based on LUT area */
+    uint32_t best_arrival = 0;
+    float best_area_flow = cut.size() > 1 ? cut.size() : 0;
+
+    for ( auto leaf : cut )
+    {
+      const auto& best_leaf_cut = cuts[leaf][0];
+      best_arrival = std::max( best_arrival, best_leaf_cut->delay );
+      best_area_flow += best_leaf_cut->flow;
+    }
+
+    cut->delay = best_arrival + ( cut.size() > 1 ) ? 1 : 0;
+    cut->flow = best_area_flow / ntk.fanout_size( n );
+  }
+
+  /* compute positions of leave indices in cut `sub` (subset) with respect to
+   * leaves in cut `sup` (super set).
+   *
+   * Example:
+   *   compute_truth_table_support( {1, 3, 6}, {0, 1, 2, 3, 6, 7} ) = {1, 3, 4}
+   */
+  void compute_truth_table_support( cut_t const& sub, cut_t const& sup, TT& tt )
+  {
+    size_t j = 0;
+    auto itp = sup.begin();
+    for ( auto i : sub )
+    {
+      itp = std::find( itp, sup.end(), i );
+      lsupport[j++] = static_cast<uint8_t>( std::distance( sup.begin(), itp ) );
+    }
+
+    /* swap variables in the truth table */
+    for ( int i = j - 1; i >= 0; --i )
+    {
+      assert( i <= lsupport[i] );
+      kitty::swap_inplace( tt, i, lsupport[i] );
+    }
+  }
+
+  void add_zero_cut( uint32_t index )
+  {
+    auto& cut = cuts[index].add_cut( &index, &index ); /* fake iterator for emptyness */
+    cut->ignore = true;
+    cut->delay = 0;
+    cut->flow = 0;
+    cut->pattern_index = 0;
+    cut->negations[0] = cut->negations[1] = 0;
+  }
+
+  void add_unit_cut( uint32_t index )
+  {
+    auto& cut = cuts[index].add_cut( &index, &index + 1 );
+
+    kitty::create_nth_var( cut->function, 0 );
+    cut->ignore = true;
+    cut->delay = 0;
+    cut->flow = 0;
+    cut->pattern_index = 1;
+    cut->negations[0] = cut->negations[1] = 0;
+  }
+
+  inline void create_structural_cut( cut_t& new_cut, std::vector<cut_t const*> const& vcuts, uint32_t new_pattern, uint32_t pattern_id1, uint32_t pattern_id2 )
+  {
+    new_cut.set_leaves( *vcuts[0] );
+    new_cut.add_leaves( vcuts[1]->begin(), vcuts[1]->end() );
+    new_cut->pattern_index = new_pattern;
+
+    /* get the polarity of the leaves of the new cut */
+    uint16_t neg_l = 0, neg_r = 0;
+    if ( ( *vcuts[0] )->pattern_index == 1 )
+    {
+      neg_r = static_cast<uint16_t>( pattern_id1 & 1 );
+    }
+    else
+    {
+      neg_r = ( *vcuts[0] )->negations[0];
+    }
+    if ( ( *vcuts[1] )->pattern_index == 1 )
+    {
+      neg_l = static_cast<uint16_t>( pattern_id2 & 1 );
+    }
+    else
+    {
+      neg_l = ( *vcuts[1] )->negations[0];
+    }
+
+    new_cut->negations[0] = ( neg_l << vcuts[0]->size() ) | neg_r;
+    new_cut->negations[1] = new_cut->negations[0];
+  }
+
+  inline bool fast_support_minimization( TT const& tt, cut_t& res )
+  {
+    uint32_t support = 0u;
+    uint32_t support_size = 0u;
+    for ( uint32_t i = 0u; i < tt.num_vars(); ++i )
+    {
+      if ( kitty::has_var( tt, i ) )
+      {
+        support |= 1u << i;
+        ++support_size;
+      }
+    }
+
+    /* has not minimized support? */
+    if ( ( support & ( support + 1u ) ) != 0u )
+    {
+      return false;
+    }
+
+    /* variables not in the support are the most significative */
+    if ( support_size != res.size() )
+    {
+      std::vector<uint32_t> leaves( res.begin(), res.begin() + support_size );
+      res.set_leaves( leaves.begin(), leaves.end() );
+    }
+
+    return true;
+  }
+
+  void compute_truth_table( uint32_t index, fanin_cut_t const& vcuts, uint32_t fanin, cut_t& res )
+  {
+    for ( uint32_t i = 0; i < fanin; ++i )
+    {
+      cut_t const* cut = vcuts[i];
+      ltruth[i] = ( *cut )->function;
+      compute_truth_table_support( *cut, res, ltruth[i] );
+    }
+
+    auto tt_res = ntk.compute( ntk.index_to_node( index ), ltruth.begin(), ltruth.begin() + fanin );
+
+    if ( ps.cut_enumeration_ps.minimize_truth_table && !fast_support_minimization( tt_res, res ) )
+    {
+      const auto support = kitty::min_base_inplace( tt_res );
+
+      std::vector<uint32_t> leaves_before( res.begin(), res.end() );
+      std::vector<uint32_t> leaves_after( support.size() );
+
+      auto it_support = support.begin();
+      auto it_leaves = leaves_after.begin();
+      while ( it_support != support.end() )
+      {
+        *it_leaves++ = leaves_before[*it_support++];
+      }
+      res.set_leaves( leaves_after.begin(), leaves_after.end() );
+    }
+
+    res->function = tt_res;
+  }
+#pragma endregion
+
+  template<bool DO_AREA>
+  inline bool compare_map( double arrival, double best_arrival, float area_flow, float best_area_flow, uint32_t size, uint32_t best_size )
+  {
+    if constexpr ( DO_AREA )
+    {
+      if ( area_flow < best_area_flow - epsilon )
+      {
+        return true;
+      }
+      else if ( area_flow > best_area_flow + epsilon )
+      {
+        return false;
+      }
+      else if ( arrival < best_arrival - epsilon )
+      {
+        return true;
+      }
+      else if ( arrival > best_arrival + epsilon )
+      {
+        return false;
+      }
+      return size < best_size;
+    }
+    else
+    {
+      if ( arrival < best_arrival - epsilon )
+      {
+        return true;
+      }
+      else if ( arrival > best_arrival + epsilon )
+      {
+        return false;
+      }
+      else if ( area_flow < best_area_flow - epsilon )
+      {
+        return true;
+      }
+      else if ( area_flow > best_area_flow + epsilon )
+      {
+        return false;
+      }
+      return size < best_size;
+    }
+  }
+
+  double compute_switching_power()
+  {
+    double power = 0.0f;
+
+    for ( auto const& n : topo_order )
+    {
+      const auto index = ntk.node_to_index( n );
+      auto& node_data = node_match[index];
+
+      if ( ntk.is_constant( n ) )
+      {
+        if ( node_data.best_gate[0] == nullptr && node_data.best_gate[1] == nullptr )
+          continue;
+      }
+      else if ( ntk.is_pi( n ) )
+      {
+        if ( node_data.map_refs[1] > 0 )
+          power += switch_activity[ntk.node_to_index( n )];
+        continue;
+      }
+
+      /* continue if cut is not in the cover */
+      if ( !node_data.map_refs[0] && !node_data.map_refs[1] )
+        continue;
+
+      unsigned phase = ( node_data.best_gate[0] != nullptr ) ? 0 : 1;
+
+      if ( node_data.same_match || node_data.map_refs[phase] > 0 )
+      {
+        power += switch_activity[ntk.node_to_index( n )];
+
+        if ( node_data.same_match && node_data.map_refs[phase ^ 1] > 0 )
+          power += switch_activity[ntk.node_to_index( n )];
+      }
+
+      phase = phase ^ 1;
+      if ( !node_data.same_match && node_data.map_refs[phase] > 0 )
+      {
+        power += switch_activity[ntk.node_to_index( n )];
+      }
+    }
+
+    return power;
+  }
+
+#pragma region multioutput
+  /* Experimental code */
+  void compute_multioutput_match()
+  {
+    stopwatch t( st.time_multioutput );
+
+    if ( library.num_multioutput_gates() == 0 )
+      return;
+
+    /* compute cuts: first simple method without proper matching */
+    cut_enumeration_params multi_ps;
+    multi_ps.minimize_truth_table = false;
+    multi_cuts_t multi_cuts = fast_cut_enumeration<Ntk, max_multioutput_cut_size, true, cut_enumeration_emap_multi_cut>( ntk, multi_ps );
+
+    /* cuts leaves classes */
+    multi_hash_t multi_cuts_classes;
+    multi_cuts_classes.reserve( 2000 );
+
+    /* Multi-output matching */
+    multi_enumerate_matches( multi_cuts, multi_cuts_classes );
+
+    multi_single_matches_t multi_node_match_local;
+    multi_node_match_local.reserve( multi_cuts_classes.size() );
+
+    multi_compute_matches( multi_cuts, multi_cuts_classes, multi_node_match_local );
+
+    if ( ps.remove_overlapping_multicuts )
+      multi_filter_and_match<true>( multi_cuts, multi_node_match_local ); /* it also adds the tuple for node mapping */
+    else
+      multi_filter_and_match<false>( multi_cuts, multi_node_match_local ); /* it also adds the tuple for node mapping */
+  }
+
+  void multi_init_topo_order()
+  {
+    /* create and initialize a choice view to store the tuples */
+    choice_view<Ntk> choice_ntk{ ntk };
+    multi_add_choices( choice_ntk );
+
+    ntk.incr_trav_id();
+    ntk.incr_trav_id();
+
+    /* add constants and CIs */
+    const auto c0 = ntk.get_node( ntk.get_constant( false ) );
+    topo_order.push_back( c0 );
+    ntk.set_visited( c0, ntk.trav_id() );
+
+    if ( const auto c1 = ntk.get_node( ntk.get_constant( true ) ); ntk.visited( c1 ) != ntk.trav_id() )
+    {
+      topo_order.push_back( c1 );
+      ntk.set_visited( c1, ntk.trav_id() );
+    }
+
+    ntk.foreach_ci( [&]( auto const& n ) {
+      if ( ntk.visited( n ) != ntk.trav_id() )
+      {
+        topo_order.push_back( n );
+        ntk.set_visited( n, ntk.trav_id() );
+      }
+    } );
+
+    /* sort topologically */
+    ntk.foreach_co( [&]( auto const& f ) {
+      if ( ntk.visited( ntk.get_node( f ) ) == ntk.trav_id() )
+        return;
+      multi_topo_sort_rec( choice_ntk, ntk.get_node( f ) );
+    } );
+  }
+
+  /* Experimental code resticted to only half adders and full adders */
+  void multi_enumerate_matches( multi_cuts_t const& multi_cuts, multi_hash_t& multi_cuts_classes )
+  {
+    static_assert( max_multioutput_cut_size > 1 && max_multioutput_cut_size < 7 );
+
+    uint32_t counter = 0;
+    multi_leaves_set_t leaves = { 0 };
+
+    ntk.foreach_gate( [&]( auto const& n ) {
+      uint32_t cut_index = 0;
+      for ( auto& cut : multi_cuts.cuts( ntk.node_to_index( n ) ) )
+      {
+        kitty::static_truth_table<max_multioutput_cut_size> tt = multi_cuts.truth_table( *cut );
+        /* reduce support for matching ID */
+        uint64_t tt_id = ( cut->size() < 3 ) ? ( tt._bits & 0xF ) : tt._bits;
+        uint64_t id = library.get_multi_function_id( tt_id );
+
+        if ( !id )
+        {
+          ++cut_index;
+          continue;
+        }
+
+        ( *cut )->data.id = id;
+
+        multi_match_data data;
+        data.node_index = ntk.node_to_index( n );
+        data.cut_index = cut_index;
+        leaves[2] = 0;
+        uint32_t i = 0;
+        for ( auto l : *cut )
+          leaves[i++] = l;
+
+        /* add to hash table */
+        multi_cuts_classes[leaves].push_back( data );
+
+        ++cut_index;
+      }
+    } );
+  }
+
+  /* Experimental code */
+  void multi_compute_matches( multi_cuts_t const& multi_cuts, multi_hash_t& multi_cuts_classes, multi_single_matches_t& multi_node_match_local )
+  {
+    ntk.clear_values();
+
+    /* copy set and sort by gate size: improve, too slow */
+    std::vector<std::pair<multi_leaves_set_t, multi_output_set_t>> class_list;
+    class_list.reserve( multi_cuts_classes.size() );
+    for ( auto& it : multi_cuts_classes )
+    {
+      /* insert multiple occurring cuts */
+      if ( it.second.size() > 1 )
+        class_list.push_back( it );
+    }
+
+    std::stable_sort( class_list.begin(), class_list.end(), [&]( auto const& a, auto const& b ) {
+      return a.first[2] > b.first[2];
+    } );
+
+    /* combine and match: specific code for 2-output cells */
+    for ( auto it : class_list )
+    {
+      for ( uint32_t i = 0; i < it.second.size() - 1; ++i )
+      {
+        multi_match_data data_i = it.second[i];
+        uint32_t index_i = data_i.node_index;
+        uint32_t cut_index_i = data_i.cut_index;
+        auto const& cut_i = multi_cuts.cuts( index_i )[cut_index_i];
+
+        for ( uint32_t j = i + 1; j < it.second.size(); ++j )
+        {
+          multi_match_data data_j = it.second[j];
+          uint32_t index_j = data_j.node_index;
+          uint32_t cut_index_j = data_j.cut_index;
+          auto const& cut_j = multi_cuts.cuts( index_j )[cut_index_j];
+
+          /* not compatible -> TODO: change */
+          if ( cut_i->data.id == cut_j->data.id )
+            continue;
+
+          /* check compatibility */
+          if ( !multi_check_partally_dangling( index_i, index_j, cut_i ) )
+            continue;
+
+          multi_node_match_local.push_back( { data_i, data_j } );
+        }
+      }
+    }
+  }
+
+  /* Experimental code */
+  template<bool OverlapFilter>
+  void multi_filter_and_match( multi_cuts_t const& multi_cuts, multi_single_matches_t const& multi_node_match_local )
+  {
+    multi_cut_set.reserve( multi_node_match_local.size() );
+    multi_node_match.reserve( multi_node_match_local.size() );
+
+    ntk.incr_trav_id();
+
+    for ( auto& pair : multi_node_match_local )
+    {
+      uint32_t index1 = pair[0].node_index;
+      uint32_t index2 = pair[1].node_index;
+      uint32_t cut_index1 = pair[0].cut_index;
+      uint32_t cut_index2 = pair[1].cut_index;
+      multi_cut_t const& cut1 = multi_cuts.cuts( index1 )[cut_index1];
+      multi_cut_t const& cut2 = multi_cuts.cuts( index2 )[cut_index2];
+
+      assert( index1 < index2 );
+
+      /* remove incompatible multi-output cuts */
+      bool is_new = true;
+      uint32_t insertion_index = multi_node_match.size();
+      if constexpr ( OverlapFilter )
+      {
+        if ( multi_gate_check_overlapping( index1, index2, cut1 ) )
+          continue;
+      }
+      else
+      {
+        if ( multi_gate_check_incompatible( index1, index2, is_new, insertion_index ) )
+          continue;
+        // if ( is_new && multi_gate_check_overlapping( index1, index2, cut1 ) )
+        //   continue;
+      }
+
+      /* copy cuts */
+      cut_t new_cut1, new_cut2;
+      new_cut1.set_leaves( cut1.begin(), cut1.end() );
+      new_cut2.set_leaves( cut2.begin(), cut2.end() );
+      new_cut1->function = kitty::extend_to<6>( multi_cuts.truth_table( cut1 ) );
+      new_cut2->function = kitty::extend_to<6>( multi_cuts.truth_table( cut2 ) );
+
+      /* Multi-output Boolean matching, continue if no match */
+      std::array<cut_t, max_multioutput_output_size> cut_pair = { new_cut1, new_cut2 };
+      if ( !multi_compute_cut_data( cut_pair ) )
+        continue;
+
+      /* mark multioutput gate */
+      if constexpr ( OverlapFilter )
+      {
+        multi_gate_mark_visited( index1, index2, cut1 );
+        node_tuple_match[index1].has_info = 1;
+        node_tuple_match[index1].lowest_index = 1;
+        node_tuple_match[index1].index = multi_node_match.size();
+        node_tuple_match[index2].has_info = 1;
+        node_tuple_match[index2].highest_index = 1;
+        node_tuple_match[index2].index = multi_node_match.size();
+      }
+      else
+      {
+        // multi_gate_mark_visited( index1, index2, cut1 );
+        multi_gate_mark_compatibility( index1, index2, insertion_index );
+      }
+
+      /* add cut */
+      multi_cut_set.push_back( cut_pair );
+
+      /* re-index data */
+      multi_match_data new_data1, new_data2;
+      new_data1.node_index = index1;
+      new_data1.cut_index = multi_cut_set.size() - 1;
+      new_data2.node_index = index2;
+      new_data2.cut_index = multi_cut_set.size() - 1;
+      multi_match_t p = { new_data1, new_data2 };
+
+      /* add cuts to the correct bucket */
+      if ( is_new )
+      {
+        multi_node_match.push_back( { p } );
+      }
+      else
+      {
+        multi_node_match[insertion_index].push_back( p );
+      }
+    }
+  }
+
+  bool multi_compute_cut_data( std::array<cut_t, max_multioutput_output_size>& cut_tuple )
+  {
+    std::array<kitty::static_truth_table<6>, max_multioutput_output_size> tts;
+    std::array<kitty::static_truth_table<6>, max_multioutput_output_size> tts_order;
+    std::array<size_t, max_multioutput_output_size> order = {};
+    std::array<uint16_t, max_multioutput_output_size> phase = { 0 };
+    std::array<uint8_t, max_multioutput_output_size> phase_order;
+
+    std::iota( order.begin(), order.end(), 0 );
+
+    for ( auto i = 0; i < max_multioutput_output_size; ++i )
+    {
+      tts[i] = kitty::extend_to<6>( cut_tuple[i]->function );
+      if ( ( tts[i]._bits & 1 ) == 1 )
+      {
+        tts[i] = ~tts[i];
+        phase[i] = 1;
+      }
+    }
+
+    std::stable_sort( order.begin(), order.end(), [&]( size_t a, size_t b ) {
+      return tts[a] < tts[b];
+    } );
+
+    std::transform( order.begin(), order.end(), tts_order.begin(), [&]( size_t a ) {
+      return tts[a];
+    } );
+
+    std::transform( order.begin(), order.end(), phase_order.begin(), [&]( uint8_t a ) {
+      return phase[a];
+    } );
+
+    auto const multigates_match = library.get_multi_supergates( tts_order );
+
+    /* Ignore not matched cuts */
+    if ( multigates_match == nullptr )
+      return false;
+
+    /* add cut matches */
+    for ( auto i = 0; i < max_multioutput_output_size; ++i )
+    {
+      cut_tuple[order[i]]->supergates[0] = nullptr;
+      cut_tuple[order[i]]->supergates[1] = nullptr;
+      cut_tuple[order[i]]->ignore = false;
+      std::vector<supergate<NInputs>> const* multigate = &( ( *multigates_match )[i] );
+      cut_tuple[order[i]]->supergates[phase_order[i]] = multigate;
+    }
+
+    return true;
+  }
+
+  inline bool multi_check_partally_dangling( uint32_t index1, uint32_t index2, multi_cut_t const& cut1 )
+  {
+    bool valid = true;
+
+    /* check containment of cut1 in cut2 and viceversa */
+    if ( index1 > index2 )
+    {
+      std::swap( index1, index2 );
+    }
+
+    ntk.foreach_fanin( ntk.index_to_node( index2 ), [&]( auto const& f ) {
+      auto g = ntk.get_node( f );
+      if ( ntk.node_to_index( g ) == index1 && ntk.fanout_size( g ) == 1 )
+      {
+        valid = false;
+      }
+      return valid;
+    } );
+
+    if ( !valid )
+      return false;
+
+    if ( !is_contained_mffc( ntk.index_to_node( index2 ), ntk.index_to_node( index1 ), cut1 ) )
+      return false;
+
+    return true;
+  }
+
+  inline bool multi_gate_check_overlapping( uint32_t index1, uint32_t index2, multi_cut_t const& cut )
+  {
+    bool contained = false;
+
+    /* mark leaves */
+    for ( auto leaf : cut )
+    {
+      ntk.incr_value( ntk.index_to_node( leaf ) );
+    }
+
+    contained = multi_mark_visited_rec<false>( ntk.index_to_node( index1 ) );
+    contained |= multi_mark_visited_rec<false>( ntk.index_to_node( index2 ) );
+
+    /* unmark leaves */
+    for ( auto leaf : cut )
+    {
+      ntk.decr_value( ntk.index_to_node( leaf ) );
+    }
+
+    return contained;
+  }
+
+  inline bool multi_gate_check_incompatible( uint32_t index1, uint32_t index2, bool& is_new, uint32_t& data_index )
+  {
+    /* check cut assigned cut outputs, specialized code for 2 outputs */
+    if ( !node_tuple_match[index1].has_info && !node_tuple_match[index2].has_info )
+      return false;
+
+    if ( node_tuple_match[index1].has_info && node_tuple_match[index2].has_info )
+    {
+      uint32_t current_assignment = node_tuple_match[index1].index;
+      if ( current_assignment != node_tuple_match[index2].index )
+        return true;
+      is_new = false;
+      data_index = current_assignment;
+      return false;
+    }
+
+    return true;
+  }
+
+  inline void multi_gate_mark_compatibility( uint32_t index1, uint32_t index2, uint32_t mark_value )
+  {
+    node_tuple_match[index1].has_info = 1;
+    node_tuple_match[index1].lowest_index = 1;
+    node_tuple_match[index1].index = mark_value;
+    node_tuple_match[index2].has_info = 1;
+    node_tuple_match[index2].highest_index = 1;
+    node_tuple_match[index2].index = mark_value;
+  }
+
+  inline void multi_gate_mark_visited( uint32_t index1, uint32_t index2, multi_cut_t const& cut )
+  {
+    /* mark leaves */
+    for ( auto leaf : cut )
+    {
+      ntk.incr_value( ntk.index_to_node( leaf ) );
+    }
+
+    /* mark */
+    multi_mark_visited_rec<true>( ntk.index_to_node( index1 ) );
+    multi_mark_visited_rec<true>( ntk.index_to_node( index2 ) );
+
+    /* unmark leaves */
+    for ( auto leaf : cut )
+    {
+      ntk.decr_value( ntk.index_to_node( leaf ) );
+    }
+  }
+
+  template<bool MARK>
+  bool multi_mark_visited_rec( node<Ntk> const& n )
+  {
+    /* leaf */
+    if ( ntk.value( n ) )
+      return false;
+
+    /* already visited */
+    if ( ntk.visited( n ) == ntk.trav_id() )
+      return true;
+
+    if constexpr ( MARK )
+    {
+      ntk.set_visited( n, ntk.trav_id() );
+    }
+
+    bool contained = false;
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      contained |= multi_mark_visited_rec<MARK>( ntk.get_node( f ) );
+
+      if constexpr ( !MARK )
+      {
+        if ( contained )
+          return false;
+      }
+
+      return true;
+    } );
+
+    return contained;
+  }
+
+  bool is_contained_mffc( node<Ntk> root, node<Ntk> n, multi_cut_t const& cut )
+  {
+    /* reference cut leaves */
+    for ( auto leaf : cut )
+    {
+      ntk.incr_value( ntk.index_to_node( leaf ) );
+    }
+
+    bool valid = true;
+    tmp_visited.clear();
+    dereference_node_rec( root );
+
+    if ( ntk.fanout_size( n ) == 0 )
+      valid = false;
+
+    for ( uint64_t g : tmp_visited )
+      ntk.incr_fanout_size( ntk.index_to_node( g ) );
+
+    /* dereference leaves */
+    for ( auto leaf : cut )
+    {
+      ntk.decr_value( ntk.index_to_node( leaf ) );
+    }
+
+    return valid;
+  }
+
+  void dereference_node_rec( node<Ntk> const& n )
+  {
+    /* leaf */
+    if ( ntk.value( n ) )
+      return;
+
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      node<Ntk> g = ntk.get_node( f );
+      if ( ntk.decr_fanout_size( g ) == 0 )
+      {
+        dereference_node_rec( g );
+      }
+      tmp_visited.push_back( ntk.node_to_index( g ) );
+    } );
+  }
+
+  void multi_add_choices( choice_view<Ntk>& choice_ntk )
+  {
+    for ( auto& field : multi_node_match )
+    {
+      auto& pair = field.front();
+      uint32_t index1 = pair[0].node_index;
+      uint32_t index2 = pair[1].node_index;
+      uint32_t cut_index1 = pair[0].cut_index;
+      cut_t const& cut = multi_cut_set[cut_index1][0];
+
+      /* don't add choice if in TFI, set TFI bit */
+      if ( multi_is_in_tfi( ntk.index_to_node( index2 ), ntk.index_to_node( index1 ), cut ) )
+      {
+        /* if there is a path of length > 1 linking node 1 and 2, save as TFI node */
+        uint32_t in_tfi = multi_is_in_direct_tfi( ntk.index_to_node( index2 ), ntk.index_to_node( index1 ) ) ? 0 : 1;
+        for ( auto& match : field )
+          match[0].in_tfi = in_tfi;
+        /* add a TFI dependency */
+        ntk.set_value( ntk.index_to_node( index1 ), index2 );
+        // multi_set_tfi_dependency( ntk.index_to_node( index2 ), ntk.index_to_node( index1 ), cut );
+        continue;
+      }
+
+      choice_ntk.add_choice( ntk.index_to_node( index1 ), ntk.index_to_node( index2 ) );
+
+      assert( choice_ntk.count_choices( ntk.index_to_node( index1 ) ) == 2 );
+    }
+  }
+
+  bool multi_topo_sort_rec( choice_view<Ntk>& choice_ntk, node<Ntk> const& n )
+  {
+    /* is permanently marked? */
+    if ( ntk.visited( n ) == ntk.trav_id() )
+      return true;
+
+    /* loop detected: backtrack to remove the cause */
+    if ( ntk.visited( n ) == ntk.trav_id() - 1 )
+      return false;
+
+    /* get the representative (smallest index) */
+    node<Ntk> repr = choice_ntk.get_choice_representative( n );
+
+    /* loop detected: backtrack to remove the cause */
+    if ( ntk.visited( repr ) == ntk.trav_id() - 1 )
+      return false;
+
+    /* solve the TFI dependency first */
+    node<Ntk> dependency_node = ntk.index_to_node( ntk.value( n ) );
+    if ( dependency_node > 0 && ntk.visited( dependency_node ) != ntk.trav_id() - 1 )
+    {
+      if ( !multi_topo_sort_rec( choice_ntk, dependency_node ) )
+        return false;
+      assert( ntk.visited( n ) == ntk.trav_id() );
+      return true;
+    }
+
+    /* for all the choices */
+    uint32_t i = 0;
+    bool check = true;
+    choice_ntk.foreach_choice( repr, [&]( auto const& g ) {
+      /* ensure that the node is not visited or temporarily marked */
+      assert( ntk.visited( g ) != ntk.trav_id() );
+      assert( ntk.visited( g ) != ntk.trav_id() - 1 );
+
+      /* mark node temporarily */
+      ntk.set_visited( g, ntk.trav_id() - 1 );
+
+      /* mark children */
+      ntk.foreach_fanin( g, [&]( auto const& f ) {
+        check = multi_topo_sort_rec( choice_ntk, ntk.get_node( f ) );
+        return check;
+      } );
+
+      /* cycle detected: backtrack to the last choice jump */
+      if ( !check )
+      {
+        /* revert visited */
+        ntk.set_visited( g, ntk.trav_id() - 2 );
+        if ( i > 0 && n == repr )
+        {
+          /* fix cycle: remove multi-output match */
+          choice_ntk.foreach_choice( repr, [&]( auto const& p ) {
+            node_tuple_match[ntk.node_to_index( p )].data = 0;
+            return true;
+          } );
+          choice_ntk.remove_choice( g );
+          check = true;
+        }
+        return false;
+      }
+
+      ++i;
+      return true;
+    } );
+
+    if ( !check )
+    {
+      return false;
+    }
+
+    choice_ntk.foreach_choice( repr, [&]( auto const& g ) {
+      /* ensure that the node is not visited */
+      assert( ntk.visited( g ) != ntk.trav_id() );
+
+      /* mark node n permanently */
+      ntk.set_visited( g, ntk.trav_id() );
+
+      /* visit node */
+      topo_order.push_back( g );
+
+      return true;
+    } );
+
+    return true;
+  }
+
+  inline bool multi_is_in_tfi( node<Ntk> const& root, node<Ntk> const& n, cut_t const& cut )
+  {
+    /* reference cut leaves */
+    for ( auto leaf : cut )
+    {
+      ntk.incr_value( ntk.index_to_node( leaf ) );
+    }
+
+    ntk.incr_trav_id();
+    multi_mark_visited_rec<true>( root );
+    bool contained = ntk.visited( n ) == ntk.trav_id();
+
+    /* dereference leaves */
+    for ( auto leaf : cut )
+    {
+      ntk.decr_value( ntk.index_to_node( leaf ) );
+    }
+
+    return contained;
+  }
+
+  inline bool multi_is_in_direct_tfi( node<Ntk> const& root, node<Ntk> const& n )
+  {
+    bool contained = false;
+
+    ntk.foreach_fanin( root, [&]( auto const& f ) {
+      if ( ntk.get_node( f ) == n )
+        contained = true;
+    } );
+
+    return contained;
+  }
+
+  inline void multi_set_tfi_dependency( node<Ntk> const& root, node<Ntk> const& n, cut_t const& cut )
+  {
+    /* reference cut leaves */
+    for ( auto leaf : cut )
+    {
+      ntk.incr_value( ntk.index_to_node( leaf ) );
+    }
+
+    ntk.incr_trav_id();
+
+    /* add a TFI dependencies */
+    ntk.set_value( n, ntk.node_to_index( root ) );
+    ntk.set_visited( n, ntk.trav_id() );
+    multi_set_tfi_dependency_rec( root, ntk.node_to_index( root ) );
+
+    /* reset root's dependency info */
+    ntk.set_value( root, 0 );
+
+    /* dereference leaves */
+    for ( auto leaf : cut )
+    {
+      ntk.decr_value( ntk.index_to_node( leaf ) );
+    }
+  }
+
+  void multi_set_tfi_dependency_rec( node<Ntk> const& n, uint32_t const dependency_info )
+  {
+    /* leaf */
+    if ( ntk.value( n ) )
+      return;
+
+    /* already visited */
+    if ( ntk.visited( n ) == ntk.trav_id() )
+      return;
+
+    ntk.set_visited( n, ntk.trav_id() );
+    ntk.set_value( n, dependency_info );
+
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      multi_set_tfi_dependency_rec( ntk.get_node( f ), dependency_info );
+    } );
+  }
+#pragma endregion
+
+private:
+  Ntk const& ntk;
+  tech_library<NInputs, Configuration> const& library;
+  emap_params const& ps;
+  emap_stats& st;
+
+  uint32_t iteration{ 0 }; /* current mapping iteration */
+  double delay{ 0.0f };    /* current delay of the mapping */
+  double area{ 0.0f };     /* current area of the mapping */
+  uint32_t inv{ 0 };       /* current inverter count */
+
+  /* lib inverter info */
+  float lib_inv_area;
+  float lib_inv_delay;
+  uint32_t lib_inv_id;
+
+  /* lib buffer info */
+  float lib_buf_area;
+  float lib_buf_delay;
+  uint32_t lib_buf_id;
+
+  std::vector<node<Ntk>> topo_order;
+  node_match_t node_match;
+  std::vector<multioutput_info> node_tuple_match;
+  std::vector<float> switch_activity;
+  std::vector<uint64_t> tmp_visited;
+
+  /* cut computation */
+  std::vector<cut_set_t> cuts; /* compressed representation of cuts */
+  cut_merge_t lcuts;           /* cut merger container */
+  cut_set_t temp_cuts;         /* temporary cut set container */
+  truth_compute_t ltruth;      /* truth table merger container */
+  support_t lsupport;          /* support merger container */
+  uint32_t cuts_total{ 0 };    /* current computed cuts */
+
+  /* multi-output matching */
+  multi_cut_set_t multi_cut_set;    /* set of multi-output cuts */
+  multi_matches_t multi_node_match; /* matched multi-output gates */
+
+  time_point time_begin;
+};
+
+} /* namespace detail */
+
+/*! \brief Technology mapping.
+ *
+ * This function implements a technology mapping algorithm.
+ *
+ * The function takes the size of the cuts in the template parameter `CutSize`.
+ *
+ * The function returns a block network that supports multi-output cells.
+ *
+ * The novelties of this mapper are contained in 2 publications:
+ * - A. Tempia Calvino and G. De Micheli, "Technology Mapping Using Multi-Output Library Cells," ICCAD, 2023.
+ * - G. Radi, A. Tempia Calvino, and G. De Micheli, "In Medio Stat Virtus: Combining Boolean and Pattern Matching," ASP-DAC, 2024.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `is_pi`
+ * - `is_constant`
+ * - `node_to_index`
+ * - `index_to_node`
+ * - `get_node`
+ * - `foreach_po`
+ * - `foreach_node`
+ * - `fanout_size`
+ *
+ * \param ntk Network
+ * \param library Technology library
+ * \param ps Mapping params
+ * \param pst Mapping statistics
+ *
+ */
+template<unsigned CutSize = 6u, class Ntk, unsigned NInputs, classification_type Configuration>
+cell_view<block_network> emap( Ntk const& ntk, tech_library<NInputs, Configuration> const& library, emap_params const& ps = {}, emap_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+
+  emap_stats st;
+  detail::emap_impl<Ntk, CutSize, NInputs, Configuration> p( ntk, library, ps, st );
+  auto res = p.run_block();
+
+  if ( ps.verbose && !st.mapping_error )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+  return res;
+}
+
+/*! \brief Technology mapping.
+ *
+ * This function implements a technology mapping algorithm.
+ *
+ * The function takes the size of the cuts in the template parameter `CutSize`.
+ *
+ * The function returns a k-LUT network. Each LUT abstacts a gate of the technology library.
+ *
+ * The novelties of this mapper are contained in 2 publications:
+ * - A. Tempia Calvino and G. De Micheli, "Technology Mapping Using Multi-Output Library Cells," ICCAD, 2023.
+ * - G. Radi, A. Tempia Calvino, and G. De Micheli, "In Medio Stat Virtus: Combining Boolean and Pattern Matching," ASP-DAC, 2024.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `is_pi`
+ * - `is_constant`
+ * - `node_to_index`
+ * - `index_to_node`
+ * - `get_node`
+ * - `foreach_po`
+ * - `foreach_node`
+ * - `fanout_size`
+ *
+ * \param ntk Network
+ * \param library Technology library
+ * \param ps Mapping params
+ * \param pst Mapping statistics
+ *
+ */
+template<unsigned CutSize = 6u, class Ntk, unsigned NInputs, classification_type Configuration>
+binding_view<klut_network> emap_klut( Ntk const& ntk, tech_library<NInputs, Configuration> const& library, emap_params const& ps = {}, emap_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+
+  emap_stats st;
+  detail::emap_impl<Ntk, CutSize, NInputs, Configuration> p( ntk, library, ps, st );
+  auto res = p.run_klut();
+
+  if ( ps.verbose && !st.mapping_error )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+  return res;
+}
+
+/*! \brief Technology node mapping.
+ *
+ * This function implements a simple technology mapping algorithm.
+ * The algorithm maps each node to the best implementation in the technology library.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `is_pi`
+ * - `is_constant`
+ * - `node_to_index`
+ * - `index_to_node`
+ * - `get_node`
+ * - `foreach_po`
+ * - `foreach_node`
+ * - `fanout_size`
+ * - `has_binding`
+ *
+ * \param ntk Network
+ * \param library Technology library
+ * \param ps Mapping params
+ * \param pst Mapping statistics
+ *
+ */
+template<unsigned CutSize = 6u, class Ntk, unsigned NInputs, classification_type Configuration>
+binding_view<klut_network> emap_node_map( Ntk const& ntk, tech_library<NInputs, Configuration> const& library, emap_params const& ps = {}, emap_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_has_binding_v<Ntk>, "Ntk does not implement the has_binding method" );
+
+  emap_stats st;
+  detail::emap_impl<Ntk, CutSize, NInputs, Configuration> p( ntk, library, ps, st );
+  auto res = p.run_node_map();
+
+  if ( ps.verbose && !st.mapping_error )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+  return res;
+}
+
+/*! \brief Technology node mapping.
+ *
+ * This function implements a simple technology mapping algorithm.
+ * The algorithm maps each node to the first implementation in the technology library.
+ *
+ * The input must be a binding_view with the gates correctly loaded.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `is_pi`
+ * - `is_constant`
+ * - `node_to_index`
+ * - `index_to_node`
+ * - `get_node`
+ * - `foreach_po`
+ * - `foreach_node`
+ * - `fanout_size`
+ * - `has_binding`
+ *
+ * \param ntk Network
+ *
+ */
+template<class Ntk>
+void emap_load_mapping( Ntk& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_has_binding_v<Ntk>, "Ntk does not implement the has_binding method" );
+
+  /* build the library map */
+  using lib_t = std::unordered_map<kitty::dynamic_truth_table, uint32_t, kitty::hash<kitty::dynamic_truth_table>>;
+  lib_t tt_to_gate;
+
+  for ( auto const& g : ntk.get_library() )
+  {
+    tt_to_gate[g.function] = g.id;
+  }
+
+  ntk.foreach_gate( [&]( auto const& n ) {
+    if ( auto it = tt_to_gate.find( ntk.node_function( n ) ); it != tt_to_gate.end() )
+    {
+      ntk.add_binding( n, it->second );
+    }
+    else
+    {
+      std::cout << fmt::format( "[e] node mapping for node {} failed: no match in the tech library\n", ntk.node_to_index( n ) );
+    }
+  } );
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/equivalence_checking.hpp b/include/mockturtle/algorithms/equivalence_checking.hpp
new file mode 100644
index 0000000..686cbfc
--- /dev/null
+++ b/include/mockturtle/algorithms/equivalence_checking.hpp
@@ -0,0 +1,325 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file equivalence_checking.hpp
+  \brief Combinational equivalence checking
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <iostream>
+#include <vector>
+
+#include "cleanup.hpp"
+#include "functional_reduction.hpp"
+#include "../traits.hpp"
+#include "../utils/include/percy.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../networks/klut.hpp"
+#include "cnf.hpp"
+
+#include <bill/sat/interface/common.hpp>
+#include <bill/sat/interface/abc_bsat2.hpp>
+
+#include <fmt/format.h>
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for equivalence_checking.
+ *
+ * The data structure `equivalence_checking_params` holds configurable
+ * parameters with default arguments for `equivalence_checking`.
+ */
+struct equivalence_checking_params
+{
+  /*! \brief Conflict limit for SAT solver.
+   *
+   * The default limit is 0, which means the number of conflicts is not used
+   * as a resource limit.
+   */
+  uint32_t conflict_limit{ 0u };
+
+  /*! \brief Whether to apply functional reduction before SAT solving. */
+  bool functional_reduction{ true };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+};
+
+/*! \brief Statistics for equivalence_checking.
+ *
+ * The data structure `equivalence_checking_stats` provides data collected by
+ * running `equivalence_checking`.
+ */
+struct equivalence_checking_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{};
+
+  /*! \brief Counter-example, in case miter is not equivalent. */
+  std::vector<bool> counter_example;
+
+  void report() const
+  {
+    if ( counter_example.size() > 0 )
+    {
+      std::cout << "[i] Networks are not equivalent under input assignment: ";
+      for ( auto i = 0u; i < counter_example.size(); ++i )
+        std::cout << "pi" << i << "=" << counter_example[i] << " ";
+      std::cout << "\n";
+    }
+
+    std::cout << fmt::format( "[i] total time = {:>5.2f} secs\n", to_seconds( time_total ) );
+  }
+};
+
+namespace detail
+{
+
+template<class Ntk>
+class equivalence_checking_impl
+{
+public:
+  equivalence_checking_impl( Ntk const& miter, equivalence_checking_params const& ps, equivalence_checking_stats& st )
+      : miter_( miter ),
+        ps_( ps ),
+        st_( st )
+  {
+  }
+
+  std::optional<bool> run()
+  {
+    stopwatch<> t( st_.time_total );
+
+    percy::bsat_wrapper solver;
+    int output;
+
+    if ( ps_.functional_reduction )
+    {
+      Ntk opt = miter_.clone();
+      if constexpr ( !std::is_same_v<typename Ntk::base_type, klut_network> )
+      {
+        functional_reduction( opt );
+        opt = cleanup_dangling( opt );
+      }
+
+      if ( opt.num_gates() == 0 )
+      {
+        return opt.po_at( 0 ) == opt.get_constant( false );
+      }
+
+      output = generate_cnf( opt, [&]( auto const& clause ) {
+        solver.add_clause( clause );
+      } )[0];
+    }
+    else
+    {
+      output = generate_cnf( miter_, [&]( auto const& clause ) {
+        solver.add_clause( clause );
+      } )[0];
+    }
+
+    const auto res = solver.solve( &output, &output + 1, ps_.conflict_limit );
+
+    switch ( res )
+    {
+    default:
+      return std::nullopt;
+    case percy::synth_result::success:
+    {
+      st_.counter_example.clear();
+      for ( auto i = 1u; i <= miter_.num_pis(); ++i )
+      {
+        st_.counter_example.push_back( solver.var_value( i ) );
+      }
+      return false;
+    }
+    case percy::synth_result::failure:
+      return true;
+    }
+  }
+
+private:
+  Ntk const& miter_;
+  equivalence_checking_params const& ps_;
+  equivalence_checking_stats& st_;
+};
+
+template<class Ntk, bill::solvers Solver = bill::solvers::bsat2>
+class equivalence_checking_impl_bill
+{
+public:
+  equivalence_checking_impl_bill( Ntk const& miter, equivalence_checking_params const& ps, equivalence_checking_stats& st )
+      : miter_( miter ),
+        ps_( ps ),
+        st_( st )
+  {
+  }
+
+  std::optional<bool> run()
+  {
+    stopwatch<> t( st_.time_total );
+
+    bill::solver<Solver> solver;
+    bill::lit_type output = convert_to_cnf( miter_, solver );
+
+    const auto res = solver.solve( {output}, ps_.conflict_limit );
+
+    switch ( res )
+    {
+    default:
+      return std::nullopt;
+    case bill::result::states::satisfiable:
+    {
+      st_.counter_example.clear();
+      for ( auto i = 1u; i <= miter_.num_pis(); ++i )
+      {
+        st_.counter_example.push_back( solver.get_model().model().at( i ) == bill::lbool_type::true_ );
+      }
+      return false;
+    }
+    case bill::result::states::unsatisfiable:
+      return true;
+    }
+  }
+
+private:
+  bill::lit_type convert_to_cnf( Ntk const& ntk, bill::solver<Solver>& solver )
+  {
+    node_map<bill::lit_type, Ntk> literals( ntk );
+
+    literals[ntk.get_constant( false )] = bill::lit_type( solver.add_variable(), bill::lit_type::polarities::positive );
+    if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+    {
+      literals[ntk.get_constant( true )] = lit_not( literals[ntk.get_constant( false )] );
+    }
+    solver.add_clause( {~literals[ntk.get_constant( false )]} );
+
+    ntk.foreach_pi( [&]( auto const& n ) {
+      literals[n] = bill::lit_type( solver.add_variable(), bill::lit_type::polarities::positive );
+    } );
+    ntk.foreach_gate( [&]( auto const& n ) {
+      literals[n] = bill::lit_type( solver.add_variable(), bill::lit_type::polarities::positive );
+    } );
+
+    if constexpr ( has_EXCDC_interface_v<Ntk> )
+    {
+      ntk.add_EXCDC_clauses( solver );
+    }
+
+    return generate_cnf<Ntk, bill::lit_type>( ntk, [&]( bill::result::clause_type const& clause ) {
+      solver.add_clause( clause );
+    }, literals )[0];
+  }
+
+private:
+  Ntk const& miter_;
+  equivalence_checking_params const& ps_;
+  equivalence_checking_stats& st_;
+};
+
+} // namespace detail
+
+/*! \brief Combinational equivalence checking.
+ *
+ * This function expects as input a miter circuit that can be generated, e.g.,
+ * with the function `miter`.  It returns an optional which is `nullopt`, if no
+ * solution can be found (this happens when a resource limit is set using the
+ * function's parameters).  Otherwise it returns `true`, if the miter is
+ * equivalent or `false`, if the miter is not equivalent.  In the latter case
+ * the counter example is written to the statistics pointer as a
+ * `std::vector<bool>` following the same order as the primary inputs.
+ *
+ * \param miter Miter network
+ * \param ps Parameters
+ * \param st Statistics
+ */
+template<class Ntk>
+std::optional<bool> equivalence_checking( Ntk const& miter, equivalence_checking_params const& ps = {}, equivalence_checking_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_num_pis_v<Ntk>, "Ntk does not implement the num_pis method" );
+  static_assert( has_num_pos_v<Ntk>, "Ntk does not implement the num_pos method" );
+
+  if ( miter.num_pos() != 1u )
+  {
+    std::cout << "[e] miter network must have a single output\n";
+    return std::nullopt;
+  }
+
+  equivalence_checking_stats st;
+  detail::equivalence_checking_impl<Ntk> impl( miter, ps, st );
+  const auto result = impl.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+
+  return result;
+}
+
+template<class Ntk>
+std::optional<bool> equivalence_checking_bill( Ntk const& miter, equivalence_checking_params const& ps = {}, equivalence_checking_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_num_pis_v<Ntk>, "Ntk does not implement the num_pis method" );
+  static_assert( has_num_pos_v<Ntk>, "Ntk does not implement the num_pos method" );
+
+  if ( miter.num_pos() != 1u )
+  {
+    std::cout << "[e] miter network must have a single output\n";
+    return std::nullopt;
+  }
+
+  equivalence_checking_stats st;
+  detail::equivalence_checking_impl_bill<Ntk> impl( miter, ps, st );
+  const auto result = impl.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+
+  return result;
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/equivalence_classes.hpp b/include/mockturtle/algorithms/equivalence_classes.hpp
new file mode 100644
index 0000000..e13efa3
--- /dev/null
+++ b/include/mockturtle/algorithms/equivalence_classes.hpp
@@ -0,0 +1,156 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file equivalence_classes.hpp
+  \brief Synthesis routines based on equivalence classes
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <type_traits>
+#include <vector>
+
+#include "../traits.hpp"
+
+#include <kitty/detail/constants.hpp>
+#include <kitty/spectral.hpp>
+
+namespace mockturtle
+{
+
+/*! \brief Applies a sequence of transformations to a network
+ *
+ * A synthesis function `synthesis_fn` computes a network into `dest` and
+ * computes an output signal.  Both the inputs and the outputs to that synthesis
+ * function are transformed according to `transformations`, a sequence of
+ * spectral transformations.  The vector `leaves` are the original inputs to the
+ * output function, which is returned in terms of a signal into the network.
+ *
+ * The signature of `synthesis_fn` is `signal<Ntk>(Ntk&, std::vector<signal<Ntk>> const&)`.
+ *
+ * \param dest Destination network for synthesis
+ * \param transformations Sequence of spectral operations (see kitty)
+ * \param leaves Original inputs, which might be transformed
+ * \param synthesis_fn Synthesis function to create the inner function (without transformations)
+ *
+   \verbatim embed:rst
+
+   .. note::
+
+      An example on how to transform the AND function into the MAJ function is
+      provided as test.
+   \endverbatim
+ */
+template<class Ntk, class SynthesisFn>
+signal<Ntk> apply_spectral_transformations( Ntk& dest, std::vector<kitty::detail::spectral_operation> const& transformations, std::vector<signal<Ntk>> const& leaves, SynthesisFn&& synthesis_fn )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+  static_assert( has_create_nary_xor_v<Ntk>, "Ntk does not implement the create_nary_xor method" );
+  static_assert( std::is_invocable_r_v<signal<Ntk>, SynthesisFn, Ntk&, std::vector<signal<Ntk>> const&>, "SynthesisFn does not have expected signature" );
+
+  auto _leaves = leaves;
+  std::vector<signal<Ntk>> _final_xors;
+  bool _output_neg = false;
+
+  for ( auto const& t : transformations )
+  {
+    switch ( t._kind )
+    {
+    default:
+      assert( false );
+    case kitty::detail::spectral_operation::kind::permutation:
+    {
+      const auto v1 = kitty::detail::log2[t._var1];
+      const auto v2 = kitty::detail::log2[t._var2];
+      std::swap( _leaves[v1], _leaves[v2] );
+    }
+    break;
+    case kitty::detail::spectral_operation::kind::input_negation:
+    {
+      const auto v1 = kitty::detail::log2[t._var1];
+      _leaves[v1] = dest.create_not( _leaves[v1] );
+    }
+    break;
+    case kitty::detail::spectral_operation::kind::output_negation:
+      _output_neg = !_output_neg;
+      break;
+    case kitty::detail::spectral_operation::kind::spectral_translation:
+    {
+      const auto v1 = kitty::detail::log2[t._var1];
+      const auto v2 = kitty::detail::log2[t._var2];
+      _leaves[v1] = dest.create_xor( _leaves[v1], _leaves[v2] );
+    }
+    break;
+    case kitty::detail::spectral_operation::kind::disjoint_translation:
+    {
+      const auto v1 = kitty::detail::log2[t._var1];
+      _final_xors.push_back( _leaves[v1] );
+    }
+    break;
+    }
+  }
+
+  _final_xors.push_back( synthesis_fn( dest, _leaves ) );
+  const auto output = dest.create_nary_xor( _final_xors );
+  return _output_neg ? dest.create_not( output ) : output;
+}
+
+/*! \brief Applies NPN transformations to a network
+ *
+ * A synthesis function `synthesis_fn` computes a network into `dest` and
+ * computes an output signal.  Both the inputs and the outputs to that synthesis
+ * function are transformed according to `phase` and `perm`, based on NPN
+ * classification.  The vector `leaves` are the original inputs to the
+ * output function, which is returned in terms of a signal into the network.
+ *
+ * The signature of `synthesis_fn` is `signal<Ntk>(Ntk&, std::vector<signal<Ntk>> const&)`.
+ *
+ * \param dest Destination network for synthesis
+ * \param phase Input and output complementation
+ * \param perm Input permutation
+ * \param leaves Original inputs, which might be transformed
+ * \param synthesis_fn Synthesis function to create the inner function (without transformations)
+ */
+template<class Ntk, class SynthesisFn>
+signal<Ntk> apply_npn_transformations( Ntk& dest, uint32_t phase, std::vector<uint8_t> const& perm, std::vector<signal<Ntk>> const& leaves, SynthesisFn&& synthesis_fn )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+  static_assert( has_create_nary_xor_v<Ntk>, "Ntk does not implement the create_nary_xor method" );
+  static_assert( std::is_invocable_r_v<signal<Ntk>, SynthesisFn, Ntk&, std::vector<signal<Ntk>> const&>, "SynthesisFn does not have expected signature" );
+
+  std::vector<signal<Ntk>> _leaves( perm.size() );
+  std::transform( perm.begin(), perm.end(), _leaves.begin(), [&]( auto const& i ) { return ( phase >> i ) & 1 ? dest.create_not( leaves[i] ) : leaves[i]; } );
+
+  const auto f = synthesis_fn( dest, _leaves );
+  return ( phase >> leaves.size() ) & 1 ? dest.create_not( f ) : f;
+}
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/exact_mc_synthesis.hpp b/include/mockturtle/algorithms/exact_mc_synthesis.hpp
new file mode 100644
index 0000000..2c195c1
--- /dev/null
+++ b/include/mockturtle/algorithms/exact_mc_synthesis.hpp
@@ -0,0 +1,638 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file exact_mc_synthesis.hpp
+  \brief SAT-based XAG synthesis based on MC
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <vector>
+
+#include <bill/sat/interface/common.hpp>
+#include <bill/sat/interface/glucose.hpp>
+#include <kitty/bit_operations.hpp>
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/operations.hpp>
+#include <kitty/properties.hpp>
+
+#include "../algorithms/simulation.hpp"
+#include "../generators/sorting.hpp"
+#include "../io/write_verilog.hpp"
+#include "../networks/xag.hpp"
+#include "../utils/progress_bar.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../views/cnf_view.hpp"
+#include "cnf.hpp"
+
+namespace mockturtle
+{
+
+struct exact_mc_synthesis_params
+{
+  /* \brief Minimum number of AND gates. */
+  uint32_t min_and_gates{ 0u };
+
+  /*! \brief Use CEGAR based solving strategy. */
+  bool use_cegar{ false };
+
+  /*! \brief Use subset symmetry breaking. */
+  bool break_subset_symmetries{ true };
+
+  /*! \brief Use multi-level subset symmetry breaking. */
+  bool break_multi_level_subset_symmetries{ true };
+
+  /*! \brief Use symmetric variables. */
+  bool break_symmetric_variables{ true };
+
+  /*! \brief User-specified variable symmetries. */
+  std::vector<std::pair<uint32_t, uint32_t>> custom_symmetric_variables;
+
+  /*! \brief Ensure to use all gates and essential variables. */
+  bool ensure_to_use_gates{ true };
+
+  /*! \brief Heuristic XOR bound (based on sorter network). */
+  std::optional<uint32_t> heuristic_xor_bound{};
+
+  /*! \brief Updates XOR bound heuristic after each found solution. */
+  bool auto_update_xor_bound{ false };
+
+  /*! \brief Conflict limit for the SAT solver. */
+  uint32_t conflict_limit{ 0u };
+
+  /*! \brief Use conflict limit only when searching for multiple solutions
+   *
+   * The conflict limit will be ignored for the first call.
+   */
+  bool ignore_conflict_limit_for_first_solution{ false };
+
+  /*! \brief Show progress (in CEGAR). */
+  bool progress{ false };
+
+  /*! \brief Write DIMACS file, everytime solve is called. */
+  std::optional<std::string> write_dimacs{};
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+
+  /*! \brief Be very verbose */
+  bool very_verbose{ false };
+};
+
+struct exact_mc_synthesis_stats
+{
+  /*! \brief Total time. */
+  stopwatch<>::duration time_total{};
+
+  /*! \brief Time for SAT solving. */
+  stopwatch<>::duration time_solving{};
+
+  /*! \brief Total number of variables. */
+  uint32_t num_vars{};
+
+  /*! \brief Total number of clauses. */
+  uint32_t num_clauses{};
+
+  /*! \brief Prints report. */
+  void report() const
+  {
+    fmt::print( "[i] total time    = {:>5.2f} secs\n", to_seconds( time_total ) );
+    fmt::print( "[i] solving time  = {:>5.2f} secs\n", to_seconds( time_solving ) );
+    fmt::print( "[i] total vars    = {}\n", num_vars );
+    fmt::print( "[i] total clauses = {}\n", num_clauses );
+  }
+};
+
+namespace detail
+{
+
+template<class Ntk, bill::solvers Solver>
+struct exact_mc_synthesis_impl
+{
+  using problem_network_t = cnf_view<xag_network, false, Solver>;
+
+  exact_mc_synthesis_impl( kitty::dynamic_truth_table const& func, uint32_t num_solutions, exact_mc_synthesis_params const& ps, exact_mc_synthesis_stats& st )
+      : num_vars_( func.num_vars() ),
+        func_( kitty::get_bit( func, 0 ) ? ~func : func ),
+        invert_( kitty::get_bit( func, 0 ) ),
+        heuristic_xor_bound_( ps.heuristic_xor_bound ),
+        num_solutions_( num_solutions ),
+        ps_( ps ),
+        st_( st )
+  {
+  }
+
+  std::vector<Ntk> run()
+  {
+    stopwatch<> t( st_.time_total );
+
+    std::vector<Ntk> ntks;
+    const auto degree = kitty::polynomial_degree( func_ );
+    uint32_t num_ands = std::max( ps_.min_and_gates, degree == 0u ? degree : degree - 1u );
+
+    while ( true )
+    {
+      if ( ps_.verbose )
+      {
+        fmt::print( "try with {} AND gates\n", num_ands );
+      }
+
+      cnf_view_params cvps;
+      cvps.write_dimacs = ps_.write_dimacs;
+      problem_network_t pntk( cvps );
+      reset( pntk );
+
+      for ( auto i = 0u; i < num_ands; ++i )
+      {
+        add_gate( pntk );
+      }
+      add_output( pntk );
+      if ( ps_.heuristic_xor_bound || ps_.auto_update_xor_bound )
+      {
+        add_xor_counter( pntk );
+      }
+
+      // TODO use LUT mapping before CNF generation
+      if ( const auto sol = ps_.use_cegar ? solve_with_cegar( pntk ) : solve_direct( pntk ); sol )
+      {
+        ntks.push_back( *sol );
+        if ( ps_.very_verbose )
+        {
+          debug_solution( pntk );
+        }
+        while ( ntks.size() < num_solutions_ )
+        {
+          block( pntk );
+          if ( const auto result = solve( pntk, false ); result && *result )
+          {
+            ntks.push_back( extract_network( pntk ) );
+            if ( ps_.very_verbose )
+            {
+              debug_solution( pntk );
+              fmt::print( "[i] found {} solutions so far\n", ntks.size() );
+            }
+          }
+          else
+          {
+            break;
+          }
+        }
+        return ntks;
+      }
+      ++num_ands;
+    }
+  }
+
+private:
+  std::optional<Ntk> solve_direct( problem_network_t& pntk )
+  {
+    prune_search_space( pntk );
+
+    for ( auto b = 1u; b < func_.num_bits(); ++b )
+    {
+      constrain_assignment( pntk, b );
+    }
+
+    st_.num_vars += pntk.num_vars();
+    st_.num_clauses += pntk.num_clauses();
+    if ( const auto result = solve( pntk, true ); result && *result )
+    {
+      return extract_network( pntk );
+    }
+    else
+    {
+      return std::nullopt;
+    }
+  }
+
+  std::optional<Ntk> solve_with_cegar( problem_network_t& pntk )
+  {
+    prune_search_space( pntk );
+
+    uint32_t num_ands = static_cast<uint32_t>( ltfi_vars_.size() ) / 2, bctr = 0u;
+    progress_bar pbar( static_cast<uint32_t>( func_.num_bits() ), "exact_mc_synthesis |{}| ANDs = {}   asserted bits = {}   SAT solving time = {:.2f} secs", ps_.progress );
+    while ( true )
+    {
+      pbar( bctr, num_ands, bctr, to_seconds( st_.time_solving ) );
+      if ( const auto result = solve( pntk, true ); result && *result )
+      {
+        const auto sol = extract_network( pntk );
+        default_simulator<kitty::dynamic_truth_table> sim( num_vars_ );
+        const auto simulated = simulate<kitty::dynamic_truth_table>( sol, sim )[0u];
+        if ( const auto bit = kitty::find_first_bit_difference( func_, simulated ); bit == -1 )
+        {
+          st_.num_vars += pntk.num_vars();
+          st_.num_clauses += pntk.num_clauses();
+          return sol;
+        }
+        else
+        {
+          constrain_assignment( pntk, static_cast<uint32_t>( bit ) );
+          bctr++;
+        }
+      }
+      else
+      {
+        st_.num_vars += pntk.num_vars();
+        st_.num_clauses += pntk.num_clauses();
+        return std::nullopt;
+      }
+    }
+  }
+
+  std::optional<bool> solve( problem_network_t& pntk, bool first )
+  {
+    stopwatch<> t_sat( st_.time_solving );
+    bill::result::clause_type assumptions;
+    pntk.foreach_po( [&]( auto const& f ) {
+      assumptions.push_back( pntk.lit( f ) );
+    } );
+    if ( heuristic_xor_bound_ )
+    {
+      if ( int32_t pos = static_cast<int32_t>( xor_counter_.size() ) - *heuristic_xor_bound_ - 1; pos >= 0 )
+      {
+        assumptions.push_back( pntk.lit( !xor_counter_[pos] ) );
+      }
+    }
+    const auto res = pntk.solve( assumptions, ps_.ignore_conflict_limit_for_first_solution && first ? 0u : ps_.conflict_limit );
+
+    if ( ps_.auto_update_xor_bound && res && *res )
+    {
+      heuristic_xor_bound_ = count_xors( pntk ) - 1u;
+    }
+
+    return res;
+  }
+
+private:
+  Ntk extract_network( problem_network_t& pntk )
+  {
+    Ntk xag;
+    std::vector<signal<Ntk>> nodes( num_vars_ );
+    std::generate( nodes.begin(), nodes.end(), [&]() { return xag.create_pi(); } );
+
+    const auto extract_ltfi = [&]( std::vector<signal<problem_network_t>> const& ltfi_vars ) -> signal<Ntk> {
+      std::vector<signal<Ntk>> ltfi;
+      for ( auto j = 0u; j < ltfi_vars.size(); ++j )
+      {
+        if ( pntk.model_value( ltfi_vars[j] ) )
+        {
+          ltfi.push_back( nodes[j] );
+        }
+      }
+      return xag.create_nary_xor( ltfi );
+    };
+
+    for ( auto i = 0u; i < ltfi_vars_.size() / 2; ++i )
+    {
+      nodes.push_back( xag.create_and( extract_ltfi( ltfi_vars_[2 * i] ), extract_ltfi( ltfi_vars_[2 * i + 1] ) ) );
+    }
+
+    const auto c = extract_ltfi( ltfi_vars_.back() );
+    xag.create_po( invert_ ? xag.create_not( c ) : c );
+
+    return xag;
+  }
+
+  void block( problem_network_t& pntk )
+  {
+    std::vector<signal<problem_network_t>> blocked_lits;
+    for ( auto const& ltfi : ltfi_vars_ )
+    {
+      for ( auto const& l : ltfi )
+      {
+        blocked_lits.push_back( l ^ pntk.model_value( l ) );
+      }
+    }
+    pntk.add_clause( blocked_lits );
+  }
+
+  void reset( problem_network_t const& pntk )
+  {
+    // TODO: can we make this more iterative?
+    ltfi_vars_.clear();
+    truth_vars_.clear();
+    truth_vars_.resize( func_.num_bits() );
+
+    /* pre-assign truth_vars_ with primary inputs */
+    for ( auto i = 0u; i < num_vars_; ++i )
+    {
+      const auto var_tt = kitty::nth_var<kitty::dynamic_truth_table>( num_vars_, i );
+      for ( auto b = 0u; b < func_.num_bits(); ++b )
+      {
+        truth_vars_[b].push_back( pntk.get_constant( kitty::get_bit( var_tt, b ) ) );
+      }
+    }
+  }
+
+  void add_gate( problem_network_t& pntk )
+  {
+    uint32_t gate_index = static_cast<uint32_t>( ltfi_vars_.size() ) / 2;
+
+    // add select variables
+    for ( auto j = 0u; j < 2u; ++j )
+    {
+      ltfi_vars_.push_back( std::vector<signal<problem_network_t>>( num_vars_ + gate_index ) );
+      std::generate( ltfi_vars_.back().begin(), ltfi_vars_.back().end(), [&]() { return pntk.create_pi(); } );
+    }
+  }
+
+  void add_output( problem_network_t& pntk )
+  {
+    ltfi_vars_.push_back( std::vector<signal<problem_network_t>>( num_vars_ + ltfi_vars_.size() / 2 ) );
+    std::generate( ltfi_vars_.back().begin(), ltfi_vars_.back().end(), [&]() { return pntk.create_pi(); } );
+  }
+
+  void constrain_assignment( problem_network_t& pntk, uint32_t bit )
+  {
+    const auto create_xor_clause = [&]( std::vector<signal<problem_network_t>> const& ltfi_vars ) -> signal<problem_network_t> {
+      std::vector<signal<problem_network_t>> ltfi( ltfi_vars.size() );
+      for ( auto j = 0u; j < ltfi.size(); ++j )
+      {
+        ltfi[j] = pntk.create_and( ltfi_vars[j], truth_vars_[bit][j] );
+      }
+      return pntk.create_nary_xor( ltfi );
+    };
+
+    for ( auto i = 0u; i < ltfi_vars_.size() / 2; ++i )
+    {
+      truth_vars_[bit].push_back( pntk.create_and( create_xor_clause( ltfi_vars_[2 * i] ), create_xor_clause( ltfi_vars_[2 * i + 1] ) ) );
+    }
+
+    const auto po_signal = create_xor_clause( ltfi_vars_.back() );
+    pntk.create_po( kitty::get_bit( func_, bit ) ? po_signal : pntk.create_not( po_signal ) );
+  }
+
+  void prune_search_space( problem_network_t& pntk )
+  {
+    // At least one element in LTFI
+    for ( auto const& ltfi : ltfi_vars_ )
+    {
+      pntk.add_clause( ltfi );
+    }
+
+    // linear TFIs are no subset of each other
+    if ( ps_.break_subset_symmetries )
+    {
+      for ( auto i = 0u; i < ltfi_vars_.size() / 2u; ++i )
+      {
+        auto const& ltfi1 = ltfi_vars_[2 * i];
+        auto const& ltfi2 = ltfi_vars_[2 * i + 1];
+
+        std::vector<signal<problem_network_t>> ands( ltfi1.size() );
+        std::vector<signal<problem_network_t>> ands2( ltfi1.size() );
+        for ( auto j = 0u; j < ltfi1.size(); ++j )
+        {
+          ands[j] = pntk.create_and( ltfi1[j], pntk.create_not( ltfi2[j] ) );
+          ands2[j] = pntk.create_and( ltfi2[j], pntk.create_not( ltfi1[j] ) );
+        }
+        pntk.add_clause( ands );
+        pntk.add_clause( ands2 );
+      }
+    }
+
+    // left linear TFI is lexicographically smaller than right one
+    for ( auto i = 0u; i < ltfi_vars_.size() / 2u; ++i )
+    {
+      auto const& ltfi2 = ltfi_vars_[2 * i];
+      auto const& ltfi1 = ltfi_vars_[2 * i + 1];
+
+      auto n = ltfi1.size();
+      std::vector<signal<problem_network_t>> as( n - 1u );
+      std::generate( as.begin(), as.end(), [&]() { return pntk.create_pi(); } );
+
+      pntk.add_clause( !ltfi1[0], ltfi2[0] );
+      pntk.add_clause( !ltfi1[0], as[0] );
+      pntk.add_clause( ltfi2[0], as[0] );
+
+      for ( auto k = 1u; k < n - 1; ++k )
+      {
+        pntk.add_clause( !ltfi1[k], ltfi2[k], !as[k - 1] );
+        pntk.add_clause( !ltfi1[k], as[k], !as[k - 1] );
+        pntk.add_clause( ltfi2[k], as[k], !as[k - 1] );
+      }
+      pntk.add_clause( !ltfi1.back(), !as.back() );
+      pntk.add_clause( ltfi2.back(), !as.back() );
+    }
+
+    // break on multi-level subset relation
+    if ( ps_.break_multi_level_subset_symmetries )
+    {
+      for ( auto ii = 0u; ii < ltfi_vars_.size(); ++ii )
+      {
+        const auto& ltfi = ltfi_vars_[ii];
+        for ( auto i = 0u; i < ii / 2u; ++i )
+        {
+          const auto n = ltfi_vars_[2 * i].size();
+          std::vector<signal<problem_network_t>> ands_left, ands_right;
+          ands_left.push_back( ltfi[num_vars_ + i] );
+          for ( auto k = 0u; k < n; ++k )
+          {
+            ands_left.push_back( pntk.create_or( !ltfi[k], ltfi_vars_[2 * i][k] ) );
+            ands_left.push_back( pntk.create_or( !ltfi[k], ltfi_vars_[2 * i + 1][k] ) );
+            ands_right.push_back( pntk.create_xnor( ltfi[k], pntk.create_and( ltfi_vars_[2 * i][k], ltfi_vars_[2 * i + 1][k] ) ) );
+          }
+          pntk.create_po( pntk.create_or( !pntk.create_nary_and( ands_left ), pntk.create_nary_and( ands_right ) ) );
+        }
+      }
+    }
+
+    // break on symmetric variables
+    if ( ps_.break_symmetric_variables )
+    {
+      const auto break_symmetric_vars = [&]( auto j, auto jj ) {
+        if ( ps_.very_verbose )
+        {
+          fmt::print( "[i] symmetry breaking based on symmetric variables {} and {}\n", j, jj );
+        }
+        for ( auto ii = 0u; ii < ltfi_vars_.size(); ++ii )
+        {
+          std::vector<signal<problem_network_t>> clause;
+          clause.push_back( !ltfi_vars_[ii][jj] );
+          for ( auto i = 0u; i <= ii; ++i )
+          {
+            clause.push_back( ltfi_vars_[i][j] );
+          }
+          pntk.add_clause( clause );
+        }
+      };
+
+      for ( auto jj = 1u; jj < num_vars_; ++jj )
+      {
+        for ( auto j = 0u; j < jj; ++j )
+        {
+          if ( kitty::is_symmetric_in( func_, j, jj ) )
+          {
+            break_symmetric_vars( j, jj );
+          }
+        }
+      }
+
+      for ( const auto& [j, jj] : ps_.custom_symmetric_variables )
+      {
+        break_symmetric_vars( j, jj );
+      }
+    }
+
+    // ensure to use essential variables and gates
+    if ( ps_.ensure_to_use_gates )
+    {
+      const auto num_ands = ltfi_vars_.size() / 2;
+      for ( auto j = 0u; j < num_vars_ + num_ands; ++j )
+      {
+        if ( j < num_vars_ && !kitty::has_var( func_, j ) )
+        {
+          continue;
+        }
+
+        std::vector<signal<problem_network_t>> clause;
+        for ( auto const& ltfi : ltfi_vars_ )
+        {
+          if ( j < ltfi.size() )
+          {
+            clause.push_back( ltfi[j] );
+          }
+        }
+        pntk.add_clause( clause );
+      }
+    }
+  }
+
+  void add_xor_counter( problem_network_t& pntk )
+  {
+    xor_counter_.clear();
+    for ( auto const& ltfi : ltfi_vars_ )
+    {
+      std::copy( ltfi.begin(), ltfi.end(), std::back_inserter( xor_counter_ ) );
+    }
+
+    insertion_sorting_network( static_cast<uint32_t>( xor_counter_.size() ), [&]( auto a, auto b ) {
+      auto const aa = pntk.create_and( xor_counter_[a], xor_counter_[b] );
+      auto const bb = pntk.create_or( xor_counter_[a], xor_counter_[b] );
+      xor_counter_[a] = aa;
+      xor_counter_[b] = bb;
+    } );
+  }
+
+private:
+  uint32_t count_xors( problem_network_t& pntk ) const
+  {
+    uint32_t ctr{};
+    for ( auto const& ltfi : ltfi_vars_ )
+    {
+      for ( auto const& l : ltfi )
+      {
+        ctr += pntk.model_value( l ) ? 1u : 0u;
+      }
+    }
+    return ctr;
+  }
+
+  void debug_solution( problem_network_t& pntk ) const
+  {
+    const auto num_ands = ltfi_vars_.size() / 2u;
+    const auto print_ltfi = [&]( std::vector<signal<problem_network_t>> const& ltfi ) {
+      for ( auto const& f : ltfi )
+      {
+        fmt::print( "{} ", (uint32_t)pntk.model_value( f ) );
+      }
+      if ( auto padding = 2u * ( num_ands + num_vars_ - ltfi.size() ); padding > 0 )
+      {
+        fmt::print( "{}", std::string( padding, ' ' ) );
+      }
+    };
+
+    for ( auto i = 0u; i < ltfi_vars_.size() / 2u; ++i )
+    {
+      fmt::print( "{:>2} = ", i + 1 );
+      print_ltfi( ltfi_vars_[2 * i] );
+      fmt::print( "   " );
+      print_ltfi( ltfi_vars_[2 * i + 1] );
+      fmt::print( "\n" );
+    }
+    fmt::print( " f = " );
+    print_ltfi( ltfi_vars_.back() );
+    fmt::print( "\n  XORs = {}\n\n", count_xors( pntk ) );
+  }
+
+private:
+  uint32_t num_vars_;
+  std::vector<std::vector<signal<problem_network_t>>> ltfi_vars_;
+  std::vector<std::vector<signal<problem_network_t>>> truth_vars_;
+  std::vector<signal<problem_network_t>> xor_counter_;
+  kitty::dynamic_truth_table func_;
+  bool invert_{ false };
+  std::optional<uint32_t> heuristic_xor_bound_;
+  uint32_t num_solutions_;
+  exact_mc_synthesis_params const& ps_;
+  exact_mc_synthesis_stats& st_;
+};
+
+} // namespace detail
+
+template<class Ntk = xag_network, bill::solvers Solver = bill::solvers::glucose_41>
+Ntk exact_mc_synthesis( kitty::dynamic_truth_table const& func, exact_mc_synthesis_params const& ps = {}, exact_mc_synthesis_stats* pst = nullptr )
+{
+  exact_mc_synthesis_stats st;
+  const auto xag = detail::exact_mc_synthesis_impl<Ntk, Solver>{ func, 1u, ps, st }.run().front();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+  if ( pst )
+  {
+    *pst = st;
+  }
+
+  return xag;
+}
+
+template<class Ntk = xag_network, bill::solvers Solver = bill::solvers::glucose_41>
+std::vector<Ntk> exact_mc_synthesis_multiple( kitty::dynamic_truth_table const& func, uint32_t num_solutions, exact_mc_synthesis_params const& ps = {}, exact_mc_synthesis_stats* pst = nullptr )
+{
+  exact_mc_synthesis_stats st;
+  const auto xags = detail::exact_mc_synthesis_impl<Ntk, Solver>{ func, num_solutions, ps, st }.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+  if ( pst )
+  {
+    *pst = st;
+  }
+
+  return xags;
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/exorcism.hpp b/include/mockturtle/algorithms/exorcism.hpp
new file mode 100644
index 0000000..f91cbde
--- /dev/null
+++ b/include/mockturtle/algorithms/exorcism.hpp
@@ -0,0 +1,82 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file exorcism.hpp
+  \brief Wrapper for ABC's exorcism
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <vector>
+
+#include <eabc/exor.h>
+#include <kitty/constructors.hpp>
+#include <kitty/cube.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/esop.hpp>
+
+namespace abc::exorcism
+{
+extern int Abc_ExorcismMain( Vec_Wec_t* vEsop, int nIns, int nOuts, std::function<void( uint32_t, uint32_t )> const& onCube, int Quality, int Verbosity, int nCubesMax, int fUseQCost );
+}
+
+namespace mockturtle
+{
+
+inline std::vector<kitty::cube> exorcism( std::vector<kitty::cube> const& esop, uint32_t num_vars )
+{
+  auto vesop = abc::exorcism::Vec_WecAlloc( esop.size() );
+
+  for ( auto const& cube : esop )
+  {
+    auto vcube = abc::exorcism::Vec_WecPushLevel( vesop );
+    for ( auto i = 0u; i < num_vars; ++i )
+    {
+      if ( !cube.get_mask( i ) )
+        continue;
+      abc::exorcism::Vec_IntPush( vcube, cube.get_bit( i ) ? 2 * i : 2 * i + 1 );
+    }
+    abc::exorcism::Vec_IntPush( vcube, -1 );
+  }
+
+  std::vector<kitty::cube> exorcism_esop;
+  abc::exorcism::Abc_ExorcismMain(
+      vesop, num_vars, 1, [&]( uint32_t bits, uint32_t mask ) { exorcism_esop.emplace_back( bits, mask ); }, 2, 0, 4 * esop.size(), 0 );
+
+  abc::exorcism::Vec_WecFree( vesop );
+
+  return exorcism_esop;
+}
+
+inline std::vector<kitty::cube> exorcism( kitty::dynamic_truth_table const& func )
+{
+  return exorcism( kitty::esop_from_optimum_pkrm( func ), func.num_vars() );
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/experimental/boolean_optimization.hpp b/include/mockturtle/algorithms/experimental/boolean_optimization.hpp
new file mode 100644
index 0000000..3fde2eb
--- /dev/null
+++ b/include/mockturtle/algorithms/experimental/boolean_optimization.hpp
@@ -0,0 +1,356 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file boolean_optimization.hpp
+  \brief A general logic optimization framework using Boolean methods
+
+  \author Hanyu Wang
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../../traits.hpp"
+#include "../../utils/progress_bar.hpp"
+#include "../../utils/stopwatch.hpp"
+#include "../../utils/null_utils.hpp"
+#include "../../views/topo_view.hpp"
+
+#include <optional>
+
+namespace mockturtle::experimental
+{
+
+template<class WinParams = null_params, class ResynParams = null_params>
+struct boolean_optimization_params
+{
+  /*! \brief Show progress. */
+  bool progress{ false };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+
+  /*! \brief Whether to use new nodes as pivots. */
+  bool optimize_new_nodes{ false };
+
+  /*! \brief Whether to run in dry-run mode (call `report` instead of `update_ntk`). */
+  bool dry_run{ false };
+
+  /*! \brief Whether to print verbosely in dry-run mode. Ignored if `dry_run` is `false`. */
+  bool dry_run_verbose{ true };
+
+  /*! \brief Parameter object for the windowing engine. */
+  WinParams wps;
+
+  /*! \brief Parameter object for the resynthesis engine. */
+  ResynParams rps;
+};
+
+template<class WinStats = null_stats, class ResynStats = null_stats>
+struct boolean_optimization_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Accumulated runtime of structural analysis and simulation. */
+  stopwatch<>::duration time_windowing{ 0 };
+
+  /*! \brief Accumulated runtime of resynthesis. */
+  stopwatch<>::duration time_resynthesis{ 0 };
+
+  /*! \brief Accumulated runtime of updating network. */
+  stopwatch<>::duration time_update{ 0 };
+
+  /*! \brief Total number of gain. */
+  uint32_t estimated_gain{ 0 };
+
+  /*! \brief Initial network size (before resubstitution). */
+  uint32_t initial_size{ 0 };
+
+  /*! \brief Number of constructed resynthesis problems. */
+  uint32_t num_problems{ 0u };
+
+  /*! \brief Number of solutions found. */
+  uint32_t num_solutions{ 0u };
+
+  /*! \brief Statistics object for the windowing engine. */
+  WinStats wst;
+
+  /*! \brief Statistics object for the resynthesis engine. */
+  ResynStats rst;
+
+  void report() const
+  {
+    // clang-format off
+    fmt::print( "[i] Boolean optimization top-level report\n" );
+    fmt::print( "Estimated gain: {:8d} ({:.2f}%)\n", estimated_gain, ( 100.0 * estimated_gain ) / initial_size );
+    fmt::print( "#problems = {}, #solutions = {} ({:.2f}%)\n", num_problems, num_solutions, float( num_solutions ) / float( num_problems ) );
+    fmt::print( "======== Runtime Breakdown ========\n" );
+    fmt::print( "Total         : {:>5.2f} secs\n", to_seconds( time_total ) );
+    fmt::print( "  Windowing   : {:>5.2f} secs\n", to_seconds( time_windowing ) );
+    fmt::print( "  Resynthesis : {:>5.2f} secs\n", to_seconds( time_resynthesis ) );
+    fmt::print( "  Update ntk  : {:>5.2f} secs\n", to_seconds( time_update ) );
+    fmt::print( "========= Windowing Stats =========\n" );
+    wst.report();
+    fmt::print( "======== Resynthesis Stats ========\n" );
+    rst.report();
+    fmt::print( "===================================\n\n" );
+    // clang-format on
+  }
+};
+
+namespace detail
+{
+
+/*! \brief Logic optimization using Boolean methods.
+ *
+ * \tparam Ntk Network type.
+ * \tparam Windowing Implementation of a windowing algorithm that creates
+ * a resynthesis problem to be solved.
+ * \tparam ResynSolver Implementation of a resynthesis algorithm that
+ * solves the resynthesis problem created by `Windowing`.
+ */
+template<class Ntk, class Windowing, class ResynSolver>
+class boolean_optimization_impl
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  using problem_t = typename Windowing::problem_t;
+  using res_t = typename ResynSolver::res_t;
+  using params_t = boolean_optimization_params<typename Windowing::params_t, typename ResynSolver::params_t>;
+  using stats_t = boolean_optimization_stats<typename Windowing::stats_t, typename ResynSolver::stats_t>;
+
+  explicit boolean_optimization_impl( Ntk& ntk, params_t const& ps, stats_t& st )
+      : ntk( ntk ), ps( ps ), st( st ), windowing( ntk, ps.wps, st.wst ), resyn( ntk, ps.rps, st.rst )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_num_gates_v<Ntk>, "Ntk does not implement the num_gates method" );
+    static_assert( std::is_same_v<problem_t, typename ResynSolver::problem_t>, "Types of resynthesis problem of Windowing and ResynSolver do not match" );
+  }
+
+  ~boolean_optimization_impl()
+  {}
+
+  void run()
+  {
+    stopwatch t( st.time_total );
+    progress_bar pbar{ ntk.size(), "B-opt |{0}| node = {1:>4}   cand = {2:>4}   est. gain = {3:>5}", ps.progress };
+
+    /* initialize */
+    call_with_stopwatch( st.time_windowing, [&]() {
+      windowing.init();
+    } );
+    call_with_stopwatch( st.time_resynthesis, [&]() {
+      resyn.init();
+    } );
+
+    st.initial_size = ntk.num_gates();
+    topo_view<Ntk>{ ntk }.foreach_gate( [&]( auto const n, auto i ) { // TODO: maybe problematic
+      if ( !ps.optimize_new_nodes && i >= st.initial_size )
+      {
+        return false; /* terminate */
+      }
+      pbar( i, i, candidates, st.estimated_gain );
+
+      /* construct a resynthesis problem; usually by creating a window around the root node */
+      auto prob = call_with_stopwatch( st.time_windowing, [&]() {
+        return windowing( n );
+      } );
+      if ( !prob )
+      {
+        return true; /* next */
+      }
+      ++st.num_problems;
+
+      /* solve the resynthesis problem; usually by finding a (re)substitution */
+      auto res = call_with_stopwatch( st.time_resynthesis, [&]() {
+        return resyn( *prob );
+      } );
+      if ( !res )
+      {
+        return true; /* next */
+      }
+      ++st.num_solutions;
+
+      /* update progress bar */
+      candidates++;
+      st.estimated_gain += windowing.gain( *prob, *res );
+
+      /* update network or report choice */
+      bool cont = true;
+      if ( !ps.dry_run )
+      {
+        cont = call_with_stopwatch( st.time_update, [&]() {
+          return windowing.update_ntk( *prob, *res );
+        } );
+      }
+      else if ( ps.dry_run_verbose )
+      {
+        cont = windowing.report( *prob, *res );
+      }
+
+      return cont;
+    } );
+  }
+
+private:
+  Ntk& ntk;
+
+  params_t const& ps;
+  stats_t& st;
+
+  Windowing windowing;
+  ResynSolver resyn;
+
+  /* temporary statistics for progress bar */
+  uint32_t candidates{ 0 };
+}; /* boolean_optimization_impl */
+
+template<class Ntk>
+struct null_problem
+{
+  using node = typename Ntk::node;
+  node pivot;
+};
+
+/*! \brief A windowing implementation that creates windows of only the pivot node.
+ *
+ * This class is an example to demonstrate the interfaces required by
+ * the `Windowing` template argument of class `boolean_optimization_impl`.
+ * It is designed to be used together with `null_resynthesis`.
+ */
+template<class Ntk>
+class null_windowing
+{
+public:
+  using problem_t = null_problem<Ntk>;
+  using res_t = typename Ntk::signal;
+  using params_t = null_params;
+  using stats_t = null_stats;
+  using node = typename Ntk::node;
+
+  explicit null_windowing( Ntk& ntk, params_t const& ps, stats_t& st )
+      : ntk( ntk )
+  {
+    (void)ps;
+    (void)st;
+  }
+
+  void init()
+  {}
+
+  std::optional<problem_t> operator()( node const& n )
+  {
+    return problem_t{ n };
+  }
+
+  uint32_t gain( problem_t const& prob, res_t const& res ) const
+  {
+    (void)prob;
+    (void)res;
+    return 0u;
+  }
+
+  bool update_ntk( problem_t const& prob, res_t const& res )
+  {
+    ntk.substitute_node( prob.pivot, res );
+    return true;
+  }
+
+  bool report( problem_t const& prob, res_t const& res )
+  {
+    fmt::print( "[i] substitute node {} with signal {}{}\n", prob.pivot, ntk.is_complemented( res ) ? "!" : "", ntk.get_node( res ) );
+    return true;
+  }
+
+private:
+  Ntk& ntk;
+};
+
+/*! \brief A resynthesis implementation that returns the pivot node itself.
+ *
+ * This class is an example to demonstrate the interfaces required by
+ * the `ResynSolver` template argument of class `boolean_optimization_impl`.
+ * It is designed to be used together with `null_windowing`.
+ */
+template<class Ntk>
+class null_resynthesis
+{
+public:
+  using problem_t = null_problem<Ntk>;
+  using res_t = typename Ntk::signal;
+  using params_t = null_params;
+  using stats_t = null_stats;
+
+  explicit null_resynthesis( Ntk const& ntk, params_t const& ps, stats_t& st )
+      : ntk( ntk )
+  {
+    (void)ps;
+    (void)st;
+  }
+
+  void init()
+  {}
+
+  std::optional<res_t> operator()( problem_t& prob )
+  {
+    return ntk.make_signal( prob.pivot );
+  }
+
+private:
+  Ntk const& ntk;
+};
+
+} /* namespace detail */
+
+template<class Ntk, typename params_t = boolean_optimization_params<null_params, null_params>, typename stats_t = boolean_optimization_stats<null_stats, null_stats>>
+void null_optimization( Ntk& ntk, params_t const& ps = {}, stats_t* pst = nullptr )
+{
+  stats_t st;
+
+  using windowing_t = typename detail::null_windowing<Ntk>;
+  using resyn_t = typename detail::null_resynthesis<Ntk>;
+  using opt_t = typename detail::boolean_optimization_impl<Ntk, windowing_t, resyn_t>;
+
+  opt_t p( ntk, ps, st );
+  p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle::experimental */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/experimental/cost_generic_resub.hpp b/include/mockturtle/algorithms/experimental/cost_generic_resub.hpp
new file mode 100644
index 0000000..a5ea472
--- /dev/null
+++ b/include/mockturtle/algorithms/experimental/cost_generic_resub.hpp
@@ -0,0 +1,426 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cost_generic_resub.hpp
+  \brief generic widnowing algorithm with customized cost function
+
+  \author Hanyu Wang
+*/
+
+#pragma once
+
+#include "../../networks/aig.hpp"
+#include "../../networks/xag.hpp"
+#include "../../traits.hpp"
+#include "../../utils/index_list.hpp"
+#include "../../utils/stopwatch.hpp"
+#include "../../views/cost_view.hpp"
+#include "../../views/depth_view.hpp"
+#include "../../views/fanout_view.hpp"
+#include "../../views/topo_view.hpp"
+#include "../detail/resub_utils.hpp"
+#include "../dont_cares.hpp"
+#include "../reconv_cut.hpp"
+#include "../simulation.hpp"
+#include "boolean_optimization.hpp"
+#include "cost_resyn.hpp"
+#include <kitty/kitty.hpp>
+
+#include <functional>
+#include <optional>
+#include <vector>
+
+namespace mockturtle::experimental
+{
+
+/*! \brief Parameters for cost.
+ */
+struct costfn_windowing_params
+{
+  /*! \brief Maximum number of PIs of reconvergence-driven cuts. */
+  uint32_t max_pis{ 8 };
+
+  /*! \brief Maximum number of divisors to consider. */
+  uint32_t max_divisors{ 150 };
+
+  /*! \brief Maximum number of nodes added by resubstitution. */
+  uint32_t max_inserts{ 2 };
+
+  /*! \brief Maximum fanout of a node to be considered as root. */
+  uint32_t skip_fanout_limit_for_roots{ 1000 };
+
+  /*! \brief Maximum fanout of a node to be considered as divisor. */
+  uint32_t skip_fanout_limit_for_divisors{ 100 };
+
+  /*! \brief Use don't cares for optimization. */
+  bool use_dont_cares{ false };
+
+  /*! \brief Window size for don't cares calculation. */
+  uint32_t window_size{ 12u };
+
+  /*! \brief Whether to normalize the truth tables.
+   *
+   * For some enumerative resynthesis engines, if the truth tables
+   * are normalized, some cases can be eliminated and thus improves
+   * efficiency. When this option is turned off, be sure to use an
+   * implementation of resynthesis that does not make this assumption;
+   * otherwise, quality degradation may be observed.
+   *
+   * Normalization is typically only useful for enumerative methods
+   * and for smaller solutions (i.e. when `max_inserts` < 2). Turning
+   * on normalization may result in larger runtime overhead when there
+   * are many divisors or when the truth tables are long.
+   */
+  bool normalize{ false };
+};
+
+struct costfn_windowing_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Accumulated runtime for cut computation. */
+  stopwatch<>::duration time_cuts{ 0 };
+
+  /*! \brief Accumulated runtime for mffc computation. */
+  stopwatch<>::duration time_mffc{ 0 };
+
+  /*! \brief Accumulated runtime for divisor collection. */
+  stopwatch<>::duration time_divs{ 0 };
+
+  /*! \brief Accumulated runtime for simulation. */
+  stopwatch<>::duration time_sim{ 0 };
+
+  /*! \brief Accumulated runtime for don't care computation. */
+  stopwatch<>::duration time_dont_care{ 0 };
+
+  /*! \brief Total number of leaves. */
+  uint64_t num_leaves{ 0u };
+
+  /*! \brief Total number of divisors. */
+  uint64_t num_divisors{ 0u };
+
+  /*! \brief Number of constructed windows. */
+  uint32_t num_windows{ 0u };
+
+  /*! \brief Total number of MFFC nodes. */
+  uint64_t sum_mffc_size{ 0u };
+
+  void report() const
+  {
+    // clang-format off
+    fmt::print( "[i] costfn_windowing report\n" );
+    fmt::print( "    tot. #leaves = {:5d}, tot. #divs = {:5d}, sum  |MFFC| = {:5d}\n", num_leaves, num_divisors, sum_mffc_size );
+    fmt::print( "    avg. #leaves = {:>5.2f}, avg. #divs = {:>5.2f}, avg. |MFFC| = {:>5.2f}\n", float( num_leaves ) / float( num_windows ), float( num_divisors ) / float( num_windows ), float( sum_mffc_size ) / float( num_windows ) );
+    fmt::print( "    ===== Runtime Breakdown =====\n" );
+    fmt::print( "    Total       : {:>5.2f} secs\n", to_seconds( time_total ) );
+    fmt::print( "      Cut       : {:>5.2f} secs\n", to_seconds( time_cuts ) );
+    fmt::print( "      MFFC      : {:>5.2f} secs\n", to_seconds( time_mffc ) );
+    fmt::print( "      Divs      : {:>5.2f} secs\n", to_seconds( time_divs ) );
+    fmt::print( "      Simulation: {:>5.2f} secs\n", to_seconds( time_sim ) );
+    fmt::print( "      Dont cares: {:>5.2f} secs\n", to_seconds( time_dont_care ) );
+    // clang-format on
+  }
+};
+
+namespace detail
+{
+template<class Ntk, class TT>
+struct cost_aware_problem
+{
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  signal root;
+  std::vector<signal> divs;
+  std::vector<uint32_t> div_ids;    /* positions of divisor truth tables in `tts` */
+  std::vector<node> div_id_to_node; /* maps IDs in `div_ids` to the corresponding node */
+  std::vector<TT> tts;
+  TT care;
+  uint32_t mffc_size;
+  uint32_t max_cost{ std::numeric_limits<uint32_t>::max() };
+};
+
+template<class Ntk, class TT = kitty::dynamic_truth_table>
+class costfn_windowing
+{
+public:
+  using problem_t = cost_aware_problem<Ntk, TT>;
+  using params_t = costfn_windowing_params;
+  using stats_t = costfn_windowing_stats;
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  explicit costfn_windowing( Ntk& ntk, params_t const& ps, stats_t& st )
+      : ntk( ntk ), ps( ps ), st( st ), cps( { ps.max_pis } ), mffc_mgr( ntk ),
+        divs_mgr( ntk, divisor_collector_params( { ps.max_divisors, ps.max_divisors, ps.skip_fanout_limit_for_divisors } ) ),
+        sim( ntk, win.tts, ps.max_pis )
+  {
+    static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+    static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+    static_assert( has_value_v<Ntk>, "Ntk does not implement the value method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+    static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+    static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the substitute_node method" );
+  }
+
+  void init()
+  {
+  }
+
+  std::optional<std::reference_wrapper<problem_t>> operator()( node const& n )
+  {
+    stopwatch t( st.time_total );
+    if ( ntk.fanout_size( n ) > ps.skip_fanout_limit_for_roots )
+    {
+      return std::nullopt; /* skip nodes with too many fanouts */
+    }
+
+    /* compute a cut and collect supported nodes */
+    std::vector<node> leaves = call_with_stopwatch( st.time_cuts, [&]() {
+      return reconvergence_driven_cut<Ntk, false, has_level_v<Ntk>>( ntk, { n }, cps ).first;
+    } );
+    std::vector<node> supported;
+    call_with_stopwatch( st.time_divs, [&]() {
+      divs_mgr.collect_supported_nodes( n, leaves, supported );
+    } );
+
+    /* simulate */
+    call_with_stopwatch( st.time_sim, [&]() {
+      sim.simulate( leaves, supported );
+    } );
+
+    /* mark MFFC nodes and collect divisors */
+    ++mffc_marker;
+    win.mffc_size = call_with_stopwatch( st.time_mffc, [&]() {
+      return mffc_mgr.call_on_mffc_and_count( n, leaves, [&]( node const& n ) {
+        ntk.set_value( n, mffc_marker );
+      } );
+    } );
+    call_with_stopwatch( st.time_divs, [&]() {
+      collect_divisors( leaves, supported );
+    } );
+
+    /* normalize */
+    call_with_stopwatch( st.time_sim, [&]() {
+      if ( ps.normalize )
+      {
+        win.root = normalize_truth_tables() ? !ntk.make_signal( n ) : ntk.make_signal( n );
+      }
+      else
+      {
+        win.root = ntk.make_signal( n );
+      }
+    } );
+
+    /* compute don't cares */
+    call_with_stopwatch( st.time_dont_care, [&]() {
+      if ( ps.use_dont_cares )
+      {
+        win.care = ~satisfiability_dont_cares( ntk, leaves, ps.window_size );
+      }
+      else
+      {
+        win.care = ~kitty::create<TT>( ps.max_pis );
+      }
+    } );
+
+    /* compute cost */
+    win.max_cost = ntk.get_cost( n, win.divs );
+
+    st.num_windows++;
+    st.num_leaves += leaves.size();
+    st.num_divisors += win.divs.size();
+    st.sum_mffc_size += win.mffc_size;
+
+    return win;
+  }
+
+  template<typename res_t>
+  uint32_t gain( problem_t const& prob, res_t const& res ) const
+  {
+    static_assert( is_index_list_v<res_t>, "res_t is not an index_list (windowing engine and resynthesis engine do not match)" );
+    return 1; /* cannot predict the final cost */
+  }
+
+  template<typename res_t>
+  bool update_ntk( problem_t const& prob, res_t const& res )
+  {
+    static_assert( is_index_list_v<res_t>, "res_t is not an index_list (windowing engine and resynthesis engine do not match)" );
+    assert( res.num_pos() == 1 );
+    insert( ntk, std::begin( prob.divs ), std::end( prob.divs ), res, [&]( signal const& g ) {
+      ntk.substitute_node( ntk.get_node( prob.root ), ntk.is_complemented( prob.root ) ? !g : g );
+    } );
+    return true; /* continue optimization */
+  }
+
+  template<typename res_t>
+  bool report( problem_t const& prob, res_t const& res )
+  {
+    static_assert( is_index_list_v<res_t>, "res_t is not an index_list (windowing engine and resynthesis engine do not match)" );
+    assert( res.num_pos() == 1 );
+    fmt::print( "[i] found solution {} for root signal {}{}\n", to_index_list_string( res ), ntk.is_complemented( prob.root ) ? "!" : "", ntk.get_node( prob.root ) );
+    return true;
+  }
+
+private:
+  void collect_divisors( std::vector<node> const& leaves, std::vector<node> const& supported )
+  {
+    win.divs.clear();
+    win.div_ids.clear();
+
+    uint32_t i{ 1 };
+    for ( auto const& l : leaves )
+    {
+      win.div_ids.emplace_back( i++ );
+      win.divs.emplace_back( ntk.make_signal( l ) );
+    }
+
+    i = ps.max_pis + 1;
+    for ( auto const& n : supported )
+    {
+      if ( ntk.value( n ) != mffc_marker ) /* not in MFFC, not root */
+      {
+        win.div_ids.emplace_back( i );
+        win.divs.emplace_back( ntk.make_signal( n ) );
+      }
+      ++i;
+    }
+    assert( i == win.tts.size() );
+  }
+
+  bool normalize_truth_tables()
+  {
+    assert( win.divs.size() == win.div_ids.size() );
+    for ( auto i = 0u; i < win.divs.size(); ++i )
+    {
+      if ( kitty::get_bit( win.tts.at( win.div_ids.at( i ) ), 0 ) )
+      {
+        win.tts.at( win.div_ids.at( i ) ) = ~win.tts.at( win.div_ids.at( i ) );
+        win.divs.at( i ) = !win.divs.at( i );
+      }
+    }
+
+    if ( kitty::get_bit( win.tts.back(), 0 ) )
+    {
+      win.tts.back() = ~win.tts.back();
+      return true;
+    }
+    else
+    {
+      return false;
+    }
+  }
+
+private:
+  Ntk& ntk;
+  problem_t win;
+  params_t const& ps;
+  stats_t& st;
+  reconvergence_driven_cut_parameters const cps;
+  typename mockturtle::detail::node_mffc_inside<Ntk> mffc_mgr; // TODO: namespaces can be removed when we move out of experimental::
+  divisor_collector<Ntk> divs_mgr;
+  window_simulator<Ntk, TT> sim;
+  uint32_t mffc_marker{ 0u };
+  std::shared_ptr<typename network_events<Ntk>::modified_event_type> lazy_update_event;
+}; /* costfn_windowing */
+
+template<class Ntk, class TT, class ResynEngine>
+class costfn_resynthesis
+{
+public:
+  using problem_t = cost_aware_problem<Ntk, TT>;
+  using res_t = typename ResynEngine::index_list_t;
+  using params_t = typename ResynEngine::params;
+  using stats_t = typename ResynEngine::stats;
+
+  explicit costfn_resynthesis( Ntk const& ntk, params_t const& ps, stats_t& st )
+      : ntk( ntk ), engine( ntk, ps, st )
+  {
+    static_assert( has_cost_v<Ntk>, "Ntk does not implement the get_cost method" );
+  }
+
+  void init()
+  {
+  }
+
+  std::optional<res_t> operator()( problem_t& prob )
+  {
+    return engine( prob.tts.back(), prob.care, prob.divs, std::begin( prob.div_ids ), std::end( prob.div_ids ), prob.tts, prob.max_cost );
+  }
+
+private:
+  Ntk const& ntk;
+  typename ResynEngine::stats rst;
+  ResynEngine engine;
+}; /* costfn_resynthesis */
+
+} /* namespace detail */
+
+using cost_generic_resub_params = boolean_optimization_params<costfn_windowing_params, cost_resyn_params>;
+using cost_generic_resub_stats = boolean_optimization_stats<costfn_windowing_stats, cost_resyn_stats>;
+
+/*! \brief Cost-generic resubstitution algorithm.
+ *
+ * This algorithm creates a reconvergence-driven window for each node in the
+ * network, collects divisors, and builds the resynthesis problem. A search core
+ * then collects all the resubstitution candidates with the same functionality as
+ * the target. The candidate with the lowest cost will then replace the MFFC
+ * of the window.
+ *
+ * \param ntk Network
+ * \param cost_fn Customized cost function
+ * \param ps Optimization params
+ * \param pst Optimization statistics
+ */
+template<class Ntk, class CostFn>
+void cost_generic_resub( Ntk& ntk, CostFn cost_fn, cost_generic_resub_params const& ps, cost_generic_resub_stats* pst = nullptr )
+{
+  fanout_view fntk( ntk );
+  cost_view viewed( fntk, cost_fn );
+  using Viewed = decltype( viewed );
+  using TT = typename kitty::dynamic_truth_table;
+  using windowing_t = typename detail::costfn_windowing<Viewed, TT>;
+  using engine_t = cost_resyn<Viewed, TT>;
+  using resyn_t = typename detail::costfn_resynthesis<Viewed, TT, engine_t>;
+  using opt_t = typename detail::boolean_optimization_impl<Viewed, windowing_t, resyn_t>;
+
+  cost_generic_resub_stats st;
+  opt_t p( viewed, ps, st );
+  p.run();
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} // namespace mockturtle::experimental
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/experimental/cost_resyn.hpp b/include/mockturtle/algorithms/experimental/cost_resyn.hpp
new file mode 100644
index 0000000..54035f1
--- /dev/null
+++ b/include/mockturtle/algorithms/experimental/cost_resyn.hpp
@@ -0,0 +1,1289 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cost_resyn.hpp
+  \brief Solver of cost-aware resynthesis problem.
+         Given a resynthesis problem and the cost function, returns
+         the solution with (1) correct functionality (2) lower cost.
+
+         This solver is cost-generic.
+
+  \author Hanyu Wang
+*/
+
+#pragma once
+
+#include "../../algorithms/cleanup.hpp"
+#include "../../utils/index_list.hpp"
+
+#include <algorithm>
+#include <optional>
+#include <queue>
+#include <type_traits>
+#include <unordered_set>
+#include <vector>
+
+namespace mockturtle::experimental
+{
+
+struct cost_resyn_params
+{
+  /* maximum number of feasible solutions to collect */
+  uint32_t max_solutions{ 1000u };
+};
+
+struct cost_resyn_stats
+{
+  /* time for cost view the solution network */
+  stopwatch<>::duration time_eval{ 0 };
+
+  /* time for searching the equivalent network */
+  stopwatch<>::duration time_search{ 0 };
+
+  /* number of solutions */
+  uint32_t num_solutions{ 0 };
+
+  /* number of problems */
+  uint32_t num_problems{ 0 };
+
+  /* number of solution with 0,1,2,3 insertions */
+  uint32_t num_resub[4]{ 0 };
+
+  /* size of the forest of feasible solutions */
+  uint32_t size_forest{ 0 };
+
+  /* number of root (feasible solutions) */
+  uint32_t num_roots{ 0 };
+
+  /* number of total gains */
+  uint32_t num_gain{ 0 };
+
+  /* data */
+  void report() const
+  {
+    fmt::print( "[i]         <cost_resyn>\n" );
+    fmt::print( "[i]             Evaluation      : {:>5.2f} secs\n", to_seconds( time_eval ) );
+    fmt::print( "[i]             Searching        : {:>5.2f} secs\n", to_seconds( time_search ) );
+    fmt::print( "[i]             # Problem        : {}\n", num_problems );
+    fmt::print( "[i]             Avg. forest size : {:>5.2f}\n", (float)size_forest / num_problems );
+    fmt::print( "[i]             Avg. num solution: {:>5.2f}\n", (float)num_roots / num_problems );
+    fmt::print( "[i]             Opt. ratio       : {:>5.2f}%\n", (float)num_solutions / num_problems * 100 );
+    fmt::print( "[i]             0 - resub        : {:>5.2f}\n", (float)num_resub[0] / num_problems );
+    fmt::print( "[i]             1 - resub        : {:>5.2f}\n", (float)num_resub[1] / num_problems );
+    fmt::print( "[i]             2 - resub        : {:>5.2f}\n", (float)num_resub[2] / num_problems );
+    fmt::print( "[i]             3 - resub        : {:>5.2f}\n", (float)num_resub[3] / num_problems );
+    fmt::print( "[i]             Gain             : {:>5.2f}\n", (float)num_gain / num_problems );
+  }
+};
+
+template<class Ntk, class TT>
+class cost_resyn
+{
+public:
+  using params = cost_resyn_params;
+  using stats = cost_resyn_stats;
+  using signal = typename Ntk::signal;
+  using node = typename Ntk::node;
+  using context_t = typename Ntk::context_t;
+  using index_list_t = large_xag_index_list;
+  using truth_table_t = TT;
+
+private:
+  struct unate_lit
+  {
+    unate_lit( uint32_t l )
+        : lit( l )
+    {
+    }
+
+    bool operator==( unate_lit const& other ) const
+    {
+      return lit == other.lit;
+    }
+
+    uint32_t lit;
+    uint32_t score{ 0 };
+  };
+  struct fanin_pair
+  {
+    fanin_pair( uint32_t l1, uint32_t l2 )
+        : lit1( l1 < l2 ? l1 : l2 ), lit2( l1 < l2 ? l2 : l1 )
+    {
+    }
+
+    fanin_pair( uint32_t l1, uint32_t l2, bool is_xor )
+        : lit1( l1 > l2 ? l1 : l2 ), lit2( l1 > l2 ? l2 : l1 )
+    {
+      (void)is_xor;
+    }
+
+    bool operator==( fanin_pair const& other ) const
+    {
+      return lit1 == other.lit1 && lit2 == other.lit2;
+    }
+
+    uint32_t lit1, lit2;
+    uint32_t score{ 0 };
+  };
+
+  inline TT const& get_div( uint32_t idx ) const
+  {
+    return ( *ptts )[divisors[idx]];
+  }
+
+  uint32_t eval_result( Ntk& forest, index_list_t const& il )
+  {
+    uint32_t eval = 0u;
+    // insert il to forest, this might not be applicable to cost related to fanout size!
+    insert( forest, std::begin( forest_leaves ), std::end( forest_leaves ), il, [&]( signal const& g ) {
+      forest.incr_trav_id();
+      eval = forest.get_cost( forest.get_node( g ), forest_leaves );
+    } );
+    return eval; // the cost of the whole network
+  }
+
+  bool update_result( Ntk& forest, index_list_t const& il )
+  {
+    st.num_roots += 1u;
+    uint32_t curr_cost = eval_result( forest, il );
+    if ( curr_cost < best_cost )
+    {
+      best_cost = curr_cost;
+      index_list = il;
+      return true;
+    }
+    return false;
+  }
+
+  bool push_solution( index_list_t const& il )
+  {
+    ils.emplace_back( il );               /* push the solution to the solution set */
+    return ils.size() < ps.max_solutions; /* continue if capacity allows */
+  }
+
+  template<bool pol1, bool pol2>
+  void collect_unate_pairs_detail( uint32_t div1, uint32_t div2 )
+  {
+    /* check intersection with off-set; additionally check intersection with on-set is not empty (otherwise it's useless) */
+    if ( kitty::intersection_is_empty<TT, pol1, pol2>( get_div( div1 ), get_div( div2 ), on_off_sets[0] ) && !kitty::intersection_is_empty<TT, pol1, pol2>( get_div( div1 ), get_div( div2 ), on_off_sets[1] ) )
+    {
+      pos_unate_pairs.emplace_back( ( div1 << 1 ) + (uint32_t)( !pol1 ), ( div2 << 1 ) + (uint32_t)( !pol2 ) );
+    }
+    /* check intersection with on-set; additionally check intersection with off-set is not empty (otherwise it's useless) */
+    else if ( kitty::intersection_is_empty<TT, pol1, pol2>( get_div( div1 ), get_div( div2 ), on_off_sets[1] ) && !kitty::intersection_is_empty<TT, pol1, pol2>( get_div( div1 ), get_div( div2 ), on_off_sets[0] ) )
+    {
+      neg_unate_pairs.emplace_back( ( div1 << 1 ) + (uint32_t)( !pol1 ), ( div2 << 1 ) + (uint32_t)( !pol2 ) );
+    }
+  }
+
+  /* Sort the unate literals by the number of minterms in the intersection.
+     - For `pos_unate_lits`, `on_off` = 1, sort by intersection with on-set;
+     - For `neg_unate_lits`, `on_off` = 0, sort by intersection with off-set
+   */
+  void sort_unate_lits( std::vector<unate_lit>& pos_unate_lits, uint32_t on_off )
+  {
+    for ( auto& l : pos_unate_lits )
+    {
+      l.score = kitty::count_ones( ( l.lit & 0x1 ? ~get_div( l.lit >> 1 ) : get_div( l.lit >> 1 ) ) & on_off_sets[on_off] );
+    }
+    std::stable_sort( pos_unate_lits.begin(), pos_unate_lits.end(), [&]( unate_lit const& l1, unate_lit const& l2 ) {
+      return l1.score > l2.score; // descending order
+    } );
+  }
+
+  void sort_unate_pairs( std::vector<fanin_pair>& unate_pairs, uint32_t on_off )
+  {
+    for ( auto& p : unate_pairs )
+    {
+      p.score = ( p.lit1 > p.lit2 ) ? kitty::count_ones( ( ( p.lit1 & 0x1 ? ~get_div( p.lit1 >> 1 ) : get_div( p.lit1 >> 1 ) ) ^ ( p.lit2 & 0x1 ? ~get_div( p.lit2 >> 1 ) : get_div( p.lit2 >> 1 ) ) ) & on_off_sets[on_off] )
+                                    : kitty::count_ones( ( p.lit1 & 0x1 ? ~get_div( p.lit1 >> 1 ) : get_div( p.lit1 >> 1 ) ) & ( p.lit2 & 0x1 ? ~get_div( p.lit2 >> 1 ) : get_div( p.lit2 >> 1 ) ) & on_off_sets[on_off] );
+    }
+    std::stable_sort( unate_pairs.begin(), unate_pairs.end(), [&]( fanin_pair const& p1, fanin_pair const& p2 ) {
+      return p1.score > p2.score; // descending order
+    } );
+  }
+
+  std::optional<index_list_t> find_and_detail( std::vector<unate_lit> const& pos_unate_lits, uint32_t on_off )
+  {
+    for ( auto i = 0u; i < pos_unate_lits.size(); ++i )
+    {
+      uint32_t const& lit1 = pos_unate_lits[i].lit;
+      if ( pos_unate_lits[i].score * 2 < num_bits[on_off] )
+      {
+        break;
+      }
+      for ( auto j = i + 1; j < pos_unate_lits.size(); ++j )
+      {
+        uint32_t const& lit2 = pos_unate_lits[j].lit;
+        if ( pos_unate_lits[i].score + pos_unate_lits[j].score < num_bits[on_off] )
+        {
+          break;
+        }
+        auto const ntt1 = lit1 & 0x1 ? get_div( lit1 >> 1 ) : ~get_div( lit1 >> 1 );
+        auto const ntt2 = lit2 & 0x1 ? get_div( lit2 >> 1 ) : ~get_div( lit2 >> 1 );
+        if ( kitty::intersection_is_empty( ntt1, ntt2, on_off_sets[on_off] ) )
+        {
+          index_list_t il;
+          il.clear();
+          il.add_inputs( divisors.size() - 1 );
+          auto const new_lit = il.add_and( ( lit1 ^ 0x1 ), ( lit2 ^ 0x1 ) );
+          il.add_output( new_lit + on_off );
+          if ( !push_solution( il ) )
+            return std::nullopt;
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  template<bool is_xor = false>
+  std::optional<index_list_t> find_and_and_helper( std::vector<unate_lit>& pos_unate_lits, std::vector<fanin_pair>& unate_pairs, uint32_t on_off )
+  {
+    for ( auto i = 0u; i < pos_unate_lits.size(); ++i )
+    {
+      uint32_t const& lit1 = pos_unate_lits[i].lit;
+      for ( auto j = 0u; j < unate_pairs.size(); ++j )
+      {
+        fanin_pair const& pair2 = unate_pairs[j];
+        if ( pos_unate_lits[i].score + pair2.score < num_bits[on_off] )
+        {
+          break;
+        }
+        auto const ntt1 = lit1 & 0x1 ? get_div( lit1 >> 1 ) : ~get_div( lit1 >> 1 );
+        TT ntt2;
+        if constexpr ( is_xor )
+        {
+          ntt2 = ( pair2.lit1 & 0x1 ? get_div( pair2.lit1 >> 1 ) : ~get_div( pair2.lit1 >> 1 ) ) ^ ( pair2.lit2 & 0x1 ? ~get_div( pair2.lit2 >> 1 ) : get_div( pair2.lit2 >> 1 ) );
+        }
+        else
+        {
+          ntt2 = ( pair2.lit1 & 0x1 ? get_div( pair2.lit1 >> 1 ) : ~get_div( pair2.lit1 >> 1 ) ) | ( pair2.lit2 & 0x1 ? get_div( pair2.lit2 >> 1 ) : ~get_div( pair2.lit2 >> 1 ) );
+        }
+        if ( kitty::intersection_is_empty( ntt1, ntt2, on_off_sets[on_off] ) )
+        {
+          index_list_t il;
+          il.clear();
+          il.add_inputs( divisors.size() - 1 );
+          uint32_t new_lit1;
+          if constexpr ( is_xor )
+          {
+            new_lit1 = il.add_xor( pair2.lit1, pair2.lit2 );
+          }
+          else
+          {
+            new_lit1 = il.add_and( pair2.lit1, pair2.lit2 );
+          }
+          auto const new_lit2 = il.add_and( ( lit1 ^ 0x1 ), new_lit1 ^ 0x1 );
+          il.add_output( new_lit2 + on_off );
+          if ( !push_solution( il ) )
+            return std::nullopt;
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  template<bool left_xor = false, bool right_xor = false>
+  std::optional<index_list_t> find_and_and_and_helper( std::vector<fanin_pair>& unate_pairs_1, std::vector<fanin_pair>& unate_pairs_2, uint32_t on_off )
+  {
+    for ( auto i = 0u; i < unate_pairs_1.size(); ++i )
+    {
+      fanin_pair const& pair1 = unate_pairs_1[i];
+      if ( pair1.score * 2 < num_bits[on_off] )
+      {
+        break;
+      }
+      for ( auto j = i + 1; j < unate_pairs_2.size(); ++j )
+      {
+        fanin_pair const& pair2 = unate_pairs_2[j];
+        if ( pair1.score + pair2.score < num_bits[on_off] )
+        {
+          break;
+        }
+        TT ntt1, ntt2;
+        if constexpr ( left_xor )
+        {
+          ntt1 = ( pair1.lit1 & 0x1 ? get_div( pair1.lit1 >> 1 ) : ~get_div( pair1.lit1 >> 1 ) ) ^ ( pair1.lit2 & 0x1 ? ~get_div( pair1.lit2 >> 1 ) : get_div( pair1.lit2 >> 1 ) );
+        }
+        else
+        {
+          ntt1 = ( pair1.lit1 & 0x1 ? get_div( pair1.lit1 >> 1 ) : ~get_div( pair1.lit1 >> 1 ) ) | ( pair1.lit2 & 0x1 ? get_div( pair1.lit2 >> 1 ) : ~get_div( pair1.lit2 >> 1 ) );
+        }
+        if constexpr ( right_xor )
+        {
+          ntt2 = ( pair2.lit1 & 0x1 ? get_div( pair2.lit1 >> 1 ) : ~get_div( pair2.lit1 >> 1 ) ) ^ ( pair2.lit2 & 0x1 ? ~get_div( pair2.lit2 >> 1 ) : get_div( pair2.lit2 >> 1 ) );
+        }
+        else
+        {
+          ntt2 = ( pair2.lit1 & 0x1 ? get_div( pair2.lit1 >> 1 ) : ~get_div( pair2.lit1 >> 1 ) ) | ( pair2.lit2 & 0x1 ? get_div( pair2.lit2 >> 1 ) : ~get_div( pair2.lit2 >> 1 ) );
+        }
+        if ( kitty::intersection_is_empty( ntt1, ntt2, on_off_sets[on_off] ) )
+        {
+          index_list_t il;
+          il.clear();
+          il.add_inputs( divisors.size() - 1 );
+          uint32_t fanin_lit1, fanin_lit2;
+          if constexpr ( left_xor )
+          {
+            fanin_lit1 = il.add_xor( pair1.lit1, pair1.lit2 );
+          }
+          else
+          {
+            fanin_lit1 = il.add_and( pair1.lit1, pair1.lit2 );
+          }
+          if constexpr ( right_xor )
+          {
+            fanin_lit2 = il.add_xor( pair2.lit1, pair2.lit2 );
+          }
+          else
+          {
+            fanin_lit2 = il.add_and( pair2.lit1, pair2.lit2 );
+          }
+          uint32_t const output_lit = il.add_and( fanin_lit1 ^ 0x1, fanin_lit2 ^ 0x1 );
+          il.add_output( output_lit + on_off );
+          if ( !push_solution( il ) )
+            return std::nullopt;
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  void prepare_clear()
+  {
+    pos_unate_lits.clear();
+    neg_unate_lits.clear();
+    binate_divs.clear();
+    pos_unate_pairs.clear();
+    neg_unate_pairs.clear();
+    pos_unate_xor_pairs.clear();
+    neg_unate_xor_pairs.clear();
+    mem_xor.clear();
+    mem_xor_xor.clear();
+    mem_xor_and.clear();
+    has_xor_xor = false;
+    has_xor = false;
+    has_xor_and = false;
+    has_unateness = false;
+    has_and_pairs = false;
+    has_xor_pairs = false;
+    has_lit_xor = false;
+    has_init = false;
+
+    index_list = std::nullopt;
+    forest_leaves.clear();
+    candidates.clear();
+    forest_root = std::nullopt;
+    div_costs.clear();
+    isConst = false;
+
+    ils.clear();
+  }
+
+  void prepare_task()
+  {
+    assert( has_init == false );
+    num_bits[0] = kitty::count_ones( on_off_sets[0] ); /* off-set */
+    num_bits[1] = kitty::count_ones( on_off_sets[1] ); /* on-set */
+    has_init = true;
+  }
+
+  void prepare_unateness()
+  {
+    assert( has_unateness == false && "already have unateness" );
+    if ( has_init == false )
+    {
+      prepare_task();
+    }
+    for ( auto v = 1u; v < divisors.size(); ++v )
+    {
+      bool unateness[4] = { false, false, false, false };
+      /* check intersection with off-set */
+      if ( kitty::intersection_is_empty<TT, 1, 1>( get_div( v ), on_off_sets[0] ) )
+      {
+        pos_unate_lits.emplace_back( v << 1 );
+        unateness[0] = true;
+      }
+      else if ( kitty::intersection_is_empty<TT, 0, 1>( get_div( v ), on_off_sets[0] ) )
+      {
+        pos_unate_lits.emplace_back( ( v << 1 ) | 0x1 );
+        unateness[1] = true;
+      }
+      /* check intersection with on-set */
+      if ( kitty::intersection_is_empty<TT, 1, 1>( get_div( v ), on_off_sets[1] ) )
+      {
+        neg_unate_lits.emplace_back( v << 1 );
+        unateness[2] = true;
+      }
+      else if ( kitty::intersection_is_empty<TT, 0, 1>( get_div( v ), on_off_sets[1] ) )
+      {
+        neg_unate_lits.emplace_back( ( v << 1 ) | 0x1 );
+        unateness[3] = true;
+      }
+      /* useless unate literal */
+      if ( ( unateness[0] && unateness[2] ) || ( unateness[1] && unateness[3] ) )
+      {
+        pos_unate_lits.pop_back();
+        neg_unate_lits.pop_back();
+      }
+      /* binate divisor */
+      else if ( !unateness[0] && !unateness[1] && !unateness[2] && !unateness[3] )
+      {
+        binate_divs.emplace_back( v );
+      }
+    }
+    sort_unate_lits( pos_unate_lits, 1 );
+    sort_unate_lits( neg_unate_lits, 0 );
+    has_unateness = true;
+  }
+
+  void prepare_xor()
+  {
+    assert( has_xor == false );
+    for ( auto i = 1u; i < divisors.size(); i++ )
+    {
+      mem_xor[on_off_sets[1] ^ get_div( i )] = i;
+    }
+    has_xor = true;
+  }
+
+  void prepare_xor_xor()
+  {
+    assert( has_xor_xor == false );
+    for ( auto i = 1u; i < divisors.size(); i++ )
+    {
+      for ( auto j = i + 1; j < divisors.size(); j++ )
+      {
+        mem_xor_xor[get_div( i ) ^ get_div( j ) ^ on_off_sets[1]] = i * divisors.size() + j;
+      }
+    }
+    has_xor_xor = true;
+  }
+
+  void prepare_xor_and()
+  {
+    assert( has_xor_and == false );
+    for ( auto i = 1u; i < divisors.size(); i++ )
+    {
+      for ( auto j = i + 1; j < divisors.size(); j++ )
+      {
+        for ( auto on_off_1 = 0u; on_off_1 < 2; on_off_1++ )
+        {
+          for ( auto on_off_2 = 0u; on_off_2 < 2; on_off_2++ )
+          {
+            auto const tt = ( on_off_1 ? ~get_div( i ) : get_div( i ) ) & ( on_off_2 ? ~get_div( j ) : get_div( j ) );
+            mem_xor_and[tt ^ on_off_sets[1]] = ( ( i << 1 ) + on_off_1 ) * 2 * divisors.size() + ( ( j << 1 ) + on_off_2 );
+          }
+        }
+      }
+    }
+    has_xor_and = true;
+  }
+
+  void prepare_and_pairs()
+  {
+    if ( has_unateness == false )
+    {
+      prepare_unateness();
+    }
+    for ( auto i = 0u; i < binate_divs.size(); ++i )
+    {
+      for ( auto j = i + 1; j < binate_divs.size(); ++j )
+      {
+        collect_unate_pairs_detail<1, 1>( binate_divs[i], binate_divs[j] );
+        collect_unate_pairs_detail<0, 1>( binate_divs[i], binate_divs[j] );
+        collect_unate_pairs_detail<1, 0>( binate_divs[i], binate_divs[j] );
+        collect_unate_pairs_detail<0, 0>( binate_divs[i], binate_divs[j] );
+      }
+    };
+    sort_unate_pairs( pos_unate_pairs, 1 );
+    sort_unate_pairs( neg_unate_pairs, 0 );
+    has_and_pairs = true;
+  }
+
+  void prepare_xor_pairs()
+  {
+    if ( has_unateness == false )
+    {
+      prepare_unateness();
+    }
+    for ( auto i = 0u; i < binate_divs.size(); ++i )
+    {
+      for ( auto j = i + 1; j < binate_divs.size(); ++j )
+      {
+        auto const tt_xor = get_div( binate_divs[i] ) ^ get_div( binate_divs[j] );
+        /* check intersection with off-set; additionally check intersection with on-set is not empty (otherwise it's useless) */
+        if ( kitty::intersection_is_empty<TT, 1, 1>( tt_xor, on_off_sets[0] ) && !kitty::intersection_is_empty<TT, 1, 1>( tt_xor, on_off_sets[1] ) )
+        {
+          pos_unate_xor_pairs.emplace_back( binate_divs[i] << 1, binate_divs[j] << 1, true );
+        }
+        if ( kitty::intersection_is_empty<TT, 0, 1>( tt_xor, on_off_sets[0] ) && !kitty::intersection_is_empty<TT, 0, 1>( tt_xor, on_off_sets[1] ) )
+        {
+          pos_unate_xor_pairs.emplace_back( ( binate_divs[i] << 1 ) + 1, binate_divs[j] << 1, true );
+        }
+        /* check intersection with on-set; additionally check intersection with off-set is not empty (otherwise it's useless) */
+        if ( kitty::intersection_is_empty<TT, 1, 1>( tt_xor, on_off_sets[1] ) && !kitty::intersection_is_empty<TT, 1, 1>( tt_xor, on_off_sets[0] ) )
+        {
+          neg_unate_xor_pairs.emplace_back( binate_divs[i] << 1, binate_divs[j] << 1, true );
+        }
+        if ( kitty::intersection_is_empty<TT, 0, 1>( tt_xor, on_off_sets[1] ) && !kitty::intersection_is_empty<TT, 0, 1>( tt_xor, on_off_sets[0] ) )
+        {
+          neg_unate_xor_pairs.emplace_back( ( binate_divs[i] << 1 ) + 1, binate_divs[j] << 1, true );
+        }
+      }
+    }
+    sort_unate_pairs( pos_unate_xor_pairs, 1 );
+    sort_unate_pairs( neg_unate_xor_pairs, 0 );
+    has_xor_pairs = true;
+  }
+
+  std::optional<index_list_t> find_wire()
+  {
+    if ( has_init == false )
+    {
+      prepare_task();
+    }
+    if ( num_bits[0] == 0 )
+    {
+      index_list_t il;
+      il.clear();
+      il.add_inputs( divisors.size() - 1 );
+      il.add_output( 1 );
+      if ( !push_solution( il ) )
+        return std::nullopt;
+      isConst = true;
+    }
+    if ( num_bits[1] == 0 )
+    {
+      index_list_t il;
+      il.clear();
+      il.add_inputs( divisors.size() - 1 );
+      il.add_output( 0 );
+      if ( !push_solution( il ) )
+        return std::nullopt;
+      isConst = true;
+    }
+    for ( auto v = 1u; v < divisors.size(); ++v )
+    {
+      if ( get_div( v ) == on_off_sets[1] )
+      {
+        index_list_t il;
+        il.clear();
+        il.add_inputs( divisors.size() - 1 );
+        il.add_output( v << 1 );
+        if ( !push_solution( il ) )
+          return std::nullopt;
+      }
+      if ( get_div( v ) == on_off_sets[0] )
+      {
+        index_list_t il;
+        il.clear();
+        il.add_inputs( divisors.size() - 1 );
+        il.add_output( ( v << 1 ) + 1 );
+        if ( !push_solution( il ) )
+          return std::nullopt;
+      }
+    }
+    return std::nullopt;
+  }
+
+  std::optional<index_list_t> find_and()
+  {
+    if ( has_unateness == false )
+    {
+      prepare_unateness();
+    }
+    return find_and_detail( neg_unate_lits, 0 );
+  }
+
+  std::optional<index_list_t> find_or()
+  {
+    if ( has_unateness == false )
+    {
+      prepare_unateness();
+    }
+    return find_and_detail( pos_unate_lits, 1 );
+  }
+
+  std::optional<index_list_t> find_xor()
+  {
+    if ( has_xor == false )
+    {
+      prepare_xor();
+    }
+    for ( auto i = 1u; i < divisors.size(); ++i )
+    {
+      auto const tt = get_div( i );
+      if ( mem_xor.find( tt ) != mem_xor.end() )
+      {
+        index_list_t il;
+        il.clear();
+        il.add_inputs( divisors.size() - 1 );
+        il.add_output( il.add_xor( ( i << 1 ), mem_xor[tt] << 1 ) );
+        if ( !push_solution( il ) )
+          return std::nullopt;
+      }
+      if ( mem_xor.find( ~tt ) != mem_xor.end() )
+      {
+        index_list_t il;
+        il.clear();
+        il.add_inputs( divisors.size() - 1 );
+        il.add_output( il.add_xor( ( i << 1 ) + 1, mem_xor[~tt] << 1 ) );
+        if ( !push_solution( il ) )
+          return std::nullopt;
+      }
+    }
+    return std::nullopt;
+  }
+
+  std::optional<index_list_t> find_or_and()
+  {
+    if ( has_and_pairs == false )
+    {
+      prepare_and_pairs();
+    }
+    return find_and_and_helper( pos_unate_lits, pos_unate_pairs, 1 );
+  }
+
+  std::optional<index_list_t> find_and_or()
+  {
+    if ( has_and_pairs == false )
+    {
+      prepare_and_pairs();
+    }
+    return find_and_and_helper( neg_unate_lits, neg_unate_pairs, 0 );
+  }
+
+  std::optional<index_list_t> find_and_and()
+  {
+    if ( has_unateness == false )
+    {
+      prepare_unateness();
+    }
+    for ( auto i = 0u; i < pos_unate_lits.size(); ++i )
+    {
+      if ( pos_unate_lits[i].score * 3 < num_bits[1] )
+      {
+        break;
+      }
+      uint32_t const& lit1 = pos_unate_lits[i].lit;
+      for ( auto j = i + 1u; j < pos_unate_lits.size(); ++j )
+      {
+        if ( pos_unate_lits[i].score + pos_unate_lits[j].score * 2 < num_bits[1] )
+        {
+          break;
+        }
+        uint32_t const& lit2 = pos_unate_lits[j].lit;
+        auto const ntt1 = lit1 & 0x1 ? ~get_div( lit1 >> 1 ) : get_div( lit1 >> 1 );
+        auto const ntt2 = lit2 & 0x1 ? ~get_div( lit2 >> 1 ) : get_div( lit2 >> 1 );
+        TT const tt = ntt1 | ntt2;
+        for ( auto k = j + 1u; k < pos_unate_lits.size(); ++k )
+        {
+          uint32_t const& lit3 = pos_unate_lits[k].lit;
+          if ( pos_unate_lits[i].score + pos_unate_lits[j].score + pos_unate_lits[k].score < num_bits[1] )
+          {
+            break;
+          }
+          auto const ntt3 = lit3 & 0x1 ? ~get_div( lit3 >> 1 ) : get_div( lit3 >> 1 );
+          if ( ( tt | ntt3 ) == on_off_sets[1] )
+          {
+            {
+              index_list_t il;
+              il.clear();
+              il.add_inputs( divisors.size() - 1 );
+              auto const new_lit1 = il.add_and( ( lit1 ^ 0x1 ), ( lit2 ^ 0x1 ) );
+              auto const new_lit2 = il.add_and( ( lit3 ^ 0x1 ), new_lit1 );
+              il.add_output( new_lit2 + 1 );
+              if ( !push_solution( il ) )
+                return std::nullopt;
+            }
+            {
+              index_list_t il;
+              il.clear();
+              il.add_inputs( divisors.size() - 1 );
+              auto const new_lit1 = il.add_and( ( lit1 ^ 0x1 ), ( lit3 ^ 0x1 ) );
+              auto const new_lit2 = il.add_and( ( lit2 ^ 0x1 ), new_lit1 );
+              il.add_output( new_lit2 + 1 );
+              if ( !push_solution( il ) )
+                return std::nullopt;
+            }
+            {
+              index_list_t il;
+              il.clear();
+              il.add_inputs( divisors.size() - 1 );
+              auto const new_lit1 = il.add_and( ( lit2 ^ 0x1 ), ( lit3 ^ 0x1 ) );
+              auto const new_lit2 = il.add_and( ( lit1 ^ 0x1 ), new_lit1 );
+              il.add_output( new_lit2 + 1 );
+              if ( !push_solution( il ) )
+                return std::nullopt;
+            }
+          }
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  std::optional<index_list_t> find_or_or()
+  {
+    if ( has_unateness == false )
+    {
+      prepare_unateness();
+    }
+    for ( auto i = 0u; i < neg_unate_lits.size(); ++i )
+    {
+      if ( neg_unate_lits[i].score * 3 < num_bits[0] )
+      {
+        break;
+      }
+      uint32_t const& lit1 = neg_unate_lits[i].lit;
+      for ( auto j = i + 1u; j < neg_unate_lits.size(); ++j )
+      {
+        if ( neg_unate_lits[i].score + neg_unate_lits[j].score * 2 < num_bits[0] )
+        {
+          break;
+        }
+        uint32_t const& lit2 = neg_unate_lits[j].lit;
+        auto const ntt1 = lit1 & 0x1 ? ~get_div( lit1 >> 1 ) : get_div( lit1 >> 1 );
+        auto const ntt2 = lit2 & 0x1 ? ~get_div( lit2 >> 1 ) : get_div( lit2 >> 1 );
+        TT const tt = ntt1 | ntt2;
+        for ( auto k = j + 1u; k < neg_unate_lits.size(); ++k )
+        {
+          uint32_t const& lit3 = neg_unate_lits[k].lit;
+          if ( neg_unate_lits[i].score + neg_unate_lits[j].score + neg_unate_lits[k].score < num_bits[0] )
+          {
+            break;
+          }
+
+          auto const ntt3 = lit3 & 0x1 ? ~get_div( lit3 >> 1 ) : get_div( lit3 >> 1 );
+          if ( ( tt | ntt3 ) == on_off_sets[0] )
+          {
+            {
+              index_list_t il;
+              il.clear();
+              il.add_inputs( divisors.size() - 1 );
+              auto const new_lit1 = il.add_and( ( lit1 ^ 0x1 ), ( lit2 ^ 0x1 ) );
+              auto const new_lit2 = il.add_and( ( lit3 ^ 0x1 ), new_lit1 );
+              il.add_output( new_lit2 );
+              if ( !push_solution( il ) )
+                return std::nullopt;
+            }
+            {
+              index_list_t il;
+              il.clear();
+              il.add_inputs( divisors.size() - 1 );
+              auto const new_lit1 = il.add_and( ( lit1 ^ 0x1 ), ( lit3 ^ 0x1 ) );
+              auto const new_lit2 = il.add_and( ( lit2 ^ 0x1 ), new_lit1 );
+              il.add_output( new_lit2 );
+              if ( !push_solution( il ) )
+                return std::nullopt;
+            }
+            {
+              index_list_t il;
+              il.clear();
+              il.add_inputs( divisors.size() - 1 );
+              auto const new_lit1 = il.add_and( ( lit2 ^ 0x1 ), ( lit3 ^ 0x1 ) );
+              auto const new_lit2 = il.add_and( ( lit1 ^ 0x1 ), new_lit1 );
+              il.add_output( new_lit2 );
+              if ( !push_solution( il ) )
+                return std::nullopt;
+            }
+          }
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  std::optional<index_list_t> find_and_xor()
+  {
+    if ( has_xor_pairs == false )
+    {
+      prepare_xor_pairs();
+    }
+    auto ret = find_and_and_helper<true>( pos_unate_lits, pos_unate_xor_pairs, 1 );
+    if ( !ret )
+      ret = find_and_and_helper<true>( neg_unate_lits, neg_unate_xor_pairs, 0 );
+    return ret;
+  }
+
+  std::optional<index_list_t> find_xor_xor()
+  {
+    if ( has_xor == false )
+    {
+      prepare_xor();
+    }
+    for ( auto i = 1u; i < divisors.size(); i++ )
+    {
+      for ( auto j = i + 1; j < divisors.size(); j++ )
+      {
+        auto const tt = get_div( i ) ^ get_div( j );
+        if ( mem_xor.find( tt ) != mem_xor.end() )
+        {
+          if ( mem_xor[tt] == i )
+            continue;
+          if ( mem_xor[tt] == j )
+            continue;
+          index_list_t il;
+          {
+            il.clear();
+            il.add_inputs( divisors.size() - 1 );
+            auto new_lit1 = il.add_xor( ( i << 1 ), ( j << 1 ) );
+            auto new_lit2 = il.add_xor( new_lit1, mem_xor[tt] << 1 );
+            il.add_output( new_lit2 );
+            if ( !push_solution( il ) )
+              return std::nullopt;
+          }
+
+          // commutative
+          {
+            il.clear();
+            il.add_inputs( divisors.size() - 1 );
+            auto new_lit1 = il.add_xor( ( i << 1 ), ( mem_xor[tt] << 1 ) );
+            auto new_lit2 = il.add_xor( new_lit1, j << 1 );
+            il.add_output( new_lit2 );
+            if ( !push_solution( il ) )
+              return std::nullopt;
+          }
+
+          // commutative
+          {
+            il.clear();
+            il.add_inputs( divisors.size() - 1 );
+            auto new_lit1 = il.add_xor( ( j << 1 ), ( mem_xor[tt] << 1 ) );
+            auto new_lit2 = il.add_xor( new_lit1, i << 1 );
+            il.add_output( new_lit2 );
+            if ( !push_solution( il ) )
+              return std::nullopt;
+          }
+        }
+        if ( mem_xor.find( ~tt ) != mem_xor.end() )
+        {
+          if ( mem_xor[~tt] == i )
+            continue;
+          if ( mem_xor[~tt] == j )
+            continue;
+          index_list_t il;
+          {
+            il.clear();
+            il.add_inputs( divisors.size() - 1 );
+            auto new_lit1 = il.add_xor( ( i << 1 ), ( j << 1 ) );
+            auto new_lit2 = il.add_xor( new_lit1 ^ 0x1, mem_xor[~tt] << 1 );
+            il.add_output( new_lit2 );
+            if ( !push_solution( il ) )
+              return std::nullopt;
+          }
+
+          // commutative
+          {
+            il.clear();
+            il.add_inputs( divisors.size() - 1 );
+            auto new_lit1 = il.add_xor( ( i << 1 ), ( mem_xor[~tt] << 1 ) );
+            auto new_lit2 = il.add_xor( new_lit1 ^ 0x1, j << 1 );
+            il.add_output( new_lit2 );
+            if ( !push_solution( il ) )
+              return std::nullopt;
+          }
+
+          // commutative
+          {
+            il.clear();
+            il.add_inputs( divisors.size() - 1 );
+            auto new_lit1 = il.add_xor( ( j << 1 ), ( mem_xor[~tt] << 1 ) );
+            auto new_lit2 = il.add_xor( new_lit1 ^ 0x1, i << 1 );
+            il.add_output( new_lit2 );
+            if ( !push_solution( il ) )
+              return std::nullopt;
+          }
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  std::optional<index_list_t> find_xor_xor_xor()
+  {
+    if ( has_xor_xor == false )
+    {
+      prepare_xor_xor();
+    }
+    for ( auto i = 1u; i < divisors.size(); i++ )
+    {
+      for ( auto j = i + 1; j < divisors.size(); j++ )
+      {
+        auto const tt = get_div( i ) ^ get_div( j );
+        if ( mem_xor_xor.find( tt ) != mem_xor_xor.end() )
+        {
+          index_list_t il;
+          il.clear();
+          il.add_inputs( divisors.size() - 1 );
+          auto new_lit1 = il.add_xor( ( i << 1 ), ( j << 1 ) );
+          auto new_lit2 = il.add_xor( ( mem_xor_xor[tt] % divisors.size() ) << 1, ( mem_xor_xor[tt] / divisors.size() ) << 1 );
+          auto new_lit3 = il.add_xor( new_lit2, new_lit1 );
+          il.add_output( new_lit3 );
+          if ( !push_solution( il ) )
+            return std::nullopt;
+        }
+        if ( mem_xor_xor.find( ~tt ) != mem_xor_xor.end() )
+        {
+          index_list_t il;
+          il.clear();
+          il.add_inputs( divisors.size() - 1 );
+          auto new_lit1 = il.add_xor( ( i << 1 ), ( j << 1 ) );
+          auto new_lit2 = il.add_xor( ( mem_xor_xor[~tt] % divisors.size() ) << 1, ( mem_xor_xor[~tt] / divisors.size() ) << 1 );
+          auto new_lit3 = il.add_xor( new_lit2 ^ 0x1, new_lit1 );
+          il.add_output( new_lit3 );
+          if ( !push_solution( il ) )
+            return std::nullopt;
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  std::optional<index_list_t> find_xor_xor_and()
+  {
+    if ( has_xor_xor == false )
+    {
+      prepare_xor_xor();
+    }
+    for ( auto i = 1u; i < divisors.size(); i++ )
+    {
+      for ( auto j = i + 1; j < divisors.size(); j++ )
+      {
+        for ( auto on_off_1 = 0u; on_off_1 < 2; on_off_1++ )
+        {
+          for ( auto on_off_2 = 0u; on_off_2 < 2; on_off_2++ )
+          {
+            auto const tt = ( on_off_1 ? ~get_div( i ) : get_div( i ) ) & ( on_off_2 ? ~get_div( j ) : get_div( j ) );
+            if ( mem_xor_xor.find( tt ) != mem_xor_xor.end() )
+            {
+              index_list_t il;
+              il.clear();
+              il.add_inputs( divisors.size() - 1 );
+              auto new_lit1 = il.add_and( ( i << 1 ) + on_off_1, ( j << 1 ) + on_off_2 );
+              auto new_lit2 = il.add_xor( ( mem_xor_xor[tt] % divisors.size() ) << 1, ( mem_xor_xor[tt] / divisors.size() ) << 1 );
+              auto new_lit3 = il.add_xor( new_lit2, new_lit1 );
+              il.add_output( new_lit3 );
+              if ( !push_solution( il ) )
+                return std::nullopt;
+            }
+            if ( mem_xor_xor.find( ~tt ) != mem_xor_xor.end() )
+            {
+              index_list_t il;
+              il.clear();
+              il.add_inputs( divisors.size() - 1 );
+              auto new_lit1 = il.add_and( ( i << 1 ) + on_off_1, ( j << 1 ) + on_off_2 );
+              auto new_lit2 = il.add_xor( ( mem_xor_xor[~tt] % divisors.size() ) << 1, ( mem_xor_xor[~tt] / divisors.size() ) << 1 );
+              auto new_lit3 = il.add_xor( new_lit2 ^ 0x1, new_lit1 );
+              il.add_output( new_lit3 );
+              if ( !push_solution( il ) )
+                return std::nullopt;
+            }
+          }
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  std::optional<index_list_t> find_xor_and()
+  {
+    if ( has_xor == false )
+    {
+      prepare_xor();
+    }
+    for ( auto i = 1u; i < divisors.size(); i++ )
+    {
+      for ( auto j = i + 1; j < divisors.size(); j++ )
+      {
+        for ( auto on_off_1 = 0u; on_off_1 < 2; on_off_1++ )
+        {
+          for ( auto on_off_2 = 0u; on_off_2 < 2; on_off_2++ )
+          {
+            auto const tt = ( on_off_1 ? ~get_div( i ) : get_div( i ) ) & ( on_off_2 ? ~get_div( j ) : get_div( j ) );
+            if ( mem_xor.find( tt ) != mem_xor.end() )
+            {
+              index_list_t il;
+              il.clear();
+              il.add_inputs( divisors.size() - 1 );
+              auto new_lit1 = il.add_and( ( i << 1 ) + on_off_1, ( j << 1 ) + on_off_2 );
+              auto new_lit2 = il.add_xor( new_lit1, mem_xor[tt] << 1 );
+              il.add_output( new_lit2 );
+              if ( !push_solution( il ) )
+                return std::nullopt;
+            }
+            if ( mem_xor.find( ~tt ) != mem_xor.end() )
+            {
+              index_list_t il;
+              il.clear();
+              il.add_inputs( divisors.size() - 1 );
+              auto new_lit1 = il.add_and( ( i << 1 ) + on_off_1, ( j << 1 ) + on_off_2 );
+              auto new_lit2 = il.add_xor( new_lit1 ^ 0x1, mem_xor[~tt] << 1 );
+              il.add_output( new_lit2 );
+              if ( !push_solution( il ) )
+                return std::nullopt;
+            }
+          }
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  std::optional<index_list_t> find_xor_and_and()
+  {
+    if ( has_xor_and == false )
+    {
+      prepare_xor_and();
+    }
+    for ( auto i = 1u; i < divisors.size(); i++ )
+    {
+      for ( auto j = i + 1; j < divisors.size(); j++ )
+      {
+        for ( auto on_off_1 = 0u; on_off_1 < 2; on_off_1++ )
+        {
+          for ( auto on_off_2 = 0u; on_off_2 < 2; on_off_2++ )
+          {
+            auto const tt = ( on_off_1 ? ~get_div( i ) : get_div( i ) ) & ( on_off_2 ? ~get_div( j ) : get_div( j ) );
+            if ( mem_xor_and.find( tt ) != mem_xor_and.end() )
+            {
+              index_list_t il;
+              il.clear();
+              il.add_inputs( divisors.size() - 1 );
+              auto new_lit1 = il.add_and( ( i << 1 ) + on_off_1, ( j << 1 ) + on_off_2 );
+              auto new_lit2 = il.add_and( mem_xor_and[tt] % ( 2 * divisors.size() ), mem_xor_and[tt] / ( 2 * divisors.size() ) );
+              auto new_lit3 = il.add_xor( new_lit1, new_lit2 );
+              il.add_output( new_lit3 );
+              if ( !push_solution( il ) )
+                return std::nullopt;
+            }
+            if ( mem_xor_and.find( ~tt ) != mem_xor_and.end() )
+            {
+              index_list_t il;
+              il.clear();
+              il.add_inputs( divisors.size() - 1 );
+              auto new_lit1 = il.add_and( ( i << 1 ) + on_off_1, ( j << 1 ) + on_off_2 );
+              auto new_lit2 = il.add_and( mem_xor_and[~tt] % ( 2 * divisors.size() ), mem_xor_and[~tt] / ( 2 * divisors.size() ) );
+              auto new_lit3 = il.add_xor( new_lit1 ^ 0x1, new_lit2 );
+              il.add_output( new_lit3 );
+              if ( !push_solution( il ) )
+                return std::nullopt;
+            }
+          }
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  std::optional<index_list_t> find_and_and_and()
+  {
+    if ( has_and_pairs == false )
+    {
+      prepare_and_pairs();
+    }
+    auto ret = find_and_and_and_helper( pos_unate_pairs, pos_unate_pairs, 1 );
+    if ( !ret )
+      ret = find_and_and_and_helper( neg_unate_pairs, neg_unate_pairs, 0 );
+    return ret;
+  }
+
+  std::optional<index_list_t> find_and_and_xor()
+  {
+    if ( has_and_pairs == false )
+    {
+      prepare_and_pairs();
+    }
+    if ( has_xor_pairs == false )
+    {
+      prepare_xor_pairs();
+    }
+    auto ret = find_and_and_and_helper<true>( pos_unate_xor_pairs, pos_unate_pairs, 1 );
+    if ( !ret )
+      ret = find_and_and_and_helper<true>( neg_unate_xor_pairs, neg_unate_pairs, 0 );
+    return ret;
+  }
+
+  std::optional<index_list_t> find_and_xor_xor()
+  {
+    if ( has_xor_pairs == false )
+    {
+      prepare_xor_pairs();
+    }
+    auto ret = find_and_and_and_helper<true, true>( pos_unate_xor_pairs, pos_unate_xor_pairs, 1 );
+    if ( !ret )
+      ret = find_and_and_and_helper<true, true>( neg_unate_xor_pairs, neg_unate_xor_pairs, 0 );
+    return ret;
+  }
+
+  struct core_func_t
+  {
+    std::function<void( cost_resyn* )> func;
+    uint32_t effort;
+    uint32_t score;
+    core_func_t( std::function<void( cost_resyn* )> func, uint32_t effort ) : func( func ), effort( effort )
+    {
+    }
+    void operator()( cost_resyn* pcore )
+    {
+      func( pcore );
+    }
+  };
+
+  void sorted_core( Ntk& forest )
+  {
+    for ( core_func_t& fn : fns )
+    {
+      if ( ils.size() >= ps.max_solutions )
+        break;
+      uint32_t nbefore = ils.size();
+      call_with_stopwatch( st.time_search, [&]() { fn( this ); } );
+      st.num_resub[fn.effort] += ils.size() - nbefore;
+      if ( isConst ) /* try to find more solution of constant will crash */
+        break;
+    }
+    st.num_roots += ils.size();
+    uint32_t ngain = 0u;
+
+    for ( index_list_t const& il : ils )
+    {
+      if ( best_cost > eval_result( forest, il ) )
+        ngain = std::max( best_cost - eval_result( forest, il ), ngain );
+      call_with_stopwatch( st.time_eval, [&]() { update_result( forest, il ); } );
+    }
+    st.num_gain += ngain;
+  }
+
+public:
+  explicit cost_resyn( Ntk const& ntk, params const& ps, stats& st ) noexcept
+      : ntk( ntk ), ps( ps ), st( st )
+  {
+    fns.clear();
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_wire(); }, 0 );
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_xor(); }, 1 );
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_and(); }, 1 );
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_or(); }, 1 );
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_xor_xor(); }, 2 );
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_xor_and(); }, 2 );
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_and_and(); }, 2 );
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_and_or(); }, 2 );
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_or_or(); }, 2 );
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_or_and(); }, 2 );
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_and_xor(); }, 2 );
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_xor_and_and(); }, 3 );
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_xor_xor_and(); }, 3 );
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_xor_xor_xor(); }, 3 ); // bad efficiency / gain trade-off
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_and_xor_xor(); }, 3 );
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_and_and_xor(); }, 3 );
+    fns.emplace_back( []( cost_resyn* _core ) { _core->find_and_and_and(); }, 3 );
+    divisors.reserve( 200u );
+  }
+
+  template<class iterator_type, class truth_table_storage_type>
+  std::optional<index_list_t> operator()( TT const& target, TT const& care, std::vector<signal> const& divs, iterator_type begin, iterator_type end, truth_table_storage_type const& tts, uint32_t max_cost = std::numeric_limits<uint32_t>::max() )
+  {
+    ptts = &tts;
+    on_off_sets[0] = ~target & care;
+    on_off_sets[1] = target & care;
+
+    divisors.resize( 1 ); /* clear previous data and reserve 1 dummy node for constant */
+    while ( begin != end )
+    {
+      divisors.emplace_back( *begin );
+      ++begin;
+    }
+
+    best_cost = max_cost;
+    prepare_clear();
+
+    // prepare solution forest
+    Ntk forest; // create an empty network
+
+    for ( signal div : divs )
+    {
+      signal const& s = forest.create_pi();
+      node n = forest.get_node( s );
+      forest_leaves.emplace_back( s );
+      context_t div_cost = ntk.get_context( ntk.get_node( div ) );
+      forest.set_context( n, div_cost );
+      div_costs.emplace_back( div_cost );
+    }
+
+    sorted_core( forest );
+
+    st.num_problems += 1u;
+    if ( index_list )
+    {
+      st.num_solutions += 1u;
+      st.size_forest += forest.num_gates();
+    }
+
+    return index_list;
+  }
+
+private:
+  std::array<TT, 2> on_off_sets;
+  std::array<uint32_t, 2> num_bits; /* number of bits in on-set and off-set */
+
+  const std::vector<TT>* ptts;
+  std::vector<uint32_t> divisors;
+  std::vector<context_t> div_costs;
+  std::array<TT, 0x100u> tts_xors;
+  std::unordered_map<TT, uint32_t, kitty::hash<TT>> mem_xor;
+  std::unordered_map<TT, uint32_t, kitty::hash<TT>> mem_xor_xor;
+  std::unordered_map<TT, uint32_t, kitty::hash<TT>> mem_xor_and;
+  bool has_xor;
+  bool has_xor_xor;
+  bool has_xor_and;
+  bool has_unateness;
+  bool has_and_pairs;
+  bool has_xor_pairs;
+  bool has_init;
+  bool has_lit_xor;
+  /* positive unate: not overlapping with off-set
+     negative unate: not overlapping with on-set */
+  std::vector<unate_lit> pos_unate_lits, neg_unate_lits;
+  std::vector<uint32_t> binate_divs;
+  std::vector<fanin_pair> pos_unate_pairs, neg_unate_pairs;
+  std::vector<fanin_pair> pos_unate_xor_pairs, neg_unate_xor_pairs;
+
+  Ntk const& ntk;
+  std::vector<signal> forest_leaves;
+  std::vector<signal> candidates; // the output signals with correct functionality
+  std::optional<signal> forest_root;
+  params const& ps;
+  stats& st;
+
+  std::optional<index_list_t> index_list;
+  std::vector<index_list_t> ils;
+  uint32_t best_cost;
+
+  std::vector<core_func_t> fns;
+  bool isConst;
+};
+
+} // namespace mockturtle::experimental
diff --git a/include/mockturtle/algorithms/experimental/decompose_multioutput.hpp b/include/mockturtle/algorithms/experimental/decompose_multioutput.hpp
new file mode 100644
index 0000000..f6385da
--- /dev/null
+++ b/include/mockturtle/algorithms/experimental/decompose_multioutput.hpp
@@ -0,0 +1,397 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file decompose_multioutput.hpp
+  \brief Decomposes the multi-output gates into single output
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <iostream>
+#include <type_traits>
+#include <vector>
+
+#include <kitty/operations.hpp>
+
+#include "../../traits.hpp"
+#include "../../utils/node_map.hpp"
+#include "../../views/topo_view.hpp"
+#include "../cleanup.hpp"
+
+namespace mockturtle
+{
+
+struct decompose_multioutput_params
+{
+  bool set_multioutput_as_dont_touch{ false };
+};
+
+namespace detail
+{
+
+template<typename NtkSrc, typename NtkDest, typename LeavesIterator>
+void decompose_multioutput_impl( NtkSrc const& ntk, NtkDest& dest, LeavesIterator begin, LeavesIterator end, std::unordered_map<uint64_t, signal<NtkDest>>& old_to_new, decompose_multioutput_params const& ps )
+{
+  /* constants */
+  old_to_new[ntk.get_constant( false )] = dest.get_constant( false );
+  if ( ntk.get_node( ntk.get_constant( true ) ) != ntk.get_node( ntk.get_constant( false ) ) )
+  {
+    old_to_new[ntk.get_constant( true )] = dest.get_constant( true );
+  }
+
+  /* create inputs in the same order */
+  auto it = begin;
+  ntk.foreach_pi( [&]( auto node ) {
+    old_to_new[ntk.make_signal( node )] = *it++;
+  } );
+  if constexpr ( has_foreach_ro_v<NtkSrc> )
+  {
+    ntk.foreach_ro( [&]( auto node ) {
+      old_to_new[ntk.make_signal( node )] = *it++;
+    } );
+  }
+  assert( it == end );
+  (void)end;
+
+  /* foreach node in topological order */
+  topo_view topo{ ntk };
+  topo.foreach_node( [&]( auto node ) {
+    if ( ntk.is_constant( node ) || ntk.is_ci( node ) )
+      return;
+
+    /* collect children */
+    std::vector<signal<NtkDest>> children;
+    ntk.foreach_fanin( node, [&]( auto child, auto ) {
+      const auto child_no_complement = child ^ ntk.is_complemented( child );
+      const auto f = old_to_new[child_no_complement];
+
+      assert( dest.get_node( f ) != dest.get_node( dest.get_constant( false ) ) );
+      assert( dest.get_node( f ) != dest.get_node( dest.get_constant( true ) ) );
+
+      children.push_back( f ^ ntk.is_complemented( child ) );
+    } );
+
+    /* clone node */
+    if ( ntk.is_multioutput( node ) )
+    {
+      for ( auto i = 0; i < ntk.num_outputs( node ); ++i )
+      {
+        auto f = ntk.make_signal( node, i );
+        do
+        {
+          if constexpr ( has_is_and_v<NtkSrc> )
+          {
+            static_assert( has_create_and_v<NtkDest>, "NtkDest cannot create AND gates" );
+            if ( ntk.is_and( f ) )
+            {
+              old_to_new[f] = dest.create_and( children[0], children[1] );
+              break;
+            }
+          }
+          if constexpr ( has_is_or_v<NtkSrc> )
+          {
+            static_assert( has_create_or_v<NtkDest>, "NtkDest cannot create OR gates" );
+            if ( ntk.is_or( f ) )
+            {
+              old_to_new[f] = dest.create_or( children[0], children[1] );
+              break;
+            }
+          }
+          if constexpr ( has_is_xor_v<NtkSrc> )
+          {
+            static_assert( has_create_xor_v<NtkDest>, "NtkDest cannot create XOR gates" );
+            if ( ntk.is_xor( f ) )
+            {
+              old_to_new[f] = dest.create_xor( children[0], children[1] );
+              break;
+            }
+          }
+          if constexpr ( has_is_maj_v<NtkSrc> )
+          {
+            static_assert( has_create_maj_v<NtkDest>, "NtkDest cannot create MAJ gates" );
+            if ( ntk.is_maj( f ) )
+            {
+              old_to_new[f] = dest.create_maj( children[0], children[1], children[2] );
+              break;
+            }
+          }
+          if constexpr ( has_is_ite_v<NtkSrc> )
+          {
+            static_assert( has_create_ite_v<NtkDest>, "NtkDest cannot create ITE gates" );
+            if ( ntk.is_ite( f ) )
+            {
+              old_to_new[f] = dest.create_ite( children[0], children[1], children[2] );
+              break;
+            }
+          }
+          if constexpr ( has_is_xor3_v<NtkSrc> )
+          {
+            static_assert( has_create_xor3_v<NtkDest>, "NtkDest cannot create XOR3 gates" );
+            if ( ntk.is_xor3( f ) )
+            {
+              old_to_new[f] = dest.create_xor3( children[0], children[1], children[2] );
+              break;
+            }
+          }
+          if constexpr ( has_is_function_v<NtkSrc> && has_create_node_v<NtkDest> )
+          {
+            old_to_new[f] = dest.create_node( children, ntk.node_function_pin( node, i ) );
+            break;
+          }
+          std::cerr << "[e] something went wrong, could not copy node " << ntk.node_to_index( node ) << "\n";
+        } while ( false );
+
+        /* set dont touch */
+        if constexpr ( has_select_dont_touch_v<NtkDest> )
+        {
+          if ( ps.set_multioutput_as_dont_touch )
+            dest.select_dont_touch( dest.get_node( old_to_new[f] ) );
+        }
+
+        /* copy name */
+        if constexpr ( has_has_name_v<NtkSrc> && has_get_name_v<NtkSrc> && has_set_name_v<NtkDest> )
+        {
+          if ( ntk.has_name( f ) )
+          {
+            dest.set_name( old_to_new[f], ntk.get_name( f ) );
+          }
+          if ( ntk.has_name( !f ) )
+          {
+            dest.set_name( !old_to_new[f], ntk.get_name( !f ) );
+          }
+        }
+      }
+    }
+    else
+    {
+      auto f = ntk.make_signal( node );
+      if constexpr ( std::is_same_v<NtkSrc, NtkDest> )
+      {
+        old_to_new[f] = dest.clone_node( ntk, node, children );
+      }
+      else
+      {
+        do
+        {
+          if constexpr ( has_is_and_v<NtkSrc> )
+          {
+            static_assert( has_create_and_v<NtkDest>, "NtkDest cannot create AND gates" );
+            if ( ntk.is_and( node ) )
+            {
+              old_to_new[f] = dest.create_and( children[0], children[1] );
+              break;
+            }
+          }
+          if constexpr ( has_is_or_v<NtkSrc> )
+          {
+            static_assert( has_create_or_v<NtkDest>, "NtkDest cannot create OR gates" );
+            if ( ntk.is_or( node ) )
+            {
+              old_to_new[f] = dest.create_or( children[0], children[1] );
+              break;
+            }
+          }
+          if constexpr ( has_is_xor_v<NtkSrc> )
+          {
+            static_assert( has_create_xor_v<NtkDest>, "NtkDest cannot create XOR gates" );
+            if ( ntk.is_xor( node ) )
+            {
+              old_to_new[f] = dest.create_xor( children[0], children[1] );
+              break;
+            }
+          }
+          if constexpr ( has_is_maj_v<NtkSrc> )
+          {
+            static_assert( has_create_maj_v<NtkDest>, "NtkDest cannot create MAJ gates" );
+            if ( ntk.is_maj( node ) )
+            {
+              old_to_new[f] = dest.create_maj( children[0], children[1], children[2] );
+              break;
+            }
+          }
+          if constexpr ( has_is_ite_v<NtkSrc> )
+          {
+            static_assert( has_create_ite_v<NtkDest>, "NtkDest cannot create ITE gates" );
+            if ( ntk.is_ite( node ) )
+            {
+              old_to_new[f] = dest.create_ite( children[0], children[1], children[2] );
+              break;
+            }
+          }
+          if constexpr ( has_is_xor3_v<NtkSrc> )
+          {
+            static_assert( has_create_xor3_v<NtkDest>, "NtkDest cannot create XOR3 gates" );
+            if ( ntk.is_xor3( node ) )
+            {
+              old_to_new[f] = dest.create_xor3( children[0], children[1], children[2] );
+              break;
+            }
+          }
+          if constexpr ( has_is_nary_and_v<NtkSrc> )
+          {
+            static_assert( has_create_nary_and_v<NtkDest>, "NtkDest cannot create n-ary AND gates" );
+            if ( ntk.is_nary_and( node ) )
+            {
+              old_to_new[f] = dest.create_nary_and( children );
+              break;
+            }
+          }
+          if constexpr ( has_is_nary_or_v<NtkSrc> )
+          {
+            static_assert( has_create_nary_or_v<NtkDest>, "NtkDest cannot create n-ary OR gates" );
+            if ( ntk.is_nary_or( node ) )
+            {
+              old_to_new[f] = dest.create_nary_or( children );
+              break;
+            }
+          }
+          if constexpr ( has_is_nary_xor_v<NtkSrc> )
+          {
+            static_assert( has_create_nary_xor_v<NtkDest>, "NtkDest cannot create n-ary XOR gates" );
+            if ( ntk.is_nary_xor( node ) )
+            {
+              old_to_new[f] = dest.create_nary_xor( children );
+              break;
+            }
+          }
+          if constexpr ( has_is_function_v<NtkSrc> && has_create_node_v<NtkDest> )
+          {
+            old_to_new[f] = dest.create_node( children, ntk.node_function( node ) );
+            break;
+          }
+          std::cerr << "[e] something went wrong, could not copy node " << ntk.node_to_index( node ) << "\n";
+        } while ( false );
+      }
+      /* copy name */
+      if constexpr ( has_has_name_v<NtkSrc> && has_get_name_v<NtkSrc> && has_set_name_v<NtkDest> )
+      {
+        if ( ntk.has_name( f ) )
+        {
+          dest.set_name( old_to_new[f], ntk.get_name( f ) );
+        }
+        if ( ntk.has_name( !f ) )
+        {
+          dest.set_name( !old_to_new[f], ntk.get_name( !f ) );
+        }
+      }
+    }
+  } );
+
+  /* POs */
+  ntk.foreach_po( [&]( auto const& po ) {
+    const auto po_no_complement = po ^ ntk.is_complemented( po );
+    auto const f = old_to_new[po_no_complement];
+    dest.create_po( f ^ ntk.is_complemented( po ) );
+  } );
+
+  /* RIs */
+  if constexpr ( has_foreach_ri_v<NtkSrc> && has_create_ri_v<NtkDest> )
+  {
+    ntk.foreach_ri( [&]( auto const& f ) {
+      dest.create_ri( old_to_new[f ^ ntk.is_complemented( f )] ^ ntk.is_complemented( f ) );
+    } );
+  }
+
+  /* CO names */
+  if constexpr ( has_has_output_name_v<NtkSrc> && has_get_output_name_v<NtkSrc> && has_set_output_name_v<NtkDest> )
+  {
+    ntk.foreach_co( [&]( auto co, auto index ) {
+      (void)co;
+      if ( ntk.has_output_name( index ) )
+      {
+        dest.set_output_name( index, ntk.get_output_name( index ) );
+      }
+    } );
+  }
+}
+
+} // namespace detail
+
+/*! \brief Decomposes the multi-output gates into single output.
+ *
+ * This method reconstructs a network decomposing the multi-output gates into
+ * single output gates. Moreover, it omits all dangling nodes.
+ *
+   \verbatim embed:rst
+
+   .. note::
+
+      This method returns the cleaned up network as a return value.  It does
+      *not* modify the input network.
+   \endverbatim
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `node_to_index`
+ * - `get_constant`
+ * - `create_pi`
+ * - `create_po`
+ * - `create_not`
+ * - `is_complemented`
+ * - `foreach_node`
+ * - `foreach_pi`
+ * - `foreach_po`
+ * - `clone_node`
+ * - `is_pi`
+ * - `is_constant`
+ * - `has_multioutput`
+ */
+template<class NtkSrc, class NtkDest = NtkSrc>
+[[nodiscard]] NtkDest decompose_multioutput( NtkSrc const& ntk, decompose_multioutput_params const& ps = {} )
+{
+  static_assert( is_network_type_v<NtkSrc>, "NtkSrc is not a network type" );
+  static_assert( is_network_type_v<NtkDest>, "NtkDest is not a network type" );
+  static_assert( has_get_node_v<NtkSrc>, "NtkSrc does not implement the get_node method" );
+  static_assert( has_node_to_index_v<NtkSrc>, "NtkSrc does not implement the node_to_index method" );
+  static_assert( has_get_constant_v<NtkSrc>, "NtkSrc does not implement the get_constant method" );
+  static_assert( has_foreach_node_v<NtkSrc>, "NtkSrc does not implement the foreach_node method" );
+  static_assert( has_foreach_pi_v<NtkSrc>, "NtkSrc does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<NtkSrc>, "NtkSrc does not implement the foreach_po method" );
+  static_assert( has_is_pi_v<NtkSrc>, "NtkSrc does not implement the is_pi method" );
+  static_assert( has_is_constant_v<NtkSrc>, "NtkSrc does not implement the is_constant method" );
+  static_assert( has_clone_node_v<NtkDest>, "NtkDest does not implement the clone_node method" );
+  static_assert( has_create_pi_v<NtkDest>, "NtkDest does not implement the create_pi method" );
+  static_assert( has_create_po_v<NtkDest>, "NtkDest does not implement the create_po method" );
+  static_assert( has_create_not_v<NtkDest>, "NtkDest does not implement the create_not method" );
+  static_assert( has_is_complemented_v<NtkSrc>, "NtkSrc does not implement the is_complemented method" );
+  static_assert( has_is_multioutput_v<NtkSrc>, "NtkSource does not implement the is_complemented method" );
+  static_assert( has_node_function_pin_v<NtkSrc>, "NtkSource does not implement the node_function_pin" );
+  static_assert( has_num_outputs_v<NtkSrc>, "NtkSource does not implement the has_num_outputs" );
+
+  NtkDest dest;
+
+  std::vector<signal<NtkDest>> cis;
+  detail::clone_inputs( ntk, dest, cis, false );
+
+  std::unordered_map<uint64_t, signal<NtkDest>> old_to_new;
+  detail::decompose_multioutput_impl( ntk, dest, cis.begin(), cis.end(), old_to_new, ps );
+
+  return dest;
+}
+
+} // namespace mockturtle
diff --git a/include/mockturtle/algorithms/experimental/sim_resub.hpp b/include/mockturtle/algorithms/experimental/sim_resub.hpp
new file mode 100644
index 0000000..cd86c54
--- /dev/null
+++ b/include/mockturtle/algorithms/experimental/sim_resub.hpp
@@ -0,0 +1,545 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file sim_resub.hpp
+  \brief Simulation-guided resubstitution
+
+  \author Hanyu Wang
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../../io/write_patterns.hpp"
+#include "../../networks/aig.hpp"
+#include "../../networks/xag.hpp"
+#include "../../traits.hpp"
+#include "../../utils/index_list.hpp"
+#include "../../views/depth_view.hpp"
+#include "../../views/fanout_view.hpp"
+#include "../circuit_validator.hpp"
+#include "../detail/resub_utils.hpp"
+#include "../dont_cares.hpp"
+#include "../pattern_generation.hpp"
+#include "../resyn_engines/aig_enumerative.hpp"
+#include "../resyn_engines/mig_enumerative.hpp"
+#include "../resyn_engines/mig_resyn.hpp"
+#include "../resyn_engines/xag_resyn.hpp"
+#include "../simulation.hpp"
+#include <kitty/kitty.hpp>
+
+#include <functional>
+#include <optional>
+#include <vector>
+
+namespace mockturtle::experimental
+{
+
+struct breadth_first_windowing_params
+{
+  /*! \brief Maximum number of divisors to consider. */
+  uint32_t max_divisors{ 50 };
+
+  /*! \brief Maximum number of TFI nodes to collect. */
+  uint32_t max_tfi{ uint32_t( max_divisors * 0.5 ) };
+
+  /*! \brief Maximum number of nodes added by resubstitution. */
+  uint32_t max_inserts{ std::numeric_limits<uint32_t>::max() };
+
+  /*! \brief Maximum fanout of a node to be considered as root. */
+  uint32_t skip_fanout_limit_for_roots{ 1000 };
+
+  /*! \brief Maximum fanout of a node to be considered as divisor. */
+  uint32_t skip_fanout_limit_for_divisors{ 100 };
+};
+
+struct simulation_guided_resynthesis_params
+{
+  /*! \brief Whether to use pre-generated patterns stored in a file.
+   * If not, by default, 1024 random pattern + 1x stuck-at patterns will be generated.
+   */
+  std::optional<std::string> pattern_filename{};
+
+  /*! \brief Whether to save the appended patterns (with CEXs) into file. */
+  std::optional<std::string> save_patterns{};
+
+  /*! \brief Maximum number of clauses of the SAT solver. */
+  uint32_t max_clauses{ 1000 };
+
+  /*! \brief Conflict limit for the SAT solver. */
+  uint32_t conflict_limit{ 1000 };
+
+  /*! \brief Random seed for the SAT solver (influences the randomness of counter-examples). */
+  uint32_t random_seed{ 1 };
+
+  /*! \brief Maximum number of trials to call the resub functor. */
+  uint32_t max_trials{ 100 };
+
+  /*! \brief Whether to utilize ODC, and how many levels. 0 = no. -1 = Consider TFO until PO. */
+  int32_t odc_levels{ 0 };
+};
+
+struct breadth_first_windowing_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Accumulated runtime for mffc computation. */
+  stopwatch<>::duration time_mffc{ 0 };
+
+  /*! \brief Accumulated runtime for divisor collection. */
+  stopwatch<>::duration time_divs{ 0 };
+
+  /*! \brief Total number of divisors. */
+  uint64_t num_divisors{ 0u };
+
+  /*! \brief Number of constructed windows. */
+  uint32_t num_windows{ 0u };
+
+  /*! \brief Total number of MFFC nodes. */
+  uint64_t sum_mffc_size{ 0u };
+
+  void report() const
+  {
+    // clang-format off
+    fmt::print( "[i] breadth_first_windowing report\n" );
+    fmt::print( "    tot. #divs = {:5d}, sum  |MFFC| = {:5d}\n", num_divisors, sum_mffc_size );
+    fmt::print( "    avg. #divs = {:>5.2f}, avg. |MFFC| = {:>5.2f}\n", float( num_divisors ) / float( num_windows ), float( sum_mffc_size ) / float( num_windows ) );
+    fmt::print( "    ===== Runtime Breakdown =====\n" );
+    fmt::print( "    Total : {:>5.2f} secs\n", to_seconds( time_total ) );
+    fmt::print( "      MFFC: {:>5.2f} secs\n", to_seconds( time_mffc ) );
+    fmt::print( "      Divs: {:>5.2f} secs\n", to_seconds( time_divs ) );
+    // clang-format on
+  }
+};
+
+struct simulation_guided_resynthesis_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Time for pattern generation. */
+  stopwatch<>::duration time_patgen{ 0 };
+
+  /*! \brief Time for simulation. */
+  stopwatch<>::duration time_sim{ 0 };
+
+  /*! \brief Time for SAT solving. */
+  stopwatch<>::duration time_sat{ 0 };
+
+  /*! \brief Time for finding dependency function. */
+  stopwatch<>::duration time_resyn{ 0 };
+
+  /*! \brief Time for computing ODCs. */
+  stopwatch<>::duration time_odc{ 0 };
+
+  /*! \brief Time for saving patterns. */
+  stopwatch<>::duration time_patsave{ 0 };
+
+  /*! \brief Number of calls to the resynthesis engine. */
+  uint32_t num_calls{ 0 };
+
+  /*! \brief Number of solutions found by the resynthesis engine. */
+  uint32_t num_sols{ 0 };
+
+  /*! \brief Number of patterns used. */
+  uint32_t num_pats{ 0 };
+
+  /*! \brief Number of valid solutions. */
+  uint32_t num_valid{ 0 };
+
+  /*! \brief Number of counter-examples. */
+  uint32_t num_cex{ 0 };
+
+  /*! \brief Number of SAT solver timeout. */
+  uint32_t num_timeout{ 0 };
+
+  void report() const
+  {
+    // clang-format off
+    fmt::print( "[i] simulation_guided_resynthesis report\n" );
+    fmt::print( "    initial #pats = {} + #CEXs = {} --> {}\n", num_pats, num_cex, num_pats + num_cex );
+    fmt::print( "    #resyn calls = {}, #solutions = {} ({:.2f}%)\n", num_calls, num_sols, float( num_sols ) / float( num_calls ) * 100 );
+    fmt::print( "    #valid = {} ({:.2f}%), #CEXs = {} ({:.2f}%), #TOs = {} ({:.2f}%)\n", num_valid, float( num_valid ) / float( num_sols ) * 100, num_cex, float( num_cex ) / float( num_sols ) * 100, num_timeout, float( num_timeout ) / float( num_sols ) * 100 );
+    fmt::print( "    ===== Runtime Breakdown =====\n" );
+    fmt::print( "    Total         : {:>5.2f} secs\n", to_seconds( time_total ) );
+    fmt::print( "      Pattern gen.: {:>5.2f} secs [Called in init() -- should be subtracted]\n", to_seconds( time_patgen ) );
+    fmt::print( "      Simulation  : {:>5.2f} secs\n", to_seconds( time_sim ) );
+    fmt::print( "      SAT         : {:>5.2f} secs\n", to_seconds( time_sat ) );
+    fmt::print( "      Resynthesis : {:>5.2f} secs\n", to_seconds( time_resyn ) );
+    fmt::print( "      ODC comp.   : {:>5.2f} secs\n", to_seconds( time_odc ) );
+    fmt::print( "    Save patterns : {:>5.2f} secs [Called in destructor -- not included in total runtime]\n", to_seconds( time_patsave ) );
+    // clang-format on
+  }
+};
+
+namespace detail
+{
+
+template<class Ntk>
+struct breadth_first_window
+{
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  node root;
+  std::vector<node> divs;
+  uint32_t mffc_size;
+  uint32_t max_size{ std::numeric_limits<uint32_t>::max() };
+  // uint32_t max_level{std::numeric_limits<uint32_t>::max()};
+};
+
+template<class Ntk>
+class breadth_first_windowing
+{
+public:
+  using problem_t = breadth_first_window<Ntk>;
+  using params_t = breadth_first_windowing_params;
+  using stats_t = breadth_first_windowing_stats;
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  explicit breadth_first_windowing( Ntk& ntk, params_t const& ps, stats_t& st )
+      : ntk( ntk ), ps( ps ), st( st ), mffc_mgr( ntk ),
+        divs_mgr( ntk, divisor_collector_params( { ps.max_tfi, ps.max_divisors, ps.skip_fanout_limit_for_divisors } ) )
+  {
+    static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+    static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+    static_assert( has_value_v<Ntk>, "Ntk does not implement the value method" );
+    static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the substitute_node method" );
+  }
+
+  void init()
+  {
+  }
+
+  std::optional<std::reference_wrapper<problem_t>> operator()( node const& n )
+  {
+    stopwatch t( st.time_total );
+    if ( ntk.fanout_size( n ) > ps.skip_fanout_limit_for_roots )
+    {
+      return std::nullopt; /* skip nodes with too many fanouts */
+    }
+
+    /* collect TFI nodes with BFS and supported "wing" nodes */
+    win.root = n;
+    win.divs.clear();
+    call_with_stopwatch( st.time_divs, [&]() {
+      divs_mgr.collect_tfi_and_wings( n, win.divs );
+    } );
+
+    /* compute and mark MFFC nodes */
+    ++mffc_marker;
+    win.mffc_size = call_with_stopwatch( st.time_mffc, [&]() {
+      return mffc_mgr.call_on_mffc_and_count( n, {}, [&]( node const& n ) {
+        ntk.set_value( n, mffc_marker );
+      } );
+    } );
+
+    /* exclude MFFC node in divs */
+    uint32_t counter{ 0 };
+    for ( int32_t i = 0; i < win.divs.size(); ++i )
+    {
+      if ( ntk.value( win.divs.at( i ) ) == mffc_marker )
+      {
+        ++counter;
+        win.divs[i] = win.divs.back();
+        win.divs.pop_back();
+        --i;
+      }
+    }
+
+    /* all MFFC nodes should be in TFI (thus collected in divs) */
+    assert( counter == win.mffc_size );
+    win.max_size = std::min( win.mffc_size - 1, ps.max_inserts );
+
+    st.num_windows++;
+    st.num_divisors += win.divs.size();
+    st.sum_mffc_size += win.mffc_size;
+
+    return win;
+  }
+
+  template<typename res_t>
+  uint32_t gain( problem_t const& prob, res_t const& res ) const
+  {
+    static_assert( is_index_list_v<res_t>, "res_t is not an index_list (windowing engine and resynthesis engine do not match)" );
+    return prob.mffc_size - res.num_gates();
+  }
+
+  template<typename res_t>
+  bool update_ntk( problem_t const& prob, res_t const& res )
+  {
+    static_assert( is_index_list_v<res_t>, "res_t is not an index_list (windowing engine and resynthesis engine do not match)" );
+    assert( res.num_pos() == 1 );
+    insert<false>( ntk, prob.divs.begin(), prob.divs.end(), res, [&]( signal const& g ) {
+      ntk.substitute_node( prob.root, g );
+    } );
+    return true; /* continue optimization */
+  }
+
+  template<typename res_t>
+  bool report( problem_t const& prob, res_t const& res )
+  {
+    static_assert( is_index_list_v<res_t>, "res_t is not an index_list (windowing engine and resynthesis engine do not match)" );
+    assert( res.num_pos() == 1 );
+    fmt::print( "[i] found solution {} for root node {}\n", to_index_list_string( res ), prob.root );
+    return true;
+  }
+
+private:
+private:
+  Ntk& ntk;
+  problem_t win;
+  params_t const& ps;
+  stats_t& st;
+  typename mockturtle::detail::node_mffc_inside<Ntk> mffc_mgr; // TODO: namespaces can be removed when we move out of experimental::
+  uint32_t mffc_marker{ 0u };
+  divisor_collector<Ntk> divs_mgr;
+}; /* breadth_first_windowing */
+
+template<class Ntk, class ResynEngine, bool UseODC = false, bill::solvers Solver = bill::solvers::bsat2>
+class simulation_guided_resynthesis
+{
+public:
+  using problem_t = breadth_first_window<Ntk>;
+  using res_t = typename ResynEngine::index_list_t;
+  using params_t = simulation_guided_resynthesis_params;
+  using stats_t = simulation_guided_resynthesis_stats;
+
+  using node = typename Ntk::node;
+  using TT = kitty::partial_truth_table;
+  using validator_t = circuit_validator<Ntk, Solver, /*use_pushpop*/ false, /*randomize*/ true, /*use_odc*/ UseODC>;
+
+  explicit simulation_guided_resynthesis( Ntk const& ntk, params_t const& ps, stats_t& st )
+      : ntk( ntk ), ps( ps ), st( st ), engine( rst ),
+        validator( ntk, { ps.max_clauses, ps.odc_levels, ps.conflict_limit, ps.random_seed } ), tts( ntk )
+  {}
+
+  ~simulation_guided_resynthesis()
+  {
+    if ( ps.save_patterns )
+    {
+      call_with_stopwatch( st.time_patsave, [&]() {
+        write_patterns( sim, *ps.save_patterns );
+      } );
+    }
+
+    if ( add_event )
+    {
+      ntk.events().release_add_event( add_event );
+    }
+  }
+
+  void init()
+  {
+    add_event = ntk.events().register_add_event( [&]( const auto& n ) {
+      tts.resize();
+      call_with_stopwatch( st.time_sim, [&]() {
+        simulate_node<Ntk>( ntk, n, tts, sim );
+      } );
+    } );
+
+    /* prepare simulation patterns */
+    call_with_stopwatch( st.time_patgen, [&]() {
+      if ( ps.pattern_filename )
+      {
+        sim = partial_simulator( *ps.pattern_filename );
+      }
+      else
+      {
+        sim = partial_simulator( ntk.num_pis(), 1024 );
+        pattern_generation( ntk, sim );
+      }
+    } );
+    st.num_pats = sim.num_bits();
+
+    /* first simulation: the whole circuit; from 0 bits. */
+    call_with_stopwatch( st.time_sim, [&]() {
+      simulate_nodes<Ntk>( ntk, tts, sim, true );
+    } );
+  }
+
+  std::optional<res_t> operator()( problem_t& prob )
+  {
+    for ( auto j = 0u; j < ps.max_trials; ++j )
+    {
+      check_tts( prob.root );
+      for ( auto const& d : prob.divs )
+      {
+        check_tts( d );
+      }
+
+      TT const care = call_with_stopwatch( st.time_odc, [&]() {
+        return ( ps.odc_levels == 0 ) ? sim.compute_constant( true ) : ~observability_dont_cares( ntk, prob.root, sim, tts, ps.odc_levels );
+      } );
+
+      const auto res = call_with_stopwatch( st.time_resyn, [&]() {
+        ++st.num_calls;
+        return engine( tts[prob.root], care, std::begin( prob.divs ), std::end( prob.divs ), tts, prob.max_size );
+      } );
+
+      if ( res )
+      {
+        ++st.num_sols;
+        auto const& id_list = *res;
+        auto valid = call_with_stopwatch( st.time_sat, [&]() {
+          return validator.validate( prob.root, prob.divs, id_list );
+        } );
+        if ( valid )
+        {
+          if ( *valid )
+          {
+            ++st.num_valid;
+            if constexpr ( UseODC )
+            {
+              /* restart the solver -- clear constructed CNF */
+              call_with_stopwatch( st.time_sat, [&]() {
+                validator.update();
+              } );
+            }
+            return id_list;
+          }
+          else
+          {
+            ++st.num_cex;
+            call_with_stopwatch( st.time_sim, [&]() {
+              sim.add_pattern( validator.cex );
+            } );
+
+            /* re-simulate the whole circuit (for the last block) when a block is full */
+            if ( sim.num_bits() % 64 == 0 )
+            {
+              call_with_stopwatch( st.time_sim, [&]() {
+                simulate_nodes<Ntk>( ntk, tts, sim, false );
+              } );
+            }
+            continue;
+          }
+        }
+        else /* timeout */
+        {
+          ++st.num_timeout;
+          return std::nullopt;
+        }
+      }
+      else /* functor can not find any potential resubstitution */
+      {
+        return std::nullopt;
+      }
+    } /* limit on number of trials exceeded */
+    return std::nullopt;
+  }
+
+private:
+  void check_tts( node const& n )
+  {
+    if ( tts[n].num_bits() != sim.num_bits() )
+    {
+      call_with_stopwatch( st.time_sim, [&]() {
+        simulate_node<Ntk>( ntk, n, tts, sim );
+      } );
+    }
+  }
+
+private:
+  Ntk const& ntk;
+  params_t const& ps;
+  stats_t& st;
+  typename ResynEngine::stats rst;
+  ResynEngine engine;
+  partial_simulator sim;
+  validator_t validator;
+  incomplete_node_map<TT, Ntk> tts;
+
+  std::shared_ptr<typename network_events<Ntk>::add_event_type> add_event;
+}; /* simulation_guided_resynthesis */
+
+} /* namespace detail */
+
+using sim_resub_params = boolean_optimization_params<breadth_first_windowing_params, simulation_guided_resynthesis_params>;
+using sim_resub_stats = boolean_optimization_stats<breadth_first_windowing_stats, simulation_guided_resynthesis_stats>;
+
+template<class Ntk>
+void simulation_xag_heuristic_resub( Ntk& ntk, sim_resub_params const& ps = {}, sim_resub_stats* pst = nullptr )
+{
+  static_assert( std::is_same_v<typename Ntk::base_type, xag_network>, "Ntk::base_type is not xag_network" );
+
+  using ViewedNtk = depth_view<fanout_view<Ntk>>;
+  fanout_view<Ntk> fntk( ntk );
+  ViewedNtk viewed( fntk );
+
+  using windowing_t = typename detail::breadth_first_windowing<ViewedNtk>;
+  using engine_t = xag_resyn_decompose<kitty::partial_truth_table, xag_resyn_static_params_for_sim_resub<ViewedNtk>>;
+  using resyn_t = typename detail::simulation_guided_resynthesis<ViewedNtk, engine_t>;
+  using opt_t = typename detail::boolean_optimization_impl<ViewedNtk, windowing_t, resyn_t>;
+
+  sim_resub_stats st;
+  opt_t p( viewed, ps, st );
+  p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+template<class Ntk>
+void simulation_aig_heuristic_resub( Ntk& ntk, sim_resub_params const& ps = {}, sim_resub_stats* pst = nullptr )
+{
+  static_assert( std::is_same_v<typename Ntk::base_type, aig_network>, "Ntk::base_type is not aig_network" );
+
+  using ViewedNtk = depth_view<fanout_view<Ntk>>;
+  fanout_view<Ntk> fntk( ntk );
+  ViewedNtk viewed( fntk );
+
+  using windowing_t = typename detail::breadth_first_windowing<ViewedNtk>;
+  using engine_t = xag_resyn_decompose<kitty::partial_truth_table, aig_resyn_static_params_for_sim_resub<ViewedNtk>>;
+  using resyn_t = typename detail::simulation_guided_resynthesis<ViewedNtk, engine_t>;
+  using opt_t = typename detail::boolean_optimization_impl<ViewedNtk, windowing_t, resyn_t>;
+
+  sim_resub_stats st;
+  opt_t p( viewed, ps, st );
+  p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle::experimental */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/experimental/window_resub.hpp b/include/mockturtle/algorithms/experimental/window_resub.hpp
new file mode 100644
index 0000000..deedd3a
--- /dev/null
+++ b/include/mockturtle/algorithms/experimental/window_resub.hpp
@@ -0,0 +1,834 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file window_resub.hpp
+  \brief Windowing for small-window-based, enumeration-based (classical) resubstitution
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../../networks/aig.hpp"
+#include "../../networks/xag.hpp"
+#include "../../traits.hpp"
+#include "../../utils/index_list.hpp"
+#include "../../utils/null_utils.hpp"
+#include "../../views/depth_view.hpp"
+#include "../../views/fanout_view.hpp"
+#include "../detail/resub_utils.hpp"
+#include "../dont_cares.hpp"
+#include "../reconv_cut.hpp"
+#include "../resyn_engines/aig_enumerative.hpp"
+#include "../resyn_engines/mig_enumerative.hpp"
+#include "../resyn_engines/mig_resyn.hpp"
+#include "../resyn_engines/xag_resyn.hpp"
+#include "../simulation.hpp"
+
+#include "../../utils/include/percy.hpp"
+
+#include <kitty/kitty.hpp>
+
+#include <functional>
+#include <optional>
+#include <vector>
+
+namespace mockturtle::experimental
+{
+
+struct complete_tt_windowing_params
+{
+  /*! \brief Maximum number of PIs of reconvergence-driven cuts. */
+  uint32_t max_pis{ 8 };
+
+  /*! \brief Maximum number of divisors to consider. */
+  uint32_t max_divisors{ 150 };
+
+  /*! \brief Maximum number of nodes added by resubstitution. */
+  uint32_t max_inserts{ 2 };
+
+  /*! \brief Maximum fanout of a node to be considered as root. */
+  uint32_t skip_fanout_limit_for_roots{ 1000 };
+
+  /*! \brief Maximum fanout of a node to be considered as divisor. */
+  uint32_t skip_fanout_limit_for_divisors{ 100 };
+
+  /*! \brief Use don't cares for optimization. */
+  bool use_dont_cares{ false };
+
+  /*! \brief Window size for don't cares calculation. */
+  uint32_t window_size{ 12u };
+
+  /*! \brief Whether to update node levels lazily. */
+  bool update_levels_lazily{ false };
+
+  /*! \brief Whether to prevent from increasing depth. */
+  bool preserve_depth{ false };
+
+  /*! \brief Whether to normalize the truth tables.
+   *
+   * For some enumerative resynthesis engines, if the truth tables
+   * are normalized, some cases can be eliminated and thus improves
+   * efficiency. When this option is turned off, be sure to use an
+   * implementation of resynthesis that does not make this assumption;
+   * otherwise, quality degradation may be observed.
+   *
+   * Normalization is typically only useful for enumerative methods
+   * and for smaller solutions (i.e. when `max_inserts` < 2). Turning
+   * on normalization may result in larger runtime overhead when there
+   * are many divisors or when the truth tables are long.
+   */
+  bool normalize{ false };
+};
+
+struct complete_tt_windowing_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Accumulated runtime for cut computation. */
+  stopwatch<>::duration time_cuts{ 0 };
+
+  /*! \brief Accumulated runtime for mffc computation. */
+  stopwatch<>::duration time_mffc{ 0 };
+
+  /*! \brief Accumulated runtime for divisor collection. */
+  stopwatch<>::duration time_divs{ 0 };
+
+  /*! \brief Accumulated runtime for simulation. */
+  stopwatch<>::duration time_sim{ 0 };
+
+  /*! \brief Accumulated runtime for don't care computation. */
+  stopwatch<>::duration time_dont_care{ 0 };
+
+  /*! \brief Total number of leaves. */
+  uint64_t num_leaves{ 0u };
+
+  /*! \brief Total number of divisors. */
+  uint64_t num_divisors{ 0u };
+
+  /*! \brief Number of constructed windows. */
+  uint32_t num_windows{ 0u };
+
+  /*! \brief Total number of MFFC nodes. */
+  uint64_t sum_mffc_size{ 0u };
+
+  void report() const
+  {
+    // clang-format off
+    fmt::print( "[i] complete_tt_windowing report\n" );
+    fmt::print( "    tot. #leaves = {:5d}, tot. #divs = {:5d}, sum  |MFFC| = {:5d}\n", num_leaves, num_divisors, sum_mffc_size );
+    fmt::print( "    avg. #leaves = {:>5.2f}, avg. #divs = {:>5.2f}, avg. |MFFC| = {:>5.2f}\n", float( num_leaves ) / float( num_windows ), float( num_divisors ) / float( num_windows ), float( sum_mffc_size ) / float( num_windows ) );
+    fmt::print( "    ===== Runtime Breakdown =====\n" );
+    fmt::print( "    Total       : {:>5.2f} secs\n", to_seconds( time_total ) );
+    fmt::print( "      Cut       : {:>5.2f} secs\n", to_seconds( time_cuts ) );
+    fmt::print( "      MFFC      : {:>5.2f} secs\n", to_seconds( time_mffc ) );
+    fmt::print( "      Divs      : {:>5.2f} secs\n", to_seconds( time_divs ) );
+    fmt::print( "      Simulation: {:>5.2f} secs\n", to_seconds( time_sim ) );
+    fmt::print( "      Dont cares: {:>5.2f} secs\n", to_seconds( time_dont_care ) );
+    // clang-format on
+  }
+};
+
+template<class EngineStats>
+struct resynthesis_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Total number of problems received. */
+  uint32_t num_probs{ 0u };
+
+  /*! \brief Total number of solutions found. */
+  uint32_t num_sols{ 0u };
+
+  /*! \brief Summed sizes of solutions. */
+  uint32_t sum_sol_size{ 0u };
+
+  /*! \brief Summed ratios of solution size over max size. */
+  float sum_ratio{ 0.0 };
+  uint32_t sum_overhead{ 0u };
+
+  /*! \brief Summed max_size of all problems. */
+  uint32_t sum_max_size{ 0u };
+
+  /*! \brief Summed max_size of solved problems. */
+  uint32_t sum_max_size_solved{ 0u };
+
+  /*! \brief Statistics object for the resynthesis engine. */
+  EngineStats rst;
+
+  void report() const
+  {
+    // clang-format off
+    fmt::print( "[i] resynthesis report\n" );
+    fmt::print( "    tot. #problems = {:5d}, tot. #solutions = {:5d}, #sols/#probs = {:>5.2f} (%)\n", num_probs, num_sols, float( num_sols ) / float( num_probs ) * 100.0 );
+    fmt::print( "    avg. |H| = {:>5.2f}, avg. |H|/max = {:>7.4f}, avg. overhead = {:>5.2f}\n", float( sum_sol_size ) / float( num_sols ), sum_ratio / float( num_sols ), sum_overhead / float( num_sols ) );
+    fmt::print( "    avg. max size (all problems) = {:>5.2f}, avg. max size (solved) = {:>5.2f}\n", float( sum_max_size ) / float( num_probs ), float( sum_max_size_solved ) / float( num_sols ) );
+    fmt::print( "    Total runtime: {:>5.2f} secs\n", to_seconds( time_total ) );
+    // clang-format on
+  }
+};
+
+namespace detail
+{
+
+template<class Ntk, class TT>
+struct small_window
+{
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  signal root;
+  uint32_t num_leaves;
+  std::vector<signal> divs;
+  std::vector<uint32_t> div_ids; /* positions of divisor truth tables in `tts` */
+  std::vector<TT> tts;
+  TT care;
+  uint32_t mffc_size;
+  uint32_t max_size{ std::numeric_limits<uint32_t>::max() };
+  uint32_t max_level{ std::numeric_limits<uint32_t>::max() };
+};
+
+template<class Ntk, class TT = kitty::dynamic_truth_table>
+class complete_tt_windowing
+{
+public:
+  using problem_t = small_window<Ntk, TT>;
+  using params_t = complete_tt_windowing_params;
+  using stats_t = complete_tt_windowing_stats;
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  explicit complete_tt_windowing( Ntk& ntk, params_t const& ps, stats_t& st )
+      : ntk( ntk ), ps( ps ), st( st ), cps( { ps.max_pis } ), mffc_mgr( ntk ),
+        divs_mgr( ntk, divisor_collector_params( { ps.max_divisors, ps.max_divisors, ps.skip_fanout_limit_for_divisors } ) ),
+        sim( ntk, win.tts, ps.max_pis )
+  {
+    static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+    static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+    static_assert( has_value_v<Ntk>, "Ntk does not implement the value method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+    static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+    static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the substitute_node method" );
+    if constexpr ( !has_level_v<Ntk> )
+    {
+      assert( !ps.preserve_depth && "Ntk does not have depth interface" );
+      assert( !ps.update_levels_lazily && "Ntk does not have depth interface" );
+    }
+  }
+
+  ~complete_tt_windowing()
+  {
+    if constexpr ( has_level_v<Ntk> )
+    {
+      if ( lazy_update_event )
+      {
+        mockturtle::detail::release_lazy_level_update_events( ntk, lazy_update_event );
+      }
+    }
+  }
+
+  void init()
+  {
+    if constexpr ( has_level_v<Ntk> )
+    {
+      if ( ps.update_levels_lazily )
+      {
+        lazy_update_event = mockturtle::detail::register_lazy_level_update_events( ntk );
+      }
+    }
+  }
+
+  std::optional<std::reference_wrapper<problem_t>> operator()( node const& n )
+  {
+    stopwatch t( st.time_total );
+    if ( ntk.fanout_size( n ) > ps.skip_fanout_limit_for_roots )
+    {
+      return std::nullopt; /* skip nodes with too many fanouts */
+    }
+
+    if constexpr ( has_level_v<Ntk> )
+    {
+      if ( ps.preserve_depth )
+      {
+        win.max_level = ntk.level( n ) - 1;
+        divs_mgr.set_max_level( win.max_level );
+      }
+    }
+
+    /* compute a cut and collect supported nodes */
+    std::vector<node> leaves = call_with_stopwatch( st.time_cuts, [&]() {
+      return reconvergence_driven_cut<Ntk, false, has_level_v<Ntk>>( ntk, { n }, cps ).first;
+    } );
+    std::vector<node> supported;
+    call_with_stopwatch( st.time_divs, [&]() {
+      divs_mgr.collect_supported_nodes( n, leaves, supported );
+    } );
+
+    /* simulate */
+    call_with_stopwatch( st.time_sim, [&]() {
+      sim.simulate( leaves, supported );
+    } );
+
+    /* mark MFFC nodes and collect divisors */
+    ++mffc_marker;
+    win.mffc_size = call_with_stopwatch( st.time_mffc, [&]() {
+      return mffc_mgr.call_on_mffc_and_count( n, leaves, [&]( node const& n ) {
+        ntk.set_value( n, mffc_marker );
+      } );
+    } );
+    call_with_stopwatch( st.time_divs, [&]() {
+      collect_divisors( leaves, supported );
+    } );
+
+    /* normalize */
+    call_with_stopwatch( st.time_sim, [&]() {
+      if ( ps.normalize )
+      {
+        win.root = normalize_truth_tables() ? !ntk.make_signal( n ) : ntk.make_signal( n );
+      }
+      else
+      {
+        win.root = ntk.make_signal( n );
+      }
+    } );
+
+    /* compute don't cares */
+    call_with_stopwatch( st.time_dont_care, [&]() {
+      if ( ps.use_dont_cares )
+      {
+        win.care = ~satisfiability_dont_cares( ntk, leaves, ps.window_size );
+      }
+      else
+      {
+        win.care = ~kitty::create<TT>( ps.max_pis );
+      }
+    } );
+
+    win.max_size = std::min( win.mffc_size - 1, ps.max_inserts );
+
+    st.num_windows++;
+    st.num_leaves += leaves.size();
+    st.num_divisors += win.divs.size();
+    st.sum_mffc_size += win.mffc_size;
+
+    return win;
+  }
+
+  template<typename res_t>
+  uint32_t gain( problem_t const& prob, res_t const& res ) const
+  {
+    static_assert( is_index_list_v<res_t>, "res_t is not an index_list (windowing engine and resynthesis engine do not match)" );
+    return prob.mffc_size - res.num_gates();
+  }
+
+  template<typename res_t>
+  bool update_ntk( problem_t const& prob, res_t const& res )
+  {
+    static_assert( is_index_list_v<res_t>, "res_t is not an index_list (windowing engine and resynthesis engine do not match)" );
+    assert( res.num_pos() == 1 );
+    insert( ntk, std::begin( prob.divs ), std::end( prob.divs ), res, [&]( signal const& g ) {
+      ntk.substitute_node( ntk.get_node( prob.root ), ntk.is_complemented( prob.root ) ? !g : g );
+    } );
+    return true; /* continue optimization */
+  }
+
+  template<typename res_t>
+  bool report( problem_t const& prob, res_t const& res )
+  {
+    static_assert( is_index_list_v<res_t>, "res_t is not an index_list (windowing engine and resynthesis engine do not match)" );
+    assert( res.num_pos() == 1 );
+    fmt::print( "[i] found solution {} for root signal {}{}\n", to_index_list_string( res ), ntk.is_complemented( prob.root ) ? "!" : "", ntk.get_node( prob.root ) );
+    return true;
+  }
+
+private:
+  void collect_divisors( std::vector<node> const& leaves, std::vector<node> const& supported )
+  {
+    win.divs.clear();
+    win.div_ids.clear();
+
+    uint32_t i{ 1 };
+    for ( auto const& l : leaves )
+    {
+      win.div_ids.emplace_back( i++ );
+      win.divs.emplace_back( ntk.make_signal( l ) );
+    }
+    win.num_leaves = leaves.size();
+
+    i = ps.max_pis + 1;
+    for ( auto const& n : supported )
+    {
+      if ( ntk.value( n ) != mffc_marker ) /* not in MFFC, not root */
+      {
+        win.div_ids.emplace_back( i );
+        win.divs.emplace_back( ntk.make_signal( n ) );
+      }
+      ++i;
+    }
+    assert( i == win.tts.size() );
+  }
+
+  bool normalize_truth_tables()
+  {
+    assert( win.divs.size() == win.div_ids.size() );
+    for ( auto i = 0u; i < win.divs.size(); ++i )
+    {
+      if ( kitty::get_bit( win.tts.at( win.div_ids.at( i ) ), 0 ) )
+      {
+        win.tts.at( win.div_ids.at( i ) ) = ~win.tts.at( win.div_ids.at( i ) );
+        win.divs.at( i ) = !win.divs.at( i );
+      }
+    }
+
+    if ( kitty::get_bit( win.tts.back(), 0 ) )
+    {
+      win.tts.back() = ~win.tts.back();
+      return true;
+    }
+    else
+    {
+      return false;
+    }
+  }
+
+private:
+  Ntk& ntk;
+  problem_t win;
+  params_t const& ps;
+  stats_t& st;
+  reconvergence_driven_cut_parameters const cps;
+  typename mockturtle::detail::node_mffc_inside<Ntk> mffc_mgr; // TODO: namespaces can be removed when we move out of experimental::
+  divisor_collector<Ntk> divs_mgr;
+  window_simulator<Ntk, TT> sim;
+  uint32_t mffc_marker{ 0u };
+  std::shared_ptr<typename network_events<Ntk>::modified_event_type> lazy_update_event;
+}; /* complete_tt_windowing */
+
+template<class Ntk, class TT, class ResynEngine, bool preserve_depth = false>
+class complete_tt_resynthesis
+{
+public:
+  using problem_t = small_window<Ntk, TT>;
+  using res_t = typename ResynEngine::index_list_t;
+  using params_t = null_params;
+  using stats_t = resynthesis_stats<typename ResynEngine::stats>;
+
+  explicit complete_tt_resynthesis( Ntk const& ntk, params_t const& ps, stats_t& st )
+      : ntk( ntk ), st( st ), engine( st.rst )
+  {}
+
+  void init()
+  {}
+
+  std::optional<res_t> operator()( problem_t& prob )
+  {
+    ++st.num_probs;
+    st.sum_max_size += prob.max_size;
+    auto const res = call_with_stopwatch( st.time_total, [&](){
+      if constexpr ( preserve_depth )
+      {
+        return engine( prob.tts.back(), prob.care, std::begin( prob.div_ids ), std::end( prob.div_ids ), prob.tts, prob.max_size, prob.max_level );
+      }
+      else
+      {
+        return engine( prob.tts.back(), prob.care, std::begin( prob.div_ids ), std::end( prob.div_ids ), prob.tts, prob.max_size );
+      }
+    });
+    if ( res )
+    {
+      ++st.num_sols;
+      st.sum_max_size_solved += prob.max_size;
+      st.sum_sol_size += res->num_gates();
+      if ( prob.max_size == 0 )
+        st.sum_ratio += 1;
+      else
+        st.sum_ratio += float( res->num_gates() ) / float( prob.max_size );
+    }
+    return res;
+  }
+
+private:
+  Ntk const& ntk;
+  stats_t& st;
+  ResynEngine engine;
+}; /* complete_tt_resynthesis */
+
+template<class Ntk, class TT, class index_list_t = xag_index_list<false>>
+class exact_resynthesis
+{
+public:
+  using problem_t = small_window<Ntk, TT>;
+  using res_t = index_list_t;
+  using params_t = null_params;
+  using stats_t = resynthesis_stats<null_stats>;
+
+  explicit exact_resynthesis( Ntk const& ntk, params_t const& ps, stats_t& st )
+      : ntk( ntk ), st( st )
+  {}
+
+  void init()
+  {
+    _allow_xor = false;
+  }
+
+  std::optional<res_t> operator()( problem_t& prob )
+  {
+    ++st.num_probs;
+    st.sum_max_size += prob.max_size;
+    auto c = call_with_stopwatch( st.time_total, [&](){
+      return solve( prob );
+    });
+
+    if ( c && c->get_nr_steps() <= prob.max_size )
+    {
+      ++st.num_sols;
+      st.sum_max_size_solved += prob.max_size;
+      st.sum_sol_size += c->get_nr_steps();
+      if ( prob.max_size == 0 )
+        st.sum_ratio += 1;
+      else
+        st.sum_ratio += float( c->get_nr_steps() ) / float( prob.max_size );
+      //return translate( prob, *c );
+    }
+    return std::nullopt;
+  }
+
+private:
+  std::optional<percy::chain> solve( problem_t& prob )
+  {
+    percy::spec spec;
+    if ( !_allow_xor )
+    {
+      spec.set_primitive( percy::AIG );
+    }
+    spec.fanin = 2;
+    spec.verbosity = 0;
+    spec.add_alonce_clauses = _ps.add_alonce_clauses;
+    spec.add_colex_clauses = _ps.add_colex_clauses;
+    spec.add_lex_clauses = _ps.add_lex_clauses;
+    spec.add_lex_func_clauses = _ps.add_lex_func_clauses;
+    spec.add_nontriv_clauses = _ps.add_nontriv_clauses;
+    spec.add_noreapply_clauses = _ps.add_noreapply_clauses;
+    spec.add_symvar_clauses = _ps.add_symvar_clauses;
+    spec.conflict_limit = _ps.conflict_limit;
+    spec.max_nr_steps = prob.max_size;
+
+    TT const& target = prob.tts.back();
+    spec[0] = target;
+    bool with_dont_cares{ false };
+    if ( !kitty::is_const0( ~prob.care ) )
+    {
+      spec.set_dont_care( 0, ~prob.care );
+      with_dont_cares = true;
+    }
+
+    /* add divisors */
+    for ( auto i = prob.num_leaves; i < prob.divs.size(); ++i )
+    {
+      spec.add_function( prob.tts[prob.div_ids[i]] );
+    }
+
+    //if ( !with_dont_cares && _ps.cache )
+    //{
+    //  const auto it = _ps.cache->find( target );
+    //  if ( it != _ps.cache->end() )
+    //  {
+    //    return it->second;
+    //  }
+    //}
+    //if ( !with_dont_cares && _ps.blacklist_cache )
+    //{
+    //  const auto it = _ps.blacklist_cache->find( target );
+    //  if ( it != _ps.blacklist_cache->end() && ( it->second == 0 || _ps.conflict_limit <= it->second ) )
+    //  {
+    //    return std::nullopt;
+    //  }
+    //}
+
+    percy::chain c;
+    if ( const auto result = percy::synthesize( spec, c, _ps.solver_type,
+                                                _ps.encoder_type,
+                                                _ps.synthesis_method );
+         result != percy::success )
+    {
+      //if ( !with_dont_cares && _ps.blacklist_cache )
+      //{
+      //  ( *_ps.blacklist_cache )[target] = ( result == percy::timeout ) ? _ps.conflict_limit : 0;
+      //}
+      return std::nullopt;
+    }
+
+    assert( kitty::to_hex( c.simulate()[0u] & prob.care ) == kitty::to_hex( target & prob.care ) );
+
+    //if ( !with_dont_cares && _ps.cache )
+    //{
+    //  ( *_ps.cache )[target] = c;
+    //}
+    return c;
+  }
+
+  index_list_t translate( problem_t& prob, percy::chain const& c )
+  {
+    index_list_t il( prob.divs.size() );
+    /* Doesn't work well yet
+    std::vector<bool> negated( prob.divs.size() + c->get_nr_steps() + 1, false );
+    for ( auto i = 0; i < c->get_nr_steps(); ++i )
+    {
+      auto const v1 = c->get_step( i )[0] + 1; // +1 : zero-based to one-based indices
+      auto const v2 = c->get_step( i )[1] + 1;
+      auto const l1 = negated[v1] ? ( v1 << 1 ) ^ 0x1 : v1 << 1;
+      auto const l2 = negated[v2] ? ( v2 << 1 ) ^ 0x1 : v2 << 1;
+
+      switch ( c->get_operator( i )._bits[0] )
+      {
+      default:
+        std::cerr << "[e] unsupported operation " << kitty::to_hex( c->get_operator( i ) ) << "\n";
+        assert( false );
+        break;
+      case 0x8:
+        il.add_and( l1, l2 );
+        break;
+      case 0x4:
+        il.add_and( l1 ^ 0x1, l2 );
+        break;
+      case 0x2:
+        il.add_and( l1, l2 ^ 0x1 );
+        break;
+      case 0xe:
+        negated[il.add_and( l1 ^ 0x1, l2 ^ 0x1 ) >> 1] = true;
+        break;
+      case 0x6:
+        il.add_xor( l1, l2 );
+        break;
+      }
+    }
+
+    auto const last_lit = ( prob.divs.size() + c->get_nr_steps() ) << 1;
+    il.add_output( c->is_output_inverted( 0 ) ? last_lit ^ 0x1 : last_lit );
+    */
+    return il;
+  }
+
+private:
+  Ntk const& ntk;
+  bool _allow_xor;
+  struct
+  {
+    using cache_map_t = std::unordered_map<kitty::dynamic_truth_table, percy::chain, kitty::hash<kitty::dynamic_truth_table>>;
+    using cache_t = std::shared_ptr<cache_map_t>;
+
+    using blacklist_cache_map_t = std::unordered_map<kitty::dynamic_truth_table, int32_t, kitty::hash<kitty::dynamic_truth_table>>;
+    using blacklist_cache_t = std::shared_ptr<blacklist_cache_map_t>;
+
+    cache_t cache;
+    blacklist_cache_t blacklist_cache;
+
+    bool add_alonce_clauses{ true };
+    bool add_colex_clauses{ true };
+    bool add_lex_clauses{ false };
+    bool add_lex_func_clauses{ true };
+    bool add_nontriv_clauses{ true };
+    bool add_noreapply_clauses{ true };
+    bool add_symvar_clauses{ true };
+    int conflict_limit{ 1000 };
+
+    percy::SolverType solver_type = percy::SLV_BSAT2;
+    percy::EncoderType encoder_type = percy::ENC_SSV;
+    percy::SynthMethod synthesis_method = percy::SYNTH_STD;
+  } _ps;
+  stats_t& st;
+}; /* exact_resynthesis */
+
+} /* namespace detail */
+
+using window_resub_params = boolean_optimization_params<complete_tt_windowing_params, null_params>;
+using window_resub_stats = boolean_optimization_stats<complete_tt_windowing_stats, resynthesis_stats<null_stats>>;
+using window_resub_stats_xag = boolean_optimization_stats<complete_tt_windowing_stats, resynthesis_stats<xag_resyn_stats>>;
+using window_resub_stats_aig_enum = boolean_optimization_stats<complete_tt_windowing_stats, resynthesis_stats<aig_enumerative_resyn_stats>>;
+using window_resub_stats_mig = boolean_optimization_stats<complete_tt_windowing_stats, resynthesis_stats<mig_resyn_stats>>;
+
+template<class Ntk>
+void window_xag_heuristic_resub( Ntk& ntk, window_resub_params const& ps = {}, window_resub_stats_xag* pst = nullptr )
+{
+  static_assert( std::is_same_v<typename Ntk::base_type, xag_network>, "Ntk::base_type is not xag_network" );
+
+  using ViewedNtk = depth_view<fanout_view<Ntk>>;
+  fanout_view<Ntk> fntk( ntk );
+  ViewedNtk viewed( fntk );
+
+  using TT = typename kitty::dynamic_truth_table;
+  using windowing_t = typename detail::complete_tt_windowing<ViewedNtk, TT>;
+  using engine_t = xag_resyn_decompose<TT, xag_resyn_static_params_default<TT>>;
+  using resyn_t = typename detail::complete_tt_resynthesis<ViewedNtk, TT, engine_t>;
+  using opt_t = typename detail::boolean_optimization_impl<ViewedNtk, windowing_t, resyn_t>;
+
+  window_resub_stats_xag st;
+  opt_t p( viewed, ps, st );
+  p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+template<class Ntk>
+void window_aig_heuristic_resub( Ntk& ntk, window_resub_params const& ps = {}, window_resub_stats_xag* pst = nullptr )
+{
+  static_assert( std::is_same_v<typename Ntk::base_type, aig_network>, "Ntk::base_type is not aig_network" );
+
+  using ViewedNtk = depth_view<fanout_view<Ntk>>;
+  fanout_view<Ntk> fntk( ntk );
+  ViewedNtk viewed( fntk );
+
+  using TT = typename kitty::dynamic_truth_table;
+  using windowing_t = typename detail::complete_tt_windowing<ViewedNtk, TT>;
+  using engine_t = xag_resyn_decompose<TT, aig_resyn_static_params_default<TT>>;
+  using resyn_t = typename detail::complete_tt_resynthesis<ViewedNtk, TT, engine_t>;
+  using opt_t = typename detail::boolean_optimization_impl<ViewedNtk, windowing_t, resyn_t>;
+
+  window_resub_stats_xag st;
+  opt_t p( viewed, ps, st );
+  p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+template<class Ntk>
+void window_aig_enumerative_resub( Ntk& ntk, window_resub_params const& ps = {}, window_resub_stats_aig_enum* pst = nullptr )
+{
+  using ViewedNtk = depth_view<fanout_view<Ntk>>;
+  fanout_view<Ntk> fntk( ntk );
+  ViewedNtk viewed( fntk );
+
+  window_resub_stats_aig_enum st;
+
+  using TT = typename kitty::static_truth_table<8>;
+  using windowing_t = typename detail::complete_tt_windowing<ViewedNtk, TT>;
+  if ( ps.wps.normalize )
+  {
+    using engine_t = aig_enumerative_resyn<TT, true>;
+    using resyn_t = typename detail::complete_tt_resynthesis<ViewedNtk, TT, engine_t>;
+    using opt_t = typename detail::boolean_optimization_impl<ViewedNtk, windowing_t, resyn_t>;
+
+    opt_t p( viewed, ps, st );
+    p.run();
+  }
+  else
+  {
+    using engine_t = aig_enumerative_resyn<TT>;
+    using resyn_t = typename detail::complete_tt_resynthesis<ViewedNtk, TT, engine_t>;
+    using opt_t = typename detail::boolean_optimization_impl<ViewedNtk, windowing_t, resyn_t>;
+
+    opt_t p( viewed, ps, st );
+    p.run();
+  }
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+template<class Ntk>
+void window_mig_heuristic_resub( Ntk& ntk, window_resub_params const& ps = {}, window_resub_stats_mig* pst = nullptr )
+{
+  using ViewedNtk = depth_view<fanout_view<Ntk>>;
+  fanout_view<Ntk> fntk( ntk );
+  ViewedNtk viewed( fntk );
+
+  using TT = typename kitty::dynamic_truth_table;
+  using windowing_t = typename detail::complete_tt_windowing<ViewedNtk, TT>;
+  using engine_t = mig_resyn_topdown<TT>;
+  using resyn_t = typename detail::complete_tt_resynthesis<ViewedNtk, TT, engine_t>;
+  using opt_t = typename detail::boolean_optimization_impl<ViewedNtk, windowing_t, resyn_t>;
+
+  window_resub_stats_mig st;
+  opt_t p( viewed, ps, st );
+  p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+template<class Ntk>
+void window_mig_enumerative_resub( Ntk& ntk, window_resub_params const& ps = {}, window_resub_stats* pst = nullptr )
+{
+  using ViewedNtk = depth_view<fanout_view<Ntk>>;
+  fanout_view<Ntk> fntk( ntk );
+  ViewedNtk viewed( fntk );
+
+  using TT = typename kitty::dynamic_truth_table;
+  using windowing_t = typename detail::complete_tt_windowing<ViewedNtk, TT>;
+  using engine_t = mig_enumerative_resyn<TT>;
+  using resyn_t = typename detail::complete_tt_resynthesis<ViewedNtk, TT, engine_t>;
+  using opt_t = typename detail::boolean_optimization_impl<ViewedNtk, windowing_t, resyn_t>;
+
+  window_resub_stats st;
+  opt_t p( viewed, ps, st );
+  p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle::experimental */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/explorer.hpp b/include/mockturtle/algorithms/explorer.hpp
new file mode 100644
index 0000000..1e27c6e
--- /dev/null
+++ b/include/mockturtle/algorithms/explorer.hpp
@@ -0,0 +1,996 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file explorer.hpp
+  \brief Implements the design space explorer engine
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "lut_mapper.hpp"
+#include "collapse_mapped.hpp"
+#include "klut_to_graph.hpp"
+#include "cut_rewriting.hpp"
+#include "refactoring.hpp"
+#include "mig_algebraic_rewriting.hpp"
+#include "mapper.hpp"
+#include "rewrite.hpp"
+#include "node_resynthesis/mig_npn.hpp"
+#include "node_resynthesis/sop_factoring.hpp"
+#include "resubstitution.hpp"
+#include "aig_resub.hpp"
+#include "mig_resub.hpp"
+#include "sim_resub.hpp"
+#include "cleanup.hpp"
+#include "balancing.hpp"
+#include "balancing/sop_balancing.hpp"
+#include "aig_balancing.hpp"
+#include "miter.hpp"
+#include "equivalence_checking.hpp"
+#include "aqfp/buffer_insertion.hpp"
+#include "../networks/klut.hpp"
+#include "../networks/mig.hpp"
+#include "../views/mapping_view.hpp"
+#include "../io/write_verilog.hpp"
+#include "../io/write_aiger.hpp"
+#include "../io/verilog_reader.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../utils/abc.hpp"
+
+#include <random>
+
+#define explorer_debug 0
+
+namespace mockturtle
+{
+
+struct explorer_params
+{
+  /*! \brief Number of iterations to run with different random seed, restarting from the original
+   * network (including the first iteration). */
+  uint32_t num_restarts{1u};
+
+  /*! \brief Initial random seed used to generate random seeds randomly. */
+  uint32_t random_seed{0u};
+
+  /*! \brief Maximum number of steps in each iteration. */
+  uint32_t max_steps{100000u};
+
+  /*! \brief Maximum number of steps without improvement in each iteration. */
+  uint32_t max_steps_no_impr{1000000u};
+
+  /*! \brief Number of compressing scripts to run per step. */
+  uint32_t compressing_scripts_per_step{3u};
+
+  /*! \brief Timeout per iteration in seconds. */
+  uint32_t timeout{30u};
+
+  /*! \brief Be verbose. */
+  bool verbose{false};
+
+  /*! \brief Be very verbose. */
+  bool very_verbose{false};
+};
+
+struct explorer_stats
+{
+  stopwatch<>::duration time_total{0};
+  stopwatch<>::duration time_evaluate{0};
+};
+
+template<class Ntk>
+using script_t = std::function<void( Ntk&, uint32_t, uint32_t )>;
+
+template<class Ntk>
+using cost_fn_t = std::function<uint32_t( Ntk const& )>;
+
+template<class Ntk>
+std::function<uint32_t( Ntk const& )> size_cost_fn = []( Ntk const& ntk ){ return ntk.num_gates(); };
+
+template<class Ntk>
+class explorer
+{
+public:
+  using RandEngine = std::default_random_engine;
+
+  explorer( explorer_params const& ps, explorer_stats& st, cost_fn_t<Ntk> const& cost_fn = size_cost_fn<Ntk> )
+      : _ps( ps ), _st( st ), cost( cost_fn )
+  {
+  }
+
+  void add_decompressing_script( script_t<Ntk> const& algo, float weight = 1.0 )
+  {
+    decompressing_scripts.emplace_back( std::make_pair( algo, total_weights_dec ) );
+    total_weights_dec += weight;
+  }
+
+  void add_compressing_script( script_t<Ntk> const& algo, float weight = 1.0 )
+  {
+    compressing_scripts.emplace_back( std::make_pair( algo, total_weights_com ) );
+    total_weights_com += weight;
+  }
+
+  Ntk run( Ntk const& ntk )
+  {
+    stopwatch t( _st.time_total );
+    if ( decompressing_scripts.size() == 0 )
+    {
+      std::cerr << "[e] No decompressing script provided.\n";
+      return ntk;
+    }
+    if ( compressing_scripts.size() == 0 )
+    {
+      std::cerr << "[e] No compressing script provided.\n";
+      return ntk;
+    }
+
+    RandEngine rnd( _ps.random_seed );
+    auto init_cost = call_with_stopwatch( _st.time_evaluate, [&](){ return cost( ntk ); } );
+    Ntk best = ntk.clone();
+    auto best_cost = init_cost;
+    for ( auto i = 0u; i < _ps.num_restarts; ++i )
+    {
+      Ntk current = ntk.clone();
+      auto new_cost = run_one_iteration( current, rnd(), init_cost );
+      if ( new_cost < best_cost )
+      {
+        best = current.clone();
+        best_cost = new_cost;
+      }
+      if ( _ps.verbose )
+        fmt::print( "[i] best cost in restart {}: {}, overall best cost: {}\n", i, new_cost, best_cost );
+    }
+    return best;
+  }
+
+private:
+  uint32_t run_one_iteration( Ntk& ntk, uint32_t seed, uint32_t init_cost )
+  {
+    if ( _ps.verbose )
+    {
+      fmt::print( "\n[i] new restart using seed {}, original cost = {}\n", seed, init_cost );
+    }
+ 
+    stopwatch<>::duration elapsed_time{0};
+    RandEngine rnd( seed );
+    Ntk best = ntk.clone();
+    auto best_cost = init_cost;
+    uint32_t last_update{0u};
+    for ( auto i = 0u; i < _ps.max_steps; ++i )
+    {
+    #if explorer_debug
+      Ntk backup = ntk.clone();
+    #endif
+
+      {
+        stopwatch t( elapsed_time );
+        decompress( ntk, rnd, i );
+        compress( ntk, rnd, i );
+      }
+      auto new_cost = call_with_stopwatch( _st.time_evaluate, [&](){ return cost( ntk ); } );
+      if ( _ps.very_verbose )
+        fmt::print( "[i] after step {}, cost = {}\n", i, new_cost );
+
+    #if explorer_debug
+      if ( !*equivalence_checking( *miter<Ntk>( ntk, best ) ) )
+      {
+        write_verilog( backup, "debug.v" );
+        write_verilog( ntk, "wrong.v" );
+        fmt::print( "NEQ at step {}!\n", i );
+        break;
+      }
+    #endif
+
+      if ( new_cost < best_cost )
+      {
+        best = ntk.clone();
+        best_cost = new_cost;
+        last_update = i;
+        if ( _ps.verbose )
+        {
+          fmt::print( "[i] updated new best at step {}: {}\n", i, best_cost );
+        }
+      }
+      if ( i - last_update >= _ps.max_steps_no_impr )
+      {
+        if ( _ps.verbose )
+          fmt::print( "[i] break restart at step {} after {} steps without improvement (elapsed time: {} secs)\n", i, _ps.max_steps_no_impr, to_seconds( elapsed_time ) );
+        break;
+      }
+      if ( to_seconds( elapsed_time ) >= _ps.timeout )
+      {
+        if ( _ps.verbose )
+          fmt::print( "[i] break restart at step {} after timeout of {} secs\n", i, to_seconds( elapsed_time ) );
+        break;
+      }
+    }
+    std::cout << std::flush;
+    ntk = best;
+    return best_cost;
+  }
+
+  void decompress( Ntk& ntk, RandEngine& rnd, uint32_t i )
+  {
+    std::uniform_real_distribution<> dis( 0.0, total_weights_dec );
+    float r = dis( rnd );
+    for ( auto it = decompressing_scripts.rbegin(); it != decompressing_scripts.rend(); ++it )
+    {
+      if ( r >= it->second )
+      {
+        it->first( ntk, i, rnd() );
+        break;
+      }
+    }
+  }
+
+  void compress( Ntk& ntk, RandEngine& rnd, uint32_t i )
+  {
+    std::uniform_real_distribution<> dis( 0.0, total_weights_com );
+    for ( auto j = 0u; j < _ps.compressing_scripts_per_step; ++j )
+    {
+      float r = dis( rnd );
+      for ( auto it = compressing_scripts.rbegin(); it != compressing_scripts.rend(); ++it )
+      {
+        if ( r >= it->second )
+        {
+          it->first( ntk, i, rnd() );
+          break;
+        }
+      }
+    }
+  }
+
+private:
+  const explorer_params _ps;
+  explorer_stats& _st;
+
+  std::vector<std::pair<script_t<Ntk>, float>> decompressing_scripts;
+  float total_weights_dec{0.0};
+  std::vector<std::pair<script_t<Ntk>, float>> compressing_scripts;
+  float total_weights_com{0.0};
+
+  cost_fn_t<Ntk> cost;
+};
+
+mig_network explore_mig( mig_network const& ntk, explorer_params const ps = {} )
+{
+  using Ntk = mig_network;
+
+  explorer_stats st;
+  explorer<Ntk> expl( ps, st );
+
+  expl.add_decompressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "decompressing with k-LUT mapping using random value {}, k = {}\n", rand, 2 + (rand % 5) );
+    lut_map_params mps;
+    mps.cut_enumeration_ps.cut_size = 3 + (rand & 0x3); //3 + (i % 4);
+    mapping_view<Ntk> mapped{ _ntk };
+    lut_map( mapped, mps );
+    const auto klut = *collapse_mapped_network<klut_network>( mapped );
+    
+    if ( (rand >> 2) & 0x1 )
+    {
+      _ntk = convert_klut_to_graph<Ntk>( klut );
+    }
+    else
+    {
+      sop_factoring<Ntk> resyn;
+      _ntk = node_resynthesis<Ntk>( klut, resyn );
+    }
+  } );
+
+  expl.add_decompressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "decompressing with break-MAJ using random value {}\n", rand );
+    std::mt19937 g( rand );
+    _ntk.foreach_gate( [&]( auto n ){
+      bool is_maj = true;
+      _ntk.foreach_fanin( n, [&]( auto fi ){
+        if ( _ntk.is_constant( _ntk.get_node( fi ) ) )
+          is_maj = false;
+        return;
+      });
+      if ( !is_maj )
+        return;
+      std::vector<typename Ntk::signal> fanins;
+      _ntk.foreach_fanin( n, [&]( auto fi ){
+        fanins.emplace_back( fi );
+      });
+
+      std::shuffle( fanins.begin(), fanins.end(), g );
+      _ntk.substitute_node( n, _ntk.create_or( _ntk.create_and( fanins[0], fanins[1] ), _ntk.create_and( fanins[2], !_ntk.create_and( !fanins[0], !fanins[1] ) ) ) );
+    });
+  } );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    mig_npn_resynthesis resyn{ true };
+    exact_library<mig_network> exact_lib( resyn );
+    map_params mps;
+    mps.skip_delay_round = true;
+    mps.required_time = std::numeric_limits<double>::max();
+    mps.area_flow_rounds = 1;
+    mps.enable_logic_sharing = rand & 0x1; /* high-effort remap */
+    _ntk = map( _ntk, exact_lib, mps );
+  } );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    resubstitution_params rps;
+    rps.max_inserts = rand & 0x7;
+    rps.max_pis = (rand >> 3) & 0x1 ? 6 : 8;
+    depth_view depth_mig{ _ntk };
+    fanout_view fanout_mig{ depth_mig };
+    mig_resubstitution2( fanout_mig, rps );
+    _ntk = cleanup_dangling( _ntk );
+  } );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    sop_rebalancing<mig_network> balance_fn;
+    balancing_params bps;
+    bps.cut_enumeration_ps.cut_size = 6u;
+    _ntk = balancing( _ntk, {balance_fn}, bps );
+  } );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    depth_view depth_mig{ _ntk };
+    mig_algebraic_depth_rewriting( depth_mig );
+    _ntk = cleanup_dangling( _ntk );
+  } );
+
+  return expl.run( ntk );
+}
+
+#ifdef ENABLE_ABC
+mig_network deepsyn_mig_v1( mig_network const& ntk, explorer_params const ps = {} )
+{
+  using Ntk = mig_network;
+
+  explorer_stats st;
+  explorer<Ntk> expl( ps, st );
+
+  expl.add_decompressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "decompressing with &if using random value {}\n", rand );
+    aig_network aig = cleanup_dangling<mig_network, aig_network>( _ntk );
+
+    std::string script = fmt::format(
+      "&dch{}; &if -a -K {}; &mfs -e -W 20 -L 20; &st",
+      (rand & 0x1) ? " -f" : "",
+      2 + (i % 5));
+    aig = call_abc_script( aig, script );
+
+    mig_npn_resynthesis resyn2{ true };
+    exact_library<mig_network> exact_lib( resyn2 );
+    map_params mps;
+    mps.skip_delay_round = true;
+    mps.required_time = std::numeric_limits<double>::max();
+    _ntk = map( aig, exact_lib, mps );
+  } );
+
+  expl.add_decompressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "decompressing with k-LUT mapping using random value {}, k = {}\n", rand, 2 + (rand % 5) );
+    lut_map_params mps;
+    mps.cut_enumeration_ps.cut_size = 3 + (rand & 0x3); //3 + (i % 4);
+    klut_network klut = lut_map( _ntk, mps );
+    
+    if ( (rand >> 2) & 0x1 )
+    {
+      _ntk = convert_klut_to_graph<Ntk>( klut );
+    }
+    else
+    {
+      sop_factoring<Ntk> resyn;
+      _ntk = node_resynthesis<Ntk>( klut, resyn );
+    }
+  } );
+
+  expl.add_decompressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "decompressing with break-MAJ using random value {}\n", rand );
+    std::mt19937 g( rand );
+    _ntk.foreach_gate( [&]( auto n ){
+      bool is_maj = true;
+      _ntk.foreach_fanin( n, [&]( auto fi ){
+        if ( _ntk.is_constant( _ntk.get_node( fi ) ) )
+          is_maj = false;
+        return;
+      });
+      if ( !is_maj )
+        return;
+      std::vector<typename Ntk::signal> fanins;
+      _ntk.foreach_fanin( n, [&]( auto fi ){
+        fanins.emplace_back( fi );
+      });
+
+      std::shuffle( fanins.begin(), fanins.end(), g );
+      _ntk.substitute_node( n, _ntk.create_or( _ntk.create_and( fanins[0], fanins[1] ), _ntk.create_and( fanins[2], !_ntk.create_and( !fanins[0], !fanins[1] ) ) ) );
+    });
+    _ntk = cleanup_dangling( _ntk );
+  } );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "compressing with resyn2rs using random value {}\n", rand );
+    aig_network aig = cleanup_dangling<mig_network, aig_network>( _ntk );
+    //std::string script = (rand & 0x1) ? "; &c2rs" : "; &dc2";
+    std::string script = "&put; resyn2rs; &get";
+
+    aig = call_abc_script( aig, script );
+    
+    mig_npn_resynthesis resyn{ true };
+    exact_library_params eps;
+    eps.np_classification = false;
+    eps.compute_dc_classes = rand & 0x2;
+    exact_library<mig_network> exact_lib( resyn, eps );
+    map_params mps;
+    mps.skip_delay_round = true;
+    mps.required_time = std::numeric_limits<double>::max();
+    mps.area_flow_rounds = 1;
+    mps.enable_logic_sharing = rand & 0x1; // high-effort remap
+    mps.use_dont_cares = rand & 0x2;
+    _ntk = map( aig, exact_lib, mps );
+  } );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "compressing with remapping using random value {}\n", rand );
+    mig_npn_resynthesis resyn{ true };
+    exact_library_params eps;
+    eps.np_classification = false;
+    eps.compute_dc_classes = rand & 0x2;
+    exact_library<mig_network> exact_lib( resyn, eps );
+    map_params mps;
+    mps.skip_delay_round = true;
+    mps.required_time = std::numeric_limits<double>::max();
+    mps.area_flow_rounds = 1;
+    mps.enable_logic_sharing = rand & 0x1; // high-effort remap
+    mps.use_dont_cares = rand & 0x2;
+    _ntk = map( _ntk, exact_lib, mps );
+  } );
+  
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "compressing with rewriting using random value {}\n", rand );
+    mig_npn_resynthesis resyn{ true };
+    exact_library_params eps;
+    eps.np_classification = false;
+    eps.compute_dc_classes = rand & 0x1;
+    exact_library<mig_network> exact_lib( resyn, eps );
+    rewrite_params rps;
+    rps.use_dont_cares = rand & 0x1;
+    rewrite( _ntk, exact_lib, rps );
+    _ntk = cleanup_dangling( _ntk );
+  } );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "compressing with resub using random value {}\n", rand );
+    resubstitution_params rps;
+    rps.max_inserts = (rand >> 1) & 0x7;
+    rps.max_pis = (rand >> 4) & 0x3 ? 6 : 8;
+    depth_view depth_mig{ _ntk };
+    fanout_view fanout_mig{ depth_mig };
+    mig_resubstitution2( fanout_mig, rps );
+    _ntk = cleanup_dangling( _ntk );
+  } );
+
+  return expl.run( ntk );
+}
+
+mig_network deepsyn_mig_v2( mig_network const& ntk, explorer_params const ps = {} )
+{
+  using Ntk = mig_network;
+
+  explorer_stats st;
+  explorer<Ntk> expl( ps, st );
+
+  expl.add_decompressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "decompressing with &if using random value {}\n", rand );
+    aig_network aig = cleanup_dangling<mig_network, aig_network>( _ntk );
+
+    std::string script = fmt::format(
+      "&dch{}; &if -a -K {}; &mfs -e -W 20 -L 20; &st",
+      (rand & 0x1) ? " -f" : "",
+      2 + (i % 5));
+    aig = call_abc_script( aig, script );
+
+    mig_npn_resynthesis resyn2{ true };
+    exact_library<mig_network> exact_lib( resyn2 );
+    map_params mps;
+    mps.skip_delay_round = true;
+    mps.required_time = std::numeric_limits<double>::max();
+    _ntk = map( aig, exact_lib, mps );
+  } );
+
+  expl.add_decompressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "decompressing with k-LUT mapping using random value {}, k = {}\n", rand, 2 + (rand % 5) );
+    lut_map_params mps;
+    mps.cut_enumeration_ps.cut_size = 3 + (rand & 0x3); //3 + (i % 4);
+    klut_network klut = lut_map( _ntk, mps );
+    
+    if ( (rand >> 2) & 0x1 )
+    {
+      _ntk = convert_klut_to_graph<Ntk>( klut );
+    }
+    else
+    {
+      sop_factoring<Ntk> resyn;
+      _ntk = node_resynthesis<Ntk>( klut, resyn );
+    }
+  } );
+
+  expl.add_decompressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "decompressing with break-MAJ using random value {}\n", rand );
+    std::mt19937 g( rand );
+    _ntk.foreach_gate( [&]( auto n ){
+      bool is_maj = true;
+      _ntk.foreach_fanin( n, [&]( auto fi ){
+        if ( _ntk.is_constant( _ntk.get_node( fi ) ) )
+          is_maj = false;
+        return;
+      });
+      if ( !is_maj )
+        return;
+      std::vector<typename Ntk::signal> fanins;
+      _ntk.foreach_fanin( n, [&]( auto fi ){
+        fanins.emplace_back( fi );
+      });
+
+      std::shuffle( fanins.begin(), fanins.end(), g );
+      _ntk.substitute_node( n, _ntk.create_or( _ntk.create_and( fanins[0], fanins[1] ), _ntk.create_and( fanins[2], !_ntk.create_and( !fanins[0], !fanins[1] ) ) ) );
+    });
+    _ntk = cleanup_dangling( _ntk );
+  } );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "compressing with resyn2rs using random value {}\n", rand );
+    aig_network aig = cleanup_dangling<mig_network, aig_network>( _ntk );
+    //std::string script = (rand & 0x1) ? "; &c2rs" : "; &dc2";
+    std::string script = "&put; resyn2rs; &get";
+
+    aig = call_abc_script( aig, script );
+    
+    mig_npn_resynthesis resyn{ true };
+    exact_library_params eps;
+    eps.np_classification = false;
+    eps.compute_dc_classes = rand & 0x2;
+    exact_library<mig_network> exact_lib( resyn, eps );
+    map_params mps;
+    mps.skip_delay_round = true;
+    mps.required_time = std::numeric_limits<double>::max();
+    mps.area_flow_rounds = 1;
+    mps.enable_logic_sharing = rand & 0x1; // high-effort remap
+    mps.use_dont_cares = rand & 0x2;
+    _ntk = map( aig, exact_lib, mps );
+  } );
+  
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "compressing with Ale flow using random value {}\n", rand );
+    //_ntk = cleanup_dangling( _ntk );
+
+    mig_npn_resynthesis resyn{ true };
+    exact_library_params eps;
+    eps.np_classification = false;
+    eps.compute_dc_classes = true;
+    exact_library<mig_network> exact_lib( resyn, eps );
+    
+    map_params mps;
+    mps.skip_delay_round = true;
+    mps.required_time = std::numeric_limits<double>::max();
+    mps.area_flow_rounds = 1;
+    mps.enable_logic_sharing = true; // high-effort remap
+    
+    rewrite_params rps;
+
+    resubstitution_params rsps;
+    rsps.max_inserts = 20;
+    rsps.max_pis = 8;
+    
+    mps.use_dont_cares = rand & 0x8;
+    _ntk = map( _ntk, exact_lib, mps );
+    mps.use_dont_cares = rand & 0xf;
+    _ntk = map( _ntk, exact_lib, mps );
+    mps.use_dont_cares = rand & 0x10;
+    _ntk = map( _ntk, exact_lib, mps );
+
+    rps.use_dont_cares = rand & 0x1;
+    rewrite( _ntk, exact_lib, rps );
+    _ntk = cleanup_dangling( _ntk );
+    rps.use_dont_cares = rand & 0x2;
+    rewrite( _ntk, exact_lib, rps );
+    _ntk = cleanup_dangling( _ntk );
+    rps.use_dont_cares = rand & 0x4;
+    rewrite( _ntk, exact_lib, rps );
+    _ntk = cleanup_dangling( _ntk );
+
+    depth_view depth_mig{ _ntk };
+    fanout_view fanout_mig{ depth_mig };
+    mig_resubstitution2( fanout_mig, rsps );
+    _ntk = cleanup_dangling( _ntk );
+  } );
+
+  return expl.run( ntk );
+}
+
+mig_network deepsyn_mig_depth( mig_network const& ntk, explorer_params const ps = {} )
+{
+  using Ntk = mig_network;
+
+  cost_fn_t<Ntk> depth_cost = []( Ntk const& _ntk ){
+    depth_view d{ _ntk };
+    return d.depth();
+  };
+
+  explorer_stats st;
+  explorer<Ntk> expl( ps, st, depth_cost );
+
+  expl.add_decompressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    aig_network aig = cleanup_dangling<mig_network, aig_network>( _ntk );
+
+    std::string script = fmt::format(
+      "&dch{} -m; &if -K {}; &mfs -e -W 20 {}",
+      (rand & 0x1) ? " -f" : "",
+      2 + (i % 5),
+      ((rand >> 2) & 0x1) ? "; &fx; &st" : "");
+    aig = call_abc_script( aig, script );
+
+    mig_npn_resynthesis resyn2{ true };
+    exact_library<mig_network> exact_lib( resyn2 );
+    map_params mps;
+    mps.skip_delay_round = false;
+    mps.required_time = std::numeric_limits<double>::max();
+    _ntk = map( aig, exact_lib, mps );
+  } );
+
+  expl.add_decompressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "decompressing with break-MAJ using random value {}\n", rand );
+    std::mt19937 g( rand );
+    _ntk.foreach_gate( [&]( auto n ){
+      bool is_maj = true;
+      _ntk.foreach_fanin( n, [&]( auto fi ){
+        if ( _ntk.is_constant( _ntk.get_node( fi ) ) )
+          is_maj = false;
+        return;
+      });
+      if ( !is_maj )
+        return;
+      std::vector<typename Ntk::signal> fanins;
+      _ntk.foreach_fanin( n, [&]( auto fi ){
+        fanins.emplace_back( fi );
+      });
+
+      std::shuffle( fanins.begin(), fanins.end(), g );
+      _ntk.substitute_node( n, _ntk.create_or( _ntk.create_and( fanins[0], fanins[1] ), _ntk.create_and( fanins[2], !_ntk.create_and( !fanins[0], !fanins[1] ) ) ) );
+    });
+    _ntk = cleanup_dangling( _ntk );
+  }, 0.3 );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    aig_network aig = cleanup_dangling<mig_network, aig_network>( _ntk );
+    std::string script = "&put; resyn2rs; &get";
+    aig = call_abc_script( aig, script );
+
+    mig_npn_resynthesis resyn2{ true };
+    exact_library<mig_network> exact_lib( resyn2 );
+    map_params mps;
+    mps.skip_delay_round = false;
+    mps.required_time = std::numeric_limits<double>::max();
+    _ntk = map( aig, exact_lib, mps );
+  } );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    mig_npn_resynthesis resyn{ true };
+    exact_library<mig_network> exact_lib( resyn );
+    map_params mps;
+    mps.skip_delay_round = false;
+    //mps.required_time = std::numeric_limits<double>::max();
+    mps.area_flow_rounds = 1;
+    mps.enable_logic_sharing = rand & 0x1; /* high-effort remap */
+    _ntk = map( _ntk, exact_lib, mps );
+  }, 0.5 );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    resubstitution_params rps;
+    rps.max_inserts = rand & 0x7;
+    rps.max_pis = (rand >> 3) & 0x1 ? 6 : 8;
+    depth_view depth_mig{ _ntk };
+    fanout_view fanout_mig{ depth_mig };
+    mig_resubstitution2( fanout_mig, rps );
+    _ntk = cleanup_dangling( _ntk );
+  }, 0.5 );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    sop_rebalancing<mig_network> balance_fn;
+    balancing_params bps;
+    bps.cut_enumeration_ps.cut_size = ( rand & 0x1 ) ? 8 : 10;
+    _ntk = balancing( _ntk, {balance_fn}, bps );
+  } );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    depth_view depth_mig{ _ntk };
+    mig_algebraic_depth_rewriting( depth_mig );
+    _ntk = cleanup_dangling( _ntk );
+  } );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    sop_factoring<Ntk> resyn;
+    refactoring( _ntk, resyn );
+    _ntk = cleanup_dangling( _ntk );
+  }, 0.5 );
+
+  return expl.run( ntk );
+}
+
+aig_network deepsyn_aig( aig_network const& ntk, explorer_params const ps = {} )
+{
+  using Ntk = aig_network;
+
+  explorer_stats st;
+  explorer<Ntk> expl( ps, st );
+
+  expl.add_decompressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    std::string script = fmt::format(
+      "&dch{}; &if -a -K {}; &mfs -e -W 20 -L 20{}",
+      (rand & 0x1) ? " -f" : "",
+      2 + (i % 5),
+      ((rand >> 2) & 0x1) ? "; &fx; &st" : "");
+    _ntk = call_abc_script( _ntk, script );
+  } );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    std::string script = (rand & 0x1) ? "; &c2rs" : "; &dc2";
+    _ntk = call_abc_script( _ntk, script );
+  } );
+
+  return expl.run( ntk );
+}
+
+mig_network deepsyn_aqfp( mig_network const& ntk, explorer_params const ps = {}, explorer_stats * pst = nullptr )
+{
+  using Ntk = mig_network;
+
+  cost_fn_t<Ntk> aqfp_cost = []( Ntk const& _ntk ){
+    buffer_insertion_params bps;
+    bps.assume.balance_cios = true;
+    bps.assume.splitter_capacity = 4;
+    bps.assume.ci_phases = {0};
+    bps.assume.num_phases = 1;
+    bps.scheduling = buffer_insertion_params::better_depth;
+    bps.optimization_effort = buffer_insertion_params::one_pass;
+    buffer_insertion buf_inst( _ntk, bps );
+    auto numbufs = buf_inst.dry_run();
+
+    //return (_ntk.num_gates() * 6 + numbufs * 2);
+    return (_ntk.num_gates() * 6 + numbufs * 2) * buf_inst.depth();
+  };
+
+  explorer_stats st;
+  explorer<Ntk> expl( ps, st, aqfp_cost );
+
+  expl.add_decompressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    aig_network aig = cleanup_dangling<mig_network, aig_network>( _ntk );
+
+    std::string script = fmt::format(
+      "&dch{}; &if -a -K {}; &mfs -e -W 20 -L 20{}",
+      (rand & 0x1) ? " -f" : "",
+      2 + (i % 5),
+      ((rand >> 2) & 0x1) ? "; &fx; &st" : "");
+    aig = call_abc_script( aig, script );
+
+    mig_npn_resynthesis resyn2{ true };
+    exact_library<mig_network> exact_lib( resyn2 );
+    map_params mps;
+    mps.skip_delay_round = true;
+    mps.required_time = std::numeric_limits<double>::max();
+    _ntk = map( aig, exact_lib, mps );
+  } );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    aig_network aig = cleanup_dangling<mig_network, aig_network>( _ntk );
+    std::string script = (rand & 0x1) ? "; &c2rs" : "; &dc2";
+    aig = call_abc_script( aig, script );
+
+    mig_npn_resynthesis resyn2{ true };
+    exact_library<mig_network> exact_lib( resyn2 );
+    map_params mps;
+    mps.skip_delay_round = true;
+    mps.required_time = std::numeric_limits<double>::max();
+    _ntk = map( aig, exact_lib, mps );
+  } );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    mig_npn_resynthesis resyn2{ true };
+    exact_library<mig_network> exact_lib( resyn2 );
+    map_params mps;
+    mps.skip_delay_round = true;
+    mps.required_time = std::numeric_limits<double>::max();
+    mps.area_flow_rounds = 1;
+    mps.enable_logic_sharing = rand & 0x1; /* high-effort remap */
+    _ntk = map( _ntk, exact_lib, mps );
+  } );
+
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    resubstitution_params rps;
+    rps.max_inserts = rand & 0x3;
+    depth_view depth_mig{ _ntk };
+    fanout_view fanout_mig{ depth_mig };
+    mig_resubstitution2( fanout_mig, rps );
+    _ntk = cleanup_dangling( _ntk );
+  } );
+
+  // balancing
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    sop_rebalancing<mig_network> balance_fn;
+    balancing_params bps;
+    bps.cut_enumeration_ps.cut_size = 6u;
+    _ntk = balancing( _ntk, {balance_fn}, bps );
+  } );
+
+  // algebraic depth optimization
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    depth_view depth_mig{ _ntk };
+    mig_algebraic_depth_rewriting( depth_mig );
+    _ntk = cleanup_dangling( _ntk );
+  } );
+
+  auto res = expl.run( ntk );
+  if ( pst )
+    *pst = st;
+  return res;
+}
+#endif
+
+void compress2rs_aig( aig_network& aig )
+{
+  xag_npn_resynthesis<aig_network> resyn;
+  cut_rewriting_params cps;
+  cps.cut_enumeration_ps.cut_size = 4;
+  resubstitution_params rps;
+  //sop_rebalancing<aig_network> balance_fn;
+  //balancing_params bps;
+  //bps.cut_enumeration_ps.cut_size = 6u;
+  aig_balancing_params abps;
+  refactoring_params fps;
+  sop_factoring<aig_network> resyn2;
+
+  /*abps.minimize_levels = true;*/ aig_balance( aig, abps ); // "b -l"
+  rps.max_pis = 6; rps.max_inserts = 1; /*rps.preserve_depth = true;*/ aig_resubstitution( aig, rps ); aig = cleanup_dangling( aig ); // "rs -K 6 -l"
+  /*cps.preserve_depth = true;*/ aig = cut_rewriting( aig, resyn, cps ); // "rw -l"
+  rps.max_pis = 6; rps.max_inserts = 2; aig_resubstitution( aig, rps ); aig = cleanup_dangling( aig ); // "rs -K 6 -N 2 -l"
+  /*fps.preserve_depth = true;*/ refactoring( aig, resyn2, fps ); aig = cleanup_dangling( aig ); // "rf -l"
+  rps.max_pis = 8; rps.max_inserts = 1; aig_resubstitution( aig, rps ); aig = cleanup_dangling( aig ); // "rs -K 8 -l"
+  aig_balance( aig, abps ); // "b -l"
+  rps.max_pis = 8; rps.max_inserts = 2; aig_resubstitution( aig, rps ); aig = cleanup_dangling( aig ); // "rs -K 8 -N 2 -l"
+  aig = cut_rewriting( aig, resyn, cps ); // "rw -l"
+  rps.max_pis = 10; rps.max_inserts = 1; aig_resubstitution( aig, rps ); aig = cleanup_dangling( aig ); // "rs -K 10 -l"
+  cps.allow_zero_gain = true; aig = cut_rewriting( aig, resyn, cps ); // "rwz -l"
+  rps.max_pis = 10; rps.max_inserts = 2; aig_resubstitution( aig, rps ); aig = cleanup_dangling( aig ); // "rs -K 10 -N 2 -l"
+  aig_balance( aig, abps ); // "b -l"
+  rps.max_pis = 12; rps.max_inserts = 1; aig_resubstitution( aig, rps ); aig = cleanup_dangling( aig ); // "rs -K 12 -l"
+  fps.allow_zero_gain = true; refactoring( aig, resyn2, fps ); aig = cleanup_dangling( aig ); // "rfz -l"
+  rps.max_pis = 12; rps.max_inserts = 2; aig_resubstitution( aig, rps ); aig = cleanup_dangling( aig ); // "rs -K 12 -N 2 -l"
+  aig = cut_rewriting( aig, resyn, cps ); // "rwz -l"
+  aig_balance( aig, abps ); // "b -l"
+}
+
+mig_network explore_aqfp( mig_network const& ntk, explorer_params const ps = {} )
+{
+  using Ntk = mig_network;
+
+  cost_fn_t<Ntk> aqfp_cost = []( Ntk const& _ntk ){
+    buffer_insertion_params bps;
+    bps.assume.balance_cios = true;
+    bps.assume.splitter_capacity = 4;
+    bps.assume.ci_phases = {0};
+    bps.scheduling = buffer_insertion_params::better_depth;
+    bps.optimization_effort = buffer_insertion_params::none;
+    buffer_insertion buf_inst( _ntk, bps );
+
+    return _ntk.num_gates() * 6 + buf_inst.dry_run() * 2;
+  };
+
+  explorer_stats st;
+  explorer<Ntk> expl( ps, st, aqfp_cost );
+
+  expl.add_decompressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "decompressing with k-LUT mapping using random value {}, k = {}\n", rand, 2 + (rand % 5) );
+    lut_map_params mps;
+    mps.cut_enumeration_ps.cut_size = 3 + (i & 0x3);
+    mapping_view<Ntk> mapped{ _ntk };
+    lut_map( mapped, mps );
+    const auto klut = *collapse_mapped_network<klut_network>( mapped );
+    
+    if ( (rand >> 2) & 0x1 )
+    {
+      _ntk = convert_klut_to_graph<Ntk>( klut );
+    }
+    else
+    {
+      sop_factoring<Ntk> resyn;
+      _ntk = node_resynthesis<Ntk>( klut, resyn );
+    }
+  } );
+
+  expl.add_decompressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    //fmt::print( "decompressing with break-MAJ using random value {}\n", rand );
+    std::mt19937 g( rand );
+    _ntk.foreach_gate( [&]( auto n ){
+      bool is_maj = true;
+      _ntk.foreach_fanin( n, [&]( auto fi ){
+        if ( _ntk.is_constant( _ntk.get_node( fi ) ) )
+          is_maj = false;
+        return;
+      });
+      if ( !is_maj )
+        return;
+      std::vector<typename Ntk::signal> fanins;
+      _ntk.foreach_fanin( n, [&]( auto fi ){
+        fanins.emplace_back( fi );
+      });
+
+      std::shuffle( fanins.begin(), fanins.end(), g );
+      _ntk.substitute_node( n, _ntk.create_or( _ntk.create_and( fanins[0], fanins[1] ), _ntk.create_and( fanins[2], !_ntk.create_and( !fanins[0], !fanins[1] ) ) ) );
+    });
+  }, 0.3 );
+
+  // high-effort AIG optimization + (50% chance high-effort) mapping
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    aig_network aig = cleanup_dangling<mig_network, aig_network>( _ntk );
+    compress2rs_aig( aig );
+
+    mig_npn_resynthesis resyn3{ true };
+    exact_library<mig_network> exact_lib( resyn3 );
+    map_params mps;
+    mps.skip_delay_round = false;
+    mps.required_time = std::numeric_limits<double>::max();
+    mps.area_flow_rounds = 1;
+    mps.enable_logic_sharing = rand & 0x1; /* high-effort remap */
+    _ntk = map( aig, exact_lib, mps );
+  } );
+
+  // high-effort MIG resub x1
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    resubstitution_params rps;
+    rps.max_inserts = rand & 0x7;
+    rps.max_pis = (rand >> 3) & 0x1 ? 6 : 8;
+    depth_view depth_mig{ _ntk };
+    fanout_view fanout_mig{ depth_mig };
+    mig_resubstitution2( fanout_mig, rps );
+    _ntk = cleanup_dangling( _ntk );
+  }, 0.5 );
+
+  // balancing
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    sop_rebalancing<mig_network> balance_fn;
+    balancing_params bps;
+    bps.cut_enumeration_ps.cut_size = 6u;
+    _ntk = balancing( _ntk, {balance_fn}, bps );
+  }, 0.5 );
+
+  // algebraic depth optimization
+  expl.add_compressing_script( []( Ntk& _ntk, uint32_t i, uint32_t rand ){
+    depth_view depth_mig{ _ntk };
+    mig_algebraic_depth_rewriting( depth_mig );
+    _ntk = cleanup_dangling( _ntk );
+  }, 0.5 );
+
+  return expl.run( ntk );
+}
+
+} // namespace mockturtle
diff --git a/include/mockturtle/algorithms/extract_adders.hpp b/include/mockturtle/algorithms/extract_adders.hpp
new file mode 100644
index 0000000..072aaf3
--- /dev/null
+++ b/include/mockturtle/algorithms/extract_adders.hpp
@@ -0,0 +1,971 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file extract_adders.hpp
+  \brief Maps adders in the network
+
+  \author Alessandro Tempia Calvino
+*/
+
+#include <algorithm>
+#include <array>
+#include <vector>
+
+#include <fmt/format.h>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/static_truth_table.hpp>
+#include <parallel_hashmap/phmap.h>
+
+#include "../networks/block.hpp"
+#include "../networks/storage.hpp"
+#include "../utils/node_map.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../views/choice_view.hpp"
+#include "cut_enumeration.hpp"
+
+namespace mockturtle
+{
+
+struct extract_adders_params
+{
+  extract_adders_params()
+  {
+    cut_enumeration_ps.cut_limit = 49;
+    cut_enumeration_ps.minimize_truth_table = false;
+  }
+
+  /*! \brief Parameters for cut enumeration
+   *
+   * The default cut limit is 49. By default,
+   * truth table minimization is performed.
+   */
+  cut_enumeration_params cut_enumeration_ps{};
+
+  /*! \brief Map inverted (NAND2-XNOR2, MIN3-XNOR3) */
+  bool map_inverted{ false };
+
+  /*! \brief Filter HAs/FAs using MFFC inclusion */
+  bool use_mffc_filter{ true };
+
+  /*! \brief Be verbose */
+  bool verbose{ false };
+};
+
+struct extract_adders_stats
+{
+  /*! \brief Computed cuts. */
+  uint32_t cuts_total{ 0 };
+
+  /*! \brief Gates count. */
+  uint32_t and2{ 0 };
+  uint32_t maj3{ 0 };
+  uint32_t xor2{ 0 };
+  uint32_t xor3{ 0 };
+
+  /*! \brief Hashed classes. */
+  uint32_t num_classes{ 0 };
+
+  /*! \brief Hash size. */
+  uint32_t mapped_ha{ 0 };
+  uint32_t mapped_fa{ 0 };
+
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  void report() const
+  {
+    std::cout << fmt::format( "[i] Cuts = {}\t And2 = {}\t Xor2 = {}\t Maj3 = {}\t Xor3 = {}\n",
+                              cuts_total, and2, xor2, maj3, xor3 );
+    std::cout << fmt::format( "[i] Classes = {} \tMapped HA = {}\t Mapped FA:{}\n", num_classes, mapped_ha, mapped_fa );
+    std::cout << fmt::format( "[i] Total runtime = {:>5.2f} secs\n", to_seconds( time_total ) );
+  }
+};
+
+namespace detail
+{
+
+struct triple_hash
+{
+  uint64_t operator()( const std::array<uint32_t, 3>& p ) const
+  {
+    uint64_t seed = hash_block( p[0] );
+
+    hash_combine( seed, hash_block( p[1] ) );
+    hash_combine( seed, hash_block( p[2] ) );
+
+    return seed;
+  }
+};
+
+struct cut_enumeration_fa_cut
+{
+  /* stats */
+  bool is_xor{ false };
+};
+
+template<class Ntk>
+class extract_adders_impl
+{
+public:
+  using network_cuts_t = fast_network_cuts<Ntk, 3, true, cut_enumeration_fa_cut>;
+  using cut_t = typename network_cuts_t::cut_t;
+  using leaves_hash_t = phmap::flat_hash_map<std::array<uint32_t, 3>, std::vector<uint64_t>, triple_hash>;
+  using match_pair_t = std::pair<uint64_t, uint64_t>;
+  using matches_t = std::vector<match_pair_t>;
+  using block_map = node_map<signal<block_network>, Ntk>;
+
+public:
+  explicit extract_adders_impl( Ntk& ntk, extract_adders_params const& ps, extract_adders_stats& st )
+      : ntk( ntk ),
+        ps( ps ),
+        st( st ),
+        cuts( fast_cut_enumeration<Ntk, 3, true, cut_enumeration_fa_cut>( ntk, ps.cut_enumeration_ps ) ),
+        cuts_classes(),
+        half_adders(),
+        full_adders(),
+        node_match( ntk.size(), UINT32_MAX )
+  {
+    cuts_classes.reserve( 2000 );
+    tmp_visited.reserve( 20 );
+  }
+
+  block_network run()
+  {
+    stopwatch t( st.time_total );
+
+    auto [res, old2new] = initialize_map_network();
+    create_classes();
+    match_adders();
+    map();
+    topo_sort();
+    finalize( res, old2new );
+
+    return res;
+  }
+
+private:
+  void create_classes()
+  {
+    uint32_t counter = 0;
+    std::array<uint32_t, 3> leaves = { 0, 0, 0 };
+
+    st.cuts_total = cuts.total_cuts();
+
+    ntk.foreach_gate( [&]( auto const& n ) {
+      uint32_t cut_index = 0;
+      for ( auto& cut : cuts.cuts( ntk.node_to_index( n ) ) )
+      {
+        kitty::static_truth_table<3> tt = cuts.truth_table( *cut );
+
+        bool to_add = false;
+        if ( cut->size() == 2 )
+        {
+          /* check for and2 */
+          for ( uint32_t func : and2func )
+          {
+            if ( tt._bits == func )
+            {
+              ++st.and2;
+              to_add = true;
+              break;
+            }
+          }
+
+          /* check for xor2 */
+          for ( uint32_t func : xor2func )
+          {
+            if ( tt._bits == func )
+            {
+              ++st.xor2;
+              ( *cut )->data.is_xor = true;
+              to_add = true;
+              break;
+            }
+          }
+        }
+        else if ( cut->size() == 3 )
+        {
+          /* check for maj3 */
+          for ( uint32_t func : maj3func )
+          {
+            if ( tt._bits == func )
+            {
+              ++st.maj3;
+              to_add = true;
+              break;
+            }
+          }
+
+          /* check xor3 */
+          for ( uint32_t func : xor3func )
+          {
+            if ( tt._bits == func )
+            {
+              ++st.xor3;
+              ( *cut )->data.is_xor = true;
+              to_add = true;
+              break;
+            }
+          }
+        }
+
+        if ( !to_add )
+        {
+          ++cut_index;
+          continue;
+        }
+
+        uint64_t data = ( static_cast<uint64_t>( ntk.node_to_index( n ) ) << 16 ) | cut_index;
+        leaves[2] = 0;
+        uint32_t i = 0;
+        for ( auto l : *cut )
+          leaves[i++] = l;
+
+        /* add to hash table */
+        auto& v = cuts_classes[leaves];
+        v.push_back( data );
+
+        ++cut_index;
+      }
+    } );
+
+    st.num_classes = cuts_classes.size();
+  }
+
+  void match_adder2( std::pair<std::array<uint32_t, 3>, std::vector<uint64_t>> const& it )
+  {
+    for ( uint32_t i = 0; i < it.second.size() - 1; ++i )
+    {
+      uint64_t data_i = it.second[i];
+      uint32_t index_i = data_i >> 16;
+      uint32_t cut_index_i = data_i & UINT16_MAX;
+      auto const& cut_i = cuts.cuts( index_i )[cut_index_i];
+
+      /* TODO: find unique matches */
+      for ( uint32_t j = i + 1; j < it.second.size(); ++j )
+      {
+        uint64_t data_j = it.second[j];
+        uint32_t index_j = data_j >> 16;
+        uint32_t cut_index_j = data_j & UINT16_MAX;
+        auto const& cut_j = cuts.cuts( index_j )[cut_index_j];
+
+        /* not compatible */
+        if ( cut_i->data.is_xor == cut_j->data.is_xor )
+          continue;
+
+        /* check compatibility */
+        if ( !check_adder( index_i, index_j, cut_i ) )
+          continue;
+
+        assert( cut_i.size() == 2 );
+        assert( cut_j.size() == 2 );
+
+        half_adders.push_back( { data_i, data_j } );
+      }
+    }
+  }
+
+  void match_adders()
+  {
+    half_adders.reserve( cuts_classes.size() );
+    full_adders.reserve( cuts_classes.size() );
+    ntk.clear_values();
+
+    for ( auto& it : cuts_classes )
+    {
+      /* not matched */
+      if ( it.second.size() < 2 )
+        continue;
+
+      /* half adder */
+      if ( it.first[2] == 0 )
+      {
+        match_adder2( it );
+        continue;
+      }
+
+      for ( uint32_t i = 0; i < it.second.size() - 1; ++i )
+      {
+        uint64_t data_i = it.second[i];
+        uint32_t index_i = data_i >> 16;
+        uint32_t cut_index_i = data_i & UINT16_MAX;
+        auto const& cut_i = cuts.cuts( index_i )[cut_index_i];
+
+        /* TODO: find unique matches */
+        for ( uint32_t j = i + 1; j < it.second.size(); ++j )
+        {
+          uint64_t data_j = it.second[j];
+          uint32_t index_j = data_j >> 16;
+          uint32_t cut_index_j = data_j & UINT16_MAX;
+          auto const& cut_j = cuts.cuts( index_j )[cut_index_j];
+
+          /* not compatible */
+          if ( cut_i->data.is_xor == cut_j->data.is_xor )
+            continue;
+
+          /* check compatibility */
+          if ( !check_adder( index_i, index_j, cut_i ) )
+            continue;
+
+          assert( cut_i.size() == 3 );
+          assert( cut_j.size() == 3 );
+
+          full_adders.push_back( { data_i, data_j } );
+        }
+      }
+    }
+  }
+
+  void map()
+  {
+    selected.reserve( full_adders.size() + half_adders.size() );
+
+    ntk.incr_trav_id();
+
+    for ( uint32_t i = 0; i < full_adders.size(); ++i )
+    {
+      auto& pair = full_adders[i];
+      uint32_t index1 = pair.first >> 16;
+      uint32_t index2 = pair.second >> 16;
+      uint32_t cut_index1 = pair.first & UINT16_MAX;
+      cut_t const& cut = cuts.cuts( index1 )[cut_index1];
+
+      /* remove overlapping multi-output gates */
+      if ( !gate_mark( index1, index2, cut ) )
+        continue;
+
+      selected.push_back( 2 * i );
+      node_match[std::max( index1, index2 )] = 2 * i;
+      node_match[std::min( index1, index2 )] = UINT32_MAX - 1;
+
+      ++st.mapped_fa;
+    }
+
+    for ( uint32_t i = 0; i < half_adders.size(); ++i )
+    {
+      auto& pair = half_adders[i];
+      uint32_t index1 = pair.first >> 16;
+      uint32_t index2 = pair.second >> 16;
+      uint32_t cut_index1 = pair.first & UINT16_MAX;
+      cut_t const& cut = cuts.cuts( index1 )[cut_index1];
+
+      if ( !gate_mark( index1, index2, cut ) )
+        continue;
+
+      selected.push_back( 2 * i + 1 );
+      node_match[std::max( index1, index2 )] = 2 * i + 1;
+      node_match[std::min( index1, index2 )] = UINT32_MAX - 1;
+
+      ++st.mapped_ha;
+    }
+  }
+
+  void topo_sort()
+  {
+    topo_order.reserve( ntk.size() );
+
+    /* add map choices */
+    choice_view<Ntk> choice_ntk{ ntk };
+    add_choices( choice_ntk );
+
+    ntk.incr_trav_id();
+    ntk.incr_trav_id();
+
+    /* add constants and CIs */
+    const auto c0 = ntk.get_node( ntk.get_constant( false ) );
+    ntk.set_visited( c0, ntk.trav_id() );
+
+    if ( const auto c1 = ntk.get_node( ntk.get_constant( true ) ); ntk.visited( c1 ) != ntk.trav_id() )
+    {
+      ntk.set_visited( c1, ntk.trav_id() );
+    }
+
+    ntk.foreach_ci( [&]( auto const& n ) {
+      if ( ntk.visited( n ) != ntk.trav_id() )
+      {
+        ntk.set_visited( n, ntk.trav_id() );
+      }
+    } );
+
+    /* sort topologically */
+    ntk.foreach_co( [&]( auto const& f ) {
+      if ( ntk.visited( ntk.get_node( f ) ) == ntk.trav_id() )
+        return;
+      topo_sort_rec( choice_ntk, ntk.get_node( f ) );
+    } );
+  }
+
+  void add_choices( choice_view<Ntk>& choice_ntk )
+  {
+    for ( uint32_t index : selected )
+    {
+      auto& pair = ( index & 1 ) ? half_adders[index >> 1] : full_adders[index >> 1];
+      uint32_t index1 = pair.first >> 16;
+      uint32_t index2 = pair.second >> 16;
+
+      if ( index1 > index2 )
+        std::swap( index1, index2 );
+
+      choice_ntk.add_choice( ntk.index_to_node( index1 ), ntk.index_to_node( index2 ) );
+
+      assert( choice_ntk.count_choices( ntk.index_to_node( index1 ) ) == 2 );
+    }
+  }
+
+  inline bool check_adder( uint32_t index1, uint32_t index2, cut_t const& cut )
+  {
+    bool valid = true;
+
+    /* check containment of cut1 in cut2 and vice versa */
+    if ( index1 > index2 )
+    {
+      std::swap( index1, index2 );
+    }
+
+    ntk.foreach_fanin( ntk.index_to_node( index2 ), [&]( auto const& f ) {
+      auto g = ntk.get_node( f );
+      if ( ntk.node_to_index( g ) == index1 && ntk.fanout_size( g ) == 1 )
+      {
+        valid = false;
+      }
+      return valid;
+    } );
+
+    if ( !valid )
+      return false;
+
+    /* check containment when node is reachable from middle nodes with multiple fanouts */
+    return check_adder_tfi_valid( ntk.index_to_node( index2 ), ntk.index_to_node( index1 ), cut );
+  }
+
+  inline bool gate_mark( uint32_t index1, uint32_t index2, cut_t const& cut )
+  {
+    bool contained = false;
+
+    /* mark leaves */
+    for ( auto leaf : cut )
+    {
+      ntk.incr_value( ntk.index_to_node( leaf ) );
+    }
+
+    contained = mark_visited_rec<false>( ntk.index_to_node( index1 ) );
+    contained |= mark_visited_rec<false>( ntk.index_to_node( index2 ) );
+
+    if ( contained )
+    {
+      /* unmark leaves */
+      for ( auto leaf : cut )
+      {
+        ntk.decr_value( ntk.index_to_node( leaf ) );
+      }
+      return false;
+    }
+
+    /* mark*/
+    mark_visited_rec<true>( ntk.index_to_node( index1 ) );
+    mark_visited_rec<true>( ntk.index_to_node( index2 ) );
+
+    /* unmark leaves */
+    for ( auto leaf : cut )
+    {
+      ntk.decr_value( ntk.index_to_node( leaf ) );
+    }
+
+    return true;
+  }
+
+  template<bool MARK>
+  bool mark_visited_rec( node<Ntk> const& n )
+  {
+    /* leaf */
+    if ( ntk.value( n ) )
+      return false;
+
+    /* already visited */
+    if ( ntk.visited( n ) == ntk.trav_id() )
+      return true;
+
+    if constexpr ( MARK )
+    {
+      ntk.set_visited( n, ntk.trav_id() );
+    }
+
+    bool contained = false;
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      contained |= mark_visited_rec<MARK>( ntk.get_node( f ) );
+
+      if constexpr ( !MARK )
+      {
+        if ( contained )
+          return false;
+      }
+
+      return true;
+    } );
+
+    return contained;
+  }
+
+  inline bool check_adder_tfi_valid( node<Ntk> const& root, node<Ntk> const& n, cut_t const& cut )
+  {
+    /* reference cut leaves */
+    for ( auto leaf : cut )
+    {
+      ntk.incr_value( ntk.index_to_node( leaf ) );
+    }
+
+    bool valid = true;
+    if ( ps.use_mffc_filter )
+    {
+      tmp_visited.clear();
+      dereference_node_rec( root );
+
+      if ( ntk.fanout_size( n ) == 0 )
+        valid = false;
+
+      for ( auto g : tmp_visited )
+        ntk.incr_fanout_size( g );
+    }
+    else
+    {
+      ntk.incr_trav_id();
+      check_adder_tfi_valid_rec( root, root, n, valid );
+    }
+
+    /* dereference leaves */
+    for ( auto leaf : cut )
+    {
+      ntk.decr_value( ntk.index_to_node( leaf ) );
+    }
+
+    return valid;
+  }
+
+  bool check_adder_tfi_valid_rec( node<Ntk> const& n, node<Ntk> const& root, node<Ntk> const& target, bool& valid )
+  {
+    /* leaf */
+    if ( ntk.value( n ) )
+      return false;
+
+    /* already visited */
+    if ( ntk.visited( n ) == ntk.trav_id() )
+      return false;
+
+    ntk.set_visited( n, ntk.trav_id() );
+
+    if ( n == target )
+      return true;
+
+    bool found = false;
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      found |= check_adder_tfi_valid_rec( ntk.get_node( f ), root, target, valid );
+      return valid;
+    } );
+
+    if ( found && n != root && ntk.fanout_size( n ) > 1 )
+      valid = false;
+
+    return found;
+  }
+
+  void dereference_node_rec( node<Ntk> const& n )
+  {
+    /* leaf */
+    if ( ntk.value( n ) )
+      return;
+
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      node<Ntk> g = ntk.get_node( f );
+      if ( ntk.decr_fanout_size( g ) == 0 )
+      {
+        dereference_node_rec( g );
+      }
+      tmp_visited.push_back( g );
+    } );
+  }
+
+  inline bool is_in_tfi( node<Ntk> const& root, node<Ntk> const& n, cut_t const& cut )
+  {
+    /* reference cut leaves */
+    for ( auto leaf : cut )
+    {
+      ntk.incr_value( ntk.index_to_node( leaf ) );
+    }
+
+    ntk.incr_trav_id();
+    mark_visited_rec<true>( root );
+    bool contained = ntk.visited( n ) == ntk.trav_id();
+
+    /* dereference leaves */
+    for ( auto leaf : cut )
+    {
+      ntk.decr_value( ntk.index_to_node( leaf ) );
+    }
+
+    return contained;
+  }
+
+  void topo_sort_rec( choice_view<Ntk>& choice_ntk, node<Ntk> const& n )
+  {
+    /* is permanently marked? */
+    if ( ntk.visited( n ) == ntk.trav_id() )
+      return;
+
+    /* get the representative (smallest index) */
+    node<Ntk> repr = choice_ntk.get_choice_representative( n );
+
+    /* multioutput gate */
+    if ( choice_ntk.count_choices( repr ) > 1 )
+    {
+      /* get the cut */
+      uint32_t max_index = 0;
+      choice_ntk.foreach_choice( repr, [&]( auto const& g ) {
+        /* ensure that the node is not visited or temporarily marked */
+        assert( ntk.visited( g ) != ntk.trav_id() );
+        assert( ntk.visited( g ) != ntk.trav_id() - 1 );
+
+        /* mark node temporarily */
+        ntk.set_visited( g, ntk.trav_id() - 1 );
+
+        max_index = std::max( max_index, ntk.node_to_index( g ) );
+        return true;
+      } );
+
+      uint32_t cindex = node_match[max_index];
+      auto& pair = ( cindex & 1 ) ? half_adders[cindex >> 1] : full_adders[cindex >> 1];
+      cut_t const& cut = cuts.cuts( pair.first >> 16 )[pair.first & UINT16_MAX];
+
+      for ( auto l : cut )
+      {
+        topo_sort_rec( choice_ntk, ntk.index_to_node( l ) );
+      }
+
+      choice_ntk.foreach_choice( repr, [&]( auto const& g ) {
+        /* ensure that the node is not visited */
+        assert( ntk.visited( g ) != ntk.trav_id() );
+
+        /* mark node n permanently */
+        ntk.set_visited( g, ntk.trav_id() );
+
+        /* visit node */
+        topo_order.push_back( g );
+
+        return true;
+      } );
+    }
+    else
+    {
+      /* ensure that the node is not visited or temporarily marked */
+      assert( ntk.visited( n ) != ntk.trav_id() );
+      assert( ntk.visited( n ) != ntk.trav_id() - 1 );
+
+      /* mark node temporarily */
+      ntk.set_visited( n, ntk.trav_id() - 1 );
+
+      /* mark cut leaves */
+      ntk.foreach_fanin( n, [&]( auto const& f ) {
+        topo_sort_rec( choice_ntk, ntk.get_node( f ) );
+      } );
+
+      /* ensure that the node is not visited */
+      assert( ntk.visited( n ) != ntk.trav_id() );
+
+      /* mark node n permanently */
+      ntk.set_visited( n, ntk.trav_id() );
+
+      /* visit node */
+      topo_order.push_back( n );
+    }
+  }
+
+  std::pair<block_network, block_map> initialize_map_network()
+  {
+    block_network dest;
+    block_map old2new( ntk );
+
+    old2new[ntk.get_node( ntk.get_constant( false ) )] = dest.get_constant( false );
+    if ( ntk.get_node( ntk.get_constant( true ) ) != ntk.get_node( ntk.get_constant( false ) ) )
+      old2new[ntk.get_node( ntk.get_constant( true ) )] = dest.get_constant( true );
+
+    ntk.foreach_ci( [&]( auto const& n ) {
+      old2new[n] = dest.create_pi();
+    } );
+    return { dest, old2new };
+  }
+
+  void finalize( block_network& res, block_map& old2new )
+  {
+    for ( auto const& n : topo_order )
+    {
+      if ( ntk.is_pi( n ) || ntk.is_constant( n ) )
+        continue;
+
+      /* is a multioutput gate root? */
+      if ( node_match[ntk.node_to_index( n )] == UINT32_MAX )
+      {
+        finalize_simple_gate( res, old2new, n );
+      }
+      else if ( node_match[ntk.node_to_index( n )] < UINT32_MAX - 1 )
+      {
+        finalize_multi_gate( res, old2new, n );
+      }
+    }
+
+    /* create POs */
+    ntk.foreach_co( [&]( auto const& f ) {
+      res.create_po( ntk.is_complemented( f ) ? !old2new[f] : old2new[f] );
+    } );
+  }
+
+  inline void finalize_simple_gate( block_network& res, block_map& old2new, node<Ntk> const& n )
+  {
+    kitty::dynamic_truth_table tt = ntk.node_function( n );
+
+    std::vector<signal<block_network>> children;
+    ntk.foreach_fanin( n, [&]( auto const& f, auto i ) {
+      auto s = old2new[f] ^ ntk.is_complemented( f );
+      children.push_back( s );
+    } );
+
+    old2new[n] = res.create_node( children, tt );
+  }
+
+  inline void finalize_multi_gate( block_network& res, block_map& old2new, node<Ntk> const& n )
+  {
+    uint32_t index = node_match[ntk.node_to_index( n )];
+    assert( index < UINT32_MAX - 1 );
+
+    /* extract the match */
+    if ( index & 1 )
+      finalize_multi_gate_ha( res, old2new, n, index >> 1 );
+    else
+      finalize_multi_gate_fa( res, old2new, n, index >> 1 );
+  }
+
+  inline void finalize_multi_gate_ha( block_network& res, block_map& old2new, node<Ntk> const& n, uint32_t index )
+  {
+    auto& pair = half_adders[index];
+    uint32_t index1 = pair.first >> 16;
+    uint32_t index2 = pair.second >> 16;
+    uint32_t cut_index1 = pair.first & UINT16_MAX;
+    uint32_t cut_index2 = pair.second & UINT16_MAX;
+    cut_t const& cut1 = cuts.cuts( index1 )[cut_index1];
+    cut_t const& cut2 = cuts.cuts( index2 )[cut_index2];
+
+    kitty::static_truth_table<3> tt1 = cuts.truth_table( cut1 );
+    kitty::static_truth_table<3> tt2 = cuts.truth_table( cut2 );
+    bool xor_is_1 = false;
+
+    /* find the XOR2 */
+    xor_is_1 = cut1->data.is_xor;
+
+    /* find the negation vector of AND2 and XOR2*/
+    kitty::static_truth_table<3> tt = xor_is_1 ? tt2 : tt1;
+    uint32_t neg_and = 0;
+    for ( uint32_t func : and2func )
+    {
+      if ( tt._bits == func )
+        break;
+      ++neg_and;
+    }
+
+    tt = xor_is_1 ? tt1 : tt2;
+    uint32_t neg_xor = 0;
+    for ( uint32_t func : xor2func )
+    {
+      if ( tt._bits == func )
+        break;
+      ++neg_xor;
+    }
+    neg_xor ^= neg_and;
+    neg_xor = ( neg_xor & 1 ) ^ ( ( neg_xor >> 1 ) & 1 ) ^ ( ( neg_xor >> 2 ) & 1 );
+
+    /* normalize and create multioutput gate */
+    std::array<signal<block_network>, 2> children;
+    uint32_t ctr = 0;
+    for ( auto l : cut1 )
+    {
+      signal<block_network> f = old2new[ntk.index_to_node( l )];
+      bool phase = ( ( neg_and >> ctr ) & 1 ) ? true : false;
+      children[ctr] = f ^ phase;
+      ++ctr;
+    }
+
+    if ( ps.map_inverted )
+    {
+      signal<block_network> ha = res.create_hai( children[0], children[1] );
+      old2new[ntk.index_to_node( xor_is_1 ? index2 : index1 )] = ha ^ ( ( neg_and >> 2 ) ? false : true );
+      old2new[ntk.index_to_node( xor_is_1 ? index1 : index2 )] = res.next_output_pin( ha ) ^ ( neg_xor ? false : true );
+      return;
+    }
+
+    signal<block_network> ha = res.create_ha( children[0], children[1] );
+    old2new[ntk.index_to_node( xor_is_1 ? index2 : index1 )] = ha ^ ( ( neg_and >> 2 ) ? true : false );
+    old2new[ntk.index_to_node( xor_is_1 ? index1 : index2 )] = res.next_output_pin( ha ) ^ ( neg_xor ? true : false );
+  }
+
+  inline void finalize_multi_gate_fa( block_network& res, block_map& old2new, node<Ntk> const& n, uint32_t index )
+  {
+    auto& pair = full_adders[index];
+    uint32_t index1 = pair.first >> 16;
+    uint32_t index2 = pair.second >> 16;
+    uint32_t cut_index1 = pair.first & UINT16_MAX;
+    uint32_t cut_index2 = pair.second & UINT16_MAX;
+    cut_t const& cut1 = cuts.cuts( index1 )[cut_index1];
+    cut_t const& cut2 = cuts.cuts( index2 )[cut_index2];
+
+    kitty::static_truth_table<3> tt1 = cuts.truth_table( cut1 );
+    kitty::static_truth_table<3> tt2 = cuts.truth_table( cut2 );
+
+    bool xor_is_1 = false;
+
+    /* find the XOR3 */
+    xor_is_1 = cut1->data.is_xor;
+
+    /* find the phase and permutation of MAJ3 and XOR3*/
+    kitty::static_truth_table<3> tt = xor_is_1 ? tt2 : tt1;
+    uint32_t neg_maj = 0;
+    for ( uint32_t func : maj3func )
+    {
+      if ( tt._bits == func )
+        break;
+      ++neg_maj;
+    }
+
+    if ( ps.map_inverted )
+    {
+      neg_maj = ( ~neg_maj ) & 0x7;
+    }
+
+    tt = xor_is_1 ? tt1 : tt2;
+    uint32_t neg_xor = 0;
+    for ( uint32_t func : xor3func )
+    {
+      if ( tt._bits == func )
+        break;
+      ++neg_xor;
+    }
+    neg_xor ^= neg_maj;
+    neg_xor = ( neg_xor & 1 ) ^ ( ( neg_xor >> 1 ) & 1 ) ^ ( ( neg_xor >> 2 ) & 1 );
+
+    /* normalize and create the multioutput gate */
+    std::array<signal<block_network>, 3> children;
+    uint32_t ctr = 0;
+    for ( auto l : cut1 )
+    {
+      signal<block_network> f = old2new[ntk.index_to_node( l )];
+      bool phase = ( ( neg_maj >> ctr ) & 1 ) ? true : false;
+      children[ctr] = f ^ phase;
+      ++ctr;
+    }
+
+    if ( ps.map_inverted )
+    {
+      signal<block_network> fa = res.create_fai( children[0], children[1], children[2] );
+      old2new[ntk.index_to_node( xor_is_1 ? index2 : index1 )] = fa;
+      old2new[ntk.index_to_node( xor_is_1 ? index1 : index2 )] = res.next_output_pin( fa ) ^ ( neg_xor ? false : true );
+      return;
+    }
+
+    signal<block_network> fa = res.create_fa( children[0], children[1], children[2] );
+    old2new[ntk.index_to_node( xor_is_1 ? index2 : index1 )] = fa;
+    old2new[ntk.index_to_node( xor_is_1 ? index1 : index2 )] = res.next_output_pin( fa ) ^ ( neg_xor ? true : false );
+  }
+
+private:
+  Ntk& ntk;
+  extract_adders_params const& ps;
+  extract_adders_stats& st;
+
+  network_cuts_t cuts;
+  leaves_hash_t cuts_classes;
+  matches_t half_adders;
+  matches_t full_adders;
+  std::vector<uint32_t> selected;
+  std::vector<uint32_t> node_match;
+
+  std::vector<node<Ntk>> topo_order;
+  std::vector<node<Ntk>> tmp_visited;
+
+  const std::array<uint64_t, 8> and2func = { 0x88, 0x44, 0x22, 0x11, 0x77, 0xbb, 0xdd, 0xee };
+  const std::array<uint64_t, 8> maj3func = { 0xe8, 0xd4, 0xb2, 0x71, 0x8e, 0x4d, 0x2b, 0x17 };
+  const std::array<uint64_t, 2> xor2func = { 0x66, 0x99 };
+  const std::array<uint64_t, 2> xor3func = { 0x96, 0x69 };
+};
+
+} /* namespace detail */
+
+/*! \brief Adders extraction.
+ *
+ * This function extracts half and full adders from a network.
+ * It returns a `block_network` with extracted half and full adder
+ * blocks.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `is_pi`
+ * - `is_constant`
+ * - `node_to_index`
+ * - `index_to_node`
+ * - `get_node`
+ * - `foreach_co`
+ * - `foreach_node`
+ * - `foreach_gate`
+ *
+ * \param ntk Network
+ * \param ps Parameters
+ * \param pst Stats
+ *
+ */
+template<class Ntk>
+block_network extract_adders( Ntk& ntk, extract_adders_params const& ps = {}, extract_adders_stats* pst = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_co_v<Ntk>, "Ntk does not implement the foreach_co method" );
+
+  extract_adders_stats st;
+
+  detail::extract_adders_impl p( ntk, ps, st );
+  block_network res = p.run();
+
+  if ( ps.verbose )
+    st.report();
+
+  if ( pst )
+    *pst = st;
+
+  return res;
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/extract_linear.hpp b/include/mockturtle/algorithms/extract_linear.hpp
new file mode 100644
index 0000000..72b2611
--- /dev/null
+++ b/include/mockturtle/algorithms/extract_linear.hpp
@@ -0,0 +1,208 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file extract_linear.hpp
+  \brief Extract linear subcircuit in XAGs
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <utility>
+#include <vector>
+
+#include "../networks/xag.hpp"
+#include "../utils/node_map.hpp"
+#include "../views/topo_view.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Extract linear circuit from XAG
+ *
+ * Creates a new XAG that only contains the XOR gates of the original XAG.  For
+ * each AND gate, the new XAG will contain one additional PI (for the AND
+ * output) and two additional POs (for the AND inputs) in the same order as the
+ * AND gates are traversed in topological order.
+ *
+ * Besides the new XAG, this function returns a vector of the size of all
+ * original AND gates with pointers to the signals referring to the AND's fanin
+ * and fanout (in that order).
+ */
+inline std::pair<xag_network, std::vector<std::array<xag_network::signal, 3>>>
+extract_linear_circuit( xag_network const& xag )
+{
+  xag_network dest;
+  std::vector<std::array<xag_network::signal, 3>> and_tuples;
+  node_map<xag_network::signal, xag_network> old_to_new( xag );
+
+  old_to_new[xag.get_constant( false )] = dest.get_constant( false );
+  xag.foreach_pi( [&]( auto const& n ) {
+    old_to_new[n] = dest.create_pi();
+  } );
+
+  topo_view topo{ xag };
+  topo.foreach_node( [&]( auto const& n ) {
+    if ( xag.is_constant( n ) || xag.is_pi( n ) )
+      return;
+
+    if ( xag.is_and( n ) )
+    {
+      std::array<xag_network::signal, 3> signal_tuple;
+      xag.foreach_fanin( n, [&]( auto const& f, auto i ) {
+        signal_tuple[i] = old_to_new[f] ^ xag.is_complemented( f );
+      } );
+      const auto and_pi = dest.create_pi();
+      old_to_new[n] = and_pi;
+      signal_tuple[2] = and_pi;
+      and_tuples.push_back( signal_tuple );
+    }
+    else /* if ( xag.is_xor( n ) ) */
+    {
+      std::array<xag_network::signal, 2> children{};
+      xag.foreach_fanin( n, [&]( auto const& f, auto i ) {
+        children[i] = old_to_new[f] ^ xag.is_complemented( f );
+      } );
+      old_to_new[n] = dest.create_xor( children[0], children[1] );
+    }
+  } );
+
+  xag.foreach_po( [&]( auto const& f ) {
+    dest.create_po( old_to_new[f] ^ xag.is_complemented( f ) );
+  } );
+  for ( auto const& [a, b, _] : and_tuples )
+  {
+    (void)_;
+    dest.create_po( a );
+    dest.create_po( b );
+  }
+
+  return { dest, and_tuples };
+}
+
+namespace detail
+{
+
+struct merge_linear_circuit_impl
+{
+public:
+  merge_linear_circuit_impl( xag_network const& xag, uint32_t num_and_gates )
+      : xag( xag ),
+        num_and_gates( num_and_gates ),
+        old_to_new( xag ),
+        and_pi( xag )
+  {
+  }
+
+  xag_network run()
+  {
+    old_to_new[xag.get_constant( false )] = dest.get_constant( false );
+
+    orig_pis = xag.num_pis() - num_and_gates;
+    orig_pos = xag.num_pos() - 2 * num_and_gates;
+
+    xag.foreach_pi( [&]( auto const& n, auto i ) {
+      if ( i == orig_pis )
+        return false;
+
+      old_to_new[n] = dest.create_pi();
+      return true;
+    } );
+
+    for ( auto i = 0u; i < num_and_gates; ++i )
+    {
+      create_and( i );
+    }
+
+    xag.foreach_po( [&]( auto const& f, auto i ) {
+      if ( i == orig_pos )
+        return false;
+
+      dest.create_po( run_rec( xag.get_node( f ) ) ^ xag.is_complemented( f ) );
+      return true;
+    } );
+
+    return dest;
+  }
+
+private:
+  xag_network::signal create_and( uint32_t index )
+  {
+    if ( old_to_new.has( xag.pi_at( orig_pis + index ) ) )
+    {
+      return old_to_new[xag.pi_at( orig_pis + index )];
+    }
+
+    const auto f1 = xag.po_at( orig_pos + 2u * index );
+    const auto f2 = xag.po_at( orig_pos + 2u * index + 1u );
+    const auto c1 = run_rec( xag.get_node( f1 ) ) ^ xag.is_complemented( f1 );
+    const auto c2 = run_rec( xag.get_node( f2 ) ) ^ xag.is_complemented( f2 );
+    return old_to_new[xag.pi_at( orig_pis + index )] = dest.create_and( c1, c2 );
+  }
+
+  xag_network::signal run_rec( xag_network::node const& n )
+  {
+    if ( old_to_new.has( n ) )
+    {
+      return old_to_new[n];
+    }
+
+    assert( xag.is_xor( n ) );
+    std::array<xag_network::signal, 2> children{};
+    xag.foreach_fanin( n, [&]( auto const& cf, auto i ) {
+      children[i] = run_rec( xag.get_node( cf ) ) ^ xag.is_complemented( cf );
+    } );
+    return old_to_new[n] = dest.create_xor( children[0], children[1] );
+  }
+
+private:
+  xag_network dest;
+  xag_network const& xag;
+  uint32_t num_and_gates;
+  uint32_t orig_pis, orig_pos;
+  unordered_node_map<xag_network::signal, xag_network> old_to_new;
+  unordered_node_map<uint32_t, xag_network> and_pi;
+};
+
+} // namespace detail
+
+/*! \brief Re-insert AND gates in linear circuit
+ *
+ * Given an extracted linear circuit from `extract_linear_circuit` and the
+ * number of original AND gates, this function re-inserts the AND gates,
+ * assuming that they are represented as PI and PO pairs at the end of the
+ * original PIs and POs.
+ */
+inline xag_network merge_linear_circuit( xag_network const& xag, uint32_t num_and_gates )
+{
+  return detail::merge_linear_circuit_impl( xag, num_and_gates ).run();
+}
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/functional_reduction.hpp b/include/mockturtle/algorithms/functional_reduction.hpp
new file mode 100644
index 0000000..5649d78
--- /dev/null
+++ b/include/mockturtle/algorithms/functional_reduction.hpp
@@ -0,0 +1,488 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file functional_reduction.hpp
+  \brief Functional reduction for any network type
+
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../utils/progress_bar.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../views/fanout_view.hpp"
+
+#include <bill/sat/interface/abc_bsat2.hpp>
+#include <kitty/partial_truth_table.hpp>
+
+#include "../io/write_patterns.hpp"
+#include "circuit_validator.hpp"
+#include "simulation.hpp"
+
+namespace mockturtle
+{
+
+struct functional_reduction_params
+{
+  /*! \brief Show progress. */
+  bool progress{ false };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+
+  /*! \brief Maximum number of iterations to run. 0 = repeat until no further improvement can be found. */
+  uint32_t max_iterations{ 10 };
+
+  /*! \brief Whether to use pre-generated patterns stored in a file.
+   * If not, by default, 256 random patterns will be used.
+   */
+  std::optional<std::string> pattern_filename{};
+
+  /*! \brief Whether to save the appended patterns (with CEXs) into file. */
+  std::optional<std::string> save_patterns{};
+
+  /*! \brief Maximum number of nodes in the transitive fanin cone (and their fanouts) to be compared to. */
+  uint32_t max_TFI_nodes{ 1000 };
+
+  /*! \brief Maximum fanout count of a node in the transitive fanin cone to explore its fanouts. */
+  uint32_t skip_fanout_limit{ 100 };
+
+  /*! \brief Conflict limit for the SAT solver. */
+  uint32_t conflict_limit{ 100 };
+
+  /*! \brief Maximum number of clauses of the SAT solver. (incremental CNF construction) */
+  uint32_t max_clauses{ 1000 };
+
+  /*! \brief Initial number of (random) simulation patterns. */
+  uint32_t num_patterns{ 256 };
+
+  /*! \brief Maximum number of simulation patterns. Discards all patterns and re-seeds with random patterns when exceeded. */
+  uint32_t max_patterns{ 1024 };
+};
+
+struct functional_reduction_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Time for simulation. */
+  stopwatch<>::duration time_sim{ 0 };
+
+  /*! \brief Time for SAT solving. */
+  stopwatch<>::duration time_sat{ 0 };
+
+  /*! \brief Number of accepted constant nodes. */
+  uint32_t num_const_accepts{ 0 };
+
+  /*! \brief Number of accepted functionally equivalent nodes. */
+  uint32_t num_equ_accepts{ 0 };
+
+  /*! \brief Number of counter-examples (SAT calls). */
+  uint32_t num_cex{ 0 };
+
+  /*! \brief Number of successful node reductions (UNSAT calls). */
+  uint32_t num_reduction{ 0 };
+
+  /*! \brief Number of SAT solver timeout. */
+  uint32_t num_timeout{ 0 };
+
+  void report() const
+  {
+    // clang-format off
+    std::cout <<              "[i] Functional Reduction\n";
+    std::cout <<              "[i] ========  Stats  ========\n";
+    std::cout << fmt::format( "[i] #constant = {:8d}\n", num_const_accepts );
+    std::cout << fmt::format( "[i] #FE pairs = {:8d}\n", num_equ_accepts );
+    std::cout << fmt::format( "[i] #SAT      = {:8d}\n", num_cex );
+    std::cout << fmt::format( "[i] #UNSAT    = {:8d}\n", num_reduction );
+    std::cout << fmt::format( "[i] #TIMEOUT  = {:8d}\n", num_timeout );
+    std::cout <<              "[i] ======== Runtime ========\n";
+    std::cout << fmt::format( "[i] total        : {:>5.2f} secs\n", to_seconds( time_total ) );
+    std::cout << fmt::format( "[i]   simulation : {:>5.2f} secs\n", to_seconds( time_sim ) );
+    std::cout << fmt::format( "[i]   SAT solving: {:>5.2f} secs\n", to_seconds( time_sat ) );
+    std::cout <<              "[i] =========================\n\n";
+    // clang-format on
+  }
+};
+
+namespace detail
+{
+template<typename Ntk, typename validator_t = circuit_validator<Ntk, bill::solvers::bsat2>>
+class functional_reduction_impl
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  using TT = unordered_node_map<kitty::partial_truth_table, Ntk>;
+
+  explicit functional_reduction_impl( Ntk& ntk, functional_reduction_params const& ps, validator_params const& vps, functional_reduction_stats& st )
+      : ntk( ntk ), ps( ps ), st( st ), tts( ntk ),
+        sim( ps.pattern_filename ? partial_simulator( *ps.pattern_filename ) : partial_simulator( ntk.num_pis(), ps.num_patterns, std::rand() ) ), validator( ntk, vps )
+  {
+    static_assert( !validator_t::use_odc_, "`circuit_validator::use_odc` flag should be turned off." );
+  }
+
+  ~functional_reduction_impl()
+  {
+    if ( ps.save_patterns )
+    {
+      write_patterns( sim, *ps.save_patterns );
+    }
+  }
+
+  void run()
+  {
+    stopwatch t( st.time_total );
+
+    /* first simulation: the whole circuit; from 0 bits. */
+    call_with_stopwatch( st.time_sim, [&]() {
+      simulate_nodes<Ntk>( ntk, tts, sim, true );
+    } );
+
+    /* remove constant nodes. */
+    substitute_constants();
+
+    /* substitute functional equivalent nodes. */
+    auto size_before = ntk.size();
+    substitute_equivalent_nodes();
+    uint32_t iterations{0};
+    while ( ps.max_iterations && iterations++ <= ps.max_iterations && ntk.size() != size_before )
+    {
+      size_before = ntk.size();
+      substitute_equivalent_nodes();
+    }
+  }
+
+private:
+  void substitute_constants()
+  {
+    progress_bar pbar{ ntk.size(), "FR-const |{0}| node = {1:>4}   cand = {2:>4}", ps.progress };
+
+    auto zero = sim.compute_constant( false );
+    auto one = sim.compute_constant( true );
+    ntk.foreach_gate( [&]( auto const& n, auto i ) {
+      pbar( i, i, candidates );
+
+      check_tts( n );
+      bool const_value;
+      if ( tts[n] == zero )
+      {
+        const_value = false;
+      }
+      else if ( tts[n] == one )
+      {
+        const_value = true;
+      }
+      else /* not constant */
+      {
+        return true; /* next */
+      }
+
+      /* update progress bar */
+      candidates++;
+
+      const auto res = call_with_stopwatch( st.time_sat, [&]() {
+        return validator.validate( n, const_value );
+      } );
+      if ( !res ) /* timeout */
+      {
+        ++st.num_timeout;
+        return true;
+      }
+      else if ( !( *res ) ) /* SAT, cex found */
+      {
+        found_cex();
+        zero = sim.compute_constant( false );
+        one = sim.compute_constant( true );
+      }
+      else /* UNSAT, constant verified */
+      {
+        ++st.num_reduction;
+        ++st.num_const_accepts;
+        /* update network */
+        ntk.substitute_node( n, ntk.get_constant( const_value ) );
+      }
+      return true;
+    } );
+  }
+
+  void substitute_equivalent_nodes()
+  {
+    progress_bar pbar{ ntk.size(), "FR-equ |{0}| node = {1:>4}   cand = {2:>4}", ps.progress };
+    ntk.foreach_gate( [&]( auto const& root, auto i ) {
+      pbar( i, i, candidates );
+
+      check_tts( root );
+      auto tt = tts[root];
+      auto ntt = ~tts[root];
+      std::vector<node> tfi;
+      bool keep_trying = true;
+      foreach_transitive_fanin( root, [&]( auto const& n ) {
+        tfi.emplace_back( n );
+        if ( tfi.size() > ps.max_TFI_nodes )
+        {
+          return false;
+        }
+
+        keep_trying = try_node( tt, ntt, root, n );
+        return keep_trying;
+      } );
+
+      if ( keep_trying ) /* didn't find a substitution in TFI cone, explore fanouts. */
+      {
+        for ( auto j = 0u; j < tfi.size() && tfi.size() <= ps.max_TFI_nodes && keep_trying; ++j )
+        {
+          auto& n = tfi.at( j );
+          if ( ntk.fanout_size( n ) > ps.skip_fanout_limit )
+          {
+            continue;
+          }
+
+          /* if the fanout has all fanins in the set, add it */
+          ntk.foreach_fanout( n, [&]( node const& p ) {
+            if ( ntk.visited( p ) == ntk.trav_id() )
+            {
+              return true; /* next fanout */
+            }
+
+            bool all_fanins_visited = true;
+            ntk.foreach_fanin( p, [&]( const auto& g ) {
+              if ( ntk.visited( ntk.get_node( g ) ) != ntk.trav_id() )
+              {
+                all_fanins_visited = false;
+                return false; /* terminate fanin-loop */
+              }
+              return true; /* next fanin */
+            } );
+            if ( !all_fanins_visited )
+            {
+              return true; /* next fanout */
+            }
+
+            bool has_root_as_child = false;
+            ntk.foreach_fanin( p, [&]( const auto& g ) {
+              if ( ntk.get_node( g ) == root )
+              {
+                has_root_as_child = true;
+                return false; /* terminate fanin-loop */
+              }
+              return true; /* next fanin */
+            } );
+            if ( has_root_as_child )
+            {
+              return true; /* next fanout */
+            }
+
+            tfi.emplace_back( p );
+            ntk.set_visited( p, ntk.trav_id() );
+
+            check_tts( p );
+            keep_trying = try_node( tt, ntt, root, p );
+            return keep_trying;
+          } );
+        }
+      }
+
+      return true; /* next */
+    } );
+  }
+
+  bool try_node( kitty::partial_truth_table& tt, kitty::partial_truth_table& ntt, node const& root, node const& n )
+  {
+    signal g;
+    if ( tt == tts[n] )
+    {
+      g = ntk.make_signal( n );
+    }
+    else if ( ntt == tts[n] )
+    {
+      g = !ntk.make_signal( n );
+    }
+    else /* not equivalent */
+    {
+      return true; /* try next transitive fanin node */
+    }
+
+    /* update progress bar */
+    candidates++;
+
+    const auto res = call_with_stopwatch( st.time_sat, [&]() {
+      return validator.validate( root, g );
+    } );
+    if ( !res ) /* timeout */
+    {
+      ++st.num_timeout;
+      return true; /* try next transitive fanin node */
+    }
+    else if ( !( *res ) ) /* SAT, cex found */
+    {
+      found_cex();
+      check_tts( root );
+      tt = tts[root];
+      ntt = ~tts[root];
+      return true; /* try next transitive fanin node */
+    }
+    else /* UNSAT, equivalent node verified */
+    {
+      ++st.num_reduction;
+      ++st.num_equ_accepts;
+      /* update network */
+      ntk.substitute_node( root, g );
+      return false; /* break `foreach_transitive_fanin` */
+    }
+  }
+
+  void found_cex()
+  {
+    ++st.num_cex;
+    sim.add_pattern( validator.cex );
+
+    if ( sim.num_bits() > ps.max_patterns )
+    {
+      reseed_patterns();
+      return;
+    }
+
+    /* re-simulate the whole circuit (for the last block) when a block is full */
+    if ( sim.num_bits() % 64 == 0 )
+    {
+      call_with_stopwatch( st.time_sim, [&]() {
+        simulate_nodes<Ntk>( ntk, tts, sim, false );
+      } );
+    }
+  }
+
+  void check_tts( node const& n )
+  {
+    if ( tts[n].num_bits() != sim.num_bits() )
+    {
+      call_with_stopwatch( st.time_sim, [&]() {
+        simulate_node<Ntk>( ntk, n, tts, sim );
+      } );
+    }
+  }
+
+  void reseed_patterns()
+  {
+    sim = partial_simulator( ntk.num_pis(), ps.num_patterns, std::rand() );
+    tts.reset();
+    call_with_stopwatch( st.time_sim, [&]() {
+      simulate_nodes<Ntk>( ntk, tts, sim, true );
+    } );
+  }
+
+  template<typename Fn>
+  void foreach_transitive_fanin( node const& n, Fn&& fn )
+  {
+    ntk.incr_trav_id();
+    ntk.set_visited( n, ntk.trav_id() );
+
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      return foreach_transitive_fanin_rec( ntk.get_node( f ), fn );
+    } );
+  }
+
+  template<typename Fn>
+  bool foreach_transitive_fanin_rec( node const& n, Fn&& fn )
+  {
+    ntk.set_visited( n, ntk.trav_id() );
+    if ( !fn( n ) )
+    {
+      return false;
+    }
+    bool continue_loop = true;
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      if ( ntk.visited( ntk.get_node( f ) ) == ntk.trav_id() )
+      {
+        return true;
+      } /* skip visited node, continue looping. */
+
+      continue_loop = foreach_transitive_fanin_rec( ntk.get_node( f ), fn );
+      return continue_loop; /* break `foreach_fanin` loop immediately when receiving `false`. */
+    } );
+    return continue_loop; /* return `false` only if `false` has ever been received from recursive calls. */
+  }
+
+private:
+  Ntk& ntk;
+  functional_reduction_params const& ps;
+  functional_reduction_stats& st;
+
+  TT tts;
+  partial_simulator sim;
+  validator_t validator;
+
+  uint32_t candidates{ 0 };
+}; /* functional_reduction_impl */
+
+} /* namespace detail */
+
+/*! \brief Functional reduction.
+ *
+ * Removes constant nodes and substitute functionally equivalent nodes.
+ */
+template<class Ntk>
+void functional_reduction( Ntk& ntk, functional_reduction_params const& ps = {}, functional_reduction_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+  static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the substitute_node method" );
+  static_assert( has_visited_v<Ntk>, "Ntk does not implement the visited method" );
+
+  validator_params vps;
+  vps.max_clauses = ps.max_clauses;
+  vps.conflict_limit = ps.conflict_limit;
+
+  using fanout_view_t = fanout_view<Ntk>;
+  fanout_view_t fanout_view{ ntk };
+
+  functional_reduction_stats st;
+  detail::functional_reduction_impl p( fanout_view, ps, vps, st );
+  p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/gates_to_nodes.hpp b/include/mockturtle/algorithms/gates_to_nodes.hpp
new file mode 100644
index 0000000..6dc6541
--- /dev/null
+++ b/include/mockturtle/algorithms/gates_to_nodes.hpp
@@ -0,0 +1,174 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file gates_to_nodes.hpp
+  \brief Convert gate-based network into node-based network
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include <fmt/format.h>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/operations.hpp>
+#include <kitty/print.hpp>
+
+#include "../traits.hpp"
+#include "../utils/node_map.hpp"
+#include "simulation.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Translates a gate-based network into a node-based network.
+ *
+ * A node will be created in the node-based network for every gate based on the
+ * gate function.  Possible complemented fanins are merged into the node
+ * function.
+ *
+ * **Required network functions for parameter ntk (type NtkSource):**
+ * - `foreach_pi`
+ * - `foreach_gate`
+ * - `foreach_fanin`
+ * - `get_constant`
+ * - `get_node`
+ * - `is_constant`
+ * - `is_pi`
+ * - `is_complemented`
+ * - `node_function`
+ *
+ * **Required network functions for return value (type NtkDest):**
+ * - `create_pi`
+ * - `create_po`
+ * - `create_node`
+ * - `create_not`
+ * - `get_constant`
+ *
+ * \param ntk Network
+ */
+template<class NtkDest, class NtkSource>
+NtkDest gates_to_nodes( NtkSource const& ntk )
+{
+  static_assert( is_network_type_v<NtkDest>, "NtkDest is not a network type" );
+  static_assert( has_create_pi_v<NtkDest>, "NtkDest does not implement the create_pi method" );
+  static_assert( has_create_po_v<NtkDest>, "NtkDest does not implement the create_po method" );
+  static_assert( has_create_node_v<NtkDest>, "NtkDest does not implement the create_node method" );
+  static_assert( has_create_not_v<NtkDest>, "NtkDest does not implement the create_not method" );
+  static_assert( has_get_constant_v<NtkDest>, "NtkDest does not implement the get_constant method" );
+
+  static_assert( is_network_type_v<NtkSource>, "NtkSource is not a network type" );
+  static_assert( has_foreach_pi_v<NtkSource>, "NtkSource does not implement the foreach_pi method" );
+  static_assert( has_foreach_gate_v<NtkSource>, "NtkSource does not implement the foreach_gate method" );
+  static_assert( has_foreach_fanin_v<NtkSource>, "NtkSource does not implement the foreach_fanin method" );
+  static_assert( has_get_constant_v<NtkSource>, "NtkSource does not implement the get_constant method" );
+  static_assert( has_get_node_v<NtkSource>, "NtkSource does not implement the get_node method" );
+  static_assert( has_is_constant_v<NtkSource>, "NtkSource does not implement the is_constant method" );
+  static_assert( has_is_pi_v<NtkSource>, "NtkSource does not implement the is_pi method" );
+  static_assert( has_is_complemented_v<NtkSource>, "NtkSource does not implement the is_complemented method" );
+  static_assert( has_node_function_v<NtkSource>, "NtkSource does not implement the node_function method" );
+
+  NtkDest dest;
+  node_map<signal<NtkDest>, NtkSource> node_to_signal( ntk );
+
+  ntk.foreach_pi( [&]( auto const& n ) {
+    node_to_signal[n] = dest.create_pi();
+  } );
+
+  node_to_signal[ntk.get_constant( false )] = dest.get_constant( false );
+  if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+  {
+    node_to_signal[ntk.get_constant( true )] = dest.get_constant( true );
+  }
+
+  ntk.foreach_gate( [&]( auto const& n ) {
+    std::vector<signal<NtkDest>> children;
+    auto func = ntk.node_function( n );
+    ntk.foreach_fanin( n, [&]( auto const& c, auto i ) {
+      if ( ntk.is_complemented( c ) )
+      {
+        kitty::flip_inplace( func, i );
+      }
+      children.push_back( node_to_signal[c] );
+    } );
+
+    node_to_signal[n] = dest.create_node( children, func );
+  } );
+
+  /* outputs */
+  ntk.foreach_po( [&]( auto const& s ) {
+    dest.create_po( ntk.is_complemented( s ) ? dest.create_not( node_to_signal[s] ) : node_to_signal[s] );
+  } );
+
+  return dest;
+}
+
+/*! \brief Creates a new network with a single node per output.
+ *
+ * This method can be applied to networks with a small number of primary inputs,
+ * to collapse all the logic of an output into a single node.  The returning
+ * network must support arbitrary node functions, e.g., `klut_network`.
+ */
+template<class NtkDest, class NtkSrc>
+NtkDest single_node_network( NtkSrc const& src )
+{
+  static_assert( is_network_type_v<NtkDest>, "NtkDest is not a network type" );
+  static_assert( has_create_pi_v<NtkDest>, "NtkDest does not implement the create_pi method" );
+  static_assert( has_create_po_v<NtkDest>, "NtkDest does not implement the create_po method" );
+  static_assert( has_create_node_v<NtkDest>, "NtkDest does not implement the create_node method" );
+  static_assert( is_network_type_v<NtkSrc>, "NtkSrc is not a network type" );
+  static_assert( has_num_pis_v<NtkSrc>, "NtkSrc does not implement the num_pis method" );
+
+  NtkDest ntk;
+  std::vector<signal<NtkDest>> pis( src.num_pis() );
+  std::generate( pis.begin(), pis.end(), [&]() { return ntk.create_pi(); } );
+
+  default_simulator<kitty::dynamic_truth_table> sim( src.num_pis() );
+  const auto tts = simulate<kitty::dynamic_truth_table>( src, sim );
+
+  for ( auto tt : tts )
+  {
+    const auto support = kitty::min_base_inplace( tt );
+    const auto small_tt = kitty::shrink_to( tt, static_cast<unsigned int>( support.size() ) );
+    std::vector<signal<NtkDest>> children( support.size() );
+    for ( auto i = 0u; i < support.size(); ++i )
+    {
+      children[i] = pis[support[i]];
+    }
+    ntk.create_po( ntk.create_node( children, small_tt ) );
+  }
+
+  return ntk;
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/klut_to_graph.hpp b/include/mockturtle/algorithms/klut_to_graph.hpp
new file mode 100644
index 0000000..4f82385
--- /dev/null
+++ b/include/mockturtle/algorithms/klut_to_graph.hpp
@@ -0,0 +1,131 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file klut_to_graph.hpp
+  \brief Convert a k-LUT network into AIG, XAG, MIG or XMG.
+
+  \author Andrea Costamagna
+*/
+
+#pragma once
+
+#include "../networks/aig.hpp"
+#include "../networks/klut.hpp"
+#include "../networks/mig.hpp"
+#include "../networks/xag.hpp"
+#include "../networks/xmg.hpp"
+#include "node_resynthesis.hpp"
+#include "node_resynthesis/dsd.hpp"
+#include "node_resynthesis/mig_npn.hpp"
+#include "node_resynthesis/shannon.hpp"
+#include "node_resynthesis/xag_npn.hpp"
+#include "node_resynthesis/xmg_npn.hpp"
+
+namespace mockturtle
+{
+namespace detail
+{
+
+/* declare the npn-resynthesis function to be used depending on the desired network type. */
+template<class NtkDestBase>
+const auto set_npn_resynthesis_fn()
+{
+  using aig_npn_type = xag_npn_resynthesis<aig_network, xag_network, xag_npn_db_kind::aig_complete>;
+  using xag_npn_type = xag_npn_resynthesis<xag_network, xag_network, xag_npn_db_kind::xag_complete>;
+  using mig_npn_type = mig_npn_resynthesis;
+  using xmg_npn_type = xmg_npn_resynthesis;
+
+  if constexpr ( std::is_same_v<NtkDestBase, aig_network> )
+    return aig_npn_type{};
+  else if constexpr ( std::is_same_v<NtkDestBase, xag_network> )
+    return xag_npn_type{};
+  else if constexpr ( std::is_same_v<NtkDestBase, mig_network> )
+    return mig_npn_type{};
+  else if constexpr ( std::is_same_v<NtkDestBase, xmg_network> )
+    return xmg_npn_type{};
+}
+
+} // namespace detail
+
+/*! \brief Convert a k-LUT network into AIG, XAG, MIG or XMG (out-of-place)
+ *
+ * This function is a wrapper function for resynthesizing a k-LUT network (type `NtkSrc`) into a
+ * new graph (of type `NtkDest`). The new data structure can be of type AIG, XAG, MIG or XMG.
+ * First the function attempts a Disjoint Support Decomposition (DSD), branching the network into subnetworks.
+ * As soon as DSD can no longer be done, there are two possibilities depending on the dimensionality of the
+ * subnetwork to be resynthesized. On the one hand, if the size of the associated support is lower or equal
+ * than 4, the solution can be recovered by exploiting the mapping of the subnetwork to its NPN-class.
+ * On the other hand, if the support size is higher than 4, A Shannon decomposition is performed, branching
+ * the network in further subnetworks with reduced support.
+ * Finally, once the threshold value of 4 is reached, the NPN mapping completes the graph definition.
+ *
+ * \tparam NtkDest Type of the destination network. Its base type should be either `aig_network`, `xag_network`, `mig_network`, or `xmg_network`.
+ * \tparam NtkSrc Type of the source network. Its base type should be `klut_network`.
+ * \param ntk_src Input k-lut network
+ * \return An equivalent AIG, XAG, MIG or XMG network
+ */
+template<class NtkDest, class NtkSrc>
+NtkDest convert_klut_to_graph( NtkSrc const& ntk_src )
+{
+  using NtkDestBase = typename NtkDest::base_type;
+  static_assert( std::is_same_v<typename NtkSrc::base_type, klut_network>, "NtkSrc is not klut_network" );
+  static_assert( std::is_same_v<NtkDestBase, aig_network> || std::is_same_v<NtkDestBase, xag_network> ||
+                     std::is_same_v<NtkDestBase, mig_network> || std::is_same_v<NtkDestBase, xmg_network>,
+                 "NtkDest is not an AIG, XAG, MIG, or XMG" );
+
+  uint32_t threshold{ 4 };
+  auto fallback_npn = detail::set_npn_resynthesis_fn<NtkDestBase>();
+  shannon_resynthesis<NtkDest, decltype( fallback_npn )> fallback_shannon( threshold, &fallback_npn );
+  dsd_resynthesis<NtkDest, decltype( fallback_shannon )> resyn( fallback_shannon );
+  return node_resynthesis<NtkDest>( ntk_src, resyn );
+}
+
+/*! \brief Convert a k-LUT network into AIG, XAG, MIG or XMG (in-place)
+ *
+ * The algorithmic details are the same as the out-of-place version.
+ *
+ * \tparam NtkDest Type of the destination network. Its base type should be either `aig_network`, `xag_network`, `mig_network`, or `xmg_network`.
+ * \tparam NtkSrc Type of the source network. Its base type should be `klut_network`.
+ * \param ntk_dest An empty AIG, XAG, MIG or XMG network to be constructed in-place
+ * \param ntk_src Input k-lut network
+ */
+template<class NtkDest, class NtkSrc>
+void convert_klut_to_graph( NtkDest& ntk_dest, NtkSrc const& ntk_src )
+{
+  using NtkDestBase = typename NtkDest::base_type;
+  static_assert( std::is_same_v<typename NtkSrc::base_type, klut_network>, "NtkSrc is not klut_network" );
+  static_assert( std::is_same_v<NtkDestBase, aig_network> || std::is_same_v<NtkDestBase, xag_network> ||
+                     std::is_same_v<NtkDestBase, mig_network> || std::is_same_v<NtkDestBase, xmg_network>,
+                 "NtkDest is not an AIG, XAG, MIG, or XMG" );
+
+  uint32_t threshold{ 4 };
+  auto fallback_npn = detail::set_npn_resynthesis_fn<NtkDestBase>();
+  shannon_resynthesis<NtkDest, decltype( fallback_npn )> fallback_shannon( threshold, &fallback_npn );
+  dsd_resynthesis<NtkDest, decltype( fallback_shannon )> resyn( fallback_shannon );
+  node_resynthesis<NtkDest>( ntk_dest, ntk_src, resyn );
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/linear_resynthesis.hpp b/include/mockturtle/algorithms/linear_resynthesis.hpp
new file mode 100644
index 0000000..a0e08de
--- /dev/null
+++ b/include/mockturtle/algorithms/linear_resynthesis.hpp
@@ -0,0 +1,1008 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file linear_resynthesis.hpp
+  \brief Resynthesize linear circuit
+
+  \author Eleonora Testa
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <iostream>
+#include <optional>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "../algorithms/cnf.hpp"
+#include "../algorithms/simulation.hpp"
+#include "../networks/xag.hpp"
+#include "../traits.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../views/cnf_view.hpp"
+
+#include <fmt/format.h>
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+class linear_sum_simulator
+{
+public:
+  std::vector<uint32_t> compute_constant( bool ) const { return {}; }
+  std::vector<uint32_t> compute_pi( uint32_t index ) const { return { index }; }
+  std::vector<uint32_t> compute_not( std::vector<uint32_t> const& value ) const
+  {
+    assert( false && "No NOTs in linear forms allowed" );
+    std::abort();
+    return value;
+  }
+};
+
+class linear_matrix_simulator
+{
+public:
+  linear_matrix_simulator( uint32_t num_inputs ) : num_inputs_( num_inputs ) {}
+
+  std::vector<bool> compute_constant( bool ) const { return std::vector<bool>( num_inputs_, false ); }
+  std::vector<bool> compute_pi( uint32_t index ) const
+  {
+    std::vector<bool> row( num_inputs_, false );
+    row[index] = true;
+    return row;
+  }
+  std::vector<bool> compute_not( std::vector<bool> const& value ) const
+  {
+    assert( false && "No NOTs in linear forms allowed" );
+    std::abort();
+    return value;
+  }
+
+private:
+  uint32_t num_inputs_;
+};
+
+class linear_xag : public xag_network
+{
+public:
+  linear_xag( xag_network const& xag ) : xag_network( xag ) {}
+
+  template<typename Iterator>
+  iterates_over_t<Iterator, std::vector<uint32_t>>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_pi( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+
+    auto set1 = *begin++;
+    auto set2 = *begin++;
+
+    if ( c1.index < c2.index )
+    {
+      assert( false );
+      std::abort();
+      return {};
+    }
+    else
+    {
+      std::vector<uint32_t> result;
+      auto it1 = set1.begin();
+      auto it2 = set2.begin();
+
+      while ( it1 != set1.end() && it2 != set2.end() )
+      {
+        if ( *it1 < *it2 )
+        {
+          result.push_back( *it1++ );
+        }
+        else if ( *it1 > *it2 )
+        {
+          result.push_back( *it2++ );
+        }
+        else
+        {
+          ++it1;
+          ++it2;
+        }
+      }
+
+      if ( it1 != set1.end() )
+      {
+        std::copy( it1, set1.end(), std::back_inserter( result ) );
+      }
+      else if ( it2 != set2.end() )
+      {
+        std::copy( it2, set2.end(), std::back_inserter( result ) );
+      }
+
+      return result;
+    }
+  }
+
+  template<typename Iterator>
+  iterates_over_t<Iterator, std::vector<bool>>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_pi( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+
+    auto set1 = *begin++;
+    auto set2 = *begin++;
+
+    if ( c1.index < c2.index )
+    {
+      assert( false );
+      std::abort();
+      return {};
+    }
+    else
+    {
+      std::vector<bool> result( set1.size() );
+      std::transform( set1.begin(), set1.end(), set2.begin(), result.begin(), std::not_equal_to<bool>{} );
+      return result;
+    }
+  }
+};
+
+struct pair_hash
+{
+  template<class T1, class T2>
+  std::size_t operator()( std::pair<T1, T2> const& p ) const
+  {
+    return std::hash<T1>()( p.first ) ^ std::hash<T2>()( p.second );
+  }
+};
+
+template<class Ntk>
+struct linear_resynthesis_paar_impl
+{
+public:
+  using index_pair_t = std::pair<uint32_t, uint32_t>;
+
+  linear_resynthesis_paar_impl( Ntk const& xag ) : xag( xag ) {}
+
+  Ntk run()
+  {
+    xag.foreach_pi( [&]( auto const& ) {
+      signals.push_back( dest.create_pi() );
+    } );
+
+    extract_linear_equations();
+
+    while ( !occurrence_to_pairs.empty() )
+    {
+      const auto p = *( occurrence_to_pairs.back().begin() );
+      replace_one_pair( p );
+    }
+
+    xag.foreach_po( [&]( auto const& f, auto i ) {
+      if ( linear_equations[i].empty() )
+      {
+        dest.create_po( dest.get_constant( xag.is_complemented( f ) ) );
+      }
+      else
+      {
+        assert( linear_equations[i].size() == 1u );
+        dest.create_po( signals[linear_equations[i].front()] ^ xag.is_complemented( f ) );
+      }
+    } );
+
+    return dest;
+  }
+
+private:
+  void extract_linear_equations()
+  {
+    occurrence_to_pairs.resize( 1u );
+
+    linear_xag lxag{ xag };
+    linear_equations = simulate<std::vector<uint32_t>>( lxag, linear_sum_simulator{} );
+
+    for ( auto o = 0u; o < linear_equations.size(); ++o )
+    {
+      const auto& lin_eq = linear_equations[o];
+      for ( auto j = 1u; j < lin_eq.size(); ++j )
+      {
+        for ( auto i = 0u; i < j; ++i )
+        {
+          const auto p = std::make_pair( lin_eq[i], lin_eq[j] );
+          pairs_to_output[p].push_back( o );
+          add_pair( p );
+        }
+      }
+    }
+  }
+
+  void add_pair( index_pair_t const& p )
+  {
+    if ( auto it = pair_to_occurrence.find( p ); it != pair_to_occurrence.end() )
+    {
+      // found another time
+      const auto occ = it->second;
+      occurrence_to_pairs[occ - 1u].erase( p );
+      if ( occurrence_to_pairs.size() <= occ + 1u )
+      {
+        occurrence_to_pairs.resize( occ + 1u );
+      }
+      occurrence_to_pairs[occ].insert( p );
+      it->second++;
+    }
+    else
+    {
+      // first time found
+      pair_to_occurrence[p] = 1u;
+      occurrence_to_pairs[0u].insert( p );
+    }
+  }
+
+  void remove_all_pairs( index_pair_t const& p )
+  {
+    auto it = pair_to_occurrence.find( p );
+    const auto occ = it->second;
+    pair_to_occurrence.erase( it );
+    occurrence_to_pairs[occ - 1u].erase( p );
+    while ( !occurrence_to_pairs.empty() && occurrence_to_pairs.back().empty() )
+    {
+      occurrence_to_pairs.pop_back();
+    }
+    pairs_to_output.erase( p );
+  }
+
+  void remove_one_pair( index_pair_t const& p, uint32_t output )
+  {
+    auto it = pair_to_occurrence.find( p );
+    const auto occ = it->second;
+    occurrence_to_pairs[occ - 1u].erase( p );
+    if ( occ > 1u )
+    {
+      occurrence_to_pairs[occ - 2u].insert( p );
+    }
+    it->second--;
+    pairs_to_output[p].erase( std::remove( pairs_to_output[p].begin(), pairs_to_output[p].end(), output ), pairs_to_output[p].end() );
+  }
+
+  void replace_one_pair( index_pair_t const& p )
+  {
+    const auto [a, b] = p;
+    auto c = static_cast<uint32_t>( signals.size() );
+    signals.push_back( dest.create_xor( signals[a], signals[b] ) );
+
+    /* update data structures */
+    for ( auto o : pairs_to_output[p] )
+    {
+      auto& leq = linear_equations[o];
+      leq.erase( std::remove( leq.begin(), leq.end(), a ), leq.end() );
+      leq.erase( std::remove( leq.begin(), leq.end(), b ), leq.end() );
+      for ( auto i : leq )
+      {
+        remove_one_pair( { std::min( i, a ), std::max( i, a ) }, o );
+        remove_one_pair( { std::min( i, b ), std::max( i, b ) }, o );
+        add_pair( { i, c } );
+        pairs_to_output[{ i, c }].push_back( o );
+      }
+      leq.push_back( c );
+    }
+    remove_all_pairs( p );
+  }
+
+  void print_linear_matrix()
+  {
+    for ( auto const& le : linear_equations )
+    {
+      auto it = le.begin();
+      for ( auto i = 0u; i < signals.size(); ++i )
+      {
+        if ( it != le.end() && *it == i )
+        {
+          std::cout << " 1";
+          it++;
+        }
+        else
+        {
+          std::cout << " 0";
+        }
+      }
+      assert( it == le.end() );
+      std::cout << "\n";
+    }
+  }
+
+private:
+  Ntk const& xag;
+  Ntk dest;
+  std::vector<signal<Ntk>> signals;
+  std::vector<std::vector<uint32_t>> linear_equations;
+  std::vector<std::unordered_set<index_pair_t, pair_hash>> occurrence_to_pairs;
+  std::unordered_map<index_pair_t, uint32_t, pair_hash> pair_to_occurrence;
+  std::unordered_map<index_pair_t, std::vector<uint32_t>, pair_hash> pairs_to_output;
+};
+
+} // namespace detail
+
+/*! \brief Linear circuit resynthesis (Paar's algorithm)
+ *
+ * This algorithm works on an XAG that is only composed of XOR gates.  It
+ * extracts a matrix representation of the linear output equations and
+ * resynthesizes them in a greedy manner by always substituting the most
+ * frequent pair of variables using the computed function of an XOR gate.
+ *
+ * Reference: [C. Paar, IEEE Int'l Symp. on Inf. Theo. (1997), page 250]
+ */
+template<typename Ntk>
+Ntk linear_resynthesis_paar( Ntk const& xag )
+{
+  static_assert( std::is_same_v<typename Ntk::base_type, xag_network>, "Ntk is not XAG-like" );
+
+  return detail::linear_resynthesis_paar_impl<Ntk>( xag ).run();
+}
+
+struct exact_linear_synthesis_params
+{
+  /*! \brief Upper bound on number of XOR gates. If used, best solution is found decreasing */
+  std::optional<uint32_t> upper_bound{};
+
+  /*! \brief Conflict limit for SAT solving (default 0 = no limit). */
+  int conflict_limit{ 0 };
+
+  /*! \brief Solution must be cancellation-free. */
+  bool cancellation_free{ false };
+
+  /*! \brief Ignore inputs in any step to compute this output.
+   *
+   * Either the vector is empty, if no inputs should be ignored, or it has as
+   * many entries as rows in the input matrix.  Each entry is a vector of input
+   * indexes (starting from 0) to be ignored, an entry can be the empty vector,
+   * if no inputs should be ignored for some output.
+   */
+  std::vector<std::vector<uint32_t>> ignore_inputs;
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+
+  /*! \brief Be very verbose (debug messages). */
+  bool very_verbose{ false };
+};
+
+struct exact_linear_synthesis_stats
+{
+  /*! \brief Total time. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Time for SAT solving. */
+  stopwatch<>::duration time_solving{ 0 };
+
+  /*! \brief Prints report. */
+  void report() const
+  {
+    fmt::print( "[i] total time   = {:>5.2f} secs\n", to_seconds( time_total ) );
+    fmt::print( "[i] solving time = {:>5.2f} secs\n", to_seconds( time_solving ) );
+  }
+};
+
+namespace detail
+{
+
+template<bill::solvers Solver>
+struct exact_linear_synthesis_problem_network
+{
+  using problem_network_t = cnf_view<xag_network, false, Solver>;
+
+  exact_linear_synthesis_problem_network( uint32_t num_steps, std::vector<std::vector<bool>> const& linear_matrix, std::vector<std::vector<uint32_t>> const& ignore_inputs, std::vector<std::pair<uint32_t, uint32_t>> const& trivial_pos, exact_linear_synthesis_params const& ps )
+      : linear_matrix_( linear_matrix ),
+        k_( num_steps ),
+        n_( static_cast<uint32_t>( linear_matrix.front().size() ) ),
+        m_( static_cast<uint32_t>( linear_matrix.size() ) ),
+        bs_( k_ * n_ ),
+        cs_( ( ( k_ - 1 ) * k_ ) / 2 ),
+        fs_( k_ * m_ ),
+        psis_( k_ * n_ ),
+        phis_( k_ * n_ ),
+        ignore_inputs_( ignore_inputs ),
+        trivial_pos_( trivial_pos ),
+        ps_( ps )
+  {
+    std::generate( bs_.begin(), bs_.end(), [&]() { return pntk_.create_pi(); } );
+    std::generate( cs_.begin(), cs_.end(), [&]() { return pntk_.create_pi(); } );
+    std::generate( fs_.begin(), fs_.end(), [&]() { return pntk_.create_pi(); } );
+
+    ensure_row_size2();
+    ensure_connectivity();
+    ensure_outputs();
+  }
+
+  std::optional<bool> solve()
+  {
+    return pntk_.solve( ps_.conflict_limit );
+  }
+
+  template<class Ntk>
+  Ntk extract_solution()
+  {
+    Ntk ntk;
+
+    std::vector<signal<Ntk>> nodes( n_ );
+    std::generate( nodes.begin(), nodes.end(), [&]() { return ntk.create_pi(); } );
+
+    for ( auto i = 0u; i < k_; ++i )
+    {
+      std::array<signal<Ntk>, 2> children;
+      auto it = children.begin();
+      for ( auto j = 0u; j < n_ + i; ++j )
+      {
+        if ( pntk_.model_value( b_or_c( i, j ) ) )
+        {
+          *it++ = nodes[j];
+        }
+      }
+      nodes.push_back( ntk.create_xor( children[0], children[1] ) );
+    }
+
+    auto it = trivial_pos_.begin();
+    auto poctr = 0u;
+    for ( auto l = 0u; l < m_; ++l )
+    {
+      while ( it != trivial_pos_.end() && it->first == poctr )
+      {
+        ntk.create_po( it->second == n_ ? ntk.get_constant( false ) : nodes[it->second] );
+        poctr++;
+        ++it;
+      }
+
+      for ( auto i = 0u; i < k_; ++i )
+      {
+        if ( pntk_.model_value( f( l, i ) ) )
+        {
+          ntk.create_po( nodes[n_ + i] );
+          poctr++;
+          break;
+        }
+      }
+    }
+
+    /* maybe some trivial POs are still left. */
+    while ( it != trivial_pos_.end() && it->first == poctr )
+    {
+      ntk.create_po( it->second == n_ ? ntk.get_constant( false ) : nodes[it->second] );
+      poctr++;
+      ++it;
+    }
+
+    return ntk;
+  }
+
+  void debug_solution()
+  {
+    for ( auto i = 0u; i < k_; ++i )
+    {
+      fmt::print( i == 0 ? "B =" : "   " );
+      for ( auto j = 0u; j < n_; ++j )
+      {
+        fmt::print( " {}", (int)pntk_.model_value( b( i, j ) ) );
+      }
+      fmt::print( i == 0 ? " C =" : "    " );
+      for ( auto p = 0u; p < i; ++p )
+      {
+        fmt::print( " {}", (int)pntk_.model_value( c( i, p ) ) );
+      }
+      fmt::print( std::string( 2 * ( k_ - i ), ' ' ) );
+      fmt::print( i == 0u ? " F =" : "    " );
+      for ( auto l = 0u; l < m_; ++l )
+      {
+        fmt::print( " {}", (int)pntk_.model_value( f( l, i ) ) );
+      }
+      fmt::print( "\n" );
+    }
+  }
+
+private:
+  void ensure_row_size2()
+  {
+    for ( auto i = 0u; i < k_; ++i )
+    {
+      /* at least 2 */
+      for ( auto cpl = 0u; cpl <= n_ + i; ++cpl )
+      {
+        std::vector<signal<problem_network_t>> lits( n_ + i );
+        for ( auto j = 0u; j < n_ + i; ++j )
+        {
+          lits[j] = b_or_c( i, j ) ^ ( cpl == j );
+        }
+        pntk_.add_clause( lits );
+      }
+
+      /* at most 2 */
+      for ( auto j = 2u; j < n_ + i; ++j )
+      {
+        for ( auto jj = 1u; jj < j; ++jj )
+        {
+          for ( auto jjj = 0u; jjj < jj; ++jjj )
+          {
+            pntk_.add_clause( !b_or_c( i, j ), !b_or_c( i, jj ), !b_or_c( i, jjj ) );
+          }
+        }
+      }
+    }
+  }
+
+  void ensure_connectivity()
+  {
+    // psi function
+    for ( auto i = 0u; i < k_; ++i )
+    {
+      for ( auto j = 0u; j < n_; ++j )
+      {
+        std::vector<signal<problem_network_t>> xors( 1 + i );
+        auto it = xors.begin();
+        *it++ = b( i, j );
+        for ( auto p = 0u; p < i; ++p )
+        {
+          *it++ = pntk_.create_and( c( i, p ), psi( j, p ) );
+        }
+        psi( j, i ) = pntk_.create_nary_xor( xors );
+      }
+    }
+
+    for ( auto l = 0u; l < m_; ++l )
+    {
+      for ( auto i = 0u; i < k_; ++i )
+      {
+        std::vector<signal<problem_network_t>> ands( n_ );
+        for ( auto j = 0u; j < n_; ++j )
+        {
+          ands[j] = pntk_.create_xnor( psi( j, i ), pntk_.get_constant( linear_matrix_[l][j] ) );
+        }
+        pntk_.add_clause( !f( l, i ), pntk_.create_nary_and( ands ) );
+      }
+    }
+
+    // No two steps are the same
+    for ( auto i = 0u; i < k_; ++i )
+    {
+      for ( auto p = 0u; p < i; ++p )
+      {
+        std::vector<signal<problem_network_t>> ors( n_ );
+        for ( auto j = 0u; j < n_; ++j )
+        {
+          ors[j] = pntk_.create_xor( psi( j, p ), psi( j, i ) );
+        }
+        pntk_.add_clause( ors );
+      }
+    }
+
+    if ( !ignore_inputs_.empty() || ps_.cancellation_free )
+    {
+      // phi function
+      for ( auto i = 0u; i < k_; ++i )
+      {
+        for ( auto j = 0u; j < n_; ++j )
+        {
+          std::vector<signal<problem_network_t>> ors( 1 + i );
+          auto it = ors.begin();
+          *it++ = b( i, j );
+          for ( auto p = 0u; p < i; ++p )
+          {
+            *it++ = pntk_.create_and( c( i, p ), phi( j, p ) );
+          }
+          phi( j, i ) = pntk_.create_nary_or( ors );
+        }
+      }
+
+      // cancellation-free
+      if ( ps_.cancellation_free )
+      {
+        for ( auto i = 0u; i < k_; ++i )
+        {
+          for ( auto j = 0u; j < n_; ++j )
+          {
+            pntk_.add_clause( !psi( j, i ), phi( j, i ) );
+            pntk_.add_clause( psi( j, i ), !phi( j, i ) );
+          }
+        }
+      }
+    }
+
+    // ignored inputs
+    if ( !ignore_inputs_.empty() )
+    {
+      for ( auto l = 0u; l < m_; ++l )
+      {
+        for ( auto j : ignore_inputs_[l] )
+        {
+          for ( auto i = 0u; i < k_; ++i )
+          {
+            pntk_.add_clause( !f( l, i ), !phi( j, i ) );
+          }
+        }
+      }
+    }
+
+    // at least 2 inputs in each compute form
+    for ( auto i = 0u; i < k_; ++i )
+    {
+      /* at least 2 */
+      for ( auto cpl = 0u; cpl <= n_; ++cpl )
+      {
+        std::vector<signal<problem_network_t>> lits( n_ );
+        for ( auto j = 0u; j < n_; ++j )
+        {
+          lits[j] = psi( j, i ) ^ ( cpl == j );
+        }
+        pntk_.add_clause( lits );
+      }
+    }
+  }
+
+  void ensure_outputs()
+  {
+    // each output covers at least one row
+    for ( auto l = 0u; l < m_; ++l )
+    {
+      std::vector<signal<problem_network_t>> lits( k_ );
+      for ( auto i = 0u; i < k_; ++i )
+      {
+        lits[i] = f( l, i );
+        for ( auto ii = i + 1; ii < k_; ++ii )
+        {
+          pntk_.add_clause( !f( l, i ), !f( l, ii ) );
+        }
+      }
+      pntk_.add_clause( lits );
+    }
+
+    // at most one output (if no duplicates) per row
+    // for ( auto i = 0u; i < k_; ++i )
+    //{
+    //  for ( auto l = 1u; l < m_; ++l )
+    //  {
+    //    for ( auto ll = 0u; ll < l; ++ll )
+    //    {
+    //      pntk_.add_clause( !f( l, i ), !f( ll, i ) );
+    //    }
+    //  }
+    //}
+  }
+
+  // 0 <= i <= k - 1
+  // 0 <= j <= n - 1
+  const signal<problem_network_t>& b( uint32_t i, uint32_t j ) const
+  {
+    return bs_[i * n_ + j];
+  }
+
+  // 0 <= i <= k - 1
+  // 0 <= p <= i - 1
+  const signal<problem_network_t>& c( uint32_t i, uint32_t p ) const
+  {
+    return cs_[( ( ( i - 1 ) * i ) / 2 ) + p];
+  }
+
+  // 0 <= i <= k - 1
+  // 0 <= j <= n + i - 1
+  const signal<problem_network_t>& b_or_c( uint32_t i, uint32_t j ) const
+  {
+    return j < n_ ? b( i, j ) : c( i, j - n_ );
+  }
+
+  // 0 <= l <= m - 1
+  // 0 <= i <= k - 1
+  const signal<problem_network_t>& f( uint32_t l, uint32_t i ) const
+  {
+    return fs_[l * k_ + i];
+  }
+
+  // 0 <= j <= n - 1
+  // 0 <= i <= k - 1
+  signal<problem_network_t>& psi( uint32_t j, uint32_t i )
+  {
+    return psis_[i * n_ + j];
+  }
+
+  // 0 <= j <= n - 1
+  // 0 <= i <= k - 1
+  signal<problem_network_t>& phi( uint32_t j, uint32_t i )
+  {
+    return phis_[i * n_ + j];
+  }
+
+private:
+  std::vector<std::vector<bool>> const& linear_matrix_;
+  uint32_t k_;
+  uint32_t n_;
+  uint32_t m_;
+
+  std::vector<signal<problem_network_t>> bs_;
+  std::vector<signal<problem_network_t>> cs_;
+  std::vector<signal<problem_network_t>> fs_;
+  std::vector<signal<problem_network_t>> psis_;
+  std::vector<signal<problem_network_t>> phis_;
+
+  problem_network_t pntk_;
+  std::vector<std::vector<uint32_t>> const& ignore_inputs_;
+  std::vector<std::pair<uint32_t, uint32_t>> const& trivial_pos_;
+  exact_linear_synthesis_params const& ps_;
+};
+
+template<class Ntk, bill::solvers Solver>
+struct exact_linear_synthesis_impl
+{
+  exact_linear_synthesis_impl( std::vector<std::vector<bool>> const& linear_matrix, exact_linear_synthesis_params const& ps, exact_linear_synthesis_stats& st )
+      : ps_( ps ),
+        st_( st )
+  {
+    if ( ps_.very_verbose )
+    {
+      fmt::print( "[i] input matrix =\n" );
+      debug_matrix( linear_matrix );
+    }
+
+    /* check whether ignore inputs matches matrix size */
+    if ( !ps_.ignore_inputs.empty() && ps_.ignore_inputs.size() != linear_matrix.size() )
+    {
+      fmt::print( "[e] size of ignored inputs vector must match number of rows in linear matrix" );
+      std::abort();
+    }
+
+    /* check matrix for trivial entries */
+    for ( auto j = 0u; j < linear_matrix.size(); ++j )
+    {
+      const auto& row = linear_matrix[j];
+      n_ = static_cast<uint32_t>( row.size() );
+
+      auto cnt = 0u;
+      auto idx = 0u;
+      for ( auto i = 0u; i < row.size(); ++i )
+      {
+        if ( row[i] )
+        {
+          idx = i;
+          if ( ++cnt == 2u )
+          {
+            break;
+          }
+        }
+      }
+      if ( cnt == 0u )
+      {
+        /* constant 0 is encoded as input n */
+        trivial_pos_.emplace_back( j, n_ );
+      }
+      else if ( cnt == 1u )
+      {
+        trivial_pos_.emplace_back( j, idx );
+      }
+      else
+      {
+        linear_matrix_.push_back( row );
+        if ( !ps_.ignore_inputs.empty() )
+        {
+          ignore_inputs_.push_back( ps_.ignore_inputs[j] );
+        }
+      }
+    }
+
+    m_ = static_cast<uint32_t>( linear_matrix_.size() );
+
+    if ( ps_.very_verbose )
+    {
+      fmt::print( "[i] problem matrix =\n" );
+      debug_matrix( linear_matrix_ );
+      fmt::print( "\n[i] trivial POs =\n" );
+      for ( auto const& [j, i] : trivial_pos_ )
+      {
+        if ( i == n_ )
+        {
+          fmt::print( "f{} = 0\n", j );
+        }
+        else
+        {
+          fmt::print( "f{} = x{}\n", j, i );
+        }
+      }
+      if ( !ignore_inputs_.empty() )
+      {
+        fmt::print( "\n[i] ignored inputs =\n" );
+        for ( auto j = 0u; j < ignore_inputs_.size(); ++j )
+        {
+          fmt::print( "for f{} ignore {{{}}}\n", j, fmt::join( ignore_inputs_[j], ", " ) );
+        }
+      }
+    }
+  }
+
+  std::optional<Ntk> run()
+  {
+    if ( m_ == 0u )
+    {
+      Ntk ntk;
+
+      std::vector<signal<Ntk>> nodes( n_ );
+      std::generate( nodes.begin(), nodes.end(), [&]() { return ntk.create_pi(); } );
+
+      for ( auto po : trivial_pos_ )
+      {
+        ntk.create_po( po.second == n_ ? ntk.get_constant( false ) : nodes[po.second] );
+      }
+
+      return ntk;
+    }
+
+    return ps_.upper_bound ? run_decreasing() : run_increasing();
+  }
+
+private:
+  std::optional<Ntk> run_increasing()
+  {
+    auto k_ = m_;
+    while ( true )
+    {
+      if ( ps_.verbose )
+      {
+        fmt::print( "[i] try to find a solution with {} steps, solving time so far = {:.2f} secs\n", k_, to_seconds( st_.time_solving ) );
+      }
+
+      exact_linear_synthesis_problem_network<Solver> pntk( k_, linear_matrix_, ignore_inputs_, trivial_pos_, ps_ );
+      const auto res = call_with_stopwatch( st_.time_solving, [&]() { return pntk.solve(); } );
+      if ( res && *res )
+      {
+        if ( ps_.very_verbose )
+        {
+          pntk.debug_solution();
+        }
+        return pntk.template extract_solution<Ntk>();
+      }
+      ++k_;
+    }
+  }
+
+  std::optional<Ntk> run_decreasing()
+  {
+    std::optional<Ntk> best{};
+    auto k_ = *ps_.upper_bound;
+    while ( true )
+    {
+      if ( ps_.verbose )
+      {
+        fmt::print( "[i] try to find a solution with {} steps, solving time so far = {:.2f} secs\n", k_, to_seconds( st_.time_solving ) );
+      }
+      exact_linear_synthesis_problem_network<Solver> pntk( k_, linear_matrix_, ignore_inputs_, trivial_pos_, ps_ );
+      const auto res = call_with_stopwatch( st_.time_solving, [&]() { return pntk.solve(); } );
+      if ( res && *res )
+      {
+        if ( ps_.very_verbose )
+        {
+          pntk.debug_solution();
+        }
+        best = pntk.template extract_solution<Ntk>();
+        --k_;
+      }
+      else /* if unsat or timeout */
+      {
+        return best;
+      }
+    }
+  }
+
+private:
+  void debug_matrix( std::vector<std::vector<bool>> const& matrix ) const
+  {
+    for ( auto const& row : matrix )
+    {
+      for ( auto b : row )
+      {
+        fmt::print( "{}", b ? '1' : '0' );
+      }
+      fmt::print( "\n" );
+    }
+  }
+
+private:
+  uint32_t n_{};
+  uint32_t m_{ 0u };
+  std::vector<std::vector<bool>> linear_matrix_;
+  std::vector<std::pair<uint32_t, uint32_t>> trivial_pos_;
+  std::vector<std::vector<uint32_t>> ignore_inputs_;
+  exact_linear_synthesis_params const& ps_;
+  exact_linear_synthesis_stats& st_;
+};
+
+} // namespace detail
+
+/*! \brief Extracts linear matrix from XOR-based XAG
+ *
+ * This algorithm can be used to extract the linear matrix represented by an
+ * XAG that only contains XOR gates and no inverters at the outputs.  The matrix
+ * can be passed as an argument to `exact_linear_synthesis`.
+ */
+template<class Ntk>
+std::vector<std::vector<bool>> get_linear_matrix( Ntk const& ntk )
+{
+  static_assert( std::is_same_v<typename Ntk::base_type, xag_network>, "Ntk is not XAG-like" );
+
+  detail::linear_matrix_simulator sim( ntk.num_pis() );
+  return simulate<std::vector<bool>>( detail::linear_xag{ ntk }, sim );
+}
+
+/*! \brief Optimum linear circuit synthesis (based on SAT)
+ *
+ * This algorithm creates an XAG that is only composed of XOR gates.  It is
+ * given as input a linear matrix, represented as vector of bool-vectors.  The
+ * size of the outer vector corresponds to the number of outputs, the size of
+ * each inner vector must be the same and corresponds to the number of inputs.
+ *
+ * Reference: [C. Fuhs and P. Schneider-Kamp, SAT (2010), page 71-84]
+ */
+template<class Ntk = xag_network, bill::solvers Solver = bill::solvers::glucose_41>
+std::optional<Ntk> exact_linear_synthesis( std::vector<std::vector<bool>> const& linear_matrix, exact_linear_synthesis_params const& ps = {}, exact_linear_synthesis_stats* pst = nullptr )
+{
+  static_assert( std::is_same_v<typename Ntk::base_type, xag_network>, "Ntk is not XAG-like" );
+
+  exact_linear_synthesis_stats st;
+  const auto xag = detail::exact_linear_synthesis_impl<Ntk, Solver>{ linear_matrix, ps, st }.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+  if ( pst )
+  {
+    *pst = st;
+  }
+  return xag;
+}
+
+/*! \brief Optimum linear circuit resynthesis (based on SAT)
+ *
+ * This algorithm extracts the linear matrix from an XAG that only contains of
+ * XOR gates and no inversions and returns a new XAG that has the optimum number
+ * of XOR gates to represent the same function.
+ *
+ * Reference: [C. Fuhs and P. Schneider-Kamp, SAT (2010), page 71-84]
+ */
+template<class Ntk = xag_network, bill::solvers Solver = bill::solvers::glucose_41>
+std::optional<Ntk> exact_linear_resynthesis( Ntk const& ntk, exact_linear_synthesis_params const& ps = {}, exact_linear_synthesis_stats* pst = nullptr )
+{
+  static_assert( std::is_same_v<typename Ntk::base_type, xag_network>, "Ntk is not XAG-like" );
+
+  const auto linear_matrix = get_linear_matrix( ntk );
+  return exact_linear_synthesis<Ntk, Solver>( linear_matrix, ps, pst );
+}
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/lut_mapper.hpp b/include/mockturtle/algorithms/lut_mapper.hpp
new file mode 100644
index 0000000..5765904
--- /dev/null
+++ b/include/mockturtle/algorithms/lut_mapper.hpp
@@ -0,0 +1,3015 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file lut_mapper.hpp
+  \brief LUT mapper
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <fstream>
+#include <iostream>
+#include <limits>
+#include <queue>
+#include <sstream>
+#include <string>
+
+#include <fmt/format.h>
+#include <kitty/cube.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/esop.hpp>
+#include <kitty/isop.hpp>
+#include <kitty/operations.hpp>
+
+#include "../networks/klut.hpp"
+#include "../utils/cost_functions.hpp"
+#include "../utils/cuts.hpp"
+#include "../utils/node_map.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../utils/truth_table_cache.hpp"
+#include "../views/choice_view.hpp"
+#include "../views/mapping_view.hpp"
+#include "../views/mffc_view.hpp"
+#include "../views/topo_view.hpp"
+#include "cleanup.hpp"
+#include "collapse_mapped.hpp"
+#include "cut_enumeration.hpp"
+#include "exorcism.hpp"
+#include "simulation.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for map.
+ *
+ * The data structure `map_params` holds configurable parameters
+ * with default arguments for `map`.
+ */
+struct lut_map_params
+{
+  lut_map_params()
+  {
+    cut_enumeration_ps.cut_size = 6u;
+    cut_enumeration_ps.cut_limit = 8u;
+    cut_enumeration_ps.minimize_truth_table = true;
+  }
+
+  /*! \brief Parameters for cut enumeration
+   *
+   * The default cut limit is 8. The maximum value
+   * is 16. The maxiumum cut size is 16. By default,
+   * truth table minimization is performed.
+   */
+  cut_enumeration_params cut_enumeration_ps{};
+
+  /*! \brief Do area-oriented mapping. */
+  bool area_oriented_mapping{ false };
+
+  /*! \brief Required depth for depth relaxation. */
+  uint32_t required_delay{ 0u };
+
+  /*! \brief Required depth relaxation ratio (%). */
+  uint32_t relax_required{ 0u };
+
+  /*! \brief Recompute cuts at each step. */
+  bool recompute_cuts{ true };
+
+  /*! \brief Number of rounds for area sharing optimization. */
+  uint32_t area_share_rounds{ 2u };
+
+  /*! \brief Number of rounds for area flow optimization. */
+  uint32_t area_flow_rounds{ 1u };
+
+  /*! \brief Number of rounds for exact area optimization. */
+  uint32_t ela_rounds{ 2u };
+
+  /*! \brief Use edge count reduction. */
+  bool edge_optimization{ true };
+
+  /*! \brief Try to expand the cuts. */
+  bool cut_expansion{ true };
+
+  /*! \brief Remove the cuts that are contained in others */
+  bool remove_dominated_cuts{ true };
+
+  /*! \brief Maps by collapsing MFFCs */
+  bool collapse_mffcs{ false };
+
+  /*! \brief Depth optimization by balancing ISOPs */
+  bool sop_balancing{ false };
+
+  /*! \brief Depth optimization by balancing ESOPs */
+  bool esop_balancing{ false };
+
+  /*! \brief Maximum number variables for cost function caching */
+  uint32_t cost_cache_vars{ 3u };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+};
+
+/*! \brief Statistics for mapper.
+ *
+ * The data structure `map_stats` provides data collected by running
+ * `map`.
+ */
+struct lut_map_stats
+{
+  /*! \brief Area result. */
+  uint32_t area{ 0 };
+  /*! \brief Worst delay result. */
+  uint32_t delay{ 0 };
+  /*! \brief Edge result. */
+  uint32_t edges{ 0 };
+
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Cut enumeration stats. */
+  cut_enumeration_stats cut_enumeration_st{};
+
+  /*! \brief Depth and size stats for each round. */
+  std::vector<std::string> round_stats{};
+
+  void report() const
+  {
+    for ( auto const& stat : round_stats )
+    {
+      std::cout << stat;
+    }
+    std::cout << fmt::format( "[i] Total runtime           = {:>5.2f} secs\n", to_seconds( time_total ) );
+  }
+};
+
+namespace detail
+{
+
+#pragma region cut set
+/* cut data */
+struct cut_enumeration_lut_cut
+{
+  uint32_t delay{ 0 };
+  uint32_t lut_area{ 0 };
+  uint32_t lut_delay{ 0 };
+  float area_flow{ 0 };
+  float edge_flow{ 0 };
+  bool ignore{ false };
+};
+
+enum class lut_cut_sort_type
+{
+  DELAY,
+  DELAY2,
+  AREA,
+  AREA2,
+  NONE
+};
+
+template<typename CutType, int MaxCuts>
+class lut_cut_set
+{
+public:
+  /*! \brief Standard constructor.
+   */
+  lut_cut_set()
+  {
+    clear();
+  }
+
+  /*! \brief Assignment operator.
+   */
+  lut_cut_set& operator=( lut_cut_set const& other )
+  {
+    if ( this != &other )
+    {
+      _pcend = _pend = _pcuts.begin();
+
+      auto it = other.begin();
+      while ( it != other.end() )
+      {
+        **_pend++ = **it++;
+        ++_pcend;
+      }
+    }
+
+    return *this;
+  }
+
+  /*! \brief Clears a cut set.
+   */
+  void clear()
+  {
+    _pcend = _pend = _pcuts.begin();
+    auto pit = _pcuts.begin();
+    for ( auto& c : _cuts )
+    {
+      *pit++ = &c;
+    }
+  }
+
+  /*! \brief Adds a cut to the end of the set.
+   *
+   * This function should only be called to create a set of cuts which is known
+   * to be sorted and irredundant (i.e., no cut in the set dominates another
+   * cut).
+   *
+   * \param begin Begin iterator to leaf indexes
+   * \param end End iterator (exclusive) to leaf indexes
+   * \return Reference to the added cut
+   */
+  template<typename Iterator>
+  CutType& add_cut( Iterator begin, Iterator end )
+  {
+    assert( _pend != _pcuts.end() );
+
+    auto& cut = **_pend++;
+    cut.set_leaves( begin, end );
+
+    ++_pcend;
+    return cut;
+  }
+
+  /*! \brief Checks whether cut is dominates by any cut in the set.
+   *
+   * \param cut Cut outside of the set
+   */
+  bool is_dominated( CutType const& cut ) const
+  {
+    return std::find_if( _pcuts.begin(), _pcend, [&cut]( auto const* other ) { return other->dominates( cut ); } ) != _pcend;
+  }
+
+  static bool sort_delay( CutType const& c1, CutType const& c2 )
+  {
+    constexpr auto eps{ 0.005f };
+    if ( !c1->data.ignore && c2->data.ignore )
+      return true;
+    if ( c1->data.ignore && !c2->data.ignore )
+      return false;
+    if ( c1->data.delay < c2->data.delay )
+      return true;
+    if ( c1->data.delay > c2->data.delay )
+      return false;
+    if ( c1.size() < c2.size() )
+      return true;
+    if ( c1.size() > c2.size() )
+      return false;
+    if ( c1->data.area_flow < c2->data.area_flow - eps )
+      return true;
+    if ( c1->data.area_flow > c2->data.area_flow + eps )
+      return false;
+    return c1->data.edge_flow < c2->data.edge_flow - eps;
+  }
+
+  static bool sort_delay2( CutType const& c1, CutType const& c2 )
+  {
+    constexpr auto eps{ 0.005f };
+    if ( !c1->data.ignore && c2->data.ignore )
+      return true;
+    if ( c1->data.ignore && !c2->data.ignore )
+      return false;
+    if ( c1->data.delay < c2->data.delay )
+      return true;
+    if ( c1->data.delay > c2->data.delay )
+      return false;
+    if ( c1->data.area_flow < c2->data.area_flow - eps )
+      return true;
+    if ( c1->data.area_flow > c2->data.area_flow + eps )
+      return false;
+    if ( c1->data.edge_flow < c2->data.edge_flow - eps )
+      return true;
+    if ( c1->data.edge_flow > c2->data.edge_flow + eps )
+      return false;
+    return c1.size() < c2.size();
+  }
+
+  static bool sort_area( CutType const& c1, CutType const& c2 )
+  {
+    constexpr auto eps{ 0.005f };
+    if ( !c1->data.ignore && c2->data.ignore )
+      return true;
+    if ( c1->data.ignore && !c2->data.ignore )
+      return false;
+    if ( c1->data.area_flow < c2->data.area_flow - eps )
+      return true;
+    if ( c1->data.area_flow > c2->data.area_flow + eps )
+      return false;
+    if ( c1->data.delay < c2->data.delay )
+      return true;
+    if ( c1->data.delay > c2->data.delay )
+      return false;
+    return c1.size() < c2.size();
+  }
+
+  static bool sort_area2( CutType const& c1, CutType const& c2 )
+  {
+    constexpr auto eps{ 0.005f };
+    if ( !c1->data.ignore && c2->data.ignore )
+      return true;
+    if ( c1->data.ignore && !c2->data.ignore )
+      return false;
+    if ( c1->data.area_flow < c2->data.area_flow - eps )
+      return true;
+    if ( c1->data.area_flow > c2->data.area_flow + eps )
+      return false;
+    if ( c1->data.edge_flow < c2->data.edge_flow - eps )
+      return true;
+    if ( c1->data.edge_flow > c2->data.edge_flow + eps )
+      return false;
+    if ( c1.size() < c2.size() )
+      return true;
+    if ( c1.size() > c2.size() )
+      return false;
+    return c1->data.delay < c2->data.delay;
+  }
+
+  /*! \brief Compare two cuts using sorting functions.
+   *
+   * This method compares two cuts using a sorting function.
+   *
+   * \param cut1 first cut.
+   * \param cut2 second cut.
+   * \param sort sorting function.
+   */
+  static bool compare( CutType const& cut1, CutType const& cut2, lut_cut_sort_type sort = lut_cut_sort_type::NONE )
+  {
+    if ( sort == lut_cut_sort_type::DELAY )
+    {
+      return sort_delay( cut1, cut2 );
+    }
+    else if ( sort == lut_cut_sort_type::DELAY2 )
+    {
+      return sort_delay2( cut1, cut2 );
+    }
+    else if ( sort == lut_cut_sort_type::AREA )
+    {
+      return sort_area( cut1, cut2 );
+    }
+    else if ( sort == lut_cut_sort_type::AREA2 )
+    {
+      return sort_area2( cut1, cut2 );
+    }
+    else
+    {
+      return false;
+    }
+  }
+
+  /*! \brief Inserts a cut into a set without checking dominance.
+   *
+   * This method will insert a cut into a set and maintain an order.  This
+   * method doesn't remove the cuts that are dominated by `cut`.
+   *
+   * If `cut` is dominated by any of the cuts in the set, it will still be
+   * inserted.  The caller is responsible to check whether `cut` is dominated
+   * before inserting it into the set.
+   *
+   * \param cut Cut to insert.
+   * \param sort Cut prioritization function.
+   */
+  void simple_insert( CutType const& cut, lut_cut_sort_type sort = lut_cut_sort_type::NONE )
+  {
+    /* insert cut in a sorted way */
+    typename std::array<CutType*, MaxCuts>::iterator ipos = _pcuts.begin();
+
+    if ( sort == lut_cut_sort_type::DELAY )
+    {
+      ipos = std::lower_bound( _pcuts.begin(), _pend, &cut, []( auto a, auto b ) { return sort_delay( *a, *b ); } );
+    }
+    else if ( sort == lut_cut_sort_type::DELAY2 )
+    {
+      ipos = std::lower_bound( _pcuts.begin(), _pend, &cut, []( auto a, auto b ) { return sort_delay2( *a, *b ); } );
+    }
+    else if ( sort == lut_cut_sort_type::AREA )
+    {
+      ipos = std::lower_bound( _pcuts.begin(), _pend, &cut, []( auto a, auto b ) { return sort_area( *a, *b ); } );
+    }
+    else if ( sort == lut_cut_sort_type::AREA2 )
+    {
+      ipos = std::lower_bound( _pcuts.begin(), _pend, &cut, []( auto a, auto b ) { return sort_area2( *a, *b ); } );
+    }
+    else /* NONE */
+    {
+      ipos == _pend;
+    }
+
+    /* too many cuts, we need to remove one */
+    if ( _pend == _pcuts.end() )
+    {
+      /* cut to be inserted is worse than all the others, return */
+      if ( ipos == _pend )
+      {
+        return;
+      }
+      else
+      {
+        /* remove last cut */
+        --_pend;
+        --_pcend;
+      }
+    }
+
+    /* copy cut */
+    auto& icut = *_pend;
+    icut->set_leaves( cut.begin(), cut.end() );
+    icut->data() = cut.data();
+
+    if ( ipos != _pend )
+    {
+      auto it = _pend;
+      while ( it > ipos )
+      {
+        std::swap( *it, *( it - 1 ) );
+        --it;
+      }
+    }
+
+    /* update iterators */
+    _pcend++;
+    _pend++;
+  }
+
+  /*! \brief Inserts a cut into a set.
+   *
+   * This method will insert a cut into a set and maintain an order.  Before the
+   * cut is inserted into the correct position, it will remove all cuts that are
+   * dominated by `cut`. Variable `skip0` tell to skip the dominance check on
+   * cut zero.
+   *
+   * If `cut` is dominated by any of the cuts in the set, it will still be
+   * inserted.  The caller is responsible to check whether `cut` is dominated
+   * before inserting it into the set.
+   *
+   * \param cut Cut to insert.
+   * \param skip0 Skip dominance check on cut zero.
+   * \param sort Cut prioritization function.
+   */
+  void insert( CutType const& cut, bool skip0 = false, lut_cut_sort_type sort = lut_cut_sort_type::NONE )
+  {
+    auto begin = _pcuts.begin();
+
+    if ( skip0 && _pend != _pcuts.begin() )
+      ++begin;
+
+    /* remove elements that are dominated by new cut */
+    _pcend = _pend = std::stable_partition( begin, _pend, [&cut]( auto const* other ) { return !cut.dominates( *other ); } );
+
+    /* insert cut in a sorted way */
+    simple_insert( cut, sort );
+  }
+
+  /*! \brief Replaces a cut of the set.
+   *
+   * This method replaces the cut at position `index` in the set by `cut`
+   * and maintains the cuts order. The function does not check whether
+   * index is in the valid range.
+   *
+   * \param index Index of the cut to replace.
+   * \param cut Cut to insert.
+   */
+  void replace( uint32_t index, CutType const& cut )
+  {
+    *_pcuts[index] = cut;
+  }
+
+  /*! \brief Begin iterator (constant).
+   *
+   * The iterator will point to a cut pointer.
+   */
+  auto begin() const { return _pcuts.begin(); }
+
+  /*! \brief End iterator (constant). */
+  auto end() const { return _pcend; }
+
+  /*! \brief Begin iterator (mutable).
+   *
+   * The iterator will point to a cut pointer.
+   */
+  auto begin() { return _pcuts.begin(); }
+
+  /*! \brief End iterator (mutable). */
+  auto end() { return _pend; }
+
+  /*! \brief Number of cuts in the set. */
+  auto size() const { return _pcend - _pcuts.begin(); }
+
+  /*! \brief Returns reference to cut at index.
+   *
+   * This function does not return the cut pointer but dereferences it and
+   * returns a reference.  The function does not check whether index is in the
+   * valid range.
+   *
+   * \param index Index
+   */
+  auto const& operator[]( uint32_t index ) const { return *_pcuts[index]; }
+
+  /*! \brief Returns the best cut, i.e., the first cut.
+   */
+  auto& best() const { return *_pcuts[0]; }
+
+  /*! \brief Updates the best cut.
+   *
+   * This method will set the cut at index `index` to be the best cut.  All
+   * cuts before `index` will be moved one position higher.
+   *
+   * \param index Index of new best cut
+   */
+  void update_best( uint32_t index )
+  {
+    auto* best = _pcuts[index];
+    for ( auto i = index; i > 0; --i )
+    {
+      _pcuts[i] = _pcuts[i - 1];
+    }
+    _pcuts[0] = best;
+  }
+
+  /*! \brief Resize the cut set, if it is too large.
+   *
+   * This method will resize the cut set to `size` only if the cut set has more
+   * than `size` elements.  Otherwise, the size will remain the same.
+   */
+  void limit( uint32_t size )
+  {
+    if ( std::distance( _pcuts.begin(), _pend ) > static_cast<long>( size ) )
+    {
+      _pcend = _pend = _pcuts.begin() + size;
+    }
+  }
+
+  /*! \brief Prints a cut set. */
+  friend std::ostream& operator<<( std::ostream& os, lut_cut_set const& set )
+  {
+    for ( auto const& c : set )
+    {
+      os << *c << "\n";
+    }
+    return os;
+  }
+
+private:
+  std::array<CutType, MaxCuts> _cuts;
+  std::array<CutType*, MaxCuts> _pcuts;
+  typename std::array<CutType*, MaxCuts>::const_iterator _pcend{ _pcuts.begin() };
+  typename std::array<CutType*, MaxCuts>::iterator _pend{ _pcuts.begin() };
+};
+#pragma endregion
+
+#pragma region LUT mapper
+struct node_lut
+{
+  /* required time at node output */
+  uint32_t required;
+  /* number of references in the cover */
+  uint32_t map_refs;
+  /* references estimation */
+  float est_refs;
+};
+
+template<class Ntk, bool StoreFunction, class LUTCostFn>
+class lut_map_impl
+{
+private:
+  /* special map for output drivers to perform some optimizations */
+  enum class driver_type : uint32_t
+  {
+    none = 0,
+    pos = 1,
+    neg = 2,
+    mixed = 3
+  };
+
+public:
+  static constexpr uint32_t max_cut_num = 32;
+  static constexpr uint32_t max_cut_size = 16;
+  static constexpr uint32_t max_cubes = 64;
+  static constexpr uint32_t max_sop_decomp_size = max_cut_size * ( max_cubes + 1 );
+  using cut_t = cut<max_cut_size, cut_data<StoreFunction, cut_enumeration_lut_cut>>;
+  using cut_set_t = lut_cut_set<cut_t, max_cut_num>;
+  using node = typename Ntk::node;
+  using cut_merge_t = typename std::array<cut_set_t*, Ntk::max_fanin_size + 1>;
+  using TT = kitty::dynamic_truth_table;
+  using tt_cache = truth_table_cache<TT>;
+  using cost_cache = std::unordered_map<uint32_t, std::pair<uint32_t, uint32_t>>;
+  using sop_t = std::vector<kitty::cube>;
+  using isop_cache = std::vector<sop_t>;
+  using cubes_queue_t = std::priority_queue<uint32_t, std::vector<uint32_t>, std::greater<uint32_t>>;
+  using lut_info = std::pair<kitty::dynamic_truth_table, std::vector<signal<klut_network>>>;
+
+public:
+  explicit lut_map_impl( Ntk& ntk, lut_map_params const& ps, lut_map_stats& st )
+      : ntk( ntk ),
+        ps( ps ),
+        st( st ),
+        node_match( ntk.size() ),
+        cuts( ntk.size() )
+  {
+    assert( ps.cut_enumeration_ps.cut_limit < max_cut_num && "cut_limit exceeds the compile-time limit for the maximum number of cuts" );
+
+    if constexpr ( StoreFunction )
+    {
+      TT zero( 0u ), proj( 1u );
+      kitty::create_nth_var( proj, 0u );
+
+      tmp_visited.reserve( 100 );
+      truth_tables.resize( 32768 );
+
+      truth_tables.insert( zero );
+      truth_tables.insert( proj );
+
+      /* reserve cost cache */
+      if constexpr ( !std::is_same<LUTCostFn, lut_unitary_cost>::value )
+      {
+        truth_tables_cost.reserve( 1000 );
+      }
+
+      /* reserve ISOP cache */
+      if ( ps.sop_balancing || ps.esop_balancing )
+      {
+        isops.reserve( 32768 );
+        isops.emplace_back();                       /* empty ISOP for constant */
+        isops.push_back( { kitty::cube{ 1, 1 } } ); /* ISOP for variable */
+      }
+    }
+  }
+
+  klut_network run()
+  {
+    stopwatch t( st.time_total );
+
+    /* compute and save topological order */
+    topo_order.reserve( ntk.size() );
+    topo_view<Ntk>( ntk ).foreach_node( [this]( auto n ) {
+      topo_order.push_back( n );
+    } );
+
+    perform_mapping();
+    return create_lut_network();
+  }
+
+  void run_inplace()
+  {
+    stopwatch t( st.time_total );
+
+    /* compute and save topological order */
+    topo_order.reserve( ntk.size() );
+    topo_view<Ntk>( ntk ).foreach_node( [this]( auto n ) {
+      topo_order.push_back( n );
+    } );
+
+    if ( ps.collapse_mffcs )
+    {
+      compute_mffcs_mapping();
+      return;
+    }
+
+    perform_mapping();
+    derive_mapping();
+  }
+
+private:
+  void perform_mapping()
+  {
+    /* define area sorting function */
+    lut_cut_sort_type area_sort = ( ps.area_oriented_mapping && !ps.edge_optimization ) ? lut_cut_sort_type::AREA : lut_cut_sort_type::AREA2;
+
+    /* init the data structure */
+    init_nodes();
+    init_cuts();
+
+    /* compute mapping for depth or area */
+    if ( !ps.area_oriented_mapping )
+    {
+      compute_required_time();
+
+      if ( ps.recompute_cuts )
+      {
+        compute_mapping<false, false>( lut_cut_sort_type::DELAY, true, true );
+        compute_required_time();
+        compute_mapping<false, false>( lut_cut_sort_type::DELAY2, true, true );
+        compute_required_time();
+        compute_mapping<true, false>( area_sort, true, true );
+      }
+      else
+      {
+        compute_mapping<false, false>( lut_cut_sort_type::DELAY2, true, true );
+      }
+    }
+    else
+    {
+      compute_required_time();
+      compute_mapping<true, false>( area_sort, false, true );
+    }
+
+    if ( ps.cut_expansion )
+    {
+      compute_required_time();
+      expand_cuts<false>();
+    }
+
+    /* try backward area iterations */
+    uint32_t i = 0;
+    while ( i < ps.area_share_rounds )
+    {
+      compute_share_mapping( area_sort, i == 0 );
+
+      if ( ps.cut_expansion )
+      {
+        expand_cuts<false>();
+      }
+      ++i;
+    }
+
+    /* compute mapping using global area flow */
+    i = 0;
+    while ( i < ps.area_flow_rounds )
+    {
+      compute_required_time();
+      compute_mapping<true, false>( area_sort, false, ps.recompute_cuts );
+
+      if ( ps.cut_expansion )
+      {
+        compute_required_time();
+        expand_cuts<false>();
+      }
+      ++i;
+    }
+
+    /* compute mapping using exact area/edge */
+    i = 0;
+    while ( i < ps.ela_rounds )
+    {
+      compute_required_time();
+      compute_mapping<true, true>( area_sort, false, ps.recompute_cuts );
+
+      if ( ps.cut_expansion )
+      {
+        compute_required_time();
+        expand_cuts<true>();
+      }
+      ++i;
+    }
+  }
+
+  void init_nodes()
+  {
+    ntk.foreach_node( [this]( auto const& n ) {
+      const auto index = ntk.node_to_index( n );
+      auto& node_data = node_match[index];
+
+      node_data.map_refs = ntk.fanout_size( n );
+      node_data.est_refs = static_cast<float>( ntk.fanout_size( n ) );
+    } );
+  }
+
+  void init_cuts()
+  {
+    /* init constant cut */
+    add_zero_cut( ntk.node_to_index( ntk.get_node( ntk.get_constant( false ) ) ), false );
+    if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+      add_zero_cut( ntk.node_to_index( ntk.get_node( ntk.get_constant( true ) ) ), true );
+
+    /* init PIs cuts */
+    ntk.foreach_ci( [&]( auto const& n ) {
+      add_unit_cut( ntk.node_to_index( n ) );
+    } );
+  }
+
+  template<bool DO_AREA, bool ELA>
+  void compute_mapping( lut_cut_sort_type const sort, bool preprocess, bool recompute_cuts )
+  {
+    cuts_total = 0;
+    for ( auto const& n : topo_order )
+    {
+      if constexpr ( !ELA )
+      {
+        auto const index = ntk.node_to_index( n );
+        if ( !preprocess && iteration != 0 )
+        {
+          node_match[index].est_refs = ( 2.0 * node_match[index].est_refs + 1.0 * node_match[index].map_refs ) / 3.0;
+        }
+        else
+        {
+          node_match[index].est_refs = static_cast<float>( node_match[index].map_refs );
+        }
+      }
+
+      if ( ntk.is_constant( n ) || ntk.is_ci( n ) )
+      {
+        continue;
+      }
+
+      if ( recompute_cuts )
+      {
+        if constexpr ( Ntk::min_fanin_size == 2 && Ntk::max_fanin_size == 2 )
+        {
+          compute_best_cut2<DO_AREA, ELA>( n, sort, preprocess );
+        }
+        else
+        {
+          compute_best_cut<DO_AREA, ELA>( n, sort, preprocess );
+        }
+      }
+      else
+      {
+        /* update cost the function and move the best one first */
+        update_cut_data<DO_AREA, ELA>( n, sort );
+      }
+    }
+
+    set_mapping_refs<ELA>();
+
+    if constexpr ( DO_AREA )
+    {
+      ++area_iteration;
+    }
+
+    /* round stats */
+    {
+      std::stringstream stats;
+
+      if ( ( sort == lut_cut_sort_type::AREA || sort == lut_cut_sort_type::AREA2 ) && ELA )
+      {
+        stats << fmt::format( "[i] Area     : Delay = {:8d}  Area = {:8d}  Edges = {:8d}  Cuts = {:8d}\n", delay, area, edges, cuts_total );
+      }
+      else if ( sort == lut_cut_sort_type::AREA || sort == lut_cut_sort_type::AREA2 )
+      {
+        stats << fmt::format( "[i] AreaFlow : Delay = {:8d}  Area = {:8d}  Edges = {:8d}  Cuts = {:8d}\n", delay, area, edges, cuts_total );
+      }
+      else if ( sort == lut_cut_sort_type::DELAY2 )
+      {
+        stats << fmt::format( "[i] Delay2   : Delay = {:8d}  Area = {:8d}  Edges = {:8d}  Cuts = {:8d}\n", delay, area, edges, cuts_total );
+      }
+      else
+      {
+        stats << fmt::format( "[i] Delay    : Delay = {:8d}  Area = {:8d}  Edges = {:8d}  Cuts = {:8d}\n", delay, area, edges, cuts_total );
+      }
+      st.round_stats.push_back( stats.str() );
+    }
+  }
+
+  void compute_share_mapping( lut_cut_sort_type const sort, bool first )
+  {
+    /* reset required times and references except for POs */
+    compute_share_mapping_init( first );
+
+    for ( auto it = topo_order.rbegin(); it != topo_order.rend(); ++it )
+    {
+      auto const index = ntk.node_to_index( *it );
+
+      /* skip not used nodes */
+      if ( node_match[index].map_refs == 0 )
+        continue;
+
+      /* update cost the function and move the best one first */
+      update_cut_data_share( *it, sort );
+    }
+
+    /* propagate correct arrival times and compute stats */
+    propagate_arrival_times();
+
+    /* round stats */
+    {
+      st.round_stats.push_back( fmt::format( "[i] AreaSh   : Delay = {:8d}  Area = {:8d}  Edges = {:8d}  Cuts = {:8d}\n", delay, area, edges, cuts_total ) );
+    }
+  }
+
+  template<bool ELA>
+  void expand_cuts()
+  {
+    /* cut expansion is not yet compatible with truth table computation */
+    if constexpr ( StoreFunction )
+      return;
+
+    /* don't expand if cut recomputed cuts is off */
+    if ( !ps.recompute_cuts )
+      return;
+
+    for ( auto const& n : topo_order )
+    {
+      if ( ntk.is_constant( n ) || ntk.is_ci( n ) )
+      {
+        continue;
+      }
+
+      expand_cuts_node( n );
+    }
+
+    set_mapping_refs<ELA>();
+
+    std::string stats = fmt::format( "[i] Reduce   : Delay = {:8d}  Area = {:8d}  Edges = {:8d}  Cuts = {:8d}\n", delay, area, edges, cuts_total );
+    st.round_stats.push_back( stats );
+  }
+
+  template<bool ELA>
+  void set_mapping_refs()
+  {
+    if constexpr ( !ELA )
+    {
+      for ( auto i = 0u; i < node_match.size(); ++i )
+      {
+        node_match[i].map_refs = 0u;
+      }
+    }
+
+    /* compute the current worst delay and update the mapping refs */
+    delay = 0;
+    ntk.foreach_co( [this]( auto s ) {
+      const auto index = ntk.node_to_index( ntk.get_node( s ) );
+
+      delay = std::max( delay, cuts[index][0]->data.delay );
+
+      if constexpr ( !ELA )
+      {
+        ++node_match[index].map_refs;
+      }
+    } );
+
+    /* compute current area and update mapping refs in top-down order */
+    area = 0;
+    edges = 0;
+    for ( auto it = topo_order.rbegin(); it != topo_order.rend(); ++it )
+    {
+      /* skip constants and PIs */
+      if ( ntk.is_constant( *it ) || ntk.is_ci( *it ) )
+      {
+        continue;
+      }
+
+      const auto index = ntk.node_to_index( *it );
+      auto& node_data = node_match[index];
+
+      /* continue if not referenced in the cover */
+      if ( node_match[index].map_refs == 0u )
+        continue;
+
+      auto& best_cut = cuts[index][0];
+
+      if constexpr ( !ELA )
+      {
+        for ( auto const leaf : best_cut )
+        {
+          node_match[leaf].map_refs++;
+        }
+      }
+      area += best_cut->data.lut_area;
+      edges += best_cut.size();
+    }
+
+    ++iteration;
+  }
+
+  void compute_required_time()
+  {
+    for ( auto i = 0u; i < node_match.size(); ++i )
+    {
+      node_match[i].required = UINT32_MAX >> 1;
+    }
+
+    /* return in case of area_oriented_mapping */
+    if ( iteration == 0 || ps.area_oriented_mapping )
+      return;
+
+    uint32_t required = delay;
+
+    /* relax delay constraints */
+    if ( ps.required_delay == 0.0f && ps.relax_required > 0.0f )
+    {
+      required *= ( 100.0 + ps.relax_required ) / 100.0;
+    }
+
+    if ( ps.required_delay != 0 )
+    {
+      /* Global target time constraint */
+      if ( ps.required_delay < delay )
+      {
+        if ( !ps.area_oriented_mapping && iteration == 1 )
+          std::cerr << fmt::format( "[i] MAP WARNING: cannot meet the target required time of {}", ps.required_delay ) << std::endl;
+      }
+      else
+      {
+        required = ps.required_delay;
+      }
+    }
+
+    /* set the required time at POs */
+    ntk.foreach_co( [&]( auto const& s ) {
+      const auto index = ntk.node_to_index( ntk.get_node( s ) );
+      node_match[index].required = required;
+    } );
+
+    /* propagate required time to the PIs */
+    for ( auto it = topo_order.rbegin(); it != topo_order.rend(); ++it )
+    {
+      if ( ntk.is_ci( *it ) || ntk.is_constant( *it ) )
+        continue;
+
+      const auto index = ntk.node_to_index( *it );
+
+      if ( node_match[index].map_refs == 0 )
+        continue;
+
+      /* in case of decomposition cost */
+      if constexpr ( StoreFunction )
+      {
+        if ( ps.sop_balancing || ps.esop_balancing )
+        {
+          compute_balancing_cost_required( index );
+          continue;
+        }
+      }
+
+      for ( auto leaf : cuts[index][0] )
+      {
+        node_match[leaf].required = std::min( node_match[leaf].required, node_match[index].required - cuts[index][0]->data.lut_delay );
+      }
+    }
+  }
+
+  void propagate_arrival_times()
+  {
+    area = 0;
+    edges = 0;
+    for ( auto const& n : topo_order )
+    {
+      auto index = ntk.node_to_index( n );
+
+      if ( ntk.is_ci( n ) || ntk.is_constant( n ) )
+      {
+        continue;
+      }
+
+      /* propagate arrival time */
+      uint32_t node_delay = 0;
+      auto& best_cut = cuts[index].best();
+
+      for ( auto leaf : best_cut )
+      {
+        const auto& best_leaf_cut = cuts[leaf][0];
+        node_delay = std::max( node_delay, best_leaf_cut->data.delay );
+      }
+
+      best_cut->data.delay = node_delay + best_cut->data.lut_delay;
+
+      /* continue if not referenced in the cover */
+      if ( node_match[index].map_refs == 0u )
+        continue;
+
+      /* update stats */
+      area += best_cut->data.lut_area;
+      edges += best_cut.size();
+    }
+
+    /* update worst delay */
+    delay = 0;
+    ntk.foreach_co( [this]( auto s ) {
+      const auto index = ntk.node_to_index( ntk.get_node( s ) );
+      delay = std::max( delay, cuts[index][0]->data.delay );
+    } );
+  }
+
+  void compute_share_mapping_init( bool first )
+  {
+    /* reset the mapping references and the required time */
+    for ( auto i = 0u; i < node_match.size(); ++i )
+    {
+      node_match[i].required = UINT32_MAX >> 1;
+      if ( !first )
+        node_match[i].est_refs = ( 2.0 * node_match[i].est_refs + 1.0 * node_match[i].map_refs ) / 3.0;
+      else
+        node_match[i].est_refs = std::max( 1.0, ( 1.0 * node_match[i].est_refs + 2.0 * node_match[i].map_refs ) / 3.0 );
+      node_match[i].map_refs = 0;
+
+      /* update flows if in area-oriented mapping */
+      if ( ps.area_oriented_mapping )
+        compute_cut_data<false>( cuts[i].best(), ntk.index_to_node( i ), false );
+    }
+
+    uint32_t required = delay;
+    if ( ps.required_delay == 0.0f && ps.relax_required > 0.0f )
+    {
+      required *= ( 100.0 + ps.relax_required ) / 100.0;
+    }
+
+    if ( ps.required_delay != 0 )
+    {
+      /* Global target time constraint */
+      if ( ps.required_delay < delay )
+      {
+        if ( !ps.area_oriented_mapping && iteration == 1 )
+          std::cerr << fmt::format( "[i] MAP WARNING: cannot meet the target required time of {}", ps.required_delay ) << std::endl;
+      }
+      else
+      {
+        required = ps.required_delay;
+      }
+    }
+
+    /* set the required time at POs */
+    ntk.foreach_co( [&]( auto const& s ) {
+      const auto index = ntk.node_to_index( ntk.get_node( s ) );
+      node_match[index].required = required;
+      node_match[index].map_refs++;
+    } );
+  }
+
+  template<bool DO_AREA, bool ELA>
+  void compute_best_cut2( node const& n, lut_cut_sort_type const sort, bool preprocess )
+  {
+    auto index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+    cut_t best_cut;
+
+    /* compute cuts */
+    const auto fanin = 2;
+    uint32_t pairs{ 1 };
+    ntk.foreach_fanin( ntk.index_to_node( index ), [this, &pairs]( auto child, auto i ) {
+      lcuts[i] = &cuts[ntk.node_to_index( ntk.get_node( child ) )];
+      pairs *= static_cast<uint32_t>( lcuts[i]->size() );
+    } );
+    lcuts[2] = &cuts[index];
+    auto& rcuts = *lcuts[fanin];
+
+    if constexpr ( DO_AREA )
+    {
+      if ( iteration != 0 && node_data.map_refs > 0 )
+      {
+        cut_deref( rcuts[0] );
+      }
+    }
+
+    /* recompute the data of the best cut */
+    if ( iteration != 0 )
+    {
+      best_cut = rcuts[0];
+      compute_cut_data<ELA>( best_cut, n, true );
+    }
+
+    /* clear cuts */
+    rcuts.clear();
+
+    /* insert the previous best cut */
+    if ( iteration != 0 && !preprocess )
+    {
+      rcuts.simple_insert( best_cut, sort );
+    }
+
+    cut_t new_cut;
+    std::vector<cut_t const*> vcuts( fanin );
+
+    for ( auto const& c1 : *lcuts[0] )
+    {
+      for ( auto const& c2 : *lcuts[1] )
+      {
+        if ( !c1->merge( *c2, new_cut, ps.cut_enumeration_ps.cut_size ) )
+        {
+          continue;
+        }
+
+        if ( ps.remove_dominated_cuts && rcuts.is_dominated( new_cut ) )
+        {
+          continue;
+        }
+
+        if constexpr ( StoreFunction )
+        {
+          vcuts[0] = c1;
+          vcuts[1] = c2;
+          new_cut->func_id = compute_truth_table( index, vcuts, new_cut );
+        }
+
+        compute_cut_data<ELA>( new_cut, ntk.index_to_node( index ), true );
+
+        /* check required time */
+        if constexpr ( DO_AREA )
+        {
+          if ( preprocess || new_cut->data.delay <= node_data.required )
+          {
+            if ( ps.remove_dominated_cuts )
+              rcuts.insert( new_cut, false, sort );
+            else
+              rcuts.simple_insert( new_cut, sort );
+          }
+        }
+        else
+        {
+          if ( ps.remove_dominated_cuts )
+            rcuts.insert( new_cut, false, sort );
+          else
+            rcuts.simple_insert( new_cut, sort );
+        }
+      }
+    }
+
+    cuts_total += rcuts.size();
+
+    /* limit the maximum number of cuts */
+    rcuts.limit( ps.cut_enumeration_ps.cut_limit );
+
+    /* replace the new best cut with previous one */
+    if ( preprocess && rcuts[0]->data.delay > node_data.required )
+      rcuts.replace( 0, best_cut );
+
+    /* add trivial cut */
+    if ( rcuts.size() > 1 || ( *rcuts.begin() )->size() > 1 )
+    {
+      add_unit_cut( index );
+    }
+
+    if constexpr ( DO_AREA )
+    {
+      if ( iteration != 0 && node_data.map_refs > 0 )
+      {
+        cut_ref( rcuts[0] );
+      }
+    }
+  }
+
+  template<bool DO_AREA, bool ELA>
+  void compute_best_cut( node const& n, lut_cut_sort_type const sort, bool preprocess )
+  {
+    auto index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+    cut_t best_cut;
+
+    /* compute cuts */
+    uint32_t pairs{ 1 };
+    std::vector<uint32_t> cut_sizes;
+    ntk.foreach_fanin( ntk.index_to_node( index ), [this, &pairs, &cut_sizes]( auto child, auto i ) {
+      lcuts[i] = &cuts[ntk.node_to_index( ntk.get_node( child ) )];
+      cut_sizes.push_back( static_cast<uint32_t>( lcuts[i]->size() ) );
+      pairs *= cut_sizes.back();
+    } );
+    const auto fanin = cut_sizes.size();
+    lcuts[fanin] = &cuts[index];
+    auto& rcuts = *lcuts[fanin];
+
+    if constexpr ( DO_AREA )
+    {
+      if ( iteration != 0 && node_data.map_refs > 0 )
+      {
+        cut_deref( rcuts[0] );
+      }
+    }
+
+    /* recompute the data of the best cut */
+    if ( iteration != 0 )
+    {
+      best_cut = rcuts[0];
+      compute_cut_data<ELA>( best_cut, n, true );
+    }
+
+    /* clear cuts */
+    rcuts.clear();
+
+    /* insert the previous best cut */
+    if ( iteration != 0 && !preprocess )
+    {
+      rcuts.simple_insert( best_cut, sort );
+    }
+
+    if ( fanin > 1 && fanin <= ps.cut_enumeration_ps.fanin_limit )
+    {
+      cut_t new_cut, tmp_cut;
+
+      std::vector<cut_t const*> vcuts( fanin );
+
+      foreach_mixed_radix_tuple( cut_sizes.begin(), cut_sizes.end(), [&]( auto begin, auto end ) {
+        auto it = vcuts.begin();
+        auto i = 0u;
+        while ( begin != end )
+        {
+          *it++ = &( ( *lcuts[i++] )[*begin++] );
+        }
+
+        if ( !vcuts[0]->merge( *vcuts[1], new_cut, ps.cut_enumeration_ps.cut_size ) )
+        {
+          return true; /* continue */
+        }
+
+        for ( i = 2; i < fanin; ++i )
+        {
+          tmp_cut = new_cut;
+          if ( !vcuts[i]->merge( tmp_cut, new_cut, ps.cut_enumeration_ps.cut_size ) )
+          {
+            return true; /* continue */
+          }
+        }
+
+        if ( ps.remove_dominated_cuts && rcuts.is_dominated( new_cut ) )
+        {
+          return true; /* continue */
+        }
+
+        if constexpr ( StoreFunction )
+        {
+          new_cut->func_id = compute_truth_table( index, vcuts, new_cut );
+        }
+
+        compute_cut_data<ELA>( new_cut, index, true );
+
+        /* check required time */
+        if constexpr ( DO_AREA )
+        {
+          if ( preprocess || new_cut->data.delay <= node_data.required )
+          {
+            if ( ps.remove_dominated_cuts )
+              rcuts.insert( new_cut, false, sort );
+            else
+              rcuts.simple_insert( new_cut, sort );
+          }
+        }
+        else
+        {
+          if ( ps.remove_dominated_cuts )
+            rcuts.insert( new_cut, false, sort );
+          else
+            rcuts.simple_insert( new_cut, sort );
+        }
+
+        return true;
+      } );
+
+      /* limit the maximum number of cuts */
+      rcuts.limit( ps.cut_enumeration_ps.cut_limit );
+    }
+    else if ( fanin == 1 )
+    {
+      for ( auto const& cut : *lcuts[0] )
+      {
+        cut_t new_cut = *cut;
+
+        if constexpr ( StoreFunction )
+        {
+          new_cut->func_id = compute_truth_table( index, { cut }, new_cut );
+        }
+
+        compute_cut_data<ELA>( new_cut, index, true );
+
+        if constexpr ( DO_AREA )
+        {
+          if ( preprocess || new_cut->data.delay <= node_data.required )
+          {
+            if ( ps.remove_dominated_cuts )
+              rcuts.insert( new_cut, false, sort );
+            else
+              rcuts.simple_insert( new_cut, sort );
+          }
+        }
+        else
+        {
+          if ( ps.remove_dominated_cuts )
+            rcuts.insert( new_cut, false, sort );
+          else
+            rcuts.simple_insert( new_cut, sort );
+        }
+      }
+
+      /* limit the maximum number of cuts */
+      rcuts.limit( ps.cut_enumeration_ps.cut_limit );
+    }
+
+    cuts_total += rcuts.size();
+
+    /* replace the new best cut with previous one */
+    if ( preprocess && rcuts[0]->data.delay > node_data.required )
+      rcuts.replace( 0, best_cut );
+
+    add_unit_cut( index );
+
+    if constexpr ( DO_AREA )
+    {
+      if ( iteration != 0 && node_data.map_refs > 0 )
+      {
+        cut_ref( rcuts[0] );
+      }
+    }
+  }
+
+  template<bool DO_AREA, bool ELA>
+  void update_cut_data( node const& n, lut_cut_sort_type const sort )
+  {
+    auto index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+    auto& node_cut_set = cuts[index];
+    uint32_t best_cut_index = 0;
+    uint32_t cut_index = 0;
+
+    cut_t const* best_cut = &node_cut_set.best();
+
+    if constexpr ( DO_AREA )
+    {
+      if ( iteration != 0 && node_data.map_refs > 0 )
+      {
+        cut_deref( *best_cut );
+      }
+    }
+
+    /* recompute the data for all the cuts and pick the best */
+    for ( cut_t* cut : node_cut_set )
+    {
+      /* skip trivial cut */
+      if ( cut->size() == 1 && *cut->begin() == index )
+      {
+        ++cut_index;
+        continue;
+      }
+
+      compute_cut_data<ELA>( *cut, n, false );
+
+      /* update best */
+      if constexpr ( DO_AREA )
+      {
+        if ( ( *cut )->data.delay <= node_data.required )
+        {
+          if ( node_cut_set.compare( *cut, *best_cut, sort ) )
+          {
+            best_cut = cut;
+            best_cut_index = cut_index;
+          }
+        }
+      }
+      else
+      {
+        if ( node_cut_set.compare( *cut, *best_cut, sort ) )
+        {
+          best_cut = cut;
+          best_cut_index = cut_index;
+        }
+      }
+
+      ++cut_index;
+    }
+
+    if constexpr ( DO_AREA || ELA )
+    {
+      if ( iteration != 0 && node_data.map_refs > 0 )
+      {
+        cut_ref( *best_cut );
+      }
+    }
+
+    /* update the best cut */
+    node_cut_set.update_best( best_cut_index );
+  }
+
+  void update_cut_data_share( node const& n, lut_cut_sort_type const sort )
+  {
+    auto index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+    auto& node_cut_set = cuts[index];
+    uint32_t best_cut_index = 0;
+    uint32_t cut_index = 0;
+
+    cut_t const* best_cut = &node_cut_set.best();
+
+    /* recompute the data for all the cuts and pick the best */
+    for ( cut_t* cut : node_cut_set )
+    {
+      /* skip trivial cut */
+      if ( cut->size() == 1 && *cut->begin() == index )
+      {
+        ++cut_index;
+        continue;
+      }
+
+      compute_cut_data_share( *cut );
+
+      /* update best */
+      if ( ( *cut )->data.delay <= node_data.required )
+      {
+        if ( node_cut_set.compare( *cut, *best_cut, sort ) )
+        {
+          best_cut = cut;
+          best_cut_index = cut_index;
+        }
+      }
+
+      ++cut_index;
+    }
+
+    /* propagate required times backward and reference the leaves */
+    for ( auto leaf : *best_cut )
+    {
+      node_match[leaf].required = std::min( node_match[leaf].required, node_data.required - ( *best_cut )->data.lut_delay );
+      node_match[leaf].map_refs++;
+    }
+
+    /* update the best cut */
+    node_cut_set.update_best( best_cut_index );
+  }
+
+  void expand_cuts_node( node const& n )
+  {
+    auto index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+    cut_t best_cut = cuts[index][0];
+
+    if ( node_data.map_refs == 0 )
+      return;
+
+    /* update delay */
+    uint32_t delay_update = 0;
+    for ( auto const leaf : best_cut )
+    {
+      delay_update = std::max( delay_update, cuts[leaf][0]->data.delay + best_cut->data.lut_delay );
+    }
+    best_cut->data.delay = delay_update;
+
+    auto const area_before = cut_deref( best_cut );
+
+    uint32_t cost_before = 0;
+
+    std::vector<uint32_t> leaves;
+
+    /* mark volume */
+    ntk.incr_trav_id();
+    for ( auto const leaf : best_cut )
+    {
+      ntk.set_visited( ntk.index_to_node( leaf ), ntk.trav_id() );
+      leaves.push_back( leaf );
+
+      /* MFFC leaves */
+      if ( node_match[leaf].map_refs == 0 )
+        ++cost_before;
+    }
+    mark_cut_volume_rec( n );
+
+    /* improve cut */
+    while ( improve_cut( leaves ) )
+      ;
+
+    /* measure improvement */
+    uint32_t cost_after = 0;
+    for ( auto const leaf : leaves )
+    {
+      /* MFFC leaves */
+      if ( node_match[leaf].map_refs == 0 )
+        ++cost_after;
+    }
+
+    assert( cost_after <= cost_before );
+
+    /* create the new cut */
+    cut_t new_cut;
+    new_cut.set_leaves( leaves.begin(), leaves.end() );
+    new_cut->data = best_cut->data;
+
+    uint32_t delay_after = 0;
+    for ( auto const leaf : leaves )
+    {
+      delay_after = std::max( delay_after, cuts[leaf][0]->data.delay + new_cut->data.lut_delay );
+    }
+    new_cut->data.delay = delay_after;
+
+    auto const area_after = cut_ref( new_cut );
+
+    /* new cut is better */
+    if ( area_after <= area_before && new_cut->data.delay <= node_data.required )
+    {
+      cuts[index].replace( 0, new_cut );
+    }
+    else
+    {
+      /* restore */
+      cut_deref( new_cut );
+      cut_ref( best_cut );
+    }
+  }
+
+  bool improve_cut( std::vector<uint32_t>& leaves )
+  {
+    if ( improve_cut_expand0( leaves ) )
+      return true;
+
+    if ( leaves.size() < ps.cut_enumeration_ps.cut_size && improve_cut_expand1( leaves ) )
+      return true;
+
+    assert( leaves.size() <= ps.cut_enumeration_ps.cut_size );
+    return false;
+  }
+
+  bool improve_cut_expand0( std::vector<uint32_t>& leaves )
+  {
+    for ( auto it = leaves.begin(); it != leaves.end(); ++it )
+    {
+      if ( ntk.is_ci( *it ) )
+        continue;
+
+      /* test if expansion would increase the number of leaves */
+      int marked = 0;
+      ntk.foreach_fanin( ntk.index_to_node( *it ), [&]( auto const& f ) {
+        if ( !ntk.is_constant( ntk.get_node( f ) ) && ntk.visited( ntk.get_node( f ) ) != ntk.trav_id() )
+          ++marked;
+      } );
+
+      if ( marked > 1 )
+        continue;
+
+      /* check that the cost does not increase */
+      marked = 0;
+      if ( node_match[*it].map_refs == 0 )
+        --marked;
+
+      ntk.foreach_fanin( ntk.index_to_node( *it ), [&]( auto const& f ) {
+        if ( ntk.is_constant( ntk.get_node( f ) ) )
+          return;
+        auto const index = ntk.node_to_index( ntk.get_node( f ) );
+        if ( ntk.visited( ntk.get_node( f ) ) != ntk.trav_id() && node_match[index].map_refs == 0 )
+          ++marked;
+      } );
+
+      /* not referenced leaves don't increase from the transformation */
+      if ( marked <= 0 )
+      {
+        /* update leaves */
+        uint32_t n = *it;
+        leaves.erase( it );
+        ntk.foreach_fanin( n, [&]( auto const& f ) {
+          auto const index = ntk.node_to_index( ntk.get_node( f ) );
+          if ( !ntk.is_constant( ntk.get_node( f ) ) && ntk.visited( ntk.get_node( f ) ) != ntk.trav_id() )
+          {
+            leaves.push_back( index );
+            ntk.set_visited( ntk.get_node( f ), ntk.trav_id() );
+          }
+        } );
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  bool improve_cut_expand1( std::vector<uint32_t>& leaves )
+  {
+    for ( auto it = leaves.begin(); it != leaves.end(); ++it )
+    {
+      if ( ntk.is_ci( *it ) )
+        continue;
+
+      /* test if expansion would increase the number of leaves by more than 1*/
+      int marked = 0;
+      ntk.foreach_fanin( ntk.index_to_node( *it ), [&]( auto const& f ) {
+        if ( !ntk.is_constant( ntk.get_node( f ) ) && ntk.visited( ntk.get_node( f ) ) != ntk.trav_id() )
+          ++marked;
+      } );
+
+      if ( marked > 2 )
+        continue;
+
+      /* check that the cost reduces */
+      marked = 0;
+      if ( node_match[*it].map_refs == 0 )
+        --marked;
+
+      ntk.foreach_fanin( ntk.index_to_node( *it ), [&]( auto const& f ) {
+        if ( ntk.is_constant( ntk.get_node( f ) ) )
+          return;
+        auto const index = ntk.node_to_index( ntk.get_node( f ) );
+        if ( ntk.visited( ntk.get_node( f ) ) != ntk.trav_id() && node_match[index].map_refs == 0 )
+          ++marked;
+      } );
+
+      /* not referenced leaves should be reduced by the transformation */
+      if ( marked < 0 )
+      {
+        /* update leaves */
+        uint32_t n = *it;
+        leaves.erase( it );
+        ntk.foreach_fanin( n, [&]( auto const& f ) {
+          auto const index = ntk.node_to_index( ntk.get_node( f ) );
+          if ( !ntk.is_constant( ntk.get_node( f ) ) && ntk.visited( ntk.get_node( f ) ) != ntk.trav_id() )
+          {
+            leaves.push_back( index );
+            ntk.set_visited( ntk.get_node( f ), ntk.trav_id() );
+          }
+        } );
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  uint32_t cut_ref( cut_t const& cut )
+  {
+    uint32_t count = cut->data.lut_area;
+
+    for ( auto leaf : cut )
+    {
+      if ( ntk.is_ci( ntk.index_to_node( leaf ) ) || ntk.is_constant( ntk.index_to_node( leaf ) ) )
+      {
+        continue;
+      }
+
+      /* Recursive referencing if leaf was not referenced */
+      if ( node_match[leaf].map_refs++ == 0u )
+      {
+        count += cut_ref( cuts[leaf][0] );
+      }
+    }
+
+    return count;
+  }
+
+  uint32_t cut_deref( cut_t const& cut )
+  {
+    uint32_t count = cut->data.lut_area;
+
+    for ( auto leaf : cut )
+    {
+      if ( ntk.is_ci( ntk.index_to_node( leaf ) ) || ntk.is_constant( ntk.index_to_node( leaf ) ) )
+      {
+        continue;
+      }
+
+      /* Recursive referencing if leaf was not referenced */
+      if ( --node_match[leaf].map_refs == 0u )
+      {
+        count += cut_deref( cuts[leaf][0] );
+      }
+    }
+
+    return count;
+  }
+
+  uint32_t cut_measure_mffc( cut_t const& cut )
+  {
+    tmp_visited.clear();
+
+    uint32_t count = cut_ref_visit( cut );
+
+    /* dereference visited */
+    for ( auto const& s : tmp_visited )
+    {
+      --node_match[s].map_refs;
+    }
+
+    return count;
+  }
+
+  uint32_t cut_ref_visit( cut_t const& cut )
+  {
+    uint32_t count = cut->data.lut_area;
+
+    for ( auto leaf : cut )
+    {
+      if ( ntk.is_ci( ntk.index_to_node( leaf ) ) || ntk.is_constant( ntk.index_to_node( leaf ) ) )
+      {
+        continue;
+      }
+
+      /* add to visited */
+      tmp_visited.push_back( leaf );
+
+      /* Recursive referencing if leaf was not referenced */
+      if ( node_match[leaf].map_refs++ == 0u )
+      {
+        count += cut_ref_visit( cuts[leaf][0] );
+      }
+    }
+
+    return count;
+  }
+
+  uint32_t cut_edge_ref( cut_t const& cut )
+  {
+    uint32_t count = cut.size();
+
+    for ( auto leaf : cut )
+    {
+      if ( ntk.is_ci( ntk.index_to_node( leaf ) ) || ntk.is_constant( ntk.index_to_node( leaf ) ) )
+      {
+        continue;
+      }
+
+      /* Recursive referencing if leaf was not referenced */
+      if ( node_match[leaf].map_refs++ == 0u )
+      {
+        count += cut_edge_ref( cuts[leaf][0] );
+      }
+    }
+    return count;
+  }
+
+  uint32_t cut_edge_deref( cut_t const& cut )
+  {
+    uint32_t count = cut.size();
+
+    for ( auto leaf : cut )
+    {
+      if ( ntk.is_ci( ntk.index_to_node( leaf ) ) || ntk.is_constant( ntk.index_to_node( leaf ) ) )
+      {
+        continue;
+      }
+
+      /* Recursive referencing if leaf was not referenced */
+      if ( --node_match[leaf].map_refs == 0u )
+      {
+        count += cut_edge_deref( cuts[leaf][0] );
+      }
+    }
+    return count;
+  }
+
+  void mark_cut_volume_rec( node const& n )
+  {
+    if ( ntk.visited( n ) == ntk.trav_id() )
+      return;
+
+    ntk.set_visited( n, ntk.trav_id() );
+
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      mark_cut_volume_rec( ntk.get_node( f ) );
+    } );
+  }
+
+  /* compute positions of leave indices in cut `sub` (subset) with respect to
+   * leaves in cut `sup` (super set).
+   *
+   * Example:
+   *   compute_truth_table_support( {1, 3, 6}, {0, 1, 2, 3, 6, 7} ) = {1, 3, 4}
+   */
+  void compute_truth_table_support( cut_t const& sub, cut_t const& sup, TT& tt )
+  {
+    std::vector<uint8_t> support( sub.size() );
+
+    size_t j = 0;
+    auto itp = sup.begin();
+    for ( auto i : sub )
+    {
+      itp = std::find( itp, sup.end(), i );
+      support[j++] = static_cast<uint8_t>( std::distance( sup.begin(), itp ) );
+    }
+
+    /* swap variables in the truth table */
+    for ( int i = j - 1; i >= 0; --i )
+    {
+      assert( i <= support[i] );
+      kitty::swap_inplace( tt, i, support[i] );
+    }
+  }
+
+  template<bool ELA>
+  void compute_cut_data( cut_t& cut, node const& n, bool recompute_cut_cost )
+  {
+    uint32_t lut_area = 0;
+    uint32_t lut_delay = 0;
+
+    if ( recompute_cut_cost )
+    {
+      cut->data.ignore = false;
+      if constexpr ( StoreFunction )
+      {
+        if ( ps.sop_balancing || ps.esop_balancing )
+        {
+          compute_isop( cut );
+        }
+        else
+        {
+          if constexpr ( !std::is_same<LUTCostFn, lut_unitary_cost>::value )
+          {
+            if ( auto it = truth_tables_cost.find( cut->func_id ); it != truth_tables_cost.end() )
+            {
+              std::tie( lut_area, lut_delay ) = it->second;
+            }
+            else
+            {
+              auto cost = lut_cost( truth_tables[cut->func_id] );
+              if ( truth_tables[cut->func_id].num_vars() <= ps.cost_cache_vars )
+              {
+                /* cache it */
+                truth_tables_cost[cut->func_id] = cost;
+              }
+              lut_area = cost.first;
+              lut_delay = cost.second;
+            }
+          }
+          else
+          {
+            std::tie( lut_area, lut_delay ) = lut_cost( truth_tables[cut->func_id] );
+          }
+        }
+      }
+      else
+      {
+        std::tie( lut_area, lut_delay ) = lut_cost( cut.size() );
+      }
+    }
+    else
+    {
+      lut_area = cut->data.lut_area;
+      lut_delay = cut->data.lut_delay;
+
+      if constexpr ( StoreFunction )
+      {
+        if ( ps.sop_balancing || ps.esop_balancing )
+        {
+          /* reset fields to be recomputed */
+          cut->data.lut_area = 0;
+          cut->data.lut_delay = 0;
+        }
+      }
+    }
+
+    if constexpr ( ELA )
+    {
+      uint32_t delay{ 0 };
+      for ( auto leaf : cut )
+      {
+        const auto& best_leaf_cut = cuts[leaf][0];
+        delay = std::max( delay, best_leaf_cut->data.delay );
+      }
+
+      cut->data.delay = lut_delay + delay;
+      cut->data.lut_area = lut_area;
+      cut->data.lut_delay = lut_delay;
+      if ( ps.edge_optimization )
+      {
+        cut->data.area_flow = static_cast<float>( cut_ref( cut ) );
+        cut->data.edge_flow = static_cast<float>( cut_edge_deref( cut ) );
+      }
+      else
+      {
+        cut->data.area_flow = static_cast<float>( cut_measure_mffc( cut ) );
+        cut->data.edge_flow = 0;
+      }
+    }
+    else
+    {
+      uint32_t delay{ 0 };
+
+      float area_flow = static_cast<float>( lut_area );
+      float edge_flow = cut.size();
+
+      for ( auto leaf : cut )
+      {
+        const auto& best_leaf_cut = cuts[leaf][0];
+        delay = std::max( delay, best_leaf_cut->data.delay );
+        if ( node_match[leaf].map_refs > 0 && leaf != 0 )
+        {
+          area_flow += best_leaf_cut->data.area_flow / node_match[leaf].est_refs;
+          edge_flow += best_leaf_cut->data.edge_flow / node_match[leaf].est_refs;
+        }
+        else
+        {
+          area_flow += best_leaf_cut->data.area_flow;
+          edge_flow += best_leaf_cut->data.edge_flow;
+        }
+      }
+
+      cut->data.delay = lut_delay + delay;
+      cut->data.lut_area = lut_area;
+      cut->data.lut_delay = lut_delay;
+      cut->data.area_flow = area_flow;
+      cut->data.edge_flow = edge_flow;
+    }
+
+    if constexpr ( StoreFunction )
+    {
+      if ( ps.sop_balancing || ps.esop_balancing )
+      {
+        /* compute delay and area */
+        compute_balancing_cost( cut );
+      }
+    }
+  }
+
+  void compute_cut_data_share( cut_t& cut )
+  {
+    uint32_t delay{ 0 };
+    float area_flow = static_cast<float>( cut->data.lut_area );
+    float edge_flow = cut.size();
+
+    for ( auto leaf : cut )
+    {
+      const auto& best_leaf_cut = cuts[leaf][0];
+      delay = std::max( delay, best_leaf_cut->data.delay );
+      /* flow contribution is added only for not shared leaves */
+      if ( node_match[leaf].map_refs == 0 && leaf != 0 )
+      {
+        area_flow += best_leaf_cut->data.area_flow / node_match[leaf].est_refs;
+        edge_flow += best_leaf_cut->data.edge_flow / node_match[leaf].est_refs;
+      }
+    }
+
+    cut->data.delay = cut->data.lut_delay + delay;
+    cut->data.area_flow = area_flow;
+    cut->data.edge_flow = edge_flow;
+  }
+
+  void add_zero_cut( uint32_t index, bool phase )
+  {
+    auto& cut = cuts[index].add_cut( &index, &index ); /* fake iterator for emptyness */
+
+    if constexpr ( StoreFunction )
+    {
+      if ( phase )
+        cut->func_id = 1;
+      else
+        cut->func_id = 0;
+    }
+  }
+
+  void add_unit_cut( uint32_t index )
+  {
+    auto& cut = cuts[index].add_cut( &index, &index + 1 );
+
+    if constexpr ( StoreFunction )
+    {
+      cut->func_id = 2;
+    }
+  }
+
+  inline bool fast_support_minimization( TT& tt, cut_t& res )
+  {
+    uint32_t support = 0u;
+    uint32_t support_size = 0u;
+    for ( uint32_t i = 0u; i < tt.num_vars(); ++i )
+    {
+      if ( kitty::has_var( tt, i ) )
+      {
+        support |= 1u << i;
+        ++support_size;
+      }
+    }
+
+    /* has not minimized support? */
+    if ( ( support & ( support + 1u ) ) != 0u )
+    {
+      return false;
+    }
+
+    /* variables not in the support are the most significative */
+    if ( support_size != res.size() )
+    {
+      std::vector<uint32_t> leaves( res.begin(), res.begin() + support_size );
+      res.set_leaves( leaves.begin(), leaves.end() );
+      tt = kitty::shrink_to( tt, support_size );
+    }
+
+    return true;
+  }
+
+  uint32_t compute_truth_table( uint32_t index, std::vector<cut_t const*> const& vcuts, cut_t& res )
+  {
+    // stopwatch t( st.cut_enumeration_st.time_truth_table ); /* runtime optimized */
+
+    std::vector<TT> tt( vcuts.size() );
+    auto i = 0;
+    for ( auto const& cut : vcuts )
+    {
+      tt[i] = kitty::extend_to( truth_tables[( *cut )->func_id], res.size() );
+      compute_truth_table_support( *cut, res, tt[i] );
+      ++i;
+    }
+
+    auto tt_res = ntk.compute( ntk.index_to_node( index ), tt.begin(), tt.end() );
+
+    if ( ps.cut_enumeration_ps.minimize_truth_table && !fast_support_minimization( tt_res, res ) )
+    {
+      const auto support = kitty::min_base_inplace( tt_res );
+      if ( support.size() != res.size() )
+      {
+        auto tt_res_shrink = shrink_to( tt_res, static_cast<unsigned>( support.size() ) );
+        std::vector<uint32_t> leaves_before( res.begin(), res.end() );
+        std::vector<uint32_t> leaves_after( support.size() );
+
+        auto it_support = support.begin();
+        auto it_leaves = leaves_after.begin();
+        while ( it_support != support.end() )
+        {
+          *it_leaves++ = leaves_before[*it_support++];
+        }
+        res.set_leaves( leaves_after.begin(), leaves_after.end() );
+        return truth_tables.insert( tt_res_shrink );
+      }
+    }
+
+    return truth_tables.insert( tt_res );
+  }
+
+  void compute_mffcs_mapping()
+  {
+    ntk.clear_mapping();
+
+    /* map POs */
+    ntk.foreach_co( [&]( auto const& f ) {
+      node const& n = ntk.get_node( f );
+      if ( ntk.is_ci( n ) || ntk.is_constant( n ) )
+        return;
+
+      compute_mffc_mapping_node( n );
+    } );
+
+    for ( auto it = topo_order.rbegin(); it != topo_order.rend(); ++it )
+    {
+      node const& n = *it;
+      if ( ntk.is_ci( n ) || ntk.is_constant( n ) )
+        continue;
+      if ( ntk.fanout_size( n ) <= 1 ) /* it should be unnecessary */
+        continue;
+
+      /* create MFFC cut */
+      compute_mffc_mapping_node( n );
+    }
+
+    st.area = area;
+    st.delay = delay;
+    st.edges = edges;
+
+    {
+      std::stringstream stats;
+      stats << fmt::format( "[i] Area MFFC: Delay = {:8d}  Area = {:8d}  Edges = {:8d}  Cuts = {:8d}\n", delay, area, edges, cuts_total );
+      st.round_stats.push_back( stats.str() );
+    }
+  }
+
+  void compute_mffc_mapping_node( node const& n )
+  {
+    uint32_t lut_area, lut_delay;
+
+    /* create FC cut */
+    std::vector<node> inner, leaves;
+    ntk.incr_trav_id();
+    get_fc_nodes_rec( n, inner );
+
+    /* extract leaves */
+    for ( auto const& g : inner )
+    {
+      ntk.foreach_fanin( g, [&]( auto const& f ) {
+        if ( ntk.visited( ntk.get_node( f ) ) != ntk.trav_id() && !ntk.is_constant( ntk.get_node( f ) ) )
+        {
+          leaves.push_back( ntk.get_node( f ) );
+          ntk.set_visited( ntk.get_node( f ), ntk.trav_id() );
+        }
+      } );
+    }
+
+    /* sort leaves in topo order */
+    std::stable_sort( leaves.begin(), leaves.end() );
+
+    ntk.add_to_mapping( n, leaves.begin(), leaves.end() );
+
+    delay = std::max( delay, static_cast<uint32_t>( leaves.size() ) );
+
+    if constexpr ( StoreFunction )
+    {
+      default_simulator<TT> sim( leaves.size() );
+      unordered_node_map<TT, Ntk> node_to_value( ntk );
+
+      /* populate simulation values for constants */
+      node_to_value[ntk.get_node( ntk.get_constant( false ) )] = sim.compute_constant( ntk.constant_value( ntk.get_node( ntk.get_constant( false ) ) ) );
+      if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+      {
+        node_to_value[ntk.get_node( ntk.get_constant( true ) )] = sim.compute_constant( ntk.constant_value( ntk.get_node( ntk.get_constant( true ) ) ) );
+      }
+
+      /* populate simulation values for leaves */
+      uint32_t i = 0u;
+      for ( auto const& g : leaves )
+      {
+        node_to_value[g] = sim.compute_pi( i++ );
+      }
+
+      /* simulate recursively */
+      simulate_fc_rec( n, node_to_value );
+
+      ntk.set_cell_function( n, node_to_value[n] );
+
+      std::tie( lut_area, lut_delay ) = lut_cost( node_to_value[n] );
+    }
+    else
+    {
+      std::tie( lut_area, lut_delay ) = lut_cost( leaves.size() );
+    }
+
+    area += lut_area;
+  }
+
+  void get_fc_nodes_rec( node const& n, std::vector<node>& nodes )
+  {
+    if ( ntk.is_ci( n ) || ntk.is_constant( n ) )
+      return;
+
+    nodes.push_back( n );
+    ntk.set_visited( n, ntk.trav_id() );
+
+    /* expand cut for single fanout nodes */
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      auto g = ntk.get_node( f );
+      if ( ntk.fanout_size( g ) == 1 )
+      {
+        get_fc_nodes_rec( g, nodes );
+      }
+    } );
+  }
+
+  void simulate_fc_rec( node const& n, unordered_node_map<TT, Ntk>& node_to_value )
+  {
+    std::vector<TT> fanin_values( ntk.fanin_size( n ) );
+
+    ntk.foreach_fanin( n, [&]( auto const& f, auto i ) {
+      if ( !node_to_value.has( ntk.get_node( f ) ) )
+      {
+        simulate_fc_rec( ntk.get_node( f ), node_to_value );
+      }
+
+      fanin_values[i] = node_to_value[ntk.get_node( f )];
+    } );
+
+    node_to_value[n] = ntk.compute( n, fanin_values.begin(), fanin_values.end() );
+  }
+
+#pragma region Dump network
+  klut_network create_lut_network()
+  {
+    /* specialized method: does not support buffer/inverter sweeping */
+    if ( StoreFunction && ps.cut_enumeration_ps.minimize_truth_table )
+    {
+      return create_lut_network_mapped();
+    }
+
+    klut_network res;
+    node_map<signal<klut_network>, Ntk> node_to_signal( ntk );
+
+    node_map<driver_type, Ntk> node_driver_type( ntk, driver_type::none );
+
+    /* opposites are filled for nodes with mixed driver types, since they have
+       two nodes in the network. */
+    std::unordered_map<node, signal<klut_network>> opposites;
+
+    /* initial driver types */
+    ntk.foreach_co( [&]( auto const& f ) {
+      switch ( node_driver_type[f] )
+      {
+      case driver_type::none:
+        node_driver_type[f] = ntk.is_complemented( f ) ? driver_type::neg : driver_type::pos;
+        break;
+      case driver_type::pos:
+        node_driver_type[f] = ntk.is_complemented( f ) ? driver_type::mixed : driver_type::pos;
+        break;
+      case driver_type::neg:
+        node_driver_type[f] = ntk.is_complemented( f ) ? driver_type::neg : driver_type::mixed;
+        break;
+      case driver_type::mixed:
+      default:
+        break;
+      }
+    } );
+
+    /* constants */
+    auto add_constant_to_map = [&]( bool value ) {
+      const auto n = ntk.get_node( ntk.get_constant( value ) );
+      switch ( node_driver_type[n] )
+      {
+      default:
+      case driver_type::none:
+      case driver_type::pos:
+        node_to_signal[n] = res.get_constant( value );
+        break;
+
+      case driver_type::neg:
+        node_to_signal[n] = res.get_constant( !value );
+        break;
+
+      case driver_type::mixed:
+        node_to_signal[n] = res.get_constant( value );
+        opposites[n] = res.get_constant( !value );
+        break;
+      }
+    };
+
+    add_constant_to_map( false );
+    if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+    {
+      add_constant_to_map( true );
+    }
+
+    /* primary inputs */
+    ntk.foreach_pi( [&]( auto n ) {
+      signal<klut_network> res_signal;
+      switch ( node_driver_type[n] )
+      {
+      default:
+      case driver_type::none:
+      case driver_type::pos:
+        res_signal = res.create_pi();
+        node_to_signal[n] = res_signal;
+        break;
+
+      case driver_type::neg:
+        res_signal = res.create_pi();
+        node_to_signal[n] = res.create_not( res_signal );
+        break;
+
+      case driver_type::mixed:
+        res_signal = res.create_pi();
+        node_to_signal[n] = res_signal;
+        opposites[n] = res.create_not( node_to_signal[n] );
+        break;
+      }
+    } );
+
+    /* TODO: add sequential compatibility */
+    edges = 0;
+    for ( auto const& n : topo_order )
+    {
+      if ( ntk.is_ci( n ) || ntk.is_constant( n ) )
+        continue;
+
+      const auto index = ntk.node_to_index( n );
+      if ( node_match[index].map_refs == 0 )
+        continue;
+
+      auto const& best_cut = cuts[index][0];
+
+      kitty::dynamic_truth_table tt;
+      std::vector<signal<klut_network>> children;
+      std::tie( tt, children ) = create_lut( n, node_to_signal, node_driver_type );
+      edges += children.size();
+
+      switch ( node_driver_type[n] )
+      {
+      default:
+      case driver_type::none:
+      case driver_type::pos:
+        node_to_signal[n] = res.create_node( children, tt );
+        break;
+
+      case driver_type::neg:
+        node_to_signal[n] = res.create_node( children, ~tt );
+        break;
+
+      case driver_type::mixed:
+        node_to_signal[n] = res.create_node( children, tt );
+        opposites[n] = res.create_node( children, ~tt );
+        edges += children.size();
+        break;
+      }
+    }
+
+    /* outputs */
+    ntk.foreach_po( [&]( auto const& f ) {
+      if ( ntk.is_complemented( f ) && node_driver_type[f] == driver_type::mixed )
+        res.create_po( opposites[ntk.get_node( f )] );
+      else
+        res.create_po( node_to_signal[f] );
+    } );
+
+    st.area = area;
+    st.delay = delay;
+    st.edges = edges;
+
+    return res;
+  }
+
+  klut_network create_lut_network_mapped()
+  {
+    klut_network res;
+    mapping_view<Ntk, true> mapping_ntk{ ntk };
+
+    /* load mapping info */
+    for ( auto const& n : topo_order )
+    {
+      if ( ntk.is_ci( n ) || ntk.is_constant( n ) )
+        continue;
+
+      const auto index = ntk.node_to_index( n );
+      if ( node_match[index].map_refs == 0 )
+        continue;
+
+      std::vector<node> nodes;
+      auto const& best_cut = cuts[index][0];
+
+      for ( auto const& l : best_cut )
+      {
+        nodes.push_back( ntk.index_to_node( l ) );
+      }
+      mapping_ntk.add_to_mapping( n, nodes.begin(), nodes.end() );
+
+      if constexpr ( StoreFunction )
+      {
+        mapping_ntk.set_cell_function( n, truth_tables[best_cut->func_id] );
+      }
+    }
+
+    /* generate mapped network */
+    collapse_mapped_network( res, mapping_ntk );
+
+    st.area = area;
+    st.delay = delay;
+    st.edges = edges;
+
+    return res;
+  }
+
+  inline lut_info create_lut( node const& n, node_map<signal<klut_network>, Ntk>& node_to_signal, node_map<driver_type, Ntk> const& node_driver_type )
+  {
+    auto const& best_cut = cuts[ntk.node_to_index( n )][0];
+
+    std::vector<signal<klut_network>> children;
+    for ( auto const& l : best_cut )
+    {
+      children.push_back( node_to_signal[ntk.index_to_node( l )] );
+    }
+
+    /* recursively compute the function for each choice until success */
+    ntk.incr_trav_id();
+    unordered_node_map<kitty::dynamic_truth_table, Ntk> node_to_value( ntk );
+
+    /* add constants */
+    node_to_value[ntk.get_node( ntk.get_constant( false ) )] = kitty::dynamic_truth_table( best_cut.size() );
+    ntk.set_visited( ntk.get_node( ntk.get_constant( false ) ), ntk.trav_id() );
+    if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+    {
+      node_to_value[ntk.get_node( ntk.get_constant( true ) )] = ~kitty::dynamic_truth_table( best_cut.size() );
+      ntk.set_visited( ntk.get_node( ntk.get_constant( true ) ), ntk.trav_id() );
+    }
+
+    /* add leaves */
+    uint32_t ctr = 0;
+    for ( uint32_t leaf : best_cut )
+    {
+      kitty::dynamic_truth_table tt_leaf( best_cut.size() );
+      kitty::create_nth_var( tt_leaf, ctr++, node_driver_type[ntk.index_to_node( leaf )] == driver_type::neg );
+      node_to_value[ntk.index_to_node( leaf )] = tt_leaf;
+      ntk.set_visited( ntk.index_to_node( leaf ), ntk.trav_id() );
+    }
+
+    /* recursively compute the function */
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      compute_function_rec( ntk.get_node( f ), node_to_value );
+    } );
+
+    std::vector<kitty::dynamic_truth_table> tts;
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      tts.push_back( node_to_value[ntk.get_node( f )] );
+    } );
+    TT tt = ntk.compute( n, tts.begin(), tts.end() );
+
+    minimize_support( tt, children );
+
+    return { tt, children };
+  }
+
+  void compute_function_rec( node const& n, unordered_node_map<kitty::dynamic_truth_table, Ntk>& node_to_value )
+  {
+    if ( ntk.visited( n ) == ntk.trav_id() )
+    {
+      assert( node_to_value.has( n ) );
+      return;
+    }
+
+    assert( !ntk.is_ci( n ) );
+    ntk.set_visited( n, ntk.trav_id() );
+
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      compute_function_rec( ntk.get_node( f ), node_to_value );
+    } );
+
+    /* compute the function */
+    std::vector<kitty::dynamic_truth_table> tts;
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      tts.push_back( node_to_value[ntk.get_node( f )] );
+    } );
+
+    node_to_value[n] = ntk.compute( n, tts.begin(), tts.end() );
+  }
+
+  void derive_mapping()
+  {
+    ntk.clear_mapping();
+
+    for ( auto const& n : topo_order )
+    {
+      if ( ntk.is_ci( n ) || ntk.is_constant( n ) )
+        continue;
+
+      const auto index = ntk.node_to_index( n );
+      if ( node_match[index].map_refs == 0 )
+        continue;
+
+      std::vector<node> nodes;
+      auto const& best_cut = cuts[index][0];
+
+      for ( auto const& l : best_cut )
+      {
+        nodes.push_back( ntk.index_to_node( l ) );
+      }
+      ntk.add_to_mapping( n, nodes.begin(), nodes.end() );
+
+      if constexpr ( StoreFunction )
+      {
+        ntk.set_cell_function( n, truth_tables[best_cut->func_id] );
+      }
+    }
+
+    st.area = area;
+    st.delay = delay;
+    st.edges = edges;
+  }
+
+  void minimize_support( TT& tt, std::vector<signal<klut_network>>& children )
+  {
+    uint32_t support = 0u;
+    uint32_t support_size = 0u;
+    for ( uint32_t i = 0u; i < tt.num_vars(); ++i )
+    {
+      if ( kitty::has_var( tt, i ) )
+      {
+        support |= 1u << i;
+        ++support_size;
+      }
+    }
+
+    /* variables not in the support are the most significative */
+    if ( ( support & ( support + 1u ) ) == 0u )
+    {
+      if ( support_size != children.size() )
+      {
+        children.erase( children.begin() + support_size, children.end() );
+        tt = kitty::shrink_to( tt, support_size );
+      }
+
+      return;
+    }
+
+    /* vacuous variables */
+    const auto support_vector = kitty::min_base_inplace( tt );
+    assert( support_vector.size() != children.size() );
+
+    auto tt_shrink = shrink_to( tt, support_size );
+    std::vector<signal<klut_network>> children_support( support_size );
+
+    auto it_support = support_vector.begin();
+    auto it_children = children_support.begin();
+    while ( it_support != support_vector.end() )
+    {
+      *it_children++ = children[*it_support++];
+    }
+
+    children = std::move( children_support );
+  }
+#pragma endregion
+
+#pragma region balancing
+  void compute_isop( cut_t& cut, bool both_phases = true )
+  {
+    uint32_t func_id = cut->func_id >> 1;
+
+    if ( func_id < isops.size() )
+    {
+      auto const& sop = isops[func_id];
+      if ( sop.size() > max_cubes )
+      {
+        cut->data.ignore = true;
+      }
+      return;
+    }
+
+    assert( func_id == isops.size() );
+
+    sop_t sop, sop_n;
+    if ( ps.sop_balancing )
+    {
+      sop = kitty::isop( truth_tables[func_id << 1u] );
+    }
+    else
+    {
+      sop = exorcism( truth_tables[func_id << 1u] );
+    }
+
+    if ( both_phases )
+    {
+      sop_t n_sop;
+      if ( ps.sop_balancing )
+      {
+        n_sop = kitty::isop( ~truth_tables[func_id << 1u] );
+      }
+      else
+      {
+        n_sop = exorcism( ~truth_tables[func_id << 1u] );
+      }
+
+      if ( n_sop.size() < sop.size() )
+      {
+        sop.swap( n_sop );
+      }
+      else if ( n_sop.size() == sop.size() )
+      {
+        /* compute literal cost */
+        uint32_t lit = 0, n_lit = 0;
+        for ( auto const& c : sop )
+        {
+          lit += c.num_literals();
+        }
+        for ( auto const& c : n_sop )
+        {
+          n_lit += c.num_literals();
+        }
+
+        if ( n_lit < lit )
+        {
+          sop.swap( n_sop );
+        }
+      }
+    }
+
+    /* check size of SOP < max_cubes */
+    if ( sop.size() > max_cubes )
+    {
+      cut->data.ignore = true;
+    }
+
+    isops.push_back( sop );
+    return;
+  }
+
+  void compute_balancing_cost( cut_t& cut )
+  {
+    uint32_t decomposition_size = 0;
+    uint32_t decomposition_delay = 0;
+
+    auto const& sop = isops[cut->func_id >> 1];
+
+    if ( cut->data.ignore || sop.size() > max_cubes )
+      return;
+
+    /* specific case size = 0 or = 1 */
+    if ( cut.size() < 2 )
+      return;
+
+    /* collect arrival times for fanin */
+    std::array<uint32_t, max_cut_size> arrival_pin;
+    unsigned i = 0;
+    for ( auto l : cut )
+      arrival_pin[i++] = cuts[l].best()->data.delay;
+
+    cubes_queue_t terms;
+
+    /* get terms delay */
+    assert( sop.size() <= max_cubes );
+    for ( kitty::cube const& c : sop )
+    {
+      cubes_queue_t lits;
+      for ( i = 0; i < cut.size(); ++i )
+      {
+        if ( c.get_mask( i ) )
+        {
+          lits.push( arrival_pin[i] );
+        }
+      }
+
+      if ( lits.size() == 0 )
+        continue;
+
+      decomposition_size += lits.size() - 1;
+      terms.push( compute_balancing_cost_term( lits ) );
+    }
+
+    assert( terms.size() > 0 );
+
+    decomposition_size += terms.size() - 1;
+    decomposition_delay = compute_balancing_cost_term( terms );
+
+    cut->data.delay = decomposition_delay;
+    cut->data.lut_area = decomposition_size;
+    cut->data.lut_delay = 1; /* not used */
+    cut->data.area_flow += decomposition_size;
+    /* edge flow not used */
+  }
+
+  inline uint32_t compute_balancing_cost_term( cubes_queue_t& terms )
+  {
+    while ( terms.size() != 1 )
+    {
+      uint32_t l0 = terms.top();
+      terms.pop();
+      uint32_t l1 = terms.top();
+      terms.pop();
+      terms.push( std::max( l0, l1 ) + 1 );
+    }
+
+    return terms.top();
+  }
+
+  void compute_balancing_cost_required( uint32_t index )
+  {
+    cut_t const& cut = cuts[index][0];
+
+    if ( cut.size() == 0 )
+      return;
+
+    /* propagate unit delay back */
+    if ( cut.size() == 1 )
+    {
+      for ( auto l : cut )
+      {
+        node_match[l].required = std::min( node_match[l].required, node_match[index].required );
+      }
+    }
+
+    /* collect arrival times for fanin */
+    std::array<std::pair<uint16_t, uint16_t>, max_sop_decomp_size> connections;
+    std::array<uint32_t, max_cut_size> arrival_pin;
+    std::array<uint32_t, max_sop_decomp_size> required;
+    unsigned size = 0;
+    for ( auto l : cut )
+    {
+      arrival_pin[size] = cuts[l].best()->data.delay;
+      connections[size] = std::make_pair( size, size );
+      ++size;
+    }
+
+    auto priority_cmp = []( std::pair<uint32_t, uint16_t> const& a, std::pair<uint32_t, uint16_t> const& b ) { return a.first > b.first; };
+    using cubes_queue2_t = std::priority_queue<std::pair<uint32_t, uint16_t>, std::vector<std::pair<uint32_t, uint16_t>>, decltype( priority_cmp )>;
+
+    cubes_queue2_t terms( priority_cmp );
+
+    /* get terms delay */
+    auto const& sop = isops[cut->func_id >> 1];
+    assert( sop.size() <= max_cubes );
+    for ( kitty::cube const& c : sop )
+    {
+      cubes_queue2_t lits( priority_cmp );
+      for ( auto i = 0; i < cut.size(); ++i )
+      {
+        if ( c.get_mask( i ) )
+        {
+          lits.push( { arrival_pin[i], i } );
+        }
+      }
+
+      if ( lits.size() == 0 )
+        continue;
+
+      compute_balancing_cost_required_term( lits, connections, size );
+      assert( size <= connections.size() );
+
+      terms.push( lits.top() );
+    }
+
+    assert( terms.size() > 0 );
+    compute_balancing_cost_required_term( terms, connections, size );
+
+    uint32_t required_node = node_match[index].required;
+    assert( terms.top().first == cut->data.delay );
+    assert( required_node >= terms.top().first );
+
+    /* init required times */
+    for ( auto i = 0; i < size - 1; ++i )
+      required[i] = UINT32_MAX;
+    required[size - 1] = required_node;
+
+    compute_balancing_cost_propagate_required( connections, required, size, cut.size() );
+
+    /* assign required time */
+    uint32_t ctr = 0;
+    for ( auto l : cut )
+    {
+      node_match[l].required = std::min( node_match[l].required, required[ctr++] );
+      assert( node_match[l].required >= cuts[l][0]->data.delay );
+    }
+  }
+
+  template<typename Queue>
+  inline void compute_balancing_cost_required_term( Queue& terms, std::array<std::pair<uint16_t, uint16_t>, max_sop_decomp_size>& connections, uint32_t& size )
+  {
+    while ( terms.size() != 1 )
+    {
+      std::pair<uint32_t, uint16_t> l0 = terms.top();
+      terms.pop();
+      std::pair<uint32_t, uint16_t> l1 = terms.top();
+      terms.pop();
+      uint32_t arrival = std::max( l0.first, l1.first ) + 1;
+      terms.push( { arrival, size } );
+      connections[size] = std::make_pair( l0.second, l1.second );
+      ++size;
+    }
+  }
+
+  inline void compute_balancing_cost_propagate_required( std::array<std::pair<uint16_t, uint16_t>, max_sop_decomp_size> const& connections, std::array<uint32_t, max_sop_decomp_size>& required, uint32_t size, uint32_t leaves )
+  {
+    for ( auto i = size - 1; i >= leaves; --i )
+    {
+      uint32_t time = required[i] - 1;
+      required[connections[i].first] = std::min( time, required[connections[i].first] );
+      required[connections[i].second] = std::min( time, required[connections[i].second] );
+    }
+  }
+#pragma endregion
+
+private:
+  Ntk& ntk;
+  lut_map_params const& ps;
+  lut_map_stats& st;
+
+  uint32_t iteration{ 0 };       /* current mapping iteration */
+  uint32_t area_iteration{ 0 };  /* current area iteration */
+  uint32_t delay{ 0 };           /* current delay of the mapping */
+  uint32_t area{ 0 };            /* current area of the mapping */
+  uint32_t edges{ 0 };           /* current edges of the mapping */
+  uint32_t cuts_total{ 0 };      /* current computed cuts */
+  const float epsilon{ 0.005f }; /* epsilon */
+  LUTCostFn lut_cost{};
+
+  std::vector<node> topo_order;
+  std::vector<uint32_t> tmp_visited;
+  std::vector<node_lut> node_match;
+
+  std::vector<cut_set_t> cuts;  /* compressed representation of cuts */
+  cut_merge_t lcuts;            /* cut merger container */
+  tt_cache truth_tables;        /* cut truth tables */
+  cost_cache truth_tables_cost; /* truth tables cost */
+  isop_cache isops;             /* cache for isops */
+};
+#pragma endregion
+
+} /* namespace detail */
+
+/*! \brief LUT mapper.
+ *
+ * This function implements a LUT mapping algorithm.  It is controlled by one
+ * template argument `ComputeTruth` (defaulted to `false`) which controls
+ * whether the LUT function is computed or the mapping is structural. In the
+ * former case, truth tables are computed during cut enumeration,
+ * which requires more runtime.
+ *
+ * This function returns a k-LUT network.
+ *
+ * The template `LUTCostFn` sets the cost function to evaluate depth and
+ * size of a truth table given its support size if `ComputeTruth` is set
+ * to false, or its function if `ComputeTruth` is set to true.
+ *
+ * This implementation offers more options such as delay oriented mapping
+ * and edges minimization compared to the command `lut_mapping`.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `is_ci`
+ * - `is_constant`
+ * - `node_to_index`
+ * - `index_to_node`
+ * - `get_node`
+ * - `foreach_co`
+ * - `foreach_node`
+ * - `fanout_size`
+ */
+template<class Ntk, bool ComputeTruth = false, class LUTCostFn = lut_unitary_cost>
+klut_network lut_map( Ntk& ntk, lut_map_params ps = {}, lut_map_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_is_ci_v<Ntk>, "Ntk does not implement the is_ci method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_ci_v<Ntk>, "Ntk does not implement the foreach_ci method" );
+  static_assert( has_foreach_co_v<Ntk>, "Ntk does not implement the foreach_co method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+
+  lut_map_params tps = ps;
+  lut_map_stats st;
+  klut_network klut;
+
+  /* adjust params for balancing */
+  if ( ps.sop_balancing || ps.esop_balancing )
+  {
+    tps.area_oriented_mapping = false;
+    tps.recompute_cuts = false;
+    tps.area_share_rounds = 0;
+    tps.edge_optimization = false;
+    tps.cut_expansion = false;
+  }
+
+  detail::lut_map_impl<Ntk, ComputeTruth, LUTCostFn> p( ntk, tps, st );
+  klut = p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst != nullptr )
+  {
+    *pst = st;
+  }
+
+  return klut;
+}
+
+/*! \brief LUT mapper inplace.
+ *
+ * This function implements a LUT mapping algorithm.  It is controlled by one
+ * template argument `StoreFunction` (defaulted to `false`) which controls
+ * whether the LUT function is stored in the mapping. In that case
+ * truth tables are computed during cut enumeration, which requires more
+ * runtime.
+ *
+ * The input network must be wrapped in a `mapping_view`. The computed mapping
+ * is stored in the view. In this version, some features of the mapper are
+ * disabled, such as on-the-fly decompositions, due to incompatibility.
+ *
+ * The template `LUTCostFn` sets the cost function to evaluate depth and
+ * size of a truth table given its support size, if `StoreFunction` is set
+ * to false, or its function, if `StoreFunction` is set to true.
+ *
+ * This implementation offers more options such as delay oriented mapping
+ * and edges minimization compared to the command `lut_mapping`.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `is_ci`
+ * - `is_constant`
+ * - `node_to_index`
+ * - `index_to_node`
+ * - `get_node`
+ * - `foreach_co`
+ * - `foreach_node`
+ * - `fanout_size`
+ * - `clear_mapping`
+ * - `add_to_mapping`
+ * - `set_lut_function` (if `StoreFunction` is true)
+ *
+ *
+   \verbatim embed:rst
+
+   .. note::
+
+      The implementation of this algorithm was inspired by the LUT
+      mapping command ``&if`` in ABC.
+   \endverbatim
+ */
+template<class Ntk, bool StoreFunction = false, class LUTCostFn = lut_unitary_cost>
+void lut_map_inplace( Ntk& ntk, lut_map_params const& ps = {}, lut_map_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_is_ci_v<Ntk>, "Ntk does not implement the is_ci method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_ci_v<Ntk>, "Ntk does not implement the foreach_ci method" );
+  static_assert( has_foreach_co_v<Ntk>, "Ntk does not implement the foreach_co method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_clear_mapping_v<Ntk>, "Ntk does not implement the clear_mapping method" );
+  static_assert( has_add_to_mapping_v<Ntk>, "Ntk does not implement the add_to_mapping method" );
+
+  lut_map_params tps = ps;
+  lut_map_stats st;
+
+  /* adjust params for balancing */
+  if ( ps.sop_balancing || ps.esop_balancing )
+  {
+    tps.area_oriented_mapping = false;
+    tps.recompute_cuts = false;
+    tps.area_share_rounds = 0;
+    tps.edge_optimization = false;
+    tps.cut_expansion = false;
+  }
+
+  detail::lut_map_impl<Ntk, StoreFunction, LUTCostFn> p( ntk, tps, st );
+  p.run_inplace();
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst != nullptr )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/lut_mapping.hpp b/include/mockturtle/algorithms/lut_mapping.hpp
new file mode 100644
index 0000000..8874873
--- /dev/null
+++ b/include/mockturtle/algorithms/lut_mapping.hpp
@@ -0,0 +1,546 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file lut_mapping.hpp
+  \brief LUT mapping
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+
+#include <fmt/format.h>
+
+#include "../utils/stopwatch.hpp"
+#include "../views/topo_view.hpp"
+#include "cut_enumeration.hpp"
+#include "cut_enumeration/mf_cut.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for lut_mapping.
+ *
+ * The data structure `lut_mapping_params` holds configurable parameters
+ * with default arguments for `lut_mapping`.
+ */
+struct lut_mapping_params
+{
+  lut_mapping_params()
+  {
+    cut_enumeration_ps.cut_size = 6;
+    cut_enumeration_ps.cut_limit = 8;
+  }
+
+  /*! \brief Parameters for cut enumeration
+   *
+   * The default cut size is 6, the default cut limit is 8.
+   */
+  cut_enumeration_params cut_enumeration_ps{};
+
+  /*! \brief Number of rounds for area flow optimization.
+   *
+   * The first round is used for delay optimization.
+   */
+  uint32_t rounds{ 2u };
+
+  /*! \brief Number of rounds for exact area optimization. */
+  uint32_t rounds_ela{ 1u };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+};
+
+/*! \brief Statistics for lut_mapping.
+ *
+ * The data structure `lut_mapping_stats` provides data collected by running
+ * `lut_mapping`.
+ */
+struct lut_mapping_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  void report() const
+  {
+    std::cout << fmt::format( "[i] total time = {:>5.2f} secs\n", to_seconds( time_total ) );
+  }
+};
+
+/* function to update all cuts after cut enumeration */
+template<typename CutData>
+struct lut_mapping_update_cuts
+{
+  template<typename NetworkCuts, typename Ntk>
+  static void apply( NetworkCuts const& cuts, Ntk const& ntk )
+  {
+    (void)cuts;
+    (void)ntk;
+  }
+};
+
+namespace detail
+{
+
+template<class Ntk, bool StoreFunction, typename CutData>
+class lut_mapping_impl
+{
+public:
+  using network_cuts_t = network_cuts<Ntk, StoreFunction, CutData>;
+  using cut_t = typename network_cuts_t::cut_t;
+
+public:
+  lut_mapping_impl( Ntk& ntk, lut_mapping_params const& ps, lut_mapping_stats& st )
+      : ntk( ntk ),
+        ps( ps ),
+        st( st ),
+        flow_refs( ntk.size() ),
+        map_refs( ntk.size(), 0 ),
+        flows( ntk.size() ),
+        delays( ntk.size() ),
+        cuts( cut_enumeration<Ntk, StoreFunction, CutData>( ntk, ps.cut_enumeration_ps ) )
+  {
+    lut_mapping_update_cuts<CutData>().apply( cuts, ntk );
+  }
+
+  void run()
+  {
+    stopwatch t( st.time_total );
+
+    /* compute and save topological order */
+    top_order.reserve( ntk.size() );
+    topo_view<Ntk>( ntk ).foreach_node( [this]( auto n ) {
+      top_order.push_back( n );
+    } );
+
+    init_nodes();
+    // print_state();
+
+    set_mapping_refs<false>();
+    // print_state();
+
+    while ( iteration < ps.rounds )
+    {
+      compute_mapping<false>();
+    }
+
+    while ( iteration < ps.rounds + ps.rounds_ela )
+    {
+      compute_mapping<true>();
+    }
+
+    derive_mapping();
+  }
+
+private:
+  uint32_t cut_area( cut_t const& cut ) const
+  {
+    return static_cast<uint32_t>( cut->data.cost );
+  }
+
+  void init_nodes()
+  {
+    ntk.foreach_node( [this]( auto n, auto ) {
+      const auto index = ntk.node_to_index( n );
+      if ( ntk.is_constant( n ) || ntk.is_ci( n ) )
+      {
+        /* all terminals have flow 1.0 */
+        flow_refs[index] = 1.0f;
+      }
+      else
+      {
+        flow_refs[index] = static_cast<float>( ntk.fanout_size( n ) );
+      }
+
+      flows[index] = cuts.cuts( index )[0]->data.flow;
+      delays[index] = cuts.cuts( index )[0]->data.delay;
+    } );
+  }
+
+  template<bool ELA>
+  void compute_mapping()
+  {
+    for ( auto const& n : top_order )
+    {
+      if ( ntk.is_constant( n ) || ntk.is_ci( n ) )
+        continue;
+      compute_best_cut<ELA>( ntk.node_to_index( n ) );
+    }
+    set_mapping_refs<ELA>();
+    // print_state();
+  }
+
+  template<bool ELA>
+  void set_mapping_refs()
+  {
+    const auto coef = 1.0f / ( 1.0f + ( iteration + 1 ) * ( iteration + 1 ) );
+
+    /* compute current delay and update mapping refs */
+    delay = 0;
+    ntk.foreach_co( [this]( auto s ) {
+      const auto index = ntk.node_to_index( ntk.get_node( s ) );
+      delay = std::max( delay, delays[index] );
+
+      if constexpr ( !ELA )
+      {
+        map_refs[index]++;
+      }
+    } );
+
+    /* compute current area and update mapping refs */
+    area = 0;
+    for ( auto it = top_order.rbegin(); it != top_order.rend(); ++it )
+    {
+      /* skip constants and PIs (TODO: stop earlier) */
+      if ( ntk.is_constant( *it ) || ntk.is_ci( *it ) )
+        continue;
+
+      const auto index = ntk.node_to_index( *it );
+      if ( map_refs[index] == 0 )
+        continue;
+
+      if constexpr ( !ELA )
+      {
+        for ( auto leaf : cuts.cuts( index )[0] )
+        {
+          map_refs[leaf]++;
+        }
+      }
+      area++;
+    }
+
+    /* blend flow references */
+    for ( auto i = 0u; i < ntk.size(); ++i )
+    {
+      flow_refs[i] = coef * flow_refs[i] + ( 1.0f - coef ) * std::max( 1.0f, static_cast<float>( map_refs[i] ) );
+    }
+
+    ++iteration;
+  }
+
+  std::pair<float, uint32_t> cut_flow( cut_t const& cut )
+  {
+    uint32_t time{ 0u };
+    float flow{ 0.0f };
+
+    for ( auto leaf : cut )
+    {
+      time = std::max( time, delays[leaf] );
+      flow += flows[leaf];
+    }
+
+    return { flow + cut_area( cut ), time + 1u };
+  }
+
+  /* reference cut:
+   *   adds cut to current mapping and recursively adds best cuts of leaf
+   *   nodes, if they are not part of the current mapping.
+   */
+  uint32_t cut_ref( cut_t const& cut )
+  {
+    uint32_t count = cut_area( cut );
+    for ( auto leaf : cut )
+    {
+      if ( ntk.is_constant( ntk.index_to_node( leaf ) ) || ntk.is_ci( ntk.index_to_node( leaf ) ) )
+        continue;
+
+      if ( map_refs[leaf]++ == 0 )
+      {
+        count += cut_ref( cuts.cuts( leaf )[0] );
+      }
+    }
+    return count;
+  }
+
+  /* dereference cut:
+   *   removes cut from current mapping and recursively removes best cuts of
+   *   leaf nodes, if they are part of the current mapping.
+   *   (this is the inverse operation to cut_ref)
+   */
+  uint32_t cut_deref( cut_t const& cut )
+  {
+    uint32_t count = cut_area( cut );
+    for ( auto leaf : cut )
+    {
+      if ( ntk.is_constant( ntk.index_to_node( leaf ) ) || ntk.is_ci( ntk.index_to_node( leaf ) ) )
+        continue;
+
+      if ( --map_refs[leaf] == 0 )
+      {
+        count += cut_deref( cuts.cuts( leaf ).best() );
+      }
+    }
+    return count;
+  }
+
+  /* reference cut (special version):
+   *   this special version of cut_ref does two additional things:
+   *   1. it stops recursing if it has found `limit` cuts
+   *   2. it remembers all cuts for which the reference count increases in the
+   *      vector `tmp_area`.
+   */
+  uint32_t cut_ref_limit_save( cut_t const& cut, uint32_t limit )
+  {
+    uint32_t count = cut_area( cut );
+    if ( limit == 0 )
+      return count;
+
+    for ( auto leaf : cut )
+    {
+      if ( ntk.is_constant( ntk.index_to_node( leaf ) ) || ntk.is_ci( ntk.index_to_node( leaf ) ) )
+        continue;
+
+      tmp_area.push_back( leaf );
+      if ( map_refs[leaf]++ == 0 )
+      {
+        count += cut_ref_limit_save( cuts.cuts( leaf ).best(), limit - 1 );
+      }
+    }
+    return count;
+  }
+
+  /* estimates the cost of adding this cut to the mapping:
+   *   This algorithm references cuts recursively to estimate how many cuts
+   *   would be needed to add to the mapping if `cut` were to be added.  It
+   *   temporarily modifies the reference counters but reverts them eventually.
+   */
+  uint32_t cut_area_estimation( cut_t const& cut )
+  {
+    tmp_area.clear();
+    const auto count = cut_ref_limit_save( cut, 8 );
+    for ( auto const& n : tmp_area )
+    {
+      map_refs[n]--;
+    }
+    return count;
+  }
+
+  template<bool ELA>
+  void compute_best_cut( uint32_t index )
+  {
+    constexpr auto mf_eps{ 0.005f };
+
+    float flow;
+    uint32_t time{ 0 };
+    int32_t best_cut{ -1 };
+    float best_flow{ std::numeric_limits<float>::max() };
+    uint32_t best_time{ std::numeric_limits<uint32_t>::max() };
+    int32_t cut_index{ -1 };
+
+    if constexpr ( ELA )
+    {
+      if ( map_refs[index] > 0 )
+      {
+        cut_deref( cuts.cuts( index )[0] );
+      }
+    }
+
+    for ( auto* cut : cuts.cuts( index ) )
+    {
+      ++cut_index;
+      if ( cut->size() == 1 )
+        continue;
+
+      if constexpr ( ELA )
+      {
+        flow = static_cast<float>( cut_area_estimation( *cut ) );
+      }
+      else
+      {
+        std::tie( flow, time ) = cut_flow( *cut );
+      }
+
+      if ( best_cut == -1 || best_flow > flow + mf_eps || ( best_flow > flow - mf_eps && best_time > time ) )
+      {
+        best_cut = cut_index;
+        best_flow = flow;
+        best_time = time;
+      }
+    }
+
+    if ( best_cut == -1 )
+      return;
+
+    if constexpr ( ELA )
+    {
+      if ( map_refs[index] > 0 )
+      {
+        cut_ref( cuts.cuts( index )[best_cut] );
+      }
+    }
+    else
+    {
+      map_refs[index] = 0;
+    }
+    if constexpr ( ELA )
+    {
+      best_time = cut_flow( cuts.cuts( index )[best_cut] ).second;
+    }
+    delays[index] = best_time;
+    flows[index] = best_flow / flow_refs[index];
+
+    if ( best_cut != 0 )
+    {
+      cuts.cuts( index ).update_best( best_cut );
+    }
+  }
+
+  void derive_mapping()
+  {
+    ntk.clear_mapping();
+
+    for ( auto const& n : top_order )
+    {
+      if ( ntk.is_constant( n ) || ntk.is_ci( n ) )
+        continue;
+
+      const auto index = ntk.node_to_index( n );
+      if ( map_refs[index] == 0 )
+        continue;
+
+      std::vector<node<Ntk>> nodes;
+      for ( auto const& l : cuts.cuts( index ).best() )
+      {
+        nodes.push_back( ntk.index_to_node( l ) );
+      }
+      ntk.add_to_mapping( n, nodes.begin(), nodes.end() );
+
+      if constexpr ( StoreFunction )
+      {
+        ntk.set_cell_function( n, cuts.truth_table( cuts.cuts( index ).best() ) );
+      }
+    }
+  }
+
+  void print_state()
+  {
+    for ( auto i = 0u; i < ntk.size(); ++i )
+    {
+      std::cout << fmt::format( "*** Obj = {:>3} (node = {:>3})  FlowRefs = {:5.2f}  MapRefs = {:>2}  Flow = {:5.2f}  Delay = {:>3}\n", i, ntk.index_to_node( i ), flow_refs[i], map_refs[i], flows[i], delays[i] );
+      // std::cout << cuts.cuts( i );
+    }
+    std::cout << fmt::format( "Level = {}  Area = {}\n", delay, area );
+  }
+
+private:
+  Ntk& ntk;
+  lut_mapping_params const& ps;
+  lut_mapping_stats& st;
+
+  uint32_t iteration{ 0 }; /* current mapping iteration */
+  uint32_t delay{ 0 };     /* current delay of the mapping */
+  uint32_t area{ 0 };      /* current area of the mapping */
+  // bool ela{false};       /* compute exact area */
+
+  std::vector<node<Ntk>> top_order;
+  std::vector<float> flow_refs;
+  std::vector<uint32_t> map_refs;
+  std::vector<float> flows;
+  std::vector<uint32_t> delays;
+  network_cuts_t cuts;
+
+  std::vector<uint32_t> tmp_area; /* temporary vector to compute exact area */
+};
+
+}; /* namespace detail */
+
+/*! \brief LUT mapping.
+ *
+ * This function implements a LUT mapping algorithm.  It is controlled by two
+ * template arguments `StoreFunction` (defaulted to `true`) and `CutData`
+ * (defaulted to `cut_enumeration_mf_cut`).  The first argument `StoreFunction`
+ * controls whether the LUT function is stored in the mapping.  In that case
+ * truth tables are computed during cut enumeration, which requires more
+ * runtime.  The second argument is simuilar to the `CutData` argument in
+ * `cut_enumeration`, which can specialize the cost function to select priority
+ * cuts and store additional data.  For LUT mapping using this function the
+ * type passed as `CutData` must implement the following three fields:
+ *
+ * - `uint32_t delay`
+ * - `float flow`
+ * - `float costs`
+ *
+ * See `include/mockturtle/algorithms/cut_enumeration/mf_cut.hpp` for one
+ * example of a CutData type that implements the cost function that is used in
+ * the LUT mapper `&mf` in ABC.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `is_ci`
+ * - `is_constant`
+ * - `node_to_index`
+ * - `index_to_node`
+ * - `get_node`
+ * - `foreach_co`
+ * - `foreach_node`
+ * - `fanout_size`
+ * - `clear_mapping`
+ * - `add_to_mapping`
+ * - `set_lut_function` (if `StoreFunction` is true)
+ *
+   \verbatim embed:rst
+
+   .. note::
+
+      The implementation of this algorithm was heavily inspired but the LUT
+      mapping command ``&mf`` in ABC.
+   \endverbatim
+ */
+template<class Ntk, bool StoreFunction = false, typename CutData = cut_enumeration_mf_cut>
+void lut_mapping( Ntk& ntk, lut_mapping_params const& ps = {}, lut_mapping_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_is_ci_v<Ntk>, "Ntk does not implement the is_ci method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_co_v<Ntk>, "Ntk does not implement the foreach_co method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_clear_mapping_v<Ntk>, "Ntk does not implement the clear_mapping method" );
+  static_assert( has_add_to_mapping_v<Ntk>, "Ntk does not implement the add_to_mapping method" );
+  static_assert( !StoreFunction || has_set_cell_function_v<Ntk>, "Ntk does not implement the set_cell_function method" );
+
+  lut_mapping_stats st;
+  detail::lut_mapping_impl<Ntk, StoreFunction, CutData> p( ntk, ps, st );
+  p.run();
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/mapper.hpp b/include/mockturtle/algorithms/mapper.hpp
new file mode 100644
index 0000000..441f981
--- /dev/null
+++ b/include/mockturtle/algorithms/mapper.hpp
@@ -0,0 +1,3483 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mapper.hpp
+  \brief Mapper
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <limits>
+
+#include <fmt/format.h>
+
+#include "../networks/aig.hpp"
+#include "../networks/klut.hpp"
+#include "../networks/mig.hpp"
+#include "../networks/sequential.hpp"
+#include "../networks/xag.hpp"
+#include "../utils/node_map.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../utils/tech_library.hpp"
+#include "../views/binding_view.hpp"
+#include "../views/color_view.hpp"
+#include "../views/depth_view.hpp"
+#include "../views/topo_view.hpp"
+#include "../views/window_view.hpp"
+#include "cleanup.hpp"
+#include "cut_enumeration.hpp"
+#include "cut_enumeration/exact_map_cut.hpp"
+#include "cut_enumeration/tech_map_cut.hpp"
+#include "detail/mffc_utils.hpp"
+#include "detail/switching_activity.hpp"
+#include "reconv_cut.hpp"
+#include "resyn_engines/mig_resyn.hpp"
+#include "resyn_engines/xag_resyn.hpp"
+#include "simulation.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for map.
+ *
+ * The data structure `map_params` holds configurable parameters
+ * with default arguments for `map`.
+ */
+struct map_params
+{
+  map_params()
+  {
+    cut_enumeration_ps.cut_limit = 49;
+    cut_enumeration_ps.minimize_truth_table = true;
+  }
+
+  /*! \brief Parameters for cut enumeration
+   *
+   * The default cut limit is 49. By default,
+   * truth table minimization is performed.
+   */
+  cut_enumeration_params cut_enumeration_ps{};
+
+  /*! \brief Required time for delay optimization. */
+  double required_time{ 0.0f };
+
+  /*! \brief Skip delay round for area optimization. */
+  bool skip_delay_round{ false };
+
+  /*! \brief Number of rounds for area flow optimization. */
+  uint32_t area_flow_rounds{ 1u };
+
+  /*! \brief Number of rounds for exact area optimization. */
+  uint32_t ela_rounds{ 2u };
+
+  /*! \brief Number of rounds for exact switching power optimization. */
+  uint32_t eswp_rounds{ 0u };
+
+  /*! \brief Number of patterns for switching activity computation. */
+  uint32_t switching_activity_patterns{ 2048u };
+
+  /*! \brief Exploit logic sharing in exact area optimization of graph mapping. */
+  bool enable_logic_sharing{ false };
+
+  /*! \brief Maximum number of cuts evaluated for logic sharing. */
+  uint32_t logic_sharing_cut_limit{ 8u };
+
+  /*! \brief Use satisfiability don't cares for optimization. */
+  bool use_dont_cares{ false };
+
+  /*! \brief Window size for don't cares calculation. */
+  uint32_t window_size{ 12u };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+};
+
+/*! \brief Statistics for mapper.
+ *
+ * The data structure `map_stats` provides data collected by running
+ * `map`.
+ */
+struct map_stats
+{
+  /*! \brief Area result. */
+  double area{ 0 };
+  /*! \brief Worst delay result. */
+  double delay{ 0 };
+  /*! \brief Power result. */
+  double power{ 0 };
+
+  /*! \brief Runtime for covering. */
+  stopwatch<>::duration time_mapping{ 0 };
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Cut enumeration stats. */
+  cut_enumeration_stats cut_enumeration_st{};
+
+  /*! \brief Delay and area stats for each round. */
+  std::vector<std::string> round_stats{};
+
+  /*! \brief Mapping error. */
+  bool mapping_error{ false };
+
+  void report() const
+  {
+    for ( auto const& stat : round_stats )
+    {
+      std::cout << stat;
+    }
+    std::cout << fmt::format( "[i] Area = {:>5.2f}; Delay = {:>5.2f};", area, delay );
+    if ( power != 0 )
+      std::cout << fmt::format( " Power = {:>5.2f};\n", power );
+    else
+      std::cout << "\n";
+    std::cout << fmt::format( "[i] Mapping runtime = {:>5.2f} secs\n", to_seconds( time_mapping ) );
+    std::cout << fmt::format( "[i] Total runtime   = {:>5.2f} secs\n", to_seconds( time_total ) );
+  }
+};
+
+namespace detail
+{
+
+template<unsigned NInputs>
+struct cut_match_tech
+{
+  /* list of supergates matching the cut for positive and negative output phases */
+  std::array<std::vector<supergate<NInputs>> const*, 2> supergates = { nullptr, nullptr };
+  /* input negations, 0: pos, 1: neg */
+  std::array<uint8_t, 2> negations{ 0, 0 };
+};
+
+template<unsigned NInputs>
+struct node_match_tech
+{
+  /* best gate match for positive and negative output phases */
+  supergate<NInputs> const* best_supergate[2] = { nullptr, nullptr };
+  /* fanin pin phases for both output phases */
+  uint8_t phase[2];
+  /* best cut index for both phases */
+  uint32_t best_cut[2];
+  /* node is mapped using only one phase */
+  bool same_match{ false };
+
+  /* arrival time at node output */
+  double arrival[2];
+  /* required time at node output */
+  double required[2];
+  /* area of the best matches */
+  float area[2];
+
+  /* number of references in the cover 0: pos, 1: neg, 2: pos+neg */
+  uint32_t map_refs[3];
+  /* references estimation */
+  float est_refs[3];
+  /* area flow */
+  float flows[3];
+};
+
+template<class Ntk, unsigned CutSize, typename CutData, unsigned NInputs, classification_type Configuration>
+class tech_map_impl
+{
+public:
+  using network_cuts_t = fast_network_cuts<Ntk, CutSize, true, CutData>;
+  using cut_t = typename network_cuts_t::cut_t;
+  using match_map = std::unordered_map<uint32_t, std::vector<cut_match_tech<NInputs>>>;
+  using klut_map = std::unordered_map<uint32_t, std::array<signal<klut_network>, 2>>;
+  using map_ntk_t = binding_view<klut_network>;
+  using seq_map_ntk_t = binding_view<sequential<klut_network>>;
+
+public:
+  explicit tech_map_impl( Ntk const& ntk, tech_library<NInputs, Configuration> const& library, map_params const& ps, map_stats& st )
+      : ntk( ntk ),
+        library( library ),
+        ps( ps ),
+        st( st ),
+        node_match( ntk.size() ),
+        matches(),
+        switch_activity( ps.eswp_rounds ? switching_activity( ntk, ps.switching_activity_patterns ) : std::vector<float>( 0 ) ),
+        cuts( fast_cut_enumeration<Ntk, CutSize, true, CutData>( ntk, ps.cut_enumeration_ps, &st.cut_enumeration_st ) )
+  {
+    std::tie( lib_inv_area, lib_inv_delay, lib_inv_id ) = library.get_inverter_info();
+    std::tie( lib_buf_area, lib_buf_delay, lib_buf_id ) = library.get_buffer_info();
+  }
+
+  explicit tech_map_impl( Ntk const& ntk, tech_library<NInputs, Configuration> const& library, std::vector<float> const& switch_activity, map_params const& ps, map_stats& st )
+      : ntk( ntk ),
+        library( library ),
+        ps( ps ),
+        st( st ),
+        node_match( ntk.size() ),
+        matches(),
+        switch_activity( switch_activity ),
+        cuts( fast_cut_enumeration<Ntk, NInputs, true, CutData>( ntk, ps.cut_enumeration_ps, &st.cut_enumeration_st ) )
+  {
+    std::tie( lib_inv_area, lib_inv_delay, lib_inv_id ) = library.get_inverter_info();
+    std::tie( lib_buf_area, lib_buf_delay, lib_buf_id ) = library.get_buffer_info();
+  }
+
+  map_ntk_t run()
+  {
+    stopwatch t( st.time_mapping );
+
+    auto [res, old2new] = initialize_map_network();
+
+    /* compute and save topological order */
+    top_order.reserve( ntk.size() );
+    topo_view<Ntk>( ntk ).foreach_node( [this]( auto n ) {
+      top_order.push_back( n );
+    } );
+
+    /* match cuts with gates */
+    compute_matches();
+
+    /* init the data structure */
+    init_nodes();
+
+    /* execute mapping */
+    if ( !execute_mapping() )
+      return res;
+
+    /* insert buffers for POs driven by PIs */
+    insert_buffers();
+
+    /* generate the output network */
+    finalize_cover<map_ntk_t>( res, old2new );
+
+    return res;
+  }
+
+  seq_map_ntk_t run_seq()
+  {
+    stopwatch t( st.time_mapping );
+
+    auto [res, old2new] = initialize_map_seq_network();
+
+    /* compute and save topological order */
+    top_order.reserve( ntk.size() );
+    topo_view<Ntk>( ntk ).foreach_node( [this]( auto n ) {
+      top_order.push_back( n );
+    } );
+
+    /* match cuts with gates */
+    compute_matches();
+
+    /* init the data structure */
+    init_nodes();
+
+    /* execute mapping */
+    if ( !execute_mapping() )
+      return res;
+
+    /* insert buffers for POs driven by PIs */
+    insert_buffers();
+
+    /* generate the output network */
+    finalize_cover<seq_map_ntk_t>( res, old2new );
+
+    return res;
+  }
+
+private:
+  bool execute_mapping()
+  {
+    /* compute mapping for delay */
+    if ( !ps.skip_delay_round )
+    {
+      if ( !compute_mapping<false>() )
+      {
+        return false;
+      }
+    }
+
+    /* compute mapping using global area flow */
+    while ( iteration < ps.area_flow_rounds + 1 )
+    {
+      compute_required_time();
+      if ( !compute_mapping<true>() )
+      {
+        return false;
+      }
+    }
+
+    /* compute mapping using exact area */
+    while ( iteration < ps.ela_rounds + ps.area_flow_rounds + 1 )
+    {
+      compute_required_time();
+      if ( !compute_mapping_exact<false>() )
+      {
+        return false;
+      }
+    }
+
+    /* compute mapping using exact switching activity estimation */
+    while ( iteration < ps.eswp_rounds + ps.ela_rounds + ps.area_flow_rounds + 1 )
+    {
+      compute_required_time();
+      if ( !compute_mapping_exact<true>() )
+      {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  void init_nodes()
+  {
+    ntk.foreach_node( [this]( auto const& n, auto ) {
+      const auto index = ntk.node_to_index( n );
+      auto& node_data = node_match[index];
+
+      node_data.est_refs[0] = node_data.est_refs[1] = node_data.est_refs[2] = static_cast<float>( ntk.fanout_size( n ) );
+
+      if ( ntk.is_constant( n ) )
+      {
+        /* all terminals have flow 1.0 */
+        node_data.flows[0] = node_data.flows[1] = node_data.flows[2] = 0.0f;
+        node_data.arrival[0] = node_data.arrival[1] = 0.0f;
+        match_constants( index );
+      }
+      else if ( ntk.is_ci( n ) )
+      {
+        /* all terminals have flow 1.0 */
+        node_data.flows[0] = node_data.flows[1] = node_data.flows[2] = 0.0f;
+        node_data.arrival[0] = 0.0f;
+        /* PIs have the negative phase implemented with an inverter */
+        node_data.arrival[1] = lib_inv_delay;
+      }
+    } );
+  }
+
+  void compute_matches()
+  {
+    /* match gates */
+    ntk.foreach_gate( [&]( auto const& n ) {
+      const auto index = ntk.node_to_index( n );
+
+      std::vector<cut_match_tech<NInputs>> node_matches;
+
+      auto i = 0u;
+      for ( auto& cut : cuts.cuts( index ) )
+      {
+        /* ignore unit cut */
+        if ( cut->size() == 1 && *cut->begin() == index )
+        {
+          ( *cut )->data.ignore = true;
+          continue;
+        }
+        if ( cut->size() > NInputs )
+        {
+          /* Ignore cuts too big to be mapped using the library */
+          ( *cut )->data.ignore = true;
+          continue;
+        }
+        const auto tt = cuts.truth_table( *cut );
+        const auto fe = kitty::extend_to<6>( tt );
+        auto fe_canon = fe;
+
+        uint8_t negations_pos = 0;
+        uint8_t negations_neg = 0;
+
+        /* match positive polarity */
+        if constexpr ( Configuration == classification_type::p_configurations )
+        {
+          auto canon = kitty::exact_n_canonization( fe );
+          fe_canon = std::get<0>( canon );
+          negations_pos = std::get<1>( canon );
+        }
+        auto const supergates_pos = library.get_supergates( fe_canon );
+
+        /* match negative polarity */
+        if constexpr ( Configuration == classification_type::p_configurations )
+        {
+          auto canon = kitty::exact_n_canonization( ~fe );
+          fe_canon = std::get<0>( canon );
+          negations_neg = std::get<1>( canon );
+        }
+        else
+        {
+          fe_canon = ~fe;
+        }
+        auto const supergates_neg = library.get_supergates( fe_canon );
+
+        if ( supergates_pos != nullptr || supergates_neg != nullptr )
+        {
+          cut_match_tech<NInputs> match{ { supergates_pos, supergates_neg }, { negations_pos, negations_neg } };
+
+          node_matches.push_back( match );
+          ( *cut )->data.match_index = i++;
+        }
+        else
+        {
+          /* Ignore not matched cuts */
+          ( *cut )->data.ignore = true;
+        }
+      }
+
+      matches[index] = node_matches;
+    } );
+  }
+
+  template<bool DO_AREA>
+  bool compute_mapping()
+  {
+    for ( auto const& n : top_order )
+    {
+      if ( ntk.is_constant( n ) || ntk.is_ci( n ) )
+      {
+        continue;
+      }
+
+      /* match positive phase */
+      match_phase<DO_AREA>( n, 0u );
+
+      /* match negative phase */
+      match_phase<DO_AREA>( n, 1u );
+
+      /* try to drop one phase */
+      match_drop_phase<DO_AREA, false>( n, 0 );
+    }
+
+    double area_old = area;
+    bool success = set_mapping_refs<false>();
+
+    /* round stats */
+    if ( ps.verbose )
+    {
+      std::stringstream stats{};
+      float area_gain = 0.0f;
+
+      if ( iteration != 1 )
+        area_gain = float( ( area_old - area ) / area_old * 100 );
+
+      if constexpr ( DO_AREA )
+      {
+        stats << fmt::format( "[i] AreaFlow : Delay = {:>12.2f}  Area = {:>12.2f}  {:>5.2f} %\n", delay, area, area_gain );
+      }
+      else
+      {
+        stats << fmt::format( "[i] Delay    : Delay = {:>12.2f}  Area = {:>12.2f}  {:>5.2f} %\n", delay, area, area_gain );
+      }
+      st.round_stats.push_back( stats.str() );
+    }
+
+    return success;
+  }
+
+  template<bool SwitchActivity>
+  bool compute_mapping_exact()
+  {
+    for ( auto const& n : top_order )
+    {
+      if ( ntk.is_constant( n ) || ntk.is_ci( n ) )
+        continue;
+
+      auto index = ntk.node_to_index( n );
+      auto& node_data = node_match[index];
+
+      /* recursively deselect the best cut shared between
+       * the two phases if in use in the cover */
+      if ( node_data.same_match && node_data.map_refs[2] != 0 )
+      {
+        if ( node_data.best_supergate[0] != nullptr )
+          cut_deref<SwitchActivity>( cuts.cuts( index )[node_data.best_cut[0]], n, 0u );
+        else
+          cut_deref<SwitchActivity>( cuts.cuts( index )[node_data.best_cut[1]], n, 1u );
+      }
+
+      /* match positive phase */
+      match_phase_exact<SwitchActivity>( n, 0u );
+
+      /* match negative phase */
+      match_phase_exact<SwitchActivity>( n, 1u );
+
+      /* try to drop one phase */
+      match_drop_phase<true, true>( n, 0 );
+    }
+
+    double area_old = area;
+    bool success = set_mapping_refs<true>();
+
+    /* round stats */
+    if ( ps.verbose )
+    {
+      float area_gain = float( ( area_old - area ) / area_old * 100 );
+      std::stringstream stats{};
+      if constexpr ( SwitchActivity )
+        stats << fmt::format( "[i] Switching: Delay = {:>12.2f}  Area = {:>12.2f}  {:>5.2f} %\n", delay, area, area_gain );
+      else
+        stats << fmt::format( "[i] Area     : Delay = {:>12.2f}  Area = {:>12.2f}  {:>5.2f} %\n", delay, area, area_gain );
+      st.round_stats.push_back( stats.str() );
+    }
+
+    return success;
+  }
+
+  template<bool ELA>
+  bool set_mapping_refs()
+  {
+    const auto coef = 1.0f / ( 2.0f + ( iteration + 1 ) * ( iteration + 1 ) );
+
+    if constexpr ( !ELA )
+    {
+      for ( auto i = 0u; i < node_match.size(); ++i )
+      {
+        node_match[i].map_refs[0] = node_match[i].map_refs[1] = node_match[i].map_refs[2] = 0u;
+      }
+    }
+
+    /* compute the current worst delay and update the mapping refs */
+    delay = 0.0f;
+    ntk.foreach_co( [this]( auto s ) {
+      const auto index = ntk.node_to_index( ntk.get_node( s ) );
+
+      if ( ntk.is_complemented( s ) )
+        delay = std::max( delay, node_match[index].arrival[1] );
+      else
+        delay = std::max( delay, node_match[index].arrival[0] );
+
+      if constexpr ( !ELA )
+      {
+        node_match[index].map_refs[2]++;
+        if ( ntk.is_complemented( s ) )
+          node_match[index].map_refs[1]++;
+        else
+          node_match[index].map_refs[0]++;
+      }
+    } );
+
+    /* compute current area and update mapping refs in top-down order */
+    area = 0.0f;
+    for ( auto it = top_order.rbegin(); it != top_order.rend(); ++it )
+    {
+      const auto index = ntk.node_to_index( *it );
+      auto& node_data = node_match[index];
+
+      /* skip constants and PIs */
+      if ( ntk.is_constant( *it ) )
+      {
+        if ( node_match[index].map_refs[2] > 0u )
+        {
+          /* if used and not available in the library launch a mapping error */
+          if ( node_data.best_supergate[0] == nullptr && node_data.best_supergate[1] == nullptr )
+          {
+            std::cerr << "[i] MAP ERROR: technology library does not contain constant gates, impossible to perform mapping" << std::endl;
+            st.mapping_error = true;
+            return false;
+          }
+        }
+        continue;
+      }
+      else if ( ntk.is_ci( *it ) )
+      {
+        if ( node_match[index].map_refs[1] > 0u )
+        {
+          /* Add inverter area over the negated fanins */
+          area += lib_inv_area;
+        }
+        continue;
+      }
+
+      /* continue if not referenced in the cover */
+      if ( node_match[index].map_refs[2] == 0u )
+        continue;
+
+      unsigned use_phase = node_data.best_supergate[0] == nullptr ? 1u : 0u;
+
+      if ( node_data.best_supergate[use_phase] == nullptr )
+      {
+        /* Library is not complete, mapping is not possible */
+        std::cerr << "[i] MAP ERROR: technology library is not complete, impossible to perform mapping" << std::endl;
+        st.mapping_error = true;
+        return false;
+      }
+
+      if ( node_data.same_match || node_data.map_refs[use_phase] > 0 )
+      {
+        if constexpr ( !ELA )
+        {
+          auto const& best_cut = cuts.cuts( index )[node_data.best_cut[use_phase]];
+          auto ctr = 0u;
+
+          for ( auto const leaf : best_cut )
+          {
+            node_match[leaf].map_refs[2]++;
+            if ( ( node_data.phase[use_phase] >> ctr++ ) & 1 )
+              node_match[leaf].map_refs[1]++;
+            else
+              node_match[leaf].map_refs[0]++;
+          }
+        }
+        area += node_data.area[use_phase];
+        if ( node_data.same_match && node_data.map_refs[use_phase ^ 1] > 0 )
+        {
+          area += lib_inv_area;
+        }
+      }
+
+      /* invert the phase */
+      use_phase = use_phase ^ 1;
+
+      /* if both phases are implemented and used */
+      if ( !node_data.same_match && node_data.map_refs[use_phase] > 0 )
+      {
+        if constexpr ( !ELA )
+        {
+          auto const& best_cut = cuts.cuts( index )[node_data.best_cut[use_phase]];
+          auto ctr = 0u;
+          for ( auto const leaf : best_cut )
+          {
+            node_match[leaf].map_refs[2]++;
+            if ( ( node_data.phase[use_phase] >> ctr++ ) & 1 )
+              node_match[leaf].map_refs[1]++;
+            else
+              node_match[leaf].map_refs[0]++;
+          }
+        }
+        area += node_data.area[use_phase];
+      }
+    }
+
+    /* blend estimated references */
+    for ( auto i = 0u; i < ntk.size(); ++i )
+    {
+      node_match[i].est_refs[2] = coef * node_match[i].est_refs[2] + ( 1.0f - coef ) * std::max( 1.0f, static_cast<float>( node_match[i].map_refs[2] ) );
+      node_match[i].est_refs[1] = coef * node_match[i].est_refs[1] + ( 1.0f - coef ) * std::max( 1.0f, static_cast<float>( node_match[i].map_refs[1] ) );
+      node_match[i].est_refs[0] = coef * node_match[i].est_refs[0] + ( 1.0f - coef ) * std::max( 1.0f, static_cast<float>( node_match[i].map_refs[0] ) );
+    }
+
+    ++iteration;
+    return true;
+  }
+
+  void compute_required_time()
+  {
+    for ( auto i = 0u; i < node_match.size(); ++i )
+    {
+      node_match[i].required[0] = node_match[i].required[1] = std::numeric_limits<double>::max();
+    }
+
+    /* return in case of `skip_delay_round` */
+    if ( iteration == 0 )
+      return;
+
+    auto required = delay;
+
+    if ( ps.required_time != 0.0f )
+    {
+      /* Global target time constraint */
+      if ( ps.required_time < delay - epsilon )
+      {
+        if ( !ps.skip_delay_round && iteration == 1 )
+          std::cerr << fmt::format( "[i] MAP WARNING: cannot meet the target required time of {:.2f}", ps.required_time ) << std::endl;
+      }
+      else
+      {
+        required = ps.required_time;
+      }
+    }
+
+    /* set the required time at POs */
+    ntk.foreach_co( [&]( auto const& s ) {
+      const auto index = ntk.node_to_index( ntk.get_node( s ) );
+      if ( ntk.is_complemented( s ) )
+        node_match[index].required[1] = required;
+      else
+        node_match[index].required[0] = required;
+    } );
+
+    /* propagate required time to the PIs */
+    for ( auto it = top_order.rbegin(); it != top_order.rend(); ++it )
+    {
+      if ( ntk.is_ci( *it ) || ntk.is_constant( *it ) )
+        break;
+
+      const auto index = ntk.node_to_index( *it );
+
+      if ( node_match[index].map_refs[2] == 0 )
+        continue;
+
+      auto& node_data = node_match[index];
+
+      unsigned use_phase = node_data.best_supergate[0] == nullptr ? 1u : 0u;
+      unsigned other_phase = use_phase ^ 1;
+
+      assert( node_data.best_supergate[0] != nullptr || node_data.best_supergate[1] != nullptr );
+      assert( node_data.map_refs[0] || node_data.map_refs[1] );
+
+      /* propagate required time over the output inverter if present */
+      if ( node_data.same_match && node_data.map_refs[other_phase] > 0 )
+      {
+        node_data.required[use_phase] = std::min( node_data.required[use_phase], node_data.required[other_phase] - lib_inv_delay );
+      }
+
+      if ( node_data.same_match || node_data.map_refs[use_phase] > 0 )
+      {
+        auto ctr = 0u;
+        auto best_cut = cuts.cuts( index )[node_data.best_cut[use_phase]];
+        auto const& supergate = node_data.best_supergate[use_phase];
+        for ( auto leaf : best_cut )
+        {
+          auto phase = ( node_data.phase[use_phase] >> ctr ) & 1;
+          node_match[leaf].required[phase] = std::min( node_match[leaf].required[phase], node_data.required[use_phase] - supergate->tdelay[ctr] );
+          ++ctr;
+        }
+      }
+
+      if ( !node_data.same_match && node_data.map_refs[other_phase] > 0 )
+      {
+        auto ctr = 0u;
+        auto best_cut = cuts.cuts( index )[node_data.best_cut[other_phase]];
+        auto const& supergate = node_data.best_supergate[other_phase];
+        for ( auto leaf : best_cut )
+        {
+          auto phase = ( node_data.phase[other_phase] >> ctr ) & 1;
+          node_match[leaf].required[phase] = std::min( node_match[leaf].required[phase], node_data.required[other_phase] - supergate->tdelay[ctr] );
+          ++ctr;
+        }
+      }
+    }
+  }
+
+  template<bool DO_AREA>
+  void match_phase( node<Ntk> const& n, uint8_t phase )
+  {
+    double best_arrival = std::numeric_limits<double>::max();
+    double best_area_flow = std::numeric_limits<double>::max();
+    float best_area = std::numeric_limits<float>::max();
+    uint32_t best_size = UINT32_MAX;
+    uint8_t best_cut = 0u;
+    uint8_t best_phase = 0u;
+    uint8_t cut_index = 0u;
+    auto index = ntk.node_to_index( n );
+
+    auto& node_data = node_match[index];
+    auto& cut_matches = matches[index];
+    supergate<NInputs> const* best_supergate = node_data.best_supergate[phase];
+
+    /* recompute best match info */
+    if ( best_supergate != nullptr )
+    {
+      auto const& cut = cuts.cuts( index )[node_data.best_cut[phase]];
+
+      best_phase = node_data.phase[phase];
+      best_arrival = 0.0f;
+      best_area_flow = best_supergate->area + cut_leaves_flow( cut, n, phase );
+      best_area = best_supergate->area;
+      best_cut = node_data.best_cut[phase];
+      best_size = cut.size();
+
+      auto ctr = 0u;
+      for ( auto l : cut )
+      {
+        double arrival_pin = node_match[l].arrival[( best_phase >> ctr ) & 1] + best_supergate->tdelay[ctr];
+        best_arrival = std::max( best_arrival, arrival_pin );
+        ++ctr;
+      }
+    }
+
+    /* foreach cut */
+    for ( auto& cut : cuts.cuts( index ) )
+    {
+      /* trivial cuts or not matched cuts */
+      if ( ( *cut )->data.ignore )
+      {
+        ++cut_index;
+        continue;
+      }
+
+      auto const& supergates = cut_matches[( *cut )->data.match_index].supergates;
+      auto const negation = cut_matches[( *cut )->data.match_index].negations[phase];
+
+      if ( supergates[phase] == nullptr )
+      {
+        ++cut_index;
+        continue;
+      }
+
+      /* match each gate and take the best one */
+      for ( auto const& gate : *supergates[phase] )
+      {
+        uint8_t gate_polarity = gate.polarity ^ negation;
+        node_data.phase[phase] = gate_polarity;
+        double area_local = gate.area + cut_leaves_flow( *cut, n, phase );
+        double worst_arrival = 0.0f;
+
+        auto ctr = 0u;
+        for ( auto l : *cut )
+        {
+          double arrival_pin = node_match[l].arrival[( gate_polarity >> ctr ) & 1] + gate.tdelay[ctr];
+          worst_arrival = std::max( worst_arrival, arrival_pin );
+          ++ctr;
+        }
+
+        if constexpr ( DO_AREA )
+        {
+          if ( worst_arrival > node_data.required[phase] + epsilon )
+            continue;
+        }
+
+        if ( compare_map<DO_AREA>( worst_arrival, best_arrival, area_local, best_area_flow, cut->size(), best_size ) )
+        {
+          best_arrival = worst_arrival;
+          best_area_flow = area_local;
+          best_size = cut->size();
+          best_cut = cut_index;
+          best_area = gate.area;
+          best_phase = gate_polarity;
+          best_supergate = &gate;
+        }
+      }
+
+      ++cut_index;
+    }
+
+    node_data.flows[phase] = best_area_flow;
+    node_data.arrival[phase] = best_arrival;
+    node_data.area[phase] = best_area;
+    node_data.best_cut[phase] = best_cut;
+    node_data.phase[phase] = best_phase;
+    node_data.best_supergate[phase] = best_supergate;
+  }
+
+  template<bool SwitchActivity>
+  void match_phase_exact( node<Ntk> const& n, uint8_t phase )
+  {
+    double best_arrival = std::numeric_limits<double>::max();
+    float best_exact_area = std::numeric_limits<float>::max();
+    float best_area = std::numeric_limits<float>::max();
+    uint32_t best_size = UINT32_MAX;
+    uint8_t best_cut = 0u;
+    uint8_t best_phase = 0u;
+    uint8_t cut_index = 0u;
+    auto index = ntk.node_to_index( n );
+
+    auto& node_data = node_match[index];
+    auto& cut_matches = matches[index];
+    supergate<NInputs> const* best_supergate = node_data.best_supergate[phase];
+
+    /* recompute best match info */
+    if ( best_supergate != nullptr )
+    {
+      auto const& cut = cuts.cuts( index )[node_data.best_cut[phase]];
+
+      best_phase = node_data.phase[phase];
+      best_arrival = 0.0f;
+      best_area = best_supergate->area;
+      best_cut = node_data.best_cut[phase];
+      best_size = cut.size();
+
+      auto ctr = 0u;
+      for ( auto l : cut )
+      {
+        double arrival_pin = node_match[l].arrival[( best_phase >> ctr ) & 1] + best_supergate->tdelay[ctr];
+        best_arrival = std::max( best_arrival, arrival_pin );
+        ++ctr;
+      }
+
+      /* if cut is implemented, remove it from the cover */
+      if ( !node_data.same_match && node_data.map_refs[phase] )
+      {
+        best_exact_area = cut_deref<SwitchActivity>( cuts.cuts( index )[best_cut], n, phase );
+      }
+      else
+      {
+        best_exact_area = cut_ref<SwitchActivity>( cuts.cuts( index )[best_cut], n, phase );
+        cut_deref<SwitchActivity>( cuts.cuts( index )[best_cut], n, phase );
+      }
+    }
+
+    /* foreach cut */
+    for ( auto& cut : cuts.cuts( index ) )
+    {
+      /* trivial cuts or not matched cuts */
+      if ( ( *cut )->data.ignore )
+      {
+        ++cut_index;
+        continue;
+      }
+
+      auto const& supergates = cut_matches[( *cut )->data.match_index].supergates;
+      auto const negation = cut_matches[( *cut )->data.match_index].negations[phase];
+
+      if ( supergates[phase] == nullptr )
+      {
+        ++cut_index;
+        continue;
+      }
+
+      /* match each gate and take the best one */
+      for ( auto const& gate : *supergates[phase] )
+      {
+        uint8_t gate_polarity = gate.polarity ^ negation;
+        node_data.phase[phase] = gate_polarity;
+        node_data.area[phase] = gate.area;
+        float area_exact = cut_ref<SwitchActivity>( *cut, n, phase );
+        cut_deref<SwitchActivity>( *cut, n, phase );
+        double worst_arrival = 0.0f;
+
+        auto ctr = 0u;
+        for ( auto l : *cut )
+        {
+          double arrival_pin = node_match[l].arrival[( gate_polarity >> ctr ) & 1] + gate.tdelay[ctr];
+          worst_arrival = std::max( worst_arrival, arrival_pin );
+          ++ctr;
+        }
+
+        if ( worst_arrival > node_data.required[phase] + epsilon )
+          continue;
+
+        if ( compare_map<true>( worst_arrival, best_arrival, area_exact, best_exact_area, cut->size(), best_size ) )
+        {
+          best_arrival = worst_arrival;
+          best_exact_area = area_exact;
+          best_area = gate.area;
+          best_size = cut->size();
+          best_cut = cut_index;
+          best_phase = gate_polarity;
+          best_supergate = &gate;
+        }
+      }
+
+      ++cut_index;
+    }
+
+    node_data.flows[phase] = best_exact_area;
+    node_data.arrival[phase] = best_arrival;
+    node_data.area[phase] = best_area;
+    node_data.best_cut[phase] = best_cut;
+    node_data.phase[phase] = best_phase;
+    node_data.best_supergate[phase] = best_supergate;
+
+    if ( !node_data.same_match && node_data.map_refs[phase] )
+    {
+      best_exact_area = cut_ref<SwitchActivity>( cuts.cuts( index )[best_cut], n, phase );
+    }
+  }
+
+  template<bool DO_AREA, bool ELA>
+  void match_drop_phase( node<Ntk> const& n, float required_margin_factor )
+  {
+    auto index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+
+    /* compute arrival adding an inverter to the other match phase */
+    double worst_arrival_npos = node_data.arrival[1] + lib_inv_delay;
+    double worst_arrival_nneg = node_data.arrival[0] + lib_inv_delay;
+    bool use_zero = false;
+    bool use_one = false;
+
+    /* only one phase is matched */
+    if ( node_data.best_supergate[0] == nullptr )
+    {
+      set_match_complemented_phase( index, 1, worst_arrival_npos );
+      if constexpr ( ELA )
+      {
+        if ( node_data.map_refs[2] )
+          cut_ref<false>( cuts.cuts( index )[node_data.best_cut[1]], n, 1 );
+      }
+      return;
+    }
+    else if ( node_data.best_supergate[1] == nullptr )
+    {
+      set_match_complemented_phase( index, 0, worst_arrival_nneg );
+      if constexpr ( ELA )
+      {
+        if ( node_data.map_refs[2] )
+          cut_ref<false>( cuts.cuts( index )[node_data.best_cut[0]], n, 0 );
+      }
+      return;
+    }
+
+    /* try to use only one match to cover both phases */
+    if constexpr ( !DO_AREA )
+    {
+      /* if arrival improves matching the other phase and inserting an inverter */
+      if ( worst_arrival_npos < node_data.arrival[0] + epsilon )
+      {
+        use_one = true;
+      }
+      if ( worst_arrival_nneg < node_data.arrival[1] + epsilon )
+      {
+        use_zero = true;
+      }
+    }
+    else
+    {
+      /* check if both phases + inverter meet the required time */
+      use_zero = worst_arrival_nneg < ( node_data.required[1] + epsilon - required_margin_factor * lib_inv_delay );
+      use_one = worst_arrival_npos < ( node_data.required[0] + epsilon - required_margin_factor * lib_inv_delay );
+    }
+
+    /* condition on not used phases, evaluate a substitution during exact area recovery */
+    if constexpr ( ELA )
+    {
+      if ( iteration != 0 )
+      {
+        if ( node_data.map_refs[0] == 0 || node_data.map_refs[1] == 0 )
+        {
+          /* select the used match */
+          auto phase = 0;
+          auto nphase = 0;
+          if ( node_data.map_refs[0] == 0 )
+          {
+            phase = 1;
+            use_one = true;
+            use_zero = false;
+          }
+          else
+          {
+            nphase = 1;
+            use_one = false;
+            use_zero = true;
+          }
+          /* select the not used match instead if it leads to area improvement and doesn't violate the required time */
+          if ( node_data.arrival[nphase] + lib_inv_delay < node_data.required[phase] + epsilon )
+          {
+            auto size_phase = cuts.cuts( index )[node_data.best_cut[phase]].size();
+            auto size_nphase = cuts.cuts( index )[node_data.best_cut[nphase]].size();
+
+            if ( compare_map<DO_AREA>( node_data.arrival[nphase] + lib_inv_delay, node_data.arrival[phase], node_data.flows[nphase] + lib_inv_area, node_data.flows[phase], size_nphase, size_phase ) )
+            {
+              /* invert the choice */
+              use_zero = !use_zero;
+              use_one = !use_one;
+            }
+          }
+        }
+      }
+    }
+
+    if ( !use_zero && !use_one )
+    {
+      /* use both phases */
+      node_data.flows[0] = node_data.flows[0] / node_data.est_refs[0];
+      node_data.flows[1] = node_data.flows[1] / node_data.est_refs[1];
+      node_data.flows[2] = node_data.flows[0] + node_data.flows[1];
+      node_data.same_match = false;
+      return;
+    }
+
+    /* use area flow as a tiebreaker */
+    if ( use_zero && use_one )
+    {
+      auto size_zero = cuts.cuts( index )[node_data.best_cut[0]].size();
+      auto size_one = cuts.cuts( index )[node_data.best_cut[1]].size();
+      if ( compare_map<DO_AREA>( worst_arrival_nneg, worst_arrival_npos, node_data.flows[0], node_data.flows[1], size_zero, size_one ) )
+        use_one = false;
+      else
+        use_zero = false;
+    }
+
+    if ( use_zero )
+    {
+      if constexpr ( ELA )
+      {
+        /* set cut references */
+        if ( !node_data.same_match )
+        {
+          /* dereference the negative phase cut if in use */
+          if ( node_data.map_refs[1] > 0 )
+            cut_deref<false>( cuts.cuts( index )[node_data.best_cut[1]], n, 1 );
+          /* reference the positive cut if not in use before */
+          if ( node_data.map_refs[0] == 0 && node_data.map_refs[2] )
+            cut_ref<false>( cuts.cuts( index )[node_data.best_cut[0]], n, 0 );
+        }
+        else if ( node_data.map_refs[2] )
+          cut_ref<false>( cuts.cuts( index )[node_data.best_cut[0]], n, 0 );
+      }
+      set_match_complemented_phase( index, 0, worst_arrival_nneg );
+    }
+    else
+    {
+      if constexpr ( ELA )
+      {
+        /* set cut references */
+        if ( !node_data.same_match )
+        {
+          /* dereference the positive phase cut if in use */
+          if ( node_data.map_refs[0] > 0 )
+            cut_deref<false>( cuts.cuts( index )[node_data.best_cut[0]], n, 0 );
+          /* reference the negative cut if not in use before */
+          if ( node_data.map_refs[1] == 0 && node_data.map_refs[2] )
+            cut_ref<false>( cuts.cuts( index )[node_data.best_cut[1]], n, 1 );
+        }
+        else if ( node_data.map_refs[2] )
+          cut_ref<false>( cuts.cuts( index )[node_data.best_cut[1]], n, 1 );
+      }
+      set_match_complemented_phase( index, 1, worst_arrival_npos );
+    }
+  }
+
+  inline void set_match_complemented_phase( uint32_t index, uint8_t phase, double worst_arrival_n )
+  {
+    auto& node_data = node_match[index];
+    auto phase_n = phase ^ 1;
+    node_data.same_match = true;
+    node_data.best_supergate[phase_n] = nullptr;
+    node_data.best_cut[phase_n] = node_data.best_cut[phase];
+    node_data.phase[phase_n] = node_data.phase[phase];
+    node_data.arrival[phase_n] = worst_arrival_n;
+    node_data.area[phase_n] = node_data.area[phase];
+    node_data.flows[phase] = node_data.flows[phase] / node_data.est_refs[2];
+    node_data.flows[phase_n] = node_data.flows[phase];
+    node_data.flows[2] = node_data.flows[phase];
+  }
+
+  void match_constants( uint32_t index )
+  {
+    auto& node_data = node_match[index];
+
+    kitty::static_truth_table<6> zero_tt;
+    auto const supergates_zero = library.get_supergates( zero_tt );
+    auto const supergates_one = library.get_supergates( ~zero_tt );
+
+    /* Not available in the library */
+    if ( supergates_zero == nullptr && supergates_one == nullptr )
+    {
+      return;
+    }
+    /* if only one is available, the other is obtained using an inverter */
+    if ( supergates_zero != nullptr )
+    {
+      node_data.best_supergate[0] = &( ( *supergates_zero )[0] );
+      node_data.arrival[0] = node_data.best_supergate[0]->tdelay[0];
+      node_data.area[0] = node_data.best_supergate[0]->area;
+      node_data.phase[0] = 0;
+    }
+    if ( supergates_one != nullptr )
+    {
+      node_data.best_supergate[1] = &( ( *supergates_one )[0] );
+      node_data.arrival[1] = node_data.best_supergate[1]->tdelay[0];
+      node_data.area[1] = node_data.best_supergate[1]->area;
+      node_data.phase[1] = 0;
+    }
+    else
+    {
+      node_data.same_match = true;
+      node_data.arrival[1] = node_data.arrival[0] + lib_inv_delay;
+      node_data.area[1] = node_data.area[0] + lib_inv_area;
+      node_data.phase[1] = 1;
+    }
+    if ( supergates_zero == nullptr )
+    {
+      node_data.same_match = true;
+      node_data.arrival[0] = node_data.arrival[1] + lib_inv_delay;
+      node_data.area[0] = node_data.area[1] + lib_inv_area;
+      node_data.phase[0] = 1;
+    }
+  }
+
+  inline double cut_leaves_flow( cut_t const& cut, node<Ntk> const& n, uint8_t phase )
+  {
+    double flow{ 0.0f };
+    auto const& node_data = node_match[ntk.node_to_index( n )];
+
+    uint8_t ctr = 0u;
+    for ( auto leaf : cut )
+    {
+      uint8_t leaf_phase = ( node_data.phase[phase] >> ctr++ ) & 1;
+      flow += node_match[leaf].flows[leaf_phase];
+    }
+
+    return flow;
+  }
+
+  template<bool SwitchActivity>
+  float cut_ref( cut_t const& cut, node<Ntk> const& n, uint8_t phase )
+  {
+    auto const& node_data = node_match[ntk.node_to_index( n )];
+    float count;
+
+    if constexpr ( SwitchActivity )
+      count = switch_activity[ntk.node_to_index( n )];
+    else
+      count = node_data.area[phase];
+
+    uint8_t ctr = 0;
+    for ( auto leaf : cut )
+    {
+      /* compute leaf phase using the current gate */
+      uint8_t leaf_phase = ( node_data.phase[phase] >> ctr++ ) & 1;
+
+      if ( ntk.is_constant( ntk.index_to_node( leaf ) ) )
+      {
+        continue;
+      }
+      else if ( ntk.is_ci( ntk.index_to_node( leaf ) ) )
+      {
+        /* reference PIs, add inverter cost for negative phase */
+        if ( leaf_phase == 1u )
+        {
+          if ( node_match[leaf].map_refs[1]++ == 0u )
+          {
+            if constexpr ( SwitchActivity )
+              count += switch_activity[leaf];
+            else
+              count += lib_inv_area;
+          }
+        }
+        else
+        {
+          ++node_match[leaf].map_refs[0];
+        }
+        continue;
+      }
+
+      if ( node_match[leaf].same_match )
+      {
+        /* Add inverter area if not present yet and leaf node is implemented in the opposite phase */
+        if ( node_match[leaf].map_refs[leaf_phase]++ == 0u && node_match[leaf].best_supergate[leaf_phase] == nullptr )
+        {
+          if constexpr ( SwitchActivity )
+            count += switch_activity[leaf];
+          else
+            count += lib_inv_area;
+        }
+        /* Recursive referencing if leaf was not referenced */
+        if ( node_match[leaf].map_refs[2]++ == 0u )
+        {
+          count += cut_ref<SwitchActivity>( cuts.cuts( leaf )[node_match[leaf].best_cut[leaf_phase]], ntk.index_to_node( leaf ), leaf_phase );
+        }
+      }
+      else
+      {
+        ++node_match[leaf].map_refs[2];
+        if ( node_match[leaf].map_refs[leaf_phase]++ == 0u )
+        {
+          count += cut_ref<SwitchActivity>( cuts.cuts( leaf )[node_match[leaf].best_cut[leaf_phase]], ntk.index_to_node( leaf ), leaf_phase );
+        }
+      }
+    }
+    return count;
+  }
+
+  template<bool SwitchActivity>
+  float cut_deref( cut_t const& cut, node<Ntk> const& n, uint8_t phase )
+  {
+    auto const& node_data = node_match[ntk.node_to_index( n )];
+    float count;
+
+    if constexpr ( SwitchActivity )
+      count = switch_activity[ntk.node_to_index( n )];
+    else
+      count = node_data.area[phase];
+
+    uint8_t ctr = 0;
+    for ( auto leaf : cut )
+    {
+      /* compute leaf phase using the current gate */
+      uint8_t leaf_phase = ( node_data.phase[phase] >> ctr++ ) & 1;
+
+      if ( ntk.is_constant( ntk.index_to_node( leaf ) ) )
+      {
+        continue;
+      }
+      else if ( ntk.is_ci( ntk.index_to_node( leaf ) ) )
+      {
+        /* dereference PIs, add inverter cost for negative phase */
+        if ( leaf_phase == 1u )
+        {
+          if ( --node_match[leaf].map_refs[1] == 0u )
+          {
+            if constexpr ( SwitchActivity )
+              count += switch_activity[leaf];
+            else
+              count += lib_inv_area;
+          }
+        }
+        else
+        {
+          --node_match[leaf].map_refs[0];
+        }
+        continue;
+      }
+
+      if ( node_match[leaf].same_match )
+      {
+        /* Add inverter area if it is used only by the current gate and leaf node is implemented in the opposite phase */
+        if ( --node_match[leaf].map_refs[leaf_phase] == 0u && node_match[leaf].best_supergate[leaf_phase] == nullptr )
+        {
+          if constexpr ( SwitchActivity )
+            count += switch_activity[leaf];
+          else
+            count += lib_inv_area;
+        }
+        /* Recursive dereferencing */
+        if ( --node_match[leaf].map_refs[2] == 0u )
+        {
+          count += cut_deref<SwitchActivity>( cuts.cuts( leaf )[node_match[leaf].best_cut[leaf_phase]], ntk.index_to_node( leaf ), leaf_phase );
+        }
+      }
+      else
+      {
+        --node_match[leaf].map_refs[2];
+        if ( --node_match[leaf].map_refs[leaf_phase] == 0u )
+        {
+          count += cut_deref<SwitchActivity>( cuts.cuts( leaf )[node_match[leaf].best_cut[leaf_phase]], ntk.index_to_node( leaf ), leaf_phase );
+        }
+      }
+    }
+    return count;
+  }
+
+  void insert_buffers()
+  {
+    if ( lib_buf_id != UINT32_MAX )
+    {
+      double area_old = area;
+      bool buffers = false;
+
+      ntk.foreach_co( [&]( auto const& f ) {
+        auto const& n = ntk.get_node( f );
+        if ( !ntk.is_constant( n ) && ntk.is_ci( n ) && !ntk.is_complemented( f ) )
+        {
+          area += lib_buf_area;
+          delay = std::max( delay, node_match[ntk.node_to_index( n )].arrival[0] + lib_inv_delay );
+          buffers = true;
+        }
+      } );
+
+      /* round stats */
+      if ( ps.verbose && buffers )
+      {
+        std::stringstream stats{};
+        float area_gain = 0.0f;
+
+        area_gain = float( ( area_old - area ) / area_old * 100 );
+
+        stats << fmt::format( "[i] Buffering: Delay = {:>12.2f}  Area = {:>12.2f}  {:>5.2f} %\n", delay, area, area_gain );
+        st.round_stats.push_back( stats.str() );
+      }
+    }
+  }
+
+  std::pair<map_ntk_t, klut_map> initialize_map_network()
+  {
+    map_ntk_t dest( library.get_gates() );
+    klut_map old2new;
+
+    old2new[ntk.node_to_index( ntk.get_node( ntk.get_constant( false ) ) )][0] = dest.get_constant( false );
+    old2new[ntk.node_to_index( ntk.get_node( ntk.get_constant( false ) ) )][1] = dest.get_constant( true );
+
+    ntk.foreach_pi( [&]( auto const& n ) {
+      old2new[ntk.node_to_index( n )][0] = dest.create_pi();
+    } );
+
+    return { dest, old2new };
+  }
+
+  std::pair<seq_map_ntk_t, klut_map> initialize_map_seq_network()
+  {
+    seq_map_ntk_t dest( library.get_gates() );
+    klut_map old2new;
+
+    old2new[ntk.node_to_index( ntk.get_node( ntk.get_constant( false ) ) )][0] = dest.get_constant( false );
+    old2new[ntk.node_to_index( ntk.get_node( ntk.get_constant( false ) ) )][1] = dest.get_constant( true );
+
+    ntk.foreach_pi( [&]( auto const& n ) {
+      old2new[ntk.node_to_index( n )][0] = dest.create_pi();
+    } );
+    ntk.foreach_ro( [&]( auto const& n ) {
+      old2new[ntk.node_to_index( n )][0] = dest.create_ro();
+    } );
+
+    return { dest, old2new };
+  }
+
+  template<class NtkDest>
+  void finalize_cover( NtkDest& res, klut_map& old2new )
+  {
+    for ( auto const& n : top_order )
+    {
+      auto index = ntk.node_to_index( n );
+      auto const& node_data = node_match[index];
+
+      /* add inverter at PI if needed */
+      if ( ntk.is_constant( n ) )
+      {
+        if ( node_data.best_supergate[0] == nullptr && node_data.best_supergate[1] == nullptr )
+          continue;
+      }
+      else if ( ntk.is_ci( n ) )
+      {
+        if ( node_data.map_refs[1] > 0 )
+        {
+          old2new[index][1] = res.create_not( old2new[n][0] );
+          res.add_binding( res.get_node( old2new[index][1] ), lib_inv_id );
+        }
+        continue;
+      }
+
+      /* continue if cut is not in the cover */
+      if ( node_data.map_refs[2] == 0u )
+        continue;
+
+      unsigned phase = ( node_data.best_supergate[0] != nullptr ) ? 0 : 1;
+
+      /* add used cut */
+      if ( node_data.same_match || node_data.map_refs[phase] > 0 )
+      {
+        create_lut_for_gate<NtkDest>( res, old2new, index, phase );
+
+        /* add inverted version if used */
+        if ( node_data.same_match && node_data.map_refs[phase ^ 1] > 0 )
+        {
+          old2new[index][phase ^ 1] = res.create_not( old2new[index][phase] );
+          res.add_binding( res.get_node( old2new[index][phase ^ 1] ), lib_inv_id );
+        }
+      }
+
+      phase = phase ^ 1;
+      /* add the optional other match if used */
+      if ( !node_data.same_match && node_data.map_refs[phase] > 0 )
+      {
+        create_lut_for_gate<NtkDest>( res, old2new, index, phase );
+      }
+    }
+
+    /* create POs */
+    ntk.foreach_po( [&]( auto const& f ) {
+      if ( ntk.is_complemented( f ) )
+      {
+        res.create_po( old2new[ntk.node_to_index( ntk.get_node( f ) )][1] );
+      }
+      else if ( !ntk.is_constant( ntk.get_node( f ) ) && ntk.is_ci( ntk.get_node( f ) ) && lib_buf_id != UINT32_MAX )
+      {
+        /* create buffers for POs */
+        static uint64_t _buf = 0x2;
+        kitty::dynamic_truth_table tt_buf( 1 );
+        kitty::create_from_words( tt_buf, &_buf, &_buf + 1 );
+        const auto buf = res.create_node( { old2new[ntk.node_to_index( ntk.get_node( f ) )][0] }, tt_buf );
+        res.create_po( buf );
+        res.add_binding( res.get_node( buf ), lib_buf_id );
+      }
+      else
+      {
+        res.create_po( old2new[ntk.node_to_index( ntk.get_node( f ) )][0] );
+      }
+    } );
+
+    if constexpr ( has_foreach_ri_v<Ntk> )
+    {
+      ntk.foreach_ri( [&]( auto const& f ) {
+        if ( ntk.is_complemented( f ) )
+        {
+          res.create_ri( old2new[ntk.node_to_index( ntk.get_node( f ) )][1] );
+        }
+        else if ( !ntk.is_constant( ntk.get_node( f ) ) && ntk.is_ci( ntk.get_node( f ) ) && lib_buf_id != UINT32_MAX )
+        {
+          /* create buffers for RIs */
+          static uint64_t _buf = 0x2;
+          kitty::dynamic_truth_table tt_buf( 1 );
+          kitty::create_from_words( tt_buf, &_buf, &_buf + 1 );
+          const auto buf = res.create_node( { old2new[ntk.node_to_index( ntk.get_node( f ) )][0] }, tt_buf );
+          res.create_ri( buf );
+          res.add_binding( res.get_node( buf ), lib_buf_id );
+        }
+        else
+        {
+          res.create_ri( old2new[ntk.node_to_index( ntk.get_node( f ) )][0] );
+        }
+      } );
+    }
+
+    /* write final results */
+    st.area = area;
+    st.delay = delay;
+    if ( ps.eswp_rounds )
+      st.power = compute_switching_power();
+  }
+
+  template<class NtkDest>
+  void create_lut_for_gate( NtkDest& res, klut_map& old2new, uint32_t index, unsigned phase )
+  {
+    auto const& node_data = node_match[index];
+    auto& best_cut = cuts.cuts( index )[node_data.best_cut[phase]];
+    auto const& gate = node_data.best_supergate[phase]->root;
+
+    /* permutate and negate to obtain the matched gate truth table */
+    std::vector<signal<klut_network>> children( gate->num_vars );
+
+    auto ctr = 0u;
+    for ( auto l : best_cut )
+    {
+      if ( ctr >= gate->num_vars )
+        break;
+      children[node_data.best_supergate[phase]->permutation[ctr]] = old2new[l][( node_data.phase[phase] >> ctr ) & 1];
+      ++ctr;
+    }
+
+    if ( !gate->is_super )
+    {
+      /* create the node */
+      auto f = res.create_node( children, gate->function );
+      res.add_binding( res.get_node( f ), gate->root->id );
+
+      /* add the node in the data structure */
+      old2new[index][phase] = f;
+    }
+    else
+    {
+      /* supergate, create sub-gates */
+      auto f = create_lut_for_gate_rec<NtkDest>( res, *gate, children );
+
+      /* add the node in the data structure */
+      old2new[index][phase] = f;
+    }
+  }
+
+  template<class NtkDest>
+  signal<klut_network> create_lut_for_gate_rec( NtkDest& res, composed_gate<NInputs> const& gate, std::vector<signal<klut_network>> const& children )
+  {
+    std::vector<signal<klut_network>> children_local( gate.fanin.size() );
+
+    auto i = 0u;
+    for ( auto const fanin : gate.fanin )
+    {
+      if ( fanin->root == nullptr )
+      {
+        /* terminal condition */
+        children_local[i] = children[fanin->id];
+      }
+      else
+      {
+        children_local[i] = create_lut_for_gate_rec<NtkDest>( res, *fanin, children );
+      }
+      ++i;
+    }
+
+    auto f = res.create_node( children_local, gate.root->function );
+    res.add_binding( res.get_node( f ), gate.root->id );
+    return f;
+  }
+
+  template<bool DO_AREA>
+  inline bool compare_map( double arrival, double best_arrival, double area_flow, double best_area_flow, uint32_t size, uint32_t best_size )
+  {
+    if constexpr ( DO_AREA )
+    {
+      if ( area_flow < best_area_flow - epsilon )
+      {
+        return true;
+      }
+      else if ( area_flow > best_area_flow + epsilon )
+      {
+        return false;
+      }
+      else if ( arrival < best_arrival - epsilon )
+      {
+        return true;
+      }
+      else if ( arrival > best_arrival + epsilon )
+      {
+        return false;
+      }
+    }
+    else
+    {
+      if ( arrival < best_arrival - epsilon )
+      {
+        return true;
+      }
+      else if ( arrival > best_arrival + epsilon )
+      {
+        return false;
+      }
+      else if ( area_flow < best_area_flow - epsilon )
+      {
+        return true;
+      }
+      else if ( area_flow > best_area_flow + epsilon )
+      {
+        return false;
+      }
+    }
+    if ( size < best_size )
+    {
+      return true;
+    }
+    return false;
+  }
+
+  double compute_switching_power()
+  {
+    double power = 0.0f;
+
+    for ( auto const& n : top_order )
+    {
+      const auto index = ntk.node_to_index( n );
+      auto& node_data = node_match[index];
+
+      if ( ntk.is_constant( n ) )
+      {
+        if ( node_data.best_supergate[0] == nullptr && node_data.best_supergate[1] == nullptr )
+          continue;
+      }
+      else if ( ntk.is_ci( n ) )
+      {
+        if ( node_data.map_refs[1] > 0 )
+          power += switch_activity[ntk.node_to_index( n )];
+        continue;
+      }
+
+      /* continue if cut is not in the cover */
+      if ( node_match[index].map_refs[2] == 0u )
+        continue;
+
+      unsigned phase = ( node_data.best_supergate[0] != nullptr ) ? 0 : 1;
+
+      if ( node_data.same_match || node_data.map_refs[phase] > 0 )
+      {
+        power += switch_activity[ntk.node_to_index( n )];
+
+        if ( node_data.same_match && node_data.map_refs[phase ^ 1] > 0 )
+          power += switch_activity[ntk.node_to_index( n )];
+      }
+
+      phase = phase ^ 1;
+      if ( !node_data.same_match && node_data.map_refs[phase] > 0 )
+      {
+        power += switch_activity[ntk.node_to_index( n )];
+      }
+    }
+
+    return power;
+  }
+
+private:
+  Ntk const& ntk;
+  tech_library<NInputs, Configuration> const& library;
+  map_params const& ps;
+  map_stats& st;
+
+  uint32_t iteration{ 0 };       /* current mapping iteration */
+  double delay{ 0.0f };          /* current delay of the mapping */
+  double area{ 0.0f };           /* current area of the mapping */
+  const float epsilon{ 0.005f }; /* epsilon */
+
+  /* lib inverter info */
+  float lib_inv_area;
+  float lib_inv_delay;
+  uint32_t lib_inv_id;
+
+  /* lib buffer info */
+  float lib_buf_area;
+  float lib_buf_delay;
+  uint32_t lib_buf_id;
+
+  std::vector<node<Ntk>> top_order;
+  std::vector<node_match_tech<NInputs>> node_match;
+  match_map matches;
+  std::vector<float> switch_activity;
+  network_cuts_t cuts;
+};
+
+} /* namespace detail */
+
+/*! \brief Technology mapping.
+ *
+ * This function implements a technology mapping algorithm. It is controlled by a
+ * template argument `CutData` (defaulted to `cut_enumeration_tech_map_cut`).
+ * The argument is similar to the `CutData` argument in `cut_enumeration`, which can
+ * specialize the cost function to select priority cuts and store additional data.
+ * The default argument gives priority firstly to the cut size, then delay, and lastly
+ * to area flow. Thus, it is more suited for delay-oriented mapping.
+ * The type passed as `CutData` must implement the following four fields:
+ *
+ * - `uint32_t delay`
+ * - `float flow`
+ * - `uint8_t match_index`
+ * - `bool ignore`
+ *
+ * See `include/mockturtle/algorithms/cut_enumeration/cut_enumeration_tech_map_cut.hpp`
+ * for one example of a CutData type that implements the cost function that is used in
+ * the technology mapper.
+ *
+ * The function takes the size of the cuts in the template parameter `CutSize`.
+ *
+ * The function returns a k-LUT network. Each LUT abstracts a gate of the technology library.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `is_ci`
+ * - `is_constant`
+ * - `node_to_index`
+ * - `index_to_node`
+ * - `get_node`
+ * - `foreach_pi`
+ * - `foreach_po`
+ * - `foreach_co`
+ * - `foreach_node`
+ * - `fanout_size`
+ *
+ * \param ntk Network
+ * \param library Technology library
+ * \param ps Mapping params
+ * \param pst Mapping statistics
+ *
+ * The implementation of this algorithm was inspired by the
+ * mapping command ``map`` in ABC.
+ */
+template<class Ntk, unsigned CutSize = 5u, typename CutData = cut_enumeration_tech_map_cut, unsigned NInputs, classification_type Configuration>
+binding_view<klut_network> map( Ntk const& ntk, tech_library<NInputs, Configuration> const& library, map_params const& ps = {}, map_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_is_ci_v<Ntk>, "Ntk does not implement the is_ci method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+
+  map_stats st;
+  detail::tech_map_impl<Ntk, CutSize, CutData, NInputs, Configuration> p( ntk, library, ps, st );
+  auto res = p.run();
+
+  st.time_total = st.time_mapping + st.cut_enumeration_st.time_total;
+  if ( ps.verbose && !st.mapping_error )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+  return res;
+}
+
+/*! \brief Technology mapping for sequential networks.
+ *
+ * Version of `map` for technology mapping of sequential networks.
+ *
+ * The function returns a sequential k-LUT network. Each LUT abstracts a gate of the technology library.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `is_ci`
+ * - `is_constant`
+ * - `node_to_index`
+ * - `index_to_node`
+ * - `get_node`
+ * - `foreach_pi`
+ * - `foreach_po`
+ * - `foreach_ro`
+ * - `foreach_co`
+ * - `foreach_ri`
+ * - `foreach_node`
+ * - `fanout_size`
+ *
+ * \param ntk Sequential network
+ * \param library Technology library
+ * \param ps Mapping params
+ * \param pst Mapping statistics
+ *
+ */
+template<class Ntk, unsigned CutSize = 5u, typename CutData = cut_enumeration_tech_map_cut, unsigned NInputs, classification_type Configuration>
+binding_view<sequential<klut_network>> seq_map( Ntk const& ntk, tech_library<NInputs, Configuration> const& library, map_params const& ps = {}, map_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_is_ci_v<Ntk>, "Ntk does not implement the is_ci method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_co_v<Ntk>, "Ntk does not implement the foreach_co method" );
+  static_assert( has_foreach_ri_v<Ntk>, "Ntk does not implement the has_foreach_ri method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the has_foreach_po method" );
+  static_assert( has_foreach_ro_v<Ntk>, "Ntk does not implement the has_foreach_ro method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+
+  map_stats st;
+  detail::tech_map_impl<Ntk, CutSize, CutData, NInputs, Configuration> p( ntk, library, ps, st );
+  auto res = p.run_seq();
+
+  st.time_total = st.time_mapping + st.cut_enumeration_st.time_total;
+  if ( ps.verbose && !st.mapping_error )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+  return res;
+}
+
+namespace detail
+{
+
+template<typename Ntk, unsigned NInputs>
+struct cut_match_t
+{
+  /* list of supergates matching the cut for positive and negative output phases */
+  std::vector<exact_supergate<Ntk, NInputs>> const* supergates[2] = { nullptr, nullptr };
+  /* input permutations, at index i, it contains the permutated position of i */
+  std::array<uint8_t, NInputs> permutation{};
+  /* permutated input negations */
+  uint8_t negation{ 0 };
+};
+
+template<typename Ntk, unsigned NInputs>
+struct node_match_t
+{
+  /* best supergate match for positive and negative output phases */
+  exact_supergate<Ntk, NInputs> const* best_supergate[2] = { nullptr, nullptr };
+  /* fanin pin phases for both output phases */
+  uint8_t phase[2];
+  /* best cut index for both phases */
+  uint32_t best_cut[2];
+  /* node is mapped using only one phase */
+  bool same_match{ false };
+
+  /* arrival time at node output */
+  double arrival[2];
+  /* required time at node output */
+  double required[2];
+  /* area of the best matches */
+  float area[2];
+
+  /* number of references in the cover 0: pos, 1: neg, 2: pos+neg */
+  uint32_t map_refs[3];
+  /* references estimation */
+  float est_refs[3];
+  /* area flow */
+  float flows[3];
+};
+
+template<class NtkDest, unsigned CutSize, typename CutData, class Ntk, unsigned NInputs>
+class exact_map_impl
+{
+public:
+  static constexpr uint32_t max_window_size = 12;
+  using network_cuts_t = fast_network_cuts<Ntk, CutSize, true, CutData>;
+  using cut_t = typename network_cuts_t::cut_t;
+
+public:
+  explicit exact_map_impl( Ntk& ntk, exact_library<NtkDest, NInputs> const& library, map_params const& ps, map_stats& st )
+      : ntk( ntk ),
+        library( library ),
+        ps( ps ),
+        st( st ),
+        lib_database( library.get_database() ),
+        node_match( ntk.size() ),
+        matches(),
+        cuts( fast_cut_enumeration<Ntk, CutSize, true, CutData>( ntk, ps.cut_enumeration_ps ) )
+  {
+    std::tie( lib_inv_area, lib_inv_delay ) = library.get_inverter_info();
+  }
+
+  NtkDest run()
+  {
+    stopwatch t( st.time_mapping );
+
+    auto [res, old2new] = initialize_dest();
+
+    /* compute and save topological order */
+    top_order.reserve( ntk.size() );
+    topo_view<Ntk>( ntk ).foreach_node( [this]( auto n ) {
+      top_order.push_back( n );
+    } );
+
+    /* match cuts with gates */
+    if ( ps.use_dont_cares )
+    {
+      compute_matches_dc();
+    }
+    else
+    {
+      compute_matches();
+    }
+
+    /* init the data structure */
+    init_nodes();
+
+    /* compute mapping delay */
+    if ( !ps.skip_delay_round )
+    {
+      if ( !compute_mapping<false>() )
+      {
+        return res;
+      }
+    }
+
+    /* compute mapping using global area flow */
+    while ( iteration < ps.area_flow_rounds + 1 )
+    {
+      compute_required_time();
+      if ( !compute_mapping<true>() )
+      {
+        return res;
+      }
+    }
+
+    /* compute mapping using exact area */
+    while ( iteration < ps.ela_rounds + ps.area_flow_rounds + 1 )
+    {
+      compute_required_time();
+      if ( ps.enable_logic_sharing && iteration == ps.ela_rounds + ps.area_flow_rounds )
+      {
+        if ( !compute_exact_area_aggressive( res, old2new ) )
+        {
+          return res;
+        }
+      }
+      else
+      {
+        if ( !compute_exact_area() )
+        {
+          return res;
+        }
+      }
+    }
+
+    /* generate the output network using the computed mapping */
+    finalize_cover( res, old2new );
+
+    if ( ps.enable_logic_sharing )
+      return cleanup_dangling( res );
+    else
+      return res;
+  }
+
+private:
+  void init_nodes()
+  {
+    ntk.foreach_node( [this]( auto const& n, auto ) {
+      const auto index = ntk.node_to_index( n );
+      auto& node_data = node_match[index];
+
+      node_data.est_refs[0] = node_data.est_refs[1] = node_data.est_refs[2] = static_cast<float>( ntk.fanout_size( n ) );
+
+      if ( ntk.is_constant( n ) )
+      {
+        /* all terminals have flow 1.0 */
+        node_data.flows[0] = node_data.flows[1] = node_data.flows[2] = 0.0f;
+        node_data.arrival[0] = node_data.arrival[1] = 0.0f;
+      }
+      else if ( ntk.is_ci( n ) )
+      {
+        /* all terminals have flow 1.0 */
+        node_data.flows[0] = node_data.flows[1] = node_data.flows[2] = 0.0f;
+        node_data.arrival[0] = 0.0f;
+        /* PIs have the negative phase implemented with an inverter */
+        node_data.arrival[1] = lib_inv_delay;
+      }
+    } );
+  }
+
+  void compute_matches()
+  {
+    /* match gates */
+    ntk.foreach_gate( [&]( auto const& n ) {
+      const auto index = ntk.node_to_index( n );
+
+      std::vector<cut_match_t<NtkDest, NInputs>> node_matches;
+
+      auto i = 0u;
+      for ( auto& cut : cuts.cuts( index ) )
+      {
+        /* ignore unit cut */
+        if ( cut->size() == 1 && *cut->begin() == index )
+        {
+          ( *cut )->data.ignore = true;
+          continue;
+        }
+
+        if ( cut->size() > NInputs )
+        {
+          /* Ignore cuts too big to be mapped using the library */
+          ( *cut )->data.ignore = true;
+          continue;
+        }
+
+        /* match the cut using canonization and get the gates */
+        const auto tt = cuts.truth_table( *cut );
+        const auto fe = kitty::extend_to<NInputs>( tt );
+        const auto config = kitty::exact_npn_canonization( fe );
+        auto const supergates_npn = library.get_supergates( std::get<0>( config ) );
+        auto const supergates_npn_neg = library.get_supergates( ~std::get<0>( config ) );
+
+        if ( supergates_npn != nullptr || supergates_npn_neg != nullptr )
+        {
+          auto neg = std::get<1>( config );
+          auto perm = std::get<2>( config );
+          uint8_t phase = ( neg >> NInputs ) & 1;
+          cut_match_t<NtkDest, NInputs> match;
+
+          match.supergates[phase] = supergates_npn;
+          match.supergates[phase ^ 1] = supergates_npn_neg;
+
+          /* store permutations and negations */
+          match.negation = 0;
+          for ( auto j = 0u; j < perm.size() && j < NInputs; ++j )
+          {
+            match.permutation[perm[j]] = j;
+            match.negation |= ( ( neg >> perm[j] ) & 1 ) << j;
+          }
+          node_matches.push_back( match );
+          ( *cut )->data.match_index = i++;
+        }
+        else
+        {
+          /* Ignore not matched cuts */
+          ( *cut )->data.ignore = true;
+        }
+      }
+
+      matches[index] = node_matches;
+    } );
+  }
+
+  void compute_matches_dc()
+  {
+    reconvergence_driven_cut_parameters rps;
+    rps.max_leaves = ps.window_size;
+    reconvergence_driven_cut_statistics rst;
+    detail::reconvergence_driven_cut_impl<Ntk, false, false> reconv_cuts( ntk, rps, rst );
+
+    color_view<Ntk> color_ntk{ ntk };
+    std::array<uint32_t, NInputs> divisors;
+    for ( uint32_t i = 0; i < NInputs; ++i )
+    {
+      divisors[i] = i;
+    }
+
+    /* match gates */
+    ntk.foreach_gate( [&]( auto const& n ) {
+      const auto index = ntk.node_to_index( n );
+      std::vector<cut_match_t<NtkDest, NInputs>> node_matches;
+
+      std::vector<node<Ntk>> roots = { n };
+      auto const extended_leaves = reconv_cuts.run( roots ).first;
+
+      std::vector<node<Ntk>> gates{ collect_nodes( color_ntk, extended_leaves, roots ) };
+      window_view window_ntk{ color_ntk, extended_leaves, roots, gates };
+
+      default_simulator<kitty::static_truth_table<max_window_size>> sim;
+      const auto tts = simulate_nodes<kitty::static_truth_table<max_window_size>>( window_ntk, sim );
+
+      auto i = 0u;
+      for ( auto& cut : cuts.cuts( index ) )
+      {
+        /* ignore unit cut */
+        if ( cut->size() == 1 && *cut->begin() == index )
+        {
+          ( *cut )->data.ignore = true;
+          continue;
+        }
+
+        if ( cut->size() > NInputs )
+        {
+          /* Ignore cuts too big to be mapped using the library */
+          ( *cut )->data.ignore = true;
+          continue;
+        }
+
+        /* match the cut using canonization and get the gates */
+        const auto tt = cuts.truth_table( *cut );
+        const auto fe = kitty::shrink_to<NInputs>( tt );
+
+        auto [tt_npn, neg, perm] = kitty::exact_npn_canonization( fe );
+        auto perm_neg = perm;
+        auto neg_neg = neg;
+
+        /* dont cares computation */
+        kitty::static_truth_table<NInputs> care;
+
+        bool containment = true;
+        bool filter = false;
+        for ( auto const& l : *cut )
+        {
+          if ( color_ntk.color( ntk.index_to_node( l ) ) != color_ntk.current_color() )
+          {
+            containment = false;
+            break;
+          }
+        }
+
+        if ( containment )
+        {
+          /* compute care set */
+          for ( auto i = 0u; i < ( 1u << window_ntk.num_pis() ); ++i )
+          {
+            uint32_t entry{ 0u };
+            auto j = 0u;
+            for ( auto const& l : *cut )
+            {
+              entry |= kitty::get_bit( tts[l], i ) << j;
+              ++j;
+            }
+            kitty::set_bit( care, entry );
+          }
+        }
+        else
+        {
+          /* completely specified */
+          care = ~care;
+        }
+
+        auto const dc_npn = apply_npn_transformation( ~care, neg & ~( 1 << NInputs ), perm );
+        const std::vector<exact_supergate<NtkDest, NInputs>>* supergates_npn = library.get_supergates( tt_npn, dc_npn, neg, perm );
+        const std::vector<exact_supergate<NtkDest, NInputs>>* supergates_npn_neg = library.get_supergates( ~tt_npn, dc_npn, neg_neg, perm_neg );
+
+        if ( supergates_npn != nullptr || supergates_npn_neg != nullptr )
+        {
+          cut_match_t<NtkDest, NInputs> match;
+
+          if ( supergates_npn == nullptr )
+          {
+            perm = perm_neg;
+            neg = neg_neg;
+          }
+
+          uint8_t phase = ( neg >> NInputs ) & 1;
+
+          match.supergates[phase] = supergates_npn;
+          match.supergates[phase ^ 1] = supergates_npn_neg;
+
+          /* store permutations and negations */
+          match.negation = 0;
+          for ( auto j = 0u; j < perm.size() && j < NInputs; ++j )
+          {
+            match.permutation[perm[j]] = j;
+            match.negation |= ( ( neg >> perm[j] ) & 1 ) << j;
+          }
+          node_matches.push_back( match );
+          ( *cut )->data.match_index = i++;
+        }
+        else
+        {
+          /* Ignore not matched cuts */
+          ( *cut )->data.ignore = true;
+        }
+      }
+
+      matches[index] = node_matches;
+    } );
+  }
+
+  template<bool DO_AREA>
+  bool compute_mapping()
+  {
+    for ( auto const& n : top_order )
+    {
+      if ( ntk.is_constant( n ) || ntk.is_ci( n ) )
+        continue;
+
+      /* match positive phase */
+      match_phase<DO_AREA>( n, 0u );
+
+      /* match negative phase */
+      match_phase<DO_AREA>( n, 1u );
+
+      /* try to drop one phase */
+      match_drop_phase<DO_AREA, false>( n, 0u );
+    }
+
+    double area_old = area;
+    bool success = set_mapping_refs<false>();
+
+    /* round stats */
+    if ( ps.verbose )
+    {
+      std::stringstream stats{};
+      float area_gain = 0.0f;
+
+      if ( iteration != 1 )
+        area_gain = float( ( area_old - area ) / area_old * 100 );
+
+      if constexpr ( DO_AREA )
+      {
+        stats << fmt::format( "[i] AreaFlow : Delay = {:>12.2f}  Area = {:>12.2f}  {:>5.2f} %\n", delay, area, area_gain );
+      }
+      else
+      {
+        stats << fmt::format( "[i] Delay    : Delay = {:>12.2f}  Area = {:>12.2f}  {:>5.2f} %\n", delay, area, area_gain );
+      }
+      st.round_stats.push_back( stats.str() );
+    }
+
+    return success;
+  }
+
+  bool compute_exact_area()
+  {
+    for ( auto const& n : top_order )
+    {
+      if ( ntk.is_constant( n ) || ntk.is_ci( n ) )
+        continue;
+
+      auto index = ntk.node_to_index( n );
+      auto& node_data = node_match[index];
+
+      /* recursively deselect the best cut shared between
+       * the two phases if in use in the cover */
+      if ( node_data.same_match && node_data.map_refs[2] != 0 )
+      {
+        if ( node_data.best_supergate[0] != nullptr )
+          cut_deref( cuts.cuts( index )[node_data.best_cut[0]], n, 0u );
+        else
+          cut_deref( cuts.cuts( index )[node_data.best_cut[1]], n, 1u );
+      }
+
+      /* match positive phase */
+      match_phase_exact( n, 0u );
+
+      /* match negative phase */
+      match_phase_exact( n, 1u );
+
+      /* try to drop one phase */
+      match_drop_phase<true, true>( n, 0u );
+    }
+
+    double area_old = area;
+    bool success = set_mapping_refs<true>();
+
+    /* round stats */
+    if ( ps.verbose )
+    {
+      float area_gain = float( ( area_old - area ) / area_old * 100 );
+      std::stringstream stats{};
+      stats << fmt::format( "[i] Area     : Delay = {:>12.2f}  Area = {:>12.2f}  {:>5.2f} %\n", delay, area, area_gain );
+      st.round_stats.push_back( stats.str() );
+    }
+
+    return success;
+  }
+
+  std::pair<NtkDest, node_map<signal<NtkDest>, Ntk>> initialize_dest()
+  {
+    node_map<signal<NtkDest>, Ntk> old2new( ntk );
+    NtkDest dest;
+
+    old2new[ntk.get_constant( false )] = dest.get_constant( false );
+    if ( ntk.get_node( ntk.get_constant( true ) ) != ntk.get_node( ntk.get_constant( false ) ) )
+    {
+      old2new[ntk.get_constant( true )] = dest.get_constant( true );
+    }
+
+    ntk.foreach_pi( [&]( auto const& n ) {
+      old2new[n] = dest.create_pi();
+    } );
+
+    if constexpr ( has_foreach_ro_v<Ntk> )
+    {
+      ntk.foreach_ro( [&]( auto const& n ) {
+        old2new[n] = dest.create_ro();
+      } );
+    }
+
+    return { dest, old2new };
+  }
+
+  void finalize_cover( NtkDest& res, node_map<signal<NtkDest>, Ntk>& old2new )
+  {
+    if ( !ps.enable_logic_sharing || iteration == ps.area_flow_rounds + 1 )
+    {
+      auto const& db = library.get_database();
+
+      ntk.foreach_node( [&]( auto const& n ) {
+        if ( ntk.is_constant( n ) || ntk.is_ci( n ) )
+          return true;
+        auto index = ntk.node_to_index( n );
+        if ( node_match[index].map_refs[2] == 0u )
+          return true;
+
+        /* get the implemented phase and map the best cut */
+        unsigned phase = ( node_match[index].best_supergate[0] != nullptr ) ? 0 : 1;
+        auto& best_cut = cuts.cuts( index )[node_match[index].best_cut[phase]];
+
+        std::vector<signal<NtkDest>> children( NInputs, res.get_constant( false ) );
+        auto const& match = matches[index][best_cut->data.match_index];
+        auto const& supergate = node_match[index].best_supergate[phase];
+        auto ctr = 0u;
+        for ( auto l : best_cut )
+        {
+          children[match.permutation[ctr++]] = old2new[ntk.index_to_node( l )];
+        }
+        for ( auto i = 0u; i < NInputs; ++i )
+        {
+          if ( ( match.negation >> i ) & 1 )
+          {
+            children[i] = !children[i];
+          }
+        }
+        topo_view topo{ db, supergate->root };
+        auto f = cleanup_dangling( topo, res, children.begin(), children.end() ).front();
+
+        if ( phase == 1 )
+          f = !f;
+
+        old2new[n] = f;
+        return true;
+      } );
+    }
+
+    /* create POs */
+    ntk.foreach_po( [&]( auto const& f ) {
+      res.create_po( ntk.is_complemented( f ) ? res.create_not( old2new[f] ) : old2new[f] );
+    } );
+
+    if constexpr ( has_foreach_ri_v<Ntk> )
+    {
+      ntk.foreach_ri( [&]( auto const& f ) {
+        res.create_ri( ntk.is_complemented( f ) ? res.create_not( old2new[f] ) : old2new[f] );
+      } );
+    }
+
+    /* write final results */
+    st.area = area;
+    st.delay = delay;
+  }
+
+  template<bool ELA>
+  bool set_mapping_refs()
+  {
+    const auto coef = 1.0f / ( 2.0f + ( iteration + 1 ) * ( iteration + 1 ) );
+
+    if constexpr ( !ELA )
+    {
+      for ( auto i = 0u; i < node_match.size(); ++i )
+      {
+        node_match[i].map_refs[0] = node_match[i].map_refs[1] = node_match[i].map_refs[2] = 0u;
+      }
+    }
+
+    /* compute current delay and update mapping refs */
+    delay = 0.0f;
+    ntk.foreach_co( [this]( auto s ) {
+      const auto index = ntk.node_to_index( ntk.get_node( s ) );
+      if ( ntk.is_complemented( s ) )
+        delay = std::max( delay, node_match[index].arrival[1] );
+      else
+        delay = std::max( delay, node_match[index].arrival[0] );
+
+      if constexpr ( !ELA )
+      {
+        node_match[index].map_refs[2]++;
+        if ( ntk.is_complemented( s ) )
+          node_match[index].map_refs[1]++;
+        else
+          node_match[index].map_refs[0]++;
+      }
+    } );
+
+    /* compute current area and update mapping refs in top-down order */
+    area = 0.0f;
+    for ( auto it = top_order.rbegin(); it != top_order.rend(); ++it )
+    {
+      const auto index = ntk.node_to_index( *it );
+      /* skip constants and PIs */
+      if ( ntk.is_constant( *it ) )
+      {
+        continue;
+      }
+      else if ( ntk.is_ci( *it ) )
+      {
+        if ( node_match[index].map_refs[1] > 0u )
+        {
+          /* Add inverter over the negated fanins */
+          area += lib_inv_area;
+        }
+        continue;
+      }
+
+      if ( node_match[index].map_refs[2] == 0u )
+        continue;
+
+      auto& node_data = node_match[index];
+      unsigned use_phase = node_data.best_supergate[0] == nullptr ? 1u : 0u;
+
+      if ( node_data.best_supergate[use_phase] == nullptr )
+      {
+        /* Library is not complete, mapping is not possible */
+        std::cerr << "[i] MAP ERROR: library is not complete, impossible to perform mapping" << std::endl;
+        st.mapping_error = true;
+        return false;
+      }
+
+      if ( node_data.same_match || node_data.map_refs[use_phase] > 0 )
+      {
+        if constexpr ( !ELA )
+        {
+          auto const& best_cut = cuts.cuts( index )[node_data.best_cut[use_phase]];
+          auto const& match = matches[index][best_cut->data.match_index];
+          auto ctr = 0u;
+          for ( auto const leaf : best_cut )
+          {
+            node_match[leaf].map_refs[2]++;
+            if ( ( node_data.phase[use_phase] >> match.permutation[ctr++] ) & 1 )
+              node_match[leaf].map_refs[1]++;
+            else
+              node_match[leaf].map_refs[0]++;
+          }
+        }
+        area += node_data.area[use_phase];
+        if ( node_data.same_match && node_data.map_refs[use_phase ^ 1] > 0 )
+        {
+          area += lib_inv_area;
+        }
+      }
+
+      /* invert the phase */
+      use_phase = use_phase ^ 1;
+
+      /* if both phases are implemented and used */
+      if ( !node_data.same_match && node_data.map_refs[use_phase] > 0 )
+      {
+        if constexpr ( !ELA )
+        {
+          auto const& best_cut = cuts.cuts( index )[node_data.best_cut[use_phase]];
+          auto const& match = matches[index][best_cut->data.match_index];
+          auto ctr = 0u;
+          for ( auto const leaf : best_cut )
+          {
+            node_match[leaf].map_refs[2]++;
+            if ( ( node_data.phase[use_phase] >> match.permutation[ctr++] ) & 1 )
+              node_match[leaf].map_refs[1]++;
+            else
+              node_match[leaf].map_refs[0]++;
+          }
+        }
+        area += node_data.area[use_phase];
+      }
+    }
+
+    /* blend flow references */
+    for ( auto i = 0u; i < ntk.size(); ++i )
+    {
+      node_match[i].est_refs[2] = coef * node_match[i].est_refs[2] + ( 1.0f - coef ) * std::max( 1.0f, static_cast<float>( node_match[i].map_refs[2] ) );
+      node_match[i].est_refs[1] = coef * node_match[i].est_refs[1] + ( 1.0f - coef ) * std::max( 1.0f, static_cast<float>( node_match[i].map_refs[1] ) );
+      node_match[i].est_refs[0] = coef * node_match[i].est_refs[0] + ( 1.0f - coef ) * std::max( 1.0f, static_cast<float>( node_match[i].map_refs[0] ) );
+    }
+
+    ++iteration;
+    return true;
+  }
+
+  void compute_required_time()
+  {
+    for ( auto i = 0u; i < node_match.size(); ++i )
+    {
+      node_match[i].required[0] = node_match[i].required[1] = std::numeric_limits<float>::max();
+    }
+
+    /* return in case of `skip_delay_round` */
+    if ( iteration == 0 )
+      return;
+
+    auto required = delay;
+
+    if ( ps.required_time != 0.0f )
+    {
+      /* Global target time constraint */
+      if ( ps.required_time < delay - epsilon )
+      {
+        if ( !ps.skip_delay_round && iteration == 1 )
+          std::cerr << fmt::format( "[i] MAP WARNING: cannot meet the target required time of {:.2f}", ps.required_time ) << std::endl;
+      }
+      else
+      {
+        required = ps.required_time;
+      }
+    }
+
+    /* set the required time at POs */
+    ntk.foreach_co( [&]( auto const& s ) {
+      const auto index = ntk.node_to_index( ntk.get_node( s ) );
+      if ( ntk.is_complemented( s ) )
+        node_match[index].required[1] = required;
+      else
+        node_match[index].required[0] = required;
+    } );
+
+    /* propagate required time to the PIs */
+    auto i = ntk.size();
+    while ( i-- > 0u )
+    {
+      const auto n = ntk.index_to_node( i );
+      if ( ntk.is_ci( n ) || ntk.is_constant( n ) )
+        break;
+
+      if ( node_match[i].map_refs[2] == 0 )
+        continue;
+
+      auto& node_data = node_match[i];
+
+      unsigned use_phase = node_data.best_supergate[0] == nullptr ? 1u : 0u;
+      unsigned other_phase = use_phase ^ 1;
+
+      assert( node_data.best_supergate[0] != nullptr || node_data.best_supergate[1] != nullptr );
+      assert( node_data.map_refs[0] || node_data.map_refs[1] );
+
+      /* propagate required time over output inverter if present */
+      if ( node_data.same_match && node_data.map_refs[other_phase] > 0 )
+      {
+        node_data.required[use_phase] = std::min( node_data.required[use_phase], node_data.required[other_phase] - lib_inv_delay );
+      }
+
+      if ( node_data.same_match || node_data.map_refs[use_phase] > 0 )
+      {
+        auto ctr = 0u;
+        auto best_cut = cuts.cuts( i )[node_data.best_cut[use_phase]];
+        auto const& match = matches[i][best_cut->data.match_index];
+        auto const& supergate = node_data.best_supergate[use_phase];
+        for ( auto leaf : best_cut )
+        {
+          auto phase = ( node_data.phase[use_phase] >> match.permutation[ctr] ) & 1;
+          node_match[leaf].required[phase] = std::min( node_match[leaf].required[phase], node_data.required[use_phase] - supergate->tdelay[match.permutation[ctr]] );
+          ctr++;
+        }
+      }
+
+      if ( !node_data.same_match && node_data.map_refs[other_phase] > 0 )
+      {
+        auto ctr = 0u;
+        auto best_cut = cuts.cuts( i )[node_data.best_cut[other_phase]];
+        auto const& match = matches[i][best_cut->data.match_index];
+        auto const& supergate = node_data.best_supergate[other_phase];
+        for ( auto leaf : best_cut )
+        {
+          auto phase = ( node_data.phase[other_phase] >> match.permutation[ctr] ) & 1;
+          node_match[leaf].required[phase] = std::min( node_match[leaf].required[phase], node_data.required[other_phase] - supergate->tdelay[match.permutation[ctr]] );
+          ctr++;
+        }
+      }
+    }
+  }
+
+  template<bool DO_AREA>
+  void match_phase( node<Ntk> const& n, uint8_t phase )
+  {
+    float best_arrival = std::numeric_limits<float>::max();
+    float best_area_flow = std::numeric_limits<float>::max();
+    float best_area = std::numeric_limits<float>::max();
+    uint32_t best_size = UINT32_MAX;
+    uint8_t best_cut = 0u;
+    uint8_t best_phase = 0u;
+    uint8_t cut_index = 0u;
+    auto index = ntk.node_to_index( n );
+
+    auto& node_data = node_match[index];
+    auto& cut_matches = matches[index];
+    exact_supergate<NtkDest, NInputs> const* best_supergate = node_data.best_supergate[phase];
+
+    /* recompute best match info */
+    if ( best_supergate != nullptr )
+    {
+      auto const& cut = cuts.cuts( index )[node_data.best_cut[phase]];
+      auto& supergates = cut_matches[( cut )->data.match_index];
+
+      /* permutate the children to the NPN-represenentative configuration */
+      std::vector<uint32_t> children( NInputs, 0u );
+      auto ctr = 0u;
+      for ( auto l : cut )
+      {
+        children[supergates.permutation[ctr++]] = l;
+      }
+
+      best_phase = node_data.phase[phase];
+      best_arrival = 0.0f;
+      best_area_flow = best_supergate->area + cut_leaves_flow( cut, n, phase );
+      best_area = best_supergate->area;
+      best_cut = node_data.best_cut[phase];
+      best_size = cut.size();
+      for ( auto pin = 0u; pin < NInputs; pin++ )
+      {
+        float arrival_pin = node_match[children[pin]].arrival[( best_phase >> pin ) & 1] + best_supergate->tdelay[pin];
+        best_arrival = std::max( best_arrival, arrival_pin );
+      }
+    }
+
+    /* foreach cut */
+    for ( auto& cut : cuts.cuts( index ) )
+    {
+      /* trivial cuts or not matched cuts */
+      if ( ( *cut )->data.ignore )
+      {
+        ++cut_index;
+        continue;
+      }
+
+      auto const& supergates = cut_matches[( *cut )->data.match_index];
+
+      if ( supergates.supergates[phase] == nullptr )
+      {
+        ++cut_index;
+        continue;
+      }
+
+      /* permutate the children to the NPN-represenentative configuration */
+      std::vector<uint32_t> children( NInputs, 0u );
+      auto ctr = 0u;
+      for ( auto l : *cut )
+      {
+        children[supergates.permutation[ctr++]] = l;
+      }
+
+      /* match each gate and take the best one */
+      for ( auto const& gate : *supergates.supergates[phase] )
+      {
+        uint8_t complement = supergates.negation ^ gate.polarity;
+        node_data.phase[phase] = complement;
+        float area_local = gate.area + cut_leaves_flow( *cut, n, phase );
+        float worst_arrival = 0.0f;
+        for ( auto pin = 0u; pin < NInputs; pin++ )
+        {
+          float arrival_pin = node_match[children[pin]].arrival[( complement >> pin ) & 1] + gate.tdelay[pin];
+          worst_arrival = std::max( worst_arrival, arrival_pin );
+        }
+
+        if constexpr ( DO_AREA )
+        {
+          if ( worst_arrival > node_data.required[phase] + epsilon )
+            continue;
+        }
+
+        if ( compare_map<DO_AREA>( worst_arrival, best_arrival, area_local, best_area_flow, cut->size(), best_size ) )
+        {
+          best_arrival = worst_arrival;
+          best_area_flow = area_local;
+          best_size = cut->size();
+          best_cut = cut_index;
+          best_area = gate.area;
+          best_phase = complement;
+          best_supergate = &gate;
+        }
+      }
+
+      ++cut_index;
+    }
+
+    node_data.flows[phase] = best_area_flow;
+    node_data.arrival[phase] = best_arrival;
+    node_data.area[phase] = best_area;
+    node_data.best_cut[phase] = best_cut;
+    node_data.phase[phase] = best_phase;
+    node_data.best_supergate[phase] = best_supergate;
+  }
+
+  void match_phase_exact( node<Ntk> const& n, uint8_t phase )
+  {
+    float best_arrival = std::numeric_limits<float>::max();
+    float best_exact_area = std::numeric_limits<float>::max();
+    float best_area = std::numeric_limits<float>::max();
+    uint32_t best_size = UINT32_MAX;
+    uint8_t best_cut = 0u;
+    uint8_t best_phase = 0u;
+    uint8_t cut_index = 0u;
+    auto index = ntk.node_to_index( n );
+
+    auto& node_data = node_match[index];
+    auto& cut_matches = matches[index];
+    exact_supergate<NtkDest, NInputs> const* best_supergate = node_data.best_supergate[phase];
+
+    /* recompute best match info */
+    if ( best_supergate != nullptr )
+    {
+      auto const& cut = cuts.cuts( index )[node_data.best_cut[phase]];
+      auto const& supergates = cut_matches[( cut )->data.match_index];
+
+      /* permutate the children to the NPN-represenentative configuration */
+      std::vector<uint32_t> children( NInputs, 0u );
+      auto ctr = 0u;
+      for ( auto l : cut )
+      {
+        children[supergates.permutation[ctr++]] = l;
+      }
+
+      best_phase = node_data.phase[phase];
+      best_arrival = 0.0f;
+      best_area = best_supergate->area;
+      best_cut = node_data.best_cut[phase];
+      best_size = cut.size();
+      for ( auto pin = 0u; pin < NInputs; pin++ )
+      {
+        float arrival_pin = node_match[children[pin]].arrival[( best_phase >> pin ) & 1] + best_supergate->tdelay[pin];
+        best_arrival = std::max( best_arrival, arrival_pin );
+      }
+
+      /* if cut is implemented, remove it from the cover */
+      if ( !node_data.same_match && node_data.map_refs[phase] )
+      {
+        best_exact_area = cut_deref( cuts.cuts( index )[best_cut], n, phase );
+      }
+      else
+      {
+        best_exact_area = cut_ref( cuts.cuts( index )[best_cut], n, phase );
+        cut_deref( cuts.cuts( index )[best_cut], n, phase );
+      }
+    }
+
+    /* foreach cut */
+    for ( auto& cut : cuts.cuts( index ) )
+    {
+      /* trivial cuts or not matched cuts */
+      if ( ( *cut )->data.ignore )
+      {
+        ++cut_index;
+        continue;
+      }
+
+      auto const& supergates = cut_matches[( *cut )->data.match_index];
+
+      if ( supergates.supergates[phase] == nullptr )
+      {
+        ++cut_index;
+        continue;
+      }
+
+      /* permutate the children to the NPN-represenentative configuration */
+      std::vector<uint32_t> children( NInputs, 0u );
+      auto ctr = 0u;
+      for ( auto l : *cut )
+      {
+        children[supergates.permutation[ctr++]] = l;
+      }
+
+      for ( auto const& gate : *supergates.supergates[phase] )
+      {
+        uint8_t complement = supergates.negation ^ gate.polarity;
+        node_data.phase[phase] = complement;
+        node_data.area[phase] = gate.area;
+        auto area_exact = cut_ref( *cut, n, phase );
+        cut_deref( *cut, n, phase );
+        float worst_arrival = 0.0f;
+        for ( auto pin = 0u; pin < NInputs; pin++ )
+        {
+          float arrival_pin = node_match[children[pin]].arrival[( complement >> pin ) & 1] + gate.tdelay[pin];
+          worst_arrival = std::max( worst_arrival, arrival_pin );
+        }
+
+        if ( worst_arrival > node_data.required[phase] + epsilon )
+          continue;
+
+        if ( compare_map<true>( worst_arrival, best_arrival, area_exact, best_exact_area, cut->size(), best_size ) )
+        {
+          best_arrival = worst_arrival;
+          best_exact_area = area_exact;
+          best_area = gate.area;
+          best_size = cut->size();
+          best_cut = cut_index;
+          best_phase = complement;
+          best_supergate = &gate;
+        }
+      }
+
+      ++cut_index;
+    }
+
+    node_data.flows[phase] = best_exact_area;
+    node_data.arrival[phase] = best_arrival;
+    node_data.area[phase] = best_area;
+    node_data.best_cut[phase] = best_cut;
+    node_data.phase[phase] = best_phase;
+    node_data.best_supergate[phase] = best_supergate;
+
+    if ( !node_data.same_match && node_data.map_refs[phase] )
+    {
+      best_exact_area = cut_ref( cuts.cuts( index )[best_cut], n, phase );
+    }
+  }
+
+  bool compute_exact_area_aggressive( NtkDest& res, node_map<signal<NtkDest>, Ntk>& old2new )
+  {
+    depth_view<NtkDest> res_d{ res };
+
+    for ( auto const& n : top_order )
+    {
+      if ( ntk.is_constant( n ) || ntk.is_ci( n ) )
+        continue;
+
+      auto index = ntk.node_to_index( n );
+      auto& node_data = node_match[index];
+
+      /* recursively deselect the best cut shared between
+       * the two phases if in use in the cover */
+      if ( node_data.same_match && node_data.map_refs[2] != 0 )
+      {
+        if ( node_data.best_supergate[0] != nullptr )
+          cut_deref( cuts.cuts( index )[node_data.best_cut[0]], n, 0u );
+        else
+          cut_deref( cuts.cuts( index )[node_data.best_cut[1]], n, 1u );
+      }
+
+      /* match positive phase */
+      auto sig0 = match_phase_exact_aggressive( res_d, old2new, n, 0u );
+
+      /* match negative phase */
+      auto sig1 = match_phase_exact_aggressive( res_d, old2new, n, 1u );
+
+      /* try to drop one phase */
+      float worst_arrival_npos = node_data.arrival[1] + lib_inv_delay;
+      float worst_arrival_nneg = node_data.arrival[0] + lib_inv_delay;
+      bool use_zero = false;
+      bool use_one = false;
+      if ( node_data.best_supergate[0] == nullptr )
+      {
+        set_match_complemented_phase( index, 1, worst_arrival_npos );
+        if ( node_data.map_refs[2] )
+        {
+          cut_ref( cuts.cuts( index )[node_data.best_cut[1]], n, 1 );
+          recursive_ref<NtkDest>( res, res.get_node( sig1 ) );
+        }
+        old2new[n] = sig1;
+        continue;
+      }
+      else if ( node_data.best_supergate[1] == nullptr )
+      {
+        set_match_complemented_phase( index, 0, worst_arrival_nneg );
+        if ( node_data.map_refs[2] )
+        {
+          cut_ref( cuts.cuts( index )[node_data.best_cut[0]], n, 0 );
+          recursive_ref<NtkDest>( res, res.get_node( sig0 ) );
+        }
+        old2new[n] = sig0;
+        continue;
+      }
+      use_zero = worst_arrival_nneg < node_data.required[1] + epsilon;
+      use_one = worst_arrival_npos < node_data.required[0] + epsilon;
+
+      if ( use_zero && use_one )
+      {
+        auto size_zero = cuts.cuts( index )[node_data.best_cut[0]].size();
+        auto size_one = cuts.cuts( index )[node_data.best_cut[1]].size();
+        if ( compare_map<true>( worst_arrival_nneg, worst_arrival_npos, node_data.flows[0], node_data.flows[1], size_zero, size_one ) )
+          use_one = false;
+        else
+          use_zero = false;
+      }
+
+      if ( use_zero )
+      {
+        if ( node_data.map_refs[2] )
+        {
+          cut_ref( cuts.cuts( index )[node_data.best_cut[0]], n, 0 );
+          recursive_ref<NtkDest>( res, res.get_node( sig0 ) );
+        }
+        set_match_complemented_phase( index, 0, worst_arrival_nneg );
+        old2new[n] = sig0;
+      }
+      else
+      {
+        if ( node_data.map_refs[2] )
+        {
+          cut_ref( cuts.cuts( index )[node_data.best_cut[1]], n, 1 );
+          recursive_ref<NtkDest>( res, res.get_node( sig1 ) );
+        }
+        set_match_complemented_phase( index, 1, worst_arrival_npos );
+        old2new[n] = sig1;
+      }
+    }
+
+    double area_old = area;
+    bool success = set_mapping_refs<true>();
+
+    /* round stats */
+    if ( ps.verbose )
+    {
+      float area_gain = float( ( area_old - area ) / area_old * 100 );
+      std::stringstream stats{};
+      stats << fmt::format( "[i] Area RW  : Delay = {:>12.2f}  Area = {:>12.2f}  {:>5.2f} %\n", delay, area, area_gain );
+      st.round_stats.push_back( stats.str() );
+    }
+
+    return success;
+  }
+
+  signal<NtkDest> match_phase_exact_aggressive( depth_view<NtkDest>& res, node_map<signal<NtkDest>, Ntk>& old2new, node<Ntk> const& n, uint8_t phase )
+  {
+    signal<NtkDest> best_signal = res.get_constant( false );
+
+    float best_arrival = std::numeric_limits<float>::max();
+    float best_exact_area = std::numeric_limits<float>::max();
+    float best_area = std::numeric_limits<float>::max();
+    uint32_t best_size = UINT32_MAX;
+    uint8_t best_cut = 0u;
+    uint8_t best_phase = 0u;
+    uint8_t cut_index = 0u;
+    auto index = ntk.node_to_index( n );
+
+    auto& node_data = node_match[index];
+    auto& cut_matches = matches[index];
+    exact_supergate<NtkDest, NInputs> const* best_supergate = node_data.best_supergate[phase];
+
+    /* create best match info */
+    if ( best_supergate != nullptr )
+    {
+      auto const& cut = cuts.cuts( index )[node_data.best_cut[phase]];
+      auto const& supergates = cut_matches[( cut )->data.match_index];
+
+      /* permutate the children to the NPN-represenentative configuration */
+      std::vector<signal<NtkDest>> children( NInputs, res.get_constant( false ) );
+      auto ctr = 0u;
+
+      for ( auto l : cut )
+      {
+        children[supergates.permutation[ctr++]] = old2new[ntk.index_to_node( l )];
+      }
+
+      best_phase = supergates.negation;
+      best_cut = node_data.best_cut[phase];
+      best_size = cut.size();
+      for ( auto i = 0u; i < NInputs; ++i )
+      {
+        if ( ( best_phase >> i ) & 1 )
+        {
+          children[i] = !children[i];
+        }
+      }
+      topo_view topo{ lib_database, best_supergate->root };
+      auto f = cleanup_dangling( topo, res, children.begin(), children.end() ).front();
+
+      if ( phase == 1 )
+        f = !f;
+
+      best_signal = f;
+
+      best_arrival = res.level( res.get_node( f ) );
+
+      /* if cut is implemented, remove it from the cover */
+      if ( !node_data.same_match && node_data.map_refs[phase] )
+      {
+        best_area = recursive_ref<NtkDest>( res, res.get_node( f ) );
+        recursive_deref<NtkDest>( res, res.get_node( f ) );
+        best_exact_area = cut_deref( cuts.cuts( index )[best_cut], n, phase );
+      }
+      else
+      {
+        best_area = recursive_ref<NtkDest>( res, res.get_node( f ) );
+        recursive_deref<NtkDest>( res, res.get_node( f ) );
+        best_exact_area = cut_ref( cuts.cuts( index )[best_cut], n, phase );
+        cut_deref( cuts.cuts( index )[best_cut], n, phase );
+      }
+    }
+
+    /* foreach cut */
+    unsigned int rewrite_count = 1u;
+    for ( auto& cut : cuts.cuts( index ) )
+    {
+      /* trivial cuts, not matched cuts, or rewriting limit reached */
+      if ( ( *cut )->data.ignore || ( rewrite_count > ps.logic_sharing_cut_limit && cut_index != best_cut ) )
+      {
+        ++cut_index;
+        continue;
+      }
+
+      auto const& supergates = cut_matches[( *cut )->data.match_index];
+
+      if ( supergates.supergates[phase] == nullptr )
+      {
+        ++cut_index;
+        continue;
+      }
+
+      ++rewrite_count;
+
+      std::vector<signal<NtkDest>> children( NInputs, res.get_constant( false ) );
+
+      auto ctr = 0u;
+      for ( auto l : *cut )
+      {
+        children[supergates.permutation[ctr++]] = old2new[ntk.index_to_node( l )];
+      }
+
+      /* match each gate and take the best one */
+      for ( auto const& gate : *supergates.supergates[phase] )
+      {
+        uint8_t complement = supergates.negation;
+        node_data.phase[phase] = complement;
+
+        /* rewrite each structure and measure the logic sharing */
+        std::vector<signal<NtkDest>> children_loc( NInputs );
+
+        for ( auto ctr = 0u; ctr < NInputs; ++ctr )
+        {
+          children_loc[ctr] = children[ctr] ^ ( ( ( complement >> ctr ) & 1 ) == 1 );
+        }
+        topo_view topo{ lib_database, gate.root };
+        auto f = cleanup_dangling( topo, res, children_loc.begin(), children_loc.end() ).front();
+
+        if ( phase == 1 )
+          f = !f;
+
+        float worst_arrival = res.level( res.get_node( f ) );
+
+        float area_hashed = recursive_ref<NtkDest>( res, res.get_node( f ) );
+        node_data.area[phase] = area_hashed;
+        recursive_deref<NtkDest>( res, res.get_node( f ) );
+        auto area_exact = cut_ref( *cut, n, phase );
+        cut_deref( *cut, n, phase );
+
+        if ( worst_arrival > node_data.required[phase] + epsilon )
+          continue;
+
+        if ( compare_map<true>( worst_arrival, best_arrival, area_exact, best_exact_area, cut->size(), best_size ) )
+        {
+          best_arrival = worst_arrival;
+          best_exact_area = area_exact;
+          best_area = area_hashed;
+          best_size = cut->size();
+          best_cut = cut_index;
+          best_phase = complement;
+          best_supergate = &gate;
+          best_signal = f;
+        }
+      }
+
+      ++cut_index;
+    }
+    old2new[n] = best_signal;
+    node_data.flows[phase] = best_exact_area;
+    node_data.arrival[phase] = best_arrival;
+    node_data.area[phase] = best_area;
+    node_data.best_cut[phase] = best_cut;
+    node_data.phase[phase] = best_phase;
+    node_data.best_supergate[phase] = best_supergate;
+
+    if ( !node_data.same_match && node_data.map_refs[phase] )
+    {
+      recursive_ref<NtkDest>( res, res.get_node( best_signal ) );
+      best_exact_area = cut_ref( cuts.cuts( index )[best_cut], n, phase );
+    }
+    return best_signal;
+  }
+
+  template<bool DO_AREA, bool ELA>
+  void match_drop_phase( node<Ntk> const& n, unsigned area_margin_factor )
+  {
+    auto index = ntk.node_to_index( n );
+    auto& node_data = node_match[index];
+
+    /* compute arrival adding an inverter to the other match phase */
+    float worst_arrival_npos = node_data.arrival[1] + lib_inv_delay;
+    float worst_arrival_nneg = node_data.arrival[0] + lib_inv_delay;
+    bool use_zero = false;
+    bool use_one = false;
+
+    /* only one phase is matched */
+    if ( node_data.best_supergate[0] == nullptr )
+    {
+      set_match_complemented_phase( index, 1, worst_arrival_npos );
+      if constexpr ( ELA )
+      {
+        if ( node_data.map_refs[2] )
+          cut_ref( cuts.cuts( index )[node_data.best_cut[1]], n, 1 );
+      }
+      return;
+    }
+    else if ( node_data.best_supergate[1] == nullptr )
+    {
+      set_match_complemented_phase( index, 0, worst_arrival_nneg );
+      if constexpr ( ELA )
+      {
+        if ( node_data.map_refs[2] )
+          cut_ref( cuts.cuts( index )[node_data.best_cut[0]], n, 0 );
+      }
+      return;
+    }
+
+    /* try to use only one match to cover both phases */
+    if constexpr ( !DO_AREA )
+    {
+      /* if arrival is less matching the other phase and inserting an inverter */
+      if ( worst_arrival_npos < node_data.arrival[0] + epsilon )
+      {
+        use_one = true;
+      }
+      if ( worst_arrival_nneg < node_data.arrival[1] + epsilon )
+      {
+        use_zero = true;
+      }
+      if ( !use_zero && !use_one )
+      {
+        /* use both phases to improve delay */
+        node_data.flows[2] = ( node_data.flows[0] + node_data.flows[1] ) / node_data.est_refs[2];
+        node_data.flows[0] = node_data.flows[0] / node_data.est_refs[0];
+        node_data.flows[1] = node_data.flows[1] / node_data.est_refs[1];
+        return;
+      }
+    }
+    else
+    {
+      /* check if both phases + inverter meet the required time */
+      use_zero = worst_arrival_nneg < node_data.required[1] + epsilon - area_margin_factor * lib_inv_delay;
+      use_one = worst_arrival_npos < node_data.required[0] + epsilon - area_margin_factor * lib_inv_delay;
+    }
+
+    /* use area flow as a tiebreaker. Unfortunately cannot keep
+     * the both phases since `node_map` does not support that */
+    if ( use_zero && use_one )
+    {
+      auto size_zero = cuts.cuts( index )[node_data.best_cut[0]].size();
+      auto size_one = cuts.cuts( index )[node_data.best_cut[1]].size();
+      if ( compare_map<DO_AREA>( worst_arrival_nneg, worst_arrival_npos, node_data.flows[0], node_data.flows[1], size_zero, size_one ) )
+        use_one = false;
+      else
+        use_zero = false;
+    }
+
+    if ( use_zero )
+    {
+      if constexpr ( ELA )
+      {
+        if ( !node_data.same_match )
+        {
+          if ( node_data.map_refs[1] > 0 )
+            cut_deref( cuts.cuts( index )[node_data.best_cut[1]], n, 1 );
+          if ( node_data.map_refs[0] == 0 )
+            cut_ref( cuts.cuts( index )[node_data.best_cut[0]], n, 0 );
+        }
+        else if ( node_data.map_refs[2] )
+          cut_ref( cuts.cuts( index )[node_data.best_cut[0]], n, 0 );
+      }
+      set_match_complemented_phase( index, 0, worst_arrival_nneg );
+    }
+    else
+    {
+      if constexpr ( ELA )
+      {
+        if ( !node_data.same_match )
+        {
+          if ( node_data.map_refs[0] > 0 )
+            cut_deref( cuts.cuts( index )[node_data.best_cut[0]], n, 0 );
+          if ( node_data.map_refs[1] == 0 && node_data.map_refs[2] )
+            cut_ref( cuts.cuts( index )[node_data.best_cut[1]], n, 1 );
+        }
+        else if ( node_data.map_refs[2] )
+          cut_ref( cuts.cuts( index )[node_data.best_cut[1]], n, 1 );
+      }
+      set_match_complemented_phase( index, 1, worst_arrival_npos );
+    }
+  }
+
+  inline void set_match_complemented_phase( uint32_t index, uint8_t phase, float worst_arrival_n )
+  {
+    auto& node_data = node_match[index];
+    auto phase_n = phase ^ 1;
+    node_data.same_match = true;
+    node_data.best_supergate[phase_n] = nullptr;
+    node_data.best_cut[phase_n] = node_data.best_cut[phase];
+    node_data.phase[phase_n] = node_data.phase[phase] ^ ( 1 << NInputs );
+    node_data.arrival[phase_n] = worst_arrival_n;
+    node_data.area[phase_n] = node_data.area[phase];
+    node_data.flows[phase] = node_data.flows[phase] / node_data.est_refs[2];
+    node_data.flows[phase_n] = node_data.flows[phase];
+    node_data.flows[2] = node_data.flows[phase];
+  }
+
+  inline float cut_leaves_flow( cut_t const& cut, node<Ntk> const& n, uint8_t phase )
+  {
+    float flow{ 0.0f };
+    auto const& node_data = node_match[ntk.node_to_index( n )];
+    auto const& match = matches[ntk.node_to_index( n )][cut->data.match_index];
+
+    uint8_t ctr = 0u;
+    for ( auto leaf : cut )
+    {
+      uint8_t leaf_phase = ( node_data.phase[phase] >> match.permutation[ctr++] ) & 1;
+      flow += node_match[leaf].flows[leaf_phase];
+    }
+
+    return flow;
+  }
+
+  float cut_ref( cut_t const& cut, node<Ntk> const& n, uint8_t phase )
+  {
+    auto const& node_data = node_match[ntk.node_to_index( n )];
+    auto const& match = matches[ntk.node_to_index( n )][cut->data.match_index];
+    float count = node_data.area[phase];
+    uint8_t ctr = 0;
+    for ( auto leaf : cut )
+    {
+      /* compute leaf phase using the current gate */
+      uint8_t leaf_phase = ( node_data.phase[phase] >> match.permutation[ctr] ) & 1;
+
+      if ( ntk.is_constant( ntk.index_to_node( leaf ) ) )
+      {
+        ++ctr;
+        continue;
+      }
+      else if ( ntk.is_ci( ntk.index_to_node( leaf ) ) )
+      {
+        /* reference PIs, add inverter cost for negative phase */
+        if ( leaf_phase == 1u )
+        {
+          if ( node_match[leaf].map_refs[1]++ == 0u )
+            count += lib_inv_area;
+        }
+        else
+        {
+          ++node_match[leaf].map_refs[0];
+        }
+        ++ctr;
+        continue;
+      }
+
+      if ( node_match[leaf].same_match )
+      {
+        /* Add inverter area if not present yet and leaf node is implemented in the opposite phase */
+        if ( node_match[leaf].map_refs[leaf_phase]++ == 0u && node_match[leaf].best_supergate[leaf_phase] == nullptr )
+          count += lib_inv_area;
+        /* Recursive referencing if leaf was not referenced */
+        if ( node_match[leaf].map_refs[2]++ == 0u )
+        {
+          count += cut_ref( cuts.cuts( leaf )[node_match[leaf].best_cut[leaf_phase]], ntk.index_to_node( leaf ), leaf_phase );
+        }
+      }
+      else
+      {
+        ++node_match[leaf].map_refs[2];
+        if ( node_match[leaf].map_refs[leaf_phase]++ == 0u )
+        {
+          count += cut_ref( cuts.cuts( leaf )[node_match[leaf].best_cut[leaf_phase]], ntk.index_to_node( leaf ), leaf_phase );
+        }
+      }
+      ++ctr;
+    }
+    return count;
+  }
+
+  float cut_deref( cut_t const& cut, node<Ntk> const& n, uint8_t phase )
+  {
+    auto const& node_data = node_match[ntk.node_to_index( n )];
+    auto const& match = matches[ntk.node_to_index( n )][cut->data.match_index];
+    float count = node_data.area[phase];
+    uint8_t ctr = 0;
+    for ( auto leaf : cut )
+    {
+      /* compute leaf phase using the current gate */
+      uint8_t leaf_phase = ( node_data.phase[phase] >> match.permutation[ctr] ) & 1;
+
+      if ( ntk.is_constant( ntk.index_to_node( leaf ) ) )
+      {
+        ++ctr;
+        continue;
+      }
+      else if ( ntk.is_ci( ntk.index_to_node( leaf ) ) )
+      {
+        /* dereference PIs, add inverter cost for negative phase */
+        if ( leaf_phase == 1u )
+        {
+          if ( --node_match[leaf].map_refs[1] == 0u )
+            count += lib_inv_area;
+        }
+        else
+        {
+          --node_match[leaf].map_refs[0];
+        }
+        ++ctr;
+        continue;
+      }
+
+      if ( node_match[leaf].same_match )
+      {
+        /* Add inverter area if it is used only by the current gate and leaf node is implemented in the opposite phase */
+        if ( --node_match[leaf].map_refs[leaf_phase] == 0u && node_match[leaf].best_supergate[leaf_phase] == nullptr )
+          count += lib_inv_area;
+        /* Recursive dereferencing */
+        if ( --node_match[leaf].map_refs[2] == 0u )
+        {
+          count += cut_deref( cuts.cuts( leaf )[node_match[leaf].best_cut[leaf_phase]], ntk.index_to_node( leaf ), leaf_phase );
+        }
+      }
+      else
+      {
+        --node_match[leaf].map_refs[2];
+        if ( --node_match[leaf].map_refs[leaf_phase] == 0u )
+        {
+          count += cut_deref( cuts.cuts( leaf )[node_match[leaf].best_cut[leaf_phase]], ntk.index_to_node( leaf ), leaf_phase );
+        }
+      }
+      ++ctr;
+    }
+    return count;
+  }
+
+  template<bool DO_AREA>
+  inline bool compare_map( float arrival, float best_arrival, float area_flow, float best_area_flow, uint32_t size, uint32_t best_size )
+  {
+    if constexpr ( DO_AREA )
+    {
+      if ( area_flow < best_area_flow - epsilon )
+      {
+        return true;
+      }
+      else if ( area_flow > best_area_flow + epsilon )
+      {
+        return false;
+      }
+      else if ( arrival < best_arrival - epsilon )
+      {
+        return true;
+      }
+      else if ( arrival > best_arrival + epsilon )
+      {
+        return false;
+      }
+    }
+    else
+    {
+      if ( arrival < best_arrival - epsilon )
+      {
+        return true;
+      }
+      else if ( arrival > best_arrival + epsilon )
+      {
+        return false;
+      }
+      else if ( area_flow < best_area_flow - epsilon )
+      {
+        return true;
+      }
+      else if ( area_flow > best_area_flow + epsilon )
+      {
+        return false;
+      }
+    }
+    if ( size < best_size )
+    {
+      return true;
+    }
+    return false;
+  }
+
+private:
+  Ntk& ntk;
+  exact_library<NtkDest, NInputs> const& library;
+  map_params const& ps;
+  map_stats& st;
+
+  uint32_t iteration{ 0 };       /* current mapping iteration */
+  double delay{ 0.0f };          /* current delay of the mapping */
+  double area{ 0.0f };           /* current area of the mapping */
+  const float epsilon{ 0.005f }; /* epsilon */
+
+  /* lib inverter info */
+  float lib_inv_area;
+  float lib_inv_delay;
+
+  NtkDest const& lib_database;
+
+  std::vector<node<Ntk>> top_order;
+  std::vector<node_match_t<NtkDest, NInputs>> node_match;
+  std::unordered_map<uint32_t, std::vector<cut_match_t<NtkDest, NInputs>>> matches;
+  network_cuts_t cuts;
+};
+
+} /* namespace detail */
+
+/*! \brief Exact mapping.
+ *
+ * This function implements a mapping algorithm using a database of structures.
+ * It is controlled by a template argument `CutData` (defaulted to
+ * `cut_enumeration_exact_map_cut`). The argument is similar to the `CutData` argument
+ * in `cut_enumeration`, which can specialize the cost function to select priority
+ * cuts and store additional data. The default argument gives priority firstly to
+ * area flow, then delay, and lastly to the cut size.
+ * The type passed as `CutData` must implement the following four fields:
+ *
+ * - `uint32_t delay`
+ * - `float flow`
+ * - `uint8_t match_index`
+ * - `bool ignore`
+ *
+ * See `include/mockturtle/algorithms/cut_enumeration/cut_enumeration_exact_map_cut.hpp`
+ * for one example of a CutData type that implements the cost function that is used in
+ * the technology mapper.
+ *
+ * The function takes the size of the cuts in the template parameter `CutSize`.
+ *
+ * The function returns a mapped network representation generated using the exact
+ * synthesis entries in the `exact_library`. This function supports also sequential networks.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `is_ci`
+ * - `is_constant`
+ * - `node_to_index`
+ * - `index_to_node`
+ * - `get_node`
+ * - `foreach_po`
+ * - `foreach_node`
+ * - `fanout_size`
+ *
+ * \param ntk Network
+ * \param library Exact library
+ * \param ps Mapping params
+ * \param pst Mapping statistics
+ */
+template<class Ntk, unsigned CutSize = 4u, typename CutData = cut_enumeration_exact_map_cut, class NtkDest, unsigned NInputs>
+NtkDest map( Ntk& ntk, exact_library<NtkDest, NInputs> const& library, map_params const& ps = {}, map_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_is_ci_v<Ntk>, "Ntk does not implement the is_ci method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_incr_value_v<NtkDest>, "Ntk does not implement the incr_value method" );
+  static_assert( has_decr_value_v<NtkDest>, "Ntk does not implement the decr_value method" );
+  static_assert( has_foreach_ri_v<Ntk> == has_create_ri_v<NtkDest>, "Ntk and NtkDest networks are not both sequential" );
+  static_assert( has_foreach_ro_v<Ntk> == has_create_ro_v<NtkDest>, "Ntk and NtkDest networks are not both sequential" );
+
+  map_stats st;
+  detail::exact_map_impl<NtkDest, CutSize, CutData, Ntk, NInputs> p( ntk, library, ps, st );
+  auto res = p.run();
+
+  st.time_total = st.time_mapping + st.cut_enumeration_st.time_total;
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+
+  return res;
+}
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/mig_algebraic_rewriting.hpp b/include/mockturtle/algorithms/mig_algebraic_rewriting.hpp
new file mode 100644
index 0000000..9aa2fce
--- /dev/null
+++ b/include/mockturtle/algorithms/mig_algebraic_rewriting.hpp
@@ -0,0 +1,376 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mig_algebraic_rewriting.hpp
+  \brief MIG algebraric rewriting
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include "../utils/stopwatch.hpp"
+#include "../views/topo_view.hpp"
+
+#include <iostream>
+#include <optional>
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for mig_algebraic_depth_rewriting.
+ *
+ * The data structure `mig_algebraic_depth_rewriting_params` holds configurable
+ * parameters with default arguments for `mig_algebraic_depth_rewriting`.
+ */
+struct mig_algebraic_depth_rewriting_params
+{
+  /*! \brief Rewriting strategy. */
+  enum strategy_t
+  {
+    /*! \brief DFS rewriting strategy.
+     *
+     * Applies depth rewriting once to all output cones whose drivers have
+     * maximum levels
+     */
+    dfs,
+    /*! \brief Aggressive rewriting strategy.
+     *
+     * Applies depth reduction multiple times until the number of nodes, which
+     * cannot be rewritten, matches the number of nodes, in the current
+     * network; or the new network size is larger than the initial size w.r.t.
+     * to an `overhead`.
+     */
+    aggressive,
+    /*! \brief Selective rewriting strategy.
+     *
+     * Like `aggressive`, but only applies rewriting to nodes on critical paths
+     * and without `overhead`.
+     */
+    selective
+  } strategy = dfs;
+
+  /*! \brief Overhead factor in aggressive rewriting strategy.
+   *
+   * When comparing to the initial size in aggressive depth rewriting, also the
+   * number of dangling nodes are taken into account.
+   */
+  float overhead{ 2.0f };
+
+  /*! \brief Allow area increase while optimizing depth. */
+  bool allow_area_increase{ true };
+};
+
+/*! \brief Statistics for mig_algebraic_depth_rewriting. */
+struct mig_algebraic_depth_rewriting_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+};
+
+namespace detail
+{
+
+template<class Ntk>
+class mig_algebraic_depth_rewriting_impl
+{
+public:
+  mig_algebraic_depth_rewriting_impl( Ntk& ntk, mig_algebraic_depth_rewriting_params const& ps, mig_algebraic_depth_rewriting_stats& st )
+      : ntk( ntk ), ps( ps ), st( st )
+  {
+  }
+
+  void run()
+  {
+    stopwatch t( st.time_total );
+
+    switch ( ps.strategy )
+    {
+    case mig_algebraic_depth_rewriting_params::dfs:
+      run_dfs();
+      break;
+    case mig_algebraic_depth_rewriting_params::selective:
+      run_selective();
+      break;
+    case mig_algebraic_depth_rewriting_params::aggressive:
+      run_aggressive();
+      break;
+    }
+  }
+
+private:
+  void run_dfs()
+  {
+    ntk.foreach_po( [this]( auto po ) {
+      const auto driver = ntk.get_node( po );
+      if ( ntk.level( driver ) < ntk.depth() )
+        return;
+      topo_view topo{ ntk, po };
+      topo.foreach_node( [this]( auto n ) {
+        reduce_depth( n );
+        return true;
+      } );
+    } );
+  }
+
+  void run_selective()
+  {
+    uint32_t counter{ 0 };
+    while ( true )
+    {
+      mark_critical_paths();
+
+      topo_view topo{ ntk };
+      topo.foreach_node( [this, &counter]( auto n ) {
+        if ( ntk.fanout_size( n ) == 0 || ntk.value( n ) == 0 )
+          return;
+
+        if ( reduce_depth( n ) )
+        {
+          mark_critical_paths();
+        }
+        else
+        {
+          ++counter;
+        }
+      } );
+
+      if ( counter > ntk.size() )
+        break;
+    }
+  }
+
+  void run_aggressive()
+  {
+    uint32_t counter{ 0 }, init_size{ ntk.size() };
+    while ( true )
+    {
+      topo_view topo{ ntk };
+      topo.foreach_node( [this, &counter]( auto n ) {
+        if ( ntk.fanout_size( n ) == 0 )
+          return;
+
+        if ( !reduce_depth( n ) )
+        {
+          ++counter;
+        }
+      } );
+
+      if ( ntk.size() > ps.overhead * init_size )
+        break;
+      if ( counter > ntk.size() )
+        break;
+    }
+  }
+
+private:
+  bool reduce_depth( node<Ntk> const& n )
+  {
+    if ( !ntk.is_maj( n ) )
+      return false;
+
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    if ( !ntk.is_maj( ntk.get_node( ocs[2] ) ) )
+      return false;
+
+    /* depth of last child must be (significantly) higher than depth of second child */
+    if ( ntk.level( ntk.get_node( ocs[2] ) ) <= ntk.level( ntk.get_node( ocs[1] ) ) + 1 )
+      return false;
+
+    /* child must have single fanout, if no area overhead is allowed */
+    if ( !ps.allow_area_increase && ntk.fanout_size( ntk.get_node( ocs[2] ) ) != 1 )
+      return false;
+
+    /* get children of last child */
+    auto ocs2 = ordered_children( ntk.get_node( ocs[2] ) );
+
+    /* depth of last grand-child must be higher than depth of second grand-child */
+    if ( ntk.level( ntk.get_node( ocs2[2] ) ) == ntk.level( ntk.get_node( ocs2[1] ) ) )
+      return false;
+
+    /* propagate inverter if necessary */
+    if ( ntk.is_complemented( ocs[2] ) )
+    {
+      ocs2[0] = !ocs2[0];
+      ocs2[1] = !ocs2[1];
+      ocs2[2] = !ocs2[2];
+    }
+
+    if ( auto cand = associativity_candidate( ocs[0], ocs[1], ocs2[0], ocs2[1], ocs2[2] ); cand )
+    {
+      const auto& [x, y, z, u, assoc] = *cand;
+      auto opt = ntk.create_maj( z, assoc ? u : x, ntk.create_maj( x, y, u ) );
+      ntk.substitute_node( n, opt );
+      ntk.update_levels();
+
+      return true;
+    }
+
+    /* distributivity */
+    if ( ps.allow_area_increase )
+    {
+      auto opt = ntk.create_maj( ocs2[2],
+                                 ntk.create_maj( ocs[0], ocs[1], ocs2[0] ),
+                                 ntk.create_maj( ocs[0], ocs[1], ocs2[1] ) );
+      ntk.substitute_node( n, opt );
+      ntk.update_levels();
+    }
+    return true;
+  }
+
+  using candidate_t = std::tuple<signal<Ntk>, signal<Ntk>, signal<Ntk>, signal<Ntk>, bool>;
+  std::optional<candidate_t> associativity_candidate( signal<Ntk> const& v, signal<Ntk> const& w, signal<Ntk> const& x, signal<Ntk> const& y, signal<Ntk> const& z ) const
+  {
+    if ( v.index == x.index )
+    {
+      return candidate_t{ w, y, z, v, v.complement == x.complement };
+    }
+    if ( v.index == y.index )
+    {
+      return candidate_t{ w, x, z, v, v.complement == y.complement };
+    }
+    if ( w.index == x.index )
+    {
+      return candidate_t{ v, y, z, w, w.complement == x.complement };
+    }
+    if ( w.index == y.index )
+    {
+      return candidate_t{ v, x, z, w, w.complement == y.complement };
+    }
+
+    return std::nullopt;
+  }
+
+  std::array<signal<Ntk>, 3> ordered_children( node<Ntk> const& n ) const
+  {
+    std::array<signal<Ntk>, 3> children;
+    ntk.foreach_fanin( n, [&children]( auto const& f, auto i ) { children[i] = f; } );
+    std::stable_sort( children.begin(), children.end(), [this]( auto const& c1, auto const& c2 ) {
+      return ntk.level( ntk.get_node( c1 ) ) < ntk.level( ntk.get_node( c2 ) );
+    } );
+    return children;
+  }
+
+  void mark_critical_path( node<Ntk> const& n )
+  {
+    if ( ntk.is_pi( n ) || ntk.is_constant( n ) || ntk.value( n ) )
+      return;
+
+    const auto level = ntk.level( n );
+    ntk.set_value( n, 1 );
+    ntk.foreach_fanin( n, [this, level]( auto const& f ) {
+      if ( ntk.level( ntk.get_node( f ) ) == level - 1 )
+      {
+        mark_critical_path( ntk.get_node( f ) );
+      }
+    } );
+  }
+
+  void mark_critical_paths()
+  {
+    ntk.clear_values();
+    ntk.foreach_po( [this]( auto const& f ) {
+      if ( ntk.level( ntk.get_node( f ) ) == ntk.depth() )
+      {
+        mark_critical_path( ntk.get_node( f ) );
+      }
+    } );
+  }
+
+private:
+  Ntk& ntk;
+  mig_algebraic_depth_rewriting_params const& ps;
+  mig_algebraic_depth_rewriting_stats& st;
+};
+
+} // namespace detail
+
+/*! \brief Majority algebraic depth rewriting.
+ *
+ * This algorithm tries to rewrite a network with majority gates for depth
+ * optimization using the associativity and distributivity rule in
+ * majority-of-3 logic.  It can be applied to networks other than MIGs, but
+ * only considers pairs of nodes which both implement the majority-of-3
+ * function.
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `level`
+ * - `update_levels`
+ * - `create_maj`
+ * - `substitute_node`
+ * - `foreach_node`
+ * - `foreach_po`
+ * - `foreach_fanin`
+ * - `is_maj`
+ * - `clear_values`
+ * - `set_value`
+ * - `value`
+ * - `fanout_size`
+ *
+   \verbatim embed:rst
+
+  .. note::
+
+      The implementation of this algorithm was heavily inspired by an
+      implementation from Luca Amarù.
+   \endverbatim
+ */
+template<class Ntk>
+void mig_algebraic_depth_rewriting( Ntk& ntk, mig_algebraic_depth_rewriting_params const& ps = {}, mig_algebraic_depth_rewriting_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_level_v<Ntk>, "Ntk does not implement the level method" );
+  static_assert( has_create_maj_v<Ntk>, "Ntk does not implement the create_maj method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the substitute_node method" );
+  static_assert( has_update_levels_v<Ntk>, "Ntk does not implement the update_levels method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_is_maj_v<Ntk>, "Ntk does not implement the is_maj method" );
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_value_v<Ntk>, "Ntk does not implement the value method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+
+  mig_algebraic_depth_rewriting_stats st;
+  detail::mig_algebraic_depth_rewriting_impl<Ntk> p( ntk, ps, st );
+  p.run();
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/mig_inv_optimization.hpp b/include/mockturtle/algorithms/mig_inv_optimization.hpp
new file mode 100644
index 0000000..7e0473c
--- /dev/null
+++ b/include/mockturtle/algorithms/mig_inv_optimization.hpp
@@ -0,0 +1,394 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mig_inv_optimization.hpp
+  \brief MIG inverter optimization
+
+  \author Bugra Eryilmaz
+  \author Marcel Walter
+*/
+
+#pragma once
+
+#include "../networks/mig.hpp"
+#include "../networks/storage.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../views/fanout_view.hpp"
+
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
+#include <memory>
+#include <type_traits>
+#include <vector>
+
+namespace mockturtle
+{
+
+/*! \brief Statistics for mig_inv_optimization. */
+struct mig_inv_optimization_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Number of one level inverted nodes. */
+  int32_t num_inverted{ 0 };
+
+  /*! \brief Number of two level inverted nodes. */
+  int32_t num_two_level_inverted{ 0 };
+
+  /*! \brief Total gain in terms of number of inverters. */
+  int32_t total_gain{ 0 };
+};
+
+namespace detail
+{
+
+template<class Ntk>
+class mig_inv_optimization_impl
+{
+public:
+  mig_inv_optimization_impl( Ntk& ntk, mig_inv_optimization_stats& st )
+      : ntk( ntk ), st( st )
+  {
+  }
+
+  void run()
+  {
+    stopwatch t( st.time_total );
+
+    minimize();
+  }
+
+private:
+  /*! \brief implements the inverter minimization algorithm */
+  void minimize()
+  {
+    bool changed = true;
+    while ( changed )
+    {
+      changed = false;
+      ntk.foreach_gate( [this, &changed]( auto const& f ) {
+        int32_t gain = calculate_gain( f );
+        if ( gain > 0 )
+        {
+          st.num_inverted++;
+          st.total_gain += gain;
+          changed = true;
+          invert_node( f );
+        }
+        else if ( two_level_gain( f ) > 0 )
+        {
+          st.num_two_level_inverted++;
+          st.total_gain += gain;
+          changed = true;
+          std::vector<node<Ntk>> nodes_to_invert{};
+          ntk.foreach_fanout( f, [this, &f, &nodes_to_invert]( auto const& parent ) {
+            // convert each fanout if inverting it makes sense
+            int32_t sub_gain = 0;
+            sub_gain += calculate_gain( parent );
+            if ( is_complemented_parent( parent, f ) )
+            {
+              // if the connection between f and parent is complemented, we counted the same gain twice which will not be inverted at all
+              sub_gain -= 2;
+            }
+            else
+            {
+              // if the connection between f and parent is not complemented, we counted the same negative gain twice which will not be inverted at all
+              sub_gain += 2;
+            }
+            if ( sub_gain > 0 )
+            {
+              st.total_gain += sub_gain;
+              nodes_to_invert.push_back( parent );
+            }
+          } );
+          invert_node( f );
+          for ( auto const& n : nodes_to_invert )
+          {
+            invert_node( n );
+          }
+        }
+      } );
+    }
+  }
+
+  /*! \brief calculates the decrease in the number of inverters if this node is inverted and all fanouts that is beneficial also inverted */
+  int32_t two_level_gain( node<Ntk> n )
+  {
+    int32_t gain = 0;
+    gain += calculate_gain( n );
+
+    ntk.foreach_fanout( n, [this, &gain, &n]( auto const& f ) {
+      int32_t sub_gain = 0;
+      sub_gain += calculate_gain( f );
+      if ( is_complemented_parent( f, n ) )
+      {
+        // if the connection between f and parent is complemented, we counted the same gain twice which will not be inverted at all
+        sub_gain -= 2;
+      }
+      else
+      {
+        // if the connection between f and parent is not complemented, we counted the same negative gain twice which will not be inverted at all
+        sub_gain += 2;
+      }
+
+      // convert each fanout if inverting it makes sense
+      if ( sub_gain > 0 )
+      {
+        gain += sub_gain;
+      }
+    } );
+
+    return gain;
+  }
+
+  /*! \brief calculates the decrease in the number of inverters if this node is inverted */
+  int32_t calculate_gain( node<Ntk> n )
+  {
+    if ( ntk.is_dead( n ) )
+    {
+      std::cerr << "node" << n << " is dead\n";
+      return 0;
+    }
+    int32_t gain = 0;
+
+    // count the inverted and non-inverted fanins
+    ntk.foreach_fanin( n, [this, &gain]( auto const& f ) {
+      if ( ntk.is_constant( ntk.get_node( f ) ) )
+      {
+        return;
+      }
+      update_gain_is_complemented( f, gain );
+    } );
+
+    // count the inverted and non-inverted fanouts
+    ntk.foreach_fanout( n, [this, &n, &gain]( auto const& parent ) {
+      if ( is_complemented_parent( parent, n ) )
+      {
+        gain++;
+      }
+      else
+      {
+        gain--;
+      }
+    } );
+
+    // count the inverted and non-inverted POs
+    ntk.foreach_po( [this, &n, &gain]( auto const& f ) {
+      if ( ntk.get_node( f ) == n )
+      {
+        update_gain_is_complemented( f, gain );
+      }
+    } );
+    return gain;
+  }
+
+  /*! \brief increases the gain if signal f is complemented, decreases otherwise. */
+  void update_gain_is_complemented( signal<Ntk> f, int32_t& gain )
+  {
+    if ( ntk.is_complemented( f ) )
+    {
+      gain++;
+    }
+    else
+    {
+      gain--;
+    }
+  }
+
+  /*! \brief checks if parent is parent of child and returns if the connection is complemented. */
+  bool is_complemented_parent( node<Ntk> parent, node<Ntk> child )
+  {
+    bool ret = false;
+    bool changed = false;
+    ntk.foreach_fanin( parent, [this, &child, &ret, &changed]( auto const& f ) {
+      if ( ntk.get_node( f ) == child )
+      {
+        changed = true;
+        ret = ntk.is_complemented( f );
+      }
+    } );
+    if ( !changed )
+    {
+      std::cerr << "parent " << parent << " is not parent of child " << child << "\n";
+    }
+    return ret;
+  }
+
+  /*! \brief inverts the inputs and changes all occurances of the node with the !inverted_node. */
+  void invert_node( node<Ntk> n )
+  {
+    signal<Ntk> a, b, c;
+    ntk.foreach_fanin( n, [&]( auto const& f, auto idx ) {
+      if ( idx == 0 )
+      {
+        a = f;
+      }
+      else if ( idx == 1 )
+      {
+        b = f;
+      }
+      else if ( idx == 2 )
+      {
+        c = f;
+      }
+    } );
+    signal<Ntk> new_node = !create_maj_directly( !a, !b, !c );
+    ntk.substitute_node( n, new_node );
+    ntk.replace_in_outputs( n, new_node );
+  }
+
+  /*! \brief original create_maj function was inverting the node
+             if more than 2 of the inputs were inverted which is
+             not suitable for the algorithm, so I removed that part. */
+  signal<Ntk> create_maj_directly( signal<Ntk> a, signal<Ntk> b, signal<Ntk> c )
+  {
+    /* order inputs */
+    if ( a.index > b.index )
+    {
+      std::swap( a, b );
+      if ( b.index > c.index )
+      {
+        std::swap( b, c );
+      }
+      if ( a.index > b.index )
+      {
+        std::swap( a, b );
+      }
+    }
+    else
+    {
+      if ( b.index > c.index )
+      {
+        std::swap( b, c );
+      }
+      if ( a.index > b.index )
+      {
+        std::swap( a, b );
+      }
+    }
+
+    /* trivial cases */
+    if ( a.index == b.index )
+    {
+      return ( a.complement == b.complement ) ? a : c;
+    }
+    if ( b.index == c.index )
+    {
+      return ( b.complement == c.complement ) ? b : a;
+    }
+
+    std::shared_ptr<storage<regular_node<3, 2, 1>>>::element_type::node_type nd;
+    nd.children[0] = a;
+    nd.children[1] = b;
+    nd.children[2] = c;
+
+    /* structural hashing */
+    if ( auto const it = ntk._storage->hash.find( nd ); it != ntk._storage->hash.end() )
+    {
+      return { it->second, 0 };
+    }
+
+    auto const index = ntk._storage->nodes.size();
+
+    if ( index >= .9 * ntk._storage->nodes.capacity() )
+    {
+      ntk._storage->nodes.reserve( static_cast<uint64_t>( 3.1415f * index ) );
+      ntk._storage->hash.reserve( static_cast<uint64_t>( 3.1415f * index ) );
+    }
+
+    ntk._storage->nodes.push_back( nd );
+
+    ntk._storage->hash[nd] = index;
+
+    /* increase ref-count to children */
+    ntk._storage->nodes[a.index].data[0].h1++;
+    ntk._storage->nodes[b.index].data[0].h1++;
+    ntk._storage->nodes[c.index].data[0].h1++;
+
+    for ( auto const& fn : ntk._events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return { index, 0 };
+  }
+
+private:
+  fanout_view<Ntk> ntk;
+  mig_inv_optimization_stats& st;
+};
+
+} // namespace detail
+
+/*! \brief MIG inverter optimization.
+ *
+ * This algorithm tries to reduce the number
+ * of inverters in a MIG network without
+ * increasing the node number. It checks each
+ * node for 1 level and 2 level optimization
+ * opportunuties and inverts the node if it
+ * decreases the number of inverted connections.
+ * It does not count constant values as inverted
+ * even if they are complemented in the graph.
+ *
+ * **Required network functions:**
+ * 'foreach_fanin'
+ * 'foreach_fanout'
+ * 'substitute_node'
+ * 'replace_in_outputs'
+ * 'is_complemented'
+ * 'get_node'
+ * 'is_dead'
+ * 'is_constant'
+ * 'foreach_gate'
+ */
+template<class Ntk>
+void mig_inv_optimization( Ntk& ntk, mig_inv_optimization_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( std::is_same_v<typename Ntk::base_type, mig_network>, "Ntk is not an MIG network" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the substitute_node method" );
+  static_assert( has_replace_in_outputs_v<Ntk>, "Ntk does not implement the replace_in_outputs method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_dead_v<Ntk>, "Ntk does not implement the is_dead method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+
+  mig_inv_optimization_stats st;
+  detail::mig_inv_optimization_impl<Ntk> p( ntk, st );
+  p.run();
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/mig_inv_propagation.hpp b/include/mockturtle/algorithms/mig_inv_propagation.hpp
new file mode 100644
index 0000000..ce9163b
--- /dev/null
+++ b/include/mockturtle/algorithms/mig_inv_propagation.hpp
@@ -0,0 +1,374 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mig_inv_propagation.hpp
+  \brief MIG inverter optimization
+
+  \author Bugra Eryilmaz
+  \author Marcel Walter
+*/
+
+#pragma once
+
+#include "../networks/mig.hpp"
+#include "../networks/storage.hpp"
+#include "../utils/stopwatch.hpp"
+#include "./cleanup.hpp"
+
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
+#include <memory>
+#include <type_traits>
+#include <vector>
+
+namespace mockturtle
+{
+
+/*! \brief Statistics for mig_inv_propagation. */
+struct mig_inv_propagation_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Increase in the node count. */
+  uint32_t node_increase{ 0 };
+
+  /*! \brief Total gain in terms of number of inverters. */
+  uint32_t total_gain{ 0 };
+};
+
+namespace detail
+{
+
+template<class Ntk>
+class mig_inv_propagation_impl
+{
+public:
+  mig_inv_propagation_impl( Ntk& ntk, mig_inv_propagation_stats& st )
+      : ntk( ntk ), st( st )
+  {
+  }
+
+  void run()
+  {
+    stopwatch t( st.time_total );
+
+    auto const initial_size = number_of_nodes( ntk );
+    auto const initial_inverters = number_of_inverters( ntk );
+
+    propagate();
+
+    st.node_increase = number_of_nodes( ntk ) - initial_size;
+    st.total_gain = initial_inverters - number_of_inverters( ntk );
+  }
+
+private:
+  /*! \brief implements the inverter propagation algorithm */
+  void propagate()
+  {
+    // starting from primary outputs, propagate the inversions
+    ntk.foreach_po( [this]( auto const& f ) {
+      if ( ntk.is_complemented( f ) )
+      {
+        // if it is complemented, invert the node
+        auto const old_node = ntk.get_node( f );
+        auto const new_node = invert_node( old_node );
+
+        // replace the po with the inverted node
+        ntk.replace_in_outputs( old_node, new_node );
+
+        // check if the old node should stay alive
+        if ( ntk.fanout_size( old_node ) == 0 )
+        {
+          ntk.take_out_node( old_node );
+        }
+
+        // propagate the inversions to the inputs
+        propagate_helper( ntk.get_node( new_node ) );
+      }
+      else
+      {
+        // propagate the inversions to the inputs
+        propagate_helper( ntk.get_node( f ) );
+      }
+    } );
+  }
+
+  void propagate_helper( const node<Ntk> n )
+  {
+    std::vector<node<Ntk>> complement_list{};
+    complement_list.reserve( Ntk::max_fanin_size );
+
+    // for each fanin, check if it is complemented
+    ntk.foreach_fanin( n, [this, &complement_list]( auto const& f ) {
+      // skip if it is a constant, PI
+      if ( ntk.is_constant( ntk.get_node( f ) ) || ntk.is_pi( ntk.get_node( f ) ) )
+      {
+        return;
+      }
+      // there should not be a dead child
+      if ( ntk.is_dead( ntk.get_node( f ) ) )
+      {
+        std::cerr << "node " << ntk.get_node( f ) << " is dead\n";
+      }
+
+      // lazy substitute node since child order is fixed and
+      // changing one child will mix the order and create a bug
+      // in the foreach_fanin loop
+      if ( ntk.is_complemented( f ) )
+      {
+        complement_list.push_back( ntk.get_node( f ) );
+      }
+      else
+      {
+        // propagate the inversions to the inputs
+        propagate_helper( ntk.get_node( f ) );
+      }
+    } );
+
+    // lazy invert the complemented fanins
+    for ( auto const& f : complement_list )
+    {
+      // for each complemented fanin, invert the node
+      auto const new_node = invert_node( f );
+      // replace the fanin with the inverted node
+      if ( auto const simplification = ntk.replace_in_node( n, f, new_node ) )
+      {
+        ntk.substitute_node( simplification->first, simplification->second );
+      }
+
+      // check if the old node should stay alive
+      if ( ntk.fanout_size( f ) == 0 )
+      {
+        ntk.take_out_node( f );
+      }
+
+      // propagate the inversions to the inputs
+      propagate_helper( ntk.get_node( new_node ) );
+    }
+  }
+
+  /*! \brief gets maj(a,b,c) returns !maj(!a,!b,!c). */
+  signal<Ntk> invert_node( const node<Ntk> n )
+  {
+    signal<Ntk> a, b, c;
+
+    ntk.foreach_fanin( n, [&a, &b, &c]( auto const& f, auto idx ) {
+      if ( idx == 0 )
+      {
+        a = f;
+      }
+      else if ( idx == 1 )
+      {
+        b = f;
+      }
+      else if ( idx == 2 )
+      {
+        c = f;
+      }
+    } );
+
+    return !create_maj_directly( !a, !b, !c );
+  }
+
+  /**
+   * \brief The original create_maj function was inverting the node if more than
+   * 2 of the inputs were inverted which is not suitable for the algorithm,
+   * so I removed that part.
+   */
+  signal<Ntk> create_maj_directly( signal<Ntk> a, signal<Ntk> b, signal<Ntk> c )
+  {
+    /* order inputs */
+    if ( a.index > b.index )
+    {
+      std::swap( a, b );
+      if ( b.index > c.index )
+      {
+        std::swap( b, c );
+      }
+      if ( a.index > b.index )
+      {
+        std::swap( a, b );
+      }
+    }
+    else
+    {
+      if ( b.index > c.index )
+      {
+        std::swap( b, c );
+      }
+      if ( a.index > b.index )
+      {
+        std::swap( a, b );
+      }
+    }
+
+    /* trivial cases */
+    if ( a.index == b.index )
+    {
+      return ( a.complement == b.complement ) ? a : c;
+    }
+    if ( b.index == c.index )
+    {
+      return ( b.complement == c.complement ) ? b : a;
+    }
+
+    std::shared_ptr<storage<regular_node<3, 2, 1>>>::element_type::node_type nd;
+    nd.children[0] = a;
+    nd.children[1] = b;
+    nd.children[2] = c;
+
+    /* structural hashing */
+    auto const it = ntk._storage->hash.find( nd );
+    if ( it != ntk._storage->hash.end() )
+    {
+      return { it->second, 0 };
+    }
+
+    auto const index = ntk._storage->nodes.size();
+
+    if ( index >= .9 * ntk._storage->nodes.capacity() )
+    {
+      ntk._storage->nodes.reserve( static_cast<uint64_t>( 3.1415f * index ) );
+      ntk._storage->hash.reserve( static_cast<uint64_t>( 3.1415f * index ) );
+    }
+
+    ntk._storage->nodes.push_back( nd );
+
+    ntk._storage->hash[nd] = index;
+
+    /* increase ref-count to children */
+    ntk._storage->nodes[a.index].data[0].h1++;
+    ntk._storage->nodes[b.index].data[0].h1++;
+    ntk._storage->nodes[c.index].data[0].h1++;
+
+    for ( auto const& fn : ntk._events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return { index, 0 };
+  }
+
+  uint32_t number_of_inverters( Ntk const& ntk ) const
+  {
+    uint32_t num_inverters{ 0 };
+    ntk.foreach_gate( [&]( auto const& n ) {
+      ntk.foreach_fanin( n, [&]( auto const& f ) {
+        if ( ntk.is_dead( ntk.get_node( f ) ) )
+        {
+          return;
+        }
+        if ( ntk.is_constant( ntk.get_node( f ) ) || ntk.is_pi( ntk.get_node( f ) ) )
+        {
+          return;
+        }
+        if ( ntk.is_complemented( f ) )
+        {
+          ++num_inverters;
+        }
+      } );
+    } );
+
+    ntk.foreach_po( [&]( auto const& f ) {
+      if ( ntk.is_complemented( f ) )
+      {
+        ++num_inverters;
+      }
+    } );
+
+    return num_inverters;
+  }
+  /**
+   * \brief Determines the number of nodes in the given network that are actually alive.
+   */
+  uint64_t number_of_nodes( Ntk const& ntk ) const
+  {
+    uint64_t nodes{};
+
+    ntk.foreach_node( [&nodes]( auto const ) {
+      ++nodes;
+    } );
+
+    return nodes;
+  }
+
+private:
+  Ntk& ntk;
+  mig_inv_propagation_stats& st;
+};
+
+} // namespace detail
+
+/*! \brief MIG inverter propagation.
+ *
+ * This algorithm tries to push all
+ * the inverters to the inputs.
+ * However, it can increase the number
+ * of nodes while doing so.
+ *
+ * **Required network functions:**
+ * get_node
+ * substitute_node
+ * take_out_node
+ * foreach_fanin
+ * replace_in_node
+ * fanout_size
+ * is_complemented
+ * is_dead
+ * is_constant
+ * is_pi
+ * foreach_po
+ */
+template<class Ntk>
+void mig_inv_propagation( Ntk& ntk, mig_inv_propagation_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( std::is_same_v<typename Ntk::base_type, mig_network>, "Ntk is not an MIG network" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the substitute_node method" );
+  static_assert( has_take_out_node_v<Ntk>, "Ntk does not implement the take_out_node method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_replace_in_node_v<Ntk>, "Ntk does not implement the replace_in_node method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_is_dead_v<Ntk>, "Ntk does not implement the is_dead method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+
+  mig_inv_propagation_stats st;
+  detail::mig_inv_propagation_impl<Ntk> p( ntk, st );
+  p.run();
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/mig_resub.hpp b/include/mockturtle/algorithms/mig_resub.hpp
new file mode 100644
index 0000000..1998a83
--- /dev/null
+++ b/include/mockturtle/algorithms/mig_resub.hpp
@@ -0,0 +1,875 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mig_resub.hpp
+  \brief Majority-specific resustitution rules
+
+  \author Eleonora Testa
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../networks/mig.hpp"
+#include "../utils/index_list.hpp"
+#include "../utils/truth_table_utils.hpp"
+#include "resubstitution.hpp"
+#include "resyn_engines/mig_resyn.hpp"
+
+#include <kitty/kitty.hpp>
+
+namespace mockturtle
+{
+
+struct mig_enumerative_resub_stats
+{
+  /*! \brief Accumulated runtime for const-resub */
+  stopwatch<>::duration time_resubC{ 0 };
+
+  /*! \brief Accumulated runtime for zero-resub */
+  stopwatch<>::duration time_resub0{ 0 };
+
+  /*! \brief Accumulated runtime for collecting unate divisors. */
+  stopwatch<>::duration time_collect_unate_divisors{ 0 };
+
+  /*! \brief Accumulated runtime for one-resub */
+  stopwatch<>::duration time_resub1{ 0 };
+
+  /*! \brief Accumulated runtime for relevance resub */
+  stopwatch<>::duration time_resubR{ 0 };
+
+  /*! \brief Accumulated runtime for collecting unate divisors. */
+  stopwatch<>::duration time_collect_binate_divisors{ 0 };
+
+  /*! \brief Accumulated runtime for two-resub. */
+  stopwatch<>::duration time_resub2{ 0 };
+
+  /*! \brief Number of accepted constant resubsitutions */
+  uint32_t num_const_accepts{ 0 };
+
+  /*! \brief Number of accepted zero resubsitutions */
+  uint32_t num_div0_accepts{ 0 };
+
+  /*! \brief Number of accepted one resubsitutions */
+  uint64_t num_div1_accepts{ 0 };
+
+  /*! \brief Number of accepted relevance resubsitutions */
+  uint32_t num_divR_accepts{ 0 };
+
+  /*! \brief Number of accepted two resubsitutions */
+  uint64_t num_div2_accepts{ 0 };
+
+  void report() const
+  {
+    std::cout << "[i] kernel: mig_enumerative_resub_functor\n";
+    std::cout << fmt::format( "[i]     constant-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_const_accepts, to_seconds( time_resubC ) );
+    std::cout << fmt::format( "[i]            0-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_div0_accepts, to_seconds( time_resub0 ) );
+    std::cout << fmt::format( "[i]            R-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_divR_accepts, to_seconds( time_resubR ) );
+    std::cout << fmt::format( "[i]            collect unate divisors                           ({:>5.2f} secs)\n", to_seconds( time_collect_unate_divisors ) );
+    std::cout << fmt::format( "[i]            1-resub {:6d} = {:6d} MAJ                      ({:>5.2f} secs)\n",
+                              num_div1_accepts, num_div1_accepts, to_seconds( time_resub1 ) );
+    std::cout << fmt::format( "[i]            collect binate divisors                          ({:>5.2f} secs)\n", to_seconds( time_collect_binate_divisors ) );
+    std::cout << fmt::format( "[i]            2-resub {:6d} = {:6d} 2MAJ                     ({:>5.2f} secs)\n",
+                              num_div2_accepts, num_div2_accepts, to_seconds( time_resub2 ) );
+    std::cout << fmt::format( "[i]            total   {:6d}\n",
+                              ( num_const_accepts + num_div0_accepts + num_divR_accepts + num_div1_accepts + num_div2_accepts ) );
+  }
+}; /* mig_enumerative_resub_stats */
+
+template<typename Ntk, typename Simulator, typename TT, bool use_constant = true>
+struct mig_enumerative_resub_functor
+{
+public:
+  using node = mig_network::node;
+  using signal = mig_network::signal;
+  using stats = mig_enumerative_resub_stats;
+
+  struct unate_divisors
+  {
+    std::vector<signal> u0;
+    std::vector<signal> u1;
+    std::vector<signal> next_candidates;
+
+    void clear()
+    {
+      u0.clear();
+      u1.clear();
+      next_candidates.clear();
+    }
+  };
+
+  struct binate_divisors
+  {
+    std::vector<signal> b0;
+    std::vector<signal> b1;
+    std::vector<signal> b2;
+
+    void clear()
+    {
+      b0.clear();
+      b1.clear();
+      b2.clear();
+    }
+  };
+
+public:
+  explicit mig_enumerative_resub_functor( Ntk& ntk, Simulator const& sim, std::vector<node> const& divs, uint32_t num_divs, stats& st )
+      : ntk( ntk ), sim( sim ), divs( divs ), num_divs( num_divs ), st( st )
+  {
+  }
+
+  std::optional<signal> operator()( node const& root, TT care, uint32_t required, uint32_t max_inserts, uint32_t num_mffc, uint32_t& last_gain )
+  {
+    (void)care;
+    assert( is_const0( ~care ) );
+
+    /* consider constants */
+    auto g = call_with_stopwatch( st.time_resubC, [&]() {
+      return resub_const( root, required );
+    } );
+    if ( g )
+    {
+      ++st.num_const_accepts;
+      last_gain = num_mffc;
+      return g; /* accepted resub */
+    }
+
+    /* consider equal nodes */
+    g = call_with_stopwatch( st.time_resub0, [&]() {
+      return resub_div0( root, required );
+    } );
+    if ( g )
+    {
+      ++st.num_div0_accepts;
+      last_gain = num_mffc;
+      return g; /* accepted resub */
+    }
+
+    /* consider relevance optimization */
+    g = call_with_stopwatch( st.time_resubR, [&]() {
+      return resub_divR( root, required );
+    } );
+    if ( g )
+    {
+      ++st.num_divR_accepts;
+      last_gain = num_mffc;
+      return g; /* accepted resub */
+    }
+
+    if ( max_inserts == 0 || num_mffc == 1 )
+      return std::nullopt;
+
+    /* collect level one divisors */
+    call_with_stopwatch( st.time_collect_unate_divisors, [&]() {
+      collect_unate_divisors( root, required );
+    } );
+
+    /* consider equal nodes */
+    g = call_with_stopwatch( st.time_resub1, [&]() {
+      return resub_div1( root, required );
+    } );
+    if ( g )
+    {
+      ++st.num_div1_accepts;
+      last_gain = num_mffc - 1;
+      return g; /* accepted resub */
+    }
+
+    if ( max_inserts == 1 || num_mffc == 2 )
+      return std::nullopt;
+
+    /* collect level two divisors */
+    call_with_stopwatch( st.time_collect_binate_divisors, [&]() {
+      collect_binate_divisors( root, required );
+    } );
+
+    /* consider two nodes */
+    g = call_with_stopwatch( st.time_resub2, [&]() { return resub_div2( root, required ); } );
+    if ( g )
+    {
+      ++st.num_div2_accepts;
+      last_gain = num_mffc - 2;
+      return g; /* accepted resub */
+    }
+
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_const( node const& root, uint32_t required ) const
+  {
+    (void)required;
+    auto const tt = sim.get_tt( ntk.make_signal( root ) );
+    if ( tt == sim.get_tt( ntk.get_constant( false ) ) )
+    {
+      return sim.get_phase( root ) ? ntk.get_constant( true ) : ntk.get_constant( false );
+    }
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_div0( node const& root, uint32_t required ) const
+  {
+    (void)required;
+    auto const tt = sim.get_tt( ntk.make_signal( root ) );
+    for ( auto i = 0u; i < num_divs; ++i )
+    {
+      auto const d = divs.at( i );
+
+      if ( tt != sim.get_tt( ntk.make_signal( d ) ) )
+        continue; /* next */
+
+      return ( sim.get_phase( d ) ^ sim.get_phase( root ) ) ? !ntk.make_signal( d ) : ntk.make_signal( d );
+    }
+
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_divR( node const& root, uint32_t required )
+  {
+    (void)required;
+
+    std::vector<signal> fs;
+    ntk.foreach_fanin( root, [&]( const auto& f ) {
+      fs.emplace_back( f );
+    } );
+
+    for ( auto i = 0u; i < divs.size(); ++i )
+    {
+      auto const& d0 = divs.at( i );
+      auto const& s = ntk.make_signal( d0 );
+      auto const& tt = sim.get_tt( s );
+
+      if ( d0 == root )
+        break;
+
+      auto const tt0 = sim.get_tt( fs[0] );
+      auto const tt1 = sim.get_tt( fs[1] );
+      auto const tt2 = sim.get_tt( fs[2] );
+
+      if ( ntk.get_node( fs[0] ) != d0 && ntk.fanout_size( ntk.get_node( fs[0] ) ) == 1 && can_replace_majority_fanin( tt0, tt1, tt2, tt ) )
+      {
+        auto const b = sim.get_phase( ntk.get_node( fs[1] ) ) ? !fs[1] : fs[1];
+        auto const c = sim.get_phase( ntk.get_node( fs[2] ) ) ? !fs[2] : fs[2];
+
+        return sim.get_phase( root ) ? !ntk.create_maj( sim.get_phase( d0 ) ? !s : s, b, c ) : ntk.create_maj( sim.get_phase( d0 ) ? !s : s, b, c );
+      }
+      else if ( ntk.get_node( fs[1] ) != d0 && ntk.fanout_size( ntk.get_node( fs[1] ) ) == 1 && can_replace_majority_fanin( tt1, tt0, tt2, tt ) )
+      {
+        auto const a = sim.get_phase( ntk.get_node( fs[0] ) ) ? !fs[0] : fs[0];
+        auto const c = sim.get_phase( ntk.get_node( fs[2] ) ) ? !fs[2] : fs[2];
+
+        return sim.get_phase( root ) ? !ntk.create_maj( sim.get_phase( d0 ) ? !s : s, a, c ) : ntk.create_maj( sim.get_phase( d0 ) ? !s : s, a, c );
+      }
+      else if ( ntk.get_node( fs[2] ) != d0 && ntk.fanout_size( ntk.get_node( fs[2] ) ) == 1 && can_replace_majority_fanin( tt2, tt0, tt1, tt ) )
+      {
+        auto const a = sim.get_phase( ntk.get_node( fs[0] ) ) ? !fs[0] : fs[0];
+        auto const b = sim.get_phase( ntk.get_node( fs[1] ) ) ? !fs[1] : fs[1];
+
+        return sim.get_phase( root ) ? !ntk.create_maj( sim.get_phase( d0 ) ? !s : s, a, b ) : ntk.create_maj( sim.get_phase( d0 ) ? !s : s, a, b );
+      }
+      else if ( ntk.get_node( fs[0] ) != d0 && ntk.fanout_size( ntk.get_node( fs[0] ) ) == 1 && can_replace_majority_fanin( ~tt0, tt1, tt2, tt ) )
+      {
+        auto const b = sim.get_phase( ntk.get_node( fs[1] ) ) ? !fs[1] : fs[1];
+        auto const c = sim.get_phase( ntk.get_node( fs[2] ) ) ? !fs[2] : fs[2];
+
+        return sim.get_phase( root ) ? !ntk.create_maj( sim.get_phase( d0 ) ? s : !s, b, c ) : ntk.create_maj( sim.get_phase( d0 ) ? s : !s, b, c );
+      }
+      else if ( ntk.get_node( fs[1] ) != d0 && ntk.fanout_size( ntk.get_node( fs[1] ) ) == 1 && can_replace_majority_fanin( ~tt1, tt0, tt2, tt ) )
+      {
+        auto const a = sim.get_phase( ntk.get_node( fs[0] ) ) ? !fs[0] : fs[0];
+        auto const c = sim.get_phase( ntk.get_node( fs[2] ) ) ? !fs[2] : fs[2];
+
+        return sim.get_phase( root ) ? !ntk.create_maj( sim.get_phase( d0 ) ? s : !s, a, c ) : ntk.create_maj( sim.get_phase( d0 ) ? s : !s, a, c );
+      }
+      else if ( ntk.get_node( fs[2] ) != d0 && ntk.fanout_size( ntk.get_node( fs[2] ) ) == 1 && can_replace_majority_fanin( ~tt2, tt0, tt1, tt ) )
+      {
+        auto const a = sim.get_phase( ntk.get_node( fs[0] ) ) ? !fs[0] : fs[0];
+        auto const b = sim.get_phase( ntk.get_node( fs[1] ) ) ? !fs[1] : fs[1];
+
+        return sim.get_phase( root ) ? !ntk.create_maj( sim.get_phase( d0 ) ? s : !s, a, b ) : ntk.create_maj( sim.get_phase( d0 ) ? s : !s, a, b );
+      }
+    }
+
+    return std::nullopt;
+  }
+
+  void collect_unate_divisors( node const& root, uint32_t required )
+  {
+    udivs.clear();
+
+    auto const& tt = sim.get_tt( ntk.make_signal( root ) );
+    auto const& one = sim.get_tt( ntk.get_constant( true ) );
+    for ( auto i = 0u; i < num_divs; ++i )
+    {
+      auto const d0 = divs.at( i );
+      if ( ntk.level( d0 ) > required - 1 )
+        continue;
+      auto const& tt_s0 = sim.get_tt( ntk.make_signal( d0 ) );
+
+      for ( auto j = i + 1; j < num_divs; ++j )
+      {
+        auto const d1 = divs.at( j );
+        if ( ntk.level( d1 ) > required - 1 )
+          continue;
+        auto const& tt_s1 = sim.get_tt( ntk.make_signal( d1 ) );
+
+        /* Boolean filtering rule for MAJ-3 */
+        if ( kitty::ternary_majority( tt_s0, tt_s1, tt ) == tt )
+        {
+          udivs.u0.emplace_back( ntk.make_signal( d0 ) );
+          udivs.u1.emplace_back( ntk.make_signal( d1 ) );
+          continue;
+        }
+
+        if ( kitty::ternary_majority( ~tt_s0, tt_s1, tt ) == tt )
+        {
+          udivs.u0.emplace_back( !ntk.make_signal( d0 ) );
+          udivs.u1.emplace_back( ntk.make_signal( d1 ) );
+          continue;
+        }
+
+        if ( kitty::ternary_majority( tt_s0, ~tt_s1, tt ) == tt )
+        {
+          udivs.u0.emplace_back( ntk.make_signal( d0 ) );
+          udivs.u1.emplace_back( !ntk.make_signal( d1 ) );
+          continue;
+        }
+
+        if ( std::find( udivs.next_candidates.begin(), udivs.next_candidates.end(), ntk.make_signal( d1 ) ) == udivs.next_candidates.end() )
+          udivs.next_candidates.emplace_back( ntk.make_signal( d1 ) );
+      }
+
+      if constexpr ( use_constant ) /* allowing "not real" MAJ gates (one fanin is constant) */
+      {
+        if ( kitty::ternary_majority( tt_s0, one, tt ) == tt )
+        {
+          udivs.u0.emplace_back( ntk.make_signal( d0 ) );
+          udivs.u1.emplace_back( ntk.get_constant( true ) );
+          continue;
+        }
+
+        if ( kitty::ternary_majority( ~tt_s0, one, tt ) == tt )
+        {
+          udivs.u0.emplace_back( !ntk.make_signal( d0 ) );
+          udivs.u1.emplace_back( ntk.get_constant( true ) );
+          continue;
+        }
+
+        if ( kitty::ternary_majority( tt_s0, ~one, tt ) == tt )
+        {
+          udivs.u0.emplace_back( ntk.make_signal( d0 ) );
+          udivs.u1.emplace_back( ntk.get_constant( false ) );
+          continue;
+        }
+      }
+
+      if ( std::find( udivs.next_candidates.begin(), udivs.next_candidates.end(), ntk.make_signal( d0 ) ) == udivs.next_candidates.end() )
+        udivs.next_candidates.emplace_back( ntk.make_signal( d0 ) );
+    }
+
+    if constexpr ( use_constant )
+    {
+      udivs.next_candidates.emplace_back( ntk.get_constant( true ) );
+    }
+  }
+
+  std::optional<signal> resub_div1( node const& root, uint32_t required )
+  {
+    (void)required;
+    auto const& tt = sim.get_tt( ntk.make_signal( root ) );
+
+    for ( auto i = 0u; i < udivs.u0.size(); ++i )
+    {
+      auto const s0 = udivs.u0.at( i );
+      auto const s1 = udivs.u1.at( i );
+      auto const& tt_s0 = sim.get_tt( s0 );
+      auto const& tt_s1 = sim.get_tt( s1 );
+
+      for ( auto j = i + 1; j < udivs.u0.size(); ++j )
+      {
+        auto s2 = udivs.u0.at( j );
+        auto tt_s2 = sim.get_tt( s2 );
+
+        if ( kitty::ternary_majority( tt_s0, tt_s1, tt_s2 ) == tt )
+        {
+          auto const a = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+          auto const b = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+          auto const c = sim.get_phase( ntk.get_node( s2 ) ) ? !s2 : s2;
+          return sim.get_phase( root ) ? !ntk.create_maj( a, b, c ) : ntk.create_maj( a, b, c );
+        }
+
+        s2 = udivs.u1.at( j );
+        tt_s2 = sim.get_tt( s2 );
+
+        if ( kitty::ternary_majority( tt_s0, tt_s1, tt_s2 ) == tt )
+        {
+          auto const a = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+          auto const b = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+          auto const c = sim.get_phase( ntk.get_node( s2 ) ) ? !s2 : s2;
+          return sim.get_phase( root ) ? !ntk.create_maj( a, b, c ) : ntk.create_maj( a, b, c );
+        }
+      }
+    }
+
+    return std::nullopt;
+  }
+
+  void collect_binate_divisors( node const& root, uint32_t required )
+  {
+    bdivs.clear();
+
+    auto const& tt = sim.get_tt( ntk.make_signal( root ) );
+    for ( auto i = 0u; i < udivs.next_candidates.size(); ++i )
+    {
+      auto const& s0 = udivs.next_candidates.at( i );
+      if ( ntk.level( ntk.get_node( s0 ) ) > required - 2 )
+        continue;
+
+      auto const& tt_s0 = sim.get_tt( s0 );
+
+      for ( auto j = i + 1; j < udivs.next_candidates.size(); ++j )
+      {
+        auto const& s1 = udivs.next_candidates.at( j );
+        if ( ntk.level( ntk.get_node( s1 ) ) > required - 2 )
+          continue;
+
+        auto const& tt_s1 = sim.get_tt( s1 );
+
+        for ( auto k = j + 1; k < udivs.next_candidates.size(); ++k )
+        {
+          auto const& s2 = udivs.next_candidates.at( k );
+          if ( ntk.level( ntk.get_node( s2 ) ) > required - 2 )
+            continue;
+
+          auto const& tt_s2 = sim.get_tt( s2 );
+
+          /* Note: the implication relation is actually not necessary for majority; this is an over-filtering */
+          if ( kitty::implies( kitty::ternary_majority( tt_s0, tt_s1, tt_s2 ), tt ) )
+          {
+            bdivs.b0.emplace_back( s0 );
+            bdivs.b1.emplace_back( s1 );
+            bdivs.b2.emplace_back( s2 );
+            continue;
+          }
+
+          if ( kitty::implies( kitty::ternary_majority( ~tt_s0, tt_s1, tt_s2 ), tt ) )
+          {
+            bdivs.b0.emplace_back( !s0 );
+            bdivs.b1.emplace_back( s1 );
+            bdivs.b2.emplace_back( s2 );
+            continue;
+          }
+
+          if ( kitty::implies( kitty::ternary_majority( tt_s0, ~tt_s1, tt_s2 ), tt ) )
+          {
+            bdivs.b0.emplace_back( s0 );
+            bdivs.b1.emplace_back( !s1 );
+            bdivs.b2.emplace_back( s2 );
+            continue;
+          }
+
+          if ( kitty::implies( kitty::ternary_majority( tt_s0, tt_s1, ~tt_s2 ), tt ) )
+          {
+            bdivs.b0.emplace_back( s0 );
+            bdivs.b1.emplace_back( s1 );
+            bdivs.b2.emplace_back( !s2 );
+            continue;
+          }
+
+          if ( kitty::implies( kitty::ternary_majority( ~tt_s0, ~tt_s1, tt_s2 ), tt ) )
+          {
+            bdivs.b0.emplace_back( !s0 );
+            bdivs.b1.emplace_back( !s1 );
+            bdivs.b2.emplace_back( s2 );
+            continue;
+          }
+
+          if ( kitty::implies( kitty::ternary_majority( tt_s0, ~tt_s1, ~tt_s2 ), tt ) )
+          {
+            bdivs.b0.emplace_back( s0 );
+            bdivs.b1.emplace_back( !s1 );
+            bdivs.b2.emplace_back( !s2 );
+            continue;
+          }
+
+          if ( kitty::implies( kitty::ternary_majority( ~tt_s0, tt_s1, ~tt_s2 ), tt ) )
+          {
+            bdivs.b0.emplace_back( !s0 );
+            bdivs.b1.emplace_back( s1 );
+            bdivs.b2.emplace_back( !s2 );
+            continue;
+          }
+
+          if ( kitty::implies( kitty::ternary_majority( ~tt_s0, ~tt_s1, ~tt_s2 ), tt ) )
+          {
+            bdivs.b0.emplace_back( !s0 );
+            bdivs.b1.emplace_back( !s1 );
+            bdivs.b2.emplace_back( !s2 );
+            continue;
+          }
+        }
+      }
+    }
+  }
+
+  std::optional<signal> resub_div2( node const& root, uint32_t required )
+  {
+    (void)required;
+    auto const& tt = sim.get_tt( ntk.make_signal( root ) );
+
+    for ( auto i = 0u; i < udivs.u0.size(); ++i )
+    {
+      auto const& s0 = udivs.u0.at( i );
+      auto const& s1 = udivs.u1.at( i );
+
+      for ( auto j = 0u; j < bdivs.b0.size(); ++j )
+      {
+        auto const& s2 = bdivs.b0.at( j );
+        auto const& s3 = bdivs.b1.at( j );
+        auto const& s4 = bdivs.b2.at( j );
+
+        auto const a = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+        auto const b = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+        auto const c = sim.get_phase( ntk.get_node( s2 ) ) ? !s2 : s2;
+        auto const d = sim.get_phase( ntk.get_node( s3 ) ) ? !s3 : s3;
+        auto const e = sim.get_phase( ntk.get_node( s4 ) ) ? !s4 : s4;
+
+        auto const& tt_s0 = sim.get_tt( s0 );
+        auto const& tt_s1 = sim.get_tt( s1 );
+        auto const& tt_s2 = sim.get_tt( s2 );
+        auto const& tt_s3 = sim.get_tt( s3 );
+        auto const& tt_s4 = sim.get_tt( s4 );
+
+        if ( kitty::ternary_majority( tt_s0, tt_s1, kitty::ternary_majority( tt_s2, tt_s3, tt_s4 ) ) == tt )
+        {
+          return sim.get_phase( root ) ? !ntk.create_maj( a, b, ntk.create_maj( c, d, e ) ) : ntk.create_maj( a, b, ntk.create_maj( c, d, e ) );
+        }
+      }
+    }
+
+    return std::nullopt;
+  }
+
+private:
+  Ntk& ntk;
+  Simulator const& sim;
+  std::vector<node> const& divs;
+  uint32_t const num_divs;
+  stats& st;
+
+  unate_divisors udivs;
+  binate_divisors bdivs;
+}; /* mig_enumerative_resub_functor */
+
+struct mig_resyn_resub_stats
+{
+  /*! \brief Time for finding dependency function. */
+  stopwatch<>::duration time_compute_function{ 0 };
+
+  /*! \brief Number of found solutions. */
+  uint32_t num_success{ 0 };
+
+  /*! \brief Number of times that no solution can be found. */
+  uint32_t num_fail{ 0 };
+
+  void report() const
+  {
+    fmt::print( "[i]     <ResubFn: mig_resyn_functor>\n" );
+    fmt::print( "[i]         #solution = {:6d}\n", num_success );
+    fmt::print( "[i]         #invoke   = {:6d}\n", num_success + num_fail );
+    fmt::print( "[i]         engine time: {:>5.2f} secs\n", to_seconds( time_compute_function ) );
+  }
+}; /* mig_resyn_resub_stats */
+
+/*! \brief Interfacing resubstitution functor with MIG resynthesis engines for `window_based_resub_engine`.
+ */
+template<typename Ntk, typename Simulator, typename TTcare, typename ResynEngine = mig_resyn_topdown<typename Simulator::truthtable_t>>
+struct mig_resyn_functor
+{
+public:
+  using node = mig_network::node;
+  using signal = mig_network::signal;
+  using stats = mig_resyn_resub_stats;
+  using TT = typename ResynEngine::truth_table_t;
+
+  static_assert( std::is_same_v<TT, typename Simulator::truthtable_t>, "truth table type of the simulator does not match" );
+
+public:
+  explicit mig_resyn_functor( Ntk& ntk, Simulator const& sim, std::vector<node> const& divs, uint32_t num_divs, stats& st )
+      : ntk( ntk ), sim( sim ), tts( ntk ), divs( divs ), st( st )
+  {
+    assert( divs.size() == num_divs );
+    (void)num_divs;
+    div_signals.reserve( divs.size() );
+  }
+
+  std::optional<signal> operator()( node const& root, TTcare care, uint32_t required, uint32_t max_inserts, uint32_t potential_gain, uint32_t& real_gain )
+  {
+    (void)required;
+    TT target = sim.get_tt( sim.get_phase( root ) ? !ntk.make_signal( root ) : ntk.make_signal( root ) );
+    TT care_transformed = target.construct();
+    care_transformed = care;
+
+    typename ResynEngine::stats st_eng;
+    ResynEngine engine( st_eng );
+    for ( auto const& d : divs )
+    {
+      div_signals.emplace_back( sim.get_phase( d ) ? !ntk.make_signal( d ) : ntk.make_signal( d ) );
+      tts[d] = sim.get_tt( div_signals.back() );
+    }
+
+    auto const res = call_with_stopwatch( st.time_compute_function, [&]() {
+      return engine( target, care_transformed, divs.begin(), divs.end(), tts, std::min( potential_gain - 1, max_inserts ) );
+    } );
+    if ( res )
+    {
+      ++st.num_success;
+      signal ret;
+      real_gain = potential_gain - ( *res ).num_gates();
+      insert( ntk, div_signals.begin(), div_signals.end(), *res, [&]( signal const& s ) { ret = s; } );
+      return ret;
+    }
+    else
+    {
+      ++st.num_fail;
+      return std::nullopt;
+    }
+  }
+
+private:
+  Ntk& ntk;
+  Simulator const& sim;
+  unordered_node_map<TT, Ntk> tts;
+  std::vector<node> const& divs;
+  std::vector<signal> div_signals;
+  stats& st;
+}; /* mig_resyn_functor */
+
+/*! \brief MIG-specific resubstitution algorithm.
+ *
+ * This algorithms iterates over each node, creates a
+ * reconvergence-driven cut, and attempts to re-express the node's
+ * function using existing nodes from the cut.  Node which are no
+ * longer used (including nodes in their transitive fanins) can then
+ * be removed.  The objective is to reduce the size of the network as
+ * much as possible while maintaining the global input-output
+ * functionality.
+ *
+ * **Required network functions:**
+ *
+ * - `clear_values`
+ * - `fanout_size`
+ * - `foreach_fanin`
+ * - `foreach_fanout`
+ * - `foreach_gate`
+ * - `foreach_node`
+ * - `get_constant`
+ * - `get_node`
+ * - `is_complemented`
+ * - `is_pi`
+ * - `level`
+ * - `make_signal`
+ * - `set_value`
+ * - `set_visited`
+ * - `size`
+ * - `substitute_node`
+ * - `value`
+ * - `visited`
+ *
+ * \param ntk A network type derived from mig_network
+ * \param ps Resubstitution parameters
+ * \param pst Resubstitution statistics
+ */
+template<class Ntk>
+void mig_resubstitution( Ntk& ntk, resubstitution_params const& ps = {}, resubstitution_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( std::is_same_v<typename Ntk::base_type, mig_network>, "Network type is not mig_network" );
+
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the has_size method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the has substitute_node method" );
+  static_assert( has_value_v<Ntk>, "Ntk does not implement the has_value method" );
+  static_assert( has_visited_v<Ntk>, "Ntk does not implement the has_visited method" );
+  static_assert( has_level_v<Ntk>, "Ntk does not implement the level method" );
+  static_assert( has_foreach_fanout_v<Ntk>, "Ntk does not implement the foreach_fanout method" );
+
+  if ( ps.max_pis == 8 )
+  {
+    using truthtable_t = kitty::static_truth_table<8u>;
+    using truthtable_dc_t = kitty::dynamic_truth_table;
+    using functor_t = mig_enumerative_resub_functor<Ntk, detail::window_simulator<Ntk, truthtable_t>, truthtable_dc_t>;
+    using resub_impl_t = detail::resubstitution_impl<Ntk, detail::window_based_resub_engine<Ntk, truthtable_t, truthtable_dc_t, functor_t>>;
+
+    resubstitution_stats st;
+    typename resub_impl_t::engine_st_t engine_st;
+    typename resub_impl_t::collector_st_t collector_st;
+
+    resub_impl_t p( ntk, ps, st, engine_st, collector_st );
+    p.run();
+
+    if ( ps.verbose )
+    {
+      st.report();
+      collector_st.report();
+      engine_st.report();
+    }
+
+    if ( pst )
+    {
+      *pst = st;
+    }
+  }
+  else
+  {
+    using truthtable_t = kitty::dynamic_truth_table;
+    using truthtable_dc_t = kitty::dynamic_truth_table;
+    using functor_t = mig_enumerative_resub_functor<Ntk, detail::window_simulator<Ntk, truthtable_t>, truthtable_dc_t>;
+    using resub_impl_t = detail::resubstitution_impl<Ntk, detail::window_based_resub_engine<Ntk, truthtable_t, truthtable_dc_t, functor_t>>;
+
+    resubstitution_stats st;
+    typename resub_impl_t::engine_st_t engine_st;
+    typename resub_impl_t::collector_st_t collector_st;
+
+    resub_impl_t p( ntk, ps, st, engine_st, collector_st );
+    p.run();
+
+    if ( ps.verbose )
+    {
+      st.report();
+      collector_st.report();
+      engine_st.report();
+    }
+
+    if ( pst )
+    {
+      *pst = st;
+    }
+  }
+}
+
+/*! \brief MIG-specific resubstitution algorithm.
+ *
+ * This algorithms iterates over each node, creates a
+ * reconvergence-driven cut, and attempts to re-express the node's
+ * function using existing nodes from the cut.  Node which are no
+ * longer used (including nodes in their transitive fanins) can then
+ * be removed.  The objective is to reduce the size of the network as
+ * much as possible while maintaining the global input-output
+ * functionality.
+ *
+ * **Required network functions:**
+ *
+ * - `clear_values`
+ * - `fanout_size`
+ * - `foreach_fanin`
+ * - `foreach_fanout`
+ * - `foreach_gate`
+ * - `foreach_node`
+ * - `get_constant`
+ * - `get_node`
+ * - `is_complemented`
+ * - `is_pi`
+ * - `level`
+ * - `make_signal`
+ * - `set_value`
+ * - `set_visited`
+ * - `size`
+ * - `substitute_node`
+ * - `value`
+ * - `visited`
+ *
+ * \param ntk A network type derived from mig_network
+ * \param ps Resubstitution parameters
+ * \param pst Resubstitution statistics
+ */
+template<class Ntk>
+void mig_resubstitution2( Ntk& ntk, resubstitution_params const& ps = {}, resubstitution_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( std::is_same_v<typename Ntk::base_type, mig_network>, "Network type is not mig_network" );
+
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the has_size method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the has substitute_node method" );
+  static_assert( has_value_v<Ntk>, "Ntk does not implement the has_value method" );
+  static_assert( has_visited_v<Ntk>, "Ntk does not implement the has_visited method" );
+  static_assert( has_level_v<Ntk>, "Ntk does not implement the level method" );
+  static_assert( has_foreach_fanout_v<Ntk>, "Ntk does not implement the foreach_fanout method" );
+
+  using truthtable_t = kitty::dynamic_truth_table;
+  using truthtable_dc_t = kitty::dynamic_truth_table;
+  using functor_t = mig_resyn_functor<Ntk, detail::window_simulator<Ntk, truthtable_t>, truthtable_dc_t>;
+
+  using resub_impl_t = detail::resubstitution_impl<Ntk, detail::window_based_resub_engine<Ntk, truthtable_t, truthtable_dc_t, functor_t>>;
+
+  resubstitution_stats st;
+  typename resub_impl_t::engine_st_t engine_st;
+  typename resub_impl_t::collector_st_t collector_st;
+
+  resub_impl_t p( ntk, ps, st, engine_st, collector_st );
+  p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+    collector_st.report();
+    engine_st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/miter.hpp b/include/mockturtle/algorithms/miter.hpp
new file mode 100644
index 0000000..1eb8263
--- /dev/null
+++ b/include/mockturtle/algorithms/miter.hpp
@@ -0,0 +1,113 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file miter.hpp
+  \brief Generate miter from two networks
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <optional>
+
+#include "../traits.hpp"
+#include "cleanup.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Creates a combinational miter from two networks.
+ *
+ * This method combines two networks that have the same number of primary
+ * inputs and the same number of primary outputs into a miter.  The miter
+ * has the same number of inputs and one primary output.  This output is the
+ * OR of XORs of all primary output pairs.  In other words, the miter outputs
+ * 1 for all input assignments in which the two input networks differ.
+ *
+ * All networks may have different types.  The method returns an optional, which
+ * is `nullopt`, whenever the two input networks don't match in their number of
+ * primary inputs and primary outputs.
+ */
+template<class NtkDest, class NtkSource1, class NtkSource2>
+std::optional<NtkDest> miter( NtkSource1 const& ntk1, NtkSource2 const& ntk2 )
+{
+  static_assert( is_network_type_v<NtkSource1>, "NtkSource1 is not a network type" );
+  static_assert( is_network_type_v<NtkSource2>, "NtkSource2 is not a network type" );
+  static_assert( is_network_type_v<NtkDest>, "NtkDest is not a network type" );
+
+  static_assert( has_num_pis_v<NtkSource1>, "NtkSource1 does not implement the num_pis method" );
+  static_assert( has_num_pos_v<NtkSource1>, "NtkSource1 does not implement the num_pos method" );
+  static_assert( has_num_pis_v<NtkSource2>, "NtkSource2 does not implement the num_pis method" );
+  static_assert( has_num_pos_v<NtkSource2>, "NtkSource2 does not implement the num_pos method" );
+  static_assert( has_create_pi_v<NtkDest>, "NtkDest does not implement the create_pi method" );
+  static_assert( has_create_po_v<NtkDest>, "NtkDest does not implement the create_po method" );
+  static_assert( has_create_xor_v<NtkDest>, "NtkDest does not implement the create_xor method" );
+  static_assert( has_create_nary_or_v<NtkDest>, "NtkDest does not implement the create_nary_or method" );
+
+  /* both networks must have same number of inputs and outputs */
+  if ( ( ntk1.num_pis() != ntk2.num_pis() ) || ( ntk1.num_pos() != ntk2.num_pos() ) )
+  {
+    return std::nullopt;
+  }
+
+  /* create primary inputs */
+  NtkDest dest;
+  std::vector<signal<NtkDest>> pis;
+  for ( auto i = 0u; i < ntk1.num_pis(); ++i )
+  {
+    pis.push_back( dest.create_pi() );
+  }
+
+  /* copy networks */
+  const auto pos1 = cleanup_dangling( ntk1, dest, pis.begin(), pis.end() );
+  const auto pos2 = cleanup_dangling( ntk2, dest, pis.begin(), pis.end() );
+
+  if constexpr ( has_EXODC_interface_v<NtkSource1> )
+  {
+    ntk1.build_oe_miter( dest, pos1, pos2 );
+    return dest;
+  }
+  if constexpr ( has_EXODC_interface_v<NtkSource2> )
+  {
+    ntk2.build_oe_miter( dest, pos1, pos2 );
+    return dest;
+  }
+
+  /* create XOR of output pairs */
+  std::vector<signal<NtkDest>> xor_outputs;
+  std::transform( pos1.begin(), pos1.end(), pos2.begin(), std::back_inserter( xor_outputs ),
+                  [&]( auto const& o1, auto const& o2 ) { return dest.create_xor( o1, o2 ); } );
+
+  /* create big OR of XOR gates */
+  dest.create_po( dest.create_nary_or( xor_outputs ) );
+
+  return dest;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/network_fuzz_tester.hpp b/include/mockturtle/algorithms/network_fuzz_tester.hpp
new file mode 100644
index 0000000..48ae5c9
--- /dev/null
+++ b/include/mockturtle/algorithms/network_fuzz_tester.hpp
@@ -0,0 +1,260 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file network_fuzz_tester.hpp
+  \brief Network fuzz tester
+
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#include "../io/aiger_reader.hpp"
+#include "../io/verilog_reader.hpp"
+#include "../io/write_aiger.hpp"
+#include "../io/write_verilog.hpp"
+#include "../utils/stopwatch.hpp"
+
+#include <array>
+#include <cstdio>
+#include <fmt/format.h>
+#include <lorina/lorina.hpp>
+#include <optional>
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for testcase_minimizer. */
+struct fuzz_tester_params
+{
+  /*! \brief File format to be generated. */
+  enum
+  {
+    verilog,
+    aiger
+  } file_format = verilog;
+
+  /*! \brief Name of the generated testcase file. */
+  std::string filename{ "fuzz_test.v" };
+
+  /*! \brief Filename written out by the command (to do CEC with the input testcase). */
+  std::optional<std::string> outputfile{ std::nullopt };
+
+  /*! \brief Max number of networks to test: nullopt means infinity. */
+  std::optional<uint64_t> num_iterations{ std::nullopt };
+
+  /*! \brief Timeout in seconds: nullopt means infinity. */
+  std::optional<uint64_t> timeout{ std::nullopt };
+}; /* fuzz_tester_params */
+
+/*! \brief Network fuzz tester
+ *
+ * Runs an algorithm on many small random logic networks.  Fuzz
+ * testing is often useful to detect potential segmentation faults in
+ * new implementations.  The generated benchmarks are saved first in a
+ * file.  If a segmentation fault or unexpected behavior occurs, the
+ * file can be used to reproduce and debug the problem.
+ *
+ * The entry function `run` generates different networks with the same
+ * number of PIs and gates. The function `run_incremental`, on the other
+ * hand, generates networks of increasing sizes. These functions return
+ * true if it was terminated by an unexpected behavior, or return false
+ * if it terminates normally after the specified number of iterations
+ * without observing any defect.
+ *
+ * The script of algorithm(s) to be tested can be provided as (1) a
+ * lambda function taking a network as input and returning a Boolean,
+ * which is true if the algorithm behaves as expected; or (2) a lambda
+ * function making a command string to be called, taking a filename string
+ * as input (not supported on Windows platform). If the command exits
+ * normally (with return value 0), CEC will be performed on the output
+ * file; otherwise (segfault, assertion fail, or return value is not 0),
+ * the fuzzer is terminated.
+ *
+  \verbatim embed:rst
+
+   Usage
+
+   .. code-block:: c++
+
+     #include <mockturtle/algorithms/aig_resub.hpp>
+     #include <mockturtle/algorithms/cleanup.hpp>
+     #include <mockturtle/algorithms/network_fuzz_tester.hpp>
+     #include <mockturtle/algorithms/resubstitution.hpp>
+     #include <mockturtle/generators/random_logic_generator.hpp>
+
+     auto opt = [&]( aig_network aig ) -> bool {
+       resubstitution_params ps;
+       resubstitution_stats st;
+       aig_resubstitution( aig, ps, &st );
+       aig = cleanup_dangling( aig );
+       return true;
+     };
+
+     fuzz_tester_params ps;
+     ps.num_iterations = 100;
+     auto gen = default_random_aig_generator();
+     network_fuzz_tester fuzzer( gen, ps );
+     fuzzer.run( opt );
+   \endverbatim
+*/
+template<typename Ntk, class NetworkGenerator>
+class network_fuzz_tester
+{
+public:
+  explicit network_fuzz_tester( NetworkGenerator& gen, fuzz_tester_params const ps = {} )
+      : gen( gen ), ps( ps )
+  {}
+
+#ifndef _MSC_VER
+  uint64_t run( std::function<std::string( std::string const& )>&& make_command )
+  {
+    return run( make_callback( make_command ) );
+  }
+#endif
+
+  uint64_t run( std::function<bool( Ntk )>&& fn )
+  {
+    uint64_t counter{ 0 };
+    stopwatch<>::duration time{ 0 };
+    while ( ( !ps.num_iterations || counter < ps.num_iterations ) &&
+            ( !ps.timeout || to_seconds( time ) < ps.timeout ) )
+    {
+      stopwatch t( time );
+      auto ntk = gen.generate();
+      fmt::print( "[i] create network #{}: I/O = {}/{} gates = {} nodes = {}, write into `{}`\n",
+                  ++counter, ntk.num_pis(), ntk.num_pos(), ntk.num_gates(), ntk.size(), ps.filename );
+
+      switch ( ps.file_format )
+      {
+      case fuzz_tester_params::verilog:
+        write_verilog( ntk, ps.filename );
+        break;
+      case fuzz_tester_params::aiger:
+        write_aiger( ntk, ps.filename );
+        break;
+      default:
+        fmt::print( "[w] unsupported format\n" );
+        return 0;
+      }
+
+      /* run optimization algorithm */
+      if ( !fn( ntk ) )
+      {
+        return counter;
+      }
+
+      if ( ps.outputfile )
+      {
+        if ( !abc_cec() )
+          return counter;
+      }
+    }
+    return 0;
+  }
+
+private:
+#ifndef _MSC_VER
+  inline std::function<bool( Ntk )> make_callback( std::function<std::string( std::string const& )>& make_command )
+  {
+    std::function<bool( Ntk )> fn = [&]( Ntk ntk ) -> bool {
+      (void)ntk;
+      int status = std::system( make_command( ps.filename ).c_str() );
+      if ( status < 0 )
+      {
+        std::cout << "[e] Unexpected error when calling command: " << strerror( errno ) << '\n';
+        return false;
+      }
+      else
+      {
+        if ( WIFEXITED( status ) )
+        {
+          if ( WEXITSTATUS( status ) == 0 ) // normal
+          {
+            if ( ps.outputfile )
+              return abc_cec();
+            return true;
+          }
+          else if ( WEXITSTATUS( status ) == 1 || WEXITSTATUS( status ) == 134 ) // buggy or assertion fail
+          {
+            return false;
+          }
+          else
+          {
+            std::cout << "[e] Unexpected return value: " << WEXITSTATUS( status ) << '\n';
+            return false;
+          }
+        }
+        else // segfault
+        {
+          return false;
+        }
+      }
+    };
+    return fn;
+  }
+#endif
+
+  inline bool abc_cec()
+  {
+    std::string command = fmt::format( "abc -q \"cec -n {} {}\"", ps.filename, *ps.outputfile );
+
+    std::array<char, 128> buffer;
+    std::string result;
+#ifdef _MSC_VER
+    std::unique_ptr<FILE, decltype( &_pclose )> pipe( _popen( command.c_str(), "r" ), _pclose );
+#else
+    std::unique_ptr<FILE, decltype( &pclose )> pipe( popen( command.c_str(), "r" ), pclose );
+#endif
+    if ( !pipe )
+    {
+      throw std::runtime_error( "popen() failed" );
+    }
+    while ( fgets( buffer.data(), buffer.size(), pipe.get() ) != nullptr )
+    {
+      result += buffer.data();
+    }
+
+    /* search for one line which says "Networks are equivalent" and ignore all other debug output from ABC */
+    std::stringstream ss( result );
+    std::string line;
+    while ( std::getline( ss, line, '\n' ) )
+    {
+      if ( line.size() >= 23u && line.substr( 0u, 23u ) == "Networks are equivalent" )
+      {
+        return true;
+      }
+    }
+
+    fmt::print( "[e] Files are not equivalent\n" );
+    return false;
+  }
+
+private:
+  NetworkGenerator& gen;
+  fuzz_tester_params const ps;
+}; /* network_fuzz_tester */
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis.hpp b/include/mockturtle/algorithms/node_resynthesis.hpp
new file mode 100644
index 0000000..743d192
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis.hpp
@@ -0,0 +1,357 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file node_resynthesis.hpp
+  \brief Node resynthesis
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Max Austin
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <iostream>
+
+#include "../traits.hpp"
+#include "../utils/node_map.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../views/topo_view.hpp"
+
+#include <fmt/format.h>
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for node_resynthesis.
+ *
+ * The data structure `node_resynthesis_params` holds configurable parameters
+ * with default arguments for `node_resynthesis`.
+ */
+struct node_resynthesis_params
+{
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+};
+
+/*! \brief Statistics for node_resynthesis.
+ *
+ * The data structure `node_resynthesis_stats` provides data collected by
+ * running `node_resynthesis`.
+ */
+struct node_resynthesis_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  void report() const
+  {
+    std::cout << fmt::format( "[i] total time = {:>5.2f} secs\n", to_seconds( time_total ) );
+  }
+};
+
+namespace detail
+{
+
+template<class NtkDest, class NtkSource, class ResynthesisFn>
+class node_resynthesis_impl
+{
+public:
+  node_resynthesis_impl( NtkDest& ntk_dest, NtkSource const& ntk, ResynthesisFn&& resynthesis_fn, node_resynthesis_params const& ps, node_resynthesis_stats& st )
+      : ntk_dest( ntk_dest ),
+        ntk( ntk ),
+        resynthesis_fn( resynthesis_fn ),
+        ps( ps ),
+        st( st )
+  {
+  }
+
+  NtkDest run()
+  {
+    stopwatch t( st.time_total );
+
+    node_map<signal<NtkDest>, NtkSource> node2new( ntk );
+
+    /* map constants */
+    node2new[ntk.get_node( ntk.get_constant( false ) )] = ntk_dest.get_constant( false );
+    if ( ntk.get_node( ntk.get_constant( true ) ) != ntk.get_node( ntk.get_constant( false ) ) )
+    {
+      node2new[ntk.get_node( ntk.get_constant( true ) )] = ntk_dest.get_constant( true );
+    }
+
+    /* map primary inputs */
+    ntk.foreach_pi( [&]( auto n ) {
+      node2new[n] = ntk_dest.create_pi();
+
+      if constexpr ( has_has_name_v<NtkSource> && has_get_name_v<NtkSource> && has_set_name_v<NtkDest> )
+      {
+        if ( ntk.has_name( ntk.make_signal( n ) ) )
+          ntk_dest.set_name( node2new[n], ntk.get_name( ntk.make_signal( n ) ) );
+      }
+    } );
+
+    if constexpr ( has_foreach_ro_v<NtkSource> && has_create_ro_v<NtkDest> )
+    {
+      ntk.foreach_ro( [&]( auto n, auto i ) {
+        node2new[n] = ntk_dest.create_ro();
+        ntk_dest.set_register( i, ntk.register_at( i ) );
+        if constexpr ( has_has_name_v<NtkSource> && has_get_name_v<NtkSource> && has_set_name_v<NtkDest> )
+        {
+          if ( ntk.has_name( ntk.make_signal( n ) ) )
+            ntk_dest.set_name( node2new[n], ntk.get_name( ntk.make_signal( n ) ) );
+        }
+      } );
+    }
+
+    /* map nodes */
+    topo_view ntk_topo{ ntk };
+    ntk_topo.foreach_node( [&]( auto n ) {
+      if ( ntk.is_constant( n ) || ntk.is_ci( n ) )
+        return;
+
+      std::vector<signal<NtkDest>> children;
+      ntk.foreach_fanin( n, [&]( auto const& f ) {
+        children.push_back( ntk.is_complemented( f ) ? ntk_dest.create_not( node2new[f] ) : node2new[f] );
+      } );
+
+      bool performed_resyn = false;
+      resynthesis_fn( ntk_dest, ntk.node_function( n ), children.begin(), children.end(), [&]( auto const& f ) {
+        node2new[n] = f;
+
+        if constexpr ( has_has_name_v<NtkSource> && has_get_name_v<NtkSource> && has_set_name_v<NtkDest> )
+        {
+          if ( ntk.has_name( ntk.make_signal( n ) ) )
+            ntk_dest.set_name( f, ntk.get_name( ntk.make_signal( n ) ) );
+        }
+
+        performed_resyn = true;
+        return false;
+      } );
+
+      if ( !performed_resyn )
+      {
+        fmt::print( "[e] could not perform resynthesis for node {} in node_resynthesis\n", ntk.node_to_index( n ) );
+        std::abort();
+      }
+    } );
+
+    /* map primary outputs */
+    ntk.foreach_po( [&]( auto const& f, auto index ) {
+      (void)index;
+
+      auto const o = ntk.is_complemented( f ) ? ntk_dest.create_not( node2new[f] ) : node2new[f];
+      ntk_dest.create_po( o );
+
+      if constexpr ( has_has_output_name_v<NtkSource> && has_get_output_name_v<NtkSource> && has_set_output_name_v<NtkDest> )
+      {
+        if ( ntk.has_output_name( index ) )
+        {
+          ntk_dest.set_output_name( index, ntk.get_output_name( index ) );
+        }
+      }
+    } );
+
+    if constexpr ( has_foreach_ri_v<NtkSource> && has_create_ri_v<NtkDest> )
+    {
+      ntk.foreach_ri( [&]( auto const& f, auto index ) {
+        (void)index;
+
+        auto const o = ntk.is_complemented( f ) ? ntk_dest.create_not( node2new[f] ) : node2new[f];
+        ntk_dest.create_ri( o );
+
+        if constexpr ( has_has_output_name_v<NtkSource> && has_get_output_name_v<NtkSource> && has_set_output_name_v<NtkDest> )
+        {
+          if ( ntk.has_output_name( index ) )
+          {
+            ntk_dest.set_output_name( index + ntk.num_pos(), ntk.get_output_name( index + ntk.num_pos() ) );
+          }
+        }
+      } );
+    }
+
+    return ntk_dest;
+  }
+
+private:
+  NtkDest& ntk_dest;
+  NtkSource const& ntk;
+  ResynthesisFn&& resynthesis_fn;
+  node_resynthesis_params const& ps;
+  node_resynthesis_stats& st;
+};
+
+} /* namespace detail */
+
+/*! \brief Node resynthesis algorithm.
+ *
+ * This algorithm takes as input a network (of type `NtkSource`) and creates a
+ * new network (of type `NtkDest`), by translating each node of the input
+ * network into a subnetwork for the output network.  To find a new subnetwork,
+ * the algorithm uses a resynthesis function that takes as input the input
+ * node's truth table.  This algorithm can for example be used to translate
+ * k-LUT networks into AIGs or MIGs.
+ *
+ * The resynthesis function must be of type `NtkDest::signal(NtkDest&,
+ * kitty::dynamic_truth_table const&, LeavesIterator, LeavesIterator)` where
+ * `LeavesIterator` can be dereferenced to a `NtkDest::signal`.  The last two
+ * parameters compose an iterator pair where the distance matches the number of
+ * variables of the truth table that is passed as second parameter.
+ *
+ * **Required network functions for parameter ntk (type NtkSource):**
+ * - `get_node`
+ * - `get_constant`
+ * - `foreach_pi`
+ * - `foreach_node`
+ * - `is_constant`
+ * - `is_pi`
+ * - `is_complemented`
+ * - `foreach_fanin`
+ * - `node_function`
+ * - `foreach_po`
+ *
+ * **Required network functions for return value (type NtkDest):**
+ * - `get_constant`
+ * - `create_pi`
+ * - `create_not`
+ * - `create_po`
+ *
+ * \param ntk Input network of type `NtkSource`
+ * \param resynthesis_fn Resynthesis function
+ * \return An equivalent network of type `NtkDest`
+ */
+template<class NtkDest, class NtkSource, class ResynthesisFn>
+NtkDest node_resynthesis( NtkSource const& ntk, ResynthesisFn&& resynthesis_fn, node_resynthesis_params const& ps = {}, node_resynthesis_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<NtkSource>, "NtkSource is not a network type" );
+  static_assert( is_network_type_v<NtkDest>, "NtkDest is not a network type" );
+
+  static_assert( has_get_node_v<NtkSource>, "NtkSource does not implement the get_node method" );
+  static_assert( has_get_constant_v<NtkSource>, "NtkSource does not implement the get_constant method" );
+  static_assert( has_foreach_pi_v<NtkSource>, "NtkSource does not implement the foreach_pi method" );
+  static_assert( has_foreach_node_v<NtkSource>, "NtkSource does not implement the foreach_node method" );
+  static_assert( has_is_constant_v<NtkSource>, "NtkSource does not implement the is_constant method" );
+  static_assert( has_is_pi_v<NtkSource>, "NtkSource does not implement the is_pi method" );
+  static_assert( has_is_complemented_v<NtkSource>, "NtkSource does not implement the is_complemented method" );
+  static_assert( has_foreach_fanin_v<NtkSource>, "NtkSource does not implement the foreach_fanin method" );
+  static_assert( has_node_function_v<NtkSource>, "NtkSource does not implement the node_function method" );
+  static_assert( has_foreach_po_v<NtkSource>, "NtkSource does not implement the foreach_po method" );
+
+  static_assert( has_get_constant_v<NtkDest>, "NtkDest does not implement the get_constant method" );
+  static_assert( has_create_pi_v<NtkDest>, "NtkDest does not implement the create_pi method" );
+  static_assert( has_create_not_v<NtkDest>, "NtkDest does not implement the create_not method" );
+  static_assert( has_create_po_v<NtkDest>, "NtkDest does not implement the create_po method" );
+
+  node_resynthesis_stats st;
+  NtkDest ntk_dest;
+  detail::node_resynthesis_impl<NtkDest, NtkSource, ResynthesisFn> p( ntk_dest, ntk, resynthesis_fn, ps, st );
+  const auto ret = p.run();
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+  return ret;
+}
+
+/*! \brief Node resynthesis algorithm.
+ *
+ * This algorithm takes as input a network (of type `NtkSource`) and creates a
+ * new network (of type `NtkDest`), by translating each node of the input
+ * network into a subnetwork for the output network.  To find a new subnetwork,
+ * the algorithm uses a resynthesis function that takes as input the input
+ * node's truth table.  This algorithm can for example be used to translate
+ * k-LUT networks into AIGs or MIGs.
+ *
+ * The resynthesis function must be of type `NtkDest::signal(NtkDest&,
+ * kitty::dynamic_truth_table const&, LeavesIterator, LeavesIterator)` where
+ * `LeavesIterator` can be dereferenced to a `NtkDest::signal`.  The last two
+ * parameters compose an iterator pair where the distance matches the number of
+ * variables of the truth table that is passed as second parameter.
+ *
+ * **Required network functions for parameter ntk (type NtkSource):**
+ * - `get_node`
+ * - `get_constant`
+ * - `foreach_pi`
+ * - `foreach_node`
+ * - `is_constant`
+ * - `is_pi`
+ * - `is_complemented`
+ * - `foreach_fanin`
+ * - `node_function`
+ * - `foreach_po`
+ *
+ * **Required network functions for return value (type NtkDest):**
+ * - `get_constant`
+ * - `create_pi`
+ * - `create_not`
+ * - `create_po`
+ *
+ * \param ntk_dest Output network of type `NtkDest`
+ * \param ntk Input network of type `NtkSource`
+ * \param resynthesis_fn Resynthesis function
+ */
+template<class NtkDest, class NtkSource, class ResynthesisFn>
+void node_resynthesis( NtkDest& ntk_dest, NtkSource const& ntk, ResynthesisFn&& resynthesis_fn, node_resynthesis_params const& ps = {}, node_resynthesis_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<NtkSource>, "NtkSource is not a network type" );
+  static_assert( is_network_type_v<NtkDest>, "NtkDest is not a network type" );
+
+  static_assert( has_get_node_v<NtkSource>, "NtkSource does not implement the get_node method" );
+  static_assert( has_get_constant_v<NtkSource>, "NtkSource does not implement the get_constant method" );
+  static_assert( has_foreach_pi_v<NtkSource>, "NtkSource does not implement the foreach_pi method" );
+  static_assert( has_foreach_node_v<NtkSource>, "NtkSource does not implement the foreach_node method" );
+  static_assert( has_is_constant_v<NtkSource>, "NtkSource does not implement the is_constant method" );
+  static_assert( has_is_pi_v<NtkSource>, "NtkSource does not implement the is_pi method" );
+  static_assert( has_is_complemented_v<NtkSource>, "NtkSource does not implement the is_complemented method" );
+  static_assert( has_foreach_fanin_v<NtkSource>, "NtkSource does not implement the foreach_fanin method" );
+  static_assert( has_node_function_v<NtkSource>, "NtkSource does not implement the node_function method" );
+  static_assert( has_foreach_po_v<NtkSource>, "NtkSource does not implement the foreach_po method" );
+
+  static_assert( has_get_constant_v<NtkDest>, "NtkDest does not implement the get_constant method" );
+  static_assert( has_create_pi_v<NtkDest>, "NtkDest does not implement the create_pi method" );
+  static_assert( has_create_not_v<NtkDest>, "NtkDest does not implement the create_not method" );
+  static_assert( has_create_po_v<NtkDest>, "NtkDest does not implement the create_po method" );
+
+  node_resynthesis_stats st;
+  detail::node_resynthesis_impl<NtkDest, NtkSource, ResynthesisFn> p( ntk_dest, ntk, resynthesis_fn, ps, st );
+  p.run();
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/akers.hpp b/include/mockturtle/algorithms/node_resynthesis/akers.hpp
new file mode 100644
index 0000000..8f20f1b
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/akers.hpp
@@ -0,0 +1,76 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file akers.hpp
+  \brief Resynthesis with Akers synthesis
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <iostream>
+#include <sstream>
+#include <unordered_map>
+#include <vector>
+
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/operators.hpp>
+
+#include "../../algorithms/akers_synthesis.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Resynthesis function based on Akers synthesis.
+ *
+ * This resynthesis function can be passed to ``node_resynthesis``,
+ * ``cut_rewriting``, and ``refactoring``.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      const klut_network klut = ...;
+      akers_resynthesis<mig_network> resyn;
+      const auto mig = node_resynthesis<mig_network>( klut, resyn );
+   \endverbatim
+ */
+template<class Ntk>
+class akers_resynthesis
+{
+public:
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    fn( akers_synthesis<Ntk>( ntk, function, ~function.construct(), begin, end ) );
+  }
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/bidecomposition.hpp b/include/mockturtle/algorithms/node_resynthesis/bidecomposition.hpp
new file mode 100644
index 0000000..270c412
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/bidecomposition.hpp
@@ -0,0 +1,82 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file bidecomposition.hpp
+  \brief Resynthesis with bi_decomposition
+
+  \author Eleonora Testa
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <iostream>
+#include <sstream>
+#include <unordered_map>
+#include <vector>
+
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/operators.hpp>
+
+#include "../../algorithms/bi_decomposition.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Resynthesis function based on bi-decomposition
+ *
+ * This resynthesis function can be passed to  ``refactoring``.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      const xag_network xag = ...;
+      bidecomposition_resynthesis<xag_network> resyn;
+      const auto xag = refactoring( xag, resyn );
+   \endverbatim
+ */
+
+template<class Ntk>
+class bidecomposition_resynthesis
+{
+public:
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, kitty::dynamic_truth_table const& dc, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    fn( bi_decomposition<Ntk>( ntk, function, ~dc, { begin, end } ) );
+  }
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    operator()( ntk, function, function.construct(), begin, end, fn );
+  }
+};
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/cached.hpp b/include/mockturtle/algorithms/node_resynthesis/cached.hpp
new file mode 100644
index 0000000..738dc53
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/cached.hpp
@@ -0,0 +1,317 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cached.hpp
+  \brief Generic resynthesis with a cache
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Shubham Rai
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#if !__clang__ || __clang_major__ > 10
+
+#include <cstdint>
+#if __GNUC__ == 7
+#include <experimental/filesystem>
+#else
+#include <filesystem>
+#endif
+#include <fstream>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/hash.hpp>
+#include <nlohmann/json.hpp>
+#include <unordered_set>
+
+#include "../../algorithms/cleanup.hpp"
+#include "../../traits.hpp"
+#include "../../utils/json_utils.hpp"
+#include "../../utils/network_cache.hpp"
+#include "traits.hpp"
+
+namespace mockturtle
+{
+
+struct no_blacklist_cache_info
+{
+  bool retry( no_blacklist_cache_info const& old_info ) const
+  {
+    (void)old_info;
+    return false;
+  }
+};
+
+inline void to_json( nlohmann::json& j, no_blacklist_cache_info const& info )
+{
+  (void)info;
+  j = nullptr;
+}
+
+inline void from_json( nlohmann::json const& j, no_blacklist_cache_info& info )
+{
+  (void)j;
+  (void)info;
+}
+
+template<class Ntk, class ResynthesisFn, class BlacklistCacheInfo = no_blacklist_cache_info>
+class cached_resynthesis
+{
+public:
+  explicit cached_resynthesis( ResynthesisFn const& resyn_fn, uint32_t max_pis, std::string const& cache_filename = {}, BlacklistCacheInfo const& blacklist_cache_info = {} )
+      : _resyn_fn( resyn_fn ),
+        _cache( max_pis ),
+        _cache_filename( cache_filename ),
+        _blacklist_cache_info( blacklist_cache_info ),
+        _initial_size( max_pis )
+  {
+    if ( !_cache_filename.empty() )
+    {
+      load();
+    }
+  }
+
+  ~cached_resynthesis()
+  {
+    if ( !_cache_filename.empty() )
+    {
+      save();
+    }
+  }
+
+private:
+  using cache_key_t = std::pair<kitty::dynamic_truth_table, std::vector<kitty::dynamic_truth_table>>;
+
+  struct cache_hash
+  {
+    std::size_t operator()( const cache_key_t& p ) const
+    {
+      auto seed = _h( p.first );
+      std::for_each( p.second.begin(), p.second.end(), [&]( auto const& tt ) { kitty::hash_combine( seed, _h( tt ) ); } );
+      return seed;
+    }
+
+  private:
+    kitty::hash<kitty::dynamic_truth_table> _h;
+  };
+
+  using blacklist_cache_key_t = std::pair<kitty::dynamic_truth_table, BlacklistCacheInfo>;
+
+  struct blacklist_cache_hash
+  {
+    std::size_t operator()( const blacklist_cache_key_t& p ) const
+    {
+      return _h( p.first );
+    }
+
+  private:
+    kitty::hash<kitty::dynamic_truth_table> _h;
+  };
+
+  struct blacklist_cache_equal
+  {
+    bool operator()( const blacklist_cache_key_t& lhs, const blacklist_cache_key_t& rhs ) const
+    {
+      return lhs.first == rhs.first;
+    }
+  };
+
+  bool is_blacklisted( kitty::dynamic_truth_table const& tt ) const
+  {
+    auto it = _blacklist_cache.find( { tt, _blacklist_cache_info } );
+
+    /* function cannot be found in black list cache */
+    if ( it == _blacklist_cache.end() )
+    {
+      return false;
+    }
+    /* newer black list info, erase old entry from cache */
+    else if ( _blacklist_cache_info.retry( it->second ) )
+    {
+      _blacklist_cache.erase( it );
+      return false;
+    }
+    /* function is black listed */
+    else
+    {
+      return true;
+    }
+  }
+
+public:
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    if ( auto const key = std::make_pair( function, _existing_functions );
+         _cache.has( key ) )
+    {
+      ++_cache_hits;
+      std::vector<signal<Ntk>> signals( _cache.pis().size(), ntk.get_constant( false ) );
+      std::copy( begin, end, signals.begin() );
+      std::copy( _existing_signals.begin(), _existing_signals.end(), signals.begin() + _initial_size );
+      fn( cleanup_dangling( _cache.get_view( key ), ntk, signals.begin(), signals.end() ).front() );
+    }
+    else if ( is_blacklisted( function ) )
+    {
+      ++_cache_hits;
+      return; /* do nothing */
+    }
+    else
+    {
+      bool found_one = false;
+      auto on_signal = [&]( signal<Ntk> const& f ) -> bool {
+        if ( !found_one )
+        {
+          ++_cache_misses;
+          _cache.insert_signal( key, f );
+          found_one = true;
+
+          std::vector<signal<Ntk>> signals( _cache.pis().size(), ntk.get_constant( false ) );
+          std::copy( begin, end, signals.begin() );
+          std::copy( _existing_signals.begin(), _existing_signals.end(), signals.begin() + _initial_size );
+          fn( cleanup_dangling( _cache.get_view( key ), ntk, signals.begin(), signals.end() ).front() );
+        }
+        return false;
+      };
+
+      _resyn_fn( _cache.network(), function, _cache.pis().begin(), _cache.pis().begin() + function.num_vars(), on_signal );
+
+      if ( !found_one )
+      {
+        _blacklist_cache.insert( { function, _blacklist_cache_info } );
+      }
+    }
+  }
+
+  void set_bounds( std::optional<uint32_t> const& lower_bound, std::optional<uint32_t> const& upper_bound )
+  {
+    if constexpr ( has_set_bounds_v<ResynthesisFn> )
+    {
+      _resyn_fn.set_bounds( lower_bound, upper_bound );
+    }
+  }
+
+  void clear_functions()
+  {
+    if constexpr ( has_clear_functions_v<ResynthesisFn> )
+    {
+      _existing_signals.clear();
+      _existing_functions.clear();
+      _resyn_fn.clear_functions();
+    }
+  }
+
+  void add_function( signal<Ntk> const& s, kitty::dynamic_truth_table const& tt )
+  {
+    if constexpr ( has_add_function_v<ResynthesisFn, Ntk> )
+    {
+      // index of cache PI to forward
+      const auto pi_index = _initial_size + _existing_signals.size();
+
+      _existing_signals.push_back( s );
+      _existing_functions.push_back( tt );
+      _cache.ensure_pis( _initial_size + _existing_functions.size() );
+
+      _resyn_fn.add_function( _cache.pis()[pi_index], tt );
+    }
+    else
+    {
+      // TODO assert or warn?
+    }
+  }
+
+  void report() const
+  {
+    fmt::print( "[i] cache hits              = {}\n", _cache_hits );
+    fmt::print( "[i] cache misses            = {}\n", _cache_misses );
+    fmt::print( "[i] size of cache           = {}\n", _cache.size() );
+    fmt::print( "[i] size of blacklist cache = {}\n", _blacklist_cache.size() );
+  }
+
+private:
+  void load()
+  {
+    std::ifstream is( _cache_filename.c_str(), std::ifstream::in );
+    if ( !is.good() )
+      return;
+    nlohmann::json data;
+    is >> data;
+
+    _cache.insert_json( data["cache"] );
+    data["blacklist_cache"].get_to( _blacklist_cache );
+    data["initial_size"].get_to( _initial_size );
+  }
+
+  void save()
+  {
+#if __GNUC__ == 7
+    namespace fs = std::experimental::filesystem::v1;
+#else
+    namespace fs = std::filesystem;
+#endif
+
+    nlohmann::json data{
+        { "cache", _cache.to_json() },
+        { "blacklist_cache", _blacklist_cache },
+        { "initial_size", _initial_size } };
+
+    // make a backup of existing cache file, if it exists
+    std::string _backup_filename = fmt::format( "{}.bak", _cache_filename );
+    if ( fs::exists( _cache_filename ) )
+    {
+      fs::copy( _cache_filename, _backup_filename );
+    }
+
+    std::ofstream os( _cache_filename.c_str(), std::ofstream::out );
+    os << data.dump() << "\n";
+    os.close();
+
+    if ( fs::exists( _backup_filename ) )
+    {
+      fs::remove( _backup_filename );
+    }
+  }
+
+private:
+  ResynthesisFn _resyn_fn;
+  mutable network_cache<Ntk, cache_key_t, cache_hash> _cache;
+  mutable std::unordered_set<blacklist_cache_key_t, blacklist_cache_hash, blacklist_cache_equal> _blacklist_cache;
+  std::string _cache_filename;
+  BlacklistCacheInfo _blacklist_cache_info;
+  uint32_t _initial_size{};
+
+  std::vector<kitty::dynamic_truth_table> _existing_functions;
+  std::vector<signal<Ntk>> _existing_signals;
+
+  /* statistics */
+  mutable uint32_t _cache_hits{};
+  mutable uint32_t _cache_misses{};
+};
+} /* namespace mockturtle */
+
+#endif
diff --git a/include/mockturtle/algorithms/node_resynthesis/composed.hpp b/include/mockturtle/algorithms/node_resynthesis/composed.hpp
new file mode 100644
index 0000000..7219c3c
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/composed.hpp
@@ -0,0 +1,83 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file composed.hpp
+  \brief Traits for additional node_resynthesis methods
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#if !__clang__ || __clang_major__ > 10
+
+#include <cstdint>
+#include <string>
+
+#include "../../networks/aig.hpp"
+#include "../../networks/xag.hpp"
+#include "cached.hpp"
+#include "exact.hpp"
+
+namespace mockturtle
+{
+
+struct exact_blacklist_cache_info
+{
+  bool retry( exact_blacklist_cache_info const& old_info ) const
+  {
+    return conflict_limit > old_info.conflict_limit;
+  }
+
+  int conflict_limit;
+};
+
+inline void to_json( nlohmann::json& j, exact_blacklist_cache_info const& info )
+{
+  j = info.conflict_limit;
+}
+
+inline void from_json( nlohmann::json const& j, exact_blacklist_cache_info& info )
+{
+  j.get_to( info.conflict_limit );
+}
+
+template<class Ntk>
+auto cached_exact_xag_resynthesis( std::string const& cache_filename, uint32_t input_limit = 12u, int conflict_limit = 10e5 )
+{
+  exact_resynthesis_params exact_ps;
+  exact_ps.conflict_limit = conflict_limit;
+  exact_aig_resynthesis<Ntk> exact_resyn( std::is_same_v<typename Ntk::base_type, xag_network>, exact_ps );
+  exact_blacklist_cache_info info;
+  info.conflict_limit = conflict_limit;
+  return cached_resynthesis<Ntk, decltype( exact_resyn ), exact_blacklist_cache_info>( exact_resyn, input_limit, cache_filename, info );
+}
+
+} // namespace mockturtle
+
+#endif
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/davio.hpp b/include/mockturtle/algorithms/node_resynthesis/davio.hpp
new file mode 100644
index 0000000..064f5ad
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/davio.hpp
@@ -0,0 +1,150 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file davio.hpp
+  \brief Use Davio decomposition for resynthesis
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <optional>
+#include <vector>
+
+#include <kitty/dynamic_truth_table.hpp>
+
+#include "../../traits.hpp"
+#include "../decomposition.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Resynthesis function based on Davio decomposition.
+ *
+ * This resynthesis function can be passed to ``node_resynthesis``,
+ * ``cut_rewriting``, and ``refactoring``.  The given truth table will be
+ * resynthized based on Shanon decomposition.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      const klut_network klut = ...;
+
+      positive_davio_resynthesis<xag_network> resyn;
+      auto xag = node_resynthesis<xag_network>( klut, resyn );
+   \endverbatim
+ *
+ */
+template<class Ntk, class ResynFn = null_resynthesis<Ntk>>
+class positive_davio_resynthesis
+{
+public:
+  positive_davio_resynthesis( std::optional<uint32_t> const& threshold = {}, ResynFn* resyn = nullptr )
+      : threshold_( threshold ),
+        resyn_( resyn ) {}
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    if ( threshold_ )
+    {
+      std::vector<uint32_t> vars( function.num_vars() - std::min<uint32_t>( *threshold_, function.num_vars() ) );
+      std::iota( vars.begin(), vars.end(), 0u );
+      const auto f = positive_davio_decomposition<Ntk, ResynFn>( ntk, function, vars, std::vector<signal<Ntk>>( begin, end ), *resyn_ );
+      fn( f );
+    }
+    else
+    {
+      std::vector<uint32_t> vars( function.num_vars() );
+      std::iota( vars.begin(), vars.end(), 0u );
+      const auto f = positive_davio_decomposition( ntk, function, vars, std::vector<signal<Ntk>>( begin, end ) );
+      fn( f );
+    }
+  }
+
+private:
+  std::optional<uint32_t> threshold_;
+  ResynFn* resyn_;
+};
+
+/*! \brief Resynthesis function based on Davio decomposition.
+ *
+ * This resynthesis function can be passed to ``node_resynthesis``,
+ * ``cut_rewriting``, and ``refactoring``.  The given truth table will be
+ * resynthized based on Shanon decomposition.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      const klut_network klut = ...;
+
+      negative_davio_resynthesis<xag_network> resyn;
+      auto xag = node_resynthesis<xag_network>( klut, resyn );
+   \endverbatim
+ *
+ */
+template<class Ntk, class ResynFn = null_resynthesis<Ntk>>
+class negative_davio_resynthesis
+{
+public:
+  negative_davio_resynthesis( std::optional<uint32_t> const& threshold = {}, ResynFn* resyn = nullptr )
+      : threshold_( threshold ),
+        resyn_( resyn ) {}
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    if ( threshold_ )
+    {
+      std::vector<uint32_t> vars( function.num_vars() - std::min<uint32_t>( *threshold_, function.num_vars() ) );
+      std::iota( vars.begin(), vars.end(), 0u );
+      const auto f = negative_davio_decomposition<Ntk, ResynFn>( ntk, function, vars, std::vector<signal<Ntk>>( begin, end ), *resyn_ );
+      fn( f );
+    }
+    else
+    {
+      std::vector<uint32_t> vars( function.num_vars() );
+      std::iota( vars.begin(), vars.end(), 0u );
+      const auto f = negative_davio_decomposition( ntk, function, vars, std::vector<signal<Ntk>>( begin, end ) );
+      fn( f );
+    }
+  }
+
+private:
+  std::optional<uint32_t> threshold_;
+  ResynFn* resyn_;
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/direct.hpp b/include/mockturtle/algorithms/node_resynthesis/direct.hpp
new file mode 100644
index 0000000..0fdd83a
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/direct.hpp
@@ -0,0 +1,264 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file direct.hpp
+  \brief Resynthesis by trying to directly add gates
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <iostream>
+#include <sstream>
+#include <unordered_map>
+#include <vector>
+
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/print.hpp>
+
+#include "../../algorithms/akers_synthesis.hpp"
+#include "../../networks/mig.hpp"
+
+namespace mockturtle
+{
+
+struct direct_resynthesis_params
+{
+  bool warn_on_unsupported{ false };
+};
+
+/*! \brief Resynthesis function that creates a gate for each node.
+ *
+ * If it detects a function that can be constructed as a gate, it does so.
+ * Otherwise, it does not create a gate.  In that case, a warning can be
+ * printed, if configured in the parameter struct.
+ *
+ * The function works with all 0-, 1-, and 2-input node functions and with
+ * some 3-input node functions, e.g., 3-input majority for MIGs and XMGs, or
+ * 3-input XOR for XMGs.
+ *
+ * This resynthesis function can be passed to ``node_resynthesis``,
+ * ``cut_rewriting``, and ``refactoring``.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      const klut_network klut = ...;
+      direct_resynthesis resyn;
+      const auto mig = node_resynthesis<mig_network>( klut, resyn );
+   \endverbatim
+ */
+template<class Ntk>
+class direct_resynthesis
+{
+public:
+  direct_resynthesis( direct_resynthesis_params const& ps = {} )
+      : ps( ps )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+    static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+    static_assert( has_create_and_v<Ntk>, "Ntk does not implement the create_and method" );
+    static_assert( has_create_or_v<Ntk>, "Ntk does not implement the create_or method" );
+    static_assert( has_create_xor_v<Ntk>, "Ntk does not implement the create_xor method" );
+  }
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    (void)end;
+    switch ( function.num_vars() )
+    {
+    case 0u:
+      synthesize0( ntk, function, fn );
+      break;
+
+    case 1u:
+      synthesize1( ntk, function, *begin, fn );
+      break;
+
+    case 2u:
+      synthesize2( ntk, function, *begin, *( begin + 1 ), fn );
+      break;
+
+    case 3u:
+      synthesize3( ntk, function, *begin, *( begin + 1 ), *( begin + 2 ), fn );
+      break;
+    }
+  }
+
+private:
+  template<typename Fn>
+  void synthesize0( Ntk& ntk, kitty::dynamic_truth_table const& function, Fn&& fn ) const
+  {
+    fn( ntk.get_constant( kitty::is_const0( function ) ) );
+  }
+
+  template<typename Fn>
+  void synthesize1( Ntk& ntk, kitty::dynamic_truth_table const& function, signal<Ntk> const& f, Fn&& fn ) const
+  {
+    switch ( *function.begin() )
+    {
+    case 0b00:
+      fn( ntk.get_constant( false ) );
+      break;
+    case 0b01:
+      fn( ntk.create_not( f ) );
+      break;
+    case 0b10:
+      fn( f );
+      break;
+    case 0b11:
+      fn( ntk.get_constant( true ) );
+      break;
+    }
+  }
+
+  template<typename Fn>
+  void synthesize2( Ntk& ntk, kitty::dynamic_truth_table const& function, signal<Ntk> const& f, signal<Ntk> const& g, Fn&& fn ) const
+  {
+    switch ( *function.begin() )
+    {
+    case 0b0000:
+      fn( ntk.get_constant( false ) );
+      break;
+    case 0b0001: /* NOR */
+      fn( ntk.create_not( ntk.create_or( f, g ) ) );
+      break;
+    case 0b0010: /* AND(f, !g) */
+      fn( ntk.create_and( f, ntk.create_not( g ) ) );
+      break;
+    case 0b0011: /* !g */
+      fn( ntk.create_not( g ) );
+      break;
+    case 0b0100: /* AND(!f, g) */
+      fn( ntk.create_and( ntk.create_not( f ), g ) );
+      break;
+    case 0b0101: /* !f */
+      fn( ntk.create_not( f ) );
+      break;
+    case 0b0110: /* XOR */
+      fn( ntk.create_xor( f, g ) );
+      break;
+    case 0b0111: /* NAND */
+      fn( ntk.create_not( ntk.create_and( f, g ) ) );
+      break;
+    case 0b1000: /* AND */
+      fn( ntk.create_and( f, g ) );
+      break;
+    case 0b1001: /* XNOR */
+      fn( ntk.create_not( ntk.create_xor( f, g ) ) );
+      break;
+    case 0b1010: /* f */
+      fn( f );
+      break;
+    case 0b1011: /* OR(f, !g) */
+      fn( ntk.create_or( f, ntk.create_not( g ) ) );
+      break;
+    case 0b1100: /* g */
+      fn( g );
+      break;
+    case 0b1101: /* OR(!f, g) */
+      fn( ntk.create_or( ntk.create_not( f ), g ) );
+      break;
+    case 0b1110: /* OR(f, g) */
+      fn( ntk.create_or( f, g ) );
+      break;
+    case 0b1111:
+      fn( ntk.get_constant( true ) );
+      break;
+    }
+  }
+
+  template<typename Fn>
+  void synthesize3( Ntk& ntk, kitty::dynamic_truth_table const& function, signal<Ntk> const& f, signal<Ntk> const& g, signal<Ntk> const& h, Fn&& fn ) const
+  {
+    // TODO? all contained extended 1-input and 2-input functions
+    // TODO create_ite
+
+    const auto word = *function.begin();
+    switch ( word )
+    {
+    case 0x00:
+      fn( ntk.get_constant( false ) );
+      break;
+    case 0xff:
+      fn( ntk.get_constant( true ) );
+      break;
+    case 0xe8: /* <fgh> */
+    case 0xd4: /* <!fgh> */
+    case 0xb2: /* <f!gh> */
+    case 0x8e: /* <fg!h> */
+    case 0x71: /* <!f!gh> */
+    case 0x4d: /* <!fg!h> */
+    case 0x2b: /* <f!g!h> */
+    case 0x17: /* <!f!g!h> */
+      if constexpr ( has_create_maj_v<Ntk> )
+      {
+        const auto _f = ( ( word == 0xd4 ) || ( word == 0x71 ) || ( word == 0x4d ) || ( word == 0x17 ) ) ? ntk.create_not( f ) : f;
+        const auto _g = ( ( word == 0xb2 ) || ( word == 0x71 ) || ( word == 0x2b ) || ( word == 0x17 ) ) ? ntk.create_not( g ) : g;
+        const auto _h = ( ( word == 0x8e ) || ( word == 0x4d ) || ( word == 0x2b ) || ( word == 0x17 ) ) ? ntk.create_not( h ) : h;
+        fn( ntk.create_maj( _f, _g, _h ) );
+      }
+      else
+      {
+        if ( ps.warn_on_unsupported )
+        {
+          std::cout << "[w] function " << kitty::to_hex( function ) << " cannot be synthesized as gate\n";
+        }
+      }
+      break;
+    case 0x96: /* [abc] */
+    case 0x69: /* ![abc] */
+      if constexpr ( has_create_xor3_v<Ntk> )
+      {
+        const auto o = ntk.create_xor3( f, g, h );
+        fn( word == 0x69 ? ntk.create_not( o ) : o );
+      }
+      else
+      {
+        if ( ps.warn_on_unsupported )
+        {
+          std::cout << "[w] function " << kitty::to_hex( function ) << " cannot be synthesized as gate\n";
+        }
+      }
+      break;
+    default:
+      std::cout << "[w] failed to synthesize function " << kitty::to_hex( function ) << "\n";
+    }
+  }
+
+private:
+  direct_resynthesis_params ps;
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/dsd.hpp b/include/mockturtle/algorithms/node_resynthesis/dsd.hpp
new file mode 100644
index 0000000..2fc1a0c
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/dsd.hpp
@@ -0,0 +1,147 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file dsd.hpp
+  \brief Use DSD as pre-process to resynthesis
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <vector>
+
+#include <kitty/dynamic_truth_table.hpp>
+
+#include "../dsd_decomposition.hpp"
+#include "traits.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for dsd_resynthesis function. */
+struct dsd_resynthesis_params
+{
+  /*! \brief Skip resynthesis on prime nodes, if it exceeds this limit. */
+  std::optional<uint32_t> prime_input_limit;
+
+  /*! \brief DSD decomposition parameters */
+  dsd_decomposition_params dsd_ps;
+};
+
+/*! \brief Resynthesis function based on DSD decomposition.
+ *
+ * This resynthesis function can be passed to ``node_resynthesis``,
+ * ``cut_rewriting``, and ``refactoring``.  The given truth table will be
+ * resynthized based on DSD decomposition.  Since DSD decomposition may not be
+ * able to decompose the whole truth table, a different fall-back resynthesis
+ * function must be passed to this function.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      const aig_network aig = ...;
+
+      exact_aig_resynthesis<aig_network> fallback; // fallback
+      dsd_resynthesis<aig_network, decltype( fallback )> resyn( fallback );
+      cut_rewriting( aig, resyn );
+      aig = cleanup_dangling( aig );
+   \endverbatim
+ *
+ */
+template<class Ntk, class ResynthesisFn>
+class dsd_resynthesis
+{
+public:
+  explicit dsd_resynthesis( ResynthesisFn& resyn_fn, dsd_resynthesis_params const& ps = {} )
+      : _resyn_fn( resyn_fn ),
+        _ps( ps )
+  {
+  }
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    bool success{ true };
+    const auto on_prime = [&]( kitty::dynamic_truth_table const& remainder, std::vector<signal<Ntk>> const& leaves ) {
+      success = false;
+      signal<Ntk> f = ntk.get_constant( false );
+      if ( _ps.prime_input_limit && leaves.size() > *_ps.prime_input_limit )
+      {
+        return f;
+      }
+
+      const auto on_signal = [&]( signal<Ntk> const& _f ) {
+        if ( !success )
+        {
+          f = _f;
+          success = true;
+        }
+        return true;
+      };
+      auto _leaves = leaves;
+
+      if constexpr ( has_set_bounds_v<ResynthesisFn> )
+      {
+        _resyn_fn.set_bounds( static_cast<uint32_t>( _leaves.size() ), std::nullopt );
+      }
+      _resyn_fn( ntk, remainder, _leaves.begin(), _leaves.end(), on_signal );
+      return f;
+    };
+
+    const auto f = dsd_decomposition( ntk, function, std::vector<signal<Ntk>>( begin, end ), on_prime, _ps.dsd_ps );
+    if ( success )
+    {
+      fn( f );
+    }
+  }
+
+  void clear_functions()
+  {
+    if constexpr ( has_clear_functions_v<ResynthesisFn> )
+    {
+      _resyn_fn.clear_functions();
+    }
+  }
+
+  void add_function( signal<Ntk> const& s, kitty::dynamic_truth_table const& tt )
+  {
+    if constexpr ( has_add_function_v<ResynthesisFn, Ntk> )
+    {
+      _resyn_fn.add_function( s, tt );
+    }
+  }
+
+private:
+  ResynthesisFn& _resyn_fn;
+  dsd_resynthesis_params _ps;
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/exact.hpp b/include/mockturtle/algorithms/node_resynthesis/exact.hpp
new file mode 100644
index 0000000..98920b4
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/exact.hpp
@@ -0,0 +1,659 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file exact.hpp
+  \brief Replace with exact synthesis result
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Shubham Rai
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <iostream>
+#include <memory>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/hash.hpp>
+#include <kitty/print.hpp>
+#include <kitty/traits.hpp>
+
+#include "../../networks/aig.hpp"
+#include "../../networks/klut.hpp"
+#include "../../networks/xmg.hpp"
+#include "../../utils/include/percy.hpp"
+
+namespace mockturtle
+{
+
+struct exact_resynthesis_params
+{
+  using cache_map_t = std::unordered_map<kitty::dynamic_truth_table, percy::chain, kitty::hash<kitty::dynamic_truth_table>>;
+  using cache_t = std::shared_ptr<cache_map_t>;
+
+  using blacklist_cache_map_t = std::unordered_map<kitty::dynamic_truth_table, int32_t, kitty::hash<kitty::dynamic_truth_table>>;
+  using blacklist_cache_t = std::shared_ptr<blacklist_cache_map_t>;
+
+  cache_t cache;
+  blacklist_cache_t blacklist_cache;
+
+  bool add_alonce_clauses{ true };
+  bool add_colex_clauses{ true };
+  bool add_lex_clauses{ false };
+  bool add_lex_func_clauses{ true };
+  bool add_nontriv_clauses{ true };
+  bool add_noreapply_clauses{ true };
+  bool add_symvar_clauses{ true };
+  int conflict_limit{ 0 };
+
+  percy::SolverType solver_type = percy::SLV_BSAT2;
+
+  percy::EncoderType encoder_type = percy::ENC_SSV;
+
+  percy::SynthMethod synthesis_method = percy::SYNTH_STD;
+};
+
+/*! \brief Resynthesis function based on exact synthesis.
+ *
+ * This resynthesis function can be passed to ``node_resynthesis``,
+ * ``cut_rewriting``, and ``refactoring``.  The given truth table will be
+ * resynthized in terms of an optimum size `k`-LUT network, where `k` is
+ * specified as input to the constructor.  In order to guarantee a reasonable
+ * runtime, `k` should be 3 or 4.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      const klut_network klut = ...;
+
+      exact_resynthesis<klut_network> resyn( 3 );
+      klut = cut_rewriting( klut, resyn );
+   \endverbatim
+ *
+ * A cache can be passed as second parameter to the constructor, which will
+ * store optimum networks for all functions for which resynthesis is invoked
+ * for.  The cache can be used to retrieve the computed network, which reduces
+ * runtime.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      const klut_network klut = ...;
+
+      exact_resynthesis_params ps;
+      ps.cache = std::make_shared<exact_resynthesis_params::cache_map_t>();
+      exact_resynthesis<klut_network> resyn( 3, ps );
+      klut = cut_rewriting( klut, resyn );
+
+   The underlying engine for this resynthesis function is percy_.
+
+   .. _percy: https://github.com/lsils/percy
+   \endverbatim
+ *
+ */
+template<class Ntk = klut_network>
+class exact_resynthesis
+{
+public:
+  explicit exact_resynthesis( uint32_t fanin_size = 3u, exact_resynthesis_params const& ps = {} )
+      : _fanin_size( fanin_size ),
+        _ps( ps )
+  {
+  }
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    operator()( ntk, function, function.construct(), begin, end, fn );
+  }
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, kitty::dynamic_truth_table const& dont_cares, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    if ( static_cast<uint32_t>( function.num_vars() ) <= _fanin_size )
+    {
+      fn( ntk.create_node( std::vector<signal<Ntk>>( begin, end ), function ) );
+      return;
+    }
+
+    percy::spec spec;
+    spec.fanin = _fanin_size;
+    spec.verbosity = 0;
+    spec.add_alonce_clauses = _ps.add_alonce_clauses;
+    spec.add_colex_clauses = _ps.add_colex_clauses;
+    spec.add_lex_clauses = _ps.add_lex_clauses;
+    spec.add_lex_func_clauses = _ps.add_lex_func_clauses;
+    spec.add_nontriv_clauses = _ps.add_nontriv_clauses;
+    spec.add_noreapply_clauses = _ps.add_noreapply_clauses;
+    spec.add_symvar_clauses = _ps.add_symvar_clauses;
+    spec.conflict_limit = _ps.conflict_limit;
+    spec[0] = function;
+    bool with_dont_cares{ false };
+    if ( !kitty::is_const0( dont_cares ) )
+    {
+      spec.set_dont_care( 0, dont_cares );
+      with_dont_cares = true;
+    }
+
+    auto c = [&]() -> std::optional<percy::chain> {
+      if ( !with_dont_cares && _ps.cache )
+      {
+        const auto it = _ps.cache->find( function );
+        if ( it != _ps.cache->end() )
+        {
+          return it->second;
+        }
+      }
+      if ( !with_dont_cares && _ps.blacklist_cache )
+      {
+        const auto it = _ps.blacklist_cache->find( function );
+        if ( it != _ps.blacklist_cache->end() && ( it->second == 0 || _ps.conflict_limit <= it->second ) )
+        {
+          return std::nullopt;
+        }
+      }
+
+      percy::chain c;
+      if ( const auto result = percy::synthesize( spec, c, _ps.solver_type,
+                                                  _ps.encoder_type,
+                                                  _ps.synthesis_method );
+           result != percy::success )
+      {
+        if ( !with_dont_cares && _ps.blacklist_cache )
+        {
+          ( *_ps.blacklist_cache )[function] = result == percy::timeout ? _ps.conflict_limit : 0;
+        }
+        return std::nullopt;
+      }
+      c.denormalize();
+      if ( !with_dont_cares && _ps.cache )
+      {
+        ( *_ps.cache )[function] = c;
+      }
+      return c;
+    }();
+
+    if ( !c )
+    {
+      return;
+    }
+
+    std::vector<signal<Ntk>> signals( begin, end );
+
+    for ( auto i = 0; i < c->get_nr_steps(); ++i )
+    {
+      std::vector<signal<Ntk>> fanin;
+      for ( const auto& child : c->get_step( i ) )
+      {
+        fanin.emplace_back( signals[child] );
+      }
+      signals.emplace_back( ntk.create_node( fanin, c->get_operator( i ) ) );
+    }
+
+    fn( signals.back() );
+  }
+
+private:
+  uint32_t _fanin_size{ 3u };
+  exact_resynthesis_params _ps;
+};
+
+/*! \brief Resynthesis function based on exact synthesis for AIGs.
+ *
+ * This resynthesis function can be passed to ``node_resynthesis``,
+ * ``cut_rewriting``, and ``refactoring``.  The given truth table will be
+ * resynthesized in terms of an optimum size AIG network.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      aig_network aig = ...;
+
+      exact_aig_resynthesis<aig_network> resyn;
+      aig = cut_rewriting( aig, resyn );
+   \endverbatim
+ *
+ * A cache can be passed as second parameter to the constructor, which will
+ * store optimum networks for all functions for which resynthesis is invoked
+ * for.  The cache can be used to retrieve the computed network, which reduces
+ * runtime.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      aig_network aig = ...;
+
+      exact_resynthesis_params ps;
+      ps.cache = std::make_shared<exact_resynthesis_params::cache_map_t>();
+      exact_aig_resynthesis<aig_network> resyn( false, ps );
+      aig = cut_rewriting( aig, resyn );
+
+   The underlying engine for this resynthesis function is percy_.
+
+   .. _percy: https://github.com/lsils/percy
+   \endverbatim
+ *
+ */
+template<class Ntk = aig_network>
+class exact_aig_resynthesis
+{
+public:
+  using signal = typename Ntk::signal;
+
+public:
+  explicit exact_aig_resynthesis( bool _allow_xor = false, exact_resynthesis_params const& ps = {} )
+      : _allow_xor( _allow_xor ),
+        _ps( ps )
+  {
+  }
+
+  void clear_functions()
+  {
+    existing_functions.clear();
+  }
+
+  void add_function( signal const& s, kitty::dynamic_truth_table const& tt )
+  {
+    existing_functions.emplace_back( s, tt );
+  }
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    operator()( ntk, function, function.construct(), begin, end, fn );
+  }
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, kitty::dynamic_truth_table const& dont_cares, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    // TODO: special case for small functions (up to 2 variables)?
+    percy::spec spec;
+    if ( !_allow_xor )
+    {
+      spec.set_primitive( percy::AIG );
+    }
+    spec.fanin = 2;
+    spec.verbosity = 0;
+    spec.add_alonce_clauses = _ps.add_alonce_clauses;
+    spec.add_colex_clauses = _ps.add_colex_clauses;
+    spec.add_lex_clauses = _ps.add_lex_clauses;
+    spec.add_lex_func_clauses = _ps.add_lex_func_clauses;
+    spec.add_nontriv_clauses = _ps.add_nontriv_clauses;
+    spec.add_noreapply_clauses = _ps.add_noreapply_clauses;
+    spec.add_symvar_clauses = _ps.add_symvar_clauses;
+    spec.conflict_limit = _ps.conflict_limit;
+    if ( _lower_bound )
+    {
+      spec.initial_steps = *_lower_bound;
+    }
+    if ( _upper_bound )
+    {
+      spec.max_nr_steps = *_upper_bound;
+    }
+    spec[0] = function;
+    bool with_dont_cares{ false };
+    if ( !kitty::is_const0( dont_cares ) )
+    {
+      spec.set_dont_care( 0, dont_cares );
+      with_dont_cares = true;
+    }
+
+    /* add existing functions */
+    for ( const auto& f : existing_functions )
+    {
+      spec.add_function( f.second );
+    }
+
+    auto c = [&]() -> std::optional<percy::chain> {
+      if ( !with_dont_cares && _ps.cache )
+      {
+        const auto it = _ps.cache->find( function );
+        if ( it != _ps.cache->end() )
+        {
+          return it->second;
+        }
+      }
+      if ( !with_dont_cares && _ps.blacklist_cache )
+      {
+        const auto it = _ps.blacklist_cache->find( function );
+        if ( it != _ps.blacklist_cache->end() && ( it->second == 0 || _ps.conflict_limit <= it->second ) )
+        {
+          return std::nullopt;
+        }
+      }
+
+      percy::chain c;
+      if ( const auto result = percy::synthesize( spec, c, _ps.solver_type,
+                                                  _ps.encoder_type,
+                                                  _ps.synthesis_method );
+           result != percy::success )
+      {
+        if ( !with_dont_cares && _ps.blacklist_cache )
+        {
+          ( *_ps.blacklist_cache )[function] = ( result == percy::timeout ) ? _ps.conflict_limit : 0;
+        }
+        return std::nullopt;
+      }
+
+      assert( kitty::to_hex( c.simulate()[0u] ) == kitty::to_hex( function ) );
+
+      if ( !with_dont_cares && _ps.cache )
+      {
+        ( *_ps.cache )[function] = c;
+      }
+      return c;
+    }();
+
+    if ( !c )
+    {
+      return;
+    }
+
+    std::vector<signal> signals( begin, end );
+    for ( const auto& f : existing_functions )
+    {
+      signals.emplace_back( f.first );
+    }
+
+    for ( auto i = 0; i < c->get_nr_steps(); ++i )
+    {
+      auto const c1 = signals[c->get_step( i )[0]];
+      auto const c2 = signals[c->get_step( i )[1]];
+
+      switch ( c->get_operator( i )._bits[0] )
+      {
+      default:
+        std::cerr << "[e] unsupported operation " << kitty::to_hex( c->get_operator( i ) ) << "\n";
+        assert( false );
+        break;
+      case 0x8:
+        signals.emplace_back( ntk.create_and( c1, c2 ) );
+        break;
+      case 0x4:
+        signals.emplace_back( ntk.create_and( !c1, c2 ) );
+        break;
+      case 0x2:
+        signals.emplace_back( ntk.create_and( c1, !c2 ) );
+        break;
+      case 0xe:
+        signals.emplace_back( !ntk.create_and( !c1, !c2 ) );
+        break;
+      case 0x6:
+        signals.emplace_back( ntk.create_xor( c1, c2 ) );
+        break;
+      }
+    }
+
+    fn( c->is_output_inverted( 0 ) ? !signals.back() : signals.back() );
+  }
+
+  void set_bounds( std::optional<uint32_t> const& lower_bound, std::optional<uint32_t> const& upper_bound )
+  {
+    _lower_bound = lower_bound;
+    _upper_bound = upper_bound;
+  }
+
+private:
+  bool _allow_xor = false;
+  exact_resynthesis_params _ps;
+
+  std::vector<std::pair<signal, kitty::dynamic_truth_table>> existing_functions;
+
+  std::optional<uint32_t> _lower_bound;
+  std::optional<uint32_t> _upper_bound;
+};
+
+struct exact_xmg_resynthesis_params
+{
+  uint32_t num_candidates{ 10u };
+  bool use_only_self_dual_gates{ false };
+  bool use_xor3{ true };
+  int conflict_limit{ 0 };
+};
+
+/*! \brief Resynthesis function based on exact synthesis for XMGs.
+ *
+ * This resynthesis function can be passed to ``node_resynthesis``,
+ * ``cut_rewriting``, and ``refactoring``.  The given truth table will be
+ * resynthesized in terms of an optimum size XMG network.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      xmg_network aig = ...;
+
+      exact_xmg_resynthesis<xmg_network> resyn;
+      xmg = cut_rewriting( xmg, resyn );
+   \endverbatim
+ *
+ *
+   The underlying engine for this resynthesis function is percy_.
+   \verbatim embed:rst
+
+   .. _percy: https://github.com/lsils/percy
+   \endverbatim
+ *
+ */
+template<class Ntk = xmg_network>
+class exact_xmg_resynthesis
+{
+public:
+  explicit exact_xmg_resynthesis( exact_xmg_resynthesis_params const& ps = {} )
+      : ps( ps )
+  {
+  }
+
+  template<typename LeavesIterator, typename TT, typename Fn>
+  void operator()( Ntk& ntk, TT const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    static_assert( kitty::is_complete_truth_table<TT>::value, "Truth table must be complete" );
+
+    using signal = mockturtle::signal<Ntk>;
+    auto const tt = function.num_vars() < 3u ? kitty::extend_to( function, 3u ) : function;
+    bool const normal = kitty::is_normal( tt );
+
+    percy::chain chain;
+    percy::spec spec;
+    spec.verbosity = 0;
+    spec.fanin = 3;
+    spec.conflict_limit = ps.conflict_limit;
+
+    /* specify local normalized gate primitives */
+    kitty::dynamic_truth_table const0{ 3 };
+    kitty::dynamic_truth_table a{ 3 };
+    kitty::dynamic_truth_table b{ 3 };
+    kitty::dynamic_truth_table c{ 3 };
+    kitty::create_nth_var( a, 0 );
+    kitty::create_nth_var( b, 1 );
+    kitty::create_nth_var( c, 2 );
+
+    spec.add_primitive( const0 ); // 00
+    spec.add_primitive( a );      // aa
+    spec.add_primitive( b );      // cc
+    spec.add_primitive( c );      // f0
+
+    /* add self dual gate functions */
+    spec.add_primitive( kitty::ternary_majority( a, b, c ) );  // e8
+    spec.add_primitive( kitty::ternary_majority( ~a, b, c ) ); // d4
+    spec.add_primitive( kitty::ternary_majority( a, ~b, c ) ); // b2
+    spec.add_primitive( kitty::ternary_majority( a, b, ~c ) ); // 8e
+    spec.add_primitive( a ^ b );                               // 66
+    spec.add_primitive( a ^ c );                               // 3c
+    spec.add_primitive( b ^ c );                               // 5a
+    if ( ps.use_xor3 )
+    {
+      spec.add_primitive( a ^ b ^ c ); // 96
+    }
+
+    /* add non-self dual gate functions */
+    if ( !ps.use_only_self_dual_gates )
+    {
+      spec.add_primitive( kitty::ternary_majority( const0, b, c ) );  // c0
+      spec.add_primitive( kitty::ternary_majority( ~const0, b, c ) ); // fc
+      spec.add_primitive( kitty::ternary_majority( const0, ~b, c ) ); // 30
+      spec.add_primitive( kitty::ternary_majority( const0, b, ~c ) ); // 0c
+      spec.add_primitive( kitty::ternary_majority( a, const0, c ) );  // a0
+      spec.add_primitive( kitty::ternary_majority( ~a, const0, c ) ); // 50
+      spec.add_primitive( kitty::ternary_majority( a, ~const0, c ) ); // fa
+      spec.add_primitive( kitty::ternary_majority( a, const0, ~c ) ); // 0a
+      spec.add_primitive( kitty::ternary_majority( a, b, const0 ) );  // 88
+      spec.add_primitive( kitty::ternary_majority( a, b, ~const0 ) ); // ee
+      spec.add_primitive( kitty::ternary_majority( ~a, b, const0 ) ); // 44
+      spec.add_primitive( kitty::ternary_majority( a, ~b, const0 ) ); // 22
+    }
+
+    percy::bsat_wrapper solver;
+    percy::ssv_encoder encoder( solver );
+
+    spec[0] = normal ? tt : ~tt;
+
+    for ( auto i = 0u; i < ps.num_candidates; ++i )
+    {
+      auto const result = percy::next_struct_solution( spec, chain, solver, encoder );
+      if ( result != percy::success )
+        break;
+
+      assert( result == percy::success );
+
+      auto const sim = chain.simulate();
+      assert( chain.simulate()[0] == spec[0] );
+
+      std::vector<signal> signals( tt.num_vars(), ntk.get_constant( false ) );
+      std::copy( begin, end, signals.begin() );
+
+      for ( auto i = 0; i < chain.get_nr_steps(); ++i )
+      {
+        auto const c1 = signals[chain.get_step( i )[0]];
+        auto const c2 = signals[chain.get_step( i )[1]];
+        auto const c3 = signals[chain.get_step( i )[2]];
+
+        switch ( chain.get_operator( i )._bits[0] )
+        {
+        case 0x00:
+          signals.emplace_back( ntk.get_constant( false ) );
+          break;
+        case 0xe8:
+          signals.emplace_back( ntk.create_maj( c1, c2, c3 ) );
+          break;
+        case 0xd4:
+          signals.emplace_back( ntk.create_maj( !c1, c2, c3 ) );
+          break;
+        case 0xb2:
+          signals.emplace_back( ntk.create_maj( c1, !c2, c3 ) );
+          break;
+        case 0x8e:
+          signals.emplace_back( ntk.create_maj( c1, c2, !c3 ) );
+          break;
+        case 0x96:
+          signals.emplace_back( ntk.create_xor3( c1, c2, c3 ) );
+          break;
+        case 0xc0:
+          signals.emplace_back( ntk.create_maj( ntk.get_constant( false ), c2, c3 ) ); // c0
+          break;
+        case 0xfc:
+          signals.emplace_back( ntk.create_maj( !ntk.get_constant( false ), c2, c3 ) ); // fc
+          break;
+        case 0x30:
+          signals.emplace_back( ntk.create_maj( ntk.get_constant( false ), !c2, c3 ) ); // 30
+          break;
+        case 0x0c:
+          signals.emplace_back( ntk.create_maj( ntk.get_constant( false ), c2, !c3 ) ); // 0c
+          break;
+        case 0xa0:
+          signals.emplace_back( ntk.create_maj( c1, ntk.get_constant( false ), c3 ) ); // 0a
+          break;
+        case 0x50:
+          signals.emplace_back( ntk.create_maj( !c1, ntk.get_constant( false ), c3 ) ); // 50
+          break;
+        case 0xfa:
+          signals.emplace_back( ntk.create_maj( c1, !ntk.get_constant( false ), c3 ) ); // fa
+          break;
+        case 0x0a:
+          signals.emplace_back( ntk.create_maj( c1, ntk.get_constant( false ), !c3 ) ); // 0a
+          break;
+        case 0x88:
+          signals.emplace_back( ntk.create_maj( c1, c2, ntk.get_constant( false ) ) ); // 88
+          break;
+        case 0xee:
+          signals.emplace_back( ntk.create_maj( c1, c2, !ntk.get_constant( false ) ) ); // ee
+          break;
+        case 0x44:
+          signals.emplace_back( ntk.create_maj( !c1, c2, ntk.get_constant( false ) ) ); // 44
+          break;
+        case 0x22:
+          signals.emplace_back( ntk.create_maj( c1, !c2, ntk.get_constant( false ) ) ); // 22
+          break;
+        case 0x66:
+          signals.emplace_back( ntk.create_xor( c1, c2 ) );
+          break;
+        case 0x3c:
+          signals.emplace_back( ntk.create_xor( c2, c3 ) );
+          break;
+        case 0x5a:
+          signals.emplace_back( ntk.create_xor( c1, c3 ) );
+          break;
+        default:
+          std::cerr << "[e] unsupported operation " << kitty::to_hex( chain.get_operator( i ) ) << "\n";
+          assert( false );
+          break;
+        }
+      }
+
+      assert( chain.get_outputs().size() > 0u );
+      uint32_t const output_index = ( chain.get_outputs()[0u] >> 1u );
+      auto const output_signal = output_index == 0u ? ntk.get_constant( false ) : signals[output_index - 1];
+      if ( !fn( chain.is_output_inverted( 0 ) ^ normal ? output_signal : !output_signal ) )
+      {
+        return; /* quit */
+      }
+    }
+  }
+
+protected:
+  exact_xmg_resynthesis_params const ps;
+}; /* exact_xmg_resynthesis */
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/mig_npn.hpp b/include/mockturtle/algorithms/node_resynthesis/mig_npn.hpp
new file mode 100644
index 0000000..4f8fb78
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/mig_npn.hpp
@@ -0,0 +1,236 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mig_npn.hpp
+  \brief Replace with size-optimum MIGs from NPN
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <iostream>
+#include <mockturtle/utils/debugging_utils.hpp>
+#include <sstream>
+#include <unordered_map>
+#include <vector>
+
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/npn.hpp>
+#include <kitty/print.hpp>
+
+#include "../../algorithms/cleanup.hpp"
+#include "../../networks/mig.hpp"
+#include "../../traits.hpp"
+#include "../../views/topo_view.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Resynthesis function based on pre-computed size-optimum MIGs.
+ *
+ * This resynthesis function can be passed to ``node_resynthesis``,
+ * ``cut_rewriting``, and ``refactoring``.  It will produce an MIG based on
+ * pre-computed size-optimum MIGs with up to at most 4 variables.
+ * Consequently, the nodes' fan-in sizes in the input network must not exceed
+ * 4.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      const klut_network klut = ...;
+      mig_npn_resynthesis resyn;
+      const auto mig = node_resynthesis<mig_network>( klut, resyn );
+   \endverbatim
+ */
+class mig_npn_resynthesis
+{
+public:
+  /*! \brief Default constructor.
+   *
+   * \param use_multiple If true, up to 10 structures are tried for each
+   *                     function.
+   */
+  mig_npn_resynthesis( bool use_multiple = false )
+  {
+    if ( use_multiple )
+    {
+      build_db10();
+    }
+    else
+    {
+      build_db();
+    }
+  }
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( mig_network& mig, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    assert( function.num_vars() <= 4 );
+    const auto fe = kitty::extend_to( function, 4 );
+    const auto config = kitty::exact_npn_canonization( fe );
+
+    const auto it = class2signal.find( static_cast<uint16_t>( std::get<0>( config )._bits[0] ) );
+
+    std::vector<mig_network::signal> pis( 4, mig.get_constant( false ) );
+    std::copy( begin, end, pis.begin() );
+
+    std::vector<mig_network::signal> pis_perm( 4 );
+    auto perm = std::get<2>( config );
+    for ( auto i = 0; i < 4; ++i )
+    {
+      pis_perm[i] = pis[perm[i]];
+    }
+
+    const auto& phase = std::get<1>( config );
+    for ( auto i = 0; i < 4; ++i )
+    {
+      if ( ( phase >> perm[i] ) & 1 )
+      {
+        pis_perm[i] = !pis_perm[i];
+      }
+    }
+
+    for ( auto const& po : it->second )
+    {
+      topo_view topo{ db, po };
+      auto f = cleanup_dangling( topo, mig, pis_perm.begin(), pis_perm.end() ).front();
+
+      mockturtle::print(topo);
+      if ( !fn( ( ( phase >> 4 ) & 1 ) ? !f : f ) )
+      {
+        return; /* quit */
+      }
+    }
+  }
+
+private:
+  void build_db()
+  {
+    std::vector<mig_network::signal> signals;
+    signals.push_back( db.get_constant( false ) );
+
+    auto p = nodes.begin();
+    for ( auto i = 0u; i < *p; ++i )
+    {
+      signals.push_back( db.create_pi() );
+    }
+
+    p++;         /* point to number of outputs */
+    p += *p + 1; /* move past number of output */
+
+    /* create nodes */
+    while ( p != nodes.end() )
+    {
+      const auto c1 = signals[*p >> 1] ^ ( *p & 1 );
+      ++p;
+      const auto c2 = signals[*p >> 1] ^ ( *p & 1 );
+      ++p;
+      const auto c3 = signals[*p >> 1] ^ ( *p & 1 );
+      ++p;
+
+      signals.push_back( db.create_maj( c1, c2, c3 ) );
+    }
+
+    /* create POs */
+    p = nodes.begin() + 2;
+    for ( auto i = 0u; i < nodes[1]; ++i )
+    {
+      const auto driver = signals[*p >> 1] ^ ( *p & 1 );
+      ++p;
+
+      db.create_po( driver );
+      class2signal[classes[i]].push_back( driver );
+    }
+  }
+
+  void build_db10()
+  {
+    std::vector<mig_network::signal> signals;
+    signals.push_back( db.get_constant( false ) );
+
+    auto p = nodes10.begin();
+    for ( auto i = 0u; i < *p; ++i )
+    {
+      signals.push_back( db.create_pi() );
+    }
+
+    p++; /* point to number of outputs */
+    const auto num_functions = *p++;
+
+    for ( auto i = 0u; i < num_functions; ++i )
+    {
+      p += *p + 1;
+    }
+
+    /* create nodes */
+    while ( p != nodes10.end() )
+    {
+      const auto c1 = signals[*p >> 1] ^ ( *p & 1 );
+      ++p;
+      const auto c2 = signals[*p >> 1] ^ ( *p & 1 );
+      ++p;
+      const auto c3 = signals[*p >> 1] ^ ( *p & 1 );
+      ++p;
+
+      signals.push_back( db.create_maj( c1, c2, c3 ) );
+    }
+
+    /* create PIs */
+    p = nodes10.begin() + 2;
+    for ( auto i = 0u; i < nodes10[1]; ++i )
+    {
+      const auto functions = *p++;
+      for ( auto j = 0u; j < functions; ++j )
+      {
+        const auto driver = signals[*p >> 1] ^ ( *p & 1 );
+        ++p;
+
+        db.create_po( driver );
+        class2signal[classes[i]].push_back( driver );
+      }
+    }
+  }
+
+  mig_network db;
+  std::unordered_map<uint16_t, std::vector<mig_network::signal>> class2signal;
+
+  inline static const std::vector<uint16_t> classes{ { 0x1ee1, 0x1be4, 0x1bd8, 0x18e7, 0x17e8, 0x17ac, 0x1798, 0x1796, 0x178e, 0x177e, 0x16e9, 0x16bc, 0x169e, 0x003f, 0x0359, 0x0672, 0x07e9, 0x0693, 0x0358, 0x01bf, 0x6996, 0x0356, 0x01bd, 0x001f, 0x01ac, 0x001e, 0x0676, 0x01ab, 0x01aa, 0x001b, 0x07e1, 0x07e0, 0x0189, 0x03de, 0x035a, 0x1686, 0x0186, 0x03db, 0x0357, 0x01be, 0x1683, 0x0368, 0x0183, 0x03d8, 0x07e6, 0x0182, 0x03d7, 0x0181, 0x03d6, 0x167e, 0x016a, 0x007e, 0x0169, 0x006f, 0x0069, 0x0168, 0x0001, 0x019a, 0x036b, 0x1697, 0x0369, 0x0199, 0x0000, 0x169b, 0x003d, 0x036f, 0x0666, 0x019b, 0x0187, 0x03dc, 0x0667, 0x0003, 0x168e, 0x06b6, 0x01eb, 0x07e2, 0x017e, 0x07b6, 0x007f, 0x19e3, 0x06b7, 0x011a, 0x077e, 0x018b, 0x00ff, 0x0673, 0x01a8, 0x000f, 0x1696, 0x036a, 0x011b, 0x0018, 0x0117, 0x1698, 0x036c, 0x01af, 0x0016, 0x067a, 0x0118, 0x0017, 0x067b, 0x0119, 0x169a, 0x003c, 0x036e, 0x07e3, 0x017f, 0x03d4, 0x06f0, 0x011e, 0x037c, 0x012c, 0x19e6, 0x01ef, 0x16a9, 0x037d, 0x006b, 0x012d, 0x012f, 0x01fe, 0x0019, 0x03fc, 0x179a, 0x013c, 0x016b, 0x06f2, 0x03c0, 0x033c, 0x1668, 0x0669, 0x019e, 0x013d, 0x0006, 0x019f, 0x013e, 0x0776, 0x013f, 0x016e, 0x03c3, 0x3cc3, 0x033f, 0x166b, 0x016f, 0x011f, 0x035e, 0x0690, 0x0180, 0x03d5, 0x06f1, 0x06b0, 0x037e, 0x03c1, 0x03c5, 0x03c6, 0x01a9, 0x166e, 0x03cf, 0x03d9, 0x07bc, 0x01bc, 0x1681, 0x03dd, 0x03c7, 0x06f9, 0x0660, 0x0196, 0x0661, 0x0197, 0x0662, 0x07f0, 0x0198, 0x0663, 0x07f1, 0x0007, 0x066b, 0x033d, 0x1669, 0x066f, 0x01ad, 0x0678, 0x01ae, 0x0679, 0x067e, 0x168b, 0x035f, 0x0691, 0x0696, 0x0697, 0x06b1, 0x0778, 0x16ac, 0x06b2, 0x0779, 0x16ad, 0x01e8, 0x06b3, 0x0116, 0x077a, 0x01e9, 0x06b4, 0x19e1, 0x01ea, 0x06b5, 0x01ee, 0x06b9, 0x06bd, 0x06f6, 0x07b0, 0x07b1, 0x07b4, 0x07b5, 0x07f2, 0x07f8, 0x018f, 0x0ff0, 0x166a, 0x035b, 0x1687, 0x1689, 0x036d, 0x069f, 0x1699 } };
+  inline static const std::vector<uint16_t> nodes{ { 4, 222, 17, 24, 34, 41, 46, 56, 68, 76, 84, 96, 109, 116, 122, 127, 137, 142, 151, 157, 166, 173, 182, 188, 193, 199, 208, 214, 220, 227, 232, 239, 247, 256, 259, 264, 272, 278, 286, 293, 297, 300, 307, 312, 321, 328, 336, 344, 351, 355, 362, 372, 378, 384, 387, 389, 393, 398, 401, 408, 417, 421, 425, 433, 0, 439, 445, 451, 454, 459, 467, 472, 475, 477, 482, 486, 491, 498, 502, 506, 509, 517, 523, 526, 532, 537, 9, 545, 548, 335, 554, 560, 563, 568, 573, 576, 580, 583, 586, 594, 596, 599, 603, 605, 612, 616, 622, 627, 629, 630, 634, 638, 640, 644, 650, 657, 665, 669, 675, 677, 679, 686, 691, 696, 702, 708, 713, 718, 722, 728, 738, 747, 750, 755, 756, 761, 766, 770, 773, 778, 785, 789, 159, 797, 801, 803, 810, 812, 820, 827, 831, 836, 844, 853, 857, 862, 869, 876, 879, 887, 892, 900, 911, 915, 921, 927, 930, 938, 941, 951, 954, 960, 966, 971, 975, 977, 985, 991, 1003, 1007, 1011, 1014, 1020, 1027, 1030, 1037, 1039, 1041, 1044, 1049, 1053, 1060, 1066, 1070, 1073, 1077, 1082, 1093, 1096, 1100, 1107, 1112, 1119, 1124, 1135, 1138, 1141, 1147, 1148, 1152, 1159, 1166, 1175, 1178, 1186, 1191, 1194, 1202, 1205, 1213, 1221, 1229, 1231, 1237, 1, 2, 4, 6, 8, 11, 9, 10, 12, 7, 12, 14, 0, 2, 7, 8, 10, 19, 8, 10, 21, 18, 20, 23, 5, 6, 8, 2, 4, 6, 0, 26, 28, 1, 26, 28, 0, 31, 32, 6, 9, 28, 8, 29, 36, 7, 36, 38, 0, 8, 28, 0, 8, 43, 28, 43, 44, 0, 5, 8, 4, 7, 48, 0, 2, 8, 2, 6, 48, 50, 53, 54, 0, 4, 9, 0, 2, 59, 0, 2, 58, 7, 8, 62, 2, 5, 6, 61, 64, 66, 0, 6, 9, 1, 4, 8, 2, 71, 72, 29, 70, 74, 0, 4, 8, 2, 4, 7, 0, 3, 8, 79, 80, 82, 0, 7, 8, 2, 7, 86, 4, 6, 87, 0, 6, 8, 2, 4, 92, 88, 90, 95, 0, 2, 4, 1, 6, 98, 2, 4, 99, 8, 100, 103, 101, 102, 104, 9, 104, 106, 1, 4, 6, 0, 9, 110, 2, 8, 110, 29, 112, 114, 0, 3, 6, 4, 52, 118, 80, 118, 121, 0, 4, 6, 1, 8, 124, 0, 2, 9, 0, 4, 128, 6, 9, 130, 4, 6, 131, 128, 133, 134, 0, 2, 5, 3, 6, 78, 93, 138, 140, 0, 9, 28, 2, 4, 9, 0, 6, 147, 145, 146, 148, 4, 8, 71, 2, 4, 8, 28, 152, 155, 4, 6, 8, 0, 8, 159, 2, 5, 158, 2, 6, 83, 160, 163, 164, 1, 2, 6, 0, 3, 4, 8, 168, 170, 3, 6, 18, 1, 18, 174, 4, 9, 176, 5, 8, 176, 177, 178, 180, 2, 82, 110, 2, 83, 110, 82, 185, 186, 2, 7, 78, 99, 158, 190, 0, 5, 6, 0, 3, 194, 6, 8, 197, 4, 8, 52, 4, 7, 8, 2, 6, 200, 1, 202, 204, 0, 201, 206, 0, 6, 10, 6, 9, 10, 0, 211, 212, 6, 9, 98, 1, 80, 216, 0, 99, 218, 4, 6, 53, 3, 52, 222, 1, 52, 224, 3, 6, 170, 2, 8, 228, 8, 128, 231, 2, 6, 8, 3, 4, 8, 1, 234, 236, 1, 6, 146, 6, 146, 241, 0, 9, 242, 0, 240, 245, 2, 5, 8, 4, 6, 248, 1, 8, 250, 0, 9, 252, 251, 252, 254, 10, 131, 194, 4, 7, 248, 0, 6, 249, 79, 260, 262, 0, 4, 7, 6, 8, 266, 3, 6, 8, 18, 269, 270, 2, 7, 8, 4, 82, 275, 5, 80, 276, 2, 8, 266, 4, 8, 281, 2, 7, 282, 0, 281, 284, 5, 8, 28, 0, 4, 29, 110, 288, 290, 0, 2, 110, 8, 110, 294, 1, 6, 236, 128, 159, 298, 4, 6, 83, 2, 4, 303, 274, 302, 305, 6, 58, 128, 8, 159, 308, 129, 308, 310, 5, 6, 170, 2, 7, 170, 4, 8, 316, 1, 314, 318, 2, 6, 9, 0, 249, 322, 0, 110, 325, 8, 324, 327, 2, 9, 170, 4, 6, 171, 1, 6, 8, 330, 333, 334, 2, 5, 266, 6, 8, 338, 2, 8, 267, 0, 341, 342, 3, 4, 6, 0, 8, 110, 110, 347, 348, 4, 8, 170, 125, 168, 352, 0, 9, 346, 1, 2, 8, 4, 194, 358, 356, 358, 361, 3, 6, 266, 1, 2, 266, 0, 2, 6, 4, 8, 368, 364, 366, 371, 7, 26, 128, 3, 6, 374, 27, 374, 376, 4, 9, 66, 0, 67, 380, 5, 380, 382, 2, 145, 346, 8, 66, 139, 7, 66, 346, 1, 8, 390, 6, 8, 80, 0, 28, 395, 8, 395, 396, 1, 10, 12, 0, 3, 26, 2, 9, 402, 0, 6, 26, 402, 404, 407, 4, 6, 129, 8, 128, 410, 4, 7, 412, 5, 410, 414, 2, 8, 158, 8, 28, 419, 4, 71, 128, 5, 410, 422, 1, 6, 10, 3, 8, 10, 0, 5, 10, 426, 428, 430, 3, 4, 86, 2, 26, 434, 87, 434, 436, 2, 7, 266, 8, 267, 440, 4, 267, 442, 4, 6, 369, 8, 368, 446, 5, 446, 448, 2, 4, 93, 3, 138, 452, 2, 8, 194, 3, 10, 456, 0, 8, 154, 6, 155, 460, 0, 7, 154, 1, 462, 464, 4, 9, 196, 4, 194, 469, 8, 468, 471, 1, 12, 98, 1, 4, 334, 1, 6, 80, 2, 8, 479, 48, 80, 481, 2, 29, 70, 10, 29, 484, 0, 4, 70, 52, 346, 489, 0, 8, 93, 2, 93, 492, 4, 7, 92, 170, 494, 497, 3, 6, 160, 146, 159, 500, 1, 2, 202, 29, 70, 504, 8, 98, 334, 4, 6, 78, 4, 6, 9, 3, 78, 512, 154, 511, 514, 0, 2, 67, 8, 171, 518, 6, 67, 520, 0, 2, 27, 26, 235, 524, 6, 8, 524, 5, 26, 524, 4, 529, 530, 3, 4, 194, 1, 456, 534, 1, 4, 270, 5, 6, 538, 0, 8, 540, 271, 538, 542, 1, 2, 110, 112, 358, 547, 4, 9, 82, 2, 6, 29, 29, 550, 552, 4, 128, 202, 4, 202, 557, 128, 557, 558, 3, 10, 234, 0, 5, 346, 4, 9, 346, 347, 564, 566, 4, 6, 358, 1, 234, 570, 0, 6, 29, 43, 154, 574, 5, 86, 368, 4, 371, 578, 6, 129, 190, 4, 9, 168, 0, 29, 584, 6, 8, 98, 2, 118, 589, 4, 8, 98, 589, 590, 592, 130, 159, 270, 1, 8, 28, 0, 4, 271, 8, 465, 600, 10, 248, 346, 0, 2, 249, 6, 8, 249, 1, 2, 608, 29, 606, 610, 6, 8, 195, 4, 194, 615, 5, 8, 128, 8, 128, 158, 4, 618, 621, 0, 147, 240, 202, 240, 624, 2, 8, 346, 1, 160, 356, 8, 81, 98, 8, 70, 633, 3, 4, 26, 159, 524, 636, 26, 58, 589, 0, 28, 159, 159, 236, 642, 5, 8, 18, 2, 8, 18, 146, 646, 649, 4, 6, 139, 4, 8, 138, 5, 652, 654, 3, 8, 110, 2, 111, 658, 0, 8, 513, 658, 660, 663, 2, 6, 73, 71, 158, 666, 0, 6, 67, 3, 4, 66, 8, 671, 672, 66, 158, 369, 6, 129, 154, 0, 4, 169, 8, 169, 680, 8, 680, 683, 168, 682, 685, 4, 8, 19, 2, 99, 688, 1, 8, 110, 0, 9, 692, 111, 692, 694, 7, 8, 128, 0, 4, 129, 346, 698, 701, 9, 194, 202, 2, 5, 202, 3, 704, 706, 2, 9, 124, 2, 346, 711, 4, 8, 70, 1, 2, 714, 29, 70, 716, 6, 26, 407, 0, 407, 720, 0, 4, 159, 7, 8, 724, 6, 159, 726, 6, 8, 159, 2, 4, 730, 1, 158, 732, 158, 732, 735, 0, 734, 737, 2, 4, 335, 2, 5, 334, 3, 740, 742, 1, 92, 744, 2, 7, 72, 9, 402, 748, 0, 2, 29, 1, 158, 752, 0, 29, 146, 4, 7, 358, 8, 10, 759, 4, 8, 66, 8, 66, 763, 266, 763, 764, 5, 6, 274, 93, 170, 768, 2, 129, 158, 0, 4, 235, 2, 9, 774, 235, 248, 776, 5, 6, 78, 1, 4, 780, 7, 780, 782, 5, 6, 202, 9, 202, 786, 0, 3, 158, 6, 202, 791, 2, 159, 790, 0, 792, 795, 0, 9, 146, 2, 346, 799, 6, 8, 10, 4, 8, 92, 4, 6, 805, 0, 3, 806, 274, 805, 808, 29, 70, 154, 6, 8, 81, 1, 6, 814, 0, 7, 816, 815, 816, 818, 4, 8, 269, 2, 266, 823, 1, 268, 824, 0, 8, 81, 71, 146, 828, 0, 2, 71, 4, 6, 832, 70, 154, 835, 5, 6, 128, 4, 8, 839, 4, 8, 838, 838, 840, 843, 0, 4, 202, 2, 6, 203, 1, 4, 848, 5, 846, 850, 0, 9, 18, 59, 110, 854, 0, 4, 275, 4, 93, 274, 5, 858, 860, 1, 4, 66, 0, 7, 66, 129, 864, 866, 6, 8, 791, 0, 4, 870, 2, 4, 159, 790, 873, 874, 1, 78, 194, 2, 8, 99, 4, 7, 98, 1, 86, 98, 880, 882, 885, 8, 111, 170, 6, 111, 170, 112, 888, 891, 3, 8, 512, 0, 4, 894, 0, 7, 894, 512, 897, 898, 2, 4, 147, 6, 8, 903, 7, 146, 904, 0, 8, 903, 904, 906, 909, 2, 8, 98, 2, 268, 913, 1, 8, 18, 4, 194, 916, 1, 194, 918, 2, 4, 155, 0, 7, 922, 8, 465, 924, 2, 4, 334, 0, 95, 928, 3, 6, 72, 0, 9, 932, 4, 6, 935, 128, 932, 937, 1, 12, 740, 1, 2, 170, 5, 170, 942, 6, 8, 944, 7, 942, 946, 945, 946, 948, 2, 93, 158, 0, 95, 952, 6, 8, 93, 8, 92, 98, 0, 956, 959, 4, 8, 195, 2, 9, 194, 11, 962, 964, 4, 270, 539, 92, 538, 969, 0, 7, 146, 1, 92, 972, 1, 334, 928, 6, 8, 589, 3, 4, 978, 0, 4, 978, 588, 980, 983, 1, 4, 274, 4, 8, 159, 158, 986, 989, 2, 8, 155, 4, 6, 992, 1, 154, 994, 4, 992, 997, 0, 155, 996, 6, 998, 1001, 0, 99, 102, 6, 8, 1005, 2, 6, 266, 168, 268, 1009, 0, 6, 155, 154, 589, 1012, 1, 8, 158, 3, 4, 1016, 128, 159, 1018, 1, 6, 154, 2, 4, 1023, 8, 465, 1024, 4, 7, 18, 6, 589, 1028, 6, 124, 237, 4, 6, 82, 236, 1032, 1035, 8, 110, 368, 87, 236, 706, 3, 4, 70, 2, 29, 1042, 2, 6, 138, 28, 248, 1047, 3, 6, 48, 71, 146, 1050, 7, 8, 98, 0, 6, 99, 8, 99, 1056, 9, 1054, 1058, 4, 52, 81, 1, 4, 234, 0, 1063, 1064, 0, 3, 154, 66, 93, 1068, 99, 588, 740, 2, 8, 111, 49, 1050, 1074, 3, 358, 570, 0, 9, 570, 571, 1078, 1080, 2, 8, 124, 7, 124, 1084, 4, 8, 1086, 4, 1084, 1089, 8, 1089, 1090, 159, 248, 346, 0, 235, 1094, 0, 358, 589, 6, 589, 1098, 0, 8, 478, 2, 4, 81, 478, 1102, 1105, 4, 8, 81, 0, 3, 80, 334, 1109, 1110, 4, 71, 138, 5, 6, 1114, 235, 1114, 1116, 1, 6, 26, 2, 6, 26, 128, 1120, 1123, 3, 4, 52, 6, 52, 1127, 5, 8, 52, 2, 6, 53, 1129, 1130, 1132, 1, 4, 698, 128, 155, 1136, 87, 236, 646, 3, 6, 52, 5, 6, 52, 248, 1142, 1145, 10, 29, 70, 70, 147, 358, 7, 70, 1150, 2, 4, 86, 4, 18, 1155, 8, 87, 1156, 0, 8, 237, 6, 52, 236, 6, 236, 1161, 1160, 1163, 1164, 0, 3, 146, 6, 8, 1168, 6, 1168, 1171, 146, 1170, 1173, 0, 29, 274, 9, 334, 1176, 7, 8, 28, 0, 29, 1180, 1, 6, 1180, 9, 1182, 1184, 2, 8, 170, 1, 314, 1188, 0, 8, 87, 6, 86, 1193, 2, 6, 158, 0, 154, 1197, 1, 2, 158, 155, 1198, 1200, 19, 234, 266, 4, 8, 235, 0, 6, 234, 3, 4, 1208, 6, 1206, 1211, 1, 6, 922, 8, 154, 1215, 9, 1214, 1216, 155, 1216, 1218, 2, 9, 368, 4, 7, 1222, 4, 9, 368, 6, 1224, 1227, 3, 28, 288, 4, 86, 237, 2, 4, 1233, 86, 1233, 1234 } };
+  inline static const std::vector<uint16_t> nodes10{ { 4, 222, 10, 17, 21, 25, 29, 33, 35, 17, 29, 21, 37, 10, 46, 56, 66, 70, 74, 78, 82, 84, 88, 90, 10, 100, 108, 112, 116, 118, 122, 126, 130, 140, 144, 10, 153, 159, 163, 167, 171, 175, 177, 181, 185, 189, 10, 194, 198, 198, 204, 206, 208, 212, 204, 214, 206, 2, 224, 230, 10, 240, 250, 258, 264, 276, 280, 286, 294, 296, 300, 10, 308, 316, 320, 326, 330, 334, 336, 340, 344, 350, 4, 352, 360, 362, 364, 10, 374, 384, 390, 392, 398, 404, 414, 398, 392, 422, 10, 431, 439, 443, 453, 463, 473, 481, 489, 499, 443, 2, 506, 510, 10, 514, 518, 526, 530, 536, 538, 542, 546, 550, 552, 4, 557, 559, 561, 563, 9, 571, 579, 587, 593, 599, 607, 613, 617, 623, 2, 626, 632, 10, 639, 643, 639, 643, 649, 651, 653, 655, 655, 649, 10, 663, 673, 679, 685, 689, 693, 697, 701, 705, 709, 10, 718, 728, 738, 744, 754, 758, 764, 768, 776, 780, 2, 783, 785, 10, 792, 800, 804, 812, 804, 816, 824, 824, 832, 840, 10, 846, 852, 856, 860, 864, 868, 872, 876, 878, 882, 10, 889, 893, 899, 903, 909, 913, 917, 923, 929, 935, 10, 937, 941, 943, 945, 949, 953, 955, 957, 961, 965, 10, 970, 980, 988, 996, 1000, 1006, 1014, 1024, 1032, 1038, 10, 1044, 1046, 1050, 1052, 1056, 1060, 1062, 1064, 1068, 1062, 10, 1070, 1074, 1080, 1070, 1082, 1084, 1088, 1096, 1102, 1108, 10, 1111, 1115, 1119, 1123, 1129, 1131, 1135, 1141, 1145, 1149, 10, 1156, 1164, 1168, 1170, 1174, 1178, 1180, 1182, 1184, 1186, 2, 1191, 1193, 10, 1197, 1203, 1205, 1209, 1211, 1203, 1215, 1217, 1221, 1223, 10, 1228, 1236, 1240, 1244, 1252, 1256, 1264, 1268, 1274, 1278, 10, 1283, 1287, 1293, 1297, 1305, 1311, 1319, 1323, 1325, 1327, 8, 1332, 1338, 1344, 1350, 1358, 1364, 1368, 1374, 10, 1378, 1380, 1384, 1388, 1394, 1396, 1402, 1406, 1410, 1412, 10, 1418, 1422, 1428, 1432, 1436, 1440, 1442, 1444, 1448, 1452, 2, 1458, 1462, 10, 1469, 1473, 1477, 1483, 1487, 1489, 1493, 1487, 1497, 1501, 7, 875, 1503, 1507, 1509, 845, 1511, 1513, 8, 1516, 1524, 1530, 1538, 1542, 1550, 1558, 1566, 10, 1573, 1577, 1581, 1589, 1593, 1597, 1601, 1607, 1611, 1615, 10, 1620, 1630, 1636, 1642, 1648, 1654, 1658, 1664, 1668, 1674, 10, 1681, 1685, 1691, 1697, 1701, 1707, 1711, 1713, 1717, 1719, 10, 1724, 1728, 1732, 1734, 1738, 1744, 1750, 1752, 1760, 1764, 2, 1768, 1772, 10, 1778, 1782, 1786, 1790, 1798, 1806, 1810, 1812, 1816, 1822, 6, 1825, 1829, 1833, 1837, 1841, 1843, 10, 1845, 1849, 1853, 1859, 1863, 1865, 1869, 1875, 1879, 1885, 10, 1888, 1892, 1898, 1904, 1908, 1912, 1920, 1926, 1934, 1938, 10, 1944, 1948, 1956, 1962, 1962, 1972, 1976, 1986, 1990, 1994, 10, 2002, 2006, 2010, 2016, 2020, 2024, 2016, 2028, 2032, 2036, 10, 2042, 2044, 2046, 2048, 2050, 2052, 2054, 2056, 2058, 2060, 9, 2063, 2063, 2067, 2069, 2071, 2073, 2069, 2077, 2071, 2, 2079, 2081, 10, 2085, 809, 809, 2089, 2085, 789, 2093, 797, 797, 2097, 10, 2100, 2104, 2108, 2114, 2120, 2124, 2130, 2134, 2136, 2140, 10, 2143, 2145, 2147, 2151, 2153, 2155, 2159, 2161, 2165, 2167, 10, 2172, 2176, 2172, 2182, 2186, 2190, 2190, 2194, 2186, 2200, 10, 2207, 2211, 2217, 2225, 2227, 2231, 2233, 2237, 2239, 2241, 10, 2245, 2249, 2251, 2253, 2255, 2259, 2263, 2267, 2269, 2271, 10, 2277, 2281, 2283, 2285, 2287, 2289, 2293, 2297, 2301, 2303, 10, 2309, 2315, 2321, 2329, 2331, 2335, 2331, 2337, 2343, 2345, 1, 0, 10, 2351, 2355, 2359, 2363, 2371, 2375, 2379, 2381, 2383, 2387, 10, 2391, 2395, 2399, 2403, 2407, 2411, 2413, 2417, 2419, 2425, 10, 2431, 2435, 2441, 2445, 2447, 2447, 2445, 2453, 2459, 2465, 10, 2468, 2474, 2478, 2482, 2484, 2486, 2490, 2492, 2494, 2498, 7, 2503, 2505, 2507, 2511, 2513, 2515, 2521, 10, 2527, 2533, 2535, 2541, 2543, 2545, 2549, 2551, 2555, 2557, 10, 2560, 2564, 2566, 2568, 2570, 2578, 2584, 2590, 2594, 2596, 10, 2601, 2603, 2607, 2609, 2611, 2603, 2615, 2617, 2619, 2617, 4, 2621, 2623, 1535, 1547, 5, 2626, 2632, 2636, 2640, 2632, 10, 2644, 2650, 2656, 2660, 2662, 2666, 2670, 2672, 2674, 2678, 10, 2683, 2687, 2693, 2697, 2701, 2707, 2711, 2717, 2721, 2729, 10, 2732, 2738, 2746, 2752, 2758, 2764, 2772, 2780, 2786, 2790, 10, 2794, 2800, 2806, 2808, 2810, 2814, 2816, 2822, 2828, 2830, 8, 2832, 2834, 2832, 2834, 2834, 2832, 2832, 2834, 10, 2837, 2841, 2845, 2847, 2849, 2851, 2855, 2857, 2859, 2861, 10, 2867, 2877, 2885, 2889, 2893, 2897, 2905, 2911, 2915, 2919, 10, 2923, 2931, 2937, 2941, 2947, 2953, 2959, 2963, 2969, 2971, 10, 2972, 2978, 2980, 2982, 2972, 2986, 2988, 2994, 2998, 2982, 10, 3006, 3014, 3018, 3022, 3026, 3030, 3034, 3038, 3042, 3046, 5, 3049, 3051, 3053, 3057, 3059, 1, 9, 10, 3065, 3069, 3077, 3069, 3081, 3087, 3095, 3099, 3081, 3103, 10, 3104, 3112, 3114, 3120, 3122, 3128, 3136, 3138, 3142, 3144, 1, 657, 10, 3146, 3154, 3160, 3164, 3172, 3180, 3186, 3190, 3192, 3194, 10, 3196, 3200, 3202, 3204, 3206, 3214, 3218, 3220, 3222, 3228, 6, 3233, 3235, 3237, 3239, 3241, 3243, 10, 3246, 3248, 3250, 3252, 3254, 3256, 3260, 3262, 3268, 3270, 10, 3273, 3277, 487, 3281, 3283, 3285, 3287, 3291, 3293, 441, 2, 3294, 3294, 10, 3296, 3302, 3306, 3310, 3314, 3296, 3318, 3324, 3330, 3332, 10, 3335, 3339, 3341, 3345, 3349, 3351, 3355, 3359, 3361, 3365, 10, 3366, 3368, 3370, 3372, 3376, 3378, 3366, 3378, 3380, 3370, 10, 3386, 3392, 3396, 3400, 3410, 3414, 3418, 3426, 3432, 3436, 10, 3440, 3442, 3446, 3452, 3454, 3458, 3462, 3464, 3468, 3474, 1, 191, 6, 3477, 3479, 3477, 3485, 3477, 3491, 10, 3493, 3495, 3497, 3499, 3503, 3507, 3511, 3513, 3515, 3519, 10, 3524, 3530, 3534, 3540, 3548, 3556, 3562, 3570, 3574, 3582, 10, 3584, 3586, 3588, 3590, 3584, 3592, 3594, 3596, 3598, 3600, 10, 3604, 3608, 3612, 3616, 3618, 3622, 3628, 3634, 3640, 3646, 10, 3653, 3653, 3657, 3663, 3665, 3667, 3669, 3671, 3673, 3679, 4, 1997, 1425, 2133, 2041, 10, 3680, 3682, 3684, 3688, 3690, 3694, 3696, 3700, 3702, 3704, 10, 3706, 3712, 3716, 3720, 3724, 3728, 3706, 3734, 3736, 3740, 10, 3744, 3748, 3752, 3756, 3760, 3764, 3766, 3772, 3776, 3782, 10, 3788, 3792, 3796, 3800, 3802, 3806, 3792, 3808, 3814, 3800, 10, 3820, 3824, 3830, 3834, 3836, 3838, 3844, 3848, 3852, 3860, 10, 3868, 3872, 3880, 3884, 3892, 3900, 3908, 3916, 3922, 3926, 10, 3929, 3933, 3939, 3941, 3943, 3947, 3949, 3951, 3953, 3957, 10, 3963, 3973, 3981, 3989, 3995, 4001, 4009, 4013, 4019, 4025, 10, 4027, 4033, 4027, 4039, 4047, 4051, 4055, 4061, 4065, 4067, 10, 4071, 4075, 4077, 4081, 4083, 4087, 4091, 4087, 4077, 4097, 3, 4099, 4101, 4103, 2, 4105, 4107, 10, 4108, 4110, 4112, 4116, 4120, 4124, 4130, 4136, 4142, 4148, 10, 4153, 4157, 4161, 4165, 4169, 4173, 4177, 4179, 4181, 4187, 10, 4188, 4192, 4194, 4196, 4198, 4200, 4204, 4206, 4198, 4200, 1, 4210, 10, 4214, 4216, 4222, 4226, 4230, 4234, 4238, 4242, 4246, 4252, 6, 4257, 4259, 4261, 4265, 4267, 4269, 10, 4270, 4276, 4280, 4284, 4288, 4294, 4294, 4270, 4288, 4300, 10, 4302, 4304, 4306, 4308, 4310, 4316, 4320, 4324, 4326, 4330, 10, 4332, 4336, 4340, 4346, 4350, 4356, 4360, 4364, 4368, 4374, 10, 4382, 4388, 4394, 4400, 4404, 4408, 4414, 4416, 4418, 4422, 10, 4433, 4437, 4447, 4453, 4457, 4459, 4465, 4467, 4471, 4475, 5, 4480, 4486, 4490, 4496, 4498, 10, 4501, 4505, 4507, 4509, 4511, 4513, 4517, 4519, 4525, 4529, 2, 4530, 4532, 10, 4537, 4539, 4541, 4543, 4545, 4549, 4551, 4555, 4559, 4563, 10, 4568, 4574, 4578, 4582, 4588, 4594, 4602, 4608, 4588, 4594, 10, 4610, 4612, 4614, 4616, 4618, 4622, 4624, 4626, 4628, 4630, 10, 4635, 4637, 4639, 4641, 4643, 4645, 4649, 4651, 4653, 4655, 10, 4660, 4664, 4666, 4672, 4678, 4682, 4688, 4692, 4696, 4700, 10, 4705, 4707, 4709, 4711, 4715, 4719, 4723, 4727, 4729, 4731, 10, 4735, 4737, 4739, 4741, 4743, 4743, 4739, 4737, 4745, 4745, 1, 927, 10, 4751, 4755, 4757, 4763, 4765, 4769, 4773, 4775, 4773, 4775, 10, 4777, 4781, 4785, 4787, 4789, 4793, 4795, 4797, 4799, 4803, 1, 19, 10, 4808, 4812, 4816, 4824, 4830, 4834, 4838, 4842, 4850, 4858, 4, 4860, 4862, 4864, 4866, 10, 4870, 4876, 4880, 4886, 4888, 4894, 4896, 4902, 4908, 4914, 10, 4921, 4927, 4931, 4935, 4937, 4927, 4943, 4949, 4953, 4959, 7, 4963, 4967, 4971, 4973, 4967, 4975, 4979, 2, 4982, 4984, 10, 4990, 4994, 4996, 5002, 5004, 5010, 5014, 5018, 5024, 5028, 10, 5031, 5039, 5043, 5051, 5055, 5059, 5061, 5063, 5067, 5071, 10, 5077, 5081, 5085, 5089, 5085, 5089, 5093, 5097, 5101, 5105, 10, 5110, 5114, 5118, 5110, 5122, 5128, 5132, 5136, 5138, 5144, 10, 5149, 5155, 5157, 5161, 5163, 5167, 5171, 5173, 5177, 5181, 10, 5186, 5192, 5198, 5186, 5204, 5208, 5212, 5218, 5224, 5204, 10, 5227, 5229, 5231, 5233, 5235, 5237, 5239, 5241, 5243, 5239, 10, 5249, 5255, 5259, 5267, 5271, 5277, 5283, 5287, 5297, 5305, 10, 5312, 5314, 5318, 5322, 5330, 5336, 5340, 5344, 5348, 5352, 3, 5358, 5362, 5366, 10, 5373, 5381, 5387, 5391, 5393, 5397, 5397, 5407, 5417, 5421, 10, 5423, 5427, 5429, 5435, 5441, 5445, 5449, 5455, 5457, 5461, 10, 5463, 5467, 5473, 5479, 5485, 5489, 5493, 5497, 5505, 5509, 10, 5515, 5517, 5521, 5521, 5527, 5531, 5535, 5539, 5545, 5549, 10, 5550, 5556, 5560, 5564, 5564, 5560, 5566, 5570, 5572, 5576, 10, 5580, 5590, 5594, 5600, 5604, 5608, 5612, 5620, 5626, 5630, 5, 5635, 5639, 5635, 5639, 5641, 10, 5647, 5653, 5657, 5661, 5663, 5669, 5675, 5681, 5689, 5695, 8, 5696, 5698, 5696, 5702, 5706, 5698, 5710, 5714, 10, 5718, 5722, 5724, 5728, 5734, 5740, 5746, 5752, 5758, 5764, 10, 5770, 5774, 5778, 5784, 5788, 5790, 5794, 5798, 5800, 5806, 10, 5809, 5811, 5811, 5809, 5815, 5819, 5823, 5825, 5829, 5815, 10, 5833, 5835, 5835, 5839, 5841, 1207, 5843, 5845, 5847, 5845, 10, 5849, 5851, 5853, 5855, 5857, 5859, 5863, 5865, 5867, 5869, 10, 5875, 5883, 5887, 5893, 5897, 5901, 5907, 5913, 5915, 5917, 10, 5919, 5923, 5929, 5935, 5941, 5947, 5955, 5961, 5967, 5973, 10, 5979, 5985, 5991, 5997, 6003, 6009, 6015, 6021, 6025, 6025, 10, 6029, 6033, 6033, 6037, 6037, 5977, 829, 829, 6029, 821, 10, 6039, 6045, 6047, 6051, 6057, 6063, 6065, 6069, 6071, 6073, 9, 6078, 6084, 6086, 6088, 6092, 6094, 6096, 6098, 6102, 10, 6106, 6110, 6112, 6118, 6122, 6126, 6134, 6138, 6142, 6144, 7, 6151, 6155, 6157, 6157, 6161, 6163, 6155, 10, 6166, 6170, 6172, 6178, 6180, 6184, 6186, 6192, 6194, 6196, 10, 6207, 6211, 6217, 6221, 6231, 6237, 6241, 6249, 6253, 6259, 2, 1387, 4837, 10,
+                                                       6265, 6269, 6273, 6277, 6283, 6285, 6287, 6291, 6293, 6295, 10, 6296, 6298, 6300, 6304, 6306, 6308, 6310, 6296, 6312, 6314, 10, 6319, 6323, 6327, 6331, 6335, 6339, 6341, 6343, 6349, 6353, 2, 6357, 6361, 10, 6362, 6366, 6370, 6376, 6380, 6386, 6390, 6394, 6398, 6402, 10, 6408, 6414, 6420, 6426, 6432, 6438, 6442, 6450, 6456, 6460, 10, 6462, 6464, 6462, 6468, 6472, 6474, 6462, 6478, 6462, 6482, 10, 6489, 6493, 6495, 6497, 6499, 6503, 6505, 6507, 6499, 6509, 10, 6515, 6517, 6521, 6523, 6525, 6529, 6531, 6537, 6539, 6545, 1, 6550, 10, 6555, 6559, 6563, 6567, 6573, 6577, 6581, 6583, 6585, 6589, 10, 6592, 6594, 6602, 6608, 6614, 6618, 6620, 6626, 6632, 6636, 10, 6640, 6646, 6652, 6658, 6662, 6664, 6668, 6672, 6676, 6680, 10, 6683, 6689, 6691, 6697, 6703, 6709, 6715, 6721, 6723, 6725, 2, 6728, 6728, 10, 6731, 6737, 6741, 6749, 6755, 6759, 6763, 6769, 6775, 6781, 10, 6784, 6788, 6794, 6798, 6784, 6802, 6804, 6810, 6812, 6816, 10, 6823, 6831, 6837, 6845, 6851, 6857, 6865, 6869, 6879, 6885, 10, 6886, 6892, 6898, 6902, 6906, 6910, 6912, 6914, 6916, 6920, 6, 6925, 6929, 6933, 6935, 6937, 6941, 4, 6945, 6947, 6949, 6953, 4, 6954, 6956, 6958, 6960, 10, 6964, 6968, 6970, 6974, 6980, 6984, 6988, 6990, 6994, 6998, 10, 7003, 7009, 7011, 7015, 7023, 7027, 7029, 7031, 7035, 7039, 10, 7046, 7054, 7060, 7064, 7068, 7072, 7076, 7082, 7088, 7096, 10, 7103, 7107, 7115, 7119, 7123, 7127, 7131, 7133, 7135, 7139, 10, 7142, 7144, 7148, 7154, 7158, 7162, 7166, 7172, 7176, 7180, 10, 7186, 7190, 7196, 7200, 7206, 7208, 7214, 7218, 7222, 7226, 10, 7229, 7231, 7233, 7235, 7237, 7239, 7241, 7243, 7245, 7247, 10, 7248, 7250, 7252, 7254, 7250, 7254, 7252, 5760, 5760, 7256, 10, 7262, 7268, 7272, 7276, 7280, 7284, 7286, 7288, 7290, 7292, 5, 7295, 7297, 7299, 7301, 7303, 9, 7305, 7307, 7311, 7317, 7319, 7323, 7329, 7333, 7339, 10, 7343, 7349, 7349, 7355, 7359, 7363, 7367, 7371, 7349, 7375, 7, 7381, 7383, 7387, 7391, 7393, 7399, 7403, 10, 7405, 7407, 7405, 7411, 7413, 7415, 7417, 7419, 7413, 7421, 10, 7425, 7431, 7437, 7441, 7443, 7447, 7453, 7459, 7463, 7467, 1, 2, 4, 7, 8, 10, 6, 8, 11, 9, 12, 14, 6, 8, 10, 6, 12, 19, 8, 10, 13, 6, 12, 23, 6, 9, 10, 7, 14, 26, 7, 8, 26, 11, 26, 30, 11, 12, 26, 10, 14, 19, 0, 4, 7, 2, 4, 6, 9, 38, 40, 8, 38, 40, 8, 42, 45, 0, 3, 4, 0, 2, 6, 9, 48, 50, 8, 48, 50, 8, 52, 55, 0, 5, 6, 3, 4, 6, 9, 58, 60, 8, 58, 60, 8, 62, 65, 48, 50, 53, 8, 52, 69, 58, 60, 63, 8, 62, 73, 8, 49, 50, 48, 55, 76, 8, 59, 60, 58, 65, 80, 51, 52, 76, 9, 48, 76, 51, 76, 86, 61, 62, 80, 2, 4, 8, 3, 6, 8, 0, 93, 94, 0, 92, 94, 92, 96, 99, 5, 6, 8, 0, 40, 103, 0, 41, 102, 1, 104, 106, 0, 92, 95, 1, 96, 110, 1, 40, 102, 41, 104, 114, 103, 106, 114, 1, 40, 106, 103, 106, 120, 1, 92, 94, 95, 96, 124, 1, 92, 96, 95, 96, 128, 2, 5, 8, 2, 6, 9, 0, 132, 135, 0, 133, 134, 1, 136, 138, 1, 132, 134, 135, 138, 142, 2, 5, 6, 3, 8, 146, 2, 8, 146, 2, 148, 151, 7, 8, 40, 6, 8, 40, 6, 154, 157, 6, 8, 41, 9, 154, 160, 6, 9, 40, 41, 154, 164, 6, 9, 154, 41, 154, 168, 2, 9, 146, 147, 148, 172, 7, 160, 164, 2, 8, 147, 3, 172, 178, 8, 146, 149, 2, 148, 183, 8, 40, 155, 6, 154, 187, 1, 8, 40, 8, 40, 191, 0, 190, 193, 0, 8, 40, 0, 190, 197, 0, 8, 41, 0, 9, 40, 1, 200, 202, 9, 190, 200, 41, 190, 202, 0, 9, 190, 41, 190, 210, 40, 197, 200, 0, 2, 8, 0, 5, 8, 2, 6, 218, 4, 7, 218, 217, 220, 222, 3, 6, 216, 4, 6, 217, 218, 227, 228, 0, 7, 8, 2, 4, 232, 5, 6, 232, 2, 216, 236, 234, 236, 239, 1, 2, 8, 5, 8, 242, 0, 6, 245, 8, 41, 246, 242, 245, 248, 0, 9, 92, 7, 8, 252, 6, 41, 254, 1, 252, 256, 2, 4, 255, 6, 254, 261, 1, 252, 262, 0, 2, 4, 0, 9, 266, 7, 8, 268, 2, 4, 271, 6, 270, 273, 1, 268, 274, 6, 41, 270, 1, 268, 278, 0, 6, 9, 8, 41, 282, 1, 252, 284, 0, 9, 234, 2, 4, 233, 6, 232, 291, 1, 288, 292, 1, 252, 292, 6, 41, 232, 1, 252, 298, 0, 4, 9, 7, 242, 302, 2, 4, 305, 6, 304, 307, 1, 4, 8, 0, 2, 9, 6, 311, 312, 41, 310, 314, 7, 310, 312, 5, 60, 318, 1, 8, 60, 5, 312, 322, 7, 60, 324, 7, 312, 322, 5, 60, 328, 6, 243, 302, 41, 242, 332, 41, 312, 322, 4, 6, 61, 312, 322, 339, 2, 4, 319, 6, 318, 343, 4, 6, 313, 1, 8, 346, 41, 312, 348, 41, 310, 312, 0, 3, 8, 0, 4, 8, 2, 4, 7, 354, 357, 358, 217, 218, 358, 41, 242, 302, 2, 6, 49, 3, 8, 48, 0, 4, 369, 6, 8, 370, 366, 368, 373, 0, 2, 5, 4, 6, 377, 5, 8, 376, 6, 8, 266, 378, 380, 383, 0, 2, 378, 6, 8, 386, 378, 380, 389, 366, 368, 383, 0, 6, 11, 1, 8, 10, 383, 394, 396, 0, 4, 366, 6, 8, 400, 366, 368, 403, 0, 6, 359, 7, 8, 358, 2, 4, 409, 0, 8, 410, 406, 408, 413, 2, 7, 48, 1, 48, 102, 2, 8, 48, 416, 418, 421, 1, 6, 266, 9, 10, 424, 10, 424, 427, 8, 426, 429, 1, 2, 60, 8, 338, 432, 9, 338, 432, 8, 435, 436, 8, 10, 424, 8, 426, 441, 2, 4, 11, 1, 6, 444, 9, 10, 446, 8, 10, 446, 8, 448, 451, 0, 5, 10, 2, 6, 455, 9, 10, 456, 8, 10, 456, 8, 458, 461, 0, 3, 10, 4, 6, 465, 9, 10, 466, 8, 10, 466, 8, 468, 471, 4, 6, 49, 9, 10, 474, 8, 10, 474, 8, 476, 479, 2, 6, 377, 9, 10, 482, 8, 10, 482, 8, 484, 487, 1, 2, 6, 4, 6, 490, 9, 10, 492, 8, 10, 492, 8, 494, 497, 1, 4, 6, 0, 9, 500, 2, 8, 500, 41, 502, 504, 3, 8, 40, 200, 500, 509, 4, 312, 491, 41, 490, 512, 5, 312, 490, 4, 41, 516, 1, 6, 358, 0, 9, 358, 3, 520, 522, 5, 358, 524, 5, 520, 522, 3, 358, 528, 2, 9, 376, 4, 6, 376, 60, 532, 535, 41, 520, 522, 4, 8, 48, 60, 416, 541, 3, 6, 48, 358, 541, 544, 2, 6, 517, 4, 516, 549, 41, 378, 532, 0, 4, 6, 1, 8, 554, 4, 8, 39, 6, 8, 59, 6, 8, 310, 4, 7, 266, 2, 9, 564, 6, 8, 564, 267, 566, 568, 1, 2, 38, 2, 8, 38, 6, 8, 38, 572, 575, 576, 2, 9, 266, 4, 6, 267, 6, 9, 266, 580, 582, 585, 2, 8, 267, 7, 8, 266, 564, 588, 591, 4, 7, 580, 6, 8, 580, 267, 594, 596, 1, 4, 312, 5, 6, 312, 6, 9, 312, 600, 602, 605, 3, 8, 38, 7, 8, 38, 572, 608, 611, 6, 8, 267, 582, 588, 615, 4, 6, 312, 6, 8, 312, 600, 619, 620, 2, 7, 356, 267, 282, 624, 0, 6, 8, 3, 6, 356, 376, 629, 630, 2, 4, 9, 0, 6, 635, 203, 634, 636, 0, 7, 634, 6, 203, 640, 1, 6, 634, 0, 8, 644, 41, 644, 646, 8, 191, 644, 0, 203, 644, 41, 196, 644, 1, 6, 8, 0, 4, 656, 3, 4, 8, 40, 659, 660, 2, 6, 8, 4, 9, 664, 1, 6, 666, 4, 664, 669, 8, 666, 671, 0, 6, 358, 4, 8, 675, 359, 634, 676, 0, 8, 147, 4, 6, 681, 132, 147, 682, 4, 8, 283, 359, 634, 686, 4, 8, 555, 359, 634, 690, 6, 9, 310, 132, 147, 694, 6, 9, 500, 132, 147, 698, 7, 8, 500, 359, 634, 702, 7, 8, 310, 359, 634, 706, 6, 8, 313, 4, 7, 710, 0, 5, 712, 312, 712, 714, 9, 710, 716, 0, 3, 134, 5, 8, 720, 1, 4, 722, 134, 722, 724, 7, 720, 726, 6, 8, 39, 0, 3, 730, 6, 9, 38, 2, 730, 734, 7, 732, 736, 2, 9, 614, 7, 218, 266, 3, 740, 742, 0, 3, 6, 1, 8, 746, 5, 6, 748, 9, 266, 746, 7, 750, 752, 4, 7, 748, 5, 752, 756, 0, 5, 590, 9, 590, 746, 1, 760, 762, 1, 4, 590, 5, 762, 766, 6, 8, 565, 0, 3, 770, 9, 266, 772, 7, 770, 774, 9, 574, 732, 7, 730, 778, 8, 48, 490, 8, 10, 746, 6, 41, 358, 1, 8, 786, 0, 8, 786, 0, 788, 791, 3, 146, 358, 1, 8, 794, 0, 8, 794, 0, 796, 799, 8, 786, 789, 0, 788, 803, 4, 41, 146, 1, 8, 806, 8, 806, 809, 0, 808, 811, 0, 8, 806, 0, 808, 815, 1, 48, 376, 6, 8, 819, 6, 8, 818, 818, 820, 823, 5, 10, 48, 6, 8, 827, 6, 8, 826, 826, 828, 831, 5, 10, 464, 6, 8, 835, 6, 8, 834, 834, 836, 839, 2, 355, 500, 2, 354, 500, 354, 842, 845, 8, 313, 500, 9, 312, 848, 501, 848, 850, 3, 354, 842, 501, 842, 854, 3, 354, 500, 501, 842, 858, 9, 312, 500, 501, 848, 862, 2, 354, 501, 3, 842, 866, 8, 312, 501, 9, 848, 870, 8, 312, 500, 312, 848, 875, 2, 845, 858, 354, 500, 859, 2, 858, 881, 4, 7, 10, 5, 10, 746, 8, 884, 886, 7, 8, 132, 48, 490, 890, 5, 6, 490, 7, 8, 894, 48, 490, 896, 2, 8, 41, 48, 490, 900, 4, 6, 9, 2, 8, 905, 48, 490, 906, 5, 8, 358, 48, 490, 910, 7, 8, 146, 48, 490, 914, 4, 7, 490, 5, 8, 918, 48, 490, 920, 2, 8, 376, 4, 6, 8, 51, 924, 926, 6, 8, 48, 1, 2, 930, 905, 930, 932, 8, 10, 656, 2, 6, 48, 1, 8, 938, 4, 132, 656, 2, 656, 660, 0, 6, 10, 1, 8, 946, 4, 6, 50, 1, 8, 950, 8, 634, 641, 1, 8, 534, 0, 6, 634, 1, 8, 958, 1, 2, 660, 6, 8, 962, 0, 2, 474, 8, 48, 475, 421, 966, 968, 2, 7, 8, 0, 3, 972, 4, 7, 974, 2, 973, 976, 357, 974, 978, 9, 38, 664, 0, 8, 983, 38, 665, 984, 39, 982, 986, 9, 38, 50, 3, 8, 990, 6, 39, 992, 7, 990, 994, 39, 50, 992, 7, 990, 998, 7, 8, 990, 2, 39, 1002, 3, 990, 1004, 8, 747, 904, 2, 4, 1008, 0, 8, 1011, 9, 1008, 1012, 4, 6, 747, 8, 747, 1016, 2, 4, 1018, 0, 8, 1021, 9, 1018, 1022, 6, 9, 48, 0, 2, 1026, 4, 7, 8, 421, 1028, 1030, 217, 218, 904, 0, 2, 1034, 7, 1034, 1036, 0, 3, 146, 4, 9, 146, 7, 1040, 1042, 7, 26, 394, 6, 9, 634, 7, 636, 1048, 9, 12, 394, 7, 8, 634, 9, 636, 1054, 0, 7, 10, 9, 394, 1058, 9, 636, 640, 9, 14, 1058, 6, 8, 635, 9, 640, 1066, 60, 376, 383, 0, 5, 490, 48, 629, 1072, 9, 358, 656, 2, 4, 1077, 0, 1076, 1079, 376, 544, 629, 282, 445, 1058, 2, 60, 267, 0, 383, 1086, 0, 8, 359, 6, 358, 1091, 2, 4, 1093, 0, 1092, 1095, 9, 358, 520, 2, 4, 1099, 0, 1098, 1101, 6, 358, 629, 2, 4, 1105, 0, 1104, 1107, 216, 313, 500, 0, 2, 60, 60, 216, 1113, 0, 2, 500, 216, 500, 1117, 0, 3, 432, 8, 432, 1120, 0, 3, 500, 1, 2, 1124, 8, 1124, 1126, 3, 216, 520, 3, 6, 38, 1, 216, 1132, 4, 7, 216, 3, 6, 1136, 1, 216, 1138, 1, 6, 1136, 3, 216, 1142, 1, 4, 146, 3, 216, 1146, 3, 8, 60, 0, 61, 1150, 1, 2, 1152, 9, 1152, 1154, 0, 3, 132, 0, 7, 132, 1, 2, 1160, 9, 1158, 1162, 3, 4, 58, 312, 354, 1167, 312, 354, 631, 1, 6, 92, 242, 312, 1173, 0, 9, 242, 242, 1173, 1176, 242, 312, 433, 242, 312, 1147, 242, 1147, 1176, 312, 354, 1125, 0, 2, 7, 8, 10, 1189, 1, 660, 664, 0, 283, 634, 1, 636, 1194, 7, 628, 634, 6, 628, 635, 1, 1198, 1200, 635, 644, 1198, 7, 628, 644, 635, 644, 1206, 1, 636, 1198, 1, 6, 1198, 635, 1198, 1212, 1, 640, 1200, 8, 634, 657, 1, 636, 1218, 635, 644, 1218, 0, 6, 148, 0, 7, 148, 6, 1225, 1226, 2, 6, 660, 1, 8, 1230, 0, 9, 1232, 1231, 1232, 1234, 0, 9, 1230, 1231, 1232, 1238, 1, 6, 148, 0, 1225, 1242, 5, 8, 60, 0, 6, 1246, 1, 6, 1246, 0, 1249, 1250, 1, 8, 634, 282, 645, 1254, 2, 4, 282, 1, 6, 1258, 1, 8, 1258, 282, 1261, 1262, 0, 7, 40, 202, 232, 1267, 0, 7, 290, 0, 9, 290, 232, 1271, 1272, 0, 8, 1230, 0, 1232, 1277, 2, 5, 356, 60, 1113, 1280, 5, 356, 490, 1, 48, 1284, 4, 9, 48, 0, 2, 1288, 48, 366, 1291, 2, 6, 1289, 48, 1291, 1294, 4, 9, 746, 0, 2, 1298,
+                                                       2, 4, 747, 746, 1301, 1302, 5, 8, 10, 0, 2, 1307, 10, 394, 1309, 5, 8, 490, 0, 2, 1313, 0, 4, 491, 490, 1315, 1316, 5, 216, 490, 1, 48, 1320, 3, 10, 1320, 3, 10, 1284, 1, 6, 132, 4, 6, 132, 302, 1328, 1331, 0, 6, 243, 4, 7, 242, 357, 1334, 1336, 0, 7, 242, 4, 6, 243, 357, 1340, 1342, 0, 6, 242, 5, 6, 242, 302, 1347, 1348, 2, 8, 303, 1, 6, 1352, 4, 6, 1352, 302, 1354, 1357, 0, 6, 1352, 5, 6, 1352, 302, 1361, 1362, 4, 6, 133, 357, 1160, 1366, 0, 6, 133, 4, 7, 132, 357, 1370, 1372, 5, 134, 310, 7, 720, 1376, 357, 1334, 1340, 0, 7, 102, 51, 134, 1382, 6, 242, 356, 242, 1334, 1387, 6, 242, 357, 0, 7, 1390, 243, 1390, 1392, 0, 1387, 1390, 7, 8, 312, 6, 218, 313, 9, 1398, 1400, 1, 102, 134, 7, 720, 1404, 1, 134, 722, 7, 720, 1408, 7, 1334, 1390, 5, 312, 664, 3, 4, 1414, 7, 1414, 1416, 3, 522, 926, 5, 358, 1420, 6, 8, 358, 3, 522, 1424, 5, 358, 1426, 5, 522, 1424, 3, 358, 1430, 5, 312, 1424, 3, 358, 1434, 5, 522, 664, 3, 358, 1438, 3, 358, 1414, 7, 60, 1414, 2, 155, 200, 4, 41, 1446, 4, 155, 200, 2, 41, 1450, 3, 6, 1336, 4, 8, 1455, 0, 1336, 1457, 4, 8, 1188, 0, 1336, 1461, 2, 9, 1370, 0, 4, 1465, 6, 1371, 1466, 1, 132, 608, 6, 38, 1470, 8, 267, 572, 6, 38, 1474, 2, 8, 58, 0, 134, 1479, 4, 58, 1481, 0, 4, 135, 132, 500, 1484, 38, 582, 588, 1, 6, 1484, 132, 1484, 1490, 0, 6, 132, 1, 1484, 1494, 1, 4, 134, 135, 1494, 1498, 6, 38, 242, 0, 4, 242, 6, 242, 1504, 0, 242, 500, 8, 500, 1116, 4, 58, 242, 3, 6, 310, 312, 927, 1514, 1, 4, 354, 2, 7, 1518, 5, 6, 354, 9, 1520, 1522, 3, 4, 242, 0, 7, 1526, 9, 1348, 1528, 0, 3, 102, 1, 4, 102, 2, 7, 1534, 9, 1532, 1536, 1, 6, 660, 312, 927, 1540, 0, 3, 1030, 1, 6, 1030, 2, 5, 1546, 9, 1544, 1548, 1, 2, 1030, 3, 6, 1030, 0, 5, 1554, 9, 1552, 1556, 1, 2, 102, 3, 4, 102, 0, 7, 1562, 9, 1560, 1564, 4, 6, 355, 6, 92, 1569, 8, 1568, 1571, 3, 6, 132, 7, 1568, 1574, 6, 8, 93, 7, 1568, 1578, 3, 8, 554, 4, 7, 1582, 4, 6, 1582, 6, 1584, 1587, 4, 146, 1569, 8, 1568, 1591, 6, 358, 1569, 8, 1568, 1595, 2, 60, 1569, 8, 1568, 1599, 4, 6, 354, 2, 1569, 1602, 8, 1568, 1605, 2, 926, 1569, 8, 1568, 1609, 5, 6, 1582, 4, 1587, 1612, 8, 312, 927, 6, 313, 1616, 302, 1616, 1618, 4, 8, 313, 5, 6, 1622, 0, 9, 1624, 4, 312, 1626, 7, 1624, 1628, 4, 312, 1624, 0, 9, 1632, 7, 1624, 1634, 2, 5, 310, 6, 310, 1638, 0, 383, 1640, 0, 2, 383, 4, 6, 1644, 218, 383, 1646, 0, 2, 346, 4, 8, 1651, 282, 347, 1652, 6, 8, 1651, 302, 347, 1656, 7, 102, 312, 6, 313, 1660, 302, 1660, 1662, 6, 102, 313, 302, 1660, 1666, 5, 312, 1030, 6, 313, 1670, 302, 1670, 1672, 5, 6, 216, 0, 146, 1677, 4, 1676, 1679, 6, 216, 267, 1, 38, 1682, 0, 5, 1146, 6, 8, 1686, 147, 1146, 1688, 6, 9, 376, 0, 2, 1692, 376, 500, 1695, 0, 2, 590, 267, 500, 1698, 2, 6, 376, 0, 9, 1702, 376, 500, 1705, 0, 4, 146, 216, 500, 1709, 216, 500, 675, 0, 4, 147, 102, 1146, 1714, 406, 520, 1030, 8, 377, 490, 0, 9, 1720, 501, 1720, 1722, 4, 8, 58, 0, 1720, 1727, 0, 8, 500, 0, 1720, 1731, 0, 577, 1720, 0, 4, 753, 752, 1030, 1737, 0, 134, 1281, 6, 8, 357, 7, 1740, 1742, 2, 6, 357, 0, 133, 1746, 7, 1742, 1748, 7, 138, 1742, 6, 92, 377, 0, 8, 1754, 1, 8, 1754, 0, 1757, 1758, 6, 8, 1737, 7, 752, 1762, 4, 9, 376, 483, 656, 1766, 2, 9, 48, 475, 656, 1770, 6, 8, 217, 2, 5, 1774, 0, 1677, 1776, 2, 7, 558, 0, 575, 1780, 2, 5, 560, 0, 1479, 1784, 6, 8, 1527, 0, 1348, 1789, 2, 8, 39, 2, 5, 38, 6, 8, 1794, 0, 1792, 1797, 2, 8, 59, 2, 7, 58, 4, 8, 1802, 0, 1800, 1805, 3, 4, 656, 312, 501, 1808, 312, 501, 1514, 6, 8, 377, 312, 501, 1814, 4, 8, 217, 2, 7, 1818, 0, 1137, 1820, 61, 500, 1730, 1, 8, 1802, 4, 58, 1826, 1, 8, 1794, 6, 38, 1830, 0, 8, 60, 61, 500, 1834, 0, 9, 60, 4, 58, 1839, 6, 38, 1839, 216, 432, 1113, 3, 216, 432, 61, 432, 1846, 3, 60, 216, 61, 432, 1850, 5, 6, 48, 2, 7, 540, 1, 1854, 1856, 2, 61, 216, 1, 1850, 1860, 51, 500, 924, 2, 8, 1188, 267, 500, 1866, 0, 8, 1146, 5, 146, 1870, 147, 1146, 1872, 0, 2, 61, 1, 1850, 1876, 4, 7, 376, 6, 313, 376, 1, 1880, 1882, 3, 4, 282, 357, 1160, 1886, 5, 58, 132, 59, 1838, 1890, 0, 5, 318, 8, 312, 1895, 6, 318, 1897, 0, 2, 323, 9, 500, 1900, 322, 501, 1902, 7, 38, 1830, 6, 1833, 1906, 5, 58, 1826, 4, 1829, 1910, 0, 8, 501, 0, 2, 501, 9, 60, 1916, 1, 1914, 1918, 4, 6, 1839, 8, 312, 1923, 1, 1838, 1924, 0, 9, 346, 4, 6, 1929, 8, 312, 1931, 1, 1928, 1932, 6, 39, 1830, 38, 1833, 1936, 4, 146, 197, 4, 146, 196, 0, 1940, 1943, 2, 60, 197, 3, 1876, 1946, 4, 6, 41, 0, 3, 1950, 0, 2, 1951, 197, 1952, 1954, 6, 196, 358, 6, 197, 358, 0, 1959, 1960, 5, 6, 376, 0, 2, 1965, 6, 8, 1966, 4, 376, 1969, 377, 1964, 1970, 2, 4, 382, 500, 1644, 1975, 2, 4, 267, 0, 7, 1978, 8, 266, 1981, 0, 1978, 1982, 6, 1980, 1985, 0, 10, 382, 6, 1058, 1989, 2, 48, 382, 6, 416, 1993, 4, 8, 146, 6, 8, 147, 0, 2, 1999, 1997, 1998, 2000, 6, 103, 312, 3, 1660, 2004, 4, 312, 1031, 3, 1670, 2008, 2, 354, 927, 3, 354, 926, 9, 2012, 2014, 9, 312, 926, 3, 1616, 2018, 3, 8, 2018, 927, 2018, 2022, 2, 9, 2014, 927, 2014, 2026, 3, 6, 1660, 103, 1660, 2030, 3, 4, 1670, 1031, 1670, 2034, 2, 9, 60, 2, 8, 60, 0, 2038, 2041, 0, 432, 2041, 60, 1876, 2041, 0, 1146, 1997, 0, 520, 1425, 358, 406, 1425, 146, 1714, 1997, 48, 134, 927, 9, 1150, 1876, 3, 1876, 2038, 2, 60, 203, 0, 9, 338, 2, 60, 2065, 6, 203, 358, 4, 146, 203, 2, 203, 1950, 2, 4, 203, 6, 203, 2074, 8, 49, 60, 8, 146, 377, 2, 41, 60, 1, 8, 2082, 2, 60, 339, 1, 8, 2086, 5, 60, 358, 1, 8, 2090, 7, 60, 146, 1, 8, 2094, 3, 40, 1030, 5, 202, 2098, 4, 8, 147, 5, 202, 2102, 1, 8, 338, 0, 2041, 2106, 5, 8, 202, 2, 6, 2110, 202, 2110, 2113, 5, 8, 40, 2, 6, 2116, 202, 2116, 2119, 2, 4, 154, 154, 202, 2123, 7, 8, 202, 2, 4, 2126, 202, 2126, 2129, 6, 8, 92, 0, 190, 2133, 0, 190, 1425, 2, 6, 203, 132, 202, 2139, 1, 2, 1150, 1, 10, 14, 1, 8, 26, 2, 8, 61, 1, 60, 2148, 1, 8, 1042, 1, 146, 2102, 5, 8, 146, 1, 4, 2156, 1, 8, 2038, 6, 9, 358, 1, 8, 2162, 1, 6, 12, 5, 8, 58, 0, 3, 2168, 2, 1479, 2170, 8, 58, 2171, 2, 2170, 2175, 6, 102, 1561, 2, 8, 2178, 0, 1560, 2181, 0, 2, 2169, 1479, 2168, 2184, 1, 2, 2168, 0, 1479, 2188, 2, 9, 58, 59, 2170, 2192, 5, 8, 2192, 0, 3, 2196, 59, 2192, 2198, 5, 312, 346, 7, 8, 346, 346, 2202, 2204, 4, 7, 620, 313, 602, 2208, 6, 102, 312, 4, 7, 2212, 313, 2212, 2214, 4, 6, 501, 0, 2, 2218, 2, 9, 2218, 500, 2220, 2223, 346, 602, 2204, 4, 313, 602, 602, 1030, 2228, 346, 602, 1030, 4, 312, 1030, 313, 602, 2234, 60, 382, 555, 346, 605, 2202, 2, 5, 408, 4, 359, 2242, 3, 6, 2156, 2, 147, 2246, 8, 338, 2087, 8, 40, 807, 8, 40, 2083, 4, 41, 664, 8, 40, 2257, 6, 41, 92, 8, 40, 2261, 2, 41, 926, 8, 40, 2265, 8, 40, 1425, 8, 40, 787, 0, 9, 618, 4, 312, 2273, 6, 619, 2274, 4, 7, 312, 303, 346, 2278, 4, 203, 602, 4, 602, 2273, 203, 312, 346, 312, 346, 2273, 4, 6, 2273, 312, 2273, 2290, 4, 6, 203, 203, 312, 2294, 302, 312, 2279, 6, 2278, 2299, 6, 2273, 2278, 6, 8, 356, 2, 5, 2304, 1, 48, 2306, 0, 2, 1306, 6, 1306, 2310, 3, 10, 2312, 8, 10, 267, 0, 6, 2316, 10, 2316, 2318, 0, 8, 490, 3, 4, 2322, 2, 5, 2322, 1, 2324, 2326, 10, 660, 1964, 5, 6, 1188, 10, 660, 2332, 10, 544, 1306, 1, 2, 48, 5, 8, 2338, 544, 2338, 2340, 10, 660, 1072, 6, 8, 235, 2, 232, 2346, 4, 235, 2348, 2, 102, 232, 3, 290, 2352, 3, 4, 232, 102, 290, 2356, 3, 232, 290, 102, 290, 2360, 2, 5, 232, 6, 8, 2364, 2, 232, 2367, 4, 2364, 2369, 2, 103, 232, 4, 2364, 2373, 2, 102, 233, 102, 290, 2377, 233, 2352, 2356, 4, 2352, 2373, 3, 4, 2352, 233, 2352, 2384, 2, 4, 58, 2, 560, 2389, 1, 4, 906, 6, 906, 2392, 1, 4, 900, 6, 900, 2396, 1, 4, 910, 6, 910, 2400, 1, 4, 914, 6, 914, 2404, 1, 4, 890, 6, 890, 2408, 4, 890, 1328, 4, 7, 1328, 8, 1328, 2414, 8, 103, 1328, 2, 6, 39, 5, 6, 38, 8, 2420, 2423, 4, 7, 50, 4, 9, 50, 6, 2426, 2429, 5, 8, 346, 312, 346, 2432, 4, 6, 51, 5, 8, 2436, 50, 2436, 2438, 5, 6, 50, 8, 2436, 2442, 8, 346, 602, 0, 9, 10, 2, 6, 11, 4, 2449, 2450, 4, 8, 50, 5, 6, 2454, 51, 2454, 2456, 4, 8, 312, 5, 6, 2460, 313, 2460, 2462, 2, 4, 628, 0, 10, 2467, 2, 4, 629, 0, 3, 2470, 5, 2470, 2472, 2, 377, 628, 4, 376, 2477, 4, 49, 628, 2, 48, 2481, 3, 376, 2470, 5, 48, 2470, 2, 4, 14, 0, 10, 2489, 48, 376, 629, 0, 2467, 2470, 2, 5, 628, 48, 629, 2496, 2, 8, 1854, 1, 48, 2500, 1, 48, 1478, 3, 10, 1478, 3, 8, 10, 10, 58, 2508, 10, 58, 2193, 4, 267, 1478, 0, 6, 267, 2, 8, 2516, 4, 267, 2518, 1, 6, 1460, 2, 4, 2523, 1460, 2522, 2525, 0, 93, 1172, 6, 9, 2528, 1172, 2528, 2531, 500, 523, 1188, 3, 6, 1876, 4, 8, 1876, 1, 2536, 2538, 267, 424, 1460, 267, 424, 574, 3, 6, 376, 1, 1460, 2546, 1, 1460, 1854, 5, 6, 746, 1, 1460, 2552, 1, 574, 2546, 5, 8, 746, 302, 629, 2558, 0, 9, 1514, 310, 927, 2562, 310, 927, 1838, 232, 357, 1298, 357, 1030, 1838, 4, 9, 58, 0, 3, 2572, 5, 8, 2574, 59, 2572, 2576, 0, 5, 1030, 1, 60, 1030, 9, 2580, 2582, 0, 5, 322, 4, 7, 322, 9, 2586, 2588, 4, 9, 2170, 59, 2168, 2592, 302, 322, 927, 6, 8, 1979, 1, 266, 2598, 4, 14, 49, 6, 8, 2339, 4, 49, 2604, 4, 14, 465, 2, 14, 377, 1, 2, 14, 4, 14, 2612, 1, 14, 266, 1, 14, 444, 1, 8, 904, 1, 8, 500, 0, 5, 1424, 217, 358, 2624, 6, 8, 216, 0, 5, 2628, 217, 358, 2630, 4, 8, 521, 354, 358, 2635, 0, 3, 1424, 357, 358, 2638, 0, 9, 146, 267, 358, 2642, 1, 4, 282, 2, 7, 2646, 5, 1886, 2648, 4, 8, 267, 0, 6, 2653, 267, 358, 2654, 6, 48, 629, 5, 358, 2658, 7, 146, 2658, 6, 48, 628, 48, 146, 2665, 2, 283, 2646, 41, 282, 2668, 41, 282, 2648, 282, 1259, 2648, 2, 4, 746, 282, 358, 2677, 4, 8, 216, 60, 555, 2680, 2, 41, 1124, 8, 500, 2684, 4, 6, 1125, 2, 1124, 2689, 8, 500, 2690, 5, 358, 1124, 8, 500, 2694, 7, 146, 1124, 8, 500, 2698, 2, 5, 1124, 7, 1124, 2702, 8, 500, 2704, 1, 58, 358, 8, 1166, 2708, 8, 41, 500, 0, 2, 2712, 500, 2712, 2714, 1, 38, 146, 8, 1132, 2718, 0, 2, 927, 4, 6, 2723, 8, 927, 2724, 2722, 2724, 2726, 4, 7, 628, 974, 2470, 2731, 1, 2, 232, 267, 554, 2734, 9, 232, 2736, 3, 232, 376, 4, 6, 232, 9, 376, 2742, 1, 2740, 2744, 4, 6, 2740, 9, 376, 2748, 1, 2740, 2750, 2, 5, 354, 1, 1602, 2754, 9, 232, 2756, 7, 354, 376, 1, 6, 2760, 1766, 2760, 2762, 4, 282, 376, 3, 8, 2766, 7, 376, 2768, 1, 2766, 2770, 9, 376, 554, 3, 8, 2774, 7, 376, 2776, 1, 2774, 2778, 7, 8, 2774, 3, 376, 2782, 1, 2774, 2784, 8, 38, 233, 48, 2734, 2789, 1, 60, 242, 0, 2041, 2792, 0, 8, 2039,
+                                                       2, 61, 2796, 3, 2038, 2798, 9, 60, 1876, 3, 8, 2802, 61, 2802, 2804, 61, 1150, 2802, 0, 2041, 2142, 1, 6, 408, 0, 1425, 2812, 0, 1997, 2158, 8, 358, 1425, 0, 7, 2818, 6, 1425, 2820, 8, 146, 1997, 0, 5, 2824, 4, 1997, 2826, 94, 927, 2448, 146, 629, 1544, 41, 282, 1552, 8, 377, 1702, 0, 7, 266, 8, 266, 2839, 0, 7, 92, 8, 92, 2843, 8, 242, 554, 4, 8, 1348, 6, 8, 1336, 0, 6, 266, 1, 8, 2852, 8, 60, 242, 8, 266, 656, 8, 242, 926, 0, 2, 102, 4, 283, 2862, 102, 133, 2864, 3, 4, 134, 1, 2, 2868, 0, 7, 2868, 5, 2870, 2872, 8, 2868, 2874, 1, 2, 1366, 0, 7, 1366, 5, 2878, 2880, 8, 1366, 2882, 8, 38, 2878, 5, 1366, 2886, 8, 2878, 2880, 5, 1366, 2890, 8, 38, 2870, 5, 2868, 2894, 4, 9, 60, 0, 7, 2898, 8, 10, 2900, 5, 2898, 2902, 3, 4, 26, 8, 10, 38, 5, 2906, 2908, 9, 10, 160, 38, 160, 2912, 9, 10, 1066, 38, 1066, 2916, 10, 41, 50, 8, 40, 2921, 5, 8, 554, 3, 6, 2924, 2, 555, 2924, 4, 2926, 2928, 3, 4, 702, 2, 501, 702, 6, 2932, 2934, 8, 10, 50, 8, 40, 2939, 8, 147, 500, 2, 6, 2942, 501, 2942, 2944, 8, 359, 554, 2, 4, 2948, 555, 2948, 2950, 1, 8, 1188, 4, 6, 1188, 359, 2954, 2956, 1, 8, 38, 40, 573, 2960, 0, 5, 508, 0, 6, 509, 40, 2964, 2967, 61, 226, 1818, 7, 134, 1532, 5, 8, 134, 0, 3, 2974, 7, 134, 2976, 0, 665, 1560, 2, 665, 1532, 0, 2, 103, 102, 665, 2984, 9, 972, 1532, 5, 6, 972, 0, 3, 2990, 9, 972, 2992, 6, 8, 1533, 2, 1532, 2997, 0, 4, 95, 3, 94, 3000, 6, 8, 3000, 2, 3002, 3005, 2, 4, 657, 1, 656, 3008, 6, 8, 3008, 0, 3010, 3013, 0, 656, 3013, 3008, 3013, 3016, 2, 94, 3005, 3000, 3005, 3020, 0, 656, 3009, 3008, 3013, 3024, 2, 94, 3001, 3000, 3005, 3028, 6, 8, 3029, 3000, 3028, 3033, 6, 8, 3025, 3008, 3024, 3037, 7, 8, 3000, 9, 3028, 3040, 7, 8, 3008, 9, 3024, 3044, 216, 267, 500, 1, 1166, 1478, 10, 58, 313, 3, 4, 216, 1, 1676, 3054, 313, 376, 500, 1, 4, 1090, 2, 9, 358, 1090, 3060, 3062, 0, 4, 3062, 1, 1090, 3066, 0, 4, 94, 6, 94, 3071, 0, 8, 3072, 4, 3071, 3074, 1, 8, 358, 359, 3066, 3078, 2, 9, 3078, 0, 4, 3082, 359, 3078, 3084, 1, 4, 94, 5, 6, 3088, 0, 8, 3090, 95, 3088, 3092, 0, 8, 358, 8, 3066, 3097, 1, 8, 3066, 359, 3066, 3100, 354, 734, 1133, 2, 8, 501, 0, 3, 3106, 1, 2, 3108, 3107, 3108, 3110, 217, 1116, 1914, 0, 2, 228, 0, 8, 229, 217, 3116, 3118, 354, 1116, 1731, 0, 9, 504, 1, 8, 3124, 505, 3124, 3126, 3, 8, 500, 0, 501, 3130, 1, 500, 3132, 3131, 3132, 3134, 312, 1914, 1917, 2, 6, 38, 354, 577, 3140, 354, 1727, 2388, 0, 2082, 2255, 0, 2, 661, 5, 6, 3148, 4, 7, 3148, 3, 3150, 3152, 0, 2, 2103, 4, 7, 3156, 3, 146, 3158, 4, 7, 2000, 3, 146, 3162, 4, 8, 359, 0, 2, 3167, 5, 6, 3168, 3, 358, 3170, 6, 8, 359, 0, 2, 3175, 5, 6, 3176, 3, 358, 3178, 0, 2, 1151, 4, 7, 3182, 5, 60, 3184, 5, 6, 3182, 7, 60, 3188, 5, 60, 3152, 7, 60, 3150, 355, 2012, 2014, 4, 313, 1030, 5, 2008, 3198, 7, 1666, 2004, 1030, 2008, 2235, 6, 1660, 2213, 2, 9, 926, 0, 3, 3208, 1, 8, 3208, 927, 3210, 3212, 5, 8, 312, 618, 621, 3216, 312, 2235, 3198, 312, 1666, 2213, 0, 243, 926, 0, 242, 926, 242, 3224, 3227, 3, 6, 10, 8, 10, 3230, 6, 10, 135, 8, 10, 973, 3, 10, 664, 4, 267, 664, 1, 48, 664, 0, 7, 164, 41, 164, 3244, 11, 38, 134, 11, 904, 1188, 38, 661, 746, 0, 151, 172, 0, 157, 164, 4, 8, 60, 0, 2898, 3259, 58, 266, 665, 0, 5, 60, 8, 60, 3265, 4, 3264, 3267, 2, 151, 1040, 1, 40, 1996, 1, 2, 926, 8, 40, 3274, 1, 2, 1950, 8, 40, 3278, 8, 40, 432, 6, 10, 190, 6, 190, 358, 1, 4, 664, 8, 40, 3288, 8, 40, 1146, 41, 252, 1172, 232, 2428, 2455, 5, 50, 232, 4, 9, 3298, 51, 3298, 3300, 4, 51, 232, 9, 3298, 3304, 5, 8, 50, 9, 3304, 3308, 4, 8, 51, 9, 3298, 3312, 4, 50, 232, 232, 2428, 3317, 0, 7, 3308, 4, 51, 3320, 9, 3308, 3322, 0, 7, 3312, 5, 50, 3326, 9, 3312, 3328, 4, 2455, 3298, 1, 746, 2680, 1, 2, 218, 8, 490, 3337, 8, 746, 1159, 2, 8, 1316, 3, 490, 3342, 4, 8, 1072, 3, 490, 3346, 1, 216, 630, 3, 6, 2680, 1, 216, 3352, 1, 6, 2680, 3, 216, 3356, 3, 490, 2680, 0, 8, 1302, 1, 746, 3362, 0, 41, 1042, 0, 339, 2038, 0, 41, 2162, 0, 41, 1048, 2, 9, 1950, 0, 41, 3374, 0, 41, 2038, 0, 26, 41, 5, 8, 266, 2, 614, 3383, 0, 383, 3384, 0, 7, 3274, 2, 628, 926, 6, 3388, 3391, 0, 6, 3275, 3274, 3391, 3394, 0, 146, 927, 665, 3274, 3398, 0, 2, 926, 6, 926, 3403, 1, 2, 3404, 6, 8, 3402, 0, 3406, 3409, 0, 3, 3404, 2, 3409, 3412, 0, 2, 3405, 3404, 3409, 3416, 4, 8, 266, 6, 267, 3420, 1, 2, 3422, 0, 383, 3424, 9, 3274, 3388, 2, 926, 3429, 6, 3388, 3431, 2, 746, 927, 665, 3274, 3434, 1, 2, 2156, 0, 151, 3438, 9, 590, 1532, 9, 102, 266, 7, 1532, 3444, 0, 5, 94, 9, 94, 266, 7, 3448, 3450, 9, 590, 3448, 7, 102, 266, 9, 1532, 3456, 7, 94, 266, 9, 3448, 3460, 2991, 2992, 2994, 9, 972, 2990, 2991, 2992, 3466, 2, 5, 926, 6, 972, 3471, 0, 927, 3472, 8, 2843, 3000, 8, 625, 3008, 1, 6, 624, 2, 4, 3481, 8, 625, 3482, 3, 6, 2842, 0, 4, 3487, 8, 2843, 3488, 8, 591, 1978, 2, 267, 3258, 4, 150, 267, 10, 146, 660, 3, 4, 18, 5, 10, 3500, 3, 4, 664, 5, 10, 3504, 2, 4, 383, 267, 382, 3508, 1, 376, 3504, 2, 267, 3504, 3, 4, 382, 2, 267, 3516, 2, 58, 357, 7, 356, 3520, 60, 3520, 3522, 0, 8, 48, 2, 7, 3526, 60, 541, 3528, 5, 312, 432, 60, 1398, 3532, 3, 146, 232, 102, 232, 3537, 2, 3536, 3539, 1, 2, 302, 4, 6, 3542, 302, 500, 3543, 2, 3545, 3546, 3, 302, 500, 4, 6, 3551, 302, 500, 3552, 2, 3550, 3555, 6, 61, 356, 2, 58, 3559, 356, 3559, 3560, 3, 58, 356, 4, 6, 3565, 5, 356, 3566, 2, 3564, 3569, 58, 356, 3566, 2, 3564, 3573, 4, 8, 282, 2, 6, 3576, 3, 282, 926, 2, 3579, 3580, 0, 904, 927, 5, 38, 904, 6, 38, 559, 4, 58, 561, 4, 58, 927, 6, 38, 927, 0, 500, 927, 0, 555, 904, 9, 38, 58, 4, 9, 312, 7, 1624, 3602, 4, 8, 2450, 0, 396, 3607, 7, 10, 660, 5, 2448, 3610, 3, 10, 1030, 5, 2448, 3614, 9, 712, 3216, 9, 312, 1622, 7, 1624, 3620, 7, 8, 2448, 3, 10, 3624, 5, 2448, 3626, 3, 8, 2448, 7, 10, 3630, 5, 2448, 3632, 6, 313, 3216, 4, 7, 3636, 9, 3216, 3638, 7, 8, 3602, 5, 312, 3642, 313, 3602, 3644, 0, 634, 1031, 0, 634, 1030, 6, 3649, 3650, 0, 635, 1030, 636, 1030, 3655, 4, 8, 640, 0, 634, 3659, 6, 640, 3661, 6, 640, 3649, 1, 636, 3650, 635, 644, 3650, 636, 644, 1030, 6, 959, 3650, 4, 8, 959, 0, 634, 3674, 6, 959, 3676, 347, 348, 1928, 0, 322, 2305, 0, 322, 577, 0, 8, 346, 0, 348, 3687, 8, 1928, 3687, 5, 6, 310, 7, 1838, 3692, 60, 1382, 1835, 4, 6, 242, 282, 310, 3699, 302, 656, 3699, 60, 1835, 2580, 92, 282, 2467, 2, 4, 656, 8, 40, 3709, 0, 656, 3711, 8, 359, 3008, 0, 656, 3715, 8, 266, 358, 267, 282, 3718, 8, 267, 282, 282, 358, 3722, 8, 266, 359, 0, 656, 3727, 0, 6, 92, 2, 4, 3730, 92, 282, 3733, 10, 282, 291, 2, 4, 522, 282, 358, 3739, 0, 3, 656, 927, 3008, 3742, 0, 10, 657, 19, 656, 3746, 0, 10, 103, 19, 102, 3750, 0, 10, 95, 19, 94, 3754, 0, 10, 15, 14, 19, 3758, 6, 8, 3758, 14, 3758, 3763, 358, 1425, 3448, 2, 4, 95, 6, 8, 3768, 3448, 3768, 3771, 6, 8, 634, 634, 3448, 3775, 2, 4, 3449, 6, 8, 3778, 3448, 3778, 3781, 0, 5, 614, 4, 7, 614, 9, 3784, 3786, 6, 8, 2984, 102, 302, 3791, 4, 8, 3403, 282, 927, 3794, 6, 8, 3403, 302, 927, 3798, 218, 383, 904, 6, 218, 267, 9, 222, 3804, 102, 302, 383, 2, 4, 731, 6, 8, 3810, 38, 730, 3813, 0, 6, 376, 4, 8, 376, 1030, 3816, 3819, 0, 665, 1030, 5, 666, 3822, 5, 50, 354, 4, 7, 3826, 9, 3826, 3828, 4, 7, 354, 5, 2428, 3832, 7, 1522, 2428, 7, 904, 3826, 0, 2, 904, 5, 354, 3840, 7, 904, 3842, 4, 242, 1189, 0, 927, 3846, 1, 6, 376, 102, 1766, 3851, 3, 8, 904, 0, 7, 3854, 4, 6, 3854, 904, 3856, 3859, 4, 7, 746, 3, 8, 3862, 2, 8, 3862, 2, 3864, 3867, 3, 8, 640, 634, 3659, 3870, 3, 4, 1188, 2, 8, 3875, 2, 8, 3874, 3874, 3876, 3879, 2, 9, 3874, 8, 3879, 3882, 2, 8, 1189, 3, 4, 3886, 5, 1188, 3886, 9, 3888, 3890, 4, 8, 1189, 2, 5, 3894, 3, 1188, 3894, 9, 3896, 3898, 3, 8, 1188, 2, 5, 3902, 4, 1189, 3902, 9, 3904, 3906, 5, 8, 1188, 3, 4, 3910, 2, 1189, 3910, 9, 3912, 3914, 4, 9, 1876, 5, 8, 1876, 1877, 3918, 3920, 5, 8, 3918, 1877, 3918, 3924, 5, 378, 3818, 1, 6, 10, 8, 394, 3930, 1, 4, 746, 2, 5, 746, 8, 3934, 3936, 8, 432, 3264, 58, 92, 313, 0, 8, 10, 1, 394, 3944, 3, 366, 420, 11, 3930, 3944, 49, 420, 544, 2, 8, 544, 49, 544, 3954, 1, 6, 3106, 4, 9, 3958, 3106, 3130, 3960, 0, 8, 555, 4, 6, 555, 2, 3964, 3966, 2, 3965, 3966, 8, 3969, 3970, 0, 7, 3130, 5, 8, 3974, 500, 3131, 3976, 2, 3130, 3979, 4, 6, 3106, 1, 2, 3982, 9, 500, 3984, 3, 3106, 3986, 1, 2, 2218, 9, 500, 3990, 3, 3106, 3992, 1, 2, 904, 9, 500, 3996, 3, 3106, 3998, 1, 4, 3106, 9, 500, 3106, 6, 4002, 4004, 3, 3106, 4006, 4, 3958, 4004, 3, 3106, 4010, 1, 4, 4004, 6, 4004, 4014, 3, 3106, 4016, 3, 8, 3966, 3964, 3966, 4021, 2, 4020, 4023, 303, 926, 2984, 6, 8, 303, 0, 2, 4029, 303, 926, 4030, 1, 4, 2984, 5, 6, 2984, 8, 4034, 4036, 0, 2, 1031, 1, 6, 4040, 4, 7, 4040, 8, 4042, 4044, 2, 38, 103, 39, 576, 4048, 6, 8, 4048, 39, 4048, 4052, 4, 8, 59, 2, 6, 4057, 59, 1726, 4058, 4, 8, 4058, 59, 4058, 4062, 39, 576, 3810, 0, 3, 40, 8, 1950, 4069, 0, 3, 338, 8, 60, 4073, 8, 60, 4069, 0, 3, 926, 8, 60, 4079, 8, 60, 3071, 0, 6, 660, 8, 60, 4085, 0, 6, 48, 8, 60, 4089, 2, 5, 60, 0, 6, 4093, 8, 60, 4095, 60, 490, 905, 51, 146, 926, 41, 490, 926, 8, 60, 490, 6, 92, 313, 217, 502, 3106, 312, 1150, 1835, 312, 1731, 3130, 3, 8, 346, 312, 3687, 4114, 2, 9, 500, 217, 1914, 4118, 0, 8, 61, 217, 2038, 4122, 0, 8, 3931, 0, 9, 3930, 1, 4126, 4128, 0, 8, 433, 0, 9, 432, 1, 4132, 4134, 0, 8, 1147, 0, 9, 1146, 1, 4138, 4140, 0, 8, 521, 0, 9, 520, 1, 4144, 4146, 4, 6, 48, 1, 132, 4150, 3, 4, 50, 1, 132, 4154, 1, 4, 132, 60, 132, 4158, 0, 133, 1188, 4, 132, 4163, 4, 6, 491, 1, 132, 4166, 0, 2, 1030, 8, 10, 4171, 0, 4, 972, 8, 10, 4175, 1, 132, 3258, 132, 1189, 4158, 2, 7, 376, 4, 8, 4183, 1, 376, 4184, 0, 1731, 2622, 8, 38, 611, 6, 610, 4191, 8, 577, 734, 302, 656, 927, 9, 610, 730, 39, 610, 734, 6, 9, 610, 39, 610, 4202, 7, 730, 734, 4, 8, 243, 60, 1340, 4209, 0, 8, 3275, 500, 927, 4212, 927, 3584, 3854, 0, 3, 906, 5, 6, 4218, 7, 904, 4220, 0, 5, 1578, 4, 927, 4224, 0, 5, 3174, 4, 927, 4228, 0, 7, 2102, 6, 927, 4232, 1, 4, 1578, 0, 927, 4236, 1, 6, 2102, 0, 927, 4240, 1, 4, 3174, 0, 927, 4244, 0, 8, 3997, 5, 6, 4248, 7, 904, 4250, 2, 9, 554, 4, 146, 4255, 6, 358, 4255, 2, 60, 4255, 2, 8, 554, 60, 555, 4262, 60, 555, 2040, 8, 60, 1583, 282, 358, 3067, 3, 8, 282, 0, 4, 4273, 282, 358,
+                                                       4275, 2, 7, 3420, 267, 282, 4278, 2, 7, 3576, 267, 282, 4282, 1, 2, 3576, 41, 282, 4286, 4, 8, 40, 1, 2, 4290, 41, 282, 4292, 2, 9, 10, 4, 6, 4296, 10, 282, 4299, 218, 554, 629, 302, 501, 656, 282, 310, 501, 59, 218, 282, 39, 232, 302, 0, 9, 926, 1, 8, 4312, 927, 4312, 4314, 1, 6, 1382, 103, 1382, 4318, 1, 4, 2580, 1031, 2580, 4322, 0, 558, 577, 6, 8, 311, 0, 3692, 4329, 38, 102, 927, 0, 5, 1546, 9, 1030, 4334, 0, 9, 1546, 5, 1030, 4338, 0, 4, 103, 6, 9, 4342, 7, 102, 4344, 0, 7, 1534, 9, 102, 4348, 0, 6, 1031, 5, 8, 4352, 9, 1030, 4354, 4, 9, 4352, 5, 1030, 4358, 0, 9, 1534, 7, 102, 4362, 7, 8, 4342, 9, 102, 4366, 6, 8, 927, 1, 4, 4370, 0, 927, 4372, 2, 8, 1950, 1, 40, 4376, 0, 41, 4376, 4377, 4378, 4380, 0, 338, 2040, 0, 338, 2041, 2040, 4385, 4386, 1, 40, 2132, 0, 40, 2132, 0, 4390, 4393, 1, 40, 1424, 0, 40, 1424, 0, 4396, 4399, 0, 41, 2132, 40, 4393, 4402, 0, 41, 1424, 40, 4399, 4406, 1, 338, 2040, 338, 2040, 4411, 0, 4410, 4413, 2133, 4390, 4402, 1425, 4396, 4406, 0, 41, 4390, 2133, 4390, 4420, 1, 8, 282, 2, 4, 4425, 2, 4, 4424, 7, 282, 4428, 4424, 4426, 4431, 1, 628, 3008, 5, 1808, 4434, 6, 8, 629, 3, 4, 4438, 2, 4, 4439, 1, 628, 4442, 5, 4440, 4444, 3, 4, 4424, 6, 283, 4426, 5, 4448, 4450, 2, 5, 4424, 3, 4450, 4454, 4, 4431, 4454, 2, 5, 656, 7, 282, 3708, 4, 4460, 4463, 2, 4431, 4448, 2, 5, 4438, 3, 4444, 4468, 4439, 4440, 4468, 1, 628, 4472, 0, 3, 4460, 4, 7, 4460, 9, 4476, 4478, 1, 2, 3448, 4, 7, 4482, 9, 3448, 4484, 0, 5, 1454, 9, 1336, 4488, 0, 5, 1808, 2, 7, 1808, 9, 4492, 4494, 9, 1336, 3448, 2, 926, 2389, 2, 6, 266, 2, 926, 4503, 2, 926, 3141, 2, 926, 1117, 2, 926, 3841, 905, 926, 3996, 4, 6, 3997, 905, 3996, 4514, 1, 926, 1916, 2, 6, 267, 4, 7, 4520, 8, 4520, 4522, 4, 7, 3850, 8, 3850, 4526, 0, 93, 358, 0, 41, 634, 1, 4, 376, 8, 2546, 4534, 8, 10, 2546, 8, 10, 2516, 8, 10, 1854, 8, 10, 2552, 5, 6, 464, 8, 10, 4546, 8, 10, 406, 0, 6, 93, 8, 10, 4552, 0, 6, 445, 8, 10, 4556, 3, 6, 454, 8, 10, 4560, 0, 5, 2162, 8, 359, 4564, 7, 2162, 4566, 7, 312, 660, 5, 6, 4570, 9, 4570, 4572, 3, 38, 972, 9, 2990, 4576, 3, 58, 132, 9, 1372, 4580, 8, 38, 147, 9, 38, 146, 5, 4584, 4586, 8, 58, 359, 9, 58, 358, 7, 4590, 4592, 2, 4, 59, 8, 58, 4597, 9, 58, 4596, 7, 4598, 4600, 8, 38, 2421, 9, 38, 2420, 5, 4604, 4606, 48, 629, 2156, 376, 629, 1562, 376, 629, 1150, 232, 267, 1042, 267, 282, 1372, 2, 7, 660, 267, 282, 4620, 232, 267, 2038, 267, 282, 408, 267, 282, 1054, 232, 267, 2162, 1, 4, 216, 6, 8, 4632, 4, 8, 3850, 4, 8, 2420, 4, 8, 4520, 6, 8, 4596, 8, 926, 3274, 5, 6, 10, 4, 8, 4646, 6, 8, 884, 1, 216, 926, 8, 10, 926, 4, 8, 93, 0, 2, 4657, 2133, 4656, 4658, 8, 927, 2722, 3, 634, 4662, 4, 93, 4662, 0, 2, 2133, 8, 2133, 4668, 4, 93, 4670, 0, 4, 665, 8, 665, 4674, 5, 634, 4676, 0, 665, 1254, 5, 634, 4680, 0, 8, 635, 3, 4, 4684, 634, 927, 4686, 0, 927, 1254, 3, 634, 4690, 4, 665, 4684, 5, 634, 4694, 5, 972, 3148, 9, 660, 4698, 0, 9, 554, 0, 500, 4703, 1, 58, 2730, 58, 1030, 2581, 6, 38, 4703, 0, 5, 500, 500, 1030, 4712, 0, 7, 500, 102, 500, 4716, 1, 6, 38, 38, 102, 4720, 5, 6, 356, 1, 38, 4724, 8, 500, 559, 38, 303, 500, 6, 8, 103, 4, 102, 4733, 4, 102, 927, 6, 927, 1030, 9, 102, 1030, 8, 904, 927, 5, 904, 1030, 6, 1030, 4079, 0, 3, 4746, 926, 4746, 4748, 3, 2722, 3274, 6, 1030, 4753, 2723, 3402, 4738, 1, 2, 4738, 0, 3, 4758, 926, 4758, 4760, 3, 3402, 4758, 0, 3, 4738, 1, 3402, 4766, 6, 1030, 3275, 1, 3402, 4770, 3, 3402, 4746, 2, 346, 635, 0, 4, 2041, 60, 2040, 4779, 0, 2, 1997, 146, 1996, 4783, 5, 92, 346, 8, 146, 3934, 2, 5, 346, 8, 346, 4790, 49, 60, 420, 49, 60, 2040, 92, 313, 602, 5, 6, 92, 92, 313, 4800, 4, 8, 1346, 242, 904, 4805, 0, 1347, 4806, 0, 3, 2622, 1188, 1731, 4810, 0, 1189, 3130, 1188, 1731, 4814, 1, 242, 500, 6, 8, 500, 0, 243, 4820, 4818, 4821, 4822, 0, 4, 2039, 2, 6, 4826, 2038, 4122, 4829, 51, 904, 972, 5, 302, 4832, 8, 50, 500, 0, 4818, 4837, 5, 310, 746, 7, 2162, 4840, 1, 4, 1348, 9, 1348, 4844, 6, 242, 4847, 0, 4844, 4849, 0, 3, 904, 4, 6, 972, 0, 8, 4854, 972, 4852, 4857, 133, 146, 232, 282, 358, 635, 60, 232, 661, 41, 92, 282, 1, 2, 346, 312, 348, 4869, 0, 7, 1574, 1, 6, 4872, 1575, 4872, 4874, 0, 4, 973, 49, 974, 4878, 0, 5, 2102, 1, 4, 4882, 2103, 4882, 4884, 354, 1112, 1835, 0, 2, 1602, 0, 8, 1602, 354, 4890, 4893, 354, 4079, 4312, 0, 3, 1602, 0, 9, 1602, 354, 4899, 4900, 0, 9, 1996, 1, 8, 4904, 1997, 4904, 4906, 0, 147, 2156, 1, 146, 4910, 2157, 4910, 4912, 4, 242, 1031, 0, 5, 4916, 1030, 4916, 4918, 8, 927, 3274, 9, 926, 3274, 0, 4922, 4924, 0, 2, 559, 1, 576, 4928, 0, 2, 561, 1, 1726, 4932, 9, 576, 1830, 0, 927, 3208, 1, 8, 4938, 926, 4938, 4940, 1, 8, 2722, 0, 9, 4944, 926, 4944, 4946, 0, 9, 4922, 926, 4922, 4950, 2, 8, 4313, 0, 9, 4954, 926, 4954, 4956, 0, 358, 656, 8, 3008, 4961, 0, 358, 635, 8, 640, 4965, 6, 10, 635, 8, 644, 4969, 283, 634, 1090, 14, 283, 634, 6, 10, 232, 8, 290, 4977, 2, 8, 2646, 41, 282, 4980, 282, 635, 2648, 6, 8, 2278, 6, 8, 2279, 2278, 4987, 4988, 6, 313, 1030, 9, 1670, 4992, 604, 927, 1622, 2, 4, 354, 2, 7, 354, 904, 4999, 5000, 904, 1340, 1505, 9, 312, 346, 8, 313, 346, 347, 5006, 5008, 8, 313, 5006, 347, 5006, 5012, 4, 7, 3216, 9, 3636, 5016, 6, 9, 2278, 7, 8, 5020, 2279, 5020, 5022, 7, 312, 1622, 9, 1624, 5026, 58, 283, 1498, 2, 4, 103, 0, 7, 5032, 1, 6, 5032, 102, 5034, 5036, 1, 6, 5034, 102, 5034, 5040, 2, 6, 1031, 0, 5, 5044, 1, 4, 5044, 1030, 5046, 5048, 1, 4, 5046, 1030, 5046, 5052, 5, 6, 640, 1, 3658, 5056, 356, 555, 644, 555, 628, 1498, 1, 4, 2192, 58, 283, 5064, 0, 5, 4118, 283, 500, 5068, 0, 103, 972, 1, 6, 5072, 102, 5072, 5074, 7, 312, 356, 1, 4724, 5078, 0, 2, 657, 303, 500, 5082, 1, 102, 972, 6, 5072, 5086, 9, 356, 972, 1, 4724, 5090, 9, 356, 624, 1, 4724, 5094, 0, 6, 5086, 103, 5086, 5098, 9, 58, 1188, 1, 1726, 5102, 1, 4, 972, 4, 628, 972, 0, 5106, 5109, 0, 5, 972, 629, 4878, 5112, 4, 629, 972, 5, 4878, 5116, 4, 628, 4879, 972, 4878, 5121, 6, 8, 5107, 4, 972, 5124, 0, 5106, 5127, 5, 972, 4878, 629, 4878, 5130, 5, 628, 972, 629, 4878, 5134, 0, 4175, 5116, 6, 8, 4174, 4, 972, 5141, 0, 4175, 5142, 4, 58, 312, 2, 1166, 5147, 3, 216, 228, 1, 2, 5150, 229, 5150, 5152, 2, 3117, 5150, 8, 501, 1126, 1124, 1126, 5158, 1124, 1126, 3106, 8, 500, 1125, 8, 1126, 5165, 9, 500, 1124, 1124, 1126, 5169, 503, 1124, 1126, 0, 2, 735, 1, 1132, 5174, 0, 2, 2573, 1, 1166, 5178, 0, 3, 664, 0, 4, 664, 2470, 5182, 5185, 1, 2, 382, 0, 4, 383, 1975, 5188, 5190, 0, 3, 382, 0, 4, 382, 3508, 5194, 5197, 4, 376, 382, 4, 376, 383, 382, 5201, 5202, 2, 48, 383, 382, 1993, 5206, 1, 2, 628, 2467, 4674, 5210, 6, 8, 5210, 0, 4, 5215, 2467, 5210, 5216, 6, 8, 2466, 0, 4, 5221, 2467, 5210, 5222, 4, 58, 303, 6, 38, 303, 0, 303, 500, 8, 311, 500, 8, 58, 219, 6, 356, 555, 6, 303, 356, 1, 58, 356, 5, 356, 500, 4, 9, 588, 0, 7, 5244, 582, 588, 5246, 6, 132, 134, 1, 4, 5250, 132, 1484, 5252, 5, 628, 634, 135, 1498, 5256, 4, 135, 628, 5, 134, 628, 0, 2, 5262, 1, 5260, 5264, 7, 500, 580, 267, 1730, 5268, 2, 9, 1730, 7, 500, 5272, 267, 1730, 5274, 2, 9, 576, 1, 38, 5278, 267, 576, 5280, 0, 2, 310, 572, 576, 5285, 6, 9, 132, 2, 4, 5289, 0, 3, 5290, 1, 4, 5288, 132, 5292, 5294, 0, 6, 581, 4, 267, 5298, 9, 266, 5298, 580, 5300, 5303, 4, 7, 200, 1, 2, 5306, 8, 40, 5309, 6, 5306, 5311, 512, 656, 927, 8, 40, 2735, 4, 236, 5317, 8, 40, 1553, 0, 1546, 5321, 4, 243, 1188, 7, 8, 5324, 6, 8, 5324, 6, 5326, 5329, 0, 2, 905, 6, 660, 5332, 0, 2620, 5335, 8, 5324, 5327, 6, 5326, 5339, 6, 8, 5325, 5324, 5329, 5342, 4, 216, 746, 232, 904, 5347, 4, 8, 746, 228, 232, 5351, 0, 5, 3854, 0, 6, 3854, 904, 5354, 5357, 0, 5, 660, 904, 4085, 5360, 0, 4, 3854, 904, 3856, 5365, 5, 6, 660, 6, 634, 5361, 7, 5368, 5370, 7, 8, 92, 6, 9, 92, 1, 634, 5376, 93, 5374, 5378, 6, 9, 5374, 1, 634, 5382, 93, 5374, 5384, 8, 93, 644, 7, 5376, 5388, 201, 408, 3174, 9, 40, 520, 7, 3174, 5394, 3, 8, 634, 4, 7, 5398, 6, 5399, 5400, 1, 634, 5402, 5, 5400, 5404, 5, 8, 634, 2, 7, 5408, 6, 5409, 5410, 1, 634, 5412, 3, 5410, 5414, 9, 92, 644, 7, 1578, 5418, 0, 1352, 1915, 0, 2, 311, 1, 1730, 5424, 1, 1726, 5424, 2, 9, 2304, 1, 4, 5430, 5, 2304, 5432, 2, 9, 1726, 1, 4, 5436, 5, 1726, 5438, 1, 356, 5430, 5, 2304, 5442, 5, 356, 5430, 1, 2304, 5446, 2, 9, 356, 5, 628, 5450, 1, 356, 5452, 1, 356, 5256, 2, 4, 219, 5, 2304, 5458, 356, 500, 4151, 4, 8, 5082, 5, 500, 5464, 7, 8, 242, 0, 4, 5468, 5, 500, 5470, 7, 8, 490, 0, 4, 5474, 5, 500, 5476, 2, 8, 51, 0, 4, 5480, 5, 500, 5482, 4, 61, 1726, 1, 58, 5486, 4, 61, 1834, 1, 58, 5490, 4, 61, 64, 1, 58, 5494, 5, 8, 500, 1, 2, 5498, 7, 5498, 5500, 0, 500, 5502, 6, 40, 357, 356, 555, 5506, 8, 10, 41, 8, 10, 40, 40, 5510, 5513, 358, 3719, 3726, 9, 266, 358, 267, 3726, 5518, 8, 11, 40, 9, 10, 40, 41, 5522, 5524, 9, 10, 5522, 41, 5522, 5528, 8, 267, 358, 359, 5518, 5532, 9, 266, 5532, 359, 5532, 5536, 8, 38, 1189, 9, 38, 1188, 39, 5540, 5542, 9, 1188, 5540, 39, 5540, 5546, 0, 2467, 3708, 0, 665, 926, 0, 664, 926, 664, 5552, 5555, 0, 664, 927, 1, 5552, 5558, 0, 359, 634, 1, 4964, 5562, 0, 18, 383, 1, 358, 634, 359, 4964, 5568, 635, 5562, 5568, 1, 358, 5562, 635, 5562, 5574, 0, 9, 1348, 1526, 3699, 5578, 1, 8, 312, 4, 6, 5583, 3, 5582, 5584, 7, 312, 5586, 5, 5584, 5588, 5, 312, 5586, 7, 5584, 5592, 3, 242, 1342, 5, 312, 5596, 7, 1342, 5598, 5, 312, 1454, 243, 1336, 5602, 7, 312, 5596, 5, 1342, 5606, 7, 312, 1526, 243, 1348, 5610, 5, 6, 5582, 3, 4, 5582, 7, 312, 5616, 5583, 5614, 5618, 2, 6, 3078, 5, 6, 3078, 522, 5623, 5624, 0, 9, 3078, 5623, 5624, 5628, 2, 4, 19, 1, 14, 5632, 6, 8, 3709, 1, 3008, 5636, 1, 14, 3008, 2, 8, 2853, 6, 216, 2853, 4, 5642, 5644, 9, 60, 216, 4, 6, 5649, 216, 1113, 5650, 4, 7, 930, 102, 932, 5654, 4, 7, 48, 102, 932, 5658, 932, 1030, 1854, 4, 8, 1854, 1, 2, 5664, 1030, 1854, 5666, 4, 8, 2546, 1, 2, 5670, 1030, 2546, 5672, 8, 48, 1854, 1, 2, 5676, 1030, 1854, 5678, 0, 3, 482, 4, 7, 5682, 1, 376, 5684, 8, 482, 5686, 3, 216, 3274, 4, 6, 3274, 927, 5690, 5692, 376, 629, 3070, 376, 629, 4078, 2, 267, 926, 0, 383, 5700, 5, 10, 94, 0, 15, 5704, 2, 629, 926, 0, 2467, 5708, 4, 95, 628, 0, 2470, 5713, 8, 629, 1258, 282, 1259, 5716, 1, 6,
+                                                       2740, 9, 2740, 5720, 9, 232, 5720, 1, 6, 3536, 9, 232, 5726, 8, 282, 1259, 0, 7, 5730, 1, 282, 5732, 0, 40, 232, 8, 233, 5736, 6, 232, 5739, 0, 232, 634, 8, 233, 5742, 6, 232, 5745, 0, 232, 290, 8, 233, 5748, 6, 232, 5751, 5, 60, 232, 1, 6, 5754, 9, 232, 5756, 1, 232, 282, 2, 5, 282, 3, 5760, 5762, 2, 8, 395, 4, 9, 394, 11, 5766, 5768, 3, 8, 746, 266, 5351, 5772, 3, 8, 58, 266, 1727, 5776, 3, 8, 2516, 4, 8, 2516, 266, 5780, 5783, 2, 8, 746, 266, 2558, 5787, 266, 1479, 2168, 5, 8, 2516, 266, 2519, 5792, 2, 8, 747, 11, 1298, 5796, 11, 1800, 2572, 2, 9, 746, 4, 8, 747, 11, 5802, 5804, 628, 3071, 3088, 102, 3000, 3088, 4, 94, 628, 628, 3088, 5813, 0, 94, 102, 4, 3071, 5816, 6, 8, 3448, 4, 3071, 5820, 1, 3000, 5820, 5, 94, 628, 1, 3000, 5826, 1, 6, 640, 8, 640, 5830, 8, 640, 644, 0, 7, 644, 8, 644, 5836, 628, 634, 959, 1, 628, 640, 283, 628, 634, 283, 634, 636, 1, 6, 590, 1, 40, 160, 1, 266, 614, 1, 6, 178, 1, 8, 482, 1, 8, 474, 4, 8, 61, 1, 6, 5860, 1, 6, 154, 1, 8, 492, 1, 266, 656, 1, 2, 94, 4, 664, 5871, 1, 3448, 5872, 0, 4, 4733, 3, 102, 5876, 1, 2, 5878, 4732, 5878, 5880, 2, 94, 3288, 664, 3088, 5885, 0, 2, 4733, 2, 103, 5876, 102, 5889, 5890, 4, 927, 2984, 102, 2723, 5894, 4, 628, 3742, 628, 1808, 5899, 0, 3, 3708, 4, 656, 3709, 628, 5903, 5904, 6, 8, 657, 2, 658, 5908, 659, 1808, 5910, 664, 3088, 3275, 664, 3088, 3709, 926, 2863, 3470, 1, 8, 5332, 9, 926, 5920, 7, 926, 3274, 5, 8, 5924, 9, 926, 5926, 5, 926, 3274, 7, 8, 5930, 9, 926, 5932, 2, 905, 926, 1, 8, 5936, 9, 926, 5938, 5, 6, 3208, 0, 7, 5942, 1, 926, 5944, 2, 7, 926, 4, 9, 5948, 0, 5, 5950, 1, 926, 5952, 6, 9, 3470, 0, 7, 5956, 1, 926, 5958, 9, 926, 3470, 0, 7, 5962, 1, 926, 5964, 9, 926, 5948, 0, 5, 5968, 1, 926, 5970, 0, 10, 267, 6, 8, 5975, 10, 441, 5976, 7, 10, 828, 8, 826, 5980, 9, 828, 5982, 7, 10, 836, 8, 834, 5986, 9, 836, 5988, 6, 191, 358, 1, 8, 5992, 787, 5992, 5994, 4, 146, 191, 1, 8, 5998, 807, 5998, 6000, 0, 201, 806, 1, 8, 6004, 807, 6004, 6006, 0, 201, 786, 1, 8, 6010, 787, 6010, 6012, 0, 8, 2083, 9, 1112, 2082, 1, 6016, 6018, 0, 8, 787, 788, 2162, 6022, 3, 10, 376, 6, 8, 6027, 2, 48, 267, 6, 8, 6031, 4, 267, 376, 6, 8, 6035, 1, 630, 5332, 4, 8, 5332, 3, 6, 6040, 1, 5332, 6042, 630, 905, 3996, 8, 358, 376, 3, 490, 6048, 3, 6, 1916, 8, 500, 6052, 1, 1916, 6054, 3, 6, 1730, 2, 501, 1730, 1, 6058, 6060, 6, 624, 3841, 2, 356, 905, 6, 3841, 6066, 51, 3818, 3850, 51, 3944, 4646, 2, 4, 1173, 6, 8, 6074, 0, 1172, 6077, 2, 4, 614, 0, 7, 6080, 9, 614, 6082, 6, 383, 2842, 0, 383, 1172, 8, 266, 2843, 6, 2842, 6091, 92, 383, 4552, 9, 614, 2842, 267, 584, 2842, 6, 9, 2842, 267, 2842, 6100, 2, 310, 927, 9, 354, 6104, 2, 7, 1540, 9, 5360, 6108, 9, 1544, 1638, 1, 4, 1544, 2, 5, 6114, 9, 1544, 6116, 2, 7, 4158, 9, 1158, 6120, 0, 7, 1514, 9, 1638, 6124, 2, 8, 49, 0, 3, 6128, 7, 48, 6130, 9, 6128, 6132, 2, 357, 1030, 3, 312, 6136, 0, 93, 1030, 1, 312, 6140, 0, 217, 6136, 1, 6, 2842, 2, 4, 6147, 8, 2843, 6148, 0, 7, 3708, 8, 3008, 6153, 8, 2843, 6074, 0, 7, 1172, 8, 6074, 6159, 8, 2843, 3008, 5, 6, 1644, 4, 383, 6164, 1, 2, 582, 0, 383, 6168, 0, 383, 432, 2, 4, 394, 6, 8, 6174, 10, 394, 6177, 376, 378, 389, 0, 2, 583, 383, 582, 6182, 60, 383, 1876, 0, 2, 2333, 6, 8, 6188, 4, 2332, 6191, 4, 1964, 1969, 383, 500, 1644, 0, 3, 92, 4, 6, 6199, 8, 92, 6201, 8, 93, 6200, 9, 6202, 6204, 2, 491, 1312, 3, 1568, 6208, 6, 133, 354, 0, 132, 6213, 3, 1568, 6214, 0, 132, 747, 3, 1568, 6218, 4, 8, 354, 0, 7, 6222, 3, 4, 6224, 5, 6, 6222, 355, 6226, 6228, 0, 7, 660, 3, 4, 6232, 355, 5368, 6234, 3, 4, 1160, 355, 1574, 6238, 1, 92, 628, 0, 3, 6242, 4, 6, 6245, 8, 6243, 6246, 2, 8, 3935, 3, 1568, 6250, 3, 4, 490, 2, 8, 6255, 3, 1568, 6256, 8, 282, 358, 2, 4, 6261, 8, 6261, 6262, 6, 9, 432, 61, 660, 6266, 4, 146, 232, 4, 132, 6271, 2, 8, 2743, 3, 290, 6274, 2, 6, 232, 4, 8, 6279, 5, 290, 6280, 233, 660, 6274, 233, 2356, 6274, 1, 6, 2038, 61, 660, 6288, 61, 644, 660, 61, 644, 5398, 41, 282, 358, 7, 1886, 5762, 7, 60, 5762, 2, 5, 1886, 7, 1886, 6302, 5, 358, 1886, 3, 358, 5762, 282, 358, 1259, 2, 41, 1886, 4, 41, 5762, 8, 50, 358, 8, 40, 6317, 2, 51, 132, 3, 40, 6320, 4, 51, 660, 5, 40, 6324, 4, 283, 660, 5, 40, 6328, 2, 102, 283, 3, 40, 6332, 4, 94, 283, 5, 40, 6336, 2, 5368, 6324, 2, 5368, 6328, 3, 4, 2954, 2, 5, 2954, 6, 6344, 6346, 2, 5, 6344, 6, 6344, 6350, 2, 7, 218, 233, 660, 6354, 3, 6, 218, 283, 634, 6358, 0, 383, 5852, 0, 267, 5848, 9, 590, 6364, 0, 7, 5852, 9, 614, 6368, 8, 266, 383, 0, 7, 6372, 6, 383, 6374, 0, 6, 6373, 383, 6372, 6378, 1, 8, 584, 0, 267, 6382, 7, 584, 6384, 0, 9, 5852, 7, 614, 6388, 0, 6, 591, 383, 590, 6392, 0, 7, 6382, 267, 584, 6396, 0, 9, 5848, 267, 590, 6400, 0, 5, 664, 4, 217, 6404, 358, 6404, 6406, 3, 312, 500, 2, 7, 6410, 218, 6410, 6412, 9, 354, 500, 2, 7, 6416, 218, 6416, 6418, 5, 302, 664, 4, 7, 6422, 217, 6422, 6424, 7, 218, 228, 2, 9, 6428, 228, 6428, 6430, 1, 38, 664, 0, 9, 6434, 41, 6434, 6436, 7, 218, 1124, 2, 5168, 6440, 3, 4, 218, 7, 218, 6444, 9, 500, 6444, 2, 6446, 6448, 7, 60, 218, 2, 9, 6452, 500, 6452, 6454, 2, 9, 6446, 500, 6446, 6458, 146, 629, 6198, 146, 629, 3526, 1, 2, 356, 41, 282, 6466, 5, 8, 216, 146, 232, 6471, 146, 232, 3383, 2, 8, 11, 146, 232, 6477, 0, 8, 49, 146, 232, 6481, 2, 4, 615, 7, 266, 614, 8, 6484, 6487, 6, 8, 6484, 267, 6484, 6490, 267, 382, 3008, 267, 3008, 3012, 6, 5518, 5532, 6, 8, 5518, 267, 5518, 6500, 6, 585, 5518, 267, 382, 5518, 8, 591, 6484, 2, 6, 219, 3, 8, 6510, 501, 6510, 6512, 3, 3106, 6510, 2, 218, 3107, 6, 3106, 6519, 8, 505, 6510, 501, 3130, 6510, 3, 6, 3106, 219, 3106, 6526, 219, 3106, 6358, 0, 5, 504, 2, 6, 6533, 8, 505, 6534, 6, 221, 3106, 1, 4, 220, 2, 8, 6541, 6, 221, 6542, 0, 9, 3698, 3, 242, 6546, 3699, 6546, 6548, 9, 660, 1188, 310, 5368, 6552, 9, 356, 656, 40, 660, 6557, 4, 8, 2853, 359, 5518, 6560, 9, 266, 6560, 359, 6560, 6564, 6, 635, 3288, 8, 665, 3288, 6, 6569, 6570, 1, 6, 302, 660, 6354, 6574, 6, 266, 310, 93, 706, 6578, 310, 640, 3174, 310, 640, 1578, 6, 555, 634, 147, 2924, 6586, 9, 2102, 2156, 0, 41, 6590, 41, 134, 6140, 0, 5, 26, 0, 8, 11, 3, 26, 6598, 7, 6596, 6600, 0, 3, 26, 5, 26, 6598, 7, 6604, 6606, 0, 3, 2162, 5, 1090, 2162, 7, 6610, 6612, 3, 1090, 2162, 7, 4564, 6616, 19, 132, 6604, 8, 10, 19, 0, 3, 6622, 19, 146, 6624, 2, 4, 94, 10, 94, 665, 0, 6629, 6630, 10, 656, 665, 0, 3709, 6634, 0, 2, 95, 94, 3005, 6638, 7, 8, 2984, 8, 2984, 6643, 6, 6642, 6645, 2, 9, 3742, 5, 656, 3742, 7, 6648, 6650, 0, 9, 5870, 5, 94, 5870, 7, 6654, 6656, 0, 2, 615, 383, 614, 6660, 267, 590, 5802, 7, 8, 5802, 267, 5802, 6666, 6, 9, 2984, 2985, 6642, 6670, 7, 8, 6670, 2985, 6670, 6674, 7, 8, 1188, 267, 584, 6678, 41, 3930, 3944, 0, 3, 520, 5, 358, 6684, 8, 520, 6686, 41, 196, 432, 0, 3, 1146, 7, 146, 6692, 8, 1146, 6694, 0, 7, 1146, 3, 146, 6698, 8, 1146, 6700, 0, 7, 432, 5, 60, 6704, 8, 432, 6706, 0, 5, 432, 7, 60, 6710, 8, 432, 6712, 0, 5, 520, 3, 358, 6716, 8, 520, 6718, 0, 203, 432, 60, 203, 1876, 0, 3, 358, 656, 3167, 6726, 26, 157, 3944, 0, 10, 283, 2, 6, 661, 3, 6732, 6734, 4, 282, 2869, 0, 2870, 6739, 4, 9, 94, 1, 2, 6742, 4, 282, 6743, 0, 6744, 6747, 1, 2, 2898, 4, 282, 2899, 0, 6750, 6753, 0, 3, 2898, 2, 6753, 6756, 0, 3, 6742, 2, 6747, 6760, 0, 2, 12, 5, 6, 6764, 12, 133, 6766, 7, 8, 2870, 5, 2868, 6770, 0, 2870, 6772, 7, 8, 6744, 5, 6742, 6776, 0, 6744, 6778, 8, 926, 2722, 926, 4662, 6783, 9, 926, 2722, 8, 6783, 6786, 2, 9, 4078, 2, 8, 4078, 8, 6790, 6793, 2, 8, 4079, 3, 6790, 6796, 3, 8, 6790, 4079, 6790, 6800, 4078, 6793, 6796, 0, 9, 3274, 1, 8, 6806, 3275, 6806, 6808, 2723, 4662, 6786, 9, 926, 4662, 2723, 4662, 6814, 2, 218, 283, 6, 218, 661, 6, 6818, 6821, 0, 2, 4801, 1, 6, 6824, 92, 4800, 6825, 8, 6826, 6829, 0, 5, 5480, 3, 6, 6832, 634, 5480, 6834, 2, 8, 283, 0, 5, 6838, 3, 6, 6840, 634, 6838, 6842, 0, 5, 5474, 3, 6, 6846, 634, 5474, 6848, 0, 5, 2954, 3, 6, 6852, 634, 2954, 6854, 4, 9, 358, 0, 2, 6858, 8, 675, 6858, 359, 6860, 6862, 6, 8, 6829, 1, 6824, 6866, 5, 8, 282, 1, 6, 6870, 0, 3, 6872, 2, 6, 6871, 283, 6874, 6876, 0, 7, 6510, 6, 218, 660, 1, 6880, 6882, 242, 302, 2041, 2, 8, 4675, 2, 9, 4674, 665, 6888, 6890, 0, 8, 2471, 0, 9, 2470, 629, 6894, 6896, 9, 664, 4674, 665, 6888, 6900, 9, 628, 2470, 629, 6894, 6904, 6, 8, 1188, 132, 302, 6909, 132, 302, 2629, 132, 302, 5787, 8, 1770, 3955, 6, 48, 94, 94, 1770, 6919, 2, 232, 500, 8, 290, 6923, 4, 93, 1188, 8, 2843, 6926, 2, 500, 635, 8, 644, 6931, 233, 660, 3910, 233, 660, 3106, 4, 233, 1188, 8, 235, 6938, 4, 6, 219, 660, 6510, 6943, 223, 660, 6354, 132, 226, 1677, 4, 6, 218, 132, 221, 6950, 48, 146, 629, 10, 41, 282, 60, 376, 629, 267, 282, 358, 6, 242, 635, 9, 232, 6962, 9, 146, 1188, 232, 1189, 6966, 282, 291, 2734, 8, 41, 746, 282, 747, 6972, 2, 7, 656, 8, 40, 6977, 0, 656, 6979, 8, 146, 1189, 7, 282, 6982, 6, 216, 661, 217, 232, 6986, 9, 232, 6982, 8, 1189, 5762, 7, 282, 6992, 0, 7, 6982, 9, 6982, 6996, 1, 6, 6926, 8, 6926, 7000, 0, 3, 634, 7, 634, 7004, 6, 283, 7006, 1, 628, 7006, 6, 283, 634, 283, 7004, 7012, 2, 7, 282, 0, 6, 7017, 4, 9, 7016, 283, 7018, 7020, 0, 51, 634, 1, 628, 7024, 1, 628, 6926, 8, 644, 7024, 2, 7, 628, 233, 660, 7032, 0, 3, 7012, 283, 7012, 7036, 4, 41, 232, 1, 2, 7040, 8, 40, 7043, 6, 7040, 7045, 7, 266, 310, 6, 266, 311, 0, 9, 7050, 267, 7048, 7052, 7, 242, 634, 242, 282, 635, 243, 7056, 7058, 7, 60, 6870, 282, 747, 7062, 7, 1886, 6870, 282, 747, 7066, 7, 1886, 2558, 282, 747, 7070, 7, 60, 2558, 282, 747, 7074, 267, 2652, 2654, 1, 6, 7078, 7, 2654, 7080, 5, 266, 282, 6, 267, 310, 7, 7084, 7086, 1, 8, 48, 0, 6, 7091, 0, 475, 7090, 1, 7092, 7094, 6, 8, 242, 6, 242, 634, 8, 7099, 7100, 4, 1188, 3887, 6, 2954, 7104, 6, 8, 146, 0, 2, 7109, 0, 9, 7108, 6, 7110, 7113, 0, 9, 4800, 6, 6824, 7117, 3, 634, 1188, 6, 2954, 7120, 6, 634, 7005, 8, 7006, 7124, 6, 9, 7004, 6, 7006, 7129, 6, 2954, 6926, 6, 5480, 7024, 9, 1188, 3874, 6, 2954, 7136, 6, 242, 266, 242, 282, 7141, 9, 656, 2760, 7, 376, 3742, 9, 656, 7146, 1, 94, 146, 0, 7, 7150, 9, 7150, 7152, 0, 41, 972, 9, 656, 7156, 0, 41, 6976, 9, 656, 7160, 0, 94, 147, 146, 629, 7164, 6, 242, 267,
+                                                       0, 7, 7168, 9, 7168, 7170, 0, 95, 146, 94, 629, 7174, 6, 8, 7151, 0, 7150, 7179, 0, 41, 656, 7, 40, 656, 9, 7182, 7184, 0, 8, 475, 9, 5858, 7188, 0, 9, 424, 0, 8, 425, 1, 7192, 7194, 1, 40, 232, 9, 298, 7198, 1, 6, 200, 7, 40, 200, 9, 7202, 7204, 268, 614, 629, 0, 9, 2466, 6, 8, 2467, 629, 7210, 7212, 0, 9, 492, 493, 5866, 7216, 1, 8, 7216, 493, 7216, 7220, 0, 8, 267, 584, 629, 7224, 6, 675, 3096, 8, 406, 1091, 1, 406, 3096, 8, 1172, 4552, 8, 406, 520, 6, 523, 3096, 358, 406, 523, 92, 253, 4552, 1, 2546, 3818, 359, 520, 3096, 0, 656, 5909, 0, 629, 656, 8, 282, 629, 6, 232, 629, 9, 232, 656, 0, 2, 4732, 4, 102, 7258, 4732, 5888, 7261, 2, 926, 3275, 6, 1030, 7264, 0, 3274, 7267, 6, 1030, 3402, 0, 3274, 7271, 4, 102, 3402, 0, 3274, 7275, 8, 40, 3402, 0, 3274, 7279, 8, 554, 3402, 0, 3274, 7283, 2, 4078, 7283, 2, 4078, 7279, 2, 4078, 7271, 2, 4078, 7275, 6, 721, 1484, 38, 664, 1189, 6, 572, 608, 50, 135, 500, 491, 500, 664, 40, 94, 1603, 61, 94, 1568, 4, 6, 1835, 61, 94, 7308, 0, 8, 146, 2, 6, 7313, 102, 147, 7314, 359, 972, 1568, 2, 6, 200, 40, 102, 7321, 2, 5, 1602, 2, 8, 1603, 6, 7325, 7326, 4, 6, 200, 40, 94, 7331, 3, 4, 972, 4, 354, 973, 6, 7334, 7337, 8, 92, 644, 92, 5388, 7341, 2, 132, 645, 2, 133, 644, 3, 7344, 7346, 5, 644, 660, 4, 645, 660, 661, 7350, 7352, 3, 132, 644, 133, 7344, 7356, 2, 645, 7356, 133, 7356, 7360, 4, 645, 7350, 661, 7350, 7364, 8, 92, 645, 9, 5388, 7368, 4, 644, 661, 5, 7352, 7372, 2, 9, 50, 5, 6, 7376, 8, 3309, 7378, 51, 2454, 7378, 4, 8, 7378, 51, 7378, 7384, 4, 7, 7376, 6, 2429, 7388, 4, 2429, 7378, 2, 9, 2454, 5, 6, 7394, 51, 2454, 7396, 4, 6, 7377, 2429, 7376, 7400, 6, 132, 660, 5, 40, 660, 3, 4, 132, 6, 132, 7408, 8, 40, 359, 8, 40, 93, 2, 359, 660, 6, 61, 660, 8, 359, 634, 5, 8, 290, 290, 2356, 7422, 8, 232, 290, 3, 4, 7426, 5, 290, 7428, 5, 232, 290, 2, 8, 7432, 3, 290, 7434, 2, 5, 7426, 3, 290, 7438, 290, 2360, 7422, 4, 8, 2360, 5, 290, 7444, 4, 232, 660, 2, 5, 7448, 233, 7448, 7450, 2, 132, 232, 3, 4, 7454, 233, 7454, 7456, 4, 232, 661, 2, 7448, 7461, 2, 133, 232, 4, 7454, 7465 } };
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/mux_resynthesis.hpp b/include/mockturtle/algorithms/node_resynthesis/mux_resynthesis.hpp
new file mode 100644
index 0000000..96f0835
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/mux_resynthesis.hpp
@@ -0,0 +1,114 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file null.hpp
+  \brief mux resynthesis for cut rewriting
+
+  \author Jasper Zwartjes
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+
+
+#include <cstdint>
+#include <iostream>
+#include <kitty/dynamic_truth_table.hpp>
+#include <mockturtle/algorithms/cleanup.hpp>
+#include <mockturtle/algorithms/resyn_engines/mux_resyn.hpp>
+#include <mockturtle/networks/muxig.hpp>
+#include <mockturtle/utils/debugging_utils.hpp>
+#include <mockturtle/utils/null_utils.hpp>
+
+
+namespace mockturtle
+{
+
+template<class Ntk>
+class mux_resynthesis
+{
+public:
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+
+    uint32_t NUM_INPUTS = function.num_vars();
+    std::cout << "\nMux resynthesis called with: " << kitty::to_binary(function)
+              << ", Num_vars: " << NUM_INPUTS << ", Network:\n";
+    //mockturtle::print(ntk);
+
+
+    
+    
+
+    std::vector<kitty::dynamic_truth_table> tts(NUM_INPUTS);
+    std::vector<uint32_t> divs;
+
+    for ( auto i = 0u; i < NUM_INPUTS; ++i )
+    {
+        tts[i] = kitty::dynamic_truth_table(NUM_INPUTS);
+        kitty::create_nth_var( tts[i], i );
+        divs.emplace_back( i );
+    }
+
+    null_stats st;
+    mux_resyn<kitty::dynamic_truth_table> engine( st );
+    const auto res = engine(function, ~function.construct(), divs.begin(), divs.end(), tts, 10 );
+    /* x1 ? (!x2 ? 0 : x3) : (x2 ? 0 : !x3) */
+
+    muxig_network ntk_after_synthesis;
+
+    if (res == std::nullopt) {
+      std::cerr << "No solution found during mux resynthesis.\n";
+      return;
+    }
+
+
+    // NOTE RES contains the optimal solution and will be decoded to ntk_after_synthesis
+    decode( ntk_after_synthesis, *res );
+
+    //std::cout << "After decoding optimal solution:\n";
+    //mockturtle::print(ntk_after_synthesis);
+
+    muxig_signal extern_signal;
+    ntk_after_synthesis.foreach_po([&]( auto signal ) {extern_signal = signal;});
+    
+    topo_view topo{ntk_after_synthesis, extern_signal};
+    auto f = cleanup_dangling( topo, ntk_after_synthesis, begin, end).front();
+    //std::cout << "After clean up:\n";
+    //mockturtle::print(ntk_after_synthesis);
+    //std::cout << "------:\n";
+
+
+    std::vector<muxig_network::signal> pis( NUM_INPUTS, ntk.get_constant( false ) );
+    std::copy( begin, end, pis.begin() );
+    fn(ntk.get_constant(false));
+  }
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/null.hpp b/include/mockturtle/algorithms/node_resynthesis/null.hpp
new file mode 100644
index 0000000..be24ab4
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/null.hpp
@@ -0,0 +1,61 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file null.hpp
+  \brief No resynthesis (as default synthesis engine)
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include "../../traits.hpp"
+#include <iostream>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/print.hpp>
+#include <mockturtle/utils/debugging_utils.hpp>
+
+namespace mockturtle
+{
+
+template<class Ntk>
+class null_resynthesis
+{
+public:
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    (void)ntk;
+    (void)function;
+    (void)begin;
+    (void)end;
+    (void)fn;
+
+  }
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/shannon.hpp b/include/mockturtle/algorithms/node_resynthesis/shannon.hpp
new file mode 100644
index 0000000..d4ed62e
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/shannon.hpp
@@ -0,0 +1,100 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file shannon.hpp
+  \brief Use Shannon decomposition for resynthesis
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <optional>
+#include <vector>
+
+#include <kitty/dynamic_truth_table.hpp>
+
+#include "../../traits.hpp"
+#include "../decomposition.hpp"
+#include "null.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Resynthesis function based on Shannon decomposition.
+ *
+ * This resynthesis function can be passed to ``node_resynthesis``,
+ * ``cut_rewriting``, and ``refactoring``.  The given truth table will be
+ * resynthized based on Shanon decomposition.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      const klut_network klut = ...;
+
+      shannon_resynthesis<xag_network> resyn;
+      auto xag = node_resynthesis<xag_network>( klut, resyn );
+   \endverbatim
+ *
+ */
+template<class Ntk, class ResynFn = null_resynthesis<Ntk>>
+class shannon_resynthesis
+{
+public:
+  shannon_resynthesis( std::optional<uint32_t> const& threshold = {}, ResynFn* resyn = nullptr )
+      : threshold_( threshold ),
+        resyn_( resyn ) {}
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    if ( threshold_ )
+    {
+      std::vector<uint32_t> vars( function.num_vars() - std::min<uint32_t>( *threshold_, function.num_vars() ) );
+      std::iota( vars.begin(), vars.end(), 0u );
+      const auto f = shannon_decomposition<Ntk, ResynFn>( ntk, function, vars, std::vector<signal<Ntk>>( begin, end ), *resyn_ );
+      fn( f );
+    }
+    else
+    {
+      std::vector<uint32_t> vars( function.num_vars() );
+      std::iota( vars.begin(), vars.end(), 0u );
+      const auto f = shannon_decomposition( ntk, function, vars, std::vector<signal<Ntk>>( begin, end ) );
+      fn( f );
+    }
+  }
+
+private:
+  std::optional<uint32_t> threshold_;
+  ResynFn* resyn_;
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/sop_factoring.hpp b/include/mockturtle/algorithms/node_resynthesis/sop_factoring.hpp
new file mode 100644
index 0000000..22adf0d
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/sop_factoring.hpp
@@ -0,0 +1,453 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file sop_factoring.hpp
+  \brief Resynthesis with SOP factoring
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <iostream>
+#include <sstream>
+#include <unordered_map>
+#include <vector>
+
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/isop.hpp>
+#include <kitty/operators.hpp>
+
+#include "../../utils/sop_utils.hpp"
+#include "../../utils/stopwatch.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for sop_factoring function. */
+struct sop_factoring_params
+{
+  /*! \brief Select divisors with a quick algorithm. */
+  bool use_quick_factoring{ true };
+
+  /*! \brief Factoring is also tried for the negated TT. */
+  bool try_both_polarities{ true };
+
+  /*! \brief Factoring considers input and output inverters as additional cost. */
+  bool consider_inverter_cost{ false };
+};
+
+/*! \brief Resynthesis function based on SOP factoring.
+ *
+ * This resynthesis function can be passed to ``node_resynthesis``,
+ * ``cut_rewriting``, and ``refactoring``. The method converts a
+ * given truth table in an ISOP, then factors the ISOP, and
+ * returns the factored form.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      aig_network aig = ...;
+
+      sop_factoring<aig_network> resyn;
+      refactoring( aig, resyn );
+   \endverbatim
+ *
+ */
+template<class Ntk>
+class sop_factoring
+{
+public:
+  using signal = typename Ntk::signal;
+  using sop_t = std::vector<uint64_t>;
+
+public:
+  explicit sop_factoring( sop_factoring_params const& ps = {} )
+      : _ps( ps ) {}
+
+public:
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& dest, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    assert( function.num_vars() <= 31 );
+
+    if ( kitty::is_const0( function ) )
+    {
+      /* constant 0 */
+      fn( dest.get_constant( false ) );
+      return;
+    }
+    else if ( kitty::is_const0( ~function ) )
+    {
+      /* constant 1 */
+      fn( dest.get_constant( true ) );
+      return;
+    }
+
+    /* derive ISOP */
+    bool negated;
+    auto cubes = get_isop( function, negated );
+
+    /* create literal form of SOP */
+    sop_t sop = cubes_to_sop( cubes, function.num_vars() );
+
+    /* derive the factored form */
+    signal f = gen_factor_rec( dest, { begin, end }, sop, 2 * function.num_vars() );
+
+    fn( negated ? !f : f );
+  }
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& dest, kitty::dynamic_truth_table const& function, kitty::dynamic_truth_table const& dc, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    assert( function.num_vars() <= 31 );
+
+    if ( kitty::is_const0( function & ( ~dc ) ) )
+    {
+      /* constant 0 */
+      fn( dest.get_constant( false ) );
+      return;
+    }
+    else if ( kitty::is_const0( ~( function | dc ) ) )
+    {
+      /* constant 1 */
+      fn( dest.get_constant( true ) );
+      return;
+    }
+
+    /* derive ISOP */
+    bool negated;
+    auto cubes = get_isop_dc( function, dc, negated );
+
+    /* create literal form of SOP */
+    sop_t sop = cubes_to_sop( cubes, function.num_vars() );
+
+    /* derive the factored form */
+    signal f = gen_factor_rec( dest, { begin, end }, sop, 2 * function.num_vars() );
+
+    fn( negated ? !f : f );
+  }
+
+private:
+  std::vector<kitty::cube> get_isop( kitty::dynamic_truth_table const& function, bool& negated ) const
+  {
+    std::vector<kitty::cube> cubes = kitty::isop( function );
+
+    if ( _ps.try_both_polarities )
+    {
+      std::vector<kitty::cube> n_cubes = kitty::isop( ~function );
+
+      if ( _ps.consider_inverter_cost )
+      {
+        uint32_t n_lit = 0;
+        uint32_t lit = 0;
+        kitty::cube n_term;
+        kitty::cube term;
+        for ( auto const& c : n_cubes )
+        {
+          n_term._mask |= c._mask & ( ~c )._bits;
+          n_lit += c.num_literals();
+        }
+        for ( auto const& c : cubes )
+        {
+          term._mask |= c._mask & ( ~c )._bits;
+          lit += c.num_literals();
+        }
+
+        /* positive cost: cubes + input negations + output negation */
+        uint32_t positive_cost = cubes.size() + term.num_literals() + 1;
+        /* negative cost: cubes + input negations */
+        uint32_t negative_cost = n_cubes.size() + n_term.num_literals();
+
+        if ( negative_cost < positive_cost )
+        {
+          negated = true;
+          return n_cubes;
+        }
+      }
+      else
+      {
+        if ( n_cubes.size() < cubes.size() )
+        {
+          negated = true;
+          return n_cubes;
+        }
+        else if ( n_cubes.size() == cubes.size() )
+        {
+          uint32_t n_lit = 0;
+          uint32_t lit = 0;
+          for ( auto const& c : n_cubes )
+          {
+            n_lit += c.num_literals();
+          }
+          for ( auto const& c : cubes )
+          {
+            lit += c.num_literals();
+          }
+
+          if ( n_lit < lit )
+          {
+            negated = true;
+            return n_cubes;
+          }
+        }
+      }
+    }
+
+    negated = false;
+    return cubes;
+  }
+
+  std::vector<kitty::cube> get_isop_dc( kitty::dynamic_truth_table const& function, kitty::dynamic_truth_table const& dc, bool& negated ) const
+  {
+    std::vector<kitty::cube> cubes;
+    kitty::detail::isop_rec( function & ~dc, function | dc, function.num_vars(), cubes );
+
+    if ( _ps.try_both_polarities )
+    {
+      std::vector<kitty::cube> n_cubes;
+      kitty::detail::isop_rec( ~function & ~dc, ~function | dc, function.num_vars(), n_cubes );
+
+      if ( _ps.consider_inverter_cost )
+      {
+        uint32_t n_lit = 0;
+        uint32_t lit = 0;
+        kitty::cube n_term;
+        kitty::cube term;
+        for ( auto const& c : n_cubes )
+        {
+          n_term._mask |= c._mask & ( ~c )._bits;
+          n_lit += c.num_literals();
+        }
+        for ( auto const& c : cubes )
+        {
+          term._mask |= c._mask & ( ~c )._bits;
+          lit += c.num_literals();
+        }
+
+        /* positive cost: cubes + input negations + output negation */
+        uint32_t positive_cost = cubes.size() + term.num_literals() + 1;
+        /* negative cost: cubes + input negations */
+        uint32_t negative_cost = n_cubes.size() + n_term.num_literals();
+
+        if ( negative_cost < positive_cost )
+        {
+          negated = true;
+          return n_cubes;
+        }
+      }
+      else
+      {
+        if ( n_cubes.size() < cubes.size() )
+        {
+          negated = true;
+          return n_cubes;
+        }
+        else if ( n_cubes.size() == cubes.size() )
+        {
+          uint32_t n_lit = 0;
+          uint32_t lit = 0;
+          for ( auto const& c : n_cubes )
+          {
+            n_lit += c.num_literals();
+          }
+          for ( auto const& c : cubes )
+          {
+            lit += c.num_literals();
+          }
+
+          if ( n_lit < lit )
+          {
+            negated = true;
+            return n_cubes;
+          }
+        }
+      }
+    }
+
+    negated = false;
+    return cubes;
+  }
+
+#pragma region SOP factoring
+  signal gen_factor_rec( Ntk& ntk, std::vector<signal> const& children, sop_t& sop, uint32_t const num_lit ) const
+  {
+    sop_t divisor, quotient, reminder;
+
+    assert( sop.size() );
+
+    /* compute the divisor */
+    bool success = _ps.use_quick_factoring ? sop_quick_divisor( sop, divisor, num_lit ) : sop_good_divisor( sop, divisor, num_lit );
+    if ( !success )
+    {
+      /* generate trivial sop circuit */
+      return gen_andor_circuit_rec( ntk, children, sop.begin(), sop.end(), num_lit );
+    }
+
+    /* divide the SOP by the divisor */
+    sop_divide( sop, divisor, quotient, reminder );
+
+    assert( quotient.size() > 0 );
+
+    if ( quotient.size() == 1 )
+    {
+      return lit_factor_rec( ntk, children, sop, quotient[0], num_lit );
+    }
+    sop_make_cube_free( quotient );
+
+    /* divide the SOP by the quotient */
+    sop_divide( sop, quotient, divisor, reminder );
+
+    if ( sop_is_cube_free( divisor ) )
+    {
+      signal div_s = gen_factor_rec( ntk, children, divisor, num_lit );
+      signal quot_s = gen_factor_rec( ntk, children, quotient, num_lit );
+
+      /* build (D)*(Q) + R */
+      signal dq_and = ntk.create_and( div_s, quot_s );
+
+      if ( reminder.size() )
+      {
+        signal rem_s = gen_factor_rec( ntk, children, reminder, num_lit );
+        return ntk.create_or( dq_and, rem_s );
+      }
+
+      return dq_and;
+    }
+
+    /* get the common cube */
+    uint64_t cube = UINT64_MAX;
+    for ( auto const& c : divisor )
+    {
+      cube &= c;
+    }
+
+    return lit_factor_rec( ntk, children, sop, cube, num_lit );
+  }
+
+  signal lit_factor_rec( Ntk& ntk, std::vector<signal> const& children, sop_t const& sop, uint64_t const c_sop, uint32_t const num_lit ) const
+  {
+    sop_t divisor, quotient, reminder;
+
+    /* extract the best literal */
+    detail::sop_best_literal( sop, divisor, c_sop, num_lit );
+
+    /* divide SOP by the literal */
+    sop_divide_by_cube( sop, divisor, quotient, reminder );
+
+    /* create the divisor: cube */
+    signal div_s = gen_and_circuit_rec( ntk, children, divisor[0], 0, num_lit );
+
+    /* factor the quotient */
+    signal quot_s = gen_factor_rec( ntk, children, quotient, num_lit );
+
+    /* build l*Q + R */
+    signal dq_and = ntk.create_and( div_s, quot_s );
+
+    /* factor the reminder */
+    if ( reminder.size() != 0 )
+    {
+      signal rem_s = gen_factor_rec( ntk, children, reminder, num_lit );
+      return ntk.create_or( dq_and, rem_s );
+    }
+
+    return dq_and;
+  }
+#pragma endregion
+
+#pragma region Circuit generation from SOP
+  signal gen_and_circuit_rec( Ntk& ntk, std::vector<signal> const& children, uint64_t const cube, uint32_t const begin, uint32_t const end ) const
+  {
+    /* count set literals */
+    uint32_t num_lit = 0;
+    uint32_t lit = begin;
+    uint32_t i;
+    for ( i = begin; i < end; ++i )
+    {
+      if ( detail::cube_has_lit( cube, i ) )
+      {
+        ++num_lit;
+        lit = i;
+      }
+    }
+
+    assert( num_lit > 0 );
+
+    if ( num_lit == 1 )
+    {
+      /* return the coprresponding signal with the correct polarity */
+      if ( lit % 2 == 1 )
+        return children[lit / 2];
+      else
+        return !children[lit / 2];
+    }
+
+    /* find splitting point */
+    uint32_t count_lit = 0;
+    for ( i = begin; i < end; ++i )
+    {
+      if ( detail::cube_has_lit( cube, i ) )
+      {
+        if ( count_lit >= num_lit / 2 )
+          break;
+
+        ++count_lit;
+      }
+    }
+
+    signal tree1 = gen_and_circuit_rec( ntk, children, cube, begin, i );
+    signal tree2 = gen_and_circuit_rec( ntk, children, cube, i, end );
+
+    return ntk.create_and( tree1, tree2 );
+  }
+
+  signal gen_andor_circuit_rec( Ntk& ntk, std::vector<signal> const& children, sop_t::const_iterator const& begin, sop_t::const_iterator const& end, uint32_t const num_lit ) const
+  {
+    auto num_prod = std::distance( begin, end );
+
+    assert( num_prod > 0 );
+
+    if ( num_prod == 1 )
+      return gen_and_circuit_rec( ntk, children, *begin, 0, num_lit );
+
+    /* create or tree */
+    signal tree1 = gen_andor_circuit_rec( ntk, children, begin, begin + num_prod / 2, num_lit );
+    signal tree2 = gen_andor_circuit_rec( ntk, children, begin + num_prod / 2, end, num_lit );
+
+    return ntk.create_or( tree1, tree2 );
+  }
+#pragma endregion
+
+private:
+  sop_factoring_params const& _ps;
+
+  mutable stopwatch<>::duration time_factoring{};
+};
+
+} // namespace mockturtle
diff --git a/include/mockturtle/algorithms/node_resynthesis/traits.hpp b/include/mockturtle/algorithms/node_resynthesis/traits.hpp
new file mode 100644
index 0000000..418786c
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/traits.hpp
@@ -0,0 +1,92 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file traits.hpp
+  \brief Traits for additional node_resynthesis methods
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include "../../traits.hpp"
+
+#include <kitty/dynamic_truth_table.hpp>
+
+#include <cstdint>
+#include <optional>
+#include <type_traits>
+
+namespace mockturtle
+{
+
+#pragma region has_set_bounds
+template<class ResynFn, class = void>
+struct has_set_bounds : std::false_type
+{
+};
+
+template<class ResynFn>
+struct has_set_bounds<ResynFn, std::void_t<decltype( std::declval<ResynFn>().set_bounds( std::optional<uint32_t>(), std::optional<uint32_t>() ) )>> : std::true_type
+{
+};
+
+template<class ResynFn>
+inline constexpr bool has_set_bounds_v = has_set_bounds<ResynFn>::value;
+#pragma endregion
+
+#pragma region has_clear_functions
+template<class ResynFn, class = void>
+struct has_clear_functions : std::false_type
+{
+};
+
+template<class ResynFn>
+struct has_clear_functions<ResynFn, std::void_t<decltype( std::declval<ResynFn>().clear_functions() )>> : std::true_type
+{
+};
+
+template<class ResynFn>
+inline constexpr bool has_clear_functions_v = has_clear_functions<ResynFn>::value;
+#pragma endregion
+
+#pragma region has_add_function
+template<class ResynFn, class Ntk, class = void>
+struct has_add_function : std::false_type
+{
+};
+
+template<class ResynFn, class Ntk>
+struct has_add_function<ResynFn, Ntk, std::void_t<decltype( std::declval<ResynFn>().add_function( signal<Ntk>(), kitty::dynamic_truth_table() ) )>> : std::true_type
+{
+};
+
+template<class ResynFn, class Ntk>
+inline constexpr bool has_add_function_v = has_add_function<ResynFn, Ntk>::value;
+#pragma endregion
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/xag_minmc.hpp b/include/mockturtle/algorithms/node_resynthesis/xag_minmc.hpp
new file mode 100644
index 0000000..b51a757
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/xag_minmc.hpp
@@ -0,0 +1,472 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xag_minmc.hpp
+  \brief XAG resynthesis
+
+  \author Eleonora Testa
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <array>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <tuple>
+#include <unordered_map>
+#include <vector>
+
+#include <kitty/algorithm.hpp>
+#include <kitty/bit_operations.hpp>
+#include <kitty/constructors.hpp>
+#include <kitty/hash.hpp>
+#include <kitty/operations.hpp>
+#include <kitty/print.hpp>
+#include <kitty/spectral.hpp>
+
+#include "../../networks/xag.hpp"
+#include "../../traits.hpp"
+#include "../../utils/stopwatch.hpp"
+#include "../../views/cut_view.hpp"
+#include "../cleanup.hpp"
+#include "../simulation.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for xag_minmc_resynthesis. */
+struct xag_minmc_resynthesis_params
+{
+  /*! \brief Print statistics when resynthesis object is destroyed. */
+  bool print_stats{ false };
+
+  /*! \brief Threshold for exhaustive don't care search.
+   *
+   * If the don't care set is smaller than this size, all possible covers with
+   * respect to the don't cares are explored.  Otherwise all covers are created
+   * that the on-set is extended by at most one element from the don't care set.
+   */
+  uint32_t exhaustive_dc_limit{ 10u };
+
+  /*! \brief Verify database when parsing. */
+  bool verify_database{ false };
+};
+
+/*! \brief Statistics for xag_minmc_resynthesis. */
+struct xag_minmc_resynthesis_stats
+{
+  /*! \brief Total time. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Time to parse database. */
+  stopwatch<>::duration time_parse_db{ 0 };
+
+  /*! \brief Overall time to classify functions. */
+  stopwatch<>::duration time_classify{ 0 };
+
+  /*! \brief Overall time to construct candidate. */
+  stopwatch<>::duration time_construct{ 0 };
+
+  /*! \brief Cache hits for classified functions. */
+  uint32_t cache_hits{ 0 };
+
+  /*! \brief Cache misses for classified functions. */
+  uint32_t cache_misses{ 0 };
+
+  /*! \brief Number of aborts due to classification. */
+  uint32_t classify_aborts{ 0 };
+
+  /*! \brief Number of aborts due to unknown function. */
+  uint32_t unknown_function_aborts{ 0 };
+
+  /*! \brief Total number of don't cares considered. */
+  uint32_t dont_cares{ 0 };
+
+  /*! \brief Prints report. */
+  void report() const
+  {
+    std::cout << fmt::format( "[i] total time     = {:>5.2f} secs\n", to_seconds( time_total ) );
+    std::cout << fmt::format( "[i] parse db time  = {:>5.2f} secs\n", to_seconds( time_parse_db ) );
+    std::cout << fmt::format( "[i] classify time  = {:>5.2f} secs\n", to_seconds( time_classify ) );
+    std::cout << fmt::format( "[i] - aborts       = {:>5}\n", classify_aborts );
+    std::cout << fmt::format( "[i] construct time = {:>5.2f} secs\n", to_seconds( time_construct ) );
+    std::cout << fmt::format( "[i] cache hits     = {:>5}\n", cache_hits );
+    std::cout << fmt::format( "[i] cache misses   = {:>5}\n", cache_misses );
+    std::cout << fmt::format( "[i] unknown func.  = {:>5}\n", unknown_function_aborts );
+    std::cout << fmt::format( "[i] don't cares    = {:>5}\n", dont_cares );
+  }
+};
+
+/*! \brief Resynthesis function to minimize multiplicative complexity in XAGs.
+ *
+ * This resynthesis function can be passed to ``cut_rewriting`` with a cut size
+ * of at most 6.  It will produce an XAG based on pre-computed XAGs with a
+ * minimum multiplicative complexity.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      const xag_network xag = ...;
+      xag_minmc_resynthesis resyn;
+      xag = cut_rewriting( xag, resyn );
+   \endverbatim
+ */
+class xag_minmc_resynthesis
+{
+public:
+  /*! \brief Default constructor.
+   *
+   * \param filename Database file with precomputed functions (information to be added)
+   * \param ps Parameters
+   * \param pst Statistics
+   */
+  xag_minmc_resynthesis( std::string const& filename, xag_minmc_resynthesis_params const& ps = {}, xag_minmc_resynthesis_stats* pst = nullptr )
+      : ps( ps ),
+        pst( pst ),
+        db( std::make_shared<xag_network>() ),
+        db_pis( std::make_shared<decltype( db_pis )::element_type>( 6u ) ),
+        func_mc( std::make_shared<decltype( func_mc )::element_type>() ),
+        classify_cache( std::make_shared<decltype( classify_cache )::element_type>() )
+  {
+    build_db( filename );
+  }
+
+  virtual ~xag_minmc_resynthesis()
+  {
+    if ( ps.print_stats )
+    {
+      st.report();
+    }
+
+    if ( pst )
+    {
+      *pst = st;
+    }
+  }
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( xag_network& xag, kitty::dynamic_truth_table function, kitty::dynamic_truth_table const& dont_cares, LeavesIterator begin, LeavesIterator end, Fn&& fn )
+  {
+    if ( !kitty::is_const0( dont_cares ) )
+    {
+      const auto cnt = kitty::count_ones( dont_cares );
+      st.dont_cares += cnt;
+
+      if ( cnt <= ps.exhaustive_dc_limit )
+      {
+        std::vector<uint8_t> ones;
+        kitty::for_each_one_bit( dont_cares, [&]( auto bit ) {
+          ones.push_back( bit );
+          kitty::clear_bit( function, bit );
+        } );
+
+        for ( auto i = 0u; i < ( 1u << ones.size() ); ++i )
+        {
+          for ( auto j = 0u; j < ones.size(); ++j )
+          {
+            if ( ( i >> j ) & 1 )
+            {
+              kitty::set_bit( function, ones[j] );
+            }
+            else
+            {
+              kitty::clear_bit( function, ones[j] );
+            }
+          }
+          ( *this )( xag, function, begin, end, fn );
+        }
+      }
+      else
+      {
+        ( *this )( xag, function, begin, end, fn );
+        kitty::for_each_one_bit( dont_cares, [&]( auto bit ) {
+          kitty::flip_bit( function, bit );
+          ( *this )( xag, function, begin, end, fn );
+          kitty::flip_bit( function, bit );
+        } );
+      }
+    }
+    else
+    {
+      ( *this )( xag, function, begin, end, fn );
+    }
+  }
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( xag_network& xag, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn )
+  {
+    stopwatch t1( st.time_total );
+
+    const auto func_ext = kitty::extend_to<6u>( function );
+    std::vector<kitty::detail::spectral_operation> trans;
+    kitty::static_truth_table<6u> tt_ext;
+
+    const auto cache_it = classify_cache->find( func_ext );
+
+    if ( cache_it != classify_cache->end() )
+    {
+      st.cache_hits++;
+      if ( !std::get<0>( cache_it->second ) )
+      {
+        return; /* quit */
+      }
+      tt_ext = std::get<1>( cache_it->second );
+      trans = std::get<2>( cache_it->second );
+    }
+    else
+    {
+      st.cache_misses++;
+      const auto spectral = call_with_stopwatch( st.time_classify,
+                                                 [&]() { return kitty::exact_spectral_canonization_limit( func_ext, 100000,
+                                                                                                          [&trans]( auto const& ops ) {
+                                                                                                            std::copy( ops.begin(), ops.end(),
+                                                                                                                       std::back_inserter( trans ) );
+                                                                                                          } ); } );
+      classify_cache->insert( { func_ext, { spectral.second, spectral.first, trans } } );
+      if ( !spectral.second )
+      {
+        st.classify_aborts++;
+        return; /* quit */
+      }
+      tt_ext = spectral.first;
+    }
+
+    xag_network::signal circuit;
+
+    auto search = func_mc->find( kitty::to_hex( tt_ext ) );
+    if ( search != func_mc->end() )
+    {
+      unsigned int mc{ 0u };
+      std::string original_f;
+
+      std::tie( original_f, mc, circuit ) = search->second;
+
+      kitty::static_truth_table<6u> db_repr;
+      kitty::create_from_hex_string( db_repr, original_f );
+
+      call_with_stopwatch( st.time_classify, [&]() { return kitty::exact_spectral_canonization(
+                                                         db_repr, [&trans]( auto const& ops ) {
+                                                           std::copy( ops.rbegin(), ops.rend(),
+                                                                      std::back_inserter( trans ) );
+                                                         } ); } );
+    }
+    else if ( kitty::is_const0( tt_ext ) )
+    {
+      circuit = db->get_constant( false );
+    }
+    else
+    {
+      // std::cout << "[w] unknown " << kitty::to_hex( tt_ext ) << " from " << kitty::to_hex( func_ext ) << "\n";
+      st.unknown_function_aborts++;
+      return; /* quit */
+    }
+
+    bool out_neg{ false };
+    std::vector<xag_network::signal> final_xor;
+    std::vector<xag_network::signal> pis( 6, xag.get_constant( false ) );
+    std::copy( begin, end, pis.begin() );
+
+    stopwatch t2( st.time_construct );
+    for ( auto const& t : trans )
+    {
+      switch ( t._kind )
+      {
+      default:
+        assert( false );
+      case kitty::detail::spectral_operation::kind::permutation:
+      {
+        const auto v1 = log2( t._var1 );
+        const auto v2 = log2( t._var2 );
+        std::swap( pis[v1], pis[v2] );
+      }
+      break;
+      case kitty::detail::spectral_operation::kind::input_negation:
+      {
+        const auto v1 = log2( t._var1 );
+        pis[v1] = !pis[v1];
+      }
+      break;
+      case kitty::detail::spectral_operation::kind::output_negation:
+        out_neg = !out_neg;
+        break;
+      case kitty::detail::spectral_operation::kind::spectral_translation:
+      {
+        const auto v1 = log2( t._var1 );
+        const auto v2 = log2( t._var2 );
+        pis[v1] = xag.create_xor( pis[v1], pis[v2] );
+      }
+      break;
+      case kitty::detail::spectral_operation::kind::disjoint_translation:
+      {
+        const auto v1 = log2( t._var1 );
+        final_xor.push_back( pis[v1] );
+      }
+      break;
+      }
+    }
+
+    xag_network::signal output;
+
+    if ( db->is_constant( db->get_node( circuit ) ) )
+    {
+      output = xag.get_constant( db->is_complemented( circuit ) );
+    }
+    else
+    {
+      cut_view<xag_network> topo{ *db, *db_pis, circuit };
+      output = cleanup_dangling( topo, xag, pis.begin(), pis.end() ).front();
+    }
+
+    for ( auto const& g : final_xor )
+    {
+      output = xag.create_xor( output, g );
+    }
+
+    fn( out_neg ? !output : output );
+  }
+
+private:
+  void build_db( std::string const& filename )
+  {
+    stopwatch t1( st.time_total );
+    stopwatch t2( st.time_parse_db );
+
+    std::generate( db_pis->begin(), db_pis->end(), [&]() { return db->create_pi(); } );
+
+    std::ifstream file1( filename.c_str(), std::ifstream::in );
+    std::string line;
+    unsigned pos{ 0u };
+
+    // std::ofstream db_file( "/tmp/db", std::ofstream::out );
+
+    while ( std::getline( file1, line ) )
+    {
+      pos = static_cast<unsigned>( line.find( '\t' ) );
+      const auto name = line.substr( 0, pos++ );
+      auto original = line.substr( pos, 16u );
+      pos += 17u;
+      const auto token_f = line.substr( pos, 16u );
+      pos += 17u;
+      auto mc = std::stoul( line.substr( pos, 1u ) );
+      pos += 2u;
+      line.erase( 0, pos );
+
+      auto circuit = line;
+      // auto orig_circuit = circuit;
+
+      const std::string delimiter = " ";
+      std::string token = circuit.substr( 0, circuit.find( ' ' ) );
+      circuit.erase( 0, circuit.find( ' ' ) + 1 );
+      const auto inputs = std::stoul( token );
+
+      std::vector<xag_network::signal> hashing_circ( db_pis->begin(), db_pis->begin() + inputs );
+
+      while ( circuit.size() > 4 )
+      {
+        std::array<unsigned, 2> signals;
+        std::vector<xag_network::signal> ff( 2 );
+        for ( auto j = 0u; j < 2u; j++ )
+        {
+          token = circuit.substr( 0, circuit.find( ' ' ) );
+          circuit.erase( 0, circuit.find( ' ' ) + 1 );
+          signals[j] = std::stoul( token );
+          if ( signals[j] == 0 )
+          {
+            ff[j] = db->get_constant( false );
+          }
+          else if ( signals[j] == 1 )
+          {
+            ff[j] = db->get_constant( true );
+          }
+          else
+          {
+            ff[j] = hashing_circ[signals[j] / 2 - 1] ^ ( signals[j] % 2 != 0 );
+          }
+        }
+        circuit.erase( 0, circuit.find( ' ' ) + 1 );
+
+        if ( signals[0] > signals[1] )
+        {
+          hashing_circ.push_back( db->create_xor( ff[0], ff[1] ) );
+        }
+        else
+        {
+          hashing_circ.push_back( db->create_and( ff[0], ff[1] ) );
+        }
+      }
+
+      const auto output = std::stoul( circuit );
+      const auto f = hashing_circ[output / 2 - 1] ^ ( output % 2 != 0 );
+      db->create_po( f );
+
+      /* verify */
+      if ( ps.verify_database )
+      {
+        cut_view<xag_network> view{ *db, *db_pis, f };
+        kitty::static_truth_table<6u> tt, tt_repr;
+        kitty::create_from_hex_string( tt, original );
+        kitty::create_from_hex_string( tt_repr, token_f );
+        auto result = simulate<kitty::static_truth_table<6u>>( view )[0];
+        if ( tt != result )
+        {
+          std::cerr << "[w] invalid circuit for " << original << ", got " << kitty::to_hex( result ) << "\n";
+          original = kitty::to_hex( result );
+
+          const auto repr = exact_spectral_canonization( tt );
+          if ( repr != tt_repr )
+          {
+            std::cerr << "[e] representatives do not match\n";
+          }
+        }
+
+        // db_file << name << "\t" << token_f << "\t" << original << "\t" << mc << "\t" << orig_circuit << "\n";
+      }
+
+      func_mc->insert( { token_f, { original, mc, f } } );
+    }
+  }
+
+public:
+  xag_minmc_resynthesis_params ps;
+  xag_minmc_resynthesis_stats st;
+
+private:
+  xag_minmc_resynthesis_stats* pst{ nullptr };
+
+  std::shared_ptr<xag_network> db;
+  std::shared_ptr<std::vector<xag_network::signal>> db_pis;
+  std::shared_ptr<std::unordered_map<std::string, std::tuple<std::string, unsigned, xag_network::signal>>> func_mc;
+  std::shared_ptr<std::unordered_map<kitty::static_truth_table<6u>, std::tuple<bool, kitty::static_truth_table<6u>, std::vector<kitty::detail::spectral_operation>>, kitty::hash<kitty::static_truth_table<6u>>>> classify_cache;
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/xag_minmc2.hpp b/include/mockturtle/algorithms/node_resynthesis/xag_minmc2.hpp
new file mode 100644
index 0000000..4c30e46
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/xag_minmc2.hpp
@@ -0,0 +1,172 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xag_minmc2.hpp
+  \brief XAG resynthesis
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <fstream>
+#include <unordered_map>
+#include <vector>
+
+#include "../../networks/xag.hpp"
+#include "../../utils/index_list.hpp"
+#include "../detail/minmc_xags.hpp"
+#include "../equivalence_classes.hpp"
+
+#include <fmt/format.h>
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/print.hpp>
+#include <kitty/spectral.hpp>
+#include <lorina/detail/utils.hpp>
+
+namespace mockturtle::future
+{
+
+struct xag_minmc_resynthesis_params
+{
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+};
+
+struct xag_minmc_resynthesis_stats
+{
+  /*! \brief Database size in bytes. */
+  uint64_t db_size{};
+};
+
+template<class Ntk = xag_network>
+class xag_minmc_resynthesis
+{
+public:
+  xag_minmc_resynthesis()
+  {
+    build_db();
+  }
+
+  void load_from_file( std::string const& filename )
+  {
+    if ( ps_.verbose )
+    {
+      fmt::print( "start loading\n" );
+    }
+    kitty::dynamic_truth_table func( 6u );
+    std::ifstream in( filename, std::ifstream::in );
+    std::string line;
+    while ( std::getline( in, line ) )
+    {
+      const auto vline = lorina::detail::split( line, " " );
+      kitty::create_from_hex_string( func, vline[0] );
+      const auto sindexes = lorina::detail::split( vline[3], "," );
+      std::vector<uint32_t> index_list( sindexes.size() );
+      std::transform( sindexes.begin(), sindexes.end(), index_list.begin(), [&]( std::string const& s ) { return static_cast<uint32_t>( std::stoul( s ) ); } );
+      db_[6u][*func.cbegin()] = index_list;
+      st_.db_size += sizeof( uint64_t ) + sizeof( sindexes ) + sizeof( uint32_t ) * sindexes.size();
+    }
+    if ( ps_.verbose )
+    {
+      fmt::print( "done loading, size = {:>5.2f} Kb\n", st_.db_size / 1024.0f );
+    }
+  }
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    const auto num_vars = function.num_vars();
+    uint64_t repr;
+    std::vector<kitty::detail::spectral_operation> trans;
+
+    if ( const auto itCache = cache_[num_vars].find( *function.cbegin() ); itCache != cache_[num_vars].end() )
+    {
+      repr = itCache->second.first;
+      trans = itCache->second.second;
+    }
+    else
+    {
+      repr = *kitty::hybrid_exact_spectral_canonization( function, [&]( auto const& ops ) { trans = ops; } ).cbegin();
+      cache_[num_vars][*function.cbegin()] = { repr, trans };
+    }
+
+    const auto it = db_[num_vars].find( repr );
+    if ( it == db_[num_vars].end() )
+    {
+      fmt::print( "[w] cannot find repr {:x} in database.\n", repr );
+      return;
+    }
+
+    const auto f = apply_spectral_transformations( ntk, trans, std::vector<signal<Ntk>>( begin, end ), [&]( xag_network& ntk, std::vector<signal<Ntk>> const& leaves ) {
+      xag_index_list il{ it->second };
+      std::vector<xag_network::signal> pos;
+      insert( ntk, std::begin( leaves ), std::begin( leaves ) + il.num_pis(), il,
+              [&]( xag_network::signal const& f ) {
+                pos.push_back( f );
+              } );
+      assert( pos.size() == 1u );
+      return pos[0u];
+    } );
+
+    fn( f );
+  }
+
+private:
+  void build_db()
+  {
+    st_.db_size += sizeof( db_ );
+
+    for ( auto i = 0u; i < detail::minmc_xags.size(); ++i )
+    {
+      for ( auto const& [_, word, repr, expr] : detail::minmc_xags[i] )
+      {
+        (void)_;
+        (void)expr;
+        db_[i][word] = repr;
+        st_.db_size += sizeof( word ) + sizeof( repr ) + sizeof( uint32_t ) * repr.size();
+      }
+    }
+
+    if ( ps_.verbose )
+    {
+      fmt::print( "[i] db size = {:>5.2f} Kb\n", st_.db_size / 1024.0f );
+    }
+  }
+
+private:
+  std::vector<std::unordered_map<uint64_t, std::vector<uint32_t>>> db_{ 7u };
+  mutable std::vector<std::unordered_map<uint64_t, std::pair<uint64_t, std::vector<kitty::detail::spectral_operation>>>> cache_{ 7u };
+
+private:
+  xag_minmc_resynthesis_params ps_;
+  xag_minmc_resynthesis_stats st_;
+};
+
+} // namespace mockturtle::future
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/xag_npn.hpp b/include/mockturtle/algorithms/node_resynthesis/xag_npn.hpp
new file mode 100644
index 0000000..36c89c0
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/xag_npn.hpp
@@ -0,0 +1,691 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xag_npn.hpp
+  \brief Replace with size-optimum XAGs and AIGs from NPN (from ABC rewrite)
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <vector>
+
+#include <fmt/format.h>
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/npn.hpp>
+#include <kitty/print.hpp>
+#include <kitty/static_truth_table.hpp>
+
+#include "../../algorithms/simulation.hpp"
+#include "../../networks/xag.hpp"
+#include "../../utils/index_list.hpp"
+#include "../../utils/node_map.hpp"
+#include "../../utils/stopwatch.hpp"
+
+namespace mockturtle
+{
+
+struct xag_npn_resynthesis_params
+{
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+};
+
+struct xag_npn_resynthesis_stats
+{
+  stopwatch<>::duration time_classes{ 0 };
+  stopwatch<>::duration time_db{ 0 };
+
+  uint32_t db_size;
+  uint32_t covered_classes;
+
+  void report() const
+  {
+    std::cout << fmt::format( "[i] build classes time = {:>5.2f} secs\n", to_seconds( time_classes ) );
+    std::cout << fmt::format( "[i] build db time      = {:>5.2f} secs\n", to_seconds( time_db ) );
+  }
+};
+
+enum class xag_npn_db_kind : uint32_t
+{
+  xag_incomplete = 0,
+  xag_complete = 1,
+  aig_complete = 2,
+};
+
+/*! \brief Resynthesis function based on pre-computed AIGs.
+ *
+ * This resynthesis function can be passed to ``cut_rewriting``.  It will
+ * produce a network based on pre-computed XAGs with up to at most 4 variables.
+ * Consequently, the nodes' fan-in sizes in the input network must not exceed
+ * 4.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      const aig_network aig = ...;
+      xag_npn_resynthesis<aig_network> resyn;
+      aig = cut_rewriting( aig, resyn );
+
+   .. note::
+
+      The implementation of this algorithm was heavily inspired by the rewrite
+      command in AIG.  It uses the same underlying database of subcircuits.
+   \endverbatim
+ */
+template<class Ntk, class DatabaseNtk = xag_network, xag_npn_db_kind DBKind = xag_npn_db_kind::xag_incomplete>
+class xag_npn_resynthesis
+{
+public:
+  xag_npn_resynthesis( xag_npn_resynthesis_params const& ps = {}, xag_npn_resynthesis_stats* pst = nullptr )
+      : ps( ps ),
+        pst( pst ),
+        _repr( 1u << 16u )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+    static_assert( has_create_and_v<Ntk>, "Ntk does not implement the create_and method" );
+    static_assert( has_create_xor_v<Ntk>, "Ntk does not implement the create_xor method" );
+    static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+
+    static_assert( is_network_type_v<DatabaseNtk>, "DatabaseNtk is not a network type" );
+    static_assert( has_get_node_v<DatabaseNtk>, "DatabaseNtk does not implement the get_node method" );
+    static_assert( has_is_complemented_v<DatabaseNtk>, "DatabaseNtk does not implement the is_complemented method" );
+    static_assert( has_is_xor_v<DatabaseNtk>, "DatabaseNtk does not implement the is_xor method" );
+    static_assert( has_size_v<DatabaseNtk>, "DatabaseNtk does not implement the size method" );
+    static_assert( has_create_pi_v<DatabaseNtk>, "DatabaseNtk does not implement the create_pi method" );
+    static_assert( has_create_and_v<DatabaseNtk>, "DatabaseNtk does not implement the create_and method" );
+    static_assert( has_create_xor_v<DatabaseNtk>, "DatabaseNtk does not implement the create_xor method" );
+    static_assert( has_foreach_fanin_v<DatabaseNtk>, "DatabaseNtk does not implement the foreach_fanin method" );
+    static_assert( has_foreach_node_v<DatabaseNtk>, "DatabaseNtk does not implement the foreach_node method" );
+    static_assert( has_make_signal_v<DatabaseNtk>, "DatabaseNtk does not implement the make_signal method" );
+
+    build_classes();
+    build_db();
+  }
+
+  virtual ~xag_npn_resynthesis()
+  {
+    if ( ps.verbose )
+    {
+      st.report();
+    }
+
+    if ( pst )
+    {
+      *pst = st;
+    }
+  }
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    kitty::static_truth_table<4u> tt = kitty::extend_to<4u>( function );
+
+    /* get representative of function */
+    const auto [repr, phase, perm] = _repr[*tt.cbegin()];
+
+    /* check if representative has circuits */
+    const auto it = _repr_to_signal.find( repr );
+    if ( it == _repr_to_signal.end() )
+    {
+      return;
+    }
+
+    std::vector<signal<Ntk>> pis( 4, ntk.get_constant( false ) );
+    std::copy( begin, end, pis.begin() );
+
+    std::unordered_map<node<DatabaseNtk>, signal<Ntk>> db_to_ntk;
+    db_to_ntk.insert( { 0, ntk.get_constant( false ) } );
+    for ( auto i = 0; i < 4; ++i )
+    {
+      db_to_ntk.insert( { i + 1, ( phase >> perm[i] & 1 ) ? ntk.create_not( pis[perm[i]] ) : pis[perm[i]] } );
+    }
+
+    for ( auto const& cand : it->second )
+    {
+      const auto f = copy_db_entry( ntk, _db.get_node( cand ), db_to_ntk );
+      if ( !fn( _db.is_complemented( cand ) != ( phase >> 4 & 1 ) ? ntk.create_not( f ) : f ) )
+      {
+        return;
+      }
+    }
+  }
+
+private:
+  signal<Ntk>
+  copy_db_entry( Ntk& ntk, node<DatabaseNtk> const& n, std::unordered_map<node<DatabaseNtk>, signal<Ntk>>& db_to_ntk ) const
+  {
+    if ( const auto it = db_to_ntk.find( n ); it != db_to_ntk.end() )
+    {
+      return it->second;
+    }
+
+    std::array<signal<Ntk>, 2> fanin{};
+    _db.foreach_fanin( n, [&]( auto const& f, auto i ) {
+      const auto ntk_f = copy_db_entry( ntk, _db.get_node( f ), db_to_ntk );
+      fanin[i] = _db.is_complemented( f ) ? ntk.create_not( ntk_f ) : ntk_f;
+    } );
+
+    const auto f = _db.is_xor( n ) ? ntk.create_xor( fanin[0], fanin[1] ) : ntk.create_and( fanin[0], fanin[1] );
+    db_to_ntk.insert( { n, f } );
+    return f;
+  }
+
+  void build_classes()
+  {
+    stopwatch t( st.time_classes );
+
+    kitty::static_truth_table<4u> tt;
+    do
+    {
+      _repr[*tt.cbegin()] = kitty::exact_npn_canonization( tt );
+      kitty::next_inplace( tt );
+    } while ( !kitty::is_const0( tt ) );
+  }
+
+  void build_db()
+  {
+    stopwatch t( st.time_db );
+
+    if constexpr ( DBKind == xag_npn_db_kind::xag_incomplete )
+    {
+      decode( _db, xag_index_list{ std::vector<uint32_t>{ subgraphs, subgraphs + sizeof subgraphs / sizeof subgraphs[0] } } );
+    }
+    else if constexpr ( DBKind == xag_npn_db_kind::xag_complete )
+    {
+      decode( _db, xag_index_list{ std::vector<uint32_t>{ subgraphs_xag, subgraphs_xag + sizeof subgraphs_xag / sizeof subgraphs_xag[0] } } );
+    }
+    else if constexpr ( DBKind == xag_npn_db_kind::aig_complete )
+    {
+      decode( _db, xag_index_list{ std::vector<uint32_t>{ subgraphs_aig, subgraphs_aig + sizeof subgraphs_aig / sizeof subgraphs_aig[0] } } );
+    }
+    const auto sim_res = simulate_nodes<kitty::static_truth_table<4u>>( _db );
+
+    _db.foreach_node( [&]( auto n ) {
+      if ( std::get<0>( _repr[*sim_res[n].cbegin()] ) == sim_res[n] )
+      {
+        if ( _repr_to_signal.count( sim_res[n] ) == 0 )
+        {
+          _repr_to_signal.insert( { sim_res[n], { _db.make_signal( n ) } } );
+        }
+        else
+        {
+          _repr_to_signal[sim_res[n]].push_back( _db.make_signal( n ) );
+        }
+      }
+      else
+      {
+        const auto f = ~sim_res[n];
+        if ( std::get<0>( _repr[*f.cbegin()] ) == f )
+        {
+          if ( _repr_to_signal.count( f ) == 0 )
+          {
+            _repr_to_signal.insert( { f, { !_db.make_signal( n ) } } );
+          }
+          else
+          {
+            _repr_to_signal[f].push_back( !_db.make_signal( n ) );
+          }
+        }
+      }
+    } );
+
+    st.db_size = _db.size();
+    st.covered_classes = static_cast<uint32_t>( _repr_to_signal.size() );
+  }
+
+  xag_npn_resynthesis_params ps;
+  xag_npn_resynthesis_stats st;
+  xag_npn_resynthesis_stats* pst{ nullptr };
+
+  std::vector<std::tuple<kitty::static_truth_table<4u>, uint32_t, std::vector<uint8_t>>> _repr;
+  std::unordered_map<kitty::static_truth_table<4u>, std::vector<signal<DatabaseNtk>>, kitty::hash<kitty::static_truth_table<4u>>> _repr_to_signal;
+
+  DatabaseNtk _db;
+
+  // clang-format off
+  /* complete XAG database */
+  inline static const uint32_t subgraphs_xag[] = { 38460932, 6, 4, 10, 8,
+    8, 6, 3, 5, 16, 14, 3, 10, 20, 8, 22, 6, 2, 6, 4, 27, 8, 2, 30, 28,
+    7, 8, 2, 35, 4, 37, 6, 9, 40, 2, 42, 38, 4, 2, 7, 46, 17, 49, 50, 8,
+    4, 8, 54, 6, 3, 56, 5, 7, 60, 8, 62, 58, 3, 8, 66, 4, 8, 68, 4, 71,
+    7, 69, 74, 72, 76, 2, 2, 4, 46, 8, 6, 83, 81, 85, 86, 8, 15, 83, 90,
+    80, 4, 15, 2, 95, 96, 14, 98, 54, 4, 6, 3, 102, 8, 105, 106, 2, 108,
+    60, 30, 4, 2, 112, 114, 6, 114, 8, 116, 118, 120, 112, 6, 54, 54, 2,
+    5, 6, 128, 126, 125, 130, 6, 81, 8, 135, 136, 2, 138, 4, 2, 8, 4,
+    142, 6, 145, 146, 4, 148, 2, 6, 2, 152, 4, 6, 31, 154, 157, 7, 55,
+    3, 9, 162, 160, 46, 6, 8, 167, 166, 4, 47, 171, 169, 173, 8, 4, 47,
+    153, 177, 179, 180, 152, 9, 167, 2, 177, 7, 187, 188, 8, 31, 177, 7,
+    193, 194, 8, 7, 145, 198, 8, 6, 67, 11, 203, 9, 10, 206, 2, 208,
+    204, 16, 6, 9, 212, 7, 81, 216, 214, 6, 8, 4, 152, 222, 162, 221,
+    225, 166, 8, 81, 213, 16, 231, 9, 230, 234, 232, 9, 216, 10, 152,
+    14, 241, 4, 31, 7, 163, 246, 8, 245, 249, 14, 46, 14, 2, 254, 4, 7,
+    257, 2, 256, 14, 261, 259, 263, 8, 17, 135, 267, 2, 221, 4, 270,
+    272, 6, 274, 8, 48, 8, 66, 28, 221, 281, 7, 9, 284, 2, 286, 4, 221,
+    288, 3, 6, 267, 293, 2, 7, 8, 297, 298, 2, 298, 4, 300, 302, 304, 6,
+    5, 153, 9, 309, 310, 60, 142, 4, 162, 6, 314, 317, 318, 8, 6, 80, 9,
+    323, 5, 27, 326, 2, 328, 6, 8, 328, 331, 333, 9, 153, 14, 154, 337,
+    339, 2, 15, 4, 343, 344, 2, 346, 6, 46, 284, 9, 223, 7, 154, 354,
+    352, 2, 9, 7, 359, 360, 8, 11, 363, 364, 358, 296, 4, 7, 368, 368,
+    2, 9, 373, 371, 375, 6, 176, 359, 379, 380, 4, 154, 221, 16, 8, 231,
+    387, 8, 103, 390, 4, 2, 14, 394, 392, 8, 217, 17, 399, 400, 216,
+    346, 220, 7, 31, 15, 407, 113, 409, 162, 4, 7, 413, 414, 2, 8, 415,
+    416, 419, 216, 8, 10, 2, 7, 424, 2, 11, 9, 429, 430, 426, 7, 113,
+    434, 8, 4, 9, 6, 439, 154, 441, 442, 8, 80, 6, 47, 447, 8, 449, 450,
+    446, 5, 9, 253, 455, 4, 163, 3, 7, 460, 458, 221, 463, 9, 155, 466,
+    354, 3, 11, 470, 8, 55, 473, 5, 284, 4, 285, 478, 2, 221, 480, 477,
+    483, 15, 461, 14, 4, 488, 2, 487, 491, 2, 63, 494, 60, 255, 489,
+    221, 499, 358, 6, 5, 503, 504, 8, 8, 152, 3, 509, 510, 176, 309,
+    512, 498, 6, 2, 10, 518, 6, 520, 8, 10, 521, 522, 525, 14, 223, 2,
+    103, 9, 531, 532, 60, 8, 61, 47, 537, 11, 14, 163, 541, 4, 14, 544,
+    6, 10, 461, 55, 549, 544, 360, 6, 55, 554, 4, 14, 176, 11, 221, 163,
+    560, 562, 8, 14, 67, 566, 326, 26, 4, 9, 570, 572, 60, 9, 254, 14,
+    257, 577, 579, 8, 47, 11, 583, 584, 2, 7, 176, 176, 2, 9, 590, 589,
+    593, 102, 8, 2, 596, 598, 4, 600, 6, 9, 103, 438, 6, 4, 7, 359, 609,
+    610, 606, 6, 571, 8, 615, 616, 570, 11, 30, 620, 6, 622, 2, 3, 4, 8,
+    609, 627, 629, 630, 6, 5, 293, 8, 635, 2, 637, 638, 634, 9, 425,
+    642, 60, 358, 4, 646, 6, 8, 646, 649, 651, 30, 176, 5, 655, 656, 30,
+    7, 658, 660, 654, 27, 537, 608, 8, 359, 667, 668, 6, 3, 221, 5, 672,
+    285, 675, 9, 152, 61, 679, 14, 583, 14, 30, 176, 684, 28, 2, 9, 689,
+    61, 163, 8, 10, 103, 695, 27, 425, 14, 699, 394, 6, 545, 703, 5,
+    246, 706, 8, 103, 709, 6, 47, 9, 713, 162, 60, 390, 6, 718, 4, 6,
+    359, 5, 723, 724, 8, 7, 16, 728, 8, 674, 8, 14, 47, 734, 6, 3, 176,
+    6, 738, 8, 739, 741, 743, 471, 537, 746, 60, 470, 6, 11, 751, 473,
+    753, 293, 387, 30, 537, 8, 247, 4, 761, 762, 246, 3, 14, 8, 767, 5,
+    14, 770, 766, 769, 773, 4, 153, 3, 777, 778, 4, 8, 780, 776, 6, 784,
+    782, 21, 267, 5, 285, 2, 791, 792, 284, 221, 795, 143, 771, 798, 2,
+    152, 771, 221, 803, 46, 607, 806, 8, 766, 8, 488, 811, 7, 387, 9,
+    47, 816, 814, 102, 2, 596, 821, 822, 60, 387, 713, 5, 30, 8, 829,
+    30, 6, 832, 4, 831, 834, 230, 8, 143, 785, 387, 447, 30, 61, 293,
+    845, 846, 2, 267, 447, 7, 177, 163, 853, 854, 6, 240, 8, 60, 2, 63,
+    860, 55, 620, 3, 285, 5, 867, 868, 2, 221, 871, 14, 654, 874, 8, 4,
+    143, 878, 2, 878, 6, 881, 883, 884, 8, 267, 713, 10, 30, 176, 424,
+    891, 893, 163, 556, 5, 766, 898, 8, 9, 240, 9, 179, 102, 30, 537,
+    906, 46, 441, 910, 8, 460, 4, 7, 915, 914, 2, 9, 918, 917, 921, 8,
+    471, 103, 925, 212, 4, 267, 928, 167, 387, 292, 4, 157, 935, 936,
+    30, 46, 221, 394, 4, 11, 943, 16, 284, 296, 60, 15, 297, 949, 951,
+    176, 6, 743, 954, 15, 163, 11, 959, 3, 60, 962, 604, 9, 17, 966,
+    216, 588, 162, 63, 820, 972, 60, 394, 8, 4, 977, 978, 14, 284, 673,
+    982, 674, 8, 323, 986, 154, 766, 4, 221, 991, 5, 470, 994, 206, 6,
+    187, 4, 67, 1000, 998, 6, 17, 9, 1005, 9, 820, 61, 1009, 386, 6, 81,
+    1013, 1005, 1014, 15, 31, 47, 1019, 1020, 6, 2, 61, 1024, 4, 1026,
+    6, 9, 1029, 152, 8, 6, 1032, 152, 439, 1036, 4, 1035, 1038, 2, 102,
+    9, 1043, 1044, 60, 7, 591, 1048, 8, 739, 1051, 6, 155, 3, 155, 1056,
+    8, 1055, 1059, 4, 359, 1062, 2, 7, 1064, 1066, 8, 503, 647, 1070, 8,
+    61, 143, 1074, 2, 518, 4, 9, 1079, 460, 8, 47, 1083, 674, 284, 3,
+    177, 1088, 6, 1032, 1091, 285, 673, 4, 1095, 1096, 672, 28, 8, 1100,
+    6, 689, 1102, 9, 519, 1106, 60, 9, 60, 9, 739, 1112, 188, 155, 267,
+    7, 17, 1118, 4, 9, 1121, 503, 591, 1124, 8, 9, 213, 296, 8, 4, 1131,
+    359, 1133, 1134, 6, 9, 81, 424, 1138, 634, 2, 221, 1143, 530, 6, 9,
+    1146, 61, 1149, 6, 46, 9, 1153, 81, 1154, 187, 424, 1158, 8, 9, 61,
+    1162, 6, 46, 1165, 21, 387, 2, 853, 1170, 4, 221, 1173, 2, 455,
+    1176, 10, 221, 1178, 13, 18, 24, 32, 45, 52, 65, 79, 89, 93, 101,
+    110, 123, 132, 141, 150, 158, 164, 174, 182, 184, 191, 197, 201,
+    211, 218, 226, 228, 236, 238, 242, 250, 252, 265, 268, 276, 279,
+    282, 290, 294, 307, 312, 321, 324, 334, 341, 348, 350, 356, 366,
+    377, 382, 384, 388, 397, 402, 404, 410, 420, 338, 423, 432, 437, 14,
+    445, 452, 457, 464, 468, 474, 485, 492, 496, 500, 507, 514, 517,
+    526, 528, 534, 63, 538, 543, 547, 550, 552, 557, 558, 565, 568, 574,
+    581, 587, 595, 602, 604, 612, 206, 618, 624, 633, 640, 644, 652,
+    662, 664, 671, 677, 681, 682, 686, 690, 693, 696, 700, 704, 710,
+    714, 716, 720, 727, 731, 9, 733, 737, 744, 748, 754, 756, 758, 764,
+    774, 787, 788, 796, 801, 804, 809, 812, 818, 824, 826, 836, 839,
+    840, 842, 848, 850, 856, 859, 862, 864, 872, 877, 884, 887, 888,
+    895, 897, 901, 902, 904, 908, 913, 923, 926, 930, 932, 938, 940,
+    944, 946, 952, 956, 960, 964, 968, 970, 974, 980, 984, 989, 992,
+    996, 1003, 1006, 1011, 1016, 1023, 1030, 1040, 1046, 1052, 1060,
+    1069, 1073, 1077, 1080, 1084, 1086, 1092, 1098, 1104, 1108, 284,
+    1110, 1114, 8, 1116, 1122, 1127, 1128, 1136, 1140, 1144, 1151, 1156,
+    1161, 1166, 1168, 1174, 1180 };
+
+  /* complete AIG database */
+  inline static const uint32_t subgraphs_aig [] = { 52223492, 4, 7, 5,
+    6, 11, 13, 8, 14, 9, 15, 17, 19, 3, 5, 6, 9, 7, 8, 25, 27, 23, 29,
+    22, 28, 31, 33, 3, 4, 2, 6, 37, 39, 8, 40, 9, 41, 43, 45, 2, 5, 2,
+    7, 4, 51, 49, 53, 8, 55, 9, 54, 57, 59, 2, 26, 25, 63, 2, 63, 5,
+    67, 65, 68, 64, 69, 71, 73, 2, 4, 6, 23, 77, 79, 8, 80, 9, 81, 83,
+    85, 5, 39, 8, 88, 2, 8, 6, 39, 93, 95, 89, 96, 91, 99, 4, 8, 2,
+    103, 13, 104, 13, 27, 3, 109, 107, 111, 8, 76, 6, 22, 77, 117, 27,
+    118, 115, 121, 7, 9, 22, 125, 6, 8, 23, 129, 76, 125, 130, 133,
+    127, 135, 5, 8, 3, 139, 93, 141, 4, 141, 7, 145, 142, 146, 143,
+    147, 149, 151, 5, 7, 8, 155, 9, 154, 157, 159, 2, 161, 4, 6, 161,
+    165, 3, 167, 163, 169, 2, 9, 4, 173, 3, 8, 7, 176, 174, 179, 39,
+    179, 5, 183, 181, 185, 4, 9, 155, 189, 2, 190, 165, 190, 3, 195,
+    193, 197, 23, 77, 6, 77, 8, 203, 200, 205, 201, 204, 207, 209, 7,
+    23, 77, 212, 9, 76, 23, 217, 6, 219, 215, 221, 23, 25, 77, 129,
+    224, 226, 225, 227, 229, 231, 3, 9, 7, 103, 235, 236, 234, 237,
+    239, 241, 23, 115, 7, 245, 8, 23, 77, 249, 6, 251, 247, 253, 23,
+    125, 227, 257, 226, 256, 259, 261, 6, 200, 7, 201, 265, 267, 9,
+    269, 49, 177, 7, 273, 25, 275, 7, 173, 4, 177, 278, 281, 25, 283,
+    7, 77, 8, 287, 125, 289, 9, 165, 155, 293, 3, 295, 8, 164, 2, 294,
+    299, 301, 297, 302, 4, 50, 5, 234, 307, 309, 129, 310, 11, 23,
+    177, 315, 129, 317, 37, 49, 6, 320, 7, 321, 323, 325, 8, 326, 9,
+    327, 329, 331, 9, 77, 7, 334, 23, 337, 129, 339, 9, 286, 26, 77,
+    9, 23, 6, 346, 345, 349, 4, 234, 7, 139, 2, 354, 353, 357, 129,
+    358, 77, 256, 129, 362, 2, 124, 4, 366, 3, 125, 4, 371, 367, 373,
+    129, 374, 369, 377, 203, 249, 6, 76, 343, 383, 289, 384, 8, 325,
+    9, 324, 389, 391, 8, 11, 51, 394, 51, 235, 4, 399, 397, 401, 367,
+    371, 4, 405, 5, 404, 407, 409, 129, 411, 3, 6, 249, 415, 5, 176,
+    4, 129, 2, 420, 419, 423, 6, 424, 7, 425, 427, 429, 5, 9, 2, 432,
+    157, 435, 3, 7, 7, 439, 2, 441, 4, 443, 439, 444, 8, 445, 441,
+    448, 447, 451, 9, 383, 24, 37, 325, 457, 9, 37, 11, 461, 50, 463,
+    51, 462, 465, 467, 88, 439, 173, 439, 4, 473, 471, 475, 50, 139,
+    139, 189, 3, 481, 479, 483, 129, 484, 155, 235, 293, 488, 292,
+    489, 491, 493, 6, 321, 9, 51, 320, 499, 497, 501, 5, 172, 129,
+    505, 4, 278, 506, 509, 7, 200, 24, 201, 513, 515, 7, 22, 347, 519,
+    337, 521, 5, 399, 398, 420, 525, 527, 22, 286, 287, 346, 531, 533,
+    3, 129, 4, 536, 2, 128, 4, 125, 541, 543, 537, 544, 539, 547, 8,
+    77, 212, 551, 9, 201, 213, 555, 553, 557, 154, 370, 9, 371, 155,
+    562, 561, 565, 24, 320, 26, 321, 569, 571, 8, 286, 9, 287, 575,
+    577, 2, 542, 3, 543, 7, 583, 4, 543, 9, 587, 585, 589, 581, 591,
+    25, 325, 125, 129, 9, 212, 8, 213, 77, 601, 598, 602, 599, 603,
+    605, 607, 7, 93, 4, 235, 611, 612, 610, 613, 615, 617, 129, 618,
+    5, 370, 7, 623, 8, 625, 373, 627, 3, 236, 129, 631, 77, 632, 125,
+    201, 129, 637, 3, 154, 8, 641, 155, 165, 234, 645, 643, 647, 5,
+    124, 3, 651, 542, 653, 543, 652, 129, 657, 655, 658, 4, 370, 5,
+    367, 371, 664, 663, 667, 129, 669, 173, 641, 3, 124, 5, 674, 581,
+    677, 129, 678, 9, 49, 155, 682, 154, 683, 685, 687, 248, 286, 22,
+    287, 76, 249, 693, 695, 691, 696, 9, 22, 265, 701, 115, 702, 334,
+    415, 157, 707, 6, 460, 4, 37, 7, 713, 8, 714, 711, 717, 2, 165, 9,
+    721, 155, 722, 154, 723, 725, 727, 8, 154, 9, 155, 731, 733, 5,
+    129, 2, 736, 173, 737, 739, 741, 165, 172, 157, 745, 13, 103, 51,
+    188, 155, 751, 9, 50, 748, 755, 4, 24, 155, 759, 7, 138, 759, 763,
+    2, 645, 9, 767, 731, 769, 8, 720, 6, 721, 9, 774, 773, 777, 4,
+    778, 5, 779, 781, 783, 12, 173, 6, 172, 9, 789, 4, 791, 787, 793,
+    2, 237, 4, 796, 129, 799, 631, 800, 125, 219, 7, 218, 77, 806,
+    805, 809, 6, 235, 9, 813, 8, 812, 5, 817, 815, 819, 309, 821, 92,
+    154, 3, 164, 93, 827, 155, 828, 825, 831, 188, 789, 279, 789, 5,
+    837, 835, 839, 9, 644, 9, 39, 5, 844, 737, 845, 847, 849, 3, 138,
+    25, 51, 2, 139, 5, 856, 855, 859, 853, 861, 77, 433, 7, 865, 9,
+    865, 6, 869, 867, 871, 5, 439, 175, 875, 234, 293, 235, 295, 879,
+    881, 188, 836, 839, 885, 27, 77, 25, 201, 889, 891, 888, 890, 893,
+    895, 235, 237, 7, 234, 5, 900, 103, 903, 813, 904, 5, 536, 125,
+    909, 6, 234, 9, 235, 4, 915, 7, 917, 913, 919, 8, 439, 237, 922,
+    236, 923, 925, 927, 4, 172, 6, 930, 7, 852, 933, 935, 53, 682,
+    157, 165, 6, 37, 8, 321, 943, 945, 129, 947, 5, 23, 6, 951, 249,
+    953, 2, 154, 9, 957, 165, 958, 731, 961, 9, 323, 154, 234, 489,
+    967, 160, 165, 5, 415, 9, 972, 7, 972, 8, 977, 975, 979, 8, 518,
+    9, 519, 983, 985, 22, 26, 347, 989, 8, 320, 497, 993, 643, 827, 3,
+    165, 2, 155, 999, 1001, 157, 1003, 3, 433, 154, 1007, 6, 1006, 9,
+    1011, 155, 1013, 1009, 1015, 3, 11, 8, 1019, 27, 1018, 1021, 1023,
+    8, 640, 173, 1027, 7, 235, 5, 1030, 4, 1031, 9, 1034, 1033, 1037,
+    4, 537, 6, 1041, 9, 1043, 909, 1045, 6, 177, 5, 1049, 179, 1050,
+    173, 179, 4, 1055, 1053, 1057, 9, 999, 5, 998, 7, 1062, 1061,
+    1065, 129, 675, 581, 1068, 3, 13, 8, 1072, 5, 1074, 2, 12, 9,
+    1073, 1079, 1080, 1077, 1083, 7, 857, 4, 857, 6, 1089, 9, 1090,
+    1087, 1093, 324, 461, 325, 460, 1097, 1099, 93, 125, 415, 1102, 5,
+    1105, 543, 1107, 5, 93, 7, 1110, 6, 1111, 2, 1114, 3, 1115, 1117,
+    1119, 9, 1121, 1113, 1123, 8, 998, 2, 164, 9, 1128, 155, 1131,
+    1126, 1132, 1127, 1133, 1135, 1137, 6, 335, 249, 701, 1141, 1142,
+    77, 701, 7, 1147, 6, 1146, 249, 1151, 1149, 1152, 23, 579, 22,
+    578, 1157, 1159, 77, 155, 93, 1163, 4, 415, 1031, 1167, 4, 1030,
+    93, 1171, 1169, 1172, 9, 415, 155, 1176, 641, 1179, 287, 383, 249,
+    1183, 125, 488, 124, 489, 1187, 1189, 5, 414, 2, 10, 1193, 1195,
+    8, 1197, 9, 1196, 1199, 1201, 155, 172, 154, 176, 1205, 1207, 9,
+    766, 730, 767, 1211, 1213, 875, 1007, 129, 1217, 455, 519, 23,
+    165, 6, 173, 1223, 1225, 383, 641, 9, 1229, 643, 1231, 6, 201,
+    249, 1235, 93, 415, 6, 415, 5, 1241, 1238, 1243, 8, 1242, 1239,
+    1246, 1245, 1249, 155, 723, 9, 973, 53, 1254, 454, 519, 2, 293, 3,
+    292, 157, 1263, 1261, 1264, 23, 1001, 9, 1268, 7, 1268, 8, 1273,
+    1271, 1275, 5, 371, 37, 1279, 129, 1281, 165, 643, 49, 103, 7,
+    1286, 6, 1287, 9, 1290, 1289, 1293, 7, 335, 265, 1297, 249, 1299,
+    1050, 1054, 1057, 1303, 129, 200, 155, 1129, 93, 1309, 22, 124, 3,
+    102, 49, 1315, 7, 1317, 25, 1319, 9, 645, 643, 1323, 9, 164, 154,
+    173, 1327, 1329, 9, 640, 1284, 1333, 286, 347, 533, 1337, 27, 235,
+    10, 1341, 11, 1340, 1343, 1345, 2, 759, 9, 1348, 3, 761, 1351,
+    1353, 461, 714, 460, 715, 1357, 1359, 9, 537, 7, 1362, 909, 1365,
+    23, 423, 596, 1368, 597, 1369, 1371, 1373, 663, 1279, 129, 1377,
+    641, 733, 165, 1381, 3, 189, 7, 1385, 4, 1386, 9, 1385, 6, 1391,
+    1389, 1393, 9, 79, 155, 1061, 1129, 1399, 226, 257, 1313, 1402, 8,
+    22, 286, 1407, 221, 1409, 9, 1129, 155, 998, 1412, 1415, 4, 439,
+    173, 1418, 439, 1049, 5, 1423, 1421, 1425, 160, 1129, 7, 37, 9,
+    36, 1431, 1433, 49, 1435, 129, 1437, 5, 51, 1177, 1441, 1176,
+    1440, 129, 1445, 1443, 1446, 9, 213, 212, 550, 1451, 1453, 157,
+    1129, 3, 158, 1456, 1459, 3, 155, 2, 733, 1463, 1465, 39, 460,
+    235, 875, 234, 874, 1471, 1473, 103, 1475, 125, 908, 124, 909,
+    1479, 1481, 675, 911, 2, 189, 51, 737, 1487, 1489, 4, 124, 909,
+    1493, 675, 1495, 165, 1463, 9, 1499, 731, 1501, 6, 461, 3, 460, 5,
+    1507, 1430, 1509, 1505, 1511, 2, 188, 23, 1515, 7, 1517, 6, 1516,
+    9, 1520, 1519, 1523, 292, 957, 5, 438, 581, 1529, 129, 1530, 79,
+    519, 9, 1534, 7, 347, 77, 1538, 349, 1541, 80, 984, 226, 519, 77,
+    415, 9, 1549, 155, 1551, 79, 334, 8, 644, 165, 1557, 2, 1559,
+    1323, 1557, 3, 1562, 1561, 1565, 129, 373, 23, 1568, 6, 433, 3,
+    1573, 8, 1575, 5, 433, 1574, 1579, 1577, 1581, 9, 13, 2, 1585, 8,
+    12, 5, 1589, 3, 1591, 1587, 1593, 8, 48, 1430, 1597, 1505, 1599,
+    20, 35, 47, 60, 74, 87, 101, 113, 122, 137, 152, 170, 186, 198,
+    210, 223, 233, 243, 254, 263, 270, 277, 285, 290, 304, 312, 318,
+    333, 340, 342, 351, 360, 364, 379, 380, 386, 392, 402, 412, 416,
+    430, 436, 452, 454, 459, 468, 477, 390, 486, 494, 502, 510, 517,
+    522, 529, 535, 549, 558, 567, 573, 579, 592, 595, 596, 608, 620,
+    628, 634, 638, 648, 660, 670, 673, 680, 689, 699, 704, 708, 719,
+    729, 735, 742, 746, 748, 753, 756, 761, 765, 771, 784, 794, 802,
+    811, 822, 833, 292, 841, 842, 850, 863, 872, 876, 883, 887, 897,
+    899, 906, 911, 921, 928, 937, 938, 489, 940, 948, 954, 963, 964,
+    968, 970, 980, 987, 9, 991, 994, 996, 1004, 1016, 1024, 1029,
+    1039, 1047, 1059, 1067, 1070, 1085, 1095, 1101, 1108, 1125, 1139,
+    1144, 1154, 1161, 1164, 1174, 1181, 1184, 1190, 1203, 1209, 1215,
+    1218, 1221, 1226, 1232, 1236, 1251, 1253, 521, 1256, 1258, 1266,
+    1276, 1282, 1284, 1295, 1300, 1305, 1306, 1310, 1312, 1321, 1324,
+    1331, 1334, 1339, 1346, 1355, 1361, 1367, 1375, 1378, 1382, 1394,
+    1396, 1400, 1404, 1411, 1416, 1426, 1428, 1438, 1448, 1455, 1460,
+    1466, 1468, 1476, 1483, 1484, 1490, 1496, 1503, 124, 158, 1512, 8,
+    1525, 1526, 1532, 1536, 1543, 1544, 1546, 1553, 1554, 1566, 1570,
+    1582, 1594, 1600 };
+
+  /* incomplete XAG database */
+  inline static const uint32_t subgraphs[] = {1780 << 16 | 0 << 8 | 4,
+      2, 4, 2, 5, 3, 4, 3, 5, 4, 2, 2, 6, 2, 7, 3, 6, 3, 7, 6, 2, 4, 6,
+      4, 7, 5, 6, 5, 7, 6, 4, 2, 8, 2, 9, 3, 8, 3, 9, 8, 2, 4, 8,
+      4, 9, 5, 8, 5, 9, 8, 4, 6, 8, 6, 9, 7, 8, 7, 9, 8, 6, 5, 11,
+      6, 10, 6, 11, 7, 10, 7, 11, 10, 6, 8, 10, 8, 11, 9, 10, 9, 11, 10, 8,
+      6, 12, 6, 13, 7, 12, 7, 13, 12, 6, 9, 12, 9, 13, 12, 8, 5, 15, 6, 14,
+      6, 15, 7, 14, 7, 15, 14, 6, 8, 14, 8, 15, 9, 14, 9, 15, 14, 8, 6, 16,
+      6, 17, 7, 16, 7, 17, 16, 6, 8, 16, 8, 17, 9, 16, 9, 17, 16, 8, 6, 18,
+      6, 19, 7, 18, 7, 19, 18, 6, 8, 19, 9, 18, 9, 19, 18, 8, 4, 20, 4, 21,
+      5, 20, 7, 21, 8, 20, 9, 21, 20, 8, 11, 21, 20, 10, 15, 21, 20, 14, 17, 21,
+      19, 21, 4, 22, 4, 23, 5, 22, 9, 22, 9, 23, 22, 8, 22, 12, 15, 23, 17, 23,
+      18, 23, 4, 24, 7, 25, 9, 25, 24, 8, 11, 25, 13, 25, 15, 25, 24, 14, 19, 25,
+      4, 26, 4, 27, 5, 26, 5, 27, 26, 4, 8, 27, 9, 26, 9, 27, 26, 8, 11, 27,
+      13, 27, 17, 27, 26, 16, 19, 27, 4, 28, 28, 4, 9, 28, 9, 29, 28, 8, 11, 28,
+      11, 29, 13, 29, 17, 29, 18, 29, 19, 28, 19, 29, 2, 30, 2, 31, 3, 30, 5, 31,
+      7, 31, 8, 30, 8, 31, 9, 30, 9, 31, 30, 8, 13, 31, 17, 31, 19, 31, 23, 31,
+      27, 31, 29, 31, 2, 32, 2, 33, 5, 33, 32, 6, 8, 33, 32, 8, 13, 33, 17, 33,
+      21, 33, 25, 33, 27, 33, 28, 33, 32, 28, 2, 34, 3, 35, 34, 4, 7, 35, 34, 8,
+      11, 35, 15, 35, 19, 35, 34, 18, 23, 35, 27, 35, 33, 35, 2, 36, 2, 37, 3, 36,
+      3, 37, 36, 2, 8, 36, 8, 37, 9, 36, 9, 37, 36, 8, 11, 37, 15, 37, 17, 37,
+      18, 37, 19, 37, 21, 37, 25, 37, 27, 37, 29, 37, 2, 38, 3, 38, 38, 2, 8, 38,
+      8, 39, 9, 38, 9, 39, 38, 8, 11, 38, 11, 39, 15, 38, 15, 39, 17, 39, 18, 38,
+      19, 38, 19, 39, 21, 39, 23, 38, 25, 39, 27, 38, 27, 39, 28, 38, 29, 38, 29, 39,
+      4, 40, 4, 41, 6, 40, 9, 41, 13, 41, 15, 41, 19, 41, 23, 41, 25, 41, 29, 41,
+      31, 41, 33, 41, 35, 41, 36, 41, 37, 41, 40, 36, 39, 41, 4, 42, 4, 43, 5, 42,
+      6, 43, 7, 42, 17, 43, 27, 43, 30, 43, 31, 42, 31, 43, 32, 43, 33, 42, 42, 32,
+      36, 43, 37, 42, 37, 43, 42, 36, 39, 42, 39, 43, 42, 38, 7, 45, 9, 45, 11, 45,
+      21, 45, 31, 45, 44, 32, 36, 44, 36, 45, 39, 45, 44, 38, 4, 46, 4, 47, 5, 46,
+      6, 47, 7, 46, 46, 6, 13, 47, 19, 47, 23, 47, 31, 46, 46, 30, 32, 47, 33, 47,
+      34, 47, 35, 47, 36, 46, 36, 47, 37, 46, 37, 47, 46, 36, 38, 47, 39, 47, 4, 49,
+      48, 4, 6, 49, 48, 6, 15, 48, 19, 48, 19, 49, 25, 48, 28, 49, 29, 48, 29, 49,
+      31, 49, 33, 48, 35, 48, 36, 49, 39, 48, 48, 38, 2, 50, 2, 51, 6, 50, 7, 51,
+      9, 51, 13, 51, 19, 51, 21, 51, 23, 51, 25, 51, 26, 51, 50, 26, 31, 51, 35, 51,
+      39, 51, 47, 51, 48, 51, 2, 53, 3, 52, 6, 52, 6, 53, 17, 53, 22, 52, 23, 52,
+      23, 53, 26, 53, 27, 53, 37, 53, 45, 53, 3, 55, 7, 55, 9, 55, 11, 55, 21, 55,
+      22, 55, 23, 55, 26, 54, 26, 55, 31, 55, 43, 55, 53, 55, 2, 56, 3, 56, 6, 57,
+      7, 56, 56, 6, 11, 57, 15, 57, 19, 57, 21, 56, 56, 20, 23, 57, 24, 57, 25, 56,
+      25, 57, 26, 56, 27, 56, 27, 57, 56, 26, 33, 57, 41, 57, 2, 59, 3, 59, 58, 2,
+      6, 59, 7, 58, 7, 59, 58, 6, 13, 59, 17, 59, 19, 59, 58, 20, 25, 59, 26, 59,
+      27, 59, 58, 28, 35, 58, 58, 34, 38, 58, 38, 59, 39, 58, 43, 59, 47, 59, 2, 60,
+      4, 60, 4, 61, 5, 61, 60, 4, 9, 61, 10, 61, 11, 61, 13, 61, 15, 61, 16, 61,
+      17, 61, 18, 61, 19, 61, 23, 61, 27, 61, 33, 61, 39, 61, 43, 61, 47, 61, 48, 61,
+      60, 52, 57, 61, 58, 61, 2, 63, 4, 62, 4, 63, 12, 63, 13, 62, 17, 63, 19, 63,
+      27, 63, 37, 63, 45, 63, 55, 63, 3, 65, 5, 65, 9, 65, 11, 65, 16, 64, 16, 65,
+      18, 65, 21, 65, 31, 65, 43, 65, 53, 65, 57, 65, 63, 65, 2, 66, 2, 67, 3, 66,
+      3, 67, 66, 2, 4, 67, 5, 66, 66, 4, 10, 67, 11, 66, 66, 10, 13, 67, 14, 67,
+      15, 67, 16, 66, 17, 66, 17, 67, 66, 16, 18, 66, 19, 66, 19, 67, 66, 18, 25, 67,
+      35, 67, 41, 67, 51, 67, 57, 67, 3, 69, 68, 2, 4, 68, 4, 69, 5, 68, 68, 4,
+      11, 69, 16, 69, 17, 68, 17, 69, 68, 16, 18, 68, 18, 69, 68, 18, 23, 69, 27, 69,
+      68, 32, 37, 69, 39, 68, 43, 69, 47, 69, 57, 69, 58, 68, 70, 68, 9, 73, 37, 73,
+      41, 73, 45, 73, 51, 73, 55, 73, 61, 73, 65, 73, 74, 2, 74, 4, 74, 16, 74, 18,
+      33, 75, 41, 75, 74, 46, 48, 75, 51, 75, 58, 75, 67, 75, 8, 77, 9, 77, 76, 8,
+      17, 77, 35, 77, 51, 77, 61, 77, 68, 77, 69, 77, 76, 68, 78, 2, 8, 79, 9, 78,
+      9, 79, 78, 8, 17, 79, 78, 16, 31, 79, 63, 79, 9, 80, 17, 80, 48, 81, 51, 81,
+      6, 83, 7, 83, 17, 83, 68, 83, 75, 83, 7, 85, 21, 85, 6, 87, 17, 87, 27, 87,
+      37, 87, 61, 87, 65, 87, 67, 87, 69, 87, 6, 89, 7, 88, 88, 6, 23, 89, 88, 22,
+      25, 88, 33, 89, 61, 89, 90, 74, 9, 93, 15, 93, 9, 94, 9, 95, 15, 95, 94, 14,
+      23, 95, 9, 97, 25, 97, 31, 97, 51, 97, 9, 99, 98, 14, 21, 99, 35, 99, 45, 98,
+      47, 99, 98, 46, 69, 99, 7, 103, 33, 103, 35, 103, 37, 103, 39, 103, 51, 103, 61, 103,
+      6, 105, 21, 104, 27, 104, 27, 105, 104, 26, 31, 104, 37, 105, 104, 36, 55, 105, 65, 105,
+      69, 105, 108, 68, 112, 4, 13, 113, 33, 113, 58, 112, 61, 115, 97, 115, 103, 115, 116, 4,
+      8, 117, 9, 117, 57, 117, 116, 56, 63, 117, 13, 118, 13, 119, 55, 119, 61, 121, 98, 121,
+      122, 2, 23, 125, 61, 125, 6, 127, 126, 6, 21, 126, 27, 127, 37, 126, 37, 127, 126, 36,
+      65, 127, 77, 127, 126, 78, 128, 20, 77, 131, 9, 133, 11, 133, 132, 10, 79, 133, 88, 133,
+      8, 135, 9, 134, 9, 135, 134, 8, 11, 135, 43, 135, 134, 42, 53, 135, 61, 135, 63, 135,
+      73, 135, 87, 135, 134, 86, 134, 88, 136, 4, 136, 6, 9, 136, 9, 137, 136, 8, 47, 137,
+      53, 136, 55, 136, 57, 137, 61, 137, 63, 137, 69, 137, 136, 68, 75, 137, 89, 137, 105, 137,
+      127, 137, 9, 139, 138, 8, 11, 138, 11, 139, 88, 139, 21, 141, 31, 141, 43, 141, 63, 141,
+      73, 141, 133, 141, 7, 143, 25, 143, 27, 143, 35, 143, 39, 143, 47, 143, 67, 143, 75, 143,
+      78, 143, 79, 143, 95, 143, 97, 143, 101, 143, 131, 143, 6, 145, 7, 144, 7, 145, 144, 6,
+      73, 145, 144, 78, 143, 145, 146, 4, 7, 146, 146, 6, 27, 146, 27, 147, 69, 147, 135, 147,
+      7, 148, 148, 6, 25, 149, 61, 149, 81, 149, 101, 149, 131, 149, 150, 90, 9, 153, 143, 153,
+      9, 154, 154, 62, 61, 157, 68, 157, 156, 68, 9, 159, 158, 8, 61, 158, 68, 158, 83, 158,
+      143, 159, 149, 159, 68, 161, 151, 161, 158, 161, 7, 162, 21, 164, 28, 164, 31, 164, 38, 164,
+      164, 134, 166, 6, 68, 167, 166, 72, 158, 167, 9, 169, 168, 166, 170, 48, 174, 58, 158, 177,
+      15, 178, 19, 178, 180, 14, 9, 186, 188, 8, 9, 192, 192, 68, 68, 195, 194, 68, 104, 197,
+      202, 78, 9, 211, 210, 8, 216, 58, 41, 226, 48, 226, 143, 229, 149, 229, 41, 230, 51, 230,
+      61, 231, 178, 235, 9, 236, 236, 42, 236, 86, 236, 164, 238, 58, 178, 241, 19, 243, 159, 243,
+      186, 243, 192, 243, 211, 243, 213, 243, 229, 243, 5, 244, 19, 249, 149, 249, 159, 249, 186, 249,
+      192, 249, 211, 249, 143, 257, 149, 257, 243, 257, 249, 257, 68, 261, 260, 180, 9, 263, 262, 8,
+      61, 262, 68, 262, 83, 262, 143, 263, 149, 263, 177, 262, 243, 263, 249, 263, 19, 264, 264, 36,
+      38, 264, 268, 4, 143, 271, 149, 271, 272, 58, 9, 280, 9, 283, 41, 282, 48, 282, 51, 282,
+      58, 282, 61, 282, 68, 282, 282, 166, 9, 285, 286, 58, 290, 68, 292, 58, 158, 295, 262, 295,
+      296, 38, 19, 300, 300, 36, 97, 300, 300, 134, 199, 300, 223, 300, 300, 236, 252, 300, 302, 36,
+      302, 222, 246, 304, 9, 308, 308, 68, 243, 308, 249, 308, 310, 58, 104, 312, 314, 58, 68, 317,
+      316, 68, 126, 319, 320, 68, 322, 8, 326, 6, 326, 210, 330, 204, 246, 331, 330, 248, 332, 48,
+      126, 335, 334, 128, 143, 339, 149, 339, 41, 341, 48, 341, 346, 8, 348, 58, 350, 4, 350, 252,
+      178, 353, 352, 180, 41, 354, 41, 356, 51, 356, 61, 357, 41, 359, 48, 359, 104, 361, 360, 106,
+      362, 106, 364, 8, 300, 367, 300, 369, 9, 370, 370, 42, 370, 86, 370, 300, 41, 373, 48, 373,
+      372, 48, 41, 374, 48, 374, 300, 375, 376, 104, 376, 178, 376, 264, 376, 300, 19, 379, 21, 379,
+      31, 379, 48, 379, 101, 379, 103, 379, 159, 379, 182, 379, 185, 379, 192, 379, 207, 379, 263, 379,
+      267, 379, 271, 379, 277, 379, 301, 379, 308, 379, 339, 379, 369, 379, 374, 379, 3, 380, 379, 381,
+      186, 382, 211, 382, 19, 385, 31, 385, 48, 385, 93, 385, 101, 385, 103, 385, 153, 385, 159, 385,
+      173, 385, 185, 385, 192, 385, 207, 385, 384, 210, 384, 254, 263, 385, 267, 385, 271, 385, 279, 385,
+      308, 385, 339, 385, 343, 385, 374, 385, 41, 387, 178, 388, 388, 220, 390, 248, 243, 393, 126, 396,
+      398, 128, 400, 8, 400, 148, 379, 403, 385, 403, 404, 302, 379, 405, 385, 405, 143, 407, 149, 407,
+      243, 407, 249, 407, 9, 409, 408, 8, 61, 408, 68, 408, 83, 408, 143, 409, 149, 409, 177, 408,
+      243, 409, 249, 409, 295, 408, 379, 409, 385, 409, 19, 414, 28, 414, 414, 134, 414, 236, 414, 370,
+      413, 415, 418, 2, 143, 418, 243, 418, 422, 48, 51, 425, 41, 426, 48, 426, 9, 429, 379, 429,
+      411, 429, 418, 429, 385, 431, 9, 432, 9, 435, 41, 434, 48, 434, 51, 434, 58, 434, 61, 434,
+      68, 434, 436, 48, 41, 440, 48, 440, 51, 443, 9, 445, 411, 445, 418, 445, 9, 446, 385, 449,
+      9, 451, 41, 450, 48, 450, 51, 450, 58, 450, 61, 450, 68, 450, 68, 453, 158, 453, 262, 453,
+      408, 453, 454, 270, 454, 338, 454, 344, 158, 457, 262, 457, 408, 457, 458, 134, 458, 154, 458, 236,
+      458, 370, 334, 460, 373, 460, 397, 460, 35, 462, 39, 462, 239, 462, 313, 462, 360, 462, 25, 464,
+      29, 464, 35, 464, 39, 464, 464, 78, 354, 466, 387, 466, 19, 468, 39, 468, 307, 468, 328, 468,
+      385, 468, 19, 470, 39, 470, 379, 472, 385, 472, 75, 474, 224, 474, 251, 474, 15, 476, 19, 476,
+      171, 476, 191, 476, 208, 476, 478, 218, 478, 300, 15, 484, 19, 484, 25, 484, 29, 484, 486, 134,
+      486, 236, 486, 370, 224, 489, 239, 489, 274, 489, 313, 489, 360, 489, 379, 491, 385, 491, 307, 493,
+      328, 493, 35, 497, 39, 497, 39, 499, 385, 499, 379, 503, 385, 503, 61, 511, 512, 298, 512, 414,
+      514, 416, 13, 517, 287, 517, 367, 517, 518, 298, 379, 521, 51, 525, 61, 525, 385, 525, 528, 134,
+      528, 154, 528, 236, 528, 370, 517, 535, 517, 541, 379, 543, 501, 545, 7, 550, 51, 553, 462, 553,
+      464, 553, 497, 553, 507, 553, 549, 553, 5, 554, 51, 557, 385, 557, 462, 557, 464, 557, 497, 557,
+      564, 478, 385, 567, 462, 573, 497, 573, 578, 300, 580, 300, 472, 584, 51, 587, 61, 587, 143, 588,
+      243, 588, 68, 591, 545, 591, 592, 6, 68, 593, 545, 595, 596, 4, 39, 598, 600, 154, 151, 603,
+      39, 604, 537, 611, 379, 613, 75, 614, 171, 616, 379, 619, 15, 620, 25, 620, 51, 620, 61, 620,
+      61, 623, 259, 623, 395, 623, 561, 623, 68, 625, 158, 625, 262, 625, 408, 625, 626, 420, 626, 438,
+      158, 629, 262, 629, 408, 629, 630, 46, 630, 56, 630, 162, 632, 134, 632, 154, 632, 236, 632, 370,
+      636, 78, 553, 636, 557, 636, 574, 640, 535, 642, 243, 648, 67, 650, 77, 650, 195, 650, 317, 650,
+      533, 650, 562, 650, 650, 608, 652, 42, 48, 652, 103, 652, 201, 652, 491, 652, 495, 652, 313, 654,
+      360, 654, 39, 656, 334, 659, 373, 659, 397, 659, 662, 512, 33, 665, 191, 665, 208, 665, 569, 665,
+      614, 665, 670, 36, 670, 218, 15, 677, 171, 677, 570, 677, 67, 679, 77, 679, 195, 679, 317, 679,
+      533, 679, 562, 679, 669, 679, 334, 681, 397, 681, 243, 683, 484, 683, 665, 685, 686, 134, 686, 154,
+      686, 236, 686, 370, 476, 691, 677, 691, 694, 522, 61, 701, 468, 701, 499, 701, 700, 606, 313, 703,
+      360, 703, 704, 6, 379, 707, 385, 707, 652, 707, 7, 708, 51, 711, 143, 711, 464, 711, 636, 711,
+      3, 712, 51, 715, 143, 715, 149, 715, 464, 715, 636, 715, 623, 721, 722, 644, 379, 725, 517, 726,
+      143, 729, 379, 731, 474, 732, 736, 630, 584, 739, 583, 740, 638, 740, 61, 742, 468, 742, 499, 742,
+      334, 744, 397, 744, 249, 749, 750, 6, 68, 751, 754, 46, 753, 755, 468, 757, 499, 757, 557, 757,
+      758, 2, 39, 763, 151, 765, 61, 766, 61, 769, 243, 771, 39, 773, 61, 775, 259, 775, 395, 775,
+      561, 775, 721, 775, 776, 508, 776, 564, 647, 781, 782, 532, 784, 468, 39, 789, 557, 789, 158, 791,
+      262, 791, 408, 791, 158, 793, 262, 793, 408, 793, 796, 66, 796, 178, 796, 264, 798, 504, 800, 134,
+      800, 154, 800, 236, 800, 370, 802, 68, 804, 66, 135, 804, 237, 804, 371, 804, 804, 416, 577, 804,
+      623, 804, 735, 804, 775, 804, 570, 806, 691, 806, 808, 98, 535, 808, 808, 684, 726, 808, 810, 66,
+      814, 66, 689, 818, 718, 818, 820, 568, 822, 42, 57, 822, 822, 502, 531, 822, 558, 822, 822, 674,
+      737, 822, 824, 42, 48, 824, 103, 824, 201, 824, 491, 824, 495, 824, 707, 824, 826, 32, 307, 828,
+      328, 828, 39, 830, 832, 570, 33, 834, 191, 834, 208, 834, 836, 508, 354, 839, 387, 839, 840, 512,
+      35, 843, 224, 843, 251, 843, 616, 843, 642, 845, 846, 126, 75, 849, 574, 849, 732, 849, 151, 851,
+      689, 853, 718, 853, 57, 855, 531, 855, 558, 855, 737, 855, 354, 857, 387, 857, 35, 859, 224, 859,
+      251, 859, 143, 861, 484, 861, 843, 863, 864, 134, 864, 154, 864, 236, 864, 370, 474, 867, 640, 867,
+      849, 867, 143, 871, 483, 873, 647, 873, 851, 873, 634, 875, 667, 875, 51, 877, 462, 877, 497, 877,
+      307, 879, 328, 879, 33, 881, 191, 881, 208, 881, 882, 570, 884, 4, 652, 887, 824, 887, 808, 889,
+      816, 889, 5, 890, 892, 480, 808, 895, 816, 895, 61, 897, 243, 897, 816, 897, 3, 898, 61, 901,
+      243, 901, 468, 901, 499, 901, 816, 901, 904, 810, 904, 814, 61, 907, 517, 908, 642, 908, 243, 911,
+      476, 912, 677, 912, 804, 915, 650, 917, 679, 917, 916, 796, 916, 810, 61, 919, 249, 919, 557, 919,
+      584, 919, 740, 919, 61, 920, 583, 920, 739, 920, 804, 920, 804, 921, 924, 814, 61, 927, 61, 928,
+      634, 930, 667, 930, 51, 932, 462, 932, 497, 932, 354, 934, 387, 934, 35, 936, 224, 936, 251, 936,
+      938, 582, 149, 941, 919, 941, 942, 4, 947, 949, 950, 2, 763, 953, 769, 953, 789, 953, 919, 953,
+      143, 955, 39, 959, 161, 965, 157, 969, 195, 969, 763, 969, 769, 969, 789, 969, 957, 969, 39, 971,
+      591, 971, 157, 975, 157, 979, 763, 979, 769, 979, 789, 979, 957, 979, 39, 981, 591, 981, 157, 983,
+      988, 78, 135, 988, 237, 988, 371, 988, 407, 988, 988, 538, 988, 696, 988, 868, 41, 991, 48, 991,
+      379, 992, 379, 995, 243, 996, 243, 999, 143, 1000, 143, 1003, 1004, 488, 1006, 658, 83, 1009, 143, 1011,
+      243, 1011, 379, 1011, 41, 1012, 48, 1012, 33, 1014, 685, 1014, 385, 1017, 789, 1017, 33, 1018, 527, 1020,
+      1022, 46, 143, 1024, 1026, 6, 1028, 962, 1030, 132, 9, 1033, 1032, 8, 243, 1033, 249, 1033, 379, 1033,
+      385, 1033, 51, 1034, 35, 1036, 645, 1038, 957, 1043, 143, 1046, 379, 1046, 67, 1049, 283, 1049, 435, 1049,
+      451, 1049, 1050, 810, 133, 1052, 1052, 810, 73, 1055, 1054, 132, 763, 1055, 769, 1055, 789, 1055, 919, 1055,
+      9, 1057, 1056, 8, 9, 1058, 143, 1059, 51, 1061, 645, 1063, 1064, 154, 161, 1067, 1068, 796, 1070, 178,
+      1072, 18, 1072, 716, 1074, 88, 1074, 126, 1076, 74, 1080, 16, 61, 1083, 1084, 812, 137, 1087, 553, 1089,
+      557, 1089, 711, 1089, 715, 1089, 33, 1091, 685, 1091, 1090, 854, 23, 1093, 527, 1093, 1092, 852, 1094, 156,
+      137, 1097, 1098, 582, 957, 1101, 143, 1103, 761, 1103, 787, 1103, 1104, 810, 83, 1107, 149, 1107, 919, 1107,
+      379, 1108, 1110, 794, 379, 1113, 243, 1114, 1114, 672, 137, 1116, 1120, 36, 243, 1122, 1124, 126, 1126, 124,
+      1126, 546, 1126, 660, 1128, 58, 9, 1131, 1132, 58, 31, 1134, 143, 1136, 379, 1136, 9, 1138, 493, 1140,
+      1142, 796, 61, 1145, 143, 1147, 379, 1147, 9, 1149, 61, 1151, 489, 1153, 489, 1154, 897, 1154, 945, 1157,
+      1158, 794, 665, 1160, 843, 1162, 1164, 8, 51, 1166, 61, 1166, 39, 1168, 39, 1170, 507, 1170, 462, 1173,
+      497, 1173, 1174, 796, 31, 1176, 197, 1179, 197, 1180, 897, 1180, 27, 1182, 381, 1185, 39, 1189, 39, 1191,
+      507, 1191, 945, 1193, 41, 1197, 48, 1197, 1198, 48, 1200, 48, 761, 1203, 787, 1203, 747, 1204, 1206, 8,
+      379, 1208, 51, 1210, 1212, 336, 1214, 154, 659, 1217, 659, 1218, 889, 1218, 747, 1221, 9, 1223, 61, 1225,
+      61, 1227, 1228, 98, 61, 1231, 39, 1232, 1234, 324, 693, 1236, 143, 1239, 157, 1239, 77, 1241, 83, 1241,
+      195, 1241, 317, 1241, 453, 1241, 625, 1241, 37, 1242, 51, 1245, 121, 1245, 21, 1246, 319, 1249, 319, 1250,
+      889, 1250, 693, 1253, 1254, 6, 9, 1261, 1260, 8, 11, 1262, 79, 1262, 1262, 134, 9, 1264, 161, 1267,
+      9, 1268, 1270, 134, 31, 1273, 47, 1273, 73, 1273, 111, 1273, 133, 1273, 145, 1273, 169, 1273, 211, 1273,
+      215, 1273, 285, 1273, 289, 1273, 565, 1273, 915, 1273, 804, 1275, 73, 1276, 169, 1276, 285, 1276, 31, 1279,
+      41, 1279, 51, 1279, 61, 1279, 133, 1279, 143, 1279, 211, 1279, 61, 1280, 301, 1283, 179, 1287, 11, 1288,
+      903, 1288, 89, 1291, 9, 1292, 67, 1295, 133, 1298, 9, 1301, 1302, 8, 650, 1305, 679, 1305, 1304, 796,
+      1306, 814, 1308, 6, 261, 1309, 591, 1309, 665, 1310, 493, 1313, 665, 1315, 493, 1316, 89, 1318, 11, 1321,
+      903, 1321, 11, 1323, 9, 1327, 61, 1328, 261, 1331, 405, 1333, 11, 1334, 83, 1339, 9, 1340, 143, 1341,
+      665, 1345, 493, 1347, 39, 1349, 75, 1351, 61, 1353, 1354, 802, 1356, 56, 1356, 144, 97, 1358, 199, 1358,
+      301, 1358, 367, 1358, 381, 1358, 713, 1358, 899, 1358, 1360, 16, 179, 1362, 47, 1364, 39, 1366, 75, 1368,
+      67, 1370, 1372, 144, 1374, 16, 25, 1378, 245, 1382, 555, 1382, 891, 1382, 143, 1385, 497, 1385, 804, 1387,
+      1388, 816, 143, 1391, 497, 1391, 379, 1392, 143, 1394, 1396, 78, 39, 1399, 650, 1401, 679, 1401, 1400, 796,
+      39, 1403, 1404, 796, 233, 1407, 699, 1407, 11, 1409, 245, 1411, 555, 1411, 891, 1411, 61, 1413};
+  // clang-format off
+}; // namespace mockturtle
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/xmg3_npn.hpp b/include/mockturtle/algorithms/node_resynthesis/xmg3_npn.hpp
new file mode 100644
index 0000000..c14b780
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/xmg3_npn.hpp
@@ -0,0 +1,347 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xmg3_npn.hpp
+  \brief Replace with size-optimum xmg3s and AIGs from NPN (from ABC rewrite)
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Shubham Rai
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <vector>
+
+#include <fmt/format.h>
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/npn.hpp>
+#include <kitty/print.hpp>
+#include <kitty/static_truth_table.hpp>
+
+#include "../../algorithms/simulation.hpp"
+#include "../../io/write_bench.hpp"
+#include "../../networks/xmg.hpp"
+#include "../../utils/node_map.hpp"
+#include "../../utils/stopwatch.hpp"
+#include "../../views/topo_view.hpp"
+
+namespace mockturtle
+{
+
+struct xmg3_npn_resynthesis_params
+{
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+};
+
+struct xmg3_npn_resynthesis_stats
+{
+  stopwatch<>::duration time_classes{ 0 };
+  stopwatch<>::duration time_db{ 0 };
+
+  uint32_t db_size;
+  uint32_t covered_classes;
+
+  void report() const
+  {
+    std::cout << fmt::format( "[i] build classes time = {:>5.2f} secs\n", to_seconds( time_classes ) );
+    std::cout << fmt::format( "[i] build db time      = {:>5.2f} secs\n", to_seconds( time_db ) );
+  }
+};
+
+/*! \brief Resynthesis function based on pre-computed AIGs.
+ *
+ * This resynthesis function can be passed to ``cut_rewriting``.  It will
+ * produce a network based on pre-computed xmg3s with up to at most 4 variables.
+ * Consequently, the nodes' fan-in sizes in the input network must not exceed
+ * 4.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      const aig_network aig = ...;
+      xmg3_npn_resynthesis<aig_network> resyn;
+      aig = cut_rewriting( aig, resyn );
+
+   .. note::
+
+      The implementation of this algorithm was heavily inspired by the rewrite
+      command in AIG.  It uses the same underlying database of subcircuits.
+   \endverbatim
+ */
+template<class Ntk, class DatabaseNtk = xmg_network>
+class xmg3_npn_resynthesis
+{
+public:
+  xmg3_npn_resynthesis( xmg3_npn_resynthesis_params const& ps = {}, xmg3_npn_resynthesis_stats* pst = nullptr )
+      : ps( ps ),
+        pst( pst ),
+        _classes( 1 << 16 )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+    static_assert( has_create_and_v<Ntk>, "Ntk does not implement the create_and method" );
+    static_assert( has_create_xor_v<Ntk>, "Ntk does not implement the create_xor method" );
+    static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+
+    static_assert( is_network_type_v<DatabaseNtk>, "DatabaseNtk is not a network type" );
+    static_assert( has_get_node_v<DatabaseNtk>, "DatabaseNtk does not implement the get_node method" );
+    static_assert( has_is_complemented_v<DatabaseNtk>, "DatabaseNtk does not implement the is_complemented method" );
+    static_assert( has_is_xor_v<DatabaseNtk>, "DatabaseNtk does not implement the is_xor method" );
+    static_assert( has_size_v<DatabaseNtk>, "DatabaseNtk does not implement the size method" );
+    static_assert( has_create_pi_v<DatabaseNtk>, "DatabaseNtk does not implement the create_pi method" );
+    static_assert( has_create_and_v<DatabaseNtk>, "DatabaseNtk does not implement the create_and method" );
+    static_assert( has_create_xor_v<DatabaseNtk>, "DatabaseNtk does not implement the create_xor method" );
+    static_assert( has_foreach_fanin_v<DatabaseNtk>, "DatabaseNtk does not implement the foreach_fanin method" );
+    static_assert( has_foreach_node_v<DatabaseNtk>, "DatabaseNtk does not implement the foreach_node method" );
+    static_assert( has_make_signal_v<DatabaseNtk>, "DatabaseNtk does not implement the make_signal method" );
+
+    _repr.reserve( 222u );
+    build_classes();
+    build_db();
+  }
+
+  virtual ~xmg3_npn_resynthesis()
+  {
+    if ( ps.verbose )
+    {
+      st.report();
+    }
+
+    if ( pst )
+    {
+      *pst = st;
+    }
+  }
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( Ntk& ntk, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    kitty::static_truth_table<4u> tt = kitty::extend_to<4u>( function );
+
+    /* get representative of function */
+    const auto repr = _repr[_classes[*tt.cbegin()]];
+
+    /* check if representative has circuits */
+    const auto it = _repr_to_signal.find( repr );
+    if ( it == _repr_to_signal.end() )
+    {
+      return;
+    }
+
+    const auto config = kitty::exact_npn_canonization( tt );
+
+    assert( repr == std::get<0>( config ) );
+
+    std::vector<signal<Ntk>> pis( 4, ntk.get_constant( false ) );
+    std::copy( begin, end, pis.begin() );
+
+    std::vector<signal<Ntk>> pis_perm;
+    auto perm = std::get<2>( config );
+    for ( auto i = 0; i < 4; ++i )
+    {
+      pis_perm.push_back( pis[perm[i]] );
+    }
+
+    const auto& phase = std::get<1>( config );
+    for ( auto i = 0; i < 4; ++i )
+    {
+      if ( ( phase >> perm[i] ) & 1 )
+      {
+        pis_perm[i] = ntk.create_not( pis_perm[i] );
+      }
+    }
+
+    for ( auto const& cand : it->second )
+    {
+      std::unordered_map<node<DatabaseNtk>, signal<Ntk>> db_to_ntk;
+
+      db_to_ntk.insert( { 0, ntk.get_constant( false ) } );
+      for ( auto i = 0; i < 4; ++i )
+      {
+        db_to_ntk.insert( { i + 1, pis_perm[i] } );
+      }
+      auto f = copy_db_entry( ntk, _db.get_node( cand ), db_to_ntk );
+      if ( _db.is_complemented( cand ) != ( ( phase >> 4 ) & 1 ) )
+      {
+        f = ntk.create_not( f );
+      }
+      if ( !fn( f ) )
+      {
+        return;
+      }
+    }
+  }
+
+private:
+  signal<Ntk>
+  copy_db_entry( Ntk& ntk, node<DatabaseNtk> const& n, std::unordered_map<node<DatabaseNtk>, signal<Ntk>>& db_to_ntk ) const
+  {
+    if ( const auto it = db_to_ntk.find( n ); it != db_to_ntk.end() )
+    {
+      return it->second;
+    }
+
+    std::vector<signal<Ntk>> fanin;
+    // std::array<signal<Ntk>, 2> fanin;
+    _db.foreach_fanin( n, [&]( auto const& f ) {
+      auto ntk_f = copy_db_entry( ntk, _db.get_node( f ), db_to_ntk );
+      if ( _db.is_complemented( f ) )
+      {
+        ntk_f = ntk.create_not( ntk_f );
+      }
+      fanin.push_back( ntk_f );
+    } );
+
+    const auto f = _db.is_xor3( n ) ? ntk.create_xor3( fanin[0], fanin[1], fanin[2] ) : ntk.create_maj( fanin[0], fanin[1], fanin[2] );
+    db_to_ntk.insert( { n, f } );
+    return f;
+  }
+
+  void build_classes()
+  {
+    stopwatch t( st.time_classes );
+
+    kitty::dynamic_truth_table map( 16u );
+    std::transform( map.cbegin(), map.cend(), map.begin(), []( auto word ) { return ~word; } );
+
+    int64_t index = 0;
+    kitty::static_truth_table<4u> tt;
+    while ( index != -1 )
+    {
+      kitty::create_from_words( tt, &index, &index + 1 );
+      const auto res = kitty::exact_npn_canonization( tt, [&]( const auto& tt ) {
+        _classes[*tt.cbegin()] = _repr.size();
+        kitty::clear_bit( map, *tt.cbegin() );
+      } );
+      _repr.push_back( std::get<0>( res ) );
+
+      /* find next non-classified truth table */
+      index = find_first_one_bit( map );
+    }
+  }
+
+  void build_db()
+  {
+    stopwatch t( st.time_db );
+
+    _db.get_constant( false );
+    /* four primary inputs */
+    _db.create_pi();
+    _db.create_pi();
+    _db.create_pi();
+    _db.create_pi();
+
+    auto* p = subgraphs;
+    while ( true )
+    {
+      auto entry0 = *p++;
+      auto entry1 = *p++;
+      auto entry2 = *p++;
+
+      if ( entry0 == 0 && entry1 == 0 && entry2 == 0 )
+        break;
+
+      auto is_xor = entry0 & 1;
+      entry0 >>= 1;
+
+      const auto child0 = _db.make_signal( entry0 >> 1 ) ^ ( entry0 & 1 );
+      const auto child1 = _db.make_signal( entry1 >> 1 ) ^ ( entry1 & 1 );
+      const auto child2 = _db.make_signal( entry2 >> 1 ) ^ ( entry2 & 1 );
+
+      if ( is_xor )
+      {
+        _db.create_xor3( child0, child1, child2 );
+      }
+      else
+      {
+        _db.create_maj( child0, child1, child2 );
+      }
+    }
+
+    const auto sim_res = simulate_nodes<kitty::static_truth_table<4u>>( _db );
+
+    _db.foreach_node( [&]( auto n ) {
+      if ( _repr[_classes[*sim_res[n].cbegin()]] == sim_res[n] )
+      {
+        if ( _repr_to_signal.count( sim_res[n] ) == 0 )
+        {
+          _repr_to_signal.insert( { sim_res[n], { _db.make_signal( n ) } } );
+        }
+        else
+        {
+          _repr_to_signal[sim_res[n]].push_back( _db.make_signal( n ) );
+        }
+      }
+      else
+      {
+        const auto f = ~sim_res[n];
+        if ( _repr[_classes[*f.cbegin()]] == f )
+        {
+          if ( _repr_to_signal.count( f ) == 0 )
+          {
+            _repr_to_signal.insert( { f, { !_db.make_signal( n ) } } );
+          }
+          else
+          {
+            _repr_to_signal[f].push_back( !_db.make_signal( n ) );
+          }
+        }
+      }
+    } );
+
+    st.db_size = _db.size();
+    st.covered_classes = static_cast<uint32_t>( _repr_to_signal.size() );
+  }
+
+  xmg3_npn_resynthesis_params ps;
+  xmg3_npn_resynthesis_stats st;
+  xmg3_npn_resynthesis_stats* pst{ nullptr };
+
+  std::vector<kitty::static_truth_table<4u>> _repr;
+  std::vector<uint32_t> _classes;
+  std::unordered_map<kitty::static_truth_table<4u>, std::vector<signal<DatabaseNtk>>, kitty::hash<kitty::static_truth_table<4u>>> _repr_to_signal;
+
+  DatabaseNtk _db;
+
+  // clang-format off
+  inline static const uint16_t subgraphs[]
+  {
+      0x2,0x2,0x4,0xc,0x8,0xb,0x2,0xa,0xc,0x8,0x7,0x8,0x2,0x6,0x10,0x2,0x6,0x8,0x29,0x4,0x2,0x0,0x15,0x16,0x0,0x3,0x4,0x8,0x14,0x1b,0x8,0x7,0x1a,0x3d,0x6,0x2,0x0,0x9,0x20,0x4,0x4,0x6,0x2,0x8,0x24,0x49,0x6,0x0,0x0,0x9,0x28,0xa,0x6,0xa,0x0,0x2,0x2d,0x10,0xa,0x2f,0x6,0x4,0x8,0x4,0x6,0x8,0x2,0x32,0x34,0x15,0x6,0x0,0x0,0x9,0x38,0x4,0x4,0x9,0x0,0x7,0x3c,0x10,0x3c,0x3f,0x11,0x6,0x4,0x0,0x9,0x42,0x0,0x6,0x9,0x8d,0x4,0x0,0x10,0xa,0x49,0x0,0x4,0x7,0x8,0x8,0x4d,0xd,0x4,0x2,0x2,0x8,0x50,0x0,0x2,0x15,0x10,0x16,0x55,0x11,0x4,0x2,0x0,0x6,0x59,0x2,0x8,0x5a,0x4,0x4,0x7,0xbd,0x8,0x6,0x0,0x9,0x60,0x4,0x4,0x8,0x0,0x6,0x65,0xc,0x8,0x67,0x4,0x6,0x51,0xd5,0x50,0x8,0x0,0x6b,0x6c,0x2,0x4,0x6,0x8,0x8,0x70,0x4,0x14,0x72,0x6,0x4,0x6,0x4,0x8,0x76,0xed,0x8,0x4,0x0,0x79,0x7a,0x69,0x4,0x2,0x2,0x34,0x7e,0x11,0x6,0x2,0x8,0x6,0x8,0x0,0x82,0x85,0x0,0x2,0x35,0x8,0x34,0x89,0x0,0x5,0x82,0xc,0x8,0x8d,0x8,0x8c,0x8f,0xc,0x8,0xa,0x85,0x6,0x2,0xc,0x8,0x95,0x0,0x42,0x97,0x0,0x2,0x5,0x135,0x6,0x0,0x2,0x84,0x9c,0x0,0x2,0x9,0xc,0x64,0xa1,0x4,0x7,0x42,0x6,0x44,0xa4,0x10,0xa,0x43,0x85,0x4,0x2,0x0,0x7,0xaa,0x12,0x42,0xac,0x0,0x2,0x8,0x2,0x84,0xb0,0x0,0x3,0x6,0x169,0x8,0x2,0x0,0x51,0xb6,0x4,0x6,0x25,0x0,0x9,0x24,0x8,0xba,0xbd,0x109,0x8,0x2,0x0,0x8,0x84,0x0,0xc0,0xc3,0x10,0x50,0x70,0x0,0x7,0x42,0x12,0x58,0xc8,0xc,0x8,0x59,0x0,0x3,0x58,0x10,0xcc,0xcf,0x4,0x5,0x8,0x0,0x4,0xd3,0x4,0x7,0xd4,0x1ad,0x8,0x6,0xc,0x8,0x64,0x8,0x7,0x32,0x1b9,0x4,0x0,0x0,0x4,0x8,0x0,0x2,0xe1,0xa,0x6,0xe2,0x1c9,0x4,0x0,0x0,0x8,0xd2,0x4,0x6,0xe8,0x1d5,0xd2,0x0,0x0,0x2,0x59,0x8,0x6,0xef,0x1e1,0xee,0x0,0x0,0x2,0x4,0xc,0x58,0xf5,0x1ed,0x6,0x0,0x0,0x8,0x64,0x0,0x6,0xfa,0x1f9,0x64,0x6,0x2,0x2,0x6,0xa,0xa0,0x100,0x205,0x4,0x0,0x65,0x4,0x0,0x2,0x8,0x32,0xc,0x107,0x108,0xc9,0x8,0x0,0xc,0x8,0x10d,0x11,0x4,0x0,0x221,0x6,0x2,0x4,0x8,0x113,0x10,0x111,0x114,0x0,0x112,0x117,0xb1,0x6,0x0,0x10,0x100,0x11b,0x8,0x6,0x9b,0x23d,0x32,0x0,0x0,0x9,0x100,0x9,0x2,0x0,0x200,0x123,0x124,0x0,0x5,0x6,0x251,0x8,0x2,0x8,0x8,0x128,0x0,0x12a,0x12d,0x10,0x70,0x124,0x1a5,0x6,0x4,0x1a5,0x2,0x0,0x12,0x132,0x134,0x161,0x4,0x2,0xc,0x8,0x138,0x2,0xb0,0x13a,0x4,0x8,0x70,0x27d,0x8,0x0,0xe1,0x2,0x0,0x2,0x2,0x70,0x10,0x142,0x144,0x0,0x6,0x8,0x291,0x8,0x2,0x8,0x8,0x148,0x0,0x14a,0x14d,0x10,0x70,0x142,0x6,0x6,0x8,0x0,0x8,0x153,0x8,0x6,0x155,0x2ad,0x152,0x0,0x0,0x7,0xd2,0x2b5,0x152,0x0,0x11,0x2,0x0,0x12,0xc8,0x15e,0x0,0x6,0x1b,0x2c5,0x1a,0x2,0xc,0x8,0x164,0xc,0x9,0x32,0x2d1,0x4c,0x32,0x4,0x4,0x4d,0x99,0x6,0x2,0x10,0x16c,0x16e,0xc,0x9,0x128,0x4,0x4,0x173,0x2e9,0x128,0x8,0xa,0x6,0x15e,0xc,0x8,0x179,0x0,0x4,0x9,0x8,0x6,0x15e,0x2fd,0x8,0x0,0x2bc,0x17c,0x180,0xc9,0x50,0x0,0x10,0x50,0x184,0x0,0x3,0x84,0x311,0x8,0x2,0x6,0x6,0xa,0x10,0x38,0x18c,0x15,0x8,0x0,0x0,0x7,0x190,0x14,0x190,0x192,0xc,0x8,0x191,0x0,0x7,0xa,0x331,0x8,0x6,0x8,0x6,0x9,0x0,0x8,0x19d,0x33d,0x6,0x4,0x8,0x6,0x43,0x0,0x2,0x43,0x2,0x1a2,0x1a4,0x2,0x2,0x8,0x351,0x128,0x4,0x0,0x4,0x1a8,0xc,0x1a8,0x1ac,0x0,0x111,0x1a8,0x2,0x6,0x1b0,0x365,0x1a8,0x0,0x8,0x8,0x83,0x36d,0x9a,0x0,0x0,0x3,0x8,0x375,0x6,0x2,0x0,0x5,0x1bc,0x12,0x1bc,0x1be,0x289,0x6,0x2,0x10,0x70,0x1c2,0x8,0x8,0x1a9,0x2,0x6,0x1c6,0x391,0x1a8,0x0,0x0,0x2,0x6,0x10,0x70,0x1cc,0x4,0x6,0x10,0x0,0x9,0x1d0,0x3a5,0x10,0x4,0x141,0x6,0x4,0x2,0xe0,0x1d6,0xa,0x6,0x8,0x3b5,0xa0,0x6,0x8,0x9,0xa0,0x8,0x6,0x1df,0x3c1,0x1de,0xa0,0x399,0x8,0x4,0xe,0x46,0x1e4,0x2,0x6,0xa0,0x10,0x1d6,0x1e8,0x4,0x4,0x85,0x0,0x8,0x1ed,0x3dd,0x1ec,0x84,0x351,0x4,0x0,0xc,0x8,0x1f3,0x10,0x4c,0x65,0x3ed,0x64,0x6,0x86,0xe0,0x1a8,0xa,0x6,0xa0,0x3f9,0x8,0x4,0x21,0x4,0x0,0x4,0x6,0x11,0x20,0x201,0x202,0xd,0x4,0x0,0x2,0xe0,0x206,0x4,0x6,0x9,0x0,0x9,0x20a,0x419,0x84,0x0,0x4,0x4,0x111,0xc,0x8,0x210,0x425,0x210,0x110,0x1c0,0x100,0x206,0xc,0x8,0x111,0x8,0x6,0xa1,0x435,0x8,0x0,0xe,0xa0,0x1da,0x43d,0x8,0x0,0x4,0x7,0x128,0x2,0x8,0x222,0x449,0x128,0x4,0x10,0x24,0x206,0xc,0x64,0x9b,0x455,0x8,0x0,0x6,0x8,0x10,0x2,0xa,0x10,0x461,0x22e,0x4,0x0,0x2,0x207,0x469,0x4,0x2,0x10,0x206,0x236,0x251,0x8,0x4,0x0,0x3,0x23a,0x252,0x23a,0x23c,0x291,0x8,0x4,0x14,0x148,0x241,0x2,0x8,0xd2,0x489,0x70,0x0,0x99,0x8,0x6,0x4,0x4,0x82,0x495,0x2,0x0,0x4,0x4,0x83,0x0,0x5,0x8,0x104,0x24f,0x250,0x4a5,0x4,0x0,0x11,0x6,0x0,0x4ad,0x4,0x2,0xc,0x8,0x258,0x134,0x256,0x25b,0x8,0x7,0x46,0x4bd,0x152,0x0,0x0,0x7,0x8,0x12,0x124,0x262,0x4,0x8,0x47,0xc,0x125,0x266,0x2bd,0x6,0x4,0xc,0x47,0x26a,0x8,0x6,0x15f,0x2,0x6,0x26e,0x10,0x26a,0x270,0xc,0x8,0x125,0x2,0x4,0x8,0x248,0x256,0x277,0x2a5,0x4,0x0,0x8,0x6,0x153,0x10,0x27a,0x27c,0x4a,0x46,0x124,0x0,0x8,0x82,0x4,0x5,0x282,0x509,0x82,0x0,0x4,0x7,0x8,0xd,0x2,0x0,0x6,0x288,0x28a,0x8,0x289,0x28c,0x51d,0x28a,0x8,0x0,0x9,0x84,0x4,0x6,0x293,0x529,0x84,0x0,0x8,0x6,0x110,0x10,0x112,0x298,0x351,0x6,0x0,0x12,0x124,0x29c,0x0,0x59,0x256,0x48,0x47,0x58,0x4,0x6,0x262,0x549,0x262,0x4,0x10,0x263,0x2a6,0x8d,0x4,0x2,0xe,0x46,0x2aa,0x8,0x8,0x1cd,0x55d,0x4,0x2,0xc,0x2ae,0x2b0,0xc,0x8,0x58,0xc,0x8,0x124,0x0,0x276,0x2b6,0x571,0x6,0x0,0x4,0xe0,0x207,0x579,0x8,0x4,0xa0,0x256,0x277,0x0,0x4,0x6,0x10,0x152,0x2c2,0x589,0x2c2,0x4,0x10,0x76,0x124,0x591,0x6,0x0,0xa,0x6,0xe0,0x1c1,0x2,0x0,0x2,0x2cc,0x2ce,0x5a1,0x8,0x6,0xa0,0x9a,0x149,0x8,0x6,0x125,0x249,0x6,0x0,0x10,0x2d6,0x2d9,0x4,0x6,0xe0,0x5b9,0x4,0x2,0x0,0x2dc,0x2de,0x5c1,0x2de,0x8,0x351,0x6,0x2,0x4,0x4,0x2e4,0x5cd,0x8,0x2,0x0,0x6,0x125,0x248,0x256,0x2ea,0x2,0x2,0x256,0x5dd,0x4,0x2,0x10,0x257,0x2ee,0x4ae,0x2f0,0x2f2,0x12,0x256,0x278,0x12,0x124,0x2d8,0x0,0x6,0x124,0x5f5,0x124,0x8,0x6a,0x124,0x256,0x4,0x4,0x148,0x0,0x149,0x300,0x605,0x8,0x6,0x68,0x7e,0x257,0x0,0x2,0x1db,0x611,0x8,0x6,0x4,0x4,0x257,0x12,0x256,0x30c,0x61d,0x256,0x0,0x61a,0x30e,0x310,0x515,0x8,0x2,0x0,0x5,0x314,0x516,0x314,0x316,0x64,0x100,0x257,0x6,0x6,0x32,0x0,0x8,0x31d,0x63d,0x32,0x6,0x4,0x6,0x33,0x645,0xb0,0x6,0x611,0x276,0x6,0xa,0x6,0x1a,0x0,0x8,0x1b,0x655,0x328,0x4,0xc,0x8,0x3c,0x65d,0x8,0x0,0xe,0x8,0x3c,0x0,0x6,0x333,0x669,0x3c,0x0,0x0,0x4,0x3c,0xe,0x8,0x338,0x675,0x3c,0x0,0x79,0x6,0x0,0x10,0x19c,0x33e,0xc,0xa,0x58,0x685,0x8,0x0,0x4,0x6,0x9b,0x8,0x9,0x9a,0x691,0x346,0x0,0x8,0x6,0x1b,0xc,0x256,0x34d,0x8,0x8,0x257,0x4,0x257,0x350,0x140,0xf5,0x256,0x0,0x6,0xf5,0x6ad,0xf4,0x8,0x4,0x5,0x6,0x8,0x43,0x35a,0x6b9,0x2,0x0,0x0,0x2,0x7,0x4,0x9,0x360,0x4,0x5,0x362,0x6c9,0x42,0x0,0x0,0x8,0x19c,0x6d1,0x4,0x2,0x0,0x369,0x36a,0x6d9,0x19c,0x6,0x85,0x2,0x0,0xc,0x8,0x370,0x84,0x370,0x372,0xc,0x9,0xf4,0x6ed,0x28a,0x4,0x0,0x9,0xa,0xc,0xf4,0x37b,0x6f9,0xa,0x0,0x65,0x6,0x4,0x201,0x8,0x4,0x2,0x380,0x382,0x6,0x8,0x2c2,0x70d,0x6,0x4,0x1a5,0x6,0x2,0x1a5,0x4,0x0,0x0,0x38b,0x38c,0x0,0x3,0x32,0x64,0x380,0x391,0x0,0x6,0x3d,0x729,0x2,0x0,0x72d,0x8,0x4,0xc,0x8,0x71,0x4,0x4,0x39a,0x739,0x70,0x8,0x2,0x4,0x32,0x65,0x6,0x0,0x4,0x3a1,0x3a2,0x749,0x6,0x4,0x0,0x8,0x3c,0x0,0x6,0x3a9,0x755,0x4,0x2,0x8,0xd2,0x38a,0x639,0x262,0x4,0x6,0x8,0x262,0x8,0x9,0x3b2,0x769,0x262,0x2,0x4,0x8,0x262,0xa,0x6,0x3b8,0x775,0x262,0x2,0x0,0x2,0x58,0xc,0x8,0x3be,0x781,0x3be,0x58,0x515,0x4,0x0,0x12,0x28a,0x3c4,0xe,0x3c4,0x3c6,0x0,0x4,0x1bb,0x0,0x6,0x3cb,0x799,0x58,0x0,0x8,0x8,0x71,0xc,0x15f,0x3d0,0x7a5,0x70,0x0,0x2,0x6,0xf4,0xa,0x8,0xf4,0x7b1,0x3d6,0x2,0x585,0x8,0x2,0x0,0x2,0x3dd,0x7bd,0x6,0x4,0xa,0x6,0xb4,0x7c5,0x58,0x0,0x0,0x4,0x207,0x6,0x8,0x206,0x7d1,0x3e6,0x2,0xe,0x110,0x15e,0x4,0x7,0x15e,0x7dd,0x6,0x4,0x6,0x3ee,0x3f0,0x8,0x8,0x15,0x4,0x6,0x3f4,0x7e9,0x14,0x0,0x7f1,0x3f6,0x4,0xa,0x6,0x1ba,0x7f9,0xe0,0x2,0x1c1,0x6,0x4,0x4,0x4,0x400,0x805,0x8,0x0,0x49,0x8,0x0,0x49,0x8,0x6,0xc,0x14,0xf5,0x815,0xf4,0x2,0x819,0x8,0x4,0x8,0x6,0xb5,0x4,0x8,0xb4,0x825,0x410,0x6,0x0,0x4,0x1cd,0x82d,0x8,0x2,0x4,0x8,0x42,0x835,0x6,0x0,0x0,0x2,0x206,0x83d,0x8,0x4,0x15,0x8,0x6,0x515,0x8,0x4,0x0,0x0,0x0
+
+  };
+  // clang-format on
+}; // namespace mockturtle
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/node_resynthesis/xmg_npn.hpp b/include/mockturtle/algorithms/node_resynthesis/xmg_npn.hpp
new file mode 100644
index 0000000..28a5284
--- /dev/null
+++ b/include/mockturtle/algorithms/node_resynthesis/xmg_npn.hpp
@@ -0,0 +1,292 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xmg_npn.hpp
+  \brief Replace with size-optimum XMGs from NPN
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+  \author Zhufei Chu
+*/
+
+#pragma once
+
+#include <iostream>
+#include <sstream>
+#include <stack>
+#include <unordered_map>
+#include <vector>
+
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/npn.hpp>
+#include <kitty/print.hpp>
+
+#include "../../algorithms/cleanup.hpp"
+#include "../../io/write_bench.hpp"
+#include "../../networks/xmg.hpp"
+#include "../../traits.hpp"
+#include "../../views/topo_view.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Resynthesis function based on pre-computed size-optimum XMGs.
+ *
+ * This resynthesis function can be passed to ``node_resynthesis``,
+ * ``cut_rewriting``, and ``refactoring``.  It will produce an XMG based on
+ * pre-computed size-optimum XMGs with up to at most 4 variables.
+ * Consequently, the nodes' fan-in sizes in the input network must not exceed
+ * 4.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      const klut_network klut = ...;
+      xmg_npn_resynthesis resyn;
+      const auto xmg = node_resynthesis<xmg_network>( klut, resyn );
+   \endverbatim
+ */
+class xmg_npn_resynthesis
+{
+public:
+  /*! \brief Default constructor.
+   *
+   */
+  xmg_npn_resynthesis()
+  {
+    build_db();
+  }
+
+  template<typename LeavesIterator, typename Fn>
+  void operator()( xmg_network& xmg, kitty::dynamic_truth_table const& function, LeavesIterator begin, LeavesIterator end, Fn&& fn ) const
+  {
+    assert( function.num_vars() <= 4 );
+    const auto fe = kitty::extend_to( function, 4 );
+    const auto config = kitty::exact_npn_canonization( fe );
+
+    auto func_str = "0x" + kitty::to_hex( std::get<0>( config ) );
+    const auto it = class2signal.find( func_str );
+    assert( it != class2signal.end() );
+
+    // const auto it = class2signal.find( static_cast<uint16_t>( std::get<0>( config )._bits[0] ) );
+
+    std::vector<xmg_network::signal> pis( 4, xmg.get_constant( false ) );
+    std::copy( begin, end, pis.begin() );
+
+    std::vector<xmg_network::signal> pis_perm( 4 );
+    auto perm = std::get<2>( config );
+    for ( auto i = 0; i < 4; ++i )
+    {
+      pis_perm[i] = pis[perm[i]];
+    }
+
+    const auto& phase = std::get<1>( config );
+    for ( auto i = 0; i < 4; ++i )
+    {
+      if ( ( phase >> perm[i] ) & 1 )
+      {
+        pis_perm[i] = !pis_perm[i];
+      }
+    }
+
+    for ( auto const& po : it->second )
+    {
+      topo_view topo{ db, po };
+      auto f = cleanup_dangling( topo, xmg, pis_perm.begin(), pis_perm.end() ).front();
+
+      if ( !fn( ( ( phase >> 4 ) & 1 ) ? !f : f ) )
+      {
+        return; /* quit */
+      }
+    }
+  }
+
+private:
+  std::unordered_map<std::string, std::string> opt_xmgs;
+
+  inline std::vector<std::string> split( const std::string& str, const std::string& sep )
+  {
+    std::vector<std::string> result;
+
+    size_t last = 0;
+    size_t next = 0;
+    while ( ( next = str.find( sep, last ) ) != std::string::npos )
+    {
+      result.push_back( str.substr( last, next - last ) );
+      last = next + 1;
+    }
+    result.push_back( str.substr( last ) );
+
+    return result;
+  }
+
+  void load_optimal_xmgs( const unsigned& strategy )
+  {
+    std::vector<std::string> result;
+
+    switch ( strategy )
+    {
+    case 1:
+      result = split( npn4_s, "\n" );
+      break;
+
+    case 2:
+      result = split( npn4_sd, "\n" );
+      break;
+
+    case 3:
+      result = split( npn4_ds, "\n" );
+      break;
+
+    default:
+      break;
+    }
+
+    for ( auto record : result )
+    {
+      auto p = split( record, " " );
+      assert( p.size() == 2u );
+      opt_xmgs.insert( std::make_pair( p[0], p[1] ) );
+    }
+  }
+
+  std::vector<xmg_network::signal> create_xmg_from_str( const std::string& str, const std::vector<xmg_network::signal>& signals )
+  {
+    auto sig = signals;
+    std::vector<xmg_network::signal> result;
+
+    std::stack<int> polar;
+    std::stack<xmg_network::signal> inputs;
+
+    for ( auto i = 0ul; i < str.size(); i++ )
+    {
+      // operators polarity
+      if ( str[i] == '[' || str[i] == '<' )
+      {
+        polar.push( i > 0 && str[i - 1] == '!' ? 1 : 0 );
+      }
+
+      // input signals
+      if ( str[i] >= 'a' && str[i] <= 'd' )
+      {
+        inputs.push( sig[str[i] - 'a' + 1] );
+
+        polar.push( i > 0 && str[i - 1] == '!' ? 1 : 0 );
+      }
+      else if ( str[i] == '0' )
+      {
+        inputs.push( sig[0] );
+
+        polar.push( i > 0 && str[i - 1] == '!' ? 1 : 0 );
+      }
+
+      // create signals
+      if ( str[i] == '>' )
+      {
+        assert( inputs.size() >= 3u );
+        auto x1 = inputs.top();
+        inputs.pop();
+        auto x2 = inputs.top();
+        inputs.pop();
+        auto x3 = inputs.top();
+        inputs.pop();
+
+        assert( polar.size() >= 4u );
+        auto p1 = polar.top();
+        polar.pop();
+        auto p2 = polar.top();
+        polar.pop();
+        auto p3 = polar.top();
+        polar.pop();
+
+        auto p4 = polar.top();
+        polar.pop();
+
+        inputs.push( db.create_maj( x1 ^ p1, x2 ^ p2, x3 ^ p3 ) ^ p4 );
+        polar.push( 0 );
+      }
+
+      if ( str[i] == ']' )
+      {
+        assert( inputs.size() >= 2u );
+        auto x1 = inputs.top();
+        inputs.pop();
+        auto x2 = inputs.top();
+        inputs.pop();
+
+        assert( polar.size() >= 3u );
+        auto p1 = polar.top();
+        polar.pop();
+        auto p2 = polar.top();
+        polar.pop();
+
+        auto p3 = polar.top();
+        polar.pop();
+
+        inputs.push( db.create_xor( x1 ^ p1, x2 ^ p2 ) ^ p3 );
+        polar.push( 0 );
+      }
+    }
+
+    assert( !polar.empty() );
+    auto po = polar.top();
+    polar.pop();
+    db.create_po( inputs.top() ^ po );
+    result.push_back( inputs.top() ^ po );
+    return result;
+  }
+
+  void build_db()
+  {
+    std::vector<xmg_network::signal> signals;
+    signals.push_back( db.get_constant( false ) );
+
+    for ( auto i = 0u; i < 4; ++i )
+    {
+      signals.push_back( db.create_pi() );
+    }
+
+    load_optimal_xmgs( 1 ); // size optimization
+
+    for ( const auto& e : opt_xmgs )
+    {
+      class2signal.insert( std::make_pair( e.first, create_xmg_from_str( e.second, signals ) ) );
+    }
+  }
+
+  xmg_network db;
+  std::unordered_map<std::string, std::vector<xmg_network::signal>> class2signal;
+
+  std::string npn4_s = "0x3cc3 [d[!bc]]\n0x1bd8 [!<ac!d>!<a!bd>]\n0x19e3 [[!<!0a!c><!bc<!0a!c>>]<ad!<!0a!c>>]\n0x19e1 [<ac[!bc]><d[!bc]<a!b!<ac[!bc]>>>]\n0x17e8 [d<abc>]\n0x179a <[!a<!0b!c>][ad]!<abc>>\n0x178e [!d<!a!b[cd]>]\n0x16e9 [![!d<!0ab>]!<!0c<abc>>]\n0x16bc [[!c<0ad>]<a!b<!0!ac>>]\n0x16ad <!d<ad!<0!b!c>>!<ac!<0!bd>>>\n0x16ac [<acd>!<!b!d<!a[!bc]<acd>>>]\n0x16a9 <!<!0!bc>!<d!<!0!bc>![ac]><d<!b!d<!0!bc>>![ac]>>\n0x169e <[bc][a[bc]]<!c!d[a[bc]]>>\n0x169b [<c[!ab]<!b!cd>><a!cd>]\n0x169a <![!bc]<0a[!bc]>[a<cd![!bc]>]>\n0x1699 <<!a!b<0!cd>><ad!<0!cd>>!<!bd<ad!<0!cd>>>>\n0x1687 [!a!<b<!0!b<a!bd>>![c<a!bd>]>]\n0x167e <b!<bd[!ac]>[<bd[!ac]><ac![!ac]>]>\n0x166e [<cd<0ab>>!<!a!b<0ab>>]\n0x03cf <!c!d![bc]>\n0x166b <!c[a<bcd>]<!bc!d>>\n0x01be <!d!<!0b!<!bcd>><b!c![a<!0b!<!bcd>>]>>\n0x07f2 <!d![!cd]<!bd[ab]>>\n0x07e9 [<bc<!0a!b>><!ad<!0a!b>>]\n0x6996 [b[a[cd]]]\n0x01af <a!<0d<abd>>!<!0ac>>\n0x033c <!<!0bd>[c<!0bd>]![!bd]>\n0x07e3 <!c[!c<ab!d>]<!b!d[!c<ab!d>]>>\n0x1681 <<!b!cd>!<!0!a<!b!cd>>![[!ab]<!bc!d>]>\n0x01ae [!d<0<!a!bc>!<acd>>]\n0x07e2 [<!a!bd>!<!cd<0b!<!a!bd>>>]\n0x01ad [<!0c!<a!bd>><!acd>]\n0x07e1 [!<!a!bd>!<0c!<!cd!<!a!bd>>>]\n0x001f <!d<0!a!b><0!c!<0!a!b>>>\n0x01ac [<!0bc><d<!acd><!0bc>>]\n0x07e0 [d<cd<ab!d>>]\n0x07bc [<!0d!<!0a!b>><bc<!0a!b>>]\n0x03dc <b[!d<0!b!c>]!<ab!<0!b!c>>>\n0x06f6 <!d[cd][ab]>\n0x06bd [<c<a!bd>!<a!b!d>><!0d!<a!bd>>]\n0x077e <!<bcd><b![!cd]!<bcd>>[a<bcd>]>\n0x06b9 <!<ad<0!b!c>><a!b!d><0!cd>>\n0x06b7 <!d!<bc![!ac]>![b[!ac]]>\n0x06b6 <!<!0a!b><a!bc>!<0c!<0!d<a!bc>>>>\n0x077a [<bcd>!<0!a<b!c!d>>]\n0x06b5 [<a!d[ac]>!<cd<!b![ac]<a!d[ac]>>>]\n0x0ff0 [cd]\n0x0779 [<cd<ab!c>><!0!<ab!c><abc>>]\n0x06b4 [c<d![!ab]<!abc>>]\n0x0778 <!b<b!d!<!0a!b>>[c<bd<!0a!b>>]>\n0x007f <!d<0!ab>!<bc<0!ab>>>\n0x06b3 <!a<a!b!d><[cd][!bd]<a!b!d>>>\n0x007e <0!d![a<a!b!c>]>\n0x06b2 <a<!a!d[ab]>[d<cd![ab]>]>\n0x0776 <[ab]!<abd>[cd]>\n0x06b1 [!d!<c<!0!bd>![ab]>]\n0x06b0 [d<c[!ab]<ad<!0cd>>>]\n0x037c <d[d<!0bc>]!<ad<bcd>>>\n0x01ef <!c!d[d<!0ab>]>\n0x0696 <b<a!b!<!0!cd>>!<abc>>\n0x035e [!<0!a!d>!<0!c!<bd<0!a!d>>>]\n0x0678 <!<!abd>[c<abd>]!<!0a!b>>\n0x0676 <!<!0!cd>!<abc>[ab]>\n0x0669 [!d!<b<a!b<!0!cd>>!<ab!c>>]\n0x01bc [<0!b!c><!c!d<a!b!d>>]\n0x0663 [!<!acd><0b<b!c!d>>]\n0x07f0 <0[cd]<!b!<0ad>[cd]>>\n0x01bf <!b!d!<!bc![ad]>>\n0x0666 <0[ab]!<0cd>>\n0x0661 [<ab!c><b!d<!0a<a!b!c>>>]\n0x1689 [!<0d![ab]><c[ab]!<abd>>]\n0x0660 <0![!cd][ab]>\n0x0182 [!<!ab!c><!bd!<!0!c<!ab!c>>>]\n0x07b6 [c<d!<0!c[!ab]>!<ac[!ab]>>]\n0x03d7 <!d![bc]!<abc>>\n0x06f1 <c<a!c<!ab!d>><!b<!ab!d>![d<a!c<!ab!d>>]>>\n0x03dd <!<a!bd>!<!0bc>![!d<!0bc>]>\n0x0180 [!<!bc!d>!<!a!b<!bc!d>>]\n0x07b4 [<a!d![bd]>!<0c!<0d<a!d![bd]>>>]\n0x03db <!d<0!b!c>[a<!a!bc>]>\n0x07b0 <!<!0a!d>[cd]<a!b!d>>\n0x03d4 [d<bc<!0!ad>>]\n0x03c7 <[!bc]<0!a!c>!<0bd>>\n0x03c6 <!d!<!0c!d>[b<a!c!<!0c!d>>]>\n0x03c5 [!<bcd>!<!ad!<0c!d>>]\n0x03c3 <!c!<b!cd>![bc]>\n0x03c1 <!a[b<b!cd>]!<c<b!cd>![b<b!cd>]>>\n0x03c0 [d<bcd>]\n0x1798 [<!a!b<ab!c>><0!d<!c!d<ab!c>>>]\n0x036f <!c!d[b<!0ad>]>\n0x03fc [d!<0!b!c>]\n0x1698 <!<abc><0!d<abd>><!0c<abd>>>\n0x177e [!<0!a!c><bd![ac]>]\n0x066f <!c!d[ab]>\n0x035b <!<acd>!<0b!c><0a!c>>\n0x1697 [<!ab<!acd>>[!bc]]\n0x066b <a<!a!b[cd]>!<cd[b<!a!b[cd]>]>>\n0x07f8 [d<ac!<0a!b>>]\n0x035a <!d<0!bd>[c<!0ad>]>\n0x1696 <0<!0!b<b!c!d>>![a[!bc]]>\n0x003f <0!d!<bcd>>\n0x0673 <!d![!b<a!c!d>]!<bc<a!c!d>>>\n0x0359 [!<0b!c><ac![!ad]>]\n0x0672 <<0!b!d>[ab][cd]>\n0x0358 [!<b!d!<0a!d>>!<d<b!d!<0a!d>>![c<0a!d>]>]\n0x003d <0<!b!c<bc!d>><!a!d<bc!d>>>\n0x0357 <!a<!0a!d>!<!0bc>>\n0x003c <0!d[bc]>\n0x0356 [<0!a!d><0!b!c>]\n0x07e6 [<ab!d><!cd<0ab>>]\n0x033f <!b!c!d>\n0x033d [<0!d<a!cd>><!b!c<0!d!<a!cd>>>]\n0x0690 [c<cd![!ab]>]\n0x01e9 [!<bc<!0a!c>><a!<!0a!c>!<0d<bc<!0a!c>>>>]\n0x1686 [!a<!b[!bc]!<ad![!bc]>>]\n0x07f1 <!b[cd]!<a!bd>>\n0x01bd <!d[b<!a!bc>]<0!c<!a!bc>>>\n0x1683 [[!bc]<!ad<0bc>>]\n0x001e <0!d[c<!0ab>]>\n0x01ab <!d!<!0bc>[ad]>\n0x01aa <a![!ad]!<!0a<!0bc>>>\n0x01a9 <!d![a<!0bc>]<0!ad>>\n0x001b <0!<!abd>!<acd>>\n0x01a8 [<0!b!c><a!d<0!b!c>>]\n0x000f <0!c!d>\n0x0199 <!<bcd>[!ab]<0!d[!ab]>>\n0x0198 [b!<a!b[d<!0b!c>]>]\n0x0197 <!d<0!b!c>[!a<0bc>]>\n0x06f9 [d<!0c![ab]>]\n0x0196 <!b!<!0d<a!b!c>>!<!bc![ad]>>\n0x03d8 [d!<!b!c<0!d![!ab]>>]\n0x06f2 <[cd]<!d![!ab][cd]><0a![cd]>>\n0x03de <!d![!bd][!c<!ab[!bd]>]>\n0x018f <!c!d![a<!ab!d>]>\n0x0691 <<!a!bd><ab!c><!d!<ab!c><0c<ab!c>>>>\n0x01ea [!d!<!0a<bcd>>]\n0x07b1 <[cd]<0!a!c>!<!abd>>\n0x0189 <<a!b!c><0b!d>[a<a!b!c>]>\n0x036b <!c[b<!0a!c>]<a!d!<!0a!c>>>\n0x03d5 <!a[b<b!cd>]<!0a!d>>\n0x0186 [<!a!bc><c!d!<0ab>>]\n0x0119 <0[!ab]!<acd>>\n0x0368 [![c<0a!d>]!<!bc!<b!d![c<0a!d>]>>]\n0x0183 <[!bc]<0a!d><0!a!b>>\n0x07b5 <!<bcd>![ac][cd]>\n0x0181 [<b!c<!0!bd>><ab<b!c<!0!bd>>>]\n0x036e <b[b<!0ad>]!<bcd>>\n0x011f <!c!d!<!0ab>>\n0x016f <b<0!b!<!abc>>!<ad<!abc>>>\n0x016e <!d[a[bd]]<0!c[bd]>>\n0x013f <!a<0a!d>!<bcd>>\n0x019f <0<!c!d[!ab]>!<0bd>>\n0x013e [[!bd]!<!bc<a!d![!bd]>>]\n0x019e [d<a!<a!b!c><!0!c<!a!bd>>>]\n0x013d <b!<bcd><0<!0!ac>!<bcd>>>\n0x016b <!d![!a[!bc]]!<bc![!bc]>>\n0x01fe [d!<0!a!<!0bc>>]\n0x166a [<bcd><ab<d!<bcd>!<0b!c>>>]\n0x0019 [<!ab!d><0b<!ac<!ab!d>>>]\n0x006b <!d<a!b!c><0!a<0bc>>>\n0x069f <a<!ab!d>!<abc>>\n0x013c <0!<bcd><b!<0ad>!<!c!d<0ad>>>>\n0x037e [<!0ad><bc<!0!ad>>]\n0x012f <!d<a!b!c><0!a!c>>\n0x0693 [c!<!d<b!cd>![!b<!ac<b!cd>>]>]\n0x012d <0!<bcd><!0b[!ac]>>\n0x01ee <!c<ac!d>[!d<0!a!b>]>\n0x012c [!<0!b!c><cd<!0!ab>>]\n0x017f <!a!d!<bcd>>\n0x1796 <![!ad]<!b!c[!ad]>![!d<bc[!ad]>]>\n0x036d <<!ab!c><ac[bd]>!<bcd>>\n0x011e <d<0!d!<0!c<0!a!b>>>!<c!<0!a!b>!<0!d!<0!c<0!a!b>>>>>\n0x0679 <a<!a!b[cd]>!<ad<!0!bc>>>\n0x035f <!c!d!<ab[bc]>>\n0x067b <!<cd!<!acd>>![b<!acd>]!<!abd>>\n0x0118 <0[!d[a<!ab!c>]]!<b!<!ab!c>[a<!ab!c>]>>\n0x067a [<!0ac><cd<ab!<!0ac>>>]\n0x0117 <0!<abd>!<cd<ab!d>>>\n0x1ee1 [!d![!c<!0ab>]]\n0x016a <d<!d!<!0!ad><bcd>>!<a<bcd>!<!d!<!0!ad><bcd>>>>\n0x0169 <!c<!a!b<abc>><0!d<abc>>>\n0x037d <!a![d<0!b!c>]<a!b!c>>\n0x0697 <<0ac>!<abc>!<d<abc>!<abd>>>\n0x006f <!d<0!c!d>![!ab]>\n0x17ac [<abc><!ad<!0bd>>]\n0x0069 <0!d![a[bc]]>\n0x0667 <0!<0ab>!<cd!<!0ab>>>\n0x0168 <!b!<!0d!<abc>><!ab!<!bc!d>>>\n0x067e <!d[ab][!c<0!b!d>]>\n0x011b <a!<!0ab>!<acd>>\n0x036a [<!0ad><bcd>]\n0x018b <!c!<a!c[bc]><0a!d>>\n0x0001 <0<0!b!d><!ab!c>>\n0x1669 <<!a!c[bd]><ac[bd]>!<[bd]!<!a!c[bd]><bd<!a!c[bd]>>>>\n0x0018 <0!d[a<a!bc>]>\n0x168b [![d<!0bc>]<ab!<!c!d<!0bc>>>]\n0x0662 [<ab<!0!bc>><c!<!0!bc><abd>>]\n0x00ff !d\n0x168e [<!0a!<!0!bc>><c!<!0!bc><a!bd>>]\n0x0007 <0<0!c!d>!<abd>>\n0x19e6 [[ad]<b!c!<!0a!b>>]\n0x0116 <0!<abd>![!c<d[ab]!<abd>>]>\n0x036c [[bd]<0c!<!ab![bd]>>]\n0x01e8 <<!a!bc><a!c[cd]><0b!d>>\n0x06f0 <<0!ab><a!bc>![!cd]>\n0x03d6 [[c<!0!bc>]!<!0d!<!ab<!0!bc>>>]\n0x1be4 [!d!<bc[ab]>]\n0x0187 <a<!a!d[!bc]><0!c<!a!d[!bc]>>>\n0x0003 <0!d<0!b!c>>\n0x017e [[!ad]<a!b<!c[!ad]<!0bd>>>]\n0x01eb <!d[!b<!0ac>]<a!b!<!0ac>>>\n0x0006 <0!d<!cd![!ab]>>\n0x011a [a<a!<b!c!d>[cd]>]\n0x0369 <0[!c<0!d![!ab]>]!<0bd>>\n0x03d9 [!b<b!<!ab[!ad]><!bc!d>>]\n0x0000 0\n0x019b <!d!<!0bc>![ab]>\n0x1668 [<acd><ab<bcd>>]\n0x18e7 [d[!b<!abc>]]\n0x0017 <0!d!<abc>>\n0x019a <!d[a<!bcd>]<0!c<!bcd>>>\n0x0016 <0!<ab<!a!bc>>!<!cd<!a!bc>>>";
+  std::string npn4_sd = "0x3cc3 [b[!cd]]\n0x1bd8 [!<b!cd><a!b!c>]\n0x19e3 [<a!b!c><c[bd]<0a!c>>]\n0x19e1 [<!b!c[bd]><a[bd]!<cd<!b!c[bd]>>>]\n0x17e8 [d<abc>]\n0x179a [<ad!<0ad>><c<0ad>[!bd]>]\n0x178e <!c[ad]![!bd]>\n0x16e9 [d<<a!b!c><abc>!<0a!b>>]\n0x16bc [<0!b!c><!d!<abc>[ad]>]\n0x16ad [!<!b!<!0a!b>[ac]><0d<!0a!b>>]\n0x16ac [!<acd><!b!d<!a[cd]<acd>>>]\n0x16a9 <0<!0a<!b!cd>>[!<0!b!c>[!ad]]>\n0x169e <!d[!a[!bc]]!<c!d[!bc]>>\n0x169b <<a!b!<0!cd>>!<ab!<0!cd>>!<!bcd>>\n0x169a [a<![!bc]<0ac><!0!bd>>]\n0x1699 <b<!a!b<0!cd>>!<b<0!cd><!abd>>>\n0x1687 [[ac]<b!<a!bd>!<0bc>>]\n0x167e <<!b!c<!abc>>[a<!abc>]!<!ad!<!abc>>>\n0x166e [<ab!<0ab>><cd<0ab>>]\n0x03cf <!c!d[bd]>\n0x166b <!c[a<bcd>]<!bc!d>>\n0x01be <c!<bcd><!<!0!bd>[ad]!<bcd>>>\n0x07f2 <[cd]<0a!b>!<0ad>>\n0x07e9 [<ac<!0!ab>><!bd<!0!ab>>]\n0x6996 [[bc][ad]]\n0x01af <[!ac]<0a!d>!<bcd>>\n0x033c <<b!cd><0c!d>!<bcd>>\n0x07e3 [c<d!<abc>!<0b!c>>]\n0x1681 <0[!<b!cd>[ab]]!<!d[ab]<0!ac>>>\n0x01ae <!<bcd>![!ad]<0b!d>>\n0x07e2 [<!a!bd>!<!cd<0b!<!a!bd>>>]\n0x01ad <!<bcd><0b!d>[!ac]>\n0x07e1 [c<d<!0!bc>!<ab!d>>]\n0x001f <!a<a!b!d><0!c!d>>\n0x01ac [d<a<!a!cd>!<0!b!c>>]\n0x07e0 [d<ac<!abd>>]\n0x07bc [<bc<!0a!b>>!<0!d<!0a!b>>]\n0x03dc <b[d<!0bc>]!<ab<!0bc>>>\n0x06f6 <!d[ab][cd]>\n0x06bd <<b!c<0!bd>><a!b!d>!<a!c<0!bd>>>\n0x077e <<!0a![!cd]><0!ab>!<bcd>>\n0x06b9 <!<!0ac><a!b!d><b<a!b!d>![!cd]>>\n0x06b7 <!d[c[ab]]<!b!c[ab]>>\n0x06b6 [!c!<<!abc>!<0c!d>[ab]>]\n0x077a [!<0a!<!bcd>>![cd]]\n0x06b5 <!<a!b!c><a!b!d>![!c<!0!ad>]>\n0x0ff0 [cd]\n0x0779 <<ac!d><b!c!<ac!d>>!<ab![cd]>>\n0x06b4 [!c<!d<a!b!c>![ab]>]\n0x0778 [[cd]<0<b!c!d><0ab>>]\n0x007f <!d<!ab!c><0!b!d>>\n0x06b3 [![!bd]!<d<0bc><a!c!d>>]\n0x007e <0!d![a<a!b!c>]>\n0x06b2 [!<0!c!<a!bd>><bd!<ab!c>>]\n0x0776 <[ab][cd]!<abc>>\n0x06b1 [d<c<!0!bd>[!ab]>]\n0x06b0 [<!a!c<ab!d>><!b<ab!d>!<0cd>>]\n0x037c [[!bd]<d<!0b!c>!<acd>>]\n0x01ef <!c!d![!c<0!a!b>]>\n0x0696 <<ab!c><0c!d>!<abc>>\n0x035e [<!0ad>!<0!c!<bd!<!0ad>>>]\n0x0678 <<!ab!d><0a!b>[c<abd>]>\n0x0676 <!<abc>[ab]<0c!d>>\n0x0669 [<0!c!d><[cd]<0!c!d>[ab]>]\n0x01bc [<bd<!acd>>!<0!b!c>]\n0x0663 <0[b<a!c!d>]!<0cd>>\n0x07f0 <[cd]!<!0!cd>!<0ab>>\n0x01bf <!d<!0a!c><0!a!b>>\n0x0666 <0[ab]!<0cd>>\n0x0661 <<a!c!d>!<ab<a!c!d>>[<a!c!d><b!c!d>]>\n0x1689 [[d<abd>]<0!c<!a!bd>>]\n0x0660 [<b!c!d>!<!acd>]\n0x0182 [<!ab!c><b!d<!0!c<!ab!c>>>]\n0x07b6 [<!0!a<!bcd>>[!c<!0bd>]]\n0x03d7 <!d[!bc]!<abc>>\n0x06f1 [<!ac<!0!bc>><d<!0!bc><0!ad>>]\n0x03dd <[bd]<0!a!d>!<0cd>>\n0x0180 [<acd>!<b!d!<acd>>]\n0x07b4 [<bd<!0!ad>><c<!0!ad><abc>>]\n0x03db <[!bc]<a!b!d>!<acd>>\n0x07b0 <<0ac>[cd]!<abc>>\n0x03d4 [!d<!b!c<0a!d>>]\n0x03c7 <!<0bd><0!a!c>[!bc]>\n0x03c6 <0!<0cd>[!b<!ac!d>]>\n0x03c5 <[bd]<0!a!c>![bc]>\n0x03c3 <!b<0b!d>[!bc]>\n0x03c1 <!<b!cd>[b<b!cd>]<!a!c<b!cd>>>\n0x03c0 [d<bcd>]\n0x1798 [<ab<!a!bc>><d<!a!bc><!0cd>>]\n0x036f <!c!d[!b<0!ac>]>\n0x03fc [d!<0!b!c>]\n0x1698 [b<<!abd>[ac][!ad]>]\n0x177e [<0!b!d>!<ac![bd]>]\n0x066f <!c!d[ab]>\n0x035b <<ac!d><0!b!c>!<0ac>>\n0x1697 <!<abc><ab!c><!bc!d>>\n0x066b [<bc<!a!bd>><a<!a!bd>!<0!cd>>]\n0x07f8 [!d!<ac!<0a!b>>]\n0x035a [!<!0c<0bd>><0!a!d>]\n0x1696 <!a<!d<0!bd><a!bc>><b!c<a!bc>>>\n0x003f <0!d!<bcd>>\n0x0673 <!b![d<ab!c>]<!a!d<ab!c>>>\n0x0359 [<!0!bc><ac[!cd]>]\n0x0672 <[cd]<0!b!d>[ab]>\n0x0358 <<!acd><0a!c>[!d<0!b!c>]>\n0x003d <!<bcd>[bc]<0!a!d>>\n0x0357 <!0!<!0bc><0!a!d>>\n0x003c <0!d![!bc]>\n0x0356 [!<0!a!d>!<0!b!c>]\n0x07e6 [<!cd!<0!a!b>><abc>]\n0x033f <!b!c!d>\n0x033d <!<bcd><bc!d><0!b<!0!ad>>>\n0x0690 [!d<!c!d[ab]>]\n0x01e9 <!d<0!b![ac]>![b<!0ac>]>\n0x1686 [[bc]<a[bc]!<!abd>>]\n0x07f1 <!b<!ab!d>[cd]>\n0x01bd <!d[c<!ab!c>]<0!b<!ab!c>>>\n0x1683 [[bc]!<!ad<0bc>>]\n0x001e <0!d![!c<ab!d>]>\n0x01ab <!d![!ad]<0!b!c>>\n0x01aa <[ad]<0!b!c><0a!d>>\n0x01a9 [a<d<0!b!c><!0a!d>>]\n0x001b <0<a!b!d>!<acd>>\n0x01a8 [a<ad!<!0bc>>]\n0x000f <0!c!d>\n0x0199 <[!ab]<a!b!d><0!a!c>>\n0x0198 [!<!abd><!b!c<0ac>>]\n0x0197 <!d[!a<0bc>]<!b!c<0bc>>>\n0x06f9 [d<!0c![ab]>]\n0x0196 <<0!d!<a!b!c>>[ad]!<bc[ad]>>\n0x03d8 [<!cd!<a!b!c>><!0b!<a!b!c>>]\n0x06f2 <a<0!a[cd]><!d[cd]![!ab]>>\n0x03de <!d![c<!ab!d>][bd]>\n0x018f <!c!d[b<!ab!c>]>\n0x0691 <0<!d<!a!bd><ab!c>><!0c<!a!bd>>>\n0x01ea [d<!0a<bcd>>]\n0x07b1 <<a!b!d><0!a!c>[cd]>\n0x0189 <[!ab]!<!0ac><0a!d>>\n0x036b <!a!<!ad![!bc]>!<!abc>>\n0x03d5 [<bcd>!<!d<bcd><0a!d>>]\n0x0186 [<!cd<0ab>>!<!a!bc>]\n0x0119 <0[!ab]!<acd>>\n0x0368 [<bcd><c<b!cd><!0ad>>]\n0x0183 <[!bc]<0a!d><0!a!b>>\n0x07b5 <!<bcd>[cd]![ac]>\n0x0181 <<!ab!c>[b<!ab!c>]<0!d!<!ab!c>>>\n0x036e <!c<bc!d>[!b<0!a!d>]>\n0x011f <!c!d!<!0ab>>\n0x016f <<!ab!c><0a!d>!<abd>>\n0x016e <!d<0!c[bd]>[a[bd]]>\n0x013f <0!<0ad>!<bcd>>\n0x019f <!d<b!c[ad]><0!a!b>>\n0x013e [[!cd]<!bc!<a!d![!cd]>>]\n0x019e <!d!<!bc[!ad]><0!b<!acd>>>\n0x013d <<bc!d>!<!0ac>!<bcd>>\n0x016b <!d<0!b!c>![!b[!ac]]>\n0x01fe [d<!0c<ab!c>>]\n0x166a <a[a<bcd>]!<ab<!bcd>>>\n0x0019 <!<!abd><0!a!b><0b!c>>\n0x006b <!d<0b<!a!bc>>!<!abc>>\n0x069f <!d<abd>!<abc>>\n0x013c <<0!ad><b!d!<!0b!c>>!<bc<0!ad>>>\n0x037e [<!0ad>!<!b!c<0a!d>>]\n0x012f <!d<a!b!c>!<!0ac>>\n0x0693 [<acd><d<!0c!d>![bd]>]\n0x012d <<0ac><!ab!c>!<bcd>>\n0x01ee [!<!0ab>!<d<0!cd><!0ab>>]\n0x012c [<0!a!b><!d[bc]<0!a!b>>]\n0x017f <!b!d!<acd>>\n0x1796 <!b!<!a!bc><!a<!0cd>!<!0!bd>>>\n0x036d <<abc>!<bcd><!a!c[bd]>>\n0x011e <d!<cd!<0!a!b>>!<d<0!a!b>!<0c!d>>>\n0x0679 <!d<!a<abd><0!b!c>>[c<abd>]>\n0x035f <!c!<0bd>!<!0ad>>\n0x067b <!d<!b!c[ad]>[![ad]<0b!c>]>\n0x0118 <<0!a!b><ac!d><!cd<0b!d>>>\n0x067a [<!0ac><cd<ab!<!0ac>>>]\n0x0117 <!b<!a!d<a!cd>><0!c!<a!cd>>>\n0x1ee1 [[cd]<0!a!b>]\n0x016a <b!<b<!0!ad>!<b!cd>>!<ab<b!cd>>>\n0x0169 <!a<a!b!c><0!d<abc>>>\n0x037d <!a<a!b!c>[!d<0!b!c>]>\n0x0697 <<!a!c<0a!b>>!<!ab!c><!ab!d>>\n0x006f <!d<0!c!d>[ab]>\n0x17ac [<abc><!0d<0!ab>>]\n0x0069 <0!d[a[!bc]]>\n0x0667 <![!ab]<0!b[!ab]>!<cd[!ab]>>\n0x0168 [<bd<!0!bc>><ad<!0bc>>]\n0x067e <!d![c<0!a!d>][ab]>\n0x011b <a!<acd>!<!0ab>>\n0x036a [!<bcd><0!a!d>]\n0x018b <!<0ad><0!b!c><0ab>>\n0x0001 <0<0!a!b><0!c!d>>\n0x1669 <<!cd<!a!bc>><b!d[!ac]>!<bd[!ac]>>\n0x0018 <0!d[a<a!bc>]>\n0x168b [[!a<!ab!d>]<!b!c<0d<!ab!d>>>]\n0x0662 <!<!0bd>[ab][d<abc>]>\n0x00ff !d\n0x168e [!<a!c!<0!b!c>><!0<0!b!c><!ab!d>>]\n0x0007 <0!<!0cd>!<0ab>>\n0x19e6 [[ad]<0b!<0ac>>]\n0x0116 [<!b!d[!ac]><0[!ac]!<!abd>>]\n0x036c [[bd]!<!0!c<!ab![bd]>>]\n0x01e8 <!d<a[bd][cd]><0!ad>>\n0x06f0 <[cd]<a!bc>!<a!bd>>\n0x03d6 [<d!<0!a!d>!<0bc>><bc!<0bc>>]\n0x1be4 [d!<!b!c[ac]>]\n0x0187 <a!<!0ac>!<ad![!bc]>>\n0x0003 <0!d<0!b!c>>\n0x017e [[!bd]<<!ab!c>[!bd]<!0bd>>]\n0x01eb <!d[b<0!a!c>]!<!ab!<0!a!c>>>\n0x0006 <0[ab]<0!c!d>>\n0x011a <0[d[ac]]!<bcd>>\n0x0369 <!b<0!d<abc>><b!c!<0a!d>>>\n0x03d9 [d<<!0!ab><bcd><a!b!d>>]\n0x0000 0\n0x019b <!d<0!b!c>![ab]>\n0x1668 [<bcd><ab<!bcd>>]\n0x18e7 [[!cd]<abc>]\n0x0017 <0!d!<abc>>\n0x019a <!d![a<b!c!d>]!<!0c<b!c!d>>>\n0x0016 <0<a!d<bc!d>>!<abc>>";
+  std::string npn4_ds = "0x3cc3 [b[!cd]]\n0x1bd8 [!<b!cd><a!b!c>]\n0x19e3 [<a!b!c><c[bd]<0a!c>>]\n0x19e1 <![<a!bd>[bc]]<!d<a!bd>![bc]><!a!c[bc]>>\n0x17e8 [d<abc>]\n0x179a [<ad!<0ad>><c<0ad>[!bd]>]\n0x178e <!c[ad]![!bd]>\n0x16e9 [d<<a!b!c><abc>!<0a!b>>]\n0x16bc [<0!b!c><!d!<abc>[ad]>]\n0x16ad [!<!b!<!0a!b>[ac]><0d<!0a!b>>]\n0x16ac [<<!0!cd>[bc]<0ab>><ad!<!0!cd>>]\n0x16a9 <0<!0a<!b!cd>>[!<0!b!c>[!ad]]>\n0x169e <!d[!a[!bc]]!<c!d[!bc]>>\n0x169b <<a!b!<0!cd>>!<ab!<0!cd>>!<!bcd>>\n0x169a [a<![!bc]<0ac><!0!bd>>]\n0x1699 <b<!a!b<0!cd>>!<b<0!cd><!abd>>>\n0x1687 [[ac]<b!<a!bd>!<0bc>>]\n0x167e <<!b!c<!abc>>[a<!abc>]!<!ad!<!abc>>>\n0x166e [<ab!<0ab>><cd<0ab>>]\n0x03cf <!c!d[bd]>\n0x166b <!c[a<bcd>]<!bc!d>>\n0x01be <c!<bcd><!<!0!bd>[ad]!<bcd>>>\n0x07f2 <[cd]<0a!b>!<0ad>>\n0x07e9 [<ac<!0!ab>><!bd<!0!ab>>]\n0x6996 [[bc][ad]]\n0x01af <[!ac]<0a!d>!<bcd>>\n0x033c <<b!cd><0c!d>!<bcd>>\n0x07e3 [c<d!<abc>!<0b!c>>]\n0x1681 <0[!<b!cd>[ab]]!<!d[ab]<0!ac>>>\n0x01ae <!<bcd>![!ad]<0b!d>>\n0x07e2 [<b!cd><b<!0!bc><ab!d>>]\n0x01ad <!<bcd><0b!d>[!ac]>\n0x07e1 [c<d<!0!bc>!<ab!d>>]\n0x001f <!a<a!b!d><0!c!d>>\n0x01ac [d<a<!a!cd>!<0!b!c>>]\n0x07e0 [d<ac<!abd>>]\n0x07bc [<bc<!0a!b>>!<0!d<!0a!b>>]\n0x03dc <b[d<!0bc>]!<ab<!0bc>>>\n0x06f6 <!d[ab][cd]>\n0x06bd <<b!c<0!bd>><a!b!d>!<a!c<0!bd>>>\n0x077e <<!0a![!cd]><0!ab>!<bcd>>\n0x06b9 <!<!0ac><a!b!d><b<a!b!d>![!cd]>>\n0x06b7 <!d[c[ab]]<!b!c[ab]>>\n0x06b6 [!c!<<!abc>!<0c!d>[ab]>]\n0x077a [!<0a!<!bcd>>![cd]]\n0x06b5 <!<a!b!c><a!b!d>![!c<!0!ad>]>\n0x0ff0 [cd]\n0x0779 <<ac!d><b!c!<ac!d>>!<ab![cd]>>\n0x06b4 [!c<!d<a!b!c>![ab]>]\n0x0778 [[cd]<0<b!c!d><0ab>>]\n0x007f <!d<!ab!c><0!b!d>>\n0x06b3 [![!bd]!<d<0bc><a!c!d>>]\n0x007e <!<abd><bc!d><0a!c>>\n0x06b2 [!<0!c!<a!bd>><bd!<ab!c>>]\n0x0776 <[ab][cd]!<abc>>\n0x06b1 [d<c<!0!bd>[!ab]>]\n0x06b0 [<!a!c<ab!d>><!b<ab!d>!<0cd>>]\n0x037c [[!bd]<d<!0b!c>!<acd>>]\n0x01ef <<0b!d><a!b!c>!<0ad>>\n0x0696 <<ab!c><0c!d>!<abc>>\n0x035e <<!0d![!ac]><0b!d>!<bcd>>\n0x0678 <<!ab!d><0a!b>[c<abd>]>\n0x0676 <!<abc>[ab]<0c!d>>\n0x0669 [<0!c!d><[cd]<0!c!d>[ab]>]\n0x01bc [<bd<!acd>>!<0!b!c>]\n0x0663 <0[b<a!c!d>]!<0cd>>\n0x07f0 <[cd]!<!0!cd>!<0ab>>\n0x01bf <!d<!0a!c><0!a!b>>\n0x0666 <0[ab]!<0cd>>\n0x0661 <<a!c!d>!<ab<a!c!d>>[<a!c!d><b!c!d>]>\n0x1689 [[d<abd>]<0!c<!a!bd>>]\n0x0660 [<b!c!d>!<!acd>]\n0x0182 <0<!0a!<!ac!d>>!<ad![!bc]>>\n0x07b6 [<!0!a<!bcd>>[!c<!0bd>]]\n0x03d7 <!d[!bc]!<abc>>\n0x06f1 [<!ac<!0!bc>><d<!0!bc><0!ad>>]\n0x03dd <[bd]<0!a!d>!<0cd>>\n0x0180 [<acd>!<b!d!<acd>>]\n0x07b4 [<bd<!0!ad>><c<!0!ad><abc>>]\n0x03db <[!bc]<a!b!d>!<acd>>\n0x07b0 <<0ac>[cd]!<abc>>\n0x03d4 <[cd]<0!a!d>[bd]>\n0x03c7 <!<0bd><0!a!c>[!bc]>\n0x03c6 <0!<0cd>[!b<!ac!d>]>\n0x03c5 <[bd]<0!a!c>![bc]>\n0x03c3 <!b<0b!d>[!bc]>\n0x03c1 <!<b!cd>[b<b!cd>]<!a!c<b!cd>>>\n0x03c0 [d<bcd>]\n0x1798 [<ab<!a!bc>><d<!a!bc><!0cd>>]\n0x036f <!c!d[!b<0!ac>]>\n0x03fc [d!<0!b!c>]\n0x1698 [b<<!abd>[ac][!ad]>]\n0x177e [<0!b!d>!<ac![bd]>]\n0x066f <!c!d[ab]>\n0x035b <<ac!d><0!b!c>!<0ac>>\n0x1697 <!<abc><ab!c><!bc!d>>\n0x066b [<bc<!a!bd>><a<!a!bd>!<0!cd>>]\n0x07f8 [!d!<ac!<0a!b>>]\n0x035a [!<!0c<0bd>><0!a!d>]\n0x1696 <!a<!d<0!bd><a!bc>><b!c<a!bc>>>\n0x003f <0!d!<bcd>>\n0x0673 <!b![d<ab!c>]<!a!d<ab!c>>>\n0x0359 [<!0!bc><ac[!cd]>]\n0x0672 <[cd]<0!b!d>[ab]>\n0x0358 <<!acd><0a!c>[!d<0!b!c>]>\n0x003d <!<bcd>[bc]<0!a!d>>\n0x0357 <!0!<!0bc><0!a!d>>\n0x003c <0!d![!bc]>\n0x0356 [!<0!a!d>!<0!b!c>]\n0x07e6 [<!cd!<0!a!b>><abc>]\n0x033f <!b!c!d>\n0x033d <!<bcd><bc!d><0!b<!0!ad>>>\n0x0690 <<!a!bd><0c!d><ab!c>>\n0x01e9 <!d<0!b![ac]>![b<!0ac>]>\n0x1686 [[bc]<a[bc]!<!abd>>]\n0x07f1 <!b<!ab!d>[cd]>\n0x01bd <!d[c<!ab!c>]<0!b<!ab!c>>>\n0x1683 [[bc]!<!ad<0bc>>]\n0x001e <0!d![!c<ab!d>]>\n0x01ab <!d![!ad]<0!b!c>>\n0x01aa <[ad]<0!b!c><0a!d>>\n0x01a9 [a<d<0!b!c><!0a!d>>]\n0x001b <0<a!b!d>!<acd>>\n0x01a8 [a<ad!<!0bc>>]\n0x000f <0!c!d>\n0x0199 <[!ab]<a!b!d><0!a!c>>\n0x0198 [!<!abd><!b!c<0ac>>]\n0x0197 <!d[!a<0bc>]<!b!c<0bc>>>\n0x06f9 <<!ab!d><a!b!d>[cd]>\n0x0196 <<0!d!<a!b!c>>[ad]!<bc[ad]>>\n0x03d8 [<!cd!<a!b!c>><!0b!<a!b!c>>]\n0x06f2 <a<0!a[cd]><!d[cd]![!ab]>>\n0x03de <!d![c<!ab!d>][bd]>\n0x018f <!c!d[b<!ab!c>]>\n0x0691 <0<!d<!a!bd><ab!c>><!0c<!a!bd>>>\n0x01ea [d<!0a<bcd>>]\n0x07b1 <<a!b!d><0!a!c>[cd]>\n0x0189 <[!ab]!<!0ac><0a!d>>\n0x036b <!a!<!ad![!bc]>!<!abc>>\n0x03d5 [<bcd>!<!d<bcd><0a!d>>]\n0x0186 [<!cd<0ab>>!<!a!bc>]\n0x0119 <0[!ab]!<acd>>\n0x0368 [<bcd><c<b!cd><!0ad>>]\n0x0183 <[!bc]<0a!d><0!a!b>>\n0x07b5 <!<bcd>[cd]![ac]>\n0x0181 <<!ab!c>[b<!ab!c>]<0!d!<!ab!c>>>\n0x036e <!c<bc!d>[!b<0!a!d>]>\n0x011f <!c!d!<!0ab>>\n0x016f <<!ab!c><0a!d>!<abd>>\n0x016e <!d<0!c[bd]>[a[bd]]>\n0x013f <0!<0ad>!<bcd>>\n0x019f <!d<b!c[ad]><0!a!b>>\n0x013e [!<b<!0ac><!0!cd>>![!d<!0!cd>]]\n0x019e <!d!<!bc[!ad]><0!b<!acd>>>\n0x013d <<bc!d>!<!0ac>!<bcd>>\n0x016b <!d<0!b!c>![!b[!ac]]>\n0x01fe [d<!0c<ab!c>>]\n0x166a <a[a<bcd>]!<ab<!bcd>>>\n0x0019 <!<!abd><0!a!b><0b!c>>\n0x006b <!d<0b<!a!bc>>!<!abc>>\n0x069f <!d<abd>!<abc>>\n0x013c <<0!ad><b!d!<!0b!c>>!<bc<0!ad>>>\n0x037e [<!0ad>!<!b!c<0a!d>>]\n0x012f <!d<a!b!c>!<!0ac>>\n0x0693 [<acd><d<!0c!d>![bd]>]\n0x012d <<0ac><!ab!c>!<bcd>>\n0x01ee [!<!0ab>!<d<0!cd><!0ab>>]\n0x012c [<0!a!b><!d[bc]<0!a!b>>]\n0x017f <!b!d!<acd>>\n0x1796 <!b!<!a!bc><!a<!0cd>!<!0!bd>>>\n0x036d <<abc>!<bcd><!a!c[bd]>>\n0x011e <d!<cd!<0!a!b>>!<d<0!a!b>!<0c!d>>>\n0x0679 <!d<!a<abd><0!b!c>>[c<abd>]>\n0x035f <!c!<0bd>!<!0ad>>\n0x067b <!d<!b!c[ad]>[![ad]<0b!c>]>\n0x0118 <<0!a!b><ac!d><!cd<0b!d>>>\n0x067a <[c<abd>]<0a!b>!<acd>>\n0x0117 <!b<!a!d<a!cd>><0!c!<a!cd>>>\n0x1ee1 [[cd]<0!a!b>]\n0x016a <b!<b<!0!ad>!<b!cd>>!<ab<b!cd>>>\n0x0169 <!a<a!b!c><0!d<abc>>>\n0x037d <!a<a!b!c>[!d<0!b!c>]>\n0x0697 <<!a!c<0a!b>>!<!ab!c><!ab!d>>\n0x006f <!d<0!c!d>[ab]>\n0x17ac [<abc><!0d<0!ab>>]\n0x0069 <0!d[a[!bc]]>\n0x0667 <![!ab]<0!b[!ab]>!<cd[!ab]>>\n0x0168 [<bd<!0!bc>><ad<!0bc>>]\n0x067e <!d![c<0!a!d>][ab]>\n0x011b <a!<acd>!<!0ab>>\n0x036a [!<bcd><0!a!d>]\n0x018b <!<0ad><0!b!c><0ab>>\n0x0001 <0<0!a!b><0!c!d>>\n0x1669 <<!cd<!a!bc>><b!d[!ac]>!<bd[!ac]>>\n0x0018 <!<bcd><0ab>!<!0a!c>>\n0x168b <<0!b!c>!<a<a!bd><0!b!c>>!<!a<0!b!c>!<!b!cd>>>\n0x0662 <!<!0bd>[ab][d<abc>]>\n0x00ff !d\n0x168e [!<a!c!<0!b!c>><!0<0!b!c><!ab!d>>]\n0x0007 <0!<!0cd>!<0ab>>\n0x19e6 [[ad]<0b!<0ac>>]\n0x0116 [<!b!d[!ac]><0[!ac]!<!abd>>]\n0x036c [<!a!d<0a!c>>!<!0b<0cd>>]\n0x01e8 <!d<a[bd][cd]><0!ad>>\n0x06f0 <[cd]<a!bc>!<a!bd>>\n0x03d6 [<d!<0!a!d>!<0bc>><bc!<0bc>>]\n0x1be4 [d!<!b!c[ac]>]\n0x0187 <a!<!0ac>!<ad![!bc]>>\n0x0003 <0!d<0!b!c>>\n0x017e [[!bd]<<!ab!c>[!bd]<!0bd>>]\n0x01eb <!d[b<0!a!c>]!<!ab!<0!a!c>>>\n0x0006 <0[ab]<0!c!d>>\n0x011a <0[d[ac]]!<bcd>>\n0x0369 <!b<0!d<abc>><b!c!<0a!d>>>\n0x03d9 [d<<!0!ab><bcd><a!b!d>>]\n0x0000 0\n0x019b <!d<0!b!c>![ab]>\n0x1668 [<bcd><ab<!bcd>>]\n0x18e7 [[!cd]<abc>]\n0x0017 <0!d!<abc>>\n0x019a <!d![a<b!c!d>]!<!0c<b!c!d>>>\n0x0016 <0<a!d<bc!d>>!<abc>>";
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/pattern_generation.hpp b/include/mockturtle/algorithms/pattern_generation.hpp
new file mode 100644
index 0000000..dd721c3
--- /dev/null
+++ b/include/mockturtle/algorithms/pattern_generation.hpp
@@ -0,0 +1,603 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file pattern_generation.hpp
+  \brief Expressive Simulation Pattern Generation
+
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../networks/aig.hpp"
+#include "../utils/progress_bar.hpp"
+#include "../utils/stopwatch.hpp"
+#include "circuit_validator.hpp"
+#include "dont_cares.hpp"
+#include "simulation.hpp"
+#include <bill/sat/interface/abc_bsat2.hpp>
+#include <bill/sat/interface/z3.hpp>
+#include <kitty/partial_truth_table.hpp>
+#include <random>
+
+namespace mockturtle
+{
+
+struct pattern_generation_params
+{
+  /*! \brief Number of patterns each node should have for both values.
+   *
+   * When this parameter is set to greater than 1, and if the network has more
+   * than 2048 PIs, the `BUFFER_SIZE` in `lib/bill/sat/interface/abc_bsat2.hpp`
+   * has to be increased to at least `ntk.num_pis()`.
+   */
+  uint32_t num_stuck_at{ 1 };
+
+  /*! \brief Whether to consider observability, and how many levels. 0 = no. -1 = Consider TFO until PO. */
+  int32_t odc_levels{ 0 };
+
+  /*! \brief Show progress. */
+  bool progress{ false };
+
+  /*! \brief Be verbose. Note that it will take more time to do extra ODC computation if this is turned on. */
+  bool verbose{ false };
+
+  /*! \brief Random seed. */
+  std::default_random_engine::result_type random_seed{ 1 };
+
+  /*! \brief Conflict limit of the SAT solver. */
+  uint32_t conflict_limit{ 1000 };
+
+  /*! \brief Maximum number of clauses of the SAT solver. (incremental CNF construction) */
+  uint32_t max_clauses{ 1000 };
+};
+
+struct pattern_generation_stats
+{
+  /*! \brief Total time. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Time for simulation. */
+  stopwatch<>::duration time_sim{ 0 };
+
+  /*! \brief Time for SAT solving. */
+  stopwatch<>::duration time_sat{ 0 };
+
+  /*! \brief Time for ODC computation */
+  stopwatch<>::duration time_odc{ 0 };
+
+  /*! \brief Number of constant nodes. */
+  uint32_t num_constant{ 0 };
+
+  /*! \brief Number of generated patterns. */
+  uint32_t num_generated_patterns{ 0 };
+
+  /*! \brief Number of stuck-at patterns that is re-generated because the original one was unobservable. */
+  uint32_t unobservable_type1{ 0 };
+
+  /*! \brief Number of additional patterns generated because the node was unobservable with one value. */
+  uint32_t unobservable_type2{ 0 };
+
+  /*! \brief Number of unobservable nodes (node for which an observable pattern can not be found). */
+  uint32_t unobservable_node{ 0 };
+};
+
+namespace detail
+{
+
+template<class Ntk, class Simulator, bool use_odc = false, bool substitute_const = false>
+class patgen_impl
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  using TT = incomplete_node_map<kitty::partial_truth_table, Ntk>;
+
+  explicit patgen_impl( Ntk& ntk, Simulator& sim, pattern_generation_params const& ps, validator_params& vps, pattern_generation_stats& st )
+      : ntk( ntk ), ps( ps ), st( st ), vps( vps ), validator( ntk, vps ),
+        tts( ntk ), sim( sim )
+  {
+  }
+
+  void run()
+  {
+    stopwatch t( st.time_total );
+
+    if constexpr ( has_EXCDC_interface_v<Ntk> )
+    {
+      sim.remove_CDC_patterns( ntk );
+    }
+
+    call_with_stopwatch( st.time_sim, [&]() {
+      simulate_nodes<Ntk>( ntk, tts, sim, true );
+    } );
+
+    if ( ps.num_stuck_at > 0 )
+    {
+      stuck_at_check();
+      if constexpr ( std::is_same_v<Simulator, bit_packed_simulator> )
+      {
+        sim.pack_bits();
+        call_with_stopwatch( st.time_sim, [&]() {
+          tts.reset();
+          simulate_nodes<Ntk>( ntk, tts, sim, true );
+        } );
+      }
+      if constexpr ( substitute_const )
+      {
+        for ( auto n : const_nodes )
+        {
+          if ( !ntk.is_dead( ntk.get_node( n ) ) )
+          {
+            ntk.substitute_node( ntk.get_node( n ), ntk.get_constant( ntk.is_complemented( n ) ) );
+          }
+        }
+      }
+    }
+
+    if constexpr ( use_odc )
+    {
+      observability_check();
+      if constexpr ( std::is_same_v<Simulator, bit_packed_simulator> )
+      {
+        sim.pack_bits();
+        call_with_stopwatch( st.time_sim, [&]() {
+          tts.reset();
+          simulate_nodes<Ntk>( ntk, tts, sim, true );
+        } );
+      }
+    }
+
+    if constexpr ( std::is_same_v<Simulator, bit_packed_simulator> )
+    {
+      sim.randomize_dont_care_bits( ps.random_seed );
+      if constexpr ( has_EXCDC_interface_v<Ntk> )
+      {
+        sim.remove_CDC_patterns( ntk );
+      }
+    }
+  }
+
+private:
+  void stuck_at_check()
+  {
+    progress_bar pbar{ ntk.size(), "patgen-sa |{0}| node = {1:>4} #pat = {2:>4}", ps.progress };
+
+    kitty::partial_truth_table zero = sim.compute_constant( false );
+
+    ntk.foreach_gate( [&]( auto const& n, auto i ) {
+      pbar( i, i, sim.num_bits() );
+
+      if ( tts[n].num_bits() != sim.num_bits() )
+      {
+        call_with_stopwatch( st.time_sim, [&]() {
+          simulate_node<Ntk>( ntk, n, tts, sim );
+        } );
+      }
+      assert( zero.num_bits() == sim.num_bits() );
+
+      if ( ( tts[n] == zero ) || ( tts[n] == ~zero ) )
+      {
+        bool value = ( tts[n] == zero ); /* wanted value of n */
+
+        const auto res = call_with_stopwatch( st.time_sat, [&]() {
+          validator.set_odc_levels( 0 );
+          return validator.validate( n, !value );
+        } );
+        if ( !res )
+        {
+          return true; /* timeout, next node */
+        }
+        else if ( !( *res ) ) /* SAT, pattern found */
+        {
+          if constexpr ( use_odc )
+          {
+            /* check if the found pattern is observable */
+            bool observable = call_with_stopwatch( st.time_odc, [&]() {
+              return pattern_is_observable( ntk, n, validator.cex, ps.odc_levels );
+            } );
+            if ( !observable )
+            {
+              if ( ps.verbose )
+              {
+                std::cout << "\t[i] generated pattern is not observable (type 1). node: " << n << ", with value " << value << "\n";
+              }
+
+              const auto res2 = call_with_stopwatch( st.time_sat, [&]() {
+                validator.set_odc_levels( ps.odc_levels );
+                return validator.validate( n, !value );
+              } );
+              if ( res2 )
+              {
+                if ( !( *res2 ) )
+                {
+                  ++st.unobservable_type1;
+                  if ( ps.verbose )
+                  {
+                    assert( pattern_is_observable( ntk, n, validator.cex, ps.odc_levels ) );
+                    std::cout << "\t\t[i] unobservable pattern resolved.\n";
+                  }
+                }
+                else
+                {
+                  ++st.unobservable_node;
+                  if ( ps.verbose )
+                  {
+                    std::cout << "\t\t[i] unobservable node " << n << "\n";
+                  }
+                }
+              }
+            }
+          }
+
+          new_pattern( validator.cex, n );
+
+          if ( ps.num_stuck_at > 1 )
+          {
+            auto generated = call_with_stopwatch( st.time_sat, [&]() {
+              validator.set_odc_levels( ps.odc_levels );
+              return validator.generate_pattern( n, value, { validator.cex }, ps.num_stuck_at - 1 );
+            } );
+            for ( auto& pattern : generated )
+            {
+              new_pattern( pattern, n );
+            }
+          }
+
+          zero = sim.compute_constant( false );
+        }
+        else /* UNSAT, constant node */
+        {
+          ++st.num_constant;
+          const_nodes.emplace_back( value ? ntk.make_signal( n ) : !ntk.make_signal( n ) );
+          return true; /* next gate */
+        }
+      }
+      else if ( ps.num_stuck_at > 1 )
+      {
+        auto const& tt = tts[n];
+        if ( kitty::count_ones( tt ) < ps.num_stuck_at )
+        {
+          generate_more_patterns( n, tt, true, zero );
+        }
+        else if ( kitty::count_zeros( tt ) < ps.num_stuck_at )
+        {
+          generate_more_patterns( n, tt, false, zero );
+        }
+      }
+      return true; /* next gate */
+    } );
+  }
+
+  void observability_check()
+  {
+    progress_bar pbar{ ntk.size(), "patgen-obs |{0}| node = {1:>4} #pat = {2:>4}", ps.progress };
+
+    kitty::partial_truth_table zero = sim.compute_constant( false );
+
+    ntk.foreach_gate( [&]( auto const& n, auto i ) {
+      pbar( i, i, sim.num_bits() );
+
+      for ( auto& f : const_nodes )
+      {
+        if ( ntk.get_node( f ) == n )
+        {
+          return true; /* skip constant nodes */
+        }
+      }
+
+      if ( tts[n].num_bits() != sim.num_bits() )
+      {
+        call_with_stopwatch( st.time_sim, [&]() {
+          simulate_node<Ntk>( ntk, n, tts, sim );
+        } );
+      }
+      assert( zero.num_bits() == sim.num_bits() );
+
+      /* compute ODC */
+      auto odc = call_with_stopwatch( st.time_odc, [&]() {
+        return observability_dont_cares<Ntk>( ntk, n, sim, tts, ps.odc_levels );
+      } );
+
+      /* check if under non-ODCs n is always the same value */
+      if ( ( tts[n] & ~odc ) == zero )
+      {
+        if ( ps.verbose )
+        {
+          std::cout << "\t[i] under all observable patterns, node " << n << " is always 0 (type 2).\n";
+        }
+
+        const auto res = call_with_stopwatch( st.time_sat, [&]() {
+          validator.set_odc_levels( ps.odc_levels );
+          return validator.validate( n, false );
+        } );
+        if ( res )
+        {
+          if ( !( *res ) )
+          {
+            new_pattern( validator.cex, n );
+            ++st.unobservable_type2;
+
+            if ( ps.verbose )
+            {
+              auto odc2 = call_with_stopwatch( st.time_odc, [&]() { return observability_dont_cares<Ntk>( ntk, n, sim, tts, ps.odc_levels ); } );
+              assert( ( tts[n] & ~odc2 ) != sim.compute_constant( false ) );
+              std::cout << "\t\t[i] added generated pattern to resolve unobservability.\n";
+            }
+
+            zero = sim.compute_constant( false );
+          }
+          else
+          {
+            ++st.unobservable_node;
+            if ( ps.verbose )
+            {
+              std::cout << "\t\t[i] unobservable node " << n << "\n";
+            }
+          }
+        }
+      }
+      else if ( ( tts[n] | odc ) == ~zero )
+      {
+        if ( ps.verbose )
+        {
+          std::cout << "\t[i] under all observable patterns, node " << n << " is always 1 (type 2).\n";
+        }
+
+        const auto res = call_with_stopwatch( st.time_sat, [&]() {
+          validator.set_odc_levels( ps.odc_levels );
+          return validator.validate( n, true );
+        } );
+        if ( res )
+        {
+          if ( !( *res ) )
+          {
+            new_pattern( validator.cex, n );
+            ++st.unobservable_type2;
+
+            if ( ps.verbose )
+            {
+              auto odc2 = call_with_stopwatch( st.time_odc, [&]() { return observability_dont_cares<Ntk>( ntk, n, sim, tts, ps.odc_levels ); } );
+              assert( ( tts[n] | odc2 ) != sim.compute_constant( true ) );
+              std::cout << "\t\t[i] added generated pattern to resolve unobservability.\n";
+            }
+
+            zero = sim.compute_constant( false );
+          }
+          else
+          {
+            ++st.unobservable_node;
+            if ( ps.verbose )
+            {
+              std::cout << "\t\t[i] unobservable node " << n << "\n";
+            }
+          }
+        }
+      }
+
+      return true; /* next gate */
+    } );
+  }
+
+private:
+  void new_pattern( std::vector<bool> const& pattern, node const& n )
+  {
+    if constexpr ( std::is_same_v<Simulator, bit_packed_simulator> )
+    {
+      sim.add_pattern( pattern, compute_support( n ) );
+    }
+    else
+    {
+      (void)n;
+      sim.add_pattern( pattern );
+    }
+
+    if constexpr ( has_EXCDC_interface_v<Ntk> )
+    {
+      assert( !ntk.pattern_is_EXCDC( pattern ) );
+    }
+    ++st.num_generated_patterns;
+
+    /* re-simulate */
+    if ( sim.num_bits() % 64 == 0 )
+    {
+      call_with_stopwatch( st.time_sim, [&]() {
+        simulate_nodes<Ntk>( ntk, tts, sim, false );
+      } );
+    }
+  }
+
+  void generate_more_patterns( node const& n, kitty::partial_truth_table const& tt, bool value, kitty::partial_truth_table& zero )
+  {
+    /* collect the `value` patterns */
+    std::vector<std::vector<bool>> patterns;
+    for ( auto i = 0u; i < tt.num_bits(); ++i )
+    {
+      if ( kitty::get_bit( tt, i ) == value )
+      {
+        patterns.emplace_back();
+        ntk.foreach_pi( [&]( auto const& pi ) {
+          patterns.back().emplace_back( kitty::get_bit( tts[pi], i ) );
+        } );
+      }
+    }
+
+    auto generated = call_with_stopwatch( st.time_sat, [&]() {
+      validator.set_odc_levels( ps.odc_levels );
+      return validator.generate_pattern( n, value, patterns, ps.num_stuck_at - patterns.size() );
+    } );
+    for ( auto& pattern : generated )
+    {
+      new_pattern( pattern, n );
+    }
+    zero = sim.compute_constant( false );
+  }
+
+  std::vector<bool> compute_support( node const& n )
+  {
+    ntk.incr_trav_id();
+    if constexpr ( use_odc )
+    {
+      if ( ps.odc_levels != 0 )
+      {
+        std::vector<node> leaves;
+        mark_fanout_leaves_rec( n, 1, leaves );
+        ntk.foreach_po( [&]( auto const& f ) {
+          if ( ntk.visited( ntk.get_node( f ) ) == ntk.trav_id() )
+          {
+            leaves.emplace_back( ntk.get_node( f ) );
+          }
+        } );
+
+        ntk.incr_trav_id();
+        for ( auto& l : leaves )
+        {
+          mark_support_rec( l );
+        }
+      }
+    }
+    mark_support_rec( n );
+
+    std::vector<bool> care( ntk.num_pis(), false );
+    ntk.foreach_pi( [&]( auto const& f, uint32_t i ) {
+      if ( ntk.visited( f ) == ntk.trav_id() )
+      {
+        care[i] = true;
+      }
+    } );
+    return care;
+  }
+
+  void mark_support_rec( node const& n )
+  {
+    if ( ntk.visited( n ) == ntk.trav_id() )
+    {
+      return;
+    }
+    ntk.set_visited( n, ntk.trav_id() );
+
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      if ( ntk.visited( ntk.get_node( f ) ) == ntk.trav_id() )
+      {
+        return true;
+      }
+      mark_support_rec( ntk.get_node( f ) );
+      return true;
+    } );
+  }
+
+  void mark_fanout_leaves_rec( node const& n, int32_t level, std::vector<node>& leaves )
+  {
+    ntk.foreach_fanout( n, [&]( auto const& fo ) {
+      if ( ntk.visited( fo ) == ntk.trav_id() )
+      {
+        return true;
+      }
+      ntk.set_visited( fo, ntk.trav_id() );
+
+      if ( level == ps.odc_levels )
+      {
+        leaves.emplace_back( fo );
+        return true;
+      }
+
+      mark_fanout_leaves_rec( fo, level + 1, leaves );
+      return true;
+    } );
+  }
+
+private:
+  Ntk& ntk;
+
+  pattern_generation_params const& ps;
+  pattern_generation_stats& st;
+
+  validator_params& vps;
+  circuit_validator<Ntk, bill::solvers::bsat2, true, true, use_odc> validator;
+
+  TT tts;
+  std::vector<signal> const_nodes;
+
+  Simulator& sim;
+};
+
+} /* namespace detail */
+
+/*! \brief Expressive simulation pattern generation.
+ *
+ * This function implements two simulation pattern generation methods:
+ * stuck-at value checking and observability checking. Please refer to
+ * [1] for details of the algorithm and its purpose.
+ *
+ * [1] Simulation-Guided Boolean Resubstitution. IWLS 2020 (arXiv:2007.02579).
+ *
+ * \param sim Reference of a `partial_simulator` or `bit_packed_simulator`
+ * object where the generated patterns will be stored.
+ * It can be empty (`Simulator( ntk.num_pis(), 0 )`)
+ * or already containing some patterns generated from previous runs
+ * (`Simulator( filename )`) or randomly generated
+ * (`Simulator( ntk.num_pis(), num_random_patterns )`). The generated
+ * patterns can then be written out with `write_patterns`
+ * or directly be used by passing the simulator to another algorithm.
+ */
+template<bool substitute_const = false, class Ntk, class Simulator>
+void pattern_generation( Ntk& ntk, Simulator& sim, pattern_generation_params const& ps = {}, pattern_generation_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+  static_assert( std::is_same_v<Simulator, partial_simulator> || std::is_same_v<Simulator, bit_packed_simulator>, "Simulator should be either partial_simulator or bit_packed_simulator" );
+
+  pattern_generation_stats st;
+  validator_params vps;
+  vps.conflict_limit = ps.conflict_limit;
+  vps.max_clauses = ps.max_clauses;
+  vps.random_seed = ps.random_seed;
+
+  if ( ps.odc_levels != 0 )
+  {
+    using fanout_view_t = fanout_view<Ntk>;
+    fanout_view_t fanout_view{ ntk };
+
+    detail::patgen_impl<fanout_view_t, Simulator, /*use_odc*/ true, substitute_const> p( fanout_view, sim, ps, vps, st );
+    p.run();
+  }
+  else
+  {
+    detail::patgen_impl<Ntk, Simulator, /*use_odc*/ false, substitute_const> p( ntk, sim, ps, vps, st );
+    p.run();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/reconv_cut.hpp b/include/mockturtle/algorithms/reconv_cut.hpp
new file mode 100644
index 0000000..3c7e5fe
--- /dev/null
+++ b/include/mockturtle/algorithms/reconv_cut.hpp
@@ -0,0 +1,461 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file reconv_cut.hpp
+  \brief Implements reconvergence-driven cuts (based on ABC's
+  implementation in `abcReconv.c` by Alan Mishchenko).
+
+  \author Heinz Riener
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+
+#include <cassert>
+#include <iostream>
+#include <optional>
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for reconvergence-driven cut computation
+ *
+ * The data structure `reconvergence_driven_cut_parameters` holds configurable parameters
+ * with default arguments for `reconvergence_driven_cut_impl*`.
+ */
+struct reconvergence_driven_cut_parameters
+{
+  /* Maximum number of leaves */
+  uint64_t max_leaves{ 8u };
+
+  /* Skip nodes with many fanouts */
+  uint64_t max_fanouts{ 100000u };
+
+  /* Initially reserve memory for a fixed number of nodes */
+  uint64_t reserve_memory_for_nodes{ 300u };
+};
+
+/*! \brief Statistics for reconvergence-driven cut computation
+ *
+ * The data structure `reconvergence_driven_cut_statistics` holds data
+ * collected when running a reconvergence-driven cut computation
+ * algorithm.
+ */
+struct reconvergence_driven_cut_statistics
+{
+  /* Total number of calls */
+  uint64_t num_calls{ 0 };
+
+  /* Total number of leaves */
+  uint64_t num_leaves{ 0 };
+
+  /* Total number of nodes */
+  uint64_t num_nodes{ 0 };
+};
+
+/*! \cond PRIVATE */
+namespace detail
+{
+
+template<typename Ntk, bool compute_nodes = false, bool sort_equal_cost_by_level = true>
+class reconvergence_driven_cut_impl
+{
+public:
+  using parameters_type = reconvergence_driven_cut_parameters;
+  using statistics_type = reconvergence_driven_cut_statistics;
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+public:
+  explicit reconvergence_driven_cut_impl( Ntk const& ntk, reconvergence_driven_cut_parameters const& ps, reconvergence_driven_cut_statistics& st )
+      : ntk( ntk ), ps( ps ), st( st )
+  {
+    leaves.reserve( ps.max_leaves );
+    if constexpr ( compute_nodes )
+    {
+      nodes.reserve( ps.reserve_memory_for_nodes );
+    }
+  }
+
+  std::pair<std::vector<node>, std::vector<node>> run( std::vector<node> const& pivots )
+  {
+    assert( pivots.size() > 0u );
+
+    /* prepare for traversal and clean internal state */
+    ntk.incr_trav_id();
+    nodes.clear();
+    leaves.clear();
+
+    /* collect and mark all pivots */
+    for ( const auto& pivot : pivots )
+    {
+      if constexpr ( compute_nodes )
+      {
+        nodes.emplace_back( pivot );
+      }
+      ntk.set_visited( pivot, ntk.trav_id() );
+    }
+
+    leaves = pivots;
+
+    if ( leaves.size() > ps.max_leaves )
+    {
+      /* special case: cut already overflows at the current node because the cut size limit is very low */
+      leaves.clear();
+      nodes.clear();
+      return { leaves, nodes };
+    }
+
+    /* compute the cut */
+    while ( construct_cut() )
+      ;
+    assert( leaves.size() <= ps.max_leaves );
+
+    /* update statistics */
+    ++st.num_calls;
+    st.num_leaves += leaves.size();
+    st.num_nodes += nodes.size();
+
+    return { leaves, nodes };
+  }
+
+private:
+  bool construct_cut()
+  {
+    uint64_t best_cost{ std::numeric_limits<uint64_t>::max() };
+    std::optional<node> best_fanin;
+    uint64_t best_position;
+
+    /* evaluate fanins of the cut */
+    uint64_t position{ 0 };
+    for ( const auto& l : leaves )
+    {
+      uint64_t const current_cost{ cost( l ) };
+      if constexpr ( sort_equal_cost_by_level )
+      {
+        if ( best_cost > current_cost ||
+             ( best_cost == current_cost && best_fanin && ntk.level( l ) > ntk.level( *best_fanin ) ) )
+        {
+          best_cost = current_cost;
+          best_fanin = std::make_optional( l );
+          best_position = position;
+        }
+      }
+      else
+      {
+        if ( best_cost > current_cost )
+        {
+          best_cost = current_cost;
+          best_fanin = std::make_optional( l );
+          best_position = position;
+        }
+      }
+
+      if ( best_cost == 0u )
+      {
+        break;
+      }
+
+      ++position;
+    }
+
+    if ( !best_fanin )
+    {
+      return false;
+    }
+
+    if ( leaves.size() - 1 + best_cost > ps.max_leaves )
+    {
+      return false;
+    }
+
+    /* remove the best node from the array */
+    leaves.erase( std::begin( leaves ) + best_position );
+
+    /* add the fanins of best to leaves and nodes */
+    ntk.foreach_fanin( *best_fanin, [&]( signal const& fi ) {
+      node const& n = ntk.get_node( fi );
+      if ( n != 0 && ( ntk.visited( n ) != ntk.trav_id() ) )
+      {
+        ntk.set_visited( n, ntk.trav_id() );
+        if constexpr ( compute_nodes )
+        {
+          nodes.emplace_back( n );
+        }
+        leaves.emplace_back( n );
+      }
+    } );
+
+    assert( leaves.size() <= ps.max_leaves );
+    return true;
+  }
+
+  uint64_t cost( node const& n ) const
+  {
+    /* make sure the node is in the construction zone */
+    assert( ntk.visited( n ) == ntk.trav_id() );
+
+    /* cannot expand over a constant or CI node */
+    if ( ntk.is_constant( n ) || ntk.is_ci( n ) )
+    {
+      return std::numeric_limits<uint64_t>::max();
+    }
+
+    /* count the number of leaves that we haven't visited */
+    uint64_t cost{ 0 };
+    ntk.foreach_fanin( n, [&]( signal const& fi ) {
+      cost += ntk.visited( ntk.get_node( fi ) ) != ntk.trav_id();
+    } );
+
+    /* always accept if the number of leaves does not increase */
+    if ( cost < ntk.fanin_size( n ) )
+    {
+      return cost;
+    }
+
+    /* skip nodes with many fanouts */
+    if ( ntk.fanout_size( n ) > ps.max_fanouts )
+    {
+      return std::numeric_limits<uint64_t>::max();
+    }
+
+    /* return the number of nodes that will be on the leaves if this node is removed */
+    return cost;
+  }
+
+private:
+  Ntk const& ntk;
+  reconvergence_driven_cut_parameters ps;
+  reconvergence_driven_cut_statistics& st;
+
+  std::vector<node> leaves;
+  std::vector<node> nodes;
+}; /* reconvergence_drive_cut_impl */
+
+template<typename Ntk, bool compute_nodes = false, bool sort_equal_cost_by_level = false>
+class reconvergence_driven_cut_impl2
+{
+public:
+  using parameters_type = reconvergence_driven_cut_parameters;
+  using statistics_type = reconvergence_driven_cut_statistics;
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+public:
+  explicit reconvergence_driven_cut_impl2( Ntk const& ntk, reconvergence_driven_cut_parameters const& ps, reconvergence_driven_cut_statistics& st )
+      : ntk( ntk ), ps( ps ), st( st )
+  {
+  }
+
+  std::pair<std::vector<node>, std::vector<node>> run( std::vector<node> const& pivots )
+  {
+    assert( pivots.size() > 0u );
+
+    /* prepare for traversal and clean internal state */
+    ntk.incr_trav_id();
+    nodes.clear();
+    leaves.clear();
+    assert( nodes.empty() );
+
+    for ( const auto& pivot : pivots )
+    {
+      ntk.set_visited( pivot, ntk.trav_id() );
+    }
+
+    while ( construct_cut() )
+      ;
+    assert( leaves.size() <= ps.max_leaves );
+
+    /* update statistics */
+    ++st.num_calls;
+    st.num_leaves += leaves.size();
+    st.num_nodes += nodes.size();
+
+    return { leaves, nodes };
+  }
+
+  bool construct_cut()
+  {
+    assert( leaves.size() <= ps.max_leaves && "cut-size overflow" );
+    std::stable_sort( std::begin( leaves ), std::end( leaves ),
+               [this]( node const& a, node const& b ) {
+                 return cost( a ) < cost( b );
+               } );
+
+    /* find the first non-pi node to extend the cut (because the vector is sorted, this non-pi is cost-minimal) */
+    auto const it = std::find_if( std::begin( leaves ), std::end( leaves ),
+                                  [&]( node const& n ) {
+                                    return !ntk.is_ci( n );
+                                  } );
+    if ( std::end( leaves ) == it )
+    {
+      /* if all nodes are pis, then the cut cannot be extended */
+      return false;
+    }
+
+    /* the cost is identical to the number of nodes added to `leaves` if *it is used to expand leaves */
+    int64_t const c = cost( *it );
+    if ( leaves.size() + c > ps.max_leaves )
+    {
+      /* if the expansion exceeds the cut_size, then the cut cannot be extended */
+      return false;
+    }
+
+    /* otherwise expand the cut with the children of *it and mark *it visited */
+    node const n = *it;
+    leaves.erase( it );
+    ntk.foreach_fanin( n, [&]( signal const& fi ) {
+      node const& child = ntk.get_node( fi );
+      if ( !ntk.is_constant( child ) && std::find( std::begin( leaves ), std::end( leaves ), child ) == std::end( leaves ) && ntk.visited( child ) != ntk.trav_id() )
+      {
+        leaves.emplace_back( child );
+        ntk.set_visited( child, ntk.trav_id() );
+      }
+    } );
+
+    assert( leaves.size() <= ps.max_leaves );
+    return true;
+  }
+
+  /* counts the number of non-constant leaves */
+  int64_t cost( node const& n ) const
+  {
+    int32_t current_cost = -1;
+    ntk.foreach_fanin( n, [&]( signal const& s ) {
+      auto const& child = ntk.get_node( s );
+      if ( !ntk.is_constant( child ) )
+      {
+        ++current_cost;
+      }
+    } );
+    return current_cost;
+  }
+
+private:
+  Ntk const& ntk;
+  reconvergence_driven_cut_parameters ps;
+  reconvergence_driven_cut_statistics& st;
+
+  std::vector<node> leaves;
+  std::vector<node> nodes;
+}; /* reconvergence_drive_cut_impl2 */
+
+template<typename Ntk, typename Impl>
+std::pair<std::vector<node<Ntk>>, std::vector<node<Ntk>>> reconvergence_driven_cut( Ntk const& ntk, std::vector<node<Ntk>> const& pivots, reconvergence_driven_cut_parameters const& ps, reconvergence_driven_cut_statistics& st )
+{
+  return Impl( ntk, ps, st ).run( pivots );
+}
+
+} // namespace detail
+/*! \endcond */
+
+/*! \brief Reconvergence-driven cut towards inputs.
+ *
+ * This class implements a generation algorithm for
+ * reconvergence-driven cuts.  The cut grows towards the primary
+ * inputs starting from a set of pivot nodes.
+ *
+ * **Required network functions:**
+ * - `is_constant`
+ * - `is_pi`
+ * - `get_node`
+ * - `visited`
+ * - `has_visited`
+ * - `foreach_fanin`
+ *
+ */
+template<typename Ntk, bool compute_nodes = false, bool sort_equal_cost_by_level = true>
+std::pair<std::vector<node<Ntk>>, std::vector<node<Ntk>>> reconvergence_driven_cut( Ntk const& ntk, std::vector<node<Ntk>> const& pivots, reconvergence_driven_cut_parameters const& ps = {}, reconvergence_driven_cut_statistics* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_ci_v<Ntk>, "Ntk does not implement the is_ci method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_visited_v<Ntk>, "Ntk does not implement the has_visited method" );
+  static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  if constexpr ( sort_equal_cost_by_level )
+  {
+    static_assert( has_level_v<Ntk>, "Ntk does not implement the level method" );
+  }
+
+  using Impl = detail::reconvergence_driven_cut_impl<Ntk, compute_nodes, sort_equal_cost_by_level>;
+
+  reconvergence_driven_cut_statistics st;
+  auto const result = detail::reconvergence_driven_cut<Ntk, Impl>( ntk, pivots, ps, st );
+  if ( pst )
+  {
+    *pst = st;
+  }
+  return result;
+}
+
+/*! \brief Reconvergence-driven cut towards inputs.
+ *
+ * This class implements a generation algorithm for
+ * reconvergence-driven cuts.  The cut grows towards the primary
+ * inputs starting from a single pivot node.
+ *
+ * **Required network functions:**
+ * - `is_constant`
+ * - `is_pi`
+ * - `get_node`
+ * - `visited`
+ * - `has_visited`
+ * - `foreach_fanin`
+ *
+ */
+template<typename Ntk, bool compute_nodes = false, bool sort_equal_cost_by_level = true>
+std::pair<std::vector<node<Ntk>>, std::vector<node<Ntk>>> reconvergence_driven_cut( Ntk const& ntk, node<Ntk> const& pivot, reconvergence_driven_cut_parameters const& ps = {}, reconvergence_driven_cut_statistics* pst = nullptr )
+{
+  return reconvergence_driven_cut<Ntk, compute_nodes, sort_equal_cost_by_level>( ntk, std::vector<node<Ntk>>{ pivot }, ps, pst );
+}
+
+/*! \brief Reconvergence-driven cut towards inputs.
+ *
+ * This class implements a generation algorithm for
+ * reconvergence-driven cuts.  The cut grows towards the primary
+ * inputs starting from a single pivot signal.
+ *
+ * **Required network functions:**
+ * - `is_constant`
+ * - `is_pi`
+ * - `get_node`
+ * - `visited`
+ * - `has_visited`
+ * - `foreach_fanin`
+ *
+ */
+template<typename Ntk, bool compute_nodes = false, bool sort_equal_cost_by_level = true>
+std::pair<std::vector<node<Ntk>>, std::vector<node<Ntk>>> reconvergence_driven_cut( Ntk const& ntk, signal<Ntk> const& pivot, reconvergence_driven_cut_parameters const& ps = {}, reconvergence_driven_cut_statistics* pst = nullptr )
+{
+  return reconvergence_driven_cut<Ntk, compute_nodes, sort_equal_cost_by_level>( ntk, std::vector<node<Ntk>>{ ntk.get_node( pivot ) }, ps, pst );
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/refactoring.hpp b/include/mockturtle/algorithms/refactoring.hpp
new file mode 100644
index 0000000..dbdef72
--- /dev/null
+++ b/include/mockturtle/algorithms/refactoring.hpp
@@ -0,0 +1,420 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file refactoring.hpp
+  \brief Refactoring
+
+  \author Alessandro Tempia Calvino
+  \author Eleonora Testa
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+#pragma once
+
+#include "../networks/mig.hpp"
+#include "../traits.hpp"
+#include "../utils/cost_functions.hpp"
+#include "../utils/progress_bar.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../views/cut_view.hpp"
+#include "../views/mffc_view.hpp"
+#include "../views/topo_view.hpp"
+#include "../views/window_view.hpp"
+#include "../views/color_view.hpp"
+#include "cleanup.hpp"
+#include "detail/mffc_utils.hpp"
+#include "dont_cares.hpp"
+#include "simulation.hpp"
+
+#include <fmt/format.h>
+#include <kitty/dynamic_truth_table.hpp>
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for refactoring.
+ *
+ * The data structure `refactoring_params` holds configurable parameters with
+ * default arguments for `refactoring`.
+ */
+struct refactoring_params
+{
+  /*! \brief Maximum number of PIs of the MFFC or window. */
+  uint32_t max_pis{ 6 };
+
+  /*! \brief Allow zero-gain substitutions */
+  bool allow_zero_gain{ false };
+
+  /*! \brief Extract a reconvergence-driven cut for large MFFcs */
+  bool use_reconvergence_cut{ true };
+
+  /*! \brief Use don't cares for optimization. */
+  bool use_dont_cares{ false };
+
+  /*! \brief Show progress. */
+  bool progress{ false };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+};
+
+/*! \brief Statistics for refactoring.
+ *
+ * The data structure `refactoring_stats` provides data collected by running
+ * `refactoring`.
+ */
+struct refactoring_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Accumulated runtime for computing MFFCs. */
+  stopwatch<>::duration time_mffc{ 0 };
+
+  /*! \brief Accumulated runtime for rewriting. */
+  stopwatch<>::duration time_refactoring{ 0 };
+
+  /*! \brief Accumulated runtime for simulating MFFCs. */
+  stopwatch<>::duration time_simulation{ 0 };
+
+  void report() const
+  {
+    std::cout << fmt::format( "[i] total time       = {:>5.2f} secs\n", to_seconds( time_total ) );
+    std::cout << fmt::format( "[i] MFFC time        = {:>5.2f} secs\n", to_seconds( time_mffc ) );
+    std::cout << fmt::format( "[i] refactoring time = {:>5.2f} secs\n", to_seconds( time_refactoring ) );
+    std::cout << fmt::format( "[i] simulation time  = {:>5.2f} secs\n", to_seconds( time_simulation ) );
+  }
+};
+
+namespace detail
+{
+
+template<class Ntk, class RefactoringFn, class Iterator, class = void>
+struct has_refactoring_with_dont_cares : std::false_type
+{
+};
+
+template<class Ntk, class RefactoringFn, class Iterator>
+struct has_refactoring_with_dont_cares<Ntk,
+                                       RefactoringFn, Iterator,
+                                       std::void_t<decltype( std::declval<RefactoringFn>()( std::declval<Ntk&>(),
+                                                                                            std::declval<kitty::dynamic_truth_table>(),
+                                                                                            std::declval<kitty::dynamic_truth_table>(),
+                                                                                            std::declval<Iterator const&>(),
+                                                                                            std::declval<Iterator const&>(),
+                                                                                            std::declval<void( signal<Ntk> )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk, class RefactoringFn, class Iterator>
+inline constexpr bool has_refactoring_with_dont_cares_v = has_refactoring_with_dont_cares<Ntk, RefactoringFn, Iterator>::value;
+
+template<class Ntk, class RefactoringFn, class NodeCostFn>
+class refactoring_impl
+{
+public:
+  refactoring_impl( Ntk& ntk, RefactoringFn&& refactoring_fn, refactoring_params const& ps, refactoring_stats& st, NodeCostFn const& cost_fn )
+      : ntk( ntk ), refactoring_fn( refactoring_fn ), ps( ps ), st( st ), cost_fn( cost_fn ) {}
+
+  void run()
+  {
+    progress_bar pbar{ ntk.size(), "refactoring |{0}| node = {1:>4}   cand = {2:>4}   est. reduction = {3:>5}", ps.progress };
+
+    stopwatch t( st.time_total );
+
+    ntk.clear_visited();
+
+    reconvergence_driven_cut_parameters rps;
+    rps.max_leaves = ps.max_pis;
+    reconvergence_driven_cut_statistics rst;
+    detail::reconvergence_driven_cut_impl<Ntk, false, false> reconv_cuts( ntk, rps, rst );
+
+    color_view<Ntk> color_ntk{ ntk };
+
+    const auto size = ntk.num_gates();
+    ntk.foreach_gate( [&]( auto const& n, auto i ) {
+      if ( i >= size )
+      {
+        return false;
+      }
+      if ( ntk.fanout_size( n ) == 0u )
+      {
+        return true;
+      }
+
+      ntk.foreach_node( [&]( auto n ){
+        ntk.set_value( n, ntk.fanout_size( n ) );
+      });
+
+      const auto mffc = make_with_stopwatch<mffc_view<Ntk>>( st.time_mffc, ntk, n );
+
+      pbar( i, i, _candidates, _estimated_gain );
+
+      if ( mffc.num_pos() == 0 || ( !ps.use_reconvergence_cut && mffc.num_pis() > ps.max_pis ) || mffc.size() < 4 )
+      {
+        return true;
+      }
+
+      kitty::dynamic_truth_table tt;
+      std::vector<signal<Ntk>> leaves( ps.max_pis );
+      uint32_t num_leaves = 0;
+
+      if ( mffc.num_pis() <= ps.max_pis )
+      {
+        /* use MFFC */
+        mffc.foreach_pi( [&]( auto const& m, auto j ) {
+          leaves[j] = ntk.make_signal( m );
+        } );
+
+        num_leaves = mffc.num_pis();
+
+        default_simulator<kitty::dynamic_truth_table> sim( mffc.num_pis() );
+        tt = call_with_stopwatch( st.time_simulation,
+                                  [&]() { return simulate<kitty::dynamic_truth_table>( mffc, sim )[0]; } );
+      }
+      else
+      {
+        /* compute a reconvergent-driven cut */
+        std::vector<node<Ntk>> roots = { n };
+        auto const extended_leaves = reconv_cuts.run( roots ).first;
+
+        num_leaves = extended_leaves.size();
+        assert( num_leaves <= ps.max_pis );
+
+        for ( auto j = 0u; j < num_leaves; ++j )
+        {
+          leaves[j] = ntk.make_signal( extended_leaves[j] );
+        }
+
+        cut_view<Ntk> cut( ntk, extended_leaves, ntk.make_signal( n ) );
+        default_simulator<kitty::dynamic_truth_table> sim( num_leaves );
+        tt = call_with_stopwatch( st.time_simulation,
+                                  [&]() { return simulate<kitty::dynamic_truth_table>( cut, sim )[0]; } );
+      }
+
+      signal<Ntk> new_f;
+      bool resynthesized{ false };
+
+      ntk.incr_trav_id();
+      int32_t gain = recursive_deref_mark( n );
+
+      {
+        if ( ps.use_dont_cares )
+        {
+          if constexpr ( has_refactoring_with_dont_cares_v<Ntk, RefactoringFn, decltype( leaves.begin() )> )
+          {
+            std::vector<node<Ntk>> pivots;
+            for ( auto const& c : leaves )
+            {
+              pivots.push_back( ntk.get_node( c ) );
+            }
+            stopwatch t( st.time_refactoring );
+
+            refactoring_fn( ntk, tt, satisfiability_dont_cares( ntk, pivots, 16u ), leaves.begin(), leaves.begin() + num_leaves, [&]( auto const& f ) { new_f = f; resynthesized = true; return false; } );
+          }
+          else
+          {
+            stopwatch t( st.time_refactoring );
+            refactoring_fn( ntk, tt, leaves.begin(), leaves.begin() + num_leaves, [&]( auto const& f ) { new_f = f; resynthesized = true; return false; } );
+          }
+        }
+        else
+        {
+          stopwatch t( st.time_refactoring );
+          refactoring_fn( ntk, tt, leaves.begin(), leaves.begin() + num_leaves, [&]( auto const& f ) { new_f = f; resynthesized = true; return false; } );
+        }
+      }
+
+      if ( !resynthesized || n == ntk.get_node( new_f ) )
+      {
+        recursive_ref( n );
+        return true;
+      }
+
+      /* ref only if it is a new node */
+      if ( ntk.fanout_size( ntk.get_node( new_f ) ) == 0 )
+      {
+        recursive_deref_check_mark( ntk.get_node( new_f ) );
+        gain -= recursive_ref( ntk.get_node( new_f ) );
+      }
+
+      recursive_ref( n );
+
+      if ( gain > 0 || ( ps.allow_zero_gain && gain == 0 ) )
+      {
+        ++_candidates;
+        _estimated_gain += gain;
+        ntk.substitute_node( n, new_f );
+      }
+      else
+      {
+        /* remove */
+        if ( ntk.fanout_size( ntk.get_node( new_f ) ) == 0 )
+          ntk.take_out_node( ntk.get_node( new_f ) );
+      }
+      return true;
+    } );
+  }
+
+private:
+  uint32_t recursive_deref_mark( node<Ntk> const& n )
+  {
+    /* terminate? */
+    if ( ntk.is_constant( n ) || ntk.is_pi( n ) )
+      return 0;
+    
+    ntk.set_visited( n, ntk.trav_id() );
+
+    /* recursively collect nodes */
+    uint32_t value{ cost_fn( ntk, n ) };
+    ntk.foreach_fanin( n, [&]( auto const& s ) {
+      if ( ntk.decr_fanout_size( ntk.get_node( s ) ) == 0 )
+      {
+        value += recursive_deref_mark( ntk.get_node( s ) );
+      }
+    } );
+    return value;
+  }
+
+  uint32_t recursive_deref_check_mark( node<Ntk> const& n )
+  {
+    /* terminate? */
+    if ( ntk.is_constant( n ) || ntk.is_pi( n ) )
+      return 0;
+    
+    if ( ntk.visited( n ) == ntk.trav_id() )
+      return 0;
+
+    /* recursively collect nodes */
+    uint32_t value{ cost_fn( ntk, n ) };
+    ntk.foreach_fanin( n, [&]( auto const& s ) {
+      if ( ntk.decr_fanout_size( ntk.get_node( s ) ) == 0 )
+      {
+        value += recursive_deref_check_mark( ntk.get_node( s ) );
+      }
+    } );
+    return value;
+  }
+
+  uint32_t recursive_ref( node<Ntk> const& n )
+  {
+    /* terminate? */
+    if ( ntk.is_constant( n ) || ntk.is_pi( n ) )
+      return 0;
+
+    /* recursively collect nodes */
+    uint32_t value{ cost_fn( ntk, n ) };
+    ntk.foreach_fanin( n, [&]( auto const& s ) {
+      if ( ntk.incr_fanout_size( ntk.get_node( s ) ) == 0 )
+      {
+        value += recursive_ref( ntk.get_node( s ) );
+      }
+    } );
+    return value;
+  }
+
+private:
+  Ntk& ntk;
+  RefactoringFn&& refactoring_fn;
+  refactoring_params const& ps;
+  refactoring_stats& st;
+  NodeCostFn cost_fn;
+
+  uint32_t _candidates{ 0 };
+  uint32_t _estimated_gain{ 0 };
+};
+
+} /* namespace detail */
+
+/*! \brief Boolean refactoring.
+ *
+ * This algorithm performs refactoring by collapsing maximal fanout-free cones
+ * (MFFCs) into truth tables and recreating a new network structure from it.
+ * If the MFFC is too large a reconvergence-driven cut is extracted.
+ * The algorithm performs changes directly in the input network and keeps the
+ * substituted structures dangling in the network.  They can be cleaned up using
+ * the `cleanup_dangling` algorithm.
+ *
+ * The refactoring function must be of type `NtkDest::signal(NtkDest&,
+ * kitty::dynamic_truth_table const&, LeavesIterator, LeavesIterator)` where
+ * `LeavesIterator` can be dereferenced to a `NtkDest::signal`.  The last two
+ * parameters compose an iterator pair where the distance matches the number of
+ * variables of the truth table that is passed as second parameter.  There are
+ * some refactoring algorithms in the folder
+ * `mockturtle/algorithms/node_resyntesis`, since the resynthesis functions
+ * have the same signature.
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `size`
+ * - `make_signal`
+ * - `foreach_gate`
+ * - `substitute_node`
+ * - `clear_visited`
+ * - `clear_values`
+ * - `fanout_size`
+ * - `set_value`
+ * - `foreach_node`
+ *
+ * \param ntk Input network (will be changed in-place)
+ * \param refactoring_fn Refactoring function
+ * \param ps Refactoring params
+ * \param pst Refactoring statistics
+ * \param cost_fn Node cost function (a functor with signature `uint32_t(Ntk const&, node<Ntk> const&)`)
+ */
+template<class Ntk, class RefactoringFn, class NodeCostFn = unit_cost<Ntk>>
+void refactoring( Ntk& ntk, RefactoringFn&& refactoring_fn, refactoring_params const& ps = {}, refactoring_stats* pst = nullptr, NodeCostFn const& cost_fn = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the substitute_node method" );
+  static_assert( has_clear_visited_v<Ntk>, "Ntk does not implement the clear_visited method" );
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+
+  fanout_view<Ntk> f_ntk{ ntk };
+
+  refactoring_stats st;
+  detail::refactoring_impl<fanout_view<Ntk>, RefactoringFn, NodeCostFn> p( f_ntk, refactoring_fn, ps, st, cost_fn );
+  p.run();
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/resubstitution.hpp b/include/mockturtle/algorithms/resubstitution.hpp
new file mode 100644
index 0000000..d8ed920
--- /dev/null
+++ b/include/mockturtle/algorithms/resubstitution.hpp
@@ -0,0 +1,859 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file resubstitution.hpp
+  \brief Generic resubstitution framework
+
+  \author Eleonora Testa
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Shubham Rai
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+#include "../utils/progress_bar.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../views/depth_view.hpp"
+#include "../views/fanout_view.hpp"
+
+#include "detail/resub_utils.hpp"
+#include "dont_cares.hpp"
+#include "reconv_cut.hpp"
+
+#include <vector>
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for resubstitution.
+ *
+ * The data structure `resubstitution_params` holds configurable parameters with
+ * default arguments for `resubstitution`.
+ */
+struct resubstitution_params
+{
+  /*! \brief Maximum number of PIs of reconvergence-driven cuts. */
+  uint32_t max_pis{ 8 };
+
+  /*! \brief Maximum number of divisors to consider. */
+  uint32_t max_divisors{ 150 };
+
+  /*! \brief Maximum number of nodes added by resubstitution. */
+  uint32_t max_inserts{ 2 };
+
+  /*! \brief Maximum fanout of a node to be considered as root. */
+  uint32_t skip_fanout_limit_for_roots{ 1000 };
+
+  /*! \brief Maximum fanout of a node to be considered as divisor. */
+  uint32_t skip_fanout_limit_for_divisors{ 100 };
+
+  /*! \brief Show progress. */
+  bool progress{ false };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+
+  /****** window-based resub engine ******/
+
+  /*! \brief Use don't cares for optimization. Only used by window-based resub engine. */
+  bool use_dont_cares{ false };
+
+  /*! \brief Window size for don't cares calculation. Only used by window-based resub engine. */
+  uint32_t window_size{ 12u };
+
+  /*! \brief Whether to prevent from increasing depth. Currently only used by window-based resub engine. */
+  bool preserve_depth{ false };
+
+  /****** simulation-based resub engine ******/
+
+  /*! \brief Whether to use pre-generated patterns stored in a file.
+   * If not, by default, 1024 random pattern + 1x stuck-at patterns will be generated. Only used by simulation-based resub engine.
+   */
+  std::optional<std::string> pattern_filename{};
+
+  /*! \brief Whether to save the appended patterns (with CEXs) into file. Only used by simulation-based resub engine. */
+  std::optional<std::string> save_patterns{};
+
+  /*! \brief Maximum number of clauses of the SAT solver. Only used by simulation-based resub engine. */
+  uint32_t max_clauses{ 1000 };
+
+  /*! \brief Conflict limit for the SAT solver. Only used by simulation-based resub engine. */
+  uint32_t conflict_limit{ 1000 };
+
+  /*! \brief Random seed for the SAT solver (influences the randomness of counter-examples). Only used by simulation-based resub engine. */
+  uint32_t random_seed{ 1 };
+
+  /*! \brief Whether to utilize ODC, and how many levels. 0 = no. -1 = Consider TFO until PO. Only used by simulation-based resub engine. */
+  int32_t odc_levels{ 0 };
+
+  /*! \brief Maximum number of trials to call the resub functor. Only used by simulation-based resub engine. */
+  uint32_t max_trials{ 100 };
+
+  /* k-resub engine specific */
+  /*! \brief Maximum number of divisors to consider in k-resub engine. Only used by `abc_resub_functor` with simulation-based resub engine. */
+  uint32_t max_divisors_k{ 50 };
+};
+
+/*! \brief Statistics for resubstitution.
+ *
+ * The data structure `resubstitution_stats` provides data collected by running
+ * `resubstitution`.
+ */
+struct resubstitution_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Accumulated runtime of the divisor collector. */
+  stopwatch<>::duration time_divs{ 0 };
+
+  /*! \brief Accumulated runtime of the resub engine. */
+  stopwatch<>::duration time_resub{ 0 };
+
+  /*! \brief Accumulated runtime of the callback function. */
+  stopwatch<>::duration time_callback{ 0 };
+
+  /*! \brief Total number of divisors. */
+  uint64_t num_total_divisors{ 0 };
+
+  /*! \brief Total number of gain. */
+  uint64_t estimated_gain{ 0 };
+
+  /*! \brief Initial network size (before resubstitution). */
+  uint64_t initial_size{ 0 };
+
+  void report() const
+  {
+    // clang-format off
+    fmt::print( "[i] <Top level>\n" );
+    fmt::print( "[i]     ========  Stats  ========\n" );
+    fmt::print( "[i]     #divisors = {:8d}\n", num_total_divisors );
+    fmt::print( "[i]     est. gain = {:8d} ({:>5.2f}%)\n", estimated_gain, ( 100.0 * estimated_gain ) / initial_size );
+    fmt::print( "[i]     ======== Runtime ========\n" );
+    fmt::print( "[i]     total         : {:>5.2f} secs\n", to_seconds( time_total ) );
+    fmt::print( "[i]       DivCollector: {:>5.2f} secs\n", to_seconds( time_divs ) );
+    fmt::print( "[i]       ResubEngine : {:>5.2f} secs\n", to_seconds( time_resub ) );
+    fmt::print( "[i]       callback    : {:>5.2f} secs\n", to_seconds( time_callback ) );
+    fmt::print( "[i]     =========================\n\n" );
+    // clang-format on
+  }
+};
+
+namespace detail
+{
+
+template<typename Ntk>
+bool substitute_fn( Ntk& ntk, typename Ntk::node const& n, typename Ntk::signal const& g )
+{
+  ntk.substitute_node( n, g );
+  return true;
+}
+
+template<typename Ntk>
+bool report_fn( Ntk& ntk, typename Ntk::node const& n, typename Ntk::signal const& g )
+{
+  fmt::print( "[i] Substitute node {} with signal {}{}\n", n, ntk.is_complemented( g ) ? "!" : "", ntk.get_node( g ) );
+  return false;
+}
+
+struct default_collector_stats
+{
+  /*! \brief Total number of leaves. */
+  uint64_t num_total_leaves{ 0 };
+
+  /*! \brief Accumulated runtime for cut computation. */
+  stopwatch<>::duration time_cuts{ 0 };
+
+  /*! \brief Accumulated runtime for mffc computation. */
+  stopwatch<>::duration time_mffc{ 0 };
+
+  /*! \brief Accumulated runtime for divisor computation. */
+  stopwatch<>::duration time_divs{ 0 };
+
+  void report() const
+  {
+    // clang-format off
+    fmt::print( "[i] <DivCollector: default_divisor_collector>\n" );
+    fmt::print( "[i]     #leaves = {:6d}\n", num_total_leaves );
+    fmt::print( "[i]     ======== Runtime ========\n" );
+    fmt::print( "[i]     reconv. cut : {:>5.2f} secs\n", to_seconds( time_cuts ) );
+    fmt::print( "[i]     MFFC        : {:>5.2f} secs\n", to_seconds( time_mffc ) );
+    fmt::print( "[i]     divs collect: {:>5.2f} secs\n", to_seconds( time_divs ) );
+    fmt::print( "[i]     =========================\n\n" );
+    // clang-format on
+  }
+};
+
+/*! \brief Prepare the three public data members `leaves`, `divs` and `mffc`
+ * to be ready for usage.
+ *
+ * `leaves`: sufficient support for all divisors
+ * `divs`: divisor nodes that can be used for resubstitution
+ * `mffc`: MFFC nodes which are needed to do simulation from
+ * `leaves`, through `divs` and `mffc` until the root node,
+ * but should be excluded from resubstitution.
+ * The last element of `mffc` is always the root node.
+ *
+ * `divs` and `mffc` are in topological order.
+ *
+ * \param MffcMgr Manager class to compute the potential gain if a
+ * resubstitution exists (number of MFFC nodes when the cost function is circuit size).
+ * \param MffcRes Typename of the return value of `MffcMgr`.
+ * \param cut_comp Manager class to compute reconvergence-driven cuts.
+ */
+template<class Ntk, class MffcMgr = node_mffc_inside<Ntk>, typename MffcRes = uint32_t, typename cut_comp = detail::reconvergence_driven_cut_impl<Ntk>>
+class default_divisor_collector
+{
+public:
+  using stats = default_collector_stats;
+  using mffc_result_t = MffcRes;
+  using node = typename Ntk::node;
+
+  using cut_comp_parameters_type = typename cut_comp::parameters_type;
+  using cut_comp_statistics_type = typename cut_comp::statistics_type;
+
+public:
+  explicit default_divisor_collector( Ntk const& ntk, resubstitution_params const& ps, stats& st )
+      : ntk( ntk ), ps( ps ), st( st ), cuts( ntk, cut_comp_parameters_type{ ps.max_pis }, cuts_st )
+  {
+  }
+
+  bool run( node const& n, mffc_result_t& potential_gain )
+  {
+    /* skip nodes with many fanouts */
+    if ( ntk.fanout_size( n ) > ps.skip_fanout_limit_for_roots )
+    {
+      return false;
+    }
+
+    /* compute a reconvergence-driven cut */
+    leaves = call_with_stopwatch( st.time_cuts, [&]() {
+      return cuts.run( { n } ).first;
+    } );
+    st.num_total_leaves += leaves.size();
+
+    /* collect the MFFC */
+    MffcMgr mffc_mgr( ntk );
+    potential_gain = call_with_stopwatch( st.time_mffc, [&]() {
+      return mffc_mgr.run( n, leaves, mffc );
+    } );
+
+    /* collect the divisor nodes in the cut */
+    bool div_comp_success = call_with_stopwatch( st.time_divs, [&]() {
+      return collect_divisors( n );
+    } );
+
+    if ( !div_comp_success )
+    {
+      return false;
+    }
+
+    return true;
+  }
+
+private:
+  void collect_divisors_rec( node const& n )
+  {
+    /* skip visited nodes */
+    if ( ntk.visited( n ) == ntk.trav_id() )
+    {
+      return;
+    }
+    ntk.set_visited( n, ntk.trav_id() );
+
+    ntk.foreach_fanin( n, [&]( const auto& f ) {
+      collect_divisors_rec( ntk.get_node( f ) );
+    } );
+
+    /* collect the internal nodes */
+    if ( ntk.value( n ) == 0 && n != 0 ) /* ntk.fanout_size( n ) */
+    {
+      divs.emplace_back( n );
+    }
+  }
+
+  bool collect_divisors( node const& root )
+  {
+    auto max_depth = std::numeric_limits<uint32_t>::max();
+    if ( ps.preserve_depth )
+    {
+      max_depth = ntk.level( root );
+    }
+    /* add the leaves of the cuts to the divisors */
+    divs.clear();
+
+    ntk.incr_trav_id();
+    for ( const auto& l : leaves )
+    {
+      divs.emplace_back( l );
+      ntk.set_visited( l, ntk.trav_id() );
+    }
+
+    /* mark nodes in the MFFC */
+    for ( const auto& t : mffc )
+    {
+      ntk.set_value( t, 1 );
+    }
+
+    /* collect the cone (without MFFC) */
+    collect_divisors_rec( root );
+
+    /* unmark the current MFFC */
+    for ( const auto& t : mffc )
+    {
+      ntk.set_value( t, 0 );
+    }
+
+    /* check if the number of divisors is not exceeded */
+    if ( divs.size() + mffc.size() - leaves.size() > ps.max_divisors - ps.max_pis )
+    {
+      return false;
+    }
+    uint32_t limit = ps.max_divisors - ps.max_pis - mffc.size() + leaves.size();
+
+    /* explore the fanouts, which are not in the MFFC */
+    bool quit = false;
+    for ( auto i = 0u; i < divs.size(); ++i )
+    {
+      auto const d = divs.at( i );
+
+      if ( ntk.fanout_size( d ) > ps.skip_fanout_limit_for_divisors )
+      {
+        continue;
+      }
+      if ( divs.size() >= limit )
+      {
+        break;
+      }
+
+      /* if the fanout has all fanins in the set, add it */
+      ntk.foreach_fanout( d, [&]( node const& p ) {
+        if ( ntk.visited( p ) == ntk.trav_id() || ntk.level( p ) > max_depth )
+        {
+          return true; /* next fanout */
+        }
+
+        bool all_fanins_visited = true;
+        ntk.foreach_fanin( p, [&]( const auto& g ) {
+          if ( ntk.visited( ntk.get_node( g ) ) != ntk.trav_id() )
+          {
+            all_fanins_visited = false;
+            return false; /* terminate fanin-loop */
+          }
+          return true; /* next fanin */
+        } );
+
+        if ( !all_fanins_visited )
+          return true; /* next fanout */
+
+        bool has_root_as_child = false;
+        ntk.foreach_fanin( p, [&]( const auto& g ) {
+          if ( ntk.get_node( g ) == root )
+          {
+            has_root_as_child = true;
+            return false; /* terminate fanin-loop */
+          }
+          return true; /* next fanin */
+        } );
+
+        if ( has_root_as_child )
+        {
+          return true; /* next fanout */
+        }
+
+        divs.emplace_back( p );
+        ntk.set_visited( p, ntk.trav_id() );
+
+        /* quit computing divisors if there are too many of them */
+        if ( divs.size() >= limit )
+        {
+          quit = true;
+          return false; /* terminate fanout-loop */
+        }
+
+        return true; /* next fanout */
+      } );
+
+      if ( quit )
+      {
+        break;
+      }
+    }
+
+    /* note: different from the previous version, now we do not add MFFC nodes into divs */
+    assert( root == mffc.at( mffc.size() - 1u ) );
+    /* note: this assertion makes sure window_simulator does not go out of bounds */
+    assert( divs.size() + mffc.size() - leaves.size() <= ps.max_divisors - ps.max_pis );
+
+    return true;
+  }
+
+private:
+  Ntk const& ntk;
+  resubstitution_params ps;
+  stats& st;
+
+  cut_comp cuts;
+  cut_comp_statistics_type cuts_st;
+
+public:
+  std::vector<node> leaves;
+  std::vector<node> divs;
+  std::vector<node> mffc;
+};
+
+template<typename ResubFnSt>
+struct window_resub_stats
+{
+  /*! \brief Number of successful resubstitutions. */
+  uint32_t num_resub{ 0 };
+
+  /*! \brief Time for simulation. */
+  stopwatch<>::duration time_sim{ 0 };
+
+  /*! \brief Time for don't-care computation. */
+  stopwatch<>::duration time_dont_care{ 0 };
+
+  /*! \brief Time of the resub functor. */
+  stopwatch<>::duration time_compute_function{ 0 };
+
+  ResubFnSt functor_st;
+
+  void report() const
+  {
+    // clang-format off
+    fmt::print( "[i] <ResubEngine: window_based_resub_engine>\n" );
+    fmt::print( "[i]     #resub = {:6d}\n", num_resub );
+    fmt::print( "[i]     ======== Runtime ========\n" );
+    fmt::print( "[i]     simulation: {:>5.2f} secs\n", to_seconds( time_sim ) );
+    fmt::print( "[i]     don't care: {:>5.2f} secs\n", to_seconds( time_dont_care ) );
+    fmt::print( "[i]     functor   : {:>5.2f} secs\n", to_seconds( time_compute_function ) );
+    fmt::print( "[i]     ======== Details ========\n" );
+    functor_st.report();
+    fmt::print( "[i]     =========================\n\n" );
+    // clang-format on
+  }
+};
+
+/*! \brief Window-based resubstitution engine.
+ *
+ * This engine computes the complete truth tables of nodes within a window
+ * with the leaves as inputs. It does not verify the resubstitution candidates
+ * given by the resubstitution functor. This engine requires the divisor
+ * collector to prepare three data members: `leaves`, `divs` and `mffc`.
+ *
+ * Required interfaces of the resubstitution functor:
+ * - Constructor: `resub_fn( Ntk const& ntk, Simulator const& sim,`
+ * `std::vector<node> const& divs, uint32_t num_divs, ResubFnSt& st )`
+ * - A public `operator()`: `std::optional<signal> operator()`
+ * `( node const& root, TTdc care, uint32_t required, uint32_t max_inserts,`
+ * `MffcRes potential_gain, uint32_t& last_gain ) const`
+ *
+ * Compatible resubstitution functors implemented:
+ * - `default_resub_functor`
+ * - `aig_resub_functor`
+ * - `mig_resub_functor`
+ * - `xmg_resub_functor`
+ * - `xag_resub_functor`
+ * - `mig_resyn_functor`
+ *
+ * \param TTsim Truth table type for simulation.
+ * \param TTdc Truth table type for don't-care computation.
+ * \param ResubFn Resubstitution functor to compute the resubstitution.
+ * \param MffcRes Typename of `potential_gain` needed by the resubstitution functor.
+ */
+template<class Ntk, class TTsim, class TTdc = kitty::dynamic_truth_table, class ResubFn = default_resub_functor<Ntk, window_simulator<Ntk, TTsim>, TTdc>, typename MffcRes = uint32_t>
+class window_based_resub_engine
+{
+public:
+  static constexpr bool require_leaves_and_mffc = true;
+  using stats = window_resub_stats<typename ResubFn::stats>;
+  using mffc_result_t = MffcRes;
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  explicit window_based_resub_engine( Ntk& ntk, resubstitution_params const& ps, stats& st )
+      : ntk( ntk ), ps( ps ), st( st ), sim( ntk, ps.max_divisors, ps.max_pis )
+  {
+  }
+
+  void init() {}
+  void update() {}
+
+  std::optional<signal> run( node const& n, std::vector<node> const& leaves, std::vector<node> const& divs, std::vector<node> const& mffc, mffc_result_t potential_gain, uint32_t& last_gain )
+  {
+    /* simulate the collected divisors */
+    call_with_stopwatch( st.time_sim, [&]() {
+      simulate( leaves, divs, mffc );
+    } );
+
+    auto care = kitty::create<TTdc>( ps.max_pis );
+    call_with_stopwatch( st.time_dont_care, [&]() {
+      if ( ps.use_dont_cares )
+      {
+        care = ~satisfiability_dont_cares( ntk, leaves, ps.window_size );
+      }
+      else
+      {
+        care = ~care;
+      }
+    } );
+
+    ResubFn resub_fn( ntk, sim, divs, divs.size(), st.functor_st );
+    auto res = call_with_stopwatch( st.time_compute_function, [&]() {
+      auto max_depth = std::numeric_limits<uint32_t>::max();
+      if ( ps.preserve_depth )
+      {
+        max_depth = ntk.level( n );
+      }
+      return resub_fn( n, care, max_depth, ps.max_inserts, potential_gain, last_gain );
+    } );
+    if ( res )
+    {
+      ++st.num_resub;
+    }
+    return res;
+  }
+
+private:
+  void simulate( std::vector<node> const& leaves, std::vector<node> const& divs, std::vector<node> const& mffc )
+  {
+    sim.resize();
+    for ( auto i = 0u; i < divs.size() + mffc.size(); ++i )
+    {
+      const auto d = i < divs.size() ? divs.at( i ) : mffc.at( i - divs.size() );
+
+      /* skip constant 0 */
+      if ( d == 0 )
+        continue;
+
+      /* assign leaves to variables */
+      if ( i < leaves.size() )
+      {
+        sim.assign( d, i + 1 );
+        continue;
+      }
+
+      /* compute truth tables of inner nodes */
+      sim.assign( d, i - uint32_t( leaves.size() ) + ps.max_pis + 1 );
+      std::vector<TTsim> tts;
+      ntk.foreach_fanin( d, [&]( const auto& s ) {
+        tts.emplace_back( sim.get_tt( ntk.make_signal( ntk.get_node( s ) ) ) ); /* ignore sign */
+      } );
+
+      auto const tt = ntk.compute( d, tts.begin(), tts.end() );
+      sim.set_tt( i - uint32_t( leaves.size() ) + ps.max_pis + 1, tt );
+    }
+
+    /* normalize truth tables */
+    sim.normalize( divs );
+    sim.normalize( mffc );
+  }
+
+private:
+  Ntk& ntk;
+  resubstitution_params const& ps;
+  stats& st;
+
+  window_simulator<Ntk, TTsim> sim;
+}; /* window_based_resub_engine */
+
+/*! \brief The top-level resubstitution framework.
+ *
+ * \param ResubEngine The engine that computes the resubtitution for a given root
+ * node and divisors. One can choose from `window_based_resub_engine` which
+ * does complete simulation within small windows, or `simulation_based_resub_engine`
+ * which does partial simulation on the whole circuit.
+ *
+ * \param DivCollector Collects divisors near a given root node, and compute
+ * the potential gain (MFFC size or its variants).
+ * Currently only `default_divisor_collector` is implemented, but
+ * a frontier-based approach may be integrated in the future.
+ * When using `window_based_resub_engine`, the `DivCollector` should prepare
+ * three public data members: `leaves`, `divs`, and `mffc` (see documentation
+ * of `default_divisor_collector` for details). When using `simulation_based_resub_engine`,
+ * only `divs` is needed.
+ */
+template<class Ntk, class ResubEngine = window_based_resub_engine<Ntk, kitty::dynamic_truth_table>, class DivCollector = default_divisor_collector<Ntk>>
+class resubstitution_impl
+{
+public:
+  using engine_st_t = typename ResubEngine::stats;
+  using collector_st_t = typename DivCollector::stats;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  using resub_callback_t = std::function<bool( Ntk&, node const&, signal const& )>;
+  using mffc_result_t = typename ResubEngine::mffc_result_t;
+
+  /*! \brief Constructor of the top-level resubstitution framework.
+   *
+   * \param ntk The network to be optimized.
+   * \param ps Resubstitution parameters.
+   * \param st Top-level resubstitution statistics.
+   * \param engine_st Statistics of the resubstitution engine.
+   * \param collector_st Statistics of the divisor collector.
+   * \param callback Callback function when a resubstitution is found.
+   */
+  explicit resubstitution_impl( Ntk& ntk, resubstitution_params const& ps, resubstitution_stats& st, engine_st_t& engine_st, collector_st_t& collector_st )
+      : ntk( ntk ), ps( ps ), st( st ), engine_st( engine_st ), collector_st( collector_st )
+  {
+    static_assert( std::is_same_v<typename ResubEngine::mffc_result_t, typename DivCollector::mffc_result_t>, "MFFC result type of the engine and the collector are different" );
+
+    st.initial_size = ntk.num_gates();
+
+    register_events();
+  }
+
+  ~resubstitution_impl()
+  {
+    ntk.events().release_add_event( add_event );
+    ntk.events().release_modified_event( modified_event );
+    ntk.events().release_delete_event( delete_event );
+  }
+
+  void run( resub_callback_t const& callback = substitute_fn<Ntk> )
+  {
+    stopwatch t( st.time_total );
+
+    /* start the managers */
+    DivCollector collector( ntk, ps, collector_st );
+    ResubEngine resub_engine( ntk, ps, engine_st );
+    call_with_stopwatch( st.time_resub, [&]() {
+      resub_engine.init();
+    } );
+
+    progress_bar pbar{ ntk.size(), "resub |{0}| node = {1:>4}   cand = {2:>4}   est. gain = {3:>5}", ps.progress };
+
+    auto const size = ntk.num_gates();
+    ntk.foreach_gate( [&]( auto const& n, auto i ) {
+      if ( i >= size )
+      {
+        return false; /* terminate */
+      }
+
+      pbar( i, i, candidates, st.estimated_gain );
+
+      /* compute cut, collect divisors, compute MFFC */
+      mffc_result_t potential_gain;
+      const auto collector_success = call_with_stopwatch( st.time_divs, [&]() {
+        return collector.run( n, potential_gain );
+      } );
+      if ( !collector_success )
+      {
+        return true; /* next */
+      }
+
+      /* update statistics */
+      last_gain = 0;
+      st.num_total_divisors += collector.divs.size();
+
+      /* try to find a resubstitution with the divisors */
+      auto g = call_with_stopwatch( st.time_resub, [&]() {
+        if constexpr ( ResubEngine::require_leaves_and_mffc ) /* window-based */
+        {
+          return resub_engine.run( n, collector.leaves, collector.divs, collector.mffc, potential_gain, last_gain );
+        }
+        else /* simulation-based */
+        {
+          return resub_engine.run( n, collector.divs, potential_gain, last_gain );
+        }
+      } );
+      if ( !g )
+      {
+        return true; /* next */
+      }
+
+      /* update progress bar */
+      candidates++;
+      st.estimated_gain += last_gain;
+
+      /* update network */
+      bool updated = call_with_stopwatch( st.time_callback, [&]() {
+        return callback( ntk, n, *g );
+      } );
+      if ( updated )
+      {
+        resub_engine.update();
+      }
+
+      return true; /* next */
+    } );
+  }
+
+private:
+  void register_events()
+  {
+    auto const update_level_of_new_node = [&]( const auto& n ) {
+      ntk.resize_levels();
+      update_node_level( n );
+    };
+
+    auto const update_level_of_existing_node = [&]( node const& n, const auto& old_children ) {
+      (void)old_children;
+      ntk.resize_levels();
+      update_node_level( n );
+    };
+
+    auto const update_level_of_deleted_node = [&]( const auto& n ) {
+      ntk.set_level( n, -1 );
+    };
+
+    add_event = ntk.events().register_add_event( update_level_of_new_node );
+    modified_event = ntk.events().register_modified_event( update_level_of_existing_node );
+    delete_event = ntk.events().register_delete_event( update_level_of_deleted_node );
+  }
+
+  /* maybe should move to depth_view */
+  void update_node_level( node const& n, bool top_most = true )
+  {
+    uint32_t curr_level = ntk.level( n );
+
+    uint32_t max_level = 0;
+    ntk.foreach_fanin( n, [&]( const auto& f ) {
+      auto const p = ntk.get_node( f );
+      auto const fanin_level = ntk.level( p );
+      if ( fanin_level > max_level )
+      {
+        max_level = fanin_level;
+      }
+    } );
+    ++max_level;
+
+    if ( curr_level != max_level )
+    {
+      ntk.set_level( n, max_level );
+
+      /* update only one more level */
+      if ( top_most )
+      {
+        ntk.foreach_fanout( n, [&]( const auto& p ) {
+          update_node_level( p, false );
+        } );
+      }
+    }
+  }
+
+private:
+  Ntk& ntk;
+
+  resubstitution_params const& ps;
+  resubstitution_stats& st;
+  engine_st_t& engine_st;
+  collector_st_t& collector_st;
+
+  /* temporary statistics for progress bar */
+  uint32_t candidates{ 0 };
+  uint32_t last_gain{ 0 };
+
+  /* events */
+  std::shared_ptr<typename network_events<Ntk>::add_event_type> add_event;
+  std::shared_ptr<typename network_events<Ntk>::modified_event_type> modified_event;
+  std::shared_ptr<typename network_events<Ntk>::delete_event_type> delete_event;
+};
+
+} /* namespace detail */
+
+/*! \brief Window-based Boolean resubstitution with default resub functor (only div0). */
+template<class Ntk>
+void default_resubstitution( Ntk& ntk, resubstitution_params const& ps = {}, resubstitution_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the substitute_node method" );
+  static_assert( has_value_v<Ntk>, "Ntk does not implement the value method" );
+  static_assert( has_visited_v<Ntk>, "Ntk does not implement the visited method" );
+
+  using resub_view_t = fanout_view<depth_view<Ntk>>;
+  depth_view<Ntk> depth_view{ ntk };
+  resub_view_t resub_view{ depth_view };
+
+  if ( ps.max_pis == 8 )
+  {
+    using truthtable_t = kitty::static_truth_table<8>;
+    using truthtable_dc_t = kitty::dynamic_truth_table;
+    using resub_impl_t = detail::resubstitution_impl<resub_view_t, typename detail::window_based_resub_engine<resub_view_t, truthtable_t, truthtable_dc_t>>;
+
+    resubstitution_stats st;
+    typename resub_impl_t::engine_st_t engine_st;
+    typename resub_impl_t::collector_st_t collector_st;
+
+    resub_impl_t p( resub_view, ps, st, engine_st, collector_st );
+    p.run();
+
+    if ( ps.verbose )
+    {
+      st.report();
+      collector_st.report();
+      engine_st.report();
+    }
+
+    if ( pst )
+    {
+      *pst = st;
+    }
+  }
+  else
+  {
+    using resub_impl_t = detail::resubstitution_impl<resub_view_t>;
+
+    resubstitution_stats st;
+    typename resub_impl_t::engine_st_t engine_st;
+    typename resub_impl_t::collector_st_t collector_st;
+
+    resub_impl_t p( resub_view, ps, st, engine_st, collector_st );
+    p.run();
+
+    if ( ps.verbose )
+    {
+      st.report();
+      collector_st.report();
+      engine_st.report();
+    }
+
+    if ( pst )
+    {
+      *pst = st;
+    }
+  }
+}
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/resyn_engines/aig_enumerative.hpp b/include/mockturtle/algorithms/resyn_engines/aig_enumerative.hpp
new file mode 100644
index 0000000..51c7e9c
--- /dev/null
+++ b/include/mockturtle/algorithms/resyn_engines/aig_enumerative.hpp
@@ -0,0 +1,472 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aig_enumerative.hpp
+  \brief AIG enumerative resynthesis
+
+  \author Hanyu Wang
+  \author Siang-Yun (Sonia) Lee
+
+  Based on previous implementation of AIG resubstitution by
+  Eleonora Testa, Heinz Riener, and Mathias Soeken
+*/
+
+#pragma once
+
+#include "../../utils/index_list.hpp"
+#include "../../utils/null_utils.hpp"
+#include <kitty/kitty.hpp>
+#include <optional>
+#include <vector>
+
+namespace mockturtle
+{
+
+struct aig_enumerative_resyn_stats
+{
+  /*! \brief Accumulated runtime for const-resub */
+  stopwatch<>::duration time_resubC{ 0 };
+
+  /*! \brief Accumulated runtime for zero-resub */
+  stopwatch<>::duration time_resub0{ 0 };
+
+  /*! \brief Accumulated runtime for collecting unate divisors. */
+  stopwatch<>::duration time_collect_unate_divisors{ 0 };
+
+  /*! \brief Accumulated runtime for one-resub */
+  stopwatch<>::duration time_resub1{ 0 };
+
+  /*! \brief Accumulated runtime for 12-resub. */
+  stopwatch<>::duration time_resub12{ 0 };
+
+  /*! \brief Accumulated runtime for collecting unate divisors. */
+  stopwatch<>::duration time_collect_binate_divisors{ 0 };
+
+  /*! \brief Accumulated runtime for two-resub. */
+  stopwatch<>::duration time_resub2{ 0 };
+
+  /*! \brief Accumulated runtime for three-resub. */
+  stopwatch<>::duration time_resub3{ 0 };
+
+  /*! \brief Number of accepted constant resubsitutions */
+  uint32_t num_const_accepts{ 0 };
+
+  /*! \brief Number of accepted zero resubsitutions */
+  uint32_t num_div0_accepts{ 0 };
+
+  /*! \brief Number of accepted one resubsitutions */
+  uint64_t num_div1_accepts{ 0 };
+
+  /*! \brief Number of accepted single AND-resubsitutions */
+  uint64_t num_div1_and_accepts{ 0 };
+
+  /*! \brief Number of accepted single OR-resubsitutions */
+  uint64_t num_div1_or_accepts{ 0 };
+
+  /*! \brief Number of accepted two resubsitutions using triples of unate divisors */
+  uint64_t num_div12_accepts{ 0 };
+
+  /*! \brief Number of accepted single 2AND-resubsitutions */
+  uint64_t num_div12_2and_accepts{ 0 };
+
+  /*! \brief Number of accepted single 2OR-resubsitutions */
+  uint64_t num_div12_2or_accepts{ 0 };
+
+  /*! \brief Number of accepted two resubsitutions */
+  uint64_t num_div2_accepts{ 0 };
+
+  /*! \brief Number of accepted double AND-OR-resubsitutions */
+  uint64_t num_div2_and_or_accepts{ 0 };
+
+  /*! \brief Number of accepted double OR-AND-resubsitutions */
+  uint64_t num_div2_or_and_accepts{ 0 };
+
+  /*! \brief Number of accepted three resubsitutions */
+  uint64_t num_div3_accepts{ 0 };
+
+  /*! \brief Number of accepted AND-2OR-resubsitutions */
+  uint64_t num_div3_and_2or_accepts{ 0 };
+
+  /*! \brief Number of accepted OR-2AND-resubsitutions */
+  uint64_t num_div3_or_2and_accepts{ 0 };
+
+  void report() const
+  {
+    // clang-format off
+    fmt::print( "[i] aig_enumerative_resyn_stats\n" );
+    fmt::print( "[i]     constant-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_const_accepts, to_seconds( time_resubC ) );
+    fmt::print( "[i]     0-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_div0_accepts, to_seconds( time_resub0 ) );
+    fmt::print( "[i]     collect unate divisors                           ({:>5.2f} secs)\n", to_seconds( time_collect_unate_divisors ) );
+    fmt::print( "[i]     1-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_div1_accepts, to_seconds( time_resub1 ) );
+    fmt::print( "[i]     2-resub {:6d} = {:6d} 2AND    + {:6d} 2OR     ({:>5.2f} secs)\n",
+                              num_div12_accepts, num_div12_2and_accepts, num_div12_2or_accepts, to_seconds( time_resub12 ) );
+    fmt::print( "[i]     collect binate divisors                          ({:>5.2f} secs)\n", to_seconds( time_collect_binate_divisors ) );
+    fmt::print( "[i]     2-resub {:6d} = {:6d} AND-OR  + {:6d} OR-AND  ({:>5.2f} secs)\n",
+                              num_div2_accepts, num_div2_and_or_accepts, num_div2_or_and_accepts, to_seconds( time_resub2 ) );
+    fmt::print( "[i]     3-resub {:6d} = {:6d} AND-2OR + {:6d} OR-2AND ({:>5.2f} secs)\n",
+                              num_div3_accepts, num_div3_and_2or_accepts, num_div3_or_2and_accepts, to_seconds( time_resub3 ) );
+    fmt::print( "[i] total   {:6d}\n",
+                              (num_const_accepts + num_div0_accepts + num_div1_accepts + num_div12_accepts + num_div2_accepts + num_div3_accepts) );
+    // clang-format on
+  }
+}; /* aig_enumerative_resyn_stats */
+
+template<typename TT, bool normalized = false>
+struct aig_enumerative_resyn
+{
+public:
+  using stats = aig_enumerative_resyn_stats;
+  using index_list_t = xag_index_list<false>;
+  using truth_table_t = TT;
+
+public:
+  explicit aig_enumerative_resyn( stats& st ) noexcept
+      : st( st )
+  {}
+
+  template<class iterator_type, class truth_table_storage_type>
+  std::optional<index_list_t> operator()( TT const& target, TT const& care, iterator_type begin, iterator_type end, truth_table_storage_type const& tts, uint32_t max_size = std::numeric_limits<uint32_t>::max() )
+  {
+    (void)care;
+    assert( is_const0( ~care ) && "enumerative resynthesis does not support don't cares" );
+
+    index_list_t il( std::distance( begin, end ) );
+    const TT ntarget = ~target;
+    uint32_t i, j, k, l;
+    iterator_type it = begin;
+
+    /* C-resub */
+    if ( kitty::is_const0( target ) )
+    {
+      il.add_output( 0 );
+      return il;
+    }
+    if constexpr ( !normalized )
+    {
+      if ( kitty::is_const0( ntarget ) )
+      {
+        il.add_output( 1 );
+        return il;
+      }
+    }
+
+    /* 0-resub */
+    for ( it = begin, i = 0u; it != end; ++it, ++i )
+    {
+      if ( target == tts[*it] )
+      {
+        il.add_output( make_lit( i ) );
+        return il;
+      }
+      if constexpr ( !normalized )
+      {
+        if ( ntarget == tts[*it] )
+        {
+          assert( !normalized );
+          il.add_output( make_lit( i, true ) );
+          return il;
+        }
+      }
+    }
+
+    if ( max_size == 0 )
+    {
+      return std::nullopt;
+    }
+
+    /* collect unate literals */
+    std::vector<uint32_t> pos_unate, neg_unate, binate;
+    for ( it = begin, i = 0u; it != end; ++it, ++i )
+    {
+      if ( kitty::implies( tts[*it], target ) )
+      {
+        pos_unate.emplace_back( make_lit( i ) );
+      }
+      else if ( kitty::implies( target, tts[*it] ) )
+      {
+        neg_unate.emplace_back( make_lit( i ) );
+      }
+      else if ( kitty::implies( target, ~tts[*it] ) )
+      {
+        neg_unate.emplace_back( make_lit( i, true ) );
+      }
+      else
+      {
+        if constexpr ( !normalized )
+        {
+          if ( kitty::implies( ~tts[*it], target ) )
+          {
+            pos_unate.emplace_back( make_lit( i, true ) );
+          }
+          else
+          {
+            binate.emplace_back( make_lit( i ) );
+          }
+        }
+        else
+        {
+          binate.emplace_back( make_lit( i ) );
+        }
+      }
+    }
+
+    /* 1-resub */
+    for ( i = 0u; i < pos_unate.size(); ++i )
+    {
+      for ( j = i + 1; j < pos_unate.size(); ++j )
+      {
+        if ( target == ( get_tt_from_lit( pos_unate[i], tts, begin ) | get_tt_from_lit( pos_unate[j], tts, begin ) ) )
+        {
+          il.add_output( il.add_and( pos_unate[i] ^ 0x1, pos_unate[j] ^ 0x1 ) ^ 0x1 ); // OR
+          return il;
+        }
+      }
+    }
+    for ( i = 0u; i < neg_unate.size(); ++i )
+    {
+      for ( j = i + 1; j < neg_unate.size(); ++j )
+      {
+        if ( target == ( get_tt_from_lit( neg_unate[i], tts, begin ) & get_tt_from_lit( neg_unate[j], tts, begin ) ) )
+        {
+          il.add_output( il.add_and( neg_unate[i], neg_unate[j] ) ); // AND
+          return il;
+        }
+      }
+    }
+
+    if ( max_size == 1 )
+    {
+      return std::nullopt;
+    }
+
+    /* 2-resub */
+    for ( i = 0u; i < pos_unate.size(); ++i )
+    {
+      for ( j = i + 1; j < pos_unate.size(); ++j )
+      {
+        for ( k = j + 1; k < pos_unate.size(); ++k )
+        {
+          if ( target == ( get_tt_from_lit( pos_unate[i], tts, begin ) | get_tt_from_lit( pos_unate[j], tts, begin ) | get_tt_from_lit( pos_unate[k], tts, begin ) ) )
+          {
+            il.add_output( il.add_and( il.add_and( pos_unate[i] ^ 0x1, pos_unate[j] ^ 0x1 ), pos_unate[k] ^ 0x1 ) ^ 0x1 ); // OR-OR
+            return il;
+          }
+        }
+      }
+    }
+
+    for ( i = 0u; i < neg_unate.size(); ++i )
+    {
+      for ( j = i + 1; j < neg_unate.size(); ++j )
+      {
+        for ( k = j + 1; k < neg_unate.size(); ++k )
+        {
+          if ( target == ( get_tt_from_lit( neg_unate[i], tts, begin ) & get_tt_from_lit( neg_unate[j], tts, begin ) & get_tt_from_lit( neg_unate[k], tts, begin ) ) )
+          {
+            il.add_output( il.add_and( il.add_and( neg_unate[i], neg_unate[j] ), neg_unate[k] ) ); // AND-AND
+            return il;
+          }
+        }
+      }
+    }
+
+    /* collect binate divisors */
+    std::vector<std::pair<uint32_t, uint32_t>> neg_binates, pos_binates;
+
+    for ( i = 0u; i < binate.size(); ++i )
+    {
+      if ( neg_binates.size() >= 500 && pos_binates.size() >= 500 )
+      {
+        break;
+      }
+      for ( j = i + 1; j < binate.size(); ++j )
+      {
+        auto const& tt_s0 = get_tt_from_lit( binate[i], tts, begin );
+        auto const& tt_s1 = get_tt_from_lit( binate[j], tts, begin );
+        if ( pos_binates.size() < 500 )
+        {
+          if ( kitty::implies( tt_s0 & tt_s1, target ) )
+          {
+            pos_binates.emplace_back( std::make_pair( binate[i], binate[j] ) );
+          }
+          if ( kitty::implies( ~tt_s0 & tt_s1, target ) )
+          {
+            pos_binates.emplace_back( std::make_pair( binate[i] ^ 0x1, binate[j] ) );
+          }
+
+          if ( kitty::implies( tt_s0 & ~tt_s1, target ) )
+          {
+            pos_binates.emplace_back( std::make_pair( binate[i], binate[j] ^ 0x1 ) );
+          }
+
+          if ( kitty::implies( ~tt_s0 & ~tt_s1, target ) )
+          {
+            pos_binates.emplace_back( std::make_pair( binate[i] ^ 0x1, binate[j] ^ 0x1 ) );
+          }
+        }
+        if ( neg_binates.size() < 500 )
+        {
+          if ( kitty::implies( target, tt_s0 | tt_s1 ) )
+          {
+            neg_binates.emplace_back( std::make_pair( binate[i], binate[j] ) );
+          }
+          if ( kitty::implies( target, ~tt_s0 | tt_s1 ) )
+          {
+            neg_binates.emplace_back( std::make_pair( binate[i] ^ 0x1, binate[j] ) );
+          }
+
+          if ( kitty::implies( target, tt_s0 | ~tt_s1 ) )
+          {
+            neg_binates.emplace_back( std::make_pair( binate[i], binate[j] ^ 0x1 ) );
+          }
+
+          if ( kitty::implies( target, ~tt_s0 | ~tt_s1 ) )
+          {
+            neg_binates.emplace_back( std::make_pair( binate[i] ^ 0x1, binate[j] ^ 0x1 ) );
+          }
+        }
+      }
+    }
+    for ( i = 0u; i < pos_binates.size(); ++i )
+    {
+      auto const& tt_binate = get_tt_from_lit( pos_binates[i].first, tts, begin ) & get_tt_from_lit( pos_binates[i].second, tts, begin );
+      for ( j = 0u; j < pos_unate.size(); ++j )
+      {
+        if ( target == ( get_tt_from_lit( pos_unate[j], tts, begin ) | tt_binate ) )
+        {
+          il.add_output( il.add_and( il.add_and( pos_binates[i].first, pos_binates[i].second ) ^ 0x1, pos_unate[j] ^ 0x1 ) ^ 0x1 ); // AND-OR
+          return il;
+        }
+      }
+    }
+    for ( i = 0u; i < neg_binates.size(); ++i )
+    {
+      auto const& tt_binate = get_tt_from_lit( neg_binates[i].first, tts, begin ) | get_tt_from_lit( neg_binates[i].second, tts, begin );
+      for ( j = 0u; j < neg_unate.size(); ++j )
+      {
+        if ( target == ( get_tt_from_lit( neg_unate[j], tts, begin ) & tt_binate ) )
+        {
+          il.add_output( il.add_and( il.add_and( neg_binates[i].first ^ 0x1, neg_binates[i].second ^ 0x1 ) ^ 0x1, neg_unate[j] ) ); // OR-AND
+          return il;
+        }
+      }
+    }
+
+    if ( max_size == 2 )
+    {
+      return std::nullopt;
+    }
+
+    /* 3-resub */
+    for ( i = 0u; i < neg_binates.size(); ++i )
+    {
+      auto const& tt_binate = get_tt_from_lit( neg_binates[i].first, tts, begin ) | get_tt_from_lit( neg_binates[i].second, tts, begin );
+      for ( j = i + 1; j < neg_binates.size(); ++j )
+      {
+        if ( target == ( ( get_tt_from_lit( neg_binates[j].first, tts, begin ) | get_tt_from_lit( neg_binates[j].second, tts, begin ) ) & tt_binate ) )
+        {
+          il.add_output( il.add_and( il.add_and( neg_binates[i].first ^ 0x1, neg_binates[i].second ^ 0x1 ) ^ 0x1, il.add_and( neg_binates[j].first ^ 0x1, neg_binates[j].second ^ 0x1 ) ^ 0x1 ) ); // AND-2OR
+          return il;
+        }
+      }
+    }
+    for ( i = 0u; i < pos_binates.size(); ++i )
+    {
+      auto const& tt_binate = get_tt_from_lit( pos_binates[i].first, tts, begin ) & get_tt_from_lit( pos_binates[i].second, tts, begin );
+      for ( j = i + 1; j < pos_binates.size(); ++j )
+      {
+        if ( target == ( ( get_tt_from_lit( pos_binates[j].first, tts, begin ) & get_tt_from_lit( pos_binates[j].second, tts, begin ) ) | tt_binate ) )
+        {
+          il.add_output( il.add_and( il.add_and( pos_binates[i].first, pos_binates[i].second ) ^ 0x1, il.add_and( pos_binates[j].first, pos_binates[j].second ) ^ 0x1 ) ^ 0x1 ); // OR-2AND
+          return il;
+        }
+      }
+    }
+
+    for ( i = 0u; i < pos_unate.size(); ++i )
+    {
+      for ( j = i + 1; j < pos_unate.size(); ++j )
+      {
+        for ( k = j + 1; k < pos_unate.size(); ++k )
+        {
+          for ( l = k + 1; l < pos_unate.size(); ++l )
+          {
+            if ( target == ( get_tt_from_lit( pos_unate[i], tts, begin ) | get_tt_from_lit( pos_unate[j], tts, begin ) | get_tt_from_lit( pos_unate[k], tts, begin ) | get_tt_from_lit( pos_unate[l], tts, begin ) ) )
+            {
+              il.add_output( il.add_and( il.add_and( pos_unate[i] ^ 0x1, pos_unate[j] ^ 0x1 ), il.add_and( pos_unate[k] ^ 0x1, pos_unate[l] ^ 0x1 ) ) ^ 0x1 ); // OR-2OR
+              return il;
+            }
+          }
+        }
+      }
+    }
+
+    for ( i = 0u; i < neg_unate.size(); ++i )
+    {
+      for ( j = i + 1; j < neg_unate.size(); ++j )
+      {
+        for ( k = j + 1; k < neg_unate.size(); ++k )
+        {
+          for ( l = k + 1; l < neg_unate.size(); ++l )
+          {
+            if ( target == ( get_tt_from_lit( neg_unate[i], tts, begin ) & get_tt_from_lit( neg_unate[j], tts, begin ) & get_tt_from_lit( neg_unate[k], tts, begin ) & get_tt_from_lit( neg_unate[l], tts, begin ) ) )
+            {
+              il.add_output( il.add_and( il.add_and( neg_unate[i], neg_unate[j] ), il.add_and( neg_unate[k], neg_unate[l] ) ) ); // AND-2AND
+              return il;
+            }
+          }
+        }
+      }
+    }
+
+    if ( max_size == 3 )
+    {
+      return std::nullopt;
+    }
+
+    return std::nullopt;
+  }
+
+private:
+  uint32_t make_lit( uint32_t const& var, bool const& inv = false )
+  {
+    return ( var + 1 ) * 2 + (uint32_t)inv;
+  }
+
+  template<class truth_table_storage_type, class iterator_type>
+  TT get_tt_from_lit( uint32_t const& lit, truth_table_storage_type const& tts, iterator_type const& begin )
+  {
+    return ( lit % 2 ) ? ~tts[*( begin + ( lit / 2 ) - 1 )] : tts[*( begin + ( lit / 2 ) - 1 )];
+  }
+
+private:
+  stats& st;
+}; /* aig_enumerative_resyn */
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/resyn_engines/dump_resyn.hpp b/include/mockturtle/algorithms/resyn_engines/dump_resyn.hpp
new file mode 100644
index 0000000..228f0f3
--- /dev/null
+++ b/include/mockturtle/algorithms/resyn_engines/dump_resyn.hpp
@@ -0,0 +1,120 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file dump_resyn.hpp
+  \brief Dumps out resynthesis problems.
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../../utils/null_utils.hpp"
+
+#include <fmt/format.h>
+#include <kitty/kitty.hpp>
+#include <optional>
+#include <string>
+#include <fstream>
+#include <iostream>
+
+namespace mockturtle
+{
+
+template<class TT, class IndexList>
+class resyn_dumper
+{
+public:
+  using stats = null_stats;
+  using index_list_t = IndexList;
+  using truth_table_t = TT;
+
+  explicit resyn_dumper( stats& st )
+  {
+    (void)st;
+  }
+
+  ~resyn_dumper()
+  {
+    std::cout << "avg. size = " << float( total_size ) / float( num_calls ) << "\n";
+  }
+
+  void reset_filename( std::string const& new_prefix )
+  {
+    filename_prefix = new_prefix;
+    id_counter = 0;
+  }
+
+  template<class iterator_type, class truth_table_storage_type>
+  std::optional<index_list_t> operator()( TT const& target, TT const& care, iterator_type begin, iterator_type end, truth_table_storage_type const& tts, uint32_t max_size = std::numeric_limits<uint32_t>::max(), uint32_t max_level = std::numeric_limits<uint32_t>::max() )
+  {
+    (void)max_level;
+
+    std::string const filename = fmt::format( "{}{:0>{}}.resyn", filename_prefix, id_counter++, id_width );
+    std::ofstream os( filename.c_str(), std::ofstream::out );
+
+    /* header */
+    const uint32_t I = 0;
+    const uint32_t N = std::distance( begin, end );
+    const uint32_t T = 1;
+    const uint32_t L = target.num_bits();
+    os << fmt::format( "resyn {} {} {} {}\n", I, N, T, L );
+
+    /* simulation signatures */
+    while ( begin != end )
+    {
+      auto const& tt = tts[*begin];
+      assert( tt.num_bits() == target.num_bits() );
+      kitty::print_binary( tt, os );
+      os << "\n";
+      ++begin;
+    }
+
+    /* target offset */
+    kitty::print_binary( ~target & care, os );
+    os << "\n";
+    /* target onset */
+    kitty::print_binary( target & care, os );
+    os << "\n";
+
+    /* comment */
+    os << fmt::format( "c\nmax size = {}\n", max_size );
+
+    total_size += max_size;
+    num_calls++;
+    os.close();
+    return std::nullopt;
+  }
+
+private:
+  std::string filename_prefix = "resyn";
+  uint32_t id_counter{0};
+  const uint32_t id_width{3}; // width = 4 means max id = 9999
+  uint32_t total_size{0};
+  uint32_t num_calls{0};
+};
+
+} // namespace mockturtle
diff --git a/include/mockturtle/algorithms/resyn_engines/mig_enumerative.hpp b/include/mockturtle/algorithms/resyn_engines/mig_enumerative.hpp
new file mode 100644
index 0000000..0e48a11
--- /dev/null
+++ b/include/mockturtle/algorithms/resyn_engines/mig_enumerative.hpp
@@ -0,0 +1,284 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mig_enumerative.hpp
+  \brief MIG enumerative resynthesis
+
+  \author Hanyu Wang
+  \author Siang-Yun (Sonia) Lee
+
+  Based on previous implementation of MIG resubstitution by
+  Eleonora Testa, Heinz Riener, and Mathias Soeken
+*/
+
+#pragma once
+
+#include "../../utils/index_list.hpp"
+#include "../../utils/null_utils.hpp"
+#include <kitty/kitty.hpp>
+#include <optional>
+#include <vector>
+
+namespace mockturtle
+{
+
+template<typename TT>
+struct mig_enumerative_resyn
+{
+public:
+  using stats = null_stats;
+  using index_list_t = mig_index_list;
+  using truth_table_t = TT;
+
+public:
+  explicit mig_enumerative_resyn( stats& st ) noexcept
+      : st( st )
+  {
+  }
+
+  template<class iterator_type, class truth_table_storage_type>
+  std::optional<index_list_t> operator()( TT const& target, TT const& care, iterator_type begin, iterator_type end, truth_table_storage_type const& tts, uint32_t max_size = std::numeric_limits<uint32_t>::max() )
+  {
+    (void)care;
+    assert( is_const0( ~care ) && "enumerative resynthesis does not support don't cares" );
+
+    index_list_t il( std::distance( begin, end ) );
+    const TT ntarget = ~target;
+    uint32_t i, j, k, l;
+    iterator_type it = begin, jt = begin;
+
+    /* C-resub */
+    if ( kitty::is_const0( target ) )
+    {
+      il.add_output( 0 );
+      return il;
+    }
+    if ( kitty::is_const0( ntarget ) ) // unreachable if normalized
+    {
+      il.add_output( 1 );
+      return il;
+    }
+
+    /* 0-resub */
+    for ( it = begin, i = 0u; it != end; ++it, ++i )
+    {
+      if ( target == tts[*it] )
+      {
+        il.add_output( make_lit( i ) );
+        return il;
+      }
+      if ( ntarget == tts[*it] ) // unreachable if normalized
+      {
+        il.add_output( make_lit( i, true ) );
+        return il;
+      }
+    }
+
+    /* R-resub: doesn't work with this problem definition (need fanins of root) */
+
+    if ( max_size == 0 )
+    {
+      return std::nullopt;
+    }
+
+    /* collect candidate pairs using MAJ filtering rule */
+    std::vector<std::pair<uint32_t, uint32_t>> maj1pairs;
+    std::vector<uint32_t> binate;
+    for ( it = begin, i = 0u; it != end; ++it, ++i )
+    {
+      for ( jt = it + 1, j = i + 1; jt != end; ++jt, ++j )
+      {
+        if ( kitty::ternary_majority( tts[*it], tts[*jt], target ) == target )
+        {
+          maj1pairs.emplace_back( make_lit( i ), make_lit( j ) );
+        }
+        else if ( kitty::ternary_majority( ~tts[*it], tts[*jt], target ) == target )
+        {
+          maj1pairs.emplace_back( make_lit( i, true ), make_lit( j ) );
+        }
+        else if ( kitty::ternary_majority( tts[*it], ~tts[*jt], target ) == target )
+        {
+          maj1pairs.emplace_back( make_lit( i ), make_lit( j, true ) );
+        }
+        else if ( kitty::ternary_majority( ~tts[*it], ~tts[*jt], target ) == target ) // unreachable if normalized
+        {
+          maj1pairs.emplace_back( make_lit( i, true ), make_lit( j, true ) );
+        }
+        else if ( std::find( binate.begin(), binate.end(), make_lit( i ) ) == binate.end() )
+        {
+          binate.emplace_back( make_lit( i ) );
+          binate.emplace_back( make_lit( i, true ) ); /* 2x redundant memory*/
+        }
+      }
+      if ( kitty::implies( tts[*it], target ) )
+      {
+        maj1pairs.emplace_back( make_lit( i ), 1 );
+      }
+      else if ( kitty::implies( ~tts[*it], target ) )
+      {
+        maj1pairs.emplace_back( make_lit( i, true ), 1 );
+      }
+      else if ( kitty::implies( target, tts[*it] ) )
+      {
+        maj1pairs.emplace_back( make_lit( i ), 0 );
+      }
+      else if ( kitty::implies( target, ~tts[*it] ) )
+      {
+        maj1pairs.emplace_back( make_lit( i, true ), 0 );
+      }
+      else if ( std::find( binate.begin(), binate.end(), make_lit( i ) ) == binate.end() )
+      {
+        binate.emplace_back( make_lit( i ) );
+        binate.emplace_back( make_lit( i, true ) ); /* 2x redundant memory*/
+      }
+    }
+
+    /* 1-resub */
+    for ( i = 0u; i < maj1pairs.size(); ++i )
+    {
+      TT const& x = get_tt_from_lit( maj1pairs[i].first, tts, begin );
+      if ( maj1pairs[i].second < 2 )
+      {
+        for ( j = i + 1; j < maj1pairs.size(); ++j )
+        {
+          if ( maj1pairs[i].second == 0 && target == ( x & get_tt_from_lit( maj1pairs[j].first, tts, begin ) ) )
+          {
+            il.add_output( il.add_maj( maj1pairs[i].first, maj1pairs[i].second, maj1pairs[j].first ) );
+            return il;
+          }
+          else if ( maj1pairs[i].second == 1 && target == ( x | get_tt_from_lit( maj1pairs[j].first, tts, begin ) ) )
+          {
+            il.add_output( il.add_maj( maj1pairs[i].first, maj1pairs[i].second, maj1pairs[j].first ) );
+            return il;
+          }
+
+          if ( maj1pairs[j].second < 2 )
+          {
+            continue;
+          }
+          if ( maj1pairs[i].second == 0 && target == ( x & get_tt_from_lit( maj1pairs[j].second, tts, begin ) ) )
+          {
+            il.add_output( il.add_maj( maj1pairs[i].first, maj1pairs[i].second, maj1pairs[j].second ) );
+            return il;
+          }
+          else if ( maj1pairs[i].second == 1 && target == ( x | get_tt_from_lit( maj1pairs[j].second, tts, begin ) ) )
+          {
+            il.add_output( il.add_maj( maj1pairs[i].first, maj1pairs[i].second, maj1pairs[j].second ) );
+            return il;
+          }
+        }
+      }
+      else
+      {
+        TT const& y = get_tt_from_lit( maj1pairs[i].second, tts, begin );
+        for ( j = i + 1; j < maj1pairs.size(); ++j )
+        {
+          if ( target == kitty::ternary_majority( x, y, get_tt_from_lit( maj1pairs[j].first, tts, begin ) ) )
+          {
+            il.add_output( il.add_maj( maj1pairs[i].first, maj1pairs[i].second, maj1pairs[j].first ) );
+            return il;
+          }
+          if ( maj1pairs[j].second < 2 )
+          {
+            if ( maj1pairs[j].second == 0 && target == ( x & y ) )
+            {
+              il.add_output( il.add_maj( maj1pairs[i].first, maj1pairs[i].second, maj1pairs[j].second ) );
+              return il;
+            }
+            else if ( maj1pairs[j].second == 1 && target == ( x | y ) )
+            {
+              il.add_output( il.add_maj( maj1pairs[i].first, maj1pairs[i].second, maj1pairs[j].second ) );
+              return il;
+            }
+          }
+          else if ( target == kitty::ternary_majority( x, y, get_tt_from_lit( maj1pairs[j].second, tts, begin ) ) )
+          {
+            il.add_output( il.add_maj( maj1pairs[i].first, maj1pairs[i].second, maj1pairs[j].second ) );
+            return il;
+          }
+        }
+      }
+    }
+
+    if ( max_size == 1 )
+    {
+      return std::nullopt;
+    }
+
+    /* 2-resub */
+    for ( i = 0u; i < binate.size(); ++i )
+    {
+      auto const& x = get_tt_from_lit( binate[i], tts, begin );
+      for ( j = i + 2u; j < binate.size(); ++j )
+      {
+        auto const& y = get_tt_from_lit( binate[j], tts, begin );
+        for ( k = j + 2u; k < binate.size(); ++k )
+        {
+          auto const& z = get_tt_from_lit( binate[k], tts, begin );
+          auto tt_binate = kitty::ternary_majority( x, y, z );
+          if ( kitty::implies( tt_binate, target ) ) /* Boolean Over-Filtering */
+          {
+            for ( l = 0u; l < maj1pairs.size(); ++l )
+            {
+              auto const& a = get_tt_from_lit( maj1pairs[l].first, tts, begin );
+              auto tt = maj1pairs[l].second >= 2 ? kitty::ternary_majority( a, get_tt_from_lit( maj1pairs[l].second, tts, begin ), tt_binate ) : maj1pairs[l].second ? a | tt_binate
+                                                                                                                                                                     : a & tt_binate;
+              if ( tt == target )
+              {
+                il.add_output( il.add_maj( maj1pairs[l].first, maj1pairs[l].second, il.add_maj( binate[i], binate[j], binate[k] ) ) );
+                return il;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if ( max_size == 2 )
+    {
+      return std::nullopt;
+    }
+
+    return std::nullopt;
+  }
+
+private:
+  uint32_t make_lit( uint32_t const& var, bool const& inv = false )
+  {
+    return ( var + 1 ) * 2 + (uint32_t)inv;
+  }
+
+  template<class truth_table_storage_type, class iterator_type>
+  TT get_tt_from_lit( uint32_t const& lit, truth_table_storage_type const& tts, iterator_type const& begin )
+  {
+    return ( lit % 2 ) ? ~tts[*( begin + ( lit / 2 ) - 1 )] : tts[*( begin + ( lit / 2 ) - 1 )];
+  }
+
+private:
+  stats& st;
+}; /* mig_enumerative_resyn */
+
+} // namespace mockturtle
diff --git a/include/mockturtle/algorithms/resyn_engines/mig_resyn.hpp b/include/mockturtle/algorithms/resyn_engines/mig_resyn.hpp
new file mode 100644
index 0000000..6684e51
--- /dev/null
+++ b/include/mockturtle/algorithms/resyn_engines/mig_resyn.hpp
@@ -0,0 +1,1344 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mig_resyn.hpp
+  \brief Implements resynthesis methods for MIGs.
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../../utils/index_list.hpp"
+
+#include <fmt/format.h>
+#include <kitty/kitty.hpp>
+
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+namespace mockturtle
+{
+
+struct mig_resyn_static_params
+{
+  using base_type = mig_resyn_static_params;
+
+  /*! \brief Reserved capacity for divisor truth tables (number of divisors). */
+  static constexpr uint32_t reserve{ 200u };
+
+  /*! \brief Whether to preserve depth. */
+  static constexpr bool preserve_depth{ false };
+
+  /*! \brief Whether the divisors have uniform costs (size and depth, whenever relevant). */
+  static constexpr bool uniform_div_cost{ true };
+
+  /*! \brief Size cost of each MAJ gate. */
+  static constexpr uint32_t size_cost_of_maj{ 1u };
+
+  /*! \brief Depth cost of each MAJ gate (only relevant when `preserve_depth = true`). */
+  static constexpr uint32_t depth_cost_of_maj{ 1u };
+
+  // Future work: Consider cost for inverter / MAJ with constant input; Add XOR support (XMG)
+};
+
+struct mig_resyn_stats
+{
+  void report() const {}
+};
+
+/*! \brief Logic resynthesis engine for MIGs with a bottom-up approach.
+ *
+ * This algorithm resynthesizes the target function with divisor functions
+ * by building a chain of majority gates from bottom to top. Divisors are
+ * chosen as side fanins based on some scoring functions aiming at covering
+ * more uncovered bits.
+ *
+ */
+template<class TT, class static_params = mig_resyn_static_params>
+class mig_resyn_bottomup
+{
+public:
+  using stats = mig_resyn_stats;
+  using index_list_t = mig_index_list;
+  using truth_table_t = TT;
+
+  explicit mig_resyn_bottomup( stats& st )
+      : st( st )
+  {
+    static_assert( std::is_same_v<typename static_params::base_type, mig_resyn_static_params>, "Invalid static_params type" );
+    static_assert( !static_params::preserve_depth && static_params::uniform_div_cost, "Advanced resynthesis is not implemented for this solver" );
+    divisors.reserve( static_params::reserve );
+  }
+
+  template<class iterator_type, class truth_table_storage_type>
+  std::optional<index_list_t> operator()( TT const& target, TT const& care, iterator_type begin, iterator_type end, truth_table_storage_type const& tts, uint32_t max_size = std::numeric_limits<uint32_t>::max(), uint32_t max_level = std::numeric_limits<uint32_t>::max() )
+  {
+    (void)care;
+    (void)max_level;
+    divisors.clear();
+    index_list.clear();
+
+    num_bits = target.num_bits();
+    divisors.emplace_back( ~target );
+    divisors.emplace_back( target );
+
+    while ( begin != end )
+    {
+      auto const& tt = tts[*begin];
+      assert( tt.num_bits() == target.num_bits() );
+      divisors.emplace_back( tt ^ divisors[0] ); // tt XNOR target = tt XOR ~target
+      divisors.emplace_back( tt ^ target );      // ~tt XNOR target = tt XOR target
+      index_list.add_inputs();
+      ++begin;
+    }
+
+    return compute_function( max_size );
+  }
+
+private:
+  std::optional<index_list_t> compute_function( uint32_t num_inserts )
+  {
+    uint64_t max_score = 0u;
+    max_i = 0u;
+    for ( auto i = 0u; i < divisors.size(); ++i )
+    {
+      uint32_t score = kitty::count_ones( divisors.at( i ) );
+      if ( score > max_score )
+      {
+        max_score = score;
+        max_i = i;
+        if ( max_score == num_bits )
+        {
+          break;
+        }
+      }
+    }
+    /* 0-resub (including constants) */
+    if ( max_score == num_bits )
+    {
+      index_list.add_output( max_i );
+      return index_list;
+    }
+
+    if ( num_inserts == 0u )
+    {
+      return std::nullopt;
+    }
+    size_limit = divisors.size() + num_inserts * 2;
+
+    return bottom_up_approach();
+  }
+
+  std::optional<mig_index_list> bottom_up_approach()
+  {
+    // maj_nodes.emplace_back( maj_node{uint32_t( divisors.size() ), {max_i}} );
+    TT const& function_i = divisors.at( max_i );
+    current_lit = divisors.size();
+    return bottom_up_approach_rec( function_i );
+  }
+
+  std::optional<mig_index_list> bottom_up_approach_rec( TT const& function_i )
+  {
+    /* THINK: Should we consider reusing newly-built nodes (nodes in maj_nodes) in addition to divisors? */
+
+    /* the second fanin: 2 * #newly-covered-bits + 1 * #cover-again-bits */
+    uint64_t max_score = 0u;
+    max_j = 0u;
+    auto const not_covered_by_i = ~function_i;
+    for ( auto j = 0u; j < divisors.size(); ++j )
+    {
+      auto const covered_by_j = divisors.at( j );
+      uint32_t score = kitty::count_ones( covered_by_j ) + kitty::count_ones( not_covered_by_i & covered_by_j );
+      if ( score > max_score && ( j >> 1 ) != ( max_i >> 1 ) )
+      {
+        max_score = score;
+        max_j = j;
+      }
+    }
+    // maj_nodes.back().fanins.emplace_back( max_j );
+
+    /* the third fanin: only care about the disagreed bits */
+    max_score = 0u;
+    max_k = 0u;
+    auto const disagree_in_ij = function_i ^ divisors.at( max_j );
+    for ( auto k = 0u; k < divisors.size(); ++k )
+    {
+      uint32_t score = kitty::count_ones( divisors.at( k ) & disagree_in_ij );
+      if ( score > max_score && ( k >> 1 ) != ( max_i >> 1 ) && ( k >> 1 ) != ( max_j >> 1 ) )
+      {
+        max_score = score;
+        max_k = k;
+      }
+    }
+    // maj_nodes.back().fanins.emplace_back( max_k );
+    index_list.add_maj( max_i, max_j, max_k );
+
+    auto const current_function = kitty::ternary_majority( function_i, divisors.at( max_j ), divisors.at( max_k ) );
+    if ( kitty::is_const0( ~current_function ) )
+    {
+      index_list.add_output( current_lit );
+      return index_list;
+    }
+    else if ( current_lit + 2 < size_limit )
+    {
+      // maj_nodes.emplace_back( maj_node{maj_nodes.back().id + 2u, {maj_nodes.back().id}} );
+      max_i = current_lit;
+      current_lit += 2;
+      return bottom_up_approach_rec( current_function );
+    }
+    else
+    {
+      return std::nullopt;
+    }
+  }
+
+private:
+  uint32_t size_limit;
+  uint32_t num_bits;
+  uint32_t current_lit; /* literal of the current topmost node */
+
+  uint32_t max_i, max_j, max_k;
+
+  std::vector<TT> divisors;
+  index_list_t index_list;
+
+  stats& st;
+}; /* mig_resyn_bottomup */
+
+/*! \brief Logic resynthesis engine for MIGs with top-down decomposition.
+ *
+ * This algorithm resynthesizes the target function with divisor functions
+ * by first building the topmost node, and then iteratively refining its
+ * output function by expanding a leaf with a new node. The three fanins
+ * of the newly-created node are chosen from the divisors based on some
+ * scoring functions aiming at covering more *care* bits.
+ *
+ */
+template<class TT, class static_params = mig_resyn_static_params>
+class mig_resyn_topdown
+{
+public:
+  using stats = mig_resyn_stats;
+  using index_list_t = mig_index_list;
+  using truth_table_t = TT;
+
+private:
+  /*! \brief Internal data structure */
+  struct expansion_position
+  {
+    int32_t parent_position = -1; // maj_nodes.at( ... )
+    int32_t fanin_num = -1;       // 0, 1, 2
+
+    bool operator==( expansion_position const& e ) const
+    {
+      return parent_position == e.parent_position && fanin_num == e.fanin_num;
+    }
+  };
+
+  struct maj_node
+  {
+    uint32_t id;                  /* maj_nodes.at( id - divisors.size() ) */
+    std::vector<uint32_t> fanins; /* ids of its three fanins */
+
+    std::vector<TT> fanin_functions = std::vector<TT>();
+    TT care = TT();
+    expansion_position parent = expansion_position();
+  };
+
+  struct simple_maj
+  {
+    std::vector<uint32_t> fanins; /* ids of divisors */
+    TT function = TT();           /* resulting function */
+  };
+
+public:
+  explicit mig_resyn_topdown( stats& st )
+      : st( st )
+  {
+    static_assert( std::is_same_v<typename static_params::base_type, mig_resyn_static_params>, "Invalid static_params type" );
+    static_assert( !( static_params::uniform_div_cost && static_params::preserve_depth ), "If depth is to be preserved, divisor depth cost must be provided (usually not uniform)" );
+    divisors.reserve( static_params::reserve );
+  }
+
+  /*! \brief Perform MIG resynthesis.
+   *
+   * `*pTTs[*begin]` must be of type `TT`.
+   *
+   * \param target Truth table of the target function.
+   * \param care Truth table of the care set.
+   * \param begin Begin iterator to divisor nodes.
+   * \param end End iterator to divisor nodes.
+   * \param tts A data structure (e.g. std::vector<TT>) that stores the truth tables of the divisor functions.
+   * \param max_size Maximum number of nodes allowed in the dependency circuit.
+   */
+  template<class iterator_type, class truth_table_storage_type, bool enabled = static_params::uniform_div_cost && !static_params::preserve_depth, typename = std::enable_if_t<enabled>>
+  std::optional<index_list_t> operator()( TT const& target, TT const& care, iterator_type begin, iterator_type end, truth_table_storage_type const& tts, uint32_t max_size = std::numeric_limits<uint32_t>::max() )
+  {
+    divisors.clear();
+    maj_nodes.clear();
+    computed_table.clear();
+    leaves.clear();
+
+    divisors.emplace_back( ~target );
+    divisors.emplace_back( target );
+
+    while ( begin != end )
+    {
+      auto const& tt = tts[*begin];
+      assert( tt.num_bits() == target.num_bits() );
+      divisors.emplace_back( tt ^ divisors[0] ); // tt XNOR target = tt XOR ~target
+      divisors.emplace_back( tt ^ target );      // ~tt XNOR target = tt XOR target
+      ++begin;
+    }
+    scores.resize( divisors.size() );
+    size_limit = max_size;
+    num_bits = kitty::count_ones( care );
+
+    return compute_function( care );
+  }
+
+  template<class iterator_type, class truth_table_storage_type, class Fn, bool enabled = !static_params::uniform_div_cost && !static_params::preserve_depth, typename = std::enable_if_t<enabled>>
+  std::optional<index_list_t> operator()( TT const& target, TT const& care, iterator_type begin, iterator_type end, truth_table_storage_type const& tts, Fn&& size_cost, uint32_t max_size = std::numeric_limits<uint32_t>::max() )
+  {
+    static_assert( !static_params::uniform_div_cost && !static_params::preserve_depth, "" );
+  }
+
+  template<class iterator_type, class truth_table_storage_type, class Fn, bool enabled = !static_params::uniform_div_cost && static_params::preserve_depth, typename = std::enable_if_t<enabled>>
+  std::optional<index_list_t> operator()( TT const& target, TT const& care, iterator_type begin, iterator_type end, truth_table_storage_type const& tts, Fn&& size_cost, Fn&& depth_cost, uint32_t max_size = std::numeric_limits<uint32_t>::max(), uint32_t max_depth = std::numeric_limits<uint32_t>::max() )
+  {}
+
+private:
+  std::optional<index_list_t> compute_function( TT const& care )
+  {
+    for ( auto i = 0u; i < divisors.size(); ++i )
+    {
+      if ( kitty::is_const0( ~divisors.at( i ) & care ) )
+      {
+        /* 0-resub (including constants) */
+        mig_index_list index_list( divisors.size() / 2 - 1 );
+        index_list.add_output( i );
+        return index_list;
+      }
+    }
+
+    if ( size_limit == 0u )
+    {
+      return std::nullopt;
+    }
+
+    return top_down_approach( care );
+  }
+
+  std::optional<index_list_t> top_down_approach( TT const& top_care )
+  {
+    maj_nodes.reserve( size_limit );
+    std::vector<simple_maj> top_node_choices = construct_top( top_care );
+
+    if ( top_node_choices.size() == 1u && kitty::is_const0( ~top_node_choices[0].function & top_care ) )
+    {
+      /* 1-resub */
+      mig_index_list index_list( divisors.size() / 2 - 1 );
+      index_list.add_maj( top_node_choices[0].fanins[0], top_node_choices[0].fanins[1], top_node_choices[0].fanins[2] );
+      index_list.add_output( divisors.size() );
+      return index_list;
+    }
+    // for ( simple_maj& top_node : top_node_choices )
+    //{
+    //   if ( easy_refine( top_node, top_care, 0 ) || easy_refine( top_node, top_care, 1 ) )
+    //   {
+    //     /* 1-resub */
+    //     mig_index_list index_list( divisors.size() / 2 - 1 );
+    //     index_list.add_maj( top_node.fanins[0], top_node.fanins[1], top_node.fanins[2] );
+    //     index_list.add_output( divisors.size() );
+    //     return index_list;
+    //   }
+    // }
+    if ( size_limit == 1u )
+    {
+      return std::nullopt;
+    }
+
+    std::vector<maj_node> maj_nodes_best;
+    for ( simple_maj const& top_node : top_node_choices )
+    {
+      // for ( int32_t i = 0; i < 3; ++i )
+      {
+        maj_nodes.clear();
+        maj_nodes.emplace_back( maj_node{ uint32_t( divisors.size() ), top_node.fanins, { divisors.at( top_node.fanins[0] ), divisors.at( top_node.fanins[1] ), divisors.at( top_node.fanins[2] ) }, top_care } );
+
+        leaves.clear();
+        // improve_in_parent.clear();
+        // shuffle.clear();
+        // first_round = true;
+        // leaves.emplace_back( expansion_position{0, (int32_t)sibling_index( i, 1 )} );
+        // leaves.emplace_back( expansion_position{0, (int32_t)sibling_index( i, 2 )} );
+        leaves.emplace_back( expansion_position{ 0, 0 } );
+        leaves.emplace_back( expansion_position{ 0, 1 } );
+        leaves.emplace_back( expansion_position{ 0, 2 } );
+
+        // TT const care = top_care & ~( divisors.at( top_node.fanins[sibling_index( i, 1 )] ) & divisors.at( top_node.fanins[sibling_index( i, 2 )] ) );
+        // if ( evaluate_one( care, divisors.at( top_node.fanins[i] ), expansion_position{0, i} ) )
+        //{
+        //   /* 2-resub */
+        //   maj_nodes_best = maj_nodes;
+        //   return translate( maj_nodes_best );
+        // }
+
+        if ( !refine() )
+        {
+          continue;
+        }
+
+        if ( maj_nodes_best.size() == 0u || maj_nodes.size() < maj_nodes_best.size() )
+        {
+          maj_nodes_best = maj_nodes;
+        }
+      }
+    }
+
+    if ( maj_nodes_best.size() == 0u )
+    {
+      return std::nullopt;
+    }
+    return translate( maj_nodes_best );
+  }
+
+  bool refine()
+  {
+    // while ( ( leaves.size() != 0u || improve_in_parent.size() != 0u || shuffle.size() != 0u ) && maj_nodes.size() < size_limit )
+    while ( leaves.size() != 0u && maj_nodes.size() < size_limit )
+    {
+      // if ( leaves.size() == 0u )
+      //{
+      //   if ( improve_in_parent.size() != 0u )
+      //   {
+      //     leaves = improve_in_parent;
+      //     improve_in_parent.clear();
+      //   }
+      //   else
+      //   {
+      //     leaves = shuffle;
+      //     shuffle.clear();
+      //   }
+      //   first_round = false;
+      // }
+
+      uint32_t min_mismatch = num_bits + 1;
+      uint32_t pos = 0u;
+      for ( int32_t i = 0; (unsigned)i < leaves.size(); ++i )
+      {
+        maj_node& parent_node = maj_nodes.at( leaves[i].parent_position );
+        uint32_t const& fi = leaves[i].fanin_num;
+        TT const& original_function = parent_node.fanin_functions.at( fi );
+
+        if ( parent_node.fanins.at( fi ) >= divisors.size() ) /* already expanded */
+        {
+          leaves.erase( leaves.begin() + i );
+          --i;
+          continue;
+        }
+
+        TT const care = parent_node.care & ~( sibling_func( parent_node, fi, 1 ) & sibling_func( parent_node, fi, 2 ) );
+        if ( fulfilled( original_function, care ) /* already fulfilled */
+             || care == parent_node.care          /* probably cannot improve */
+        )
+        {
+          leaves.erase( leaves.begin() + i );
+          --i;
+          continue;
+        }
+
+        uint32_t const mismatch = count_ones( care & ~original_function );
+        if ( mismatch < min_mismatch )
+        {
+          pos = i;
+          min_mismatch = mismatch;
+        }
+      }
+      if ( leaves.size() == 0u )
+      {
+        break;
+      }
+      expansion_position node_position = leaves.at( pos );
+      leaves.erase( leaves.begin() + pos );
+
+      maj_node& parent_node = maj_nodes.at( node_position.parent_position );
+      uint32_t const& fi = node_position.fanin_num;
+      TT const& original_function = parent_node.fanin_functions.at( fi );
+      TT const care = parent_node.care & ~( sibling_func( parent_node, fi, 1 ) & sibling_func( parent_node, fi, 2 ) );
+
+      if ( evaluate_one( care, original_function, node_position ) )
+      {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool evaluate_one( TT const& care, TT const& original_function, expansion_position const& node_position )
+  {
+    maj_node& parent_node = maj_nodes.at( node_position.parent_position );
+    uint32_t const& fi = node_position.fanin_num;
+
+    simple_maj const new_node = expand_one( care );
+    uint64_t const original_score = score( original_function, care );
+    uint64_t const new_score = score( new_node.function, care );
+    if ( new_score <= original_score )
+    {
+      return false;
+    }
+
+    // if ( new_score == original_score )
+    //{
+    //   if ( kitty::count_ones( new_node.function & parent_node.care ) > kitty::count_ones( original_function & parent_node.care ) )
+    //   {
+    //     if ( first_round )
+    //     {
+    //       /* We put it into a back-up queue for now */
+    //       improve_in_parent.emplace_back( node_position );
+    //       return false;
+    //     }
+    //     else
+    //     {
+    //       /* When there is no other possibilities, we try one in the back-up queues, and go back to the stricter state */
+    //       first_round = true;
+    //     }
+    //   }
+    //   else if ( kitty::count_ones( new_node.function & parent_node.care ) == kitty::count_ones( original_function & parent_node.care ) && new_node.function != original_function )
+    //   {
+    //     if ( first_round )
+    //     {
+    //       /* We put it into a back-up queue for now */
+    //       shuffle.emplace_back( node_position );
+    //       return false;
+    //     }
+    //     else
+    //     {
+    //       /* When there is no other possibilities, we try one in the back-up queues, and go back to the stricter state */
+    //       first_round = true;
+    //     }
+    //   }
+    //   else
+    //   {
+    //     return false;
+    //   }
+    // }
+
+    /* construct the new node */
+    uint32_t const new_id = maj_nodes.size() + divisors.size();
+    maj_nodes.emplace_back( maj_node{ new_id, new_node.fanins, { divisors.at( new_node.fanins[0] ), divisors.at( new_node.fanins[1] ), divisors.at( new_node.fanins[2] ) }, care, node_position } );
+    update_fanin( parent_node, fi, new_id, new_node.function );
+
+    if ( kitty::is_const0( ~new_node.function & care ) )
+    {
+      if ( node_fulfilled( maj_nodes.at( 0u ) ) )
+      {
+        return true;
+      }
+      // TODO: add all the fulfilled nodes (trace upwards) to the divisor list, determining their indices in topological order
+      // This also has to be taken care of in the different runs.
+    }
+    else
+    {
+      leaves.emplace_back( expansion_position{ int32_t( maj_nodes.size() - 1 ), 0 } );
+      leaves.emplace_back( expansion_position{ int32_t( maj_nodes.size() - 1 ), 1 } );
+      leaves.emplace_back( expansion_position{ int32_t( maj_nodes.size() - 1 ), 2 } );
+    }
+    return false;
+  }
+
+  simple_maj expand_one( TT const& care )
+  {
+    /* look up in computed_table */
+    auto computed = computed_table.find( care );
+    if ( computed != computed_table.end() )
+    {
+      // std::cout<<"cache hit!\n";
+      return computed->second;
+    }
+
+    /* the first fanin: cover most care bits */
+    uint64_t max_score = 0u;
+    uint32_t max_i = 0u;
+    for ( auto i = 0u; i < divisors.size(); ++i )
+    {
+      scores.at( i ) = kitty::count_ones( divisors.at( i ) & care );
+      if ( scores.at( i ) > max_score )
+      {
+        max_score = scores.at( i );
+        max_i = i;
+      }
+    }
+
+    /* the second fanin: 2 * #newly-covered-bits + 1 * #cover-again-bits */
+    max_score = 0u;
+    uint32_t max_j = 0u;
+    auto const not_covered_by_i = ~divisors.at( max_i );
+    for ( auto j = 0u; j < divisors.size(); ++j )
+    {
+      auto const covered_by_j = divisors.at( j ) & care;
+      scores.at( j ) = kitty::count_ones( covered_by_j ) + kitty::count_ones( not_covered_by_i & covered_by_j );
+      if ( scores.at( j ) > max_score && !same_divisor( j, max_i ) )
+      {
+        max_score = scores.at( j );
+        max_j = j;
+      }
+    }
+
+    /* the third fanin: 2 * #cover-never-covered-bits + 1 * #cover-covered-once-bits */
+    max_score = 0u;
+    uint32_t max_k = 0u;
+    auto const not_covered_by_j = ~divisors.at( max_j );
+    for ( auto k = 0u; k < divisors.size(); ++k )
+    {
+      auto const covered_by_k = divisors.at( k ) & care;
+      scores.at( k ) = kitty::count_ones( covered_by_k & not_covered_by_i ) + kitty::count_ones( covered_by_k & not_covered_by_j );
+      if ( scores.at( k ) > max_score && !same_divisor( k, max_i ) && !same_divisor( k, max_j ) )
+      {
+        max_score = scores.at( k );
+        max_k = k;
+      }
+    }
+
+    computed_table[care] = simple_maj( { { max_i, max_j, max_k }, kitty::ternary_majority( divisors.at( max_i ), divisors.at( max_j ), divisors.at( max_k ) ) } );
+    return computed_table[care];
+  }
+
+  std::vector<simple_maj> construct_top( TT const& care )
+  {
+    std::vector<simple_maj> res;
+
+    /* the first fanin: cover most bits */
+    uint64_t max_score = 0u;
+    for ( auto i = 0u; i < divisors.size(); ++i )
+    {
+      scores.at( i ) = kitty::count_ones( divisors.at( i ) & care );
+      if ( scores.at( i ) > max_score )
+      {
+        max_score = scores.at( i );
+      }
+    }
+    for ( auto i = 0u; i < divisors.size(); ++i )
+    {
+      if ( scores.at( i ) == max_score )
+      {
+        if ( construct_top( care, i, res ) )
+        {
+          break;
+        }
+      }
+    }
+    return res;
+  }
+
+  bool construct_top( TT const& care, uint32_t max_i, std::vector<simple_maj>& res )
+  {
+    /* the second fanin: 2 * #newly-covered-bits + 1 * #cover-again-bits */
+    uint64_t max_score = 0u;
+    auto const not_covered_by_i = ~divisors.at( max_i );
+    for ( auto j = 0u; j < divisors.size(); ++j )
+    {
+      auto const covered_by_j = divisors.at( j ) & care;
+      scores.at( j ) = kitty::count_ones( covered_by_j ) + kitty::count_ones( not_covered_by_i & covered_by_j );
+      if ( scores.at( j ) > max_score && !same_divisor( j, max_i ) )
+      {
+        max_score = scores.at( j );
+      }
+    }
+    for ( auto j = 0u; j < divisors.size(); ++j )
+    {
+      if ( scores.at( j ) == max_score && !same_divisor( j, max_i ) )
+      {
+        if ( construct_top( care, max_i, j, res ) )
+        {
+          break;
+        }
+      }
+    }
+    return false;
+  }
+
+  bool construct_top( TT const& care, uint32_t max_i, uint32_t max_j, std::vector<simple_maj>& res )
+  {
+    /* the third fanin: 2 * #cover-never-covered-bits + 1 * #cover-covered-once-bits */
+    uint64_t max_score = 0u;
+    auto const not_covered_by_i = ~divisors.at( max_i );
+    auto const not_covered_by_j = ~divisors.at( max_j );
+    for ( auto k = 0u; k < divisors.size(); ++k )
+    {
+      auto const covered_by_k = divisors.at( k ) & care;
+      scores.at( k ) = kitty::count_ones( covered_by_k & not_covered_by_i ) + kitty::count_ones( covered_by_k & not_covered_by_j );
+      if ( scores.at( k ) > max_score && !same_divisor( k, max_i ) && !same_divisor( k, max_j ) )
+      {
+        max_score = scores.at( k );
+      }
+    }
+
+    for ( auto k = 0u; k < divisors.size(); ++k )
+    {
+      if ( scores.at( k ) == max_score && !same_divisor( k, max_i ) && !same_divisor( k, max_j ) )
+      {
+        TT const func = kitty::ternary_majority( divisors.at( max_i ), divisors.at( max_j ), divisors.at( k ) );
+        if ( kitty::is_const0( ~func & care ) )
+        {
+          res.clear();
+          res.emplace_back( simple_maj( { { max_i, max_j, k }, func } ) );
+          return true;
+        }
+        res.emplace_back( simple_maj( { { max_i, max_j, k }, func } ) );
+      }
+    }
+    return false;
+  }
+
+  /* try to replace the first (fi=0) or the second (fi=1) fanin with another divisor to improve coverage */
+  // bool easy_refine( simple_maj& n, TT const& care, uint32_t fi )
+  //{
+  //   uint64_t const original_coverage = kitty::count_ones( n.function & care );
+  //   uint64_t current_coverage = original_coverage;
+  //   auto const& tt1 = divisors.at( n.fanins[fi ? 0 : 1] );
+  //   auto const& tt2 = divisors.at( n.fanins[fi < 2 ? 2 : 1] );
+  //   for ( auto i = 0u; i < divisors.size(); ++i )
+  //   {
+  //     if ( same_divisor( i, n.fanins[0] ) || same_divisor( i, n.fanins[1] ) || same_divisor( i, n.fanins[2] ) )
+  //     {
+  //       continue;
+  //     }
+  //     auto const& tti = divisors.at( i );
+  //     uint64_t coverage = kitty::count_ones( kitty::ternary_majority( tti, tt1, tt2 ) & care );
+  //     if ( coverage > current_coverage )
+  //     {
+  //       current_coverage = coverage;
+  //       n.fanins[fi] = i;
+  //     }
+  //   }
+  //   if ( current_coverage > original_coverage )
+  //   {
+  //     n.function = kitty::ternary_majority( divisors.at( n.fanins[0] ), divisors.at( n.fanins[1] ), divisors.at( n.fanins[2] ) );
+  //     if ( current_coverage == num_bits )
+  //     {
+  //       return true;
+  //     }
+  //   }
+  //   return false;
+  // }
+
+  mig_index_list translate( std::vector<maj_node> const& maj_nodes_best ) const
+  {
+    mig_index_list index_list( divisors.size() / 2 - 1 );
+    std::unordered_map<uint32_t, uint32_t> id_map;
+    for ( auto i = 0u; i < maj_nodes_best.size(); ++i )
+    {
+      auto& n = maj_nodes_best.at( maj_nodes_best.size() - i - 1u );
+      uint32_t lits[3];
+      for ( auto j = 0u; j < 3u; ++j )
+      {
+        if ( n.fanins[j] < divisors.size() )
+        {
+          lits[j] = n.fanins[j];
+        }
+        else
+        {
+          auto mapped = id_map.find( n.fanins[j] );
+          assert( mapped != id_map.end() );
+          lits[j] = mapped->second;
+        }
+      }
+      id_map[n.id] = divisors.size() + i * 2;
+      index_list.add_maj( lits[0], lits[1], lits[2] );
+    }
+    index_list.add_output( ( id_map.find( maj_nodes_best.at( 0u ).id ) )->second );
+    return index_list;
+  }
+
+private:
+  bool same_divisor( uint32_t const i, uint32_t const j )
+  {
+    return ( i >> 1 ) == ( j >> 1 );
+  }
+
+  bool fulfilled( TT const& func, TT const& care )
+  {
+    return kitty::is_const0( ~func & care );
+  }
+
+  bool node_fulfilled( maj_node const& node )
+  {
+    return fulfilled( kitty::ternary_majority( node.fanin_functions.at( 0u ), node.fanin_functions.at( 1u ), node.fanin_functions.at( 2u ) ), node.care );
+  }
+
+  uint64_t score( TT const& func, TT const& care )
+  {
+    return kitty::count_ones( func & care );
+  }
+
+  void update_fanin( maj_node& parent_node, uint32_t const fi, uint32_t const new_id, TT const& new_function )
+  {
+    parent_node.fanins.at( fi ) = new_id;
+    TT const old_function = parent_node.fanin_functions.at( fi );
+    parent_node.fanin_functions.at( fi ) = new_function;
+
+    TT const& sibling_func1 = sibling_func( parent_node, fi, 1 );
+    TT const& sibling_func2 = sibling_func( parent_node, fi, 2 );
+
+    update_sibling( parent_node, fi, 1, old_function, new_function, sibling_func1, sibling_func2 );
+    update_sibling( parent_node, fi, 2, old_function, new_function, sibling_func2, sibling_func1 );
+
+    /* update grandparents */
+    if ( parent_node.parent.parent_position != -1 ) /* not the topmost node */
+    {
+      update_fanin( grandparent( parent_node ), parent_node.parent.fanin_num, parent_node.id, kitty::ternary_majority( new_function, sibling_func1, sibling_func2 ) );
+    }
+  }
+
+  /* Deal with the affects on siblings due to a change in one fanin function
+   * \param parent_node The node one of whose fanin functions is changed.
+   * \param fi The index of the changed fanin. (0 <= fi <= 2)
+   * \param sibling_num Which sibling we are updating. (1 or 2)
+   * \param old_function The original function of the changed fanin.
+   * \param new_function The new function of the changed fanin.
+   * \param sibling_func The function of the sibling being updated.
+   * \param other_sibling_func The function of the other sibling.
+   */
+  void update_sibling( maj_node const& parent_node, uint32_t const fi, uint32_t const sibling_num, TT const& old_function, TT const& new_function, TT const& sibling_func, TT const& other_sibling_func )
+  {
+    uint32_t index = sibling_index( fi, sibling_num );
+    uint32_t id = parent_node.fanins.at( index );
+    TT const old_care = care( parent_node.care, old_function, other_sibling_func );
+    TT const new_care = care( parent_node.care, new_function, other_sibling_func );
+
+    if ( old_care != new_care )
+    {
+      /* update care of the sibling (if it is not a divisor) */
+      if ( id >= divisors.size() )
+      {
+        update_node_care( id_to_node( id ), sibling_func, old_care, new_care );
+      }
+      else /* add the position back to queue because there may be new opportunities */
+      {
+        add_position( expansion_position( { int32_t( id_to_pos( parent_node.id ) ), int32_t( index ) } ) );
+      }
+    }
+  }
+
+  void update_node_care( maj_node& node, TT const& func, TT const& old_care, TT const& new_care )
+  {
+    assert( node.care == old_care );
+    /* check if it was fulfilled but becomes unfulfilled */
+    if ( fulfilled( func, old_care ) && !fulfilled( func, new_care ) )
+    {
+      /* add the fanin positions back to queue */
+      for ( auto fi = 0; fi < 3; ++fi )
+      {
+        if ( node.fanins.at( fi ) < divisors.size() )
+        {
+          add_position( expansion_position( { int32_t( id_to_pos( node.id ) ), int32_t( fi ) } ) );
+        }
+      }
+    }
+    node.care = new_care;
+
+    /* the update may propagate to its children */
+    for ( auto fi = 0; fi < 3; ++fi )
+    {
+      if ( node.fanins.at( fi ) >= divisors.size() )
+      {
+        TT const old_child_care = care( old_care, sibling_func( node, fi, 1 ), sibling_func( node, fi, 2 ) );
+        TT const new_child_care = care( new_care, sibling_func( node, fi, 1 ), sibling_func( node, fi, 2 ) );
+        if ( old_child_care != new_child_care )
+        {
+          update_node_care( id_to_node( node.fanins.at( fi ) ), node.fanin_functions.at( fi ), old_child_care, new_child_care );
+        }
+      }
+    }
+  }
+
+  void add_position( expansion_position const& pos )
+  {
+    for ( auto& l : leaves )
+    {
+      if ( l == pos )
+      {
+        return;
+      }
+    }
+    leaves.emplace_back( pos );
+  }
+
+  TT care( TT const& parent_care, TT const& sibling_func1, TT const& sibling_func2 )
+  {
+    return parent_care & ~( sibling_func1 & sibling_func2 );
+  }
+
+  inline maj_node& grandparent( maj_node const& parent_node )
+  {
+    return maj_nodes.at( parent_node.parent.parent_position );
+  }
+
+  inline uint32_t sibling_index( uint32_t const my_index, uint32_t const sibling_num )
+  {
+    return ( my_index + sibling_num ) % 3;
+  }
+
+  inline TT const& sibling_func( maj_node const& parent_node, uint32_t const my_index, uint32_t const sibling_num )
+  {
+    return parent_node.fanin_functions.at( sibling_index( my_index, sibling_num ) );
+  }
+
+  inline uint32_t id_to_pos( uint32_t const id )
+  {
+    assert( id >= divisors.size() );
+    return ( id - divisors.size() );
+  }
+
+  inline maj_node& id_to_node( uint32_t const id )
+  {
+    return maj_nodes.at( id_to_pos( id ) );
+  }
+
+private:
+  uint32_t size_limit;
+  uint32_t num_bits;
+
+  std::vector<TT> divisors;
+  std::vector<uint64_t> scores;
+  std::vector<maj_node> maj_nodes;                                    /* the really used nodes */
+  std::unordered_map<TT, simple_maj, kitty::hash<TT>> computed_table; /* map from care to a simple_maj with divisors as fanins */
+
+  std::vector<expansion_position> leaves; //, improve_in_parent, shuffle;
+  // bool first_round = true;
+
+  stats& st;
+}; /* mig_resyn_topdown */
+
+/*! \brief Logic resynthesis engine for MIGs by Akers' majority synthesis algorithm.
+ *
+ * This engine is a re-implementation of Akers' algorithm based on the following paper:
+ *
+ * Akers, S. B. (1962, October). Synthesis of combinational logic using
+ * three-input majority gates. In 3rd Annual Symposium on Switching Circuit Theory
+ * and Logical Design (SWCT 1962) (pp. 149-158). IEEE.
+ *
+ */
+template<class static_params = mig_resyn_static_params>
+class mig_resyn_akers
+{
+public:
+  using stats = mig_resyn_stats;
+  using index_list_t = mig_index_list;
+  using TT = kitty::partial_truth_table;
+  using truth_table_t = TT;
+
+  explicit mig_resyn_akers( stats& st )
+      : id_to_lit( { 0, 1 } ), st( st )
+  {
+    static_assert( std::is_same_v<typename static_params::base_type, mig_resyn_static_params>, "Invalid static_params type" );
+    static_assert( !static_params::preserve_depth && static_params::uniform_div_cost, "Advanced resynthesis is not implemented for this solver" );
+    divisors.reserve( static_params::reserve );
+  }
+
+  template<class iterator_type, class truth_table_storage_type>
+  std::optional<index_list_t> operator()( TT const& target, TT const& care, iterator_type begin, iterator_type end, truth_table_storage_type const& tts, uint32_t max_size = std::numeric_limits<uint32_t>::max(), uint32_t max_level = std::numeric_limits<uint32_t>::max() )
+  {
+    (void)care;
+    (void)max_level;
+
+    divisors.clear();
+    id_to_lit.resize( 2 );
+    index_list.clear();
+
+    divisors.emplace_back( ~target );
+    divisors.emplace_back( target );
+
+    while ( begin != end )
+    {
+      auto const& tt = tts[*begin];
+      assert( tt.num_bits() == divisors[0].num_bits() );
+      id_to_lit.emplace_back( divisors.size() );
+      divisors.emplace_back( tt ^ divisors[0] );
+      id_to_lit.emplace_back( divisors.size() );
+      divisors.emplace_back( tt ^ target );
+      index_list.add_inputs();
+      ++begin;
+    }
+
+    return compute_function( max_size );
+  }
+
+private:
+  std::optional<index_list_t> compute_function( uint32_t num_inserts )
+  {
+    (void)st;
+    if ( !is_feasible() )
+    {
+      return std::nullopt;
+    }
+
+    /* search for 0-resub (including constants) */
+    for ( auto i = 0u; i < divisors.size(); ++i )
+    {
+      if ( kitty::is_const0( ~divisors[i] ) )
+      {
+        index_list.add_output( id_to_lit[i] );
+        return index_list;
+      }
+    }
+
+    reduce();
+
+    while ( divisors.size() > 1 )
+    {
+      if ( index_list.num_gates() >= num_inserts )
+      {
+        return std::nullopt;
+      }
+      find_gate();
+      add_gate();
+      if ( kitty::is_const0( ~divisors.back() ) )
+      {
+        break;
+      }
+      reduce();
+    }
+
+    index_list.add_output( id_to_lit.back() );
+    return index_list;
+  }
+
+  void reduce()
+  {
+    uint32_t num_bits_before = 0u;
+    uint32_t num_divs_before = 0u;
+    while ( num_bits_before != divisors[0].num_bits() || num_divs_before != divisors.size() )
+    {
+      num_bits_before = divisors[0].num_bits();
+      num_divs_before = divisors.size();
+      eliminate_divs(); /* reduce column */
+      eliminate_bits(); /* reduce row */
+    }
+  }
+
+  void eliminate_divs()
+  {
+    for ( int32_t x = 0; x < (int32_t)divisors.size(); ++x ) /* try to remove divisors[x] */
+    {
+      if ( is_feasible( x ) )
+      {
+        divisors.erase( divisors.begin() + x );
+        id_to_lit.erase( id_to_lit.begin() + x );
+        --x;
+      }
+    }
+  }
+
+  void eliminate_bits()
+  {
+    /* for each pair of bits, check if we can remove i or j */
+    for ( int32_t i = 0; i < (int32_t)divisors[0].num_bits() - 1; ++i )
+    {
+      for ( int32_t j = i + 1; j < (int32_t)divisors[0].num_bits(); ++j )
+      {
+        bool can_remove_i = true, can_remove_j = true;
+        for ( auto x = 0u; x < divisors.size(); ++x )
+        {
+          if ( !kitty::get_bit( divisors[x], i ) && kitty::get_bit( divisors[x], j ) )
+          {
+            can_remove_i = false;
+          }
+          if ( kitty::get_bit( divisors[x], i ) && !kitty::get_bit( divisors[x], j ) )
+          {
+            can_remove_j = false;
+          }
+          if ( !can_remove_i && !can_remove_j )
+          {
+            break;
+          }
+        }
+
+        if ( can_remove_i )
+        {
+          for ( auto& d : divisors )
+          {
+            d.erase_bit_swap( i );
+          }
+          --i;
+          break; /* break loop j */
+        }
+        else if ( can_remove_j )
+        {
+          for ( auto& d : divisors )
+          {
+            d.erase_bit_swap( j );
+          }
+          --j;
+        }
+      }
+    }
+  }
+
+  void find_gate()
+  {
+    /* 1. Try if there are some gates that can eliminate some columns */
+    uint32_t best_num_eliminates = 0u;
+    /* for each column, find candidate gates that eliminates it */
+    for ( auto i = 0u; i < divisors.size(); ++i )
+    {
+      find_gate_to_eliminate( i, best_num_eliminates );
+      if ( best_num_eliminates == 3 )
+      {
+        /* cannot be better */
+        break;
+      }
+    }
+    if ( best_num_eliminates > 0 )
+    {
+      return;
+    }
+
+    /* 2. No gate can eliminate any column. Choose a gate that misses the least essentials */
+    uint32_t least_missed_essentials = divisors[0].num_bits() + 1;
+    /* for all possible gates (input combinations) */
+    assert( divisors.size() >= 3 );
+    for ( auto i = 0u; i < divisors.size() - 2; ++i )
+    {
+      for ( auto j = i + 1; j < divisors.size() - 1; ++j )
+      {
+        for ( auto k = j + 1; k < divisors.size(); ++k )
+        {
+          kitty::partial_truth_table const gate_function = kitty::ternary_majority( divisors[i], divisors[j], divisors[k] );
+          uint32_t missed_essentials = 0u;
+          /* for each bit */
+          for ( auto b = 0u; b < gate_function.num_bits(); ++b )
+          {
+            if ( kitty::get_bit( gate_function, b ) )
+              continue;
+            if ( is_essential( i, b ) )
+            {
+              ++missed_essentials;
+            }
+            else if ( is_essential( j, b ) )
+            {
+              ++missed_essentials;
+            }
+            else if ( is_essential( k, b ) )
+            {
+              ++missed_essentials;
+            }
+          }
+
+          if ( missed_essentials < least_missed_essentials )
+          {
+            fanins[0] = i;
+            fanins[1] = j;
+            fanins[2] = k;
+            least_missed_essentials = missed_essentials;
+          }
+        }
+      }
+    }
+  }
+
+  void find_gate_to_eliminate( uint32_t column, uint32_t& best_num_eliminates )
+  {
+    std::vector<std::vector<uint32_t>> candidates;
+    /* for each of its essential bits */
+    for ( auto b = 0u; b < divisors[0].num_bits(); ++b )
+    {
+      if ( !is_essential( column, b ) )
+        continue;
+      candidates.emplace_back();
+      for ( auto j = 0u; j < divisors.size(); ++j )
+      {
+        if ( column != j && kitty::get_bit( divisors[j], b ) )
+        {
+          candidates.back().emplace_back( j );
+        }
+      }
+      if ( candidates.back().size() == 0u )
+      {
+        /* impossible to eliminate this column */
+        return;
+      }
+    }
+
+    assert( candidates.size() >= 2 ); // why must be? but what if not?
+    /* try all combinations of size 2 */
+    for ( auto const& j : candidates[0] )
+    {
+      for ( auto const& k : candidates[1] )
+      {
+        if ( j == k )
+          continue;
+        /* check if either j or k appears in all other sets */
+        bool all_satisfied = true;
+        for ( auto s = 2u; s < candidates.size(); ++s )
+        {
+          bool is_in_set = false;
+          for ( auto const& ele : candidates[s] )
+          {
+            if ( ele == j || ele == k )
+            {
+              is_in_set = true;
+              break;
+            }
+          }
+          if ( !is_in_set )
+          {
+            all_satisfied = false;
+            break;
+          }
+        }
+        if ( all_satisfied )
+        {
+          /* this gate <column, j, k> eliminates column */
+          uint32_t num_eliminates = 1u;
+          /* see if it also eliminates j and/or k */
+          kitty::partial_truth_table const gate_function = kitty::ternary_majority( divisors[column], divisors[j], divisors[k] );
+          if ( eliminates( gate_function, j ) )
+          {
+            ++num_eliminates;
+          }
+          if ( eliminates( gate_function, k ) )
+          {
+            ++num_eliminates;
+          }
+          if ( num_eliminates > best_num_eliminates )
+          {
+            fanins[0] = column;
+            fanins[1] = j;
+            fanins[2] = k;
+            best_num_eliminates = num_eliminates;
+            if ( num_eliminates == 3 )
+            {
+              /* cannot be better */
+              return;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  void add_gate()
+  {
+    index_list.add_maj( id_to_lit[fanins[0]], id_to_lit[fanins[1]], id_to_lit[fanins[2]] );
+    id_to_lit.emplace_back( ( index_list.num_pis() + index_list.num_gates() ) * 2 );
+    divisors.emplace_back( kitty::ternary_majority( divisors[fanins[0]], divisors[fanins[1]], divisors[fanins[2]] ) );
+  }
+
+private:
+  /* whether the table is feasible (lpsd) if divisors[x] is deleted */
+  bool is_feasible( int32_t x = -1 ) const
+  {
+    if ( divisors.size() == 1 && x == 0 )
+    {
+      /* x is the only remaining column */
+      return false;
+    }
+
+    /* for every pair of rows _bits[i], _bits[j] */
+    for ( auto i = 0u; i < divisors[0].num_bits() - 1; ++i )
+    {
+      for ( auto j = i + 1; j < divisors[0].num_bits(); ++j )
+      {
+        /* check if there is another divisors[y] having both bits 1 */
+        bool found = false;
+        for ( int32_t y = 0; y < (int32_t)divisors.size(); ++y )
+        {
+          if ( y == x )
+            continue;
+          if ( kitty::get_bit( divisors[y], i ) && kitty::get_bit( divisors[y], j ) )
+          {
+            found = true;
+            break;
+          }
+        }
+        if ( !found )
+        {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  /* whether divisors[x]._bits[i] is essential */
+  bool is_essential( uint32_t x, uint32_t i ) const
+  {
+    if ( !kitty::get_bit( divisors[x], i ) )
+    {
+      return false;
+    }
+
+    kitty::partial_truth_table tt( divisors[0].num_bits() );
+    for ( auto y = 0u; y < divisors.size(); ++y )
+    {
+      if ( x == y )
+        continue;
+      if ( !kitty::get_bit( divisors[y], i ) )
+        continue;
+      tt |= divisors[y];
+    }
+
+    return !kitty::is_const0( ~tt );
+  }
+
+  /* whether the gate eliminates a given column */
+  bool eliminates( kitty::partial_truth_table const& gate_function, uint32_t column ) const
+  {
+    /* for each of its essential bits */
+    for ( auto b = 0u; b < gate_function.num_bits(); ++b )
+    {
+      if ( !kitty::get_bit( gate_function, b ) && is_essential( column, b ) )
+      {
+        return false;
+      }
+    }
+    return true;
+  }
+
+private:
+  void print_table() const
+  {
+    for ( auto i = 0u; i < divisors.size(); ++i )
+    {
+      std::cout << "[" << std::setw( 2 ) << id_to_lit[i] << "] ";
+      kitty::print_binary( divisors[i] );
+      std::cout << "\n";
+    }
+  }
+
+private:
+  std::vector<kitty::partial_truth_table> divisors;
+  std::vector<uint32_t> id_to_lit;
+  index_list_t index_list;
+  uint32_t fanins[3];
+
+  stats& st;
+}; /* mig_resyn_akers */
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/resyn_engines/mux_resyn.hpp b/include/mockturtle/algorithms/resyn_engines/mux_resyn.hpp
new file mode 100644
index 0000000..1bc55dc
--- /dev/null
+++ b/include/mockturtle/algorithms/resyn_engines/mux_resyn.hpp
@@ -0,0 +1,274 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+
+A B Y
+0 0 1
+0 1 1
+1 0 1
+1 1 0
+
+A B Y
+0 0 0
+0 1 
+
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mux_resyn.hpp
+  \brief Implements resynthesis methods for MuxIGs.
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../../utils/index_list.hpp"
+#include "../../utils/null_utils.hpp"
+
+#include <fmt/format.h>
+#include <fstream>
+#include <iostream>
+#include <kitty/kitty.hpp>
+
+#include <kitty/print.hpp>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+namespace mockturtle
+{
+
+/*! \brief Logic resynthesis engine for MuxIGs with top-down decomposition.
+ *
+ */
+template<class TT>
+class mux_resyn
+{
+public:
+  using stats = null_stats;
+  using index_list_t = muxig_index_list;
+  using truth_table_t = TT;
+
+public:
+  explicit mux_resyn( stats& st )
+      : st( st )
+  {
+  }
+
+  template<class iterator_type, class truth_table_storage_type>
+  std::optional<index_list_t> operator()( TT const& target, TT const& care, iterator_type begin, iterator_type end, truth_table_storage_type const& tts, uint32_t max_size = std::numeric_limits<uint32_t>::max() )
+  {
+    divisors.clear();
+    normalized.clear(); 
+
+    normalized.emplace_back( ~target ); // 0 XNOR target = ~target
+    normalized.emplace_back( target );  // 1 XNOR target = target
+
+    while ( begin != end )
+    {
+      auto const& tt = tts[*begin];
+      assert( tt.num_bits() == target.num_bits() );
+      normalized.emplace_back( tt ^ normalized[0] ); // tt XNOR target = tt XOR ~target
+      normalized.emplace_back( tt ^ target );        // ~tt XNOR target = tt XOR target
+      divisors.emplace_back( tt );
+      ++begin;
+    }
+
+    num_bits = kitty::count_ones( care );
+    remaining_size = max_size;
+    max_depth = std::min( 10u, max_size );
+    index_list.clear();
+    index_list.add_inputs( divisors.size() );
+
+    auto res = compute_function( care, 0 );
+    if ( res )
+    {
+      index_list.add_output( *res );
+      return index_list;
+    }
+    else
+    {
+      return std::nullopt;
+    }
+  }
+
+private:
+  std::optional<index_list_t::element_type> compute_function( TT const& care, uint32_t depth )
+  {
+    if ( depth > max_depth )
+      return std::nullopt;
+
+    /*
+    std::cout << "In computation function with depth: " << depth << " and care: ";
+    kitty::print_binary(care);
+    std::cout << "\n";
+    */
+    uint32_t chosen_t{0}, chosen_s{0}, chosen_e{0}, score1{0}, score2{0}, max_score{0}, min_score1{num_bits}, min_score2{num_bits};
+    for ( auto t = 0u; t < normalized.size(); ++t )
+    {
+      score1 = kitty::count_ones( normalized.at( t ) & care );
+      if ( score1 > max_score )
+      {
+        max_score = score1;
+        chosen_t = t;
+        if ( score1 == num_bits )
+        {
+          /* 0-resub */
+          return t;
+        }
+      }
+    }
+
+    if ( remaining_size == 0 )
+      return std::nullopt;
+
+    TT uncovered = ~normalized.at( chosen_t ) & care;
+
+    /*std::cout << "Chose T: " << chosen_t << " with uncovered: ";
+    kitty::print_binary(uncovered);
+    std::cout << "\n";
+    */
+    for ( auto s = 0u; s < divisors.size(); ++s )
+    {
+      TT& tt_s = divisors.at( s );
+      TT tt_not_s = ~divisors.at( s );
+
+      // try positive s
+      score1 = kitty::count_ones( uncovered & tt_s );
+      if ( score1 < min_score1 )
+      {
+        min_score1 = score1;
+        chosen_s = s * 2;
+        min_score2 = num_bits;
+      }
+      if ( score1 == min_score1 )
+      {
+        score2 = kitty::count_ones( tt_not_s & care );
+        if ( score2 < min_score2 )
+        {
+          min_score2 = score2;
+          chosen_s = s * 2;
+        }
+      }
+
+      // try negative s
+      score1 = kitty::count_ones( uncovered & tt_not_s );
+      if ( score1 < min_score1 )
+      {
+        min_score1 = score1;
+        chosen_s = s * 2 + 1;
+        min_score2 = num_bits;
+      }
+      if ( score1 == min_score1 )
+      {
+        score2 = kitty::count_ones( tt_s & care );
+        if ( score2 < min_score2 )
+        {
+          min_score2 = score2;
+          chosen_s = s * 2 + 1;
+        }
+      }
+    }
+
+    /*if (chosen_s % 2 == 1){
+      printf("inverted select\n");
+    }*/
+    TT tt_chosen_s = chosen_s % 2 ? ~divisors.at( chosen_s / 2 ) : divisors.at( chosen_s / 2 );
+
+
+
+    if ( min_score2 != 0 )
+    {
+      TT to_cover = care & ~tt_chosen_s;
+      
+      /*std::cout << "Chose S: " << chosen_s /2 << " complemented: "<< chosen_s%2 <<" with uncovered: ";
+      kitty::print_binary(to_cover);
+      std::cout << "\n";
+      */
+
+      max_score = 0;
+      for ( auto e = 0u; e < normalized.size(); ++e )
+      {
+        score1 = kitty::count_ones( normalized.at( e ) & to_cover );
+        if ( score1 > max_score )
+        {
+          max_score = score1;
+          chosen_e = e;
+          if ( max_score == min_score2 ) // best e-child
+            break;
+        }
+      }
+    }
+
+    if ( min_score1 != 0 ) /* expand on t-child */
+    {
+      TT t_care = care & tt_chosen_s;
+
+      /*
+      std::cout << "Chose S: " << chosen_s /2 << " complemented: "<< chosen_s%2 <<" with uncovered: ";
+      kitty::print_binary(t_care);
+      std::cout << "\n";
+      */
+
+      auto res = compute_function( t_care, depth + 1 );
+      if ( res && remaining_size > 0 )
+        chosen_t = *res;
+      else
+        return std::nullopt;
+    }
+
+    if ( max_score != min_score2 ) /* expand on e-child */
+    {
+      TT e_care = care & ~tt_chosen_s;
+
+      /*std::cout << "Chose S: " << chosen_s /2 << " complemented: "<< chosen_s%2 <<" with uncovered: ";
+      kitty::print_binary(e_care);
+      std::cout << "\n";
+      */
+      auto res = compute_function( e_care, depth + 1 );
+      if ( res && remaining_size > 0 )
+        chosen_e = *res;
+      else
+        return std::nullopt;
+    }
+
+    assert( remaining_size >= 1 );
+    --remaining_size;
+    return index_list.add_mux( chosen_s + 2, chosen_t, chosen_e );
+  }
+
+private:
+  uint32_t num_bits;
+  uint32_t remaining_size;
+  uint32_t max_depth;
+
+  std::vector<TT> divisors;
+  std::vector<TT> normalized;
+
+  muxig_index_list index_list;
+
+  stats& st;
+}; /* mux_resyn */
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/resyn_engines/mux_resyn_select_opt.hpp b/include/mockturtle/algorithms/resyn_engines/mux_resyn_select_opt.hpp
new file mode 100644
index 0000000..019e815
--- /dev/null
+++ b/include/mockturtle/algorithms/resyn_engines/mux_resyn_select_opt.hpp
@@ -0,0 +1,268 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mux_resyn.hpp
+  \brief Implements resynthesis methods for MuxIGs.
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../../utils/index_list.hpp"
+#include "../../utils/null_utils.hpp"
+
+#include <fmt/format.h>
+#include <iostream>
+#include <kitty/kitty.hpp>
+
+#include <kitty/print.hpp>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+namespace mockturtle
+{
+
+/*! \brief Logic resynthesis engine for MuxIGs with top-down decomposition.
+ *
+ */
+template<class TT>
+class mux_resyn_select_opt
+{
+public:
+  using stats = null_stats;
+  using index_list_t = muxig_index_list;
+  using truth_table_t = TT;
+
+public:
+  explicit mux_resyn_select_opt( stats& st )
+      : st( st )
+  {
+  }
+
+  template<class iterator_type, class truth_table_storage_type>
+  std::optional<index_list_t> operator()( TT const& target, TT const& care, iterator_type begin, iterator_type end, truth_table_storage_type const& tts, uint32_t max_size = std::numeric_limits<uint32_t>::max() )
+  {
+    divisors.clear();
+    normalized.clear(); 
+
+    normalized.emplace_back( ~target ); // 0 XNOR target = ~target
+    normalized.emplace_back( target );  // 1 XNOR target = target
+
+    while ( begin != end )
+    {
+      auto const& tt = tts[*begin];
+      assert( tt.num_bits() == target.num_bits() );
+      normalized.emplace_back( tt ^ normalized[0] ); // tt XNOR target = tt XOR ~target
+      normalized.emplace_back( tt ^ target );        // ~tt XNOR target = tt XOR target
+      divisors.emplace_back( tt );
+      ++begin;
+    }
+
+    num_bits = kitty::count_ones( care );
+    remaining_size = max_size;
+    max_depth = std::min( 10u, max_size );
+    index_list.clear();
+    index_list.add_inputs( divisors.size() );
+
+    auto res = compute_function( care, 0 );
+    if ( res )
+    {
+      index_list.add_output( *res );
+      return index_list;
+    }
+    else
+    {
+      return std::nullopt;
+    }
+  }
+
+private:
+  std::optional<index_list_t::element_type> compute_function( TT const& care, uint32_t depth )
+  {
+    if ( depth > max_depth )
+      return std::nullopt;
+
+    /*
+    std::cout << "In computation function with depth: " << depth << " and care: ";
+    kitty::print_binary(care);
+    std::cout << "\n";
+    */
+    uint32_t chosen_t{0}, chosen_s{0}, chosen_e{0}, score1{0}, score2{0}, max_score{0}, min_score1{num_bits}, min_score2{num_bits};
+    for ( auto t = 0u; t < normalized.size(); ++t )
+    {
+      score1 = kitty::count_ones( normalized.at( t ) & care );
+      if ( score1 > max_score )
+      {
+        max_score = score1;
+        chosen_t = t;
+        if ( score1 == num_bits )
+        {
+          /* 0-resub */
+          return t;
+        }
+      }
+    }
+
+    if ( remaining_size == 0 )
+      return std::nullopt;
+
+    TT uncovered = ~normalized.at( chosen_t ) & care;
+
+    //std::cout << "Chose T: " << chosen_t << " with uncovered: ";
+    //kitty::print_binary(uncovered);
+    //std::cout << "\n";
+    
+    for ( auto s = 0u; s < divisors.size(); ++s )
+    {
+      TT& tt_s = divisors.at( s );
+      TT tt_not_s = ~divisors.at( s );
+
+      // try positive s
+      score1 = kitty::count_ones( uncovered & tt_s );
+      if ( score1 < min_score1 )
+      {
+        min_score1 = score1;
+        chosen_s = s * 2;
+        min_score2 = num_bits;
+      }
+      if ( score1 == min_score1 )
+      {
+        score2 = kitty::count_ones( tt_not_s & care );
+        if ( score2 < min_score2 )
+        {
+          min_score2 = score2;
+          chosen_s = s * 2;
+        }
+      }
+
+      // try negative s
+      score1 = kitty::count_ones( uncovered & tt_not_s );
+      if ( score1 < min_score1 )
+      {
+        min_score1 = score1;
+        chosen_s = s * 2 + 1;
+        min_score2 = num_bits;
+      }
+      if ( score1 == min_score1 )
+      {
+        score2 = kitty::count_ones( tt_s & care );
+        if ( score2 < min_score2 )
+        {
+          min_score2 = score2;
+          chosen_s = s * 2 + 1;
+        }
+      }
+    }
+
+    bool inverted_s = false;
+    if (chosen_s % 2 == 1){
+      inverted_s = true;
+      printf("Inverted Select\n");
+    } else {
+      printf("Not Inverted Select\n");
+    }
+    TT tt_chosen_s = chosen_s % 2 ? ~divisors.at( chosen_s / 2 ) : divisors.at( chosen_s / 2 );
+
+    if ( min_score2 != 0 )
+    {
+      TT to_cover = care & ~tt_chosen_s;
+      
+      //std::cout << "Chose S: " << chosen_s /2 << " complemented: "<< chosen_s%2 <<" with uncovered: ";
+      //kitty::print_binary(to_cover);
+      //std::cout << "\n";
+      
+
+      max_score = 0;
+      for ( auto e = 0u; e < normalized.size(); ++e )
+      {
+        score1 = kitty::count_ones( normalized.at( e ) & to_cover );
+        if ( score1 > max_score )
+        {
+          max_score = score1;
+          chosen_e = e;
+          if ( max_score == min_score2 ) // best e-child
+            break;
+        }
+      }
+    }
+
+    if ( min_score1 != 0 ) /* expand on t-child */
+    {
+      TT t_care = care & tt_chosen_s;
+
+      /*
+      std::cout << "Chose S: " << chosen_s /2 << " complemented: "<< chosen_s%2 <<" with uncovered: ";
+      kitty::print_binary(t_care);
+      std::cout << "\n";
+      */
+
+      auto res = compute_function( t_care, depth + 1 );
+      if ( res && remaining_size > 0 )
+        chosen_t = *res;
+      else
+        return std::nullopt;
+    }
+
+    if ( max_score != min_score2 ) /* expand on e-child */
+    {
+      TT e_care = care & ~tt_chosen_s;
+
+      /*std::cout << "Chose S: " << chosen_s /2 << " complemented: "<< chosen_s%2 <<" with uncovered: ";
+      kitty::print_binary(e_care);
+      std::cout << "\n";
+      */
+      auto res = compute_function( e_care, depth + 1 );
+      if ( res && remaining_size > 0 )
+        chosen_e = *res;
+      else
+        return std::nullopt;
+    }
+
+    assert( remaining_size >= 1 );
+    --remaining_size;
+    if (inverted_s){
+      return index_list.add_mux( chosen_s + 1, chosen_e, chosen_t );
+    } else {
+      return index_list.add_mux( chosen_s + 2, chosen_t, chosen_e );
+    }
+  }
+
+private:
+  uint32_t num_bits;
+  uint32_t remaining_size;
+  uint32_t max_depth;
+
+  std::vector<TT> divisors;
+  std::vector<TT> normalized;
+
+  muxig_index_list index_list;
+
+  stats& st;
+}; /* mux_resyn */
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/resyn_engines/mux_resyn_xnor_sel.hpp b/include/mockturtle/algorithms/resyn_engines/mux_resyn_xnor_sel.hpp
new file mode 100644
index 0000000..9cc4719
--- /dev/null
+++ b/include/mockturtle/algorithms/resyn_engines/mux_resyn_xnor_sel.hpp
@@ -0,0 +1,312 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+
+A B Y
+0 0 1
+0 1 1
+1 0 1
+1 1 0
+
+A B Y
+0 0 0
+0 1
+
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mux_resyn.hpp
+  \brief Implements resynthesis methods for MuxIGs.
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../../utils/index_list.hpp"
+#include "../../utils/null_utils.hpp"
+
+#include <cassert>
+#include <cstdint>
+#include <fmt/format.h>
+#include <fstream>
+#include <iostream>
+#include <kitty/kitty.hpp>
+
+#include <kitty/print.hpp>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+namespace mockturtle {
+
+/*! \brief Logic resynthesis engine for MuxIGs with top-down decomposition.
+ *
+ */
+template <class TT> class mux_resyn_xnor_sel {
+public:
+  using stats = null_stats;
+  using index_list_t = muxig_index_list;
+  using truth_table_t = TT;
+
+public:
+  explicit mux_resyn_xnor_sel(stats &st) : st(st) {}
+
+  template <class iterator_type, class truth_table_storage_type>
+  std::optional<index_list_t>
+  operator()(TT const &target, TT const &care, iterator_type begin,
+             iterator_type end, truth_table_storage_type const &tts,
+             uint32_t max_size = std::numeric_limits<uint32_t>::max()) {
+    divisors.clear();
+    normalized.clear();
+    xor_selects.clear();
+
+    normalized.emplace_back(~target); // 0 XNOR target = ~target
+    normalized.emplace_back(target);  // 1 XNOR target = target
+
+    while (begin != end) {
+      auto const &tt = tts[*begin];
+      assert(tt.num_bits() == target.num_bits());
+      normalized.emplace_back(tt ^
+                              normalized[0]); // tt XNOR target = tt XOR ~target
+      normalized.emplace_back(tt ^ target);   // ~tt XNOR target = tt XOR target
+      divisors.emplace_back(tt);
+      iterator_type iter = begin + 1;
+      while (iter != end) {
+        xor_selects.emplace_back((tt ^ tts[*iter]));
+        iter++;
+      }
+      ++begin;
+    }
+    assert(xor_selects.size() == (divisors.size() * (divisors.size() - 1)) / 2);
+
+    num_bits = kitty::count_ones(care);
+    remaining_size = max_size;
+    // remaining_size = std::numeric_limits<uint32_t>::max();
+    max_depth = std::min(10u, max_size);
+    index_list.clear();
+    index_list.add_inputs(divisors.size());
+
+    auto res = compute_function(care, 0);
+    if (res) {
+      index_list.add_output(*res);
+      return index_list;
+    } else {
+      return std::nullopt;
+    }
+  }
+
+private:
+  std::optional<index_list_t::element_type> compute_function(TT const &care,
+                                                             uint32_t depth) {
+    if (depth > max_depth)
+      return std::nullopt;
+
+    /*
+    std::cout << "In computation function with depth: " << depth << " and care:
+    "; kitty::print_binary(care); std::cout << "\n";
+    */
+    uint32_t chosen_t{0}, chosen_s{0}, chosen_e{0}, score1{0}, score2{0},
+        max_score{0}, min_score1{num_bits}, min_score2{num_bits};
+    for (auto t = 0u; t < normalized.size(); ++t) {
+      score1 = kitty::count_ones(normalized.at(t) & care);
+      if (score1 > max_score) {
+        max_score = score1;
+        chosen_t = t;
+        if (score1 == num_bits) {
+          /* 0-resub */
+          return t;
+        }
+      }
+    }
+
+    if (remaining_size == 0)
+      return std::nullopt;
+
+    TT uncovered = ~normalized.at(chosen_t) & care;
+
+    /*std::cout << "Chose T: " << chosen_t << " with uncovered: ";
+    kitty::print_binary(uncovered);
+    std::cout << "\n";
+    */
+    for (auto s = 0u; s < divisors.size(); ++s) {
+      TT &tt_s = divisors.at(s);
+      TT tt_not_s = ~divisors.at(s);
+
+      // try positive s
+      score1 = kitty::count_ones(uncovered & tt_s);
+      if (score1 < min_score1) {
+        min_score1 = score1;
+        chosen_s = s * 2;
+        min_score2 = num_bits;
+      }
+      if (score1 == min_score1) {
+        score2 = kitty::count_ones(tt_not_s & care);
+        if (score2 < min_score2) {
+          min_score2 = score2;
+          chosen_s = s * 2;
+        }
+      }
+
+      // try negative s
+      score1 = kitty::count_ones(uncovered & tt_not_s);
+      if (score1 < min_score1) {
+        min_score1 = score1;
+        chosen_s = s * 2 + 1;
+        min_score2 = num_bits;
+      }
+      if (score1 == min_score1) {
+        score2 = kitty::count_ones(tt_s & care);
+        if (score2 < min_score2) {
+          min_score2 = score2;
+          chosen_s = s * 2 + 1;
+        }
+      }
+    }
+
+    TT tt_chosen_s =
+        chosen_s % 2 ? ~divisors.at(chosen_s / 2) : divisors.at(chosen_s / 2);
+
+    uint32_t zeros = 0;
+    uint32_t min_score_xor = num_bits;
+    uint32_t score_xor1 = num_bits;
+    uint32_t score_xnor1 = num_bits;
+    uint32_t score_xor2 = num_bits;
+    uint32_t min_score_xor2 = num_bits + 1;
+    uint32_t chosen_xor1{0}, chosen_xor2{0};
+    std::vector<std::pair<uint32_t, uint32_t>> xor_s_candidates;
+    bool use_xor_s = false;
+    bool use_xnor_s = false;
+    for (auto s1_xor = 0u; s1_xor < divisors.size(); s1_xor++) {
+      TT &tt_s1 = divisors.at(s1_xor);
+      // TT tt_not_s1 = ~divisors.at(s1_xor);
+      for (auto s2_xor = s1_xor + 1; s2_xor < divisors.size(); s2_xor++) {
+        TT &tt_s2 = divisors.at(s2_xor);
+        // TT tt_not_s2 = ~divisors.at(s2_xor);
+        score_xor1 = kitty::count_ones(uncovered & (tt_s1 ^ tt_s2));
+        // single variable didn't find solution but xor did
+        if (score_xor1 == 0 && min_score1 != 0) {
+          use_xnor_s = false;
+          use_xor_s = true;
+          xor_s_candidates.emplace_back(s1_xor, s2_xor);
+          score_xor2 = kitty::count_ones(care & ~(tt_s1 ^ tt_s2));
+          if (score_xor2 < min_score_xor2) {
+            min_score_xor2 = score_xor2;
+            chosen_xor1 = s1_xor * 2;
+            chosen_xor2 = s2_xor * 2;
+          }
+        }
+        // try xnor
+        score_xnor1 = kitty::count_ones(uncovered & ~(tt_s1 ^ tt_s2));
+        if (score_xnor1 == 0 && min_score1 != 0) {
+          use_xnor_s = true;
+          use_xor_s = false;
+          score_xor2 = kitty::count_ones(care & ~(tt_s1 ^ tt_s2));
+          if (score_xor2 < min_score_xor2) {
+            min_score_xor2 = score_xor2;
+            chosen_xor1 = s1_xor * 2;
+            chosen_xor2 = s2_xor * 2;
+          }
+        }
+      }
+    }
+    TT tt_chosen_xor1 = chosen_xor1 % 2 ? ~divisors.at(chosen_xor1 / 2)
+                                        : divisors.at(chosen_xor1 / 2);
+    TT tt_chosen_xor2 = chosen_xor2 % 2 ? ~divisors.at(chosen_xor2 / 2)
+                                        : divisors.at(chosen_xor2 / 2);
+    assert(!(use_xor_s && use_xnor_s));
+    if (use_xnor_s) {
+      tt_chosen_s = ~(tt_chosen_xor1 ^ tt_chosen_xor2);
+      printf("use xnor\n");
+    }
+    if (use_xor_s) {
+      tt_chosen_s = tt_chosen_xor1 ^ tt_chosen_xor2;
+      printf("use xor\n");
+    }
+    // printf("%d/%d, %d\n", zeros, not_zeros, xor_s_candidates.size());
+
+    if (min_score2 != 0) {
+      TT to_cover = care & ~tt_chosen_s;
+      max_score = 0;
+      for (auto e = 0u; e < normalized.size(); ++e) {
+        score1 = kitty::count_ones(normalized.at(e) & to_cover);
+        if (score1 > max_score) {
+          max_score = score1;
+          chosen_e = e;
+          if (max_score == min_score2) // best e-child
+            break;
+        }
+      }
+    }
+
+    if (min_score1 != 0) /* expand on t-child */
+    {
+      TT t_care = care & tt_chosen_s;
+      auto res = compute_function(t_care, depth + 1);
+      if (res && remaining_size > 0)
+        chosen_t = *res;
+      else
+        return std::nullopt;
+    }
+
+    if (max_score != min_score2) /* expand on e-child */
+    {
+      TT e_care = care & ~tt_chosen_s;
+      auto res = compute_function(e_care, depth + 1);
+      if (res && remaining_size > 0)
+        chosen_e = *res;
+      else
+        return std::nullopt;
+    }
+
+    assert(remaining_size >= 1);
+    --remaining_size;
+    if (use_xnor_s) {
+      return index_list.add_mux(
+          index_list.add_xor(chosen_xor1 + 2, chosen_xor2 + 2), chosen_e,
+          chosen_t);
+    } else if (use_xor_s) {
+      return index_list.add_mux(
+          index_list.add_xor(chosen_xor1 + 2, chosen_xor2 + 2), chosen_t,
+          chosen_e);
+    } else {
+      return index_list.add_mux(chosen_s + 2, chosen_t, chosen_e);
+    }
+  }
+
+private:
+  uint32_t num_bits;
+  uint32_t remaining_size;
+  uint32_t max_depth;
+
+  std::vector<TT> divisors;
+  std::vector<TT> normalized;
+  // std::vector<std::pair<TT, std::pair<uint32_t, uint32_t>>> xnor_selects;
+  std::vector<TT> xor_selects;
+
+  muxig_index_list index_list;
+
+  stats &st;
+}; /* mux_resyn */
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/resyn_engines/xag_resyn.hpp b/include/mockturtle/algorithms/resyn_engines/xag_resyn.hpp
new file mode 100644
index 0000000..ae01942
--- /dev/null
+++ b/include/mockturtle/algorithms/resyn_engines/xag_resyn.hpp
@@ -0,0 +1,890 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xag_resyn.hpp
+  \brief Resynthesis by recursive decomposition for AIGs or XAGs.
+  (based on ABC's implementation in `giaResub.c` by Alan Mishchenko)
+
+  \author Siang-Yun Lee
+*/
+
+#pragma once
+
+#include "../../utils/index_list.hpp"
+#include "../../utils/node_map.hpp"
+#include "../../utils/stopwatch.hpp"
+
+#include <fmt/format.h>
+#include <kitty/kitty.hpp>
+
+#include <algorithm>
+#include <optional>
+#include <type_traits>
+#include <vector>
+
+namespace mockturtle
+{
+
+struct xag_resyn_static_params
+{
+  using base_type = xag_resyn_static_params;
+
+  /*! \brief Maximum number of binate divisors to be considered. */
+  static constexpr uint32_t max_binates{ 50u };
+
+  /*! \brief Reserved capacity for divisor truth tables (number of divisors). */
+  static constexpr uint32_t reserve{ 200u };
+
+  /*! \brief Whether to consider single XOR gates (i.e., using XAGs instead of AIGs). */
+  static constexpr bool use_xor{ true };
+
+  /*! \brief Whether to copy truth tables. */
+  static constexpr bool copy_tts{ false };
+
+  /*! \brief Whether to preserve depth. */
+  static constexpr bool preserve_depth{ false };
+
+  /*! \brief Whether the divisors have uniform costs (size and depth, whenever relevant). */
+  static constexpr bool uniform_div_cost{ true };
+
+  /*! \brief Size cost of each AND gate. */
+  static constexpr uint32_t size_cost_of_and{ 1u };
+
+  /*! \brief Size cost of each XOR gate (only relevant when `use_xor = true`). */
+  static constexpr uint32_t size_cost_of_xor{ 1u };
+
+  /*! \brief Depth cost of each AND gate (only relevant when `preserve_depth = true`). */
+  static constexpr uint32_t depth_cost_of_and{ 1u };
+
+  /*! \brief Depth cost of each XOR gate (only relevant when `preserve_depth = true` and `use_xor = true`). */
+  static constexpr uint32_t depth_cost_of_xor{ 1u };
+
+  using truth_table_storage_type = void;
+  using node_type = void;
+};
+
+template<class TT>
+struct xag_resyn_static_params_default : public xag_resyn_static_params
+{
+  using truth_table_storage_type = std::vector<TT>;
+  using node_type = uint32_t;
+};
+
+template<class TT>
+struct aig_resyn_static_params_default : public xag_resyn_static_params_default<TT>
+{
+  static constexpr bool use_xor = false;
+};
+
+template<class Ntk>
+struct xag_resyn_static_params_for_win_resub : public xag_resyn_static_params
+{
+  using truth_table_storage_type = unordered_node_map<kitty::dynamic_truth_table, Ntk>;
+  using node_type = typename Ntk::node;
+};
+
+template<class Ntk>
+struct xag_resyn_static_params_for_sim_resub : public xag_resyn_static_params
+{
+  using truth_table_storage_type = incomplete_node_map<kitty::partial_truth_table, Ntk>;
+  using node_type = typename Ntk::node;
+};
+
+template<class Ntk>
+struct aig_resyn_static_params_for_win_resub : public xag_resyn_static_params
+{
+  using truth_table_storage_type = unordered_node_map<kitty::dynamic_truth_table, Ntk>;
+  using node_type = typename Ntk::node;
+  static constexpr bool use_xor = false;
+};
+
+template<class Ntk>
+struct aig_resyn_static_params_for_sim_resub : public xag_resyn_static_params_for_sim_resub<Ntk>
+{
+  static constexpr bool use_xor = false;
+};
+
+struct xag_resyn_stats
+{
+  /*! \brief Time for finding 0-resub and collecting unate literals. */
+  stopwatch<>::duration time_unate{ 0 };
+
+  /*! \brief Time for finding 1-resub. */
+  stopwatch<>::duration time_resub1{ 0 };
+
+  /*! \brief Time for finding 2-resub. */
+  stopwatch<>::duration time_resub2{ 0 };
+
+  /*! \brief Time for finding 3-resub. */
+  stopwatch<>::duration time_resub3{ 0 };
+
+  /*! \brief Time for sorting unate literals and unate pairs. */
+  stopwatch<>::duration time_sort{ 0 };
+
+  /*! \brief Time for collecting unate pairs. */
+  stopwatch<>::duration time_collect_pairs{ 0 };
+
+  /*! \brief Time for dividing the target and recursive call. */
+  stopwatch<>::duration time_divide{ 0 };
+
+  void report() const
+  {
+    fmt::print( "[i]         <xag_resyn_decompose>\n" );
+    fmt::print( "[i]             0-resub      : {:>5.2f} secs\n", to_seconds( time_unate ) );
+    fmt::print( "[i]             1-resub      : {:>5.2f} secs\n", to_seconds( time_resub1 ) );
+    fmt::print( "[i]             2-resub      : {:>5.2f} secs\n", to_seconds( time_resub2 ) );
+    fmt::print( "[i]             3-resub      : {:>5.2f} secs\n", to_seconds( time_resub3 ) );
+    fmt::print( "[i]             sort         : {:>5.2f} secs\n", to_seconds( time_sort ) );
+    fmt::print( "[i]             collect pairs: {:>5.2f} secs\n", to_seconds( time_collect_pairs ) );
+    fmt::print( "[i]             dividing     : {:>5.2f} secs\n", to_seconds( time_divide ) );
+  }
+};
+
+/*! \brief Logic resynthesis engine for AIGs or XAGs.
+ *
+ * The algorithm is based on ABC's implementation in `giaResub.c` by Alan Mishchenko.
+ *
+ * Divisors are classified as positive unate (not overlapping with target offset),
+ * negative unate (not overlapping with target onset), or binate (overlapping with
+ * both onset and offset). Furthermore, pairs of binate divisors are combined with
+ * an AND operation and considering all possible input polarities and again classified
+ * as positive unate, negative unate or binate. Simple solutions of zero cost
+ * (one unate divisor), one node (two unate divisors), two nodes (one unate divisor +
+ * one unate pair), and three nodes (two unate pairs) are exhaustively examined.
+ * When no simple solutions can be found, the algorithm heuristically chooses an unate
+ * divisor or an unate pair to divide the target function with and recursively calls
+ * itself to decompose the remainder function.
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      using TT = kitty::static_truth_table<6>;
+      const std::vector<aig_network::node> divisors = ...;
+      const node_map<TT, aig_network> tts = ...;
+      const TT target = ..., care = ...;
+      xag_resyn_stats st;
+      xag_resyn_decompose<TT, node_map<TT, aig_network>, false, false, aig_network::node> resyn( st );
+      auto result = resyn( target, care, divisors.begin(), divisors.end(), tts );
+   \endverbatim
+ */
+template<class TT, class static_params = xag_resyn_static_params_default<TT>>
+class xag_resyn_decompose
+{
+public:
+  using stats = xag_resyn_stats;
+  using index_list_t = large_xag_index_list;
+  using truth_table_t = TT;
+
+private:
+  struct unate_lit
+  {
+    unate_lit( uint32_t l )
+        : lit( l )
+    {}
+
+    bool operator==( unate_lit const& other ) const
+    {
+      return lit == other.lit;
+    }
+
+    uint32_t lit;
+    uint32_t score{ 0 };
+  };
+
+  struct fanin_pair
+  {
+    fanin_pair( uint32_t l1, uint32_t l2 )
+        : lit1( l1 < l2 ? l1 : l2 ), lit2( l1 < l2 ? l2 : l1 )
+    {}
+
+    fanin_pair( uint32_t l1, uint32_t l2, bool is_xor )
+        : lit1( l1 > l2 ? l1 : l2 ), lit2( l1 > l2 ? l2 : l1 )
+    {
+      (void)is_xor;
+    }
+
+    bool operator==( fanin_pair const& other ) const
+    {
+      return lit1 == other.lit1 && lit2 == other.lit2;
+    }
+
+    uint32_t lit1, lit2;
+    uint32_t score{ 0 };
+  };
+
+public:
+  explicit xag_resyn_decompose( stats& st ) noexcept
+      : st( st )
+  {
+    static_assert( std::is_same_v<typename static_params::base_type, xag_resyn_static_params>, "Invalid static_params type" );
+    static_assert( !( static_params::uniform_div_cost && static_params::preserve_depth ), "If depth is to be preserved, divisor depth cost must be provided (usually not uniform)" );
+    divisors.reserve( static_params::reserve );
+  }
+
+  /*! \brief Perform XAG resynthesis.
+   *
+   * `tts[*begin]` must be of type `TT`.
+   * Moreover, if `static_params::copy_tts = false`, `*begin` must be of type `static_params::node_type`.
+   *
+   * \param target Truth table of the target function.
+   * \param care Truth table of the care set.
+   * \param begin Begin iterator to divisor nodes.
+   * \param end End iterator to divisor nodes.
+   * \param tts A data structure (e.g. std::vector<TT>) that stores the truth tables of the divisor functions.
+   * \param max_size Maximum number of nodes allowed in the dependency circuit.
+   */
+  template<class iterator_type,
+           bool enabled = static_params::uniform_div_cost && !static_params::preserve_depth, typename = std::enable_if_t<enabled>>
+  std::optional<index_list_t> operator()( TT const& target, TT const& care, iterator_type begin, iterator_type end, typename static_params::truth_table_storage_type const& tts, uint32_t max_size = std::numeric_limits<uint32_t>::max() )
+  {
+    static_assert( static_params::copy_tts || std::is_same_v<typename std::iterator_traits<iterator_type>::value_type, typename static_params::node_type>, "iterator_type does not dereference to static_params::node_type" );
+
+    ptts = &tts;
+    on_off_sets[0] = ~target & care;
+    on_off_sets[1] = target & care;
+
+    divisors.resize( 1 ); /* clear previous data and reserve 1 dummy node for constant */
+    while ( begin != end )
+    {
+      if constexpr ( static_params::copy_tts )
+      {
+        divisors.emplace_back( ( *ptts )[*begin] );
+      }
+      else
+      {
+        divisors.emplace_back( *begin );
+      }
+      ++begin;
+    }
+
+    return compute_function( max_size );
+  }
+
+  template<class iterator_type, class Fn,
+           bool enabled = !static_params::uniform_div_cost && !static_params::preserve_depth, typename = std::enable_if_t<enabled>>
+  std::optional<index_list_t> operator()( TT const& target, TT const& care, iterator_type begin, iterator_type end, typename static_params::truth_table_storage_type const& tts, Fn&& size_cost, uint32_t max_size = std::numeric_limits<uint32_t>::max() )
+  {}
+
+  template<class iterator_type, class Fn,
+           bool enabled = !static_params::uniform_div_cost && static_params::preserve_depth, typename = std::enable_if_t<enabled>>
+  std::optional<index_list_t> operator()( TT const& target, TT const& care, iterator_type begin, iterator_type end, typename static_params::truth_table_storage_type const& tts, Fn&& size_cost, Fn&& depth_cost, uint32_t max_size = std::numeric_limits<uint32_t>::max(), uint32_t max_depth = std::numeric_limits<uint32_t>::max() )
+  {}
+
+private:
+  std::optional<index_list_t> compute_function( uint32_t num_inserts )
+  {
+    index_list.clear();
+    index_list.add_inputs( divisors.size() - 1 );
+    auto const lit = compute_function_rec( num_inserts );
+    if ( lit )
+    {
+      assert( index_list.num_gates() <= num_inserts );
+      index_list.add_output( *lit );
+      return index_list;
+    }
+    return std::nullopt;
+  }
+
+  std::optional<uint32_t> compute_function_rec( uint32_t num_inserts )
+  {
+    pos_unate_lits.clear();
+    neg_unate_lits.clear();
+    binate_divs.clear();
+    pos_unate_pairs.clear();
+    neg_unate_pairs.clear();
+
+    /* try 0-resub and collect unate literals */
+    auto const res0 = call_with_stopwatch( st.time_unate, [&]() {
+      return find_one_unate();
+    } );
+    if ( res0 )
+    {
+      return *res0;
+    }
+    if ( num_inserts == 0u )
+    {
+      return std::nullopt;
+    }
+
+    /* sort unate literals and try 1-resub */
+    call_with_stopwatch( st.time_sort, [&]() {
+      sort_unate_lits( pos_unate_lits, 1 );
+      sort_unate_lits( neg_unate_lits, 0 );
+    } );
+    auto const res1or = call_with_stopwatch( st.time_resub1, [&]() {
+      return find_div_div( pos_unate_lits, 1 );
+    } );
+    if ( res1or )
+    {
+      return *res1or;
+    }
+    auto const res1and = call_with_stopwatch( st.time_resub1, [&]() {
+      return find_div_div( neg_unate_lits, 0 );
+    } );
+    if ( res1and )
+    {
+      return *res1and;
+    }
+
+    if ( binate_divs.size() > static_params::max_binates )
+    {
+      binate_divs.resize( static_params::max_binates );
+    }
+
+    if constexpr ( static_params::use_xor )
+    {
+      /* collect XOR-type unate pairs and try 1-resub with XOR */
+      auto const res1xor = find_xor();
+      if ( res1xor )
+      {
+        return *res1xor;
+      }
+    }
+    if ( num_inserts == 1u )
+    {
+      return std::nullopt;
+    }
+
+    /* collect AND-type unate pairs and sort (both types), then try 2- and 3-resub */
+    call_with_stopwatch( st.time_collect_pairs, [&]() {
+      collect_unate_pairs();
+    } );
+    call_with_stopwatch( st.time_sort, [&]() {
+      sort_unate_pairs( pos_unate_pairs, 1 );
+      sort_unate_pairs( neg_unate_pairs, 0 );
+    } );
+    auto const res2or = call_with_stopwatch( st.time_resub2, [&]() {
+      return find_div_pair( pos_unate_lits, pos_unate_pairs, 1 );
+    } );
+    if ( res2or )
+    {
+      return *res2or;
+    }
+    auto const res2and = call_with_stopwatch( st.time_resub2, [&]() {
+      return find_div_pair( neg_unate_lits, neg_unate_pairs, 0 );
+    } );
+    if ( res2and )
+    {
+      return *res2and;
+    }
+
+    if ( num_inserts >= 3u )
+    {
+      auto const res3or = call_with_stopwatch( st.time_resub3, [&]() {
+        return find_pair_pair( pos_unate_pairs, 1 );
+      } );
+      if ( res3or )
+      {
+        return *res3or;
+      }
+      auto const res3and = call_with_stopwatch( st.time_resub3, [&]() {
+        return find_pair_pair( neg_unate_pairs, 0 );
+      } );
+      if ( res3and )
+      {
+        return *res3and;
+      }
+    }
+
+    /* choose something to divide and recursive call on the remainder */
+    /* Note: dividing = AND the on-set (if using positive unate) or the off-set (if using negative unate)
+                        with the *negation* of the divisor/pair (subtracting) */
+    uint32_t on_off_div, on_off_pair;
+    uint32_t score_div = 0, score_pair = 0;
+
+    call_with_stopwatch( st.time_divide, [&]() {
+      if ( pos_unate_lits.size() > 0 )
+      {
+        on_off_div = 1; /* use pos_lit */
+        score_div = pos_unate_lits[0].score;
+        if ( neg_unate_lits.size() > 0 && neg_unate_lits[0].score > pos_unate_lits[0].score )
+        {
+          on_off_div = 0; /* use neg_lit */
+          score_div = neg_unate_lits[0].score;
+        }
+      }
+      else if ( neg_unate_lits.size() > 0 )
+      {
+        on_off_div = 0; /* use neg_lit */
+        score_div = neg_unate_lits[0].score;
+      }
+
+      if ( num_inserts > 3u )
+      {
+        if ( pos_unate_pairs.size() > 0 )
+        {
+          on_off_pair = 1; /* use pos_pair */
+          score_pair = pos_unate_pairs[0].score;
+          if ( neg_unate_pairs.size() > 0 && neg_unate_pairs[0].score > pos_unate_pairs[0].score )
+          {
+            on_off_pair = 0; /* use neg_pair */
+            score_pair = neg_unate_pairs[0].score;
+          }
+        }
+        else if ( neg_unate_pairs.size() > 0 )
+        {
+          on_off_pair = 0; /* use neg_pair */
+          score_pair = neg_unate_pairs[0].score;
+        }
+      }
+    } );
+
+    if ( score_div > score_pair / 2 ) /* divide with a divisor */
+    {
+      /* if using pos_lit (on_off_div = 1), modify on-set and use an OR gate on top;
+         if using neg_lit (on_off_div = 0), modify off-set and use an AND gate on top
+       */
+      uint32_t const lit = on_off_div ? pos_unate_lits[0].lit : neg_unate_lits[0].lit;
+      call_with_stopwatch( st.time_divide, [&]() {
+        on_off_sets[on_off_div] &= lit & 0x1 ? get_div( lit >> 1 ) : ~get_div( lit >> 1 );
+      } );
+
+      auto const res_remain_div = compute_function_rec( num_inserts - 1 );
+      if ( res_remain_div )
+      {
+        auto const new_lit = index_list.add_and( ( lit ^ 0x1 ), *res_remain_div ^ on_off_div );
+        return new_lit + on_off_div;
+      }
+    }
+    else if ( score_pair > 0 ) /* divide with a pair */
+    {
+      fanin_pair const pair = on_off_pair ? pos_unate_pairs[0] : neg_unate_pairs[0];
+      call_with_stopwatch( st.time_divide, [&]() {
+        if constexpr ( static_params::use_xor )
+        {
+          if ( pair.lit1 > pair.lit2 ) /* XOR pair: ~(lit1 ^ lit2) = ~lit1 ^ lit2 */
+          {
+            on_off_sets[on_off_pair] &= ( pair.lit1 & 0x1 ? get_div( pair.lit1 >> 1 ) : ~get_div( pair.lit1 >> 1 ) ) ^ ( pair.lit2 & 0x1 ? ~get_div( pair.lit2 >> 1 ) : get_div( pair.lit2 >> 1 ) );
+          }
+          else /* AND pair: ~(lit1 & lit2) = ~lit1 | ~lit2 */
+          {
+            on_off_sets[on_off_pair] &= ( pair.lit1 & 0x1 ? get_div( pair.lit1 >> 1 ) : ~get_div( pair.lit1 >> 1 ) ) | ( pair.lit2 & 0x1 ? get_div( pair.lit2 >> 1 ) : ~get_div( pair.lit2 >> 1 ) );
+          }
+        }
+        else /* AND pair: ~(lit1 & lit2) = ~lit1 | ~lit2 */
+        {
+          on_off_sets[on_off_pair] &= ( pair.lit1 & 0x1 ? get_div( pair.lit1 >> 1 ) : ~get_div( pair.lit1 >> 1 ) ) | ( pair.lit2 & 0x1 ? get_div( pair.lit2 >> 1 ) : ~get_div( pair.lit2 >> 1 ) );
+        }
+      } );
+
+      auto const res_remain_pair = compute_function_rec( num_inserts - 2 );
+      if ( res_remain_pair )
+      {
+        uint32_t new_lit1;
+        if constexpr ( static_params::use_xor )
+        {
+          new_lit1 = ( pair.lit1 > pair.lit2 ) ? index_list.add_xor( pair.lit1, pair.lit2 ) : index_list.add_and( pair.lit1, pair.lit2 );
+        }
+        else
+        {
+          new_lit1 = index_list.add_and( pair.lit1, pair.lit2 );
+        }
+        auto const new_lit2 = index_list.add_and( new_lit1 ^ 0x1, *res_remain_pair ^ on_off_pair );
+        return new_lit2 + on_off_pair;
+      }
+    }
+
+    return std::nullopt;
+  }
+
+  /* See if there is a constant or divisor covering all on-set bits or all off-set bits.
+     1. Check constant-resub
+     2. Collect unate literals
+     3. Find 0-resub (both positive unate and negative unate) and collect binate (neither pos nor neg unate) divisors
+   */
+  std::optional<uint32_t> find_one_unate()
+  {
+    num_bits[0] = kitty::count_ones( on_off_sets[0] ); /* off-set */
+    num_bits[1] = kitty::count_ones( on_off_sets[1] ); /* on-set */
+    if ( num_bits[0] == 0 )
+    {
+      return 1;
+    }
+    if ( num_bits[1] == 0 )
+    {
+      return 0;
+    }
+
+    for ( auto v = 1u; v < divisors.size(); ++v )
+    {
+      bool unateness[4] = { false, false, false, false };
+      /* check intersection with off-set */
+      if ( kitty::intersection_is_empty<TT, 1, 1>( get_div( v ), on_off_sets[0] ) )
+      {
+        pos_unate_lits.emplace_back( v << 1 );
+        unateness[0] = true;
+      }
+      else if ( kitty::intersection_is_empty<TT, 0, 1>( get_div( v ), on_off_sets[0] ) )
+      {
+        pos_unate_lits.emplace_back( v << 1 | 0x1 );
+        unateness[1] = true;
+      }
+
+      /* check intersection with on-set */
+      if ( kitty::intersection_is_empty<TT, 1, 1>( get_div( v ), on_off_sets[1] ) )
+      {
+        neg_unate_lits.emplace_back( v << 1 );
+        unateness[2] = true;
+      }
+      else if ( kitty::intersection_is_empty<TT, 0, 1>( get_div( v ), on_off_sets[1] ) )
+      {
+        neg_unate_lits.emplace_back( v << 1 | 0x1 );
+        unateness[3] = true;
+      }
+
+      /* 0-resub */
+      if ( unateness[0] && unateness[3] )
+      {
+        return ( v << 1 );
+      }
+      if ( unateness[1] && unateness[2] )
+      {
+        return ( v << 1 ) + 1;
+      }
+      /* useless unate literal */
+      if ( ( unateness[0] && unateness[2] ) || ( unateness[1] && unateness[3] ) )
+      {
+        pos_unate_lits.pop_back();
+        neg_unate_lits.pop_back();
+      }
+      /* binate divisor */
+      else if ( !unateness[0] && !unateness[1] && !unateness[2] && !unateness[3] )
+      {
+        binate_divs.emplace_back( v );
+      }
+    }
+    return std::nullopt;
+  }
+
+  /* Sort the unate literals by the number of minterms in the intersection.
+     - For `pos_unate_lits`, `on_off` = 1, sort by intersection with on-set;
+     - For `neg_unate_lits`, `on_off` = 0, sort by intersection with off-set
+   */
+  void sort_unate_lits( std::vector<unate_lit>& unate_lits, uint32_t on_off )
+  {
+    for ( auto& l : unate_lits )
+    {
+      l.score = kitty::count_ones( ( l.lit & 0x1 ? ~get_div( l.lit >> 1 ) : get_div( l.lit >> 1 ) ) & on_off_sets[on_off] );
+    }
+    std::stable_sort( unate_lits.begin(), unate_lits.end(), [&]( unate_lit const& l1, unate_lit const& l2 ) {
+      return l1.score > l2.score; // descending order
+    } );
+  }
+
+  void sort_unate_pairs( std::vector<fanin_pair>& unate_pairs, uint32_t on_off )
+  {
+    for ( auto& p : unate_pairs )
+    {
+      if constexpr ( static_params::use_xor )
+      {
+        p.score = ( p.lit1 > p.lit2 ) ? kitty::count_ones( ( ( p.lit1 & 0x1 ? ~get_div( p.lit1 >> 1 ) : get_div( p.lit1 >> 1 ) ) ^ ( p.lit2 & 0x1 ? ~get_div( p.lit2 >> 1 ) : get_div( p.lit2 >> 1 ) ) ) & on_off_sets[on_off] )
+                                      : kitty::count_ones( ( p.lit1 & 0x1 ? ~get_div( p.lit1 >> 1 ) : get_div( p.lit1 >> 1 ) ) & ( p.lit2 & 0x1 ? ~get_div( p.lit2 >> 1 ) : get_div( p.lit2 >> 1 ) ) & on_off_sets[on_off] );
+      }
+      else
+      {
+        p.score = kitty::count_ones( ( p.lit1 & 0x1 ? ~get_div( p.lit1 >> 1 ) : get_div( p.lit1 >> 1 ) ) & ( p.lit2 & 0x1 ? ~get_div( p.lit2 >> 1 ) : get_div( p.lit2 >> 1 ) ) & on_off_sets[on_off] );
+      }
+    }
+    std::stable_sort( unate_pairs.begin(), unate_pairs.end(), [&]( fanin_pair const& p1, fanin_pair const& p2 ) {
+      return p1.score > p2.score; // descending order
+    } );
+  }
+
+  /* See if there are two unate divisors covering all on-set bits or all off-set bits.
+     - For `pos_unate_lits`, `on_off` = 1, try covering all on-set bits by combining two with an OR gate;
+     - For `neg_unate_lits`, `on_off` = 0, try covering all off-set bits by combining two with an AND gate
+   */
+  std::optional<uint32_t> find_div_div( std::vector<unate_lit>& unate_lits, uint32_t on_off )
+  {
+    for ( auto i = 0u; i < unate_lits.size(); ++i )
+    {
+      uint32_t const& lit1 = unate_lits[i].lit;
+      if ( unate_lits[i].score * 2 < num_bits[on_off] )
+      {
+        break;
+      }
+      for ( auto j = i + 1; j < unate_lits.size(); ++j )
+      {
+        uint32_t const& lit2 = unate_lits[j].lit;
+        if ( unate_lits[i].score + unate_lits[j].score < num_bits[on_off] )
+        {
+          break;
+        }
+        auto const ntt1 = lit1 & 0x1 ? get_div( lit1 >> 1 ) : ~get_div( lit1 >> 1 );
+        auto const ntt2 = lit2 & 0x1 ? get_div( lit2 >> 1 ) : ~get_div( lit2 >> 1 );
+        if ( kitty::intersection_is_empty( ntt1, ntt2, on_off_sets[on_off] ) )
+        {
+          auto const new_lit = index_list.add_and( ( lit1 ^ 0x1 ), ( lit2 ^ 0x1 ) );
+          return new_lit + on_off;
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  std::optional<uint32_t> find_div_pair( std::vector<unate_lit>& unate_lits, std::vector<fanin_pair>& unate_pairs, uint32_t on_off )
+  {
+    for ( auto i = 0u; i < unate_lits.size(); ++i )
+    {
+      uint32_t const& lit1 = unate_lits[i].lit;
+      for ( auto j = 0u; j < unate_pairs.size(); ++j )
+      {
+        fanin_pair const& pair2 = unate_pairs[j];
+        if ( unate_lits[i].score + pair2.score < num_bits[on_off] )
+        {
+          break;
+        }
+        auto const ntt1 = lit1 & 0x1 ? get_div( lit1 >> 1 ) : ~get_div( lit1 >> 1 );
+        TT ntt2;
+        if constexpr ( static_params::use_xor )
+        {
+          if ( pair2.lit1 > pair2.lit2 )
+          {
+            ntt2 = ( pair2.lit1 & 0x1 ? get_div( pair2.lit1 >> 1 ) : ~get_div( pair2.lit1 >> 1 ) ) ^ ( pair2.lit2 & 0x1 ? ~get_div( pair2.lit2 >> 1 ) : get_div( pair2.lit2 >> 1 ) );
+          }
+          else
+          {
+            ntt2 = ( pair2.lit1 & 0x1 ? get_div( pair2.lit1 >> 1 ) : ~get_div( pair2.lit1 >> 1 ) ) | ( pair2.lit2 & 0x1 ? get_div( pair2.lit2 >> 1 ) : ~get_div( pair2.lit2 >> 1 ) );
+          }
+        }
+        else
+        {
+          ntt2 = ( pair2.lit1 & 0x1 ? get_div( pair2.lit1 >> 1 ) : ~get_div( pair2.lit1 >> 1 ) ) | ( pair2.lit2 & 0x1 ? get_div( pair2.lit2 >> 1 ) : ~get_div( pair2.lit2 >> 1 ) );
+        }
+
+        if ( kitty::intersection_is_empty( ntt1, ntt2, on_off_sets[on_off] ) )
+        {
+          uint32_t new_lit1;
+          if constexpr ( static_params::use_xor )
+          {
+            if ( pair2.lit1 > pair2.lit2 )
+            {
+              new_lit1 = index_list.add_xor( pair2.lit1, pair2.lit2 );
+            }
+            else
+            {
+              new_lit1 = index_list.add_and( pair2.lit1, pair2.lit2 );
+            }
+          }
+          else
+          {
+            new_lit1 = index_list.add_and( pair2.lit1, pair2.lit2 );
+          }
+          auto const new_lit2 = index_list.add_and( ( lit1 ^ 0x1 ), new_lit1 ^ 0x1 );
+          return new_lit2 + on_off;
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  std::optional<uint32_t> find_pair_pair( std::vector<fanin_pair>& unate_pairs, uint32_t on_off )
+  {
+    for ( auto i = 0u; i < unate_pairs.size(); ++i )
+    {
+      fanin_pair const& pair1 = unate_pairs[i];
+      if ( pair1.score * 2 < num_bits[on_off] )
+      {
+        break;
+      }
+      for ( auto j = i + 1; j < unate_pairs.size(); ++j )
+      {
+        fanin_pair const& pair2 = unate_pairs[j];
+        if ( pair1.score + pair2.score < num_bits[on_off] )
+        {
+          break;
+        }
+        TT ntt1, ntt2;
+        if constexpr ( static_params::use_xor )
+        {
+          if ( pair1.lit1 > pair1.lit2 )
+          {
+            ntt1 = ( pair1.lit1 & 0x1 ? get_div( pair1.lit1 >> 1 ) : ~get_div( pair1.lit1 >> 1 ) ) ^ ( pair1.lit2 & 0x1 ? ~get_div( pair1.lit2 >> 1 ) : get_div( pair1.lit2 >> 1 ) );
+          }
+          else
+          {
+            ntt1 = ( pair1.lit1 & 0x1 ? get_div( pair1.lit1 >> 1 ) : ~get_div( pair1.lit1 >> 1 ) ) | ( pair1.lit2 & 0x1 ? get_div( pair1.lit2 >> 1 ) : ~get_div( pair1.lit2 >> 1 ) );
+          }
+          if ( pair2.lit1 > pair2.lit2 )
+          {
+            ntt2 = ( pair2.lit1 & 0x1 ? get_div( pair2.lit1 >> 1 ) : ~get_div( pair2.lit1 >> 1 ) ) ^ ( pair2.lit2 & 0x1 ? ~get_div( pair2.lit2 >> 1 ) : get_div( pair2.lit2 >> 1 ) );
+          }
+          else
+          {
+            ntt2 = ( pair2.lit1 & 0x1 ? get_div( pair2.lit1 >> 1 ) : ~get_div( pair2.lit1 >> 1 ) ) | ( pair2.lit2 & 0x1 ? get_div( pair2.lit2 >> 1 ) : ~get_div( pair2.lit2 >> 1 ) );
+          }
+        }
+        else
+        {
+          ntt1 = ( pair1.lit1 & 0x1 ? get_div( pair1.lit1 >> 1 ) : ~get_div( pair1.lit1 >> 1 ) ) | ( pair1.lit2 & 0x1 ? get_div( pair1.lit2 >> 1 ) : ~get_div( pair1.lit2 >> 1 ) );
+          ntt2 = ( pair2.lit1 & 0x1 ? get_div( pair2.lit1 >> 1 ) : ~get_div( pair2.lit1 >> 1 ) ) | ( pair2.lit2 & 0x1 ? get_div( pair2.lit2 >> 1 ) : ~get_div( pair2.lit2 >> 1 ) );
+        }
+
+        if ( kitty::intersection_is_empty( ntt1, ntt2, on_off_sets[on_off] ) )
+        {
+          uint32_t fanin_lit1, fanin_lit2;
+          if constexpr ( static_params::use_xor )
+          {
+            if ( pair1.lit1 > pair1.lit2 )
+            {
+              fanin_lit1 = index_list.add_xor( pair1.lit1, pair1.lit2 );
+            }
+            else
+            {
+              fanin_lit1 = index_list.add_and( pair1.lit1, pair1.lit2 );
+            }
+            if ( pair2.lit1 > pair2.lit2 )
+            {
+              fanin_lit2 = index_list.add_xor( pair2.lit1, pair2.lit2 );
+            }
+            else
+            {
+              fanin_lit2 = index_list.add_and( pair2.lit1, pair2.lit2 );
+            }
+          }
+          else
+          {
+            fanin_lit1 = index_list.add_and( pair1.lit1, pair1.lit2 );
+            fanin_lit2 = index_list.add_and( pair2.lit1, pair2.lit2 );
+          }
+          uint32_t const output_lit = index_list.add_and( fanin_lit1 ^ 0x1, fanin_lit2 ^ 0x1 );
+          return output_lit + on_off;
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  std::optional<uint32_t> find_xor()
+  {
+    /* collect XOR-type pairs (d1 ^ d2) & off = 0 or ~(d1 ^ d2) & on = 0, selecting d1, d2 from binate_divs */
+    for ( auto i = 0u; i < binate_divs.size(); ++i )
+    {
+      for ( auto j = i + 1; j < binate_divs.size(); ++j )
+      {
+        auto const tt_xor = get_div( binate_divs[i] ) ^ get_div( binate_divs[j] );
+        bool unateness[4] = { false, false, false, false };
+        /* check intersection with off-set; additionally check intersection with on-set is not empty (otherwise it's useless) */
+        if ( kitty::intersection_is_empty<TT, 1, 1>( tt_xor, on_off_sets[0] ) && !kitty::intersection_is_empty<TT, 1, 1>( tt_xor, on_off_sets[1] ) )
+        {
+          pos_unate_pairs.emplace_back( binate_divs[i] << 1, binate_divs[j] << 1, true );
+          unateness[0] = true;
+        }
+        if ( kitty::intersection_is_empty<TT, 0, 1>( tt_xor, on_off_sets[0] ) && !kitty::intersection_is_empty<TT, 0, 1>( tt_xor, on_off_sets[1] ) )
+        {
+          pos_unate_pairs.emplace_back( ( binate_divs[i] << 1 ) + 1, binate_divs[j] << 1, true );
+          unateness[1] = true;
+        }
+
+        /* check intersection with on-set; additionally check intersection with off-set is not empty (otherwise it's useless) */
+        if ( kitty::intersection_is_empty<TT, 1, 1>( tt_xor, on_off_sets[1] ) && !kitty::intersection_is_empty<TT, 1, 1>( tt_xor, on_off_sets[0] ) )
+        {
+          neg_unate_pairs.emplace_back( binate_divs[i] << 1, binate_divs[j] << 1, true );
+          unateness[2] = true;
+        }
+        if ( kitty::intersection_is_empty<TT, 0, 1>( tt_xor, on_off_sets[1] ) && !kitty::intersection_is_empty<TT, 0, 1>( tt_xor, on_off_sets[0] ) )
+        {
+          neg_unate_pairs.emplace_back( ( binate_divs[i] << 1 ) + 1, binate_divs[j] << 1, true );
+          unateness[3] = true;
+        }
+
+        if ( unateness[0] && unateness[2] )
+        {
+          return index_list.add_xor( ( binate_divs[i] << 1 ), ( binate_divs[j] << 1 ) );
+        }
+        if ( unateness[1] && unateness[3] )
+        {
+          return index_list.add_xor( ( binate_divs[i] << 1 ) + 1, ( binate_divs[j] << 1 ) );
+        }
+      }
+    }
+
+    return std::nullopt;
+  }
+
+  /* collect AND-type pairs (d1 & d2) & off = 0 or ~(d1 & d2) & on = 0, selecting d1, d2 from binate_divs */
+  void collect_unate_pairs()
+  {
+    for ( auto i = 0u; i < binate_divs.size(); ++i )
+    {
+      for ( auto j = i + 1; j < binate_divs.size(); ++j )
+      {
+        collect_unate_pairs_detail<1, 1>( binate_divs[i], binate_divs[j] );
+        collect_unate_pairs_detail<0, 1>( binate_divs[i], binate_divs[j] );
+        collect_unate_pairs_detail<1, 0>( binate_divs[i], binate_divs[j] );
+        collect_unate_pairs_detail<0, 0>( binate_divs[i], binate_divs[j] );
+      }
+    }
+  }
+
+  template<bool pol1, bool pol2>
+  void collect_unate_pairs_detail( uint32_t div1, uint32_t div2 )
+  {
+    /* check intersection with off-set; additionally check intersection with on-set is not empty (otherwise it's useless) */
+    if ( kitty::intersection_is_empty<TT, pol1, pol2>( get_div( div1 ), get_div( div2 ), on_off_sets[0] ) && !kitty::intersection_is_empty<TT, pol1, pol2>( get_div( div1 ), get_div( div2 ), on_off_sets[1] ) )
+    {
+      pos_unate_pairs.emplace_back( ( div1 << 1 ) + (uint32_t)( !pol1 ), ( div2 << 1 ) + (uint32_t)( !pol2 ) );
+    }
+    /* check intersection with on-set; additionally check intersection with off-set is not empty (otherwise it's useless) */
+    else if ( kitty::intersection_is_empty<TT, pol1, pol2>( get_div( div1 ), get_div( div2 ), on_off_sets[1] ) && !kitty::intersection_is_empty<TT, pol1, pol2>( get_div( div1 ), get_div( div2 ), on_off_sets[0] ) )
+    {
+      neg_unate_pairs.emplace_back( ( div1 << 1 ) + (uint32_t)( !pol1 ), ( div2 << 1 ) + (uint32_t)( !pol2 ) );
+    }
+  }
+
+  inline TT const& get_div( uint32_t idx ) const
+  {
+    if constexpr ( static_params::copy_tts )
+    {
+      return divisors[idx];
+    }
+    else
+    {
+      return ( *ptts )[divisors[idx]];
+    }
+  }
+
+private:
+  std::array<TT, 2> on_off_sets;
+  std::array<uint32_t, 2> num_bits; /* number of bits in on-set and off-set */
+
+  const typename static_params::truth_table_storage_type* ptts;
+  std::vector<std::conditional_t<static_params::copy_tts, TT, typename static_params::node_type>> divisors;
+
+  index_list_t index_list;
+
+  /* positive unate: not overlapping with off-set
+     negative unate: not overlapping with on-set */
+  std::vector<unate_lit> pos_unate_lits, neg_unate_lits;
+  std::vector<uint32_t> binate_divs;
+  std::vector<fanin_pair> pos_unate_pairs, neg_unate_pairs;
+
+  stats& st;
+}; /* xag_resyn_decompose */
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/retiming.hpp b/include/mockturtle/algorithms/retiming.hpp
new file mode 100644
index 0000000..7cb0704
--- /dev/null
+++ b/include/mockturtle/algorithms/retiming.hpp
@@ -0,0 +1,808 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file retiming.hpp
+  \brief Retiming
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <limits>
+
+#include "../utils/node_map.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../views/fanout_view.hpp"
+#include "../views/topo_view.hpp"
+#include <fmt/format.h>
+
+namespace mockturtle
+{
+/*! \brief Parameters for retiming.
+ *
+ * The data structure `retime_params` holds configurable parameters
+ * with default arguments for `retime`.
+ */
+struct retime_params
+{
+  /*! \brief Do forward only retiming. */
+  bool forward_only{ false };
+
+  /*! \brief Do backward only retiming. */
+  bool backward_only{ false };
+
+  /*! \brief Retiming max iterations. */
+  uint32_t iterations{ UINT32_MAX };
+
+  /*! \brief Be verbose */
+  bool verbose{ false };
+};
+
+/*! \brief Statistics for retiming.
+ *
+ * The data structure `retime_stats` provides data collected by running
+ * `retime`.
+ */
+struct retime_stats
+{
+  /*! \brief Initial number of registers. */
+  uint32_t registers_pre{ 0 };
+
+  /*! \brief Number of registers after retime. */
+  uint32_t registers_post{ 0 };
+
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  void report() const
+  {
+    std::cout << fmt::format( "[i] Initial registers = {:7d}\t Final registers = {:7d}\n", registers_pre, registers_post );
+    std::cout << fmt::format( "[i] Total runtime   = {:>5.2f} secs\n", to_seconds( time_total ) );
+  }
+};
+
+namespace detail
+{
+
+template<class Ntk>
+class retime_impl
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  static constexpr uint32_t sink_node = UINT32_MAX;
+
+public:
+  explicit retime_impl( Ntk& ntk, retime_params const& ps, retime_stats& st )
+      : _ntk( ntk ),
+        _ps( ps ),
+        _st( st ),
+        _flow_path( ntk )
+  {}
+
+public:
+  void run()
+  {
+    stopwatch t( _st.time_total );
+
+    _st.registers_pre = _ntk.num_registers();
+
+    if ( !_ps.backward_only )
+    {
+      bool improvement = true;
+      for ( auto i = 0; i < _ps.iterations && improvement == true; ++i )
+      {
+        improvement = retime_area<true>( i + 1 );
+      }
+    }
+
+    if ( !_ps.forward_only )
+    {
+      bool improvement = true;
+      for ( auto i = 0; i < _ps.iterations && improvement == true; ++i )
+      {
+        improvement = retime_area<false>( i + 1 );
+      }
+    }
+
+    _st.registers_post = _ntk.num_registers();
+  }
+
+private:
+  template<bool forward>
+  bool retime_area( uint32_t iteration )
+  {
+    auto const num_registers_pre = _ntk.num_registers();
+
+    init_values<forward>();
+
+    auto min_cut = max_flow<forward>( iteration );
+
+    if ( _ps.verbose )
+    {
+      float register_improvement = ( (float)num_registers_pre - min_cut.size() ) / num_registers_pre * 100;
+      std::cout << fmt::format( "[i] Retiming {}\t pre = {:7d}\t post = {:7d}\t improvement = {:>5.2f}%\n",
+                                forward ? "forward" : "backward", num_registers_pre, min_cut.size(), register_improvement );
+    }
+
+    if ( min_cut.size() >= num_registers_pre )
+      return false;
+
+    /* move registers */
+    update_registers_position<forward>( min_cut, iteration );
+
+    return true;
+  }
+
+  template<bool forward>
+  std::vector<node> max_flow( uint32_t iteration )
+  {
+    uint32_t flow = 0;
+
+    _flow_path.reset();
+    _ntk.incr_trav_id();
+
+    /* run max flow from each register (capacity 1) */
+    _ntk.foreach_register( [&]( auto const& n ) {
+      uint32_t local_flow;
+      if constexpr ( forward )
+      {
+        local_flow = max_flow_forwards_compute_rec( _ntk.fanout( n )[0] );
+      }
+      else
+      {
+        node fanin = _ntk.get_node( _ntk.get_fanin0( n ) );
+        local_flow = max_flow_backwards_compute_rec( fanin );
+      }
+
+      flow += local_flow;
+
+      if ( local_flow )
+        _ntk.incr_trav_id();
+
+      return true;
+    } );
+
+    /* run reachability */
+    _ntk.incr_trav_id();
+    _ntk.foreach_register( [&]( auto const& n ) {
+      uint32_t local_flow;
+      if constexpr ( forward )
+      {
+        local_flow = max_flow_forwards_compute_rec( _ntk.fanout( n )[0] );
+      }
+      else
+      {
+        node fanin = _ntk.get_node( _ntk.get_fanin0( n ) );
+        local_flow = max_flow_backwards_compute_rec( fanin );
+      }
+
+      assert( local_flow == 0 );
+      return true;
+    } );
+
+    auto min_cut = get_min_cut();
+
+    // assert( check_min_cut<forward>( min_cut, iteration ) );
+
+    legalize_retiming<forward>( min_cut, iteration );
+
+    return min_cut;
+  }
+
+  uint32_t max_flow_forwards_compute_rec( node const& n )
+  {
+    uint32_t found_path = 0;
+
+    if ( _ntk.visited( n ) == _ntk.trav_id() )
+      return 0;
+
+    _ntk.set_visited( n, _ntk.trav_id() );
+
+    /* node is not in a flow path */
+    if ( _flow_path[n] == 0 )
+    {
+      /* cut boundary (sink) */
+      if ( _ntk.value( n ) )
+      {
+        _flow_path[n] = sink_node;
+        return 1;
+      }
+
+      _ntk.foreach_fanout( n, [&]( auto const& f ) {
+        /* there is a path for flow */
+        if ( max_flow_forwards_compute_rec( f ) )
+        {
+          _flow_path[n] = _ntk.node_to_index( f );
+          found_path = 1;
+          return false;
+        }
+        return true;
+      } );
+
+      return found_path;
+    }
+
+    /* path has flow already, find alternative path from fanin with flow */
+    node fanin_flow = 0;
+    _ntk.foreach_fanin( n, [&]( auto const& f ) {
+      if ( _ntk.is_constant( _ntk.get_node( f ) ) )
+        return true;
+      if ( _flow_path[f] == _ntk.node_to_index( n ) )
+      {
+        fanin_flow = _ntk.get_node( f );
+        return false;
+      }
+      return true;
+    } );
+
+    if ( fanin_flow == 0 )
+      return 0;
+
+    /* augment path */
+    _ntk.foreach_fanout( fanin_flow, [&]( auto const& f ) {
+      /* there is a path for flow */
+      if ( max_flow_forwards_compute_rec( f ) )
+      {
+        _flow_path[fanin_flow] = _ntk.node_to_index( f );
+        found_path = 1;
+        return false;
+      }
+      return true;
+    } );
+
+    if ( found_path )
+      return 1;
+
+    if ( max_flow_forwards_compute_rec( fanin_flow ) )
+    {
+      _flow_path[fanin_flow] = 0;
+      return 1;
+    }
+
+    return 0;
+  }
+
+  uint32_t max_flow_backwards_compute_rec( node const& n )
+  {
+    uint32_t found_path = 0;
+
+    if ( _ntk.visited( n ) == _ntk.trav_id() )
+      return 0;
+
+    _ntk.set_visited( n, _ntk.trav_id() );
+
+    /* node is not in a flow path */
+    if ( _flow_path[n] == 0 )
+    {
+      /* cut boundary (sink) */
+      if ( _ntk.value( n ) )
+      {
+        _flow_path[n] = sink_node;
+        return 1;
+      }
+
+      _ntk.foreach_fanin( n, [&]( auto const& f ) {
+        if ( _ntk.is_constant( _ntk.get_node( f ) ) )
+          return true;
+        /* there is a path for flow */
+        if ( max_flow_backwards_compute_rec( _ntk.get_node( f ) ) )
+        {
+          _flow_path[n] = _ntk.node_to_index( _ntk.get_node( f ) );
+          found_path = 1;
+          return false;
+        }
+        return true;
+      } );
+
+      return found_path;
+    }
+
+    /* path has flow already, find alternative path from fanout with flow */
+    node fanout_flow = 0;
+    _ntk.foreach_fanout( n, [&]( auto const& f ) {
+      if ( _flow_path[f] == _ntk.node_to_index( n ) )
+      {
+        fanout_flow = _ntk.get_node( f );
+        return false;
+      }
+      return true;
+    } );
+
+    if ( fanout_flow == 0 )
+      return 0;
+
+    /* augment path */
+    _ntk.foreach_fanin( fanout_flow, [&]( auto const& f ) {
+      if ( _ntk.is_constant( _ntk.get_node( f ) ) )
+        return true;
+      /* there is a path for flow */
+      if ( max_flow_backwards_compute_rec( _ntk.get_node( f ) ) )
+      {
+        _flow_path[fanout_flow] = _ntk.node_to_index( _ntk.get_node( f ) );
+        found_path = 1;
+        return false;
+      }
+      return true;
+    } );
+
+    if ( found_path )
+      return 1;
+
+    if ( max_flow_backwards_compute_rec( fanout_flow ) )
+    {
+      _flow_path[fanout_flow] = 0;
+      return 1;
+    }
+
+    return 0;
+  }
+
+  std::vector<node> get_min_cut()
+  {
+    std::vector<node> min_cut;
+    min_cut.reserve( _ntk.num_registers() );
+
+    _ntk.foreach_node( [&]( auto const& n ) {
+      if ( _flow_path[n] == 0 )
+        return true;
+      if ( _ntk.visited( n ) != _ntk.trav_id() )
+        return true;
+
+      if ( _ntk.value( n ) || _ntk.visited( _flow_path[n] ) != _ntk.trav_id() )
+        min_cut.push_back( n );
+      return true;
+    } );
+
+    return min_cut;
+  }
+
+  template<bool forward>
+  void legalize_retiming( std::vector<node>& min_cut, uint32_t iteration )
+  {
+    _ntk.clear_values();
+
+    _ntk.foreach_register( [&]( auto const& n ) {
+      _ntk.set_value( _ntk.fanout( n )[0], 1 );
+    } );
+
+    for ( auto const& n : min_cut )
+    {
+      rec_mark_tfi( n );
+    }
+
+    min_cut.clear();
+
+    if constexpr ( forward )
+    {
+      _ntk.foreach_gate( [&]( auto const& n ) {
+        if ( _ntk.value( n ) == 1 )
+        {
+          /* if is sink or before a register */
+          _ntk.foreach_fanout( n, [&]( auto const& f ) {
+            if ( _ntk.value( f ) != 1 )
+            {
+              min_cut.push_back( n );
+              return false;
+            }
+            return true;
+          } );
+        }
+      } );
+    }
+    else
+    {
+      _ntk.incr_trav_id();
+      _ntk.foreach_register( [&]( auto const& n ) {
+        node fanin = _ntk.get_node( _ntk.get_fanin0( n ) );
+        collect_cut_nodes_tfi( fanin, min_cut );
+        return true;
+      } );
+      _ntk.foreach_node( [&]( auto const& n ) {
+        if ( _ntk.visited( n ) == _ntk.trav_id() )
+          _ntk.set_value( n, 1 );
+        else
+          _ntk.set_value( n, 0 );
+      } );
+      for ( auto const& n : min_cut )
+        _ntk.set_value( n, 0 );
+    }
+  }
+
+  void collect_cut_nodes_tfi( node const& n, std::vector<node>& min_cut )
+  {
+    if ( _ntk.visited( n ) == _ntk.trav_id() )
+      return;
+
+    _ntk.set_visited( n, _ntk.trav_id() );
+
+    if ( _ntk.value( n ) )
+    {
+      min_cut.push_back( n );
+      return;
+    }
+
+    _ntk.foreach_fanin( n, [&]( auto const& f ) {
+      if ( _ntk.is_constant( _ntk.get_node( f ) ) )
+        return;
+      collect_cut_nodes_tfi( _ntk.get_node( f ), min_cut );
+    } );
+  }
+
+  template<bool forward>
+  void init_values()
+  {
+    _ntk.clear_values();
+
+    /* marks the frontiers */
+    if constexpr ( forward )
+    {
+      /* mark POs as sink */
+      _ntk.foreach_po( [&]( auto const& f ) {
+        _ntk.set_value( _ntk.get_node( f ), 1 );
+      } );
+
+      /* mark registers as sink */
+      _ntk.foreach_register( [&]( auto const& n ) {
+        _ntk.set_value( n, 1 );
+        _ntk.foreach_fanin( n, [&]( auto const& f ) {
+          if ( _ntk.is_constant( _ntk.get_node( f ) ) )
+            return;
+          _ntk.set_value( _ntk.get_node( f ), 1 );
+        } );
+      } );
+
+      /* exclude reachable nodes from PIs from retiming */
+      _ntk.foreach_pi( [&]( auto const& n ) {
+        rec_mark_tfo( n );
+      } );
+
+      /* mark childrens of marked nodes */
+      std::vector<node> to_mark;
+      to_mark.reserve( 200 );
+      _ntk.foreach_gate( [&]( auto const& n ) {
+        if ( _ntk.value( n ) == 1 )
+        {
+          _ntk.foreach_fanin( n, [&]( auto const& f ) {
+            if ( _ntk.is_constant( _ntk.get_node( f ) ) )
+              return;
+            if ( _ntk.value( _ntk.get_node( f ) ) == 0 )
+              to_mark.push_back( _ntk.get_node( f ) );
+          } );
+        }
+      } );
+      for ( auto const& n : to_mark )
+      {
+        _ntk.set_value( n, 1 );
+      }
+    }
+    else
+    {
+      /* mark PIs as sink */
+      _ntk.foreach_pi( [&]( auto const& n ) {
+        _ntk.set_value( n, 1 );
+      } );
+
+      /* mark registers as sink */
+      _ntk.foreach_register( [&]( auto const& n ) {
+        _ntk.set_value( n, 1 );
+        _ntk.foreach_fanout( n, [&]( auto const& f ) {
+          _ntk.set_value( f, 1 );
+        } );
+      } );
+
+      /* exclude reachable nodes from POs from retiming */
+      _ntk.foreach_po( [&]( auto const& f ) {
+        rec_mark_tfi( _ntk.get_node( f ) );
+      } );
+    }
+  }
+
+  template<bool forward>
+  void update_registers_position( std::vector<node> const& min_cut, uint32_t iteration )
+  {
+    _ntk.incr_trav_id();
+
+    /* create new registers and mark the ones to reuse */
+    for ( auto const& n : min_cut )
+    {
+      if constexpr ( forward )
+      {
+        if ( _ntk.is_box_output( n ) )
+        {
+          /* reuse the current register */
+          auto node_register = _ntk.get_node( _ntk.get_fanin0( n ) );
+          auto in_register = _ntk.get_node( _ntk.get_fanin0( node_register ) );
+          auto in_in_register = _ntk.get_node( _ntk.get_fanin0( in_register ) );
+
+          /* check for marked fanouts to connect to register input */
+          auto fanout = _ntk.fanout( n );
+          for ( auto const& f : fanout )
+          {
+            if ( _ntk.value( f ) )
+            {
+              _ntk.replace_in_node( f, n, in_in_register );
+              _ntk.decr_fanout_size( n );
+            }
+          }
+
+          _ntk.set_visited( node_register, _ntk.trav_id() );
+        }
+        else
+        {
+          /* create a new register */
+          auto const in_register = _ntk.create_box_input( _ntk.make_signal( n ) );
+          auto const node_register = _ntk.create_register( in_register );
+          auto const node_register_out = _ntk.create_box_output( node_register );
+
+          /* replace in n fanout */
+          auto fanout = _ntk.fanout( n );
+          for ( auto const& f : fanout )
+          {
+            if ( f != _ntk.get_node( in_register ) && !_ntk.value( f ) )
+            {
+              _ntk.replace_in_node( f, n, node_register_out );
+              _ntk.decr_fanout_size( n );
+            }
+          }
+
+          _ntk.set_visited( _ntk.get_node( node_register ), _ntk.trav_id() );
+        }
+      }
+      else
+      {
+        if ( _ntk.is_box_input( n ) )
+        {
+          _ntk.foreach_fanout( n, [&]( auto const& f ) {
+            _ntk.set_visited( f, _ntk.trav_id() );
+          } );
+        }
+        else
+        {
+          /* create a new register */
+          auto const in_register = _ntk.create_box_input( _ntk.make_signal( n ) );
+          auto const node_register = _ntk.create_register( in_register );
+          auto const node_register_out = _ntk.create_box_output( node_register );
+
+          /* replace in n fanout */
+          auto fanout = _ntk.fanout( n );
+          for ( auto const& f : fanout )
+          {
+            if ( f != _ntk.get_node( in_register ) && _ntk.value( f ) )
+            {
+              _ntk.replace_in_node( f, n, node_register_out );
+              _ntk.decr_fanout_size( n );
+            }
+          }
+
+          _ntk.set_visited( _ntk.get_node( node_register ), _ntk.trav_id() );
+        }
+      }
+    }
+
+    /* remove retimed registers */
+    _ntk.foreach_register( [&]( auto const& n ) {
+      if ( _ntk.visited( n ) == _ntk.trav_id() )
+        return true;
+
+      node node_register_out;
+      node node_register_in = _ntk.get_node( _ntk.get_fanin0( n ) );
+      signal node_register_in_in = _ntk.get_fanin0( node_register_in );
+
+      _ntk.foreach_fanout( n, [&]( auto const& f ) {
+        node_register_out = f;
+      } );
+
+      auto node_register_fanout = _ntk.fanout_size( node_register_out );
+      auto fanin_fanout = _ntk.fanout_size( _ntk.get_node( node_register_in_in ) );
+      auto fanin_type = _ntk.is_box_output( _ntk.get_node( node_register_in_in ) );
+
+      _ntk.substitute_node( node_register_out, node_register_in_in );
+
+      return true;
+    } );
+  }
+
+  void rec_mark_tfo( node const& n )
+  {
+    if ( _ntk.value( n ) )
+      return;
+
+    _ntk.set_value( n, 1 );
+    _ntk.foreach_fanout( n, [&]( auto const& f ) {
+      rec_mark_tfo( f );
+    } );
+  }
+
+  void rec_mark_tfi( node const& n )
+  {
+    if ( _ntk.value( n ) )
+      return;
+
+    _ntk.set_value( n, 1 );
+    _ntk.foreach_fanin( n, [&]( auto const& f ) {
+      if ( _ntk.is_constant( _ntk.get_node( f ) ) )
+        return;
+      rec_mark_tfi( _ntk.get_node( f ) );
+    } );
+  }
+
+  template<bool forward>
+  bool check_min_cut( std::vector<node> const& min_cut, uint32_t iteration )
+  {
+    _ntk.incr_trav_id();
+
+    for ( node const& n : min_cut )
+    {
+      _ntk.set_visited( n, _ntk.trav_id() );
+    }
+
+    bool check = true;
+    _ntk.foreach_register( [&]( auto const& n ) {
+      if constexpr ( forward )
+      {
+        if ( !check_min_cut_rec<forward>( _ntk.fanout( n )[0] ) )
+          check = false;
+      }
+      else
+      {
+        node fanin = _ntk.get_node( _ntk.get_fanin0( n ) );
+        if ( !check_min_cut_rec<forward>( fanin ) )
+          check = false;
+      }
+
+      return check;
+    } );
+
+    return check;
+  }
+
+  template<bool forward>
+  bool check_min_cut_rec( node const& n )
+  {
+    bool check = true;
+
+    if ( _ntk.visited( n ) == _ntk.trav_id() )
+      return true;
+
+    _ntk.set_visited( n, _ntk.trav_id() );
+
+    if constexpr ( forward )
+    {
+      if ( _ntk.is_co( n ) )
+      {
+        check = false;
+        return false;
+      }
+
+      _ntk.foreach_fanout( n, [&]( auto const& f ) {
+        if ( !check_min_cut_rec<forward>( f ) )
+        {
+          check = false;
+        }
+      } );
+    }
+    else
+    {
+      if ( _ntk.is_ci( n ) )
+      {
+        check = false;
+        return false;
+      }
+
+      _ntk.foreach_fanin( n, [&]( auto const& f ) {
+        if ( _ntk.is_constant( _ntk.get_node( f ) ) )
+          return true;
+        if ( !check_min_cut_rec<forward>( _ntk.get_node( f ) ) )
+        {
+          check = false;
+        }
+        return check;
+      } );
+
+      return check;
+    }
+
+    return check;
+  }
+
+private:
+  Ntk& _ntk;
+  retime_params const& _ps;
+  retime_stats& _st;
+
+  node_map<uint32_t, Ntk> _flow_path;
+};
+
+} /* namespace detail */
+
+/*! \brief Retiming.
+ *
+ * This function implements a retiming algorithm for registers minimization.
+ * The only supported network type is the `generic_network`.
+ * The algorithm excecutes the retiming inplace.
+ * 
+ * Currently, only area-based retiming is implemented. Mixed register types
+ * such as (active high/low, rising/falling edge) are not supported yet.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `is_pi`
+ * - `is_constant`
+ * - `node_to_index`
+ * - `index_to_node`
+ * - `get_node`
+ * - `foreach_po`
+ * - `foreach_node`
+ * - `fanout_size`
+ * - `has_incr_value`
+ * - `has_decr_value`
+ * - `has_get_fanin0`
+ *
+ * \param ntk Network
+ * \param ps Retiming params
+ * \param pst Retiming statistics
+ *
+ * The implementation of this algorithm was inspired by the
+ * mapping command ``retime`` in ABC.
+ */
+template<class Ntk>
+void retime( Ntk& ntk, retime_params const& ps = {}, retime_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_incr_value_v<Ntk>, "Ntk does not implement the incr_value method" );
+  static_assert( has_decr_value_v<Ntk>, "Ntk does not implement the decr_value method" );
+  static_assert( has_get_fanin0_v<Ntk>, "Ntk does not implement the get_fanin0 method" );
+
+  retime_stats st;
+
+  using fanout_view_t = fanout_view<Ntk>;
+  fanout_view_t fanout_view{ ntk };
+
+  detail::retime_impl p( fanout_view, ps, st );
+  p.run();
+
+  if ( ps.verbose )
+    st.report();
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/rewrite.hpp b/include/mockturtle/algorithms/rewrite.hpp
new file mode 100644
index 0000000..e515dae
--- /dev/null
+++ b/include/mockturtle/algorithms/rewrite.hpp
@@ -0,0 +1,953 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file rewrite.hpp
+  \brief Inplace rewrite
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+#include "../utils/cost_functions.hpp"
+#include "../utils/node_map.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../views/color_view.hpp"
+#include "../views/depth_view.hpp"
+#include "../views/fanout_view.hpp"
+#include "../views/window_view.hpp"
+#include "cleanup.hpp"
+#include "cut_enumeration.hpp"
+#include "cut_enumeration/rewrite_cut.hpp"
+#include "reconv_cut.hpp"
+#include "simulation.hpp"
+
+#include <fmt/format.h>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/npn.hpp>
+#include <kitty/operations.hpp>
+#include <kitty/static_truth_table.hpp>
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for Rewrite.
+ *
+ * The data structure `rewrite_params` holds configurable parameters with
+ * default arguments for `rewrite`.
+ */
+struct rewrite_params
+{
+  rewrite_params()
+  {
+    /* 0 < Cut limit < 16 */
+    cut_enumeration_ps.cut_limit = 8;
+    cut_enumeration_ps.minimize_truth_table = true;
+  }
+
+  /*! \brief Cut enumeration parameters. */
+  cut_enumeration_params cut_enumeration_ps{};
+
+  /*! \brief If true, candidates are only accepted if they do not increase logic depth. */
+  bool preserve_depth{ false };
+
+  /*! \brief Allow rewrite with multiple structures */
+  bool allow_multiple_structures{ true };
+
+  /*! \brief Allow zero-gain substitutions */
+  bool allow_zero_gain{ false };
+
+  /*! \brief Use satisfiability don't cares for optimization. */
+  bool use_dont_cares{ false };
+
+  /*! \brief Window size for don't cares calculation. */
+  uint32_t window_size{ 8u };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+};
+
+/*! \brief Statistics for rewrite.
+ *
+ * The data structure `rewrite_stats` provides data collected by running
+ * `rewrite`.
+ */
+struct rewrite_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Expected gain. */
+  uint32_t estimated_gain{ 0 };
+
+  /*! \brief Candidates */
+  uint32_t candidates{ 0 };
+
+  void report() const
+  {
+    std::cout << fmt::format( "[i] total time       = {:>5.2f} secs\n", to_seconds( time_total ) );
+  }
+};
+
+namespace detail
+{
+
+template<class Ntk, class Library, class NodeCostFn>
+class rewrite_impl
+{
+  static constexpr uint32_t num_vars = 4u;
+  static constexpr uint32_t max_window_size = 8u;
+  using network_cuts_t = dynamic_network_cuts<Ntk, num_vars, true, cut_enumeration_rewrite_cut>;
+  using cut_manager_t = detail::dynamic_cut_enumeration_impl<Ntk, num_vars, true, cut_enumeration_rewrite_cut>;
+  using cut_t = typename network_cuts_t::cut_t;
+  using node_data = typename Ntk::storage::element_type::node_type;
+
+public:
+  rewrite_impl( Ntk& ntk, Library&& library, rewrite_params const& ps, rewrite_stats& st, NodeCostFn const& cost_fn )
+      : ntk( ntk ), library( library ), ps( ps ), st( st ), cost_fn( cost_fn ), required( ntk, UINT32_MAX )
+  {
+    register_events();
+  }
+
+  ~rewrite_impl()
+  {
+    if constexpr ( has_level_v<Ntk> )
+    {
+      ntk.events().release_add_event( add_event );
+      ntk.events().release_modified_event( modified_event );
+      ntk.events().release_delete_event( delete_event );
+    }
+  }
+
+  void run()
+  {
+    stopwatch t( st.time_total );
+
+    ntk.incr_trav_id();
+
+    if ( ps.preserve_depth )
+    {
+      compute_required();
+    }
+
+    if ( ps.use_dont_cares )
+      perform_rewriting_dc();
+    else
+      perform_rewriting();
+
+    st.estimated_gain = _estimated_gain;
+    st.candidates = _candidates;
+  }
+
+private:
+  void perform_rewriting()
+  {
+    /* initialize the cut manager */
+    cut_enumeration_stats cst;
+    network_cuts_t cuts( ntk.size() + ( ntk.size() >> 1 ) );
+    cut_manager_t cut_manager( ntk, ps.cut_enumeration_ps, cst, cuts );
+
+    /* initialize cuts for constant nodes and PIs */
+    cut_manager.init_cuts();
+
+    auto& db = library.get_database();
+
+    std::array<signal<Ntk>, num_vars> leaves;
+    std::array<signal<Ntk>, num_vars> best_leaves;
+    std::array<uint8_t, num_vars> permutation;
+    signal<Ntk> best_signal;
+
+    const auto size = ntk.size();
+    ntk.foreach_gate( [&]( auto const& n, auto i ) {
+      if ( ntk.fanout_size( n ) == 0u )
+        return;
+
+      int32_t best_gain = -1;
+      uint32_t best_level = UINT32_MAX;
+      bool best_phase = false;
+
+      /* update level for node */
+      if constexpr ( has_level_v<Ntk> )
+      {
+        if ( ps.preserve_depth )
+        {
+          uint32_t level = 0;
+          ntk.foreach_fanin( n, [&]( auto const& f ) {
+            level = std::max( level, ntk.level( ntk.get_node( f ) ) );
+          } );
+          ntk.set_level( n, level + 1 );
+          best_level = level + 1;
+        }
+      }
+
+      cut_manager.clear_cuts( n );
+      cut_manager.compute_cuts( n );
+
+      uint32_t cut_index = 0;
+      for ( auto& cut : cuts.cuts( ntk.node_to_index( n ) ) )
+      {
+        /* skip trivial cut */
+        if ( ( cut->size() == 1 && *cut->begin() == ntk.node_to_index( n ) ) )
+        {
+          ++cut_index;
+          continue;
+        }
+
+        /* Boolean matching */
+        auto config = kitty::exact_npn_canonization( cuts.truth_table( *cut ) );
+        auto tt_npn = std::get<0>( config );
+        auto neg = std::get<1>( config );
+        auto perm = std::get<2>( config );
+
+        auto const structures = library.get_supergates( tt_npn );
+
+        if ( structures == nullptr )
+        {
+          ++cut_index;
+          continue;
+        }
+
+        uint32_t negation = 0;
+        for ( auto j = 0u; j < num_vars; ++j )
+        {
+          permutation[perm[j]] = j;
+          negation |= ( ( neg >> perm[j] ) & 1 ) << j;
+        }
+
+        /* save output negation to apply */
+        bool phase = ( neg >> num_vars == 1 ) ? true : false;
+
+        {
+          auto j = 0u;
+          for ( auto const leaf : *cut )
+          {
+            leaves[permutation[j++]] = ntk.make_signal( ntk.index_to_node( leaf ) );
+          }
+
+          while ( j < num_vars )
+            leaves[permutation[j++]] = ntk.get_constant( false );
+        }
+
+        for ( auto j = 0u; j < num_vars; ++j )
+        {
+          if ( ( negation >> j ) & 1 )
+          {
+            leaves[j] = !leaves[j];
+          }
+        }
+
+        {
+          /* measure the MFFC contained in the cut */
+          int32_t mffc_size = measure_mffc_deref( n, cut );
+
+          for ( auto const& dag : *structures )
+          {
+            auto [nodes_added, level] = evaluate_entry( n, db.get_node( dag.root ), leaves );
+            int32_t gain = mffc_size - nodes_added;
+
+            /* discard if dag.root and n are the same */
+            if ( ntk.node_to_index( n ) == db.value( db.get_node( dag.root ) ) >> 1 )
+              continue;
+
+            /* discard if no gain */
+            if ( gain < 0 || ( !ps.allow_zero_gain && gain == 0 ) )
+              continue;
+
+            /* discard if level increases */
+            if constexpr ( has_level_v<Ntk> )
+            {
+              if ( ps.preserve_depth && level > required[n] )
+                continue;
+            }
+
+            if ( ( gain > best_gain ) || ( gain == best_gain && level < best_level ) )
+            {
+              ++_candidates;
+              best_gain = gain;
+              best_signal = dag.root;
+              best_leaves = leaves;
+              best_phase = phase;
+              best_level = level;
+            }
+
+            if ( !ps.allow_multiple_structures )
+              break;
+          }
+
+          /* restore contained MFFC */
+          measure_mffc_ref( n, cut );
+          ++cut_index;
+
+          if ( cut->size() == 0 || ( cut->size() == 1 && *cut->begin() != ntk.node_to_index( n ) ) )
+            break;
+        }
+      }
+
+      if ( best_gain > 0 || ( ps.allow_zero_gain && best_gain == 0 ) )
+      {
+        /* replace node wth the new structure */
+        topo_view topo{ db, best_signal };
+        auto new_f = cleanup_dangling( topo, ntk, best_leaves.begin(), best_leaves.end() ).front();
+
+        assert( n != ntk.get_node( new_f ) );
+
+        _estimated_gain += best_gain;
+        ntk.substitute_node_no_restrash( n, new_f ^ best_phase );
+
+        if constexpr ( has_level_v<Ntk> )
+        {
+          /* propagate new required to leaves */
+          if ( ps.preserve_depth )
+          {
+            propagate_required_rec( ntk.node_to_index( n ), ntk.get_node( new_f ), size, required[n] );
+            assert( ntk.level( ntk.get_node( new_f ) ) <= required[n] );
+          }
+        }
+
+        clear_cuts_fanout_rec( cuts, cut_manager, ntk.get_node( new_f ) );
+      }
+    } );
+  }
+
+  void perform_rewriting_dc()
+  {
+    /* initialize the cut manager */
+    cut_enumeration_stats cst;
+    network_cuts_t cuts( ntk.size() + ( ntk.size() >> 1 ) );
+    cut_manager_t cut_manager( ntk, ps.cut_enumeration_ps, cst, cuts );
+
+    /* initialize cuts for constant nodes and PIs */
+    cut_manager.init_cuts();
+
+    auto& db = library.get_database();
+
+    std::array<signal<Ntk>, num_vars> leaves;
+    std::array<signal<Ntk>, num_vars> best_leaves;
+    std::array<uint8_t, num_vars> permutation;
+    signal<Ntk> best_signal;
+
+    reconvergence_driven_cut_parameters rps;
+    rps.max_leaves = ps.window_size;
+    reconvergence_driven_cut_statistics rst;
+    detail::reconvergence_driven_cut_impl<Ntk, false, has_level_v<Ntk>> reconv_cuts( ntk, rps, rst );
+    unordered_node_map<kitty::static_truth_table<max_window_size>, Ntk> tts( ntk );
+
+    color_view<Ntk> color_ntk{ ntk };
+    std::array<uint32_t, num_vars> divisors;
+    for ( uint32_t i = 0; i < num_vars; ++i )
+    {
+      divisors[i] = i;
+    }
+
+    const auto size = ntk.size();
+    ntk.foreach_gate( [&]( auto const& n, auto i ) {
+      if ( ntk.fanout_size( n ) == 0u )
+        return;
+
+      int32_t best_gain = -1;
+      uint32_t best_level = UINT32_MAX;
+      bool best_phase = false;
+
+      /* update level for node */
+      if constexpr ( has_level_v<Ntk> )
+      {
+        if ( ps.preserve_depth )
+        {
+          uint32_t level = 0;
+          ntk.foreach_fanin( n, [&]( auto const& f ) {
+            level = std::max( level, ntk.level( ntk.get_node( f ) ) );
+          } );
+          ntk.set_level( n, level + 1 );
+          best_level = level + 1;
+        }
+      }
+
+      cut_manager.clear_cuts( n );
+      cut_manager.compute_cuts( n );
+
+      /* compute window */
+      std::vector<node<Ntk>> roots = { n };
+      auto const extended_leaves = reconv_cuts.run( roots ).first;
+      std::vector<node<Ntk>> gates{ collect_nodes( color_ntk, extended_leaves, roots ) };
+      window_view window_ntk{ color_ntk, extended_leaves, roots, gates };
+
+      default_simulator<kitty::static_truth_table<max_window_size>> sim;
+      tts.reset();
+      simulate_nodes_with_node_map<kitty::static_truth_table<max_window_size>>( window_ntk, tts, sim );
+
+      uint32_t cut_index = 0;
+      for ( auto& cut : cuts.cuts( ntk.node_to_index( n ) ) )
+      {
+        /* skip trivial cut */
+        if ( ( cut->size() == 1 && *cut->begin() == ntk.node_to_index( n ) ) )
+        {
+          ++cut_index;
+          continue;
+        }
+
+        /* Boolean matching */
+        auto config = kitty::exact_npn_canonization( cuts.truth_table( *cut ) );
+        auto tt_npn = std::get<0>( config );
+        auto neg = std::get<1>( config );
+        auto perm = std::get<2>( config );
+
+        kitty::static_truth_table<num_vars> care;
+
+        bool containment = true;
+        for ( auto const& l : *cut )
+        {
+          if ( color_ntk.color( ntk.index_to_node( l ) ) != color_ntk.current_color() )
+          {
+            containment = false;
+            break;
+          }
+        }
+
+        if ( containment )
+        {
+          /* compute care set */
+          for ( auto i = 0u; i < ( 1u << window_ntk.num_pis() ); ++i )
+          {
+            uint32_t entry{ 0u };
+            auto j = 0u;
+            for ( auto const& l : *cut )
+            {
+              entry |= kitty::get_bit( tts[l], i ) << j;
+              ++j;
+            }
+            kitty::set_bit( care, entry );
+          }
+        }
+        else
+        {
+          /* completely specified */
+          care = ~care;
+        }
+
+        auto const dc_npn = apply_npn_transformation( ~care, neg & ~( 1 << num_vars ), perm );
+        auto const structures = library.get_supergates( tt_npn, dc_npn, neg, perm );
+
+        if ( structures == nullptr )
+        {
+          ++cut_index;
+          continue;
+        }
+
+        uint32_t negation = 0;
+        for ( auto j = 0u; j < num_vars; ++j )
+        {
+          permutation[perm[j]] = j;
+          negation |= ( ( neg >> perm[j] ) & 1 ) << j;
+        }
+
+        /* save output negation to apply */
+        bool phase = ( neg >> num_vars == 1 ) ? true : false;
+
+        {
+          auto j = 0u;
+          for ( auto const leaf : *cut )
+          {
+            leaves[permutation[j++]] = ntk.make_signal( ntk.index_to_node( leaf ) );
+          }
+
+          while ( j < num_vars )
+            leaves[permutation[j++]] = ntk.get_constant( false );
+        }
+
+        for ( auto j = 0u; j < num_vars; ++j )
+        {
+          if ( ( negation >> j ) & 1 )
+          {
+            leaves[j] = !leaves[j];
+          }
+        }
+
+        {
+          /* measure the MFFC contained in the cut */
+          int32_t mffc_size = measure_mffc_deref( n, cut );
+
+          for ( auto const& dag : *structures )
+          {
+            auto [nodes_added, level] = evaluate_entry( n, db.get_node( dag.root ), leaves );
+            int32_t gain = mffc_size - nodes_added;
+
+            /* discard if dag.root and n are the same */
+            if ( ntk.node_to_index( n ) == db.value( db.get_node( dag.root ) ) >> 1 )
+              continue;
+
+            /* discard if no gain */
+            if ( gain < 0 || ( !ps.allow_zero_gain && gain == 0 ) )
+              continue;
+
+            /* discard if level increases */
+            if constexpr ( has_level_v<Ntk> )
+            {
+              if ( ps.preserve_depth && level > required[n] )
+                continue;
+            }
+
+            if ( ( gain > best_gain ) || ( gain == best_gain && level < best_level ) )
+            {
+              ++_candidates;
+              best_gain = gain;
+              best_signal = dag.root;
+              best_leaves = leaves;
+              best_phase = phase;
+              best_level = level;
+            }
+
+            if ( !ps.allow_multiple_structures )
+              break;
+          }
+
+          /* restore contained MFFC */
+          measure_mffc_ref( n, cut );
+          ++cut_index;
+
+          if ( cut->size() == 0 || ( cut->size() == 1 && *cut->begin() != ntk.node_to_index( n ) ) )
+            break;
+        }
+      }
+
+      if ( best_gain > 0 || ( ps.allow_zero_gain && best_gain == 0 ) )
+      {
+        /* replace node wth the new structure */
+        topo_view topo{ db, best_signal };
+        auto new_f = cleanup_dangling( topo, ntk, best_leaves.begin(), best_leaves.end() ).front();
+
+        assert( n != ntk.get_node( new_f ) );
+
+        _estimated_gain += best_gain;
+        ntk.substitute_node_no_restrash( n, new_f ^ best_phase );
+
+        if constexpr ( has_level_v<Ntk> )
+        {
+          /* propagate new required to leaves */
+          if ( ps.preserve_depth )
+          {
+            propagate_required_rec( ntk.node_to_index( n ), ntk.get_node( new_f ), size, required[n] );
+            assert( ntk.level( ntk.get_node( new_f ) ) <= required[n] );
+          }
+        }
+
+        clear_cuts_fanout_rec( cuts, cut_manager, ntk.get_node( new_f ) );
+      }
+    } );
+  }
+
+  int32_t measure_mffc_ref( node<Ntk> const& n, cut_t const* cut )
+  {
+    /* reference cut leaves */
+    for ( auto leaf : *cut )
+    {
+      ntk.incr_fanout_size( ntk.index_to_node( leaf ) );
+    }
+
+    int32_t mffc_size = static_cast<int32_t>( recursive_ref( n ) );
+
+    /* dereference leaves */
+    for ( auto leaf : *cut )
+    {
+      ntk.decr_fanout_size( ntk.index_to_node( leaf ) );
+    }
+
+    return mffc_size;
+  }
+
+  int32_t measure_mffc_deref( node<Ntk> const& n, cut_t const* cut )
+  {
+    /* reference cut leaves */
+    for ( auto leaf : *cut )
+    {
+      ntk.incr_fanout_size( ntk.index_to_node( leaf ) );
+    }
+
+    int32_t mffc_size = static_cast<int32_t>( recursive_deref( n ) );
+
+    /* dereference leaves */
+    for ( auto leaf : *cut )
+    {
+      ntk.decr_fanout_size( ntk.index_to_node( leaf ) );
+    }
+
+    return mffc_size;
+  }
+
+  uint32_t recursive_deref( node<Ntk> const& n )
+  {
+    /* terminate? */
+    if ( ntk.is_constant( n ) || ntk.is_pi( n ) )
+      return 0;
+
+    /* recursively collect nodes */
+    uint32_t value{ cost_fn( ntk, n ) };
+    ntk.foreach_fanin( n, [&]( auto const& s ) {
+      if ( ntk.decr_fanout_size( ntk.get_node( s ) ) == 0 )
+      {
+        value += recursive_deref( ntk.get_node( s ) );
+      }
+    } );
+    return value;
+  }
+
+  uint32_t recursive_ref( node<Ntk> const& n )
+  {
+    /* terminate? */
+    if ( ntk.is_constant( n ) || ntk.is_pi( n ) )
+      return 0;
+
+    /* recursively collect nodes */
+    uint32_t value{ cost_fn( ntk, n ) };
+    ntk.foreach_fanin( n, [&]( auto const& s ) {
+      if ( ntk.incr_fanout_size( ntk.get_node( s ) ) == 0 )
+      {
+        value += recursive_ref( ntk.get_node( s ) );
+      }
+    } );
+    return value;
+  }
+
+  inline std::pair<int32_t, uint32_t> evaluate_entry( node<Ntk> const& current_root, node<Ntk> const& n, std::array<signal<Ntk>, num_vars> const& leaves )
+  {
+    auto& db = library.get_database();
+    db.incr_trav_id();
+
+    return evaluate_entry_rec( current_root, n, leaves );
+  }
+
+  std::pair<int32_t, uint32_t> evaluate_entry_rec( node<Ntk> const& current_root, node<Ntk> const& n, std::array<signal<Ntk>, num_vars> const& leaves )
+  {
+    auto& db = library.get_database();
+    if ( db.is_pi( n ) || db.is_constant( n ) )
+      return { 0, 0 };
+    if ( db.visited( n ) == db.trav_id() )
+      return { 0, 0 };
+
+    db.set_visited( n, db.trav_id() );
+
+    int32_t area = 0;
+    uint32_t level = 0;
+    bool hashed = true;
+
+    std::array<signal<Ntk>, Ntk::max_fanin_size> node_data;
+    db.foreach_fanin( n, [&]( auto const& f, auto i ) {
+      node<Ntk> g = db.get_node( f );
+      if ( db.is_constant( g ) )
+      {
+        node_data[i] = f; /* ntk.get_costant( db.is_complemented( f ) ) */
+        return;
+      }
+      if ( db.is_pi( g ) )
+      {
+        node_data[i] = leaves[db.node_to_index( g ) - 1] ^ db.is_complemented( f );
+        if constexpr ( has_level_v<Ntk> )
+        {
+          level = std::max( level, ntk.level( ntk.get_node( leaves[db.node_to_index( g ) - 1] ) ) );
+        }
+        return;
+      }
+
+      auto [area_rec, level_rec] = evaluate_entry_rec( current_root, g, leaves );
+      area += area_rec;
+      level = std::max( level, level_rec );
+
+      /* check value */
+      if ( db.value( g ) < UINT32_MAX )
+      {
+        signal<Ntk> s;
+        s.data = static_cast<uint64_t>( db.value( g ) );
+        node_data[i] = s ^ db.is_complemented( f );
+      }
+      else
+      {
+        hashed = false;
+      }
+    } );
+
+    if ( hashed )
+    {
+      /* try hash */
+      /* AIG, XAG, MIG, and XMG are supported now */
+      std::optional<signal<Ntk>> val;
+      do
+      {
+        /* XAG */
+        if constexpr ( has_has_and_v<Ntk> && has_has_xor_v<Ntk> )
+        {
+          if ( db.is_and( n ) )
+            val = ntk.has_and( node_data[0], node_data[1] );
+          else
+            val = ntk.has_xor( node_data[0], node_data[1] );
+          break;
+        }
+
+        /* AIG */
+        if constexpr ( has_has_and_v<Ntk> )
+        {
+          val = ntk.has_and( node_data[0], node_data[1] );
+          break;
+        }
+
+        /* XMG */
+        if constexpr ( has_has_maj_v<Ntk> && has_has_xor3_v<Ntk> )
+        {
+          if ( db.is_maj( n ) )
+            val = ntk.has_maj( node_data[0], node_data[1], node_data[2] );
+          else
+            val = ntk.has_xor3( node_data[0], node_data[1], node_data[2] );
+          break;
+        }
+
+        /* MAJ */
+        if constexpr ( has_has_maj_v<Ntk> )
+        {
+          val = ntk.has_maj( node_data[0], node_data[1], node_data[2] );
+          break;
+        }
+        std::cerr << "[e] Only AIGs, XAGs, MAJs, and XMGs are currently supported \n";
+      } while ( false );
+
+      if ( val.has_value() )
+      {
+        /* bad condition (current root is contained in the DAG): return a very high cost */
+        if ( db.get_node( *val ) == current_root )
+          return { UINT32_MAX / 2, level + 1 };
+
+        /* annotate hashing info */
+        db.set_value( n, val->data );
+        return { area + ( ntk.fanout_size( ntk.get_node( *val ) ) > 0 ? 0 : cost_fn( ntk, n ) ), level + 1 };
+      }
+    }
+
+    db.set_value( n, UINT32_MAX );
+    return { area + cost_fn( ntk, n ), level + 1 };
+  }
+
+  void compute_required()
+  {
+    if constexpr ( has_level_v<Ntk> )
+    {
+      ntk.foreach_po( [&]( auto const& f ) {
+        required[f] = ntk.depth();
+      } );
+
+      for ( uint32_t index = ntk.size() - 1; index > ntk.num_pis(); index-- )
+      {
+        node<Ntk> n = ntk.index_to_node( index );
+        uint32_t req = required[n];
+
+        ntk.foreach_fanin( n, [&]( auto const& f ) {
+          required[f] = std::min( required[f], req - 1 );
+        } );
+      }
+    }
+  }
+
+  void propagate_required_rec( uint32_t root, node<Ntk> const& n, uint32_t size, uint32_t req )
+  {
+    if ( ntk.is_constant( n ) || ntk.is_pi( n ) )
+      return;
+
+    /* recursively update required time */
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      auto const g = ntk.get_node( f );
+
+      /* recur if it is still a node to explore and to update */
+      if ( ntk.node_to_index( g ) > root && ( ntk.node_to_index( g ) >= size || required[g] > req ) )
+        propagate_required_rec( root, g, size, req - 1 );
+
+      /* update the required time */
+      if ( ntk.node_to_index( g ) < size )
+        required[g] = std::min( required[g], req - 1 );
+    } );
+  }
+
+  void clear_cuts_fanout_rec( network_cuts_t& cuts, cut_manager_t& cut_manager, node<Ntk> const& n )
+  {
+    ntk.foreach_fanout( n, [&]( auto const& g ) {
+      auto const index = ntk.node_to_index( g );
+      if ( cuts.cuts( index ).size() > 0 )
+      {
+        cut_manager.clear_cuts( g );
+        clear_cuts_fanout_rec( cuts, cut_manager, g );
+      }
+    } );
+  }
+
+private:
+  void register_events()
+  {
+    if constexpr ( has_level_v<Ntk> )
+    {
+      auto const update_level_of_new_node = [&]( const auto& n ) {
+        ntk.resize_levels();
+        update_node_level( n );
+      };
+
+      auto const update_level_of_existing_node = [&]( node<Ntk> const& n, const auto& old_children ) {
+        (void)old_children;
+        ntk.resize_levels();
+        update_node_level( n );
+      };
+
+      auto const update_level_of_deleted_node = [&]( node<Ntk> const& n ) {
+        ntk.set_level( n, -1 );
+      };
+
+      add_event = ntk.events().register_add_event( update_level_of_new_node );
+      modified_event = ntk.events().register_modified_event( update_level_of_existing_node );
+      delete_event = ntk.events().register_delete_event( update_level_of_deleted_node );
+    }
+  }
+
+  /* maybe it should be moved to depth_view */
+  void update_node_level( node<Ntk> const& n, bool top_most = true )
+  {
+    if constexpr ( has_level_v<Ntk> )
+    {
+      uint32_t curr_level = ntk.level( n );
+
+      uint32_t max_level = 0;
+      ntk.foreach_fanin( n, [&]( const auto& f ) {
+        auto const p = ntk.get_node( f );
+        auto const fanin_level = ntk.level( p );
+        if ( fanin_level > max_level )
+        {
+          max_level = fanin_level;
+        }
+      } );
+      ++max_level;
+
+      if ( curr_level != max_level )
+      {
+        ntk.set_level( n, max_level );
+
+        /* update only one more level */
+        if ( top_most )
+        {
+          ntk.foreach_fanout( n, [&]( const auto& p ) {
+            update_node_level( p, false );
+          } );
+        }
+      }
+    }
+  }
+
+private:
+  Ntk& ntk;
+  Library&& library;
+  rewrite_params const& ps;
+  rewrite_stats& st;
+  NodeCostFn cost_fn;
+
+  node_map<uint32_t, Ntk> required;
+
+  uint32_t _candidates{ 0 };
+  uint32_t _estimated_gain{ 0 };
+
+  /* events */
+  std::shared_ptr<typename network_events<Ntk>::add_event_type> add_event;
+  std::shared_ptr<typename network_events<Ntk>::modified_event_type> modified_event;
+  std::shared_ptr<typename network_events<Ntk>::delete_event_type> delete_event;
+};
+
+} /* namespace detail */
+
+/*! \brief Boolean rewrite.
+ *
+ * This algorithm rewrites enumerated cuts using new network structures from a database.
+ * The algorithm performs changes in-place and keeps the substituted structures dangling
+ * in the network.
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `size`
+ * - `make_signal`
+ * - `foreach_gate`
+ * - `substitute_node`
+ * - `clear_visited`
+ * - `clear_values`
+ * - `fanout_size`
+ * - `set_value`
+ * - `foreach_node`
+ *
+ * \param ntk Input network (will be changed in-place)
+ * \param library Exact library containing pre-computed structures
+ * \param ps Rewrite params
+ * \param pst Rewrite statistics
+ * \param cost_fn Node cost function (a functor with signature `uint32_t(Ntk const&, node<Ntk> const&)`)
+ */
+template<class Ntk, class Library, class NodeCostFn = unit_cost<Ntk>>
+void rewrite( Ntk& ntk, Library&& library, rewrite_params const& ps = {}, rewrite_stats* pst = nullptr, NodeCostFn const& cost_fn = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the substitute_node method" );
+  static_assert( has_clear_visited_v<Ntk>, "Ntk does not implement the clear_visited method" );
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+
+  rewrite_stats st;
+
+  if ( ps.preserve_depth || ps.use_dont_cares )
+  {
+    using depth_view_t = depth_view<Ntk, NodeCostFn>;
+    depth_view_t depth_ntk{ ntk };
+    using fanout_view_t = fanout_view<depth_view_t>;
+    fanout_view_t fanout_view{ depth_ntk };
+
+    detail::rewrite_impl<fanout_view_t, Library, NodeCostFn> p( fanout_view, library, ps, st, cost_fn );
+    p.run();
+  }
+  else
+  {
+    using fanout_view_t = fanout_view<Ntk>;
+    fanout_view_t fanout_view{ ntk };
+
+    detail::rewrite_impl<fanout_view_t, Library, NodeCostFn> p( fanout_view, library, ps, st, cost_fn );
+    p.run();
+  }
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+
+  ntk = cleanup_dangling( ntk );
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/satlut_mapping.hpp b/include/mockturtle/algorithms/satlut_mapping.hpp
new file mode 100644
index 0000000..fab0cca
--- /dev/null
+++ b/include/mockturtle/algorithms/satlut_mapping.hpp
@@ -0,0 +1,480 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file satlut_mapping.hpp
+  \brief SAT LUT mapping
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cmath>
+
+#include "../generators/sorting.hpp"
+#include "../utils/include/percy.hpp"
+#include "../utils/node_map.hpp"
+#include "../utils/progress_bar.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../views/topo_view.hpp"
+#include "cell_window.hpp"
+#include "cut_enumeration.hpp"
+#include "cut_enumeration/mf_cut.hpp"
+
+#include <fmt/format.h>
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for satlut_mapping.
+ *
+ * The data structure `satlut_mapping_params` holds configurable parameters with
+ * default arguments for `satlut_mapping`.
+ */
+struct satlut_mapping_params
+{
+  satlut_mapping_params()
+  {
+    cut_enumeration_ps.cut_size = 6;
+    cut_enumeration_ps.cut_limit = 8;
+  }
+
+  /*! \brief Parameters for cut enumeration
+   *
+   * The default cut size is 6, the default cut limit is 8.
+   */
+  cut_enumeration_params cut_enumeration_ps{};
+
+  /*! \brief Conflict limit for SAT solver.
+   *
+   * The default limit is 0, which means the number of conflicts is not used
+   * as a resource limit.
+   */
+  uint32_t conflict_limit{ 0u };
+
+  /*! \brief Show progress. */
+  bool progress{ false };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+
+  /*! \brief Be very verbose. */
+  bool very_verbose{ false };
+};
+
+/*! \brief Statistics for satlut_mapping.
+ *
+ * The data structure `satlut_mapping_stats` provides data collected by running
+ * `satlut_mapping`.
+ */
+struct satlut_mapping_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_sat{ 0 };
+
+  /*! \brief Number of SAT variables. */
+  uint64_t num_vars{ 0u };
+
+  /*! \brief Number of SAT clauses. */
+  uint64_t num_clauses{ 0u };
+
+  void report()
+  {
+    std::cout << fmt::format( "[i] total time              = {:>7.2f} secs\n", to_seconds( time_total ) )
+              << fmt::format( "[i] SAT solving time        = {:>7.2f} secs\n", to_seconds( time_sat ) )
+              << fmt::format( "[i] number of SAT variables = {}\n", num_vars )
+              << fmt::format( "[i] number of SAT clauses   = {}\n", num_clauses );
+  }
+};
+
+namespace detail
+{
+
+template<class Solver>
+std::vector<int> cardinality_network( Solver& solver, std::vector<int> const& vars, int& next_var )
+{
+  int lits[3];
+
+  auto logn = static_cast<uint32_t>( ceil( log2( vars.size() ) ) );
+  auto current = vars;
+
+  if ( current.size() != static_cast<uint64_t>( 1u ) << logn )
+  {
+    current.resize( static_cast<uint64_t>( 1u ) << logn, next_var );
+    lits[0] = pabc::Abc_Var2Lit( next_var++, 1 );
+    solver.add_clause( lits, lits + 1 );
+  }
+
+  batcher_sorting_network( static_cast<uint32_t>( current.size() ), [&]( auto a, auto b ) {
+    auto va = current[a];
+    auto vb = current[b];
+    auto va_next = next_var++;
+    auto vb_next = next_var++;
+
+    // AND(a, b) a + !c , b + !c , !a + !b + c
+    lits[0] = pabc::Abc_Var2Lit( va, 0 );
+    lits[1] = pabc::Abc_Var2Lit( va_next, 1 );
+    solver.add_clause( lits, lits + 2 );
+    lits[0] = pabc::Abc_Var2Lit( vb, 0 );
+    lits[1] = pabc::Abc_Var2Lit( va_next, 1 );
+    solver.add_clause( lits, lits + 2 );
+    lits[0] = pabc::Abc_Var2Lit( va, 1 );
+    lits[1] = pabc::Abc_Var2Lit( vb, 1 );
+    lits[2] = pabc::Abc_Var2Lit( va_next, 0 );
+    solver.add_clause( lits, lits + 3 );
+
+    // OR(a, b) !a + c , !b + c , a + b + !c
+    lits[0] = pabc::Abc_Var2Lit( va, 1 );
+    lits[1] = pabc::Abc_Var2Lit( vb_next, 0 );
+    solver.add_clause( lits, lits + 2 );
+    lits[0] = pabc::Abc_Var2Lit( vb, 1 );
+    lits[1] = pabc::Abc_Var2Lit( vb_next, 0 );
+    solver.add_clause( lits, lits + 2 );
+    lits[0] = pabc::Abc_Var2Lit( va, 0 );
+    lits[1] = pabc::Abc_Var2Lit( vb, 0 );
+    lits[2] = pabc::Abc_Var2Lit( vb_next, 1 );
+    solver.add_clause( lits, lits + 3 );
+
+    current[a] = va_next;
+    current[b] = vb_next;
+  } );
+
+  for ( auto i = 0u; i < current.size() - 1; ++i )
+  {
+    lits[0] = pabc::Abc_Var2Lit( current[i], 1 );
+    lits[1] = pabc::Abc_Var2Lit( current[i + 1], 0 );
+    solver.add_clause( lits, lits + 2 );
+  }
+
+  return current;
+}
+
+template<class Ntk, bool StoreFunction, typename CutData>
+class satlut_mapping_impl
+{
+public:
+  using network_cuts_t = network_cuts<Ntk, StoreFunction, CutData>;
+  using cut_t = typename network_cuts_t::cut_t;
+
+public:
+  satlut_mapping_impl( Ntk& ntk, satlut_mapping_params const& ps, satlut_mapping_stats& st )
+      : ntk( ntk ),
+        ps( ps ),
+        st( st ),
+        cuts( cut_enumeration<Ntk, StoreFunction, CutData>( ntk, ps.cut_enumeration_ps ) )
+  {
+  }
+
+  void run()
+  {
+    stopwatch t( st.time_total );
+
+    std::vector<int> card_inp;
+    node_map<int, Ntk> gate_var( ntk );
+    node_map<std::vector<int>, Ntk> cut_vars( ntk );
+    auto next_var = 0;
+
+    percy::bsat_wrapper solver;
+
+    /* initialize gate vars */
+    ntk.foreach_gate( [&]( auto n ) {
+      card_inp.push_back( next_var );
+      gate_var[n] = next_var++;
+    } );
+
+    const auto card_out = cardinality_network( solver, card_inp, next_var );
+
+    /* create clauses */
+    int cut_lits[2];
+    ntk.foreach_gate( [&]( auto n ) {
+      std::vector<int> gate_is_mapped;
+      gate_is_mapped.push_back( pabc::Abc_Var2Lit( gate_var[n], 1 ) );
+
+      for ( auto const& cut : cuts.cuts( ntk.node_to_index( n ) ) )
+      {
+        if ( cut->size() == 1 )
+        {
+          break; /* we assume that trivial cuts are in the end of the set */
+        }
+        gate_is_mapped.push_back( pabc::Abc_Var2Lit( next_var, 0 ) );
+        cut_lits[0] = pabc::Abc_Var2Lit( next_var, 1 );
+        cut_vars[n].push_back( next_var++ );
+        for ( auto leaf : *cut )
+        {
+          if ( ntk.is_pi( ntk.index_to_node( leaf ) ) )
+            continue;
+          cut_lits[1] = pabc::Abc_Var2Lit( gate_var[ntk.index_to_node( leaf )], 0 );
+          solver.add_clause( cut_lits, cut_lits + 2 );
+        }
+      }
+
+      solver.add_clause( &gate_is_mapped[0], &gate_is_mapped[0] + gate_is_mapped.size() );
+    } );
+
+    /* outputs must be mapped */
+    ntk.foreach_po( [&]( auto f ) {
+      auto lit = pabc::Abc_Var2Lit( gate_var[f], 0 );
+      solver.add_clause( &lit, &lit + 1 );
+    } );
+
+    st.num_vars = solver.nr_vars();
+    st.num_clauses = solver.nr_clauses();
+
+    auto best_size = ntk.has_mapping() ? ntk.num_cells() + 1 : card_inp.size();
+
+    progress_bar pbar{ "satlut iteration = {0}   try size = {1}", ps.progress };
+    auto iteration = 0u;
+    while ( true )
+    {
+      pbar( ++iteration, best_size );
+      if ( best_size > card_out.size() )
+      {
+        std::cout << fmt::format( "[e] best_size = {}   card_inp.size() = {}   card_out.size() = {}   ntk.num_cells = {}   ntk.has_mapping = {}\n",
+                                  best_size, card_inp.size(), card_out.size(), ntk.num_cells(), ntk.has_mapping() );
+        assert( false );
+      }
+      auto assump = pabc::Abc_Var2Lit( card_out[card_out.size() - best_size], 1 );
+
+      const auto result = call_with_stopwatch( st.time_sat, [&]() { return solver.solve( &assump, &assump + 1, ps.conflict_limit ); } );
+      if ( result == percy::success )
+      {
+        ntk.clear_mapping();
+        ntk.foreach_gate( [&]( auto n ) {
+          if ( solver.var_value( gate_var[n] ) )
+          {
+            for ( auto i = 0u; i < cut_vars[n].size(); ++i )
+            {
+              if ( solver.var_value( cut_vars[n][i] ) )
+              {
+                const auto index = ntk.node_to_index( n );
+                std::vector<node<Ntk>> nodes;
+                for ( auto const& l : cuts.cuts( index )[i] )
+                {
+                  nodes.push_back( ntk.index_to_node( l ) );
+                }
+                ntk.add_to_mapping( n, nodes.begin(), nodes.end() );
+
+                if constexpr ( StoreFunction )
+                {
+                  ntk.set_cell_function( n, cuts.truth_table( cuts.cuts( index )[i] ) );
+                }
+                break;
+              }
+            }
+          }
+        } );
+
+        if ( ntk.num_cells() == ntk.num_pos() )
+        {
+          /* no further improvement possible */
+          break;
+        }
+
+        best_size = ntk.num_cells();
+      }
+      else
+      {
+        break;
+      }
+    }
+  }
+
+private:
+  Ntk& ntk;
+  satlut_mapping_params const& ps;
+  satlut_mapping_stats& st;
+  network_cuts_t cuts;
+};
+
+} // namespace detail
+
+/*! \brief SAT-LUT mapping.
+ *
+ * This algorithm implements the SAT-based area-oriented LUT mapping algorithm
+ * presented in [B. Schmitt, A. Mishchenko, and R.K. Brayton, *ASP-DAC* **23**
+ * (2018), 586-591].
+ *
+ * The interface is similar to the one in `lut_mapping`.
+ *
+ * This algorithm applies SAT-LUT mapping to the whole networking and therefore
+ * may show poor performance for larger networks.  There exists a method with
+ * the same name that takes as input a window size to apply SAT-LUT mapping to
+ * windows.
+ *
+ * **Required network functions:**
+ * - `is_pi`
+ * - `index_to_node`
+ * - `node_to_index`
+ * - `foreach_gate`
+ * - `foreach_po`
+ * - `num_gates`
+ * - `num_cells`
+ * - `has_mapping`
+ * - `clear_mapping`
+ * - `add_to_mapping`
+ * - `set_cell_function` if `StoreFunction` is true
+ *
+ * \param ntk Logic network to be mapped
+ * \param ps Parameters
+ * \param st Statistics
+ */
+template<class Ntk, bool StoreFunction = false, typename CutData = cut_enumeration_mf_cut>
+void satlut_mapping( Ntk& ntk, satlut_mapping_params const& ps = {}, satlut_mapping_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_num_gates_v<Ntk>, "Ntk does not implement the num_gates method" );
+  static_assert( has_num_cells_v<Ntk>, "Ntk does not implement the num_cells method" );
+  static_assert( has_has_mapping_v<Ntk>, "Ntk does not implement the has_mapping method" );
+  static_assert( has_clear_mapping_v<Ntk>, "Ntk does not implement the clear_mapping method" );
+  static_assert( has_add_to_mapping_v<Ntk>, "Ntk does not implement the add_to_mapping method" );
+  static_assert( !StoreFunction || has_set_cell_function_v<Ntk>, "Ntk does not implement the set_cell_function method" );
+
+  satlut_mapping_stats st;
+  detail::satlut_mapping_impl<Ntk, StoreFunction, CutData> p( ntk, ps, st );
+  p.run();
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+/*! \brief SAT-LUT mapping (windowed).
+ *
+ * This algorithm applies SAT-LUT mapping to windows of a given size (e.g., 32,
+ * 64, 128) and can therefore better deal with larger networks.  It has
+ * otherwise the same interface as `satlut_mapping`.
+ *
+ * The initial network must already contain a mapping, e.g., found with
+ * `lut_mapping`.
+ *
+ * **Required network functions:**
+ * - `is_pi`
+ * - `index_to_node`
+ * - `node_to_index`
+ * - `foreach_gate`
+ * - `foreach_po`
+ * - `num_gates`
+ * - `num_cells`
+ * - `has_mapping`
+ * - `clear_mapping`
+ * - `add_to_mapping`
+ * - `is_cell_root`
+ * - `set_cell_function` if `StoreFunction` is true
+ *
+ * \param ntk Logic network to be mapped
+ * \param window_size Maximum number of gates in a window
+ * \param ps Parameters
+ * \param st Statistics
+ */
+template<class Ntk, bool StoreFunction = false, typename CutData = cut_enumeration_mf_cut>
+void satlut_mapping( Ntk& ntk, uint32_t window_size, satlut_mapping_params ps = {}, satlut_mapping_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_num_gates_v<Ntk>, "Ntk does not implement the num_gates method" );
+  static_assert( has_num_cells_v<Ntk>, "Ntk does not implement the num_cells method" );
+  static_assert( has_has_mapping_v<Ntk>, "Ntk does not implement the has_mapping method" );
+  static_assert( has_clear_mapping_v<Ntk>, "Ntk does not implement the clear_mapping method" );
+  static_assert( has_add_to_mapping_v<Ntk>, "Ntk does not implement the add_to_mapping method" );
+  static_assert( has_is_cell_root_v<Ntk>, "Ntk does not implement the is_cell_root method" );
+  static_assert( !StoreFunction || has_set_cell_function_v<Ntk>, "Ntk does not implement the set_cell_function method" );
+
+  if ( !ntk.has_mapping() )
+  {
+    return;
+  }
+
+  satlut_mapping_stats st;
+  stopwatch<>::duration time_total{};
+  cell_window window( ntk, window_size );
+  progress_bar pbar{ ntk.size(), "satlut (windowed) |{0}| node = {1:>4} / " + std::to_string( ntk.size() ), ps.progress };
+  ps.progress = false; /* do not show inner progress */
+  ntk.foreach_gate( [&]( auto n, int index ) {
+    stopwatch<> t( time_total );
+    pbar( index, ntk.node_to_index( n ) );
+    if ( ntk.is_cell_root( n ) )
+    {
+      if ( !window.compute_window_for( n ) ) /* window has been visited before */
+      {
+        return true;
+      }
+
+      if ( ps.verbose )
+      {
+        std::cout << fmt::format( "[i] cell {:>5}   size = {:>4}   nodes = {:>2}   gates = {:>3}   pis = {:>3}   pos = {:>3}\n",
+                                  n,
+                                  window.size(),
+                                  window.num_cells(),
+                                  window.num_gates(),
+                                  window.num_pis(),
+                                  window.num_pos() );
+      }
+      if ( window.num_cells() == window.num_pos() || window.num_pos() == 0 )
+      {
+        return true;
+      }
+      topo_view window_topo{ window };
+      detail::satlut_mapping_impl<decltype( window_topo ), StoreFunction, CutData> p( window_topo, ps, st );
+      p.run();
+      return true;
+    }
+
+    return true;
+  } );
+
+  st.time_total = time_total;
+
+  if ( ps.verbose )
+  {
+    st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/sim_resub.hpp b/include/mockturtle/algorithms/sim_resub.hpp
new file mode 100644
index 0000000..6ebe334
--- /dev/null
+++ b/include/mockturtle/algorithms/sim_resub.hpp
@@ -0,0 +1,459 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file sim_resub.hpp
+  \brief Simulation-Guided Resubstitution
+
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../io/write_patterns.hpp"
+#include "../networks/aig.hpp"
+#include "../networks/xag.hpp"
+#include "../networks/mig.hpp"
+#include "../utils/progress_bar.hpp"
+#include "../utils/stopwatch.hpp"
+#include "circuit_validator.hpp"
+#include "pattern_generation.hpp"
+#include "resubstitution.hpp"
+#include "resyn_engines/mux_resyn_select_opt.hpp"
+#include "resyn_engines/mux_resyn_xnor_sel.hpp"
+#include "resyn_engines/xag_resyn.hpp"
+#include "resyn_engines/mig_resyn.hpp"
+#include "simulation.hpp"
+
+#include <bill/bill.hpp>
+#include <fmt/format.h>
+#include <kitty/kitty.hpp>
+
+#include <algorithm>
+#include <kitty/print.hpp>
+#include <mockturtle/algorithms/resyn_engines/mux_resyn.hpp>
+#include <mockturtle/algorithms/resyn_engines/mux_resyn_select_opt.hpp>
+#include <mockturtle/algorithms/resyn_engines/mux_resyn_xnor_sel.hpp>
+#include <mockturtle/networks/muxig.hpp>
+#include <variant>
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+template<typename ResynSt>
+struct sim_resub_stats
+{
+  /*! \brief Time for pattern generation. */
+  stopwatch<>::duration time_patgen{ 0 };
+
+  /*! \brief Time for saving patterns. */
+  stopwatch<>::duration time_patsave{ 0 };
+
+  /*! \brief Time for simulation. */
+  stopwatch<>::duration time_sim{ 0 };
+
+  /*! \brief Time for SAT solving. */
+  stopwatch<>::duration time_sat{ 0 };
+  stopwatch<>::duration time_sat_restart{ 0 };
+
+  /*! \brief Time for computing ODCs. */
+  stopwatch<>::duration time_odc{ 0 };
+
+  /*! \brief Time for finding dependency function. */
+  stopwatch<>::duration time_resyn{ 0 };
+
+  /*! \brief Time for translating from index lists to network signals. */
+  stopwatch<>::duration time_interface{ 0 };
+
+  /*! \brief Number of patterns used. */
+  uint32_t num_pats{ 0 };
+
+  /*! \brief Number of counter-examples. */
+  uint32_t num_cex{ 0 };
+
+  /*! \brief Number of successful resubstitutions. */
+  uint32_t num_resub{ 0 };
+
+  /*! \brief Number of SAT solver timeout. */
+  uint32_t num_timeout{ 0 };
+
+  /*! \brief Number of calls to the resynthesis engine. */
+  uint32_t num_resyn{ 0 };
+
+  ResynSt resyn_st;
+
+  void report() const
+  {
+    fmt::print( "[i] <ResubEngine: simulation_based_resub_engine>\n" );
+    fmt::print( "[i]     ========  Stats  ========\n" );
+    fmt::print( "[i]     #pat        = {:6d}\n", num_pats );
+    fmt::print( "[i]     #resyn call = {:6d}\n", num_resyn );
+    fmt::print( "[i]     #valid      = {:6d}\n", num_resub );
+    fmt::print( "[i]     #CEX        = {:6d}\n", num_cex );
+    fmt::print( "[i]     #timeout    = {:6d}\n", num_timeout );
+    fmt::print( "[i]     ======== Runtime ========\n" );
+    fmt::print( "[i]     generate pattern: {:>5.2f} secs [excluded]\n", to_seconds( time_patgen ) );
+    fmt::print( "[i]     save pattern    : {:>5.2f} secs [excluded]\n", to_seconds( time_patsave ) );
+    fmt::print( "[i]     simulation      : {:>5.2f} secs\n", to_seconds( time_sim ) );
+    fmt::print( "[i]     SAT solve       : {:>5.2f} secs\n", to_seconds( time_sat ) );
+    fmt::print( "[i]     SAT restart     : {:>5.2f} secs\n", to_seconds( time_sat_restart ) );
+    fmt::print( "[i]     compute ODCs    : {:>5.2f} secs\n", to_seconds( time_odc ) );
+    fmt::print( "[i]     interfacing     : {:>5.2f} secs\n", to_seconds( time_interface ) );
+    fmt::print( "[i]     compute function: {:>5.2f} secs\n", to_seconds( time_resyn ) );
+    fmt::print( "[i]     ======== Details ========\n" );
+    resyn_st.report();
+    fmt::print( "[i]     =========================\n\n" );
+  }
+};
+
+/*! \brief Simulation-based resubstitution engine.
+ *
+ * This engine simulates the entire network using partial truth tables and calls a
+ * resynthesis engine (template parameter `ResynEngine`) to find potential resubstitutions.
+ * If a resubstitution candidate is found, it then formally verifies it with SAT solving.
+ * If the validation fails, a counter-example will be added to the simulation patterns,
+ * and resynthesis will be invoked again with updated truth tables, looping until it returns
+ * `std::nullopt`. This engine only requires the divisor collector to prepare `divs`.
+ *
+ * Please refer to the following paper for further details.
+ *
+ * [1] A Simulation-Guided Paradigm for Logic Synthesis and Verification. TCAD, 2022.
+ *
+ * Required interface of `ResynEngine`:
+ * - A public `operator()`: `std::optional<index_list_t> operator()`
+ * `( TT const& target, TT const& care, iterator_type begin, iterator_type end,
+ * truth_table_storage_type const& tts, uint32_t max_size )`
+ *
+ * All classes implemented in `algorithms/resyn_engines/` are compatible.
+ *
+ * \tparam validator_t Specialization of `circuit_validator`.
+ * \tparam ResynEngine A resynthesis solver to compute the resubstitution candidate.
+ * \tparam MffcRes Typename of `potential_gain`.
+ */
+template<class Ntk, typename validator_t = circuit_validator<Ntk, bill::solvers::bsat2, false, true, false>, class ResynEngine = xag_resyn_decompose<kitty::partial_truth_table, xag_resyn_static_params_for_sim_resub<Ntk>>, typename MffcRes = uint32_t>
+class simulation_based_resub_engine
+{
+public:
+  static constexpr bool require_leaves_and_mffc = false;
+  using stats = sim_resub_stats<typename ResynEngine::stats>;
+  using mffc_result_t = MffcRes;
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  using TT = kitty::partial_truth_table;
+
+  explicit simulation_based_resub_engine( Ntk& ntk, resubstitution_params const& ps, stats& st )
+      : ntk( ntk ), ps( ps ), st( st ), tts( ntk ), validator( ntk, { ps.max_clauses, ps.odc_levels, ps.conflict_limit, ps.random_seed } ), engine( st.resyn_st )
+  {
+    if constexpr ( !validator_t::use_odc_ )
+    {
+      assert( ps.odc_levels == 0 && "to consider ODCs, circuit_validator::use_odc (the last template parameter) has to be turned on" );
+    }
+
+    add_event = ntk.events().register_add_event( [&]( const auto& n ) {
+      tts.resize();
+      call_with_stopwatch( st.time_sim, [&]() {
+        simulate_node<Ntk>( ntk, n, tts, sim );
+      } );
+    } );
+  }
+
+  ~simulation_based_resub_engine()
+  {
+    if ( ps.save_patterns )
+    {
+      call_with_stopwatch( st.time_patsave, [&]() {
+        write_patterns( sim, *ps.save_patterns );
+      } );
+    }
+
+    if ( add_event )
+    {
+      ntk.events().release_add_event( add_event );
+    }
+  }
+
+  void init()
+  {
+    /* prepare simulation patterns */
+    call_with_stopwatch( st.time_patgen, [&]() {
+      if ( ps.pattern_filename )
+      {
+        sim = partial_simulator( *ps.pattern_filename );
+      }
+      else
+      {
+        sim = partial_simulator( ntk.num_pis(), 1024 );
+        pattern_generation( ntk, sim );
+      }
+
+      if constexpr ( has_EXCDC_interface_v<Ntk> )
+      {
+        sim.remove_CDC_patterns( ntk );
+      }
+    } );
+    st.num_pats = sim.num_bits();
+    assert( sim.num_bits() > 0 );
+
+    /* first simulation: the whole circuit; from 0 bits. */
+    call_with_stopwatch( st.time_sim, [&]() {
+      simulate_nodes<Ntk>( ntk, tts, sim, true );
+    } );
+  }
+
+  void update()
+  {
+    if constexpr ( validator_t::use_odc_ || has_EXODC_interface_v<Ntk> )
+    {
+      call_with_stopwatch( st.time_sat_restart, [&]() {
+        validator.update();
+      } );
+      tts.reset();
+      call_with_stopwatch( st.time_sim, [&]() {
+        simulate_nodes<Ntk>( ntk, tts, sim, true );
+      } );
+    }
+  }
+
+  std::optional<signal> run( node const& n, std::vector<node> const& divs, mffc_result_t potential_gain, uint32_t& last_gain )
+  {
+    for ( auto j = 0u; j < ps.max_trials; ++j )
+    {
+      check_tts( n );
+      for ( auto const& d : divs )
+      {
+        check_tts( d );
+      }
+
+      TT const care = call_with_stopwatch( st.time_odc, [&]() {
+        return ( ps.odc_levels == 0 ) ? sim.compute_constant( true ) : ~observability_dont_cares( ntk, n, sim, tts, ps.odc_levels );
+      } );
+
+      const auto res = call_with_stopwatch( st.time_resyn, [&]() {
+        ++st.num_resyn;
+        return engine( tts[n], care, std::begin( divs ), std::end( divs ), tts, std::min( potential_gain - 1, ps.max_inserts ) );
+      } );
+
+      if ( res )
+      {
+        auto const& id_list = *res;
+        assert( id_list.num_pos() == 1u );
+        last_gain = potential_gain - id_list.num_gates();
+        auto valid = call_with_stopwatch( st.time_sat, [&]() {
+          return validator.validate( n, divs, id_list );
+        } );
+        if ( valid )
+        {
+          if ( *valid )
+          {
+            ++st.num_resub;
+            signal out_sig;
+            call_with_stopwatch( st.time_interface, [&]() {
+              std::vector<signal> divs_sig( divs.size() );
+              std::transform( divs.begin(), divs.end(), divs_sig.begin(), [&]( const node n ) {
+                return ntk.make_signal( n );
+              } );
+              insert( ntk, divs_sig.begin(), divs_sig.end(), id_list, [&]( signal const& s ) {
+                out_sig = s;
+              } );
+            } );
+            return out_sig;
+          }
+          else
+          {
+            found_cex();
+            continue;
+          }
+        }
+        else /* timeout */
+        {
+          return std::nullopt;
+        }
+      }
+      else /* functor can not find any potential resubstitution */
+      {
+        return std::nullopt;
+      }
+    }
+    return std::nullopt;
+  }
+
+  void found_cex()
+  {
+    ++st.num_cex;
+    call_with_stopwatch( st.time_sim, [&]() {
+      sim.add_pattern( validator.cex );
+    } );
+
+    /* re-simulate the whole circuit (for the last block) when a block is full */
+    if ( sim.num_bits() % 64 == 0 )
+    {
+      call_with_stopwatch( st.time_sim, [&]() {
+        simulate_nodes<Ntk>( ntk, tts, sim, false );
+      } );
+    }
+  }
+
+  void check_tts( node const& n )
+  {
+    if ( tts[n].num_bits() != sim.num_bits() )
+    {
+      call_with_stopwatch( st.time_sim, [&]() {
+        simulate_node<Ntk>( ntk, n, tts, sim );
+      } );
+    }
+  }
+
+private:
+  Ntk& ntk;
+  resubstitution_params const& ps;
+  stats& st;
+
+  incomplete_node_map<TT, Ntk> tts;
+  partial_simulator sim;
+
+  validator_t validator;
+  ResynEngine engine;
+
+  /* events */
+  std::shared_ptr<typename network_events<Ntk>::add_event_type> add_event;
+}; /* simulation_based_resub_engine */
+
+template<class Ntk, typename resub_impl_t>
+void sim_resubstitution_run( Ntk& ntk, resubstitution_params const& ps, resubstitution_stats* pst )
+{
+  resubstitution_stats st;
+  typename resub_impl_t::engine_st_t engine_st;
+  typename resub_impl_t::collector_st_t collector_st;
+
+  resub_impl_t p( ntk, ps, st, engine_st, collector_st );
+  p.run();
+  st.time_resub -= engine_st.time_patgen;
+  st.time_total -= engine_st.time_patgen + engine_st.time_patsave;
+
+  if ( ps.verbose )
+  {
+    st.report();
+    collector_st.report();
+    engine_st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace detail */
+
+template<class Ntk>
+void sim_resubstitution( Ntk& ntk, resubstitution_params const& ps = {}, resubstitution_stats* pst = nullptr )
+{
+  static_assert( std::is_same_v<typename Ntk::base_type, aig_network> 
+                 || std::is_same_v<typename Ntk::base_type, xag_network>
+                 || std::is_same_v<typename Ntk::base_type, mig_network>
+                 || std::is_same_v<typename Ntk::base_type, muxig_network>, "Currently only supports AIG, XAG, and MIG" );
+
+  using resub_view_t = fanout_view<depth_view<Ntk>>;
+  depth_view<Ntk> depth_view{ ntk };
+  resub_view_t resub_view{ depth_view };
+
+  if constexpr ( std::is_same_v<typename Ntk::base_type, aig_network> )
+  {
+    using resyn_engine_t = xag_resyn_decompose<kitty::partial_truth_table, aig_resyn_static_params_for_sim_resub<resub_view_t>>;
+
+    if ( ps.odc_levels != 0 )
+    {
+      using validator_t = circuit_validator<resub_view_t, bill::solvers::bsat2, false, true, true>;
+      using resub_impl_t = typename detail::resubstitution_impl<resub_view_t, typename detail::simulation_based_resub_engine<resub_view_t, validator_t, resyn_engine_t>>;
+      detail::sim_resubstitution_run<resub_view_t, resub_impl_t>( resub_view, ps, pst );
+    }
+    else
+    {
+      using validator_t = circuit_validator<resub_view_t, bill::solvers::bsat2, false, true, false>;
+      using resub_impl_t = typename detail::resubstitution_impl<resub_view_t, typename detail::simulation_based_resub_engine<resub_view_t, validator_t, resyn_engine_t>>;
+      detail::sim_resubstitution_run<resub_view_t, resub_impl_t>( resub_view, ps, pst );
+    }
+  }
+  else if constexpr ( std::is_same_v<typename Ntk::base_type, xag_network> )
+  {
+    using resyn_engine_t = xag_resyn_decompose<kitty::partial_truth_table, xag_resyn_static_params_for_sim_resub<resub_view_t>>;
+
+    if ( ps.odc_levels != 0 )
+    {
+      using validator_t = circuit_validator<resub_view_t, bill::solvers::bsat2, false, true, true>;
+      using resub_impl_t = typename detail::resubstitution_impl<resub_view_t, typename detail::simulation_based_resub_engine<resub_view_t, validator_t, resyn_engine_t>>;
+      detail::sim_resubstitution_run<resub_view_t, resub_impl_t>( resub_view, ps, pst );
+    }
+    else
+    {
+      using validator_t = circuit_validator<resub_view_t, bill::solvers::bsat2, false, true, false>;
+      using resub_impl_t = typename detail::resubstitution_impl<resub_view_t, typename detail::simulation_based_resub_engine<resub_view_t, validator_t, resyn_engine_t>>;
+      detail::sim_resubstitution_run<resub_view_t, resub_impl_t>( resub_view, ps, pst );
+    }
+  }
+  else if constexpr ( std::is_same_v<typename Ntk::base_type, mig_network> )
+  {
+    using resyn_engine_t = mig_resyn_topdown<kitty::partial_truth_table, mig_resyn_static_params>;
+
+    if ( ps.odc_levels != 0 )
+    {
+      using validator_t = circuit_validator<resub_view_t, bill::solvers::bsat2, false, true, true>;
+      using resub_impl_t = typename detail::resubstitution_impl<resub_view_t, typename detail::simulation_based_resub_engine<resub_view_t, validator_t, resyn_engine_t>>;
+      detail::sim_resubstitution_run<resub_view_t, resub_impl_t>( resub_view, ps, pst );
+    }
+    else
+    {
+      using validator_t = circuit_validator<resub_view_t, bill::solvers::bsat2, false, true, false>;
+      using resub_impl_t = typename detail::resubstitution_impl<resub_view_t, typename detail::simulation_based_resub_engine<resub_view_t, validator_t, resyn_engine_t>>;
+      detail::sim_resubstitution_run<resub_view_t, resub_impl_t>( resub_view, ps, pst );
+    }
+  }
+  else if constexpr ( std::is_same_v<typename Ntk::base_type, muxig_network> )
+  {
+    //using resyn_engine_t = mux_resyn<kitty::partial_truth_table>;
+    //using resyn_engine_t = mux_resyn_select_opt<kitty::partial_truth_table>;
+    using resyn_engine_t = mux_resyn_xnor_sel<kitty::partial_truth_table>;
+
+    if ( ps.odc_levels != 0 )
+    {
+      using validator_t = circuit_validator<resub_view_t, bill::solvers::bsat2, false, true, true>;
+      using resub_impl_t = typename detail::resubstitution_impl<resub_view_t, typename detail::simulation_based_resub_engine<resub_view_t, validator_t, resyn_engine_t>>;
+      detail::sim_resubstitution_run<resub_view_t, resub_impl_t>( resub_view, ps, pst );
+    }
+    else
+    {
+      using validator_t = circuit_validator<resub_view_t, bill::solvers::bsat2, false, true, false>;
+      using resub_impl_t = typename detail::resubstitution_impl<resub_view_t, typename detail::simulation_based_resub_engine<resub_view_t, validator_t, resyn_engine_t>>;
+      detail::sim_resubstitution_run<resub_view_t, resub_impl_t>( resub_view, ps, pst );
+    }
+  }
+}
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/simulation.hpp b/include/mockturtle/algorithms/simulation.hpp
new file mode 100644
index 0000000..119c96a
--- /dev/null
+++ b/include/mockturtle/algorithms/simulation.hpp
@@ -0,0 +1,982 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file simulation.hpp
+  \brief Simulate networks
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+  \author Marcel Walter
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <fstream>
+#include <random>
+#include <vector>
+
+#include "../traits.hpp"
+#include "../utils/node_map.hpp"
+
+#include <kitty/bit_operations.hpp>
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/operators.hpp>
+#include <kitty/partial_truth_table.hpp>
+#include <kitty/static_truth_table.hpp>
+
+namespace mockturtle
+{
+
+/*! \brief Abstract template class for simulation. */
+template<class SimulationType>
+class default_simulator
+{
+public:
+  default_simulator() = delete;
+};
+
+/*! \brief Simulates Boolean assignments.
+ *
+ * This simulator simulates Boolean values.  A vector with assignments for each
+ * primary input must be passed to the constructor.
+ */
+template<>
+class default_simulator<bool>
+{
+public:
+  default_simulator() = delete;
+  default_simulator( std::vector<bool> const& assignments ) : assignments( assignments ) {}
+
+  bool compute_constant( bool value ) const { return value; }
+  bool compute_pi( uint32_t index ) const { return assignments[index]; }
+  bool compute_not( bool value ) const { return !value; }
+
+private:
+  std::vector<bool> assignments;
+};
+
+/*! \brief Simulates Boolean assignments with input word.
+ *
+ * This simulator simulates Boolean values.  A bitstring with assignments for
+ * each primary input must be passed to the constructor.  Because this
+ * bitstring can have at most 64 bits, this simulator is not suitable for
+ * logic networks with more than 64 primary inputs.
+ */
+class input_word_simulator
+{
+public:
+  input_word_simulator( uint64_t word ) : word( word ) {}
+
+  bool compute_constant( bool value ) const { return value; }
+  bool compute_pi( uint32_t index ) const { return ( word >> index ) & 1; }
+  bool compute_not( bool value ) const { return !value; }
+
+private:
+  uint64_t word;
+};
+
+/*! \brief Simulates truth tables.
+ *
+ * This simulator simulates truth tables.  Each primary input is assigned the
+ * projection function according to the index.  The number of variables be
+ * passed to the constructor of the simulator.
+ */
+template<>
+class default_simulator<kitty::dynamic_truth_table>
+{
+public:
+  default_simulator() = delete;
+  default_simulator( unsigned num_vars ) : num_vars( num_vars ) {}
+
+  kitty::dynamic_truth_table compute_constant( bool value ) const
+  {
+    kitty::dynamic_truth_table tt( num_vars );
+    return value ? ~tt : tt;
+  }
+
+  kitty::dynamic_truth_table compute_pi( uint32_t index ) const
+  {
+    kitty::dynamic_truth_table tt( num_vars );
+    kitty::create_nth_var( tt, index );
+    return tt;
+  }
+
+  kitty::dynamic_truth_table compute_not( kitty::dynamic_truth_table const& value ) const
+  {
+    return ~value;
+  }
+
+private:
+  unsigned num_vars;
+};
+
+/*! \brief Simulates truth tables.
+ *
+ * This simulator simulates truth tables.  Each primary input is assigned the
+ * projection function according to the index.  The number of variables must be
+ * known at compile time.
+ */
+template<uint32_t NumVars>
+class default_simulator<kitty::static_truth_table<NumVars>>
+{
+public:
+  kitty::static_truth_table<NumVars> compute_constant( bool value ) const
+  {
+    kitty::static_truth_table<NumVars> tt;
+    return value ? ~tt : tt;
+  }
+
+  kitty::static_truth_table<NumVars> compute_pi( uint32_t index ) const
+  {
+    kitty::static_truth_table<NumVars> tt;
+    kitty::create_nth_var( tt, index );
+    return tt;
+  }
+
+  kitty::static_truth_table<NumVars> compute_not( kitty::static_truth_table<NumVars> const& value ) const
+  {
+    return ~value;
+  }
+};
+
+/*! \brief Simulates partial truth tables.
+ *
+ * This simulator simulates partial truth tables, whose length is flexible
+ * and new simulation patterns can be added.
+ */
+class partial_simulator
+{
+  friend class bit_packed_simulator;
+
+public:
+  partial_simulator() {}
+
+  /*! \brief Create a `partial_simulator` with random simulation patterns.
+   *
+   * \param num_pis Number of primary inputs, which is the same as the length of a simulation pattern.
+   * \param num_patterns Number of initial random simulation patterns.
+   */
+  partial_simulator( uint32_t num_pis, uint32_t num_patterns, std::default_random_engine::result_type seed = 1 )
+      : num_patterns( num_patterns )
+  {
+    assert( num_pis > 0u );
+
+    for ( auto i = 0u; i < num_pis; ++i )
+    {
+      patterns.emplace_back( num_patterns );
+      kitty::create_random( patterns.back(), seed + i );
+    }
+  }
+
+  /* copy constructors */
+  partial_simulator( partial_simulator const& sim ) = default;
+  partial_simulator& operator=( partial_simulator const& sim ) = default;
+
+  /*! \brief Create a `partial_simulator` with given simulation patterns.
+   *
+   * \param initial_patterns Initial simulation patterns.
+   */
+  partial_simulator( std::vector<kitty::partial_truth_table> const& initial_patterns )
+      : patterns( initial_patterns ), num_patterns( patterns.at( 0 ).num_bits() )
+  {}
+
+  /*! \brief Create a `partial_simulator` with simulation patterns read from a file.
+   *
+   * The simulation pattern file should contain `num_pis` lines of the same length.
+   * Each line is the simulation signature of a primary input, represented in hexadecimal.
+   *
+   * \param filename Name of the simulation pattern file.
+   * \param length Number of simulation patterns to keep. Should not be greater than 4 times
+   * the length of a line in the file. Setting this parameter to 0 means to keep all patterns in the file.
+   */
+  partial_simulator( const std::string& filename, uint32_t length = 0u )
+  {
+    std::ifstream in( filename, std::ifstream::in );
+    std::string line;
+
+    while ( getline( in, line ) )
+    {
+      patterns.emplace_back( line.length() * 4 );
+      kitty::create_from_hex_string( patterns.back(), line );
+      if ( length != 0u )
+      {
+        patterns.back().resize( length );
+      }
+    }
+
+    in.close();
+
+    assert( patterns.size() > 0 );
+    num_patterns = patterns[0].num_bits();
+  }
+
+  kitty::partial_truth_table compute_constant( bool value ) const
+  {
+    kitty::partial_truth_table zero( num_patterns );
+    return value ? ~zero : zero;
+  }
+
+  kitty::partial_truth_table compute_pi( uint32_t index ) const
+  {
+    return patterns.at( index );
+  }
+
+  kitty::partial_truth_table compute_not( kitty::partial_truth_table const& value ) const
+  {
+    return ~value;
+  }
+
+  /*! \brief Get the current number of simulation patterns. */
+  uint32_t num_bits() const
+  {
+    return num_patterns;
+  }
+
+  /*! \brief Add a pattern (primary input assignment) into the pattern set.
+   *
+   * \param pattern The pattern. Length should be the same as number of PIs.
+   */
+  void add_pattern( std::vector<bool> const& pattern )
+  {
+    assert( pattern.size() == patterns.size() );
+
+    for ( auto i = 0u; i < pattern.size(); ++i )
+    {
+      patterns.at( i ).add_bit( pattern.at( i ) );
+    }
+    ++num_patterns;
+  }
+
+  /*! \brief Get the simulation patterns.
+   *
+   * \return A vector of `num_pis()` patterns stored in `kitty::partial_truth_table`s.
+   */
+  std::vector<kitty::partial_truth_table> get_patterns() const
+  {
+    return patterns;
+  }
+
+  template<class Ntk, bool enabled = has_EXCDC_interface_v<Ntk>, typename = std::enable_if_t<enabled>>
+  void remove_CDC_patterns( Ntk const& ntk )
+  {
+    std::vector<bool> pattern( patterns.size() );
+    for ( int i = 0; i < (int)num_patterns; ++i )
+    {
+      for ( auto j = 0u; j < patterns.size(); ++j )
+      {
+        pattern[j] = kitty::get_bit( patterns[j], i );
+      }
+      if ( ntk.pattern_is_EXCDC( pattern ) )
+      {
+        for ( auto j = 0u; j < patterns.size(); ++j )
+        {
+          kitty::copy_bit( patterns[j], num_patterns - 1, patterns[j], i );
+        }
+        --num_patterns;
+        --i;
+      }
+    }
+    for ( auto j = 0u; j < patterns.size(); ++j )
+    {
+      patterns[j].resize( num_patterns );
+    }
+  }
+
+private:
+  std::vector<kitty::partial_truth_table> patterns;
+  uint32_t num_patterns;
+};
+
+/*! \brief Simulates partial truth tables, and performs bit packing when requested.
+ *
+ * This class has the same interfaces as `partial_simulator`, except that
+ * (1) care bits should be provided as the second argument of `add_pattern`; and
+ * (2) `pack_bits` can be called to reduce the size of pattern set.
+ */
+class bit_packed_simulator : public partial_simulator
+{
+public:
+  using partial_simulator::compute_constant;
+  using partial_simulator::compute_not;
+  using partial_simulator::compute_pi;
+  using partial_simulator::get_patterns;
+  using partial_simulator::num_bits;
+
+  bit_packed_simulator() {}
+
+  bit_packed_simulator( uint32_t num_pis, uint32_t num_patterns, std::default_random_engine::result_type seed = 1 )
+      : partial_simulator( num_pis, num_patterns, seed ), packed_patterns( num_patterns )
+  {
+    fill_cares( num_pis );
+  }
+
+  /* copy constructors */
+  bit_packed_simulator( bit_packed_simulator const& sim ) = default;
+  bit_packed_simulator& operator=( bit_packed_simulator const& sim ) = default;
+
+  /* copy constructor from `partial_simulator` */
+  bit_packed_simulator( partial_simulator const& sim )
+      : partial_simulator( sim ), packed_patterns( num_patterns )
+  {
+    fill_cares( patterns.size() );
+  }
+
+  bit_packed_simulator( std::vector<kitty::partial_truth_table> const& initial_patterns )
+      : partial_simulator( initial_patterns ), packed_patterns( num_patterns )
+  {
+    fill_cares( patterns.size() );
+  }
+
+  bit_packed_simulator( const std::string& filename, uint32_t length = 0u )
+      : partial_simulator( filename, length ), packed_patterns( num_patterns )
+  {
+    fill_cares( patterns.size() );
+  }
+
+  /*! \brief Add a pattern (primary input assignment) into the pattern set.
+   *
+   * \param pattern The pattern. Length should be the same as number of PIs.
+   * \param care_bits Care bits of the pattern. Length should be the same as `pattern`.
+   */
+  void add_pattern( std::vector<bool> const& pattern, std::vector<bool> const& care_bits )
+  {
+    assert( pattern.size() == care_bits.size() );
+    assert( pattern.size() == patterns.size() );
+
+    for ( auto i = 0u; i < pattern.size(); ++i )
+    {
+      patterns.at( i ).add_bit( pattern.at( i ) );
+      care.at( i ).add_bit( care_bits.at( i ) );
+    }
+    ++num_patterns;
+  }
+
+  /*! \brief Try to pack the newly added patterns (since the last call) into preceding patterns.
+   *
+   * \return `true` when some patterns are packed (so that update of simulated truth tables is needed)
+   */
+  bool pack_bits()
+  {
+    if ( num_patterns == 0u )
+    {
+      return false;
+    }
+    if ( num_patterns == packed_patterns )
+    {
+      return false;
+    }
+    assert( num_patterns > packed_patterns );
+
+    std::vector<int64_t> empty_slots;
+    /* for each unpacked pattern (at `p`), try to pack it into one of the patterns before it (at `pos` in block `block`). */
+    for ( int64_t p = num_patterns - 1; p >= (int64_t)packed_patterns; --p )
+    {
+      for ( auto block = p < 1024 ? 0 : std::rand() % ( p >> 6 ); block <= ( p >> 6 ); ++block )
+      {
+        uint64_t unavailable = 0u;
+        /* check each PI */
+        for ( auto i = 0u; i < patterns.size(); ++i )
+        {
+          if ( !kitty::get_bit( care[i], p ) )
+          {
+            continue;
+          } /* only check for the cared PIs of p */
+          unavailable |= care[i]._bits[block];
+        }
+        auto pos = kitty::find_first_bit_in_word( ~unavailable );
+        if ( pos != -1 && ( block < ( p >> 6 ) || pos < ( p % 64 ) ) )
+        {
+          move_pattern( p, pos + ( block << 6 ) );
+          empty_slots.emplace_back( p );
+          break;
+        }
+      }
+    }
+
+    if ( empty_slots.size() > 0u )
+    {
+      /* fill the empty slots (from smaller values; `empty_slots` should be reversely sorted) */
+      /* `empty_slots[j]` is the smallest position where larger positions are all empty */
+      int64_t j = 0;
+      for ( int64_t i = empty_slots.size() - 1; i >= 0; --i )
+      {
+        while ( j <= i && empty_slots[j] >= num_patterns - 1 )
+        {
+          if ( empty_slots[j] == num_patterns - 1 )
+          {
+            --num_patterns;
+          }
+          ++j;
+          if ( j == (int64_t)empty_slots.size() )
+          {
+            break;
+          }
+        }
+        if ( j > i )
+        {
+          break;
+        }
+        move_pattern( num_patterns - 1, empty_slots[i] );
+        --num_patterns;
+      }
+      assert( patterns[0].num_bits() - num_patterns == empty_slots.size() );
+      for ( auto i = 0u; i < patterns.size(); ++i )
+      {
+        patterns[i].resize( num_patterns );
+        care[i].resize( num_patterns );
+      }
+      packed_patterns = num_patterns;
+      return true;
+    }
+    packed_patterns = num_patterns;
+    return false;
+  }
+
+  void randomize_dont_care_bits( std::default_random_engine::result_type seed = 1 )
+  {
+    for ( auto i = 0u; i < patterns.size(); ++i )
+    {
+      kitty::partial_truth_table tt( num_patterns );
+      kitty::create_random( tt, std::default_random_engine::result_type( seed + patterns.size() + i ) );
+      patterns.at( i ) = ( patterns.at( i ) & care.at( i ) ) | ( tt & ~care.at( i ) );
+    }
+  }
+
+private:
+  /* all bits in patterns generated before construction are care bits */
+  void fill_cares( uint64_t const num_pis )
+  {
+    for ( auto i = 0u; i < num_pis; ++i )
+    {
+      care.emplace_back( num_patterns );
+      care.back() = ~care.back();
+    }
+  }
+
+  /* move the pattern at position `from` to position `to`. */
+  void move_pattern( uint64_t const from, uint64_t const to )
+  {
+    for ( auto i = 0u; i < patterns.size(); ++i )
+    {
+      if ( !kitty::get_bit( care[i], from ) )
+      {
+        continue;
+      }
+      assert( !kitty::get_bit( care[i], to ) );
+      kitty::copy_bit( patterns[i], from, patterns[i], to );
+      kitty::set_bit( care[i], to );
+      kitty::clear_bit( care[i], from );
+    }
+  }
+
+private:
+  std::vector<kitty::partial_truth_table> care;
+  uint32_t packed_patterns;
+};
+
+/*! \brief Simulates a network with a generic simulator.
+ *
+ * This is a generic simulation algorithm that can simulate arbitrary values.
+ * In order to that, the network needs to implement the `compute` method for
+ * `SimulationType` and one must pass an instance of a `Simulator` that
+ * implements the three methods:
+ * - `SimulationType compute_constant(bool)`
+ * - `SimulationType compute_pi(index)`
+ * - `SimulationType compute_not(SimulationType const&)`
+ *
+ * The method `compute_constant` returns a simulation value for a constant
+ * value.  The method `compute_pi` returns a simulation value for a primary
+ * input based on its index, and `compute_not` to invert a simulation value.
+ *
+ * This method returns a map that maps each node to its computed simulation
+ * value.
+ *
+ * **Required network functions:**
+ * - `foreach_po`
+ * - `get_constant`
+ * - `constant_value`
+ * - `get_node`
+ * - `foreach_pi`
+ * - `foreach_gate`
+ * - `fanin_size`
+ * - `num_pos`
+ * - `compute<SimulationType>`
+ *
+ * \param ntk Network
+ * \param sim Simulator, which implements the simulator interface
+ */
+template<class SimulationType, class Ntk, class Simulator = default_simulator<SimulationType>>
+node_map<SimulationType, Ntk> simulate_nodes( Ntk const& ntk, Simulator const& sim = Simulator() )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_constant_value_v<Ntk>, "Ntk does not implement the constant_value method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_fanin_size_v<Ntk>, "Ntk does not implement the fanin_size method" );
+  static_assert( has_num_pos_v<Ntk>, "Ntk does not implement the num_pos method" );
+  static_assert( has_compute_v<Ntk, SimulationType>, "Ntk does not implement the compute method for SimulationType" );
+
+  node_map<SimulationType, Ntk> node_to_value( ntk );
+
+  node_to_value[ntk.get_node( ntk.get_constant( false ) )] = sim.compute_constant( ntk.constant_value( ntk.get_node( ntk.get_constant( false ) ) ) );
+  if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+  {
+    node_to_value[ntk.get_node( ntk.get_constant( true ) )] = sim.compute_constant( ntk.constant_value( ntk.get_node( ntk.get_constant( true ) ) ) );
+  }
+  ntk.foreach_pi( [&]( auto const& n, auto i ) {
+    node_to_value[n] = sim.compute_pi( i );
+  } );
+
+  ntk.foreach_gate( [&]( auto const& n ) {
+    // skip crossings
+    if constexpr ( has_is_crossing_v<Ntk> )
+    {
+      if ( ntk.is_crossing( n ) )
+      {
+        return;
+      }
+    }
+
+    std::vector<SimulationType> fanin_values( ntk.fanin_size( n ) );
+    auto const fanin_fun = [&]( auto const& f, auto i ) {
+      fanin_values[i] = node_to_value[f];
+    };
+
+    if constexpr ( is_crossed_network_type_v<Ntk> )
+    {
+      ntk.foreach_fanin_ignore_crossings( n, fanin_fun );
+    }
+    else
+    {
+      ntk.foreach_fanin( n, fanin_fun );
+    }
+    node_to_value[n] = ntk.compute( n, fanin_values.begin(), fanin_values.end() );
+  } );
+
+  return node_to_value;
+}
+
+namespace detail
+{
+
+template<class SimulationType, class Ntk, class Simulator, class Container>
+void simulate_nodes_with_node_map( Ntk const& ntk, Container& node_to_value, Simulator const& sim )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_constant_value_v<Ntk>, "Ntk does not implement the constant_value method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_fanin_size_v<Ntk>, "Ntk does not implement the fanin_size method" );
+  static_assert( has_num_pos_v<Ntk>, "Ntk does not implement the num_pos method" );
+  static_assert( has_compute_v<Ntk, SimulationType>, "Ntk does not implement the compute method for SimulationType" );
+
+  /* constants */
+  if ( !node_to_value.has( ntk.get_node( ntk.get_constant( false ) ) ) )
+  {
+    node_to_value[ntk.get_node( ntk.get_constant( false ) )] = sim.compute_constant( ntk.constant_value( ntk.get_node( ntk.get_constant( false ) ) ) );
+  }
+  if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+  {
+    if ( !node_to_value.has( ntk.get_node( ntk.get_constant( true ) ) ) )
+    {
+      node_to_value[ntk.get_node( ntk.get_constant( true ) )] = sim.compute_constant( ntk.constant_value( ntk.get_node( ntk.get_constant( true ) ) ) );
+    }
+  }
+
+  /* pis */
+  ntk.foreach_pi( [&]( auto const& n, auto i ) {
+    if ( !node_to_value.has( n ) )
+    {
+      node_to_value[n] = sim.compute_pi( i );
+    }
+  } );
+
+  /* gates */
+  ntk.foreach_gate( [&]( auto const& n ) {
+    // skip crossings
+    if constexpr ( has_is_crossing_v<Ntk> )
+    {
+      if ( ntk.is_crossing( n ) )
+      {
+        return;
+      }
+    }
+
+    if ( !node_to_value.has( n ) )
+    {
+      std::vector<SimulationType> fanin_values( ntk.fanin_size( n ) );
+      auto const fanin_fun = [&]( auto const& f, auto i ) {
+        fanin_values[i] = node_to_value[ntk.get_node( f )];
+      };
+
+      if constexpr ( is_crossed_network_type_v<Ntk> )
+      {
+        ntk.foreach_fanin_ignore_crossings( n, fanin_fun );
+      }
+      else
+      {
+        ntk.foreach_fanin( n, fanin_fun );
+      }
+
+      node_to_value[n] = ntk.compute( n, fanin_values.begin(), fanin_values.end() );
+    }
+  } );
+}
+
+} // namespace detail
+
+/*! \brief Simulates a network with a generic simulator.
+ *
+ * This is a generic simulation algorithm that can simulate arbitrary values.
+ * In order to that, the network needs to implement the `compute` method for
+ * `SimulationType` and one must pass an instance of a `Simulator` that
+ * implements the three methods:
+ * - `SimulationType compute_constant(bool)`
+ * - `SimulationType compute_pi(index)`
+ * - `SimulationType compute_not(SimulationType const&)`
+ *
+ * The method `compute_constant` returns a simulation value for a constant
+ * value.  The method `compute_pi` returns a simulation value for a primary
+ * input based on its index, and `compute_not` to invert a simulation value.
+ *
+ * This method returns a map that maps each node to its computed simulation
+ * value.
+ *
+ * **Required network functions:**
+ * - `foreach_po`
+ * - `get_constant`
+ * - `constant_value`
+ * - `get_node`
+ * - `foreach_pi`
+ * - `foreach_gate`
+ * - `fanin_size`
+ * - `num_pos`
+ * - `compute<SimulationType>`
+ *
+ * \param ntk Network
+ * \param node_to_value A map from nodes to values
+ * \param sim Simulator, which implements the simulator interface
+ */
+template<class SimulationType, class Ntk, class Simulator = default_simulator<SimulationType>>
+void simulate_nodes( Ntk const& ntk, unordered_node_map<SimulationType, Ntk>& node_to_value, Simulator const& sim = Simulator() )
+{
+  detail::simulate_nodes_with_node_map<SimulationType, Ntk, Simulator, unordered_node_map<SimulationType, Ntk>>( ntk, node_to_value, sim );
+}
+
+template<class SimulationType, class Ntk, class Simulator = default_simulator<SimulationType>>
+void simulate_nodes( Ntk const& ntk, incomplete_node_map<SimulationType, Ntk>& node_to_value, Simulator const& sim = Simulator() )
+{
+  detail::simulate_nodes_with_node_map<SimulationType, Ntk, Simulator, incomplete_node_map<SimulationType, Ntk>>( ntk, node_to_value, sim );
+}
+
+namespace detail
+{
+/* Forward declaration */
+template<class Ntk, class Simulator, class Container>
+void re_simulate_fanin_cone( Ntk const& ntk, typename Ntk::node const& n, Container& node_to_value, Simulator const& sim );
+
+template<class Ntk, class Simulator, class Container>
+void simulate_fanin_cone( Ntk const& ntk, typename Ntk::node const& n, Container& node_to_value, Simulator const& sim )
+{
+  std::vector<kitty::partial_truth_table> fanin_values( ntk.fanin_size( n ) );
+  auto const fanin_fun = [&]( auto const& f, auto i ) {
+    if ( !node_to_value.has( ntk.get_node( f ) ) )
+    {
+      simulate_fanin_cone( ntk, ntk.get_node( f ), node_to_value, sim );
+    }
+    else if ( node_to_value[ntk.get_node( f )].num_bits() != sim.num_bits() )
+    {
+      re_simulate_fanin_cone( ntk, ntk.get_node( f ), node_to_value, sim );
+    }
+    fanin_values[i] = node_to_value[ntk.get_node( f )];
+  };
+
+  if constexpr ( is_crossed_network_type_v<Ntk> )
+  {
+    ntk.foreach_fanin_ignore_crossings( n, fanin_fun );
+  }
+  else
+  {
+    ntk.foreach_fanin( n, fanin_fun );
+  }
+
+  node_to_value[n] = ntk.compute( n, fanin_values.begin(), fanin_values.end() );
+}
+
+template<class Ntk, class Simulator, class Container>
+void re_simulate_fanin_cone( Ntk const& ntk, typename Ntk::node const& n, Container& node_to_value, Simulator const& sim )
+{
+  std::vector<kitty::partial_truth_table> fanin_values( ntk.fanin_size( n ) );
+  auto const fanin_fun = [&]( auto const& f, auto i ) {
+    if ( !node_to_value.has( ntk.get_node( f ) ) )
+    {
+      simulate_fanin_cone( ntk, ntk.get_node( f ), node_to_value, sim );
+    }
+    else if ( node_to_value[ntk.get_node( f )].num_bits() != sim.num_bits() )
+    {
+      re_simulate_fanin_cone( ntk, ntk.get_node( f ), node_to_value, sim );
+    }
+    fanin_values[i] = node_to_value[ntk.get_node( f )];
+  };
+
+  if constexpr ( is_crossed_network_type_v<Ntk> )
+  {
+    ntk.foreach_fanin_ignore_crossings( n, fanin_fun );
+  }
+  else
+  {
+    ntk.foreach_fanin( n, fanin_fun );
+  }
+  ntk.compute( n, node_to_value[n], fanin_values.begin(), fanin_values.end() );
+}
+
+template<class Ntk, class Simulator, class Container>
+void update_const_pi( Ntk const& ntk, Container& node_to_value, Simulator const& sim )
+{
+  /* constants */
+  node_to_value[ntk.get_constant( false )] = sim.compute_constant( ntk.constant_value( ntk.get_node( ntk.get_constant( false ) ) ) );
+  if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+  {
+    node_to_value[ntk.get_constant( true )] = sim.compute_constant( ntk.constant_value( ntk.get_node( ntk.get_constant( true ) ) ) );
+  }
+
+  /* pis */
+  ntk.foreach_pi( [&]( auto const& n, auto i ) {
+    node_to_value[n] = sim.compute_pi( i );
+  } );
+}
+
+} // namespace detail
+
+/*! \brief (Re-)simulate `n` and its transitive fanin cone.
+ *
+ * Note that re-simulation (when `node_to_value.has( n ) == true`) is only done
+ * for the last block, no matter how many bits are used in this block.
+ * Hence, it is advised to call `simulate_nodes` with `simulate_whole_tt = false`
+ * whenever `sim.num_bits() % 64 == 0`.
+ *
+ */
+template<class Ntk, class Simulator = partial_simulator, class Container = unordered_node_map<kitty::partial_truth_table, Ntk>>
+void simulate_node( Ntk const& ntk, typename Ntk::node const& n, Container& node_to_value, Simulator const& sim )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_constant_value_v<Ntk>, "Ntk does not implement the constant_value method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_compute_v<Ntk, kitty::partial_truth_table>, "Ntk does not implement the compute specialization for kitty::partial_truth_table" );
+  static_assert( has_compute_inplace_v<Ntk, kitty::partial_truth_table>, "Ntk does not implement the in-place compute specialization for kitty::partial_truth_table" );
+  static_assert( std::is_same_v<Simulator, partial_simulator> || std::is_same_v<Simulator, bit_packed_simulator>, "This function is specialized for partial_simulator or bit_packed_simulator" );
+
+  if ( node_to_value[ntk.get_node( ntk.get_constant( false ) )].num_bits() != sim.num_bits() )
+  {
+    detail::update_const_pi( ntk, node_to_value, sim );
+  }
+
+  if ( !node_to_value.has( n ) )
+  {
+    detail::simulate_fanin_cone( ntk, n, node_to_value, sim );
+  }
+  else if ( node_to_value[n].num_bits() != sim.num_bits() )
+  {
+    detail::re_simulate_fanin_cone( ntk, n, node_to_value, sim );
+  }
+}
+
+/*! \brief Simulates a network with `partial_simulator` (or `bit_packed_simulator`).
+ *
+ * This is the specialization for `partial_truth_table`.
+ * This function simulates every node in the circuit.
+ *
+ * \param simulate_whole_tt When this parameter is true, it is assumed that `node_to_value.has( n )` is false for every node.
+ * In contrast, when this parameter is false, only the last block of `partial_truth_table` will be re-computed,
+ * and it is assumed that `node_to_value.has( n )` is true for every node.
+ */
+template<class Ntk, class Simulator = partial_simulator, class Container = unordered_node_map<kitty::partial_truth_table, Ntk>>
+void simulate_nodes( Ntk const& ntk, Container& node_to_value, Simulator const& sim, bool simulate_whole_tt )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_constant_value_v<Ntk>, "Ntk does not implement the constant_value method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_compute_v<Ntk, kitty::partial_truth_table>, "Ntk does not implement the compute specialization for kitty::partial_truth_table" );
+  static_assert( has_compute_inplace_v<Ntk, kitty::partial_truth_table>, "Ntk does not implement the in-place compute specialization for kitty::partial_truth_table" );
+  static_assert( std::is_same_v<Simulator, partial_simulator> || std::is_same_v<Simulator, bit_packed_simulator>, "This function is specialized for partial_simulator or bit_packed_simulator" );
+
+  detail::update_const_pi( ntk, node_to_value, sim );
+
+  /* gates */
+  if ( simulate_whole_tt )
+  {
+    ntk.foreach_gate( [&]( auto const& n ) {
+      if ( !node_to_value.has( n ) )
+      {
+        detail::simulate_fanin_cone( ntk, n, node_to_value, sim );
+      }
+    } );
+  }
+  else
+  {
+    ntk.foreach_gate( [&]( auto const& n ) {
+      assert( node_to_value.has( n ) );
+      if ( node_to_value[n].num_bits() != sim.num_bits() )
+      {
+        detail::re_simulate_fanin_cone( ntk, n, node_to_value, sim );
+      }
+    } );
+  }
+}
+
+/*! \brief Simulates a network with a generic simulator.
+ *
+ * This is a generic simulation algorithm that can simulate arbitrary values.
+ * In order to that, the network needs to implement the `compute` method for
+ * `SimulationType` and one must pass an instance of a `Simulator` that
+ * implements the three methods:
+ * - `SimulationType compute_constant(bool)`
+ * - `SimulationType compute_pi(index)`
+ * - `SimulationType compute_not(SimulationType const&)`
+ *
+ * The method `compute_constant` returns a simulation value for a constant
+ * value.  The method `compute_pi` returns a simulation value for a primary
+ * input based on its index, and `compute_not` to invert a simulation value.
+ *
+ * This method returns a vector that maps each primary output (ordered by
+ * position) to it's simulation value (taking possible complemented attributes
+ * into account).
+ *
+ * **Required network functions:**
+ * - `foreach_po`
+ * - `is_complemented`
+ * - `compute<SimulationType>`
+ *
+ * \param ntk Network
+ * \param sim Simulator, which implements the simulator interface
+ */
+template<class SimulationType, class Ntk, class Simulator = default_simulator<SimulationType>>
+std::vector<SimulationType> simulate( Ntk const& ntk, Simulator const& sim = Simulator() )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po function" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented function" );
+  static_assert( has_compute_v<Ntk, SimulationType>, "Ntk does not implement the compute function for SimulationType" );
+
+  auto const node_to_value = simulate_nodes<SimulationType, Ntk, Simulator>( ntk, sim );
+
+  std::vector<SimulationType> po_values( ntk.num_pos() );
+  ntk.foreach_po( [&]( auto const& f, auto i ) {
+    if ( ntk.is_complemented( f ) )
+    {
+      po_values[i] = sim.compute_not( node_to_value[f] );
+    }
+    else
+    {
+      po_values[i] = node_to_value[f];
+    }
+  } );
+  return po_values;
+}
+
+/*! \brief Simulates a buffered network
+ *
+ * The implementation is only slightly different from `simulate` by
+ * replacing `foreach_gate` with `foreach_node` and checking `fanin_size`
+ * because buffers are not counted as gates but still need to be simulated.
+ */
+template<uint32_t NumPIs, class Ntk>
+std::vector<kitty::static_truth_table<NumPIs>> simulate_buffered( Ntk const& ntk )
+{
+  static_assert( has_is_buf_v<Ntk>, "Ntk is not a buffered network type" );
+  static_assert( has_compute_v<Ntk, kitty::static_truth_table<NumPIs>>, "Ntk does not implement the compute function for static_truth_table" );
+  assert( ntk.num_pis() == NumPIs );
+
+  default_simulator<kitty::static_truth_table<NumPIs>> sim;
+  node_map<kitty::static_truth_table<NumPIs>, Ntk> node_to_value( ntk );
+  node_to_value[ntk.get_node( ntk.get_constant( false ) )] = sim.compute_constant( ntk.constant_value( ntk.get_node( ntk.get_constant( false ) ) ) );
+  if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+  {
+    node_to_value[ntk.get_node( ntk.get_constant( true ) )] = sim.compute_constant( ntk.constant_value( ntk.get_node( ntk.get_constant( true ) ) ) );
+  }
+  ntk.foreach_pi( [&]( auto const& n, auto i ) {
+    node_to_value[n] = sim.compute_pi( i );
+  } );
+  ntk.foreach_node( [&]( auto const& n ) {
+    // skip crossings
+    if constexpr ( has_is_crossing_v<Ntk> )
+    {
+      if ( ntk.is_crossing( n ) )
+      {
+        return;
+      }
+    }
+
+    if ( ntk.fanin_size( n ) > 0 )
+    {
+      std::vector<kitty::static_truth_table<NumPIs>> fanin_values( ntk.fanin_size( n ) );
+      auto const fanin_fun = [&]( auto const& f, auto i ) {
+        fanin_values[i] = node_to_value[f];
+      };
+
+      if constexpr ( is_crossed_network_type_v<Ntk> )
+      {
+        ntk.foreach_fanin_ignore_crossings( n, fanin_fun );
+      }
+      else
+      {
+        ntk.foreach_fanin( n, fanin_fun );
+      }
+      node_to_value[n] = ntk.compute( n, fanin_values.begin(), fanin_values.end() );
+    }
+  } );
+
+  std::vector<kitty::static_truth_table<NumPIs>> po_values( ntk.num_pos() );
+  ntk.foreach_po( [&]( auto const& f, auto i ) {
+    if ( ntk.is_complemented( f ) )
+    {
+      po_values[i] = sim.compute_not( node_to_value[f] );
+    }
+    else
+    {
+      po_values[i] = node_to_value[f];
+    }
+  } );
+  return po_values;
+}
+
+} // namespace mockturtle
diff --git a/include/mockturtle/algorithms/testcase_minimizer.hpp b/include/mockturtle/algorithms/testcase_minimizer.hpp
new file mode 100644
index 0000000..34a9a72
--- /dev/null
+++ b/include/mockturtle/algorithms/testcase_minimizer.hpp
@@ -0,0 +1,558 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file testcase_minimizer.hpp
+  \brief Minimize testcase for debugging
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#include "../io/aiger_reader.hpp"
+#include "../io/verilog_reader.hpp"
+#include "../io/write_aiger.hpp"
+#include "../io/write_verilog.hpp"
+#include "../networks/aig.hpp"
+#include "../utils/debugging_utils.hpp"
+#include "../views/color_view.hpp"
+#include "cleanup.hpp"
+
+#include <fmt/format.h>
+#include <lorina/lorina.hpp>
+#include <optional>
+#include <utility>
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for testcase_minimizer. */
+struct testcase_minimizer_params
+{
+  /*! \brief File format of the testcase. */
+  enum
+  {
+    verilog,
+    aiger
+  } file_format = verilog;
+
+  /*! \brief Path to find the initial test case and to store the minimized test case. */
+  std::string path{ "." };
+
+  /*! \brief File name of the initial test case (excluding extension). */
+  std::string init_case{ "testcase" };
+
+  /*! \brief File name of the minimized test case (excluding extension). */
+  std::string minimized_case{ "minimized" };
+
+  /*! \brief Maximum number of iterations in total. nullopt = infinity */
+  std::optional<uint32_t> num_iterations{ std::nullopt };
+
+  /*! \brief Step into the next stage if nothing works for this number of iterations. */
+  std::optional<uint32_t> num_iterations_stage{ std::nullopt };
+
+  /*! \brief Be verbose. */
+  bool verbose{ false };
+
+  /*! \brief Seed of the random generator. */
+  uint64_t seed{ 0xcafeaffe };
+}; /* testcase_minimizer_params */
+
+/*! \brief Debugging testcase minimizer
+ *
+ * Given a (sequence of) algorithm(s) and a testcase that is
+ * known to trigger a bug in the algorithm(s), this utility
+ * minimizes the testcase by trying to remove parts of the network
+ * with an increasing granularity in each stage. Only changes after
+ * which the bug is still triggered are kept; otherwise, the change
+ * is reverted.
+ *
+ * The script of algorithm(s) to be run can be provided as (1) a
+ * lambda function taking a network as input and returning a Boolean,
+ * which is true if the script runs normally and is false otherwise
+ * (i.e. the buggy behavior is observed); or (2) (not supported on
+ * Windows platform) a lambda function making a command string to be
+ * called, taking a filename string as input. The command should return
+ * 0 if the program runs normally, return 1 if the concerned buggy
+ * behavior is observed, and return other values if the input network
+ * is not valid (thus the latest change will not be kept). If the
+ * command segfaults or an assertion fails, it is treated as observing
+ * the buggy behavior.
+ *
+ *
+ *
+  \verbatim embed:rst
+
+   Usage
+
+   .. code-block:: c++
+
+     auto opt = []( mig_network ntk ) -> bool {
+       direct_resynthesis<mig_network> resyn;
+       refactoring( ntk, resyn );
+       return network_is_acyclic( ntk );
+     };
+
+     auto make_command = []( std::string const& filename ) -> std::string {
+       return "./abc -c \"read " + filename + "; drw\"";
+     };
+
+     testcase_minimizer_params ps;
+     ps.path = "."; // current directory
+     testcase_minimizer<mig_network> minimizer( ps );
+     minimizer.run( opt ); // debug algorithms implemented in mockturtle
+     minimizer.run( make_command ); // debug external scripts
+   \endverbatim
+*/
+template<typename Ntk>
+class testcase_minimizer
+{
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+public:
+  explicit testcase_minimizer( testcase_minimizer_params const ps = {} )
+      : ps( ps )
+  {
+    // assert( ps.file_format != testcase_minimizer_params::aiger || std::is_same_v<typename Ntk::base_type, aig_network> );
+    switch ( ps.file_format )
+    {
+    case testcase_minimizer_params::verilog:
+      file_extension = ".v";
+      break;
+    case testcase_minimizer_params::aiger:
+      file_extension = ".aig";
+      break;
+    default:
+      fmt::print( "[e] Unsupported format\n" );
+    }
+    std::srand( ps.seed );
+  }
+
+  void run( std::function<bool( Ntk )> const& fn )
+  {
+    if ( !read_initial_testcase() )
+    {
+      return;
+    }
+
+    if ( !test( fn ) )
+    {
+      fmt::print( "[e] The initial test case does not trigger the buggy behavior\n" );
+      return;
+    }
+
+    uint32_t counter{ 0 };
+    while ( !ps.num_iterations || counter++ < ps.num_iterations )
+    {
+      ntk_backup2 = cleanup_dangling( ntk );
+      if ( !reduce() )
+      {
+        write_testcase( ps.minimized_case );
+        break;
+      }
+      if ( ntk.num_gates() == 0 )
+      {
+        ++stage_counter;
+        ntk = ntk_backup2;
+        continue;
+      }
+
+      if ( test( fn ) )
+      {
+        fmt::print( "[i] Testcase with I/O = {}/{} gates = {} triggers the buggy behavior\n", ntk.num_pis(), ntk.num_pos(), ntk.num_gates() );
+        write_testcase( ps.minimized_case );
+        stage_counter = 0;
+        sampled.clear();
+      }
+      else
+      {
+        ++stage_counter;
+        ntk = ntk_backup2;
+      }
+    }
+
+    if ( init_PIs != ntk.num_pis() || init_POs != ntk.num_pos() || init_gates != ntk.num_gates() )
+    {
+      fmt::print( "[i] Minimized the testcase from I/O = {}/{} gates = {}\n", init_PIs, init_POs, init_gates );
+      fmt::print( "                             to I/O = {}/{} gates = {}\n", ntk.num_pis(), ntk.num_pos(), ntk.num_gates() );
+    }
+  }
+
+#ifndef _MSC_VER
+  void run( std::function<std::string( std::string const& )> const& make_command )
+  {
+    if ( !read_initial_testcase() )
+    {
+      return;
+    }
+
+    if ( !test( make_command, ps.init_case ) )
+    {
+      fmt::print( "[e] The initial test case does not trigger the buggy behavior\n" );
+      return;
+    }
+
+    uint32_t counter{ 0 };
+    while ( !ps.num_iterations || counter++ < ps.num_iterations )
+    {
+      ntk_backup2 = cleanup_dangling( ntk );
+      if ( !reduce() )
+      {
+        break;
+      }
+      if ( ntk.num_gates() == 0 )
+      {
+        ++stage_counter;
+        ntk = ntk_backup2;
+        continue;
+      }
+
+      write_testcase( "tmp" );
+
+      if ( test( make_command, "tmp" ) )
+      {
+        fmt::print( "[i] Testcase with I/O = {}/{} gates = {} triggers the buggy behavior\n", ntk.num_pis(), ntk.num_pos(), ntk.num_gates() );
+        write_testcase( ps.minimized_case );
+        stage_counter = 0;
+        sampled.clear();
+      }
+      else
+      {
+        ++stage_counter;
+        ntk = ntk_backup2;
+      }
+    }
+
+    if ( init_PIs != ntk.num_pis() || init_POs != ntk.num_pos() || init_gates != ntk.num_gates() )
+    {
+      fmt::print( "[i] Minimized the testcase from I/O = {}/{} gates = {}\n", init_PIs, init_POs, init_gates );
+      fmt::print( "                             to I/O = {}/{} gates = {}\n", ntk.num_pis(), ntk.num_pos(), ntk.num_gates() );
+    }
+  }
+#endif
+
+private:
+  bool read_initial_testcase()
+  {
+    switch ( ps.file_format )
+    {
+    case testcase_minimizer_params::verilog:
+      if ( lorina::read_verilog( ps.path + "/" + ps.init_case + file_extension, verilog_reader( ntk ) ) != lorina::return_code::success )
+      {
+        fmt::print( "[e] Could not read test case `{}`\n", ps.path + "/" + ps.init_case + file_extension );
+        return false;
+      }
+      break;
+    case testcase_minimizer_params::aiger:
+      if ( lorina::read_aiger( ps.path + "/" + ps.init_case + file_extension, aiger_reader( ntk ) ) != lorina::return_code::success )
+      {
+        fmt::print( "[e] Could not read test case `{}`\n", ps.path + "/" + ps.init_case + file_extension );
+        return false;
+      }
+      break;
+    default:
+      fmt::print( "[e] Unsupported format\n" );
+      return false;
+    }
+    init_PIs = ntk.num_pis();
+    init_POs = ntk.num_pos();
+    init_gates = ntk.num_gates();
+    return true;
+  }
+
+  void write_testcase( std::string const& filename )
+  {
+    switch ( ps.file_format )
+    {
+    case testcase_minimizer_params::verilog:
+      write_verilog( ntk, ps.path + "/" + filename + file_extension );
+      break;
+    case testcase_minimizer_params::aiger:
+      write_aiger( ntk, ps.path + "/" + filename + file_extension );
+      break;
+    default:
+      fmt::print( "[e] Unsupported format\n" );
+    }
+  }
+
+  bool test( std::function<bool( Ntk )> const& fn )
+  {
+    ntk_backup = cleanup_dangling( ntk );
+    bool res = fn( ntk );
+    ntk = ntk_backup;
+    was_FIT = !res;
+    return was_FIT;
+  }
+
+#ifndef _MSC_VER
+  bool test( std::function<std::string( std::string const& )> const& make_command, std::string const& filename )
+  {
+    was_FIT = test_inner( make_command, filename );
+    return was_FIT;
+  }
+
+  bool test_inner( std::function<std::string( std::string const& )> const& make_command, std::string const& filename )
+  {
+    std::string const command = make_command( ps.path + "/" + filename + file_extension );
+    int status = std::system( command.c_str() );
+    if ( status < 0 )
+    {
+      std::cout << "[e] Unexpected error when calling command: " << strerror( errno ) << '\n';
+      return false;
+    }
+    else
+    {
+      if ( WIFEXITED( status ) )
+      {
+        if ( WEXITSTATUS( status ) == 0 ) // normal
+          return false;
+        else if ( WEXITSTATUS( status ) == 1 ) // buggy
+          return true;
+        else if ( WEXITSTATUS( status ) == 134 ) // assertion fail
+          return true;
+        else
+        {
+          std::cout << "[e] Unexpected return value: " << WEXITSTATUS( status ) << '\n';
+          return false;
+        }
+      }
+      else // segfault
+      {
+        return true;
+      }
+    }
+  }
+#endif
+
+  bool reduce()
+  {
+    pos_to_remove = ntk.num_pos() >> 3; // 1/8
+
+    if ( ( ps.num_iterations_stage && stage_counter >= *ps.num_iterations_stage ) ||
+         ( reducing_stage == many_pos && pos_to_remove > ntk.num_pos() - sampled.size() ) ||
+         ( reducing_stage == many_pos && pos_to_remove < 2 ) ||
+         ( reducing_stage == po && ntk.num_pos() == 1 ) ||
+         ( reducing_stage == po && sampled.size() == ntk.num_pos() ) ||
+         ( reducing_stage == pi && ntk.num_pis() > ntk.num_pos() ) ||
+         ( reducing_stage == pi && sampled.size() == ntk.num_pis() ) ||
+         ( reducing_stage == const_gate && sampled.size() == ntk.num_gates() ) ||
+         ( reducing_stage == mffc && sampled.size() == ntk.num_gates() ) ||
+         ( reducing_stage == half_mffc && sampled.size() == ntk.num_gates() ) ||
+         ( reducing_stage == simplify_tfo && sampled.size() == ntk.num_gates() ) ||
+         ( reducing_stage == single_gate && sampled.size() == ntk.num_gates() ) )
+    {
+      reducing_stage = static_cast<stages>( static_cast<int>( reducing_stage ) + 1 );
+      stage_counter = 0;
+      sampled.clear();
+    }
+
+    switch ( reducing_stage )
+    {
+    case many_pos:
+    {
+      assert( pos_to_remove <= ntk.num_pos() - sampled.size() );
+      if ( ps.verbose )
+        fmt::print( "[i] Remove {} POs\n", pos_to_remove );
+      for ( auto i = 0u; i < pos_to_remove; ++i )
+      {
+        auto const& [ith_po, n] = get_random_po();
+        if ( ntk.is_pi( n ) || ntk.is_constant( n ) )
+          continue;
+        ntk.substitute_node( n, ntk.get_constant( false ) );
+      }
+      break;
+    }
+    case po:
+    {
+      auto const& [ith_po, n] = get_random_po();
+      if ( ps.verbose )
+        fmt::print( "[i] Remove {}-th PO (node {})\n", ith_po, n );
+      ntk.substitute_node( n, ntk.get_constant( false ) );
+      break;
+    }
+    case pi:
+    {
+      const node n = get_random_pi();
+      if ( ps.verbose )
+        fmt::print( "[i] Remove PI {}\n", n );
+      ntk.substitute_node( n, ntk.get_constant( false ) );
+      break;
+    }
+    case const_gate:
+    {
+      node const& n = get_random_gate();
+      if ( ps.verbose )
+        fmt::print( "[i] Substitute gate {} with const0\n", n );
+      ntk.substitute_node( n, ntk.get_constant( false ) );
+      break;
+    }
+    case mffc:
+    {
+      node const& n = get_random_gate();
+      signal fi = ntk.create_pi();
+      if ( ps.verbose )
+        fmt::print( "[i] Substitute gate {} with a new PI {}\n", n, ntk.get_node( fi ) );
+      ntk.substitute_node( n, fi );
+      break;
+    }
+    case half_mffc:
+    {
+      node const& n = get_random_gate();
+      signal fi;
+      uint32_t const ith_fanin = std::rand() % ntk.fanin_size( n );
+      ntk.foreach_fanin( n, [&]( auto const& f, auto i ) {
+        if ( i == ith_fanin )
+          fi = f;
+      } );
+      if ( ps.verbose )
+        fmt::print( "[i] Substitute gate {} with its {}-th fanin {}{}\n", n, ith_fanin, ntk.is_complemented( fi ) ? "!" : "", ntk.get_node( fi ) );
+      ntk.substitute_node( n, fi );
+      assert( network_is_acyclic( color_view{ ntk } ) );
+      break;
+    }
+    case simplify_tfo:
+    {
+      node const& n = get_random_gate();
+      if ( ps.verbose )
+        fmt::print( "[i] Simplify TFO of gate {} with const0 but keep all its fanins\n", n );
+      ntk.foreach_fanin( n, [&]( auto f ) {
+        ntk.create_po( f );
+      } );
+      ntk.substitute_node( n, ntk.get_constant( false ) );
+      break;
+    }
+    case single_gate:
+    {
+      node const& n = get_random_gate();
+      if ( ps.verbose )
+        fmt::print( "[i] Remove a single gate {}\n", n );
+      ntk.foreach_fanin( n, [&]( auto f ) {
+        ntk.create_po( f );
+      } );
+      signal fi = ntk.create_pi();
+      ntk.substitute_node( n, fi );
+      break;
+    }
+    default:
+    {
+      ntk = cleanup_dangling( ntk, true, true );
+      return false; // all stages done, nothing to reduce
+    }
+    }
+
+    ntk = cleanup_dangling( ntk, true, true );
+    return true;
+  }
+
+  std::pair<uint32_t, node> get_random_po()
+  {
+    while ( true )
+    {
+      uint32_t const ith_po = std::rand() % ntk.num_pos();
+      const node n = ntk.get_node( ntk.po_at( ith_po ) );
+      if ( sampled.find( ith_po ) == sampled.end() )
+      {
+        sampled.insert( ith_po );
+        return std::make_pair( ith_po, n );
+      }
+    }
+  }
+
+  node get_random_pi()
+  {
+    while ( true )
+    {
+      uint32_t const ith_pi = std::rand() % ntk.num_pis() + 1;
+      if ( sampled.find( ith_pi ) == sampled.end() )
+      {
+        sampled.insert( ith_pi );
+        return ntk.index_to_node( ith_pi );
+      }
+    }
+  }
+
+  node get_random_gate()
+  {
+    while ( true )
+    {
+      uint32_t const node_index = ( std::rand() % ntk.num_gates() ) + ntk.num_pis() + 1;
+      node n = ntk.index_to_node( node_index );
+      if ( sampled.find( node_index ) == sampled.end() )
+      {
+        sampled.insert( node_index );
+        assert( !ntk.is_dead( n ) && !ntk.is_pi( n ) );
+        return n;
+      }
+    }
+  }
+
+  std::pair<node, node> get_random_gate_with_gate_fanin()
+  {
+    while ( true )
+    {
+      node const& n = get_random_gate();
+      node ni;
+      bool has_gate_fanin = false;
+      ntk.foreach_fanin( n, [&]( auto const& f ) {
+        ni = ntk.get_node( f );
+        if ( !ntk.is_pi( ni ) && !ntk.is_constant( ni ) )
+        {
+          has_gate_fanin = true;
+          return false; // break
+        }
+        return true; // next fanin
+      } );
+      if ( has_gate_fanin )
+      {
+        return std::make_pair( n, ni );
+      }
+    }
+  }
+
+private:
+  testcase_minimizer_params const ps;
+  std::string file_extension;
+  Ntk ntk, ntk_backup, ntk_backup2;
+
+  enum stages : int
+  {
+    pi = 1, // remove a PI (substitute with const0)
+    many_pos,
+    po,           // remove a PO (substitute with const0)
+    const_gate,   // substitute a gate with const0
+    simplify_tfo, // create PO for all of a gate's fanins, then substitute it with const0
+    mffc,         // substitute a gate with a new PI
+    half_mffc,    // substitute a gate with one of its fanin
+    single_gate   // remove a single gate by creating POs for its fanins and substitute it with a new PI
+  } reducing_stage{ pi };
+  uint32_t stage_counter{ 0u };
+  uint32_t pos_to_remove{ 1000 };
+  bool was_FIT{ true };
+  std::set<uint32_t> sampled;
+
+  uint32_t init_PIs, init_POs, init_gates;
+}; /* testcase_minimizer */
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/window_rewriting.hpp b/include/mockturtle/algorithms/window_rewriting.hpp
new file mode 100644
index 0000000..a35ef2d
--- /dev/null
+++ b/include/mockturtle/algorithms/window_rewriting.hpp
@@ -0,0 +1,799 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file window_rewriting.hpp
+  \brief Window rewriting
+
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#include "../networks/aig.hpp"
+#include "../networks/events.hpp"
+#include "../networks/xag.hpp"
+#include "../utils/debugging_utils.hpp"
+#include "../utils/index_list.hpp"
+#include "../utils/network_utils.hpp"
+#include "../utils/node_map.hpp"
+#include "../utils/stopwatch.hpp"
+#include "../utils/window_utils.hpp"
+#include "../views/color_view.hpp"
+#include "../views/depth_view.hpp"
+#include "../views/fanout_view.hpp"
+#include "../views/topo_view.hpp"
+#include "../views/window_view.hpp"
+#include "detail/resub_utils.hpp"
+#include "resyn_engines/xag_resyn.hpp"
+#include "simulation.hpp"
+
+#include <fmt/format.h>
+#include <kitty/kitty.hpp>
+#include <stack>
+
+#pragma once
+
+namespace mockturtle
+{
+
+struct window_rewriting_params
+{
+  uint64_t cut_size{ 6 };
+  uint64_t num_levels{ 5 };
+
+  /* Level information guides the windowing construction and as such impacts QoR:
+     -- dont_update: fastest, but levels are wrong (QoR degrades)
+     -- eager: fast, some levels are wrong
+     -- precise: fast, all levels are correct (best QoR)
+     -- recompute: slow, same as precise (used only for debugging)
+  */
+  enum
+  {
+    /* do not update any levels */
+    dont_update,
+    /* eagerly update the levels of changed nodes but avoid
+       topological sorting (some levels will be wrong) */
+    eager,
+    /* precisely update the levels of changed nodes bottom-to-top and
+       in topological order */
+    precise,
+    /* recompute all levels (also precise, but more expensive to
+       compute) */
+    recompute,
+  } level_update_strategy = dont_update;
+
+  uint64_t max_num_divs{ 100 };
+
+  bool filter_cyclic_substitutions{ false };
+}; /* window_rewriting_params */
+
+struct window_rewriting_stats
+{
+  /*! \brief Total runtime. */
+  stopwatch<>::duration time_total{ 0 };
+
+  /*! \brief Time for constructing windows. */
+  stopwatch<>::duration time_window{ 0 };
+
+  /*! \brief Time for optimizing windows. */
+  stopwatch<>::duration time_optimize{ 0 };
+
+  /*! \brief Time for substituting. */
+  stopwatch<>::duration time_substitute{ 0 };
+
+  /*! \brief Time for updating level information. */
+  stopwatch<>::duration time_levels{ 0 };
+
+  /*! \brief Time for topological sorting. */
+  stopwatch<>::duration time_topo_sort{ 0 };
+
+  /*! \brief Time for encoding index_list. */
+  stopwatch<>::duration time_encode{ 0 };
+
+  /*! \brief Time for computing dependency circuit. */
+  stopwatch<>::duration time_resyn{ 0 };
+
+  /*! \brief Time for simulation. */
+  stopwatch<>::duration time_simulate{ 0 };
+
+  /*! \brief Time for marking TFO and MFFC. */
+  stopwatch<>::duration time_mark{ 0 };
+
+  /*! \brief Time for adding divisor truth tables. */
+  stopwatch<>::duration time_add_divisor{ 0 };
+
+  /*! \brief Time for substitution within windows. */
+  stopwatch<>::duration time_window_substitute{ 0 };
+
+  /*! \brief Time for constructing fanout_view within windows. */
+  stopwatch<>::duration time_fanout_view{ 0 };
+
+  /*! \brief Time for detecting cycles. */
+  stopwatch<>::duration time_cycle{ 0 };
+
+  /*! \brief Total number of calls to the resub. engine. */
+  uint64_t num_resyn_invokes{ 0 };
+  uint64_t num_substitutions{ 0 };
+  uint64_t num_restrashes{ 0 };
+  uint64_t num_windows{ 0 };
+  uint64_t gain{ 0 };
+
+  window_rewriting_stats operator+=( window_rewriting_stats const& other )
+  {
+    time_total += other.time_total;
+    time_window += other.time_window;
+    time_optimize += other.time_optimize;
+    time_substitute += other.time_substitute;
+    time_levels += other.time_levels;
+    time_topo_sort += other.time_topo_sort;
+    time_encode += other.time_encode;
+    time_resyn += other.time_resyn;
+    time_simulate += other.time_simulate;
+    time_mark += other.time_mark;
+    time_add_divisor += other.time_add_divisor;
+    time_window_substitute += other.time_window_substitute;
+    time_fanout_view += other.time_fanout_view;
+    num_substitutions += other.num_substitutions;
+    num_restrashes += other.num_restrashes;
+    num_windows += other.num_windows;
+    num_resyn_invokes += other.num_resyn_invokes;
+    gain += other.gain;
+    return *this;
+  }
+
+  void report() const
+  {
+    stopwatch<>::duration time_other =
+        time_total - time_window - time_topo_sort - time_optimize - time_substitute - time_levels;
+
+    fmt::print( "===========================================================================\n" );
+    fmt::print( "[i] Windowing =  {:7.2f} ({:5.2f}%) (#win = {})\n",
+                to_seconds( time_window ), to_seconds( time_window ) / to_seconds( time_total ) * 100, num_windows );
+    fmt::print( "[i] Top.sort =   {:7.2f} ({:5.2f}%)\n", to_seconds( time_topo_sort ), to_seconds( time_topo_sort ) / to_seconds( time_total ) * 100 );
+    fmt::print( "[i] Enc.list =   {:7.2f} ({:5.2f}%)\n", to_seconds( time_encode ), to_seconds( time_encode ) / to_seconds( time_total ) * 100 );
+    fmt::print( "[i] Optimize =   {:7.2f} ({:5.2f}%) (#invokes = {}, #resubs = {}, est. gain = {})\n",
+                to_seconds( time_optimize ), to_seconds( time_optimize ) / to_seconds( time_total ) * 100, num_resyn_invokes, num_substitutions, gain );
+    fmt::print( "[i] >> resynthesis = {:7.2f} ({:5.2f}%)\n", to_seconds( time_resyn ), to_seconds( time_resyn ) / to_seconds( time_optimize ) * 100 );
+    fmt::print( "[i] >> simulate =    {:7.2f} ({:5.2f}%)\n", to_seconds( time_simulate ), to_seconds( time_simulate ) / to_seconds( time_optimize ) * 100 );
+    fmt::print( "[i] >> marking =     {:7.2f} ({:5.2f}%)\n", to_seconds( time_mark ), to_seconds( time_mark ) / to_seconds( time_optimize ) * 100 );
+    fmt::print( "[i] >> add div. =    {:7.2f} ({:5.2f}%)\n", to_seconds( time_add_divisor ), to_seconds( time_add_divisor ) / to_seconds( time_optimize ) * 100 );
+    fmt::print( "[i] >> substitute =  {:7.2f} ({:5.2f}%)\n", to_seconds( time_window_substitute ), to_seconds( time_window_substitute ) / to_seconds( time_optimize ) * 100 );
+    fmt::print( "[i] >> fanout_view = {:7.2f} ({:5.2f}%)\n", to_seconds( time_fanout_view ), to_seconds( time_fanout_view ) / to_seconds( time_optimize ) * 100 );
+    fmt::print( "[i] Substitute = {:7.2f} ({:5.2f}%) (#hash upd. = {})\n",
+                to_seconds( time_substitute ),
+                to_seconds( time_substitute ) / to_seconds( time_total ) * 100,
+                num_restrashes );
+    fmt::print( "[i] Upd.levels = {:7.2f} ({:5.2f}%)\n", to_seconds( time_levels ), to_seconds( time_levels ) / to_seconds( time_total ) * 100 );
+    fmt::print( "[i] Other =      {:7.2f} ({:5.2f}%)\n", to_seconds( time_other ), to_seconds( time_other ) / to_seconds( time_total ) * 100 );
+    fmt::print( "---------------------------------------------------------------------------\n" );
+    fmt::print( "[i] TOTAL =      {:7.2f}\n", to_seconds( time_total ) );
+    fmt::print( "===========================================================================\n" );
+  }
+}; /* window_rewriting_stats */
+
+namespace detail
+{
+
+template<typename Ntk>
+bool is_contained_in_tfi_recursive( Ntk const& ntk, typename Ntk::node const& node, typename Ntk::node const& n )
+{
+  if ( ntk.color( node ) == ntk.current_color() )
+  {
+    return false;
+  }
+  ntk.paint( node );
+
+  if ( n == node )
+  {
+    return true;
+  }
+
+  bool found = false;
+  ntk.foreach_fanin( node, [&]( typename Ntk::signal const& fi ) {
+    if ( is_contained_in_tfi_recursive( ntk, ntk.get_node( fi ), n ) )
+    {
+      found = true;
+      return false;
+    }
+    return true;
+  } );
+
+  return found;
+}
+
+} /* namespace detail */
+
+template<typename Ntk>
+bool is_contained_in_tfi( Ntk const& ntk, typename Ntk::node const& node, typename Ntk::node const& n )
+{
+  /* do not even build the TFI, but just search for the node */
+  ntk.new_color();
+  return detail::is_contained_in_tfi_recursive( ntk, node, n );
+}
+
+namespace detail
+{
+
+template<typename NtkWin, typename TT>
+struct resyn_sparams : public xag_resyn_static_params
+{
+  using truth_table_storage_type = node_map<TT, NtkWin>;
+  using node_type = typename NtkWin::signal;
+  static constexpr bool use_xor = false;
+};
+
+template<class Ntk, typename NtkWin = Ntk, typename TT = kitty::dynamic_truth_table, typename ResynEngine = xag_resyn_decompose<TT, resyn_sparams<NtkWin, TT>>>
+class window_rewriting_impl
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+public:
+  explicit window_rewriting_impl( Ntk& ntk, window_rewriting_params const& ps, window_rewriting_stats& st )
+      : ntk( ntk ), ps( ps ), st( st )
+        /* initialize levels to network depth */
+        ,
+        levels( ntk.depth() ), engine( engine_st )
+  {
+    register_events();
+  }
+
+  ~window_rewriting_impl()
+  {
+    ntk.events().release_add_event( add_event );
+    ntk.events().release_modified_event( modified_event );
+    ntk.events().release_delete_event( delete_event );
+  }
+
+  void run()
+  {
+    stopwatch t( st.time_total );
+
+    if constexpr ( std::is_same_v<TT, kitty::dynamic_truth_table> )
+    {
+      sim = new default_simulator<TT>( ps.cut_size );
+    }
+    else
+    {
+      sim = new default_simulator<TT>();
+    }
+
+    create_window_impl windowing( ntk );
+    uint32_t const size = ntk.size();
+    for ( uint32_t n = 0u; n < size; ++n )
+    {
+      if ( ntk.is_constant( n ) || ntk.is_ci( n ) || ntk.is_dead( n ) )
+      {
+        continue;
+      }
+
+      if ( auto w = call_with_stopwatch( st.time_window, [&]() { return windowing.run( n, ps.cut_size, ps.num_levels ); } ) )
+      {
+        ++st.num_windows;
+
+        NtkWin win;
+        call_with_stopwatch( st.time_encode, [&]() {
+          clone_subnetwork( ntk, w->inputs, w->outputs, w->nodes, win );
+        } );
+
+        if ( !optimize( win ) )
+        {
+          continue;
+        }
+
+        std::vector<signal> signals;
+        for ( auto const& i : w->inputs )
+        {
+          signals.push_back( ntk.make_signal( i ) );
+        }
+
+        uint32_t counter{ 0 };
+        ++st.num_substitutions;
+        /* ensure that no dead nodes are reachable */
+        assert( count_reachable_dead_nodes( ntk ) == 0u );
+
+        std::list<std::pair<node, signal>> substitutions;
+        insert_ntk( ntk, std::begin( signals ), std::end( signals ), win,
+                    [&]( signal const& _new ) {
+                      assert( !ntk.is_dead( ntk.get_node( _new ) ) );
+                      auto const _old = w->outputs.at( counter++ );
+                      if ( _old == _new )
+                      {
+                        return true;
+                      }
+
+                      /* ensure that _old is not in the TFI of _new */
+                      // assert( !is_contained_in_tfi( ntk, ntk.get_node( _new ), ntk.get_node( _old ) ) );
+                      if ( ps.filter_cyclic_substitutions &&
+                           call_with_stopwatch( st.time_window, [&]() { return is_contained_in_tfi( ntk, ntk.get_node( _new ), ntk.get_node( _old ) ); } ) )
+                      {
+                        std::cout << "undo resubstitution " << ntk.get_node( _old ) << std::endl;
+                        substitutions.emplace_back( std::make_pair( ntk.get_node( _old ), ntk.is_complemented( _old ) ? !_new : _new ) );
+                        for ( auto it = std::rbegin( substitutions ); it != std::rend( substitutions ); ++it )
+                        {
+                          if ( ntk.fanout_size( ntk.get_node( it->second ) ) == 0u )
+                          {
+                            ntk.take_out_node( ntk.get_node( it->second ) );
+                          }
+                        }
+                        substitutions.clear();
+                        return false;
+                      }
+
+                      substitutions.emplace_back( std::make_pair( ntk.get_node( _old ), ntk.is_complemented( _old ) ? !_new : _new ) );
+                      return true;
+                    } );
+
+        /* ensure that no dead nodes are reachable */
+        assert( count_reachable_dead_nodes( ntk ) == 0u );
+        substitute_nodes( substitutions );
+
+        /* recompute levels and depth */
+        if ( ps.level_update_strategy == window_rewriting_params::recompute )
+        {
+          call_with_stopwatch( st.time_levels, [&]() { ntk.update_levels(); } );
+        }
+        if ( ps.level_update_strategy != window_rewriting_params::dont_update )
+        {
+          update_depth();
+        }
+
+        /* ensure that no dead nodes are reachable */
+        assert( count_reachable_dead_nodes( ntk ) == 0u );
+
+        /* ensure that the network structure is still acyclic */
+        assert( network_is_acyclic( ntk ) );
+
+        if ( ps.level_update_strategy == window_rewriting_params::precise ||
+             ps.level_update_strategy == window_rewriting_params::recompute )
+        {
+          /* ensure that the levels and depth is correct */
+          assert( check_network_levels( ntk ) );
+        }
+
+        /* update internal data structures in windowing */
+        windowing.resize( ntk.size() );
+      }
+    }
+
+    /* ensure that no dead nodes are reachable */
+    assert( count_reachable_dead_nodes( ntk ) == 0u );
+
+    delete sim;
+  }
+
+private:
+  void register_events()
+  {
+    auto const update_level_of_new_node = [&]( const auto& n ) {
+      stopwatch t( st.time_total );
+      update_levels( n );
+    };
+
+    auto const update_level_of_existing_node = [&]( node const& n, const auto& old_children ) {
+      (void)old_children;
+      stopwatch t( st.time_total );
+      update_levels( n );
+    };
+
+    auto const update_level_of_deleted_node = [&]( node const& n ) {
+      stopwatch t( st.time_total );
+      assert( ntk.fanout_size( n ) == 0u );
+      assert( ntk.is_dead( n ) );
+      ntk.set_level( n, -1 );
+    };
+
+    add_event = ntk.events().register_add_event( update_level_of_new_node );
+    modified_event = ntk.events().register_modified_event( update_level_of_existing_node );
+    delete_event = ntk.events().register_delete_event( update_level_of_deleted_node );
+  }
+
+  bool optimize( NtkWin& win )
+  {
+    stopwatch t( st.time_optimize );
+    bool changed = false;
+
+    node_map<TT, NtkWin> tts = call_with_stopwatch( st.time_simulate, [&]() {
+      return simulate_nodes<TT, NtkWin>( win, *sim );
+    } );
+    auto win_add_event = win.events().register_add_event( [&]( auto const& n ) {
+      call_with_stopwatch( st.time_simulate, [&]() {
+        tts.resize();
+        std::vector<TT> fanin_values( win.fanin_size( n ) );
+        win.foreach_fanin( n, [&]( auto const& f, auto i ) {
+          fanin_values[i] = tts[f];
+        } );
+        tts[n] = win.compute( n, fanin_values.begin(), fanin_values.end() );
+      } );
+    } );
+    fanout_view<NtkWin> fanout_win = make_with_stopwatch<fanout_view<NtkWin>, NtkWin&>( st.time_fanout_view, win );
+    // fanout_view<NtkWin> fanout_win{win};
+
+    win.foreach_po( [&]( auto const& f ) {
+      auto root = win.get_node( f );
+      if ( win.value( root ) != 1 )
+      {
+        win.set_value( root, 1 );
+        changed |= optimize_node( win, fanout_win, tts, root );
+      }
+    } );
+
+    win.foreach_gate( [&]( auto const& root ) {
+      if ( win.value( root ) != 1 )
+      {
+        win.set_value( root, 1 );
+        bool all_fanin_is_pi = true;
+        win.foreach_fanin( root, [&]( auto const& fi ) {
+          if ( !win.is_pi( win.get_node( fi ) ) )
+          {
+            all_fanin_is_pi = false;
+          }
+        } );
+        if ( !all_fanin_is_pi )
+          changed |= optimize_node( win, fanout_win, tts, root );
+      }
+    } );
+
+    win.events().release_add_event( win_add_event );
+    return changed;
+  }
+
+  bool optimize_node( NtkWin& win, fanout_view<NtkWin>& fanout_win, node_map<TT, NtkWin>& tts, typename NtkWin::node const& root )
+  {
+    st.num_resyn_invokes++;
+
+    auto mffc_size = call_with_stopwatch( st.time_mark, [&]() {
+      /* mark MFFC */
+      std::vector<typename NtkWin::node> mffc;
+      node_mffc_inside<NtkWin> mffc_mgr( win );
+      auto mffc_size = mffc_mgr.run( root, {}, mffc );
+      win.incr_trav_id();
+      for ( auto const& n : mffc )
+      {
+        win.set_visited( n, win.trav_id() );
+      }
+      /* mark TFO */
+      mark_tfo( fanout_win, root );
+
+      /* exclude constant node */
+      if constexpr ( std::is_same_v<typename NtkWin::base_type, aig_network> || std::is_same_v<typename NtkWin::base_type, xag_network> )
+      {
+        win.set_visited( win.get_node( win.get_constant( false ) ), win.trav_id() );
+      }
+      return mffc_size;
+    } );
+
+    /* add divisors (all nodes in the window except TFO and MFFC) */
+    std::vector<typename NtkWin::signal> divs;
+    call_with_stopwatch( st.time_add_divisor, [&]() {
+      win.foreach_node( [&]( auto const& n ) {
+        if ( win.visited( n ) != win.trav_id() )
+        {
+          divs.emplace_back( win.make_signal( n ) );
+          if ( divs.size() > ps.max_num_divs )
+          {
+            return false;
+          }
+        }
+        return true;
+      } );
+    } );
+
+    /* run resynthesis */
+    auto const il = call_with_stopwatch( st.time_resyn, [&]() {
+      return engine( tts[root], ~tts[win.get_constant( false )], divs.begin(), divs.end(), tts, mffc_size - 1 );
+    } );
+    if ( il )
+    {
+      st.gain += mffc_size - il->num_gates();
+      call_with_stopwatch( st.time_window_substitute, [&]() {
+        insert( win, divs.begin(), divs.end(), *il, [&]( auto const& s ) {
+          win.substitute_node( root, s );
+        } );
+      } );
+      return true;
+    }
+    return false;
+  }
+
+  void mark_tfo( fanout_view<NtkWin>& fanout_win, typename NtkWin::node const& n )
+  {
+    fanout_win.set_visited( n, fanout_win.trav_id() );
+    fanout_win.foreach_fanout( n, [&]( auto const& fo ) {
+      if ( fanout_win.visited( fo ) != fanout_win.trav_id() )
+      {
+        mark_tfo( fanout_win, fo );
+      }
+    } );
+  }
+
+private:
+  void substitute_nodes( std::list<std::pair<node, signal>> substitutions )
+  {
+    stopwatch t( st.time_substitute );
+
+    auto clean_substitutions = [&]( node const& n ) {
+      substitutions.erase( std::remove_if( std::begin( substitutions ), std::end( substitutions ),
+                                           [&]( auto const& s ) {
+                                             if ( s.first == n )
+                                             {
+                                               node const nn = ntk.get_node( s.second );
+                                               if ( ntk.is_dead( nn ) )
+                                                 return true;
+
+                                               /* deref fanout_size of the node */
+                                               if ( ntk.fanout_size( nn ) > 0 )
+                                               {
+                                                 ntk.decr_fanout_size( nn );
+                                               }
+                                               /* remove the node if its fanout_size becomes 0 */
+                                               if ( ntk.fanout_size( nn ) == 0 )
+                                               {
+                                                 ntk.take_out_node( nn );
+                                               }
+                                               /* remove substitution from list */
+                                               return true;
+                                             }
+                                             return false; /* keep */
+                                           } ),
+                           std::end( substitutions ) );
+    };
+
+    /* register event to delete substitutions if their right-hand side
+       nodes get deleted */
+    auto clean_subs_event = ntk.events().register_delete_event( clean_substitutions );
+
+    /* increment fanout_size of all signals to be used in
+       substitutions to ensure that they will not be deleted */
+    for ( const auto& s : substitutions )
+    {
+      ntk.incr_fanout_size( ntk.get_node( s.second ) );
+    }
+
+    while ( !substitutions.empty() )
+    {
+      auto const [old_node, new_signal] = substitutions.front();
+      substitutions.pop_front();
+
+      for ( auto index : ntk.fanout( old_node ) )
+      {
+        /* skip CIs and dead nodes */
+        if ( ntk.is_dead( index ) )
+        {
+          continue;
+        }
+
+        /* skip nodes that will be deleted */
+        if ( std::find_if( std::begin( substitutions ), std::end( substitutions ),
+                           [&index]( auto s ) { return s.first == index; } ) != std::end( substitutions ) )
+        {
+          continue;
+        }
+
+        /* replace in node */
+        if ( const auto repl = ntk.replace_in_node( index, old_node, new_signal ); repl )
+        {
+          ntk.incr_fanout_size( ntk.get_node( repl->second ) );
+          substitutions.emplace_back( *repl );
+          ++st.num_restrashes;
+        }
+      }
+
+      /* replace in outputs */
+      ntk.replace_in_outputs( old_node, new_signal );
+
+      /* replace in substitutions */
+      for ( auto& s : substitutions )
+      {
+        if ( ntk.get_node( s.second ) == old_node )
+        {
+          s.second = ntk.is_complemented( s.second ) ? !new_signal : new_signal;
+          ntk.incr_fanout_size( ntk.get_node( new_signal ) );
+        }
+      }
+
+      /* finally remove the node: note that we never decrement the
+         fanout_size of the old_node. instead, we remove the node and
+         reset its fanout_size to 0 knowing that it must be 0 after
+         substituting all references. */
+      assert( !ntk.is_dead( old_node ) );
+      ntk.take_out_node( old_node );
+
+      /* decrement fanout_size when released from substitution list */
+      ntk.decr_fanout_size( ntk.get_node( new_signal ) );
+      if ( ntk.fanout_size( ntk.get_node( new_signal ) ) == 0 )
+      {
+        ntk.take_out_node( ntk.get_node( new_signal ) );
+      }
+    }
+
+    ntk.events().release_delete_event( clean_subs_event );
+  }
+
+  void update_levels( node const& n )
+  {
+    ntk.resize_levels();
+    if ( ps.level_update_strategy == window_rewriting_params::precise )
+    {
+      call_with_stopwatch( st.time_levels, [&]() { update_node_level_precise( n ); } );
+    }
+    else if ( ps.level_update_strategy == window_rewriting_params::eager )
+    {
+      call_with_stopwatch( st.time_levels, [&]() { update_node_level_eager( n ); } );
+    }
+
+    /* levels can be wrong until substitute_nodes has finished */
+    // assert( check_network_levels( ntk ) );
+  }
+
+  /* precisely update node levels using an iterative topological sorting approach */
+  void update_node_level_precise( node const& n )
+  {
+    assert( count_reachable_dead_nodes_from_node( ntk, n ) == 0u );
+    // assert( count_nodes_with_dead_fanins( ntk, n ) == 0u );
+
+    /* compute level of current node */
+    uint32_t level_offset{ 0 };
+    ntk.foreach_fanin( n, [&]( signal const& fi ) {
+      level_offset = std::max( ntk.level( ntk.get_node( fi ) ), level_offset );
+    } );
+    ++level_offset;
+
+    /* add node into levels */
+    if ( levels.size() < 1u )
+    {
+      levels.resize( 1u );
+    }
+    levels[0].emplace_back( n );
+
+    for ( uint32_t level_index = 0u; level_index < levels.size(); ++level_index )
+    {
+      if ( levels[level_index].empty() )
+        continue;
+
+      for ( uint32_t node_index = 0u; node_index < levels[level_index].size(); ++node_index )
+      {
+        node const p = levels[level_index][node_index];
+
+        /* recompute level of this node */
+        uint32_t lvl{ 0 };
+        ntk.foreach_fanin( p, [&]( signal const& fi ) {
+          if ( ntk.is_dead( ntk.get_node( fi ) ) )
+            return;
+
+          lvl = std::max( ntk.level( ntk.get_node( fi ) ), lvl );
+          return;
+        } );
+        ++lvl;
+        assert( lvl > 0 );
+
+        /* update level and add fanouts to levels[.] if the recomputed
+           level is different from the current level */
+        if ( lvl != ntk.level( p ) )
+        {
+          ntk.set_level( p, lvl );
+          ntk.foreach_fanout( p, [&]( node const& fo ) {
+            assert( std::max( ntk.level( fo ), lvl + 1 ) >= level_offset );
+            uint32_t const pos = std::max( ntk.level( fo ), lvl + 1 ) - level_offset;
+            assert( pos >= 0u );
+            assert( pos >= level_index );
+            if ( levels.size() <= pos )
+            {
+              levels.resize( std::max( uint32_t( levels.size() << 1 ), pos + 1 ) );
+            }
+            levels[pos].emplace_back( fo );
+          } );
+        }
+      }
+
+      /* clean the level */
+      levels[level_index].clear();
+    }
+    levels.clear();
+  }
+
+  /* eagerly update the node levels without topologically sorting (may
+     stack-overflow if the network is deep)*/
+  void update_node_level_eager( node const& n )
+  {
+    uint32_t const curr_level = ntk.level( n );
+    uint32_t max_level = 0;
+    ntk.foreach_fanin( n, [&]( const auto& f ) {
+      auto const p = ntk.get_node( f );
+      auto const fanin_level = ntk.level( p );
+      if ( fanin_level > max_level )
+      {
+        max_level = fanin_level;
+      }
+    } );
+    ++max_level;
+
+    if ( curr_level != max_level )
+    {
+      ntk.set_level( n, max_level );
+      ntk.foreach_fanout( n, [&]( const auto& p ) {
+        if ( !ntk.is_dead( p ) )
+        {
+          update_node_level_eager( p );
+        }
+      } );
+    }
+  }
+
+  /* update network depth (needs level information!) */
+  void update_depth()
+  {
+    stopwatch t( st.time_levels );
+
+    uint32_t max_level{ 0 };
+    ntk.foreach_co( [&]( signal const& s ) {
+      assert( !ntk.is_dead( ntk.get_node( s ) ) );
+      max_level = std::max( ntk.level( ntk.get_node( s ) ), max_level );
+    } );
+
+    if ( ntk.depth() != max_level )
+    {
+      ntk.set_depth( max_level );
+    }
+  }
+
+private:
+  Ntk& ntk;
+  window_rewriting_params ps;
+  window_rewriting_stats& st;
+
+  std::vector<std::vector<node>> levels;
+
+  /* events */
+  std::shared_ptr<typename network_events<Ntk>::add_event_type> add_event;
+  std::shared_ptr<typename network_events<Ntk>::modified_event_type> modified_event;
+  std::shared_ptr<typename network_events<Ntk>::delete_event_type> delete_event;
+
+  default_simulator<TT>* sim;
+  typename ResynEngine::stats engine_st;
+  ResynEngine engine;
+}; /* window_rewriting_impl */
+
+} /* namespace detail */
+
+template<class Ntk>
+void window_rewriting( Ntk& ntk, window_rewriting_params const& ps = {}, window_rewriting_stats* pst = nullptr )
+{
+  fanout_view fntk{ ntk };
+  depth_view dntk{ fntk };
+  color_view cntk{ dntk };
+
+  window_rewriting_stats st;
+  using NtkWin = typename Ntk::base_type;
+  using TT = kitty::dynamic_truth_table;
+  detail::window_rewriting_impl<decltype( cntk ), NtkWin, TT>( cntk, ps, st ).run();
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/xag_algebraic_rewriting.hpp b/include/mockturtle/algorithms/xag_algebraic_rewriting.hpp
new file mode 100644
index 0000000..358ea75
--- /dev/null
+++ b/include/mockturtle/algorithms/xag_algebraic_rewriting.hpp
@@ -0,0 +1,565 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xag_algebraic_rewriting.hpp
+  \brief xag algebraric rewriting
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <iostream>
+#include <optional>
+
+#include "../views/fanout_view.hpp"
+#include "../views/topo_view.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for xag_algebraic_depth_rewriting.
+ *
+ * The data structure `xag_algebraic_depth_rewriting_params` holds configurable
+ * parameters with default arguments for `xag_algebraic_depth_rewriting`.
+ */
+struct xag_algebraic_depth_rewriting_params
+{
+  /*! \brief Rewriting strategy. */
+  enum strategy_t
+  {
+    /*! \brief DFS rewriting strategy.
+     *
+     * Applies depth rewriting once to all output cones whose drivers have
+     * maximum levels
+     */
+    dfs,
+    /*! \brief Aggressive rewriting strategy.
+     *
+     * Applies depth reduction multiple times until the number of nodes, which
+     * cannot be rewritten, matches the number of nodes, in the current
+     * network; or the new network size is larger than the initial size w.r.t.
+     * to an `overhead`.
+     */
+    aggressive,
+    /*! \brief Selective rewriting strategy.
+     *
+     * Like `aggressive`, but only applies rewriting to nodes on critical paths
+     * and without `overhead`.
+     */
+    selective
+  } strategy = dfs;
+
+  /*! \brief Overhead factor in aggressive rewriting strategy.
+   *
+   * When comparing to the initial size in aggressive depth rewriting, also the
+   * number of dangling nodes are taken into account.
+   */
+  float overhead{ 2.0f };
+
+  /*! \brief Allow area increase while optimizing depth. */
+  bool allow_area_increase{ true };
+
+  /*! \brief Try rules that are rarely applied. */
+  bool allow_rare_rules{ false };
+};
+
+namespace detail
+{
+
+template<class Ntk>
+class xag_algebraic_depth_rewriting_impl
+{
+public:
+  xag_algebraic_depth_rewriting_impl( Ntk& ntk, xag_algebraic_depth_rewriting_params const& ps )
+      : ntk( ntk ), ps( ps )
+  {
+  }
+
+  void run()
+  {
+    switch ( ps.strategy )
+    {
+    case xag_algebraic_depth_rewriting_params::dfs:
+      run_dfs();
+      break;
+    case xag_algebraic_depth_rewriting_params::selective:
+      run_selective();
+      break;
+    case xag_algebraic_depth_rewriting_params::aggressive:
+      run_aggressive();
+      break;
+    }
+  }
+
+private:
+  void run_dfs()
+  {
+    ntk.foreach_po( [this]( auto po ) {
+      const auto driver = ntk.get_node( po );
+      if ( ntk.level( driver ) < ntk.depth() )
+        return;
+      topo_view topo{ ntk, po };
+      topo.foreach_node( [&]( auto n ) {
+        bool res = reduce_depth_and_associativity( n );
+        res |= reduce_depth_xor_associativity( n );
+
+        if ( ps.allow_area_increase && !res )
+        {
+          reduce_depth_and_or_distributivity( n );
+
+          reduce_depth_and_xor_distributivity( n );
+        }
+
+        if ( ps.allow_rare_rules && !res )
+          res = reduce_depth_and_distributity( n );
+
+        return true;
+      } );
+    } );
+  }
+
+  void run_selective()
+  {
+    uint32_t counter{ 0 };
+    while ( true )
+    {
+      mark_critical_paths();
+
+      topo_view topo{ ntk };
+      topo.foreach_node( [this, &counter]( auto n ) {
+        if ( ntk.fanout_size( n ) == 0 || ntk.value( n ) == 0 )
+          return;
+
+        bool res = reduce_depth_and_associativity( n );
+        res |= reduce_depth_xor_associativity( n );
+
+        if ( ps.allow_area_increase && !res )
+        {
+          reduce_depth_and_or_distributivity( n );
+
+          reduce_depth_and_xor_distributivity( n );
+        }
+
+        if ( ps.allow_rare_rules && !res )
+          res = reduce_depth_and_distributity( n );
+
+        if ( res )
+        {
+          mark_critical_paths();
+        }
+        else
+        {
+          ++counter;
+        }
+      } );
+
+      if ( counter > ntk.size() )
+        break;
+    }
+  }
+
+  void run_aggressive()
+  {
+    uint32_t counter{ 0 }, init_size{ ntk.size() };
+    while ( true )
+    {
+      topo_view topo{ ntk };
+      topo.foreach_node( [this, &counter]( auto n ) {
+        if ( ntk.fanout_size( n ) == 0 )
+          return;
+
+        bool res = reduce_depth_and_associativity( n );
+        res |= reduce_depth_xor_associativity( n );
+
+        if ( ps.allow_area_increase && !res )
+        {
+          reduce_depth_and_or_distributivity( n );
+
+          reduce_depth_and_xor_distributivity( n );
+        }
+
+        if ( ps.allow_rare_rules && !res )
+          res = reduce_depth_and_distributity( n );
+
+        if ( !res )
+        {
+          ++counter;
+        }
+      } );
+
+      if ( ntk.size() > ps.overhead * init_size )
+        break;
+      if ( counter > ntk.size() )
+        break;
+    }
+  }
+
+private:
+  /* AND associativity */
+  bool reduce_depth_and_associativity( node<Ntk> const& n )
+  {
+    if ( !ntk.is_and( n ) )
+      return false;
+
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    if ( !ntk.is_and( ntk.get_node( ocs[1] ) ) || ntk.is_complemented( ocs[1] ) )
+      return false;
+
+    /* depth of second child must be (significantly) higher than depth of first child */
+    if ( ntk.level( ntk.get_node( ocs[1] ) ) <= ntk.level( ntk.get_node( ocs[0] ) ) + 1 )
+      return false;
+
+    /* child must have single fanout, if no area overhead is allowed */
+    if ( !ps.allow_area_increase && ntk.fanout_size( ntk.get_node( ocs[1] ) ) != 1 )
+      return false;
+
+    /* get children of second child */
+    auto ocs1 = ordered_children( ntk.get_node( ocs[1] ) );
+
+    /* depth of second grand-child must be higher than depth of first grand-child */
+    if ( ntk.level( ntk.get_node( ocs1[1] ) ) == ntk.level( ntk.get_node( ocs1[0] ) ) )
+      return false;
+
+    auto opt = ntk.create_and( ocs1[1], ntk.create_and( ocs[0], ocs1[0] ) );
+    ntk.substitute_node( n, opt );
+    ntk.update_levels();
+
+    return true;
+  }
+
+  /* XOR associativity */
+  bool reduce_depth_xor_associativity( node<Ntk> const& n )
+  {
+    if ( !ntk.is_xor( n ) )
+      return false;
+
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    if ( !ntk.is_xor( ntk.get_node( ocs[1] ) ) )
+      return false;
+
+    /* depth of second child must be (significantly) higher than depth of first child */
+    if ( ntk.level( ntk.get_node( ocs[1] ) ) <= ntk.level( ntk.get_node( ocs[0] ) ) + 1 )
+      return false;
+
+    /* child must have single fanout, if no area overhead is allowed */
+    if ( !ps.allow_area_increase && ntk.fanout_size( ntk.get_node( ocs[1] ) ) != 1 )
+      return false;
+
+    /* get children of last child */
+    auto ocs1 = ordered_children( ntk.get_node( ocs[1] ) );
+
+    /* depth of second grand-child must be higher than depth of first grand-child */
+    if ( ntk.level( ntk.get_node( ocs1[1] ) ) == ntk.level( ntk.get_node( ocs1[0] ) ) )
+      return false;
+
+    auto opt = ntk.create_xor( ocs1[1], ntk.create_xor( ocs[0], ocs1[0] ) );
+
+    if ( ntk.is_complemented( ocs[1] ) )
+      opt = !opt;
+
+    ntk.substitute_node( n, opt );
+    ntk.update_levels();
+
+    return true;
+  }
+
+  /* AND distributivity */
+  bool reduce_depth_and_distributity( node<Ntk> const& n )
+  {
+    if ( !ntk.is_and( n ) )
+      return false;
+
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    if ( !ntk.is_and( ntk.get_node( ocs[0] ) ) || !ntk.is_complemented( ocs[0] ) )
+      return false;
+
+    if ( !ntk.is_and( ntk.get_node( ocs[1] ) ) || !ntk.is_complemented( ocs[1] ) )
+      return false;
+
+    /* children must have single fanout, if no area overhead is allowed */
+    if ( !ps.allow_area_increase && ( ntk.fanout_size( ntk.get_node( ocs[0] ) ) != 1 || ntk.fanout_size( ntk.get_node( ocs[1] ) ) != 1 ) )
+      return false;
+
+    /* get children of first child */
+    auto ocs0 = ordered_children( ntk.get_node( ocs[0] ) );
+
+    /* get children of second child */
+    auto ocs1 = ordered_children( ntk.get_node( ocs[1] ) );
+
+    /* find common support */
+    bool critical_common = false;
+    signal<Ntk> common, x, y;
+    if ( ocs0[0] == ocs1[0] )
+    {
+      common = ocs0[0];
+      x = ocs0[1];
+      y = ocs1[1];
+    }
+    else if ( ocs0[0] == ocs1[1] )
+    {
+      common = ocs0[0];
+      x = ocs0[1];
+      y = ocs1[0];
+    }
+    else if ( ocs0[1] == ocs1[0] )
+    {
+      common = ocs0[1];
+      x = ocs0[0];
+      y = ocs1[1];
+    }
+    else if ( ocs0[1] == ocs1[1] )
+    {
+      common = ocs0[1];
+      x = ocs0[0];
+      y = ocs1[0];
+      critical_common = true;
+    }
+    else
+    {
+      return false;
+    }
+
+    /* common signal is not critical, children must have single fanout, to not increase the area */
+    if ( !critical_common && ( ntk.fanout_size( ntk.get_node( ocs[0] ) ) != 1 || ntk.fanout_size( ntk.get_node( ocs[1] ) ) != 1 ) )
+      return false;
+
+    auto opt = !ntk.create_and( common, !ntk.create_and( !x, !y ) );
+    ntk.substitute_node( n, opt );
+    ntk.update_levels();
+
+    return true;
+  }
+
+  /* AND-OR distributivity */
+  bool reduce_depth_and_or_distributivity( node<Ntk> const& n )
+  {
+    if ( !ntk.is_and( n ) )
+      return false;
+
+    if ( ntk.level( n ) < 3 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    if ( !ntk.is_and( ntk.get_node( ocs[1] ) ) || !ntk.is_complemented( ocs[1] ) )
+      return false;
+
+    /* depth of second child must be significantly higher than depth of first child */
+    if ( ntk.level( ntk.get_node( ocs[1] ) ) <= ntk.level( ntk.get_node( ocs[0] ) ) + 2 )
+      return false;
+
+    /* get children of last child */
+    auto ocs1 = ordered_children( ntk.get_node( ocs[1] ) );
+
+    if ( !ntk.is_and( ntk.get_node( ocs1[1] ) ) || !ntk.is_complemented( ocs1[1] ) )
+      return false;
+
+    /* depth of second grand-child must be higher than depth of first grand-child */
+    if ( ntk.level( ntk.get_node( ocs1[1] ) ) == ntk.level( ntk.get_node( ocs1[0] ) ) )
+      return false;
+
+    /* get children of last grand-child */
+    auto ocs11 = ordered_children( ntk.get_node( ocs1[1] ) );
+
+    /* depth of second grand-grand-child must be higher than depth of first grand-grand-child */
+    if ( ntk.level( ntk.get_node( ocs11[1] ) ) == ntk.level( ntk.get_node( ocs11[0] ) ) )
+      return false;
+
+    auto opt = !ntk.create_and( !ntk.create_and( ocs[0], !ocs1[0] ), !ntk.create_and( ntk.create_and( ocs[0], ocs11[0] ), ocs11[1] ) );
+    ntk.substitute_node( n, opt );
+    ntk.update_levels();
+
+    return true;
+  }
+
+  /* AND-XOR distributivity */
+  bool reduce_depth_and_xor_distributivity( node<Ntk> const& n )
+  {
+    if ( !ntk.is_and( n ) )
+      return false;
+
+    if ( ntk.level( n ) < 3 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    if ( !ntk.is_xor( ntk.get_node( ocs[1] ) ) )
+      return false;
+
+    /* depth of second child must be significantly higher than depth of first child */
+    if ( ntk.level( ntk.get_node( ocs[1] ) ) <= ntk.level( ntk.get_node( ocs[0] ) ) + 2 )
+      return false;
+
+    /* get children of last child */
+    auto ocs1 = ordered_children( ntk.get_node( ocs[1] ) );
+
+    if ( !ntk.is_and( ntk.get_node( ocs1[1] ) ) )
+      return false;
+
+    /* depth of second grand-child must be higher than depth of first grand-child */
+    if ( ntk.level( ntk.get_node( ocs1[1] ) ) == ntk.level( ntk.get_node( ocs1[0] ) ) )
+      return false;
+
+    /* get children of last grand-child */
+    auto ocs11 = ordered_children( ntk.get_node( ocs1[1] ) );
+
+    /* depth of second grand-grand-child must be higher than depth of first grand-grand-child */
+    if ( ntk.level( ntk.get_node( ocs11[1] ) ) == ntk.level( ntk.get_node( ocs11[0] ) ) )
+      return false;
+
+    /* if XOR is complemented, complement first grand-child */
+    if ( ntk.is_complemented( ocs[1] ) != ntk.is_complemented( ocs1[1] ) )
+    {
+      ocs1[0] = !ocs1[0];
+    }
+
+    auto opt = ntk.create_xor( ntk.create_and( ocs[0], ocs1[0] ), ntk.create_and( ntk.create_and( ocs[0], ocs11[0] ), ocs11[1] ) );
+    ntk.substitute_node( n, opt );
+    ntk.update_levels();
+
+    return true;
+  }
+
+  inline std::array<signal<Ntk>, 2> ordered_children( node<Ntk> const& n ) const
+  {
+    std::array<signal<Ntk>, 2> children;
+    ntk.foreach_fanin( n, [&children]( auto const& f, auto i ) {
+      children[i] = f;
+    } );
+    if ( ntk.level( ntk.get_node( children[0] ) ) > ntk.level( ntk.get_node( children[1] ) ) )
+    {
+      std::swap( children[0], children[1] );
+    }
+    return children;
+  }
+
+  void mark_critical_path( node<Ntk> const& n )
+  {
+    if ( ntk.is_pi( n ) || ntk.is_constant( n ) || ntk.value( n ) )
+      return;
+
+    const auto level = ntk.level( n );
+    ntk.set_value( n, 1 );
+    ntk.foreach_fanin( n, [this, level]( auto const& f ) {
+      if ( ntk.level( ntk.get_node( f ) ) == level - 1 )
+      {
+        mark_critical_path( ntk.get_node( f ) );
+      }
+    } );
+  }
+
+  void mark_critical_paths()
+  {
+    ntk.clear_values();
+    ntk.foreach_po( [this]( auto const& f ) {
+      if ( ntk.level( ntk.get_node( f ) ) == ntk.depth() )
+      {
+        mark_critical_path( ntk.get_node( f ) );
+      }
+    } );
+  }
+
+private:
+  Ntk& ntk;
+  xag_algebraic_depth_rewriting_params const& ps;
+};
+
+} // namespace detail
+
+/*! \brief XAG algebraic depth rewriting.
+ *
+ * This algorithm tries to rewrite a network with AND/XOR gates for depth
+ * optimization using the associativity and distributivity rule in
+ * AND-XOR logic.  It can be applied to networks other than XAGs, but
+ * only considers pairs of nodes which both implement the AND
+ * function and the XOR function.
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `level`
+ * - `update_levels`
+ * - `create_and`
+ * - `create_xor`
+ * - `substitute_node`
+ * - `foreach_node`
+ * - `foreach_po`
+ * - `foreach_fanin`
+ * - `is_and`
+ * - `is_xor`
+ * - `clear_values`
+ * - `set_value`
+ * - `value`
+ * - `fanout_size`
+ *
+   \verbatim embed:rst
+
+  .. note::
+
+   \endverbatim
+ */
+template<class Ntk>
+void xag_algebraic_depth_rewriting( Ntk& ntk, xag_algebraic_depth_rewriting_params const& ps = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_level_v<Ntk>, "Ntk does not implement the level method" );
+  static_assert( has_create_and_v<Ntk>, "Ntk does not implement the create_maj method" );
+  static_assert( has_create_xor_v<Ntk>, "Ntk does not implement the create_maj method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the substitute_node method" );
+  static_assert( has_update_levels_v<Ntk>, "Ntk does not implement the update_levels method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_is_and_v<Ntk>, "Ntk does not implement the is_and method" );
+  static_assert( has_is_xor_v<Ntk>, "Ntk does not implement the is_xor method" );
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_value_v<Ntk>, "Ntk does not implement the value method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+
+  detail::xag_algebraic_depth_rewriting_impl<Ntk> p( ntk, ps );
+  p.run();
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/xag_balancing.hpp b/include/mockturtle/algorithms/xag_balancing.hpp
new file mode 100644
index 0000000..e3e6cfc
--- /dev/null
+++ b/include/mockturtle/algorithms/xag_balancing.hpp
@@ -0,0 +1,729 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xag_balancing.hpp
+  \brief Balances the XAG to reduce the depth
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <vector>
+#include <random>
+#include <algorithm>
+
+#include "cleanup.hpp"
+#include "../networks/aig.hpp"
+#include "../traits.hpp"
+#include "../views/depth_view.hpp"
+#include "../views/fanout_view.hpp"
+
+namespace mockturtle
+{
+
+struct xag_balancing_params
+{
+  /*! \brief Minimizes the number of levels. */
+  bool minimize_levels{ true };
+
+  /*! \brief Use fast version, it may not find some area optimizations. */
+  bool fast_mode{ true };
+};
+
+namespace detail
+{
+
+template<class Ntk>
+class xag_balance_impl
+{
+public:
+  static constexpr size_t storage_init_size = 30;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  using storage_t = std::vector<std::vector<signal>>;
+
+public:
+  xag_balance_impl( Ntk& ntk, xag_balancing_params const& ps )
+      : ntk( ntk ), ps( ps ), storage( storage_init_size )
+  {
+  }
+
+  void run()
+  {
+    ntk.clear_values();
+
+    for ( auto i = 0; i < storage_init_size; ++i )
+      storage[i].reserve( 10 );
+
+    /* balance every CO */
+    ntk.foreach_co( [&]( auto const& f ) {
+      balance_rec( ntk.get_node( f ), 0 );
+    } );
+  }
+
+private:
+  signal balance_rec( node const& n, uint32_t level )
+  {
+    if ( ntk.is_ci( n ) )
+      return ntk.make_signal( n );
+
+    /* node has been replaced in a previous recursion */
+    if ( ntk.is_dead( n ) || ntk.value( n ) > 0 )
+    {
+      return ntk.make_signal( find_substituted_node( n ) );
+    }
+
+    if ( level >= storage.size() )
+    {
+      storage.emplace_back( std::vector<signal>() );
+      storage.back().reserve( 10 );
+    }
+
+    /* collect leaves of the AND or XOR trees */
+    bool polarity = false;
+    bool is_and = true;
+    if constexpr ( has_is_xor_v<Ntk> )
+    {
+      if ( ntk.is_and( n ) )
+      {
+        collect_leaves_and( n, storage[level] );
+      }
+      else
+      {
+        polarity = collect_leaves_xor( n, storage[level] );
+        is_and = false;
+      }
+    }
+    else
+    {
+      collect_leaves_and( n, storage[level] );
+    }
+
+    if ( storage[level].size() == 0 )
+    {
+      ntk.substitute_node( n, ntk.get_constant( polarity ) );
+      return ntk.get_constant( polarity );
+    }
+
+    /* recur over the leaves */
+    for ( auto& f : storage[level] )
+    {
+      signal new_signal = balance_rec( ntk.get_node( f ), level + 1 );
+      f = new_signal ^ ntk.is_complemented( f );
+    }
+
+    assert( storage[level].size() > 1 );
+
+    /* sort by decreasing level */
+    std::stable_sort( storage[level].begin(), storage[level].end(), [this]( auto const& a, auto const& b ) {
+      return ntk.level( ntk.get_node( a ) ) > ntk.level( ntk.get_node( b ) );
+    } );
+
+    /* mark TFI cone of n */
+    ntk.incr_trav_id();
+    mark_tfi( ntk.make_signal( n ), true );
+
+    /* generate the AND or XOR tree */
+    if ( is_and )
+    {
+      while ( storage[level].size() > 1 )
+      {
+        /* explore multiple possibilities to find logic sharing */
+        if ( ps.fast_mode )
+        {
+          if ( ps.minimize_levels )
+            pick_nodes_and_fast( storage[level], find_left_most_at_level( storage[level] ) );
+          else
+            pick_nodes_and_area_fast( storage[level] );
+        }
+        else
+        {
+          if ( ps.minimize_levels )
+            pick_nodes_and( storage[level], find_left_most_at_level( storage[level] ) );
+          else
+            pick_nodes_and_area( storage[level] );
+        }
+
+        /* pop the two selected nodes to create the new AND gate */
+        signal child1 = storage[level].back();
+        storage[level].pop_back();
+        signal child2 = storage[level].back();
+        storage[level].pop_back();
+        signal new_sig = ntk.create_and( child1, child2 );
+
+        /* update level for AND node */
+        update_level( ntk.get_node( new_sig ) );
+
+        /* insert the new node back */
+        insert_node_sorted_and( storage[level], new_sig );
+      }
+    }
+    else
+    {
+      while ( storage[level].size() > 1 )
+      {
+        /* explore multiple possibilities to find logic sharing */
+        if ( ps.fast_mode )
+        {
+          if ( ps.minimize_levels )
+            pick_nodes_xor_fast( storage[level], find_left_most_at_level( storage[level] ) );
+          else
+            pick_nodes_xor_area_fast( storage[level] );
+        }
+        else
+        {
+          if ( ps.minimize_levels )
+            pick_nodes_xor( storage[level], find_left_most_at_level( storage[level] ) );
+          else
+            pick_nodes_xor_area( storage[level] );
+        }
+
+        /* pop the two selected nodes to create the new XOR gate */
+        signal child1 = storage[level].back();
+        storage[level].pop_back();
+        signal child2 = storage[level].back();
+        storage[level].pop_back();
+        signal new_sig = ntk.create_xor( child1, child2 );
+
+        /* update level for XOR node */
+        update_level( ntk.get_node( new_sig ) );
+
+        /* insert the new node back */
+        insert_node_sorted_xor( storage[level], new_sig, polarity );
+      }
+    }
+
+    signal root = storage[level][0] ^ polarity;
+
+    /* replace if new */
+    if ( n != ntk.get_node( root ) )
+    {
+      ntk.substitute_node_no_restrash( n, root );
+    }
+
+    /* remember the substitution and the new node as already balanced */
+    ntk.set_value( n, ntk.node_to_index( ntk.get_node( root ) ) );
+    ntk.set_value( ntk.get_node( root ), ntk.node_to_index( ntk.get_node( root ) ) );
+
+    /* clean leaves storage */
+    storage[level].clear();
+
+    return root;
+  }
+
+  void collect_leaves_and( node const& n, std::vector<signal>& leaves )
+  {
+    ntk.incr_trav_id();
+
+    int ret = collect_leaves_and_rec( ntk.make_signal( n ), leaves, true );
+
+    /* check for constant false */
+    if ( ret < 0 )
+    {
+      leaves.clear();
+    }
+  }
+
+  int collect_leaves_and_rec( signal const& f, std::vector<signal>& leaves, bool is_root )
+  {
+    node n = ntk.get_node( f );
+
+    /* check if already visited */
+    if ( ntk.visited( n ) == ntk.trav_id() )
+    {
+      for ( signal const& s : leaves )
+      {
+        if ( ntk.get_node( s ) != n )
+          continue;
+
+        if ( s == f )
+          return 1;   /* same polarity: duplicate */
+        else
+          return -1;  /* opposite polarity: const0 */
+      }
+
+      return 0;
+    }
+
+    /* set as leaf if signal is complemented or is a XOR or is a CI or has a multiple fanout */
+    if ( !is_root && ( ntk.is_complemented( f ) || ntk.is_xor( n ) || ntk.is_ci( n ) || ntk.fanout_size( n ) > 1 ) )
+    {
+      leaves.push_back( f );
+      ntk.set_visited( n, ntk.trav_id() );
+      return 0;
+    }
+
+    int ret = 0;
+    ntk.foreach_fanin( n, [&]( auto const& child ) {
+      ret |= collect_leaves_and_rec( child, leaves, false );
+    } );
+
+    return ret;
+  }
+
+  bool collect_leaves_xor( node const& n, std::vector<signal>& leaves )
+  {
+    ntk.incr_trav_id();
+
+    int ret = collect_leaves_xor_rec( ntk.make_signal( n ), leaves, true );
+
+    /* return top polarity */
+    return ret ? true : false;
+  }
+
+  int collect_leaves_xor_rec( signal const& f, std::vector<signal>& leaves, bool is_root )
+  {
+    node n = ntk.get_node( f );
+
+    /* check if already visited */
+    if ( ntk.visited( n ) == ntk.trav_id() )
+    {
+      auto it = leaves.begin();
+      while ( it != leaves.end() )
+      {
+        if ( ntk.get_node( *it ) != n )
+        {
+          ++it;
+          continue;
+        }
+
+        /* remove node (XOR property) */
+        if ( ntk.get_node( *it ) == n )
+          leaves.erase( it );
+
+        return 0;
+      }
+
+      return 0;
+    }
+
+    /* set as leaf if signal is an AND or is a CI or has a multiple fanout */
+    if ( !is_root && ( ntk.is_and( n ) || ntk.is_ci( n ) || ntk.fanout_size( n ) > 1 ) )
+    {
+      leaves.push_back( f ^ ntk.is_complemented( f ) );
+      ntk.set_visited( n, ntk.trav_id() );
+      return 0;
+    }
+
+    int ret = 0;
+    ntk.foreach_fanin( n, [&]( auto const& child ) {
+      ret ^= ntk.is_complemented( child ) ? 1 : 0;
+      ret ^= collect_leaves_xor_rec( child, leaves, false );
+    } );
+
+    return ret;
+  }
+
+  size_t find_left_most_at_level( std::vector<signal> const& leaves )
+  {
+    size_t pointer = leaves.size() - 1;
+    uint32_t current_level = ntk.level( ntk.get_node( leaves[leaves.size() - 2] ) );
+
+    while ( pointer > 0 )
+    {
+      if ( ntk.level( ntk.get_node( leaves[pointer - 1] ) ) > current_level )
+        break;
+
+      --pointer;
+    }
+
+    assert( ntk.level( ntk.get_node( leaves[pointer] ) ) == current_level );
+    return pointer;
+  }
+
+  inline void pick_nodes_and( std::vector<signal>& leaves, size_t left_most )
+  {
+    size_t right_most = leaves.size() - 2;
+
+    if ( ntk.level( ntk.get_node( leaves[leaves.size() - 1] ) ) == ntk.level( ntk.get_node( leaves[leaves.size() - 2] ) ) )
+      right_most = left_most;
+
+    for ( size_t right_pointer = leaves.size() - 1; right_pointer > right_most; --right_pointer )
+    {
+      assert( left_most < right_pointer );
+
+      size_t left_pointer = right_pointer;
+      while ( left_pointer-- > left_most )
+      {
+        /* select if node exists */
+        std::optional<signal> pnode = ntk.has_and( leaves[right_pointer], leaves[left_pointer] );
+        if ( pnode.has_value() )
+        {
+          /* already present in TFI */
+          if ( ntk.visited( ntk.get_node( *pnode ) ) == ntk.trav_id() )
+          {
+            continue;
+          }
+
+          if ( leaves[right_pointer] != leaves[leaves.size() - 1] )
+            std::swap( leaves[right_pointer], leaves[leaves.size() - 1] );
+          if ( leaves[left_pointer] != leaves[leaves.size() - 2] )
+            std::swap( leaves[left_pointer], leaves[leaves.size() - 2] );
+          break;
+        }
+      }
+    }
+  }
+
+  inline void pick_nodes_and_fast( std::vector<signal>& leaves, size_t left_most )
+  {
+    size_t left_pointer = leaves.size() - 1;
+    while ( left_pointer-- > left_most )
+    {
+      /* select if node exists */
+      std::optional<signal> pnode = ntk.has_and( leaves.back(), leaves[left_pointer] );
+      if ( pnode.has_value() )
+      {
+        /* already present in TFI */
+        if ( ntk.visited( ntk.get_node( *pnode ) ) == ntk.trav_id() )
+        {
+          continue;
+        }
+
+        if ( leaves[left_pointer] != leaves[leaves.size() - 2] )
+          std::swap( leaves[left_pointer], leaves[leaves.size() - 2] );
+        break;
+      }
+    }
+  }
+
+  inline void pick_nodes_and_area( std::vector<signal>& leaves )
+  {
+    for ( size_t right_pointer = leaves.size() - 1; right_pointer > 0; --right_pointer )
+    {
+      size_t left_pointer = right_pointer;
+      while ( left_pointer-- > 0 )
+      {
+        /* select if node exists */
+        std::optional<signal> pnode = ntk.has_and( leaves[right_pointer], leaves[left_pointer] );
+        if ( pnode.has_value() )
+        {
+          /* already present in TFI */
+          if ( ntk.visited( ntk.get_node( *pnode ) ) == ntk.trav_id() )
+          {
+            continue;
+          }
+
+          if ( leaves[right_pointer] != leaves[leaves.size() - 1] )
+            std::swap( leaves[right_pointer], leaves[leaves.size() - 1] );
+          if ( leaves[left_pointer] != leaves[leaves.size() - 2] )
+            std::swap( leaves[left_pointer], leaves[leaves.size() - 2] );
+          break;
+        }
+      }
+    }
+  }
+
+  inline void pick_nodes_and_area_fast( std::vector<signal>& leaves )
+  {
+    size_t left_pointer = leaves.size() - 1;
+    while ( left_pointer-- > 0 )
+    {
+      /* select if node exists */
+      std::optional<signal> pnode = ntk.has_and( leaves.back(), leaves[left_pointer] );
+      if ( pnode.has_value() )
+      {
+        /* already present in TFI */
+        if ( ntk.visited( ntk.get_node( *pnode ) ) == ntk.trav_id() )
+        {
+          continue;
+        }
+
+        if ( leaves[left_pointer] != leaves[leaves.size() - 2] )
+          std::swap( leaves[left_pointer], leaves[leaves.size() - 2] );
+        break;
+      }
+    }
+  }
+
+  inline void pick_nodes_xor( std::vector<signal>& leaves, size_t left_most )
+  {
+    size_t right_most = leaves.size() - 2;
+
+    if ( ntk.level( ntk.get_node( leaves[leaves.size() - 1] ) ) == ntk.level( ntk.get_node( leaves[leaves.size() - 2] ) ) )
+      right_most = left_most;
+
+    for ( size_t right_pointer = leaves.size() - 1; right_pointer > right_most; --right_pointer )
+    {
+      assert( left_most < right_pointer );
+
+      size_t left_pointer = right_pointer;
+      while ( left_pointer-- > left_most )
+      {
+        /* select if node exists */
+        std::optional<signal> pnode = ntk.has_xor( leaves[right_pointer], leaves[left_pointer] );
+        if ( pnode.has_value() )
+        {
+          /* already present in TFI */
+          if ( ntk.visited( ntk.get_node( *pnode ) ) == ntk.trav_id() )
+          {
+            continue;
+          }
+
+          if ( leaves[right_pointer] != leaves[leaves.size() - 1] )
+            std::swap( leaves[right_pointer], leaves[leaves.size() - 1] );
+          if ( leaves[left_pointer] != leaves[leaves.size() - 2] )
+            std::swap( leaves[left_pointer], leaves[leaves.size() - 2] );
+          break;
+        }
+      }
+    }
+  }
+
+  inline void pick_nodes_xor_fast( std::vector<signal>& leaves, size_t left_most )
+  {
+    size_t left_pointer = leaves.size() - 1;
+    while ( left_pointer-- > left_most )
+    {
+      /* select if node exists */
+      std::optional<signal> pnode = ntk.has_xor( leaves.back(), leaves[left_pointer] );
+      if ( pnode.has_value() )
+      {
+        /* already present in TFI */
+        if ( ntk.visited( ntk.get_node( *pnode ) ) == ntk.trav_id() )
+        {
+          continue;
+        }
+
+        if ( leaves[left_pointer] != leaves[leaves.size() - 2] )
+          std::swap( leaves[left_pointer], leaves[leaves.size() - 2] );
+        break;
+      }
+    }
+  }
+
+  inline void pick_nodes_xor_area( std::vector<signal>& leaves )
+  {
+    for ( size_t right_pointer = leaves.size() - 1; right_pointer > 0; --right_pointer )
+    {
+      size_t left_pointer = right_pointer;
+      while ( left_pointer-- > 0 )
+      {
+        /* select if node exists */
+        std::optional<signal> pnode = ntk.has_xor( leaves[right_pointer], leaves[left_pointer] );
+        if ( pnode.has_value() )
+        {
+          /* already present in TFI */
+          if ( ntk.visited( ntk.get_node( *pnode ) ) == ntk.trav_id() )
+          {
+            continue;
+          }
+
+          if ( leaves[right_pointer] != leaves[leaves.size() - 1] )
+            std::swap( leaves[right_pointer], leaves[leaves.size() - 1] );
+          if ( leaves[left_pointer] != leaves[leaves.size() - 2] )
+            std::swap( leaves[left_pointer], leaves[leaves.size() - 2] );
+          break;
+        }
+      }
+    }
+  }
+
+  inline void pick_nodes_xor_area_fast( std::vector<signal>& leaves )
+  {
+    size_t left_pointer = leaves.size() - 1;
+    while ( left_pointer-- > 0 )
+    {
+      /* select if node exists */
+      std::optional<signal> pnode = ntk.has_xor( leaves.back(), leaves[left_pointer] );
+      if ( pnode.has_value() )
+      {
+        /* already present in TFI */
+        if ( ntk.visited( ntk.get_node( *pnode ) ) == ntk.trav_id() )
+        {
+          continue;
+        }
+
+        if ( leaves[left_pointer] != leaves[leaves.size() - 2] )
+          std::swap( leaves[left_pointer], leaves[leaves.size() - 2] );
+        break;
+      }
+    }
+  }
+
+  void insert_node_sorted_and( std::vector<signal>& leaves, signal const& f )
+  {
+    node n = ntk.get_node( f );
+
+    /* check uniqueness */
+    for ( auto const& s : leaves )
+    {
+      if ( s == f )
+        return;
+    }
+
+    leaves.push_back( f );
+    for ( size_t i = leaves.size() - 1; i > 0; --i )
+    {
+      auto& s2 = leaves[i - 1];
+
+      if ( ntk.level( ntk.get_node( s2 ) ) < ntk.level( n ) )
+      {
+        std::swap( s2, leaves[i] );
+      }
+      else
+      {
+        break;
+      }
+    }
+  }
+
+  void insert_node_sorted_xor( std::vector<signal>& leaves, signal const& f, bool& polarity )
+  {
+    node n = ntk.get_node( f );
+
+    /* check uniqueness */
+    auto it = leaves.begin();
+    while ( it != leaves.end() )
+    {
+      if ( ntk.get_node( *it ) == ntk.get_node( f ) )
+      {
+        polarity ^= ntk.is_complemented( f ) ^ ntk.is_complemented( *it );
+        leaves.erase( it );
+        return;
+      }
+
+      ++it;
+    }
+
+    leaves.push_back( f );
+    for ( size_t i = leaves.size() - 1; i > 0; --i )
+    {
+      auto& s2 = leaves[i - 1];
+
+      if ( ntk.level( ntk.get_node( s2 ) ) < ntk.level( n ) )
+      {
+        std::swap( s2, leaves[i] );
+      }
+      else
+      {
+        break;
+      }
+    }
+  }
+
+  void update_level( node const& n )
+  {
+    uint32_t l = 0;
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      l = std::max( l, ntk.level( ntk.get_node( f ) ) );
+    } );
+
+    ntk.set_level( n, l + 1 );
+  }
+
+  node find_substituted_node( node n )
+  {
+    while ( ntk.is_dead( n ) )
+      n = ntk.index_to_node( ntk.value( n ) );
+    
+    return n;
+  }
+
+  void mark_tfi( signal const& f, bool is_root )
+  {
+    node n = ntk.get_node( f );
+
+    /* check if already visited */
+    if ( ntk.visited( n ) == ntk.trav_id() )
+      return;
+
+    ntk.set_visited( n, ntk.trav_id() );
+
+    /* set as leaf if signal is complemented or is a CI or has a multiple fanout */
+    if ( !is_root && ( ntk.is_complemented( f ) || ntk.is_ci( n ) || ntk.fanout_size( n ) > 1 ) )
+    {
+      return;
+    }
+
+    ntk.foreach_fanin( n, [&]( auto const& child ) {
+      mark_tfi( child, false );
+    } );
+  }
+
+private:
+  Ntk& ntk;
+  xag_balancing_params const& ps;
+
+  storage_t storage;
+};
+
+} /* namespace detail */
+
+/*! \brief XAG balancing.
+ *
+ * This method balance the XAG to reduce the
+ * depth. Level minimization can be turned off.
+ * In this case, balancing tries to reconstruct
+ * AND and XOR trees such that logic sharing is maximized.
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `node_to_index`
+ * - `get_constant`
+ * - `create_pi`
+ * - `create_po`
+ * - `create_not`
+ * - `is_complemented`
+ * - `foreach_node`
+ * - `foreach_pi`
+ * - `foreach_po`
+ * - `clone_node`
+ * - `is_pi`
+ * - `is_constant`
+ * - `has_and`
+ */
+template<class Ntk>
+void xag_balance( Ntk& ntk, xag_balancing_params const& ps = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_clone_node_v<Ntk>, "Ntk does not implement the clone_node method" );
+  static_assert( has_create_pi_v<Ntk>, "Ntk does not implement the create_pi method" );
+  static_assert( has_create_po_v<Ntk>, "Ntk does not implement the create_po method" );
+  static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_has_and_v<Ntk>, "Ntk does not implement the has_and method" );
+  static_assert( has_has_xor_v<Ntk>, "Ntk does not implement the has_xor method" );
+
+  fanout_view<Ntk> f_ntk{ ntk };
+  depth_view<fanout_view<Ntk>> d_ntk{ f_ntk };
+
+  detail::xag_balance_impl p( d_ntk, ps );
+  p.run();
+
+  ntk = cleanup_dangling( ntk );
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/xag_optimization.hpp b/include/mockturtle/algorithms/xag_optimization.hpp
new file mode 100644
index 0000000..d07ac24
--- /dev/null
+++ b/include/mockturtle/algorithms/xag_optimization.hpp
@@ -0,0 +1,273 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xag_optimization.hpp
+  \brief Various XAG optimization algorithms
+
+  \author Bruno Schmitt
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Zhufei Chu
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <functional>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include <bill/sat/interface/common.hpp>
+#include <bill/sat/interface/glucose.hpp>
+
+#include "../algorithms/extract_linear.hpp"
+#include "../algorithms/linear_resynthesis.hpp"
+#include "../io/write_verilog.hpp"
+#include "../networks/xag.hpp"
+#include "../properties/mccost.hpp"
+#include "../utils/node_map.hpp"
+#include "../views/topo_view.hpp"
+#include "cleanup.hpp"
+#include "dont_cares.hpp"
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+class xag_constant_fanin_optimization_impl
+{
+public:
+  xag_constant_fanin_optimization_impl( xag_network const& xag )
+      : xag( xag )
+  {
+  }
+
+  xag_network run()
+  {
+    xag_network dest;
+
+    node_map<xag_network::signal, xag_network> old2new( xag );
+    node_map<std::vector<xag_network::node>, xag_network> lfi( xag );
+
+    old2new[xag.get_node( xag.get_constant( false ) )] = dest.get_constant( false );
+    if ( xag.get_node( xag.get_constant( true ) ) != xag.get_node( xag.get_constant( false ) ) )
+    {
+      old2new[xag.get_node( xag.get_constant( true ) )] = dest.get_constant( true );
+    }
+    xag.foreach_pi( [&]( auto const& n ) {
+      old2new[n] = dest.create_pi();
+      lfi[n].emplace_back( n );
+    } );
+    topo_view topo{ xag };
+    topo.foreach_node( [&]( auto const& n ) {
+      if ( xag.is_constant( n ) || xag.is_pi( n ) )
+        return;
+
+      if ( xag.is_xor( n ) )
+      {
+        std::array<xag_network::signal*, 2> children{};
+        std::array<std::vector<xag_network::node>*, 2> clfi{};
+        xag.foreach_fanin( n, [&]( auto const& f, auto i ) {
+          children[i] = &old2new[f];
+          clfi[i] = &lfi[f];
+        } );
+        lfi[n] = merge( *clfi[0], *clfi[1] );
+        if ( lfi[n].size() == 0 )
+        {
+          old2new[n] = dest.get_constant( false );
+        }
+        else if ( lfi[n].size() == 1 )
+        {
+          old2new[n] = old2new[lfi[n].front()];
+        }
+        else
+        {
+          old2new[n] = dest.create_xor( *children[0], *children[1] );
+        }
+      }
+      else /* is AND */
+      {
+        lfi[n].emplace_back( n );
+        std::vector<xag_network::signal> children;
+        xag.foreach_fanin( n, [&]( auto const& f ) {
+          children.push_back( old2new[f] ^ xag.is_complemented( f ) );
+        } );
+        old2new[n] = dest.create_and( children[0], children[1] );
+      }
+    } );
+
+    xag.foreach_po( [&]( auto const& f ) {
+      dest.create_po( old2new[f] ^ xag.is_complemented( f ) );
+    } );
+
+    return cleanup_dangling( dest );
+  }
+
+private:
+  std::vector<xag_network::node> merge( std::vector<xag_network::node> const& s1, std::vector<xag_network::node> const& s2 ) const
+  {
+    std::vector<xag_network::node> s;
+    std::set_symmetric_difference( s1.cbegin(), s1.cend(), s2.cbegin(), s2.cend(), std::back_inserter( s ) );
+    return s;
+  }
+
+private:
+  xag_network const& xag;
+};
+
+} // namespace detail
+
+/*! \brief Optimizes some AND gates by computing transitive linear fanin
+ *
+ * This function reevaluates the transitive linear fanin for each AND gate.
+ * This is a subnetwork composed of all immediate XOR gates in the transitive
+ * fanin cone until primary inputs or AND gates are reached.  This linear
+ * transitive fanin might be constant for some fanin due to the cancellation
+ * property of the XOR operation.  In such cases the AND gate can be replaced
+ * by a constant or a fanin.
+ */
+inline xag_network xag_constant_fanin_optimization( xag_network const& xag )
+{
+  return detail::xag_constant_fanin_optimization_impl( xag ).run();
+}
+
+/*! \brief Optimizes some AND gates using satisfiability don't cares
+ *
+ * If an AND gate is satisfiability don't care for assignment 00, it can be
+ * replaced by an XNOR gate, therefore reducing the multiplicative complexity.
+ */
+inline xag_network xag_dont_cares_optimization( xag_network const& xag )
+{
+  node_map<xag_network::signal, xag_network> old_to_new( xag );
+
+  xag_network dest;
+  old_to_new[xag.get_constant( false )] = dest.get_constant( false );
+
+  xag.foreach_pi( [&]( auto const& n ) {
+    old_to_new[n] = dest.create_pi();
+  } );
+
+  satisfiability_dont_cares_checker<xag_network> checker( xag );
+
+  topo_view<xag_network>{ xag }.foreach_node( [&]( auto const& n ) {
+    if ( xag.is_constant( n ) || xag.is_pi( n ) )
+      return;
+
+    std::array<xag_network::signal, 2> fanin{};
+    xag.foreach_fanin( n, [&]( auto const& f, auto i ) {
+      fanin[i] = old_to_new[f] ^ xag.is_complemented( f );
+    } );
+
+    if ( xag.is_and( n ) )
+    {
+      if ( checker.is_dont_care( n, { false, false } ) )
+      {
+        old_to_new[n] = dest.create_xnor( fanin[0], fanin[1] );
+      }
+      else
+      {
+        old_to_new[n] = dest.create_and( fanin[0], fanin[1] );
+      }
+    }
+    else /* is XOR */
+    {
+      old_to_new[n] = dest.create_xor( fanin[0], fanin[1] );
+    }
+  } );
+
+  xag.foreach_po( [&]( auto const& f ) {
+    dest.create_po( old_to_new[f] ^ xag.is_complemented( f ) );
+  } );
+
+  return dest;
+}
+
+/*! \brief Optimizes XOR gates by linear network resynthesis
+ *
+ * See `exact_linear_resynthesis_optimization` for an example implementation
+ * of this function.
+ */
+inline xag_network linear_resynthesis_optimization( xag_network const& xag, std::function<xag_network( xag_network const& )> linear_resyn, std::function<void( std::vector<uint32_t> const& )> const& on_ignore_inputs = {} )
+{
+  const auto num_ands = *multiplicative_complexity( xag );
+  if ( num_ands == 0u )
+  {
+    return linear_resyn( xag );
+  }
+
+  const auto linear = extract_linear_circuit( xag ).first;
+
+  /* ignore inputs (if linear resynthesis is not cancellation-free) */
+  on_ignore_inputs( {} );
+  for ( auto i = 0u; i < num_ands; ++i )
+  {
+    std::vector<uint32_t> ignore( num_ands - i );
+    std::iota( ignore.begin(), ignore.end(), xag.num_pis() + i );
+    on_ignore_inputs( ignore );
+    on_ignore_inputs( ignore );
+  }
+
+  const auto linear_optimized = linear_resyn( linear );
+
+  assert( linear.num_pis() == linear_optimized.num_pis() );
+  assert( linear.num_pos() == linear_optimized.num_pos() );
+  assert( linear.num_pis() == xag.num_pis() + num_ands );
+  assert( linear.num_pos() == 1 + 2 * num_ands );
+
+  return merge_linear_circuit( linear_optimized, num_ands );
+}
+
+/*! \brief Optimizes XOR gates by exact linear network resynthesis
+ */
+template<bill::solvers Solver = bill::solvers::glucose_41>
+inline xag_network exact_linear_resynthesis_optimization( xag_network const& xag, uint32_t conflict_limit = 0u )
+{
+  exact_linear_synthesis_params ps;
+  ps.conflict_limit = conflict_limit;
+
+  const auto linear_resyn = [&]( xag_network const& linear ) {
+    if ( const auto optimized = exact_linear_resynthesis<xag_network, Solver>( linear, ps ); optimized )
+    {
+      return *optimized;
+    }
+    else
+    {
+      return linear;
+    }
+  };
+
+  const auto on_ignore_inputs = [&]( std::vector<uint32_t> const& ignore ) {
+    ps.ignore_inputs.push_back( ignore );
+  };
+
+  return linear_resynthesis_optimization( xag, linear_resyn, on_ignore_inputs );
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/xag_resub.hpp b/include/mockturtle/algorithms/xag_resub.hpp
new file mode 100644
index 0000000..1a2774f
--- /dev/null
+++ b/include/mockturtle/algorithms/xag_resub.hpp
@@ -0,0 +1,216 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2024  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xag_resub.hpp
+  \brief XAG-specific resubstitution rules
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include "../networks/xag.hpp"
+#include "../utils/index_list.hpp"
+#include "../utils/truth_table_utils.hpp"
+#include "resubstitution.hpp"
+#include "resyn_engines/xag_resyn.hpp"
+
+#include <kitty/kitty.hpp>
+
+namespace mockturtle
+{
+
+struct xag_resyn_resub_stats
+{
+  /*! \brief Time for finding dependency function. */
+  stopwatch<>::duration time_compute_function{ 0 };
+
+  /*! \brief Number of found solutions. */
+  uint32_t num_success{ 0 };
+
+  /*! \brief Number of times that no solution can be found. */
+  uint32_t num_fail{ 0 };
+
+  void report() const
+  {
+    fmt::print( "[i]     <ResubFn: xag_resyn_functor>\n" );
+    fmt::print( "[i]         #solution = {:6d}\n", num_success );
+    fmt::print( "[i]         #invoke   = {:6d}\n", num_success + num_fail );
+    fmt::print( "[i]         engine time: {:>5.2f} secs\n", to_seconds( time_compute_function ) );
+  }
+}; /* xag_resyn_resub_stats */
+
+/*! \brief Interfacing resubstitution functor with XAG resynthesis engines for `window_based_resub_engine`.
+ */
+template<typename Ntk, typename Simulator, typename TTcare, typename ResynEngine = xag_resyn_decompose<typename Simulator::truthtable_t, xag_resyn_static_params_for_win_resub<Ntk>>>
+struct xag_resyn_functor
+{
+public:
+  using node = xag_network::node;
+  using signal = xag_network::signal;
+  using stats = xag_resyn_resub_stats;
+  using TT = typename ResynEngine::truth_table_t;
+
+  static_assert( std::is_same_v<TT, typename Simulator::truthtable_t>, "truth table type of the simulator does not match" );
+
+public:
+  explicit xag_resyn_functor( Ntk& ntk, Simulator const& sim, std::vector<node> const& divs, uint32_t num_divs, stats& st )
+      : ntk( ntk ), sim( sim ), tts( ntk ), divs( divs ), st( st )
+  {
+    assert( divs.size() == num_divs );
+    (void)num_divs;
+    div_signals.reserve( divs.size() );
+  }
+
+  std::optional<signal> operator()( node const& root, TTcare care, uint32_t required, uint32_t max_inserts, uint32_t potential_gain, uint32_t& real_gain )
+  {
+    (void)required;
+    TT target = sim.get_tt( sim.get_phase( root ) ? !ntk.make_signal( root ) : ntk.make_signal( root ) );
+    TT care_transformed = target.construct();
+    care_transformed = care;
+
+    typename ResynEngine::stats st_eng;
+    ResynEngine engine( st_eng );
+    for ( auto const& d : divs )
+    {
+      div_signals.emplace_back( sim.get_phase( d ) ? !ntk.make_signal( d ) : ntk.make_signal( d ) );
+      tts[d] = sim.get_tt( ntk.make_signal( d ) );
+    }
+
+    auto const res = call_with_stopwatch( st.time_compute_function, [&]() {
+      return engine( target, care_transformed, std::begin( divs ), std::end( divs ), tts, std::min( potential_gain - 1, max_inserts ) );
+    } );
+    if ( res )
+    {
+      ++st.num_success;
+      signal ret;
+      real_gain = potential_gain - ( *res ).num_gates();
+      insert( ntk, div_signals.begin(), div_signals.end(), *res, [&]( signal const& s ) { ret = s; } );
+      return ret;
+    }
+    else
+    {
+      ++st.num_fail;
+      return std::nullopt;
+    }
+  }
+
+private:
+  Ntk& ntk;
+  Simulator const& sim;
+  unordered_node_map<TT, Ntk> tts;
+  std::vector<node> const& divs;
+  std::vector<signal> div_signals;
+  stats& st;
+}; /* xag_resyn_functor */
+
+/*! \brief XAG-specific resubstitution algorithm.
+ *
+ * This algorithms iterates over each node, creates a
+ * reconvergence-driven cut, and attempts to re-express the node's
+ * function using existing nodes from the cut.  Node which are no
+ * longer used (including nodes in their transitive fanins) can then
+ * be removed.  The objective is to reduce the size of the network as
+ * much as possible while maintaining the global input-output
+ * functionality.
+ *
+ * **Required network functions:**
+ *
+ * - `clear_values`
+ * - `fanout_size`
+ * - `foreach_fanin`
+ * - `foreach_fanout`
+ * - `foreach_gate`
+ * - `foreach_node`
+ * - `get_constant`
+ * - `get_node`
+ * - `is_complemented`
+ * - `is_pi`
+ * - `level`
+ * - `make_signal`
+ * - `set_value`
+ * - `set_visited`
+ * - `size`
+ * - `substitute_node`
+ * - `value`
+ * - `visited`
+ *
+ * \param ntk A network type derived from xag_network
+ * \param ps Resubstitution parameters
+ * \param pst Resubstitution statistics
+ */
+template<class Ntk>
+void xag_resubstitution( Ntk& ntk, resubstitution_params const& ps = {}, resubstitution_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( std::is_same_v<typename Ntk::base_type, xag_network>, "Network type is not xag_network" );
+
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the has_size method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the has substitute_node method" );
+  static_assert( has_value_v<Ntk>, "Ntk does not implement the has_value method" );
+  static_assert( has_visited_v<Ntk>, "Ntk does not implement the has_visited method" );
+  static_assert( has_level_v<Ntk>, "Ntk does not implement the level method" );
+  static_assert( has_foreach_fanout_v<Ntk>, "Ntk does not implement the foreach_fanout method" );
+
+  using truthtable_t = kitty::dynamic_truth_table;
+  using truthtable_dc_t = kitty::dynamic_truth_table;
+  using functor_t = xag_resyn_functor<Ntk, detail::window_simulator<Ntk, truthtable_t>, truthtable_dc_t>;
+
+  using resub_impl_t = detail::resubstitution_impl<Ntk, detail::window_based_resub_engine<Ntk, truthtable_t, truthtable_dc_t, functor_t>>;
+
+  resubstitution_stats st;
+  typename resub_impl_t::engine_st_t engine_st;
+  typename resub_impl_t::collector_st_t collector_st;
+
+  resub_impl_t p( ntk, ps, st, engine_st, collector_st );
+  p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+    collector_st.report();
+    engine_st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/algorithms/xag_resub_withDC.hpp b/include/mockturtle/algorithms/xag_resub_withDC.hpp
new file mode 100644
index 0000000..e3c851f
--- /dev/null
+++ b/include/mockturtle/algorithms/xag_resub_withDC.hpp
@@ -0,0 +1,989 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xag_resub_withDC.hpp
+  \brief Resubstitution with free xor (works for XAGs, XOR gates are considered for free)
+
+  \author Eleonora Testa
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../networks/xag.hpp"
+#include "dont_cares.hpp"
+#include "resubstitution.hpp"
+#include <kitty/operations.hpp>
+
+namespace mockturtle
+{
+
+struct xag_resub_stats
+{
+  /*! \brief Accumulated runtime for const-resub */
+  stopwatch<>::duration time_resubC{ 0 };
+
+  /*! \brief Accumulated runtime for zero-resub */
+  stopwatch<>::duration time_resub0{ 0 };
+
+  /*! \brief Accumulated runtime for one-resub */
+  stopwatch<>::duration time_resub1{ 0 };
+
+  /*! \brief Accumulated runtime for two-resub. */
+  stopwatch<>::duration time_resub2{ 0 };
+
+  /*! \brief Accumulated runtime for three-resub. */
+  stopwatch<>::duration time_resub3{ 0 };
+
+  /*! \brief Accumulated runtime for one-resub */
+  stopwatch<>::duration time_resub1_and{ 0 };
+
+  /*! \brief Accumulated runtime for one-resub */
+  stopwatch<>::duration time_resub2_and{ 0 };
+
+  /*! \brief Accumulated runtime for collecting unate divisors. */
+  stopwatch<>::duration time_collect_unate_divisors{ 0 };
+
+  /*! \brief Accumulated runtime for collecting unate divisors. */
+  stopwatch<>::duration time_collect_binate_divisors{ 0 };
+
+  /*! \brief Accumulated runtime for 12-resub. */
+  stopwatch<>::duration time_resub12{ 0 };
+
+  /*! \brief Number of accepted constant resubsitutions */
+  uint32_t num_const_accepts{ 0 };
+
+  /*! \brief Number of accepted zero resubsitutions */
+  uint32_t num_div0_accepts{ 0 };
+
+  /*! \brief Number of accepted one resubsitutions */
+  uint64_t num_div1_accepts{ 0 };
+
+  /*! \brief Number of accepted two resubsitutions */
+  uint64_t num_div2_accepts{ 0 };
+
+  /*! \brief Number of accepted one resubsitutions for AND */
+  uint64_t num_div1_and_accepts{ 0 };
+
+  /*! \brief Number of accepted one resubsitutions for AND */
+  uint64_t num_div2_and_accepts{ 0 };
+
+  /*! \brief Number of accepted two resubsitutions using triples of unate divisors */
+  uint64_t num_div12_accepts{ 0 };
+
+  void report() const
+  {
+    std::cout << "[i] kernel: xag_resub_functor\n";
+    std::cout << fmt::format( "[i]     constant-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_const_accepts, to_seconds( time_resubC ) );
+    std::cout << fmt::format( "[i]            0-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_div0_accepts, to_seconds( time_resub0 ) );
+    std::cout << fmt::format( "[i]            1-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_div1_accepts, to_seconds( time_resub1 ) );
+    std::cout << fmt::format( "[i]            2-resub {:6d}                                   ({:>5.2f} secs)\n",
+                              num_div2_accepts, to_seconds( time_resub2 ) );
+    std::cout << fmt::format( "[i]            1-resub AND {:6d}                                   ({:>5.2f} secs)\n",
+                              num_div1_and_accepts, to_seconds( time_resub1_and ) );
+    std::cout << fmt::format( "[i]           12-resub {:6d}                                      ({:>5.2f} secs)\n",
+                              num_div12_accepts, to_seconds( time_resub12 ) );
+    std::cout << fmt::format( "[i]            2-resub AND {:6d}                                   ({:>5.2f} secs)\n",
+                              num_div2_and_accepts, to_seconds( time_resub2_and ) );
+    std::cout << fmt::format( "[i]            collect unate divisors                           ({:>5.2f} secs)\n", to_seconds( time_collect_unate_divisors ) );
+    std::cout << fmt::format( "[i]            collect binate divisors                           ({:>5.2f} secs)\n", to_seconds( time_collect_binate_divisors ) );
+    std::cout << fmt::format( "[i]            total   {:6d}\n",
+                              ( num_const_accepts + num_div0_accepts + num_div1_accepts + num_div2_accepts + num_div1_and_accepts + num_div12_accepts + num_div2_and_accepts ) );
+  }
+}; /* xag_resub_stats */
+
+namespace detail
+{
+
+template<typename Ntk>
+class node_mffc_inside_xag
+{
+public:
+  using node = typename Ntk::node;
+
+public:
+  explicit node_mffc_inside_xag( Ntk const& ntk )
+      : ntk( ntk )
+  {
+  }
+
+  std::pair<int32_t, int32_t> run( node const& n, std::vector<node> const& leaves, std::vector<node>& inside )
+  {
+    /* increment the fanout counters for the leaves */
+    for ( const auto& l : leaves )
+      ntk.incr_fanout_size( l );
+
+    /* dereference the node */
+    auto count1 = node_deref_rec( n );
+
+    /* collect the nodes inside the MFFC */
+    node_mffc_cone( n, inside );
+
+    /* reference it back */
+    auto count2 = node_ref_rec( n );
+    (void)count2;
+
+    assert( count1.first == count2.first );
+    assert( count1.second == count2.second );
+
+    for ( const auto& l : leaves )
+      ntk.decr_fanout_size( l );
+
+    return count1;
+  }
+
+private:
+  /* ! \brief Dereference the node's MFFC */
+  std::pair<int32_t, int32_t> node_deref_rec( node const& n )
+  {
+
+    if ( ntk.is_pi( n ) )
+      return { 0, 0 };
+
+    int32_t counter_and = 0;
+    int32_t counter_xor = 0;
+
+    if ( ntk.is_and( n ) )
+    {
+      counter_and = 1;
+    }
+    else if ( ntk.is_xor( n ) )
+    {
+      counter_xor = 1;
+    }
+
+    ntk.foreach_fanin( n, [&]( const auto& f ) {
+      auto const& p = ntk.get_node( f );
+
+      ntk.decr_fanout_size( p );
+      if ( ntk.fanout_size( p ) == 0 )
+      {
+        auto counter = node_deref_rec( p );
+        counter_and += counter.first;
+        counter_xor += counter.second;
+      }
+    } );
+
+    return { counter_and, counter_xor };
+  }
+
+  /* ! \brief Reference the node's MFFC */
+  std::pair<int32_t, int32_t> node_ref_rec( node const& n )
+  {
+    if ( ntk.is_pi( n ) )
+      return { 0, 0 };
+
+    int32_t counter_and = 0;
+    int32_t counter_xor = 0;
+
+    if ( ntk.is_and( n ) )
+    {
+      counter_and = 1;
+    }
+    else if ( ntk.is_xor( n ) )
+    {
+      counter_xor = 1;
+    }
+
+    ntk.foreach_fanin( n, [&]( const auto& f ) {
+      auto const& p = ntk.get_node( f );
+
+      auto v = ntk.fanout_size( p );
+      ntk.incr_fanout_size( p );
+      if ( v == 0 )
+      {
+        auto counter = node_ref_rec( p );
+        counter_and += counter.first;
+        counter_xor += counter.second;
+      }
+    } );
+
+    return { counter_and, counter_xor };
+  }
+
+  void node_mffc_cone_rec( node const& n, std::vector<node>& cone, bool top_most )
+  {
+    /* skip visited nodes */
+    if ( ntk.visited( n ) == ntk.trav_id() )
+      return;
+    ntk.set_visited( n, ntk.trav_id() );
+
+    if ( !top_most && ( ntk.is_pi( n ) || ntk.fanout_size( n ) > 0 ) )
+      return;
+
+    /* recurse on children */
+    ntk.foreach_fanin( n, [&]( const auto& f ) {
+      node_mffc_cone_rec( ntk.get_node( f ), cone, false );
+    } );
+
+    /* collect the internal nodes */
+    cone.emplace_back( n );
+  }
+
+  void node_mffc_cone( node const& n, std::vector<node>& cone )
+  {
+    cone.clear();
+    ntk.incr_trav_id();
+    node_mffc_cone_rec( n, cone, true );
+  }
+
+private:
+  Ntk const& ntk;
+};
+
+} /* namespace detail */
+
+template<typename Ntk, typename Simulator, typename TT>
+struct xag_resub_functor
+{
+public:
+  using node = xag_network::node;
+  using signal = xag_network::signal;
+  using stats = xag_resub_stats;
+
+  struct unate_divisors
+  {
+    using signal = typename xag_network::signal;
+
+    std::vector<signal> positive_divisors;
+    std::vector<signal> negative_divisors;
+    std::vector<signal> next_candidates;
+
+    void clear()
+    {
+      positive_divisors.clear();
+      negative_divisors.clear();
+      next_candidates.clear();
+    }
+  };
+
+  struct binate_divisors
+  {
+    using signal = typename xag_network::signal;
+
+    std::vector<signal> positive_divisors0;
+    std::vector<signal> positive_divisors1;
+    std::vector<signal> negative_divisors0;
+    std::vector<signal> negative_divisors1;
+
+    void clear()
+    {
+      positive_divisors0.clear();
+      positive_divisors1.clear();
+      negative_divisors0.clear();
+      negative_divisors1.clear();
+    }
+  };
+
+public:
+  explicit xag_resub_functor( Ntk& ntk, Simulator const& sim, std::vector<node> const& divs, uint32_t num_divs, stats& st )
+      : ntk( ntk ), sim( sim ), divs( divs ), num_divs( num_divs ), st( st )
+  {
+  }
+
+  std::optional<signal> operator()( node const& root, TT care, uint32_t required, uint32_t max_inserts, std::pair<uint32_t, uint32_t> num_mffc, uint32_t& last_gain )
+  {
+
+    uint32_t num_and_mffc = num_mffc.first;
+    uint32_t num_xor_mffc = num_mffc.second;
+    /* consider constants */
+    auto g = call_with_stopwatch( st.time_resubC, [&]() {
+      return resub_const( root, care, required );
+    } );
+    if ( g )
+    {
+      ++st.num_const_accepts;
+      last_gain = num_and_mffc;
+      return g; /* accepted resub */
+    }
+
+    /* consider equal nodes */
+    g = call_with_stopwatch( st.time_resub0, [&]() {
+      return resub_div0( root, care, required );
+    } );
+    if ( g )
+    {
+      ++st.num_div0_accepts;
+      last_gain = num_and_mffc;
+      return g; /* accepted resub */
+    }
+
+    if ( num_and_mffc == 0 )
+    {
+      return std::nullopt;
+      if ( max_inserts == 0 || num_xor_mffc == 1 )
+        return std::nullopt;
+
+      g = call_with_stopwatch( st.time_resub1, [&]() {
+        return resub_div1( root, care, required );
+      } );
+      if ( g )
+      {
+        ++st.num_div1_accepts;
+        last_gain = 0;
+        return g; /* accepted resub */
+      }
+
+      if ( max_inserts == 1 || num_xor_mffc == 2 )
+        return std::nullopt;
+
+      /* consider two nodes */
+      g = call_with_stopwatch( st.time_resub2, [&]() { return resub_div2( root, care, required ); } );
+      if ( g )
+      {
+        ++st.num_div2_accepts;
+        last_gain = 0;
+        return g; /* accepted resub */
+      }
+    }
+    else
+    {
+
+      g = call_with_stopwatch( st.time_resub1, [&]() {
+        return resub_div1( root, care, required );
+      } );
+      if ( g )
+      {
+        ++st.num_div1_accepts;
+        last_gain = num_and_mffc;
+        return g; /* accepted resub */
+      }
+
+      /* consider two nodes */
+      g = call_with_stopwatch( st.time_resub2, [&]() { return resub_div2( root, care, required ); } );
+      if ( g )
+      {
+        ++st.num_div2_accepts;
+        last_gain = num_and_mffc;
+        return g; /*  accepted resub */
+      }
+
+      if ( num_and_mffc < 2 ) /* it is worth trying also AND resub here */
+        return std::nullopt;
+
+      /* collect level one divisors */
+      call_with_stopwatch( st.time_collect_unate_divisors, [&]() {
+        collect_unate_divisors( root, required );
+      } );
+
+      g = call_with_stopwatch( st.time_resub1_and, [&]() { return resub_div1_and( root, care, required ); } );
+      if ( g )
+      {
+        ++st.num_div1_and_accepts;
+        last_gain = num_and_mffc - 1;
+        return g; /*  accepted resub */
+      }
+      if ( num_and_mffc < 3 ) /* it is worth trying also AND-12 resub here */
+        return std::nullopt;
+
+      /* consider triples */
+      g = call_with_stopwatch( st.time_resub12, [&]() { return resub_div12( root, care, required ); } );
+      if ( g )
+      {
+        ++st.num_div12_accepts;
+        last_gain = num_and_mffc - 2;
+        return g; /* accepted resub */
+      }
+
+      /* collect level two divisors */
+      call_with_stopwatch( st.time_collect_binate_divisors, [&]() {
+        collect_binate_divisors( root, required );
+      } );
+
+      /* consider two nodes */
+      g = call_with_stopwatch( st.time_resub2_and, [&]() { return resub_div2_and( root, care, required ); } );
+      if ( g )
+      {
+        ++st.num_div2_and_accepts;
+        last_gain = num_and_mffc - 2;
+        return g; /* accepted resub */
+      }
+    }
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_const( node const& root, TT care, uint32_t required ) const
+  {
+    (void)required;
+    auto tt = sim.get_tt( ntk.make_signal( root ) );
+    if ( care.num_vars() > tt.num_vars() )
+      care = kitty::shrink_to( care, tt.num_vars() );
+    else
+      care = kitty::extend_to( care, tt.num_vars() );
+
+    if ( binary_and( tt, care ) == sim.get_tt( ntk.get_constant( false ) ) )
+    {
+      return sim.get_phase( root ) ? ntk.get_constant( true ) : ntk.get_constant( false );
+    }
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_div0( node const& root, TT care, uint32_t required ) const
+  {
+    (void)required;
+    auto const tt = sim.get_tt( ntk.make_signal( root ) );
+    if ( care.num_vars() > tt.num_vars() )
+      care = kitty::shrink_to( care, tt.num_vars() );
+    else
+      care = kitty::extend_to( care, tt.num_vars() );
+    for ( auto i = 0u; i < num_divs; ++i )
+    {
+      auto const d = divs.at( i );
+
+      if ( binary_and( tt, care ) != binary_and( sim.get_tt( ntk.make_signal( d ) ), care ) )
+        continue;
+      return ( sim.get_phase( d ) ^ sim.get_phase( root ) ) ? !ntk.make_signal( d ) : ntk.make_signal( d );
+    }
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_div1( node const& root, TT care, uint32_t required )
+  {
+    (void)required;
+    auto const& tt = sim.get_tt( ntk.make_signal( root ) );
+    if ( care.num_vars() > tt.num_vars() )
+      care = kitty::shrink_to( care, tt.num_vars() );
+    else
+      care = kitty::extend_to( care, tt.num_vars() );
+    /* check for divisors  */
+    for ( auto i = 0u; i < num_divs; ++i )
+    {
+      auto const& s0 = divs.at( i );
+
+      for ( auto j = i + 1; j < num_divs; ++j )
+      {
+        auto const& s1 = divs.at( j );
+        auto const& tt_s0 = sim.get_tt( ntk.make_signal( s0 ) );
+        auto const& tt_s1 = sim.get_tt( ntk.make_signal( s1 ) );
+
+        if ( binary_and( ( tt_s0 ^ tt_s1 ), care ) == binary_and( tt, care ) )
+        {
+          auto const l = sim.get_phase( s0 ) ? !ntk.make_signal( s0 ) : ntk.make_signal( s0 );
+          auto const r = sim.get_phase( s1 ) ? !ntk.make_signal( s1 ) : ntk.make_signal( s1 );
+          return sim.get_phase( root ) ? !ntk.create_xor( l, r ) : ntk.create_xor( l, r );
+        }
+        else if ( binary_and( ( tt_s0 ^ tt_s1 ), care ) == binary_and( kitty::unary_not( tt ), care ) )
+        {
+          auto const l = sim.get_phase( s0 ) ? !ntk.make_signal( s0 ) : ntk.make_signal( s0 );
+          auto const r = sim.get_phase( s1 ) ? !ntk.make_signal( s1 ) : ntk.make_signal( s1 );
+          return sim.get_phase( root ) ? ntk.create_xor( l, r ) : !ntk.create_xor( l, r );
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_div2( node const& root, TT care, uint32_t required )
+  {
+    (void)required;
+    auto const s = ntk.make_signal( root );
+    auto const& tt = sim.get_tt( s );
+    if ( care.num_vars() > tt.num_vars() )
+      care = kitty::shrink_to( care, tt.num_vars() );
+    else
+      care = kitty::extend_to( care, tt.num_vars() );
+
+    for ( auto i = 0u; i < num_divs; ++i )
+    {
+      auto const s0 = divs.at( i );
+
+      for ( auto j = i + 1; j < num_divs; ++j )
+      {
+        auto const s1 = divs.at( j );
+
+        for ( auto k = j + 1; k < num_divs; ++k )
+        {
+          auto const s2 = divs.at( k );
+          auto const& tt_s0 = sim.get_tt( ntk.make_signal( s0 ) );
+          auto const& tt_s1 = sim.get_tt( ntk.make_signal( s1 ) );
+          auto const& tt_s2 = sim.get_tt( ntk.make_signal( s2 ) );
+
+          if ( binary_and( ( tt_s0 ^ tt_s1 ^ tt_s2 ), care ) == binary_and( tt, care ) )
+          {
+            auto const max_level = std::max( { ntk.level( s0 ),
+                                               ntk.level( s1 ),
+                                               ntk.level( s2 ) } );
+            assert( max_level <= required - 1 );
+
+            signal max = ntk.make_signal( s0 );
+            signal min0 = ntk.make_signal( s1 );
+            signal min1 = ntk.make_signal( s2 );
+            if ( ntk.level( s1 ) == max_level )
+            {
+              max = ntk.make_signal( s1 );
+              min0 = ntk.make_signal( s0 );
+              min1 = ntk.make_signal( s2 );
+            }
+            else if ( ntk.level( s2 ) == max_level )
+            {
+              max = ntk.make_signal( s2 );
+              min0 = ntk.make_signal( s0 );
+              min1 = ntk.make_signal( s1 );
+            }
+
+            auto const a = sim.get_phase( ntk.get_node( max ) ) ? !max : max;
+            auto const b = sim.get_phase( ntk.get_node( min0 ) ) ? !min0 : min0;
+            auto const c = sim.get_phase( ntk.get_node( min1 ) ) ? !min1 : min1;
+
+            return sim.get_phase( root ) ? !ntk.create_xor( a, ntk.create_xor( b, c ) ) : ntk.create_xor( a, ntk.create_xor( b, c ) );
+          }
+          else if ( binary_and( ( tt_s0 ^ tt_s1 ^ tt_s2 ), care ) == binary_and( kitty::unary_not( tt ), care ) )
+          {
+            auto const max_level = std::max( { ntk.level( s0 ),
+                                               ntk.level( s1 ),
+                                               ntk.level( s2 ) } );
+            assert( max_level <= required - 1 );
+
+            signal max = ntk.make_signal( s0 );
+            signal min0 = ntk.make_signal( s1 );
+            signal min1 = ntk.make_signal( s2 );
+            if ( ntk.level( s1 ) == max_level )
+            {
+              max = ntk.make_signal( s1 );
+              min0 = ntk.make_signal( s0 );
+              min1 = ntk.make_signal( s2 );
+            }
+            else if ( ntk.level( s2 ) == max_level )
+            {
+              max = ntk.make_signal( s2 );
+              min0 = ntk.make_signal( s0 );
+              min1 = ntk.make_signal( s1 );
+            }
+
+            auto const a = sim.get_phase( ntk.get_node( max ) ) ? !max : max;
+            auto const b = sim.get_phase( ntk.get_node( min0 ) ) ? !min0 : min0;
+            auto const c = sim.get_phase( ntk.get_node( min1 ) ) ? !min1 : min1;
+
+            return sim.get_phase( root ) ? ntk.create_xor( a, ntk.create_xor( b, c ) ) : !ntk.create_xor( a, ntk.create_xor( b, c ) );
+          }
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  void collect_unate_divisors( node const& root, uint32_t required )
+  {
+    udivs.clear();
+
+    auto const& tt = sim.get_tt( ntk.make_signal( root ) );
+    for ( auto i = 0u; i < num_divs; ++i )
+    {
+      auto const d = divs.at( i );
+
+      if ( ntk.level( d ) > required - 1 )
+        continue;
+
+      auto const& tt_d = sim.get_tt( ntk.make_signal( d ) );
+
+      /* check positive containment */
+      if ( kitty::implies( tt_d, tt ) )
+      {
+        udivs.positive_divisors.emplace_back( ntk.make_signal( d ) );
+        continue;
+      }
+
+      /* check negative containment */
+      if ( kitty::implies( tt, tt_d ) )
+      {
+        udivs.negative_divisors.emplace_back( ntk.make_signal( d ) );
+        continue;
+      }
+
+      udivs.next_candidates.emplace_back( ntk.make_signal( d ) );
+    }
+  }
+
+  std::optional<signal> resub_div1_and( node const& root, TT care, uint32_t required )
+  {
+    (void)required;
+    auto const& tt = sim.get_tt( ntk.make_signal( root ) );
+    if ( care.num_vars() > tt.num_vars() )
+      care = kitty::shrink_to( care, tt.num_vars() );
+    else
+      care = kitty::extend_to( care, tt.num_vars() );
+
+    /* check for positive unate divisors */
+    for ( auto i = 0u; i < udivs.positive_divisors.size(); ++i )
+    {
+      auto const& s0 = udivs.positive_divisors.at( i );
+
+      for ( auto j = i + 1; j < udivs.positive_divisors.size(); ++j )
+      {
+        auto const& s1 = udivs.positive_divisors.at( j );
+
+        auto const& tt_s0 = sim.get_tt( s0 );
+        auto const& tt_s1 = sim.get_tt( s1 );
+
+        if ( binary_and( ( tt_s0 | tt_s1 ), care ) == binary_and( tt, care ) )
+        {
+          auto const l = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+          auto const r = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+          return sim.get_phase( root ) ? !ntk.create_or( l, r ) : ntk.create_or( l, r );
+        }
+      }
+    }
+    /* check for negative unate divisors */
+    for ( auto i = 0u; i < udivs.negative_divisors.size(); ++i )
+    {
+      auto const& s0 = udivs.negative_divisors.at( i );
+
+      for ( auto j = i + 1; j < udivs.negative_divisors.size(); ++j )
+      {
+        auto const& s1 = udivs.negative_divisors.at( j );
+
+        auto const& tt_s0 = sim.get_tt( s0 );
+        auto const& tt_s1 = sim.get_tt( s1 );
+
+        if ( binary_and( ( tt_s0 & tt_s1 ), care ) == binary_and( tt, care ) )
+        {
+          auto const l = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+          auto const r = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+          return sim.get_phase( root ) ? !ntk.create_and( l, r ) : ntk.create_and( l, r );
+        }
+      }
+    }
+
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_div12( node const& root, TT care, uint32_t required )
+  {
+    (void)required;
+    auto const s = ntk.make_signal( root );
+    auto const& tt = sim.get_tt( s );
+    if ( care.num_vars() > tt.num_vars() )
+      care = kitty::shrink_to( care, tt.num_vars() );
+    else
+      care = kitty::extend_to( care, tt.num_vars() );
+
+    /* check positive unate divisors */
+    for ( auto i = 0u; i < udivs.positive_divisors.size(); ++i )
+    {
+      auto const s0 = udivs.positive_divisors.at( i );
+
+      for ( auto j = i + 1; j < udivs.positive_divisors.size(); ++j )
+      {
+        auto const s1 = udivs.positive_divisors.at( j );
+
+        for ( auto k = j + 1; k < udivs.positive_divisors.size(); ++k )
+        {
+          auto const s2 = udivs.positive_divisors.at( k );
+
+          auto const& tt_s0 = sim.get_tt( s0 );
+          auto const& tt_s1 = sim.get_tt( s1 );
+          auto const& tt_s2 = sim.get_tt( s2 );
+
+          if ( binary_and( ( tt_s0 | tt_s1 | tt_s2 ), care ) == binary_and( tt, care ) )
+          {
+            auto const max_level = std::max( { ntk.level( ntk.get_node( s0 ) ),
+                                               ntk.level( ntk.get_node( s1 ) ),
+                                               ntk.level( ntk.get_node( s2 ) ) } );
+            assert( max_level <= required - 1 );
+
+            signal max = s0;
+            signal min0 = s1;
+            signal min1 = s2;
+            if ( ntk.level( ntk.get_node( s1 ) ) == max_level )
+            {
+              max = s1;
+              min0 = s0;
+              min1 = s2;
+            }
+            else if ( ntk.level( ntk.get_node( s2 ) ) == max_level )
+            {
+              max = s2;
+              min0 = s0;
+              min1 = s1;
+            }
+
+            auto const a = sim.get_phase( ntk.get_node( max ) ) ? !max : max;
+            auto const b = sim.get_phase( ntk.get_node( min0 ) ) ? !min0 : min0;
+            auto const c = sim.get_phase( ntk.get_node( min1 ) ) ? !min1 : min1;
+
+            return sim.get_phase( root ) ? !ntk.create_or( a, ntk.create_or( b, c ) ) : ntk.create_or( a, ntk.create_or( b, c ) );
+          }
+        }
+      }
+    }
+
+    /* check negative unate divisors */
+    for ( auto i = 0u; i < udivs.positive_divisors.size(); ++i )
+    {
+      auto const s0 = udivs.positive_divisors.at( i );
+
+      for ( auto j = i + 1; j < udivs.positive_divisors.size(); ++j )
+      {
+        auto const s1 = udivs.positive_divisors.at( j );
+
+        for ( auto k = j + 1; k < udivs.positive_divisors.size(); ++k )
+        {
+          auto const s2 = udivs.positive_divisors.at( k );
+
+          auto const& tt_s0 = sim.get_tt( s0 );
+          auto const& tt_s1 = sim.get_tt( s1 );
+          auto const& tt_s2 = sim.get_tt( s2 );
+
+          if ( binary_and( ( tt_s0 & tt_s1 & tt_s2 ), care ) == binary_and( tt, care ) )
+          {
+            auto const max_level = std::max( { ntk.level( ntk.get_node( s0 ) ),
+                                               ntk.level( ntk.get_node( s1 ) ),
+                                               ntk.level( ntk.get_node( s2 ) ) } );
+            assert( max_level <= required - 1 );
+
+            signal max = s0;
+            signal min0 = s1;
+            signal min1 = s2;
+            if ( ntk.level( ntk.get_node( s1 ) ) == max_level )
+            {
+              max = s1;
+              min0 = s0;
+              min1 = s2;
+            }
+            else if ( ntk.level( ntk.get_node( s2 ) ) == max_level )
+            {
+              max = s2;
+              min0 = s0;
+              min1 = s1;
+            }
+
+            auto const a = sim.get_phase( ntk.get_node( max ) ) ? !max : max;
+            auto const b = sim.get_phase( ntk.get_node( min0 ) ) ? !min0 : min0;
+            auto const c = sim.get_phase( ntk.get_node( min1 ) ) ? !min1 : min1;
+
+            return sim.get_phase( root ) ? !ntk.create_and( a, ntk.create_and( b, c ) ) : ntk.create_and( a, ntk.create_and( b, c ) );
+          }
+        }
+      }
+    }
+
+    return std::nullopt;
+  }
+
+  void collect_binate_divisors( node const& root, uint32_t required )
+  {
+    bdivs.clear();
+
+    auto const& tt = sim.get_tt( ntk.make_signal( root ) );
+    for ( auto i = 0u; i < udivs.next_candidates.size(); ++i )
+    {
+      auto const& s0 = udivs.next_candidates.at( i );
+      if ( ntk.level( ntk.get_node( s0 ) ) > required - 2 )
+        continue;
+
+      for ( auto j = i + 1; j < udivs.next_candidates.size(); ++j )
+      {
+        auto const& s1 = udivs.next_candidates.at( j );
+        if ( ntk.level( ntk.get_node( s1 ) ) > required - 2 )
+          continue;
+
+        if ( bdivs.positive_divisors0.size() < 500 ) // ps.max_divisors2
+        {
+          auto const& tt_s0 = sim.get_tt( s0 );
+          auto const& tt_s1 = sim.get_tt( s1 );
+          if ( kitty::implies( tt_s0 & tt_s1, tt ) )
+          {
+            bdivs.positive_divisors0.emplace_back( s0 );
+            bdivs.positive_divisors1.emplace_back( s1 );
+          }
+
+          if ( kitty::implies( ~tt_s0 & tt_s1, tt ) )
+          {
+            bdivs.positive_divisors0.emplace_back( !s0 );
+            bdivs.positive_divisors1.emplace_back( s1 );
+          }
+
+          if ( kitty::implies( tt_s0 & ~tt_s1, tt ) )
+          {
+            bdivs.positive_divisors0.emplace_back( s0 );
+            bdivs.positive_divisors1.emplace_back( !s1 );
+          }
+
+          if ( kitty::implies( ~tt_s0 & ~tt_s1, tt ) )
+          {
+            bdivs.positive_divisors0.emplace_back( !s0 );
+            bdivs.positive_divisors1.emplace_back( !s1 );
+          }
+        }
+
+        if ( bdivs.negative_divisors0.size() < 500 ) // ps.max_divisors2
+        {
+          auto const& tt_s0 = sim.get_tt( s0 );
+          auto const& tt_s1 = sim.get_tt( s1 );
+          if ( kitty::implies( tt, tt_s0 & tt_s1 ) )
+          {
+            bdivs.negative_divisors0.emplace_back( s0 );
+            bdivs.negative_divisors1.emplace_back( s1 );
+          }
+
+          if ( kitty::implies( tt, ~tt_s0 & tt_s1 ) )
+          {
+            bdivs.negative_divisors0.emplace_back( !s0 );
+            bdivs.negative_divisors1.emplace_back( s1 );
+          }
+
+          if ( kitty::implies( tt, tt_s0 & ~tt_s1 ) )
+          {
+            bdivs.negative_divisors0.emplace_back( s0 );
+            bdivs.negative_divisors1.emplace_back( !s1 );
+          }
+
+          if ( kitty::implies( tt, ~tt_s0 & ~tt_s1 ) )
+          {
+            bdivs.negative_divisors0.emplace_back( !s0 );
+            bdivs.negative_divisors1.emplace_back( !s1 );
+          }
+        }
+      }
+    }
+  }
+
+  std::optional<signal> resub_div2_and( node const& root, TT care, uint32_t required )
+  {
+    (void)required;
+    auto const s = ntk.make_signal( root );
+    auto const& tt = sim.get_tt( s );
+    if ( care.num_vars() > tt.num_vars() )
+      care = kitty::shrink_to( care, tt.num_vars() );
+    else
+      care = kitty::extend_to( care, tt.num_vars() );
+
+    /* check positive unate divisors */
+    for ( const auto& s0 : udivs.positive_divisors )
+    {
+      auto const& tt_s0 = sim.get_tt( s0 );
+
+      for ( auto j = 0u; j < bdivs.positive_divisors0.size(); ++j )
+      {
+        auto const s1 = bdivs.positive_divisors0.at( j );
+        auto const s2 = bdivs.positive_divisors1.at( j );
+
+        auto const& tt_s1 = sim.get_tt( s1 );
+        auto const& tt_s2 = sim.get_tt( s2 );
+
+        auto const a = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+        auto const b = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+        auto const c = sim.get_phase( ntk.get_node( s2 ) ) ? !s2 : s2;
+
+        if ( binary_and( ( tt_s0 | ( tt_s1 & tt_s2 ) ), care ) == binary_and( tt, care ) )
+        {
+          return sim.get_phase( root ) ? !ntk.create_or( a, ntk.create_and( b, c ) ) : ntk.create_or( a, ntk.create_and( b, c ) );
+        }
+      }
+    }
+
+    /* check negative unate divisors */
+    for ( const auto& s0 : udivs.negative_divisors )
+    {
+      auto const& tt_s0 = sim.get_tt( s0 );
+
+      for ( auto j = 0u; j < bdivs.negative_divisors0.size(); ++j )
+      {
+        auto const s1 = bdivs.negative_divisors0.at( j );
+        auto const s2 = bdivs.negative_divisors1.at( j );
+
+        auto const& tt_s1 = sim.get_tt( s1 );
+        auto const& tt_s2 = sim.get_tt( s2 );
+
+        auto const a = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+        auto const b = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+        auto const c = sim.get_phase( ntk.get_node( s2 ) ) ? !s2 : s2;
+
+        if ( binary_and( ( tt_s0 | ( tt_s1 & tt_s2 ) ), care ) == binary_and( tt, care ) )
+        {
+          return sim.get_phase( root ) ? !ntk.create_and( a, ntk.create_or( b, c ) ) : ntk.create_and( a, ntk.create_or( b, c ) );
+        }
+      }
+    }
+
+    return std::nullopt;
+  }
+
+private:
+  Ntk& ntk;
+  Simulator const& sim;
+  std::vector<node> const& divs;
+  uint32_t const num_divs;
+  stats& st;
+
+  unate_divisors udivs;
+  binate_divisors bdivs;
+}; /* xag_resub_functor */
+
+template<class Ntk>
+void resubstitution_minmc_withDC( Ntk& ntk, resubstitution_params const& ps = {}, resubstitution_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the has_size method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the has substitute_node method" );
+  static_assert( has_value_v<Ntk>, "Ntk does not implement the has_value method" );
+  static_assert( has_visited_v<Ntk>, "Ntk does not implement the has_visited method" );
+
+  using resub_view_t = fanout_view<depth_view<Ntk>>;
+  depth_view<Ntk> depth_view{ ntk };
+  resub_view_t resub_view{ depth_view };
+
+  using truthtable_t = kitty::dynamic_truth_table;
+  using mffc_result_t = std::pair<uint32_t, uint32_t>;
+  using resub_impl_t = detail::resubstitution_impl<resub_view_t, typename detail::window_based_resub_engine<resub_view_t, truthtable_t, truthtable_t, xag_resub_functor<resub_view_t, typename detail::window_simulator<resub_view_t, truthtable_t>, truthtable_t>, mffc_result_t>, typename detail::default_divisor_collector<Ntk, typename detail::node_mffc_inside_xag<Ntk>, mffc_result_t>>;
+
+  resubstitution_stats st;
+  typename resub_impl_t::engine_st_t engine_st;
+  typename resub_impl_t::collector_st_t collector_st;
+
+  resub_impl_t p( resub_view, ps, st, engine_st, collector_st );
+  p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+    collector_st.report();
+    engine_st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/xmg_algebraic_rewriting.hpp b/include/mockturtle/algorithms/xmg_algebraic_rewriting.hpp
new file mode 100644
index 0000000..7b8640e
--- /dev/null
+++ b/include/mockturtle/algorithms/xmg_algebraic_rewriting.hpp
@@ -0,0 +1,518 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xmg_algebraic_rewriting.hpp
+  \brief xmg algebraric rewriting
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Zhufei Chu
+*/
+
+#pragma once
+
+#include <iostream>
+#include <optional>
+
+#include "../views/topo_view.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for xmg_algebraic_depth_rewriting.
+ *
+ * The data structure `xmg_algebraic_depth_rewriting_params` holds configurable
+ * parameters with default arguments for `xmg_algebraic_depth_rewriting`.
+ */
+struct xmg_algebraic_depth_rewriting_params
+{
+  /*! \brief Rewriting strategy. */
+  enum strategy_t
+  {
+    /*! \brief DFS rewriting strategy.
+     *
+     * Applies depth rewriting once to all output cones whose drivers have
+     * maximum levels
+     */
+    dfs,
+    /*! \brief Aggressive rewriting strategy.
+     *
+     * Applies depth reduction multiple times until the number of nodes, which
+     * cannot be rewritten, matches the number of nodes, in the current
+     * network; or the new network size is larger than the initial size w.r.t.
+     * to an `overhead`.
+     */
+    aggressive,
+    /*! \brief Selective rewriting strategy.
+     *
+     * Like `aggressive`, but only applies rewriting to nodes on critical paths
+     * and without `overhead`.
+     */
+    selective
+  } strategy = dfs;
+
+  /*! \brief Overhead factor in aggressive rewriting strategy.
+   *
+   * When comparing to the initial size in aggressive depth rewriting, also the
+   * number of dangling nodes are taken into account.
+   */
+  float overhead{ 2.0f };
+
+  /*! \brief Allow area increase while optimizing depth. */
+  bool allow_area_increase{ true };
+};
+
+namespace detail
+{
+
+template<class Ntk>
+class xmg_algebraic_depth_rewriting_impl
+{
+public:
+  xmg_algebraic_depth_rewriting_impl( Ntk& ntk, xmg_algebraic_depth_rewriting_params const& ps )
+      : ntk( ntk ), ps( ps )
+  {
+  }
+
+  void run()
+  {
+    switch ( ps.strategy )
+    {
+    case xmg_algebraic_depth_rewriting_params::dfs:
+      run_dfs();
+      break;
+    case xmg_algebraic_depth_rewriting_params::selective:
+      run_selective();
+      break;
+    case xmg_algebraic_depth_rewriting_params::aggressive:
+      run_aggressive();
+      break;
+    }
+  }
+
+private:
+  void run_dfs()
+  {
+    ntk.foreach_po( [this]( auto po ) {
+      const auto driver = ntk.get_node( po );
+      if ( ntk.level( driver ) < ntk.depth() )
+        return;
+      topo_view topo{ ntk, po };
+      topo.foreach_node( [this]( auto n ) {
+        reduce_depth( n );
+        reduce_depth_xor_associativity( n );
+        reduce_depth_xor_complementary_associativity( n );
+        return true;
+      } );
+    } );
+  }
+
+  void run_selective()
+  {
+    uint32_t counter{ 0 };
+    while ( true )
+    {
+      mark_critical_paths();
+
+      topo_view topo{ ntk };
+      topo.foreach_node( [this, &counter]( auto n ) {
+        if ( ntk.fanout_size( n ) == 0 || ntk.value( n ) == 0 )
+          return;
+
+        if ( reduce_depth( n ) )
+        {
+          mark_critical_paths();
+        }
+        else
+        {
+          ++counter;
+        }
+      } );
+
+      if ( counter > ntk.size() )
+        break;
+    }
+  }
+
+  void run_aggressive()
+  {
+    uint32_t counter{ 0 }, init_size{ ntk.size() };
+    while ( true )
+    {
+      topo_view topo{ ntk };
+      topo.foreach_node( [this, &counter]( auto n ) {
+        if ( ntk.fanout_size( n ) == 0 )
+          return;
+
+        if ( !reduce_depth( n ) )
+        {
+          ++counter;
+        }
+      } );
+
+      if ( ntk.size() > ps.overhead * init_size )
+        break;
+      if ( counter > ntk.size() )
+        break;
+    }
+  }
+
+private:
+  bool reduce_depth( node<Ntk> const& n )
+  {
+    if ( !ntk.is_maj( n ) )
+      return false;
+
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    if ( !ntk.is_maj( ntk.get_node( ocs[2] ) ) )
+      return false;
+
+    /* depth of last child must be (significantly) higher than depth of second child */
+    if ( ntk.level( ntk.get_node( ocs[2] ) ) <= ntk.level( ntk.get_node( ocs[1] ) ) + 1 )
+      return false;
+
+    /* child must have single fanout, if no area overhead is allowed */
+    if ( !ps.allow_area_increase && ntk.fanout_size( ntk.get_node( ocs[2] ) ) != 1 )
+      return false;
+
+    /* get children of last child */
+    auto ocs2 = ordered_children( ntk.get_node( ocs[2] ) );
+
+    /* depth of last grand-child must be higher than depth of second grand-child */
+    if ( ntk.level( ntk.get_node( ocs2[2] ) ) == ntk.level( ntk.get_node( ocs2[1] ) ) )
+      return false;
+
+    /* propagate inverter if necessary */
+    if ( ntk.is_complemented( ocs[2] ) )
+    {
+      ocs2[0] = !ocs2[0];
+      ocs2[1] = !ocs2[1];
+      ocs2[2] = !ocs2[2];
+    }
+
+    if ( auto cand = associativity_candidate( ocs[0], ocs[1], ocs2[0], ocs2[1], ocs2[2] ); cand )
+    {
+      const auto& [x, y, z, u, assoc] = *cand;
+      auto opt = ntk.create_maj( z, assoc ? u : x, ntk.create_maj( x, y, u ) );
+      ntk.substitute_node( n, opt );
+      ntk.update_levels();
+
+      return true;
+    }
+
+    /* distributivity */
+    if ( ps.allow_area_increase )
+    {
+      auto opt = ntk.create_maj( ocs2[2],
+                                 ntk.create_maj( ocs[0], ocs[1], ocs2[0] ),
+                                 ntk.create_maj( ocs[0], ocs[1], ocs2[1] ) );
+      ntk.substitute_node( n, opt );
+      ntk.update_levels();
+    }
+    return true;
+  }
+
+  using candidate_t = std::tuple<signal<Ntk>, signal<Ntk>, signal<Ntk>, signal<Ntk>, bool>;
+  std::optional<candidate_t> associativity_candidate( signal<Ntk> const& v, signal<Ntk> const& w, signal<Ntk> const& x, signal<Ntk> const& y, signal<Ntk> const& z ) const
+  {
+    if ( v.index == x.index )
+    {
+      return candidate_t{ w, y, z, v, v.complement == x.complement };
+    }
+    if ( v.index == y.index )
+    {
+      return candidate_t{ w, x, z, v, v.complement == y.complement };
+    }
+    if ( w.index == x.index )
+    {
+      return candidate_t{ v, y, z, w, w.complement == x.complement };
+    }
+    if ( w.index == y.index )
+    {
+      return candidate_t{ v, x, z, w, w.complement == y.complement };
+    }
+
+    return std::nullopt;
+  }
+
+  /* XOR associativity */
+  bool reduce_depth_xor_associativity( node<Ntk> const& n )
+  {
+    if ( !ntk.is_xor3( n ) )
+      return false;
+
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    if ( !ntk.is_xor3( ntk.get_node( ocs[2] ) ) )
+      return false;
+
+    /* depth of last child must be (significantly) higher than depth of second child */
+    if ( ntk.level( ntk.get_node( ocs[2] ) ) <= ntk.level( ntk.get_node( ocs[1] ) ) + 1 )
+      return false;
+
+    /* child must have single fanout, if no area overhead is allowed */
+    if ( !ps.allow_area_increase && ntk.fanout_size( ntk.get_node( ocs[2] ) ) != 1 )
+      return false;
+
+    /* get children of last child */
+    auto ocs2 = ordered_children( ntk.get_node( ocs[2] ) );
+
+    /* depth of last grand-child must be higher than depth of second grand-child */
+    if ( ntk.level( ntk.get_node( ocs2[2] ) ) == ntk.level( ntk.get_node( ocs2[1] ) ) )
+      return false;
+
+    /* propagate inverter if necessary */
+    if ( ntk.is_complemented( ocs[2] ) )
+    {
+      if ( ntk.is_complemented( ocs2[0] ) )
+      {
+        ocs2[0] = !ocs2[0];
+      }
+      else if ( ntk.is_complemented( ocs2[1] ) )
+      {
+        ocs2[1] = !ocs2[1];
+      }
+      else if ( ntk.is_complemented( ocs2[2] ) )
+      {
+        ocs2[2] = !ocs2[2];
+      }
+      else
+      {
+        ocs2[0] = !ocs2[0];
+      }
+    }
+
+    auto opt = ntk.create_xor3( ocs[0], ocs2[2],
+                                ntk.create_xor3( ocs2[0], ocs2[1], ocs[1] ) );
+    ntk.substitute_node( n, opt );
+    ntk.update_levels();
+
+    return true;
+  }
+
+  /* XOR complementary associativity <xy[!yz]> = <xy[xz]> */
+  bool reduce_depth_xor_complementary_associativity( node<Ntk> const& n )
+  {
+    if ( !ntk.is_maj( n ) )
+      return false;
+
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    if ( !ntk.is_xor3( ntk.get_node( ocs[2] ) ) )
+      return false;
+
+    /* depth of last child must be (significantly) higher than depth of second child */
+    /* depth of last child must be higher than depth of second child */
+    if ( ntk.level( ntk.get_node( ocs[2] ) ) < ntk.level( ntk.get_node( ocs[1] ) ) + 1 )
+      return false;
+
+    /* multiple child fanout is allowable */
+    // if ( !ps.allow_area_increase && ntk.fanout_size( ntk.get_node( ocs[2] ) ) != 1 )
+    //   return false;
+
+    /* get children of last child */
+    auto ocs2 = ordered_children( ntk.get_node( ocs[2] ) );
+
+    /* depth of last grand-child must be higher than depth of second grand-child */
+    if ( ntk.level( ntk.get_node( ocs2[2] ) ) == ntk.level( ntk.get_node( ocs2[1] ) ) )
+      return false;
+
+    /* propagate inverter if necessary */
+    if ( ntk.is_complemented( ocs[2] ) )
+    {
+      if ( ntk.is_complemented( ocs2[0] ) )
+      {
+        ocs2[0] = !ocs2[0];
+      }
+      else if ( ntk.is_complemented( ocs2[1] ) )
+      {
+        ocs2[1] = !ocs2[1];
+      }
+      else if ( ntk.is_complemented( ocs2[2] ) )
+      {
+        ocs2[2] = !ocs2[2];
+      }
+      else
+      {
+        ocs2[0] = !ocs2[0];
+      }
+    }
+
+    if ( auto cand = xor_compl_associativity_candidate( ocs[0], ocs[1], ocs2[0], ocs2[1], ocs2[2] ); cand )
+    {
+      const auto& [x, y, z, u, assoc] = *cand;
+      auto opt = ntk.create_maj( x, u, ntk.create_xor3( assoc ? !x : x, y, z ) );
+      ntk.substitute_node( n, opt );
+      ntk.update_levels();
+
+      return true;
+    }
+
+    return true;
+  }
+
+  std::optional<candidate_t> xor_compl_associativity_candidate( signal<Ntk> const& v, signal<Ntk> const& w, signal<Ntk> const& x, signal<Ntk> const& y, signal<Ntk> const& z ) const
+  {
+    if ( v.index == x.index )
+    {
+      return candidate_t{ w, y, z, v, v.complement == x.complement };
+    }
+    if ( v.index == y.index )
+    {
+      return candidate_t{ w, x, z, v, v.complement == y.complement };
+    }
+    if ( v.index == z.index )
+    {
+      return candidate_t{ w, x, y, v, v.complement == z.complement };
+    }
+    if ( w.index == x.index )
+    {
+      return candidate_t{ v, y, z, w, w.complement == x.complement };
+    }
+    if ( w.index == y.index )
+    {
+      return candidate_t{ v, x, z, w, w.complement == y.complement };
+    }
+    if ( w.index == z.index )
+    {
+      return candidate_t{ v, x, y, w, w.complement == z.complement };
+    }
+
+    return std::nullopt;
+  }
+
+  std::array<signal<Ntk>, 3> ordered_children( node<Ntk> const& n ) const
+  {
+    std::array<signal<Ntk>, 3> children;
+    ntk.foreach_fanin( n, [&children]( auto const& f, auto i ) { children[i] = f; } );
+    std::stable_sort( children.begin(), children.end(), [this]( auto const& c1, auto const& c2 ) {
+      return ntk.level( ntk.get_node( c1 ) ) < ntk.level( ntk.get_node( c2 ) );
+    } );
+    return children;
+  }
+
+  void mark_critical_path( node<Ntk> const& n )
+  {
+    if ( ntk.is_pi( n ) || ntk.is_constant( n ) || ntk.value( n ) )
+      return;
+
+    const auto level = ntk.level( n );
+    ntk.set_value( n, 1 );
+    ntk.foreach_fanin( n, [this, level]( auto const& f ) {
+      if ( ntk.level( ntk.get_node( f ) ) == level - 1 )
+      {
+        mark_critical_path( ntk.get_node( f ) );
+      }
+    } );
+  }
+
+  void mark_critical_paths()
+  {
+    ntk.clear_values();
+    ntk.foreach_po( [this]( auto const& f ) {
+      if ( ntk.level( ntk.get_node( f ) ) == ntk.depth() )
+      {
+        mark_critical_path( ntk.get_node( f ) );
+      }
+    } );
+  }
+
+private:
+  Ntk& ntk;
+  xmg_algebraic_depth_rewriting_params const& ps;
+};
+
+} // namespace detail
+
+/*! \brief XMG algebraic depth rewriting.
+ *
+ * This algorithm tries to rewrite a network with majority gates for depth
+ * optimization using the associativity and distributivity rule in
+ * majority-of-3 logic.  It can be applied to networks other than XMGs, but
+ * only considers pairs of nodes which both implement the majority-of-3
+ * function and the XOR function.
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `level`
+ * - `update_levels`
+ * - `create_maj`
+ * - `substitute_node`
+ * - `foreach_node`
+ * - `foreach_po`
+ * - `foreach_fanin`
+ * - `is_maj`
+ * - `clear_values`
+ * - `set_value`
+ * - `value`
+ * - `fanout_size`
+ *
+   \verbatim embed:rst
+
+  .. note::
+
+      The implementation of this algorithm was heavily inspired by an
+      implementation from Luca Amarù.
+   \endverbatim
+ */
+template<class Ntk>
+void xmg_algebraic_depth_rewriting( Ntk& ntk, xmg_algebraic_depth_rewriting_params const& ps = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_level_v<Ntk>, "Ntk does not implement the level method" );
+  static_assert( has_create_maj_v<Ntk>, "Ntk does not implement the create_maj method" );
+  static_assert( has_create_xor_v<Ntk>, "Ntk does not implement the create_maj method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the substitute_node method" );
+  static_assert( has_update_levels_v<Ntk>, "Ntk does not implement the update_levels method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_is_maj_v<Ntk>, "Ntk does not implement the is_maj method" );
+  static_assert( has_is_xor3_v<Ntk>, "Ntk does not implement the is_maj method" );
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_value_v<Ntk>, "Ntk does not implement the value method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+
+  detail::xmg_algebraic_depth_rewriting_impl<Ntk> p( ntk, ps );
+  p.run();
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/xmg_optimization.hpp b/include/mockturtle/algorithms/xmg_optimization.hpp
new file mode 100644
index 0000000..b19c73d
--- /dev/null
+++ b/include/mockturtle/algorithms/xmg_optimization.hpp
@@ -0,0 +1,101 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xmg_optimization.hpp
+  \brief Rewriting MAJ to XNORs.
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+#include "../networks/xmg.hpp"
+#include "../utils/node_map.hpp"
+#include "../views/topo_view.hpp"
+#include "cleanup.hpp"
+#include "dont_cares.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Optimizes some MAJ gates using satisfiability don't cares
+ *
+ * The function is based on `xag_dont_cares_optimization` in `xag_optimization.hpp`.
+ *
+ * If a MAJ gate is satisfiability don't care for assignments 000 and 111, it can be
+ * replaced by an XNOR gate.
+ */
+inline xmg_network xmg_dont_cares_optimization( xmg_network const& xmg )
+{
+  node_map<xmg_network::signal, xmg_network> old_to_new( xmg );
+
+  xmg_network dest;
+  old_to_new[xmg.get_constant( false )] = dest.get_constant( false );
+
+  xmg.foreach_pi( [&]( auto const& n ) {
+    old_to_new[n] = dest.create_pi();
+  } );
+
+  satisfiability_dont_cares_checker<xmg_network> checker( xmg );
+
+  topo_view<xmg_network>{ xmg }.foreach_node( [&]( auto const& n ) {
+    if ( xmg.is_constant( n ) || xmg.is_pi( n ) )
+      return;
+
+    std::array<xmg_network::signal, 3> fanin;
+    xmg.foreach_fanin( n, [&]( auto const& f, auto i ) {
+      fanin[i] = old_to_new[f] ^ xmg.is_complemented( f );
+    } );
+
+    if ( xmg.is_maj( n ) )
+    {
+      if ( checker.is_dont_care( n, { false, false, false } ) && checker.is_dont_care( n, { true, true, true } ) )
+      {
+        old_to_new[n] = dest.create_xor3( !fanin[0], fanin[1], fanin[2] );
+      }
+      else
+      {
+        old_to_new[n] = dest.create_maj( fanin[0], fanin[1], fanin[2] );
+      }
+    }
+    else /* is XOR */
+    {
+      old_to_new[n] = dest.create_xor3( fanin[0], fanin[1], fanin[2] );
+    }
+  } );
+
+  xmg.foreach_po( [&]( auto const& f ) {
+    dest.create_po( old_to_new[f] ^ xmg.is_complemented( f ) );
+  } );
+
+  return dest;
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/algorithms/xmg_resub.hpp b/include/mockturtle/algorithms/xmg_resub.hpp
new file mode 100644
index 0000000..44690e0
--- /dev/null
+++ b/include/mockturtle/algorithms/xmg_resub.hpp
@@ -0,0 +1,346 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xmg_resub.hpp
+  \brief Resubstitution
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Shubham Rai
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+#include "../networks/xmg.hpp"
+#include "dont_cares.hpp"
+#include "resubstitution.hpp"
+#include <kitty/operations.hpp>
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+/*! \brief Ternary XOR of three truth tables */
+template<typename TT>
+inline TT ternary_xor( const TT& first, const TT& second, const TT& third )
+{
+  return kitty::ternary_operation( first, second, third, []( auto a, auto b, auto c ) { return ( ( a ^ b ) ^ c ); } );
+}
+
+} // namespace detail
+
+struct xmg_resub_stats
+{
+  /*! \brief Accumulated runtime for const-resub */
+  stopwatch<>::duration time_resubC{ 0 };
+
+  /*! \brief Accumulated runtime for zero-resub */
+  stopwatch<>::duration time_resub0{ 0 };
+
+  /*! \brief Accumulated runtime for one-resub */
+  stopwatch<>::duration time_resub1{ 0 };
+
+  /*! \brief Number of accepted constant resubsitutions */
+  uint32_t num_const_accepts{ 0 };
+
+  /*! \brief Number of accepted zero resubsitutions */
+  uint32_t num_div0_accepts{ 0 };
+
+  /*! \brief Number of accepted one resubsitutions */
+  uint32_t num_div1_accepts{ 0 };
+
+  uint32_t num_div1_xor3_accepts{ 0 };
+  uint32_t num_div1_xnor3_accepts{ 0 };
+  uint32_t num_div1_maj3_accepts{ 0 };
+  uint32_t num_div1_not_maj3_accepts{ 0 };
+
+  uint32_t num_filtered0{ 0 };
+  uint32_t num_filtered1{ 0 };
+
+  void report() const
+  {
+    fmt::print( "[i] kernel: xmg_resub_functor\n" );
+    fmt::print( "[i] constant-resub {:6d}                                                           ({:>5.2f} secs)\n",
+                num_const_accepts, to_seconds( time_resubC ) );
+    fmt::print( "[i]        0-resub {:6d}                                                           ({:>5.2f} secs)\n",
+                num_div0_accepts, to_seconds( time_resub0 ) );
+    fmt::print( "[i]        1-resub {:6d} = {:6d} XOR3 + {:6d} XNOR3 + {:6d} MAJ3 + {:6d} NOT-MAJ3  ({:>5.2f} secs)\n",
+                num_div1_accepts, num_div1_xor3_accepts, num_div1_xnor3_accepts, num_div1_maj3_accepts, num_div1_not_maj3_accepts,
+                to_seconds( time_resub1 ) );
+    fmt::print( "[i] filtering candidates: {:6d} candidates in first loop + {:6d} candidates in second loop\n", num_filtered0, num_filtered1 );
+  }
+}; /* xmg_resub_stats */
+
+template<typename Ntk, typename Simulator, typename TT>
+struct xmg_resub_functor
+{
+public:
+  using node = xmg_network::node;
+  using signal = xmg_network::signal;
+  using stats = xmg_resub_stats;
+
+public:
+  explicit xmg_resub_functor( Ntk& ntk, Simulator const& sim, std::vector<node> const& divs, uint32_t num_divs, stats& st )
+      : ntk( ntk ), sim( sim ), divs( divs ), num_divs( num_divs ), st( st )
+  {
+  }
+
+  std::optional<signal> operator()( node const& root, TT& care, uint32_t required, uint32_t max_inserts, uint32_t num_mffc, uint32_t& last_gain )
+  {
+    (void)care;
+    assert( is_const0( ~care ) );
+
+    auto const tt = sim.get_tt( ntk.make_signal( root ) );
+    if ( care.num_vars() > tt.num_vars() )
+      care = kitty::shrink_to( care, tt.num_vars() );
+    else
+      care = kitty::extend_to( care, tt.num_vars() );
+
+    /* consider constants */
+    auto g = call_with_stopwatch( st.time_resubC, [&]() {
+      return resub_const( root, care, required );
+    } );
+    if ( g )
+    {
+      ++st.num_const_accepts;
+      last_gain = num_mffc;
+      return g; /* accepted resub */
+    }
+
+    /* consider equal nodes */
+    g = call_with_stopwatch( st.time_resub0, [&]() {
+      return resub_div0( root, care, required );
+    } );
+    if ( g )
+    {
+      ++st.num_div0_accepts;
+      last_gain = num_mffc;
+      return g; /* accepted resub */
+    }
+
+    if ( max_inserts == 0 || num_mffc == 1 )
+      return std::nullopt;
+
+    /* consider adding one gate */
+    g = call_with_stopwatch( st.time_resub1, [&]() {
+      return resub_div1( root, care, required );
+    } );
+    if ( g )
+    {
+      ++st.num_div1_accepts;
+      last_gain = num_mffc - 1;
+      return g; /* accepted resub */
+    }
+
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_const( node const& root, TT& care, uint32_t required ) const
+  {
+    (void)required;
+    auto const tt = sim.get_tt( ntk.make_signal( root ) );
+
+    if ( binary_and( tt, care ) == sim.get_tt( ntk.get_constant( false ) ) )
+    {
+      return sim.get_phase( root ) ? ntk.get_constant( true ) : ntk.get_constant( false );
+    }
+    return std::nullopt;
+  }
+
+  std::optional<signal> resub_div0( node const& root, TT& care, uint32_t required ) const
+  {
+    (void)required;
+    auto const tt = sim.get_tt( ntk.make_signal( root ) );
+    for ( auto i = 0u; i < num_divs; ++i )
+    {
+      auto const d = divs.at( i );
+
+      if ( binary_and( tt, care ) != binary_and( sim.get_tt( ntk.make_signal( d ) ), care ) )
+        continue; /* next */
+
+      return ( sim.get_phase( d ) ^ sim.get_phase( root ) ) ? !ntk.make_signal( d ) : ntk.make_signal( d );
+    }
+
+    return std::nullopt;
+  }
+
+  struct divisor
+  {
+    explicit divisor( uint32_t node, int32_t entropy )
+        : node( node ), entropy( entropy )
+    {
+    }
+
+    uint32_t node;
+    int32_t entropy;
+  };
+
+  std::optional<signal> resub_div1( node const& root, TT& care, uint32_t required )
+  {
+    (void)required;
+    auto const& tt = sim.get_tt( ntk.make_signal( root ) );
+
+    const auto root_rdb = static_cast<int32_t>( absolute_distinguishing_power( tt ) );
+
+    std::vector<divisor> sorted_divs;
+    for ( auto it = std::begin( divs ), ie = std::begin( divs ) + num_divs; it != ie; ++it )
+    {
+      auto const s = ntk.make_signal( *it );
+      auto const& tt_s = sim.get_tt( s );
+      sorted_divs.emplace_back( static_cast<uint32_t>( *it ), static_cast<uint32_t>( relative_distinguishing_power( tt_s, tt ) ) );
+    }
+    std::stable_sort( std::rbegin( sorted_divs ), std::rend( sorted_divs ),
+               [&]( auto const& u, auto const& v ) {
+                 if ( u.entropy == v.entropy )
+                   return u.node < v.node;
+                 return u.entropy < v.entropy;
+               } );
+
+    for ( auto i = 0u; i < sorted_divs.size(); ++i )
+    {
+      auto const s0 = ntk.make_signal( sorted_divs.at( i ).node );
+      auto const& tt0 = sim.get_tt( s0 );
+      auto const a = sim.get_phase( ntk.get_node( s0 ) ) ? !s0 : s0;
+
+      int64_t const db_s0 = sorted_divs.at( i ).entropy;
+      int64_t const bound0 = root_rdb - db_s0;
+      for ( auto j = i + 1; j < sorted_divs.size(); ++j )
+      {
+        auto const s1 = ntk.make_signal( sorted_divs.at( j ).node );
+        auto const& tt1 = sim.get_tt( s1 );
+        auto const b = sim.get_phase( ntk.get_node( s1 ) ) ? !s1 : s1;
+
+        int64_t const db_s1 = sorted_divs.at( j ).entropy;
+        if ( ( 2u * db_s1 ) < bound0 )
+        {
+          st.num_filtered0 += static_cast<uint32_t>( ( sorted_divs.size() - j - 1 ) * ( sorted_divs.size() - j ) );
+          break;
+        }
+
+        int64_t const bound1 = bound0 - db_s1;
+        for ( auto k = j + 1; k < sorted_divs.size(); ++k )
+        {
+          auto const s2 = ntk.make_signal( sorted_divs.at( k ).node );
+          auto const& tt2 = sim.get_tt( s2 );
+          auto const c = sim.get_phase( ntk.get_node( s2 ) ) ? !s2 : s2;
+
+          int64_t const db_s2 = sorted_divs.at( k ).entropy;
+          if ( db_s2 < bound1 )
+          {
+            st.num_filtered1 += static_cast<uint32_t>( sorted_divs.size() - k - 1 );
+            break;
+          }
+
+          if ( binary_and( tt, care ) == binary_and( detail::ternary_xor( tt0, tt1, tt2 ), care ) )
+          {
+            /* XOR3 */
+            ++st.num_div1_xor3_accepts;
+            return sim.get_phase( root ) ? !ntk.create_xor3( a, b, c ) : ntk.create_xor3( a, b, c );
+          }
+          else if ( binary_and( tt, care ) == binary_and( detail::ternary_xor( ~tt0, tt1, tt2 ), care ) )
+          {
+            /* XNOR3 */
+            ++st.num_div1_xnor3_accepts;
+            return sim.get_phase( root ) ? !ntk.create_xor3( !a, b, c ) : ntk.create_xor3( !a, b, c );
+          }
+          else if ( binary_and( tt, care ) == binary_and( kitty::ternary_majority( tt0, tt1, tt2 ), care ) )
+          {
+            /* MAJ3 */
+            ++st.num_div1_maj3_accepts;
+            return sim.get_phase( root ) ? !ntk.create_maj( a, b, c ) : ntk.create_maj( a, b, c );
+          }
+          else if ( binary_and( tt, care ) == binary_and( kitty::ternary_majority( ~tt0, tt1, tt2 ), care ) )
+          {
+            /* NOT-MAJ3 */
+            ++st.num_div1_not_maj3_accepts;
+            return sim.get_phase( root ) ? !ntk.create_maj( !a, b, c ) : ntk.create_maj( !a, b, c );
+          }
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+private:
+  Ntk& ntk;
+  Simulator const& sim;
+  std::vector<node> const& divs;
+  uint32_t const num_divs;
+  stats& st;
+}; /* xmg_resub_functor */
+
+template<class Ntk>
+void xmg_resubstitution( Ntk& ntk, resubstitution_params const& ps = {}, resubstitution_stats* pst = nullptr )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the has_size method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the has substitute_node method" );
+  static_assert( has_value_v<Ntk>, "Ntk does not implement the has_value method" );
+  static_assert( has_visited_v<Ntk>, "Ntk does not implement the has_visited method" );
+
+  using resub_view_t = fanout_view<depth_view<Ntk>>;
+  depth_view<Ntk> depth_view{ ntk };
+  resub_view_t resub_view{ depth_view };
+
+  using truthtable_t = kitty::dynamic_truth_table;
+  using truthtable_dc_t = kitty::dynamic_truth_table;
+  using resub_impl_t = detail::resubstitution_impl<resub_view_t, typename detail::window_based_resub_engine<resub_view_t, truthtable_t, truthtable_dc_t, xmg_resub_functor<resub_view_t, typename detail::window_simulator<resub_view_t, truthtable_t>, truthtable_dc_t>>>;
+
+  resubstitution_stats st;
+  typename resub_impl_t::engine_st_t engine_st;
+  typename resub_impl_t::collector_st_t collector_st;
+
+  resub_impl_t p( resub_view, ps, st, engine_st, collector_st );
+  p.run();
+
+  if ( ps.verbose )
+  {
+    st.report();
+    collector_st.report();
+    engine_st.report();
+  }
+
+  if ( pst )
+  {
+    *pst = st;
+  }
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/generators/arithmetic.hpp b/include/mockturtle/generators/arithmetic.hpp
new file mode 100644
index 0000000..f99df24
--- /dev/null
+++ b/include/mockturtle/generators/arithmetic.hpp
@@ -0,0 +1,411 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file arithmetic.hpp
+  \brief Generate arithmetic logic networks
+
+  \author Heinz Riener
+  \author Jovan Blanuša
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <list>
+#include <utility>
+#include <vector>
+
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+
+#include "../networks/aig.hpp"
+#include "../traits.hpp"
+#include "control.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Inserts a full adder into a network.
+ *
+ * Inserts a full adder for three inputs (two 1-bit operands and one carry)
+ * into the network and returns a pair of sum and carry bit.
+ *
+ * By default creates a seven 2-input gate network composed of AND, NOR, and OR
+ * gates.  If network has `create_node` function, creates two 3-input gate
+ * network.  If the network has ternary `create_maj` and `create_xor3`
+ * functions, it will use them (except for AIGs).
+ *
+ * \param ntk Network
+ * \param a First input operand
+ * \param b Second input operand
+ * \param c Carry
+ * \return Pair of sum (`first`) and carry (`second`)
+ */
+template<typename Ntk>
+inline std::pair<signal<Ntk>, signal<Ntk>> full_adder( Ntk& ntk, const signal<Ntk>& a, const signal<Ntk>& b, const signal<Ntk>& c )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+
+  /* specialization for LUT-ish networks */
+  if constexpr ( has_create_node_v<Ntk> )
+  {
+    kitty::dynamic_truth_table tt_maj( 3u ), tt_xor( 3u );
+    kitty::create_from_hex_string( tt_maj, "e8" );
+    kitty::create_from_hex_string( tt_xor, "96" );
+
+    const auto sum = ntk.create_node( { a, b, c }, tt_xor );
+    const auto carry = ntk.create_node( { a, b, c }, tt_maj );
+
+    return { sum, carry };
+  }
+  /* use MAJ and XOR3 if available by network, unless network is AIG */
+  else if constexpr ( !std::is_same_v<typename Ntk::base_type, aig_network> && has_create_maj_v<Ntk> && has_create_xor3_v<Ntk> )
+  {
+    const auto carry = ntk.create_maj( a, b, c );
+    const auto sum = ntk.create_xor3( a, b, c );
+    return { sum, carry };
+  }
+  else
+  {
+    static_assert( has_create_and_v<Ntk>, "Ntk does not implement the create_and method" );
+    static_assert( has_create_nor_v<Ntk>, "Ntk does not implement the create_nor method" );
+    static_assert( has_create_or_v<Ntk>, "Ntk does not implement the create_or method" );
+
+    const auto w1 = ntk.create_and( a, b );
+    const auto w2 = ntk.create_nor( a, b );
+    const auto w3 = ntk.create_nor( w1, w2 );
+    const auto w4 = ntk.create_and( c, w3 );
+    const auto w5 = ntk.create_nor( c, w3 );
+    const auto sum = ntk.create_nor( w4, w5 );
+    const auto carry = ntk.create_or( w1, w4 );
+
+    return { sum, carry };
+  }
+}
+
+/*! \brief Inserts a half adder into a network.
+ *
+ * Inserts a half adder for two inputs (two 1-bit operands)
+ * into the network and returns a pair of sum and carry bit.
+ *
+ * It creates three 2-input gate network composed of AND and NOR gates.
+ *
+ * \param ntk Network
+ * \param a First input operand
+ * \param b Second input operand
+ * \return Pair of sum (`first`) and carry (`second`)
+ */
+template<typename Ntk>
+inline std::pair<signal<Ntk>, signal<Ntk>> half_adder( Ntk& ntk, const signal<Ntk>& a, const signal<Ntk>& b )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+
+  /* specialization for LUT-ish networks */
+  if constexpr ( has_create_node_v<Ntk> )
+  {
+    kitty::dynamic_truth_table tt_and( 2u ), tt_xor( 2u );
+    kitty::create_from_hex_string( tt_and, "8" );
+    kitty::create_from_hex_string( tt_xor, "6" );
+
+    const auto sum = ntk.create_node( { a, b }, tt_xor );
+    const auto carry = ntk.create_node( { a, b }, tt_and );
+
+    return { sum, carry };
+  }
+  else
+  {
+    static_assert( has_create_and_v<Ntk>, "Ntk does not implement the create_and method" );
+    static_assert( has_create_nor_v<Ntk>, "Ntk does not implement the create_nor method" );
+
+    const auto carry = ntk.create_and( a, b );
+    const auto w2 = ntk.create_nor( a, b );
+    const auto sum = ntk.create_nor( carry, w2 );
+
+    return { sum, carry };
+  }
+}
+
+/*! \brief Creates carry ripple adder structure.
+ *
+ * Creates a carry ripple structure composed of full adders.  The vectors `a`
+ * and `b` must have the same size.  The resulting sum bits are eventually
+ * stored in `a` and the carry bit will be overridden to store the output carry
+ * bit.
+ *
+ * \param a First input operand, will also have the output after the call
+ * \param b Second input operand
+ * \param carry Carry bit, will also have the output carry after the call
+ */
+template<typename Ntk>
+inline void carry_ripple_adder_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<signal<Ntk>> const& b, signal<Ntk>& carry )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+
+  assert( a.size() == b.size() );
+
+  auto pa = a.begin();
+  for ( auto pb = b.begin(); pa != a.end(); ++pa, ++pb )
+  {
+    std::tie( *pa, carry ) = full_adder( ntk, *pa, *pb, carry );
+  }
+}
+
+/*! \brief Creates carry ripple subtractor structure.
+ *
+ * Creates a carry ripple structure composed of full adders.  The vectors `a`
+ * and `b` must have the same size.  The resulting sum bits are eventually
+ * stored in `a` and the carry bit will be overridden to store the output carry
+ * bit.  The inputs in `b` are inverted to realize subtraction with full
+ * adders.  The carry bit must be passed in inverted state to the subtractor.
+ *
+ * \param a First input operand, will also have the output after the call
+ * \param b Second input operand
+ * \param carry Carry bit, will also have the output carry after the call
+ */
+template<typename Ntk>
+inline void carry_ripple_subtractor_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, const std::vector<signal<Ntk>>& b, signal<Ntk>& carry )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+
+  assert( a.size() == b.size() );
+
+  auto pa = a.begin();
+  for ( auto pb = b.begin(); pa != a.end(); ++pa, ++pb )
+  {
+    std::tie( *pa, carry ) = full_adder( ntk, *pa, ntk.create_not( *pb ), carry );
+  }
+}
+
+/*! \brief Creates a classical multiplier using full adders.
+ *
+ * The vectors `a` and `b` must not have the same size.  The function creates
+ * the multiplier in `ntk` and returns output signals, whose size is the summed
+ * sizes of `a` and `b`.
+ *
+ * \param ntk Network
+ * \param a First input operand
+ * \param b Second input operand
+ */
+template<typename Ntk>
+inline std::vector<signal<Ntk>> carry_ripple_multiplier( Ntk& ntk, std::vector<signal<Ntk>> const& a, std::vector<signal<Ntk>> const& b )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_and_v<Ntk>, "Ntk does not implement the create_and method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+
+  auto res = constant_word( ntk, 0, static_cast<uint32_t>( a.size() + b.size() ) );
+  auto tmp = constant_word( ntk, 0, static_cast<uint32_t>( a.size() * 2 ) );
+
+  for ( auto j = 0u; j < b.size(); ++j )
+  {
+    for ( auto i = 0u; i < a.size(); ++i )
+    {
+      std::tie( i ? tmp[a.size() + i - 1] : res[j], tmp[i] ) = full_adder( ntk, ntk.create_and( a[i], b[j] ), tmp[a.size() + i], tmp[i] );
+    }
+  }
+
+  auto carry = tmp.back() = ntk.get_constant( false );
+  for ( auto i = 0u; i < a.size(); ++i )
+  {
+    std::tie( res[b.size() + i], carry ) = full_adder( ntk, tmp[i], tmp[a.size() + i], carry );
+  }
+
+  return res;
+}
+
+// CLA implementation based on Alan Mishchenko's implementation in
+// https://github.com/berkeley-abc/abc/blob/master/src/base/wlc/wlcBlast.c
+namespace detail
+{
+
+template<typename Ntk>
+inline std::pair<signal<Ntk>, signal<Ntk>> carry_lookahead_adder_inplace_rec( Ntk& ntk,
+                                                                              typename std::vector<signal<Ntk>>::iterator genBegin,
+                                                                              typename std::vector<signal<Ntk>>::iterator genEnd,
+                                                                              typename std::vector<signal<Ntk>>::iterator proBegin,
+                                                                              typename std::vector<signal<Ntk>>::iterator carBegin )
+{
+  auto const term_case = [&]( signal<Ntk> const& gen0, signal<Ntk> const& gen1, signal<Ntk> const& pro0, signal<Ntk> const& pro1, signal<Ntk> const& car ) -> std::tuple<signal<Ntk>, signal<Ntk>, signal<Ntk>> {
+    auto tmp = ntk.create_and( gen0, pro1 );
+    auto rPro = ntk.create_and( pro0, pro1 );
+    auto rGen = ntk.create_or( ntk.create_or( gen1, tmp ), ntk.create_and( rPro, car ) );
+    auto rCar = ntk.create_or( gen0, ntk.create_and( pro0, car ) );
+
+    return { rGen, rPro, rCar };
+  };
+
+  auto m = std::distance( genBegin, genEnd );
+
+  if ( m == 2 )
+  {
+    const auto [gen, pro, car] = term_case( *genBegin, *( genBegin + 1 ), *proBegin, *( proBegin + 1 ), *carBegin );
+    *( carBegin + 1 ) = car;
+    return { gen, pro };
+  }
+  else
+  {
+    m >>= 1;
+    const auto [gen0, pro0] = carry_lookahead_adder_inplace_rec( ntk, genBegin, genBegin + m, proBegin, carBegin );
+    *( carBegin + m ) = gen0;
+    const auto [gen1, pro1] = carry_lookahead_adder_inplace_rec( ntk, genBegin + m, genEnd, proBegin + m, carBegin + m );
+
+    const auto [gen, pro, car] = term_case( gen0, gen1, pro0, pro1, *carBegin );
+    *( carBegin + m ) = car;
+    return { gen, pro };
+  }
+}
+
+template<typename Ntk>
+inline void carry_lookahead_adder_inplace_pow2( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<signal<Ntk>> const& b, signal<Ntk>& carry )
+{
+  if ( a.size() == 1u )
+  {
+    a[0] = full_adder( ntk, a[0], b[0], carry ).first;
+    return;
+  }
+
+  std::vector<signal<Ntk>> gen( a.size() ), pro( a.size() ), car( a.size() + 1 );
+  car[0] = carry;
+  std::transform( a.begin(), a.end(), b.begin(), gen.begin(), [&]( auto const& f, auto const& g ) { return ntk.create_and( f, g ); } );
+  std::transform( a.begin(), a.end(), b.begin(), pro.begin(), [&]( auto const& f, auto const& g ) { return ntk.create_xor( f, g ); } );
+
+  carry_lookahead_adder_inplace_rec( ntk, gen.begin(), gen.end(), pro.begin(), car.begin() );
+  std::transform( pro.begin(), pro.end(), car.begin(), a.begin(), [&]( auto const& f, auto const& g ) { return ntk.create_xor( f, g ); } );
+}
+
+} // namespace detail
+
+/*! \brief Creates carry lookahead adder structure.
+ *
+ * Creates a carry lookahead structure composed of full adders.  The vectors `a`
+ * and `b` must have the same size.  The resulting sum bits are eventually
+ * stored in `a` and the carry bit will be overridden to store the output carry
+ * bit.
+ *
+ * \param a First input operand, will also have the output after the call
+ * \param b Second input operand
+ * \param carry Carry bit, will also have the output carry after the call
+ */
+template<typename Ntk>
+inline void carry_lookahead_adder_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<signal<Ntk>> const& b, signal<Ntk>& carry )
+{
+  /* extend bitsize to next power of two */
+  const auto log2 = static_cast<uint32_t>( std::ceil( std::log2( static_cast<double>( a.size() + 1 ) ) ) );
+
+  std::vector<signal<Ntk>> a_ext( a.begin(), a.end() );
+  a_ext.resize( static_cast<uint64_t>( 1 ) << log2, ntk.get_constant( false ) );
+  std::vector<signal<Ntk>> b_ext( b.begin(), b.end() );
+  b_ext.resize( static_cast<uint64_t>( 1 ) << log2, ntk.get_constant( false ) );
+
+  detail::carry_lookahead_adder_inplace_pow2( ntk, a_ext, b_ext, carry );
+
+  std::copy_n( a_ext.begin(), a.size(), a.begin() );
+  carry = a_ext[a.size()];
+}
+
+/*! \brief Creates a sideways sum adder using half and full adders
+ *
+ * The function creates the adder in `ntk` and returns output signals,
+ * whose size is floor(log2(a.size()))+1.
+ *
+ * \param ntk Network
+ * \param a Input operand
+ */
+template<typename Ntk>
+inline std::vector<signal<Ntk>> sideways_sum_adder( Ntk& ntk, std::vector<signal<Ntk>> const& a )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+
+  int n = static_cast<int>( a.size() );
+
+  int out_n = 1; // floor(log2(n) + 1)
+  int tmpn = n;
+  while ( tmpn >>= 1 )
+    out_n++;
+
+  std::list<signal<Ntk>> sum_bits, carry_bits;
+
+  auto* first_level = &sum_bits;
+  auto* second_level = &carry_bits;
+
+  auto res = constant_word( ntk, 0, out_n );
+  int output_ind = 0;
+
+  for ( int i = 0; i < n; i++ )
+    first_level->push_back( a[i] );
+
+  while ( 1 )
+  {
+    while ( !first_level->empty() )
+    {
+      if ( first_level->size() == 1 )
+      {
+        auto in_sig = first_level->front();
+        first_level->pop_front();
+        res[output_ind++] = in_sig;
+      }
+      else if ( first_level->size() == 2 )
+      {
+        auto in_sig1 = first_level->front();
+        first_level->pop_front();
+        auto in_sig2 = first_level->front();
+        first_level->pop_front();
+        signal<Ntk> tmp_sum;
+        signal<Ntk> tmp_carry;
+        std::tie( tmp_sum, tmp_carry ) = half_adder( ntk, in_sig1, in_sig2 );
+        first_level->push_back( tmp_sum );
+        second_level->push_back( tmp_carry );
+      }
+      else // first_level->size() >=3
+      {
+        auto in_sig1 = first_level->front();
+        first_level->pop_front();
+        auto in_sig2 = first_level->front();
+        first_level->pop_front();
+        auto in_sig3 = first_level->front();
+        first_level->pop_front();
+        signal<Ntk> tmp_sum;
+        signal<Ntk> tmp_carry;
+        std::tie( tmp_sum, tmp_carry ) = full_adder( ntk, in_sig1, in_sig2, in_sig3 );
+        first_level->push_back( tmp_sum );
+        second_level->push_back( tmp_carry );
+      }
+    }
+
+    if ( second_level->empty() )
+      break;
+
+    // swapping buffers
+    auto tmp = first_level;
+    first_level = second_level;
+    second_level = tmp;
+  }
+
+  return res;
+}
+
+} // namespace mockturtle
diff --git a/include/mockturtle/generators/control.hpp b/include/mockturtle/generators/control.hpp
new file mode 100644
index 0000000..8c2fe52
--- /dev/null
+++ b/include/mockturtle/generators/control.hpp
@@ -0,0 +1,217 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file control.hpp
+  \brief Generate control logic networks
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <vector>
+
+#include "../traits.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Creates a word from a constant
+ *
+ * Creates a vector of `bitwidth` constants that represent the positive number
+ * `value`.
+ */
+template<class Ntk>
+inline std::vector<signal<Ntk>> constant_word( Ntk& ntk, uint64_t value, uint32_t bitwidth )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+
+  std::vector<signal<Ntk>> word( bitwidth );
+  for ( auto i = 0u; i < bitwidth; ++i )
+  {
+    bool bit = false;
+    if ( i < 64 )
+    {
+      bit = static_cast<bool>( ( value >> i ) & 1 );
+    }
+    word[i] = ntk.get_constant( bit );
+  }
+  return word;
+}
+
+/*! \brief Extends a word by leading zeros
+ *
+ * Adds leading zeros as most-significant bits to word `a`.  The size of `a`
+ * must be smaller or equal to `bitwidth`, which is the width of the resulting
+ * word.
+ */
+template<class Ntk>
+inline std::vector<signal<Ntk>> zero_extend( Ntk& ntk, std::vector<signal<Ntk>> const& a, uint32_t bitwidth )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+
+  assert( bitwidth >= a.size() );
+
+  auto ret{ a };
+  for ( auto i = a.size(); i < bitwidth; ++i )
+  {
+    ret.emplace_back( ntk.get_constant( false ) );
+  }
+  return ret;
+}
+
+/*! \brief Creates a 2k-k MUX (array of k 2-1 MUXes).
+ *
+ * This creates *k* MUXes using `cond` as condition signal and `t` for the then
+ * signals and `e` for the else signals.  The method works in-place and writes
+ * the outputs of the networ into `t`.
+ */
+template<class Ntk>
+inline void mux_inplace( Ntk& ntk, signal<Ntk> const& cond, std::vector<signal<Ntk>>& t, std::vector<signal<Ntk>> const& e )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_ite_v<Ntk>, "Ntk does not implement the create_ite method" );
+
+  std::transform( t.begin(), t.end(), e.begin(), t.begin(), [&]( auto const& a, auto const& b ) { return ntk.create_ite( cond, a, b ); } );
+}
+
+template<class Ntk>
+inline std::vector<signal<Ntk>> mux( Ntk& ntk, signal<Ntk> const& cond, std::vector<signal<Ntk>> const& t, std::vector<signal<Ntk>> const& e )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_ite_v<Ntk>, "Ntk does not implement the create_ite method" );
+
+  std::vector<signal<Ntk>> ret;
+  std::transform( t.begin(), t.end(), e.begin(), std::back_inserter( ret ), [&]( auto const& a, auto const& b ) { return ntk.create_ite( cond, a, b ); } );
+  return ret;
+}
+
+/*! \brief Creates k-to-2^k binary decoder
+ *
+ * Given k signals `xs`, this function creates 2^k signals of which exactly one
+ * input is 1, for each of the 2^k input assignments to `xs`.
+ */
+template<class Ntk>
+std::vector<signal<Ntk>> binary_decoder( Ntk& ntk, std::vector<signal<Ntk>> const& xs )
+{
+  if ( xs.empty() )
+  {
+    return {};
+  }
+
+  if ( xs.size() == 1u )
+  {
+    return { ntk.create_not( xs[0] ), xs[0] };
+  }
+
+  // recursion
+  const auto m = ( xs.size() + 1 ) / 2;
+
+  const auto d1 = binary_decoder( ntk, std::vector<signal<Ntk>>( xs.begin(), xs.begin() + m ) );
+  const auto d2 = binary_decoder( ntk, std::vector<signal<Ntk>>( xs.begin() + m, xs.end() ) );
+
+  std::vector<signal<Ntk>> d( 1 << xs.size() );
+  auto it = d.begin();
+
+  for ( auto const& s2 : d2 )
+  {
+    for ( auto const& s1 : d1 )
+    {
+      *it++ = ntk.create_and( s1, s2 );
+    }
+  }
+
+  return d;
+}
+
+/*! \brief Creates 2^k MUX
+ *
+ * Given k select signals `sel` and 2^k data signals `data`, this function
+ * creates a logic network that outputs `data[i]` when `i` is the encoded
+ * assignment of `sel`.
+ *
+ * This is an iterative construction based on MUX gates.  A more efficient
+ * method may be provided by the Klein-Paterson variant
+ * `binary_mux_klein_paterson`.
+ */
+template<class Ntk>
+signal<Ntk> binary_mux( Ntk& ntk, std::vector<signal<Ntk>> const& sel, std::vector<signal<Ntk>> data )
+{
+  for ( auto i = 0u; i < sel.size(); ++i )
+  {
+    for ( auto j = 0u; j < ( 1u << ( sel.size() - i - 1u ) ); ++j )
+    {
+      data[j] = ntk.create_ite( sel[i], data[2 * j + 1], data[2 * j] );
+    }
+  }
+
+  return data[0u];
+}
+
+/*! \brief Creates 2^k MUX
+ *
+ * Given k select signals `sel` and 2^k data signals `data`, this function
+ * creates a logic network that outputs `data[i]` when `i` is the encoded
+ * assignment of `sel`.
+ *
+ * This Klein-Paterson variant uses fewer gates than the direct method
+ * `binary_mux` (see Klein, & Paterson. (1980). Asymptotically Optimal Circuit
+ * for a Storage Access Function. IEEE Transactions on Computers, C-29(8),
+ * 737–738. doi:10.1109/tc.1980.1675657 )
+ */
+template<class Ntk>
+signal<Ntk> binary_mux_klein_paterson( Ntk& ntk, std::vector<signal<Ntk>> const& sel, std::vector<signal<Ntk>> const& data )
+{
+  if ( sel.size() == 1u )
+  {
+    return ntk.create_ite( sel[0u], data[1u], data[0u] );
+  }
+
+  // recursion
+  const auto s = sel.size() / 2u;
+  const auto r = sel.size() - s;
+
+  const auto ds = binary_decoder( ntk, std::vector<signal<Ntk>>( sel.begin(), sel.begin() + s ) );
+  std::vector<signal<Ntk>> s_data( 1u << r );
+  for ( auto j = 0u; j < s_data.size(); ++j )
+  {
+    std::vector<signal<Ntk>> and_terms( 1u << s );
+    std::transform( ds.begin(), ds.end(),
+                    data.begin() + ( j * ( 1u << s ) ),
+                    and_terms.begin(),
+                    [&]( auto const& f1, auto const& f2 ) { return ntk.create_and( f1, f2 ); } );
+    s_data[j] = ntk.create_nary_or( and_terms );
+  }
+
+  return binary_mux_klein_paterson( ntk, std::vector<signal<Ntk>>( sel.begin() + s, sel.end() ), s_data );
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/generators/legacy.hpp b/include/mockturtle/generators/legacy.hpp
new file mode 100644
index 0000000..f278d64
--- /dev/null
+++ b/include/mockturtle/generators/legacy.hpp
@@ -0,0 +1,209 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file legacy.hpp
+  \brief Some older not used routines
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include <fmt/format.h>
+
+#include "../traits.hpp"
+#include "arithmetic.hpp"
+#include "control.hpp"
+
+namespace mockturtle
+{
+
+namespace legacy
+{
+
+namespace detail
+{
+
+template<class IntType = int64_t>
+inline std::pair<IntType, IntType> compute_montgomery_parameters( IntType c, IntType k = 0 )
+{
+  if ( k == 0 )
+  {
+    k = 1 << ( static_cast<IntType>( std::ceil( std::log2( c ) ) ) + 1 );
+  }
+
+  // egcd
+  IntType y = k % c;
+  IntType x = c;
+  IntType a{ 0 }, b{ 1 };
+
+  while ( y )
+  {
+    std::tie( a, b ) = std::pair<IntType, IntType>{ b, a - ( x / y ) * b };
+    std::tie( x, y ) = std::pair<IntType, IntType>{ y, x % y };
+  }
+
+  const IntType ki = ( a > 0 ) ? ( a % c ) : ( c + ( a % c ) % c );
+  const IntType factor = ( k * ki - 1 ) / c;
+
+  return { k, factor };
+}
+
+template<class Ntk>
+std::vector<signal<Ntk>> to_montgomery_form( Ntk& ntk, std::vector<signal<Ntk>> const& t, int32_t mod, uint32_t rbits, int64_t np )
+{
+  /* bit-width of original mod */
+  uint32_t nbits = t.size() - rbits;
+
+  std::vector<signal<Ntk>> t_rpart( t.begin(), t.begin() + rbits );
+  auto m = carry_ripple_multiplier( ntk, t_rpart, constant_word( ntk, np, rbits ) );
+  assert( m.size() == 2 * rbits );
+  m.resize( rbits );
+  assert( m.size() == rbits );
+
+  m = carry_ripple_multiplier( ntk, m, constant_word( ntk, mod, nbits ) );
+  assert( m.size() == t.size() );
+
+  auto carry = ntk.get_constant( false );
+  carry_ripple_adder_inplace( ntk, m, t, carry );
+
+  m.erase( m.begin(), m.begin() + rbits );
+  assert( m.size() == nbits );
+
+  std::vector<signal<Ntk>> sum( m.begin(), m.end() );
+  auto carry_inv = ntk.get_constant( true );
+  carry_ripple_subtractor_inplace( ntk, sum, constant_word( ntk, mod, nbits ), carry_inv );
+
+  mux_inplace( ntk, !carry, m, sum );
+  return m;
+}
+
+} /* namespace detail */
+
+/*! \brief Creates modular adder
+ *
+ * Given two input words of the same size *k*, this function creates a circuit
+ * that computes *k* output signals that represent \f$(a + b) \bmod (2^k -
+ * c)\f$.  The first input word `a` is overridden and stores the output signals.
+ */
+template<class Ntk>
+inline void modular_adder_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<signal<Ntk>> const& b, uint64_t c )
+{
+  /* c must be smaller than 2^k */
+  assert( c < ( UINT64_C( 1 ) << a.size() ) );
+
+  /* refer to simpler case */
+  if ( c == 0 )
+  {
+    modular_adder_inplace( ntk, a, b );
+    return;
+  }
+
+  const auto word = constant_word( ntk, c, static_cast<uint32_t>( a.size() ) );
+  auto carry = ntk.get_constant( false );
+  carry_ripple_adder_inplace( ntk, a, word, carry );
+
+  carry = ntk.get_constant( false );
+  carry_ripple_adder_inplace( ntk, a, b, carry );
+
+  std::vector<signal<Ntk>> sum( a.begin(), a.end() );
+  auto carry_inv = ntk.get_constant( true );
+  carry_ripple_subtractor_inplace( ntk, a, word, carry_inv );
+
+  mux_inplace( ntk, !carry, a, sum );
+}
+
+/*! \brief Creates modular subtractor
+ *
+ * Given two input words of the same size *k*, this function creates a circuit
+ * that computes *k* output signals that represent \f$(a - b) \bmod (2^k -
+ * c)\f$.  The first input word `a` is overridden and stores the output signals.
+ */
+template<class Ntk>
+inline void modular_subtractor_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<signal<Ntk>> const& b, uint64_t c )
+{
+  /* c must be smaller than 2^k */
+  assert( c < ( UINT64_C( 1 ) << a.size() ) );
+
+  /* refer to simpler case */
+  if ( c == 0 )
+  {
+    modular_subtractor_inplace( ntk, a, b );
+    return;
+  }
+
+  auto carry = ntk.get_constant( true );
+  carry_ripple_subtractor_inplace( ntk, a, b, carry );
+
+  const auto word = constant_word( ntk, c, static_cast<uint32_t>( a.size() ) );
+  std::vector<signal<Ntk>> sum( a.begin(), a.end() );
+  auto carry_inv = ntk.get_constant( true );
+  carry_ripple_subtractor_inplace( ntk, sum, word, carry_inv );
+
+  mux_inplace( ntk, carry, a, sum );
+}
+
+/*! \brief Creates modular multiplication based on Montgomery multiplication
+ *
+ * Given two inputs words of the same size *k*, this function creates a circuit
+ * that computes *k* output signals that represent \f$(ab) \bmod (2^k - c)\f$.
+ * The first input word `a` is overridden and stores the output signals.
+ *
+ * The implementation is based on Montgomery multiplication and includes the
+ * encoding and decoding in and from the Montgomery number representation.
+ * Correct functionality is only ensured if both `a` and `b` are smaller than
+ * \f$2^k - c\f$.
+ */
+template<class Ntk>
+inline void modular_multiplication_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<signal<Ntk>> const& b, uint64_t c )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+
+  const auto n = ( 1 << a.size() ) - c;
+  const auto nbits = static_cast<uint64_t>( std::ceil( std::log2( n ) ) );
+
+  auto [r, np] = detail::compute_montgomery_parameters<int64_t>( n );
+  const auto rbits = static_cast<uint64_t>( std::log2( r ) );
+
+  const auto f2 = constant_word( ntk, ( r * r ) % n, rbits );
+
+  const auto ma = detail::to_montgomery_form( ntk, carry_ripple_multiplier( ntk, a, f2 ), n, rbits, np );
+  const auto mb = detail::to_montgomery_form( ntk, carry_ripple_multiplier( ntk, b, f2 ), n, rbits, np );
+
+  assert( ma.size() == nbits );
+  assert( mb.size() == nbits );
+
+  a = detail::to_montgomery_form( ntk, zero_extend( ntk, carry_ripple_multiplier( ntk, ma, mb ), nbits + rbits ), n, rbits, np );
+  a = detail::to_montgomery_form( ntk, zero_extend( ntk, a, nbits + rbits ), n, rbits, np );
+}
+
+} // namespace legacy
+
+} // namespace mockturtle
diff --git a/include/mockturtle/generators/majority.hpp b/include/mockturtle/generators/majority.hpp
new file mode 100644
index 0000000..3aa22c2
--- /dev/null
+++ b/include/mockturtle/generators/majority.hpp
@@ -0,0 +1,136 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file majority.hpp
+  \brief Generate majority-n networks
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <array>
+
+#include "../traits.hpp"
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+template<class Ntk>
+signal<Ntk> fake_majority9( Ntk& ntk, std::array<signal<Ntk>, 9> const& xs )
+{
+  return ntk.create_maj(
+      ntk.create_maj( xs[0], xs[1], xs[2] ),
+      ntk.create_maj( xs[3], xs[4], xs[5] ),
+      ntk.create_maj( xs[6], xs[7], xs[8] ) );
+}
+
+template<class Ntk>
+signal<Ntk> general_associativity( Ntk& ntk, signal<Ntk> const& y, std::vector<signal<Ntk>> const& xs )
+{
+  assert( xs.size() >= 2u );
+
+  return std::accumulate( xs.rbegin() + 1, xs.rend(), xs.back(),
+                          [&]( auto const& f, auto const& x ) { return ntk.create_maj( x, y, f ); } );
+}
+
+} // namespace detail
+
+/*! \brief Implements Majority-5 using 4 MAJ operations.
+ *
+ * All majority operations require no inverters and are leafy.
+ */
+template<class Ntk>
+signal<Ntk> majority5( Ntk& ntk, std::array<signal<Ntk>, 5> const& xs )
+{
+  const auto lhs = ntk.create_maj( xs[0], xs[1], xs[2] );
+  const auto rhs = detail::general_associativity( ntk, xs[3], { xs[0], xs[1], xs[2] } );
+  return ntk.create_maj( lhs, xs[4], rhs );
+}
+
+/*! \brief Implements Majority-7 using 7 MAJ operations.
+ *
+ * All majority operations require no inverters and are leafy.
+ */
+template<class Ntk>
+signal<Ntk> majority7( Ntk& ntk, std::array<signal<Ntk>, 7> const& xs )
+{
+  const auto side = [&]( std::array<signal<Ntk>, 6> const& ws ) {
+    const auto l1 = ntk.create_maj( ws[0], ws[1], ws[2] );
+    return detail::general_associativity( ntk, l1, { ws[3], ws[4], ws[5] } );
+  };
+
+  return ntk.create_maj(
+      side( { xs[1], xs[2], xs[3], xs[4], xs[5], xs[6] } ),
+      xs[0],
+      side( { xs[4], xs[5], xs[6], xs[1], xs[2], xs[3] } ) );
+}
+
+/*! \brief Implements Majority-9 using 13 MAJ operations.
+ *
+ * All majority operations require no inverters.
+ */
+template<class Ntk>
+signal<Ntk> majority9_13( Ntk& ntk, std::array<signal<Ntk>, 9> const& xs )
+{
+  const auto side = [&]( std::array<signal<Ntk>, 9> const& ws ) {
+    const auto l1 = ntk.create_maj( ws[3], ws[4], ws[5] );
+    const auto l2 = detail::general_associativity( ntk, l1, { ws[0], ws[1], ws[2] } );
+    return detail::general_associativity( ntk, l2, { ws[6], ws[7], ws[8] } );
+  };
+
+  return ntk.create_maj(
+      side( xs ),
+      detail::fake_majority9( ntk, xs ),
+      side( { xs[0], xs[1], xs[2], xs[6], xs[7], xs[8], xs[3], xs[4], xs[5] } ) );
+}
+
+/*! \brief Implements Majority-9 using 12 MAJ operations.
+ *
+ * This construction requires one inverter.
+ */
+template<class Ntk>
+signal<Ntk> majority9_12( Ntk& ntk, std::array<signal<Ntk>, 9> const& xs )
+{
+  const auto side = [&]( std::array<signal<Ntk>, 9> const& ws ) {
+    const auto bottom = ntk.create_maj( ntk.create_not( ws[0] ), ws[1], ws[2] );
+    const auto l1 = ntk.create_maj( ws[3], ws[4], ws[5] );
+    const auto l2 = ntk.create_maj( ws[0], l1, bottom );
+    return detail::general_associativity( ntk, l2, { ws[6], ws[7], ws[8] } );
+  };
+
+  return ntk.create_maj(
+      side( xs ),
+      detail::fake_majority9( ntk, xs ),
+      side( { xs[0], xs[1], xs[2], xs[6], xs[7], xs[8], xs[3], xs[4], xs[5] } ) );
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/generators/majority_n.hpp b/include/mockturtle/generators/majority_n.hpp
new file mode 100644
index 0000000..590f781
--- /dev/null
+++ b/include/mockturtle/generators/majority_n.hpp
@@ -0,0 +1,90 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+/*!
+  \file majority_n.hpp
+  \brief Generate majority-n networks using BDD and sorter network based methods
+
+  \author Dewmini Sudara
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include "sorting.hpp"
+
+#include <array>
+#include <vector>
+
+namespace mockturtle
+{
+/**! \brief Generates majority-n network on given input signals using the BDD based method
+ *
+ *  All majority operations are leafy.
+ */
+template<typename Ntk, typename SizeT, SizeT N>
+signal<Ntk> majority_n_bdd( Ntk& ntk, std::array<signal<Ntk>, N> const& xs )
+{
+  const auto logic1 = ntk.get_constant( true );
+  const auto logic0 = ntk.get_constant( false );
+  std::array<std::vector<signal<Ntk>>, N> dp;
+  dp[0].push_back( xs[0] );
+  for ( auto r = 1u; r <= xs.size() / 2; r++ )
+  {
+    dp[r].push_back( ntk.create_maj( logic0, dp[r - 1][0], xs[r] ) );
+    for ( auto c = 1u; c < r; c++ )
+    {
+      dp[r].push_back( ntk.create_maj( dp[r - 1][c - 1], dp[r - 1][c], xs[r] ) );
+    }
+    dp[r].push_back( ntk.create_maj( logic1, dp[r - 1][r - 1], xs[r] ) );
+  }
+  for ( auto r = xs.size() / 2 + 1; r < xs.size(); r++ )
+  {
+    for ( auto c = 0u; c < xs.size() - r; c++ )
+    {
+      dp[r].push_back( ntk.create_maj( dp[r - 1][c], dp[r - 1][c + 1], xs[r] ) );
+    }
+  }
+  return dp[xs.size() - 1][0];
+}
+
+/**! \brief Generates majority-n network on given input signals using bubble sort.
+ *
+ * All majority operations require no inverters and are leafy.
+ */
+template<typename Ntk, typename SizeT, SizeT N>
+signal<Ntk> majority_n_bubble_sort( Ntk& ntk, std::array<signal<Ntk>, N> const& xs )
+{
+  std::vector<signal<Ntk>> sigs( xs.begin(), xs.end() );
+  bubble_sorting_network( static_cast<uint32_t>( sigs.size() ), [&sigs, &ntk]( auto i, auto j ) {
+    signal<Ntk> lhs = ntk.create_and( sigs[i], sigs[j] );
+    signal<Ntk> rhs = ntk.create_or( sigs[i], sigs[j] );
+    sigs[i] = lhs;
+    sigs[j] = rhs;
+  } );
+  return sigs[sigs.size() / 2];
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/generators/modular_arithmetic.hpp b/include/mockturtle/generators/modular_arithmetic.hpp
new file mode 100644
index 0000000..9018a28
--- /dev/null
+++ b/include/mockturtle/generators/modular_arithmetic.hpp
@@ -0,0 +1,796 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file modular_arithmetic.hpp
+  \brief Generate modular arithmetic logic networks
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include <fmt/format.h>
+
+#include "../traits.hpp"
+#include "arithmetic.hpp"
+#include "control.hpp"
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+inline void invert_modulus( std::vector<bool>& m )
+{
+  m.flip();
+
+  for ( auto i = 0u; i < m.size(); ++i )
+  {
+    m[i] = !m[i];
+    if ( m[i] )
+      break;
+  }
+}
+
+inline void increment_inplace( std::vector<bool>& word )
+{
+  auto it = word.begin();
+
+  while ( it != word.end() )
+  {
+    if ( ( *it++ = !*it ) )
+    {
+      return;
+    }
+  }
+}
+
+inline std::vector<bool> increment( std::vector<bool> const& word )
+{
+  auto copy = word;
+  increment_inplace( copy );
+  return copy;
+}
+
+inline void decrement_inplace( std::vector<bool>& word )
+{
+  auto it = word.begin();
+
+  while ( it != word.end() )
+  {
+    if ( !( *it++ = !*it ) )
+    {
+      return;
+    }
+  }
+}
+
+inline std::vector<bool> decrement( std::vector<bool> const& word )
+{
+  auto copy = word;
+  decrement_inplace( copy );
+  return copy;
+}
+
+} /* namespace detail */
+
+/*! \brief Creates modular adder
+ *
+ * Given two input words of the same size *k*, this function creates a circuit
+ * that computes *k* output signals that represent \f$(a + b) \bmod 2^k\f$.
+ * The first input word `a` is overridden and stores the output signals.
+ */
+template<class Ntk>
+inline void modular_adder_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<signal<Ntk>> const& b )
+{
+  auto carry = ntk.get_constant( false );
+  carry_ripple_adder_inplace( ntk, a, b, carry );
+}
+
+/*! \brief Creates modular adder
+ *
+ * Given two input words of the same size *k*, this function creates a circuit
+ * that computes *k* output signals that represent \f$(a + b) \bmod m\f$.
+ * The modulus `m` is passed as a vector of Booleans to support large bitsizes.
+ * The first input word `a` is overridden and stores the output signals.
+ */
+template<class Ntk>
+inline void modular_adder_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<signal<Ntk>> const& b, std::vector<bool> const& m )
+{
+  // bit-size for corrected addition
+  const uint32_t bitsize = static_cast<uint32_t>( m.size() );
+  assert( bitsize <= a.size() );
+
+  // corrected registers
+  std::vector<signal<Ntk>> a_trim( a.begin(), a.begin() + bitsize );
+  std::vector<signal<Ntk>> b_trim( b.begin(), b.begin() + bitsize );
+
+  // 1. Compute (a + b) on bitsize bits
+  auto carry = ntk.get_constant( false );
+  carry_ripple_adder_inplace( ntk, a_trim, b_trim, carry ); /* a_trim <- a + b */
+
+  // store result in sum (and extend it to bitsize + 1 bits)
+  auto sum = a_trim; /* sum <- a + b */
+  sum.emplace_back( ntk.get_constant( false ) );
+
+  // 2. Compute (a + b) - m (m is represented as word) on (bitsize + 1) bits
+  std::vector<signal<Ntk>> word( bitsize + 1, ntk.get_constant( false ) );
+  std::transform( m.begin(), m.end(), word.begin(), [&]( auto b ) { return ntk.get_constant( b ); } );
+  auto carry_inv = ntk.get_constant( true );
+  a_trim.emplace_back( carry );
+  carry_ripple_subtractor_inplace( ntk, a_trim, word, carry_inv ); /* a_trim <- a + b - c */
+
+  // if overflow occurred in step 2, return result from step 2, otherwise, result from step 1.
+  mux_inplace( ntk, carry_inv, a_trim, sum );
+
+  // copy corrected register back into input register
+  std::copy_n( a_trim.begin(), bitsize, a.begin() );
+}
+
+/*! \brief Creates modular adder
+ *
+ * Given two input words of the same size *k*, this function creates a circuit
+ * that computes *k* output signals that represent \f$(a + b) \bmod m\f$.
+ * The first input word `a` is overridden and stores the output signals.
+ */
+template<class Ntk>
+inline void modular_adder_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<signal<Ntk>> const& b, uint64_t m )
+{
+  // simpler case
+  if ( m == ( UINT64_C( 1 ) << a.size() ) )
+  {
+    modular_adder_inplace( ntk, a, b );
+    return;
+  }
+
+  // bit-size for corrected addition
+  const auto bitsize = static_cast<uint32_t>( std::ceil( std::log2( m ) ) );
+  std::vector<bool> mvec( bitsize );
+  for ( auto i = 0u; i < bitsize; ++i )
+  {
+    mvec[i] = static_cast<bool>( ( m >> i ) & 1 );
+  }
+
+  modular_adder_inplace( ntk, a, b, mvec );
+}
+
+template<class Ntk>
+inline std::vector<signal<Ntk>> modular_adder( Ntk& ntk, std::vector<signal<Ntk>> const& a, std::vector<signal<Ntk>> const& b, std::vector<bool> const& m )
+{
+  auto w = a;
+  modular_adder_inplace( ntk, w, b, m );
+  return w;
+}
+
+template<class Ntk>
+inline void modular_adder_hiasat_inplace( Ntk& ntk, std::vector<signal<Ntk>>& x, std::vector<signal<Ntk>> const& y, std::vector<bool> const& m )
+{
+  assert( m.size() <= x.size() );
+  assert( x.size() == y.size() );
+
+  const uint32_t bitsize = static_cast<uint32_t>( m.size() );
+
+  // corrected registers
+  std::vector<signal<Ntk>> x_trim( x.begin(), x.begin() + bitsize );
+  std::vector<signal<Ntk>> y_trim( y.begin(), y.begin() + bitsize );
+
+  // compute Z-vector from m-vector (Z = 2^bitsize - m)
+  auto z = m;
+  detail::invert_modulus( z );
+
+  /* SAC unit */
+  std::vector<signal<Ntk>> A( bitsize ), B( bitsize + 1 ), a( bitsize ), b( bitsize + 1 );
+
+  B[0] = b[0] = ntk.get_constant( false );
+  for ( auto i = 0u; i < bitsize; ++i )
+  {
+    A[i] = ntk.create_xor( x_trim[i], y_trim[i] );
+    B[i + 1] = ntk.create_and( x_trim[i], y_trim[i] );
+    a[i] = z[i] ? ntk.create_xnor( x_trim[i], y_trim[i] ) : A[i];
+    b[i + 1] = z[i] ? ntk.create_or( x_trim[i], y_trim[i] ) : B[i + 1];
+  }
+
+  /* CPG unit */
+  std::vector<signal<Ntk>> G( bitsize ), P( bitsize + 1 ), g( bitsize ), p( bitsize + 1 );
+  for ( auto i = 0u; i < bitsize; ++i )
+  {
+    G[i] = ntk.create_and( A[i], B[i] );
+    P[i] = ntk.create_xor( A[i], B[i] );
+    g[i] = ntk.create_and( a[i], b[i] );
+    p[i] = ntk.create_xor( a[i], b[i] );
+  }
+  P[bitsize] = B[bitsize];
+  p[bitsize] = b[bitsize];
+
+  /* CLA for C_out */
+  std::vector<signal<Ntk>> C( bitsize );
+  C[0] = p[bitsize];
+  for ( auto i = 1u; i < bitsize; ++i )
+  {
+    std::vector<signal<Ntk>> cube;
+    cube.push_back( g[i] );
+    for ( auto j = i + 1u; j < bitsize; ++j )
+    {
+      cube.push_back( p[j] );
+    }
+    C[i] = ntk.create_nary_and( cube );
+  }
+  const auto Cout = ntk.create_nary_or( C );
+  // ntk.create_po( Cout );
+
+  /* MUX store result in p and g */
+  p.pop_back();
+  P.pop_back();
+  mux_inplace( ntk, Cout, g, G );
+  mux_inplace( ntk, Cout, p, P );
+
+  /* CLAS */
+  C[0] = ntk.get_constant( false );
+  for ( auto i = 1u; i < bitsize; ++i )
+  {
+    C[i] = ntk.create_or( g[i - 1], ntk.create_and( p[i - 1], C[i - 1] ) );
+  }
+
+  for ( auto i = 0u; i < bitsize; ++i )
+  {
+    x[i] = ntk.create_xor( p[i], C[i] );
+  }
+}
+
+template<class Ntk>
+inline void modular_adder_hiasat_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<signal<Ntk>> const& b, uint64_t m )
+{
+  // simpler case
+  if ( m == ( UINT64_C( 1 ) << a.size() ) )
+  {
+    modular_adder_inplace( ntk, a, b );
+    return;
+  }
+
+  // bit-size for corrected addition
+  const auto bitsize = static_cast<uint32_t>( std::ceil( std::log2( m ) ) );
+  std::vector<bool> mvec( bitsize );
+  for ( auto i = 0u; i < bitsize; ++i )
+  {
+    mvec[i] = static_cast<bool>( ( m >> i ) & 1 );
+  }
+
+  modular_adder_hiasat_inplace( ntk, a, b, mvec );
+}
+
+/*! \brief Creates modular subtractor
+ *
+ * Given two input words of the same size *k*, this function creates a circuit
+ * that computes *k* output signals that represent \f$(a - b) \bmod 2^k\f$.
+ * The first input word `a` is overridden and stores the output signals.
+ */
+template<class Ntk>
+inline void modular_subtractor_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<signal<Ntk>> const& b )
+{
+  auto carry = ntk.get_constant( true );
+  carry_ripple_subtractor_inplace( ntk, a, b, carry );
+}
+
+/*! \brief Creates modular subtractor
+ *
+ * Given two input words of the same size *k*, this function creates a circuit
+ * that computes *k* output signals that represent \f$(a - b) \bmod m\f$.
+ * The modulus `m` is passed as a vector of Booleans to support large bitsizes.
+ * The first input word `a` is overridden and stores the output signals.
+ */
+template<class Ntk>
+inline void modular_subtractor_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<signal<Ntk>> const& b, std::vector<bool> const& m )
+{
+  // bit-size for corrected addition
+  const uint32_t bitsize = static_cast<uint32_t>( m.size() );
+  assert( bitsize <= a.size() );
+
+  // corrected registers
+  std::vector<signal<Ntk>> a_trim( a.begin(), a.begin() + bitsize );
+  std::vector<signal<Ntk>> b_trim( b.begin(), b.begin() + bitsize );
+
+  // 1. Compute (a - b) on bitsize bits
+  auto carry_inv = ntk.get_constant( true );
+  carry_ripple_subtractor_inplace( ntk, a_trim, b_trim, carry_inv ); /* a_trim <- a - b */
+
+  // store result in sum (and extend it to bitsize + 1 bits)
+  auto sum = a_trim; /* sum <- a - b */
+
+  sum.emplace_back( ntk.get_constant( false ) );
+
+  // 2. Compute (a - b) + m (m is represented as word) on (bitsize + 1) bits
+  std::vector<signal<Ntk>> word( bitsize + 1, ntk.get_constant( false ) );
+  std::transform( m.begin(), m.end(), word.begin(), [&]( auto b ) { return ntk.get_constant( b ); } );
+  auto carry = ntk.get_constant( false );
+  a_trim.emplace_back( ntk.create_not( carry_inv ) );
+  carry_ripple_adder_inplace( ntk, a_trim, word, carry ); /* a_trim <- (a - b) + c */
+
+  // if overflow occurred in step 2, return result from step 2, otherwise, result from step 1.
+  mux_inplace( ntk, carry, a_trim, sum );
+
+  // copy corrected register back into input register
+  std::copy_n( a_trim.begin(), bitsize, a.begin() );
+}
+
+/*! \brief Creates modular subtractor
+ *
+ * Given two input words of the same size *k*, this function creates a circuit
+ * that computes *k* output signals that represent \f$(a - b) \bmod m\f$.
+ * The first input word `a` is overridden and stores the output signals.
+ */
+template<class Ntk>
+inline void modular_subtractor_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<signal<Ntk>> const& b, uint64_t m )
+{
+  // simpler case
+  if ( m == ( UINT64_C( 1 ) << a.size() ) )
+  {
+    modular_subtractor_inplace( ntk, a, b );
+    return;
+  }
+
+  // bit-size for corrected subtraction
+  const auto bitsize = static_cast<uint32_t>( std::ceil( std::log2( m ) ) );
+  std::vector<bool> mvec( bitsize );
+  for ( auto i = 0u; i < bitsize; ++i )
+  {
+    mvec[i] = static_cast<bool>( ( m >> i ) & 1 );
+  }
+
+  modular_subtractor_inplace( ntk, a, b, mvec );
+}
+
+template<class Ntk>
+inline std::vector<signal<Ntk>> modular_subtractor( Ntk& ntk, std::vector<signal<Ntk>> const& a, std::vector<signal<Ntk>> const& b, std::vector<bool> const& m )
+{
+  auto w = a;
+  modular_subtractor_inplace( ntk, w, b, m );
+  return w;
+}
+
+/*! \brief Creates modular doubling (multiplication by 2)
+ *
+ * Given one input word \f$a\f$ of size *k*, this function creates a circuit
+ * that computes *k* output signals that represent \f$(2 * a) \bmod m\f$.
+ * The modulus `m` is passed as a vector of Booleans to support large bitsizes.
+ * The input word `a` is overridden and stores the output signals.
+ */
+template<class Ntk>
+inline void modular_doubling_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<bool> const& m )
+{
+  assert( a.size() >= m.size() );
+  const auto bitsize = m.size();
+  std::vector<signal<Ntk>> a_trim( a.begin(), a.begin() + bitsize );
+
+  std::vector<signal<Ntk>> shifted( bitsize + 1u, ntk.get_constant( false ) );
+  std::copy( a_trim.begin(), a_trim.end(), shifted.begin() + 1u );
+  std::copy_n( shifted.begin(), bitsize, a_trim.begin() );
+
+  std::vector<signal<Ntk>> word( bitsize + 1, ntk.get_constant( false ) );
+  std::transform( m.begin(), m.end(), word.begin(), [&]( auto b ) { return ntk.get_constant( b ); } );
+
+  auto carry_inv = ntk.get_constant( true );
+  carry_ripple_subtractor_inplace( ntk, shifted, word, carry_inv );
+
+  mux_inplace( ntk, ntk.create_not( carry_inv ), a_trim, std::vector<signal<Ntk>>( shifted.begin(), shifted.begin() + bitsize ) );
+  std::copy( a_trim.begin(), a_trim.end(), a.begin() );
+}
+
+/*! \brief Creates modular doubling (multiplication by 2)
+ *
+ * Given one input word \f$a\f$ of size *k*, this function creates a circuit
+ * that computes *k* output signals that represent \f$(2 * a) \bmod m\f$.
+ * The input word `a` is overridden and stores the output signals.
+ */
+template<class Ntk>
+inline void modular_doubling_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, uint64_t m )
+{
+  const auto bitsize = static_cast<uint32_t>( std::ceil( std::log2( m ) ) );
+  std::vector<bool> mvec( bitsize );
+  for ( auto i = 0u; i < bitsize; ++i )
+  {
+    mvec[i] = static_cast<bool>( ( m >> i ) & 1 );
+  }
+
+  modular_doubling_inplace( ntk, a, mvec );
+}
+
+/*! \brief Creates modular halving (corrected division by 2)
+ *
+ * Given one input word \f$a\f$ of size *k*, this function creates a circuit
+ * that computes *k* output signals that represent \f$(a / 2) \bmod m\f$.  The
+ * modulus must be odd, and the function is evaluated to \f$a / 2\f$, if `a` is
+ * even and to \f$(a + m) / 2\f$, if `a` is odd.
+ * The modulus `m` is passed as a vector of Booleans to support large bitsizes.
+ * The input word `a` is overridden and stores the output signals.
+ */
+template<class Ntk>
+inline void modular_halving_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<bool> const& m )
+{
+  assert( a.size() >= m.size() );
+  assert( m.size() > 0u );
+  assert( m[0] );
+  const auto bitsize = m.size();
+  std::vector<signal<Ntk>> a_trim( a.begin(), a.begin() + bitsize );
+
+  std::vector<signal<Ntk>> extended( bitsize + 1u, ntk.get_constant( false ) ), a_extended( bitsize + 1u, ntk.get_constant( false ) );
+  std::copy( a_trim.begin(), a_trim.end(), extended.begin() );
+  std::copy( a_trim.begin(), a_trim.end(), a_extended.begin() );
+
+  std::vector<signal<Ntk>> word( bitsize + 1, ntk.get_constant( false ) );
+  std::transform( m.begin(), m.end(), word.begin(), [&]( auto b ) { return ntk.get_constant( b ); } );
+
+  auto carry = ntk.get_constant( false );
+  carry_ripple_adder_inplace( ntk, extended, word, carry );
+
+  mux_inplace( ntk, a_trim[0], extended, a_extended );
+
+  std::copy_n( extended.begin() + 1, bitsize, a.begin() );
+}
+
+/*! \brief Creates modular halving (corrected division by 2)
+ *
+ * Given one input word \f$a\f$ of size *k*, this function creates a circuit
+ * that computes *k* output signals that represent \f$(a / 2) \bmod m\f$.  The
+ * modulus must be odd, and the function is evaluated to \f$a / 2\f$, if `a` is
+ * even and to \f$(a + m) / 2\f$, if `a` is odd.
+ * The input word `a` is overridden and stores the output signals.
+ */
+template<class Ntk>
+inline void modular_halving_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, uint64_t m )
+{
+  const auto bitsize = static_cast<uint32_t>( std::ceil( std::log2( m ) ) );
+  std::vector<bool> mvec( bitsize );
+  for ( auto i = 0u; i < bitsize; ++i )
+  {
+    mvec[i] = static_cast<bool>( ( m >> i ) & 1 );
+  }
+
+  modular_halving_inplace( ntk, a, mvec );
+}
+
+/*! \brief Creates modular multiplication
+ *
+ * Given two inputs words of the same size *k*, this function creates a circuit
+ * that computes *k* output signals that represent \f$(ab) \bmod c\f$.
+ * The modulus `m` is passed as a vector of Booleans to support large bitsizes.
+ * The first input word `a` is overridden and stores the output signals.
+ */
+template<class Ntk>
+inline void modular_multiplication_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<signal<Ntk>> const& b, std::vector<bool> const& m )
+{
+  assert( a.size() >= m.size() );
+  assert( a.size() == b.size() );
+
+  const auto bitsize = m.size();
+  std::vector<signal<Ntk>> a_trim( a.begin(), a.begin() + bitsize );
+  std::vector<signal<Ntk>> b_trim( b.begin(), b.begin() + bitsize );
+
+  std::vector<signal<Ntk>> accu( bitsize );
+  auto itA = a_trim.rbegin();
+  std::transform( b_trim.begin(), b_trim.end(), accu.begin(), [&]( auto const& f ) { return ntk.create_and( *itA, f ); } );
+
+  while ( ++itA != a_trim.rend() )
+  {
+    modular_doubling_inplace( ntk, accu, m );
+    std::vector<signal<Ntk>> summand( bitsize );
+    std::transform( b_trim.begin(), b_trim.end(), summand.begin(), [&]( auto const& f ) { return ntk.create_and( *itA, f ); } );
+    modular_adder_inplace( ntk, accu, summand, m );
+  }
+
+  std::copy( accu.begin(), accu.end(), a.begin() );
+}
+
+/*! \brief Creates modular multiplier
+ *
+ * Given two inputs words of the same size *k*, this function creates a circuit
+ * that computes *k* output signals that represent \f$(ab) \bmod c\f$.
+ * The first input word `a` is overridden and stores the output signals.
+ */
+template<class Ntk>
+inline void modular_multiplication_inplace( Ntk& ntk, std::vector<signal<Ntk>>& a, std::vector<signal<Ntk>> const& b, uint64_t m )
+{
+  const auto bitsize = static_cast<uint32_t>( std::ceil( std::log2( m ) ) );
+  std::vector<bool> mvec( bitsize );
+  for ( auto i = 0u; i < bitsize; ++i )
+  {
+    mvec[i] = static_cast<bool>( ( m >> i ) & 1 );
+  }
+
+  modular_multiplication_inplace( ntk, a, b, mvec );
+}
+
+template<class Ntk>
+inline std::vector<signal<Ntk>> modular_multiplication( Ntk& ntk, std::vector<signal<Ntk>> const& a, std::vector<signal<Ntk>> const& b, std::vector<bool> const& m )
+{
+  auto w = a;
+  modular_multiplication_inplace( ntk, w, b, m );
+  return w;
+}
+
+template<typename Ntk>
+inline std::vector<signal<Ntk>> modular_constant_multiplier_one_bits( Ntk& ntk, std::vector<signal<Ntk>> const& a, std::vector<bool> const& constant )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+
+  std::vector<signal<Ntk>> sum( a.size(), ntk.get_constant( false ) );
+
+  auto it = std::find( constant.begin(), constant.end(), true );
+  if ( it != constant.end() )
+  {
+    auto shift = std::distance( constant.begin(), it );
+    std::copy_n( a.begin(), a.size() - shift, sum.begin() + shift );
+    it = std::find( it + 1, constant.end(), true );
+
+    while ( it != constant.end() )
+    {
+      shift = std::distance( constant.begin(), it );
+      std::vector<signal<Ntk>> summand( a.size(), ntk.get_constant( false ) );
+      std::copy_n( a.begin(), a.size() - shift, summand.begin() + shift );
+      auto carry = ntk.get_constant( false );
+      carry_ripple_adder_inplace( ntk, sum, summand, carry );
+      it = std::find( it + 1, constant.end(), true );
+    }
+  }
+
+  return sum;
+}
+
+template<class Ntk>
+inline std::vector<signal<Ntk>> modular_constant_multiplier_csd( Ntk& ntk, std::vector<signal<Ntk>> const& a, std::vector<bool> const& constant )
+{
+  // constant == 0
+  if ( std::find( constant.begin(), constant.end(), true ) == constant.end() )
+  {
+    return std::vector<signal<Ntk>>( a.size(), ntk.get_constant( false ) );
+  }
+  // constant == 1
+  else if ( constant.front() && std::find( constant.begin() + 1, constant.end(), true ) == constant.end() )
+  {
+    return a;
+  }
+  // constant % 2 == 0
+  else if ( !constant.front() )
+  {
+    // constant / 2
+    std::vector<bool> new_constant( a.size(), false );
+    std::copy( constant.begin() + 1, constant.end(), new_constant.begin() );
+    auto res = modular_constant_multiplier( ntk, a, new_constant );
+    res.insert( res.begin(), ntk.get_constant( false ) );
+    res.pop_back();
+    return res;
+  }
+  // constant % 4 == 1u
+  else if ( !constant[1] )
+  {
+    auto res = modular_constant_multiplier( ntk, a, detail::decrement( constant ) );
+    modular_adder_inplace( ntk, res, a );
+    return res;
+  }
+  else /* ( constant % 4 == 3u ) */
+  {
+    auto res = modular_constant_multiplier( ntk, a, detail::increment( constant ) );
+    modular_subtractor_inplace( ntk, res, a );
+    return res;
+  }
+}
+
+/*! \brief Creates modular constant-multiplier
+ *
+ * Given an input word of size *k* and a constant with the same bit-width,
+ * this function creates a circuit that computes \f$(a\cdot\mathrm{constant}) \bmod 2^k\f$.
+ */
+template<class Ntk>
+inline std::vector<signal<Ntk>> modular_constant_multiplier( Ntk& ntk, std::vector<signal<Ntk>> const& a, std::vector<bool> const& constant )
+{
+  return modular_constant_multiplier_csd( ntk, a, constant );
+}
+
+/*! \brief Creates vector of Booleans from hex string
+ *
+ * This function can be used to create moduli for very large numbers that cannot
+ * be represented using any of the integer built-in data types.  If the vector
+ * `res` is too small for the value `hex` most-significant digits will be
+ * ignored.
+ */
+inline void bool_vector_from_hex( std::vector<bool>& res, std::string_view hex, bool shrink_to_fit = true )
+{
+  auto itR = res.begin();
+  auto itS = hex.rbegin();
+
+  while ( itR != res.end() && itS != hex.rend() )
+  {
+    uint32_t number{ 0 };
+    if ( *itS >= '0' && *itS <= '9' )
+    {
+      number = *itS - '0';
+    }
+    else if ( *itS >= 'a' && *itS <= 'f' )
+    {
+      number = *itS - 'a' + 10;
+    }
+    else if ( *itS >= 'A' && *itS <= 'F' )
+    {
+      number = *itS - 'A' + 10;
+    }
+    else
+    {
+      assert( false && "invalid hex number" );
+    }
+
+    for ( auto i = 0u; i < 4u; ++i )
+    {
+      *itR++ = ( number >> i ) & 1;
+      if ( itR == res.end() )
+      {
+        break;
+      }
+    }
+
+    ++itS;
+  }
+
+  if ( shrink_to_fit )
+  {
+    auto find_last = []( std::vector<bool>::const_iterator itFirst,
+                         std::vector<bool>::const_iterator itLast,
+                         bool value ) -> std::vector<bool>::const_iterator {
+      auto cur = itLast;
+      while ( itFirst != itLast )
+      {
+        if ( *itFirst == value )
+        {
+          cur = itFirst;
+        }
+        ++itFirst;
+      }
+      return cur;
+    };
+
+    const auto itLast = find_last( res.begin(), res.end(), true );
+    if ( itLast == res.end() )
+    {
+      res.clear();
+    }
+    else
+    {
+      res.erase( find_last( res.begin(), res.end(), true ) + 1u, res.end() );
+    }
+  }
+  else
+  {
+    /* in case the hex string was short, fill remaining values with false */
+    std::fill( itR, res.end(), false );
+  }
+}
+
+inline void bool_vector_from_dec( std::vector<bool>& res, uint64_t value )
+{
+  auto it = res.begin();
+  while ( value && it != res.end() )
+  {
+    *it++ = value % 2;
+    value >>= 1;
+  }
+}
+
+inline uint64_t bool_vector_to_long( std::vector<bool> const& vec )
+{
+  return std::accumulate( vec.begin(), vec.end(), std::make_pair( 0u, 0ul ),
+                          []( auto accu, auto bit ) {
+                            return std::make_pair( accu.first + 1u, accu.second + ( bit ? 1ul << accu.first : 0ul ) );
+                          } )
+      .second;
+}
+
+/*! \brief Creates a multiplier assuming Montgomery numbers as inputs.
+ *
+ * This modular multiplication assumes the two inputs *a* and *b* to be
+ * Montgomery numbers representing \f$a \cdot 2^k \bmod N\f$, where \f$N\f$ is
+ * the modulus as bit-string, and \f$k\f$ is the bit-width of *a* and *b*.  It
+ * returns a signal of length *b*.  The last paramaeter *NN* must be computed
+ * such that \f$R \cdot 2^k = N \cdot NN\f$ using the extended GCD.
+ */
+template<class Ntk>
+inline std::vector<signal<Ntk>> montgomery_multiplication( Ntk& ntk, std::vector<signal<Ntk>> const& a, std::vector<signal<Ntk>> const& b, std::vector<bool> const& N, std::vector<bool> const& NN )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  assert( a.size() == b.size() );
+
+  const auto logR = a.size();
+
+  std::vector<signal<Ntk>> Nbits( logR, ntk.get_constant( false ) );
+  std::transform( N.begin(), N.end(), Nbits.begin(), [&]( auto b ) { return ntk.get_constant( b ); } );
+
+  /* multiply a and b and truncate to least-significant logR bits */
+  auto mult1 = carry_ripple_multiplier( ntk, a, b );
+  std::vector<signal<Ntk>> mult1_truncated( mult1.begin(), mult1.begin() + logR );
+
+  /* compute (((a * b) % R) * NN) % R */
+  auto mult2 = modular_constant_multiplier( ntk, mult1_truncated, NN );
+
+  mult2.resize( 2 * logR, ntk.get_constant( false ) );
+  auto Ncopy = N;
+  Ncopy.resize( 2 * logR, false );
+  auto summand = modular_constant_multiplier( ntk, mult2, Ncopy );
+
+  assert( mult1.size() == 2 * logR );
+  assert( summand.size() == 2 * logR );
+
+  auto carry = ntk.get_constant( false );
+  carry_ripple_adder_inplace( ntk, mult1, summand, carry );
+  mult1.erase( mult1.begin(), mult1.begin() + logR );
+
+  auto tcopy = mult1;
+  carry = ntk.get_constant( true );
+  carry_ripple_subtractor_inplace( ntk, tcopy, Nbits, carry );
+  mux_inplace( ntk, carry, tcopy, mult1 );
+
+  return tcopy;
+}
+
+/*! \brief Creates a multiplier assuming Montgomery numbers as inputs.
+ *
+ * This modular multiplication assumes the two inputs *a* and *b* to be
+ * Montgomery numbers representing \f$a \cdot 2^k \bmod N\f$, where \f$N\f$ is
+ * the modulus, and \f$k\f$ is the bit-width of *a* and *b*.  It returns a
+ * signal of length *b*.
+ */
+template<class Ntk>
+inline std::vector<signal<Ntk>> montgomery_multiplication( Ntk& ntk, std::vector<signal<Ntk>> const& a, std::vector<signal<Ntk>> const& b, uint64_t N )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+
+  const auto logR = a.size();
+  const auto R = 1 << logR;
+
+  // egcd
+  int64_t s = 0, old_s = 1, r = R, old_r = N;
+  while ( r )
+  {
+    const auto q = old_r / r;
+    std::tie( old_r, r ) = std::pair{ r, old_r - q * r };
+    std::tie( old_s, s ) = std::pair{ s, old_s - q * s };
+  }
+  const auto NN = std::abs( old_s );
+
+  std::vector<bool> Nvec( logR ), NNvec( logR );
+  for ( auto i = 0u; i < logR; ++i )
+  {
+    Nvec[i] = static_cast<bool>( ( N >> i ) & 1 );
+    NNvec[i] = static_cast<bool>( ( NN >> i ) & 1 );
+  }
+
+  // std::cout << fmt::format( "[i] R = {}, NN = {}, N = {}\n", R, NN, N );
+
+  return montgomery_multiplication( ntk, a, b, Nvec, NNvec );
+}
+
+} // namespace mockturtle
diff --git a/include/mockturtle/generators/random_network.hpp b/include/mockturtle/generators/random_network.hpp
new file mode 100644
index 0000000..a0c8ddf
--- /dev/null
+++ b/include/mockturtle/generators/random_network.hpp
@@ -0,0 +1,672 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file random_network.hpp
+  \brief Generate random logic networks
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../networks/aig.hpp"
+#include "../networks/mig.hpp"
+#include "../networks/xag.hpp"
+
+#include <algorithm>
+#include <percy/percy.hpp>
+#include <random>
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for random_network_generator.
+ *
+ * When this parameter object is used, random_network_generator
+ * generates networks according to the specified number of PIs
+ * and number of gates. After generating primary inputs and gates,
+ * all nodes with no fanout become primary outputs. After generating
+ * `num_networks_per_configuration` networks (i.e. `generate` being
+ * called this number of times), the configuration (numbers of PIs
+ * and gates) will be incremented by `num_pis_increment` and
+ * `num_gates_increment`, respectively.
+ */
+struct random_network_generator_params_size
+{
+  /*! \brief Seed of the random generator. */
+  uint64_t seed{ 0xcafeaffe };
+
+  /*! \brief Number of networks of each configuration to generate
+   * before increasing size. */
+  uint32_t num_networks_per_configuration{ 100u };
+
+  /*! \brief Number of PIs to start with. */
+  uint32_t num_pis{ 4u };
+
+  /*! \brief Number of gates to start with. */
+  uint32_t num_gates{ 10u };
+
+  /*! \brief Number of PIs to increment at each step. */
+  uint32_t num_pis_increment{ 0u };
+
+  /*! \brief Number of gates to increment at each step. */
+  uint32_t num_gates_increment{ 0u };
+}; /* random_network_generator_params_size */
+
+/*! \brief Parameters for random_network_generator.
+ *
+ * When this parameter object is used, random_network_generator
+ * first enumerates all non-isomorphic connected partial DAGs of
+ * `num_gates` vertices, randomly shuffles them, and then generates
+ * `num_networks_per_configuration` random networks of each topology.
+ * It is guaranteed that all possible topologies are generated for
+ * the same number of times, provided that `generate` is called for
+ * enough times. After all topologies have been generated, `num_gates`
+ * is increased by 1 and the above steps are repeated.
+ *
+ * This method currently only supports generating 2-regular (i.e.,
+ * each gate has two fanins), single-output DAGs.
+ *
+ * Guideline on how many iterations are needed to visit all topologies:
+ * - `num_gates` = 2: 1 topology
+ * - `num_gates` = 3: 3 topologies
+ * - `num_gates` = 4: 10 topologies
+ * - `num_gates` = 5: 49 topologies
+ * - `num_gates` = 6: 302 topologies
+ * - `num_gates` = 7: 2312 topologies
+ * - `num_gates` = 8: 21218 topologies
+ * - `num_gates` = 9: 228249 topologies
+ *
+ * For example, starting from `num_gates` = 3 and using
+ * `num_networks_per_configuration` = 100, to generate networks
+ * of all topologies with no more than 5 vertices, `generate`
+ * should be called (3 + 10 + 49) * 100 = 6200 times.
+ *
+ * For each topology, a random network is concretized from the partial
+ * DAG by randomly choosing a (#PIs/#inputs of DAG) ratio and allocating
+ * the corresponding number of PIs, randomly choosing a PI to be connected
+ * to each input of the partial DAG, and randomly deciding if each edge
+ * should be complemented.
+ */
+struct random_network_generator_params_topology
+{
+  /*! \brief Seed of the random generator. */
+  uint64_t seed{ 0xcafeaffe };
+
+  /*! \brief Number of networks to generate for each topology. */
+  uint32_t num_networks_per_configuration{ 100u };
+
+  /*! \brief Number of gates to start with. */
+  uint32_t num_gates{ 3u };
+
+  /*! \brief Minimum ratio of (#PIs/#inputs of DAG).
+   * Lower ratio makes more reconvergences. */
+  float min_PI_ratio{ 0.5 };
+
+  /*! \brief Maximum ratio of (#PIs/#inputs of DAG).
+   * Higher ratio makes it more likely to sample a full tree. */
+  float max_PI_ratio{ 1.0 };
+}; /* random_network_generator_params_topology */
+
+/*! \brief Parameters for random_network_generator.
+ *
+ * When this parameter object is used, random_network_generator
+ * first enumerates all non-isomorphic connected partial DAGs with
+ * numbers of vertices between `min_num_gates_component` and
+ * `max_num_gates_component`. Random networks are generated by
+ * randomly generating `num_components` DAGs of randomly-sampled
+ * topologies (repeated topologies are allowed). The first topology
+ * is concretized by connecting inputs to randomly-chosen PIs, and
+ * the remaining ones are concretized by connecting inputs to PIs
+ * or nodes in the previous components.
+ *
+ * After generating `num_networks_per_configuration` networks,
+ * `num_components` is increased by `num_components_increment`
+ * and `num_pis` is increased by `num_pis_increment`.
+ */
+struct random_network_generator_params_composed
+{
+  /*! \brief Seed of the random generator. */
+  uint64_t seed{ 0xcafeaffe };
+
+  /*! \brief Number of networks to generate for each topology. */
+  uint32_t num_networks_per_configuration{ 1000u };
+
+  /*! \brief Minimum number of gates of the components. */
+  uint32_t min_num_gates_component{ 3u };
+
+  /*! \brief Maximum number of gates of the components. */
+  uint32_t max_num_gates_component{ 5u };
+
+  /*! \brief Number of components to start with. */
+  uint32_t num_components{ 2u };
+
+  /*! \brief Number of PIs to start with. */
+  uint32_t num_pis{ 4u };
+
+  /*! \brief Number of components to increment at each step. */
+  uint32_t num_components_increment{ 1u };
+
+  /*! \brief Number of PIs to increment at each step. */
+  uint32_t num_pis_increment{ 2u };
+}; /* random_network_generator_params_composed */
+
+namespace detail
+{
+
+template<typename Ntk>
+struct create_gate_rule
+{
+  using signal = typename Ntk::signal;
+
+  std::function<signal( Ntk&, std::vector<signal> const& )> func;
+  uint32_t num_args;
+};
+
+} /* namespace detail */
+
+/*! \brief Generates random logic networks
+ *
+ * Generate random logic networks with certain parameters.
+ *
+ * The constructor takes a vector of construction rules, which are
+ * used in the algorithm to build the logic network. The constructor
+ * also takes a parameter object, which can be of various types and
+ * influences the way networks are generated.
+ *
+ * The function `generate` returns a random network and can be called
+ * repeatedly, each time generating a different network.
+ *
+ */
+template<typename Ntk, typename Params = random_network_generator_params_size>
+class random_network_generator
+{
+};
+
+template<typename Ntk>
+class random_network_generator<Ntk, random_network_generator_params_size>
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  using rand_engine_t = std::mt19937;
+  using rules_t = std::vector<typename detail::create_gate_rule<Ntk>>;
+  using params_t = random_network_generator_params_size;
+
+private: /* common data members */
+  rules_t const _gens;
+  params_t const _ps;
+  rand_engine_t _rng;
+
+public:
+  explicit random_network_generator( rules_t const& gens, params_t ps = {} )
+      : _gens( gens ), _ps( ps ), _rng( static_cast<rand_engine_t::result_type>( ps.seed ) ),
+        _counter( 0u ), _num_pis( ps.num_pis ), _num_gates( ps.num_gates )
+  {
+  }
+
+  Ntk generate()
+  {
+    assert( _num_pis > 0 );
+    assert( _num_gates > 0 );
+
+    std::vector<signal> fs;
+    Ntk ntk;
+
+    /* generate constant */
+    fs.emplace_back( ntk.get_constant( false ) );
+
+    /* generate pis */
+    for ( auto i = 0u; i < _num_pis; ++i )
+    {
+      fs.emplace_back( ntk.create_pi() );
+    }
+
+    /* generate gates */
+    std::uniform_int_distribution<int> rule_dist( 0, static_cast<int>( _gens.size() - 1u ) );
+
+    auto gate_counter = ntk.num_gates();
+    while ( gate_counter < _num_gates )
+    {
+      auto const r = _gens.at( rule_dist( _rng ) );
+
+      std::uniform_int_distribution<int> dist( 0, static_cast<int>( fs.size() - 1 ) );
+      std::vector<signal> args;
+      for ( auto i = 0u; i < r.num_args; ++i )
+      {
+        auto const a_compl = dist( _rng ) & 1;
+        auto const a = fs.at( dist( _rng ) );
+        args.emplace_back( a_compl ? !a : a );
+      }
+
+      auto const g = r.func( ntk, args );
+      if ( ntk.num_gates() > gate_counter )
+      {
+        fs.emplace_back( g );
+        ++gate_counter;
+      }
+
+      assert( ntk.num_gates() == gate_counter );
+    }
+
+    /* generate pos */
+    ntk.foreach_node( [&]( auto const& n ) {
+      if ( ntk.fanout_size( n ) == 0u )
+      {
+        ntk.create_po( ntk.make_signal( n ) );
+      }
+    } );
+
+    assert( ntk.num_pis() == _num_pis );
+    assert( ntk.num_gates() == _num_gates );
+
+    if ( ++_counter >= _ps.num_networks_per_configuration )
+    {
+      _counter = 0;
+      _num_gates += _ps.num_gates_increment;
+      _num_pis += _ps.num_pis_increment;
+    }
+
+    return ntk;
+  }
+
+private:
+  uint32_t _counter;
+  uint32_t _num_pis;
+  uint32_t _num_gates;
+}; /* random_network_generator<Ntk, random_network_generator_params_size> */
+
+#ifdef ENABLE_NAUTY
+template<typename Ntk>
+class random_network_generator<Ntk, random_network_generator_params_topology>
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  using rand_engine_t = std::mt19937;
+  using rules_t = std::vector<typename detail::create_gate_rule<Ntk>>;
+  using params_t = random_network_generator_params_topology;
+
+private: /* common data members */
+  rules_t const _gens;
+  params_t const _ps;
+  rand_engine_t _rng;
+
+public:
+  explicit random_network_generator( rules_t const& gens, params_t ps = {} )
+      : _gens( gens ), _ps( ps ), _rng( static_cast<rand_engine_t::result_type>( ps.seed ) ),
+        _counter( 0u ), _num_gates( ps.num_gates ), _ith_dag( 0u ),
+        _rule_dist( 0, _gens.size() - 1u )
+  {
+  }
+
+  Ntk generate()
+  {
+    if ( _counter == 0 )
+    {
+      if ( _ith_dag == 0 )
+      {
+        prepare_partial_dags();
+      }
+      auto num_inputs = _dags.at( _ith_dag ).nr_pi_fanins();
+      uint32_t min_num_pis = std::ceil( _ps.min_PI_ratio * num_inputs );
+      uint32_t max_num_pis = std::ceil( _ps.max_PI_ratio * num_inputs );
+      _num_pis_dist = std::uniform_int_distribution<uint32_t>( min_num_pis, max_num_pis );
+    }
+
+    percy::partial_dag const& pd = _dags.at( _ith_dag );
+    uint32_t num_pis = _num_pis_dist( _rng );
+    std::uniform_int_distribution<uint32_t> pis_dist( 1u, num_pis );
+
+    std::vector<signal> fs;
+    Ntk ntk;
+
+    /* generate constant */
+    fs.emplace_back( ntk.get_constant( false ) );
+
+    /* generate pis */
+    for ( auto i = 0u; i < num_pis; ++i )
+    {
+      fs.emplace_back( ntk.create_pi() );
+    }
+
+    /* generate gates */
+    pd.foreach_vertex( [&]( auto const& v, auto i ) {
+      uint32_t size_before = ntk.num_gates();
+      signal g;
+
+      do
+      {
+        auto const r = _gens.at( _rule_dist( _rng ) );
+        std::vector<signal> args;
+
+        for ( auto fi : v )
+        {
+          bool const inv = _rng() & 1;
+          if ( fi == percy::FANIN_PI )
+          {
+            auto const& a = fs.at( pis_dist( _rng ) );
+            args.emplace_back( inv ? !a : a );
+          }
+          else
+          {
+            assert( fi >= 1 && num_pis + fi < fs.size() );
+            auto const& a = fs.at( num_pis + fi );
+            args.emplace_back( inv ? !a : a );
+          }
+        }
+
+        g = r.func( ntk, args );
+      } while ( ntk.num_gates() == size_before );
+
+      fs.emplace_back( g );
+    } );
+
+    /* generate pos */
+    ntk.foreach_gate( [&]( auto const& n ) {
+      if ( ntk.fanout_size( n ) == 0u )
+      {
+        ntk.create_po( ntk.make_signal( n ) );
+      }
+    } );
+
+    if ( ++_counter >= _ps.num_networks_per_configuration )
+    {
+      _counter = 0;
+      if ( ++_ith_dag >= _dags.size() )
+      {
+        _ith_dag = 0;
+        ++_num_gates;
+      }
+    }
+
+    return ntk;
+  }
+
+private:
+  void prepare_partial_dags()
+  {
+    using namespace percy;
+
+    _dags.clear();
+    partial_dag g;
+    partial_dag_generator gen( _num_gates );
+    std::set<std::vector<graph>> can_reprs;
+    pd_iso_checker checker( _num_gates );
+
+    gen.set_callback( [&]( partial_dag_generator* gen ) {
+      for ( int i = 0; i < gen->nr_vertices(); i++ )
+      {
+        g.set_vertex( i, gen->_js[i], gen->_ks[i] );
+      }
+      const auto can_repr = checker.crepr( g );
+      const auto res = can_reprs.insert( can_repr );
+      if ( res.second )
+        _dags.push_back( g );
+    } );
+    gen.gen_type( partial_gen_type::GEN_COLEX );
+    g.reset( 2, _num_gates );
+    gen.count_dags();
+
+    std::shuffle( _dags.begin(), _dags.end(), _rng );
+  }
+
+private:
+  uint32_t _counter;
+  uint32_t _num_gates;
+  std::vector<percy::partial_dag> _dags;
+  uint32_t _ith_dag;
+  std::uniform_int_distribution<uint32_t> _num_pis_dist, _rule_dist;
+}; /* random_network_generator<Ntk, random_network_generator_params_topology> */
+
+template<typename Ntk>
+class random_network_generator<Ntk, random_network_generator_params_composed>
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  using rand_engine_t = std::mt19937;
+  using rules_t = std::vector<typename detail::create_gate_rule<Ntk>>;
+  using params_t = random_network_generator_params_composed;
+
+private: /* common data members */
+  rules_t const _gens;
+  params_t const _ps;
+  rand_engine_t _rng;
+
+public:
+  explicit random_network_generator( rules_t const& gens, params_t ps = {} )
+      : _gens( gens ), _ps( ps ), _rng( static_cast<rand_engine_t::result_type>( ps.seed ) ),
+        _counter( 0u ), _num_components( ps.num_components ), _num_pis( ps.num_pis ),
+        _rule_dist( 0, _gens.size() - 1u )
+  {
+    prepare_partial_dags();
+    _dag_dist = std::uniform_int_distribution<uint32_t>( 0, _dags.size() - 1u );
+  }
+
+  Ntk generate()
+  {
+    std::vector<signal> fs;
+    Ntk ntk;
+
+    /* generate constant */
+    fs.emplace_back( ntk.get_constant( false ) );
+
+    /* generate pis */
+    for ( auto i = 0u; i < _num_pis; ++i )
+    {
+      fs.emplace_back( ntk.create_pi() );
+    }
+
+    /* generate gates */
+    for ( auto i = 0u; i < _num_components; ++i )
+    {
+      concretize( ntk, _dags.at( _dag_dist( _rng ) ), fs );
+      // concretize( ntk, _dags.at( 3 ), fs ); // [3] in 4-gate topologies: diamond
+    }
+
+    /* generate pos */
+    ntk.foreach_gate( [&]( auto const& n ) {
+      if ( ntk.fanout_size( n ) == 0u )
+      {
+        ntk.create_po( ntk.make_signal( n ) );
+      }
+    } );
+
+    if ( ++_counter >= _ps.num_networks_per_configuration )
+    {
+      _counter = 0;
+      _num_components += _ps.num_components_increment;
+      _num_pis += _ps.num_pis_increment;
+    }
+
+    return ntk;
+  }
+
+private:
+  void concretize( Ntk& ntk, percy::partial_dag& pd, std::vector<signal>& fs )
+  {
+    uint32_t num_existing = ntk.size() - 1u;
+    std::uniform_int_distribution<uint32_t> dist( 1u, num_existing );
+    // std::uniform_int_distribution<uint32_t> dist( 1u, _num_pis );
+
+    pd.foreach_vertex( [&]( auto const& v, auto i ) {
+      uint32_t size_before = ntk.num_gates();
+      signal g;
+
+      do
+      {
+        auto const r = _gens.at( _rule_dist( _rng ) );
+        std::vector<signal> args;
+
+        for ( auto fi : v )
+        {
+          bool const inv = _rng() & 1;
+          if ( fi == percy::FANIN_PI )
+          {
+            auto const& a = fs.at( dist( _rng ) );
+            args.emplace_back( inv ? !a : a );
+          }
+          else
+          {
+            assert( fi >= 1 && num_existing + fi < fs.size() );
+            auto const& a = fs.at( num_existing + fi );
+            args.emplace_back( inv ? !a : a );
+          }
+        }
+
+        g = r.func( ntk, args );
+      } while ( ntk.num_gates() == size_before );
+
+      fs.emplace_back( g );
+      assert( ntk.size() == fs.size() );
+    } );
+  }
+
+  void prepare_partial_dags()
+  {
+    for ( auto num = _ps.min_num_gates_component; num <= _ps.max_num_gates_component; ++num )
+    {
+      prepare_partial_dags( num );
+    }
+  }
+
+  void prepare_partial_dags( uint32_t num_gates )
+  {
+    using namespace percy;
+
+    partial_dag g;
+    partial_dag_generator gen( num_gates );
+    std::set<std::vector<graph>> can_reprs;
+    pd_iso_checker checker( num_gates );
+
+    gen.set_callback( [&]( partial_dag_generator* gen ) {
+      for ( int i = 0; i < gen->nr_vertices(); i++ )
+      {
+        g.set_vertex( i, gen->_js[i], gen->_ks[i] );
+      }
+      const auto can_repr = checker.crepr( g );
+      const auto res = can_reprs.insert( can_repr );
+      if ( res.second )
+        _dags.push_back( g );
+    } );
+    gen.gen_type( partial_gen_type::GEN_COLEX );
+    g.reset( 2, num_gates );
+    gen.count_dags();
+  }
+
+private:
+  uint32_t _counter;
+  uint32_t _num_components, _num_pis;
+  std::vector<percy::partial_dag> _dags;
+  std::uniform_int_distribution<uint32_t> _rule_dist, _dag_dist;
+}; /* random_network_generator<Ntk, random_network_generator_params_composed> */
+#endif
+
+/*! \brief Generates a random AIG network */
+template<typename GenParams = random_network_generator_params_size>
+auto random_aig_generator( GenParams ps = {} )
+{
+  using gen_t = random_network_generator<aig_network, GenParams>;
+  using rule_t = typename detail::create_gate_rule<aig_network>;
+
+  std::vector<rule_t> rules;
+  rules.emplace_back( rule_t{ []( aig_network& aig, std::vector<aig_network::signal> const& vs ) -> aig_network::signal {
+                               assert( vs.size() == 2u );
+                               return aig.create_and( vs[0], vs[1] );
+                             },
+                              2u } );
+
+  return gen_t( rules, ps );
+}
+
+/*! \brief Generates a random XAG network */
+template<typename GenParams = random_network_generator_params_size>
+auto random_xag_generator( GenParams ps = {} )
+{
+  using gen_t = random_network_generator<xag_network, GenParams>;
+  using rule_t = typename detail::create_gate_rule<xag_network>;
+
+  std::vector<rule_t> rules;
+  rules.emplace_back( rule_t{ []( xag_network& xag, std::vector<xag_network::signal> const& vs ) -> xag_network::signal {
+                               assert( vs.size() == 2u );
+                               return xag.create_and( vs[0], vs[1] );
+                             },
+                              2u } );
+  rules.emplace_back( rule_t{ []( xag_network& xag, std::vector<xag_network::signal> const& vs ) -> xag_network::signal {
+                               assert( vs.size() == 2u );
+                               return xag.create_xor( vs[0], vs[1] );
+                             },
+                              2u } );
+
+  return gen_t( rules, ps );
+}
+
+/*! \brief Generates a random MIG network */
+template<typename GenParams = random_network_generator_params_size>
+auto random_mig_generator( GenParams ps = {} )
+{
+  using gen_t = random_network_generator<mig_network, GenParams>;
+  using rule_t = typename detail::create_gate_rule<mig_network>;
+
+  std::vector<rule_t> rules;
+  rules.emplace_back( rule_t{ []( mig_network& mig, std::vector<mig_network::signal> const& vs ) -> mig_network::signal {
+                               assert( vs.size() == 3u );
+                               return mig.create_maj( vs[0], vs[1], vs[2] );
+                             },
+                              3u } );
+
+  return gen_t( rules, ps );
+}
+
+/*! \brief Generates a random MIG network MAJ-, AND-, and OR-gates */
+template<typename GenParams = random_network_generator_params_size>
+auto mixed_random_mig_generator( GenParams ps = {} )
+{
+  using gen_t = random_network_generator<mig_network, GenParams>;
+  using rule_t = typename detail::create_gate_rule<mig_network>;
+
+  std::vector<rule_t> rules;
+  rules.emplace_back( rule_t{ []( mig_network& mig, std::vector<mig_network::signal> const& vs ) -> mig_network::signal {
+                               assert( vs.size() == 3u );
+                               return mig.create_maj( vs[0], vs[1], vs[2] );
+                             },
+                              3u } );
+  rules.emplace_back( rule_t{ []( mig_network& mig, std::vector<mig_network::signal> const& vs ) -> mig_network::signal {
+                               assert( vs.size() == 2u );
+                               return mig.create_and( vs[0], vs[1] );
+                             },
+                              2u } );
+  rules.emplace_back( rule_t{ []( mig_network& mig, std::vector<mig_network::signal> const& vs ) -> mig_network::signal {
+                               assert( vs.size() == 2u );
+                               return mig.create_or( vs[0], vs[1] );
+                             },
+                              2u } );
+
+  return gen_t( rules, ps );
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/generators/self_dualize.hpp b/include/mockturtle/generators/self_dualize.hpp
new file mode 100644
index 0000000..837df18
--- /dev/null
+++ b/include/mockturtle/generators/self_dualize.hpp
@@ -0,0 +1,129 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file self_dualize.hpp
+  \brief Self-dualize a logic network
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#include "../algorithms/reconv_cut.hpp"
+#include "../networks/aig.hpp"
+#include "../views/cut_view.hpp"
+#include "../views/topo_view.hpp"
+
+#include <algorithm>
+#include <unordered_map>
+
+namespace mockturtle
+{
+
+/*! \brief Generates a self-dual AIG
+ *
+ * Generates the self-dualization of a multi-output logic network N.
+ * The algorithm iterates over the output functions f0, ..., fm of N
+ * and computes self-dualized function gi for 0 <= i <= m defined by
+ * the formula
+ *
+ * gi(x0, x1, ..., xn)
+ *   = (x0 * fi(x1, ..., xn)) + (!x0 * !fi(!x1, ..., !xn)).
+ *
+ */
+inline aig_network self_dualize_aig( aig_network const& src_aig )
+{
+  using node = node<aig_network>;
+  using signal = signal<aig_network>;
+
+  aig_network dest_aig;
+  std::unordered_map<node, signal> node_to_signal_one;
+  std::unordered_map<node, signal> node_to_signal_two;
+
+  /* copy inputs */
+  node_to_signal_one[0] = dest_aig.get_constant( false );
+  node_to_signal_two[0] = dest_aig.get_constant( false );
+  src_aig.foreach_pi( [&]( const auto& n ) {
+    auto const pi = dest_aig.create_pi();
+    node_to_signal_one[n] = pi;
+    node_to_signal_two[n] = !pi;
+  } );
+
+  reconvergence_driven_cut_parameters ps;
+  ps.max_leaves = 99999999u;
+  reconvergence_driven_cut_statistics st;
+  detail::reconvergence_driven_cut_impl<aig_network, false, false> cut_generator( src_aig, ps, st );
+
+  src_aig.foreach_po( [&]( const auto& f ) {
+    auto leaves = cut_generator.run( { src_aig.get_node( f ) } ).first;
+    std::stable_sort( std::begin( leaves ), std::end( leaves ) );
+
+    /* check if all leaves are pis */
+    for ( const auto& l : leaves )
+    {
+      (void)l;
+      assert( src_aig.is_pi( l ) );
+    }
+
+    cut_view<aig_network> view( src_aig, leaves, f );
+    topo_view<decltype( view )> topo_view( view );
+
+    /* create cone once */
+    topo_view.foreach_gate( [&]( const auto& g ) {
+      std::vector<signal> new_fanins;
+      topo_view.foreach_fanin( g, [&]( const auto& fi ) {
+        auto const n = topo_view.get_node( fi );
+        new_fanins.emplace_back( topo_view.is_complemented( fi ) ? !node_to_signal_one[n] : node_to_signal_one[n] );
+      } );
+
+      assert( new_fanins.size() == 2u );
+      node_to_signal_one[g] = dest_aig.create_and( new_fanins[0u], new_fanins[1u] );
+    } );
+
+    /* create cone once */
+    topo_view.foreach_gate( [&]( const auto& g ) {
+      std::vector<signal> new_fanins;
+      topo_view.foreach_fanin( g, [&]( const auto& fi ) {
+        auto const n = topo_view.get_node( fi );
+        new_fanins.emplace_back( topo_view.is_complemented( fi ) ? !node_to_signal_two[n] : node_to_signal_two[n] );
+      } );
+
+      assert( new_fanins.size() == 2u );
+      node_to_signal_two[g] = dest_aig.create_and( new_fanins[0u], new_fanins[1u] );
+    } );
+
+    auto const output_signal_one = topo_view.is_complemented( f ) ? !node_to_signal_one[topo_view.get_node( f )] : node_to_signal_one[topo_view.get_node( f )];
+    auto const output_signal_two = topo_view.is_complemented( f ) ? !node_to_signal_two[topo_view.get_node( f )] : node_to_signal_two[topo_view.get_node( f )];
+
+    auto const new_pi = dest_aig.create_pi();
+    auto const output = dest_aig.create_or( dest_aig.create_and( new_pi, output_signal_one ), dest_aig.create_and( !new_pi, !output_signal_two ) );
+    dest_aig.create_po( output );
+  } );
+
+  return dest_aig;
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/generators/sorting.hpp b/include/mockturtle/generators/sorting.hpp
new file mode 100644
index 0000000..cf68be9
--- /dev/null
+++ b/include/mockturtle/generators/sorting.hpp
@@ -0,0 +1,148 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file sorting.hpp
+  \brief Generate sorting networks
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <numeric>
+
+namespace mockturtle
+{
+
+/*! \brief Generates sorting network based on bubble sort.
+ *
+ * The functor is called for every comparator in the network.  The arguments
+ * to the functor are two integers that define on which lines the comparator
+ * acts.
+ *
+ * \param n Number of elements to sort
+ * \param compare_fn Functor
+ */
+template<class Fn>
+void bubble_sorting_network( uint32_t n, Fn&& compare_fn )
+{
+  if ( n <= 1 )
+  {
+    return;
+  }
+  for ( auto c = n - 1; c >= 1; --c )
+  {
+    for ( auto j = 0u; j < c; ++j )
+    {
+      compare_fn( j, j + 1 );
+    }
+  }
+}
+
+/*! \brief Generates sorting network based on insertion sort.
+ *
+ * The functor is called for every comparator in the network.  The arguments
+ * to the functor are two integers that define on which lines the comparator
+ * acts.
+ *
+ * \param n Number of elements to sort
+ * \param compare_fn Functor
+ */
+template<class Fn>
+void insertion_sorting_network( uint32_t n, Fn&& compare_fn )
+{
+  if ( n <= 1 )
+  {
+    return;
+  }
+  for ( auto c = 1u; c < n; ++c )
+  {
+    for ( int j = c - 1; j >= 0; --j )
+    {
+      compare_fn( j, j + 1 );
+    }
+  }
+}
+
+namespace detail
+{
+
+template<class Fn>
+void batcher_merge( std::vector<uint32_t> const& list, Fn&& compare_fn )
+{
+  if ( list.size() == 2u )
+  {
+    compare_fn( list[0], list[1] );
+    return;
+  }
+
+  std::vector<uint32_t> even, odd;
+  for ( auto i = 0u; i < list.size(); i += 2 )
+  {
+    even.push_back( list[i] );
+    odd.push_back( list[i + 1] );
+  }
+
+  batcher_merge( even, compare_fn );
+  batcher_merge( odd, compare_fn );
+
+  for ( auto i = 1u; i < list.size() - 2; i += 2 )
+  {
+    compare_fn( list[i], list[i + 1] );
+  }
+}
+
+template<class Fn>
+void batcher_sort( uint32_t begin, uint32_t end, Fn&& compare_fn )
+{
+  const auto size = end - begin;
+  if ( size == 2u )
+  {
+    compare_fn( begin, begin + 1 );
+    return;
+  }
+
+  batcher_sort( begin, begin + size / 2, compare_fn );
+  batcher_sort( begin + size / 2, end, compare_fn );
+
+  std::vector<uint32_t> list( size );
+  std::iota( list.begin(), list.end(), begin );
+  batcher_merge( list, compare_fn );
+}
+
+} // namespace detail
+
+template<class Fn>
+void batcher_sorting_network( uint32_t n, Fn&& compare_fn )
+{
+  if ( n < 2 )
+    return;
+  detail::batcher_sort( 0u, n, compare_fn );
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/interface.hpp b/include/mockturtle/interface.hpp
new file mode 100644
index 0000000..ec012fd
--- /dev/null
+++ b/include/mockturtle/interface.hpp
@@ -0,0 +1,768 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file interface.hpp
+  \brief Documentation of network interfaces
+
+  \author Bruno Schmitt
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include <kitty/dynamic_truth_table.hpp>
+
+#include "networks/events.hpp"
+#include "traits.hpp"
+
+namespace mockturtle
+{
+
+static_assert( false, "file interface.hpp cannot be included, it's only used for documentation" );
+
+class network final
+{
+public:
+  /*! \brief Type referring to itself.
+   *
+   * The ``base_type`` is the network type itself.  It is required, because
+   * views may extend networks, and this type provides a way to determine the
+   * underlying network type.
+   */
+  using base_type = network;
+
+  /*! \brief Type representing a node.
+   *
+   * A ``node`` is a node in the logic network.  It could be a constant, a
+   * primary input or a logic gate.
+   */
+  struct node
+  {
+  };
+
+  /*! \brief Type representing a signal.
+   *
+   * A ``signal`` can be seen as a pointer to a node, or an outgoing edge of
+   * a node towards its fanout.  Depending on the kind of logic network, it
+   * may carry additional information such as a complement attribute.
+   */
+  struct signal
+  {
+  };
+
+  /*! \brief Type representing the storage.
+   *
+   * A ``storage`` is some container that can contain all data necessary to
+   * store the logic network.  It can be constructed outside of the logic network
+   * and passed as a reference to the constructor.  It may be shared among
+   * several logic networks.  A `std::shared_ptr<T>` is a convenient data
+   * structure to hold a storage in a logic network.
+   */
+  struct storage
+  {
+  };
+
+  /*! \brief Default constructor.
+   *
+   * Constructs an empty network.
+   */
+  network();
+
+  /*! \brief Constructor taking a storage. */
+  explicit network( storage s );
+
+  /*! \brief Default copy assignment operator.
+   *
+   * Currently, most network implementations in mockturtle use `std::shared_ptr<storage>`
+   * to hold and share the storage. Thus, the default behavior of copy-assigning
+   * a network only copies the pointer, but not really duplicating the contents
+   * in the storage data structure. In other words, it makes a shallow copy
+   * by default.
+   */
+  network& operator=( const network& other ) = default;
+
+  /*! \brief Explicitly duplicate a network.
+   *
+   * Deep copy a network by duplicating the storage. Note that this method
+   * does not duplicate the network events.
+   */
+  network clone();
+
+#pragma region Primary I / O and constants
+  /*! \brief Gets constant value represented by network.
+   *
+   * A constant node is the only node that must be created when initializing
+   * the network.  For this reason, this method has constant access and is not
+   * called `create_constant`.
+   *
+   * \param value Constant value
+   */
+  signal get_constant( bool value ) const;
+
+  /*! \brief Creates a primary input in the network.
+   *
+   * Each created primary input is stored in a node and contributes to the size
+   * of the network.
+   */
+  signal create_pi();
+
+  /*! \brief Creates a primary output in the network.
+   *
+   * A primary output is not stored in terms of a node, and it also does not
+   * contribute to the size of the network.  A primary output is created for a
+   * signal in the network and it is possible that multiple primary outputs
+   * point to the same signal.
+   *
+   * \param s Signal that drives the created primary output
+   */
+  void create_po( signal const& s );
+
+  /*! \brief Checks whether a node is a constant node. */
+  bool is_constant( node const& n ) const;
+
+  /*! \brief Checks whether a node is a primary input. */
+  bool is_pi( node const& n ) const;
+
+  /*! \brief Checks whether a node is a combinational input.
+   *
+   * This method should be effectively the same as ``is_pi`` in a
+   * combinational network.
+   */
+  bool is_ci( node const& n ) const;
+
+  /*! \brief Gets the Boolean value of the constant node.
+   *
+   * The method expects that `n` is a constant node.
+   */
+  bool constant_value( node const& n ) const;
+#pragma endregion
+
+#pragma region Create unary functions
+  /*! \brief Creates signal that computes ``f``.
+   *
+   * This method is not required to create a gate in the network.  A network
+   * implementation can also just return ``f``.
+   *
+   * \param f Child signal
+   */
+  signal create_buf( signal const& f );
+
+  /*! \brief Creates a signal that inverts ``f``.
+   *
+   * This method is not required to create a gate in the network.  If a network
+   * supports complemented attributes on signals, it can just return the
+   * complemented signal ``f``.
+   *
+   * \param f Child signal
+   */
+  signal create_not( signal const& f );
+#pragma endregion
+
+#pragma region Create binary functions
+  /*! \brief Creates a signal that computes the binary AND. */
+  signal create_and( signal const& f, signal const& g );
+
+  /*! \brief Creates a signal that computes the binary NAND. */
+  signal create_nand( signal const& f, signal const& g );
+
+  /*! \brief Creates a signal that computes the binary OR. */
+  signal create_or( signal const& f, signal const& g );
+
+  /*! \brief Creates a signal that computes the binary NOR. */
+  signal create_nor( signal const& f, signal const& g );
+
+  /*! \brief Creates a signal that computes the binary less-than.
+   *
+   * The signal is true if and only if ``f`` is 0 and ``g`` is 1.
+   */
+  signal create_lt( signal const& f, signal const& g );
+
+  /*! \brief Creates a signal that computes the binary less-than-or-equal.
+   *
+   * The signal is true if and only if ``f`` is 0 or ``g`` is 1.
+   */
+  signal create_le( signal const& f, signal const& g );
+
+  /*! \brief Creates a signal that computes the binary greater-than.
+   *
+   * The signal is true if and only if ``f`` is 1 and ``g`` is 0.
+   */
+  signal create_gt( signal const& f, signal const& g );
+
+  /*! \brief Creates a signal that computes the binary greater-than-or-equal.
+   *
+   * The signal is true if and only if ``f`` is 1 or ``g`` is 0.
+   */
+  signal create_ge( signal const& f, signal const& g );
+
+  /*! \brief Creates a signal that computes the binary XOR. */
+  signal create_xor( signal const& f, signal const& g );
+
+  /*! \brief Creates a signal that computes the binary XNOR. */
+  signal create_xnor( signal const& f, signal const& g );
+#pragma endregion
+
+#pragma region Create ternary functions
+  /*! \brief Creates a signal that computes the majority-of-3. */
+  signal create_maj( signal const& f, signal const& g, signal const& h );
+
+  /*! \brief Creates a signal that computes the if-then-else operation.
+   *
+   * \param cond Condition for ITE operator
+   * \param f_then Then-case for ITE operator
+   * \param f_else Else-case for ITE operator
+   */
+  signal create_ite( signal const& cond, signal const& f_then, signal const& f_else );
+
+  /*! \brief Creates a signal that computes the ternary XOR operation. */
+  signal create_xor3( signal const& a, signal const& b, signal const& c );
+#pragma endregion
+
+#pragma region Create nary functions
+  /*! \brief Creates a signal that computes the n-ary AND.
+   *
+   * If `fs` is empty, it returns constant-1.
+   */
+  signal create_nary_and( std::vector<signal> const& fs );
+
+  /*! \brief Creates a signal that computes the n-ary OR.
+   *
+   * If `fs` is empty, it returns constant-0.
+   */
+  signal create_nary_or( std::vector<signal> const& fs );
+
+  /*! \brief Creates a signal that computes the n-ary XOR.
+   *
+   * If `fs` is empty, it returns constant-0.
+   */
+  signal create_nary_xor( std::vector<signal> const& fs );
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  /*! \brief Creates node with arbitrary function.
+   *
+   * The number of variables in ``function`` must match the number of fanin
+   * signals in ``fanin``.  ``fanin[0]`` will correspond to the
+   * least-significant variable in ``function``.
+   *
+   * \param fanin Fan-in signals
+   * \param function Truth table for node function
+   */
+  signal create_node( std::vector<signal> const& fanin, kitty::dynamic_truth_table const& function );
+
+  /*! \brief Clones a node from another network of same type.
+   *
+   * This method can clone a node from a different network ``other``, which is
+   * from the same type.  The node ``source`` is a node in the source network
+   * ``other``, but the signals in ``fanin`` refer to signals in the target
+   * network, which are assumed to be in the same order as in the source
+   * network.
+   *
+   * \param other Other network of same type
+   * \param source Node in ``other``
+   * \param children Fan-in signals from the current network
+   * \return New signal representing node in current network
+   */
+  signal clone_node( network const& other, node const& source, std::vector<signal> const& fanin );
+#pragma endregion
+
+#pragma region Restructuring
+  /*! \brief Replaces one node in a network by another signal.
+   *
+   * This method causes all nodes that have ``old_node`` as fanin to have
+   * `new_signal` as fanin instead.  In doing so, a possible polarity of
+   * `new_signal` is taken into account.  Afterwards, the fan-out count of
+   * ``old_node`` is guaranteed to be 0.
+   *
+   * It does not update custom values or visited flags of a node.
+   *
+   * \param old_node Node to replace
+   * \param new_signal Signal to replace ``old_node`` with
+   */
+  void substitute_node( node const& old_node, signal const& new_signal );
+
+  /*! \brief Perform multiple node-signal replacements in a network.
+   *
+   * This method replaces all occurrences of a node with a signal for
+   * all pairs (node, signal) in the substitution list.
+   *
+   * \param substitutions A list of (node, signal) replacement pairs
+   */
+  void substitute_nodes( std::list<std::pair<node, signal>> substitutions );
+
+  /*! \brief Replaces a child node by a new signal in a node.
+   *
+   * If ``n`` has a child pointing to ``old_node``, then it will be replaced by
+   * ``new_signal``.  If the replacement catches a trivial case, e.g., ``n``
+   * becomes a constant, then this will be returned as an optional replacement
+   * candidate by the function.
+   *
+   * The function updates the hash table. If no trivial case was found, it
+   * updates the hash table according to the new structure of ``n``.
+   *
+   * \param n Node which may have ``old_node`` as a child
+   * \param old_node Child to be replaced
+   * \param new_signal Signel to replace ``old_node`` with
+   * \return May return new recursive replacement candidate
+   */
+  std::optional<std::pair<node, signal>> replace_in_node( node const& n, node const& old_node, signal new_signal );
+
+  /*! \brief Replaces a output driver by a new signal.
+   *
+   * If ``old_node`` is drive to some output, then it will be replaced by
+   * ``new_signal``.
+   *
+   * \param old_node Driver to be replaced
+   * \param new_signal Signal replace ``old_node`` with
+   */
+  void replace_in_outputs( node const& old_node, signal const& new_signal );
+
+  /*! \brief Removes a node (and potentially its fanins) from the hash table.
+   *
+   * The node will be marked dead.  This status can be checked with
+   * ``is_dead``. Taking out a node does not change the indexes of
+   * other nodes.  The node will be removed from the hash table.
+   * The reference counters of all fanin will be decremented and
+   * ``take_out_node`` will be recursively invoked on all fanins
+   * if their fanout count reach 0.
+   *
+   * \param n Node to be removed
+   */
+  void take_out_node( node const& n );
+
+  /*! \brief Check if a node is dead.
+   *
+   * A dead node is no longer visited in the ``foreach_node`` and
+   * ``foreach_gate`` methods.  It still contributes to the overall
+   * ``size`` of the network, but ``num_gates`` does not take dead
+   * nodes into account.
+   *
+   * \param n Node to check
+   * \return Whether ``n`` is dead
+   */
+  bool is_dead( node const& n ) const;
+#pragma endregion
+
+#pragma region Structural properties
+  /*! \brief Checks whether the network is combinational. */
+  bool is_combinational() const;
+
+  /*! \brief Returns the number of nodes (incl. constants and PIs and dead nodes). */
+  uint32_t size() const;
+
+  /*! \brief Returns the number of primary inputs. */
+  uint32_t num_pis() const;
+
+  /*! \brief Returns the number of primary outputs. */
+  uint32_t num_pos() const;
+
+  /*! \brief Returns the number of combinational inputs.
+   *
+   * This method should be effectively the same as `num_pis`` in a
+   * combinational network.
+   */
+  uint32_t num_cis() const;
+
+  /*! \brief Returns the number of combinational outputs.
+   *
+   * This method should be effectively the same as `num_pos`` in a
+   * combinational network.
+   */
+  uint32_t num_cos() const;
+
+  /*! \brief Returns the number of gates (without dead nodes) */
+  uint32_t num_gates() const;
+
+  /*! \brief Returns the fanin size of a node. */
+  uint32_t fanin_size( node const& n ) const;
+
+  /*! \brief Returns the fanout size of a node. */
+  uint32_t fanout_size( node const& n ) const;
+
+  /*! \brief Increments fanout size and returns old value.
+   *
+   * This is useful for ref-counting based algorithm.  The user of this function
+   * should make sure to bring the value back to a consistent state.
+   */
+  uint32_t incr_fanout_size( node const& n ) const;
+
+  /*! \brief Decrements fanout size and returns new value.
+   *
+   * This is useful for ref-counting based algorithm.  The user of this function
+   * should make sure to bring the value back to a consistent state.
+   */
+  uint32_t decr_fanout_size( node const& n ) const;
+
+  /*! \brief Returns the length of the critical path.
+   *
+   * For efficiency reasons, this interface is often not provided in the
+   * network implementations, but has to be extended by wrapping with `depth_view`.
+   */
+  uint32_t depth() const;
+
+  /*! \brief Returns the level of a node.
+   *
+   * For efficiency reasons, this interface is often not provided in the
+   * network implementations, but has to be extended by wrapping with `depth_view`.
+   */
+  uint32_t level( node const& n ) const;
+
+  /*! \brief Returns true if node is a 2-input AND gate. */
+  bool is_and( node const& n ) const;
+
+  /*! \brief Returns true if node is a 2-input OR gate. */
+  bool is_or( node const& n ) const;
+
+  /*! \brief Returns true if node is a 2-input XOR gate. */
+  bool is_xor( node const& n ) const;
+
+  /*! \brief Returns true if node is a majority-of-3 gate. */
+  bool is_maj( node const& n ) const;
+
+  /*! \brief Returns true if node is a if-then-else gate. */
+  bool is_ite( node const& n ) const;
+
+  /*! \brief Returns true if node is a 3-input XOR gate. */
+  bool is_xor3( node const& n ) const;
+
+  /*! \brief Returns true if node is a primitive n-ary AND gate. */
+  bool is_nary_and( node const& n ) const;
+
+  /*! \brief Returns true if node is a primitive n-ary OR gate. */
+  bool is_nary_or( node const& n ) const;
+
+  /*! \brief Returns true if node is a primitive n-ary XOR gate. */
+  bool is_nary_xor( node const& n ) const;
+
+  /*! \brief Returns true if node is a general function node. */
+  bool is_function( node const& n ) const;
+#pragma endregion
+
+#pragma region Functional properties
+  /*! \brief Returns the gate function of a node.
+   *
+   * Note that this function returns the gate function represented by a node
+   * in terms of the *intended* gate.  For example, in an AIG, all gate
+   * functions are AND, complemented edges are not taken into account.  Also,
+   * in an MIG, all gate functions are MAJ, independently of complemented edges
+   * and possible constant inputs.
+   *
+   * In order to retrieve a function with respect to complemented edges one can
+   * use the `compute` function with a truth table as simulation value.
+   */
+  kitty::dynamic_truth_table node_function( node const& n ) const;
+#pragma endregion
+
+#pragma region Nodes and signals
+  /*! \brief Get the node a signal is pointing to. */
+  node get_node( signal const& f ) const;
+
+  /*! \brief Create a signal from a node (without edge attributes). */
+  signal make_signal( node const& n ) const;
+
+  /*! \brief Check whether a signal is complemented.
+   *
+   * This method may also be provided by network implementations that do not
+   * have complemented edges.  In this case, the method simply returns
+   * ``false`` for each node.
+   */
+  bool is_complemented( signal const& f ) const;
+
+  /*! \brief Returns the index of a node.
+   *
+   * The index of a node must be a unique for each node and must be between 0
+   * (inclusive) and the size of a network (exclusive, value returned by
+   * ``size()``).
+   */
+  uint32_t node_to_index( node const& n ) const;
+
+  /*! \brief Returns the node for an index.
+   *
+   * This is the inverse function to ``node_to_index``.
+   *
+   * \param index A value between 0 (inclusive) and the size of the network
+   *              (exclusive)
+   */
+  node index_to_node( uint32_t index ) const;
+
+  /*! \brief Returns the primary input node for an index.
+   *
+   * \param index A value between 0 (inclusive) and the number of
+   *              primary inputs (exclusive).
+   */
+  node pi_at( uint32_t index ) const;
+
+  /*! \brief Returns the primary output signal for an index.
+   *
+   * \param index A value between 0 (inclusive) and the number of
+   *              primary outputs (exclusive).
+   */
+  signal po_at( uint32_t index ) const;
+
+  /*! \brief Returns the combinational input node for an index.
+   *
+   * \param index A value between 0 (inclusive) and the number of
+   *              combinational inputs (exclusive).
+   */
+  node ci_at( uint32_t index ) const;
+
+  /*! \brief Returns the combinational output signal for an index.
+   *
+   * \param index A value between 0 (inclusive) and the number of
+   *              combinational outputs (exclusive).
+   */
+  signal co_at( uint32_t index ) const;
+
+  /*! \brief Returns the index of a primary input node.
+   *
+   * \param n A primary input node.
+   * \return A value between 0 and num_pis()-1.
+   */
+  uint32_t pi_index( node const& n ) const;
+
+  /*! \brief Returns the index of a primary output signal.
+   *
+   * \param n A primary output signal.
+   * \return A value between 0 and num_pos()-1.
+   */
+  uint32_t po_index( signal const& n ) const;
+
+  /*! \brief Returns the index of a combinational input node.
+   *
+   * \param n A combinational input node.
+   * \return A value between 0 and num_cis()-1.
+   */
+  uint32_t ci_index( node const& n ) const;
+
+  /*! \brief Returns the index of a combinational output signal.
+   *
+   * \param n A combinational output signal.
+   * \return A value between 0 and num_cos()-1.
+   */
+  uint32_t co_index( signal const& n ) const;
+#pragma endregion
+
+#pragma region Node and signal iterators
+  /*! \brief Calls ``fn`` on every node in network.
+   *
+   * The order of nodes depends on the implementation and must not guarantee
+   * topological order.  The parameter ``fn`` is any callable that must have
+   * one of the following four signatures.
+   * - ``void(node const&)``
+   * - ``void(node const&, uint32_t)``
+   * - ``bool(node const&)``
+   * - ``bool(node const&, uint32_t)``
+   *
+   * If ``fn`` has two parameters, the second parameter is an index starting
+   * from 0 and incremented in every iteration.  If ``fn`` returns a ``bool``,
+   * then it can interrupt the iteration by returning ``false``.
+   */
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const;
+
+  /*! \brief Calls ``fn`` on every gate node in the network.
+   *
+   * Calls each node that is not constant and not a combinational input.  The
+   * parameter ``fn`` is any callable that must have one of the following four
+   * signatures.
+   * - ``void(node const&)``
+   * - ``void(node const&, uint32_t)``
+   * - ``bool(node const&)``
+   * - ``bool(node const&, uint32_t)``
+   *
+   * If ``fn`` has two parameters, the second parameter is an index starting
+   * from 0 and incremented in every iteration.  If ``fn`` returns a ``bool``,
+   * then it can interrupt the iteration by returning ``false``.
+   */
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const;
+
+  /*! \brief Calls ``fn`` on every primary input node in the network.
+   *
+   * The order is in the same order as primary inputs have been created with
+   * ``create_pi``.  The parameter ``fn`` is any callable that must have one of
+   * the following four signatures.
+   * - ``void(node const&)``
+   * - ``void(node const&, uint32_t)``
+   * - ``bool(node const&)``
+   * - ``bool(node const&, uint32_t)``
+   *
+   * If ``fn`` has two parameters, the second parameter is an index starting
+   * from 0 and incremented in every iteration.  If ``fn`` returns a ``bool``,
+   * then it can interrupt the iteration by returning ``false``.
+   */
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const;
+
+  /*! \brief Calls ``fn`` on every primary output signal in the network.
+   *
+   * The order is in the same order as primary outputs have been created with
+   * ``create_po``.  The function is called on the signal that is driving the
+   * output and may occur more than once in the iteration, if it drives more
+   * than one output.  The parameter ``fn`` is any callable that must have one
+   * of the following four signatures.
+   * - ``void(signal const&)``
+   * - ``void(signal const&, uint32_t)``
+   * - ``bool(signal const&)``
+   * - ``bool(signal const&, uint32_t)``
+   *
+   * If ``fn`` has two parameters, the second parameter is an index starting
+   * from 0 and incremented in every iteration.  If ``fn`` returns a ``bool``,
+   * then it can interrupt the iteration by returning ``false``.
+   */
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const;
+
+  /*! \brief Calls ``fn`` on every combinational input node in the network.
+   *
+   * This method should be effectively the same as ``foreach_pi`` in a
+   * combinational network.
+   */
+  template<typename Fn>
+  void foreach_ci( Fn&& fn ) const;
+
+  /*! \brief Calls ``fn`` on every combinational output signal in the network.
+   *
+   * This method should be effectively the same as ``foreach_po`` in a
+   * combinational network.
+   */
+  template<typename Fn>
+  void foreach_co( Fn&& fn ) const;
+
+  /*! \brief Calls ``fn`` on every fanin of a node.
+   *
+   * The order of the fanins is in the same order that was used to create the
+   * node.  The parameter ``fn`` is any callable that must have one of the
+   * following four signatures.
+   * - ``void(signal const&)``
+   * - ``void(signal const&, uint32_t)``
+   * - ``bool(signal const&)``
+   * - ``bool(signal const&, uint32_t)``
+   *
+   * If ``fn`` has two parameters, the second parameter is an index starting
+   * from 0 and incremented in every iteration.  If ``fn`` returns a ``bool``,
+   * then it can interrupt the iteration by returning ``false``.
+   */
+  template<typename Fn>
+  void foreach_fanin( node const& n, Fn&& fn ) const;
+
+  /*! \brief Calls ``fn`` on every fanout of a node.
+   *
+   * The method gives no guarantee on the order of the fanout.  The parameter
+   * ``fn`` is any callable that must have one of the following signatures.
+   * - ``void(node const&)``
+   * - ``void(node const&, uint32_t)``
+   * - ``bool(node const&)``
+   * - ``bool(node const&, uint32_t)``
+   *
+   * If ``fn`` has two parameters, the second parameter is an index starting
+   * from 0 and incremented in every iteration.  If ``fn`` returns a ``bool``,
+   * then it can interrupt the iteration by returning ``false``.
+   *
+   * For efficiency reasons, this interface is often not provided in the
+   * network implementations, but has to be extended by wrapping with `fanout_view`.
+   */
+  template<typename Fn>
+  void foreach_fanout( node const& n, Fn&& fn ) const;
+#pragma endregion
+
+#pragma region Simulate values
+  /*! \brief Simulates arbitrary value on a node.
+   *
+   * This is a generic simulation method that can be implemented multiple times
+   * for a network interface for different types.  One only needs to change the
+   * implementation and change the value for the type parameter ``T``, which
+   * indicates the element type of the iterators.
+   *
+   * Examples for simulation types are ``bool``,
+   * ``kitty::dynamic_truth_table``, bit masks, or BDDs.
+   *
+   * The ``begin`` and ``end`` iterator point to values which are assumed to be
+   * assigned to the fanin of the node.  Consequently, the distance from
+   * ``begin`` to ``end`` must equal the fanin size of the node.
+   *
+   * \param n Node to simulate (used to retrieve the node function)
+   * \param begin Begin iterator to simulation values of fanin
+   * \param end End iterator to simulation values of fanin
+   * \return Returns computed simulation value of type ``T``
+   */
+  template<typename Iterator>
+  iterates_over_t<Iterator, T>
+  compute( node const& n, Iterator begin, Iterator end ) const;
+#pragma endregion
+
+#pragma region Custom node values
+  /*! \brief Reset all values to 0. */
+  void clear_values() const;
+
+  /*! \brief Returns value of a node. */
+  uint32_t value( node const& n ) const;
+
+  /*! \brief Sets value of a node. */
+  void set_value( node const& n, uint32_t value ) const;
+
+  /*! \brief Increments value of a node and returns *previous* value. */
+  uint32_t incr_value( node const& n ) const;
+
+  /*! \brief Decrements value of a node and returns *new* value. */
+  uint32_t decr_value( node const& n ) const;
+#pragma endregion
+
+#pragma region Visited flags
+  /*! \brief Reset all visited values to 0. */
+  void clear_visited() const;
+
+  /*! \brief Returns the visited value of a node. */
+  uint32_t visited( node const& n ) const;
+
+  /*! \brief Sets the visited value of a node. */
+  void set_visited( node const& n, uint32_t v ) const;
+
+  /*! \brief Returns the current traversal id. */
+  uint32_t trav_id() const;
+
+  /*! \brief Increment the current traversal id. */
+  void incr_trav_id() const;
+#pragma endregion
+
+#pragma region General methods
+  /*! \brief Returns network events object.
+   *
+   * Clients can register callbacks for network events to this object.  Events
+   * include adding nodes, modifying nodes, and deleting nodes.
+   */
+  network_events<base_type>& events() const;
+#pragma endregion
+};
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/io/aiger_reader.hpp b/include/mockturtle/io/aiger_reader.hpp
new file mode 100644
index 0000000..3a633f1
--- /dev/null
+++ b/include/mockturtle/io/aiger_reader.hpp
@@ -0,0 +1,233 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aiger_reader.hpp
+  \brief Lorina reader for AIGER files
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../networks/aig.hpp"
+#include "../networks/sequential.hpp"
+#include "../traits.hpp"
+#include <lorina/aiger.hpp>
+
+namespace mockturtle
+{
+
+/*! \brief Lorina reader callback for Aiger files.
+ *
+ * **Required network functions:**
+ * - `create_pi`
+ * - `create_po`
+ * - `get_constant`
+ * - `create_not`
+ * - `create_and`
+ *
+ * **Optional network functions to support sequential networks:**
+ * - `create_ri`
+ * - `create_ro`
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      aig_network aig;
+      lorina::read_aiger( "file.aig", aiger_reader( aig ) );
+
+      mig_network mig;
+      lorina::read_aiger( "file.aig", aiger_reader( mig ) );
+   \endverbatim
+ */
+template<typename Ntk>
+class aiger_reader : public lorina::aiger_reader
+{
+public:
+  explicit aiger_reader( Ntk& ntk ) : _ntk( ntk )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_create_pi_v<Ntk>, "Ntk does not implement the create_pi function" );
+    static_assert( has_create_po_v<Ntk>, "Ntk does not implement the create_po function" );
+    static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant function" );
+    static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not function" );
+    static_assert( has_create_and_v<Ntk>, "Ntk does not implement the create_and function" );
+  }
+
+  ~aiger_reader()
+  {
+    uint32_t output_id{ 0 };
+    for ( auto out : outputs )
+    {
+      auto const lit = std::get<0>( out );
+      auto signal = signals[lit >> 1];
+      if ( lit & 1 )
+      {
+        signal = _ntk.create_not( signal );
+      }
+      if constexpr ( has_set_output_name_v<Ntk> )
+      {
+        if ( !std::get<1>( out ).empty() )
+        {
+          _ntk.set_output_name( output_id++, std::get<1>( out ) );
+        }
+      }
+      _ntk.create_po( signal );
+    }
+
+    if constexpr ( has_create_ri_v<Ntk> )
+    {
+      for ( auto i = 0u; i < latches.size(); ++i )
+      {
+        auto& latch = latches[i];
+        auto const lit = std::get<0>( latch );
+        auto const reset = std::get<1>( latch );
+
+        auto signal = signals[lit >> 1];
+        if ( lit & 1 )
+        {
+          signal = _ntk.create_not( signal );
+        }
+
+        if constexpr ( has_set_name_v<Ntk> )
+        {
+          _ntk.set_name( signal, std::get<2>( latch ) + "_next" );
+        }
+
+        _ntk.create_ri( signal );
+        register_t reg;
+        reg.init = reset;
+        _ntk.set_register( i, reg );
+      }
+    }
+  }
+
+  void on_header( uint64_t, uint64_t num_inputs, uint64_t num_latches, uint64_t, uint64_t ) const override
+  {
+    (void)num_latches;
+    if constexpr ( !has_create_ri_v<Ntk> || !has_create_ro_v<Ntk> )
+    {
+      assert( num_latches == 0 && "network type does not support the creation of latches" );
+    }
+
+    _num_inputs = static_cast<uint32_t>( num_inputs );
+
+    /* constant */
+    signals.push_back( _ntk.get_constant( false ) );
+
+    /* create primary inputs (pi) */
+    for ( auto i = 0u; i < num_inputs; ++i )
+    {
+      signals.push_back( _ntk.create_pi() );
+    }
+
+    if constexpr ( has_create_ro_v<Ntk> )
+    {
+      /* create latch outputs (ro) */
+      for ( auto i = 0u; i < num_latches; ++i )
+      {
+        signals.push_back( _ntk.create_ro() );
+      }
+    }
+  }
+
+  void on_input_name( unsigned index, const std::string& name ) const override
+  {
+    if constexpr ( has_set_name_v<Ntk> )
+    {
+      _ntk.set_name( signals[1 + index], name );
+    }
+  }
+
+  void on_output_name( unsigned index, const std::string& name ) const override
+  {
+    std::get<1>( outputs[index] ) = name;
+  }
+
+  void on_latch_name( unsigned index, const std::string& name ) const override
+  {
+    if constexpr ( has_create_ri_v<Ntk> && has_create_ro_v<Ntk> )
+    {
+      if constexpr ( has_set_name_v<Ntk> )
+      {
+        _ntk.set_name( signals[1 + _num_inputs + index], name );
+      }
+      std::get<2>( latches[index] ) = name;
+    }
+  }
+
+  void on_and( unsigned index, unsigned left_lit, unsigned right_lit ) const override
+  {
+    (void)index;
+    assert( signals.size() == index );
+
+    auto left = signals[left_lit >> 1];
+    if ( left_lit & 1 )
+    {
+      left = _ntk.create_not( left );
+    }
+
+    auto right = signals[right_lit >> 1];
+    if ( right_lit & 1 )
+    {
+      right = _ntk.create_not( right );
+    }
+
+    signals.push_back( _ntk.create_and( left, right ) );
+  }
+
+  void on_latch( unsigned index, unsigned next, latch_init_value reset ) const override
+  {
+    if constexpr ( has_create_ri_v<Ntk> && has_create_ro_v<Ntk> )
+    {
+      (void)index;
+      int8_t r = reset == latch_init_value::NONDETERMINISTIC ? -1 : ( reset == latch_init_value::ONE ? 1 : 0 );
+      latches.push_back( std::make_tuple( next, r, "" ) );
+    }
+  }
+
+  void on_output( unsigned index, unsigned lit ) const override
+  {
+    (void)index;
+    assert( index == outputs.size() );
+    outputs.emplace_back( lit, "" );
+  }
+
+private:
+  Ntk& _ntk;
+
+  mutable uint32_t _num_inputs{ 0 };
+  mutable std::vector<std::tuple<unsigned, std::string>> outputs;
+  mutable std::vector<typename Ntk::signal> signals;
+  mutable std::vector<std::tuple<unsigned, int8_t, std::string>> latches;
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/io/bench_reader.hpp b/include/mockturtle/io/bench_reader.hpp
new file mode 100644
index 0000000..a3cf95a
--- /dev/null
+++ b/include/mockturtle/io/bench_reader.hpp
@@ -0,0 +1,194 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file bench_reader.hpp
+  \brief Lorina reader for BENCH files
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Max Austin
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <iostream>
+#include <map>
+#include <string>
+#include <vector>
+
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <lorina/bench.hpp>
+
+#include "../traits.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Lorina reader callback for BENCH files.
+ *
+ * **Required network functions:**
+ * - `create_pi`
+ * - `create_po`
+ * - `get_constant`
+ * - `create_node`
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      klut_network klut;
+      lorina::read_bench( "file.bench", bench_reader( klut ) );
+   \endverbatim
+ */
+template<typename Ntk>
+class bench_reader : public lorina::bench_reader
+{
+public:
+  explicit bench_reader( Ntk& ntk ) : _ntk( ntk )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_create_pi_v<Ntk>, "Ntk does not implement the create_pi function" );
+    static_assert( has_create_po_v<Ntk>, "Ntk does not implement the create_po function" );
+    static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant function" );
+    static_assert( has_create_node_v<Ntk>, "Ntk does not implement the create_node function" );
+    signals["gnd"] = _ntk.get_constant( false );
+    signals["vdd"] = _ntk.get_constant( true );
+  }
+
+  ~bench_reader()
+  {
+    for ( auto const& o : outputs )
+    {
+      _ntk.create_po( signals[o] );
+    }
+  }
+
+  void on_input( const std::string& name ) const override
+  {
+    signals[name] = _ntk.create_pi();
+    if constexpr ( has_set_name_v<Ntk> )
+    {
+      _ntk.set_name( signals[name], name );
+    }
+  }
+
+  void on_output( const std::string& name ) const override
+  {
+    if constexpr ( has_set_output_name_v<Ntk> )
+    {
+      _ntk.set_output_name( outputs.size(), name );
+    }
+    outputs.emplace_back( name );
+  }
+
+  void on_assign( const std::string& input, const std::string& output ) const override
+  {
+    signals[output] = signals.at( input );
+  }
+
+  void on_gate( const std::vector<std::string>& inputs, const std::string& output, const std::string& type ) const override
+  {
+    if ( type.size() > 2 && std::string_view( type ).substr( 0, 2 ) == "0x" && inputs.size() <= 6u )
+    {
+      /* modern-style gate definition */
+      kitty::dynamic_truth_table tt( static_cast<int>( inputs.size() ) );
+      kitty::create_from_hex_string( tt, type.substr( 2 ) );
+
+      std::vector<signal<Ntk>> input_signals;
+      for ( const auto& i : inputs )
+        input_signals.push_back( signals[i] );
+
+      signals[output] = _ntk.create_node( input_signals, tt );
+    }
+    else
+    {
+      /* old-style gate definition */
+      std::vector<signal<Ntk>> input_signals;
+      for ( const auto& i : inputs )
+        input_signals.push_back( signals[i] );
+
+      kitty::dynamic_truth_table tt( static_cast<int>( inputs.size() ) );
+
+      std::vector<kitty::dynamic_truth_table> vs( inputs.size(), tt );
+      for ( auto i = 0u; i < inputs.size(); ++i )
+        kitty::create_nth_var( vs[i], i );
+
+      if ( type == "NOT" )
+      {
+        assert( inputs.size() == 1u );
+        tt = ~vs.at( 0u );
+      }
+      else if ( type == "BUFF" )
+      {
+        assert( inputs.size() == 1u );
+        tt = vs.at( 0u );
+      }
+      else if ( type == "AND" )
+      {
+        tt = vs.at( 0u );
+        for ( auto i = 1u; i < inputs.size(); ++i )
+          tt &= vs.at( i );
+      }
+      else if ( type == "NAND" )
+      {
+        tt = vs.at( 0u );
+        for ( auto i = 1u; i < inputs.size(); ++i )
+          tt &= vs.at( i );
+        tt = ~tt;
+      }
+      else if ( type == "OR" )
+      {
+        tt = vs.at( 0u );
+        for ( auto i = 1u; i < inputs.size(); ++i )
+          tt |= vs.at( i );
+      }
+      else if ( type == "NOR" )
+      {
+        tt = vs.at( 0u );
+        for ( auto i = 1u; i < inputs.size(); ++i )
+          tt |= vs.at( i );
+        tt = ~tt;
+      }
+      else
+      {
+        assert( false && "unsupported gate type" );
+      }
+      signals[output] = _ntk.create_node( input_signals, tt );
+    }
+  }
+
+private:
+  Ntk& _ntk;
+
+  mutable std::map<std::string, signal<Ntk>> signals;
+  mutable std::vector<std::string> outputs;
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/io/blif_reader.hpp b/include/mockturtle/io/blif_reader.hpp
new file mode 100644
index 0000000..970c088
--- /dev/null
+++ b/include/mockturtle/io/blif_reader.hpp
@@ -0,0 +1,332 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file blif_reader.hpp
+  \brief Lorina reader for BLIF files
+
+  \author Andrea Costamagna
+  \author Heinz Riener
+  \author Marcel Walter
+  \author Mathias Soeken
+  \author Max Austin
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../networks/aig.hpp"
+#include "../networks/cover.hpp"
+#include "../networks/sequential.hpp"
+#include "../traits.hpp"
+
+#include <kitty/kitty.hpp>
+#include <lorina/blif.hpp>
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace mockturtle
+{
+
+/*! \brief Lorina reader callback for BLIF files.
+ *
+ * **Required network functions:**
+ * - `create_pi`
+ * - `create_po`
+ * - `create_node` or `create_cover_node`
+ * - `get_constant`
+ *
+   \verbatim embed:rst
+   Example
+   .. code-block:: c++
+      klut_network klut;
+      lorina::read_blif( "file.blif", blif_reader( klut ) );
+
+      cover_network cover;
+      lorina::read_blif( "file.blif", blif_reader( cover ) );
+   \endverbatim
+ */
+template<typename Ntk>
+class blif_reader : public lorina::blif_reader
+{
+public:
+  explicit blif_reader( Ntk& ntk )
+      : ntk_( ntk )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_create_pi_v<Ntk>, "Ntk does not implement the create_pi function" );
+    static_assert( has_create_po_v<Ntk>, "Ntk does not implement the create_po function" );
+    static_assert( has_create_node_v<Ntk> || has_create_cover_node_v<Ntk>, "Ntk does not implement the create_node function or the create_cover_node function" );
+    static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant function" );
+  }
+
+  ~blif_reader()
+  {
+    for ( auto const& o : outputs )
+    {
+      ntk_.create_po( signals[o] );
+    }
+
+    if constexpr ( has_create_ri_v<Ntk> )
+    {
+      for ( auto const& latch : latches )
+      {
+        auto signal = signals[latch];
+        ntk_.create_ri( signal );
+      }
+    }
+  }
+
+  virtual void on_model( const std::string& model_name ) const override
+  {
+    if constexpr ( has_set_network_name_v<Ntk> )
+    {
+      ntk_.set_network_name( model_name );
+    }
+
+    (void)model_name;
+  }
+
+  virtual void on_input( const std::string& name ) const override
+  {
+    signals[name] = ntk_.create_pi();
+    if constexpr ( has_set_name_v<Ntk> )
+    {
+      ntk_.set_name( signals[name], name );
+    }
+  }
+
+  virtual void on_output( const std::string& name ) const override
+  {
+    if constexpr ( has_set_output_name_v<Ntk> )
+    {
+      ntk_.set_output_name( outputs.size(), name );
+    }
+    outputs.emplace_back( name );
+  }
+
+  virtual void on_latch( const std::string& input, const std::string& output, const std::optional<latch_type>& l_type, const std::optional<std::string>& control, const std::optional<latch_init_value>& reset ) const override
+  {
+    if constexpr ( has_create_ro_v<Ntk> )
+    {
+      std::string type = "re";
+      if ( l_type )
+      {
+        switch ( *l_type )
+        {
+        case latch_type::FALLING:
+        {
+          type = "fe";
+        }
+        break;
+        case latch_type::RISING:
+        {
+          type = "re";
+        }
+        break;
+        case latch_type::ACTIVE_HIGH:
+        {
+          type = "ah";
+        }
+        break;
+        case latch_type::ACTIVE_LOW:
+        {
+          type = "al";
+        }
+        break;
+        case latch_type::ASYNC:
+        {
+          type = "as";
+        }
+        break;
+        default:
+        {
+          type = "";
+        }
+        break;
+        }
+      }
+
+      uint32_t r = 3;
+      if ( reset )
+      {
+        switch ( *reset )
+        {
+        case latch_init_value::NONDETERMINISTIC:
+        {
+          r = 2;
+        }
+        break;
+        case latch_init_value::ONE:
+        {
+          r = 1;
+        }
+        break;
+        case latch_init_value::ZERO:
+        {
+          r = 0;
+        }
+        break;
+        default:
+          break;
+        }
+      }
+
+      std::string ctrl = control.has_value() ? control.value() : "clock";
+
+      register_t reg;
+      reg.control = ctrl;
+      reg.init = r;
+      reg.type = type;
+
+      signals[output] = ntk_.create_ro();
+      ntk_.set_register( latches.size(), reg );
+
+      if constexpr ( has_set_name_v<Ntk> && has_set_output_name_v<Ntk> )
+      {
+        ntk_.set_name( signals[output], output );
+        ntk_.set_output_name( outputs.size() + latches.size(), input );
+      }
+
+      latches.emplace_back( input );
+    }
+  }
+
+  virtual void on_gate( const std::vector<std::string>& inputs, const std::string& output, const output_cover_t& cover ) const override
+  {
+    if ( inputs.size() == 0u )
+    {
+      if ( cover.size() == 0u )
+      {
+        signals[output] = ntk_.get_constant( false );
+        return;
+      }
+
+      assert( cover.size() == 1u );
+      assert( cover.at( 0u ).first.size() == 0u );
+      assert( cover.at( 0u ).second.size() == 1u );
+
+      auto const assigned_value = cover.at( 0u ).second.at( 0u );
+      auto const const_value = ntk_.get_constant( assigned_value == '1' ? true : false );
+      signals[output] = const_value;
+      return;
+    }
+
+    assert( cover.size() > 0u );
+    assert( cover.at( 0u ).second.size() == 1 );
+    auto const first_output_value = cover.at( 0u ).second.at( 0u );
+
+    if constexpr ( std::is_same<typename Ntk::base_type, cover_network>::value )
+    {
+      std::vector<kitty::cube> cubes;
+      bool is_sop = ( first_output_value == '1' );
+      for ( const auto& c : cover )
+      {
+        assert( c.second.size() == 1 );
+
+        auto const output = c.second[0u];
+        assert( output == '0' || output == '1' );
+        assert( output == first_output_value );
+        (void)first_output_value;
+
+        cubes.emplace_back( kitty::cube( c.first ) );
+      }
+
+      std::vector<signal<Ntk>> input_signals;
+      for ( const auto& i : inputs )
+      {
+        assert( signals.find( i ) != signals.end() );
+        input_signals.push_back( signals.at( i ) );
+      }
+
+      if ( cubes.size() != 0 )
+      {
+        signals[output] = ntk_.create_cover_node( input_signals, std::make_pair( cubes, is_sop ) );
+      }
+    }
+    else
+    {
+
+      std::vector<kitty::cube> minterms;
+      std::vector<kitty::cube> maxterms;
+
+      for ( const auto& c : cover )
+      {
+        assert( c.second.size() == 1 );
+
+        auto const output = c.second[0u];
+        assert( output == '0' || output == '1' );
+        assert( output == first_output_value );
+        (void)first_output_value;
+
+        if ( output == '1' )
+        {
+          minterms.emplace_back( kitty::cube( c.first ) );
+        }
+        else if ( output == '0' )
+        {
+          maxterms.emplace_back( ~kitty::cube( c.first ) );
+        }
+      }
+
+      assert( minterms.size() == 0u || maxterms.size() == 0u );
+
+      kitty::dynamic_truth_table tt( int( inputs.size() ) );
+      if ( minterms.size() != 0 )
+      {
+        kitty::create_from_cubes( tt, minterms, false );
+      }
+      else if ( maxterms.size() != 0 )
+      {
+        kitty::create_from_clauses( tt, maxterms, false );
+      }
+      std::vector<signal<Ntk>> input_signals;
+      for ( const auto& i : inputs )
+      {
+        assert( signals.find( i ) != signals.end() );
+        input_signals.push_back( signals.at( i ) );
+      }
+      signals[output] = ntk_.create_node( input_signals, tt );
+    }
+  }
+
+  virtual void on_end() const override {}
+
+  virtual void on_comment( const std::string& comment ) const override
+  {
+    (void)comment;
+  }
+
+private:
+  Ntk& ntk_;
+
+  mutable std::map<std::string, signal<Ntk>> signals;
+  mutable std::vector<std::string> outputs;
+  mutable std::vector<std::string> latches;
+}; /* blif_reader */
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/io/bristol_reader.hpp b/include/mockturtle/io/bristol_reader.hpp
new file mode 100644
index 0000000..49e0610
--- /dev/null
+++ b/include/mockturtle/io/bristol_reader.hpp
@@ -0,0 +1,149 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file bristol_reader.hpp
+  \brief Lorina reader for Bristol files
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include <fmt/format.h>
+#include <lorina/bristol.hpp>
+
+#include "../traits.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Lorina reader callback for Bristol files.
+ *
+ * **Required network functions:**
+ * - `create_pi`
+ * - `create_po`
+ * - `create_and`
+ * - `create_xor`
+ * - `create_not`
+ * - `get_constant`
+ *
+   \verbatim embed:rst
+   Example
+   .. code-block:: c++
+      xag_network xag;
+      lorina::read_bristol( "file.txt", bristol_reader( xag ) );
+   \endverbatim
+ */
+template<typename Ntk>
+class bristol_reader : public lorina::bristol_reader
+{
+public:
+  explicit bristol_reader( Ntk& ntk )
+      : ntk_( ntk )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_create_pi_v<Ntk>, "Ntk does not implement the create_pi function" );
+    static_assert( has_create_po_v<Ntk>, "Ntk does not implement the create_po function" );
+    static_assert( has_create_and_v<Ntk>, "Ntk does not implement the create_and function" );
+    static_assert( has_create_xor_v<Ntk>, "Ntk does not implement the create_xor function" );
+    static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not function" );
+    static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant function" );
+  }
+
+  ~bristol_reader()
+  {
+  }
+
+  virtual void on_header( uint32_t num_gates, uint32_t num_wires, uint32_t num_inputs, std::vector<uint32_t> const& num_wires_per_input, uint32_t num_outputs, std::vector<uint32_t> const& num_wires_per_output ) const override
+  {
+    (void)num_inputs;
+    (void)num_outputs;
+
+    const auto num_pis = std::accumulate( num_wires_per_input.begin(), num_wires_per_input.end(), 0u );
+    num_pos_ = std::accumulate( num_wires_per_output.begin(), num_wires_per_output.end(), 0u );
+    num_gates_ = num_gates;
+    gate_ctr_ = 0u;
+    signal_.resize( num_wires );
+
+    for ( auto i = 0u; i < num_pis; ++i )
+    {
+      signal_[i] = ntk_.create_pi();
+    }
+  }
+
+  virtual void on_gate( std::vector<uint32_t> const& in, uint32_t out, std::string const& gate ) const override
+  {
+    if ( gate == "XOR" )
+    {
+      signal_[out] = ntk_.create_xor( signal_[in[0]], signal_[in[1]] );
+    }
+    else if ( gate == "AND" )
+    {
+      signal_[out] = ntk_.create_and( signal_[in[0]], signal_[in[1]] );
+    }
+    else if ( gate == "INV" )
+    {
+      signal_[out] = ntk_.create_not( signal_[in[0]] );
+    }
+    else if ( gate == "EQW" )
+    {
+      signal_[out] = signal_[in[0]];
+    }
+    else
+    {
+      fmt::print( "[e] unknown {} gate {} with {} inputs!", gate, out, in.size() );
+      std::abort();
+    }
+
+    ++gate_ctr_;
+
+    if ( gate_ctr_ == num_gates_ )
+    {
+      for ( auto i = signal_.size() - num_pos_; i < signal_.size(); ++i )
+      {
+        ntk_.create_po( signal_[i] );
+      }
+    }
+    else if ( gate_ctr_ > num_gates_ )
+    {
+      fmt::print( "[w] adding dangling {} gate with inputs {} and output {}\n", gate, fmt::join( in, ", " ), out );
+    }
+  }
+
+private:
+  Ntk& ntk_;
+
+  mutable uint32_t num_pos_;
+  mutable uint32_t num_gates_;
+  mutable uint32_t gate_ctr_;
+  mutable std::vector<signal<Ntk>> signal_;
+}; /* bristol_reader */
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/io/dimacs_reader.hpp b/include/mockturtle/io/dimacs_reader.hpp
new file mode 100644
index 0000000..1378472
--- /dev/null
+++ b/include/mockturtle/io/dimacs_reader.hpp
@@ -0,0 +1,113 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file dimacs_reader.hpp
+  \brief Lorina reader for DIMACS files
+
+  \author Bruno Schmitt
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+#include <lorina/dimacs.hpp>
+
+namespace mockturtle
+{
+
+/*! \brief Lorina reader callback for DIMACS files.
+ *
+ * **Required network functions:**
+ * - `create_pi`
+ * - `create_po`
+ * - `create_not`
+ * - `create_nary_and`
+ * - `create_nary_or`
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      xag_network xag;
+      lorina::read_dimacs( "file.cnf", dimacs_reader( xag ) );
+   \endverbatim
+ */
+template<typename Ntk>
+class dimacs_reader : public lorina::dimacs_reader
+{
+public:
+  explicit dimacs_reader( Ntk& ntk ) : _ntk( ntk )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_create_pi_v<Ntk>, "Ntk does not implement the create_pi function" );
+    static_assert( has_create_po_v<Ntk>, "Ntk does not implement the create_po function" );
+    static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not function" );
+    static_assert( has_create_nary_and_v<Ntk>, "Ntk does not implement the create_nary_and function" );
+    static_assert( has_create_nary_or_v<Ntk>, "Ntk does not implement the create_nary_or function" );
+  }
+
+  void on_number_of_variables( uint64_t number_of_inputs ) const override
+  {
+    _pis.resize( number_of_inputs );
+    std::generate( _pis.begin(), _pis.end(), [this]() { return _ntk.create_pi(); } );
+  }
+
+  void on_clause( const std::vector<int>& clause ) const override
+  {
+    std::vector<signal<Ntk>> literals;
+
+    for ( int lit : clause )
+    {
+      uint32_t var = std::abs( lit ) - 1;
+      if ( lit < 0 )
+      {
+        literals.push_back( !_pis.at( var ) );
+      }
+      else
+      {
+        literals.push_back( _pis.at( var ) );
+      }
+    }
+
+    const auto sum = _ntk.create_nary_or( literals );
+    _sums.push_back( sum );
+  }
+
+  void on_end() const override
+  {
+    const auto output = _ntk.create_nary_and( _sums );
+    _ntk.create_po( output );
+  }
+
+private:
+  Ntk& _ntk;
+  mutable std::vector<signal<Ntk>> _pis;
+  mutable std::vector<signal<Ntk>> _sums;
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/io/genlib_reader.hpp b/include/mockturtle/io/genlib_reader.hpp
new file mode 100644
index 0000000..1a3faae
--- /dev/null
+++ b/include/mockturtle/io/genlib_reader.hpp
@@ -0,0 +1,169 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file genlib_reader.hpp
+  \brief Reader visitor for GENLIB files
+
+  \author Alessandro Tempia Calvino
+  \author Heinz Riener
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+
+#include <fmt/format.h>
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <lorina/genlib.hpp>
+
+namespace mockturtle
+{
+
+enum class phase_type : uint8_t
+{
+  INV = 0,
+  NONINV = 1,
+  UNKNOWN = 2,
+};
+
+struct pin
+{
+  std::string name;
+  phase_type phase;
+  double input_load;
+  double max_load;
+  double rise_block_delay;
+  double rise_fanout_delay;
+  double fall_block_delay;
+  double fall_fanout_delay;
+}; /* pin */
+
+struct gate
+{
+  unsigned int id;
+  std::string name;
+  std::string expression;
+  uint32_t num_vars;
+  kitty::dynamic_truth_table function;
+  double area;
+  std::vector<pin> pins;
+  std::string output_name;
+}; /* gate */
+
+/*! \brief lorina callbacks for GENLIB files.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      std::vector<gate> gates;
+      lorina::read_genlib( "file.genlib", genlib_reader( gates ) );
+   \endverbatim
+ */
+class genlib_reader : public lorina::genlib_reader
+{
+public:
+  explicit genlib_reader( std::vector<gate>& gates )
+      : gates( gates )
+  {}
+
+  virtual void on_gate( std::string const& name, std::string const& expression, double area, std::vector<lorina::pin_spec> const& ps, std::string const& output_pin ) const override
+  {
+    std::vector<pin> pp;
+    std::vector<std::string> pin_names;
+
+    if ( ps.size() == 1 && ps[0].name == "*" )
+    {
+      /* pins not defined, use names and appearance order of the expression */
+      std::vector<std::string> tokens;
+      std::string const delimitators{ " ()!\'*&+|^\t\r\n" };
+      std::size_t prev = 0, pos;
+      while ( ( pos = expression.find_first_of( delimitators, prev ) ) != std::string::npos )
+      {
+        if ( pos > prev )
+        {
+          tokens.emplace_back( expression.substr( prev, pos - prev ) );
+        }
+        prev = pos + 1;
+      }
+      if ( prev < expression.length() )
+      {
+        tokens.emplace_back( expression.substr( prev, std::string::npos ) );
+      }
+      for ( auto const& pin_name : tokens )
+      {
+        if ( std::find( pin_names.begin(), pin_names.end(), pin_name ) == pin_names.end() )
+        {
+          pp.emplace_back( pin{ pin_name,
+                                phase_type( static_cast<uint8_t>( ps[0].phase ) ),
+                                ps[0].input_load, ps[0].max_load,
+                                ps[0].rise_block_delay, ps[0].rise_fanout_delay, ps[0].fall_block_delay, ps[0].fall_fanout_delay } );
+          pin_names.push_back( pin_name );
+        }
+      }
+    }
+    else
+    {
+      for ( const auto& p : ps )
+      {
+        pp.emplace_back( pin{ p.name,
+                              phase_type( static_cast<uint8_t>( p.phase ) ),
+                              p.input_load, p.max_load,
+                              p.rise_block_delay, p.rise_fanout_delay, p.fall_block_delay, p.fall_fanout_delay } );
+        pin_names.push_back( p.name );
+      }
+    }
+
+    /* replace possible CONST0 or CONST1 by 0 and 1 */
+    std::string formula( expression );
+    std::size_t found = formula.find( "CONST" );
+    if ( found != std::string::npos )
+    {
+      formula.erase( found, found + 5 );
+    }
+
+    uint32_t num_vars = pin_names.size();
+
+    kitty::dynamic_truth_table tt{ num_vars };
+
+    if ( !kitty::create_from_formula( tt, formula, pin_names ) )
+    {
+      /* formula error, skip gate */
+      return;
+    }
+
+    gates.emplace_back( gate{ static_cast<unsigned int>( gates.size() ), name,
+                              expression, num_vars, tt, area, pp, output_pin } );
+  }
+
+protected:
+  std::vector<gate>& gates;
+}; /* genlib_reader */
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/io/pla_reader.hpp b/include/mockturtle/io/pla_reader.hpp
new file mode 100644
index 0000000..558ed44
--- /dev/null
+++ b/include/mockturtle/io/pla_reader.hpp
@@ -0,0 +1,154 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file pla_reader.hpp
+  \brief Lorina reader for PLA files
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+#include <lorina/pla.hpp>
+
+namespace mockturtle
+{
+
+/*! \brief Lorina reader callback for PLA files.
+ *
+ * **Required network functions:**
+ * - `create_pi`
+ * - `create_po`
+ * - `create_not`
+ * - `create_nary_and`
+ * - `create_nary_or`
+ * - `create_nary_xor`
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      aig_network aig;
+      lorina::read_pla( "file.pla", pla_reader( aig ) );
+
+      mig_network mig;
+      lorina::read_pla( "file.pla", pla_reader( mig ) );
+   \endverbatim
+ */
+template<typename Ntk>
+class pla_reader : public lorina::pla_reader
+{
+public:
+  explicit pla_reader( Ntk& ntk ) : _ntk( ntk )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_create_pi_v<Ntk>, "Ntk does not implement the create_pi function" );
+    static_assert( has_create_po_v<Ntk>, "Ntk does not implement the create_po function" );
+    static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not function" );
+    static_assert( has_create_nary_and_v<Ntk>, "Ntk does not implement the create_nary_and function" );
+    static_assert( has_create_nary_or_v<Ntk>, "Ntk does not implement the create_nary_or function" );
+    static_assert( has_create_nary_xor_v<Ntk>, "Ntk does not implement the create_nary_xor function" );
+  }
+
+  void on_number_of_inputs( uint64_t number_of_inputs ) const override
+  {
+    _pis.resize( number_of_inputs );
+    std::generate( _pis.begin(), _pis.end(), [this]() { return _ntk.create_pi(); } );
+  }
+
+  void on_number_of_outputs( uint64_t number_of_outputs ) const override
+  {
+    _products.resize( number_of_outputs );
+  }
+
+  bool on_keyword( const std::string& keyword, const std::string& value ) const override
+  {
+    if ( keyword == "type" && value == "esop" )
+    {
+      _is_xor = true;
+      return true;
+    }
+    return false;
+  }
+
+  void on_end() const override
+  {
+    for ( auto const& v : _products )
+    {
+      _ntk.create_po( _is_xor ? _ntk.create_nary_xor( v ) : _ntk.create_nary_or( v ) );
+    }
+  }
+
+  void on_term( const std::string& term, const std::string& out ) const override
+  {
+    std::vector<signal<Ntk>> literals;
+    for ( auto i = 0u; i < term.size(); ++i )
+    {
+      switch ( term[i] )
+      {
+      default:
+        std::cerr << "[w] unknown character '" << term[i] << "' in PLA input term, treat as don't care\n";
+      case '-':
+        break;
+
+      case '0':
+        literals.push_back( _ntk.create_not( _pis[i] ) );
+        break;
+      case '1':
+        literals.push_back( _pis[i] );
+        break;
+      }
+    }
+
+    const auto product = _ntk.create_nary_and( literals );
+    for ( auto i = 0u; i < out.size(); ++i )
+    {
+      switch ( out[i] )
+      {
+      default:
+        std::cerr << "[w] unknown character '" << out[i] << "' in PLA output term, treat is 0\n";
+      case '0':
+        break;
+
+      case '1':
+        _products[i].push_back( product );
+        break;
+      }
+    }
+  }
+
+private:
+  Ntk& _ntk;
+  mutable std::vector<signal<Ntk>> _pis;
+  mutable std::vector<std::vector<signal<Ntk>>> _products;
+  mutable bool _is_xor{ false };
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/io/serialize.hpp b/include/mockturtle/io/serialize.hpp
new file mode 100644
index 0000000..b02a1a5
--- /dev/null
+++ b/include/mockturtle/io/serialize.hpp
@@ -0,0 +1,377 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file serialize.hpp
+  \brief Serialize network into a file
+
+  \author Bruno Schmitt
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+
+  This file implements functions to serialize a (combinational)
+  `aig_network` into a file.  The serializer should be used for
+  debugging-purpose only.  It allows to store the current state of the
+  network (including dangling and dead nodes), but does not guarantee
+  platform-independence (use, e.g., `write_verilog` instead).
+*/
+
+#pragma once
+
+#include "../networks/aig.hpp"
+#include <fstream>
+#include <optional>
+#include <parallel_hashmap/phmap_dump.h>
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+struct serializer
+{
+public:
+  using node_type = typename aig_network::storage::element_type::node_type;
+  using pointer_type = typename node_type::pointer_type;
+
+public:
+  bool operator()( phmap::BinaryOutputArchive& os, uint64_t const& data ) const
+  {
+    return os.dump( (char*)&data, sizeof( uint64_t ) );
+  }
+
+  bool operator()( phmap::BinaryInputArchive& ar_input, uint64_t* data ) const
+  {
+    return ar_input.load( (char*)data, sizeof( uint64_t ) );
+  }
+
+  template<int PointerFieldSize>
+  bool operator()( phmap::BinaryOutputArchive& os, node_pointer<PointerFieldSize> const& ptr ) const
+  {
+    return os.dump( (char*)&ptr.data, sizeof( ptr.data ) );
+  }
+
+  template<int PointerFieldSize>
+  bool operator()( phmap::BinaryInputArchive& ar_input, node_pointer<PointerFieldSize>* ptr ) const
+  {
+    return ar_input.load( (char*)&ptr->data, sizeof( ptr->data ) );
+  }
+
+  bool operator()( phmap::BinaryOutputArchive& os, cauint64_t const& data ) const
+  {
+    return os.dump( (char*)&data.n, sizeof( data.n ) );
+  }
+
+  bool operator()( phmap::BinaryInputArchive& ar_input, cauint64_t* data ) const
+  {
+    return ar_input.load( (char*)&data->n, sizeof( data->n ) );
+  }
+
+  template<int Fanin, int Size, int PointerFieldSize>
+  bool operator()( phmap::BinaryOutputArchive& os, regular_node<Fanin, Size, PointerFieldSize> const& n ) const
+  {
+    uint64_t size = n.children.size();
+    if ( !os.dump( (char*)&size, sizeof( uint64_t ) ) )
+    {
+      return false;
+    }
+
+    for ( const auto& c : n.children )
+    {
+      bool result = this->operator()( os, c );
+      if ( !result )
+      {
+        return false;
+      }
+    }
+
+    size = n.data.size();
+    if ( !os.dump( (char*)&size, sizeof( uint64_t ) ) )
+    {
+      return false;
+    }
+    for ( const auto& d : n.data )
+    {
+      bool result = this->operator()( os, d );
+      if ( !result )
+      {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  template<int Fanin, int Size, int PointerFieldSize>
+  bool operator()( phmap::BinaryInputArchive& ar_input, const regular_node<Fanin, Size, PointerFieldSize>* n ) const
+  {
+    uint64_t size;
+    if ( !ar_input.load( (char*)&size, sizeof( uint64_t ) ) )
+    {
+      return false;
+    }
+
+    for ( uint64_t i = 0; i < size; ++i )
+    {
+      pointer_type ptr;
+      bool result = this->operator()( ar_input, &ptr );
+      if ( !result )
+      {
+        return false;
+      }
+      const_cast<regular_node<Fanin, Size, PointerFieldSize>*>( n )->children[i] = ptr;
+    }
+
+    ar_input.load( (char*)&size, sizeof( uint64_t ) );
+    for ( uint64_t i = 0; i < size; ++i )
+    {
+      cauint64_t data;
+      bool result = this->operator()( ar_input, &data );
+      if ( !result )
+      {
+        return false;
+      }
+      const_cast<regular_node<Fanin, Size, PointerFieldSize>*>( n )->data[i] = data;
+    }
+
+    return true;
+  }
+
+  bool operator()( phmap::BinaryOutputArchive& os, std::pair<const node_type, uint64_t> const& value ) const
+  {
+    return this->operator()( os, value.first ) && this->operator()( os, value.second );
+  }
+
+  bool operator()( phmap::BinaryInputArchive& ar_input, std::pair<const node_type, uint64_t>* value ) const
+  {
+    return this->operator()( ar_input, &value->first ) && this->operator()( ar_input, &value->second );
+  }
+
+  bool operator()( phmap::BinaryOutputArchive& os, aig_storage const& storage ) const
+  {
+    /* nodes */
+    uint64_t size = storage.nodes.size();
+    if ( !os.dump( (char*)&size, sizeof( uint64_t ) ) )
+    {
+      return false;
+    }
+    for ( const auto& n : storage.nodes )
+    {
+      if ( !this->operator()( os, n ) )
+      {
+        return false;
+      }
+    }
+
+    /* inputs */
+    size = storage.inputs.size();
+    if ( !os.dump( (char*)&size, sizeof( uint64_t ) ) )
+    {
+      return false;
+    }
+    for ( const auto& i : storage.inputs )
+    {
+      if ( !this->operator()( os, i ) )
+      {
+        return false;
+      }
+    }
+
+    /* outputs */
+    size = storage.outputs.size();
+    if ( !os.dump( (char*)&size, sizeof( uint64_t ) ) )
+    {
+      return false;
+    }
+    for ( const auto& o : storage.outputs )
+    {
+      if ( !this->operator()( os, o ) )
+      {
+        return false;
+      }
+    }
+
+    /* hash */
+    if ( !const_cast<aig_storage&>( storage ).hash.dump( os ) )
+    {
+      return false;
+    }
+
+    if ( !os.dump( (char*)&storage.trav_id, sizeof( uint32_t ) ) )
+    {
+      return false;
+    }
+
+    return true;
+  }
+
+  bool operator()( phmap::BinaryInputArchive& ar_input, aig_storage* storage ) const
+  {
+    /* nodes */
+    uint64_t size;
+    if ( !ar_input.load( (char*)&size, sizeof( uint64_t ) ) )
+    {
+      return false;
+    }
+    for ( uint64_t i = 0; i < size; ++i )
+    {
+      node_type n;
+      if ( !this->operator()( ar_input, &n ) )
+      {
+        return false;
+      }
+      storage->nodes.push_back( n );
+    }
+
+    /* inputs */
+    if ( !ar_input.load( (char*)&size, sizeof( uint64_t ) ) )
+    {
+      return false;
+    }
+    for ( uint64_t i = 0; i < size; ++i )
+    {
+      uint64_t value;
+      if ( !ar_input.load( (char*)&value, sizeof( uint64_t ) ) )
+      {
+        return false;
+      }
+      storage->inputs.push_back( value );
+    }
+
+    /* outputs */
+    if ( !ar_input.load( (char*)&size, sizeof( uint64_t ) ) )
+    {
+      return false;
+    }
+    for ( uint64_t i = 0; i < size; ++i )
+    {
+      pointer_type ptr;
+      if ( !this->operator()( ar_input, &ptr ) )
+      {
+        return false;
+      }
+      storage->outputs.push_back( ptr );
+    }
+
+    /* hash */
+    if ( !storage->hash.load( ar_input ) )
+    {
+      return false;
+    }
+
+    if ( !ar_input.load( (char*)&storage->trav_id, sizeof( uint32_t ) ) )
+    {
+      return false;
+    }
+
+    return true;
+  }
+}; /* struct serializer */
+
+} /* namespace detail */
+
+/*! \brief Serializes a combinational AIG network to a archive, returning false on failure
+ *
+ * \param aig Combinational AIG network
+ * \param os Output archive
+ */
+inline bool serialize_network_fallible( aig_network const& aig, phmap::BinaryOutputArchive& os )
+{
+  detail::serializer _serializer;
+  return _serializer( os, *aig._storage );
+}
+
+/*! \brief Serializes a combinational AIG network to a archive
+ *
+ * \param aig Combinational AIG network
+ * \param os Output archive
+ */
+inline void serialize_network( aig_network const& aig, phmap::BinaryOutputArchive& os )
+{
+  bool const okay = serialize_network_fallible( aig, os );
+  (void)okay;
+  assert( okay && "failed to serialize the network onto stream" );
+}
+
+/*! \brief Serializes a combinational AIG network in a file
+ *
+ * \param aig Combinational AIG network
+ * \param filename Filename
+ */
+inline void serialize_network( aig_network const& aig, std::string const& filename )
+{
+  phmap::BinaryOutputArchive ar_out( filename.c_str() );
+  serialize_network( aig, ar_out );
+}
+
+/*! \brief Deserializes a combinational AIG network from a input archive, returning nullopt on failure
+ *
+ * \param ar_input Input archive
+ * \return Deserialized AIG network
+ */
+inline std::optional<aig_network> deserialize_network_fallible( phmap::BinaryInputArchive& ar_input )
+{
+  detail::serializer _serializer;
+  auto storage = std::make_shared<aig_storage>();
+  storage->nodes.clear();
+  storage->inputs.clear();
+  storage->outputs.clear();
+  storage->hash.clear();
+
+  if ( _serializer( ar_input, storage.get() ) )
+  {
+    return aig_network{ storage };
+  }
+
+  return std::nullopt;
+}
+
+/*! \brief Deserializes a combinational AIG network from a input archive
+ *
+ * \param ar_input Input archive
+ * \return Deserialized AIG network
+ */
+inline aig_network deserialize_network( phmap::BinaryInputArchive& ar_input )
+{
+  auto result = deserialize_network_fallible( ar_input );
+  (void)result.has_value();
+  assert( result.has_value() && "failed to deserialize the network onto stream" );
+  return *result;
+}
+
+/*! \brief Deserializes a combinational AIG network from a file
+ *
+ * \param filename Filename
+ * \return Deserialized AIG network
+ */
+inline aig_network deserialize_network( std::string const& filename )
+{
+  phmap::BinaryInputArchive ar_input( filename.c_str() );
+  auto aig = deserialize_network( ar_input );
+  return aig;
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/io/super_reader.hpp b/include/mockturtle/io/super_reader.hpp
new file mode 100644
index 0000000..335dbf6
--- /dev/null
+++ b/include/mockturtle/io/super_reader.hpp
@@ -0,0 +1,103 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file super_reader.hpp
+  \brief Reader visitor for SUPER files generated by ABC
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+
+#include <fmt/format.h>
+#include <lorina/super.hpp>
+
+namespace mockturtle
+{
+
+struct supergate_spec
+{
+  unsigned int id;
+  std::string name{};
+  bool is_super{ false };
+  std::vector<uint32_t> fanin_id;
+};
+
+struct super_lib
+{
+  std::string genlib_name{};
+  uint32_t max_num_vars{ 0u };
+  uint32_t num_supergates{ 0u };
+  uint32_t num_lines{ 0 };
+  std::vector<supergate_spec> supergates{};
+};
+
+/*! \brief lorina callbacks for SUPER files.
+ *
+ * SUPER files can be generated by ABC with the command `super`.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      super_lib supergates_spec;
+      lorina::read_super( "file.super", super_reader( supergates_spec ) );
+   \endverbatim
+ */
+class super_reader : public lorina::super_reader
+{
+public:
+  explicit super_reader( super_lib& lib )
+      : lib( lib )
+  {
+  }
+
+  virtual void on_super_info( std::string const& genlib_name, uint32_t max_num_vars, uint32_t max_superGates, uint32_t num_lines ) const override
+  {
+    lib.genlib_name = genlib_name;
+    lib.max_num_vars = max_num_vars;
+    lib.num_supergates = max_superGates;
+    lib.num_lines = num_lines;
+  }
+
+  virtual void on_supergate( std::string const& name, bool const& is_super, std::vector<uint32_t> const& fanins_id ) const override
+  {
+
+    lib.supergates.emplace_back( supergate_spec{ static_cast<unsigned int>( lib.supergates.size() ),
+                                                 name,
+                                                 is_super,
+                                                 fanins_id } );
+  }
+
+protected:
+  super_lib& lib;
+}; /* super_reader */
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/io/verilog_reader.hpp b/include/mockturtle/io/verilog_reader.hpp
new file mode 100644
index 0000000..1f8c851
--- /dev/null
+++ b/include/mockturtle/io/verilog_reader.hpp
@@ -0,0 +1,636 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file verilog_reader.hpp
+  \brief Lorina reader for VERILOG files
+
+  \author Heinz Riener
+  \author Marcel Walter
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cctype>
+#include <iostream>
+#include <map>
+#include <regex>
+#include <string>
+#include <vector>
+
+#include <fmt/format.h>
+#include <lorina/verilog.hpp>
+
+#include "../generators/arithmetic.hpp"
+#include "../generators/modular_arithmetic.hpp"
+#include "../traits.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Lorina reader callback for VERILOG files.
+ *
+ * **Required network functions:**
+ * - `create_pi`
+ * - `create_po`
+ * - `get_constant`
+ * - `create_not`
+ * - `create_and`
+ * - `create_or`
+ * - `create_xor`
+ * - `create_maj`
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      mig_network mig;
+      lorina::read_verilog( "file.v", verilog_reader( mig ) );
+   \endverbatim
+ */
+template<typename Ntk>
+class verilog_reader : public lorina::verilog_reader
+{
+public:
+  explicit verilog_reader( Ntk& ntk, std::string const& top_module_name = "top" ) : ntk_( ntk ), top_module_name_( top_module_name )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_create_pi_v<Ntk>, "Ntk does not implement the create_pi function" );
+    static_assert( has_create_po_v<Ntk>, "Ntk does not implement the create_po function" );
+    static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant function" );
+    static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not function" );
+    static_assert( has_create_and_v<Ntk>, "Ntk does not implement the create_and function" );
+    static_assert( has_create_or_v<Ntk>, "Ntk does not implement the create_or function" );
+    static_assert( has_create_xor_v<Ntk>, "Ntk does not implement the create_xor function" );
+    static_assert( has_create_ite_v<Ntk>, "Ntk does not implement the create_ite function" );
+    static_assert( has_create_maj_v<Ntk>, "Ntk does not implement the create_maj function" );
+
+    signals_["0"] = ntk_.get_constant( false );
+    signals_["1"] = ntk_.get_constant( true );
+    signals_["1'b0"] = ntk_.get_constant( false );
+    signals_["1'b1"] = ntk_.get_constant( true );
+  }
+
+  void on_module_header( const std::string& module_name, const std::vector<std::string>& inouts ) const override
+  {
+    (void)inouts;
+    if constexpr ( has_set_network_name_v<Ntk> )
+    {
+      ntk_.set_network_name( module_name );
+    }
+
+    name_ = module_name;
+  }
+
+  void on_inputs( const std::vector<std::string>& names, std::string const& size = "" ) const override
+  {
+    (void)size;
+    if ( name_ != top_module_name_ )
+      return;
+
+    for ( const auto& name : names )
+    {
+      if ( size.empty() )
+      {
+        signals_[name] = ntk_.create_pi();
+        input_names_.emplace_back( name, 1u );
+        if constexpr ( has_set_name_v<Ntk> )
+        {
+          ntk_.set_name( signals_[name], name );
+        }
+      }
+      else
+      {
+        std::vector<signal<Ntk>> word;
+        const auto length = parse_size( size );
+        for ( auto i = 0u; i < length; ++i )
+        {
+          const auto sname = fmt::format( "{}[{}]", name, i );
+          word.push_back( ntk_.create_pi() );
+          signals_[sname] = word.back();
+          if constexpr ( has_set_name_v<Ntk> )
+          {
+            ntk_.set_name( signals_[sname], sname );
+          }
+        }
+        registers_[name] = word;
+        input_names_.emplace_back( name, length );
+      }
+    }
+  }
+
+  void on_outputs( const std::vector<std::string>& names, std::string const& size = "" ) const override
+  {
+    (void)size;
+    if ( name_ != top_module_name_ )
+      return;
+
+    for ( const auto& name : names )
+    {
+      if ( size.empty() )
+      {
+        outputs_.emplace_back( name );
+        output_names_.emplace_back( name, 1u );
+      }
+      else
+      {
+        const auto length = parse_size( size );
+        for ( auto i = 0u; i < length; ++i )
+        {
+          outputs_.emplace_back( fmt::format( "{}[{}]", name, i ) );
+        }
+        output_names_.emplace_back( name, length );
+      }
+    }
+  }
+
+  void on_assign( const std::string& lhs, const std::pair<std::string, bool>& rhs ) const override
+  {
+    if ( name_ != top_module_name_ )
+      return;
+
+    if ( signals_.find( rhs.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", rhs.first );
+
+    auto r = signals_[rhs.first];
+    signals_[lhs] = rhs.second ? ntk_.create_not( r ) : r;
+  }
+
+  void on_nand( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2 ) const override
+  {
+    if ( name_ != top_module_name_ )
+      return;
+
+    if ( signals_.find( op1.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op1.first );
+    if ( signals_.find( op2.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op2.first );
+
+    auto a = signals_[op1.first];
+    auto b = signals_[op2.first];
+    signals_[lhs] = ntk_.create_nand( op1.second ? ntk_.create_not( a ) : a, op2.second ? ntk_.create_not( b ) : b );
+  }
+
+  void on_and( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2 ) const override
+  {
+    if ( name_ != top_module_name_ )
+      return;
+
+    if ( signals_.find( op1.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op1.first );
+    if ( signals_.find( op2.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op2.first );
+
+    auto a = signals_[op1.first];
+    auto b = signals_[op2.first];
+    if constexpr ( is_crossed_network_type_v<Ntk> )
+    {
+      if ( !op1.second && !op2.second )
+        signals_[lhs] = ntk_.create_and( a, b );
+      else if ( !op1.second && op2.second )
+        signals_[lhs] = ntk_.create_gt( a, b ); // a & !b
+      else if ( op1.second && !op2.second )
+        signals_[lhs] = ntk_.create_lt( a, b ); // !a & b
+      else
+        signals_[lhs] = ntk_.create_nor( a, b ); // !a & !b = !(a | b)
+    }
+    else
+    {
+      signals_[lhs] = ntk_.create_and( op1.second ? ntk_.create_not( a ) : a, op2.second ? ntk_.create_not( b ) : b );
+    }
+  }
+
+  void on_or( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2 ) const override
+  {
+    if ( name_ != top_module_name_ )
+      return;
+
+    if ( signals_.find( op1.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op1.first );
+    if ( signals_.find( op2.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op2.first );
+
+    auto a = signals_[op1.first];
+    auto b = signals_[op2.first];
+    if constexpr ( is_crossed_network_type_v<Ntk> )
+    {
+      if ( !op1.second && !op2.second )
+        signals_[lhs] = ntk_.create_or( a, b );
+      else if ( !op1.second && op2.second )
+        signals_[lhs] = ntk_.create_ge( a, b ); // a | !b
+      else if ( op1.second && !op2.second )
+        signals_[lhs] = ntk_.create_le( a, b ); // !a | b
+      else
+        signals_[lhs] = ntk_.create_nand( a, b ); // !a | !b = !(a & b)
+    }
+    else
+    {
+      signals_[lhs] = ntk_.create_or( op1.second ? ntk_.create_not( a ) : a, op2.second ? ntk_.create_not( b ) : b );
+    }
+  }
+
+  void on_xor( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2 ) const override
+  {
+    if ( name_ != top_module_name_ )
+      return;
+
+    if ( signals_.find( op1.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op1.first );
+    if ( signals_.find( op2.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op2.first );
+
+    auto a = signals_[op1.first];
+    auto b = signals_[op2.first];
+    if constexpr ( is_crossed_network_type_v<Ntk> )
+    {
+      if ( !op1.second == !op2.second )
+        signals_[lhs] = ntk_.create_xor( a, b );
+      else
+        signals_[lhs] = ntk_.create_xnor( a, b );
+    }
+    else
+    {
+      signals_[lhs] = ntk_.create_xor( op1.second ? ntk_.create_not( a ) : a, op2.second ? ntk_.create_not( b ) : b );
+    }
+  }
+
+  void on_xor3( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2, const std::pair<std::string, bool>& op3 ) const override
+  {
+    if ( name_ != top_module_name_ )
+      return;
+
+    if constexpr ( is_crossed_network_type_v<Ntk> )
+    {
+      assert( false && "3-input gates in crossed_network are not supported (to be implemented)" );
+    }
+
+    if ( signals_.find( op1.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op1.first );
+    if ( signals_.find( op2.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op2.first );
+    if ( signals_.find( op3.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op3.first );
+
+    auto a = signals_[op1.first];
+    auto b = signals_[op2.first];
+    auto c = signals_[op3.first];
+
+    if constexpr ( has_create_xor3_v<Ntk> )
+    {
+      signals_[lhs] = ntk_.create_xor3( op1.second ? ntk_.create_not( a ) : a, op2.second ? ntk_.create_not( b ) : b, op3.second ? ntk_.create_not( c ) : c );
+    }
+    else
+    {
+      signals_[lhs] = ntk_.create_xor( ntk_.create_xor( op1.second ? ntk_.create_not( a ) : a, op2.second ? ntk_.create_not( b ) : b ), op3.second ? ntk_.create_not( c ) : c );
+    }
+  }
+
+  void on_maj3( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2, const std::pair<std::string, bool>& op3 ) const override
+  {
+    if ( name_ != top_module_name_ )
+      return;
+
+    if constexpr ( is_crossed_network_type_v<Ntk> )
+    {
+      assert( false && "3-input gates in crossed_network are not supported (to be implemented)" );
+    }
+
+    if ( signals_.find( op1.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op1.first );
+    if ( signals_.find( op2.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op2.first );
+    if ( signals_.find( op3.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op3.first );
+
+    auto a = signals_[op1.first];
+    auto b = signals_[op2.first];
+    auto c = signals_[op3.first];
+    signals_[lhs] = ntk_.create_maj( op1.second ? ntk_.create_not( a ) : a, op2.second ? ntk_.create_not( b ) : b, op3.second ? ntk_.create_not( c ) : c );
+  }
+
+  void on_mux21( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2, const std::pair<std::string, bool>& op3 ) const override
+  {
+    if ( name_ != top_module_name_ )
+      return;
+
+    if constexpr ( is_crossed_network_type_v<Ntk> )
+    {
+      assert( false && "3-input gates in crossed_network are not supported (to be implemented)" );
+    }
+
+    if ( signals_.find( op1.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op1.first );
+    if ( signals_.find( op2.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op2.first );
+    if ( signals_.find( op3.first ) == signals_.end() )
+      fmt::print( stderr, "[w] undefined signal {} assigned 0\n", op3.first );
+
+    auto a = signals_[op1.first];
+    auto b = signals_[op2.first];
+    auto c = signals_[op3.first];
+    signals_[lhs] = ntk_.create_ite( op1.second ? ntk_.create_not( a ) : a, op2.second ? ntk_.create_not( b ) : b, op3.second ? ntk_.create_not( c ) : c );
+  }
+
+  void on_module_instantiation( std::string const& module_name, std::vector<std::string> const& params, std::string const& inst_name,
+                                std::vector<std::pair<std::string, std::string>> const& args ) const override
+  {
+    (void)inst_name;
+    if ( name_ != top_module_name_ )
+      return;
+
+    /* check routines */
+    const auto num_args_equals = [&]( uint32_t expected_count ) {
+      if ( args.size() != expected_count )
+      {
+        fmt::print( stderr, "[e] {} module expects {} arguments\n", module_name, expected_count );
+        return false;
+      }
+      return true;
+    };
+
+    const auto num_params_equals = [&]( uint32_t expected_count ) {
+      if ( params.size() != expected_count )
+      {
+        fmt::print( stderr, "[e] {} module expects {} parameters\n", module_name, expected_count );
+        return false;
+      }
+      return true;
+    };
+
+    const auto register_exists = [&]( std::string const& name ) {
+      if ( registers_.find( name ) == registers_.end() )
+      {
+        fmt::print( stderr, "[e] register {} does not exist\n", name );
+        return false;
+      }
+      return true;
+    };
+
+    const auto register_has_size = [&]( std::string const& name, uint32_t size ) {
+      if ( !register_exists( name ) || registers_[name].size() != size )
+      {
+        fmt::print( stderr, "[e] register {} must have size {}\n", name, size );
+        return false;
+      }
+      return true;
+    };
+
+    const auto add_register = [&]( std::string const& name, std::vector<signal<Ntk>> const& fs ) {
+      for ( auto i = 0u; i < fs.size(); ++i )
+      {
+        signals_[fmt::format( "{}[{}]", name, i )] = fs[i];
+      }
+      registers_[name] = fs;
+    };
+
+    if ( module_name == "ripple_carry_adder" )
+    {
+      if ( !num_args_equals( 3u ) )
+        return;
+      if ( !num_params_equals( 1u ) )
+        return;
+      const auto bitwidth = static_cast<uint32_t>( parse_small_value( params[0u] ) );
+      if ( !register_has_size( args[0].second, bitwidth ) )
+        return;
+      if ( !register_has_size( args[1].second, bitwidth ) )
+        return;
+
+      auto a_copy = registers_[args[0].second];
+      const auto& b = registers_[args[1].second];
+      auto carry = ntk_.get_constant( false );
+      carry_ripple_adder_inplace( ntk_, a_copy, b, carry );
+      a_copy.push_back( carry );
+      add_register( args[2].second, a_copy );
+    }
+    else if ( module_name == "montgomery_multiplier" )
+    {
+      if ( !num_args_equals( 3u ) )
+        return;
+      if ( !num_params_equals( 3u ) )
+        return;
+      const auto bitwidth = static_cast<uint32_t>( parse_small_value( params[0u] ) );
+      if ( !register_has_size( args[0].second, bitwidth ) )
+        return;
+      if ( !register_has_size( args[1].second, bitwidth ) )
+        return;
+
+      auto N = parse_value( params[1u] );
+      auto NN = parse_value( params[2u] );
+
+      N.resize( bitwidth );
+      NN.resize( bitwidth );
+
+      add_register( args[2].second, montgomery_multiplication( ntk_, registers_[args[0].second], registers_[args[1].second], N, NN ) );
+    }
+    else if ( module_name == "buffer" || module_name == "inverter" )
+    {
+      if constexpr ( is_buffered_network_type_v<Ntk> )
+      {
+        static_assert( has_create_buf_v<Ntk>, "Ntk does not implement the create_buf method" );
+        if ( !num_args_equals( 2u ) )
+          fmt::print( stderr, "[e] number of arguments of a `{}` instance is not 2\n", module_name );
+
+        signal<Ntk> fi = ntk_.get_constant( false );
+        std::string lhs;
+        for ( auto const& arg : args )
+        {
+          if ( arg.first == ".i" )
+          {
+            if ( signals_.find( arg.second ) == signals_.end() )
+              fmt::print( stderr, "[w] undefined signal {} assigned 0\n", arg.second );
+            else
+              fi = signals_[arg.second];
+          }
+          else if ( arg.first == ".o" )
+            lhs = arg.second;
+          else
+            fmt::print( stderr, "[e] unknown argument {} to a `{}` instance\n", arg.first, module_name );
+        }
+        signals_[lhs] = ntk_.create_buf( fi );
+        if ( module_name == "inverter" )
+          ntk_.invert( ntk_.get_node( signals_[lhs] ) );
+      }
+    }
+    else if ( module_name == "crossing" )
+    {
+      if constexpr ( is_crossed_network_type_v<Ntk> )
+      {
+        if ( !num_args_equals( 4u ) )
+          fmt::print( stderr, "[e] number of arguments of a `{}` instance is not 4\n", module_name );
+
+        signal<Ntk> fi1 = ntk_.get_constant( false );
+        signal<Ntk> fi2 = ntk_.get_constant( false );
+        std::string fo1, fo2;
+        for ( auto const& arg : args )
+        {
+          if ( arg.first == ".i1" )
+          {
+            if ( signals_.find( arg.second ) == signals_.end() )
+              fmt::print( stderr, "[w] undefined signal {} assigned 0\n", arg.second );
+            else
+              fi1 = signals_[arg.second];
+          }
+          else if ( arg.first == ".i2" )
+          {
+            if ( signals_.find( arg.second ) == signals_.end() )
+              fmt::print( stderr, "[w] undefined signal {} assigned 0\n", arg.second );
+            else
+              fi2 = signals_[arg.second];
+          }
+          else if ( arg.first == ".o1" )
+            fo1 = arg.second;
+          else if ( arg.first == ".o2" )
+            fo2 = arg.second;
+          else
+            fmt::print( stderr, "[e] unknown argument {} to a `{}` instance\n", arg.first, module_name );
+        }
+
+        if ( signals_.find( fo1 ) == signals_.end() ) // due to lorina bug, each crossing will be instantiated twice...
+        {
+          auto p = ntk_.create_crossing( fi1, fi2 );
+          signals_[fo1] = p.first;
+          signals_[fo2] = p.second;
+        }
+      }
+    }
+    else
+    {
+      fmt::print( stderr, "[e] unknown module name {}\n", module_name );
+    }
+  }
+
+  void on_endmodule() const override
+  {
+    if ( name_ != top_module_name_ )
+      return;
+
+    for ( auto const& o : outputs_ )
+    {
+      ntk_.create_po( signals_[o] );
+    }
+
+    if constexpr ( has_set_output_name_v<Ntk> )
+    {
+      uint32_t ctr{ 0u };
+      for ( auto const& output_name : output_names_ )
+      {
+        if ( output_name.second == 1u )
+        {
+          ntk_.set_output_name( ctr++, output_name.first );
+        }
+        else
+        {
+          for ( auto i = 0u; i < output_name.second; ++i )
+          {
+            ntk_.set_output_name( ctr++, fmt::format( "{}[{}]", output_name.first, i ) );
+          }
+        }
+      }
+      assert( ctr == ntk_.num_pos() );
+    }
+  }
+
+  const std::string& name() const
+  {
+    return name_;
+  }
+
+  const std::vector<std::pair<std::string, uint32_t>> input_names()
+  {
+    return input_names_;
+  }
+
+  const std::vector<std::pair<std::string, uint32_t>> output_names()
+  {
+    return output_names_;
+  }
+
+private:
+  std::vector<bool> parse_value( const std::string& value ) const
+  {
+    std::smatch match;
+
+    if ( std::all_of( value.begin(), value.end(), isdigit ) )
+    {
+      std::vector<bool> res( 64u );
+      bool_vector_from_dec( res, static_cast<uint64_t>( std::stoul( value ) ) );
+      return res;
+    }
+    else if ( std::regex_match( value, match, hex_string ) )
+    {
+      std::vector<bool> res( static_cast<uint64_t>( std::stoul( match.str( 1 ) ) ) );
+      bool_vector_from_hex( res, match.str( 2 ) );
+      return res;
+    }
+    else
+    {
+      fmt::print( stderr, "[e] cannot parse number '{}'\n", value );
+    }
+    assert( false );
+    return {};
+  }
+
+  uint64_t parse_small_value( const std::string& value ) const
+  {
+    return bool_vector_to_long( parse_value( value ) );
+  }
+
+  uint32_t parse_size( const std::string& size ) const
+  {
+    if ( size.empty() )
+    {
+      return 1u;
+    }
+
+    if ( auto const l = size.size(); l > 2 && size[l - 2] == ':' && size[l - 1] == '0' )
+    {
+      return static_cast<uint32_t>( parse_small_value( size.substr( 0u, l - 2 ) ) + 1u );
+    }
+
+    assert( false );
+    return 0u;
+  }
+
+private:
+  Ntk& ntk_;
+
+  std::string const top_module_name_;
+
+  mutable std::map<std::string, signal<Ntk>> signals_;
+  mutable std::map<std::string, std::vector<signal<Ntk>>> registers_;
+  mutable std::vector<std::string> outputs_;
+  mutable std::string name_;
+  mutable std::vector<std::pair<std::string, uint32_t>> input_names_;
+  mutable std::vector<std::pair<std::string, uint32_t>> output_names_;
+
+  std::regex hex_string{ "(\\d+)'h([0-9a-fA-F]+)" };
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/io/write_aiger.hpp b/include/mockturtle/io/write_aiger.hpp
new file mode 100644
index 0000000..621b364
--- /dev/null
+++ b/include/mockturtle/io/write_aiger.hpp
@@ -0,0 +1,199 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file write_aiger.hpp
+  \brief Write networks to AIGER format
+
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+
+  A detailed description of the (binary) AIGER format and its encoding is available at [1].
+
+  [1] http://fmv.jku.at/aiger/
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+
+#include <cstdio>
+#include <fstream>
+#include <iostream>
+#include <cstring>
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+inline void encode( std::vector<unsigned char>& buffer, uint32_t lit )
+{
+  unsigned char ch;
+  while ( lit & ~0x7f )
+  {
+    ch = ( lit & 0x7f ) | 0x80;
+    buffer.push_back( ch );
+    lit >>= 7;
+  }
+  ch = lit;
+  buffer.push_back( ch );
+}
+
+} // namespace detail
+
+/*! \brief Writes a combinational AIG network in binary AIGER format into a file
+ *
+ * This function should be only called on "clean" aig_networks, e.g.,
+ * immediately after `cleanup_dangling`.
+ *
+ * **Required network functions:**
+ * - `num_cis`
+ * - `num_cos`
+ * - `foreach_gate`
+ * - `foreach_fanin`
+ * - `foreach_po`
+ * - `get_node`
+ * - `is_complemented`
+ * - `node_to_index`
+ *
+ * \param aig Combinational AIG network
+ * \param os Output stream
+ */
+template<typename Ntk>
+inline void write_aiger( Ntk const& aig, std::ostream& os )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_num_cis_v<Ntk>, "Ntk does not implement the num_cis method" );
+  static_assert( has_num_cos_v<Ntk>, "Ntk does not implement the num_cos method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+
+  assert( aig.is_combinational() && "Network has to be combinational" );
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  uint32_t const M = aig.num_cis() + aig.num_gates();
+
+  /* HEADER */
+  char string_buffer[1024];
+  sprintf( string_buffer, "aig %u %u %u %u %u\n", M, aig.num_pis(), /*latches*/ 0, aig.num_pos(), aig.num_gates() );
+  os.write( &string_buffer[0], sizeof( unsigned char ) * std::strlen( string_buffer ) );
+
+  /* POs */
+  aig.foreach_po( [&]( signal const& f ) {
+    sprintf( string_buffer, "%u\n", uint32_t( 2 * aig.node_to_index( aig.get_node( f ) ) + aig.is_complemented( f ) ) );
+    os.write( &string_buffer[0], sizeof( unsigned char ) * std::strlen( string_buffer ) );
+  } );
+
+  /* GATES */
+  std::vector<unsigned char> buffer;
+  aig.foreach_gate( [&]( node const& n ) {
+    std::vector<uint32_t> lits;
+    lits.push_back( 2 * aig.node_to_index( n ) );
+
+    aig.foreach_fanin( n, [&]( signal const& fi ) {
+      lits.push_back( 2 * aig.node_to_index( aig.get_node( fi ) ) + aig.is_complemented( fi ) );
+    } );
+
+    if ( lits[1] > lits[2] )
+    {
+      auto const tmp = lits[1];
+      lits[1] = lits[2];
+      lits[2] = tmp;
+    }
+
+    assert( lits[2] < lits[0] );
+    detail::encode( buffer, lits[0] - lits[2] );
+    detail::encode( buffer, lits[2] - lits[1] );
+  } );
+
+  for ( const auto& b : buffer )
+  {
+    os.put( b );
+  }
+
+  /* symbol table */
+  if constexpr ( has_has_name_v<Ntk> && has_get_name_v<Ntk> )
+  {
+    aig.foreach_pi( [&]( node const& i, uint32_t index ) {
+      if ( !aig.has_name( aig.make_signal( i ) ) )
+        return;
+
+      sprintf( string_buffer, "i%u %s\n",
+               uint32_t( index ),
+               aig.get_name( aig.make_signal( i ) ).c_str() );
+      os.write( &string_buffer[0], sizeof( unsigned char ) * std::strlen( string_buffer ) );
+    } );
+  }
+  if constexpr ( has_has_output_name_v<Ntk> && has_get_output_name_v<Ntk> )
+  {
+    aig.foreach_po( [&]( signal const& f, uint32_t index ) {
+      if ( !aig.has_output_name( index ) )
+        return;
+
+      sprintf( string_buffer, "o%u %s\n",
+               uint32_t( index ),
+               aig.get_output_name( index ).c_str() );
+      os.write( &string_buffer[0], sizeof( unsigned char ) * std::strlen( string_buffer ) );
+    } );
+  }
+
+  /* COMMENT */
+  os.put( 'c' );
+}
+
+/*! \brief Writes a combinational AIG network in binary AIGER format into a file
+ *
+ * This function should be only called on "clean" aig_networks, e.g.,
+ * immediately after `cleanup_dangling`.
+ *
+ * **Required network functions:**
+ * - `num_cis`
+ * - `num_cos`
+ * - `foreach_gate`
+ * - `foreach_fanin`
+ * - `foreach_po`
+ * - `get_node`
+ * - `is_complemented`
+ * - `node_to_index`
+ *
+ * \param aig Combinational AIG network
+ * \param filename Filename
+ */
+template<typename Ntk>
+inline void write_aiger( Ntk const& aig, std::string const& filename )
+{
+  std::ofstream os( filename.c_str(), std::ofstream::out );
+  write_aiger( aig, os );
+  os.close();
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/io/write_bench.hpp b/include/mockturtle/io/write_bench.hpp
new file mode 100644
index 0000000..964d4c3
--- /dev/null
+++ b/include/mockturtle/io/write_bench.hpp
@@ -0,0 +1,164 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file write_bench.hpp
+  \brief Write networks to BENCH format
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+#include <fmt/format.h>
+#include <kitty/operations.hpp>
+#include <kitty/print.hpp>
+
+#include "../traits.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Writes network in BENCH format into output stream
+ *
+ * An overloaded variant exists that writes the network into a file.
+ *
+ * **Required network functions:**
+ * - `is_constant`
+ * - `is_pi`
+ * - `is_complemented`
+ * - `get_node`
+ * - `num_pos`
+ * - `node_to_index`
+ * - `node_function`
+ *
+ * \param ntk Network
+ * \param os Output stream
+ */
+template<class Ntk>
+void write_bench( Ntk const& ntk, std::ostream& os )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_num_pos_v<Ntk>, "Ntk does not implement the num_pos method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_node_function_v<Ntk>, "Ntk does not implement the node_function method" );
+
+  ntk.foreach_pi( [&]( auto const& n ) {
+    os << fmt::format( "INPUT(n{})\n", ntk.node_to_index( n ) );
+  } );
+
+  for ( auto i = 0u; i < ntk.num_pos(); ++i )
+  {
+    os << fmt::format( "OUTPUT(po{})\n", i );
+  }
+
+  os << fmt::format( "n{} = gnd\n", ntk.node_to_index( ntk.get_node( ntk.get_constant( false ) ) ) );
+  if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+  {
+    os << fmt::format( "n{} = vdd\n", ntk.node_to_index( ntk.get_node( ntk.get_constant( true ) ) ) );
+  }
+
+  ntk.foreach_node( [&]( auto const& n ) {
+    if ( ntk.is_constant( n ) || ntk.is_pi( n ) )
+      return; /* continue */
+
+    auto func = ntk.node_function( n );
+    std::string children;
+    auto first = true;
+    ntk.foreach_fanin( n, [&]( auto const& c, auto i ) {
+      if ( ntk.is_complemented( c ) )
+      {
+        kitty::flip_inplace( func, i );
+      }
+      if ( first )
+      {
+        first = false;
+      }
+      else
+      {
+        children += ", ";
+      }
+
+      children += fmt::format( "n{}", ntk.node_to_index( ntk.get_node( c ) ) );
+    } );
+
+    os << fmt::format( "n{} = LUT 0x{} ({})\n",
+                       ntk.node_to_index( n ),
+                       kitty::to_hex( func ), children );
+  } );
+
+  /* outputs */
+  ntk.foreach_po( [&]( auto const& s, auto i ) {
+    if ( ntk.is_constant( ntk.get_node( s ) ) )
+    {
+      os << fmt::format( "po{} = {}\n",
+                         i,
+                         ( ntk.constant_value( ntk.get_node( s ) ) ^ ntk.is_complemented( s ) ) ? "vdd" : "gnd" );
+    }
+    else
+    {
+      os << fmt::format( "po{} = LUT 0x{} (n{})\n",
+                         i,
+                         ntk.is_complemented( s ) ? 1 : 2,
+                         ntk.node_to_index( ntk.get_node( s ) ) );
+    }
+  } );
+
+  os << std::flush;
+}
+
+/*! \brief Writes network in BENCH format into a file
+ *
+ * **Required network functions:**
+ * - `is_constant`
+ * - `is_pi`
+ * - `is_complemented`
+ * - `get_node`
+ * - `num_pos`
+ * - `node_to_index`
+ * - `node_function`
+ *
+ * \param ntk Network
+ * \param filename Filename
+ */
+template<class Ntk>
+void write_bench( Ntk const& ntk, std::string const& filename )
+{
+  std::ofstream os( filename.c_str(), std::ofstream::out );
+  write_bench( ntk, os );
+  os.close();
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/io/write_blif.hpp b/include/mockturtle/io/write_blif.hpp
new file mode 100644
index 0000000..bf0de34
--- /dev/null
+++ b/include/mockturtle/io/write_blif.hpp
@@ -0,0 +1,430 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file write_blif.hpp
+  \brief Write networks to BLIF format
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Max Austin
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../networks/sequential.hpp"
+#include "../traits.hpp"
+#include "../views/topo_view.hpp"
+
+#include <kitty/constructors.hpp>
+#include <kitty/isop.hpp>
+#include <kitty/operations.hpp>
+#include <kitty/print.hpp>
+
+#include <fmt/format.h>
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+namespace mockturtle
+{
+
+struct write_blif_params
+{
+  /**
+    * ## `ps.rename_ri_using_node`
+    * 
+    * Rename registers using node name if `rename_ri_using_node` is set to 1 ( default: 0 )
+    * 
+    * A register is represented by a `ro_to_ri` mapping:
+    * 
+    * ```
+    *  ri_node --> ro_signal
+    * ```
+    * where `ri_node` is the register input (a combinational output node), and `ro_signal` is 
+    * the register output (a combinational input signal).
+    * 
+    * If `rename_ri_using_node` is set to 1, then `ri_node` will be renamed (from its default 
+    * name) using the node name. We write the following to the BLIF file:
+    * 
+    * ```
+    * .latch ri_node ro_signal
+    * ```
+    * 
+    * Otherwise, if `rename_ri_using_node` is set to 1, `ri_node` will be named by its default 
+    * name, `li_<idx>`, where `idx` is the index of the register (based on the definition order 
+    * when calling `create_ro`). Then we write:
+    * 
+    * ```
+    * .latch li_<idx> ro_signal
+    * .names ri_node li_<idx>
+    * 1 1
+    * ```
+   */
+  uint32_t rename_ri_using_node = 0u;
+};
+
+/*! \brief Writes network in BLIF format into output stream
+ *
+ * An overloaded variant exists that writes the network into a file.
+ *
+ * **Required network functions:**
+ * - `fanin_size`
+ * - `foreach_fanin`
+ * - `foreach_pi`
+ * - `foreach_po`
+ * - `get_node`
+ * - `is_constant`
+ * - `is_pi`
+ * - `node_function`
+ * - `node_to_index`
+ * - `num_pis`
+ * - `num_pos`
+ *
+ * \param ntk Network
+ * \param os Output stream
+ */
+template<class Ntk>
+void write_blif( Ntk const& ntk, std::ostream& os, write_blif_params const& ps = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_fanin_size_v<Ntk>, "Ntk does not implement the fanin_size method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_num_pis_v<Ntk>, "Ntk does not implement the num_pis method" );
+  static_assert( has_num_pos_v<Ntk>, "Ntk does not implement the num_pos method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_node_function_v<Ntk>, "Ntk does not implement the node_function method" );
+
+  uint32_t num_latches{ 0 };
+  if constexpr ( has_num_registers_v<Ntk> )
+  {
+    num_latches = ntk.num_registers();
+  }
+
+  topo_view topo_ntk{ ntk };
+  std::unordered_set<std::string> defined_names;
+
+  /* write model */
+  os << ".model top\n";
+
+  /* write inputs */
+  if ( topo_ntk.num_pis() > 0u )
+  {
+    os << ".inputs ";
+    topo_ntk.foreach_ci( [&]( auto const& n, auto index ) {
+      if ( ( ( index + 1 ) <= topo_ntk.num_cis() - num_latches ) )
+      {
+        if constexpr ( has_has_name_v<Ntk> && has_get_name_v<Ntk> )
+        {
+          signal<Ntk> const s = topo_ntk.make_signal( topo_ntk.node_to_index( n ) );
+          std::string const input_name = topo_ntk.has_name( s ) ? topo_ntk.get_name( s ) : fmt::format( "pi{}", topo_ntk.get_node( s ) );
+          os << input_name << ' ';
+          defined_names.insert( input_name ); /* we should not have collision here */
+        }
+        else
+        {
+          std::string const input_name = fmt::format( "pi{}", topo_ntk.node_to_index( n ) );
+          os << input_name << ' ';
+          defined_names.insert( input_name ); /* we should not have collision here */
+        }
+      }
+    } );
+    os << "\n";
+  }
+
+  /* write outputs */
+  if ( topo_ntk.num_pos() > 0u )
+  {
+    os << ".outputs ";
+    topo_ntk.foreach_co( [&]( auto const& f, auto index ) {
+      (void)f;
+      if ( index < topo_ntk.num_cos() - num_latches )
+      {
+        if constexpr ( has_has_output_name_v<Ntk> && has_get_output_name_v<Ntk> )
+        {
+          std::string const output_name = topo_ntk.has_output_name( index ) ? topo_ntk.get_output_name( index ) : fmt::format( "po{}", index );
+          os << output_name << ' ';
+        }
+        else
+        {
+          std::string const output_name = fmt::format( "po{}", index );
+          os << output_name << ' ';
+        }
+      }
+    } );
+    os << "\n";
+  }
+
+  if constexpr ( has_num_registers_v<Ntk> )
+  {
+    if ( num_latches > 0u )
+    {
+      uint32_t latch_idx = 0;
+      topo_ntk.foreach_co( [&]( auto const& f, auto index ) {
+        if ( index >= topo_ntk.num_cos() - num_latches )
+        {
+          os << ".latch ";
+          auto const ro_signal = topo_ntk.make_signal( topo_ntk.ro_at( latch_idx ) );
+          auto const ri_signal = topo_ntk.ri_at( latch_idx );
+          register_t latch_info = topo_ntk.register_at( latch_idx );
+          if constexpr ( has_has_name_v<Ntk> && has_get_name_v<Ntk> )
+          {
+            std::string const node_name = topo_ntk.has_name( ri_signal ) ? 
+                topo_ntk.get_name( ri_signal ) 
+              : fmt::format( "new_n{}", topo_ntk.get_node( ri_signal ) );
+            std::string const latch_name = ps.rename_ri_using_node ? 
+                node_name
+              : fmt::format( "li{}", latch_idx );
+            std::string const ri_name = topo_ntk.has_output_name( index ) ? 
+                topo_ntk.get_output_name( index ) 
+              : latch_name;
+            std::string const ro_name = topo_ntk.has_name( ro_signal ) ? topo_ntk.get_name( ro_signal ) : fmt::format( "new_n{}", topo_ntk.get_node( ro_signal ) );
+            os << fmt::format( "{} {} {} {} {}\n", ri_name, ro_name, latch_info.type, latch_info.control, latch_info.init );
+            defined_names.insert( ro_name ); /* we should not have collision here */
+          }
+          else
+          {
+            std::string const ri_name = ps.rename_ri_using_node? 
+                fmt::format( "new_n{}", topo_ntk.get_node( topo_ntk.ri_at( latch_idx ) ) )
+              : fmt::format( "li{}", latch_idx );
+            std::string const ro_name = fmt::format( "new_n{}", topo_ntk.get_node( ro_signal ) );
+            os << fmt::format( "{} {} {} {} {}\n", ri_name, ro_name, latch_info.type, latch_info.control, latch_info.init );
+            defined_names.insert( ro_name ); /* we should not have collision here */
+          }
+          latch_idx++;
+        }
+      } );
+    }
+  }
+
+  /* write constants */
+  os << ".names new_n0\n";
+  os << "0\n";
+  defined_names.insert( "new_n0" ); /* we should not have collision here */
+
+  if ( topo_ntk.get_constant( false ) != topo_ntk.get_constant( true ) )
+  {
+    os << ".names new_n1\n";
+    os << "1\n";
+    defined_names.insert( "new_n1" ); /* we should not have collision here */
+  }
+
+  /* write nodes */
+  topo_ntk.foreach_node( [&]( auto const& n ) {
+    if ( topo_ntk.is_constant( n ) || topo_ntk.is_ci( n ) )
+      return; /* continue */
+
+    /* write truth table of node */
+    auto func = topo_ntk.node_function( n );
+
+    if ( isop( func ).size() == 0 ) /* constants */
+    {
+      if constexpr ( has_has_name_v<Ntk> && has_get_name_v<Ntk> )
+      {
+        auto const s = topo_ntk.make_signal( n );
+        std::string const constant_name = topo_ntk.has_name( s ) ? topo_ntk.get_name( s ) : fmt::format( "new_n{}", topo_ntk.get_node( s ) );
+        os << fmt::format( ".names {}\n", constant_name );
+        os << "0" << '\n';
+        defined_names.insert( constant_name ); /* we should not have collision here */
+      }
+      else
+      {
+        std::string const constant_name = fmt::format( "new_n{}", n );
+        os << fmt::format( ".names {}\n", constant_name );
+        os << "0" << '\n';
+        defined_names.insert( constant_name ); /* we should not have collision here */
+      }
+      return;
+    }
+
+    os << fmt::format( ".names " );
+
+    /* write fanins of node */
+    topo_ntk.foreach_fanin( n, [&]( auto const& f ) {
+      auto f_node = topo_ntk.get_node( f );
+      if constexpr ( has_has_name_v<Ntk> && has_get_name_v<Ntk> )
+      {
+        signal<Ntk> const s = topo_ntk.make_signal( f_node );
+        std::string const fanin_name = topo_ntk.has_name( s ) ? topo_ntk.get_name( s ) : topo_ntk.is_pi( f_node ) ? fmt::format( "pi{}", f_node ) : fmt::format( "new_n{}", f_node );
+        os << fanin_name << ' ';
+      }
+      else
+      {
+        std::string const fanin_name = topo_ntk.is_pi( f_node ) ? fmt::format( "pi{} ", f_node ) : fmt::format( "new_n{} ", f_node );
+        os << fanin_name;
+      }
+    } );
+
+    /* write fanout of node */
+    if constexpr ( has_has_name_v<Ntk> && has_get_name_v<Ntk> )
+    {
+      auto const s = topo_ntk.make_signal( n );
+      std::string const fanout_name = topo_ntk.has_name( s ) ? topo_ntk.get_name( s ) : fmt::format( "new_n{}", topo_ntk.get_node( s ) );
+      os << fanout_name << '\n';
+      defined_names.insert( fanout_name ); /* we should not have collision here */
+    }
+    else
+    {
+      std::string const fanout_name = fmt::format( "new_n{}", n );
+      os << fanout_name << '\n';
+      defined_names.insert( fanout_name ); /* we should not have collision here */
+    }
+
+    int count = 0;
+    for ( auto cube : isop( func ) )
+    {
+      topo_ntk.foreach_fanin( n, [&]( auto const& f, auto index ) {
+        if ( cube.get_mask( index ) && topo_ntk.is_complemented( f ) )
+          cube.flip_bit( index );
+      } );
+
+      cube.print( topo_ntk.fanin_size( n ), os );
+      os << " 1\n";
+      count++;
+    }
+  } );
+
+  auto latch_idx = 0;
+  topo_ntk.foreach_co( [&]( auto const& f, auto index ) {
+    auto f_node = topo_ntk.get_node( f );
+    auto const minterm_string = topo_ntk.is_complemented( f ) ? "0" : "1";
+
+    if ( index < topo_ntk.num_cos() - num_latches ) /* the signal f is a PO */
+    {
+      /* the default name depends on whether the signal is a PI or a regular signal */
+      std::string const node_default_name = topo_ntk.is_pi( f_node ) ? fmt::format( "pi{}", f_node ) : fmt::format( "new_n{}", f_node );
+
+      if constexpr ( has_has_name_v<Ntk> && has_get_name_v<Ntk> && has_has_output_name_v<Ntk> && has_get_output_name_v<Ntk> ) /* with name view */
+      {
+        signal<Ntk> const s = topo_ntk.make_signal( topo_ntk.get_node( f ) );
+
+        /* then we overwrite the default name if we assigned names from name_view */
+        std::string const node_name = topo_ntk.has_name( s ) ? topo_ntk.get_name( s ) : node_default_name;
+
+        /* get the default name of PO */
+        std::string default_output_name = fmt::format( "po{}", index );
+
+        /* over write the name if we have name view */
+        std::string const output_name = topo_ntk.has_output_name( index ) ? topo_ntk.get_output_name( index ) : default_output_name;
+
+        /* we need to bridge the nodes */
+        if ( node_name != output_name && defined_names.find( output_name ) == defined_names.end() )
+        {
+          os << fmt::format( ".names {} {}\n{} 1\n", node_name, output_name, minterm_string );
+          defined_names.insert( output_name );
+        }
+      }
+      else /* without name view */
+      {
+        std::string const node_name = node_default_name;
+        std::string const output_name = fmt::format( "po{}", index );
+        if ( node_name != output_name && defined_names.find( output_name ) == defined_names.end() )
+        {
+          os << fmt::format( ".names {} {}\n{} 1\n", node_name, output_name, minterm_string );
+          defined_names.insert( output_name );
+        }
+      }
+    }
+    else /* the signal f is a RI */
+    {
+      /* the default name depends on whether the signal is a PI or a regular signal */
+      std::string const node_default_name = topo_ntk.is_pi( f_node ) ? fmt::format( "pi{}", f_node ) : fmt::format( "new_n{}", f_node );
+
+      if constexpr ( has_has_name_v<Ntk> && has_get_name_v<Ntk> && has_has_output_name_v<Ntk> && has_get_output_name_v<Ntk> ) /* with name view */
+      {
+        signal<Ntk> const s = topo_ntk.make_signal( topo_ntk.get_node( f ) );
+
+        /* then we overwrite the default name if we assigned names from name_view */
+        std::string const node_name = topo_ntk.has_name( s ) ? topo_ntk.get_name( s ) : node_default_name;
+
+        /* get the default name of RI */
+        std::string default_ri_name = ps.rename_ri_using_node ? node_name : fmt::format( "li{}", latch_idx );
+
+        /* overwrite the name if we have name view */
+        std::string const ri_name = topo_ntk.has_output_name( index ) ? topo_ntk.get_output_name( index ) : default_ri_name;
+
+        /* we need to bridge the nodes */
+        if ( node_name != ri_name && defined_names.find( ri_name ) == defined_names.end() )
+        {
+          os << fmt::format( ".names {} {}\n{} 1\n", node_name, ri_name, minterm_string );
+          defined_names.insert( ri_name );
+        }
+      }
+      else /* without name view */
+      {
+        std::string const node_name = node_default_name;
+
+        /* get the default name of RI */
+        std::string ri_name = ps.rename_ri_using_node ? node_name : fmt::format( "li{}", latch_idx );
+
+        if ( node_name != ri_name && defined_names.find( ri_name ) == defined_names.end() )
+        {
+          os << fmt::format( ".names {} {}\n{} 1\n", node_name, ri_name, minterm_string );
+          defined_names.insert( ri_name );
+        }
+      }
+
+      latch_idx++;
+    }
+  } );
+
+  os << ".end\n";
+  os << std::flush;
+}
+
+/*! \brief Writes network in BLIF format into a file
+ *
+ * **Required network functions:**
+ * - `fanin_size`
+ * - `foreach_fanin`
+ * - `foreach_pi`
+ * - `foreach_po`
+ * - `get_node`
+ * - `is_constant`
+ * - `is_pi`
+ * - `node_function`
+ * - `node_to_index`
+ * - `num_pis`
+ * - `num_pos`
+ *
+ * \param ntk Network
+ * \param filename Filename
+ */
+template<class Ntk>
+void write_blif( Ntk const& ntk, std::string const& filename, write_blif_params const& ps = {} )
+{
+  std::ofstream os( filename.c_str(), std::ofstream::out );
+  write_blif( ntk, os, ps );
+  os.close();
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/io/write_dimacs.hpp b/include/mockturtle/io/write_dimacs.hpp
new file mode 100644
index 0000000..092c40c
--- /dev/null
+++ b/include/mockturtle/io/write_dimacs.hpp
@@ -0,0 +1,126 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2019  EPFL EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file write_dimacs.hpp
+  \brief Write networks CNF encoding to DIMACS format
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#include <fmt/format.h>
+
+#include "../algorithms/cnf.hpp"
+#include "../traits.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Writes network into CNF DIMACS format
+ *
+ * It also adds unit clauses for the outputs.  Therefore a satisfying solution
+ * is one that makes all outputs 1.
+ *
+ * \param ntk Logic network
+ * \param out Output stream
+ */
+template<class Ntk>
+void write_dimacs( Ntk const& ntk, std::ostream& out = std::cout )
+{
+  std::stringstream clauses;
+  uint32_t num_clauses = 0u;
+
+  const auto lits = generate_cnf( ntk, [&]( std::vector<uint32_t> const& clause ) {
+    for ( auto lit : clause )
+    {
+      const auto var = ( lit / 2 ) + 1;
+      const auto pol = lit % 2;
+      clauses << fmt::format( "{}{} ", pol ? "-" : "", var );
+    }
+    clauses << fmt::format( "0\n" );
+    ++num_clauses;
+  } );
+
+  for ( auto lit : lits )
+  {
+    const auto var = ( lit / 2 ) + 1;
+    const auto pol = lit % 2;
+    clauses << fmt::format( "{}{} 0\n", pol ? "-" : "", var );
+    ++num_clauses;
+  }
+
+  out << fmt::format( "p cnf {} {}\n{}", ntk.size(), num_clauses, clauses.str() );
+}
+
+/*! \brief Writes network into CNF DIMACS format
+ *
+ * It also adds unit clauses for the outputs.  Therefore a satisfying solution
+ * is one that makes all outputs 1.
+ *
+ * \param ntk Logic network
+ * \param filename Filename
+ */
+template<class Ntk>
+void write_dimacs( Ntk const& ntk, std::string const& filename )
+{
+  std::ofstream os( filename.c_str(), std::ofstream::out );
+  write_dimacs( ntk, os );
+  os.close();
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/io/write_dot.hpp b/include/mockturtle/io/write_dot.hpp
new file mode 100644
index 0000000..edbed29
--- /dev/null
+++ b/include/mockturtle/io/write_dot.hpp
@@ -0,0 +1,456 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file write_dot.hpp
+  \brief Write graphical representation of networks to DOT format
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Marcel Walter
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <fstream>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <string>
+
+#include <fmt/format.h>
+
+#include "../traits.hpp"
+#include "../views/depth_view.hpp"
+
+namespace mockturtle
+{
+
+template<class Ntk>
+class default_dot_drawer
+{
+public:
+  virtual ~default_dot_drawer()
+  {
+  }
+
+public: /* callbacks */
+  virtual std::string node_label( Ntk const& ntk, node<Ntk> const& n ) const
+  {
+    return std::to_string( ntk.node_to_index( n ) );
+  }
+
+  virtual std::string node_shape( Ntk const& ntk, node<Ntk> const& n ) const
+  {
+    if ( ntk.is_constant( n ) )
+    {
+      return "box";
+    }
+    else if ( ntk.is_ci( n ) )
+    {
+      return "triangle";
+    }
+    else
+    {
+      if constexpr ( has_is_buf_v<Ntk> )
+      {
+        if ( ntk.is_buf( n ) )
+        {
+          return "box";
+        }
+      }
+      return "ellipse";
+    }
+  }
+
+  virtual uint32_t node_level( Ntk const& ntk, node<Ntk> const& n ) const
+  {
+    if ( !_depth_ntk )
+    {
+      _depth_ntk = std::make_shared<depth_view<Ntk>>( ntk );
+    }
+
+    return _depth_ntk->level( n );
+  }
+
+  virtual std::string po_shape( Ntk const& ntk, uint32_t i ) const
+  {
+    (void)ntk;
+    (void)i;
+    return "invtriangle";
+  }
+
+  virtual std::string node_fillcolor( Ntk const& ntk, node<Ntk> const& n ) const
+  {
+    if constexpr ( has_is_buf_v<Ntk> )
+    {
+      if ( ntk.is_buf( n ) )
+      {
+        if ( ntk.fanout_size( n ) > 1 )
+          return "lightcoral";
+        else
+          return "lightskyblue";
+      }
+    }
+    return ( ntk.is_constant( n ) || ntk.is_ci( n ) ) ? "snow2" : "white";
+  }
+
+  virtual std::string po_fillcolor( Ntk const& ntk, uint32_t i ) const
+  {
+    (void)ntk;
+    (void)i;
+    return "snow2";
+  }
+
+  virtual bool draw_signal( Ntk const& ntk, node<Ntk> const& n, signal<Ntk> const& f ) const
+  {
+    (void)ntk;
+    (void)n;
+    (void)f;
+    if constexpr ( is_buffered_network_type_v<Ntk> )
+    {
+      if ( ntk.is_constant( ntk.get_node( f ) ) )
+        return false;
+    }
+    return true;
+  }
+
+  virtual std::string signal_style( Ntk const& ntk, signal<Ntk> const& f ) const
+  {
+    return ntk.is_complemented( f ) ? "dashed" : "solid";
+  }
+
+private:
+  mutable std::shared_ptr<depth_view<Ntk>> _depth_ntk;
+};
+
+template<class Ntk>
+class gate_dot_drawer : public default_dot_drawer<Ntk>
+{
+public:
+  virtual std::string node_label( Ntk const& ntk, node<Ntk> const& n ) const override
+  {
+    if constexpr ( has_is_and_v<Ntk> )
+    {
+      if ( ntk.is_and( n ) )
+      {
+        return "AND";
+      }
+    }
+
+    if constexpr ( has_is_or_v<Ntk> )
+    {
+      if ( ntk.is_or( n ) )
+      {
+        return "OR";
+      }
+    }
+
+    if constexpr ( has_is_xor_v<Ntk> )
+    {
+      if ( ntk.is_xor( n ) )
+      {
+        return "XOR";
+      }
+    }
+
+    if constexpr ( has_is_maj_v<Ntk> )
+    {
+      if ( ntk.is_maj( n ) )
+      {
+        std::string label{ "MAJ" };
+        ntk.foreach_fanin( n, [&]( auto const& f ) {
+          if ( ntk.is_constant( ntk.get_node( f ) ) )
+          {
+            const auto v = ntk.constant_value( ntk.get_node( f ) ) != ntk.is_complemented( f );
+            label = v ? "OR" : "AND";
+            return false;
+          }
+          return true;
+        } );
+        return label;
+      }
+    }
+
+    if constexpr ( has_is_xor3_v<Ntk> )
+    {
+      if ( ntk.is_xor3( n ) )
+      {
+        return "XOR";
+      }
+    }
+
+    if constexpr ( has_is_nary_and_v<Ntk> )
+    {
+      if ( ntk.is_nary_and( n ) )
+      {
+        return "AND";
+      }
+    }
+
+    if constexpr ( has_is_nary_or_v<Ntk> )
+    {
+      if ( ntk.is_nary_or( n ) )
+      {
+        return "OR";
+      }
+    }
+
+    if constexpr ( has_is_nary_xor_v<Ntk> )
+    {
+      if ( ntk.is_nary_xor( n ) )
+      {
+        return "XOR";
+      }
+    }
+
+    if constexpr ( has_is_buf_v<Ntk> )
+    {
+      if ( ntk.is_buf( n ) && !ntk.is_ci( n ) )
+      {
+        return "BUF";
+      }
+    }
+
+    if constexpr ( has_is_crossing_v<Ntk> )
+    {
+      if ( ntk.is_crossing( n ) )
+      {
+        return "CROSS";
+      }
+    }
+
+    return default_dot_drawer<Ntk>::node_label( ntk, n );
+  }
+
+  virtual std::string node_fillcolor( Ntk const& ntk, node<Ntk> const& n ) const override
+  {
+    if constexpr ( has_is_and_v<Ntk> )
+    {
+      if ( ntk.is_and( n ) )
+      {
+        return "lightcoral";
+      }
+    }
+
+    if constexpr ( has_is_or_v<Ntk> )
+    {
+      if ( ntk.is_or( n ) )
+      {
+        return "palegreen2";
+      }
+    }
+
+    if constexpr ( has_is_xor_v<Ntk> )
+    {
+      if ( ntk.is_xor( n ) )
+      {
+        return "lightskyblue";
+      }
+    }
+
+    if constexpr ( has_is_maj_v<Ntk> )
+    {
+      if ( ntk.is_maj( n ) )
+      {
+        std::string color{ "lightsalmon" };
+        ntk.foreach_fanin( n, [&]( auto const& f ) {
+          if ( ntk.is_constant( ntk.get_node( f ) ) )
+          {
+            const auto v = ntk.constant_value( ntk.get_node( f ) ) != ntk.is_complemented( f );
+            color = v ? "palegreen2" : "lightcoral";
+            return false;
+          }
+          return true;
+        } );
+        return color;
+      }
+    }
+
+    if constexpr ( has_is_xor3_v<Ntk> )
+    {
+      if ( ntk.is_xor3( n ) )
+      {
+        return "lightskyblue";
+      }
+    }
+
+    if constexpr ( has_is_nary_and_v<Ntk> )
+    {
+      if ( ntk.is_nary_and( n ) )
+      {
+        return "lightcoral";
+      }
+    }
+
+    if constexpr ( has_is_nary_or_v<Ntk> )
+    {
+      if ( ntk.is_nary_or( n ) )
+      {
+        return "palegreen2";
+      }
+    }
+
+    if constexpr ( has_is_nary_xor_v<Ntk> )
+    {
+      if ( ntk.is_nary_xor( n ) )
+      {
+        return "lightskyblue";
+      }
+    }
+
+    if constexpr ( has_is_buf_v<Ntk> )
+    {
+      if ( ntk.is_buf( n ) && !ntk.is_ci( n ) )
+      {
+        return "palegoldenrod";
+      }
+    }
+
+    if constexpr ( has_is_crossing_v<Ntk> )
+    {
+      if ( ntk.is_crossing( n ) )
+      {
+        return "palegoldenrod";
+      }
+    }
+
+    return default_dot_drawer<Ntk>::node_fillcolor( ntk, n );
+  }
+
+  virtual bool draw_signal( Ntk const& ntk, node<Ntk> const& n, signal<Ntk> const& f ) const override
+  {
+    if constexpr ( has_is_maj_v<Ntk> )
+    {
+      if ( ntk.is_maj( n ) )
+      {
+        return !ntk.is_constant( ntk.get_node( f ) );
+      }
+    }
+
+    return default_dot_drawer<Ntk>::draw_signal( ntk, n, f );
+  }
+};
+
+/*! \brief Writes network in DOT format into output stream
+ *
+ * An overloaded variant exists that writes the network into a file.
+ *
+ * **Required network functions:**
+ * - is_constant
+ * - is_ci
+ * - foreach_node
+ * - foreach_fanin
+ * - foreach_po
+ *
+ * \param ntk Network
+ * \param os Output stream
+ */
+template<class Ntk, class Drawer = default_dot_drawer<Ntk>>
+void write_dot( Ntk const& ntk, std::ostream& os, Drawer const& drawer = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_ci_v<Ntk>, "Ntk does not implement the is_ci method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+
+  std::stringstream nodes, edges, levels;
+
+  std::vector<std::vector<uint32_t>> level_to_node_indexes;
+
+  ntk.foreach_node( [&]( auto const& n ) {
+    nodes << fmt::format( "{} [label=\"{}\",shape={},style=filled,fillcolor={}]\n",
+                          ntk.node_to_index( n ),
+                          drawer.node_label( ntk, n ),
+                          drawer.node_shape( ntk, n ),
+                          drawer.node_fillcolor( ntk, n ) );
+    if ( !ntk.is_constant( n ) && !ntk.is_ci( n ) )
+    {
+      ntk.foreach_fanin( n, [&]( auto const& f ) {
+        if ( !drawer.draw_signal( ntk, n, f ) )
+          return true;
+        edges << fmt::format( "{} -> {} [style={}]\n",
+                              ntk.node_to_index( ntk.get_node( f ) ),
+                              ntk.node_to_index( n ),
+                              drawer.signal_style( ntk, f ) );
+        return true;
+      } );
+    }
+
+    const auto lvl = drawer.node_level( ntk, n );
+    if ( level_to_node_indexes.size() <= lvl )
+    {
+      level_to_node_indexes.resize( lvl + 1 );
+    }
+    level_to_node_indexes[lvl].push_back( ntk.node_to_index( n ) );
+  } );
+
+  for ( auto const& indexes : level_to_node_indexes )
+  {
+    levels << "{rank = same; ";
+    std::copy( indexes.begin(), indexes.end(), std::ostream_iterator<uint32_t>( levels, "; " ) );
+    levels << "}\n";
+  }
+
+  levels << "{rank = same; ";
+  ntk.foreach_po( [&]( auto const& f, auto i ) {
+    nodes << fmt::format( "po{} [shape={},style=filled,fillcolor={}]\n", i, drawer.po_shape( ntk, i ), drawer.po_fillcolor( ntk, i ) );
+    edges << fmt::format( "{} -> po{} [style={}]\n",
+                          ntk.node_to_index( ntk.get_node( f ) ),
+                          i,
+                          drawer.signal_style( ntk, f ) );
+    levels << fmt::format( "po{}; ", i );
+  } );
+  levels << "}\n";
+
+  os << "digraph {\n"
+     << "rankdir=BT;\n"
+     << nodes.str() << edges.str() << levels.str() << "}\n";
+}
+
+/*! \brief Writes network in DOT format into a file
+ *
+ * **Required network functions:**
+ * - is_constant
+ * - is_ci
+ * - foreach_node
+ * - foreach_fanin
+ * - foreach_po
+ *
+ * \param ntk Network
+ * \param filename Filename
+ */
+template<class Ntk, class Drawer = default_dot_drawer<Ntk>>
+void write_dot( Ntk const& ntk, std::string const& filename, Drawer const& drawer = {} )
+{
+  std::ofstream os( filename.c_str(), std::ofstream::out );
+  write_dot( ntk, os, drawer );
+  os.close();
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/io/write_genlib.hpp b/include/mockturtle/io/write_genlib.hpp
new file mode 100644
index 0000000..9ef31ee
--- /dev/null
+++ b/include/mockturtle/io/write_genlib.hpp
@@ -0,0 +1,105 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file write_genlib.hpp
+  \brief Writes library of gates to GENLIB format
+
+  \author Alessandro tempia Calvino
+*/
+
+#pragma once
+
+#include "genlib_reader.hpp"
+#include "../traits.hpp"
+
+#include <fmt/format.h>
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+namespace mockturtle
+{
+
+/*! \brief Writes library of gates to GENLIB format
+ *
+ * An overloaded variant exists that writes the network into a file.
+ *
+ * \param gates List of gates
+ * \param os Output stream
+ */
+void write_genlib( std::vector<gate> const& gates, std::ostream& os )
+{
+  /* compute pad spaces */
+  size_t max_name_size = 0;
+  for ( gate const& g : gates )
+  {
+    max_name_size = std::max( max_name_size, g.name.size() );
+  }
+  ++max_name_size;
+
+  for ( gate const& g : gates )
+  {
+    os << "GATE ";
+    std::string name = g.name + std::string( max_name_size - g.name.size(), ' ' );
+    os << fmt::format( "{} {:>5.4f} {}={};\n", name, g.area, g.output_name, g.expression );
+
+    for ( pin const& p : g.pins )
+    {
+      std::string phase;
+      if ( p.phase == phase_type::INV )
+        phase = "INV";
+      else if ( p.phase == phase_type::NONINV )
+        phase = "NONINV";
+      else
+        phase = "UNKNOWN";
+
+      os << fmt::format( "\tPIN {} {} {:>3} {:>3} {:>6.4f} {:>6.4f} {:>6.4f} {:>6.4f}\n",
+        p.name,
+        phase,
+        ( uint32_t )p.input_load,
+        ( uint32_t )p.max_load,
+        p.rise_block_delay,
+        p.rise_fanout_delay,
+        p.fall_block_delay,
+        p.fall_fanout_delay );
+    }
+  }
+}
+
+/*! \brief Write library of gates into a GENLIB file
+ *
+ * \param gates List of gates
+ * \param filename Filename
+ */
+void write_genlib( std::vector<gate> const& gates, std::string const& filename )
+{
+  std::ofstream os( filename.c_str(), std::ofstream::out );
+  write_genlib( gates, os );
+  os.close();
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/io/write_patterns.hpp b/include/mockturtle/io/write_patterns.hpp
new file mode 100644
index 0000000..f46ad9e
--- /dev/null
+++ b/include/mockturtle/io/write_patterns.hpp
@@ -0,0 +1,87 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file write_patterns.hpp
+  \brief Write simulation patterns
+
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#include <kitty/print.hpp>
+
+#include "../algorithms/simulation.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Writes simulation patterns
+ *
+ * The output contains `num_pis()` lines, each line contains a stream of
+ * simulation values of a primary input, represented in hexadecimal.
+ *
+ * \param sim The `partial_simulator` or `bit_packed_simulator` object containing simulation patterns
+ * \param out Output stream
+ */
+template<class Simulator>
+void write_patterns( Simulator const& sim, std::ostream& out = std::cout )
+{
+  static_assert( std::is_same_v<Simulator, partial_simulator> || std::is_same_v<Simulator, bit_packed_simulator>, "This function is specialized for partial_simulator or bit_packed_simulator" );
+
+  auto const& patterns = sim.get_patterns();
+  for ( auto i = 0u; i < patterns.size(); ++i )
+  {
+    out << kitty::to_hex( patterns.at( i ) ) << "\n";
+  }
+}
+
+/*! \brief Writes simulation patterns
+ *
+ * The output contains `num_pis()` lines, each line contains a stream of
+ * simulation values of a primary input, represented in hexadecimal.
+ *
+ * \param sim The `partial_simulator` or `bit_packed_simulator` object containing simulation patterns
+ * \param filename Filename
+ */
+template<class Simulator>
+void write_patterns( Simulator const& sim, std::string const& filename )
+{
+  static_assert( std::is_same_v<Simulator, partial_simulator> || std::is_same_v<Simulator, bit_packed_simulator>, "This function is specialized for partial_simulator or bit_packed_simulator" );
+
+  std::ofstream os( filename.c_str(), std::ofstream::out );
+  write_patterns( sim, os );
+  os.close();
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/io/write_verilog.hpp b/include/mockturtle/io/write_verilog.hpp
new file mode 100644
index 0000000..607b41d
--- /dev/null
+++ b/include/mockturtle/io/write_verilog.hpp
@@ -0,0 +1,1315 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file write_verilog.hpp
+  \brief Write networks to structural Verilog format
+
+  \author Alessandro Tempia Calvino
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+#include "../utils/node_map.hpp"
+#include "../utils/string_utils.hpp"
+#include "../views/binding_view.hpp"
+#include "../views/topo_view.hpp"
+
+#include <fmt/format.h>
+#include <kitty/print.hpp>
+#include <lorina/verilog.hpp>
+
+#include <array>
+#include <fstream>
+#include <iostream>
+#include <optional>
+#include <string>
+
+namespace mockturtle
+{
+
+using namespace std::string_literals;
+
+namespace detail
+{
+
+template<class Ntk>
+std::vector<std::pair<bool, std::string>>
+format_fanin( Ntk const& ntk, node<Ntk> const& n, node_map<std::string, Ntk>& node_names )
+{
+  std::vector<std::pair<bool, std::string>> children;
+  ntk.foreach_fanin( n, [&]( auto const& f, auto i ) {
+    if constexpr ( is_crossed_network_type_v<Ntk> )
+    {
+      std::string postfix = ntk.is_crossing( ntk.get_node( f ) ) ? ( ntk.is_second( f ) ? "_2" : "_1" ) : "";
+      children.emplace_back( std::make_pair( ntk.get_fanin_negations( n )[i], node_names[f] + postfix ) );
+    }
+    else
+    {
+      children.emplace_back( std::make_pair( ntk.is_complemented( f ), node_names[f] ) );
+    }
+  } );
+  return children;
+}
+
+template<class Ntk>
+std::vector<std::pair<bool, std::string>>
+format_fanin( Ntk const& ntk, node<Ntk> const& n, node_map<std::vector<std::string>, Ntk>& node_names )
+{
+  std::vector<std::pair<bool, std::string>> children;
+  ntk.foreach_fanin( n, [&]( auto const& f, auto i ) {
+    if constexpr ( is_crossed_network_type_v<Ntk> )
+    {
+      std::string postfix = ntk.is_crossing( ntk.get_node( f ) ) ? ( ntk.is_second( f ) ? "_2" : "_1" ) : "";
+      children.emplace_back( std::make_pair( ntk.get_fanin_negations( n )[i], node_names[f].front() + postfix ) );
+    }
+    else if constexpr ( has_is_multioutput_v<Ntk> )
+    {
+      children.emplace_back( std::make_pair( ntk.is_complemented( f ), node_names[f][ntk.get_output_pin( f )] ) );
+    }
+    else
+    {
+      children.emplace_back( std::make_pair( ntk.is_complemented( f ), node_names[f].front() ) );
+    }
+  } );
+  return children;
+}
+
+template<typename Signal>
+struct verilog_writer_signal_hash
+{
+  uint64_t operator()( const Signal& f ) const
+  {
+    return f.data;
+  }
+};
+
+} // namespace detail
+
+struct write_verilog_params
+{
+  std::optional<std::string> module_name{ std::nullopt };
+  std::vector<std::pair<std::string, uint32_t>> input_names;
+  std::vector<std::pair<std::string, uint32_t>> output_names;
+  bool verbose{ false };
+};
+
+/*! \brief Writes network in structural Verilog format into output stream
+ *
+ * An overloaded variant exists that writes the network into a file.
+ *
+ * **Required network functions:**
+ * - `num_pis`
+ * - `num_pos`
+ * - `foreach_pi`
+ * - `foreach_node`
+ * - `foreach_fanin`
+ * - `get_node`
+ * - `get_constant`
+ * - `is_constant`
+ * - `is_pi`
+ * - `is_and`
+ * - `is_or`
+ * - `is_xor`
+ * - `is_xor3`
+ * - `is_maj`
+ * - `is_ite`
+ * - `node_to_index`
+ *
+ * \param ntk Network
+ * \param os Output stream
+ */
+template<class Ntk>
+void write_verilog( Ntk const& ntk, std::ostream& os, write_verilog_params const& ps = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_num_pis_v<Ntk>, "Ntk does not implement the num_pis method" );
+  static_assert( has_num_pos_v<Ntk>, "Ntk does not implement the num_pos method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_is_and_v<Ntk>, "Ntk does not implement the is_and method" );
+  static_assert( has_is_or_v<Ntk>, "Ntk does not implement the is_or method" );
+  static_assert( has_is_xor_v<Ntk>, "Ntk does not implement the is_xor method" );
+  static_assert( has_is_xor3_v<Ntk>, "Ntk does not implement the is_xor3 method" );
+  static_assert( has_is_maj_v<Ntk>, "Ntk does not implement the is_maj method" );
+  static_assert( has_is_ite_v<Ntk>, "Ntk does not implement the is_ite method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+
+  assert( ntk.is_combinational() && "Network has to be combinational" );
+
+  lorina::verilog_writer writer( os );
+
+  if constexpr ( is_buffered_network_type_v<Ntk> )
+  {
+    writer.on_module_begin( "buffer", { "i" }, { "o" } );
+    writer.on_input( "i" );
+    writer.on_output( "o" );
+    writer.on_module_end();
+
+    writer.on_module_begin( "inverter", { "i" }, { "o" } );
+    writer.on_input( "i" );
+    writer.on_output( "o" );
+    writer.on_module_end();
+  }
+  if constexpr ( is_crossed_network_type_v<Ntk> )
+  {
+    writer.on_module_begin( "crossing", { "i1", "i2" }, { "o1", "o2" } );
+    writer.on_input( std::vector<std::string>( { "i1", "i2" } ) );
+    writer.on_output( std::vector<std::string>( { "o1", "o2" } ) );
+    writer.on_module_end();
+  }
+
+  std::vector<std::string> xs, inputs;
+  if ( ps.input_names.empty() )
+  {
+    if constexpr ( has_has_name_v<Ntk> && has_get_name_v<Ntk> )
+    {
+      ntk.foreach_pi( [&]( auto const& i, uint32_t index ) {
+        if ( ntk.has_name( ntk.make_signal( i ) ) )
+        {
+          xs.emplace_back( ntk.get_name( ntk.make_signal( i ) ) );
+        }
+        else
+        {
+          xs.emplace_back( fmt::format( "x{}", index ) );
+        }
+      } );
+    }
+    else
+    {
+      ntk.foreach_pi( [&]( auto const& i, uint32_t index ) {
+        (void)i;
+        xs.emplace_back( fmt::format( "x{}", index ) );
+      } );
+    }
+    inputs = xs;
+  }
+  else
+  {
+    uint32_t ctr{ 0u };
+    for ( auto const& [name, width] : ps.input_names )
+    {
+      inputs.emplace_back( name );
+      ctr += width;
+      for ( auto i = 0u; i < width; ++i )
+      {
+        xs.emplace_back( fmt::format( "{}[{}]", name, i ) );
+      }
+    }
+    if ( ctr != ntk.num_pis() )
+    {
+      std::cerr << "[e] input names do not partition all inputs\n";
+    }
+  }
+
+  std::vector<std::string> ys, outputs;
+  if ( ps.output_names.empty() )
+  {
+    if constexpr ( has_has_output_name_v<Ntk> && has_get_output_name_v<Ntk> )
+    {
+      ntk.foreach_po( [&]( auto const& o, uint32_t index ) {
+        if ( ntk.has_output_name( index ) )
+        {
+          ys.emplace_back( ntk.get_output_name( index ) );
+        }
+        else
+        {
+          ys.emplace_back( fmt::format( "y{}", index ) );
+        }
+      } );
+    }
+    else
+    {
+      ntk.foreach_po( [&]( auto const& o, uint32_t index ) {
+        (void)o;
+        ys.emplace_back( fmt::format( "y{}", index ) );
+      } );
+    }
+    outputs = ys;
+  }
+  else
+  {
+    uint32_t ctr{ 0u };
+    for ( auto const& [name, width] : ps.output_names )
+    {
+      outputs.emplace_back( name );
+      ctr += width;
+      for ( auto i = 0u; i < width; ++i )
+      {
+        ys.emplace_back( fmt::format( "{}[{}]", name, i ) );
+      }
+    }
+    if ( ctr != ntk.num_pos() )
+    {
+      std::cerr << "[e] output names do not partition all outputs\n";
+    }
+  }
+
+  std::vector<std::string> ws;
+
+  if constexpr ( is_buffered_network_type_v<Ntk> )
+  {
+    static_assert( has_is_buf_v<Ntk>, "Ntk does not implement the is_buf method" );
+    ntk.foreach_node( [&]( auto const& n ) {
+      if ( ntk.fanin_size( n ) > 0 )
+        ws.emplace_back( fmt::format( "n{}", ntk.node_to_index( n ) ) );
+    } );
+  }
+  else
+  {
+    ntk.foreach_gate( [&]( auto const& n ) {
+      ws.emplace_back( fmt::format( "n{}", ntk.node_to_index( n ) ) );
+    } );
+  }
+
+  std::string module_name = "top";
+  if ( ps.module_name )
+  {
+    module_name = *ps.module_name;
+  }
+  else
+  {
+    if constexpr ( has_get_network_name_v<Ntk> )
+    {
+      if ( ntk.get_network_name().length() > 0 )
+      {
+        module_name = ntk.get_network_name();
+      }
+    }
+  }
+  writer.on_module_begin( module_name, inputs, outputs );
+
+  if ( ps.input_names.empty() )
+  {
+    writer.on_input( xs );
+  }
+  else
+  {
+    for ( auto const& [name, width] : ps.input_names )
+    {
+      writer.on_input( width, name );
+    }
+  }
+  if ( ps.output_names.empty() )
+  {
+    writer.on_output( ys );
+  }
+  else
+  {
+    for ( auto const& [name, width] : ps.output_names )
+    {
+      writer.on_output( width, name );
+    }
+  }
+  if ( !ws.empty() )
+  {
+    writer.on_wire( ws );
+  }
+
+  node_map<std::string, Ntk> node_names( ntk );
+  node_names[ntk.get_constant( false )] = "1'b0";
+  if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+    node_names[ntk.get_constant( true )] = "1'b1";
+
+  ntk.foreach_pi( [&]( auto const& n, auto i ) {
+    node_names[n] = xs[i];
+  } );
+
+  topo_view ntk_topo{ ntk };
+
+  ntk_topo.foreach_node( [&]( auto const& n ) {
+    if ( ntk.is_constant( n ) || ntk.is_pi( n ) )
+      return true;
+
+    /* assign a name */
+    node_names[n] = fmt::format( "n{}", ntk.node_to_index( n ) );
+
+    if constexpr ( has_is_buf_v<Ntk> )
+    {
+      if ( ntk.is_buf( n ) )
+      {
+        auto const fanin = detail::format_fanin<Ntk>( ntk, n, node_names );
+        assert( fanin.size() == 1 );
+        std::vector<std::pair<std::string, std::string>> args;
+        if ( fanin[0].first ) /* input negated */
+        {
+          args.emplace_back( std::make_pair( "i", fanin[0].second ) );
+          args.emplace_back( std::make_pair( "o", node_names[n] ) );
+          writer.on_module_instantiation( "inverter", {}, "inv_" + node_names[n], args );
+        }
+        else
+        {
+          args.emplace_back( std::make_pair( "i", fanin[0].second ) );
+          args.emplace_back( std::make_pair( "o", node_names[n] ) );
+          writer.on_module_instantiation( "buffer", {}, "buf_" + node_names[n], args );
+        }
+        return true;
+      }
+    }
+
+    if constexpr ( is_crossed_network_type_v<Ntk> )
+    {
+      if ( ntk.is_crossing( n ) )
+      {
+        auto const fanin = detail::format_fanin<Ntk>( ntk, n, node_names );
+        assert( fanin.size() == 2 );
+        std::vector<std::pair<std::string, std::string>> args;
+        args.emplace_back( std::make_pair( "i1", fanin[0].second ) );
+        args.emplace_back( std::make_pair( "i2", fanin[1].second ) );
+        args.emplace_back( std::make_pair( "o1", node_names[n] + "_1" ) );
+        args.emplace_back( std::make_pair( "o2", node_names[n] + "_2" ) );
+        writer.on_module_instantiation( "crossing", {}, "cross_" + node_names[n], args );
+        return true;
+      }
+    }
+
+    if ( ntk.is_and( n ) )
+    {
+      writer.on_assign( node_names[n], detail::format_fanin<Ntk>( ntk, n, node_names ), "&" );
+    }
+    else if ( ntk.is_or( n ) )
+    {
+      writer.on_assign( node_names[n], detail::format_fanin<Ntk>( ntk, n, node_names ), "|" );
+    }
+    else if ( ntk.is_xor( n ) || ntk.is_xor3( n ) )
+    {
+      writer.on_assign( node_names[n], detail::format_fanin<Ntk>( ntk, n, node_names ), "^" );
+    }
+    else if ( ntk.is_maj( n ) )
+    {
+      std::array<signal<Ntk>, 3> children;
+      ntk.foreach_fanin( n, [&]( auto const& f, auto i ) { children[i] = f; } );
+
+      if ( ntk.is_constant( ntk.get_node( children[0u] ) ) )
+      {
+        std::vector<std::pair<bool, std::string>> vs;
+        vs.emplace_back( std::make_pair( ntk.is_complemented( children[1u] ), node_names[ntk.get_node( children[1u] )] ) );
+        vs.emplace_back( std::make_pair( ntk.is_complemented( children[2u] ), node_names[ntk.get_node( children[2u] )] ) );
+
+        if ( ntk.is_complemented( children[0u] ) )
+        {
+          // or
+          writer.on_assign( node_names[n], { vs[0u], vs[1u] }, "|" );
+        }
+        else
+        {
+          // and
+          writer.on_assign( node_names[n], { vs[0u], vs[1u] }, "&" );
+        }
+      }
+      else
+      {
+        writer.on_assign_maj3( node_names[n], detail::format_fanin<Ntk>( ntk, n, node_names ) );
+      }
+    }
+    else if ( ntk.is_ite( n ) )
+    {
+      std::array<signal<Ntk>, 3> children;
+      ntk.foreach_fanin( n, [&]( auto const& f, auto i ) { children[i] = f; } );
+
+      if ( ntk.is_constant( ntk.get_node( children[1u] ) ) )
+      {
+        assert( children[1u] == ntk.get_constant( false ) );
+        // a ? 0 : c = ~a & c
+        std::vector<std::pair<bool, std::string>> ins;
+        ins.emplace_back( std::make_pair( !ntk.is_complemented( children[0u] ), node_names[ntk.get_node( children[0u] )] ) );
+        ins.emplace_back( std::make_pair( ntk.is_complemented( children[2u] ), node_names[ntk.get_node( children[2u] )] ) );
+        writer.on_assign( node_names[n], ins, "&" );
+      }
+      else if ( ntk.get_node( children[1u] ) == ntk.get_node( children[2u] ) )
+      {
+        assert( !ntk.is_complemented( children[1u] ) && ntk.is_complemented( children[2u] ) );
+        // a ? b : ~b = a ^ ~b
+        std::vector<std::pair<bool, std::string>> ins;
+        ins.emplace_back( std::make_pair( ntk.is_complemented( children[0u] ), node_names[ntk.get_node( children[0u] )] ) );
+        ins.emplace_back( std::make_pair( ntk.is_complemented( children[2u] ), node_names[ntk.get_node( children[2u] )] ) );
+        writer.on_assign( node_names[n], ins, "^" );
+      }
+      else
+      {
+        writer.on_assign_mux21( node_names[n], detail::format_fanin<Ntk>( ntk, n, node_names ) );
+      }
+    }
+    else
+    {
+      if constexpr ( has_is_nary_and_v<Ntk> )
+      {
+        if ( ntk.is_nary_and( n ) )
+        {
+          writer.on_assign( node_names[n], detail::format_fanin<Ntk>( ntk, n, node_names ), "&" );
+          return true;
+        }
+      }
+      if constexpr ( has_is_nary_or_v<Ntk> )
+      {
+        if ( ntk.is_nary_or( n ) )
+        {
+          writer.on_assign( node_names[n], detail::format_fanin<Ntk>( ntk, n, node_names ), "|" );
+          return true;
+        }
+      }
+      if constexpr ( has_is_nary_xor_v<Ntk> )
+      {
+        if ( ntk.is_nary_xor( n ) )
+        {
+          writer.on_assign( node_names[n], detail::format_fanin<Ntk>( ntk, n, node_names ), "^" );
+          return true;
+        }
+      }
+      if constexpr ( has_is_function_v<Ntk> )
+      {
+        fmt::print( stderr, "[w] unknown node function {}\n", kitty::to_hex( ntk.node_function( n ) ) );
+      }
+      writer.on_assign_unknown_gate( node_names[n] );
+    }
+
+    return true;
+  } );
+
+  ntk.foreach_po( [&]( auto const& f, auto i ) {
+    writer.on_assign_po( ys[i], std::make_pair( ntk.is_complemented( f ), node_names[f] ) );
+  } );
+
+  writer.on_module_end();
+}
+
+/*! \brief Writes mapped network in structural Verilog format into output stream
+ *
+ * **Required network functions:**
+ * - `num_pis`
+ * - `num_pos`
+ * - `foreach_pi`
+ * - `foreach_node`
+ * - `foreach_fanin`
+ * - `get_node`
+ * - `get_constant`
+ * - `is_constant`
+ * - `is_pi`
+ * - `node_to_index`
+ * - `has_binding`
+ * - `get_binding_index`
+ *
+ * \param ntk Mapped network
+ * \param os Output stream
+ * \param ps Verilog parameters
+ */
+template<class Ntk>
+void write_verilog_with_binding( Ntk const& ntk, std::ostream& os, write_verilog_params const& ps = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_num_pis_v<Ntk>, "Ntk does not implement the num_pis method" );
+  static_assert( has_num_pos_v<Ntk>, "Ntk does not implement the num_pos method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_has_binding_v<Ntk>, "Ntk does not implement the has_binding method" );
+  static_assert( has_get_binding_index_v<Ntk>, "Ntk does not implement the get_binding_index method" );
+
+  assert( ntk.is_combinational() && "Network has to be combinational" );
+
+  lorina::verilog_writer writer( os );
+
+  std::vector<std::string> xs, inputs;
+  if ( ps.input_names.empty() )
+  {
+    if constexpr ( has_has_name_v<Ntk> && has_get_name_v<Ntk> )
+    {
+      ntk.foreach_pi( [&]( auto const& i, uint32_t index ) {
+        if ( ntk.has_name( ntk.make_signal( i ) ) )
+        {
+          xs.emplace_back( ntk.get_name( ntk.make_signal( i ) ) );
+        }
+        else
+        {
+          xs.emplace_back( fmt::format( "x{}", index ) );
+        }
+      } );
+    }
+    else
+    {
+      for ( auto i = 0u; i < ntk.num_pis(); ++i )
+      {
+        xs.emplace_back( fmt::format( "x{}", i ) );
+      }
+    }
+    inputs = xs;
+  }
+  else
+  {
+    uint32_t ctr{ 0u };
+    for ( auto const& [name, width] : ps.input_names )
+    {
+      inputs.emplace_back( name );
+      ctr += width;
+      for ( auto i = 0u; i < width; ++i )
+      {
+        xs.emplace_back( fmt::format( "{}[{}]", name, i ) );
+      }
+    }
+    if ( ctr != ntk.num_pis() )
+    {
+      std::cerr << "[e] input names do not partition all inputs\n";
+    }
+  }
+
+  std::vector<std::string> ys, outputs;
+  if ( ps.output_names.empty() )
+  {
+    if constexpr ( has_has_output_name_v<Ntk> && has_get_output_name_v<Ntk> )
+    {
+      ntk.foreach_po( [&]( auto const& o, uint32_t index ) {
+        if ( ntk.has_output_name( index ) )
+        {
+          ys.emplace_back( ntk.get_output_name( index ) );
+        }
+        else
+        {
+          ys.emplace_back( fmt::format( "y{}", index ) );
+        }
+      } );
+    }
+    else
+    {
+      for ( auto i = 0u; i < ntk.num_pos(); ++i )
+      {
+        ys.emplace_back( fmt::format( "y{}", i ) );
+      }
+    }
+    outputs = ys;
+  }
+  else
+  {
+    uint32_t ctr{ 0u };
+    for ( auto const& [name, width] : ps.output_names )
+    {
+      outputs.emplace_back( name );
+      ctr += width;
+      for ( auto i = 0u; i < width; ++i )
+      {
+        ys.emplace_back( fmt::format( "{}[{}]", name, i ) );
+      }
+    }
+    if ( ctr != ntk.num_pos() )
+    {
+      std::cerr << "[e] output names do not partition all outputs\n";
+    }
+  }
+
+  /* compute which nodes are POs and register index */
+  node_map<std::vector<uint32_t>, Ntk, std::unordered_map<typename Ntk::node, std::vector<uint32_t>>> po_nodes( ntk );
+  ntk.foreach_po( [&]( auto const& f, auto i ) {
+    po_nodes[f].push_back( i );
+  } );
+
+  std::vector<std::string> ws;
+  node_map<std::string, Ntk> node_names( ntk );
+
+  /* constants */
+  if ( ntk.has_binding( ntk.get_constant( false ) ) )
+  {
+    node_names[ntk.get_constant( false )] = fmt::format( "n{}", ntk.node_to_index( ntk.get_constant( false ) ) );
+    if ( !po_nodes.has( ntk.get_constant( false ) ) )
+    {
+      ws.emplace_back( node_names[ntk.get_constant( false )] );
+    }
+  }
+  else
+  {
+    node_names[ntk.get_constant( false )] = "1'b0";
+  }
+  if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+  {
+    if ( ntk.has_binding( ntk.get_constant( true ) ) )
+    {
+      node_names[ntk.get_constant( true )] = fmt::format( "n{}", ntk.node_to_index( ntk.get_constant( true ) ) );
+      if ( !po_nodes.has( ntk.get_constant( true ) ) )
+      {
+        ws.emplace_back( node_names[ntk.get_constant( true )] );
+      }
+    }
+    else
+    {
+      node_names[ntk.get_constant( true )] = "1'b1";
+    }
+  }
+
+  /* add wires */
+  ntk.foreach_gate( [&]( auto const& n ) {
+    if ( !po_nodes.has( n ) )
+    {
+      ws.emplace_back( fmt::format( "n{}", ntk.node_to_index( n ) ) );
+    }
+  } );
+
+  std::string module_name = "top";
+  if ( ps.module_name )
+  {
+    module_name = *ps.module_name;
+  }
+  else
+  {
+    if constexpr ( has_get_network_name_v<Ntk> )
+    {
+      if ( ntk.get_network_name().length() > 0 )
+      {
+        module_name = ntk.get_network_name();
+      }
+    }
+  }
+  writer.on_module_begin( module_name, inputs, outputs );
+  if ( ps.input_names.empty() )
+  {
+    writer.on_input( xs );
+  }
+  else
+  {
+    for ( auto const& [name, width] : ps.input_names )
+    {
+      writer.on_input( width, name );
+    }
+  }
+  if ( ps.output_names.empty() )
+  {
+    writer.on_output( ys );
+  }
+  else
+  {
+    for ( auto const& [name, width] : ps.output_names )
+    {
+      writer.on_output( width, name );
+    }
+  }
+  if ( !ws.empty() )
+  {
+    writer.on_wire( ws );
+  }
+
+  ntk.foreach_pi( [&]( auto const& n, auto i ) {
+    node_names[n] = xs[i];
+  } );
+
+  auto const& gates = ntk.get_library();
+
+  int nDigits = (int)std::floor( std::log10( ntk.num_gates() ) );
+  unsigned int length = 0;
+  unsigned counter = 0;
+
+  for ( auto const& gate : gates )
+  {
+    length = std::max( length, static_cast<unsigned int>( gate.name.length() ) );
+  }
+
+  topo_view ntk_topo{ ntk };
+
+  ntk_topo.foreach_node( [&]( auto const& n ) {
+    if ( po_nodes.has( n ) )
+    {
+      node_names[n] = ys[po_nodes[n][0]];
+    }
+    else if ( !ntk.is_constant( n ) && !ntk.is_pi( n ) )
+    {
+      node_names[n] = fmt::format( "n{}", ntk.node_to_index( n ) );
+    }
+
+    if ( ntk.has_binding( n ) )
+    {
+      auto const& gate = gates[ntk.get_binding_index( n )];
+      std::string name = gate.name;
+
+      int digits = counter == 0 ? 0 : (int)std::floor( std::log10( counter ) );
+      auto fanin_names = detail::format_fanin<Ntk>( ntk, n, node_names );
+      std::vector<std::pair<std::string, std::string>> args;
+
+      auto i = 0;
+      for ( auto pair : fanin_names )
+      {
+        args.emplace_back( std::make_pair( gate.pins[i++].name, pair.second ) );
+      }
+      args.emplace_back( std::make_pair( gate.output_name, node_names[n] ) );
+
+      writer.on_module_instantiation( name.append( std::string( length - name.length(), ' ' ) ),
+                                      {},
+                                      std::string( "g" ) + std::string( nDigits - digits, '0' ) + std::to_string( counter ),
+                                      args );
+      ++counter;
+
+      /* if node drives multiple POs, duplicate */
+      if ( po_nodes.has( n ) && po_nodes[n].size() > 1 )
+      {
+        if ( ps.verbose )
+        {
+          std::cerr << "[i] node " << n << " driving multiple POs has been duplicated.\n";
+        }
+        auto const& po_list = po_nodes[n];
+        for ( auto i = 1u; i < po_list.size(); ++i )
+        {
+          digits = counter == 0 ? 0 : (int)std::floor( std::log10( counter ) );
+          args[args.size() - 1] = std::make_pair( gate.output_name, ys[po_list[i]] );
+
+          writer.on_module_instantiation( name.append( std::string( length - name.length(), ' ' ) ),
+                                          {},
+                                          std::string( "g" ) + std::string( nDigits - digits, '0' ) + std::to_string( counter ),
+                                          args );
+          ++counter;
+        }
+      }
+    }
+    else if ( !ntk.is_constant( n ) && !ntk.is_pi( n ) )
+    {
+      std::cerr << "[e] internal node " << n << " is not mapped.\n";
+    }
+
+    return true;
+  } );
+
+  writer.on_module_end();
+}
+
+/*! \brief Writes mapped network in structural Verilog format into output stream
+ *
+ * **Required network functions:**
+ * - `num_pis`
+ * - `num_pos`
+ * - `foreach_pi`
+ * - `foreach_node`
+ * - `foreach_fanin`
+ * - `get_node`
+ * - `get_constant`
+ * - `is_constant`
+ * - `is_pi`
+ * - `node_to_index`
+ * - `has_cell`
+ * - `get_cell_index`
+ *
+ * \param ntk Mapped network
+ * \param os Output stream
+ * \param ps Verilog parameters
+ */
+template<class Ntk>
+void write_verilog_with_cell( Ntk const& ntk, std::ostream& os, write_verilog_params const& ps = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_num_pis_v<Ntk>, "Ntk does not implement the num_pis method" );
+  static_assert( has_num_pos_v<Ntk>, "Ntk does not implement the num_pos method" );
+  static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_has_cell_v<Ntk>, "Ntk does not implement the has_cell method" );
+  static_assert( has_get_cell_index_v<Ntk>, "Ntk does not implement the get_cell_index method" );
+
+  assert( ntk.is_combinational() && "Network has to be combinational" );
+
+  lorina::verilog_writer writer( os );
+
+  std::vector<std::string> xs, inputs;
+  if ( ps.input_names.empty() )
+  {
+    if constexpr ( has_has_name_v<Ntk> && has_get_name_v<Ntk> )
+    {
+      ntk.foreach_pi( [&]( auto const& i, uint32_t index ) {
+        if ( ntk.has_name( ntk.make_signal( i ) ) )
+        {
+          xs.emplace_back( ntk.get_name( ntk.make_signal( i ) ) );
+        }
+        else
+        {
+          xs.emplace_back( fmt::format( "x{}", index ) );
+        }
+      } );
+    }
+    else
+    {
+      for ( auto i = 0u; i < ntk.num_pis(); ++i )
+      {
+        xs.emplace_back( fmt::format( "x{}", i ) );
+      }
+    }
+    inputs = xs;
+  }
+  else
+  {
+    uint32_t ctr{ 0u };
+    for ( auto const& [name, width] : ps.input_names )
+    {
+      inputs.emplace_back( name );
+      ctr += width;
+      for ( auto i = 0u; i < width; ++i )
+      {
+        xs.emplace_back( fmt::format( "{}[{}]", name, i ) );
+      }
+    }
+    if ( ctr != ntk.num_pis() )
+    {
+      std::cerr << "[e] input names do not partition all inputs\n";
+    }
+  }
+
+  std::vector<std::string> ys, outputs;
+  if ( ps.output_names.empty() )
+  {
+    if constexpr ( has_has_output_name_v<Ntk> && has_get_output_name_v<Ntk> )
+    {
+      ntk.foreach_po( [&]( auto const& o, uint32_t index ) {
+        if ( ntk.has_output_name( index ) )
+        {
+          ys.emplace_back( ntk.get_output_name( index ) );
+        }
+        else
+        {
+          ys.emplace_back( fmt::format( "y{}", index ) );
+        }
+      } );
+    }
+    else
+    {
+      for ( auto i = 0u; i < ntk.num_pos(); ++i )
+      {
+        ys.emplace_back( fmt::format( "y{}", i ) );
+      }
+    }
+    outputs = ys;
+  }
+  else
+  {
+    uint32_t ctr{ 0u };
+    for ( auto const& [name, width] : ps.output_names )
+    {
+      outputs.emplace_back( name );
+      ctr += width;
+      for ( auto i = 0u; i < width; ++i )
+      {
+        ys.emplace_back( fmt::format( "{}[{}]", name, i ) );
+      }
+    }
+    if ( ctr != ntk.num_pos() )
+    {
+      std::cerr << "[e] output names do not partition all outputs\n";
+    }
+  }
+
+  /* compute which nodes are POs and register index */
+  uint32_t additional_buffers = 0;
+  std::unordered_map<typename Ntk::signal, std::vector<uint32_t>, detail::verilog_writer_signal_hash<typename Ntk::signal>> po_nodes;
+  ntk.foreach_po( [&]( auto const& f, auto i ) {
+    po_nodes[f ^ ntk.is_complemented( f )].push_back( i );
+    additional_buffers += po_nodes[f ^ ntk.is_complemented( f )].size() > 1 ? 1 : 0;
+  } );
+
+  std::vector<std::string> ws;
+  node_map<std::vector<std::string>, Ntk> node_names( ntk );
+
+  /* constants */
+  if ( ntk.has_cell( ntk.get_node( ntk.get_constant( false ) ) ) )
+  {
+    if ( po_nodes.find( ntk.get_constant( false ) ) == po_nodes.end() )
+    {
+      node_names[ntk.get_node( ntk.get_constant( false ) )].push_back( fmt::format( "n{}", ntk.node_to_index( ntk.get_constant( false ) ) ) );
+      ws.emplace_back( node_names[ntk.get_constant( false )].front() );
+    }
+  }
+  else
+  {
+    node_names[ntk.get_node( ntk.get_constant( false ) )].push_back( "1'b0" );
+  }
+  if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+  {
+    if ( ntk.has_cell( ntk.get_node( ntk.get_constant( true ) ) ) )
+    {
+      if ( po_nodes.find( ntk.get_constant( true ) ) == po_nodes.end() )
+      {
+        node_names[ntk.get_node( ntk.get_constant( true ) )].push_back( fmt::format( "n{}", ntk.node_to_index( ntk.get_constant( true ) ) ) );
+        ws.emplace_back( node_names[ntk.get_constant( true )].front() );
+      }
+    }
+    else
+    {
+      node_names[ntk.get_constant( true )].push_back( "1'b1" );
+    }
+  }
+
+  /* add wires */
+  ntk.foreach_gate( [&]( auto const& n ) {
+    if constexpr ( has_is_multioutput_v<Ntk> )
+    {
+      /* create wire for each individual output */
+      if ( !ntk.is_multioutput( n ) && po_nodes.find( ntk.make_signal( n ) ) == po_nodes.end() )
+      {
+        ws.emplace_back( fmt::format( "n{}", ntk.node_to_index( n ) ) );
+        return;
+      }
+
+      for ( uint32_t i = 0; i < ntk.num_outputs( n ); ++i )
+      {
+        if ( po_nodes.find( ntk.make_signal( n, i ) ) == po_nodes.end() )
+        {
+          ws.emplace_back( fmt::format( "n{}_{}", ntk.node_to_index( n ), i ) );
+        }
+      }
+
+      return;
+    }
+
+    if ( po_nodes.find( ntk.make_signal( n ) ) == po_nodes.end() )
+    {
+      ws.emplace_back( fmt::format( "n{}", ntk.node_to_index( n ) ) );
+    }
+  } );
+
+  std::string module_name = "top";
+  if ( ps.module_name )
+  {
+    module_name = *ps.module_name;
+  }
+  else
+  {
+    if constexpr ( has_get_network_name_v<Ntk> )
+    {
+      if ( ntk.get_network_name().length() > 0 )
+      {
+        module_name = ntk.get_network_name();
+      }
+    }
+  }
+  writer.on_module_begin( module_name, inputs, outputs );
+  if ( ps.input_names.empty() )
+  {
+    writer.on_input( xs );
+  }
+  else
+  {
+    for ( auto const& [name, width] : ps.input_names )
+    {
+      writer.on_input( width, name );
+    }
+  }
+  if ( ps.output_names.empty() )
+  {
+    writer.on_output( ys );
+  }
+  else
+  {
+    for ( auto const& [name, width] : ps.output_names )
+    {
+      writer.on_output( width, name );
+    }
+  }
+  if ( !ws.empty() )
+  {
+    writer.on_wire( ws );
+  }
+
+  ntk.foreach_pi( [&]( auto const& n, auto i ) {
+    node_names[n].push_back( xs[i] );
+  } );
+
+  auto const& cells = ntk.get_library();
+
+  /* get buffer */
+  uint32_t buf_id = UINT32_MAX;
+  double buf_area = std::numeric_limits<double>::max();
+  for ( uint32_t i = 0; i < cells.size(); ++i )
+  {
+    auto const& g = cells[i].gates.front();
+    if ( cells[i].gates.size() > 1 || g.num_vars != 1 )
+      continue;
+    if ( g.function._bits[0] != 0x2 )
+      continue;
+
+    if ( buf_id == UINT32_MAX || g.area < buf_area )
+    {
+      buf_id = i;
+      buf_area = g.area;
+    }
+  }
+
+  int nDigits = (int)std::floor( std::log10( ntk.num_gates() + additional_buffers ) );
+  unsigned int length = 0;
+  unsigned counter = 0;
+
+  for ( auto const& cell : cells )
+  {
+    length = std::max( length, static_cast<unsigned int>( cell.name.length() ) );
+  }
+
+  topo_view ntk_topo{ ntk };
+
+  ntk_topo.foreach_node( [&]( auto const& n ) {
+    /* load names of n */
+    if constexpr ( has_is_multioutput_v<Ntk> )
+    {
+      /* create wire for each individual output */
+      if ( !ntk.is_multioutput( n ) )
+      {
+        if ( auto el = po_nodes.find( ntk.make_signal( n ) ); el != po_nodes.end() )
+        {
+          node_names[n].emplace_back( ys[el->second.front()] );
+        }
+        else if ( !ntk.is_constant( n ) && !ntk.is_pi( n ) )
+        {
+          node_names[n].emplace_back( fmt::format( "n{}", ntk.node_to_index( n ) ) );
+        }
+      }
+      else
+      {
+        for ( uint32_t i = 0; i < ntk.num_outputs( n ); ++i )
+        {
+          if ( auto el = po_nodes.find( ntk.make_signal( n, i ) ); el != po_nodes.end() )
+          {
+            node_names[n].emplace_back( ys[el->second.front()] );
+          }
+          else
+          {
+            node_names[n].emplace_back( fmt::format( "n{}_{}", ntk.node_to_index( n ), i ) );
+          }
+        }
+      }
+    }
+    else
+    {
+      if ( auto el = po_nodes.find( ntk.make_signal( n ) ); el != po_nodes.end() )
+      {
+        node_names[n] = ys[el->second.front()];
+      }
+      else if ( !ntk.is_constant( n ) && !ntk.is_pi( n ) )
+      {
+        node_names[n] = fmt::format( "n{}", ntk.node_to_index( n ) );
+      }
+    }
+
+    if ( ntk.has_cell( n ) )
+    {
+      auto const& cell = cells[ntk.get_cell_index( n )];
+      std::string name = cell.name;
+
+      int digits = counter == 0 ? 0 : (int)std::floor( std::log10( counter ) );
+      auto fanin_names = detail::format_fanin<Ntk>( ntk, n, node_names );
+      std::vector<std::pair<std::string, std::string>> args;
+
+      auto i = 0;
+      for ( auto pair : fanin_names )
+      {
+        args.emplace_back( std::make_pair( cell.gates[0].pins[i++].name, pair.second ) );
+      }
+
+      assert( cell.gates.size() == node_names[n].size() );
+
+      i = 0;
+      for ( auto const& ogate : cell.gates )
+      {
+        args.emplace_back( std::make_pair( ogate.output_name, node_names[n][i++] ) );
+      }
+
+      writer.on_module_instantiation( name.append( std::string( length - name.length(), ' ' ) ),
+                                      {},
+                                      std::string( "g" ) + std::string( nDigits - digits, '0' ) + std::to_string( counter ),
+                                      args );
+      ++counter;
+
+      /* if node drives multiple POs, buffer */
+      if constexpr ( has_is_multioutput_v<Ntk> )
+      {
+        i = 0;
+        for ( i = 0; i < ntk.num_outputs( n ); ++i )
+        {
+          if ( auto el = po_nodes.find( ntk.make_signal( n, i ) ); el != po_nodes.end() && el->second.size() > 1 )
+          {
+            if ( buf_id == UINT32_MAX )
+            {
+              std::cerr << "[e] Error: cell library does not contain a buffer cell\n";
+              return false;
+            }
+
+            if ( ps.verbose )
+            {
+              std::cerr << "[i] Buffering node " << n << " driving multiple POs.\n";
+            }
+
+            gate const& g = cells[buf_id].gates.front();
+            std::string buf_name = g.name;
+            auto const& po_list = el->second;
+            args.clear();
+            args.emplace_back( std::make_pair( g.pins.front().name, node_names[n].at( i ) ) );
+            args.emplace_back( std::make_pair( "", "" ) );
+            for ( uint32_t j = 1u; j < po_list.size(); ++j )
+            {
+              digits = counter == (int)std::floor( std::log10( counter ) );
+              args[args.size() - 1] = std::make_pair( g.output_name, ys[po_list[j]] );
+
+              writer.on_module_instantiation( buf_name.append( std::string( length - buf_name.length(), ' ' ) ),
+                                              {},
+                                              std::string( "g" ) + std::string( nDigits - digits, '0' ) + std::to_string( counter ),
+                                              args );
+              ++counter;
+            }
+          }
+        }
+      }
+      else
+      {
+        if ( auto el = po_nodes.find( ntk.make_signal( n ) ); el != po_nodes.end() && el->second.size() > 1 )
+        {
+          if ( buf_id == UINT32_MAX )
+          {
+            std::cerr << "[e] Error: cell library does not contain a buffer cell\n";
+            return false;
+          }
+
+          std::cerr << "[i] Buffering node " << n << " driving multiple POs.\n";
+
+          gate const& g = cells[buf_id].gates.front();
+          std::string buf_name = g.name;
+          auto const& po_list = el->second;
+          args.clear();
+          args.emplace_back( std::make_pair( g.pins.front().name, node_names[n].front() ) );
+          args.emplace_back( std::make_pair( "", "" ) );
+          for ( i = 1u; i < po_list.size(); ++i )
+          {
+            digits = counter == (int)std::floor( std::log10( counter ) );
+            args[args.size() - 1] = std::make_pair( g.output_name, ys[po_list[i]] );
+
+            writer.on_module_instantiation( buf_name.append( std::string( length - buf_name.length(), ' ' ) ),
+                                            {},
+                                            std::string( "g" ) + std::string( nDigits - digits, '0' ) + std::to_string( counter ),
+                                            args );
+            ++counter;
+          }
+        }
+      }
+    }
+    else if ( !ntk.is_constant( n ) && !ntk.is_pi( n ) )
+    {
+      std::cerr << "[e] internal node " << n << " is not mapped.\n";
+    }
+
+    return true;
+  } );
+
+  writer.on_module_end();
+}
+
+/*! \brief Writes network in structural Verilog format into a file
+ *
+ * **Required network functions:**
+ * - `num_pis`
+ * - `num_pos`
+ * - `foreach_pi`
+ * - `foreach_node`
+ * - `foreach_fanin`
+ * - `get_node`
+ * - `get_constant`
+ * - `is_constant`
+ * - `is_pi`
+ * - `is_and`
+ * - `is_or`
+ * - `is_xor`
+ * - `is_xor3`
+ * - `is_maj`
+ * - `node_to_index`
+ *
+ * \param ntk Network
+ * \param filename Filename
+ */
+template<class Ntk>
+void write_verilog( Ntk const& ntk, std::string const& filename, write_verilog_params const& ps = {} )
+{
+  std::ofstream os( filename.c_str(), std::ofstream::out );
+  write_verilog( ntk, os, ps );
+  os.close();
+}
+
+/*! \brief Writes mapped network in structural Verilog format into a file
+ *
+ * **Required network functions:**
+ * - `num_pis`
+ * - `num_pos`
+ * - `foreach_pi`
+ * - `foreach_node`
+ * - `foreach_fanin`
+ * - `get_node`
+ * - `get_constant`
+ * - `is_constant`
+ * - `is_pi`
+ * - `node_to_index`
+ * - `has_binding`
+ * - `get_binding_index`
+ *
+ * \param ntk Network (binding_view)
+ * \param filename Filename
+ */
+template<class Ntk>
+void write_verilog_with_binding( Ntk const& ntk, std::string const& filename, write_verilog_params const& ps = {} )
+{
+  std::ofstream os( filename.c_str(), std::ofstream::out );
+  write_verilog_with_binding( ntk, os, ps );
+  os.close();
+}
+
+/*! \brief Writes mapped network in structural Verilog format into a file
+ *
+ * **Required network functions:**
+ * - `num_pis`
+ * - `num_pos`
+ * - `foreach_pi`
+ * - `foreach_node`
+ * - `foreach_fanin`
+ * - `get_node`
+ * - `get_constant`
+ * - `is_constant`
+ * - `is_pi`
+ * - `node_to_index`
+ * - `has_cell`
+ * - `get_cell_index`
+ *
+ * \param ntk Network (cell_view)
+ * \param filename Filename
+ */
+template<class Ntk>
+void write_verilog_with_cell( Ntk const& ntk, std::string const& filename, write_verilog_params const& ps = {} )
+{
+  std::ofstream os( filename.c_str(), std::ofstream::out );
+  write_verilog_with_cell( ntk, os, ps );
+  os.close();
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/mockturtle.hpp b/include/mockturtle/mockturtle.hpp
new file mode 100644
index 0000000..030bfdc
--- /dev/null
+++ b/include/mockturtle/mockturtle.hpp
@@ -0,0 +1,218 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mockturtle.hpp
+  \brief Main header file for mockturtle
+*/
+
+#pragma once
+
+#include "mockturtle/algorithms/aig_resub.hpp"
+#include "mockturtle/algorithms/akers_synthesis.hpp"
+#include "mockturtle/algorithms/aqfp/aqfp_assumptions.hpp"
+#include "mockturtle/algorithms/aqfp/aqfp_db.hpp"
+#include "mockturtle/algorithms/aqfp/aqfp_fanout_resyn.hpp"
+#include "mockturtle/algorithms/aqfp/aqfp_node_resyn.hpp"
+#include "mockturtle/algorithms/aqfp/aqfp_resynthesis.hpp"
+#include "mockturtle/algorithms/aqfp/buffer_insertion.hpp"
+#include "mockturtle/algorithms/aqfp/buffer_verification.hpp"
+#include "mockturtle/algorithms/aqfp/detail/dag.hpp"
+#include "mockturtle/algorithms/aqfp/detail/dag_cost.hpp"
+#include "mockturtle/algorithms/aqfp/detail/dag_gen.hpp"
+#include "mockturtle/algorithms/aqfp/detail/dag_util.hpp"
+#include "mockturtle/algorithms/aqfp/detail/db_builder.hpp"
+#include "mockturtle/algorithms/aqfp/detail/db_utils.hpp"
+#include "mockturtle/algorithms/aqfp/detail/npn_cache.hpp"
+#include "mockturtle/algorithms/aqfp/detail/partial_dag.hpp"
+#include "mockturtle/algorithms/aqfp/mig_algebraic_rewriting_splitters.hpp"
+#include "mockturtle/algorithms/aqfp/mig_resub_splitters.hpp"
+#include "mockturtle/algorithms/balancing.hpp"
+#include "mockturtle/algorithms/balancing/esop_balancing.hpp"
+#include "mockturtle/algorithms/balancing/sop_balancing.hpp"
+#include "mockturtle/algorithms/balancing/utils.hpp"
+#include "mockturtle/algorithms/bi_decomposition.hpp"
+#include "mockturtle/algorithms/cell_window.hpp"
+#include "mockturtle/algorithms/circuit_validator.hpp"
+#include "mockturtle/algorithms/cleanup.hpp"
+#include "mockturtle/algorithms/cnf.hpp"
+#include "mockturtle/algorithms/collapse_mapped.hpp"
+#include "mockturtle/algorithms/cover_to_graph.hpp"
+#include "mockturtle/algorithms/cut_enumeration.hpp"
+#include "mockturtle/algorithms/cut_enumeration/cnf_cut.hpp"
+#include "mockturtle/algorithms/cut_enumeration/exact_map_cut.hpp"
+#include "mockturtle/algorithms/cut_enumeration/gia_cut.hpp"
+#include "mockturtle/algorithms/cut_enumeration/mf_cut.hpp"
+#include "mockturtle/algorithms/cut_enumeration/spectr_cut.hpp"
+#include "mockturtle/algorithms/cut_enumeration/tech_map_cut.hpp"
+#include "mockturtle/algorithms/cut_rewriting.hpp"
+#include "mockturtle/algorithms/decomposition.hpp"
+#include "mockturtle/algorithms/detail/database_generator.hpp"
+#include "mockturtle/algorithms/detail/mffc_utils.hpp"
+#include "mockturtle/algorithms/detail/minmc_xags.hpp"
+#include "mockturtle/algorithms/detail/resub_utils.hpp"
+#include "mockturtle/algorithms/detail/switching_activity.hpp"
+#include "mockturtle/algorithms/dont_cares.hpp"
+#include "mockturtle/algorithms/dsd_decomposition.hpp"
+#include "mockturtle/algorithms/equivalence_checking.hpp"
+#include "mockturtle/algorithms/equivalence_classes.hpp"
+#include "mockturtle/algorithms/exact_mc_synthesis.hpp"
+#include "mockturtle/algorithms/exorcism.hpp"
+#include "mockturtle/algorithms/experimental/boolean_optimization.hpp"
+#include "mockturtle/algorithms/experimental/cost_generic_resub.hpp"
+#include "mockturtle/algorithms/experimental/cost_resyn.hpp"
+#include "mockturtle/algorithms/experimental/sim_resub.hpp"
+#include "mockturtle/algorithms/experimental/window_resub.hpp"
+#include "mockturtle/algorithms/extract_linear.hpp"
+#include "mockturtle/algorithms/functional_reduction.hpp"
+#include "mockturtle/algorithms/gates_to_nodes.hpp"
+#include "mockturtle/algorithms/klut_to_graph.hpp"
+#include "mockturtle/algorithms/linear_resynthesis.hpp"
+#include "mockturtle/algorithms/lut_mapping.hpp"
+#include "mockturtle/algorithms/mapper.hpp"
+#include "mockturtle/algorithms/mig_algebraic_rewriting.hpp"
+#include "mockturtle/algorithms/mig_resub.hpp"
+#include "mockturtle/algorithms/miter.hpp"
+#include "mockturtle/algorithms/network_fuzz_tester.hpp"
+#include "mockturtle/algorithms/node_resynthesis.hpp"
+#include "mockturtle/algorithms/node_resynthesis/akers.hpp"
+#include "mockturtle/algorithms/node_resynthesis/bidecomposition.hpp"
+#include "mockturtle/algorithms/node_resynthesis/cached.hpp"
+#include "mockturtle/algorithms/node_resynthesis/composed.hpp"
+#include "mockturtle/algorithms/node_resynthesis/davio.hpp"
+#include "mockturtle/algorithms/node_resynthesis/direct.hpp"
+#include "mockturtle/algorithms/node_resynthesis/dsd.hpp"
+#include "mockturtle/algorithms/node_resynthesis/exact.hpp"
+#include "mockturtle/algorithms/node_resynthesis/mig_npn.hpp"
+#include "mockturtle/algorithms/node_resynthesis/null.hpp"
+#include "mockturtle/algorithms/node_resynthesis/shannon.hpp"
+#include "mockturtle/algorithms/node_resynthesis/traits.hpp"
+#include "mockturtle/algorithms/node_resynthesis/xag_minmc.hpp"
+#include "mockturtle/algorithms/node_resynthesis/xag_minmc2.hpp"
+#include "mockturtle/algorithms/node_resynthesis/xag_npn.hpp"
+#include "mockturtle/algorithms/node_resynthesis/xmg3_npn.hpp"
+#include "mockturtle/algorithms/node_resynthesis/xmg_npn.hpp"
+#include "mockturtle/algorithms/pattern_generation.hpp"
+#include "mockturtle/algorithms/reconv_cut.hpp"
+#include "mockturtle/algorithms/refactoring.hpp"
+#include "mockturtle/algorithms/resubstitution.hpp"
+#include "mockturtle/algorithms/resyn_engines/aig_enumerative.hpp"
+#include "mockturtle/algorithms/resyn_engines/mig_enumerative.hpp"
+#include "mockturtle/algorithms/resyn_engines/mig_resyn.hpp"
+#include "mockturtle/algorithms/resyn_engines/xag_resyn.hpp"
+#include "mockturtle/algorithms/satlut_mapping.hpp"
+#include "mockturtle/algorithms/sim_resub.hpp"
+#include "mockturtle/algorithms/simulation.hpp"
+#include "mockturtle/algorithms/testcase_minimizer.hpp"
+#include "mockturtle/algorithms/window_rewriting.hpp"
+#include "mockturtle/algorithms/xag_optimization.hpp"
+#include "mockturtle/algorithms/xag_resub_withDC.hpp"
+#include "mockturtle/algorithms/xmg_algebraic_rewriting.hpp"
+#include "mockturtle/algorithms/xmg_optimization.hpp"
+#include "mockturtle/algorithms/xmg_resub.hpp"
+#include "mockturtle/generators/arithmetic.hpp"
+#include "mockturtle/generators/control.hpp"
+#include "mockturtle/generators/legacy.hpp"
+#include "mockturtle/generators/majority.hpp"
+#include "mockturtle/generators/majority_n.hpp"
+#include "mockturtle/generators/modular_arithmetic.hpp"
+#include "mockturtle/generators/random_network.hpp"
+#include "mockturtle/generators/self_dualize.hpp"
+#include "mockturtle/generators/sorting.hpp"
+#include "mockturtle/io/aiger_reader.hpp"
+#include "mockturtle/io/bench_reader.hpp"
+#include "mockturtle/io/blif_reader.hpp"
+#include "mockturtle/io/bristol_reader.hpp"
+#include "mockturtle/io/dimacs_reader.hpp"
+#include "mockturtle/io/genlib_reader.hpp"
+#include "mockturtle/io/pla_reader.hpp"
+#include "mockturtle/io/serialize.hpp"
+#include "mockturtle/io/super_reader.hpp"
+#include "mockturtle/io/verilog_reader.hpp"
+#include "mockturtle/io/write_aiger.hpp"
+#include "mockturtle/io/write_bench.hpp"
+#include "mockturtle/io/write_blif.hpp"
+#include "mockturtle/io/write_dimacs.hpp"
+#include "mockturtle/io/write_dot.hpp"
+#include "mockturtle/io/write_patterns.hpp"
+#include "mockturtle/io/write_verilog.hpp"
+#include "mockturtle/networks/abstract_xag.hpp"
+#include "mockturtle/networks/aig.hpp"
+#include "mockturtle/networks/aqfp.hpp"
+#include "mockturtle/networks/buffered.hpp"
+#include "mockturtle/networks/cover.hpp"
+#include "mockturtle/networks/detail/foreach.hpp"
+#include "mockturtle/networks/events.hpp"
+#include "mockturtle/networks/klut.hpp"
+#include "mockturtle/networks/mig.hpp"
+#include "mockturtle/networks/muxig.hpp"
+#include "mockturtle/networks/sequential.hpp"
+#include "mockturtle/networks/storage.hpp"
+#include "mockturtle/networks/tig.hpp"
+#include "mockturtle/networks/xag.hpp"
+#include "mockturtle/networks/xmg.hpp"
+#include "mockturtle/networks/crossed.hpp"
+#include "mockturtle/properties/aqfpcost.hpp"
+#include "mockturtle/properties/mccost.hpp"
+#include "mockturtle/properties/migcost.hpp"
+#include "mockturtle/properties/xmgcost.hpp"
+#include "mockturtle/traits.hpp"
+#include "mockturtle/utils/algorithm.hpp"
+#include "mockturtle/utils/cost_functions.hpp"
+#include "mockturtle/utils/cuts.hpp"
+#include "mockturtle/utils/debugging_utils.hpp"
+#include "mockturtle/utils/hash_functions.hpp"
+#include "mockturtle/utils/include/percy.hpp"
+#include "mockturtle/utils/index_list.hpp"
+#include "mockturtle/utils/json_utils.hpp"
+#include "mockturtle/utils/mixed_radix.hpp"
+#include "mockturtle/utils/name_utils.hpp"
+#include "mockturtle/utils/network_cache.hpp"
+#include "mockturtle/utils/network_utils.hpp"
+#include "mockturtle/utils/node_map.hpp"
+#include "mockturtle/utils/progress_bar.hpp"
+#include "mockturtle/utils/recursive_cost_functions.hpp"
+#include "mockturtle/utils/stopwatch.hpp"
+#include "mockturtle/utils/string_utils.hpp"
+#include "mockturtle/utils/super_utils.hpp"
+#include "mockturtle/utils/tech_library.hpp"
+#include "mockturtle/utils/truth_table_cache.hpp"
+#include "mockturtle/utils/truth_table_utils.hpp"
+#include "mockturtle/utils/window_utils.hpp"
+#include "mockturtle/views/binding_view.hpp"
+#include "mockturtle/views/cnf_view.hpp"
+#include "mockturtle/views/color_view.hpp"
+#include "mockturtle/views/cost_view.hpp"
+#include "mockturtle/views/cut_view.hpp"
+#include "mockturtle/views/depth_view.hpp"
+#include "mockturtle/views/fanout_limit_view.hpp"
+#include "mockturtle/views/fanout_view.hpp"
+#include "mockturtle/views/immutable_view.hpp"
+#include "mockturtle/views/mapping_view.hpp"
+#include "mockturtle/views/mffc_view.hpp"
+#include "mockturtle/views/names_view.hpp"
+#include "mockturtle/views/topo_view.hpp"
+#include "mockturtle/views/window_view.hpp"
+#include "mockturtle/views/rank_view.hpp"
diff --git a/include/mockturtle/networks/abstract_xag.hpp b/include/mockturtle/networks/abstract_xag.hpp
new file mode 100644
index 0000000..632f109
--- /dev/null
+++ b/include/mockturtle/networks/abstract_xag.hpp
@@ -0,0 +1,892 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file abstract_xag.hpp
+  \brief Abstract XAG logic network implementation
+
+  This network type is (for now) only meant for experimental use cases.
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <stack>
+#include <string>
+
+#include <fmt/format.h>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/operators.hpp>
+#include <parallel_hashmap/phmap.h>
+
+#include "../traits.hpp"
+#include "../utils/algorithm.hpp"
+#include "detail/foreach.hpp"
+
+namespace mockturtle
+{
+
+struct abstract_xag_storage
+{
+  struct node_type
+  {
+    uint32_t* fanin{};
+    uint32_t fanin_size{};
+    uint32_t fanout_size{};
+    uint32_t value{};
+    uint32_t visited{};
+    uint32_t level{};
+  };
+
+  abstract_xag_storage()
+  {
+    /* constant 0 node */
+    nodes.emplace_back();
+
+    // nodes.reserve( 10000u );
+  }
+
+  ~abstract_xag_storage()
+  {
+    for ( auto& n : nodes )
+    {
+      if ( n.fanin )
+      {
+        delete[] n.fanin;
+      }
+    }
+  }
+
+  struct abstract_xag_node_eq
+  {
+    bool operator()( abstract_xag_storage::node_type const& a, abstract_xag_storage::node_type const& b ) const
+    {
+      return a.fanin_size == b.fanin_size && std::equal( a.fanin, a.fanin + a.fanin_size, b.fanin );
+    }
+  };
+
+  struct abstract_xag_node_hash
+  {
+    uint64_t operator()( abstract_xag_storage::node_type const& n ) const
+    {
+      return std::accumulate( n.fanin, n.fanin + n.fanin_size, UINT64_C( 0 ), [&]( auto accu, auto c ) { return accu + std::hash<uint32_t>{}( c ); } );
+    }
+  };
+
+  std::vector<node_type> nodes;
+  std::vector<uint32_t> children;
+  std::vector<uint32_t> inputs;
+  std::vector<std::pair<uint32_t, bool>> outputs;
+  phmap::flat_hash_map<node_type, uint32_t, abstract_xag_node_hash, abstract_xag_node_eq> hash;
+
+  uint32_t trav_id = 0u;
+  uint32_t depth = 0u;
+};
+
+class abstract_xag_network
+{
+public:
+#pragma region Types and constructors
+  static constexpr auto min_fanin_size = 1u;
+  static constexpr auto max_fanin_size = std::numeric_limits<uint32_t>::max();
+
+  using base_type = abstract_xag_network;
+  using storage_type = abstract_xag_storage;
+  using storage = std::shared_ptr<storage_type>;
+  using node = uint32_t;
+
+  struct signal
+  {
+    signal() = default;
+    signal( uint32_t index, bool complement = false ) : index( index ), complement( complement ) {}
+
+    uint32_t index;
+    bool complement;
+
+    signal operator!() const
+    {
+      return { index, !complement };
+    }
+
+    signal operator+() const
+    {
+      return { index, false };
+    }
+
+    signal operator-() const
+    {
+      return { index, true };
+    }
+
+    signal operator^( bool complement ) const
+    {
+      return { index, this->complement != complement };
+    }
+
+    bool operator==( signal const& other ) const
+    {
+      return index == other.index && complement == other.complement;
+    }
+
+    bool operator!=( signal const& other ) const
+    {
+      return index != other.index || complement != other.complement;
+    }
+
+    bool operator<( signal const& other ) const
+    {
+      return index < other.index || ( index == other.index && !complement && other.complement );
+    }
+  };
+
+  abstract_xag_network()
+      : _storage( std::make_shared<storage_type>() )
+  {
+  }
+
+  abstract_xag_network( std::shared_ptr<storage_type> storage )
+      : _storage( storage )
+  {
+  }
+#pragma endregion
+
+#pragma region Primary I / O and constants
+  signal get_constant( bool value ) const
+  {
+    return { 0, value };
+  }
+
+  signal create_pi()
+  {
+    const auto index = static_cast<uint32_t>( _storage->nodes.size() );
+    _storage->nodes.emplace_back();
+    _storage->inputs.emplace_back( index );
+    return { index, 0 };
+  }
+
+  uint32_t create_po( signal const& f )
+  {
+    /* increase ref-count to children */
+    _storage->nodes[f.index].fanout_size++;
+    auto const po_index = static_cast<uint32_t>( _storage->outputs.size() );
+    _storage->outputs.emplace_back( f.index, f.complement );
+    _storage->depth = std::max( _storage->depth, level( f.index ) );
+    return po_index;
+  }
+
+  bool is_combinational() const
+  {
+    return true;
+  }
+
+  bool is_constant( node const& n ) const
+  {
+    return n == 0;
+  }
+
+  bool is_pi( node const& n ) const
+  {
+    return n > 0 && _storage->nodes[n].fanin_size == 0u;
+  }
+
+  bool is_ci( node const& n ) const
+  {
+    return n > 0 && _storage->nodes[n].fanin_size == 0u;
+  }
+
+  bool constant_value( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+#pragma endregion
+
+#pragma region Create unary functions
+  signal create_buf( signal const& a )
+  {
+    return a;
+  }
+
+  signal create_not( signal const& a )
+  {
+    return !a;
+  }
+#pragma endregion
+
+#pragma region Create binary functions
+  signal _create_node( std::vector<uint32_t> const& fanin, uint32_t level_offset )
+  {
+    storage::element_type::node_type node;
+    node.fanin = new uint32_t[fanin.size()];
+    node.fanin_size = fanin.size();
+    std::copy( fanin.begin(), fanin.end(), node.fanin );
+
+    /* structural hashing */
+    if ( const auto it = _storage->hash.find( node ); it != _storage->hash.end() )
+    {
+      delete[] node.fanin;
+      return { it->second, 0 };
+    }
+
+    const auto index = static_cast<uint32_t>( _storage->nodes.size() );
+    _storage->nodes.push_back( node );
+    _storage->hash.emplace( node, index );
+
+    /* increase ref-count to children */
+    uint32_t _level = 0u;
+    for ( auto const& f : fanin )
+    {
+      _storage->nodes[f].fanout_size++;
+      _level = std::max( _level, level( f ) );
+    }
+    _storage->nodes[index].level = _level + level_offset;
+
+    return { index, 0u };
+  }
+
+  signal create_and( signal a, signal b )
+  {
+    /* order inputs a > b it is a AND */
+    if ( a.index < b.index )
+    {
+      std::swap( a, b );
+    }
+    /* trivial cases */
+    if ( a.index == b.index )
+    {
+      return a.complement == b.complement ? a : get_constant( false );
+    }
+    else if ( b.index == 0 )
+    {
+      return b.complement == false ? get_constant( false ) : a;
+    }
+    /* constant propagation */
+    else if ( a.complement && b.complement )
+    {
+      return !create_nary_xor( { +a, +b, create_and( +a, +b ) } );
+    }
+    else if ( a.complement )
+    {
+      return create_xor( create_and( +a, b ), b );
+    }
+    else if ( b.complement )
+    {
+      return create_xor( create_and( a, +b ), a );
+    }
+
+    /* subset resolution */
+    const auto& anode = _storage->nodes[a.index];
+    const auto& bnode = _storage->nodes[b.index];
+
+    const auto a_begin = is_nary_xor( a.index ) ? anode.fanin : &a.index;
+    const auto a_end = is_nary_xor( a.index ) ? anode.fanin + anode.fanin_size : &a.index + 1;
+    const auto b_begin = is_nary_xor( b.index ) ? bnode.fanin : &b.index;
+    const auto b_end = is_nary_xor( b.index ) ? bnode.fanin + bnode.fanin_size : &b.index + 1;
+
+    if ( std::includes( a_begin, a_end, b_begin, b_end ) )
+    {
+      std::vector<uint32_t> set_anew;
+      std::set_difference( a_begin, a_end, b_begin, b_end, std::back_inserter( set_anew ) );
+      return create_xor( b, create_and( b, _create_nary_xor( set_anew ) ) );
+    }
+    else if ( std::includes( b_begin, b_end, a_begin, a_end ) )
+    {
+      std::vector<uint32_t> set_bnew;
+      std::set_difference( b_begin, b_end, a_begin, a_end, std::back_inserter( set_bnew ) );
+      return create_xor( a, create_and( a, _create_nary_xor( set_bnew ) ) );
+    }
+
+    return _create_node( std::vector<uint32_t>{ { a.index, b.index } }, 1u );
+  }
+
+  signal create_nand( signal const& a, signal const& b )
+  {
+    return !create_and( a, b );
+  }
+
+  signal create_or( signal const& a, signal const& b )
+  {
+    return !create_and( !a, !b );
+  }
+
+  signal create_nor( signal const& a, signal const& b )
+  {
+    return create_and( !a, !b );
+  }
+
+  signal create_lt( signal const& a, signal const& b )
+  {
+    return create_and( !a, b );
+  }
+
+  signal create_le( signal const& a, signal const& b )
+  {
+    return !create_and( a, !b );
+  }
+
+  signal create_xor( signal const& a, signal const& b )
+  {
+    return create_nary_xor( { a, b } );
+  }
+
+  signal create_xnor( signal const& a, signal const& b )
+  {
+    return !create_xor( a, b );
+  }
+#pragma endregion
+
+#pragma region Create ternary functions
+  signal create_ite( signal cond, signal f_then, signal f_else )
+  {
+    bool f_compl{ false };
+    if ( f_then.index < f_else.index )
+    {
+      std::swap( f_then, f_else );
+      cond.complement ^= 1;
+    }
+    if ( f_then.complement )
+    {
+      f_then.complement = 0;
+      f_else.complement ^= 1;
+      f_compl = true;
+    }
+
+    return create_xor( create_and( !cond, create_xor( f_then, f_else ) ), f_then ) ^ f_compl;
+  }
+
+  signal create_maj( signal const& a, signal const& b, signal const& c )
+  {
+    auto c1 = create_xor( a, b );
+    auto c2 = create_xor( a, c );
+    auto c3 = create_and( c1, c2 );
+    return create_xor( a, c3 );
+  }
+
+  signal create_xor3( signal const& a, signal const& b, signal const& c )
+  {
+    return create_nary_xor( { a, b, c } );
+  }
+#pragma endregion
+
+#pragma region Create nary functions
+  signal create_nary_and( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( true ), [this]( auto const& a, auto const& b ) { return create_and( a, b ); } );
+  }
+
+  signal create_nary_or( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_or( a, b ); } );
+  }
+
+  signal _create_nary_xor( std::vector<uint32_t> const& fs )
+  {
+    std::vector<uint32_t> _fs;
+
+    const auto merge_one = [&]( uint32_t f ) {
+      const auto it = std::lower_bound( _fs.begin(), _fs.end(), f );
+      if ( it != _fs.end() && *it == f )
+      {
+        _fs.erase( it );
+      }
+      else
+      {
+        _fs.insert( it, f );
+      }
+    };
+
+    const auto merge_many = [&]( uint32_t* begin, uint32_t* end ) {
+      std::vector<uint32_t> tmp;
+      std::set_symmetric_difference( _fs.begin(), _fs.end(), begin, end, std::back_inserter( tmp ) );
+      _fs = std::move( tmp );
+    };
+
+    for ( auto const& f : fs )
+    {
+      auto const& node = _storage->nodes[f];
+      if ( node.fanin_size == 0u )
+      {
+        merge_one( f );
+      }
+      else if ( node.fanin[0] > node.fanin[1] )
+      {
+        merge_one( f );
+      }
+      else
+      {
+        merge_many( node.fanin, node.fanin + node.fanin_size );
+      }
+    }
+
+    if ( _fs.empty() )
+    {
+      return get_constant( false );
+    }
+    else if ( _fs.size() == 1u )
+    {
+      return { _fs.front(), false };
+    }
+    else
+    {
+      return _create_node( _fs, 0u );
+    }
+  }
+
+  signal create_nary_xor( std::vector<signal> const& fs )
+  {
+    std::vector<uint32_t> _fs;
+
+    const auto merge_one = [&]( uint32_t f ) {
+      const auto it = std::lower_bound( _fs.begin(), _fs.end(), f );
+      if ( it != _fs.end() && *it == f )
+      {
+        _fs.erase( it );
+      }
+      else
+      {
+        _fs.insert( it, f );
+      }
+    };
+
+    const auto merge_many = [&]( uint32_t* begin, uint32_t* end ) {
+      std::vector<uint32_t> tmp;
+      std::set_symmetric_difference( _fs.begin(), _fs.end(), begin, end, std::back_inserter( tmp ) );
+      _fs = std::move( tmp );
+    };
+
+    bool complement{ false };
+    for ( auto const& f : fs )
+    {
+      complement ^= f.complement;
+      auto const& node = _storage->nodes[f.index];
+      if ( f.index == 0 )
+      {
+        // do nothing
+      }
+      else if ( node.fanin_size == 0u )
+      {
+        merge_one( f.index );
+      }
+      else if ( node.fanin[0] > node.fanin[1] )
+      {
+        merge_one( f.index );
+      }
+      else
+      {
+        merge_many( node.fanin, node.fanin + node.fanin_size );
+      }
+    }
+
+    if ( _fs.empty() )
+    {
+      return get_constant( complement );
+    }
+    else if ( _fs.size() == 1u )
+    {
+      return { _fs.front(), complement };
+    }
+    else
+    {
+      return _create_node( _fs, 0u ) ^ complement;
+    }
+  }
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  signal clone_node( abstract_xag_network const& other, node const& source, std::vector<signal> const& children )
+  {
+    if ( other.is_and( source ) )
+    {
+      return create_and( children[0u], children[1u] );
+    }
+    else
+    {
+      return create_nary_xor( children );
+    }
+  }
+#pragma endregion
+
+#pragma region Nodes and signals
+  node get_node( signal const& f ) const
+  {
+    return f.index;
+  }
+
+  signal make_signal( node const& n ) const
+  {
+    return { n, false };
+  }
+
+  bool is_complemented( signal const& f ) const
+  {
+    return f.complement;
+  }
+
+  uint32_t node_to_index( node const& n ) const
+  {
+    return n;
+  }
+
+  node index_to_node( uint32_t index ) const
+  {
+    return index;
+  }
+
+  node pi_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return _storage->inputs[index];
+  }
+
+  signal po_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    const auto po = _storage->outputs[index];
+    return { po.first, po.second };
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    auto r = range<uint32_t>( _storage->nodes.size() );
+    detail::foreach_element( r.begin(), r.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_ci( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_co( Fn&& fn ) const
+  {
+    using Iterator = decltype( _storage->outputs.begin() );
+    using ElementType = signal;
+    detail::foreach_element_transform<Iterator, ElementType>(
+        _storage->outputs.begin(), _storage->outputs.end(), []( auto const& po ) -> signal { return { po.first, po.second }; }, fn );
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    using Iterator = decltype( _storage->outputs.begin() );
+    detail::foreach_element_transform<Iterator, signal>(
+        _storage->outputs.begin(), _storage->outputs.end(), []( auto const& po ) -> signal { return { po.first, po.second }; }, fn );
+  }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    auto r = range<uint32_t>( 1u, _storage->nodes.size() ); /* start from 1 to avoid constants */
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_pi( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_fanin( node const& n, Fn&& fn ) const
+  {
+    if ( n == 0 || is_pi( n ) )
+      return;
+
+    const auto& node = _storage->nodes[n];
+    detail::foreach_element_transform<uint32_t*, signal>(
+        node.fanin, node.fanin + node.fanin_size, []( auto c ) -> signal { return { c, false }; }, fn );
+  }
+#pragma endregion
+
+#pragma region Structural properties
+  uint32_t size() const
+  {
+    return num_gates() + num_pis() + 1u;
+  }
+
+  uint32_t num_pis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  uint32_t num_pos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  uint32_t num_gates() const
+  {
+    return static_cast<uint32_t>( _storage->hash.size() );
+  }
+
+  uint32_t fanin_size( node const& n ) const
+  {
+    return _storage->nodes[n].fanin_size;
+  }
+
+  uint32_t fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].fanout_size;
+  }
+
+  uint32_t incr_fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].fanout_size++;
+  }
+
+  uint32_t decr_fanout_size( node const& n ) const
+  {
+    return --_storage->nodes[n].fanout_size;
+  }
+
+  uint32_t depth() const
+  {
+    return _storage->depth;
+  }
+
+  uint32_t level( node const& n ) const
+  {
+    return _storage->nodes[n].level;
+  }
+
+  bool is_and( node const& n ) const
+  {
+    const auto& node = _storage->nodes[n];
+    return node.fanin_size == 2 && ( node.fanin[0] > node.fanin[1] );
+  }
+
+  bool is_or( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_xor( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_maj( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_ite( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_xor3( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_and( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_or( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_xor( node const& n ) const
+  {
+    const auto& node = _storage->nodes[n];
+    return node.fanin_size != 0u && ( node.fanin[0] < node.fanin[1] );
+  }
+#pragma endregion
+
+#pragma region Value simulation
+  template<typename Iterator>
+  iterates_over_t<Iterator, bool>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    assert( n != 0 && !is_pi( n ) );
+
+    const auto& node = _storage->nodes[n];
+
+    if ( node.fanin[0] > node.fanin[1] )
+    {
+      auto v1 = *begin++;
+      auto v2 = *begin++;
+      return v1 && v2;
+    }
+    else
+    {
+      auto v = *begin++;
+      while ( begin != end )
+      {
+        v ^= *begin++;
+      }
+      return v;
+    }
+  }
+
+  template<typename Iterator>
+  iterates_over_truth_table_t<Iterator>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_pi( n ) );
+
+    const auto& node = _storage->nodes[n];
+
+    if ( node.fanin[0] > node.fanin[1] )
+    {
+      auto v1 = *begin++;
+      auto v2 = *begin++;
+      return v1 & v2;
+    }
+    else
+    {
+      auto v = *begin++;
+      while ( begin != end )
+      {
+        v ^= *begin++;
+      }
+      return v;
+    }
+  }
+#pragma endregion
+
+#pragma region Custom node values
+  void clear_values() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.value = 0; } );
+  }
+
+  auto value( node const& n ) const
+  {
+    return _storage->nodes[n].value;
+  }
+
+  void set_value( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].value = v;
+  }
+
+  auto incr_value( node const& n ) const
+  {
+    return _storage->nodes[n].value++;
+  }
+
+  auto decr_value( node const& n ) const
+  {
+    return --_storage->nodes[n].value;
+  }
+#pragma endregion
+
+#pragma region Visited flags
+  void clear_visited() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.visited = 0; } );
+  }
+
+  auto visited( node const& n ) const
+  {
+    return _storage->nodes[n].visited;
+  }
+
+  void set_visited( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].visited = v;
+  }
+
+  uint32_t trav_id() const
+  {
+    return _storage->trav_id;
+  }
+
+  void incr_trav_id() const
+  {
+    ++_storage->trav_id;
+  }
+#pragma endregion
+
+public:
+  storage _storage;
+};
+
+} // namespace mockturtle
+
+template<>
+struct fmt::formatter<mockturtle::abstract_xag_network::signal>
+{
+  constexpr auto parse( format_parse_context& ctx )
+  {
+    auto it = ctx.begin(), end = ctx.end();
+    if ( it != end && *it != '}' )
+    {
+      throw format_error( "invalid format" );
+    }
+    return it;
+  }
+
+  template<typename FormatContext>
+  auto format( const mockturtle::abstract_xag_network::signal& f, FormatContext& ctx )
+  {
+    return format_to( ctx.out(), "{}{}", f.complement ? "~" : "", f.index );
+  }
+};
+
+namespace std
+{
+
+template<>
+struct hash<mockturtle::abstract_xag_network::signal>
+{
+  uint64_t operator()( mockturtle::abstract_xag_network::signal const& s ) const noexcept
+  {
+    uint64_t k = s.index;
+    k ^= k >> 33;
+    k *= 0xff51afd7ed558ccd;
+    k ^= k >> 33;
+    k *= 0xc4ceb9fe1a85ec53;
+    k ^= k >> 33;
+    k ^= s.complement;
+    return k;
+  }
+}; /* hash */
+
+} // namespace std
\ No newline at end of file
diff --git a/include/mockturtle/networks/aig.hpp b/include/mockturtle/networks/aig.hpp
new file mode 100644
index 0000000..c8c4643
--- /dev/null
+++ b/include/mockturtle/networks/aig.hpp
@@ -0,0 +1,1265 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aig.hpp
+  \brief AIG logic network implementation
+
+  \author Alessandro Tempia Calvino
+  \author Bruno Schmitt
+  \author Hanyu Wang
+  \author Heinz Riener
+  \author Jinzheng Tu
+  \author Mathias Soeken
+  \author Max Austin
+  \author Siang-Yun (Sonia) Lee
+  \author Walter Lau Neto
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+#include "../utils/algorithm.hpp"
+#include "detail/foreach.hpp"
+#include "events.hpp"
+#include "storage.hpp"
+
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/operators.hpp>
+#include <kitty/partial_truth_table.hpp>
+
+#include <list>
+#include <memory>
+#include <optional>
+#include <stack>
+#include <string>
+
+namespace mockturtle
+{
+
+/*! \brief Hash function for AIGs (from ABC) */
+template<class Node>
+struct aig_hash
+{
+  uint64_t operator()( Node const& n ) const
+  {
+    uint64_t seed = -2011;
+    seed += n.children[0].index * 7937;
+    seed += n.children[1].index * 2971;
+    seed += n.children[0].weight * 911;
+    seed += n.children[1].weight * 353;
+    return seed;
+  }
+};
+
+/*! \brief AIG storage container
+
+  AIGs have nodes with fan-in 2.  We split of one bit of the index pointer to
+  store a complemented attribute.  Every node has 64-bit of additional data
+  used for the following purposes:
+
+  `data[0].h1`: Fan-out size (we use MSB to indicate whether a node is dead)
+  `data[0].h2`: Application-specific value
+  `data[1].h1`: Visited flag
+  `data[1].h2`: Is terminal node (PI or CI)
+*/
+using aig_storage = storage<regular_node<2, 2, 1>,
+                            empty_storage_data,
+                            aig_hash<regular_node<2, 2, 1>>>;
+
+class aig_network
+{
+public:
+#pragma region Types and constructors
+  static constexpr bool is_aig_network_type = true;
+  static constexpr auto min_fanin_size = 2u;
+  static constexpr auto max_fanin_size = 2u;
+
+  using base_type = aig_network;
+  using storage = std::shared_ptr<aig_storage>;
+  using node = uint64_t;
+
+  struct signal
+  {
+    signal() = default;
+
+    signal( uint64_t index, uint64_t complement )
+        : complement( complement ), index( index )
+    {
+    }
+
+    explicit signal( uint64_t data )
+        : data( data )
+    {
+    }
+
+    signal( aig_storage::node_type::pointer_type const& p )
+        : complement( p.weight ), index( p.index )
+    {
+    }
+
+    union
+    {
+      struct
+      {
+        uint64_t complement : 1;
+        uint64_t index : 63;
+      };
+      uint64_t data;
+    };
+
+    signal operator!() const
+    {
+      return signal( data ^ 1 );
+    }
+
+    signal operator+() const
+    {
+      return { index, 0 };
+    }
+
+    signal operator-() const
+    {
+      return { index, 1 };
+    }
+
+    signal operator^( bool complement ) const
+    {
+      return signal( data ^ ( complement ? 1 : 0 ) );
+    }
+
+    bool operator==( signal const& other ) const
+    {
+      return data == other.data;
+    }
+
+    bool operator!=( signal const& other ) const
+    {
+      return data != other.data;
+    }
+
+    bool operator<( signal const& other ) const
+    {
+      return data < other.data;
+    }
+
+    operator aig_storage::node_type::pointer_type() const
+    {
+      return { index, complement };
+    }
+
+#if __cplusplus > 201703L
+    bool operator==( aig_storage::node_type::pointer_type const& other ) const
+    {
+      return data == other.data;
+    }
+#endif
+  };
+
+  aig_network()
+      : _storage( std::make_shared<aig_storage>() ),
+        _events( std::make_shared<decltype( _events )::element_type>() )
+  {
+  }
+
+  aig_network( std::shared_ptr<aig_storage> storage )
+      : _storage( storage ),
+        _events( std::make_shared<decltype( _events )::element_type>() )
+  {
+  }
+
+  aig_network clone() const
+  {
+    return { std::make_shared<aig_storage>( *_storage ) };
+  }
+#pragma endregion
+
+#pragma region Primary I / O and constants
+  signal get_constant( bool value ) const
+  {
+    return { 0, static_cast<uint64_t>( value ? 1 : 0 ) };
+  }
+
+  signal create_pi()
+  {
+    const auto index = _storage->nodes.size();
+    auto& node = _storage->nodes.emplace_back();
+    node.children[0].data = node.children[1].data = _storage->inputs.size();
+    node.data[1].h2 = 1; // mark as PI
+    _storage->inputs.emplace_back( index );
+    return { index, 0 };
+  }
+
+  uint32_t create_po( signal const& f )
+  {
+    /* increase ref-count to children */
+    _storage->nodes[f.index].data[0].h1++;
+    auto const po_index = _storage->outputs.size();
+    _storage->outputs.emplace_back( f.index, f.complement );
+    return static_cast<uint32_t>( po_index );
+  }
+
+  bool is_combinational() const
+  {
+    return true;
+  }
+
+  bool is_constant( node const& n ) const
+  {
+    return n == 0;
+  }
+
+  bool is_ci( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h2 == 1;
+  }
+
+  bool is_pi( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h2 == 1 && !is_constant( n );
+  }
+
+  bool constant_value( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+#pragma endregion
+
+#pragma region Create unary functions
+  signal create_buf( signal const& a )
+  {
+    return a;
+  }
+
+  signal create_not( signal const& a )
+  {
+    return !a;
+  }
+#pragma endregion
+
+#pragma region Create binary functions
+  signal create_and( signal a, signal b )
+  {
+    /* order inputs */
+    if ( a.index > b.index )
+    {
+      std::swap( a, b );
+    }
+
+    /* trivial cases */
+    if ( a.index == b.index )
+    {
+      return ( a.complement == b.complement ) ? a : get_constant( false );
+    }
+    else if ( a.index == 0 )
+    {
+      return a.complement ? b : get_constant( false );
+    }
+
+    storage::element_type::node_type node;
+    node.children[0] = a;
+    node.children[1] = b;
+
+    /* structural hashing */
+    const auto it = _storage->hash.find( node );
+    if ( it != _storage->hash.end() )
+    {
+      assert( !is_dead( it->second ) );
+      return { it->second, 0 };
+    }
+
+    const auto index = _storage->nodes.size();
+
+    if ( index >= .9 * _storage->nodes.capacity() )
+    {
+      _storage->nodes.reserve( static_cast<uint64_t>( 3.1415f * index ) );
+      _storage->hash.reserve( static_cast<uint64_t>( 3.1415f * index ) );
+    }
+
+    _storage->nodes.push_back( node );
+
+    _storage->hash[node] = index;
+
+    /* increase ref-count to children */
+    _storage->nodes[a.index].data[0].h1++;
+    _storage->nodes[b.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return { index, 0 };
+  }
+
+  signal create_nand( signal const& a, signal const& b )
+  {
+    return !create_and( a, b );
+  }
+
+  signal create_or( signal const& a, signal const& b )
+  {
+    return !create_and( !a, !b );
+  }
+
+  signal create_nor( signal const& a, signal const& b )
+  {
+    return create_and( !a, !b );
+  }
+
+  signal create_lt( signal const& a, signal const& b )
+  {
+    return create_and( !a, b );
+  }
+
+  signal create_le( signal const& a, signal const& b )
+  {
+    return !create_and( a, !b );
+  }
+
+  signal create_xor( signal const& a, signal const& b )
+  {
+    const auto fcompl = a.complement ^ b.complement;
+    const auto c1 = create_and( +a, -b );
+    const auto c2 = create_and( +b, -a );
+    return create_and( !c1, !c2 ) ^ !fcompl;
+  }
+
+  signal create_xnor( signal const& a, signal const& b )
+  {
+    return !create_xor( a, b );
+  }
+#pragma endregion
+
+#pragma region Createy ternary functions
+  signal create_ite( signal cond, signal f_then, signal f_else )
+  {
+    bool f_compl{ false };
+    if ( f_then.index < f_else.index )
+    {
+      std::swap( f_then, f_else );
+      cond.complement ^= 1;
+    }
+    if ( f_then.complement )
+    {
+      f_then.complement = 0;
+      f_else.complement ^= 1;
+      f_compl = true;
+    }
+
+    return create_and( !create_and( !cond, f_else ), !create_and( cond, f_then ) ) ^ !f_compl;
+  }
+
+  signal create_maj( signal const& a, signal const& b, signal const& c )
+  {
+    return create_or( create_and( a, b ), create_and( c, !create_and( !a, !b ) ) );
+  }
+
+  signal create_xor3( signal const& a, signal const& b, signal const& c )
+  {
+    return create_xor( create_xor( a, b ), c );
+  }
+#pragma endregion
+
+#pragma region Create nary functions
+  signal create_nary_and( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( true ), [this]( auto const& a, auto const& b ) { return create_and( a, b ); } );
+  }
+
+  signal create_nary_or( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_or( a, b ); } );
+  }
+
+  signal create_nary_xor( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_xor( a, b ); } );
+  }
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  signal clone_node( aig_network const& other, node const& source, std::vector<signal> const& children )
+  {
+    (void)other;
+    (void)source;
+    assert( children.size() == 2u );
+    return create_and( children[0u], children[1u] );
+  }
+#pragma endregion
+
+#pragma region Has node
+  std::optional<signal> has_and( signal a, signal b )
+  {
+    /* order inputs */
+    if ( a.index > b.index )
+    {
+      std::swap( a, b );
+    }
+
+    /* trivial cases */
+    if ( a.index == b.index )
+    {
+      return a.complement == b.complement ? a : get_constant( false );
+    }
+    else if ( a.index == 0 )
+    {
+      return a.complement == false ? get_constant( false ) : b;
+    }
+
+    storage::element_type::node_type node;
+    node.children[0] = a;
+    node.children[1] = b;
+
+    /* structural hashing */
+    const auto it = _storage->hash.find( node );
+    if ( it != _storage->hash.end() )
+    {
+      assert( !is_dead( it->second ) );
+      return signal( it->second, 0 );
+    }
+
+    return {};
+  }
+#pragma endregion
+
+#pragma region Restructuring
+  std::optional<std::pair<node, signal>> replace_in_node( node const& n, node const& old_node, signal new_signal )
+  {
+    auto& node = _storage->nodes[n];
+
+    uint32_t fanin = 0u;
+    if ( node.children[0].index == old_node )
+    {
+      fanin = 0u;
+      new_signal.complement ^= node.children[0].weight;
+    }
+    else if ( node.children[1].index == old_node )
+    {
+      fanin = 1u;
+      new_signal.complement ^= node.children[1].weight;
+    }
+    else
+    {
+      return std::nullopt;
+    }
+
+    // determine potential new children of node n
+    signal child1 = new_signal;
+    signal child0 = node.children[fanin ^ 1];
+
+    if ( child0.index > child1.index )
+    {
+      std::swap( child0, child1 );
+    }
+
+    // check for trivial cases?
+    if ( child0.index == child1.index )
+    {
+      const auto diff_pol = child0.complement != child1.complement;
+      return std::make_pair( n, diff_pol ? get_constant( false ) : child1 );
+    }
+    else if ( child0.index == 0 ) /* constant child */
+    {
+      return std::make_pair( n, child0.complement ? child1 : get_constant( false ) );
+    }
+
+    // node already in hash table
+    storage::element_type::node_type _hash_obj;
+    _hash_obj.children[0] = child0;
+    _hash_obj.children[1] = child1;
+    if ( const auto it = _storage->hash.find( _hash_obj ); it != _storage->hash.end() && it->second != old_node )
+    {
+      return std::make_pair( n, signal( it->second, 0 ) );
+    }
+
+    // remember before
+    const auto old_child0 = signal{ node.children[0] };
+    const auto old_child1 = signal{ node.children[1] };
+
+    // erase old node in hash table
+    _storage->hash.erase( node );
+
+    // insert updated node into hash table
+    node.children[0] = child0;
+    node.children[1] = child1;
+    _storage->hash[node] = n;
+
+    // update the reference counter of the new signal
+    _storage->nodes[new_signal.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_modified )
+    {
+      ( *fn )( n, { old_child0, old_child1 } );
+    }
+
+    return std::nullopt;
+  }
+
+  void replace_in_node_no_restrash( node const& n, node const& old_node, signal new_signal )
+  {
+    auto& node = _storage->nodes[n];
+
+    uint32_t fanin = 0u;
+    if ( node.children[0].index == old_node )
+    {
+      fanin = 0u;
+      new_signal.complement ^= node.children[0].weight;
+    }
+    else if ( node.children[1].index == old_node )
+    {
+      fanin = 1u;
+      new_signal.complement ^= node.children[1].weight;
+    }
+    else
+    {
+      return;
+    }
+
+    // determine potential new children of node n
+    signal child1 = new_signal;
+    signal child0 = node.children[fanin ^ 1];
+
+    if ( child0.index > child1.index )
+    {
+      std::swap( child0, child1 );
+    }
+
+    // don't check for trivial cases
+
+    // remember before
+    const auto old_child0 = signal{ node.children[0] };
+    const auto old_child1 = signal{ node.children[1] };
+
+    // erase old node in hash table
+    _storage->hash.erase( node );
+
+    // insert updated node into the hash table
+    node.children[0] = child0;
+    node.children[1] = child1;
+    if ( _storage->hash.find( node ) == _storage->hash.end() )
+    {
+      _storage->hash[node] = n;
+    }
+
+    // update the reference counter of the new signal
+    _storage->nodes[new_signal.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_modified )
+    {
+      ( *fn )( n, { old_child0, old_child1 } );
+    }
+  }
+
+  void replace_in_outputs( node const& old_node, signal const& new_signal )
+  {
+    if ( is_dead( old_node ) )
+      return;
+
+    for ( auto& output : _storage->outputs )
+    {
+      if ( output.index == old_node )
+      {
+        output.index = new_signal.index;
+        output.weight ^= new_signal.complement;
+
+        if ( old_node != new_signal.index )
+        {
+          /* increment fan-in of new node */
+          _storage->nodes[new_signal.index].data[0].h1++;
+        }
+      }
+    }
+  }
+
+  void take_out_node( node const& n )
+  {
+    /* we cannot delete CIs, constants, or already dead nodes */
+    if ( n == 0 || is_ci( n ) || is_dead( n ) )
+      return;
+
+    /* delete the node (ignoring its current fanout_size) */
+    auto& nobj = _storage->nodes[n];
+    nobj.data[0].h1 = UINT32_C( 0x80000000 ); /* fanout size 0, but dead */
+    _storage->hash.erase( nobj );
+
+    for ( auto const& fn : _events->on_delete )
+    {
+      ( *fn )( n );
+    }
+
+    /* if the node has been deleted, then deref fanout_size of
+       fanins and try to take them out if their fanout_size become 0 */
+    for ( auto i = 0u; i < 2u; ++i )
+    {
+      if ( fanout_size( nobj.children[i].index ) == 0 )
+      {
+        continue;
+      }
+      if ( decr_fanout_size( nobj.children[i].index ) == 0 )
+      {
+        take_out_node( nobj.children[i].index );
+      }
+    }
+  }
+
+  void revive_node( node const& n )
+  {
+    if ( !is_dead( n ) )
+      return;
+    
+    assert( n < _storage->nodes.size() );
+    auto& nobj = _storage->nodes[n];
+    nobj.data[0].h1 = UINT32_C( 0 ); /* fanout size 0, but not dead (like just created) */
+    _storage->hash[nobj] = n;
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( n );
+    }
+
+    /* revive its children if dead, and increment their fanout_size */
+    for ( auto i = 0u; i < 2u; ++i )
+    {
+      if ( is_dead( nobj.children[i].index ) )
+      {
+        revive_node( nobj.children[i].index );
+      }
+      incr_fanout_size( nobj.children[i].index );
+    }
+  }
+
+  inline bool is_dead( node const& n ) const
+  {
+    return ( _storage->nodes[n].data[0].h1 >> 31 ) & 1;
+  }
+
+  void substitute_node( node const& old_node, signal const& new_signal )
+  {
+    std::unordered_map<node, signal> old_to_new;
+    std::stack<std::pair<node, signal>> to_substitute;
+    to_substitute.push( { old_node, new_signal } );
+
+    while ( !to_substitute.empty() )
+    {
+      const auto [_old, _curr] = to_substitute.top();
+      to_substitute.pop();
+
+      signal _new = _curr;
+      /* find the real new node */
+      if ( is_dead( get_node( _new ) ) )
+      {
+        auto it = old_to_new.find( get_node( _new ) );
+        while ( it != old_to_new.end() )
+        {
+          _new = is_complemented( _new ) ? create_not( it->second ) : it->second;
+          it = old_to_new.find( get_node( _new ) );
+        }
+      }
+      /* revive */
+      if ( is_dead( get_node( _new ) ) )
+      {
+        revive_node( get_node( _new ) );
+      }
+
+      for ( auto idx = 1u; idx < _storage->nodes.size(); ++idx )
+      {
+        if ( is_ci( idx ) || is_dead( idx ) )
+          continue; /* ignore CIs */
+
+        if ( const auto repl = replace_in_node( idx, _old, _new ); repl )
+        {
+          to_substitute.push( *repl );
+        }
+      }
+
+      /* check outputs */
+      replace_in_outputs( _old, _new );
+
+      /* recursively reset old node */
+      if ( _old != _new.index )
+      {
+        old_to_new.insert( { _old, _new } );
+        take_out_node( _old );
+      }
+    }
+  }
+
+  void substitute_node_no_restrash( node const& old_node, signal const& new_signal )
+  {
+    if ( is_dead( get_node( new_signal ) ) )
+    {
+      revive_node( get_node( new_signal ) );
+    }
+
+    for ( auto idx = 1u; idx < _storage->nodes.size(); ++idx )
+    {
+      if ( is_ci( idx ) || is_dead( idx ) )
+        continue; /* ignore CIs and dead nodes */
+
+      replace_in_node_no_restrash( idx, old_node, new_signal );
+    }
+
+    /* check outputs */
+    replace_in_outputs( old_node, new_signal );
+
+    /* recursively reset old node */
+    if ( old_node != new_signal.index )
+    {
+      take_out_node( old_node );
+    }
+  }
+
+  void substitute_nodes( std::list<std::pair<node, signal>> substitutions )
+  {
+    auto clean_substitutions = [&]( node const& n ) {
+      substitutions.erase( std::remove_if( std::begin( substitutions ), std::end( substitutions ),
+                                           [&]( auto const& s ) {
+                                             if ( s.first == n )
+                                             {
+                                               node const nn = get_node( s.second );
+                                               if ( is_dead( nn ) )
+                                                 return true;
+
+                                               /* deref fanout_size of the node */
+                                               if ( fanout_size( nn ) > 0 )
+                                               {
+                                                 decr_fanout_size( nn );
+                                               }
+                                               /* remove the node if it's fanout_size becomes 0 */
+                                               if ( fanout_size( nn ) == 0 )
+                                               {
+                                                 take_out_node( nn );
+                                               }
+                                               /* remove substitution from list */
+                                               return true;
+                                             }
+                                             return false; /* keep */
+                                           } ),
+                           std::end( substitutions ) );
+    };
+
+    /* register event to delete substitutions if their right-hand side
+       nodes get deleted */
+    auto clean_sub_event = _events->register_delete_event( clean_substitutions );
+
+    /* increment fanout_size of all signals to be used in
+       substitutions to ensure that they will not be deleted */
+    for ( const auto& s : substitutions )
+    {
+      incr_fanout_size( get_node( s.second ) );
+    }
+
+    while ( !substitutions.empty() )
+    {
+      auto const [old_node, new_signal] = substitutions.front();
+      substitutions.pop_front();
+
+      for ( auto index = 1u; index < _storage->nodes.size(); ++index )
+      {
+        /* skip CIs and dead nodes */
+        if ( is_ci( index ) || is_dead( index ) )
+          continue;
+
+        /* skip nodes that will be deleted */
+        if ( std::find_if( std::begin( substitutions ), std::end( substitutions ),
+                           [&index]( auto s ) { return s.first == index; } ) != std::end( substitutions ) )
+          continue;
+
+        /* replace in node */
+        if ( const auto repl = replace_in_node( index, old_node, new_signal ); repl )
+        {
+          incr_fanout_size( get_node( repl->second ) );
+          substitutions.emplace_back( *repl );
+        }
+      }
+
+      /* replace in outputs */
+      replace_in_outputs( old_node, new_signal );
+
+      /* replace in substitutions */
+      for ( auto& s : substitutions )
+      {
+        if ( get_node( s.second ) == old_node )
+        {
+          s.second = is_complemented( s.second ) ? !new_signal : new_signal;
+          incr_fanout_size( get_node( new_signal ) );
+        }
+      }
+
+      /* finally remove the node: note that we never decrement the
+         fanout_size of the old_node. instead, we remove the node and
+         reset its fanout_size to 0 knowing that it must be 0 after
+         substituting all references. */
+      assert( !is_dead( old_node ) );
+      take_out_node( old_node );
+
+      /* decrement fanout_size when released from substitution list */
+      decr_fanout_size( get_node( new_signal ) );
+    }
+
+    _events->release_delete_event( clean_sub_event );
+  }
+#pragma endregion
+
+#pragma region Structural properties
+  auto size() const
+  {
+    return static_cast<uint32_t>( _storage->nodes.size() );
+  }
+
+  auto num_cis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_cos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  auto num_pis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_pos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  auto num_gates() const
+  {
+    return static_cast<uint32_t>( _storage->hash.size() );
+  }
+
+  uint32_t fanin_size( node const& n ) const
+  {
+    if ( is_constant( n ) || is_ci( n ) )
+      return 0;
+    return 2;
+  }
+
+  uint32_t fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1 & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t incr_fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1++ & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t decr_fanout_size( node const& n ) const
+  {
+    return --_storage->nodes[n].data[0].h1 & UINT32_C( 0x7FFFFFFF );
+  }
+
+  bool is_and( node const& n ) const
+  {
+    return n > 0 && !is_ci( n );
+  }
+
+  bool is_or( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_xor( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_maj( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_ite( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_xor3( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_and( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_or( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_xor( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+#pragma endregion
+
+#pragma region Functional properties
+  kitty::dynamic_truth_table node_function( const node& n ) const
+  {
+    (void)n;
+    kitty::dynamic_truth_table _and( 2 );
+    _and._bits[0] = 0x8;
+    return _and;
+  }
+#pragma endregion
+
+#pragma region Nodes and signals
+  node get_node( signal const& f ) const
+  {
+    return f.index;
+  }
+
+  signal make_signal( node const& n ) const
+  {
+    return signal( n, 0 );
+  }
+
+  bool is_complemented( signal const& f ) const
+  {
+    return f.complement;
+  }
+
+  uint32_t node_to_index( node const& n ) const
+  {
+    return static_cast<uint32_t>( n );
+  }
+
+  node index_to_node( uint32_t index ) const
+  {
+    return index;
+  }
+
+  node ci_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal co_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return *( _storage->outputs.begin() + index );
+  }
+
+  node pi_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal po_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return *( _storage->outputs.begin() + index );
+  }
+
+  uint32_t ci_index( node const& n ) const
+  {
+    assert( _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data );
+    return static_cast<uint32_t>( _storage->nodes[n].children[0].data );
+  }
+
+  uint32_t co_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_co( [&]( const auto& x, auto index ) {
+      if ( x == s )
+      {
+        i = index;
+        return false;
+      }
+      return true;
+    } );
+    return i;
+  }
+
+  uint32_t pi_index( node const& n ) const
+  {
+    assert( _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data );
+    return static_cast<uint32_t>( _storage->nodes[n].children[0].data );
+  }
+
+  uint32_t po_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_po( [&]( const auto& x, auto index ) {
+      if ( x == s )
+      {
+        i = index;
+        return false;
+      }
+      return true;
+    } );
+    return i;
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( _storage->nodes.size() );
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_dead( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_ci( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_co( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->outputs.begin(), _storage->outputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->outputs.begin(), _storage->outputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( 1u, _storage->nodes.size() ); /* start from 1 to avoid constant */
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_ci( n ) && !is_dead( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_fanin( node const& n, Fn&& fn ) const
+  {
+    if ( n == 0 || is_ci( n ) )
+      return;
+
+    static_assert( detail::is_callable_without_index_v<Fn, signal, bool> ||
+                   detail::is_callable_with_index_v<Fn, signal, bool> ||
+                   detail::is_callable_without_index_v<Fn, signal, void> ||
+                   detail::is_callable_with_index_v<Fn, signal, void> );
+
+    /* we don't use foreach_element here to have better performance */
+    if constexpr ( detail::is_callable_without_index_v<Fn, signal, bool> )
+    {
+      if ( !fn( signal{ _storage->nodes[n].children[0] } ) )
+        return;
+      fn( signal{ _storage->nodes[n].children[1] } );
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, signal, bool> )
+    {
+      if ( !fn( signal{ _storage->nodes[n].children[0] }, 0 ) )
+        return;
+      fn( signal{ _storage->nodes[n].children[1] }, 1 );
+    }
+    else if constexpr ( detail::is_callable_without_index_v<Fn, signal, void> )
+    {
+      fn( signal{ _storage->nodes[n].children[0] } );
+      fn( signal{ _storage->nodes[n].children[1] } );
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, signal, void> )
+    {
+      fn( signal{ _storage->nodes[n].children[0] }, 0 );
+      fn( signal{ _storage->nodes[n].children[1] }, 1 );
+    }
+  }
+#pragma endregion
+
+#pragma region Value simulation
+  template<typename Iterator>
+  iterates_over_t<Iterator, bool>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+
+    auto v1 = *begin++;
+    auto v2 = *begin++;
+
+    return ( v1 ^ c1.weight ) && ( v2 ^ c2.weight );
+  }
+
+  template<typename Iterator>
+  iterates_over_truth_table_t<Iterator>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+
+    auto tt1 = *begin++;
+    auto tt2 = *begin++;
+
+    return ( c1.weight ? ~tt1 : tt1 ) & ( c2.weight ? ~tt2 : tt2 );
+  }
+
+  /*! \brief Re-compute the last block. */
+  template<typename Iterator>
+  void compute( node const& n, kitty::partial_truth_table& result, Iterator begin, Iterator end ) const
+  {
+    static_assert( iterates_over_v<Iterator, kitty::partial_truth_table>, "begin and end have to iterate over partial_truth_tables" );
+
+    (void)end;
+    assert( n != 0 && !is_ci( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+
+    auto tt1 = *begin++;
+    auto tt2 = *begin++;
+
+    assert( tt1.num_bits() > 0 && "truth tables must not be empty" );
+    assert( tt1.num_bits() == tt2.num_bits() );
+    assert( tt1.num_bits() >= result.num_bits() );
+    assert( result.num_blocks() == tt1.num_blocks() || ( result.num_blocks() == tt1.num_blocks() - 1 && result.num_bits() % 64 == 0 ) );
+
+    result.resize( tt1.num_bits() );
+    result._bits.back() = ( c1.weight ? ~( tt1._bits.back() ) : tt1._bits.back() ) & ( c2.weight ? ~( tt2._bits.back() ) : tt2._bits.back() );
+    result.mask_bits();
+  }
+#pragma endregion
+
+#pragma region Custom node values
+  void clear_values() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[0].h2 = 0; } );
+  }
+
+  auto value( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h2;
+  }
+
+  void set_value( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[0].h2 = v;
+  }
+
+  auto incr_value( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h2++;
+  }
+
+  auto decr_value( node const& n ) const
+  {
+    return --_storage->nodes[n].data[0].h2;
+  }
+#pragma endregion
+
+#pragma region Visited flags
+  void clear_visited() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[1].h1 = 0; } );
+  }
+
+  auto visited( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h1;
+  }
+
+  void set_visited( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[1].h1 = v;
+  }
+
+  uint32_t trav_id() const
+  {
+    return _storage->trav_id;
+  }
+
+  void incr_trav_id() const
+  {
+    ++_storage->trav_id;
+  }
+#pragma endregion
+
+#pragma region General methods
+  auto& events() const
+  {
+    return *_events;
+  }
+#pragma endregion
+
+public:
+  std::shared_ptr<aig_storage> _storage;
+  std::shared_ptr<network_events<base_type>> _events;
+};
+
+} // namespace mockturtle
+
+namespace std
+{
+
+template<>
+struct hash<mockturtle::aig_network::signal>
+{
+  uint64_t operator()( mockturtle::aig_network::signal const& s ) const noexcept
+  {
+    uint64_t k = s.data;
+    k ^= k >> 33;
+    k *= 0xff51afd7ed558ccd;
+    k ^= k >> 33;
+    k *= 0xc4ceb9fe1a85ec53;
+    k ^= k >> 33;
+    return k;
+  }
+}; /* hash */
+
+} // namespace std
\ No newline at end of file
diff --git a/include/mockturtle/networks/aqfp.hpp b/include/mockturtle/networks/aqfp.hpp
new file mode 100644
index 0000000..e739860
--- /dev/null
+++ b/include/mockturtle/networks/aqfp.hpp
@@ -0,0 +1,1121 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aqfp.hpp
+  \brief AQFP network implementation
+
+  \author Alessandro Tempia Calvino
+  \author Dewmini Sudara Marakkalage
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <limits>
+#include <memory>
+#include <optional>
+#include <stack>
+#include <string>
+
+#include <fmt/format.h>
+#include <kitty/kitty.hpp>
+
+#include "../traits.hpp"
+#include "../utils/algorithm.hpp"
+#include "detail/foreach.hpp"
+#include "events.hpp"
+#include "storage.hpp"
+
+namespace mockturtle
+{
+
+struct aqfp_storage_data
+{
+  std::unordered_map<uint32_t, kitty::dynamic_truth_table> node_fn_cache;
+};
+
+/*! \brief AQFP storage container
+
+  We use one bit of the index pointer to store a complemented attribute.
+  Every node has 64-bit of additional data used for the following purposes:
+
+  `data[0].h1`: Fan-out size (we use MSB to indicate whether a node is dead)
+  `data[0].h2`: Application-specific value
+  `data[1].h1`: Visited flag
+*/
+using aqfp_storage = storage<mixed_fanin_node<2, 1>, aqfp_storage_data>;
+
+class aqfp_network
+{
+public:
+#pragma region Types and constructors
+  static constexpr auto min_fanin_size = 3u;
+  static constexpr auto max_fanin_size = 5u;
+
+  using base_type = aqfp_network;
+  using storage = std::shared_ptr<aqfp_storage>;
+  using node = uint64_t;
+
+  struct signal
+  {
+    signal() = default;
+
+    signal( uint64_t index, uint64_t complement )
+        : complement( complement ), index( index )
+    {
+    }
+
+    explicit signal( uint64_t data )
+        : data( data )
+    {
+    }
+
+    signal( aqfp_storage::node_type::pointer_type const& p )
+        : complement( p.weight ), index( p.index )
+    {
+    }
+
+    union
+    {
+      struct
+      {
+        uint64_t complement : 1;
+        uint64_t index : 63;
+      };
+      uint64_t data;
+    };
+
+    signal operator!() const
+    {
+      return signal( data ^ 1 );
+    }
+
+    signal operator+() const
+    {
+      return { index, 0 };
+    }
+
+    signal operator-() const
+    {
+      return { index, 1 };
+    }
+
+    signal operator^( bool complement ) const
+    {
+      return signal( data ^ ( complement ? 1 : 0 ) );
+    }
+
+    bool operator==( signal const& other ) const
+    {
+      return data == other.data;
+    }
+
+    bool operator!=( signal const& other ) const
+    {
+      return data != other.data;
+    }
+
+    bool operator<( signal const& other ) const
+    {
+      return data < other.data;
+    }
+
+    operator aqfp_storage::node_type::pointer_type() const
+    {
+      return { index, complement };
+    }
+
+#if __cplusplus > 201703L
+    bool operator==( aqfp_storage::node_type::pointer_type const& other ) const
+    {
+      return data == other.data;
+    }
+#endif
+  };
+
+  aqfp_network()
+      : _storage( std::make_shared<aqfp_storage>() ),
+        _events( std::make_shared<decltype( _events )::element_type>() )
+  {
+    _storage->nodes[0].children.resize( 3u );
+    _storage->nodes[0].children[0].data = _storage->nodes[0].children[0].data = _storage->nodes[0].children[0].data = static_cast<uint64_t>( 0u );
+  }
+
+  aqfp_network( std::shared_ptr<aqfp_storage> storage )
+      : _storage( storage ),
+        _events( std::make_shared<decltype( _events )::element_type>() )
+  {
+  }
+#pragma endregion
+
+#pragma region Primary I / O and constants
+  signal get_constant( bool value ) const
+  {
+    return { 0, static_cast<uint64_t>( value ? 1 : 0 ) };
+  }
+
+  signal create_pi()
+  {
+    const auto index = _storage->nodes.size();
+    auto& node = _storage->nodes.emplace_back();
+    node.children.resize( 3u );
+    node.children[0].data = node.children[1].data = node.children[2].data = ~static_cast<uint64_t>( 0 );
+    _storage->inputs.emplace_back( index );
+    return { index, 0 };
+  }
+
+  uint32_t create_po( signal const& f )
+  {
+    /* increase ref-count to children */
+    _storage->nodes[f.index].data[0].h1++;
+    auto const po_index = static_cast<uint32_t>( _storage->outputs.size() );
+    _storage->outputs.emplace_back( f.index, f.complement );
+    return po_index;
+  }
+
+  bool is_combinational() const
+  {
+    return true;
+  }
+
+  bool is_constant( node const& n ) const
+  {
+    return n == 0;
+  }
+
+  bool is_ci( node const& n ) const
+  {
+    return _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data && _storage->nodes[n].children[0].data == _storage->nodes[n].children[2].data;
+  }
+
+  bool is_pi( node const& n ) const
+  {
+    return _storage->nodes[n].children[0].data == ~static_cast<uint64_t>( 0 ) && _storage->nodes[n].children[1].data == ~static_cast<uint64_t>( 0 ) && _storage->nodes[n].children[2].data == ~static_cast<uint64_t>( 0 );
+  }
+
+  bool constant_value( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+#pragma endregion
+
+#pragma region Create unary functions
+  signal create_buf( signal const& a )
+  {
+    return a;
+  }
+
+  signal create_not( signal const& a )
+  {
+    return !a;
+  }
+#pragma endregion
+
+#pragma region Create binary / ternary functions
+  signal create_maj( signal a, signal b, signal c )
+  {
+    /* order inputs */
+    if ( a.index > b.index )
+    {
+      std::swap( a, b );
+      if ( b.index > c.index )
+        std::swap( b, c );
+      if ( a.index > b.index )
+        std::swap( a, b );
+    }
+    else
+    {
+      if ( b.index > c.index )
+        std::swap( b, c );
+      if ( a.index > b.index )
+        std::swap( a, b );
+    }
+
+    /* trivial cases */
+    if ( a.index == b.index )
+    {
+      return ( a.complement == b.complement ) ? a : c;
+    }
+    else if ( b.index == c.index )
+    {
+      return ( b.complement == c.complement ) ? b : a;
+    }
+
+    /*  complemented edges minimization */
+    auto node_complement = false;
+    if ( static_cast<unsigned>( a.complement ) + static_cast<unsigned>( b.complement ) + static_cast<unsigned>( c.complement ) >= 2u )
+    {
+      node_complement = true;
+      a.complement = !a.complement;
+      b.complement = !b.complement;
+      c.complement = !c.complement;
+    }
+
+    storage::element_type::node_type node;
+
+    node.children.resize( 3u );
+    node.children[0] = a;
+    node.children[1] = b;
+    node.children[2] = c;
+
+    const auto index = _storage->nodes.size();
+
+    _storage->nodes.push_back( node );
+
+    /* increase ref-count to children */
+    _storage->nodes[a.index].data[0].h1++;
+    _storage->nodes[b.index].data[0].h1++;
+    _storage->nodes[c.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return { index, node_complement };
+  }
+
+  signal create_maj( std::vector<signal> children )
+  {
+    assert( children.size() > 0u );
+    assert( children.size() % 2 == 1u );
+
+    if ( children.size() == 1u )
+    {
+      return children[0u];
+    }
+
+    std::stable_sort( children.begin(), children.end(), []( auto f, auto s ) { return f.index < s.index; } );
+
+    for ( auto i = 1u; i < children.size(); i++ )
+    {
+      if ( children[i - 1].index == children[i].index && children[i - 1].complement != children[i].complement )
+      {
+        children.erase( children.begin() + ( i - 1 ), children.begin() + ( i + 1 ) );
+        return create_maj( children );
+      }
+    }
+
+    for ( auto i = 0u; i < children.size(); i++ )
+    {
+      const auto index = children[i].index;
+      const auto complement = children[i].complement;
+      auto j = i + 1;
+      while ( j < children.size() && children[j].index == index && children[j].complement == complement )
+      {
+        j++;
+      }
+      if ( j - i > children.size() / 2 )
+      {
+        return { index, complement };
+      }
+    }
+
+    auto node_complement = false;
+
+    auto num_complemented = 0u;
+    for ( const auto& c : children )
+    {
+      num_complemented += static_cast<unsigned>( c.complement );
+    }
+
+    if ( num_complemented > children.size() / 2 )
+    {
+      node_complement = true;
+      for ( auto& c : children )
+      {
+        c.complement = !c.complement;
+      }
+    }
+
+    storage::element_type::node_type node;
+
+    for ( const auto& c : children )
+    {
+      node.children.push_back( c );
+    }
+
+    const auto index = _storage->nodes.size();
+
+    _storage->nodes.push_back( node );
+
+    /* increase ref-count to children */
+    for ( const auto& c : children )
+    {
+      _storage->nodes[c.index].data[0].h1++;
+    }
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return { index, node_complement };
+  }
+
+  signal create_and( signal const& a, signal const& b )
+  {
+    return create_maj( get_constant( false ), a, b );
+  }
+
+  signal create_nand( signal const& a, signal const& b )
+  {
+    return !create_and( a, b );
+  }
+
+  signal create_or( signal const& a, signal const& b )
+  {
+    return create_maj( get_constant( true ), a, b );
+  }
+
+  signal create_nor( signal const& a, signal const& b )
+  {
+    return !create_or( a, b );
+  }
+
+  signal create_lt( signal const& a, signal const& b )
+  {
+    return create_and( !a, b );
+  }
+
+  signal create_le( signal const& a, signal const& b )
+  {
+    return !create_and( a, !b );
+  }
+
+  signal create_xor( signal const& a, signal const& b )
+  {
+    const auto fcompl = a.complement ^ b.complement;
+    const auto c1 = create_and( +a, -b );
+    const auto c2 = create_and( +b, -a );
+    return create_and( !c1, !c2 ) ^ !fcompl;
+  }
+
+  signal create_ite( signal cond, signal f_then, signal f_else )
+  {
+    bool f_compl{ false };
+    if ( f_then.index < f_else.index )
+    {
+      std::swap( f_then, f_else );
+      cond.complement ^= 1;
+    }
+    if ( f_then.complement )
+    {
+      f_then.complement = 0;
+      f_else.complement ^= 1;
+      f_compl = true;
+    }
+
+    return create_and( !create_and( !cond, f_else ), !create_and( cond, f_then ) ) ^ !f_compl;
+  }
+
+  signal create_xor3( signal const& a, signal const& b, signal const& c )
+  {
+    const auto f = create_maj( a, !b, c );
+    const auto g = create_maj( a, b, !c );
+    return create_maj( !a, f, g );
+  }
+#pragma endregion
+
+#pragma region Create nary functions
+  signal create_nary_and( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( true ), [this]( auto const& a, auto const& b ) { return create_and( a, b ); } );
+  }
+
+  signal create_nary_or( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_or( a, b ); } );
+  }
+
+  signal create_nary_xor( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_xor( a, b ); } );
+  }
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  signal clone_node( aqfp_network const& other, node const& source, std::vector<signal> const& children )
+  {
+    (void)other;
+    (void)source;
+    assert( children.size() > 1 && children.size() % 2 == 1 );
+    return create_maj( children );
+  }
+#pragma endregion
+
+#pragma region Restructuring
+  std::optional<std::pair<node, signal>> replace_in_node( node const& n, node const& old_node, signal new_signal )
+  {
+    auto& node = _storage->nodes[n];
+
+    std::vector<signal> old_children;
+
+    bool replacement = false;
+    for ( size_t i = 0u; i < node.children.size(); ++i )
+    {
+      old_children.push_back( signal{ node.children[i] } );
+
+      if ( node.children[i].index == old_node )
+      {
+        node.children[i] = node.children[i].weight ? !new_signal : new_signal;
+        replacement = true;
+
+        // update the reference counter of the new signal
+        _storage->nodes[new_signal.index].data[0].h1++;
+      }
+    }
+
+    if ( !replacement )
+    {
+      return std::nullopt;
+    }
+
+    /* TODO: Do the simplifications if possible and ordering */
+
+    for ( auto const& fn : _events->on_modified )
+    {
+      ( *fn )( n, old_children );
+    }
+
+    return std::nullopt;
+  }
+
+  void replace_in_outputs( node const& old_node, signal const& new_signal )
+  {
+    for ( auto& output : _storage->outputs )
+    {
+      if ( output.index == old_node )
+      {
+        output.index = new_signal.index;
+        output.weight ^= new_signal.complement;
+
+        // increment fan-in of new node
+        _storage->nodes[new_signal.index].data[0].h1++;
+      }
+    }
+  }
+
+  void take_out_node( node const& n )
+  {
+    /* we cannot delete CIs or constants */
+    if ( n == 0 || is_ci( n ) )
+      return;
+
+    auto& nobj = _storage->nodes[n];
+    nobj.data[0].h1 = UINT32_C( 0x80000000 ); /* fanout size 0, but dead */
+
+    for ( auto const& fn : _events->on_delete )
+    {
+      ( *fn )( n );
+    }
+
+    for ( auto i = 0u; i < nobj.children.size(); ++i )
+    {
+      if ( fanout_size( nobj.children[i].index ) == 0 )
+      {
+        continue;
+      }
+      if ( decr_fanout_size( nobj.children[i].index ) == 0 )
+      {
+        take_out_node( nobj.children[i].index );
+      }
+    }
+  }
+
+  inline bool is_dead( node const& n ) const
+  {
+    return ( _storage->nodes[n].data[0].h1 >> 31 ) & 1;
+  }
+
+  void substitute_node( node const& old_node, signal const& new_signal )
+  {
+    std::stack<std::pair<node, signal>> to_substitute;
+    to_substitute.push( { old_node, new_signal } );
+
+    while ( !to_substitute.empty() )
+    {
+      const auto [_old, _new] = to_substitute.top();
+      to_substitute.pop();
+
+      for ( auto idx = 1u; idx < _storage->nodes.size(); ++idx )
+      {
+        if ( is_ci( idx ) )
+          continue; /* ignore CIs */
+
+        if ( const auto repl = replace_in_node( idx, _old, _new ); repl )
+        {
+          to_substitute.push( *repl );
+        }
+      }
+
+      /* check outputs */
+      replace_in_outputs( _old, _new );
+
+      // reset fan-in of old node
+      take_out_node( _old );
+    }
+  }
+
+#pragma endregion
+
+#pragma region Structural properties
+  auto size() const
+  {
+    return static_cast<uint32_t>( _storage->nodes.size() );
+  }
+
+  auto num_cis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_cos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  auto num_pis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_pos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  auto num_gates() const
+  {
+    return static_cast<uint32_t>( _storage->nodes.size() - 1u - _storage->inputs.size() );
+  }
+
+  uint32_t fanin_size( node const& n ) const
+  {
+    if ( is_constant( n ) || is_ci( n ) )
+      return 0;
+    return _storage->nodes[n].children.size();
+  }
+
+  uint32_t fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1 & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t incr_fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1++ & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t decr_fanout_size( node const& n ) const
+  {
+    return --_storage->nodes[n].data[0].h1 & UINT32_C( 0x7FFFFFFF );
+  }
+
+  bool is_and( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_or( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_xor( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_maj( node const& n ) const
+  {
+    return n > 0 && !is_ci( n );
+  }
+
+  bool is_ite( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_xor3( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_and( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_or( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_xor( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+#pragma endregion
+
+#pragma region Functional properties
+  kitty::dynamic_truth_table node_function( const node& n ) const
+  {
+    const auto num_fanin = _storage->nodes[n].children.size();
+
+    if ( num_fanin == 3u )
+    {
+      kitty::dynamic_truth_table _maj( 3u );
+      _maj._bits[0] = 0xe8;
+      return _maj;
+    }
+    else if ( num_fanin == 5u )
+    {
+      kitty::dynamic_truth_table _maj( 5u );
+      _maj._bits[0] = 0xfee8e880;
+      return _maj;
+    }
+    else
+    {
+      if ( _storage->data.node_fn_cache.count( num_fanin ) )
+      {
+        return _storage->data.node_fn_cache[num_fanin];
+      }
+
+      std::vector<std::vector<kitty::dynamic_truth_table>> dp;
+      for ( auto i = 0u; i <= num_fanin; i++ )
+      {
+        dp.push_back( { ~kitty::dynamic_truth_table( num_fanin ) } );
+        if ( i == 0u )
+          continue;
+        auto ith_var = kitty::nth_var<kitty::dynamic_truth_table>( num_fanin, i - 1 );
+        for ( auto j = 1u; j <= i && j <= ( num_fanin / 2 ) + 1; j++ )
+        {
+          dp[i].push_back( ( j < i ) ? ( ith_var & dp[i - 1][j - 1] ) | dp[i - 1][j] : ( ith_var & dp[i - 1][j - 1] ) );
+        }
+      }
+
+      return ( _storage->data.node_fn_cache[num_fanin] = dp[num_fanin][( num_fanin / 2 ) + 1] );
+    }
+  }
+#pragma endregion
+
+#pragma region Nodes and signals
+  node get_node( signal const& f ) const
+  {
+    return f.index;
+  }
+
+  signal make_signal( node const& n ) const
+  {
+    return signal( n, 0 );
+  }
+
+  bool is_complemented( signal const& f ) const
+  {
+    return f.complement;
+  }
+
+  uint32_t node_to_index( node const& n ) const
+  {
+    return static_cast<uint32_t>( n );
+  }
+
+  node index_to_node( uint32_t index ) const
+  {
+    return index;
+  }
+
+  node ci_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal co_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return *( _storage->outputs.begin() + index );
+  }
+
+  node pi_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal po_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return *( _storage->outputs.begin() + index );
+  }
+
+  uint32_t ci_index( node const& n ) const
+  {
+    assert( _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data &&
+            _storage->nodes[n].children[0].data == _storage->nodes[n].children[2].data );
+    return static_cast<uint32_t>( _storage->nodes[n].children[0].data );
+  }
+
+  uint32_t co_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_co( [&]( const auto& x, auto index ) {
+      if ( x == s )
+      {
+        i = index;
+        return false;
+      }
+      return true;
+    } );
+    return i;
+  }
+
+  uint32_t pi_index( node const& n ) const
+  {
+    assert( _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data &&
+            _storage->nodes[n].children[0].data == _storage->nodes[n].children[2].data );
+    return static_cast<uint32_t>( _storage->nodes[n].children[0].data );
+  }
+
+  uint32_t po_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_po( [&]( const auto& x, auto index ) {
+      if ( x == s )
+      {
+        i = index;
+        return false;
+      }
+      return true;
+    } );
+    return i;
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( _storage->nodes.size() );
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_dead( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_ci( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_co( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->outputs.begin(), _storage->outputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->outputs.begin(), _storage->outputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( 1u, _storage->nodes.size() ); // start from 1 to avoid constant
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_ci( n ) && !is_dead( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_fanin( node const& n, Fn&& fn ) const
+  {
+    if ( n == 0 || is_ci( n ) )
+      return;
+
+    static_assert( detail::is_callable_without_index_v<Fn, signal, bool> ||
+                   detail::is_callable_with_index_v<Fn, signal, bool> ||
+                   detail::is_callable_without_index_v<Fn, signal, void> ||
+                   detail::is_callable_with_index_v<Fn, signal, void> );
+
+    if constexpr ( detail::is_callable_without_index_v<Fn, signal, bool> )
+    {
+      for ( auto i = 0u; i < _storage->nodes[n].children.size(); i++ )
+      {
+        if ( !fn( signal{ _storage->nodes[n].children[i] } ) )
+          return;
+      }
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, signal, bool> )
+    {
+      for ( auto i = 0u; i < _storage->nodes[n].children.size(); i++ )
+      {
+        if ( !fn( signal{ _storage->nodes[n].children[i] }, i ) )
+          return;
+      }
+    }
+    else if constexpr ( detail::is_callable_without_index_v<Fn, signal, void> )
+    {
+      for ( auto i = 0u; i < _storage->nodes[n].children.size(); i++ )
+      {
+        fn( signal{ _storage->nodes[n].children[i] } );
+      }
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, signal, void> )
+    {
+      for ( auto i = 0u; i < _storage->nodes[n].children.size(); i++ )
+      {
+        fn( signal{ _storage->nodes[n].children[i] }, i );
+      }
+    }
+  }
+#pragma endregion
+
+  template<typename Iterator>
+  iterates_over_t<Iterator, bool>
+  compute_majority_n_with_bool( Iterator begin, Iterator end ) const
+  {
+    std::vector<std::vector<typename Iterator::value_type>> dp;
+    std::vector<typename Iterator::value_type> v( begin, end );
+
+    const auto n = v.size();
+    typename Iterator::value_type one = true;
+
+    for ( auto i = 0u; i <= n; i++ )
+    {
+      dp.push_back( { one } );
+      if ( i == 0u )
+        continue;
+      auto ith_var = v[i - 1];
+      for ( auto j = 1u; j <= i && j <= ( n / 2 ) + 1; j++ )
+      {
+        dp[i].push_back( ( j < i ) ? ( ith_var & dp[i - 1][j - 1] ) || dp[i - 1][j] : ( ith_var && dp[i - 1][j - 1] ) );
+      }
+    }
+
+    return ( dp[n][( n / 2 ) + 1] );
+  }
+
+  template<typename Iterator>
+  auto compute_majority_n( Iterator begin, Iterator end ) const
+  {
+    std::vector<std::vector<typename Iterator::value_type>> dp;
+    std::vector<typename Iterator::value_type> v( begin, end );
+
+    const auto n = v.size();
+    typename Iterator::value_type one = ~( v[0] ^ v[0] );
+
+    for ( auto i = 0u; i <= n; i++ )
+    {
+      dp.push_back( { one } );
+      if ( i == 0u )
+        continue;
+      auto ith_var = v[i - 1];
+      for ( auto j = 1u; j <= i && j <= ( n / 2 ) + 1; j++ )
+      {
+        dp[i].push_back( ( j < i ) ? ( ith_var & dp[i - 1][j - 1] ) | dp[i - 1][j] : ( ith_var & dp[i - 1][j - 1] ) );
+      }
+    }
+
+    return ( dp[n][( n / 2 ) + 1] );
+  }
+
+#pragma region Value simulation
+  template<typename Iterator>
+  iterates_over_t<Iterator, bool>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    std::vector<typename Iterator::value_type> v;
+    auto i = 0u;
+    for ( auto it = begin; it != end; it++, i++ )
+    {
+      v.push_back( ( *it ) ^ _storage->nodes[n].children[i].weight );
+    }
+    return compute_majority_n_with_bool( v.begin(), v.end() );
+  }
+
+  template<typename Iterator>
+  iterates_over_truth_table_t<Iterator>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    std::vector<typename Iterator::value_type> v;
+    auto i = 0u;
+    for ( auto it = begin; it != end; it++, i++ )
+    {
+      v.push_back( _storage->nodes[n].children[i].weight ? ~( *it ) : ( *it ) );
+    }
+
+    return compute_majority_n( v.begin(), v.end() );
+  }
+
+  /*! \brief Re-compute the last block. */
+  template<typename Iterator>
+  void compute( node const& n, kitty::partial_truth_table& result, Iterator begin, Iterator end ) const
+  {
+    static_assert( iterates_over_v<Iterator, kitty::partial_truth_table>, "begin and end have to iterate over partial_truth_tables" );
+
+    (void)end;
+    assert( n != 0 && !is_ci( n ) );
+
+    assert( begin->num_bits() > 0 && "truth tables must not be empty" );
+    for ( auto it = begin; it != end; it++ )
+    {
+      assert( begin->num_bits() == it->num_bits() );
+    }
+    assert( begin->num_bits() >= result.num_bits() );
+    assert( result.num_blocks() == begin->num_blocks() || ( result.num_blocks() == begin->num_blocks() - 1 && result.num_bits() % 64 == 0 ) );
+
+    result.resize( begin->num_bits() );
+
+    std::vector<uint64_t> v;
+    auto i = 0u;
+    for ( auto it = begin; it != end; it++, i++ )
+    {
+      v.push_back( _storage->nodes[n].children[i].weight ? ~( it->_bits.back() ) : ( it->_bits.back() ) );
+    }
+
+    result._bits.back() = compute_majority_n( v.begin(), v.end() );
+
+    result.mask_bits();
+  }
+#pragma endregion
+
+#pragma region Custom node values
+  void clear_values() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[0].h2 = 0; } );
+  }
+
+  auto value( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h2;
+  }
+
+  void set_value( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[0].h2 = v;
+  }
+
+  auto incr_value( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h2++;
+  }
+
+  auto decr_value( node const& n ) const
+  {
+    return --_storage->nodes[n].data[0].h2;
+  }
+#pragma endregion
+
+#pragma region Visited flags
+  void clear_visited() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[1].h1 = 0; } );
+  }
+
+  auto visited( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h1;
+  }
+
+  void set_visited( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[1].h1 = v;
+  }
+
+  uint32_t trav_id() const
+  {
+    return _storage->trav_id;
+  }
+
+  void incr_trav_id() const
+  {
+    ++_storage->trav_id;
+  }
+#pragma endregion
+
+#pragma region General methods
+  auto& events() const
+  {
+    return *_events;
+  }
+#pragma endregion
+
+public:
+  std::shared_ptr<aqfp_storage> _storage;
+  std::shared_ptr<network_events<base_type>> _events;
+};
+
+} // namespace mockturtle
+
+namespace std
+{
+
+template<>
+struct hash<mockturtle::aqfp_network::signal>
+{
+  uint64_t operator()( mockturtle::aqfp_network::signal const& s ) const noexcept
+  {
+    uint64_t k = s.data;
+    k ^= k >> 33;
+    k *= 0xff51afd7ed558ccd;
+    k ^= k >> 33;
+    k *= 0xc4ceb9fe1a85ec53;
+    k ^= k >> 33;
+    return k;
+  }
+}; /* hash */
+
+} // namespace std
\ No newline at end of file
diff --git a/include/mockturtle/networks/block.hpp b/include/mockturtle/networks/block.hpp
new file mode 100644
index 0000000..0097e5a
--- /dev/null
+++ b/include/mockturtle/networks/block.hpp
@@ -0,0 +1,1078 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file block.hpp
+  \brief Block logic network implementation with multi-output support
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+#include "../utils/algorithm.hpp"
+#include "../utils/truth_table_cache.hpp"
+#include "detail/foreach.hpp"
+#include "events.hpp"
+#include "storage.hpp"
+
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+
+#include <algorithm>
+#include <memory>
+
+namespace mockturtle
+{
+
+struct block_storage_data
+{
+  truth_table_cache<kitty::dynamic_truth_table> cache;
+};
+
+/*! \brief Block node
+ *
+ * `data[0].h1`  : Application-specific value
+ * `data[1].h1`  : Visited flags
+ * `data[1].h2`  : Total fan-out size (we use MSB to indicate whether a node is dead)
+ * `data[2+i].h1`: Function literal in truth table cache for the fanout
+ * `data[2+i].h2`: Fan-out size
+ *
+ */
+struct block_storage_node : block_fanin_node<2>
+{
+  block_storage_node()
+  {
+    data = decltype( data )( 3 );
+  }
+
+  bool operator==( block_storage_node const& other ) const
+  {
+    if ( data.size() != other.data.size() )
+      return false;
+
+    for ( auto i = 2; i < data.size() + 2; ++i )
+      if ( ( data[i].h1 != other.data[i].h1 ) || ( children != other.children ) )
+        return false;
+
+    return true;
+  }
+};
+
+/*! \brief Block storage container
+
+  ...
+*/
+using block_storage = storage_no_hash<block_storage_node, block_storage_data>;
+
+class block_network
+{
+public:
+#pragma region Types and constructors
+  static constexpr auto min_fanin_size = 1;
+  static constexpr auto max_fanin_size = 32;
+  static constexpr auto min_gate_output_size = 1;
+  static constexpr auto max_gate_output_size = 2;
+  static constexpr auto output_signal_bits = 1;
+
+  using base_type = block_network;
+  using storage = std::shared_ptr<block_storage>;
+  using node = uint64_t;
+
+  struct signal
+  {
+    signal() = default;
+
+    signal( uint64_t index, uint64_t complement )
+        : complement( complement ), output( 0 ), index( index )
+    {
+    }
+
+    signal( uint32_t index )
+        : complement( 0 ), output( 0 ), index( index )
+    {
+    }
+
+    signal( uint64_t index, uint64_t complement, uint64_t output )
+        : complement( complement ), output( output ), index( index )
+    {
+    }
+
+    explicit signal( uint64_t data )
+        : data( data )
+    {
+    }
+
+    signal( block_storage::node_type::pointer_type const& p )
+        : complement( p.weight & 1 ), output( p.weight >> 1 ), index( p.index )
+    {
+    }
+
+    union
+    {
+      struct
+      {
+        uint64_t complement : 1;
+        uint64_t output : output_signal_bits;
+        uint64_t index : 63 - output_signal_bits;
+      };
+      uint64_t data;
+    };
+
+    signal operator!() const
+    {
+      return signal( data ^ 1 );
+    }
+
+    signal operator+() const
+    {
+      return { index, output, 0 };
+    }
+
+    signal operator-() const
+    {
+      return { index, output, 1 };
+    }
+
+    signal operator^( bool complement ) const
+    {
+      return signal( data ^ ( complement ? 1 : 0 ) );
+    }
+
+    bool operator==( signal const& other ) const
+    {
+      return data == other.data;
+    }
+
+    bool operator!=( signal const& other ) const
+    {
+      return data != other.data;
+    }
+
+    bool operator<( signal const& other ) const
+    {
+      return data < other.data;
+    }
+
+    operator block_storage::node_type::pointer_type() const
+    {
+      return { index, ( output << 1 ) | complement };
+    }
+
+    operator uint64_t() const
+    {
+      return data;
+    }
+
+#if __cplusplus > 201703L
+    bool operator==( block_storage::node_type::pointer_type const& other ) const
+    {
+      return data == other.data;
+    }
+#endif
+  };
+
+  block_network()
+      : _storage( std::make_shared<block_storage>() ),
+        _events( std::make_shared<decltype( _events )::element_type>() )
+  {
+    _init();
+  }
+
+  block_network( std::shared_ptr<block_storage> storage )
+      : _storage( storage ),
+        _events( std::make_shared<decltype( _events )::element_type>() )
+  {
+    _init();
+  }
+
+  block_network clone() const
+  {
+    return { std::make_shared<block_storage>( *_storage ) };
+  }
+
+protected:
+  inline void _init()
+  {
+    /* reserve the second node for constant 1 */
+    _storage->nodes.emplace_back();
+
+    /* reserve some truth tables for nodes */
+    kitty::dynamic_truth_table tt_zero( 0 );
+    _storage->data.cache.insert( tt_zero );
+
+    static uint64_t _not = 0x1;
+    kitty::dynamic_truth_table tt_not( 1 );
+    kitty::create_from_words( tt_not, &_not, &_not + 1 );
+    _storage->data.cache.insert( tt_not );
+
+    static uint64_t _and = 0x8;
+    kitty::dynamic_truth_table tt_and( 2 );
+    kitty::create_from_words( tt_and, &_and, &_and + 1 );
+    _storage->data.cache.insert( tt_and );
+
+    static uint64_t _or = 0xe;
+    kitty::dynamic_truth_table tt_or( 2 );
+    kitty::create_from_words( tt_or, &_or, &_or + 1 );
+    _storage->data.cache.insert( tt_or );
+
+    static uint64_t _lt = 0x4;
+    kitty::dynamic_truth_table tt_lt( 2 );
+    kitty::create_from_words( tt_lt, &_lt, &_lt + 1 );
+    _storage->data.cache.insert( tt_lt );
+
+    static uint64_t _le = 0xd;
+    kitty::dynamic_truth_table tt_le( 2 );
+    kitty::create_from_words( tt_le, &_le, &_le + 1 );
+    _storage->data.cache.insert( tt_le );
+
+    static uint64_t _xor = 0x6;
+    kitty::dynamic_truth_table tt_xor( 2 );
+    kitty::create_from_words( tt_xor, &_xor, &_xor + 1 );
+    _storage->data.cache.insert( tt_xor );
+
+    static uint64_t _maj = 0xe8;
+    kitty::dynamic_truth_table tt_maj( 3 );
+    kitty::create_from_words( tt_maj, &_maj, &_maj + 1 );
+    _storage->data.cache.insert( tt_maj );
+
+    static uint64_t _ite = 0xd8;
+    kitty::dynamic_truth_table tt_ite( 3 );
+    kitty::create_from_words( tt_ite, &_ite, &_ite + 1 );
+    _storage->data.cache.insert( tt_ite );
+
+    static uint64_t _xor3 = 0x96;
+    kitty::dynamic_truth_table tt_xor3( 3 );
+    kitty::create_from_words( tt_xor3, &_xor3, &_xor3 + 1 );
+    _storage->data.cache.insert( tt_xor3 );
+
+    /* truth tables for constants */
+    _storage->nodes[0].data[2].h1 = 0;
+    _storage->nodes[1].data[2].h1 = 1;
+  }
+#pragma endregion
+
+#pragma region Primary I / O and constants
+public:
+  signal get_constant( bool value = false ) const
+  {
+    return value ? signal( 1, 0 ) : signal( 0, 0 );
+  }
+
+  signal create_pi()
+  {
+    const auto index = _storage->nodes.size();
+    _storage->nodes.emplace_back();
+    _storage->inputs.emplace_back( index );
+    _storage->nodes[index].data[2].h1 = 2;
+    return { index, 0 };
+  }
+
+  uint32_t create_po( signal const& f )
+  {
+    /* increase ref-count to children */
+    _storage->nodes[f.index].data[1].h2++;
+    _storage->nodes[f.index].data[2 + f.output].h2++;
+    auto const po_index = static_cast<uint32_t>( _storage->outputs.size() );
+    _storage->outputs.emplace_back( f.index, ( f.output << 1 ) | f.complement );
+    return po_index;
+  }
+
+  bool is_combinational() const
+  {
+    return true;
+  }
+
+  bool is_multioutput( node const& n ) const
+  {
+    return _storage->nodes[n].data.size() > 3;
+  }
+
+  bool is_constant( node const& n ) const
+  {
+    return n <= 1;
+  }
+
+  bool is_ci( node const& n ) const
+  {
+    return n > 1 && _storage->nodes[n].children.size() == 0u;
+  }
+
+  bool is_pi( node const& n ) const
+  {
+    return n > 1 && _storage->nodes[n].children.size() == 0u;
+  }
+
+  bool constant_value( node const& n ) const
+  {
+    return n != 0;
+  }
+#pragma endregion
+
+#pragma region Create unary functions
+  signal create_buf( signal const& a )
+  {
+    return _create_node( { a }, 2 );
+  }
+
+  signal create_not( signal const& a )
+  {
+    return _create_node( { a }, 3 );
+  }
+#pragma endregion
+
+#pragma region Create binary functions
+  signal create_and( signal a, signal b )
+  {
+    return _create_node( { a, b }, 4 );
+  }
+
+  signal create_nand( signal a, signal b )
+  {
+    return _create_node( { a, b }, 5 );
+  }
+
+  signal create_or( signal a, signal b )
+  {
+    return _create_node( { a, b }, 6 );
+  }
+
+  signal create_lt( signal a, signal b )
+  {
+    return _create_node( { a, b }, 8 );
+  }
+
+  signal create_le( signal a, signal b )
+  {
+    return _create_node( { a, b }, 11 );
+  }
+
+  signal create_xor( signal a, signal b )
+  {
+    return _create_node( { a, b }, 12 );
+  }
+#pragma endregion
+
+#pragma region Create ternary functions
+  signal create_maj( signal a, signal b, signal c )
+  {
+    return _create_node( { a, b, c }, 14 );
+  }
+
+  signal create_ite( signal a, signal b, signal c )
+  {
+    return _create_node( { a, b, c }, 16 );
+  }
+
+  signal create_xor3( signal a, signal b, signal c )
+  {
+    return _create_node( { a, b, c }, 18 );
+  }
+
+  signal create_ha( signal a, signal b )
+  {
+    /* PO0: carry, PO1: sum */
+    return _create_node( { a, b }, { 4, 12 } );
+  }
+
+  signal create_hai( signal a, signal b )
+  {
+    /* PO0: carry, PO1: sum */
+    return _create_node( { a, b }, { 5, 13 } );
+  }
+
+  signal create_fa( signal a, signal b, signal c )
+  {
+    /* PO0: carry, PO1: sum */
+    return _create_node( { a, b, c }, { 14, 18 } );
+  }
+
+  signal create_fai( signal a, signal b, signal c )
+  {
+    /* PO0: carry, PO1: sum */
+    return _create_node( { a, b, c }, { 15, 19 } );
+  }
+#pragma endregion
+
+#pragma region Create nary functions
+  signal create_nary_and( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( true ), [this]( auto const& a, auto const& b ) { return create_and( a, b ); } );
+  }
+
+  signal create_nary_or( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_or( a, b ); } );
+  }
+
+  signal create_nary_xor( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_xor( a, b ); } );
+  }
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  signal _create_node( std::vector<signal> const& children, uint32_t literal )
+  {
+    storage::element_type::node_type node;
+    std::copy( children.begin(), children.end(), std::back_inserter( node.children ) );
+    node.data[2].h1 = literal;
+
+    const auto index = _storage->nodes.size();
+    _storage->nodes.push_back( node );
+
+    /* increase ref-count to children */
+    for ( auto c : children )
+    {
+      _storage->nodes[c.index].data[1].h2++; /* TODO: increase fanout count for output */
+      _storage->nodes[c.index].data[2 + c.output].h2++;
+    }
+
+    set_value( index, 0 );
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return { index, 0 };
+  }
+
+  signal _create_node( std::vector<signal> const& children, std::vector<uint32_t> const& literals )
+  {
+    storage::element_type::node_type node;
+    std::copy( children.begin(), children.end(), std::back_inserter( node.children ) );
+
+    node.data = decltype( node.data )( 2 + literals.size() );
+
+    for ( auto i = 0; i < literals.size(); ++i )
+      node.data[2 + i].h1 = literals[i];
+
+    const auto index = _storage->nodes.size();
+    _storage->nodes.push_back( node );
+
+    /* increase ref-count to children */
+    for ( auto c : children )
+    {
+      _storage->nodes[c.index].data[1].h2++;
+      _storage->nodes[c.index].data[2 + c.output].h2++;
+    }
+
+    set_value( index, 0 );
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return { index, 0 };
+  }
+
+  signal create_node( std::vector<signal> const& children, kitty::dynamic_truth_table const& function )
+  {
+    if ( children.size() == 0u )
+    {
+      assert( function.num_vars() == 0u );
+      return get_constant( !kitty::is_const0( function ) );
+    }
+    return _create_node( children, _storage->data.cache.insert( function ) );
+  }
+
+  signal create_node( std::vector<signal> const& children, std::vector<kitty::dynamic_truth_table> const& functions )
+  {
+    assert( functions.size() > 0 );
+
+    if ( children.size() == 0u )
+    {
+      assert( functions[0].num_vars() == 0u );
+      return get_constant( !kitty::is_const0( functions[0] ) );
+    }
+    std::vector<uint32_t> literals;
+    for ( auto const& tt : functions )
+      literals.push_back( _storage->data.cache.insert( tt ) );
+
+    return _create_node( children, literals );
+  }
+
+  signal clone_node( block_network const& other, node const& source, std::vector<signal> const& children )
+  {
+    assert( !children.empty() );
+    if ( other.is_multioutput( source ) )
+    {
+      std::vector<kitty::dynamic_truth_table> tts;
+      for ( auto i = 2; i < other._storage->nodes[source].data.size(); ++i )
+        tts.push_back( other._storage->data.cache[other._storage->nodes[source].data[i].h1] );
+      return create_node( children, tts );
+    }
+    else
+    {
+      const auto tt = other._storage->data.cache[other._storage->nodes[source].data[2].h1];
+      return create_node( children, tt );
+    }
+  }
+#pragma endregion
+
+#pragma region Restructuring
+  void replace_in_node( node const& n, node const& old_node, signal new_signal )
+  {
+    bool in_fanin = false;
+    auto& nobj = _storage->nodes[n];
+    for ( auto& child : nobj.children )
+    {
+      if ( child.index == old_node )
+      {
+        in_fanin = true;
+        break;
+      }
+    }
+
+    if ( !in_fanin )
+      return;
+
+    // remember before
+    std::vector<signal> old_children( nobj.children.size() );
+    std::transform( nobj.children.begin(), nobj.children.end(), old_children.begin(), []( auto c ) { return signal{ c }; } );
+
+    /* replace in node */
+    for ( auto& child : nobj.children )
+    {
+      if ( child.index == old_node )
+      {
+        child = signal{ new_signal.data ^ ( child.data & 1 ) };
+        // increment fan-out of new node
+        _storage->nodes[new_signal.index].data[1].h2++;
+        _storage->nodes[new_signal.index].data[2 + new_signal.output].h2++;
+      }
+    }
+
+    for ( auto const& fn : _events->on_modified )
+    {
+      ( *fn )( n, old_children );
+    }
+  }
+
+  void replace_in_node_no_restrash( node const& n, node const& old_node, signal new_signal )
+  {
+    replace_in_node( n, old_node, new_signal );
+  }
+
+  void replace_in_outputs( node const& old_node, signal const& new_signal )
+  {
+    if ( is_dead( old_node ) )
+      return;
+
+    for ( auto& output : _storage->outputs )
+    {
+      if ( output.index == old_node )
+      {
+        output = signal{ new_signal.data ^ ( output.data & 1 ) };
+
+        if ( old_node != new_signal.index )
+        {
+          /* increment fan-in of new node */
+          _storage->nodes[new_signal.index].data[1].h2++;
+          _storage->nodes[new_signal.index].data[2 + new_signal.output].h2++;
+        }
+      }
+    }
+  }
+
+  void take_out_node( node const& n )
+  {
+    /* we cannot delete CIs, constants, or already dead nodes */
+    if ( n < 2 || is_ci( n ) )
+      return;
+
+    /* delete the node */
+    auto& nobj = _storage->nodes[n];
+    nobj.data[1].h2 = UINT32_C( 0x80000000 ); /* fanout size 0, but dead */
+
+    /* remove fanout count over output pins */
+    for ( uint32_t i = 2; i < _storage->nodes[n].data.size(); ++i )
+    {
+      nobj.data[i].h2 = 0;
+    }
+
+    for ( auto const& fn : _events->on_delete )
+    {
+      ( *fn )( n );
+    }
+
+    /* if the node has been deleted, then deref fanout_size of
+       fanins and try to take them out if their fanout_size become 0 */
+    for ( auto i = 0; i < nobj.children.size(); ++i )
+    {
+      auto& child = nobj.children[i];
+      if ( fanout_size( nobj.children[i].index ) == 0 )
+      {
+        continue;
+      }
+
+      decr_fanout_size_pin( nobj.children[i].index, signal{ child }.output );
+      if ( decr_fanout_size( nobj.children[i].index ) == 0 )
+      {
+        take_out_node( nobj.children[i].index );
+      }
+    }
+  }
+
+  void revive_node( node const& n )
+  {
+    assert( !is_dead( n ) );
+    return;
+  }
+
+  void substitute_node( node const& old_node, signal const& new_signal )
+  {
+    /* find all parents from old_node */
+    for ( auto idx = 2u; idx < _storage->nodes.size(); ++idx )
+    {
+      if ( is_ci( idx ) || is_dead( idx ) )
+        continue; /* ignore CIs and dead nodes */
+
+      replace_in_node( idx, old_node, new_signal );
+    }
+
+    /* check outputs */
+    replace_in_outputs( old_node, new_signal );
+
+    /* recursively reset old node */
+    if ( old_node != new_signal.index )
+    {
+      take_out_node( old_node );
+    }
+  }
+
+  void substitute_node_no_restrash( node const& old_node, signal const& new_signal )
+  {
+    substitute_node( old_node, new_signal );
+  }
+
+  inline bool is_dead( node const& n ) const
+  {
+    /* A dead node is simply a dangling node */
+    return ( _storage->nodes[n].data[1].h2 >> 31 ) & 1;
+  }
+#pragma endregion
+
+#pragma region Structural properties
+  auto size() const
+  {
+    return static_cast<uint32_t>( _storage->nodes.size() );
+  }
+
+  auto num_cis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_cos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  auto num_pis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_pos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  auto num_gates() const
+  {
+    return static_cast<uint32_t>( _storage->nodes.size() - _storage->inputs.size() - 2 );
+  }
+
+  uint32_t num_outputs( node const& n ) const
+  {
+    return static_cast<uint32_t>( _storage->nodes[n].data.size() - 2 );
+  }
+
+  uint32_t fanin_size( node const& n ) const
+  {
+    return static_cast<uint32_t>( _storage->nodes[n].children.size() );
+  }
+
+  uint32_t fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h2 & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t incr_fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h2++ & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t decr_fanout_size( node const& n ) const
+  {
+    return --_storage->nodes[n].data[1].h2 & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t incr_fanout_size_pin( node const& n, uint32_t pin_index ) const
+  {
+    return _storage->nodes[n].data[2 + pin_index].h2++;
+  }
+
+  uint32_t decr_fanout_size_pin( node const& n, uint32_t pin_index ) const
+  {
+    return --_storage->nodes[n].data[2 + pin_index].h2;
+  }
+
+  uint32_t fanout_size_pin( node const& n, uint32_t pin_index ) const
+  {
+    return _storage->nodes[n].data[2 + pin_index].h2;
+  }
+
+  bool is_function( node const& n ) const
+  {
+    return n > 1 && !is_ci( n );
+  }
+
+  bool is_and( node const& n ) const
+  {
+    return n > 1 && _storage->nodes[n].data.size() == 3 && _storage->nodes[n].data[2].h1 == 4;
+  }
+
+  bool is_and( signal const& f ) const
+  {
+    return f.index > 1 && _storage->nodes[f.index].data[2 + f.output].h1 == 4;
+  }
+
+  bool is_or( node const& n ) const
+  {
+    return n > 1 && _storage->nodes[n].data.size() == 3 && _storage->nodes[n].data[2].h1 == 6;
+  }
+
+  bool is_or( signal const& f ) const
+  {
+    return f.index > 1 && _storage->nodes[f.index].data[2 + f.output].h1 == 6;
+  }
+
+  bool is_xor( node const& n ) const
+  {
+    return n > 1 && _storage->nodes[n].data.size() == 3 && _storage->nodes[n].data[2].h1 == 12;
+  }
+
+  bool is_xor( signal const& f ) const
+  {
+    return f.index > 1 && _storage->nodes[f.index].data[2 + f.output].h1 == 12;
+  }
+
+  bool is_maj( node const& n ) const
+  {
+    return n > 1 && _storage->nodes[n].data.size() == 3 && _storage->nodes[n].data[2].h1 == 14;
+  }
+
+  bool is_maj( signal const& f ) const
+  {
+    return f.index > 1 && _storage->nodes[f.index].data[2 + f.output].h1 == 14;
+  }
+
+  bool is_ite( node const& n ) const
+  {
+    return n > 1 && _storage->nodes[n].data.size() == 3 && _storage->nodes[n].data[2].h1 == 16;
+  }
+
+  bool is_ite( signal const& f ) const
+  {
+    return f.index > 1 && _storage->nodes[f.index].data[2 + f.output].h1 == 16;
+  }
+
+  bool is_xor3( node const& n ) const
+  {
+    return n > 1 && _storage->nodes[n].data.size() == 3 && _storage->nodes[n].data[2].h1 == 18;
+  }
+
+  bool is_xor3( signal const& f ) const
+  {
+    return f.index > 1 && _storage->nodes[f.index].data[2 + f.output].h1 == 18;
+  }
+#pragma endregion
+
+#pragma region Functional properties
+  kitty::dynamic_truth_table node_function( const node& n ) const
+  {
+    return _storage->data.cache[_storage->nodes[n].data[2].h1];
+  }
+
+  kitty::dynamic_truth_table node_function_pin( const node& n, uint32_t pin_index ) const
+  {
+    return _storage->data.cache[_storage->nodes[n].data[2 + pin_index].h1];
+  }
+#pragma endregion
+
+#pragma region Nodes and signals
+  node get_node( signal const& f ) const
+  {
+    return f.index;
+  }
+
+  signal make_signal( node const& n ) const
+  {
+    return { n, 0 };
+  }
+
+  signal make_signal( node const& n, uint32_t output_pin ) const
+  {
+    return { n, 0, output_pin };
+  }
+
+  bool is_complemented( signal const& f ) const
+  {
+    return f.complement ? true : false;
+  }
+
+  uint32_t get_output_pin( signal const& f ) const
+  {
+    return static_cast<uint32_t>( f.output );
+  }
+
+  signal next_output_pin( signal const& f ) const
+  {
+    return { f.index, f.complement, f.output + 1 };
+  }
+
+  uint32_t node_to_index( node const& n ) const
+  {
+    return static_cast<uint32_t>( n );
+  }
+
+  node index_to_node( uint32_t index ) const
+  {
+    return index;
+  }
+
+  node ci_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal co_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return *( _storage->outputs.begin() + index );
+  }
+
+  node pi_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal po_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return *( _storage->outputs.begin() + index );
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( _storage->nodes.size() );
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_dead( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_ci( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_co( Fn&& fn ) const
+  {
+    using IteratorType = decltype( _storage->outputs.begin() );
+    detail::foreach_element_transform<IteratorType, signal>(
+        _storage->outputs.begin(), _storage->outputs.end(), []( auto f ) { return signal( f ); }, fn );
+  }
+
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    using IteratorType = decltype( _storage->outputs.begin() );
+    detail::foreach_element_transform<IteratorType, signal>(
+        _storage->outputs.begin(), _storage->outputs.end(), []( auto f ) { return signal( f ); }, fn );
+  }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( 2u, _storage->nodes.size() ); /* start from 2 to avoid constants */
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_ci( n ) && !is_dead( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_fanin( node const& n, Fn&& fn ) const
+  {
+    if ( n == 0 || is_ci( n ) )
+      return;
+
+    using IteratorType = decltype( _storage->outputs.begin() );
+    detail::foreach_element_transform<IteratorType, signal>(
+        _storage->nodes[n].children.begin(), _storage->nodes[n].children.end(), []( auto f ) { return signal( f ); }, fn );
+  }
+#pragma endregion
+
+#pragma region Simulate values // (Works on single-output gates only)
+  template<typename Iterator>
+  iterates_over_t<Iterator, bool>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    uint32_t index{ 0 };
+    auto it = _storage->nodes[n].children.begin();
+    while ( begin != end )
+    {
+      index <<= 1;
+      index ^= *begin++ ? ( ~( it->weight ) & 1 ) : ( ( it->weight ) & 1 );
+      ++it;
+    }
+    return kitty::get_bit( _storage->data.cache[_storage->nodes[n].data[2].h1], index );
+  }
+
+  template<typename Iterator>
+  iterates_over_truth_table_t<Iterator>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    const auto nfanin = _storage->nodes[n].children.size();
+
+    std::vector<typename std::iterator_traits<Iterator>::value_type> tts( begin, end );
+
+    assert( nfanin != 0 );
+    assert( tts.size() == nfanin );
+
+    /* adjust polarities */
+    for ( auto j = 0u; j < nfanin; ++j )
+    {
+      if ( _storage->nodes[n].children[j].weight & 1 )
+        tts[j] = ~tts[j];
+    }
+
+    /* resulting truth table has the same size as any of the children */
+    auto result = tts.front().construct();
+    const auto gate_tt = _storage->data.cache[_storage->nodes[n].data[2].h1];
+
+    for ( uint32_t i = 0u; i < static_cast<uint32_t>( result.num_bits() ); ++i )
+    {
+      uint32_t pattern = 0u;
+      for ( auto j = 0u; j < nfanin; ++j )
+      {
+        pattern |= kitty::get_bit( tts[j], i ) << j;
+      }
+      if ( kitty::get_bit( gate_tt, pattern ) )
+      {
+        kitty::set_bit( result, i );
+      }
+    }
+
+    return result;
+  }
+#pragma endregion
+
+#pragma region Custom node values
+  void clear_values() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[0].h1 = 0; } );
+  }
+
+  uint32_t value( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1;
+  }
+
+  void set_value( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[0].h1 = v;
+  }
+
+  uint32_t incr_value( node const& n ) const
+  {
+    return static_cast<uint32_t>( _storage->nodes[n].data[0].h1++ );
+  }
+
+  uint32_t decr_value( node const& n ) const
+  {
+    return static_cast<uint32_t>( --_storage->nodes[n].data[0].h1 );
+  }
+#pragma endregion
+
+#pragma region Visited flags
+  void clear_visited() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[1].h1 = 0; } );
+  }
+
+  auto visited( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h1;
+  }
+
+  void set_visited( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[1].h1 = v;
+  }
+
+  uint32_t trav_id() const
+  {
+    return _storage->trav_id;
+  }
+
+  void incr_trav_id() const
+  {
+    ++_storage->trav_id;
+  }
+#pragma endregion
+
+#pragma region General methods
+  auto& events() const
+  {
+    return *_events;
+  }
+#pragma endregion
+
+public:
+  std::shared_ptr<block_storage> _storage;
+  std::shared_ptr<network_events<base_type>> _events;
+};
+
+} // namespace mockturtle
diff --git a/include/mockturtle/networks/buffered.hpp b/include/mockturtle/networks/buffered.hpp
new file mode 100644
index 0000000..eef214f
--- /dev/null
+++ b/include/mockturtle/networks/buffered.hpp
@@ -0,0 +1,1030 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file buffered.hpp
+  \brief Buffered networks implementation
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+#include "aig.hpp"
+#include "aqfp.hpp"
+#include "crossed.hpp"
+#include "mig.hpp"
+
+#include <cassert>
+
+namespace mockturtle
+{
+
+class buffered_aig_network : public aig_network
+{
+public:
+  static constexpr bool is_buffered_network_type = true;
+
+#pragma region Create unary functions
+  signal create_buf( signal const& a )
+  {
+    const auto index = _storage->nodes.size();
+    auto& node = _storage->nodes.emplace_back();
+    node.children[0] = a;
+    node.children[1] = !a;
+
+    if ( index >= .9 * _storage->nodes.capacity() )
+    {
+      _storage->nodes.reserve( static_cast<uint64_t>( 3.1415f * index ) );
+    }
+
+    /* increase ref-count to children */
+    _storage->nodes[a.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return { index, 0 };
+  }
+
+  void invert( node const& n )
+  {
+    assert( !is_constant( n ) && !is_pi( n ) );
+    assert( fanout_size( n ) == 0 );
+    _storage->nodes[n].children[0].weight ^= 1;
+    _storage->nodes[n].children[1].weight ^= 1;
+  }
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  signal clone_node( aig_network const& other, node const& source, std::vector<signal> const& children )
+  {
+    (void)other;
+    (void)source;
+    assert( other.is_and( source ) );
+    assert( children.size() == 2u );
+    return create_and( children[0u], children[1u] );
+  }
+#pragma endregion
+
+#pragma region Restructuring
+  // disable restructuring
+  std::optional<std::pair<node, signal>> replace_in_node( node const& n, node const& old_node, signal new_signal ) = delete;
+  void replace_in_outputs( node const& old_node, signal const& new_signal ) = delete;
+  void take_out_node( node const& n ) = delete;
+  void substitute_node( node const& old_node, signal const& new_signal ) = delete;
+  void substitute_nodes( std::list<std::pair<node, signal>> substitutions ) = delete;
+#pragma endregion
+
+#pragma region Structural properties
+  uint32_t fanin_size( node const& n ) const
+  {
+    if ( is_constant( n ) || is_ci( n ) )
+      return 0;
+    else if ( is_buf( n ) )
+      return 1;
+    else
+      return 2;
+  }
+
+  // including buffers, splitters, and inverters
+  bool is_buf( node const& n ) const
+  {
+    return _storage->nodes[n].children[0].index == _storage->nodes[n].children[1].index && _storage->nodes[n].children[0].weight != _storage->nodes[n].children[1].weight;
+  }
+
+  bool is_not( node const& n ) const
+  {
+    return _storage->nodes[n].children[0].weight;
+  }
+
+  bool is_and( node const& n ) const
+  {
+    return n > 0 && !is_ci( n ) && !is_buf( n );
+  }
+
+#pragma endregion
+
+#pragma region Functional properties
+  kitty::dynamic_truth_table node_function( const node& n ) const
+  {
+    if ( is_buf( n ) )
+    {
+      kitty::dynamic_truth_table _buf( 1 );
+      _buf._bits[0] = 0x2;
+      return _buf;
+    }
+
+    kitty::dynamic_truth_table _and( 2 );
+    _and._bits[0] = 0x8;
+    return _and;
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( 1u, _storage->nodes.size() ); /* start from 1 to avoid constant */
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_ci( n ) && !is_dead( n ) && !is_buf( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_fanin( node const& n, Fn&& fn ) const
+  {
+    if ( n == 0 || is_ci( n ) )
+      return;
+
+    static_assert( detail::is_callable_without_index_v<Fn, signal, bool> ||
+                   detail::is_callable_with_index_v<Fn, signal, bool> ||
+                   detail::is_callable_without_index_v<Fn, signal, void> ||
+                   detail::is_callable_with_index_v<Fn, signal, void> );
+
+    /* we don't use foreach_element here to have better performance */
+    if ( is_buf( n ) )
+    {
+      if constexpr ( detail::is_callable_without_index_v<Fn, signal, bool> )
+      {
+        fn( signal{ _storage->nodes[n].children[0] } );
+      }
+      else if constexpr ( detail::is_callable_with_index_v<Fn, signal, bool> )
+      {
+        fn( signal{ _storage->nodes[n].children[0] }, 0 );
+      }
+      else if constexpr ( detail::is_callable_without_index_v<Fn, signal, void> )
+      {
+        fn( signal{ _storage->nodes[n].children[0] } );
+      }
+      else if constexpr ( detail::is_callable_with_index_v<Fn, signal, void> )
+      {
+        fn( signal{ _storage->nodes[n].children[0] }, 0 );
+      }
+    }
+    else
+    {
+      if constexpr ( detail::is_callable_without_index_v<Fn, signal, bool> )
+      {
+        if ( !fn( signal{ _storage->nodes[n].children[0] } ) )
+          return;
+        fn( signal{ _storage->nodes[n].children[1] } );
+      }
+      else if constexpr ( detail::is_callable_with_index_v<Fn, signal, bool> )
+      {
+        if ( !fn( signal{ _storage->nodes[n].children[0] }, 0 ) )
+          return;
+        fn( signal{ _storage->nodes[n].children[1] }, 1 );
+      }
+      else if constexpr ( detail::is_callable_without_index_v<Fn, signal, void> )
+      {
+        fn( signal{ _storage->nodes[n].children[0] } );
+        fn( signal{ _storage->nodes[n].children[1] } );
+      }
+      else if constexpr ( detail::is_callable_with_index_v<Fn, signal, void> )
+      {
+        fn( signal{ _storage->nodes[n].children[0] }, 0 );
+        fn( signal{ _storage->nodes[n].children[1] }, 1 );
+      }
+    }
+  }
+#pragma endregion
+
+#pragma region Value simulation
+  template<typename Iterator>
+  iterates_over_t<Iterator, bool>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    if ( is_buf( n ) )
+      return is_complemented( _storage->nodes[n].children[0] ) ? !( *begin ) : *begin;
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+
+    auto v1 = *begin++;
+    auto v2 = *begin++;
+
+    return ( v1 ^ c1.weight ) && ( v2 ^ c2.weight );
+  }
+
+  template<typename Iterator>
+  iterates_over_truth_table_t<Iterator>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    if ( is_buf( n ) )
+      return is_complemented( _storage->nodes[n].children[0] ) ? ~( *begin ) : *begin;
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+
+    auto tt1 = *begin++;
+    auto tt2 = *begin++;
+
+    return ( c1.weight ? ~tt1 : tt1 ) & ( c2.weight ? ~tt2 : tt2 );
+  }
+
+  /*! \brief Re-compute the last block. */
+  template<typename Iterator>
+  void compute( node const& n, kitty::partial_truth_table& result, Iterator begin, Iterator end ) const
+  {
+    static_assert( iterates_over_v<Iterator, kitty::partial_truth_table>, "begin and end have to iterate over partial_truth_tables" );
+
+    (void)end;
+    assert( n != 0 && !is_ci( n ) );
+
+    if ( is_buf( n ) )
+    {
+      result.resize( begin->num_bits() );
+      result._bits.back() = is_complemented( _storage->nodes[n].children[0] ) ? ~( begin->_bits.back() ) : begin->_bits.back();
+      result.mask_bits();
+      return;
+    }
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+
+    auto tt1 = *begin++;
+    auto tt2 = *begin++;
+
+    assert( tt1.num_bits() > 0 && "truth tables must not be empty" );
+    assert( tt1.num_bits() == tt2.num_bits() );
+    assert( tt1.num_bits() >= result.num_bits() );
+    assert( result.num_blocks() == tt1.num_blocks() || ( result.num_blocks() == tt1.num_blocks() - 1 && result.num_bits() % 64 == 0 ) );
+
+    result.resize( tt1.num_bits() );
+    result._bits.back() = ( c1.weight ? ~( tt1._bits.back() ) : tt1._bits.back() ) & ( c2.weight ? ~( tt2._bits.back() ) : tt2._bits.back() );
+    result.mask_bits();
+  }
+#pragma endregion
+}; /* buffered_aig_network */
+
+class buffered_mig_network : public mig_network
+{
+public:
+  static constexpr bool is_buffered_network_type = true;
+
+#pragma region Create unary functions
+  signal create_buf( signal const& a )
+  {
+    const auto index = _storage->nodes.size();
+    auto& node = _storage->nodes.emplace_back();
+    node.children[0] = a;
+    node.children[1] = !a;
+    // node.children[2] = a; // not used
+
+    if ( index >= .9 * _storage->nodes.capacity() )
+    {
+      _storage->nodes.reserve( static_cast<uint64_t>( 3.1415f * index ) );
+    }
+
+    /* increase ref-count to children */
+    _storage->nodes[a.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return { index, 0 };
+  }
+
+  void invert( node const& n )
+  {
+    assert( !is_constant( n ) && !is_pi( n ) );
+    assert( fanout_size( n ) == 0 );
+    _storage->nodes[n].children[0].weight ^= 1;
+    _storage->nodes[n].children[1].weight ^= 1;
+    _storage->nodes[n].children[2].weight ^= 1;
+  }
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  signal clone_node( mig_network const& other, node const& source, std::vector<signal> const& children )
+  {
+    (void)other;
+    (void)source;
+    assert( other.is_maj( source ) );
+    assert( children.size() == 3u );
+    return create_maj( children[0u], children[1u], children[2u] );
+  }
+#pragma endregion
+
+#pragma region Restructuring
+  // disable restructuring
+  void replace_in_node( node const& n, node const& old_node, signal new_signal )
+  {
+    assert( is_buf( old_node ) );
+    auto& node = _storage->nodes[n];
+
+    if ( is_buf( n ) )
+    {
+      assert( node.children[0].index == old_node );
+      new_signal.complement ^= node.children[0].weight;
+      node.children[0] = new_signal;
+      node.children[1] = !new_signal;
+      _storage->nodes[new_signal.index].data[0].h1++;
+      return;
+    }
+
+    uint32_t fanin = 3u;
+    for ( auto i = 0u; i < 3u; ++i )
+    {
+      if ( node.children[i].index == old_node )
+      {
+        fanin = i;
+        new_signal.complement ^= node.children[i].weight;
+        break;
+      }
+    }
+    assert( fanin < 3 );
+    signal child2 = new_signal;
+    signal child1 = node.children[( fanin + 1 ) % 3];
+    signal child0 = node.children[( fanin + 2 ) % 3];
+    if ( child0.index > child1.index )
+    {
+      std::swap( child0, child1 );
+    }
+    if ( child1.index > child2.index )
+    {
+      std::swap( child1, child2 );
+    }
+    if ( child0.index > child1.index )
+    {
+      std::swap( child0, child1 );
+    }
+
+    _storage->hash.erase( node );
+    node.children[0] = child0;
+    node.children[1] = child1;
+    node.children[2] = child2;
+    _storage->hash[node] = n;
+
+    // update the reference counter of the new signal
+    _storage->nodes[new_signal.index].data[0].h1++;
+  }
+  void replace_in_outputs( node const& old_node, signal const& new_signal )
+  {
+    assert( !is_dead( old_node ) );
+
+    for ( auto& output : _storage->outputs )
+    {
+      if ( output.index == old_node )
+      {
+        output.index = new_signal.index;
+        output.weight ^= new_signal.complement;
+
+        if ( old_node != new_signal.index )
+        {
+          // increment fan-in of new node
+          _storage->nodes[new_signal.index].data[0].h1++;
+        }
+      }
+    }
+  }
+  void take_out_node( node const& n )
+  {
+    assert( is_buf( n ) );
+
+    auto& nobj = _storage->nodes[n];
+    nobj.data[0].h1 = UINT32_C( 0x80000000 ); /* fanout size 0, but dead */
+
+    for ( auto const& fn : _events->on_delete )
+    {
+      ( *fn )( n );
+    }
+
+    if ( decr_fanout_size( nobj.children[0].index ) == 0 )
+    {
+      take_out_node( nobj.children[0].index );
+    }
+  }
+  void substitute_node( node const& old_node, signal const& new_signal ) = delete;
+  void substitute_nodes( std::list<std::pair<node, signal>> substitutions ) = delete;
+#pragma endregion
+
+#pragma region Structural properties
+  uint32_t fanin_size( node const& n ) const
+  {
+    if ( is_constant( n ) || is_ci( n ) )
+      return 0;
+    else if ( is_buf( n ) )
+      return 1;
+    else
+      return 3;
+  }
+
+  // including buffers, splitters, and inverters
+  bool is_buf( node const& n ) const
+  {
+    return _storage->nodes[n].children[0].index == _storage->nodes[n].children[1].index && _storage->nodes[n].children[0].weight != _storage->nodes[n].children[1].weight;
+  }
+
+  bool is_not( node const& n ) const
+  {
+    return _storage->nodes[n].children[0].weight;
+  }
+
+  bool is_maj( node const& n ) const
+  {
+    return n > 0 && !is_ci( n ) && !is_buf( n );
+  }
+
+#pragma endregion
+
+#pragma region Functional properties
+  kitty::dynamic_truth_table node_function( const node& n ) const
+  {
+    if ( is_buf( n ) )
+    {
+      kitty::dynamic_truth_table _buf( 1 );
+      _buf._bits[0] = 0x2;
+      return _buf;
+    }
+
+    kitty::dynamic_truth_table _maj( 3 );
+    _maj._bits[0] = 0xe8;
+    return _maj;
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( 1u, _storage->nodes.size() ); /* start from 1 to avoid constant */
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_ci( n ) && !is_dead( n ) && !is_buf( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_fanin( node const& n, Fn&& fn ) const
+  {
+    if ( n == 0 || is_ci( n ) )
+      return;
+
+    static_assert( detail::is_callable_without_index_v<Fn, signal, bool> ||
+                   detail::is_callable_with_index_v<Fn, signal, bool> ||
+                   detail::is_callable_without_index_v<Fn, signal, void> ||
+                   detail::is_callable_with_index_v<Fn, signal, void> );
+
+    /* we don't use foreach_element here to have better performance */
+    if ( is_buf( n ) )
+    {
+      if constexpr ( detail::is_callable_without_index_v<Fn, signal, bool> )
+      {
+        fn( signal{ _storage->nodes[n].children[0] } );
+      }
+      else if constexpr ( detail::is_callable_with_index_v<Fn, signal, bool> )
+      {
+        fn( signal{ _storage->nodes[n].children[0] }, 0 );
+      }
+      else if constexpr ( detail::is_callable_without_index_v<Fn, signal, void> )
+      {
+        fn( signal{ _storage->nodes[n].children[0] } );
+      }
+      else if constexpr ( detail::is_callable_with_index_v<Fn, signal, void> )
+      {
+        fn( signal{ _storage->nodes[n].children[0] }, 0 );
+      }
+    }
+    else
+    {
+      if constexpr ( detail::is_callable_without_index_v<Fn, signal, bool> )
+      {
+        if ( !fn( signal{ _storage->nodes[n].children[0] } ) )
+          return;
+        if ( !fn( signal{ _storage->nodes[n].children[1] } ) )
+          return;
+        fn( signal{ _storage->nodes[n].children[2] } );
+      }
+      else if constexpr ( detail::is_callable_with_index_v<Fn, signal, bool> )
+      {
+        if ( !fn( signal{ _storage->nodes[n].children[0] }, 0 ) )
+          return;
+        if ( !fn( signal{ _storage->nodes[n].children[1] }, 1 ) )
+          return;
+        fn( signal{ _storage->nodes[n].children[2] }, 2 );
+      }
+      else if constexpr ( detail::is_callable_without_index_v<Fn, signal, void> )
+      {
+        fn( signal{ _storage->nodes[n].children[0] } );
+        fn( signal{ _storage->nodes[n].children[1] } );
+        fn( signal{ _storage->nodes[n].children[2] } );
+      }
+      else if constexpr ( detail::is_callable_with_index_v<Fn, signal, void> )
+      {
+        fn( signal{ _storage->nodes[n].children[0] }, 0 );
+        fn( signal{ _storage->nodes[n].children[1] }, 1 );
+        fn( signal{ _storage->nodes[n].children[2] }, 2 );
+      }
+    }
+  }
+#pragma endregion
+
+#pragma region Value simulation
+  template<typename Iterator>
+  iterates_over_t<Iterator, bool>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    if ( is_buf( n ) )
+      return is_complemented( _storage->nodes[n].children[0] ) ? !( *begin ) : *begin;
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+    auto const& c3 = _storage->nodes[n].children[2];
+
+    auto v1 = *begin++;
+    auto v2 = *begin++;
+    auto v3 = *begin++;
+
+    return ( ( v1 ^ c1.weight ) && ( v2 ^ c2.weight ) ) || ( ( v3 ^ c3.weight ) && ( v1 ^ c1.weight ) ) || ( ( v3 ^ c3.weight ) && ( v2 ^ c2.weight ) );
+  }
+
+  template<typename Iterator>
+  iterates_over_truth_table_t<Iterator>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    if ( is_buf( n ) )
+      return is_complemented( _storage->nodes[n].children[0] ) ? ~( *begin ) : *begin;
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+    auto const& c3 = _storage->nodes[n].children[2];
+
+    auto tt1 = *begin++;
+    auto tt2 = *begin++;
+    auto tt3 = *begin++;
+
+    return kitty::ternary_majority( c1.weight ? ~tt1 : tt1, c2.weight ? ~tt2 : tt2, c3.weight ? ~tt3 : tt3 );
+  }
+
+  /*! \brief Re-compute the last block. */
+  template<typename Iterator>
+  void compute( node const& n, kitty::partial_truth_table& result, Iterator begin, Iterator end ) const
+  {
+    static_assert( iterates_over_v<Iterator, kitty::partial_truth_table>, "begin and end have to iterate over partial_truth_tables" );
+
+    (void)end;
+    assert( n != 0 && !is_ci( n ) );
+
+    if ( is_buf( n ) )
+    {
+      result.resize( begin->num_bits() );
+      result._bits.back() = is_complemented( _storage->nodes[n].children[0] ) ? ~( begin->_bits.back() ) : begin->_bits.back();
+      result.mask_bits();
+      return;
+    }
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+    auto const& c3 = _storage->nodes[n].children[2];
+
+    auto tt1 = *begin++;
+    auto tt2 = *begin++;
+    auto tt3 = *begin++;
+
+    assert( tt1.num_bits() > 0 && "truth tables must not be empty" );
+    assert( tt1.num_bits() == tt2.num_bits() );
+    assert( tt1.num_bits() == tt3.num_bits() );
+    assert( tt1.num_bits() >= result.num_bits() );
+    assert( result.num_blocks() == tt1.num_blocks() || ( result.num_blocks() == tt1.num_blocks() - 1 && result.num_bits() % 64 == 0 ) );
+
+    result.resize( tt1.num_bits() );
+    result._bits.back() =
+        ( ( c1.weight ? ~tt1._bits.back() : tt1._bits.back() ) & ( c2.weight ? ~tt2._bits.back() : tt2._bits.back() ) ) |
+        ( ( c1.weight ? ~tt1._bits.back() : tt1._bits.back() ) & ( c3.weight ? ~tt3._bits.back() : tt3._bits.back() ) ) |
+        ( ( c2.weight ? ~tt2._bits.back() : tt2._bits.back() ) & ( c3.weight ? ~tt3._bits.back() : tt3._bits.back() ) );
+    result.mask_bits();
+  }
+#pragma endregion
+}; /* buffered_mig_network */
+
+class buffered_aqfp_network : public aqfp_network
+{
+public:
+  static constexpr bool is_buffered_network_type = true;
+
+#pragma region Primary I / O and constants
+  bool is_ci( node const& n ) const
+  {
+    if ( is_buf( n ) )
+      return false;
+
+    return _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data && _storage->nodes[n].children[0].data == _storage->nodes[n].children[2].data;
+  }
+
+  bool is_pi( node const& n ) const
+  {
+    if ( is_buf( n ) )
+      return false;
+
+    return _storage->nodes[n].children[0].data == ~static_cast<uint64_t>( 0 ) && _storage->nodes[n].children[1].data == ~static_cast<uint64_t>( 0 ) && _storage->nodes[n].children[2].data == ~static_cast<uint64_t>( 0 );
+  }
+#pragma endregion
+
+#pragma region Create unary functions
+  signal create_buf( signal const& a )
+  {
+    if ( is_constant( get_node( a ) ) )
+      return a;
+
+    const auto index = _storage->nodes.size();
+    auto& node = _storage->nodes.emplace_back();
+
+    node.children.resize( 1u );
+    node.children[0] = a;
+
+    /* increase ref-count to children */
+    _storage->nodes[a.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return { index, 0 };
+  }
+
+  void invert( node const& n )
+  {
+    assert( !is_constant( n ) && !is_pi( n ) );
+    assert( fanout_size( n ) == 0 );
+    for ( auto& s : _storage->nodes[n].children )
+    {
+      s.weight ^= 1;
+    }
+  }
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  signal clone_node( aqfp_network const& other, node const& source, std::vector<signal> const& children )
+  {
+    (void)other;
+    (void)source;
+    assert( other.is_maj( source ) );
+    assert( children.size() > 1 && children.size() % 2 == 1 );
+    return create_maj( children );
+  }
+#pragma endregion
+
+#pragma region Structural properties
+  /* redefinition of num_gates counting the gates */
+  auto num_gates() const
+  {
+    uint32_t gate_count = 0;
+    foreach_gate( [&gate_count]( auto const& n ) {
+      ++gate_count;
+    } );
+    return gate_count;
+  }
+
+  bool is_buf( node const& n ) const
+  {
+    return _storage->nodes[n].children.size() == 1;
+  }
+
+  bool is_not( node const& n ) const
+  {
+    return _storage->nodes[n].children.size() == 1 && _storage->nodes[n].children[0].weight;
+  }
+
+  bool is_maj( node const& n ) const
+  {
+    return n > 0 && !is_ci( n ) && !is_buf( n );
+  }
+
+#pragma endregion
+
+#pragma region Functional properties
+  kitty::dynamic_truth_table node_function( const node& n ) const
+  {
+    if ( is_buf( n ) )
+    {
+      kitty::dynamic_truth_table _buf( 1 );
+      _buf._bits[0] = 0x2;
+      return _buf;
+    }
+
+    const auto num_fanin = _storage->nodes[n].children.size();
+
+    if ( num_fanin == 3u )
+    {
+      kitty::dynamic_truth_table _maj( 3u );
+      _maj._bits[0] = 0xe8;
+      return _maj;
+    }
+    else if ( num_fanin == 5u )
+    {
+      kitty::dynamic_truth_table _maj( 5u );
+      _maj._bits[0] = 0xfee8e880;
+      return _maj;
+    }
+    else
+    {
+      if ( _storage->data.node_fn_cache.count( num_fanin ) )
+      {
+        return _storage->data.node_fn_cache[num_fanin];
+      }
+
+      std::vector<std::vector<kitty::dynamic_truth_table>> dp;
+      for ( auto i = 0u; i <= num_fanin; i++ )
+      {
+        dp.push_back( { ~kitty::dynamic_truth_table( num_fanin ) } );
+        if ( i == 0u )
+          continue;
+        auto ith_var = kitty::nth_var<kitty::dynamic_truth_table>( num_fanin, i - 1 );
+        for ( auto j = 1u; j <= i && j <= ( num_fanin / 2 ) + 1; j++ )
+        {
+          dp[i].push_back( ( j < i ) ? ( ith_var & dp[i - 1][j - 1] ) | dp[i - 1][j] : ( ith_var & dp[i - 1][j - 1] ) );
+        }
+      }
+
+      return ( _storage->data.node_fn_cache[num_fanin] = dp[num_fanin][( num_fanin / 2 ) + 1] );
+    }
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( 1u, _storage->nodes.size() ); /* start from 1 to avoid constant */
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_ci( n ) && !is_dead( n ) && !is_buf( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_fanin( node const& n, Fn&& fn ) const
+  {
+    if ( n == 0 || is_ci( n ) )
+      return;
+
+    static_assert( detail::is_callable_without_index_v<Fn, signal, bool> ||
+                   detail::is_callable_with_index_v<Fn, signal, bool> ||
+                   detail::is_callable_without_index_v<Fn, signal, void> ||
+                   detail::is_callable_with_index_v<Fn, signal, void> );
+
+    if constexpr ( detail::is_callable_without_index_v<Fn, signal, bool> )
+    {
+      for ( auto i = 0u; i < _storage->nodes[n].children.size(); i++ )
+      {
+        if ( !fn( signal{ _storage->nodes[n].children[i] } ) )
+          return;
+      }
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, signal, bool> )
+    {
+      for ( auto i = 0u; i < _storage->nodes[n].children.size(); i++ )
+      {
+        if ( !fn( signal{ _storage->nodes[n].children[i] }, i ) )
+          return;
+      }
+    }
+    else if constexpr ( detail::is_callable_without_index_v<Fn, signal, void> )
+    {
+      for ( auto i = 0u; i < _storage->nodes[n].children.size(); i++ )
+      {
+        fn( signal{ _storage->nodes[n].children[i] } );
+      }
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, signal, void> )
+    {
+      for ( auto i = 0u; i < _storage->nodes[n].children.size(); i++ )
+      {
+        fn( signal{ _storage->nodes[n].children[i] }, i );
+      }
+    }
+  }
+#pragma endregion
+
+#pragma region Value simulation
+  template<typename Iterator>
+  iterates_over_t<Iterator, bool>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    if ( is_buf( n ) )
+      return is_complemented( _storage->nodes[n].children[0] ) ? !( *begin ) : *begin;
+
+    std::vector<typename Iterator::value_type> v;
+    auto i = 0u;
+    for ( auto it = begin; it != end; it++, i++ )
+    {
+      v.push_back( ( *it ) ^ _storage->nodes[n].children[i].weight );
+    }
+    return compute_majority_n_with_bool( v.begin(), v.end() );
+  }
+
+  template<typename Iterator>
+  iterates_over_truth_table_t<Iterator>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    if ( is_buf( n ) )
+      return is_complemented( _storage->nodes[n].children[0] ) ? ~( *begin ) : *begin;
+
+    std::vector<typename Iterator::value_type> v;
+    auto i = 0u;
+    for ( auto it = begin; it != end; it++, i++ )
+    {
+      v.push_back( _storage->nodes[n].children[i].weight ? ~( *it ) : ( *it ) );
+    }
+
+    return compute_majority_n( v.begin(), v.end() );
+  }
+
+  /*! \brief Re-compute the last block. */
+  template<typename Iterator>
+  void compute( node const& n, kitty::partial_truth_table& result, Iterator begin, Iterator end ) const
+  {
+    static_assert( iterates_over_v<Iterator, kitty::partial_truth_table>, "begin and end have to iterate over partial_truth_tables" );
+
+    (void)end;
+    assert( n != 0 && !is_ci( n ) );
+
+    if ( is_buf( n ) )
+    {
+      result.resize( begin->num_bits() );
+      result._bits.back() = is_complemented( _storage->nodes[n].children[0] ) ? ~( begin->_bits.back() ) : begin->_bits.back();
+      result.mask_bits();
+      return;
+    }
+
+    assert( begin->num_bits() > 0 && "truth tables must not be empty" );
+    for ( auto it = begin; it != end; it++ )
+    {
+      assert( begin->num_bits() == it->num_bits() );
+    }
+    assert( begin->num_bits() >= result.num_bits() );
+    assert( result.num_blocks() == begin->num_blocks() || ( result.num_blocks() == begin->num_blocks() - 1 && result.num_bits() % 64 == 0 ) );
+
+    result.resize( begin->num_bits() );
+
+    std::vector<uint64_t> v;
+    auto i = 0u;
+    for ( auto it = begin; it != end; it++, i++ )
+    {
+      v.push_back( _storage->nodes[n].children[i].weight ? ~( it->_bits.back() ) : ( it->_bits.back() ) );
+    }
+
+    result._bits.back() = compute_majority_n( v.begin(), v.end() );
+
+    result.mask_bits();
+  }
+#pragma endregion
+}; /* buffered_aqfp_network */
+
+class buffered_crossed_klut_network : public crossed_klut_network
+{
+public:
+  static constexpr bool is_buffered_network_type = true;
+
+#pragma region Create unary functions
+  signal create_buf( signal const& a )
+  {
+    return _create_node( { a }, 2 );
+  }
+
+  void invert( node const& n )
+  {
+    if ( _storage->nodes[n].data[1].h1 == 2 )
+      _storage->nodes[n].data[1].h1 = 3;
+    else if ( _storage->nodes[n].data[1].h1 == 3 )
+      _storage->nodes[n].data[1].h1 = 2;
+    else
+      assert( false );
+  }
+#pragma endregion
+
+#pragma region Crossings
+  /*! \brief Merges two buffer nodes into a crossing cell
+   *
+   * After this operation, the network will not be in a topological order. Additionally, buf1 and buf2 will be dangling.
+   *
+   * \param buf1 First buffer node.
+   * \param buf2 Second buffer node.
+   * \return The created crossing cell.
+   */
+  node merge_into_crossing( node const& buf1, node const& buf2 )
+  {
+    assert( is_buf( buf1 ) && is_buf( buf2 ) );
+
+    auto const& in_buf1 = _storage->nodes[buf1].children[0];
+    auto const& in_buf2 = _storage->nodes[buf2].children[0];
+
+    node out_buf1{}, out_buf2{};
+    uint32_t fanin_index1 = std::numeric_limits<uint32_t>::max(), fanin_index2 = std::numeric_limits<uint32_t>::max();
+    foreach_node( [&]( node const& n ) {
+      foreach_fanin( n, [&]( auto const& f, auto i ) {
+        if ( auto const fin = get_node( f ); fin == buf1 )
+        {
+          out_buf1 = n;
+          fanin_index1 = i;
+        }
+        else if ( fin == buf2 )
+        {
+          out_buf2 = n;
+          fanin_index2 = i;
+        }
+      } );
+    } );
+    assert( out_buf1 != 0 && out_buf2 != 0 );
+    assert( fanin_index1 != std::numeric_limits<uint32_t>::max() && fanin_index2 != std::numeric_limits<uint32_t>::max() );
+
+    auto const [fout1, fout2] = create_crossing( in_buf1, in_buf2 );
+
+    _storage->nodes[out_buf1].children[fanin_index1] = fout1;
+    _storage->nodes[out_buf2].children[fanin_index2] = fout2;
+
+    /* decrease ref-count to children (was increased in `create_crossing`) */
+    _storage->nodes[in_buf1.index].data[0].h1--;
+    _storage->nodes[in_buf2.index].data[0].h1--;
+
+    _storage->nodes[buf1].children.clear();
+    _storage->nodes[buf2].children.clear();
+
+    return get_node( fout1 );
+  }
+
+#pragma endregion
+
+#pragma region Structural properties
+  // including buffers, splitters, and inverters
+  bool is_buf( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h1 == 2 || _storage->nodes[n].data[1].h1 == 3;
+  }
+
+  bool is_not( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h1 == 3;
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  /* Note: crossings are included; buffers, splitters, inverters are not */
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( 2u, _storage->nodes.size() ); /* start from 2 to avoid constants */
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_ci( n ) && !is_buf( n ); },
+        fn );
+  }
+#pragma endregion
+}; /* buffered_crossed_klut_network */
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/networks/cover.hpp b/include/mockturtle/networks/cover.hpp
new file mode 100644
index 0000000..376f4e2
--- /dev/null
+++ b/include/mockturtle/networks/cover.hpp
@@ -0,0 +1,722 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cover.hpp
+  \brief single output cover logic network implementation
+
+  \author Andrea Costamagna
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+#include "../utils/algorithm.hpp"
+
+#include "detail/foreach.hpp"
+#include "events.hpp"
+#include "storage.hpp"
+
+#include <cstdint>
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/print.hpp>
+
+#include <algorithm>
+
+namespace mockturtle {
+/*! \brief cover storage data
+ *
+ * This struct contains the constituents of the network and its main features.
+ *
+ * The constituents of the network are the covers representing the boolean
+ * functions stored in each node. These are stored in a vector of pairs. Each
+ * element is the cover of a function and a boolean value indicating whether the
+ * cover indicates the ON-set or the OFF set. More precisely:
+ * `covers`           : Vector of pairs for covers storage
+ * `covers[i].first`  : Cubes i-th cover
+ * `covers[i].second` : Boolean true (false) if ON set (OFF set)
+ * This data structure directly originates from the k-LUT one and, for this
+ * reason, it inherits from it the vast majority of the features. The main
+ * difference is the way the nodes are stored and future improvements could
+ * include the substitution of the current covers storage with a cache, to avoid
+ * the redundant storage of some recurrent boolean functions.
+ */
+struct cover_storage_data {
+  uint64_t insert(std::pair<std::vector<kitty::cube>, bool> const &cover) {
+    const auto index = covers.size();
+    covers.emplace_back(cover);
+    return index;
+  }
+
+  std::vector<std::pair<std::vector<kitty::cube>, bool>> covers;
+};
+
+/*! \brief cover node
+ *
+ * The cover node is a mixed fanin node with the following attributes:
+ * `children`  : vector of pointers to children
+ * `data[0].h1`: Fan-out size
+ * `data[0].h2`: Application-specific value
+ * `data[1].h1`: Index of the cover of the node in the covers container
+ * `data[1].h2`: Visited flags
+ */
+struct cover_storage_node : mixed_fanin_node<2> {
+  bool operator==(cover_storage_node const &other) const {
+    return data[1].h1 == other.data[1].h1 && children == other.children;
+  }
+};
+
+/*! \brief cover storage container
+ *
+ * The network as a storage entity is defined by combining the node structure
+ * with the cover_storage structure. The attributes of this storage unit are
+ * listed in the following: `nodes`            : Vector of cover storage nodes
+ * `inputs`           : Vector of indices to inputs nodes
+ * `outputs`          : Vector of pointers to node types
+ * `hash`             : maps a node to its index in the nodes vector
+ * `data`             : cover storage data
+ */
+using cover_storage = storage<cover_storage_node, cover_storage_data>;
+
+/*! \brief cover_network
+ *
+ * This class implements a data structure for a cover based network.
+ * In this representation, each node is represented by specifying its ON set or
+ its OFF set, that in both cases are stored as a vector of cubes.
+ * The information related to the set to which the node refers to is contained
+ in a boolean variable, that is true (false) if the
+ * ON set (OFF set) is considered.
+ *
+ * This data structure is primarily meant to be used for reading .blif files in
+ which the number of variables would make it unfeasible the reading via a k-LUT
+ network.
+ *
+  \verbatim embed:rst
+
+  Example
+
+  .. code-block:: c++
+
+    cover_network cover;
+
+    const auto a = cover.create_pi();
+    const auto b = cover.create_pi();
+    const auto c = cover.create_pi();
+
+    kitty::cube _11 = kitty::cube("11");
+
+    std::vector<kitty::cube> nand_from_offset { _11 };
+    const auto n1 = cover.create_cover_node( {a, b}, std::make_pair(
+ nand_from_offset, false ) );
+
+    const auto y1 = cover.create_and( n1, c );
+    cover.create_po( y1 );
+
+  \endverbatim
+ */
+
+class cover_network {
+public:
+#pragma region Types and constructors
+  static constexpr auto min_fanin_size = 1;
+  static constexpr auto max_fanin_size = 32;
+
+  using base_type = cover_network;
+  using cover_type = std::pair<std::vector<kitty::cube>, bool>;
+  using storage = std::shared_ptr<cover_storage>;
+  using node = uint64_t;
+  using signal = uint64_t;
+
+  cover_network()
+      : _storage(std::make_shared<cover_storage>()),
+        _events(std::make_shared<decltype(_events)::element_type>()) {
+    _init();
+  }
+
+  cover_network(std::shared_ptr<cover_storage> storage)
+      : _storage(storage),
+        _events(std::make_shared<decltype(_events)::element_type>()) {
+    _init();
+  }
+
+protected:
+  inline void _init() {
+    uint64_t index;
+
+    std::vector<kitty::cube> cube_dc = {kitty::cube()};
+
+    /* first node reserved for constant 0 */
+    index = _storage->data.insert(std::make_pair(cube_dc, false));
+    cover_storage_node &node_0 = _storage->nodes[0];
+    node_0.data[1].h1 = index;
+    _storage->hash[node_0] = 0;
+
+    /* reserve the second node for constant 1 */
+    _storage->nodes.emplace_back();
+    index = _storage->data.insert(std::make_pair(cube_dc, true));
+    cover_storage_node &node_1 = _storage->nodes[1];
+    node_1.data[1].h1 = index;
+    _storage->hash[node_1] = 1;
+
+    /* reserve the third node for the identity (inputs)*/
+  }
+#pragma endregion
+
+#pragma region Primary I / O and constants
+public:
+  signal get_constant(bool value = false) const { return value ? 1 : 0; }
+
+  signal create_pi() {
+    const auto index_node = _storage->nodes.size();
+    std::vector<kitty::cube> cube_I{kitty::cube("1")};
+    const auto index_covers =
+        _storage->data.insert(std::make_pair(cube_I, true));
+
+    _storage->nodes.emplace_back();
+    cover_storage_node &node_in = _storage->nodes[index_node];
+    node_in.data[1].h1 = index_node;
+    _storage->hash[node_in] = index_node;
+    _storage->inputs.emplace_back(index_node);
+
+    return index_node;
+  }
+
+  uint32_t create_po(signal const &f) {
+    /* increase ref-count to children */
+    _storage->nodes[f].data[0].h1++;
+    auto const po_index = static_cast<uint32_t>(_storage->outputs.size());
+    _storage->outputs.emplace_back(f);
+    return po_index;
+  }
+
+  bool is_combinational() const { return true; }
+
+  bool is_constant(node const &n) const { return n <= 1; }
+
+  bool is_ci(node const &n) const {
+    return std::find(_storage->inputs.begin(), _storage->inputs.end(), n) !=
+           _storage->inputs.end();
+  }
+
+  bool is_pi(node const &n) const {
+    return std::find(_storage->inputs.begin(), _storage->inputs.end(), n) !=
+           _storage->inputs.end();
+  }
+
+  bool constant_value(node const &n) const { return n == 1; }
+#pragma endregion
+
+#pragma region Create unary functions
+  signal create_buf(signal const &a) { return a; }
+
+  signal create_not(signal const &a) {
+    std::vector<kitty::cube> _not{kitty::cube("0")};
+    return _create_cover_node({a}, std::make_pair(_not, true));
+  }
+#pragma endregion
+
+#pragma region Create binary functions
+  signal create_and(signal a, signal b) {
+    std::vector<kitty::cube> _and{kitty::cube("11")};
+    return _create_cover_node({a, b}, std::make_pair(_and, true));
+  }
+
+  signal create_nand(signal a, signal b) {
+    std::vector<kitty::cube> _nand{kitty::cube("11")};
+    return _create_cover_node({a, b}, std::make_pair(_nand, false));
+  }
+
+  signal create_or(signal a, signal b) {
+    std::vector<kitty::cube> _or{kitty::cube("00")};
+    return _create_cover_node({a, b}, std::make_pair(_or, false));
+  }
+
+  signal create_nor(signal a, signal b) {
+    std::vector<kitty::cube> _nor{kitty::cube("00")};
+    return _create_cover_node({a, b}, std::make_pair(_nor, true));
+  }
+
+  signal create_lt(signal a, signal b) {
+    std::vector<kitty::cube> _lt{kitty::cube("01")};
+    return _create_cover_node({a, b}, std::make_pair(_lt, true));
+  }
+
+  signal create_le(signal a, signal b) {
+    std::vector<kitty::cube> _le{kitty::cube("10")};
+    return _create_cover_node({a, b}, std::make_pair(_le, false));
+  }
+
+  signal create_gt(signal a, signal b) {
+    std::vector<kitty::cube> _gt{kitty::cube("10")};
+    return _create_cover_node({a, b}, std::make_pair(_gt, true));
+  }
+
+  signal create_ge(signal a, signal b) {
+    std::vector<kitty::cube> _ge{kitty::cube("01")};
+    return _create_cover_node({a, b}, std::make_pair(_ge, false));
+  }
+
+  signal create_xor(signal a, signal b) {
+    std::vector<kitty::cube> _xor{kitty::cube("01"), kitty::cube("10")};
+    return _create_cover_node({a, b}, std::make_pair(_xor, true));
+  }
+
+  signal create_xnor(signal a, signal b) {
+    std::vector<kitty::cube> _xnor{kitty::cube("00"), kitty::cube("11")};
+    return _create_cover_node({a, b}, std::make_pair(_xnor, true));
+  }
+#pragma endregion
+
+#pragma region Create ternary functions
+
+  signal create_maj(signal a, signal b, signal c) {
+    std::vector<kitty::cube> _maj{kitty::cube("011"), kitty::cube("101"),
+                                  kitty::cube("110"), kitty::cube("111")};
+    return _create_cover_node({a, b, c}, std::make_pair(_maj, true));
+  }
+
+  signal create_ite(signal a, signal b, signal c) {
+    std::vector<kitty::cube> _ite{kitty::cube("11-"), kitty::cube("0-1")};
+    return _create_cover_node({a, b, c}, std::make_pair(_ite, true));
+  }
+
+  signal create_xor3(signal a, signal b, signal c) {
+    std::vector<kitty::cube> _xor3{kitty::cube("001"), kitty::cube("010"),
+                                   kitty::cube("100"), kitty::cube("111")};
+    return _create_cover_node({a, b, c}, std::make_pair(_xor3, true));
+  }
+#pragma endregion
+
+#pragma region Create nary functions
+  signal create_nary_and(std::vector<signal> const &fs) {
+    return tree_reduce(
+        fs.begin(), fs.end(), get_constant(true),
+        [this](auto const &a, auto const &b) { return create_and(a, b); });
+  }
+
+  signal create_nary_or(std::vector<signal> const &fs) {
+    return tree_reduce(
+        fs.begin(), fs.end(), get_constant(false),
+        [this](auto const &a, auto const &b) { return create_or(a, b); });
+  }
+
+  signal create_nary_xor(std::vector<signal> const &fs) {
+    return tree_reduce(
+        fs.begin(), fs.end(), get_constant(false),
+        [this](auto const &a, auto const &b) { return create_xor(a, b); });
+  }
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  signal _create_cover_node(std::vector<signal> const &children,
+                            cover_type const &new_cover) {
+
+    uint64_t literal = _storage->data.insert(new_cover);
+    storage::element_type::node_type node;
+    std::copy(children.begin(), children.end(),
+              std::back_inserter(node.children));
+    node.data[1].h1 = literal;
+
+    const auto it = _storage->hash.find(node);
+    if (it != _storage->hash.end()) {
+      return it->second;
+    }
+
+    const auto index = _storage->nodes.size();
+    _storage->nodes.emplace_back(node);
+    _storage->hash[node] = index;
+
+    /* increase ref-count to children */
+    for (auto c : children) {
+      _storage->nodes[c].data[0].h1++;
+    }
+
+    set_value(index, 0);
+
+    for (auto const &fn : _events->on_add) {
+      (*fn)(index);
+    }
+
+    return index;
+  }
+
+  /*! \brief Creates node with arbitrary cover (SOP or POS).
+   *
+   * `cover_type` is `std::pair<std::vector<kitty::cube>, bool>`, where the
+   * first element defines the cubes (clauses) of the onset (offset) and the
+   * second element selects between the onset mode (true) or offset mode
+   * (false).
+   *
+   * \param children Fanin signals
+   * \param cover Cover for node function
+   */
+  signal create_cover_node(std::vector<signal> const &children,
+                           cover_type cover) {
+    if (children.size() == 0u) {
+      return get_constant(cover.second);
+    }
+
+    return _create_cover_node(children, cover);
+  }
+
+  signal create_node(std::vector<signal> const &children,
+                     kitty::dynamic_truth_table const &function) {
+    if (children.size() == 0u) {
+      return get_constant(!kitty::is_const0(function));
+    }
+
+    cover_type new_cover;
+    bool is_sop = (kitty::count_ones(function) <= kitty::count_zeros(function));
+    new_cover.second = is_sop;
+    uint32_t mask = 1u;
+    for (uint32_t i{1}; i < children.size(); ++i)
+      mask |= mask << 1;
+    for (uint32_t i{0}; i < pow(2, children.size()); ++i) {
+      if (kitty::get_bit(function, i) == is_sop) {
+        auto cb = kitty::cube(i, mask);
+        new_cover.first.push_back(cb);
+      }
+    }
+
+    return _create_cover_node(children, new_cover);
+  }
+
+  signal clone_node(cover_network const &other, node const &source,
+                    std::vector<signal> const &children) {
+    assert(!children.empty());
+    cover_type cb =
+        other._storage->data.covers[other._storage->nodes[source].data[1].h1];
+    return create_cover_node(children, cb);
+  }
+#pragma endregion
+
+#pragma region Restructuring
+  void substitute_node(node const &old_node, signal const &new_signal) {
+    /* find all parents from old_node */
+    for (auto i = 0u; i < _storage->nodes.size(); ++i) {
+      auto &n = _storage->nodes[i];
+      for (auto &child : n.children) {
+        if (child == old_node) {
+          std::vector<signal> old_children(n.children.size());
+          std::transform(n.children.begin(), n.children.end(),
+                         old_children.begin(), [](auto c) { return c.index; });
+          child = new_signal;
+
+          // increment fan-out of new node
+          _storage->nodes[new_signal].data[0].h1++;
+
+          for (auto const &fn : _events->on_modified) {
+            (*fn)(i, old_children);
+          }
+        }
+      }
+    }
+
+    /* check outputs */
+    for (auto &output : _storage->outputs) {
+      if (output == old_node) {
+        output = new_signal;
+
+        // increment fan-out of new node
+        _storage->nodes[new_signal].data[0].h1++;
+      }
+    }
+
+    // reset fan-out of old node
+    _storage->nodes[old_node].data[0].h1 = 0;
+  }
+
+  inline bool is_dead(node const &n) const { return false; }
+#pragma endregion
+
+#pragma region Structural properties
+  auto size() const { return static_cast<uint32_t>(_storage->nodes.size()); }
+
+  auto num_cis() const {
+    return static_cast<uint32_t>(_storage->inputs.size());
+  }
+
+  auto num_cos() const {
+    return static_cast<uint32_t>(_storage->outputs.size());
+  }
+
+  auto num_pis() const {
+    return static_cast<uint32_t>(_storage->inputs.size());
+  }
+
+  auto num_pos() const {
+    return static_cast<uint32_t>(_storage->outputs.size());
+  }
+
+  auto num_gates() const {
+    return static_cast<uint32_t>(_storage->nodes.size() -
+                                 _storage->inputs.size() - 2);
+  }
+
+  uint32_t fanin_size(node const &n) const {
+    return static_cast<uint32_t>(_storage->nodes[n].children.size());
+  }
+
+  uint32_t fanout_size(node const &n) const {
+    return _storage->nodes[n].data[0].h1;
+  }
+
+  bool is_function(node const &n) const { return n > 1 && !is_ci(n); }
+#pragma endregion
+
+#pragma region Functional properties
+  cover_type node_cover(const node &n) const {
+    return _storage->data.covers[_storage->nodes[n].data[1].h1];
+  }
+#pragma endregion
+
+#pragma region Nodes and signals
+  node get_node(signal const &f) const { return f; }
+
+  signal make_signal(node const &n) const { return n; }
+
+  bool is_complemented(signal const &f) const {
+    (void)f;
+    return false;
+  }
+
+  uint32_t node_to_index(node const &n) const {
+    return static_cast<uint32_t>(n);
+  }
+
+  node index_to_node(uint32_t index) const { return index; }
+
+  node ci_at(uint32_t index) const {
+    assert(index < _storage->inputs.size());
+    return *(_storage->inputs.begin() + index);
+  }
+
+  signal co_at(uint32_t index) const {
+    assert(index < _storage->outputs.size());
+    return (_storage->outputs.begin() + index)->index;
+  }
+
+  node pi_at(uint32_t index) const {
+    assert(index < _storage->inputs.size());
+    return *(_storage->inputs.begin() + index);
+  }
+
+  signal po_at(uint32_t index) const {
+    assert(index < _storage->outputs.size());
+    return (_storage->outputs.begin() + index)->index;
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  template <typename Fn> void foreach_node(Fn &&fn) const {
+    auto r = range<uint64_t>(_storage->nodes.size());
+    detail::foreach_element(r.begin(), r.end(), fn);
+  }
+
+  template <typename Fn> void foreach_ci(Fn &&fn) const {
+    detail::foreach_element(_storage->inputs.begin(), _storage->inputs.end(),
+                            fn);
+  }
+
+  template <typename Fn> void foreach_co(Fn &&fn) const {
+    using IteratorType = decltype(_storage->outputs.begin());
+    detail::foreach_element_transform<IteratorType, uint32_t>(
+        _storage->outputs.begin(), _storage->outputs.end(),
+        [](auto o) { return o.index; }, fn);
+  }
+
+  template <typename Fn> void foreach_pi(Fn &&fn) const {
+    detail::foreach_element(_storage->inputs.begin(), _storage->inputs.end(),
+                            fn);
+  }
+
+  template <typename Fn> void foreach_po(Fn &&fn) const {
+    using IteratorType = decltype(_storage->outputs.begin());
+    detail::foreach_element_transform<IteratorType, uint32_t>(
+        _storage->outputs.begin(), _storage->outputs.end(),
+        [](auto o) { return o.index; }, fn);
+  }
+
+  template <typename Fn> void foreach_gate(Fn &&fn) const {
+    auto r = range<uint64_t>(
+        2u, _storage->nodes.size()); /* start from 2 to avoid constants */
+    detail::foreach_element_if(
+        r.begin(), r.end(), [this](auto n) { return !is_ci(n); }, fn);
+  }
+
+  template <typename Fn> void foreach_fanin(node const &n, Fn &&fn) const {
+    if (n == 0 || is_ci(n))
+      return;
+
+    using IteratorType = decltype(_storage->outputs.begin());
+    detail::foreach_element_transform<IteratorType, uint32_t>(
+        _storage->nodes[n].children.begin(), _storage->nodes[n].children.end(),
+        [](auto f) { return f.index; }, fn);
+  }
+
+#pragma endregion
+
+#pragma region Simulate values
+  template <typename Iterator>
+  iterates_over_t<Iterator, bool> compute(node const &n, Iterator begin,
+                                          Iterator end) const {
+    uint32_t index{0};
+    uint32_t mask{0};
+    while (begin != end) {
+      mask = (mask << 1) | 1u;
+      index <<= 1;
+      index ^= *begin++ ? 1 : 0;
+    }
+    auto cb_input = kitty::cube(index, mask);
+    cover_type &cubes_cover =
+        _storage->data.covers[_storage->nodes[n].data[1].h1];
+    for (auto cb : cubes_cover.first) {
+      if ((cb._bits & cb._mask) == (cb_input._bits & cb._mask))
+        return (cubes_cover.second == 1);
+    }
+
+    return (cubes_cover.second == 0);
+  }
+
+  template <typename Iterator>
+  iterates_over_truth_table_t<Iterator> compute(node const &n, Iterator begin,
+                                                Iterator end) const {
+    const auto nfanin = _storage->nodes[n].children.size();
+
+    std::vector<typename Iterator::value_type> tts(begin, end);
+
+    assert(nfanin != 0);
+    assert(tts.size() == nfanin);
+
+    /* resulting truth table has the same size as any of the children */
+    auto result = tts.front().construct();
+    cover_type &cubes_cover =
+        _storage->data.covers[_storage->nodes[n].data[1].h1];
+    bool is_found = false;
+    for (uint32_t i = 0u; i < static_cast<uint32_t>(result.num_bits()); ++i) {
+      is_found = false;
+      uint32_t pattern = 0u;
+      uint32_t mask = 0u;
+      for (auto j = 0u; j < nfanin; ++j) {
+        pattern |= kitty::get_bit(tts[j], i) << j;
+        mask |= 1u << j;
+      }
+      auto cb_input = kitty::cube(pattern, mask);
+      for (auto cb : cubes_cover.first) {
+        if ((cb._bits & cb._mask) == (cb_input._bits & cb._mask)) {
+          is_found = true;
+          if (cubes_cover.second == 1) {
+            kitty::set_bit(result, i);
+          }
+          break;
+        }
+      }
+      if (!is_found && (cubes_cover.second == 0))
+        kitty::set_bit(result, i);
+    }
+
+    return result;
+  }
+
+#pragma endregion
+
+#pragma region Custom node values
+  void clear_values() const {
+    std::for_each(_storage->nodes.begin(), _storage->nodes.end(),
+                  [](auto &n) { n.data[0].h2 = 0; });
+  }
+
+  uint32_t value(node const &n) const { return _storage->nodes[n].data[0].h2; }
+
+  void set_value(node const &n, uint32_t v) const {
+    _storage->nodes[n].data[0].h2 = v;
+  }
+
+  uint32_t incr_value(node const &n) const {
+    return static_cast<uint32_t>(_storage->nodes[n].data[0].h2++);
+  }
+
+  uint32_t decr_value(node const &n) const {
+    return static_cast<uint32_t>(--_storage->nodes[n].data[0].h2);
+  }
+#pragma endregion
+
+#pragma region Visited flags
+  void clear_visited() const {
+    std::for_each(_storage->nodes.begin(), _storage->nodes.end(),
+                  [](auto &n) { n.data[1].h2 = 0; });
+  }
+
+  auto visited(node const &n) const { return _storage->nodes[n].data[1].h2; }
+
+  void set_visited(node const &n, uint32_t v) const {
+    _storage->nodes[n].data[1].h2 = v;
+  }
+
+  uint32_t trav_id() const { return _storage->trav_id; }
+
+  void incr_trav_id() const { ++_storage->trav_id; }
+#pragma endregion
+
+#pragma region General methods
+  auto &events() const { return *_events; }
+#pragma endregion
+
+  std::vector<std::string> signal_map;
+
+  void set_name(uint32_t signal, std::string name) {
+    signal_map.emplace_back(name);
+  }
+
+  void set_output_name(uint32_t signal, std::string name) {
+    signal_map.emplace_back(name);
+  }
+
+  std::string module_name;
+
+  void set_network_name(std::string name){
+    module_name = name;
+  }
+
+public:
+  std::string get_module_name(){
+    return module_name;
+  }
+
+  std::string get_signal_name(uint32_t signal) const {
+    // - 2 because 0 and 1 is reserved for terminal nodes
+    if (signal - 2 >= signal_map.size()) {
+      std::cerr << "[ERROR] signal index is out of bounds\n";
+    }
+    return signal_map[signal - 2];
+  }
+
+  std::shared_ptr<cover_storage> _storage;
+  std::shared_ptr<network_events<base_type>> _events;
+};
+
+} // namespace mockturtle
diff --git a/include/mockturtle/networks/crossed.hpp b/include/mockturtle/networks/crossed.hpp
new file mode 100644
index 0000000..0e50305
--- /dev/null
+++ b/include/mockturtle/networks/crossed.hpp
@@ -0,0 +1,867 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file crossed.hpp
+  \brief Implements networks with crossing cells
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+#include "klut.hpp"
+
+namespace mockturtle
+{
+
+/* Version 1: annotate information of crossing fanout ordereing with different signals
+ * Share the same `klut_storage_data` as regular k-LUT network,
+ * but define a different `crossed_klut_storage_node` with a weight field in the pointer.
+ */
+
+/*! \brief k-LUT node
+ *
+ * `data[0].h1`: Fan-out size
+ * `data[0].h2`: Application-specific value
+ * `data[1].h1`: Function literal in truth table cache
+ * `data[1].h2`: Visited flags
+ */
+struct crossed_klut_storage_node : mixed_fanin_node<2, 1>
+{
+  bool operator==( crossed_klut_storage_node const& other ) const
+  {
+    return data[1].h1 == other.data[1].h1 && children == other.children;
+  }
+};
+using crossed_klut_storage = storage<crossed_klut_storage_node, klut_storage_data>;
+
+class crossed_klut_network
+{
+public:
+#pragma region Types and constructors
+  static constexpr auto min_fanin_size = 1;
+  static constexpr auto max_fanin_size = 32;
+
+  static constexpr bool is_crossed_network_type = true;
+
+  using base_type = crossed_klut_network;
+  using storage = std::shared_ptr<crossed_klut_storage>;
+  using node = uint64_t;
+  using signal = crossed_klut_storage_node::pointer_type;
+
+  crossed_klut_network()
+      : _storage( std::make_shared<crossed_klut_storage>() ),
+        _events( std::make_shared<decltype( _events )::element_type>() )
+  {
+    _init();
+  }
+
+  crossed_klut_network( std::shared_ptr<crossed_klut_storage> storage )
+      : _storage( storage ),
+        _events( std::make_shared<decltype( _events )::element_type>() )
+  {
+    _init();
+  }
+#pragma endregion
+
+protected:
+  static constexpr uint32_t literal_crossing = 0xffffffff;
+
+  inline void _init()
+  {
+    /* reserve the second node for constant 1 */
+    _storage->nodes.emplace_back();
+
+    /* reserve some truth tables for nodes */
+    kitty::dynamic_truth_table tt_zero( 0 );
+    _storage->data.cache.insert( tt_zero );
+
+    static uint64_t _not = 0x1;
+    kitty::dynamic_truth_table tt_not( 1 );
+    kitty::create_from_words( tt_not, &_not, &_not + 1 );
+    _storage->data.cache.insert( tt_not );
+
+    static uint64_t _and = 0x8;
+    kitty::dynamic_truth_table tt_and( 2 );
+    kitty::create_from_words( tt_and, &_and, &_and + 1 );
+    _storage->data.cache.insert( tt_and );
+
+    static uint64_t _or = 0xe;
+    kitty::dynamic_truth_table tt_or( 2 );
+    kitty::create_from_words( tt_or, &_or, &_or + 1 );
+    _storage->data.cache.insert( tt_or );
+
+    static uint64_t _lt = 0x4;
+    kitty::dynamic_truth_table tt_lt( 2 );
+    kitty::create_from_words( tt_lt, &_lt, &_lt + 1 );
+    _storage->data.cache.insert( tt_lt );
+
+    static uint64_t _le = 0xd;
+    kitty::dynamic_truth_table tt_le( 2 );
+    kitty::create_from_words( tt_le, &_le, &_le + 1 );
+    _storage->data.cache.insert( tt_le );
+
+    static uint64_t _xor = 0x6;
+    kitty::dynamic_truth_table tt_xor( 2 );
+    kitty::create_from_words( tt_xor, &_xor, &_xor + 1 );
+    _storage->data.cache.insert( tt_xor );
+
+    static uint64_t _maj = 0xe8;
+    kitty::dynamic_truth_table tt_maj( 3 );
+    kitty::create_from_words( tt_maj, &_maj, &_maj + 1 );
+    _storage->data.cache.insert( tt_maj );
+
+    static uint64_t _ite = 0xd8;
+    kitty::dynamic_truth_table tt_ite( 3 );
+    kitty::create_from_words( tt_ite, &_ite, &_ite + 1 );
+    _storage->data.cache.insert( tt_ite );
+
+    static uint64_t _xor3 = 0x96;
+    kitty::dynamic_truth_table tt_xor3( 3 );
+    kitty::create_from_words( tt_xor3, &_xor3, &_xor3 + 1 );
+    _storage->data.cache.insert( tt_xor3 );
+
+    /* truth tables for constants */
+    _storage->nodes[0].data[1].h1 = 0;
+    _storage->nodes[1].data[1].h1 = 1;
+  }
+
+public:
+#pragma region Primary I / O and constants
+  signal get_constant( bool value = false ) const
+  {
+    return value ? signal( 1, 0 ) : signal( 0, 0 );
+  }
+
+  signal create_pi()
+  {
+    const auto index = _storage->nodes.size();
+    _storage->nodes.emplace_back();
+    _storage->inputs.emplace_back( index );
+    _storage->nodes[index].data[1].h1 = 2;
+    return signal( index, 0 );
+  }
+
+  uint32_t create_po( signal const& f )
+  {
+    /* increase ref-count to children */
+    _storage->nodes[f.index].data[0].h1++;
+    auto const po_index = static_cast<uint32_t>( _storage->outputs.size() );
+    _storage->outputs.emplace_back( f );
+    return po_index;
+  }
+
+  bool is_combinational() const
+  {
+    return true;
+  }
+
+  bool is_constant( node const& n ) const
+  {
+    return n <= 1;
+  }
+
+  bool is_ci( node const& n ) const
+  {
+    return std::find( _storage->inputs.begin(), _storage->inputs.end(), n ) != _storage->inputs.end();
+  }
+
+  bool is_pi( node const& n ) const
+  {
+    return std::find( _storage->inputs.begin(), _storage->inputs.end(), n ) != _storage->inputs.end();
+  }
+
+  bool constant_value( node const& n ) const
+  {
+    return n == 1;
+  }
+#pragma endregion
+
+#pragma region Create unary functions
+  signal create_buf( signal const& a )
+  {
+    return a;
+  }
+
+  signal create_not( signal const& a )
+  {
+    return _create_node( { a }, 3 );
+  }
+#pragma endregion
+
+#pragma region Create binary functions
+  signal create_and( signal a, signal b )
+  {
+    return _create_node( { a, b }, 4 );
+  }
+
+  signal create_nand( signal a, signal b )
+  {
+    return _create_node( { a, b }, 5 );
+  }
+
+  signal create_or( signal a, signal b )
+  {
+    return _create_node( { a, b }, 6 );
+  }
+
+  signal create_nor( signal a, signal b )
+  {
+    return _create_node( { a, b }, 7 );
+  }
+
+  signal create_lt( signal a, signal b )
+  {
+    return _create_node( { a, b }, 8 );
+  }
+
+  signal create_ge( signal a, signal b )
+  {
+    return _create_node( { a, b }, 9 );
+  }
+
+  signal create_gt( signal a, signal b )
+  {
+    return _create_node( { a, b }, 10 );
+  }
+
+  signal create_le( signal a, signal b )
+  {
+    return _create_node( { a, b }, 11 );
+  }
+
+  signal create_xor( signal a, signal b )
+  {
+    return _create_node( { a, b }, 12 );
+  }
+
+  signal create_xnor( signal a, signal b )
+  {
+    return _create_node( { a, b }, 13 );
+  }
+#pragma endregion
+
+#pragma region Create ternary functions
+  signal create_maj( signal a, signal b, signal c )
+  {
+    return _create_node( { a, b, c }, 14 );
+  }
+
+  signal create_ite( signal a, signal b, signal c )
+  {
+    return _create_node( { a, b, c }, 16 );
+  }
+
+  signal create_xor3( signal a, signal b, signal c )
+  {
+    return _create_node( { a, b, c }, 18 );
+  }
+#pragma endregion
+
+#pragma region Create nary functions
+  signal create_nary_and( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( true ), [this]( auto const& a, auto const& b ) { return create_and( a, b ); } );
+  }
+
+  signal create_nary_or( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_or( a, b ); } );
+  }
+
+  signal create_nary_xor( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_xor( a, b ); } );
+  }
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  signal _create_node( std::vector<signal> const& children, uint32_t literal )
+  {
+    storage::element_type::node_type node;
+    std::copy( children.begin(), children.end(), std::back_inserter( node.children ) );
+    node.data[1].h1 = literal;
+
+    const auto it = _storage->hash.find( node );
+    if ( it != _storage->hash.end() )
+    {
+      return it->second;
+    }
+
+    const auto index = _storage->nodes.size();
+    _storage->nodes.push_back( node );
+    _storage->hash[node] = index;
+
+    /* increase ref-count to children */
+    for ( auto c : children )
+    {
+      _storage->nodes[c.index].data[0].h1++;
+    }
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return signal( index, 0 );
+  }
+
+  signal create_node( std::vector<signal> const& children, kitty::dynamic_truth_table const& function )
+  {
+    if ( children.size() == 0u )
+    {
+      assert( function.num_vars() == 0u );
+      return get_constant( !kitty::is_const0( function ) );
+    }
+    return _create_node( children, _storage->data.cache.insert( function ) );
+  }
+
+  signal clone_node( crossed_klut_network const& other, node const& source, std::vector<signal> const& children )
+  {
+    assert( !other.is_crossing( source ) );
+    assert( !children.empty() );
+    const auto tt = other._storage->data.cache[other._storage->nodes[source].data[1].h1];
+    return create_node( children, tt );
+  }
+
+  signal clone_node( klut_network const& other, node const& source, std::vector<signal> const& children )
+  {
+    assert( !children.empty() );
+    const auto tt = other._storage->data.cache[other._storage->nodes[source].data[1].h1];
+    return create_node( children, tt );
+  }
+#pragma endregion
+
+#pragma region Crossings
+  /*! \brief Create a crossing cell
+   *
+   * \return A pair `(out1, out2)` of two signals to be used as fanouts of the crossing,
+   * where `in1` connects to `out1` and `in2` connects to `out2`.
+   */
+  std::pair<signal, signal> create_crossing( signal const& in1, signal const& in2 )
+  {
+    storage::element_type::node_type node;
+    node.children.emplace_back( in1 );
+    node.children.emplace_back( in2 );
+    node.data[1].h1 = literal_crossing;
+
+    const auto index = _storage->nodes.size();
+    _storage->nodes.push_back( node );
+
+    /* increase ref-count to children */
+    _storage->nodes[in1.index].data[0].h1++;
+    _storage->nodes[in2.index].data[0].h1++;
+
+    /* TODO: not sure if this is wanted/needed? */
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return std::make_pair( signal( index, 0 ), signal( index, 1 ) );
+  }
+
+  /*! \brief Insert a crossing cell on two wires
+   *
+   * After this operation, the network will not be in a topological order.
+   *
+   * \param in1 A fanin signal of the node `out1`
+   * \param in2 A fanin signal of the node `out2`
+   * \return The created crossing cell. No more fanouts should be added to it.
+   */
+  node insert_crossing( signal const& in1, signal const& in2, node const& out1, node const& out2 )
+  {
+    uint32_t fanin_index1 = std::numeric_limits<uint32_t>::max();
+    foreach_fanin( out1, [&]( auto const& f, auto i ) {
+      if ( f == in1 )
+      {
+        fanin_index1 = i;
+        return false;
+      }
+      return true;
+    } );
+    assert( fanin_index1 != std::numeric_limits<uint32_t>::max() );
+
+    uint32_t fanin_index2 = std::numeric_limits<uint32_t>::max();
+    foreach_fanin( out2, [&]( auto const& f, auto i ) {
+      if ( f == in2 )
+      {
+        fanin_index2 = i;
+        return false;
+      }
+      return true;
+    } );
+    assert( fanin_index2 != std::numeric_limits<uint32_t>::max() );
+
+    auto [fout1, fout2] = create_crossing( in1, in2 );
+    _storage->nodes[out1].children[fanin_index1] = fout1;
+    _storage->nodes[out2].children[fanin_index2] = fout2;
+
+    /* decrease ref-count to children (was increased in `create_crossing`) */
+    _storage->nodes[in1.index].data[0].h1--;
+    _storage->nodes[in2.index].data[0].h1--;
+
+    return get_node( fout1 );
+  }
+
+  /*! \brief Whether a node is a crossing cell
+   *
+   * \param n The node to be checked
+   * \return Whether this node is a crossing cell
+   */
+  bool is_crossing( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h1 == literal_crossing;
+  }
+
+  /*! \brief Whether a crossing's fanout signal is the second one
+   *
+   * \param f A signal pointing to a crossing cell
+   * \return Whether this fanout connects to the second fanin (return 1) or the first fanin (return 0)
+   */
+  bool is_second( signal const& f ) const
+  {
+    assert( is_crossing( f.index ) );
+    return f.weight;
+  }
+
+  /*! \brief Take a crossing's first fanout signal and make it the second
+   *
+   * \param f A signal pointing to a crossing cell, referring to the fanout connecting to the first fanin
+   * \return The signal referring to the fanout connecting to the second fanin
+   */
+  signal make_second( signal const& f ) const
+  {
+    assert( is_crossing( f.index ) );
+    assert( !is_second( f ) );
+    return signal( f.index, 1 );
+  }
+
+  /*! \brief Get the real fanin signal ignoring all crossings in between
+   *
+   * \param f A signal pointing to a crossing
+   * \return The corresponding signal pointing to a non-crossing node
+   */
+  signal ignore_crossings( signal const& f ) const
+  {
+    if ( !is_crossing( get_node( f ) ) )
+      return f;
+    return ignore_crossings( _storage->nodes[f.index].children[f.weight] );
+  }
+
+  /*! \brief Iterate through the real fanins of a node, ignoring all crossings in between */
+  template<typename Fn>
+  void foreach_fanin_ignore_crossings( node const& n, Fn&& fn ) const
+  {
+    if ( n == 0 || is_ci( n ) )
+      return;
+
+    using IteratorType = decltype( _storage->nodes[n].children.begin() );
+    detail::foreach_element_transform<IteratorType, signal>(
+        _storage->nodes[n].children.begin(), _storage->nodes[n].children.end(), [this]( auto f ) { return ignore_crossings( f ); }, fn );
+  }
+#pragma endregion
+
+#pragma region Structural properties
+  auto size() const
+  {
+    return static_cast<uint32_t>( _storage->nodes.size() );
+  }
+
+  auto num_cis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_cos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  auto num_pis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_pos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  auto num_gates() const
+  {
+    return static_cast<uint32_t>( _storage->nodes.size() - _storage->inputs.size() - 2 );
+  }
+
+  uint32_t fanin_size( node const& n ) const
+  {
+    return static_cast<uint32_t>( _storage->nodes[n].children.size() );
+  }
+
+  uint32_t fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1;
+  }
+
+  bool is_function( node const& n ) const
+  {
+    return n > 1 && !is_ci( n ) && !is_crossing( n );
+  }
+#pragma endregion
+
+#pragma region Functional properties
+  kitty::dynamic_truth_table node_function( const node& n ) const
+  {
+    assert( !is_crossing( n ) );
+    return _storage->data.cache[_storage->nodes[n].data[1].h1];
+  }
+
+  bool is_not( node const& n ) const
+  {
+    if ( !is_function( n ) )
+      return false;
+    return _storage->nodes[n].children.size() == 1 && _storage->nodes[n].data[1].h1 == 3;
+  }
+
+  /* AND-2 with any input negation, but not output negation */
+  bool is_and( node const& n ) const
+  {
+    if ( !is_function( n ) )
+      return false;
+    auto const& node = _storage->nodes[n];
+    if ( node.children.size() != 2 )
+      return false;
+    return node.data[1].h1 == 4 || node.data[1].h1 == 8 || node.data[1].h1 == 10 || node.data[1].h1 == 7;
+  }
+
+  /* OR-2 with any input negation, but not output negation */
+  bool is_or( node const& n ) const
+  {
+    if ( !is_function( n ) )
+      return false;
+    auto const& node = _storage->nodes[n];
+    if ( node.children.size() != 2 )
+      return false;
+    return node.data[1].h1 == 5 || node.data[1].h1 == 9 || node.data[1].h1 == 11 || node.data[1].h1 == 6;
+  }
+
+  /* XOR-2 or XNOR-2 */
+  bool is_xor( node const& n ) const
+  {
+    if ( !is_function( n ) )
+      return false;
+    auto const& node = _storage->nodes[n];
+    if ( node.children.size() != 2 )
+      return false;
+    return node.data[1].h1 == 12 || node.data[1].h1 == 13;
+  }
+
+  /* XOR-3 or XNOR-3 */
+  bool is_xor3( node const& n ) const
+  {
+    if ( !is_function( n ) )
+      return false;
+    auto const& node = _storage->nodes[n];
+    if ( node.children.size() != 3 )
+      return false;
+    return node.data[1].h1 == 18 || node.data[1].h1 == 19;
+  }
+
+  /* MAJ-3 or MINORITY-3 without non-symmetric input negation */
+  bool is_maj( node const& n ) const
+  {
+    if ( !is_function( n ) )
+      return false;
+    auto const& node = _storage->nodes[n];
+    if ( node.children.size() != 3 )
+      return false;
+    return node.data[1].h1 == 14 || node.data[1].h1 == 15;
+  }
+
+  /* ITE (MUX2-1) without input negation; with or without output negation
+   * i.e., (x ? y :z) or !(x ? y : z) = x ? !y : !z */
+  bool is_ite( node const& n ) const
+  {
+    if ( !is_function( n ) )
+      return false;
+    auto const& node = _storage->nodes[n];
+    if ( node.children.size() != 3 )
+      return false;
+    return node.data[1].h1 == 16 || node.data[1].h1 == 17;
+  }
+
+  std::vector<bool> get_fanin_negations( node const& n ) const
+  {
+    if ( is_crossing( n ) )
+      return {false, false};
+    if ( !is_function( n ) )
+      return {};
+    switch ( _storage->nodes[n].data[1].h1 )
+    {
+      case 2: return {false}; // buf
+      case 3: return {true}; // not
+      case 4: return {false, false}; // and
+      case 5: return {true, true}; // x nand y = !x or !y
+      case 6: return {false, false}; // or
+      case 7: return {true, true}; // x nor y = !x and !y
+      case 8: return {true, false}; // !x and y
+      case 9: return {false, true}; // x or !y
+      case 10: return {false, true}; // x and !y
+      case 11: return {true, false}; // !x or y
+      case 12: return {false, false}; // xor
+      case 13: return {true, false}; // xnor (symmetric)
+      case 14: return {false, false, false}; // maj
+      case 15: return {true, true, true}; // minority
+      case 16: return {false, false, false}; // ite
+      case 17: return {false, true, true}; // !(x ? y : z) = x ? !y : !z
+      case 18: return {false, false, false}; // xor3
+      case 19: return {true, false, false}; // xnor3 (symmetric)
+    }
+    return {};
+  }
+#pragma endregion
+
+#pragma region Nodes and signals
+  node get_node( signal const& f ) const
+  {
+    return f.index;
+  }
+
+  signal make_signal( node const& n ) const
+  {
+    return signal( n, 0 );
+  }
+
+  bool is_complemented( signal const& f ) const
+  {
+    (void)f;
+    return false;
+  }
+
+  uint32_t node_to_index( node const& n ) const
+  {
+    return static_cast<uint32_t>( n );
+  }
+
+  node index_to_node( uint32_t index ) const
+  {
+    return index;
+  }
+
+  node ci_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal co_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return ( _storage->outputs.begin() + index )->index;
+  }
+
+  node pi_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal po_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return ( _storage->outputs.begin() + index )->index;
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( _storage->nodes.size() );
+    detail::foreach_element( r.begin(), r.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_ci( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_co( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->outputs.begin(), _storage->outputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->outputs.begin(), _storage->outputs.end(), fn );
+  }
+
+  /* Note: crossings are included */
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( 2u, _storage->nodes.size() ); /* start from 2 to avoid constants */
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_ci( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_fanin( node const& n, Fn&& fn ) const
+  {
+    if ( n == 0 || is_ci( n ) )
+      return;
+
+    detail::foreach_element( _storage->nodes[n].children.begin(), _storage->nodes[n].children.end(), fn );
+  }
+#pragma endregion
+
+#pragma region Simulate values
+  template<typename Iterator>
+  iterates_over_t<Iterator, bool>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    assert( !is_crossing( n ) );
+    uint32_t index{ 0 };
+    while ( begin != end )
+    {
+      index <<= 1;
+      index ^= *begin++ ? 1 : 0;
+    }
+    return kitty::get_bit( _storage->data.cache[_storage->nodes[n].data[1].h1], index );
+  }
+
+  template<typename Iterator>
+  iterates_over_truth_table_t<Iterator>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    assert( !is_crossing( n ) );
+    const auto nfanin = _storage->nodes[n].children.size();
+
+    std::vector<typename Iterator::value_type> tts( begin, end );
+
+    assert( nfanin != 0 );
+    assert( tts.size() == nfanin );
+
+    /* resulting truth table has the same size as any of the children */
+    auto result = tts.front().construct();
+    const auto gate_tt = _storage->data.cache[_storage->nodes[n].data[1].h1];
+
+    for ( uint32_t i = 0u; i < static_cast<uint32_t>( result.num_bits() ); ++i )
+    {
+      uint32_t pattern = 0u;
+      for ( auto j = 0u; j < nfanin; ++j )
+      {
+        pattern |= kitty::get_bit( tts[j], i ) << j;
+      }
+      if ( kitty::get_bit( gate_tt, pattern ) )
+      {
+        kitty::set_bit( result, i );
+      }
+    }
+
+    return result;
+  }
+#pragma endregion
+
+#pragma region Custom node values
+  void clear_values() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[0].h2 = 0; } );
+  }
+
+  uint32_t value( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h2;
+  }
+
+  void set_value( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[0].h2 = v;
+  }
+
+  uint32_t incr_value( node const& n ) const
+  {
+    return static_cast<uint32_t>( _storage->nodes[n].data[0].h2++ );
+  }
+
+  uint32_t decr_value( node const& n ) const
+  {
+    return static_cast<uint32_t>( --_storage->nodes[n].data[0].h2 );
+  }
+#pragma endregion
+
+#pragma region Visited flags
+  void clear_visited() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[1].h2 = 0; } );
+  }
+
+  auto visited( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h2;
+  }
+
+  void set_visited( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[1].h2 = v;
+  }
+
+  uint32_t trav_id() const
+  {
+    return _storage->trav_id;
+  }
+
+  void incr_trav_id() const
+  {
+    ++_storage->trav_id;
+  }
+#pragma endregion
+
+#pragma region General methods
+  auto& events() const
+  {
+    return *_events;
+  }
+#pragma endregion
+
+public:
+  std::shared_ptr<crossed_klut_storage> _storage;
+  std::shared_ptr<network_events<base_type>> _events;
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/networks/detail/foreach.hpp b/include/mockturtle/networks/detail/foreach.hpp
new file mode 100644
index 0000000..7aadd5b
--- /dev/null
+++ b/include/mockturtle/networks/detail/foreach.hpp
@@ -0,0 +1,224 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file foreach.hpp
+  \brief For each functor utilities
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <type_traits>
+
+namespace mockturtle::detail
+{
+
+template<class Fn, class ElementType, class ReturnType>
+inline constexpr bool is_callable_with_index_v = std::is_invocable_r_v<ReturnType, Fn, ElementType, uint32_t>;
+
+template<class Fn, class ElementType, class ReturnType>
+inline constexpr bool is_callable_without_index_v = std::is_invocable_r_v<ReturnType, Fn, ElementType>;
+
+template<class Iterator, class ElementType = typename Iterator::value_type, class Fn>
+Iterator foreach_element( Iterator begin, Iterator end, Fn&& fn, uint32_t counter_offset = 0 )
+{
+  static_assert( is_callable_with_index_v<Fn, ElementType, void> ||
+                 is_callable_without_index_v<Fn, ElementType, void> ||
+                 is_callable_with_index_v<Fn, ElementType, bool> ||
+                 is_callable_without_index_v<Fn, ElementType, bool> );
+
+  if constexpr ( is_callable_without_index_v<Fn, ElementType, bool> )
+  {
+    (void)counter_offset;
+    while ( begin != end )
+    {
+      if ( !fn( *begin++ ) )
+      {
+        return begin;
+      }
+    }
+    return begin;
+  }
+  else if constexpr ( is_callable_with_index_v<Fn, ElementType, bool> )
+  {
+    uint32_t index{ counter_offset };
+    while ( begin != end )
+    {
+      if ( !fn( *begin++, index++ ) )
+      {
+        return begin;
+      }
+    }
+    return begin;
+  }
+  else if constexpr ( is_callable_without_index_v<Fn, ElementType, void> )
+  {
+    (void)counter_offset;
+    while ( begin != end )
+    {
+      fn( *begin++ );
+    }
+    return begin;
+  }
+  else if constexpr ( is_callable_with_index_v<Fn, ElementType, void> )
+  {
+    uint32_t index{ counter_offset };
+    while ( begin != end )
+    {
+      fn( *begin++, index++ );
+    }
+    return begin;
+  }
+}
+
+template<class Iterator, class ElementType = typename Iterator::value_type, class Pred, class Fn>
+Iterator foreach_element_if( Iterator begin, Iterator end, Pred&& pred, Fn&& fn, uint32_t counter_offset = 0 )
+{
+  static_assert( is_callable_with_index_v<Fn, ElementType, void> ||
+                 is_callable_without_index_v<Fn, ElementType, void> ||
+                 is_callable_with_index_v<Fn, ElementType, bool> ||
+                 is_callable_without_index_v<Fn, ElementType, bool> );
+
+  if constexpr ( is_callable_without_index_v<Fn, ElementType, bool> )
+  {
+    (void)counter_offset;
+    while ( begin != end )
+    {
+      if ( !pred( *begin ) )
+      {
+        ++begin;
+        continue;
+      }
+      if ( !fn( *begin++ ) )
+      {
+        return begin;
+      }
+    }
+    return begin;
+  }
+  else if constexpr ( is_callable_with_index_v<Fn, ElementType, bool> )
+  {
+    uint32_t index{ counter_offset };
+    while ( begin != end )
+    {
+      if ( !pred( *begin ) )
+      {
+        ++begin;
+        continue;
+      }
+      if ( !fn( *begin++, index++ ) )
+      {
+        return begin;
+      }
+    }
+    return begin;
+  }
+  else if constexpr ( is_callable_without_index_v<Fn, ElementType, void> )
+  {
+    (void)counter_offset;
+    while ( begin != end )
+    {
+      if ( !pred( *begin ) )
+      {
+        ++begin;
+        continue;
+      }
+      fn( *begin++ );
+    }
+    return begin;
+  }
+  else if constexpr ( is_callable_with_index_v<Fn, ElementType, void> )
+  {
+    uint32_t index{ counter_offset };
+    while ( begin != end )
+    {
+      if ( !pred( *begin ) )
+      {
+        ++begin;
+        continue;
+      }
+      fn( *begin++, index++ );
+    }
+    return begin;
+  }
+}
+
+template<class Iterator, class ElementType, class Transform, class Fn>
+Iterator foreach_element_transform( Iterator begin, Iterator end, Transform&& transform, Fn&& fn, uint32_t counter_offset = 0 )
+{
+  static_assert( is_callable_with_index_v<Fn, ElementType, void> ||
+                 is_callable_without_index_v<Fn, ElementType, void> ||
+                 is_callable_with_index_v<Fn, ElementType, bool> ||
+                 is_callable_without_index_v<Fn, ElementType, bool> );
+
+  if constexpr ( is_callable_without_index_v<Fn, ElementType, bool> )
+  {
+    (void)counter_offset;
+    while ( begin != end )
+    {
+      if ( !fn( transform( *begin++ ) ) )
+      {
+        return begin;
+      }
+    }
+    return begin;
+  }
+  else if constexpr ( is_callable_with_index_v<Fn, ElementType, bool> )
+  {
+    uint32_t index{ counter_offset };
+    while ( begin != end )
+    {
+      if ( !fn( transform( *begin++ ), index++ ) )
+      {
+        return begin;
+      }
+    }
+    return begin;
+  }
+  else if constexpr ( is_callable_without_index_v<Fn, ElementType, void> )
+  {
+    (void)counter_offset;
+    while ( begin != end )
+    {
+      fn( transform( *begin++ ) );
+    }
+    return begin;
+  }
+  else if constexpr ( is_callable_with_index_v<Fn, ElementType, void> )
+  {
+    uint32_t index{ counter_offset };
+    while ( begin != end )
+    {
+      fn( transform( *begin++ ), index++ );
+    }
+    return begin;
+  }
+}
+
+} // namespace mockturtle::detail
\ No newline at end of file
diff --git a/include/mockturtle/networks/events.hpp b/include/mockturtle/networks/events.hpp
new file mode 100644
index 0000000..6f508ec
--- /dev/null
+++ b/include/mockturtle/networks/events.hpp
@@ -0,0 +1,134 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file events.hpp
+  \brief Event API for updating a logic network.
+
+  \author Heinz Riener
+  \author Marcel Walter
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+
+#include <functional>
+#include <vector>
+#include <iostream>
+#include <memory>
+
+namespace mockturtle
+{
+
+/*! \brief Network events.
+ *
+ * This data structure can be returned by a network.  Clients can add functions
+ * to network events to call code whenever an event occurs.  Events are adding
+ * a node, modifying a node, and deleting a node.
+ */
+template<class Ntk>
+class network_events
+{
+public:
+  using add_event_type = std::function<void( node<Ntk> const& n )>;
+  using modified_event_type = std::function<void( node<Ntk> const& n, std::vector<signal<Ntk>> const& previous_children )>;
+  using delete_event_type = std::function<void( node<Ntk> const& n )>;
+
+public:
+  std::shared_ptr<add_event_type> register_add_event( add_event_type const& fn )
+  {
+    auto pfn = std::make_shared<add_event_type>( fn );
+    on_add.emplace_back( pfn );
+    return pfn;
+  }
+
+  std::shared_ptr<modified_event_type> register_modified_event( modified_event_type const& fn )
+  {
+    auto pfn = std::make_shared<modified_event_type>( fn );
+    on_modified.emplace_back( pfn );
+    return pfn;
+  }
+
+  std::shared_ptr<delete_event_type> register_delete_event( delete_event_type const& fn )
+  {
+    auto pfn = std::make_shared<delete_event_type>( fn );
+    on_delete.emplace_back( pfn );
+    return pfn;
+  }
+
+  void release_add_event( std::shared_ptr<add_event_type>& fn )
+  {
+    /* first decrement the reference counter of the event */
+    auto fn_ptr = fn.get();
+    fn = nullptr;
+
+    /* erase the event if the only instance remains in the vector */
+    on_add.erase( std::remove_if( std::begin( on_add ), std::end( on_add ),
+                                  [&]( auto&& event ) { return event.get() == fn_ptr && event.use_count() <= 1u; } ),
+                  std::end( on_add ) );
+  }
+
+  void release_modified_event( std::shared_ptr<modified_event_type>& fn )
+  {
+    /* first decrement the reference counter of the event */
+    auto fn_ptr = fn.get();
+    fn = nullptr;
+
+    /* erase the event if the only instance remains in the vector */
+    on_modified.erase( std::remove_if( std::begin( on_modified ), std::end( on_modified ),
+                                       [&]( auto&& event ) { return event.get() == fn_ptr && event.use_count() <= 1u; } ),
+                       std::end( on_modified ) );
+  }
+
+  void release_delete_event( std::shared_ptr<delete_event_type>& fn )
+  {
+    /* first decrement the reference counter of the event */
+    auto fn_ptr = fn.get();
+    fn = nullptr;
+
+    /* erase the event if the only instance remains in the vector */
+    on_delete.erase( std::remove_if( std::begin( on_delete ), std::end( on_delete ),
+                                     [&]( auto&& event ) { return event.get() == fn_ptr && event.use_count() <= 1u; } ),
+                     std::end( on_delete ) );
+  }
+
+public:
+  /*! \brief Event when node `n` is added. */
+  std::vector<std::shared_ptr<add_event_type>> on_add;
+
+  /*! \brief Event when `n` is modified.
+   *
+   * The event also informs about the previous children.  Note that the new
+   * children are already available at the time the event is triggered.
+   */
+  std::vector<std::shared_ptr<modified_event_type>> on_modified;
+
+  /*! \brief Event when `n` is deleted. */
+  std::vector<std::shared_ptr<delete_event_type>> on_delete;
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/networks/generic.hpp b/include/mockturtle/networks/generic.hpp
new file mode 100644
index 0000000..067db51
--- /dev/null
+++ b/include/mockturtle/networks/generic.hpp
@@ -0,0 +1,1065 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file generic.hpp
+  \brief Generic sequential logic network implementation without strashing
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+#include "../utils/algorithm.hpp"
+#include "../utils/truth_table_cache.hpp"
+#include "detail/foreach.hpp"
+#include "events.hpp"
+#include "sequential.hpp"
+#include "storage.hpp"
+
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+
+#include <algorithm>
+#include <memory>
+
+namespace mockturtle
+{
+
+struct generic_storage_data
+{
+  truth_table_cache<kitty::dynamic_truth_table> cache;
+  uint32_t num_pis = 0u;
+  uint32_t num_pos = 0u;
+  std::vector<int8_t> registers;
+  uint32_t trav_id = 0u;
+};
+
+/*! \brief Generic node
+ *
+ * `data[0].h1`: Fan-out size (we use MSB to indicate whether a node is dead)
+ * `data[0].h2`: Application-specific value
+ * `data[1].h1`: Function literal in truth table cache
+ * `data[1].h2`: Visited flags
+ * `data[2].h1`: Node type
+ * `data[2].h2`: Application-specific value
+ *
+ * Node types:
+ * - 0: unknown
+ * - 1: klut node
+ * - 2: PI terminal
+ * - 3: PO terminal
+ * - 4: Box input terminal
+ * - 5: Box output terminal
+ * - 6: Register
+ * - 7: Whitebox
+ * - 8: Blackbox
+ */
+struct generic_storage_node : mixed_fanin_node<3>
+{
+  bool operator==( generic_storage_node const& other ) const
+  {
+    return data[1].h1 == other.data[1].h1 && children == other.children;
+  }
+};
+
+/*! \brief Generic storage container
+
+  ...
+*/
+using generic_storage = storage_no_hash<generic_storage_node, generic_storage_data>;
+
+class generic_network
+{
+public:
+#pragma region Types and constructors
+  static constexpr auto min_fanin_size = 1;
+  static constexpr auto max_fanin_size = 32;
+
+  using base_type = generic_network;
+  using storage = std::shared_ptr<generic_storage>;
+  using node = uint64_t;
+  using signal = uint64_t;
+
+  generic_network()
+      : _storage( std::make_shared<generic_storage>() ),
+        _events( std::make_shared<decltype( _events )::element_type>() ),
+        _register_information( std::make_shared<std::unordered_map<uint64_t, register_t>>() )
+  {
+    _init();
+  }
+
+  generic_network( std::shared_ptr<generic_storage> storage )
+      : _storage( storage ),
+        _events( std::make_shared<decltype( _events )::element_type>() ),
+        _register_information( std::make_shared<std::unordered_map<uint64_t, register_t>>() )
+  {
+    _init();
+  }
+
+  generic_network( std::shared_ptr<generic_storage> storage, std::shared_ptr<std::unordered_map<uint64_t, register_t>> register_information )
+      : _storage( storage ),
+        _events( std::make_shared<decltype( _events )::element_type>() ),
+        _register_information( register_information )
+  {
+    _init();
+  }
+
+  generic_network clone() const
+  {
+    return { std::make_shared<generic_storage>( *_storage ), std::make_shared<std::unordered_map<uint64_t, register_t>>( *_register_information ) };
+  }
+
+protected:
+  inline void _init()
+  {
+    /* already initialized */
+    if ( _storage->nodes.size() > 1 ) 
+      return;
+
+    /* reserve the second node for constant 1 */
+    _storage->nodes.emplace_back();
+
+    /* reserve some truth tables for nodes */
+    kitty::dynamic_truth_table tt_zero( 0 );
+    _storage->data.cache.insert( tt_zero );
+
+    static uint64_t _buf = 0x2;
+    kitty::dynamic_truth_table tt_buf( 1 );
+    kitty::create_from_words( tt_buf, &_buf, &_buf + 1 );
+    _storage->data.cache.insert( tt_buf );
+
+    static uint64_t _and = 0x8;
+    kitty::dynamic_truth_table tt_and( 2 );
+    kitty::create_from_words( tt_and, &_and, &_and + 1 );
+    _storage->data.cache.insert( tt_and );
+
+    static uint64_t _or = 0xe;
+    kitty::dynamic_truth_table tt_or( 2 );
+    kitty::create_from_words( tt_or, &_or, &_or + 1 );
+    _storage->data.cache.insert( tt_or );
+
+    static uint64_t _lt = 0x4;
+    kitty::dynamic_truth_table tt_lt( 2 );
+    kitty::create_from_words( tt_lt, &_lt, &_lt + 1 );
+    _storage->data.cache.insert( tt_lt );
+
+    static uint64_t _le = 0xd;
+    kitty::dynamic_truth_table tt_le( 2 );
+    kitty::create_from_words( tt_le, &_le, &_le + 1 );
+    _storage->data.cache.insert( tt_le );
+
+    static uint64_t _xor = 0x6;
+    kitty::dynamic_truth_table tt_xor( 2 );
+    kitty::create_from_words( tt_xor, &_xor, &_xor + 1 );
+    _storage->data.cache.insert( tt_xor );
+
+    static uint64_t _maj = 0xe8;
+    kitty::dynamic_truth_table tt_maj( 3 );
+    kitty::create_from_words( tt_maj, &_maj, &_maj + 1 );
+    _storage->data.cache.insert( tt_maj );
+
+    static uint64_t _ite = 0xd8;
+    kitty::dynamic_truth_table tt_ite( 3 );
+    kitty::create_from_words( tt_ite, &_ite, &_ite + 1 );
+    _storage->data.cache.insert( tt_ite );
+
+    static uint64_t _xor3 = 0x96;
+    kitty::dynamic_truth_table tt_xor3( 3 );
+    kitty::create_from_words( tt_xor3, &_xor3, &_xor3 + 1 );
+    _storage->data.cache.insert( tt_xor3 );
+
+    /* truth tables for constants */
+    _storage->nodes[0].data[1].h1 = 0;
+    _storage->nodes[1].data[1].h1 = 1;
+  }
+#pragma endregion
+
+#pragma region Primary I / O and constants
+public:
+  signal get_constant( bool value = false ) const
+  {
+    return value ? 1 : 0;
+  }
+
+  signal create_pi( std::string const& name = std::string() )
+  {
+    (void)name;
+
+    const auto index = _storage->nodes.size();
+    _storage->nodes.emplace_back();
+    _storage->inputs.emplace_back( index );
+    _storage->nodes[index].data[1].h1 = 2;
+    _storage->nodes[index].data[2].h1 = 2;
+    ++_storage->data.num_pis;
+    return index;
+  }
+
+  uint32_t create_po( signal const& f, std::string const& name = std::string() )
+  {
+    (void)name;
+
+    /* check f is not a PO already */
+    if ( is_po( get_node( f ) ) )
+      return get_node( f );
+
+    const auto index = _storage->nodes.size();
+    const auto po = create_buf( f );
+    _storage->nodes[index].data[2].h1 = 3;
+    /* increase ref-count of PO */
+    _storage->nodes[po].data[0].h1++;
+
+    auto const po_index = static_cast<uint32_t>( _storage->outputs.size() );
+    _storage->outputs.emplace_back( po );
+    ++_storage->data.num_pos;
+    return po_index;
+  }
+
+  signal create_ro( std::string const& name = std::string() )
+  {
+    (void)name;
+
+    auto const index = static_cast<uint32_t>( _storage->nodes.size() );
+    _storage->nodes.emplace_back();
+    _storage->inputs.emplace_back( index );
+    _storage->nodes[index].data[1].h1 = 2;
+    _storage->nodes[index].data[2].h1 = 5;
+    return index;
+  }
+
+  uint32_t create_ri( signal const& f, int8_t reset = 0, std::string const& name = std::string() )
+  {
+    (void)name;
+
+    /* increase ref-count to children */
+    _storage->nodes[f].data[0].h1++;
+    auto const ri_index = static_cast<uint32_t>( _storage->outputs.size() );
+    _storage->outputs.emplace_back( f );
+    _storage->data.registers.emplace_back( reset );
+    return ri_index;
+  }
+
+  bool is_combinational() const
+  {
+    return ( static_cast<uint32_t>( _storage->inputs.size() ) == _storage->data.num_pis &&
+             static_cast<uint32_t>( _storage->outputs.size() ) == _storage->data.num_pos );
+  }
+
+  bool is_constant( node const& n ) const
+  {
+    return n <= 1;
+  }
+
+  bool is_ci( node const& n ) const
+  {
+    return _storage->nodes[n].data[2].h1 == 2 || _storage->nodes[n].data[2].h1 == 5;
+  }
+
+  bool is_co( node const& n ) const
+  {
+    return _storage->nodes[n].data[2].h1 == 3 || _storage->nodes[n].data[2].h1 == 4;
+  }
+
+  bool is_pi( node const& n ) const
+  {
+    return _storage->nodes[n].data[2].h1 == 2;
+  }
+
+  bool is_po( node const& n ) const
+  {
+    return _storage->nodes[n].data[2].h1 == 3;
+  }
+
+  bool is_ro( node const& n ) const
+  {
+    return std::find( _storage->inputs.begin() + _storage->data.num_pis, _storage->inputs.end(), n ) != _storage->inputs.end();
+  }
+
+  bool is_node( node const& n ) const
+  {
+    return _storage->nodes[n].data[2].h1 == 1;
+  }
+
+  bool is_register( node const& n ) const
+  {
+    return _storage->nodes[n].data[2].h1 == 6;
+  }
+
+  bool is_box_input( node const& n ) const
+  {
+    return _storage->nodes[n].data[2].h1 == 4;
+  }
+
+  bool is_box_output( node const& n ) const
+  {
+    return _storage->nodes[n].data[2].h1 == 5;
+  }
+
+  bool constant_value( node const& n ) const
+  {
+    return n == 1;
+  }
+#pragma endregion
+
+#pragma region Create unary functions
+  signal create_buf( signal const& a )
+  {
+    return _create_node( { a }, 2 );
+  }
+
+  signal create_not( signal const& a )
+  {
+    return _create_node( { a }, 3 );
+  }
+#pragma endregion
+
+#pragma region Create binary functions
+  signal create_and( signal a, signal b )
+  {
+    return _create_node( { a, b }, 4 );
+  }
+
+  signal create_nand( signal a, signal b )
+  {
+    return _create_node( { a, b }, 5 );
+  }
+
+  signal create_or( signal a, signal b )
+  {
+    return _create_node( { a, b }, 6 );
+  }
+
+  signal create_lt( signal a, signal b )
+  {
+    return _create_node( { a, b }, 8 );
+  }
+
+  signal create_le( signal a, signal b )
+  {
+    return _create_node( { a, b }, 11 );
+  }
+
+  signal create_xor( signal a, signal b )
+  {
+    return _create_node( { a, b }, 12 );
+  }
+#pragma endregion
+
+#pragma region Create ternary functions
+  signal create_maj( signal a, signal b, signal c )
+  {
+    return _create_node( { a, b, c }, 14 );
+  }
+
+  signal create_ite( signal a, signal b, signal c )
+  {
+    return _create_node( { a, b, c }, 16 );
+  }
+
+  signal create_xor3( signal a, signal b, signal c )
+  {
+    return _create_node( { a, b, c }, 18 );
+  }
+#pragma endregion
+
+#pragma region Create nary functions
+  signal create_nary_and( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( true ), [this]( auto const& a, auto const& b ) { return create_and( a, b ); } );
+  }
+
+  signal create_nary_or( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_or( a, b ); } );
+  }
+
+  signal create_nary_xor( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_xor( a, b ); } );
+  }
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  signal _create_node( std::vector<signal> const& children, uint32_t literal )
+  {
+    storage::element_type::node_type node;
+    std::copy( children.begin(), children.end(), std::back_inserter( node.children ) );
+    node.data[1].h1 = literal;
+    node.data[2].h1 = 1;
+
+    /* structural hashing is not used */
+    const auto index = _storage->nodes.size();
+    _storage->nodes.push_back( node );
+
+    /* increase ref-count to children */
+    for ( auto c : children )
+    {
+      _storage->nodes[c].data[0].h1++;
+    }
+
+    set_value( index, 0 );
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return index;
+  }
+
+  signal create_node( std::vector<signal> const& children, kitty::dynamic_truth_table const& function )
+  {
+    if ( children.size() == 0u )
+    {
+      assert( function.num_vars() == 0u );
+      return get_constant( !kitty::is_const0( function ) );
+    }
+    return _create_node( children, _storage->data.cache.insert( function ) );
+  }
+
+  signal clone_node( generic_network const& other, node const& source, std::vector<signal> const& children )
+  {
+    assert( !children.empty() );
+    const auto tt = other._storage->data.cache[other._storage->nodes[source].data[1].h1];
+    return create_node( children, tt );
+  }
+
+  signal create_box_input( signal a )
+  {
+    auto const ri = create_buf( a );
+    _storage->nodes[get_node( ri )].data[2].h1 = 4;
+    return ri;
+  }
+
+  signal create_box_output( signal a )
+  {
+    auto const ro = create_buf( a );
+    _storage->nodes[get_node( ro )].data[2].h1 = 5;
+    return ro;
+  }
+
+  signal create_register( signal a, register_t const& l_info = {} )
+  {
+    auto const r = create_buf( a );
+    _storage->nodes[get_node( r )].data[2].h1 = 6;
+    _register_information->insert( { get_node( r ), l_info } );
+
+    return r;
+  }
+#pragma endregion
+
+#pragma region Restructuring
+  std::optional<std::pair<node, signal>> replace_in_node( node const& n, node const& old_node, signal new_signal )
+  {
+    auto& root = _storage->nodes[n];
+    for ( auto& child : root.children )
+    {
+      if ( child == old_node )
+      {
+        std::vector<signal> old_children( root.children.size() );
+        std::transform( root.children.begin(), root.children.end(), old_children.begin(), []( auto c ) { return c.index; } );
+        child = new_signal;
+
+        // increment fan-out of new node
+        _storage->nodes[new_signal].data[0].h1++;
+
+        for ( auto const& fn : _events->on_modified )
+        {
+          ( *fn )( n, old_children );
+        }
+      }
+    }
+    return std::nullopt;
+  }
+
+  void replace_in_outputs( node const& old_node, signal const& new_signal )
+  {
+    for ( auto& output : _storage->outputs )
+    {
+      if ( output == old_node )
+      {
+        output = new_signal;
+
+        // increment fan-out of new node
+        _storage->nodes[new_signal].data[0].h1++;
+      }
+    }
+  }
+
+  void take_out_node( node const& n )
+  {
+    /* we cannot delete PIs, constants, or already dead nodes */
+    if ( n <= 1 || is_pi( n ) || is_dead( n ) )
+      return;
+
+    auto& nobj = _storage->nodes[n];
+    nobj.data[0].h1 = UINT32_C( 0x80000000 ); /* fanout size 0, but dead */
+
+    /*  remove register entry if register */
+    if ( is_register( n ) )
+    {
+      _register_information->erase( n );
+    }
+
+    for ( auto const& fn : _events->on_delete )
+    {
+      ( *fn )( n );
+    }
+
+    for ( auto& child : nobj.children )
+    {
+      if ( fanout_size( child.index ) == 0 )
+      {
+        continue;
+      }
+      if ( decr_fanout_size( child.index ) == 0 )
+      {
+        take_out_node( child.index );
+      }
+    }
+  }
+
+  void revive_node( node const& n )
+  {
+    assert( !is_dead( n ) );
+    return;
+  }
+
+  inline bool is_dead( node const& n ) const
+  {
+    return ( _storage->nodes[n].data[0].h1 >> 31 ) & 1;
+  }
+
+  void substitute_node( node const& old_node, signal const& new_signal )
+  {
+    /* find all parents from old_node */
+    for ( auto i = 0u; i < _storage->nodes.size(); ++i )
+    {
+      auto& n = _storage->nodes[i];
+      for ( auto& child : n.children )
+      {
+        if ( child == old_node )
+        {
+          std::vector<signal> old_children( n.children.size() );
+          std::transform( n.children.begin(), n.children.end(), old_children.begin(), []( auto c ) { return c.index; } );
+          child = new_signal;
+
+          // increment fan-out of new node
+          _storage->nodes[new_signal].data[0].h1++;
+
+          for ( auto const& fn : _events->on_modified )
+          {
+            ( *fn )( i, old_children );
+          }
+        }
+      }
+    }
+
+    /* check outputs */
+    replace_in_outputs( old_node, new_signal );
+
+    /* reset fan-in of old node */
+    take_out_node( old_node );
+  }
+#pragma endregion
+
+#pragma region Structural properties
+  auto size() const
+  {
+    return static_cast<uint32_t>( _storage->nodes.size() );
+  }
+
+  auto num_cis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_cos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  uint32_t num_registers() const
+  {
+    return static_cast<uint32_t>( _register_information->size() );
+  }
+
+  /*! \brief Standard version of num_registers replaced by the one above. */
+  // auto num_registers() const
+  // {
+  //   assert( static_cast<uint32_t>( _storage->inputs.size() - _storage->data.num_pis ) == static_cast<uint32_t>( _storage->outputs.size() - _storage->data.num_pos ) );
+  //   return static_cast<uint32_t>( _storage->inputs.size() - _storage->data.num_pis );
+  // }
+
+  auto num_pis() const
+  {
+    return _storage->data.num_pis;
+  }
+
+  auto num_pos() const
+  {
+    return _storage->data.num_pos;
+  }
+
+  auto num_gates() const
+  {
+    return static_cast<uint32_t>( _storage->nodes.size() - _storage->inputs.size() - _storage->outputs.size() - 2 );
+  }
+
+  uint32_t fanin_size( node const& n ) const
+  {
+    return static_cast<uint32_t>( _storage->nodes[n].children.size() );
+  }
+
+  uint32_t fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1 & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t incr_fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1++ & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t decr_fanout_size( node const& n ) const
+  {
+    return --_storage->nodes[n].data[0].h1 & UINT32_C( 0x7FFFFFFF );
+  }
+
+  bool is_function( node const& n ) const
+  {
+    return n > 1 && !is_ci( n );
+  }
+#pragma endregion
+
+#pragma region Functional properties
+  kitty::dynamic_truth_table node_function( const node& n ) const
+  {
+    return _storage->data.cache[_storage->nodes[n].data[1].h1];
+  }
+#pragma endregion
+
+#pragma region Nodes and signals
+  node get_node( signal const& f ) const
+  {
+    return f;
+  }
+
+  signal make_signal( node const& n ) const
+  {
+    return n;
+  }
+
+  bool is_complemented( signal const& f ) const
+  {
+    (void)f;
+    return false;
+  }
+
+  uint32_t node_to_index( node const& n ) const
+  {
+    return static_cast<uint32_t>( n );
+  }
+
+  node index_to_node( uint32_t index ) const
+  {
+    return index;
+  }
+
+  node ci_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal co_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return ( _storage->outputs.begin() + index )->index;
+  }
+
+  node pi_at( uint32_t index ) const
+  {
+    assert( index < _storage->data.num_pis );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal po_at( uint32_t index ) const
+  {
+    assert( index < _storage->data.num_pos );
+    return ( _storage->outputs.begin() + index )->index;
+  }
+
+  node ro_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() - _storage->data.num_pis );
+    return *( _storage->inputs.begin() + _storage->data.num_pis + index );
+  }
+
+  signal ri_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() - _storage->data.num_pos );
+    return ( _storage->outputs.begin() + _storage->data.num_pos + index )->index;
+  }
+
+  uint32_t ci_index( node const& n ) const
+  {
+    assert( _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data );
+    return static_cast<uint32_t>( _storage->nodes[n].children[0].data );
+  }
+
+  uint32_t co_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_co( [&]( const auto& x, auto index ) {
+      if ( x == s )
+      {
+        i = index;
+        return false;
+      }
+      return true;
+    } );
+    return i;
+  }
+
+  uint32_t pi_index( node const& n ) const
+  {
+    assert( _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data );
+    return static_cast<uint32_t>( _storage->nodes[n].children[0].data );
+  }
+
+  uint32_t po_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_po( [&]( const auto& x, auto index ) {
+      if ( x == s )
+      {
+        i = index;
+        return false;
+      }
+      return true;
+    } );
+    return i;
+  }
+
+  uint32_t ro_index( node const& n ) const
+  {
+    assert( _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data );
+    return static_cast<uint32_t>( _storage->nodes[n].children[0].data - _storage->data.num_pis );
+  }
+
+  uint32_t ri_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_ri( [&]( const auto& x, auto index ) {
+      if ( x == s )
+      {
+        i = index;
+        return false;
+      }
+      return true;
+    } );
+    return i;
+  }
+
+  signal ro_to_ri( signal const& s ) const
+  {
+    return ( _storage->outputs.begin() + _storage->data.num_pos + _storage->nodes[s].children[0].data - _storage->data.num_pis )->index;
+  }
+
+  node ri_to_ro( signal const& s ) const
+  {
+    return *( _storage->inputs.begin() + _storage->data.num_pis + ri_index( s ) );
+  }
+#pragma endregion
+
+#pragma region Children acces
+  signal get_fanin0( node const& n ) const
+  {
+    assert( _storage->nodes[n].children.size() );
+    return _storage->nodes[n].children[0].data;
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( _storage->nodes.size() );
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_dead( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_ci( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_co( Fn&& fn ) const
+  {
+    using IteratorType = decltype( _storage->outputs.begin() );
+    detail::foreach_element_transform<IteratorType, uint32_t>(
+        _storage->outputs.begin(), _storage->outputs.end(), []( auto o ) { return o.index; }, fn );
+  }
+
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.begin() + _storage->data.num_pis, fn );
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    using IteratorType = decltype( _storage->outputs.begin() );
+    detail::foreach_element_transform<IteratorType, uint32_t>(
+        _storage->outputs.begin(), _storage->outputs.begin() + _storage->data.num_pos, []( auto o ) { return o.index; }, fn );
+  }
+
+  template<typename Fn>
+  void foreach_ro( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin() + _storage->data.num_pis, _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_ri( Fn&& fn ) const
+  {
+    using IteratorType = decltype( _storage->outputs.begin() );
+    detail::foreach_element_transform<IteratorType, uint32_t>(
+        _storage->outputs.begin() + _storage->data.num_pos, _storage->outputs.end(), []( auto o ) { return o.index; }, fn );
+  }
+
+  template<typename Fn>
+  void foreach_register( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( 2u, _storage->nodes.size() ); /* start from 2 to avoid constants */
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return is_register( n ) && !is_dead( n ); },
+        fn );
+  }
+
+  /*! \brief Standard version of foreach_register replaced by the one above. */
+  // template<typename Fn>
+  // void foreach_register( Fn&& fn ) const
+  // {
+  //   static_assert( detail::is_callable_with_index_v<Fn, std::pair<signal, node>, void> ||
+  //                  detail::is_callable_without_index_v<Fn, std::pair<signal, node>, void> ||
+  //                  detail::is_callable_with_index_v<Fn, std::pair<signal, node>, bool> ||
+  //                  detail::is_callable_without_index_v<Fn, std::pair<signal, node>, bool> );
+
+  //   assert( _storage->inputs.size() - _storage->data.num_pis == _storage->outputs.size() - _storage->data.num_pos );
+  //   auto ro = _storage->inputs.begin() + _storage->data.num_pis;
+  //   auto ri = _storage->outputs.begin() + _storage->data.num_pos;
+  //   if constexpr ( detail::is_callable_without_index_v<Fn, std::pair<signal, node>, bool> )
+  //   {
+  //     while ( ro != _storage->inputs.end() && ri != _storage->outputs.end() )
+  //     {
+  //       if ( !fn( std::make_pair( ( ri++ )->index, ro++ ) ) )
+  //         return;
+  //     }
+  //   }
+  //   else if constexpr ( detail::is_callable_with_index_v<Fn, std::pair<signal, node>, bool> )
+  //   {
+  //     uint32_t index{ 0 };
+  //     while ( ro != _storage->inputs.end() && ri != _storage->outputs.end() )
+  //     {
+  //       if ( !fn( std::make_pair( ( ri++ )->index, ro++ ), index++ ) )
+  //         return;
+  //     }
+  //   }
+  //   else if constexpr ( detail::is_callable_without_index_v<Fn, std::pair<signal, node>, void> )
+  //   {
+  //     while ( ro != _storage->inputs.end() && ri != _storage->outputs.end() )
+  //     {
+  //       fn( std::make_pair( ( ri++ )->index, *ro++ ) );
+  //     }
+  //   }
+  //   else if constexpr ( detail::is_callable_with_index_v<Fn, std::pair<signal, node>, void> )
+  //   {
+  //     uint32_t index{ 0 };
+  //     while ( ro != _storage->inputs.end() && ri != _storage->outputs.end() )
+  //     {
+  //       fn( std::make_pair( ( ri++ )->index, *ro++ ), index++ );
+  //     }
+  //   }
+  // }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( 2u, _storage->nodes.size() ); /* start from 2 to avoid constants */
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_pi( n ) && !is_dead( n ); }, /* change to PI to cycle over boxes as well */
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_fanin( node const& n, Fn&& fn ) const
+  {
+    if ( n <= 1 ) /* || is_ci( n ) */
+      return;
+
+    using IteratorType = decltype( _storage->outputs.begin() );
+    detail::foreach_element_transform<IteratorType, uint32_t>(
+        _storage->nodes[n].children.begin(), _storage->nodes[n].children.end(), []( auto f ) { return f.index; }, fn );
+  }
+#pragma endregion
+
+#pragma region Simulate values
+  template<typename Iterator>
+  iterates_over_t<Iterator, bool>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    uint32_t index{ 0 };
+    while ( begin != end )
+    {
+      index <<= 1;
+      index ^= *begin++ ? 1 : 0;
+    }
+    return kitty::get_bit( _storage->data.cache[_storage->nodes[n].data[1].h1], index );
+  }
+
+  template<typename Iterator>
+  iterates_over_truth_table_t<Iterator>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    const auto nfanin = _storage->nodes[n].children.size();
+    std::vector<typename Iterator::value_type> tts( begin, end );
+
+    assert( nfanin != 0 );
+    assert( tts.size() == nfanin );
+
+    /* resulting truth table has the same size as any of the children */
+    auto result = tts.front().construct();
+    const auto gate_tt = _storage->data.cache[_storage->nodes[n].data[1].h1];
+
+    for ( uint32_t i = 0u; i < static_cast<uint32_t>( result.num_bits() ); ++i )
+    {
+      uint32_t pattern = 0u;
+      for ( auto j = 0u; j < nfanin; ++j )
+      {
+        pattern |= kitty::get_bit( tts[j], i ) << j;
+      }
+      if ( kitty::get_bit( gate_tt, pattern ) )
+      {
+        kitty::set_bit( result, i );
+      }
+    }
+
+    return result;
+  }
+#pragma endregion
+
+#pragma region Custom node values
+  void clear_values() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[0].h2 = 0; } );
+  }
+
+  uint32_t value( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h2;
+  }
+
+  void set_value( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[0].h2 = v;
+  }
+
+  uint32_t incr_value( node const& n ) const
+  {
+    return static_cast<uint32_t>( _storage->nodes[n].data[0].h2++ );
+  }
+
+  uint32_t decr_value( node const& n ) const
+  {
+    return static_cast<uint32_t>( --_storage->nodes[n].data[0].h2 );
+  }
+
+  void clear_values2() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[2].h2 = 0; } );
+  }
+
+  uint32_t value2( node const& n ) const
+  {
+    return _storage->nodes[n].data[2].h2;
+  }
+
+  void set_value2( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[2].h2 = v;
+  }
+#pragma endregion
+
+#pragma region Visited flags
+  void clear_visited() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[1].h2 = 0; } );
+  }
+
+  auto visited( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h2;
+  }
+
+  void set_visited( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[1].h2 = v;
+  }
+
+  uint32_t trav_id() const
+  {
+    return _storage->data.trav_id;
+  }
+
+  void incr_trav_id() const
+  {
+    ++_storage->data.trav_id;
+  }
+#pragma endregion
+
+#pragma region General methods
+  auto& events() const
+  {
+    return *_events;
+  }
+#pragma endregion
+
+public:
+  std::shared_ptr<generic_storage> _storage;
+  std::shared_ptr<network_events<base_type>> _events;
+  std::shared_ptr<std::unordered_map<uint64_t, register_t>> _register_information;
+};
+
+} // namespace mockturtle
diff --git a/include/mockturtle/networks/gia.hpp b/include/mockturtle/networks/gia.hpp
new file mode 100644
index 0000000..64fed98
--- /dev/null
+++ b/include/mockturtle/networks/gia.hpp
@@ -0,0 +1,269 @@
+#pragma once
+#ifdef ENABLE_ABC
+
+#include "detail/foreach.hpp"
+#include <kitty/dynamic_truth_table.hpp>
+
+namespace abc {
+  typedef struct Gia_Man_t_ Gia_Man_t;
+  typedef struct Gia_Obj_t_ Gia_Obj_t;
+  typedef struct Abc_Frame_t_ Abc_Frame_t;
+  
+  inline int      Abc_LitNot( int Lit )                  { assert(Lit >= 0); return Lit ^ 1;                           }
+  inline int      Abc_Lit2Var( int Lit )                 { assert(Lit >= 0); return Lit >> 1;                          }
+  inline int      Abc_LitRegular( int Lit )              { assert(Lit >= 0); return Lit & ~01;                         }
+
+  extern Gia_Obj_t * Gia_Regular( Gia_Obj_t * p );
+  extern Gia_Obj_t * Gia_Not( Gia_Obj_t * p );
+  extern Gia_Man_t * Gia_ManStart(int nObjsMax);
+  extern void        Gia_ManStop(Gia_Man_t * p);
+  extern int         Gia_ManAppendCi(Gia_Man_t * p);
+  extern int         Gia_ManAppendCo(Gia_Man_t * p, int iLit0);
+  extern int         Gia_ManAppendAnd2(Gia_Man_t * p, int iLit0, int iLit1);
+  extern Gia_Obj_t * Gia_ManObj(Gia_Man_t * p, int v);
+  extern int         Gia_ObjIsPi(Gia_Man_t * p, Gia_Obj_t * pObj);
+  extern int         Gia_ObjIsAnd(Gia_Obj_t * pObj);
+  extern int         Gia_IsComplement(Gia_Obj_t * p);
+  extern int         Gia_ManPiNum(Gia_Man_t * p);
+  extern int         Gia_ManPoNum(Gia_Man_t * p);
+  extern int         Gia_ManAndNum(Gia_Man_t * p);
+  extern int         Gia_ManObjNum(Gia_Man_t * p);
+  extern Gia_Obj_t * Gia_ManPi(Gia_Man_t * p, int v);
+  extern int         Gia_Obj2Lit(Gia_Man_t * p, Gia_Obj_t * pObj);
+  extern Gia_Obj_t * Gia_ManCi(Gia_Man_t * p, int v);
+  extern Gia_Obj_t * Gia_ManCo(Gia_Man_t * p, int v);
+  extern Gia_Obj_t * Gia_ObjFanin0(Gia_Obj_t * pObj);
+  extern Gia_Obj_t * Gia_ObjFanin1(Gia_Obj_t * pObj);
+  extern int Gia_ObjFaninC0(Gia_Obj_t * pObj);
+  extern int Gia_ObjFaninC1(Gia_Obj_t * pObj);
+  extern int         Gia_ManLevelNum( Gia_Man_t * p );
+  extern Gia_Obj_t * Gia_ManConst0( Gia_Man_t * p );
+  extern Gia_Obj_t * Gia_ManConst1( Gia_Man_t * p );
+  extern int Gia_ObjId( Gia_Man_t * p, Gia_Obj_t * pObj );
+  extern Gia_Man_t * Gia_ManDup( Gia_Man_t * p );
+
+  extern Abc_Frame_t * Abc_FrameGetGlobalFrame();
+  extern void Abc_FrameUpdateGia( Abc_Frame_t * p, Gia_Man_t * pNew );
+  extern Gia_Man_t * Abc_FrameGetGia( Abc_Frame_t * p );
+  extern int Cmd_CommandExecute( Abc_Frame_t * pAbc, const char * sCommand );
+}
+
+#include <iostream>
+
+namespace mockturtle {
+
+class gia_network;
+  
+class gia_signal {
+  friend class gia_network;
+
+public:
+  explicit gia_signal() = default;
+  explicit gia_signal(abc::Gia_Obj_t * obj) : obj_(obj) {}
+ 
+  gia_signal operator!() const { return gia_signal(abc::Gia_Not(obj_)); }
+  gia_signal operator+() const { return gia_signal(abc::Gia_Regular(obj_)); }
+  gia_signal operator-() const { return gia_signal(abc::Gia_Not(abc::Gia_Regular(obj_))); }
+ 
+  bool operator==(const gia_signal& other) const { return obj_ == other.obj_; }
+  bool operator!=(const gia_signal& other) const { return !operator==(other); }
+  bool operator<(const gia_signal& other) const { return obj_ < other.obj_; }
+
+  abc::Gia_Obj_t * obj() const { return obj_; }
+  
+private:
+  abc::Gia_Obj_t * obj_;
+};
+  
+class gia_network {
+public:
+  static constexpr auto min_fanin_size = 2u;
+  static constexpr auto max_fanin_size = 2u;
+
+  using base_type = gia_network;
+  using node = int;
+  using signal = gia_signal;
+  using storage = abc::Gia_Man_t*;
+  
+  gia_network(int size)
+    : gia_(abc::Gia_ManStart(size)) /* doesn't automatically resize? */
+  {}
+
+  /* network does not implement constant value */
+  bool constant_value(node n) const { (void)n; return false; }
+
+  /* each node implements AND function */
+  kitty::dynamic_truth_table node_function(node n) const { (void)n; kitty::dynamic_truth_table tt(2); tt._bits[0] = 0x8; return tt; }
+
+  
+  signal get_constant(bool value) const {
+    return value ? signal(abc::Gia_ManConst1(gia_)) : signal(abc::Gia_ManConst0(gia_));
+  }
+  
+  signal create_pi() {
+    return signal(abc::Gia_ManObj(gia_, abc::Abc_Lit2Var(abc::Gia_ManAppendCi(gia_))));
+  }
+
+  void create_po(const signal& f) {
+    /* po_node = */abc::Gia_ManAppendCo(gia_, abc::Gia_Obj2Lit(gia_, f.obj()));
+  }
+
+  signal create_not(const signal& f) {
+    return !f;
+  }
+  
+  signal create_and(const signal& f, const signal& g) {
+    return signal(abc::Gia_ManObj(gia_, abc::Abc_Lit2Var(abc::Gia_ManAppendAnd2(gia_, abc::Gia_Obj2Lit(gia_, f.obj()), abc::Gia_Obj2Lit(gia_, g.obj())))));
+  }
+
+  bool is_constant(node n) const {
+    return n == 0;
+  }
+
+  node get_node(const signal& f) const {
+    return Gia_ObjId(gia_, f.obj());
+  }
+
+  bool is_pi(node const& n) const {
+    return abc::Gia_ObjIsPi(gia_, abc::Gia_ManObj(gia_, n));
+  }
+
+  bool is_complemented(const signal& f) const {
+    return Gia_IsComplement(f.obj());
+  }
+
+  template<typename Fn>
+  void foreach_pi(Fn&& fn) const {
+    abc::Gia_Obj_t * pObj;
+    for (int i = 0; (i < abc::Gia_ManPiNum(gia_)) && ((pObj) = abc::Gia_ManCi(gia_, i)); ++i) {
+      fn(Gia_ObjId(gia_, pObj));
+    }
+  }
+
+  template<typename Fn>
+  void foreach_po(Fn&& fn) const {
+    abc::Gia_Obj_t * pObj, * pFiObj;
+    for (int i = 0; (i < abc::Gia_ManPoNum(gia_)) && ((pObj) = abc::Gia_ManCo(gia_, i)); ++i) {
+      pFiObj = abc::Gia_ObjFanin0(pObj);
+      fn(abc::Gia_ObjFaninC0(pObj) ? !signal(pFiObj) : signal(pFiObj));
+    }
+  }
+
+  template<typename Fn>
+  void foreach_gate(Fn&& fn) const {
+    abc::Gia_Obj_t * pObj;
+    for (int i = 0; i < abc::Gia_ManObjNum(gia_) && ((pObj) = abc::Gia_ManObj(gia_, i)); ++i) {
+      if (abc::Gia_ObjIsAnd(pObj)) {
+        fn(Gia_ObjId(gia_, pObj));
+      }
+    }
+  }  
+
+  template<typename Fn>
+  void foreach_node(Fn&& fn) const {
+    abc::Gia_Obj_t * pObj;
+    for (int i = 0; i < abc::Gia_ManObjNum(gia_) && ((pObj) = abc::Gia_ManObj(gia_, i)); ++i) {
+      fn(signal(pObj));
+    }
+  }  
+
+  template<typename Fn>
+  void foreach_fanin(node n, Fn&& fn) const {
+    static_assert( detail::is_callable_without_index_v<Fn, signal, bool> ||
+                   detail::is_callable_with_index_v<Fn, signal, bool> ||
+                   detail::is_callable_without_index_v<Fn, signal, void> ||
+                   detail::is_callable_with_index_v<Fn, signal, void> );
+
+    if (n == 0 || is_pi(n)) { return; }    
+
+    abc::Gia_Obj_t * pObj = abc::Gia_ManObj(gia_, n);
+    if constexpr ( detail::is_callable_without_index_v<Fn, signal, bool> )
+    {
+      if (!fn(signal(abc::Gia_ObjFaninC0(pObj) ? Gia_Not(abc::Gia_ObjFanin0(pObj)) : abc::Gia_ObjFanin0(pObj)))) {
+        return;
+      }
+      fn(signal(abc::Gia_ObjFaninC1(pObj) ? Gia_Not(abc::Gia_ObjFanin1(pObj)) : abc::Gia_ObjFanin1(pObj)));
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, signal, bool> )
+    {
+      if (!fn(signal(abc::Gia_ObjFaninC0(pObj) ? Gia_Not(abc::Gia_ObjFanin0(pObj)) : abc::Gia_ObjFanin0(pObj))), 0) {
+        return;
+      }
+      fn(signal(abc::Gia_ObjFaninC1(pObj) ? Gia_Not(abc::Gia_ObjFanin1(pObj)) : abc::Gia_ObjFanin1(pObj)), 1);
+    }
+    else if constexpr ( detail::is_callable_without_index_v<Fn, signal, void> )
+    {
+      fn(signal(abc::Gia_ObjFaninC0(pObj) ? Gia_Not(abc::Gia_ObjFanin0(pObj)) : abc::Gia_ObjFanin0(pObj)));
+      fn(signal(abc::Gia_ObjFaninC1(pObj) ? Gia_Not(abc::Gia_ObjFanin1(pObj)) : abc::Gia_ObjFanin1(pObj)));
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, signal, void> )
+    {
+      fn(signal(abc::Gia_ObjFaninC0(pObj) ? Gia_Not(abc::Gia_ObjFanin0(pObj)) : abc::Gia_ObjFanin0(pObj)), 0);
+      fn(signal(abc::Gia_ObjFaninC1(pObj) ? Gia_Not(abc::Gia_ObjFanin1(pObj)) : abc::Gia_ObjFanin1(pObj)), 1);
+    }
+  }  
+
+  int literal(const signal& f) const
+  {
+    return (abc::Gia_ObjId(gia_, f.obj()) << 1) + abc::Gia_IsComplement(f.obj());
+  }
+  
+  int node_to_index(node n) const
+  {
+    return n;
+  }
+
+  auto num_pis() const { return abc::Gia_ManPiNum(gia_); }
+  auto num_pos() const { return abc::Gia_ManPoNum(gia_); }
+  auto num_gates() const { return abc::Gia_ManAndNum(gia_); }
+  auto num_levels() const { return abc::Gia_ManLevelNum(gia_); }
+  auto size() const { return abc::Gia_ManObjNum(gia_); }
+
+  bool load_rc() {
+    abc::Abc_Frame_t * abc = abc::Abc_FrameGetGlobalFrame();
+    const int success = abc::Cmd_CommandExecute(abc, default_rc);
+    if (success != 0) {
+      printf("syntax error in script\n");
+    }
+    return success == 0;
+  }
+
+  bool run_opt_script(const std::string &script) {
+    abc::Gia_Man_t * gia = abc::Gia_ManDup(gia_);
+    abc::Abc_Frame_t * abc = abc::Abc_FrameGetGlobalFrame();
+    abc::Abc_FrameUpdateGia(abc, gia);
+
+    const int success = abc::Cmd_CommandExecute(abc, script.c_str());
+    if (success != 0) {
+      printf("syntax error in script\n");
+    }
+
+    abc::Gia_Man_t * new_gia = abc::Abc_FrameGetGia(abc);
+    abc::Gia_ManStop(gia_);
+    gia_ = new_gia;
+    
+    return success == 0;
+  }
+
+private:
+  const char * default_rc =
+    "alias b balance;\n"
+    "alias rw rewrite;\n"
+    "alias rwz rewrite -z;\n"
+    "alias rf refactor;\n"
+    "alias rfz refactor -z;\n"
+    "alias rs resub;\n"
+    "alias rsz resub -z;\n"
+    "alias &r2rs '&put; b; rs -K 6; rw; rs -K 6 -N 2; rf; rs -K 8; b; rs -K 8 -N 2; rw; rs -K 10; rwz; rs -K 10 -N 2; b; rs -K 12; rfz; rs -K 12 -N 2; rwz; b; &get';\n"
+    "alias &c2rs '&put; b -l; rs -K 6 -l; rw -l; rs -K 6 -N 2 -l; rf -l; rs -K 8 -l; b -l; rs -K 8 -N 2 -l; rw -l; rs -K 10 -l; rwz -l; rs -K 10 -N 2 -l; b -l; rs -K 12 -l; rfz -l; rs -K 12 -N 2 -l; rwz -l; b -l; &get';\n"
+    "alias compress2rs 'b -l; rs -K 6 -l; rw -l; rs -K 6 -N 2 -l; rf -l; rs -K 8 -l; b -l; rs -K 8 -N 2 -l; rw -l; rs -K 10 -l; rwz -l; rs -K 10 -N 2 -l; b -l; rs -K 12 -l; rfz -l; rs -K 12 -N 2 -l; rwz -l; b -l';\n"
+    "alias resyn2rs 'b; rs -K 6; rw; rs -K 6 -N 2; rf; rs -K 8; b; rs -K 8 -N 2; rw; rs -K 10; rwz; rs -K 10 -N 2; b; rs -K 12; rfz; rs -K 12 -N 2; rwz; b;'\n"
+    "alias resyn2rs2 'b; rs -K 6; rw; rs -K 6 -N 2; rs -K 8; b; rs -K 8 -N 2; rw; rs -K 10; rwz; rs -K 10 -N 2; b; rs -K 12; rs -K 12 -N 2; rwz; b;'\n";
+
+private:
+  abc::Gia_Man_t *gia_;
+}; // gia_network
+
+} // mockturtle
+
+#endif
diff --git a/include/mockturtle/networks/klut.hpp b/include/mockturtle/networks/klut.hpp
new file mode 100644
index 0000000..96a7a6f
--- /dev/null
+++ b/include/mockturtle/networks/klut.hpp
@@ -0,0 +1,707 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file klut.hpp
+  \brief k-LUT logic network implementation
+
+  \author Alessandro Tempia Calvino
+  \author Andrea Costamagna
+  \author Heinz Riener
+  \author Marcel Walter
+  \author Mathias Soeken
+  \author Max Austin
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+#include "../utils/algorithm.hpp"
+#include "../utils/truth_table_cache.hpp"
+#include "detail/foreach.hpp"
+#include "events.hpp"
+#include "storage.hpp"
+
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+
+#include <algorithm>
+#include <memory>
+
+namespace mockturtle
+{
+
+struct klut_storage_data
+{
+  truth_table_cache<kitty::dynamic_truth_table> cache;
+};
+
+/*! \brief k-LUT node
+ *
+ * `data[0].h1`: Fan-out size
+ * `data[0].h2`: Application-specific value
+ * `data[1].h1`: Function literal in truth table cache
+ * `data[1].h2`: Visited flags
+ */
+struct klut_storage_node : mixed_fanin_node<2>
+{
+  bool operator==( klut_storage_node const& other ) const
+  {
+    return data[1].h1 == other.data[1].h1 && children == other.children;
+  }
+};
+
+/*! \brief k-LUT storage container
+
+  ...
+*/
+using klut_storage = storage<klut_storage_node, klut_storage_data>;
+
+class klut_network
+{
+public:
+#pragma region Types and constructors
+  static constexpr auto min_fanin_size = 1;
+  static constexpr auto max_fanin_size = 32;
+
+  using base_type = klut_network;
+  using storage = std::shared_ptr<klut_storage>;
+  using node = uint64_t;
+  using signal = uint64_t;
+
+  klut_network()
+      : _storage( std::make_shared<klut_storage>() ),
+        _events( std::make_shared<decltype( _events )::element_type>() )
+  {
+    _init();
+  }
+
+  klut_network( std::shared_ptr<klut_storage> storage )
+      : _storage( storage ),
+        _events( std::make_shared<decltype( _events )::element_type>() )
+  {
+    _init();
+  }
+
+  klut_network clone() const
+  {
+    return { std::make_shared<klut_storage>( *_storage ) };
+  }
+
+protected:
+  inline void _init()
+  {
+    /* already initialized */
+    if ( _storage->nodes.size() > 1 )
+      return;
+
+    /* reserve the second node for constant 1 */
+    _storage->nodes.emplace_back();
+
+    /* reserve some truth tables for nodes */
+    kitty::dynamic_truth_table tt_zero( 0 );
+    _storage->data.cache.insert( tt_zero );
+
+    static uint64_t _not = 0x1;
+    kitty::dynamic_truth_table tt_not( 1 );
+    kitty::create_from_words( tt_not, &_not, &_not + 1 );
+    _storage->data.cache.insert( tt_not );
+
+    static uint64_t _and = 0x8;
+    kitty::dynamic_truth_table tt_and( 2 );
+    kitty::create_from_words( tt_and, &_and, &_and + 1 );
+    _storage->data.cache.insert( tt_and );
+
+    static uint64_t _or = 0xe;
+    kitty::dynamic_truth_table tt_or( 2 );
+    kitty::create_from_words( tt_or, &_or, &_or + 1 );
+    _storage->data.cache.insert( tt_or );
+
+    static uint64_t _lt = 0x4;
+    kitty::dynamic_truth_table tt_lt( 2 );
+    kitty::create_from_words( tt_lt, &_lt, &_lt + 1 );
+    _storage->data.cache.insert( tt_lt );
+
+    static uint64_t _le = 0xd;
+    kitty::dynamic_truth_table tt_le( 2 );
+    kitty::create_from_words( tt_le, &_le, &_le + 1 );
+    _storage->data.cache.insert( tt_le );
+
+    static uint64_t _xor = 0x6;
+    kitty::dynamic_truth_table tt_xor( 2 );
+    kitty::create_from_words( tt_xor, &_xor, &_xor + 1 );
+    _storage->data.cache.insert( tt_xor );
+
+    static uint64_t _maj = 0xe8;
+    kitty::dynamic_truth_table tt_maj( 3 );
+    kitty::create_from_words( tt_maj, &_maj, &_maj + 1 );
+    _storage->data.cache.insert( tt_maj );
+
+    static uint64_t _ite = 0xd8;
+    kitty::dynamic_truth_table tt_ite( 3 );
+    kitty::create_from_words( tt_ite, &_ite, &_ite + 1 );
+    _storage->data.cache.insert( tt_ite );
+
+    static uint64_t _xor3 = 0x96;
+    kitty::dynamic_truth_table tt_xor3( 3 );
+    kitty::create_from_words( tt_xor3, &_xor3, &_xor3 + 1 );
+    _storage->data.cache.insert( tt_xor3 );
+
+    /* truth tables for constants */
+    _storage->nodes[0].data[1].h1 = 0;
+    _storage->nodes[1].data[1].h1 = 1;
+  }
+#pragma endregion
+
+#pragma region Primary I / O and constants
+public:
+  signal get_constant( bool value = false ) const
+  {
+    return value ? 1 : 0;
+  }
+
+  signal create_pi()
+  {
+    const auto index = _storage->nodes.size();
+    _storage->nodes.emplace_back();
+    _storage->inputs.emplace_back( index );
+    _storage->nodes[index].data[1].h1 = 2;
+    return index;
+  }
+
+  uint32_t create_po( signal const& f )
+  {
+    /* increase ref-count to children */
+    _storage->nodes[f].data[0].h1++;
+    auto const po_index = static_cast<uint32_t>( _storage->outputs.size() );
+    _storage->outputs.emplace_back( f );
+    return po_index;
+  }
+
+  bool is_combinational() const
+  {
+    return true;
+  }
+
+  bool is_constant( node const& n ) const
+  {
+    return n <= 1;
+  }
+
+  bool is_ci( node const& n ) const
+  {
+    return std::find( _storage->inputs.begin(), _storage->inputs.end(), n ) != _storage->inputs.end();
+  }
+
+  bool is_pi( node const& n ) const
+  {
+    return std::find( _storage->inputs.begin(), _storage->inputs.end(), n ) != _storage->inputs.end();
+  }
+
+  bool constant_value( node const& n ) const
+  {
+    return n == 1;
+  }
+
+  uint32_t po_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_po( [&]( const auto& x, auto index ) {
+      if ( x == s )
+      {
+        i = index;
+        return false;
+      }
+      return true;
+    } );
+    return i;
+  }
+#pragma endregion
+
+#pragma region Create unary functions
+  signal create_buf( signal const& a )
+  {
+    return a;
+  }
+
+  signal create_not( signal const& a )
+  {
+    return _create_node( { a }, 3 );
+  }
+#pragma endregion
+
+#pragma region Create binary functions
+  signal create_and( signal a, signal b )
+  {
+    return _create_node( { a, b }, 4 );
+  }
+
+  signal create_nand( signal a, signal b )
+  {
+    return _create_node( { a, b }, 5 );
+  }
+
+  signal create_or( signal a, signal b )
+  {
+    return _create_node( { a, b }, 6 );
+  }
+
+  signal create_lt( signal a, signal b )
+  {
+    return _create_node( { a, b }, 8 );
+  }
+
+  signal create_le( signal a, signal b )
+  {
+    return _create_node( { a, b }, 11 );
+  }
+
+  signal create_xor( signal a, signal b )
+  {
+    return _create_node( { a, b }, 12 );
+  }
+#pragma endregion
+
+#pragma region Create ternary functions
+  signal create_maj( signal a, signal b, signal c )
+  {
+    return _create_node( { a, b, c }, 14 );
+  }
+
+  signal create_ite( signal a, signal b, signal c )
+  {
+    return _create_node( { a, b, c }, 16 );
+  }
+
+  signal create_xor3( signal a, signal b, signal c )
+  {
+    return _create_node( { a, b, c }, 18 );
+  }
+#pragma endregion
+
+#pragma region Create nary functions
+  signal create_nary_and( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( true ), [this]( auto const& a, auto const& b ) { return create_and( a, b ); } );
+  }
+
+  signal create_nary_or( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_or( a, b ); } );
+  }
+
+  signal create_nary_xor( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_xor( a, b ); } );
+  }
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  signal _create_node( std::vector<signal> const& children, uint32_t literal )
+  {
+    storage::element_type::node_type node;
+    std::copy( children.begin(), children.end(), std::back_inserter( node.children ) );
+    node.data[1].h1 = literal;
+
+    const auto it = _storage->hash.find( node );
+    if ( it != _storage->hash.end() )
+    {
+      return it->second;
+    }
+
+    const auto index = _storage->nodes.size();
+    _storage->nodes.push_back( node );
+    _storage->hash[node] = index;
+
+    /* increase ref-count to children */
+    for ( auto c : children )
+    {
+      _storage->nodes[c].data[0].h1++;
+    }
+
+    set_value( index, 0 );
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return index;
+  }
+
+  signal create_node( std::vector<signal> const& children, kitty::dynamic_truth_table const& function )
+  {
+    if ( children.size() == 0u )
+    {
+      assert( function.num_vars() == 0u );
+      return get_constant( !kitty::is_const0( function ) );
+    }
+    return _create_node( children, _storage->data.cache.insert( function ) );
+  }
+
+  signal clone_node( klut_network const& other, node const& source, std::vector<signal> const& children )
+  {
+    assert( !children.empty() );
+    const auto tt = other._storage->data.cache[other._storage->nodes[source].data[1].h1];
+    return create_node( children, tt );
+  }
+#pragma endregion
+
+#pragma region Restructuring
+  void substitute_node( node const& old_node, signal const& new_signal )
+  {
+    /* find all parents from old_node */
+    for ( auto i = 0u; i < _storage->nodes.size(); ++i )
+    {
+      auto& n = _storage->nodes[i];
+      for ( auto& child : n.children )
+      {
+        if ( child == old_node )
+        {
+          std::vector<signal> old_children( n.children.size() );
+          std::transform( n.children.begin(), n.children.end(), old_children.begin(), []( auto c ) { return c.index; } );
+          child = new_signal;
+
+          // increment fan-out of new node
+          _storage->nodes[new_signal].data[0].h1++;
+
+          for ( auto const& fn : _events->on_modified )
+          {
+            ( *fn )( i, old_children );
+          }
+        }
+      }
+    }
+
+    /* check outputs */
+    for ( auto& output : _storage->outputs )
+    {
+      if ( output == old_node )
+      {
+        output = new_signal;
+
+        // increment fan-out of new node
+        _storage->nodes[new_signal].data[0].h1++;
+      }
+    }
+
+    // reset fan-out of old node
+    _storage->nodes[old_node].data[0].h1 = 0;
+  }
+
+  inline bool is_dead( node const& n ) const
+  {
+    return false;
+  }
+#pragma endregion
+
+#pragma region Structural properties
+  auto size() const
+  {
+    return static_cast<uint32_t>( _storage->nodes.size() );
+  }
+
+  auto num_cis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_cos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  auto num_pis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_pos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  auto num_gates() const
+  {
+    return static_cast<uint32_t>( _storage->nodes.size() - _storage->inputs.size() - 2 );
+  }
+
+  uint32_t fanin_size( node const& n ) const
+  {
+    return static_cast<uint32_t>( _storage->nodes[n].children.size() );
+  }
+
+  uint32_t fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1;
+  }
+
+  uint32_t incr_fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1++;
+  }
+
+  uint32_t decr_fanout_size( node const& n ) const
+  {
+    return --_storage->nodes[n].data[0].h1;
+  }
+
+  bool is_function( node const& n ) const
+  {
+    return n > 1 && !is_ci( n );
+  }
+#pragma endregion
+
+#pragma region Functional properties
+  kitty::dynamic_truth_table node_function( const node& n ) const
+  {
+    return _storage->data.cache[_storage->nodes[n].data[1].h1];
+  }
+#pragma endregion
+
+#pragma region Nodes and signals
+  node get_node( signal const& f ) const
+  {
+    return f;
+  }
+
+  signal make_signal( node const& n ) const
+  {
+    return n;
+  }
+
+  bool is_complemented( signal const& f ) const
+  {
+    (void)f;
+    return false;
+  }
+
+  uint32_t node_to_index( node const& n ) const
+  {
+    return static_cast<uint32_t>( n );
+  }
+
+  node index_to_node( uint32_t index ) const
+  {
+    return index;
+  }
+
+  node ci_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal co_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return ( _storage->outputs.begin() + index )->index;
+  }
+
+  node pi_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal po_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return ( _storage->outputs.begin() + index )->index;
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( _storage->nodes.size() );
+    detail::foreach_element( r.begin(), r.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_ci( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_co( Fn&& fn ) const
+  {
+    using IteratorType = decltype( _storage->outputs.begin() );
+    detail::foreach_element_transform<IteratorType, uint32_t>(
+        _storage->outputs.begin(), _storage->outputs.end(), []( auto o ) { return o.index; }, fn );
+  }
+
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    using IteratorType = decltype( _storage->outputs.begin() );
+    detail::foreach_element_transform<IteratorType, uint32_t>(
+        _storage->outputs.begin(), _storage->outputs.end(), []( auto o ) { return o.index; }, fn );
+  }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( 2u, _storage->nodes.size() ); /* start from 2 to avoid constants */
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_ci( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_fanin( node const& n, Fn&& fn ) const
+  {
+    if ( n == 0 || is_ci( n ) )
+      return;
+
+    using IteratorType = decltype( _storage->outputs.begin() );
+    detail::foreach_element_transform<IteratorType, uint32_t>(
+        _storage->nodes[n].children.begin(), _storage->nodes[n].children.end(), []( auto f ) { return f.index; }, fn );
+  }
+#pragma endregion
+
+#pragma region Simulate values
+  template<typename Iterator>
+  iterates_over_t<Iterator, bool>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    uint32_t index{ 0 };
+    while ( begin != end )
+    {
+      index <<= 1;
+      index ^= *begin++ ? 1 : 0;
+    }
+    return kitty::get_bit( _storage->data.cache[_storage->nodes[n].data[1].h1], index );
+  }
+
+  template<typename Iterator>
+  iterates_over_truth_table_t<Iterator>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    const auto nfanin = _storage->nodes[n].children.size();
+
+    std::vector<typename std::iterator_traits<Iterator>::value_type> tts( begin, end );
+
+    assert( nfanin != 0 );
+    assert( tts.size() == nfanin );
+
+    /* resulting truth table has the same size as any of the children */
+    auto result = tts.front().construct();
+    const auto gate_tt = _storage->data.cache[_storage->nodes[n].data[1].h1];
+
+    for ( uint32_t i = 0u; i < static_cast<uint32_t>( result.num_bits() ); ++i )
+    {
+      uint32_t pattern = 0u;
+      for ( auto j = 0u; j < nfanin; ++j )
+      {
+        pattern |= kitty::get_bit( tts[j], i ) << j;
+      }
+      if ( kitty::get_bit( gate_tt, pattern ) )
+      {
+        kitty::set_bit( result, i );
+      }
+    }
+
+    return result;
+  }
+#pragma endregion
+
+#pragma region Custom node values
+  void clear_values() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[0].h2 = 0; } );
+  }
+
+  uint32_t value( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h2;
+  }
+
+  void set_value( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[0].h2 = v;
+  }
+
+  uint32_t incr_value( node const& n ) const
+  {
+    return static_cast<uint32_t>( _storage->nodes[n].data[0].h2++ );
+  }
+
+  uint32_t decr_value( node const& n ) const
+  {
+    return static_cast<uint32_t>( --_storage->nodes[n].data[0].h2 );
+  }
+#pragma endregion
+
+#pragma region Visited flags
+  void clear_visited() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[1].h2 = 0; } );
+  }
+
+  auto visited( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h2;
+  }
+
+  void set_visited( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[1].h2 = v;
+  }
+
+  uint32_t trav_id() const
+  {
+    return _storage->trav_id;
+  }
+
+  void incr_trav_id() const
+  {
+    ++_storage->trav_id;
+  }
+#pragma endregion
+
+#pragma region General methods
+  auto& events() const
+  {
+    return *_events;
+  }
+#pragma endregion
+
+public:
+  std::shared_ptr<klut_storage> _storage;
+  std::shared_ptr<network_events<base_type>> _events;
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/networks/mig.hpp b/include/mockturtle/networks/mig.hpp
new file mode 100644
index 0000000..c8646ac
--- /dev/null
+++ b/include/mockturtle/networks/mig.hpp
@@ -0,0 +1,1249 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mig.hpp
+  \brief MIG logic network implementation
+
+  \author Alessandro Tempia Calvino
+  \author Bruno Schmitt
+  \author Eleonora Testa
+  \author Hanyu Wang
+  \author Heinz Riener
+  \author Jinzheng Tu
+  \author Mathias Soeken
+  \author Max Austin
+  \author Siang-Yun (Sonia) Lee
+  \author Walter Lau Neto
+*/
+
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <stack>
+#include <string>
+
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/operators.hpp>
+
+#include "../traits.hpp"
+#include "../utils/algorithm.hpp"
+#include "detail/foreach.hpp"
+#include "events.hpp"
+#include "storage.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief MIG storage container
+
+  MIGs have nodes with fan-in 3.  We split of one bit of the index pointer to
+  store a complemented attribute.  Every node has 64-bit of additional data
+  used for the following purposes:
+
+  `data[0].h1`: Fan-out size (we use MSB to indicate whether a node is dead)
+  `data[0].h2`: Application-specific value
+  `data[1].h1`: Visited flag
+  `data[1].h2`: Is terminal node (PI or CI)
+*/
+using mig_storage = storage<regular_node<3, 2, 1>>;
+
+class mig_network
+{
+public:
+#pragma region Types and constructors
+  static constexpr auto min_fanin_size = 3u;
+  static constexpr auto max_fanin_size = 3u;
+
+  using base_type = mig_network;
+  using storage = std::shared_ptr<mig_storage>;
+  using node = uint64_t;
+
+  struct signal
+  {
+    signal() = default;
+
+    signal( uint64_t index, uint64_t complement )
+        : complement( complement ), index( index )
+    {
+    }
+
+    explicit signal( uint64_t data )
+        : data( data )
+    {
+    }
+
+    signal( mig_storage::node_type::pointer_type const& p )
+        : complement( p.weight ), index( p.index )
+    {
+    }
+
+    union
+    {
+      struct
+      {
+        uint64_t complement : 1;
+        uint64_t index : 63;
+      };
+      uint64_t data;
+    };
+
+    signal operator!() const
+    {
+      return signal( data ^ 1 );
+    }
+
+    signal operator+() const
+    {
+      return { index, 0 };
+    }
+
+    signal operator-() const
+    {
+      return { index, 1 };
+    }
+
+    signal operator^( bool complement ) const
+    {
+      return signal( data ^ ( complement ? 1 : 0 ) );
+    }
+
+    bool operator==( signal const& other ) const
+    {
+      return data == other.data;
+    }
+
+    bool operator!=( signal const& other ) const
+    {
+      return data != other.data;
+    }
+
+    bool operator<( signal const& other ) const
+    {
+      return data < other.data;
+    }
+
+    operator mig_storage::node_type::pointer_type() const
+    {
+      return { index, complement };
+    }
+
+#if __cplusplus > 201703L
+    bool operator==( mig_storage::node_type::pointer_type const& other ) const
+    {
+      return data == other.data;
+    }
+#endif
+  };
+
+  mig_network()
+      : _storage( std::make_shared<mig_storage>() ),
+        _events( std::make_shared<decltype( _events )::element_type>() )
+  {
+  }
+
+  mig_network( std::shared_ptr<mig_storage> storage )
+      : _storage( storage ),
+        _events( std::make_shared<decltype( _events )::element_type>() )
+  {
+  }
+
+  mig_network clone() const
+  {
+    return { std::make_shared<mig_storage>( *_storage ) };
+  }
+#pragma endregion
+
+#pragma region Primary I / O and constants
+  signal get_constant( bool value ) const
+  {
+    return { 0, static_cast<uint64_t>( value ? 1 : 0 ) };
+  }
+
+  signal create_pi()
+  {
+    const auto index = _storage->nodes.size();
+    auto& node = _storage->nodes.emplace_back();
+    node.children[0].data = node.children[1].data = node.children[2].data = _storage->inputs.size();
+    node.data[1].h2 = 1; // mark as PI
+    _storage->inputs.emplace_back( index );
+    return { index, 0 };
+  }
+
+  uint32_t create_po( signal const& f )
+  {
+    /* increase ref-count to children */
+    _storage->nodes[f.index].data[0].h1++;
+    auto const po_index = static_cast<uint32_t>( _storage->outputs.size() );
+    _storage->outputs.emplace_back( f.index, f.complement );
+    return po_index;
+  }
+
+  bool is_combinational() const
+  {
+    return true;
+  }
+
+  bool is_constant( node const& n ) const
+  {
+    return n == 0;
+  }
+
+  bool is_ci( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h2 == 1;
+  }
+
+  bool is_pi( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h2 == 1 && !is_constant( n );
+  }
+
+  bool constant_value( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+#pragma endregion
+
+#pragma region Create unary functions
+  signal create_buf( signal const& a )
+  {
+    return a;
+  }
+
+  signal create_not( signal const& a )
+  {
+    return !a;
+  }
+#pragma endregion
+
+#pragma region Create binary / ternary functions
+  signal create_maj( signal a, signal b, signal c )
+  {
+    /* order inputs */
+    if ( a.index > b.index )
+    {
+      std::swap( a, b );
+      if ( b.index > c.index )
+        std::swap( b, c );
+      if ( a.index > b.index )
+        std::swap( a, b );
+    }
+    else
+    {
+      if ( b.index > c.index )
+        std::swap( b, c );
+      if ( a.index > b.index )
+        std::swap( a, b );
+    }
+
+    /* trivial cases */
+    if ( a.index == b.index )
+    {
+      return ( a.complement == b.complement ) ? a : c;
+    }
+    else if ( b.index == c.index )
+    {
+      return ( b.complement == c.complement ) ? b : a;
+    }
+
+    /*  complemented edges minimization */
+    auto node_complement = false;
+    if ( static_cast<unsigned>( a.complement ) + static_cast<unsigned>( b.complement ) +
+             static_cast<unsigned>( c.complement ) >=
+         2u )
+    {
+      node_complement = true;
+      a.complement = !a.complement;
+      b.complement = !b.complement;
+      c.complement = !c.complement;
+    }
+
+    storage::element_type::node_type node;
+    node.children[0] = a;
+    node.children[1] = b;
+    node.children[2] = c;
+
+    /* structural hashing */
+    const auto it = _storage->hash.find( node );
+    if ( it != _storage->hash.end() )
+    {
+      return { it->second, node_complement };
+    }
+
+    const auto index = _storage->nodes.size();
+
+    if ( index >= .9 * _storage->nodes.capacity() )
+    {
+      _storage->nodes.reserve( static_cast<uint64_t>( 3.1415f * index ) );
+      _storage->hash.reserve( static_cast<uint64_t>( 3.1415f * index ) );
+    }
+
+    _storage->nodes.push_back( node );
+
+    _storage->hash[node] = index;
+
+    /* increase ref-count to children */
+    _storage->nodes[a.index].data[0].h1++;
+    _storage->nodes[b.index].data[0].h1++;
+    _storage->nodes[c.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return { index, node_complement };
+  }
+
+  signal create_and( signal const& a, signal const& b )
+  {
+    return create_maj( get_constant( false ), a, b );
+  }
+
+  signal create_nand( signal const& a, signal const& b )
+  {
+    return !create_and( a, b );
+  }
+
+  signal create_or( signal const& a, signal const& b )
+  {
+    return create_maj( get_constant( true ), a, b );
+  }
+
+  signal create_nor( signal const& a, signal const& b )
+  {
+    return !create_or( a, b );
+  }
+
+  signal create_lt( signal const& a, signal const& b )
+  {
+    return create_and( !a, b );
+  }
+
+  signal create_le( signal const& a, signal const& b )
+  {
+    return !create_and( a, !b );
+  }
+
+  signal create_xor( signal const& a, signal const& b )
+  {
+    const auto fcompl = a.complement ^ b.complement;
+    const auto c1 = create_and( +a, -b );
+    const auto c2 = create_and( +b, -a );
+    return create_and( !c1, !c2 ) ^ !fcompl;
+  }
+
+  signal create_ite( signal cond, signal f_then, signal f_else )
+  {
+    bool f_compl{ false };
+    if ( f_then.index < f_else.index )
+    {
+      std::swap( f_then, f_else );
+      cond.complement ^= 1;
+    }
+    if ( f_then.complement )
+    {
+      f_then.complement = 0;
+      f_else.complement ^= 1;
+      f_compl = true;
+    }
+
+    return create_and( !create_and( !cond, f_else ), !create_and( cond, f_then ) ) ^ !f_compl;
+  }
+
+  signal create_xor3( signal const& a, signal const& b, signal const& c )
+  {
+    const auto f = create_maj( a, !b, c );
+    const auto g = create_maj( a, b, !c );
+    return create_maj( !a, f, g );
+  }
+#pragma endregion
+
+#pragma region Create nary functions
+  signal create_nary_and( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( true ), [this]( auto const& a, auto const& b ) { return create_and( a, b ); } );
+  }
+
+  signal create_nary_or( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_or( a, b ); } );
+  }
+
+  signal create_nary_xor( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_xor( a, b ); } );
+  }
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  signal clone_node( mig_network const& other, node const& source, std::vector<signal> const& children )
+  {
+    (void)other;
+    (void)source;
+    assert( children.size() == 3u );
+    return create_maj( children[0u], children[1u], children[2u] );
+  }
+#pragma endregion
+
+#pragma region Has node
+  std::optional<signal> has_maj( signal a, signal b, signal c )
+  {
+    /* order inputs */
+    if ( a.index > b.index )
+    {
+      std::swap( a, b );
+      if ( b.index > c.index )
+        std::swap( b, c );
+      if ( a.index > b.index )
+        std::swap( a, b );
+    }
+    else
+    {
+      if ( b.index > c.index )
+        std::swap( b, c );
+      if ( a.index > b.index )
+        std::swap( a, b );
+    }
+
+    /* trivial cases */
+    if ( a.index == b.index )
+    {
+      return ( a.complement == b.complement ) ? a : c;
+    }
+    else if ( b.index == c.index )
+    {
+      return ( b.complement == c.complement ) ? b : a;
+    }
+
+    /*  complemented edges minimization */
+    auto node_complement = false;
+    if ( static_cast<unsigned>( a.complement ) + static_cast<unsigned>( b.complement ) +
+             static_cast<unsigned>( c.complement ) >=
+         2u )
+    {
+      node_complement = true;
+      a.complement = !a.complement;
+      b.complement = !b.complement;
+      c.complement = !c.complement;
+    }
+
+    storage::element_type::node_type node;
+    node.children[0] = a;
+    node.children[1] = b;
+    node.children[2] = c;
+
+    /* structural hashing */
+    const auto it = _storage->hash.find( node );
+    if ( it != _storage->hash.end() )
+    {
+      assert( !is_dead( it->second ) );
+      return signal( it->second, node_complement );
+    }
+
+    return {};
+  }
+#pragma endregion
+
+#pragma region Restructuring
+  std::optional<std::pair<node, signal>> replace_in_node( node const& n, node const& old_node, signal new_signal )
+  {
+    auto& node = _storage->nodes[n];
+
+    uint32_t fanin = 0u;
+    for ( auto i = 0u; i < 4u; ++i )
+    {
+      if ( i == 3u )
+      {
+        return std::nullopt;
+      }
+
+      if ( node.children[i].index == old_node )
+      {
+        fanin = i;
+        new_signal.complement ^= node.children[i].weight;
+        break;
+      }
+    }
+
+    // determine potential new children of node n
+    signal child2 = new_signal;
+    signal child1 = node.children[( fanin + 1 ) % 3];
+    signal child0 = node.children[( fanin + 2 ) % 3];
+
+    if ( child0.index > child1.index )
+    {
+      std::swap( child0, child1 );
+    }
+    if ( child1.index > child2.index )
+    {
+      std::swap( child1, child2 );
+    }
+    if ( child0.index > child1.index )
+    {
+      std::swap( child0, child1 );
+    }
+
+    assert( child0.index <= child1.index );
+    assert( child1.index <= child2.index );
+
+    // check for trivial cases?
+    if ( child0.index == child1.index )
+    {
+      const auto diff_pol = child0.complement != child1.complement;
+      return std::make_pair( n, diff_pol ? child2 : child0 );
+    }
+    else if ( child1.index == child2.index )
+    {
+      const auto diff_pol = child1.complement != child2.complement;
+      return std::make_pair( n, diff_pol ? child0 : child1 );
+    }
+
+    // node already in hash table
+    storage::element_type::node_type _hash_obj;
+    _hash_obj.children[0] = child0;
+    _hash_obj.children[1] = child1;
+    _hash_obj.children[2] = child2;
+    if ( const auto it = _storage->hash.find( _hash_obj ); it != _storage->hash.end() && it->second != old_node )
+    {
+      return std::make_pair( n, signal( it->second, 0 ) );
+    }
+
+    // remember before
+    const auto old_child0 = signal{ node.children[0] };
+    const auto old_child1 = signal{ node.children[1] };
+    const auto old_child2 = signal{ node.children[2] };
+
+    // erase old node in hash table
+    _storage->hash.erase( node );
+
+    // insert updated node into hash table
+    node.children[0] = child0;
+    node.children[1] = child1;
+    node.children[2] = child2;
+    _storage->hash[node] = n;
+
+    // update the reference counter of the new signal
+    _storage->nodes[new_signal.index].data[0].h1++;
+    // update the reference counter of the old signal
+    _storage->nodes[old_node].data[0].h1--;
+
+    for ( auto const& fn : _events->on_modified )
+    {
+      ( *fn )( n, { old_child0, old_child1, old_child2 } );
+    }
+
+    return std::nullopt;
+  }
+
+  void replace_in_node_no_restrash( node const& n, node const& old_node, signal new_signal )
+  {
+    auto& node = _storage->nodes[n];
+
+    uint32_t fanin = 0u;
+    for ( auto i = 0u; i < 4u; ++i )
+    {
+      if ( i == 3u )
+      {
+        return;
+      }
+
+      if ( node.children[i].index == old_node )
+      {
+        fanin = i;
+        new_signal.complement ^= node.children[i].weight;
+        break;
+      }
+    }
+
+    // determine potential new children of node n
+    signal child2 = new_signal;
+    signal child1 = node.children[( fanin + 1 ) % 3];
+    signal child0 = node.children[( fanin + 2 ) % 3];
+
+    if ( child0.index > child1.index )
+    {
+      std::swap( child0, child1 );
+    }
+    if ( child1.index > child2.index )
+    {
+      std::swap( child1, child2 );
+    }
+    if ( child0.index > child1.index )
+    {
+      std::swap( child0, child1 );
+    }
+
+    assert( child0.index <= child1.index );
+    assert( child1.index <= child2.index );
+
+    // don't check for trivial cases
+
+    // remember before
+    const auto old_child0 = signal{ node.children[0] };
+    const auto old_child1 = signal{ node.children[1] };
+    const auto old_child2 = signal{ node.children[2] };
+
+    // erase old node in hash table
+    _storage->hash.erase( node );
+
+    // insert updated node into hash table
+    node.children[0] = child0;
+    node.children[1] = child1;
+    node.children[2] = child2;
+    if ( _storage->hash.find( node ) == _storage->hash.end() )
+    {
+      _storage->hash[node] = n;
+    }
+
+    // update the reference counter of the new signal
+    _storage->nodes[new_signal.index].data[0].h1++;
+    // update the reference counter of the old signal
+    _storage->nodes[old_node].data[0].h1--;
+
+    for ( auto const& fn : _events->on_modified )
+    {
+      ( *fn )( n, { old_child0, old_child1, old_child2 } );
+    }
+  }
+
+  void replace_in_outputs( node const& old_node, signal const& new_signal )
+  {
+    if ( is_dead( old_node ) )
+      return;
+
+    for ( auto& output : _storage->outputs )
+    {
+      if ( output.index == old_node )
+      {
+        output.index = new_signal.index;
+        output.weight ^= new_signal.complement;
+
+        if ( old_node != new_signal.index )
+        {
+          // increment fan-out of new node
+          _storage->nodes[new_signal.index].data[0].h1++;
+          // decrement fan-out of old node
+          _storage->nodes[old_node].data[0].h1--;
+        }
+      }
+    }
+  }
+
+  void take_out_node( node const& n )
+  {
+    /* we cannot delete CIs, constants, or already dead nodes */
+    if ( n == 0 || is_ci( n ) || is_dead( n ) )
+      return;
+
+    auto& nobj = _storage->nodes[n];
+    nobj.data[0].h1 = UINT32_C( 0x80000000 ); /* fanout size 0, but dead */
+    _storage->hash.erase( nobj );
+
+    for ( auto const& fn : _events->on_delete )
+    {
+      ( *fn )( n );
+    }
+
+    for ( auto i = 0u; i < 3u; ++i )
+    {
+      if ( fanout_size( nobj.children[i].index ) == 0 )
+      {
+        continue;
+      }
+      if ( decr_fanout_size( nobj.children[i].index ) == 0 )
+      {
+        take_out_node( nobj.children[i].index );
+      }
+    }
+  }
+
+  void revive_node( node const& n )
+  {
+    if ( !is_dead( n ) )
+      return;
+
+    assert( n < _storage->nodes.size() );
+    auto& nobj = _storage->nodes[n];
+    nobj.data[0].h1 = UINT32_C( 0 ); /* fanout size 0, but not dead (like just created) */
+    _storage->hash[nobj] = n;
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( n );
+    }
+
+    /* revive its children if dead, and increment their fanout_size */
+    for ( auto i = 0u; i < 3u; ++i )
+    {
+      if ( is_dead( nobj.children[i].index ) )
+      {
+        revive_node( nobj.children[i].index );
+      }
+      incr_fanout_size( nobj.children[i].index );
+    }
+  }
+
+  inline bool is_dead( node const& n ) const
+  {
+    return ( _storage->nodes[n].data[0].h1 >> 31 ) & 1;
+  }
+
+  void substitute_node( node const& old_node, signal const& new_signal )
+  {
+    std::unordered_map<node, signal> old_to_new;
+    std::stack<std::pair<node, signal>> to_substitute;
+    to_substitute.push( { old_node, new_signal } );
+
+    while ( !to_substitute.empty() )
+    {
+      const auto [_old, _curr] = to_substitute.top();
+      to_substitute.pop();
+
+      signal _new = _curr;
+      /* find the real new node */
+      if ( is_dead( get_node( _new ) ) )
+      {
+        auto it = old_to_new.find( get_node( _new ) );
+        while ( it != old_to_new.end() )
+        {
+          _new = is_complemented( _new ) ? create_not( it->second ) : it->second;
+          it = old_to_new.find( get_node( _new ) );
+        }
+      }
+      /* revive */
+      if ( is_dead( get_node( _new ) ) )
+      {
+        revive_node( get_node( _new ) );
+      }
+
+      for ( auto idx = 1u; idx < _storage->nodes.size(); ++idx )
+      {
+        if ( is_ci( idx ) || is_dead( idx ) )
+          continue; /* ignore CIs */
+
+        if ( const auto repl = replace_in_node( idx, _old, _new ); repl )
+        {
+          to_substitute.push( *repl );
+        }
+      }
+
+      /* check outputs */
+      replace_in_outputs( _old, _new );
+
+      // reset fan-in of old node
+      if ( _old != _new.index )
+      {
+        old_to_new.insert( { _old, _new } );
+        take_out_node( _old );
+      }
+    }
+  }
+
+  void substitute_node_no_restrash( node const& old_node, signal const& new_signal )
+  {
+    if ( is_dead( get_node( new_signal ) ) )
+    {
+      revive_node( get_node( new_signal ) );
+    }
+
+    for ( auto idx = 1u; idx < _storage->nodes.size(); ++idx )
+    {
+      if ( is_ci( idx ) || is_dead( idx ) )
+        continue; /* ignore CIs and dead nodes */
+
+      replace_in_node_no_restrash( idx, old_node, new_signal );
+    }
+
+    /* check outputs */
+    replace_in_outputs( old_node, new_signal );
+
+    /* recursively reset old node */
+    if ( old_node != new_signal.index )
+    {
+      take_out_node( old_node );
+    }
+  }
+#pragma endregion
+
+#pragma region Structural properties
+  auto size() const
+  {
+    return static_cast<uint32_t>( _storage->nodes.size() );
+  }
+
+  auto num_cis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_cos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  auto num_pis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_pos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  auto num_gates() const
+  {
+    return static_cast<uint32_t>( _storage->hash.size() );
+  }
+
+  uint32_t fanin_size( node const& n ) const
+  {
+    if ( is_constant( n ) || is_ci( n ) )
+      return 0;
+    return 3;
+  }
+
+  uint32_t fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1 & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t incr_fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1++ & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t decr_fanout_size( node const& n ) const
+  {
+    return --_storage->nodes[n].data[0].h1 & UINT32_C( 0x7FFFFFFF );
+  }
+
+  bool is_and( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_or( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_xor( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_maj( node const& n ) const
+  {
+    return n > 0 && !is_ci( n );
+  }
+
+  bool is_ite( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_xor3( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_and( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_or( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_xor( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+#pragma endregion
+
+#pragma region Functional properties
+  kitty::dynamic_truth_table node_function( const node& n ) const
+  {
+    (void)n;
+    kitty::dynamic_truth_table _maj( 3 );
+    _maj._bits[0] = 0xe8;
+    return _maj;
+  }
+#pragma endregion
+
+#pragma region Nodes and signals
+  node get_node( signal const& f ) const
+  {
+    return f.index;
+  }
+
+  signal make_signal( node const& n ) const
+  {
+    return signal( n, 0 );
+  }
+
+  bool is_complemented( signal const& f ) const
+  {
+    return f.complement;
+  }
+
+  uint32_t node_to_index( node const& n ) const
+  {
+    return static_cast<uint32_t>( n );
+  }
+
+  node index_to_node( uint32_t index ) const
+  {
+    return index;
+  }
+
+  node ci_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal co_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return *( _storage->outputs.begin() + index );
+  }
+
+  node pi_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal po_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return *( _storage->outputs.begin() + index );
+  }
+
+  uint32_t ci_index( node const& n ) const
+  {
+    assert( _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data &&
+            _storage->nodes[n].children[0].data == _storage->nodes[n].children[2].data );
+    return static_cast<uint32_t>( _storage->nodes[n].children[0].data );
+  }
+
+  uint32_t co_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_co( [&]( const auto& x, auto index ) {
+      if ( x == s )
+      {
+        i = index;
+        return false;
+      }
+      return true;
+    } );
+    return i;
+  }
+
+  uint32_t pi_index( node const& n ) const
+  {
+    assert( _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data &&
+            _storage->nodes[n].children[0].data == _storage->nodes[n].children[2].data );
+    return static_cast<uint32_t>( _storage->nodes[n].children[0].data );
+  }
+
+  uint32_t po_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_po( [&]( const auto& x, auto index ) {
+      if ( x == s )
+      {
+        i = index;
+        return false;
+      }
+      return true;
+    } );
+    return i;
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( _storage->nodes.size() );
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_dead( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_ci( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_co( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->outputs.begin(), _storage->outputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->outputs.begin(), _storage->outputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( 1u, _storage->nodes.size() ); // start from 1 to avoid constant
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_ci( n ) && !is_dead( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_fanin( node const& n, Fn&& fn ) const
+  {
+    if ( n == 0 || is_ci( n ) )
+      return;
+
+    static_assert( detail::is_callable_without_index_v<Fn, signal, bool> ||
+                   detail::is_callable_with_index_v<Fn, signal, bool> ||
+                   detail::is_callable_without_index_v<Fn, signal, void> ||
+                   detail::is_callable_with_index_v<Fn, signal, void> );
+
+    // we don't use foreach_element here to have better performance
+    if constexpr ( detail::is_callable_without_index_v<Fn, signal, bool> )
+    {
+      if ( !fn( signal{ _storage->nodes[n].children[0] } ) )
+        return;
+      if ( !fn( signal{ _storage->nodes[n].children[1] } ) )
+        return;
+      fn( signal{ _storage->nodes[n].children[2] } );
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, signal, bool> )
+    {
+      if ( !fn( signal{ _storage->nodes[n].children[0] }, 0 ) )
+        return;
+      if ( !fn( signal{ _storage->nodes[n].children[1] }, 1 ) )
+        return;
+      fn( signal{ _storage->nodes[n].children[2] }, 2 );
+    }
+    else if constexpr ( detail::is_callable_without_index_v<Fn, signal, void> )
+    {
+      fn( signal{ _storage->nodes[n].children[0] } );
+      fn( signal{ _storage->nodes[n].children[1] } );
+      fn( signal{ _storage->nodes[n].children[2] } );
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, signal, void> )
+    {
+      fn( signal{ _storage->nodes[n].children[0] }, 0 );
+      fn( signal{ _storage->nodes[n].children[1] }, 1 );
+      fn( signal{ _storage->nodes[n].children[2] }, 2 );
+    }
+  }
+#pragma endregion
+
+#pragma region Value simulation
+  template<typename Iterator>
+  iterates_over_t<Iterator, bool>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+    auto const& c3 = _storage->nodes[n].children[2];
+
+    auto v1 = *begin++;
+    auto v2 = *begin++;
+    auto v3 = *begin++;
+
+    return ( ( v1 ^ c1.weight ) && ( v2 ^ c2.weight ) ) || ( ( v3 ^ c3.weight ) && ( v1 ^ c1.weight ) ) || ( ( v3 ^ c3.weight ) && ( v2 ^ c2.weight ) );
+  }
+
+  template<typename Iterator>
+  iterates_over_truth_table_t<Iterator>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+    auto const& c3 = _storage->nodes[n].children[2];
+
+    auto tt1 = *begin++;
+    auto tt2 = *begin++;
+    auto tt3 = *begin++;
+
+    return kitty::ternary_majority( c1.weight ? ~tt1 : tt1, c2.weight ? ~tt2 : tt2, c3.weight ? ~tt3 : tt3 );
+  }
+
+  /*! \brief Re-compute the last block. */
+  template<typename Iterator>
+  void compute( node const& n, kitty::partial_truth_table& result, Iterator begin, Iterator end ) const
+  {
+    static_assert( iterates_over_v<Iterator, kitty::partial_truth_table>, "begin and end have to iterate over partial_truth_tables" );
+
+    (void)end;
+    assert( n != 0 && !is_ci( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+    auto const& c3 = _storage->nodes[n].children[2];
+
+    auto tt1 = *begin++;
+    auto tt2 = *begin++;
+    auto tt3 = *begin++;
+
+    assert( tt1.num_bits() > 0 && "truth tables must not be empty" );
+    assert( tt1.num_bits() == tt2.num_bits() );
+    assert( tt1.num_bits() == tt3.num_bits() );
+    assert( tt1.num_bits() >= result.num_bits() );
+    assert( result.num_blocks() == tt1.num_blocks() || ( result.num_blocks() == tt1.num_blocks() - 1 && result.num_bits() % 64 == 0 ) );
+
+    result.resize( tt1.num_bits() );
+    result._bits.back() =
+        ( ( c1.weight ? ~tt1._bits.back() : tt1._bits.back() ) & ( c2.weight ? ~tt2._bits.back() : tt2._bits.back() ) ) |
+        ( ( c1.weight ? ~tt1._bits.back() : tt1._bits.back() ) & ( c3.weight ? ~tt3._bits.back() : tt3._bits.back() ) ) |
+        ( ( c2.weight ? ~tt2._bits.back() : tt2._bits.back() ) & ( c3.weight ? ~tt3._bits.back() : tt3._bits.back() ) );
+    result.mask_bits();
+  }
+#pragma endregion
+
+#pragma region Custom node values
+  void clear_values() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[0].h2 = 0; } );
+  }
+
+  auto value( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h2;
+  }
+
+  void set_value( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[0].h2 = v;
+  }
+
+  auto incr_value( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h2++;
+  }
+
+  auto decr_value( node const& n ) const
+  {
+    return --_storage->nodes[n].data[0].h2;
+  }
+#pragma endregion
+
+#pragma region Visited flags
+  void clear_visited() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[1].h1 = 0; } );
+  }
+
+  auto visited( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h1;
+  }
+
+  void set_visited( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[1].h1 = v;
+  }
+
+  uint32_t trav_id() const
+  {
+    return _storage->trav_id;
+  }
+
+  void incr_trav_id() const
+  {
+    ++_storage->trav_id;
+  }
+#pragma endregion
+
+#pragma region General methods
+  auto& events() const
+  {
+    return *_events;
+  }
+#pragma endregion
+
+public:
+  std::shared_ptr<mig_storage> _storage;
+  std::shared_ptr<network_events<base_type>> _events;
+};
+
+} // namespace mockturtle
+
+namespace std
+{
+
+template<>
+struct hash<mockturtle::mig_network::signal>
+{
+  uint64_t operator()( mockturtle::mig_network::signal const& s ) const noexcept
+  {
+    uint64_t k = s.data;
+    k ^= k >> 33;
+    k *= 0xff51afd7ed558ccd;
+    k ^= k >> 33;
+    k *= 0xc4ceb9fe1a85ec53;
+    k ^= k >> 33;
+    return k;
+  }
+}; /* hash */
+
+} // namespace std
\ No newline at end of file
diff --git a/include/mockturtle/networks/muxig.hpp b/include/mockturtle/networks/muxig.hpp
new file mode 100644
index 0000000..b7f769a
--- /dev/null
+++ b/include/mockturtle/networks/muxig.hpp
@@ -0,0 +1,256 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file muxig.hpp
+  \brief  Mux-inverter graph logic network implementation
+
+  \author Dewmini Marakkalage
+  */
+
+#pragma once
+
+#include "tig.hpp"
+#include <iostream>
+
+namespace mockturtle
+{
+
+template<>
+struct compute_function<three_input_function::mux>
+{
+  template<typename T>
+  inline std::enable_if_t<kitty::is_truth_table<T>::value, T> operator()( T a, T b, T c )
+  {
+    return ternary_operation( a, b, c, []( auto a, auto b, auto c ) { return ( a & b ) | ( ~a & c ); } );
+  }
+
+  template<typename T>
+  inline std::enable_if_t<std::is_integral<T>::value, T> operator()( T a, T b, T c )
+  {
+    return ( a & b ) | ( ~a & c );
+  }
+};
+
+using muxig_signal = tig_network<three_input_function::mux>::signal;
+using muxig_network = tig_network<three_input_function::mux>;
+
+template<>
+inline muxig_network::normalization_result muxig_network::normalized_fanins_for_and( muxig_signal a, muxig_signal b )
+{
+  if ( a.index > b.index )
+  {
+    std::swap( a, b );
+  }
+
+  if ( a.index == 0 )
+  {
+    return { false, { a.complement ? b : get_constant( false ) } };
+  }
+
+  if ( a.index == b.index )
+  {
+    return { false, { ( a.complement == b.complement ) ? a : get_constant( false ) } };
+  }
+
+  return { false, { !a, get_constant( false ), b } };
+}
+
+template<>
+inline muxig_network::normalization_result muxig_network::normalized_fanins_for_xor( muxig_signal a, muxig_signal b )
+{
+  if ( a.index > b.index )
+  {
+    std::swap( a, b );
+  }
+
+  if ( a.index == 0 )
+  {
+    return { false, { a.complement ? !b : b } };
+  }
+
+  if ( a.index == b.index )
+  {
+    return { false, { get_constant( a.complement != b.complement ) } };
+  }
+
+  if ( b.complement )
+  {
+    // !(!a, !b, b) or (a, !b, b)
+    if ( a.complement )
+    {
+      return { true, { !a, !b, b } };
+    }
+    return { false, { a, !b, b } };
+  }
+
+  // (!a, b, !b) or !(a, b, !b)
+  if ( a.complement )
+  {
+    return { false, { !a, b, !b } };
+  }
+  return { true, { a, b, !b } };
+}
+
+template<>
+inline muxig_network::normalization_result muxig_network::normalized_fanins( muxig_signal a, muxig_signal b, muxig_signal c )
+{
+  /* mux(a b c) = a b + a' c */
+  /* always make sure that b is never inverted */
+  /* always make sure that b.index <= c.index */
+  /* if possible, make sure a is not inverted */
+  /* if possible, make sure that a.index < b.index */
+  /* else, if possible, make sure that a.index < c.index */
+
+  if ( a.index == 0 )
+  { // (1 b c) = b, (0 b c) = c,
+    return { false, { a.complement ? b : c } };
+  }
+
+  if ( a.complement )
+  {
+
+    return { false, { !a, c, b } };
+  }
+
+  if ( b.index == 0 )
+  {
+    if ( b.complement )
+    {
+      // (a 1 c) = a + a'c = a + c = (a'c')'
+      return complement( normalized_fanins_for_and( !a, !c ) );
+    }
+    // (a 0 c) = a'c
+    return normalized_fanins_for_and( !a, c );
+  }
+
+  if ( a.index == b.index )
+  {
+    if ( a.complement == b.complement )
+    {
+      // (a a c) = aa + a'c = a + c = (a'c')'
+      return complement( normalized_fanins_for_and( !a, !c ) );
+    }
+    // (a a' c) = aa' + a'c = a'c
+    return normalized_fanins_for_and( !a, c );
+  }
+
+  if ( a.index == c.index )
+  {
+    if ( a.complement == c.complement )
+    {
+      // (a b a) = ab + a'a = ab
+      return normalized_fanins_for_and( a, b );
+    }
+    // (a b a') == ab + a'a' = ab + a' = a' + b = (ab')'
+    return complement( normalized_fanins_for_and( a, !b ) );
+  }
+
+  if ( b.index == c.index )
+  {
+    if ( b.complement == c.complement )
+    {
+      // (a, b, b) = a b + a' b
+      return { false, { b } };
+    }
+    // (a, b, b') = a b + a' b' = a xnor b = (a xor b)'
+    return complement( normalized_fanins_for_xor( a, b ) );
+  }
+
+  // (a b c) = a b + a' c
+  if ( b.complement )
+  {
+    return { true, { a, !b, !c } };
+  }
+  return { false, { a, b, c } };
+}
+
+// implemented by jasper
+template<>
+inline muxig_network::normalization_result muxig_network::normalized_fanout( muxig_signal a, muxig_signal b, muxig_signal c)
+{
+  //We have an ANDNOT. can be converted to ORNOT to flip output inverter
+  if(b.index == 0 && b.complement == 0 && c.index != 0){
+    std::swap(a,c);
+    std::swap(b,c);
+    b = !b;
+    return { true, { c, a, !b } };
+  }
+
+  //We have an ORNOT. can be converted to ORAND to flip output inverter
+  if(c.index == 0 && c.complement == 1 && b.index != 0){
+    return { true, { b, !c, a } };
+  }
+
+  return { false, { a, b, c } };
+}
+
+template<>
+inline muxig_signal muxig_network::create_and( muxig_signal const& a, muxig_signal const& b )
+{
+  return create_gate( a, b, get_constant( false ) );
+}
+
+template<>
+inline muxig_signal muxig_network::create_xor( muxig_signal const& a, muxig_signal const& b )
+{
+  return create_gate( a, !b, b );
+}
+
+template<>
+inline muxig_signal muxig_network::create_maj( signal const& a, signal const& b, signal const& c )
+{
+  auto sel = !create_xor( a, b );
+  return create_gate( sel, a, c );
+}
+
+template<>
+inline muxig_signal muxig_network::create_ite( signal a, signal b, signal c )
+{
+  return create_gate( a, b, c );
+}
+
+template<>
+inline bool muxig_network::is_ite( node const& n ) const
+{
+  return true;
+}
+
+template<>
+inline bool muxig_network::is_mux( node const& n ) const
+{
+  return true;
+}
+
+template<>
+inline kitty::dynamic_truth_table muxig_network::node_function( const node& n ) const
+{
+  (void)n;
+  kitty::dynamic_truth_table tt( 3 );
+  tt._bits[0] = 0xd8;
+  return tt;
+}
+
+} // namespace mockturtle
diff --git a/include/mockturtle/networks/sequential.hpp b/include/mockturtle/networks/sequential.hpp
new file mode 100644
index 0000000..b854a86
--- /dev/null
+++ b/include/mockturtle/networks/sequential.hpp
@@ -0,0 +1,925 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file sequential.hpp
+  \brief Sequential extension to networks
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+#include "aig.hpp"
+#include "aqfp.hpp"
+#include "cover.hpp"
+#include "detail/foreach.hpp"
+#include "klut.hpp"
+#include "mig.hpp"
+#include "xag.hpp"
+#include "xmg.hpp"
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+template<class Ntk>
+struct is_aig_like : std::false_type
+{
+};
+
+template<>
+struct is_aig_like<aig_network> : std::true_type
+{
+};
+template<>
+struct is_aig_like<xag_network> : std::true_type
+{
+};
+template<>
+struct is_aig_like<mig_network> : std::true_type
+{
+};
+template<>
+struct is_aig_like<xmg_network> : std::true_type
+{
+};
+template<>
+struct is_aig_like<aqfp_network> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool is_aig_like_v = is_aig_like<Ntk>::value;
+
+} // namespace detail
+
+/*! \brief Register information */
+struct register_t
+{
+  /*! \brief Control (clocking or enabling) signal */
+  std::string control = "";
+  /*! \brief Initial (reset) value */
+  uint8_t init = 3;
+  /*! \brief Type of register or latch (active high/low, rising/falling edge) */
+  std::string type = "";
+};
+
+template<typename Ntk, bool aig_like = detail::is_aig_like_v<typename Ntk::base_type>>
+class sequential
+{
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  /*! \brief Creates a register output in the network.
+   *
+   * Each created register output is stored in a node and contributes
+   * to the size of the network.  Register outputs must be created
+   * after all primary inputs have been created and must have a
+   * corresponding register input that is created with `create_ri`.
+   *
+   * Register outputs serve as inputs for the network.
+   *
+   * Register outputs and register inputs always have to be created in
+   * pairs; they are associated to each other by index, i.e., the
+   * first created register output corresponds to the first created
+   * register input, etc.
+   */
+  signal create_ro();
+
+  /*! \brief Creates a register input in the network.
+   *
+   * A register input is not stored in terms of a node, and it also
+   * does not contribute to the size of the network.  A register input
+   * is created for a signal in the network and it is possible that
+   * multiple register inputs point to the same signal.  Register
+   * inputs must be created after all primary outputs have been
+   * created and must have a corresponding register output that is
+   * created with `create_ro`.
+   *
+   * Register inputs serve as outputs for the network.
+   *
+   * Register outputs and register inputs always have to be created in
+   * pairs; they are associated to each other by index, i.e., the
+   * first created register output corresponds to the first created
+   * register input, etc.
+   *
+   * \param f Signal that drives the created register input
+   */
+  uint32_t create_ri( signal const& f );
+
+  /*! \brief Checks whether a node is a combinational input (PI or RO). */
+  bool is_ci( node const& n ) const;
+
+  /*! \brief Checks whether a node is a register output. */
+  bool is_ro( node const& n ) const;
+
+  /*! \brief Checks whether the network is combinational.
+   *
+   * Returns true if and only if the network has no registers (neither
+   * register outputs nor register inputs).
+   */
+  bool is_combinational() const;
+
+  /*! \brief Returns the number of combinational inputs (PIs and ROs). */
+  auto num_cis() const;
+
+  /*! \brief Returns the number of combinational outputs (POs and RIs). */
+  auto num_cos() const;
+
+  /*! \brief Returns the number of registers.
+   *
+   * This number is usually equal to the number of register outputs
+   * and register inputs because they have to appear in pairs.  During
+   * the construction of a network, the number of register outputs and
+   * register inputs may diverge.
+   */
+  auto num_registers() const;
+
+  /*! \brief Returns the combinational input node for an index.
+   *
+   * \param index A value between 0 (inclusive) and the number of
+   *              combinational inputs (exclusive).
+   */
+  node ci_at( uint32_t index ) const;
+
+  /*! \brief Returns the combinational output signal for an index.
+   *
+   * \param index A value between 0 (inclusive) and the number of
+   *              combinational outputs (exclusive).
+   */
+  signal co_at( uint32_t index ) const;
+
+  /*! \brief Returns the register output node for an index.
+   *
+   * \param index A value between 0 (inclusive) and the number of
+   *              register outputs (exclusive).
+   */
+  node ro_at( uint32_t index ) const;
+
+  /*! \brief Returns the register input signal for an index.
+   *
+   * \param index A value between 0 (inclusive) and the number of
+   *              register inputs (exclusive).
+   */
+  signal ri_at( uint32_t index ) const;
+
+  /*! \brief Returns the index of a combinational input node.
+   *
+   * \param n A combinational input node.
+   * \return A value between 0 and num_cis()-1.
+   */
+  uint32_t ci_index( node const& n ) const;
+
+  /*! \brief Returns the index of a combinational output signal.
+   *
+   * \param n A combinational output signal.
+   * \return A value between 0 and num_cos()-1.
+   */
+  uint32_t co_index( signal const& s ) const;
+
+  /*! \brief Returns the index of a register output node.
+   *
+   * \param n A register output node.
+   * \return A value between 0 and num_cis()-num_pis()-1.
+   */
+  uint32_t ro_index( node const& n ) const;
+
+  /*! \brief Returns the index of a register input signal.
+   *
+   * \param n A register input signal.
+   * \return A value between 0 and num_cos()-num_pos()-1.
+   */
+  uint32_t ri_index( signal const& s ) const;
+
+  /*! \brief Returns the register input signal to a register output node.
+   *
+   * \param signal A signal of a register output.
+   */
+  signal ro_to_ri( signal const& s ) const;
+
+  /*! \brief Returns the register output node for a register input signal.
+   *
+   * \param signal A node of a register input.
+   */
+  node ri_to_ro( signal const& s ) const;
+
+  /*! \brief Calls ``fn`` on every combinational input node in the network.
+   *
+   * The order is in the same order as combinational inputs have been
+   * created with ``create_pi`` or ``create_ro``.  The parameter
+   * ``fn`` is any callable that must have one of the following four
+   * signatures.
+   * - ``void(node const&)``
+   * - ``void(node const&, uint32_t)``
+   * - ``bool(node const&)``
+   * - ``bool(node const&, uint32_t)``
+   *
+   * If ``fn`` has two parameters, the second parameter is an index starting
+   * from 0 and incremented in every iteration.  If ``fn`` returns a ``bool``,
+   * then it can interrupt the iteration by returning ``false``.
+   */
+  template<typename Fn>
+  void foreach_ci( Fn&& fn ) const;
+
+  /*! \brief Calls ``fn`` on every combinational output signal in the network.
+   *
+   * The order is in the same order as combinational outputs have been
+   * created with ``create_po`` or ``create_ri``.  The function is
+   * called on the signal that is driving the output and may occur
+   * more than once in the iteration, if it drives more than one
+   * output.  The parameter ``fn`` is any callable that must have one
+   * of the following four
+   * signatures.
+   * - ``void(signal const&)``
+   * - ``void(signal const&, uint32_t)``
+   * - ``bool(signal const&)``
+   * - ``bool(signal const&, uint32_t)``
+   *
+   * If ``fn`` has two parameters, the second parameter is an index starting
+   * from 0 and incremented in every iteration.  If ``fn`` returns a ``bool``,
+   * then it can interrupt the iteration by returning ``false``.
+   */
+  template<typename Fn>
+  void foreach_co( Fn&& fn ) const;
+
+  /*! \brief Calls ``fn`` on every register output node in the network.
+   *
+   * The order is in the same order as register outputs have been created with
+   * ``create_ro``.  The parameter ``fn`` is any callable that must have one of
+   * the following four signatures.
+   * - ``void(node const&)``
+   * - ``void(node const&, uint32_t)``
+   * - ``bool(node const&)``
+   * - ``bool(node const&, uint32_t)``
+   *
+   * If ``fn`` has two parameters, the second parameter is an index starting
+   * from 0 and incremented in every iteration.  If ``fn`` returns a ``bool``,
+   * then it can interrupt the iteration by returning ``false``.
+   */
+  template<typename Fn>
+  void foreach_ro( Fn&& fn ) const;
+
+  /*! \brief Calls ``fn`` on every register input signal in the network.
+   *
+   * The order is in the same order as register inputs have been created with
+   * ``create_ri``.  The function is called on the signal that is driving the
+   * output and may occur more than once in the iteration, if it drives more
+   * than one output.  The parameter ``fn`` is any callable that must have one
+   * of the following four signatures.
+   * - ``void(signal const&)``
+   * - ``void(signal const&, uint32_t)``
+   * - ``bool(signal const&)``
+   * - ``bool(signal const&, uint32_t)``
+   *
+   * If ``fn`` has two parameters, the second parameter is an index starting
+   * from 0 and incremented in every iteration.  If ``fn`` returns a ``bool``,
+   * then it can interrupt the iteration by returning ``false``.
+   */
+  template<typename Fn>
+  void foreach_ri( Fn&& fn ) const;
+
+  /*! \brief Calls ``fn`` on every pair of register input signal and
+   *         register output node in the network.
+   *
+   * Calls each pair of a register input signal and the associated
+   * register output node.  The parameter ``fn`` is any callable that
+   * must have one of the following four signatures.
+   * - ``void(std::pair<signal, node> const&)``
+   * - ``void(std::pair<signal, node> const&, uint32_t)``
+   * - ``bool(std::pair<signal, node> const&)``
+   * - ``bool(std::pair<signal, node> const&, uint32_t)``
+   *
+   * If ``fn`` has two parameters, the second parameter is an index starting
+   * from 0 and incremented in every iteration.  If ``fn`` returns a ``bool``,
+   * then it can interrupt the iteration by returning ``false``.
+   */
+  template<typename Fn>
+  void foreach_register( Fn&& fn ) const;
+
+  /*! \brief Sets the register information for an index.
+   *
+   * \param index A value between 0 (inclusive) and the number of
+   *              registers (exclusive).
+   * \param reg Register information to set.
+   */
+  void set_register( uint32_t index, register_t reg );
+
+  /*! \brief Returns the register information for an index.
+   *
+   * \param index A value between 0 (inclusive) and the number of
+   *              registers (exclusive).
+   * \return Register information (see ``register_t``).
+   */
+  register_t register_at( uint32_t index ) const;
+};
+
+template<typename Ntk>
+class sequential<Ntk, true> : public Ntk
+{
+public:
+  using base_type = typename Ntk::base_type;
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  struct sequential_information
+  {
+    uint32_t num_pis{ 0 };
+    uint32_t num_pos{ 0 };
+    std::vector<register_t> registers;
+  };
+
+  sequential()
+      : _sequential_storage( std::make_shared<sequential_information>() )
+  {
+    static_assert( std::is_same_v<base_type, aig_network> || std::is_same_v<base_type, xag_network> ||
+                       std::is_same_v<base_type, mig_network> || std::is_same_v<base_type, xmg_network> ||
+                       std::is_same_v<base_type, aqfp_network>,
+                   "Sequential interfaces extended for unknown network type. Please check the compatibility of implementations." );
+  }
+
+  sequential( storage base_storage )
+      : Ntk( base_storage ), _sequential_storage( std::make_shared<sequential_information>() )
+  {
+    static_assert( std::is_same_v<base_type, aig_network> || std::is_same_v<base_type, xag_network> ||
+                       std::is_same_v<base_type, mig_network> || std::is_same_v<base_type, xmg_network> ||
+                       std::is_same_v<base_type, aqfp_network>,
+                   "Sequential interfaces extended for unknown network type. Please check the compatibility of implementations." );
+  }
+
+  signal create_pi()
+  {
+    ++_sequential_storage->num_pis;
+    return Ntk::create_pi();
+  }
+
+  uint32_t create_po( signal const& f )
+  {
+    ++_sequential_storage->num_pos;
+    return Ntk::create_po( f );
+  }
+
+  signal create_ro()
+  {
+    _sequential_storage->registers.emplace_back();
+    return Ntk::create_pi();
+  }
+
+  uint32_t create_ri( signal const& f )
+  {
+    return Ntk::create_po( f );
+  }
+
+  bool is_combinational() const
+  {
+    return ( static_cast<uint32_t>( this->_storage->inputs.size() ) == _sequential_storage->num_pis &&
+             static_cast<uint32_t>( this->_storage->outputs.size() ) == _sequential_storage->num_pos );
+  }
+
+  bool is_ci( node const& n ) const
+  {
+    return Ntk::is_pi( n );
+  }
+
+  bool is_pi( node const& n ) const
+  {
+    return Ntk::is_pi( n ) && this->_storage->nodes[n].children[0].data < static_cast<uint64_t>( _sequential_storage->num_pis );
+  }
+
+  bool is_ro( node const& n ) const
+  {
+    return Ntk::is_pi( n ) && this->_storage->nodes[n].children[0].data >= static_cast<uint64_t>( _sequential_storage->num_pis );
+  }
+
+  auto num_cis() const
+  {
+    return static_cast<uint32_t>( this->_storage->inputs.size() );
+  }
+
+  auto num_cos() const
+  {
+    return static_cast<uint32_t>( this->_storage->outputs.size() );
+  }
+
+  auto num_pis() const
+  {
+    return _sequential_storage->num_pis;
+  }
+
+  auto num_pos() const
+  {
+    return _sequential_storage->num_pos;
+  }
+
+  auto num_registers() const
+  {
+    assert( static_cast<uint32_t>( this->_storage->inputs.size() - _sequential_storage->num_pis ) == static_cast<uint32_t>( this->_storage->outputs.size() - _sequential_storage->num_pos ) );
+    return static_cast<uint32_t>( this->_storage->inputs.size() - _sequential_storage->num_pis );
+  }
+
+  node pi_at( uint32_t index ) const
+  {
+    assert( index < _sequential_storage->num_pis );
+    return *( this->_storage->inputs.begin() + index );
+  }
+
+  signal po_at( uint32_t index ) const
+  {
+    assert( index < _sequential_storage->num_pos );
+    return *( this->_storage->outputs.begin() + index );
+  }
+
+  node ci_at( uint32_t index ) const
+  {
+    assert( index < this->_storage->inputs.size() );
+    return *( this->_storage->inputs.begin() + index );
+  }
+
+  signal co_at( uint32_t index ) const
+  {
+    assert( index < this->_storage->outputs.size() );
+    return *( this->_storage->outputs.begin() + index );
+  }
+
+  node ro_at( uint32_t index ) const
+  {
+    assert( index < this->_storage->inputs.size() - _sequential_storage->num_pis );
+    return *( this->_storage->inputs.begin() + _sequential_storage->num_pis + index );
+  }
+
+  signal ri_at( uint32_t index ) const
+  {
+    assert( index < this->_storage->outputs.size() - _sequential_storage->num_pos );
+    return *( this->_storage->outputs.begin() + _sequential_storage->num_pos + index );
+  }
+
+  void set_register( uint32_t index, register_t reg )
+  {
+    assert( index < _sequential_storage->registers.size() );
+    _sequential_storage->registers[index] = reg;
+  }
+
+  register_t register_at( uint32_t index ) const
+  {
+    assert( index < _sequential_storage->registers.size() );
+    return _sequential_storage->registers[index];
+  }
+
+  uint32_t pi_index( node const& n ) const
+  {
+    assert( this->_storage->nodes[n].children[0].data < _sequential_storage->num_pis );
+    return Ntk::pi_index( n );
+  }
+
+  uint32_t ci_index( node const& n ) const
+  {
+    return Ntk::pi_index( n );
+  }
+
+  uint32_t co_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_co( [&]( const auto& x, auto index ) {
+        if ( x == s )
+        {
+          i = index;
+          return false;
+        }
+        return true; } );
+    return i;
+  }
+
+  uint32_t ro_index( node const& n ) const
+  {
+    assert( this->_storage->nodes[n].children[0].data >= _sequential_storage->num_pis );
+    return Ntk::pi_index( n ) - _sequential_storage->num_pis;
+  }
+
+  uint32_t ri_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_ri( [&]( const auto& x, auto index ) {
+        if ( x == s )
+        {
+          i = index;
+          return false;
+        }
+        return true; } );
+    return i;
+  }
+
+  signal ro_to_ri( signal const& s ) const
+  {
+    return *( this->_storage->outputs.begin() + _sequential_storage->num_pos + this->_storage->nodes[s.index].children[0].data - _sequential_storage->num_pis );
+  }
+
+  node ri_to_ro( signal const& s ) const
+  {
+    return *( this->_storage->inputs.begin() + _sequential_storage->num_pis + ri_index( s ) );
+  }
+
+  template<typename Fn>
+  void foreach_ci( Fn&& fn ) const
+  {
+    detail::foreach_element( this->_storage->inputs.begin(), this->_storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_co( Fn&& fn ) const
+  {
+    detail::foreach_element( this->_storage->outputs.begin(), this->_storage->outputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( this->_storage->inputs.begin(), this->_storage->inputs.begin() + _sequential_storage->num_pis, fn );
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    detail::foreach_element( this->_storage->outputs.begin(), this->_storage->outputs.begin() + _sequential_storage->num_pos, fn );
+  }
+
+  template<typename Fn>
+  void foreach_ro( Fn&& fn ) const
+  {
+    detail::foreach_element( this->_storage->inputs.begin() + _sequential_storage->num_pis, this->_storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_ri( Fn&& fn ) const
+  {
+    detail::foreach_element( this->_storage->outputs.begin() + _sequential_storage->num_pos, this->_storage->outputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_register( Fn&& fn ) const
+  {
+    static_assert( detail::is_callable_with_index_v<Fn, std::pair<signal, node>, void> ||
+                   detail::is_callable_without_index_v<Fn, std::pair<signal, node>, void> ||
+                   detail::is_callable_with_index_v<Fn, std::pair<signal, node>, bool> ||
+                   detail::is_callable_without_index_v<Fn, std::pair<signal, node>, bool> );
+
+    assert( this->_storage->inputs.size() - _sequential_storage->num_pis == this->_storage->outputs.size() - _sequential_storage->num_pos );
+    auto ro = this->_storage->inputs.begin() + _sequential_storage->num_pis;
+    auto ri = this->_storage->outputs.begin() + _sequential_storage->num_pos;
+    if constexpr ( detail::is_callable_without_index_v<Fn, std::pair<signal, node>, bool> )
+    {
+      while ( ro != this->_storage->inputs.end() && ri != this->_storage->outputs.end() )
+      {
+        if ( !fn( std::make_pair( ri++, ro++ ) ) )
+          return;
+      }
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, std::pair<signal, node>, bool> )
+    {
+      uint32_t index{ 0 };
+      while ( ro != this->_storage->inputs.end() && ri != this->_storage->outputs.end() )
+      {
+        if ( !fn( std::make_pair( ri++, ro++ ), index++ ) )
+          return;
+      }
+    }
+    else if constexpr ( detail::is_callable_without_index_v<Fn, std::pair<signal, node>, void> )
+    {
+      while ( ro != this->_storage->inputs.end() && ri != this->_storage->outputs.end() )
+      {
+        fn( std::make_pair( *ri++, *ro++ ) );
+      }
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, std::pair<signal, node>, void> )
+    {
+      uint32_t index{ 0 };
+      while ( ro != this->_storage->inputs.end() && ri != this->_storage->outputs.end() )
+      {
+        fn( std::make_pair( *ri++, *ro++ ), index++ );
+      }
+    }
+  }
+
+public:
+  std::shared_ptr<sequential_information> _sequential_storage;
+}; // class sequential<Ntk, true>
+
+template<typename Ntk>
+class sequential<Ntk, false> : public Ntk
+{
+public:
+  using base_type = typename Ntk::base_type;
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  struct sequential_information
+  {
+    uint32_t num_pis{ 0 };
+    uint32_t num_pos{ 0 };
+    std::vector<register_t> registers;
+  };
+
+  sequential()
+      : _sequential_storage( std::make_shared<sequential_information>() )
+  {
+    static_assert( std::is_same_v<base_type, klut_network> || std::is_same_v<base_type, cover_network>,
+                   "Sequential interfaces extended for unknown network type. Please check the compatibility of implementations." );
+  }
+
+  sequential( storage base_storage )
+      : Ntk( base_storage ), _sequential_storage( std::make_shared<sequential_information>() )
+  {
+    static_assert( std::is_same_v<base_type, klut_network> || std::is_same_v<base_type, cover_network>,
+                   "Sequential interfaces extended for unknown network type. Please check the compatibility of implementations." );
+  }
+
+  signal create_pi()
+  {
+    ++_sequential_storage->num_pis;
+    return Ntk::create_pi();
+  }
+
+  uint32_t create_po( signal const& f )
+  {
+    ++_sequential_storage->num_pos;
+    return Ntk::create_po( f );
+  }
+
+  signal create_ro()
+  {
+    _sequential_storage->registers.emplace_back();
+    return Ntk::create_pi();
+  }
+
+  uint32_t create_ri( signal const& f )
+  {
+    return Ntk::create_po( f );
+  }
+
+  bool is_combinational() const
+  {
+    return ( static_cast<uint32_t>( this->_storage->inputs.size() ) == _sequential_storage->num_pis &&
+             static_cast<uint32_t>( this->_storage->outputs.size() ) == _sequential_storage->num_pos );
+  }
+
+  bool is_ci( node const& n ) const
+  {
+    return std::find( this->_storage->inputs.begin(), this->_storage->inputs.end(), n ) != this->_storage->inputs.end();
+  }
+
+  bool is_pi( node const& n ) const
+  {
+    const auto end = this->_storage->inputs.begin() + _sequential_storage->num_pis;
+    return std::find( this->_storage->inputs.begin(), end, n ) != end;
+  }
+
+  bool is_ro( node const& n ) const
+  {
+    return std::find( this->_storage->inputs.begin() + _sequential_storage->num_pis, this->_storage->inputs.end(), n ) != this->_storage->inputs.end();
+  }
+
+  auto num_cis() const
+  {
+    return static_cast<uint32_t>( this->_storage->inputs.size() );
+  }
+
+  auto num_cos() const
+  {
+    return static_cast<uint32_t>( this->_storage->outputs.size() );
+  }
+
+  auto num_pis() const
+  {
+    return _sequential_storage->num_pis;
+  }
+
+  auto num_pos() const
+  {
+    return _sequential_storage->num_pos;
+  }
+
+  auto num_registers() const
+  {
+    assert( static_cast<uint32_t>( this->_storage->inputs.size() - _sequential_storage->num_pis ) == static_cast<uint32_t>( this->_storage->outputs.size() - _sequential_storage->num_pos ) );
+    return static_cast<uint32_t>( this->_storage->inputs.size() - _sequential_storage->num_pis );
+  }
+
+  node pi_at( uint32_t index ) const
+  {
+    assert( index < _sequential_storage->num_pis );
+    return *( this->_storage->inputs.begin() + index );
+  }
+
+  signal po_at( uint32_t index ) const
+  {
+    assert( index < _sequential_storage->num_pos );
+    return ( this->_storage->outputs.begin() + index )->index;
+  }
+
+  node ci_at( uint32_t index ) const
+  {
+    assert( index < this->_storage->inputs.size() );
+    return *( this->_storage->inputs.begin() + index );
+  }
+
+  signal co_at( uint32_t index ) const
+  {
+    assert( index < this->_storage->outputs.size() );
+    return ( this->_storage->outputs.begin() + index )->index;
+  }
+
+  node ro_at( uint32_t index ) const
+  {
+    assert( index < this->_storage->inputs.size() - _sequential_storage->num_pis );
+    return *( this->_storage->inputs.begin() + _sequential_storage->num_pis + index );
+  }
+
+  signal ri_at( uint32_t index ) const
+  {
+    assert( index < this->_storage->outputs.size() - _sequential_storage->num_pos );
+    return ( this->_storage->outputs.begin() + _sequential_storage->num_pos + index )->index;
+  }
+
+  void set_register( uint32_t index, register_t reg )
+  {
+    assert( index < _sequential_storage->registers.size() );
+    _sequential_storage->registers[index] = reg;
+  }
+
+  register_t register_at( uint32_t index ) const
+  {
+    assert( index < _sequential_storage->registers.size() );
+    return _sequential_storage->registers[index];
+  }
+
+  uint32_t pi_index( node const& n ) const
+  {
+    assert( this->_storage->nodes[n].children[0].data < _sequential_storage->num_pis );
+    return Ntk::pi_index( n );
+  }
+
+  uint32_t ci_index( node const& n ) const
+  {
+    return Ntk::pi_index( n );
+  }
+
+  uint32_t co_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_co( [&]( const auto& x, auto index ) {
+        if ( x == s )
+        {
+          i = index;
+          return false;
+        }
+        return true; } );
+    return i;
+  }
+
+  uint32_t ro_index( node const& n ) const
+  {
+    assert( this->_storage->nodes[n].children[0].data >= _sequential_storage->num_pis );
+    return Ntk::pi_index( n ) - _sequential_storage->num_pis;
+  }
+
+  uint32_t ri_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_ri( [&]( const auto& x, auto index ) {
+        if ( x == s )
+        {
+          i = index;
+          return false;
+        }
+        return true; } );
+    return i;
+  }
+
+  signal ro_to_ri( signal const& s ) const
+  {
+    return *( this->_storage->outputs.begin() + _sequential_storage->num_pos + this->_storage->nodes[s.index].children[0].data - _sequential_storage->num_pis );
+  }
+
+  node ri_to_ro( signal const& s ) const
+  {
+    return *( this->_storage->inputs.begin() + _sequential_storage->num_pis + ri_index( s ) );
+  }
+
+  template<typename Fn>
+  void foreach_ci( Fn&& fn ) const
+  {
+    detail::foreach_element( this->_storage->inputs.begin(), this->_storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_co( Fn&& fn ) const
+  {
+    using IteratorType = decltype( this->_storage->outputs.begin() );
+    detail::foreach_element_transform<IteratorType, uint32_t>(
+        this->_storage->outputs.begin(), this->_storage->outputs.end(), []( auto o ) { return o.index; }, fn );
+  }
+
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( this->_storage->inputs.begin(), this->_storage->inputs.begin() + _sequential_storage->num_pis, fn );
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    using IteratorType = decltype( this->_storage->outputs.begin() );
+    detail::foreach_element_transform<IteratorType, uint32_t>(
+        this->_storage->outputs.begin(), this->_storage->outputs.begin() + _sequential_storage->num_pos, []( auto o ) { return o.index; }, fn );
+  }
+
+  template<typename Fn>
+  void foreach_ro( Fn&& fn ) const
+  {
+    detail::foreach_element( this->_storage->inputs.begin() + _sequential_storage->num_pis, this->_storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_ri( Fn&& fn ) const
+  {
+    using IteratorType = decltype( this->_storage->outputs.begin() );
+    detail::foreach_element_transform<IteratorType, uint32_t>(
+        this->_storage->outputs.begin() + _sequential_storage->num_pos, this->_storage->outputs.end(), []( auto o ) { return o.index; }, fn );
+  }
+
+  template<typename Fn>
+  void foreach_register( Fn&& fn ) const
+  {
+    static_assert( detail::is_callable_with_index_v<Fn, std::pair<signal, node>, void> ||
+                   detail::is_callable_without_index_v<Fn, std::pair<signal, node>, void> ||
+                   detail::is_callable_with_index_v<Fn, std::pair<signal, node>, bool> ||
+                   detail::is_callable_without_index_v<Fn, std::pair<signal, node>, bool> );
+
+    assert( this->_storage->inputs.size() - _sequential_storage->num_pis == this->_storage->outputs.size() - _sequential_storage->num_pos );
+    auto ro = this->_storage->inputs.begin() + _sequential_storage->num_pis;
+    auto ri = this->_storage->outputs.begin() + _sequential_storage->num_pos;
+    if constexpr ( detail::is_callable_without_index_v<Fn, std::pair<signal, node>, bool> )
+    {
+      while ( ro != this->_storage->inputs.end() && ri != this->_storage->outputs.end() )
+      {
+        if ( !fn( std::make_pair( ri++, ro++ ) ) )
+          return;
+      }
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, std::pair<signal, node>, bool> )
+    {
+      uint32_t index{ 0 };
+      while ( ro != this->_storage->inputs.end() && ri != this->_storage->outputs.end() )
+      {
+        if ( !fn( std::make_pair( ri++, ro++ ), index++ ) )
+          return;
+      }
+    }
+    else if constexpr ( detail::is_callable_without_index_v<Fn, std::pair<signal, node>, void> )
+    {
+      while ( ro != this->_storage->inputs.end() && ri != this->_storage->outputs.end() )
+      {
+        fn( std::make_pair( *ri++, *ro++ ) );
+      }
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, std::pair<signal, node>, void> )
+    {
+      uint32_t index{ 0 };
+      while ( ro != this->_storage->inputs.end() && ri != this->_storage->outputs.end() )
+      {
+        fn( std::make_pair( *ri++, *ro++ ), index++ );
+      }
+    }
+  }
+
+public:
+  std::shared_ptr<sequential_information> _sequential_storage;
+}; // class sequential<Ntk, false>
+
+} // namespace mockturtle
diff --git a/include/mockturtle/networks/storage.hpp b/include/mockturtle/networks/storage.hpp
new file mode 100644
index 0000000..85a2b42
--- /dev/null
+++ b/include/mockturtle/networks/storage.hpp
@@ -0,0 +1,259 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file storage.hpp
+  \brief Configurable storage container
+
+  \author Alessandro Tempia Calvino
+  \author Andrea Costamagna
+  \author Bruno Schmitt
+  \author Heinz Riener
+  \author Jinzheng Tu
+  \author Mathias Soeken
+  \author Max Austin
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <array>
+#include <iostream>
+#include <unordered_map>
+#include <vector>
+
+#include <parallel_hashmap/phmap.h>
+
+namespace mockturtle
+{
+
+template<int PointerFieldSize = 0>
+struct node_pointer
+{
+private:
+  static constexpr auto _len = sizeof( uint64_t ) * 8;
+
+public:
+  node_pointer() = default;
+  node_pointer( uint64_t index, uint64_t weight ) : weight( weight ), index( index ) {}
+  node_pointer( uint64_t data ) : data( data ) {}
+
+  union
+  {
+    struct
+    {
+      uint64_t weight : PointerFieldSize;
+      uint64_t index : _len - PointerFieldSize;
+    };
+    uint64_t data;
+  };
+
+  bool operator==( node_pointer<PointerFieldSize> const& other ) const
+  {
+    return data == other.data;
+  }
+
+  bool operator!=( node_pointer<PointerFieldSize> const& other ) const
+  {
+    return data != other.data;
+  }
+};
+
+template<>
+struct node_pointer<0>
+{
+public:
+  node_pointer() = default;
+  node_pointer( uint64_t index ) : index( index ) {}
+
+  union
+  {
+    uint64_t index;
+    uint64_t data;
+  };
+
+  bool operator==( node_pointer<0> const& other ) const
+  {
+    return data == other.data;
+  }
+};
+
+union cauint64_t
+{
+  uint64_t n{ 0 };
+  struct
+  {
+    uint64_t h1 : 32;
+    uint64_t h2 : 32;
+  };
+  struct
+  {
+    uint64_t q1 : 16;
+    uint64_t q2 : 16;
+    uint64_t q3 : 16;
+    uint64_t q4 : 16;
+  };
+};
+
+template<int Fanin, int Size = 0, int PointerFieldSize = 0>
+struct regular_node
+{
+  using pointer_type = node_pointer<PointerFieldSize>;
+
+  std::array<pointer_type, Fanin> children;
+  std::array<cauint64_t, Size> data;
+
+  bool operator==( regular_node<Fanin, Size, PointerFieldSize> const& other ) const
+  {
+    return children == other.children;
+  }
+};
+
+template<int Size = 0, int PointerFieldSize = 0>
+struct mixed_fanin_node
+{
+  using pointer_type = node_pointer<PointerFieldSize>;
+
+  std::vector<pointer_type> children;
+  std::array<cauint64_t, Size> data;
+
+  bool operator==( mixed_fanin_node<Size, PointerFieldSize> const& other ) const
+  {
+    return children == other.children;
+  }
+};
+
+template<int PointerFieldSize = 0>
+struct block_fanin_node
+{
+  using pointer_type = node_pointer<PointerFieldSize>;
+
+  std::vector<pointer_type> children;
+  std::vector<cauint64_t> data;
+
+  bool operator==( block_fanin_node<PointerFieldSize> const& other ) const
+  {
+    return children == other.children;
+  }
+};
+
+/*! \brief Hash function for 64-bit word */
+inline uint64_t hash_block( uint64_t word )
+{
+  /* from boost::hash_detail::hash_value_unsigned */
+  return word ^ ( word + ( word << 6 ) + ( word >> 2 ) );
+}
+
+/*! \brief Combines two hash values */
+inline void hash_combine( uint64_t& seed, uint64_t other )
+{
+  /* from boost::hash_detail::hash_combine_impl */
+  const uint64_t m = UINT64_C( 0xc6a4a7935bd1e995 );
+  const int r = 47;
+
+  other *= m;
+  other ^= other >> r;
+  other *= m;
+
+  seed ^= other;
+  seed *= m;
+
+  seed += 0xe6546b64;
+}
+
+template<typename Node>
+struct node_hash
+{
+  uint64_t operator()( const Node& n ) const
+  {
+    if ( n.children.size() == 0 )
+      return 0;
+
+    auto it = std::begin( n.children );
+    auto seed = hash_block( it->data );
+    ++it;
+
+    while ( it != std::end( n.children ) )
+    {
+      hash_combine( seed, hash_block( it->data ) );
+      ++it;
+    }
+
+    return seed;
+  }
+};
+
+struct empty_storage_data
+{
+};
+
+template<typename Node, typename T = empty_storage_data, typename NodeHasher = node_hash<Node>>
+struct storage
+{
+  storage()
+  {
+    nodes.reserve( 10000u );
+    hash.reserve( 10000u );
+
+    /* we generally reserve the first node for a constant */
+    nodes.emplace_back();
+  }
+
+  using node_type = Node;
+
+  uint32_t trav_id = 0u;
+
+  std::vector<node_type> nodes;
+  std::vector<uint64_t> inputs;
+  std::vector<typename node_type::pointer_type> outputs;
+
+  phmap::flat_hash_map<node_type, uint64_t, NodeHasher> hash;
+
+  T data;
+};
+
+template<typename Node, typename T = empty_storage_data>
+struct storage_no_hash
+{
+  storage_no_hash()
+  {
+    nodes.reserve( 10000u );
+
+    /* we generally reserve the first node for a constant */
+    nodes.emplace_back();
+  }
+
+  using node_type = Node;
+
+  uint32_t trav_id = 0u;
+
+  std::vector<node_type> nodes;
+  std::vector<uint64_t> inputs;
+  std::vector<typename node_type::pointer_type> outputs;
+
+  T data;
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/networks/tig.hpp b/include/mockturtle/networks/tig.hpp
new file mode 100644
index 0000000..8a95d26
--- /dev/null
+++ b/include/mockturtle/networks/tig.hpp
@@ -0,0 +1,1134 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file tig.hpp
+  \brief Three-input-gate-inverter graph logic network implementation
+
+  \author Dewmini Marakkalage
+  */
+
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <stack>
+#include <string>
+
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/operators.hpp>
+
+#include "../traits.hpp"
+#include "../utils/algorithm.hpp"
+#include "detail/foreach.hpp"
+#include "events.hpp"
+#include "storage.hpp"
+
+namespace mockturtle
+{
+enum class three_input_function
+{
+  dot,
+  onehot,
+  mux,
+  andxor,
+  xorand,
+  gamble,
+  orand,
+  majority,
+  and3,
+  xor3
+};
+
+/* Remark: Must be specialized. */
+template<three_input_function Fn>
+struct compute_function
+{
+  template<typename T>
+  std::enable_if_t<kitty::is_truth_table<T>::value, T> operator()( T a, T b, T c );
+
+  template<typename T>
+  std::enable_if_t<std::is_integral<T>::value, T> operator()( T a, T b, T c );
+};
+
+using tig_storage = storage<regular_node<3, 2, 1>>;
+
+struct tig_signal
+{
+  tig_signal() = default;
+
+  tig_signal( uint64_t index, uint64_t complement )
+      : complement( complement ), index( index )
+  {
+  }
+
+  explicit tig_signal( uint64_t data )
+      : data( data )
+  {
+  }
+
+  tig_signal( tig_storage::node_type::pointer_type const& p )
+      : complement( p.weight ), index( p.index )
+  {
+  }
+
+  union
+  {
+    struct
+    {
+      uint64_t complement : 1;
+      uint64_t index : 63;
+    };
+    uint64_t data;
+  };
+
+  tig_signal operator!() const
+  {
+    return tig_signal( data ^ 1 );
+  }
+
+  tig_signal operator+() const
+  {
+    return { index, 0 };
+  }
+
+  tig_signal operator-() const
+  {
+    return { index, 1 };
+  }
+
+  tig_signal operator^( bool complement ) const
+  {
+    return tig_signal( data ^ ( complement ? 1 : 0 ) );
+  }
+
+  bool operator==( tig_signal const& other ) const
+  {
+    return data == other.data;
+  }
+
+  bool operator!=( tig_signal const& other ) const
+  {
+    return data != other.data;
+  }
+
+  bool operator<( tig_signal const& other ) const
+  {
+    return data < other.data;
+  }
+
+  operator tig_storage::node_type::pointer_type() const
+  {
+    return { index, complement };
+  }
+
+#if __cplusplus > 201703L
+  bool operator==( tig_storage::node_type::pointer_type const& other ) const
+  {
+    return data == other.data;
+  }
+#endif
+};
+
+/*! \brief T-Inverter-Graph storage container
+  TIGs have nodes with fan-in 3.  We split of one bit of the index pointer to
+  store a complemented attribute.  Every node has 64-bit of additional data
+  used for the following purposes:
+  `data[0].h1`: Fan-out size (we use MSB to indicate whether a node is dead)
+  `data[0].h2`: Application-specific value
+  `data[1].h1`: Visited flag
+  */
+
+template<three_input_function NodeFunc>
+class tig_network
+{
+public:
+#pragma region Types and constructors
+  static constexpr auto min_fanin_size = 3u;
+  static constexpr auto max_fanin_size = 3u;
+
+  using base_type = tig_network<NodeFunc>;
+  using storage = std::shared_ptr<tig_storage>;
+  using node = uint64_t;
+  using signal = tig_signal;
+
+  tig_network()
+      : _storage( std::make_shared<tig_storage>() ),
+        _events( std::make_shared<typename decltype( _events )::element_type>() )
+  {
+  }
+
+  tig_network( std::shared_ptr<tig_storage> storage )
+      : _storage( storage ),
+        _events( std::make_shared<typename decltype( _events )::element_type>() )
+  {
+  }
+
+  tig_network clone() const
+  {
+    return { std::make_shared<tig_storage>( *_storage ) };
+  }
+#pragma endregion
+
+#pragma region Primary I / O and constants
+  signal get_constant( bool value ) const
+  {
+    return { 0, static_cast<uint64_t>( value ? 1 : 0 ) };
+  }
+
+  signal create_pi()
+  {
+    const auto index = _storage->nodes.size();
+    auto& node = _storage->nodes.emplace_back();
+    node.children[0].data = node.children[1].data = node.children[2].data = _storage->inputs.size();
+    _storage->inputs.emplace_back( index );
+    return { index, 0 };
+  }
+
+  uint32_t create_po( signal const& f )
+  {
+    /* increase ref-count to children */
+    _storage->nodes[f.index].data[0].h1++;
+    auto const po_index = static_cast<uint32_t>( _storage->outputs.size() );
+    _storage->outputs.emplace_back( f.index, f.complement );
+    return po_index;
+  }
+
+  bool is_combinational() const
+  {
+    return true;
+  }
+
+  bool is_constant( node const& n ) const
+  {
+    return n == 0;
+  }
+
+  bool is_ci( node const& n ) const
+  {
+    return _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data && _storage->nodes[n].children[0].data == _storage->nodes[n].children[2].data;
+  }
+
+  bool is_pi( node const& n ) const
+  {
+    return _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data && _storage->nodes[n].children[0].data == _storage->nodes[n].children[2].data && !is_constant( n );
+  }
+
+  bool constant_value( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+#pragma endregion
+
+#pragma region Create unary functions
+  signal create_buf( signal const& a )
+  {
+    return a;
+  }
+
+  signal create_not( signal const& a )
+  {
+    return !a;
+  }
+#pragma endregion
+
+#pragma region Create binary / ternary functions
+
+  struct normalization_result
+  {
+    bool output_compl;
+    std::vector<signal> fanins;
+  };
+
+  /*!
+   * \brief Normalizes fanins. If the gate degenerates to a single fanin, sets
+   *  the first fanin in the return value to the corresponding degenerate signal.
+   *  Remark: Must be specialized in each three-input-gate-network type.
+   */
+  normalization_result normalized_fanins( signal a, signal b, signal c );
+  normalization_result normalized_fanout( signal a, signal b, signal c );
+
+  signal create_gate( signal a, signal b, signal c )
+  {
+    auto norm_res = normalized_fanins( a, b, c );
+
+    if ( norm_res.fanins.size() == 1u )
+    {
+      return norm_res.fanins[0];
+    }
+
+    storage::element_type::node_type node;
+    node.children[0] = norm_res.fanins[0];
+    node.children[1] = norm_res.fanins[1];
+    node.children[2] = norm_res.fanins[2];
+
+    /* structural hashing */
+    const auto it = _storage->hash.find( node );
+    if ( it != _storage->hash.end() )
+    {
+      return { it->second, norm_res.output_compl };
+    }
+
+    const auto index = _storage->nodes.size();
+
+    if ( index >= .9 * _storage->nodes.capacity() )
+    {
+      _storage->nodes.reserve( static_cast<uint64_t>( 3.1415f * index ) );
+      _storage->hash.reserve( static_cast<uint64_t>( 3.1415f * index ) );
+    }
+
+    _storage->nodes.push_back( node );
+
+    _storage->hash[node] = index;
+
+    /* increase ref-count to children */
+    _storage->nodes[a.index].data[0].h1++;
+    _storage->nodes[b.index].data[0].h1++;
+    _storage->nodes[c.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return { index, norm_res.output_compl };
+  }
+
+  /* Remark: Must be specialized. */
+  signal create_and( signal const& a, signal const& b );
+
+  signal create_nand( signal const& a, signal const& b )
+  {
+    return !create_and( a, b );
+  }
+
+  signal create_or( signal const& a, signal const& b )
+  {
+    return !create_and( !a, !b );
+  }
+
+  signal create_nor( signal const& a, signal const& b )
+  {
+    return !create_or( a, b );
+  }
+
+  signal create_lt( signal const& a, signal const& b )
+  {
+    return create_and( !a, b );
+  }
+
+  signal create_le( signal const& a, signal const& b )
+  {
+    return !create_and( a, !b );
+  }
+
+  /* Remark: To be specialized. */
+  signal create_xor( signal const& a, signal const& b )
+  {
+    const auto fcompl = a.complement ^ b.complement;
+    const auto c1 = create_and( +a, -b );
+    const auto c2 = create_and( +b, -a );
+    return create_and( !c1, !c2 ) ^ !fcompl;
+  }
+
+  /* Remark: To be specialized. */
+  signal create_maj( signal const& a, signal const& b, signal const& c )
+  {
+    return create_or( create_and( a, b ), create_and( c, create_or( a, b ) ) );
+  }
+
+  /* Remark: To be specialized. */
+  signal create_ite( signal cond, signal f_then, signal f_else )
+  {
+    bool f_compl{ false };
+    if ( f_then.index < f_else.index )
+    {
+      std::swap( f_then, f_else );
+      cond.complement ^= 1;
+    }
+    if ( f_then.complement )
+    {
+      f_then.complement = 0;
+      f_else.complement ^= 1;
+      f_compl = true;
+    }
+
+    return create_and( !create_and( !cond, f_else ), !create_and( cond, f_then ) ) ^ !f_compl;
+  }
+
+  /* Remark: To be specialized. */
+  signal create_xor3( signal const& a, signal const& b, signal const& c )
+  {
+    return create_xor( a, create_xor( b, c ) );
+  }
+#pragma endregion
+
+#pragma region Create nary functions
+  signal create_nary_and( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( true ), [this]( auto const& a, auto const& b ) { return create_and( a, b ); } );
+  }
+
+  signal create_nary_or( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_or( a, b ); } );
+  }
+
+  signal create_nary_xor( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_xor( a, b ); } );
+  }
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  signal clone_node( tig_network const& other, node const& source, std::vector<signal> const& children )
+  {
+    (void)other;
+    (void)source;
+    assert( children.size() == 3u );
+    return create_gate( children[0u], children[1u], children[2u] );
+  }
+#pragma endregion
+
+#pragma region Restructuring
+
+  std::optional<std::pair<node, signal>> replace_in_node( node const& n, node const& old_node, signal new_signal )
+  {
+    auto& node = _storage->nodes[n];
+
+    std::array<signal, 3> child;
+
+    bool found = false;
+    for ( auto i = 0u; i < 3u; ++i )
+    {
+      if ( node.children[i].index == old_node )
+      {
+        found = true;
+        child[i] = { new_signal.index, new_signal.complement ^ node.children[i].weight };
+      }
+      else
+      {
+        child[i] = node.children[i];
+      }
+    }
+
+    if ( !found )
+    {
+      return std::nullopt;
+    }
+
+    auto norm_res = normalized_fanins( child[0], child[1], child[2] );
+    if ( norm_res.fanins.size() == 1u )
+    {
+      return std::make_pair( n, norm_res.fanins[0] );
+    }
+
+    // node already in hash table and is alive
+    storage::element_type::node_type _hash_obj;
+    _hash_obj.children[0] = child[0];
+    _hash_obj.children[1] = child[1];
+    _hash_obj.children[2] = child[2];
+    if ( const auto it = _storage->hash.find( _hash_obj ); it != _storage->hash.end() && it->second != old_node )
+    {
+      return std::make_pair( n, signal( it->second, 0 ) );
+    }
+
+    // remember before
+    const auto old_child0 = signal{ node.children[0] };
+    const auto old_child1 = signal{ node.children[1] };
+    const auto old_child2 = signal{ node.children[2] };
+
+    // erase old node in hash table
+    _storage->hash.erase( node );
+
+    // insert updated node into hash table
+    node.children[0] = child[0];
+    node.children[1] = child[1];
+    node.children[2] = child[2];
+    _storage->hash[node] = n;
+
+    // update the reference counter of the new signal
+    _storage->nodes[new_signal.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_modified )
+    {
+      ( *fn )( n, { old_child0, old_child1, old_child2 } );
+    }
+
+    return std::nullopt;
+  }
+
+  void replace_in_outputs( node const& old_node, signal const& new_signal )
+  {
+    if ( is_dead( old_node ) )
+      return;
+
+    for ( auto& output : _storage->outputs )
+    {
+      if ( output.index == old_node )
+      {
+        output.index = new_signal.index;
+        output.weight ^= new_signal.complement;
+
+        if ( old_node != new_signal.index )
+        {
+          // increment fan-in of new node
+          _storage->nodes[new_signal.index].data[0].h1++;
+        }
+      }
+    }
+  }
+
+  void take_out_node( node const& n )
+  {
+    /* we cannot delete CIs, constants, or already dead nodes */
+    if ( n == 0 || is_ci( n ) || is_dead( n ) )
+      return;
+
+    auto& nobj = _storage->nodes[n];
+    nobj.data[0].h1 = UINT32_C( 0x80000000 ); /* fanout size 0, but dead */
+    _storage->hash.erase( nobj );
+
+    for ( auto const& fn : _events->on_delete )
+    {
+      ( *fn )( n );
+    }
+
+    for ( auto i = 0u; i < 3u; ++i )
+    {
+      if ( fanout_size( nobj.children[i].index ) == 0 )
+      {
+        continue;
+      }
+      if ( decr_fanout_size( nobj.children[i].index ) == 0 )
+      {
+        take_out_node( nobj.children[i].index );
+      }
+    }
+  }
+
+  void revive_node( node const& n )
+  {
+    if ( !is_dead( n ) )
+      return;
+
+    assert( n < _storage->nodes.size() );
+    auto& nobj = _storage->nodes[n];
+    nobj.data[0].h1 = UINT32_C( 0 ); /* fanout size 0, but not dead (like just created) */
+    _storage->hash[nobj] = n;
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( n );
+    }
+
+    /* revive its children if dead, and increment their fanout_size */
+    for ( auto i = 0u; i < 3u; ++i )
+    {
+      if ( is_dead( nobj.children[i].index ) )
+      {
+        revive_node( nobj.children[i].index );
+      }
+      incr_fanout_size( nobj.children[i].index );
+    }
+  }
+
+  inline bool is_dead( node const& n ) const
+  {
+    return ( _storage->nodes[n].data[0].h1 >> 31 ) & 1;
+  }
+
+  void substitute_node( node const& old_node, signal const& new_signal )
+  {
+    //if ( get_node( new_signal ) == old_node && !is_complemented( new_signal ) )
+    //  return;
+
+    std::unordered_map<node, signal> old_to_new;
+    std::stack<std::pair<node, signal>> to_substitute;
+    to_substitute.push( { old_node, new_signal } );
+
+    while ( !to_substitute.empty() )
+    {
+      const auto [_old, _curr] = to_substitute.top();
+      to_substitute.pop();
+
+      signal _new = _curr;
+      /* find the real new node */
+      if ( is_dead( get_node( _new ) ) )
+      {
+        auto it = old_to_new.find( get_node( _new ) );
+        while ( it != old_to_new.end() )
+        {
+          _new = is_complemented( _new ) ? create_not( it->second ) : it->second;
+          it = old_to_new.find( get_node( _new ) );
+        }
+      }
+      /* revive */
+      if ( is_dead( get_node( _new ) ) )
+      {
+        revive_node( get_node( _new ) );
+      }
+
+      //if ( get_node( _new ) == _old && !is_complemented( _new ) )
+      //  continue;
+
+      for ( auto idx = 1u; idx < _storage->nodes.size(); ++idx )
+      {
+        if ( is_ci( idx ) || is_dead( idx ) )
+          continue; /* ignore CIs */
+
+        if ( const auto repl = replace_in_node( idx, _old, _new ); repl )
+        {
+          to_substitute.push( *repl );
+        }
+      }
+
+      /* check outputs */
+      replace_in_outputs( _old, _new );
+
+      // reset fan-in of old node
+      if ( _old != _new.index )
+      {
+        old_to_new.insert( { _old, _new } );
+        take_out_node( _old );
+      }
+    }
+  }
+#pragma endregion
+
+#pragma region Structural properties
+  auto size() const
+  {
+    return static_cast<uint32_t>( _storage->nodes.size() );
+  }
+
+  auto num_cis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_cos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  auto num_pis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_pos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  auto num_gates() const
+  {
+    return static_cast<uint32_t>( _storage->hash.size() );
+  }
+
+  uint32_t fanin_size( node const& n ) const
+  {
+    if ( is_constant( n ) || is_ci( n ) )
+      return 0;
+    return 3;
+  }
+
+  uint32_t fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1 & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t incr_fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1++ & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t decr_fanout_size( node const& n ) const
+  {
+    return --_storage->nodes[n].data[0].h1 & UINT32_C( 0x7FFFFFFF );
+  }
+
+  bool is_and( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_or( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_xor( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  /* One of the is_{gate} functions for three-input gates needs to be specialized. */
+  bool is_maj( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_ite( node const& n ) const
+  {
+    return is_mux( n );
+  }
+
+  bool is_mux( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_xor3( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_and3( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_dot( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_onehot( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_orand( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_xorand( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_andxor( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_gamble( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_and( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_or( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_xor( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+#pragma endregion
+
+#pragma region Functional properties
+  /* Remark: Must be specialized */
+  kitty::dynamic_truth_table node_function( const node& n ) const;
+#pragma endregion
+
+#pragma region Nodes and signals
+  node get_node( signal const& f ) const
+  {
+    return f.index;
+  }
+
+  signal make_signal( node const& n ) const
+  {
+    return signal( n, 0 );
+  }
+
+  bool is_complemented( signal const& f ) const
+  {
+    return f.complement;
+  }
+
+  uint32_t node_to_index( node const& n ) const
+  {
+    return static_cast<uint32_t>( n );
+  }
+
+  node index_to_node( uint32_t index ) const
+  {
+    return index;
+  }
+
+  node ci_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal co_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return *( _storage->outputs.begin() + index );
+  }
+
+  node pi_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal po_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return *( _storage->outputs.begin() + index );
+  }
+
+  uint32_t ci_index( node const& n ) const
+  {
+    assert( _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data &&
+            _storage->nodes[n].children[0].data == _storage->nodes[n].children[2].data );
+    return static_cast<uint32_t>( _storage->nodes[n].children[0].data );
+  }
+
+  uint32_t co_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_co( [&]( const auto& x, auto index ) {
+      if ( x == s )
+      {
+        i = index;
+        return false;
+      }
+      return true;
+    } );
+    return i;
+  }
+
+  uint32_t pi_index( node const& n ) const
+  {
+    assert( _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data &&
+            _storage->nodes[n].children[0].data == _storage->nodes[n].children[2].data );
+    return static_cast<uint32_t>( _storage->nodes[n].children[0].data );
+  }
+
+  uint32_t po_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_po( [&]( const auto& x, auto index ) {
+      if ( x == s )
+      {
+        i = index;
+        return false;
+      }
+      return true;
+    } );
+    return i;
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( _storage->nodes.size() );
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_dead( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_ci( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_co( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->outputs.begin(), _storage->outputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->outputs.begin(), _storage->outputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( 1u, _storage->nodes.size() ); // start from 1 to avoid constant
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_ci( n ) && !is_dead( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_fanin( node const& n, Fn&& fn ) const
+  {
+    if ( n == 0 || is_ci( n ) )
+      return;
+
+    static_assert( detail::is_callable_without_index_v<Fn, signal, bool> ||
+                   detail::is_callable_with_index_v<Fn, signal, bool> ||
+                   detail::is_callable_without_index_v<Fn, signal, void> ||
+                   detail::is_callable_with_index_v<Fn, signal, void> );
+
+    // we don't use foreach_element here to have better performance
+    if constexpr ( detail::is_callable_without_index_v<Fn, signal, bool> )
+    {
+      if ( !fn( signal{ _storage->nodes[n].children[0] } ) )
+        return;
+      if ( !fn( signal{ _storage->nodes[n].children[1] } ) )
+        return;
+      fn( signal{ _storage->nodes[n].children[2] } );
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, signal, bool> )
+    {
+      if ( !fn( signal{ _storage->nodes[n].children[0] }, 0 ) )
+        return;
+      if ( !fn( signal{ _storage->nodes[n].children[1] }, 1 ) )
+        return;
+      fn( signal{ _storage->nodes[n].children[2] }, 2 );
+    }
+    else if constexpr ( detail::is_callable_without_index_v<Fn, signal, void> )
+    {
+      fn( signal{ _storage->nodes[n].children[0] } );
+      fn( signal{ _storage->nodes[n].children[1] } );
+      fn( signal{ _storage->nodes[n].children[2] } );
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, signal, void> )
+    {
+      fn( signal{ _storage->nodes[n].children[0] }, 0 );
+      fn( signal{ _storage->nodes[n].children[1] }, 1 );
+      fn( signal{ _storage->nodes[n].children[2] }, 2 );
+    }
+  }
+#pragma endregion
+
+#pragma region Value simulation
+  template<typename Iterator>
+  iterates_over_t<Iterator, bool>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+    auto const& c3 = _storage->nodes[n].children[2];
+
+    auto v1 = *begin++;
+    auto v2 = *begin++;
+    auto v3 = *begin++;
+
+    return compute_function<NodeFunc>()( v1 ^ c1.weight, v2 ^ c2.weight, v3 ^ c3.weight );
+  }
+
+  template<typename Iterator>
+  iterates_over_truth_table_t<Iterator>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+    auto const& c3 = _storage->nodes[n].children[2];
+
+    auto tt1 = *begin++;
+    auto tt2 = *begin++;
+    auto tt3 = *begin++;
+
+    return compute_function<NodeFunc>()( c1.weight ? ~tt1 : tt1, c2.weight ? ~tt2 : tt2, c3.weight ? ~tt3 : tt3 );
+  }
+
+  /*! \brief Re-compute the last block. */
+  template<typename Iterator>
+  void compute( node const& n, kitty::partial_truth_table& result, Iterator begin, Iterator end ) const
+  {
+    static_assert( iterates_over_v<Iterator, kitty::partial_truth_table>, "begin and end have to iterate over partial_truth_tables" );
+
+    (void)end;
+    assert( n != 0 && !is_ci( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+    auto const& c3 = _storage->nodes[n].children[2];
+
+    auto tt1 = *begin++;
+    auto tt2 = *begin++;
+    auto tt3 = *begin++;
+
+    assert( tt1.num_bits() > 0 && "truth tables must not be empty" );
+    assert( tt1.num_bits() == tt2.num_bits() );
+    assert( tt1.num_bits() == tt3.num_bits() );
+    assert( tt1.num_bits() >= result.num_bits() );
+    assert( result.num_blocks() == tt1.num_blocks() || ( result.num_blocks() == tt1.num_blocks() - 1 && result.num_bits() % 64 == 0 ) );
+
+    result.resize( tt1.num_bits() );
+    result._bits.back() = compute_function<NodeFunc>()(
+        c1.weight ? ~tt1._bits.back() : tt1._bits.back(),
+        c2.weight ? ~tt2._bits.back() : tt2._bits.back(),
+        c3.weight ? ~tt3._bits.back() : tt3._bits.back() );
+    result.mask_bits();
+  }
+#pragma endregion
+
+#pragma region Custom node values
+  void clear_values() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[0].h2 = 0; } );
+  }
+
+  auto value( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h2;
+  }
+
+  void set_value( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[0].h2 = v;
+  }
+
+  auto incr_value( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h2++;
+  }
+
+  auto decr_value( node const& n ) const
+  {
+    return --_storage->nodes[n].data[0].h2;
+  }
+#pragma endregion
+
+#pragma region Visited flags
+  void clear_visited() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[1].h1 = 0; } );
+  }
+
+  auto visited( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h1;
+  }
+
+  void set_visited( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[1].h1 = v;
+  }
+
+  uint32_t trav_id() const
+  {
+    return _storage->trav_id;
+  }
+
+  void incr_trav_id() const
+  {
+    ++_storage->trav_id;
+  }
+#pragma endregion
+
+#pragma region General methods
+  auto& events() const
+  {
+    return *_events;
+  }
+#pragma endregion
+
+public:
+  std::shared_ptr<tig_storage> _storage;
+  std::shared_ptr<network_events<base_type>> _events;
+
+private:
+  normalization_result normalized_fanins_for_and( signal a, signal b );
+  normalization_result normalized_fanins_for_xor( signal a, signal b );
+  normalization_result complement( normalization_result res )
+  {
+    res.output_compl = !res.output_compl;
+    if ( res.fanins.size() != 1 )
+    {
+      return res;
+    }
+    return { false, { res.output_compl ? !res.fanins[0] : res.fanins[0] } };
+  }
+};
+
+} // namespace mockturtle
+
+namespace std
+{
+
+template<>
+struct hash<mockturtle::tig_signal>
+{
+  uint64_t operator()( mockturtle::tig_signal const& s ) const noexcept
+  {
+    uint64_t k = s.data;
+    k ^= k >> 33;
+    k *= 0xff51afd7ed558ccd;
+    k ^= k >> 33;
+    k *= 0xc4ceb9fe1a85ec53;
+    k ^= k >> 33;
+    return k;
+  }
+}; /* hash */
+
+} // namespace std
diff --git a/include/mockturtle/networks/xag.hpp b/include/mockturtle/networks/xag.hpp
new file mode 100644
index 0000000..17606a2
--- /dev/null
+++ b/include/mockturtle/networks/xag.hpp
@@ -0,0 +1,1288 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xag.hpp
+  \brief Xor-And Graph (XAG) logic network implementation
+
+  \author Alessandro Tempia Calvino
+  \author Bruno Schmitt
+  \author Eleonora Testa
+  \author Hanyu Wang
+  \author Heinz Riener
+  \author Jinzheng Tu
+  \author Mathias Soeken
+  \author Max Austin
+  \author Siang-Yun (Sonia) Lee
+  \author Walter Lau Neto
+*/
+
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <stack>
+#include <string>
+
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/operators.hpp>
+
+#include "../traits.hpp"
+#include "../utils/algorithm.hpp"
+#include "detail/foreach.hpp"
+#include "events.hpp"
+#include "storage.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Hash function for XAGs -- the same as for AIGs (from ABC) */
+template<class Node>
+struct xag_hash
+{
+  uint64_t operator()( Node const& n ) const
+  {
+    uint64_t seed = -2011;
+    seed += n.children[0].index * 7937;
+    seed += n.children[1].index * 2971;
+    seed += n.children[0].weight * 911;
+    seed += n.children[1].weight * 353;
+    return seed;
+  }
+};
+
+/*! \brief XAG storage container
+
+  XAGs have nodes with fan-in 2.  We split of one bit of the index pointer to
+  store a complemented attribute.  Every node has 64-bit of additional data
+  used for the following purposes:
+
+  `data[0].h1`: Fan-out size (we use MSB to indicate whether a node is dead)
+  `data[0].h2`: Application-specific value
+  `data[1].h1`: Visited flag
+  `data[1].h2`: Is terminal node (PI or CI)
+*/
+using xag_storage = storage<regular_node<2, 2, 1>,
+                            empty_storage_data,
+                            xag_hash<regular_node<2, 2, 1>>>;
+
+class xag_network
+{
+public:
+#pragma region Types and constructors
+  static constexpr auto min_fanin_size = 2u;
+  static constexpr auto max_fanin_size = 2u;
+
+  using base_type = xag_network;
+  using storage = std::shared_ptr<xag_storage>;
+  using node = uint64_t;
+
+  struct signal
+  {
+    signal() = default;
+
+    signal( uint64_t index, uint64_t complement )
+        : complement( complement ), index( index )
+    {
+    }
+
+    explicit signal( uint64_t data )
+        : data( data )
+    {
+    }
+
+    signal( xag_storage::node_type::pointer_type const& p )
+        : complement( p.weight ), index( p.index )
+    {
+    }
+
+    union
+    {
+      struct
+      {
+        uint64_t complement : 1;
+        uint64_t index : 63;
+      };
+      uint64_t data;
+    };
+
+    signal operator!() const
+    {
+      return signal( data ^ 1 );
+    }
+
+    signal operator+() const
+    {
+      return { index, 0 };
+    }
+
+    signal operator-() const
+    {
+      return { index, 1 };
+    }
+
+    signal operator^( bool complement ) const
+    {
+      return signal( data ^ ( complement ? 1 : 0 ) );
+    }
+
+    bool operator==( signal const& other ) const
+    {
+      return data == other.data;
+    }
+
+    bool operator!=( signal const& other ) const
+    {
+      return data != other.data;
+    }
+
+    bool operator<( signal const& other ) const
+    {
+      return data < other.data;
+    }
+
+    operator xag_storage::node_type::pointer_type() const
+    {
+      return { index, complement };
+    }
+
+#if __cplusplus > 201703L
+    bool operator==( xag_storage::node_type::pointer_type const& other ) const
+    {
+      return data == other.data;
+    }
+#endif
+  };
+
+  xag_network()
+      : _storage( std::make_shared<xag_storage>() ),
+        _events( std::make_shared<decltype( _events )::element_type>() )
+  {
+  }
+
+  xag_network( std::shared_ptr<xag_storage> storage )
+      : _storage( storage ),
+        _events( std::make_shared<decltype( _events )::element_type>() )
+  {
+  }
+
+  xag_network clone() const
+  {
+    return { std::make_shared<xag_storage>( *_storage ) };
+  }
+#pragma endregion
+
+#pragma region Primary I / O and constants
+  signal get_constant( bool value ) const
+  {
+    return { 0, static_cast<uint64_t>( value ? 1 : 0 ) };
+  }
+
+  signal create_pi()
+  {
+    const auto index = _storage->nodes.size();
+    auto& node = _storage->nodes.emplace_back();
+    node.children[0].data = node.children[1].data = _storage->inputs.size();
+    node.data[1].h2 = 1; // mark as PI
+    _storage->inputs.emplace_back( index );
+    return { index, 0 };
+  }
+
+  uint32_t create_po( signal const& f )
+  {
+    /* increase ref-count to children */
+    _storage->nodes[f.index].data[0].h1++;
+    auto const po_index = static_cast<uint32_t>( _storage->outputs.size() );
+    _storage->outputs.emplace_back( f.index, f.complement );
+    return po_index;
+  }
+
+  bool is_combinational() const
+  {
+    return true;
+  }
+
+  bool is_constant( node const& n ) const
+  {
+    return n == 0;
+  }
+
+  bool is_ci( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h2 == 1;
+  }
+
+  bool is_pi( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h2 == 1 && !is_constant( n );
+  }
+
+  bool constant_value( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+#pragma endregion
+
+#pragma region Create unary functions
+  signal create_buf( signal const& a )
+  {
+    return a;
+  }
+
+  signal create_not( signal const& a )
+  {
+    return !a;
+  }
+#pragma endregion
+
+#pragma region Create binary functions
+  signal _create_node( signal a, signal b )
+  {
+    storage::element_type::node_type node;
+    node.children[0] = a;
+    node.children[1] = b;
+
+    /* structural hashing */
+    const auto it = _storage->hash.find( node );
+    if ( it != _storage->hash.end() )
+    {
+      return { it->second, 0 };
+    }
+
+    const auto index = _storage->nodes.size();
+
+    if ( index >= .9 * _storage->nodes.capacity() )
+    {
+      _storage->nodes.reserve( static_cast<uint64_t>( 3.1415f * index ) );
+      _storage->hash.reserve( static_cast<uint64_t>( 3.1415f * index ) );
+    }
+
+    _storage->nodes.push_back( node );
+
+    _storage->hash[node] = index;
+
+    /* increase ref-count to children */
+    _storage->nodes[a.index].data[0].h1++;
+    _storage->nodes[b.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return { index, 0 };
+  }
+
+  signal create_and( signal a, signal b )
+  {
+    /* order inputs a < b it is a AND */
+    if ( a.index > b.index )
+    {
+      std::swap( a, b );
+    }
+    if ( a.index == b.index )
+    {
+      return a.complement == b.complement ? a : get_constant( false );
+    }
+    else if ( a.index == 0 )
+    {
+      return a.complement == false ? get_constant( false ) : b;
+    }
+    return _create_node( a, b );
+  }
+
+  signal create_nand( signal const& a, signal const& b )
+  {
+    return !create_and( a, b );
+  }
+
+  signal create_or( signal const& a, signal const& b )
+  {
+    return !create_and( !a, !b );
+  }
+
+  signal create_nor( signal const& a, signal const& b )
+  {
+    return create_and( !a, !b );
+  }
+
+  signal create_lt( signal const& a, signal const& b )
+  {
+    return create_and( !a, b );
+  }
+
+  signal create_le( signal const& a, signal const& b )
+  {
+    return !create_and( a, !b );
+  }
+
+  signal create_xor( signal a, signal b )
+  {
+    /* order inputs a > b it is a XOR */
+    if ( a.index < b.index )
+    {
+      std::swap( a, b );
+    }
+
+    bool f_compl = a.complement != b.complement;
+    a.complement = b.complement = false;
+
+    if ( a.index == b.index )
+    {
+      return get_constant( f_compl );
+    }
+    else if ( b.index == 0 )
+    {
+      return a ^ f_compl;
+    }
+
+    return _create_node( a, b ) ^ f_compl;
+  }
+
+  signal create_xnor( signal const& a, signal const& b )
+  {
+    return !create_xor( a, b );
+  }
+#pragma endregion
+
+#pragma region Create ternary functions
+  signal create_ite( signal cond, signal f_then, signal f_else )
+  {
+    bool f_compl{ false };
+    if ( f_then.index < f_else.index )
+    {
+      std::swap( f_then, f_else );
+      cond.complement ^= 1;
+    }
+    if ( f_then.complement )
+    {
+      f_then.complement = 0;
+      f_else.complement ^= 1;
+      f_compl = true;
+    }
+
+    return create_xor( create_and( !cond, create_xor( f_then, f_else ) ), f_then ) ^ f_compl;
+  }
+
+  signal create_maj( signal const& a, signal const& b, signal const& c )
+  {
+    auto c1 = create_xor( a, b );
+    auto c2 = create_xor( a, c );
+    auto c3 = create_and( c1, c2 );
+    return create_xor( a, c3 );
+  }
+
+  signal create_xor3( signal const& a, signal const& b, signal const& c )
+  {
+    return create_xor( create_xor( a, b ), c );
+  }
+#pragma endregion
+
+#pragma region Create nary functions
+  signal create_nary_and( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( true ), [this]( auto const& a, auto const& b ) { return create_and( a, b ); } );
+  }
+
+  signal create_nary_or( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_or( a, b ); } );
+  }
+
+  signal create_nary_xor( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_xor( a, b ); } );
+  }
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  signal clone_node( xag_network const& other, node const& source, std::vector<signal> const& children )
+  {
+    assert( children.size() == 2u );
+    if ( other.is_and( source ) )
+    {
+      return create_and( children[0u], children[1u] );
+    }
+    else
+    {
+      return create_xor( children[0u], children[1u] );
+    }
+  }
+#pragma endregion
+
+#pragma region Has node
+  std::optional<signal> has_and( signal a, signal b )
+  {
+    /* order inputs */
+    if ( a.index > b.index )
+    {
+      std::swap( a, b );
+    }
+
+    /* trivial cases */
+    if ( a.index == b.index )
+    {
+      return ( a.complement == b.complement ) ? a : get_constant( false );
+    }
+    else if ( a.index == 0 )
+    {
+      return a.complement == false ? get_constant( false ) : b;
+    }
+
+    storage::element_type::node_type node;
+    node.children[0] = a;
+    node.children[1] = b;
+
+    /* structural hashing */
+    const auto it = _storage->hash.find( node );
+    if ( it != _storage->hash.end() )
+    {
+      assert( !is_dead( it->second ) );
+      return signal( it->second, 0 );
+    }
+
+    return {};
+  }
+
+  std::optional<signal> has_xor( signal a, signal b )
+  {
+    /* order inputs */
+    if ( a.index < b.index )
+    {
+      std::swap( a, b );
+    }
+
+    bool f_compl = a.complement != b.complement;
+    a.complement = b.complement = false;
+
+    /* trivial cases */
+    if ( a.index == b.index )
+    {
+      return get_constant( f_compl );
+    }
+    else if ( b.index == 0 )
+    {
+      return a ^ f_compl;
+    }
+
+    storage::element_type::node_type node;
+    node.children[0] = a;
+    node.children[1] = b;
+
+    /* structural hashing */
+    const auto it = _storage->hash.find( node );
+    if ( it != _storage->hash.end() )
+    {
+      assert( !is_dead( it->second ) );
+      return signal( it->second, f_compl );
+    }
+
+    return {};
+  }
+#pragma endregion
+
+#pragma region Restructuring
+  std::optional<std::pair<node, signal>> replace_in_node( node const& n, node const& old_node, signal new_signal )
+  {
+    auto& node = _storage->nodes[n];
+
+    uint32_t fanin = 0u;
+    if ( node.children[0].index == old_node )
+    {
+      fanin = 0u;
+      new_signal.complement ^= node.children[0].weight;
+    }
+    else if ( node.children[1].index == old_node )
+    {
+      fanin = 1u;
+      new_signal.complement ^= node.children[1].weight;
+    }
+    else
+    {
+      return std::nullopt;
+    }
+
+    // determine gate type of n
+    auto _is_and = node.children[0].index <= node.children[1].index;
+
+    // determine potential new children of node n
+    signal child1 = new_signal;
+    signal child0 = node.children[fanin ^ 1];
+
+    if ( ( _is_and && child0.index > child1.index ) || ( !_is_and && child0.index < child1.index ) )
+    {
+      std::swap( child0, child1 );
+    }
+
+    // check for trivial cases?
+    if ( child0.index == child1.index )
+    {
+      const auto diff_pol = child0.complement != child1.complement;
+      if ( _is_and )
+      {
+        return std::make_pair( n, diff_pol ? get_constant( false ) : child1 );
+      }
+      else
+      {
+        return std::make_pair( n, get_constant( diff_pol ) );
+      }
+    }
+    else if ( _is_and && child0.index == 0 ) /* constant child */
+    {
+      return std::make_pair( n, child0.complement ? child1 : get_constant( false ) );
+    }
+    else if ( !_is_and && child1.index == 0 )
+    {
+      return std::make_pair( n, child0 ^ child1.complement );
+    }
+
+    // node already in hash table
+    storage::element_type::node_type _hash_obj;
+    _hash_obj.children[0] = child0;
+    _hash_obj.children[1] = child1;
+    if ( const auto it = _storage->hash.find( _hash_obj ); it != _storage->hash.end() && it->second != old_node )
+    {
+      return std::make_pair( n, signal( it->second, 0 ) );
+    }
+
+    // remember before
+    const auto old_child0 = signal{ node.children[0] };
+    const auto old_child1 = signal{ node.children[1] };
+
+    // erase old node in hash table
+    _storage->hash.erase( node );
+
+    // insert updated node into hash table
+    node.children[0] = child0;
+    node.children[1] = child1;
+    _storage->hash[node] = n;
+
+    // update the reference counter of the new signal
+    _storage->nodes[new_signal.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_modified )
+    {
+      ( *fn )( n, { old_child0, old_child1 } );
+    }
+
+    return std::nullopt;
+  }
+
+  void replace_in_node_no_restrash( node const& n, node const& old_node, signal new_signal )
+  {
+    auto& node = _storage->nodes[n];
+
+    uint32_t fanin = 0u;
+    if ( node.children[0].index == old_node )
+    {
+      fanin = 0u;
+      new_signal.complement ^= node.children[0].weight;
+    }
+    else if ( node.children[1].index == old_node )
+    {
+      fanin = 1u;
+      new_signal.complement ^= node.children[1].weight;
+    }
+    else
+    {
+      return;
+    }
+
+    // determine gate type of n
+    auto _is_and = node.children[0].index <= node.children[1].index;
+
+    // determine potential new children of node n
+    signal child1 = new_signal;
+    signal child0 = node.children[fanin ^ 1];
+
+    if ( ( _is_and && child0.index > child1.index ) || ( !_is_and && child0.index < child1.index ) )
+    {
+      std::swap( child0, child1 );
+    }
+
+    // if a buffer is created adjust the polarities
+    if ( child0.index == child1.index && !_is_and )
+    {
+      if ( child0.complement == child1.complement )
+      {
+        child0.data = 0; // the buffer is a constant zero
+        child1.data = 0; // the buffer is a constant zero
+      }
+      else
+      {
+        child0.data = 1; // the buffer is a constant one
+        child1.data = 1; // the buffer is a constant zero
+      }
+    }
+
+    // don't check for trivial cases
+
+    // remember before
+    const auto old_child0 = signal{ node.children[0] };
+    const auto old_child1 = signal{ node.children[1] };
+
+    // erase old node in hash table
+    _storage->hash.erase( node );
+
+    // insert updated node into hash table
+    node.children[0] = child0;
+    node.children[1] = child1;
+    if ( _storage->hash.find( node ) == _storage->hash.end() )
+    {
+      _storage->hash[node] = n;
+    }
+
+    // update the reference counter of the new signal
+    _storage->nodes[new_signal.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_modified )
+    {
+      ( *fn )( n, { old_child0, old_child1 } );
+    }
+  }
+
+  void replace_in_outputs( node const& old_node, signal const& new_signal )
+  {
+    if ( is_dead( old_node ) )
+      return;
+
+    for ( auto& output : _storage->outputs )
+    {
+      if ( output.index == old_node )
+      {
+        output.index = new_signal.index;
+        output.weight ^= new_signal.complement;
+
+        if ( old_node != new_signal.index )
+        {
+          /* increment fan-in of new node */
+          _storage->nodes[new_signal.index].data[0].h1++;
+        }
+      }
+    }
+  }
+
+  void take_out_node( node const& n )
+  {
+    /* we cannot delete CIs or constants */
+    if ( n == 0 || is_ci( n ) || is_dead( n ) )
+      return;
+
+    auto& nobj = _storage->nodes[n];
+    nobj.data[0].h1 = UINT32_C( 0x80000000 ); /* fanout size 0, but dead */
+    _storage->hash.erase( nobj );
+
+    for ( auto const& fn : _events->on_delete )
+    {
+      ( *fn )( n );
+    }
+
+    for ( auto i = 0u; i < 2u; ++i )
+    {
+      if ( fanout_size( nobj.children[i].index ) == 0 )
+      {
+        continue;
+      }
+      if ( decr_fanout_size( nobj.children[i].index ) == 0 )
+      {
+        take_out_node( nobj.children[i].index );
+      }
+    }
+  }
+
+  void revive_node( node const& n )
+  {
+    if ( !is_dead( n ) )
+      return;
+
+    assert( n < _storage->nodes.size() );
+    auto& nobj = _storage->nodes[n];
+    nobj.data[0].h1 = UINT32_C( 0 ); /* fanout size 0, but not dead (like just created) */
+    _storage->hash[nobj] = n;
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( n );
+    }
+
+    /* revive its children if dead, and increment their fanout_size */
+    for ( auto i = 0u; i < 2u; ++i )
+    {
+      if ( is_dead( nobj.children[i].index ) )
+      {
+        revive_node( nobj.children[i].index );
+      }
+      incr_fanout_size( nobj.children[i].index );
+    }
+  }
+
+  inline bool is_dead( node const& n ) const
+  {
+    return ( _storage->nodes[n].data[0].h1 >> 31 ) & 1;
+  }
+
+  void substitute_node( node const& old_node, signal const& new_signal )
+  {
+    std::unordered_map<node, signal> old_to_new;
+    std::stack<std::pair<node, signal>> to_substitute;
+    to_substitute.push( { old_node, new_signal } );
+
+    while ( !to_substitute.empty() )
+    {
+      const auto [_old, _curr] = to_substitute.top();
+      to_substitute.pop();
+
+      signal _new = _curr;
+      /* find the real new node */
+      if ( is_dead( get_node( _new ) ) )
+      {
+        auto it = old_to_new.find( get_node( _new ) );
+        while ( it != old_to_new.end() )
+        {
+          _new = is_complemented( _new ) ? create_not( it->second ) : it->second;
+          it = old_to_new.find( get_node( _new ) );
+        }
+      }
+      /* revive */
+      if ( is_dead( get_node( _new ) ) )
+      {
+        revive_node( get_node( _new ) );
+      }
+
+      for ( auto idx = 1u; idx < _storage->nodes.size(); ++idx )
+      {
+        if ( is_ci( idx ) || is_dead( idx ) )
+          continue; /* ignore CIs */
+
+        if ( const auto repl = replace_in_node( idx, _old, _new ); repl )
+        {
+          to_substitute.push( *repl );
+        }
+      }
+
+      /* check outputs */
+      replace_in_outputs( _old, _new );
+
+      // reset fan-in of old node
+      if ( _old != _new.index )
+      {
+        old_to_new.insert( { _old, _new } );
+        take_out_node( _old );
+      }
+    }
+  }
+
+  void substitute_node_no_restrash( node const& old_node, signal const& new_signal )
+  {
+    if ( is_dead( get_node( new_signal ) ) )
+    {
+      revive_node( get_node( new_signal ) );
+    }
+
+    for ( auto idx = 1u; idx < _storage->nodes.size(); ++idx )
+    {
+      if ( is_ci( idx ) || is_dead( idx ) )
+        continue; /* ignore CIs and dead nodes */
+
+      replace_in_node_no_restrash( idx, old_node, new_signal );
+    }
+
+    /* check outputs */
+    replace_in_outputs( old_node, new_signal );
+
+    /* recursively reset old node */
+    if ( old_node != new_signal.index )
+    {
+      take_out_node( old_node );
+    }
+  }
+#pragma endregion
+
+#pragma region Structural properties
+  auto size() const
+  {
+    return static_cast<uint32_t>( _storage->nodes.size() );
+  }
+
+  auto num_cis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_cos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  auto num_pis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_pos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  auto num_gates() const
+  {
+    return static_cast<uint32_t>( _storage->hash.size() );
+  }
+
+  uint32_t fanin_size( node const& n ) const
+  {
+    if ( is_constant( n ) || is_ci( n ) )
+      return 0;
+    return 2;
+  }
+
+  uint32_t fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1 & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t incr_fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1++ & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t decr_fanout_size( node const& n ) const
+  {
+    return --_storage->nodes[n].data[0].h1 & UINT32_C( 0x7FFFFFFF );
+  }
+
+  bool is_and( node const& n ) const
+  {
+    return n > 0 && !is_ci( n ) && ( _storage->nodes[n].children[0].index <= _storage->nodes[n].children[1].index );
+  }
+
+  bool is_or( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_xor( node const& n ) const
+  {
+    return n > 0 && !is_ci( n ) && ( _storage->nodes[n].children[0].index > _storage->nodes[n].children[1].index );
+  }
+
+  bool is_maj( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_ite( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_xor3( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_and( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_or( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_xor( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+#pragma endregion
+
+#pragma region Functional properties
+  kitty::dynamic_truth_table node_function( const node& n ) const
+  {
+    kitty::dynamic_truth_table _func( 2 );
+    if ( _storage->nodes[n].children[0u].index <= _storage->nodes[n].children[1u].index )
+    {
+      _func._bits[0] = 0x8;
+      return _func;
+    }
+    else
+    {
+      _func._bits[0] = 0x6;
+      return _func;
+    }
+  }
+#pragma endregion
+
+#pragma region Nodes and signals
+  node get_node( signal const& f ) const
+  {
+    return f.index;
+  }
+
+  signal make_signal( node const& n ) const
+  {
+    return signal( n, 0 );
+  }
+
+  bool is_complemented( signal const& f ) const
+  {
+    return f.complement;
+  }
+
+  uint32_t node_to_index( node const& n ) const
+  {
+    return static_cast<uint32_t>( n );
+  }
+
+  node index_to_node( uint32_t index ) const
+  {
+    return index;
+  }
+
+  node ci_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal co_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return *( _storage->outputs.begin() + index );
+  }
+
+  node pi_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal po_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return *( _storage->outputs.begin() + index );
+  }
+
+  uint32_t ci_index( node const& n ) const
+  {
+    assert( _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data );
+    return static_cast<uint32_t>( _storage->nodes[n].children[0].data );
+  }
+
+  uint32_t co_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_co( [&]( const auto& x, auto index ) {
+      if ( x == s )
+      {
+        i = index;
+        return false;
+      }
+      return true;
+    } );
+    return i;
+  }
+
+  uint32_t pi_index( node const& n ) const
+  {
+    assert( _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data );
+    return static_cast<uint32_t>( _storage->nodes[n].children[0].data );
+  }
+
+  uint32_t po_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_po( [&]( const auto& x, auto index ) {
+      if ( x == s )
+      {
+        i = index;
+        return false;
+      }
+      return true;
+    } );
+    return i;
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( _storage->nodes.size() );
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_dead( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_ci( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_co( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->outputs.begin(), _storage->outputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->outputs.begin(), _storage->outputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( 1u, _storage->nodes.size() ); /* start from 1 to avoid constant */
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_ci( n ) && !is_dead( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_fanin( node const& n, Fn&& fn ) const
+  {
+    if ( n == 0 || is_ci( n ) )
+      return;
+
+    static_assert( detail::is_callable_without_index_v<Fn, signal, bool> ||
+                   detail::is_callable_with_index_v<Fn, signal, bool> ||
+                   detail::is_callable_without_index_v<Fn, signal, void> ||
+                   detail::is_callable_with_index_v<Fn, signal, void> );
+
+    /* we don't use foreach_element here to have better performance */
+    if constexpr ( detail::is_callable_without_index_v<Fn, signal, bool> )
+    {
+      if ( !fn( signal{ _storage->nodes[n].children[0] } ) )
+        return;
+      fn( signal{ _storage->nodes[n].children[1] } );
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, signal, bool> )
+    {
+      if ( !fn( signal{ _storage->nodes[n].children[0] }, 0 ) )
+        return;
+      fn( signal{ _storage->nodes[n].children[1] }, 1 );
+    }
+    else if constexpr ( detail::is_callable_without_index_v<Fn, signal, void> )
+    {
+      fn( signal{ _storage->nodes[n].children[0] } );
+      fn( signal{ _storage->nodes[n].children[1] } );
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, signal, void> )
+    {
+      fn( signal{ _storage->nodes[n].children[0] }, 0 );
+      fn( signal{ _storage->nodes[n].children[1] }, 1 );
+    }
+  }
+#pragma endregion
+
+#pragma region Value simulation
+  template<typename Iterator>
+  iterates_over_t<Iterator, bool>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+
+    auto v1 = *begin++;
+    auto v2 = *begin++;
+
+    if ( c1.index <= c2.index )
+    {
+      return ( v1 ^ c1.weight ) && ( v2 ^ c2.weight );
+    }
+    else
+    {
+      return ( v1 ^ c1.weight ) ^ ( v2 ^ c2.weight );
+    }
+  }
+
+  template<typename Iterator>
+  iterates_over_truth_table_t<Iterator>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+
+    auto tt1 = *begin++;
+    auto tt2 = *begin++;
+
+    if ( c1.index <= c2.index )
+    {
+      return ( c1.weight ? ~tt1 : tt1 ) & ( c2.weight ? ~tt2 : tt2 );
+    }
+    else
+    {
+      return ( c1.weight ? ~tt1 : tt1 ) ^ ( c2.weight ? ~tt2 : tt2 );
+    }
+  }
+
+  /*! \brief Re-compute the last block. */
+  template<typename Iterator>
+  void compute( node const& n, kitty::partial_truth_table& result, Iterator begin, Iterator end ) const
+  {
+    static_assert( iterates_over_v<Iterator, kitty::partial_truth_table>, "begin and end have to iterate over partial_truth_tables" );
+
+    (void)end;
+    assert( n != 0 && !is_ci( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+
+    auto tt1 = *begin++;
+    auto tt2 = *begin++;
+
+    assert( tt1.num_bits() > 0 && "truth tables must not be empty" );
+    assert( tt1.num_bits() == tt2.num_bits() );
+    assert( tt1.num_bits() >= result.num_bits() );
+    assert( result.num_blocks() == tt1.num_blocks() || ( result.num_blocks() == tt1.num_blocks() - 1 && result.num_bits() % 64 == 0 ) );
+
+    result.resize( tt1.num_bits() );
+    if ( c1.index <= c2.index )
+    {
+      result._bits.back() = ( c1.weight ? ~( tt1._bits.back() ) : tt1._bits.back() ) & ( c2.weight ? ~( tt2._bits.back() ) : tt2._bits.back() );
+    }
+    else
+    {
+      result._bits.back() = ( c1.weight ? ~( tt1._bits.back() ) : tt1._bits.back() ) ^ ( c2.weight ? ~( tt2._bits.back() ) : tt2._bits.back() );
+    }
+    result.mask_bits();
+  }
+#pragma endregion
+
+#pragma region Custom node values
+  void clear_values() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[0].h2 = 0; } );
+  }
+
+  auto value( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h2;
+  }
+
+  void set_value( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[0].h2 = v;
+  }
+
+  auto incr_value( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h2++;
+  }
+
+  auto decr_value( node const& n ) const
+  {
+    return --_storage->nodes[n].data[0].h2;
+  }
+#pragma endregion
+
+#pragma region Visited flags
+  void clear_visited() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[1].h1 = 0; } );
+  }
+
+  auto visited( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h1;
+  }
+
+  void set_visited( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[1].h1 = v;
+  }
+
+  uint32_t trav_id() const
+  {
+    return _storage->trav_id;
+  }
+
+  void incr_trav_id() const
+  {
+    ++_storage->trav_id;
+  }
+#pragma endregion
+
+#pragma region General methods
+  auto& events() const
+  {
+    return *_events;
+  }
+#pragma endregion
+
+public:
+  std::shared_ptr<xag_storage> _storage;
+  std::shared_ptr<network_events<base_type>> _events;
+};
+
+} // namespace mockturtle
+
+namespace std
+{
+
+template<>
+struct hash<mockturtle::xag_network::signal>
+{
+  uint64_t operator()( mockturtle::xag_network::signal const& s ) const noexcept
+  {
+    uint64_t k = s.data;
+    k ^= k >> 33;
+    k *= 0xff51afd7ed558ccd;
+    k ^= k >> 33;
+    k *= 0xc4ceb9fe1a85ec53;
+    k ^= k >> 33;
+    return k;
+  }
+}; /* hash */
+
+} // namespace std
\ No newline at end of file
diff --git a/include/mockturtle/networks/xmg.hpp b/include/mockturtle/networks/xmg.hpp
new file mode 100644
index 0000000..536b68e
--- /dev/null
+++ b/include/mockturtle/networks/xmg.hpp
@@ -0,0 +1,1493 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xmg.hpp
+  \brief XMG logic network implementation
+
+  \author Alessandro Tempia Calvino
+  \author Bruno Schmitt
+  \author Hanyu Wang
+  \author Heinz Riener
+  \author Jinzheng Tu
+  \author Mathias Soeken
+  \author Max Austin
+  \author Siang-Yun (Sonia) Lee
+  \author Walter Lau Neto
+*/
+
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <stack>
+#include <string>
+
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/operators.hpp>
+
+#include "../traits.hpp"
+#include "../utils/algorithm.hpp"
+#include "detail/foreach.hpp"
+#include "events.hpp"
+#include "storage.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief XMG storage container
+
+  XMGs have nodes with fan-in 3.  We split of one bit of the index pointer to
+  store a complemented attribute.  Every node has 64-bit of additional data
+  used for the following purposes:
+
+  `data[0].h1`: Fan-out size (we use MSB to indicate whether a node is dead)
+  `data[0].h2`: Application-specific value
+  `data[1].h1`: Visited flag
+  `data[1].h2`: Is terminal node (PI or CI)
+*/
+using xmg_storage = storage<regular_node<3, 2, 1>>;
+
+class xmg_network
+{
+public:
+#pragma region Types and constructors
+  static constexpr auto min_fanin_size = 3u;
+  static constexpr auto max_fanin_size = 3u;
+
+  using base_type = xmg_network;
+  using storage = std::shared_ptr<xmg_storage>;
+  using node = std::size_t;
+
+  struct signal
+  {
+    signal() = default;
+
+    signal( std::size_t index, std::size_t complement )
+        : complement( complement ), index( index )
+    {
+    }
+
+    signal( std::size_t data )
+        : data( data )
+    {
+    }
+
+    signal( xmg_storage::node_type::pointer_type const& p )
+        : complement( p.weight ), index( p.index )
+    {
+    }
+
+    union
+    {
+      struct
+      {
+        std::size_t complement : 1;
+        std::size_t index : 63;
+      };
+      std::size_t data;
+    };
+
+    signal operator!() const
+    {
+      return signal( data ^ 1 );
+    }
+
+    signal operator+() const
+    {
+      return { index, 0 };
+    }
+
+    signal operator-() const
+    {
+      return { index, 1 };
+    }
+
+    signal operator^( bool complement ) const
+    {
+      return signal( data ^ ( complement ? 1 : 0 ) );
+    }
+
+    bool operator==( signal const& other ) const
+    {
+      return data == other.data;
+    }
+
+    bool operator!=( signal const& other ) const
+    {
+      return data != other.data;
+    }
+
+    bool operator<( signal const& other ) const
+    {
+      return data < other.data;
+    }
+
+    operator xmg_storage::node_type::pointer_type() const
+    {
+      return { index, complement };
+    }
+
+#if __cplusplus > 201703L
+    bool operator==( xmg_storage::node_type::pointer_type const& other ) const
+    {
+      return data == other.data;
+    }
+#endif
+  };
+
+  xmg_network()
+      : _storage( std::make_shared<xmg_storage>() ),
+        _events( std::make_shared<decltype( _events )::element_type>() )
+  {
+  }
+
+  xmg_network( std::shared_ptr<xmg_storage> storage )
+      : _storage( storage ),
+        _events( std::make_shared<decltype( _events )::element_type>() )
+  {
+  }
+
+  xmg_network clone() const
+  {
+    return { std::make_shared<xmg_storage>( *_storage ) };
+  }
+#pragma endregion
+
+#pragma region Primary I / O and constants
+  signal get_constant( bool value ) const
+  {
+    return { 0, static_cast<size_t>( value ? 1 : 0 ) };
+  }
+
+  signal create_pi()
+  {
+    const auto index = _storage->nodes.size();
+    auto& node = _storage->nodes.emplace_back();
+    node.children[0].data = node.children[1].data = node.children[2].data = _storage->inputs.size();
+    node.data[1].h2 = 1; // mark as PI
+    _storage->inputs.emplace_back( index );
+    return { index, 0 };
+  }
+
+  uint32_t create_po( signal const& f )
+  {
+    /* increase ref-count to children */
+    _storage->nodes[f.index].data[0].h1++;
+    auto const po_index = static_cast<uint32_t>( _storage->outputs.size() );
+    _storage->outputs.emplace_back( f.index, f.complement );
+    return po_index;
+  }
+
+  bool is_combinational() const
+  {
+    return true;
+  }
+
+  bool is_constant( node const& n ) const
+  {
+    return n == 0;
+  }
+
+  bool is_ci( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h2 == 1;
+  }
+
+  bool is_pi( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h2 == 1 && !is_constant( n );
+  }
+
+  bool constant_value( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+#pragma endregion
+
+#pragma region Create unary functions
+  signal create_buf( signal const& a )
+  {
+    return a;
+  }
+
+  signal create_not( signal const& a )
+  {
+    return !a;
+  }
+#pragma endregion
+
+#pragma region Create binary / ternary functions
+  signal create_maj( signal a, signal b, signal c )
+  {
+    /* order inputs */
+    if ( a.index > b.index )
+    {
+      std::swap( a, b );
+    }
+    if ( b.index > c.index )
+    {
+      std::swap( b, c );
+    }
+    if ( a.index > b.index )
+    {
+      std::swap( a, b );
+    }
+
+    /* trivial cases */
+    if ( a.index == b.index )
+    {
+      return ( a.complement == b.complement ) ? a : c;
+    }
+    else if ( b.index == c.index )
+    {
+      return ( b.complement == c.complement ) ? b : a;
+    }
+
+    /*  complemented edges minimization */
+    auto node_complement = false;
+    if ( static_cast<unsigned>( a.complement ) + static_cast<unsigned>( b.complement ) +
+             static_cast<unsigned>( c.complement ) >=
+         2u )
+    {
+      node_complement = true;
+      a.complement = !a.complement;
+      b.complement = !b.complement;
+      c.complement = !c.complement;
+    }
+
+    storage::element_type::node_type node;
+    node.children[0] = a;
+    node.children[1] = b;
+    node.children[2] = c;
+
+    /* structural hashing */
+    const auto it = _storage->hash.find( node );
+    if ( it != _storage->hash.end() )
+    {
+      return { it->second, node_complement };
+    }
+
+    const auto index = _storage->nodes.size();
+
+    if ( index >= .9 * _storage->nodes.capacity() )
+    {
+      _storage->nodes.reserve( static_cast<size_t>( 3.1415 * index ) );
+      _storage->hash.reserve( static_cast<size_t>( 3.1415 * index ) );
+    }
+
+    _storage->nodes.push_back( node );
+
+    _storage->hash[node] = index;
+
+    /* increase ref-count to children */
+    _storage->nodes[a.index].data[0].h1++;
+    _storage->nodes[b.index].data[0].h1++;
+    _storage->nodes[c.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return { index, node_complement };
+  }
+
+  signal create_xor3( signal a, signal b, signal c )
+  {
+    /* order inputs */
+    if ( a.index < b.index )
+    {
+      std::swap( a, b );
+    }
+    if ( b.index < c.index )
+    {
+      std::swap( b, c );
+    }
+    if ( a.index < b.index )
+    {
+      std::swap( a, b );
+    }
+
+    /* propagate complement edges */
+    bool fcompl = ( a.complement != b.complement ) != c.complement;
+    a.complement = b.complement = c.complement = false;
+
+    /* trivial cases */
+    if ( a.index == b.index )
+    {
+      return c ^ fcompl;
+    }
+    else if ( b.index == c.index )
+    {
+      return a ^ fcompl;
+    }
+
+    storage::element_type::node_type node;
+    node.children[0] = a;
+    node.children[1] = b;
+    node.children[2] = c;
+
+    /* structural hashing */
+    const auto it = _storage->hash.find( node );
+    if ( it != _storage->hash.end() )
+    {
+      return { it->second, fcompl };
+    }
+
+    const auto index = _storage->nodes.size();
+
+    if ( index >= .9 * _storage->nodes.capacity() )
+    {
+      _storage->nodes.reserve( static_cast<size_t>( 3.1415 * index ) );
+      _storage->hash.reserve( static_cast<size_t>( 3.1415 * index ) );
+    }
+
+    _storage->nodes.push_back( node );
+
+    _storage->hash[node] = index;
+
+    /* increase ref-count to children */
+    _storage->nodes[a.index].data[0].h1++;
+    _storage->nodes[b.index].data[0].h1++;
+    _storage->nodes[c.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return { index, fcompl };
+  }
+
+  signal create_ite( signal cond, signal f_then, signal f_else )
+  {
+    bool f_compl{ false };
+    if ( f_then.index < f_else.index )
+    {
+      std::swap( f_then, f_else );
+      cond.complement ^= 1;
+    }
+    if ( f_then.complement )
+    {
+      f_then.complement = 0;
+      f_else.complement ^= 1;
+      f_compl = true;
+    }
+
+    return create_and( !create_and( !cond, f_else ), !create_and( cond, f_then ) ) ^ !f_compl;
+  }
+
+  signal create_and( signal const& a, signal const& b )
+  {
+    return create_maj( get_constant( false ), a, b );
+  }
+
+  signal create_nand( signal const& a, signal const& b )
+  {
+    return !create_and( a, b );
+  }
+
+  signal create_or( signal const& a, signal const& b )
+  {
+    return create_maj( get_constant( true ), a, b );
+  }
+
+  signal create_nor( signal const& a, signal const& b )
+  {
+    return !create_or( a, b );
+  }
+
+  signal create_lt( signal const& a, signal const& b )
+  {
+    return create_and( !a, b );
+  }
+
+  signal create_le( signal const& a, signal const& b )
+  {
+    return !create_and( a, !b );
+  }
+
+  signal create_xor( signal const& a, signal const& b )
+  {
+    return create_xor3( get_constant( false ), a, b );
+  }
+
+  signal create_xnor( signal const& a, signal const& b )
+  {
+    return create_xor3( get_constant( true ), a, b );
+  }
+#pragma endregion
+
+#pragma region Create nary functions
+  signal create_nary_and( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( true ), [this]( auto const& a, auto const& b ) { return create_and( a, b ); } );
+  }
+
+  signal create_nary_or( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b ) { return create_or( a, b ); } );
+  }
+
+  signal create_nary_xor( std::vector<signal> const& fs )
+  {
+    return ternary_tree_reduce( fs.begin(), fs.end(), get_constant( false ), [this]( auto const& a, auto const& b, auto const& c ) { return create_xor3( a, b, c ); } );
+  }
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  signal clone_node( xmg_network const& other, node const& source, std::vector<signal> const& children )
+  {
+    assert( children.size() == 3u );
+
+    if ( other.is_maj( source ) )
+    {
+      return create_maj( children[0u], children[1u], children[2u] );
+    }
+    else
+    {
+      return create_xor3( children[0u], children[1u], children[2u] );
+    }
+  }
+#pragma endregion
+
+#pragma region Has node
+  std::optional<signal> has_maj( signal a, signal b, signal c )
+  {
+    /* order inputs */
+    if ( a.index > b.index )
+    {
+      std::swap( a, b );
+    }
+    if ( b.index > c.index )
+    {
+      std::swap( b, c );
+    }
+    if ( a.index > b.index )
+    {
+      std::swap( a, b );
+    }
+
+    /* trivial cases */
+    if ( a.index == b.index )
+    {
+      return ( a.complement == b.complement ) ? a : c;
+    }
+    else if ( b.index == c.index )
+    {
+      return ( b.complement == c.complement ) ? b : a;
+    }
+
+    /*  complemented edges minimization */
+    auto node_complement = false;
+    if ( static_cast<unsigned>( a.complement ) + static_cast<unsigned>( b.complement ) +
+             static_cast<unsigned>( c.complement ) >=
+         2u )
+    {
+      node_complement = true;
+      a.complement = !a.complement;
+      b.complement = !b.complement;
+      c.complement = !c.complement;
+    }
+
+    storage::element_type::node_type node;
+    node.children[0] = a;
+    node.children[1] = b;
+    node.children[2] = c;
+
+    /* structural hashing */
+    const auto it = _storage->hash.find( node );
+    if ( it != _storage->hash.end() )
+    {
+      assert( !is_dead( it->second ) );
+      return signal( it->second, node_complement );
+    }
+
+    return {};
+  }
+
+  std::optional<signal> has_xor3( signal a, signal b, signal c )
+  {
+    /* order inputs */
+    if ( a.index < b.index )
+    {
+      std::swap( a, b );
+    }
+    if ( b.index < c.index )
+    {
+      std::swap( b, c );
+    }
+    if ( a.index < b.index )
+    {
+      std::swap( a, b );
+    }
+
+    /* propagate complement edges */
+    bool fcompl = ( a.complement != b.complement ) != c.complement;
+    a.complement = b.complement = c.complement = false;
+
+    /* trivial cases */
+    if ( a.index == b.index )
+    {
+      return c ^ fcompl;
+    }
+    else if ( b.index == c.index )
+    {
+      return a ^ fcompl;
+    }
+
+    storage::element_type::node_type node;
+    node.children[0] = a;
+    node.children[1] = b;
+    node.children[2] = c;
+
+    /* structural hashing */
+    const auto it = _storage->hash.find( node );
+    if ( it != _storage->hash.end() )
+    {
+      assert( !is_dead( it->second ) );
+      return signal( it->second, fcompl );
+    }
+
+    return {};
+  }
+#pragma endregion
+
+#pragma region Restructuring
+  std::optional<std::pair<node, signal>> replace_in_node( node const& n, node const& old_node, signal new_signal )
+  {
+    auto& node = _storage->nodes[n];
+
+    uint32_t fanin = 0u;
+    for ( auto i = 0u; i < 4u; ++i )
+    {
+      if ( i == 3u )
+      {
+        return std::nullopt;
+      }
+
+      if ( node.children[i].index == old_node )
+      {
+        fanin = i;
+        new_signal.complement ^= node.children[i].weight;
+        break;
+      }
+    }
+
+    // determine potential new children of node n
+    signal child2 = new_signal;
+    signal child1 = node.children[( fanin + 1 ) % 3];
+    signal child0 = node.children[( fanin + 2 ) % 3];
+
+    auto _is_maj = is_maj( n );
+
+    /* normalize order */
+    if ( _is_maj )
+    {
+      if ( child0.index > child1.index )
+      {
+        std::swap( child0, child1 );
+      }
+      if ( child1.index > child2.index )
+      {
+        std::swap( child1, child2 );
+      }
+      if ( child0.index > child1.index )
+      {
+        std::swap( child0, child1 );
+      }
+
+      assert( child0.index <= child1.index );
+      assert( child1.index <= child2.index );
+    }
+    else
+    {
+      if ( child0.index < child1.index )
+      {
+        std::swap( child0, child1 );
+      }
+      if ( child1.index < child2.index )
+      {
+        std::swap( child1, child2 );
+      }
+      if ( child0.index < child1.index )
+      {
+        std::swap( child0, child1 );
+      }
+
+      assert( child0.index >= child1.index );
+      assert( child1.index >= child2.index );
+    }
+
+    // normalize complemented edges
+    auto node_complement = false;
+    if ( _is_maj )
+    {
+      if ( static_cast<unsigned>( child0.complement ) + static_cast<unsigned>( child1.complement ) +
+               static_cast<unsigned>( child2.complement ) >=
+           2u )
+      {
+        node_complement = true;
+        child0.complement = !child0.complement;
+        child1.complement = !child1.complement;
+        child2.complement = !child2.complement;
+      }
+    }
+    else
+    {
+      node_complement = ( child0.complement != child1.complement ) != child2.complement;
+      child0.complement = child1.complement = child2.complement = false;
+    }
+
+    // check for trivial cases?
+    if ( _is_maj )
+    {
+      if ( child0.index == child1.index )
+      {
+        const auto diff_pol = child0.complement != child1.complement;
+        return std::make_pair( n, ( diff_pol ? child2 : child0 ) ^ node_complement );
+      }
+      else if ( child1.index == child2.index )
+      {
+        const auto diff_pol = child1.complement != child2.complement;
+        return std::make_pair( n, ( diff_pol ? child0 : child1 ) ^ node_complement );
+      }
+    }
+    else
+    {
+      if ( child0.index == child1.index )
+      {
+        return std::make_pair( n, child2 ^ node_complement );
+      }
+      else if ( child1.index == child2.index )
+      {
+        return std::make_pair( n, child0 ^ node_complement );
+      }
+    }
+
+    // node already in hash table
+    storage::element_type::node_type _hash_obj;
+    _hash_obj.children[0] = child0;
+    _hash_obj.children[1] = child1;
+    _hash_obj.children[2] = child2;
+    if ( const auto it = _storage->hash.find( _hash_obj ); it != _storage->hash.end() && it->second != old_node )
+    {
+      return std::make_pair( n, signal( it->second, 0 ) );
+    }
+
+    // remember before
+    const auto old_child0 = signal{ node.children[0] };
+    const auto old_child1 = signal{ node.children[1] };
+    const auto old_child2 = signal{ node.children[2] };
+
+    // erase old node in hash table
+    _storage->hash.erase( node );
+
+    // insert updated node into hash table
+    node.children[0] = child0;
+    node.children[1] = child1;
+    node.children[2] = child2;
+    _storage->hash[node] = n;
+
+    // update the reference counter of the new signal
+    _storage->nodes[new_signal.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_modified )
+    {
+      ( *fn )( n, { old_child0, old_child1, old_child2 } );
+    }
+
+    return std::nullopt;
+  }
+
+  void replace_in_node_no_restrash( node const& n, node const& old_node, signal new_signal )
+  {
+    auto& node = _storage->nodes[n];
+
+    uint32_t fanin = 0u;
+    for ( auto i = 0u; i < 4u; ++i )
+    {
+      if ( i == 3u )
+      {
+        return;
+      }
+
+      if ( node.children[i].index == old_node )
+      {
+        fanin = i;
+        new_signal.complement ^= node.children[i].weight;
+        break;
+      }
+    }
+
+    // determine potential new children of node n
+    signal child2 = new_signal;
+    signal child1 = node.children[( fanin + 1 ) % 3];
+    signal child0 = node.children[( fanin + 2 ) % 3];
+
+    auto _is_maj = is_maj( n );
+
+    /* normalize order */
+    if ( _is_maj )
+    {
+      if ( child0.index > child1.index )
+      {
+        std::swap( child0, child1 );
+      }
+      if ( child1.index > child2.index )
+      {
+        std::swap( child1, child2 );
+      }
+      if ( child0.index > child1.index )
+      {
+        std::swap( child0, child1 );
+      }
+
+      assert( child0.index <= child1.index );
+      assert( child1.index <= child2.index );
+    }
+    else
+    {
+      if ( child0.index < child1.index )
+      {
+        std::swap( child0, child1 );
+      }
+      if ( child1.index < child2.index )
+      {
+        std::swap( child1, child2 );
+      }
+      if ( child0.index < child1.index )
+      {
+        std::swap( child0, child1 );
+      }
+
+      assert( child0.index >= child1.index );
+      assert( child1.index >= child2.index );
+
+      // check same fanins: transform the XOR3 into a MAJ3
+      if ( child0.index == child1.index )
+      {
+        child0.index = child2.index;
+        child1.index = child2.index;
+        if ( child0.complement == child1.complement )
+        {
+          child0.complement = child2.complement;
+          child1.complement = child2.complement;
+        }
+        else
+        {
+          child0.complement = !child2.complement;
+          child1.complement = !child2.complement;
+        }
+
+        _is_maj = true;
+      }
+    }
+
+    // normalize complemented edges
+    auto node_complement = false;
+    if ( _is_maj )
+    {
+      if ( static_cast<unsigned>( child0.complement ) + static_cast<unsigned>( child1.complement ) +
+               static_cast<unsigned>( child2.complement ) >=
+           2u )
+      {
+        node_complement = true;
+        child0.complement = !child0.complement;
+        child1.complement = !child1.complement;
+        child2.complement = !child2.complement;
+      }
+    }
+    else
+    {
+      node_complement = ( child0.complement != child1.complement ) != child2.complement;
+      child0.complement = child1.complement = child2.complement = false;
+    }
+
+    // don't check for trivial cases
+
+    // remember before
+    const auto old_child0 = signal{ node.children[0] };
+    const auto old_child1 = signal{ node.children[1] };
+    const auto old_child2 = signal{ node.children[2] };
+
+    // erase old node in hash table
+    _storage->hash.erase( node );
+
+    // insert updated node into hash table
+    node.children[0] = child0;
+    node.children[1] = child1;
+    node.children[2] = child2;
+    if ( _storage->hash.find( node ) == _storage->hash.end() )
+    {
+      _storage->hash[node] = n;
+    }
+
+    // update the reference counter of the new signal
+    _storage->nodes[new_signal.index].data[0].h1++;
+
+    for ( auto const& fn : _events->on_modified )
+    {
+      ( *fn )( n, { old_child0, old_child1, old_child2 } );
+    }
+  }
+
+  void replace_in_outputs( node const& old_node, signal const& new_signal )
+  {
+    if ( is_dead( old_node ) )
+      return;
+
+    for ( auto& output : _storage->outputs )
+    {
+      if ( output.index == old_node )
+      {
+        output.index = new_signal.index;
+        output.weight ^= new_signal.complement;
+
+        if ( old_node != new_signal.index )
+        {
+          /* increment fan-in of new node */
+          _storage->nodes[new_signal.index].data[0].h1++;
+        }
+      }
+    }
+  }
+
+  void take_out_node( node const& n )
+  {
+    /* we cannot delete CIs or constants */
+    if ( n == 0 || is_ci( n ) || is_dead( n ) )
+      return;
+
+    auto& nobj = _storage->nodes[n];
+    nobj.data[0].h1 = UINT32_C( 0x80000000 ); /* fanout size 0, but dead */
+    _storage->hash.erase( nobj );
+
+    for ( auto const& fn : _events->on_delete )
+    {
+      ( *fn )( n );
+    }
+
+    for ( auto i = 0u; i < 3u; ++i )
+    {
+      if ( fanout_size( nobj.children[i].index ) == 0 )
+      {
+        continue;
+      }
+      if ( decr_fanout_size( nobj.children[i].index ) == 0 )
+      {
+        take_out_node( nobj.children[i].index );
+      }
+    }
+  }
+
+  void revive_node( node const& n )
+  {
+    if ( !is_dead( n ) )
+      return;
+
+    assert( n < _storage->nodes.size() );
+    auto& nobj = _storage->nodes[n];
+    nobj.data[0].h1 = UINT32_C( 0 ); /* fanout size 0, but not dead (like just created) */
+    _storage->hash[nobj] = n;
+
+    for ( auto const& fn : _events->on_add )
+    {
+      ( *fn )( n );
+    }
+
+    /* revive its children if dead, and increment their fanout_size */
+    for ( auto i = 0u; i < 3u; ++i )
+    {
+      if ( is_dead( nobj.children[i].index ) )
+      {
+        revive_node( nobj.children[i].index );
+      }
+      incr_fanout_size( nobj.children[i].index );
+    }
+  }
+
+  inline bool is_dead( node const& n ) const
+  {
+    return ( _storage->nodes[n].data[0].h1 >> 31 ) & 1;
+  }
+
+  void substitute_node( node const& old_node, signal const& new_signal )
+  {
+    std::unordered_map<node, signal> old_to_new;
+    std::stack<std::pair<node, signal>> to_substitute;
+    to_substitute.push( { old_node, new_signal } );
+
+    while ( !to_substitute.empty() )
+    {
+      const auto [_old, _curr] = to_substitute.top();
+      to_substitute.pop();
+
+      signal _new = _curr;
+      /* find the real new node */
+      if ( is_dead( get_node( _new ) ) )
+      {
+        auto it = old_to_new.find( get_node( _new ) );
+        while ( it != old_to_new.end() )
+        {
+          _new = is_complemented( _new ) ? create_not( it->second ) : it->second;
+          it = old_to_new.find( get_node( _new ) );
+        }
+      }
+      /* revive */
+      if ( is_dead( get_node( _new ) ) )
+      {
+        revive_node( get_node( _new ) );
+      }
+
+      for ( auto idx = 1u; idx < _storage->nodes.size(); ++idx )
+      {
+        if ( is_ci( idx ) || is_dead( idx ) )
+          continue; /* ignore CIs */
+
+        if ( const auto repl = replace_in_node( idx, _old, _new ); repl )
+        {
+          to_substitute.push( *repl );
+        }
+      }
+
+      /* check outputs */
+      replace_in_outputs( _old, _new );
+
+      // reset fan-in of old node
+      if ( _old != _new.index )
+      {
+        old_to_new.insert( { _old, _new } );
+        take_out_node( _old );
+      }
+    }
+  }
+
+  void substitute_node_no_restrash( node const& old_node, signal const& new_signal )
+  {
+    if ( is_dead( get_node( new_signal ) ) )
+    {
+      revive_node( get_node( new_signal ) );
+    }
+
+    for ( auto idx = 1u; idx < _storage->nodes.size(); ++idx )
+    {
+      if ( is_ci( idx ) || is_dead( idx ) )
+        continue; /* ignore CIs and dead nodes */
+
+      replace_in_node_no_restrash( idx, old_node, new_signal );
+    }
+
+    /* check outputs */
+    replace_in_outputs( old_node, new_signal );
+
+    /* recursively reset old node */
+    if ( old_node != new_signal.index )
+    {
+      take_out_node( old_node );
+    }
+  }
+#pragma endregion
+
+#pragma region Structural properties
+  uint32_t size() const
+  {
+    return static_cast<uint32_t>( _storage->nodes.size() );
+  }
+
+  auto num_cis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  auto num_cos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  uint32_t num_pis() const
+  {
+    return static_cast<uint32_t>( _storage->inputs.size() );
+  }
+
+  uint32_t num_pos() const
+  {
+    return static_cast<uint32_t>( _storage->outputs.size() );
+  }
+
+  uint32_t num_gates() const
+  {
+    return static_cast<uint32_t>( _storage->hash.size() );
+  }
+
+  uint32_t fanin_size( node const& n ) const
+  {
+    if ( is_constant( n ) || is_ci( n ) )
+      return 0;
+    return 3;
+  }
+
+  uint32_t fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1 & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t incr_fanout_size( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h1++ & UINT32_C( 0x7FFFFFFF );
+  }
+
+  uint32_t decr_fanout_size( node const& n ) const
+  {
+    return --_storage->nodes[n].data[0].h1 & UINT32_C( 0x7FFFFFFF );
+  }
+
+  bool is_and( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_or( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_xor( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_maj( node const& n ) const
+  {
+    return n > 0 && !is_ci( n ) && _storage->nodes[n].children[0].index <= _storage->nodes[n].children[1].index;
+  }
+
+  bool is_ite( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_xor3( node const& n ) const
+  {
+    return n > 0 && !is_ci( n ) && _storage->nodes[n].children[0].index > _storage->nodes[n].children[1].index;
+  }
+
+  bool is_nary_and( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_or( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+
+  bool is_nary_xor( node const& n ) const
+  {
+    (void)n;
+    return false;
+  }
+#pragma endregion
+
+#pragma region Functional properties
+  kitty::dynamic_truth_table node_function( const node& n ) const
+  {
+    kitty::dynamic_truth_table _tt( 3 );
+    _tt._bits[0] = is_xor3( n ) ? 0x96 : 0xe8;
+    return _tt;
+  }
+#pragma endregion
+
+#pragma region Nodes and signals
+  node get_node( signal const& f ) const
+  {
+    return f.index;
+  }
+
+  signal make_signal( node const& n ) const
+  {
+    return signal( n, 0 );
+  }
+
+  bool is_complemented( signal const& f ) const
+  {
+    return f.complement;
+  }
+
+  uint32_t node_to_index( node const& n ) const
+  {
+    return static_cast<uint32_t>( n );
+  }
+
+  node index_to_node( uint32_t index ) const
+  {
+    return index;
+  }
+
+  node ci_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal co_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return *( _storage->outputs.begin() + index );
+  }
+
+  node pi_at( uint32_t index ) const
+  {
+    assert( index < _storage->inputs.size() );
+    return *( _storage->inputs.begin() + index );
+  }
+
+  signal po_at( uint32_t index ) const
+  {
+    assert( index < _storage->outputs.size() );
+    return *( _storage->outputs.begin() + index );
+  }
+
+  uint32_t ci_index( node const& n ) const
+  {
+    assert( _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data &&
+            _storage->nodes[n].children[0].data == _storage->nodes[n].children[2].data );
+    return static_cast<uint32_t>( _storage->nodes[n].children[0].data );
+  }
+
+  uint32_t co_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_co( [&]( const auto& x, auto index ) {
+      if ( x == s )
+      {
+        i = index;
+        return false;
+      }
+      return true;
+    } );
+    return i;
+  }
+
+  uint32_t pi_index( node const& n ) const
+  {
+    assert( _storage->nodes[n].children[0].data == _storage->nodes[n].children[1].data &&
+            _storage->nodes[n].children[0].data == _storage->nodes[n].children[2].data );
+    return static_cast<uint32_t>( _storage->nodes[n].children[0].data );
+  }
+
+  uint32_t po_index( signal const& s ) const
+  {
+    uint32_t i = -1;
+    foreach_po( [&]( const auto& x, auto index ) {
+      if ( x == s )
+      {
+        i = index;
+        return false;
+      }
+      return true;
+    } );
+    return i;
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( _storage->nodes.size() );
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_dead( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_ci( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_co( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->outputs.begin(), _storage->outputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->inputs.begin(), _storage->inputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    detail::foreach_element( _storage->outputs.begin(), _storage->outputs.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    auto r = range<uint64_t>( 1u, _storage->nodes.size() ); // start from 1 to avoid constant
+    detail::foreach_element_if(
+        r.begin(), r.end(),
+        [this]( auto n ) { return !is_ci( n ) && !is_dead( n ); },
+        fn );
+  }
+
+  template<typename Fn>
+  void foreach_fanin( node const& n, Fn&& fn ) const
+  {
+    if ( n == 0 || is_ci( n ) )
+      return;
+
+    static_assert( detail::is_callable_without_index_v<Fn, signal, bool> ||
+                   detail::is_callable_with_index_v<Fn, signal, bool> ||
+                   detail::is_callable_without_index_v<Fn, signal, void> ||
+                   detail::is_callable_with_index_v<Fn, signal, void> );
+
+    // we don't use foreach_element here to have better performance
+    if constexpr ( detail::is_callable_without_index_v<Fn, signal, bool> )
+    {
+      if ( !fn( signal{ _storage->nodes[n].children[0] } ) )
+        return;
+      if ( !fn( signal{ _storage->nodes[n].children[1] } ) )
+        return;
+      fn( signal{ _storage->nodes[n].children[2] } );
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, signal, bool> )
+    {
+      if ( !fn( signal{ _storage->nodes[n].children[0] }, 0 ) )
+        return;
+      if ( !fn( signal{ _storage->nodes[n].children[1] }, 1 ) )
+        return;
+      fn( signal{ _storage->nodes[n].children[2] }, 2 );
+    }
+    else if constexpr ( detail::is_callable_without_index_v<Fn, signal, void> )
+    {
+      fn( signal{ _storage->nodes[n].children[0] } );
+      fn( signal{ _storage->nodes[n].children[1] } );
+      fn( signal{ _storage->nodes[n].children[2] } );
+    }
+    else if constexpr ( detail::is_callable_with_index_v<Fn, signal, void> )
+    {
+      fn( signal{ _storage->nodes[n].children[0] }, 0 );
+      fn( signal{ _storage->nodes[n].children[1] }, 1 );
+      fn( signal{ _storage->nodes[n].children[2] }, 2 );
+    }
+  }
+#pragma endregion
+
+#pragma region Value simulation
+  template<typename Iterator>
+  iterates_over_t<Iterator, bool>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+    auto const& c3 = _storage->nodes[n].children[2];
+
+    auto v1 = *begin++;
+    auto v2 = *begin++;
+    auto v3 = *begin++;
+
+    if ( is_xor3( n ) )
+    {
+      return ( ( v1 ^ c1.weight ) != ( v2 ^ c2.weight ) ) != ( v3 ^ c3.weight );
+    }
+    else
+    {
+      return ( ( v1 ^ c1.weight ) && ( v2 ^ c2.weight ) ) || ( ( v3 ^ c3.weight ) && ( v1 ^ c1.weight ) ) || ( ( v3 ^ c3.weight ) && ( v2 ^ c2.weight ) );
+    }
+  }
+
+  template<typename Iterator>
+  iterates_over_truth_table_t<Iterator>
+  compute( node const& n, Iterator begin, Iterator end ) const
+  {
+    (void)end;
+
+    assert( n != 0 && !is_ci( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+    auto const& c3 = _storage->nodes[n].children[2];
+
+    auto tt1 = *begin++;
+    auto tt2 = *begin++;
+    auto tt3 = *begin++;
+
+    if ( is_xor3( n ) )
+    {
+      return ( c1.weight ? ~tt1 : tt1 ) ^ ( c2.weight ? ~tt2 : tt2 ) ^ ( c3.weight ? ~tt3 : tt3 );
+    }
+    else
+    {
+      return kitty::ternary_majority( c1.weight ? ~tt1 : tt1, c2.weight ? ~tt2 : tt2, c3.weight ? ~tt3 : tt3 );
+    }
+  }
+
+  /*! \brief Re-compute the last block. */
+  template<typename Iterator>
+  void compute( node const& n, kitty::partial_truth_table& result, Iterator begin, Iterator end ) const
+  {
+    static_assert( iterates_over_v<Iterator, kitty::partial_truth_table>, "begin and end have to iterate over partial_truth_tables" );
+
+    (void)end;
+    assert( n != 0 && !is_ci( n ) );
+
+    auto const& c1 = _storage->nodes[n].children[0];
+    auto const& c2 = _storage->nodes[n].children[1];
+    auto const& c3 = _storage->nodes[n].children[2];
+
+    auto tt1 = *begin++;
+    auto tt2 = *begin++;
+    auto tt3 = *begin++;
+
+    assert( tt1.num_bits() > 0 && "truth tables must not be empty" );
+    assert( tt1.num_bits() == tt2.num_bits() );
+    assert( tt1.num_bits() == tt3.num_bits() );
+    assert( tt1.num_bits() >= result.num_bits() );
+    assert( result.num_blocks() == tt1.num_blocks() || ( result.num_blocks() == tt1.num_blocks() - 1 && result.num_bits() % 64 == 0 ) );
+
+    result.resize( tt1.num_bits() );
+    if ( is_xor3( n ) )
+    {
+      result._bits.back() =
+          ( c1.weight ? ~tt1._bits.back() : tt1._bits.back() ) ^
+          ( c2.weight ? ~tt2._bits.back() : tt2._bits.back() ) ^
+          ( c3.weight ? ~tt3._bits.back() : tt3._bits.back() );
+    }
+    else
+    {
+      result._bits.back() =
+          ( ( c1.weight ? ~tt1._bits.back() : tt1._bits.back() ) & ( c2.weight ? ~tt2._bits.back() : tt2._bits.back() ) ) |
+          ( ( c1.weight ? ~tt1._bits.back() : tt1._bits.back() ) & ( c3.weight ? ~tt3._bits.back() : tt3._bits.back() ) ) |
+          ( ( c2.weight ? ~tt2._bits.back() : tt2._bits.back() ) & ( c3.weight ? ~tt3._bits.back() : tt3._bits.back() ) );
+    }
+    result.mask_bits();
+  }
+#pragma endregion
+
+#pragma region Custom node values
+  void clear_values() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[0].h2 = 0; } );
+  }
+
+  auto value( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h2;
+  }
+
+  void set_value( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[0].h2 = v;
+  }
+
+  auto incr_value( node const& n ) const
+  {
+    return _storage->nodes[n].data[0].h2++;
+  }
+
+  auto decr_value( node const& n ) const
+  {
+    return --_storage->nodes[n].data[0].h2;
+  }
+#pragma endregion
+
+#pragma region Visited flags
+  void clear_visited() const
+  {
+    std::for_each( _storage->nodes.begin(), _storage->nodes.end(), []( auto& n ) { n.data[1].h1 = 0; } );
+  }
+
+  auto visited( node const& n ) const
+  {
+    return _storage->nodes[n].data[1].h1;
+  }
+
+  void set_visited( node const& n, uint32_t v ) const
+  {
+    _storage->nodes[n].data[1].h1 = v;
+  }
+
+  uint32_t trav_id() const
+  {
+    return _storage->trav_id;
+  }
+
+  void incr_trav_id() const
+  {
+    ++_storage->trav_id;
+  }
+#pragma endregion
+
+#pragma region General methods
+  auto& events() const
+  {
+    return *_events;
+  }
+#pragma endregion
+
+public:
+  std::shared_ptr<xmg_storage> _storage;
+  std::shared_ptr<network_events<base_type>> _events;
+};
+
+} // namespace mockturtle
+
+namespace std
+{
+
+template<>
+struct hash<mockturtle::xmg_network::signal>
+{
+  uint64_t operator()( mockturtle::xmg_network::signal const& s ) const noexcept
+  {
+    uint64_t k = s.data;
+    k ^= k >> 33;
+    k *= 0xff51afd7ed558ccd;
+    k ^= k >> 33;
+    k *= 0xc4ceb9fe1a85ec53;
+    k ^= k >> 33;
+    return k;
+  }
+}; /* hash */
+
+} // namespace std
\ No newline at end of file
diff --git a/include/mockturtle/properties/aqfpcost.hpp b/include/mockturtle/properties/aqfpcost.hpp
new file mode 100644
index 0000000..dd1503a
--- /dev/null
+++ b/include/mockturtle/properties/aqfpcost.hpp
@@ -0,0 +1,237 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aqfpcost.hpp
+  \brief Cost functions for AQFP networks
+
+  \author Dewmini Sudara Marakkalage
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <iostream>
+#include <limits>
+#include <unordered_map>
+#include <vector>
+
+#include "../utils/hash_functions.hpp"
+#include "../views/fanout_view.hpp"
+
+#include "../algorithms/aqfp/aqfp_assumptions.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Cost function for computing the best splitter and buffer cost for a fanout net with given relative levels. */
+class fanout_net_cost
+{
+public:
+  static constexpr double IMPOSSIBLE = std::numeric_limits<double>::infinity();
+
+  fanout_net_cost( const std::unordered_map<uint32_t, double>& splitters )
+      : buffer_cost( splitters.at( 1u ) ), splitters( remove_buffer( splitters ) )
+  {
+  }
+
+  double operator()( const std::vector<uint32_t>& config )
+  {
+    return cost_for_config( config, false );
+  }
+
+  double operator()( const std::vector<uint32_t>& config, bool ignore_initial_buffers )
+  {
+    return cost_for_config( config, ignore_initial_buffers );
+  }
+
+private:
+  using cache_key_t = std::tuple<bool, std::vector<uint32_t>>;
+
+  double buffer_cost;
+  std::unordered_map<uint32_t, double> splitters;
+  std::unordered_map<cache_key_t, double, hash<cache_key_t>> cache;
+
+  static std::unordered_map<uint32_t, double> remove_buffer( std::unordered_map<uint32_t, double> splitters )
+  {
+    splitters.erase( 1u );
+    return splitters;
+  }
+
+  double cost_for_config( const std::vector<uint32_t> config, bool ignore_initial_buffers )
+  {
+    if ( config.size() == 1 )
+    {
+      if ( config[0] >= 1 )
+      {
+        return ignore_initial_buffers ? 0.0 : ( config[0] - 1 ) * buffer_cost;
+      }
+      else
+      {
+        return IMPOSSIBLE;
+      }
+    }
+
+    std::tuple key = { ignore_initial_buffers, config };
+    if ( cache.count( key ) )
+    {
+      return cache[key];
+    }
+
+    auto result = IMPOSSIBLE;
+
+    for ( const auto& s : splitters )
+    {
+      for ( auto size = 2u; size <= std::min( s.first, uint32_t( config.size() ) ); size++ )
+      {
+        auto sp_lev = config[config.size() - size] - 1;
+        if ( sp_lev == 0 )
+        {
+          continue;
+        }
+
+        auto temp = s.second;
+
+        for ( auto i = config.size() - size; i < config.size(); i++ )
+        {
+          temp += ( config[i] - config[config.size() - size] ) * buffer_cost;
+        }
+
+        std::vector<uint32_t> new_config( config.begin(), config.begin() + ( config.size() - size ) );
+        new_config.push_back( sp_lev );
+        std::stable_sort( new_config.begin(), new_config.end() );
+
+        temp += cost_for_config( new_config, ignore_initial_buffers );
+
+        if ( temp < result )
+        {
+          result = temp;
+        }
+      }
+    }
+
+    return ( cache[key] = result );
+  }
+};
+
+/*! \brief Cost function for computing the cost of a path-balanced AQFP network with a given assignment of node levels.
+ *
+ * Assumes no path balancing or splitters are needed for primary inputs or register outputs.
+ */
+struct aqfp_network_cost
+{
+  static constexpr double IMPOSSIBLE = std::numeric_limits<double>::infinity();
+
+  aqfp_network_cost( const aqfp_assumptions& assume, const std::unordered_map<uint32_t, double>& gate_costs, const std::unordered_map<uint32_t, double>& splitters )
+      : assume( assume ), gate_costs( gate_costs ), fanout_cc( splitters ) {}
+
+  template<typename Ntk, typename LevelMap, typename PoLevelMap>
+  double operator()( const Ntk& ntk, const LevelMap& level_of_node, const PoLevelMap& po_level_of_node )
+  {
+    /*  Collect fanouts of each node.
+        Cannot use the fanout_view as duplicate fanis are not accounted with the correct multiplicity. */
+    std::unordered_map<node<Ntk>, std::vector<node<Ntk>>> fanouts;
+    ntk.foreach_gate( [&]( auto n ) { ntk.foreach_fanin( n, [&]( auto fi ) { fanouts[ntk.get_node( fi )].push_back( n ); } ); } );
+
+    auto gate_cost = 0.0;
+    auto fanout_net_cost = 0.0;
+
+    std::vector<node<Ntk>> nodes;
+    if ( assume.branch_pis )
+    {
+      ntk.foreach_ci( [&]( auto n ) { nodes.push_back( n ); } );
+    }
+    ntk.foreach_gate( [&]( auto n ) { nodes.push_back( n ); } );
+
+    if ( po_level_of_node.size() == 0 )
+    {
+      std::cout << "[w] - the map po_level_of_node is empty!\n";
+    }
+
+    size_t critical_po_level = std::max_element( po_level_of_node.begin(), po_level_of_node.end(), []( auto n1, auto n2 ) { return n1.second < n2.second; } )
+                                   ->second;
+    for ( auto n : nodes )
+    {
+      if ( !ntk.is_ci( n ) ) // n must be a gate
+      {
+        gate_cost += gate_costs.at( ntk.fanin_size( n ) );
+      }
+
+      if ( ntk.fanout_size( n ) == 0 )
+      {
+        std::cout << fmt::format( "[w] - dangling node {}\n", n );
+        continue;
+      }
+
+      std::vector<uint32_t> rellev;
+
+      for ( auto fo : fanouts[n] )
+      {
+        assert( level_of_node.at( fo ) > level_of_node.at( n ) );
+        rellev.push_back( level_of_node.at( fo ) - level_of_node.at( n ) );
+      }
+
+      uint32_t pos = 0u;
+      while ( rellev.size() < ntk.fanout_size( n ) )
+      {
+        pos++;
+        if ( assume.balance_pos )
+        {
+          rellev.push_back( critical_po_level + 1 - level_of_node.at( n ) );
+        }
+        else
+        {
+          rellev.push_back( po_level_of_node.at( n ) + 1 - level_of_node.at( n ) );
+        }
+      }
+
+      if ( rellev.size() > 1u || ( rellev.size() == 1u && rellev[0] > 0 ) )
+      {
+        std::stable_sort( rellev.begin(), rellev.end() );
+        auto net_cost = fanout_cc( rellev, ntk.is_ci( n ) && !assume.balance_pis );
+        if ( net_cost == std::numeric_limits<double>::infinity() )
+        {
+          std::cerr << fmt::format( "[e] impossible to synthesize fanout net of node {} for relative levels [{}]\n", n, fmt::join( rellev, " " ) );
+          std::abort();
+        }
+        fanout_net_cost += net_cost;
+      }
+      else
+      {
+        std::cerr << fmt::format( "[e] invalid level assignment for node {} with levels [{}]\n", n, fmt::join( rellev, " " ) );
+        std::abort();
+      }
+    }
+
+    return gate_cost + fanout_net_cost;
+  }
+
+private:
+  aqfp_assumptions assume;
+  std::unordered_map<uint32_t, double> gate_costs;
+  fanout_net_cost fanout_cc;
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/properties/litcost.hpp b/include/mockturtle/properties/litcost.hpp
new file mode 100644
index 0000000..5e2fad3
--- /dev/null
+++ b/include/mockturtle/properties/litcost.hpp
@@ -0,0 +1,270 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file litcost.hpp
+  \brief Cost function based on the factored literal cost
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include <kitty/constructors.hpp>
+#include <kitty/cube.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/isop.hpp>
+
+#include "../utils/sop_utils.hpp"
+
+namespace mockturtle
+{
+
+namespace detail
+{
+uint32_t count_literals_rec( std::vector<uint64_t>&, uint32_t const );
+
+uint32_t count_term_literals( uint64_t const term, uint32_t const num_lit )
+{
+  uint32_t lit = 0;
+
+  for ( auto i = 0u; i < num_lit; ++i )
+  {
+    if ( cube_has_lit( term, i ) )
+      ++lit;
+  }
+
+  return lit;
+}
+
+uint32_t lit_factor_count_rec( std::vector<uint64_t> const& sop, uint64_t const c_sop, uint32_t const num_lit )
+{
+  using sop_t = std::vector<uint64_t>;
+
+  sop_t divisor, quotient, reminder;
+
+  /* extract the best literal */
+  sop_best_literal( sop, divisor, c_sop, num_lit );
+
+  /* divide SOP by the literal */
+  sop_divide_by_cube( sop, divisor, quotient, reminder );
+
+  /* count literals in the divisor: cube */
+  uint32_t div_lit = count_term_literals( divisor[0], num_lit );
+
+  /* factor the quotient */
+  uint32_t quot_lit = count_literals_rec( quotient, num_lit );
+
+  /* factor the reminder */
+  if ( reminder.size() != 0 )
+  {
+    return div_lit + quot_lit + count_literals_rec( reminder, num_lit );
+  }
+
+  return div_lit + quot_lit;
+}
+
+uint32_t count_literals_rec( std::vector<uint64_t>& sop, uint32_t const num_lit )
+{
+  using sop_t = std::vector<uint64_t>;
+
+  assert( sop.size() );
+
+  sop_t divisor, quotient, reminder;
+
+  /* compute the divisor */
+  if ( !sop_quick_divisor( sop, divisor, num_lit ) )
+  {
+    /* count_literals of the current SOP */
+    return sop_count_literals( sop );
+  }
+
+  /* divide the SOP by the divisor */
+  sop_divide( sop, divisor, quotient, reminder );
+
+  assert( quotient.size() > 0 );
+
+  if ( quotient.size() == 1 )
+  {
+    return lit_factor_count_rec( sop, quotient[0], num_lit );
+  }
+
+  sop_make_cube_free( quotient );
+
+  /* divide the SOP by the quotient */
+  sop_divide( sop, quotient, divisor, reminder );
+
+  if ( sop_is_cube_free( divisor ) )
+  {
+    uint32_t div_lit = count_literals_rec( divisor, num_lit );
+    uint32_t quot_lit = count_literals_rec( quotient, num_lit );
+
+    if ( reminder.size() )
+    {
+      return div_lit + quot_lit + count_literals_rec( reminder, num_lit );
+    }
+
+    return div_lit + quot_lit;
+  }
+
+  /* get the common cube */
+  uint64_t cube = UINT64_MAX;
+  for ( auto const& c : divisor )
+  {
+    cube &= c;
+  }
+
+  return lit_factor_count_rec( sop, cube, num_lit );
+}
+
+} // namespace detail
+
+/*! \brief Counts number of literals of the factored form of a SOP.
+ *
+ * This method computes the factored form of the SOP and
+ * returns its number of factored form literals.
+ *
+ * \param sop Sum-of-products
+ * \param num_vars Number of variables
+ */
+uint32_t factored_literal_cost( std::vector<kitty::cube> const& sop, uint32_t num_vars )
+{
+  /* trivial cases: constant 0 or 1 */
+  if ( sop.size() == 0 || sop.size() == 1 && sop[0]._mask == 0 )
+    return 0;
+
+  using sop_t = std::vector<uint64_t>;
+  sop_t lit_sop = cubes_to_sop( sop, num_vars );
+
+  return detail::count_literals_rec( lit_sop, num_vars * 2 );
+}
+
+/*! \brief Counts number of literals of the factored form of a SOP.
+ *
+ * This method computes the factored form of a completely specified
+ * function given as a truth table and returns its number of
+ * factored form literals.
+ *
+ * \param tt function as truth table
+ * \param try_both_polarities factoring is also tried for the negated TT
+ */
+uint32_t factored_literal_cost( kitty::dynamic_truth_table const& tt, bool try_both_polarities = false )
+{
+  if ( kitty::is_const0( tt ) || kitty::is_const0( ~tt ) )
+  {
+    /* constant */
+    return 0;
+  }
+
+  std::vector<kitty::cube> cubes = kitty::isop( tt );
+
+  if ( try_both_polarities )
+  {
+    std::vector<kitty::cube> n_cubes = kitty::isop( ~tt );
+
+    if ( n_cubes.size() < cubes.size() )
+    {
+      cubes = n_cubes;
+    }
+    else if ( n_cubes.size() == cubes.size() )
+    {
+      uint32_t n_lit = 0;
+      uint32_t lit = 0;
+      for ( auto const& c : n_cubes )
+      {
+        n_lit += c.num_literals();
+      }
+      for ( auto const& c : cubes )
+      {
+        lit += c.num_literals();
+      }
+
+      if ( n_lit < lit )
+      {
+        cubes = n_cubes;
+      }
+    }
+  }
+
+  return factored_literal_cost( cubes, tt.num_vars() );
+}
+
+/*! \brief Counts number of literals of the factored form of a SOP.
+ *
+ * This method computes the factored form of an incompletely specified
+ * function given as a truth table and its don't care set and returns
+ * its number of factored form literals.
+ *
+ * \param tt function as truth table
+ * \param dc don't care set
+ * \param try_both_polarities factoring is also tried for the negated TT
+ */
+uint32_t factored_literal_cost( kitty::dynamic_truth_table const& tt, kitty::dynamic_truth_table const& dc, bool try_both_polarities = false )
+{
+  if ( kitty::is_const0( tt & ( ~dc ) ) || kitty::is_const0( ~( tt | dc ) ) )
+  {
+    /* constant */
+    return 0;
+  }
+
+  std::vector<kitty::cube> cubes;
+  kitty::detail::isop_rec( tt & ~dc, tt | dc, tt.num_vars(), cubes );
+
+  if ( try_both_polarities )
+  {
+    std::vector<kitty::cube> n_cubes;
+    kitty::detail::isop_rec( ~tt & ~dc, ~tt | dc, tt.num_vars(), n_cubes );
+
+    if ( n_cubes.size() < cubes.size() )
+    {
+      cubes = n_cubes;
+    }
+    else if ( n_cubes.size() == cubes.size() )
+    {
+      uint32_t n_lit = 0;
+      uint32_t lit = 0;
+      for ( auto const& c : n_cubes )
+      {
+        n_lit += c.num_literals();
+      }
+      for ( auto const& c : cubes )
+      {
+        lit += c.num_literals();
+      }
+
+      if ( n_lit < lit )
+      {
+        cubes = n_cubes;
+      }
+    }
+  }
+
+  return factored_literal_cost( cubes, tt.num_vars() );
+}
+
+} // namespace mockturtle
diff --git a/include/mockturtle/properties/mccost.hpp b/include/mockturtle/properties/mccost.hpp
new file mode 100644
index 0000000..59622c6
--- /dev/null
+++ b/include/mockturtle/properties/mccost.hpp
@@ -0,0 +1,301 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mccost.hpp
+  \brief Cost functions based on multiplicative-complexity
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+
+#include "../traits.hpp"
+#include "../utils/node_map.hpp"
+#include "../views/topo_view.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Computes the multiplicative complexity
+ *
+ * Computes and sums the multiplicative complexity of each gate in the network.
+ * Returns `std::nullopt`, if multiplicative complexity cannot be determined
+ * for some gate.
+ *
+ * \param ntk Network
+ */
+template<class Ntk>
+std::optional<uint32_t> multiplicative_complexity( Ntk const& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+
+  uint32_t total{ 0u };
+  bool valid{ true };
+
+  ntk.foreach_gate( [&]( auto const& n ) {
+    if constexpr ( has_is_and_v<Ntk> )
+    {
+      if ( ntk.is_and( n ) )
+      {
+        total++;
+        return true;
+      }
+    }
+
+    if constexpr ( has_is_or_v<Ntk> )
+    {
+      if ( ntk.is_or( n ) )
+      {
+        total++;
+        return true;
+      }
+    }
+
+    if constexpr ( has_is_xor_v<Ntk> )
+    {
+      if ( ntk.is_xor( n ) )
+      {
+        return true;
+      }
+    }
+
+    if constexpr ( has_is_maj_v<Ntk> )
+    {
+      if ( ntk.is_maj( n ) )
+      {
+        total++;
+        return true;
+      }
+    }
+
+    if constexpr ( has_is_ite_v<Ntk> )
+    {
+      if ( ntk.is_ite( n ) )
+      {
+        total++;
+        return true;
+      }
+    }
+
+    if constexpr ( has_is_xor3_v<Ntk> )
+    {
+      if ( ntk.is_xor3( n ) )
+      {
+        return true;
+      }
+    }
+
+    if constexpr ( has_is_nary_and_v<Ntk> )
+    {
+      if ( ntk.is_nary_and( n ) )
+      {
+        if ( ntk.fanin_size( n ) > 1u )
+        {
+          total += ntk.fanin_size( n ) - 1u;
+        }
+        return true;
+      }
+    }
+
+    if constexpr ( has_is_nary_or_v<Ntk> )
+    {
+      if ( ntk.is_nary_or( n ) )
+      {
+        if ( ntk.fanin_size( n ) > 1u )
+        {
+          total += ntk.fanin_size( n ) - 1u;
+        }
+        return true;
+      }
+    }
+
+    if constexpr ( has_is_nary_xor_v<Ntk> )
+    {
+      if ( ntk.is_nary_xor( n ) )
+      {
+        return true;
+      }
+    }
+
+    valid = false;
+    return false; /* break */
+  } );
+
+  if ( valid )
+  {
+    return total;
+  }
+  else
+  {
+    return std::nullopt;
+  }
+}
+
+/*! \brief Computes the multiplicative complexity depth
+ *
+ * Computes multiplicative complexity of each gate and the sum of them on the
+ * critical path in the network. Returns `std::nullopt`, if multiplicative
+ * complexity cannot be determined for some gate.
+ *
+ * \param ntk Network
+ */
+template<class Ntk>
+std::optional<uint32_t> multiplicative_complexity_depth( Ntk const& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+
+  bool valid{ true };
+
+  node_map<uint32_t, Ntk> level( ntk, 0u );
+  topo_view<Ntk> topo{ ntk };
+
+  topo.foreach_node( [&]( auto const& n ) {
+    if ( ntk.is_constant( n ) || ntk.is_pi( n ) )
+    {
+      return true;
+    }
+
+    /* compute the maximum MC of children */
+    uint32_t max_level{ 0u };
+    ntk.foreach_fanin( n, [&]( const auto& f ) {
+      if ( level[f] > max_level )
+      {
+        max_level = level[f];
+      }
+    } );
+
+    if ( has_is_and_v<Ntk> )
+    {
+      if ( ntk.is_and( n ) )
+      {
+        level[n] = max_level + 1u;
+        return true;
+      }
+    }
+
+    if ( has_is_or_v<Ntk> )
+    {
+      if ( ntk.is_or( n ) )
+      {
+        level[n] = max_level + 1u;
+        return true;
+      }
+    }
+
+    if ( has_is_xor_v<Ntk> )
+    {
+      if ( ntk.is_xor( n ) )
+      {
+        level[n] = max_level;
+        return true;
+      }
+    }
+
+    if ( has_is_maj_v<Ntk> )
+    {
+      if ( ntk.is_maj( n ) )
+      {
+        level[n] = max_level + 1u;
+        return true;
+      }
+    }
+
+    if ( has_is_ite_v<Ntk> )
+    {
+      if ( ntk.is_ite( n ) )
+      {
+        level[n] = max_level + 1u;
+        return true;
+      }
+    }
+
+    if ( has_is_xor3_v<Ntk> )
+    {
+      if ( ntk.is_xor3( n ) )
+      {
+        level[n] = max_level;
+        return true;
+      }
+    }
+
+    if ( has_is_nary_and_v<Ntk> )
+    {
+      if ( ntk.is_nary_and( n ) )
+      {
+        level[n] = max_level + static_cast<uint32_t>( std::ceil( std::log2( ntk.fanin_size( n ) ) ) );
+        return true;
+      }
+    }
+
+    if ( has_is_nary_or_v<Ntk> )
+    {
+      if ( ntk.is_nary_or( n ) )
+      {
+        level[n] = max_level + static_cast<uint32_t>( std::ceil( std::log2( ntk.fanin_size( n ) ) ) );
+        return true;
+      }
+    }
+
+    if ( has_is_nary_xor_v<Ntk> )
+    {
+      if ( ntk.is_nary_xor( n ) )
+      {
+        level[n] = max_level;
+        return true;
+      }
+    }
+
+    valid = false;
+    return false; /* break */
+  } );
+
+  if ( valid )
+  {
+    uint32_t max_level{ 0u };
+    ntk.foreach_po( [&]( const auto& f ) {
+      if ( level[f] > max_level )
+      {
+        max_level = level[f];
+      }
+    } );
+    return max_level;
+  }
+  else
+  {
+    return std::nullopt;
+  }
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/properties/migcost.hpp b/include/mockturtle/properties/migcost.hpp
new file mode 100644
index 0000000..82342b1
--- /dev/null
+++ b/include/mockturtle/properties/migcost.hpp
@@ -0,0 +1,117 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file migcost.hpp
+  \brief Cost functions for majority-based technologies
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <unordered_set>
+
+#include "../traits.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Counts number of inverters.
+ *
+ * This number counts all nodes that need to be inverted.  Multiple signals
+ * with complements to the same node are counted once.
+ *
+ * \param ntk Network
+ */
+template<class Ntk>
+uint32_t num_inverters( Ntk const& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+
+  std::unordered_set<node<Ntk>> inverted_nodes;
+
+  ntk.foreach_gate( [&]( auto const& n ) {
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      if ( ntk.is_complemented( f ) )
+      {
+        inverted_nodes.insert( ntk.get_node( f ) );
+      }
+    } );
+  } );
+
+  ntk.foreach_po( [&]( auto const& f ) {
+    if ( ntk.is_complemented( f ) )
+    {
+      inverted_nodes.insert( ntk.get_node( f ) );
+    }
+  } );
+
+  return static_cast<uint32_t>( inverted_nodes.size() );
+}
+
+/*! \brief Counts fanins which are primary inputs.
+ *
+ * \param ntk Network
+ */
+template<class Ntk>
+uint32_t num_dangling_inputs( Ntk const& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+
+  uint32_t costs{ 0u };
+
+  ntk.foreach_gate( [&]( auto const& n ) {
+    ntk.foreach_fanin( n, [&]( auto const& f ) {
+      if ( ntk.is_pi( ntk.get_node( f ) ) )
+      {
+        costs++;
+      }
+    } );
+  } );
+
+  ntk.foreach_po( [&]( auto const& f ) {
+    if ( ntk.is_pi( ntk.get_node( f ) ) )
+    {
+      costs++;
+    }
+  } );
+
+  return costs;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/properties/xmgcost.hpp b/include/mockturtle/properties/xmgcost.hpp
new file mode 100644
index 0000000..a6a4409
--- /dev/null
+++ b/include/mockturtle/properties/xmgcost.hpp
@@ -0,0 +1,129 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file xmgcost.hpp
+  \brief Cost functions for xmg-based networks
+
+  \author Heinz Riener
+  \author Shubham Rai
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+
+#include <fmt/format.h>
+
+namespace mockturtle
+{
+
+struct xmg_gate_stats
+{
+  /*! \brief Total number of XOR3 gates (structurally). */
+  uint32_t total_xor3{ 0 };
+
+  /*! \brief Number of XOR3 (functionally). */
+  uint32_t xor3{ 0 };
+
+  /*! \brief Number of XOR2 (functionally). */
+  uint32_t xor2{ 0 };
+
+  /*! \brief Total number of MAJ gates (structurally). */
+  uint32_t total_maj{ 0 };
+
+  /*! \brief Number of MAJ gates. */
+  uint32_t maj{ 0 };
+
+  /*! \brief Number of AND/OR gates. */
+  uint32_t and_or{ 0 };
+
+  void report() const
+  {
+    fmt::print( "XOR3: {} = {} XOR3 + {} XOR2 / MAJ: {} = {} MAJ3 + {} AND/OR\n",
+                total_xor3, xor2, xor3, total_maj, maj, and_or );
+  }
+};
+
+/*! \brief Profile gates
+ *
+ * Counts the numbers of MAJ and XOR nodes in an XMG.
+ *
+ * \param ntk Network
+ * \param stats Statistics
+ */
+template<class Ntk>
+void xmg_profile_gates( Ntk const& ntk, xmg_gate_stats& stats )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+  static_assert( has_is_maj_v<Ntk>, "Ntk does not implement the is_maj method" );
+  static_assert( has_is_xor3_v<Ntk>, "Ntk does not implement the is_xor3 method" );
+
+  ntk.foreach_gate( [&]( auto const& node ) {
+    bool has_const_fanin = false;
+
+    /* Check if all of the fanin nodes are not constant */
+    ntk.foreach_fanin( node, [&]( auto const& f ) {
+      if ( ntk.is_constant( ntk.get_node( f ) ) )
+      {
+        has_const_fanin = true;
+        return false;
+      }
+      return true;
+    } );
+
+    if ( ntk.is_maj( node ) )
+    {
+      if ( has_const_fanin )
+      {
+        ++stats.and_or;
+      }
+      else
+      {
+        ++stats.maj;
+      }
+    }
+    else if ( ntk.is_xor3( node ) )
+    {
+      if ( has_const_fanin )
+      {
+        ++stats.xor2;
+      }
+      else
+      {
+        ++stats.xor3;
+      }
+    }
+  } );
+
+  stats.total_xor3 = stats.xor2 + stats.xor3;
+  stats.total_maj = stats.and_or + stats.maj;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/traits.hpp b/include/mockturtle/traits.hpp
new file mode 100644
index 0000000..2808733
--- /dev/null
+++ b/include/mockturtle/traits.hpp
@@ -0,0 +1,2674 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file traits.hpp
+  \brief Type traits and checkers for the network interface
+
+  \author Alessandro Tempia Calvino
+  \author Andrea Costamagna
+  \author Bruno Schmitt
+  \author Hanyu Wang
+  \author Heinz Riener
+  \author Marcel Walter
+  \author Mathias Soeken
+  \author Max Austin
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <list>
+#include <map>
+#include <string>
+#include <type_traits>
+
+#include <kitty/cube.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/traits.hpp>
+
+namespace mockturtle
+{
+
+template<typename Ntk>
+using signal = typename Ntk::signal;
+
+template<typename Ntk>
+using node = typename Ntk::node;
+
+template<class Ntk, class = void>
+struct is_network_type : std::false_type
+{
+};
+
+template<class Ntk>
+struct is_network_type<Ntk, std::enable_if_t<
+                                std::is_constructible_v<signal<Ntk>, node<Ntk>>,
+                                std::void_t<typename Ntk::base_type,
+                                            signal<Ntk>,
+                                            node<Ntk>,
+                                            typename Ntk::storage,
+                                            decltype( Ntk::max_fanin_size ),
+                                            decltype( Ntk::min_fanin_size )>>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool is_network_type_v = is_network_type<Ntk>::value;
+
+#pragma region is_aig_network_type
+template<class Ntk, class = void>
+struct is_aig_network_type : std::false_type
+{
+};
+
+template<class Ntk>
+struct is_aig_network_type<Ntk, std::enable_if_t<Ntk::is_aig_network_type, std::void_t<decltype( Ntk::is_aig_network_type )>>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool is_aig_network_type_v = is_aig_network_type<Ntk>::value;
+#pragma endregion
+
+#pragma region is_buffered_network_type
+template<class Ntk, class = void>
+struct is_buffered_network_type : std::false_type
+{
+};
+
+template<class Ntk>
+struct is_buffered_network_type<Ntk, std::enable_if_t<Ntk::is_buffered_network_type, std::void_t<decltype( Ntk::is_buffered_network_type )>>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool is_buffered_network_type_v = is_buffered_network_type<Ntk>::value;
+#pragma endregion
+
+#pragma region is_crossed_network_type
+template<class Ntk, class = void>
+struct is_crossed_network_type : std::false_type
+{
+};
+
+template<class Ntk>
+struct is_crossed_network_type<Ntk, std::enable_if_t<Ntk::is_crossed_network_type, std::void_t<decltype( Ntk::is_crossed_network_type )>>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool is_crossed_network_type_v = is_crossed_network_type<Ntk>::value;
+#pragma endregion
+
+#pragma region has_clone
+template<class Ntk, class = void>
+struct has_clone : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_clone<Ntk, std::void_t<decltype( std::declval<Ntk>().clone() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_clone_v = has_clone<Ntk>::value;
+#pragma endregion
+
+#pragma region is_topologically_sorted
+template<class Ntk, class = void>
+struct is_topologically_sorted : std::false_type
+{
+};
+
+template<class Ntk>
+struct is_topologically_sorted<Ntk, std::enable_if_t<Ntk::is_topologically_sorted, std::void_t<decltype( Ntk::is_topologically_sorted )>>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool is_topologically_sorted_v = is_topologically_sorted<Ntk>::value;
+#pragma endregion
+
+#pragma region has_get_constant
+template<class Ntk, class = void>
+struct has_get_constant : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_get_constant<Ntk, std::void_t<decltype( std::declval<Ntk>().get_constant( bool() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_get_constant_v = has_get_constant<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_pi
+template<class Ntk, class = void>
+struct has_create_pi : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_pi<Ntk, std::void_t<decltype( std::declval<Ntk>().create_pi() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_pi_v = has_create_pi<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_po
+template<class Ntk, class = void>
+struct has_create_po : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_po<Ntk, std::void_t<decltype( std::declval<Ntk>().create_po( std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_po_v = has_create_po<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_ro
+template<class Ntk, class = void>
+struct has_create_ro : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_ro<Ntk, std::void_t<decltype( std::declval<Ntk>().create_ro() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_ro_v = has_create_ro<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_ri
+template<class Ntk, class = void>
+struct has_create_ri : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_ri<Ntk, std::void_t<decltype( std::declval<Ntk>().create_ri( std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_ri_v = has_create_ri<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_combinational
+template<class Ntk, class = void>
+struct has_is_combinational : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_combinational<Ntk, std::void_t<decltype( std::declval<Ntk>().is_combinational() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_combinational_v = has_is_combinational<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_constant
+template<class Ntk, class = void>
+struct has_is_constant : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_constant<Ntk, std::void_t<decltype( std::declval<Ntk>().is_constant( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_constant_v = has_is_constant<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_ci
+template<class Ntk, class = void>
+struct has_is_ci : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_ci<Ntk, std::void_t<decltype( std::declval<Ntk>().is_ci( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_ci_v = has_is_ci<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_pi
+template<class Ntk, class = void>
+struct has_is_pi : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_pi<Ntk, std::void_t<decltype( std::declval<Ntk>().is_pi( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_pi_v = has_is_pi<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_ro
+template<class Ntk, class = void>
+struct has_is_ro : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_ro<Ntk, std::void_t<decltype( std::declval<Ntk>().is_ro( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_ro_v = has_is_ro<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_ro
+template<class Ntk, class = void>
+struct has_is_multioutput : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_multioutput<Ntk, std::void_t<decltype( std::declval<Ntk>().is_multioutput( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_multioutput_v = has_is_multioutput<Ntk>::value;
+#pragma endregion
+
+#pragma region has_constant_value
+template<class Ntk, class = void>
+struct has_constant_value : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_constant_value<Ntk, std::void_t<decltype( std::declval<Ntk>().constant_value( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_constant_value_v = has_constant_value<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_buf
+template<class Ntk, class = void>
+struct has_create_buf : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_buf<Ntk, std::void_t<decltype( std::declval<Ntk>().create_buf( std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_buf_v = has_create_buf<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_not
+template<class Ntk, class = void>
+struct has_create_not : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_not<Ntk, std::void_t<decltype( std::declval<Ntk>().create_not( std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_not_v = has_create_not<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_and
+template<class Ntk, class = void>
+struct has_create_and : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_and<Ntk, std::void_t<decltype( std::declval<Ntk>().create_and( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_and_v = has_create_and<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_nand
+template<class Ntk, class = void>
+struct has_create_nand : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_nand<Ntk, std::void_t<decltype( std::declval<Ntk>().create_nand( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_nand_v = has_create_nand<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_or
+template<class Ntk, class = void>
+struct has_create_or : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_or<Ntk, std::void_t<decltype( std::declval<Ntk>().create_or( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_or_v = has_create_or<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_nor
+template<class Ntk, class = void>
+struct has_create_nor : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_nor<Ntk, std::void_t<decltype( std::declval<Ntk>().create_nor( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_nor_v = has_create_nor<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_lt
+template<class Ntk, class = void>
+struct has_create_lt : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_lt<Ntk, std::void_t<decltype( std::declval<Ntk>().create_lt( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_lt_v = has_create_lt<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_le
+template<class Ntk, class = void>
+struct has_create_le : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_le<Ntk, std::void_t<decltype( std::declval<Ntk>().create_le( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_le_v = has_create_le<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_gt
+template<class Ntk, class = void>
+struct has_create_gt : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_gt<Ntk, std::void_t<decltype( std::declval<Ntk>().create_gt( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_gt_v = has_create_gt<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_ge
+template<class Ntk, class = void>
+struct has_create_ge : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_ge<Ntk, std::void_t<decltype( std::declval<Ntk>().create_ge( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_ge_v = has_create_ge<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_xor
+template<class Ntk, class = void>
+struct has_create_xor : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_xor<Ntk, std::void_t<decltype( std::declval<Ntk>().create_xor( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_xor_v = has_create_xor<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_xnor
+template<class Ntk, class = void>
+struct has_create_xnor : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_xnor<Ntk, std::void_t<decltype( std::declval<Ntk>().create_xnor( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_xnor_v = has_create_xnor<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_maj
+template<class Ntk, class = void>
+struct has_create_maj : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_maj<Ntk, std::void_t<decltype( std::declval<Ntk>().create_maj( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_maj_v = has_create_maj<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_maj_odd
+template<class Ntk, class = void>
+struct has_create_maj_odd : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_maj_odd<Ntk, std::void_t<decltype( std::declval<Ntk>().create_maj( std::declval<std::vector<signal<Ntk>>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_maj_odd_v = has_create_maj_odd<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_ite
+template<class Ntk, class = void>
+struct has_create_ite : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_ite<Ntk, std::void_t<decltype( std::declval<Ntk>().create_ite( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_ite_v = has_create_ite<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_xor3
+template<class Ntk, class = void>
+struct has_create_xor3 : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_xor3<Ntk, std::void_t<decltype( std::declval<Ntk>().create_xor3( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_xor3_v = has_create_xor3<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_nary_and
+template<class Ntk, class = void>
+struct has_create_nary_and : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_nary_and<Ntk, std::void_t<decltype( std::declval<Ntk>().create_nary_and( std::declval<std::vector<signal<Ntk>>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_nary_and_v = has_create_nary_and<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_nary_or
+template<class Ntk, class = void>
+struct has_create_nary_or : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_nary_or<Ntk, std::void_t<decltype( std::declval<Ntk>().create_nary_or( std::declval<std::vector<signal<Ntk>>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_nary_or_v = has_create_nary_or<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_nary_xor
+template<class Ntk, class = void>
+struct has_create_nary_xor : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_nary_xor<Ntk, std::void_t<decltype( std::declval<Ntk>().create_nary_xor( std::declval<std::vector<signal<Ntk>>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_nary_xor_v = has_create_nary_xor<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_node
+template<class Ntk, class = void>
+struct has_create_node : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_node<Ntk, std::void_t<decltype( std::declval<Ntk>().create_node( std::declval<std::vector<signal<Ntk>>>(), std::declval<kitty::dynamic_truth_table>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_node_v = has_create_node<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_cover_node
+template<class Ntk, class = void>
+struct has_create_cover_node : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_cover_node<Ntk, std::void_t<decltype( std::declval<Ntk>().create_cover_node( std::declval<std::vector<signal<Ntk>>>(), std::declval<std::pair<std::vector<kitty::cube>, bool>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_cover_node_v = has_create_cover_node<Ntk>::value;
+#pragma endregion
+
+#pragma region has_create_crossing
+template<class Ntk, class = void>
+struct has_create_crossing : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_create_crossing<Ntk, std::void_t<decltype( std::declval<Ntk>().create_crossing( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_create_crossing_v = has_create_crossing<Ntk>::value;
+#pragma endregion
+
+#pragma region has_insert_crossing
+template<class Ntk, class = void>
+struct has_insert_crossing : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_insert_crossing<Ntk, std::void_t<decltype( std::declval<Ntk>().insert_crossing( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>(), std::declval<node<Ntk>>(), std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_insert_crossing_v = has_insert_crossing<Ntk>::value;
+#pragma endregion
+
+#pragma region has_merge_into_crossing
+template<class Ntk, class = void>
+struct has_merge_into_crossing : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_merge_into_crossing<Ntk, std::void_t<decltype( std::declval<Ntk>().merge_into_crossing( std::declval<node<Ntk>>(), std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_merge_into_crossing_v = has_merge_into_crossing<Ntk>::value;
+#pragma endregion
+
+#pragma region has_clone_node
+template<class Ntk, class = void>
+struct has_clone_node : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_clone_node<Ntk, std::void_t<decltype( std::declval<Ntk>().clone_node( std::declval<Ntk>(), std::declval<node<Ntk>>(), std::declval<std::vector<signal<Ntk>>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_clone_node_v = has_clone_node<Ntk>::value;
+#pragma endregion
+
+#pragma region has_has_and
+template<class Ntk, class = void>
+struct has_has_and : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_has_and<Ntk, std::void_t<decltype( std::declval<Ntk>().has_and( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_has_and_v = has_has_and<Ntk>::value;
+#pragma endregion
+
+#pragma region has_has_xor
+template<class Ntk, class = void>
+struct has_has_xor : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_has_xor<Ntk, std::void_t<decltype( std::declval<Ntk>().has_xor( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_has_xor_v = has_has_xor<Ntk>::value;
+#pragma endregion
+
+#pragma region has_has_maj
+template<class Ntk, class = void>
+struct has_has_maj : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_has_maj<Ntk, std::void_t<decltype( std::declval<Ntk>().has_maj( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_has_maj_v = has_has_maj<Ntk>::value;
+#pragma endregion
+
+#pragma region has_has_xor3
+template<class Ntk, class = void>
+struct has_has_xor3 : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_has_xor3<Ntk, std::void_t<decltype( std::declval<Ntk>().has_xor3( std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_has_xor3_v = has_has_xor3<Ntk>::value;
+#pragma endregion
+
+#pragma region has_substitute_node
+template<class Ntk, class = void>
+struct has_substitute_node : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_substitute_node<Ntk, std::void_t<decltype( std::declval<Ntk>().substitute_node( std::declval<node<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_substitute_node_v = has_substitute_node<Ntk>::value;
+#pragma endregion
+
+#pragma region has_substitute_nodes
+template<class Ntk, class = void>
+struct has_substitute_nodes : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_substitute_nodes<Ntk, std::void_t<decltype( std::declval<Ntk>().substitute_nodes( std::declval<std::list<std::pair<node<Ntk>, signal<Ntk>>>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_substitute_nodes_v = has_substitute_nodes<Ntk>::value;
+#pragma endregion
+
+#pragma region has_replace_in_node
+template<class Ntk, class = void>
+struct has_replace_in_node : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_replace_in_node<Ntk, std::void_t<decltype( std::declval<Ntk>().replace_in_node( std::declval<node<Ntk>>(), std::declval<node<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_replace_in_node_v = has_replace_in_node<Ntk>::value;
+#pragma endregion
+
+#pragma region has_replace_in_outputs
+template<class Ntk, class = void>
+struct has_replace_in_outputs : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_replace_in_outputs<Ntk, std::void_t<decltype( std::declval<Ntk>().replace_in_outputs( std::declval<node<Ntk>>(), std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_replace_in_outputs_v = has_replace_in_outputs<Ntk>::value;
+#pragma endregion
+
+#pragma region has_take_out_node
+template<class Ntk, class = void>
+struct has_take_out_node : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_take_out_node<Ntk, std::void_t<decltype( std::declval<Ntk>().take_out_node( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_take_out_node_v = has_take_out_node<Ntk>::value;
+#pragma endregion
+
+#pragma region is_dead
+template<class Ntk, class = void>
+struct has_is_dead : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_dead<Ntk, std::void_t<decltype( std::declval<Ntk>().is_dead( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_dead_v = has_is_dead<Ntk>::value;
+#pragma endregion
+
+#pragma region has_size
+template<class Ntk, class = void>
+struct has_size : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_size<Ntk, std::void_t<decltype( std::declval<Ntk>().size() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_size_v = has_size<Ntk>::value;
+#pragma endregion
+
+#pragma region has_num_cis
+template<class Ntk, class = void>
+struct has_num_cis : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_num_cis<Ntk, std::void_t<decltype( std::declval<Ntk>().num_cis() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_num_cis_v = has_num_cis<Ntk>::value;
+#pragma endregion
+
+#pragma region has_num_cos
+template<class Ntk, class = void>
+struct has_num_cos : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_num_cos<Ntk, std::void_t<decltype( std::declval<Ntk>().num_cos() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_num_cos_v = has_num_cos<Ntk>::value;
+#pragma endregion
+
+#pragma region has_num_pis
+template<class Ntk, class = void>
+struct has_num_pis : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_num_pis<Ntk, std::void_t<decltype( std::declval<Ntk>().num_pis() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_num_pis_v = has_num_pis<Ntk>::value;
+#pragma endregion
+
+#pragma region has_num_pos
+template<class Ntk, class = void>
+struct has_num_pos : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_num_pos<Ntk, std::void_t<decltype( std::declval<Ntk>().num_pos() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_num_pos_v = has_num_pos<Ntk>::value;
+#pragma endregion
+
+#pragma region has_num_gates
+template<class Ntk, class = void>
+struct has_num_gates : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_num_gates<Ntk, std::void_t<decltype( std::declval<Ntk>().num_gates() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_num_gates_v = has_num_gates<Ntk>::value;
+#pragma endregion
+
+#pragma region has_num_registers
+template<class Ntk, class = void>
+struct has_num_registers : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_num_registers<Ntk, std::void_t<decltype( std::declval<Ntk>().num_registers() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_num_registers_v = has_num_registers<Ntk>::value;
+#pragma endregion
+
+#pragma region has_fanin_size
+template<class Ntk, class = void>
+struct has_fanin_size : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_fanin_size<Ntk, std::void_t<decltype( std::declval<Ntk>().fanin_size( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_fanin_size_v = has_fanin_size<Ntk>::value;
+#pragma endregion
+
+#pragma region has_num_outputs
+template<class Ntk, class = void>
+struct has_num_outputs : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_num_outputs<Ntk, std::void_t<decltype( std::declval<Ntk>().num_outputs( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_num_outputs_v = has_num_outputs<Ntk>::value;
+#pragma endregion
+
+#pragma region has_fanout_size
+template<class Ntk, class = void>
+struct has_fanout_size : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_fanout_size<Ntk, std::void_t<decltype( std::declval<Ntk>().fanout_size( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_fanout_size_v = has_fanout_size<Ntk>::value;
+#pragma endregion
+
+#pragma region has_incr_fanout_size
+template<class Ntk, class = void>
+struct has_incr_fanout_size : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_incr_fanout_size<Ntk, std::void_t<decltype( std::declval<Ntk>().incr_fanout_size( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_incr_fanout_size_v = has_incr_fanout_size<Ntk>::value;
+#pragma endregion
+
+#pragma region has_decr_fanout_size
+template<class Ntk, class = void>
+struct has_decr_fanout_size : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_decr_fanout_size<Ntk, std::void_t<decltype( std::declval<Ntk>().decr_fanout_size( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_decr_fanout_size_v = has_decr_fanout_size<Ntk>::value;
+#pragma endregion
+
+#pragma region has_cost
+template<class Ntk, class = void>
+struct has_cost : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_cost<Ntk, std::void_t<decltype( std::declval<Ntk>().get_cost() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_cost_v = has_cost<Ntk>::value;
+#pragma endregion
+
+#pragma region has_depth
+template<class Ntk, class = void>
+struct has_depth : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_depth<Ntk, std::void_t<decltype( std::declval<Ntk>().depth() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_depth_v = has_depth<Ntk>::value;
+#pragma endregion
+
+#pragma region has_level
+template<class Ntk, class = void>
+struct has_level : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_level<Ntk, std::void_t<decltype( std::declval<Ntk>().level( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_level_v = has_level<Ntk>::value;
+#pragma endregion
+
+#pragma region has_update_levels
+template<class Ntk, class = void>
+struct has_update_levels : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_update_levels<Ntk, std::void_t<decltype( std::declval<Ntk>().update_levels() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_update_levels_v = has_update_levels<Ntk>::value;
+#pragma endregion
+
+#pragma region has_rank_position
+template<class Ntk, class = void>
+struct has_rank_position : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_rank_position<Ntk, std::void_t<decltype( std::declval<Ntk>().rank_position( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_rank_position_v = has_rank_position<Ntk>::value;
+#pragma endregion
+
+#pragma region has_at_rank_position
+template<class Ntk, class = void>
+struct has_at_rank_position : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_at_rank_position<Ntk, std::void_t<decltype( std::declval<Ntk>().at_rank_position( std::declval<uint32_t>(), std::declval<uint32_t>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_at_rank_position_v = has_at_rank_position<Ntk>::value;
+#pragma endregion
+
+#pragma region has_width
+template<class Ntk, class = void>
+struct has_width : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_width<Ntk, std::void_t<decltype( std::declval<Ntk>().width() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_width_v = has_width<Ntk>::value;
+#pragma endregion
+
+#pragma region has_swap
+template<class Ntk, class = void>
+struct has_swap : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_swap<Ntk, std::void_t<decltype( std::declval<Ntk>().swap( std::declval<node<Ntk>>(), std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_swap_v = has_swap<Ntk>::value;
+#pragma endregion
+
+#pragma region has_sort_rank
+template<class Ntk, class = void>
+struct has_sort_rank : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_sort_rank<Ntk, std::void_t<decltype( std::declval<Ntk>().sort_rank( std::declval<uint32_t>(), std::declval<void( node<Ntk>, node<Ntk> )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_sort_rank_v = has_sort_rank<Ntk>::value;
+#pragma endregion
+
+#pragma region has_foreach_node_in_rank
+template<class Ntk, class = void>
+struct has_foreach_node_in_rank : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_foreach_node_in_rank<Ntk, std::void_t<decltype( std::declval<Ntk>().foreach_node_in_rank( std::declval<uint32_t>(), std::declval<void( node<Ntk>, uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_foreach_node_in_rank_v = has_foreach_node_in_rank<Ntk>::value;
+#pragma endregion
+
+#pragma region has_foreach_gate_in_rank
+template<class Ntk, class = void>
+struct has_foreach_gate_in_rank : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_foreach_gate_in_rank<Ntk, std::void_t<decltype( std::declval<Ntk>().foreach_gate_in_rank( std::declval<uint32_t>(), std::declval<void( node<Ntk>, uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_foreach_gate_in_rank_v = has_foreach_gate_in_rank<Ntk>::value;
+#pragma endregion
+
+#pragma region has_update_mffcs
+template<class Ntk, class = void>
+struct has_update_mffcs : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_update_mffcs<Ntk, std::void_t<decltype( std::declval<Ntk>().update_mffcs() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_update_mffcs_v = has_update_mffcs<Ntk>::value;
+#pragma endregion
+
+#pragma region has_update_topo
+template<class Ntk, class = void>
+struct has_update_topo : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_update_topo<Ntk, std::void_t<decltype( std::declval<Ntk>().update_topo() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_update_topo_v = has_update_topo<Ntk>::value;
+#pragma endregion
+
+#pragma region has_update_fanout
+template<class Ntk, class = void>
+struct has_update_fanout : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_update_fanout<Ntk, std::void_t<decltype( std::declval<Ntk>().update_fanout() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_update_fanout_v = has_update_fanout<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_on_critical_path
+template<class Ntk, class = void>
+struct has_is_on_critical_path : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_on_critical_path<Ntk, std::void_t<decltype( std::declval<Ntk>().is_on_critical_path( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_on_critical_path_v = has_is_on_critical_path<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_buf
+template<class Ntk, class = void>
+struct has_is_buf : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_buf<Ntk, std::void_t<decltype( std::declval<Ntk>().is_buf( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_buf_v = has_is_buf<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_not
+template<class Ntk, class = void>
+struct has_is_not : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_not<Ntk, std::void_t<decltype( std::declval<Ntk>().is_not( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_not_v = has_is_not<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_crossing
+template<class Ntk, class = void>
+struct has_is_crossing : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_crossing<Ntk, std::void_t<decltype( std::declval<Ntk>().is_crossing( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_crossing_v = has_is_crossing<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_and
+template<class Ntk, class = void>
+struct has_is_and : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_and<Ntk, std::void_t<decltype( std::declval<Ntk>().is_and( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_and_v = has_is_and<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_or
+template<class Ntk, class = void>
+struct has_is_or : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_or<Ntk, std::void_t<decltype( std::declval<Ntk>().is_or( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_or_v = has_is_or<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_xor
+template<class Ntk, class = void>
+struct has_is_xor : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_xor<Ntk, std::void_t<decltype( std::declval<Ntk>().is_xor( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_xor_v = has_is_xor<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_maj
+template<class Ntk, class = void>
+struct has_is_maj : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_maj<Ntk, std::void_t<decltype( std::declval<Ntk>().is_maj( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_maj_v = has_is_maj<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_ite
+template<class Ntk, class = void>
+struct has_is_ite : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_ite<Ntk, std::void_t<decltype( std::declval<Ntk>().is_ite( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_ite_v = has_is_ite<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_xor3
+template<class Ntk, class = void>
+struct has_is_xor3 : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_xor3<Ntk, std::void_t<decltype( std::declval<Ntk>().is_xor3( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_xor3_v = has_is_xor3<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_nary_and
+template<class Ntk, class = void>
+struct has_is_nary_and : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_nary_and<Ntk, std::void_t<decltype( std::declval<Ntk>().is_nary_and( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_nary_and_v = has_is_nary_and<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_nary_or
+template<class Ntk, class = void>
+struct has_is_nary_or : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_nary_or<Ntk, std::void_t<decltype( std::declval<Ntk>().is_nary_or( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_nary_or_v = has_is_nary_or<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_nary_xor
+template<class Ntk, class = void>
+struct has_is_nary_xor : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_nary_xor<Ntk, std::void_t<decltype( std::declval<Ntk>().is_nary_xor( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_nary_xor_v = has_is_nary_xor<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_function
+template<class Ntk, class = void>
+struct has_is_function : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_function<Ntk, std::void_t<decltype( std::declval<Ntk>().is_function( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_function_v = has_is_function<Ntk>::value;
+#pragma endregion
+
+#pragma region has_node_function
+template<class Ntk, class = void>
+struct has_node_function : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_node_function<Ntk, std::void_t<decltype( std::declval<Ntk>().node_function( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_node_function_v = has_node_function<Ntk>::value;
+#pragma endregion
+
+#pragma region has_node_function_pin
+template<class Ntk, class = void>
+struct has_node_function_pin : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_node_function_pin<Ntk, std::void_t<decltype( std::declval<Ntk>().node_function_pin( std::declval<node<Ntk>>(), uint32_t() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_node_function_pin_v = has_node_function_pin<Ntk>::value;
+#pragma endregion
+
+#pragma region has_get_node
+template<class Ntk, class = void>
+struct has_get_node : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_get_node<Ntk, std::void_t<decltype( std::declval<Ntk>().get_node( std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_get_node_v = has_get_node<Ntk>::value;
+#pragma endregion
+
+#pragma region has_make_signal
+template<class Ntk, class = void>
+struct has_make_signal : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_make_signal<Ntk, std::void_t<decltype( std::declval<Ntk>().make_signal( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_make_signal_v = has_make_signal<Ntk>::value;
+#pragma endregion
+
+#pragma region has_get_output_pin
+template<class Ntk, class = void>
+struct has_get_output_pin : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_get_output_pin<Ntk, std::void_t<decltype( std::declval<Ntk>().get_output_pin( std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_get_output_pin_v = has_get_output_pin<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_complemented
+template<class Ntk, class = void>
+struct has_is_complemented : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_complemented<Ntk, std::void_t<decltype( std::declval<Ntk>().is_complemented( std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_complemented_v = has_is_complemented<Ntk>::value;
+#pragma endregion
+
+#pragma region has_node_to_index
+template<class Ntk, class = void>
+struct has_node_to_index : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_node_to_index<Ntk, std::void_t<decltype( std::declval<Ntk>().node_to_index( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_node_to_index_v = has_node_to_index<Ntk>::value;
+#pragma endregion
+
+#pragma region has_index_to_node
+template<class Ntk, class = void>
+struct has_index_to_node : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_index_to_node<Ntk, std::void_t<decltype( std::declval<Ntk>().index_to_node( uint32_t() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_index_to_node_v = has_index_to_node<Ntk>::value;
+#pragma endregion
+
+#pragma region has_ci_at
+template<class Ntk, class = void>
+struct has_ci_at : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_ci_at<Ntk, std::void_t<decltype( std::declval<Ntk>().ci_at( uint32_t() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_ci_at_v = has_ci_at<Ntk>::value;
+#pragma endregion
+
+#pragma region has_co_at
+template<class Ntk, class = void>
+struct has_co_at : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_co_at<Ntk, std::void_t<decltype( std::declval<Ntk>().co_at( uint32_t() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_co_at_v = has_co_at<Ntk>::value;
+#pragma endregion
+
+#pragma region has_pi_at
+template<class Ntk, class = void>
+struct has_pi_at : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_pi_at<Ntk, std::void_t<decltype( std::declval<Ntk>().pi_at( uint32_t() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_pi_at_v = has_pi_at<Ntk>::value;
+#pragma endregion
+
+#pragma region has_po_at
+template<class Ntk, class = void>
+struct has_po_at : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_po_at<Ntk, std::void_t<decltype( std::declval<Ntk>().po_at( uint32_t() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_po_at_v = has_po_at<Ntk>::value;
+#pragma endregion
+
+#pragma region has_ro_at
+template<class Ntk, class = void>
+struct has_ro_at : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_ro_at<Ntk, std::void_t<decltype( std::declval<Ntk>().ro_at( uint32_t() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_ro_at_v = has_ro_at<Ntk>::value;
+#pragma endregion
+
+#pragma region has_ri_at
+template<class Ntk, class = void>
+struct has_ri_at : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_ri_at<Ntk, std::void_t<decltype( std::declval<Ntk>().ri_at( uint32_t() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_ri_at_v = has_ri_at<Ntk>::value;
+#pragma endregion
+
+#pragma region ci_index
+template<class Ntk, class = void>
+struct ci_index : std::false_type
+{
+};
+
+template<class Ntk>
+struct ci_index<Ntk, std::void_t<decltype( std::declval<Ntk>().index_to_node( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool ci_index_v = ci_index<Ntk>::value;
+#pragma endregion
+
+#pragma region co_index
+template<class Ntk, class = void>
+struct co_index : std::false_type
+{
+};
+
+template<class Ntk>
+struct co_index<Ntk, std::void_t<decltype( std::declval<Ntk>().index_to_node( std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool co_index_v = co_index<Ntk>::value;
+#pragma endregion
+
+#pragma region pi_index
+template<class Ntk, class = void>
+struct pi_index : std::false_type
+{
+};
+
+template<class Ntk>
+struct pi_index<Ntk, std::void_t<decltype( std::declval<Ntk>().index_to_node( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool pi_index_v = pi_index<Ntk>::value;
+#pragma endregion
+
+#pragma region po_index
+template<class Ntk, class = void>
+struct po_index : std::false_type
+{
+};
+
+template<class Ntk>
+struct po_index<Ntk, std::void_t<decltype( std::declval<Ntk>().index_to_node( std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool po_index_v = po_index<Ntk>::value;
+#pragma endregion
+
+#pragma region ro_index
+template<class Ntk, class = void>
+struct ro_index : std::false_type
+{
+};
+
+template<class Ntk>
+struct ro_index<Ntk, std::void_t<decltype( std::declval<Ntk>().index_to_node( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool ro_index_v = ro_index<Ntk>::value;
+#pragma endregion
+
+#pragma region ri_index
+template<class Ntk, class = void>
+struct ri_index : std::false_type
+{
+};
+
+template<class Ntk>
+struct ri_index<Ntk, std::void_t<decltype( std::declval<Ntk>().index_to_node( std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool ri_index_v = ri_index<Ntk>::value;
+#pragma endregion
+
+#pragma region has_ro_to_ri
+template<class Ntk, class = void>
+struct has_ro_to_ri : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_ro_to_ri<Ntk, std::void_t<decltype( std::declval<Ntk>().ro_to_ri( std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_ro_to_ri_v = has_ro_to_ri<Ntk>::value;
+#pragma endregion
+
+#pragma region has_ri_to_ro
+template<class Ntk, class = void>
+struct has_ri_to_ro : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_ri_to_ro<Ntk, std::void_t<decltype( std::declval<Ntk>().ri_to_ro( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_ri_to_ro_v = has_ri_to_ro<Ntk>::value;
+#pragma endregion
+
+#pragma region has_foreach_node
+template<class Ntk, class = void>
+struct has_foreach_node : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_foreach_node<Ntk, std::void_t<decltype( std::declval<Ntk>().foreach_node( std::declval<void( node<Ntk>, uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_foreach_node_v = has_foreach_node<Ntk>::value;
+#pragma endregion
+
+#pragma region has_foreach_ci
+template<class Ntk, class = void>
+struct has_foreach_ci : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_foreach_ci<Ntk, std::void_t<decltype( std::declval<Ntk>().foreach_ci( std::declval<void( node<Ntk>, uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_foreach_ci_v = has_foreach_ci<Ntk>::value;
+#pragma endregion
+
+#pragma region has_foreach_co
+template<class Ntk, class = void>
+struct has_foreach_co : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_foreach_co<Ntk, std::void_t<decltype( std::declval<Ntk>().foreach_co( std::declval<void( signal<Ntk>, uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_foreach_co_v = has_foreach_co<Ntk>::value;
+#pragma endregion
+
+#pragma region has_foreach_pi
+template<class Ntk, class = void>
+struct has_foreach_pi : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_foreach_pi<Ntk, std::void_t<decltype( std::declval<Ntk>().foreach_pi( std::declval<void( node<Ntk>, uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_foreach_pi_v = has_foreach_pi<Ntk>::value;
+#pragma endregion
+
+#pragma region has_foreach_po
+template<class Ntk, class = void>
+struct has_foreach_po : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_foreach_po<Ntk, std::void_t<decltype( std::declval<Ntk>().foreach_po( std::declval<void( signal<Ntk>, uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_foreach_po_v = has_foreach_po<Ntk>::value;
+#pragma endregion
+
+#pragma region has_foreach_ro
+template<class Ntk, class = void>
+struct has_foreach_ro : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_foreach_ro<Ntk, std::void_t<decltype( std::declval<Ntk>().foreach_ro( std::declval<void( node<Ntk>, uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_foreach_ro_v = has_foreach_ro<Ntk>::value;
+#pragma endregion
+
+#pragma region has_foreach_ri
+template<class Ntk, class = void>
+struct has_foreach_ri : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_foreach_ri<Ntk, std::void_t<decltype( std::declval<Ntk>().foreach_ri( std::declval<void( signal<Ntk>, uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_foreach_ri_v = has_foreach_ri<Ntk>::value;
+#pragma endregion
+
+#pragma region has_foreach_gate
+template<class Ntk, class = void>
+struct has_foreach_gate : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_foreach_gate<Ntk, std::void_t<decltype( std::declval<Ntk>().foreach_gate( std::declval<void( node<Ntk>, uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_foreach_gate_v = has_foreach_gate<Ntk>::value;
+#pragma endregion
+
+#pragma region has_foreach_register
+template<class Ntk, class = void>
+struct has_foreach_register : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_foreach_register<Ntk, std::void_t<decltype( std::declval<Ntk>().foreach_register( std::declval<void( std::pair<node<Ntk>, signal<Ntk>>, uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_foreach_register_v = has_foreach_register<Ntk>::value;
+#pragma endregion
+
+#pragma region has_foreach_fanin
+template<class Ntk, class = void>
+struct has_foreach_fanin : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_foreach_fanin<Ntk, std::void_t<decltype( std::declval<Ntk>().foreach_fanin( std::declval<node<Ntk>>(), std::declval<void( signal<Ntk>, uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_foreach_fanin_v = has_foreach_fanin<Ntk>::value;
+#pragma endregion
+
+#pragma region has_foreach_fanout
+template<class Ntk, class = void>
+struct has_foreach_fanout : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_foreach_fanout<Ntk, std::void_t<decltype( std::declval<Ntk>().foreach_fanout( std::declval<node<Ntk>>(), std::declval<void( node<Ntk>, uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_foreach_fanout_v = has_foreach_fanout<Ntk>::value;
+#pragma endregion
+
+#pragma region has_foreach_choice
+template<class Ntk, class = void>
+struct has_foreach_choice : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_foreach_choice<Ntk, std::void_t<decltype( std::declval<Ntk>().foreach_choice( std::declval<node<Ntk>>(), std::declval<void( node<Ntk>, uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_foreach_choice_v = has_foreach_choice<Ntk>::value;
+#pragma endregion
+
+#pragma region has_compute
+template<class Ntk, typename T, class = void>
+struct has_compute : std::false_type
+{
+};
+
+template<class Ntk, typename T>
+struct has_compute<Ntk, T, std::void_t<decltype( std::declval<Ntk>().compute( std::declval<node<Ntk>>(), std::begin( std::vector<T>() ), std::end( std::vector<T>() ) ) )>> : std::true_type
+{
+};
+
+template<class Ntk, typename T>
+inline constexpr bool has_compute_v = has_compute<Ntk, T>::value;
+#pragma endregion
+
+#pragma region has_compute_inplace
+template<class Ntk, typename T, class = void>
+struct has_compute_inplace : std::false_type
+{
+};
+
+template<class Ntk, typename T>
+struct has_compute_inplace<Ntk, T, std::void_t<decltype( std::declval<Ntk>().compute( std::declval<node<Ntk>>(), std::declval<T&>(), std::begin( std::vector<T>() ), std::end( std::vector<T>() ) ) )>> : std::true_type
+{
+};
+
+template<class Ntk, typename T>
+inline constexpr bool has_compute_inplace_v = has_compute_inplace<Ntk, T>::value;
+#pragma endregion
+
+#pragma region has_has_mapping
+template<class Ntk, class = void>
+struct has_has_mapping : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_has_mapping<Ntk, std::void_t<decltype( std::declval<Ntk>().has_mapping() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_has_mapping_v = has_has_mapping<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_cell_root
+template<class Ntk, class = void>
+struct has_is_cell_root : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_cell_root<Ntk, std::void_t<decltype( std::declval<Ntk>().is_cell_root( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_cell_root_v = has_is_cell_root<Ntk>::value;
+#pragma endregion
+
+#pragma region has_clear_mapping
+template<class Ntk, class = void>
+struct has_clear_mapping : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_clear_mapping<Ntk, std::void_t<decltype( std::declval<Ntk>().clear_mapping() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_clear_mapping_v = has_clear_mapping<Ntk>::value;
+#pragma endregion
+
+#pragma region has_num_cells
+template<class Ntk, class = void>
+struct has_num_cells : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_num_cells<Ntk, std::void_t<decltype( std::declval<Ntk>().num_cells() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_num_cells_v = has_num_cells<Ntk>::value;
+#pragma endregion
+
+#pragma region has_add_to_mapping
+template<class Ntk, class = void>
+struct has_add_to_mapping : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_add_to_mapping<Ntk, std::void_t<decltype( std::declval<Ntk>().add_to_mapping( std::declval<node<Ntk>>(), std::begin( std::vector<node<Ntk>>() ), std::end( std::vector<node<Ntk>>() ) ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_add_to_mapping_v = has_add_to_mapping<Ntk>::value;
+#pragma endregion
+
+#pragma region has_remove_from_mapping
+template<class Ntk, class = void>
+struct has_remove_from_mapping : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_remove_from_mapping<Ntk, std::void_t<decltype( std::declval<Ntk>().remove_from_mapping( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_remove_from_mapping_v = has_remove_from_mapping<Ntk>::value;
+#pragma endregion
+
+#pragma region has_cell_function
+template<class Ntk, class = void>
+struct has_cell_function : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_cell_function<Ntk, std::void_t<decltype( std::declval<Ntk>().cell_function( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_cell_function_v = has_cell_function<Ntk>::value;
+#pragma endregion
+
+#pragma region has_set_cell_function
+template<class Ntk, class = void>
+struct has_set_cell_function : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_set_cell_function<Ntk, std::void_t<decltype( std::declval<Ntk>().set_cell_function( std::declval<node<Ntk>>(), std::declval<kitty::dynamic_truth_table>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_set_cell_function_v = has_set_cell_function<Ntk>::value;
+#pragma endregion
+
+#pragma region has_foreach_cell_fanin
+template<class Ntk, class = void>
+struct has_foreach_cell_fanin : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_foreach_cell_fanin<Ntk, std::void_t<decltype( std::declval<Ntk>().foreach_cell_fanin( std::declval<node<Ntk>>(), std::declval<void( node<Ntk>, uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_foreach_cell_fanin_v = has_foreach_cell_fanin<Ntk>::value;
+#pragma endregion
+
+#pragma region has_has_binding
+template<class Ntk, class = void>
+struct has_has_binding : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_has_binding<Ntk, std::void_t<decltype( std::declval<Ntk>().has_binding( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_has_binding_v = has_has_binding<Ntk>::value;
+#pragma endregion
+
+#pragma region has_has_cell
+template<class Ntk, class = void>
+struct has_has_cell : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_has_cell<Ntk, std::void_t<decltype( std::declval<Ntk>().has_cell( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_has_cell_v = has_has_cell<Ntk>::value;
+#pragma endregion
+
+#pragma region has_get_binding_index
+template<class Ntk, class = void>
+struct has_get_binding_index : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_get_binding_index<Ntk, std::void_t<decltype( std::declval<Ntk>().get_binding_index( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_get_binding_index_v = has_get_binding_index<Ntk>::value;
+#pragma endregion
+
+#pragma region has_get_cell_index
+template<class Ntk, class = void>
+struct has_get_cell_index : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_get_cell_index<Ntk, std::void_t<decltype( std::declval<Ntk>().get_cell_index( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_get_cell_index_v = has_get_cell_index<Ntk>::value;
+#pragma endregion
+
+#pragma region has_add_binding
+template<class Ntk, class = void>
+struct has_add_binding : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_add_binding<Ntk, std::void_t<decltype( std::declval<Ntk>().add_binding( std::declval<node<Ntk>>(), uint32_t() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_add_binding_v = has_add_binding<Ntk>::value;
+#pragma endregion
+
+#pragma region has_select_dont_touch
+template<class Ntk, class = void>
+struct has_select_dont_touch : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_select_dont_touch<Ntk, std::void_t<decltype( std::declval<Ntk>().select_dont_touch( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_select_dont_touch_v = has_select_dont_touch<Ntk>::value;
+#pragma endregion
+
+#pragma region has_is_dont_touch
+template<class Ntk, class = void>
+struct has_is_dont_touch : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_is_dont_touch<Ntk, std::void_t<decltype( std::declval<Ntk>().is_dont_touch( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_is_dont_touch_v = has_is_dont_touch<Ntk>::value;
+#pragma endregion
+
+#pragma region has_clear_values
+template<class Ntk, class = void>
+struct has_clear_values : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_clear_values<Ntk, std::void_t<decltype( std::declval<Ntk>().clear_values() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_clear_values_v = has_clear_values<Ntk>::value;
+#pragma endregion
+
+#pragma region has_value
+template<class Ntk, class = void>
+struct has_value : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_value<Ntk, std::void_t<decltype( std::declval<Ntk>().value( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_value_v = has_value<Ntk>::value;
+#pragma endregion
+
+#pragma region set_value
+template<class Ntk, class = void>
+struct has_set_value : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_set_value<Ntk, std::void_t<decltype( std::declval<Ntk>().set_value( std::declval<node<Ntk>>(), uint32_t() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_set_value_v = has_set_value<Ntk>::value;
+#pragma endregion
+
+#pragma region incr_value
+template<class Ntk, class = void>
+struct has_incr_value : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_incr_value<Ntk, std::void_t<decltype( std::declval<Ntk>().incr_value( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_incr_value_v = has_incr_value<Ntk>::value;
+#pragma endregion
+
+#pragma region decr_value
+template<class Ntk, class = void>
+struct has_decr_value : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_decr_value<Ntk, std::void_t<decltype( std::declval<Ntk>().decr_value( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_decr_value_v = has_decr_value<Ntk>::value;
+#pragma endregion
+
+#pragma region has_get_fanin0
+template<class Ntk, class = void>
+struct has_get_fanin0 : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_get_fanin0<Ntk, std::void_t<decltype( std::declval<Ntk>().get_fanin0( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_get_fanin0_v = has_get_fanin0<Ntk>::value;
+#pragma endregion
+
+#pragma region has_clear_visited
+template<class Ntk, class = void>
+struct has_clear_visited : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_clear_visited<Ntk, std::void_t<decltype( std::declval<Ntk>().clear_visited() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_clear_visited_v = has_clear_visited<Ntk>::value;
+#pragma endregion
+
+#pragma region has_visited
+template<class Ntk, class = void>
+struct has_visited : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_visited<Ntk, std::void_t<decltype( std::declval<Ntk>().visited( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_visited_v = has_visited<Ntk>::value;
+#pragma endregion
+
+#pragma region set_visited
+template<class Ntk, class = void>
+struct has_set_visited : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_set_visited<Ntk, std::void_t<decltype( std::declval<Ntk>().set_visited( std::declval<node<Ntk>>(), uint32_t() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_set_visited_v = has_set_visited<Ntk>::value;
+#pragma endregion
+
+#pragma region trav_id
+template<class Ntk, class = void>
+struct has_trav_id : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_trav_id<Ntk, std::void_t<decltype( std::declval<Ntk>().trav_id() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_trav_id_v = has_trav_id<Ntk>::value;
+#pragma endregion
+
+#pragma region incr_trav_id
+template<class Ntk, class = void>
+struct has_incr_trav_id : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_incr_trav_id<Ntk, std::void_t<decltype( std::declval<Ntk>().incr_trav_id() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_incr_trav_id_v = has_incr_trav_id<Ntk>::value;
+#pragma endregion
+
+#pragma region has_get_network_name
+template<class Ntk, class = void>
+struct has_get_network_name : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_get_network_name<Ntk, std::void_t<decltype( std::declval<Ntk>().get_network_name() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_get_network_name_v = has_get_network_name<Ntk>::value;
+#pragma endregion
+
+#pragma region has_set_network_name
+template<class Ntk, class = void>
+struct has_set_network_name : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_set_network_name<Ntk, std::void_t<decltype( std::declval<Ntk>().set_network_name( std::string() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_set_network_name_v = has_set_network_name<Ntk>::value;
+#pragma endregion
+
+#pragma region has_get_name
+template<class Ntk, class = void>
+struct has_get_name : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_get_name<Ntk, std::void_t<decltype( std::declval<Ntk>().get_name( std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_get_name_v = has_get_name<Ntk>::value;
+#pragma endregion
+
+#pragma region has_set_name
+template<class Ntk, class = void>
+struct has_set_name : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_set_name<Ntk, std::void_t<decltype( std::declval<Ntk>().set_name( std::declval<signal<Ntk>>(), std::string() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_set_name_v = has_set_name<Ntk>::value;
+#pragma endregion
+
+#pragma region has_has_name
+template<class Ntk, class = void>
+struct has_has_name : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_has_name<Ntk, std::void_t<decltype( std::declval<Ntk>().has_name( std::declval<signal<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_has_name_v = has_has_name<Ntk>::value;
+#pragma endregion
+
+#pragma region has_get_output_name
+template<class Ntk, class = void>
+struct has_get_output_name : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_get_output_name<Ntk, std::void_t<decltype( std::declval<Ntk>().get_output_name( uint32_t() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_get_output_name_v = has_get_output_name<Ntk>::value;
+#pragma endregion
+
+#pragma region has_set_output_name
+template<class Ntk, class = void>
+struct has_set_output_name : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_set_output_name<Ntk, std::void_t<decltype( std::declval<Ntk>().set_output_name( uint32_t(), std::string() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_set_output_name_v = has_set_output_name<Ntk>::value;
+#pragma endregion
+
+#pragma region has_has_output_name
+template<class Ntk, class = void>
+struct has_has_output_name : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_has_output_name<Ntk, std::void_t<decltype( std::declval<Ntk>().has_output_name( uint32_t() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_has_output_name_v = has_has_output_name<Ntk>::value;
+#pragma endregion
+
+#pragma region has_new_color
+template<class Ntk, class = void>
+struct has_new_color : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_new_color<Ntk, std::void_t<decltype( std::declval<Ntk>().new_color() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_new_color_v = has_new_color<Ntk>::value;
+#pragma endregion
+
+#pragma region has_current_color
+template<class Ntk, class = void>
+struct has_current_color : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_current_color<Ntk, std::void_t<decltype( std::declval<Ntk>().current_color() )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_current_color_v = has_current_color<Ntk>::value;
+#pragma endregion
+
+#pragma region has_clear_colors
+template<class Ntk, class = void>
+struct has_clear_colors : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_clear_colors<Ntk, std::void_t<decltype( std::declval<Ntk>().clear_colors( uint32_t() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_clear_colors_v = has_clear_colors<Ntk>::value;
+#pragma endregion
+
+#pragma region has_color
+template<class Ntk, class = void>
+struct has_color : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_color<Ntk, std::void_t<decltype( std::declval<Ntk>().color( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_color_v = has_color<Ntk>::value;
+#pragma endregion
+
+#pragma region has_paint
+template<class Ntk, class = void>
+struct has_paint : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_paint<Ntk, std::void_t<decltype( std::declval<Ntk>().paint( std::declval<node<Ntk>>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_paint_v = has_paint<Ntk>::value;
+#pragma endregion
+
+#pragma region has_eval_color
+template<class Ntk, class = void>
+struct has_eval_color : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_eval_color<Ntk, std::void_t<decltype( std::declval<Ntk>().eval_color( std::declval<node<Ntk>>(), std::declval<void( uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_eval_color_v = has_eval_color<Ntk>::value;
+#pragma endregion
+
+#pragma region has_eval_fanins_color
+template<class Ntk, class = void>
+struct has_eval_fanins_color : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_eval_fanins_color<Ntk, std::void_t<decltype( std::declval<Ntk>().eval_fanins_color( std::declval<node<Ntk>>(), std::declval<void( uint32_t )>() ) )>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_eval_fanins_color_v = has_eval_fanins_color<Ntk>::value;
+#pragma endregion
+
+#pragma region has_EXCDC_interface
+template<class Ntk, class = void>
+struct has_EXCDC_interface : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_EXCDC_interface<Ntk, std::enable_if_t<Ntk::has_EXCDC_interface, std::void_t<decltype( Ntk::has_EXCDC_interface )>>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_EXCDC_interface_v = has_EXCDC_interface<Ntk>::value;
+#pragma endregion
+
+#pragma region has_EXODC_interface
+template<class Ntk, class = void>
+struct has_EXODC_interface : std::false_type
+{
+};
+
+template<class Ntk>
+struct has_EXODC_interface<Ntk, std::enable_if_t<Ntk::has_EXODC_interface, std::void_t<decltype( Ntk::has_EXODC_interface )>>> : std::true_type
+{
+};
+
+template<class Ntk>
+inline constexpr bool has_EXODC_interface_v = has_EXODC_interface<Ntk>::value;
+#pragma endregion
+
+/*! \brief SFINAE based on iterator type (for compute functions).
+ */
+template<typename Iterator, typename T>
+using iterates_over_t = std::enable_if_t<std::is_same_v<typename std::iterator_traits<Iterator>::value_type, T>, T>;
+
+/*! \brief SFINAE based on iterator type for truth tables (for compute functions).
+ */
+template<typename Iterator>
+using iterates_over_truth_table_t = std::enable_if_t<kitty::is_truth_table<typename std::iterator_traits<Iterator>::value_type>::value, typename std::iterator_traits<Iterator>::value_type>;
+
+template<class Iterator, typename T>
+inline constexpr bool iterates_over_v = std::is_same_v<typename Iterator::value_type, T>;
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/utils/abc.hpp b/include/mockturtle/utils/abc.hpp
new file mode 100644
index 0000000..5988a1e
--- /dev/null
+++ b/include/mockturtle/utils/abc.hpp
@@ -0,0 +1,118 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file abc.hpp
+  \brief Utility functions for interfacing with ABC
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+#ifdef ENABLE_ABC
+
+#include "../networks/aig.hpp"
+#include "../networks/gia.hpp"
+
+namespace mockturtle
+{
+
+void aig_to_gia(gia_network &gia, aig_network aig) {
+  using aig_node = aig_network::node;
+  using aig_signal = aig_network::signal;
+
+  std::vector<gia_signal> a_to_g(aig.size());
+
+  /* constant */
+  a_to_g[0] = gia.get_constant(false);
+
+  /* pis */
+  aig.foreach_pi([&](aig_node n) {
+    a_to_g[n] = gia.create_pi();
+  });
+
+  /* ands */
+  aig.foreach_gate([&](aig_node n){
+    std::array<gia_signal, 2u> fis;
+    aig.foreach_fanin(n, [&](aig_signal fi, int index){
+      fis[index] = aig.is_complemented(fi) ? !a_to_g[aig.get_node(fi)] : a_to_g[aig.get_node(fi)];
+    });
+    a_to_g[n] = gia.create_and(fis[0], fis[1]);
+  });
+
+  /* pos */
+  aig.foreach_po([&](aig_signal f){
+    gia.create_po(aig.is_complemented(f) ? !a_to_g[aig.get_node(f)] : a_to_g[aig.get_node(f)]);
+  });
+}
+
+void gia_to_aig(aig_network aig, const gia_network &gia) {
+  using gia_node = gia_network::node;
+  using gia_signal = gia_network::signal;
+
+  std::vector<aig_network::signal> g_to_a(gia.size());
+
+  /* constant */
+  g_to_a[0] = aig.get_constant(false);
+
+  /* pis */
+  gia.foreach_pi([&](gia_network::node n){
+    g_to_a[n] = aig.create_pi();
+  });
+
+  /* ands */
+  gia.foreach_gate([&](gia_network::node n){
+    std::array<aig_network::signal, 2u> fis;
+    gia.foreach_fanin(n, [&](gia_signal fi, int index){
+      fis[index] = gia.is_complemented(fi) ? !g_to_a[gia.get_node(fi)] : g_to_a[gia.get_node(fi)];
+    });
+    
+    g_to_a[n] = aig.create_and(fis[0], fis[1]);
+  });
+
+  /* pos */
+  gia.foreach_po([&](gia_network::signal f){
+    aig.create_po(gia.is_complemented(f) ? !g_to_a[gia.get_node(f)] : g_to_a[gia.get_node(f)]);
+  });
+}
+
+aig_network call_abc_script( aig_network const& aig, std::string const& script )
+{
+  gia_network gia( aig.size() << 1 );
+  aig_to_gia( gia, aig );
+
+  gia.load_rc();
+  gia.run_opt_script( script );
+
+  aig_network new_aig;
+  gia_to_aig( new_aig, gia );
+
+  new_aig = cleanup_dangling( new_aig );
+  return new_aig;
+}
+
+}
+
+#endif
\ No newline at end of file
diff --git a/include/mockturtle/utils/algorithm.hpp b/include/mockturtle/utils/algorithm.hpp
new file mode 100644
index 0000000..6397fff
--- /dev/null
+++ b/include/mockturtle/utils/algorithm.hpp
@@ -0,0 +1,230 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file algorithm.hpp
+  \brief STL-like algorithm extensions
+
+  \author Alessandro Tempia Calvino
+  \author Heinz Riener
+  \author Marcel Walter
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <iterator>
+
+namespace mockturtle
+{
+
+template<class Iterator, class T, class BinaryOperation>
+T tree_reduce( Iterator first, Iterator last, T const& init, BinaryOperation&& op )
+{
+  const auto len = std::distance( first, last );
+
+  switch ( len )
+  {
+  case 0u:
+    return init;
+  case 1u:
+    return *first;
+  case 2u:
+    return op( *first, *( first + 1 ) );
+  default:
+  {
+    const auto m = len / 2;
+    return op( tree_reduce( first, first + m, init, op ), tree_reduce( first + m, last, init, op ) );
+  }
+  break;
+  }
+}
+
+template<class Iterator, class T, class TernaryOperation>
+T ternary_tree_reduce( Iterator first, Iterator last, T const& init, TernaryOperation&& op )
+{
+  const auto len = std::distance( first, last );
+
+  switch ( len )
+  {
+  case 0u:
+    return init;
+  case 1u:
+    return *first;
+  case 2u:
+    return op( init, *first, *( first + 1 ) );
+  case 3u:
+    return op( *first, *( first + 1 ), *( first + 2 ) );
+  default:
+  {
+    const auto m1 = len / 3;
+    const auto m2 = ( len - m1 ) / 2;
+    return op( ternary_tree_reduce( first, first + m1, init, op ),
+               ternary_tree_reduce( first + m1, first + m1 + m2, init, op ),
+               ternary_tree_reduce( first + m1 + m2, last, init, op ) );
+  }
+  break;
+  }
+}
+
+template<class Iterator, class UnaryOperation, class T>
+Iterator max_element_unary( Iterator first, Iterator last, UnaryOperation&& fn, T const& init )
+{
+  auto best = last;
+  auto max = init;
+  for ( ; first != last; ++first )
+  {
+    if ( const auto v = fn( *first ) > max )
+    {
+      max = v;
+      best = first;
+    }
+  }
+  return best;
+}
+
+template<class T, typename = std::enable_if_t<std::is_integral_v<T>>>
+constexpr auto range( T begin, T end )
+{
+  struct iterator
+  {
+    using value_type = T;
+
+    value_type curr_;
+    bool operator!=( iterator const& other ) const { return curr_ != other.curr_; }
+    iterator& operator++()
+    {
+      ++curr_;
+      return *this;
+    }
+    iterator operator++( int )
+    {
+      auto copy = *this;
+      ++( *this );
+      return copy;
+    }
+    value_type operator*() const { return curr_; }
+  };
+  struct iterable_wrapper
+  {
+    T begin_;
+    T end_;
+    auto begin() { return iterator{ begin_ }; }
+    auto end() { return iterator{ end_ }; }
+  };
+  return iterable_wrapper{ begin, end };
+}
+
+template<class T, typename = std::enable_if_t<std::is_integral_v<T>>>
+constexpr auto range( T end )
+{
+  return range<T>( {}, end );
+}
+
+/*! \brief Performs the set union of two sorted sets.
+ *
+ * Compared to std::set_union, limits the copy to `limit`.
+ * Moreover, it returns the number of elements copied if the
+ * union operation is successful. Else, it returns -1.
+ *
+ */
+template<class InputIterator1, class InputIterator2, class OutputIterator>
+int32_t set_union_safe( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, uint32_t limit )
+{
+  /* special case: sets are at the limit */
+  if ( std::distance( first1, last1 ) == limit && std::distance( first2, last2 ) == limit )
+  {
+    while ( first1 != last1 )
+    {
+      if ( *first1 != *first2 )
+        return -1;
+
+      *result = *first1;
+      ++first1;
+      ++first2;
+      ++result;
+    }
+
+    return static_cast<int32_t>( limit );
+  }
+
+  uint32_t size = 0;
+  while ( size < limit )
+  {
+    if ( first1 == last1 )
+    {
+      size += std::distance( first2, last2 );
+      if ( size <= limit )
+      {
+        std::copy( first2, last2, result );
+        return static_cast<int32_t>( size );
+      }
+      else
+      {
+        return -1;
+      }
+    }
+    else if ( first2 == last2 )
+    {
+      size += std::distance( first1, last1 );
+      if ( size <= limit )
+      {
+        std::copy( first1, last1, result );
+        return static_cast<int32_t>( size );
+      }
+      else
+      {
+        return -1;
+      }
+    }
+
+    if ( *first1 < *first2 )
+    {
+      *result = *first1;
+      ++first1;
+    }
+    else if ( *first2 < *first1 )
+    {
+      *result = *first2;
+      ++first2;
+    }
+    else
+    {
+      *result = *first1;
+      ++first1;
+      ++first2;
+    }
+
+    ++result;
+    ++size;
+  }
+
+  if ( std::distance( first1, last1 ) + std::distance( first2, last2 ) > 0 )
+    return -1;
+
+  return static_cast<int32_t>( size );
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/utils/cost_functions.hpp b/include/mockturtle/utils/cost_functions.hpp
new file mode 100644
index 0000000..6b5315b
--- /dev/null
+++ b/include/mockturtle/utils/cost_functions.hpp
@@ -0,0 +1,146 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cost_functions.hpp
+  \brief Various cost functions for (optimization) algorithms
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <cstdint>
+
+#include <kitty/dynamic_truth_table.hpp>
+
+#include "../traits.hpp"
+
+namespace mockturtle
+{
+
+template<class Ntk>
+struct unit_cost
+{
+  uint32_t operator()( Ntk const& ntk, node<Ntk> const& node ) const
+  {
+    (void)ntk;
+    (void)node;
+    return 1u;
+  }
+};
+
+template<class Ntk>
+struct mc_cost
+{
+  uint32_t operator()( Ntk const& ntk, node<Ntk> const& node ) const
+  {
+    if constexpr ( has_is_xor_v<Ntk> )
+    {
+      if ( ntk.is_xor( node ) )
+      {
+        return 0u;
+      }
+    }
+
+    if constexpr ( has_is_xor3_v<Ntk> )
+    {
+      if ( ntk.is_xor3( node ) )
+      {
+        return 0u;
+      }
+    }
+
+    if constexpr ( has_is_nary_and_v<Ntk> )
+    {
+      if ( ntk.is_nary_and( node ) )
+      {
+        if ( ntk.fanin_size( node ) > 1u )
+        {
+          return ntk.fanin_size( node ) - 1u;
+        }
+        return 0u;
+      }
+    }
+
+    if constexpr ( has_is_nary_or_v<Ntk> )
+    {
+      if ( ntk.is_nary_or( node ) )
+      {
+        if ( ntk.fanin_size( node ) > 1u )
+        {
+          return ntk.fanin_size( node ) - 1u;
+        }
+        return 0u;
+      }
+    }
+
+    if constexpr ( has_is_nary_xor_v<Ntk> )
+    {
+      if ( ntk.is_nary_xor( node ) )
+      {
+        return 0u;
+      }
+    }
+
+    // TODO (Does not take into account general node functions)
+    return 1u;
+  }
+};
+
+struct lut_unitary_cost
+{
+  std::pair<uint32_t, uint32_t> operator()( uint32_t num_leaves ) const
+  {
+    if ( num_leaves < 2u )
+      return { 0u, 0u };
+    return { 1u, 1u }; /* area, delay */
+  }
+
+  std::pair<uint32_t, uint32_t> operator()( kitty::dynamic_truth_table const& tt ) const
+  {
+    if ( tt.num_vars() < 2u )
+      return { 0u, 0u };
+    return { 1u, 1u }; /* area, delay */
+  }
+};
+
+template<class Ntk, class NodeCostFn = unit_cost<Ntk>>
+uint32_t costs( Ntk const& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+
+  uint32_t total{ 0u };
+  NodeCostFn cost_fn{};
+  ntk.foreach_gate( [&]( auto const& n ) {
+    total += cost_fn( ntk, n );
+  } );
+  return total;
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/utils/cuts.hpp b/include/mockturtle/utils/cuts.hpp
new file mode 100644
index 0000000..5a9c440
--- /dev/null
+++ b/include/mockturtle/utils/cuts.hpp
@@ -0,0 +1,591 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cuts.hpp
+  \brief Data structure for cuts
+
+  \author Alessandro Tempia Calvino
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <array>
+#include <cassert>
+#include <iostream>
+#include <iterator>
+
+#include <kitty/detail/mscfix.hpp>
+
+#include "algorithm.hpp"
+
+namespace mockturtle
+{
+
+struct empty_cut_data
+{
+};
+
+/*! \brief A data-structure to hold a cut.
+ *
+ * The cut class is specialized via two template arguments, `MaxLeaves` and `T`.
+ * `MaxLeaves` controls the maximum number of leaves a cut can hold.  To
+ * guarantee an efficient implementation, this value should be \f$k \cdot l\f$,
+ * where \f$k\f$ is the maximum cut size and \f$l\f$ is the maximum fanin size
+ * of a gate in the logic network.  The second template argument `T` can be a
+ * type for which a data entry is created in the cut to store additional data,
+ * e.g., to compute the cost of a cut.  It defaults to `empty_cut_data`, which
+ * is an empty struct that does not consume memory.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      std::vector<uint32_t> data{1, 2, 3, 4};
+
+      cut<10> cut1;
+      cut1.set_leaves( data.begin(), data.end() );
+
+      cut<10, uint32_t> cut2;
+      cut2.set_leaves( data.begin(), data.end() );
+      cut2.data() = 42u;
+
+      struct cut_data { uint32_t costs; };
+      cut<20, cut_data> c3;
+      c3.set_leaves( std::vector<uint32_t>{1, 2, 3} );
+      c3->costs = 37u;
+   \endverbatim
+ */
+template<int MaxLeaves, typename T = empty_cut_data>
+class cut
+{
+public:
+  /*! \brief Default constructor.
+   */
+  cut() = default;
+
+  /*! \brief Copy constructor.
+   *
+   * Copies leaves, length, signature, and data.
+   *
+   * \param other Other cut
+   */
+  cut( cut const& other )
+  {
+    _cend = _end = std::copy( other.begin(), other.end(), _leaves.begin() );
+    _length = other._length;
+    _signature = other._signature;
+    _data = other._data;
+  }
+
+  /*! \brief Assignment operator.
+   *
+   * Copies leaves, length, signature, and data.
+   *
+   * \param other Other cut
+   */
+  cut& operator=( cut const& other );
+
+  /*! \brief Sets leaves (using iterators).
+   *
+   * \param begin Begin iterator to leaves
+   * \param end End iterator to leaves (exclusive)
+   */
+  template<typename Iterator>
+  void set_leaves( Iterator begin, Iterator end );
+
+  /*! \brief Sets leaves (using container).
+   *
+   * Convenience function, which extracts the begin and end iterators from the
+   * container.
+   */
+  template<typename Container>
+  void set_leaves( Container const& c );
+
+  /*! \brief Add leaves (using iterators).
+   *
+   * \param begin Begin iterator to leaves
+   * \param end End iterator to leaves (exclusive)
+   */
+  template<typename Iterator>
+  void add_leaves( Iterator begin, Iterator end );
+
+  /*! \brief Signature of the cut. */
+  auto signature() const { return _signature; }
+
+  /*! \brief Returns the size of the cut (number of leaves). */
+  auto size() const { return _length; }
+
+  /*! \brief Begin iterator (constant). */
+  auto begin() const { return _leaves.begin(); }
+
+  /*! \brief End iterator (constant). */
+  auto end() const { return _cend; }
+
+  /*! \brief Begin iterator (mutable). */
+  auto begin() { return _leaves.begin(); }
+
+  /*! \brief End iterator (mutable). */
+  auto end() { return _end; }
+
+  /*! \brief Access to data (mutable). */
+  T* operator->() { return &_data; }
+
+  /*! \brief Access to data (constant). */
+  T const* operator->() const { return &_data; }
+
+  /*! \brief Access to data (mutable). */
+  T& data() { return _data; }
+
+  /*! \brief Access to data (constant). */
+  T const& data() const { return _data; }
+
+  /*! \brief Checks whether the cut is a subset of another cut.
+   *
+   * If \f$L_1\f$ are the leaves of the current cut and \f$L_2\f$ are the leaves
+   * of `that`, then this method returns true if and only if
+   * \f$L_1 \subseteq L_2\f$.
+   *
+   * \param that Other cut
+   */
+  bool dominates( cut const& that ) const;
+
+  /*! \brief Merges two cuts.
+   *
+   * This method merges two cuts and stores the result in `res`.  The merge of
+   * two cuts is the union \f$L_1 \cup L_2\f$ of the two leaf sets \f$L_1\f$ of
+   * the cut and \f$L_2\f$ of `that`.  The merge is only successful if the
+   * union has not more than `cut_size` elements.  In that case, the function
+   * returns `false`, otherwise `true`.
+   *
+   * \param that Other cut
+   * \param res Resulting cut
+   * \param cut_size Maximum cut size
+   * \return True, if resulting cut is small enough
+   */
+  bool merge( cut const& that, cut& res, uint32_t cut_size ) const;
+
+private:
+  std::array<uint32_t, MaxLeaves> _leaves;
+  uint32_t _length;
+  uint64_t _signature;
+  typename std::array<uint32_t, MaxLeaves>::const_iterator _cend;
+  typename std::array<uint32_t, MaxLeaves>::iterator _end;
+
+  T _data;
+};
+
+/*! \brief Compare two cuts.
+ *
+ * Default comparison function for two cuts.  A cut is smaller than another
+ * cut, if it has fewer leaves.
+ *
+ * This function should be specialized for custom cuts, if additional data
+ * changes the cost of a cut.
+ */
+template<int MaxLeaves, typename T>
+bool operator<( cut<MaxLeaves, T> const& c1, cut<MaxLeaves, T> const& c2 )
+{
+  return c1.size() < c2.size();
+}
+
+/*! \brief Prints a cut.
+ */
+template<int MaxLeaves, typename T>
+std::ostream& operator<<( std::ostream& os, cut<MaxLeaves, T> const& c )
+{
+  os << "{ ";
+  std::copy( c.begin(), c.end(), std::ostream_iterator<uint32_t>( os, " " ) );
+  os << "}";
+  return os;
+}
+
+template<int MaxLeaves, typename T>
+cut<MaxLeaves, T>& cut<MaxLeaves, T>::operator=( cut<MaxLeaves, T> const& other )
+{
+  if ( &other != this )
+  {
+    _cend = _end = std::copy( other.begin(), other.end(), _leaves.begin() );
+    _length = other._length;
+    _signature = other._signature;
+    _data = other._data;
+  }
+  return *this;
+}
+
+template<int MaxLeaves, typename T>
+template<typename Iterator>
+void cut<MaxLeaves, T>::set_leaves( Iterator begin, Iterator end )
+{
+  _cend = _end = std::copy( begin, end, _leaves.begin() );
+  _length = static_cast<uint32_t>( std::distance( begin, end ) );
+  _signature = 0;
+
+  while ( begin != end )
+  {
+    _signature |= UINT64_C( 1 ) << ( *begin++ & 0x3f );
+  }
+}
+
+template<int MaxLeaves, typename T>
+template<typename Container>
+void cut<MaxLeaves, T>::set_leaves( Container const& c )
+{
+  set_leaves( std::begin( c ), std::end( c ) );
+}
+
+template<int MaxLeaves, typename T>
+template<typename Iterator>
+void cut<MaxLeaves, T>::add_leaves( Iterator begin, Iterator end )
+{
+  _cend = _end = std::copy( begin, end, _end );
+  _length = static_cast<uint32_t>( std::distance( _leaves.begin(), _end ) );
+
+  while ( begin != end )
+  {
+    _signature |= UINT64_C( 1 ) << ( *begin++ & 0x3f );
+  }
+}
+
+template<int MaxLeaves, typename T>
+bool cut<MaxLeaves, T>::dominates( cut const& that ) const
+{
+  /* quick check for counter example */
+  if ( _length > that._length || ( _signature & that._signature ) != _signature )
+  {
+    return false;
+  }
+
+  if ( _length == that._length )
+  {
+    return std::equal( begin(), end(), that.begin() );
+  }
+
+  if ( _length == 0 )
+  {
+    return true;
+  }
+
+  // this is basically
+  //     return std::includes( that.begin(), that.end(), begin(), end() )
+  // but it turns out that this code is faster compared to the standard
+  // implementation.
+  for ( auto it2 = that.begin(), it1 = begin(); it2 != that.end(); ++it2 )
+  {
+    if ( *it2 > *it1 )
+    {
+      return false;
+    }
+    if ( ( *it2 == *it1 ) && ( ++it1 == end() ) )
+    {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+template<int MaxLeaves, typename T>
+bool cut<MaxLeaves, T>::merge( cut const& that, cut& res, uint32_t cut_size ) const
+{
+  if ( _length + that._length > cut_size )
+  {
+    const auto sign = _signature + that._signature;
+    if ( uint32_t( __builtin_popcount( static_cast<uint32_t>( sign & 0xffffffff ) ) ) + uint32_t( __builtin_popcount( static_cast<uint32_t>( sign >> 32 ) ) ) > cut_size )
+    {
+      return false;
+    }
+  }
+
+  int32_t length = set_union_safe( begin(), end(), that.begin(), that.end(), res.begin(), cut_size );
+  if ( length >= 0 )
+  {
+    res._cend = res._end = res.begin() + length;
+    res._length = static_cast<uint32_t>( length );
+    res._signature = _signature | that._signature;
+    return true;
+  }
+  return false;
+}
+
+/*! \brief A data-structure to hold a set of cuts.
+ *
+ * The aim of a cut set is to contain cuts and maintain two properties.  First,
+ * all cuts are ordered according to the `<` operator, and second, all cuts
+ * are irredundant, i.e., no cut in the set dominates another cut in the set.
+ *
+ * The cut set is defined using the `CutType` of cuts it should hold and a
+ * maximum number of cuts it can hold.  No check is performed whether a cut set
+ * is full, and therefore the caller must not insert cuts into a full set.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      cut_set<cut<10>, 30> cuts;
+
+      cut<10> c1, c2, c3, c4;
+
+      c1.set_leaves( {1, 2, 3} );
+      c2.set_leaves( {4, 5} );
+      c3.set_leaves( {1, 2} );
+      c4.set_leaves( {1, 3, 4} );
+
+      cuts.insert( c1 );
+      cuts.insert( c2 );
+      cuts.insert( c3 );
+      cuts.insert( c4 );
+
+      assert( cuts.size() == 3 );
+
+      std::cout << cuts << std::endl;
+
+      // will print:
+      //   { 4, 5 }
+      //   { 1, 2 }
+      //   { 1, 3, 4 }
+   \endverbatim
+ */
+template<typename CutType, int MaxCuts>
+class cut_set
+{
+public:
+  /*! \brief Standard constructor.
+   */
+  cut_set();
+
+  /*! \brief Clears a cut set.
+   */
+  void clear();
+
+  /*! \brief Adds a cut to the end of the set.
+   *
+   * This function should only be called to create a set of cuts which is known
+   * to be sorted and irredundant (i.e., no cut in the set dominates another
+   * cut).
+   *
+   * \param begin Begin iterator to leaf indexes
+   * \param end End iterator (exclusive) to leaf indexes
+   * \return Reference to the added cut
+   */
+  template<typename Iterator>
+  CutType& add_cut( Iterator begin, Iterator end );
+
+  /*! \brief Checks whether cut is dominates by any cut in the set.
+   *
+   * \param cut Cut outside of the set
+   */
+  bool is_dominated( CutType const& cut ) const;
+
+  /*! \brief Inserts a cut into a set.
+   *
+   * This method will insert a cut into a set and maintain an order.  Before the
+   * cut is inserted into the correct position, it will remove all cuts that are
+   * dominated by `cut`.
+   *
+   * If `cut` is dominated by any of the cuts in the set, it will still be
+   * inserted.  The caller is responsible to check whether `cut` is dominated
+   * before inserting it into the set.
+   *
+   * \param cut Cut to insert.
+   */
+  void insert( CutType const& cut );
+
+  /*! \brief Begin iterator (constant).
+   *
+   * The iterator will point to a cut pointer.
+   */
+  auto begin() const { return _pcuts.begin(); }
+
+  /*! \brief End iterator (constant). */
+  auto end() const { return _pcend; }
+
+  /*! \brief Begin iterator (mutable).
+   *
+   * The iterator will point to a cut pointer.
+   */
+  auto begin() { return _pcuts.begin(); }
+
+  /*! \brief End iterator (mutable). */
+  auto end() { return _pend; }
+
+  /*! \brief Number of cuts in the set. */
+  auto size() const { return _pcend - _pcuts.begin(); }
+
+  /*! \brief Returns reference to cut at index.
+   *
+   * This function does not return the cut pointer but dereferences it and
+   * returns a reference.  The function does not check whether index is in the
+   * valid range.
+   *
+   * \param index Index
+   */
+  auto const& operator[]( uint32_t index ) const { return *_pcuts[index]; }
+
+  /*! \brief Returns the best cut, i.e., the first cut.
+   */
+  auto const& best() const { return *_pcuts[0]; }
+
+  /*! \brief Updates the best cut.
+   *
+   * This method will set the cut at index `index` to be the best cut.  All
+   * cuts before `index` will be moved one position higher.
+   *
+   * \param index Index of new best cut
+   */
+  void update_best( uint32_t index );
+
+  /*! \brief Resize the cut set, if it is too large.
+   *
+   * This method will resize the cut set to `size` only if the cut set has more
+   * than `size` elements.  Otherwise, the size will remain the same.
+   */
+  void limit( uint32_t size );
+
+  /*! \brief Prints a cut set. */
+  friend std::ostream& operator<<( std::ostream& os, cut_set const& set )
+  {
+    for ( auto const& c : set )
+    {
+      os << *c << "\n";
+    }
+    return os;
+  }
+
+private:
+  std::array<CutType, MaxCuts> _cuts;
+  std::array<CutType*, MaxCuts> _pcuts;
+  typename std::array<CutType*, MaxCuts>::const_iterator _pcend{ _pcuts.begin() };
+  typename std::array<CutType*, MaxCuts>::iterator _pend{ _pcuts.begin() };
+};
+
+template<typename CutType, int MaxCuts>
+cut_set<CutType, MaxCuts>::cut_set()
+{
+  clear();
+}
+
+template<typename CutType, int MaxCuts>
+void cut_set<CutType, MaxCuts>::clear()
+{
+  _pcend = _pend = _pcuts.begin();
+  auto pit = _pcuts.begin();
+  for ( auto& c : _cuts )
+  {
+    *pit++ = &c;
+  }
+}
+
+template<typename CutType, int MaxCuts>
+template<typename Iterator>
+CutType& cut_set<CutType, MaxCuts>::add_cut( Iterator begin, Iterator end )
+{
+  assert( _pend != _pcuts.end() );
+
+  auto& cut = **_pend++;
+  cut.set_leaves( begin, end );
+
+  ++_pcend;
+  return cut;
+}
+
+template<typename CutType, int MaxCuts>
+bool cut_set<CutType, MaxCuts>::is_dominated( CutType const& cut ) const
+{
+  return std::find_if( _pcuts.begin(), _pcend, [&cut]( auto const* other ) { return other->dominates( cut ); } ) != _pcend;
+}
+
+template<typename CutType, int MaxCuts>
+void cut_set<CutType, MaxCuts>::insert( CutType const& cut )
+{
+  /* remove elements that are dominated by new cut */
+  _pcend = _pend = std::stable_partition( _pcuts.begin(), _pend, [&cut]( auto const* other ) { return !cut.dominates( *other ); } );
+
+  /* insert cut in a sorted way */
+  auto ipos = std::lower_bound( _pcuts.begin(), _pend, &cut, []( auto a, auto b ) { return *a < *b; } );
+
+  /* too many cuts, we need to remove one */
+  if ( _pend == _pcuts.end() )
+  {
+    /* cut to be inserted is worse than all the others, return */
+    if ( ipos == _pend )
+    {
+      return;
+    }
+    else
+    {
+      /* remove last cut */
+      --_pend;
+      --_pcend;
+    }
+  }
+
+  /* copy cut */
+  auto& icut = *_pend;
+  icut->set_leaves( cut.begin(), cut.end() );
+  icut->data() = cut.data();
+
+  if ( ipos != _pend )
+  {
+    auto it = _pend;
+    while ( it > ipos )
+    {
+      std::swap( *it, *( it - 1 ) );
+      --it;
+    }
+  }
+
+  /* update iterators */
+  _pcend++;
+  _pend++;
+}
+
+template<typename CutType, int MaxCuts>
+void cut_set<CutType, MaxCuts>::update_best( uint32_t index )
+{
+  auto* best = _pcuts[index];
+  for ( auto i = index; i > 0; --i )
+  {
+    _pcuts[i] = _pcuts[i - 1];
+  }
+  _pcuts[0] = best;
+}
+
+template<typename CutType, int MaxCuts>
+void cut_set<CutType, MaxCuts>::limit( uint32_t size )
+{
+  if ( std::distance( _pcuts.begin(), _pend ) > static_cast<long>( size ) )
+  {
+    _pcend = _pend = _pcuts.begin() + size;
+  }
+}
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/utils/debugging_utils.hpp b/include/mockturtle/utils/debugging_utils.hpp
new file mode 100644
index 0000000..0a53b79
--- /dev/null
+++ b/include/mockturtle/utils/debugging_utils.hpp
@@ -0,0 +1,551 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file debugging_utils.hpp
+  \brief Network debugging utilities
+
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../algorithms/simulation.hpp"
+#include "../traits.hpp"
+#include "../views/topo_view.hpp"
+
+#include <kitty/kitty.hpp>
+
+#include <algorithm>
+#include <vector>
+
+namespace mockturtle
+{
+
+/*! \brief Prints information of all nodes in a network
+ *
+ * This utility function prints the following information for all
+ * nodes in the network:
+ * - ID
+ * - Fanin signals, if any
+ * - Level, if `level` is provided for the network type
+ * - Whether the node is dead
+ * - Reference count (fanout size)
+ * - Visited marker
+ * - Custom value data
+ *
+ * It also prints the outputs of the network.
+ */
+template<typename Ntk>
+inline void print( Ntk const& ntk )
+{
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  for ( uint32_t n = 0; n < ntk.size(); ++n )
+  {
+    std::cout << n;
+
+    if ( ntk.is_constant( n ) || ntk.is_pi( n ) )
+    {
+      std::cout << std::endl;
+      continue;
+    }
+
+    std::cout << " = ";
+
+    ntk.foreach_fanin( n, [&]( signal const& fi ) {
+      std::cout << ( ntk.is_complemented( fi ) ? "~" : "" ) << ntk.get_node( fi ) << " ";
+    } );
+    std::cout << " ;";
+    if constexpr ( has_level_v<Ntk> )
+    {
+      std::cout << " [level = " << int32_t( ntk.level( n ) ) << "]";
+    }
+    std::cout << " [dead = " << ntk.is_dead( n ) << "]";
+    std::cout << " [ref = " << ntk.fanout_size( n ) << "]";
+    std::cout << " [visited = " << ntk.visited( n ) << "]";
+    std::cout << " [value = " << ntk.value( n ) << "]";
+    std::cout << std::endl;
+  }
+
+  ntk.foreach_co( [&]( signal const& s ) {
+    std::cout << "o " << ( ntk.is_complemented( s ) ? "~" : "" ) << ntk.get_node( s ) << std::endl;
+  } );
+}
+
+/*! \brief Counts dead nodes in a network
+ *
+ * This utility function counts how many nodes in the network are
+ * said to be dead (i.e., `is_dead` returns true).
+ */
+template<typename Ntk>
+inline uint64_t count_dead_nodes( Ntk const& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_is_dead_v<Ntk>, "Ntk does not implement the is_dead function" );
+
+  uint64_t counter{ 0 };
+  for ( uint64_t n = 0; n < ntk.size(); ++n )
+  {
+    if ( ntk.is_dead( n ) )
+    {
+      ++counter;
+    }
+  }
+  return counter;
+}
+
+/*! \brief Counts dangling roots in a network
+ *
+ * This utility function counts how many nodes in the network have
+ * a fanout size of zero. Note that it does not skip the nodes which
+ * are marked as dead, which are normally skipped when using `foreach`
+ * functions.
+ */
+template<typename Ntk>
+inline uint64_t count_dangling_roots( Ntk const& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size function" );
+
+  uint64_t counter{ 0 };
+  for ( uint64_t n = 0; n < ntk.size(); ++n )
+  {
+    if ( ntk.fanout_size( n ) == 0 )
+    {
+      ++counter;
+    }
+  }
+  return counter;
+}
+
+namespace detail
+{
+
+template<typename Ntk>
+void count_reachable_dead_nodes_recur( Ntk const& ntk, typename Ntk::node const& n, std::vector<typename Ntk::node>& nodes )
+{
+  using signal = typename Ntk::signal;
+
+  if ( ntk.current_color() == ntk.color( n ) )
+  {
+    return;
+  }
+
+  if ( ntk.is_dead( n ) )
+  {
+    if ( std::find( std::begin( nodes ), std::end( nodes ), n ) == std::end( nodes ) )
+    {
+      nodes.push_back( n );
+    }
+  }
+
+  ntk.paint( n );
+  ntk.foreach_fanin( n, [&]( signal const& fi ) {
+    count_reachable_dead_nodes_recur( ntk, ntk.get_node( fi ), nodes );
+  } );
+}
+
+} /* namespace detail */
+
+/*! \brief Counts reachable dead nodes in a network
+ *
+ * This utility function counts how many nodes in the network are
+ * said to be dead (i.e., `is_dead` returns true) and are reachable
+ * from an output.
+ *
+ * This function requires the `paint` by the network (provided by
+ * wrapping with `color_view`).
+ */
+template<typename Ntk>
+inline uint64_t count_reachable_dead_nodes( Ntk const& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_color_v<Ntk>, "Ntk does not implement the color function" );
+  static_assert( has_current_color_v<Ntk>, "Ntk does not implement the current_color function" );
+  static_assert( has_foreach_co_v<Ntk>, "Ntk does not implement the foreach_co function" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin function" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node function" );
+  static_assert( has_is_dead_v<Ntk>, "Ntk does not implement the is_dead function" );
+  static_assert( has_new_color_v<Ntk>, "Ntk does not implement the new_color function" );
+  static_assert( has_paint_v<Ntk>, "Ntk does not implement the paint function" );
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  ntk.new_color();
+
+  std::vector<node> dead_nodes;
+  ntk.foreach_co( [&]( signal const& po ) {
+    detail::count_reachable_dead_nodes_recur( ntk, ntk.get_node( po ), dead_nodes );
+  } );
+
+  return dead_nodes.size();
+}
+
+namespace detail
+{
+
+template<typename Ntk>
+void count_reachable_dead_nodes_from_node_recur( Ntk const& ntk, typename Ntk::node const& n, std::vector<typename Ntk::node>& nodes )
+{
+  using node = typename Ntk::node;
+
+  if ( ntk.current_color() == ntk.color( n ) )
+  {
+    return;
+  }
+
+  if ( ntk.is_dead( n ) )
+  {
+    if ( std::find( std::begin( nodes ), std::end( nodes ), n ) == std::end( nodes ) )
+    {
+      nodes.push_back( n );
+    }
+  }
+
+  ntk.paint( n );
+  ntk.foreach_fanin( n, [&]( auto const& f ) {
+    count_reachable_dead_nodes_from_node_recur( ntk, ntk.get_node( f ), nodes );
+  } );
+}
+
+} /* namespace detail */
+
+/*! \brief Counts dead nodes that are reachable from a given node
+ *
+ * This utility function counts how many nodes in the network are
+ * said to be dead (i.e., `is_dead` returns true) and are reachable
+ * from a given node (i.e., in the transitive fanin cone of this node).
+ *
+ * This function requires `paint` of the network (provided by
+ * wrapping with `color_view`).
+ */
+template<typename Ntk>
+inline uint64_t count_reachable_dead_nodes_from_node( Ntk const& ntk, typename Ntk::node const& n )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_color_v<Ntk>, "Ntk does not implement the color function" );
+  static_assert( has_current_color_v<Ntk>, "Ntk does not implement the current_color function" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin function" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node function" );
+  static_assert( has_is_dead_v<Ntk>, "Ntk does not implement the is_dead function" );
+  static_assert( has_new_color_v<Ntk>, "Ntk does not implement the new_color function" );
+  static_assert( has_paint_v<Ntk>, "Ntk does not implement the paint function" );
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  ntk.new_color();
+
+  std::vector<node> dead_nodes;
+  detail::count_reachable_dead_nodes_from_node_recur( ntk, n, dead_nodes );
+
+  return dead_nodes.size();
+}
+
+/*! \brief Counts nodes with dead fanin(s) in a network
+ *
+ * This utility function counts how many (not-dead) nodes in the
+ * network have at least one fanin being dead.
+ */
+template<typename Ntk>
+uint64_t count_nodes_with_dead_fanins( Ntk const& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin function" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node function" );
+  static_assert( has_is_dead_v<Ntk>, "Ntk does not implement the is_dead function" );
+  static_assert( has_new_color_v<Ntk>, "Ntk does not implement the new_color function" );
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  uint64_t counter{ 0u };
+  ntk.foreach_node( [&]( node const& n ) {
+    ntk.foreach_fanin( n, [&]( signal const& s ) {
+      if ( ntk.is_dead( ntk.get_node( s ) ) )
+      {
+        counter++;
+        return false;
+      }
+      return true;
+    } );
+  } );
+
+  return counter;
+}
+
+namespace detail
+{
+
+template<typename Ntk>
+bool network_is_acyclic_recur( Ntk const& ntk, typename Ntk::node const& n )
+{
+  using signal = typename Ntk::signal;
+
+  if ( ntk.color( n ) == ntk.current_color() )
+  {
+    return true;
+  }
+
+  if ( ntk.color( n ) == ntk.current_color() - 1 )
+  {
+    /* cycle detected at node n */
+    return false;
+  }
+
+  ntk.paint( n, ntk.current_color() - 1 );
+
+  bool result{ true };
+  ntk.foreach_fanin( n, [&]( signal const& fi ) {
+    if ( !network_is_acyclic_recur( ntk, ntk.get_node( fi ) ) )
+    {
+      result = false;
+      return false;
+    }
+    return true;
+  } );
+  ntk.paint( n, ntk.current_color() );
+
+  return result;
+}
+
+} /* namespace detail */
+
+/*! \brief Check if a network is acyclic
+ *
+ * This utility function checks if the network is acyclic, i.e., there
+ * is no path from a node to itself.
+ *
+ * This function requires `paint` of the network (provided by
+ * wrapping with `color_view`).
+ */
+template<typename Ntk>
+bool network_is_acyclic( Ntk const& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_foreach_ci_v<Ntk>, "Ntk does not implement the foreach_ci function" );
+  static_assert( has_foreach_co_v<Ntk>, "Ntk does not implement the foreach_co function" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin function" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant function" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node function" );
+  static_assert( has_color_v<Ntk>, "Ntk does not implement the color function" );
+  static_assert( has_current_color_v<Ntk>, "Ntk does not implement the current_color function" );
+  static_assert( has_paint_v<Ntk>, "Ntk does not implement the paint function" );
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  ntk.new_color();
+  ntk.new_color();
+
+  ntk.paint( ntk.get_node( ntk.get_constant( false ) ) );
+  ntk.foreach_ci( [&]( node const& n ) {
+    ntk.paint( n );
+  } );
+
+  bool result{ true };
+  ntk.foreach_co( [&]( signal const& o ) {
+    if ( !detail::network_is_acyclic_recur( ntk, ntk.get_node( o ) ) )
+    {
+      result = false;
+      return false;
+    }
+    return true;
+  } );
+
+  return result;
+}
+
+/*! \brief Check the level information of a network
+ *
+ * This utility function checks if the levels of each node in the
+ * network and the depth of the network are correct.
+ *
+ * This function requires `level` of the network (provided by
+ * wrapping with `depth_view`).
+ */
+template<typename Ntk>
+bool check_network_levels( Ntk const& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size function" );
+  static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant function" );
+  static_assert( has_is_ci_v<Ntk>, "Ntk does not implement the is_ci function" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node function" );
+  static_assert( has_is_dead_v<Ntk>, "Ntk does not implement the is_dead function" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin function" );
+  static_assert( has_level_v<Ntk>, "Ntk does not implement the level function" );
+  static_assert( has_depth_v<Ntk>, "Ntk does not implement the depth function" );
+
+  using signal = typename Ntk::signal;
+
+  uint32_t max = 0;
+  for ( uint32_t i = 0u; i < ntk.size(); ++i )
+  {
+    if ( ntk.is_constant( i ) || ntk.is_ci( i ) || ntk.is_dead( i ) )
+    {
+      continue;
+    }
+
+    uint32_t max_fanin_level = 0;
+    ntk.foreach_fanin( i, [&]( signal fi ) {
+      if ( ntk.level( ntk.get_node( fi ) ) > max_fanin_level )
+      {
+        max_fanin_level = ntk.level( ntk.get_node( fi ) );
+      }
+    } );
+
+    /* the node's level has not been correctly computed */
+    if ( ntk.level( i ) != max_fanin_level + 1 )
+    {
+      return false;
+    }
+
+    if ( ntk.level( i ) > max )
+    {
+      max = ntk.level( i );
+    }
+  }
+
+  /* the network's depth has not been correctly computed */
+  if ( ntk.depth() != max )
+  {
+    return false;
+  }
+
+  return true;
+}
+
+/*! \brief Check the fanout information of a network
+ *
+ * This utility function checks if the fanouts of each node in the
+ * network are correct.
+ *
+ * This function requires `foreach_fanout` of the network (provided by
+ * wrapping with `fanout_view`).
+ */
+template<typename Ntk>
+bool check_fanouts( Ntk const& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_size_v<Ntk>, "Ntk does not implement the size function" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node function" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin function" );
+  static_assert( has_foreach_fanout_v<Ntk>, "Ntk does not implement the foreach_fanout function" );
+  static_assert( has_foreach_co_v<Ntk>, "Ntk does not implement the foreach_co function" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size function" );
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  for ( auto i = 0u; i < ntk.size(); ++i )
+  {
+    uint32_t fanout_counter{ 0 };
+
+    bool fanout_error = false;
+    ntk.foreach_fanout( i, [&]( node fo ) {
+      ++fanout_counter;
+
+      /* check the fanins of the fanout  */
+      bool found = false;
+      ntk.foreach_fanin( fo, [&]( signal fi ) {
+        if ( ntk.get_node( fi ) == i )
+        {
+          found = true;
+          return false;
+        }
+        return true;
+      } );
+
+      /* if errors have been detected, then terminate */
+      if ( !found )
+      {
+        fanout_error = true;
+        return false;
+      }
+
+      return true;
+    } );
+
+    /* report error */
+    if ( fanout_error )
+    {
+      return false;
+    }
+
+    /* update the fanout counter by considering outputs */
+    ntk.foreach_co( [&]( signal f ) {
+      if ( ntk.get_node( f ) == i )
+      {
+        ++fanout_counter;
+      }
+    } );
+
+    /* report error fanout_size does not match with the counter */
+    if ( fanout_counter != ntk.fanout_size( i ) )
+    {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/*! \brief Check functional equivalence between a window in a network
+ * and a stand-alone window.
+ *
+ * This utility function checks if a window in a network, defined by
+ * a set of inputs, a set of gates (internal nodes), and a set of
+ * outputs, is functionally equivalent to an extracted window represented
+ * as a stand-alone network.
+ *
+ */
+template<typename Ntk, typename NtkWin>
+bool check_window_equivalence( Ntk const& ntk, std::vector<typename Ntk::node> const& inputs, std::vector<typename Ntk::signal> const& outputs, std::vector<typename Ntk::node> const& gates, NtkWin const& win_opt )
+{
+  NtkWin win;
+  clone_subnetwork( ntk, inputs, outputs, gates, win );
+  topo_view topo_win{ win_opt };
+  assert( win.num_pis() == win_opt.num_pis() );
+  assert( win.num_pos() == win_opt.num_pos() );
+
+  default_simulator<kitty::dynamic_truth_table> sim( inputs.size() );
+  auto const tts1 = simulate<kitty::dynamic_truth_table, NtkWin>( win, sim );
+  auto const tts2 = simulate<kitty::dynamic_truth_table, topo_view<NtkWin>>( topo_win, sim );
+  for ( auto i = 0u; i < tts1.size(); ++i )
+  {
+    if ( tts1[i] != tts2[i] )
+    {
+      return false;
+    }
+  }
+  return true;
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/utils/hash_functions.hpp b/include/mockturtle/utils/hash_functions.hpp
new file mode 100644
index 0000000..a4d9b17
--- /dev/null
+++ b/include/mockturtle/utils/hash_functions.hpp
@@ -0,0 +1,156 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file hash_functions.hpp
+  \brief hash specializations for collections.
+
+  \author Dewmini Sudara Marakkalage
+*/
+
+#pragma once
+
+#include <functional>
+#include <map>
+#include <set>
+#include <tuple>
+#include <vector>
+
+namespace mockturtle
+{
+
+template<typename T>
+struct hash
+{
+  std::hash<T> h;
+  size_t operator()( const T& t ) const { return h( t ); }
+};
+
+template<typename A, typename B, typename C>
+struct hash<std::tuple<A, B, C>>;
+
+template<typename A, typename B>
+struct hash<std::tuple<A, B>>;
+
+template<typename A>
+struct hash<std::vector<A>>;
+
+template<typename A>
+struct hash<std::multiset<A>>;
+
+template<typename A, typename B>
+struct hash<std::map<A, B>>;
+
+template<typename A, typename B>
+struct hash<std::tuple<A, B>>
+{
+public:
+  size_t operator()( const std::tuple<const A, const B>& key ) const
+  {
+    size_t seed = ha( std::get<0>( key ) );
+    seed ^= hb( std::get<1>( key ) ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 );
+    return seed;
+  }
+
+private:
+  hash<A> ha;
+  hash<B> hb;
+};
+
+template<typename A, typename B, typename C>
+struct hash<std::tuple<A, B, C>>
+{
+public:
+  size_t operator()( const std::tuple<const A, const B, const C>& key ) const
+  {
+    size_t seed = ha( std::get<0>( key ) );
+    seed ^= hb( std::get<1>( key ) ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 );
+    seed ^= hc( std::get<2>( key ) ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 );
+    return seed;
+  }
+
+private:
+  hash<A> ha;
+  hash<B> hb;
+  hash<C> hc;
+};
+
+template<typename A>
+struct hash<std::vector<A>>
+{
+public:
+  size_t operator()( const std::vector<A>& key ) const
+  {
+    std::size_t seed = key.size();
+    for ( auto& i : key )
+    {
+      seed ^= ha( i ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 );
+    }
+    return seed;
+  }
+
+private:
+  hash<A> ha;
+};
+
+template<typename A>
+struct hash<std::multiset<std::multiset<A>>>
+{
+public:
+  size_t operator()( const std::multiset<std::multiset<A>>& key ) const
+  {
+    size_t seed = key.size();
+    for ( auto& x : key )
+    {
+      seed ^= ha( x ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 );
+    }
+    return seed;
+  }
+
+private:
+  hash<A> ha;
+};
+
+template<typename A, typename B>
+struct hash<std::map<A, B>>
+{
+public:
+  size_t operator()( const std::map<A, B>& key ) const
+  {
+    size_t seed = key.size();
+    for ( auto it = key.begin(); it != key.end(); it++ )
+    {
+      seed ^= ha( it->first ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 );
+      seed ^= hb( it->second ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 );
+    }
+    return seed;
+  }
+
+private:
+  hash<A> ha;
+  hash<B> hb;
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/utils/include/percy.hpp b/include/mockturtle/utils/include/percy.hpp
new file mode 100644
index 0000000..da2576d
--- /dev/null
+++ b/include/mockturtle/utils/include/percy.hpp
@@ -0,0 +1,51 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file percy.hpp
+  \brief Include percy, disable warnings for Windows
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#ifdef _MSC_VER
+#pragma warning( push )
+#pragma warning( disable : 4018 )
+#pragma warning( disable : 4068 )
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4267 )
+#pragma warning( disable : 4334 )
+#pragma warning( disable : 4477 )
+#pragma warning( disable : 4566 )
+#pragma warning( disable : 4805 )
+#pragma warning( disable : 4996 )
+#include <percy/percy.hpp>
+#pragma warning( pop )
+#else
+#include <percy/percy.hpp>
+#endif
\ No newline at end of file
diff --git a/include/mockturtle/utils/include/supergate.hpp b/include/mockturtle/utils/include/supergate.hpp
new file mode 100644
index 0000000..2ff55c0
--- /dev/null
+++ b/include/mockturtle/utils/include/supergate.hpp
@@ -0,0 +1,92 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file supergate.hpp
+  \brief Defines the composed gate and supergate data structure.
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <array>
+#include <vector>
+
+#include "../../io/genlib_reader.hpp"
+
+#include <kitty/dynamic_truth_table.hpp>
+
+namespace mockturtle
+{
+
+template<unsigned NInputs>
+struct composed_gate
+{
+  /* unique ID */
+  uint32_t id;
+
+  /* gate is a supergate */
+  bool is_super{ false };
+
+  /* pointer to the root library gate */
+  gate const* root{ nullptr };
+
+  /* support of the composed gate */
+  uint32_t num_vars{ 0 };
+
+  /* function */
+  kitty::dynamic_truth_table function;
+
+  /* area */
+  double area{ 0.0 };
+
+  /* pin-to-pin delays */
+  std::array<float, NInputs> tdelay{};
+
+  /* fanin gates */
+  std::vector<composed_gate<NInputs>*> fanin{};
+};
+
+template<unsigned NInputs>
+struct supergate
+{
+  /* pointer to the root gate */
+  composed_gate<NInputs> const* root{};
+
+  /* area */
+  double area{ 0.0 };
+
+  /* pin-to-pin delay */
+  std::array<float, NInputs> tdelay{};
+
+  /* np permutation vector */
+  std::vector<uint8_t> permutation{};
+
+  /* pin negations */
+  uint16_t polarity{ 0 };
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/utils/index_list.hpp b/include/mockturtle/utils/index_list.hpp
new file mode 100644
index 0000000..aa38400
--- /dev/null
+++ b/include/mockturtle/utils/index_list.hpp
@@ -0,0 +1,1079 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file index_list.hpp
+  \brief List of indices to represent small networks.
+
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+
+#include <fmt/format.h>
+
+#include <array>
+#include <vector>
+
+namespace mockturtle
+{
+
+/*! \brief Index list for mux-inverter graphs.
+ *
+ * Small network consisting of mux gates and inverters
+ * represented as a list of literals.
+ *
+ * Example: The following index list creates the output function
+ * `<<x1 ? x2 : x3> ? x2 : x4>` with 4 inputs, 1 output, and 2 gates:
+ * `{4 | 1 << 8 | 2 << 16, 2, 4, 6, 4, 8, 10, 12}`
+ */
+struct muxig_index_list
+{
+public:
+  using element_type = uint32_t;
+
+public:
+  explicit muxig_index_list( uint32_t num_pis = 0 )
+      : values( { num_pis } )
+  {
+  }
+
+  explicit muxig_index_list( std::vector<element_type> const& values )
+      : values( std::begin( values ), std::end( values ) )
+  {}
+
+  std::vector<element_type> raw() const
+  {
+    return values;
+  }
+
+  uint64_t size() const
+  {
+    return values.size();
+  }
+
+  uint64_t num_gates() const
+  {
+    return ( values.at( 0 ) >> 16 );
+  }
+
+  uint64_t num_pis() const
+  {
+    return values.at( 0 ) & 0xff;
+  }
+
+  uint64_t num_pos() const
+  {
+    return ( values.at( 0 ) >> 8 ) & 0xff;
+  }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    assert( ( values.size() - 1u - num_pos() ) % 3 == 0 );
+    for ( uint64_t i = 1u; i < values.size() - num_pos(); i += 3 )
+    {
+      fn( values.at( i ), values.at( i + 1 ), values.at( i + 2 ) );
+    }
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    for ( uint64_t i = values.size() - num_pos(); i < values.size(); ++i )
+    {
+      fn( values.at( i ) );
+    }
+  }
+
+  void clear()
+  {
+    values.clear();
+    values.emplace_back( 0 );
+  }
+
+  void add_inputs( uint32_t n = 1u )
+  {
+    assert( num_pis() + n <= 0xff );
+    values.at( 0u ) += n;
+  }
+
+  element_type add_mux( element_type lit0, element_type lit1, element_type lit2 )
+  {
+    assert( num_gates() + 1u <= 0xffff );
+    values.at( 0u ) = ( ( num_gates() + 1 ) << 16 ) | ( values.at( 0 ) & 0xffff );
+    values.push_back( lit0 );
+    values.push_back( lit1 );
+    values.push_back( lit2 );
+    return ( num_gates() + num_pis() ) << 1;
+  }
+
+  element_type add_xor( element_type lit0, element_type lit1 )
+  {
+    assert( num_gates() + 1u <= 0xffff );
+    values.at( 0u ) = ( ( num_gates() + 1 ) << 16 ) | ( values.at( 0 ) & 0xffff );
+
+    // select, then, else
+    values.push_back( lit0 );
+    values.push_back( !lit1 );
+    values.push_back( lit1 );
+    return ( num_gates() + num_pis() ) << 1;
+  }
+
+  void add_output( element_type lit )
+  {
+    assert( num_pos() + 1 <= 0xff );
+    values.at( 0u ) = ( num_pos() + 1 ) << 8 | ( values.at( 0u ) & 0xffff00ff );
+    values.push_back( lit );
+  }
+
+private:
+  std::vector<element_type> values;
+};
+
+/*! \brief Inserts a muxig_index_list into an existing network
+ *
+ * **Required network functions:**
+ * - `get_constant`
+ * - `create_ite`
+ *
+ * \param ntk A logic network
+ * \param begin Begin iterator of signal inputs
+ * \param end End iterator of signal inputs
+ * \param indices An index list
+ * \param fn Callback function
+ */
+template<bool useSignal = true, typename Ntk, typename BeginIter, typename EndIter, typename Fn>
+void insert( Ntk& ntk, BeginIter begin, EndIter end, muxig_index_list const& indices, Fn&& fn )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_ite_v<Ntk>, "Ntk does not implement the create_maj method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  if constexpr ( useSignal )
+  {
+    static_assert( std::is_same_v<std::decay_t<typename std::iterator_traits<BeginIter>::value_type>, signal>, "BeginIter value_type must be Ntk signal type" );
+    static_assert( std::is_same_v<std::decay_t<typename std::iterator_traits<EndIter>::value_type>, signal>, "EndIter value_type must be Ntk signal type" );
+  }
+  else
+  {
+    static_assert( std::is_same_v<std::decay_t<typename std::iterator_traits<BeginIter>::value_type>, node>, "BeginIter value_type must be Ntk node type" );
+    static_assert( std::is_same_v<std::decay_t<typename std::iterator_traits<EndIter>::value_type>, node>, "EndIter value_type must be Ntk node type" );
+  }
+
+  assert( uint64_t( std::distance( begin, end ) ) == indices.num_pis() );
+
+  std::vector<signal> signals;
+  signals.emplace_back( ntk.get_constant( false ) );
+  for ( auto it = begin; it != end; ++it )
+  {
+    if constexpr ( useSignal )
+    {
+      signals.push_back( *it );
+    }
+    else
+    {
+      signals.emplace_back( ntk.make_signal( *it ) );
+    }
+  }
+
+  indices.foreach_gate( [&]( uint32_t lit0, uint32_t lit1, uint32_t lit2 ) {
+    signal const s0 = ( lit0 % 2 ) ? !signals.at( lit0 >> 1 ) : signals.at( lit0 >> 1 );
+    signal const s1 = ( lit1 % 2 ) ? !signals.at( lit1 >> 1 ) : signals.at( lit1 >> 1 );
+    signal const s2 = ( lit2 % 2 ) ? !signals.at( lit2 >> 1 ) : signals.at( lit2 >> 1 );
+    signals.push_back( ntk.create_ite( s0, s1, s2 ) );
+  } );
+
+  indices.foreach_po( [&]( uint32_t lit ) {
+    uint32_t const i = lit >> 1;
+    fn( ( lit % 2 ) ? !signals.at( i ) : signals.at( i ) );
+  } );
+}
+
+/*! \brief Converts an mig_index_list to a string
+ *
+ * \param indices An index list
+ * \return A string representation of the index list
+ */
+inline std::string to_index_list_string( muxig_index_list const& indices )
+{
+  auto s = fmt::format( "{{{} pis | {} pos | {} gates", indices.num_pis(), indices.num_pos(), indices.num_gates() );
+
+  indices.foreach_gate( [&]( uint32_t lit0, uint32_t lit1, uint32_t lit2 ) {
+    s += fmt::format( ", ({} ? {} : {})", lit0, lit1, lit2 );
+  } );
+
+  indices.foreach_po( [&]( uint32_t lit ) {
+    s += fmt::format( ", {}", lit );
+  } );
+
+  s += "}";
+
+  return s;
+}
+
+/*! \brief Index list for majority-inverter graphs.
+ *
+ * Small network consisting of majority gates and inverters
+ * represented as a list of literals.
+ *
+ * Example: The following index list creates the output function
+ * `<<x1, x2, x3>, x2, x4>` with 4 inputs, 1 output, and 2 gates:
+ * `{4 | 1 << 8 | 2 << 16, 2, 4, 6, 4, 8, 10, 12}`
+ */
+struct mig_index_list
+{
+public:
+  using element_type = uint32_t;
+
+public:
+  explicit mig_index_list( uint32_t num_pis = 0 )
+      : values( { num_pis } )
+  {
+  }
+
+  explicit mig_index_list( std::vector<element_type> const& values )
+      : values( std::begin( values ), std::end( values ) )
+  {}
+
+  std::vector<element_type> raw() const
+  {
+    return values;
+  }
+
+  uint64_t size() const
+  {
+    return values.size();
+  }
+
+  uint64_t num_gates() const
+  {
+    return ( values.at( 0 ) >> 16 );
+  }
+
+  uint64_t num_pis() const
+  {
+    return values.at( 0 ) & 0xff;
+  }
+
+  uint64_t num_pos() const
+  {
+    return ( values.at( 0 ) >> 8 ) & 0xff;
+  }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    assert( ( values.size() - 1u - num_pos() ) % 3 == 0 );
+    for ( uint64_t i = 1u; i < values.size() - num_pos(); i += 3 )
+    {
+      fn( values.at( i ), values.at( i + 1 ), values.at( i + 2 ) );
+    }
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    for ( uint64_t i = values.size() - num_pos(); i < values.size(); ++i )
+    {
+      fn( values.at( i ) );
+    }
+  }
+
+  void clear()
+  {
+    values.clear();
+    values.emplace_back( 0 );
+  }
+
+  void add_inputs( uint32_t n = 1u )
+  {
+    assert( num_pis() + n <= 0xff );
+    values.at( 0u ) += n;
+  }
+
+  element_type add_maj( element_type lit0, element_type lit1, element_type lit2 )
+  {
+    assert( num_gates() + 1u <= 0xffff );
+    values.at( 0u ) = ( ( num_gates() + 1 ) << 16 ) | ( values.at( 0 ) & 0xffff );
+    values.push_back( lit0 );
+    values.push_back( lit1 );
+    values.push_back( lit2 );
+    return ( num_gates() + num_pis() ) << 1;
+  }
+
+  void add_output( element_type lit )
+  {
+    assert( num_pos() + 1 <= 0xff );
+    values.at( 0u ) = ( num_pos() + 1 ) << 8 | ( values.at( 0u ) & 0xffff00ff );
+    values.push_back( lit );
+  }
+
+private:
+  std::vector<element_type> values;
+};
+
+/*! \brief Generates a mig_index_list from a network
+ *
+ * The function requires `ntk` to consist of majority gates.
+ *
+ * **Required network functions:**
+ * - `foreach_fanin`
+ * - `foreach_gate`
+ * - `get_node`
+ * - `is_complemented`
+ * - `is_maj`
+ * - `node_to_index`
+ * - `num_gates`
+ * - `num_pis`
+ * - `num_pos`
+ *
+ * \param indices An index list
+ * \param ntk A logic network
+ */
+template<typename Ntk>
+void encode( mig_index_list& indices, Ntk const& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_is_maj_v<Ntk>, "Ntk does not implement the is_maj method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_num_gates_v<Ntk>, "Ntk does not implement the num_gates method" );
+  static_assert( has_num_pis_v<Ntk>, "Ntk does not implement the num_pis method" );
+  static_assert( has_num_pos_v<Ntk>, "Ntk does not implement the num_pos method" );
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  ntk.foreach_pi( [&]( node const& n, uint64_t index ) {
+    if ( ntk.node_to_index( n ) != index + 1 )
+    {
+      fmt::print( "[e] network is not in normalized index order (violated by PI {})\n", index + 1 );
+      std::abort();
+    }
+  } );
+
+  /* inputs */
+  indices.add_inputs( ntk.num_pis() );
+
+  /* gates */
+  ntk.foreach_gate( [&]( node const& n, uint64_t index ) {
+    assert( ntk.is_maj( n ) );
+    if ( ntk.node_to_index( n ) != ntk.num_pis() + index + 1 )
+    {
+      fmt::print( "[e] network is not in normalized index order (violated by node {})\n", ntk.node_to_index( n ) );
+      std::abort();
+    }
+
+    std::array<uint32_t, 3u> lits;
+    ntk.foreach_fanin( n, [&]( signal const& fi, uint64_t index ) {
+      if ( ntk.node_to_index( ntk.get_node( fi ) ) > ntk.node_to_index( n ) )
+      {
+        fmt::print( "[e] node {} not in topological order\n", ntk.node_to_index( n ) );
+        std::abort();
+      }
+      lits[index] = 2 * ntk.node_to_index( ntk.get_node( fi ) ) + ntk.is_complemented( fi );
+    } );
+    indices.add_maj( lits[0u], lits[1u], lits[2u] );
+  } );
+
+  /* outputs */
+  ntk.foreach_po( [&]( signal const& f ) {
+    indices.add_output( 2 * ntk.node_to_index( ntk.get_node( f ) ) + ntk.is_complemented( f ) );
+  } );
+
+  assert( indices.size() == 1u + 3u * ntk.num_gates() + ntk.num_pos() );
+}
+
+/*! \brief Inserts a mig_index_list into an existing network
+ *
+ * **Required network functions:**
+ * - `get_constant`
+ * - `create_maj`
+ *
+ * \param ntk A logic network
+ * \param begin Begin iterator of signal inputs
+ * \param end End iterator of signal inputs
+ * \param indices An index list
+ * \param fn Callback function
+ */
+template<bool useSignal = true, typename Ntk, typename BeginIter, typename EndIter, typename Fn>
+void insert( Ntk& ntk, BeginIter begin, EndIter end, mig_index_list const& indices, Fn&& fn )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_maj_v<Ntk>, "Ntk does not implement the create_maj method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  if constexpr ( useSignal )
+  {
+    static_assert( std::is_same_v<std::decay_t<typename std::iterator_traits<BeginIter>::value_type>, signal>, "BeginIter value_type must be Ntk signal type" );
+    static_assert( std::is_same_v<std::decay_t<typename std::iterator_traits<EndIter>::value_type>, signal>, "EndIter value_type must be Ntk signal type" );
+  }
+  else
+  {
+    static_assert( std::is_same_v<std::decay_t<typename std::iterator_traits<BeginIter>::value_type>, node>, "BeginIter value_type must be Ntk node type" );
+    static_assert( std::is_same_v<std::decay_t<typename std::iterator_traits<EndIter>::value_type>, node>, "EndIter value_type must be Ntk node type" );
+  }
+
+  assert( uint64_t( std::distance( begin, end ) ) == indices.num_pis() );
+
+  std::vector<signal> signals;
+  signals.emplace_back( ntk.get_constant( false ) );
+  for ( auto it = begin; it != end; ++it )
+  {
+    if constexpr ( useSignal )
+    {
+      signals.push_back( *it );
+    }
+    else
+    {
+      signals.emplace_back( ntk.make_signal( *it ) );
+    }
+  }
+
+  indices.foreach_gate( [&]( uint32_t lit0, uint32_t lit1, uint32_t lit2 ) {
+    signal const s0 = ( lit0 % 2 ) ? !signals.at( lit0 >> 1 ) : signals.at( lit0 >> 1 );
+    signal const s1 = ( lit1 % 2 ) ? !signals.at( lit1 >> 1 ) : signals.at( lit1 >> 1 );
+    signal const s2 = ( lit2 % 2 ) ? !signals.at( lit2 >> 1 ) : signals.at( lit2 >> 1 );
+    signals.push_back( ntk.create_maj( s0, s1, s2 ) );
+  } );
+
+  indices.foreach_po( [&]( uint32_t lit ) {
+    uint32_t const i = lit >> 1;
+    fn( ( lit % 2 ) ? !signals.at( i ) : signals.at( i ) );
+  } );
+}
+
+/*! \brief Converts an mig_index_list to a string
+ *
+ * \param indices An index list
+ * \return A string representation of the index list
+ */
+inline std::string to_index_list_string( mig_index_list const& indices )
+{
+  auto s = fmt::format( "{{{} | {} << 8 | {} << 16", indices.num_pis(), indices.num_pos(), indices.num_gates() );
+
+  indices.foreach_gate( [&]( uint32_t lit0, uint32_t lit1, uint32_t lit2 ) {
+    s += fmt::format( ", {}, {}, {}", lit0, lit1, lit2 );
+  } );
+
+  indices.foreach_po( [&]( uint32_t lit ) {
+    s += fmt::format( ", {}", lit );
+  } );
+
+  s += "}";
+
+  return s;
+}
+
+/*! \brief Index list for xor-and graphs.
+ *
+ * Small network represented as a list of literals. Supports XOR and
+ * AND gates.  The list has the following 32-bit unsigned integer
+ * elements.  It starts with a signature whose partitioned into `|
+ * num_gates | num_pos | num_pis |`, where `num_gates` accounts for
+ * the most-significant 16 bits, `num_pos` accounts for 8 bits, and
+ * `num_pis` accounts for the least-significant 8 bits.  Afterwards,
+ * gates are defined as literal indexes `(2 * i + c)`, where `i` is an
+ * index, with 0 indexing the constant 0, 1 to `num_pis` indexing the
+ * primary inputs, and all successive indexes for the gates.  Gate
+ * literals come in pairs.  If the first literal has a smaller value
+ * than the second one, an AND gate is created, otherwise, an XOR gate
+ * is created.  Afterwards, all outputs are defined in terms of
+ * literals.
+ *
+ * Example: The following index list creates the output function `(x1
+ * AND x2) XOR (x3 AND x4)` with 4 inputs, 1 output, and 3 gates:
+ * `{4 | 1 << 8 | 3 << 16, 2, 4, 6, 8, 12, 10, 14}`
+ *
+ * Note: if `separate_header = true`, the header will be split into 3
+ * elements to support networks with larger number of PIs.
+ */
+template<bool separate_header = false>
+struct xag_index_list
+{
+public:
+  using element_type = uint32_t;
+
+public:
+  explicit xag_index_list( uint32_t num_pis = 0 )
+      : values( { num_pis } )
+  {
+    if constexpr ( separate_header )
+    {
+      values.emplace_back( 0 );
+      values.emplace_back( 0 );
+    }
+  }
+
+  explicit xag_index_list( std::vector<element_type> const& values )
+      : values( std::begin( values ), std::end( values ) )
+  {}
+
+  std::vector<element_type> raw() const
+  {
+    return values;
+  }
+
+  uint64_t size() const
+  {
+    return values.size();
+  }
+
+  uint64_t num_gates() const
+  {
+    if constexpr ( separate_header )
+    {
+      return values.at( 2 );
+    }
+    return ( values.at( 0 ) >> 16 );
+  }
+
+  uint64_t num_pis() const
+  {
+    if constexpr ( separate_header )
+    {
+      return values.at( 0 );
+    }
+    return values.at( 0 ) & 0xff;
+  }
+
+  uint64_t num_pos() const
+  {
+    if constexpr ( separate_header )
+    {
+      return values.at( 1 );
+    }
+    return ( values.at( 0 ) >> 8 ) & 0xff;
+  }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    if constexpr ( separate_header )
+    {
+      assert( ( values.size() - 3u - num_pos() ) % 2 == 0 );
+      for ( uint64_t i = 3u; i < values.size() - num_pos(); i += 2 )
+      {
+        fn( values.at( i ), values.at( i + 1 ) );
+      }
+    }
+    else
+    {
+      assert( ( values.size() - 1u - num_pos() ) % 2 == 0 );
+      for ( uint64_t i = 1u; i < values.size() - num_pos(); i += 2 )
+      {
+        fn( values.at( i ), values.at( i + 1 ) );
+      }
+    }
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    for ( uint64_t i = values.size() - num_pos(); i < values.size(); ++i )
+    {
+      fn( values.at( i ) );
+    }
+  }
+
+  void clear()
+  {
+    values.clear();
+    values.emplace_back( 0 );
+    if constexpr ( separate_header )
+    {
+      values.emplace_back( 0 );
+      values.emplace_back( 0 );
+    }
+  }
+
+  void add_inputs( uint32_t n = 1u )
+  {
+    if constexpr ( !separate_header )
+    {
+      assert( num_pis() + n <= 0xff );
+    }
+    values.at( 0u ) += n;
+  }
+
+  element_type add_and( element_type lit0, element_type lit1 )
+  {
+    if constexpr ( separate_header )
+    {
+      values.at( 2u ) += 1;
+    }
+    else
+    {
+      assert( num_gates() + 1u <= 0xffff );
+      values.at( 0u ) = ( ( num_gates() + 1 ) << 16 ) | ( values.at( 0 ) & 0xffff );
+    }
+
+    values.push_back( lit0 < lit1 ? lit0 : lit1 );
+    values.push_back( lit0 < lit1 ? lit1 : lit0 );
+    return ( num_gates() + num_pis() ) << 1;
+  }
+
+  element_type add_xor( element_type lit0, element_type lit1 )
+  {
+    if constexpr ( separate_header )
+    {
+      values.at( 2u ) += 1;
+    }
+    else
+    {
+      assert( num_gates() + 1u <= 0xffff );
+      values.at( 0u ) = ( ( num_gates() + 1 ) << 16 ) | ( values.at( 0 ) & 0xffff );
+    }
+
+    values.push_back( lit0 > lit1 ? lit0 : lit1 );
+    values.push_back( lit0 > lit1 ? lit1 : lit0 );
+    return ( num_gates() + num_pis() ) << 1;
+  }
+
+  void add_output( element_type lit )
+  {
+    if constexpr ( separate_header )
+    {
+      values.at( 1u ) += 1;
+    }
+    else
+    {
+      assert( num_pos() + 1 <= 0xff );
+      values.at( 0u ) = ( num_pos() + 1 ) << 8 | ( values.at( 0u ) & 0xffff00ff );
+    }
+
+    values.push_back( lit );
+  }
+
+private:
+  std::vector<element_type> values;
+};
+
+using large_xag_index_list = xag_index_list<true>;
+
+/*! \brief Generates a xag_index_list from a network
+ *
+ * The function requires `ntk` to consist of XOR and AND gates.
+ *
+ * **Required network functions:**
+ * - `foreach_fanin`
+ * - `foreach_gate`
+ * - `get_node`
+ * - `is_and`
+ * - `is_complemented`
+ * - `is_xor`
+ * - `node_to_index`
+ * - `num_gates`
+ * - `num_pis`
+ * - `num_pos`
+ *
+ * \param indices An index list
+ * \param ntk A logic network
+ */
+template<typename Ntk, bool separate_header = false>
+void encode( xag_index_list<separate_header>& indices, Ntk const& ntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_foreach_gate_v<Ntk>, "Ntk does not implement the foreach_gate method" );
+  static_assert( has_is_and_v<Ntk>, "Ntk does not implement the is_and method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+  static_assert( has_is_xor_v<Ntk>, "Ntk does not implement the is_xor method" );
+  static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  static_assert( has_num_gates_v<Ntk>, "Ntk does not implement the num_gates method" );
+  static_assert( has_num_pis_v<Ntk>, "Ntk does not implement the num_pis method" );
+  static_assert( has_num_pos_v<Ntk>, "Ntk does not implement the num_pos method" );
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  ntk.foreach_pi( [&]( node const& n, uint64_t index ) {
+    if ( ntk.node_to_index( n ) != index + 1 )
+    {
+      fmt::print( "[e] network is not in normalized index order (violated by PI {})\n", index + 1 );
+      std::abort();
+    }
+  } );
+
+  /* inputs */
+  indices.add_inputs( ntk.num_pis() );
+
+  /* gates */
+  ntk.foreach_gate( [&]( node const& n, uint64_t index ) {
+    assert( ntk.is_and( n ) || ntk.is_xor( n ) );
+    if ( ntk.node_to_index( n ) != ntk.num_pis() + index + 1 )
+    {
+      fmt::print( "[e] network is not in normalized index order (violated by node {})\n", ntk.node_to_index( n ) );
+      std::abort();
+    }
+
+    std::array<uint32_t, 2u> lits;
+    ntk.foreach_fanin( n, [&]( signal const& fi, uint64_t index ) {
+      if ( ntk.node_to_index( ntk.get_node( fi ) ) > ntk.node_to_index( n ) )
+      {
+        fmt::print( "[e] node {} not in topological order\n", ntk.node_to_index( n ) );
+        std::abort();
+      }
+      lits[index] = 2 * ntk.node_to_index( ntk.get_node( fi ) ) + ntk.is_complemented( fi );
+    } );
+
+    if ( ntk.is_and( n ) )
+    {
+      indices.add_and( lits[0u], lits[1u] );
+    }
+    else if ( ntk.is_xor( n ) )
+    {
+      indices.add_xor( lits[0u], lits[1u] );
+    }
+  } );
+
+  /* outputs */
+  ntk.foreach_po( [&]( signal const& f ) {
+    indices.add_output( 2 * ntk.node_to_index( ntk.get_node( f ) ) + ntk.is_complemented( f ) );
+  } );
+
+  if constexpr ( separate_header )
+  {
+    assert( indices.size() == 3u + 2u * ntk.num_gates() + ntk.num_pos() );
+  }
+  else
+  {
+    assert( indices.size() == 1u + 2u * ntk.num_gates() + ntk.num_pos() );
+  }
+}
+
+/*! \brief Inserts a xag_index_list into an existing network
+ *
+ * **Required network functions:**
+ * - `create_and`
+ * - `create_xor`
+ * - `get_constant`
+ *
+ * \param ntk A logic network
+ * \param begin Begin iterator of signal inputs
+ * \param end End iterator of signal inputs
+ * \param indices An index list
+ * \param fn Callback function
+ */
+template<bool useSignal = true, typename Ntk, typename BeginIter, typename EndIter, typename Fn, bool separate_header = false>
+void insert( Ntk& ntk, BeginIter begin, EndIter end, xag_index_list<separate_header> const& indices, Fn&& fn )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_and_v<Ntk>, "Ntk does not implement the create_and method" );
+  static_assert( has_create_xor_v<Ntk>, "Ntk does not implement the create_xor method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  if constexpr ( useSignal )
+  {
+    static_assert( std::is_same_v<std::decay_t<typename std::iterator_traits<BeginIter>::value_type>, signal>, "BeginIter value_type must be Ntk signal type" );
+    static_assert( std::is_same_v<std::decay_t<typename std::iterator_traits<EndIter>::value_type>, signal>, "EndIter value_type must be Ntk signal type" );
+  }
+  else
+  {
+    static_assert( std::is_same_v<std::decay_t<typename std::iterator_traits<BeginIter>::value_type>, node>, "BeginIter value_type must be Ntk node type" );
+    static_assert( std::is_same_v<std::decay_t<typename std::iterator_traits<EndIter>::value_type>, node>, "EndIter value_type must be Ntk node type" );
+  }
+
+  assert( uint64_t( std::distance( begin, end ) ) == indices.num_pis() );
+
+  std::vector<signal> signals;
+  signals.emplace_back( ntk.get_constant( false ) );
+  for ( auto it = begin; it != end; ++it )
+  {
+    if constexpr ( useSignal )
+    {
+      signals.push_back( *it );
+    }
+    else
+    {
+      signals.emplace_back( ntk.make_signal( *it ) );
+    }
+  }
+
+  indices.foreach_gate( [&]( uint32_t lit0, uint32_t lit1 ) {
+    assert( lit0 != lit1 );
+    uint32_t const i0 = lit0 >> 1;
+    uint32_t const i1 = lit1 >> 1;
+    signal const s0 = ( lit0 % 2 ) ? ntk.create_not( signals.at( i0 ) ) : signals.at( i0 );
+    signal const s1 = ( lit1 % 2 ) ? ntk.create_not( signals.at( i1 ) ) : signals.at( i1 );
+    signals.push_back( lit0 > lit1 ? ntk.create_xor( s0, s1 ) : ntk.create_and( s0, s1 ) );
+  } );
+
+  indices.foreach_po( [&]( uint32_t lit ) {
+    uint32_t const i = lit >> 1;
+    fn( ( lit % 2 ) ? ntk.create_not( signals.at( i ) ) : signals.at( i ) );
+  } );
+}
+
+/*! \brief Converts an xag_index_list to a string
+ *
+ * \param indices An index list
+ * \return A string representation of the index list
+ */
+inline std::string to_index_list_string( xag_index_list<false> const& indices )
+{
+  auto s = fmt::format( "{{{} | {} << 8 | {} << 16", indices.num_pis(), indices.num_pos(), indices.num_gates() );
+
+  indices.foreach_gate( [&]( uint32_t lit0, uint32_t lit1 ) {
+    s += fmt::format( ", {}, {}", lit0, lit1 );
+  } );
+
+  indices.foreach_po( [&]( uint32_t lit ) {
+    s += fmt::format( ", {}", lit );
+  } );
+
+  s += "}";
+
+  return s;
+}
+
+inline std::string to_index_list_string( xag_index_list<true> const& indices )
+{
+  auto s = fmt::format( "{{{}, {}, {}", indices.num_pis(), indices.num_pos(), indices.num_gates() );
+
+  indices.foreach_gate( [&]( uint32_t lit0, uint32_t lit1 ) {
+    s += fmt::format( ", {}, {}", lit0, lit1 );
+  } );
+
+  indices.foreach_po( [&]( uint32_t lit ) {
+    s += fmt::format( ", {}", lit );
+  } );
+
+  s += "}";
+
+  return s;
+}
+
+/*! \brief Generates a network from an index_list
+ *
+ * **Required network functions:**
+ * - `create_pi`
+ * - `create_po`
+ *
+ * \param ntk A logic network
+ * \param indices An index list
+ */
+template<typename Ntk, typename IndexList>
+void decode( Ntk& ntk, IndexList const& indices )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_create_pi_v<Ntk>, "Ntk does not implement the create_pi method" );
+  static_assert( has_create_po_v<Ntk>, "Ntk does not implement the create_po method" );
+
+  using signal = typename Ntk::signal;
+
+  std::vector<signal> signals( indices.num_pis() );
+  std::generate( std::begin( signals ), std::end( signals ),
+                 [&]() { return ntk.create_pi(); } );
+
+  insert( ntk, std::begin( signals ), std::end( signals ), indices,
+          [&]( signal const& s ) { ntk.create_po( s ); } );
+}
+
+/*! \brief Enumerate structured index_lists
+ *
+ * Enumerate concrete `xag_index_list`s from an abstract index list
+ * specification.  The specifiation is provided in an extended index
+ * list format, where a `-1` indicates an unspecified input.
+ *
+ * The algorithm concretizes unspecified inputs and negates nodes.
+ *
+ * The enumerator generates the following concrete index lists
+ *    {2 | 1 << 8 | 1 << 16, 2, 4, 6}
+ *    {2 | 1 << 8 | 1 << 16, 2, 4, 7}
+ *    {2 | 1 << 8 | 1 << 16, 3, 4, 6}
+ *    {2 | 1 << 8 | 1 << 16, 3, 4, 7}
+ *    {2 | 1 << 8 | 1 << 16, 3, 5, 6}
+ *    {2 | 1 << 8 | 1 << 16, 3, 5, 7}
+ *    {2 | 1 << 8 | 1 << 16, 2, 5, 6}
+ *    {2 | 1 << 8 | 1 << 16, 2, 5, 7}
+ * from the abstract index list specification `{ -1, -1, 6 }`.
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      aig_index_list_enumerator e( { -1, -1, -1, 6, 8 }, 2u, 2u, 1u );
+      e.run( [&]( xag_index_list const& il ) {
+        aig_network aig;
+        decode( aig, il );
+      } );
+   \endverbatim
+ */
+class aig_index_list_enumerator
+{
+public:
+  explicit aig_index_list_enumerator( std::vector<int32_t> const& values, uint32_t num_pis, uint32_t num_gates, uint32_t num_pos )
+      : values_( values ), num_pis( num_pis ), num_gates( num_gates ), num_pos( num_pos )
+  {}
+
+  template<typename Fn>
+  void run( Fn&& fn )
+  {
+    recurse( values_, 0u, fn );
+  }
+
+protected:
+  template<typename Fn>
+  void recurse( std::vector<int32_t> values, uint32_t pos, Fn&& fn )
+  {
+    /* process gate */
+    if ( pos < 2 * num_gates )
+    {
+      auto& a = values.at( pos );
+      auto& b = values.at( pos + 1 );
+      if ( a == -1 && b == -1 )
+      {
+        for ( uint32_t i = 0u; i < num_pis; ++i )
+        {
+          a = ( i + 1 ) << 1;
+          for ( uint32_t j = i + 1; j < num_pis; ++j )
+          {
+            b = ( j + 1 ) << 1;
+            recurse( values, pos + 2, fn );
+            a = a ^ 1;
+            recurse( values, pos + 2, fn );
+            b = b ^ 1;
+            recurse( values, pos + 2, fn );
+            a = a ^ 1;
+            recurse( values, pos + 2, fn );
+            b = b ^ 1;
+          }
+        }
+        return;
+      }
+      else if ( a == -1 )
+      {
+        for ( uint32_t i = 0u; i < num_pis; ++i )
+        {
+          a = ( i + 1 ) << 1;
+          recurse( values, pos + 2, fn );
+          a = a ^ 1;
+          recurse( values, pos + 2, fn );
+          b = b ^ 1;
+          recurse( values, pos + 2, fn );
+          a = a ^ 1;
+          recurse( values, pos + 2, fn );
+          b = b ^ 1;
+        }
+        return;
+      }
+      else if ( b == -1 )
+      {
+        for ( uint32_t i = 0u; i < num_pis; ++i )
+        {
+          b = ( i + 1 ) << 1;
+          recurse( values, pos + 2, fn );
+          a = a ^ 1;
+          recurse( values, pos + 2, fn );
+          b = b ^ 1;
+          recurse( values, pos + 2, fn );
+          a = a ^ 1;
+          recurse( values, pos + 2, fn );
+          b = b ^ 1;
+        }
+        return;
+      }
+
+      recurse( values, pos + 2, fn );
+      a = a ^ 1;
+      recurse( values, pos + 2, fn );
+      b = b ^ 1;
+      recurse( values, pos + 2, fn );
+      a = a ^ 1;
+      recurse( values, pos + 2, fn );
+      b = b ^ 1;
+      return;
+    }
+
+    /* process output */
+    if ( pos < values.size() )
+    {
+      auto& o = values.at( pos );
+      recurse( values, pos + 1u, fn );
+      o = o ^ 1;
+      recurse( values, pos + 1u, fn );
+      return;
+    }
+
+    /* finished processing values */
+    std::vector<uint32_t> index_list;
+    index_list.emplace_back( num_pis | ( num_pos << 8 ) | ( num_gates << 16 ) );
+    for ( int32_t const& v : values )
+    {
+      index_list.emplace_back( v );
+    }
+    fn( xag_index_list( index_list ) );
+  }
+
+protected:
+  std::vector<int32_t> values_;
+  uint32_t num_pis;
+  uint32_t num_gates;
+  uint32_t num_pos;
+};
+
+template<class T>
+struct is_index_list : std::false_type
+{
+};
+
+template<>
+struct is_index_list<xag_index_list<true>> : std::true_type
+{
+};
+
+template<>
+struct is_index_list<xag_index_list<false>> : std::true_type
+{
+};
+
+template<>
+struct is_index_list<mig_index_list> : std::true_type
+{
+};
+
+template<class T>
+inline constexpr bool is_index_list_v = is_index_list<T>::value;
+
+} // namespace mockturtle
diff --git a/include/mockturtle/utils/json_utils.hpp b/include/mockturtle/utils/json_utils.hpp
new file mode 100644
index 0000000..b19f11b
--- /dev/null
+++ b/include/mockturtle/utils/json_utils.hpp
@@ -0,0 +1,53 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file json_utils.hpp
+  \brief JSON utils
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <kitty/dynamic_truth_table.hpp>
+#include <nlohmann/json.hpp>
+
+namespace kitty
+{
+
+inline void to_json( nlohmann::json& j, const dynamic_truth_table& tt )
+{
+  j = nlohmann::json{ { "_bits", tt._bits }, { "_num_vars", tt._num_vars } };
+}
+
+inline void from_json( const nlohmann::json& j, dynamic_truth_table& tt )
+{
+  j.at( "_bits" ).get_to( tt._bits );
+  j.at( "_num_vars" ).get_to( tt._num_vars );
+}
+
+} // namespace kitty
\ No newline at end of file
diff --git a/include/mockturtle/utils/mixed_radix.hpp b/include/mockturtle/utils/mixed_radix.hpp
new file mode 100644
index 0000000..1660a49
--- /dev/null
+++ b/include/mockturtle/utils/mixed_radix.hpp
@@ -0,0 +1,113 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mixed_radix.hpp
+  \brief Mixed radix loop
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <type_traits>
+#include <vector>
+
+namespace mockturtle
+{
+
+/*! \brief Mixed radix enumeration.
+ *
+ * The iterator pair `begin` and `end` represent a list of radixes, which are
+ * used to enumerate all combinations of indexes.
+ *
+ * For example if the radixes are \f$2, 3, 3\f$, then the callable `fn` is
+ * called on the index lists \f$0, 0, 0\f$, \f$0, 0, 1\f$, \f$0, 0, 2\f$,
+ * \f$\dots\f$, \f$1, 2, 1\f$, \f$1, 2, 2\f$.
+ *
+ * The callable `fn` expects two parameters which are an iterator pair of the
+ * indexes.  If it returns a `bool`, the iteration is stopped, if the return
+ * value is `false`.
+ *
+ * \param begin Begin iterator of radixes
+ * \param end End iterator of radixes
+ * \param fn Callable
+ */
+template<typename Iterator, typename Fn>
+void foreach_mixed_radix_tuple( Iterator begin, Iterator end, Fn&& fn )
+{
+  constexpr auto is_bool_f = std::is_invocable_r_v<bool, Fn, std::vector<uint32_t>::iterator, std::vector<uint32_t>::iterator>;
+  constexpr auto is_void_f = std::is_invocable_r_v<void, Fn, std::vector<uint32_t>::iterator, std::vector<uint32_t>::iterator>;
+
+  static_assert( is_bool_f || is_void_f );
+
+  std::vector<uint32_t> positions( std::distance( begin, end ), 0u );
+
+  while ( true )
+  {
+    if constexpr ( is_bool_f )
+    {
+      if ( !fn( positions.begin(), positions.end() ) )
+      {
+        return;
+      }
+    }
+    else
+    {
+      fn( positions.begin(), positions.end() );
+    }
+
+    auto itm = end - 1;
+    auto itp = positions.end() - 1;
+    auto ret = false;
+    while ( !ret && *itp == ( *itm - 1 ) )
+    {
+      *itp = 0;
+      if ( itp != positions.begin() )
+      {
+        --itp;
+      }
+
+      if ( itm == begin )
+      {
+        ret = true;
+      }
+      else
+      {
+        --itm;
+      }
+    }
+
+    if ( ret )
+    {
+      break;
+    }
+
+    ( *itp )++;
+  }
+}
+
+} // namespace mockturtle
diff --git a/include/mockturtle/utils/name_utils.hpp b/include/mockturtle/utils/name_utils.hpp
new file mode 100644
index 0000000..19e4d9d
--- /dev/null
+++ b/include/mockturtle/utils/name_utils.hpp
@@ -0,0 +1,159 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file name_utils.hpp
+  \brief Utility functions to restore network names after optimization.
+
+  \author Marcel Walter
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+#include "node_map.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Restores the network name that might have been given to network's former incarnation.
+ *
+ * \param ntk_src The source logic network, which potentially has a name
+ * \param ntk_dest The destination logic network, whose name is to be restored
+ */
+template<typename NtkSrc, typename NtkDest>
+void restore_network_name( const NtkSrc& ntk_src, NtkDest& ntk_dest ) noexcept
+{
+  static_assert( is_network_type_v<NtkSrc>, "NtkSrc is not a network type" );
+  static_assert( is_network_type_v<NtkDest>, "NtkDest is not a network type" );
+
+  if constexpr ( has_get_network_name_v<NtkSrc> && has_set_network_name_v<NtkDest> )
+  {
+    ntk_dest.set_network_name( ntk_src.get_network_name() );
+  }
+}
+
+/*! \brief Restores all names that might have been given to a network's former incarnation.
+ *
+ * **Required network functions for the NtkSrc:**
+ * - `foreach_node`
+ * - `foreach_fanin`
+ * - `foreach_po`
+ * - `get_node`
+ *
+ * \param ntk_src The source logic network, which potentially has named signals
+ * \param ntk_dest The destination logic network, whose names are to be restored
+ * \param old2new Mapping of nodes from ntk_src to signals of ntk_dest
+ */
+template<typename NtkSrc, typename NtkDest>
+void restore_names( const NtkSrc& ntk_src, NtkDest& ntk_dest, node_map<signal<NtkDest>, NtkSrc>& old2new ) noexcept
+{
+  restore_network_name( ntk_src, ntk_dest );
+
+  if constexpr ( has_has_name_v<NtkSrc> && has_get_name_v<NtkSrc> && has_set_name_v<NtkDest> )
+  {
+    static_assert( has_foreach_node_v<NtkSrc>, "NtkSrc does not implement the foreach_node function" );
+    static_assert( has_foreach_fanin_v<NtkSrc>, "NtkSrc does not implement the foreach_fanin function" );
+    static_assert( has_foreach_po_v<NtkSrc>, "NtkSrc does not implement the foreach_po function" );
+    static_assert( has_get_node_v<NtkSrc>, "NtkSrc does not implement the get_node function" );
+
+    const auto restore_signal_name = [&ntk_src, &ntk_dest, &old2new]( const auto& f ) {
+      if ( ntk_src.has_name( f ) )
+      {
+        const auto name = ntk_src.get_name( f );
+
+        ntk_dest.set_name( old2new[ntk_src.get_node( f )], name );
+      }
+    };
+
+    const auto restore_output_name = [&ntk_src, &ntk_dest]( [[maybe_unused]] const auto& po, const auto i ) {
+      if ( ntk_src.has_output_name( i ) )
+      {
+        const auto name = ntk_src.get_output_name( i );
+
+        ntk_dest.set_output_name( i, name );
+      }
+    };
+
+    ntk_src.foreach_node( [&ntk_src, &restore_signal_name]( const auto& n ) { ntk_src.foreach_fanin( n, restore_signal_name ); } );
+
+    ntk_src.foreach_po( restore_output_name );
+  }
+}
+
+/*! \brief Restore PI and PO names, matching by order.
+ *
+ * **Required network functions for NtkSrc:**
+ * - `foreach_pi`
+ * - `foreach_po`
+ * - `num_pis`
+ * - `num_pos`
+ * - `has_name`
+ * - `get_name`
+ * - `make_signal`
+ * - `has_output_name`
+ * - `get_output_name`
+ *
+ * **Required network functions for NtkDest:**
+ * - `foreach_pi`
+ * - `num_pis`
+ * - `num_pos`
+ * - `set_name`
+ * - `make_signal`
+ * - `set_output_name`
+ *
+ * \param ntk_src The source logic network, which potentially has named signals
+ * \param ntk_dest The destination logic network, whose names are to be restored
+ */
+template<typename NtkSrc, typename NtkDest>
+void restore_pio_names_by_order( const NtkSrc& ntk_src, NtkDest& ntk_dest )
+{
+  static_assert( is_network_type_v<NtkSrc>, "NtkSrc is not a network type" );
+  static_assert( is_network_type_v<NtkDest>, "NtkDest is not a network type" );
+  static_assert( has_has_name_v<NtkSrc> && has_get_name_v<NtkSrc>, "NtkSrc does not implement the has_name and/or get_name functions" );
+  static_assert( has_has_output_name_v<NtkSrc> && has_get_output_name_v<NtkSrc>, "NtkSrc does not implement the has_output_name and/or get_output_name functions" );
+  static_assert( has_set_name_v<NtkDest> && has_set_output_name_v<NtkDest>, "NtkDest does not implement the set_name and/or set_output_name functions" );
+
+  assert( ntk_src.num_pis() == ntk_dest.num_pis() );
+  assert( ntk_src.num_pos() == ntk_dest.num_pos() );
+
+  std::vector<std::string> pi_names( ntk_src.num_pis(), "" );
+  ntk_src.foreach_pi( [&]( auto const& n, auto i ) {
+    if ( ntk_src.has_name( ntk_src.make_signal( n ) ) )
+      pi_names[i] = ntk_src.get_name( ntk_src.make_signal( n ) );
+  } );
+  ntk_dest.foreach_pi( [&]( auto const& n, auto i ) {
+    if ( pi_names[i] != "" )
+      ntk_dest.set_name( ntk_dest.make_signal( n ), pi_names[i] );
+  } );
+
+  ntk_src.foreach_po( [&]( auto const& f, auto i ) {
+    if ( ntk_src.has_output_name( i ) )
+      ntk_dest.set_output_name( i, ntk_src.get_output_name( i ) );
+  } );
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/utils/network_cache.hpp b/include/mockturtle/utils/network_cache.hpp
new file mode 100644
index 0000000..26e28d3
--- /dev/null
+++ b/include/mockturtle/utils/network_cache.hpp
@@ -0,0 +1,173 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file network_cache.hpp
+  \brief Network cache
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <sstream>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+
+#include <fmt/format.h>
+#include <kitty/print.hpp>
+#include <nlohmann/json.hpp>
+
+#include "../algorithms/simulation.hpp"
+#include "../io/verilog_reader.hpp"
+#include "../io/write_verilog.hpp"
+#include "../traits.hpp"
+#include "../views/topo_view.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Network cache.
+ *
+ * ...
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      ...
+   \endverbatim
+ */
+template<typename Ntk, typename Key, class Hash = std::hash<Key>>
+class network_cache
+{
+public:
+  explicit network_cache( uint32_t num_vars )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_create_pi_v<Ntk>, "Ntk does not implement the create_pi method" );
+
+    ensure_pis( num_vars );
+  }
+
+  Ntk& network()
+  {
+    return _db;
+  }
+
+  std::vector<signal<Ntk>> const& pis() const
+  {
+    return _pis;
+  }
+
+  void ensure_pis( uint32_t count )
+  {
+    if ( count > _pis.size() )
+    {
+      for ( auto i = _pis.size(); i < count; ++i )
+      {
+        _pis.emplace_back( _db.create_pi() );
+      }
+    }
+  }
+
+  auto size() const
+  {
+    return _db.num_pos();
+  }
+
+  bool has( Key const& key ) const
+  {
+    return _map.find( key ) != _map.end();
+  }
+
+  template<class _Ntk>
+  bool insert( Key const& key, _Ntk const& ntk )
+  {
+    /* ntk must have one primary output and not too many primary inputs */
+    if ( ntk.num_pos() != 1u || ntk.num_pis() > _pis.size() )
+    {
+      return false;
+    }
+
+    /* insert ntk into _db, create an output and return the index of the output */
+    const auto f = cleanup_dangling( ntk, _db, _pis.begin(), _pis.begin() + ntk.num_pis() ).front();
+    insert_signal( key, f );
+    return true;
+  }
+
+  void insert_signal( Key const& key, signal<Ntk> const& f )
+  {
+    _map.emplace( key, f );
+    _db.create_po( f );
+    _output_functions.push_back( key );
+  }
+
+  signal<Ntk> get( Key const& key ) const
+  {
+    return _map.at( key ).first;
+  }
+
+  auto get_view( Key const& key ) const
+  {
+    return topo_view<Ntk>( _db, _map.at( key ) );
+  }
+
+  void insert_json( nlohmann::json const& data )
+  {
+    ensure_pis( data["num_pis"].get<uint32_t>() );
+
+    std::istringstream sstr( data["db"].get<std::string>() );
+    Ntk read_ntk;
+    lorina::read_verilog( sstr, verilog_reader( read_ntk ) );
+    const auto pos = cleanup_dangling( read_ntk, _db, _pis.begin(), _pis.end() );
+
+    auto cntr = 0u;
+    for ( auto const& tt : data["output_functions"].get<std::vector<Key>>() )
+    {
+      insert_signal( tt, pos[cntr++] );
+    }
+  }
+
+  nlohmann::json to_json() const
+  {
+    std::stringstream sstr;
+    write_verilog( _db, sstr );
+
+    return nlohmann::json{ { "num_pis", _pis.size() }, { "output_functions", _output_functions }, { "db", sstr.str() } };
+  }
+
+private:
+  Ntk _db;
+  std::vector<signal<Ntk>> _pis;
+  std::unordered_map<Key, signal<Ntk>, Hash> _map;
+  std::vector<Key> _output_functions;
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/utils/network_utils.hpp b/include/mockturtle/utils/network_utils.hpp
new file mode 100644
index 0000000..0a6bdda
--- /dev/null
+++ b/include/mockturtle/utils/network_utils.hpp
@@ -0,0 +1,237 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file network_utils.hpp
+  \brief Utility functions to insert a network into another network.
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+#include "node_map.hpp"
+
+#include <vector>
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+template<typename NtkSrc, typename NtkDest>
+auto clone_node_topologically( NtkSrc const& ntk, NtkDest& subntk, unordered_node_map<typename NtkDest::signal, NtkSrc>& node_to_signal, typename NtkSrc::node n )
+{
+  if ( node_to_signal.has( n ) )
+  {
+    return node_to_signal[n];
+  }
+
+  std::vector<typename NtkDest::signal> children;
+  ntk.foreach_fanin( n, [&]( auto const& fi ) {
+    auto s = clone_node_topologically( ntk, subntk, node_to_signal, ntk.get_node( fi ) );
+    children.emplace_back( ntk.is_complemented( fi ) ? !s : s );
+  } );
+
+  if constexpr ( has_is_and_v<NtkSrc> )
+  {
+    static_assert( has_create_and_v<NtkDest> && "NtkDest does not implement the create_and method" );
+    if ( ntk.is_and( n ) )
+    {
+      assert( children.size() == 2u );
+      return node_to_signal[n] = subntk.create_and( children[0], children[1] );
+    }
+  }
+  if constexpr ( has_is_xor_v<NtkSrc> )
+  {
+    static_assert( has_create_xor_v<NtkDest> && "NtkDest does not implement the create_xor method" );
+    if ( ntk.is_xor( n ) )
+    {
+      assert( children.size() == 2u );
+      return node_to_signal[n] = subntk.create_xor( children[0], children[1] );
+    }
+  }
+  if constexpr ( has_is_maj_v<NtkSrc> )
+  {
+    static_assert( has_create_maj_v<NtkDest> && "NtkDest does not implement the create_maj method" );
+    if ( ntk.is_maj( n ) )
+    {
+      assert( children.size() == 3u );
+      return node_to_signal[n] = subntk.create_maj( children[0], children[1], children[2] );
+    }
+  }
+  if constexpr ( has_is_xor3_v<NtkSrc> )
+  {
+    static_assert( has_create_xor3_v<NtkDest> && "NtkDest does not implement the create_xor3 method" );
+    if ( ntk.is_xor3( n ) )
+    {
+      assert( children.size() == 3u );
+      return node_to_signal[n] = subntk.create_xor3( children[0], children[1], children[2] );
+    }
+  }
+
+  assert( false && "[e] unsupported node type" );
+  return subntk.get_constant( false );
+}
+
+} // namespace detail
+
+/*! \brief Constructs a (sub-)network from a window of another network.
+ *
+ * The window is specified by three parameters:
+ *   1.) `inputs` are the common support of all window nodes, they do
+ *       not overlap with `gates` (i.e., the intersection of `inputs` and
+ *       `gates` is the empty set).
+ *   2.) `gates` are the nodes in the window, supported by the
+ *       `inputs` (i.e., `gates` are in the transitive fanout of the
+ *       `inputs`).
+ *   3.) `outputs` are signals (regular or complemented nodes)
+ *        pointing to nodes in `gates` or `inputs`.  Not all fanouts
+ *        of an output node are already part of the window.
+ *
+ * **Required network functions for the source Ntk:**
+ * - `foreach_fanin`
+ * - `get_node`
+ * - `get_constant`
+ * - `is_complemented`
+ *
+ * **Required network functions for the cloned SubNtk:**
+ * - `create_pi`
+ * - `create_po`
+ * - `create_not`
+ * - `get_constant`
+ *
+ * \param ntk A logic network
+ * \param subntk An empty network to be constructed
+ */
+template<typename Ntk, typename SubNtk>
+void clone_subnetwork( Ntk const& ntk, std::vector<typename Ntk::node> const& inputs, std::vector<typename Ntk::signal> const& outputs, std::vector<typename Ntk::node> const& gates, SubNtk& subntk )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+
+  static_assert( is_network_type_v<SubNtk>, "SubNtk is not a network type" );
+  static_assert( has_create_pi_v<SubNtk>, "SubNtk does not implement the create_pi method" );
+  static_assert( has_create_po_v<SubNtk>, "SubNtk does not implement the create_po method" );
+  static_assert( has_create_not_v<SubNtk>, "SubNtk does not implement the create_not method" );
+  static_assert( has_get_constant_v<SubNtk>, "SubNtk does not implement the get_constant method" );
+
+  /* map from nodes in ntk to signals in subntk */
+  unordered_node_map<typename SubNtk::signal, Ntk> node_to_signal( ntk );
+
+  /* constant */
+  node_to_signal[ntk.get_node( ntk.get_constant( false ) )] = subntk.get_constant( false );
+  if ( ntk.get_node( ntk.get_constant( false ) ) != ntk.get_node( ntk.get_constant( true ) ) )
+  {
+    node_to_signal[ntk.get_node( ntk.get_constant( true ) )] = subntk.get_constant( true );
+  }
+
+  /* inputs */
+  for ( auto const& i : inputs )
+  {
+    node_to_signal[i] = subntk.create_pi();
+  }
+
+  /* create gates topologically */
+  for ( auto const& g : gates )
+  {
+    detail::clone_node_topologically( ntk, subntk, node_to_signal, g );
+  }
+
+  /* outputs */
+  for ( auto const& o : outputs )
+  {
+    subntk.create_po( ntk.is_complemented( o ) ? subntk.create_not( node_to_signal[ntk.get_node( o )] ) : node_to_signal[ntk.get_node( o )] );
+  }
+}
+
+/*! \brief Inserts a network into another network
+ *
+ * **Required network functions for the host Ntk:**
+ * - `get_constant`
+ * - `create_not`
+ *
+ * **Required network functions for the subnetwork SubNtk:**
+ * - `num_pis`
+ * - `foreach_pi`
+ * - `foreach_po`
+ * - `foreach_gate`
+ * - `foreach_fanin`
+ * - `get_node`
+ * - `is_complemented`
+ *
+ * \param ntk The host logic network
+ * \param begin Begin iterator of signal inputs in the host network
+ * \param end End iterator of signal inputs in the host network
+ * \param subntk The sub-network
+ * \param fn Callback function
+ */
+template<typename Ntk, typename SubNtk, typename BeginIter, typename EndIter, typename Fn>
+void insert_ntk( Ntk& ntk, BeginIter begin, EndIter end, SubNtk const& subntk, Fn&& fn )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+  static_assert( has_create_not_v<Ntk>, "Ntk does not implement the create_not method" );
+
+  static_assert( is_network_type_v<SubNtk>, "SubNtk is not a network type" );
+  static_assert( has_num_pis_v<SubNtk>, "SubNtk does not implement the num_pis method" );
+  static_assert( has_foreach_pi_v<SubNtk>, "SubNtk does not implement the foreach_pi method" );
+  static_assert( has_foreach_po_v<SubNtk>, "SubNtk does not implement the foreach_po method" );
+  static_assert( has_foreach_gate_v<SubNtk>, "SubNtk does not implement the foreach_gate method" );
+  static_assert( has_foreach_fanin_v<SubNtk>, "SubNtk does not implement the foreach_fanin method" );
+  static_assert( has_get_node_v<SubNtk>, "SubNtk does not implement the get_node method" );
+  static_assert( has_is_complemented_v<SubNtk>, "SubNtk does not implement the is_complemented method" );
+
+  static_assert( std::is_same_v<std::decay_t<typename std::iterator_traits<BeginIter>::value_type>, signal<Ntk>>, "BeginIter value_type must be Ntk signal type" );
+  static_assert( std::is_same_v<std::decay_t<typename std::iterator_traits<EndIter>::value_type>, signal<Ntk>>, "EndIter value_type must be Ntk signal type" );
+
+  assert( uint64_t( std::distance( begin, end ) ) == subntk.num_pis() );
+
+  /* map from nodes in subntk to signals in ntk */
+  unordered_node_map<typename Ntk::signal, SubNtk> node_to_signal( subntk );
+
+  /* inputs */
+  auto it = begin;
+  subntk.foreach_pi( [&]( auto const& n ) {
+    node_to_signal[n] = *( it++ );
+  } );
+
+  /* create gates topologically */
+  subntk.foreach_gate( [&]( auto const& n ) {
+    detail::clone_node_topologically( subntk, ntk, node_to_signal, n );
+  } );
+
+  /* outputs */
+  subntk.foreach_po( [&]( auto const& f ) {
+    fn( subntk.is_complemented( f ) ? ntk.create_not( node_to_signal[subntk.get_node( f )] ) : node_to_signal[subntk.get_node( f )] );
+  } );
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/utils/node_map.hpp b/include/mockturtle/utils/node_map.hpp
new file mode 100644
index 0000000..6fb4e12
--- /dev/null
+++ b/include/mockturtle/utils/node_map.hpp
@@ -0,0 +1,555 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file node_map.hpp
+  \brief Map indexed by network nodes
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <cassert>
+#include <memory>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+#include "../traits.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Associative container network nodes
+ *
+ * This container helps to store and access values associated to nodes
+ * in a network.
+ *
+ * Two implementations are provided, one using std::vector and another
+ * using std::unordered_map as internal storage.  The former
+ * implementation can be pre-allocated and provides a fast way to
+ * access the data.  The later implementation offers a way to
+ * associate values to a subset of nodes and to check whether a value
+ * is available.
+ */
+template<class T, class Ntk, class Impl = std::vector<T>>
+class node_map;
+
+/*! \brief Vector node map
+ *
+ * This container is initialized with a network to derive the size
+ * according to the number of nodes.  The container can be accessed
+ * via nodes, or indirectly via signals, from which the corresponding
+ * node is derived.
+ *
+ * The implementation uses a vector as underlying data structure which
+ * is indexed by the node's index.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `get_node`
+ * - `node_to_index`
+ *
+ */
+template<class T, class Ntk>
+class node_map<T, Ntk, std::vector<T>>
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  using container_type = std::vector<T>;
+  using reference = typename container_type::reference;
+  using const_reference = typename container_type::const_reference;
+
+public:
+  /*! \brief Default constructor. */
+  explicit node_map( Ntk const& ntk )
+      : ntk( &ntk ),
+        data( std::make_shared<container_type>( ntk.size() ) )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  }
+
+  /*! \brief Constructor with default value.
+   *
+   * Initializes all values in the container to `init_value`.
+   */
+  node_map( Ntk const& ntk, T const& init_value )
+      : ntk( &ntk ),
+        data( std::make_shared<container_type>( ntk.size(), init_value ) )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  }
+
+  /*! \brief Number of keys stored in the data structure. */
+  auto size() const
+  {
+    return data->size();
+  }
+
+  /*! \brief Deep copy. */
+  node_map<T, Ntk, container_type> copy() const
+  {
+    node_map<T, Ntk, container_type> copy( ntk );
+    *( copy.data ) = *data;
+    return copy;
+  }
+
+  /*! \brief Mutable access to value by node. */
+  reference operator[]( node const& n )
+  {
+    assert( ntk->node_to_index( n ) < data->size() && "index out of bounds" );
+    return ( *data )[ntk->node_to_index( n )];
+  }
+
+  /*! \brief Constant access to value by node. */
+  const_reference operator[]( node const& n ) const
+  {
+    assert( ntk->node_to_index( n ) < data->size() && "index out of bounds" );
+    return ( *data )[ntk->node_to_index( n )];
+  }
+
+  /*! \brief Mutable access to value by signal.
+   *
+   * This method derives the node from the signal.  If the node and signal type
+   * are the same in the network implementation, this method is disabled.
+   */
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  reference operator[]( signal const& f )
+  {
+    assert( ntk->node_to_index( ntk->get_node( f ) ) < data->size() && "index out of bounds" );
+    return ( *data )[ntk->node_to_index( ntk->get_node( f ) )];
+  }
+
+  /*! \brief Constant access to value by signal.
+   *
+   * This method derives the node from the signal.  If the node and signal type
+   * are the same in the network implementation, this method is disabled.
+   */
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  const_reference operator[]( signal const& f ) const
+  {
+    assert( ntk->node_to_index( ntk->get_node( f ) ) < data->size() && "index out of bounds" );
+    return ( *data )[ntk->node_to_index( ntk->get_node( f ) )];
+  }
+
+  /*! \brief Resets the size of the map.
+   *
+   * This function should be called, if the network changed in size.  Then, the
+   * map is cleared, and resized to the current network's size.  All values are
+   * initialized with `init_value`.
+   *
+   * \param init_value Initialization value after resize
+   */
+  void reset( T const& init_value = {} )
+  {
+    data->clear();
+    data->resize( ntk->size(), init_value );
+  }
+
+  /*! \brief Resizes the map.
+   *
+   * This function should be called, if the node_map's size needs to
+   * be changed without clearing its data.
+   *
+   * \param init_value Initialization value after resize
+   */
+  void resize( T const& init_value = {} )
+  {
+    if ( ntk->size() > data->size() )
+    {
+      data->resize( ntk->size(), init_value );
+    }
+  }
+
+private:
+  Ntk const* ntk;
+  std::shared_ptr<container_type> data;
+};
+
+/*! \brief Unordered node map
+ *
+ * This implementation of the container is initialized with a network.
+ * The map entries are constructed on the fly.  The container
+ * can be accessed via ndoes, or indirectly via signals, from which
+ * the corresponding node is derived.
+ *
+ * The implementation uses an std::unordered_map as underlying data
+ * structure which is indexed by the node's index.
+ *
+ * This implementation is aliased as `unordered_node_map`.
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `node_to_index`
+ *
+ */
+template<class T, class Ntk>
+class node_map<T, Ntk, std::unordered_map<typename Ntk::node, T>>
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  using container_type = std::unordered_map<node, T>;
+  using reference = T&;
+  using const_reference = const T&;
+
+public:
+  /*! \brief Default constructor. */
+  explicit node_map( Ntk const& ntk )
+      : ntk( &ntk ),
+        data( std::make_shared<container_type>() )
+  {
+  }
+
+  /*! \brief Number of keys stored in the data structure. */
+  auto size() const
+  {
+    return data->size();
+  }
+
+  /*! \brief Deep copy. */
+  node_map<T, Ntk, container_type> copy() const
+  {
+    node_map<T, Ntk, container_type> copy( ntk );
+    *( copy.data ) = *data;
+    return copy;
+  }
+
+  /*! \brief Check if a key is already defined. */
+  bool has( node const& n ) const
+  {
+    return data->find( ntk->node_to_index( n ) ) != data->end();
+  }
+
+  /*! \brief Check if a key is already defined. */
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  bool has( signal const& f ) const
+  {
+    return data->find( ntk->node_to_index( ntk->get_node( f ) ) ) != data->end();
+  }
+
+  /*! \brief Erase a key (if it exists). */
+  void erase( node const& n )
+  {
+    if ( has( n ) )
+    {
+      data->erase( ntk->node_to_index( n ) );
+    }
+  }
+
+  /*! \brief Erase a key (if it exists). */
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  void erase( signal const& f )
+  {
+    if ( has( ntk->get_node( f ) ) )
+    {
+      data->erase( ntk->node_to_index( ntk->get_node( f ) ) );
+    }
+  }
+
+  /*! \brief Mutable access to value by node. */
+  reference operator[]( node const& n )
+  {
+    return ( *data )[ntk->node_to_index( n )];
+  }
+
+  /*! \brief Constant access to value by node. */
+  const_reference operator[]( node const& n ) const
+  {
+    assert( has( n ) && "index out of bounds" );
+    return ( *data )[ntk->node_to_index( n )];
+  }
+
+  /*! \brief Mutable access to value by signal.
+   *
+   * This method derives the node from the signal.  If the node and signal type
+   * are the same in the network implementation, this method is disabled.
+   */
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  reference operator[]( signal const& f )
+  {
+    return ( *data )[ntk->node_to_index( ntk->get_node( f ) )];
+  }
+
+  /*! \brief Constant access to value by signal.
+   *
+   * This method derives the node from the signal.  If the node and signal type
+   * are the same in the network implementation, this method is disabled.
+   */
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  const_reference operator[]( signal const& f ) const
+  {
+    assert( has( ntk->get_node( f ) ) && "index out of bounds" );
+    return ( *data )[ntk->node_to_index( ntk->get_node( f ) )];
+  }
+
+  /*! \brief Clear all entries of the map.
+   *
+   * All data in the map is cleared.
+   */
+  void reset()
+  {
+    data->clear();
+  }
+
+  void resize()
+  {
+  }
+
+protected:
+  Ntk const* ntk;
+  std::shared_ptr<container_type> data;
+};
+
+/*! \brief Template alias `unordered_node_map` */
+template<class T, class Ntk>
+using unordered_node_map = node_map<T, Ntk, std::unordered_map<typename Ntk::node, T>>;
+
+/*! \brief Vector-based node map with validity query
+ *
+ * This container is initialized with a network to derive the size
+ * according to the number of nodes.  The container can be accessed
+ * via nodes, or indirectly via signals, from which the corresponding
+ * node is derived.
+ *
+ * The implementation uses a vector as underlying data structure, so
+ * that it benefits from fast access. It is supplemented with an
+ * additional validity field such that it can be used like an
+ * `unordered_node_map`.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `get_node`
+ * - `node_to_index`
+ *
+ */
+template<class T, class Ntk>
+class incomplete_node_map
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  using container_type = std::vector<std::variant<std::monostate, T>>;
+
+public:
+  /*! \brief Default constructor. */
+  explicit incomplete_node_map( Ntk const& ntk )
+      : ntk( &ntk ),
+        data( std::make_shared<container_type>( ntk.size() ) )
+  {
+    static_assert( !std::is_same_v<T, std::monostate>, "T cannot be std::monostate" );
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  }
+
+  /*! \brief Constructor with default value.
+   *
+   * Initializes all values in the container to `init_value`.
+   */
+  incomplete_node_map( Ntk const& ntk, T const& init_value )
+      : ntk( &ntk ),
+        data( std::make_shared<container_type>( ntk.size(), init_value ) )
+  {
+    static_assert( !std::is_same_v<T, std::monostate>, "T cannot be std::monostate" );
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  }
+
+  /*! \brief Number of keys stored in the data structure. */
+  auto size() const
+  {
+    return data->size();
+  }
+
+  /*! \brief Check if a key is already defined. */
+  bool has( node const& n ) const
+  {
+    return std::holds_alternative<T>( ( *data )[ntk->node_to_index( n )] );
+  }
+
+  /*! \brief Check if a key is already defined. */
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  bool has( signal const& f ) const
+  {
+    return std::holds_alternative<T>( ( *data )[ntk->node_to_index( ntk->get_node( f ) )] );
+  }
+
+  /*! \brief Erase a key (if it exists). */
+  void erase( node const& n )
+  {
+    ( *data )[ntk->node_to_index( n )] = std::monostate();
+  }
+
+  /*! \brief Erase a key (if it exists). */
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  void erase( signal const& f )
+  {
+    ( *data )[ntk->node_to_index( ntk->get_node( f ) )] = std::monostate();
+  }
+
+  /*! \brief Mutable access to value by node. */
+  T& operator[]( node const& n )
+  {
+    assert( ntk->node_to_index( n ) < data->size() && "index out of bounds" );
+    if ( !has( n ) )
+    {
+      ( *data )[ntk->node_to_index( n )] = T();
+    }
+    return std::get<T>( ( *data )[ntk->node_to_index( n )] );
+  }
+
+  /*! \brief Constant access to value by node. */
+  T const& operator[]( node const& n ) const
+  {
+    assert( ntk->node_to_index( n ) < data->size() && "index out of bounds" );
+    assert( has( n ) );
+    return std::get<T>( ( *data )[ntk->node_to_index( n )] );
+  }
+
+  /*! \brief Mutable access to value by signal.
+   *
+   * This method derives the node from the signal.  If the node and signal type
+   * are the same in the network implementation, this method is disabled.
+   */
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  T& operator[]( signal const& f )
+  {
+    auto n = ntk->get_node( f );
+    assert( ntk->node_to_index( n ) < data->size() && "index out of bounds" );
+    if ( !has( n ) )
+    {
+      ( *data )[ntk->node_to_index( n )] = T();
+    }
+    return std::get<T>( ( *data )[ntk->node_to_index( n )] );
+  }
+
+  /*! \brief Constant access to value by signal.
+   *
+   * This method derives the node from the signal.  If the node and signal type
+   * are the same in the network implementation, this method is disabled.
+   */
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  T const& operator[]( signal const& f ) const
+  {
+    assert( ntk->node_to_index( ntk->get_node( f ) ) < data->size() && "index out of bounds" );
+    assert( has( ntk->get_node( f ) ) );
+    return std::get<T>( ( *data )[ntk->node_to_index( ntk->get_node( f ) )] );
+  }
+
+  /*! \brief Resets the size of the map.
+   *
+   * This function should be called, if the network changed in size.  Then, the
+   * map is cleared, and resized to the current network's size.  All values are
+   * initialized with the place holder (empty) element.
+   */
+  void reset()
+  {
+    data->clear();
+    data->resize( ntk->size() );
+  }
+
+  /*! \brief Resets the size of the map.
+   *
+   * This function should be called, if the network changed in size.  Then, the
+   * map is cleared, and resized to the current network's size.  All values are
+   * initialized with `init_value`.
+   *
+   * \param init_value Initialization value after resize
+   */
+  void reset( T const& init_value )
+  {
+    data->clear();
+    data->resize( ntk->size(), init_value );
+  }
+
+  /*! \brief Resizes the map.
+   *
+   * This function should be called, if the node_map's size needs to
+   * be changed without clearing its data.
+   */
+  void resize()
+  {
+    if ( ntk->size() > data->size() )
+    {
+      data->resize( ntk->size() );
+    }
+  }
+
+private:
+  Ntk const* ntk;
+  std::shared_ptr<container_type> data;
+};
+
+/*! \brief Initializes a network for copying together with node map.
+ *
+ * This utility function is helpful when creating a network from another one,
+ * a very common task.  It creates the network of type `NtkDest` and already
+ * creates a node map to map nodes from the source network, of type `NtkSrc` to
+ * nodes of the new network.  The function map constant inputs and creates and
+ * maps primary inputs.
+ */
+template<class NtkDest, class NtkSrc>
+std::pair<NtkDest, node_map<signal<NtkDest>, NtkSrc>> initialize_copy_network( NtkSrc const& src )
+{
+  static_assert( is_network_type_v<NtkDest>, "NtkDest is not a network type" );
+  static_assert( is_network_type_v<NtkSrc>, "NtkSrc is not a network type" );
+
+  static_assert( has_get_constant_v<NtkDest>, "NtkDest does not implement the get_constant method" );
+  static_assert( has_create_pi_v<NtkDest>, "NtkDest does not implement the create_pi method" );
+  static_assert( has_get_constant_v<NtkSrc>, "NtkSrc does not implement the get_constant method" );
+  static_assert( has_get_node_v<NtkSrc>, "NtkSrc does not implement the get_node method" );
+  static_assert( has_foreach_pi_v<NtkSrc>, "NtkSrc does not implement the foreach_pi method" );
+
+  node_map<signal<NtkDest>, NtkSrc> old2new( src );
+  NtkDest dest;
+  old2new[src.get_constant( false )] = dest.get_constant( false );
+  if ( src.get_node( src.get_constant( true ) ) != src.get_node( src.get_constant( false ) ) )
+  {
+    old2new[src.get_constant( true )] = dest.get_constant( true );
+  }
+  src.foreach_pi( [&]( auto const& n ) {
+    old2new[n] = dest.create_pi();
+  } );
+  return { dest, old2new };
+}
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/utils/null_utils.hpp b/include/mockturtle/utils/null_utils.hpp
new file mode 100644
index 0000000..e031564
--- /dev/null
+++ b/include/mockturtle/utils/null_utils.hpp
@@ -0,0 +1,46 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file null_utils.hpp
+  \brief Placeholder empty data structures for interfacing purposes
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+namespace mockturtle
+{
+
+struct null_params
+{
+};
+struct null_stats
+{
+  void report() const {}
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/utils/progress_bar.hpp b/include/mockturtle/utils/progress_bar.hpp
new file mode 100644
index 0000000..a36840c
--- /dev/null
+++ b/include/mockturtle/utils/progress_bar.hpp
@@ -0,0 +1,178 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file progress_bar.hpp
+  \brief Progress bar
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <iostream>
+#include <string>
+
+#include <fmt/format.h>
+
+namespace mockturtle
+{
+
+/*! \brief Prints progress bars.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      { // some block
+        progress_bar bar( 100, "|{0}| neg. index = {1}, index squared = {2}" );
+
+        for ( auto i = 0; i < 100; ++i )
+        {
+          bar( i, -i, i * i );
+        }
+      } // progress bar is deleted at exit of this block
+   \endverbatim
+ */
+class progress_bar
+{
+public:
+  /*! \brief Constructor.
+   *
+   * This constructor is used when a the total number of iterations is known,
+   * and the progress should be visually printed.  When using this constructor,
+   * the current iteration must be provided to the `operator()` call.
+   *
+   * \param size Number of iterations (for progress bar)
+   * \param fmt Format strind; used with `fmt::format`, first placeholder `{0}`
+   *            is used for progress bar, the others for the parameters passed
+   *            to `operator()`
+   * \param enable If true, output is printed, otherwise not
+   * \param os Output stream
+   */
+  progress_bar( uint32_t size, std::string const& fmt, bool enable = true, std::ostream& os = std::cout )
+      : _show_progress( true ),
+        _size( size ),
+        _fmt( fmt ),
+        _enable( enable ),
+        _os( os ) {}
+
+  /*! \brief Constructor.
+   *
+   * This constructor is used when a the total number of iterations is not
+   * known.  In this case, the progress is not visually printed. When using this
+   * constructor, just pass the arguments for the `fmt` string.
+   *
+   * \param fmt Format strind; used with `fmt::format`, parameters are passed
+   *            to `operator()`
+   * \param enable If true, output is printed, otherwise not
+   * \param os Output stream
+   */
+  progress_bar( std::string const& fmt, bool enable = true, std::ostream& os = std::cout )
+      : _show_progress( false ),
+        _fmt( fmt ),
+        _enable( enable ),
+        _os( os ) {}
+
+  /*! \brief Deconstructor
+   *
+   * Will remove the last printed line and restore the cursor.
+   */
+  ~progress_bar()
+  {
+    done();
+  }
+
+  /*! \brief Prints and updates the progress bar status.
+   *
+   * This updates the progress and re-prints the progress line.  The previous
+   * print of the line is removed.  If the progress bar has a progress segment
+   * the first argument must be an integer indicating the current progress
+   * with respect to the `size` parameter passed to the constructor.
+   *
+   * \param first Progress position or first argument
+   * \param args Vardiadic argument pack with values for format string
+   */
+  template<typename First, typename... Args>
+  void operator()( First first, Args... args )
+  {
+    if ( _show_progress )
+    {
+      show_with_progress( first, args... );
+    }
+    else
+    {
+      show_without_progress( first, args... );
+    }
+  }
+
+  /*! \brief Removes the progress bar.
+   *
+   * This method is automatically invoked when the progress bar is deleted.  In
+   * some cases, one may wish to invoke this method manually.
+   */
+  void done()
+  {
+    if ( _enable )
+    {
+      _os << "\u001B[G" << std::string( 79, ' ' ) << "\u001B[G\u001B[?25h" << std::flush;
+    }
+  }
+
+private:
+  template<typename... Args>
+  void show_with_progress( uint32_t pos, Args... args )
+  {
+    if ( !_enable )
+      return;
+
+    int spidx = static_cast<int>( ( 6.0 * pos ) / _size );
+    _os << "\u001B[G" << fmt::format( _fmt, spinner.substr( spidx * 5, 5 ), args... ) << std::flush;
+  }
+
+  template<typename... Args>
+  void show_without_progress( Args... args )
+  {
+    if ( !_enable )
+      return;
+
+    _os << "\u001B[G" << fmt::format( _fmt, args... ) << std::flush;
+  }
+
+private:
+  bool _show_progress;
+  uint32_t _size;
+  std::string _fmt;
+  bool _enable;
+  std::ostream& _os;
+
+  std::string spinner{ "     .    ..   ...  .... ....." };
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/utils/recursive_cost_functions.hpp b/include/mockturtle/utils/recursive_cost_functions.hpp
new file mode 100644
index 0000000..1792cd1
--- /dev/null
+++ b/include/mockturtle/utils/recursive_cost_functions.hpp
@@ -0,0 +1,122 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file recursive_cost_functions.hpp
+  \brief Various recursive cost functions for (optimization) algorithms
+
+  \author Hanyu Wang
+*/
+
+#pragma once
+
+#include <cstdint>
+
+#include "../traits.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief (Recursive) customizable cost function
+ *
+ * To define a new cost function, you need to first specify how each node
+ * contributes to the total cost via the *contribution function*. Each node
+ * is evaluated individually and independently.
+ *
+ * If additional (global) information is required to decide a node's contribution,
+ * you may specify them as *context*. The content stored in the context can be
+ * arbitrarily defined (`context_t`), but the derivation must be recursive. In
+ * other words, the context of a node is derived using *context propagation function*
+ * which takes only the context of fanins as input.
+ *
+ * Examples of recursive cost functions can be found at:
+ * `mockturtle/utils/recursive_cost_functions.hpp`
+ */
+template<class Ntk>
+struct recursive_cost_functions
+{
+  using base_type = recursive_cost_functions;
+  using context_t = uint32_t;
+  /*! \brief Context propagation function
+   *
+   * Return the context of a node given fanin contexts.
+   */
+  virtual context_t operator()( Ntk const& ntk, node<Ntk> const& n, std::vector<context_t> const& fanin_contexts = {} ) const = 0;
+
+  /*! \brief Contribution function
+   *
+   * Update the total cost using node n and its context.
+   */
+  virtual void operator()( Ntk const& ntk, node<Ntk> const& n, uint32_t& total_cost, context_t const context ) const = 0;
+};
+
+template<class Ntk>
+struct xag_depth_cost_function : recursive_cost_functions<Ntk>
+{
+public:
+  using context_t = uint32_t;
+  context_t operator()( Ntk const& ntk, node<Ntk> const& n, std::vector<context_t> const& fanin_contexts = {} ) const
+  {
+    uint32_t _cost = ntk.is_pi( n ) ? 0 : *std::max_element( std::begin( fanin_contexts ), std::end( fanin_contexts ) ) + 1;
+    return _cost;
+  }
+  void operator()( Ntk const& ntk, node<Ntk> const& n, uint32_t& total_cost, context_t const context ) const
+  {
+    total_cost = std::max( total_cost, context );
+  }
+};
+
+template<class Ntk>
+struct t_xag_depth_cost_function : recursive_cost_functions<Ntk>
+{
+public:
+  using context_t = uint32_t;
+  context_t operator()( Ntk const& ntk, node<Ntk> const& n, std::vector<context_t> const& fanin_contexts = {} ) const
+  {
+    uint32_t _cost = ntk.is_pi( n ) ? 0 : *std::max_element( std::begin( fanin_contexts ), std::end( fanin_contexts ) ) + ntk.is_and( n );
+    return _cost;
+  }
+  void operator()( Ntk const& ntk, node<Ntk> const& n, uint32_t& total_cost, context_t const context ) const
+  {
+    total_cost = std::max( total_cost, context );
+  }
+};
+
+template<class Ntk>
+struct xag_size_cost_function : recursive_cost_functions<Ntk>
+{
+public:
+  using context_t = uint32_t;
+  context_t operator()( Ntk const& ntk, node<Ntk> const& n, std::vector<uint32_t> const& fanin_contexts = {} ) const
+  {
+    return 0;
+  }
+  void operator()( Ntk const& ntk, node<Ntk> const& n, uint32_t& total_cost, context_t const context ) const
+  {
+    total_cost += ( !ntk.is_pi( n ) && ntk.visited( n ) != ntk.trav_id() ) ? 1 : 0;
+  }
+};
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/utils/sop_utils.hpp b/include/mockturtle/utils/sop_utils.hpp
new file mode 100644
index 0000000..4c2432c
--- /dev/null
+++ b/include/mockturtle/utils/sop_utils.hpp
@@ -0,0 +1,594 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file sop_utils.hpp
+  \brief Utilities for sum-of-products
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <cassert>
+#include <cstdint>
+#include <vector>
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+inline bool cube_has_lit( uint64_t const cube, uint64_t const lit )
+{
+  return ( cube & ( static_cast<uint64_t>( 1 ) << lit ) ) > 0;
+}
+
+inline uint32_t cube_count_literals( uint64_t cube )
+{
+  uint32_t count;
+  for ( count = 0; cube; ++count )
+  {
+    cube &= cube - 1u;
+  };
+  return count;
+}
+
+inline int64_t sop_literals_occurrences( std::vector<uint64_t> const& sop, uint32_t const num_lit )
+{
+  /* find the first literal which occurs more than once */
+  for ( uint64_t lit = 0; lit < num_lit; ++lit )
+  {
+    unsigned occurrences = 0;
+    for ( auto const& cube : sop )
+    {
+      if ( cube_has_lit( cube, lit ) )
+        ++occurrences;
+
+      if ( occurrences > 1 )
+        return lit;
+    }
+  }
+
+  /* each literal appears once */
+  return -1;
+}
+
+inline int64_t sop_least_occurrent_literal( std::vector<uint64_t> const& sop, uint32_t const num_lit )
+{
+  int64_t min_lit = -1;
+  uint32_t min_occurrences = UINT32_MAX;
+
+  /* find the first literal which occurs more than once */
+  for ( uint64_t lit = 0; lit < num_lit; ++lit )
+  {
+    uint32_t occurrences = 0;
+    for ( auto const& cube : sop )
+    {
+      if ( cube_has_lit( cube, lit ) )
+        ++occurrences;
+    }
+
+    if ( occurrences > 1 && occurrences < min_occurrences )
+    {
+      min_lit = static_cast<int64_t>( lit );
+      min_occurrences = occurrences;
+    }
+  }
+
+  return min_lit;
+}
+
+inline int64_t sop_most_occurrent_literal_masked( std::vector<uint64_t> const& sop, uint64_t const cube, uint32_t const num_lit )
+{
+  int64_t max_lit = -1;
+  uint32_t max_occurrences = 1;
+
+  for ( uint64_t lit = 0; lit < num_lit; ++lit )
+  {
+    if ( !cube_has_lit( cube, lit ) )
+      continue;
+
+    uint32_t occurrences = 0;
+    for ( auto const& c : sop )
+    {
+      if ( cube_has_lit( c, lit ) )
+        ++occurrences;
+    }
+
+    if ( occurrences > max_occurrences )
+    {
+      max_lit = static_cast<int64_t>( lit );
+      max_occurrences = occurrences;
+    }
+  }
+
+  return max_lit;
+}
+
+inline bool sop_maximal_cube_literal( std::vector<uint64_t> const& sop, uint64_t& cube, uint32_t const lit )
+{
+  uint64_t max_cube = UINT64_MAX;
+  uint32_t occurrences = 0;
+
+  for ( auto const& c : sop )
+  {
+    if ( cube_has_lit( c, lit ) )
+    {
+      ++occurrences;
+      max_cube &= c;
+    }
+  }
+
+  cube = max_cube;
+  return occurrences > 1;
+}
+
+inline void sop_best_literal( std::vector<uint64_t> const& sop, std::vector<uint64_t>& result, uint64_t const cube, uint32_t const num_lit )
+{
+  int64_t max_lit = sop_most_occurrent_literal_masked( sop, cube, num_lit );
+  assert( max_lit >= 0 );
+
+  result.push_back( static_cast<uint64_t>( 1 ) << max_lit );
+}
+
+} // namespace detail
+
+inline uint32_t sop_count_literals( std::vector<uint64_t> const& sop )
+{
+  uint32_t lit_count = 0;
+
+  for ( auto const& c : sop )
+  {
+    lit_count += detail::cube_count_literals( c );
+  }
+
+  return lit_count;
+}
+
+/*! \brief Makes a SOP cube free
+ *
+ * This method checks for a common cube divisor in
+ * the SOP. If found, the SOP is divided by that cube.
+ *
+ * \param sop
+ */
+inline void sop_make_cube_free( std::vector<uint64_t>& sop )
+{
+  /* find common cube */
+  uint64_t mask = UINT64_MAX;
+  for ( auto const& c : sop )
+  {
+    mask &= c;
+  }
+
+  if ( mask == 0 )
+    return;
+
+  /* make cube free */
+  for ( auto& c : sop )
+  {
+    c &= ~mask;
+  }
+}
+
+/*! \brief Checks if a SOP is cube free
+ *
+ * This method checks for a common cube divisor in
+ * the SOP.
+ *
+ * \param sop
+ */
+inline bool sop_is_cube_free( std::vector<uint64_t> const& sop )
+{
+  /* find common cube */
+  uint64_t mask = UINT64_MAX;
+  for ( auto const& c : sop )
+  {
+    mask &= c;
+  }
+
+  return mask == 0;
+}
+
+/*! \brief Algebraic division by literal
+ *
+ * This method divides a SOP inplace by a literal and
+ * stores the resulting quotient in the original SOP.
+ *
+ * \param sop
+ * \param lit
+ */
+inline void sop_divide_by_literal_inplace( std::vector<uint64_t>& sop, uint64_t const lit )
+{
+  uint32_t p = 0;
+  for ( auto i = 0; i < sop.size(); ++i )
+  {
+    if ( detail::cube_has_lit( sop[i], lit ) )
+    {
+      sop[p++] = sop[i] & ( ~( static_cast<uint64_t>( 1 ) << lit ) );
+    }
+  }
+
+  sop.resize( p );
+}
+
+/*! \brief Algebraic division by a cube
+ *
+ * This method divides a SOP (divident) by the divisor
+ * and stores the resulting quotient and reminder.
+ *
+ * \param Divident
+ * \param Divisor
+ * \param Quotient
+ * \param Reminder
+ */
+inline void sop_divide_by_cube( std::vector<uint64_t> const& divident, std::vector<uint64_t> const& divisor, std::vector<uint64_t>& quotient, std::vector<uint64_t>& reminder )
+{
+  assert( divisor.size() == 1 );
+
+  quotient.clear();
+  reminder.clear();
+
+  uint32_t p = 0;
+  for ( auto const& c : divident )
+  {
+    if ( ( c & divisor[0] ) == divisor[0] )
+    {
+      quotient.push_back( c & ( ~divisor[0] ) );
+    }
+    else
+    {
+      reminder.push_back( c );
+    }
+  }
+}
+
+/*! \brief Algebraic division by a cube
+ *
+ * This method divides a SOP (divident) by the divisor
+ * and stores the resulting quotient.
+ *
+ * \param Divident
+ * \param Divisor
+ * \param Quotient
+ */
+inline void sop_divide_by_cube_no_reminder( std::vector<uint64_t> const& divident, uint64_t const& divisor, std::vector<uint64_t>& quotient )
+{
+  quotient.clear();
+
+  uint32_t p = 0;
+  for ( auto const& c : divident )
+  {
+    if ( ( c & divisor ) == divisor )
+    {
+      quotient.push_back( c & ~divisor );
+    }
+  }
+}
+
+/*! \brief Algebraic division
+ *
+ * This method divides a SOP (divident) by the divisor
+ * and stores the resulting quotient and reminder.
+ *
+ * \param Divident
+ * \param Divisor
+ * \param Quotient
+ * \param Reminder
+ */
+inline void sop_divide( std::vector<uint64_t>& divident, std::vector<uint64_t> const& divisor, std::vector<uint64_t>& quotient, std::vector<uint64_t>& reminder )
+{
+  /* divisor contains a single cube */
+  if ( divisor.size() == 1 )
+  {
+    sop_divide_by_cube( divident, divisor, quotient, reminder );
+    return;
+  }
+
+  quotient.clear();
+  reminder.clear();
+
+  /* perform division */
+  for ( auto i = 0; i < divident.size(); ++i )
+  {
+    auto const c = divident[i];
+
+    /* cube has been already covered */
+    if ( detail::cube_has_lit( c, 63 ) )
+      continue;
+
+    uint32_t div_i;
+    for ( div_i = 0u; div_i < divisor.size(); ++div_i )
+    {
+      if ( ( c & divisor[div_i] ) == divisor[div_i] )
+        break;
+    }
+
+    /* cube is not divisible -> reminder */
+    if ( div_i >= divisor.size() )
+      continue;
+
+    /* extract quotient */
+    uint64_t c_quotient = c & ~divisor[div_i];
+
+    /* find if c_quotient can be obtained for all the divisors */
+    bool found = true;
+    for ( auto const& div : divisor )
+    {
+      if ( div == divisor[div_i] )
+        continue;
+
+      found = false;
+      for ( auto const& c2 : divident )
+      {
+        /* cube has been already covered */
+        if ( detail::cube_has_lit( c2, 63 ) )
+          continue;
+
+        if ( ( ( c2 & div ) == div ) && ( c_quotient == ( c2 & ~div ) ) )
+        {
+          found = true;
+          break;
+        }
+      }
+
+      if ( !found )
+        break;
+    }
+
+    if ( !found )
+      continue;
+
+    /* valid divisor, select covered cubes */
+    quotient.push_back( c_quotient );
+
+    divident[i] |= static_cast<uint64_t>( 1 ) << 63;
+    for ( auto const& div : divisor )
+    {
+      if ( div == divisor[div_i] )
+        continue;
+
+      for ( auto& c2 : divident )
+      {
+        /* cube has been already covered */
+        if ( detail::cube_has_lit( c2, 63 ) )
+          continue;
+
+        if ( ( ( c2 & div ) == div ) && ( c_quotient == ( c2 & ~div ) ) )
+        {
+          c2 |= static_cast<uint64_t>( 1 ) << 63;
+          break;
+        }
+      }
+    }
+  }
+
+  /* add remainder */
+  for ( auto& c : divident )
+  {
+    if ( !detail::cube_has_lit( c, 63 ) )
+    {
+      reminder.push_back( c );
+    }
+    else
+    {
+      /* unmark */
+      c &= ~( static_cast<uint64_t>( 1 ) << 63 );
+    }
+  }
+}
+
+/*! \brief Extracts all the kernels
+ *
+ * This method is used to identify and collect all
+ * the kernels.
+ *
+ * \param sop
+ * \param kernels
+ * \param j
+ * \param num_lit
+ */
+inline void sop_kernels_rec( std::vector<uint64_t> const& sop, std::vector<std::vector<uint64_t>>& kernels, uint32_t const j, uint32_t const num_lit )
+{
+  std::vector<uint64_t> kernel;
+
+  for ( uint32_t i = j; i < num_lit; ++i )
+  {
+    uint64_t c;
+    if ( detail::sop_maximal_cube_literal( sop, c, i ) )
+    {
+      /* cube has been visited already */
+      if ( ( c & ( ( static_cast<uint64_t>( 1 ) << i ) - 1 ) ) > 0u )
+        continue;
+
+      sop_divide_by_cube_no_reminder( sop, c, kernel );
+      sop_kernels_rec( kernel, kernels, i + 1, num_lit );
+    }
+  }
+
+  kernels.push_back( sop );
+}
+
+/*! \brief Extracts the best factorizing kernel
+ *
+ * This method is used to identify the best kernel
+ * according to the algebraic factorization value.
+ *
+ * \param sop
+ * \param kernel
+ * \param best_kernel
+ * \param j
+ * \param best_cost
+ * \param num_lit
+ */
+inline uint32_t sop_best_kernel_rec( std::vector<uint64_t>& sop, std::vector<uint64_t>& kernel, std::vector<uint64_t>& best_kernel, uint32_t const j, uint32_t& best_cost, uint32_t const num_lit )
+{
+  std::vector<uint64_t> new_kernel;
+  std::vector<uint64_t> quotient;
+  std::vector<uint64_t> reminder;
+
+  /* evaluate kernel */
+  sop_divide( sop, kernel, quotient, reminder );
+  uint32_t division_cost = sop_count_literals( quotient ) + sop_count_literals( reminder );
+  uint32_t best_fact_cost = sop_count_literals( kernel );
+
+  for ( uint32_t i = j; i < num_lit; ++i )
+  {
+    uint64_t c;
+    if ( detail::sop_maximal_cube_literal( kernel, c, i ) )
+    {
+      /* cube has been already visited */
+      if ( ( c & ( ( static_cast<uint64_t>( 1 ) << i ) - 1 ) ) > 0u )
+        continue;
+
+      /* extract the new kernel */
+      sop_divide_by_cube( kernel, { c }, new_kernel, reminder );
+      uint32_t fact_cost_rec = detail::cube_count_literals( c ) + sop_count_literals( reminder );
+      uint32_t fact_cost = sop_best_kernel_rec( sop, new_kernel, best_kernel, i + 1, best_cost, num_lit );
+
+      /* compute the factorization value for kernel */
+      if ( ( fact_cost + fact_cost_rec ) < best_fact_cost )
+        best_fact_cost = fact_cost + fact_cost_rec;
+    }
+  }
+
+  if ( best_kernel.empty() || ( division_cost + best_fact_cost ) < best_cost )
+  {
+    best_kernel = kernel;
+    best_cost = division_cost + best_fact_cost;
+  }
+
+  return best_fact_cost;
+}
+
+/*! \brief Extracts a one level-0 kernel
+ *
+ * This method is used to identify and return a one
+ * level-0 kernel.
+ *
+ * \param sop
+ * \param num_lit
+ */
+inline void sop_one_level_zero_kernel_rec( std::vector<uint64_t>& sop, uint32_t const num_lit )
+{
+  /* find least occurring leteral which occurs more than once. TODO: test other metrics */
+  int64_t min_lit = detail::sop_least_occurrent_literal( sop, num_lit );
+
+  if ( min_lit == -1 )
+    return;
+
+  sop_divide_by_literal_inplace( sop, static_cast<uint64_t>( min_lit ) );
+  sop_make_cube_free( sop );
+
+  sop_one_level_zero_kernel_rec( sop, num_lit );
+}
+
+/*! \brief Finds a quick divisor for a SOP
+ *
+ * This method is used to identify and return a quick
+ * divisor for the SOP.
+ *
+ * \param sop
+ * \param num_lit
+ */
+inline bool sop_quick_divisor( std::vector<uint64_t> const& sop, std::vector<uint64_t>& res, uint32_t const num_lit )
+{
+  if ( sop.size() <= 1 )
+    return false;
+
+  /* each literal appears no more than once */
+  if ( detail::sop_literals_occurrences( sop, num_lit ) < 0 )
+    return false;
+
+  /* one level 0-kernel */
+  res = sop;
+  sop_one_level_zero_kernel_rec( res, num_lit );
+
+  assert( res.size() );
+  return true;
+}
+
+/*! \brief Finds a good divisor for a SOP
+ *
+ * This method is used to identify and return a good
+ * divisor for the SOP.
+ *
+ * \param sop
+ * \param num_lit
+ */
+inline bool sop_good_divisor( std::vector<uint64_t>& sop, std::vector<uint64_t>& res, uint32_t const num_lit )
+{
+  if ( sop.size() <= 1 )
+    return false;
+
+  /* each literal appears no more than once */
+  if ( detail::sop_literals_occurrences( sop, num_lit ) < 0 )
+    return false;
+
+  std::vector<uint64_t> kernel = sop;
+
+  /* compute all the kernels and return the one with the best factorization value */
+  uint32_t best_cost = 0;
+  sop_best_kernel_rec( sop, kernel, res, 0, best_cost, num_lit );
+
+  return true;
+}
+
+/*! \brief Translates cubes into products
+ *
+ * This method translate SOP of kitty::cubes (bits + mask)
+ * into SOP of products represented by literals.
+ * Example for: ab'c*
+ *   - cube: _bits = 1010; _mask = 1110
+ *   - product: 10011000
+ *
+ * \param cubes Sum-of-products described using cubes
+ * \param num_vars Number of variables
+ */
+inline std::vector<uint64_t> cubes_to_sop( std::vector<kitty::cube> const& cubes, uint32_t const num_vars )
+{
+  using sop_t = std::vector<uint64_t>;
+
+  sop_t sop( cubes.size() );
+
+  /* Represent literals instead of variables as a a' b b' */
+  /* Bit 63 is reserved, up to 31 varibles support */
+  auto it = sop.begin();
+  for ( auto const& c : cubes )
+  {
+    uint64_t& product = *it++;
+    for ( auto i = 0; i < num_vars; ++i )
+    {
+      if ( c.get_mask( i ) )
+        product |= static_cast<uint64_t>( 1 ) << ( 2 * i + static_cast<unsigned>( c.get_bit( i ) ) );
+    }
+  }
+
+  return sop;
+}
+
+} // namespace mockturtle
diff --git a/include/mockturtle/utils/standard_cell.hpp b/include/mockturtle/utils/standard_cell.hpp
new file mode 100644
index 0000000..917550d
--- /dev/null
+++ b/include/mockturtle/utils/standard_cell.hpp
@@ -0,0 +1,98 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file standard_cell.hpp
+  \brief Defines logic cells.
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <unordered_map>
+#include <vector>
+
+#include "../io/genlib_reader.hpp"
+
+namespace mockturtle
+{
+
+struct standard_cell
+{
+  /* Unique name */
+  std::string name;
+
+  /* Unique ID */
+  uint32_t id;
+
+  /* Pointer to a gate representing each individual output */
+  std::vector<gate> gates;
+
+  /* Area */
+  double area;
+};
+
+/*! \brief Reconstruct standard cells from GENLIB gates.
+ *
+ * This function returns a vector of standard cells given
+ * GENLIB gates.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      std::vector<gate> gates;
+      lorina::read_genlib( in, genlib_reader( gates ) );
+
+      // Extract standard cells
+      std::vector<standard_cell> cells = get_standard_cells( gates );
+   \endverbatim
+ */
+inline std::vector<standard_cell> get_standard_cells( std::vector<gate> const& gates )
+{
+  std::unordered_map<std::string, uint32_t> name_to_index;
+  std::vector<standard_cell> cells;
+
+  for ( gate const& g : gates )
+  {
+    if ( auto it = name_to_index.find( g.name ); it != name_to_index.end() )
+    {
+      /* add to existing cell (multi-output) */
+      cells[it->second].gates.push_back( g );
+    }
+    else
+    {
+      name_to_index[g.name] = cells.size();
+      cells.emplace_back( standard_cell{ g.name, static_cast<uint32_t>( cells.size() ), { g }, g.area } );
+    }
+  }
+
+  return cells;
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/utils/stopwatch.hpp b/include/mockturtle/utils/stopwatch.hpp
new file mode 100644
index 0000000..5f1daac
--- /dev/null
+++ b/include/mockturtle/utils/stopwatch.hpp
@@ -0,0 +1,180 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file stopwatch.hpp
+  \brief Stopwatch
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <chrono>
+#include <iostream>
+#include <type_traits>
+
+#include <fmt/format.h>
+
+namespace mockturtle
+{
+
+/*! \brief Stopwatch interface
+ *
+ * This class implements a stopwatch interface to track time.  It starts
+ * tracking time at construction and stops tracking time at deletion
+ * automatically.  A reference to a duration object is passed to the
+ * constructor.  After stopping the time the measured time interval is added
+ * to the durationr reference.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      stopwatch<>::duration time{0};
+
+      { // some block
+        stopwatch t( time );
+
+        // do some work
+      } // stopwatch is stopped here
+
+      std::cout << fmt::format( "{:5.2f} seconds passed\n", to_seconds( time ) );
+   \endverbatim
+ */
+template<class Clock = std::chrono::steady_clock>
+class stopwatch
+{
+public:
+  using clock = Clock;
+  using duration = typename Clock::duration;
+  using time_point = typename Clock::time_point;
+
+  /*! \brief Default constructor.
+   *
+   * Starts tracking time.
+   */
+  explicit stopwatch( duration& dur )
+      : dur( dur ),
+        beg( clock::now() )
+  {
+  }
+
+  /*! \brief Default deconstructor.
+   *
+   * Stops tracking time and updates duration.
+   */
+  ~stopwatch()
+  {
+    dur += ( clock::now() - beg );
+  }
+
+private:
+  duration& dur;
+  time_point beg;
+};
+
+/*! \brief Calls a function and tracks time.
+ *
+ * The function that is passed as second parameter can be any callable object
+ * that takes no parameters.  This construction can be used to avoid
+ * pre-declaring the result type of a computation that should be tracked.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      stopwatch<>::duration time{0};
+
+      auto result = call_with_stopwatch( time, [&]() { return function( parameters ); } );
+   \endverbatim
+ *
+ * \param dur Duration reference (time will be added to it)
+ * \param fn Callable object with no arguments
+ */
+template<class Fn, class Clock = std::chrono::steady_clock>
+std::invoke_result_t<Fn> call_with_stopwatch( typename Clock::duration& dur, Fn&& fn )
+{
+  stopwatch<Clock> t( dur );
+  return fn();
+}
+
+/*! \brief Constructs an object and calls time.
+ *
+ * This function can track the time for the construction of an object and
+ * returns the constructed object.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      stopwatch<>::duration time{0};
+
+      // create vector with 100000 elements initialized to 42
+      auto result = make_with_stopwatch<std::vector<int>>( time, 100000, 42 );
+   \endverbatim
+ */
+template<class T, class... Args, class Clock = std::chrono::steady_clock>
+T make_with_stopwatch( typename Clock::duration& dur, Args... args )
+{
+  stopwatch<Clock> t( dur );
+  return T{ std::forward<Args>( args )... };
+}
+
+/*! \brief Utility function to convert duration into seconds. */
+template<class Duration>
+inline double to_seconds( Duration const& dur )
+{
+  return std::chrono::duration_cast<std::chrono::duration<double>>( dur ).count();
+}
+
+template<class Clock = std::chrono::steady_clock>
+class print_time
+{
+public:
+  print_time()
+      : _t( new stopwatch<Clock>( _d ) )
+  {
+  }
+
+  ~print_time()
+  {
+    delete _t;
+    std::cout << fmt::format( "[i] run-time: {:5.2f} secs\n", to_seconds( _d ) );
+  }
+
+private:
+  stopwatch<Clock>* _t{ nullptr };
+  typename stopwatch<Clock>::duration _d{};
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/utils/string_utils.hpp b/include/mockturtle/utils/string_utils.hpp
new file mode 100644
index 0000000..af7101e
--- /dev/null
+++ b/include/mockturtle/utils/string_utils.hpp
@@ -0,0 +1,63 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file string_utils.hpp
+  \brief String utils
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <numeric>
+#include <string>
+#include <type_traits>
+
+namespace mockturtle
+{
+
+template<class Iterator, class MapFn, class JoinFn>
+std::invoke_result_t<MapFn, typename Iterator::value_type> map_and_join( Iterator begin, Iterator end, MapFn&& map_fn, JoinFn&& join_fn )
+{
+  if constexpr ( std::is_same_v<std::decay_t<JoinFn>, std::string> )
+  {
+    return std::accumulate( begin + 1, end, map_fn( *begin ),
+                            [&]( auto const& a, auto const& v ) {
+                              return a + join_fn + map_fn( v );
+                            } );
+  }
+  else
+  {
+    return std::accumulate( begin + 1, end, map_fn( *begin ),
+                            [&]( auto const& a, auto const& v ) {
+                              return join_fn( a, map_fn( v ) );
+                            } );
+  }
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/utils/struct_library.hpp b/include/mockturtle/utils/struct_library.hpp
new file mode 100644
index 0000000..165e9eb
--- /dev/null
+++ b/include/mockturtle/utils/struct_library.hpp
@@ -0,0 +1,1542 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file struct_library.hpp
+  \brief Implements utilities for structural matching
+
+  \author Alessandro Tempia Calvino
+  \author Gianluca Radi
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cassert>
+#include <numeric>
+#include <tuple>
+#include <unordered_map>
+#include <vector>
+
+#include <kitty/constructors.hpp>
+#include <kitty/decomposition.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/npn.hpp>
+#include <kitty/print.hpp>
+#include <kitty/static_truth_table.hpp>
+
+#include <parallel_hashmap/phmap.h>
+
+#include "../io/genlib_reader.hpp"
+#include "include/supergate.hpp"
+
+namespace mockturtle
+{
+
+struct struct_library_params
+{
+  /*! \brief Load gates with minimum size only */
+  bool load_minimum_size_only{ true };
+
+  /*! \brief Reports loaded gates */
+  bool verbose{ false };
+};
+
+/*! \brief Library of gates for structural matching
+ *
+ * This class creates a technology library from a set
+ * of input gates.
+ *
+ * Gates are processed to derive rules in the AIG format.
+ * Then, every rule and subrule gets a unique id and the AND table is built.
+ * Every gate gets a unique label comprehensive of its rule id and whether it is positive or negative.
+ *
+ * The template parameter `NInputs` selects the maximum number of variables
+ * allowed for a gate in the library.
+ *
+ * By default, `struct_library` is used in `tech_library` when NInputs is greater than 6.
+ *
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      std::vector<gate> gates;
+      lorina::read_genlib( "file.genlib", genlib_reader( gates ) );
+      // struct library
+      mockturtle::struct_library lib( gates );
+   \endverbatim
+ */
+template<unsigned NInputs = 9u>
+class struct_library
+{
+public:
+  enum class node_type
+  {
+    none,
+    zero_,
+    pi_,
+    and_,
+    or_,
+    mux_,
+    xor_
+  };
+
+  struct signal
+  {
+    union
+    {
+      struct
+      {
+        uint32_t inv : 1;
+        uint32_t index : 31;
+      };
+      uint32_t data;
+    };
+
+    bool operator==( signal const& other ) const
+    {
+      return data == other.data;
+    }
+  };
+
+  /*  struct for representing nodes in dsd decomposition */
+  struct dsd_node
+  {
+    node_type type;
+
+    uint32_t index;
+
+    std::vector<signal> fanin = {};
+  };
+
+  /* struct for labels to assign to gates */
+  struct label
+  {
+    union
+    {
+      struct
+      {
+        uint32_t inv : 1;
+        uint32_t index : 31;
+      };
+      uint32_t data;
+    };
+    bool operator==( label const& other ) const
+    {
+      return data == other.data;
+    }
+  };
+
+  struct signal_hash
+  {
+    std::size_t operator()( signal const& s ) const noexcept
+    {
+      return std::hash<uint32_t>{}( s.data );
+    }
+  };
+
+  struct tuple_s_hash
+  {
+    std::size_t operator()( std::tuple<signal, signal> const& t ) const noexcept
+    {
+      size_t h1 = signal_hash()( std::get<0>( t ) );
+      size_t h2 = signal_hash()( std::get<1>( t ) );
+      return (uint64_t)h1 ^ ( ( (uint64_t)h2 ) << 32 ); // or use boost::hash_combine
+    }
+  };
+
+private:
+  static constexpr uint32_t invalid_index = UINT32_MAX;
+  using supergates_list_t = std::vector<supergate<NInputs>>;
+  using composed_list_t = std::vector<composed_gate<NInputs>>;
+  using lib_rule = phmap::flat_hash_map<kitty::dynamic_truth_table, std::vector<dsd_node>, kitty::hash<kitty::dynamic_truth_table>>;
+  using rule = std::vector<dsd_node>;
+  using lib_table = phmap::flat_hash_map<std::tuple<signal, signal>, uint32_t, tuple_s_hash>;
+  using map_label_gate = std::unordered_map<uint32_t, supergates_list_t>;
+
+public:
+  explicit struct_library( std::vector<gate> const& gates, struct_library_params const& ps = {} )
+      : _gates( gates ),
+        _ps( ps ),
+        _supergates(),
+        _dsd_map(),
+        _and_table(),
+        _label_to_gate()
+  {}
+
+public:
+  /*! \brief Construct the structural library.
+   *
+   * Generates the patterns for structural matching.
+   * Variable `min_vars` defines the minimum number of
+   * gate inputs considered for the library creation.
+   * 0 < min_vars < UINT32_MAX
+   */
+  void construct( uint32_t min_vars = 2u )
+  {
+    generate_library( min_vars );
+  }
+
+  /*! \brief Construct the structural library.
+   *
+   * Generates the patterns for structural matching.
+   */
+  const map_label_gate& get_struct_library() const
+  {
+    return _label_to_gate;
+  }
+
+  /*! \brief Get the pattern ID.
+   *
+   *  \param id1 first pattern id.
+   *  \param id2 second pattern id.
+   * Returns a pattern ID if found, UINT32_MAX otherwise given the
+   * children IDs. This function works with only AND operators.
+   */
+  const uint32_t get_pattern_id( uint32_t id1, uint32_t id2 ) const
+  {
+    signal l, r;
+    l.data = id1;
+    /* ignore input negations */
+    if ( l.data == 3 )
+      l.data = 2;
+    r.data = id2;
+    if ( r.data == 3 )
+      r.data = 2;
+    std::tuple<signal, signal> key;
+    if ( l.index <= r.index )
+      key = std::make_tuple( l, r );
+    else
+      key = std::make_tuple( r, l );
+    auto match = _and_table.find( key );
+    if ( match != _and_table.end() )
+      return match->second;
+    return UINT32_MAX;
+  }
+
+  /*! \brief Get the gates matching the pattern ID.
+   *
+   * Returns a list of gates that match the pattern ID.
+   */
+  const supergates_list_t* get_supergates_pattern( uint32_t id, bool phase ) const
+  {
+    auto match = _label_to_gate.find( ( id << 1 ) | ( phase ? 1 : 0 ) );
+    if ( match != _label_to_gate.end() )
+    {
+      return &( match->second );
+    }
+    return nullptr;
+  }
+
+  /*! \brief Returns the number of large gates.
+   *
+   * Number of gates with more than 6 inputs.
+   */
+  const uint32_t get_num_large_gates() const
+  {
+    return num_large_gates;
+  }
+
+  /*! \brief Print and table.
+   *
+   */
+  void print_and_table()
+  {
+    for ( auto elem : _and_table )
+    {
+      auto first0 = std::get<0>( elem.first );
+      auto first1 = std::get<1>( elem.first );
+      std::cout << "<" << ( first0.inv ? "!" : "" ) << first0.index;
+      std::cout << ", " << ( first1.inv ? "!" : "" ) << first1.index << "> ";
+      std::cout << elem.second << "\n";
+    }
+  }
+
+private:
+  void generate_library( uint32_t min_vars )
+  {
+    /* select and load gates */
+    _supergates.reserve( _gates.size() );
+    generate_composed_gates();
+
+    /* mark dominate gates */
+    std::vector<bool> skip_gates( _supergates.size(), false );
+    filter_gates( skip_gates );
+
+    std::vector<uint32_t> indexes( _supergates.size() );
+    std::iota( indexes.begin(), indexes.end(), 0 );
+    uint32_t max_label = 1;
+    uint32_t gate_pol = 0; // polarity of AND equivalent gate
+    uint32_t shift = 0;
+
+    /* sort cells by increasing order of area */
+    std::stable_sort( indexes.begin(), indexes.end(),
+               [&]( auto const& a, auto const& b ) -> bool {
+                 return _supergates[a].area < _supergates[b].area;
+               } );
+
+    for ( uint32_t const ind : indexes )
+    {
+      composed_gate<NInputs> const& gate = _supergates[ind];
+
+      if ( gate.num_vars < 2 || skip_gates[ind] )
+        continue;
+
+      /* DSD decomposition */
+      rule rule = {};
+      std::vector<uint32_t> support = {};
+      for ( uint32_t i = 0; i < gate.num_vars; i++ )
+      {
+        rule.push_back( { node_type::pi_, i, {} } );
+        support.push_back( i );
+      }
+      auto cpy = gate.function;
+      gate_disjoint = false;
+      compute_dsd( cpy, support, rule );
+
+      /* ignore gates with reconvergence */
+      if ( gate_disjoint )
+        continue;
+      
+      if ( gate.num_vars > 6 )
+      {
+        ++num_large_gates;
+      }
+
+      _dsd_map.insert( { gate.function, rule } );
+      if ( _ps.verbose )
+      {
+        std::cout << "Dsd:\n";
+        print_rule( rule, rule[rule.size() - 1] );
+      }
+
+      /* Aig conversion */
+      auto aig_rule = map_to_aig( rule );
+      if ( _ps.verbose )
+      {
+        std::cout << "\nAig:\n";
+        print_rule( aig_rule, aig_rule[aig_rule.size() - 1] );
+      }
+
+      /* Rules derivation */
+      std::vector<std::vector<dsd_node>> der_rules = {};
+      der_rules.push_back( aig_rule );
+      std::vector<std::tuple<uint32_t, uint32_t>> depths = { { get_depth( aig_rule, aig_rule[aig_rule[aig_rule.size() - 1].fanin[0].index] ), get_depth( aig_rule, aig_rule[aig_rule[aig_rule.size() - 1].fanin[1].index] ) } };
+      create_rules_from_dsd( der_rules, aig_rule, aig_rule[aig_rule.size() - 1], depths, true, true );
+      if ( _ps.verbose )
+      {
+        std::cout << "\nDerived:\n";
+      }
+
+      /* Indexing of rules and subrules, and_table construction, and gates' label assignement */
+      for ( auto elem : der_rules )
+      {
+        gate_pol = 0;
+        shift = 0;
+        std::vector<uint8_t> perm( gate.num_vars );
+        auto index_rule = do_indexing_rule( elem, elem[elem.size() - 1], max_label, gate_pol, perm, shift );
+
+        /* skip gate creation for small gates (<`min_vars` inputs) */
+        if ( gate.num_vars < min_vars )
+          continue;
+
+        supergate<NInputs> sg = { &gate,
+                                  static_cast<float>( gate.area ),
+                                  gate.tdelay,
+                                  perm,
+                                  gate_pol };
+
+        /* permute pin-to-pin delays */
+        for ( uint32_t i = 0; i < gate.num_vars; ++i )
+        {
+          sg.tdelay[i] = gate.tdelay[perm[i]];
+        }
+
+        auto& v = _label_to_gate[index_rule.data];
+
+        auto it = std::lower_bound( v.begin(), v.end(), sg, [&]( auto const& s1, auto const& s2 ) {
+          if ( s1.area < s2.area )
+            return true;
+          if ( s1.area > s2.area )
+            return false;
+          if ( s1.root->num_vars < s2.root->num_vars )
+            return true;
+          if ( s1.root->num_vars > s2.root->num_vars )
+            return true;
+          return s1.root->id < s2.root->id;
+        } );
+
+        v.insert( it, sg );
+
+        if ( _ps.verbose )
+        {
+          print_rule( elem, elem[elem.size() - 1] );
+          std::cout << "\n";
+          for ( const std::pair<uint32_t, supergates_list_t>& elem : _label_to_gate )
+          {
+            std::cout << elem.first << "\n";
+            for ( auto sg : elem.second )
+            {
+              std::cout << ( sg.root )->root->expression << "\n";
+            }
+          }
+        }
+      }
+
+      if ( _ps.verbose )
+      {
+        std::cout << "\n";
+        std::cout << "And table:\n";
+        print_and_table();
+        std::cout << "\n";
+      }
+    }
+    if ( _ps.verbose )
+      std::cout << "\n";
+  }
+
+  void generate_composed_gates()
+  {
+    /* filter multi-output gates */
+    std::unordered_map<std::string, uint32_t> multioutput_map;
+    multioutput_map.reserve( _gates.size() );
+
+    for ( const auto& g : _gates )
+    {
+      if ( multioutput_map.find( g.name ) != multioutput_map.end() )
+      {
+        multioutput_map[g.name] += 1;
+      }
+      else
+      {
+        multioutput_map[g.name] = 1;
+      }
+    }
+
+    /* create composed gates */
+    uint32_t ignored = 0;
+    for ( const auto& g : _gates )
+    {
+      std::array<float, NInputs> pin_to_pin_delays{};
+
+      /* filter large gates and multi-output gates */
+      if ( g.function.num_vars() > NInputs || multioutput_map[g.name] > 1 )
+      {
+        ++ignored;
+        continue;
+      }
+
+      auto i = 0u;
+      for ( auto const& pin : g.pins )
+      {
+        /* use worst pin delay */
+        pin_to_pin_delays[i++] = std::max( pin.rise_block_delay, pin.fall_block_delay );
+      }
+
+      _supergates.emplace_back( composed_gate<NInputs>{ static_cast<unsigned int>( _supergates.size() ),
+                                                        false,
+                                                        &g,
+                                                        g.num_vars,
+                                                        g.function,
+                                                        g.area,
+                                                        pin_to_pin_delays,
+                                                        {} } );
+    }
+  }
+
+  bool compare_sizes( composed_gate<NInputs> const& s1, composed_gate<NInputs> const& s2 )
+  {
+    if ( s1.area < s2.area )
+      return true;
+    else if ( s1.area > s2.area )
+      return false;
+
+    /* compute average pin delay */
+    float s1_delay = 0, s2_delay = 0;
+    assert( s1.num_vars == s2.num_vars );
+    for ( uint32_t i = 0; i < s1.num_vars; ++i )
+    {
+      s1_delay += s1.tdelay[i];
+      s2_delay += s2.tdelay[i];
+    }
+
+    if ( s1_delay < s2_delay )
+      return true;
+    else if ( s1_delay > s2_delay )
+      return false;
+    else if ( s1.root->name < s2.root->name )
+      return true;
+
+    return false;
+  }
+
+  void filter_gates( std::vector<bool>& skip_gates )
+  {
+    for ( uint32_t i = 0; i < skip_gates.size() - 1; ++i )
+    {
+      if ( _supergates[i].root == nullptr )
+        continue;
+
+      if ( skip_gates[i] )
+        continue;
+
+      auto const& tti = _supergates[i].function;
+      for ( uint32_t j = i + 1; j < skip_gates.size(); ++j )
+      {
+        auto const& ttj = _supergates[j].function;
+
+        /* get the same functionality */
+        if ( skip_gates[j] || tti != ttj )
+          continue;
+        
+        if ( _ps.load_minimum_size_only )
+        {
+          if ( compare_sizes( _supergates[i], _supergates[j] ) )
+          {
+            skip_gates[j] = true;
+            continue;
+          }
+          else
+          {
+            skip_gates[i] = true;
+            break;
+          }
+        }
+
+        /* is i smaller than j */
+        bool smaller = _supergates[i].area < _supergates[j].area;
+
+        /* is i faster for every pin */
+        bool faster = true;
+        for ( uint32_t k = 0; k < tti.num_vars(); ++k )
+        {
+          if ( _supergates[i].tdelay[k] > _supergates[j].tdelay[k] )
+            faster = false;
+        }
+
+        if ( smaller && faster )
+        {
+          skip_gates[j] = true;
+          continue;
+        }
+
+        /* is j faster for every pin */
+        faster = true;
+        for ( uint32_t k = 0; k < tti.num_vars(); ++k )
+        {
+          if ( _supergates[j].tdelay[k] > _supergates[i].tdelay[k] )
+            faster = false;
+        }
+
+        if ( !smaller && faster )
+        {
+          skip_gates[i] = true;
+          break;
+        }
+      }
+    }
+  }
+
+  uint32_t try_top_dec( kitty::dynamic_truth_table& tt, uint32_t num_vars )
+  {
+    uint32_t i = 0;
+    for ( ; i < num_vars; i++ )
+    {
+      auto res = is_top_dec( tt, i, false );
+      if ( res.type != node_type::none )
+        break;
+    }
+    return i;
+  }
+
+  dsd_node do_top_dec( kitty::dynamic_truth_table& tt, uint32_t index, std::vector<uint32_t> mapped_support )
+  {
+    auto node = is_top_dec( tt, index, false, &tt );
+
+    node.fanin[0].index = mapped_support[index];
+    return node;
+  }
+
+  std::tuple<int, int> try_bottom_dec( kitty::dynamic_truth_table& tt, uint32_t num_vars )
+  {
+    uint32_t i;
+    uint32_t j;
+    dsd_node res;
+    for ( i = 0; i < num_vars; i++ )
+    {
+      for ( j = i + 1; j < num_vars; j++ )
+      {
+        res = is_bottom_dec( tt, i, j );
+        if ( res.type != node_type::none )
+          break;
+      }
+      if ( res.type != node_type::none )
+        break;
+    }
+    std::tuple<int, int> ret = { i, j };
+    return ret;
+  }
+
+  dsd_node do_bottom_dec( kitty::dynamic_truth_table& tt, uint32_t i, uint32_t j, uint32_t new_index, std::vector<uint32_t>& mapped_support )
+  {
+    auto node = is_bottom_dec( tt, i, j, &tt, new_index, false );
+
+    node.fanin[0].index = mapped_support[i];
+    node.fanin[1].index = mapped_support[j];
+
+    mapped_support[i] = node.index;
+    return node;
+  }
+
+  dsd_node do_shannon_dec( kitty::dynamic_truth_table tt, uint32_t index, kitty::dynamic_truth_table& co0, kitty::dynamic_truth_table& co1, std::vector<uint32_t> mapped_support )
+  {
+    auto node = shannon_dec( tt, index, &co0, &co1 );
+    node.fanin[0].index = mapped_support[index];
+    return node;
+  }
+
+  void update_support( std::vector<uint32_t>& v, uint32_t index )
+  {
+    uint32_t i = 0;
+    for ( ; i < v.size() && i < index; i++ )
+      ;
+
+    for ( ; i < v.size() - 1; i++ )
+    {
+      v[i] = v[i + 1];
+    }
+
+    v.pop_back();
+  }
+
+  template<class TT>
+  void min_base_shrink( TT& tt, TT& tt_shr )
+  {
+    kitty::min_base_inplace( tt );
+    kitty::shrink_to_inplace( tt_shr, tt );
+  }
+
+  uint32_t is_PI( kitty::dynamic_truth_table const& rem, uint32_t n_vars )
+  {
+    for ( uint32_t i = 0; i < n_vars; i++ )
+    {
+      auto var = rem.construct();
+      kitty::create_nth_var( var, i );
+      if ( rem == var )
+      {
+        return i;
+      }
+    }
+    return invalid_index;
+  }
+
+  uint32_t is_inv_PI( kitty::dynamic_truth_table const& rem, uint32_t n_vars )
+  {
+    for ( uint32_t i = 0; i < n_vars; i++ )
+    {
+      auto var = rem.construct();
+      kitty::create_nth_var( var, i );
+      if ( rem == ~var )
+      {
+        return i;
+      }
+    }
+    return invalid_index;
+  }
+
+  void update_found_rule( kitty::dynamic_truth_table& tt, std::vector<uint32_t>& mapped_support, std::vector<dsd_node>& rule )
+  {
+    uint32_t count_old = 0;
+    uint32_t count_curr = 0;
+    std::vector<dsd_node> new_rule;
+    auto found_rule = get_rules( tt );
+    std::copy_if( found_rule.begin(), found_rule.end(), std::back_inserter( new_rule ), []( dsd_node n ) {
+      return ( n.type != node_type::pi_ );
+    } );
+    for_each( found_rule.begin(), found_rule.end(), [&]( dsd_node elem ) {
+      if ( elem.type == node_type::pi_ )
+        count_old++;
+    } );
+    for_each( rule.begin(), rule.end(), [&]( dsd_node elem ) {
+      count_curr++;
+    } );
+    /* update index of node */
+    std::transform( new_rule.begin(), new_rule.end(), new_rule.begin(), [&]( dsd_node& n ) -> dsd_node {
+      return { n.type, n.index + count_curr - count_old, n.fanin };
+    } );
+    /* update index of signal of fanins of nodes */
+    std::transform( new_rule.begin(), new_rule.end(), new_rule.begin(), [&]( dsd_node& n ) -> dsd_node {
+      transform( n.fanin.begin(), n.fanin.end(), n.fanin.begin(), [&]( signal s ) -> signal {
+        if ( s.index >= count_old )
+          return { s.inv, s.index + count_curr - count_old };
+        else
+          return { s.inv, mapped_support[s.index] };
+      } );
+      return { n.type, n.index, n.fanin };
+    } );
+    rule.insert( rule.end(), new_rule.begin(), new_rule.end() );
+  }
+
+  /*! \brief Compute DSD decomposition for a boolean function recursively.
+   *
+   *  \param tt dynamic truth table representing the function.
+   *  \param mapped_support vector indicating function's support at every recursive step.
+   *  \param rule DSD decomposition of the function.
+   * Returns index of dsd_node to add to rule.
+   */
+  uint32_t compute_dsd( kitty::dynamic_truth_table& tt, std::vector<uint32_t> mapped_support, std::vector<dsd_node>& rule )
+  {
+    /* Function has been already found */
+    if ( !get_rules( tt ).empty() )
+    {
+      update_found_rule( tt, mapped_support, rule );
+      return rule.size() - 1;
+    }
+    /* try top decomposition */
+    uint32_t i = try_top_dec( tt, tt.num_vars() );
+    if ( i < tt.num_vars() ) // it was top decomposable
+    {
+      auto res = do_top_dec( tt, i, mapped_support );
+
+      update_support( mapped_support, i );
+
+      kitty::dynamic_truth_table tt_shr( tt.num_vars() - 1 );
+      min_base_shrink( tt, tt_shr );
+
+      if ( is_PI( tt_shr, tt_shr.num_vars() ) == invalid_index && is_inv_PI( tt_shr, tt_shr.num_vars() ) == invalid_index ) // check if remainder is PI
+      {
+        res.fanin.push_back( { 0, compute_dsd( tt_shr, mapped_support, rule ) } );
+      }
+      else
+      {
+        if ( is_PI( tt_shr, tt_shr.num_vars() ) != invalid_index )
+        {
+          res.fanin.push_back( { 0, mapped_support[is_PI( tt_shr, tt_shr.num_vars() )] } );
+        }
+        else
+        {
+          res.fanin.push_back( { 1, mapped_support[is_inv_PI( tt_shr, tt_shr.num_vars() )] } );
+        }
+      }
+      res.index = rule.size();
+      rule.push_back( res );
+
+      return res.index;
+    }
+    else /* try bottom decomposition */
+    {
+      auto couple = try_bottom_dec( tt, tt.num_vars() );
+      i = std::get<0>( couple );
+      uint32_t j = std::get<1>( couple );
+
+      if ( i < tt.num_vars() ) // it was bottom decomposable
+      {
+        auto res = do_bottom_dec( tt, i, j, rule.size(), mapped_support );
+        rule.push_back( res );
+
+        update_support( mapped_support, j );
+
+        kitty::dynamic_truth_table tt_shr( tt.num_vars() - 1 );
+        min_base_shrink( tt, tt_shr );
+
+        return compute_dsd( tt_shr, mapped_support, rule );
+      }
+      else /* do shannon decomposition */
+      {
+        kitty::dynamic_truth_table co0( tt.num_vars() );
+        kitty::dynamic_truth_table co1( tt.num_vars() );
+        kitty::dynamic_truth_table co0_shr( tt.num_vars() - 1 );
+        kitty::dynamic_truth_table co1_shr( tt.num_vars() - 1 );
+
+        uint32_t index = find_unate_var( tt );
+
+        auto res = do_shannon_dec( tt, index, co0, co1, mapped_support );
+
+        /* check for reconvergence */
+        gate_disjoint = true;
+
+        uint32_t inv_var_co1 = is_inv_PI( co1, co1.num_vars() );
+        uint32_t var_co1 = is_PI( co1, co1.num_vars() );
+        uint32_t inv_var_co0 = is_inv_PI( co0, co0.num_vars() );
+        uint32_t var_co0 = is_PI( co0, co0.num_vars() );
+
+        update_support( mapped_support, index );
+
+        if ( inv_var_co1 == invalid_index && var_co1 == invalid_index ) // check if co1 is PI
+        {
+          min_base_shrink( co1, co1_shr );
+          res.fanin.insert( res.fanin.begin(), { 0, compute_dsd( co1_shr, mapped_support, rule ) } );
+        }
+        else
+        {
+          if ( inv_var_co1 != invalid_index )
+          {
+            uint32_t map_inv_var_co1 = mapped_support[inv_var_co1];
+            res.fanin.insert( res.fanin.begin(), { 1, map_inv_var_co1 } );
+          }
+          else
+          {
+            uint32_t map_var_co1 = mapped_support[var_co1];
+            res.fanin.insert( res.fanin.begin(), { 0, map_var_co1 } );
+          }
+        }
+
+        if ( inv_var_co0 == invalid_index && var_co0 == invalid_index ) // check if co0 is PI
+        {
+          min_base_shrink( co0, co0_shr );
+          res.fanin.insert( res.fanin.begin(), { 0, compute_dsd( co0_shr, mapped_support, rule ) } );
+        }
+        else
+        {
+          if ( inv_var_co0 != invalid_index )
+          {
+            uint32_t map_inv_var_co0 = mapped_support[inv_var_co0];
+            res.fanin.insert( res.fanin.begin(), { 1, map_inv_var_co0 } );
+          }
+          else
+          {
+            uint32_t map_var_co0 = mapped_support[var_co0];
+            res.fanin.insert( res.fanin.begin(), { 0, map_var_co0 } );
+          }
+        }
+
+        res.index = rule.size();
+        rule.push_back( res );
+
+        return res.index;
+      }
+    }
+  }
+
+  rule get_rules( kitty::dynamic_truth_table const& tt )
+  {
+    auto match = _dsd_map.find( tt );
+    if ( match != _dsd_map.end() )
+      return match->second;
+    return {};
+  }
+
+  dsd_node* get_father( rule& rule, dsd_node& node )
+  {
+    for ( uint32_t i = 0; i < rule.size(); i++ )
+    {
+      if ( rule[i].type != node_type::pi_ && rule[i].type != node_type::zero_ && ( rule[i].fanin[0].index == node.index || rule[i].fanin[1].index == node.index ) )
+        return &rule[i];
+    }
+    return nullptr;
+  }
+
+  dsd_node* find_node( rule& r, uint32_t i )
+  {
+    for ( uint32_t j = 0; j < r.size(); j++ )
+    {
+      if ( r[j].index == i )
+        return &r[j];
+    }
+    return nullptr;
+  }
+
+  /*! \brief Convert rule derived from DSD decomposition into aig format.
+   *
+   *  \param r rule to convert.
+   * Returns rule converted into aig format.
+   */
+  rule map_to_aig( rule& r )
+  {
+    std::vector<dsd_node> rule( r );
+    std::vector<dsd_node> aig_rule;
+
+    std::transform( rule.begin(), rule.end(), rule.begin(), []( dsd_node n ) -> dsd_node {
+      for ( auto& s : n.fanin )
+      {
+        s.index += 1;
+      }
+      return { n.type, n.index + 1, n.fanin };
+    } );
+
+    rule.insert( rule.begin(), { node_type::zero_, 0, {} } );
+
+    for ( typename std::vector<dsd_node>::reverse_iterator i = rule.rbegin(); i != rule.rend(); ++i )
+    {
+      dsd_node n = *i;
+      dsd_node new_node;
+
+      if ( n.type == node_type::and_ || n.type == node_type::pi_ || n.type == node_type::zero_ )
+      {
+        new_node = n;
+      }
+      else if ( n.type == node_type::or_ )
+      {
+        new_node = { node_type::and_, n.index, { { ~n.fanin[0].inv, n.fanin[0].index }, { ~n.fanin[1].inv, n.fanin[1].index } } };
+        if ( get_father( rule, n ) != nullptr )
+        {
+          dsd_node* father = find_node( aig_rule, get_father( rule, n )->index );
+          if ( father->fanin[0].index == n.index )
+          {
+            father->fanin[0].inv = ~father->fanin[0].inv;
+          }
+          else
+          {
+            father->fanin[1].inv = ~father->fanin[1].inv;
+          }
+        }
+        else // it is root
+        {
+          dsd_node new_root = { node_type::and_, static_cast<uint32_t>( rule.size() ), { { 1, 0 }, { 1, n.index } } };
+          aig_rule.insert( aig_rule.begin(), new_root );
+        }
+      }
+      else if ( n.type == node_type::mux_ )
+      {
+        if ( get_father( rule, n ) != nullptr )
+        {
+          dsd_node* father = find_node( aig_rule, get_father( rule, n )->index );
+          if ( father->fanin[0].index == n.index )
+          {
+            father->fanin[0].inv = ~father->fanin[0].inv;
+          }
+          else
+          {
+            father->fanin[1].inv = ~father->fanin[1].inv;
+          }
+          dsd_node node_or = { node_type::and_, n.index + 2, { { 1, n.index }, { 1, n.index + 1 } } };
+          dsd_node node_and1 = { node_type::and_, n.index + 1, { { 0, n.fanin[2].index }, { n.fanin[1].inv, n.fanin[1].index } } };
+          new_node = { node_type::and_, n.index, { { 1, n.fanin[2].index }, { n.fanin[0].inv, n.fanin[0].index } } }; // and0_node
+
+          // node already in aig_rule must have index and fanin index update (index += 2, fanin_index -> (>= n.index -> +2; nothing))
+          for ( auto& elem : aig_rule )
+          {
+            elem.index += 2;
+            for ( auto& s : elem.fanin )
+            {
+              if ( s.index >= n.index )
+                s.index += 2;
+            }
+          }
+
+          aig_rule.insert( aig_rule.begin(), node_or );
+          aig_rule.insert( aig_rule.begin(), node_and1 );
+        }
+        else // it is root
+        {
+          dsd_node new_root = { node_type::and_, static_cast<uint32_t>( rule.size() + 2 ), { { 1, 0 }, { 1, static_cast<uint32_t>( rule.size() ) + 1 } } };
+          dsd_node node_or = { node_type::and_, static_cast<uint32_t>( rule.size() + 1 ), { { 1, static_cast<uint32_t>( rule.size() - 1 ) }, { 1, static_cast<uint32_t>( rule.size() ) } } };
+          dsd_node node_and1 = { node_type::and_, static_cast<uint32_t>( rule.size() ), { { 0, n.fanin[2].index }, { n.fanin[1].inv, n.fanin[1].index } } };
+          new_node = { node_type::and_, static_cast<uint32_t>( rule.size() - 1 ), { { 1, n.fanin[2].index }, { n.fanin[0].inv, n.fanin[0].index } } }; // and0_node
+
+          aig_rule.insert( aig_rule.begin(), new_root );
+          aig_rule.insert( aig_rule.begin(), node_or );
+          aig_rule.insert( aig_rule.begin(), node_and1 );
+        }
+      }
+      else if ( n.type == node_type::xor_ )
+      {
+        if ( get_father( rule, n ) != nullptr )
+        {
+          dsd_node* father = find_node( aig_rule, get_father( rule, n )->index );
+          if ( father->fanin[0].index == n.index )
+          {
+            father->fanin[0].inv = ~father->fanin[0].inv;
+          }
+          else
+          {
+            father->fanin[1].inv = ~father->fanin[1].inv;
+          }
+          dsd_node node_or = { node_type::and_, n.index + 2, { { 1, n.index }, { 1, n.index + 1 } } };
+          dsd_node node_and1 = { node_type::and_, n.index + 1, { { 0, n.fanin[0].index }, { 1, n.fanin[1].index } } };
+          new_node = { node_type::and_, n.index, { { 1, n.fanin[0].index }, { 0, n.fanin[1].index } } }; // and0_node
+
+          // node already in aig_rule must have index and fanin index update (index += 2, fanin_index -> (>= n.index -> +2; nothing))
+          for ( auto& elem : aig_rule )
+          {
+            elem.index += 2;
+            for ( auto& s : elem.fanin )
+            {
+              if ( s.index >= n.index )
+                s.index += 2;
+            }
+          }
+
+          aig_rule.insert( aig_rule.begin(), node_or );
+          aig_rule.insert( aig_rule.begin(), node_and1 );
+        }
+        else // it is root
+        {
+          dsd_node new_root = { node_type::and_, static_cast<uint32_t>( rule.size() + 2 ), { { 1, 0 }, { 1, static_cast<uint32_t>( rule.size() + 1 ) } } };
+          dsd_node node_or = { node_type::and_, static_cast<uint32_t>( rule.size() + 1 ), { { 1, static_cast<uint32_t>( rule.size() - 1 ) }, { 1, static_cast<uint32_t>( rule.size() ) } } };
+          dsd_node node_and1 = { node_type::and_, static_cast<uint32_t>( rule.size() ), { { 0, n.fanin[0].index }, { 1, n.fanin[1].index } } };
+          new_node = { node_type::and_, static_cast<uint32_t>( rule.size() - 1 ), { { 1, n.fanin[0].index }, { 0, n.fanin[1].index } } }; // and0_node
+
+          aig_rule.insert( aig_rule.begin(), new_root );
+          aig_rule.insert( aig_rule.begin(), node_or );
+          aig_rule.insert( aig_rule.begin(), node_and1 );
+        }
+      }
+      aig_rule.insert( aig_rule.begin(), new_node );
+    }
+    return aig_rule;
+  }
+
+  void swap( rule& rule, dsd_node* node_i, dsd_node* node_j )
+  {
+    auto i = node_i->index;
+    auto j = node_j->index;
+    node_i->index = j;
+    node_j->index = i;
+    std::swap( rule[i], rule[j] );
+  }
+
+  /* makes left or right move to derive a new rule */
+  void make_move( rule& rule, dsd_node* target, dsd_node* r, uint8_t left )
+  {
+    auto targ_index = 0 + left;
+    auto r_index = 1 - targ_index;
+    auto temp_index = target->fanin[targ_index].index;
+    auto temp_inv = target->fanin[targ_index].inv;
+    // swap position internal to rule of the two elements
+    swap( rule, target, r );
+    auto temp = target;
+    target = r;
+    r = temp;
+
+    // adjust children
+    target->fanin[targ_index].index = r->index;
+    target->fanin[targ_index].inv = 0;
+    r->fanin[r_index].index = temp_index;
+    r->fanin[r_index].inv = temp_inv;
+  }
+
+  /* checks whether a rule with the same left depth or right depth has already been encountered */
+  bool check_depths( rule rule, dsd_node root, std::vector<std::tuple<uint32_t, uint32_t>> depth_branches, uint32_t left ) // for left = 1 check if left move is possible
+  {
+    auto left_node = rule[root.fanin[0].index];
+    auto right_node = rule[root.fanin[1].index];
+    auto left_depth = get_depth( rule, left_node );
+    auto right_depth = get_depth( rule, right_node );
+    auto left_it1 = std::find( depth_branches.begin(), depth_branches.end(), std::tuple<uint32_t, uint32_t>{ left_depth - 1, right_depth + 1 } );
+    auto left_it2 = std::find( depth_branches.begin(), depth_branches.end(), std::tuple<uint32_t, uint32_t>{ right_depth + 1, left_depth - 1 } );
+    auto right_it1 = std::find( depth_branches.begin(), depth_branches.end(), std::tuple<uint32_t, uint32_t>{ left_depth + 1, right_depth - 1 } );
+    auto right_it2 = std::find( depth_branches.begin(), depth_branches.end(), std::tuple<uint32_t, uint32_t>{ right_depth - 1, left_depth + 1 } );
+    if ( left )
+      return left_it1 == depth_branches.end() && left_it2 == depth_branches.end();
+    else
+      return right_it1 == depth_branches.end() && right_it2 == depth_branches.end();
+  }
+
+  /*! \brief Recursively create new rules from the given one.
+   *         For every dsd node of the original rule, left and right moves are tried.
+   *         Then, the same algorithm is applied to all derived rules.
+   *         The algorithm stops if no new acceptable rules can be found.
+   *         A new rule is acceptable if no other rule with the same left and right depths has been found.
+   *  \param new_rules vector of derived rules.
+   *  \param rule original rule.
+   *  \param start_node node of rule on which we try the right and left moves.
+   *  \param depth_branches vector of encountered left and right depths.
+   *  \param can_left specifies if we can perform a left move.
+   *  \param can_right specifies if we can perform a right move.
+   */
+  void create_rules_from_dsd( std::vector<rule>& new_rules, rule rule, dsd_node start_node, std::vector<std::tuple<uint32_t, uint32_t>>& depth_branches, bool can_left, bool can_right )
+  {
+    if ( start_node.type == node_type::pi_ || start_node.type == node_type::zero_ ) // if you cannot produce new rules or you are a PI return
+      return;
+
+    std::vector<dsd_node> left_rule( rule );
+    std::vector<dsd_node> right_rule( rule );
+    std::vector<std::tuple<uint32_t, uint32_t>> next_depths = {};
+    auto left_node = &left_rule[start_node.fanin[0].index];
+    auto right_node = &right_rule[start_node.fanin[1].index];
+    bool new_left = false;
+    bool new_right = false;
+
+    std::tuple<uint32_t, uint32_t> depths = { get_depth( rule, *left_node ), get_depth( rule, *right_node ) };
+    depth_branches.push_back( depths );
+
+    /* left move */
+    if ( can_left && left_node->type == start_node.type && start_node.fanin[0].inv == 0 && check_depths( rule, start_node, depth_branches, 1 ) )
+    {
+      auto r = &left_rule[start_node.index];
+
+      make_move( left_rule, left_node, r, 1 );
+
+      new_rules.push_back( left_rule );
+      new_left = true;
+      depth_branches.push_back( { get_depth( left_rule, left_rule[left_rule[left_node->index].fanin[0].index] ), get_depth( left_rule, left_rule[left_rule[left_node->index].fanin[1].index] ) } );
+    }
+    /* right move */
+    if ( can_right && right_node->type == start_node.type && start_node.fanin[1].inv == 0 && check_depths( rule, start_node, depth_branches, 0 ) )
+    {
+      auto r = &right_rule[start_node.index];
+
+      make_move( right_rule, right_node, r, 0 );
+
+      new_rules.push_back( right_rule );
+      new_right = true;
+      depth_branches.push_back( { get_depth( right_rule, right_rule[right_rule[right_node->index].fanin[0].index] ), get_depth( right_rule, right_rule[right_rule[right_node->index].fanin[1].index] ) } );
+    }
+
+    /* initial rule, start_node left children */
+    create_rules_from_dsd( new_rules, rule, rule[start_node.fanin[0].index], next_depths, true, true );
+    /* initial rule, start_node right children */
+    create_rules_from_dsd( new_rules, rule, rule[start_node.fanin[1].index], next_depths, true, true );
+    /* left rule, start_node new root */
+    if ( new_left )
+    {
+      create_rules_from_dsd( new_rules, left_rule, left_rule[start_node.index], depth_branches, true, false );
+    }
+    /* right rule, start_node new root */
+    if ( new_right )
+    {
+      create_rules_from_dsd( new_rules, right_rule, right_rule[start_node.index], depth_branches, false, true );
+    }
+  }
+
+  uint32_t compute_canonized_polarity( uint32_t polarity, uint32_t left_pi, uint32_t right_pi, uint32_t obs_pi )
+  {
+    uint32_t mask_l = 0;
+    uint32_t mask_r = 0;
+    uint32_t mask_obs = 0;
+    for ( uint32_t i = 0; i < obs_pi; i++ )
+    {
+      mask_obs |= ( 1 << i );
+    }
+    for ( uint32_t i = obs_pi; i < obs_pi + left_pi; i++ )
+    {
+      mask_l |= ( 1 << i );
+    }
+    for ( uint32_t i = obs_pi + left_pi; i < obs_pi + left_pi + right_pi; i++ )
+    {
+      mask_r |= ( 1 << i );
+    }
+    return ( ( polarity & mask_l ) << right_pi ) | ( ( polarity & mask_r ) >> left_pi ) | ( polarity & mask_obs );
+  }
+
+  void compute_canonized_permutation( std::vector<uint8_t>& perm, uint32_t left_pi, uint32_t right_pi, uint32_t obs_pi )
+  {
+    std::vector copy( perm );
+    for ( uint32_t i = obs_pi; i < obs_pi + right_pi; i++ )
+    {
+      perm[i] = copy[( i + left_pi )];
+    }
+    for ( uint32_t i = right_pi + obs_pi; i < perm.size(); i++ )
+    {
+      perm[i] = copy[( i - right_pi )];
+    }
+  }
+
+  /*! \brief Recursively assigns indexes to a rule and its subrules and builds and_table.
+   *         It also computes negations and permutations for the gate whose rule is being passed as parameter.
+   *
+   *  \param r rule to index.
+   *  \param n dsd node to start from.
+   *  \param max max index assigned.
+   *  \param polarity polarity of gate.
+   *  \param perm permutation of gate.
+   *  \param shift specifies the number of PIs encountered.
+   * Returns label to be assigned to gate whose rule is r.
+   */
+  label do_indexing_rule( rule r, dsd_node n, uint32_t& max, uint32_t& polarity, std::vector<uint8_t>& perm, uint32_t& shift )
+  {
+    if ( n.type == node_type::pi_ )
+    {
+      perm[shift] = n.index - 1;
+      return { 0, 1 };
+    }
+    if ( n.type == node_type::zero_ )
+      return { 0, 0 };
+
+    uint32_t obs_pi = shift;
+
+    /* do indexing on the left */
+    uint32_t left_index = do_indexing_rule( r, r[n.fanin[0].index], max, polarity, perm, shift ).index;
+    if ( r[n.fanin[0].index].type == node_type::pi_ )
+    {
+      polarity |= ( n.fanin[0].inv << shift );
+      shift++;
+    }
+    /* encountered PIs on the left */
+    uint32_t left_pi = shift - obs_pi;
+
+    /* do indexing on the right */
+    uint32_t right_index = do_indexing_rule( r, r[n.fanin[1].index], max, polarity, perm, shift ).index;
+    if ( r[n.fanin[1].index].type == node_type::pi_ )
+    {
+      polarity |= ( n.fanin[1].inv << shift );
+      shift++;
+    }
+    /* encountered PIs on the right */
+    uint32_t right_pi = shift - obs_pi - left_pi;
+
+    /* check if it is inverted gate */
+    if ( n.fanin[0].index == 0 && n.fanin[1].inv && n.index == r.size() - 1 )
+    {
+      return { 1, right_index };
+    }
+    signal left, right;
+
+    /* ignore invertion of PIs */
+    if ( r[n.fanin[0].index].type == node_type::pi_ )
+      left.inv = 0;
+    else
+      left.inv = (uint64_t)n.fanin[0].inv;
+    left.index = left_index;
+    if ( r[n.fanin[1].index].type == node_type::pi_ )
+      right.inv = 0;
+    else
+      right.inv = (uint64_t)n.fanin[1].inv;
+    right.index = right_index;
+
+    std::tuple<signal, signal> t;
+
+    /* canonize and_table on left index being smaller than right one */
+    if ( left.index <= right.index )
+      t = std::make_tuple( left, right );
+    else
+    {
+      /* new polarity */
+      polarity = compute_canonized_polarity( polarity, left_pi, right_pi, obs_pi );
+
+      /* new permutation */
+      compute_canonized_permutation( perm, left_pi, right_pi, obs_pi );
+
+      t = std::make_tuple( right, left );
+    }
+    auto match = _and_table.find( t );
+    if ( match != _and_table.end() )
+      return { 0, match->second };
+    max++;
+    /* insert new value in and_table */
+    _and_table.insert( { t, max } );
+    return { 0, max };
+  }
+
+  template<class TT>
+  dsd_node is_top_dec( const TT& tt, uint32_t var_index, bool allow_xor = false, TT* func = nullptr )
+  {
+    static_assert( kitty::is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+    auto var = tt.construct();
+    kitty::create_nth_var( var, var_index );
+
+    if ( kitty::implies( tt, var ) )
+    {
+      if ( func )
+      {
+        *func = kitty::cofactor1( tt, var_index );
+      }
+      dsd_node res = { node_type::and_, var_index, {} };
+      res.fanin.push_back( { 0, UINT32_MAX } );
+      return res;
+    }
+    else if ( kitty::implies( var, tt ) )
+    {
+      if ( func )
+      {
+        *func = kitty::cofactor0( tt, var_index );
+      }
+      dsd_node res = { node_type::or_, var_index, {} };
+      res.fanin.push_back( { 0, UINT32_MAX } );
+      return res;
+    }
+    else if ( kitty::implies( tt, ~var ) )
+    {
+      if ( func )
+      {
+        *func = kitty::cofactor0( tt, var_index );
+      }
+      dsd_node res = { node_type::and_, var_index, {} };
+      res.fanin.push_back( { 1, UINT32_MAX } );
+      return res;
+    }
+    else if ( kitty::implies( ~var, tt ) )
+    {
+      if ( func )
+      {
+        *func = kitty::cofactor1( tt, var_index );
+      }
+      dsd_node res = { node_type::or_, var_index, {} };
+      res.fanin.push_back( { 1, UINT32_MAX } );
+      return res;
+    }
+
+    if ( allow_xor )
+    {
+      /* try XOR */
+      const auto co0 = kitty::cofactor0( tt, var_index );
+      const auto co1 = kitty::cofactor1( tt, var_index );
+
+      if ( kitty::equal( co0, ~co1 ) )
+      {
+        if ( func )
+        {
+          *func = co0;
+        }
+        dsd_node res = { node_type::xor_, var_index, {} };
+        res.fanin.push_back( { 0, UINT32_MAX } );
+        return res;
+      }
+    }
+
+    return { node_type::none, var_index, {} };
+  }
+
+  template<class TT>
+  dsd_node is_bottom_dec( const TT& tt, uint32_t var_index1, uint32_t var_index2, TT* func = nullptr, uint32_t new_index = invalid_index, bool allow_xor = false )
+  {
+    static_assert( kitty::is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+    const auto tt0 = kitty::cofactor0( tt, var_index1 );
+    const auto tt1 = kitty::cofactor1( tt, var_index1 );
+
+    const auto tt00 = kitty::cofactor0( tt0, var_index2 );
+    const auto tt01 = kitty::cofactor1( tt0, var_index2 );
+    const auto tt10 = kitty::cofactor0( tt1, var_index2 );
+    const auto tt11 = kitty::cofactor1( tt1, var_index2 );
+
+    const auto eq01 = kitty::equal( tt00, tt01 );
+    const auto eq02 = kitty::equal( tt00, tt10 );
+    const auto eq03 = kitty::equal( tt00, tt11 );
+    const auto eq12 = kitty::equal( tt01, tt10 );
+    const auto eq13 = kitty::equal( tt01, tt11 );
+    const auto eq23 = kitty::equal( tt10, tt11 );
+
+    const auto num_pairs =
+        static_cast<uint32_t>( eq01 ) +
+        static_cast<uint32_t>( eq02 ) +
+        static_cast<uint32_t>( eq03 ) +
+        static_cast<uint32_t>( eq12 ) +
+        static_cast<uint32_t>( eq13 ) +
+        static_cast<uint32_t>( eq23 );
+
+    if ( num_pairs != 2u && num_pairs != 3 )
+    {
+      return { node_type::none, invalid_index, {} };
+    }
+
+    if ( !eq01 && !eq02 && !eq03 ) // 00 is different
+    {
+      if ( func )
+      {
+        *func = kitty::mux_var( var_index1, tt11, tt00 );
+      }
+      dsd_node res = { node_type::or_, new_index, {} };
+      res.fanin.push_back( { 0, var_index1 } );
+      res.fanin.push_back( { 0, var_index2 } );
+      return res;
+    }
+    else if ( !eq01 && !eq12 && !eq13 ) // 01 is different
+    {
+      if ( func )
+      {
+        *func = kitty::mux_var( var_index1, tt01, tt10 );
+      }
+      dsd_node res = { node_type::and_, new_index, {} };
+      res.fanin.push_back( { 1, var_index1 } );
+      res.fanin.push_back( { 0, var_index2 } );
+      return res;
+    }
+    else if ( !eq02 && !eq12 && !eq23 ) // 10 is different
+    {
+      if ( func )
+      {
+        *func = kitty::mux_var( var_index1, tt01, tt10 );
+      }
+      dsd_node res = { node_type::or_, new_index, {} };
+      res.fanin.push_back( { 1, var_index1 } );
+      res.fanin.push_back( { 0, var_index2 } );
+      return res;
+    }
+    else if ( !eq03 && !eq13 && !eq23 ) // 11 is different
+    {
+      if ( func )
+      {
+        *func = kitty::mux_var( var_index1, tt11, tt00 );
+      }
+      dsd_node res = { node_type::and_, new_index, {} };
+      res.fanin.push_back( { 0, var_index1 } );
+      res.fanin.push_back( { 0, var_index2 } );
+      return res;
+    }
+    else if ( allow_xor ) // XOR
+    {
+      if ( func )
+      {
+        *func = kitty::mux_var( var_index1, tt01, tt00 );
+      }
+      dsd_node res = { node_type::xor_, new_index, {} };
+      res.fanin.push_back( { 0, var_index1 } );
+      res.fanin.push_back( { 0, var_index2 } );
+      return res;
+    }
+
+    return { node_type::none, invalid_index, {} };
+  }
+
+  template<class TT>
+  uint32_t find_unate_var( const TT tt )
+  {
+    for ( uint32_t index = 0; index < tt.num_vars() - 2; ++index )
+    {
+      const auto tt0 = kitty::cofactor0( tt, index );
+      const auto tt1 = kitty::cofactor1( tt, index );
+      if ( ( ( tt0 & tt1 ) == tt0 ) && ( ( tt0 & tt1 ) == tt1 ) )
+        return index;
+    }
+
+    return tt.num_vars() - 1;
+  }
+
+  template<class TT>
+  dsd_node shannon_dec( const TT& tt, uint32_t index, TT* func0 = nullptr, TT* func1 = nullptr )
+  {
+    static_assert( kitty::is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+    const auto tt0 = kitty::cofactor0( tt, index );
+    const auto tt1 = kitty::cofactor1( tt, index );
+
+    dsd_node res = { node_type::mux_, index, {} };
+    res.fanin.push_back( { 0, index } );
+
+    if ( func0 && func1 )
+    {
+      *func0 = tt0;
+      *func1 = tt1;
+    }
+
+    return res;
+  }
+
+  /*! \brief Get depth of rule starting from a specific dsd_node.
+   *
+   *  \param rule rule
+   *  \param n dsd_node to start from
+   * Returns depth of rule starting from n.
+   */
+  uint32_t get_depth( rule rule, dsd_node n )
+  {
+    if ( n.type == node_type::pi_ || n.type == node_type::zero_ )
+    {
+      return 0;
+    }
+    uint32_t max_depth;
+    uint32_t left_depth = get_depth( rule, rule[n.fanin[0].index] );
+    uint32_t right_depth = get_depth( rule, rule[n.fanin[1].index] );
+    max_depth = ( left_depth > right_depth ) ? left_depth : right_depth;
+    return max_depth + 1;
+  }
+
+#pragma region Report
+  std::string to_string( node_type t )
+  {
+    if ( t == node_type::and_ )
+      return "*";
+    if ( t == node_type::or_ )
+      return "+";
+    if ( t == node_type::mux_ )
+      return "+";
+    if ( t == node_type::xor_ )
+      return "xor";
+    if ( t == node_type::pi_ )
+      return "pi";
+    if ( t == node_type::none )
+      return "none";
+    if ( t == node_type::zero_ )
+      return "zero";
+  }
+
+  void print_dsd_node( dsd_node& n )
+  {
+    std::cout << n.index << " " << to_string( n.type ) << " ";
+    for ( auto elem : n.fanin )
+      std::cout << "{" << elem.index << ", " << elem.inv << "}";
+    std::cout << "\n";
+  }
+
+  void print_rule( rule& r )
+  {
+    for ( auto elem : r )
+      print_dsd_node( elem );
+  }
+
+  /*! \brief Print expression of a rule.
+   *
+   *  \param rule rule.
+   *  \param n dsd_node to start from.
+   */
+  void print_rule( rule rule, dsd_node n )
+  {
+    if ( n.type == node_type::pi_ )
+    {
+      std::cout << char( 'a' + n.index );
+      return;
+    }
+    if ( n.type == node_type::zero_ )
+    {
+      std::cout << "0";
+      return;
+    }
+    else
+    {
+      std::cout << "(";
+      if ( n.fanin[0].inv )
+      {
+        std::cout << "!";
+      }
+      if ( n.type == node_type::mux_ )
+      {
+        std::cout << "!" << char( 'a' + n.fanin[2].index ) << " * ";
+      }
+      print_rule( rule, rule[n.fanin[0].index] );
+      std::cout << " " << to_string( n.type ) << " ";
+      if ( n.type == node_type::mux_ )
+      {
+        std::cout << char( 'a' + n.fanin[2].index ) << " * ";
+      }
+      if ( n.fanin[1].inv )
+      {
+        std::cout << "!";
+      }
+      print_rule( rule, rule[n.fanin[1].index] );
+      std::cout << ")";
+    }
+  }
+#pragma endregion
+
+private:
+  bool gate_disjoint{ false }; /* flag for gate support*/
+  uint32_t num_large_gates{ 0 };
+
+  std::vector<gate> const& _gates; /* collection of gates */
+  struct_library_params const _ps;
+
+  composed_list_t _supergates;     /* list of composed_gates */
+  lib_rule _dsd_map;               /* hash map for DSD decomposition of gates */
+  lib_table _and_table;            /* AND table */
+  map_label_gate _label_to_gate;   /* map label to gate */
+};
+
+} // namespace mockturtle
diff --git a/include/mockturtle/utils/super_utils.hpp b/include/mockturtle/utils/super_utils.hpp
new file mode 100644
index 0000000..c7a74b1
--- /dev/null
+++ b/include/mockturtle/utils/super_utils.hpp
@@ -0,0 +1,466 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file super_utils.hpp
+  \brief Implements utilities to create supergates for technology mapping
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <cassert>
+#include <deque>
+#include <unordered_map>
+#include <vector>
+
+#include <fmt/format.h>
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+
+#include "../io/genlib_reader.hpp"
+#include "../io/super_reader.hpp"
+#include "include/supergate.hpp"
+
+namespace mockturtle
+{
+
+struct super_utils_params
+{
+  /*! \brief load multi-output gates in simple supergates */
+  bool load_multioutput_in_single{ false };
+
+  /*! \brief reports loaded supergates */
+  bool verbose{ false };
+};
+
+/*! \brief Utilities to generate supergates
+ *
+ * This class creates supergates starting from supergates
+ * specifications contained in `supergates_spec` extracted
+ * from a SUPER file.
+ *
+ * Multi-output gates are also extracted from the list of
+ * GENLIB gates. However multi-output gates are currently not
+ * supported as supergates members.
+ *
+ * This utility is called by `tech_library` to construct
+ * the library for technology mapping.
+ */
+template<unsigned NInputs = 6u>
+class super_utils
+{
+private:
+  static constexpr uint32_t truth_table_size = 6;
+
+public:
+  explicit super_utils( std::vector<gate> const& gates, super_lib const& supergates_spec = {}, super_utils_params const ps = {} )
+      : _gates( gates ),
+        _supergates_spec( supergates_spec ),
+        _ps( ps ),
+        _supergates(),
+        _multioutput_gates()
+  {
+    if ( _supergates_spec.supergates.size() == 0 )
+    {
+      generate_library_with_genlib();
+    }
+    else
+    {
+      generate_library_with_super();
+    }
+  }
+
+  /*! \brief Get the all the supergates.
+   *
+   * Returns a list of supergates created accordingly to
+   * the standard library and the supergates specifications.
+   */
+  const std::deque<composed_gate<NInputs>>& get_super_library() const
+  {
+    return _supergates;
+  }
+
+  /*! \brief Get the number of standard gates.
+   *
+   * Returns the number of standard gates contained in the
+   * supergate library.
+   */
+  const uint32_t get_standard_library_size() const
+  {
+    return simple_gates_size;
+  }
+
+  /*! \brief Get multi-output gates.
+   *
+   * Returns a list of multioutput gates.
+   */
+  const std::vector<std::vector<composed_gate<NInputs>>>& get_multioutput_library() const
+  {
+    return _multioutput_gates;
+  }
+
+public:
+  void generate_library_with_genlib()
+  {
+    uint32_t initial_size = _supergates.size();
+
+    std::unordered_map<std::string, uint32_t> multioutput_map;
+    std::unordered_map<std::string, uint32_t> multioutput_idx;
+    multioutput_map.reserve( _gates.size() );
+
+    /* look for multi-output gates (gates with the same name) */
+    uint32_t multioutput_i = 0;
+    for ( const auto& g : _gates )
+    {
+      if ( multioutput_map.find( g.name ) != multioutput_map.end() )
+      {
+        /* assign an index */
+        if ( multioutput_map[g.name] == 1 )
+          multioutput_idx[g.name] = multioutput_i++;
+
+        multioutput_map[g.name] += 1;
+      }
+      else
+      {
+        multioutput_map[g.name] = 1;
+        multioutput_idx[g.name] = UINT32_MAX;
+      }
+    }
+
+    /* create composed gates */
+    uint32_t ignored = 0;
+    uint32_t ignored_id = 0;
+    uint32_t large_gates = 0;
+    for ( const auto& g : _gates )
+    {
+      std::array<float, NInputs> pin_to_pin_delays{};
+
+      if ( g.function.num_vars() > NInputs )
+      {
+        ++ignored;
+        ignored_id = g.id;
+        continue;
+      }
+      if ( g.function.num_vars() > truth_table_size )
+      {
+        ++large_gates;
+        continue;
+      }
+
+      auto i = 0u;
+      for ( auto const& pin : g.pins )
+      {
+        /* use worst pin delay */
+        pin_to_pin_delays[i++] = std::max( pin.rise_block_delay, pin.fall_block_delay );
+      }
+
+      if ( multioutput_map[g.name] == 1 || _ps.load_multioutput_in_single )
+      {
+        _supergates.emplace_back( composed_gate<NInputs>{ static_cast<unsigned int>( _supergates.size() ),
+                                                          false,
+                                                          &g,
+                                                          g.num_vars,
+                                                          g.function,
+                                                          g.area,
+                                                          pin_to_pin_delays,
+                                                          {} } );
+      }
+
+      if ( multioutput_map[g.name] > 1 )
+      {
+        uint32_t idx = multioutput_idx[g.name];
+        if ( _multioutput_gates.size() <= idx )
+          _multioutput_gates.emplace_back( std::vector<composed_gate<NInputs>>() );
+
+        _multioutput_gates[multioutput_idx[g.name]].emplace_back(
+            composed_gate<NInputs>{ static_cast<unsigned int>( idx ),
+                                    false,
+                                    &g,
+                                    g.num_vars,
+                                    g.function,
+                                    g.area,
+                                    pin_to_pin_delays,
+                                    {} } );
+      }
+    }
+
+    simple_gates_size = _supergates.size() - initial_size;
+
+    if ( _ps.verbose )
+    {
+      std::cout << fmt::format( "[i] Loading {} simple library cells\n", simple_gates_size + large_gates );
+      std::cout << fmt::format( "[i] Loading {} multi-output library cells\n", _multioutput_gates.size() );
+    }
+
+    if ( ignored > 0 )
+    {
+      std::cerr << fmt::format( "[i] WARNING: {} gates IGNORED (e.g., {}), too many inputs for the library settings\n", ignored, _gates[ignored_id].name );
+    }
+  }
+
+  void generate_library_with_super()
+  {
+    if ( _supergates_spec.max_num_vars > NInputs || _supergates_spec.max_num_vars > truth_table_size )
+    {
+      std::cerr << fmt::format(
+          "[e] ERROR: NInputs ({}) should be greater or equal than the max number of variables ({}) in the super file.\n", NInputs, _supergates_spec.max_num_vars );
+      std::cerr << "[i] WARNING: ignoring supergates, proceeding with standard library." << std::endl;
+      generate_library_with_genlib();
+      return;
+    }
+
+    /* create a map for the gates IDs */
+    std::unordered_map<std::string, uint32_t> gates_map;
+
+    for ( auto const& g : _gates )
+    {
+      if ( gates_map.find( g.name ) != gates_map.end() )
+      {
+        std::cerr << fmt::format( "[i] WARNING: ignoring genlib gate {}, duplicated name entry in supergates.", g.name ) << std::endl;
+      }
+      else
+      {
+        gates_map[g.name] = g.id;
+      }
+    }
+
+    /* creating input variables */
+    for ( uint8_t i = 0; i < _supergates_spec.max_num_vars; ++i )
+    {
+      kitty::dynamic_truth_table tt{ NInputs };
+      kitty::create_nth_var( tt, i );
+
+      _supergates.emplace_back( composed_gate<NInputs>{ static_cast<unsigned int>( i ),
+                                                        false,
+                                                        nullptr,
+                                                        0,
+                                                        tt,
+                                                        0.0,
+                                                        {},
+                                                        {} } );
+    }
+
+    generate_library_with_genlib();
+
+    uint32_t super_count = 0;
+
+    /* add supergates */
+    for ( auto const& g : _supergates_spec.supergates )
+    {
+      uint32_t root_match_id;
+      if ( auto it = gates_map.find( g.name ); it != gates_map.end() )
+      {
+        root_match_id = it->second;
+      }
+      else
+      {
+        std::cerr << fmt::format( "[i] WARNING: ignoring supergate {}, no reference in genlib.", g.id ) << std::endl;
+        continue;
+      }
+
+      uint32_t num_vars = _gates[root_match_id].num_vars;
+
+      if ( num_vars != g.fanin_id.size() )
+      {
+        std::cerr << fmt::format( "[i] WARNING: ignoring supergate {}, wrong number of fanins.", g.id ) << std::endl;
+        continue;
+      }
+      if ( num_vars > _supergates_spec.max_num_vars )
+      {
+        std::cerr << fmt::format( "[i] WARNING: ignoring supergate {}, too many variables for the library settings.", g.id ) << std::endl;
+        continue;
+      }
+
+      std::vector<composed_gate<NInputs>*> sub_gates;
+
+      bool error = false;
+      bool simple_gate = true;
+      for ( uint32_t f : g.fanin_id )
+      {
+        if ( f >= g.id + _supergates_spec.max_num_vars )
+        {
+          error = true;
+          std::cerr << fmt::format( "[i] WARNING: ignoring supergate {}, wrong fanins.", g.id ) << std::endl;
+        }
+        if ( f < _supergates_spec.max_num_vars )
+        {
+          sub_gates.emplace_back( &_supergates[f] );
+        }
+        else
+        {
+          sub_gates.emplace_back( &_supergates[f + simple_gates_size] );
+          simple_gate = false;
+        }
+      }
+
+      if ( error )
+      {
+        continue;
+      }
+
+      /* force at `is_super = false` simple gates considered as supergates.
+       * This is necessary to not have duplicates since tech_library
+       * computes indipendently the permutations for simple gates.
+       * Moreover simple gates permutations could be incomplete in SUPER
+       * libraries which are constrained by the number of gates. */
+      bool is_super_verified = g.is_super;
+      if ( simple_gate )
+      {
+        is_super_verified = false;
+      }
+
+      float area = compute_area( root_match_id, sub_gates );
+      const kitty::dynamic_truth_table tt = compute_truth_table( root_match_id, sub_gates );
+
+      _supergates.emplace_back( composed_gate<NInputs>{ static_cast<unsigned int>( _supergates.size() ),
+                                                        is_super_verified,
+                                                        &_gates[root_match_id],
+                                                        0,
+                                                        tt,
+                                                        area,
+                                                        {},
+                                                        sub_gates } );
+
+      if ( g.is_super )
+      {
+        ++super_count;
+      }
+
+      auto& s = _supergates[_supergates.size() - 1];
+      s.num_vars = compute_support( s );
+      compute_delay_parameters( s );
+    }
+
+    /* minimize supergates */
+    for ( auto& g : _supergates )
+    {
+      if ( g.is_super )
+      {
+        g.function = shrink_to( g.function, static_cast<unsigned>( g.num_vars ) );
+      }
+    }
+
+    if ( _ps.verbose )
+    {
+      std::cout << fmt::format( "[i] Loaded {} supergates in the library\n", super_count );
+    }
+  }
+
+private:
+  inline float compute_area( uint32_t root_id, std::vector<composed_gate<NInputs>*> const& sub_gates )
+  {
+    float area = _gates[root_id].area;
+    for ( auto const f : sub_gates )
+    {
+      area += f->area;
+    }
+
+    return area;
+  }
+
+  inline uint32_t compute_support( composed_gate<NInputs>& s )
+  {
+    std::array<uint8_t, NInputs> used_pins{};
+    uint32_t support = 0;
+
+    return compute_support_rec( s, used_pins );
+  }
+
+  uint32_t compute_support_rec( composed_gate<NInputs>& s, std::array<uint8_t, NInputs>& used_pins )
+  {
+    /* termination: input variable */
+    if ( s.root == nullptr )
+    {
+      if ( used_pins[s.id]++ == 0u )
+      {
+        return 1;
+      }
+      return 0;
+    }
+
+    uint32_t support = 0;
+    for ( auto const pin : s.fanin )
+    {
+      support += compute_support_rec( *pin, used_pins );
+    }
+    return support;
+  }
+
+  inline kitty::dynamic_truth_table compute_truth_table( uint32_t root_id, std::vector<composed_gate<NInputs>*> const& sub_gates )
+  {
+    std::vector<kitty::dynamic_truth_table> ttv;
+
+    for ( auto const f : sub_gates )
+    {
+      ttv.emplace_back( f->function );
+    }
+
+    return kitty::compose_truth_table( _gates[root_id].function, ttv );
+  }
+
+  inline void compute_delay_parameters( composed_gate<NInputs>& s )
+  {
+    const auto& root = *( s.root );
+
+    auto i = 0u;
+    for ( auto const& pin : root.pins )
+    {
+      float worst_delay = std::max( pin.rise_block_delay, pin.fall_block_delay );
+
+      compute_delay_pin_rec( s, *( s.fanin[i++] ), worst_delay );
+    }
+  }
+
+  void compute_delay_pin_rec( composed_gate<NInputs>& root, composed_gate<NInputs>& s, float delay )
+  {
+    /* termination: input variable */
+    if ( s.root == nullptr )
+    {
+      root.tdelay[s.id] = std::max( root.tdelay[s.id], delay );
+      return;
+    }
+
+    auto i = 0u;
+    for ( auto const& pin : s.root->pins )
+    {
+      float worst_delay = delay + std::max( pin.rise_block_delay, pin.fall_block_delay );
+
+      compute_delay_pin_rec( root, *( s.fanin[i++] ), worst_delay );
+    }
+  }
+
+protected:
+  uint32_t simple_gates_size{ 0 };
+
+  std::vector<gate> const& _gates;
+  super_lib const& _supergates_spec;
+  super_utils_params const _ps;
+  std::deque<composed_gate<NInputs>> _supergates;
+  std::vector<std::vector<composed_gate<NInputs>>> _multioutput_gates;
+}; /* class super_utils */
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/utils/tech_library.hpp b/include/mockturtle/utils/tech_library.hpp
new file mode 100644
index 0000000..1669555
--- /dev/null
+++ b/include/mockturtle/utils/tech_library.hpp
@@ -0,0 +1,1652 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file tech_library.hpp
+  \brief Implements utilities to enumerates gates for technology mapping
+
+  \author Alessandro Tempia Calvino
+  \author Heinz Riener
+  \author Marcel Walter
+*/
+
+#pragma once
+
+#include <array>
+#include <cassert>
+#include <unordered_map>
+#include <vector>
+
+#include <kitty/constructors.hpp>
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/hash.hpp>
+#include <kitty/npn.hpp>
+#include <kitty/operators.hpp>
+#include <kitty/print.hpp>
+#include <kitty/static_truth_table.hpp>
+
+#include <parallel_hashmap/phmap.h>
+
+#include "../io/genlib_reader.hpp"
+#include "../io/super_reader.hpp"
+#include "include/supergate.hpp"
+#include "standard_cell.hpp"
+#include "struct_library.hpp"
+#include "super_utils.hpp"
+
+namespace mockturtle
+{
+
+/*
+std::string const mcnc_library = "GATE   inv1    1  O=!a;             PIN * INV 1 999 0.9 0.3 0.9 0.3\n"
+                                 "GATE   inv2    2  O=!a;             PIN * INV 2 999 1.0 0.1 1.0 0.1\n"
+                                 "GATE   inv3    3  O=!a;             PIN * INV 3 999 1.1 0.09 1.1 0.09\n"
+                                 "GATE   inv4    4  O=!a;             PIN * INV 4 999 1.2 0.07 1.2 0.07\n"
+                                 "GATE   nand2   2  O=!(a*b);         PIN * INV 1 999 1.0 0.2 1.0 0.2\n"
+                                 "GATE   nand3   3  O=!(a*b*c);       PIN * INV 1 999 1.1 0.3 1.1 0.3\n"
+                                 "GATE   nand4   4  O=!(a*b*c*d);     PIN * INV 1 999 1.4 0.4 1.4 0.4\n"
+                                 "GATE   nor2    2  O=!(a+b);         PIN * INV 1 999 1.4 0.5 1.4 0.5\n"
+                                 "GATE   nor3    3  O=!(a+b+c);       PIN * INV 1 999 2.4 0.7 2.4 0.7\n"
+                                 "GATE   nor4    4  O=!(a+b+c+d);     PIN * INV 1 999 3.8 1.0 3.8 1.0\n"
+                                 "GATE   and2    3  O=a*b;            PIN * NONINV 1 999 1.9 0.3 1.9 0.3\n"
+                                 "GATE   or2     3  O=a+b;            PIN * NONINV 1 999 2.4 0.3 2.4 0.3\n"
+                                 "GATE   xor2a   5  O=a*!b+!a*b;      PIN * UNKNOWN 2 999 1.9 0.5 1.9 0.5\n"
+                                 "#GATE  xor2b   5  O=!(a*b+!a*!b);   PIN * UNKNOWN 2 999 1.9 0.5 1.9 0.5\n"
+                                 "GATE   xnor2a  5  O=a*b+!a*!b;      PIN * UNKNOWN 2 999 2.1 0.5 2.1 0.5\n"
+                                 "#GATE  xnor2b  5  O=!(a*!b+!a*b);   PIN * UNKNOWN 2 999 2.1 0.5 2.1 0.5\n"
+                                 "GATE   aoi21   3  O=!(a*b+c);       PIN * INV 1 999 1.6 0.4 1.6 0.4\n"
+                                 "GATE   aoi22   4  O=!(a*b+c*d);     PIN * INV 1 999 2.0 0.4 2.0 0.4\n"
+                                 "GATE   oai21   3  O=!((a+b)*c);     PIN * INV 1 999 1.6 0.4 1.6 0.4\n"
+                                 "GATE   oai22   4  O=!((a+b)*(c+d)); PIN * INV 1 999 2.0 0.4 2.0 0.4\n"
+                                 "GATE   buf     2  O=a;              PIN * NONINV 1 999 1.0 0.0 1.0 0.0\n"
+                                 "GATE   zero    0  O=CONST0;\n"
+                                 "GATE   one     0  O=CONST1;";
+*/
+
+enum class classification_type : uint32_t
+{
+  /*! \brief generate the NP configurations (n! * 2^n)
+   *  Direct matching: best up to ~200 library gates */
+  np_configurations = 0,
+
+  /*! \brief generate the P configurations (n!)
+   *  Matching by N-canonization: best for more
+   * than ~200 library gates */
+  p_configurations = 1,
+
+  /*! \brief generate the n configurations (2^n)
+   *  Direct fast matching, less quality */
+  n_configurations = 2,
+};
+
+struct tech_library_params
+{
+  /*! \brief Load large gates with more than 6 inputs */
+  bool load_large_gates{ true };
+
+  /*! \brief Loads multioutput gates in the library */
+  bool load_multioutput_gates{ true };
+
+  /*! \brief Don't load symmetrical permutations of gate pins (drastically speeds-up mapping) */
+  bool ignore_symmetries{ false };
+
+  /*! \brief Load gates with minimum size only */
+  bool load_minimum_size_only{ true };
+
+  /*! \brief Remove dominated gates (larger sizes) */
+  bool remove_dominated_gates{ true };
+
+  /*! \brief Loads multioutput gates in single-output library */
+  bool load_multioutput_gates_single{ false };
+
+  /*! \brief reports np enumerations */
+  bool verbose{ false };
+
+  /*! \brief reports all the entries in the library */
+  bool very_verbose{ false };
+};
+
+namespace detail
+{
+
+template<uint32_t NumVars, uint32_t NumOutputs>
+struct tuple_tt_hash
+{
+  inline std::size_t operator()( std::array<kitty::static_truth_table<NumVars, true>, NumOutputs> const& tts ) const
+  {
+    std::size_t seed = kitty::hash_block( tts[0]._bits );
+
+    for ( auto i = 1; i < NumOutputs; ++i )
+      kitty::hash_combine( seed, kitty::hash_block( tts[i]._bits ) );
+
+    return seed;
+  }
+};
+
+} // namespace detail
+
+/*! \brief Library of gates for Boolean matching
+ *
+ * This class creates a technology library from a set
+ * of input gates. Each NP- or P-configuration of the gates
+ * are enumerated and inserted in the library.
+ *
+ * The configuration is selected using the template
+ * parameter `Configuration`. P-configuration is suggested
+ * for big libraries with few symmetric gates. The template
+ * parameter `NInputs` selects the maximum number of variables
+ * allowed for a gate in the library.
+ *
+ * The library can be generated also using supergates definitions.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      std::vector<gate> gates;
+      lorina::read_genlib( "file.genlib", genlib_reader( gates ) );
+      // standard library
+      mockturtle::tech_library lib( gates );
+
+      super_lib supergates_spec;
+      lorina::read_super( "file.super", super_reader( supergates_spec ) );
+      // library with supergates
+      mockturtle::tech_library lib_super( gates, supergates_spec );
+   \endverbatim
+ */
+template<unsigned NInputs = 6u, classification_type Configuration = classification_type::np_configurations>
+class tech_library
+{
+private:
+  static constexpr float epsilon = 0.0005;
+  static constexpr uint32_t max_multi_outputs = 2;
+  static constexpr uint32_t truth_table_size = 6;
+  using supergates_list_t = std::vector<supergate<NInputs>>;
+  using TT = kitty::static_truth_table<truth_table_size>;
+  using tt_hash = kitty::hash<TT>;
+  using multi_tt_hash = detail::tuple_tt_hash<truth_table_size, max_multi_outputs>;
+  using index_t = phmap::flat_hash_map<TT, uint32_t, tt_hash>;
+  using lib_t = phmap::flat_hash_map<TT, supergates_list_t, tt_hash>;
+  using multi_relation_t = std::array<TT, max_multi_outputs>;
+  using multi_supergates_list_t = std::array<std::vector<supergate<NInputs>>, max_multi_outputs>;
+  using multi_lib_t = phmap::flat_hash_map<multi_relation_t, multi_supergates_list_t, multi_tt_hash>;
+  using multi_func_t = phmap::flat_hash_map<uint64_t, uint64_t>;
+  using struct_lib_t = phmap::flat_hash_map<uint32_t, supergates_list_t>;
+
+public:
+  explicit tech_library( std::vector<gate> const& gates, tech_library_params const ps = {}, super_lib const& supergates_spec = {} )
+      : _gates( gates ),
+        _supergates_spec( supergates_spec ),
+        _ps( ps ),
+        _cells( get_standard_cells( _gates ) ),
+        _super( _gates, _supergates_spec, super_utils_params{ ps.load_multioutput_gates_single, ps.verbose } ),
+        _use_supergates( false ),
+        _struct( _gates, struct_library_params{ ps.load_minimum_size_only, ps.very_verbose } ),
+        _super_lib(),
+        _multi_lib(),
+        _struct_lib()
+  {
+    static_assert( NInputs < 16, "The technology library database supports NInputs up to 15\n" );
+
+    generate_library();
+
+    if ( ps.load_multioutput_gates )
+      generate_multioutput_library();
+
+    if ( ps.load_large_gates )
+    {
+      _struct.construct( 2 );
+    }
+  }
+
+  explicit tech_library( std::vector<gate> const& gates, super_lib const& supergates_spec, tech_library_params const ps = {} )
+      : _gates( gates ),
+        _supergates_spec( supergates_spec ),
+        _ps( ps ),
+        _cells( get_standard_cells( _gates ) ),
+        _super( _gates, _supergates_spec, super_utils_params{ ps.load_multioutput_gates_single, ps.verbose } ),
+        _use_supergates( true ),
+        _struct( _gates, struct_library_params{ ps.load_minimum_size_only, ps.very_verbose } ),
+        _super_lib(),
+        _multi_lib(),
+        _struct_lib()
+  {
+    static_assert( NInputs < 16, "The technology library database supports NInputs up to 15\n" );
+
+    generate_library();
+
+    if ( ps.load_multioutput_gates )
+      generate_multioutput_library();
+
+    if ( ps.load_large_gates )
+    {
+      _struct.construct( 2 );
+    }
+  }
+
+  tech_library ( const tech_library& ) = delete;
+  tech_library& operator=( const tech_library& ) = delete;
+
+  /*! \brief Get the gates matching the function.
+   *
+   * Returns a list of gates that match the function represented
+   * by the truth table.
+   */
+  const supergates_list_t* get_supergates( TT const& tt ) const
+  {
+    auto match = _super_lib.find( tt );
+    if ( match != _super_lib.end() )
+      return &match->second;
+    return nullptr;
+  }
+
+  /*! \brief Get the multi-output gates matching the function.
+   *
+   * Returns a list of multi-output gates that match the function
+   * represented by the truth table.
+   */
+  const multi_supergates_list_t* get_multi_supergates( std::array<TT, max_multi_outputs> const& tts ) const
+  {
+    auto match = _multi_lib.find( tts );
+    if ( match != _multi_lib.end() )
+      return &match->second;
+    return nullptr;
+  }
+
+  /*! \brief Get the multi-output gate function ID for a single output.
+   *
+   * Returns the function ID of a multi-output gate output if matched. This function
+   * supports up to 6 inputs. Returns zero in case of no match.
+   */
+  uint64_t get_multi_function_id( uint64_t const& tt ) const
+  {
+    auto match = _multi_funcs.find( tt );
+    if ( match != _multi_funcs.end() )
+      return match->second;
+    return 0;
+  }
+
+  /*! \brief Get the pattern ID for structural matching.
+   *
+   * Returns a pattern ID if found, UINT32_MAX otherwise given the
+   * children IDs. This function works with only AND operators.
+   */
+  uint32_t get_pattern_id( uint32_t id1, uint32_t id2 ) const
+  {
+    return _struct.get_pattern_id( id1, id2 );
+  }
+
+  /*! \brief Get the gates matching the pattern ID and phase.
+   *
+   * Returns a list of gates that match the pattern ID and the given polarity.
+   */
+  const supergates_list_t* get_supergates_pattern( uint32_t id, bool phase ) const
+  {
+    return _struct.get_supergates_pattern( id, phase );
+  }
+
+  /*! \brief Get inverter information.
+   *
+   * Returns area, delay, and ID of the smallest inverter.
+   */
+  const std::tuple<float, float, uint32_t> get_inverter_info() const
+  {
+    return std::make_tuple( _inv_area, _inv_delay, _inv_id );
+  }
+
+  /*! \brief Get buffer information.
+   *
+   * Returns area, delay, and ID of the smallest buffer.
+   */
+  const std::tuple<float, float, uint32_t> get_buffer_info() const
+  {
+    return std::make_tuple( _buf_area, _buf_delay, _buf_id );
+  }
+
+  /*! \brief Returns the maximum number of variables of the gates. */
+  unsigned max_gate_size()
+  {
+    return _max_size;
+  }
+
+  /*! \brief Returns the original gates. */
+  const std::vector<gate> get_gates() const
+  {
+    return _gates;
+  }
+
+  /*! \brief Returns the standard cells. */
+  const std::vector<standard_cell>& get_cells() const
+  {
+    return _cells;
+  }
+
+  /*! \brief Returns multioutput gates. */
+  const std::vector<std::vector<composed_gate<NInputs>>>& get_multioutput_gates() const
+  {
+    return _super.get_multioutput_library();
+  }
+
+  /*! \brief Returns the number of multi-output gates loaded in the library. */
+  const uint32_t num_multioutput_gates() const
+  {
+    if ( !_ps.load_multioutput_gates )
+      return 0;
+    return _multi_lib.size();
+  }
+
+  /*! \brief Returns the number of gates for structural matching. */
+  const uint32_t num_structural_gates() const
+  {
+    return _struct.get_struct_library().size();
+  }
+
+  /*! \brief Returns the number of gates for structural matching with more than 6 inputs. */
+  const uint32_t num_structural_large_gates() const
+  {
+    return _struct.get_struct_library().size();
+  }
+
+private:
+  void generate_library()
+  {
+    bool inv = false;
+    bool buf = false;
+
+    /* extract the smallest inverter and buffer info */
+    for ( auto& gate : _gates )
+    {
+      if ( gate.function.num_vars() == 1 )
+      {
+        /* extract inverter delay and area */
+        if ( kitty::is_const0( kitty::cofactor1( gate.function, 0 ) ) )
+        {
+          /* get the smallest area inverter */
+          if ( !inv || gate.area < _inv_area - epsilon )
+          {
+            _inv_area = gate.area;
+            _inv_delay = compute_worst_delay( gate );
+            _inv_id = gate.id;
+            inv = true;
+          }
+        }
+        else
+        {
+          /* get the smallest area buffer */
+          if ( !buf || gate.area < _buf_area - epsilon )
+          {
+            _buf_area = gate.area;
+            _buf_delay = compute_worst_delay( gate );
+            _buf_id = gate.id;
+            buf = true;
+          }
+        }
+      }
+    }
+
+    auto const& supergates = _super.get_super_library();
+    uint32_t const standard_gate_size = _super.get_standard_library_size();
+
+    std::vector<bool> skip_gates( supergates.size(), false );
+
+    if ( _ps.load_minimum_size_only || _ps.remove_dominated_gates )
+    {
+      filter_gates( supergates, skip_gates );
+    }
+
+    /* generate the configurations for the standard gates */
+    uint32_t i = 0u;
+    uint32_t skip_count = 0;
+    for ( auto const& gate : supergates )
+    {
+      uint32_t np_count = 0;
+
+      if ( skip_gates[skip_count++] )
+      {
+        /* exclude gate */
+        ++i;
+        continue;
+      }
+
+      if ( gate.root == nullptr )
+      {
+        /* exclude PIs */
+        continue;
+      }
+
+      _max_size = std::max( _max_size, gate.num_vars );
+
+      if ( i++ < standard_gate_size )
+      {
+        const auto on_np = [&]( auto const& tt, auto neg, auto const& perm ) {
+          supergate<NInputs> sg = { &gate,
+                                    static_cast<float>( gate.area ),
+                                    {},
+                                    perm,
+                                    0 };
+
+          for ( auto i = 0u; i < perm.size() && i < NInputs; ++i )
+          {
+            sg.tdelay[i] = gate.tdelay[perm[i]];
+            sg.polarity |= ( ( neg >> perm[i] ) & 1 ) << i; /* permutate input negation to match the right pin */
+          }
+
+          const auto static_tt = kitty::extend_to<truth_table_size>( tt );
+
+          auto& v = _super_lib[static_tt];
+
+          /* ordered insert by ascending area and number of input pins */
+          auto it = std::lower_bound( v.begin(), v.end(), sg, [&]( auto const& s1, auto const& s2 ) {
+            if ( s1.area < s2.area )
+              return true;
+            if ( s1.area > s2.area )
+              return false;
+            if ( s1.root->num_vars < s2.root->num_vars )
+              return true;
+            if ( s1.root->num_vars > s2.root->num_vars )
+              return true;
+            return s1.root->id < s2.root->id;
+          } );
+
+          bool to_add = true;
+          /* search for duplicated element due to symmetries */
+          while ( it != v.end() )
+          {
+            if ( sg.root->id == it->root->id )
+            {
+              /* if already in the library exit, else ignore permutations if with equal delay cost */
+              if ( sg.polarity == it->polarity && ( _ps.ignore_symmetries || sg.tdelay == it->tdelay ) )
+              {
+                to_add = false;
+                break;
+              }
+            }
+            else
+            {
+              break;
+            }
+            ++it;
+          }
+
+          if ( to_add )
+          {
+            v.insert( it, sg );
+            ++np_count;
+          }
+        };
+
+        const auto on_p = [&]( auto const& tt, auto const& perm ) {
+          /* get all the configurations that lead to the N-class representative */
+          auto [tt_canon, phases] = kitty::exact_n_canonization_complete( tt );
+
+          for ( auto phase : phases )
+          {
+            supergate<NInputs> sg = { &gate,
+                                      static_cast<float>( gate.area ),
+                                      {},
+                                      perm,
+                                      static_cast<uint16_t>( phase ) };
+
+            for ( auto i = 0u; i < perm.size() && i < NInputs; ++i )
+            {
+              sg.tdelay[i] = gate.tdelay[perm[i]];
+            }
+
+            const auto static_tt = kitty::extend_to<truth_table_size>( tt_canon );
+
+            auto& v = _super_lib[static_tt];
+
+            /* ordered insert by ascending area and number of input pins */
+            auto it = std::lower_bound( v.begin(), v.end(), sg, [&]( auto const& s1, auto const& s2 ) {
+              if ( s1.area < s2.area )
+                return true;
+              if ( s1.area > s2.area )
+                return false;
+              if ( s1.root->num_vars < s2.root->num_vars )
+                return true;
+              if ( s1.root->num_vars > s2.root->num_vars )
+                return true;
+              return s1.root->id < s2.root->id;
+            } );
+
+            bool to_add = true;
+            /* search for duplicated element due to symmetries */
+            while ( it != v.end() )
+            {
+              if ( sg.root->id == it->root->id )
+              {
+                /* if already in the library exit, else ignore permutations if with equal delay cost */
+                if ( sg.polarity == it->polarity && ( _ps.ignore_symmetries || sg.tdelay == it->tdelay ) )
+                {
+                  to_add = false;
+                  break;
+                }
+              }
+              else
+              {
+                break;
+              }
+              ++it;
+            }
+
+            if ( to_add )
+            {
+              v.insert( it, sg );
+              ++np_count;
+            }
+          }
+        };
+
+        if constexpr ( Configuration == classification_type::np_configurations )
+        {
+          /* NP enumeration of the function */
+          const auto tt = gate.function;
+          kitty::exact_np_enumeration( tt, on_np );
+        }
+        else if ( Configuration == classification_type::n_configurations )
+        {
+          /* N enumeration of the function */
+          const auto tt = gate.function;
+          std::vector<uint8_t> pin_order( tt.num_vars() );
+          std::iota( pin_order.begin(), pin_order.end(), 0 );
+          kitty::exact_n_enumeration( tt, [&]( auto const& tt, auto neg ) { on_np( tt, neg, pin_order ); } );
+        }
+        else
+        {
+          /* P enumeration followed by N canonization of the function */
+          const auto tt = gate.function;
+          kitty::exact_p_enumeration( tt, on_p );
+        }
+      }
+      else
+      {
+        /* process the supergates */
+        if ( !gate.is_super )
+        {
+          /* ignore simple gates */
+          continue;
+        }
+
+        const auto on_np = [&]( auto const& tt, auto neg ) {
+          std::vector<uint8_t> perm( gate.num_vars );
+          std::iota( perm.begin(), perm.end(), 0u );
+
+          supergate<NInputs> sg = { &gate,
+                                    static_cast<float>( gate.area ),
+                                    {},
+                                    perm,
+                                    static_cast<uint16_t>( neg ) };
+
+          for ( auto i = 0u; i < perm.size() && i < NInputs; ++i )
+          {
+            sg.tdelay[i] = gate.tdelay[perm[i]];
+          }
+
+          const auto static_tt = kitty::extend_to<truth_table_size>( tt );
+
+          auto& v = _super_lib[static_tt];
+
+          /* ordered insert by ascending area and number of input pins */
+          auto it = std::lower_bound( v.begin(), v.end(), sg, [&]( auto const& s1, auto const& s2 ) {
+            if ( s1.area < s2.area )
+              return true;
+            if ( s1.area > s2.area )
+              return false;
+            if ( s1.root->num_vars < s2.root->num_vars )
+              return true;
+            if ( s1.root->num_vars > s2.root->num_vars )
+              return true;
+            return s1.root->id < s2.root->id;
+          } );
+
+          bool to_add = true;
+          /* search for duplicated element due to symmetries */
+          while ( it != v.end() )
+          {
+            if ( sg.root->id == it->root->id )
+            {
+              /* if already in the library exit, else ignore permutations if with equal delay cost */
+              if ( sg.polarity == it->polarity && sg.tdelay == it->tdelay )
+              {
+                to_add = false;
+                break;
+              }
+            }
+            else
+            {
+              break;
+            }
+            ++it;
+          }
+
+          if ( to_add )
+          {
+            v.insert( it, sg );
+            ++np_count;
+          }
+        };
+
+        const auto on_p = [&]() {
+          auto [tt_canon, phases] = kitty::exact_n_canonization_complete( gate.function );
+          std::vector<uint8_t> perm( gate.num_vars );
+          std::iota( perm.begin(), perm.end(), 0u );
+
+          for ( auto phase : phases )
+          {
+            supergate<NInputs> sg = { &gate,
+                                      static_cast<float>( gate.area ),
+                                      {},
+                                      perm,
+                                      static_cast<uint16_t>( phase ) };
+
+            for ( auto i = 0u; i < perm.size() && i < NInputs; ++i )
+            {
+              sg.tdelay[i] = gate.tdelay[perm[i]];
+            }
+
+            const auto static_tt = kitty::extend_to<truth_table_size>( tt_canon );
+
+            auto& v = _super_lib[static_tt];
+
+            /* ordered insert by ascending area and number of input pins */
+            auto it = std::lower_bound( v.begin(), v.end(), sg, [&]( auto const& s1, auto const& s2 ) {
+              if ( s1.area < s2.area )
+                return true;
+              if ( s1.area > s2.area )
+                return false;
+              if ( s1.root->num_vars < s2.root->num_vars )
+                return true;
+              if ( s1.root->num_vars > s2.root->num_vars )
+                return true;
+              return s1.root->id < s2.root->id;
+            } );
+
+            bool to_add = true;
+            /* search for duplicated element due to symmetries */
+            while ( it != v.end() )
+            {
+              if ( sg.root->id == it->root->id )
+              {
+                /* if already in the library exit, else ignore permutations if with equal delay cost */
+                if ( sg.polarity == it->polarity && sg.tdelay == it->tdelay )
+                {
+                  to_add = false;
+                  break;
+                }
+              }
+              else
+              {
+                break;
+              }
+              ++it;
+            }
+
+            if ( to_add )
+            {
+              v.insert( it, sg );
+              ++np_count;
+            }
+          }
+        };
+
+        if constexpr ( Configuration == classification_type::np_configurations )
+        {
+          /* N enumeration of the function */
+          const auto tt = gate.function;
+          kitty::exact_n_enumeration( tt, on_np );
+        }
+        else
+        {
+          /* N canonization of the function */
+          const auto tt = gate.function;
+          on_p();
+        }
+      }
+
+      if ( _ps.very_verbose )
+      {
+        std::cout << "Gate " << gate.root->name << ", num_vars = " << gate.num_vars << ", np entries = " << np_count << std::endl;
+      }
+    }
+
+    if ( !inv )
+    {
+      std::cerr << "[i] WARNING: inverter gate has not been detected in the library" << std::endl;
+    }
+
+    if ( !buf )
+    {
+      std::cerr << "[i] WARNING: buffer gate has not been detected in the library" << std::endl;
+    }
+
+    if ( _ps.very_verbose )
+    {
+      for ( auto const& entry : _super_lib )
+      {
+        kitty::print_hex( entry.first );
+        std::cout << ": ";
+        for ( auto const& gate : entry.second )
+        {
+          printf( "%d(a:%.2f, p:%d) ", gate.root->id, gate.area, gate.polarity );
+        }
+        std::cout << std::endl;
+      }
+    }
+  }
+
+  /* Supports only NP configurations */
+  void generate_multioutput_library()
+  {
+    uint32_t np_count = 0;
+    std::string ignored_name;
+    bool consistency_check = true;
+
+    /* load multi-output gates */
+    auto const& multioutput_gates = _super.get_multioutput_library();
+
+    uint32_t ignored_gates = 0;
+    for ( auto const& multi_gate : multioutput_gates )
+    {
+      /* select the on up to max_multi_outputs outputs */
+      if ( multi_gate.size() > max_multi_outputs )
+      {
+        ignored_name = multi_gate[0].root->name;
+        ++ignored_gates;
+        continue;
+      }
+
+      std::array<size_t, max_multi_outputs> order = { 0 };
+
+      const auto on_np = [&]( auto const& tts, auto neg, auto const& perm ) {
+        std::vector<supergate<NInputs>> multi_sg;
+
+        for ( auto const& gate : multi_gate )
+        {
+          multi_sg.emplace_back( supergate<NInputs>{ &gate,
+                                                     static_cast<float>( gate.area ),
+                                                     {},
+                                                     perm,
+                                                     0 } );
+        }
+
+        for ( auto i = 0u; i < perm.size() && i < NInputs; ++i )
+        {
+          uint32_t j = 0;
+          for ( auto& sg : multi_sg )
+          {
+            sg.tdelay[i] = multi_gate[j++].tdelay[perm[i]];
+            sg.polarity |= ( ( neg >> perm[i] ) & 1 ) << i; /* permutate input negation to match the right pin */
+          }
+        }
+
+        std::array<TT, max_multi_outputs> static_tts = {};
+        std::array<TT, max_multi_outputs> sorted_tts = {};
+
+        /* canonize output */
+        for ( auto i = 0; i < tts.size(); ++i )
+        {
+          static_tts[i] = kitty::extend_to<truth_table_size>( tts[i] );
+          if ( ( static_tts[i]._bits & 1 ) == 1 )
+          {
+            static_tts[i] = ~static_tts[i];
+            multi_sg[i].polarity |= 1 << NInputs; /* set flipped output polarity*/
+          }
+        }
+
+        std::iota( order.begin(), order.end(), 0 );
+
+        std::stable_sort( order.begin(), order.end(), [&]( size_t a, size_t b ) {
+          return static_tts[a] < static_tts[b];
+        } );
+
+        std::transform( order.begin(), order.end(), sorted_tts.begin(), [&]( size_t a ) {
+          return static_tts[a];
+        } );
+
+        // std::stable_sort( static_tts.begin(), static_tts.end() );
+
+        auto& v = _multi_lib[sorted_tts];
+
+        /* ordered insert by ascending area and number of input pins */
+        auto it = std::lower_bound( v[0].begin(), v[0].end(), multi_sg[0], [&]( auto const& s1, auto const& s2 ) {
+          if ( s1.area < s2.area )
+            return true;
+          if ( s1.area > s2.area )
+            return false;
+          if ( s1.root->num_vars < s2.root->num_vars )
+            return true;
+          if ( s1.root->num_vars > s2.root->num_vars )
+            return true;
+          return s1.root->id < s2.root->id;
+        } );
+
+        bool to_add = true;
+        /* search for duplicated elements due to symmetries */
+        while ( it != v[0].end() )
+        {
+          /* if different gate, exit */
+          if ( multi_sg[0].root->id != it->root->id )
+            break;
+
+          /* if already in the library, exit */
+          if ( multi_sg[order[0]].polarity != it->polarity )
+          {
+            ++it;
+            continue;
+          }
+
+          bool same_delay = true;
+          size_t d = std::distance( v[0].begin(), it );
+          for ( auto i = 0; i < multi_sg.size(); ++i )
+          {
+            if ( multi_sg[order[i]].tdelay != v[i][d].tdelay )
+            {
+              same_delay = false;
+              break;
+            }
+          }
+
+          /* do not add if equivalent to another in the library */
+          if ( same_delay )
+          {
+            to_add = false;
+            break;
+          }
+
+          ++it;
+        }
+
+        if ( to_add )
+        {
+          size_t d = std::distance( v[0].begin(), it );
+          for ( auto i = 0; i < multi_sg.size(); ++i )
+          {
+            v[i].insert( v[i].begin() + d, multi_sg[order[i]] );
+          }
+          ++np_count;
+        }
+      };
+
+      /* NP enumeration of the function */
+      std::vector<kitty::dynamic_truth_table> tts;
+      for ( auto gate : multi_gate )
+        tts.push_back( gate.function );
+      kitty::exact_multi_np_enumeration( tts, on_np );
+
+      /* NPN enumeration of the single outputs */
+      uint32_t pin = 0;
+      for ( auto const& gate : multi_gate )
+      {
+        consistency_check &= check_delay_consistency( gate, pin++ );
+        exact_npn_enumeration( gate.function, [&]( auto const& tt, auto neg, auto const& perm ) {
+          (void)neg;
+          (void)perm;
+          _multi_funcs[tt._bits[0]] = gate.function._bits[0];
+        } );
+      }
+    }
+
+    /* update area based on the single output contribution */
+    multi_update_area();
+
+    if ( _ps.verbose && ignored_gates > 0 )
+    {
+      std::cerr << fmt::format( "[i] WARNING: {} multi-output gates IGNORED (e.g., {}), too many outputs for the library settings\n", ignored_gates, ignored_name );
+    }
+
+    if ( !consistency_check )
+    {
+      std::cerr << "[i] WARNING: technology mapping using multi-output cells with warnings might generate required time violations or circuits with dangling pins\n";
+    }
+
+    // std::cout << _multi_lib.size() << "\n";
+  }
+
+  void multi_update_area()
+  {
+    /* update area for each sub-function in a multi-output gate with their contribution */
+    for ( auto& pair : _multi_lib )
+    {
+      auto& multi_gates = pair.second;
+      for ( auto i = 0; i < multi_gates[0].size(); ++i )
+      {
+        /* get sum of area and area count */
+        double area = 0;
+        uint32_t contribution_count = 0;
+        std::array<double, max_multi_outputs> area_contribution = { 0 };
+        for ( auto j = 0; j < max_multi_outputs; ++j )
+        {
+          auto& gate = multi_gates[j][i];
+          const TT tt = kitty::extend_to<truth_table_size>( gate.root->function );
+
+          /* get the area of the smallest match with a simple gate */
+          const auto match = get_supergates( tt );
+          if ( match == nullptr )
+            continue;
+
+          area_contribution[j] = ( *match )[0].area;
+          area += area_contribution[j];
+          ++contribution_count;
+
+          // std::cout << fmt::format( "Contribution {}\t = {}\n", ( *match )[0].root->root->name, area_contribution[j] );
+        }
+
+        /* compute scaling factor and remaining area for non-matched gates */
+        double scaling_factor = 1.0;
+        double remaining_area = 0;
+
+        if ( contribution_count != max_multi_outputs )
+        {
+          scaling_factor = 0.9;
+
+          if ( area > multi_gates[0][i].area )
+            scaling_factor -= ( area - multi_gates[0][i].area ) / area;
+
+          remaining_area = ( multi_gates[0][i].area - area * scaling_factor );
+          area = area * scaling_factor + remaining_area;
+          remaining_area /= ( max_multi_outputs - contribution_count );
+        }
+
+        /* assign weighted contribution */
+        // double area_old = multi_gates[0][i].area;
+        // double area_check = 0;
+        for ( auto j = 0; j < max_multi_outputs; ++j )
+        {
+          auto& gate = multi_gates[j][i];
+
+          if ( area_contribution[j] > 0 )
+            gate.area = scaling_factor * area_contribution[j] * gate.area / area;
+          else
+            gate.area = remaining_area;
+
+          // area_check += gate.area;
+        }
+
+        // std::cout << fmt::format( "Area before: {}\t Area after {}\n", area_old, area_check );
+      }
+    }
+  }
+
+  bool check_delay_consistency( composed_gate<NInputs> const& g, uint32_t pin )
+  {
+    TT tt = kitty::extend_to<truth_table_size>( g.function );
+    uint16_t polarity = 0;
+
+    /* canonicalize in case of P-configurations */
+    if constexpr ( Configuration == classification_type::p_configurations )
+    {
+      auto canon = kitty::exact_n_canonization_support( tt, g.num_vars );
+      tt = std::get<0>( canon );
+      polarity = static_cast<uint16_t>( std::get<1>( canon ) );
+    }
+
+    auto entry = _super_lib.find( tt );
+    if ( entry == _super_lib.end() )
+    {
+      std::cerr << fmt::format( "[i] WARNING: library does not contain cells that can implement output pin {} of the multi-output cell {}\n", pin, g.root->name );
+      return false;
+    }
+
+    /* check delay (at least one entry must have better or equal delay) */
+    for ( auto const& sg : entry->second )
+    {
+      bool valid = true;
+      for ( uint32_t i = 0; i < g.num_vars; ++i )
+      {
+        float pin_delay = sg.tdelay[i];
+        if ( ( sg.polarity >> i ) & 1 )
+          pin_delay += _inv_delay;
+
+        float mo_pin_delay = g.tdelay[i];
+        if ( ( polarity >> i ) & 1 )
+          mo_pin_delay += _inv_delay;
+
+        if ( pin_delay > mo_pin_delay )
+        {
+          valid = false;
+          break;
+        }
+      }
+
+      if ( valid )
+      {
+        return true;
+      }
+    }
+
+    std::cerr << fmt::format( "[i] WARNING: library does not contain cells that could match the delay of output pin {} of multi-output cell {}\n", pin + 1, g.root->name );
+    return false;
+  }
+
+  float compute_worst_delay( gate const& g )
+  {
+    float worst_delay = 0.0f;
+
+    /* consider only block_delay */
+    for ( auto const& pin : g.pins )
+    {
+      float worst_pin_delay = static_cast<float>( std::max( pin.rise_block_delay, pin.fall_block_delay ) );
+      worst_delay = std::max( worst_delay, worst_pin_delay );
+    }
+    return worst_delay;
+  }
+
+  bool compare_sizes( composed_gate<NInputs> const& s1, composed_gate<NInputs> const& s2 )
+  {
+    if ( s1.area < s2.area )
+      return true;
+    else if ( s1.area > s2.area )
+      return false;
+
+    /* compute average pin delay */
+    float s1_delay = 0, s2_delay = 0;
+    assert( s1.num_vars == s2.num_vars );
+    for ( uint32_t i = 0; i < s1.num_vars; ++i )
+    {
+      s1_delay += s1.tdelay[i];
+      s2_delay += s2.tdelay[i];
+    }
+
+    if ( s1_delay < s2_delay )
+      return true;
+    else if ( s1_delay > s2_delay )
+      return false;
+    else if ( s1.root->name < s2.root->name )
+      return true;
+
+    return false;
+  }
+
+  void filter_gates( std::deque<composed_gate<NInputs>> const& supergates, std::vector<bool>& skip_gates )
+  {
+    assert( supergates.size() >= skip_gates.size() );
+    for ( uint32_t i = 0; i < skip_gates.size() - 1; ++i )
+    {
+      if ( supergates[i].root == nullptr )
+        continue;
+
+      if ( skip_gates[i] )
+        continue;
+
+      auto const& tti = supergates[i].function;
+      for ( uint32_t j = i + 1; j < skip_gates.size(); ++j )
+      {
+        auto const& ttj = supergates[j].function;
+
+        /* get the same functionality */
+        if ( skip_gates[j] || tti != ttj )
+          continue;
+
+        if ( _ps.load_minimum_size_only )
+        {
+          if ( compare_sizes( supergates[i], supergates[j] ) )
+          {
+            skip_gates[j] = true;
+            continue;
+          }
+          else
+          {
+            skip_gates[i] = true;
+            break;
+          }
+        }
+
+        /* is i smaller than j */
+        bool smaller = supergates[i].area <= supergates[j].area;
+
+        /* is i faster for every pin */
+        bool faster = true;
+        for ( uint32_t k = 0; k < tti.num_vars(); ++k )
+        {
+          if ( supergates[i].tdelay[k] > supergates[j].tdelay[k] )
+            faster = false;
+        }
+
+        if ( smaller && faster )
+        {
+          skip_gates[j] = true;
+          continue;
+        }
+
+        /* is j faster for every pin */
+        smaller = supergates[i].area >= supergates[j].area;
+        faster = true;
+        for ( uint32_t k = 0; k < tti.num_vars(); ++k )
+        {
+          if ( supergates[j].tdelay[k] > supergates[i].tdelay[k] )
+            faster = false;
+        }
+
+        if ( smaller && faster )
+        {
+          skip_gates[i] = true;
+          break;
+        }
+      }
+    }
+  }
+
+private:
+  /* inverter info */
+  float _inv_area{ 0.0 };
+  float _inv_delay{ 0.0 };
+  uint32_t _inv_id{ UINT32_MAX };
+
+  /* buffer info */
+  float _buf_area{ 0.0 };
+  float _buf_delay{ 0.0 };
+  uint32_t _buf_id{ UINT32_MAX };
+
+  unsigned _max_size{ 0 }; /* max #fanins of the gates in the library */
+
+  bool _use_supergates;
+
+  std::vector<gate> const _gates;    /* collection of gates */
+  super_lib const _supergates_spec;  /* collection of supergates declarations */
+  tech_library_params const _ps;
+
+  std::vector<standard_cell> const _cells; /* collection of standard cells */
+
+  super_utils<NInputs> _super;     /* supergates generation */
+  struct_library<NInputs> _struct; /* library for structural matching */
+  lib_t _super_lib;                /* library of enumerated gates */
+  multi_lib_t _multi_lib;          /* library of enumerated multioutput gates */
+  multi_func_t _multi_funcs;       /* enumerated functions for multioutput gates */
+  struct_lib_t _struct_lib;        /* library of gates for patterns IDs */
+};                                 /* class tech_library */
+
+template<typename Ntk, unsigned NInputs>
+struct exact_supergate
+{
+  signal<Ntk> root;
+
+  /* number of inputs of the supergate */
+  uint8_t n_inputs{ 0 };
+  /* saved polarities for inputs and/or outputs */
+  uint8_t polarity{ 0 };
+
+  /* area */
+  float area{ 0 };
+  /* worst delay */
+  float worstDelay{ 0 };
+  /* pin-to-pin delay */
+  std::array<float, NInputs> tdelay{ 0 };
+
+  exact_supergate( signal<Ntk> const root )
+      : root( root ) {}
+};
+
+struct exact_library_params
+{
+  /* area of a gate */
+  float area_gate{ 1.0f };
+  /* area of an inverter */
+  float area_inverter{ 0.0f };
+  /* delay of a gate */
+  float delay_gate{ 1.0f };
+  /* delay of an inverter */
+  float delay_inverter{ 0.0f };
+
+  /* classify in NP instead of NPN */
+  bool np_classification{ false };
+  /* Compute DC classes for matching with  don't cares */
+  bool compute_dc_classes{ false };
+  /* verbose */
+  bool verbose{ false };
+};
+
+/*! \brief Library of graph structures for Boolean matching
+ *
+ * This class creates a technology library from a database
+ * of structures classified in NPN classes. Each NPN-entry in
+ * the database is stored in its NP class by removing the output
+ * inverter if present. The class creates supergates from the
+ * database computing area and delay information.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      mockturtle::mig_npn_resynthesis mig_resyn{ true };
+      mockturtle::exact_library<mockturtle::mig_network> lib( mig_resyn );
+   \endverbatim
+ */
+template<typename Ntk, unsigned NInputs = 4u>
+class exact_library
+{
+  using supergates_list_t = std::vector<exact_supergate<Ntk, NInputs>>;
+  using TT = kitty::static_truth_table<NInputs>;
+  using tt_hash = kitty::hash<TT>;
+  using lib_t = std::unordered_map<TT, supergates_list_t, tt_hash>;
+  using dc_transformation_t = std::tuple<supergates_list_t const*, uint32_t, std::array<uint8_t, NInputs>>;
+  using dc_t = std::pair<TT, dc_transformation_t>;
+  using dc_lib_t = std::unordered_map<TT, std::vector<dc_t>, tt_hash>;
+
+public:
+  explicit exact_library( exact_library_params const& ps = {} )
+      : _database(),
+        _ps( ps ),
+        _super_lib(),
+        _dc_lib()
+  {
+    _super_lib.reserve( 222 );
+  }
+
+  template<class RewritingFn>
+  explicit exact_library( RewritingFn const& rewriting_fn, exact_library_params const& ps = {} )
+      : _database(),
+        _ps( ps ),
+        _super_lib(),
+        _dc_lib()
+  {
+    _super_lib.reserve( 222 );
+    generate_library( rewriting_fn );
+  }
+
+  template<class RewritingFn>
+  void add_library( RewritingFn const& rewriting_fn )
+  {
+    generate_library( rewriting_fn );
+  }
+
+  /*! \brief Get the structures matching the function.
+   *
+   * Returns a list of graph structures that match the function
+   * represented by the truth table.
+   */
+  const supergates_list_t* get_supergates( TT const& tt ) const
+  {
+    auto match = _super_lib.find( tt );
+    if ( match != _super_lib.end() )
+      return &match->second;
+    return nullptr;
+  }
+
+  /*! \brief Get the structures matching the function with DC.
+   *
+   * Returns a list of graph structures that match the function
+   * represented by the truth table and its dont care set.
+   * This functions also updates the phase and permutation vector
+   * of the original NPN class to the new one obtained using
+   * don't cares.
+   */
+  const supergates_list_t* get_supergates( TT const& tt, TT const& dc, uint32_t& phase, std::vector<uint8_t>& perm ) const
+  {
+    auto match = _super_lib.find( tt );
+    if ( match == _super_lib.end() )
+      return nullptr;
+
+    /* lookup for don't care optimization */
+    auto match_dc = _dc_lib.find( tt );
+    if ( dc._bits == 0 || match_dc == _dc_lib.end() )
+      return &match->second;
+
+    for ( auto const& entry : match_dc->second )
+    {
+      auto const& dc_entry_tt = std::get<0>( entry );
+
+      /* check for containment */
+      if ( ( dc & dc_entry_tt ) == dc_entry_tt )
+      {
+        auto const& dc_entry = std::get<1>( entry );
+
+        /* update phase and perm */
+        uint32_t dc_entry_phase = std::get<1>( dc_entry );
+        auto const& dc_entry_perm = std::get<2>( dc_entry );
+        std::vector<uint8_t> temp_perm( perm.size() );
+        uint32_t temp_phase = dc_entry_phase & ( 1 << NInputs );
+        for ( auto i = 0u; i < NInputs; ++i )
+        {
+          temp_perm[dc_entry_perm[i]] = perm[i];
+          temp_phase |= ( ( dc_entry_phase >> i ) & 1 ) << perm[i];
+        }
+        phase ^= temp_phase;
+        std::copy( temp_perm.begin(), temp_perm.end(), perm.begin() );
+        return std::get<0>( dc_entry );
+      }
+    }
+
+    /* no dont care optimization found */
+    return &match->second;
+  }
+
+  /*! \brief Returns the NPN database of structures. */
+  Ntk& get_database()
+  {
+    return _database;
+  }
+
+  /*! \brief Returns the NPN database of structures. */
+  const Ntk& get_database() const
+  {
+    return _database;
+  }
+
+  /*! \brief Get inverter information.
+   *
+   * Returns area, and delay cost of the inverter.
+   */
+  const std::tuple<float, float> get_inverter_info() const
+  {
+    return std::make_pair( _ps.area_inverter, _ps.delay_inverter );
+  }
+
+private:
+  template<class RewritingFn>
+  void generate_library( RewritingFn const& rewriting_fn )
+  {
+    std::vector<signal<Ntk>> pis;
+    for ( auto i = 0u; i < NInputs; ++i )
+    {
+      pis.push_back( _database.create_pi() );
+    }
+
+    /* Compute NPN classes */
+    std::unordered_set<TT, tt_hash> classes;
+    TT tt;
+    do
+    {
+      const auto res = kitty::exact_npn_canonization( tt );
+      classes.insert( std::get<0>( res ) );
+      kitty::next_inplace( tt );
+    } while ( !kitty::is_const0( tt ) );
+
+    /* Constuct supergates */
+    for ( auto const& entry : classes )
+    {
+      supergates_list_t supergates_pos;
+      supergates_list_t supergates_neg;
+      auto const not_entry = ~entry;
+
+      const auto add_supergate = [&]( auto const& f_new ) {
+        bool complemented = _database.is_complemented( f_new );
+        auto f = f_new;
+        if ( _ps.np_classification && complemented )
+        {
+          f = !f;
+        }
+        exact_supergate<Ntk, NInputs> sg( f );
+        compute_info( sg );
+        if ( _ps.np_classification && complemented )
+        {
+          supergates_neg.push_back( sg );
+        }
+        else
+        {
+          supergates_pos.push_back( sg );
+        }
+        _database.create_po( f );
+        return true;
+      };
+
+      kitty::dynamic_truth_table function = kitty::extend_to( entry, NInputs );
+      rewriting_fn( _database, function, pis.begin(), pis.end(), add_supergate );
+      if ( supergates_pos.size() > 0 )
+      {
+        std::stable_sort( supergates_pos.begin(), supergates_pos.end(), [&]( auto const& a, auto const& b ) {
+          return a.area < b.area;
+        } );
+        _super_lib.insert( { entry, supergates_pos } );
+      }
+      if ( _ps.np_classification && supergates_neg.size() > 0 )
+      {
+        std::stable_sort( supergates_neg.begin(), supergates_neg.end(), [&]( auto const& a, auto const& b ) {
+          return a.area < b.area;
+        } );
+        _super_lib.insert( { not_entry, supergates_neg } );
+      }
+    }
+
+    if ( _ps.compute_dc_classes )
+      compute_dont_cares_classes();
+
+    if ( _ps.verbose )
+    {
+      std::cout << "Classified in " << _super_lib.size() << " entries" << std::endl;
+      for ( auto const& pair : _super_lib )
+      {
+        kitty::print_hex( pair.first );
+        std::cout << ": ";
+
+        for ( auto const& gate : pair.second )
+        {
+          printf( "%.2f,%.2f,%x,%d,:", gate.worstDelay, gate.area, gate.polarity, gate.n_inputs );
+          for ( auto j = 0u; j < NInputs; ++j )
+            printf( "%.2f/", gate.tdelay[j] );
+          std::cout << " ";
+        }
+        std::cout << std::endl;
+      }
+    }
+  }
+
+  /* Computes delay and area info */
+  void compute_info( exact_supergate<Ntk, NInputs>& sg )
+  {
+    _database.incr_trav_id();
+    /* info does not consider input and output inverters */
+    bool compl_root = _database.is_complemented( sg.root );
+    auto const root = compl_root ? !sg.root : sg.root;
+    sg.area = compute_info_rec( sg, root, 0.0f );
+
+    /* output polarity */
+    sg.polarity |= ( unsigned( compl_root ) ) << NInputs;
+    /* number of inputs */
+    for ( auto i = 0u; i < NInputs; ++i )
+    {
+      sg.tdelay[i] *= -1; /* invert to positive value */
+      if ( sg.tdelay[i] != 0.0f )
+        sg.n_inputs++;
+    }
+    sg.worstDelay *= -1;
+  }
+
+  float compute_info_rec( exact_supergate<Ntk, NInputs>& sg, signal<Ntk> const& root, float delay )
+  {
+    auto n = _database.get_node( root );
+
+    if ( _database.is_constant( n ) )
+      return 0.0f;
+
+    float area = 0.0f;
+    float tdelay = delay;
+
+    if ( _database.is_pi( n ) )
+    {
+      sg.tdelay[_database.index_to_node( n ) - 1u] = std::min( sg.tdelay[_database.index_to_node( n ) - 1u], tdelay );
+      sg.worstDelay = std::min( sg.worstDelay, tdelay );
+      sg.polarity |= ( unsigned( _database.is_complemented( root ) ) ) << ( _database.index_to_node( n ) - 1u );
+      return area;
+    }
+
+    tdelay -= _ps.delay_gate;
+
+    /* add gate area once */
+    if ( _database.visited( n ) != _database.trav_id() )
+    {
+      area += _ps.area_gate;
+      _database.set_value( n, 0u );
+      _database.set_visited( n, _database.trav_id() );
+    }
+
+    if ( _database.is_complemented( root ) )
+    {
+      tdelay -= _ps.delay_inverter;
+      /* add inverter area only once (shared by fanout) */
+      if ( _database.value( n ) == 0u )
+      {
+        area += _ps.area_inverter;
+        _database.set_value( n, 1u );
+      }
+    }
+
+    _database.foreach_fanin( n, [&]( auto const& child ) {
+      area += compute_info_rec( sg, child, tdelay );
+    } );
+
+    return area;
+  }
+
+  void compute_dont_cares_classes()
+  {
+    _dc_lib.clear();
+
+    /* save the size for each NPN class */
+    std::unordered_map<TT, uint32_t, tt_hash> class_sizes;
+    for ( auto const& entry : _super_lib )
+    {
+      const unsigned numgates = static_cast<unsigned>( std::get<1>( entry ).front().area );
+      class_sizes.insert( { std::get<0>( entry ), numgates } );
+    }
+
+    uint32_t conflict_found = 0;
+    uint32_t total_exploration = 0;
+
+    /* find don't care links */
+    for ( auto entry_i = class_sizes.begin(); entry_i != class_sizes.end(); ++entry_i )
+    {
+      auto const& tt_i = std::get<0>( *entry_i );
+      auto const current_size = std::get<1>( *entry_i );
+
+      /* use a map to link the dont cares to the new size, NPN class, negations, and permutation vector */
+      using dc_transf_t = std::tuple<uint32_t, TT, uint32_t, std::vector<uint8_t>>;
+      std::unordered_map<TT, dc_transf_t, tt_hash> dc_sets;
+
+      for ( auto entry_j = class_sizes.begin(); entry_j != class_sizes.end(); ++entry_j )
+      {
+        auto const& tt_j = std::get<0>( *entry_j );
+        uint32_t size = std::get<1>( *entry_j );
+
+        /* evaluate DC only for size improvement */
+        if ( size >= current_size )
+          continue;
+
+        /* skip the same NPN class if gates are constructed in NP classes */
+        if ( _ps.np_classification && tt_i == ~tt_j )
+          continue;
+
+        exact_npn_enumeration( tt_j, [&]( auto const& tt, uint32_t phase, std::vector<uint8_t> const& perm ) {
+          /* extract the DC set */
+          const auto dc = tt_i ^ tt;
+
+          /* limit the explosion of DC combinations to evaluate */
+          // if ( kitty::count_ones( dc ) > 3 )
+          //   return;
+
+          ++total_exploration;
+
+          /* check existance: filters ~12% of conflicts */
+          if ( auto const& p = dc_sets.find( dc ); p != dc_sets.end() )
+          {
+            if ( size < std::get<0>( std::get<1>( *p ) ) )
+              dc_sets[dc] = std::make_tuple( size, tt_j, phase, perm );
+
+            ++conflict_found;
+            return;
+          }
+
+          /* check dominance */
+          auto it = dc_sets.begin();
+          while ( it != dc_sets.end() )
+          {
+            auto const& dc_set_tt = std::get<0>( *it );
+            auto const& and_tt = dc_set_tt & dc;
+
+            if ( dc_set_tt == and_tt && std::get<0>( std::get<1>( *it ) ) <= size )
+            {
+              return;
+            }
+            else if ( dc == and_tt && size <= std::get<0>( std::get<1>( *it ) ) )
+            {
+              it = dc_sets.erase( it );
+            }
+            else
+            {
+              ++it;
+            }
+          }
+
+          /* permute phase */
+          uint32_t phase_perm = phase & ( 1 << NInputs );
+          for ( auto i = 0u; i < NInputs; ++i )
+          {
+            phase_perm |= ( ( phase >> perm[i] ) & 1 ) << i;
+          }
+
+          /* insert in the dc_sets */
+          dc_sets[dc] = std::make_tuple( size, tt_j, phase_perm, perm );
+        } );
+      }
+
+      /* add entries to the main data structure */
+      std::vector<dc_t> dc_transformations;
+      dc_transformations.reserve( dc_sets.size() );
+
+      std::array<uint8_t, NInputs> permutation;
+
+      /* insert in a sorted way based on gain */
+      /* TODO: optimize to reduce the number of cycles */
+      for ( auto i = 0u; i < std::get<1>( *entry_i ); ++i )
+      {
+        for ( auto const& dc : dc_sets )
+        {
+          auto const& transf = std::get<1>( dc );
+
+          if ( std::get<0>( transf ) != i )
+          {
+            continue;
+          }
+
+          supergates_list_t const* sg = &_super_lib[std::get<1>( transf )];
+          auto const& perm = std::get<3>( transf );
+
+          assert( perm.size() == NInputs );
+
+          for ( auto j = 0u; j < NInputs; ++j )
+          {
+            permutation[j] = perm[j];
+          }
+
+          dc_transformations.emplace_back( std::make_pair( std::get<0>( dc ), std::make_tuple( sg, std::get<2>( transf ), permutation ) ) );
+        }
+      }
+
+      if ( !dc_transformations.empty() )
+        _dc_lib.insert( { tt_i, dc_transformations } );
+    }
+  }
+
+private:
+  Ntk _database;
+  exact_library_params const _ps;
+  lib_t _super_lib;
+  dc_lib_t _dc_lib;
+}; /* class exact_library */
+
+} // namespace mockturtle
diff --git a/include/mockturtle/utils/truth_table_cache.hpp b/include/mockturtle/utils/truth_table_cache.hpp
new file mode 100644
index 0000000..2224e18
--- /dev/null
+++ b/include/mockturtle/utils/truth_table_cache.hpp
@@ -0,0 +1,172 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file truth_table_cache.hpp
+  \brief Truth table cache
+
+  \author Alessandro Tempia Calvino
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <vector>
+
+#include <kitty/hash.hpp>
+#include <kitty/operations.hpp>
+#include <kitty/operators.hpp>
+
+#include <parallel_hashmap/phmap.h>
+
+namespace mockturtle
+{
+
+/*! \brief Truth table cache.
+ *
+ * A truth table cache is used to store truth tables.  Many applications
+ * require to assign truth tables to nodes in a network.  But since the truth
+ * tables often repeat, it is more convenient to store an index to a cache
+ * that stores the truth table.  In order to reduce space, only one entry for
+ * a truth table and its complement are stored in the cache.  To distinguish
+ * between both versions, the index to an entry in the truth table cache is
+ * represented as literal.  The truth table whose function maps the input
+ * assignment \f$0, \dots, 0\f$ to \f$0\f$ is considered the *normal* truth
+ * table, while its complement is considered the complemented version.  Only
+ * the normal truth table is stored at some index \f$i\f$.  A positive literal
+ * \f$2i\f$ points to the normal truth table at index \f$i\f$.  A negative
+ * literal \f$2i + 1\f$ points to the same truth table but returns its
+ * complement.
+ *
+   \verbatim embed:rst
+
+   Example
+
+   .. code-block:: c++
+
+      truth_table_cache cache;
+
+      kitty::dynamic_truth_table maj( 3 );
+      kitty::create_majority( maj );
+      auto l1 = cache.insert( maj );  // index is 0
+
+      auto tt = cache[l1 ^ 1]; // tt is ~maj
+      auto l2 = cache.insert( tt ); // index is 1
+
+      auto s = cache.size(); // size is 1
+   \endverbatim
+ */
+template<typename TT>
+class truth_table_cache
+{
+public:
+  /*! \brief Creates a truth table cache and reserves memory. */
+  truth_table_cache( uint32_t capacity = 1000u );
+
+  /*! \brief Inserts a truth table and returns a literal.
+   *
+   * To save space, only normal functions are stored in the truth table cache.
+   * A function is normal, if the input pattern \f$0, \dots, 0\f$ maps to
+   * \f$0\f$.  If a function is not normal, its complement is inserted into the
+   * cache and a negative literal is returned.
+   *
+   * The default convention for literals is assumed.  That is an index \f$i\f$
+   * (starting) from \f$0\f$ has positive literal \f$2i\f$ and negative literal
+   * \f$2i + 1\f$.
+   *
+   * \param tt Truth table to insert
+   * \return Literal of position in cache
+   */
+  uint32_t insert( TT tt );
+
+  /*! \brief Returns truth table for a given literal.
+   *
+   * The function requires that `lit` is smaller than `size()`.
+   */
+  TT operator[]( uint32_t lit ) const;
+
+  /*! \brief Returns number of normalized truth tables in the cache. */
+  auto size() const { return _data.size(); }
+
+  /*! \brief Resizes the cache.
+   *
+   * Reserve additional space for cache and data.
+   */
+  void resize( uint32_t capacity );
+
+private:
+  phmap::flat_hash_map<TT, uint32_t, kitty::hash<TT>> _indexes;
+  std::vector<TT> _data;
+};
+
+template<typename TT>
+truth_table_cache<TT>::truth_table_cache( uint32_t capacity )
+{
+  _indexes.reserve( capacity );
+  _data.reserve( capacity );
+}
+
+template<typename TT>
+uint32_t truth_table_cache<TT>::insert( TT tt )
+{
+  uint32_t is_compl{ 0 };
+
+  if ( kitty::get_bit( tt, 0 ) )
+  {
+    is_compl = 1;
+    tt = ~tt;
+  }
+
+  /* is truth table already in cache? */
+  const auto it = _indexes.find( tt );
+  if ( it != _indexes.end() )
+  {
+    return static_cast<uint32_t>( 2 * it->second + is_compl );
+  }
+
+  /* add truth table to end of cache */
+  const auto size = _data.size();
+  const auto index = static_cast<uint32_t>( 2 * size + is_compl );
+  _data.push_back( tt );
+  _indexes[tt] = static_cast<unsigned int>( size );
+  return index;
+}
+
+template<typename TT>
+TT truth_table_cache<TT>::operator[]( uint32_t index ) const
+{
+  auto& entry = _data[index >> 1];
+  return ( index & 1 ) ? ~entry : entry;
+}
+
+template<typename TT>
+void truth_table_cache<TT>::resize( uint32_t capacity )
+{
+  _indexes.reserve( capacity );
+  _data.reserve( capacity );
+}
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/utils/truth_table_utils.hpp b/include/mockturtle/utils/truth_table_utils.hpp
new file mode 100644
index 0000000..2a0d4fb
--- /dev/null
+++ b/include/mockturtle/utils/truth_table_utils.hpp
@@ -0,0 +1,63 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file truth_table_utils.hpp
+  \brief Truth table manipulation utils
+
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <kitty/kitty.hpp>
+
+namespace mockturtle
+{
+
+/*! \brief Replacement rule of MAJ3
+ *
+ * Given a majority gate with fanin functions `fanin0`, `fanin1` and `fanin2`,
+ * check if the first fanin `fanin0` can be replaced by `replacement`
+ * without changing the output function of the majority gate.
+ *
+ * By the replacement rule, `<x, y, z> = <w, y, z>` if and only if
+ * `(x ^ w)(y ^ z) = 0`, i.e., `y != z` implies `w = x`.
+ *
+ * This check is used in relevance optimization in MIG resubstitution.
+ *
+ * \param fanin0 Truth table of the first fanin function; also the fanin to be replaced.
+ * \param fanin1 Truth table of the second fanin function.
+ * \param fanin2 Truth table of the third fanin function.
+ * \param replacement Truth table of the candidate to replace `fanin0`.
+ * \return `<fanin0, fanin1, fanin2> = <replacement, fanin1, fanin2>`
+ */
+template<typename TT, typename = std::enable_if_t<kitty::is_truth_table<TT>::value>>
+bool can_replace_majority_fanin( TT const& fanin0, TT const& fanin1, TT const& fanin2, TT const& replacement )
+{
+  return kitty::is_const0( ( ( fanin0 ^ replacement ) & ( fanin1 ^ fanin2 ) ) );
+}
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/utils/window_utils.hpp b/include/mockturtle/utils/window_utils.hpp
new file mode 100644
index 0000000..6fce12d
--- /dev/null
+++ b/include/mockturtle/utils/window_utils.hpp
@@ -0,0 +1,1046 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file window_utils.hpp
+  \brief Utilities to collect small-scale sets of nodes
+
+  \author Heinz Riener
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <optional>
+#include <set>
+#include <type_traits>
+#include <vector>
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+template<typename Ntk>
+inline void collect_nodes_recur( Ntk const& ntk, typename Ntk::node const& n, std::vector<typename Ntk::node>& nodes )
+{
+  using signal = typename Ntk::signal;
+
+  if ( ntk.eval_color( n, [&]( auto c ) { return c == ntk.current_color(); } ) )
+  {
+    return;
+  }
+  ntk.paint( n );
+
+  ntk.foreach_fanin( n, [&]( signal const& fi ) {
+    if ( ntk.is_constant( ntk.get_node( fi ) ) )
+      return;
+    collect_nodes_recur( ntk, ntk.get_node( fi ), nodes );
+  } );
+  nodes.push_back( n );
+}
+
+} /* namespace detail */
+
+/*! \brief Collect nodes in between of two node sets
+ *
+ * \param ntk A network
+ * \param inputs A node set
+ * \param outputs A signal set
+ * \return Nodes enclosed by inputs and outputs
+ *
+ * The output set has to be chosen in a way such that every path from
+ * PIs to outputs passes through at least one input.
+ *
+ * Uses a new color.
+ *
+ * **Required network functions:**
+ * - `current_color`
+ * - `eval_color`
+ * - `foreach_fanin`
+ * - `get_node`
+ * - `new_color`
+ * - `paint`
+ */
+template<typename Ntk, typename = std::enable_if_t<!std::is_same_v<typename Ntk::signal, typename Ntk::node>>>
+inline std::vector<typename Ntk::node> collect_nodes( Ntk const& ntk,
+                                                      std::vector<typename Ntk::node> const& inputs,
+                                                      std::vector<typename Ntk::signal> const& outputs )
+{
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  /* convert output signals to nodes */
+  std::vector<node> _outputs;
+  std::transform( std::begin( outputs ), std::end( outputs ), std::back_inserter( _outputs ),
+                  [&ntk]( signal const& s ) {
+                    return ntk.get_node( s );
+                  } );
+  return collect_nodes( ntk, inputs, _outputs );
+}
+
+/*! \brief Collect nodes in between of two node sets
+ *
+ * \param ntk A network
+ * \param inputs A node set
+ * \param outputs A node set
+ * \return Nodes enclosed by inputs and outputs
+ *
+ * The output set has to be chosen in a way such that every path from
+ * PIs to outputs passes through at least one input.
+ *
+ * Uses a new color.
+ *
+ * **Required network functions:**
+ * - `current_color`
+ * - `eval_color`
+ * - `foreach_fanin`
+ * - `get_node`
+ * - `new_color`
+ * - `paint`
+ */
+template<typename Ntk>
+inline std::vector<typename Ntk::node> collect_nodes( Ntk const& ntk,
+                                                      std::vector<typename Ntk::node> const& inputs,
+                                                      std::vector<typename Ntk::node> const& outputs )
+{
+  using node = typename Ntk::node;
+
+  ntk.new_color();
+
+  /* mark inputs visited */
+  for ( auto const& i : inputs )
+  {
+    if ( ntk.eval_color( i, [&]( auto c ) { return c == ntk.current_color(); } ) )
+    {
+      continue;
+    }
+    ntk.paint( i );
+  }
+
+  /* recursively collect all nodes in between inputs and outputs */
+  std::vector<node> nodes;
+  for ( auto const& o : outputs )
+  {
+    detail::collect_nodes_recur( ntk, o, nodes );
+  }
+  return nodes;
+}
+
+/*! \brief Identify inputs using reference counting
+ *
+ * Uses a new_color and marks all nodes and inputs.
+ *
+ * **Required network functions:**
+ * - `current_color`
+ * - `eval_color`
+ * - `foreach_fanin`
+ * - `get_node`
+ * - `new_color`
+ * - `paint`
+ */
+template<typename Ntk>
+std::vector<typename Ntk::node> collect_inputs( Ntk const& ntk, std::vector<typename Ntk::node> const& nodes )
+{
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  /* mark all nodes with a new color */
+  ntk.new_color();
+  for ( const auto& n : nodes )
+  {
+    ntk.paint( n );
+  }
+
+  /* if a fanin is not colored, then it's an input */
+  std::vector<node> inputs;
+  for ( const auto& n : nodes )
+  {
+    ntk.foreach_fanin( n, [&]( signal const& fi ) {
+      node const i = ntk.get_node( fi );
+      if ( ntk.eval_color( i, [&ntk]( auto c ) { return c != ntk.current_color(); } ) )
+      {
+        if ( std::find( std::begin( inputs ), std::end( inputs ), i ) == std::end( inputs ) )
+        {
+          inputs.push_back( i );
+        }
+      }
+      return true;
+    } );
+  }
+
+  /* mark all inputs */
+  for ( const auto& n : inputs )
+  {
+    ntk.paint( n );
+  }
+
+  return inputs;
+}
+
+/*! \brief Identify outputs using reference counting
+ *
+ * Identify outputs using a reference counting approach.  The
+ * algorithm counts the references of the fanins of all nodes and
+ * compares them with the fanout_sizes of the respective nodes.  If
+ * reference count and fanout_size do not match, then the node is
+ * references outside of the node set and the respective is identified
+ * as an output.
+ *
+ * \param ntk A network
+ * \param inputs Inputs of a window
+ * \param nodes Inner nodes of a window (i.e., the intersection of
+ *              inputs and nodes is assumed to be empty)
+ * \param refs Reference counters (in the size of the network and
+ *             initialized to 0)
+ * \return Output signals of the window
+ *
+ * **Required network functions:**
+ * - `current_color`
+ * - `eval_color`
+ * - `fanout_size`
+ * - `foreach_fanin`
+ * - `get_node`
+ * - `is_ci`
+ * - `is_constant`
+ * - `make_signal`
+ */
+template<typename Ntk>
+inline std::vector<typename Ntk::signal> collect_outputs( Ntk const& ntk,
+                                                          std::vector<typename Ntk::node> const& inputs,
+                                                          std::vector<typename Ntk::node> const& nodes,
+                                                          std::vector<uint32_t>& refs )
+{
+  using signal = typename Ntk::signal;
+
+  std::vector<signal> outputs;
+
+  /* mark the inputs visited */
+  ntk.new_color();
+  for ( auto const& i : inputs )
+  {
+    ntk.paint( i );
+  }
+
+  /* reference fanins of nodes */
+  for ( auto const& n : nodes )
+  {
+    if ( ntk.eval_color( n, [&ntk]( auto c ) { return c == ntk.current_color(); } ) )
+    {
+      continue;
+    }
+
+    assert( !ntk.is_constant( n ) && !ntk.is_ci( n ) );
+    ntk.foreach_fanin( n, [&]( signal const& fi ) {
+      refs[ntk.get_node( fi )] += 1;
+    } );
+  }
+
+  /* if the fanout_size of a node does not match the reference count,
+     the node has fanouts outside of the window is an output */
+  for ( const auto& n : nodes )
+  {
+    if ( ntk.eval_color( n, [&ntk]( auto c ) { return c == ntk.current_color(); } ) )
+    {
+      continue;
+    }
+
+    if ( ntk.fanout_size( n ) != refs[n] )
+    {
+      outputs.emplace_back( ntk.make_signal( n ) );
+    }
+  }
+
+  /* dereference fanins of nodes */
+  for ( auto const& n : nodes )
+  {
+    if ( ntk.eval_color( n, [&ntk]( auto c ) { return c == ntk.current_color(); } ) )
+    {
+      continue;
+    }
+
+    assert( !ntk.is_constant( n ) && !ntk.is_ci( n ) );
+    ntk.foreach_fanin( n, [&]( signal const& fi ) {
+      refs[ntk.get_node( fi )] -= 1;
+    } );
+  }
+
+  return outputs;
+}
+
+namespace detail
+{
+
+template<typename Ntk>
+inline bool cut_is_trivial( Ntk const& ntk, std::vector<typename Ntk::node> const& inputs )
+{
+  for ( const auto& n : inputs )
+  {
+    if ( !ntk.is_constant( n ) && !ntk.is_ci( n ) )
+    {
+      return false;
+    }
+  }
+  return true;
+}
+
+} // namespace detail
+
+/*! \brief Performs in-place zero-cost expansion of a set of nodes towards TFI
+ *
+ * The algorithm attempts to derive a different cut of the same size
+ * that is closer to the network's PIs.  This expansion towards TFI is
+ * called zero-cost because it merges nodes only if the number of
+ * inputs does not increase.
+ *
+ * Precondition: This procedure presumes that nodes and inputs are
+ * painted in the current color.
+ *
+ * Uses the current color to mark nodes.  Only nodes not painted with
+ * the current color are considered for expanding the cut.  Nodes
+ * marked are considered already in the cut.
+ *
+ * \param ntk A network
+ * \param inputs Input nodes
+ * \return True if and only if the inputs form a trivial cut that
+ *         cannot be further extended, e.g., when the cut only
+ *         consists of PIs.
+ *
+ * **Required network functions:**
+ * - `current_color`
+ * - `eval_color`
+ * - `foreach_fanin`
+ * - `get_node`
+ * - `paint`
+ * - `size`
+ */
+template<typename Ntk>
+bool expand0_towards_tfi( Ntk const& ntk, std::vector<typename Ntk::node>& inputs )
+{
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  /* we call a set of inputs (= a cut) trivial if all nodes are either
+     constants or CIs, such that they cannot be further expanded towards
+     the TFI */
+  bool trivial_cut{ true };
+
+  /* repeat expansion towards TFI until a fix-point is reached */
+  bool changed{ true };
+  std::vector<node> new_inputs;
+  while ( changed )
+  {
+    trivial_cut = true;
+    changed = false;
+
+    for ( auto it = std::begin( inputs ); it != std::end( inputs ); )
+    {
+      assert( ntk.color( *it ) == ntk.current_color() );
+      if ( ntk.is_constant( *it ) || ntk.is_ci( *it ) )
+      {
+        ++it;
+        continue;
+      }
+      trivial_cut = false;
+
+      /* count how many fanins are already in the cut */
+      uint32_t count_fanin_outside{ 0 };
+      std::optional<node> ep;
+      ntk.foreach_fanin( *it, [&]( signal const& fi ) {
+        node const n = ntk.get_node( fi );
+        if ( ntk.eval_color( n, [&ntk]( auto c ) { return c == ntk.current_color(); } ) )
+        {
+          ++count_fanin_outside;
+        }
+        else
+        {
+          ep = n;
+        }
+      } );
+
+      /* if the expansion is not cost-free, then proceeded with the next leaf */
+      if ( count_fanin_outside + 1 < ntk.fanin_size( *it ) )
+      {
+        ++it;
+        continue;
+      }
+
+      if ( ep )
+      {
+        if ( ntk.eval_color( *ep, [&ntk]( auto c ) { return c != ntk.current_color(); } ) )
+        {
+          new_inputs.push_back( *ep );
+          ntk.paint( *ep );
+        }
+      }
+      it = inputs.erase( it );
+      changed = true;
+    }
+
+    std::copy( std::begin( new_inputs ), std::end( new_inputs ),
+               std::back_inserter( inputs ) );
+    new_inputs.clear();
+  }
+
+  assert( trivial_cut == detail::cut_is_trivial( ntk, inputs ) );
+  return trivial_cut;
+}
+
+namespace detail
+{
+
+template<typename Ntk>
+inline void evaluate_fanin( typename Ntk::node const& n, std::vector<std::pair<typename Ntk::node, uint32_t>>& candidates )
+{
+  auto it = std::find_if( std::begin( candidates ), std::end( candidates ),
+                          [&n]( auto const& p ) {
+                            return p.first == n;
+                          } );
+  if ( it == std::end( candidates ) )
+  {
+    /* new fanin: referenced for the 1st time */
+    candidates.push_back( std::make_pair( n, 1u ) );
+  }
+  else
+  {
+    /* otherwise, if not new, then just increase the reference counter */
+    ++it->second;
+  }
+}
+
+template<typename Ntk>
+inline typename Ntk::node select_next_fanin_to_expand_tfi( Ntk const& ntk, std::vector<typename Ntk::node> const& inputs )
+{
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  assert( inputs.size() > 0u && "inputs must not be empty" );
+  assert( !cut_is_trivial( ntk, inputs ) );
+
+  /* evaluate the fanins with respect to their costs (how often are they referenced?) */
+  std::vector<std::pair<node, uint32_t>> candidates;
+  for ( auto const& i : inputs )
+  {
+    if ( ntk.is_constant( i ) || ntk.is_ci( i ) )
+    {
+      continue;
+    }
+
+    ntk.foreach_fanin( i, [&]( signal const& fi ) {
+      if ( ntk.is_constant( ntk.get_node( fi ) ) )
+      {
+        return true;
+      }
+      detail::evaluate_fanin<Ntk>( ntk.get_node( fi ), candidates );
+      return true;
+    } );
+  }
+
+  assert( candidates.size() > 0u );
+
+  /* select the fanin with maximum reference count; if two fanins have equal reference count, select the one with more fanouts */
+  std::pair<node, uint32_t> best_fanin{ candidates[0] };
+  for ( auto const& candidate : candidates )
+  {
+    if ( candidate.second > best_fanin.second ||
+         ( candidate.second == best_fanin.second && ntk.fanout_size( candidate.first ) > ntk.fanout_size( best_fanin.first ) ) )
+    {
+      best_fanin = candidate;
+    }
+  }
+
+  /* as long as the inputs do not form a trivial cut, this procedure will always find a fanin to expand */
+  assert( best_fanin.first != 0 );
+
+  return best_fanin.first;
+}
+
+} /* namespace detail */
+
+/*! \brief Performs in-place expansion of a set of nodes towards TFI
+ *
+ * Expand the inputs towards TFI by iteratively selecting the fanins
+ * with the highest reference count within the cut and highest number
+ * of fanouts.  Expansion continues until either `inputs` forms a
+ * trivial cut or the `inputs`'s size reaches `input_limit`.  The
+ * procedure allows a temporary increase of `inputs` beyond the
+ * `input_limit` for at most `MAX_ITERATIONS`.
+ *
+ * Precondition: This procedure presumes that nodes and inputs are
+ * painted in the current color.
+ *
+ * Uses a new color.
+ *
+ * \param ntk A network
+ * \param inputs Input nodes
+ * \param input_limit Size limit for the maximum number of input nodes
+ */
+template<typename Ntk>
+void expand_towards_tfi( Ntk const& ntk, std::vector<typename Ntk::node>& inputs, uint32_t input_limit )
+{
+  using node = typename Ntk::node;
+
+  static constexpr uint32_t const MAX_ITERATIONS{ 5u };
+
+  if ( expand0_towards_tfi( ntk, inputs ) )
+  {
+    return;
+  }
+
+  std::optional<std::vector<node>> best_cut;
+  if ( inputs.size() <= input_limit )
+  {
+    best_cut = inputs;
+  }
+
+  bool trivial_cut = false;
+  uint32_t iterations{ 0 };
+  while ( !trivial_cut && ( inputs.size() <= input_limit || iterations < MAX_ITERATIONS ) )
+  {
+    node const n = detail::select_next_fanin_to_expand_tfi( ntk, inputs );
+    inputs.push_back( n );
+    ntk.paint( n );
+
+    trivial_cut = expand0_towards_tfi( ntk, inputs );
+    assert( trivial_cut == detail::cut_is_trivial( ntk, inputs ) );
+
+    iterations = inputs.size() > input_limit ? iterations + 1 : 0;
+    if ( inputs.size() <= input_limit &&
+         ( !best_cut || best_cut->size() <= inputs.size() ) )
+    {
+      best_cut = inputs;
+    }
+  }
+
+  if ( best_cut )
+  {
+    inputs = *best_cut;
+  }
+  else
+  {
+    assert( inputs.size() > input_limit );
+  }
+}
+
+/*! \brief Performs in-place expansion of a set of nodes towards TFO
+ *
+ * Iteratively expands the inner nodes of the window with those
+ * fanouts that are supported by the window until a fixed-point is
+ * reached.
+ *
+ * Uses a new color.
+ *
+ * \param ntk A network
+ * \param inputs Input nodes of a window
+ * \param nodes Inner nodes of a window
+ *
+ * **Required network functions:**
+ * - `current_color`
+ * - `eval_color`
+ * - `foreach_fanin`
+ * - `foreach_fanout`
+ * - `get_node`
+ * - `is_ci`
+ * - `new_color`
+ */
+template<typename Ntk>
+void expand_towards_tfo( Ntk const& ntk, std::vector<typename Ntk::node> const& inputs, std::vector<typename Ntk::node>& nodes )
+{
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  auto explore_fanouts = [&]( Ntk const& ntk, node const& n, std::set<node>& result ) {
+    ntk.foreach_fanout( n, [&]( node const& fo, uint64_t index ) {
+      /* only look at the first few fanouts */
+      if ( index > 5 )
+      {
+        return false;
+      }
+      /* skip all nodes that are already in nodes */
+      if ( ntk.eval_color( fo, [&]( auto c ) { return c == ntk.current_color(); } ) )
+      {
+        return true;
+      }
+      result.insert( fo );
+      return true;
+    } );
+  };
+
+  /* create a new traversal ID */
+  ntk.new_color();
+
+  /* mark the inputs visited */
+  std::for_each( std::begin( inputs ), std::end( inputs ),
+                 [&ntk]( node const& n ) { ntk.paint( n ); } );
+
+  /* mark the nodes visited */
+  std::for_each( std::begin( nodes ), std::end( nodes ),
+                 [&ntk]( node const& n ) { ntk.paint( n ); } );
+
+  /* collect all nodes that have fanouts not yet contained in nodes */
+  std::set<node> eps;
+  for ( const auto& i : inputs )
+  {
+    explore_fanouts( ntk, i, eps );
+  }
+  for ( const auto& n : nodes )
+  {
+    explore_fanouts( ntk, n, eps );
+  }
+
+  bool changed = true;
+  std::set<node> new_eps;
+  while ( changed )
+  {
+    new_eps.clear();
+    changed = false;
+
+    auto it = std::begin( eps );
+    while ( it != std::end( eps ) )
+    {
+      node const ep = *it;
+      if ( ntk.eval_color( ep, [&]( auto c ) { return c == ntk.current_color(); } ) )
+      {
+        it = eps.erase( it );
+        continue;
+      }
+
+      bool all_children_belong_to_window = true;
+      ntk.foreach_fanin( ep, [&]( signal const& fi ) {
+        node const child = ntk.get_node( fi );
+        if ( ntk.eval_color( child, [&]( auto c ) { return c != ntk.current_color(); } ) )
+        {
+          all_children_belong_to_window = false;
+          return false;
+        }
+        return true;
+      } );
+
+      if ( all_children_belong_to_window )
+      {
+        assert( ep != 0 );
+        assert( !ntk.is_ci( ep ) );
+        nodes.emplace_back( ep );
+        ntk.paint( ep );
+        it = eps.erase( it );
+
+        explore_fanouts( ntk, ep, new_eps );
+      }
+
+      if ( it != std::end( eps ) )
+      {
+        ++it;
+      }
+    }
+
+    if ( !new_eps.empty() )
+    {
+      eps.insert( std::begin( new_eps ), std::end( new_eps ) );
+      changed = true;
+    }
+  }
+}
+
+namespace detail
+{
+
+template<typename Ntk, bool auto_resize = true>
+void levelized_expand_towards_tfo( Ntk const& ntk, std::vector<typename Ntk::node> const& inputs, std::vector<typename Ntk::node>& nodes,
+                                   std::vector<std::vector<typename Ntk::node>>& levels )
+{
+  using node = typename Ntk::node;
+
+  static constexpr uint32_t const MAX_FANOUTS{ 5u };
+
+  ntk.new_color();
+
+  /* mapping from level to nodes (which nodes are on a certain level?) */
+  levels.resize( ntk.depth() + 1 );
+
+  /* list of indices of used levels (avoid iterating over all levels) */
+  std::vector<uint32_t> used;
+
+  /* mark all inputs and fill their level information into `levels` and `used` */
+  for ( const auto& i : inputs )
+  {
+    uint32_t const node_level = ntk.level( i );
+    ntk.paint( i );
+    if constexpr ( auto_resize )
+    {
+      if ( levels.size() <= node_level )
+      {
+        levels.resize( std::max( uint32_t( 2 * levels.size() ), node_level ) );
+      }
+    }
+    levels.at( node_level ).push_back( i );
+    if ( std::find( std::begin( used ), std::end( used ), node_level ) == std::end( used ) )
+    {
+      used.push_back( node_level );
+    }
+  }
+
+  /* mark all nodes and fill their level information into `levels` and `used` */
+  for ( const auto& n : nodes )
+  {
+    uint32_t const node_level = ntk.level( n );
+    ntk.paint( n );
+    if constexpr ( auto_resize )
+    {
+      if ( levels.size() <= node_level )
+      {
+        levels.resize( std::max( uint32_t( 2 * levels.size() ), node_level ) );
+      }
+    }
+    levels.at( node_level ).push_back( n );
+    if ( std::find( std::begin( used ), std::end( used ), node_level ) == std::end( used ) )
+    {
+      used.push_back( node_level );
+    }
+  }
+
+  std::stable_sort( std::begin( used ), std::end( used ) );
+
+  for ( uint32_t index = 0u; index < used.size(); ++index )
+  {
+    std::vector<node>& level = levels.at( used[index] );
+    for ( auto j = 0u; j < level.size(); ++j )
+    {
+      ntk.foreach_fanout( level[j], [&]( node const& fo, uint64_t index ) {
+        /* avoid getting stuck on nodes with many fanouts */
+        if ( index == MAX_FANOUTS )
+        {
+          return false;
+        }
+
+        /* ignore nodes without fanins */
+        if ( ntk.is_constant( fo ) || ntk.is_ci( fo ) )
+        {
+          return true;
+        }
+
+        if ( ntk.eval_color( fo, [&ntk]( auto c ) { return c != ntk.current_color(); } ) &&
+             ntk.eval_fanins_color( fo, [&ntk]( auto c ) { return c == ntk.current_color(); } ) )
+        {
+          /* add fanout to nodes */
+          nodes.push_back( fo );
+
+          /* update data structured */
+          uint32_t const node_level = ntk.level( fo );
+          ntk.paint( fo );
+          if constexpr ( auto_resize )
+          {
+            if ( levels.size() <= node_level )
+            {
+              levels.resize( std::max( uint32_t( 2 * levels.size() ), node_level ) );
+            }
+          }
+          levels.at( node_level ).push_back( fo );
+          if ( std::find( std::begin( used ), std::end( used ), node_level ) == std::end( used ) )
+          {
+            used.push_back( node_level );
+            std::stable_sort( std::begin( used ), std::end( used ) );
+          }
+        }
+
+        return true;
+      } );
+    }
+    level.clear();
+  }
+}
+
+} // namespace detail
+
+/*! \brief Performs in-place expansion of a set of nodes towards TFO
+ *
+ * Iteratively expands the inner nodes of the window with those
+ * fanouts that are supported by the window.  Explores the fanouts
+ * level by level.  Starting with those that are closest to the
+ * inputs.
+ *
+ * Uses a new color.
+ *
+ * \param ntk A network
+ * \param inputs Input nodes of a window
+ * \param nodes Inner nodes of a window
+ *
+ * **Required network functions:**
+ * - `current_color`
+ * - `depth`
+ * - `eval_color`
+ * - `eval_fanins_color`
+ * - `foreach_fanin`
+ * - `foreach_fanout`
+ * - `get_node`
+ * - `is_ci`
+ * - `is_constant`
+ * - `level`
+ * - `new_color`
+ * - `paint`
+ */
+template<typename Ntk, bool auto_resize = true>
+void levelized_expand_towards_tfo( Ntk const& ntk, std::vector<typename Ntk::node> const& inputs, std::vector<typename Ntk::node>& nodes )
+{
+  std::vector<std::vector<typename Ntk::node>> levels;
+  detail::levelized_expand_towards_tfo<Ntk, auto_resize>( ntk, inputs, nodes, levels );
+}
+
+namespace detail
+{
+
+template<typename Ntk>
+void cover_recursive( Ntk const& ntk, typename Ntk::node const& root, std::vector<typename Ntk::node>& nodes )
+{
+  if ( ntk.color( root ) == ntk.current_color() )
+  {
+    return;
+  }
+
+  ntk.foreach_fanin( root, [&]( auto const& fi ) {
+    cover_recursive( ntk, ntk.get_node( fi ), nodes );
+  } );
+
+  nodes.push_back( root );
+}
+
+} // namespace detail
+
+template<typename Ntk>
+std::vector<typename Ntk::node> cover( Ntk const& ntk, typename Ntk::node const& root, std::vector<typename Ntk::node> const& leaves )
+{
+  ntk.new_color();
+  for ( auto const& l : leaves )
+  {
+    ntk.paint( l );
+  }
+
+  std::vector<typename Ntk::node> nodes;
+  detail::cover_recursive( ntk, root, nodes );
+
+  /* remove duplicates */
+  std::stable_sort( std::begin( nodes ), std::end( nodes ) );
+  auto last = std::unique( std::begin( nodes ), std::end( nodes ) );
+  nodes.erase( last, std::end( nodes ) );
+
+  return nodes;
+}
+
+/*! \brief Create a (l,k)-window around a pivot.
+ *
+ * Expands a reconvergency rooted in a given pivot node `p` into a
+ * window with l inputs and k outputs.
+ *
+ * Uses a new color.
+ *
+ * **Required network functions:**
+ * - `current_color`
+ * - `depth`
+ * - `eval_color`
+ * - `eval_fanins_color`
+ * - `foreach_fanin`
+ * - `foreach_fanout`
+ * - `get_node`
+ * - `is_ci`
+ * - `is_constant`
+ * - `level`
+ * - `new_color`
+ * - `paint`
+ */
+template<typename Ntk>
+class create_window_impl
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  struct window
+  {
+    std::vector<node> inputs;
+    std::vector<node> nodes;
+    std::vector<signal> outputs;
+  };
+
+protected:
+  /* constant node used to denotes invalid window element */
+  static constexpr node INVALID_NODE{ 0 };
+
+  /* number of iterations */
+  static constexpr uint32_t NUM_ITERATIONS{ 5 };
+
+public:
+  create_window_impl( Ntk const& ntk )
+      : ntk( ntk ), path( ntk.size() ), refs( ntk.size() )
+  {
+  }
+
+  void resize( uint32_t size )
+  {
+    path.resize( size );
+    refs.resize( size );
+  }
+
+  std::optional<window> run( node const& pivot, uint32_t cut_size, uint32_t num_levels )
+  {
+    /* find a reconvergence from the pivot and collect the nodes */
+    std::optional<std::vector<node>> nodes;
+    if ( !( nodes = identify_reconvergence( pivot, num_levels ) ) )
+    {
+      /* if there is no reconvergence, then optimization is not possible */
+      return std::nullopt;
+    }
+
+    /* collect the fanins for these nodes */
+    std::vector<node> inputs = collect_inputs( ntk, *nodes );
+    if ( inputs.size() <= cut_size + 3 )
+    {
+      /* expand the nodes towards the TFI */
+      expand_towards_tfi( ntk, inputs, cut_size );
+
+      /* compute the cover of the (pivot, inputs)-cut */
+      *nodes = cover( ntk, pivot, inputs );
+
+      /* expand the nodes towards the TFO */
+      std::stable_sort( std::begin( inputs ), std::end( inputs ) );
+      detail::levelized_expand_towards_tfo( ntk, inputs, *nodes, levels );
+    }
+
+    if ( inputs.size() > cut_size || nodes->empty() )
+    {
+      return std::nullopt;
+    }
+
+    /* top. sort nodes */
+    std::stable_sort( std::begin( inputs ), std::end( inputs ) );
+    std::stable_sort( std::begin( *nodes ), std::end( *nodes ) );
+
+    /* collect the nodes with fanout outside of nodes */
+    std::vector<signal> outputs = collect_outputs( ntk, inputs, *nodes, refs );
+    assert( outputs.size() > 0u );
+
+    return window{ inputs, *nodes, outputs };
+  }
+
+protected:
+  std::optional<std::vector<node>> identify_reconvergence( node const& pivot, uint64_t num_iterations )
+  {
+    assert( !ntk.is_ci( pivot ) && !ntk.is_constant( pivot ) );
+
+    ntk.new_color();
+    visited.clear();
+    ntk.foreach_fanin( pivot, [&]( signal const& fi ) {
+      uint32_t const color = ntk.new_color();
+      node const& n = ntk.get_node( fi );
+      path[n] = INVALID_NODE;
+      visited.push_back( n );
+      ntk.paint( n, color );
+    } );
+
+    uint64_t start{ 0 };
+    uint64_t stop;
+    for ( uint32_t iteration = 0u; iteration < num_iterations; ++iteration )
+    {
+      stop = visited.size();
+      for ( uint32_t i = start; i < stop; ++i )
+      {
+        node const n = visited.at( i );
+        std::optional<node> meet = explore_frontier_of_node( n );
+        if ( meet )
+        {
+          visited.clear();
+          gather_nodes_recursively( path[*meet] );
+          gather_nodes_recursively( n );
+          visited.push_back( pivot );
+          return visited;
+        }
+      }
+      start = stop;
+    }
+
+    return std::nullopt;
+  }
+
+  std::optional<node> explore_frontier_of_node( node const& n )
+  {
+    if ( ntk.is_constant( n ) || ntk.is_ci( n ) )
+    {
+      return std::nullopt;
+    }
+
+    std::optional<node> meet;
+    ntk.foreach_fanin( n, [&]( signal const& fi ) {
+      node const& fi_node = ntk.get_node( fi );
+      if ( ntk.eval_color( n, [this]( auto c ) { return c > ntk.current_color() - ntk.max_fanin_size; } ) &&
+           ntk.eval_color( fi_node, [this]( auto c ) { return c > ntk.current_color() - ntk.max_fanin_size; } ) &&
+           ntk.eval_color( n, fi_node, []( auto c0, auto c1 ) { return c0 != c1; } ) )
+      {
+        meet = fi_node;
+        return false;
+      }
+
+      if ( ntk.eval_color( fi_node, [this]( auto c ) { return c > ntk.current_color() - ntk.max_fanin_size; } ) )
+      {
+        return true; /* next */
+      }
+
+      ntk.paint( fi_node, n );
+      path[fi_node] = n;
+      visited.push_back( fi_node );
+
+      return true; /* next */
+    } );
+
+    return meet;
+  }
+
+  /* collect nodes recursively following along the `path` until INVALID_NODE is reached */
+  void gather_nodes_recursively( node const& n )
+  {
+    if ( n == INVALID_NODE )
+    {
+      return;
+    }
+
+    visited.push_back( n );
+
+    node const pred = path[n];
+    if ( pred == INVALID_NODE )
+    {
+      return;
+    }
+
+    assert( ntk.eval_color( n, pred, []( auto c0, auto c1 ) { return c0 == c1; } ) );
+    gather_nodes_recursively( pred );
+  }
+
+protected:
+  Ntk const& ntk;
+  std::vector<node> visited;
+  std::vector<node> path;
+  std::vector<uint32_t> refs;
+  std::vector<std::vector<node>> levels;
+}; /* create_window_impl */
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/views/binding_view.hpp b/include/mockturtle/views/binding_view.hpp
new file mode 100644
index 0000000..1eb529a
--- /dev/null
+++ b/include/mockturtle/views/binding_view.hpp
@@ -0,0 +1,261 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file binding_view.hpp
+  \brief Implements methods to bind the network to a standard cell library
+
+  \author Alessandro Tempia Calvino
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../io/genlib_reader.hpp"
+#include "../utils/node_map.hpp"
+#include "../views/topo_view.hpp"
+
+#include <iostream>
+#include <map>
+
+namespace mockturtle
+{
+
+/*! \brief Adds bindings to a technology library and mapping API methods.
+ *
+ * This view adds methods to create and manage a mapped network that
+ * implements gates contained in a technology library. This view
+ * is returned by the technology mapping command `map`. It can be used
+ * to report statistics about the network and write the network into
+ * a verilog file. It always adds the functions `has_binding`,
+ * `remove_binding`, `add_binding`, `add_binding_with_check`, `get_binding`,
+ * `get_binding_index`, `get_library`, `compute_area`, `compute_worst_delay`,
+ * `report_stats`, and `report_gates_usage`.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `foreach_node`
+ * - `foreach_fanin`
+ * - `is_constant`
+ * - `is_pi`
+ *
+ * Example
+ *
+   \verbatim embed:rst
+
+   .. code-block:: c++
+
+      // create network somehow
+      aig_network aig = ...;
+
+      // read cell library in genlib format
+      std::vector<gate> gates;
+      lorina::read_genlib( "file.genlib", genlib_reader( gates ) )
+      tech_library tech_lib( gates );
+
+      // call technology mapping to obtain the view
+      binding_view<klut_network> res = map( aig, tech_lib );
+
+      // prints stats and gates usage
+      res.report_stats();
+      res.report_gates_usage();
+
+      // write the mapped network in verilog
+      write_verilog_with_binding( res, "file.v" );
+   \endverbatim
+ */
+template<class Ntk>
+class binding_view : public Ntk
+{
+public:
+  using node = typename Ntk::node;
+
+public:
+  explicit binding_view( std::vector<gate> const& library )
+      : Ntk(), _library{ library }, _bindings( *this )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+    static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+    static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  }
+
+  explicit binding_view( Ntk const& ntk, std::vector<gate> const& library )
+      : Ntk( ntk ), _library{ library }, _bindings( *this )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+    static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+    static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  }
+
+  binding_view<Ntk>& operator=( binding_view<Ntk> const& binding_ntk )
+  {
+    Ntk::operator=( binding_ntk );
+    _library = binding_ntk._library;
+    _bindings = binding_ntk._bindings;
+    return *this;
+  }
+
+  void add_binding( node const& n, uint32_t gate_id )
+  {
+    assert( gate_id < _library.size() );
+    _bindings[n] = gate_id;
+  }
+
+  bool add_binding_with_check( node const& n, uint32_t gate_id )
+  {
+    assert( gate_id < _library.size() );
+
+    auto const& cell = _library[gate_id];
+
+    if ( Ntk::node_function( n ) == cell.function )
+    {
+      _bindings[n] = gate_id;
+      return true;
+    }
+    return false;
+  }
+
+  void remove_binding( node const& n ) const
+  {
+    _bindings.erase( n );
+  }
+
+  const gate& get_binding( node const& n ) const
+  {
+    return _library[_bindings[n]];
+  }
+
+  bool has_binding( node const& n ) const
+  {
+    return _bindings.has( n );
+  }
+
+  unsigned int get_binding_index( node const& n ) const
+  {
+    return _bindings[n];
+  }
+
+  const std::vector<gate>& get_library() const
+  {
+    return _library;
+  }
+
+  double compute_area() const
+  {
+    double area = 0;
+    Ntk::foreach_node( [&]( auto const& n, auto ) {
+      if ( has_binding( n ) )
+      {
+        area += get_binding( n ).area;
+      }
+    } );
+
+    return area;
+  }
+
+  double compute_worst_delay() const
+  {
+    topo_view ntk_topo{ *this };
+    node_map<double, Ntk> delays( *this );
+    double worst_delay = 0;
+
+    ntk_topo.foreach_node( [&]( auto const& n, auto ) {
+      if ( Ntk::is_constant( n ) || Ntk::is_pi( n ) )
+      {
+        delays[n] = 0;
+        return true;
+      }
+
+      if ( has_binding( n ) )
+      {
+        auto const& g = get_binding( n );
+        double gate_delay = 0;
+        Ntk::foreach_fanin( n, [&]( auto const& f, auto i ) {
+          gate_delay = std::max( gate_delay, (double)( delays[f] + std::max( g.pins[i].rise_block_delay, g.pins[i].fall_block_delay ) ) );
+        } );
+        delays[n] = gate_delay;
+        worst_delay = std::max( worst_delay, gate_delay );
+      }
+      return true;
+    } );
+
+    return worst_delay;
+  }
+
+  void report_stats( std::ostream& os = std::cout ) const
+  {
+    os << fmt::format( "[i] Report stats: area = {:>5.2f}; delay = {:>5.2f};\n", compute_area(), compute_worst_delay() );
+  }
+
+  void report_gates_usage( std::ostream& os = std::cout ) const
+  {
+    std::vector<uint32_t> gates_profile( _library.size(), 0u );
+
+    double area = 0;
+    Ntk::foreach_node( [&]( auto const& n, auto ) {
+      if ( has_binding( n ) )
+      {
+        auto const& g = get_binding( n );
+        ++gates_profile[g.id];
+        area += g.area;
+      }
+    } );
+
+    os << "[i] Report gates usage:\n";
+
+    uint32_t tot_instances = 0u;
+    for ( auto i = 0u; i < gates_profile.size(); ++i )
+    {
+      if ( gates_profile[i] > 0u )
+      {
+        float tot_gate_area = gates_profile[i] * _library[i].area;
+
+        os << fmt::format( "[i] {:<25}", _library[i].name )
+           << fmt::format( "\t Instance = {:>10d}", gates_profile[i] )
+           << fmt::format( "\t Area = {:>12.2f}", tot_gate_area )
+           << fmt::format( " {:>8.2f} %\n", tot_gate_area / area * 100 );
+
+        tot_instances += gates_profile[i];
+      }
+    }
+
+    os << fmt::format( "[i] {:<25}", "TOTAL" )
+       << fmt::format( "\t Instance = {:>10d}", tot_instances )
+       << fmt::format( "\t Area = {:>12.2f}   100.00 %\n", area );
+  }
+
+private:
+  std::vector<gate> _library;
+  node_map<uint32_t, Ntk, std::unordered_map<node, uint32_t>> _bindings;
+}; /* binding_view */
+
+template<class T>
+binding_view( T const& ) -> binding_view<T>;
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/views/cell_view.hpp b/include/mockturtle/views/cell_view.hpp
new file mode 100644
index 0000000..505cea8
--- /dev/null
+++ b/include/mockturtle/views/cell_view.hpp
@@ -0,0 +1,297 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cell_view.hpp
+  \brief Implements methods to bind the network to a standard cell library
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include "../utils/node_map.hpp"
+#include "../utils/standard_cell.hpp"
+#include "../views/topo_view.hpp"
+
+#include <iostream>
+#include <map>
+
+namespace mockturtle
+{
+
+/*! \brief Adds cells to a technology library and mapping API methods.
+ *
+ * This view adds methods to create and manage a mapped network that
+ * implements cells contained in a technology library. This view
+ * is returned by the technology mapping command `emap`. It can be used
+ * to report statistics about the network and write the network into
+ * a verilog file. It always adds the functions `has_cell`,
+ * `remove_cell`, `add_cell`, `add_cell_with_check`, `get_cell`,
+ * `get_cell_index`, `get_library`, `compute_area`, `compute_worst_delay`,
+ * `report_stats`, and `report_cells_usage`.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `foreach_node`
+ * - `foreach_fanin`
+ * - `is_constant`
+ * - `is_pi`
+ *
+ * Example
+ *
+   \verbatim embed:rst
+
+   .. code-block:: c++
+
+      // create network somehow
+      aig_network aig = ...;
+
+      // read cell library in genlib format
+      std::vector<gate> gates;
+      lorina::read_genlib( "file.genlib", genlib_reader( gates ) )
+      tech_library tech_lib( gates );
+
+      // call technology mapping to obtain the view
+      cell_view<block_network> res = emap_block( aig, tech_lib );
+
+      // prints stats and cells usage
+      res.report_stats();
+      res.report_cells_usage();
+   \endverbatim
+ */
+template<class Ntk>
+class cell_view : public Ntk
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+public:
+  explicit cell_view( std::vector<standard_cell> const& library )
+      : Ntk(), _library{ library }, _cells( *this )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+    static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+    static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  }
+
+  explicit cell_view( Ntk const& ntk, std::vector<standard_cell> const& library )
+      : Ntk( ntk ), _library{ library }, _cells( *this )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+    static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+    static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+  }
+
+  cell_view<Ntk>& operator=( cell_view<Ntk> const& cell_ntk )
+  {
+    Ntk::operator=( cell_ntk );
+    _library = cell_ntk._library;
+    _cells = cell_ntk._cells;
+    return *this;
+  }
+
+  void add_cell( node const& n, uint32_t cell_id )
+  {
+    assert( cell_id < _library.size() );
+    _cells[n] = cell_id;
+  }
+
+  bool add_cell_with_check( node const& n, uint32_t cell_id )
+  {
+    assert( cell_id < _library.size() );
+
+    auto const& cell = _library[cell_id];
+
+    if constexpr ( has_num_outputs_v<Ntk> && has_node_function_v<Ntk> )
+    {
+      if ( Ntk::num_outputs( n ) != cell.gates.size() )
+        return false;
+
+      for ( uint32_t i = 0; i < Ntk::num_outputs( n ); ++i )
+      {
+        if ( Ntk::node_function_pin( n, i ) != cell.gates[i].function )
+        {
+          return false;
+        }
+      }
+
+      _cells[n] = cell_id;
+      return true;
+    }
+
+    if ( cell.gates.size() > 1 )
+      return false;
+
+    if ( Ntk::node_function( n ) == cell.gates[0].function )
+    {
+      _cells[n] = cell_id;
+      return true;
+    }
+
+    return false;
+  }
+
+  void remove_cell( node const& n ) const
+  {
+    _cells.erase( n );
+  }
+
+  const standard_cell& get_cell( node const& n ) const
+  {
+    return _library[_cells[n]];
+  }
+
+  bool has_cell( node const& n ) const
+  {
+    return _cells.has( n );
+  }
+
+  unsigned int get_cell_index( node const& n ) const
+  {
+    return _cells[n];
+  }
+
+  const std::vector<standard_cell>& get_library() const
+  {
+    return _library;
+  }
+
+  double compute_area() const
+  {
+    double area = 0;
+    Ntk::foreach_node( [&]( auto const& n, auto ) {
+      if ( has_cell( n ) )
+      {
+        area += get_cell( n ).area;
+      }
+    } );
+
+    return area;
+  }
+
+  double compute_worst_delay() const
+  {
+    topo_view ntk_topo{ *this };
+    std::vector<std::vector<double>> delays( Ntk::size() );
+    double worst_delay = 0;
+
+    ntk_topo.foreach_node( [&]( auto const& n, auto ) {
+      if ( Ntk::is_constant( n ) || Ntk::is_pi( n ) )
+      {
+        delays[n].push_back( 0 );
+        return true;
+      }
+
+      if ( has_cell( n ) )
+      {
+        auto const& cell = get_cell( n );
+
+        for ( gate const& g : cell.gates )
+        {
+          double cell_delay = 0;
+          if constexpr ( has_get_output_pin_v<Ntk> )
+          {
+            Ntk::foreach_fanin( n, [&]( signal const& f, auto i ) {
+              cell_delay = std::max( cell_delay, delays[Ntk::get_node( f )][Ntk::get_output_pin( f )] + std::max( g.pins[i].rise_block_delay, g.pins[i].fall_block_delay ) );
+            } );
+          }
+          else
+          {
+            Ntk::foreach_fanin( n, [&]( signal const& f, auto i ) {
+              cell_delay = std::max( cell_delay, delays[Ntk::get_node( f )].front() + std::max( g.pins[i].rise_block_delay, g.pins[i].fall_block_delay ) );
+            } );
+          }
+          delays[n].push_back( cell_delay );
+          worst_delay = std::max( worst_delay, cell_delay );
+        }
+      }
+      else
+      {
+        worst_delay = -1;
+        return false;
+      }
+      return true;
+    } );
+
+    return worst_delay;
+  }
+
+  void report_stats( std::ostream& os = std::cout ) const
+  {
+    os << fmt::format( "[i] Report stats: area = {:>5.2f}; delay = {:>5.2f};\n", compute_area(), compute_worst_delay() );
+  }
+
+  void report_cells_usage( std::ostream& os = std::cout ) const
+  {
+    std::vector<uint32_t> cells_profile( _library.size(), 0u );
+
+    double area = 0;
+    Ntk::foreach_node( [&]( node const& n, auto ) {
+      if ( has_cell( n ) )
+      {
+        auto const& g = get_cell( n );
+        ++cells_profile[g.id];
+        area += g.area;
+      }
+    } );
+
+    os << "[i] Report cells usage:\n";
+
+    uint32_t tot_instances = 0u;
+    for ( auto i = 0u; i < cells_profile.size(); ++i )
+    {
+      if ( cells_profile[i] > 0u )
+      {
+        float tot_cell_area = cells_profile[i] * _library[i].area;
+
+        os << fmt::format( "[i] {:<25}", _library[i].name )
+           << fmt::format( "\t Instance = {:>10d}", cells_profile[i] )
+           << fmt::format( "\t Area = {:>12.2f}", tot_cell_area )
+           << fmt::format( " {:>8.2f} %\n", tot_cell_area / area * 100 );
+
+        tot_instances += cells_profile[i];
+      }
+    }
+
+    os << fmt::format( "[i] {:<25}", "TOTAL" )
+       << fmt::format( "\t Instance = {:>10d}", tot_instances )
+       << fmt::format( "\t Area = {:>12.2f}   100.00 %\n", area );
+  }
+
+private:
+  std::vector<standard_cell> _library;
+  node_map<uint32_t, Ntk, std::unordered_map<node, uint32_t>> _cells;
+}; /* cell_view */
+
+template<class T>
+cell_view( T const& ) -> cell_view<T>;
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/views/choice_view.hpp b/include/mockturtle/views/choice_view.hpp
new file mode 100644
index 0000000..a65eb3c
--- /dev/null
+++ b/include/mockturtle/views/choice_view.hpp
@@ -0,0 +1,592 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file choice_view.hpp
+  \brief Implement choices in network
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include <cassert>
+#include <optional>
+#include <utility>
+#include <vector>
+
+#include "../networks/detail/foreach.hpp"
+#include "../networks/events.hpp"
+#include "../traits.hpp"
+
+namespace mockturtle
+{
+
+struct choice_view_params
+{
+  bool add_choices_on_substitute{ true };
+  bool update_on_add{ true };
+};
+
+/*! \brief Implements choices in network
+ *
+ * Overrides the interface methods `substitute_node`, `incr_fanout_size`,
+ * `decr_fanout_size`, `fanout_size`.
+ *
+ * This class manages equivalent nodes keeping them saved as alternatives in
+ * the network. Each node belongs to an equivalence class in which a node
+ * is the class representative, by default the one with the lowest index.
+ * Equivalence classes are saved as linked lists. The `_choice_repr` vector
+ * associates each node to the next one in the linked list (the one closer
+ * to the representative). The representative is the tail and "points" at itself.
+ * The `_choice_phase` vector is used to save the polarity of each node in the
+ * class with respect to the representative. The representative uses its field
+ * to point to the head of the list.
+ *
+ * This view is not compatible with `fanout_view`.
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `size`
+ * - `node_to_index`
+ * - `index_to_node`
+ * - `is_complemented`
+ * - `make_signal`
+ */
+template<typename Ntk, bool has_choice_interface = has_foreach_choice_v<Ntk>>
+class choice_view
+{
+};
+
+template<typename Ntk>
+class choice_view<Ntk, true> : public Ntk
+{
+public:
+  choice_view( Ntk const& ntk, choice_view_params const& ps = {} ) : Ntk( ntk )
+  {
+    (void)ps;
+  }
+};
+
+template<typename Ntk>
+class choice_view<Ntk, false> : public Ntk
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+public:
+  choice_view( choice_view_params const& ps = {} )
+      : Ntk(), _ps( ps )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+    static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+    static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+    static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+
+    init_choice_classes();
+
+    if ( _ps.update_on_add )
+    {
+      _add_event = Ntk::events().register_add_event( [this]( auto const& n ) {
+        on_add( n );
+      } );
+    }
+  }
+
+  choice_view( Ntk const& ntk, choice_view_params const& ps = {} )
+      : Ntk( ntk ), _ps( ps )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+    static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+    static_assert( has_index_to_node_v<Ntk>, "Ntk does not implement the index_to_node method" );
+    static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+
+    init_choice_classes();
+
+    if ( _ps.update_on_add )
+    {
+      _add_event = Ntk::events().register_add_event( [this]( auto const& n ) {
+        on_add( n );
+      } );
+    }
+  }
+
+  choice_view<Ntk, false>& operator=( choice_view<Ntk, false> const& choice_ntk )
+  {
+    Ntk::operator=( choice_ntk );
+    if ( this != &choice_ntk )
+    {
+      this->_choice_repr = choice_ntk._choice_repr;
+      this->_choice_phase = choice_ntk._choice_phase;
+      this->_ps = choice_ntk._ps;
+    }
+    if ( _ps.update_on_add )
+    {
+      _add_event = Ntk::events().register_add_event( [this]( auto const& n ) {
+        on_add( n );
+      } );
+    }
+    return *this;
+  }
+
+  ~choice_view()
+  {
+    if ( _ps.update_on_add )
+    {
+      Ntk::events().release_add_event( _add_event );
+    }
+  }
+
+  template<typename T = Ntk>
+  std::enable_if_t<!std::is_same_v<typename T::node, typename T::signal>, void> add_choice( node const& n1, node const& n2 )
+  {
+    add_choice( n1, Ntk::make_signal( n2 ) );
+  }
+
+  void add_choice( node const& n1, signal const& s2 )
+  {
+    auto const n2 = Ntk::get_node( s2 );
+    auto const id1 = Ntk::node_to_index( n1 );
+    auto const id2 = Ntk::node_to_index( n2 );
+
+    if ( id1 == id2 )
+    {
+      /* same node */
+      return;
+    }
+
+    auto rep1 = get_choice_representative( n1 );
+    auto rep2 = get_choice_representative( n2 );
+
+    auto idrep1 = Ntk::node_to_index( rep1 );
+    auto idrep2 = Ntk::node_to_index( rep2 );
+
+    if ( idrep1 == idrep2 )
+    {
+      /* already in the same equivalence class */
+      return;
+    }
+
+    /* set the representative as the node with lowest index */
+    if ( idrep1 > idrep2 )
+    {
+      std::swap( rep1, rep2 );
+      std::swap( idrep1, idrep2 );
+    }
+
+    /* merge the eq lists */
+    bool inv = false;
+    if ( ( ( _choice_repr->at( id1 ) != n1 && Ntk::is_complemented( _choice_phase->at( id1 ) ) ) != Ntk::is_complemented( s2 ) ) !=
+         ( _choice_repr->at( id2 ) != n2 && Ntk::is_complemented( _choice_phase->at( id2 ) ) ) )
+    {
+      /* before merging, complement nodes accordingly to the new representative phase, if needed */
+      invert_phases_in_class( rep2 );
+      inv = true;
+    }
+    _choice_repr->at( idrep2 ) = Ntk::get_node( _choice_phase->at( idrep1 ) );
+    _choice_phase->at( idrep1 ) = _choice_phase->at( idrep2 );
+    /* store the right phase */
+    _choice_phase->at( idrep2 ) = Ntk::make_signal( rep2 ) ^ inv;
+  }
+
+  /* Set sig as an equivalence representative of n without including n in the choice list */
+  void set_representative( node const& n, signal const& sig )
+  {
+    /* TODO: TEST */
+    auto nsig = Ntk::get_node( sig );
+    auto repr = get_choice_representative( nsig );
+    bool c = false;
+
+    if ( repr != nsig )
+    {
+      c = Ntk::is_complemented( _choice_phase->at( Ntk::node_to_index( nsig ) ) );
+    }
+    _choice_repr->at( Ntk::node_to_index( n ) ) = repr;
+    _choice_phase->at( Ntk::node_to_index( n ) ) = Ntk::make_signal( n ) ^ ( Ntk::is_complemented( sig ) ^ c );
+  }
+
+  void update_choice_representative( node const& n )
+  {
+    assert( Ntk::node_to_index( n ) < Ntk::size() );
+
+    if ( is_choice_representative( n ) )
+      return;
+
+    bool inv = Ntk::is_complemented( _choice_phase->at( Ntk::node_to_index( n ) ) );
+    auto repr = get_choice_representative( n );
+    _choice_phase->at( Ntk::node_to_index( n ) ) = Ntk::make_signal( _choice_repr->at( Ntk::node_to_index( n ) ) );
+    _choice_repr->at( Ntk::node_to_index( n ) ) = n;
+    _choice_repr->at( Ntk::node_to_index( repr ) ) = Ntk::get_node( _choice_phase->at( Ntk::node_to_index( repr ) ) );
+    _choice_phase->at( Ntk::node_to_index( repr ) ) = Ntk::make_signal( repr );
+    if ( inv )
+    {
+      invert_phases_in_class( n );
+    }
+  }
+
+  /* returns the new class representative */
+  std::optional<signal> remove_choice( node const& n )
+  {
+    assert( Ntk::node_to_index( n ) < Ntk::size() );
+
+    auto next = Ntk::node_to_index( _choice_repr->at( Ntk::node_to_index( n ) ) );
+    auto repr = Ntk::node_to_index( get_choice_representative( next ) );
+    auto tail = Ntk::node_to_index( Ntk::get_node( _choice_phase->at( Ntk::node_to_index( repr ) ) ) );
+
+    /* if n is a representative, recompute the representative of the new class */
+    if ( repr == Ntk::node_to_index( n ) && tail != Ntk::node_to_index( n ) )
+    {
+      auto new_repr = tail;
+      node pred = tail;
+      foreach_choice( tail, [&]( auto const& g ) {
+        if ( Ntk::node_to_index( g ) != repr && Ntk::node_to_index( g ) < new_repr )
+        {
+          new_repr = Ntk::node_to_index( g );
+        }
+        if ( Ntk::node_to_index( g ) != repr && Ntk::node_to_index( _choice_repr->at( g ) ) == repr )
+        {
+          pred = Ntk::node_to_index( g );
+        }
+        return true;
+      } );
+      auto const new_repr_signal = _choice_phase->at( new_repr );
+      bool polarity = Ntk::is_complemented( new_repr_signal );
+      if ( new_repr == pred )
+      {
+        _choice_phase->at( new_repr ) = _choice_phase->at( repr );
+      }
+      else
+      {
+        _choice_phase->at( new_repr ) = Ntk::make_signal( _choice_repr->at( new_repr ) );
+        _choice_repr->at( pred ) = Ntk::index_to_node( tail );
+      }
+      _choice_repr->at( new_repr ) = Ntk::index_to_node( new_repr );
+      if ( polarity )
+      {
+        invert_phases_in_class( new_repr );
+      }
+      return new_repr_signal;
+    }
+    else if ( tail == n )
+    {
+      _choice_phase->at( Ntk::node_to_index( repr ) ) = Ntk::make_signal( next );
+    }
+    else
+    {
+      while ( Ntk::node_to_index( _choice_repr->at( tail ) ) != Ntk::node_to_index( n ) )
+      {
+        tail = Ntk::node_to_index( _choice_repr->at( tail ) );
+      }
+      _choice_repr->at( tail ) = Ntk::index_to_node( next );
+    }
+
+    _choice_repr->at( Ntk::node_to_index( n ) ) = n;
+    return std::nullopt;
+  }
+
+  void clear_choices()
+  {
+    for ( auto i = 0u; i < Ntk::size(); i++ )
+    {
+      _choice_repr->at( i ) = Ntk::index_to_node( i );
+      _choice_phase->at( i ) = Ntk::make_signal( Ntk::index_to_node( i ) );
+    }
+  }
+
+  bool delete_choice_from_network( node const& n )
+  {
+    if ( Ntk::is_dead( n ) || !is_choice( n ) )
+    {
+      /* node is already dead or not dangling */
+      return false;
+    }
+
+    Ntk::take_out_node( n );
+    remove_choice( n );
+    return true;
+  }
+
+  node get_choice_representative( node const& n ) const
+  {
+    assert( Ntk::node_to_index( n ) < Ntk::size() );
+
+    auto rep = _choice_repr->at( Ntk::node_to_index( n ) );
+    while ( Ntk::node_to_index( rep ) != Ntk::node_to_index( _choice_repr->at( Ntk::node_to_index( rep ) ) ) )
+    {
+      rep = _choice_repr->at( Ntk::node_to_index( rep ) );
+    }
+    return rep;
+  }
+
+  bool is_choice_representative( node const& n ) const
+  {
+    assert( Ntk::node_to_index( n ) < Ntk::size() );
+    return _choice_repr->at( Ntk::node_to_index( n ) ) == n;
+  }
+
+  signal get_choice_representative_signal( node const& n ) const
+  {
+    auto repr = Ntk::make_signal( get_choice_representative( n ) );
+
+    if ( Ntk::get_node( repr ) == n )
+    {
+      return repr;
+    }
+
+    return repr ^ Ntk::is_complemented( _choice_phase->at( Ntk::node_to_index( n ) ) );
+  }
+
+  template<typename T = Ntk>
+  std::enable_if_t<!std::is_same_v<typename T::node, typename T::signal>, typename T::signal> get_choice_representative_signal( signal const& sig ) const
+  {
+    auto n = Ntk::get_node( sig );
+    auto repr = get_choice_representative( n );
+
+    if ( repr == n )
+    {
+      return sig;
+    }
+
+    bool c = Ntk::is_complemented( _choice_phase->at( Ntk::node_to_index( n ) ) ) != Ntk::is_complemented( sig );
+    return Ntk::make_signal( repr ) ^ c;
+  }
+
+  uint32_t count_choices( node const& n ) const
+  {
+    assert( Ntk::node_to_index( n ) < Ntk::size() );
+    uint32_t size = 1u;
+    auto p = n;
+    while ( Ntk::node_to_index( p ) != Ntk::node_to_index( _choice_repr->at( Ntk::node_to_index( p ) ) ) )
+    {
+      p = _choice_repr->at( Ntk::node_to_index( p ) );
+      size++;
+    }
+    p = Ntk::get_node( _choice_phase->at( Ntk::node_to_index( p ) ) );
+    while ( Ntk::node_to_index( p ) != Ntk::node_to_index( n ) )
+    {
+      size++;
+      p = _choice_repr->at( Ntk::node_to_index( p ) );
+    }
+    return size;
+  }
+
+  template<typename Fn>
+  void foreach_choice( node const& n, Fn&& fn ) const
+  {
+    auto p = n;
+    if ( !fn( p ) )
+    {
+      return;
+    }
+    while ( Ntk::node_to_index( p ) != Ntk::node_to_index( _choice_repr->at( Ntk::node_to_index( p ) ) ) )
+    {
+      p = _choice_repr->at( Ntk::node_to_index( p ) );
+      if ( !fn( p ) )
+      {
+        return;
+      }
+    }
+    p = Ntk::get_node( _choice_phase->at( Ntk::node_to_index( p ) ) );
+    while ( Ntk::node_to_index( p ) != Ntk::node_to_index( n ) )
+    {
+      if ( !fn( p ) )
+      {
+        return;
+      }
+      p = _choice_repr->at( Ntk::node_to_index( p ) );
+    }
+  }
+
+  /* redefine node substitution */
+  void substitute_node( node const& old_node, signal const& new_signal )
+  {
+    std::stack<std::pair<node, signal>> to_substitute;
+    to_substitute.push( { old_node, new_signal } );
+
+    while ( !to_substitute.empty() )
+    {
+      const auto [_old, _new] = to_substitute.top();
+      to_substitute.pop();
+
+      if ( _ps.add_choices_on_substitute )
+      {
+        add_choice( _old, _new );
+      }
+      // TODO: add replace choice mode
+
+      for ( auto idx = 1u; idx < Ntk::_storage->nodes.size(); ++idx )
+      {
+        if ( Ntk::is_ci( idx ) || Ntk::is_dead( idx ) )
+          continue; /* ignore CIs */
+
+        if ( const auto repl = Ntk::replace_in_node( idx, _old, _new ); repl )
+        {
+          to_substitute.push( *repl );
+        }
+      }
+
+      /* check outputs */
+      Ntk::replace_in_outputs( _old, _new );
+
+      // set old node as choice, reset fanout
+      Ntk::_storage->nodes[_old].data[0].h1 &= UINT32_C( 0xC0000000 );
+      take_out_choice( _old );
+
+      if ( is_choice( Ntk::get_node( _new ) ) && fanout_size( Ntk::get_node( _new ) ) > 0u )
+      {
+        take_in_choice( Ntk::get_node( _new ) );
+      }
+    }
+  }
+
+  void take_out_choice( node const& n )
+  {
+    /* we cannot delete CIs or constants */
+    if ( n == 0 || Ntk::is_ci( n ) )
+      return;
+
+    auto& nobj = Ntk::_storage->nodes[n];
+    set_choice_flag( n );
+    Ntk::_storage->hash.erase( nobj );
+
+    for ( auto i = 0u; i < Ntk::fanin_size( n ); ++i )
+    {
+      if ( fanout_size( nobj.children[i].index ) == 0 )
+      {
+        continue;
+      }
+      /* set childrens in MFFC as choice, decrement the fanout count */
+      if ( decr_fanout_size( nobj.children[i].index ) == 0 )
+      {
+        take_out_choice( nobj.children[i].index );
+      }
+    }
+  }
+
+  void take_in_choice( node const& n )
+  {
+    /* we cannot delete CIs or constants */
+    if ( n == 0 || Ntk::is_ci( n ) )
+      return;
+
+    auto& nobj = Ntk::_storage->nodes[n];
+    reset_choice_flag( n );
+    Ntk::_storage->hash[nobj] = n;
+
+    for ( auto i = 0u; i < Ntk::fanin_size( n ); ++i )
+    {
+      /* restore choice childrens in MFFC, increment the fanout count */
+      if ( incr_fanout_size( nobj.children[i].index ) == 0 )
+      {
+        take_in_choice( nobj.children[i].index );
+      }
+    }
+  }
+
+  /* redefine methods for choice flag: storage h1 = dead(31), choice(30), fanout_size(29 to 0) */
+  uint32_t fanout_size( node const& n ) const
+  {
+    return Ntk::_storage->nodes[n].data[0].h1 & UINT32_C( 0x3FFFFFFF );
+  }
+
+  uint32_t incr_fanout_size( node const& n ) const
+  {
+    return Ntk::_storage->nodes[n].data[0].h1++ & UINT32_C( 0x3FFFFFFF );
+  }
+
+  uint32_t decr_fanout_size( node const& n ) const
+  {
+    return --Ntk::_storage->nodes[n].data[0].h1 & UINT32_C( 0x3FFFFFFF );
+  }
+
+  inline bool is_choice( node const& n ) const
+  {
+    return ( Ntk::_storage->nodes[n].data[0].h1 >> 30 ) & 1;
+  }
+
+private:
+  inline void set_choice_flag( node const& n ) const
+  {
+    Ntk::_storage->nodes[n].data[0].h1 |= UINT32_C( 0x40000000 );
+  }
+
+  inline void reset_choice_flag( node const& n ) const
+  {
+    Ntk::_storage->nodes[n].data[0].h1 &= UINT32_C( 0xBFFFFFFF );
+  }
+
+  void init_choice_classes()
+  {
+    _choice_repr = std::make_shared<std::vector<node>>( Ntk::size() );
+    _choice_phase = std::make_shared<std::vector<signal>>( Ntk::size() );
+    // Ntk::foreach_node( [&]( auto n ) {
+    for ( auto i = 0u; i < Ntk::size(); i++ )
+    {
+      _choice_repr->at( i ) = Ntk::index_to_node( i );
+      _choice_phase->at( i ) = Ntk::make_signal( Ntk::index_to_node( i ) );
+    }
+  }
+
+  void invert_phases_in_class( node const& rep )
+  {
+    assert( Ntk::node_to_index( rep ) < Ntk::size() );
+    assert( is_choice_representative( rep ) );
+
+    auto p = Ntk::get_node( _choice_phase->at( rep ) );
+
+    while ( Ntk::node_to_index( p ) != Ntk::node_to_index( _choice_repr->at( Ntk::node_to_index( p ) ) ) )
+    {
+      _choice_phase->at( p ) = !_choice_phase->at( p );
+      p = _choice_repr->at( Ntk::node_to_index( p ) );
+    }
+  }
+
+  void on_add( node const& n )
+  {
+    if ( Ntk::size() > _choice_repr->size() )
+    {
+      _choice_repr->push_back( n );
+      _choice_phase->push_back( Ntk::make_signal( n ) );
+    }
+  }
+
+private:
+  std::shared_ptr<std::vector<node>> _choice_repr;
+  std::shared_ptr<std::vector<signal>> _choice_phase;
+  choice_view_params _ps;
+  std::shared_ptr<typename network_events<Ntk>::add_event_type> _add_event;
+};
+
+template<class T>
+choice_view( T const&, choice_view_params const& ps = {} ) -> choice_view<T>;
+
+} // namespace mockturtle
diff --git a/include/mockturtle/views/cnf_view.hpp b/include/mockturtle/views/cnf_view.hpp
new file mode 100644
index 0000000..240153d
--- /dev/null
+++ b/include/mockturtle/views/cnf_view.hpp
@@ -0,0 +1,691 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cnf_view.hpp
+  \brief Creates a CNF while creating a network
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <cstdio>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "../algorithms/cnf.hpp"
+#include "../traits.hpp"
+#include "../utils/include/percy.hpp"
+
+#include <bill/sat/interface/common.hpp>
+#include <bill/sat/interface/glucose.hpp>
+#include <fmt/format.h>
+
+namespace mockturtle
+{
+
+struct cnf_view_params
+{
+  /*! \brief Write DIMACS file, whenever solve is called. */
+  std::optional<std::string> write_dimacs{};
+
+  /*! \brief Automatically update clauses when network is modified.
+             Only meaningful when AllowModify = true. */
+  bool auto_update{ true };
+};
+
+/* forward declaration */
+template<typename Ntk, bool AllowModify = false, bill::solvers Solver = bill::solvers::glucose_41>
+class cnf_view;
+
+namespace detail
+{
+
+template<typename CnfView, typename Ntk, bool AllowModify = false, bill::solvers Solver = bill::solvers::glucose_41>
+class cnf_view_impl : public Ntk
+{
+public:
+  cnf_view_impl( CnfView& cnf_view )
+      : Ntk()
+  {
+    (void)cnf_view;
+  }
+};
+
+template<typename CnfView, typename Ntk, bill::solvers Solver>
+class cnf_view_impl<CnfView, Ntk, true, Solver> : public Ntk
+{
+  friend class cnf_view<Ntk, true, Solver>;
+  using node = typename Ntk::node;
+
+public:
+  cnf_view_impl( CnfView& cnf_view )
+      : Ntk(), cnf_view_( cnf_view ), literals_( *this )
+  {
+  }
+
+  cnf_view_impl( CnfView& cnf_view, Ntk& ntk )
+      : Ntk( ntk ), cnf_view_( cnf_view ), literals_( *this )
+  {
+  }
+
+  ~cnf_view_impl()
+  {
+  }
+
+  void init()
+  {
+    cnf_view_.solver_.add_variables( Ntk::size() );
+
+    /* unit clause for constants */
+    bill::lit_type lit_const( 0, bill::lit_type::polarities::negative );
+    cnf_view_.add_clause( lit_const );
+    literals_[Ntk::get_constant( false )] = lit_const;
+    if ( Ntk::get_node( Ntk::get_constant( false ) ) != Ntk::get_node( Ntk::get_constant( true ) ) )
+    {
+      literals_[Ntk::get_constant( true )] = ~lit_const;
+    }
+
+    uint32_t v = 0;
+    Ntk::foreach_pi( [&]( auto const& n ) {
+      literals_[n] = bill::lit_type( ++v, bill::lit_type::polarities::positive );
+    } );
+
+    Ntk::foreach_gate( [&]( auto const& n ) {
+      literals_[n] = bill::lit_type( ++v, bill::lit_type::polarities::positive );
+      cnf_view_.on_add( n, false );
+    } );
+  }
+
+  inline bill::var_type add_var()
+  {
+    return cnf_view_.solver_.add_variable();
+  }
+
+  /*! \brief Returns the switching literal associated to a node. */
+  inline bill::lit_type switch_lit( node const& n ) const
+  {
+    assert( !Ntk::is_pi( n ) && !Ntk::is_constant( n ) && "PI and constant node are not switch-able" );
+    return switches_[Ntk::node_to_index( n )];
+  }
+
+  /*! \brief Whether a node is currently activated (included in CNF). */
+  inline bool is_activated( node const& n ) const
+  {
+    return switch_lit( n ).is_complemented();
+    /* clauses are activated if switch literal is complemented */
+  }
+
+  /*! \brief Deactivates the clauses for a node. */
+  void deactivate( node const& n )
+  {
+    if ( is_activated( n ) )
+    {
+      switches_[Ntk::node_to_index( n )].complement();
+    }
+  }
+
+  /*! \brief (Re-)activates the clauses for a node. */
+  void activate( node const& n )
+  {
+    if ( !is_activated( n ) )
+    {
+      switches_[Ntk::node_to_index( n )].complement();
+    }
+  }
+
+  void on_modified( node const& n )
+  {
+    deactivate( n );
+    cnf_view_.add_clause( switch_lit( n ) );
+    cnf_view_.on_add( n, false );
+    /* reuse literals_[n] (so that the fanout clauses are still valid),
+    but create a new switches_[n] to control a new set of gate clauses */
+  }
+
+  void on_delete( node const& n )
+  {
+    deactivate( n );
+  }
+
+private:
+  CnfView& cnf_view_;
+
+  node_map<bill::lit_type, Ntk> literals_;
+  std::vector<bill::lit_type> switches_;
+};
+
+} /* namespace detail */
+
+/*! \brief A view to connect logic network creation to SAT solving.
+ *
+ * When using this view to create a new network, it creates a CNF internally
+ * while nodes are added to the network.  It also contains a SAT solver.  The
+ * network can be solved by calling the `solve` method, which by default assumes
+ * that each output should compute `true` (an overload of the `solve` method can
+ * override this default behaviour and apply custom assumptions).  Further, the
+ * methods `model_value` and `pi_vmodel_alues` can be used to access model
+ * values in case solving was satisfiable.  Finally, methods `var` and `lit` can
+ * be used to access variable and literal information for nodes and signals,
+ * respectively, in order to add custom clauses with the `add_clause` methods.
+ *
+ * The `cnf_view` can also be wrapped around an existing network by setting the
+ * `AllowModify` template parameter to true.  Then it also updates the CNF when
+ * nodes are deleted or modified.  This comes with an addition cost in variable
+ * and clause size.
+ */
+template<typename Ntk, bool AllowModify, bill::solvers Solver>
+class cnf_view : public detail::cnf_view_impl<cnf_view<Ntk, AllowModify, Solver>, Ntk, AllowModify, Solver>
+{
+  friend class detail::cnf_view_impl<cnf_view<Ntk, AllowModify, Solver>, Ntk, AllowModify, Solver>;
+
+public:
+  using cnf_view_impl_t = detail::cnf_view_impl<cnf_view<Ntk, AllowModify, Solver>, Ntk, AllowModify, Solver>;
+
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+public:
+  // can only be constructed as empty network
+  explicit cnf_view( cnf_view_params const& ps = {} )
+      : cnf_view_impl_t( *this ),
+        ps_( ps )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+    static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+    static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+    static_assert( has_node_function_v<Ntk>, "Ntk does not implement the node_function method" );
+
+    if constexpr ( AllowModify )
+    {
+      cnf_view_impl_t::init();
+    }
+    else
+    {
+      const auto v = solver_.add_variable(); /* for the constant input */
+      assert( v == var( Ntk::get_node( Ntk::get_constant( false ) ) ) );
+      add_clause( bill::lit_type( v, bill::lit_type::polarities::negative ) );
+
+      if ( Ntk::get_node( Ntk::get_constant( true ) ) != Ntk::get_node( Ntk::get_constant( false ) ) )
+      {
+        const auto v = solver_.add_variable(); /* for the constant input */
+        assert( v == var( Ntk::get_node( Ntk::get_constant( true ) ) ) );
+        add_clause( bill::lit_type( v, bill::lit_type::polarities::positive ) );
+      }
+    }
+
+    register_events();
+  }
+
+  template<bool enabled = AllowModify, typename = std::enable_if_t<enabled>>
+  explicit cnf_view( Ntk& ntk, cnf_view_params const& ps = {} )
+      : cnf_view_impl_t( *this, ntk ),
+        ps_( ps )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+    static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+    static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+    static_assert( has_node_function_v<Ntk>, "Ntk does not implement the node_function method" );
+
+    cnf_view_impl_t::init();
+
+    register_events();
+  }
+
+  ~cnf_view()
+  {
+    if ( add_event )
+    {
+      Ntk::events().release_add_event( add_event );
+    }
+    if ( modified_event )
+    {
+      Ntk::events().release_modified_event( modified_event );
+    }
+    if ( delete_event )
+    {
+      Ntk::events().release_delete_event( delete_event );
+    }
+  }
+
+  signal create_pi()
+  {
+    const auto f = Ntk::create_pi();
+
+    const auto v = solver_.add_variable();
+
+    if constexpr ( AllowModify )
+    {
+      cnf_view_impl_t::literals_.resize( bill::lit_type( 0, bill::lit_type::polarities::positive ) );
+      cnf_view_impl_t::literals_[f] = bill::lit_type( v, bill::lit_type::polarities::positive );
+      return f;
+    }
+
+    assert( v == var( Ntk::get_node( f ) ) );
+    (void)v;
+
+    return f;
+  }
+
+  /* \brief Returns the variable associated to a node. */
+  inline bill::var_type var( node const& n ) const
+  {
+    if constexpr ( AllowModify )
+    {
+      return cnf_view_impl_t::literals_[n].variable();
+    }
+    return Ntk::node_to_index( n );
+  }
+
+  /*! \brief Returns the literal associated to a node. */
+  inline bill::lit_type lit( node const& n ) const
+  {
+    return bill::lit_type( var( n ), bill::lit_type::polarities::positive );
+  }
+
+  /*! \brief Returns the literal associated to a signal. */
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  inline bill::lit_type lit( signal const& f ) const
+  {
+    return bill::lit_type( var( Ntk::get_node( f ) ), Ntk::is_complemented( f ) ? bill::lit_type::polarities::negative : bill::lit_type::polarities::positive );
+  }
+
+  /*! \brief Solves the network with a set of custom assumptions.
+   *
+   * This function does not assert any primary output, unless specified
+   * explicitly through the assumptions.
+   *
+   * The function returns `nullopt`, if no solution can be found (due to a
+   * conflict limit), or `true` in case of SAT, and `false` in case of UNSAT.
+   *
+   * \param assumptions Vector of literals to be assumped when solving
+   * \param limit Conflict limit (unlimited if 0)
+   */
+  inline std::optional<bool> solve( bill::result::clause_type const& assumptions, uint32_t limit = 0 )
+  {
+    const auto _write_dimacs = [&]( bill::result::clause_type const& assumps ) {
+      if ( ps_.write_dimacs )
+      {
+        for ( const auto& a : assumps )
+        {
+          auto l = pabc::Abc_Var2Lit( a.variable(), a.is_complemented() );
+          dimacs_.add_clause( &l, &l + 1 );
+        }
+        dimacs_.set_nr_vars( solver_.num_variables() );
+#ifdef _MSC_VER
+        FILE* fd = nullptr;
+        fopen_s( &fd, ps_.write_dimacs->c_str(), "w" );
+#else
+        FILE* fd = fopen( ps_.write_dimacs->c_str(), "w" );
+#endif
+        dimacs_.to_dimacs( fd );
+        fclose( fd );
+      }
+    };
+
+    const auto _solve = [&]( bill::result::clause_type const& assumps ) -> std::optional<bool> {
+      const auto res = solver_.solve( assumps, limit );
+
+      switch ( res )
+      {
+      case bill::result::states::satisfiable:
+        model_ = solver_.get_model().model();
+        return true;
+      case bill::result::states::unsatisfiable:
+        return false;
+      default:
+        return std::nullopt;
+      }
+
+      return std::nullopt;
+    };
+
+    if constexpr ( AllowModify )
+    {
+      bill::result::clause_type assumptions_copy = assumptions;
+      for ( auto i = 1u; i < cnf_view_impl_t::switches_.size(); ++i )
+      {
+        if ( !Ntk::is_pi( Ntk::index_to_node( i ) ) )
+        {
+          assumptions_copy.push_back( cnf_view_impl_t::switches_[i] );
+        }
+      }
+
+      _write_dimacs( assumptions_copy );
+      return _solve( assumptions_copy );
+    }
+
+    _write_dimacs( assumptions );
+    return _solve( assumptions );
+  }
+
+  /*! \brief Solves the network by asserting all primary outputs to be true
+   *
+   * The function returns `nullopt`, if no solution can be found (due to a
+   * conflict limit), or `true` in case of SAT, and `false` in case of UNSAT.
+   *
+   * \param limit Conflict limit (unlimited if 0)
+   */
+  inline std::optional<bool> solve( int limit = 0 )
+  {
+    bill::result::clause_type assumptions;
+    Ntk::foreach_po( [&]( auto const& f ) {
+      assumptions.push_back( lit( f ) );
+    } );
+    return solve( assumptions, limit );
+  }
+
+  /*! \brief Return model value for a node. */
+  inline bool model_value( node const& n ) const
+  {
+    return model_.at( var( n ) ) == bill::lbool_type::true_;
+  }
+
+  /*! \brief Return model value for a node (takes complementation into account). */
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  inline bool model_value( signal const& f ) const
+  {
+    return model_value( Ntk::get_node( f ) ) != Ntk::is_complemented( f );
+  }
+
+  /* \brief Returns all model values for all primary inputs. */
+  std::vector<bool> pi_model_values()
+  {
+    std::vector<bool> values( Ntk::num_pis() );
+    Ntk::foreach_pi( [&]( auto const& n, auto i ) {
+      values[i] = model_value( n );
+    } );
+    return values;
+  }
+
+  /*! \brief Blocks last model for primary input values. */
+  void block()
+  {
+    bill::result::clause_type blocking_clause;
+    Ntk::foreach_pi( [&]( auto const& n ) {
+      blocking_clause.push_back( bill::lit_type( var( n ), model_value( n ) ? bill::lit_type::polarities::negative : bill::lit_type::polarities::positive ) );
+    } );
+    add_clause( blocking_clause );
+  }
+
+  /*! \brief Number of variables. */
+  inline uint32_t num_vars() const
+  {
+    return solver_.num_variables();
+  }
+
+  /*! \brief Number of clauses. */
+  inline uint32_t num_clauses() const
+  {
+    return solver_.num_clauses();
+  }
+
+  /*! \brief Adds a clause to the solver. */
+  void add_clause( bill::result::clause_type const& clause )
+  {
+    if ( ps_.write_dimacs )
+    {
+      std::vector<int> lits;
+      for ( auto c : clause )
+      {
+        lits.push_back( pabc::Abc_Var2Lit( c.variable(), c.is_complemented() ) );
+      }
+      dimacs_.add_clause( &lits[0], &lits[0] + lits.size() );
+    }
+    solver_.add_clause( clause );
+  }
+
+  /*! \brief Adds a clause from signals to the solver. */
+  void add_clause( std::vector<signal> const& clause )
+  {
+    bill::result::clause_type lits;
+    std::transform( clause.begin(), clause.end(), std::back_inserter( lits ), [&]( auto const& s ) { return lit( s ); } );
+    add_clause( lits );
+  }
+
+  /*! \brief Adds a clause to the solver.
+   *
+   * Entries are either all literals or network signals.
+   */
+  template<typename... Lit, typename = std::enable_if_t<
+                                std::disjunction_v<
+                                    std::conjunction<std::is_same<Lit, bill::lit_type>...>,
+                                    std::conjunction<std::is_same<Lit, signal>...>>>>
+  void add_clause( Lit... lits )
+  {
+    if constexpr ( std::conjunction_v<std::is_same<Lit, bill::lit_type>...> )
+    {
+      add_clause( bill::result::clause_type{ { lits... } } );
+    }
+    else
+    {
+      add_clause( bill::result::clause_type{ { lit( lits )... } } );
+    }
+  }
+
+private:
+  void register_events()
+  {
+    add_event = Ntk::events().register_add_event( [this]( auto const& n ) { on_add( n ); } );
+    modified_event = Ntk::events().register_modified_event( [this]( auto const& n, auto const& previous ) {
+      (void)previous;
+      if constexpr ( AllowModify )
+      {
+        if ( ps_.auto_update )
+        {
+          cnf_view_impl_t::on_modified( n );
+        }
+        return;
+      }
+
+      (void)n;
+      (void)this;
+      assert( false && "nodes should not be modified in cnf_view" );
+      std::abort();
+    } );
+    delete_event = Ntk::events().register_delete_event( [this]( auto const& n ) {
+      if constexpr ( AllowModify )
+      {
+        if ( ps_.auto_update )
+        {
+          cnf_view_impl_t::on_delete( n );
+        }
+        return;
+      }
+
+      (void)n;
+      (void)this;
+      assert( false && "nodes should not be deleted in cnf_view" );
+      std::abort();
+    } );
+  }
+
+  void on_add( node const& n, bool add_var = true ) /* add_var is only used when AllowModify = true */
+  {
+    bill::lit_type node_lit;
+    bill::lit_type switch_lit;
+
+    if constexpr ( AllowModify )
+    {
+      if ( add_var )
+      {
+        node_lit = bill::lit_type( solver_.add_variable(), bill::lit_type::polarities::positive );
+        cnf_view_impl_t::literals_.resize();
+        cnf_view_impl_t::literals_[n] = node_lit;
+      }
+      else
+      {
+        node_lit = cnf_view_impl_t::literals_[n];
+      }
+
+      switch_lit = bill::lit_type( solver_.add_variable(), bill::lit_type::polarities::positive );
+      cnf_view_impl_t::switches_.resize( Ntk::size() );
+      cnf_view_impl_t::switches_[Ntk::node_to_index( n )] = ~switch_lit;
+    }
+    else
+    {
+      (void)add_var;
+      const auto v = solver_.add_variable();
+      assert( v == var( n ) );
+      (void)v;
+
+      node_lit = lit( Ntk::make_signal( n ) );
+    }
+
+    const auto _add_clause = [&]( bill::result::clause_type const& clause ) {
+      if constexpr ( AllowModify )
+      {
+        bill::result::clause_type clause_ = clause;
+        clause_.push_back( switch_lit );
+        add_clause( clause_ );
+      }
+      else
+      {
+        add_clause( clause );
+      }
+    };
+
+    bill::result::clause_type child_lits;
+    Ntk::foreach_fanin( n, [&]( auto const& f ) {
+      child_lits.push_back( lit( f ) );
+    } );
+
+    if constexpr ( has_is_and_v<Ntk> )
+    {
+      if ( Ntk::is_and( n ) )
+      {
+        detail::on_and( node_lit, child_lits[0], child_lits[1], _add_clause );
+        return;
+      }
+    }
+
+    if constexpr ( has_is_or_v<Ntk> )
+    {
+      if ( Ntk::is_or( n ) )
+      {
+        detail::on_or( node_lit, child_lits[0], child_lits[1], _add_clause );
+        return;
+      }
+    }
+
+    if constexpr ( has_is_xor_v<Ntk> )
+    {
+      if ( Ntk::is_xor( n ) )
+      {
+        detail::on_xor( node_lit, child_lits[0], child_lits[1], _add_clause );
+        return;
+      }
+    }
+
+    if constexpr ( has_is_maj_v<Ntk> )
+    {
+      if ( Ntk::is_maj( n ) )
+      {
+        detail::on_maj( node_lit, child_lits[0], child_lits[1], child_lits[2], _add_clause );
+        return;
+      }
+    }
+
+    if constexpr ( has_is_ite_v<Ntk> )
+    {
+      if ( Ntk::is_ite( n ) )
+      {
+        detail::on_ite( node_lit, child_lits[0], child_lits[1], child_lits[2], _add_clause );
+        return;
+      }
+    }
+
+    if constexpr ( has_is_xor3_v<Ntk> )
+    {
+      if ( Ntk::is_xor3( n ) )
+      {
+        detail::on_xor3( node_lit, child_lits[0], child_lits[1], child_lits[2], _add_clause );
+        return;
+      }
+    }
+
+    if constexpr ( has_is_nary_and_v<Ntk> )
+    {
+      if ( Ntk::is_nary_and( n ) )
+      {
+        fmt::print( stderr, "[e] nary-AND not yet supported in generate_cnf" );
+        std::abort();
+        return;
+      }
+    }
+
+    if constexpr ( has_is_nary_or_v<Ntk> )
+    {
+      if ( Ntk::is_nary_or( n ) )
+      {
+        fmt::print( stderr, "[e] nary-OR not yet supported in generate_cnf" );
+        std::abort();
+        return;
+      }
+    }
+
+    if constexpr ( has_is_nary_xor_v<Ntk> )
+    {
+      if ( Ntk::is_nary_xor( n ) )
+      {
+        fmt::print( stderr, "[e] nary-XOR not yet supported in generate_cnf" );
+        std::abort();
+        return;
+      }
+    }
+
+    detail::on_function( node_lit, child_lits, Ntk::node_function( n ), _add_clause );
+  }
+
+private:
+  bill::solver<Solver> solver_;
+  bill::result::model_type model_;
+  percy::cnf_formula dimacs_;
+
+  cnf_view_params ps_;
+
+  std::shared_ptr<typename network_events<Ntk>::add_event_type> add_event;
+  std::shared_ptr<typename network_events<Ntk>::modified_event_type> modified_event;
+  std::shared_ptr<typename network_events<Ntk>::delete_event_type> delete_event;
+};
+
+template<class T>
+cnf_view( T const& ) -> cnf_view<T, true>;
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/views/color_view.hpp b/include/mockturtle/views/color_view.hpp
new file mode 100644
index 0000000..a9c7cc0
--- /dev/null
+++ b/include/mockturtle/views/color_view.hpp
@@ -0,0 +1,244 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file color_view.hpp
+  \brief Manager view for traversal IDs, called colors
+
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+namespace mockturtle
+{
+
+/*!\brief Manager view for traversal IDs (in-place storage).
+ *
+ * Traversal IDs, called colors, are unsigned integers that can be
+ * assigned to nodes.  The corresponding values are stored in-place in
+ * the flags of the underlying of the network.
+ */
+template<typename Ntk>
+class color_view : public Ntk
+{
+public:
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+public:
+  explicit color_view( Ntk const& ntk )
+      : Ntk( ntk )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  }
+
+  /*! \brief Returns a new color and increases the current color */
+  uint32_t new_color() const
+  {
+    return ++this->_storage->trav_id;
+    // return ++value;
+  }
+
+  /*! \brief Returns the current color */
+  uint32_t current_color() const
+  {
+    return this->_storage->trav_id;
+    // return value;
+  }
+
+  /*! \brief Assigns all nodes to `color` */
+  void clear_colors( uint32_t color = 0 ) const
+  {
+    std::for_each( this->_storage->nodes.begin(), this->_storage->nodes.end(),
+                   [color]( auto& n ) { n.data[1].h1 = color; } );
+  }
+
+  /*! \brief Returns the color of a node */
+  auto color( node const& n ) const
+  {
+    return this->_storage->nodes[n].data[1].h1;
+  }
+
+  /*! \brief Returns the color of a node */
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  auto color( signal const& n ) const
+  {
+    return this->_storage->nodes[this->get_node( n )].data[1].h1;
+  }
+
+  /*! \brief Assigns the current color to a node */
+  void paint( node const& n ) const
+  {
+    this->_storage->nodes[n].data[1].h1 = current_color();
+  }
+
+  /*! \brief Assigns `color` to a node */
+  void paint( node const& n, uint32_t color ) const
+  {
+    this->_storage->nodes[n].data[1].h1 = color;
+  }
+
+  /*! \brief Copies the color from `other` to `n` */
+  void paint( node const& n, node const& other ) const
+  {
+    this->_storage->nodes[n].data[1].h1 = color( other );
+  }
+
+  /*! \brief Evaluates a predicate on the color of a node */
+  template<typename Pred>
+  bool eval_color( node const& n, Pred&& pred ) const
+  {
+    return pred( color( n ) );
+  }
+
+  /*! \brief Evaluates a predicate on the colors of two nodes */
+  template<typename Pred>
+  bool eval_color( node const& a, node const& b, Pred&& pred ) const
+  {
+    return pred( color( a ), color( b ) );
+  }
+
+  /*! \brief Evaluates a predicate on the colors of the fanins of a node */
+  template<typename Pred>
+  bool eval_fanins_color( node const& n, Pred&& pred ) const
+  {
+    bool result = true;
+    this->foreach_fanin( n, [&]( signal const& fi ) {
+      if ( !pred( color( this->get_node( fi ) ) ) )
+      {
+        result = false;
+        return false;
+      }
+      return true;
+    } );
+    return result;
+  }
+
+protected:
+  // mutable uint32_t value{0};
+}; /* color_view */
+
+/*!\brief Manager view for traversal IDs (out-of-place storage).
+ *
+ * Traversal IDs, called colors, are unsigned integers that can be
+ * assigned to nodes.  The corresponding values are stored
+ * out-of-place in this view.
+ */
+template<typename Ntk>
+class out_of_place_color_view : public Ntk
+{
+public:
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+public:
+  explicit out_of_place_color_view( Ntk const& ntk )
+      : Ntk( ntk ), values( ntk.size() )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  }
+
+  uint32_t new_color() const
+  {
+    return ++value;
+  }
+
+  uint32_t current_color() const
+  {
+    return value;
+  }
+
+  void clear_colors( uint32_t color = 0 ) const
+  {
+    std::for_each( std::begin( values ), std::end( values ),
+                   [color]( auto& v ) { v = color; } );
+  }
+
+  auto color( node const& n ) const
+  {
+    return values[n];
+  }
+
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  auto color( signal const& n ) const
+  {
+    return values[this->get_node( n )];
+  }
+
+  void paint( node const& n ) const
+  {
+    values[n] = value;
+  }
+
+  void paint( node const& n, uint32_t color ) const
+  {
+    values[n] = color;
+  }
+
+  void paint( node const& n, node const& other ) const
+  {
+    values[n] = values[other];
+  }
+
+  /*! \brief Evaluates a predicate on the color of a node */
+  template<typename Pred>
+  bool eval_color( node const& n, Pred&& pred ) const
+  {
+    return pred( color( n ) );
+  }
+
+  /*! \brief Evaluates a predicate on the colors of two nodes */
+  template<typename Pred>
+  bool eval_color( node const& a, node const& b, Pred&& pred ) const
+  {
+    return pred( color( a ), color( b ) );
+  }
+
+  /*! \brief Evaluates a predicate on the colors of the fanins of a node */
+  template<typename Pred>
+  bool eval_fanins_color( node const& n, Pred&& pred ) const
+  {
+    bool result = true;
+    this->foreach_fanin( n, [&]( signal const& fi ) {
+      if ( !pred( color( this->get_node( fi ) ) ) )
+      {
+        result = false;
+        return false;
+      }
+      return true;
+    } );
+    return result;
+  }
+
+protected:
+  mutable std::vector<uint32_t> values;
+  mutable uint32_t value{ 0 };
+}; /* out_of_place_color_view */
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/views/cost_view.hpp b/include/mockturtle/views/cost_view.hpp
new file mode 100644
index 0000000..eb6be69
--- /dev/null
+++ b/include/mockturtle/views/cost_view.hpp
@@ -0,0 +1,281 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cost_view.hpp
+  \brief Implements various cost estimation methods for a network
+
+  \author Hanyu Wang
+*/
+
+#pragma once
+
+#include "../networks/events.hpp"
+#include "../traits.hpp"
+#include "../utils/node_map.hpp"
+#include "../utils/recursive_cost_functions.hpp"
+#include "immutable_view.hpp"
+
+#include <cstdint>
+#include <vector>
+
+namespace mockturtle
+{
+
+/*! \brief Implements `get_cost` methods for networks.
+ *
+ * This view computes the cost of the entire network, a subnetwork, and
+ * also fanin cone of a single node. It maintains the context of each
+ * node, which is the aggregated variables that affect the cost a node.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `get_node`
+ * - `visited`
+ * - `set_visited`
+ * - `foreach_fanin`
+ * - `foreach_po`
+ *
+ * Example
+ *
+   \verbatim embed:rst
+
+   .. code-block:: c++
+
+      // create network somehow
+      xag_network xag = ...;
+
+      // create a cost view on the network, for example size cost
+      auto viewed = cost_view( xag, xag_size_cost_function<xag_network>() );
+
+      // print size
+      std::cout << "size: " << viewed.get_cost() << "\n";
+   \endverbatim
+ */
+template<class Ntk, class RecCostFn>
+class cost_view : public Ntk
+{
+public:
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  using context_t = typename RecCostFn::context_t;
+
+  explicit cost_view( RecCostFn const& cost_fn = {} )
+      : Ntk(),
+        _cost_fn( cost_fn ),
+        context( *this )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+    static_assert( has_visited_v<Ntk>, "Ntk does not implement the visited method" );
+    static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+    static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+
+    add_event = Ntk::events().register_add_event( [this]( auto const& n ) { on_add( n ); } );
+  }
+
+  explicit cost_view( Ntk const& ntk, RecCostFn const& cost_fn = {} )
+      : Ntk( ntk ),
+        _cost_fn( cost_fn ),
+        context( ntk )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+    static_assert( has_visited_v<Ntk>, "Ntk does not implement the visited method" );
+    static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+    static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+
+    update_cost();
+    add_event = Ntk::events().register_add_event( [this]( auto const& n ) { on_add( n ); } );
+  }
+
+  explicit cost_view( cost_view<Ntk, RecCostFn> const& other )
+      : Ntk( other ),
+        _cost_fn( other._cost_fn ),
+        context( other.context )
+  {
+    add_event = Ntk::events().register_add_event( [this]( auto const& n ) { on_add( n ); } );
+  }
+
+  cost_view<Ntk, RecCostFn>& operator=( cost_view<Ntk, RecCostFn> const& other )
+  {
+    /* delete the event of this network */
+    Ntk::events().release_add_event( add_event );
+
+    /* update the base class */
+    this->_storage = other._storage;
+    this->_events = other._events;
+
+    /* copy */
+    context = other.context;
+    _cost_fn = other._cost_fn;
+
+    add_event = Ntk::events().register_add_event( [this]( auto const& n ) { on_add( n ); } );
+
+    return *this;
+  }
+
+  ~cost_view()
+  {
+    Ntk::events().release_add_event( add_event );
+  }
+
+  /*! \brief Returns the context of node n */
+  context_t get_context( node const& n ) const
+  {
+    return context[n];
+  }
+
+  /*! \brief Assigns the context of node n */
+  void set_context( node const& n, context_t cost_val )
+  {
+    context[n] = cost_val;
+    this->set_visited( n, this->trav_id() );
+  }
+
+  /*! \brief Returns the cost of the entire network */
+  uint32_t get_cost() const
+  {
+    return _cost;
+  }
+
+  /*! \brief Returns the cost of node n's fanin cone */
+  uint32_t get_cost( node const& n )
+  {
+    uint32_t _c = 0u;
+    this->incr_trav_id();
+    compute_cost( n, _c );
+    return _c;
+  }
+
+  /*! \brief Returns the cost between node n and divs */
+  uint32_t get_cost( node const& n, std::vector<signal> const& divs )
+  {
+    uint32_t _c = 0u;
+    this->incr_trav_id();
+    for ( signal s : divs )
+    {
+      this->set_visited( this->get_node( s ), this->trav_id() );
+    }
+    compute_cost( n, _c );
+    return _c;
+  }
+
+  /*! \brief Updates the context and cost of the entire network */
+  void update_cost()
+  {
+    context.reset( context_t{} );
+    this->incr_trav_id();
+    compute_cost();
+  }
+
+  void on_add( node const& n )
+  {
+    context.resize();
+
+    std::vector<context_t> fanin_costs;
+    this->foreach_fanin( n, [&]( auto const& f ) {
+      fanin_costs.emplace_back( context[this->get_node( f )] );
+    } );
+    context[n] = _cost_fn( *this, n, fanin_costs );
+    _cost_fn( *this, n, _cost, context[n] );
+  }
+
+  /*! \brief Creates a PI with context assigned */
+  signal create_pi( context_t pi_cotext )
+  {
+    signal s = Ntk::create_pi();
+    context.resize();
+    set_context( this->get_node( s ), pi_cotext );
+    return s;
+  }
+
+  signal create_pi()
+  {
+    signal s = Ntk::create_pi();
+    context.resize();
+    return s;
+  }
+
+  void create_po( signal const& f )
+  {
+    Ntk::create_po( f );
+  }
+
+private:
+  context_t compute_cost( node const& n, uint32_t& _c )
+  {
+    context_t _context{};
+    if ( this->visited( n ) == this->trav_id() )
+    {
+      _context = context[n]; // do not update context
+      _cost_fn( *this, n, _c, _context );
+      return _context;
+    }
+    if ( this->is_constant( n ) )
+    {
+      _context = context[n] = context_t{};
+    }
+    else if ( this->is_pi( n ) )
+    {
+      _context = context[n] = _cost_fn( *this, n );
+    }
+    else
+    {
+      std::vector<context_t> fanin_costs;
+      this->foreach_fanin( n, [&]( auto const& f ) {
+        fanin_costs.emplace_back( compute_cost( this->get_node( f ), _c ) );
+      } );
+      _context = context[n] = _cost_fn( *this, n, fanin_costs );
+    }
+    _cost_fn( *this, n, _c, _context );
+    this->set_visited( n, this->trav_id() );
+    return _context;
+  }
+  void compute_cost()
+  {
+    _cost = 0u; /* must define the zero initialization */
+    this->foreach_po( [&]( auto const& f ) {
+      compute_cost( this->get_node( f ), _cost );
+    } );
+  }
+
+  node_map<context_t, Ntk> context;
+  uint32_t _cost;
+  RecCostFn _cost_fn;
+
+  std::shared_ptr<typename network_events<Ntk>::add_event_type> add_event;
+};
+
+template<class T>
+cost_view( T const& ) -> cost_view<T, typename T::RecCostFn>;
+
+template<class T, class RecCostFn>
+cost_view( T const&, RecCostFn const& ) -> cost_view<T, RecCostFn>;
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/views/cut_view.hpp b/include/mockturtle/views/cut_view.hpp
new file mode 100644
index 0000000..eb0b57f
--- /dev/null
+++ b/include/mockturtle/views/cut_view.hpp
@@ -0,0 +1,232 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cut_view.hpp
+  \brief Implements an isolated view on a single cut in a network
+
+  \author Bruno Schmitt
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <type_traits>
+#include <vector>
+
+#include <parallel_hashmap/phmap.h>
+
+#include "../networks/detail/foreach.hpp"
+#include "../traits.hpp"
+#include "immutable_view.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Implements an isolated view on a single cut in a network.
+ *
+ * This view can create a network from a single cut in a largest network.  This
+ * cut has a single output `root` and set of `leaves`.  The view reimplements
+ * the methods `size`, `num_pis`, `num_pos`, `foreach_pi`, `foreach_po`,
+ * `foreach_node`, `foreach_gate`, `is_pi`, `node_to_index`, and
+ * `index_to_node`.
+ *
+ * This view assumes that all nodes' visited flags are set 0 before creating
+ * the view.  The view guarantees that all the nodes in the view will have a 0
+ * visited flag after the construction.
+ *
+ * **Required network functions:**
+ * - `set_visited`
+ * - `visited`
+ * - `get_node`
+ * - `get_constant`
+ * - `is_constant`
+ * - `make_signal`
+ */
+template<typename Ntk>
+class cut_view : public immutable_view<Ntk>
+{
+public:
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  static constexpr bool is_topologically_sorted = true;
+
+public:
+  explicit cut_view( Ntk const& ntk, std::vector<node> const& leaves, signal const& root )
+      : immutable_view<Ntk>( ntk ), _root( root )
+  {
+    construct( leaves );
+  }
+
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  explicit cut_view( Ntk const& ntk, std::vector<signal> const& leaves, signal const& root )
+      : immutable_view<Ntk>( ntk ), _root( root )
+  {
+    construct( leaves );
+  }
+
+private:
+  template<typename LeaveType>
+  void construct( std::vector<LeaveType> const& leaves )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+    static_assert( has_visited_v<Ntk>, "Ntk does not implement the visited method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+    static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+    static_assert( has_make_signal_v<Ntk>, "Ntk does not implement the make_signal method" );
+    static_assert( has_incr_trav_id_v<Ntk>, "Ntk does not implement the incr_trav_id method" );
+    static_assert( has_trav_id_v<Ntk>, "Ntk does not implement the trav_id method" );
+    static_assert( std::is_same_v<LeaveType, node> || std::is_same_v<LeaveType, signal>, "leaves must be vector of either node or signal" );
+
+    this->incr_trav_id();
+
+    /* constants */
+    add_constants();
+
+    /* primary inputs */
+    for ( auto const& leaf : leaves )
+    {
+      if constexpr ( std::is_same_v<LeaveType, node> )
+      {
+        add_leaf( leaf );
+      }
+      else
+      {
+        add_leaf( this->get_node( leaf ) );
+      }
+    }
+
+    traverse( this->get_node( _root ) );
+
+    /* restore visited */
+    // for ( auto const& n : _nodes )
+    //{
+    //   this->set_visited( n, 0 );
+    // }
+  }
+
+public:
+  inline auto size() const { return _nodes.size(); }
+  inline auto num_pis() const { return _num_leaves; }
+  inline auto num_pos() const { return 1; }
+  inline auto num_gates() const { return _nodes.size() - _num_leaves - _num_constants; }
+
+  inline auto node_to_index( const node& n ) const { return _node_to_index.at( n ); }
+  inline auto index_to_node( uint32_t index ) const { return _nodes[index]; }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    std::vector<signal> roots{ { _root } };
+    detail::foreach_element( roots.begin(), roots.end(), fn );
+  }
+
+  inline bool is_pi( node const& pi ) const
+  {
+    const auto beg = _nodes.begin() + _num_constants;
+    return std::find( beg, beg + _num_leaves, pi ) != beg + _num_leaves;
+  }
+
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( _nodes.begin() + _num_constants, _nodes.begin() + _num_constants + _num_leaves, fn );
+  }
+
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    detail::foreach_element( _nodes.begin(), _nodes.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    detail::foreach_element( _nodes.begin() + _num_constants + _num_leaves, _nodes.end(), fn );
+  }
+
+private:
+  inline void add_constants()
+  {
+    add_node( this->get_node( this->get_constant( false ) ) );
+    this->set_visited( this->get_node( this->get_constant( false ) ), this->trav_id() );
+    if ( this->get_node( this->get_constant( true ) ) != this->get_node( this->get_constant( false ) ) )
+    {
+      add_node( this->get_node( this->get_constant( true ) ) );
+      this->set_visited( this->get_node( this->get_constant( true ) ), this->trav_id() );
+      ++_num_constants;
+    }
+  }
+
+  inline void add_leaf( node const& leaf )
+  {
+    if ( this->visited( leaf ) == this->trav_id() )
+      return;
+
+    add_node( leaf );
+    this->set_visited( leaf, this->trav_id() );
+    ++_num_leaves;
+  }
+
+  inline void add_node( node const& n )
+  {
+    _node_to_index[n] = static_cast<uint32_t>( _nodes.size() );
+    _nodes.push_back( n );
+  }
+
+  void traverse( node const& n )
+  {
+    if ( this->visited( n ) == this->trav_id() )
+      return;
+
+    this->foreach_fanin( n, [&]( const auto& f ) {
+      traverse( this->get_node( f ) );
+    } );
+
+    add_node( n );
+    this->set_visited( n, this->trav_id() );
+  }
+
+public:
+  unsigned _num_constants{ 1 };
+  unsigned _num_leaves{ 0 };
+  std::vector<node> _nodes;
+  phmap::flat_hash_map<node, uint32_t> _node_to_index;
+  signal _root;
+};
+
+template<class T>
+cut_view( T const&, std::vector<node<T>> const&, signal<T> const& ) -> cut_view<T>;
+
+template<class T, typename = std::enable_if_t<!std::is_same_v<typename T::signal, typename T::node>>>
+cut_view( T const&, std::vector<signal<T>> const&, signal<T> const& ) -> cut_view<T>;
+
+} /* namespace mockturtle */
diff --git a/include/mockturtle/views/depth_view.hpp b/include/mockturtle/views/depth_view.hpp
new file mode 100644
index 0000000..32941ec
--- /dev/null
+++ b/include/mockturtle/views/depth_view.hpp
@@ -0,0 +1,363 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file depth_view.hpp
+  \brief Implements depth and level for a network
+
+  \author Alessandro Tempia Calvino
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../networks/events.hpp"
+#include "../traits.hpp"
+#include "../utils/cost_functions.hpp"
+#include "../utils/node_map.hpp"
+#include "immutable_view.hpp"
+
+#include <cstdint>
+#include <vector>
+
+namespace mockturtle
+{
+
+struct depth_view_params
+{
+  /*! \brief Take complemented edges into account for depth computation. */
+  bool count_complements{ false };
+
+  /*! \brief Whether PIs have costs. */
+  bool pi_cost{ false };
+};
+
+/*! \brief Implements `depth` and `level` methods for networks.
+ *
+ * This view computes the level of each node and also the depth of
+ * the network.  It implements the network interface methods
+ * `level` and `depth`.  The levels are computed at construction
+ * and can be recomputed by calling the `update_levels` method.
+ *
+ * It also automatically updates levels, and depth when creating nodes or
+ * creating a PO on a depth_view, however, it does not update the information,
+ * when modifying or deleting nodes, neither will the critical paths be
+ * recalculated (due to efficiency reasons).  In order to recalculate levels,
+ * depth, and critical paths, one can call `update_levels` instead.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `get_node`
+ * - `visited`
+ * - `set_visited`
+ * - `foreach_fanin`
+ * - `foreach_po`
+ *
+ * Example
+ *
+   \verbatim embed:rst
+
+   .. code-block:: c++
+
+      // create network somehow
+      aig_network aig = ...;
+
+      // create a depth view on the network
+      depth_view aig_depth{aig};
+
+      // print depth
+      std::cout << "Depth: " << aig_depth.depth() << "\n";
+   \endverbatim
+ */
+template<class Ntk, class NodeCostFn = unit_cost<Ntk>, bool has_depth_interface = has_depth_v<Ntk>&& has_level_v<Ntk>&& has_update_levels_v<Ntk>>
+class depth_view
+{
+};
+
+template<class Ntk, class NodeCostFn>
+class depth_view<Ntk, NodeCostFn, true> : public Ntk
+{
+public:
+  depth_view( Ntk const& ntk, depth_view_params const& ps = {} ) : Ntk( ntk )
+  {
+    (void)ps;
+  }
+};
+
+template<class Ntk, class NodeCostFn>
+class depth_view<Ntk, NodeCostFn, false> : public Ntk
+{
+public:
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  explicit depth_view( NodeCostFn const& cost_fn = {}, depth_view_params const& ps = {} )
+      : Ntk(), _ps( ps ), _levels( *this ), _crit_path( *this ), _cost_fn( cost_fn )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+    static_assert( has_visited_v<Ntk>, "Ntk does not implement the visited method" );
+    static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+    static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+
+    add_event = Ntk::events().register_add_event( [this]( auto const& n ) { on_add( n ); } );
+  }
+
+  /*! \brief Standard constructor.
+   *
+   * \param ntk Base network
+   */
+  explicit depth_view( Ntk const& ntk, NodeCostFn const& cost_fn = {}, depth_view_params const& ps = {} )
+      : Ntk( ntk ), _ps( ps ), _levels( ntk ), _crit_path( ntk ), _cost_fn( cost_fn )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_is_complemented_v<Ntk>, "Ntk does not implement the is_complemented method" );
+    static_assert( has_visited_v<Ntk>, "Ntk does not implement the visited method" );
+    static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+    static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+
+    update_levels();
+
+    add_event = Ntk::events().register_add_event( [this]( auto const& n ) { on_add( n ); } );
+  }
+
+  /*! \brief Copy constructor. */
+  explicit depth_view( depth_view<Ntk, NodeCostFn, false> const& other )
+      : Ntk( other ), _ps( other._ps ), _levels( other._levels ), _crit_path( other._crit_path ), _depth( other._depth ), _cost_fn( other._cost_fn )
+  {
+    add_event = Ntk::events().register_add_event( [this]( auto const& n ) { on_add( n ); } );
+  }
+
+  depth_view<Ntk, NodeCostFn, false>& operator=( depth_view<Ntk, NodeCostFn, false> const& other )
+  {
+    /* delete the event of this network */
+    Ntk::events().release_add_event( add_event );
+
+    /* update the base class */
+    this->_storage = other._storage;
+    this->_events = other._events;
+
+    /* copy */
+    _ps = other._ps;
+    _levels = other._levels;
+    _crit_path = other._crit_path;
+    _depth = other._depth;
+    _cost_fn = other._cost_fn;
+
+    /* register new event in the other network */
+    add_event = Ntk::events().register_add_event( [this]( auto const& n ) { on_add( n ); } );
+
+    return *this;
+  }
+
+  ~depth_view()
+  {
+    Ntk::events().release_add_event( add_event );
+  }
+
+  uint32_t depth() const
+  {
+    return _depth;
+  }
+
+  uint32_t level( node const& n ) const
+  {
+    return _levels[n];
+  }
+
+  bool is_on_critical_path( node const& n ) const
+  {
+    return _crit_path[n];
+  }
+
+  void set_level( node const& n, uint32_t level )
+  {
+    _levels[n] = level;
+  }
+
+  void set_depth( uint32_t level )
+  {
+    _depth = level;
+  }
+
+  void update_levels()
+  {
+    _levels.reset( 0 );
+    _crit_path.reset( false );
+
+    this->incr_trav_id();
+    compute_levels();
+  }
+
+  void resize_levels()
+  {
+    _levels.resize();
+  }
+
+  void create_po( signal const& f )
+  {
+    Ntk::create_po( f );
+    _depth = std::max( _depth, _levels[f] );
+  }
+
+private:
+  uint32_t compute_levels( node const& n )
+  {
+    if ( this->visited( n ) == this->trav_id() )
+    {
+      return _levels[n];
+    }
+    this->set_visited( n, this->trav_id() );
+
+    if ( this->is_constant( n ) )
+    {
+      return _levels[n] = 0;
+    }
+    if ( this->is_ci( n ) )
+    {
+      assert( !_ps.pi_cost || _cost_fn( *this, n ) >= 1 );
+      return _levels[n] = _ps.pi_cost ? _cost_fn( *this, n ) - 1 : 0;
+    }
+
+    uint32_t level{ 0 };
+    this->foreach_fanin( n, [&]( auto const& f ) {
+      auto clevel = compute_levels( this->get_node( f ) );
+      if ( _ps.count_complements && this->is_complemented( f ) )
+      {
+        clevel++;
+      }
+      level = std::max( level, clevel );
+    } );
+
+    return _levels[n] = level + _cost_fn( *this, n );
+  }
+
+  void compute_levels()
+  {
+    _depth = 0;
+    this->foreach_po( [&]( auto const& f ) {
+      auto clevel = compute_levels( this->get_node( f ) );
+      if ( _ps.count_complements && this->is_complemented( f ) )
+      {
+        clevel++;
+      }
+      _depth = std::max( _depth, clevel );
+    } );
+
+    if constexpr ( has_foreach_ri_v<Ntk> )
+    {
+      this->foreach_ri( [&]( auto const& f ) {
+        auto clevel = compute_levels( this->get_node( f ) );
+        if ( _ps.count_complements && this->is_complemented( f ) )
+        {
+          clevel++;
+        }
+        _depth = std::max( _depth, clevel );
+      } );
+    }
+
+    this->foreach_po( [&]( auto const& f ) {
+      const auto n = this->get_node( f );
+      if ( _levels[n] == _depth )
+      {
+        set_critical_path( n );
+      }
+    } );
+
+    if constexpr ( has_foreach_ri_v<Ntk> )
+    {
+      this->foreach_ri( [&]( auto const& f ) {
+        const auto n = this->get_node( f );
+        if ( _levels[n] == _depth )
+        {
+          set_critical_path( n );
+        }
+      } );
+    }
+  }
+
+  void set_critical_path( node const& n )
+  {
+    _crit_path[n] = true;
+    if ( !this->is_constant( n ) && !( _ps.pi_cost && this->is_pi( n ) ) )
+    {
+      const auto lvl = _levels[n];
+      this->foreach_fanin( n, [&]( auto const& f ) {
+        const auto cn = this->get_node( f );
+        auto offset = _cost_fn( *this, n );
+        if ( _ps.count_complements && this->is_complemented( f ) )
+        {
+          offset++;
+        }
+        if ( _levels[cn] + offset == lvl && !_crit_path[cn] )
+        {
+          set_critical_path( cn );
+        }
+      } );
+    }
+  }
+
+  void on_add( node const& n )
+  {
+    _levels.resize();
+
+    uint32_t level{ 0 };
+    this->foreach_fanin( n, [&]( auto const& f ) {
+      auto clevel = _levels[f];
+      if ( _ps.count_complements && this->is_complemented( f ) )
+      {
+        clevel++;
+      }
+      level = std::max( level, clevel );
+    } );
+
+    _levels[n] = level + _cost_fn( *this, n );
+  }
+
+  depth_view_params _ps;
+  node_map<uint32_t, Ntk> _levels;
+  node_map<uint32_t, Ntk> _crit_path;
+  uint32_t _depth{};
+  NodeCostFn _cost_fn;
+
+  std::shared_ptr<typename network_events<Ntk>::add_event_type> add_event;
+};
+
+template<class T>
+depth_view( T const& ) -> depth_view<T>;
+
+template<class T, class NodeCostFn = unit_cost<T>>
+depth_view( T const&, NodeCostFn const&, depth_view_params const& ) -> depth_view<T, NodeCostFn>;
+
+} // namespace mockturtle
diff --git a/include/mockturtle/views/dont_care_view.hpp b/include/mockturtle/views/dont_care_view.hpp
new file mode 100644
index 0000000..f08d605
--- /dev/null
+++ b/include/mockturtle/views/dont_care_view.hpp
@@ -0,0 +1,481 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file dont_care_view.hpp
+  \brief Implements methods to store external don't-cares
+
+  \author Siang-Yun Lee
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+#include "../algorithms/simulation.hpp"
+#include "../algorithms/cnf.hpp"
+#include "../utils/node_map.hpp"
+#include "../utils/window_utils.hpp"
+#include "../views/color_view.hpp"
+#include "../views/window_view.hpp"
+
+#include <bill/sat/interface/common.hpp>
+
+#include <kitty/dynamic_truth_table.hpp>
+#include <kitty/cube.hpp>
+
+#include <vector>
+#include <set>
+#include <utility>
+
+namespace mockturtle
+{
+
+/*! \brief A view holding external don't care information of a network
+ *
+ * This view helps storing and managing external don't care information.
+ * There are two types of external don't cares that may be given together
+ * or independently:
+ *
+ * External controllability don't cares (EXCDCs) are primary input patterns
+ * that will never happen or can be ignored. They are given as another
+ * network `cdc_ntk` having the same number of PIs as the main network and
+ * one PO. An input assignment making `cdc_ntk` output 1 is an EXCDC.
+ *
+ * External observability don't cares (EXODCs) are conditions for one or
+ * more primary outputs under which their values can be altered. EXODCs may
+ * be given for a PO as value combinations of other POs (for example, “the
+ * second PO is don't care whenever the first PO is 1”). They may also be
+ * given as pairs of observably equivalent PO values (for example, “the output
+ * values 01 and 10 are considered equivalent and interchangable”).
+ *
+ * By wrapping a network with this view and giving some external don't care
+ * conditions, some algorithms supporting the consideration of external don't
+ * cares can make use of them. Currently, only `sim_resubstitution`
+ * (which makes use of `circuit_validator`) and `equivalence_checking_bill`
+ * support external don't cares.
+ *
+ * \tparam hasEXCDC Enables interfaces and data structure holding external
+ * controllability don't cares (external don't cares at the primary inputs)
+ * \tparam hasEXODC Enables interfaces and data structure holding external
+ * observability don't cares (external dont cares at the primary outputs)
+ */
+template<class Ntk, bool hasEXCDC = true, bool hasEXODC = true>
+class dont_care_view;
+
+namespace detail
+{
+
+/*! \brief A manager to classify bit-strings into equivalence classes
+ *
+ * This data structure holds and manages equivalence classes of
+ * bit-strings of the same length (i.e. complete or partial binary
+ * truth tables).
+ * The three properties of an equivalence relation are maintained:
+ * - Reflexive (x = x)
+ * - Symmetric (if x = y then y = x)
+ * - Transitive (if x = y and y = z then x = z)
+ *
+ * In the current implementation, the big-string length may not be
+ * larger than 31.
+ */
+class equivalence_classes_mgr
+{
+public:
+  equivalence_classes_mgr() {}
+
+  equivalence_classes_mgr( uint32_t num_bits ) : _num_bits( num_bits )
+  {
+    assert( num_bits < 32 );
+    uint32_t max_val = 1u << num_bits;
+    _classes.resize( max_val );
+    for ( uint32_t i = 0u; i < max_val; ++i )
+    {
+      _classes[i] = i;
+    }
+  }
+
+  equivalence_classes_mgr& operator=( equivalence_classes_mgr const& other )
+  {
+    _num_bits = other._num_bits;
+    _classes = other._classes;
+    return *this;
+  }
+
+  void set_equivalent( uint32_t const& a, uint32_t const& b )
+  {
+    uint32_t repr_class = _classes.at( a );
+    uint32_t to_be_replaced = _classes.at( b );
+    for ( auto i = 0u; i < _classes.size(); ++i )
+    {
+      if ( _classes[i] == to_be_replaced )
+        _classes[i] = repr_class;
+    }
+  }
+
+  /*! \brief Set two bit strings to be equivalent. */
+  void set_equivalent( std::vector<bool> const& a, std::vector<bool> const& b )
+  {
+    set_equivalent( vector_bool_to_uint32( a ), vector_bool_to_uint32( b ) );
+  }
+
+  /*! \brief Check equivalence of fully-assigned bit-strings */
+  bool are_equivalent( uint32_t const& a, uint32_t const& b ) const
+  {
+    return _classes.at( a ) == _classes.at( b );
+  }
+
+  /*! \brief Check equivalence of fully-assigned bit-strings */
+  bool are_equivalent( std::vector<bool> const& a, std::vector<bool> const& b ) const
+  {
+    return are_equivalent( vector_bool_to_uint32( a ), vector_bool_to_uint32( b ) );
+  }
+
+  /*! \brief Check equivalence of partially-assigned bit-strings
+   *
+   * The don't-care bit positions in the two cubes should be the same.
+   * Two cubes are equivalent if for all possible assignments to the
+   * don't-care bits, they are always equivalent.
+   */
+  bool are_equivalent( kitty::cube const& a, kitty::cube const& b ) const
+  {
+    assert( a._mask == b._mask && "The don't-care bit positions in the two cubes should be the same." );
+    return are_equivalent_rec( a, b, 0 );
+  }
+
+  uint32_t num_classes() const
+  {
+    std::set<uint32_t> unique_ids;
+    for ( auto const& id : _classes )
+    {
+      unique_ids.insert( id );
+    }
+    return unique_ids.size();
+  }
+
+  template<class Fn>
+  void foreach_class( Fn&& fn ) const
+  {
+    std::unordered_map<uint32_t, std::vector<uint32_t>> class2pats;
+    for ( auto pat = 0u; pat < _classes.size(); ++pat )
+    {
+      auto const& id = _classes[pat];
+      class2pats.try_emplace( id );
+      class2pats[id].emplace_back( pat );
+    }
+    
+    for ( auto const& p : class2pats )
+    {
+      if ( !fn( p.second ) )
+        break;
+    }
+  }
+
+private:
+  bool are_equivalent_rec( kitty::cube const& a, kitty::cube const& b, uint32_t i ) const
+  {
+    if ( i == _num_bits )
+    {
+      return are_equivalent( cube_to_uint32( a ), cube_to_uint32( b ) );
+    }
+
+    if ( a.get_mask( i ) )
+    {
+      return are_equivalent_rec( a, b, i + 1 );
+    }
+    else
+    {
+      kitty::cube a0 = a;
+      a0.set_mask( i );
+      kitty::cube b0 = b;
+      b0.set_mask( i );
+      if ( !are_equivalent_rec( a0, b0, i + 1 ) )
+        return false;
+      a0.set_bit( i );
+      b0.set_bit( i );
+      return are_equivalent_rec( a0, b0, i + 1 );
+    }
+  }
+
+  uint32_t vector_bool_to_uint32( std::vector<bool> const& vec ) const
+  {
+    assert( vec.size() == _num_bits );
+    uint32_t res{0u};
+    for ( auto i = 0u; i < _num_bits; ++i )
+    {
+      if ( vec[i] )
+        res |= 1u << i;
+    }
+    return res;
+  }
+
+  uint32_t cube_to_uint32( kitty::cube const& c ) const
+  {
+    assert( c.num_literals() == _num_bits ); // fully assigned
+    return c._bits;
+  }
+
+private:
+  uint32_t _num_bits;
+  std::vector<uint32_t> _classes;
+}; // equivalence_classes_mgr
+
+template<class Ntk, bool hasEXCDC>
+class dont_care_view_impl : public Ntk
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+public:
+  template<bool enabled = !hasEXCDC, typename = std::enable_if_t<enabled>>
+  dont_care_view_impl( Ntk const& ntk )
+    : Ntk( ntk )
+  {}
+
+  template<bool enabled = hasEXCDC, typename = std::enable_if_t<enabled>>
+  dont_care_view_impl( Ntk const& ntk, Ntk const& cdc_ntk )
+    : Ntk( ntk ), _excdc( cdc_ntk )
+  {
+    assert( cdc_ntk.num_pis() == ntk.num_pis() );
+    assert( cdc_ntk.num_pos() == 1 );
+  }
+
+  /*! \brief Checks whether an input pattern is EXCDC
+   *
+   * \param pattern The PI value combination to be checked
+   * \return Whether `pattern` is EXCDC
+   */
+  template<bool enabled = hasEXCDC, typename = std::enable_if_t<enabled>>
+  bool pattern_is_EXCDC( std::vector<bool> const& pattern ) const
+  {
+    assert( pattern.size() == this->num_pis() );
+
+    default_simulator<bool> sim( pattern );
+    auto const vals = simulate<bool>( _excdc, sim );
+    return vals[0];
+  }
+
+  template<typename solver_t, bool enabled = hasEXCDC, typename = std::enable_if_t<enabled>>
+  void add_EXCDC_clauses( solver_t& solver ) const
+  {
+    using add_clause_fn_t = std::function<void( std::vector<bill::lit_type> const& )>;
+    add_clause_fn_t const add_clause_fn = [&]( auto const& clause ) { solver.add_clause( clause ); };
+
+    // topological order of the gates in _excdc is assumed
+    node_map<bill::lit_type, Ntk> cdc_lits( _excdc );
+    cdc_lits[_excdc.get_constant( false )] = bill::lit_type( 0, bill::lit_type::polarities::positive );
+    if ( _excdc.get_node( _excdc.get_constant( false ) ) != _excdc.get_node( _excdc.get_constant( true ) ) )
+    {
+      cdc_lits[_excdc.get_constant( true )] = bill::lit_type( 0, bill::lit_type::polarities::negative );
+    }
+    _excdc.foreach_pi( [&]( auto const& n, auto i ) {
+      cdc_lits[n] = bill::lit_type( i + 1, bill::lit_type::polarities::positive );
+    } );
+
+    _excdc.foreach_gate( [&]( auto const& n ){
+      cdc_lits[n] = bill::lit_type( solver.add_variable(), bill::lit_type::polarities::positive );
+    });
+
+    auto out_lits = generate_cnf<Ntk, bill::lit_type>( _excdc, add_clause_fn, cdc_lits );
+    solver.add_clause( {~out_lits[0]} );
+  }
+
+private:
+  Ntk _excdc;
+}; /* dont_care_view_impl */
+} // namespace detail
+
+template<class Ntk, bool hasEXCDC>
+class dont_care_view<Ntk, hasEXCDC, false> : public detail::dont_care_view_impl<Ntk, hasEXCDC>
+{
+public:
+  static constexpr bool has_EXCDC_interface = hasEXCDC;
+  static constexpr bool has_EXODC_interface = false;
+
+public:
+  template<bool enabled = !hasEXCDC, typename = std::enable_if_t<enabled>>
+  dont_care_view( Ntk const& ntk )
+    : detail::dont_care_view_impl<Ntk, hasEXCDC>( ntk )
+  {}
+
+  template<bool enabled = hasEXCDC, typename = std::enable_if_t<enabled>>
+  dont_care_view( Ntk const& ntk, Ntk const& cdc_ntk )
+    : detail::dont_care_view_impl<Ntk, hasEXCDC>( ntk, cdc_ntk )
+  {}
+};
+
+template<class Ntk, bool hasEXCDC>
+class dont_care_view<Ntk, hasEXCDC, true> : public detail::dont_care_view_impl<Ntk, hasEXCDC>
+{
+public:
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  static constexpr bool has_EXCDC_interface = hasEXCDC;
+  static constexpr bool has_EXODC_interface = true;
+
+public:
+  /*! \brief Constructor when no EXCDC is provided
+   *
+   * \param ntk The main network
+   */
+  template<bool enabled = !hasEXCDC, typename = std::enable_if_t<enabled>>
+  dont_care_view( Ntk const& ntk )
+    : detail::dont_care_view_impl<Ntk, hasEXCDC>( ntk ), _exoec( ntk.num_pos() )
+  {}
+
+  /*! \brief Constructor when EXCDC is provided
+   *
+   * \param ntk The main network
+   * \param cdc_ntk The network representing EXCDC conditions, having the same
+   * number of PIs as `ntk` and one PO
+   */
+  template<bool enabled = hasEXCDC, typename = std::enable_if_t<enabled>>
+  dont_care_view( Ntk const& ntk, Ntk const& cdc_ntk )
+    : detail::dont_care_view_impl<Ntk, hasEXCDC>( ntk, cdc_ntk ), _exoec( ntk.num_pos() )
+  {}
+
+  /*! \brief Adds an EXODC condition for a PO in terms of other POs
+   *
+   * \param cond Condition in terms of other POs for the concerned PO to be don't care
+   * \param po_id Index of the concerned PO
+   */
+  void add_EXODC( kitty::cube const& cond, uint32_t po_id )
+  {
+    cond.foreach_minterm( this->num_pos(), [&]( kitty::cube const& c ){
+      assert( c.num_literals() == this->num_pos() );
+      if ( c.get_bit( po_id ) ) return true;
+      kitty::cube c2 = c;
+      c2.set_bit( po_id );
+      _exoec.set_equivalent( c._bits, c2._bits );
+      return true;
+    });
+  }
+
+  /*! \brief Adds a pair of PO values that are considered observably equivalent
+   *
+   * \param pat1 The first PO value combination
+   * \param pat2 The second PO value combination
+   */
+  void add_EXOEC_pair( std::vector<bool> const& pat1, std::vector<bool> const& pat2 )
+  {
+    _exoec.set_equivalent( pat1, pat2 );
+  }
+
+  /*! \brief Checks whether a pair of PO value assignments are observably equivalent
+   *
+   * \param pat1 The first PO value combination
+   * \param pat2 The second PO value combination
+   * \return Whether `pat1` and `pat2` are observably equivalent
+   */
+  bool are_observably_equivalent( std::vector<bool> const& pat1, std::vector<bool> const& pat2 ) const
+  {
+    return _exoec.are_equivalent( pat1, pat2 );
+  }
+
+  /*! \brief Checks whether a pair of partial PO value assignments are observably equivalent
+   *
+   * For a pair of partial assignments to be equivalent, all pairs of expansions of
+   * the partial assignments have to be equivalent.
+   *
+   * \param pat1 The first partial PO value
+   * \param pat2 The second partial PO value
+   * \return Whether `pat1` and `pat2` are observably equivalent
+   */
+  bool are_observably_equivalent( kitty::cube const& pat1, kitty::cube const& pat2 ) const
+  {
+    return _exoec.are_equivalent( pat1, pat2 );
+  }
+
+  /*! \brief Builds an observability-equivalence miter network
+   *
+   * An observability-equivalence miter network is a generalization of a miter network.
+   * This network takes two PO value combinations as inputs (thus it has
+   * `2 * ntk.num_pos()` PIs) and outputs 1 if the two PO value combinations are
+   * _not_ observably equivalent.
+   *
+   * \param miter An empty network where the miter will be built
+   */
+  void build_oe_miter( Ntk& miter ) const
+  {
+    std::vector<signal> pos1, pos2;
+    for ( auto i = 0u; i < this->num_pos(); ++i )
+    {
+      pos1.emplace_back( miter.create_pi() );
+    }
+    for ( auto i = 0u; i < this->num_pos(); ++i )
+    {
+      pos2.emplace_back( miter.create_pi() );
+    }
+    build_oe_miter( miter, pos1, pos2 );
+  }
+
+  /*! \brief Builds an observability-equivalence miter network
+   *
+   * An observability-equivalence miter network is a generalization of a miter network.
+   * This network takes two PO value combinations as inputs (thus it has
+   * `2 * ntk.num_pos()` PIs) and outputs 1 if the two PO value combinations are
+   * _not_ observably equivalent.
+   *
+   * \param miter The network where the miter will be built
+   * \param pos1 Signals of the first set of (main network's) POs
+   * \param pos2 Signals of the second set of (main network's) POs
+   */
+  template<class NtkMiter>
+  void build_oe_miter( NtkMiter& miter, std::vector<typename NtkMiter::signal> const& pos1, std::vector<typename NtkMiter::signal> const& pos2 ) const
+  {
+    assert( pos1.size() == this->num_pos() );
+    assert( pos2.size() == this->num_pos() );
+
+    std::vector<typename NtkMiter::signal> are_both_in_class_i;
+    std::vector<typename NtkMiter::signal> is_in_class1, is_in_class2;
+    std::vector<typename NtkMiter::signal> ins1, ins2;
+    ins1.resize( this->num_pos() );
+    ins2.resize( this->num_pos() );
+    _exoec.foreach_class( [&]( std::vector<uint32_t> const& pats ){
+      is_in_class1.clear();
+      is_in_class2.clear();
+      for ( uint32_t pat : pats )
+      {
+        for ( auto i = 0u; i < this->num_pos(); ++i )
+        {
+          ins1[i] = ( pat & 0x1 ) ? pos1[i] : !pos1[i];
+          ins2[i] = ( pat & 0x1 ) ? pos2[i] : !pos2[i];
+          pat >>= 1;
+        }
+        is_in_class1.emplace_back( miter.create_nary_and( ins1 ) );
+        is_in_class2.emplace_back( miter.create_nary_and( ins2 ) );
+      }
+      are_both_in_class_i.emplace_back( miter.create_and( miter.create_nary_or( is_in_class1 ), miter.create_nary_or( is_in_class2 ) ) );
+      return true;
+    });
+    miter.create_po( !miter.create_nary_or( are_both_in_class_i ) );
+    /* miter output = 1 <=> there is no class i that pos1 and pos2 are both in <=> pos1 and pos2 are not OE */
+  }
+
+private:
+  detail::equivalence_classes_mgr _exoec;
+}; /* dont_care_view */
+
+} // namespace mockturtle
diff --git a/include/mockturtle/views/dont_touch_view.hpp b/include/mockturtle/views/dont_touch_view.hpp
new file mode 100644
index 0000000..7f70712
--- /dev/null
+++ b/include/mockturtle/views/dont_touch_view.hpp
@@ -0,0 +1,142 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file dont_touch_view.hpp
+  \brief Select nodes to be "don't touch"
+
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+
+#include <type_traits>
+#include <unordered_set>
+
+namespace mockturtle
+{
+
+/*! \brief Mark nodes as "don't touch".
+ *
+ * This view adds methods to mark nodes as don't touch. A don't touch node
+ * will be skipped during logic optimization or mapping.
+ * It always adds the functions `select_dont_touch`, `remove_dont_touch`,
+ * `is_dont_touch`.
+ *
+ * **Required network functions:**
+ * - `size`
+ *
+ * Example
+ *
+   \verbatim embed:rst
+
+   .. code-block:: c++
+
+      // create network somehow
+      klut_network klut = ...;
+      dont_touch_view klut_dont_touch{ klut };
+
+      // select dont touch nodes
+      klut_dont_touch.select_dont_touch( 20 );
+
+      // call technology mapping to map the rest of the network
+      binding_view<klut_network> res = emap( klut_dont_touch, tech_lib );
+   \endverbatim
+ */
+template<class Ntk>
+class dont_touch_view : public Ntk
+{
+public:
+  using node = typename Ntk::node;
+
+public:
+  explicit dont_touch_view()
+      : Ntk(), _dont_touch()
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+  }
+
+  explicit dont_touch_view( Ntk const& ntk )
+      : Ntk( ntk ), _dont_touch()
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  }
+
+  dont_touch_view<Ntk>& operator=( dont_touch_view<Ntk> const& dont_touch_ntk )
+  {
+    Ntk::operator=( dont_touch_ntk );
+    _dont_touch = dont_touch_ntk._dont_touch;
+    return *this;
+  }
+
+  void select_dont_touch( node const& n )
+  {
+    _dont_touch.insert( Ntk::node_to_index( n ) );
+  }
+
+  void remove_dont_touch( node const& n )
+  {
+    if ( auto it = _dont_touch.find( Ntk::node_to_index( n ) ); it != _dont_touch.end() )
+    {
+      _dont_touch.erase( it );
+    }
+  }
+
+  bool is_dont_touch( node const& n ) const
+  {
+    return _dont_touch.find( Ntk::node_to_index( n ) ) != _dont_touch.end();
+  }
+
+  template<typename Fn>
+  void foreach_dont_touch( Fn&& fn ) const
+  {
+    constexpr auto is_bool_f = std::is_invocable_r_v<bool, Fn, node>;
+    constexpr auto is_void_f = std::is_invocable_r_v<void, Fn, node>;
+
+    for ( auto el : _dont_touch )
+    {
+      if constexpr ( is_bool_f )
+      {
+        if ( !fn( Ntk::index_to_node( el ) ) )
+          return;
+      }
+      else
+      {
+        fn( Ntk::index_to_node( el ) );
+      }
+    }
+  }
+
+private:
+  std::unordered_set<uint32_t> _dont_touch;
+}; /* dont_touch_view */
+
+template<class T>
+dont_touch_view( T const& ) -> dont_touch_view<T>;
+
+} // namespace mockturtle
diff --git a/include/mockturtle/views/fanout_limit_view.hpp b/include/mockturtle/views/fanout_limit_view.hpp
new file mode 100644
index 0000000..acbef80
--- /dev/null
+++ b/include/mockturtle/views/fanout_limit_view.hpp
@@ -0,0 +1,293 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file fanout_limit_view.hpp
+  \brief View that replicates nodes whose fanout size exceed a limit
+
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../networks/mig.hpp"
+#include "../utils/node_map.hpp"
+
+namespace mockturtle
+{
+
+struct fanout_limit_view_params
+{
+  uint64_t fanout_limit{ 16 };
+};
+
+template<typename Ntk>
+class fanout_limit_view : public Ntk
+{
+public:
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+public:
+  fanout_limit_view( fanout_limit_view_params const ps = {} )
+      : replicas( *this ), ps( ps )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    assert( ps.fanout_limit > 0u );
+  }
+
+  uint32_t create_po( signal const& f )
+  {
+    if ( Ntk::is_maj( Ntk::get_node( f ) ) && Ntk::fanout_size( Ntk::get_node( f ) ) + 1 > ps.fanout_limit )
+    {
+      return Ntk::create_po( replicate_node( f ) );
+    }
+    else
+    {
+      return Ntk::create_po( f );
+    }
+  }
+
+  signal create_maj( signal const& a, signal const& b, signal const& c )
+  {
+    std::array<signal, 3u> fanins;
+    fanins[0u] = ( Ntk::is_maj( Ntk::get_node( a ) ) && Ntk::fanout_size( Ntk::get_node( a ) ) > ps.fanout_limit - 1 ) ? replicate_node( a ) : a;
+    fanins[1u] = ( Ntk::is_maj( Ntk::get_node( b ) ) && Ntk::fanout_size( Ntk::get_node( b ) ) > ps.fanout_limit - 1 ) ? replicate_node( b ) : b;
+    fanins[2u] = ( Ntk::is_maj( Ntk::get_node( c ) ) && Ntk::fanout_size( Ntk::get_node( c ) ) > ps.fanout_limit - 1 ) ? replicate_node( c ) : c;
+    return Ntk::create_maj( fanins[0u], fanins[1u], fanins[2u] );
+  }
+
+  signal create_and( signal const& a, signal const& b )
+  {
+    return create_maj( Ntk::get_constant( false ), a, b );
+  }
+
+  signal create_nand( signal const& a, signal const& b )
+  {
+    return !create_and( a, b );
+  }
+
+  signal create_or( signal const& a, signal const& b )
+  {
+    return create_maj( Ntk::get_constant( true ), a, b );
+  }
+
+  signal create_nor( signal const& a, signal const& b )
+  {
+    return !create_or( a, b );
+  }
+
+  signal create_lt( signal const& a, signal const& b )
+  {
+    return create_and( !a, b );
+  }
+
+  signal create_le( signal const& a, signal const& b )
+  {
+    return !create_and( a, !b );
+  }
+
+  signal create_xor( signal const& a, signal const& b )
+  {
+    const auto fcompl = a.complement ^ b.complement;
+    const auto c1 = create_and( +a, -b );
+    const auto c2 = create_and( +b, -a );
+    return create_and( !c1, !c2 ) ^ !fcompl;
+  }
+
+  signal create_ite( signal cond, signal f_then, signal f_else )
+  {
+    bool f_compl{ false };
+    if ( f_then.index < f_else.index )
+    {
+      std::swap( f_then, f_else );
+      cond.complement ^= 1;
+    }
+    if ( f_then.complement )
+    {
+      f_then.complement = 0;
+      f_else.complement ^= 1;
+      f_compl = true;
+    }
+
+    return create_and( !create_and( !cond, f_else ), !create_and( cond, f_then ) ) ^ !f_compl;
+  }
+
+  signal create_xor3( signal const& a, signal const& b, signal const& c )
+  {
+    const auto f = create_maj( a, !b, c );
+    const auto g = create_maj( a, b, !c );
+    return create_maj( !a, f, g );
+  }
+#pragma endregion
+
+#pragma region Create nary functions
+  signal create_nary_and( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), Ntk::get_constant( true ), [this]( auto const& a, auto const& b ) { return create_and( a, b ); } );
+  }
+
+  signal create_nary_or( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), Ntk::get_constant( false ), [this]( auto const& a, auto const& b ) { return create_or( a, b ); } );
+  }
+
+  signal create_nary_xor( std::vector<signal> const& fs )
+  {
+    return tree_reduce( fs.begin(), fs.end(), Ntk::get_constant( false ), [this]( auto const& a, auto const& b ) { return create_xor( a, b ); } );
+  }
+#pragma endregion
+
+#pragma region Create arbitrary functions
+  signal clone_node( mig_network const& other, node const& source, std::vector<signal> const& children )
+  {
+    (void)other;
+    (void)source;
+    assert( children.size() == 3u );
+    return create_maj( children[0u], children[1u], children[2u] );
+  }
+#pragma endregion
+
+  signal replicate_node( signal const& s )
+  {
+    return Ntk::is_complemented( s ) ? !replicate_node( Ntk::get_node( s ) ) : replicate_node( Ntk::get_node( s ) );
+  }
+
+  signal replicate_node( node const& n )
+  {
+    if ( replicas.has( n ) )
+    {
+      auto replica = replicas[n];
+      if ( Ntk::fanout_size( replica ) < ps.fanout_limit )
+      {
+        return Ntk::make_signal( replica );
+      }
+    }
+
+    std::array<signal, 3u> fanins;
+    Ntk::foreach_fanin( n, [&]( signal const& f, auto index ) {
+      fanins[index] = ( Ntk::is_maj( Ntk::get_node( f ) ) && Ntk::fanout_size( Ntk::get_node( f ) ) > ps.fanout_limit - 1u ) ? replicate_node( f ) : f;
+    } );
+
+    auto const new_signal = create_maj_overwrite_strash( fanins[0u], fanins[1u], fanins[2u] );
+    replicas[n] = Ntk::get_node( new_signal );
+    return new_signal;
+  }
+
+  uint32_t num_gates() const
+  {
+    return Ntk::num_gates() + count_hash_overwrites;
+  }
+
+protected:
+  signal create_maj_overwrite_strash( signal a, signal b, signal c )
+  {
+    /* order inputs */
+    if ( a.index > b.index )
+    {
+      std::swap( a, b );
+      if ( b.index > c.index )
+        std::swap( b, c );
+      if ( a.index > b.index )
+        std::swap( a, b );
+    }
+    else
+    {
+      if ( b.index > c.index )
+        std::swap( b, c );
+      if ( a.index > b.index )
+        std::swap( a, b );
+    }
+
+    /* trivial cases */
+    if ( a.index == b.index )
+    {
+      return ( a.complement == b.complement ) ? a : c;
+    }
+    else if ( b.index == c.index )
+    {
+      return ( b.complement == c.complement ) ? b : a;
+    }
+
+    /*  complemented edges minimization */
+    auto node_complement = false;
+    if ( static_cast<unsigned>( a.complement ) + static_cast<unsigned>( b.complement ) +
+             static_cast<unsigned>( c.complement ) >=
+         2u )
+    {
+      node_complement = true;
+      a.complement = !a.complement;
+      b.complement = !b.complement;
+      c.complement = !c.complement;
+    }
+
+    typename storage::element_type::node_type node;
+    node.children[0] = a;
+    node.children[1] = b;
+    node.children[2] = c;
+
+    /* structural hashing */
+    if ( true )
+    {
+      const auto it = Ntk::_storage->hash.find( node );
+      if ( it != Ntk::_storage->hash.end() )
+      {
+        ++count_hash_overwrites;
+      }
+    }
+
+    const auto index = Ntk::_storage->nodes.size();
+
+    if ( index >= .9 * Ntk::_storage->nodes.capacity() )
+    {
+      Ntk::_storage->nodes.reserve( static_cast<uint64_t>( 3.1415f * index ) );
+      Ntk::_storage->hash.reserve( static_cast<uint64_t>( 3.1415f * index ) );
+    }
+
+    Ntk::_storage->nodes.push_back( node );
+    Ntk::_storage->hash[node] = index;
+
+    /* increase ref-count to children */
+    Ntk::_storage->nodes[a.index].data[0].h1++;
+    Ntk::_storage->nodes[b.index].data[0].h1++;
+    Ntk::_storage->nodes[c.index].data[0].h1++;
+
+    for ( auto const& fn : Ntk::_events->on_add )
+    {
+      ( *fn )( index );
+    }
+
+    return { index, node_complement };
+  }
+
+protected:
+  uint32_t count_hash_overwrites{ 0 };
+  unordered_node_map<node, Ntk> replicas;
+  fanout_limit_view_params const ps;
+};
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/views/fanout_view.hpp b/include/mockturtle/views/fanout_view.hpp
new file mode 100644
index 0000000..257b31c
--- /dev/null
+++ b/include/mockturtle/views/fanout_view.hpp
@@ -0,0 +1,350 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file fanout_view.hpp
+  \brief Implements fanout for a network
+
+  \author Alessandro Tempia Calvino
+  \author Hanyu Wang
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include "../networks/detail/foreach.hpp"
+#include "../networks/events.hpp"
+#include "../traits.hpp"
+#include "../utils/node_map.hpp"
+#include "immutable_view.hpp"
+
+#include <cstdint>
+#include <stack>
+#include <vector>
+
+namespace mockturtle
+{
+
+struct fanout_view_params
+{
+  bool update_on_add{ true };
+  bool update_on_modified{ true };
+  bool update_on_delete{ true };
+};
+
+/*! \brief Implements `foreach_fanout` methods for networks.
+ *
+ * This view computes the fanout of each node of the network.
+ * It implements the network interface method `foreach_fanout`.  The
+ * fanout are computed at construction and can be recomputed by
+ * calling the `update_fanout` method.
+ *
+ * **Required network functions:**
+ * - `foreach_node`
+ * - `foreach_fanin`
+ *
+ */
+template<typename Ntk, bool has_fanout_interface = has_foreach_fanout_v<Ntk>>
+class fanout_view
+{
+};
+
+template<typename Ntk>
+class fanout_view<Ntk, true> : public Ntk
+{
+public:
+  fanout_view( Ntk const& ntk, fanout_view_params const& ps = {} ) : Ntk( ntk )
+  {
+    (void)ps;
+  }
+};
+
+template<typename Ntk>
+class fanout_view<Ntk, false> : public Ntk
+{
+public:
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  explicit fanout_view( fanout_view_params const& ps = {} )
+      : Ntk(), _fanout( *this ), _ps( ps )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+
+    update_fanout();
+
+    register_events();
+  }
+
+  explicit fanout_view( Ntk const& ntk, fanout_view_params const& ps = {} )
+      : Ntk( ntk ), _fanout( ntk ), _ps( ps )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+
+    update_fanout();
+
+    register_events();
+  }
+
+  /*! \brief Copy constructor. */
+  fanout_view( fanout_view<Ntk, false> const& other )
+      : Ntk( other ), _fanout( other._fanout ), _ps( other._ps )
+  {
+    register_events();
+  }
+
+  fanout_view<Ntk, false>& operator=( fanout_view<Ntk, false> const& other )
+  {
+    release_events();
+
+    /* update the base class */
+    this->_storage = other._storage;
+    this->_events = other._events;
+
+    /* copy */
+    _ps = other._ps;
+    _fanout = other._fanout;
+
+    register_events();
+
+    return *this;
+  }
+
+  ~fanout_view()
+  {
+    release_events();
+  }
+
+  template<typename Fn>
+  void foreach_fanout( node const& n, Fn&& fn ) const
+  {
+    assert( n < this->size() );
+    detail::foreach_element( _fanout[n].begin(), _fanout[n].end(), fn );
+  }
+
+  void update_fanout()
+  {
+    compute_fanout();
+  }
+
+  std::vector<node> fanout( node const& n ) const /* deprecated */
+  {
+    return _fanout[n];
+  }
+
+  void substitute_node( node const& old_node, signal const& new_signal )
+  {
+    if ( Ntk::get_node( new_signal ) == old_node && !Ntk::is_complemented( new_signal ) )
+      return;
+
+    if ( Ntk::is_dead( Ntk::get_node( new_signal ) ) )
+    {
+      Ntk::revive_node( Ntk::get_node( new_signal ) );
+    }
+
+    std::unordered_map<node, signal> old_to_new;
+    std::stack<std::pair<node, signal>> to_substitute;
+    to_substitute.push( { old_node, new_signal } );
+
+    while ( !to_substitute.empty() )
+    {
+      const auto [_old, _curr] = to_substitute.top();
+      to_substitute.pop();
+
+      signal _new = _curr;
+      /* find the real new node */
+      if ( Ntk::is_dead( Ntk::get_node( _new ) ) )
+      {
+        auto it = old_to_new.find( Ntk::get_node( _new ) );
+        while ( it != old_to_new.end() )
+        {
+          _new = Ntk::is_complemented( _new ) ? Ntk::create_not( it->second ) : it->second;
+          it = old_to_new.find( Ntk::get_node( _new ) );
+        }
+      }
+      /* revive */
+      if ( Ntk::is_dead( Ntk::get_node( _new ) ) )
+      {
+        Ntk::revive_node( Ntk::get_node( _new ) );
+      }
+
+      if ( Ntk::get_node( _new ) == _old && !Ntk::is_complemented( _new ) )
+        continue;
+
+      const auto parents = _fanout[_old];
+      for ( auto n : parents )
+      {
+        if ( const auto repl = Ntk::replace_in_node( n, _old, _new ); repl )
+        {
+          to_substitute.push( *repl );
+        }
+      }
+
+      /* check outputs */
+      Ntk::replace_in_outputs( _old, _new );
+
+      /* reset fan-in of old node */
+      if ( _old != Ntk::get_node( _new ) ) /* substitute a node using itself*/
+      {
+        old_to_new.insert( { _old, _new } );
+        Ntk::take_out_node( _old );
+      }
+    }
+  }
+
+  void substitute_node_no_restrash( node const& old_node, signal const& new_signal )
+  {
+    if ( Ntk::get_node( new_signal ) == old_node && !Ntk::is_complemented( new_signal ) )
+      return;
+
+    if ( Ntk::is_dead( Ntk::get_node( new_signal ) ) )
+    {
+      Ntk::revive_node( Ntk::get_node( new_signal ) );
+    }
+
+    const auto parents = _fanout[old_node];
+    for ( auto n : parents )
+    {
+      Ntk::replace_in_node_no_restrash( n, old_node, new_signal );
+    }
+
+    /* check outputs */
+    Ntk::replace_in_outputs( old_node, new_signal );
+
+    /* recursively reset old node */
+    if ( old_node != new_signal.index )
+    {
+      Ntk::take_out_node( old_node );
+    }
+  }
+
+private:
+  void register_events()
+  {
+    if ( _ps.update_on_add )
+    {
+      add_event = Ntk::events().register_add_event( [this]( auto const& n ) {
+        _fanout.resize();
+        Ntk::foreach_fanin( n, [&, this]( auto const& f ) {
+          _fanout[f].push_back( n );
+        } );
+      } );
+    }
+
+    if ( _ps.update_on_modified )
+    {
+      modified_event = Ntk::events().register_modified_event( [this]( auto const& n, auto const& previous ) {
+        (void)previous;
+        for ( auto const& f : previous )
+        {
+          _fanout[f].erase( std::remove( _fanout[f].begin(), _fanout[f].end(), n ), _fanout[f].end() );
+        }
+        Ntk::foreach_fanin( n, [&, this]( auto const& f ) {
+          _fanout[f].push_back( n );
+        } );
+      } );
+    }
+
+    if ( _ps.update_on_delete )
+    {
+      delete_event = Ntk::events().register_delete_event( [this]( auto const& n ) {
+        _fanout[n].clear();
+        Ntk::foreach_fanin( n, [&, this]( auto const& f ) {
+          _fanout[f].erase( std::remove( _fanout[f].begin(), _fanout[f].end(), n ), _fanout[f].end() );
+        } );
+      } );
+    }
+  }
+
+  void release_events()
+  {
+    if ( add_event )
+    {
+      Ntk::events().release_add_event( add_event );
+    }
+
+    if ( modified_event )
+    {
+      Ntk::events().release_modified_event( modified_event );
+    }
+
+    if ( delete_event )
+    {
+      Ntk::events().release_delete_event( delete_event );
+    }
+  }
+
+  void compute_fanout()
+  {
+    _fanout.reset();
+
+    /* Compute fanout also for buffers in buffered networks */
+    if constexpr ( is_buffered_network_type_v<Ntk> )
+    {
+      this->foreach_node( [&]( auto const& n ) {
+        if ( this->is_pi( n ) || this->is_constant( n ) )
+          return true;
+        this->foreach_fanin( n, [&]( auto const& c ) {
+          auto& fanout = _fanout[c];
+          if ( std::find( fanout.begin(), fanout.end(), n ) == fanout.end() )
+          {
+            fanout.push_back( n );
+          }
+        } );
+        return true;
+      } );
+    }
+    else
+    {
+      this->foreach_gate( [&]( auto const& n ) {
+        this->foreach_fanin( n, [&]( auto const& c ) {
+          auto& fanout = _fanout[c];
+          if ( std::find( fanout.begin(), fanout.end(), n ) == fanout.end() )
+          {
+            fanout.push_back( n );
+          }
+        } );
+      } );
+    }
+  }
+
+  node_map<std::vector<node>, Ntk> _fanout;
+  fanout_view_params _ps;
+
+  std::shared_ptr<typename network_events<Ntk>::add_event_type> add_event;
+  std::shared_ptr<typename network_events<Ntk>::modified_event_type> modified_event;
+  std::shared_ptr<typename network_events<Ntk>::delete_event_type> delete_event;
+};
+
+template<class T>
+fanout_view( T const&, fanout_view_params const& ps = {} ) -> fanout_view<T>;
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/views/immutable_view.hpp b/include/mockturtle/views/immutable_view.hpp
new file mode 100644
index 0000000..f5ee118
--- /dev/null
+++ b/include/mockturtle/views/immutable_view.hpp
@@ -0,0 +1,89 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file immutable_view.hpp
+  \brief Disables all methods to change the network
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Deletes all methods that can change the network.
+ *
+ * This view deletes all methods that can change the network structure such as
+ * `create_not`, `create_and`, or `create_node`.  This view is convenient to
+ * use as a base class for other views that make some computations based on the
+ * structure when being constructed.  Then, changes to the structure invalidate
+ * these data.
+ */
+template<typename Ntk>
+class immutable_view : public Ntk
+{
+public:
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  /*! \brief Default constructor.
+   *
+   * Constructs immutable view on another network.
+   */
+  immutable_view( Ntk const& ntk ) : Ntk( ntk )
+  {
+  }
+
+  signal create_pi() = delete;
+  void create_po( signal const& s ) = delete;
+  signal create_ro() = delete;
+  void create_ri( signal const& s ) = delete;
+  signal create_buf( signal const& f ) = delete;
+  signal create_not( signal const& f ) = delete;
+  signal create_and( signal const& f, signal const& g ) = delete;
+  signal create_nand( signal const& f, signal const& g ) = delete;
+  signal create_or( signal const& f, signal const& g ) = delete;
+  signal create_nor( signal const& f, signal const& g ) = delete;
+  signal create_lt( signal const& f, signal const& g ) = delete;
+  signal create_le( signal const& f, signal const& g ) = delete;
+  signal create_gt( signal const& f, signal const& g ) = delete;
+  signal create_ge( signal const& f, signal const& g ) = delete;
+  signal create_xor( signal const& f, signal const& g ) = delete;
+  signal create_xnor( signal const& f, signal const& g ) = delete;
+  signal create_maj( signal const& f, signal const& g, signal const& h ) = delete;
+  signal create_ite( signal const& cond, signal const& f_then, signal const& f_else ) = delete;
+  signal create_node( std::vector<signal> const& fanin, kitty::dynamic_truth_table const& function ) = delete;
+  signal clone_node( immutable_view<Ntk> const& other, node const& source, std::vector<signal> const& fanin ) = delete;
+  void substitute_node( node const& old_node, node const& new_node ) = delete;
+};
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/views/mapping_view.hpp b/include/mockturtle/views/mapping_view.hpp
new file mode 100644
index 0000000..075e61d
--- /dev/null
+++ b/include/mockturtle/views/mapping_view.hpp
@@ -0,0 +1,276 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mapping_view.hpp
+  \brief Implements mapping methods to create mapped networks
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "../networks/detail/foreach.hpp"
+#include "../traits.hpp"
+#include "../utils/truth_table_cache.hpp"
+#include "../views/immutable_view.hpp"
+
+#include <kitty/dynamic_truth_table.hpp>
+
+namespace mockturtle
+{
+
+namespace detail
+{
+
+template<bool StoreFunction>
+struct mapping_view_storage;
+
+template<>
+struct mapping_view_storage<true>
+{
+  std::vector<uint32_t> mappings;
+  uint32_t mapping_size{ 0 };
+  std::vector<uint32_t> functions;
+  truth_table_cache<kitty::dynamic_truth_table> cache;
+};
+
+template<>
+struct mapping_view_storage<false>
+{
+  std::vector<uint32_t> mappings;
+  uint32_t mapping_size{ 0 };
+};
+
+} // namespace detail
+
+template<typename Ntk, bool StoreFunction>
+inline constexpr bool implements_mapping_interface_v = has_has_mapping_v<Ntk> && ( !StoreFunction || has_cell_function_v<Ntk> );
+
+/*! \brief Adds mapping API methods to network.
+ *
+ * This view adds methods of the mapping API methods to a network.  It always
+ * adds the functions `has_mapping`, `is_cell_root`, `clear_mapping`,
+ * `num_cells`, `add_to_mapping`, `remove_from_mapping`, and
+ * `foreach_cell_fanin`.  If the template argument `StoreFunction` is set to
+ * `true`, it also adds functions for `cell_function` and `set_cell_function`.
+ * For the latter case, this view requires more memory to also store the cells'
+ * truth tables.
+ *
+ * These methods are used to represent a mapping that is annotated to a
+ * subject graph.  The interface can, e.g., be used for LUT mapping or standard
+ * cell mapping.  For a common terminology, we call a collection of nodes that
+ * belong to the same unit a cell, which has a single root.  The *mapped node* is
+ * the cell root.  A cell root, and therefore the cell it represents, may be
+ * assigned a function by means of a truth table.
+ *
+ * **Required network functions:**
+ * - `size`
+ * - `node_to_index`
+ *
+ * Example
+ *
+   \verbatim embed:rst
+
+   .. code-block:: c++
+
+      // create network somehow
+      aig_network aig = ...;
+
+      // in order to apply mapping, wrap network in mapping view
+      mapping_view mapped_aig{aig};
+
+      // call LUT mapping algorithm
+      lut_mapping( mapped_aig );
+
+      // nodes of aig and mapped_aig are the same
+      aig.foreach_node( [&]( auto n ) {
+        std::cout << n << " has mapping? " << mapped_aig.is_cell_root( n ) << "\n";
+      } );
+   \endverbatim
+ */
+template<typename Ntk, bool StoreFunction = false, bool has_mapping_interface = implements_mapping_interface_v<Ntk, StoreFunction>>
+class mapping_view
+{
+};
+
+template<typename Ntk, bool StoreFunction>
+class mapping_view<Ntk, StoreFunction, true> : public Ntk
+{
+public:
+  mapping_view( Ntk const& ntk ) : Ntk( ntk )
+  {
+  }
+};
+
+template<typename Ntk, bool StoreFunction>
+class mapping_view<Ntk, StoreFunction, false> : public immutable_view<Ntk>
+{
+public:
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  /*! \brief Default constructor.
+   *
+   * Constructs mapping view on another network.
+   */
+  mapping_view( Ntk const& ntk )
+      : immutable_view<Ntk>( ntk ),
+        _mapping_storage( std::make_shared<typename decltype( _mapping_storage )::element_type>() )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+
+    _mapping_storage->mappings.resize( ntk.size(), 0 );
+
+    if constexpr ( StoreFunction )
+    {
+      /* insert 0 truth table */
+      _mapping_storage->cache.insert( kitty::dynamic_truth_table( 0 ) );
+
+      /* default each truth table to 0 */
+      _mapping_storage->functions.resize( ntk.size(), 0 );
+    }
+  }
+
+  /*! \brief Returns true, if network has a mapping. */
+  bool has_mapping() const
+  {
+    return _mapping_storage->mapping_size > 0;
+  }
+
+  /*! \brief Returns true, if node is the root of a mapped cell. */
+  bool is_cell_root( node const& n ) const
+  {
+    return _mapping_storage->mappings[this->node_to_index( n )] != 0;
+  }
+
+  /*! \brief Clears a mapping. */
+  void clear_mapping()
+  {
+    _mapping_storage->mappings.clear();
+    _mapping_storage->mappings.resize( this->size(), 0 );
+    _mapping_storage->mapping_size = 0;
+  }
+
+  /*! \brief Number of cells, i.e, mapped nodes. */
+  uint32_t num_cells() const
+  {
+    return _mapping_storage->mapping_size;
+  }
+
+  /*! \brief Adds a node to the mapping. */
+  template<typename LeavesIterator>
+  void add_to_mapping( node const& n, LeavesIterator begin, LeavesIterator end )
+  {
+    auto& mindex = _mapping_storage->mappings[this->node_to_index( n )];
+
+    /* increase mapping size? */
+    if ( mindex == 0 )
+    {
+      _mapping_storage->mapping_size++;
+    }
+
+    /* set starting index of leafs */
+    mindex = static_cast<uint32_t>( _mapping_storage->mappings.size() );
+
+    /* insert number of leafs */
+    _mapping_storage->mappings.push_back( static_cast<uint32_t>( std::distance( begin, end ) ) );
+
+    /* insert leaf indexes */
+    while ( begin != end )
+    {
+      _mapping_storage->mappings.push_back( this->node_to_index( *begin++ ) );
+    }
+  }
+
+  /*! \brief Remove from mapping. */
+  void remove_from_mapping( node const& n )
+  {
+    auto& mindex = _mapping_storage->mappings[this->node_to_index( n )];
+
+    if ( mindex != 0 )
+    {
+      _mapping_storage->mapping_size--;
+    }
+
+    _mapping_storage->mappings[this->node_to_index( n )] = 0;
+  }
+
+  /*! \brief Gets function of the cell.
+   *
+   * The parameter `n` is a node that must be a cell root.
+   */
+  template<bool enabled = StoreFunction, typename = std::enable_if_t<std::is_same_v<Ntk, Ntk> && enabled>>
+  kitty::dynamic_truth_table cell_function( node const& n ) const
+  {
+    return _mapping_storage->cache[_mapping_storage->functions[this->node_to_index( n )]];
+  }
+
+  /*! \brief Sets cell function.
+   *
+   * The parameter `n` is a node that must be a cell root.
+   */
+  template<bool enabled = StoreFunction, typename = std::enable_if_t<std::is_same_v<Ntk, Ntk> && enabled>>
+  void set_cell_function( node const& n, kitty::dynamic_truth_table const& function )
+  {
+    _mapping_storage->functions[this->node_to_index( n )] = _mapping_storage->cache.insert( function );
+  }
+
+  /*! \brief Iterators over cell's fan-ins.
+   * The parameter `n` is a node that must be a cell root.
+   * The parameter ``fn`` is any callable that must have one of the
+   * following four signatures.
+   * - ``void(node const&)``
+   * - ``void(node const&, uint32_t)``
+   * - ``bool(node const&)``
+   * - ``bool(node const&, uint32_t)``
+   */
+  template<typename Fn>
+  void foreach_cell_fanin( node const& n, Fn&& fn ) const
+  {
+    auto it = _mapping_storage->mappings.begin() + _mapping_storage->mappings[this->node_to_index( n )];
+    const auto size = *it++;
+    using IteratorType = decltype( it );
+    detail::foreach_element_transform<IteratorType, typename Ntk::node>(
+        it, it + size,
+        [&]( auto i ) { return this->index_to_node( i ); }, fn );
+  }
+
+private:
+  std::shared_ptr<detail::mapping_view_storage<StoreFunction>> _mapping_storage;
+};
+
+template<class T>
+mapping_view( T const& ) -> mapping_view<T>;
+
+} // namespace mockturtle
diff --git a/include/mockturtle/views/mffc_view.hpp b/include/mockturtle/views/mffc_view.hpp
new file mode 100644
index 0000000..8ab2639
--- /dev/null
+++ b/include/mockturtle/views/mffc_view.hpp
@@ -0,0 +1,310 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2023  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mffc_view.hpp
+  \brief Implements an isolated view on a single cut in a network
+
+  \author Alessandro Tempia Calvino
+  \author Bruno Schmitt
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <vector>
+
+#include <parallel_hashmap/phmap.h>
+
+#include "../networks/detail/foreach.hpp"
+#include "../traits.hpp"
+#include "immutable_view.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Implements an isolated view on the MFFC of a node.
+ *
+ * The network is constructed from a given root node which is traversed towards
+ * the primary inputs.  Nodes are collected as long they only fanout into nodes
+ * which are already among the visited nodes.  Therefore the final view only
+ * has outgoing edges to nodes not in the view from the given root node or from
+ * the newly generated primary inputs.
+ *
+ * The view reimplements the methods `size`, `num_pis`, `num_pos`, `foreach_pi`,
+ * `foreach_po`, `foreach_node`, `foreach_gate`, `is_pi`, `node_to_index`, and
+ * `index_to_node`.
+ *
+ * The view requires that the nodes' values contain their reference counts,
+ * i.e., they are assigned their fanout size.  The values are restored by the
+ * view.
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `decr_value`
+ * - `value`
+ * - `foreach_fanin`
+ * - `is_constant`
+ * - `node_to_index`
+ */
+template<typename Ntk>
+class mffc_view : public immutable_view<Ntk>
+{
+public:
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+public:
+  explicit mffc_view( Ntk const& ntk, node const& root )
+      : immutable_view<Ntk>( ntk ), _root( root )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_decr_value_v<Ntk>, "Ntk does not implement the decr_value method" );
+    static_assert( has_incr_value_v<Ntk>, "Ntk does not implement the incr_value method" );
+    static_assert( has_value_v<Ntk>, "Ntk does not implement the value method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+    static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+    static_assert( has_is_pi_v<Ntk>, "Ntk does not implement the is_pi method" );
+    static_assert( has_node_to_index_v<Ntk>, "Ntk does not implement the node_to_index method" );
+
+    const auto c0 = this->get_node( this->get_constant( false ) );
+    _constants.push_back( c0 );
+    _node_to_index.emplace( c0, _node_to_index.size() );
+
+    const auto c1 = this->get_node( this->get_constant( true ) );
+    if ( c1 != c0 )
+    {
+      _constants.push_back( c1 );
+      _node_to_index.emplace( c1, _node_to_index.size() );
+      ++_num_constants;
+    }
+
+    _leaves.reserve( 16 );
+    _nodes.reserve( _limit );
+    _inner.reserve( _limit );
+    update_mffcs();
+  }
+
+  inline auto size() const { return _num_constants + _num_leaves + _inner.size(); }
+  inline auto num_pis() const { return _num_leaves; }
+  inline auto num_pos() const { return _empty ? 0u : 1u; }
+  inline auto num_gates() const { return _inner.size(); }
+
+  inline bool is_pi( node const& pi ) const
+  {
+    return std::find( _leaves.begin(), _leaves.end(), pi ) != _leaves.end();
+  }
+
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( _leaves.begin(), _leaves.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    if ( _empty )
+      return;
+    std::vector<signal> signals( 1, this->make_signal( _root ) );
+    detail::foreach_element( signals.begin(), signals.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    detail::foreach_element( _inner.begin(), _inner.end(), fn );
+  }
+
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    detail::foreach_element( _constants.begin(), _constants.end(), fn );
+    detail::foreach_element( _leaves.begin(), _leaves.end(), fn, _num_constants );
+    detail::foreach_element( _inner.begin(), _inner.end(), fn, _num_constants + _num_leaves );
+  }
+
+  inline auto index_to_node( uint32_t index ) const
+  {
+    if ( index < _num_constants )
+    {
+      return _constants[index];
+    }
+    if ( index < _num_constants + _num_leaves )
+    {
+      return _leaves[index - _num_constants];
+    }
+    return _inner[index - _num_constants - _num_leaves];
+  }
+
+  inline auto node_to_index( node const& n ) const { return _node_to_index.at( n ); }
+
+  void update_mffcs()
+  {
+    _leaves.clear();
+    _inner.clear();
+    if ( collect( _root ) )
+    {
+      _empty = false;
+      compute_sets();
+    }
+    else
+    {
+      _empty = true;
+    }
+    _num_leaves = static_cast<uint32_t>( _leaves.size() );
+
+    /* restore ref counts */
+    for ( auto const& n : _nodes )
+    {
+      this->incr_fanout_size( n );
+    }
+  }
+
+private:
+  bool collect( node const& n )
+  {
+    if ( Ntk::is_constant( n ) )
+      return true;
+
+    if ( Ntk::is_pi( n ) )
+    {
+      return true;
+    }
+
+    /* we break from the loop over the fanins, if we find that _nodes contains
+       too many nodes; the return value is stored in ret_val */
+    bool ret_val = true;
+    this->foreach_fanin( n, [&]( auto const& f ) {
+      _nodes.push_back( this->get_node( f ) );
+      if ( this->decr_fanout_size( this->get_node( f ) ) == 0 && ( _nodes.size() > _limit || !collect( this->get_node( f ) ) ) )
+      {
+        ret_val = false;
+        return false;
+      }
+      return true;
+    } );
+
+    return ret_val;
+  }
+
+  void compute_sets()
+  {
+    // std::stable_sort( _nodes.begin(), _nodes.end(),
+    //            [&]( auto const& n1, auto const& n2 ) { return static_cast<Ntk*>( this )->node_to_index( n1 ) < static_cast<Ntk*>( this )->node_to_index( n2 ); } );
+    std::stable_sort( _nodes.begin(), _nodes.end() );
+
+    for ( auto const& n : _nodes )
+    {
+      if ( Ntk::is_constant( n ) )
+      {
+        continue;
+      }
+
+      if ( this->fanout_size( n ) > 0 || Ntk::is_pi( n ) ) /* PI candidate */
+      {
+        if ( _leaves.empty() || _leaves.back() != n )
+        {
+          _leaves.push_back( n );
+        }
+      }
+      else
+      {
+        if ( _inner.empty() || _inner.back() != n )
+        {
+          _inner.push_back( n );
+        }
+      }
+    }
+
+    for ( auto const& n : _leaves )
+    {
+      _node_to_index.emplace( n, _node_to_index.size() );
+    }
+    for ( auto const& n : _inner )
+    {
+      _node_to_index.emplace( n, _node_to_index.size() );
+    }
+
+    _inner.push_back( _root );
+    _node_to_index.emplace( _root, _node_to_index.size() );
+
+    /* sort topologically */
+    _topo.clear();
+    _colors.clear();
+    const auto _size = _num_constants + _inner.size() + _leaves.size();
+    _colors.resize( _size, 0 );
+    std::for_each( _leaves.begin(), _leaves.end(), [&]( auto& l ) { _colors[_node_to_index[l]] = 2u; } );
+    for ( auto i = 0u; i < _num_constants; ++i )
+    {
+      _colors[i] = 2u;
+    }
+    topo_sort_rec( _root );
+
+    assert( _inner.size() == _topo.size() );
+    _inner = _topo;
+  }
+
+  void topo_sort_rec( node const& n )
+  {
+    const auto idx = _node_to_index[n];
+
+    /* is permanently marked? */
+    if ( _colors[idx] == 2u )
+      return;
+
+    /* mark node temporarily */
+    _colors[idx] = 1u;
+
+    /* mark children */
+    Ntk::foreach_fanin( n, [&]( auto const& f ) {
+      topo_sort_rec( Ntk::get_node( f ) );
+    } );
+
+    /* mark node n permanently */
+    _colors[idx] = 2u;
+
+    _topo.push_back( n );
+  }
+
+public:
+  std::vector<node> _nodes, _constants, _leaves, _inner, _topo;
+  std::vector<uint8_t> _colors;
+  unsigned _num_constants{ 1 }, _num_leaves{ 0 };
+  phmap::flat_hash_map<node, uint32_t> _node_to_index;
+  node _root;
+  bool _empty{ true };
+  uint32_t _limit{ 100 };
+};
+
+template<class T>
+mffc_view( T const&, typename T::node const& ) -> mffc_view<T>;
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/mockturtle/views/names_view.hpp b/include/mockturtle/views/names_view.hpp
new file mode 100644
index 0000000..e633b91
--- /dev/null
+++ b/include/mockturtle/views/names_view.hpp
@@ -0,0 +1,210 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file names_view.hpp
+  \brief Implements methods to declare names for network signals
+
+  \author Heinz Riener
+  \author Marcel Walter
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../traits.hpp"
+
+#include <map>
+#include <string>
+
+namespace mockturtle
+{
+
+template<class Ntk>
+class names_view : public Ntk
+{
+public:
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+public:
+  template<typename StrType = const char*>
+  names_view( Ntk const& ntk = Ntk(), StrType name = "" )
+      : Ntk( ntk ), _network_name{ name }
+  {
+  }
+
+  names_view( names_view<Ntk> const& named_ntk )
+      : Ntk( named_ntk ), _network_name( named_ntk._network_name ), _signal_names( named_ntk._signal_names ), _output_names( named_ntk._output_names )
+  {
+  }
+
+  names_view<Ntk>& operator=( names_view<Ntk> const& named_ntk )
+  {
+    if ( this != &named_ntk ) // Check for self-assignment
+    {
+      Ntk::operator=( named_ntk );
+      _signal_names = named_ntk._signal_names;
+      _network_name = named_ntk._network_name;
+      _output_names = named_ntk._output_names;
+    }
+    return *this;
+  }
+
+  /*! \brief Creates a primary input and set its name.
+   *
+   * \param name Name of the created primary input
+   */
+  signal create_pi( std::string const& name = {} )
+  {
+    const auto s = Ntk::create_pi();
+    if ( !name.empty() )
+    {
+      set_name( s, name );
+    }
+    return s;
+  }
+
+  /*! \brief Creates a primary output and set its name.
+   *
+   * \param s Signal that drives the created primary output
+   * \param name Name of the created primary output
+   */
+  void create_po( signal const& s, std::string const& name = {} )
+  {
+    const auto index = Ntk::num_pos();
+    Ntk::create_po( s );
+    if ( !name.empty() )
+    {
+      set_output_name( index, name );
+    }
+  }
+
+  /*! \brief Sets network name.
+   *
+   * \param name Name of the network
+   */
+  template<typename StrType = const char*>
+  void set_network_name( StrType name ) noexcept
+  {
+    _network_name = name;
+  }
+
+  /*! \brief Gets network name.
+   *
+   * \return Network name
+   */
+  std::string get_network_name() const noexcept
+  {
+    return _network_name;
+  }
+
+  /*! \brief Checks if a signal has a name.
+   *
+   * Note that complemented signals may have different names.
+   *
+   * \param s Signal to be checked
+   * \return Whether the signal has a name in record
+   */
+  bool has_name( signal const& s ) const
+  {
+    return ( _signal_names.find( s ) != _signal_names.end() );
+  }
+
+  /*! \brief Sets the name for a signal.
+   *
+   * Note that names are set separately for complemented signals.
+   *
+   * \param s Signal to be set a name
+   * \param name Name of the signal
+   */
+  void set_name( signal const& s, std::string const& name )
+  {
+    _signal_names[s] = name;
+  }
+
+  /*! \brief Gets signal name.
+   *
+   * Note that complemented signals may have different names.
+   *
+   * \param s Signal to be queried
+   * \return Name of the signal
+   */
+  std::string get_name( signal const& s ) const
+  {
+    return _signal_names.at( s );
+  }
+
+  /*! \brief Checks if a primary output has a name.
+   *
+   * \param index Index of the primary output to be checked
+   * \return Whether the primary output has a name in record
+   */
+  bool has_output_name( uint32_t index ) const
+  {
+    return ( _output_names.find( index ) != _output_names.end() );
+  }
+
+  /*! \brief Sets the name for a primary output.
+   *
+   * Note that even if two primary outputs are driven by
+   * the same signal, they may have different names.
+   *
+   * \param index Index of the primary output to set a name
+   * \param name Name of the primary output
+   */
+  void set_output_name( uint32_t index, std::string const& name )
+  {
+    _output_names[index] = name;
+  }
+
+  /*! \brief Gets the name of a primary output.
+   *
+   * Note that even if two primary outputs are driven by
+   * the same signal, they may have different names.
+   *
+   * \param index Index of the primary output to be queried
+   * \return Name of the primary output
+   */
+  std::string get_output_name( uint32_t index ) const
+  {
+    return _output_names.at( index );
+  }
+
+private:
+  std::string _network_name;
+  std::map<signal, std::string> _signal_names;
+  std::map<uint32_t, std::string> _output_names;
+}; /* names_view */
+
+template<class T>
+names_view( T const& ) -> names_view<T>;
+
+template<class T>
+names_view( T const&, typename T::signal const& ) -> names_view<T>;
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/views/rank_view.hpp b/include/mockturtle/views/rank_view.hpp
new file mode 100644
index 0000000..ecfef63
--- /dev/null
+++ b/include/mockturtle/views/rank_view.hpp
@@ -0,0 +1,384 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+ \file rank_view.hpp
+ \brief Implements rank orders for a network
+
+ \author Marcel Walter
+*/
+
+#pragma once
+
+#include "../networks/detail/foreach.hpp"
+#include "../traits.hpp"
+#include "../utils/node_map.hpp"
+#include "depth_view.hpp"
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <functional>
+#include <utility>
+#include <vector>
+
+namespace mockturtle
+{
+
+/*! \brief Implements rank orders for a network.
+*
+* This view assigns manipulable relative orders to the nodes of each level.
+* A sequence of nodes in the same level is called a rank. The width
+* of a rank is thereby defined as the number of nodes in the rank. The width of
+* the network is equal to the width of the widest rank. This view implements
+* functions to retrieve the assigned node position within a rank (`rank_position`)
+* as well as to fetch the node in a certain rank at a certain position (`at_rank_position`).
+* The ranks are assigned at construction and can be manipulated by calling the `swap` function.
+*
+* This view also automatically inserts new nodes into their respective rank (at the end),
+* however, it does not update the information, when modifying or deleting nodes.
+*
+* **Required network functions:**
+* -  `foreach_node`
+* -  `get_node`
+* -  `num_pis`
+* -  `is_ci`
+* -  `is_constant`
+*
+* Example
+*
+  \verbatim embed:rst
+
+  .. code-block:: c++
+
+     // create network somehow
+     aig_network aig = ...;
+
+     // create a rank view on the network
+     rank_view aig_rank{aig_depth};
+
+     // print width
+     std::cout << "Width: " << aig_rank.width() << "\n";
+  \endverbatim
+*/
+template<class Ntk, bool has_rank_interface = has_rank_position_v<Ntk>&& has_at_rank_position_v<Ntk>&& has_swap_v<Ntk>&& has_width_v<Ntk>&& has_foreach_node_in_rank_v<Ntk>&& has_foreach_gate_in_rank_v<Ntk>>
+class rank_view
+{
+};
+
+template<class Ntk>
+class rank_view<Ntk, true> : public depth_view<Ntk>
+{
+public:
+  rank_view( Ntk const& ntk ) : depth_view<Ntk>( ntk )
+  {
+  }
+};
+
+template<class Ntk>
+class rank_view<Ntk, false> : public depth_view<Ntk>
+{
+public:
+  static constexpr bool is_topologically_sorted = true;
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+  explicit rank_view()
+      : depth_view<Ntk>(), rank_pos{ *this }, ranks{}, max_rank_width{ 0 }
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_num_pis_v<Ntk>, "Ntk does not implement the num_pis method" );
+    static_assert( has_is_ci_v<Ntk>, "Ntk does not implement the is_ci method" );
+    static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+
+    add_event = Ntk::events().register_add_event( [this]( auto const& n ) { on_add( n ); } );
+  }
+
+  /*! \brief Standard constructor.
+   *
+   * \param ntk Base network
+   */
+  explicit rank_view( Ntk const& ntk )
+      : depth_view<Ntk>{ ntk }, rank_pos{ ntk }, ranks{ this->depth() + 1 }, max_rank_width{ 0 }
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+    static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+    static_assert( has_num_pis_v<Ntk>, "Ntk does not implement the num_pis method" );
+    static_assert( has_is_ci_v<Ntk>, "Ntk does not implement the is_ci method" );
+    static_assert( has_is_constant_v<Ntk>, "Ntk does not implement the is_constant method" );
+
+    init_ranks();
+
+    add_event = Ntk::events().register_add_event( [this]( auto const& n ) { on_add( n ); } );
+  }
+
+  /*! \brief Copy constructor. */
+  rank_view( rank_view<Ntk, false> const& other )
+      : depth_view<Ntk>( other ), rank_pos{ other.rank_pos }, ranks{ other.ranks }, max_rank_width{ other.max_rank_width }
+  {
+    add_event = Ntk::events().register_add_event( [this]( auto const& n ) { on_add( n ); } );
+  }
+
+  rank_view<Ntk, false>& operator=( rank_view<Ntk, false> const& other )
+  {
+    /* delete the event of this network */
+    Ntk::events().release_add_event( add_event );
+
+    /* update the base class */
+    this->_storage = other._storage;
+    this->_events = other._events;
+
+    /* copy */
+    rank_pos = other.rank_pos;
+    ranks = other.ranks;
+    max_rank_width = other.max_rank_width;
+
+    /* register new event in the other network */
+    add_event = Ntk::events().register_add_event( [this]( auto const& n ) { on_add( n ); } );
+
+    return *this;
+  }
+
+  ~rank_view()
+  {
+    Ntk::events().release_add_event( add_event );
+  }
+  /**
+   * \brief Returns the rank position of a node.
+   *
+   * @param n Node to get the rank position of.
+   * @return Rank position of node `n`.
+   */
+  uint32_t rank_position( node const& n ) const noexcept
+  {
+    assert( !this->is_constant( n ) && "node must not be constant" );
+
+    return rank_pos[n];
+  }
+  /**
+   * \brief Returns the node at a certain rank position.
+   *
+   * @param level Level in the network, i.e., rank to get the node from.
+   * @param pos Position in the rank to get the node from.
+   * @return Node at position `pos` in rank `level`.
+   */
+  node at_rank_position( uint32_t const level, uint32_t const pos ) const noexcept
+  {
+    assert( level < ranks.size() && "level must be less than the number of ranks" );
+    assert( pos < ranks[level].size() && "pos must be less than the number of nodes in rank" );
+
+    return ranks[level][pos];
+  }
+  /**
+   * \brief Returns the width of the widest rank in the network.
+   *
+   * @return Width of the widest rank in the network.
+   */
+  uint32_t width() const noexcept
+  {
+    return max_rank_width;
+  }
+  /**
+   * \brief Swaps the positions of two nodes in the same rank.
+   *
+   * @param n1 First node to swap.
+   * @param n2 Second node to swap.
+   */
+  void swap( node const& n1, node const& n2 ) noexcept
+  {
+    assert( this->level( n1 ) == this->level( n2 ) && "nodes must be in the same rank" );
+
+    auto& pos1 = rank_pos[n1];
+    auto& pos2 = rank_pos[n2];
+
+    std::swap( ranks[this->level( n1 )][pos1], ranks[this->level( n2 )][pos2] );
+    std::swap( pos1, pos2 );
+  }
+  /**
+   * \brief Sorts the given rank according to a comparator.
+   *
+   * @tparam Cmp Functor type that compares two nodes. It needs to fulfill the requirements of `Compare` (named C++ requirement).
+   * @param level The level of the rank to sort.
+   * @param cmp The comparator to use.
+   */
+  template<typename Cmp>
+  void sort_rank( uint32_t const level, Cmp const& cmp )
+  {
+    // level must be less than the number of ranks
+    if ( level < ranks.size() )
+    {
+      auto& rank = ranks[level];
+
+      std::stable_sort( rank.begin(), rank.end(), cmp );
+      std::for_each( rank.cbegin(), rank.cend(), [this, i = 0u]( auto const& n ) mutable { rank_pos[n] = i++; } );
+    }
+  }
+  /**
+   * \brief Applies a given function to each node in the rank level in order.
+   *
+   * @tparam Fn Functor type.
+   * @param level The rank to apply fn to.
+   * @param fn The function to apply.
+   */
+  template<typename Fn>
+  void foreach_node_in_rank( uint32_t const level, Fn&& fn ) const
+  {
+    // level must be less than the number of ranks
+    if ( level < ranks.size() )
+    {
+      auto const& rank = ranks[level];
+
+      detail::foreach_element( rank.cbegin(), rank.cend(), std::forward<Fn>( fn ) );
+    }
+  }
+  /**
+   * \brief Applies a given function to each node in rank order.
+   *
+   * This function overrides the `foreach_node` method of the base class.
+   *
+   * @tparam Fn Functor type.
+   * @param fn The function to apply.
+   */
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    for ( auto l = 0; l < ranks.size(); ++l )
+    {
+      foreach_node_in_rank( l, std::forward<Fn>( fn ) );
+    }
+  }
+  /**
+   * \brief Applies a given function to each gate in the rank level in order.
+   *
+   * @tparam Fn Functor type.
+   * @param level The rank to apply fn to.
+   * @param fn The function to apply.
+   */
+  template<typename Fn>
+  void foreach_gate_in_rank( uint32_t const level, Fn&& fn ) const
+  {
+    // level must be less than the number of ranks
+    if ( level < ranks.size() )
+    {
+      auto const& rank = ranks[level];
+
+      detail::foreach_element_if(
+          rank.cbegin(), rank.cend(), [this]( auto const& n ) { return !this->is_ci( n ); }, std::forward<Fn>( fn ) );
+    }
+  }
+  /**
+   * \brief Applies a given function to each gate in rank order.
+   *
+   * This function overrides the `foreach_gate` method of the base class.
+   *
+   * @tparam Fn Functor type.
+   * @param fn The function to apply.
+   */
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    for ( auto l = 0; l < ranks.size(); ++l )
+    {
+      foreach_gate_in_rank( l, std::forward<Fn>( fn ) );
+    }
+  }
+  /**
+   * \brief Applies a given function to each PI in rank order.
+   *
+   * This function overrides the `foreach_pi` method of the base class.
+   *
+   * @tparam Fn Functor type.
+   * @param fn The function to apply.
+   */
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    std::vector<node> pis{};
+    pis.reserve( this->num_pis() );
+
+    depth_view<Ntk>::foreach_pi( [&pis]( auto const& pi ) { pis.push_back( pi ); } );
+    std::stable_sort( pis.begin(), pis.end(), [this]( auto const& n1, auto const& n2 ) { return rank_pos[n1] < rank_pos[n2]; } );
+    detail::foreach_element( pis.cbegin(), pis.cend(), std::forward<Fn>( fn ) );
+  }
+  /**
+   * Overrides the base class method to also call the add_event on create_pi().
+   *
+   * @note This can (and in fact will) lead to issues if Ntk already calls add_event functions on create_pi()!
+   *
+   * @return Newly created PI signal.
+   */
+  signal create_pi()
+  {
+    auto const n = depth_view<Ntk>::create_pi();
+    this->resize_levels();
+    on_add( this->get_node( n ) );
+    return n;
+  }
+
+private:
+  node_map<uint32_t, Ntk> rank_pos;
+  std::vector<std::vector<node>> ranks;
+  uint32_t max_rank_width;
+
+  std::shared_ptr<typename network_events<Ntk>::add_event_type> add_event;
+
+  void insert_in_rank( node const& n ) noexcept
+  {
+    auto& rank = ranks[this->level( n )];
+    rank_pos[n] = rank.size();
+    rank.push_back( n );
+    max_rank_width = std::max( max_rank_width, static_cast<uint32_t>( rank.size() ) );
+  }
+
+  void on_add( node const& n ) noexcept
+  {
+    if ( this->level( n ) >= ranks.size() )
+    {
+      // add sufficient ranks to store the new node
+      ranks.insert( ranks.end(), this->level( n ) - ranks.size() + 1, {} );
+    }
+    rank_pos.resize();
+
+    insert_in_rank( n );
+  }
+
+  void init_ranks() noexcept
+  {
+    depth_view<Ntk>::foreach_node( [this]( auto const& n ) {
+     if (!this->is_constant(n))
+     {
+       insert_in_rank(n);
+     } } );
+  }
+};
+
+template<class T>
+rank_view( T const& ) -> rank_view<T>;
+
+} // namespace mockturtle
diff --git a/include/mockturtle/views/topo_view.hpp b/include/mockturtle/views/topo_view.hpp
new file mode 100644
index 0000000..227e9c3
--- /dev/null
+++ b/include/mockturtle/views/topo_view.hpp
@@ -0,0 +1,324 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file topo_view.hpp
+  \brief Reimplements foreach_node to guarantee topological order
+
+  \author Alessandro Tempia Calvino
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Max Austin
+*/
+
+#pragma once
+
+#include <cassert>
+#include <optional>
+#include <vector>
+
+#include "../networks/detail/foreach.hpp"
+#include "../traits.hpp"
+#include "immutable_view.hpp"
+
+namespace mockturtle
+{
+
+/*! \brief Ensures topological order for of all nodes reachable from the outputs.
+ *
+ * Overrides the interface methods `foreach_node`, `foreach_gate`,
+ * `size`, `num_gates`.
+ *
+ * This class computes *on construction* a topological order of the nodes which
+ * are reachable from the outputs.  Constant nodes and primary inputs will also
+ * be considered even if they are not reachable from the outputs.  Further,
+ * constant nodes and primary inputs will be visited first before any gate node
+ * is visited.  Constant nodes precede primary inputs, and primary inputs are
+ * visited in the same order in which they were created.
+ *
+ * Since the topological order is computed only once when creating an instance,
+ * this view disables changes to the network interface.  Also, since only
+ * reachable nodes are traversed, not all network nodes may be called in
+ * `foreach_node` and `foreach_gate`.
+ *
+ * **Required network functions:**
+ * - `get_constant`
+ * - `foreach_pi`
+ * - `foreach_po`
+ * - `foreach_fanin`
+ * - `incr_trav_id`
+ * - `set_visited`
+ * - `trav_id`
+ * - `visited`
+ *
+ * Example
+ *
+   \verbatim embed:rst
+
+   .. code-block:: c++
+
+      // create network somehow; aig may not be in topological order
+      aig_network aig = ...;
+
+      // create a topological view on the network
+      topo_view aig_topo{aig};
+
+      // call algorithm that requires topological order
+      cut_enumeration( aig_topo );
+   \endverbatim
+ */
+template<class Ntk, bool sorted = is_topologically_sorted_v<Ntk>>
+class topo_view
+{
+};
+
+template<typename Ntk>
+class topo_view<Ntk, false> : public immutable_view<Ntk>
+{
+public:
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+  static constexpr bool is_topologically_sorted = true;
+
+  /*! \brief Default constructor.
+   *
+   * Constructs topological view on another network.
+   */
+  topo_view( Ntk const& ntk ) : immutable_view<Ntk>( ntk )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+    static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+    static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+    static_assert( has_incr_trav_id_v<Ntk>, "Ntk does not implement the incr_trav_id method" );
+    static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+    static_assert( has_trav_id_v<Ntk>, "Ntk does not implement the trav_id method" );
+    static_assert( has_visited_v<Ntk>, "Ntk does not implement the visited method" );
+
+    update_topo();
+  }
+
+  /*! \brief Default constructor.
+   *
+   * Constructs topological view, but only for the transitive fan-in starting
+   * from a given start signal.
+   */
+  topo_view( Ntk const& ntk, typename Ntk::signal const& start_signal )
+      : immutable_view<Ntk>( ntk ),
+        start_signal( start_signal )
+  {
+    static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+    static_assert( has_size_v<Ntk>, "Ntk does not implement the size method" );
+    static_assert( has_get_constant_v<Ntk>, "Ntk does not implement the get_constant method" );
+    static_assert( has_foreach_pi_v<Ntk>, "Ntk does not implement the foreach_pi method" );
+    static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+    static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+    static_assert( has_incr_trav_id_v<Ntk>, "Ntk does not implement the incr_trav_id method" );
+    static_assert( has_set_visited_v<Ntk>, "Ntk does not implement the set_visited method" );
+    static_assert( has_trav_id_v<Ntk>, "Ntk does not implement the trav_id method" );
+    static_assert( has_visited_v<Ntk>, "Ntk does not implement the visited method" );
+
+    update_topo();
+  }
+
+  /*! \brief Reimplementation of `size`. */
+  auto size() const
+  {
+    return static_cast<uint32_t>( topo_order.size() );
+  }
+
+  /*! \brief Reimplementation of `num_gates`. */
+  auto num_gates() const
+  {
+    uint32_t const offset = 1u + this->num_pis() + ( this->get_node( this->get_constant( true ) ) != this->get_node( this->get_constant( false ) ) );
+    return static_cast<uint32_t>( topo_order.size() - offset );
+  }
+
+  /*! \brief Reimplementation of `node_to_index`. */
+  uint32_t node_to_index( node const& n ) const
+  {
+    return std::distance( std::begin( topo_order ), std::find( std::begin( topo_order ), std::end( topo_order ), n ) );
+  }
+
+  /*! \brief Reimplementation of `index_to_node`. */
+  node index_to_node( uint32_t index ) const
+  {
+    return topo_order.at( index );
+  }
+
+  /*! \brief Reimplementation of `foreach_node`. */
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    detail::foreach_element( topo_order.begin(),
+                             topo_order.end(),
+                             fn );
+  }
+
+  /*! \brief Implementation of `foreach_node` in reverse topological order. */
+  template<typename Fn>
+  void foreach_node_reverse( Fn&& fn ) const
+  {
+    detail::foreach_element( topo_order.rbegin(),
+                             topo_order.rend(),
+                             fn );
+  }
+
+  /*! \brief Reimplementation of `foreach_gate`. */
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    uint32_t const offset = 1u + this->num_pis() + ( this->get_node( this->get_constant( true ) ) != this->get_node( this->get_constant( false ) ) );
+    detail::foreach_element( topo_order.begin() + offset,
+                             topo_order.end(),
+                             fn );
+  }
+
+  /*! \brief Implementation of `foreach_gate` in reverse topological order. */
+  template<typename Fn>
+  void foreach_gate_reverse( Fn&& fn ) const
+  {
+    uint32_t const offset = 1u + this->num_pis() + ( this->get_node( this->get_constant( true ) ) != this->get_node( this->get_constant( false ) ) );
+    detail::foreach_element( topo_order.rbegin(),
+                             topo_order.rend() - offset,
+                             fn );
+  }
+
+  /*! \brief Reimplementation of `foreach_po`.
+   *
+   * If `start_signal` is provided in constructor, only this is returned as
+   * primary output, otherwise reverts to original `foreach_po` implementation.
+   */
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    if ( start_signal )
+    {
+      std::vector<signal> signals( 1, *start_signal );
+      detail::foreach_element( signals.begin(), signals.end(), fn );
+    }
+    else
+    {
+      Ntk::foreach_po( fn );
+    }
+  }
+
+  uint32_t num_pos() const
+  {
+    return start_signal ? 1 : Ntk::num_pos();
+  }
+
+  void update_topo()
+  {
+    this->incr_trav_id();
+    this->incr_trav_id();
+    topo_order.reserve( this->size() );
+
+    /* constants and PIs */
+    const auto c0 = this->get_node( this->get_constant( false ) );
+    topo_order.push_back( c0 );
+    this->set_visited( c0, this->trav_id() );
+
+    if ( const auto c1 = this->get_node( this->get_constant( true ) ); this->visited( c1 ) != this->trav_id() )
+    {
+      topo_order.push_back( c1 );
+      this->set_visited( c1, this->trav_id() );
+    }
+
+    this->foreach_ci( [this]( auto n ) {
+      if ( this->visited( n ) != this->trav_id() )
+      {
+        topo_order.push_back( n );
+        this->set_visited( n, this->trav_id() );
+      }
+    } );
+
+    if ( start_signal )
+    {
+      if ( this->visited( this->get_node( *start_signal ) ) == this->trav_id() )
+        return;
+      create_topo_rec( this->get_node( *start_signal ) );
+    }
+    else
+    {
+      Ntk::foreach_co( [this]( auto f ) {
+        /* node was already visited */
+        if ( this->visited( this->get_node( f ) ) == this->trav_id() )
+          return;
+
+        create_topo_rec( this->get_node( f ) );
+      } );
+    }
+  }
+
+private:
+  void create_topo_rec( node const& n )
+  {
+    /* is permanently marked? */
+    if ( this->visited( n ) == this->trav_id() )
+      return;
+
+    /* ensure that the node is not temporarily marked */
+    assert( this->visited( n ) != this->trav_id() - 1 );
+
+    /* mark node temporarily */
+    this->set_visited( n, this->trav_id() - 1 );
+
+    /* mark children */
+    this->foreach_fanin( n, [this]( signal const& f ) {
+      create_topo_rec( this->get_node( f ) );
+    } );
+
+    /* mark node n permanently */
+    this->set_visited( n, this->trav_id() );
+
+    /* visit node */
+    topo_order.push_back( n );
+  }
+
+private:
+  std::vector<node> topo_order;
+  std::optional<signal> start_signal;
+};
+
+template<typename Ntk>
+class topo_view<Ntk, true> : public Ntk
+{
+public:
+  topo_view( Ntk const& ntk ) : Ntk( ntk )
+  {
+  }
+};
+
+template<class T>
+topo_view( T const& ) -> topo_view<T>;
+
+template<class T>
+topo_view( T const&, typename T::signal const& ) -> topo_view<T>;
+
+} // namespace mockturtle
\ No newline at end of file
diff --git a/include/mockturtle/views/window_view.hpp b/include/mockturtle/views/window_view.hpp
new file mode 100644
index 0000000..4fafb45
--- /dev/null
+++ b/include/mockturtle/views/window_view.hpp
@@ -0,0 +1,308 @@
+/* mockturtle: C++ logic network library
+ * Copyright (C) 2018-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file window_view.hpp
+  \brief Implements an isolated view on a window in a network
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "../networks/detail/foreach.hpp"
+#include "../traits.hpp"
+#include "../utils/window_utils.hpp"
+#include "immutable_view.hpp"
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <unordered_map>
+#include <vector>
+
+namespace mockturtle
+{
+
+/*! \brief Implements an isolated view on a window in a network.
+ *
+ * This view creates a network from a window in a large network.  The
+ * window is specified by three parameters:
+ *   1.) `inputs` are the common support of all window nodes, they do
+ *       not overlap with `gates` (i.e., the intersection of `inputs` and
+ *       `gates` is the empty set).
+ *   2.) `gates` are the nodes in the window, supported by the
+ *       `inputs` (i.e., `gates` are in the transitive fanout of the
+ *       `inputs`,
+ *   3.) `outputs` are signals (regular or complemented nodes)
+ *        pointing to nodes in `gates` or `inputs`.  Not all fanouts
+ *        of an output node are already part of the window.
+ *
+ * The second parameter `gates` has to be passed and is not
+ * automatically computed (for example in contrast to `cut_view`),
+ * because there are different strategies to construct a window from a
+ * support set.  The outputs could be automatically computed.
+ *
+ * The window_view implements three new API methods:
+ *   1.) `belongs_to`: takes a node (or a signal) and returns true if and
+ *       only if the corresponding node belongs to the window
+ *   2.) `foreach_internal_fanout`: takes a node and invokes a predicate
+         on all fanout nodes of the node that belong to the window
+ *   3.) `foreach_external_fanout`: takes a node and invokes a predicate
+         on all fanouts of the node that do not belong to the window
+ */
+template<typename Ntk>
+class window_view : public immutable_view<Ntk>
+{
+public:
+  using storage = typename Ntk::storage;
+  using node = typename Ntk::node;
+  using signal = typename Ntk::signal;
+
+public:
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  explicit window_view( Ntk const& ntk, std::vector<node> const& inputs, std::vector<signal> const& outputs, std::vector<node> const& gates )
+      : immutable_view<Ntk>( ntk ), _inputs( inputs ), _outputs( outputs )
+  {
+    construct( inputs, gates );
+  }
+
+  explicit window_view( Ntk const& ntk, std::vector<node> const& inputs, std::vector<node> const& outputs, std::vector<node> const& gates )
+      : immutable_view<Ntk>( ntk ), _inputs( inputs )
+  {
+    construct( inputs, gates );
+
+    /* convert output nodes to signals */
+    std::transform( std::begin( outputs ), std::end( outputs ), std::back_inserter( _outputs ),
+                    [this]( node const& n ) {
+                      return this->make_signal( n );
+                    } );
+  }
+
+#pragma region Window
+  template<typename _Ntk = Ntk, typename = std::enable_if_t<!std::is_same_v<typename _Ntk::signal, typename _Ntk::node>>>
+  inline bool belongs_to( signal const& s ) const
+  {
+    return std::find( std::begin( _nodes ), std::end( _nodes ), get_node( s ) ) != std::end( _nodes );
+  }
+
+  inline bool belongs_to( node const& n ) const
+  {
+    return std::find( std::begin( _nodes ), std::end( _nodes ), n ) != std::end( _nodes );
+  }
+#pragma endregion
+
+#pragma region Structural properties
+  inline uint32_t size() const
+  {
+    return static_cast<uint32_t>( _nodes.size() );
+  }
+
+  inline uint32_t num_cis() const
+  {
+    return num_pis();
+  }
+
+  inline uint32_t num_cos() const
+  {
+    return num_pos();
+  }
+
+  inline uint32_t num_pis() const
+  {
+    return static_cast<uint32_t>( _inputs.size() );
+  }
+
+  inline uint32_t num_pos() const
+  {
+    return static_cast<uint32_t>( _outputs.size() );
+  }
+
+  inline uint32_t num_registers() const
+  {
+    return 0u;
+  }
+
+  inline uint32_t num_gates() const
+  {
+    return static_cast<uint32_t>( _nodes.size() - _inputs.size() - 1u );
+  }
+
+  inline uint32_t fanout_size( node const& n ) const = delete;
+
+  inline uint32_t node_to_index( node const& n ) const
+  {
+    return _node_to_index.at( n );
+  }
+
+  inline node index_to_node( uint32_t index ) const
+  {
+    return _nodes[index];
+  }
+
+  inline bool is_pi( node const& n ) const
+  {
+    return std::find( std::begin( _inputs ), std::end( _inputs ), n ) != std::end( _inputs );
+  }
+
+  inline bool is_ci( node const& n ) const
+  {
+    return is_pi( n );
+  }
+
+  signal po_at( uint32_t index ) const
+  {
+    assert( index < _outputs.size() );
+    return *( std::begin( _outputs ) + index );
+  }
+
+  signal co_at( uint32_t index ) const
+  {
+    return po_at( index );
+  }
+#pragma endregion
+
+#pragma region Node and signal iterators
+  template<typename Fn>
+  void foreach_pi( Fn&& fn ) const
+  {
+    detail::foreach_element( std::begin( _inputs ), std::end( _inputs ), fn );
+  }
+
+  template<typename Fn>
+  void foreach_po( Fn&& fn ) const
+  {
+    detail::foreach_element( std::begin( _outputs ), std::end( _outputs ), fn );
+  }
+
+  template<typename Fn>
+  void foreach_ci( Fn&& fn ) const
+  {
+    foreach_pi( fn );
+  }
+
+  template<typename Fn>
+  void foreach_co( Fn&& fn ) const
+  {
+    foreach_po( fn );
+  }
+
+  template<typename Fn>
+  void foreach_ro( Fn&& fn ) const
+  {
+    (void)fn;
+  }
+
+  template<typename Fn>
+  void foreach_ri( Fn&& fn ) const
+  {
+    (void)fn;
+  }
+
+  template<typename Fn>
+  void foreach_register( Fn&& fn ) const
+  {
+    (void)fn;
+  }
+
+  template<typename Fn>
+  void foreach_node( Fn&& fn ) const
+  {
+    detail::foreach_element( std::begin( _nodes ), std::end( _nodes ), fn );
+  }
+
+  template<typename Fn>
+  void foreach_gate( Fn&& fn ) const
+  {
+    detail::foreach_element( std::begin( _nodes ) + 1u + _inputs.size(), std::end( _nodes ), fn );
+  }
+
+  template<typename Fn>
+  void foreach_fanin( node const& n, Fn&& fn ) const
+  {
+    /* constants and inputs do not have fanins */
+    if ( this->is_constant( n ) ||
+         std::find( std::begin( _inputs ), std::end( _inputs ), n ) != std::end( _inputs ) )
+    {
+      return;
+    }
+
+    /* if it's not a window input, the node has to be a window node */
+    assert( std::find( std::begin( _nodes ) + 1 + _inputs.size(), std::end( _nodes ), n ) != std::end( _nodes ) );
+    immutable_view<Ntk>::foreach_fanin( n, fn );
+  }
+
+  template<typename Fn>
+  void foreach_internal_fanout( node const& n, Fn&& fn ) const
+  {
+    this->foreach_fanout( n, [&]( node const& fo ) {
+      if ( tbelongs_to( fo ) )
+      {
+        fn( fo );
+      }
+    } );
+  }
+
+  template<typename Fn>
+  void foreach_external_fanout( node const& n, Fn&& fn ) const
+  {
+    this->foreach_fanout( n, [&]( node const& fo ) {
+      if ( !belongs_to( fo ) )
+      {
+        fn( fo );
+      }
+    } );
+  }
+#pragma endregion
+
+protected:
+  void construct( std::vector<node> const& inputs, std::vector<node> const& gates )
+  {
+    /* copy constant to nodes */
+    _nodes.emplace_back( this->get_node( this->get_constant( false ) ) );
+
+    /* copy inputs to nodes */
+    std::copy( std::begin( inputs ), std::end( inputs ), std::back_inserter( _nodes ) );
+
+    /* copy gates to nodes */
+    std::copy( std::begin( gates ), std::end( gates ), std::back_inserter( _nodes ) );
+
+    /* create a mapping from node id (index in the original network) to window index */
+    for ( uint32_t index = 0; index < _nodes.size(); ++index )
+    {
+      _node_to_index[_nodes.at( index )] = index;
+    }
+  }
+
+protected:
+  std::vector<node> _inputs;
+  std::vector<signal> _outputs;
+  std::vector<node> _nodes;
+  std::unordered_map<node, uint32_t> _node_to_index;
+}; /* window_view */
+
+} /* namespace mockturtle */
\ No newline at end of file
diff --git a/include/util/cover_to_bbdd.hpp b/include/util/cover_to_bbdd.hpp
new file mode 100644
index 0000000..9cffedb
--- /dev/null
+++ b/include/util/cover_to_bbdd.hpp
@@ -0,0 +1,149 @@
+#pragma once
+
+#include "../bbdd/include/bbdd.hpp"
+#include "../bbdd/include/bbdd_node.hpp"
+#include "mockturtle/traits.hpp"
+#include "../bbdd/include/unique_table.hpp"
+#include "util.hpp"
+#include <climits>
+#include <cstdint>
+
+#define LEFT_CHILD(node) node.children[0].index
+#define RIGHT_CHILD(node) node.children[1].index
+
+#define CUBE(node) ntk._storage->data.covers[node.data[1].h1]
+
+int nodes_visited;
+
+using namespace mockturtle;
+
+template <typename Ntk>
+bbdd_node_t *create_bbdd(Unique_table *table, Ntk &ntk, const auto &node_i,
+                         int output_completed) {
+  static_assert(has_is_ci_v<Ntk>, "Ntk does not implement the is_ci method");
+  const auto &node = ntk._storage->nodes[node_i];
+  bbdd_node_t *f, *g, *result;
+  bbdd_op_t op = Util::cube_to_bbdd_op(CUBE(node));
+  if (ntk.visited(node_i)) {
+    return table->get_node_p(ntk.visited(node_i));
+  }
+#ifdef DEBUG_COVER
+  printf("[INFO] CREATE: node %d with op %s\n", node_i, bbdd_op_s[op].c_str());
+#endif
+  if (node.children.size() != 2 && node.children.size() != 1) {
+    if (node_i == 1 || node_i == 0) {
+      return table->get_node_p(node_i);
+    }
+#ifdef DEBUG_COVER
+    std::cout << node_i << ": " << node.children.size() << " with "
+              << bbdd_op_s[op].c_str() << "\n";
+#endif
+    assert(ntk.is_ci(node_i));
+    assert(node_i < pow(2, 31));
+    assert(node_i - 2 < ntk._storage->inputs.size());
+    return table->insert_node({{(node_index_t)node_i, INT_MAX}, 0, 1});
+  }
+  assert(node.children.size() == 2 || node.children.size() == 1);
+  // all the logic gates except buf and inv
+  if (node.children.size() == 2) {
+    node_index_t f_i = LEFT_CHILD(node), g_i = RIGHT_CHILD(node);
+    if (ntk.is_ci(LEFT_CHILD(node)) && ntk.is_ci(RIGHT_CHILD(node))) {
+      result = base_case_two_inputs(table, f_i, g_i, op);
+#ifdef DEBUG_COVER
+      printf("[INFO] CREATE: two input case %d: %d %s %d\n", result->index, f_i,
+             bbdd_op_s[op].c_str(), g_i);
+#endif
+      return result;
+    }
+    f = create_bbdd(table, ntk, LEFT_CHILD(node), output_completed);
+    g = create_bbdd(table, ntk, RIGHT_CHILD(node), output_completed);
+    result = merge_bbdds(table, f, g, op);
+#ifdef DEBUG_COVER
+    std::cout << "[INFO] CREATE: merging " << result->index << ": " << f->index
+              << " " << bbdd_op_s[op] << " " << g->index << "\n";
+    dump_node(g);
+#endif
+    ntk.set_visited(node_i, result->index);
+    Util::show_progress_bar(
+        {{"Output", {output_completed, ntk._storage->outputs.size()}},
+         {"Nodes", {++nodes_visited, ntk._storage->nodes.size()}}},
+        50);
+    return result;
+  } else {
+    // buf and inverter nodes
+    f = create_bbdd(table, ntk, LEFT_CHILD(node), output_completed);
+    if (op == bbdd_inv) {
+      result = negate_recursive(table, f);
+      ntk.set_visited(node_i, result->index);
+      Util::show_progress_bar(
+          {{"Output", {output_completed, ntk._storage->outputs.size()}},
+           {"Nodes", {++nodes_visited, ntk._storage->nodes.size()}}},
+          50);
+      return result;
+    }
+    ntk.set_visited(node_i, f->index);
+    Util::show_progress_bar(
+        {{"Output", {output_completed, ntk._storage->outputs.size()}},
+         {"Nodes", {++nodes_visited, ntk._storage->nodes.size()}}},
+        50);
+    return f;
+  }
+}
+
+template <typename Ntk>
+void cover_to_bbdd(Unique_table *table, Ntk &ntk, bool use_height,
+                   int sifting_repetitions, std::ofstream &order_file) {
+
+  static_assert(has_foreach_co_v<Ntk>,
+                "Ntk does not implement the foreach_pi method");
+  static_assert(has_get_node_v<Ntk>,
+                "Ntk does not implement the get_node method");
+  static_assert(has_set_visited_v<Ntk>,
+                "Ntk does not implement the set_visited method");
+  static_assert(has_visited_v<Ntk>,
+                "Ntk does not implement the set_visited method");
+  int index = ntk._storage->inputs.size() + 2;
+  int output_completed = 0;
+  nodes_visited = 0;
+  Util::show_progress_bar(
+      {{"Output", {output_completed, ntk._storage->outputs.size()}},
+       {"Nodes", {++nodes_visited, ntk._storage->nodes.size()}}},
+      50);
+  ntk.foreach_co([ntk, &table, &index, &output_completed, sifting_repetitions](const auto &node_i) {
+    const auto &node = ntk.get_node(node_i);
+    auto &n = ntk._storage->nodes[node_i];
+#ifdef DEBUG_COVER
+    std::cout << "output with node_i: " << node_i << " and n->index: " << " : "
+              << n.children.size() << "\n";
+#endif
+    bbdd_node_t *output =
+        add_ref(create_bbdd(table, ntk, node, output_completed));
+    Util::show_progress_bar(
+        {{"Output", {++output_completed, ntk._storage->outputs.size()}},
+         {"Nodes", {++nodes_visited, ntk._storage->nodes.size()}}},
+        50);
+    table->add_output(ntk.get_signal_name(index), output);
+    index++;
+    /*if (table->get_total_height() > 20 && table->get_total_height() < 30) {
+      sift(table, &Unique_table::get_total_number_nodes, table);
+      ntk.clear_visited();
+    }*/
+  });
+  for (int i = 0; i < sifting_repetitions; i++) {
+    /*printf("total height before sifting: %d and total number of nodes before: "
+           "%d\n",
+           table->get_max_height(), table->get_total_number_nodes());
+    if (order_file.is_open()) {
+      dump_ordering(table->cvo, order_file);
+      order_file << ";" << table->get_max_height() << ";"
+                 << table->get_total_number_nodes() << "\n";
+    }*/
+    if (table->get_total_height() < 30) {
+      if (use_height) {
+        sift(table, &Unique_table::get_total_height, table);
+      } else {
+        sift(table, &Unique_table::get_total_number_nodes, table);
+      }
+    }
+  }
+}
diff --git a/include/util/cover_to_bdd.hpp b/include/util/cover_to_bdd.hpp
new file mode 100644
index 0000000..dc444e1
--- /dev/null
+++ b/include/util/cover_to_bdd.hpp
@@ -0,0 +1,114 @@
+#pragma once
+
+#include "../bbdd/include/bbdd_node.hpp"
+#include "bdd.h"
+#include "util.hpp"
+
+#define LEFT_CHILD(node) node.children[0].index
+#define RIGHT_CHILD(node) node.children[1].index
+#define CUBE(node) ntk._storage->data.covers[node.data[1].h1]
+
+using namespace mockturtle;
+
+template <typename Ntk> bdd create_bdd(Ntk &ntk, const auto &node_i) {
+  static_assert(has_is_ci_v<Ntk>, "Ntk does not implement the is_ci method");
+  const auto &node = ntk._storage->nodes[node_i];
+  bdd f, g, result;
+  bbdd_op_t op = Util::cube_to_bbdd_op(CUBE(node));
+  if (node.children.size() != 2 && node.children.size() != 1) {
+    if (node_i == 1) {
+#ifdef DEBUG_BDD
+      printf("[INFO] cover to bdd: constant 1 node\n");
+#endif
+      return bdd_true();
+    }
+    if (node_i == 0) {
+#ifdef DEBUG_BDD
+      printf("[INFO] cover to bdd: constant 0 node\n");
+#endif
+      return bdd_false();
+    }
+    assert(ntk.is_ci(node_i));
+    assert(node_i < pow(2, 31));
+    assert(node_i - 2 < ntk._storage->inputs.size());
+#ifdef DEBUG_BDD
+    printf("[INFO] cover to bdd: base case input: %d\n", node_i);
+#endif
+    return bdd_ithvar(node_i - 2);
+  }
+  assert(node.children.size() == 2 || node.children.size() == 1);
+  // all the logic gates except buf and inv
+  if (node.children.size() == 2) {
+    node_index_t f_i = LEFT_CHILD(node), g_i = RIGHT_CHILD(node);
+    f = create_bdd(ntk, LEFT_CHILD(node));
+#ifdef DEBUG_BDD
+    printf("[INFO] cover to bdd: return from f\n");
+#endif
+    g = create_bdd(ntk, RIGHT_CHILD(node));
+#ifdef DEBUG_BDD
+    printf("[INFO] cover to bdd: merge %d %s %d\n", f,
+           bbdd_op_s[op].c_str(), g);
+#endif
+    switch (op) {
+    case bbdd_and:
+      result = bdd_apply(f, g, bddop_and);
+      break;
+    case bbdd_xor:
+      result = bdd_apply(f, g, bddop_xor);
+      break;
+    case bbdd_xnor:
+      result = bdd_not(bdd_apply(f, g, bddop_xor));
+      break;
+    case bbdd_or:
+      result = bdd_apply(f, g, bddop_or);
+      break;
+    case bbdd_nand:
+      result = bdd_apply(f, g, bddop_nand);
+      break;
+    case bbdd_nor:
+      result = bdd_apply(f, g, bddop_nor);
+      break;
+    default:
+      printf("%s\n", bbdd_op_s[op].c_str());
+      assert(false && "not implemented yet");
+      break;
+    }
+    return result;
+  } else {
+    // buf and inverter nodes
+    f = create_bdd(ntk, LEFT_CHILD(node));
+    // TODO how to invert
+    if (op == bbdd_inv) {
+#ifdef DEBUG_BDD
+      printf("[INFO] cover to bdd: negate\n");
+#endif
+      result = bdd_not(f);
+      return result;
+    }
+#ifdef DEBUG_BDD
+    printf("[INFO] cover to bdd: buffer\n");
+#endif
+    return f;
+  }
+}
+
+template <typename Ntk> void cover_to_bdd(Ntk &ntk, std::vector<std::pair<bdd, std::string>> &output_map) {
+
+  static_assert(has_foreach_co_v<Ntk>,
+                "Ntk does not implement the foreach_pi method");
+  static_assert(has_get_node_v<Ntk>,
+                "Ntk does not implement the get_node method");
+  static_assert(has_set_visited_v<Ntk>,
+                "Ntk does not implement the set_visited method");
+  static_assert(has_visited_v<Ntk>,
+                "Ntk does not implement the set_visited method");
+  int index = ntk._storage->inputs.size() + 2;
+  ntk.foreach_co([ntk, &index, &output_map](const auto &node_i) {
+    const auto &node = ntk.get_node(node_i);
+    auto &n = ntk._storage->nodes[node_i];
+    bdd output = create_bdd(ntk, node);
+    output_map.emplace_back(output, ntk.get_signal_name(index));
+    bdd_printtable(output);
+    index++;
+  });
+  }
diff --git a/include/util/util.hpp b/include/util/util.hpp
new file mode 100644
index 0000000..d2aec2b
--- /dev/null
+++ b/include/util/util.hpp
@@ -0,0 +1,97 @@
+#include "../bbdd/include/bbdd_node.hpp"
+#include "kitty/cube.hpp"
+#include "mockturtle/networks/cover.hpp"
+#include <algorithm>
+#include <kitty/kitty.hpp>
+#include <mockturtle/mockturtle.hpp>
+#include <string>
+
+class Util {
+
+public:
+  static bbdd_op_t
+  cube_to_bbdd_op(std::pair<std::vector<kitty::cube>, bool> const &cover) {
+    bbdd_op_t type = bbdd_none;
+    if (cover.second) { // on-set
+      if (cover.first.size() == 1) {
+        if (cover.first[0] == kitty::cube("11")) {
+          type = bbdd_and;
+        } else if (cover.first[0] == kitty::cube("0")) {
+          type = bbdd_inv;
+        } else if (cover.first[0] == kitty::cube("00")) {
+          type = bbdd_and;
+        } else if (cover.first[0] == kitty::cube("01")) {
+          type = bbdd_notand;
+        } else if (cover.first[0] == kitty::cube("10")) {
+          type = bbdd_andnot;
+        } else if (cover.first[0] == kitty::cube("1")) {
+          type = bbdd_buf;
+        } else if (cover.first[0] == kitty::cube("")) {
+          type = bbdd_one;
+        }
+      } else if (cover.first.size() == 2) {
+        if (cover.first[0] == kitty::cube("1-") &&
+            cover.first[1] == kitty::cube("-1")) {
+          type = bbdd_or;
+        } else if (cover.first[0] == kitty::cube("10") &&
+                   cover.first[1] == kitty::cube("01")) {
+          type = bbdd_xor;
+        } else if (cover.first[0] == kitty::cube("11") &&
+                   cover.first[1] == kitty::cube("00")) {
+          type = bbdd_xnor;
+        }
+      } else if (cover.first.size() == 3) {
+        if (cover.first[0] == kitty::cube("10") &&
+            cover.first[1] == kitty::cube("01") &&
+            cover.first[0] == kitty::cube("11")) {
+          type = bbdd_or;
+        }
+      }
+    } else if (!cover.second) { // off-set
+      if (cover.first.size() == 1) {
+        if (cover.first[0] == kitty::cube("")) {
+          type = bbdd_zero;
+        }
+        if (cover.first[0] == kitty::cube("00")) {
+          type = bbdd_or;
+        } else if (cover.first[0] == kitty::cube("01")) {
+          type = bbdd_ornot;
+        } else if (cover.first[0] == kitty::cube("10")) {
+          type = bbdd_notor;
+        } else if (cover.first[0] == kitty::cube("11")) {
+          type = bbdd_nor;
+        }
+      }
+    }
+    if (type == bbdd_none) {
+      kitty::print_cubes(cover.first);
+    }
+    assert(type != bbdd_none && "[ERROR] cube function not implemented\n");
+    return type;
+  }
+
+  // format list(progress name, (share, base))
+  void static show_progress_bar(std::vector<std::pair<std::string, std::pair<int, int>>> progress_v,
+                                int bar_width) {
+    for (std::pair<std::string, std::pair<int, int>> progress : progress_v) {
+      std::string name = progress.first;
+      int share = progress.second.first;
+      int base = progress.second.second;
+      int current_width = bar_width / progress_v.size();
+      float percent = (float)share / base;
+      int pos = percent * current_width;
+      std::cout << name << ": [";
+      for (int i = 0; i < current_width; i++) {
+        if (i < pos)
+          std::cout << "=";
+        else if (i == pos)
+          std::cout << ">";
+        else
+          std::cout << " ";
+      }
+      std::cout << "] " << share << "/" << base << " " << (int)(percent * 100) << "% ";
+    }
+    std::cout << " \r";
+    std::cout.flush();
+  }
+};
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
new file mode 100644
index 0000000..b6594fa
--- /dev/null
+++ b/lib/CMakeLists.txt
@@ -0,0 +1,91 @@
+if (NOT TARGET parallel_hashmap)
+  add_library(parallel_hashmap INTERFACE) # 2020.11
+  target_include_directories(parallel_hashmap SYSTEM INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/parallel_hashmap)
+endif()
+
+if (NOT TARGET fmt)
+  add_library(fmt INTERFACE) # v6.3.0
+  target_include_directories(fmt SYSTEM INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/fmt)
+  target_compile_definitions(fmt INTERFACE FMT_HEADER_ONLY)
+endif()
+
+if (NOT TARGET kitty)
+  add_library(kitty INTERFACE) # v0.4
+  target_include_directories(kitty SYSTEM INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/kitty)
+endif()
+
+if (NOT TARGET range)
+  add_library(rang INTERFACE)
+  target_include_directories(rang SYSTEM INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/rang)
+endif()
+
+if (NOT TARGET lorina)
+  add_library(lorina INTERFACE) # v0.1
+  target_include_directories(lorina SYSTEM INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/lorina)
+  target_link_libraries(lorina INTERFACE rang fmt)
+endif()
+
+if (NOT TARGET json)
+  add_library(json INTERFACE) # v3.5.0
+  target_include_directories(json SYSTEM INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/json)
+endif()
+
+if (NOT TARGET percy)
+  add_library(percy INTERFACE) # >v0.1.2
+  target_include_directories(percy SYSTEM INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/percy)
+
+  set(THREADS_PREFER_PTHREAD_FLAG ON)
+  find_package(Threads REQUIRED)
+  target_link_libraries(percy INTERFACE Threads::Threads)
+
+  set(ABC_USE_NAMESPACE "pabc")
+  set(STATIC_LIBABC true)
+  add_subdirectory(abcsat)
+  if (UNIX)
+    target_compile_definitions(libabcsat PUBLIC "LIN64" ABC_NAMESPACE=pabc ABC_NO_USE_READLINE)
+  elseif(WIN32)
+    target_compile_definitions(libabcsat PUBLIC ABC_NAMESPACE=pabc ABC_USE_NO_READLINE NOMINMAX  WIN32_NO_DLL _CRT_SECURE_NO_WARNINGS)
+  endif()
+  target_link_libraries(percy INTERFACE libabcsat)
+
+  if (ENABLE_NAUTY)
+    add_subdirectory(nauty)
+    target_link_libraries(percy INTERFACE nauty)
+  else()
+    target_compile_definitions(percy INTERFACE DISABLE_NAUTY)
+  endif()
+endif()
+
+if (NOT TARGET bill)
+  add_library(bill INTERFACE)
+  target_include_directories(bill SYSTEM INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/bill)
+
+  if(BILL_Z3)
+    target_compile_definitions(bill INTERFACE BILL_HAS_Z3)
+    set(BILL_Z3_INCLUDE_PATH "" CACHE PATH "Path to Z3 includes, e.g., z3++.h")
+    set(BILL_Z3_LIBRARY_PATH "" CACHE PATH "Path to Z3 library, e.g., libz3.a")
+    if(NOT "${BILL_Z3_INCLUDE_PATH}" STREQUAL "")
+      target_include_directories(bill SYSTEM INTERFACE ${BILL_Z3_INCLUDE_PATH})
+    endif()
+    if(NOT "${BILL_Z3_LIBRARY_PATH}" STREQUAL "")
+      target_link_directories(bill INTERFACE ${BILL_Z3_LIBRARY_PATH})
+    endif()
+    if (WIN32)
+      target_link_libraries(bill INTERFACE libz3)
+    else()
+      target_link_libraries(bill INTERFACE z3)
+    endif()
+  endif()
+endif()
+
+if (NOT TARGET libabcesop)
+  set(STATIC_LIBABC true)
+  add_subdirectory(abcesop)
+endif()
+
+if (ENABLE_MATPLOTLIB AND NOT TARGET matplot)
+  find_package(Python3 COMPONENTS Development NumPy)
+  add_library(matplot INTERFACE)
+  target_include_directories(matplot SYSTEM INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/matplot/ ${Python3_INCLUDE_DIRS} ${Python3_NumPy_INCLUDE_DIRS})
+  target_link_libraries(matplot INTERFACE Python3::Python Python3::NumPy)
+endif()
diff --git a/lib/abcesop/CMakeLists.txt b/lib/abcesop/CMakeLists.txt
new file mode 100644
index 0000000..c2a056b
--- /dev/null
+++ b/lib/abcesop/CMakeLists.txt
@@ -0,0 +1,29 @@
+cmake_minimum_required (VERSION 3.6)
+
+project(libabcesop LANGUAGES CXX)
+
+include_directories(${PROJECT_SOURCE_DIR})
+file(GLOB ABC_SRC *.cpp)
+
+# Surpress warnings in external library
+if (UNIX)
+    add_compile_options("-w")
+elseif (MSVC)
+    string(REPLACE "/W3" "/w" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+endif()
+
+if (STATIC_LIBABC)
+    add_library(libabcesop STATIC EXCLUDE_FROM_ALL ${ABC_SRC})
+    set_property(TARGET libabcesop PROPERTY OUTPUT_NAME libabcesop)
+else()
+    add_library(libabcesop SHARED EXCLUDE_FROM_ALL ${ABC_SRC})
+    set_property(TARGET libabcesop PROPERTY OUTPUT_NAME libabcesop)
+    set_property(TARGET libabcesop PROPERTY POSITION_INDEPENDENT_CODE ON)
+endif()
+target_include_directories(libabcesop INTERFACE ${PROJECT_SOURCE_DIR})
+
+if (UNIX)
+    target_compile_definitions(libabcesop PUBLIC "LIN64" ABC_NO_USE_READLINE)
+elseif(WIN32)
+    target_compile_definitions(libabcesop PUBLIC ABC_USE_NO_READLINE NOMINMAX  WIN32_NO_DLL _CRT_SECURE_NO_WARNINGS)
+endif()
diff --git a/lib/abcesop/eabc/abc_global.h b/lib/abcesop/eabc/abc_global.h
new file mode 100644
index 0000000..98a8fc0
--- /dev/null
+++ b/lib/abcesop/eabc/abc_global.h
@@ -0,0 +1,157 @@
+/**CFile****************************************************************
+
+  FileName    [abc_global.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Global declarations.]
+
+  Synopsis    [Global declarations.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - Jan 30, 2009.]
+
+  Revision    [$Id: abc_global.h,v 1.00 2009/01/30 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#pragma once
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#ifdef _WIN32
+#ifndef __MINGW32__
+//#define inline __inline // compatible with MS VS 6.0
+#pragma warning(disable : 4152) // warning C4152: nonstandard extension, function/data pointer conversion in expression
+#pragma warning(disable : 4200) // warning C4200: nonstandard extension used : zero-sized array in struct/union
+#pragma warning(disable : 4244) // warning C4244: '+=' : conversion from 'int ' to 'unsigned short ', possible loss of data
+#pragma warning(disable : 4514) // warning C4514: 'Vec_StrPop' : unreferenced inline function has been removed
+#pragma warning(disable : 4710) // warning C4710: function 'Vec_PtrGrow' not inlined
+//#pragma warning( disable : 4273 )
+#endif
+#endif
+
+#ifdef WIN32
+  #ifdef WIN32_NO_DLL
+    #define ABC_DLLEXPORT
+    #define ABC_DLLIMPORT
+  #else
+    #define ABC_DLLEXPORT __declspec(dllexport)
+    #define ABC_DLLIMPORT __declspec(dllimport)
+  #endif
+#else  /* defined(WIN32) */
+#define ABC_DLLIMPORT
+#endif /* defined(WIN32) */
+
+#ifndef ABC_DLL
+#define ABC_DLL ABC_DLLIMPORT
+#endif
+
+#if !defined(___unused)
+#if defined(__GNUC__)
+#define ___unused __attribute__ ((__unused__))
+#else
+#define ___unused
+#endif
+#endif
+
+#include <time.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+namespace abc::exorcism {
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+/**
+ * Signed integral type that can contain a pointer.
+ * This is a signed integral type that is the same size as a pointer.
+ * NOTE: This type may be different sizes on different platforms.
+ */
+#if       defined(__ccdoc__)
+typedef platform_dependent_type ABC_PTRINT_T;
+#elif     defined(ABC_USE_STDINT_H)
+typedef intptr_t ABC_PTRINT_T;
+#elif     defined(LIN64)
+typedef long ABC_PTRINT_T;
+#elif     defined(NT64)
+typedef long long ABC_PTRINT_T;
+#elif     defined(NT) || defined(LIN) || defined(WIN32)
+typedef int ABC_PTRINT_T;
+#else
+   #error unknown platform
+#endif /* defined(PLATFORM) */
+
+/**
+ * 64-bit signed integral type.
+ */
+#if       defined(__ccdoc__)
+typedef platform_dependent_type ABC_INT64_T;
+#elif     defined(ABC_USE_STDINT_H)
+typedef int64_t ABC_INT64_T;
+#elif     defined(LIN64)
+typedef long ABC_INT64_T;
+#elif     defined(NT64) || defined(LIN)
+typedef long long ABC_INT64_T;
+#elif     defined(WIN32) || defined(NT)
+typedef signed __int64 ABC_INT64_T;
+#else
+   #error unknown platform
+#endif /* defined(PLATFORM) */
+
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+#define ABC_SWAP(Type, a, b)  { Type t = a; a = b; b = t; }
+
+#define ABC_ALLOC(type, num)     ((type *) malloc(sizeof(type) * (size_t)(num)))
+#define ABC_CALLOC(type, num)    ((type *) calloc((size_t)(num), sizeof(type)))
+#define ABC_FALLOC(type, num)    ((type *) memset(malloc(sizeof(type) * (size_t)(num)), 0xff, sizeof(type) * (size_t)(num)))
+#define ABC_FREE(obj)            ((obj) ? (free((char *) (obj)), (obj) = 0) : 0)
+#define ABC_REALLOC(type, obj, num) \
+        ((obj) ? ((type *) realloc((char *)(obj), sizeof(type) * (size_t)(num))) : \
+         ((type *) malloc(sizeof(type) * (size_t)(num))))
+
+static inline int      Abc_MaxInt( int a, int b )             { return a > b ?  a : b; }
+static inline int      Abc_Base2Log( unsigned n )             { int r; if ( n < 2 ) return (int)n; for ( r = 0, n--; n; n >>= 1, r++ ) {}; return r; }
+static inline char *   Abc_UtilStrsav( char * s )             { return s ? strcpy(ABC_ALLOC(char, strlen(s)+1), s) : NULL;  }
+static inline int      Abc_Lit2Var( int Lit )                 { assert(Lit >= 0); return Lit >> 1;                          }
+static inline int      Abc_LitIsCompl( int Lit )              { assert(Lit >= 0); return Lit & 1;                           }
+
+// time counting
+typedef ABC_INT64_T abctime;
+static inline abctime Abc_Clock()
+{
+#if (defined(LIN) || defined(LIN64)) && !(__APPLE__ & __MACH__) && !defined(__MINGW32__)
+    struct timespec ts;
+    if ( clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) < 0 ) 
+        return (abctime)-1;
+    abctime res = ((abctime) ts.tv_sec) * CLOCKS_PER_SEC;
+    res += (((abctime) ts.tv_nsec) * CLOCKS_PER_SEC) / 1000000000;
+    return res;
+#else
+    return (abctime) clock();
+#endif
+}
+
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
diff --git a/lib/abcesop/eabc/exor.h b/lib/abcesop/eabc/exor.h
new file mode 100644
index 0000000..6a25ccf
--- /dev/null
+++ b/lib/abcesop/eabc/exor.h
@@ -0,0 +1,184 @@
+/**CFile****************************************************************
+
+  FileName    [exor.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Exclusive sum-of-product minimization.]
+
+  Synopsis    [Internal declarations.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: exor.h,v 1.0 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+////////////////////////////////////////////////////////////////////////
+///                                                                  ///
+///                    Interface of EXORCISM - 4                     ///
+///              An Exclusive Sum-of-Product Minimizer               ///
+///               Alan Mishchenko  <alanmi@ee.pdx.edu>               ///
+///                                                                  ///
+////////////////////////////////////////////////////////////////////////
+///                                                                  ///
+///                         Main Module                              ///
+///                                                                  ///
+///  Ver. 1.0. Started - July 15, 2000. Last update - July 20, 2000  ///
+///  Ver. 1.4. Started - Aug 10, 2000.  Last update - Aug 10, 2000   ///
+///  Ver. 1.7. Started - Sep 20, 2000.  Last update - Sep 23, 2000   ///
+///                                                                  ///
+////////////////////////////////////////////////////////////////////////
+///   This software was tested with the BDD package "CUDD", v.2.3.0  ///
+///                          by Fabio Somenzi                        ///
+///                  http://vlsi.colorado.edu/~fabio/                ///
+////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <time.h>
+#include "eabc/abc_global.h"
+#include "eabc/vecInt.h"
+#include "eabc/vecPtr.h"
+#include "eabc/vecWec.h"
+
+namespace abc::exorcism { 
+
+////////////////////////////////////////////////////////////////////////
+///                       MACRO DEFINITIONS                          ///
+////////////////////////////////////////////////////////////////////////
+
+enum {
+  // the number of bits per integer
+  BPI = 32,
+  BPIMASK = 31,
+  LOGBPI = 5,
+
+  // the maximum number of input variables
+  MAXVARS = 1000,
+
+  // the number of cubes that are allocated additionally
+  ADDITIONAL_CUBES = 33,
+
+  // the factor showing how many cube pairs will be allocated
+  CUBE_PAIR_FACTOR = 20,
+  // the following number of cube pairs are allocated:
+  // nCubesAlloc/CUBE_PAIR_FACTOR
+
+  DIFFERENT = 0x55555555,
+};
+
+extern unsigned char BitCount[];
+
+static inline int BIT_COUNT(int w) { return BitCount[(w)&0xffff] + BitCount[(w)>>16]; }
+
+static inline int VarWord(int element) { return element>>LOGBPI; }
+static inline int VarBit(int element) { return element&BPIMASK; }
+
+static inline float TICKS_TO_SECONDS(abctime time) { return (float)time/(float)CLOCKS_PER_SEC; }
+
+////////////////////////////////////////////////////////////////////////
+///                  CUBE COVER and CUBE typedefs                    ///
+////////////////////////////////////////////////////////////////////////
+
+typedef enum { MULTI_OUTPUT = 1, SINGLE_NODE, MULTI_NODE  } type;
+
+// infomation about the cover
+typedef struct cinfo_tag 
+{
+    int nVarsIn;        // number of input binary variables in the cubes
+    int nVarsOut;       // number of output binary variables in the cubes
+    int nWordsIn;       // number of input words used to represent the cover
+    int nWordsOut;      // number of output words used to represent the cover
+    int nCubesAlloc;    // the number of allocated cubes 
+    int nCubesBefore;   // number of cubes before simplification
+    int nCubesInUse;    // number of cubes after simplification
+    int nCubesFree;     // number of free cubes
+    int nLiteralsBefore;// number of literals before
+    int nLiteralsAfter; // number of literals after
+    int QCostBefore;    // q-cost before
+    int QCostAfter;     // q-cost after
+    int cIDs;           // the counter of cube IDs
+
+    int Verbosity;      // verbosity level
+    int Quality;        // quality
+    int nCubesMax;      // maximum number of cubes in starting cover
+    int fUseQCost;      // use q-cost instead of literal count
+
+    abctime TimeRead;   // reading time
+    abctime TimeStart;  // starting cover computation time
+    abctime TimeMin;    // pure minimization time
+} cinfo;
+
+// representation of one cube (24 bytes + bit info)
+typedef unsigned int  drow;
+typedef unsigned char byte;
+typedef struct cube 
+{
+    byte  fMark;        // the flag which is TRUE if the cubes is enabled
+    byte  ID;           // (almost) unique ID of the cube
+    short a;            // the number of literals
+    short z;            // the number of 1's in the output part
+    short q;            // user cost
+    drow* pCubeDataIn;  // a pointer to the bit string representing literals
+    drow* pCubeDataOut; // a pointer to the bit string representing literals
+    struct cube* Prev;  // pointers to the previous/next cubes in the list/ring 
+    struct cube* Next;
+} Cube;
+
+
+// preparation
+extern void PrepareBitSetModule();
+extern int WriteResultIntoFile( char * pFileName );
+
+// iterative ExorLink
+extern int IterativelyApplyExorLink2( char fDistEnable );   
+extern int IterativelyApplyExorLink3( char fDistEnable );   
+extern int IterativelyApplyExorLink4( char fDistEnable );   
+
+// cube storage allocation/delocation
+extern int AllocateCubeSets( int nVarsIn, int nVarsOut );
+extern void DelocateCubeSets();
+
+// adjacency queque allocation/delocation procedures
+extern int AllocateQueques( int nPlaces );
+extern void DelocateQueques();
+
+extern int AllocateCover( int nCubes, int nWordsIn, int nWordsOut );
+extern void DelocateCover();
+
+extern void AddToFreeCubes( Cube* pC );
+extern Cube* GetFreeCube();
+// getting and returning free cubes to the heap
+
+extern void InsertVarsWithoutClearing( Cube * pC, int * pVars, int nVarsIn, int * pVarValues, int Output );
+extern int CheckForCloseCubes( Cube* p, int fAddCube );
+
+extern int FindDiffVars( int *pDiffVars, Cube* pC1, Cube* pC2 );
+// determines the variables that are different in cubes pC1 and pC2
+// returns the number of variables
+
+extern int ComputeQCost( Vec_Int_t * vCube );
+extern int ComputeQCostBits( Cube * p );
+
+extern int CountLiterals();
+extern int CountQCost();
+
+////////////////////////////////////////////////////////////////////////
+///              VARVALUE and CUBEDIST enum typedefs                 ///
+////////////////////////////////////////////////////////////////////////
+
+// literal values
+typedef enum { VAR_NEG = 1, VAR_POS, VAR_ABS  } varvalue;
+
+// the flag in some function calls can take one of the follwing values
+typedef enum { DIST2, DIST3, DIST4 } cubedist;
+
+}
diff --git a/lib/abcesop/eabc/vecInt.h b/lib/abcesop/eabc/vecInt.h
new file mode 100644
index 0000000..1a13e6c
--- /dev/null
+++ b/lib/abcesop/eabc/vecInt.h
@@ -0,0 +1,2070 @@
+/**CFile****************************************************************
+
+  FileName    [vecInt.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Resizable arrays.]
+
+  Synopsis    [Resizable arrays of integers.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: vecInt.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+ 
+#pragma once
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include <stdio.h>
+
+namespace abc::exorcism {
+
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct Vec_Int_t_       Vec_Int_t;
+struct Vec_Int_t_ 
+{
+    int              nCap;
+    int              nSize;
+    int *            pArray;
+};
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+#define Vec_IntForEachEntry( vVec, Entry, i )                                               \
+    for ( i = 0; (i < Vec_IntSize(vVec)) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ )
+#define Vec_IntForEachEntryStart( vVec, Entry, i, Start )                                   \
+    for ( i = Start; (i < Vec_IntSize(vVec)) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ )
+#define Vec_IntForEachEntryStop( vVec, Entry, i, Stop )                                     \
+    for ( i = 0; (i < Stop) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ )
+#define Vec_IntForEachEntryStartStop( vVec, Entry, i, Start, Stop )                         \
+    for ( i = Start; (i < Stop) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ )
+#define Vec_IntForEachEntryReverse( vVec, pEntry, i )                                       \
+    for ( i = Vec_IntSize(vVec) - 1; (i >= 0) && (((pEntry) = Vec_IntEntry(vVec, i)), 1); i-- )
+#define Vec_IntForEachEntryTwo( vVec1, vVec2, Entry1, Entry2, i )                           \
+    for ( i = 0; (i < Vec_IntSize(vVec1)) && (((Entry1) = Vec_IntEntry(vVec1, i)), 1) && (((Entry2) = Vec_IntEntry(vVec2, i)), 1); i++ )
+#define Vec_IntForEachEntryDouble( vVec, Entry1, Entry2, i )                                \
+    for ( i = 0; (i+1 < Vec_IntSize(vVec)) && (((Entry1) = Vec_IntEntry(vVec, i)), 1) && (((Entry2) = Vec_IntEntry(vVec, i+1)), 1); i += 2 )
+#define Vec_IntForEachEntryDoubleStart( vVec, Entry1, Entry2, i, Start )                    \
+    for ( i = Start; (i+1 < Vec_IntSize(vVec)) && (((Entry1) = Vec_IntEntry(vVec, i)), 1) && (((Entry2) = Vec_IntEntry(vVec, i+1)), 1); i += 2 )
+#define Vec_IntForEachEntryTriple( vVec, Entry1, Entry2, Entry3, i )                        \
+    for ( i = 0; (i+2 < Vec_IntSize(vVec)) && (((Entry1) = Vec_IntEntry(vVec, i)), 1) && (((Entry2) = Vec_IntEntry(vVec, i+1)), 1) && (((Entry3) = Vec_IntEntry(vVec, i+2)), 1); i += 3 )
+#define Vec_IntForEachEntryThisNext( vVec, This, Next, i )                                  \
+    for ( i = 0, (This) = (Next) = (Vec_IntSize(vVec) ? Vec_IntEntry(vVec, 0) : -1); (i+1 < Vec_IntSize(vVec)) && (((Next) = Vec_IntEntry(vVec, i+1)), 1); i += 2, (This) = (Next) )
+#define Vec_IntForEachEntryInVec( vVec2, vVec, Entry, i )                                   \
+    for ( i = 0; (i < Vec_IntSize(vVec)) && (((Entry) = Vec_IntEntry(vVec2, Vec_IntEntry(vVec, i))), 1); i++ )
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates a vector with the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntAlloc( int nCap )
+{
+    Vec_Int_t * p;
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    if ( nCap > 0 && nCap < 16 )
+        nCap = 16;
+    p->nSize  = 0;
+    p->nCap   = nCap;
+    p->pArray = p->nCap? ABC_ALLOC( int, p->nCap ) : NULL;
+    return p;
+}
+static inline Vec_Int_t * Vec_IntAllocExact( int nCap )
+{
+    Vec_Int_t * p;
+    assert( nCap >= 0 );
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    p->nSize  = 0;
+    p->nCap   = nCap;
+    p->pArray = p->nCap? ABC_ALLOC( int, p->nCap ) : NULL;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates a vector with the given size and cleans it.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntStart( int nSize )
+{
+    Vec_Int_t * p;
+    p = Vec_IntAlloc( nSize );
+    p->nSize = nSize;
+    if ( p->pArray ) memset( p->pArray, 0, sizeof(int) * (size_t)nSize );
+    return p;
+}
+static inline Vec_Int_t * Vec_IntStartFull( int nSize )
+{
+    Vec_Int_t * p;
+    p = Vec_IntAlloc( nSize );
+    p->nSize = nSize;
+    if ( p->pArray ) memset( p->pArray, 0xff, sizeof(int) * (size_t)nSize );
+    return p;
+}
+static inline Vec_Int_t * Vec_IntStartRange( int First, int Range )
+{
+    Vec_Int_t * p;
+    int i;
+    p = Vec_IntAlloc( Range );
+    p->nSize = Range;
+    for ( i = 0; i < Range; i++ )
+        p->pArray[i] = First + i;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates a vector with the given size and cleans it.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntStartNatural( int nSize )
+{
+    Vec_Int_t * p;
+    int i;
+    p = Vec_IntAlloc( nSize );
+    p->nSize = nSize;
+    for ( i = 0; i < nSize; i++ )
+        p->pArray[i] = i;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Creates the vector from an integer array of the given size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntAllocArray( int * pArray, int nSize )
+{
+    Vec_Int_t * p;
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    p->nSize  = nSize;
+    p->nCap   = nSize;
+    p->pArray = pArray;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Creates the vector from an integer array of the given size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntAllocArrayCopy( int * pArray, int nSize )
+{
+    Vec_Int_t * p;
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    p->nSize  = nSize;
+    p->nCap   = nSize;
+    p->pArray = ABC_ALLOC( int, nSize );
+    memcpy( p->pArray, pArray, sizeof(int) * (size_t)nSize );
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Duplicates the integer array.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntDup( Vec_Int_t * pVec )
+{
+    Vec_Int_t * p;
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    p->nSize  = pVec->nSize;
+    p->nCap   = pVec->nSize;
+    p->pArray = p->nCap? ABC_ALLOC( int, p->nCap ) : NULL;
+    memcpy( p->pArray, pVec->pArray, sizeof(int) * (size_t)pVec->nSize );
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Transfers the array into another vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntDupArray( Vec_Int_t * pVec )
+{
+    Vec_Int_t * p;
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    p->nSize  = pVec->nSize;
+    p->nCap   = pVec->nCap;
+    p->pArray = pVec->pArray;
+    pVec->nSize  = 0;
+    pVec->nCap   = 0;
+    pVec->pArray = NULL;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntZero( Vec_Int_t * p )
+{
+    p->pArray = NULL;
+    p->nSize = 0;
+    p->nCap = 0;
+}
+static inline void Vec_IntErase( Vec_Int_t * p )
+{
+    ABC_FREE( p->pArray );
+    p->nSize = 0;
+    p->nCap = 0;
+}
+static inline void Vec_IntFree( Vec_Int_t * p )
+{
+    ABC_FREE( p->pArray );
+    ABC_FREE( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntFreeP( Vec_Int_t ** p )
+{
+    if ( *p == NULL )
+        return;
+    ABC_FREE( (*p)->pArray );
+    ABC_FREE( (*p) );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int * Vec_IntReleaseArray( Vec_Int_t * p )
+{
+    int * pArray = p->pArray;
+    p->nCap = 0;
+    p->nSize = 0;
+    p->pArray = NULL;
+    return pArray;
+}
+static inline int * Vec_IntReleaseNewArray( Vec_Int_t * p )
+{
+    int * pArray = ABC_ALLOC( int, p->nSize+1 );
+    pArray[0] = p->nSize+1;
+    memcpy( pArray+1, p->pArray, sizeof(int)*(size_t)p->nSize );
+    return pArray;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int * Vec_IntArray( Vec_Int_t * p )
+{
+    return p->pArray;
+}
+static inline int ** Vec_IntArrayP( Vec_Int_t * p )
+{
+    return &p->pArray;
+}
+static inline int * Vec_IntLimit( Vec_Int_t * p )
+{
+    return p->pArray + p->nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntSize( Vec_Int_t * p )
+{
+    return p->nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntCap( Vec_Int_t * p )
+{
+    return p->nCap;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline double Vec_IntMemory( Vec_Int_t * p )
+{
+    return !p ? 0.0 : 1.0 * sizeof(int) * (size_t)p->nCap + sizeof(Vec_Int_t) ;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntEntry( Vec_Int_t * p, int i )
+{
+    assert( i >= 0 && i < p->nSize );
+    return p->pArray[i];
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int * Vec_IntEntryP( Vec_Int_t * p, int i )
+{
+    assert( i >= 0 && i < p->nSize );
+    return p->pArray + i;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntWriteEntry( Vec_Int_t * p, int i, int Entry )
+{
+    assert( i >= 0 && i < p->nSize );
+    p->pArray[i] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntAddToEntry( Vec_Int_t * p, int i, int Addition )
+{
+    assert( i >= 0 && i < p->nSize );
+    return p->pArray[i] += Addition;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntUpdateEntry( Vec_Int_t * p, int i, int Value )
+{
+    if ( Vec_IntEntry( p, i ) < Value )
+        Vec_IntWriteEntry( p, i, Value );
+}
+static inline void Vec_IntDowndateEntry( Vec_Int_t * p, int i, int Value )
+{
+    if ( Vec_IntEntry( p, i ) > Value )
+        Vec_IntWriteEntry( p, i, Value );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntEntryLast( Vec_Int_t * p )
+{
+    assert( p->nSize > 0 );
+    return p->pArray[p->nSize-1];
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Resizes the vector to the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntGrow( Vec_Int_t * p, int nCapMin )
+{
+    if ( p->nCap >= nCapMin )
+        return;
+    p->pArray = ABC_REALLOC( int, p->pArray, nCapMin ); 
+    assert( p->pArray );
+    p->nCap   = nCapMin;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Resizes the vector to the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntGrowResize( Vec_Int_t * p, int nCapMin )
+{
+    p->nSize  = nCapMin;
+    if ( p->nCap >= nCapMin )
+        return;
+    p->pArray = ABC_REALLOC( int, p->pArray, nCapMin ); 
+    assert( p->pArray );
+    p->nCap   = nCapMin;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Fills the vector with given number of entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntFill( Vec_Int_t * p, int nSize, int Fill )
+{
+    int i;
+    Vec_IntGrow( p, nSize );
+    for ( i = 0; i < nSize; i++ )
+        p->pArray[i] = Fill;
+    p->nSize = nSize;
+}
+static inline void Vec_IntFillTwo( Vec_Int_t * p, int nSize, int FillEven, int FillOdd )
+{
+    int i;
+    Vec_IntGrow( p, nSize );
+    for ( i = 0; i < nSize; i++ )
+        p->pArray[i] = (i & 1) ? FillOdd : FillEven;
+    p->nSize = nSize;
+}
+static inline void Vec_IntFillNatural( Vec_Int_t * p, int nSize )
+{
+    int i;
+    Vec_IntGrow( p, nSize );
+    for ( i = 0; i < nSize; i++ )
+        p->pArray[i] = i;
+    p->nSize = nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Fills the vector with given number of entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntFillExtra( Vec_Int_t * p, int nSize, int Fill )
+{
+    int i;
+    if ( nSize <= p->nSize )
+        return;
+    if ( nSize > 2 * p->nCap )
+        Vec_IntGrow( p, nSize );
+    else if ( nSize > p->nCap )
+        Vec_IntGrow( p, 2 * p->nCap );
+    for ( i = p->nSize; i < nSize; i++ )
+        p->pArray[i] = Fill;
+    p->nSize = nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the entry even if the place not exist.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntGetEntry( Vec_Int_t * p, int i )
+{
+    Vec_IntFillExtra( p, i + 1, 0 );
+    return Vec_IntEntry( p, i );
+}
+static inline int Vec_IntGetEntryFull( Vec_Int_t * p, int i )
+{
+    Vec_IntFillExtra( p, i + 1, -1 );
+    return Vec_IntEntry( p, i );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the entry even if the place not exist.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int * Vec_IntGetEntryP( Vec_Int_t * p, int i )
+{
+    Vec_IntFillExtra( p, i + 1, 0 );
+    return Vec_IntEntryP( p, i );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the entry even if the place does not exist.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntSetEntry( Vec_Int_t * p, int i, int Entry )
+{
+    Vec_IntFillExtra( p, i + 1, 0 );
+    Vec_IntWriteEntry( p, i, Entry );
+}
+static inline void Vec_IntSetEntryFull( Vec_Int_t * p, int i, int Entry )
+{
+    Vec_IntFillExtra( p, i + 1, -1 );
+    Vec_IntWriteEntry( p, i, Entry );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntShrink( Vec_Int_t * p, int nSizeNew )
+{
+    assert( p->nSize >= nSizeNew );
+    p->nSize = nSizeNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntClear( Vec_Int_t * p )
+{
+    p->nSize = 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntPush( Vec_Int_t * p, int Entry )
+{
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_IntGrow( p, 16 );
+        else
+            Vec_IntGrow( p, 2 * p->nCap );
+    }
+    p->pArray[p->nSize++] = Entry;
+}
+static inline void Vec_IntPushTwo( Vec_Int_t * p, int Entry1, int Entry2 )
+{
+    Vec_IntPush( p, Entry1 );
+    Vec_IntPush( p, Entry2 );
+}
+static inline void Vec_IntPushThree( Vec_Int_t * p, int Entry1, int Entry2, int Entry3 )
+{
+    Vec_IntPush( p, Entry1 );
+    Vec_IntPush( p, Entry2 );
+    Vec_IntPush( p, Entry3 );
+}
+static inline void Vec_IntPushFour( Vec_Int_t * p, int Entry1, int Entry2, int Entry3, int Entry4 )
+{
+    Vec_IntPush( p, Entry1 );
+    Vec_IntPush( p, Entry2 );
+    Vec_IntPush( p, Entry3 );
+    Vec_IntPush( p, Entry4 );
+}
+static inline void Vec_IntPushArray( Vec_Int_t * p, int * pEntries, int nEntries )
+{
+    int i;
+    for ( i = 0; i < nEntries; i++ )
+        Vec_IntPush( p, pEntries[i] );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntPushFirst( Vec_Int_t * p, int Entry )
+{
+    int i;
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_IntGrow( p, 16 );
+        else
+            Vec_IntGrow( p, 2 * p->nCap );
+    }
+    p->nSize++;
+    for ( i = p->nSize - 1; i >= 1; i-- )
+        p->pArray[i] = p->pArray[i-1];
+    p->pArray[0] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the entry while preserving the increasing order.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntPushOrder( Vec_Int_t * p, int Entry )
+{
+    int i;
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_IntGrow( p, 16 );
+        else
+            Vec_IntGrow( p, 2 * p->nCap );
+    }
+    p->nSize++;
+    for ( i = p->nSize-2; i >= 0; i-- )
+        if ( p->pArray[i] > Entry )
+            p->pArray[i+1] = p->pArray[i];
+        else
+            break;
+    p->pArray[i+1] = Entry;
+}
+static inline void Vec_IntPushOrderCost( Vec_Int_t * p, int Entry, Vec_Int_t * vCost )
+{
+    int i;
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_IntGrow( p, 16 );
+        else
+            Vec_IntGrow( p, 2 * p->nCap );
+    }
+    p->nSize++;
+    for ( i = p->nSize-2; i >= 0; i-- )
+        if ( Vec_IntEntry(vCost, p->pArray[i]) > Vec_IntEntry(vCost, Entry) )
+            p->pArray[i+1] = p->pArray[i];
+        else
+            break;
+    p->pArray[i+1] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the entry while preserving the increasing order.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntPushOrderReverse( Vec_Int_t * p, int Entry )
+{
+    int i;
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_IntGrow( p, 16 );
+        else
+            Vec_IntGrow( p, 2 * p->nCap );
+    }
+    p->nSize++;
+    for ( i = p->nSize-2; i >= 0; i-- )
+        if ( p->pArray[i] < Entry )
+            p->pArray[i+1] = p->pArray[i];
+        else
+            break;
+    p->pArray[i+1] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the entry while preserving the increasing order.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntPushUniqueOrder( Vec_Int_t * p, int Entry )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            return 1;
+    Vec_IntPushOrder( p, Entry );
+    return 0;
+}
+static inline int Vec_IntPushUniqueOrderCost( Vec_Int_t * p, int Entry, Vec_Int_t * vCost )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            return 1;
+    Vec_IntPushOrderCost( p, Entry, vCost );
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntPushUnique( Vec_Int_t * p, int Entry )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            return 1;
+    Vec_IntPush( p, Entry );
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the pointer to the next nWords entries in the vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline unsigned * Vec_IntFetch( Vec_Int_t * p, int nWords )
+{
+    if ( nWords == 0 )
+        return NULL;
+    assert( nWords > 0 );
+    p->nSize += nWords;
+    if ( p->nSize > p->nCap )
+    {
+//         Vec_IntGrow( p, 2 * p->nSize );
+        return NULL;
+    }
+    return ((unsigned *)p->pArray) + p->nSize - nWords;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the last entry and removes it from the list.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntPop( Vec_Int_t * p )
+{
+    assert( p->nSize > 0 );
+    return p->pArray[--p->nSize];
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Find entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntFind( Vec_Int_t * p, int Entry )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            return i;
+    return -1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntRemove( Vec_Int_t * p, int Entry )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            break;
+    if ( i == p->nSize )
+        return 0;
+    assert( i < p->nSize );
+    for ( i++; i < p->nSize; i++ )
+        p->pArray[i-1] = p->pArray[i];
+    p->nSize--;
+    return 1;
+}
+static inline int Vec_IntRemove1( Vec_Int_t * p, int Entry )
+{
+    int i;
+    for ( i = 1; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            break;
+    if ( i >= p->nSize )
+        return 0;
+    assert( i < p->nSize );
+    for ( i++; i < p->nSize; i++ )
+        p->pArray[i-1] = p->pArray[i];
+    p->nSize--;
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntDrop( Vec_Int_t * p, int i )
+{
+    int k;
+    assert( i >= 0 && i < Vec_IntSize(p) );
+    p->nSize--;
+    for ( k = i; k < p->nSize; k++ )
+        p->pArray[k] = p->pArray[k+1];
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Interts entry at the index iHere. Shifts other entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntInsert( Vec_Int_t * p, int iHere, int Entry )
+{
+    int i;
+    assert( iHere >= 0 && iHere <= p->nSize );
+    Vec_IntPush( p, 0 );
+    for ( i = p->nSize - 1; i > iHere; i-- )
+        p->pArray[i] = p->pArray[i-1];
+    p->pArray[i] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Find entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntFindMax( Vec_Int_t * p )
+{
+    int i, Best;
+    if ( p->nSize == 0 )
+        return 0;
+    Best = p->pArray[0];
+    for ( i = 1; i < p->nSize; i++ )
+        if ( Best < p->pArray[i] )
+            Best = p->pArray[i];
+    return Best;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Find entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntFindMin( Vec_Int_t * p )
+{
+    int i, Best;
+    if ( p->nSize == 0 )
+        return 0;
+    Best = p->pArray[0];
+    for ( i = 1; i < p->nSize; i++ )
+        if ( Best > p->pArray[i] )
+            Best = p->pArray[i];
+    return Best;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Reverses the order of entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntReverseOrder( Vec_Int_t * p )
+{
+    int i, Temp;
+    for ( i = 0; i < p->nSize/2; i++ )
+    {
+        Temp = p->pArray[i];
+        p->pArray[i] = p->pArray[p->nSize-1-i];
+        p->pArray[p->nSize-1-i] = Temp;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Removes odd entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntRemoveOdd( Vec_Int_t * p )
+{
+    int i;
+    assert( (p->nSize & 1) == 0 );
+    p->nSize >>= 1;
+    for ( i = 0; i < p->nSize; i++ )
+        p->pArray[i] = p->pArray[2*i];
+}
+static inline void Vec_IntRemoveEven( Vec_Int_t * p )
+{
+    int i;
+    assert( (p->nSize & 1) == 0 );
+    p->nSize >>= 1;
+    for ( i = 0; i < p->nSize; i++ )
+        p->pArray[i] = p->pArray[2*i+1];
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntInvert( Vec_Int_t * p, int Fill ) 
+{
+    int Entry, i;
+    Vec_Int_t * vRes = Vec_IntAlloc( 0 );
+    if ( Vec_IntSize(p) == 0 )
+        return vRes;
+    Vec_IntFill( vRes, Vec_IntFindMax(p) + 1, Fill );
+    Vec_IntForEachEntry( p, Entry, i )
+        if ( Entry != Fill )
+            Vec_IntWriteEntry( vRes, Entry, i );
+    return vRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntCondense( Vec_Int_t * p, int Fill ) 
+{
+    int Entry, i;
+    Vec_Int_t * vRes = Vec_IntAlloc( Vec_IntSize(p) );
+    Vec_IntForEachEntry( p, Entry, i )
+        if ( Entry != Fill )
+            Vec_IntPush( vRes, Entry );
+    return vRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntSum( Vec_Int_t * p ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += p->pArray[i];
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntCountEntry( Vec_Int_t * p, int Entry ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += (p->pArray[i] == Entry);
+    return Counter;
+}
+static inline int Vec_IntCountLarger( Vec_Int_t * p, int Entry ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += (p->pArray[i] > Entry);
+    return Counter;
+}
+static inline int Vec_IntCountSmaller( Vec_Int_t * p, int Entry ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += (p->pArray[i] < Entry);
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntCountPositive( Vec_Int_t * p ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += (p->pArray[i] > 0);
+    return Counter;
+}
+static inline int Vec_IntCountZero( Vec_Int_t * p ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += (p->pArray[i] == 0);
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Checks if two vectors are equal.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntEqual( Vec_Int_t * p1, Vec_Int_t * p2 ) 
+{
+    int i;
+    if ( p1->nSize != p2->nSize )
+        return 0;
+    for ( i = 0; i < p1->nSize; i++ )
+        if ( p1->pArray[i] != p2->pArray[i] )
+            return 0;
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Counts the number of common entries.]
+
+  Description [Assumes that the entries are non-negative integers that
+  are not very large, so inversion of the array can be performed.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntCountCommon( Vec_Int_t * p1, Vec_Int_t * p2 ) 
+{
+    Vec_Int_t * vTemp;
+    int Entry, i, Counter = 0;
+    if ( Vec_IntSize(p1) < Vec_IntSize(p2) )
+        vTemp = p1, p1 = p2, p2 = vTemp;
+    assert( Vec_IntSize(p1) >= Vec_IntSize(p2) );
+    vTemp = Vec_IntInvert( p2, -1 );
+    Vec_IntFillExtra( vTemp, Vec_IntFindMax(p1) + 1, -1 );
+    Vec_IntForEachEntry( p1, Entry, i )
+        if ( Vec_IntEntry(vTemp, Entry) >= 0 )
+            Counter++;
+    Vec_IntFree( vTemp );
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Comparison procedure for two integers.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Vec_IntSortCompare1( int * pp1, int * pp2 )
+{
+    // for some reason commenting out lines (as shown) led to crashing of the release version
+    if ( *pp1 < *pp2 )
+        return -1;
+    if ( *pp1 > *pp2 ) //
+        return 1;
+    return 0; //
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Comparison procedure for two integers.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Vec_IntSortCompare2( int * pp1, int * pp2 )
+{
+    // for some reason commenting out lines (as shown) led to crashing of the release version
+    if ( *pp1 > *pp2 )
+        return -1;
+    if ( *pp1 < *pp2 ) //
+        return 1;
+    return 0; //
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting the entries by their integer value.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntSort( Vec_Int_t * p, int fReverse )
+{
+    if ( fReverse ) 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(int), 
+                (int (*)(const void *, const void *)) Vec_IntSortCompare2 );
+    else
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(int), 
+                (int (*)(const void *, const void *)) Vec_IntSortCompare1 );
+}
+static inline void Vec_IntSortMulti( Vec_Int_t * p, int nMulti, int fReverse )
+{
+    assert( Vec_IntSize(p) % nMulti == 0 );
+    if ( fReverse ) 
+        qsort( (void *)p->pArray, (size_t)(p->nSize/nMulti), nMulti*sizeof(int), 
+                (int (*)(const void *, const void *)) Vec_IntSortCompare2 );
+    else
+        qsort( (void *)p->pArray, (size_t)(p->nSize/nMulti), nMulti*sizeof(int), 
+                (int (*)(const void *, const void *)) Vec_IntSortCompare1 );
+}
+static inline int Vec_IntIsSorted( Vec_Int_t * p, int fReverse )
+{
+    int i;
+    for ( i = 1; i < p->nSize; i++ )
+        if ( fReverse ? (p->pArray[i-1] < p->pArray[i]) : (p->pArray[i-1] > p->pArray[i]) )
+            return 0;
+    return 1;            
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Leaves only unique entries.]
+
+  Description [Returns the number of duplicated entried found.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntUniqify( Vec_Int_t * p )
+{
+    int i, k, RetValue;
+    if ( p->nSize < 2 )
+        return 0;
+    Vec_IntSort( p, 0 );
+    for ( i = k = 1; i < p->nSize; i++ )
+        if ( p->pArray[i] != p->pArray[i-1] )
+            p->pArray[k++] = p->pArray[i];
+    RetValue = p->nSize - k;
+    p->nSize = k;
+    return RetValue;
+}
+static inline int Vec_IntCountDuplicates( Vec_Int_t * p )
+{
+    int RetValue;
+    Vec_Int_t * pDup = Vec_IntDup( p );
+    Vec_IntUniqify( pDup );
+    RetValue = Vec_IntSize(p) - Vec_IntSize(pDup);
+    Vec_IntFree( pDup );
+    return RetValue;
+}
+static inline int Vec_IntCheckUniqueSmall( Vec_Int_t * p )
+{
+    int i, k;
+    for ( i = 0; i < p->nSize; i++ )
+        for ( k = i+1; k < p->nSize; k++ )
+            if ( p->pArray[i] == p->pArray[k] )
+                return 0;
+    return 1;
+}
+static inline int Vec_IntCountUnique( Vec_Int_t * p )
+{
+    int i, Count = 0, Max = Vec_IntFindMax(p);
+    unsigned char * pPres = ABC_CALLOC( unsigned char, Max+1 );
+    for ( i = 0; i < p->nSize; i++ )
+        if ( pPres[p->pArray[i]] == 0 )
+            pPres[p->pArray[i]] = 1, Count++;
+    ABC_FREE( pPres );
+    return Count;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Counts the number of unique pairs.]
+
+  Description []
+               
+  SideEffects [] 
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntUniqifyPairs( Vec_Int_t * p )
+{
+    int i, k, RetValue;
+    assert( p->nSize % 2 == 0 );
+    if ( p->nSize < 4 )
+        return 0;
+    Vec_IntSortMulti( p, 2, 0 );
+    for ( i = k = 1; i < p->nSize/2; i++ )
+        if ( p->pArray[2*i] != p->pArray[2*(i-1)] || p->pArray[2*i+1] != p->pArray[2*(i-1)+1] )
+        {
+            p->pArray[2*k]   = p->pArray[2*i];
+            p->pArray[2*k+1] = p->pArray[2*i+1];
+            k++;
+        }
+    RetValue = p->nSize/2 - k;
+    p->nSize = 2*k;
+    return RetValue;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Counts the number of unique entries.]
+
+  Description []
+               
+  SideEffects [] 
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline unsigned Vec_IntUniqueHashKeyDebug( unsigned char * pStr, int nChars, int TableMask )
+{
+    static unsigned s_BigPrimes[4] = {12582917, 25165843, 50331653, 100663319};
+    unsigned Key = 0; int c;
+    for ( c = 0; c < nChars; c++ )
+    {
+        Key += (unsigned)pStr[c] * s_BigPrimes[c & 3];
+        printf( "%d : ", c );
+        printf( "%3d  ", pStr[c] );
+        printf( "%12u ", Key );
+        printf( "%12u ", Key&TableMask );
+        printf( "\n" );
+    }
+    return Key;
+}
+
+static inline unsigned Vec_IntUniqueHashKey2( unsigned char * pStr, int nChars )
+{
+    static unsigned s_BigPrimes[4] = {12582917, 25165843, 50331653, 100663319};
+    unsigned Key = 0; int c;
+    for ( c = 0; c < nChars; c++ )
+        Key += (unsigned)pStr[c] * s_BigPrimes[c & 3];
+    return Key;
+}
+
+static inline unsigned Vec_IntUniqueHashKey( unsigned char * pStr, int nChars )
+{
+    static unsigned s_BigPrimes[16] = 
+    {
+        0x984b6ad9,0x18a6eed3,0x950353e2,0x6222f6eb,0xdfbedd47,0xef0f9023,0xac932a26,0x590eaf55,
+        0x97d0a034,0xdc36cd2e,0x22736b37,0xdc9066b0,0x2eb2f98b,0x5d9c7baf,0x85747c9e,0x8aca1055
+    };
+    static unsigned s_BigPrimes2[16] = 
+    {
+        0x8d8a5ebe,0x1e6a15dc,0x197d49db,0x5bab9c89,0x4b55dea7,0x55dede49,0x9a6a8080,0xe5e51035,
+        0xe148d658,0x8a17eb3b,0xe22e4b38,0xe5be2a9a,0xbe938cbb,0x3b981069,0x7f9c0c8e,0xf756df10
+    };
+    unsigned Key = 0; int c;
+    for ( c = 0; c < nChars; c++ )
+        Key += s_BigPrimes2[(2*c)&15]   * s_BigPrimes[(unsigned)pStr[c] & 15] +
+               s_BigPrimes2[(2*c+1)&15] * s_BigPrimes[(unsigned)pStr[c] >> 4];
+    return Key;
+}
+static inline int * Vec_IntUniqueLookup( Vec_Int_t * vData, int i, int nIntSize, int * pNexts, int * pStart )
+{
+    int * pData = Vec_IntEntryP( vData, i*nIntSize );
+    for ( ; *pStart != -1; pStart = pNexts + *pStart )
+        if ( !memcmp( pData, Vec_IntEntryP(vData, *pStart*nIntSize), sizeof(int) * (size_t)nIntSize ) )
+            return pStart;
+    return pStart;
+}
+static inline int Vec_IntUniqueCount( Vec_Int_t * vData, int nIntSize, Vec_Int_t ** pvMap )
+{
+    int nEntries  = Vec_IntSize(vData) / nIntSize;
+    int TableMask = (1 << Abc_Base2Log(nEntries)) - 1;
+    int * pTable  = ABC_FALLOC( int, TableMask+1 );
+    int * pNexts  = ABC_FALLOC( int, TableMask+1 );
+    int * pClass  = ABC_ALLOC( int, nEntries );
+    int i, Key, * pEnt, nUnique = 0;
+    assert( nEntries * nIntSize == Vec_IntSize(vData) );
+    for ( i = 0; i < nEntries; i++ )
+    {
+        pEnt = Vec_IntEntryP( vData, i*nIntSize );
+        Key  = TableMask & Vec_IntUniqueHashKey( (unsigned char *)pEnt, 4*nIntSize );
+        pEnt = Vec_IntUniqueLookup( vData, i, nIntSize, pNexts, pTable+Key );
+        if ( *pEnt == -1 )
+            *pEnt = i, nUnique++;
+        pClass[i] = *pEnt;
+    }
+//    Vec_IntUniqueProfile( vData, pTable, pNexts, TableMask, nIntSize );
+    ABC_FREE( pTable );
+    ABC_FREE( pNexts );
+    if ( pvMap )
+        *pvMap = Vec_IntAllocArray( pClass, nEntries );
+    else
+        ABC_FREE( pClass );
+    return nUnique;
+}
+static inline Vec_Int_t * Vec_IntUniqifyHash( Vec_Int_t * vData, int nIntSize )
+{
+    Vec_Int_t * vMap, * vUnique;
+    int i, Ent, nUnique = Vec_IntUniqueCount( vData, nIntSize, &vMap );
+    vUnique = Vec_IntAlloc( nUnique * nIntSize );
+    Vec_IntForEachEntry( vMap, Ent, i )
+    {
+        if ( Ent < i ) continue;
+        assert( Ent == i );
+        Vec_IntPushArray( vUnique, Vec_IntEntryP(vData, i*nIntSize), nIntSize );
+    }
+    assert( Vec_IntSize(vUnique) == nUnique * nIntSize );
+    Vec_IntFree( vMap );
+    return vUnique;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Comparison procedure for two integers.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntSortCompareUnsigned( unsigned * pp1, unsigned * pp2 )
+{
+    if ( *pp1 < *pp2 )
+        return -1;
+    if ( *pp1 > *pp2 )
+        return 1;
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting the entries by their integer value.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntSortUnsigned( Vec_Int_t * p )
+{
+    qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(int), 
+            (int (*)(const void *, const void *)) Vec_IntSortCompareUnsigned );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the number of common entries.]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntTwoCountCommon( Vec_Int_t * vArr1, Vec_Int_t * vArr2 )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    int Counter = 0;
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            pBeg1++, pBeg2++, Counter++;
+        else if ( *pBeg1 < *pBeg2 )
+            pBeg1++;
+        else 
+            pBeg2++;
+    }
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Collects common entries.]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntTwoFindCommon( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    Vec_IntClear( vArr );
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            Vec_IntPush( vArr, *pBeg1 ), pBeg1++, pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            pBeg1++;
+        else 
+            pBeg2++;
+    }
+    return Vec_IntSize(vArr);
+}
+static inline int Vec_IntTwoFindCommonReverse( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    Vec_IntClear( vArr );
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            Vec_IntPush( vArr, *pBeg1 ), pBeg1++, pBeg2++;
+        else if ( *pBeg1 > *pBeg2 )
+            pBeg1++;
+        else 
+            pBeg2++;
+    }
+    return Vec_IntSize(vArr);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Collects and removes common entries]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntTwoRemoveCommon( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    int * pBeg1New = vArr1->pArray;
+    int * pBeg2New = vArr2->pArray;
+    Vec_IntClear( vArr );
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            Vec_IntPush( vArr, *pBeg1 ), pBeg1++, pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            *pBeg1New++ = *pBeg1++;
+        else 
+            *pBeg2New++ = *pBeg2++;
+    }
+    while ( pBeg1 < pEnd1 )
+        *pBeg1New++ = *pBeg1++;
+    while ( pBeg2 < pEnd2 )
+        *pBeg2New++ = *pBeg2++;
+    Vec_IntShrink( vArr1, pBeg1New - vArr1->pArray );
+    Vec_IntShrink( vArr2, pBeg2New - vArr2->pArray );
+    return Vec_IntSize(vArr);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Removes entries of the second one from the first one.]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntTwoRemove( Vec_Int_t * vArr1, Vec_Int_t * vArr2 )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    int * pBeg1New = vArr1->pArray;
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            pBeg1++, pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            *pBeg1New++ = *pBeg1++;
+        else 
+            pBeg2++;
+    }
+    while ( pBeg1 < pEnd1 )
+        *pBeg1New++ = *pBeg1++;
+    Vec_IntShrink( vArr1, pBeg1New - vArr1->pArray );
+    return Vec_IntSize(vArr1);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the result of merging the two vectors.]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntTwoMerge2Int( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr )
+{
+    int * pBeg  = vArr->pArray;
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            *pBeg++ = *pBeg1++, pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            *pBeg++ = *pBeg1++;
+        else 
+            *pBeg++ = *pBeg2++;
+    }
+    while ( pBeg1 < pEnd1 )
+        *pBeg++ = *pBeg1++;
+    while ( pBeg2 < pEnd2 )
+        *pBeg++ = *pBeg2++;
+    vArr->nSize = pBeg - vArr->pArray;
+    assert( vArr->nSize <= vArr->nCap );
+    assert( vArr->nSize >= vArr1->nSize );
+    assert( vArr->nSize >= vArr2->nSize );
+}
+static inline Vec_Int_t * Vec_IntTwoMerge( Vec_Int_t * vArr1, Vec_Int_t * vArr2 )
+{
+    Vec_Int_t * vArr = Vec_IntAlloc( vArr1->nSize + vArr2->nSize ); 
+    Vec_IntTwoMerge2Int( vArr1, vArr2, vArr );
+    return vArr;
+}
+static inline void Vec_IntTwoMerge2( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr )
+{
+    Vec_IntGrow( vArr, Vec_IntSize(vArr1) + Vec_IntSize(vArr2) );
+    Vec_IntTwoMerge2Int( vArr1, vArr2, vArr );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the result of splitting of the two vectors.]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntTwoSplit( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr, Vec_Int_t * vArr1n, Vec_Int_t * vArr2n )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            Vec_IntPush( vArr, *pBeg1++ ), pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            Vec_IntPush( vArr1n, *pBeg1++ );
+        else 
+            Vec_IntPush( vArr2n, *pBeg2++ );
+    }
+    while ( pBeg1 < pEnd1 )
+        Vec_IntPush( vArr1n, *pBeg1++ );
+    while ( pBeg2 < pEnd2 )
+        Vec_IntPush( vArr2n, *pBeg2++ );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntSelectSort( int * pArray, int nSize )
+{
+    int temp, i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( pArray[j] < pArray[best_i] )
+                best_i = j;
+        temp = pArray[i]; 
+        pArray[i] = pArray[best_i]; 
+        pArray[best_i] = temp;
+    }
+}
+static inline void Vec_IntSelectSortReverse( int * pArray, int nSize )
+{
+    int temp, i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( pArray[j] > pArray[best_i] )
+                best_i = j;
+        temp = pArray[i]; 
+        pArray[i] = pArray[best_i]; 
+        pArray[best_i] = temp;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntSelectSortCost( int * pArray, int nSize, Vec_Int_t * vCosts )
+{
+    int i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( Vec_IntEntry(vCosts, pArray[j]) < Vec_IntEntry(vCosts, pArray[best_i]) )
+                best_i = j;
+        ABC_SWAP( int, pArray[i], pArray[best_i] );
+    }
+}
+static inline void Vec_IntSelectSortCostReverse( int * pArray, int nSize, Vec_Int_t * vCosts )
+{
+    int i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( Vec_IntEntry(vCosts, pArray[j]) > Vec_IntEntry(vCosts, pArray[best_i]) )
+                best_i = j;
+        ABC_SWAP( int, pArray[i], pArray[best_i] );
+    }
+}
+
+static inline void Vec_IntSelectSortCost2( int * pArray, int nSize, int * pCosts )
+{
+    int i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( pCosts[j] < pCosts[best_i] )
+                best_i = j;
+        ABC_SWAP( int, pArray[i], pArray[best_i] );
+        ABC_SWAP( int, pCosts[i], pCosts[best_i] );
+    }
+}
+static inline void Vec_IntSelectSortCost2Reverse( int * pArray, int nSize, int * pCosts )
+{
+    int i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( pCosts[j] > pCosts[best_i] )
+                best_i = j;
+        ABC_SWAP( int, pArray[i], pArray[best_i] );
+        ABC_SWAP( int, pCosts[i], pCosts[best_i] );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntPrint( Vec_Int_t * vVec )
+{
+    int i, Entry;
+    printf( "Vector has %d entries: {", Vec_IntSize(vVec) );
+    Vec_IntForEachEntry( vVec, Entry, i )
+        printf( " %d", Entry );
+    printf( " }\n" );
+}
+static inline void Vec_IntPrintBinary( Vec_Int_t * vVec )
+{
+    int i, Entry;
+    Vec_IntForEachEntry( vVec, Entry, i )
+        printf( "%d", (int)(Entry != 0) );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntCompareVec( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( p1 == NULL || p2 == NULL )
+        return (p1 != NULL) - (p2 != NULL);
+    if ( Vec_IntSize(p1) != Vec_IntSize(p2) )
+        return Vec_IntSize(p1) - Vec_IntSize(p2);
+    return memcmp( Vec_IntArray(p1), Vec_IntArray(p2), sizeof(int)*(size_t)Vec_IntSize(p1) );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Appends the contents of the second vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntAppend( Vec_Int_t * vVec1, Vec_Int_t * vVec2 )
+{
+    int Entry, i;
+    Vec_IntForEachEntry( vVec2, Entry, i )
+        Vec_IntPush( vVec1, Entry );
+}
+static inline void Vec_IntAppendSkip( Vec_Int_t * vVec1, Vec_Int_t * vVec2, int iVar )
+{
+    int Entry, i;
+    Vec_IntForEachEntry( vVec2, Entry, i )
+        if ( i != iVar )
+            Vec_IntPush( vVec1, Entry );
+}
+static inline void Vec_IntAppendMinus( Vec_Int_t * vVec1, Vec_Int_t * vVec2, int fMinus )
+{
+    int Entry, i;
+    Vec_IntClear( vVec1 );
+    Vec_IntForEachEntry( vVec2, Entry, i )
+        Vec_IntPush( vVec1, fMinus ? -Entry : Entry );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Remapping attributes after objects were duplicated.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntRemapArray( Vec_Int_t * vOld2New, Vec_Int_t * vOld, Vec_Int_t * vNew, int nNew )
+{
+    int iOld, iNew;
+    if ( Vec_IntSize(vOld) == 0 )
+        return;
+    Vec_IntFill( vNew, nNew, 0 );
+    Vec_IntForEachEntry( vOld2New, iNew, iOld )
+        if ( iNew > 0 && iNew < nNew && iOld < Vec_IntSize(vOld) && Vec_IntEntry(vOld, iOld) != 0 )
+            Vec_IntWriteEntry( vNew, iNew, Vec_IntEntry(vOld, iOld) );
+}
+
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
diff --git a/lib/abcesop/eabc/vecPtr.h b/lib/abcesop/eabc/vecPtr.h
new file mode 100644
index 0000000..9093901
--- /dev/null
+++ b/lib/abcesop/eabc/vecPtr.h
@@ -0,0 +1,1170 @@
+/**CFile****************************************************************
+
+  FileName    [vecPtr.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Resizable arrays.]
+
+  Synopsis    [Resizable arrays of generic pointers.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: vecPtr.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+ 
+#pragma once
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include <stdio.h>
+
+namespace abc::exorcism {
+
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct Vec_Ptr_t_       Vec_Ptr_t;
+struct Vec_Ptr_t_ 
+{
+    int              nCap;
+    int              nSize;
+    void **          pArray;
+};
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+// iterators through entries
+#define Vec_PtrForEachEntry( Type, vVec, pEntry, i )                                               \
+    for ( i = 0; (i < Vec_PtrSize(vVec)) && (((pEntry) = (Type)Vec_PtrEntry(vVec, i)), 1); i++ )
+#define Vec_PtrForEachEntryStart( Type, vVec, pEntry, i, Start )                                   \
+    for ( i = Start; (i < Vec_PtrSize(vVec)) && (((pEntry) = (Type)Vec_PtrEntry(vVec, i)), 1); i++ )
+#define Vec_PtrForEachEntryStop( Type, vVec, pEntry, i, Stop )                                     \
+    for ( i = 0; (i < Stop) && (((pEntry) = (Type)Vec_PtrEntry(vVec, i)), 1); i++ )
+#define Vec_PtrForEachEntryStartStop( Type, vVec, pEntry, i, Start, Stop )                         \
+    for ( i = Start; (i < Stop) && (((pEntry) = (Type)Vec_PtrEntry(vVec, i)), 1); i++ )
+#define Vec_PtrForEachEntryReverse( Type, vVec, pEntry, i )                                        \
+    for ( i = Vec_PtrSize(vVec) - 1; (i >= 0) && (((pEntry) = (Type)Vec_PtrEntry(vVec, i)), 1); i-- )
+#define Vec_PtrForEachEntryTwo( Type1, vVec1, Type2, vVec2, pEntry1, pEntry2, i )                  \
+    for ( i = 0; (i < Vec_PtrSize(vVec1)) && (((pEntry1) = (Type1)Vec_PtrEntry(vVec1, i)), 1) && (((pEntry2) = (Type2)Vec_PtrEntry(vVec2, i)), 1); i++ )
+#define Vec_PtrForEachEntryDouble( Type1, Type2, vVec, Entry1, Entry2, i )                                \
+    for ( i = 0; (i+1 < Vec_PtrSize(vVec)) && (((Entry1) = (Type1)Vec_PtrEntry(vVec, i)), 1) && (((Entry2) = (Type2)Vec_PtrEntry(vVec, i+1)), 1); i += 2 )
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates a vector with the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Ptr_t * Vec_PtrAlloc( int nCap )
+{
+    Vec_Ptr_t * p;
+    p = ABC_ALLOC( Vec_Ptr_t, 1 );
+    if ( nCap > 0 && nCap < 8 )
+        nCap = 8;
+    p->nSize  = 0;
+    p->nCap   = nCap;
+    p->pArray = p->nCap? ABC_ALLOC( void *, p->nCap ) : NULL;
+    return p;
+}
+static inline Vec_Ptr_t * Vec_PtrAllocExact( int nCap )
+{
+    Vec_Ptr_t * p;
+    assert( nCap >= 0 );
+    p = ABC_ALLOC( Vec_Ptr_t, 1 );
+    p->nSize  = 0;
+    p->nCap   = nCap;
+    p->pArray = p->nCap? ABC_ALLOC( void *, p->nCap ) : NULL;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates a vector with the given size and cleans it.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Ptr_t * Vec_PtrStart( int nSize )
+{
+    Vec_Ptr_t * p;
+    p = Vec_PtrAlloc( nSize );
+    p->nSize = nSize;
+    memset( p->pArray, 0, sizeof(void *) * (size_t)nSize );
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Creates the vector from an integer array of the given size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Ptr_t * Vec_PtrAllocArray( void ** pArray, int nSize )
+{
+    Vec_Ptr_t * p;
+    p = ABC_ALLOC( Vec_Ptr_t, 1 );
+    p->nSize  = nSize;
+    p->nCap   = nSize;
+    p->pArray = pArray;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Creates the vector from an integer array of the given size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Ptr_t * Vec_PtrAllocArrayCopy( void ** pArray, int nSize )
+{
+    Vec_Ptr_t * p;
+    p = ABC_ALLOC( Vec_Ptr_t, 1 );
+    p->nSize  = nSize;
+    p->nCap   = nSize;
+    p->pArray = ABC_ALLOC( void *, nSize );
+    memcpy( p->pArray, pArray, sizeof(void *) * (size_t)nSize );
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Duplicates the integer array.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Ptr_t * Vec_PtrDup( Vec_Ptr_t * pVec )
+{
+    Vec_Ptr_t * p;
+    p = ABC_ALLOC( Vec_Ptr_t, 1 );
+    p->nSize  = pVec->nSize;
+    p->nCap   = pVec->nCap;
+    p->pArray = p->nCap? ABC_ALLOC( void *, p->nCap ) : NULL;
+    memcpy( p->pArray, pVec->pArray, sizeof(void *) * (size_t)pVec->nSize );
+    return p;
+}
+static inline Vec_Ptr_t * Vec_PtrDupStr( Vec_Ptr_t * pVec )
+{
+    int i;
+    Vec_Ptr_t * p = Vec_PtrDup( pVec );
+    for ( i = 0; i < p->nSize; i++ )
+        p->pArray[i] = Abc_UtilStrsav( (char *)p->pArray[i] );
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Transfers the array into another vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Ptr_t * Vec_PtrDupArray( Vec_Ptr_t * pVec )
+{
+    Vec_Ptr_t * p;
+    p = ABC_ALLOC( Vec_Ptr_t, 1 );
+    p->nSize  = pVec->nSize;
+    p->nCap   = pVec->nCap;
+    p->pArray = pVec->pArray;
+    pVec->nSize  = 0;
+    pVec->nCap   = 0;
+    pVec->pArray = NULL;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Frees the vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrZero( Vec_Ptr_t * p )
+{
+    p->pArray = NULL;
+    p->nSize = 0;
+    p->nCap = 0;
+}
+static inline void Vec_PtrErase( Vec_Ptr_t * p )
+{
+    ABC_FREE( p->pArray );
+    p->nSize = 0;
+    p->nCap = 0;
+}
+static inline void Vec_PtrFree( Vec_Ptr_t * p )
+{
+    ABC_FREE( p->pArray );
+    ABC_FREE( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrFreeP( Vec_Ptr_t ** p )
+{
+    if ( *p == NULL )
+        return;
+    ABC_FREE( (*p)->pArray );
+    ABC_FREE( (*p) );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void ** Vec_PtrReleaseArray( Vec_Ptr_t * p )
+{
+    void ** pArray = p->pArray;
+    p->nCap = 0;
+    p->nSize = 0;
+    p->pArray = NULL;
+    return pArray;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void ** Vec_PtrArray( Vec_Ptr_t * p )
+{
+    return p->pArray;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_PtrSize( Vec_Ptr_t * p )
+{
+    return p->nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_PtrCap( Vec_Ptr_t * p )
+{
+    return p->nCap;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline double Vec_PtrMemory( Vec_Ptr_t * p )
+{
+    return !p ? 0.0 : 1.0 * sizeof(void *) * (size_t)p->nCap + sizeof(Vec_Ptr_t);
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_PtrCountZero( Vec_Ptr_t * p ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += (p->pArray[i] == NULL);
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void * Vec_PtrEntry( Vec_Ptr_t * p, int i )
+{
+    assert( i >= 0 && i < p->nSize );
+    return p->pArray[i];
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void ** Vec_PtrEntryP( Vec_Ptr_t * p, int i )
+{
+    assert( i >= 0 && i < p->nSize );
+    return p->pArray + i;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrWriteEntry( Vec_Ptr_t * p, int i, void * Entry )
+{
+    assert( i >= 0 && i < p->nSize );
+    p->pArray[i] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void * Vec_PtrEntryLast( Vec_Ptr_t * p )
+{
+    assert( p->nSize > 0 );
+    return p->pArray[p->nSize-1];
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Resizes the vector to the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrGrow( Vec_Ptr_t * p, int nCapMin )
+{
+    if ( p->nCap >= nCapMin )
+        return;
+    p->pArray = ABC_REALLOC( void *, p->pArray, nCapMin ); 
+    p->nCap   = nCapMin;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Fills the vector with given number of entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrFill( Vec_Ptr_t * p, int nSize, void * Entry )
+{
+    int i;
+    Vec_PtrGrow( p, nSize );
+    for ( i = 0; i < nSize; i++ )
+        p->pArray[i] = Entry;
+    p->nSize = nSize;
+}
+static inline void Vec_PtrFillTwo( Vec_Ptr_t * p, int nSize, void * EntryEven, void * EntryOdd )
+{
+    int i;
+    Vec_PtrGrow( p, nSize );
+    for ( i = 0; i < nSize; i++ )
+        p->pArray[i] = (i & 1) ? EntryOdd : EntryEven;
+    p->nSize = nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Fills the vector with given number of entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrFillExtra( Vec_Ptr_t * p, int nSize, void * Fill )
+{
+    int i;
+    if ( nSize <= p->nSize )
+        return;
+    if ( nSize > 2 * p->nCap )
+        Vec_PtrGrow( p, nSize );
+    else if ( nSize > p->nCap )
+        Vec_PtrGrow( p, 2 * p->nCap );
+    for ( i = p->nSize; i < nSize; i++ )
+        p->pArray[i] = Fill;
+    p->nSize = nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the entry even if the place not exist.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void * Vec_PtrGetEntry( Vec_Ptr_t * p, int i )
+{
+    Vec_PtrFillExtra( p, i + 1, NULL );
+    return Vec_PtrEntry( p, i );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the entry even if the place does not exist.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrSetEntry( Vec_Ptr_t * p, int i, void * Entry )
+{
+    Vec_PtrFillExtra( p, i + 1, NULL );
+    Vec_PtrWriteEntry( p, i, Entry );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrShrink( Vec_Ptr_t * p, int nSizeNew )
+{
+    assert( p->nSize >= nSizeNew );
+    p->nSize = nSizeNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrClear( Vec_Ptr_t * p )
+{
+    p->nSize = 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Deallocates array of memory pointers.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrFreeData( Vec_Ptr_t * p )
+{
+    void * pTemp; int i;
+    if ( p == NULL ) return;
+    Vec_PtrForEachEntry( void *, p, pTemp, i )
+        if ( pTemp != (void *)(ABC_PTRINT_T)1 && pTemp != (void *)(ABC_PTRINT_T)2 )
+            ABC_FREE( pTemp );
+}
+static inline void Vec_PtrFreeFree( Vec_Ptr_t * p )
+{
+    if ( p == NULL ) return;
+    Vec_PtrFreeData( p );
+    Vec_PtrFree( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Copies the interger array.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrCopy( Vec_Ptr_t * pDest, Vec_Ptr_t * pSour )
+{
+    pDest->nSize = 0;
+    Vec_PtrGrow( pDest, pSour->nSize );
+    memcpy( pDest->pArray, pSour->pArray, sizeof(void *) * (size_t)pSour->nSize );
+    pDest->nSize = pSour->nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrPush( Vec_Ptr_t * p, void * Entry )
+{
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_PtrGrow( p, 16 );
+        else
+            Vec_PtrGrow( p, 2 * p->nCap );
+    }
+    p->pArray[p->nSize++] = Entry;
+}
+static inline void Vec_PtrPushTwo( Vec_Ptr_t * p, void * Entry1, void * Entry2 )
+{
+    Vec_PtrPush( p, Entry1 );
+    Vec_PtrPush( p, Entry2 );
+}
+static inline void Vec_PtrAppend( Vec_Ptr_t * vVec1, Vec_Ptr_t * vVec2 )
+{
+    void * Entry; int i;
+    Vec_PtrForEachEntry( void *, vVec2, Entry, i )
+        Vec_PtrPush( vVec1, Entry );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrPushFirst( Vec_Ptr_t * p, void * Entry )
+{
+    int i;
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_PtrGrow( p, 16 );
+        else
+            Vec_PtrGrow( p, 2 * p->nCap );
+    }
+    p->nSize++;
+    for ( i = p->nSize - 1; i >= 1; i-- )
+        p->pArray[i] = p->pArray[i-1];
+    p->pArray[0] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_PtrPushUnique( Vec_Ptr_t * p, void * Entry )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            return 1;
+    Vec_PtrPush( p, Entry );
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the last entry and removes it from the list.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void * Vec_PtrPop( Vec_Ptr_t * p )
+{
+    assert( p->nSize > 0 );
+    return p->pArray[--p->nSize];
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Find entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_PtrFind( Vec_Ptr_t * p, void * Entry )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            return i;
+    return -1;
+}
+static inline int Vec_PtrFindStr( Vec_Ptr_t * p, char * Entry )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] && !strcmp((char *)p->pArray[i], Entry) )
+            return i;
+    return -1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrRemove( Vec_Ptr_t * p, void * Entry )
+{
+    int i;
+    // delete assuming that it is closer to the end
+    for ( i = p->nSize - 1; i >= 0; i-- )
+        if ( p->pArray[i] == Entry )
+            break;
+    assert( i >= 0 );
+/*
+    // delete assuming that it is closer to the beginning
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            break;
+    assert( i < p->nSize );
+*/
+    for ( i++; i < p->nSize; i++ )
+        p->pArray[i-1] = p->pArray[i];
+    p->nSize--;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrDrop( Vec_Ptr_t * p, int i )
+{
+    int k;
+    assert( i >= 0 && i < Vec_PtrSize(p) );
+    p->nSize--;
+    for ( k = i; k < p->nSize; k++ )
+        p->pArray[k] = p->pArray[k+1];
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Interts entry at the index iHere. Shifts other entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrInsert( Vec_Ptr_t * p, int iHere, void * Entry )
+{
+    int i;
+    assert( iHere >= 0 && iHere < p->nSize );
+    Vec_PtrPush( p, 0 );
+    for ( i = p->nSize - 1; i > iHere; i-- )
+        p->pArray[i] = p->pArray[i-1];
+    p->pArray[i] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Moves the first nItems to the end.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrReorder( Vec_Ptr_t * p, int nItems )
+{
+    assert( nItems < p->nSize );
+    Vec_PtrGrow( p, nItems + p->nSize );
+    memmove( (char **)p->pArray + p->nSize, p->pArray, (size_t)nItems * sizeof(void*) );
+    memmove( p->pArray, (char **)p->pArray + nItems, (size_t)p->nSize * sizeof(void*) );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Reverses the order of entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrReverseOrder( Vec_Ptr_t * p )
+{
+    void * Temp;
+    int i;
+    for ( i = 0; i < p->nSize/2; i++ )
+    {
+        Temp = p->pArray[i];
+        p->pArray[i] = p->pArray[p->nSize-1-i];
+        p->pArray[p->nSize-1-i] = Temp;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Checks if two vectors are equal.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_PtrEqual( Vec_Ptr_t * p1, Vec_Ptr_t * p2 ) 
+{
+    int i;
+    if ( p1->nSize != p2->nSize )
+        return 0;
+    for ( i = 0; i < p1->nSize; i++ )
+        if ( p1->pArray[i] != p2->pArray[i] )
+            return 0;
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Comparison procedure for two integers.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Vec_PtrSortComparePtr( void ** pp1, void ** pp2 )
+{
+    if ( *pp1 < *pp2 )
+        return -1;
+    if ( *pp1 > *pp2 ) 
+        return 1;
+    return 0; 
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting the entries by their integer value.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static void Vec_PtrSort( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)() ) ___unused;
+static void Vec_PtrSort( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)() )
+{
+    if ( p->nSize < 2 )
+        return;
+    if ( Vec_PtrSortCompare == NULL )
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(void *), 
+                (int (*)(const void *, const void *)) Vec_PtrSortComparePtr );
+    else
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(void *), 
+                (int (*)(const void *, const void *)) Vec_PtrSortCompare );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting the entries by their integer value.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static void Vec_PtrUniqify( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)() ) ___unused;
+static void Vec_PtrUniqify( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)() )
+{
+    int i, k;
+    if ( p->nSize < 2 )
+        return;
+    Vec_PtrSort( p, Vec_PtrSortCompare );
+    for ( i = k = 1; i < p->nSize; i++ )
+        if ( p->pArray[i] != p->pArray[i-1] )
+            p->pArray[k++] = p->pArray[i];
+    p->nSize = k;
+}
+static void Vec_PtrUniqify2( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)(void**, void**), void (*Vec_PtrObjFree)(void*), Vec_Int_t * vCounts ) ___unused;
+static void Vec_PtrUniqify2( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)(void**, void**), void (*Vec_PtrObjFree)(void*), Vec_Int_t * vCounts )
+{
+    int i, k;
+    if ( vCounts )
+        Vec_IntFill( vCounts, 1, 1 );
+    if ( p->nSize < 2 )
+        return;
+    Vec_PtrSort( p, (int (*)())Vec_PtrSortCompare );
+    for ( i = k = 1; i < p->nSize; i++ )
+        if ( Vec_PtrSortCompare(p->pArray+i, p->pArray+k-1) != 0 )
+        {
+            p->pArray[k++] = p->pArray[i];
+            if ( vCounts )
+                Vec_IntPush( vCounts, 1 );
+        }
+        else 
+        {
+            if ( Vec_PtrObjFree )
+                Vec_PtrObjFree( p->pArray[i] );
+            if ( vCounts )
+                Vec_IntAddToEntry( vCounts, Vec_IntSize(vCounts)-1, 1 );
+        }
+    p->nSize = k;
+    assert( vCounts == NULL || Vec_IntSize(vCounts) == Vec_PtrSize(p) );
+}
+
+
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates the array of simulation info.]
+
+  Description [Allocates the array containing given number of entries, 
+  each of which contains given number of unsigned words of simulation data.
+  The resulting array can be freed using regular procedure Vec_PtrFree().
+  It is the responsibility of the user to ensure this array is never grown.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Ptr_t * Vec_PtrAllocSimInfo( int nEntries, int nWords )
+{
+    void ** pMemory;
+    unsigned * pInfo;
+    int i;
+    pMemory = (void **)ABC_ALLOC( char, (sizeof(void *) + sizeof(unsigned) * (size_t)nWords) * nEntries );
+    pInfo = (unsigned *)(pMemory + nEntries);
+    for ( i = 0; i < nEntries; i++ )
+        pMemory[i] = pInfo + i * nWords;
+    return Vec_PtrAllocArray( pMemory, nEntries );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Cleans simulation info of each entry beginning with iWord.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_PtrReadWordsSimInfo( Vec_Ptr_t * p )
+{
+    return (unsigned *)Vec_PtrEntry(p,1) - (unsigned *)Vec_PtrEntry(p,0);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Cleans simulation info of each entry beginning with iWord.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrCleanSimInfo( Vec_Ptr_t * vInfo, int iWord, int nWords )
+{
+    int i;
+    for ( i = 0; i < vInfo->nSize; i++ )
+        memset( (char*)Vec_PtrEntry(vInfo,i) + 4*iWord, 0, (size_t)(4*(nWords-iWord)) );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Cleans simulation info of each entry beginning with iWord.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrFillSimInfo( Vec_Ptr_t * vInfo, int iWord, int nWords )
+{
+    int i;
+    for ( i = 0; i < vInfo->nSize; i++ )
+        memset( (char*)Vec_PtrEntry(vInfo,i) + 4*iWord, 0xFF, (size_t)(4*(nWords-iWord)) );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Resizes the array of simulation info.]
+
+  Description [Doubles the number of objects for which siminfo is allocated.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrDoubleSimInfo( Vec_Ptr_t * vInfo )
+{
+    Vec_Ptr_t * vInfoNew;
+    int nWords;
+    assert( Vec_PtrSize(vInfo) > 1 );
+    // get the new array
+    nWords = (unsigned *)Vec_PtrEntry(vInfo,1) - (unsigned *)Vec_PtrEntry(vInfo,0);
+    vInfoNew = Vec_PtrAllocSimInfo( 2*Vec_PtrSize(vInfo), nWords );
+    // copy the simulation info
+    memcpy( Vec_PtrEntry(vInfoNew,0), Vec_PtrEntry(vInfo,0), (size_t)(Vec_PtrSize(vInfo) * nWords * 4) );
+    // replace the array
+    ABC_FREE( vInfo->pArray );
+    vInfo->pArray = vInfoNew->pArray;
+    vInfo->nSize *= 2;
+    vInfo->nCap *= 2;
+    // free the old array
+    vInfoNew->pArray = NULL;
+    ABC_FREE( vInfoNew );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Resizes the array of simulation info.]
+
+  Description [Doubles the number of simulation patterns stored for each object.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_PtrReallocSimInfo( Vec_Ptr_t * vInfo )
+{
+    Vec_Ptr_t * vInfoNew;
+    int nWords, i;
+    assert( Vec_PtrSize(vInfo) > 1 );
+    // get the new array
+    nWords = (unsigned *)Vec_PtrEntry(vInfo,1) - (unsigned *)Vec_PtrEntry(vInfo,0);
+    vInfoNew = Vec_PtrAllocSimInfo( Vec_PtrSize(vInfo), 2*nWords );
+    // copy the simulation info
+    for ( i = 0; i < vInfo->nSize; i++ )
+        memcpy( Vec_PtrEntry(vInfoNew,i), Vec_PtrEntry(vInfo,i), (size_t)(nWords * 4) );
+    // replace the array
+    ABC_FREE( vInfo->pArray );
+    vInfo->pArray = vInfoNew->pArray;
+    // free the old array
+    vInfoNew->pArray = NULL;
+    ABC_FREE( vInfoNew );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates the array of truth tables for the given number of vars.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Ptr_t * Vec_PtrAllocTruthTables( int nVars )
+{
+    Vec_Ptr_t * p;
+    unsigned Masks[5] = { 0xAAAAAAAA, 0xCCCCCCCC, 0xF0F0F0F0, 0xFF00FF00, 0xFFFF0000 };
+    unsigned * pTruth;
+    int i, k, nWords;
+    nWords = (nVars <= 5 ? 1 : (1 << (nVars - 5)));
+    p = Vec_PtrAllocSimInfo( nVars, nWords );
+    for ( i = 0; i < nVars; i++ )
+    {
+        pTruth = (unsigned *)p->pArray[i];
+        if ( i < 5 )
+        {
+            for ( k = 0; k < nWords; k++ )
+                pTruth[k] = Masks[i];
+        }
+        else
+        {
+            for ( k = 0; k < nWords; k++ )
+                if ( k & (1 << (i-5)) )
+                    pTruth[k] = ~(unsigned)0;
+                else
+                    pTruth[k] = 0;
+        }
+    }
+    return p;
+}
+
+
+
+}
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
diff --git a/lib/abcesop/eabc/vecWec.h b/lib/abcesop/eabc/vecWec.h
new file mode 100644
index 0000000..e630477
--- /dev/null
+++ b/lib/abcesop/eabc/vecWec.h
@@ -0,0 +1,739 @@
+/**CFile****************************************************************
+
+  FileName    [vecWec.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Resizable arrays.]
+
+  Synopsis    [Resizable vector of resizable vectors.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: vecWec.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#pragma once
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include <stdio.h>
+
+namespace abc::exorcism {
+
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct Vec_Wec_t_       Vec_Wec_t;
+struct Vec_Wec_t_ 
+{
+    int              nCap;
+    int              nSize;
+    Vec_Int_t *      pArray;
+};
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+// iterators through levels 
+#define Vec_WecForEachLevel( vGlob, vVec, i )                                              \
+    for ( i = 0; (i < Vec_WecSize(vGlob)) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ )
+#define Vec_WecForEachLevelVec( vLevels, vGlob, vVec, i )                                  \
+    for ( i = 0; (i < Vec_IntSize(vLevels)) && (((vVec) = Vec_WecEntry(vGlob, Vec_IntEntry(vLevels, i))), 1); i++ )
+#define Vec_WecForEachLevelStart( vGlob, vVec, i, LevelStart )                             \
+    for ( i = LevelStart; (i < Vec_WecSize(vGlob)) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ )
+#define Vec_WecForEachLevelStop( vGlob, vVec, i, LevelStop )                               \
+    for ( i = 0; (i < LevelStop) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ )
+#define Vec_WecForEachLevelStartStop( vGlob, vVec, i, LevelStart, LevelStop )              \
+    for ( i = LevelStart; (i < LevelStop) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ )
+#define Vec_WecForEachLevelReverse( vGlob, vVec, i )                                       \
+    for ( i = Vec_WecSize(vGlob)-1; (i >= 0) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i-- )
+#define Vec_WecForEachLevelReverseStartStop( vGlob, vVec, i, LevelStart, LevelStop )       \
+    for ( i = LevelStart-1; (i >= LevelStop) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i-- )
+#define Vec_WecForEachLevelTwo( vGlob1, vGlob2, vVec1, vVec2, i )                          \
+    for ( i = 0; (i < Vec_WecSize(vGlob1)) && (((vVec1) = Vec_WecEntry(vGlob1, i)), 1) && (((vVec2) = Vec_WecEntry(vGlob2, i)), 1); i++ )
+#define Vec_WecForEachLevelDouble( vGlob, vVec1, vVec2, i )                                \
+    for ( i = 0; (i < Vec_WecSize(vGlob)) && (((vVec1) = Vec_WecEntry(vGlob, i)), 1) && (((vVec2) = Vec_WecEntry(vGlob, i+1)), 1); i += 2 )
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates a vector with the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Wec_t * Vec_WecAlloc( int nCap )
+{
+    Vec_Wec_t * p;
+    p = ABC_ALLOC( Vec_Wec_t, 1 );
+    if ( nCap > 0 && nCap < 8 )
+        nCap = 8;
+    p->nSize  = 0;
+    p->nCap   = nCap;
+    p->pArray = p->nCap? ABC_CALLOC( Vec_Int_t, p->nCap ) : NULL;
+    return p;
+}
+static inline Vec_Wec_t * Vec_WecAllocExact( int nCap )
+{
+    Vec_Wec_t * p;
+    assert( nCap >= 0 );
+    p = ABC_ALLOC( Vec_Wec_t, 1 );
+    p->nSize  = 0;
+    p->nCap   = nCap;
+    p->pArray = p->nCap? ABC_CALLOC( Vec_Int_t, p->nCap ) : NULL;
+    return p;
+}
+static inline Vec_Wec_t * Vec_WecStart( int nSize )
+{
+    Vec_Wec_t * p;
+    p = Vec_WecAlloc( nSize );
+    p->nSize = nSize;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Resizes the vector to the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecGrow( Vec_Wec_t * p, int nCapMin )
+{
+    if ( p->nCap >= nCapMin )
+        return;
+    p->pArray = ABC_REALLOC( Vec_Int_t, p->pArray, nCapMin ); 
+    memset( p->pArray + p->nCap, 0, sizeof(Vec_Int_t) * (size_t)(nCapMin - p->nCap) );
+    p->nCap   = nCapMin;
+}
+static inline void Vec_WecInit( Vec_Wec_t * p, int nSize )
+{
+    Vec_WecGrow( p, nSize );
+    p->nSize = nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_WecEntry( Vec_Wec_t * p, int i )
+{
+    assert( i >= 0 && i < p->nSize );
+    return p->pArray + i;
+}
+static inline Vec_Int_t * Vec_WecEntryLast( Vec_Wec_t * p )
+{
+    assert( p->nSize > 0 );
+    return p->pArray + p->nSize - 1;
+}
+static inline int Vec_WecEntryEntry( Vec_Wec_t * p, int i, int k )
+{
+    return Vec_IntEntry( Vec_WecEntry(p, i), k );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_WecArray( Vec_Wec_t * p )
+{
+    return p->pArray;
+}
+static inline int Vec_WecLevelId( Vec_Wec_t * p, Vec_Int_t * vLevel )
+{
+    assert( p->pArray <= vLevel && vLevel < p->pArray + p->nSize );
+    return vLevel - p->pArray;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_WecCap( Vec_Wec_t * p )
+{
+    return p->nCap;
+}
+static inline int Vec_WecSize( Vec_Wec_t * p )
+{
+    return p->nSize;
+}
+static inline int Vec_WecLevelSize( Vec_Wec_t * p, int i )
+{
+    assert( i >= 0 && i < p->nSize );
+    return Vec_IntSize( p->pArray + i );
+}
+static inline int Vec_WecSizeSize( Vec_Wec_t * p )
+{
+    Vec_Int_t * vVec;
+    int i, Counter = 0;
+    Vec_WecForEachLevel( p, vVec, i )
+        Counter += Vec_IntSize(vVec);
+    return Counter;
+}
+static inline int Vec_WecSizeUsed( Vec_Wec_t * p )
+{
+    Vec_Int_t * vVec;
+    int i, Counter = 0;
+    Vec_WecForEachLevel( p, vVec, i )
+        Counter += (int)(Vec_IntSize(vVec) > 0);
+    return Counter;
+}
+static inline int Vec_WecSizeUsedLimits( Vec_Wec_t * p, int iStart, int iStop )
+{
+    Vec_Int_t * vVec;
+    int i, Counter = 0;
+    Vec_WecForEachLevelStartStop( p, vVec, i, iStart, iStop )
+        Counter += (int)(Vec_IntSize(vVec) > 0);
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecShrink( Vec_Wec_t * p, int nSizeNew )
+{
+    Vec_Int_t * vVec; int i;
+    Vec_WecForEachLevelStart( p, vVec, i, nSizeNew )
+        Vec_IntShrink( vVec, 0 );
+    assert( p->nSize >= nSizeNew );
+    p->nSize = nSizeNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecClear( Vec_Wec_t * p )
+{
+    Vec_Int_t * vVec;
+    int i;
+    Vec_WecForEachLevel( p, vVec, i )
+        Vec_IntClear( vVec );
+    p->nSize = 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecPush( Vec_Wec_t * p, int Level, int Entry )
+{
+    if ( p->nSize < Level + 1 )
+    {
+        Vec_WecGrow( p, Abc_MaxInt(2*p->nSize, Level + 1) );
+        p->nSize = Level + 1;
+    }
+    Vec_IntPush( Vec_WecEntry(p, Level), Entry );
+}
+static inline Vec_Int_t * Vec_WecPushLevel( Vec_Wec_t * p )
+{
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_WecGrow( p, 16 );
+        else
+            Vec_WecGrow( p, 2 * p->nCap );
+    }
+    ++p->nSize;
+    return Vec_WecEntryLast( p );
+}
+static inline Vec_Int_t * Vec_WecInsertLevel( Vec_Wec_t * p, int i )
+{
+    Vec_Int_t * pTemp;
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_WecGrow( p, 16 );
+        else
+            Vec_WecGrow( p, 2 * p->nCap );
+    }
+    ++p->nSize;
+    assert( i >= 0 && i < p->nSize );
+    for ( pTemp = p->pArray + p->nSize - 2; pTemp >= p->pArray + i; pTemp-- )
+        pTemp[1] = pTemp[0];
+    Vec_IntZero( p->pArray + i );
+    return p->pArray + i;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline double Vec_WecMemory( Vec_Wec_t * p )
+{
+    int i;
+    double Mem;
+    if ( p == NULL )  return 0.0;
+    Mem = sizeof(Vec_Int_t) * Vec_WecCap(p);
+    for ( i = 0; i < p->nSize; i++ )
+        Mem += sizeof(int) * (size_t)Vec_IntCap( Vec_WecEntry(p, i) );
+    return Mem;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Frees the vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecZero( Vec_Wec_t * p )
+{
+    p->pArray = NULL;
+    p->nSize = 0;
+    p->nCap = 0;
+}
+static inline void Vec_WecErase( Vec_Wec_t * p )
+{
+    int i;
+    for ( i = 0; i < p->nCap; i++ )
+        ABC_FREE( p->pArray[i].pArray );
+    ABC_FREE( p->pArray );
+    p->nSize = 0;
+    p->nCap = 0;
+}
+static inline void Vec_WecFree( Vec_Wec_t * p )
+{
+    Vec_WecErase( p );
+    ABC_FREE( p );
+}
+static inline void Vec_WecFreeP( Vec_Wec_t ** p )
+{
+    if ( *p == NULL )
+        return;
+    Vec_WecFree( *p );
+    *p = NULL;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecPushUnique( Vec_Wec_t * p, int Level, int Entry )
+{
+    if ( p->nSize < Level + 1 )
+        Vec_WecPush( p, Level, Entry );
+    else
+        Vec_IntPushUnique( Vec_WecEntry(p, Level), Entry );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Frees the vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Wec_t * Vec_WecDup( Vec_Wec_t * p )
+{
+    Vec_Wec_t * vNew;
+    Vec_Int_t * vVec;
+    int i, k, Entry;
+    vNew = Vec_WecAlloc( Vec_WecSize(p) );
+    Vec_WecForEachLevel( p, vVec, i )
+        Vec_IntForEachEntry( vVec, Entry, k )
+            Vec_WecPush( vNew, i, Entry );
+    return vNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting by array size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Vec_WecSortCompare1( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntSize(p1) < Vec_IntSize(p2) )
+        return -1;
+    if ( Vec_IntSize(p1) > Vec_IntSize(p2) ) 
+        return 1;
+    return 0; 
+}
+static int Vec_WecSortCompare2( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntSize(p1) > Vec_IntSize(p2) )
+        return -1;
+    if ( Vec_IntSize(p1) < Vec_IntSize(p2) ) 
+        return 1;
+    return 0; 
+}
+static inline void Vec_WecSort( Vec_Wec_t * p, int fReverse )
+{
+    if ( fReverse ) 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare2 );
+    else
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare1 );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting by the first entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Vec_WecSortCompare3( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntEntry(p1,0) < Vec_IntEntry(p2,0) )
+        return -1;
+    if ( Vec_IntEntry(p1,0) > Vec_IntEntry(p2,0) ) 
+        return 1;
+    return 0; 
+}
+static int Vec_WecSortCompare4( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntEntry(p1,0) > Vec_IntEntry(p2,0) )
+        return -1;
+    if ( Vec_IntEntry(p1,0) < Vec_IntEntry(p2,0) ) 
+        return 1;
+    return 0; 
+}
+static inline void Vec_WecSortByFirstInt( Vec_Wec_t * p, int fReverse )
+{
+    if ( fReverse ) 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare4 );
+    else
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare3 );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting by the last entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Vec_WecSortCompare5( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntEntryLast(p1) < Vec_IntEntryLast(p2) )
+        return -1;
+    if ( Vec_IntEntryLast(p1) > Vec_IntEntryLast(p2) ) 
+        return 1;
+    return 0; 
+}
+static int Vec_WecSortCompare6( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntEntryLast(p1) > Vec_IntEntryLast(p2) )
+        return -1;
+    if ( Vec_IntEntryLast(p1) < Vec_IntEntryLast(p2) ) 
+        return 1;
+    return 0; 
+}
+static inline void Vec_WecSortByLastInt( Vec_Wec_t * p, int fReverse )
+{
+    if ( fReverse ) 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare6 );
+    else
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare5 );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+  
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecPrint( Vec_Wec_t * p, int fSkipSingles )
+{
+    Vec_Int_t * vVec;
+    int i, k, Entry;
+    Vec_WecForEachLevel( p, vVec, i )
+    {
+        if ( fSkipSingles && Vec_IntSize(vVec) == 1 )
+            continue;
+        printf( " %4d : {", i );
+        Vec_IntForEachEntry( vVec, Entry, k )
+            printf( " %d", Entry );
+        printf( " }\n" );
+    }
+}
+static inline void Vec_WecPrintLits( Vec_Wec_t * p )
+{
+    Vec_Int_t * vVec;
+    int i, k, iLit;
+    Vec_WecForEachLevel( p, vVec, i )
+    {
+        printf( " %4d : %2d  {", i, Vec_IntSize(vVec) );
+        Vec_IntForEachEntry( vVec, iLit, k )
+            printf( " %c%d", Abc_LitIsCompl(iLit) ? '-' : '+', Abc_Lit2Var(iLit) );
+        printf( " }\n" );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Derives the set of equivalence classes.]
+
+  Description []
+  
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Wec_t * Vec_WecCreateClasses( Vec_Int_t * vMap )
+{
+    Vec_Wec_t * vClasses;
+    int i, Entry;
+    vClasses = Vec_WecStart( Vec_IntFindMax(vMap) + 1 );
+    Vec_IntForEachEntry( vMap, Entry, i )
+        Vec_WecPush( vClasses, Entry, i );
+    return vClasses;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_WecCountNonTrivial( Vec_Wec_t * p, int * pnUsed )
+{
+    Vec_Int_t * vClass;
+    int i, nClasses = 0;
+    *pnUsed = 0;
+    Vec_WecForEachLevel( p, vClass, i )
+    {
+        if ( Vec_IntSize(vClass) < 2 )
+            continue;
+        nClasses++;
+        (*pnUsed) += Vec_IntSize(vClass);
+    }
+    return nClasses;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_WecCollectFirsts( Vec_Wec_t * p )
+{
+    Vec_Int_t * vFirsts, * vLevel;
+    int i;
+    vFirsts = Vec_IntAlloc( Vec_WecSize(p) );
+    Vec_WecForEachLevel( p, vLevel, i )
+        if ( Vec_IntSize(vLevel) > 0 )
+            Vec_IntPush( vFirsts, Vec_IntEntry(vLevel, 0) );
+    return vFirsts;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Ptr_t * Vec_WecConvertToVecPtr( Vec_Wec_t * p )
+{
+    Vec_Ptr_t * vCopy;
+    Vec_Int_t * vLevel;
+    int i;
+    vCopy = Vec_PtrAlloc( Vec_WecSize(p) );
+    Vec_WecForEachLevel( p, vLevel, i )
+        Vec_PtrPush( vCopy, Vec_IntDup(vLevel) );
+    return vCopy;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Temporary vector marking.]
+
+  Description [The vector should be static when the marking is used.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int  Vec_WecIntHasMark( Vec_Int_t * vVec ) { return (vVec->nCap >> 30) & 1; }
+static inline void Vec_WecIntSetMark( Vec_Int_t * vVec ) { vVec->nCap |= (1<<30);         }
+static inline void Vec_WecIntXorMark( Vec_Int_t * vVec ) { vVec->nCap ^= (1<<30);         }
+static inline void Vec_WecMarkLevels( Vec_Wec_t * vCubes, Vec_Int_t * vLevels )
+{
+    Vec_Int_t * vCube;
+    int i;
+    Vec_WecForEachLevelVec( vLevels, vCubes, vCube, i )
+    {
+        assert( !Vec_WecIntHasMark( vCube ) );
+        Vec_WecIntXorMark( vCube );
+    }
+}
+static inline void Vec_WecUnmarkLevels( Vec_Wec_t * vCubes, Vec_Int_t * vLevels )
+{
+    Vec_Int_t * vCube;
+    int i;
+    Vec_WecForEachLevelVec( vLevels, vCubes, vCube, i )
+    {
+        assert( Vec_WecIntHasMark( vCube ) );
+        Vec_WecIntXorMark( vCube );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Removes 0-size vectors.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecRemoveEmpty( Vec_Wec_t * vCubes )
+{
+    Vec_Int_t * vCube;
+    int i, k = 0;
+    Vec_WecForEachLevel( vCubes, vCube, i )
+        if ( Vec_IntSize(vCube) > 0 )
+            vCubes->pArray[k++] = *vCube;
+        else
+            ABC_FREE( vCube->pArray );
+    for ( i = k; i < Vec_WecSize(vCubes); i++ )
+        Vec_IntZero( Vec_WecEntry(vCubes, i) );
+    Vec_WecShrink( vCubes, k );
+//    Vec_WecSortByFirstInt( vCubes, 0 );
+}
+
+
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
diff --git a/lib/abcesop/exor.cpp b/lib/abcesop/exor.cpp
new file mode 100644
index 0000000..5c63fd5
--- /dev/null
+++ b/lib/abcesop/exor.cpp
@@ -0,0 +1,990 @@
+/**CFile****************************************************************
+
+  FileName    [exor.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Exclusive sum-of-product minimization.]
+
+  Synopsis    [Main procedure.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: exor.c,v 1.0 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+////////////////////////////////////////////////////////////////////////
+///                                                                  ///
+///                  Implementation of EXORCISM - 4                  ///
+///              An Exclusive Sum-of-Product Minimizer               ///
+///               Alan Mishchenko  <alanmi@ee.pdx.edu>               ///
+///                                                                  ///
+////////////////////////////////////////////////////////////////////////
+///                                                                  ///
+///                         Main Module                              ///
+///                ESOP Minimization Task Coordinator                ///
+///                                                                  ///
+///          1) interprets command line                              ///  
+///          2) calls the approapriate reading procedure             ///
+///          3) calls the minimization module                        ///
+///                                                                  ///
+///  Ver. 1.0. Started - July 18, 2000. Last update - July 20, 2000  ///
+///  Ver. 1.1. Started - July 24, 2000. Last update - July 29, 2000  ///
+///  Ver. 1.4. Started -  Aug 10, 2000. Last update -  Aug 26, 2000  ///
+///  Ver. 1.6. Started -  Sep 11, 2000. Last update -  Sep 15, 2000  ///
+///  Ver. 1.7. Started -  Sep 20, 2000. Last update -  Sep 23, 2000  ///
+///                                                                  ///
+////////////////////////////////////////////////////////////////////////
+///   This software was tested with the BDD package "CUDD", v.2.3.0  ///
+///                          by Fabio Somenzi                        ///
+///                  http://vlsi.colorado.edu/~fabio/                ///
+////////////////////////////////////////////////////////////////////////
+
+#include "eabc/exor.h"
+
+#include <cstdint>
+#include <functional>
+#include <cstdint>
+
+namespace abc::exorcism {
+
+///////////////////////////////////////////////////////////////////////
+///                      GLOBAL VARIABLES                            ///
+////////////////////////////////////////////////////////////////////////
+
+// information about the cube cover
+cinfo g_CoverInfo;
+
+extern int s_fDecreaseLiterals;
+
+////////////////////////////////////////////////////////////////////////
+///                       EXTERNAL FUNCTIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                        FUNCTION main()                           ///
+////////////////////////////////////////////////////////////////////////
+
+
+/**Function*************************************************************
+
+  Synopsis    [Number of negative literals.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+/*
+static int QCost[16][16] = 
+{
+    {  1}, // 0
+    {  1,   2}, // 1
+    {  5,   5,   6}, // 2
+    { 14,  14,  16,  18}, // 3
+    { 20,  20,  20,  22,  24}, // 4
+    { 32,  32,  32,  34,  36,  38}, // 5
+    { 44,  44,  44,  44,  46,  48,  50}, // 6
+    { 56,  56,  56,  56,  58,  60,  62,  64}, // 7
+    { 0 }
+};
+*/
+int GetQCost( int nVars, int nNegs )
+{
+    int Extra;
+    assert( nVars >= nNegs );
+    if ( nVars == 0 )  
+        return 1;
+    if ( nVars == 1 )  
+    {
+        if ( nNegs == 0 )  return 1;
+        if ( nNegs == 1 )  return 2;
+    }
+    if ( nVars == 2 )
+    {
+        if ( nNegs <= 1 )  return 5;
+        if ( nNegs == 2 )  return 6;
+    }
+    if ( nVars == 3 )
+    {
+        if ( nNegs <= 1 )  return 14;
+        if ( nNegs == 2 )  return 16;
+        if ( nNegs == 3 )  return 18;
+    }
+    Extra = nNegs - nVars/2;
+    return 20 + 12 * (nVars - 4) + (Extra > 0 ? 2 * Extra : 0);
+
+}
+void GetQCostTest()
+{
+    int i, k, Limit = 10;
+    for ( i = 0; i < Limit; i++ )
+    {
+        for ( k = 0; k <= i; k++ )
+            printf( "%4d ", GetQCost(i, k) );
+        printf( "\n" );
+    }
+}
+int ComputeQCost( Vec_Int_t * vCube )
+{
+    int i, Entry, nLitsN = 0;
+    Vec_IntForEachEntry( vCube, Entry, i )
+        nLitsN += Abc_LitIsCompl(Entry);
+    return GetQCost( Vec_IntSize(vCube), nLitsN );
+}
+int ComputeQCostBits( Cube * p )
+{
+    extern varvalue GetVar( Cube* pC, int Var );
+    int v, nLits = 0, nLitsN = 0;
+    for ( v = 0; v < g_CoverInfo.nVarsIn; v++ )
+    {
+        int Value = GetVar( p, v );
+        if ( Value == VAR_NEG )
+            nLitsN++;
+        else if ( Value == VAR_POS )
+            nLits++;
+    }
+    nLits += nLitsN;
+    return GetQCost( nLits, nLitsN );
+}
+int ToffoliGateCount( int controls, int lines )
+{
+    switch ( controls )
+    {
+    case 0u:
+    case 1u:
+        return 0;
+        break;
+    case 2u:
+        return 1;
+        break;
+    case 3u:
+        return 4;
+        break;
+    case 4u:
+        return ( ( ( lines + 1 ) / 2 ) >= controls ) ? 8 : 10;
+        break;
+    default:
+        return ( ( ( lines + 1 ) / 2 ) >= controls ) ? 4 * ( controls - 2 ) : 8 * ( controls - 3 );
+    }
+}
+int ComputeQCostTcount( Vec_Int_t * vCube )
+{
+    return 7 * ToffoliGateCount( Vec_IntSize( vCube ), g_CoverInfo.nVarsIn + 1 );
+}
+int ComputeQCostTcountBits( Cube * p )
+{
+    extern varvalue GetVar( Cube* pC, int Var );
+    int v, nLits = 0;
+    for ( v = 0; v < g_CoverInfo.nVarsIn; v++ )
+        if ( GetVar( p, v ) != VAR_ABS )
+            nLits++;
+    return 7 * ToffoliGateCount( nLits, g_CoverInfo.nVarsIn + 1 );
+
+    /* maybe just: 7 * ToffoliGateCount( p->a, g_CoverInfo.nVarsIn + 1 ); */
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int ReduceEsopCover()
+{
+    ///////////////////////////////////////////////////////////////
+    // SIMPLIFICATION
+    ////////////////////////////////////////////////////////////////////
+
+    int nIterWithoutImprovement = 0;
+    int nIterCount = 0;
+    int GainTotal;
+    int z;
+
+    do
+    {
+//START:
+        if ( g_CoverInfo.Verbosity == 2 )
+            printf( "\nITERATION #%d\n\n", ++nIterCount );
+        else if ( g_CoverInfo.Verbosity == 1 )
+            printf( "." );
+
+        GainTotal  = 0;
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+        if ( nIterWithoutImprovement > (int)(g_CoverInfo.Quality>0) )
+        {
+            GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+            GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+            GainTotal += IterativelyApplyExorLink2( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink3( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink2( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink4( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink2( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink4( 1|2|0 );
+
+            GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+            GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+            GainTotal += IterativelyApplyExorLink2( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink3( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink2( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink4( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink2( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink4( 1|2|0 );
+        }
+
+        if ( GainTotal )
+            nIterWithoutImprovement = 0;
+        else
+            nIterWithoutImprovement++;
+
+//      if ( g_CoverInfo.Quality >= 2 && nIterWithoutImprovement == 2 )
+//          s_fDecreaseLiterals = 1;
+    }
+    while ( nIterWithoutImprovement < 1 + g_CoverInfo.Quality );
+
+
+    // improve the literal count
+    s_fDecreaseLiterals = 1;
+    for ( z = 0; z < 1; z++ )
+    {
+        if ( g_CoverInfo.Verbosity == 2 )
+            printf( "\nITERATION #%d\n\n", ++nIterCount );
+        else if ( g_CoverInfo.Verbosity == 1 )
+            printf( "." );
+
+        GainTotal  = 0;
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+//      if ( GainTotal )
+//      {
+//          nIterWithoutImprovement = 0;
+//          goto START;
+//      }           
+    }
+
+
+/*  ////////////////////////////////////////////////////////////////////
+    // Print statistics
+    printf( "\nShallow simplification time is ";
+    cout << (float)(clk2 - clk1)/(float)(CLOCKS_PER_SEC) << " sec\n" );
+    printf( "Deep simplification time is ";
+    cout << (float)(Abc_Clock() - clk2)/(float)(CLOCKS_PER_SEC) << " sec\n" );
+    printf( "Cover after iterative simplification = " << s_nCubesInUse << endl;
+    printf( "Reduced by initial cube writing      = " << g_CoverInfo.nCubesBefore-nCubesAfterWriting << endl;
+    printf( "Reduced by shallow simplification    = " << nCubesAfterWriting-nCubesAfterShallow << endl;
+    printf( "Reduced by deep simplification       = " << nCubesAfterWriting-s_nCubesInUse << endl;
+
+//  printf( "\nThe total number of cubes created = " << g_CoverInfo.cIDs << endl;
+//  printf( "Total number of places in a queque = " << s_nPosAlloc << endl;
+//  printf( "Minimum free places in queque-2 = " << s_nPosMax[0] << endl;
+//  printf( "Minimum free places in queque-3 = " << s_nPosMax[1] << endl;
+//  printf( "Minimum free places in queque-4 = " << s_nPosMax[2] << endl;
+*/  ////////////////////////////////////////////////////////////////////
+
+    // write the number of cubes into cover information 
+    assert ( g_CoverInfo.nCubesInUse + g_CoverInfo.nCubesFree == g_CoverInfo.nCubesAlloc );
+
+//  printf( "\nThe output cover is\n" );
+//  PrintCoverDebug( cout );
+
+    return 0;
+}
+
+//////////////////////////////////////////////////////////////////
+// quite a good script
+//////////////////////////////////////////////////////////////////
+/*
+    long clk1 = Abc_Clock();
+    int nIterWithoutImprovement = 0;
+    do
+    {
+        PrintQuequeStats();
+        GainTotal  = 0;
+        GainTotal += IterativelyApplyExorLink( DIST2, 0|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 0|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+
+        if ( nIterWithoutImprovement > 2 )
+        {
+            GainTotal += IterativelyApplyExorLink( DIST2, 0|0|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 0|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST3, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|0 );
+        }
+
+        if ( nIterWithoutImprovement > 6 )
+        {
+            GainTotal += IterativelyApplyExorLink( DIST2, 0|0|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 0|0|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 0|0|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|0 );
+        }
+
+        if ( GainTotal )
+            nIterWithoutImprovement = 0;
+        else
+            nIterWithoutImprovement++;
+    }
+    while ( nIterWithoutImprovement < 12 );
+
+    nCubesAfterShallow = s_nCubesInUse;
+
+*/
+
+/*
+    // alu4 - 439
+    long clk1 = Abc_Clock();
+    int nIterWithoutImprovement = 0;
+    do
+    {
+        PrintQuequeStats();
+        GainTotal  = 0;
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|0|0 );
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+
+        if ( nIterWithoutImprovement > 2 )
+        {
+            GainTotal += IterativelyApplyExorLink( DIST2, 0|0|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 0|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST3, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|0 );
+        }
+
+        if ( nIterWithoutImprovement > 6 )
+        {
+            GainTotal += IterativelyApplyExorLink( DIST2, 0|0|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 0|0|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 0|0|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|0 );
+        }
+
+        if ( GainTotal )
+            nIterWithoutImprovement = 0;
+        else
+            nIterWithoutImprovement++;
+    }
+    while ( nIterWithoutImprovement < 12 );
+*/
+
+/*
+// alu4 - 412 cubes, 700 sec
+
+    long clk1 = Abc_Clock();
+    int nIterWithoutImprovement = 0;
+    int nIterCount = 0;
+    do
+    {
+        printf( "\nITERATION #" << ++nIterCount << endl << endl;
+
+        GainTotal  = 0;
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+        if ( nIterWithoutImprovement > 3 )
+        {
+            GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+            GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+            GainTotal += IterativelyApplyExorLink3( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink2( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink3( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink4( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink3( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink4( 1|2|4 );
+        }
+
+        if ( nIterWithoutImprovement > 7 )
+        {
+            GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+            GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+            GainTotal += IterativelyApplyExorLink2( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink3( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink3( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink4( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink4( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink4( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink3( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink4( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink4( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink4( 1|2|4 );
+        }
+
+        if ( GainTotal )
+            nIterWithoutImprovement = 0;
+        else
+            nIterWithoutImprovement++;
+    }
+    while ( nIterWithoutImprovement < 12 );
+*/
+
+/*
+// pretty good script
+// alu4 = 424   in 250 sec
+
+    long clk1 = Abc_Clock();
+    int nIterWithoutImprovement = 0;
+    int nIterCount = 0;
+    do
+    {
+        printf( "\nITERATION #" << ++nIterCount << "   |";
+        for ( int k = 0; k < nIterWithoutImprovement; k++ )
+            printf( "*";
+        for ( ; k < 11; k++ )
+            printf( "_";
+        printf( "|" << endl << endl;
+
+        GainTotal  = 0;
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+
+        if ( nIterWithoutImprovement > 2 )
+        {
+            GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+            GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+            GainTotal += IterativelyApplyExorLink( DIST2, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST3, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST3, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|4 );
+        }
+
+        if ( nIterWithoutImprovement > 4 )
+        {
+            GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+            GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+            GainTotal += IterativelyApplyExorLink( DIST2, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST3, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST2, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST3, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|4 );
+        }
+
+        if ( GainTotal )
+            nIterWithoutImprovement = 0;
+        else
+            nIterWithoutImprovement++;
+    }
+    while ( nIterWithoutImprovement < 7 );
+*/
+
+/*
+alu4 = 435   70 secs
+
+    long clk1 = Abc_Clock();
+    int nIterWithoutImprovement = 0;
+    int nIterCount = 0;
+
+    do
+    {
+        printf( "\nITERATION #" << ++nIterCount << endl << endl;
+
+        GainTotal  = 0;
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+
+
+        if ( GainTotal )
+            nIterWithoutImprovement = 0;
+        else
+            nIterWithoutImprovement++;
+    }
+    while ( nIterWithoutImprovement < 4 );
+*/
+
+/*
+  // the best previous
+  
+    long clk1 = Abc_Clock();
+    int nIterWithoutImprovement = 0;
+    int nIterCount = 0;
+    int GainTotal;
+    do
+    {
+        if ( g_CoverInfo.Verbosity == 2 )
+        printf( "\nITERATION #" << ++nIterCount << endl << endl;
+        else if ( g_CoverInfo.Verbosity == 1 )
+        cout << '.';
+
+        GainTotal  = 0;
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+        GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+
+        if ( nIterWithoutImprovement > 1 )
+        {
+            GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+            GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+            GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+            GainTotal += IterativelyApplyExorLink( DIST3, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST2, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST2, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|0 );
+
+            GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+            GainTotal += IterativelyApplyExorLink( DIST3, 1|2|0 );
+            GainTotal += IterativelyApplyExorLink( DIST2, 1|2|0 );
+            GainTotal += IterativelyApplyExorLink( DIST3, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST2, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST2, 1|2|4 );
+            GainTotal += IterativelyApplyExorLink( DIST4, 1|2|0 );
+        }
+
+        if ( GainTotal )
+            nIterWithoutImprovement = 0;
+        else
+            nIterWithoutImprovement++;
+    }
+//  while ( nIterWithoutImprovement < 20 );
+//  while ( nIterWithoutImprovement < 7 );
+    while ( nIterWithoutImprovement < 1 + g_CoverInfo.Quality );
+
+*/
+
+/*
+// the last tried
+
+    long clk1 = Abc_Clock();
+    int nIterWithoutImprovement = 0;
+    int nIterCount = 0;
+    int GainTotal;
+    do
+    {
+        if ( g_CoverInfo.Verbosity == 2 )
+        printf( "\nITERATION #" << ++nIterCount << endl << endl;
+        else if ( g_CoverInfo.Verbosity == 1 )
+        cout << '.';
+
+        GainTotal  = 0;
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+        GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+        GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+
+        if ( nIterWithoutImprovement > (int)(g_CoverInfo.Quality>0) )
+        {
+            GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+            GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+            GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+            GainTotal += IterativelyApplyExorLink3( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink2( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink4( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink2( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink4( 1|2|0 );
+
+            GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+            GainTotal += IterativelyApplyExorLink3( 1|2|0 );
+            GainTotal += IterativelyApplyExorLink2( 1|2|0 );
+            GainTotal += IterativelyApplyExorLink3( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink2( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink4( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink2( 1|2|4 );
+            GainTotal += IterativelyApplyExorLink4( 1|2|0 );
+        }
+
+        if ( GainTotal )
+            nIterWithoutImprovement = 0;
+        else
+            nIterWithoutImprovement++;
+    }
+    while ( nIterWithoutImprovement < 1 + g_CoverInfo.Quality );
+*/
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void AddCubesToStartingCover( Vec_Wec_t * vEsop )
+{
+    Vec_Int_t * vCube;
+    Cube * pNew;
+    int * s_Level2Var;
+    int * s_LevelValues;
+    int c, i, k, Lit, Out;
+
+    s_Level2Var = ABC_ALLOC( int, g_CoverInfo.nVarsIn );
+    s_LevelValues = ABC_ALLOC( int, g_CoverInfo.nVarsIn );
+
+    for ( i = 0; i < g_CoverInfo.nVarsIn; i++ )
+        s_Level2Var[i] = i;
+
+    g_CoverInfo.nLiteralsBefore = 0;
+    g_CoverInfo.QCostBefore = 0;
+    Vec_WecForEachLevel( vEsop, vCube, c )
+    {
+        // get the output of this cube
+        Out = -Vec_IntPop(vCube) - 1;
+
+        // fill in the cube with blanks
+        for ( i = 0; i < g_CoverInfo.nVarsIn; i++ )
+            s_LevelValues[i] = VAR_ABS;
+        Vec_IntForEachEntry( vCube, Lit, k )
+        {
+            if ( Abc_LitIsCompl(Lit) )
+                s_LevelValues[Abc_Lit2Var(Lit)] = VAR_NEG;
+            else
+                s_LevelValues[Abc_Lit2Var(Lit)] = VAR_POS;
+        }
+
+        // get the new cube
+        pNew = GetFreeCube();
+        // consider the need to clear the cube
+        if ( pNew->pCubeDataIn[0] ) // this is a recycled cube
+        {
+            for ( i = 0; i < g_CoverInfo.nWordsIn; i++ )
+                pNew->pCubeDataIn[i] = 0;
+            for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
+                pNew->pCubeDataOut[i] = 0;
+        }
+
+        InsertVarsWithoutClearing( pNew, s_Level2Var, g_CoverInfo.nVarsIn, s_LevelValues, Out );
+        // set literal counts
+        pNew->a = Vec_IntSize(vCube);
+        pNew->z = 1;
+        pNew->q = ComputeQCost(vCube);
+        // set the ID
+        pNew->ID = g_CoverInfo.cIDs++;
+        // skip through zero-ID
+        if ( g_CoverInfo.cIDs == 256 )
+            g_CoverInfo.cIDs = 1;
+
+        // add this cube to storage
+        CheckForCloseCubes( pNew, 1 );
+
+        g_CoverInfo.nLiteralsBefore += Vec_IntSize(vCube);
+        g_CoverInfo.QCostBefore += ComputeQCost(vCube);
+    }
+    ABC_FREE( s_Level2Var );
+    ABC_FREE( s_LevelValues );
+
+    assert ( g_CoverInfo.nCubesInUse + g_CoverInfo.nCubesFree == g_CoverInfo.nCubesAlloc );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Performs heuristic minimization of ESOPs.]
+
+  Description [Returns 1 on success, 0 on failure.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Exorcism( Vec_Wec_t * vEsop, int nIns, int nOuts, std::function<void(uint32_t, uint32_t)> const& onCube )
+{
+    abctime clk1;
+    int RemainderBits;
+    int TotalWords;
+    int MemTemp, MemTotal;
+
+    ///////////////////////////////////////////////////////////////////////
+    // STEPS of HEURISTIC ESOP MINIMIZATION
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+    // STEP 1: determine the size of the starting cover
+    ///////////////////////////////////////////////////////////////////////
+    assert( nIns > 0 );
+    // inputs
+    RemainderBits = (nIns*2)%(sizeof(unsigned)*8);
+    TotalWords    = (nIns*2)/(sizeof(unsigned)*8) + (RemainderBits > 0);
+    g_CoverInfo.nVarsIn  = nIns;
+    g_CoverInfo.nWordsIn = TotalWords;
+    // outputs
+    RemainderBits = (nOuts)%(sizeof(unsigned)*8);
+    TotalWords    = (nOuts)/(sizeof(unsigned)*8) + (RemainderBits > 0);
+    g_CoverInfo.nVarsOut  = nOuts;
+    g_CoverInfo.nWordsOut = TotalWords;
+    g_CoverInfo.cIDs = 1;
+
+    // cubes
+    clk1 = Abc_Clock();
+//  g_CoverInfo.nCubesBefore = CountTermsInPseudoKroneckerCover( g_Func.dd, nOuts );
+    g_CoverInfo.nCubesBefore = Vec_WecSize(vEsop);
+    g_CoverInfo.TimeStart = Abc_Clock() - clk1;
+
+    if ( g_CoverInfo.Verbosity )
+    {
+    printf( "Starting cover generation time is %.2f sec\n", TICKS_TO_SECONDS(g_CoverInfo.TimeStart) );
+    printf( "The number of cubes in the starting cover is %d\n", g_CoverInfo.nCubesBefore );
+    }
+
+    if ( g_CoverInfo.nCubesBefore > g_CoverInfo.nCubesMax )
+    {
+        printf( "\nThe size of the starting cover is more than %d cubes. Quitting...\n", g_CoverInfo.nCubesMax );
+        return 0;
+    }
+
+    ///////////////////////////////////////////////////////////////////////
+    // STEP 2: prepare internal data structures
+    ///////////////////////////////////////////////////////////////////////
+    g_CoverInfo.nCubesAlloc = g_CoverInfo.nCubesBefore + ADDITIONAL_CUBES; 
+
+    // allocate cube cover
+    MemTotal = 0;
+    MemTemp = AllocateCover( g_CoverInfo.nCubesAlloc, g_CoverInfo.nWordsIn, g_CoverInfo.nWordsOut );
+    if ( MemTemp == 0 )
+    {
+        printf( "Unexpected memory allocation problem. Quitting...\n" );
+        return 0;
+    }
+    else 
+        MemTotal += MemTemp;
+
+    // allocate cube sets
+    MemTemp = AllocateCubeSets( g_CoverInfo.nVarsIn, g_CoverInfo.nVarsOut );
+    if ( MemTemp == 0 )
+    {
+        printf( "Unexpected memory allocation problem. Quitting...\n" );
+        return 0;
+    }
+    else 
+        MemTotal += MemTemp;
+
+    // allocate adjacency queques
+    MemTemp = AllocateQueques( g_CoverInfo.nCubesAlloc*g_CoverInfo.nCubesAlloc/CUBE_PAIR_FACTOR );
+    if ( MemTemp == 0 )
+    {
+        printf( "Unexpected memory allocation problem. Quitting...\n" );
+        return 0;
+    }
+    else 
+        MemTotal += MemTemp;
+
+    if ( g_CoverInfo.Verbosity )
+    printf( "Dynamically allocated memory is %dK\n",  MemTotal/1000 );
+
+    ///////////////////////////////////////////////////////////////////////
+    // STEP 3: write the cube cover into the allocated storage
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+    clk1 = Abc_Clock();
+    if ( g_CoverInfo.Verbosity )
+    printf( "Generating the starting cover...\n" );
+    AddCubesToStartingCover( vEsop );
+    ///////////////////////////////////////////////////////////////////////
+
+    ///////////////////////////////////////////////////////////////////////
+    // STEP 4: iteratively improve the cover 
+    ///////////////////////////////////////////////////////////////////////
+    if ( g_CoverInfo.Verbosity )
+    printf( "Performing minimization...\n" );
+    clk1 = Abc_Clock();
+    ReduceEsopCover();
+    g_CoverInfo.TimeMin = Abc_Clock() - clk1;
+//  g_Func.TimeMin = (float)(Abc_Clock() - clk1)/(float)(CLOCKS_PER_SEC);
+    if ( g_CoverInfo.Verbosity )
+    {
+    printf( "\nMinimization time is %.2f sec\n", TICKS_TO_SECONDS(g_CoverInfo.TimeMin) );
+    printf( "\nThe number of cubes after minimization is %d\n", g_CoverInfo.nCubesInUse );
+    }
+
+    ///////////////////////////////////////////////////////////////////////
+    // STEP 5: save the cover into file 
+    ///////////////////////////////////////////////////////////////////////
+    // if option is MULTI_OUTPUT, the output is written into the output file;
+    // if option is SINGLE_NODE, the output is added to the input file
+    // and written into the output file; in this case, the minimized nodes is
+    // also stored in the temporary file "temp.blif" for verification
+
+    // create the file name and write the output
+    extern Cube* IterCubeSetStart();
+    extern Cube* IterCubeSetNext();
+    extern varvalue GetVar( Cube* pC, int Var );
+
+    {
+      int v;
+      Cube* p;
+
+      for ( p = IterCubeSetStart(); p; p = IterCubeSetNext() )
+      {
+        assert( p->fMark == 0 );
+
+        // write the input variables
+        uint32_t mask{}, bits{};
+        for ( v = 0; v < g_CoverInfo.nVarsIn; v++ )
+        {
+          int Value = GetVar( p, v );
+          if ( Value == VAR_NEG )
+          {
+            mask |= 1 << v;
+          }
+          else if ( Value == VAR_POS )
+          {
+            mask |= 1 << v;
+            bits |= 1 << v;
+          }
+          else if ( Value == VAR_ABS )
+          {
+            // do nothing
+          }
+          else
+            assert( 0 );
+        }
+
+        onCube( bits, mask );
+      }
+    }
+
+    ///////////////////////////////////////////////////////////////////////
+    // STEP 6: delocate memory
+    ///////////////////////////////////////////////////////////////////////
+    DelocateCubeSets();
+    DelocateCover();
+    DelocateQueques();
+
+    // return success
+    return 1;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_ExorcismMain( Vec_Wec_t * vEsop, int nIns, int nOuts, std::function<void(uint32_t, uint32_t)> const& onCube, int Quality, int Verbosity, int nCubesMax, int fUseQCost )
+{
+    memset( &g_CoverInfo, 0, sizeof(cinfo) );
+    g_CoverInfo.Quality = Quality;
+    g_CoverInfo.Verbosity = Verbosity;
+    g_CoverInfo.nCubesMax = nCubesMax;
+    g_CoverInfo.fUseQCost = fUseQCost;
+    if ( fUseQCost )
+        s_fDecreaseLiterals = 1;
+    if ( g_CoverInfo.Verbosity )
+    {
+        printf( "\nEXORCISM, Ver.4.7: Exclusive Sum-of-Product Minimizer\n" );
+        printf( "by Alan Mishchenko, Portland State University, July-September 2000\n\n" );
+        printf( "Incoming ESOP has %d inputs, %d outputs, and %d cubes.\n", nIns, nOuts, Vec_WecSize(vEsop) );
+    }
+    PrepareBitSetModule();
+    if ( Exorcism( vEsop, nIns, nOuts, onCube ) == 0 )
+    {
+        printf( "Something went wrong when minimizing the cover\n" );
+        return 0;
+    }
+    return 1;
+}
+
+///////////////////////////////////////////////////////////////////
+////////////              End of File             /////////////////
+///////////////////////////////////////////////////////////////////
+
+
+}
+
diff --git a/lib/abcesop/exorBits.cpp b/lib/abcesop/exorBits.cpp
new file mode 100644
index 0000000..c362381
--- /dev/null
+++ b/lib/abcesop/exorBits.cpp
@@ -0,0 +1,425 @@
+/**CFile****************************************************************
+
+  FileName    [exorBits.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Exclusive sum-of-product minimization.]
+
+  Synopsis    [Bit-level procedures.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: exorBits.c,v 1.0 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+////////////////////////////////////////////////////////////////////////
+///                                                                  ///
+///                  Implementation of EXORCISM - 4                  ///
+///              An Exclusive Sum-of-Product Minimizer               ///
+///                                                                  ///
+///               Alan Mishchenko  <alanmi@ee.pdx.edu>               ///
+///                                                                  ///
+////////////////////////////////////////////////////////////////////////
+///                                                                  ///
+///              EXOR-Oriented Bit String Manipulation               ///
+///                                                                  ///
+///  Ver. 1.0. Started - July 18, 2000. Last update - July 20, 2000  ///
+///  Ver. 1.4. Started -  Aug 10, 2000. Last update -  Aug 10, 2000  ///
+///                                                                  ///
+////////////////////////////////////////////////////////////////////////
+///   This software was tested with the BDD package "CUDD", v.2.3.0  ///
+///                          by Fabio Somenzi                        ///
+///                  http://vlsi.colorado.edu/~fabio/                ///
+////////////////////////////////////////////////////////////////////////
+
+#include "eabc/exor.h"
+
+namespace abc::exorcism {
+
+////////////////////////////////////////////////////////////////////////
+///                       MACRO DEFINITIONS                          ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                       EXTERNAL VARIABLES                         ///
+////////////////////////////////////////////////////////////////////////
+
+// information about the cube cover
+// the number of cubes is constantly updated when the cube cover is processed
+// in this module, only the number of variables (nVarsIn) and integers (nWordsIn)
+// is used, which do not change
+extern cinfo g_CoverInfo;
+
+////////////////////////////////////////////////////////////////////////
+///                  FUNCTIONS OF THIS MODULE                        ///
+////////////////////////////////////////////////////////////////////////
+
+int GetDistance( Cube * pC1, Cube * pC2 );
+// return the distance between two cubes
+int GetDistancePlus( Cube * pC1, Cube * pC2 );
+
+int FindDiffVars( int * pDiffVars, Cube * pC1, Cube * pC2 );
+// determine different variables in cubes from pCubes[] and writes them into pDiffVars
+// returns the number of different variables
+
+void InsertVars( Cube * pC, int * pVars, int nVarsIn, int * pVarValues );
+
+//inline int VarWord( int element );
+//inline int VarBit( int element );
+varvalue GetVar( Cube * pC, int Var );
+
+void ExorVar( Cube * pC, int Var, varvalue Val );
+
+////////////////////////////////////////////////////////////////////////
+///                        STATIC VARIABLES                          ///
+////////////////////////////////////////////////////////////////////////
+
+// the bit count for the first 256 integer numbers
+static unsigned char BitCount8[256] = {
+    0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+    1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+    1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+    2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+    1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+    2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+    2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+    3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8
+};
+
+static int SparseNumbers[163] = { 
+    0,1,4,5,16,17,20,21,64,65,68,69,80,81,84,85,256,257,260,
+    261,272,273,276,277,320,321,324,325,336,337,340,1024,1025,
+    1028,1029,1040,1041,1044,1045,1088,1089,1092,1093,1104,1105,
+    1108,1280,1281,1284,1285,1296,1297,1300,1344,1345,1348,1360,
+    4096,4097,4100,4101,4112,4113,4116,4117,4160,4161,4164,4165,
+    4176,4177,4180,4352,4353,4356,4357,4368,4369,4372,4416,4417,
+    4420,4432,5120,5121,5124,5125,5136,5137,5140,5184,5185,5188,
+    5200,5376,5377,5380,5392,5440,16384,16385,16388,16389,16400,
+    16401,16404,16405,16448,16449,16452,16453,16464,16465,16468,
+    16640,16641,16644,16645,16656,16657,16660,16704,16705,16708,
+    16720,17408,17409,17412,17413,17424,17425,17428,17472,17473,
+    17476,17488,17664,17665,17668,17680,17728,20480,20481,20484,
+    20485,20496,20497,20500,20544,20545,20548,20560,20736,20737,
+    20740,20752,20800,21504,21505,21508,21520,21568,21760 
+};
+
+static unsigned char GroupLiterals[163][4] = {
+    {0}, {0}, {1}, {0,1}, {2}, {0,2}, {1,2}, {0,1,2}, {3}, {0,3},
+    {1,3}, {0,1,3}, {2,3}, {0,2,3}, {1,2,3}, {0,1,2,3}, {4}, {0,4},
+    {1,4}, {0,1,4}, {2,4}, {0,2,4}, {1,2,4}, {0,1,2,4}, {3,4},
+    {0,3,4}, {1,3,4}, {0,1,3,4}, {2,3,4}, {0,2,3,4}, {1,2,3,4}, {5},
+    {0,5}, {1,5}, {0,1,5}, {2,5}, {0,2,5}, {1,2,5}, {0,1,2,5}, {3,5},
+    {0,3,5}, {1,3,5}, {0,1,3,5}, {2,3,5}, {0,2,3,5}, {1,2,3,5},
+    {4,5}, {0,4,5}, {1,4,5}, {0,1,4,5}, {2,4,5}, {0,2,4,5},
+    {1,2,4,5}, {3,4,5}, {0,3,4,5}, {1,3,4,5}, {2,3,4,5}, {6}, {0,6},
+    {1,6}, {0,1,6}, {2,6}, {0,2,6}, {1,2,6}, {0,1,2,6}, {3,6},
+    {0,3,6}, {1,3,6}, {0,1,3,6}, {2,3,6}, {0,2,3,6}, {1,2,3,6},
+    {4,6}, {0,4,6}, {1,4,6}, {0,1,4,6}, {2,4,6}, {0,2,4,6},
+    {1,2,4,6}, {3,4,6}, {0,3,4,6}, {1,3,4,6}, {2,3,4,6}, {5,6},
+    {0,5,6}, {1,5,6}, {0,1,5,6}, {2,5,6}, {0,2,5,6}, {1,2,5,6},
+    {3,5,6}, {0,3,5,6}, {1,3,5,6}, {2,3,5,6}, {4,5,6}, {0,4,5,6},
+    {1,4,5,6}, {2,4,5,6}, {3,4,5,6}, {7}, {0,7}, {1,7}, {0,1,7},
+    {2,7}, {0,2,7}, {1,2,7}, {0,1,2,7}, {3,7}, {0,3,7}, {1,3,7},
+    {0,1,3,7}, {2,3,7}, {0,2,3,7}, {1,2,3,7}, {4,7}, {0,4,7},
+    {1,4,7}, {0,1,4,7}, {2,4,7}, {0,2,4,7}, {1,2,4,7}, {3,4,7},
+    {0,3,4,7}, {1,3,4,7}, {2,3,4,7}, {5,7}, {0,5,7}, {1,5,7},
+    {0,1,5,7}, {2,5,7}, {0,2,5,7}, {1,2,5,7}, {3,5,7}, {0,3,5,7},
+    {1,3,5,7}, {2,3,5,7}, {4,5,7}, {0,4,5,7}, {1,4,5,7}, {2,4,5,7},
+    {3,4,5,7}, {6,7}, {0,6,7}, {1,6,7}, {0,1,6,7}, {2,6,7},
+    {0,2,6,7}, {1,2,6,7}, {3,6,7}, {0,3,6,7}, {1,3,6,7}, {2,3,6,7},
+    {4,6,7}, {0,4,6,7}, {1,4,6,7}, {2,4,6,7}, {3,4,6,7}, {5,6,7},
+    {0,5,6,7}, {1,5,6,7}, {2,5,6,7}, {3,5,6,7}, {4,5,6,7} 
+};
+
+// the bit count to 16-bit numbers
+#define FULL16BITS  0x10000
+#define MARKNUMBER  200
+
+static unsigned char BitGroupNumbers[FULL16BITS];
+unsigned char BitCount[FULL16BITS];
+
+////////////////////////////////////////////////////////////////////////
+///                      FUNCTION DEFINITIONS                        ///
+////////////////////////////////////////////////////////////////////////
+
+void PrepareBitSetModule()
+// this function should be called before anything is done with the cube cover
+{   
+    // prepare bit count
+    int i, k;
+    int nLimit;
+    
+    nLimit = FULL16BITS;
+    for ( i = 0; i < nLimit; i++ )
+    {
+        BitCount[i] = BitCount8[ i & 0xff ] + BitCount8[ i>>8 ];
+        BitGroupNumbers[i] = MARKNUMBER;
+    }
+    // prepare bit groups
+    for ( k = 0; k < 163; k++ )
+        BitGroupNumbers[ SparseNumbers[k] ] = k;
+/*
+    // verify bit groups
+    int n = 4368;
+    char Buff[100];
+    cout << "The number is " << n << endl;
+    cout << "The binary is " << itoa(n,Buff,2) << endl;
+    cout << "BitGroupNumbers[n] is " << (int)BitGroupNumbers[n] << endl;
+    cout << "The group literals are ";
+    for ( int g = 0; g < 4; g++ )
+        cout << " " << (int)GroupLiterals[BitGroupNumbers[n]][g];
+*/
+}
+
+////////////////////////////////////////////////////////////////////////
+///                   INLINE FUNCTION DEFINITIONS                    ///
+////////////////////////////////////////////////////////////////////////
+/*
+int VarWord( int element )
+{
+    return ( element >> LOGBPI );
+}
+
+int VarBit( int element )
+{
+    return ( element & BPIMASK );
+}
+*/
+
+varvalue GetVar( Cube * pC, int Var )
+// returns VAR_NEG if var is neg, VAR_POS if var is pos, VAR_ABS if var is absent
+{
+    int Bit = (Var<<1);
+    int Value = ((pC->pCubeDataIn[VarWord(Bit)] >> VarBit(Bit)) & 3);
+    assert( Value == VAR_NEG || Value == VAR_POS || Value == VAR_ABS );
+    return (varvalue)Value;
+}
+
+void ExorVar( Cube * pC, int Var, varvalue Val )
+// EXORs the value Val with the value of variable Var in the given cube
+// ((cube[VAR_WORD((v)<<1)]) ^ ( (pol)<<VAR_BIT((v)<<1) ))
+{
+    int Bit = (Var<<1);
+    pC->pCubeDataIn[VarWord(Bit)] ^= ( Val << VarBit(Bit) );
+}
+
+////////////////////////////////////////////////////////////////////////
+///                      FUNCTION DEFINITIONS                        ///
+////////////////////////////////////////////////////////////////////////
+
+static int DiffVarCounter, cVars;
+static drow Temp1, Temp2, Temp;
+static drow LastNonZeroWord;
+static int LastNonZeroWordNum;
+
+int GetDistance( Cube * pC1, Cube * pC2 )
+// finds and returns the distance between two cubes pC1 and pC2
+{
+    int i;
+    DiffVarCounter = 0;
+
+    for ( i = 0; i < g_CoverInfo.nWordsIn; i++ )
+    {
+        Temp1 = pC1->pCubeDataIn[i] ^ pC2->pCubeDataIn[i];
+        Temp2 = (Temp1|(Temp1>>1)) & DIFFERENT;
+
+        // count how many bits are one in this var difference
+        DiffVarCounter  += BIT_COUNT(Temp2);
+        if ( DiffVarCounter > 4 )
+            return 5;
+    }
+    // check whether the output parts are different
+    for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
+        if ( pC1->pCubeDataOut[i] ^ pC2->pCubeDataOut[i] )
+        {
+            DiffVarCounter++;
+            break;
+        }
+    return DiffVarCounter;
+}
+
+// place to put the number of the different variable and its value in the second cube
+extern int s_DiffVarNum;
+extern int s_DiffVarValueP_old;
+extern int s_DiffVarValueP_new;
+extern int s_DiffVarValueQ;
+
+int GetDistancePlus( Cube * pC1, Cube * pC2 )
+// finds and returns the distance between two cubes pC1 and pC2
+// if the distance is 1, returns the number of diff variable in VarNum
+{
+    int i;
+
+    DiffVarCounter = 0;
+    LastNonZeroWordNum = -1;
+    for ( i = 0; i < g_CoverInfo.nWordsIn; i++ )
+    {
+        Temp1 = pC1->pCubeDataIn[i] ^ pC2->pCubeDataIn[i];
+        Temp2 = (Temp1|(Temp1>>1)) & DIFFERENT;
+
+        // save the value of var difference, in case 
+        // the distance is one and we need to return the var number
+        if ( Temp2 )
+        {
+            LastNonZeroWordNum = i;
+            LastNonZeroWord = Temp2;
+        }
+
+        // count how many bits are one in this var difference
+        DiffVarCounter  += BIT_COUNT(Temp2);
+        if ( DiffVarCounter > 4 )
+            return 5;
+    }
+    // check whether the output parts are different
+    for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
+        if ( pC1->pCubeDataOut[i] ^ pC2->pCubeDataOut[i] )
+        {
+            DiffVarCounter++;
+            break;
+        }
+
+    if ( DiffVarCounter == 1 )
+    {
+        if ( LastNonZeroWordNum == -1 ) // the output is the only different variable
+            s_DiffVarNum = -1;
+        else
+        {
+            Temp = (LastNonZeroWord>>2);
+            for ( i = 0; Temp; Temp>>=2, i++ );
+            s_DiffVarNum = LastNonZeroWordNum*BPI/2 + i;
+
+            // save the old var value
+            s_DiffVarValueP_old = GetVar( pC1, s_DiffVarNum );
+            s_DiffVarValueQ = GetVar( pC2, s_DiffVarNum );
+
+            // EXOR this value with the corresponding value in p cube           
+            ExorVar( pC1, s_DiffVarNum, (varvalue)s_DiffVarValueQ );
+
+            s_DiffVarValueP_new = GetVar( pC1, s_DiffVarNum );
+        }
+    }
+
+    return DiffVarCounter;
+}
+
+int FindDiffVars( int * pDiffVars, Cube * pC1, Cube * pC2 )
+// determine different variables in two cubes and 
+// writes them into pDiffVars[]
+// -1 is written into pDiffVars[0] if the cubes have different outputs
+// returns the number of different variables (including the output)
+{
+    int i, v;
+    DiffVarCounter = 0;
+    // check whether the output parts of the cubes are different
+
+    for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
+        if ( pC1->pCubeDataOut[i] != pC2->pCubeDataOut[i] )
+        { // they are different
+            pDiffVars[0] = -1;
+            DiffVarCounter = 1;
+            break;
+        }
+
+    for ( i = 0; i < g_CoverInfo.nWordsIn; i++ )
+    {
+
+        Temp1 = pC1->pCubeDataIn[i] ^ pC2->pCubeDataIn[i];
+        Temp2 = (Temp1|(Temp1>>1)) & DIFFERENT;
+
+        // check the first part of this word
+        Temp = Temp2 & 0xffff;
+        cVars = BitCount[ Temp ];
+        if ( cVars )
+        {
+            if ( cVars < 5 )
+                for ( v = 0; v < cVars; v++ )
+                {
+                    assert( BitGroupNumbers[Temp] != MARKNUMBER );
+                    pDiffVars[ DiffVarCounter++ ] = i*16 + GroupLiterals[ BitGroupNumbers[Temp] ][v];
+                }
+            else
+                return 5;
+        }
+        if ( DiffVarCounter > 4 )
+            return 5;
+
+        // check the second part of this word
+        Temp = Temp2 >> 16;
+        cVars = BitCount[ Temp ];
+        if ( cVars )
+        {
+            if ( cVars < 5 )
+                for ( v = 0; v < cVars; v++ )
+                {
+                    assert( BitGroupNumbers[Temp] != MARKNUMBER );
+                    pDiffVars[ DiffVarCounter++ ] = i*16 + 8 + GroupLiterals[ BitGroupNumbers[Temp] ][v];
+                }
+            else
+                return 5;
+        }
+        if ( DiffVarCounter > 4 )
+            return 5;
+    }
+    return DiffVarCounter;
+}
+
+void InsertVars( Cube * pC, int * pVars, int nVarsIn, int * pVarValues )
+// corrects the given number of variables (nVarsIn) in pC->pCubeDataIn[]
+// variable numbers are given in pVarNumbers[], their values are in pVarValues[]
+// arrays pVarNumbers[] and pVarValues[] are provided by the user
+{
+    int GlobalBit;
+    int LocalWord;
+    int LocalBit;
+    int i;
+    assert( nVarsIn > 0 && nVarsIn <= g_CoverInfo.nVarsIn );
+    for ( i = 0; i < nVarsIn; i++ )
+    {
+        assert( pVars[i] >= 0 && pVars[i] < g_CoverInfo.nVarsIn );
+        assert( pVarValues[i] == VAR_NEG || pVarValues[i] == VAR_POS || pVarValues[i] == VAR_ABS );
+        GlobalBit = (pVars[i]<<1);
+        LocalWord = VarWord(GlobalBit);
+        LocalBit  = VarBit(GlobalBit);
+
+        // correct this variables
+        pC->pCubeDataIn[LocalWord] = ((pC->pCubeDataIn[LocalWord]&(~(3<<LocalBit)))|(pVarValues[i]<<LocalBit));
+    }
+}
+
+void InsertVarsWithoutClearing( Cube * pC, int * pVars, int nVarsIn, int * pVarValues, int Output )
+// corrects the given number of variables (nVarsIn) in pC->pCubeDataIn[]
+// variable numbers are given in pVarNumbers[], their values are in pVarValues[]
+// arrays pVarNumbers[] and pVarValues[] are provided by the user
+{
+    int GlobalBit;
+    int LocalWord;
+    int LocalBit;
+    int i;
+    assert( nVarsIn > 0 && nVarsIn <= g_CoverInfo.nVarsIn );
+    for ( i = 0; i < nVarsIn; i++ )
+    {
+        assert( pVars[i] >= 0 && pVars[i] < g_CoverInfo.nVarsIn );
+        assert( pVarValues[i] == VAR_NEG || pVarValues[i] == VAR_POS || pVarValues[i] == VAR_ABS );
+        GlobalBit = (pVars[i]<<1);
+        LocalWord = VarWord(GlobalBit);
+        LocalBit  = VarBit(GlobalBit);
+
+        // correct this variables
+        pC->pCubeDataIn[LocalWord] |= ( pVarValues[i] << LocalBit );
+    }
+    // insert the output bit
+    pC->pCubeDataOut[VarWord(Output)] |= ( 1 << VarBit(Output) );
+}
+
+///////////////////////////////////////////////////////////////////
+////////////              End of File             /////////////////
+///////////////////////////////////////////////////////////////////
+
+
+}
diff --git a/lib/abcesop/exorCubes.cpp b/lib/abcesop/exorCubes.cpp
new file mode 100644
index 0000000..35a1d2a
--- /dev/null
+++ b/lib/abcesop/exorCubes.cpp
@@ -0,0 +1,190 @@
+/**CFile****************************************************************
+
+  FileName    [exorCubes.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Exclusive sum-of-product minimization.]
+
+  Synopsis    [Cube manipulation.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: exorCubes.c,v 1.0 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+////////////////////////////////////////////////////////////////////////
+///                                                                  ///
+///                  Implementation of EXORCISM - 4                  ///
+///              An Exclusive Sum-of-Product Minimizer               ///
+///                                                                  ///
+///               Alan Mishchenko  <alanmi@ee.pdx.edu>               ///
+///                                                                  ///
+////////////////////////////////////////////////////////////////////////
+///                                                                  ///
+///              Cube Allocation and Free Cube Management            ///
+///                                                                  ///
+///  Ver. 1.0. Started - July 18, 2000. Last update - July 20, 2000  ///
+///  Ver. 1.1. Started - July 24, 2000. Last update - July 29, 2000  ///
+///  Ver. 1.2. Started - July 30, 2000. Last update - July 30, 2000  ///
+///  Ver. 1.5. Started -  Aug 19, 2000. Last update -  Aug 19, 2000  ///
+///                                                                  ///
+////////////////////////////////////////////////////////////////////////
+///   This software was tested with the BDD package "CUDD", v.2.3.0  ///
+///                          by Fabio Somenzi                        ///
+///                  http://vlsi.colorado.edu/~fabio/                ///
+////////////////////////////////////////////////////////////////////////
+
+#include "eabc/exor.h"
+
+namespace abc::exorcism {
+
+////////////////////////////////////////////////////////////////////////
+///                       EXTERNAL FUNCTIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                       EXTERNAL VARIABLES                         ///
+////////////////////////////////////////////////////////////////////////
+
+// information about the cube cover before and after simplification
+extern cinfo g_CoverInfo;
+
+////////////////////////////////////////////////////////////////////////
+///                    FUNCTIONS OF THIS MODULE                      ///
+////////////////////////////////////////////////////////////////////////
+
+// cube cover memory allocation/delocation procedures
+// (called from the ExorMain module)
+int AllocateCover( int nCubes, int nWordsIn, int nWordsOut );
+void DelocateCover();
+
+// manipulation of the free cube list
+// (called from Pseudo-Kronecker, ExorList, and ExorLink modules)
+void AddToFreeCubes( Cube * pC );
+Cube * GetFreeCube();
+
+////////////////////////////////////////////////////////////////////////
+///                      EXPORTED VARIABLES                          ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                      STATIC VARIABLES                            ///
+////////////////////////////////////////////////////////////////////////
+
+// the pointer to the allocated memory
+Cube ** s_pCoverMemory;
+
+// the list of free cubes
+Cube * s_CubesFree;
+
+///////////////////////////////////////////////////////////////////
+///                  CUBE COVER MEMORY MANAGEMENT                //
+///////////////////////////////////////////////////////////////////
+
+int AllocateCover( int nCubes, int nWordsIn, int nWordsOut )
+// uses the cover parameters nCubes and nWords
+// to allocate-and-clean the cover in one large piece
+{
+    int OneCubeSize;
+    int OneInputSetSize;
+    Cube ** pp;
+    int TotalSize;
+    int i, k;
+
+    // determine the size of one cube WITH storage for bits
+    OneCubeSize = sizeof(Cube) + (nWordsIn+nWordsOut)*sizeof(unsigned);
+    // determine what is the amount of storage for the input part of the cube 
+    OneInputSetSize = nWordsIn*sizeof(unsigned);
+
+    // allocate memory for the array of pointers
+    pp = (Cube **)ABC_ALLOC( Cube *, nCubes );
+    if ( pp == NULL )
+        return 0;
+
+    // determine the size of the total cube cover
+    TotalSize = nCubes*OneCubeSize;
+    // allocate and clear memory for the cover in one large piece
+    pp[0] = (Cube *)ABC_ALLOC( char, TotalSize );
+    if ( pp[0] == NULL )
+        return 0;
+    memset( pp[0], 0, (size_t)TotalSize );
+
+    // assign pointers to cubes and bit strings inside this piece
+    pp[0]->pCubeDataIn  = (unsigned*)(pp[0] + 1);
+    pp[0]->pCubeDataOut = (unsigned*)((char*)pp[0]->pCubeDataIn + OneInputSetSize);
+    for ( i = 1; i < nCubes; i++ )
+    {
+        pp[i] = (Cube *)((char*)pp[i-1] + OneCubeSize);
+        pp[i]->pCubeDataIn = (unsigned*)(pp[i] + 1);
+        pp[i]->pCubeDataOut = (unsigned*)((char*)pp[i]->pCubeDataIn + OneInputSetSize);
+    }
+
+    // connect the cubes into the list using Next pointers
+    for ( k = 0; k < nCubes-1; k++ )
+        pp[k]->Next = pp[k+1];
+    // the last pointer is already set to NULL
+
+    // assign the head of the free list
+    s_CubesFree = pp[0];
+    // set the counters of the used and free cubes
+    g_CoverInfo.nCubesInUse = 0;
+    g_CoverInfo.nCubesFree = nCubes;
+
+    // save the pointer to the allocated memory
+    s_pCoverMemory = pp;
+
+    assert ( g_CoverInfo.nCubesInUse + g_CoverInfo.nCubesFree == g_CoverInfo.nCubesAlloc );
+
+    return nCubes*sizeof(Cube *) + TotalSize;
+}
+
+void DelocateCover()
+{
+    ABC_FREE( s_pCoverMemory[0] );
+    ABC_FREE( s_pCoverMemory );
+}
+
+///////////////////////////////////////////////////////////////////
+///           FREE CUBE LIST MANIPULATION FUNCTIONS             ///
+///////////////////////////////////////////////////////////////////
+
+void AddToFreeCubes( Cube * p )
+{
+    assert( p );
+    assert( p->Prev == NULL ); // the cube should not be in use
+    assert( p->Next == NULL );
+    assert( p->ID );
+
+    p->Next = s_CubesFree;
+    s_CubesFree = p;
+
+    // set the ID of the cube to 0, 
+    // so that cube pair garbage collection could recognize it as different
+    p->ID = 0;
+
+    g_CoverInfo.nCubesFree++;
+}
+
+Cube * GetFreeCube()
+{
+    Cube * p;
+    assert( s_CubesFree );
+    p = s_CubesFree;
+    s_CubesFree = s_CubesFree->Next;
+    p->Next = NULL;
+    g_CoverInfo.nCubesFree--;
+    return p;
+}
+
+///////////////////////////////////////////////////////////////////
+////////////              End of File             /////////////////
+///////////////////////////////////////////////////////////////////
+
+
+}
diff --git a/lib/abcesop/exorLink.cpp b/lib/abcesop/exorLink.cpp
new file mode 100644
index 0000000..634ec77
--- /dev/null
+++ b/lib/abcesop/exorLink.cpp
@@ -0,0 +1,749 @@
+/**CFile****************************************************************
+
+  FileName    [exorLink.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Exclusive sum-of-product minimization.]
+
+  Synopsis    [Cube iterators.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: exorLink.c,v 1.0 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+////////////////////////////////////////////////////////////////////////
+///                                                                  ///
+///                  Implementation of EXORCISM - 4                  ///
+///              An Exclusive Sum-of-Product Minimizer               ///
+///                                                                  ///
+///               Alan Mishchenko  <alanmi@ee.pdx.edu>               ///
+///                                                                  ///
+////////////////////////////////////////////////////////////////////////
+///                                                                  ///
+///                 Generation of ExorLinked Cubes                   ///
+///                                                                  ///
+///  Ver. 1.0. Started - July 26, 2000. Last update - July 29, 2000  ///
+///  Ver. 1.4. Started -  Aug 10, 2000. Last update -  Aug 12, 2000  ///
+///                                                                  ///
+////////////////////////////////////////////////////////////////////////
+///   This software was tested with the BDD package "CUDD", v.2.3.0  ///
+///                          by Fabio Somenzi                        ///
+///                  http://vlsi.colorado.edu/~fabio/                ///
+////////////////////////////////////////////////////////////////////////
+
+#include "eabc/exor.h"
+
+namespace abc::exorcism {
+
+////////////////////////////////////////////////////////////////////////
+///                       MACRO DEFINITIONS                          ///
+////////////////////////////////////////////////////////////////////////
+
+#define LARGE_NUM 1000000
+
+////////////////////////////////////////////////////////////////////////
+///                 EXTERNAL FUNCTION DECLARATIONS                   ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                    FUNCTIONS OF THIS MODULE                      ///
+////////////////////////////////////////////////////////////////////////
+
+int ExorLinkCubeIteratorStart( Cube** pGroup, Cube* pC1, Cube* pC2, cubedist Dist );
+// this function starts the Exor-Link iterator, which iterates
+// through the cube groups starting from the group with min literals
+// returns 1 on success, returns 0 if the cubes have wrong distance
+
+int ExorLinkCubeIteratorNext( Cube** pGroup );
+// give the next group in the decreasing order of sum of literals
+// returns 1 on success, returns 0 if there are no more groups
+
+int ExorLinkCubeIteratorPick( Cube** pGroup, int g );
+// gives the group #g in the order in which the groups were given
+// during iteration
+// returns 1 on success, returns 0 if something g is too large
+
+void ExorLinkCubeIteratorCleanUp( int fTakeLastGroup );
+// removes the cubes from the store back into the list of free cubes
+// if fTakeLastGroup is 0, removes all cubes
+// if fTakeLastGroup is 1, does not store the last group
+
+////////////////////////////////////////////////////////////////////////
+///                       EXTERNAL VARIABLES                         ///
+////////////////////////////////////////////////////////////////////////
+
+// information about the cube cover before
+extern cinfo g_CoverInfo;
+// new IDs are assigned only when it is known that the cubes are useful
+// this is done in ExorLinkCubeIteratorCleanUp();
+
+// the head of the list of free cubes
+extern Cube* g_CubesFree;
+
+extern byte BitCount[];
+
+////////////////////////////////////////////////////////////////////////
+///                         EXORLINK INFO                            ///
+////////////////////////////////////////////////////////////////////////
+
+const int s_ELMax = 4;
+
+// ExorLink-2: there are 4 cubes,  2 literals each, combined into 2 groups
+// ExorLink-3: there are 12 cubes, 3 literals each, combined into 6 groups
+// ExorLink-4: there are 32 cubes, 4 literals each, combined into 24 groups
+// ExorLink-5: there are 80 cubes, 5 literals each, combined into 120 groups
+// Exorlink-n: there are n*2^(n-1) cubes, n literals each, combined into n! groups
+const int s_ELnCubes[4]  = { 4, 12, 32, 80 };
+const int s_ELnGroups[4] = { 2,  6, 24, 120 };
+
+// value sets of cubes X{a0}Y{b0}Z{c0}U{d0} and X{a1}Y{b1}Z{c1}U{d1}
+// used to represent the ExorLink cube generation rules
+enum { vs0, vs1, vsX };
+// vs0 = 0, // the value set of the first cube 
+// vs1 = 1, // the value set of the second cube
+// vsX = 2  // EXOR of the value sets of the first and second cubes
+
+// representation of ExorLinked cubes
+static int s_ELCubeRules[3][32][4]  = {
+{ // ExorLink-2 Cube Generating Rules
+                       // | 0 | 1 | - sections
+                       // |-------|
+    {vsX,vs0}, // cube 0  |   |   |
+    {vsX,vs1}, // cube 1  |   | 0 |
+    {vs0,vsX}, // cube 2  |   |   |
+    {vs1,vsX}  // cube 3  | 0 |   |
+},
+{ // ExorLink-3 Cube Generating Rules
+                            // | 0 | 1 | 2 | - sections
+                            // |-----------|
+    {vsX,vs0,vs0}, // cube 0   |   |   |   |
+    {vsX,vs0,vs1}, // cube 1   |   |   | 0 |
+    {vsX,vs1,vs0}, // cube 2   |   | 0 |   |
+    {vsX,vs1,vs1}, // cube 3   |   | 1 | 1 |
+
+    {vs0,vsX,vs0}, // cube 4   |   |   |   |
+    {vs0,vsX,vs1}, // cube 5   |   |   | 2 |
+    {vs1,vsX,vs0}, // cube 6   | 0 |   |   |
+    {vs1,vsX,vs1}, // cube 7   | 1 |   | 3 |
+
+    {vs0,vs0,vsX}, // cube 8   |   |   |   |
+    {vs0,vs1,vsX}, // cube 9   |   | 2 |   |
+    {vs1,vs0,vsX}, // cube 10  | 2 |   |   |
+    {vs1,vs1,vsX}  // cube 11  | 3 | 3 |   |
+},
+{ // ExorLink-4 Rules Generating Rules
+                                // | 0 | 1 | 2 | 4 | - sections
+                                // |---------------|
+    {vsX,vs0,vs0,vs0}, // cube 0   |   |   |   |   |
+    {vsX,vs0,vs0,vs1}, // cube 1   |   |   |   | 0 |
+    {vsX,vs0,vs1,vs0}, // cube 2   |   |   | 0 |   |
+    {vsX,vs0,vs1,vs1}, // cube 3   |   |   | 1 | 1 |
+    {vsX,vs1,vs0,vs0}, // cube 4   |   | 0 |   |   |
+    {vsX,vs1,vs0,vs1}, // cube 5   |   | 1 |   | 2 |
+    {vsX,vs1,vs1,vs0}, // cube 6   |   | 2 | 2 |   |
+    {vsX,vs1,vs1,vs1}, // cube 7   |   | 3 | 3 | 3 |
+
+    {vs0,vsX,vs0,vs0}, // cube 8   |   |   |   |   |
+    {vs0,vsX,vs0,vs1}, // cube 9   |   |   |   | 4 |
+    {vs0,vsX,vs1,vs0}, // cube 10  |   |   | 4 |   |
+    {vs0,vsX,vs1,vs1}, // cube 11  |   |   | 5 | 5 |
+    {vs1,vsX,vs0,vs0}, // cube 12  | 0 |   |   |   |
+    {vs1,vsX,vs0,vs1}, // cube 13  | 1 |   |   | 6 |
+    {vs1,vsX,vs1,vs0}, // cube 14  | 2 |   | 6 |   |
+    {vs1,vsX,vs1,vs1}, // cube 15  | 3 |   | 7 | 7 |
+
+    {vs0,vs0,vsX,vs0}, // cube 16  |   |   |   |   |
+    {vs0,vs0,vsX,vs1}, // cube 17  |   |   |   | 8 |
+    {vs0,vs1,vsX,vs0}, // cube 18  |   | 4 |   |   |
+    {vs0,vs1,vsX,vs1}, // cube 19  |   | 5 |   | 9 |
+    {vs1,vs0,vsX,vs0}, // cube 20  | 4 |   |   |   |
+    {vs1,vs0,vsX,vs1}, // cube 21  | 5 |   |   | 10|
+    {vs1,vs1,vsX,vs0}, // cube 22  | 6 | 6 |   |   |
+    {vs1,vs1,vsX,vs1}, // cube 23  | 7 | 7 |   | 11|
+
+    {vs0,vs0,vs0,vsX}, // cube 24  |   |   |   |   |
+    {vs0,vs0,vs1,vsX}, // cube 25  |   |   | 8 |   |
+    {vs0,vs1,vs0,vsX}, // cube 26  |   | 8 |   |   |
+    {vs0,vs1,vs1,vsX}, // cube 27  |   | 9 | 9 |   |
+    {vs1,vs0,vs0,vsX}, // cube 28  | 8 |   |   |   |
+    {vs1,vs0,vs1,vsX}, // cube 29  | 9 |   | 10|   |
+    {vs1,vs1,vs0,vsX}, // cube 30  | 10| 10|   |   |
+    {vs1,vs1,vs1,vsX}  // cube 31  | 11| 11| 11|   |
+}
+};
+
+// these cubes are combined into groups
+static int s_ELGroupRules[3][24][4] = { 
+{ // ExorLink-2 Group Forming Rules
+    {0,3},  // group 0 - section 0
+    {2,1}   // group 1 - section 1
+},
+{ // ExorLink-3 Group Forming Rules
+    {0,6,11}, // group 0 - section 0 
+    {0,7,10}, // group 1
+    {4,2,11}, // group 2 - section 1 
+    {4,3,9},  // group 3
+    {8,1,7},  // group 4 - section 2 
+    {8,3,5}   // group 5
+},
+{ // ExorLink-4 Group Forming Rules 
+// section 0: (0-12)(1-13)(2-14)(3-15)(4-20)(5-21)(6-22)(7-23)(8-28)(9-29)(10-30)(11-31)
+    {0,12,22,31},  // group 0       // {0,6,11}, // group 0  - section 0
+    {0,12,23,30},  // group 1       // {0,7,10}, // group 1
+    {0,20,14,31},  // group 2       // {4,2,11}, // group 2
+    {0,20,15,29},  // group 3       // {4,3,9},  // group 3
+    {0,28,13,23},  // group 4       // {8,1,7},  // group 4
+    {0,28,15,21},  // group 5       // {8,3,5}   // group 5
+// section 1: (0-4)(1-5)(2-6)(3-7)(4-18)(5-19)(6-22)(7-23)(8-26)(9-27)(10-30)(11-31)
+    {8,4,22,31},   // group 6
+    {8,4,23,30},   // group 7
+    {8,18,6,31},   // group 8
+    {8,18,7,27},   // group 9
+    {8,26,5,23},   // group 10
+    {8,26,7,19},   // group 11
+// section 2: (0-2)(1-3)(2-6)(3-7)(4-10)(5-11)(6-14)(7-15)(8-25)(9-27)(10-29)(11-31)
+    {16,2,14,31},  // group 12
+    {16,2,15,29},  // group 13
+    {16,10,6,31},  // group 14
+    {16,10,7,27},  // group 15
+    {16,25,3,15},  // group 16
+    {16,25,7,11},  // group 17
+// section 3: (0-1)(1-3)(2-5)(3-7)(4-9)(5-11)(6-13)(7-15)(8-17)(9-19)(10-21)(11-23)
+    {24,1,13,23},  // group 18
+    {24,1,15,21},  // group 19
+    {24,9, 5,23},  // group 20
+    {24,9, 7,19},  // group 21
+    {24,17,3,15},  // group 22
+    {24,17,7,11}   // group 23
+}
+};
+
+// it is assumed that if literals in the first cube, second cube 
+// and their EXOR are 0 or 1 (as opposed to -), they are written
+// into a mask, which is used to count the number of literals in 
+// the cube groups cubes
+//
+// below is the set of masks selecting literals belonging
+// to the given cube of the group
+
+static drow s_CubeLitMasks[3][32] = { 
+{  // ExorLink-2 Literal Counting Masks
+//                      v3   v2   v1   v0
+//                     -xBA -xBA -xBA -xBA  
+//                     -------------------
+    0x14,  // cube 0  <0000 0000 0001 0100> {vsX,vs0}
+    0x24,  // cube 1  <0000 0000 0010 0100> {vsX,vs1}
+    0x41,  // cube 2  <0000 0000 0100 0001> {vs0,vsX}
+    0x42,  // cube 3  <0000 0000 0100 0010> {vs1,vsX}
+},
+{  // ExorLink-3 Literal Counting Masks
+    0x114, // cube 0  <0000 0001 0001 0100> {vsX,vs0,vs0}
+    0x214, // cube 1  <0000 0010 0001 0100> {vsX,vs0,vs1}
+    0x124, // cube 2  <0000 0001 0010 0100> {vsX,vs1,vs0}
+    0x224, // cube 3  <0000 0010 0010 0100> {vsX,vs1,vs1}
+    0x141, // cube 4  <0000 0001 0100 0001> {vs0,vsX,vs0}
+    0x241, // cube 5  <0000 0010 0100 0001> {vs0,vsX,vs1}
+    0x142, // cube 6  <0000 0001 0100 0010> {vs1,vsX,vs0}
+    0x242, // cube 7  <0000 0010 0100 0010> {vs1,vsX,vs1}
+    0x411, // cube 8  <0000 0100 0001 0001> {vs0,vs0,vsX}
+    0x421, // cube 9  <0000 0100 0010 0001> {vs0,vs1,vsX}
+    0x412, // cube 10 <0000 0100 0001 0010> {vs1,vs0,vsX}
+    0x422, // cube 11 <0000 0100 0010 0010> {vs1,vs1,vsX}
+},
+{  // ExorLink-4 Literal Counting Masks
+    0x1114, // cube 0   <0001 0001 0001 0100> {vsX,vs0,vs0,vs0}
+    0x2114, // cube 1   <0010 0001 0001 0100> {vsX,vs0,vs0,vs1}
+    0x1214, // cube 2   <0001 0010 0001 0100> {vsX,vs0,vs1,vs0}
+    0x2214, // cube 3   <0010 0010 0001 0100> {vsX,vs0,vs1,vs1}
+    0x1124, // cube 4   <0001 0001 0010 0100> {vsX,vs1,vs0,vs0}
+    0x2124, // cube 5   <0010 0001 0010 0100> {vsX,vs1,vs0,vs1}
+    0x1224, // cube 6   <0001 0010 0010 0100> {vsX,vs1,vs1,vs0}
+    0x2224, // cube 7   <0010 0010 0010 0100> {vsX,vs1,vs1,vs1}
+    0x1141, // cube 8   <0001 0001 0100 0001> {vs0,vsX,vs0,vs0}
+    0x2141, // cube 9   <0010 0001 0100 0001> {vs0,vsX,vs0,vs1}
+    0x1241, // cube 10  <0001 0010 0100 0001> {vs0,vsX,vs1,vs0}
+    0x2241, // cube 11  <0010 0010 0100 0001> {vs0,vsX,vs1,vs1}
+    0x1142, // cube 12  <0001 0001 0100 0010> {vs1,vsX,vs0,vs0}
+    0x2142, // cube 13  <0010 0001 0100 0010> {vs1,vsX,vs0,vs1}
+    0x1242, // cube 14  <0001 0010 0100 0010> {vs1,vsX,vs1,vs0}
+    0x2242, // cube 15  <0010 0010 0100 0010> {vs1,vsX,vs1,vs1}
+    0x1411, // cube 16  <0001 0100 0001 0001> {vs0,vs0,vsX,vs0}
+    0x2411, // cube 17  <0010 0100 0001 0001> {vs0,vs0,vsX,vs1}
+    0x1421, // cube 18  <0001 0100 0010 0001> {vs0,vs1,vsX,vs0}
+    0x2421, // cube 19  <0010 0100 0010 0001> {vs0,vs1,vsX,vs1}
+    0x1412, // cube 20  <0001 0100 0001 0010> {vs1,vs0,vsX,vs0}
+    0x2412, // cube 21  <0010 0100 0001 0010> {vs1,vs0,vsX,vs1}
+    0x1422, // cube 22  <0001 0100 0010 0010> {vs1,vs1,vsX,vs0}
+    0x2422, // cube 23  <0010 0100 0010 0010> {vs1,vs1,vsX,vs1}
+    0x4111, // cube 24  <0100 0001 0001 0001> {vs0,vs0,vs0,vsX}
+    0x4211, // cube 25  <0100 0010 0001 0001> {vs0,vs0,vs1,vsX}
+    0x4121, // cube 26  <0100 0001 0010 0001> {vs0,vs1,vs0,vsX}
+    0x4221, // cube 27  <0100 0010 0010 0001> {vs0,vs1,vs1,vsX}
+    0x4112, // cube 28  <0100 0001 0001 0010> {vs1,vs0,vs0,vsX}
+    0x4212, // cube 29  <0100 0010 0001 0010> {vs1,vs0,vs1,vsX}
+    0x4122, // cube 30  <0100 0001 0010 0010> {vs1,vs1,vs0,vsX}
+    0x4222, // cube 31  <0100 0010 0010 0010> {vs1,vs1,vs1,vsX}
+}
+};
+
+static drow s_BitMasks[32] = 
+{
+    0x00000001,0x00000002,0x00000004,0x00000008,
+    0x00000010,0x00000020,0x00000040,0x00000080,
+    0x00000100,0x00000200,0x00000400,0x00000800,
+    0x00001000,0x00002000,0x00004000,0x00008000,
+    0x00010000,0x00020000,0x00040000,0x00080000,
+    0x00100000,0x00200000,0x00400000,0x00800000,
+    0x01000000,0x02000000,0x04000000,0x08000000,
+    0x10000000,0x20000000,0x40000000,0x80000000
+};
+
+////////////////////////////////////////////////////////////////////////
+///                        STATIC VARIABLES                          ///
+////////////////////////////////////////////////////////////////////////
+
+// this flag is TRUE as long as the storage is allocated
+static int fWorking;
+
+// set these flags to have minimum literal groups generated first
+static int fMinLitGroupsFirst[4] = { 0 /*dist2*/, 0 /*dist3*/, 0 /*dist4*/};
+
+static int nDist;
+static int nCubes;
+static int nCubesInGroup;
+static int nGroups;
+static Cube *pCA, *pCB;
+
+// storage for variable numbers that are different in the cubes
+static int DiffVars[5];
+static int* pDiffVars;
+static int nDifferentVars;
+
+// storage for the bits and words of different input variables
+static int nDiffVarsIn;
+static int DiffVarWords[5];
+static int DiffVarBits[5];
+
+// literal mask used to count the number of literals in the cubes
+static drow MaskLiterals;
+// the base for counting literals
+static int StartingLiterals;
+// the number of literals in each cube
+static int CubeLiterals[32];
+static int BitShift;
+static int DiffVarValues[4][3];
+static int Value;
+
+// the sorted array of groups in the increasing order of costs
+static int GroupCosts[32];
+static int GroupCostBest;
+static int GroupCostBestNum;
+
+static int CubeNum;
+static int NewZ;
+static drow Temp;
+
+// the cubes currently created
+static Cube* ELCubes[32];
+
+// the bit string with 1's corresponding to cubes in ELCubes[] 
+// that constitute the last group
+static drow LastGroup;
+
+static int  GroupOrder[24];
+static drow VisitedGroups;
+static int  nVisitedGroups;
+
+//int RemainderBits = (nVars*2)%(sizeof(drow)*8);
+//int TotalWords    = (nVars*2)/(sizeof(drow)*8) + (RemainderBits > 0);
+static drow DammyBitData[(MAXVARS*2)/(sizeof(drow)*8)+(MAXVARS*2)%(sizeof(drow)*8)];
+
+////////////////////////////////////////////////////////////////////////
+///                       FUNCTION DEFINTIONS                        ///
+////////////////////////////////////////////////////////////////////////
+
+// IDEA! if we already used a cube to count distances and it did not improve
+// there is no need to try it again with other group
+// (this idea works only for ExorLink-2 and -3)
+
+int ExorLinkCubeIteratorStart( Cube** pGroup, Cube* pC1, Cube* pC2, cubedist Dist )
+// this function starts the Exor-Link iterator, which iterates
+// through the cube groups starting from the group with min literals
+// returns 1 on success, returns 0 if the cubes have wrong distance
+{
+    int i, c;
+
+    // check that everything is okey
+    assert( pC1 != NULL );
+    assert( pC2 != NULL );
+    assert( !fWorking );
+
+    nDist = Dist;
+    nCubes = Dist + 2;
+    nCubesInGroup = s_ELnCubes[nDist];
+    nGroups = s_ELnGroups[Dist];
+    pCA = pC1;
+    pCB = pC2;
+    // find what variables are different in these two cubes
+    // FindDiffVars returns DiffVars[0] < 0, if the output is different
+    nDifferentVars = FindDiffVars( DiffVars, pCA, pCB );
+    if ( nCubes != nDifferentVars )
+    {
+//      cout << "ExorLinkCubeIterator(): Distance mismatch";
+//      cout << " nCubes = " << nCubes << " nDiffVars = " << nDifferentVars << endl;
+        fWorking = 0;
+        return 0;
+    }
+
+    // copy the input variable cube data into DammyBitData[]
+    for ( i = 0; i < g_CoverInfo.nWordsIn; i++ )
+        DammyBitData[i] = pCA->pCubeDataIn[i];
+
+    // find the number of different input variables
+    nDiffVarsIn = ( DiffVars[0] >= 0 )? nCubes: nCubes-1;
+    // assign the pointer to the place where the number of diff input vars is stored
+    pDiffVars   = ( DiffVars[0] >= 0 )? DiffVars: DiffVars+1;
+    // find the bit offsets and remove different variables
+    for ( i = 0; i < nDiffVarsIn; i++ )
+    {
+        DiffVarWords[i] = ((2*pDiffVars[i]) >> LOGBPI) ;
+        DiffVarBits[i]  = ((2*pDiffVars[i]) & BPIMASK);
+        // clear this position
+        DammyBitData[ DiffVarWords[i] ] &= ~( 3 << DiffVarBits[i] );
+    }
+
+    // extract the values from the cubes and create the mask of literals
+    MaskLiterals = 0;
+    // initialize the base for literal counts
+    StartingLiterals = pCA->a;
+    for ( i = 0, BitShift = 0; i < nDiffVarsIn; i++, BitShift++ )
+    {
+        DiffVarValues[i][0] = ( pCA->pCubeDataIn[DiffVarWords[i]] >> DiffVarBits[i] ) & 3;
+        if ( DiffVarValues[i][0] != VAR_ABS )
+        {
+            MaskLiterals |= ( 1 << BitShift );
+            // update the base for literal counts
+            StartingLiterals--;
+        }
+        BitShift++;
+
+        DiffVarValues[i][1] = ( pCB->pCubeDataIn[DiffVarWords[i]] >> DiffVarBits[i] ) & 3;
+        if ( DiffVarValues[i][1] != VAR_ABS )
+            MaskLiterals |= ( 1 << BitShift );
+        BitShift++;
+
+        DiffVarValues[i][2] = DiffVarValues[i][0] ^ DiffVarValues[i][1];
+        if ( DiffVarValues[i][2] != VAR_ABS )
+            MaskLiterals |= ( 1 << BitShift );
+        BitShift++;
+    }
+
+    // count the number of additional literals in each cube of the group
+    for ( i = 0; i < nCubesInGroup; i++ )
+        CubeLiterals[i] = BitCount[ MaskLiterals & s_CubeLitMasks[Dist][i] ];
+
+    // compute the costs of all groups
+    for ( i = 0; i < nGroups; i++ )
+        // go over all cubes in the group
+        for ( GroupCosts[i] = 0, c = 0; c < nCubes; c++ )
+            GroupCosts[i] += CubeLiterals[ s_ELGroupRules[Dist][i][c] ];
+
+    // find the best cost group
+    if ( fMinLitGroupsFirst[Dist] ) 
+    { // find the minimum cost group
+        GroupCostBest = LARGE_NUM;
+        for ( i = 0; i < nGroups; i++ )
+            if ( GroupCostBest > GroupCosts[i] )
+            {
+                GroupCostBest = GroupCosts[i];
+                GroupCostBestNum = i;
+            }
+    }
+    else 
+    { // find the maximum cost group
+        GroupCostBest = -1;
+        for ( i = 0; i < nGroups; i++ )
+            if ( GroupCostBest < GroupCosts[i] )
+            {
+                GroupCostBest = GroupCosts[i];
+                GroupCostBestNum = i;
+            }
+    }
+
+    // create the cubes with min number of literals needed for the group
+    LastGroup = 0;
+    for ( c = 0; c < nCubes; c++ )
+    {
+        CubeNum = s_ELGroupRules[Dist][GroupCostBestNum][c];
+        LastGroup |= s_BitMasks[CubeNum];
+
+        // bring a cube from the free cube list
+        ELCubes[CubeNum] = GetFreeCube();
+
+        // copy the input bit data into the cube 
+        for ( i = 0; i < g_CoverInfo.nWordsIn; i++ )
+            ELCubes[CubeNum]->pCubeDataIn[i] = DammyBitData[i];
+
+        // copy the output bit data into the cube
+        NewZ = 0;
+        if ( DiffVars[0] >= 0 ) // the output is not involved in ExorLink
+        {
+            for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
+                ELCubes[CubeNum]->pCubeDataOut[i] = pCA->pCubeDataOut[i];
+            NewZ = pCA->z;
+        }
+        else // the output is involved
+        { // determine where the output information comes from
+            Value = s_ELCubeRules[Dist][CubeNum][nDiffVarsIn];
+            if ( Value == vs0 )
+                for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
+                {
+                    Temp = pCA->pCubeDataOut[i];
+                    ELCubes[CubeNum]->pCubeDataOut[i] = Temp;
+                    NewZ += BIT_COUNT(Temp);
+                }
+            else if ( Value == vs1 )
+                for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
+                {
+                    Temp = pCB->pCubeDataOut[i];
+                    ELCubes[CubeNum]->pCubeDataOut[i] = Temp;
+                    NewZ += BIT_COUNT(Temp);
+                }
+            else if ( Value == vsX )
+                for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
+                {
+                    Temp = pCA->pCubeDataOut[i] ^ pCB->pCubeDataOut[i];
+                    ELCubes[CubeNum]->pCubeDataOut[i] = Temp;
+                    NewZ += BIT_COUNT(Temp);
+                }
+        }
+
+        // set the variables that should be there
+        for ( i = 0; i < nDiffVarsIn; i++ )
+        {
+            Value = DiffVarValues[i][ s_ELCubeRules[Dist][CubeNum][i] ];
+            ELCubes[CubeNum]->pCubeDataIn[ DiffVarWords[i] ] |= ( Value << DiffVarBits[i] );
+        }
+
+        // set the number of literals
+        ELCubes[CubeNum]->a = StartingLiterals + CubeLiterals[CubeNum];
+        ELCubes[CubeNum]->z = NewZ;
+        ELCubes[CubeNum]->q = ComputeQCostBits( ELCubes[CubeNum] );
+
+        // assign the ID
+        ELCubes[CubeNum]->ID = g_CoverInfo.cIDs++;
+        // skip through zero-ID
+        if ( g_CoverInfo.cIDs == 256 )
+            g_CoverInfo.cIDs = 1;
+
+        // prepare the return array
+        pGroup[c] = ELCubes[CubeNum];
+    }
+
+    // mark this group as visited 
+    VisitedGroups |= s_BitMasks[ GroupCostBestNum ];
+    // set the first visited group number
+    GroupOrder[0] = GroupCostBestNum;
+    // increment the counter of visited groups
+    nVisitedGroups = 1;
+    fWorking = 1;
+    return 1;
+}
+
+int ExorLinkCubeIteratorNext( Cube** pGroup )
+// give the next group in the decreasing order of sum of literals
+// returns 1 on success, returns 0 if there are no more groups
+{
+    int i, c;
+
+    // check that everything is okey
+    assert( fWorking );
+
+    if ( nVisitedGroups == nGroups ) 
+    // we have iterated through all groups
+        return 0;
+
+    // find the min/max cost group
+    if ( fMinLitGroupsFirst[nDist] ) 
+//  if ( nCubes == 4 ) 
+    { // find the minimum cost
+        // go through all groups
+        GroupCostBest = LARGE_NUM;
+        for ( i = 0; i < nGroups; i++ )
+            if ( !(VisitedGroups & s_BitMasks[i]) && GroupCostBest > GroupCosts[i] )
+            {
+                GroupCostBest = GroupCosts[i];
+                GroupCostBestNum = i;
+            }
+        assert( GroupCostBest != LARGE_NUM );
+    }
+    else 
+    { // find the maximum cost
+        // go through all groups
+        GroupCostBest = -1;
+        for ( i = 0; i < nGroups; i++ )
+            if ( !(VisitedGroups & s_BitMasks[i]) && GroupCostBest < GroupCosts[i] )
+            {
+                GroupCostBest = GroupCosts[i];
+                GroupCostBestNum = i;
+            }
+        assert( GroupCostBest != -1 );
+    }
+
+    // create the cubes needed for the group, if they are not created already
+    LastGroup = 0;
+    for ( c = 0; c < nCubes; c++ )
+    {
+        CubeNum = s_ELGroupRules[nDist][GroupCostBestNum][c];
+        LastGroup |= s_BitMasks[CubeNum];
+
+        if ( ELCubes[CubeNum] == NULL ) // this cube does not exist
+        {
+            // bring a cube from the free cube list
+            ELCubes[CubeNum] = GetFreeCube();
+
+            // copy the input bit data into the cube 
+            for ( i = 0; i < g_CoverInfo.nWordsIn; i++ )
+                ELCubes[CubeNum]->pCubeDataIn[i] = DammyBitData[i];
+
+            // copy the output bit data into the cube
+            NewZ = 0;
+            if ( DiffVars[0] >= 0 ) // the output is not involved in ExorLink
+            {
+                for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
+                    ELCubes[CubeNum]->pCubeDataOut[i] = pCA->pCubeDataOut[i];
+                NewZ = pCA->z;
+            }
+            else // the output is involved
+            { // determine where the output information comes from
+                Value = s_ELCubeRules[nDist][CubeNum][nDiffVarsIn];
+                if ( Value == vs0 )
+                    for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
+                    {
+                        Temp = pCA->pCubeDataOut[i];
+                        ELCubes[CubeNum]->pCubeDataOut[i] = Temp;
+                        NewZ += BIT_COUNT(Temp);
+                    }
+                else if ( Value == vs1 )
+                    for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
+                    {
+                        Temp = pCB->pCubeDataOut[i];
+                        ELCubes[CubeNum]->pCubeDataOut[i] = Temp;
+                        NewZ += BIT_COUNT(Temp);
+                    }
+                else if ( Value == vsX )
+                    for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
+                    {
+                        Temp = pCA->pCubeDataOut[i] ^ pCB->pCubeDataOut[i];
+                        ELCubes[CubeNum]->pCubeDataOut[i] = Temp;
+                        NewZ += BIT_COUNT(Temp);
+                    }
+            }
+
+            // set the variables that should be there
+            for ( i = 0; i < nDiffVarsIn; i++ )
+            {
+                Value = DiffVarValues[i][ s_ELCubeRules[nDist][CubeNum][i] ];
+                ELCubes[CubeNum]->pCubeDataIn[ DiffVarWords[i] ] |= ( Value << DiffVarBits[i] );
+            }
+
+            // set the number of literals and output ones
+            ELCubes[CubeNum]->a = StartingLiterals + CubeLiterals[CubeNum];
+            ELCubes[CubeNum]->z = NewZ;
+            ELCubes[CubeNum]->q = ComputeQCostBits( ELCubes[CubeNum] );
+            assert( NewZ != 255 );
+
+            // assign the ID
+            ELCubes[CubeNum]->ID = g_CoverInfo.cIDs++;
+            // skip through zero-ID
+            if ( g_CoverInfo.cIDs == 256 )
+                g_CoverInfo.cIDs = 1;
+
+        }
+        // prepare the return array
+        pGroup[c] = ELCubes[CubeNum];
+    }
+
+    // mark this group as visited 
+    VisitedGroups |= s_BitMasks[ GroupCostBestNum ];
+    // set the next visited group number and
+    // increment the counter of visited groups
+    GroupOrder[ nVisitedGroups++ ] = GroupCostBestNum;
+    return 1;
+}
+
+int ExorLinkCubeIteratorPick( Cube** pGroup, int g )
+// gives the group #g in the order in which the groups were given
+// during iteration
+// returns 1 on success, returns 0 if something is wrong (g is too large)
+{
+    int GroupNum, c;
+
+    assert( fWorking );
+    assert( g >= 0 && g < nGroups );
+    assert( VisitedGroups & s_BitMasks[g] );
+
+    GroupNum = GroupOrder[g];
+    // form the group
+    LastGroup = 0;
+    for ( c = 0; c < nCubes; c++ )
+    {
+        CubeNum = s_ELGroupRules[nDist][GroupNum][c];
+
+        // remember this group as the last one
+        LastGroup |= s_BitMasks[CubeNum];
+
+        assert( ELCubes[CubeNum] != NULL ); // this cube should exist
+        // prepare the return array
+        pGroup[c] = ELCubes[CubeNum];
+    }
+    return 1;
+}
+
+void ExorLinkCubeIteratorCleanUp( int fTakeLastGroup )
+// removes the cubes from the store back into the list of free cubes
+// if fTakeLastGroup is 0, removes all cubes
+// if fTakeLastGroup is 1, does not store the last group
+{
+    int c;
+    assert( fWorking );
+
+    // put cubes back
+    // set the cube pointers to zero
+    if ( fTakeLastGroup == 0 )
+        for ( c = 0; c < nCubesInGroup; c++ )
+        {
+            ELCubes[c]->fMark = 0;
+            AddToFreeCubes( ELCubes[c] );
+            ELCubes[c] = NULL;
+        }
+    else
+        for ( c = 0; c < nCubesInGroup; c++ )
+        if ( ELCubes[c] )
+        {
+            ELCubes[c]->fMark = 0;
+            if ( (LastGroup & s_BitMasks[c]) == 0 ) // does not belong to the last group
+                AddToFreeCubes( ELCubes[c] );
+            ELCubes[c] = NULL;
+        }
+
+    // set the cube groups to zero
+    VisitedGroups = 0;
+    // shut down the iterator
+    fWorking = 0;
+}
+
+    
+///////////////////////////////////////////////////////////////////
+////////////              End of File             /////////////////
+///////////////////////////////////////////////////////////////////
+
+
+}
diff --git a/lib/abcesop/exorList.cpp b/lib/abcesop/exorList.cpp
new file mode 100644
index 0000000..e3e1cbc
--- /dev/null
+++ b/lib/abcesop/exorList.cpp
@@ -0,0 +1,1156 @@
+/**CFile****************************************************************
+
+  FileName    [exorList.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Exclusive sum-of-product minimization.]
+
+  Synopsis    [Cube lists.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: exorList.c,v 1.0 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+////////////////////////////////////////////////////////////////////////
+///                                                                  ///
+///                  Implementation of EXORCISM - 4                  ///
+///              An Exclusive Sum-of-Product Minimizer               ///
+///                                                                  ///
+///               Alan Mishchenko  <alanmi@ee.pdx.edu>               ///
+///                                                                  ///
+////////////////////////////////////////////////////////////////////////
+///                                                                  ///
+///                 Iterative Cube Set Minimization                  ///
+///                  Iterative ExorLink Procedure                    ///
+///                  Support of Cube Pair Queques                    ///
+///                                                                  ///
+///  Ver. 1.0. Started - July 18, 2000. Last update - July 20, 2000  ///
+///  Ver. 1.1. Started - July 24, 2000. Last update - July 29, 2000  ///
+///  Ver. 1.2. Started - July 30, 2000. Last update - July 31, 2000  ///
+///  Ver. 1.4. Started -  Aug 10, 2000. Last update -  Aug 26, 2000  ///
+///  Ver. 1.5. Started -  Aug 30, 2000. Last update -  Aug 30, 2000  ///
+///  Ver. 1.6. Started -  Sep 11, 2000. Last update -  Sep 15, 2000  ///
+///  Ver. 1.7. Started -  Sep 20, 2000. Last update -  Sep 23, 2000  ///
+///                                                                  ///
+////////////////////////////////////////////////////////////////////////
+///   This software was tested with the BDD package "CUDD", v.2.3.0  ///
+///                          by Fabio Somenzi                        ///
+///                  http://vlsi.colorado.edu/~fabio/                ///
+////////////////////////////////////////////////////////////////////////
+
+#include "eabc/exor.h"
+
+namespace abc::exorcism {
+
+////////////////////////////////////////////////////////////////////////
+///                       EXTERNAL VARIABLES                         ///
+////////////////////////////////////////////////////////////////////////
+
+// information about options and the cover
+extern cinfo g_CoverInfo;
+
+// the look-up table for the number of 1's in unsigned short
+extern unsigned char BitCount[];
+
+////////////////////////////////////////////////////////////////////////
+///                       EXTERNAL FUNCTIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+extern int GetDistance( Cube* pC1, Cube* pC2 );
+// distance computation for two cubes
+extern int GetDistancePlus( Cube* pC1, Cube* pC2 );
+
+extern void ExorVar( Cube* pC, int Var, varvalue Val );
+
+extern void AddToFreeCubes( Cube* pC );
+// returns a simplified cube back into the free list
+
+//extern void PrintCube( ostream& DebugStream, Cube* pC );
+// debug output for cubes
+
+extern Cube* GetFreeCube();
+
+////////////////////////////////////////////////////////////////////////
+/// ExorLink Functions
+extern int ExorLinkCubeIteratorStart( Cube** pGroup, Cube* pC1, Cube* pC2, cubedist Dist );
+// this function starts the Exor-Link IteratorCubePair, which iterates
+// through the cube groups starting from the group with min literals
+// returns 1 on success, returns 0 if the cubes have wrong distance
+
+extern int ExorLinkCubeIteratorNext( Cube** pGroup );
+// give the next group in the decreasing order of sum of literals
+// returns 1 on success, returns 0 if there are no more groups
+
+extern int ExorLinkCubeIteratorPick( Cube** pGroup, int g );
+// gives the group #g in the order in which the groups were given
+// during iteration
+// returns 1 on success, returns 0 if something g is too large
+
+extern void ExorLinkCubeIteratorCleanUp( int fTakeLastGroup );
+// removes the cubes from the store back into the list of free cubes
+// if fTakeLastGroup is 0, removes all cubes
+// if fTakeLastGroup is 1, does not store the last group
+
+////////////////////////////////////////////////////////////////////////
+///                    FUNCTIONS OF THIS MODULE                      ///
+////////////////////////////////////////////////////////////////////////
+
+// iterative ExorLink
+int IterativelyApplyExorLink2( char fDistEnable );   
+int IterativelyApplyExorLink3( char fDistEnable );   
+int IterativelyApplyExorLink4( char fDistEnable );   
+
+// function which performs distance computation and simplifes on the fly
+// it is also called from the Pseudo-Kronecker module when cubes are added
+int CheckForCloseCubes( Cube* p, int fAddCube );
+int CheckAndInsert( Cube* p );
+
+// this function changes the cube back after it was DIST-1 transformed
+void UndoRecentChanges();
+
+////////////////////////////////////////////////////////////////////////
+// iterating through adjucency pair queques (with authomatic garbage collection)
+
+// start an iterator through cubes of dist CubeDist,
+// the resulting pointers are written into ppC1 and ppC2
+int IteratorCubePairStart( cubedist Dist, Cube** ppC1, Cube** ppC2 );
+// gives the next VALID cube pair (the previous one is automatically dequequed)
+int IteratorCubePairNext();
+
+////////////////////////////////////////////////////////////////////////
+// the cube storage
+
+// cube storage allocation/delocation
+int AllocateCubeSets( int nVarsIn, int nVarsOut );
+void DelocateCubeSets();
+
+// insert/extract a cube into/from the storage
+void CubeInsert( Cube* p );
+Cube* CubeExtract( Cube* p );
+
+////////////////////////////////////////////////////////////////////////
+// Cube Set Iterator
+Cube* IterCubeSetStart();
+// starts an iterator that traverses all the cubes in the ring
+Cube* IterCubeSetNext();
+// returns the next cube in the ring
+// to use it again after it has returned NULL, call IterCubeSetStart() first
+
+////////////////////////////////////////////////////////////////////////
+// cube adjacency queques
+
+// adjacency queque allocation/delocation procedures
+int AllocateQueques( int nPlaces );
+void DelocateQueques();
+
+// conditional adding cube pairs to queques
+// reset temporarily stored new range of cube pairs
+static void NewRangeReset();
+// add temporarily stored new range of cube pairs to the queque
+static void NewRangeAdd();
+// insert one cube pair into the new range
+static void NewRangeInsertCubePair( cubedist Dist, Cube* p1, Cube* p2 );
+
+static void MarkSet();
+static void MarkRewind();
+
+void PrintQuequeStats();
+int GetQuequeStats( cubedist Dist );
+
+// iterating through the queque (with authomatic garbage collection)
+// start an iterator through cubes of dist CubeDist,
+// the resulting pointers are written into ppC1 and ppC2
+int IteratorCubePairStart( cubedist Dist, Cube** ppC1, Cube** ppC2 );
+// gives the next VALID cube pair (the previous one is automatically dequequed)
+int IteratorCubePairNext();
+
+////////////////////////////////////////////////////////////////////////
+///                      EXPORTED VARIABLES                          ///
+////////////////////////////////////////////////////////////////////////`
+
+// the number of allocated places
+int s_nPosAlloc;
+// the maximum number of occupied places
+int s_nPosMax[3];
+
+////////////////////////////////////////////////////////////////////////
+///                      Minimization Strategy                       ///
+////////////////////////////////////////////////////////////////////////
+
+// 1) check that ExorLink for this cube pair can be performed
+//    (it may happen that the group is outdated due to recent reshaping)
+// 2) find out what is the improvement achieved by each cube group
+// 3) depending on the distance, do the following:
+//    a) if ( Dist == 2 ) 
+//           try both cube groups, 
+//           if one of them leads to improvement, take the cube group right away
+//           if none of them leads to improment
+//              - take the last one (because it reshapes)
+//              - take the last one only in case it does not increase literals
+//    b) if ( Dist == 3 )
+//           try groups one by one
+//           if one of them leads to improvement, take the group right away
+//           if none of them leads to improvement
+//              - take the group which reshapes
+//              - take the reshaping group only in case it does not increase literals
+//           if none of them leads to reshaping, do not take any of them
+//    c) if ( Dist == 4 )
+//           try groups one by one
+//           if one of the leads to reshaping, take it right away
+//           if none of them leads to reshaping, do not take any of them
+
+////////////////////////////////////////////////////////////////////////
+///                       STATIC VARIABLES                           ///
+////////////////////////////////////////////////////////////////////////
+
+// Cube set is a list of cubes
+static Cube* s_List;
+
+///////////////////////////////////////////////////////////////////////////
+// undo information
+///////////////////////////////////////////////////////////////////////////
+static struct
+{
+    int fInput;   // 1 if the input was changed
+    Cube* p;      // the pointer to the modified cube
+    int PrevQa;
+    int PrevPa;
+    int PrevQq;
+    int PrevPq;
+    int PrevPz;
+    int Var;      // the number of variable that was changed
+    int Value;    // the value what was there
+    int PrevID;   // the previous ID of the removed cube
+} s_ChangeStore;
+///////////////////////////////////////////////////////////////////////////
+
+// enable pair accumulation
+// from the begginning (while the starting cover is generated)
+// only the distance 2 accumulation is enabled
+static int s_fDistEnable2 = 1;
+static int s_fDistEnable3;
+static int s_fDistEnable4;
+
+// temporary storage for cubes generated by the ExorLink iterator
+static Cube* s_CubeGroup[5];
+// the marks telling whether the given cube is inserted
+static int s_fInserted[5];
+
+// enable selection only those Dist2 and Dist3 that do not increase literals
+int s_fDecreaseLiterals = 0;
+
+// the counters for display
+static int s_cEnquequed;
+static int s_cAttempts;
+static int s_cReshapes;
+
+// the number of cubes before ExorLink starts
+static int s_nCubesBefore;
+// the distance code specific for each ExorLink
+static cubedist s_Dist;
+
+// other variables
+static int s_Gain;
+static int s_GainTotal;
+static int s_GroupCounter;
+static int s_GroupBest;
+static Cube *s_pC1, *s_pC2;
+
+////////////////////////////////////////////////////////////////////////
+///                  Iterative ExorLink Operation                    ///
+////////////////////////////////////////////////////////////////////////
+
+int CheckAndInsert( Cube* p )
+{
+//  return CheckForCloseCubes( p, 1 );
+    CubeInsert( p );
+    return 0;
+}
+
+int IterativelyApplyExorLink2( char fDistEnable )   
+// MEMO: instead of inserting the cubes that have already been checked
+// by running CheckForCloseCubes again, try inserting them without checking
+// and observe the difference (it will save 50% of checking time)
+{
+    int z;
+
+    // this var is specific to ExorLink-2
+    s_Dist = (cubedist)0;
+
+    // enable pair accumulation
+    s_fDistEnable2 = fDistEnable & 1;
+    s_fDistEnable3 = fDistEnable & 2;
+    s_fDistEnable4 = fDistEnable & 4;
+
+    // initialize counters
+    s_cEnquequed = GetQuequeStats( s_Dist );
+    s_cAttempts  = 0;
+    s_cReshapes  = 0;
+
+    // remember the number of cubes before minimization
+    s_nCubesBefore = g_CoverInfo.nCubesInUse;
+
+    for ( z = IteratorCubePairStart( s_Dist, &s_pC1, &s_pC2 ); z; z = IteratorCubePairNext() )
+    {
+        s_cAttempts++;
+        // start ExorLink of the given Distance
+        if ( ExorLinkCubeIteratorStart( s_CubeGroup, s_pC1, s_pC2, s_Dist ) )
+        {
+            // extract old cubes from storage (to prevent EXORing with their derivitives)
+            CubeExtract( s_pC1 );
+            CubeExtract( s_pC2 );
+
+            // mark the current position in the cube pair queques
+            MarkSet();
+
+            // check the first group (generated by ExorLinkCubeIteratorStart())
+            if ( CheckForCloseCubes( s_CubeGroup[0], 0 ) ) 
+            {  // the first cube leads to improvement - it is already inserted
+                CheckForCloseCubes( s_CubeGroup[1], 1 ); // insert the second cube
+                goto SUCCESS;
+            }
+            if ( CheckForCloseCubes( s_CubeGroup[1], 0 ) ) 
+            {  // the second cube leads to improvement - it is already inserted
+                CheckForCloseCubes( s_CubeGroup[0], 1 ); // insert the first cube
+//              CheckAndInsert( s_CubeGroup[0] );
+                goto SUCCESS;
+            }
+            // the first group does not lead to improvement
+
+            // rewind to the previously marked position in the cube pair queques
+            MarkRewind();
+
+            // generate the second group
+            ExorLinkCubeIteratorNext( s_CubeGroup );
+
+            // check the second group
+            if ( CheckForCloseCubes( s_CubeGroup[0], 0 ) ) 
+            { // the first cube leads to improvement - it is already inserted
+                CheckForCloseCubes( s_CubeGroup[1], 1 ); // insert the second cube
+                goto SUCCESS;
+            }
+            if ( CheckForCloseCubes( s_CubeGroup[1], 0 ) ) 
+            { // the second cube leads to improvement - it is already inserted
+                CheckForCloseCubes( s_CubeGroup[0], 1 ); // insert the first cube
+//              CheckAndInsert( s_CubeGroup[0] );
+                goto SUCCESS;
+            }
+            // the second group does not lead to improvement
+
+            // decide whether to accept the second group, depending on literals
+            if ( s_fDecreaseLiterals )
+            {
+                if ( g_CoverInfo.fUseQCost ? 
+                     s_CubeGroup[0]->q + s_CubeGroup[1]->q >= s_pC1->q + s_pC2->q :
+                     s_CubeGroup[0]->a + s_CubeGroup[1]->a >= s_pC1->a + s_pC2->a ) 
+                // the group increases literals
+                { // do not take the last group
+                            
+                    // rewind to the previously marked position in the cube pair queques
+                    MarkRewind();
+
+                    // return the old cubes back to storage
+                    CubeInsert( s_pC1 );
+                    CubeInsert( s_pC2 );
+                    // clean the results of generating ExorLinked cubes
+                    ExorLinkCubeIteratorCleanUp( 0 );
+                    continue;
+                }
+            }
+
+            // take the last group
+            // there is no need to test these cubes again,
+            // because they have been tested and did not yield any improvement
+            CubeInsert( s_CubeGroup[0] );
+            CubeInsert( s_CubeGroup[1] );
+//          CheckForCloseCubes( s_CubeGroup[0], 1 ); 
+//          CheckForCloseCubes( s_CubeGroup[1], 1 ); 
+
+SUCCESS:
+            // clean the results of generating ExorLinked cubes
+            ExorLinkCubeIteratorCleanUp( 1 ); // take the last group
+            // free old cubes
+            AddToFreeCubes( s_pC1 );
+            AddToFreeCubes( s_pC2 );
+            // increate the counter
+            s_cReshapes++;
+        }
+    }
+    // print the report
+    if ( g_CoverInfo.Verbosity == 2 )
+    {
+    printf( "ExLink-%d", 2 );
+    printf( ": Que= %5d", s_cEnquequed );
+    printf( "  Att= %4d", s_cAttempts );
+    printf( "  Resh= %4d", s_cReshapes );
+    printf( "  NoResh= %4d", s_cAttempts - s_cReshapes );
+    printf( "  Cubes= %3d", g_CoverInfo.nCubesInUse );
+    printf( "  (%d)", s_nCubesBefore - g_CoverInfo.nCubesInUse );
+    printf( "  Lits= %5d", CountLiterals() );
+    printf( "  QCost = %6d", CountQCost() );
+    printf( "\n" );
+    }
+
+    // return the number of cubes gained in the process
+    return s_nCubesBefore - g_CoverInfo.nCubesInUse;
+}
+
+int IterativelyApplyExorLink3( char fDistEnable )   
+{
+    int z, c, d;
+    // this var is specific to ExorLink-3
+    s_Dist = (cubedist)1;
+
+    // enable pair accumulation
+    s_fDistEnable2 = fDistEnable & 1;
+    s_fDistEnable3 = fDistEnable & 2;
+    s_fDistEnable4 = fDistEnable & 4;
+
+    // initialize counters
+    s_cEnquequed = GetQuequeStats( s_Dist );
+    s_cAttempts  = 0;
+    s_cReshapes  = 0;
+
+    // remember the number of cubes before minimization
+    s_nCubesBefore = g_CoverInfo.nCubesInUse;
+
+    for ( z = IteratorCubePairStart( s_Dist, &s_pC1, &s_pC2 ); z; z = IteratorCubePairNext() )
+    {
+        s_cAttempts++;
+        // start ExorLink of the given Distance
+        if ( ExorLinkCubeIteratorStart( s_CubeGroup, s_pC1, s_pC2, s_Dist ) )
+        {
+            // extract old cubes from storage (to prevent EXORing with their derivitives)
+            CubeExtract( s_pC1 );
+            CubeExtract( s_pC2 );
+
+            // mark the current position in the cube pair queques
+            MarkSet();
+
+            // check cube groups one by one
+            s_GroupCounter = 0;
+            do  
+            {   // check the cubes of this group one by one
+                for ( c = 0; c < 3; c++ )
+                if ( !s_CubeGroup[c]->fMark ) // this cube has not yet been checked
+                {
+                    s_Gain = CheckForCloseCubes( s_CubeGroup[c], 0 ); // do not insert the cube, by default
+                    if ( s_Gain ) 
+                    { // this cube leads to improvement or reshaping - it is already inserted
+
+                        // decide whether to accept this group based on literal count
+                        if ( s_fDecreaseLiterals && s_Gain == 1 )
+                        if ( g_CoverInfo.fUseQCost ?
+                             s_CubeGroup[0]->q + s_CubeGroup[1]->q + s_CubeGroup[2]->q > s_pC1->q + s_pC2->q + s_ChangeStore.PrevQq :
+                             s_CubeGroup[0]->a + s_CubeGroup[1]->a + s_CubeGroup[2]->a > s_pC1->a + s_pC2->a + s_ChangeStore.PrevQa 
+                           ) // the group increases literals
+                        { // do not take this group
+                            // remember the group
+                            s_GroupBest = s_GroupCounter;
+                            // undo changes to be able to continue checking other groups
+                            UndoRecentChanges();
+                            break;
+                        }
+
+                        // take this group
+                        for ( d = 0; d < 3; d++ ) // insert other cubes
+                            if ( d != c )
+                            {
+                                CheckForCloseCubes( s_CubeGroup[d], 1 ); 
+//                              if ( s_CubeGroup[d]->fMark )
+//                                  CheckAndInsert( s_CubeGroup[d] );
+//                                  CheckOnlyOneCube( s_CubeGroup[d] );
+//                                  CheckForCloseCubes( s_CubeGroup[d], 1 ); 
+//                              else
+//                                  CheckForCloseCubes( s_CubeGroup[d], 1 ); 
+                            }
+
+                        // clean the results of generating ExorLinked cubes
+                        ExorLinkCubeIteratorCleanUp( 1 ); // take the last group
+                        // free old cubes
+                        AddToFreeCubes( s_pC1 );
+                        AddToFreeCubes( s_pC2 );
+                        // update the counter
+                        s_cReshapes++;
+                        goto END_OF_LOOP;
+                    }
+                    else // mark the cube as checked
+                        s_CubeGroup[c]->fMark = 1;
+                }
+                // the group is not taken - find the new group
+                s_GroupCounter++;
+                                        
+                // rewind to the previously marked position in the cube pair queques
+                MarkRewind();
+            } 
+            while ( ExorLinkCubeIteratorNext( s_CubeGroup ) );
+            // none of the groups leads to improvement
+
+            // return the old cubes back to storage
+            CubeInsert( s_pC1 );
+            CubeInsert( s_pC2 );
+            // clean the results of generating ExorLinked cubes
+            ExorLinkCubeIteratorCleanUp( 0 );
+        }
+END_OF_LOOP: {}
+    }
+
+    // print the report
+    if ( g_CoverInfo.Verbosity == 2 )
+    {
+    printf( "ExLink-%d", 3 );
+    printf( ": Que= %5d", s_cEnquequed );
+    printf( "  Att= %4d", s_cAttempts );
+    printf( "  Resh= %4d", s_cReshapes );
+    printf( "  NoResh= %4d", s_cAttempts - s_cReshapes );
+    printf( "  Cubes= %3d", g_CoverInfo.nCubesInUse );
+    printf( "  (%d)", s_nCubesBefore - g_CoverInfo.nCubesInUse );
+    printf( "  Lits= %5d", CountLiterals() );
+    printf( "  QCost = %6d", CountQCost() );
+    printf( "\n" );
+    }
+
+    // return the number of cubes gained in the process
+    return s_nCubesBefore - g_CoverInfo.nCubesInUse;
+}
+
+int IterativelyApplyExorLink4( char fDistEnable )   
+{
+    int z, c;
+    // this var is specific to ExorLink-4
+    s_Dist = (cubedist)2;
+
+    // enable pair accumulation
+    s_fDistEnable2 = fDistEnable & 1;
+    s_fDistEnable3 = fDistEnable & 2;
+    s_fDistEnable4 = fDistEnable & 4;
+
+    // initialize counters
+    s_cEnquequed = GetQuequeStats( s_Dist );
+    s_cAttempts  = 0;
+    s_cReshapes  = 0;
+
+    // remember the number of cubes before minimization
+    s_nCubesBefore = g_CoverInfo.nCubesInUse;
+
+    for ( z = IteratorCubePairStart( s_Dist, &s_pC1, &s_pC2 ); z; z = IteratorCubePairNext() )
+    {
+        s_cAttempts++;
+        // start ExorLink of the given Distance
+        if ( ExorLinkCubeIteratorStart( s_CubeGroup, s_pC1, s_pC2, s_Dist ) )
+        {
+            // extract old cubes from storage (to prevent EXORing with their derivitives)
+            CubeExtract( s_pC1 );
+            CubeExtract( s_pC2 );
+
+            // mark the current position in the cube pair queques
+            MarkSet();
+
+            // check cube groups one by one
+            do  
+            {   // check the cubes of this group one by one
+                s_GainTotal = 0;
+                for ( c = 0; c < 4; c++ )
+                if ( !s_CubeGroup[c]->fMark ) // this cube has not yet been checked
+                {
+                    s_Gain = CheckForCloseCubes( s_CubeGroup[c], 0 ); // do not insert the cube, by default
+                    // if the cube leads to gain, it is already inserted
+                    s_fInserted[c] = (int)(s_Gain>0);
+                    // increment the total gain
+                    s_GainTotal += s_Gain;
+                }
+                else
+                    s_fInserted[c] = 0; // the cube has already been checked - it is not inserted
+
+                if ( s_GainTotal == 0 ) // the group does not lead to any gain
+                { // mark the cubes
+                    for ( c = 0; c < 4; c++ )
+                        s_CubeGroup[c]->fMark = 1;
+                }
+                else if ( s_GainTotal == 1 ) // the group does not lead to substantial gain, too
+                { 
+                    // undo changes to be able to continue checking groups
+                    UndoRecentChanges();
+                    // mark those cubes that were not inserted
+                    for ( c = 0; c < 4; c++ )
+                        s_CubeGroup[c]->fMark = !s_fInserted[c];
+                }
+                else // if ( s_GainTotal > 1 ) // the group reshapes or improves
+                { // accept the group
+                    for ( c = 0; c < 4; c++ ) // insert other cubes
+                        if ( !s_fInserted[c] )
+                            CheckForCloseCubes( s_CubeGroup[c], 1 ); 
+//                          CheckAndInsert( s_CubeGroup[c] );
+                    // clean the results of generating ExorLinked cubes
+                    ExorLinkCubeIteratorCleanUp( 1 ); // take the last group
+                    // free old cubes
+                    AddToFreeCubes( s_pC1 );
+                    AddToFreeCubes( s_pC2 );
+                    // update the counter
+                    s_cReshapes++;
+                    goto END_OF_LOOP;
+                }
+                                        
+                // rewind to the previously marked position in the cube pair queques
+                MarkRewind();
+            } 
+            while ( ExorLinkCubeIteratorNext( s_CubeGroup ) );
+            // none of the groups leads to improvement
+
+            // return the old cubes back to storage
+            CubeInsert( s_pC1 );
+            CubeInsert( s_pC2 );
+            // clean the results of generating ExorLinked cubes
+            ExorLinkCubeIteratorCleanUp( 0 );
+        }
+END_OF_LOOP: {}
+    }
+
+    // print the report
+    if ( g_CoverInfo.Verbosity == 2 )
+    {
+    printf( "ExLink-%d", 4 );
+    printf( ": Que= %5d", s_cEnquequed );
+    printf( "  Att= %4d", s_cAttempts );
+    printf( "  Resh= %4d", s_cReshapes );
+    printf( "  NoResh= %4d", s_cAttempts - s_cReshapes );
+    printf( "  Cubes= %3d", g_CoverInfo.nCubesInUse );
+    printf( "  (%d)", s_nCubesBefore - g_CoverInfo.nCubesInUse );
+    printf( "  Lits= %5d", CountLiterals() );
+    printf( "  QCost = %6d", CountQCost() );
+    printf( "\n" );
+    }
+
+    // return the number of cubes gained in the process
+    return s_nCubesBefore - g_CoverInfo.nCubesInUse;
+}
+
+// local static variables
+Cube* s_q;
+int s_Distance;
+int s_DiffVarNum;
+int s_DiffVarValueP_old;
+int s_DiffVarValueP_new;
+int s_DiffVarValueQ;
+
+int CheckForCloseCubes( Cube* p, int fAddCube )
+// checks the cube storage for a cube that is dist-0 and dist-1 removed 
+// from the given one (p) if such a cube is found, extracts it from the data 
+// structure, EXORs it with the given cube, adds the resultant cube
+// to the data structure and performed the same check for the resultant cube;
+// returns the number of cubes gained in the process of reduction;
+// if an adjacent cube is not found, inserts the cube only if (fAddCube==1)!!!
+{
+    // start the new range
+    NewRangeReset();
+
+    for ( s_q = s_List; s_q; s_q = s_q->Next )
+    {
+        s_Distance = GetDistancePlus( p, s_q );
+        if ( s_Distance > 4 )
+        {
+        }
+        else if ( s_Distance == 4 )
+        {
+            if ( s_fDistEnable4 ) 
+                NewRangeInsertCubePair( DIST4, p, s_q );
+        }
+        else if ( s_Distance == 3 )
+        {
+            if ( s_fDistEnable3 ) 
+                NewRangeInsertCubePair( DIST3, p, s_q );
+        }
+        else if ( s_Distance == 2 )
+        { 
+            if ( s_fDistEnable2 ) 
+                NewRangeInsertCubePair( DIST2, p, s_q );
+        }
+        else if ( s_Distance == 1 )
+        {   // extract the cube from the data structure
+
+            //////////////////////////////////////////////////////////
+            // store the changes
+            s_ChangeStore.fInput = (s_DiffVarNum != -1);
+            s_ChangeStore.p      = p;
+            s_ChangeStore.PrevQa = s_q->a;
+            s_ChangeStore.PrevPa = p->a;
+            s_ChangeStore.PrevQq = s_q->q;
+            s_ChangeStore.PrevPq = p->q;
+            s_ChangeStore.PrevPz = p->z;
+            s_ChangeStore.Var    = s_DiffVarNum;
+            s_ChangeStore.Value  = s_DiffVarValueQ;
+            s_ChangeStore.PrevID = s_q->ID;
+            //////////////////////////////////////////////////////////
+
+            CubeExtract( s_q );
+            // perform the EXOR of the two cubes and write the result into p
+
+            // it is important that the resultant cube is written into p!!!
+
+            if ( s_DiffVarNum == -1 )
+            {
+                int i;
+                // exor the output part
+                p->z = 0;
+                for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
+                {
+                    p->pCubeDataOut[i] ^= s_q->pCubeDataOut[i];
+                    p->z += BIT_COUNT(p->pCubeDataOut[i]);
+                }
+            }
+            else
+            {
+                // the cube has already been updated by GetDistancePlus()
+
+                // modify the parameters of the number of literals in the new cube
+//              p->a += s_UpdateLiterals[ s_DiffVarValueP ][ s_DiffVarValueQ ];
+                if ( s_DiffVarValueP_old == VAR_NEG || s_DiffVarValueP_old == VAR_POS )
+                    p->a--;
+                if ( s_DiffVarValueP_new == VAR_NEG || s_DiffVarValueP_new == VAR_POS )
+                    p->a++;
+                p->q = ComputeQCostBits(p);
+            }
+
+            // move q to the free cube list
+            AddToFreeCubes( s_q );
+
+            // make sure that nobody with use the pairs created so far
+//          NewRangeReset();
+            // call the function again for the new cube
+            return 1 + CheckForCloseCubes( p, 1 );
+        }
+        else // if ( Distance == 0 )
+        {   // extract the second cube from the data structure and add them both to the free list
+            AddToFreeCubes( p );
+            AddToFreeCubes( CubeExtract( s_q ) );
+
+            // make sure that nobody with use the pairs created so far
+            NewRangeReset();
+            return 2;
+        }
+    }
+    
+    // add the cube to the data structure if needed
+    if ( fAddCube )
+        CubeInsert( p );
+
+    // add temporarily stored new range of cube pairs to the queque
+    NewRangeAdd();
+
+    return 0;
+}
+
+void UndoRecentChanges()
+{
+    Cube * p, * q;
+    // get back cube q that was deleted
+    q = GetFreeCube();
+    // restore the ID
+    q->ID = s_ChangeStore.PrevID;
+    // insert the cube into storage again
+    CubeInsert( q );
+
+    // extract cube p
+    p = CubeExtract( s_ChangeStore.p );
+
+    // modify it back
+    if ( s_ChangeStore.fInput ) // the input has changed
+    {
+        ExorVar( p, s_ChangeStore.Var, (varvalue)s_ChangeStore.Value );
+        p->a = s_ChangeStore.PrevPa;
+        p->q = s_ChangeStore.PrevPq;
+        // p->z did not change
+    }
+    else // if ( s_ChangeStore.fInput ) // the output has changed
+    {
+        int i;
+        for ( i = 0; i < g_CoverInfo.nWordsOut; i++ )
+            p->pCubeDataOut[i] ^= q->pCubeDataOut[i];
+        p->z = s_ChangeStore.PrevPz;
+        // p->a did not change
+    }
+}
+
+///////////////////////////////////////////////////////////////////
+///               CUBE SET MANIPULATION PROCEDURES              ///
+///////////////////////////////////////////////////////////////////
+
+// Cube set is a list of cubes
+//static Cube* s_List;
+
+///////////////////////////////////////////////////////////////////
+///                 Memory Allocation/Delocation                ///
+///////////////////////////////////////////////////////////////////
+
+int AllocateCubeSets( int nVarsIn, int nVarsOut )
+{
+    s_List = NULL;
+
+    // clean other data
+    s_fDistEnable2 = 1;
+    s_fDistEnable3 = 0;
+    s_fDistEnable4 = 0;
+    memset( s_CubeGroup, 0, sizeof(void *) * 5 );
+    memset( s_fInserted, 0, sizeof(int) * 5 );
+    s_fDecreaseLiterals = 0;
+    s_cEnquequed = 0;
+    s_cAttempts = 0;
+    s_cReshapes = 0;
+    s_nCubesBefore = 0;
+    s_Gain = 0;
+    s_GainTotal = 0;
+    s_GroupCounter = 0;
+    s_GroupBest = 0;
+    s_pC1 = s_pC2 = NULL;
+
+    return 4;
+}
+
+void DelocateCubeSets()
+{
+}
+
+///////////////////////////////////////////////////////////////////
+///                     Insertion Operators                     ///
+///////////////////////////////////////////////////////////////////
+
+void CubeInsert( Cube* p )
+// inserts the cube into storage (puts it at the beginning of the list)
+{
+    assert( p->Prev == NULL && p->Next == NULL );
+    assert( p->ID );
+
+    if ( s_List == NULL )
+        s_List = p;
+    else
+    {
+        p->Next = s_List;
+
+        s_List->Prev = p;
+        s_List = p;
+    }
+
+    g_CoverInfo.nCubesInUse++;
+}
+
+Cube* CubeExtract( Cube* p )
+// extracts the cube from storage
+{
+//  assert( p->Prev && p->Next ); // can be done only with rings
+    assert( p->ID );
+
+//  if ( s_List == p )
+//      s_List = p->Next;
+//  if ( p->Prev )
+//      p->Prev->Next = p->Next;
+
+    if ( s_List == p )
+        s_List = p->Next;
+    else
+        p->Prev->Next = p->Next;
+
+    if ( p->Next )
+        p->Next->Prev = p->Prev;
+
+    p->Prev = NULL;
+    p->Next = NULL;
+
+    g_CoverInfo.nCubesInUse--;
+    return p;
+}
+
+///////////////////////////////////////////////////////////////////
+///                       CUBE ITERATOR                         ///
+///////////////////////////////////////////////////////////////////
+
+// the iterator starts from the Head and stops when it sees NULL
+Cube* s_pCubeLast;
+
+///////////////////////////////////////////////////////////////////
+///                     Cube Set Iterator                       ///
+///////////////////////////////////////////////////////////////////
+
+Cube* IterCubeSetStart()
+// starts an iterator that traverses all the cubes in the ring
+{
+    assert( s_pCubeLast == NULL );
+
+    // check whether the List has cubes
+    if ( s_List == NULL )
+        return NULL;
+
+    return ( s_pCubeLast = s_List );
+}
+
+Cube* IterCubeSetNext()
+// returns the next cube in the cube set
+// to use it again after it has returned NULL, first call IterCubeSetStart()
+{
+    assert( s_pCubeLast );
+    return ( s_pCubeLast = s_pCubeLast->Next );
+}
+
+///////////////////////////////////////////////////////////////////
+////                      ADJACENCY QUEQUES                  //////
+///////////////////////////////////////////////////////////////////
+
+typedef struct
+{
+    Cube** pC1;      // the pointer to the first cube
+    Cube** pC2;      // the pointer to the second cube
+    byte*  ID1;      // the ID of the first cube
+    byte*  ID2;      // the ID of the second cube
+    int  PosOut;     // extract position
+    int  PosIn;      // insert position
+    int  PosCur;     // temporary insert position
+    int  PosMark;    // the marked position
+    int  fEmpty;     // this flag is 1 if there is nothing in the queque
+} que;
+
+static que s_Que[3];  // Dist-2, Dist-3, Dist-4 queques
+
+// the number of allocated places
+//int s_nPosAlloc;
+// the maximum number of occupied places
+//int s_nPosMax[3];
+
+//////////////////////////////////////////////////////////////////////
+//            Conditional Adding Cube Pairs To Queques              //
+//////////////////////////////////////////////////////////////////////
+
+int GetPosDiff( int PosBeg, int PosEnd )
+{
+    return (PosEnd - PosBeg + s_nPosAlloc) % s_nPosAlloc;
+}
+
+void MarkSet()
+// sets marks in the cube pair queques
+{
+    s_Que[0].PosMark = s_Que[0].PosIn;
+    s_Que[1].PosMark = s_Que[1].PosIn;
+    s_Que[2].PosMark = s_Que[2].PosIn;
+}
+
+void MarkRewind()
+// rewinds the queques to the previously set marks
+{
+    s_Que[0].PosIn = s_Que[0].PosMark;
+    s_Que[1].PosIn = s_Que[1].PosMark;
+    s_Que[2].PosIn = s_Que[2].PosMark;
+}
+
+void NewRangeReset()
+// resets temporarily stored new range of cube pairs
+{
+    s_Que[0].PosCur = s_Que[0].PosIn;
+    s_Que[1].PosCur = s_Que[1].PosIn;
+    s_Que[2].PosCur = s_Que[2].PosIn;
+}
+
+void NewRangeAdd()
+// adds temporarily stored new range of cube pairs to the queque
+{
+    s_Que[0].PosIn = s_Que[0].PosCur;
+    s_Que[1].PosIn = s_Que[1].PosCur;
+    s_Que[2].PosIn = s_Que[2].PosCur;
+}
+
+void NewRangeInsertCubePair( cubedist Dist, Cube* p1, Cube* p2 )
+// insert one cube pair into the new range
+{
+    que* p = &s_Que[Dist];
+    int Pos = p->PosCur;
+
+    if ( p->fEmpty || Pos != p->PosOut )
+    {
+        p->pC1[Pos] = p1;
+        p->pC2[Pos] = p2;
+        p->ID1[Pos] = p1->ID;
+        p->ID2[Pos] = p2->ID;
+
+        p->PosCur = (p->PosCur+1)%s_nPosAlloc;
+    }
+    else
+        assert(0);
+//      cout << endl << "DIST-" << (int)(Dist+2) << ": Have run out of queque space!" << endl;
+}
+
+void PrintQuequeStats()
+{
+/*
+    cout << endl << "Queque statistics: ";
+    cout << " Alloc = " << s_nPosAlloc;
+    cout << "   DIST2 = " << GetPosDiff( s_Que[0].PosOut, s_Que[0].PosIn );
+    cout << "   DIST3 = " << GetPosDiff( s_Que[1].PosOut, s_Que[1].PosIn );
+    cout << "   DIST4 = " << GetPosDiff( s_Que[2].PosOut, s_Que[2].PosIn );
+    cout << endl;
+    cout << endl;
+*/
+}
+
+int GetQuequeStats( cubedist Dist )
+{
+    return GetPosDiff( s_Que[Dist].PosOut, s_Que[Dist].PosIn );
+}
+
+//////////////////////////////////////////////////////////////////////
+//                       Queque Iterators                           //
+//////////////////////////////////////////////////////////////////////
+
+// iterating through the queque (with authomatic garbage collection)
+// only one iterator can be active at a time
+static struct
+{
+    int fStarted;    // status of the iterator (1 if working)
+    cubedist Dist;   // the currently iterated queque
+    Cube** ppC1;     // the position where the first cube pointer goes
+    Cube** ppC2;     // the position where the second cube pointer goes
+    int PosStop;     // the stop position (to prevent the iterator from
+                     // choking when new pairs are added during iteration)
+    int CutValue;    // the number of literals below which the cubes are not used
+} s_Iter;
+
+static que* pQ;
+static Cube *p1, *p2;
+
+int IteratorCubePairStart( cubedist CubeDist, Cube** ppC1, Cube** ppC2 )
+// start an iterator through cubes of dist CubeDist,
+// the resulting pointers are written into ppC1 and ppC2
+// returns 1 if the first cube pair is found
+{
+    int fEntryFound;
+
+    assert( s_Iter.fStarted == 0 );
+    assert( CubeDist >= 0 && CubeDist <= 2 );
+
+    s_Iter.fStarted = 1;
+    s_Iter.Dist = CubeDist;
+    s_Iter.ppC1 = ppC1;
+    s_Iter.ppC2 = ppC2;
+
+    s_Iter.PosStop = s_Que[ CubeDist ].PosIn;
+
+    // determine the cut value
+//  s_Iter.CutValue = s_nLiteralsInUse/s_nCubesInUse/2;
+    s_Iter.CutValue = -1;
+
+    fEntryFound = 0;
+    // go through the entries while there is something in the queque
+    for ( pQ = &s_Que[ CubeDist ]; pQ->PosOut != s_Iter.PosStop; pQ->PosOut = (pQ->PosOut+1)%s_nPosAlloc )
+    {
+        p1 = pQ->pC1[ pQ->PosOut ];
+        p2 = pQ->pC2[ pQ->PosOut ];
+
+        // check whether the entry is valid
+        if ( p1->ID == pQ->ID1[ pQ->PosOut ] && 
+             p2->ID == pQ->ID2[ pQ->PosOut ] ) //&&
+             //p1->x + p1->y + p2->x + p2->y > s_Iter.CutValue )
+        {
+             fEntryFound = 1;
+             break;
+        }
+    }
+
+    if ( fEntryFound )
+    { // write the result into the pick-up place
+        *ppC1 = pQ->pC1[ pQ->PosOut ];
+        *ppC2 = pQ->pC2[ pQ->PosOut ];
+
+        pQ->PosOut = (pQ->PosOut+1)%s_nPosAlloc;
+    }
+    else
+        s_Iter.fStarted = 0;
+    return fEntryFound;
+}
+
+int IteratorCubePairNext()
+// gives the next VALID cube pair (the previous one is automatically dequequed)
+{
+    int fEntryFound = 0;
+    assert( s_Iter.fStarted );
+
+    // go through the entries while there is something in the queque
+    for ( pQ = &s_Que[ s_Iter.Dist ]; pQ->PosOut != s_Iter.PosStop; pQ->PosOut = (pQ->PosOut+1)%s_nPosAlloc )
+    {
+        p1 = pQ->pC1[ pQ->PosOut ];
+        p2 = pQ->pC2[ pQ->PosOut ];
+
+        // check whether the entry is valid
+        if ( p1->ID == pQ->ID1[ pQ->PosOut ] && 
+             p2->ID == pQ->ID2[ pQ->PosOut ] ) //&&
+             //p1->x + p1->y + p2->x + p2->y > s_Iter.CutValue )
+        {
+             fEntryFound = 1;
+             break;
+        }
+    }
+
+    if ( fEntryFound )
+    { // write the result into the pick-up place
+        *(s_Iter.ppC1) = pQ->pC1[ pQ->PosOut ];
+        *(s_Iter.ppC2) = pQ->pC2[ pQ->PosOut ];
+
+        pQ->PosOut = (pQ->PosOut+1)%s_nPosAlloc;
+    }
+    else // iteration has finished
+        s_Iter.fStarted = 0;
+
+    return fEntryFound;
+}
+
+//////////////////////////////////////////////////////////////////////
+//                     Allocation/Delocation                        //
+//////////////////////////////////////////////////////////////////////
+
+int AllocateQueques( int nPlaces )
+// nPlaces should be approximately nCubes*nCubes/10
+// allocates memory for cube pair queques
+{
+    int i;
+    s_nPosAlloc  = nPlaces;
+
+    for ( i = 0; i < 3; i++ )
+    {
+        // clean data
+        memset( &s_Que[i], 0, sizeof(que) );
+
+        s_Que[i].pC1 = (Cube**) ABC_ALLOC( Cube*, nPlaces );
+        s_Que[i].pC2 = (Cube**) ABC_ALLOC( Cube*, nPlaces );
+        s_Que[i].ID1 = (byte*) ABC_ALLOC( byte, nPlaces );
+        s_Que[i].ID2 = (byte*) ABC_ALLOC( byte, nPlaces );
+
+        if ( s_Que[i].pC1==NULL || s_Que[i].pC2==NULL || s_Que[i].ID1==NULL || s_Que[i].ID2==NULL )
+            return 0;
+
+        s_nPosMax[i] = 0;
+        s_Que[i].fEmpty = 1;
+    }
+
+    return nPlaces * (sizeof(Cube*) + sizeof(Cube*) + 2*sizeof(byte) );
+}
+
+void DelocateQueques()
+{
+    int i;
+    for ( i = 0; i < 3; i++ )
+    {
+        ABC_FREE( s_Que[i].pC1 );
+        ABC_FREE( s_Que[i].pC2 );
+        ABC_FREE( s_Que[i].ID1 );
+        ABC_FREE( s_Que[i].ID2 );
+    }
+}
+
+///////////////////////////////////////////////////////////////////
+////////////              End of File             /////////////////
+///////////////////////////////////////////////////////////////////
+
+
+}
diff --git a/lib/abcesop/exorUtil.cpp b/lib/abcesop/exorUtil.cpp
new file mode 100644
index 0000000..2309e0b
--- /dev/null
+++ b/lib/abcesop/exorUtil.cpp
@@ -0,0 +1,228 @@
+/**CFile****************************************************************
+
+  FileName    [exorUtil.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Exclusive sum-of-product minimization.]
+
+  Synopsis    [Utilities.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: exorUtil.c,v 1.0 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+////////////////////////////////////////////////////////////////////////
+///                                                                  ///
+///                  Implementation of EXORCISM - 4                  ///
+///              An Exclusive Sum-of-Product Minimizer               ///
+///               Alan Mishchenko  <alanmi@ee.pdx.edu>               ///
+///                                                                  ///
+////////////////////////////////////////////////////////////////////////
+///                                                                  ///
+///                        Utility Functions                         ///
+///                                                                  ///
+///       1) allocating memory for and creating the ESOP cover       ///
+///       2) writing the resultant cover into an ESOP PLA file       ///
+///                                                                  ///
+///  Ver. 1.0. Started - July 15, 2000. Last update - July 20, 2000  ///
+///  Ver. 1.4. Started -  Aug 10, 2000. Last update -  Aug 10, 2000  ///
+///  Ver. 1.5. Started -  Aug 19, 2000. Last update -  Aug 19, 2000  ///
+///  Ver. 1.7. Started -  Sep 20, 2000. Last update -  Sep 23, 2000  ///
+///                                                                  ///
+////////////////////////////////////////////////////////////////////////
+///   This software was tested with the BDD package "CUDD", v.2.3.0  ///
+///                          by Fabio Somenzi                        ///
+///                  http://vlsi.colorado.edu/~fabio/                ///
+////////////////////////////////////////////////////////////////////////
+
+#include "eabc/exor.h"
+
+namespace abc::exorcism {
+
+////////////////////////////////////////////////////////////////////////
+///                      EXTERNAL VARIABLES                         ////
+////////////////////////////////////////////////////////////////////////
+
+// information about the options, the function, and the cover
+extern cinfo g_CoverInfo;
+
+////////////////////////////////////////////////////////////////////////
+///                        EXTERNAL FUNCTIONS                        ///
+////////////////////////////////////////////////////////////////////////
+
+// Cube Cover Iterator
+// starts an iterator that traverses all the cubes in the ring
+extern Cube* IterCubeSetStart();
+// returns the next cube in the ring
+extern Cube* IterCubeSetNext();
+
+// retrieves the variable from the cube
+extern varvalue GetVar( Cube* pC, int Var );
+
+////////////////////////////////////////////////////////////////////////
+///                      FUNCTION DECLARATIONS                       ///
+////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////
+////////////       Cover Service Procedures       /////////////////
+///////////////////////////////////////////////////////////////////
+
+int CountLiterals()
+{
+    Cube* p;
+    int LitCounter = 0;
+    for ( p = IterCubeSetStart( ); p; p = IterCubeSetNext() )
+        LitCounter += p->a;
+    return LitCounter;
+}
+
+int CountLiteralsCheck()
+{
+    Cube* p;
+    int Value, v;
+    int LitCounter = 0;
+    int LitCounterControl = 0;
+
+    for ( p = IterCubeSetStart( ); p; p = IterCubeSetNext() )
+    {
+        LitCounterControl += p->a;
+
+        assert( p->fMark == 0 );
+
+        // write the input variables
+        for ( v = 0; v < g_CoverInfo.nVarsIn; v++ )
+        {
+            Value = GetVar( p, v );
+            if ( Value == VAR_NEG )
+                LitCounter++;
+            else if ( Value == VAR_POS )
+                LitCounter++;
+            else if ( Value != VAR_ABS )
+            {
+                assert(0);
+            }
+        }
+    }
+
+    if ( LitCounterControl != LitCounter )
+        printf( "Warning! The recorded number of literals (%d) differs from the actual number (%d)\n", LitCounterControl, LitCounter );
+    return LitCounter;
+}
+
+int CountQCost()
+{
+    Cube* p;
+    int QCost = 0;
+    int QCostControl = 0;
+    for ( p = IterCubeSetStart( ); p; p = IterCubeSetNext() )
+    {
+        QCostControl += p->q;
+        QCost += ComputeQCostBits( p );
+    }
+//    if ( QCostControl != QCost )
+//        printf( "Warning! The recorded number of literals (%d) differs from the actual number (%d)\n", QCostControl, QCost );
+    return QCost;
+}
+
+
+void WriteTableIntoFile( FILE * pFile )
+// nCubesAlloc is the number of allocated cubes 
+{
+    int v, w;
+    Cube * p;
+    int cOutputs;
+    int nOutput;
+    int WordSize;
+
+    for ( p = IterCubeSetStart( ); p; p = IterCubeSetNext() )
+    {
+        assert( p->fMark == 0 );
+
+        // write the input variables
+        for ( v = 0; v < g_CoverInfo.nVarsIn; v++ )
+        {
+            int Value = GetVar( p, v );
+            if ( Value == VAR_NEG )
+                fprintf( pFile, "0" );
+            else if ( Value == VAR_POS )
+                fprintf( pFile, "1" );
+            else if ( Value == VAR_ABS )
+                fprintf( pFile, "-" );
+            else
+                assert(0);
+        }
+        fprintf( pFile, " " );
+
+        // write the output variables
+        cOutputs = 0;
+        nOutput = g_CoverInfo.nVarsOut;
+        WordSize = 8*sizeof( unsigned );
+        for ( w = 0; w < g_CoverInfo.nWordsOut; w++ )
+            for ( v = 0; v < WordSize; v++ )
+            {
+                if ( p->pCubeDataOut[w] & (1<<v) )
+                    fprintf( pFile, "1" );
+                else
+                    fprintf( pFile, "0" );
+                if ( ++cOutputs == nOutput )
+                    break;
+            }
+        fprintf( pFile, "\n" );
+    }
+}
+
+
+int WriteResultIntoFile( char * pFileName )
+// write the ESOP cover into the PLA file <NewFileName>
+{
+    FILE * pFile;
+    time_t ltime;
+    char * TimeStr;
+
+    pFile = fopen( pFileName, "w" );
+    if ( pFile == NULL )
+    {
+        fprintf( pFile, "\n\nCannot open the output file\n" );
+        return 1;
+    }
+
+    // get current time
+    time( &ltime );
+    TimeStr = asctime( localtime( &ltime ) );
+    // get the number of literals
+    g_CoverInfo.nLiteralsAfter = CountLiteralsCheck();
+    g_CoverInfo.QCostAfter = CountQCost();
+    fprintf( pFile, "# EXORCISM-4 output for command line arguments: " );
+    fprintf( pFile, "\"-Q %d -V %d\"\n", g_CoverInfo.Quality, g_CoverInfo.Verbosity );
+    fprintf( pFile, "# Minimization performed %s", TimeStr );
+    fprintf( pFile, "# Initial statistics: " );
+    fprintf( pFile, "Cubes = %d  Literals = %d  QCost = %d\n", g_CoverInfo.nCubesBefore, g_CoverInfo.nLiteralsBefore, g_CoverInfo.QCostBefore );
+    fprintf( pFile, "# Final   statistics: " );
+    fprintf( pFile, "Cubes = %d  Literals = %d  QCost = %d\n", g_CoverInfo.nCubesInUse, g_CoverInfo.nLiteralsAfter, g_CoverInfo.QCostAfter );
+    fprintf( pFile, "# File reading and reordering time = %.2f sec\n", TICKS_TO_SECONDS(g_CoverInfo.TimeRead) );
+    fprintf( pFile, "# Starting cover generation time   = %.2f sec\n", TICKS_TO_SECONDS(g_CoverInfo.TimeStart) );
+    fprintf( pFile, "# Pure ESOP minimization time      = %.2f sec\n", TICKS_TO_SECONDS(g_CoverInfo.TimeMin) );
+    fprintf( pFile, ".i %d\n", g_CoverInfo.nVarsIn );
+    fprintf( pFile, ".o %d\n", g_CoverInfo.nVarsOut );
+    fprintf( pFile, ".p %d\n", g_CoverInfo.nCubesInUse );
+    fprintf( pFile, ".type esop\n" );
+    WriteTableIntoFile( pFile );
+    fprintf( pFile, ".e\n" );
+    fclose( pFile );
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////
+////////////              End of File             /////////////////
+///////////////////////////////////////////////////////////////////
+
+
+}
+
diff --git a/lib/abcsat/AbcGlucose.cpp b/lib/abcsat/AbcGlucose.cpp
new file mode 100644
index 0000000..d1c55fd
--- /dev/null
+++ b/lib/abcsat/AbcGlucose.cpp
@@ -0,0 +1,596 @@
+/**CFile****************************************************************
+
+  FileName    [AbcGlucose.cpp]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SAT solver Glucose 3.0 by Gilles Audemard and Laurent Simon.]
+
+  Synopsis    [Interface to Glucose.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - September 6, 2017.]
+
+  Revision    [$Id: AbcGlucose.cpp,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "abc/system.h"
+#include "abc/Dimacs.h"
+#include "abc/SimpSolver.h"
+
+#include "abc/AbcGlucose.h"
+#include "abc/abc_global.h"
+
+//#include "base/abc/abc.h"
+//#include "sat/cnf/cnf.h"
+//#include "misc/extra/extra.h"
+
+ABC_NAMESPACE_IMPL_START
+
+using namespace Gluco;
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+#define USE_SIMP_SOLVER 1
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+#ifdef USE_SIMP_SOLVER
+    
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Gluco::SimpSolver * glucose_solver_start()
+{
+    SimpSolver * S = new SimpSolver;
+    S->setIncrementalMode();
+    return S;
+}
+
+void glucose_solver_stop(Gluco::SimpSolver* S)
+{
+    delete S;
+}
+
+void glucose_solver_reset(Gluco::SimpSolver* S)
+{
+    S->reset();
+}
+
+int glucose_solver_addclause(Gluco::SimpSolver* S, int * plits, int nlits)
+{
+    vec<Lit> lits;
+    for ( int i = 0; i < nlits; i++,plits++)
+    {
+        // note: Glucose uses the same var->lit conventiaon as ABC
+        while ((*plits)/2 >= S->nVars()) S->newVar();
+        assert((*plits)/2 < S->nVars()); // NOTE: since we explicitely use new function bmc_add_var
+        Lit p;
+        p.x = *plits;
+        lits.push(p);
+    }
+    return S->addClause(lits); // returns 0 if the problem is UNSAT
+}
+
+void glucose_solver_setcallback(Gluco::SimpSolver* S, void * pman, int(*pfunc)(void*, int, int*))
+{
+    S->pCnfMan = pman;
+    S->pCnfFunc = pfunc;
+    S->nCallConfl = 1000;
+}
+
+int glucose_solver_solve(Gluco::SimpSolver* S, int * plits, int nlits)
+{
+    vec<Lit> lits;
+    for (int i=0;i<nlits;i++,plits++)
+    {
+        Lit p;
+        p.x = *plits;
+        lits.push(p);
+    }
+    Gluco::lbool res = S->solveLimited(lits, 0);
+    return (res == l_True ? 1 : res == l_False ? -1 : 0);
+}
+
+int glucose_solver_addvar(Gluco::SimpSolver* S)
+{
+    S->newVar();
+    return S->nVars() - 1;
+}
+
+int glucose_solver_read_cex_varvalue(Gluco::SimpSolver* S, int ivar)
+{
+    return S->model[ivar] == l_True;
+}
+
+void glucose_solver_setstop(Gluco::SimpSolver* S, int * pstop)
+{
+    S->pstop = pstop;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Wrapper APIs to calling from ABC.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+bmcg_sat_solver * bmcg_sat_solver_start() 
+{
+    return (bmcg_sat_solver *)glucose_solver_start();
+}
+void bmcg_sat_solver_stop(bmcg_sat_solver* s)
+{
+    glucose_solver_stop((Gluco::SimpSolver*)s);
+}
+void bmcg_sat_solver_reset(bmcg_sat_solver* s)
+{
+    glucose_solver_reset((Gluco::SimpSolver*)s);
+}
+
+
+int bmcg_sat_solver_addclause(bmcg_sat_solver* s, int * plits, int nlits)
+{
+    return glucose_solver_addclause((Gluco::SimpSolver*)s,plits,nlits);
+}
+
+void bmcg_sat_solver_setcallback(bmcg_sat_solver* s, void * pman, int(*pfunc)(void*, int, int*))
+{
+    glucose_solver_setcallback((Gluco::SimpSolver*)s,pman,pfunc);
+}
+
+int bmcg_sat_solver_solve(bmcg_sat_solver* s, int * plits, int nlits)
+{
+    return glucose_solver_solve((Gluco::SimpSolver*)s,plits,nlits);
+}
+
+int bmcg_sat_solver_final(bmcg_sat_solver* s, int ** ppArray)
+{
+    *ppArray = (int *)(Lit *)((Gluco::SimpSolver*)s)->conflict;
+    return ((Gluco::SimpSolver*)s)->conflict.size();
+}
+
+int bmcg_sat_solver_addvar(bmcg_sat_solver* s)
+{
+    return glucose_solver_addvar((Gluco::SimpSolver*)s);
+}
+
+void bmcg_sat_solver_set_nvars( bmcg_sat_solver* s, int nvars )
+{
+    int i;
+    for ( i = bmcg_sat_solver_varnum(s); i < nvars; i++ )
+        bmcg_sat_solver_addvar(s);
+}
+
+int bmcg_sat_solver_eliminate( bmcg_sat_solver* s, int turn_off_elim )
+{
+//    return 1; 
+    return ((Gluco::SimpSolver*)s)->eliminate(turn_off_elim != 0);
+}
+
+int bmcg_sat_solver_var_is_elim( bmcg_sat_solver* s, int v )
+{
+//    return 0; 
+    return ((Gluco::SimpSolver*)s)->isEliminated(v);
+}
+
+void bmcg_sat_solver_var_set_frozen( bmcg_sat_solver* s, int v, int freeze )
+{
+    ((Gluco::SimpSolver*)s)->setFrozen(v, freeze != 0);
+}
+
+int bmcg_sat_solver_elim_varnum(bmcg_sat_solver* s)
+{
+//    return 0; 
+    return ((Gluco::SimpSolver*)s)->eliminated_vars;
+}
+
+int bmcg_sat_solver_read_cex_varvalue(bmcg_sat_solver* s, int ivar)
+{
+    return glucose_solver_read_cex_varvalue((Gluco::SimpSolver*)s, ivar);
+}
+
+void bmcg_sat_solver_set_stop(bmcg_sat_solver* s, int * pstop)
+{
+    glucose_solver_setstop((Gluco::SimpSolver*)s, pstop);
+}
+
+abctime bmcg_sat_solver_set_runtime_limit(bmcg_sat_solver* s, abctime Limit)
+{
+    abctime nRuntimeLimit = ((Gluco::SimpSolver*)s)->nRuntimeLimit;
+    ((Gluco::SimpSolver*)s)->nRuntimeLimit = Limit;
+    return nRuntimeLimit;
+}
+
+void bmcg_sat_solver_set_conflict_budget(bmcg_sat_solver* s, int Limit)
+{
+    if ( Limit > 0 ) 
+        ((Gluco::SimpSolver*)s)->setConfBudget( (int64_t)Limit );
+    else 
+        ((Gluco::SimpSolver*)s)->budgetOff();
+}
+
+int bmcg_sat_solver_varnum(bmcg_sat_solver* s)
+{
+    return ((Gluco::SimpSolver*)s)->nVars();
+}
+int bmcg_sat_solver_clausenum(bmcg_sat_solver* s)
+{
+    return ((Gluco::SimpSolver*)s)->nClauses();
+}
+int bmcg_sat_solver_learntnum(bmcg_sat_solver* s)
+{
+    return ((Gluco::SimpSolver*)s)->nLearnts();
+}
+int bmcg_sat_solver_conflictnum(bmcg_sat_solver* s)
+{
+    return ((Gluco::SimpSolver*)s)->conflicts;
+}
+
+int bmcg_sat_solver_minimize_assumptions( bmcg_sat_solver * s, int * plits, int nlits, int pivot )
+{
+    vec<int>*array = &((Gluco::SimpSolver*)s)->user_vec;
+    int i, nlitsL, nlitsR, nresL, nresR, status;
+    assert( pivot >= 0 );
+//    assert( nlits - pivot >= 2 );
+    assert( nlits - pivot >= 1 );
+    if ( nlits - pivot == 1 )
+    {
+        // since the problem is UNSAT, we try to solve it without assuming the last literal
+        // if the result is UNSAT, the last literal can be dropped; otherwise, it is needed
+        status = bmcg_sat_solver_solve( s, plits, pivot );
+        return status != GLUCOSE_UNSAT; // return 1 if the problem is not UNSAT
+    }
+    assert( nlits - pivot >= 2 );
+    nlitsL = (nlits - pivot) / 2;
+    nlitsR = (nlits - pivot) - nlitsL;
+    assert( nlitsL + nlitsR == nlits - pivot );
+    // solve with these assumptions
+    status = bmcg_sat_solver_solve( s, plits, pivot + nlitsL );
+    if ( status == GLUCOSE_UNSAT ) // these are enough
+        return bmcg_sat_solver_minimize_assumptions( s, plits, pivot + nlitsL, pivot );
+    // these are not enough
+    // solve for the right lits
+//    nResL = nLitsR == 1 ? 1 : sat_solver_minimize_assumptions( s, pLits + nLitsL, nLitsR, nConfLimit );
+    nresL = nlitsR == 1 ? 1 : bmcg_sat_solver_minimize_assumptions( s, plits, nlits, pivot + nlitsL );
+    // swap literals
+    array->clear();
+    for ( i = 0; i < nlitsL; i++ )
+        array->push(plits[pivot + i]);
+    for ( i = 0; i < nresL; i++ )
+        plits[pivot + i] = plits[pivot + nlitsL + i];
+    for ( i = 0; i < nlitsL; i++ )
+        plits[pivot + nresL + i] = (*array)[i];
+    // solve with these assumptions
+    status = bmcg_sat_solver_solve( s, plits, pivot + nresL );
+    if ( status == GLUCOSE_UNSAT ) // these are enough
+        return nresL;
+    // solve for the left lits
+//    nResR = nLitsL == 1 ? 1 : sat_solver_minimize_assumptions( s, pLits + nResL, nLitsL, nConfLimit );
+    nresR = nlitsL == 1 ? 1 : bmcg_sat_solver_minimize_assumptions( s, plits, pivot + nresL + nlitsL, pivot + nresL );
+    return nresL + nresR;
+}
+
+int bmcg_sat_solver_add_and( bmcg_sat_solver * s, int iVar, int iVar0, int iVar1, int fCompl0, int fCompl1, int fCompl )
+{
+    int Lits[3];
+
+    Lits[0] = Abc_Var2Lit( iVar, !fCompl );
+    Lits[1] = Abc_Var2Lit( iVar0, fCompl0 );
+    if ( !bmcg_sat_solver_addclause( s, Lits, 2 ) )
+        return 0;
+
+    Lits[0] = Abc_Var2Lit( iVar, !fCompl );
+    Lits[1] = Abc_Var2Lit( iVar1, fCompl1 );
+    if ( !bmcg_sat_solver_addclause( s, Lits, 2 ) )
+        return 0;
+
+    Lits[0] = Abc_Var2Lit( iVar,   fCompl );
+    Lits[1] = Abc_Var2Lit( iVar0, !fCompl0 );
+    Lits[2] = Abc_Var2Lit( iVar1, !fCompl1 );
+    if ( !bmcg_sat_solver_addclause( s, Lits, 3 ) )
+        return 0;
+
+    return 1;
+}
+
+#else
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Gluco::Solver * glucose_solver_start()
+{
+    Solver * S = new Solver;
+    S->setIncrementalMode();
+    return S;
+}
+
+void glucose_solver_stop(Gluco::Solver* S)
+{
+    delete S;
+}
+
+int glucose_solver_addclause(Gluco::Solver* S, int * plits, int nlits)
+{
+    vec<Lit> lits;
+    for ( int i = 0; i < nlits; i++,plits++)
+    {
+        // note: Glucose uses the same var->lit conventiaon as ABC
+        while ((*plits)/2 >= S->nVars()) S->newVar();
+        assert((*plits)/2 < S->nVars()); // NOTE: since we explicitely use new function bmc_add_var
+        Lit p;
+        p.x = *plits;
+        lits.push(p);
+    }
+    return S->addClause(lits); // returns 0 if the problem is UNSAT
+}
+
+void glucose_solver_setcallback(Gluco::Solver* S, void * pman, int(*pfunc)(void*, int, int*))
+{
+    S->pCnfMan = pman;
+    S->pCnfFunc = pfunc;
+    S->nCallConfl = 1000;
+}
+
+int glucose_solver_solve(Gluco::Solver* S, int * plits, int nlits)
+{
+    vec<Lit> lits;
+    for (int i=0;i<nlits;i++,plits++)
+    {
+        Lit p;
+        p.x = *plits;
+        lits.push(p);
+    }
+    Gluco::lbool res = S->solveLimited(lits);
+    return (res == l_True ? 1 : res == l_False ? -1 : 0);
+}
+
+int glucose_solver_addvar(Gluco::Solver* S)
+{
+    S->newVar();
+    return S->nVars() - 1;
+}
+
+int glucose_solver_read_cex_varvalue(Gluco::Solver* S, int ivar)
+{
+    return S->model[ivar] == l_True;
+}
+
+void glucose_solver_setstop(Gluco::Solver* S, int * pstop)
+{
+    S->pstop = pstop;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Wrapper APIs to calling from ABC.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+bmcg_sat_solver * bmcg_sat_solver_start() 
+{
+    return (bmcg_sat_solver *)glucose_solver_start();
+}
+void bmcg_sat_solver_stop(bmcg_sat_solver* s)
+{
+    glucose_solver_stop((Gluco::Solver*)s);
+}
+
+int bmcg_sat_solver_addclause(bmcg_sat_solver* s, int * plits, int nlits)
+{
+    return glucose_solver_addclause((Gluco::Solver*)s,plits,nlits);
+}
+
+void bmcg_sat_solver_setcallback(bmcg_sat_solver* s, void * pman, int(*pfunc)(void*, int, int*))
+{
+    glucose_solver_setcallback((Gluco::Solver*)s,pman,pfunc);
+}
+
+int bmcg_sat_solver_solve(bmcg_sat_solver* s, int * plits, int nlits)
+{
+    return glucose_solver_solve((Gluco::Solver*)s,plits,nlits);
+}
+
+int bmcg_sat_solver_final(bmcg_sat_solver* s, int ** ppArray)
+{
+    *ppArray = (int *)(Lit *)((Gluco::Solver*)s)->conflict;
+    return ((Gluco::Solver*)s)->conflict.size();
+}
+
+int bmcg_sat_solver_addvar(bmcg_sat_solver* s)
+{
+    return glucose_solver_addvar((Gluco::Solver*)s);
+}
+
+void bmcg_sat_solver_set_nvars( bmcg_sat_solver* s, int nvars )
+{
+    int i;
+    for ( i = bmcg_sat_solver_varnum(s); i < nvars; i++ )
+        bmcg_sat_solver_addvar(s);
+}
+
+int bmcg_sat_solver_eliminate( bmcg_sat_solver* s, int turn_off_elim )
+{
+    return 1; 
+//    return ((Gluco::SimpSolver*)s)->eliminate(turn_off_elim != 0);
+}
+
+int bmcg_sat_solver_var_is_elim( bmcg_sat_solver* s, int v )
+{
+    return 0; 
+//    return ((Gluco::SimpSolver*)s)->isEliminated(v);
+}
+
+void bmcg_sat_solver_var_set_frozen( bmcg_sat_solver* s, int v, int freeze )
+{
+//    ((Gluco::SimpSolver*)s)->setFrozen(v, freeze);
+}
+
+int bmcg_sat_solver_elim_varnum(bmcg_sat_solver* s)
+{
+    return 0;
+//    return ((Gluco::SimpSolver*)s)->eliminated_vars;
+}
+
+int bmcg_sat_solver_read_cex_varvalue(bmcg_sat_solver* s, int ivar)
+{
+    return glucose_solver_read_cex_varvalue((Gluco::Solver*)s, ivar);
+}
+
+void bmcg_sat_solver_set_stop(bmcg_sat_solver* s, int * pstop)
+{
+    glucose_solver_setstop((Gluco::Solver*)s, pstop);
+}
+
+abctime bmcg_sat_solver_set_runtime_limit(bmcg_sat_solver* s, abctime Limit)
+{
+    abctime nRuntimeLimit = ((Gluco::Solver*)s)->nRuntimeLimit;
+    ((Gluco::Solver*)s)->nRuntimeLimit = Limit;
+    return nRuntimeLimit;
+}
+
+void bmcg_sat_solver_set_conflict_budget(bmcg_sat_solver* s, int Limit)
+{
+    if ( Limit > 0 ) 
+        ((Gluco::Solver*)s)->setConfBudget( (int64_t)Limit );
+    else 
+        ((Gluco::Solver*)s)->budgetOff();
+}
+
+int bmcg_sat_solver_varnum(bmcg_sat_solver* s)
+{
+    return ((Gluco::Solver*)s)->nVars();
+}
+int bmcg_sat_solver_clausenum(bmcg_sat_solver* s)
+{
+    return ((Gluco::Solver*)s)->nClauses();
+}
+int bmcg_sat_solver_learntnum(bmcg_sat_solver* s)
+{
+    return ((Gluco::Solver*)s)->nLearnts();
+}
+int bmcg_sat_solver_conflictnum(bmcg_sat_solver* s)
+{
+    return ((Gluco::Solver*)s)->conflicts;
+}
+
+int bmcg_sat_solver_minimize_assumptions( bmcg_sat_solver * s, int * plits, int nlits, int pivot )
+{
+    vec<int>*array = &((Gluco::Solver*)s)->user_vec;
+    int i, nlitsL, nlitsR, nresL, nresR, status;
+    assert( pivot >= 0 );
+//    assert( nlits - pivot >= 2 );
+    assert( nlits - pivot >= 1 );
+    if ( nlits - pivot == 1 )
+    {
+        // since the problem is UNSAT, we try to solve it without assuming the last literal
+        // if the result is UNSAT, the last literal can be dropped; otherwise, it is needed
+        status = bmcg_sat_solver_solve( s, plits, pivot );
+        return status != GLUCOSE_UNSAT; // return 1 if the problem is not UNSAT
+    }
+    assert( nlits - pivot >= 2 );
+    nlitsL = (nlits - pivot) / 2;
+    nlitsR = (nlits - pivot) - nlitsL;
+    assert( nlitsL + nlitsR == nlits - pivot );
+    // solve with these assumptions
+    status = bmcg_sat_solver_solve( s, plits, pivot + nlitsL );
+    if ( status == GLUCOSE_UNSAT ) // these are enough
+        return bmcg_sat_solver_minimize_assumptions( s, plits, pivot + nlitsL, pivot );
+    // these are not enough
+    // solve for the right lits
+//    nResL = nLitsR == 1 ? 1 : sat_solver_minimize_assumptions( s, pLits + nLitsL, nLitsR, nConfLimit );
+    nresL = nlitsR == 1 ? 1 : bmcg_sat_solver_minimize_assumptions( s, plits, nlits, pivot + nlitsL );
+    // swap literals
+    array->clear();
+    for ( i = 0; i < nlitsL; i++ )
+        array->push(plits[pivot + i]);
+    for ( i = 0; i < nresL; i++ )
+        plits[pivot + i] = plits[pivot + nlitsL + i];
+    for ( i = 0; i < nlitsL; i++ )
+        plits[pivot + nresL + i] = (*array)[i];
+    // solve with these assumptions
+    status = bmcg_sat_solver_solve( s, plits, pivot + nresL );
+    if ( status == GLUCOSE_UNSAT ) // these are enough
+        return nresL;
+    // solve for the left lits
+//    nResR = nLitsL == 1 ? 1 : sat_solver_minimize_assumptions( s, pLits + nResL, nLitsL, nConfLimit );
+    nresR = nlitsL == 1 ? 1 : bmcg_sat_solver_minimize_assumptions( s, plits, pivot + nresL + nlitsL, pivot + nresL );
+    return nresL + nresR;
+}
+
+#endif
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void glucose_print_stats(SimpSolver& s, abctime clk)
+{
+    double cpu_time = (double)(unsigned)clk / CLOCKS_PER_SEC;
+    printf("c restarts              : %d (%d conflicts on average)\n",         (int)s.starts, s.starts > 0 ? (int)(s.conflicts/s.starts) : 0);
+    printf("c blocked restarts      : %d (multiple: %d) \n",                   (int)s.nbstopsrestarts, (int)s.nbstopsrestartssame);
+    printf("c last block at restart : %d\n",                                   (int)s.lastblockatrestart);
+    printf("c nb ReduceDB           : %-12d\n",                                (int)s.nbReduceDB);
+    printf("c nb removed Clauses    : %-12d\n",                                (int)s.nbRemovedClauses);
+    printf("c nb learnts DL2        : %-12d\n",                                (int)s.nbDL2);
+    printf("c nb learnts size 2     : %-12d\n",                                (int)s.nbBin);
+    printf("c nb learnts size 1     : %-12d\n",                                (int)s.nbUn);
+    printf("c conflicts             : %-12d  (%.0f /sec)\n",                   (int)s.conflicts,    s.conflicts   /cpu_time);
+    printf("c decisions             : %-12d  (%4.2f %% random) (%.0f /sec)\n", (int)s.decisions,    (float)s.rnd_decisions*100 / (float)s.decisions, s.decisions   /cpu_time);
+    printf("c propagations          : %-12d  (%.0f /sec)\n",                   (int)s.propagations, s.propagations/cpu_time);
+    printf("c conflict literals     : %-12d  (%4.2f %% deleted)\n",            (int)s.tot_literals, (s.max_literals - s.tot_literals)*100 / (double)s.max_literals);
+    printf("c nb reduced Clauses    : %-12d\n", (int)s.nbReducedClauses);
+    //printf("c CPU time              : %.2f sec\n", cpu_time);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+ABC_NAMESPACE_IMPL_END
diff --git a/lib/abcsat/CMakeLists.txt b/lib/abcsat/CMakeLists.txt
new file mode 100644
index 0000000..edcec0a
--- /dev/null
+++ b/lib/abcsat/CMakeLists.txt
@@ -0,0 +1,23 @@
+cmake_minimum_required (VERSION 3.6)
+
+project(libabcsat LANGUAGES CXX)
+
+include_directories(${PROJECT_SOURCE_DIR})
+file(GLOB ABC_SRC *.cpp)
+
+# Surpress warnings in external library
+if (UNIX)
+    add_compile_options("-w")
+elseif (MSVC)
+    string(REPLACE "/W3" "/w" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+endif()
+
+if (STATIC_LIBABC)
+    add_library(libabcsat STATIC EXCLUDE_FROM_ALL ${ABC_SRC})
+    set_property(TARGET libabcsat PROPERTY OUTPUT_NAME libabcsat)
+else()
+    add_library(libabcsat SHARED EXCLUDE_FROM_ALL ${ABC_SRC})
+    set_property(TARGET libabcsat PROPERTY OUTPUT_NAME libabcsat)
+    set_property(TARGET libabcsat PROPERTY POSITION_INDEPENDENT_CODE ON)
+endif()
+target_include_directories(libabcsat INTERFACE ${PROJECT_SOURCE_DIR})
diff --git a/lib/abcsat/Glucose.cpp b/lib/abcsat/Glucose.cpp
new file mode 100644
index 0000000..10135fe
--- /dev/null
+++ b/lib/abcsat/Glucose.cpp
@@ -0,0 +1,1499 @@
+/***************************************************************************************[Solver.cc]
+ Glucose -- Copyright (c) 2013, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                LRI  - Univ. Paris Sud, France
+ 
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose are exactly the same as Minisat on which it is based on. (see below).
+
+---------------
+
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#include <math.h>
+
+#include "abc/Sort.h"
+#include "abc/Solver.h"
+#include "abc/Constants.h"
+#include "abc/system.h"
+
+ABC_NAMESPACE_IMPL_START
+
+using namespace Gluco;
+
+//=================================================================================================
+// Options:
+
+static const char* _cat = "CORE";
+static const char* _cr = "CORE -- RESTART";
+static const char* _cred = "CORE -- REDUCE";
+static const char* _cm = "CORE -- MINIMIZE";
+static const char* _certified = "CORE -- CERTIFIED UNSAT";
+
+
+const bool opt_incremental = false;
+const double opt_K = 0.8;
+const double opt_R = 1.4;
+const int opt_size_lbd_queue = 50;
+
+const int opt_first_reduce_db = 2000;
+const int opt_inc_reduce_db = 300;
+const int opt_spec_inc_reduce_db = 1000;
+const int opt_lb_lbd_frozen_clause = 30;
+
+const int opt_lb_size_minimzing_clause = 30;
+const int opt_lb_lbd_minimzing_clause = 6;
+
+const double opt_var_decay = 0.8;
+const double opt_clause_decay = 0.999;
+const double opt_random_var_freq = 0;
+const double opt_random_seed = 91648253;
+const int opt_ccmin_mode = 2;
+const int opt_phase_saving = 2;
+const bool opt_rnd_init_act = false;
+/*
+static IntOption     opt_restart_first     (_cat, "rfirst",      "The base restart interval",                                                                100, IntRange(1, INT32_MAX));
+static DoubleOption  opt_restart_inc       (_cat, "rinc",        "Restart interval increase factor",                                                         2, DoubleRange(1, false, HUGE_VAL, false));
+*/
+const double opt_garbage_frac = 0.20;
+
+
+const bool opt_certified_ = false;
+const char* const opt_certified_file_ = "NULL";
+
+
+//=================================================================================================
+// Constructor/Destructor:
+
+
+Solver::Solver() :
+
+    // Parameters (user settable):
+    //
+    SolverType(0)
+    , pCnfFunc(NULL)
+    , nCallConfl(1000)
+    , terminate_search_early(false)
+    , pstop(NULL)
+    , nRuntimeLimit(0)
+
+    , verbosity      (0)
+    , verbEveryConflicts(10000)
+    , showModel      (0)
+    , K              (opt_K)
+    , R              (opt_R)
+    , sizeLBDQueue   (50)
+    , sizeTrailQueue   (5000)
+    , firstReduceDB  (opt_first_reduce_db)
+    , incReduceDB    (opt_inc_reduce_db)
+    , specialIncReduceDB    (opt_spec_inc_reduce_db)
+    , lbLBDFrozenClause (opt_lb_lbd_frozen_clause)
+    , lbSizeMinimizingClause (opt_lb_size_minimzing_clause)
+    , lbLBDMinimizingClause (opt_lb_lbd_minimzing_clause)
+  , var_decay        (opt_var_decay)
+  , clause_decay     (opt_clause_decay)
+  , random_var_freq  (opt_random_var_freq)
+  , random_seed      (opt_random_seed)
+  , ccmin_mode       (opt_ccmin_mode)
+  , phase_saving     (opt_phase_saving)
+  , rnd_pol          (false)
+  , rnd_init_act     (opt_rnd_init_act)
+  , garbage_frac     (opt_garbage_frac)
+  , certifiedOutput  (NULL)
+  , certifiedUNSAT   (opt_certified_) 
+    // Statistics: (formerly in 'SolverStats')
+    //
+  ,  nbRemovedClauses(0),nbReducedClauses(0), nbDL2(0),nbBin(0),nbUn(0) , nbReduceDB(0)
+    , solves(0), starts(0), decisions(0), rnd_decisions(0), propagations(0),conflicts(0),conflictsRestarts(0),nbstopsrestarts(0),nbstopsrestartssame(0),lastblockatrestart(0)
+  , dec_vars(0), clauses_literals(0), learnts_literals(0), max_literals(0), tot_literals(0)
+    , curRestart(1)
+
+  , ok                 (true)
+  , cla_inc            (1)
+  , var_inc            (1)
+  , watches            (WatcherDeleted(ca))
+  , watchesBin            (WatcherDeleted(ca))
+  , qhead              (0)
+  , simpDB_assigns     (-1)
+  , simpDB_props       (0)
+  , order_heap         (VarOrderLt(activity))
+  , progress_estimate  (0)
+  , remove_satisfied   (true)
+
+    // Resource constraints:
+    //
+  , conflict_budget    (-1)
+  , propagation_budget (-1)
+  , asynch_interrupt   (false)
+  , incremental(opt_incremental)
+  , nbVarsInitialFormula(INT32_MAX)
+{
+  MYFLAG=0;  
+  // Initialize only first time. Useful for incremental solving, useless otherwise
+  lbdQueue.initSize(sizeLBDQueue);
+  trailQueue.initSize(sizeTrailQueue);
+  sumLBD = 0;
+  nbclausesbeforereduce = firstReduceDB;
+  totalTime4Sat=0;totalTime4Unsat=0;
+  nbSatCalls=0;nbUnsatCalls=0;
+
+
+  if(certifiedUNSAT) {
+    if(!strcmp(opt_certified_file_,"NULL")) {
+      certifiedOutput =  fopen("/dev/stdout", "wb");
+    } else {
+      certifiedOutput =  fopen(opt_certified_file_, "wb");           
+    }
+    //    fprintf(certifiedOutput,"o proof DRUP\n");
+  }
+}
+
+
+Solver::~Solver()
+{
+}
+
+
+/****************************************************************
+ Set the incremental mode
+****************************************************************/
+
+// This function set the incremental mode to true.
+// You can add special code for this mode here.
+
+void Solver::setIncrementalMode() {
+  incremental = true;
+}
+
+// Number of variables without selectors
+void Solver::initNbInitialVars(int nb) {
+  nbVarsInitialFormula = nb;
+}
+
+
+//=================================================================================================
+// Minor methods:
+
+
+// Creates a new SAT variable in the solver. If 'decision' is cleared, variable will not be
+// used as a decision variable (NOTE! This has effects on the meaning of a SATISFIABLE result).
+//
+Var Solver::newVar(bool sign, bool dvar)
+{
+    int v = nVars();
+    watches  .init(mkLit(v, false));
+    watches  .init(mkLit(v, true ));
+    watchesBin  .init(mkLit(v, false));
+    watchesBin  .init(mkLit(v, true ));
+    assigns  .push(l_Undef);
+    vardata  .push(mkVarData(CRef_Undef, 0));
+    //activity .push(0);
+    activity .push(rnd_init_act ? drand(random_seed) * 0.00001 : 0);
+    seen     .push(0);
+    permDiff .push(0);
+    polarity .push(sign);
+    decision .push();
+    trail    .capacity(v+1);
+    setDecisionVar(v, dvar);
+    return v;
+}
+
+
+
+bool Solver::addClause_(vec<Lit>& ps)
+{
+    assert(decisionLevel() == 0);
+    if (!ok) return false;
+
+    if ( 0 ) {
+        for ( int i = 0; i < ps.size(); i++ )
+            printf( "%s%d ", (toInt(ps[i]) & 1) ? "-":"", toInt(ps[i]) >> 1 );
+        printf( "\n" );
+    }
+
+    // Check if clause is satisfied and remove false/duplicate literals:
+    sort(ps);
+
+    vec<Lit>    oc;
+    oc.clear();
+
+    Lit p; int i, j, flag = 0;
+    if(certifiedUNSAT) {
+      for (i = j = 0, p = lit_Undef; i < ps.size(); i++) {
+        oc.push(ps[i]);
+        if (value(ps[i]) == l_True || ps[i] == ~p || value(ps[i]) == l_False)
+          flag = 1;
+      }
+    }
+
+    for (i = j = 0, p = lit_Undef; i < ps.size(); i++)
+      if (value(ps[i]) == l_True || ps[i] == ~p)
+        return true;
+      else if (value(ps[i]) != l_False && ps[i] != p)
+        ps[j++] = p = ps[i];
+    ps.shrink(i - j);
+
+    if ( 0 ) {
+        for ( int i = 0; i < ps.size(); i++ )
+            printf( "%s%d ", (toInt(ps[i]) & 1) ? "-":"", toInt(ps[i]) >> 1 );
+        printf( "\n" );
+    }
+    
+    if (flag && (certifiedUNSAT)) {
+      for (i = j = 0, p = lit_Undef; i < ps.size(); i++)
+        fprintf(certifiedOutput, "%i ", (var(ps[i]) + 1) * (-2 * sign(ps[i]) + 1));
+      fprintf(certifiedOutput, "0\n");
+
+      fprintf(certifiedOutput, "d ");
+      for (i = j = 0, p = lit_Undef; i < oc.size(); i++)
+        fprintf(certifiedOutput, "%i ", (var(oc[i]) + 1) * (-2 * sign(oc[i]) + 1));
+      fprintf(certifiedOutput, "0\n");
+    }
+
+    if (ps.size() == 0)
+        return ok = false;
+    else if (ps.size() == 1){
+        uncheckedEnqueue(ps[0]);
+        return ok = (propagate() == CRef_Undef);
+    }else{
+        CRef cr = ca.alloc(ps, false);
+        clauses.push(cr);
+        attachClause(cr);
+    }
+
+    return true;
+}
+
+
+void Solver::attachClause(CRef cr) {
+    const Clause& c = ca[cr];
+
+    assert(c.size() > 1);
+    if(c.size()==2) {
+      watchesBin[~c[0]].push(Watcher(cr, c[1]));
+      watchesBin[~c[1]].push(Watcher(cr, c[0]));
+    } else {
+      watches[~c[0]].push(Watcher(cr, c[1]));
+      watches[~c[1]].push(Watcher(cr, c[0]));
+    }
+    if (c.learnt()) learnts_literals += c.size();
+    else            clauses_literals += c.size(); }
+
+
+
+
+void Solver::detachClause(CRef cr, bool strict) {
+    const Clause& c = ca[cr];
+    
+    assert(c.size() > 1);
+    if(c.size()==2) {
+      if (strict){
+        remove(watchesBin[~c[0]], Watcher(cr, c[1]));
+        remove(watchesBin[~c[1]], Watcher(cr, c[0]));
+      }else{
+        // Lazy detaching: (NOTE! Must clean all watcher lists before garbage collecting this clause)
+        watchesBin.smudge(~c[0]);
+        watchesBin.smudge(~c[1]);
+      }
+    } else {
+      if (strict){
+        remove(watches[~c[0]], Watcher(cr, c[1]));
+        remove(watches[~c[1]], Watcher(cr, c[0]));
+      }else{
+        // Lazy detaching: (NOTE! Must clean all watcher lists before garbage collecting this clause)
+        watches.smudge(~c[0]);
+        watches.smudge(~c[1]);
+      }
+    }
+    if (c.learnt()) learnts_literals -= c.size();
+    else            clauses_literals -= c.size(); }
+
+
+void Solver::removeClause(CRef cr) {
+
+  Clause& c = ca[cr];
+
+  if (certifiedUNSAT) {
+    fprintf(certifiedOutput, "d ");
+    for (int i = 0; i < c.size(); i++)
+      fprintf(certifiedOutput, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+    fprintf(certifiedOutput, "0\n");
+  }
+
+  detachClause(cr);
+  // Don't leave pointers to free'd memory!
+  if (locked(c)) vardata[var(c[0])].reason = CRef_Undef;
+  c.mark(1);
+  ca.free_(cr);
+}
+
+
+bool Solver::satisfied(const Clause& c) const {
+  if(incremental)  // Check clauses with many selectors is too time consuming
+    return (value(c[0]) == l_True) || (value(c[1]) == l_True);
+
+  // Default mode.
+    for (int i = 0; i < c.size(); i++)
+        if (value(c[i]) == l_True)
+            return true;
+    return false; 
+}
+
+/************************************************************
+ * Compute LBD functions
+ *************************************************************/
+
+inline unsigned int Solver::computeLBD(const vec<Lit> & lits,int end) {
+  int nblevels = 0;
+  MYFLAG++;
+
+  if(incremental) { // ----------------- INCREMENTAL MODE
+    if(end==-1) end = lits.size();
+    unsigned int nbDone = 0;
+    for(int i=0;i<lits.size();i++) {
+      if(nbDone>=end) break;
+      if(isSelector(var(lits[i]))) continue;
+      nbDone++;
+      int l = level(var(lits[i]));
+      if (permDiff[l] != MYFLAG) {
+        permDiff[l] = MYFLAG;
+        nblevels++;
+      }
+    }
+  } else { // -------- DEFAULT MODE. NOT A LOT OF DIFFERENCES... BUT EASIER TO READ
+    for(int i=0;i<lits.size();i++) {
+      int l = level(var(lits[i]));
+      if (permDiff[l] != MYFLAG) {
+        permDiff[l] = MYFLAG;
+        nblevels++;
+      }
+    }
+  }
+
+  return nblevels;
+}
+
+inline unsigned int Solver::computeLBD(const Clause &c) {
+  int nblevels = 0;
+  MYFLAG++;
+
+  if(incremental) { // ----------------- INCREMENTAL MODE
+     int nbDone = 0;
+    for(int i=0;i<c.size();i++) {
+      if(nbDone>=c.sizeWithoutSelectors()) break;
+      if(isSelector(var(c[i]))) continue;
+      nbDone++;
+      int l = level(var(c[i]));
+      if (permDiff[l] != MYFLAG) {
+        permDiff[l] = MYFLAG;
+        nblevels++;
+      }
+    }
+  } else { // -------- DEFAULT MODE. NOT A LOT OF DIFFERENCES... BUT EASIER TO READ
+    for(int i=0;i<c.size();i++) {
+      int l = level(var(c[i]));
+      if (permDiff[l] != MYFLAG) {
+        permDiff[l] = MYFLAG;
+        nblevels++;
+      }
+    }
+  }
+  return nblevels;
+}
+
+
+/******************************************************************
+ * Minimisation with binary reolution
+ ******************************************************************/
+void Solver::minimisationWithBinaryResolution(vec<Lit> &out_learnt) {
+  
+  // Find the LBD measure                                                                                                         
+  unsigned int lbd = computeLBD(out_learnt);
+  Lit p = ~out_learnt[0];
+  
+  if(lbd<=lbLBDMinimizingClause){
+    MYFLAG++;
+    
+    for(int i = 1;i<out_learnt.size();i++) {
+      permDiff[var(out_learnt[i])] = MYFLAG;
+    }
+
+    vec<Watcher>&  wbin  = watchesBin[p];
+    int nb = 0;
+    for(int k = 0;k<wbin.size();k++) {
+      Lit imp = wbin[k].blocker;
+      if(permDiff[var(imp)]==MYFLAG && value(imp)==l_True) {
+        nb++;
+        permDiff[var(imp)]= MYFLAG-1;
+      }
+      }
+    int l = out_learnt.size()-1;
+    if(nb>0) {
+      nbReducedClauses++;
+      for(int i = 1;i<out_learnt.size()-nb;i++) {
+        if(permDiff[var(out_learnt[i])]!=MYFLAG) {
+          Lit p = out_learnt[l];
+          out_learnt[l] = out_learnt[i];
+          out_learnt[i] = p;
+          l--;i--;
+        }
+      }
+      
+      out_learnt.shrink(nb);
+      
+    }
+  }
+}
+
+// Revert to the state at given level (keeping all assignment at 'level' but not beyond).
+//
+void Solver::cancelUntil(int level) {
+    if (decisionLevel() > level){
+        for (int c = trail.size()-1; c >= trail_lim[level]; c--){
+            Var      x  = var(trail[c]);
+            assigns [x] = l_Undef;
+            if (phase_saving > 1 || ((phase_saving == 1) && c > trail_lim.last()))
+                polarity[x] = sign(trail[c]);
+            insertVarOrder(x); }
+        qhead = trail_lim[level];
+        trail.shrink(trail.size() - trail_lim[level]);
+        trail_lim.shrink(trail_lim.size() - level);
+    } 
+}
+
+
+//=================================================================================================
+// Major methods:
+
+
+Lit Solver::pickBranchLit()
+{
+    Var next = var_Undef;
+
+    // Random decision:
+    if (drand(random_seed) < random_var_freq && !order_heap.empty()){
+        next = order_heap[irand(random_seed,order_heap.size())];
+        if (value(next) == l_Undef && decision[next])
+            rnd_decisions++; }
+
+    // Activity based decision:
+    while (next == var_Undef || value(next) != l_Undef || !decision[next])
+        if (order_heap.empty()){
+            next = var_Undef;
+            break;
+        }else
+            next = order_heap.removeMin();
+    
+    return next == var_Undef ? lit_Undef : mkLit(next, rnd_pol ? drand(random_seed) < 0.5 : (polarity[next] != 0));
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  analyze : (confl : Clause*) (out_learnt : vec<Lit>&) (out_btlevel : int&)  ->  [void]
+|  
+|  Description:
+|    Analyze conflict and produce a reason clause.
+|  
+|    Pre-conditions:
+|      * 'out_learnt' is assumed to be cleared.
+|      * Current decision level must be greater than root level.
+|  
+|    Post-conditions:
+|      * 'out_learnt[0]' is the asserting literal at level 'out_btlevel'.
+|      * If out_learnt.size() > 1 then 'out_learnt[1]' has the greatest decision level of the 
+|        rest of literals. There may be others from the same level though.
+|  
+|________________________________________________________________________________________________@*/
+void Solver::analyze(CRef confl, vec<Lit>& out_learnt,vec<Lit>&selectors, int& out_btlevel,unsigned int &lbd,unsigned int &szWithoutSelectors)
+{
+    int pathC = 0;
+    Lit p     = lit_Undef;
+
+    // Generate conflict clause:
+    //
+    out_learnt.push();      // (leave room for the asserting literal)
+    int index   = trail.size() - 1;
+
+    do{
+        assert(confl != CRef_Undef); // (otherwise should be UIP)
+        Clause& c = ca[confl];
+
+        // Special case for binary clauses
+        // The first one has to be SAT
+        if( p != lit_Undef && c.size()==2 && value(c[0])==l_False) {
+          
+          assert(value(c[1])==l_True);
+          Lit tmp = c[0];
+          c[0] =  c[1], c[1] = tmp;
+        }
+        
+        if (c.learnt()) 
+            claBumpActivity(c);
+
+#ifdef DYNAMICNBLEVEL               
+        // DYNAMIC NBLEVEL trick (see competition'09 companion paper)
+        if(c.learnt()  && c.lbd()>2) { 
+          unsigned int nblevels = computeLBD(c);
+          if(nblevels+1<c.lbd() ) { // improve the LBD
+            if(c.lbd()<=lbLBDFrozenClause) {
+              c.setCanBeDel(false); 
+            }
+            // seems to be interesting : keep it for the next round
+            c.setLBD(nblevels); // Update it
+          }
+        }
+#endif
+
+
+        for (int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++){
+            Lit q = c[j];
+
+            if (!seen[var(q)] && level(var(q)) > 0){
+              if(!isSelector(var(q)))
+                varBumpActivity(var(q));
+              seen[var(q)] = 1;
+              if (level(var(q)) >= decisionLevel()) {
+                pathC++;
+#ifdef UPDATEVARACTIVITY
+                // UPDATEVARACTIVITY trick (see competition'09 companion paper)
+                if(!isSelector(var(q)) && (reason(var(q))!= CRef_Undef)  && ca[reason(var(q))].learnt()) 
+                  lastDecisionLevel.push(q);
+#endif
+                
+              } else {
+                if(isSelector(var(q))) {
+                  assert(value(q) == l_False);
+                  selectors.push(q);
+                } else 
+                  out_learnt.push(q);
+              }
+            }
+        }
+        
+        // Select next clause to look at:
+        while (!seen[var(trail[index--])]);
+        p     = trail[index+1];
+        confl = reason(var(p));
+        seen[var(p)] = 0;
+        pathC--;
+
+    }while (pathC > 0);
+    out_learnt[0] = ~p;
+
+    // Simplify conflict clause:
+    //
+    int i, j;
+
+    for(i = 0;i<selectors.size();i++)  
+      out_learnt.push(selectors[i]);       
+
+    out_learnt.copyTo(analyze_toclear);
+    if (ccmin_mode == 2){
+        uint32_t abstract_level = 0;
+        for (i = 1; i < out_learnt.size(); i++)
+            abstract_level |= abstractLevel(var(out_learnt[i])); // (maintain an abstraction of levels involved in conflict)
+
+        for (i = j = 1; i < out_learnt.size(); i++)
+            if (reason(var(out_learnt[i])) == CRef_Undef || !litRedundant(out_learnt[i], abstract_level))
+                out_learnt[j++] = out_learnt[i];
+        
+    }else if (ccmin_mode == 1){
+        for (i = j = 1; i < out_learnt.size(); i++){
+            Var x = var(out_learnt[i]);
+
+            if (reason(x) == CRef_Undef)
+                out_learnt[j++] = out_learnt[i];
+            else{
+                Clause& c = ca[reason(var(out_learnt[i]))];
+                // Thanks to Siert Wieringa for this bug fix!
+                for (int k = ((c.size()==2) ? 0:1); k < c.size(); k++)
+                    if (!seen[var(c[k])] && level(var(c[k])) > 0){
+                        out_learnt[j++] = out_learnt[i];
+                        break; }
+            }
+        }
+    }else
+        i = j = out_learnt.size();
+
+    max_literals += out_learnt.size();
+    out_learnt.shrink(i - j);
+    tot_literals += out_learnt.size();
+
+
+    /* ***************************************
+      Minimisation with binary clauses of the asserting clause
+      First of all : we look for small clauses
+      Then, we reduce clauses with small LBD.
+      Otherwise, this can be useless
+     */
+    if(!incremental && out_learnt.size()<=lbSizeMinimizingClause) {
+      minimisationWithBinaryResolution(out_learnt);
+    }
+    // Find correct backtrack level:
+    //
+    if (out_learnt.size() == 1)
+        out_btlevel = 0;
+    else{
+        int max_i = 1;
+        // Find the first literal assigned at the next-highest level:
+        for (int i = 2; i < out_learnt.size(); i++)
+            if (level(var(out_learnt[i])) > level(var(out_learnt[max_i])))
+                max_i = i;
+        // Swap-in this literal at index 1:
+        Lit p             = out_learnt[max_i];
+        out_learnt[max_i] = out_learnt[1];
+        out_learnt[1]     = p;
+        out_btlevel       = level(var(p));
+    }
+
+
+    // Compute the size of the clause without selectors (incremental mode)
+    if(incremental) {
+      szWithoutSelectors = 0;
+      for(int i=0;i<out_learnt.size();i++) {
+        if(!isSelector(var((out_learnt[i])))) szWithoutSelectors++; 
+        else if(i>0) break;
+      }
+    } else 
+      szWithoutSelectors = out_learnt.size();
+    
+    // Compute LBD
+    lbd = computeLBD(out_learnt,out_learnt.size()-selectors.size());
+
+  
+#ifdef UPDATEVARACTIVITY
+  // UPDATEVARACTIVITY trick (see competition'09 companion paper)
+  if(lastDecisionLevel.size()>0) {
+    for(int i = 0;i<lastDecisionLevel.size();i++) {
+      if(ca[reason(var(lastDecisionLevel[i]))].lbd()<lbd)
+        varBumpActivity(var(lastDecisionLevel[i]));
+    }
+    lastDecisionLevel.clear();
+  } 
+#endif      
+
+
+
+  for (j = 0; j < analyze_toclear.size(); j++) seen[var(analyze_toclear[j])] = 0;    // ('seen[]' is now cleared)
+  for(j = 0 ; j<selectors.size() ; j++) seen[var(selectors[j])] = 0;  
+}
+
+
+// Check if 'p' can be removed. 'abstract_levels' is used to abort early if the algorithm is
+// visiting literals at levels that cannot be removed later.
+bool Solver::litRedundant(Lit p, uint32_t abstract_levels)
+{
+    analyze_stack.clear(); analyze_stack.push(p);
+    int top = analyze_toclear.size();
+    while (analyze_stack.size() > 0){
+        assert(reason(var(analyze_stack.last())) != CRef_Undef);
+        Clause& c = ca[reason(var(analyze_stack.last()))]; analyze_stack.pop();
+        if(c.size()==2 && value(c[0])==l_False) {
+          assert(value(c[1])==l_True);
+          Lit tmp = c[0];
+          c[0] =  c[1], c[1] = tmp;
+        }
+
+        for (int i = 1; i < c.size(); i++){
+            Lit p  = c[i];
+            if (!seen[var(p)] && level(var(p)) > 0){
+                if (reason(var(p)) != CRef_Undef && (abstractLevel(var(p)) & abstract_levels) != 0){
+                    seen[var(p)] = 1;
+                    analyze_stack.push(p);
+                    analyze_toclear.push(p);
+                }else{
+                    for (int j = top; j < analyze_toclear.size(); j++)
+                        seen[var(analyze_toclear[j])] = 0;
+                    analyze_toclear.shrink(analyze_toclear.size() - top);
+                    return false;
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  analyzeFinal : (p : Lit)  ->  [void]
+|  
+|  Description:
+|    Specialized analysis procedure to express the final conflict in terms of assumptions.
+|    Calculates the (possibly empty) set of assumptions that led to the assignment of 'p', and
+|    stores the result in 'out_conflict'.
+|________________________________________________________________________________________________@*/
+void Solver::analyzeFinal(Lit p, vec<Lit>& out_conflict)
+{
+    out_conflict.clear();
+    out_conflict.push(p);
+
+    if (decisionLevel() == 0)
+        return;
+
+    seen[var(p)] = 1;
+
+    for (int i = trail.size()-1; i >= trail_lim[0]; i--){
+        Var x = var(trail[i]);
+        if (seen[x]){
+            if (reason(x) == CRef_Undef){
+                assert(level(x) > 0);
+                out_conflict.push(~trail[i]);
+            }else{
+                Clause& c = ca[reason(x)];
+                //                for (int j = 1; j < c.size(); j++) Minisat (glucose 2.0) loop 
+                // Bug in case of assumptions due to special data structures for Binary.
+                // Many thanks to Sam Bayless (sbayless@cs.ubc.ca) for discover this bug.
+                for (int j = ((c.size()==2) ? 0:1); j < c.size(); j++)
+                    if (level(var(c[j])) > 0)
+                        seen[var(c[j])] = 1;
+            }  
+
+            seen[x] = 0;
+        }
+    }
+
+    seen[var(p)] = 0;
+}
+
+
+void Solver::uncheckedEnqueue(Lit p, CRef from)
+{
+    assert(value(p) == l_Undef);
+    assigns[var(p)] = lbool(!sign(p));
+    vardata[var(p)] = mkVarData(from, decisionLevel());
+    trail.push_(p);
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  propagate : [void]  ->  [Clause*]
+|  
+|  Description:
+|    Propagates all enqueued facts. If a conflict arises, the conflicting clause is returned,
+|    otherwise CRef_Undef.
+|  
+|    Post-conditions:
+|      * the propagation queue is empty, even if there was a conflict.
+|________________________________________________________________________________________________@*/
+CRef Solver::propagate()
+{
+    CRef    confl     = CRef_Undef;
+    int     num_props = 0;
+    watches.cleanAll();
+    watchesBin.cleanAll();
+    while (qhead < trail.size()){
+        Lit            p   = trail[qhead++];     // 'p' is enqueued fact to propagate.
+        vec<Watcher>&  ws  = watches[p];
+        Watcher        *i, *j, *end;
+        num_props++;
+        
+        // First, Propagate binary clauses 
+        vec<Watcher>&  wbin  = watchesBin[p];
+        for(int k = 0;k<wbin.size();k++) {
+          Lit imp = wbin[k].blocker;
+          if(value(imp) == l_False) {
+            return wbin[k].cref;
+          }
+          if(value(imp) == l_Undef) {
+            uncheckedEnqueue(imp,wbin[k].cref);
+          }
+        }
+
+        for (i = j = (Watcher*)ws, end = i + ws.size();  i != end;){
+            // Try to avoid inspecting the clause:
+            Lit blocker = i->blocker;
+            if (value(blocker) == l_True){
+                *j++ = *i++; continue; }
+
+            // Make sure the false literal is data[1]:
+            CRef     cr        = i->cref;
+            Clause&  c         = ca[cr];
+            Lit      false_lit = ~p;
+            if (c[0] == false_lit)
+                c[0] = c[1], c[1] = false_lit;
+            assert(c[1] == false_lit);
+            i++;
+
+            // If 0th watch is true, then clause is already satisfied.
+            Lit     first = c[0];
+            Watcher w     = Watcher(cr, first);
+            if (first != blocker && value(first) == l_True){
+              *j++ = w; continue; }
+
+            // Look for new watch:
+            if(incremental) { // ----------------- INCREMENTAL MODE
+              int choosenPos = -1;
+              for (int k = 2; k < c.size(); k++) {
+                
+                if (value(c[k]) != l_False){
+                  if(decisionLevel()>assumptions.size()) {
+                    choosenPos = k;
+                    break;
+                  } else {
+                    choosenPos = k;
+                    
+                    if(value(c[k])==l_True || !isSelector(var(c[k]))) {
+                      break;
+                    }
+                  }
+
+                }
+              }
+              if(choosenPos!=-1) {
+                c[1] = c[choosenPos]; c[choosenPos] = false_lit;
+                watches[~c[1]].push(w);
+                goto NextClause; }
+            } else {  // ----------------- DEFAULT  MODE (NOT INCREMENTAL)
+              for (int k = 2; k < c.size(); k++) {
+                
+                if (value(c[k]) != l_False){
+                  c[1] = c[k]; c[k] = false_lit;
+                  watches[~c[1]].push(w);
+                  goto NextClause; }
+              }
+            }
+
+            // Did not find watch -- clause is unit under assignment:
+            *j++ = w;
+            if (value(first) == l_False){
+                confl = cr;
+                qhead = trail.size();
+                // Copy the remaining watches:
+                while (i < end)
+                    *j++ = *i++;
+            }else {
+                uncheckedEnqueue(first, cr);
+          
+                
+            }
+        NextClause:;
+        }
+        ws.shrink(i - j);
+    }
+    propagations += num_props;
+    simpDB_props -= num_props;
+    
+    return confl;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  reduceDB : ()  ->  [void]
+|  
+|  Description:
+|    Remove half of the learnt clauses, minus the clauses locked by the current assignment. Locked
+|    clauses are clauses that are reason to some assignment. Binary clauses are never removed.
+|________________________________________________________________________________________________@*/
+struct reduceDB_lt { 
+    ClauseAllocator& ca;
+    reduceDB_lt(ClauseAllocator& ca_) : ca(ca_) {}
+    bool operator () (CRef x, CRef y) { 
+ 
+    // Main criteria... Like in MiniSat we keep all binary clauses
+    if(ca[x].size()> 2 && ca[y].size()==2) return 1;
+    
+    if(ca[y].size()> 2 && ca[x].size()==2) return 0;
+    if(ca[x].size()==2 && ca[y].size()==2) return 0;
+    
+    // Second one  based on literal block distance
+    if(ca[x].lbd()> ca[y].lbd()) return 1;
+    if(ca[x].lbd()< ca[y].lbd()) return 0;    
+    
+    // Finally we can use old activity or size, we choose the last one
+    return ca[x].activity() < ca[y].activity();
+    //return x->size() < y->size();
+    //return ca[x].size() > 2 && (ca[y].size() == 2 || ca[x].activity() < ca[y].activity()); } 
+    }    
+};
+
+void Solver::reduceDB()
+{ 
+  int i, j;
+  nbReduceDB++;
+  sort(learnts, reduceDB_lt(ca));
+
+  // We have a lot of "good" clauses, it is difficult to compare them. Keep more !
+  if(ca[learnts[learnts.size() / RATIOREMOVECLAUSES]].lbd()<=3) nbclausesbeforereduce +=specialIncReduceDB; 
+  // Useless :-)
+  if(ca[learnts.last()].lbd()<=5)  nbclausesbeforereduce +=specialIncReduceDB;   
+  
+  // Don't delete binary or locked clauses. From the rest, delete clauses from the first half
+  // Keep clauses which seem to be usefull (their lbd was reduce during this sequence)
+
+  int limit = learnts.size() / 2;
+  for (i = j = 0; i < learnts.size(); i++){
+    Clause& c = ca[learnts[i]];
+    if (c.lbd()>2 && c.size() > 2 && c.canBeDel() &&  !locked(c) && (i < limit)) {
+      removeClause(learnts[i]);
+      nbRemovedClauses++;
+    }
+    else {
+      if(!c.canBeDel()) limit++; //we keep c, so we can delete an other clause
+      c.setCanBeDel(true);       // At the next step, c can be delete
+      learnts[j++] = learnts[i];
+    }
+  }
+  learnts.shrink(i - j);
+  checkGarbage();
+}
+
+
+void Solver::removeSatisfied(vec<CRef>& cs)
+{
+    int i, j;
+    for (i = j = 0; i < cs.size(); i++){
+        Clause& c = ca[cs[i]];
+        if (satisfied(c)) 
+            removeClause(cs[i]);
+        else
+            cs[j++] = cs[i];
+    }
+    cs.shrink(i - j);
+}
+
+
+void Solver::rebuildOrderHeap()
+{
+    vec<Var> vs;
+    for (Var v = 0; v < nVars(); v++)
+        if (decision[v] && value(v) == l_Undef)
+            vs.push(v);
+    order_heap.build(vs);
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  simplify : [void]  ->  [bool]
+|  
+|  Description:
+|    Simplify the clause database according to the current top-level assigment. Currently, the only
+|    thing done here is the removal of satisfied clauses, but more things can be put here.
+|________________________________________________________________________________________________@*/
+bool Solver::simplify()
+{
+    assert(decisionLevel() == 0);
+
+    if (!ok || propagate() != CRef_Undef)
+        return ok = false;
+
+    if (nAssigns() == simpDB_assigns || (simpDB_props > 0))
+        return true;
+
+    // Remove satisfied clauses:
+    removeSatisfied(learnts);
+    if (remove_satisfied)        // Can be turned off.
+        removeSatisfied(clauses);
+
+    checkGarbage();
+
+    rebuildOrderHeap();
+
+    simpDB_assigns = nAssigns();
+    simpDB_props   = clauses_literals + learnts_literals;   // (shouldn't depend on stats really, but it will do for now)
+
+    return true;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  search : (nof_conflicts : int) (params : const SearchParams&)  ->  [lbool]
+|  
+|  Description:
+|    Search for a model the specified number of conflicts. 
+|    NOTE! Use negative value for 'nof_conflicts' indicate infinity.
+|  
+|  Output:
+|    'l_True' if a partial assigment that is consistent with respect to the clauseset is found. If
+|    all variables are decision variables, this means that the clause set is satisfiable. 'l_False'
+|    if the clause set is unsatisfiable. 'l_Undef' if the bound on number of conflicts is reached.
+|________________________________________________________________________________________________@*/
+lbool Solver::search(int nof_conflicts)
+{
+    assert(ok);
+    int         backtrack_level;
+    int         conflictC = 0;
+    vec<Lit>    learnt_clause,selectors;
+    unsigned int nblevels,szWoutSelectors;
+    bool blocked=false;
+    starts++;
+    for (;;){
+        CRef confl = propagate();
+        if (confl != CRef_Undef){
+            // CONFLICT
+          conflicts++; conflictC++;conflictsRestarts++;
+          if(conflicts%5000==0 && var_decay<0.95)
+            var_decay += 0.01;
+
+          if (verbosity >= 1 && conflicts%verbEveryConflicts==0){
+            printf("c | %8d   %7d    %5d | %7d %8d %8d | %5d %8d   %6d %8d | %6.3f %% |\n", 
+                   (int)starts,(int)nbstopsrestarts, (int)(conflicts/starts), 
+                   (int)dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]), nClauses(), (int)clauses_literals, 
+                   (int)nbReduceDB, nLearnts(), (int)nbDL2,(int)nbRemovedClauses, progressEstimate()*100);
+          }
+          if (decisionLevel() == 0) {
+            return l_False;
+            
+          }
+
+          trailQueue.push(trail.size());
+          // BLOCK RESTART (CP 2012 paper)
+          if( conflictsRestarts>LOWER_BOUND_FOR_BLOCKING_RESTART && lbdQueue.isvalid()  && trail.size()>R*trailQueue.getavg()) {
+            lbdQueue.fastclear();
+            nbstopsrestarts++;
+            if(!blocked) {lastblockatrestart=starts;nbstopsrestartssame++;blocked=true;}
+          }
+
+            learnt_clause.clear();
+            selectors.clear();
+            analyze(confl, learnt_clause, selectors,backtrack_level,nblevels,szWoutSelectors);
+
+            lbdQueue.push(nblevels);
+            sumLBD += nblevels;
+ 
+            cancelUntil(backtrack_level);
+
+            if (certifiedUNSAT) {
+              for (int i = 0; i < learnt_clause.size(); i++)
+                fprintf(certifiedOutput, "%i " , (var(learnt_clause[i]) + 1) *
+                            (-2 * sign(learnt_clause[i]) + 1) );
+              fprintf(certifiedOutput, "0\n");
+            }
+
+            if (learnt_clause.size() == 1){
+              uncheckedEnqueue(learnt_clause[0]);nbUn++;
+            }else{
+                CRef cr = ca.alloc(learnt_clause, true);
+                ca[cr].setLBD(nblevels); 
+                ca[cr].setSizeWithoutSelectors(szWoutSelectors);
+                if(nblevels<=2) nbDL2++; // stats
+                if(ca[cr].size()==2) nbBin++; // stats
+                learnts.push(cr);
+                attachClause(cr);
+
+                claBumpActivity(ca[cr]);
+                uncheckedEnqueue(learnt_clause[0], cr);
+            }
+            varDecayActivity();
+            claDecayActivity();
+
+           
+        }else{
+
+          // Our dynamic restart, see the SAT09 competition compagnion paper 
+          if ( (conflictsRestarts && lbdQueue.isvalid() && lbdQueue.getavg()*K > sumLBD/conflictsRestarts) || (pstop && *pstop) ) {
+            lbdQueue.fastclear();
+            progress_estimate = progressEstimate();
+            int bt = 0;
+            if(incremental) { // DO NOT BACKTRACK UNTIL 0.. USELESS
+              bt = (decisionLevel()<assumptions.size()) ? decisionLevel() : assumptions.size();
+            }
+            cancelUntil(bt);
+            return l_Undef; 
+          }
+
+           // Simplify the set of problem clauses:
+          if (decisionLevel() == 0 && !simplify()) {
+            return l_False;
+          }
+            // Perform clause database reduction !
+            if(conflicts>=curRestart* nbclausesbeforereduce) 
+              {
+                  
+                assert(learnts.size()>0);
+                curRestart = (conflicts/ nbclausesbeforereduce)+1;
+                reduceDB();
+                nbclausesbeforereduce += incReduceDB;
+              }
+
+            Lit next = lit_Undef;
+            while (decisionLevel() < assumptions.size()){
+                // Perform user provided assumption:
+                Lit p = assumptions[decisionLevel()];
+                if (value(p) == l_True){
+                    // Dummy decision level:
+                    newDecisionLevel();
+                }else if (value(p) == l_False){
+                    analyzeFinal(~p, conflict);
+                    return l_False;
+                }else{
+                    next = p;
+                    break;
+                }
+            }
+
+            if (next == lit_Undef){
+                // New variable decision:
+                decisions++;
+                next = pickBranchLit();
+
+                if (next == lit_Undef){
+                  //printf("c last restart ## conflicts  :  %d %d \n",conflictC,decisionLevel());
+                  // Model found:
+                  return l_True;
+                }
+            }
+
+            // Increase decision level and enqueue 'next'
+            newDecisionLevel();
+            uncheckedEnqueue(next);
+        }
+    }
+}
+
+
+double Solver::progressEstimate() const
+{
+    double  progress = 0;
+    double  F = 1.0 / nVars();
+
+    for (int i = 0; i <= decisionLevel(); i++){
+        int beg = i == 0 ? 0 : trail_lim[i - 1];
+        int end = i == decisionLevel() ? trail.size() : trail_lim[i];
+        progress += pow(F, i) * (end - beg);
+    }
+
+    return progress / nVars();
+}
+
+void Solver::printIncrementalStats() {
+
+  printf("c---------- Glucose Stats -------------------------\n");
+  printf("c restarts              : %ld\n", starts);
+  printf("c nb ReduceDB           : %ld\n", nbReduceDB);
+  printf("c nb removed Clauses    : %ld\n", nbRemovedClauses);
+  printf("c nb learnts DL2        : %ld\n", nbDL2);
+  printf("c nb learnts size 2     : %ld\n", nbBin);
+  printf("c nb learnts size 1     : %ld\n", nbUn);
+
+  printf("c conflicts             : %ld\n", conflicts);
+  printf("c decisions             : %ld\n", decisions);
+  printf("c propagations          : %ld\n", propagations);
+
+  printf("c SAT Calls             : %d in %g seconds\n", nbSatCalls,   totalTime4Sat);
+  printf("c UNSAT Calls           : %d in %g seconds\n", nbUnsatCalls, totalTime4Unsat);
+  printf("c--------------------------------------------------\n");
+
+
+}
+
+
+// NOTE: assumptions passed in member-variable 'assumptions'.
+lbool Solver::solve_()
+{
+
+  if(incremental && certifiedUNSAT) {
+    printf("Can not use incremental and certified unsat in the same time\n");
+    exit(-1);
+  }
+    model.clear();
+    conflict.clear();
+    if (!ok) return l_False;
+    double curTime = cpuTime();
+
+    
+    solves++;
+            
+
+    
+    lbool   status        = l_Undef;
+    if(!incremental && verbosity>=1) {
+      printf("c ========================================[ MAGIC CONSTANTS ]==============================================\n");
+      printf("c | Constants are supposed to work well together :-)                                                      |\n");
+      printf("c | however, if you find better choices, please let us known...                                           |\n");
+      printf("c |-------------------------------------------------------------------------------------------------------|\n");
+    printf("c |                                |                                |                                     |\n"); 
+    printf("c | - Restarts:                    | - Reduce Clause DB:            | - Minimize Asserting:               |\n");
+    printf("c |   * LBD Queue    : %6d      |   * First     : %6d         |    * size < %3d                     |\n",lbdQueue.maxSize(),nbclausesbeforereduce,lbSizeMinimizingClause);
+    printf("c |   * Trail  Queue : %6d      |   * Inc       : %6d         |    * lbd  < %3d                     |\n",trailQueue.maxSize(),incReduceDB,lbLBDMinimizingClause);
+    printf("c |   * K            : %6.2f      |   * Special   : %6d         |                                     |\n",K,specialIncReduceDB);
+    printf("c |   * R            : %6.2f      |   * Protected :  (lbd)< %2d     |                                     |\n",R,lbLBDFrozenClause);
+    printf("c |                                |                                |                                     |\n"); 
+printf("c ==================================[ Search Statistics (every %6d conflicts) ]=========================\n",verbEveryConflicts);
+      printf("c |                                                                                                       |\n"); 
+
+      printf("c |          RESTARTS           |          ORIGINAL         |              LEARNT              | Progress |\n");
+      printf("c |       NB   Blocked  Avg Cfc |    Vars  Clauses Literals |   Red   Learnts    LBD2  Removed |          |\n");
+      printf("c =========================================================================================================\n");
+    }
+
+    // Search:
+    int curr_restarts = 0;
+    while (status == l_Undef){
+      status = search(0); // the parameter is useless in glucose, kept to allow modifications
+        if (!withinBudget() || terminate_search_early || (pstop && *pstop)) break;
+        if (nRuntimeLimit && Abc_Clock() > nRuntimeLimit)                   break;
+        curr_restarts++;
+    }
+
+    if (!incremental && verbosity >= 1)
+      printf("c =========================================================================================================\n");
+
+
+    if (certifiedUNSAT){ // Want certified output
+      if (status == l_False)
+        fprintf(certifiedOutput, "0\n");
+      fclose(certifiedOutput);
+    }
+
+
+    if (status == l_True){
+        // Extend & copy model:
+        model.growTo(nVars());
+        for (int i = 0; i < nVars(); i++) model[i] = value(i);
+    }else if (status == l_False && conflict.size() == 0)
+        ok = false;
+
+    cancelUntil(0);
+
+    double finalTime = cpuTime();
+    if(status==l_True) {
+      nbSatCalls++; 
+      totalTime4Sat +=(finalTime-curTime);
+    }
+    if(status==l_False) {
+      nbUnsatCalls++; 
+      totalTime4Unsat +=(finalTime-curTime);
+    }
+
+    // ABC callback
+    if (pCnfFunc && !terminate_search_early) {// hack to avoid calling callback twise if the solver was terminated early
+        int * pCex = NULL;
+        int message = (status == l_True ? 1 : status == l_False ? 0 : -1);
+        if (status == l_True) {
+            pCex = new int[nVars()];
+            for (int i = 0; i < nVars(); i++)
+                pCex[i] = (model[i] == l_True);
+        }
+        
+        int callback_result = pCnfFunc(pCnfMan, message, pCex);
+        assert(callback_result == 0);
+    }
+    else if (pCnfFunc)
+        terminate_search_early = false; // for next run
+
+    return status;
+}
+
+//=================================================================================================
+// Writing CNF to DIMACS:
+// 
+// FIXME: this needs to be rewritten completely.
+
+static Var mapVar(Var x, vec<Var>& map, Var& max)
+{
+    if (map.size() <= x || map[x] == -1){
+        map.growTo(x+1, -1);
+        map[x] = max++;
+    }
+    return map[x];
+}
+
+
+void Solver::toDimacs(FILE* f, Clause& c, vec<Var>& map, Var& max)
+{
+    if (satisfied(c)) return;
+
+    for (int i = 0; i < c.size(); i++)
+        if (value(c[i]) != l_False)
+            fprintf(f, "%s%d ", sign(c[i]) ? "-" : "", mapVar(var(c[i]), map, max)+1);
+    fprintf(f, "0\n");
+}
+
+
+void Solver::toDimacs(const char *file, const vec<Lit>& assumps)
+{
+    FILE* f = fopen(file, "wr");
+    if (f == NULL)
+        fprintf(stderr, "could not open file %s\n", file), exit(1);
+    toDimacs(f, assumps);
+    fclose(f);
+}
+
+
+void Solver::toDimacs(FILE* f, const vec<Lit>& assumps)
+{
+    // Handle case when solver is in contradictory state:
+    if (!ok){
+        fprintf(f, "p cnf 1 2\n1 0\n-1 0\n");
+        return; }
+
+    vec<Var> map; Var max = 0;
+
+    // Cannot use removeClauses here because it is not safe
+    // to deallocate them at this point. Could be improved.
+    int i, cnt = 0;
+    for (i = 0; i < clauses.size(); i++)
+        if (!satisfied(ca[clauses[i]]))
+            cnt++;
+        
+    for (i = 0; i < clauses.size(); i++)
+        if (!satisfied(ca[clauses[i]])){
+            Clause& c = ca[clauses[i]];
+            for (int j = 0; j < c.size(); j++)
+                if (value(c[j]) != l_False)
+                    mapVar(var(c[j]), map, max);
+        }
+
+    // Assumptions are added as unit clauses:
+    cnt += assumptions.size();
+
+    fprintf(f, "p cnf %d %d\n", max, cnt);
+
+    for (i = 0; i < assumptions.size(); i++){
+        assert(value(assumptions[i]) != l_False);
+        fprintf(f, "%s%d 0\n", sign(assumptions[i]) ? "-" : "", mapVar(var(assumptions[i]), map, max)+1);
+    }
+
+    for (i = 0; i < clauses.size(); i++)
+        toDimacs(f, ca[clauses[i]], map, max);
+
+    if (verbosity > 0)
+        printf("Wrote %d clauses with %d variables.\n", cnt, max);
+}
+
+
+//=================================================================================================
+// Garbage Collection methods:
+
+void Solver::relocAll(ClauseAllocator& to)
+{
+    int v, s, i, j;
+    // All watchers:
+    //
+    // for (int i = 0; i < watches.size(); i++)
+    watches.cleanAll();
+    watchesBin.cleanAll();
+    for (v = 0; v < nVars(); v++)
+        for (s = 0; s < 2; s++){
+            Lit p = mkLit(v, s != 0);
+            // printf(" >>> RELOCING: %s%d\n", sign(p)?"-":"", var(p)+1);
+            vec<Watcher>& ws = watches[p];
+            for (j = 0; j < ws.size(); j++)
+                ca.reloc(ws[j].cref, to);
+            vec<Watcher>& ws2 = watchesBin[p];
+            for (j = 0; j < ws2.size(); j++)
+                ca.reloc(ws2[j].cref, to);
+        }
+
+    // All reasons:
+    //
+    for (i = 0; i < trail.size(); i++){
+        Var v = var(trail[i]);
+
+        if (reason(v) != CRef_Undef && (ca[reason(v)].reloced() || locked(ca[reason(v)])))
+            ca.reloc(vardata[v].reason, to);
+    }
+
+    // All learnt:
+    //
+    for (i = 0; i < learnts.size(); i++)
+        ca.reloc(learnts[i], to);
+
+    // All original:
+    //
+    for (i = 0; i < clauses.size(); i++)
+        ca.reloc(clauses[i], to);
+}
+
+
+void Solver::garbageCollect()
+{
+    // Initialize the next region to a size corresponding to the estimated utilization degree. This
+    // is not precise but should avoid some unnecessary reallocations for the new region:
+    ClauseAllocator to(ca.size() - ca.wasted()); 
+
+    relocAll(to);
+    if (verbosity >= 2)
+        printf("|  Garbage collection:   %12d bytes => %12d bytes             |\n", 
+               ca.size()*ClauseAllocator::Unit_Size, to.size()*ClauseAllocator::Unit_Size);
+    to.moveTo(ca);
+}
+
+void Solver::reset() 
+{
+    // Reset everything
+    ok = true;
+    K = (double)opt_K;
+    R = (double)opt_R;
+    firstReduceDB = opt_first_reduce_db;
+    var_decay = (double)opt_var_decay;
+    //max_var_decay = opt_max_var_decay;
+    solves = starts = decisions = propagations = conflicts = conflictsRestarts = 0;
+    curRestart = 1;
+    cla_inc = var_inc = 1;
+    watches.clear(false); // We don't free the memory, new calls should be of the same size order.
+    watchesBin.clear(false); 
+    //unaryWatches.clear(false);
+    qhead = 0;
+    simpDB_assigns = -1;
+    simpDB_props = 0;
+    order_heap.clear(false);
+    progress_estimate = 0;
+    //lastLearntClause = CRef_Undef;
+    conflict_budget = -1;
+    propagation_budget = -1;
+    nbVarsInitialFormula = INT32_MAX;
+    totalTime4Sat = 0.;
+    totalTime4Unsat = 0.;
+    nbSatCalls = nbUnsatCalls = 0;
+    MYFLAG = 0;
+    lbdQueue.clear(false);
+    lbdQueue.initSize(sizeLBDQueue);
+    trailQueue.clear(false);
+    trailQueue.initSize(sizeTrailQueue);
+    sumLBD = 0;
+    nbclausesbeforereduce = firstReduceDB;
+    //stats.clear();
+    //stats.growTo(coreStatsSize, 0);
+    clauses.clear(false);
+    learnts.clear(false);
+    //permanentLearnts.clear(false);
+    //unaryWatchedClauses.clear(false);
+    model.clear(false);
+    conflict.clear(false);
+    activity.clear(false);
+    assigns.clear(false);
+    polarity.clear(false);
+    //forceUNSAT.clear(false);
+    decision.clear(false);
+    trail.clear(false);
+    nbpos.clear(false);
+    trail_lim.clear(false);
+    vardata.clear(false);
+    assumptions.clear(false);
+    permDiff.clear(false);
+    lastDecisionLevel.clear(false);
+    ca.clear();
+    seen.clear(false);
+    analyze_stack.clear(false);
+    analyze_toclear.clear(false);
+    add_tmp.clear(false);
+    assumptionPositions.clear(false);
+    initialPositions.clear(false);
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/lib/abcsat/SimpSolver.cpp b/lib/abcsat/SimpSolver.cpp
new file mode 100644
index 0000000..15279f3
--- /dev/null
+++ b/lib/abcsat/SimpSolver.cpp
@@ -0,0 +1,761 @@
+/***********************************************************************************[SimpSolver.cc]
+Copyright (c) 2006,      Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#include "abc/Sort.h"
+#include "abc/SimpSolver.h"
+#include "abc/system.h"
+
+ABC_NAMESPACE_IMPL_START
+
+using namespace Gluco;
+
+//=================================================================================================
+// Options:
+
+
+static const char* _cat = "SIMP";
+
+//=================================================================================================
+// Constructor/Destructor:
+
+
+SimpSolver::SimpSolver() :
+    grow               (0)
+  , clause_lim         (20)
+  , subsumption_lim    (1000)
+  , simp_garbage_frac  (0.5)
+  , use_asymm          (false)
+  , use_rcheck         (false)
+  , use_elim           (true)
+  , merges             (0)
+  , asymm_lits         (0)
+  , eliminated_vars    (0)
+  , eliminated_clauses (0)
+  , elimorder          (1)
+  , use_simplification (true)
+  , occurs             (ClauseDeleted(ca))
+  , elim_heap          (ElimLt(n_occ))
+  , bwdsub_assigns     (0)
+  , n_touched          (0)
+{
+    vec<Lit> dummy(1,lit_Undef);
+    ca.extra_clause_field = true; // NOTE: must happen before allocating the dummy clause below.
+    bwdsub_tmpunit        = ca.alloc(dummy);
+    remove_satisfied      = false;
+}
+
+
+SimpSolver::~SimpSolver()
+{
+}
+
+
+Var SimpSolver::newVar(bool sign, bool dvar) {
+    Var v = Solver::newVar(sign, dvar);
+
+    frozen    .push((char)false);
+    eliminated.push((char)false);
+
+    if (use_simplification){
+        n_occ     .push(0);
+        n_occ     .push(0);
+        occurs    .init(v);
+        touched   .push(0);
+        elim_heap .insert(v);
+    }
+    return v; }
+
+
+
+lbool SimpSolver::solve_(bool do_simp, bool turn_off_simp)
+{
+    vec<Var> extra_frozen;
+    lbool    result = l_True;
+
+    do_simp &= use_simplification;
+
+    if (do_simp){
+        // Assumptions must be temporarily frozen to run variable elimination:
+        for (int i = 0; i < assumptions.size(); i++){
+            Var v = var(assumptions[i]);
+
+            // If an assumption has been eliminated, remember it.
+            assert(!isEliminated(v));
+
+            if (!frozen[v]){
+                // Freeze and store.
+                setFrozen(v, true);
+                extra_frozen.push(v);
+            } }
+
+        result = lbool(eliminate(turn_off_simp));
+    }
+
+    if (result == l_True)
+        result = Solver::solve_();
+    else if (verbosity >= 1)
+        printf("===============================================================================\n");
+
+    if (result == l_True)
+        extendModel();
+
+    if (do_simp)
+        // Unfreeze the assumptions that were frozen:
+        for (int i = 0; i < extra_frozen.size(); i++)
+            setFrozen(extra_frozen[i], false);
+
+    return result;
+}
+
+
+
+bool SimpSolver::addClause_(vec<Lit>& ps)
+{
+#ifndef NDEBUG
+    for (int i = 0; i < ps.size(); i++)
+        assert(!isEliminated(var(ps[i])));
+#endif
+    int nclauses = clauses.size();
+
+    if (use_rcheck && implied(ps))
+        return true;
+
+    if (!Solver::addClause_(ps))
+        return false;
+
+    if (use_simplification && clauses.size() == nclauses + 1){
+        CRef          cr = clauses.last();
+        const Clause& c  = ca[cr];
+
+        // NOTE: the clause is added to the queue immediately and then
+        // again during 'gatherTouchedClauses()'. If nothing happens
+        // in between, it will only be checked once. Otherwise, it may
+        // be checked twice unnecessarily. This is an unfortunate
+        // consequence of how backward subsumption is used to mimic
+        // forward subsumption.
+        subsumption_queue.insert(cr);
+        for (int i = 0; i < c.size(); i++){
+            occurs[var(c[i])].push(cr);
+            n_occ[toInt(c[i])]++;
+            touched[var(c[i])] = 1;
+            n_touched++;
+            if (elim_heap.inHeap(var(c[i])))
+                elim_heap.increase(var(c[i]));
+        }
+    }
+
+    return true;
+}
+
+
+void SimpSolver::removeClause(CRef cr)
+{
+    const Clause& c = ca[cr];
+
+    if (use_simplification)
+        for (int i = 0; i < c.size(); i++){
+            n_occ[toInt(c[i])]--;
+            updateElimHeap(var(c[i]));
+            occurs.smudge(var(c[i]));
+        }
+
+    Solver::removeClause(cr);
+}
+
+
+bool SimpSolver::strengthenClause(CRef cr, Lit l)
+{
+    Clause& c = ca[cr];
+    assert(decisionLevel() == 0);
+    assert(use_simplification);
+
+    // FIX: this is too inefficient but would be nice to have (properly implemented)
+    // if (!find(subsumption_queue, &c))
+    subsumption_queue.insert(cr);
+
+    if (certifiedUNSAT) {
+      for (int i = 0; i < c.size(); i++)
+        if (c[i] != l) fprintf(certifiedOutput, "%i " , (var(c[i]) + 1) * (-2 * sign(c[i]) + 1) );
+      fprintf(certifiedOutput, "0\n");
+    }
+
+    if (c.size() == 2){
+        removeClause(cr);
+        c.strengthen(l);
+    }else{
+        if (certifiedUNSAT) {
+          fprintf(certifiedOutput, "d ");
+          for (int i = 0; i < c.size(); i++)
+            fprintf(certifiedOutput, "%i " , (var(c[i]) + 1) * (-2 * sign(c[i]) + 1) );
+          fprintf(certifiedOutput, "0\n");
+        }
+
+        detachClause(cr, true);
+        c.strengthen(l);
+        attachClause(cr);
+        remove(occurs[var(l)], cr);
+        n_occ[toInt(l)]--;
+        updateElimHeap(var(l));
+    }
+
+    return c.size() == 1 ? enqueue(c[0]) && propagate() == CRef_Undef : true;
+}
+
+
+// Returns FALSE if clause is always satisfied ('out_clause' should not be used).
+bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, vec<Lit>& out_clause)
+{
+    merges++;
+    out_clause.clear();
+
+    bool  ps_smallest = _ps.size() < _qs.size();
+    const Clause& ps  =  ps_smallest ? _qs : _ps;
+    const Clause& qs  =  ps_smallest ? _ps : _qs;
+
+    int i, j;
+    for (i = 0; i < qs.size(); i++){
+        if (var(qs[i]) != v){
+            for (j = 0; j < ps.size(); j++)
+                if (var(ps[j]) == var(qs[i])) {
+                    if (ps[j] == ~qs[i])
+                        return false;
+                    else
+                        goto next;
+                }
+            out_clause.push(qs[i]);
+        }
+        next:;
+    }
+
+    for (i = 0; i < ps.size(); i++)
+        if (var(ps[i]) != v)
+            out_clause.push(ps[i]);
+
+    return true;
+}
+
+
+// Returns FALSE if clause is always satisfied.
+bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, int& size)
+{
+    merges++;
+
+    bool  ps_smallest = _ps.size() < _qs.size();
+    const Clause& ps  =  ps_smallest ? _qs : _ps;
+    const Clause& qs  =  ps_smallest ? _ps : _qs;
+    const Lit*  __ps  = (const Lit*)ps;
+    const Lit*  __qs  = (const Lit*)qs;
+
+    size = ps.size()-1;
+
+    for (int i = 0; i < qs.size(); i++){
+        if (var(__qs[i]) != v){
+            for (int j = 0; j < ps.size(); j++)
+                if (var(__ps[j]) == var(__qs[i])) {
+                    if (__ps[j] == ~__qs[i])
+                        return false;
+                    else
+                        goto next;
+                }
+            size++;
+        }
+        next:;
+    }
+
+    return true;
+}
+
+
+void SimpSolver::gatherTouchedClauses()
+{
+    if (n_touched == 0) return;
+
+    int i,j;
+    for (i = j = 0; i < subsumption_queue.size(); i++)
+        if (ca[subsumption_queue[i]].mark() == 0)
+            ca[subsumption_queue[i]].mark(2);
+
+    for (i = 0; i < touched.size(); i++)
+        if (touched[i]){
+            const vec<CRef>& cs = occurs.lookup(i);
+            for (j = 0; j < cs.size(); j++)
+                if (ca[cs[j]].mark() == 0){
+                    subsumption_queue.insert(cs[j]);
+                    ca[cs[j]].mark(2);
+                }
+            touched[i] = 0;
+        }
+
+    for (i = 0; i < subsumption_queue.size(); i++)
+        if (ca[subsumption_queue[i]].mark() == 2)
+            ca[subsumption_queue[i]].mark(0);
+
+    n_touched = 0;
+}
+
+
+bool SimpSolver::implied(const vec<Lit>& c)
+{
+    assert(decisionLevel() == 0);
+
+    trail_lim.push(trail.size());
+    for (int i = 0; i < c.size(); i++)
+        if (value(c[i]) == l_True){
+            cancelUntil(0);
+            return false;
+        }else if (value(c[i]) != l_False){
+            assert(value(c[i]) == l_Undef);
+            uncheckedEnqueue(~c[i]);
+        }
+
+    bool result = propagate() != CRef_Undef;
+    cancelUntil(0);
+    return result;
+}
+
+
+// Backward subsumption + backward subsumption resolution
+bool SimpSolver::backwardSubsumptionCheck(bool verbose)
+{
+    int cnt = 0;
+    int subsumed = 0;
+    int deleted_literals = 0;
+    assert(decisionLevel() == 0);
+
+    while (subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()){
+
+        // Empty subsumption queue and return immediately on user-interrupt:
+        if (asynch_interrupt){
+            subsumption_queue.clear();
+            bwdsub_assigns = trail.size();
+            break; }
+
+        // Check top-level assignments by creating a dummy clause and placing it in the queue:
+        if (subsumption_queue.size() == 0 && bwdsub_assigns < trail.size()){
+            Lit l = trail[bwdsub_assigns++];
+            ca[bwdsub_tmpunit][0] = l;
+            ca[bwdsub_tmpunit].calcAbstraction();
+            subsumption_queue.insert(bwdsub_tmpunit); }
+
+        CRef    cr = subsumption_queue.peek(); subsumption_queue.pop();
+        Clause& c  = ca[cr];
+
+        if (c.mark()) continue;
+
+        if (verbose && verbosity >= 2 && cnt++ % 1000 == 0)
+            printf("subsumption left: %10d (%10d subsumed, %10d deleted literals)\r", subsumption_queue.size(), subsumed, deleted_literals);
+
+        assert(c.size() > 1 || value(c[0]) == l_True);    // Unit-clauses should have been propagated before this point.
+
+        // Find best variable to scan:
+        Var best = var(c[0]);
+        for (int i = 1; i < c.size(); i++)
+            if (occurs[var(c[i])].size() < occurs[best].size())
+                best = var(c[i]);
+
+        // Search all candidates:
+        vec<CRef>& _cs = occurs.lookup(best);
+        CRef*       cs = (CRef*)_cs;
+
+        for (int j = 0; j < _cs.size(); j++)
+            if (c.mark())
+                break;
+            else if (!ca[cs[j]].mark() &&  cs[j] != cr && (subsumption_lim == -1 || ca[cs[j]].size() < subsumption_lim)){
+                Lit l = c.subsumes(ca[cs[j]]);
+
+                if (l == lit_Undef)
+                    subsumed++, removeClause(cs[j]);
+                else if (l != lit_Error){
+                    deleted_literals++;
+
+                    if (!strengthenClause(cs[j], ~l))
+                        return false;
+
+                    // Did current candidate get deleted from cs? Then check candidate at index j again:
+                    if (var(l) == best)
+                        j--;
+                }
+            }
+    }
+
+    return true;
+}
+
+
+bool SimpSolver::asymm(Var v, CRef cr)
+{
+    Clause& c = ca[cr];
+    assert(decisionLevel() == 0);
+
+    if (c.mark() || satisfied(c)) return true;
+
+    trail_lim.push(trail.size());
+    Lit l = lit_Undef;
+    for (int i = 0; i < c.size(); i++)
+        if (var(c[i]) != v && value(c[i]) != l_False)
+            uncheckedEnqueue(~c[i]);
+        else
+            l = c[i];
+
+    if (propagate() != CRef_Undef){
+        cancelUntil(0);
+        asymm_lits++;
+        if (!strengthenClause(cr, l))
+            return false;
+    }else
+        cancelUntil(0);
+
+    return true;
+}
+
+
+bool SimpSolver::asymmVar(Var v)
+{
+    assert(use_simplification);
+
+    const vec<CRef>& cls = occurs.lookup(v);
+
+    if (value(v) != l_Undef || cls.size() == 0)
+        return true;
+
+    for (int i = 0; i < cls.size(); i++)
+        if (!asymm(v, cls[i]))
+            return false;
+
+    return backwardSubsumptionCheck();
+}
+
+
+static void mkElimClause(vec<uint32_t>& elimclauses, Lit x)
+{
+    elimclauses.push(toInt(x));
+    elimclauses.push(1);
+}
+
+
+static void mkElimClause(vec<uint32_t>& elimclauses, Var v, Clause& c)
+{
+    int first = elimclauses.size();
+    int v_pos = -1;
+
+    // Copy clause to elimclauses-vector. Remember position where the
+    // variable 'v' occurs:
+    for (int i = 0; i < c.size(); i++){
+        elimclauses.push(toInt(c[i]));
+        if (var(c[i]) == v)
+            v_pos = i + first;
+    }
+    assert(v_pos != -1);
+
+    // Swap the first literal with the 'v' literal, so that the literal
+    // containing 'v' will occur first in the clause:
+    uint32_t tmp = elimclauses[v_pos];
+    elimclauses[v_pos] = elimclauses[first];
+    elimclauses[first] = tmp;
+
+    // Store the length of the clause last:
+    elimclauses.push(c.size());
+}
+
+
+
+bool SimpSolver::eliminateVar(Var v)
+{
+    int i, j;
+    assert(!frozen[v]);
+    assert(!isEliminated(v));
+    assert(value(v) == l_Undef);
+
+    // Split the occurrences into positive and negative:
+    //
+    const vec<CRef>& cls = occurs.lookup(v);
+    vec<CRef>        pos, neg;
+    for (i = 0; i < cls.size(); i++)
+        (find(ca[cls[i]], mkLit(v)) ? pos : neg).push(cls[i]);
+
+    // Check wether the increase in number of clauses stays within the allowed ('grow'). Moreover, no
+    // clause must exceed the limit on the maximal clause size (if it is set):
+    //
+    int cnt         = 0;
+    int clause_size = 0;
+
+    for (i = 0; i < pos.size(); i++)
+        for (j = 0; j < neg.size(); j++)
+            if (merge(ca[pos[i]], ca[neg[j]], v, clause_size) && 
+                (++cnt > cls.size() + grow || (clause_lim != -1 && clause_size > clause_lim)))
+                return true;
+
+    // Delete and store old clauses:
+    eliminated[v] = true;
+    setDecisionVar(v, false);
+    eliminated_vars++;
+
+    if (pos.size() > neg.size()){
+        for (i = 0; i < neg.size(); i++)
+            mkElimClause(elimclauses, v, ca[neg[i]]);
+        mkElimClause(elimclauses, mkLit(v));
+        eliminated_clauses += neg.size();
+    }else{
+        for (i = 0; i < pos.size(); i++)
+            mkElimClause(elimclauses, v, ca[pos[i]]);
+        mkElimClause(elimclauses, ~mkLit(v));
+        eliminated_clauses += pos.size();
+    }
+
+
+    // Produce clauses in cross product:
+    vec<Lit>& resolvent = add_tmp;
+    for (i = 0; i < pos.size(); i++)
+        for (j = 0; j < neg.size(); j++)
+            if (merge(ca[pos[i]], ca[neg[j]], v, resolvent) && !addClause_(resolvent))
+                return false;
+
+    for (i = 0; i < cls.size(); i++)
+        removeClause(cls[i]);
+
+    // Free occurs list for this variable:
+    occurs[v].clear(true);
+
+    // Free watchers lists for this variable, if possible:
+    if (watches[ mkLit(v)].size() == 0) watches[ mkLit(v)].clear(true);
+    if (watches[~mkLit(v)].size() == 0) watches[~mkLit(v)].clear(true);
+
+    return backwardSubsumptionCheck();
+}
+
+
+bool SimpSolver::substitute(Var v, Lit x)
+{
+    assert(!frozen[v]);
+    assert(!isEliminated(v));
+    assert(value(v) == l_Undef);
+
+    if (!ok) return false;
+
+    eliminated[v] = true;
+    setDecisionVar(v, false);
+    const vec<CRef>& cls = occurs.lookup(v);
+    
+    vec<Lit>& subst_clause = add_tmp;
+    for (int i = 0; i < cls.size(); i++){
+        Clause& c = ca[cls[i]];
+
+        subst_clause.clear();
+        for (int j = 0; j < c.size(); j++){
+            Lit p = c[j];
+            subst_clause.push(var(p) == v ? x ^ sign(p) : p);
+        }
+
+ 
+        if (!addClause_(subst_clause))
+            return ok = false;
+
+       removeClause(cls[i]);
+ 
+   }
+
+    return true;
+}
+
+
+void SimpSolver::extendModel()
+{
+    int i, j;
+    Lit x;
+
+    for (i = elimclauses.size()-1; i > 0; i -= j){
+        for (j = elimclauses[i--]; j > 1; j--, i--)
+            if (modelValue(toLit(elimclauses[i])) != l_False)
+                goto next;
+
+        x = toLit(elimclauses[i]);
+        model[var(x)] = lbool(!sign(x));
+    next:;
+    }
+}
+
+
+bool SimpSolver::eliminate(bool turn_off_elim)
+{
+    //abctime clk = Abc_Clock();
+    if (!simplify())
+        return false;
+    else if (!use_simplification)
+        return true;
+
+    // Main simplification loop:
+    //
+
+    int toPerform = clauses.size()<=4800000;
+    
+    if(!toPerform) {
+      printf("c Too many clauses... No preprocessing\n");
+    }
+
+    while (toPerform && (n_touched > 0 || bwdsub_assigns < trail.size() || elim_heap.size() > 0)){
+
+        gatherTouchedClauses();
+        // printf("  ## (time = %6.2f s) BWD-SUB: queue = %d, trail = %d\n", cpuTime(), subsumption_queue.size(), trail.size() - bwdsub_assigns);
+        if ((subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()) && 
+            !backwardSubsumptionCheck(true)){
+            ok = false; goto cleanup; }
+
+        // Empty elim_heap and return immediately on user-interrupt:
+        if (asynch_interrupt){
+            assert(bwdsub_assigns == trail.size());
+            assert(subsumption_queue.size() == 0);
+            assert(n_touched == 0);
+            elim_heap.clear();
+            goto cleanup; }
+
+        // printf("  ## (time = %6.2f s) ELIM: vars = %d\n", cpuTime(), elim_heap.size());
+        for (int cnt = 0; !elim_heap.empty(); cnt++){
+            Var elim = elim_heap.removeMin();
+            
+            if (asynch_interrupt) break;
+
+            if (isEliminated(elim) || value(elim) != l_Undef) continue;
+
+            if (verbosity >= 2 && cnt % 100 == 0)
+                printf("elimination left: %10d\r", elim_heap.size());
+
+            if (use_asymm){
+                // Temporarily freeze variable. Otherwise, it would immediately end up on the queue again:
+                bool was_frozen = frozen[elim] != 0;
+                frozen[elim] = true;
+                if (!asymmVar(elim)){
+                    ok = false; goto cleanup; }
+                frozen[elim] = was_frozen; }
+
+            // At this point, the variable may have been set by assymetric branching, so check it
+            // again. Also, don't eliminate frozen variables:
+            if (use_elim && value(elim) == l_Undef && !frozen[elim] && !eliminateVar(elim)){
+                ok = false; goto cleanup; }
+
+            checkGarbage(simp_garbage_frac);
+        }
+
+        assert(subsumption_queue.size() == 0);
+    }
+ cleanup:
+
+    // If no more simplification is needed, free all simplification-related data structures:
+    if (turn_off_elim){
+        touched  .clear(true);
+        occurs   .clear(true);
+        n_occ    .clear(true);
+        elim_heap.clear(true);
+        subsumption_queue.clear(true);
+
+        use_simplification    = false;
+        remove_satisfied      = true;
+        ca.extra_clause_field = false;
+
+        // Force full cleanup (this is safe and desirable since it only happens once):
+        rebuildOrderHeap();
+        garbageCollect();
+    }else{
+        // Cheaper cleanup:
+        cleanUpClauses(); // TODO: can we make 'cleanUpClauses()' not be linear in the problem size somehow?
+        checkGarbage();
+    }
+
+    if (verbosity >= 1 && elimclauses.size() > 0)
+        printf("c |  Eliminated clauses:     %10.2f Mb                                                                |\n", 
+               double(elimclauses.size() * sizeof(uint32_t)) / (1024*1024));
+    return ok;
+}
+
+
+void SimpSolver::cleanUpClauses()
+{
+    occurs.cleanAll();
+    int i,j;
+    for (i = j = 0; i < clauses.size(); i++)
+        if (ca[clauses[i]].mark() == 0)
+            clauses[j++] = clauses[i];
+    clauses.shrink(i - j);
+}
+
+
+//=================================================================================================
+// Garbage Collection methods:
+
+
+void SimpSolver::relocAll(ClauseAllocator& to)
+{
+    int i;
+    if (!use_simplification) return;
+
+    // All occurs lists:
+    //
+    for (i = 0; i < nVars(); i++){
+        vec<CRef>& cs = occurs[i];
+        for (int j = 0; j < cs.size(); j++)
+            ca.reloc(cs[j], to);
+    }
+
+    // Subsumption queue:
+    //
+    for (i = 0; i < subsumption_queue.size(); i++)
+        ca.reloc(subsumption_queue[i], to);
+
+    // Temporary clause:
+    //
+    ca.reloc(bwdsub_tmpunit, to);
+}
+
+
+void SimpSolver::garbageCollect()
+{
+    // Initialize the next region to a size corresponding to the estimated utilization degree. This
+    // is not precise but should avoid some unnecessary reallocations for the new region:
+    ClauseAllocator to(ca.size() - ca.wasted()); 
+
+    cleanUpClauses();
+    to.extra_clause_field = ca.extra_clause_field; // NOTE: this is important to keep (or lose) the extra fields.
+    relocAll(to);
+    Solver::relocAll(to);
+    if (verbosity >= 2)
+        printf("|  Garbage collection:   %12d bytes => %12d bytes             |\n", 
+               ca.size()*ClauseAllocator::Unit_Size, to.size()*ClauseAllocator::Unit_Size);
+    to.moveTo(ca);
+}
+
+void SimpSolver::reset() 
+{
+    Solver::reset();
+    grow = 0;
+    asymm_lits = eliminated_vars = bwdsub_assigns = n_touched = 0;
+    elimclauses.clear(false);
+    touched.clear(false);
+    occurs.clear(false);
+    n_occ.clear(false);
+    elim_heap.clear(false);
+    subsumption_queue.clear(false);
+    frozen.clear(false);
+    eliminated.clear(false);
+    vec<Lit> dummy(1,lit_Undef);
+    ca.extra_clause_field = true; // NOTE: must happen before allocating the dummy clause below.
+    bwdsub_tmpunit        = ca.alloc(dummy);
+    remove_satisfied      = false;
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/lib/abcsat/abc/AbcGlucose.h b/lib/abcsat/abc/AbcGlucose.h
new file mode 100644
index 0000000..129a713
--- /dev/null
+++ b/lib/abcsat/abc/AbcGlucose.h
@@ -0,0 +1,107 @@
+/**CFile****************************************************************
+
+  FileName    [AbcGlucose.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SAT solver Glucose 3.0 by Gilles Audemard and Laurent Simon.]
+
+  Synopsis    [Interface to Glucose.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - September 6, 2017.]
+
+  Revision    [$Id: AbcGlucose.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#ifndef ABC_SAT_GLUCOSE_H_
+#define ABC_SAT_GLUCOSE_H_
+
+#include "abc/abc_global.h"
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+#define GLUCOSE_UNSAT -1
+#define GLUCOSE_SAT    1
+#define GLUCOSE_UNDEC  0
+
+
+ABC_NAMESPACE_HEADER_START
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct Glucose_Pars_ Glucose_Pars;
+struct Glucose_Pars_ {
+    int pre;     // preprocessing
+    int verb;    // verbosity
+    int cust;    // customizable
+    int nConfls; // conflict limit (0 = no limit)
+};
+
+static inline Glucose_Pars Glucose_CreatePars(int p, int v, int c, int nConfls)
+{
+    Glucose_Pars pars;
+    pars.pre     = p;
+    pars.verb    = v;
+    pars.cust    = c;
+    pars.nConfls = nConfls;
+    return pars;
+}
+
+typedef void bmcg_sat_solver;
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                    FUNCTION DECLARATIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+extern bmcg_sat_solver * bmcg_sat_solver_start();
+extern void              bmcg_sat_solver_stop( bmcg_sat_solver* s );
+extern void              bmcg_sat_solver_reset( bmcg_sat_solver* s );
+extern int               bmcg_sat_solver_addclause( bmcg_sat_solver* s, int * plits, int nlits );
+extern void              bmcg_sat_solver_setcallback( bmcg_sat_solver* s, void * pman, int(*pfunc)(void*, int, int*) );
+extern int               bmcg_sat_solver_solve( bmcg_sat_solver* s, int * plits, int nlits );
+extern int               bmcg_sat_solver_final( bmcg_sat_solver* s, int ** ppArray );
+extern int               bmcg_sat_solver_addvar( bmcg_sat_solver* s );
+extern void              bmcg_sat_solver_set_nvars( bmcg_sat_solver* s, int nvars );
+extern int               bmcg_sat_solver_eliminate( bmcg_sat_solver* s, int turn_off_elim );
+extern int               bmcg_sat_solver_var_is_elim( bmcg_sat_solver* s, int v );
+extern void              bmcg_sat_solver_var_set_frozen( bmcg_sat_solver* s, int v, int freeze );
+extern int               bmcg_sat_solver_elim_varnum(bmcg_sat_solver* s);
+extern int               bmcg_sat_solver_read_cex_varvalue( bmcg_sat_solver* s, int );
+extern void              bmcg_sat_solver_set_stop( bmcg_sat_solver* s, int * pstop );
+extern abctime           bmcg_sat_solver_set_runtime_limit( bmcg_sat_solver* s, abctime Limit );
+extern void              bmcg_sat_solver_set_conflict_budget( bmcg_sat_solver* s, int Limit );
+extern int               bmcg_sat_solver_varnum( bmcg_sat_solver* s );
+extern int               bmcg_sat_solver_clausenum( bmcg_sat_solver* s );
+extern int               bmcg_sat_solver_learntnum( bmcg_sat_solver* s );
+extern int               bmcg_sat_solver_conflictnum( bmcg_sat_solver* s );
+extern int               bmcg_sat_solver_minimize_assumptions( bmcg_sat_solver * s, int * plits, int nlits, int pivot );
+extern int               bmcg_sat_solver_add_and( bmcg_sat_solver * s, int iVar, int iVar0, int iVar1, int fCompl0, int fCompl1, int fCompl );
+
+extern void              Glucose_SolveCnf( char * pFilename, Glucose_Pars * pPars );
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
diff --git a/lib/abcsat/abc/Alg.h b/lib/abcsat/abc/Alg.h
new file mode 100644
index 0000000..c33ccc0
--- /dev/null
+++ b/lib/abcsat/abc/Alg.h
@@ -0,0 +1,88 @@
+/*******************************************************************************************[Alg.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_Alg_h
+#define Glucose_Alg_h
+
+#include "Vec.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// Useful functions on vector-like types:
+
+//=================================================================================================
+// Removing and searching for elements:
+//
+
+template<class V, class T>
+static inline void remove(V& ts, const T& t)
+{
+    int j = 0;
+    for (; j < ts.size() && ts[j] != t; j++);
+    assert(j < ts.size());
+    for (; j < ts.size()-1; j++) ts[j] = ts[j+1];
+    ts.pop();
+}
+
+
+template<class V, class T>
+static inline bool find(V& ts, const T& t)
+{
+    int j = 0;
+    for (; j < ts.size() && ts[j] != t; j++);
+    return j < ts.size();
+}
+
+
+//=================================================================================================
+// Copying vectors with support for nested vector types:
+//
+
+// Base case:
+template<class T>
+static inline void copy(const T& from, T& to)
+{
+    to = from;
+}
+
+// Recursive case:
+template<class T>
+static inline void copy(const vec<T>& from, vec<T>& to, bool append = false)
+{
+    if (!append)
+        to.clear();
+    for (int i = 0; i < from.size(); i++){
+        to.push();
+        copy(from[i], to.last());
+    }
+}
+
+template<class T>
+static inline void append(const vec<T>& from, vec<T>& to){ copy(from, to, true); }
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/abcsat/abc/Alloc.h b/lib/abcsat/abc/Alloc.h
new file mode 100644
index 0000000..b28d618
--- /dev/null
+++ b/lib/abcsat/abc/Alloc.h
@@ -0,0 +1,136 @@
+/*****************************************************************************************[Alloc.h]
+Copyright (c) 2008-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Glucose_Alloc_h
+#define Glucose_Alloc_h
+
+#include "XAlloc.h"
+#include "Vec.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// Simple Region-based memory allocator:
+
+template<class T>
+class RegionAllocator
+{
+    T*        memory;
+    uint32_t  sz;
+    uint32_t  cap;
+    uint32_t  wasted_;
+
+    void capacity(uint32_t min_cap);
+
+ public:
+    // TODO: make this a class for better type-checking?
+    typedef uint32_t Ref;
+    enum { Ref_Undef = UINT32_MAX };
+    enum { Unit_Size = sizeof(uint32_t) };
+
+    explicit RegionAllocator(uint32_t start_cap = 1024*1024) : memory(NULL), sz(0), cap(0), wasted_(0){ capacity(start_cap); }
+    ~RegionAllocator()
+    {
+        if (memory != NULL)
+            ::free(memory);
+    }
+
+
+    uint32_t size      () const      { return sz; }
+    uint32_t wasted    () const      { return wasted_; }
+
+    Ref      alloc     (int size); 
+    void     free_     (int size)    { wasted_ += size; }
+    void     clear     ()            { sz = 0; wasted_=0; }
+
+    // Deref, Load Effective Address (LEA), Inverse of LEA (AEL):
+    T&       operator[](Ref r)       { assert(r >= 0 && r < sz); return memory[r]; }
+    const T& operator[](Ref r) const { assert(r >= 0 && r < sz); return memory[r]; }
+
+    T*       lea       (Ref r)       { assert(r >= 0 && r < sz); return &memory[r]; }
+    const T* lea       (Ref r) const { assert(r >= 0 && r < sz); return &memory[r]; }
+    Ref      ael       (const T* t)  { assert((void*)t >= (void*)&memory[0] && (void*)t < (void*)&memory[sz-1]);
+        return  (Ref)(t - &memory[0]); }
+
+    void     moveTo(RegionAllocator& to) {
+        if (to.memory != NULL) ::free(to.memory);
+        to.memory = memory;
+        to.sz = sz;
+        to.cap = cap;
+        to.wasted_ = wasted_;
+
+        memory = NULL;
+        sz = cap = wasted_ = 0;
+    }
+
+
+};
+
+template<class T>
+void RegionAllocator<T>::capacity(uint32_t min_cap)
+{
+    if (cap >= min_cap) return;
+
+    uint32_t prev_cap = cap;
+    while (cap < min_cap){
+        // NOTE: Multiply by a factor (13/8) without causing overflow, then add 2 and make the
+        // result even by clearing the least significant bit. The resulting sequence of capacities
+        // is carefully chosen to hit a maximum capacity that is close to the '2^32-1' limit when
+        // using 'uint32_t' as indices so that as much as possible of this space can be used.
+        uint32_t delta = ((cap >> 1) + (cap >> 3) + 2) & ~1;
+        cap += delta;
+
+        if (cap <= prev_cap)
+            throw OutOfMemoryException();
+    }
+    //printf(" .. (%p) cap = %u\n", this, cap);
+
+    assert(cap > 0);
+    memory = (T*)xrealloc(memory, sizeof(T)*cap);
+}
+
+
+template<class T>
+typename RegionAllocator<T>::Ref
+RegionAllocator<T>::alloc(int size)
+{ 
+    //printf("ALLOC called (this = %p, size = %d)\n", this, size); fflush(stdout);
+    assert(size > 0);
+    capacity(sz + size);
+
+    uint32_t prev_sz = sz;
+    sz += size;
+    
+    // Handle overflow:
+    if (sz < prev_sz)
+        throw OutOfMemoryException();
+
+    return prev_sz;
+}
+
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/abcsat/abc/BoundedQueue.h b/lib/abcsat/abc/BoundedQueue.h
new file mode 100644
index 0000000..ead1443
--- /dev/null
+++ b/lib/abcsat/abc/BoundedQueue.h
@@ -0,0 +1,114 @@
+/***********************************************************************************[BoundedQueue.h]
+ Glucose -- Copyright (c) 2009, Gilles Audemard, Laurent Simon
+                CRIL - Univ. Artois, France
+                LRI  - Univ. Paris Sud, France
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef BoundedQueue_h
+#define BoundedQueue_h
+
+#include "Vec.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+//=================================================================================================
+
+namespace Gluco {
+
+template <class T>
+class bqueue {
+    vec<T>  elems;
+    int     first;
+    int        last;
+    uint64_t sumofqueue;
+    int     maxsize;
+    int     queuesize; // Number of current elements (must be < maxsize !)
+    bool expComputed;
+    double exp,value;
+public:
+ bqueue(void) : first(0), last(0), sumofqueue(0), maxsize(0), queuesize(0),expComputed(false) { } 
+    
+    void initSize(int size) {growTo(size);exp = 2.0/(size+1);} // Init size of bounded size queue
+    
+    void push(T x) {
+      expComputed = false;
+        if (queuesize==maxsize) {
+            assert(last==first); // The queue is full, next value to enter will replace oldest one
+            sumofqueue -= elems[last];
+            if ((++last) == maxsize) last = 0;
+        } else 
+            queuesize++;
+        sumofqueue += x;
+        elems[first] = x;
+        if ((++first) == maxsize) {first = 0;last = 0;}
+    }
+
+    T peek() { assert(queuesize>0); return elems[last]; }
+    void pop() {sumofqueue-=elems[last]; queuesize--; if ((++last) == maxsize) last = 0;}
+    
+    uint64_t getsum() const {return sumofqueue;}
+    unsigned int getavg() const {return (unsigned int)(sumofqueue/((uint64_t)queuesize));}
+    int maxSize() const {return maxsize;}
+    double getavgDouble() const {
+      double tmp = 0;
+      for(int i=0;i<elems.size();i++) {
+        tmp+=elems[i];
+      }
+      return tmp/elems.size();
+    }
+    int isvalid() const {return (queuesize==maxsize);}
+    
+    void growTo(int size) {
+        elems.growTo(size); 
+        first=0; maxsize=size; queuesize = 0;last = 0;
+        for(int i=0;i<size;i++) elems[i]=0; 
+    }
+    
+    double getAvgExp() {
+      if(expComputed) return value;
+      double a=exp;
+      value = elems[first];
+      for(int i  = first;i<maxsize;i++) {
+        value+=a*((double)elems[i]);
+        a=a*exp;
+      }
+      for(int i  = 0;i<last;i++) {
+        value+=a*((double)elems[i]);
+        a=a*exp;
+      }
+      value = value*(1-exp)/(1-a);
+      expComputed = true;
+      return value;
+      
+
+    }
+    void fastclear() {first = 0; last = 0; queuesize=0; sumofqueue=0;} // to be called after restarts... Discard the queue
+    
+    int  size(void)    { return queuesize; }
+
+    void clear(bool dealloc = false)   { elems.clear(dealloc); first = 0; maxsize=0; queuesize=0;sumofqueue=0;}
+
+
+};
+}
+//=================================================================================================
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/abcsat/abc/Constants.h b/lib/abcsat/abc/Constants.h
new file mode 100644
index 0000000..4cccad2
--- /dev/null
+++ b/lib/abcsat/abc/Constants.h
@@ -0,0 +1,33 @@
+/************************************************************************************[Constants.h]
+ Glucose -- Copyright (c) 2009, Gilles Audemard, Laurent Simon
+                CRIL - Univ. Artois, France
+                LRI  - Univ. Paris Sud, France
+  
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#define DYNAMICNBLEVEL
+#define CONSTANTREMOVECLAUSE
+#define UPDATEVARACTIVITY
+
+// Constants for clauses reductions
+#define RATIOREMOVECLAUSES 2
+
+
+
+// Constants for restarts
+#define LOWER_BOUND_FOR_BLOCKING_RESTART 10000
+
diff --git a/lib/abcsat/abc/Dimacs.h b/lib/abcsat/abc/Dimacs.h
new file mode 100644
index 0000000..bf08c6f
--- /dev/null
+++ b/lib/abcsat/abc/Dimacs.h
@@ -0,0 +1,85 @@
+/****************************************************************************************[Dimacs.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_Dimacs_h
+#define Glucose_Dimacs_h
+
+#include <stdio.h>
+
+#include "SolverTypes.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// DIMACS Parser:
+
+template<class B, class Solver>
+static void readClause(B& in, Solver& S, vec<Lit>& lits) {
+    int     parsed_lit, var;
+    lits.clear();
+    for (;;){
+        parsed_lit = parseInt(in);
+        if (parsed_lit == 0) break;
+        var = abs(parsed_lit)-1;
+        while (var >= S.nVars()) S.newVar();
+        lits.push( (parsed_lit > 0) ? mkLit(var) : ~mkLit(var) );
+    }
+}
+
+template<class B, class Solver>
+static void parse_DIMACS_main(B& in, Solver& S) {
+    vec<Lit> lits;
+    int vars    = 0;
+    int clauses = 0;
+    int cnt     = 0;
+    for (;;){
+        skipWhitespace(in);
+        if (*in == EOF) break;
+        else if (*in == 'p'){
+            if (eagerMatch(in, "p cnf")){
+                vars    = parseInt(in);
+                clauses = parseInt(in);
+                // SATRACE'06 hack
+                // if (clauses > 4000000)
+                //     S.eliminate(true);
+            }else{
+                printf("PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
+            }
+        } else if (*in == 'c' || *in == 'p')
+            skipLine(in);
+        else{
+            cnt++;
+            readClause(in, S, lits);
+            S.addClause_(lits); }
+    }
+    if (vars != S.nVars())
+        fprintf(stderr, "WARNING! DIMACS header mismatch: wrong number of variables.\n");
+    if (cnt  != clauses)
+        fprintf(stderr, "WARNING! DIMACS header mismatch: wrong number of clauses.\n");
+}
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/abcsat/abc/Heap.h b/lib/abcsat/abc/Heap.h
new file mode 100644
index 0000000..99142d8
--- /dev/null
+++ b/lib/abcsat/abc/Heap.h
@@ -0,0 +1,154 @@
+/******************************************************************************************[Heap.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_Heap_h
+#define Glucose_Heap_h
+
+#include "Vec.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// A heap implementation with support for decrease/increase key.
+
+
+template<class Comp>
+class Heap {
+    Comp     lt;       // The heap is a minimum-heap with respect to this comparator
+    vec<int> heap;     // Heap of integers
+    vec<int> indices;  // Each integers position (index) in the Heap
+
+    // Index "traversal" functions
+    static inline int left  (int i) { return i*2+1; }
+    static inline int right (int i) { return (i+1)*2; }
+    static inline int parent(int i) { return (i-1) >> 1; }
+
+
+    void percolateUp(int i)
+    {
+        int x  = heap[i];
+        int p  = parent(i);
+        
+        while (i != 0 && lt(x, heap[p])){
+            heap[i]          = heap[p];
+            indices[heap[p]] = i;
+            i                = p;
+            p                = parent(p);
+        }
+        heap   [i] = x;
+        indices[x] = i;
+    }
+
+
+    void percolateDown(int i)
+    {
+        int x = heap[i];
+        while (left(i) < heap.size()){
+            int child = right(i) < heap.size() && lt(heap[right(i)], heap[left(i)]) ? right(i) : left(i);
+            if (!lt(heap[child], x)) break;
+            heap[i]          = heap[child];
+            indices[heap[i]] = i;
+            i                = child;
+        }
+        heap   [i] = x;
+        indices[x] = i;
+    }
+
+
+  public:
+    Heap(const Comp& c) : lt(c) { }
+
+    int  size      ()          const { return heap.size(); }
+    bool empty     ()          const { return heap.size() == 0; }
+    bool inHeap    (int n)     const { return n < indices.size() && indices[n] >= 0; }
+    int  operator[](int index) const { assert(index < heap.size()); return heap[index]; }
+
+
+    void decrease  (int n) { assert(inHeap(n)); percolateUp  (indices[n]); }
+    void increase  (int n) { assert(inHeap(n)); percolateDown(indices[n]); }
+
+
+    // Safe variant of insert/decrease/increase:
+    void update(int n)
+    {
+        if (!inHeap(n))
+            insert(n);
+        else {
+            percolateUp(indices[n]);
+            percolateDown(indices[n]); }
+    }
+
+
+    void insert(int n)
+    {
+        indices.growTo(n+1, -1);
+        assert(!inHeap(n));
+
+        indices[n] = heap.size();
+        heap.push(n);
+        percolateUp(indices[n]); 
+    }
+
+
+    int  removeMin()
+    {
+        int x            = heap[0];
+        heap[0]          = heap.last();
+        indices[heap[0]] = 0;
+        indices[x]       = -1;
+        heap.pop();
+        if (heap.size() > 1) percolateDown(0);
+        return x; 
+    }
+
+
+    // Rebuild the heap from scratch, using the elements in 'ns':
+    void build(vec<int>& ns) {
+        int i;
+        for (i = 0; i < heap.size(); i++)
+            indices[heap[i]] = -1;
+        heap.clear();
+
+        for (i = 0; i < ns.size(); i++){
+            indices[ns[i]] = i;
+            heap.push(ns[i]); }
+
+        for (i = heap.size() / 2 - 1; i >= 0; i--)
+            percolateDown(i);
+    }
+
+    void clear(bool dealloc = false) 
+    { 
+        int i;
+        for (i = 0; i < heap.size(); i++)
+            indices[heap[i]] = -1;
+        heap.clear(dealloc); 
+    }
+};
+
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/abcsat/abc/IntTypes.h b/lib/abcsat/abc/IntTypes.h
new file mode 100644
index 0000000..bddcebe
--- /dev/null
+++ b/lib/abcsat/abc/IntTypes.h
@@ -0,0 +1,49 @@
+/**************************************************************************************[IntTypes.h]
+Copyright (c) 2009-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_IntTypes_h
+#define Glucose_IntTypes_h
+
+#ifdef __sun
+    // Not sure if there are newer versions that support C99 headers. The
+    // needed features are implemented in the headers below though:
+
+#   include <sys/int_types.h>
+#   include <sys/int_fmtio.h>
+#   include <sys/int_limits.h>
+
+#else
+
+#define __STDC_LIMIT_MACROS
+#   include "pstdint.h"
+//#   include <inttypes.h>
+
+#endif
+
+#include <limits.h>
+
+#ifndef PRIu64
+#define PRIu64 "lu"
+#define PRIi64 "ld"
+#endif
+//=================================================================================================
+
+#include "abc_namespaces.h"
+
+#endif
diff --git a/lib/abcsat/abc/Map.h b/lib/abcsat/abc/Map.h
new file mode 100644
index 0000000..47b7eef
--- /dev/null
+++ b/lib/abcsat/abc/Map.h
@@ -0,0 +1,197 @@
+/*******************************************************************************************[Map.h]
+Copyright (c) 2006-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_Map_h
+#define Glucose_Map_h
+
+#include "IntTypes.h"
+#include "Vec.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// Default hash/equals functions
+//
+
+template<class K> struct Hash  { uint32_t operator()(const K& k)               const { return hash(k);  } };
+template<class K> struct Equal { bool     operator()(const K& k1, const K& k2) const { return k1 == k2; } };
+
+template<class K> struct DeepHash  { uint32_t operator()(const K* k)               const { return hash(*k);  } };
+template<class K> struct DeepEqual { bool     operator()(const K* k1, const K* k2) const { return *k1 == *k2; } };
+
+static inline uint32_t hash(uint32_t x){ return x; }
+static inline uint32_t hash(uint64_t x){ return (uint32_t)x; }
+static inline uint32_t hash(int32_t x) { return (uint32_t)x; }
+static inline uint32_t hash(int64_t x) { return (uint32_t)x; }
+
+
+//=================================================================================================
+// Some primes
+//
+
+static const int nprimes          = 25;
+static const int primes [nprimes] = { 31, 73, 151, 313, 643, 1291, 2593, 5233, 10501, 21013, 42073, 84181, 168451, 337219, 674701, 1349473, 2699299, 5398891, 10798093, 21596719, 43193641, 86387383, 172775299, 345550609, 691101253 };
+
+//=================================================================================================
+// Hash table implementation of Maps
+//
+
+template<class K, class D, class H = Hash<K>, class E = Equal<K> >
+class Map {
+ public:
+    struct Pair { K key; D data; };
+
+ private:
+    H          hash;
+    E          equals;
+
+    vec<Pair>* table;
+    int        cap;
+    int        size;
+
+    // Don't allow copying (error prone):
+    Map<K,D,H,E>&  operator = (Map<K,D,H,E>& other) { assert(0); }
+                   Map        (Map<K,D,H,E>& other) { assert(0); }
+
+    bool    checkCap(int new_size) const { return new_size > cap; }
+
+    int32_t index  (const K& k) const { return hash(k) % cap; }
+    void   _insert (const K& k, const D& d) { 
+        vec<Pair>& ps = table[index(k)];
+        ps.push(); ps.last().key = k; ps.last().data = d; }
+
+    void    rehash () {
+        const vec<Pair>* old = table;
+
+        int old_cap = cap;
+        int newsize = primes[0];
+        for (int i = 1; newsize <= cap && i < nprimes; i++)
+           newsize = primes[i];
+
+        table = new vec<Pair>[newsize];
+        cap   = newsize;
+
+        for (int i = 0; i < old_cap; i++){
+            for (int j = 0; j < old[i].size(); j++){
+                _insert(old[i][j].key, old[i][j].data); }}
+
+        delete [] old;
+
+        // printf(" --- rehashing, old-cap=%d, new-cap=%d\n", cap, newsize);
+    }
+
+    
+ public:
+
+    Map () : table(NULL), cap(0), size(0) {}
+    Map (const H& h, const E& e) : hash(h), equals(e), table(NULL), cap(0), size(0){}
+    ~Map () { delete [] table; }
+
+    // PRECONDITION: the key must already exist in the map.
+    const D& operator [] (const K& k) const
+    {
+        assert(size != 0);
+        const D*         res = NULL;
+        const vec<Pair>& ps  = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k))
+                res = &ps[i].data;
+        assert(res != NULL);
+        return *res;
+    }
+
+    // PRECONDITION: the key must already exist in the map.
+    D& operator [] (const K& k)
+    {
+        assert(size != 0);
+        D*         res = NULL;
+        vec<Pair>& ps  = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k))
+                res = &ps[i].data;
+        assert(res != NULL);
+        return *res;
+    }
+
+    // PRECONDITION: the key must *NOT* exist in the map.
+    void insert (const K& k, const D& d) { if (checkCap(size+1)) rehash(); _insert(k, d); size++; }
+    bool peek   (const K& k, D& d) const {
+        if (size == 0) return false;
+        const vec<Pair>& ps = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k)){
+                d = ps[i].data;
+                return true; } 
+        return false;
+    }
+
+    bool has   (const K& k) const {
+        if (size == 0) return false;
+        const vec<Pair>& ps = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k))
+                return true;
+        return false;
+    }
+
+    // PRECONDITION: the key must exist in the map.
+    void remove(const K& k) {
+        assert(table != NULL);
+        vec<Pair>& ps = table[index(k)];
+        int j = 0;
+        for (; j < ps.size() && !equals(ps[j].key, k); j++);
+        assert(j < ps.size());
+        ps[j] = ps.last();
+        ps.pop();
+        size--;
+    }
+
+    void clear  () {
+        cap = size = 0;
+        delete [] table;
+        table = NULL;
+    }
+
+    int  elems() const { return size; }
+    int  bucket_count() const { return cap; }
+
+    // NOTE: the hash and equality objects are not moved by this method:
+    void moveTo(Map& other){
+        delete [] other.table;
+
+        other.table = table;
+        other.cap   = cap;
+        other.size  = size;
+
+        table = NULL;
+        size = cap = 0;
+    }
+
+    // NOTE: given a bit more time, I could make a more C++-style iterator out of this:
+    const vec<Pair>& bucket(int i) const { return table[i]; }
+};
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/abcsat/abc/Queue.h b/lib/abcsat/abc/Queue.h
new file mode 100644
index 0000000..577f566
--- /dev/null
+++ b/lib/abcsat/abc/Queue.h
@@ -0,0 +1,73 @@
+/*****************************************************************************************[Queue.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_Queue_h
+#define Glucose_Queue_h
+
+#include "abc/Vec.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+
+template<class T>
+class Queue {
+    vec<T>  buf;
+    int     first;
+    int     end;
+
+public:
+    typedef T Key;
+
+    Queue() : buf(1), first(0), end(0) {}
+
+    void clear (bool dealloc = false) { buf.clear(dealloc); buf.growTo(1); first = end = 0; }
+    int  size  () const { return (end >= first) ? end - first : end - first + buf.size(); }
+
+    const T& operator [] (int index) const  { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; }
+    T&       operator [] (int index)        { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; }
+
+    T    peek  () const { assert(first != end); return buf[first]; }
+    void pop   () { assert(first != end); first++; if (first == buf.size()) first = 0; }
+    void insert(T elem) {   // INVARIANT: buf[end] is always unused
+        buf[end++] = elem;
+        if (end == buf.size()) end = 0;
+        if (first == end){  // Resize:
+            vec<T>  tmp((buf.size()*3 + 1) >> 1);
+            //**/printf("queue alloc: %d elems (%.1f MB)\n", tmp.size(), tmp.size() * sizeof(T) / 1000000.0);
+            int j, i = 0;
+            for (j = first; j < buf.size(); j++) tmp[i++] = buf[j];
+            for (j = 0    ; j < end       ; j++) tmp[i++] = buf[j];
+            first = 0;
+            end   = buf.size();
+            tmp.moveTo(buf);
+        }
+    }
+};
+
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/abcsat/abc/SimpSolver.h b/lib/abcsat/abc/SimpSolver.h
new file mode 100644
index 0000000..04b1dab
--- /dev/null
+++ b/lib/abcsat/abc/SimpSolver.h
@@ -0,0 +1,208 @@
+/************************************************************************************[SimpSolver.h]
+Copyright (c) 2006,      Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_SimpSolver_h
+#define Glucose_SimpSolver_h
+
+#include "Queue.h"
+#include "Solver.h"
+#include "abc_global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+
+
+class SimpSolver : public Solver {
+ public:
+    // Constructor/Destructor:
+    //
+    SimpSolver();
+    ~SimpSolver();
+
+    // Problem specification:
+    //
+    Var     newVar    (bool polarity = true, bool dvar = true);
+    void    addVar    (Var v);               
+    bool    addClause (const vec<Lit>& ps);
+    bool    addEmptyClause();                // Add the empty clause to the solver.
+    bool    addClause (Lit p);               // Add a unit clause to the solver.
+    bool    addClause (Lit p, Lit q);        // Add a binary clause to the solver.
+    bool    addClause (Lit p, Lit q, Lit r); // Add a ternary clause to the solver.
+    bool    addClause_(      vec<Lit>& ps);
+    bool    substitute(Var v, Lit x);  // Replace all occurences of v with x (may cause a contradiction).
+
+    // Variable mode:
+    // 
+    void    setFrozen (Var v, bool b); // If a variable is frozen it will not be eliminated.
+    bool    isEliminated(Var v) const;
+
+    // Solving:
+    //
+    bool    solve       (const vec<Lit>& assumps, bool do_simp = true, bool turn_off_simp = false);
+    lbool   solveLimited(const vec<Lit>& assumps, bool do_simp = true, bool turn_off_simp = false);
+    bool    solve       (                     bool do_simp = true, bool turn_off_simp = false);
+    bool    solve       (Lit p       ,        bool do_simp = true, bool turn_off_simp = false);       
+    bool    solve       (Lit p, Lit q,        bool do_simp = true, bool turn_off_simp = false);
+    bool    solve       (Lit p, Lit q, Lit r, bool do_simp = true, bool turn_off_simp = false);
+    bool    eliminate   (bool turn_off_elim = false);  // Perform variable elimination based simplification. 
+
+    // Memory managment:
+    //
+    virtual void reset();
+    virtual void garbageCollect();
+
+
+    // Generate a (possibly simplified) DIMACS file:
+    //
+#if 0
+    void    toDimacs  (const char* file, const vec<Lit>& assumps);
+    void    toDimacs  (const char* file);
+    void    toDimacs  (const char* file, Lit p);
+    void    toDimacs  (const char* file, Lit p, Lit q);
+    void    toDimacs  (const char* file, Lit p, Lit q, Lit r);
+#endif
+
+    // Mode of operation:
+    //
+    int     parsing;
+    int     grow;              // Allow a variable elimination step to grow by a number of clauses (default to zero).
+    int     clause_lim;        // Variables are not eliminated if it produces a resolvent with a length above this limit.
+                               // -1 means no limit.
+    int     subsumption_lim;   // Do not check if subsumption against a clause larger than this. -1 means no limit.
+    double  simp_garbage_frac; // A different limit for when to issue a GC during simplification (Also see 'garbage_frac').
+
+    bool    use_asymm;         // Shrink clauses by asymmetric branching.
+    bool    use_rcheck;        // Check if a clause is already implied. Prett costly, and subsumes subsumptions :)
+    bool    use_elim;          // Perform variable elimination.
+
+    // Statistics:
+    //
+    int     merges;
+    int     asymm_lits;
+    int     eliminated_vars;
+    int     eliminated_clauses;
+
+ protected:
+
+    // Helper structures:
+    //
+    struct ElimLt {
+        const vec<int>& n_occ;
+        explicit ElimLt(const vec<int>& no) : n_occ(no) {}
+
+        // TODO: are 64-bit operations here noticably bad on 32-bit platforms? Could use a saturating
+        // 32-bit implementation instead then, but this will have to do for now.
+        uint64_t cost  (Var x)        const { return (uint64_t)n_occ[toInt(mkLit(x))] * (uint64_t)n_occ[toInt(~mkLit(x))]; }
+        bool operator()(Var x, Var y) const { return cost(x) < cost(y); }
+        
+        // TODO: investigate this order alternative more.
+        // bool operator()(Var x, Var y) const { 
+        //     int c_x = cost(x);
+        //     int c_y = cost(y);
+        //     return c_x < c_y || c_x == c_y && x < y; }
+    };
+
+    struct ClauseDeleted {
+        const ClauseAllocator& ca;
+        explicit ClauseDeleted(const ClauseAllocator& _ca) : ca(_ca) {}
+        bool operator()(const CRef& cr) const { return ca[cr].mark() == 1; } };
+
+    // Solver state:
+    //
+    int                 elimorder;
+    bool                use_simplification;
+    vec<uint32_t>       elimclauses;
+    vec<char>           touched;
+    OccLists<Var, vec<CRef>, ClauseDeleted>
+                        occurs;
+    vec<int>            n_occ;
+    Heap<ElimLt>        elim_heap;
+    Queue<CRef>         subsumption_queue;
+    vec<char>           frozen;
+    vec<char>           eliminated;
+    int                 bwdsub_assigns;
+    int                 n_touched;
+
+    // Temporaries:
+    //
+    CRef                bwdsub_tmpunit;
+
+    // Main internal methods:
+    //
+    lbool         solve_                   (bool do_simp = true, bool turn_off_simp = false);
+    bool          asymm                    (Var v, CRef cr);
+    bool          asymmVar                 (Var v);
+    void          updateElimHeap           (Var v);
+    void          gatherTouchedClauses     ();
+    bool          merge                    (const Clause& _ps, const Clause& _qs, Var v, vec<Lit>& out_clause);
+    bool          merge                    (const Clause& _ps, const Clause& _qs, Var v, int& size);
+    bool          backwardSubsumptionCheck (bool verbose = false);
+    bool          eliminateVar             (Var v);
+    void          extendModel              ();
+
+    void          removeClause             (CRef cr);
+    bool          strengthenClause         (CRef cr, Lit l);
+    void          cleanUpClauses           ();
+    bool          implied                  (const vec<Lit>& c);
+    void          relocAll                 (ClauseAllocator& to);
+};
+
+
+//=================================================================================================
+// Implementation of inline methods:
+
+
+//inline bool SimpSolver::isEliminated (Var v) const { return eliminated[v]; }
+inline bool SimpSolver::isEliminated (Var v) const { return eliminated.size() > 0 ? eliminated[v] != 0 : 0; }
+inline void SimpSolver::updateElimHeap(Var v) {
+    assert(use_simplification);
+    // if (!frozen[v] && !isEliminated(v) && value(v) == l_Undef)
+    if (elim_heap.inHeap(v) || (!frozen[v] && !isEliminated(v) && value(v) == l_Undef))
+        elim_heap.update(v); }
+
+
+inline bool SimpSolver::addClause    (const vec<Lit>& ps)  { ps.copyTo(add_tmp); return addClause_(add_tmp); }
+inline bool SimpSolver::addEmptyClause()                   { add_tmp.clear(); return addClause_(add_tmp); }
+inline bool SimpSolver::addClause    (Lit p)               { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); }
+inline bool SimpSolver::addClause    (Lit p, Lit q)        { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); }
+inline bool SimpSolver::addClause    (Lit p, Lit q, Lit r) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); }
+inline void SimpSolver::setFrozen    (Var v, bool b) { frozen[v] = (char)b; if (use_simplification && !b) { updateElimHeap(v); } }
+
+inline bool SimpSolver::solve        (                     bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (Lit p       ,        bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (Lit p, Lit q,        bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (Lit p, Lit q, Lit r, bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (const vec<Lit>& assumps, bool do_simp, bool turn_off_simp){ 
+    budgetOff(); assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp) == l_True; }
+
+inline lbool SimpSolver::solveLimited (const vec<Lit>& assumps, bool do_simp, bool turn_off_simp){ 
+    assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp); }
+
+inline void SimpSolver::addVar(Var v) { while (v >= nVars()) newVar(); }
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/abcsat/abc/Solver.h b/lib/abcsat/abc/Solver.h
new file mode 100644
index 0000000..a9a6f62
--- /dev/null
+++ b/lib/abcsat/abc/Solver.h
@@ -0,0 +1,493 @@
+/****************************************************************************************[Solver.h]
+ Glucose -- Copyright (c) 2009, Gilles Audemard, Laurent Simon
+                CRIL - Univ. Artois, France
+                LRI  - Univ. Paris Sud, France
+ 
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose are exactly the same as Minisat on which it is based on. (see below).
+
+---------------
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_Solver_h
+#define Glucose_Solver_h
+
+#include "Vec.h"
+#include "Heap.h"
+#include "Alg.h"
+#include "SolverTypes.h"
+#include "BoundedQueue.h"
+#include "Constants.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// Solver -- the main class:
+
+class Solver {
+public:
+
+    int SolverType; // ABC identifies Glucose's type as 0
+
+    // Constructor/Destructor:
+    //
+    Solver();
+    virtual ~Solver();
+
+    // ABC callbacks
+    void * pCnfMan;                      // external CNF manager
+    int(*pCnfFunc)(void * p, int, int*); // external callback. messages: 0: unsat; 1: sat; -1: still working
+    int nCallConfl;                      // callback will be called every this number of conflicts
+    bool terminate_search_early;         // used to stop the solver early if it as instructed by an external caller
+    int * pstop;                         // another callback
+    uint64_t nRuntimeLimit;              // runtime limit
+    vec<int> user_vec;
+    vec<Lit> user_lits;
+
+    // Problem specification:
+    //
+    Var     newVar    (bool polarity = true, bool dvar = true); // Add a new variable with parameters specifying variable mode.
+    void    addVar    (Var v);                                  // Add enough variables to make sure there is variable v.
+
+    bool    addClause (const vec<Lit>& ps);                     // Add a clause to the solver. 
+    bool    addEmptyClause();                                   // Add the empty clause, making the solver contradictory.
+    bool    addClause (Lit p);                                  // Add a unit clause to the solver. 
+    bool    addClause (Lit p, Lit q);                           // Add a binary clause to the solver. 
+    bool    addClause (Lit p, Lit q, Lit r);                    // Add a ternary clause to the solver. 
+    bool    addClause_(      vec<Lit>& ps);                     // Add a clause to the solver without making superflous internal copy. Will
+                                                                // change the passed vector 'ps'.
+
+    // Solving:
+    //
+    bool    simplify     ();                        // Removes already satisfied clauses.
+    bool    solve        (const vec<Lit>& assumps); // Search for a model that respects a given set of assumptions.
+    lbool   solveLimited (const vec<Lit>& assumps); // Search for a model that respects a given set of assumptions (With resource constraints).
+    bool    solve        ();                        // Search without assumptions.
+    bool    solve        (Lit p);                   // Search for a model that respects a single assumption.
+    bool    solve        (Lit p, Lit q);            // Search for a model that respects two assumptions.
+    bool    solve        (Lit p, Lit q, Lit r);     // Search for a model that respects three assumptions.
+    bool    okay         () const;                  // FALSE means solver is in a conflicting state
+
+    void    toDimacs     (FILE* f, const vec<Lit>& assumps);            // Write CNF to file in DIMACS-format.
+    void    toDimacs     (const char *file, const vec<Lit>& assumps);
+    void    toDimacs     (FILE* f, Clause& c, vec<Var>& map, Var& max);
+    void printLit(Lit l);
+    void printClause(CRef c);
+    void printInitialClause(CRef c);
+    // Convenience versions of 'toDimacs()':
+    void    toDimacs     (const char* file);
+    void    toDimacs     (const char* file, Lit p);
+    void    toDimacs     (const char* file, Lit p, Lit q);
+    void    toDimacs     (const char* file, Lit p, Lit q, Lit r);
+    
+    // Variable mode:
+    // 
+    void    setPolarity    (Var v, bool b); // Declare which polarity the decision heuristic should use for a variable. Requires mode 'polarity_user'.
+    void    setDecisionVar (Var v, bool b); // Declare if a variable should be eligible for selection in the decision heuristic.
+
+    // Read state:
+    //
+    lbool   value      (Var x) const;       // The current value of a variable.
+    lbool   value      (Lit p) const;       // The current value of a literal.
+    lbool   modelValue (Var x) const;       // The value of a variable in the last model. The last call to solve must have been satisfiable.
+    lbool   modelValue (Lit p) const;       // The value of a literal in the last model. The last call to solve must have been satisfiable.
+    int     nAssigns   ()      const;       // The current number of assigned literals.
+    int     nClauses   ()      const;       // The current number of original clauses.
+    int     nLearnts   ()      const;       // The current number of learnt clauses.
+    int     nVars      ()      const;       // The current number of variables.
+    int     nFreeVars  ()      const;
+
+    // Incremental mode
+    void setIncrementalMode();
+    void initNbInitialVars(int nb);
+    void printIncrementalStats();
+
+    // Resource contraints:
+    //
+    void    setConfBudget(int64_t x);
+    void    setPropBudget(int64_t x);
+    void    budgetOff();
+    void    interrupt();          // Trigger a (potentially asynchronous) interruption of the solver.
+    void    clearInterrupt();     // Clear interrupt indicator flag.
+
+    // Memory managment:
+    //
+    virtual void reset();
+    virtual void garbageCollect(); // virtuality causes segfault for some reason
+    void    checkGarbage(double gf);
+    void    checkGarbage();
+
+
+
+
+    // Extra results: (read-only member variable)
+    //
+    vec<lbool> model;             // If problem is satisfiable, this vector contains the model (if any).
+    vec<Lit>   conflict;          // If problem is unsatisfiable (possibly under assumptions),
+                                  // this vector represent the final conflict clause expressed in the assumptions.
+
+    // Mode of operation:
+    //
+    int       verbosity;
+    int       verbEveryConflicts;
+    int       showModel;
+    // Constants For restarts
+    double    K;
+    double    R;
+    double    sizeLBDQueue;
+    double    sizeTrailQueue;
+
+    // Constants for reduce DB
+    int firstReduceDB;
+    int incReduceDB;
+    int specialIncReduceDB;
+    unsigned int lbLBDFrozenClause;
+
+    // Constant for reducing clause
+    int lbSizeMinimizingClause;
+    unsigned int lbLBDMinimizingClause;
+
+    double    var_decay;
+    double    clause_decay;
+    double    random_var_freq;
+    double    random_seed;
+    int       ccmin_mode;         // Controls conflict clause minimization (0=none, 1=basic, 2=deep).
+    int       phase_saving;       // Controls the level of phase saving (0=none, 1=limited, 2=full).
+    bool      rnd_pol;            // Use random polarities for branching heuristics.
+    bool      rnd_init_act;       // Initialize variable activities with a small random value.
+    double    garbage_frac;       // The fraction of wasted memory allowed before a garbage collection is triggered.
+
+    // Certified UNSAT ( Thanks to Marijn Heule)
+    FILE*               certifiedOutput;
+    bool                certifiedUNSAT;
+
+    
+    // Statistics: (read-only member variable)
+    //
+    int64_t nbRemovedClauses,nbReducedClauses,nbDL2,nbBin,nbUn,nbReduceDB,solves, starts, decisions, rnd_decisions, propagations, conflicts,conflictsRestarts,nbstopsrestarts,nbstopsrestartssame,lastblockatrestart;
+    int64_t dec_vars, clauses_literals, learnts_literals, max_literals, tot_literals;
+
+protected:
+    long curRestart;
+    // Helper structures:
+    //
+    struct VarData { CRef reason; int level; };
+    static inline VarData mkVarData(CRef cr, int l){ VarData d = {cr, l}; return d; }
+
+    struct Watcher {
+        CRef cref;
+        Lit  blocker;
+        Watcher(CRef cr, Lit p) : cref(cr), blocker(p) {}
+        bool operator==(const Watcher& w) const { return cref == w.cref; }
+        bool operator!=(const Watcher& w) const { return cref != w.cref; }
+    };
+
+    struct WatcherDeleted
+    {
+        const ClauseAllocator& ca;
+        WatcherDeleted(const ClauseAllocator& _ca) : ca(_ca) {}
+        bool operator()(const Watcher& w) const { return ca[w.cref].mark() == 1; }
+    };
+
+    struct VarOrderLt {
+        const vec<double>&  activity;
+        bool operator () (Var x, Var y) const { return activity[x] > activity[y]; }
+        VarOrderLt(const vec<double>&  act) : activity(act) { }
+    };
+
+
+    // Solver state:
+    //
+    int lastIndexRed;
+    bool                ok;               // If FALSE, the constraints are already unsatisfiable. No part of the solver state may be used!
+    double              cla_inc;          // Amount to bump next clause with.
+    vec<double>         activity;         // A heuristic measurement of the activity of a variable.
+    double              var_inc;          // Amount to bump next variable with.
+    OccLists<Lit, vec<Watcher>, WatcherDeleted>
+                        watches;          // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true).
+    OccLists<Lit, vec<Watcher>, WatcherDeleted>
+                        watchesBin;          // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true).
+    vec<CRef>           clauses;          // List of problem clauses.
+    vec<CRef>           learnts;          // List of learnt clauses.
+
+    vec<lbool>          assigns;          // The current assignments.
+    vec<char>           polarity;         // The preferred polarity of each variable.
+    vec<char>           decision;         // Declares if a variable is eligible for selection in the decision heuristic.
+    vec<Lit>            trail;            // Assignment stack; stores all assigments made in the order they were made.
+    vec<int>            nbpos;
+    vec<int>            trail_lim;        // Separator indices for different decision levels in 'trail'.
+    vec<VarData>        vardata;          // Stores reason and level for each variable.
+    int                 qhead;            // Head of queue (as index into the trail -- no more explicit propagation queue in MiniSat).
+    int                 simpDB_assigns;   // Number of top-level assignments since last execution of 'simplify()'.
+    int64_t             simpDB_props;     // Remaining number of propagations that must be made before next execution of 'simplify()'.
+    vec<Lit>            assumptions;      // Current set of assumptions provided to solve by the user.
+    Heap<VarOrderLt>    order_heap;       // A priority queue of variables ordered with respect to the variable activity.
+    double              progress_estimate;// Set by 'search()'.
+    bool                remove_satisfied; // Indicates whether possibly inefficient linear scan for satisfied clauses should be performed in 'simplify'.
+    vec<unsigned int> permDiff;      // permDiff[var] contains the current conflict number... Used to count the number of  LBD
+    
+#ifdef UPDATEVARACTIVITY
+    // UPDATEVARACTIVITY trick (see competition'09 companion paper)
+    vec<Lit> lastDecisionLevel; 
+#endif
+
+    ClauseAllocator     ca;
+
+    int nbclausesbeforereduce;            // To know when it is time to reduce clause database
+    
+    bqueue<unsigned int> trailQueue,lbdQueue; // Bounded queues for restarts.
+    float sumLBD; // used to compute the global average of LBD. Restarts...
+    int sumAssumptions;
+
+
+    // Temporaries (to reduce allocation overhead). Each variable is prefixed by the method in which it is
+    // used, exept 'seen' wich is used in several places.
+    //
+    vec<char>           seen;
+    vec<Lit>            analyze_stack;
+    vec<Lit>            analyze_toclear;
+    vec<Lit>            add_tmp;
+    unsigned int  MYFLAG;
+
+
+    double              max_learnts;
+    double              learntsize_adjust_confl;
+    int                 learntsize_adjust_cnt;
+
+    // Resource contraints:
+    //
+    int64_t             conflict_budget;    // -1 means no budget.
+    int64_t             propagation_budget; // -1 means no budget.
+    bool                asynch_interrupt;
+
+
+    // Variables added for incremental mode
+    int incremental; // Use incremental SAT Solver
+    int nbVarsInitialFormula; // nb VAR in formula without assumptions (incremental SAT)
+    double totalTime4Sat,totalTime4Unsat;
+    int nbSatCalls,nbUnsatCalls;
+    vec<int> assumptionPositions,initialPositions;
+
+
+    // Main internal methods:
+    //
+    void     insertVarOrder   (Var x);                                                 // Insert a variable in the decision order priority queue.
+    Lit      pickBranchLit    ();                                                      // Return the next decision variable.
+    void     newDecisionLevel ();                                                      // Begins a new decision level.
+    void     uncheckedEnqueue (Lit p, CRef from = CRef_Undef);                         // Enqueue a literal. Assumes value of literal is undefined.
+    bool     enqueue          (Lit p, CRef from = CRef_Undef);                         // Test if fact 'p' contradicts current state, enqueue otherwise.
+    CRef     propagate        ();                                                      // Perform unit propagation. Returns possibly conflicting clause.
+    void     cancelUntil      (int level);                                             // Backtrack until a certain level.
+    void     analyze          (CRef confl, vec<Lit>& out_learnt, vec<Lit> & selectors, int& out_btlevel,unsigned int &nblevels,unsigned int &szWithoutSelectors);    // (bt = backtrack)
+    void     analyzeFinal     (Lit p, vec<Lit>& out_conflict);                         // COULD THIS BE IMPLEMENTED BY THE ORDINARIY "analyze" BY SOME REASONABLE GENERALIZATION?
+    bool     litRedundant     (Lit p, uint32_t abstract_levels);                       // (helper method for 'analyze()')
+    lbool    search           (int nof_conflicts);                                     // Search for a given number of conflicts.
+    lbool    solve_           ();                                                      // Main solve method (assumptions given in 'assumptions').
+    void     reduceDB         ();                                                      // Reduce the set of learnt clauses.
+    void     removeSatisfied  (vec<CRef>& cs);                                         // Shrink 'cs' to contain only non-satisfied clauses.
+    void     rebuildOrderHeap ();
+
+    // Maintaining Variable/Clause activity:
+    //
+    void     varDecayActivity ();                      // Decay all variables with the specified factor. Implemented by increasing the 'bump' value instead.
+    void     varBumpActivity  (Var v, double inc);     // Increase a variable with the current 'bump' value.
+    void     varBumpActivity  (Var v);                 // Increase a variable with the current 'bump' value.
+    void     claDecayActivity ();                      // Decay all clauses with the specified factor. Implemented by increasing the 'bump' value instead.
+    void     claBumpActivity  (Clause& c);             // Increase a clause with the current 'bump' value.
+
+    // Operations on clauses:
+    //
+    void     attachClause     (CRef cr);               // Attach a clause to watcher lists.
+    void     detachClause     (CRef cr, bool strict = false); // Detach a clause to watcher lists.
+    void     removeClause     (CRef cr);               // Detach and free a clause.
+    bool     locked           (const Clause& c) const; // Returns TRUE if a clause is a reason for some implication in the current state.
+    bool     satisfied        (const Clause& c) const; // Returns TRUE if a clause is satisfied in the current state.
+
+    unsigned int computeLBD(const vec<Lit> & lits,int end=-1);
+    unsigned int computeLBD(const Clause &c);
+    void minimisationWithBinaryResolution(vec<Lit> &out_learnt);
+
+    void     relocAll         (ClauseAllocator& to);
+
+    // Misc:
+    //
+    int      decisionLevel    ()      const; // Gives the current decisionlevel.
+    uint32_t abstractLevel    (Var x) const; // Used to represent an abstraction of sets of decision levels.
+    CRef     reason           (Var x) const;
+    int      level            (Var x) const;
+    double   progressEstimate ()      const; // DELETE THIS ?? IT'S NOT VERY USEFUL ...
+    bool     withinBudget     ()      const;
+    inline bool isSelector(Var v) {return (incremental && v>nbVarsInitialFormula);}
+
+    // Static helpers:
+    //
+
+    // Returns a random float 0 <= x < 1. Seed must never be 0.
+    static inline double drand(double& seed) {
+        seed *= 1389796;
+        int q = (int)(seed / 2147483647);
+        seed -= (double)q * 2147483647;
+        return seed / 2147483647; }
+
+    // Returns a random integer 0 <= x < size. Seed must never be 0.
+    static inline int irand(double& seed, int size) {
+        return (int)(drand(seed) * size); }
+};
+
+
+//=================================================================================================
+// Implementation of inline methods:
+
+inline CRef Solver::reason(Var x) const { return vardata[x].reason; }
+inline int  Solver::level (Var x) const { return vardata[x].level; }
+
+inline void Solver::insertVarOrder(Var x) {
+    if (!order_heap.inHeap(x) && decision[x]) order_heap.insert(x); }
+
+inline void Solver::varDecayActivity() { var_inc *= (1 / var_decay); }
+inline void Solver::varBumpActivity(Var v) { varBumpActivity(v, var_inc); }
+inline void Solver::varBumpActivity(Var v, double inc) {
+    if ( (activity[v] += inc) > 1e100 ) {
+        // Rescale:
+        for (int i = 0; i < nVars(); i++)
+            activity[i] *= 1e-100;
+        var_inc *= 1e-100; }
+
+    // Update order_heap with respect to new activity:
+    if (order_heap.inHeap(v))
+        order_heap.decrease(v); }
+
+inline void Solver::claDecayActivity() { cla_inc *= (1 / clause_decay); }
+inline void Solver::claBumpActivity (Clause& c) {
+        if ( (c.activity() += cla_inc) > 1e20 ) {
+            // Rescale:
+            for (int i = 0; i < learnts.size(); i++)
+                ca[learnts[i]].activity() *= (float)1e-20;
+            cla_inc *= 1e-20; } }
+
+inline void Solver::checkGarbage(void){ checkGarbage(garbage_frac); }
+inline void Solver::checkGarbage(double gf){
+    if (ca.wasted() > ca.size() * gf)
+        garbageCollect();}
+
+// NOTE: enqueue does not set the ok flag! (only public methods do)
+inline bool     Solver::enqueue         (Lit p, CRef from)      { return value(p) != l_Undef ? value(p) != l_False : (uncheckedEnqueue(p, from), true); }
+inline bool     Solver::addClause       (const vec<Lit>& ps)    { ps.copyTo(add_tmp); return addClause_(add_tmp); }
+inline bool     Solver::addEmptyClause  ()                      { add_tmp.clear(); return addClause_(add_tmp); }
+inline bool     Solver::addClause       (Lit p)                 { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); }
+inline bool     Solver::addClause       (Lit p, Lit q)          { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); }
+inline bool     Solver::addClause       (Lit p, Lit q, Lit r)   { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); }
+inline bool     Solver::locked          (const Clause& c) const { 
+   if(c.size()>2) 
+     return value(c[0]) == l_True && reason(var(c[0])) != CRef_Undef && ca.lea(reason(var(c[0]))) == &c; 
+   return 
+     (value(c[0]) == l_True && reason(var(c[0])) != CRef_Undef && ca.lea(reason(var(c[0]))) == &c)
+     || 
+     (value(c[1]) == l_True && reason(var(c[1])) != CRef_Undef && ca.lea(reason(var(c[1]))) == &c);
+ }
+inline void     Solver::newDecisionLevel()                      { trail_lim.push(trail.size()); }
+
+inline int      Solver::decisionLevel ()      const   { return trail_lim.size(); }
+inline uint32_t Solver::abstractLevel (Var x) const   { return 1 << (level(x) & 31); }
+inline lbool    Solver::value         (Var x) const   { return assigns[x]; }
+inline lbool    Solver::value         (Lit p) const   { return assigns[var(p)] ^ sign(p); }
+inline lbool    Solver::modelValue    (Var x) const   { return model[x]; }
+inline lbool    Solver::modelValue    (Lit p) const   { return model[var(p)] ^ sign(p); }
+inline int      Solver::nAssigns      ()      const   { return trail.size(); }
+inline int      Solver::nClauses      ()      const   { return clauses.size(); }
+inline int      Solver::nLearnts      ()      const   { return learnts.size(); }
+inline int      Solver::nVars         ()      const   { return vardata.size(); }
+inline int      Solver::nFreeVars     ()      const   { return (int)dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]); }
+inline void     Solver::setPolarity   (Var v, bool b) { polarity[v] = b; }
+inline void     Solver::setDecisionVar(Var v, bool b) 
+{ 
+    if      ( b && !decision[v]) dec_vars++;
+    else if (!b &&  decision[v]) dec_vars--;
+
+    decision[v] = b;
+    insertVarOrder(v);
+}
+inline void     Solver::setConfBudget(int64_t x){ conflict_budget    = conflicts    + x; }
+inline void     Solver::setPropBudget(int64_t x){ propagation_budget = propagations + x; }
+inline void     Solver::interrupt(){ asynch_interrupt = true; }
+inline void     Solver::clearInterrupt(){ asynch_interrupt = false; }
+inline void     Solver::budgetOff(){ conflict_budget = propagation_budget = -1; }
+inline bool     Solver::withinBudget() const {
+    return !asynch_interrupt &&
+           (conflict_budget    < 0 || conflicts < (uint64_t)conflict_budget) &&
+           (propagation_budget < 0 || propagations < (uint64_t)propagation_budget); }
+
+// FIXME: after the introduction of asynchronous interrruptions the solve-versions that return a
+// pure bool do not give a safe interface. Either interrupts must be possible to turn off here, or
+// all calls to solve must return an 'lbool'. I'm not yet sure which I prefer.
+inline bool     Solver::solve         ()                    { budgetOff(); assumptions.clear(); return solve_() == l_True; }
+inline bool     Solver::solve         (Lit p)               { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_() == l_True; }
+inline bool     Solver::solve         (Lit p, Lit q)        { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_() == l_True; }
+inline bool     Solver::solve         (Lit p, Lit q, Lit r) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_() == l_True; }
+inline bool     Solver::solve         (const vec<Lit>& assumps){ budgetOff(); assumps.copyTo(assumptions); return solve_() == l_True; }
+inline lbool    Solver::solveLimited  (const vec<Lit>& assumps){ assumps.copyTo(assumptions); return solve_(); }
+inline bool     Solver::okay          ()      const   { return ok; }
+
+inline void     Solver::toDimacs      (const char* file){ vec<Lit> as; toDimacs(file, as); }
+inline void     Solver::toDimacs      (const char* file, Lit p){ vec<Lit> as; as.push(p); toDimacs(file, as); }
+inline void     Solver::toDimacs      (const char* file, Lit p, Lit q){ vec<Lit> as; as.push(p); as.push(q); toDimacs(file, as); }
+inline void     Solver::toDimacs      (const char* file, Lit p, Lit q, Lit r){ vec<Lit> as; as.push(p); as.push(q); as.push(r); toDimacs(file, as); }
+
+inline void     Solver::addVar(Var v) { while (v >= nVars()) newVar(); }
+
+//=================================================================================================
+// Debug etc:
+
+
+inline void Solver::printLit(Lit l)
+{
+    printf("%s%d:%c", sign(l) ? "-" : "", var(l)+1, value(l) == l_True ? '1' : (value(l) == l_False ? '0' : 'X'));
+}
+
+
+inline void Solver::printClause(CRef cr)
+{
+  Clause &c = ca[cr];
+    for (int i = 0; i < c.size(); i++){
+        printLit(c[i]);
+        printf(" ");
+    }
+}
+
+inline void Solver::printInitialClause(CRef cr)
+{
+  Clause &c = ca[cr];
+    for (int i = 0; i < c.size(); i++){
+      if(!isSelector(var(c[i]))) {
+    printLit(c[i]);
+        printf(" ");
+      }
+    }
+}
+
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/abcsat/abc/SolverTypes.h b/lib/abcsat/abc/SolverTypes.h
new file mode 100644
index 0000000..34dc2cc
--- /dev/null
+++ b/lib/abcsat/abc/SolverTypes.h
@@ -0,0 +1,437 @@
+/***********************************************************************************[SolverTypes.h]
+ Glucose -- Copyright (c) 2009, Gilles Audemard, Laurent Simon
+                CRIL - Univ. Artois, France
+                LRI  - Univ. Paris Sud, France
+ 
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose are exactly the same as Minisat on which it is based on. (see below).
+
+---------------
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Glucose_SolverTypes_h
+#define Glucose_SolverTypes_h
+
+#include <assert.h>
+
+#include "IntTypes.h"
+#include "Alg.h"
+#include "Vec.h"
+#include "Map.h"
+#include "Alloc.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// Variables, literals, lifted booleans, clauses:
+
+
+// NOTE! Variables are just integers. No abstraction here. They should be chosen from 0..N,
+// so that they can be used as array indices.
+
+typedef int Var;
+#define var_Undef (-1)
+
+
+struct Lit {
+    int     x;
+
+    // Use this as a constructor:
+    friend Lit mkLit(Var var, bool sign);
+    bool operator == (Lit p) const { return x == p.x; }
+    bool operator != (Lit p) const { return x != p.x; }
+    bool operator <  (Lit p) const { return x < p.x;  } // '<' makes p, ~p adjacent in the ordering.
+};
+
+
+inline  Lit  mkLit     (Var var, bool sign = false) { Lit p; p.x = var + var + (int)sign; return p; }
+inline  Lit  operator ~(Lit p)              { Lit q; q.x = p.x ^ 1; return q; }
+inline  Lit  operator ^(Lit p, bool b)      { Lit q; q.x = p.x ^ (unsigned int)b; return q; }
+inline  bool sign      (Lit p)              { return p.x & 1; }
+inline  int  var       (Lit p)              { return p.x >> 1; }
+
+// Mapping Literals to and from compact integers suitable for array indexing:
+inline  int  toInt     (Var v)              { return v; } 
+inline  int  toInt     (Lit p)              { return p.x; } 
+inline  Lit  toLit     (int i)              { Lit p; p.x = i; return p; } 
+
+//const Lit lit_Undef = mkLit(var_Undef, false);  // }- Useful special constants.
+//const Lit lit_Error = mkLit(var_Undef, true );  // }
+
+const Lit lit_Undef = { -2 };  // }- Useful special constants.
+const Lit lit_Error = { -1 };  // }
+
+
+//=================================================================================================
+// Lifted booleans:
+//
+// NOTE: this implementation is optimized for the case when comparisons between values are mostly
+//       between one variable and one constant. Some care had to be taken to make sure that gcc 
+//       does enough constant propagation to produce sensible code, and this appears to be somewhat
+//       fragile unfortunately.
+
+#define l_True  (Gluco::lbool((uint8_t)0)) // gcc does not do constant propagation if these are real constants.
+#define l_False (Gluco::lbool((uint8_t)1))
+#define l_Undef (Gluco::lbool((uint8_t)2))
+
+class lbool {
+    uint8_t value;
+
+public:
+    explicit lbool(uint8_t v) : value(v) { }
+
+    lbool()       : value(0) { }
+    explicit lbool(bool x) : value(!x) { }
+
+    bool  operator == (lbool b) const { return (((b.value&2) & (value&2)) | (!(b.value&2)&(value == b.value))) != 0; }
+    bool  operator != (lbool b) const { return !(*this == b); }
+    lbool operator ^  (bool  b) const { return lbool((uint8_t)(value^(uint8_t)b)); }
+
+    lbool operator && (lbool b) const { 
+        uint8_t sel = (this->value << 1) | (b.value << 3);
+        uint8_t v   = (0xF7F755F4 >> sel) & 3;
+        return lbool(v); }
+
+    lbool operator || (lbool b) const {
+        uint8_t sel = (this->value << 1) | (b.value << 3);
+        uint8_t v   = (0xFCFCF400 >> sel) & 3;
+        return lbool(v); }
+
+    friend int   toInt  (lbool l);
+    friend lbool toLbool(int   v);
+};
+inline int   toInt  (lbool l) { return l.value; }
+inline lbool toLbool(int   v) { return lbool((uint8_t)v);  }
+
+//=================================================================================================
+// Clause -- a simple class for representing a clause:
+
+class Clause;
+typedef RegionAllocator<uint32_t>::Ref CRef;
+
+class Clause {
+    struct {
+      unsigned mark      : 2;
+      unsigned learnt    : 1;
+      unsigned has_extra : 1;
+      unsigned reloced   : 1;
+      unsigned lbd       : 26;
+      unsigned canbedel  : 1;
+      unsigned size      : 32;
+      unsigned szWithoutSelectors : 32;
+
+    }                            header;
+    union { Lit lit; float act; uint32_t abs; CRef rel; } data[0];
+
+    friend class ClauseAllocator;
+
+    // NOTE: This constructor cannot be used directly (doesn't allocate enough memory).
+    template<class V>
+    Clause(const V& ps, bool use_extra, bool learnt) {
+        header.mark      = 0;
+        header.learnt    = learnt;
+        header.has_extra = use_extra;
+        header.reloced   = 0;
+        header.size      = ps.size();
+    header.lbd = 0;
+    header.canbedel = 1;
+        for (int i = 0; i < ps.size(); i++) 
+            data[i].lit = ps[i];
+    
+        if (header.has_extra){
+      if (header.learnt) 
+                data[header.size].act = 0; 
+            else 
+                calcAbstraction(); }
+    }
+
+public:
+    void calcAbstraction() {
+        assert(header.has_extra);
+        uint32_t abstraction = 0;
+        for (int i = 0; i < size(); i++)
+            abstraction |= 1 << (var(data[i].lit) & 31);
+        data[header.size].abs = abstraction;  }
+
+
+    int          size        ()      const   { return header.size; }
+    void         shrink      (int i)         { assert(i <= size()); if (header.has_extra) data[header.size-i] = data[header.size]; header.size -= i; }
+    void         pop         ()              { shrink(1); }
+    bool         learnt      ()      const   { return header.learnt; }
+    bool         has_extra   ()      const   { return header.has_extra; }
+    uint32_t     mark        ()      const   { return header.mark; }
+    void         mark        (uint32_t m)    { header.mark = m; }
+    const Lit&   last        ()      const   { return data[header.size-1].lit; }
+
+    bool         reloced     ()      const   { return header.reloced; }
+    CRef         relocation  ()      const   { return data[0].rel; }
+    void         relocate    (CRef c)        { header.reloced = 1; data[0].rel = c; }
+
+    // NOTE: somewhat unsafe to change the clause in-place! Must manually call 'calcAbstraction' afterwards for
+    //       subsumption operations to behave correctly.
+    Lit&         operator [] (int i)         { return data[i].lit; }
+    Lit          operator [] (int i) const   { return data[i].lit; }
+    operator const Lit* (void) const         { return (Lit*)data; }
+
+    float&       activity    ()              { assert(header.has_extra); return data[header.size].act; }
+    uint32_t     abstraction () const        { assert(header.has_extra); return data[header.size].abs; }
+
+    Lit          subsumes    (const Clause& other) const;
+    void         strengthen  (Lit p);
+    void         setLBD(int i)  {header.lbd = i;} 
+    // unsigned int&       lbd    ()              { return header.lbd; }
+    unsigned int        lbd    () const        { return header.lbd; }
+    void setCanBeDel(bool b) {header.canbedel = b;}
+    bool canBeDel() {return header.canbedel;}
+    void setSizeWithoutSelectors   (unsigned int n)              {header.szWithoutSelectors = n; }
+    unsigned int        sizeWithoutSelectors   () const        { return header.szWithoutSelectors; }
+
+};
+
+
+//=================================================================================================
+// ClauseAllocator -- a simple class for allocating memory for clauses:
+
+
+const CRef CRef_Undef = RegionAllocator<uint32_t>::Ref_Undef;
+class ClauseAllocator : public RegionAllocator<uint32_t>
+{
+    static int clauseWord32Size(int size, bool has_extra){
+        return (sizeof(Clause) + (sizeof(Lit) * (size + (int)has_extra))) / sizeof(uint32_t); }
+ public:
+    bool extra_clause_field;
+
+    ClauseAllocator(uint32_t start_cap) : RegionAllocator<uint32_t>(start_cap), extra_clause_field(false){}
+    ClauseAllocator() : extra_clause_field(false){}
+
+    void moveTo(ClauseAllocator& to){
+        to.extra_clause_field = extra_clause_field;
+        RegionAllocator<uint32_t>::moveTo(to); }
+
+    template<class Lits>
+    CRef alloc(const Lits& ps, bool learnt = false)
+    {
+        assert(sizeof(Lit)      == sizeof(uint32_t));
+        assert(sizeof(float)    == sizeof(uint32_t));
+        bool use_extra = learnt | extra_clause_field;
+
+        CRef cid = RegionAllocator<uint32_t>::alloc(clauseWord32Size(ps.size(), use_extra));
+        new (lea(cid)) Clause(ps, use_extra, learnt);
+
+        return cid;
+    }
+
+    // Deref, Load Effective Address (LEA), Inverse of LEA (AEL):
+    Clause&       operator[](Ref r)       { return (Clause&)RegionAllocator<uint32_t>::operator[](r); }
+    const Clause& operator[](Ref r) const { return (Clause&)RegionAllocator<uint32_t>::operator[](r); }
+    Clause*       lea       (Ref r)       { return (Clause*)RegionAllocator<uint32_t>::lea(r); }
+    const Clause* lea       (Ref r) const { return (Clause*)RegionAllocator<uint32_t>::lea(r); }
+    Ref           ael       (const Clause* t){ return RegionAllocator<uint32_t>::ael((uint32_t*)t); }
+
+    void free_(CRef cid)
+    {
+        Clause& c = operator[](cid);
+        RegionAllocator<uint32_t>::free_(clauseWord32Size(c.size(), c.has_extra()));
+    }
+
+    void reloc(CRef& cr, ClauseAllocator& to)
+    {
+        Clause& c = operator[](cr);
+        
+        if (c.reloced()) { cr = c.relocation(); return; }
+        
+        cr = to.alloc(c, c.learnt());
+        c.relocate(cr);
+        
+        // Copy extra data-fields: 
+        // (This could be cleaned-up. Generalize Clause-constructor to be applicable here instead?)
+        to[cr].mark(c.mark());
+        if (to[cr].learnt())        {
+      to[cr].activity() = c.activity();
+      to[cr].setLBD(c.lbd());
+      to[cr].setSizeWithoutSelectors(c.sizeWithoutSelectors());
+      to[cr].setCanBeDel(c.canBeDel());
+    }
+        else if (to[cr].has_extra()) to[cr].calcAbstraction();
+    }
+};
+
+
+//=================================================================================================
+// OccLists -- a class for maintaining occurence lists with lazy deletion:
+
+template<class Idx, class Vec, class Deleted>
+class OccLists
+{
+    vec<Vec>  occs;
+    vec<char> dirty;
+    vec<Idx>  dirties;
+    Deleted   deleted;
+
+ public:
+    OccLists(const Deleted& d) : deleted(d) {}
+    
+    void  init      (const Idx& idx){ occs.growTo(toInt(idx)+1); dirty.growTo(toInt(idx)+1, 0); }
+    // Vec&  operator[](const Idx& idx){ return occs[toInt(idx)]; }
+    Vec&  operator[](const Idx& idx){ return occs[toInt(idx)]; }
+    Vec&  lookup    (const Idx& idx){ if (dirty[toInt(idx)]) clean(idx); return occs[toInt(idx)]; }
+
+    void  cleanAll  ();
+    void  clean     (const Idx& idx);
+    void  smudge    (const Idx& idx){
+        if (dirty[toInt(idx)] == 0){
+            dirty[toInt(idx)] = 1;
+            dirties.push(idx);
+        }
+    }
+
+    void  clear(bool free = true){
+        occs   .clear(free);
+        dirty  .clear(free);
+        dirties.clear(free);
+    }
+};
+
+
+template<class Idx, class Vec, class Deleted>
+void OccLists<Idx,Vec,Deleted>::cleanAll()
+{
+    for (int i = 0; i < dirties.size(); i++)
+        // Dirties may contain duplicates so check here if a variable is already cleaned:
+        if (dirty[toInt(dirties[i])])
+            clean(dirties[i]);
+    dirties.clear();
+}
+
+
+template<class Idx, class Vec, class Deleted>
+void OccLists<Idx,Vec,Deleted>::clean(const Idx& idx)
+{
+    Vec& vec = occs[toInt(idx)];
+    int  i, j;
+    for (i = j = 0; i < vec.size(); i++)
+        if (!deleted(vec[i]))
+            vec[j++] = vec[i];
+    vec.shrink(i - j);
+    dirty[toInt(idx)] = 0;
+}
+
+
+//=================================================================================================
+// CMap -- a class for mapping clauses to values:
+
+
+template<class T>
+class CMap
+{
+    struct CRefHash {
+        uint32_t operator()(CRef cr) const { return (uint32_t)cr; } };
+
+    typedef Map<CRef, T, CRefHash> HashTable;
+    HashTable map;
+        
+ public:
+    // Size-operations:
+    void     clear       ()                           { map.clear(); }
+    int      size        ()                const      { return map.elems(); }
+
+    
+    // Insert/Remove/Test mapping:
+    void     insert      (CRef cr, const T& t){ map.insert(cr, t); }
+    void     growTo      (CRef cr, const T& t){ map.insert(cr, t); } // NOTE: for compatibility
+    void     remove      (CRef cr)            { map.remove(cr); }
+    bool     has         (CRef cr, T& t)      { return map.peek(cr, t); }
+
+    // Vector interface (the clause 'c' must already exist):
+    const T& operator [] (CRef cr) const      { return map[cr]; }
+    T&       operator [] (CRef cr)            { return map[cr]; }
+
+    // Iteration (not transparent at all at the moment):
+    int  bucket_count() const { return map.bucket_count(); }
+    const vec<typename HashTable::Pair>& bucket(int i) const { return map.bucket(i); }
+
+    // Move contents to other map:
+    void moveTo(CMap& other){ map.moveTo(other.map); }
+
+    // TMP debug:
+    void debug(){
+        printf(" --- size = %d, bucket_count = %d\n", size(), map.bucket_count()); }
+};
+
+
+/*_________________________________________________________________________________________________
+|
+|  subsumes : (other : const Clause&)  ->  Lit
+|  
+|  Description:
+|       Checks if clause subsumes 'other', and at the same time, if it can be used to simplify 'other'
+|       by subsumption resolution.
+|  
+|    Result:
+|       lit_Error  - No subsumption or simplification
+|       lit_Undef  - Clause subsumes 'other'
+|       p          - The literal p can be deleted from 'other'
+|________________________________________________________________________________________________@*/
+inline Lit Clause::subsumes(const Clause& other) const
+{
+    //if (other.size() < size() || (extra.abst & ~other.extra.abst) != 0)
+    //if (other.size() < size() || (!learnt() && !other.learnt() && (extra.abst & ~other.extra.abst) != 0))
+    assert(!header.learnt);   assert(!other.header.learnt);
+    assert(header.has_extra); assert(other.header.has_extra);
+    if (other.header.size < header.size || (data[header.size].abs & ~other.data[other.header.size].abs) != 0)
+        return lit_Error;
+
+    Lit        ret = lit_Undef;
+    const Lit* c   = (const Lit*)(*this);
+    const Lit* d   = (const Lit*)other;
+
+    for (unsigned i = 0; i < header.size; i++) {
+        // search for c[i] or ~c[i]
+        for (unsigned j = 0; j < other.header.size; j++)
+            if (c[i] == d[j])
+                goto ok;
+            else if (ret == lit_Undef && c[i] == ~d[j]){
+                ret = c[i];
+                goto ok;
+            }
+
+        // did not find it
+        return lit_Error;
+    ok:;
+    }
+
+    return ret;
+}
+
+inline void Clause::strengthen(Lit p)
+{
+    remove(*this, p);
+    calcAbstraction();
+}
+ 
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/abcsat/abc/Sort.h b/lib/abcsat/abc/Sort.h
new file mode 100644
index 0000000..b82f240
--- /dev/null
+++ b/lib/abcsat/abc/Sort.h
@@ -0,0 +1,101 @@
+/******************************************************************************************[Sort.h]
+Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_Sort_h
+#define Glucose_Sort_h
+
+#include "Vec.h"
+
+//=================================================================================================
+// Some sorting algorithms for vec's
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+template<class T>
+struct LessThan_default {
+    bool operator () (T x, T y) { return x < y; }
+};
+
+
+template <class T, class LessThan>
+void selectionSort(T* array, int size, LessThan lt)
+{
+    int     i, j, best_i;
+    T       tmp;
+
+    for (i = 0; i < size-1; i++){
+        best_i = i;
+        for (j = i+1; j < size; j++){
+            if (lt(array[j], array[best_i]))
+                best_i = j;
+        }
+        tmp = array[i]; array[i] = array[best_i]; array[best_i] = tmp;
+    }
+}
+template <class T> static inline void selectionSort(T* array, int size) {
+    selectionSort(array, size, LessThan_default<T>()); }
+
+template <class T, class LessThan>
+void sort(T* array, int size, LessThan lt)
+{
+    if (size <= 15)
+        selectionSort(array, size, lt);
+
+    else{
+        T           pivot = array[size / 2];
+        T           tmp;
+        int         i = -1;
+        int         j = size;
+
+        for(;;){
+            do i++; while(lt(array[i], pivot));
+            do j--; while(lt(pivot, array[j]));
+
+            if (i >= j) break;
+
+            tmp = array[i]; array[i] = array[j]; array[j] = tmp;
+        }
+
+        sort(array    , i     , lt);
+        sort(&array[i], size-i, lt);
+    }
+}
+template <class T> static inline void sort(T* array, int size) {
+    sort(array, size, LessThan_default<T>()); }
+
+
+//=================================================================================================
+// For 'vec's:
+
+
+template <class T, class LessThan> void sort(vec<T>& v, LessThan lt) {
+    sort((T*)v, v.size(), lt); }
+template <class T> void sort(vec<T>& v) {
+    sort(v, LessThan_default<T>()); }
+
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/abcsat/abc/Vec.h b/lib/abcsat/abc/Vec.h
new file mode 100644
index 0000000..e52dace
--- /dev/null
+++ b/lib/abcsat/abc/Vec.h
@@ -0,0 +1,135 @@
+/*******************************************************************************************[Vec.h]
+Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_Vec_h
+#define Glucose_Vec_h
+
+#include <assert.h>
+#include <new>
+
+#include "IntTypes.h"
+#include "XAlloc.h"
+#include "abc_global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// Automatically resizable arrays
+//
+// NOTE! Don't use this vector on datatypes that cannot be re-located in memory (with realloc)
+
+template<class T>
+class vec {
+    T*  data;
+    int sz;
+    int cap;
+
+    // Don't allow copying (error prone):
+    vec<T>&  operator = (vec<T>& other) { assert(0); return *this; }
+             vec        (vec<T>& other) { assert(0); }
+             
+    // Helpers for calculating next capacity:
+    static inline int  imax   (int x, int y) { int mask = (y-x) >> (sizeof(int)*8-1); return (x&mask) + (y&(~mask)); }
+    //static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; }
+    static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; }
+
+public:
+    // Constructors:
+    vec()                       : data(NULL) , sz(0)   , cap(0)    { }
+    explicit vec(int size)      : data(NULL) , sz(0)   , cap(0)    { growTo(size); }
+    vec(int size, const T& pad) : data(NULL) , sz(0)   , cap(0)    { growTo(size, pad); }
+   ~vec()                                                          { clear(true); }
+
+    // Pointer to first element:
+    operator T*       (void)           { return data; }
+
+    // Size operations:
+    int      size     (void) const     { return sz; }
+    void     shrink   (int nelems)     { assert(nelems <= sz); for (int i = 0; i < nelems; i++) sz--, data[sz].~T(); }
+    void     shrink_  (int nelems)     { assert(nelems <= sz); sz -= nelems; }
+    int      capacity (void) const     { return cap; }
+    void     capacity (int min_cap);
+    void     growTo   (int size);
+    void     growTo   (int size, const T& pad);
+    void     clear    (bool dealloc = false);
+
+    // Stack interface:
+    void     push  (void)              { if (sz == cap) capacity(sz+1); new (&data[sz]) T(); sz++; }
+    void     push  (const T& elem)     { if (sz == cap) capacity(sz+1); data[sz++] = elem; }
+    void     push_ (const T& elem)     { assert(sz < cap); data[sz++] = elem; }
+    void     pop   (void)              { assert(sz > 0); sz--, data[sz].~T(); }
+    // NOTE: it seems possible that overflow can happen in the 'sz+1' expression of 'push()', but
+    // in fact it can not since it requires that 'cap' is equal to INT_MAX. This in turn can not
+    // happen given the way capacities are calculated (below). Essentially, all capacities are
+    // even, but INT_MAX is odd.
+
+    const T& last  (void) const        { return data[sz-1]; }
+    T&       last  (void)              { return data[sz-1]; }
+
+    // Vector interface:
+    const T& operator [] (int index) const { return data[index]; }
+    T&       operator [] (int index)       { return data[index]; }
+
+    // Duplicatation (preferred instead):
+    void copyTo(vec<T>& copy) const { copy.clear(); copy.growTo(sz); for (int i = 0; i < sz; i++) copy[i] = data[i]; }
+    void moveTo(vec<T>& dest) { dest.clear(true); dest.data = data; dest.sz = sz; dest.cap = cap; data = NULL; sz = 0; cap = 0; }
+};
+
+
+template<class T>
+void vec<T>::capacity(int min_cap) {
+    if (cap >= min_cap) return;
+    int add = imax((min_cap - cap + 1) & ~1, ((cap >> 1) + 2) & ~1);   // NOTE: grow by approximately 3/2
+    if (add > INT_MAX - cap || (((data = (T*)::realloc(data, (cap += add) * sizeof(T))) == NULL) && errno == ENOMEM))
+        throw OutOfMemoryException();
+ }
+
+
+template<class T>
+void vec<T>::growTo(int size, const T& pad) {
+    if (sz >= size) return;
+    capacity(size);
+    for (int i = sz; i < size; i++) data[i] = pad;
+    sz = size; }
+
+
+template<class T>
+void vec<T>::growTo(int size) {
+    if (sz >= size) return;
+    capacity(size);
+    for (int i = sz; i < size; i++) new (&data[i]) T();
+    sz = size; }
+
+
+template<class T>
+void vec<T>::clear(bool dealloc) {
+    if (data != NULL){
+        for (int i = 0; i < sz; i++) data[i].~T();
+        sz = 0;
+        if (dealloc) free(data), data = NULL, cap = 0; } }
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/abcsat/abc/XAlloc.h b/lib/abcsat/abc/XAlloc.h
new file mode 100644
index 0000000..3fa8142
--- /dev/null
+++ b/lib/abcsat/abc/XAlloc.h
@@ -0,0 +1,53 @@
+/****************************************************************************************[XAlloc.h]
+Copyright (c) 2009-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Glucose_XAlloc_h
+#define Glucose_XAlloc_h
+
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "abc_namespaces.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// Simple layer on top of malloc/realloc to catch out-of-memory situtaions and provide some typing:
+
+class OutOfMemoryException{};
+static inline void* xrealloc(void *ptr, size_t size)
+{
+    void* mem = realloc(ptr, size);
+    if (mem == NULL && errno == ENOMEM){
+        throw OutOfMemoryException();
+    }else {
+        return mem;
+    }
+}
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/abcsat/abc/abc_global.h b/lib/abcsat/abc/abc_global.h
new file mode 100644
index 0000000..9ca6d92
--- /dev/null
+++ b/lib/abcsat/abc/abc_global.h
@@ -0,0 +1,422 @@
+/**CFile****************************************************************
+
+  FileName    [abc_global.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Global declarations.]
+
+  Synopsis    [Global declarations.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - Jan 30, 2009.]
+
+  Revision    [$Id: abc_global.h,v 1.00 2009/01/30 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#ifndef ABC__misc__util__abc_global_h
+#define ABC__misc__util__abc_global_h
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include <cstdint>
+#ifdef _MSC_VER
+//#define inline __inline // compatible with MS VS 6.0
+#pragma warning(push)
+#pragma warning(disable : 4152) // warning C4152: nonstandard extension, function/data pointer conversion in expression
+#pragma warning(disable : 4200) // warning C4200: nonstandard extension used : zero-sized array in struct/union
+#pragma warning(disable : 4244) // warning C4244: '+=' : conversion from 'int ' to 'unsigned short ', possible loss of data
+#pragma warning(disable : 4302) // warning C4302: 'type cast': truncation from 'void *' to 'pabc::ABC_PTRINT_T'
+#pragma warning(disable : 4311) // warning C4311: 'type cast': pointer truncation from 'void *' to 'pabc::ABC_PTRINT_T'
+#pragma warning(disable : 4312) // warning C4312: 'type cast': conversion from 'pabc::ABC_PTRINT_T' to 'void *' of greater size
+#pragma warning(disable : 4514) // warning C4514: 'Vec_StrPop' : unreferenced inline function has been removed
+#pragma warning(disable : 4710) // warning C4710: function 'Vec_PtrGrow' not inlined
+//#pragma warning( disable : 4273 )
+#endif
+
+#ifdef WIN32
+  #ifdef WIN32_NO_DLL
+    #define ABC_DLLEXPORT
+    #define ABC_DLLIMPORT
+  #else
+    #define ABC_DLLEXPORT __declspec(dllexport)
+    #define ABC_DLLIMPORT __declspec(dllimport)
+  #endif
+#else  /* defined(WIN32) */
+#define ABC_DLLIMPORT
+#endif /* defined(WIN32) */
+
+#ifndef ABC_DLL
+#define ABC_DLL ABC_DLLIMPORT
+#endif
+
+#if !defined(___unused)
+#if defined(__GNUC__)
+#define ___unused __attribute__ ((__unused__))
+#else
+#define ___unused
+#endif
+#endif
+
+/*
+#ifdef __cplusplus
+#error "C++ code"
+#else
+#error "C code"
+#endif
+*/
+
+#include <time.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+// catch memory leaks in Visual Studio
+#ifdef WIN32
+  #ifdef _DEBUG
+    #define _CRTDBG_MAP_ALLOC
+    #include <crtdbg.h>
+  #endif
+#endif
+
+#ifdef _WIN32
+#include <Windows.h>
+#endif
+
+#include "abc_namespaces.h"
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+ABC_NAMESPACE_HEADER_START
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+/**
+ * Pointer difference type; replacement for ptrdiff_t.
+ * This is a signed integral type that is the same size as a pointer.
+ * NOTE: This type may be different sizes on different platforms.
+ */
+#if       defined(__ccdoc__)
+typedef platform_dependent_type ABC_PTRDIFF_T;
+#elif     defined(LIN64)
+typedef long ABC_PTRDIFF_T;
+#elif     defined(NT64)
+typedef long long ABC_PTRDIFF_T;
+#elif     defined(NT) || defined(LIN) || defined(WIN32)
+typedef int ABC_PTRDIFF_T;
+#else
+   #error unknown platform
+#endif /* defined(PLATFORM) */
+
+/**
+ * Unsigned integral type that can contain a pointer.
+ * This is an unsigned integral type that is the same size as a pointer.
+ * NOTE: This type may be different sizes on different platforms.
+ */
+#if       defined(__ccdoc__)
+typedef platform_dependent_type ABC_PTRUINT_T;
+#elif     defined(LIN64)
+typedef unsigned long ABC_PTRUINT_T;
+#elif     defined(NT64)
+typedef unsigned long long ABC_PTRUINT_T;
+#elif     defined(NT) || defined(LIN) || defined(WIN32)
+typedef unsigned int ABC_PTRUINT_T;
+#else
+   #error unknown platform
+#endif /* defined(PLATFORM) */
+
+/**
+ * Signed integral type that can contain a pointer.
+ * This is a signed integral type that is the same size as a pointer.
+ * NOTE: This type may be different sizes on different platforms.
+ */
+#if       defined(__ccdoc__)
+typedef platform_dependent_type ABC_PTRINT_T;
+#elif     defined(LIN64)
+typedef long ABC_PTRINT_T;
+#elif     defined(NT64)
+typedef long long ABC_PTRINT_T;
+#elif     defined(NT) || defined(LIN) || defined(WIN32)
+typedef int ABC_PTRINT_T;
+#else
+   #error unknown platform
+#endif /* defined(PLATFORM) */
+
+/**
+ * 64-bit signed integral type.
+ */
+#if       defined(__ccdoc__)
+typedef platform_dependent_type ABC_INT64_T;
+#elif     defined(LIN64)
+typedef long ABC_INT64_T;
+#elif     defined(NT64) || defined(LIN)
+typedef long long ABC_INT64_T;
+#elif     defined(WIN32) || defined(NT)
+typedef signed __int64 ABC_INT64_T;
+#else
+   #error unknown platform
+#endif /* defined(PLATFORM) */
+
+/**
+ * 64-bit unsigned integral type.
+ */
+typedef uint64_t ABC_UINT64_T;
+
+#ifdef LIN
+  #define ABC_CONST(number) number ## ULL 
+#else // LIN64 and windows
+  #define ABC_CONST(number) number
+#endif
+
+typedef ABC_UINT64_T word;
+typedef ABC_INT64_T iword;
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+#define ABC_INFINITY    (1000000000)
+
+#define ABC_SWAP(Type, a, b)  { Type t = a; a = b; b = t; }
+
+#define ABC_PRT(a,t)    (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec\n", 1.0*(t)/(CLOCKS_PER_SEC)))
+#define ABC_PRTr(a,t)   (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec\r", 1.0*(t)/(CLOCKS_PER_SEC)))
+#define ABC_PRTn(a,t)   (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec  ", 1.0*(t)/(CLOCKS_PER_SEC)))
+#define ABC_PRTP(a,t,T) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec (%6.2f %%)\n", 1.0*(t)/(CLOCKS_PER_SEC), (T)? 100.0*(t)/(T) : 0.0))
+#define ABC_PRM(a,f)    (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB\n",    1.0*(f)/(1<<20)))
+#define ABC_PRMr(a,f)   (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB\r",    1.0*(f)/(1<<20)))
+#define ABC_PRMn(a,f)   (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB  ",    1.0*(f)/(1<<20)))
+#define ABC_PRMP(a,f,F) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB (%6.2f %%)\n",  (1.0*(f)/(1<<20)), ((F)? 100.0*(f)/(F) : 0.0) ) )
+
+#define ABC_ALLOC(type, num)     ((type *) malloc(sizeof(type) * (num)))
+#define ABC_CALLOC(type, num)    ((type *) calloc((num), sizeof(type)))
+#define ABC_FALLOC(type, num)    ((type *) memset(malloc(sizeof(type) * (num)), 0xff, sizeof(type) * (num)))
+#define ABC_FREE(obj)            ((obj) ? (free((char *) (obj)), (obj) = 0) : 0)
+#define ABC_REALLOC(type, obj, num) \
+        ((obj) ? ((type *) realloc((char *)(obj), sizeof(type) * (num))) : \
+         ((type *) malloc(sizeof(type) * (num))))
+
+static inline int      Abc_AbsInt( int a        )             { return a < 0 ? -a : a; }
+static inline int      Abc_MaxInt( int a, int b )             { return a > b ?  a : b; }
+static inline int      Abc_MinInt( int a, int b )             { return a < b ?  a : b; }
+static inline word     Abc_MaxWord( word a, word b )          { return a > b ?  a : b; }
+static inline word     Abc_MinWord( word a, word b )          { return a < b ?  a : b; }
+static inline float    Abc_AbsFloat( float a          )       { return a < 0 ? -a : a; }
+static inline float    Abc_MaxFloat( float a, float b )       { return a > b ?  a : b; }
+static inline float    Abc_MinFloat( float a, float b )       { return a < b ?  a : b; }
+static inline double   Abc_AbsDouble( double a           )    { return a < 0 ? -a : a; }
+static inline double   Abc_MaxDouble( double a, double b )    { return a > b ?  a : b; }
+static inline double   Abc_MinDouble( double a, double b )    { return a < b ?  a : b; }
+
+static inline int      Abc_Float2Int( float Val )             { union { int x; float y; } v; v.y = Val; return v.x;         }
+static inline float    Abc_Int2Float( int Num )               { union { int x; float y; } v; v.x = Num; return v.y;         }
+static inline word     Abc_Dbl2Word( double Dbl )             { union { word x; double y; } v; v.y = Dbl; return v.x;       }
+static inline double   Abc_Word2Dbl( word Num )               { union { word x; double y; } v; v.x = Num; return v.y;       }
+static inline int      Abc_Base2Log( unsigned n )             { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n >>= 1, r++ ) {}; return r; }
+static inline int      Abc_Base10Log( unsigned n )            { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n /= 10, r++ ) {}; return r; }
+static inline int      Abc_Base16Log( unsigned n )            { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n /= 16, r++ ) {}; return r; }
+static inline char *   Abc_UtilStrsav( char * s )             { return s ? strcpy(ABC_ALLOC(char, strlen(s)+1), s) : NULL;  }
+static inline int      Abc_BitWordNum( int nBits )            { return (nBits>>5) + ((nBits&31) > 0);                       }
+static inline int      Abc_Bit6WordNum( int nBits )           { return (nBits>>6) + ((nBits&63) > 0);                       }
+static inline int      Abc_TruthWordNum( int nVars )          { return nVars <= 5 ? 1 : (1 << (nVars - 5));                 }
+static inline int      Abc_Truth6WordNum( int nVars )         { return nVars <= 6 ? 1 : (1 << (nVars - 6));                 }
+static inline int      Abc_InfoHasBit( unsigned * p, int i )  { return (p[(i)>>5] & (1<<((i) & 31))) > 0;                   }
+static inline void     Abc_InfoSetBit( unsigned * p, int i )  { p[(i)>>5] |= (1<<((i) & 31));                               }
+static inline void     Abc_InfoXorBit( unsigned * p, int i )  { p[(i)>>5] ^= (1<<((i) & 31));                               }
+static inline unsigned Abc_InfoMask( int nVar )               { return (~(unsigned)0) >> (32-nVar);                         }
+
+static inline int      Abc_Var2Lit( int Var, int c )          { assert(Var >= 0 && !(c >> 1)); return Var + Var + c;        }
+static inline int      Abc_Lit2Var( int Lit )                 { assert(Lit >= 0); return Lit >> 1;                          }
+static inline int      Abc_LitIsCompl( int Lit )              { assert(Lit >= 0); return Lit & 1;                           }
+static inline int      Abc_LitNot( int Lit )                  { assert(Lit >= 0); return Lit ^ 1;                           }
+static inline int      Abc_LitNotCond( int Lit, int c )       { assert(Lit >= 0); return Lit ^ (int)(c > 0);                }
+static inline int      Abc_LitRegular( int Lit )              { assert(Lit >= 0); return Lit & ~01;                         }
+static inline int      Abc_Lit2LitV( int * pMap, int Lit )    { assert(Lit >= 0); return Abc_Var2Lit( pMap[Abc_Lit2Var(Lit)], Abc_LitIsCompl(Lit) );      }
+static inline int      Abc_Lit2LitL( int * pMap, int Lit )    { assert(Lit >= 0); return Abc_LitNotCond( pMap[Abc_Lit2Var(Lit)], Abc_LitIsCompl(Lit) );   }
+
+static inline int      Abc_Ptr2Int( void * p )                { return (int)(ABC_PTRINT_T)p;      }
+static inline void *   Abc_Int2Ptr( int i )                   { return (void *)(ABC_PTRINT_T)i;   }
+static inline word     Abc_Ptr2Wrd( void * p )                { return (word)(ABC_PTRUINT_T)p;    }
+static inline void *   Abc_Wrd2Ptr( word i )                  { return (void *)(ABC_PTRUINT_T)i;  }
+
+static inline int      Abc_Var2Lit2( int Var, int Att )       { assert(!(Att >> 2)); return (Var << 2) + Att; }
+static inline int      Abc_Lit2Var2( int Lit )                { assert(Lit >= 0);    return Lit >> 2;         }
+static inline int      Abc_Lit2Att2( int Lit )                { assert(Lit >= 0);    return Lit & 3;          }
+static inline int      Abc_Var2Lit3( int Var, int Att )       { assert(!(Att >> 3)); return (Var << 3) + Att; }
+static inline int      Abc_Lit2Var3( int Lit )                { assert(Lit >= 0);    return Lit >> 3;         }
+static inline int      Abc_Lit2Att3( int Lit )                { assert(Lit >= 0);    return Lit & 7;          }
+static inline int      Abc_Var2Lit4( int Var, int Att )       { assert(!(Att >> 4)); return (Var << 4) + Att; }
+static inline int      Abc_Lit2Var4( int Lit )                { assert(Lit >= 0);    return Lit >> 4;         }
+static inline int      Abc_Lit2Att4( int Lit )                { assert(Lit >= 0);    return Lit & 15;         }
+
+// time counting
+typedef ABC_INT64_T abctime;
+static inline abctime Abc_Clock()
+{
+#if (defined(LIN) || defined(LIN64)) && !(__APPLE__ & __MACH__) && !defined(__MINGW32__)
+    struct timespec ts;
+#ifdef _WIN32
+    if ( clock_gettime(0, &ts) < 0 ) 
+        return (abctime)-1;
+#else
+    if ( clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) < 0 ) 
+        return (abctime)-1;
+#endif
+    abctime res = ((abctime) ts.tv_sec) * CLOCKS_PER_SEC;
+    res += (((abctime) ts.tv_nsec) * CLOCKS_PER_SEC) / 1000000000;
+    return res;
+#else
+    return (abctime) clock();
+#endif
+}
+
+// bridge communication
+#define BRIDGE_NETLIST           106
+#define BRIDGE_ABS_NETLIST       107
+extern int Gia_ManToBridgeText( FILE * pFile, int Size, unsigned char * pBuffer );
+extern int Gia_ManToBridgeAbsNetlist( FILE * pFile, void * p, int pkg_type );
+
+// string printing
+extern char * vnsprintf(const char* format, va_list args);
+extern char * nsprintf(const char* format, ...);
+
+
+// misc printing procedures
+enum Abc_VerbLevel
+{
+    ABC_PROMPT   = -2,
+    ABC_ERROR    = -1,
+    ABC_WARNING  =  0,
+    ABC_STANDARD =  1,
+    ABC_VERBOSE  =  2
+};
+static inline void Abc_Print( int level, const char * format, ... )
+{
+    extern ABC_DLL int Abc_FrameIsBridgeMode();
+    va_list args;
+
+    if ( ! Abc_FrameIsBridgeMode() ){
+        if ( level == ABC_ERROR )
+            printf( "Error: " );
+        else if ( level == ABC_WARNING )
+            printf( "Warning: " );
+    }else{
+        if ( level == ABC_ERROR )
+            Gia_ManToBridgeText( stdout, (int)strlen("Error: "), (unsigned char*)"Error: " );
+        else if ( level == ABC_WARNING )
+            Gia_ManToBridgeText( stdout, (int)strlen("Warning: "), (unsigned char*)"Warning: " );
+    }
+
+    va_start( args, format );
+    if ( Abc_FrameIsBridgeMode() )
+    {
+        char * tmp = vnsprintf( format, args );
+        Gia_ManToBridgeText( stdout, (int)strlen(tmp), (unsigned char*)tmp );
+        free( tmp );
+    }
+    else
+        vprintf( format, args );
+    va_end( args );
+}
+
+static inline void Abc_PrintInt( int i )
+{
+    double v3 = (double)i/1000;
+    double v6 = (double)i/1000000;
+
+    Abc_Print( 1,  "  " );
+
+    if ( i > -1000 && i < 1000 )
+        Abc_Print( 1, " %4d", i );
+
+    else if ( v3 > -9.995 && v3 < 9.995 )
+        Abc_Print( 1, "%4.2fk", v3 );
+    else if ( v3 > -99.95 && v3 < 99.95 )
+        Abc_Print( 1, "%4.1fk", v3 );
+    else if ( v3 > -999.5 && v3 < 999.5 )
+        Abc_Print( 1, "%4.0fk", v3 );
+
+    else if ( v6 > -9.995 && v6 < 9.995 )
+        Abc_Print( 1, "%4.2fm", v6 );
+    else if ( v6 > -99.95 && v6 < 99.95 )
+        Abc_Print( 1, "%4.1fm", v6 );
+    else if ( v6 > -999.5 && v6 < 999.5 )
+        Abc_Print( 1, "%4.0fm", v6 );
+}
+
+static inline void Abc_PrintTime( int level, const char * pStr, abctime time )
+{
+    ABC_PRT( pStr, time );
+}
+
+static inline void Abc_PrintTimeP( int level, const char * pStr, abctime time, abctime Time )
+{
+    ABC_PRTP( pStr, time, Time );
+}
+
+static inline void Abc_PrintMemoryP( int level, const char * pStr, int mem, int Mem )
+{
+    ABC_PRMP( pStr, mem, Mem );
+}
+
+// Returns the next prime >= p
+static inline int Abc_PrimeCudd( unsigned int p )
+{
+    int i,pn;
+    p--;
+    do {
+        p++;
+        if (p&1)
+        {
+            pn = 1;
+            i = 3;
+            while ((unsigned) (i * i) <= p)
+            {
+                if (p % i == 0) {
+                    pn = 0;
+                    break;
+                }
+                i += 2;
+            }
+        }
+        else
+            pn = 0;
+    } while (!pn);
+    return(p);
+
+} // end of Cudd_Prime 
+
+
+// sorting
+extern void   Abc_MergeSort( int * pInput, int nSize );
+extern int *  Abc_MergeSortCost( int * pCosts, int nSize );
+extern void   Abc_QuickSort1( word * pData, int nSize, int fDecrease );
+extern void   Abc_QuickSort2( word * pData, int nSize, int fDecrease );
+extern void   Abc_QuickSort3( word * pData, int nSize, int fDecrease );
+extern void   Abc_QuickSortCostData( int * pCosts, int nSize, int fDecrease, word * pData, int * pResult );
+extern int *  Abc_QuickSortCost( int * pCosts, int nSize, int fDecrease );
+
+
+ABC_NAMESPACE_HEADER_END
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
diff --git a/lib/abcsat/abc/abc_namespaces.h b/lib/abcsat/abc/abc_namespaces.h
new file mode 100644
index 0000000..8cd681c
--- /dev/null
+++ b/lib/abcsat/abc/abc_namespaces.h
@@ -0,0 +1,74 @@
+/**CFile****************************************************************
+
+  FileName    [abc_namespaces.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Namespace logic.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - Nov 20, 2015.]
+
+  Revision    []
+
+***********************************************************************/
+
+#ifndef ABC__misc__util__abc_namespaces_h
+#define ABC__misc__util__abc_namespaces_h
+
+
+////////////////////////////////////////////////////////////////////////
+///                         NAMESPACES                               ///
+////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+#  ifdef ABC_NAMESPACE
+#    define ABC_NAMESPACE_HEADER_START namespace ABC_NAMESPACE {
+#    define ABC_NAMESPACE_HEADER_END }
+#    define ABC_NAMESPACE_CXX_HEADER_START ABC_NAMESPACE_HEADER_START
+#    define ABC_NAMESPACE_CXX_HEADER_END ABC_NAMESPACE_HEADER_END
+#    define ABC_NAMESPACE_IMPL_START namespace ABC_NAMESPACE {
+#    define ABC_NAMESPACE_IMPL_END }
+#    define ABC_NAMESPACE_PREFIX ABC_NAMESPACE::
+#    define ABC_NAMESPACE_USING_NAMESPACE using namespace ABC_NAMESPACE;
+#  else
+#    define ABC_NAMESPACE_HEADER_START extern "C" {
+#    define ABC_NAMESPACE_HEADER_END }
+#    define ABC_NAMESPACE_CXX_HEADER_START
+#    define ABC_NAMESPACE_CXX_HEADER_END
+#    define ABC_NAMESPACE_IMPL_START
+#    define ABC_NAMESPACE_IMPL_END
+#    define ABC_NAMESPACE_PREFIX
+#    define ABC_NAMESPACE_USING_NAMESPACE
+#  endif // #ifdef ABC_NAMESPACE
+#ifdef SATOKO_NAMESPACE
+    #define SATOKO_NAMESPACE_HEADER_START namespace SATOKO_NAMESPACE {
+    #define SATOKO_NAMESPACE_HEADER_END }
+    #define SATOKO_NAMESPACE_CXX_HEADER_START ABC_NAMESPACE_HEADER_START
+    #define SATOKO_NAMESPACE_CXX_HEADER_END ABC_NAMESPACE_HEADER_END
+    #define SATOKO_NAMESPACE_IMPL_START namespace SATOKO_NAMESPACE {
+    #define SATOKO_NAMESPACE_IMPL_END }
+    #define SATOKO_NAMESPACE_PREFIX SATOKO_NAMESPACE::
+    #define SATOKO_NAMESPACE_USING_NAMESPACE using namespace SATOKO_NAMESPACE;
+#endif
+#else
+#  define ABC_NAMESPACE_HEADER_START
+#  define ABC_NAMESPACE_HEADER_END
+#  define ABC_NAMESPACE_CXX_HEADER_START
+#  define ABC_NAMESPACE_CXX_HEADER_END
+#  define ABC_NAMESPACE_IMPL_START
+#  define ABC_NAMESPACE_IMPL_END
+#  define ABC_NAMESPACE_PREFIX
+#  define ABC_NAMESPACE_USING_NAMESPACE
+#endif // #ifdef __cplusplus
+
+#endif // #ifndef ABC__misc__util__abc_namespaces_h
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
diff --git a/lib/abcsat/abc/pstdint.h b/lib/abcsat/abc/pstdint.h
new file mode 100644
index 0000000..989d016
--- /dev/null
+++ b/lib/abcsat/abc/pstdint.h
@@ -0,0 +1,919 @@
+/*  A portable stdint.h
+ ****************************************************************************
+ *  BSD License:
+ ****************************************************************************
+ *
+ *  Copyright (c) 2005-2016 Paul Hsieh
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, 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 name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS 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 AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 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.
+ *
+ ****************************************************************************
+ *
+ *  Version 0.1.16.0
+ *
+ *  The ANSI C standard committee, for the C99 standard, specified the
+ *  inclusion of a new standard include file called stdint.h.  This is
+ *  a very useful and long desired include file which contains several
+ *  very precise definitions for integer scalar types that is critically
+ *  important for making several classes of applications portable
+ *  including cryptography, hashing, variable length integer libraries
+ *  and so on.  But for most developers its likely useful just for
+ *  programming sanity.
+ *
+ *  The problem is that some compiler vendors chose to ignore the C99
+ *  standard and some older compilers have no opportunity to be updated.
+ *  Because of this situation, simply including stdint.h in your code
+ *  makes it unportable.
+ *
+ *  So that's what this file is all about.  It's an attempt to build a
+ *  single universal include file that works on as many platforms as
+ *  possible to deliver what stdint.h is supposed to.  Even compilers
+ *  that already come with stdint.h can use this file instead without
+ *  any loss of functionality.  A few things that should be noted about
+ *  this file:
+ *
+ *    1) It is not guaranteed to be portable and/or present an identical
+ *       interface on all platforms.  The extreme variability of the
+ *       ANSI C standard makes this an impossibility right from the
+ *       very get go. Its really only meant to be useful for the vast
+ *       majority of platforms that possess the capability of
+ *       implementing usefully and precisely defined, standard sized
+ *       integer scalars.  Systems which are not intrinsically 2s
+ *       complement may produce invalid constants.
+ *
+ *    2) There is an unavoidable use of non-reserved symbols.
+ *
+ *    3) Other standard include files are invoked.
+ *
+ *    4) This file may come in conflict with future platforms that do
+ *       include stdint.h.  The hope is that one or the other can be
+ *       used with no real difference.
+ *
+ *    5) In the current version, if your platform can't represent
+ *       int32_t, int16_t and int8_t, it just dumps out with a compiler
+ *       error.
+ *
+ *    6) 64 bit integers may or may not be defined.  Test for their
+ *       presence with the test: #ifdef INT64_MAX or #ifdef UINT64_MAX.
+ *       Note that this is different from the C99 specification which
+ *       requires the existence of 64 bit support in the compiler.  If
+ *       this is not defined for your platform, yet it is capable of
+ *       dealing with 64 bits then it is because this file has not yet
+ *       been extended to cover all of your system's capabilities.
+ *
+ *    7) (u)intptr_t may or may not be defined.  Test for its presence
+ *       with the test: #ifdef PTRDIFF_MAX.  If this is not defined
+ *       for your platform, then it is because this file has not yet
+ *       been extended to cover all of your system's capabilities, not
+ *       because its optional.
+ *
+ *    8) The following might not been defined even if your platform is
+ *       capable of defining it:
+ *
+ *       WCHAR_MIN
+ *       WCHAR_MAX
+ *       (u)int64_t
+ *       PTRDIFF_MIN
+ *       PTRDIFF_MAX
+ *       (u)intptr_t
+ *
+ *    9) The following have not been defined:
+ *
+ *       WINT_MIN
+ *       WINT_MAX
+ *
+ *   10) The criteria for defining (u)int_least(*)_t isn't clear,
+ *       except for systems which don't have a type that precisely
+ *       defined 8, 16, or 32 bit types (which this include file does
+ *       not support anyways). Default definitions have been given.
+ *
+ *   11) The criteria for defining (u)int_fast(*)_t isn't something I
+ *       would trust to any particular compiler vendor or the ANSI C
+ *       committee.  It is well known that "compatible systems" are
+ *       commonly created that have very different performance
+ *       characteristics from the systems they are compatible with,
+ *       especially those whose vendors make both the compiler and the
+ *       system.  Default definitions have been given, but its strongly
+ *       recommended that users never use these definitions for any
+ *       reason (they do *NOT* deliver any serious guarantee of
+ *       improved performance -- not in this file, nor any vendor's
+ *       stdint.h).
+ *
+ *   12) The following macros:
+ *
+ *       PRINTF_INTMAX_MODIFIER
+ *       PRINTF_INT64_MODIFIER
+ *       PRINTF_INT32_MODIFIER
+ *       PRINTF_INT16_MODIFIER
+ *       PRINTF_LEAST64_MODIFIER
+ *       PRINTF_LEAST32_MODIFIER
+ *       PRINTF_LEAST16_MODIFIER
+ *       PRINTF_INTPTR_MODIFIER
+ *
+ *       are strings which have been defined as the modifiers required
+ *       for the "d", "u" and "x" printf formats to correctly output
+ *       (u)intmax_t, (u)int64_t, (u)int32_t, (u)int16_t, (u)least64_t,
+ *       (u)least32_t, (u)least16_t and (u)intptr_t types respectively.
+ *       PRINTF_INTPTR_MODIFIER is not defined for some systems which
+ *       provide their own stdint.h.  PRINTF_INT64_MODIFIER is not
+ *       defined if INT64_MAX is not defined.  These are an extension
+ *       beyond what C99 specifies must be in stdint.h.
+ *
+ *       In addition, the following macros are defined:
+ *
+ *       PRINTF_INTMAX_HEX_WIDTH
+ *       PRINTF_INT64_HEX_WIDTH
+ *       PRINTF_INT32_HEX_WIDTH
+ *       PRINTF_INT16_HEX_WIDTH
+ *       PRINTF_INT8_HEX_WIDTH
+ *       PRINTF_INTMAX_DEC_WIDTH
+ *       PRINTF_INT64_DEC_WIDTH
+ *       PRINTF_INT32_DEC_WIDTH
+ *       PRINTF_INT16_DEC_WIDTH
+ *       PRINTF_UINT8_DEC_WIDTH
+ *       PRINTF_UINTMAX_DEC_WIDTH
+ *       PRINTF_UINT64_DEC_WIDTH
+ *       PRINTF_UINT32_DEC_WIDTH
+ *       PRINTF_UINT16_DEC_WIDTH
+ *       PRINTF_UINT8_DEC_WIDTH
+ *
+ *       Which specifies the maximum number of characters required to
+ *       print the number of that type in either hexadecimal or decimal.
+ *       These are an extension beyond what C99 specifies must be in
+ *       stdint.h.
+ *
+ *  Compilers tested (all with 0 warnings at their highest respective
+ *  settings): Borland Turbo C 2.0, WATCOM C/C++ 11.0 (16 bits and 32
+ *  bits), Microsoft Visual C++ 6.0 (32 bit), Microsoft Visual Studio
+ *  .net (VC7), Intel C++ 4.0, GNU gcc v3.3.3
+ *
+ *  This file should be considered a work in progress.  Suggestions for
+ *  improvements, especially those which increase coverage are strongly
+ *  encouraged.
+ *
+ *  Acknowledgements
+ *
+ *  The following people have made significant contributions to the
+ *  development and testing of this file:
+ *
+ *  Chris Howie
+ *  John Steele Scott
+ *  Dave Thorup
+ *  John Dill
+ *  Florian Wobbe
+ *  Christopher Sean Morrison
+ *  Mikkel Fahnoe Jorgensen
+ *
+ */
+
+#include <stddef.h>
+#include <limits.h>
+#include <signal.h>
+
+/*
+ *  For gcc with _STDINT_H, fill in the PRINTF_INT*_MODIFIER macros, and
+ *  do nothing else.  On the Mac OS X version of gcc this is _STDINT_H_.
+ */
+
+#if ((defined(__SUNPRO_C) && __SUNPRO_C >= 0x570) || (defined(_MSC_VER) && _MSC_VER >= 1600) || (defined(__STDC__) && __STDC__ && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || (defined (__WATCOMC__) && (defined (_STDINT_H_INCLUDED) || __WATCOMC__ >= 1250)) || (defined(__GNUC__) && (__GNUC__ > 3 || defined(_STDINT_H) || defined(_STDINT_H_) || defined (__UINT_FAST64_TYPE__)) )) && !defined (_PSTDINT_H_INCLUDED)
+#include <stdint.h>
+#define _PSTDINT_H_INCLUDED
+# if defined(__GNUC__) && (defined(__x86_64__) || defined(__ppc64__)) && !(defined(__APPLE__) && defined(__MACH__))
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "l"
+#  endif
+#  ifndef PRINTF_INT32_MODIFIER
+#   define PRINTF_INT32_MODIFIER ""
+#  endif
+# else
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "ll"
+#  endif
+#  ifndef PRINTF_INT32_MODIFIER
+#   if (UINT_MAX == UINT32_MAX)
+#    define PRINTF_INT32_MODIFIER ""
+#   else
+#    define PRINTF_INT32_MODIFIER "l"
+#   endif
+#  endif
+# endif
+# ifndef PRINTF_INT16_MODIFIER
+#  define PRINTF_INT16_MODIFIER "h"
+# endif
+# ifndef PRINTF_INTMAX_MODIFIER
+#  define PRINTF_INTMAX_MODIFIER PRINTF_INT64_MODIFIER
+# endif
+# ifndef PRINTF_INT64_HEX_WIDTH
+#  define PRINTF_INT64_HEX_WIDTH "16"
+# endif
+# ifndef PRINTF_UINT64_HEX_WIDTH
+#  define PRINTF_UINT64_HEX_WIDTH "16"
+# endif
+# ifndef PRINTF_INT32_HEX_WIDTH
+#  define PRINTF_INT32_HEX_WIDTH "8"
+# endif
+# ifndef PRINTF_UINT32_HEX_WIDTH
+#  define PRINTF_UINT32_HEX_WIDTH "8"
+# endif
+# ifndef PRINTF_INT16_HEX_WIDTH
+#  define PRINTF_INT16_HEX_WIDTH "4"
+# endif
+# ifndef PRINTF_UINT16_HEX_WIDTH
+#  define PRINTF_UINT16_HEX_WIDTH "4"
+# endif
+# ifndef PRINTF_INT8_HEX_WIDTH
+#  define PRINTF_INT8_HEX_WIDTH "2"
+# endif
+# ifndef PRINTF_UINT8_HEX_WIDTH
+#  define PRINTF_UINT8_HEX_WIDTH "2"
+# endif
+# ifndef PRINTF_INT64_DEC_WIDTH
+#  define PRINTF_INT64_DEC_WIDTH "19"
+# endif
+# ifndef PRINTF_UINT64_DEC_WIDTH
+#  define PRINTF_UINT64_DEC_WIDTH "20"
+# endif
+# ifndef PRINTF_INT32_DEC_WIDTH
+#  define PRINTF_INT32_DEC_WIDTH "10"
+# endif
+# ifndef PRINTF_UINT32_DEC_WIDTH
+#  define PRINTF_UINT32_DEC_WIDTH "10"
+# endif
+# ifndef PRINTF_INT16_DEC_WIDTH
+#  define PRINTF_INT16_DEC_WIDTH "5"
+# endif
+# ifndef PRINTF_UINT16_DEC_WIDTH
+#  define PRINTF_UINT16_DEC_WIDTH "5"
+# endif
+# ifndef PRINTF_INT8_DEC_WIDTH
+#  define PRINTF_INT8_DEC_WIDTH "3"
+# endif
+# ifndef PRINTF_UINT8_DEC_WIDTH
+#  define PRINTF_UINT8_DEC_WIDTH "3"
+# endif
+# ifndef PRINTF_INTMAX_HEX_WIDTH
+#  define PRINTF_INTMAX_HEX_WIDTH PRINTF_UINT64_HEX_WIDTH
+# endif
+# ifndef PRINTF_UINTMAX_HEX_WIDTH
+#  define PRINTF_UINTMAX_HEX_WIDTH PRINTF_UINT64_HEX_WIDTH
+# endif
+# ifndef PRINTF_INTMAX_DEC_WIDTH
+#  define PRINTF_INTMAX_DEC_WIDTH PRINTF_UINT64_DEC_WIDTH
+# endif
+# ifndef PRINTF_UINTMAX_DEC_WIDTH
+#  define PRINTF_UINTMAX_DEC_WIDTH PRINTF_UINT64_DEC_WIDTH
+# endif
+
+/*
+ *  Something really weird is going on with Open Watcom.  Just pull some of
+ *  these duplicated definitions from Open Watcom's stdint.h file for now.
+ */
+
+# if defined (__WATCOMC__) && __WATCOMC__ >= 1250
+#  if !defined (INT64_C)
+#   define INT64_C(x)   (x + (INT64_MAX - INT64_MAX))
+#  endif
+#  if !defined (UINT64_C)
+#   define UINT64_C(x)  (x + (UINT64_MAX - UINT64_MAX))
+#  endif
+#  if !defined (INT32_C)
+#   define INT32_C(x)   (x + (INT32_MAX - INT32_MAX))
+#  endif
+#  if !defined (UINT32_C)
+#   define UINT32_C(x)  (x + (UINT32_MAX - UINT32_MAX))
+#  endif
+#  if !defined (INT16_C)
+#   define INT16_C(x)   (x)
+#  endif
+#  if !defined (UINT16_C)
+#   define UINT16_C(x)  (x)
+#  endif
+#  if !defined (INT8_C)
+#   define INT8_C(x)   (x)
+#  endif
+#  if !defined (UINT8_C)
+#   define UINT8_C(x)  (x)
+#  endif
+#  if !defined (UINT64_MAX)
+#   define UINT64_MAX  18446744073709551615ULL
+#  endif
+#  if !defined (INT64_MAX)
+#   define INT64_MAX  9223372036854775807LL
+#  endif
+#  if !defined (UINT32_MAX)
+#   define UINT32_MAX  4294967295UL
+#  endif
+#  if !defined (INT32_MAX)
+#   define INT32_MAX  2147483647L
+#  endif
+#  if !defined (INTMAX_MAX)
+#   define INTMAX_MAX INT64_MAX
+#  endif
+#  if !defined (INTMAX_MIN)
+#   define INTMAX_MIN INT64_MIN
+#  endif
+# endif
+#endif
+
+/*
+ *  I have no idea what is the truly correct thing to do on older Solaris.
+ *  From some online discussions, this seems to be what is being
+ *  recommended.  For people who actually are developing on older Solaris,
+ *  what I would like to know is, does this define all of the relevant
+ *  macros of a complete stdint.h?  Remember, in pstdint.h 64 bit is
+ *  considered optional.
+ */
+
+#if (defined(__SUNPRO_C) && __SUNPRO_C >= 0x420) && !defined(_PSTDINT_H_INCLUDED)
+#include <sys/inttypes.h>
+#define _PSTDINT_H_INCLUDED
+#endif
+
+#ifndef _PSTDINT_H_INCLUDED
+#define _PSTDINT_H_INCLUDED
+
+#ifndef SIZE_MAX
+# define SIZE_MAX ((size_t)-1)
+#endif
+
+/*
+ *  Deduce the type assignments from limits.h under the assumption that
+ *  integer sizes in bits are powers of 2, and follow the ANSI
+ *  definitions.
+ */
+
+#ifndef UINT8_MAX
+# define UINT8_MAX 0xff
+#endif
+#if !defined(uint8_t) && !defined(_UINT8_T) && !defined(vxWorks)
+# if (UCHAR_MAX == UINT8_MAX) || defined (S_SPLINT_S)
+    typedef unsigned char uint8_t;
+#   define UINT8_C(v) ((uint8_t) v)
+# else
+#   error "Platform not supported"
+# endif
+#endif
+
+#ifndef INT8_MAX
+# define INT8_MAX 0x7f
+#endif
+#ifndef INT8_MIN
+# define INT8_MIN INT8_C(0x80)
+#endif
+#if !defined(int8_t) && !defined(_INT8_T) && !defined(vxWorks)
+# if (SCHAR_MAX == INT8_MAX) || defined (S_SPLINT_S)
+    typedef signed char int8_t;
+#   define INT8_C(v) ((int8_t) v)
+# else
+#   error "Platform not supported"
+# endif
+#endif
+
+#ifndef UINT16_MAX
+# define UINT16_MAX 0xffff
+#endif
+#if !defined(uint16_t) && !defined(_UINT16_T) && !defined(vxWorks)
+#if (UINT_MAX == UINT16_MAX) || defined (S_SPLINT_S)
+  typedef unsigned int uint16_t;
+# ifndef PRINTF_INT16_MODIFIER
+#  define PRINTF_INT16_MODIFIER ""
+# endif
+# define UINT16_C(v) ((uint16_t) (v))
+#elif (USHRT_MAX == UINT16_MAX)
+  typedef unsigned short uint16_t;
+# define UINT16_C(v) ((uint16_t) (v))
+# ifndef PRINTF_INT16_MODIFIER
+#  define PRINTF_INT16_MODIFIER "h"
+# endif
+#else
+#error "Platform not supported"
+#endif
+#endif
+
+#ifndef INT16_MAX
+# define INT16_MAX 0x7fff
+#endif
+#ifndef INT16_MIN
+# define INT16_MIN INT16_C(0x8000)
+#endif
+#if !defined(int16_t) && !defined(_INT16_T) && !defined(vxWorks)
+#if (INT_MAX == INT16_MAX) || defined (S_SPLINT_S)
+  typedef signed int int16_t;
+# define INT16_C(v) ((int16_t) (v))
+# ifndef PRINTF_INT16_MODIFIER
+#  define PRINTF_INT16_MODIFIER ""
+# endif
+#elif (SHRT_MAX == INT16_MAX)
+  typedef signed short int16_t;
+# define INT16_C(v) ((int16_t) (v))
+# ifndef PRINTF_INT16_MODIFIER
+#  define PRINTF_INT16_MODIFIER "h"
+# endif
+#else
+#error "Platform not supported"
+#endif
+#endif
+
+#ifndef UINT32_MAX
+# define UINT32_MAX (0xffffffffUL)
+#endif
+#if !defined(uint32_t) && !defined(_UINT32_T) && !defined(vxWorks)
+#if (ULONG_MAX == UINT32_MAX) || defined (S_SPLINT_S)
+  typedef unsigned long uint32_t;
+# define UINT32_C(v) v ## UL
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER "l"
+# endif
+#elif (UINT_MAX == UINT32_MAX)
+  typedef unsigned int uint32_t;
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER ""
+# endif
+# define UINT32_C(v) v ## U
+#elif (USHRT_MAX == UINT32_MAX)
+  typedef unsigned short uint32_t;
+# define UINT32_C(v) ((unsigned short) (v))
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER ""
+# endif
+#else
+#error "Platform not supported"
+#endif
+#endif
+
+#ifndef INT32_MAX
+# define INT32_MAX (0x7fffffffL)
+#endif
+#ifndef INT32_MIN
+# define INT32_MIN INT32_C(0x80000000)
+#endif
+#if !defined(int32_t) && !defined(_INT32_T) && !defined(vxWorks)
+#if (LONG_MAX == INT32_MAX) || defined (S_SPLINT_S)
+  typedef signed long int32_t;
+# define INT32_C(v) v ## L
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER "l"
+# endif
+#elif (INT_MAX == INT32_MAX)
+  typedef signed int int32_t;
+# define INT32_C(v) v
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER ""
+# endif
+#elif (SHRT_MAX == INT32_MAX)
+  typedef signed short int32_t;
+# define INT32_C(v) ((short) (v))
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER ""
+# endif
+#else
+#error "Platform not supported"
+#endif
+#endif
+
+/*
+ *  The macro stdint_int64_defined is temporarily used to record
+ *  whether or not 64 integer support is available.  It must be
+ *  defined for any 64 integer extensions for new platforms that are
+ *  added.
+ */
+
+#undef stdint_int64_defined
+#if (defined(__STDC__) && defined(__STDC_VERSION__)) || defined (S_SPLINT_S)
+# if (__STDC__ && __STDC_VERSION__ >= 199901L) || defined (S_SPLINT_S)
+#  define stdint_int64_defined
+   typedef long long int64_t;
+   typedef unsigned long long uint64_t;
+#  define UINT64_C(v) v ## ULL
+#  define  INT64_C(v) v ## LL
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "ll"
+#  endif
+# endif
+#endif
+
+#if !defined (stdint_int64_defined)
+# if defined(__GNUC__) && !defined(vxWorks)
+#  define stdint_int64_defined
+   __extension__ typedef long long int64_t;
+   __extension__ typedef unsigned long long uint64_t;
+#  define UINT64_C(v) v ## ULL
+#  define  INT64_C(v) v ## LL
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "ll"
+#  endif
+# elif defined(__MWERKS__) || defined (__SUNPRO_C) || defined (__SUNPRO_CC) || defined (__APPLE_CC__) || defined (_LONG_LONG) || defined (_CRAYC) || defined (S_SPLINT_S)
+#  define stdint_int64_defined
+   typedef long long int64_t;
+   typedef unsigned long long uint64_t;
+#  define UINT64_C(v) v ## ULL
+#  define  INT64_C(v) v ## LL
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "ll"
+#  endif
+# elif (defined(__WATCOMC__) && defined(__WATCOM_INT64__)) || (defined(_MSC_VER) && _INTEGRAL_MAX_BITS >= 64) || (defined (__BORLANDC__) && __BORLANDC__ > 0x460) || defined (__alpha) || defined (__DECC)
+#  define stdint_int64_defined
+   typedef __int64 int64_t;
+   typedef unsigned __int64 uint64_t;
+#  define UINT64_C(v) v ## UI64
+#  define  INT64_C(v) v ## I64
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "I64"
+#  endif
+# endif
+#endif
+
+#if !defined (LONG_LONG_MAX) && defined (INT64_C)
+# define LONG_LONG_MAX INT64_C (9223372036854775807)
+#endif
+#ifndef ULONG_LONG_MAX
+# define ULONG_LONG_MAX UINT64_C (18446744073709551615)
+#endif
+
+#if !defined (INT64_MAX) && defined (INT64_C)
+# define INT64_MAX INT64_C (9223372036854775807)
+#endif
+#if !defined (INT64_MIN) && defined (INT64_C)
+# define INT64_MIN INT64_C (-9223372036854775808)
+#endif
+#if !defined (UINT64_MAX) && defined (INT64_C)
+# define UINT64_MAX UINT64_C (18446744073709551615)
+#endif
+
+/*
+ *  Width of hexadecimal for number field.
+ */
+
+#ifndef PRINTF_INT64_HEX_WIDTH
+# define PRINTF_INT64_HEX_WIDTH "16"
+#endif
+#ifndef PRINTF_INT32_HEX_WIDTH
+# define PRINTF_INT32_HEX_WIDTH "8"
+#endif
+#ifndef PRINTF_INT16_HEX_WIDTH
+# define PRINTF_INT16_HEX_WIDTH "4"
+#endif
+#ifndef PRINTF_INT8_HEX_WIDTH
+# define PRINTF_INT8_HEX_WIDTH "2"
+#endif
+#ifndef PRINTF_INT64_DEC_WIDTH
+# define PRINTF_INT64_DEC_WIDTH "19"
+#endif
+#ifndef PRINTF_INT32_DEC_WIDTH
+# define PRINTF_INT32_DEC_WIDTH "10"
+#endif
+#ifndef PRINTF_INT16_DEC_WIDTH
+# define PRINTF_INT16_DEC_WIDTH "5"
+#endif
+#ifndef PRINTF_INT8_DEC_WIDTH
+# define PRINTF_INT8_DEC_WIDTH "3"
+#endif
+#ifndef PRINTF_UINT64_DEC_WIDTH
+# define PRINTF_UINT64_DEC_WIDTH "20"
+#endif
+#ifndef PRINTF_UINT32_DEC_WIDTH
+# define PRINTF_UINT32_DEC_WIDTH "10"
+#endif
+#ifndef PRINTF_UINT16_DEC_WIDTH
+# define PRINTF_UINT16_DEC_WIDTH "5"
+#endif
+#ifndef PRINTF_UINT8_DEC_WIDTH
+# define PRINTF_UINT8_DEC_WIDTH "3"
+#endif
+
+/*
+ *  Ok, lets not worry about 128 bit integers for now.  Moore's law says
+ *  we don't need to worry about that until about 2040 at which point
+ *  we'll have bigger things to worry about.
+ */
+
+#ifdef stdint_int64_defined
+  typedef int64_t intmax_t;
+  typedef uint64_t uintmax_t;
+# define  INTMAX_MAX   INT64_MAX
+# define  INTMAX_MIN   INT64_MIN
+# define UINTMAX_MAX  UINT64_MAX
+# define UINTMAX_C(v) UINT64_C(v)
+# define  INTMAX_C(v)  INT64_C(v)
+# ifndef PRINTF_INTMAX_MODIFIER
+#   define PRINTF_INTMAX_MODIFIER PRINTF_INT64_MODIFIER
+# endif
+# ifndef PRINTF_INTMAX_HEX_WIDTH
+#  define PRINTF_INTMAX_HEX_WIDTH PRINTF_INT64_HEX_WIDTH
+# endif
+# ifndef PRINTF_INTMAX_DEC_WIDTH
+#  define PRINTF_INTMAX_DEC_WIDTH PRINTF_INT64_DEC_WIDTH
+# endif
+#else
+  typedef int32_t intmax_t;
+  typedef uint32_t uintmax_t;
+# define  INTMAX_MAX   INT32_MAX
+# define UINTMAX_MAX  UINT32_MAX
+# define UINTMAX_C(v) UINT32_C(v)
+# define  INTMAX_C(v)  INT32_C(v)
+# ifndef PRINTF_INTMAX_MODIFIER
+#   define PRINTF_INTMAX_MODIFIER PRINTF_INT32_MODIFIER
+# endif
+# ifndef PRINTF_INTMAX_HEX_WIDTH
+#  define PRINTF_INTMAX_HEX_WIDTH PRINTF_INT32_HEX_WIDTH
+# endif
+# ifndef PRINTF_INTMAX_DEC_WIDTH
+#  define PRINTF_INTMAX_DEC_WIDTH PRINTF_INT32_DEC_WIDTH
+# endif
+#endif
+
+/*
+ *  Because this file currently only supports platforms which have
+ *  precise powers of 2 as bit sizes for the default integers, the
+ *  least definitions are all trivial.  Its possible that a future
+ *  version of this file could have different definitions.
+ */
+
+#ifndef stdint_least_defined
+  typedef   int8_t   int_least8_t;
+  typedef  uint8_t  uint_least8_t;
+  typedef  int16_t  int_least16_t;
+  typedef uint16_t uint_least16_t;
+  typedef  int32_t  int_least32_t;
+  typedef uint32_t uint_least32_t;
+# define PRINTF_LEAST32_MODIFIER PRINTF_INT32_MODIFIER
+# define PRINTF_LEAST16_MODIFIER PRINTF_INT16_MODIFIER
+# define  UINT_LEAST8_MAX  UINT8_MAX
+# define   INT_LEAST8_MAX   INT8_MAX
+# define UINT_LEAST16_MAX UINT16_MAX
+# define  INT_LEAST16_MAX  INT16_MAX
+# define UINT_LEAST32_MAX UINT32_MAX
+# define  INT_LEAST32_MAX  INT32_MAX
+# define   INT_LEAST8_MIN   INT8_MIN
+# define  INT_LEAST16_MIN  INT16_MIN
+# define  INT_LEAST32_MIN  INT32_MIN
+# ifdef stdint_int64_defined
+    typedef  int64_t  int_least64_t;
+    typedef uint64_t uint_least64_t;
+#   define PRINTF_LEAST64_MODIFIER PRINTF_INT64_MODIFIER
+#   define UINT_LEAST64_MAX UINT64_MAX
+#   define  INT_LEAST64_MAX  INT64_MAX
+#   define  INT_LEAST64_MIN  INT64_MIN
+# endif
+#endif
+#undef stdint_least_defined
+
+/*
+ *  The ANSI C committee has defined *int*_fast*_t types as well.  This,
+ *  of course, defies rationality -- you can't know what will be fast
+ *  just from the type itself.  Even for a given architecture, compatible
+ *  implementations might have different performance characteristics.
+ *  Developers are warned to stay away from these types when using this
+ *  or any other stdint.h.
+ */
+
+typedef   int_least8_t   int_fast8_t;
+typedef  uint_least8_t  uint_fast8_t;
+typedef  int_least16_t  int_fast16_t;
+typedef uint_least16_t uint_fast16_t;
+typedef  int_least32_t  int_fast32_t;
+typedef uint_least32_t uint_fast32_t;
+#define  UINT_FAST8_MAX  UINT_LEAST8_MAX
+#define   INT_FAST8_MAX   INT_LEAST8_MAX
+#define UINT_FAST16_MAX UINT_LEAST16_MAX
+#define  INT_FAST16_MAX  INT_LEAST16_MAX
+#define UINT_FAST32_MAX UINT_LEAST32_MAX
+#define  INT_FAST32_MAX  INT_LEAST32_MAX
+#define   INT_FAST8_MIN   INT_LEAST8_MIN
+#define  INT_FAST16_MIN  INT_LEAST16_MIN
+#define  INT_FAST32_MIN  INT_LEAST32_MIN
+#ifdef stdint_int64_defined
+  typedef  int_least64_t  int_fast64_t;
+  typedef uint_least64_t uint_fast64_t;
+# define UINT_FAST64_MAX UINT_LEAST64_MAX
+# define  INT_FAST64_MAX  INT_LEAST64_MAX
+# define  INT_FAST64_MIN  INT_LEAST64_MIN
+#endif
+
+#undef stdint_int64_defined
+
+/*
+ *  Whatever piecemeal, per compiler thing we can do about the wchar_t
+ *  type limits.
+ */
+
+#if defined(__WATCOMC__) || defined(_MSC_VER) || defined (__GNUC__) && !defined(vxWorks)
+# include <wchar.h>
+# ifndef WCHAR_MIN
+#  define WCHAR_MIN 0
+# endif
+# ifndef WCHAR_MAX
+#  define WCHAR_MAX ((wchar_t)-1)
+# endif
+#endif
+
+/*
+ *  Whatever piecemeal, per compiler/platform thing we can do about the
+ *  (u)intptr_t types and limits.
+ */
+
+#if (defined (_MSC_VER) && defined (_UINTPTR_T_DEFINED)) || defined (_UINTPTR_T)
+# define STDINT_H_UINTPTR_T_DEFINED
+#endif
+
+#ifndef STDINT_H_UINTPTR_T_DEFINED
+# if defined (__alpha__) || defined (__ia64__) || defined (__x86_64__) || defined (_WIN64) || defined (__ppc64__)
+#  define stdint_intptr_bits 64
+# elif defined (__WATCOMC__) || defined (__TURBOC__)
+#  if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
+#    define stdint_intptr_bits 16
+#  else
+#    define stdint_intptr_bits 32
+#  endif
+# elif defined (__i386__) || defined (_WIN32) || defined (WIN32) || defined (__ppc64__)
+#  define stdint_intptr_bits 32
+# elif defined (__INTEL_COMPILER)
+/* TODO -- what did Intel do about x86-64? */
+# else
+/* #error "This platform might not be supported yet" */
+# endif
+
+# ifdef stdint_intptr_bits
+#  define stdint_intptr_glue3_i(a,b,c)  a##b##c
+#  define stdint_intptr_glue3(a,b,c)    stdint_intptr_glue3_i(a,b,c)
+#  ifndef PRINTF_INTPTR_MODIFIER
+#    define PRINTF_INTPTR_MODIFIER      stdint_intptr_glue3(PRINTF_INT,stdint_intptr_bits,_MODIFIER)
+#  endif
+#  ifndef PTRDIFF_MAX
+#    define PTRDIFF_MAX                 stdint_intptr_glue3(INT,stdint_intptr_bits,_MAX)
+#  endif
+#  ifndef PTRDIFF_MIN
+#    define PTRDIFF_MIN                 stdint_intptr_glue3(INT,stdint_intptr_bits,_MIN)
+#  endif
+#  ifndef UINTPTR_MAX
+#    define UINTPTR_MAX                 stdint_intptr_glue3(UINT,stdint_intptr_bits,_MAX)
+#  endif
+#  ifndef INTPTR_MAX
+#    define INTPTR_MAX                  stdint_intptr_glue3(INT,stdint_intptr_bits,_MAX)
+#  endif
+#  ifndef INTPTR_MIN
+#    define INTPTR_MIN                  stdint_intptr_glue3(INT,stdint_intptr_bits,_MIN)
+#  endif
+#  ifndef INTPTR_C
+#    define INTPTR_C(x)                 stdint_intptr_glue3(INT,stdint_intptr_bits,_C)(x)
+#  endif
+#  ifndef UINTPTR_C
+#    define UINTPTR_C(x)                stdint_intptr_glue3(UINT,stdint_intptr_bits,_C)(x)
+#  endif
+  typedef stdint_intptr_glue3(uint,stdint_intptr_bits,_t) uintptr_t;
+  typedef stdint_intptr_glue3( int,stdint_intptr_bits,_t)  intptr_t;
+# else
+/* TODO -- This following is likely wrong for some platforms, and does
+   nothing for the definition of uintptr_t. */
+  typedef ptrdiff_t intptr_t;
+# endif
+# define STDINT_H_UINTPTR_T_DEFINED
+#endif
+
+/*
+ *  Assumes sig_atomic_t is signed and we have a 2s complement machine.
+ */
+
+#ifndef SIG_ATOMIC_MAX
+# define SIG_ATOMIC_MAX ((((sig_atomic_t) 1) << (sizeof (sig_atomic_t)*CHAR_BIT-1)) - 1)
+#endif
+
+#endif
+
+#if defined (__TEST_PSTDINT_FOR_CORRECTNESS)
+
+/*
+ *  Please compile with the maximum warning settings to make sure macros are
+ *  not defined more than once.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#define glue3_aux(x,y,z) x ## y ## z
+#define glue3(x,y,z) glue3_aux(x,y,z)
+
+#define DECLU(bits) glue3(uint,bits,_t) glue3(u,bits,) = glue3(UINT,bits,_C) (0);
+#define DECLI(bits) glue3(int,bits,_t) glue3(i,bits,) = glue3(INT,bits,_C) (0);
+
+#define DECL(us,bits) glue3(DECL,us,) (bits)
+
+#define TESTUMAX(bits) glue3(u,bits,) = ~glue3(u,bits,); if (glue3(UINT,bits,_MAX) != glue3(u,bits,)) printf ("Something wrong with UINT%d_MAX\n", bits)
+
+#define REPORTERROR(msg) { err_n++; if (err_first <= 0) err_first = __LINE__; printf msg; }
+
+#define X_SIZE_MAX ((size_t)-1)
+
+int main () {
+    int err_n = 0;
+    int err_first = 0;
+    DECL(I,8)
+    DECL(U,8)
+    DECL(I,16)
+    DECL(U,16)
+    DECL(I,32)
+    DECL(U,32)
+#ifdef INT64_MAX
+    DECL(I,64)
+    DECL(U,64)
+#endif
+    intmax_t imax = INTMAX_C(0);
+    uintmax_t umax = UINTMAX_C(0);
+    char str0[256], str1[256];
+
+    sprintf (str0, "%" PRINTF_INT32_MODIFIER "d", INT32_C(2147483647));
+    if (0 != strcmp (str0, "2147483647")) REPORTERROR (("Something wrong with PRINTF_INT32_MODIFIER : %s\n", str0));
+    if (atoi(PRINTF_INT32_DEC_WIDTH) != (int) strlen(str0)) REPORTERROR (("Something wrong with PRINTF_INT32_DEC_WIDTH : %s\n", PRINTF_INT32_DEC_WIDTH));
+    sprintf (str0, "%" PRINTF_INT32_MODIFIER "u", UINT32_C(4294967295));
+    if (0 != strcmp (str0, "4294967295")) REPORTERROR (("Something wrong with PRINTF_INT32_MODIFIER : %s\n", str0));
+    if (atoi(PRINTF_UINT32_DEC_WIDTH) != (int) strlen(str0)) REPORTERROR (("Something wrong with PRINTF_UINT32_DEC_WIDTH : %s\n", PRINTF_UINT32_DEC_WIDTH));
+#ifdef INT64_MAX
+    sprintf (str1, "%" PRINTF_INT64_MODIFIER "d", INT64_C(9223372036854775807));
+    if (0 != strcmp (str1, "9223372036854775807")) REPORTERROR (("Something wrong with PRINTF_INT32_MODIFIER : %s\n", str1));
+    if (atoi(PRINTF_INT64_DEC_WIDTH) != (int) strlen(str1)) REPORTERROR (("Something wrong with PRINTF_INT64_DEC_WIDTH : %s, %d\n", PRINTF_INT64_DEC_WIDTH, (int) strlen(str1)));
+    sprintf (str1, "%" PRINTF_INT64_MODIFIER "u", UINT64_C(18446744073709550591));
+    if (0 != strcmp (str1, "18446744073709550591")) REPORTERROR (("Something wrong with PRINTF_INT32_MODIFIER : %s\n", str1));
+    if (atoi(PRINTF_UINT64_DEC_WIDTH) != (int) strlen(str1)) REPORTERROR (("Something wrong with PRINTF_UINT64_DEC_WIDTH : %s, %d\n", PRINTF_UINT64_DEC_WIDTH, (int) strlen(str1)));
+#endif
+
+    sprintf (str0, "%d %x\n", 0, ~0);
+
+    sprintf (str1, "%d %x\n",  i8, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with i8 : %s\n", str1));
+    sprintf (str1, "%u %x\n",  u8, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with u8 : %s\n", str1));
+    sprintf (str1, "%d %x\n",  i16, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with i16 : %s\n", str1));
+    sprintf (str1, "%u %x\n",  u16, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with u16 : %s\n", str1));
+    sprintf (str1, "%" PRINTF_INT32_MODIFIER "d %x\n",  i32, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with i32 : %s\n", str1));
+    sprintf (str1, "%" PRINTF_INT32_MODIFIER "u %x\n",  u32, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with u32 : %s\n", str1));
+#ifdef INT64_MAX
+    sprintf (str1, "%" PRINTF_INT64_MODIFIER "d %x\n",  i64, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with i64 : %s\n", str1));
+#endif
+    sprintf (str1, "%" PRINTF_INTMAX_MODIFIER "d %x\n",  imax, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with imax : %s\n", str1));
+    sprintf (str1, "%" PRINTF_INTMAX_MODIFIER "u %x\n",  umax, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with umax : %s\n", str1));
+
+    TESTUMAX(8);
+    TESTUMAX(16);
+    TESTUMAX(32);
+#ifdef INT64_MAX
+    TESTUMAX(64);
+#endif
+
+#define STR(v) #v
+#define Q(v) printf ("sizeof " STR(v) " = %u\n", (unsigned) sizeof (v));
+    if (err_n) {
+        printf ("pstdint.h is not correct.  Please use sizes below to correct it:\n");
+    }
+
+    Q(int)
+    Q(unsigned)
+    Q(long int)
+    Q(short int)
+    Q(int8_t)
+    Q(int16_t)
+    Q(int32_t)
+#ifdef INT64_MAX
+    Q(int64_t)
+#endif
+
+#if UINT_MAX < X_SIZE_MAX
+    printf ("UINT_MAX < X_SIZE_MAX\n");
+#else
+    printf ("UINT_MAX >= X_SIZE_MAX\n");
+#endif
+    printf ("%" PRINTF_INT64_MODIFIER "u vs %" PRINTF_INT64_MODIFIER "u\n", UINT_MAX, X_SIZE_MAX);
+
+    return EXIT_SUCCESS;
+}
+
+#endif
diff --git a/lib/abcsat/abc/satClause.h b/lib/abcsat/abc/satClause.h
new file mode 100644
index 0000000..1a0bd74
--- /dev/null
+++ b/lib/abcsat/abc/satClause.h
@@ -0,0 +1,485 @@
+/**CFile****************************************************************
+
+  FileName    [satMem.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SAT solver.]
+
+  Synopsis    [Memory management.]
+
+  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - January 1, 2004.]
+
+  Revision    [$Id: satMem.h,v 1.0 2004/01/01 1:00:00 alanmi Exp $]
+
+***********************************************************************/
+ 
+#ifndef ABC__sat__bsat__satMem_h
+#define ABC__sat__bsat__satMem_h
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4200)
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include <abc/abc_global.h>
+
+ABC_NAMESPACE_HEADER_START
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+//#define LEARNT_MAX_START_DEFAULT  0
+#define LEARNT_MAX_START_DEFAULT  10000
+#define LEARNT_MAX_INCRE_DEFAULT   1000
+#define LEARNT_MAX_RATIO_DEFAULT     50
+
+////////////////////////////////////////////////////////////////////////
+///                    STRUCTURE DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+ 
+//=================================================================================================
+// Clause datatype + minor functions:
+
+typedef struct clause_t clause;
+struct clause_t
+{
+    unsigned   lrn   :   1;
+    unsigned   mark  :   1;
+    unsigned   partA :   1;
+    unsigned   lbd   :   8;
+    unsigned   size  :  21;
+    lit        lits[0];
+};
+
+// learned clauses have "hidden" literal (c->lits[c->size]) to store clause ID
+
+// data-structure for logging entries
+// memory is allocated in 2^nPageSize word-sized pages
+// the first 'word' of each page are stores the word limit
+
+// although clause memory pieces are aligned to 64-bit words
+// the integer clause handles are in terms of 32-bit unsigneds
+// allowing for the first bit to be used for labeling 2-lit clauses
+
+
+typedef struct Sat_Mem_t_ Sat_Mem_t;
+struct Sat_Mem_t_
+{
+    int                 nEntries[2];  // entry count
+    int                 BookMarkH[2]; // bookmarks for handles
+    int                 BookMarkE[2]; // bookmarks for entries
+    int                 iPage[2];     // current memory page
+    int                 nPageSize;    // page log size in terms of ints
+    unsigned            uPageMask;    // page mask
+    unsigned            uLearnedMask; // learned mask
+    int                 nPagesAlloc;  // page count allocated
+    int **              pPages;       // page pointers
+}; 
+
+static inline int       Sat_MemLimit( int * p )                      { return p[0];                                 }
+static inline int       Sat_MemIncLimit( int * p, int nInts )        { return p[0] += nInts;                        }
+static inline void      Sat_MemWriteLimit( int * p, int nInts )      { p[0] = nInts;                                }
+
+static inline int       Sat_MemHandPage( Sat_Mem_t * p, cla h )      { return h >> p->nPageSize;                    }
+static inline int       Sat_MemHandShift( Sat_Mem_t * p, cla h )     { return h & p->uPageMask;                     }
+
+static inline int       Sat_MemIntSize( int size, int lrn )          { return (size + 2 + lrn) & ~01;               }
+static inline int       Sat_MemClauseSize( clause * p )              { return Sat_MemIntSize(p->size, p->lrn);      }
+static inline int       Sat_MemClauseSize2( clause * p )             { return Sat_MemIntSize(p->size, 1);           }
+
+//static inline clause *  Sat_MemClause( Sat_Mem_t * p, int i, int k ) { assert(i <= p->iPage[i&1] && k <= Sat_MemLimit(p->pPages[i]));  return (clause *)(p->pPages[i] + k ); }
+static inline clause *  Sat_MemClause( Sat_Mem_t * p, int i, int k ) { assert( k ); return (clause *)(p->pPages[i] + k);         }
+//static inline clause *  Sat_MemClauseHand( Sat_Mem_t * p, cla h )    { assert(Sat_MemHandPage(p, h) <= p->iPage[(h & p->uLearnedMask) > 0]); assert(Sat_MemHandShift(p, h) >= 2 && Sat_MemHandShift(p, h) < (int)p->uLearnedMask); return Sat_MemClause( p, Sat_MemHandPage(p, h), Sat_MemHandShift(p, h) );     }
+static inline clause *  Sat_MemClauseHand( Sat_Mem_t * p, cla h )    { return h ? Sat_MemClause( p, Sat_MemHandPage(p, h), Sat_MemHandShift(p, h) ) : NULL;                  }
+static inline int       Sat_MemEntryNum( Sat_Mem_t * p, int lrn )    { return p->nEntries[lrn];                                                                              }
+
+static inline cla       Sat_MemHand( Sat_Mem_t * p, int i, int k )   { return (i << p->nPageSize) | k;                                                                       }
+static inline cla       Sat_MemHandCurrent( Sat_Mem_t * p, int lrn ) { return (p->iPage[lrn] << p->nPageSize) | Sat_MemLimit( p->pPages[p->iPage[lrn]] );                    }
+
+static inline int       Sat_MemClauseUsed( Sat_Mem_t * p, cla h )    { return h < p->BookMarkH[(h & p->uLearnedMask) > 0];                                                   }
+
+static inline double    Sat_MemMemoryHand( Sat_Mem_t * p, cla h )    { return 1.0 * ((Sat_MemHandPage(p, h) + 2)/2 * (1 << (p->nPageSize+2)) + Sat_MemHandShift(p, h) * 4);  }
+static inline double    Sat_MemMemoryUsed( Sat_Mem_t * p, int lrn )  { return Sat_MemMemoryHand( p, Sat_MemHandCurrent(p, lrn) );                                            }
+static inline double    Sat_MemMemoryAllUsed( Sat_Mem_t * p )        { return Sat_MemMemoryUsed( p, 0 ) + Sat_MemMemoryUsed( p, 1 );                                         }
+static inline double    Sat_MemMemoryAll( Sat_Mem_t * p )            { return 1.0 * (p->iPage[0] + p->iPage[1] + 2) * (1 << (p->nPageSize+2));                               }
+
+// p is memory storage
+// c is clause pointer
+// i is page number
+// k is page offset
+
+// print problem clauses NOT in proof mode
+#define Sat_MemForEachClause( p, c, i, k )      \
+    for ( i = 0; i <= p->iPage[0]; i += 2 )     \
+        for ( k = 2; k < Sat_MemLimit(p->pPages[i]) && ((c) = Sat_MemClause( p, i, k )); k += Sat_MemClauseSize(c) ) if ( i == 0 && k == 2 ) {} else
+
+// print problem clauses in proof mode
+#define Sat_MemForEachClause2( p, c, i, k )      \
+    for ( i = 0; i <= p->iPage[0]; i += 2 )     \
+        for ( k = 2; k < Sat_MemLimit(p->pPages[i]) && ((c) = Sat_MemClause( p, i, k )); k += Sat_MemClauseSize2(c) ) if ( i == 0 && k == 2 ) {} else
+
+#define Sat_MemForEachLearned( p, c, i, k )     \
+    for ( i = 1; i <= p->iPage[1]; i += 2 )     \
+        for ( k = 2; k < Sat_MemLimit(p->pPages[i]) && ((c) = Sat_MemClause( p, i, k )); k += Sat_MemClauseSize(c) )
+
+////////////////////////////////////////////////////////////////////////
+///                       GLOBAL VARIABLES                           ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                       MACRO DEFINITIONS                          ///
+////////////////////////////////////////////////////////////////////////
+
+static inline int      clause_from_lit( lit l )                     { return l + l + 1;                            }
+static inline int      clause_is_lit( cla h )                       { return (h & 1);                              }
+static inline lit      clause_read_lit( cla h )                     { return (lit)(h >> 1);                        }
+
+static inline int      clause_learnt_h( Sat_Mem_t * p, cla h )      { return (h & p->uLearnedMask) > 0;            }
+static inline int      clause_learnt( clause * c )                  { return c->lrn;                               }
+static inline int      clause_id( clause * c )                      { return c->lits[c->size];                     }
+static inline void     clause_set_id( clause * c, int id )          { c->lits[c->size] = id;                       }
+static inline int      clause_size( clause * c )                    { return c->size;                              }
+static inline lit *    clause_begin( clause * c )                   { return c->lits;                              }
+static inline lit *    clause_end( clause * c )                     { return c->lits + c->size;                    }
+static inline void     clause_print_( clause * c )               
+{ 
+    int i;
+    printf( "{ " );
+    for ( i = 0; i < clause_size(c); i++ )
+        printf( "%d ", (clause_begin(c)[i] & 1)? -(clause_begin(c)[i] >> 1) : clause_begin(c)[i] >> 1 );
+    printf( "}\n" );
+}
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DECLARATIONS                        ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Allocating vector.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Sat_MemCountL( Sat_Mem_t * p )
+{
+    clause * c;
+    int i, k, Count = 0;
+    Sat_MemForEachLearned( p, c, i, k )
+        Count++;
+    return Count;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocating vector.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Sat_MemAlloc_( Sat_Mem_t * p, int nPageSize )
+{
+    assert( nPageSize > 8 && nPageSize < 32 );
+    memset( p, 0, sizeof(Sat_Mem_t) );
+    p->nPageSize    = nPageSize;
+    p->uLearnedMask = (unsigned)(1 << nPageSize);
+    p->uPageMask    = (unsigned)((1 << nPageSize) - 1);
+    p->nPagesAlloc  = 256;
+    p->pPages       = ABC_CALLOC( int *, p->nPagesAlloc );
+    p->pPages[0]    = ABC_ALLOC( int, (int)(((word)1) << p->nPageSize) );
+    p->pPages[1]    = ABC_ALLOC( int, (int)(((word)1) << p->nPageSize) );
+    p->iPage[0]     = 0;
+    p->iPage[1]     = 1;
+    Sat_MemWriteLimit( p->pPages[0], 2 );
+    Sat_MemWriteLimit( p->pPages[1], 2 );
+}
+static inline Sat_Mem_t * Sat_MemAlloc( int nPageSize )
+{
+    Sat_Mem_t * p;
+    p = ABC_CALLOC( Sat_Mem_t, 1 );
+    Sat_MemAlloc_( p, nPageSize );
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Resetting vector.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Sat_MemRestart( Sat_Mem_t * p )
+{
+    p->nEntries[0]  = 0;
+    p->nEntries[1]  = 0;
+    p->iPage[0]     = 0;
+    p->iPage[1]     = 1;
+    Sat_MemWriteLimit( p->pPages[0], 2 );
+    Sat_MemWriteLimit( p->pPages[1], 2 );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sets the bookmark.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Sat_MemBookMark( Sat_Mem_t * p )
+{
+    p->BookMarkE[0] = p->nEntries[0];
+    p->BookMarkE[1] = p->nEntries[1];
+    p->BookMarkH[0] = Sat_MemHandCurrent( p, 0 );
+    p->BookMarkH[1] = Sat_MemHandCurrent( p, 1 );
+}
+static inline void Sat_MemRollBack( Sat_Mem_t * p )
+{
+    p->nEntries[0]  = p->BookMarkE[0];
+    p->nEntries[1]  = p->BookMarkE[1];
+    p->iPage[0]     = Sat_MemHandPage( p, p->BookMarkH[0] );
+    p->iPage[1]     = Sat_MemHandPage( p, p->BookMarkH[1] );
+    Sat_MemWriteLimit( p->pPages[p->iPage[0]], Sat_MemHandShift( p, p->BookMarkH[0] ) );
+    Sat_MemWriteLimit( p->pPages[p->iPage[1]], Sat_MemHandShift( p, p->BookMarkH[1] ) );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Freeing vector.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Sat_MemFree_( Sat_Mem_t * p )
+{
+    int i;
+    for ( i = 0; i < p->nPagesAlloc; i++ )
+        ABC_FREE( p->pPages[i] );
+    ABC_FREE( p->pPages );
+}
+static inline void Sat_MemFree( Sat_Mem_t * p )
+{
+    Sat_MemFree_( p );
+    ABC_FREE( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Creates new clause.]
+
+  Description [The resulting clause is fully initialized.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Sat_MemAppend( Sat_Mem_t * p, int * pArray, int nSize, int lrn, int fPlus1 )
+{
+    clause * c;
+    int * pPage = p->pPages[p->iPage[lrn]];
+    int nInts = Sat_MemIntSize( nSize, lrn | fPlus1 );
+    assert( nInts + 3 < (1 << p->nPageSize) );
+    // need two extra at the begining of the page and one extra in the end
+    if ( Sat_MemLimit(pPage) + nInts + 2 >= (1 << p->nPageSize) )
+    { 
+        p->iPage[lrn] += 2;
+        if ( p->iPage[lrn] >= p->nPagesAlloc )
+        {
+            p->pPages = ABC_REALLOC( int *, p->pPages, p->nPagesAlloc * 2 );
+            memset( p->pPages + p->nPagesAlloc, 0, sizeof(int *) * p->nPagesAlloc );
+            p->nPagesAlloc *= 2;
+        }
+        if ( p->pPages[p->iPage[lrn]] == NULL )
+            p->pPages[p->iPage[lrn]] = ABC_ALLOC( int, (int)(((word)1) << p->nPageSize) );
+        pPage = p->pPages[p->iPage[lrn]];
+        Sat_MemWriteLimit( pPage, 2 );
+    }
+    pPage[Sat_MemLimit(pPage)] = 0;
+    c = (clause *)(pPage + Sat_MemLimit(pPage));
+    c->size = nSize;
+    c->lrn = lrn;
+    if ( pArray )
+        memcpy( c->lits, pArray, sizeof(int) * nSize );
+    if ( lrn | fPlus1 )
+        c->lits[c->size] = p->nEntries[lrn];
+    p->nEntries[lrn]++;
+    Sat_MemIncLimit( pPage, nInts );
+    return Sat_MemHandCurrent(p, lrn) - nInts;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Shrinking vector size.]
+
+  Description []
+
+  SideEffects [This procedure does not update the number of entries.]
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Sat_MemShrink( Sat_Mem_t * p, int h, int lrn )
+{
+    assert( clause_learnt_h(p, h) == lrn );
+    assert( h && h <= Sat_MemHandCurrent(p, lrn) );
+    p->iPage[lrn] = Sat_MemHandPage(p, h);
+    Sat_MemWriteLimit( p->pPages[p->iPage[lrn]], Sat_MemHandShift(p, h) );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Compacts learned clauses by removing marked entries.]
+
+  Description [Returns the number of remaining entries.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Sat_MemCompactLearned( Sat_Mem_t * p, int fDoMove )
+{
+    clause * c, * cPivot = NULL;
+    int i, k, iNew = 1, kNew = 2, nInts, fStartLooking, Counter = 0;
+    int hLimit = Sat_MemHandCurrent(p, 1);
+    if ( hLimit == Sat_MemHand(p, 1, 2) )
+        return 0;
+    if ( fDoMove && p->BookMarkH[1] )
+    {
+        // move the pivot
+        assert( p->BookMarkH[1] >= Sat_MemHand(p, 1, 2) && p->BookMarkH[1] <= hLimit );
+        // get the pivot and remember it may be pointed offlimit
+        cPivot = Sat_MemClauseHand( p, p->BookMarkH[1] );
+        if ( p->BookMarkH[1] < hLimit && !cPivot->mark )
+        {
+            p->BookMarkH[1] = cPivot->lits[cPivot->size];
+            cPivot = NULL;
+        }
+        // else find the next used clause after cPivot
+    }
+    // iterate through the learned clauses
+    fStartLooking = 0;
+    Sat_MemForEachLearned( p, c, i, k )
+    {
+        assert( c->lrn );
+        // skip marked entry
+        if ( c->mark )
+        {
+            // if pivot is a marked clause, start looking for the next non-marked one
+            if ( cPivot && cPivot == c )
+            {
+                fStartLooking = 1;
+                cPivot = NULL;
+            }
+            continue;
+        }
+        // if we started looking before, we found it!
+        if ( fStartLooking )
+        {
+            fStartLooking = 0;
+            p->BookMarkH[1] = c->lits[c->size];
+        }
+        // compute entry size
+        nInts = Sat_MemClauseSize(c);
+        assert( !(nInts & 1) );
+        // check if we need to scroll to the next page
+        if ( kNew + nInts >= (1 << p->nPageSize) )
+        {
+            // set the limit of the current page
+            if ( fDoMove )
+                Sat_MemWriteLimit( p->pPages[iNew], kNew );
+            // move writing position to the new page
+            iNew += 2;
+            kNew = 2;
+        }
+        if ( fDoMove )
+        {
+            // make sure the result is the same as previous dry run
+            assert( c->lits[c->size] == Sat_MemHand(p, iNew, kNew) );
+            // only copy the clause if it has changed
+            if ( i != iNew || k != kNew )
+            {
+                memmove( p->pPages[iNew] + kNew, c, sizeof(int) * nInts );
+//                c = Sat_MemClause( p, iNew, kNew ); // assersions do not hold during dry run
+                c = (clause *)(p->pPages[iNew] + kNew);
+                assert( nInts == Sat_MemClauseSize(c) );
+            }
+            // set the new ID value
+            c->lits[c->size] = Counter;
+        }
+        else // remember the address of the clause in the new location
+            c->lits[c->size] = Sat_MemHand(p, iNew, kNew);
+        // update writing position
+        kNew += nInts;
+        assert( iNew <= i && kNew < (1 << p->nPageSize) );
+        // update counter
+        Counter++;
+    }
+    if ( fDoMove )
+    {
+        // update the counter
+        p->nEntries[1] = Counter;
+        // update the page count
+        p->iPage[1] = iNew;
+        // set the limit of the last page
+        Sat_MemWriteLimit( p->pPages[iNew], kNew );
+        // check if the pivot need to be updated
+        if ( p->BookMarkH[1] )
+        {
+            if ( cPivot )
+            {
+                p->BookMarkH[1] = Sat_MemHandCurrent(p, 1);
+                p->BookMarkE[1] = p->nEntries[1];
+            }
+            else
+                p->BookMarkE[1] = clause_id(Sat_MemClauseHand( p, p->BookMarkH[1] ));
+        }
+
+    }
+    return Counter;
+}
+
+
+ABC_NAMESPACE_HEADER_END
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
diff --git a/lib/abcsat/abc/satSolver.h b/lib/abcsat/abc/satSolver.h
new file mode 100644
index 0000000..bedc6dc
--- /dev/null
+++ b/lib/abcsat/abc/satSolver.h
@@ -0,0 +1,661 @@
+/**************************************************************************************************
+MiniSat -- Copyright (c) 2005, Niklas Sorensson
+http://www.cs.chalmers.se/Cs/Research/FormalMethods/MiniSat/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+// Modified to compile with MS Visual Studio 6.0 by Alan Mishchenko
+
+#ifndef ABC__sat__bsat__satSolver_h
+#define ABC__sat__bsat__satSolver_h
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "satVec.h"
+#include "satClause.h"
+#include <abc/utilDouble.h>
+
+ABC_NAMESPACE_HEADER_START
+
+//=================================================================================================
+// Public interface:
+
+struct sat_solver_t;
+typedef struct sat_solver_t sat_solver;
+
+extern sat_solver* sat_solver_new(void);
+extern sat_solver* zsat_solver_new_seed(double seed);
+extern void        sat_solver_delete(sat_solver* s);
+
+extern void        solver_init_activities(sat_solver* s);
+
+extern int         sat_solver_addclause(sat_solver* s, lit* begin, lit* end);
+extern int         sat_solver_clause_new(sat_solver* s, lit* begin, lit* end, int learnt);
+extern int         sat_solver_simplify(sat_solver* s);
+extern int         sat_solver_solve(sat_solver* s, lit* begin, lit* end, ABC_INT64_T nConfLimit, ABC_INT64_T nInsLimit, ABC_INT64_T nConfLimitGlobal, ABC_INT64_T nInsLimitGlobal);
+extern int         sat_solver_solve_internal(sat_solver* s);
+extern int         sat_solver_solve_lexsat(sat_solver* s, int * pLits, int nLits);
+extern int         sat_solver_minimize_assumptions( sat_solver* s, int * pLits, int nLits, int nConfLimit );
+extern int         sat_solver_minimize_assumptions2( sat_solver* s, int * pLits, int nLits, int nConfLimit );
+extern int         sat_solver_push(sat_solver* s, int p);
+extern void        sat_solver_pop(sat_solver* s);
+extern void        sat_solver_set_resource_limits(sat_solver* s, ABC_INT64_T nConfLimit, ABC_INT64_T nInsLimit, ABC_INT64_T nConfLimitGlobal, ABC_INT64_T nInsLimitGlobal);
+extern void        sat_solver_restart( sat_solver* s );
+extern void        zsat_solver_restart_seed( sat_solver* s, double seed );
+extern void        sat_solver_rollback( sat_solver* s );
+
+extern int         sat_solver_nvars(sat_solver* s);
+extern int         sat_solver_nclauses(sat_solver* s);
+extern int         sat_solver_nconflicts(sat_solver* s);
+extern double      sat_solver_memory(sat_solver* s);
+extern int         sat_solver_count_assigned(sat_solver* s);
+
+extern int         sat_solver_addvar(sat_solver* s);
+extern void        sat_solver_setnvars(sat_solver* s,int n);
+extern int         sat_solver_get_var_value(sat_solver* s, int v);
+extern void        sat_solver_set_var_activity(sat_solver* s, int * pVars, int nVars);
+
+extern void        Sat_SolverWriteDimacs( sat_solver * p, char * pFileName, lit* assumptionsBegin, lit* assumptionsEnd, int incrementVars );
+extern void        Sat_SolverPrintStats( FILE * pFile, sat_solver * p );
+extern int *       Sat_SolverGetModel( sat_solver * p, int * pVars, int nVars );
+extern void        Sat_SolverDoubleClauses( sat_solver * p, int iVar );
+
+// trace recording
+extern void        Sat_SolverTraceStart( sat_solver * pSat, char * pName );
+extern void        Sat_SolverTraceStop( sat_solver * pSat );
+extern void        Sat_SolverTraceWrite( sat_solver * pSat, int * pBeg, int * pEnd, int fRoot );
+
+// clause storage
+extern void        sat_solver_store_alloc( sat_solver * s );
+extern void        sat_solver_store_write( sat_solver * s, char * pFileName );
+extern void        sat_solver_store_free( sat_solver * s );
+extern void        sat_solver_store_mark_roots( sat_solver * s );
+extern void        sat_solver_store_mark_clauses_a( sat_solver * s );
+extern void *      sat_solver_store_release( sat_solver * s ); 
+
+//=================================================================================================
+// Solver representation:
+
+//struct clause_t;
+//typedef struct clause_t clause;
+
+struct varinfo_t;
+typedef struct varinfo_t varinfo;
+
+struct sat_solver_t
+{
+    int         size;          // nof variables
+    int         cap;           // size of varmaps
+    int         qhead;         // Head index of queue.
+    int         qtail;         // Tail index of queue.
+
+    // clauses
+    Sat_Mem_t   Mem;
+    int         hLearnts;      // the first learnt clause
+    int         hBinary;       // the special binary clause
+    clause *    binary;
+    veci*       wlists;        // watcher lists
+
+    // rollback
+    int         iVarPivot;     // the pivot for variables
+    int         iTrailPivot;   // the pivot for trail
+    int         hProofPivot;   // the pivot for proof records
+
+    // activities
+    int         VarActType = 0;
+    int         ClaActType = 0;
+    word        var_inc;       // Amount to bump next variable with.
+    word        var_inc2;      // Amount to bump next variable with.
+    word        var_decay;     // INVERSE decay factor for variable activity: stores 1/decay. 
+    word*       activity;      // A heuristic measurement of the activity of a variable.
+    word*       activity2;     // backup variable activity
+    unsigned    cla_inc;       // Amount to bump next clause with.
+    unsigned    cla_decay;     // INVERSE decay factor for clause activity: stores 1/decay.
+    veci        act_clas;      // contain clause activities
+
+    char *      pFreqs;        // how many times this variable was assigned a value
+    int         nVarUsed;
+
+//    varinfo *   vi;            // variable information
+    int*        levels;        //
+    char*       assigns;       // Current values of variables.
+    char*       polarity;      //
+    char*       tags;          //
+    char*       loads;         //
+
+    int*        orderpos;      // Index in variable order.
+    int*        reasons;       //
+    lit*        trail;
+    veci        tagged;        // (contains: var)
+    veci        stack;         // (contains: var)
+
+    veci        order;         // Variable order. (heap) (contains: var)
+    veci        trail_lim;     // Separator indices for different decision levels in 'trail'. (contains: int)
+//    veci        model;         // If problem is solved, this vector contains the model (contains: lbool).
+    int *       model;         // If problem is solved, this vector contains the model (contains: lbool).
+    veci        conf_final;    // If problem is unsatisfiable (possibly under assumptions),
+                               // this vector represent the final conflict clause expressed in the assumptions.
+
+    int         root_level;    // Level of first proper decision.
+    int         simpdb_assigns;// Number of top-level assignments at last 'simplifyDB()'.
+    int         simpdb_props;  // Number of propagations before next 'simplifyDB()'.
+    double      random_seed = 91648253;
+    double      progress_estimate;
+    int         verbosity;     // Verbosity level. 0=silent, 1=some progress report, 2=everything
+    int         fVerbose;
+    int         fPrintClause;
+
+    stats_t     stats;
+    int         nLearntMax;    // max number of learned clauses
+    int         nLearntStart;  // starting learned clause limit
+    int         nLearntDelta;  // delta of learned clause limit
+    int         nLearntRatio;  // ratio percentage of learned clauses
+    int         nDBreduces;    // number of DB reductions
+
+    ABC_INT64_T nConfLimit;    // external limit on the number of conflicts
+    ABC_INT64_T nInsLimit;     // external limit on the number of implications
+    abctime     nRuntimeLimit; // external limit on runtime
+
+    veci        act_vars;      // variables whose activity has changed
+    double*     factors;       // the activity factors
+    int         nRestarts;     // the number of local restarts
+    int         nCalls;        // the number of local restarts
+    int         nCalls2;       // the number of local restarts
+    veci        unit_lits;     // variables whose activity has changed
+    veci        pivot_vars;    // pivot variables
+
+    int         fSkipSimplify; // set to one to skip simplification of the clause database
+    int         fNotUseRandom; // do not allow random decisions with a fixed probability
+    int         fNoRestarts;   // disables periodic restarts
+
+    int *       pGlobalVars;   // for experiments with global vars during interpolation
+    // clause store
+    void *      pStore;
+    int         fSolved;
+
+    // trace recording
+    FILE *      pFile;
+    int         nClauses;
+    int         nRoots;
+
+    veci        temp_clause;    // temporary storage for a CNF clause
+
+    // assignment storage
+    veci        user_vars;      // variable IDs
+    veci        user_values;    // values of these variables
+
+    // CNF loading
+    void *      pCnfMan;           // external CNF manager
+    int(*pCnfFunc)(void * p, int); // external callback
+
+    // termination callback
+    int         RunId;          // SAT id in this run
+    int(*pFuncStop)(int);       // callback to terminate
+};
+
+static inline clause * clause_read( sat_solver * s, cla h )          
+{ 
+    return Sat_MemClauseHand( &s->Mem, h );      
+}
+
+static inline int sat_solver_var_value( sat_solver* s, int v )
+{
+    assert( v >= 0 && v < s->size );
+    return (int)(s->model[v] == l_True);
+}
+static inline int sat_solver_var_literal( sat_solver* s, int v )
+{
+    assert( v >= 0 && v < s->size );
+    return toLitCond( v, s->model[v] != l_True );
+}
+static inline void sat_solver_flip_print_clause( sat_solver* s )
+{
+    s->fPrintClause ^= 1;
+}
+static inline void sat_solver_act_var_clear(sat_solver* s) 
+{
+    int i;
+    if ( s->VarActType == 0 )
+    {
+        for (i = 0; i < s->size; i++)
+            s->activity[i] = (1 << 10);
+        s->var_inc = (1 << 5);
+    }
+    else if ( s->VarActType == 1 )
+    {
+        for (i = 0; i < s->size; i++)
+            s->activity[i] = 0;
+        s->var_inc = 1;
+    }
+    else if ( s->VarActType == 2 )
+    {
+        for (i = 0; i < s->size; i++)
+            s->activity[i] = Xdbl_Const1();
+        s->var_inc = Xdbl_Const1();
+    }
+    else assert(0);
+}
+static inline void sat_solver_compress(sat_solver* s) 
+{
+    if ( s->qtail != s->qhead )
+    {
+        int RetValue = sat_solver_simplify(s);
+        assert( RetValue != 0 );
+        (void) RetValue;
+    }
+}
+static inline void sat_solver_delete_p( sat_solver ** ps )
+{
+    if ( *ps )
+        sat_solver_delete( *ps );
+    *ps = NULL;
+}
+static inline void sat_solver_clean_polarity(sat_solver* s, int * pVars, int nVars )
+{
+    int i;
+    for ( i = 0; i < nVars; i++ )
+        s->polarity[pVars[i]] = 0;
+}
+static inline void sat_solver_set_polarity(sat_solver* s, int * pVars, int nVars )
+{
+    int i;
+    for ( i = 0; i < s->size; i++ )
+        s->polarity[i] = 0;
+    for ( i = 0; i < nVars; i++ )
+        s->polarity[pVars[i]] = 1;
+}
+static inline void sat_solver_set_literal_polarity(sat_solver* s, int * pLits, int nLits )
+{
+    int i;
+    for ( i = 0; i < nLits; i++ )
+        s->polarity[Abc_Lit2Var(pLits[i])] = !Abc_LitIsCompl(pLits[i]);
+}
+
+static inline int sat_solver_final(sat_solver* s, int ** ppArray)
+{
+    *ppArray = s->conf_final.ptr;
+    return s->conf_final.size;
+}
+
+static inline abctime sat_solver_set_runtime_limit(sat_solver* s, abctime Limit)
+{
+    abctime nRuntimeLimit = s->nRuntimeLimit;
+    s->nRuntimeLimit = Limit;
+    return nRuntimeLimit;
+}
+
+static inline int sat_solver_set_random(sat_solver* s, int fNotUseRandom)
+{
+    int fNotUseRandomOld = s->fNotUseRandom;
+    s->fNotUseRandom = fNotUseRandom;
+    return fNotUseRandomOld;
+}
+
+static inline void sat_solver_bookmark(sat_solver* s)
+{
+    if (s->qtail != s->qhead)
+    {
+        int status = sat_solver_simplify(s);
+        assert(status!=0);
+        assert(s->qtail == s->qhead);
+    }
+    assert( s->qhead == s->qtail );
+    s->iVarPivot    = s->size;
+    s->iTrailPivot  = s->qhead;
+    Sat_MemBookMark( &s->Mem );
+    if ( s->activity2 )
+    {
+        s->var_inc2 = s->var_inc;
+        memcpy( s->activity2, s->activity, sizeof(word) * s->iVarPivot );
+    }
+}
+static inline void sat_solver_set_pivot_variables( sat_solver* s, int * pPivots, int nPivots )
+{
+    s->pivot_vars.cap = nPivots;
+    s->pivot_vars.size = nPivots;
+    s->pivot_vars.ptr = pPivots;
+}
+static inline int sat_solver_count_usedvars(sat_solver* s)
+{
+    int i, nVars = 0;
+    for ( i = 0; i < s->size; i++ )
+        if ( s->pFreqs[i] )
+        {
+            s->pFreqs[i] = 0;
+            nVars++;
+        }
+    return nVars;
+}
+static inline void sat_solver_set_runid( sat_solver *s, int id )               
+{ 
+    s->RunId      = id;  
+}
+static inline void sat_solver_set_stop_func( sat_solver *s, int (*fnct)(int) ) 
+{ 
+    s->pFuncStop = fnct; 
+}
+
+static inline int sat_solver_add_const( sat_solver * pSat, int iVar, int fCompl )
+{
+    lit Lits[1];
+    int Cid;
+    assert( iVar >= 0 );
+
+    Lits[0] = toLitCond( iVar, fCompl );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 1 );
+    assert( Cid );
+    (void)Cid;
+    return 1;
+}
+static inline int sat_solver_add_buffer( sat_solver * pSat, int iVarA, int iVarB, int fCompl )
+{
+    lit Lits[2];
+    int Cid;
+    assert( iVarA >= 0 && iVarB >= 0 );
+
+    Lits[0] = toLitCond( iVarA, 0 );
+    Lits[1] = toLitCond( iVarB, !fCompl );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    if ( Cid == 0 )
+        return 0;
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarA, 1 );
+    Lits[1] = toLitCond( iVarB, fCompl );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    if ( Cid == 0 )
+        return 0;
+    assert( Cid );
+    return 2;
+}
+static inline int sat_solver_add_buffer_enable( sat_solver * pSat, int iVarA, int iVarB, int iVarEn, int fCompl )
+{
+    lit Lits[3];
+    int Cid;
+    assert( iVarA >= 0 && iVarB >= 0 && iVarEn >= 0 );
+
+    Lits[0] = toLitCond( iVarA, 0 );
+    Lits[1] = toLitCond( iVarB, !fCompl );
+    Lits[2] = toLitCond( iVarEn, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarA, 1 );
+    Lits[1] = toLitCond( iVarB, fCompl );
+    Lits[2] = toLitCond( iVarEn, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+    (void)Cid;
+    return 2;
+}
+static inline int sat_solver_add_and( sat_solver * pSat, int iVar, int iVar0, int iVar1, int fCompl0, int fCompl1, int fCompl )
+{
+    lit Lits[3];
+    int Cid;
+
+    Lits[0] = toLitCond( iVar, !fCompl );
+    Lits[1] = toLitCond( iVar0, fCompl0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVar, !fCompl );
+    Lits[1] = toLitCond( iVar1, fCompl1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVar, fCompl );
+    Lits[1] = toLitCond( iVar0, !fCompl0 );
+    Lits[2] = toLitCond( iVar1, !fCompl1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+    (void)Cid;
+    return 3;
+}
+static inline int sat_solver_add_xor( sat_solver * pSat, int iVarA, int iVarB, int iVarC, int fCompl )
+{
+    lit Lits[3];
+    int Cid;
+    assert( iVarA >= 0 && iVarB >= 0 && iVarC >= 0 );
+
+    Lits[0] = toLitCond( iVarA, !fCompl );
+    Lits[1] = toLitCond( iVarB, 1 );
+    Lits[2] = toLitCond( iVarC, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarA, !fCompl );
+    Lits[1] = toLitCond( iVarB, 0 );
+    Lits[2] = toLitCond( iVarC, 0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarA, fCompl );
+    Lits[1] = toLitCond( iVarB, 1 );
+    Lits[2] = toLitCond( iVarC, 0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarA, fCompl );
+    Lits[1] = toLitCond( iVarB, 0 );
+    Lits[2] = toLitCond( iVarC, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+    (void)Cid;
+    return 4;
+}
+static inline int sat_solver_add_mux( sat_solver * pSat, int iVarZ, int iVarC, int iVarT, int iVarE, int iComplC, int iComplT, int iComplE, int iComplZ )
+{
+    lit Lits[3];
+    int Cid;
+    assert( iVarC >= 0 && iVarT >= 0 && iVarE >= 0 && iVarZ >= 0 );
+
+    Lits[0] = toLitCond( iVarC, 1 ^ iComplC );
+    Lits[1] = toLitCond( iVarT, 1 ^ iComplT );
+    Lits[2] = toLitCond( iVarZ, 0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarC, 1 ^ iComplC );
+    Lits[1] = toLitCond( iVarT, 0 ^ iComplT );
+    Lits[2] = toLitCond( iVarZ, 1 ^ iComplZ );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarC, 0 ^ iComplC );
+    Lits[1] = toLitCond( iVarE, 1 ^ iComplE );
+    Lits[2] = toLitCond( iVarZ, 0 ^ iComplZ );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarC, 0 ^ iComplC );
+    Lits[1] = toLitCond( iVarE, 0 ^ iComplE );
+    Lits[2] = toLitCond( iVarZ, 1 ^ iComplZ );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    if ( iVarT == iVarE )
+        return 4;
+
+    Lits[0] = toLitCond( iVarT, 0 ^ iComplT );
+    Lits[1] = toLitCond( iVarE, 0 ^ iComplE );
+    Lits[2] = toLitCond( iVarZ, 1 ^ iComplZ );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarT, 1 ^ iComplT );
+    Lits[1] = toLitCond( iVarE, 1 ^ iComplE );
+    Lits[2] = toLitCond( iVarZ, 0 ^ iComplZ );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+    (void)Cid;
+    return 6;
+}
+static inline int sat_solver_add_mux41( sat_solver * pSat, int iVarZ, int iVarC0, int iVarC1, int iVarD0, int iVarD1, int iVarD2, int iVarD3 )
+{
+    lit Lits[4];
+    int Cid;
+    assert( iVarC0 >= 0 && iVarC1 >= 0 && iVarD0 >= 0 && iVarD1 >= 0 && iVarD2 >= 0 && iVarD3 >= 0 && iVarZ >= 0 );
+
+    Lits[0] = toLitCond( iVarD0, 1 );
+    Lits[1] = toLitCond( iVarC0, 0 );
+    Lits[2] = toLitCond( iVarC1, 0 );
+    Lits[3] = toLitCond( iVarZ,  0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarD1, 1 );
+    Lits[1] = toLitCond( iVarC0, 1 );
+    Lits[2] = toLitCond( iVarC1, 0 );
+    Lits[3] = toLitCond( iVarZ,  0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarD2, 1 );
+    Lits[1] = toLitCond( iVarC0, 0 );
+    Lits[2] = toLitCond( iVarC1, 1 );
+    Lits[3] = toLitCond( iVarZ,  0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarD3, 1 );
+    Lits[1] = toLitCond( iVarC0, 1 );
+    Lits[2] = toLitCond( iVarC1, 1 );
+    Lits[3] = toLitCond( iVarZ,  0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+
+
+    Lits[0] = toLitCond( iVarD0, 0 );
+    Lits[1] = toLitCond( iVarC0, 0 );
+    Lits[2] = toLitCond( iVarC1, 0 );
+    Lits[3] = toLitCond( iVarZ,  1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarD1, 0 );
+    Lits[1] = toLitCond( iVarC0, 1 );
+    Lits[2] = toLitCond( iVarC1, 0 );
+    Lits[3] = toLitCond( iVarZ,  1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarD2, 0 );
+    Lits[1] = toLitCond( iVarC0, 0 );
+    Lits[2] = toLitCond( iVarC1, 1 );
+    Lits[3] = toLitCond( iVarZ,  1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarD3, 0 );
+    Lits[1] = toLitCond( iVarC0, 1 );
+    Lits[2] = toLitCond( iVarC1, 1 );
+    Lits[3] = toLitCond( iVarZ,  1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+    (void)Cid;
+    return 8;
+}
+static inline int sat_solver_add_xor_and( sat_solver * pSat, int iVarF, int iVarA, int iVarB, int iVarC )
+{
+    // F = (a (+) b) * c
+    lit Lits[4];
+    int Cid;
+    assert( iVarF >= 0 && iVarA >= 0 && iVarB >= 0 && iVarC >= 0 );
+
+    Lits[0] = toLitCond( iVarF, 1 );
+    Lits[1] = toLitCond( iVarA, 1 );
+    Lits[2] = toLitCond( iVarB, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarF, 1 );
+    Lits[1] = toLitCond( iVarA, 0 );
+    Lits[2] = toLitCond( iVarB, 0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarF, 1 );
+    Lits[1] = toLitCond( iVarC, 0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarF, 0 );
+    Lits[1] = toLitCond( iVarA, 1 );
+    Lits[2] = toLitCond( iVarB, 0 );
+    Lits[3] = toLitCond( iVarC, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarF, 0 );
+    Lits[1] = toLitCond( iVarA, 0 );
+    Lits[2] = toLitCond( iVarB, 1 );
+    Lits[3] = toLitCond( iVarC, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+    (void)Cid;
+    return 5;
+}
+static inline int sat_solver_add_constraint( sat_solver * pSat, int iVar, int iVar2, int fCompl )
+{
+    lit Lits[2];
+    int Cid;
+    assert( iVar >= 0 );
+
+    Lits[0] = toLitCond( iVar, fCompl );
+    Lits[1] = toLitCond( iVar2, 0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVar, fCompl );
+    Lits[1] = toLitCond( iVar2, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    assert( Cid );
+    (void)Cid;
+    return 2;
+}
+
+static inline int sat_solver_add_half_sorter( sat_solver * pSat, int iVarA, int iVarB, int iVar0, int iVar1 )
+{
+    lit Lits[3];
+    int Cid;
+
+    Lits[0] = toLitCond( iVarA, 0 );
+    Lits[1] = toLitCond( iVar0, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarA, 0 );
+    Lits[1] = toLitCond( iVar1, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarB, 0 );
+    Lits[1] = toLitCond( iVar0, 1 );
+    Lits[2] = toLitCond( iVar1, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+    (void)Cid;
+    return 3;
+}
+
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/lib/abcsat/abc/satStore.h b/lib/abcsat/abc/satStore.h
new file mode 100644
index 0000000..f2480a7
--- /dev/null
+++ b/lib/abcsat/abc/satStore.h
@@ -0,0 +1,158 @@
+/**CFile****************************************************************
+
+  FileName    [satStore.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Proof recording.]
+
+  Synopsis    [External declarations.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: pr.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+ 
+#ifndef ABC__sat__bsat__satStore_h
+#define ABC__sat__bsat__satStore_h
+
+
+/*
+    The trace of SAT solving contains the original clauses of the problem
+    along with the learned clauses derived during SAT solving.
+    The first line of the resulting file contains 3 numbers instead of 2:
+    c <num_vars> <num_all_clauses> <num_root_clauses>
+*/
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include "satSolver.h"
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+ABC_NAMESPACE_HEADER_START
+
+#ifdef _WIN32
+#define inline __inline // compatible with MS VS 6.0
+#endif
+
+#define STO_MAX(a,b)  ((a) > (b) ? (a) : (b))
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+/*
+typedef unsigned lit;
+// variable/literal conversions (taken from MiniSat)
+static inline lit   toLit    (int v)        { return v + v;  }
+static inline lit   toLitCond(int v, int c) { return v + v + (c != 0); }
+static inline lit   lit_neg  (lit l)        { return l ^ 1;  }
+static inline int   lit_var  (lit l)        { return l >> 1; }
+static inline int   lit_sign (lit l)        { return l & 1;  }
+static inline int   lit_print(lit l)        { return lit_sign(l)? -lit_var(l)-1 : lit_var(l)+1; }
+static inline lit   lit_read (int s)        { return s > 0 ? toLit(s-1) : lit_neg(toLit(-s-1)); }
+static inline int   lit_check(lit l, int n) { return l >= 0 && lit_var(l) < n;                  }
+*/
+
+typedef struct Sto_Cls_t_ Sto_Cls_t;
+struct Sto_Cls_t_
+{
+    Sto_Cls_t *     pNext;        // the next clause
+    Sto_Cls_t *     pNext0;       // the next 0-watch
+    Sto_Cls_t *     pNext1;       // the next 1-watch
+    int             Id;           // the clause ID
+    unsigned        fA     :  1;  // belongs to A
+    unsigned        fRoot  :  1;  // original clause
+    unsigned        fVisit :  1;  // visited clause
+    unsigned        nLits  : 24;  // the number of literals
+    lit             pLits[0];     // literals of this clause
+};
+
+typedef struct Sto_Man_t_ Sto_Man_t;
+struct Sto_Man_t_
+{
+    // general data
+    int             nVars;        // the number of variables
+    int             nRoots;       // the number of root clauses
+    int             nClauses;     // the number of all clauses
+    int             nClausesA;    // the number of clauses of A 
+    Sto_Cls_t *     pHead;        // the head clause
+    Sto_Cls_t *     pTail;        // the tail clause
+    Sto_Cls_t *     pEmpty;       // the empty clause
+    // memory management
+    int             nChunkSize;   // the number of bytes in a chunk
+    int             nChunkUsed;   // the number of bytes used in the last chunk
+    char *          pChunkLast;   // the last memory chunk
+};
+
+// iterators through the clauses
+#define Sto_ManForEachClause( p, pCls )      for( pCls = p->pHead; pCls; pCls = pCls->pNext )
+#define Sto_ManForEachClauseRoot( p, pCls )  for( pCls = p->pHead; pCls && pCls->fRoot; pCls = pCls->pNext )
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                    FUNCTION DECLARATIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/*=== satStore.c ==========================================================*/
+extern Sto_Man_t *  Sto_ManAlloc();
+extern void         Sto_ManFree( Sto_Man_t * p );
+extern int          Sto_ManAddClause( Sto_Man_t * p, lit * pBeg, lit * pEnd );
+extern int          Sto_ManMemoryReport( Sto_Man_t * p );
+extern void         Sto_ManMarkRoots( Sto_Man_t * p );
+extern void         Sto_ManMarkClausesA( Sto_Man_t * p );
+extern void         Sto_ManDumpClauses( Sto_Man_t * p, char * pFileName );
+extern int          Sto_ManChangeLastClause( Sto_Man_t * p );
+extern Sto_Man_t *  Sto_ManLoadClauses( char * pFileName );
+
+
+/*=== satInter.c ==========================================================*/
+typedef struct Int_Man_t_ Int_Man_t;
+extern Int_Man_t *  Int_ManAlloc();
+extern int *        Int_ManSetGlobalVars( Int_Man_t * p, int nGloVars );
+extern void         Int_ManFree( Int_Man_t * p );
+extern int          Int_ManInterpolate( Int_Man_t * p, Sto_Man_t * pCnf, int fVerbose, unsigned ** ppResult );
+
+/*=== satInterA.c ==========================================================*/
+typedef struct Inta_Man_t_ Inta_Man_t;
+extern Inta_Man_t * Inta_ManAlloc();
+extern void         Inta_ManFree( Inta_Man_t * p );
+extern void *       Inta_ManInterpolate( Inta_Man_t * p, Sto_Man_t * pCnf, abctime TimeToStop, void * vVarsAB, int fVerbose );
+
+/*=== satInterB.c ==========================================================*/
+typedef struct Intb_Man_t_ Intb_Man_t;
+extern Intb_Man_t * Intb_ManAlloc();
+extern void         Intb_ManFree( Intb_Man_t * p );
+extern void *       Intb_ManInterpolate( Intb_Man_t * p, Sto_Man_t * pCnf, void * vVarsAB, int fVerbose );
+
+/*=== satInterP.c ==========================================================*/
+typedef struct Intp_Man_t_ Intp_Man_t;
+extern Intp_Man_t * Intp_ManAlloc();
+extern void         Intp_ManFree( Intp_Man_t * p );
+extern void *       Intp_ManUnsatCore( Intp_Man_t * p, Sto_Man_t * pCnf, int fLearned, int fVerbose );
+extern void         Intp_ManUnsatCorePrintForBmc( FILE * pFile, Sto_Man_t * pCnf, void * vCore, void * vVarMap );
+
+
+ABC_NAMESPACE_HEADER_END
+
+
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
diff --git a/lib/abcsat/abc/satVec.h b/lib/abcsat/abc/satVec.h
new file mode 100644
index 0000000..120328e
--- /dev/null
+++ b/lib/abcsat/abc/satVec.h
@@ -0,0 +1,169 @@
+/**************************************************************************************************
+MiniSat -- Copyright (c) 2005, Niklas Sorensson
+http://www.cs.chalmers.se/Cs/Research/FormalMethods/MiniSat/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+// Modified to compile with MS Visual Studio 6.0 by Alan Mishchenko
+
+#ifndef ABC__sat__bsat__satVec_h
+#define ABC__sat__bsat__satVec_h
+
+#include <abc/abc_global.h>
+
+ABC_NAMESPACE_HEADER_START
+
+
+// vector of 32-bit intergers (added for 64-bit portability)
+struct veci_t {
+    int    cap;
+    int    size;
+    int*   ptr;
+};
+typedef struct veci_t veci;
+
+static inline void veci_new (veci* v) {
+    v->cap  = 4;
+    v->size = 0;
+    v->ptr  = (int*)ABC_ALLOC( char, sizeof(int)*v->cap);
+}
+
+static inline void   veci_delete (veci* v)          { ABC_FREE(v->ptr);   }
+static inline int*   veci_begin  (veci* v)          { return v->ptr;  }
+static inline int    veci_size   (veci* v)          { return v->size; }
+static inline void   veci_resize (veci* v, int k)   { 
+    assert(k <= v->size); 
+//    memset( veci_begin(v) + k, -1, sizeof(int) * (veci_size(v) - k) );
+    v->size = k;         
+} // only safe to shrink !!
+static inline int    veci_pop    (veci* v)          { assert(v->size); return v->ptr[--v->size]; }
+static inline void   veci_push   (veci* v, int e)
+{
+    if (v->size == v->cap) {
+//        int newsize = v->cap * 2;//+1;
+        int newsize = (v->cap < 4) ? v->cap * 2 : (v->cap / 2) * 3;
+        v->ptr = ABC_REALLOC( int, v->ptr, newsize );
+        if ( v->ptr == NULL )
+        {
+            printf( "Failed to realloc memory from %.1f MB to %.1f MB.\n", 
+                1.0 * v->cap / (1<<20), 1.0 * newsize / (1<<20) );
+            fflush( stdout );
+        }
+        v->cap = newsize; }
+    v->ptr[v->size++] = e;
+}
+static inline void   veci_remove(veci* v, int e)
+{
+    int * ws = (int*)veci_begin(v);
+    int    j  = 0;
+    for (; ws[j] != e  ; j++);
+    assert(j < veci_size(v));
+    for (; j < veci_size(v)-1; j++) ws[j] = ws[j+1];
+    veci_resize(v,veci_size(v)-1);
+}
+
+
+// vector of 32- or 64-bit pointers
+struct vecp_t {
+    int    cap;
+    int    size;
+    void** ptr;
+};
+typedef struct vecp_t vecp;
+
+static inline void vecp_new (vecp* v) {
+    v->size = 0;
+    v->cap  = 4;
+    v->ptr  = (void**)ABC_ALLOC( char, sizeof(void*)*v->cap);
+}
+
+static inline void   vecp_delete (vecp* v)          { ABC_FREE(v->ptr);   }
+static inline void** vecp_begin  (vecp* v)          { return v->ptr;  }
+static inline int    vecp_size   (vecp* v)          { return v->size; }
+static inline void   vecp_resize (vecp* v, int   k) { assert(k <= v->size); v->size = k;    } // only safe to shrink !!
+static inline void   vecp_push   (vecp* v, void* e)
+{
+    if (v->size == v->cap) {
+//        int newsize = v->cap * 2;//+1;
+        int newsize = (v->cap < 4) ? v->cap * 2 : (v->cap / 2) * 3;
+        v->ptr = ABC_REALLOC( void*, v->ptr, newsize );
+        v->cap = newsize; }
+    v->ptr[v->size++] = e;
+}
+static inline void   vecp_remove(vecp* v, void* e)
+{
+    void** ws = vecp_begin(v);
+    int    j  = 0;
+    for (; ws[j] != e  ; j++);
+    assert(j < vecp_size(v));
+    for (; j < vecp_size(v)-1; j++) ws[j] = ws[j+1];
+    vecp_resize(v,vecp_size(v)-1);
+}
+
+
+
+//=================================================================================================
+// Simple types:
+
+#ifndef __cplusplus
+#ifndef false
+#  define false 0
+#endif
+#ifndef true
+#  define true 1
+#endif
+#endif
+
+typedef int    lit;
+typedef int    cla;
+
+// Explicitly make it signed so promotion-to-int behavior doesn't vary
+// across platforms that define signedness of char differently.
+typedef signed char lbool;
+
+// CryptoMinisat defines it's own var_Undef values.
+// When it's included we prefer the ABC version instead.
+#ifdef var_Undef
+#undef var_Undef
+#endif
+
+static const int   var_Undef = -1;
+static const lit   lit_Undef = -2;
+
+static const lbool l_Undef   =  0;
+static const lbool l_True    =  1;
+static const lbool l_False   = -1;
+
+static inline lit  toLit    (int v)        { return v + v; }
+static inline lit  toLitCond(int v, int c) { return v + v + (c != 0); }
+static inline lit  lit_neg  (lit l)        { return l ^ 1; }
+static inline int  lit_var  (lit l)        { return l >> 1; }
+static inline int  lit_sign (lit l)        { return l & 1; }
+static inline int  lit_print(lit l)        { return lit_sign(l)? -lit_var(l)-1 : lit_var(l)+1; }
+static inline lit  lit_read (int s)        { return s > 0 ? toLit(s-1) : lit_neg(toLit(-s-1)); }
+static inline int  lit_check(lit l, int n) { return l >= 0 && lit_var(l) < n;                  }
+
+struct stats_t
+{
+    unsigned starts, clauses, learnts;
+    ABC_INT64_T decisions, propagations, inspects, conflicts;
+    ABC_INT64_T clauses_literals, learnts_literals, tot_literals;
+};
+typedef struct stats_t stats_t;
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/lib/abcsat/abc/system.h b/lib/abcsat/abc/system.h
new file mode 100644
index 0000000..9e6bf11
--- /dev/null
+++ b/lib/abcsat/abc/system.h
@@ -0,0 +1,68 @@
+/****************************************************************************************[System.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_System_h
+#define Glucose_System_h
+
+
+#include "IntTypes.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+//-------------------------------------------------------------------------------------------------
+
+namespace Gluco {
+
+static inline double cpuTime(void); // CPU-time in seconds.
+
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+//-------------------------------------------------------------------------------------------------
+// Implementation of inline functions:
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#include <time.h>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+static inline double Gluco::cpuTime(void) { return (double)clock() / CLOCKS_PER_SEC; }
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+
+#else
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <unistd.h>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+static inline double Gluco::cpuTime(void) {
+    struct rusage ru;
+    getrusage(RUSAGE_SELF, &ru);
+    return (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec / 1000000; }
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
+
+#endif
diff --git a/lib/abcsat/abc/utilDouble.h b/lib/abcsat/abc/utilDouble.h
new file mode 100644
index 0000000..877103b
--- /dev/null
+++ b/lib/abcsat/abc/utilDouble.h
@@ -0,0 +1,224 @@
+/**CFile****************************************************************
+
+  FileName    [utilDouble.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName []
+
+  Synopsis    [Double floating point number implementation.]
+
+  Author      [Alan Mishchenko, Bruno Schmitt]
+
+  Affiliation [UC Berkeley / UFRGS]
+
+  Date        [Ver. 1.0. Started - February 11, 2017.]
+
+  Revision    []
+
+***********************************************************************/
+
+#ifndef ABC__sat__Xdbl__Xdbl_h
+#define ABC__sat__Xdbl__Xdbl_h
+
+#include <abc/abc_global.h>
+
+ABC_NAMESPACE_HEADER_START
+
+////////////////////////////////////////////////////////////////////////
+///                    STRUCTURE DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/* 
+    The xdbl floating-point number is represented as a 64-bit unsigned int.
+    The number is (2^Exp)*Mnt, where Exp is a 16-bit exponent and Mnt is a 
+    48-bit mantissa.  The decimal point is located between the MSB of Mnt,
+    which is always 1, and the remaining 15 digits of Mnt.
+
+    Currently, only positive numbers are represented.
+
+    The range of possible values is [1.0; 2^(2^16-1)*1.111111111111111]
+    that is, the smallest possible number is 1.0 and the largest possible 
+    number is 2^(---16 ones---).(1.---47 ones---)
+
+    Comparison of numbers can be done by comparing the underlying unsigned ints.
+
+    Only addition, multiplication, and division by 2^n are currently implemented.
+*/
+
+typedef word xdbl;
+
+static inline word   Xdbl_Exp( xdbl a )                 { return a >> 48;           }
+static inline word   Xdbl_Mnt( xdbl a )                 { return (a << 16) >> 16;   }
+
+static inline xdbl   Xdbl_Create( word Exp, word Mnt )  { assert(!(Exp>>16) && (Mnt>>47)==(word)1); return (Exp<<48) | Mnt;  }
+
+static inline xdbl   Xdbl_Const1()                      { return Xdbl_Create( (word)0, (word)1 << 47 );                      }
+static inline xdbl   Xdbl_Const2()                      { return Xdbl_Create( (word)1, (word)1 << 47 );                      }
+static inline xdbl   Xdbl_Const3()                      { return Xdbl_Create( (word)1, (word)3 << 46 );                      }
+static inline xdbl   Xdbl_Const12()                     { return Xdbl_Create( (word)3, (word)3 << 46 );                      }
+static inline xdbl   Xdbl_Const1point5()                { return Xdbl_Create( (word)0, (word)3 << 46 );                      }
+static inline xdbl   Xdbl_Const2point5()                { return Xdbl_Create( (word)1, (word)5 << 45 );                      }
+static inline xdbl   Xdbl_Maximum()                     { return ~(word)0;                                                   }
+
+static inline double Xdbl_ToDouble( xdbl a )            { assert(Xdbl_Exp(a) < 1023); return Abc_Word2Dbl(((Xdbl_Exp(a) + 1023) << 52) | (((a<<17)>>17) << 5));                  }
+static inline xdbl   Xdbl_FromDouble( double a )        { word A = Abc_Dbl2Word(a); assert(a >= 1.0); return Xdbl_Create((A >> 52)-1023, (((word)1) << 47) | ((A << 12) >> 17)); }
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Adding two floating-point numbers.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline xdbl Xdbl_Add( xdbl a, xdbl b )
+{
+    word Exp, Mnt;
+    if ( a < b ) a ^= b, b ^= a, a ^= b;
+    assert( a >= b );
+    Mnt = Xdbl_Mnt(a) + (Xdbl_Mnt(b) >> (Xdbl_Exp(a) - Xdbl_Exp(b)));
+    Exp = Xdbl_Exp(a);
+    if ( Mnt >> 48 ) // new MSB is created
+        Exp++, Mnt >>= 1;
+    if ( Exp >> 16 ) // overflow
+        return Xdbl_Maximum();
+    return Xdbl_Create( Exp, Mnt );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Multiplying two floating-point numbers.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline xdbl Xdbl_Mul( xdbl a, xdbl b )
+{
+    word Exp, Mnt, MntA, MntB, MntAh, MntBh, MntAl, MntBl;
+    if ( a < b ) a ^= b, b ^= a, a ^= b;
+    assert( a >= b );
+    MntA  = Xdbl_Mnt(a);
+    MntB  = Xdbl_Mnt(b);
+    MntAh = MntA>>32;
+    MntBh = MntB>>32;
+    MntAl = (MntA<<32)>>32;
+    MntBl = (MntB<<32)>>32;
+    Mnt = ((MntAh * MntBh) << 17) + ((MntAl * MntBl) >> 47) + ((MntAl * MntBh) >> 15) + ((MntAh * MntBl) >> 15);
+    Exp = Xdbl_Exp(a) + Xdbl_Exp(b);
+    if ( Mnt >> 48 ) // new MSB is created
+        Exp++, Mnt >>= 1;
+    if ( Exp >> 16 ) // overflow
+        return Xdbl_Maximum();
+    return Xdbl_Create( Exp, Mnt );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Dividing floating point number by a degree of 2.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline xdbl Xdbl_Div( xdbl a, unsigned Deg2 )
+{
+    if ( Xdbl_Exp(a) >= (word)Deg2 )
+        return Xdbl_Create( Xdbl_Exp(a) - Deg2, Xdbl_Mnt(a) );
+    return Xdbl_Const1(); // underflow
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Testing procedure.]
+
+  Description [Helpful link https://www.h-schmidt.net/FloatConverter/IEEE754.html]
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Xdbl_Test()
+{
+    xdbl c1   = Xdbl_Const1();
+    xdbl c2   = Xdbl_Const2();
+    xdbl c3   = Xdbl_Const3();
+    xdbl c12  = Xdbl_Const12();
+    xdbl c1p5 = Xdbl_Const1point5();
+    xdbl c2p5 = Xdbl_Const2point5();
+
+    xdbl c1_   = Xdbl_FromDouble(1.0);
+    xdbl c2_   = Xdbl_FromDouble(2.0);
+    xdbl c3_   = Xdbl_FromDouble(3.0);
+    xdbl c12_  = Xdbl_FromDouble(12.0);
+    xdbl c1p5_ = Xdbl_FromDouble(1.5);
+    xdbl c2p5_ = Xdbl_FromDouble(2.5);
+
+    xdbl sum1 = Xdbl_Add(c1, c1p5);
+    xdbl mul1 = Xdbl_Mul(c2, c1p5);
+
+    xdbl sum2 = Xdbl_Add(c1p5, c2p5);
+    xdbl mul2 = Xdbl_Mul(c1p5, c2p5);
+
+    xdbl a    = Xdbl_FromDouble(1.2929725);
+    xdbl b    = Xdbl_FromDouble(10.28828287);
+    xdbl ab   = Xdbl_Mul(a, b);
+
+    xdbl ten100 = Xdbl_FromDouble( 1e100 );
+    xdbl ten100_ = ABC_CONST(0x014c924d692ca61b);
+
+    assert( ten100 == ten100_ );
+    (void)ten100;
+    (void)ten100_;
+
+//    float f1 = Xdbl_ToDouble(c1);
+//    Extra_PrintBinary( stdout, (int *)&c1, 32 ); printf( "\n" );
+//    Extra_PrintBinary( stdout, (int *)&f1, 32 ); printf( "\n" );
+
+    printf( "1 = %lf\n",   Xdbl_ToDouble(c1) );
+    printf( "2 = %lf\n",   Xdbl_ToDouble(c2) );
+    printf( "3 = %lf\n",   Xdbl_ToDouble(c3) );
+    printf( "12 = %lf\n",  Xdbl_ToDouble(c12) );
+    printf( "1.5 = %lf\n", Xdbl_ToDouble(c1p5) );
+    printf( "2.5 = %lf\n", Xdbl_ToDouble(c2p5) );
+
+    printf( "Converted 1 = %lf\n",   Xdbl_ToDouble(c1_) );
+    printf( "Converted 2 = %lf\n",   Xdbl_ToDouble(c2_) );
+    printf( "Converted 3 = %lf\n",   Xdbl_ToDouble(c3_) );
+    printf( "Converted 12 = %lf\n",  Xdbl_ToDouble(c12_) );
+    printf( "Converted 1.5 = %lf\n", Xdbl_ToDouble(c1p5_) );
+    printf( "Converted 2.5 = %lf\n", Xdbl_ToDouble(c2p5_) );
+
+    printf( "1.0 + 1.5 = %lf\n", Xdbl_ToDouble(sum1) );
+    printf( "2.0 * 1.5 = %lf\n", Xdbl_ToDouble(mul1) );
+
+    printf( "1.5 + 2.5 = %lf\n", Xdbl_ToDouble(sum2) );
+    printf( "1.5 * 2.5 = %lf\n", Xdbl_ToDouble(mul2) );
+    printf( "12 / 2^2  = %lf\n", Xdbl_ToDouble(Xdbl_Div(c12, 2)) );
+
+    printf( "12 / 2^2  = %lf\n", Xdbl_ToDouble(Xdbl_Div(c12, 2)) );
+
+    printf( "%.16lf * %.16lf = %.16lf (%.16lf)\n", Xdbl_ToDouble(a), Xdbl_ToDouble(b), Xdbl_ToDouble(ab), 1.2929725 * 10.28828287 );
+
+    assert( sum1 == c2p5 );
+    assert( mul1 == c3 );
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/lib/abcsat/abc/vecInt.h b/lib/abcsat/abc/vecInt.h
new file mode 100644
index 0000000..b8f8e20
--- /dev/null
+++ b/lib/abcsat/abc/vecInt.h
@@ -0,0 +1,2087 @@
+/**CFile****************************************************************
+
+  FileName    [vecInt.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Resizable arrays.]
+
+  Synopsis    [Resizable arrays of integers.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: vecInt.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+ 
+#ifndef ABC__misc__vec__vecInt_h
+#define ABC__misc__vec__vecInt_h
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4244) // warning C4244: '+=' : conversion from 'int ' to 'unsigned short ', possible loss of data
+#endif
+
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include <stdio.h>
+
+ABC_NAMESPACE_HEADER_START
+
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct Vec_Int_t_       Vec_Int_t;
+struct Vec_Int_t_ 
+{
+    int              nCap;
+    int              nSize;
+    int *            pArray;
+};
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+#define Vec_IntForEachEntry( vVec, Entry, i )                                               \
+    for ( i = 0; (i < Vec_IntSize(vVec)) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ )
+#define Vec_IntForEachEntryStart( vVec, Entry, i, Start )                                   \
+    for ( i = Start; (i < Vec_IntSize(vVec)) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ )
+#define Vec_IntForEachEntryStop( vVec, Entry, i, Stop )                                     \
+    for ( i = 0; (i < Stop) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ )
+#define Vec_IntForEachEntryStartStop( vVec, Entry, i, Start, Stop )                         \
+    for ( i = Start; (i < Stop) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ )
+#define Vec_IntForEachEntryReverse( vVec, pEntry, i )                                       \
+    for ( i = Vec_IntSize(vVec) - 1; (i >= 0) && (((pEntry) = Vec_IntEntry(vVec, i)), 1); i-- )
+#define Vec_IntForEachEntryTwo( vVec1, vVec2, Entry1, Entry2, i )                           \
+    for ( i = 0; (i < Vec_IntSize(vVec1)) && (((Entry1) = Vec_IntEntry(vVec1, i)), 1) && (((Entry2) = Vec_IntEntry(vVec2, i)), 1); i++ )
+#define Vec_IntForEachEntryDouble( vVec, Entry1, Entry2, i )                                \
+    for ( i = 0; (i+1 < Vec_IntSize(vVec)) && (((Entry1) = Vec_IntEntry(vVec, i)), 1) && (((Entry2) = Vec_IntEntry(vVec, i+1)), 1); i += 2 )
+#define Vec_IntForEachEntryDoubleStart( vVec, Entry1, Entry2, i, Start )                    \
+    for ( i = Start; (i+1 < Vec_IntSize(vVec)) && (((Entry1) = Vec_IntEntry(vVec, i)), 1) && (((Entry2) = Vec_IntEntry(vVec, i+1)), 1); i += 2 )
+#define Vec_IntForEachEntryTriple( vVec, Entry1, Entry2, Entry3, i )                        \
+    for ( i = 0; (i+2 < Vec_IntSize(vVec)) && (((Entry1) = Vec_IntEntry(vVec, i)), 1) && (((Entry2) = Vec_IntEntry(vVec, i+1)), 1) && (((Entry3) = Vec_IntEntry(vVec, i+2)), 1); i += 3 )
+#define Vec_IntForEachEntryThisNext( vVec, This, Next, i )                                  \
+    for ( i = 0, (This) = (Next) = (Vec_IntSize(vVec) ? Vec_IntEntry(vVec, 0) : -1); (i+1 < Vec_IntSize(vVec)) && (((Next) = Vec_IntEntry(vVec, i+1)), 1); i += 2, (This) = (Next) )
+#define Vec_IntForEachEntryInVec( vVec2, vVec, Entry, i )                                   \
+    for ( i = 0; (i < Vec_IntSize(vVec)) && (((Entry) = Vec_IntEntry(vVec2, Vec_IntEntry(vVec, i))), 1); i++ )
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates a vector with the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntAlloc( int nCap )
+{
+    Vec_Int_t * p;
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    if ( nCap > 0 && nCap < 16 )
+        nCap = 16;
+    p->nSize  = 0;
+    p->nCap   = nCap;
+    p->pArray = p->nCap? ABC_ALLOC( int, p->nCap ) : NULL;
+    return p;
+}
+static inline Vec_Int_t * Vec_IntAllocExact( int nCap )
+{
+    Vec_Int_t * p;
+    assert( nCap >= 0 );
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    p->nSize  = 0;
+    p->nCap   = nCap;
+    p->pArray = p->nCap? ABC_ALLOC( int, p->nCap ) : NULL;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates a vector with the given size and cleans it.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntStart( int nSize )
+{
+    Vec_Int_t * p;
+    p = Vec_IntAlloc( nSize );
+    p->nSize = nSize;
+    memset( p->pArray, 0, sizeof(int) * nSize );
+    return p;
+}
+static inline Vec_Int_t * Vec_IntStartFull( int nSize )
+{
+    Vec_Int_t * p;
+    p = Vec_IntAlloc( nSize );
+    p->nSize = nSize;
+    memset( p->pArray, 0xff, sizeof(int) * nSize );
+    return p;
+}
+static inline Vec_Int_t * Vec_IntStartRange( int First, int Range )
+{
+    Vec_Int_t * p;
+    int i;
+    p = Vec_IntAlloc( Range );
+    p->nSize = Range;
+    for ( i = 0; i < Range; i++ )
+        p->pArray[i] = First + i;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates a vector with the given size and cleans it.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntStartNatural( int nSize )
+{
+    Vec_Int_t * p;
+    int i;
+    p = Vec_IntAlloc( nSize );
+    p->nSize = nSize;
+    for ( i = 0; i < nSize; i++ )
+        p->pArray[i] = i;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Creates the vector from an integer array of the given size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntAllocArray( int * pArray, int nSize )
+{
+    Vec_Int_t * p;
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    p->nSize  = nSize;
+    p->nCap   = nSize;
+    p->pArray = pArray;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Creates the vector from an integer array of the given size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntAllocArrayCopy( int * pArray, int nSize )
+{
+    Vec_Int_t * p;
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    p->nSize  = nSize;
+    p->nCap   = nSize;
+    p->pArray = ABC_ALLOC( int, nSize );
+    memcpy( p->pArray, pArray, sizeof(int) * nSize );
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Duplicates the integer array.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntDup( Vec_Int_t * pVec )
+{
+    Vec_Int_t * p;
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    p->nSize  = pVec->nSize;
+    p->nCap   = pVec->nSize;
+    p->pArray = p->nCap? ABC_ALLOC( int, p->nCap ) : NULL;
+    memcpy( p->pArray, pVec->pArray, sizeof(int) * pVec->nSize );
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Transfers the array into another vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntDupArray( Vec_Int_t * pVec )
+{
+    Vec_Int_t * p;
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    p->nSize  = pVec->nSize;
+    p->nCap   = pVec->nCap;
+    p->pArray = pVec->pArray;
+    pVec->nSize  = 0;
+    pVec->nCap   = 0;
+    pVec->pArray = NULL;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntZero( Vec_Int_t * p )
+{
+    p->pArray = NULL;
+    p->nSize = 0;
+    p->nCap = 0;
+}
+static inline void Vec_IntErase( Vec_Int_t * p )
+{
+    ABC_FREE( p->pArray );
+    p->nSize = 0;
+    p->nCap = 0;
+}
+static inline void Vec_IntFree( Vec_Int_t * p )
+{
+    ABC_FREE( p->pArray );
+    ABC_FREE( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntFreeP( Vec_Int_t ** p )
+{
+    if ( *p == NULL )
+        return;
+    ABC_FREE( (*p)->pArray );
+    ABC_FREE( (*p) );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int * Vec_IntReleaseArray( Vec_Int_t * p )
+{
+    int * pArray = p->pArray;
+    p->nCap = 0;
+    p->nSize = 0;
+    p->pArray = NULL;
+    return pArray;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int * Vec_IntArray( Vec_Int_t * p )
+{
+    return p->pArray;
+}
+static inline int ** Vec_IntArrayP( Vec_Int_t * p )
+{
+    return &p->pArray;
+}
+static inline int * Vec_IntLimit( Vec_Int_t * p )
+{
+    return p->pArray + p->nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntSize( Vec_Int_t * p )
+{
+    return p->nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntCap( Vec_Int_t * p )
+{
+    return p->nCap;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline double Vec_IntMemory( Vec_Int_t * p )
+{
+    return !p ? 0.0 : 1.0 * sizeof(int) * p->nCap + sizeof(Vec_Int_t) ;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntEntry( Vec_Int_t * p, int i )
+{
+    assert( i >= 0 && i < p->nSize );
+    return p->pArray[i];
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int * Vec_IntEntryP( Vec_Int_t * p, int i )
+{
+    assert( i >= 0 && i < p->nSize );
+    return p->pArray + i;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntWriteEntry( Vec_Int_t * p, int i, int Entry )
+{
+    assert( i >= 0 && i < p->nSize );
+    p->pArray[i] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntAddToEntry( Vec_Int_t * p, int i, int Addition )
+{
+    assert( i >= 0 && i < p->nSize );
+    return p->pArray[i] += Addition;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntUpdateEntry( Vec_Int_t * p, int i, int Value )
+{
+    if ( Vec_IntEntry( p, i ) < Value )
+        Vec_IntWriteEntry( p, i, Value );
+}
+static inline void Vec_IntDowndateEntry( Vec_Int_t * p, int i, int Value )
+{
+    if ( Vec_IntEntry( p, i ) > Value )
+        Vec_IntWriteEntry( p, i, Value );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntEntryLast( Vec_Int_t * p )
+{
+    assert( p->nSize > 0 );
+    return p->pArray[p->nSize-1];
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Resizes the vector to the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntGrow( Vec_Int_t * p, int nCapMin )
+{
+    if ( p->nCap >= nCapMin )
+        return;
+    p->pArray = ABC_REALLOC( int, p->pArray, nCapMin ); 
+    assert( p->pArray );
+    p->nCap   = nCapMin;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Resizes the vector to the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntGrowResize( Vec_Int_t * p, int nCapMin )
+{
+    p->nSize  = nCapMin;
+    if ( p->nCap >= nCapMin )
+        return;
+    p->pArray = ABC_REALLOC( int, p->pArray, nCapMin ); 
+    assert( p->pArray );
+    p->nCap   = nCapMin;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Fills the vector with given number of entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntFill( Vec_Int_t * p, int nSize, int Fill )
+{
+    int i;
+    Vec_IntGrow( p, nSize );
+    for ( i = 0; i < nSize; i++ )
+        p->pArray[i] = Fill;
+    p->nSize = nSize;
+}
+static inline void Vec_IntFillTwo( Vec_Int_t * p, int nSize, int FillEven, int FillOdd )
+{
+    int i;
+    Vec_IntGrow( p, nSize );
+    for ( i = 0; i < nSize; i++ )
+        p->pArray[i] = (i & 1) ? FillOdd : FillEven;
+    p->nSize = nSize;
+}
+static inline void Vec_IntFillNatural( Vec_Int_t * p, int nSize )
+{
+    int i;
+    Vec_IntGrow( p, nSize );
+    for ( i = 0; i < nSize; i++ )
+        p->pArray[i] = i;
+    p->nSize = nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Fills the vector with given number of entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntFillExtra( Vec_Int_t * p, int nSize, int Fill )
+{
+    int i;
+    if ( nSize <= p->nSize )
+        return;
+    if ( nSize > 2 * p->nCap )
+        Vec_IntGrow( p, nSize );
+    else if ( nSize > p->nCap )
+        Vec_IntGrow( p, 2 * p->nCap );
+    for ( i = p->nSize; i < nSize; i++ )
+        p->pArray[i] = Fill;
+    p->nSize = nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the entry even if the place not exist.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntGetEntry( Vec_Int_t * p, int i )
+{
+    Vec_IntFillExtra( p, i + 1, 0 );
+    return Vec_IntEntry( p, i );
+}
+static inline int Vec_IntGetEntryFull( Vec_Int_t * p, int i )
+{
+    Vec_IntFillExtra( p, i + 1, -1 );
+    return Vec_IntEntry( p, i );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the entry even if the place not exist.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int * Vec_IntGetEntryP( Vec_Int_t * p, int i )
+{
+    Vec_IntFillExtra( p, i + 1, 0 );
+    return Vec_IntEntryP( p, i );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the entry even if the place does not exist.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntSetEntry( Vec_Int_t * p, int i, int Entry )
+{
+    Vec_IntFillExtra( p, i + 1, 0 );
+    Vec_IntWriteEntry( p, i, Entry );
+}
+static inline void Vec_IntSetEntryFull( Vec_Int_t * p, int i, int Entry )
+{
+    Vec_IntFillExtra( p, i + 1, -1 );
+    Vec_IntWriteEntry( p, i, Entry );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntShrink( Vec_Int_t * p, int nSizeNew )
+{
+    assert( p->nSize >= nSizeNew );
+    p->nSize = nSizeNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntClear( Vec_Int_t * p )
+{
+    p->nSize = 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntPush( Vec_Int_t * p, int Entry )
+{
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_IntGrow( p, 16 );
+        else
+            Vec_IntGrow( p, 2 * p->nCap );
+    }
+    p->pArray[p->nSize++] = Entry;
+}
+static inline void Vec_IntPushTwo( Vec_Int_t * p, int Entry1, int Entry2 )
+{
+    Vec_IntPush( p, Entry1 );
+    Vec_IntPush( p, Entry2 );
+}
+static inline void Vec_IntPushThree( Vec_Int_t * p, int Entry1, int Entry2, int Entry3 )
+{
+    Vec_IntPush( p, Entry1 );
+    Vec_IntPush( p, Entry2 );
+    Vec_IntPush( p, Entry3 );
+}
+static inline void Vec_IntPushFour( Vec_Int_t * p, int Entry1, int Entry2, int Entry3, int Entry4 )
+{
+    Vec_IntPush( p, Entry1 );
+    Vec_IntPush( p, Entry2 );
+    Vec_IntPush( p, Entry3 );
+    Vec_IntPush( p, Entry4 );
+}
+static inline void Vec_IntPushArray( Vec_Int_t * p, int * pEntries, int nEntries )
+{
+    int i;
+    for ( i = 0; i < nEntries; i++ )
+        Vec_IntPush( p, pEntries[i] );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntPushFirst( Vec_Int_t * p, int Entry )
+{
+    int i;
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_IntGrow( p, 16 );
+        else
+            Vec_IntGrow( p, 2 * p->nCap );
+    }
+    p->nSize++;
+    for ( i = p->nSize - 1; i >= 1; i-- )
+        p->pArray[i] = p->pArray[i-1];
+    p->pArray[0] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the entry while preserving the increasing order.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntPushOrder( Vec_Int_t * p, int Entry )
+{
+    int i;
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_IntGrow( p, 16 );
+        else
+            Vec_IntGrow( p, 2 * p->nCap );
+    }
+    p->nSize++;
+    for ( i = p->nSize-2; i >= 0; i-- )
+        if ( p->pArray[i] > Entry )
+            p->pArray[i+1] = p->pArray[i];
+        else
+            break;
+    p->pArray[i+1] = Entry;
+}
+static inline void Vec_IntPushOrderCost( Vec_Int_t * p, int Entry, Vec_Int_t * vCost )
+{
+    int i;
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_IntGrow( p, 16 );
+        else
+            Vec_IntGrow( p, 2 * p->nCap );
+    }
+    p->nSize++;
+    for ( i = p->nSize-2; i >= 0; i-- )
+        if ( Vec_IntEntry(vCost, p->pArray[i]) > Vec_IntEntry(vCost, Entry) )
+            p->pArray[i+1] = p->pArray[i];
+        else
+            break;
+    p->pArray[i+1] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the entry while preserving the increasing order.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntPushOrderReverse( Vec_Int_t * p, int Entry )
+{
+    int i;
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_IntGrow( p, 16 );
+        else
+            Vec_IntGrow( p, 2 * p->nCap );
+    }
+    p->nSize++;
+    for ( i = p->nSize-2; i >= 0; i-- )
+        if ( p->pArray[i] < Entry )
+            p->pArray[i+1] = p->pArray[i];
+        else
+            break;
+    p->pArray[i+1] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the entry while preserving the increasing order.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntPushUniqueOrder( Vec_Int_t * p, int Entry )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            return 1;
+    Vec_IntPushOrder( p, Entry );
+    return 0;
+}
+static inline int Vec_IntPushUniqueOrderCost( Vec_Int_t * p, int Entry, Vec_Int_t * vCost )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            return 1;
+    Vec_IntPushOrderCost( p, Entry, vCost );
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntPushUnique( Vec_Int_t * p, int Entry )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            return 1;
+    Vec_IntPush( p, Entry );
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the pointer to the next nWords entries in the vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline unsigned * Vec_IntFetch( Vec_Int_t * p, int nWords )
+{
+    if ( nWords == 0 )
+        return NULL;
+    assert( nWords > 0 );
+    p->nSize += nWords;
+    if ( p->nSize > p->nCap )
+    {
+//         Vec_IntGrow( p, 2 * p->nSize );
+        return NULL;
+    }
+    return ((unsigned *)p->pArray) + p->nSize - nWords;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the last entry and removes it from the list.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntPop( Vec_Int_t * p )
+{
+    assert( p->nSize > 0 );
+    return p->pArray[--p->nSize];
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Find entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntFind( Vec_Int_t * p, int Entry )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            return i;
+    return -1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntRemove( Vec_Int_t * p, int Entry )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            break;
+    if ( i == p->nSize )
+        return 0;
+    assert( i < p->nSize );
+    for ( i++; i < p->nSize; i++ )
+        p->pArray[i-1] = p->pArray[i];
+    p->nSize--;
+    return 1;
+}
+static inline int Vec_IntRemove1( Vec_Int_t * p, int Entry )
+{
+    int i;
+    for ( i = 1; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            break;
+    if ( i >= p->nSize )
+        return 0;
+    assert( i < p->nSize );
+    for ( i++; i < p->nSize; i++ )
+        p->pArray[i-1] = p->pArray[i];
+    p->nSize--;
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntDrop( Vec_Int_t * p, int i )
+{
+    int k;
+    assert( i >= 0 && i < Vec_IntSize(p) );
+    p->nSize--;
+    for ( k = i; k < p->nSize; k++ )
+        p->pArray[k] = p->pArray[k+1];
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Interts entry at the index iHere. Shifts other entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntInsert( Vec_Int_t * p, int iHere, int Entry )
+{
+    int i;
+    assert( iHere >= 0 && iHere <= p->nSize );
+    Vec_IntPush( p, 0 );
+    for ( i = p->nSize - 1; i > iHere; i-- )
+        p->pArray[i] = p->pArray[i-1];
+    p->pArray[i] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Find entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntFindMax( Vec_Int_t * p )
+{
+    int i, Best;
+    if ( p->nSize == 0 )
+        return 0;
+    Best = p->pArray[0];
+    for ( i = 1; i < p->nSize; i++ )
+        if ( Best < p->pArray[i] )
+            Best = p->pArray[i];
+    return Best;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Find entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntFindMin( Vec_Int_t * p )
+{
+    int i, Best;
+    if ( p->nSize == 0 )
+        return 0;
+    Best = p->pArray[0];
+    for ( i = 1; i < p->nSize; i++ )
+        if ( Best > p->pArray[i] )
+            Best = p->pArray[i];
+    return Best;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Reverses the order of entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntReverseOrder( Vec_Int_t * p )
+{
+    int i, Temp;
+    for ( i = 0; i < p->nSize/2; i++ )
+    {
+        Temp = p->pArray[i];
+        p->pArray[i] = p->pArray[p->nSize-1-i];
+        p->pArray[p->nSize-1-i] = Temp;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Removes odd entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntRemoveOdd( Vec_Int_t * p )
+{
+    int i;
+    assert( (p->nSize & 1) == 0 );
+    p->nSize >>= 1;
+    for ( i = 0; i < p->nSize; i++ )
+        p->pArray[i] = p->pArray[2*i];
+}
+static inline void Vec_IntRemoveEven( Vec_Int_t * p )
+{
+    int i;
+    assert( (p->nSize & 1) == 0 );
+    p->nSize >>= 1;
+    for ( i = 0; i < p->nSize; i++ )
+        p->pArray[i] = p->pArray[2*i+1];
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntInvert( Vec_Int_t * p, int Fill ) 
+{
+    int Entry, i;
+    Vec_Int_t * vRes = Vec_IntAlloc( 0 );
+    if ( Vec_IntSize(p) == 0 )
+        return vRes;
+    Vec_IntFill( vRes, Vec_IntFindMax(p) + 1, Fill );
+    Vec_IntForEachEntry( p, Entry, i )
+        if ( Entry != Fill )
+            Vec_IntWriteEntry( vRes, Entry, i );
+    return vRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntCondense( Vec_Int_t * p, int Fill ) 
+{
+    int Entry, i;
+    Vec_Int_t * vRes = Vec_IntAlloc( Vec_IntSize(p) );
+    Vec_IntForEachEntry( p, Entry, i )
+        if ( Entry != Fill )
+            Vec_IntPush( vRes, Entry );
+    return vRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntSum( Vec_Int_t * p ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += p->pArray[i];
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntCountEntry( Vec_Int_t * p, int Entry ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += (p->pArray[i] == Entry);
+    return Counter;
+}
+static inline int Vec_IntCountLarger( Vec_Int_t * p, int Entry ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += (p->pArray[i] > Entry);
+    return Counter;
+}
+static inline int Vec_IntCountSmaller( Vec_Int_t * p, int Entry ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += (p->pArray[i] < Entry);
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntCountPositive( Vec_Int_t * p ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += (p->pArray[i] > 0);
+    return Counter;
+}
+static inline int Vec_IntCountZero( Vec_Int_t * p ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += (p->pArray[i] == 0);
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Checks if two vectors are equal.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntEqual( Vec_Int_t * p1, Vec_Int_t * p2 ) 
+{
+    int i;
+    if ( p1->nSize != p2->nSize )
+        return 0;
+    for ( i = 0; i < p1->nSize; i++ )
+        if ( p1->pArray[i] != p2->pArray[i] )
+            return 0;
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Counts the number of common entries.]
+
+  Description [Assumes that the entries are non-negative integers that
+  are not very large, so inversion of the array can be performed.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntCountCommon( Vec_Int_t * p1, Vec_Int_t * p2 ) 
+{
+    Vec_Int_t * vTemp;
+    int Entry, i, Counter = 0;
+    if ( Vec_IntSize(p1) < Vec_IntSize(p2) )
+        vTemp = p1, p1 = p2, p2 = vTemp;
+    assert( Vec_IntSize(p1) >= Vec_IntSize(p2) );
+    vTemp = Vec_IntInvert( p2, -1 );
+    Vec_IntFillExtra( vTemp, Vec_IntFindMax(p1) + 1, -1 );
+    Vec_IntForEachEntry( p1, Entry, i )
+        if ( Vec_IntEntry(vTemp, Entry) >= 0 )
+            Counter++;
+    Vec_IntFree( vTemp );
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Comparison procedure for two integers.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Vec_IntSortCompare1( int * pp1, int * pp2 )
+{
+    // for some reason commenting out lines (as shown) led to crashing of the release version
+    if ( *pp1 < *pp2 )
+        return -1;
+    if ( *pp1 > *pp2 ) //
+        return 1;
+    return 0; //
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Comparison procedure for two integers.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Vec_IntSortCompare2( int * pp1, int * pp2 )
+{
+    // for some reason commenting out lines (as shown) led to crashing of the release version
+    if ( *pp1 > *pp2 )
+        return -1;
+    if ( *pp1 < *pp2 ) //
+        return 1;
+    return 0; //
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting the entries by their integer value.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntSort( Vec_Int_t * p, int fReverse )
+{
+    if ( fReverse ) 
+        qsort( (void *)p->pArray, p->nSize, sizeof(int), 
+                (int (*)(const void *, const void *)) Vec_IntSortCompare2 );
+    else
+        qsort( (void *)p->pArray, p->nSize, sizeof(int), 
+                (int (*)(const void *, const void *)) Vec_IntSortCompare1 );
+}
+static inline void Vec_IntSortMulti( Vec_Int_t * p, int nMulti, int fReverse )
+{
+    assert( Vec_IntSize(p) % nMulti == 0 );
+    if ( fReverse ) 
+        qsort( (void *)p->pArray, p->nSize/nMulti, nMulti*sizeof(int), 
+                (int (*)(const void *, const void *)) Vec_IntSortCompare2 );
+    else
+        qsort( (void *)p->pArray, p->nSize/nMulti, nMulti*sizeof(int), 
+                (int (*)(const void *, const void *)) Vec_IntSortCompare1 );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Leaves only unique entries.]
+
+  Description [Returns the number of duplicated entried found.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntUniqify( Vec_Int_t * p )
+{
+    int i, k, RetValue;
+    if ( p->nSize < 2 )
+        return 0;
+    Vec_IntSort( p, 0 );
+    for ( i = k = 1; i < p->nSize; i++ )
+        if ( p->pArray[i] != p->pArray[i-1] )
+            p->pArray[k++] = p->pArray[i];
+    RetValue = p->nSize - k;
+    p->nSize = k;
+    return RetValue;
+}
+static inline int Vec_IntCountDuplicates( Vec_Int_t * p )
+{
+    int RetValue;
+    Vec_Int_t * pDup = Vec_IntDup( p );
+    Vec_IntUniqify( pDup );
+    RetValue = Vec_IntSize(p) - Vec_IntSize(pDup);
+    Vec_IntFree( pDup );
+    return RetValue;
+}
+static inline int Vec_IntCheckUniqueSmall( Vec_Int_t * p )
+{
+    int i, k;
+    for ( i = 0; i < p->nSize; i++ )
+        for ( k = i+1; k < p->nSize; k++ )
+            if ( p->pArray[i] == p->pArray[k] )
+                return 0;
+    return 1;
+}
+static inline int Vec_IntCountUnique( Vec_Int_t * p )
+{
+    int i, Count = 0, Max = Vec_IntFindMax(p);
+    unsigned char * pPres = ABC_CALLOC( unsigned char, Max+1 );
+    for ( i = 0; i < p->nSize; i++ )
+        if ( pPres[p->pArray[i]] == 0 )
+            pPres[p->pArray[i]] = 1, Count++;
+    ABC_FREE( pPres );
+    return Count;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Counts the number of unique pairs.]
+
+  Description []
+               
+  SideEffects [] 
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntUniqifyPairs( Vec_Int_t * p )
+{
+    int i, k, RetValue;
+    assert( p->nSize % 2 == 0 );
+    if ( p->nSize < 4 )
+        return 0;
+    Vec_IntSortMulti( p, 2, 0 );
+    for ( i = k = 1; i < p->nSize/2; i++ )
+        if ( p->pArray[2*i] != p->pArray[2*(i-1)] || p->pArray[2*i+1] != p->pArray[2*(i-1)+1] )
+        {
+            p->pArray[2*k]   = p->pArray[2*i];
+            p->pArray[2*k+1] = p->pArray[2*i+1];
+            k++;
+        }
+    RetValue = p->nSize/2 - k;
+    p->nSize = 2*k;
+    return RetValue;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Counts the number of unique entries.]
+
+  Description []
+               
+  SideEffects [] 
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline unsigned Vec_IntUniqueHashKeyDebug( unsigned char * pStr, int nChars, int TableMask )
+{
+    static unsigned s_BigPrimes[4] = {12582917, 25165843, 50331653, 100663319};
+    unsigned Key = 0; int c;
+    for ( c = 0; c < nChars; c++ )
+    {
+        Key += (unsigned)pStr[c] * s_BigPrimes[c & 3];
+        printf( "%d : ", c );
+        printf( "%3d  ", pStr[c] );
+        printf( "%12u ", Key );
+        printf( "%12u ", Key&TableMask );
+        printf( "\n" );
+    }
+    return Key;
+}
+static inline void Vec_IntUniqueProfile( Vec_Int_t * vData, int * pTable, int * pNexts, int TableMask, int nIntSize )
+{
+    int i, Key, Counter;
+    for ( i = 0; i <= TableMask; i++ )
+    {
+        Counter = 0;
+        for ( Key = pTable[i]; Key != -1; Key = pNexts[Key] )
+            Counter++;
+        if ( Counter < 7 )
+            continue;
+        printf( "%d\n", Counter );
+        for ( Key = pTable[i]; Key != -1; Key = pNexts[Key] )
+        {
+//            Extra_PrintBinary( stdout, (unsigned *)Vec_IntEntryP(vData, Key*nIntSize), 40 ), printf( "\n" );
+//            Vec_IntUniqueHashKeyDebug( (unsigned char *)Vec_IntEntryP(vData, Key*nIntSize), 4*nIntSize, TableMask );
+        }
+    }
+    printf( "\n" );
+}
+
+static inline unsigned Vec_IntUniqueHashKey2( unsigned char * pStr, int nChars )
+{
+    static unsigned s_BigPrimes[4] = {12582917, 25165843, 50331653, 100663319};
+    unsigned Key = 0; int c;
+    for ( c = 0; c < nChars; c++ )
+        Key += (unsigned)pStr[c] * s_BigPrimes[c & 3];
+    return Key;
+}
+
+static inline unsigned Vec_IntUniqueHashKey( unsigned char * pStr, int nChars )
+{
+    static unsigned s_BigPrimes[16] = 
+    {
+        0x984b6ad9,0x18a6eed3,0x950353e2,0x6222f6eb,0xdfbedd47,0xef0f9023,0xac932a26,0x590eaf55,
+        0x97d0a034,0xdc36cd2e,0x22736b37,0xdc9066b0,0x2eb2f98b,0x5d9c7baf,0x85747c9e,0x8aca1055
+    };
+    static unsigned s_BigPrimes2[16] = 
+    {
+        0x8d8a5ebe,0x1e6a15dc,0x197d49db,0x5bab9c89,0x4b55dea7,0x55dede49,0x9a6a8080,0xe5e51035,
+        0xe148d658,0x8a17eb3b,0xe22e4b38,0xe5be2a9a,0xbe938cbb,0x3b981069,0x7f9c0c8e,0xf756df10
+    };
+    unsigned Key = 0; int c;
+    for ( c = 0; c < nChars; c++ )
+        Key += s_BigPrimes2[(2*c)&15]   * s_BigPrimes[(unsigned)pStr[c] & 15] +
+               s_BigPrimes2[(2*c+1)&15] * s_BigPrimes[(unsigned)pStr[c] >> 4];
+    return Key;
+}
+static inline int * Vec_IntUniqueLookup( Vec_Int_t * vData, int i, int nIntSize, int * pNexts, int * pStart )
+{
+    int * pData = Vec_IntEntryP( vData, i*nIntSize );
+    for ( ; *pStart != -1; pStart = pNexts + *pStart )
+        if ( !memcmp( pData, Vec_IntEntryP(vData, *pStart*nIntSize), sizeof(int) * nIntSize ) )
+            return pStart;
+    return pStart;
+}
+static inline int Vec_IntUniqueCount( Vec_Int_t * vData, int nIntSize, Vec_Int_t ** pvMap )
+{
+    int nEntries  = Vec_IntSize(vData) / nIntSize;
+    int TableMask = (1 << pabc::Abc_Base2Log(nEntries)) - 1;
+    int * pTable  = ABC_FALLOC( int, TableMask+1 );
+    int * pNexts  = ABC_FALLOC( int, TableMask+1 );
+    int * pClass  = ABC_ALLOC( int, nEntries );
+    int i, Key, * pEnt, nUnique = 0;
+    assert( nEntries * nIntSize == Vec_IntSize(vData) );
+    for ( i = 0; i < nEntries; i++ )
+    {
+        pEnt = Vec_IntEntryP( vData, i*nIntSize );
+        Key  = TableMask & Vec_IntUniqueHashKey( (unsigned char *)pEnt, 4*nIntSize );
+        pEnt = Vec_IntUniqueLookup( vData, i, nIntSize, pNexts, pTable+Key );
+        if ( *pEnt == -1 )
+            *pEnt = i, nUnique++;
+        pClass[i] = *pEnt;
+    }
+//    Vec_IntUniqueProfile( vData, pTable, pNexts, TableMask, nIntSize );
+    ABC_FREE( pTable );
+    ABC_FREE( pNexts );
+    if ( pvMap )
+        *pvMap = Vec_IntAllocArray( pClass, nEntries );
+    else
+        ABC_FREE( pClass );
+    return nUnique;
+}
+static inline Vec_Int_t * Vec_IntUniqifyHash( Vec_Int_t * vData, int nIntSize )
+{
+    Vec_Int_t * vMap, * vUnique;
+    int i, Ent, nUnique = Vec_IntUniqueCount( vData, nIntSize, &vMap );
+    vUnique = Vec_IntAlloc( nUnique * nIntSize );
+    Vec_IntForEachEntry( vMap, Ent, i )
+    {
+        if ( Ent < i ) continue;
+        assert( Ent == i );
+        Vec_IntPushArray( vUnique, Vec_IntEntryP(vData, i*nIntSize), nIntSize );
+    }
+    assert( Vec_IntSize(vUnique) == nUnique * nIntSize );
+    Vec_IntFree( vMap );
+    return vUnique;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Comparison procedure for two integers.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntSortCompareUnsigned( unsigned * pp1, unsigned * pp2 )
+{
+    if ( *pp1 < *pp2 )
+        return -1;
+    if ( *pp1 > *pp2 )
+        return 1;
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting the entries by their integer value.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntSortUnsigned( Vec_Int_t * p )
+{
+    qsort( (void *)p->pArray, p->nSize, sizeof(int), 
+            (int (*)(const void *, const void *)) Vec_IntSortCompareUnsigned );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the number of common entries.]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntTwoCountCommon( Vec_Int_t * vArr1, Vec_Int_t * vArr2 )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    int Counter = 0;
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            pBeg1++, pBeg2++, Counter++;
+        else if ( *pBeg1 < *pBeg2 )
+            pBeg1++;
+        else 
+            pBeg2++;
+    }
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Collects common entries.]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntTwoFindCommon( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    Vec_IntClear( vArr );
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            Vec_IntPush( vArr, *pBeg1 ), pBeg1++, pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            pBeg1++;
+        else 
+            pBeg2++;
+    }
+    return Vec_IntSize(vArr);
+}
+static inline int Vec_IntTwoFindCommonReverse( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    Vec_IntClear( vArr );
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            Vec_IntPush( vArr, *pBeg1 ), pBeg1++, pBeg2++;
+        else if ( *pBeg1 > *pBeg2 )
+            pBeg1++;
+        else 
+            pBeg2++;
+    }
+    return Vec_IntSize(vArr);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Collects and removes common entries]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntTwoRemoveCommon( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    int * pBeg1New = vArr1->pArray;
+    int * pBeg2New = vArr2->pArray;
+    Vec_IntClear( vArr );
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            Vec_IntPush( vArr, *pBeg1 ), pBeg1++, pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            *pBeg1New++ = *pBeg1++;
+        else 
+            *pBeg2New++ = *pBeg2++;
+    }
+    while ( pBeg1 < pEnd1 )
+        *pBeg1New++ = *pBeg1++;
+    while ( pBeg2 < pEnd2 )
+        *pBeg2New++ = *pBeg2++;
+    Vec_IntShrink( vArr1, pBeg1New - vArr1->pArray );
+    Vec_IntShrink( vArr2, pBeg2New - vArr2->pArray );
+    return Vec_IntSize(vArr);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Removes entries of the second one from the first one.]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntTwoRemove( Vec_Int_t * vArr1, Vec_Int_t * vArr2 )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    int * pBeg1New = vArr1->pArray;
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            pBeg1++, pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            *pBeg1New++ = *pBeg1++;
+        else 
+            pBeg2++;
+    }
+    while ( pBeg1 < pEnd1 )
+        *pBeg1New++ = *pBeg1++;
+    Vec_IntShrink( vArr1, pBeg1New - vArr1->pArray );
+    return Vec_IntSize(vArr1);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the result of merging the two vectors.]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntTwoMerge2Int( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr )
+{
+    int * pBeg  = vArr->pArray;
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            *pBeg++ = *pBeg1++, pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            *pBeg++ = *pBeg1++;
+        else 
+            *pBeg++ = *pBeg2++;
+    }
+    while ( pBeg1 < pEnd1 )
+        *pBeg++ = *pBeg1++;
+    while ( pBeg2 < pEnd2 )
+        *pBeg++ = *pBeg2++;
+    vArr->nSize = pBeg - vArr->pArray;
+    assert( vArr->nSize <= vArr->nCap );
+    assert( vArr->nSize >= vArr1->nSize );
+    assert( vArr->nSize >= vArr2->nSize );
+}
+static inline Vec_Int_t * Vec_IntTwoMerge( Vec_Int_t * vArr1, Vec_Int_t * vArr2 )
+{
+    Vec_Int_t * vArr = Vec_IntAlloc( vArr1->nSize + vArr2->nSize ); 
+    Vec_IntTwoMerge2Int( vArr1, vArr2, vArr );
+    return vArr;
+}
+static inline void Vec_IntTwoMerge2( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr )
+{
+    Vec_IntGrow( vArr, Vec_IntSize(vArr1) + Vec_IntSize(vArr2) );
+    Vec_IntTwoMerge2Int( vArr1, vArr2, vArr );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the result of splitting of the two vectors.]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntTwoSplit( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr, Vec_Int_t * vArr1n, Vec_Int_t * vArr2n )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            Vec_IntPush( vArr, *pBeg1++ ), pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            Vec_IntPush( vArr1n, *pBeg1++ );
+        else 
+            Vec_IntPush( vArr2n, *pBeg2++ );
+    }
+    while ( pBeg1 < pEnd1 )
+        Vec_IntPush( vArr1n, *pBeg1++ );
+    while ( pBeg2 < pEnd2 )
+        Vec_IntPush( vArr2n, *pBeg2++ );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntSelectSort( int * pArray, int nSize )
+{
+    int temp, i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( pArray[j] < pArray[best_i] )
+                best_i = j;
+        temp = pArray[i]; 
+        pArray[i] = pArray[best_i]; 
+        pArray[best_i] = temp;
+    }
+}
+static inline void Vec_IntSelectSortReverse( int * pArray, int nSize )
+{
+    int temp, i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( pArray[j] > pArray[best_i] )
+                best_i = j;
+        temp = pArray[i]; 
+        pArray[i] = pArray[best_i]; 
+        pArray[best_i] = temp;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntSelectSortCost( int * pArray, int nSize, Vec_Int_t * vCosts )
+{
+    int i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( Vec_IntEntry(vCosts, pArray[j]) < Vec_IntEntry(vCosts, pArray[best_i]) )
+                best_i = j;
+        ABC_SWAP( int, pArray[i], pArray[best_i] );
+    }
+}
+static inline void Vec_IntSelectSortCostReverse( int * pArray, int nSize, Vec_Int_t * vCosts )
+{
+    int i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( Vec_IntEntry(vCosts, pArray[j]) > Vec_IntEntry(vCosts, pArray[best_i]) )
+                best_i = j;
+        ABC_SWAP( int, pArray[i], pArray[best_i] );
+    }
+}
+
+static inline void Vec_IntSelectSortCost2( int * pArray, int nSize, int * pCosts )
+{
+    int i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( pCosts[j] < pCosts[best_i] )
+                best_i = j;
+        ABC_SWAP( int, pArray[i], pArray[best_i] );
+        ABC_SWAP( int, pCosts[i], pCosts[best_i] );
+    }
+}
+static inline void Vec_IntSelectSortCost2Reverse( int * pArray, int nSize, int * pCosts )
+{
+    int i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( pCosts[j] > pCosts[best_i] )
+                best_i = j;
+        ABC_SWAP( int, pArray[i], pArray[best_i] );
+        ABC_SWAP( int, pCosts[i], pCosts[best_i] );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntPrint( Vec_Int_t * vVec )
+{
+    int i, Entry;
+    printf( "Vector has %d entries: {", Vec_IntSize(vVec) );
+    Vec_IntForEachEntry( vVec, Entry, i )
+        printf( " %d", Entry );
+    printf( " }\n" );
+}
+static inline void Vec_IntPrintBinary( Vec_Int_t * vVec )
+{
+    int i, Entry;
+    Vec_IntForEachEntry( vVec, Entry, i )
+        printf( "%d", (int)(Entry != 0) );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntCompareVec( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( p1 == NULL || p2 == NULL )
+        return (p1 != NULL) - (p2 != NULL);
+    if ( Vec_IntSize(p1) != Vec_IntSize(p2) )
+        return Vec_IntSize(p1) - Vec_IntSize(p2);
+    return memcmp( Vec_IntArray(p1), Vec_IntArray(p2), sizeof(int)*Vec_IntSize(p1) );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Appends the contents of the second vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntAppend( Vec_Int_t * vVec1, Vec_Int_t * vVec2 )
+{
+    int Entry, i;
+    Vec_IntForEachEntry( vVec2, Entry, i )
+        Vec_IntPush( vVec1, Entry );
+}
+static inline void Vec_IntAppendSkip( Vec_Int_t * vVec1, Vec_Int_t * vVec2, int iVar )
+{
+    int Entry, i;
+    Vec_IntForEachEntry( vVec2, Entry, i )
+        if ( i != iVar )
+            Vec_IntPush( vVec1, Entry );
+}
+static inline void Vec_IntAppendMinus( Vec_Int_t * vVec1, Vec_Int_t * vVec2, int fMinus )
+{
+    int Entry, i;
+    Vec_IntClear( vVec1 );
+    Vec_IntForEachEntry( vVec2, Entry, i )
+        Vec_IntPush( vVec1, fMinus ? -Entry : Entry );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Remapping attributes after objects were duplicated.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntRemapArray( Vec_Int_t * vOld2New, Vec_Int_t * vOld, Vec_Int_t * vNew, int nNew )
+{
+    int iOld, iNew;
+    if ( Vec_IntSize(vOld) == 0 )
+        return;
+    Vec_IntFill( vNew, nNew, 0 );
+    Vec_IntForEachEntry( vOld2New, iNew, iOld )
+        if ( iNew > 0 && iNew < nNew && iOld < Vec_IntSize(vOld) && Vec_IntEntry(vOld, iOld) != 0 )
+            Vec_IntWriteEntry( vNew, iNew, Vec_IntEntry(vOld, iOld) );
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
diff --git a/lib/abcsat/abc/vecWec.h b/lib/abcsat/abc/vecWec.h
new file mode 100644
index 0000000..73899ed
--- /dev/null
+++ b/lib/abcsat/abc/vecWec.h
@@ -0,0 +1,724 @@
+/**CFile****************************************************************
+
+  FileName    [vecWec.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Resizable arrays.]
+
+  Synopsis    [Resizable vector of resizable vectors.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: vecWec.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+ 
+#ifndef ABC__misc__vec__vecWec_h
+#define ABC__misc__vec__vecWec_h
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4244) // warning C4244: '+=' : conversion from 'int ' to 'unsigned short ', possible loss of data
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include <stdio.h>
+
+ABC_NAMESPACE_HEADER_START
+
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct Vec_Wec_t_       Vec_Wec_t;
+struct Vec_Wec_t_ 
+{
+    int              nCap;
+    int              nSize;
+    Vec_Int_t *      pArray;
+};
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+// iterators through levels 
+#define Vec_WecForEachLevel( vGlob, vVec, i )                                              \
+    for ( i = 0; (i < Vec_WecSize(vGlob)) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ )
+#define Vec_WecForEachLevelVec( vLevels, vGlob, vVec, i )                                  \
+    for ( i = 0; (i < Vec_IntSize(vLevels)) && (((vVec) = Vec_WecEntry(vGlob, Vec_IntEntry(vLevels, i))), 1); i++ )
+#define Vec_WecForEachLevelStart( vGlob, vVec, i, LevelStart )                             \
+    for ( i = LevelStart; (i < Vec_WecSize(vGlob)) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ )
+#define Vec_WecForEachLevelStop( vGlob, vVec, i, LevelStop )                               \
+    for ( i = 0; (i < LevelStop) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ )
+#define Vec_WecForEachLevelStartStop( vGlob, vVec, i, LevelStart, LevelStop )              \
+    for ( i = LevelStart; (i < LevelStop) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ )
+#define Vec_WecForEachLevelReverse( vGlob, vVec, i )                                       \
+    for ( i = Vec_WecSize(vGlob)-1; (i >= 0) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i-- )
+#define Vec_WecForEachLevelReverseStartStop( vGlob, vVec, i, LevelStart, LevelStop )       \
+    for ( i = LevelStart-1; (i >= LevelStop) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i-- )
+#define Vec_WecForEachLevelTwo( vGlob1, vGlob2, vVec1, vVec2, i )                          \
+    for ( i = 0; (i < Vec_WecSize(vGlob1)) && (((vVec1) = Vec_WecEntry(vGlob1, i)), 1) && (((vVec2) = Vec_WecEntry(vGlob2, i)), 1); i++ )
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates a vector with the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Wec_t * Vec_WecAlloc( int nCap )
+{
+    Vec_Wec_t * p;
+    p = ABC_ALLOC( Vec_Wec_t, 1 );
+    if ( nCap > 0 && nCap < 8 )
+        nCap = 8;
+    p->nSize  = 0;
+    p->nCap   = nCap;
+    p->pArray = p->nCap? ABC_CALLOC( Vec_Int_t, p->nCap ) : NULL;
+    return p;
+}
+static inline Vec_Wec_t * Vec_WecAllocExact( int nCap )
+{
+    Vec_Wec_t * p;
+    assert( nCap >= 0 );
+    p = ABC_ALLOC( Vec_Wec_t, 1 );
+    p->nSize  = 0;
+    p->nCap   = nCap;
+    p->pArray = p->nCap? ABC_CALLOC( Vec_Int_t, p->nCap ) : NULL;
+    return p;
+}
+static inline Vec_Wec_t * Vec_WecStart( int nSize )
+{
+    Vec_Wec_t * p;
+    p = Vec_WecAlloc( nSize );
+    p->nSize = nSize;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Resizes the vector to the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecGrow( Vec_Wec_t * p, int nCapMin )
+{
+    if ( p->nCap >= nCapMin )
+        return;
+    p->pArray = ABC_REALLOC( Vec_Int_t, p->pArray, nCapMin ); 
+    memset( p->pArray + p->nCap, 0, sizeof(Vec_Int_t) * (nCapMin - p->nCap) );
+    p->nCap   = nCapMin;
+}
+static inline void Vec_WecInit( Vec_Wec_t * p, int nSize )
+{
+    Vec_WecGrow( p, nSize );
+    p->nSize = nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_WecEntry( Vec_Wec_t * p, int i )
+{
+    assert( i >= 0 && i < p->nSize );
+    return p->pArray + i;
+}
+static inline Vec_Int_t * Vec_WecEntryLast( Vec_Wec_t * p )
+{
+    assert( p->nSize > 0 );
+    return p->pArray + p->nSize - 1;
+}
+static inline int Vec_WecEntryEntry( Vec_Wec_t * p, int i, int k )
+{
+    return Vec_IntEntry( Vec_WecEntry(p, i), k );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_WecArray( Vec_Wec_t * p )
+{
+    return p->pArray;
+}
+static inline int Vec_WecLevelId( Vec_Wec_t * p, Vec_Int_t * vLevel )
+{
+    assert( p->pArray <= vLevel && vLevel < p->pArray + p->nSize );
+    return vLevel - p->pArray;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_WecCap( Vec_Wec_t * p )
+{
+    return p->nCap;
+}
+static inline int Vec_WecSize( Vec_Wec_t * p )
+{
+    return p->nSize;
+}
+static inline int Vec_WecLevelSize( Vec_Wec_t * p, int i )
+{
+    assert( i >= 0 && i < p->nSize );
+    return Vec_IntSize( p->pArray + i );
+}
+static inline int Vec_WecSizeSize( Vec_Wec_t * p )
+{
+    Vec_Int_t * vVec;
+    int i, Counter = 0;
+    Vec_WecForEachLevel( p, vVec, i )
+        Counter += Vec_IntSize(vVec);
+    return Counter;
+}
+static inline int Vec_WecSizeUsed( Vec_Wec_t * p )
+{
+    Vec_Int_t * vVec;
+    int i, Counter = 0;
+    Vec_WecForEachLevel( p, vVec, i )
+        Counter += (int)(Vec_IntSize(vVec) > 0);
+    return Counter;
+}
+static inline int Vec_WecSizeUsedLimits( Vec_Wec_t * p, int iStart, int iStop )
+{
+    Vec_Int_t * vVec;
+    int i, Counter = 0;
+    Vec_WecForEachLevelStartStop( p, vVec, i, iStart, iStop )
+        Counter += (int)(Vec_IntSize(vVec) > 0);
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecShrink( Vec_Wec_t * p, int nSizeNew )
+{
+    assert( p->nSize >= nSizeNew );
+    p->nSize = nSizeNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecClear( Vec_Wec_t * p )
+{
+    Vec_Int_t * vVec;
+    int i;
+    Vec_WecForEachLevel( p, vVec, i )
+        Vec_IntClear( vVec );
+    p->nSize = 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecPush( Vec_Wec_t * p, int Level, int Entry )
+{
+    if ( p->nSize < Level + 1 )
+    {
+        Vec_WecGrow( p, Abc_MaxInt(2*p->nSize, Level + 1) );
+        p->nSize = Level + 1;
+    }
+    Vec_IntPush( Vec_WecEntry(p, Level), Entry );
+}
+static inline Vec_Int_t * Vec_WecPushLevel( Vec_Wec_t * p )
+{
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_WecGrow( p, 16 );
+        else
+            Vec_WecGrow( p, 2 * p->nCap );
+    }
+    ++p->nSize;
+    return Vec_WecEntryLast( p );
+}
+static inline Vec_Int_t * Vec_WecInsertLevel( Vec_Wec_t * p, int i )
+{
+    Vec_Int_t * pTemp;
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_WecGrow( p, 16 );
+        else
+            Vec_WecGrow( p, 2 * p->nCap );
+    }
+    ++p->nSize;
+    assert( i >= 0 && i < p->nSize );
+    for ( pTemp = p->pArray + p->nSize - 2; pTemp >= p->pArray + i; pTemp-- )
+        pTemp[1] = pTemp[0];
+    Vec_IntZero( p->pArray + i );
+    return p->pArray + i;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline double Vec_WecMemory( Vec_Wec_t * p )
+{
+    int i;
+    double Mem;
+    if ( p == NULL )  return 0.0;
+    Mem = sizeof(Vec_Int_t) * Vec_WecCap(p);
+    for ( i = 0; i < p->nSize; i++ )
+        Mem += sizeof(int) * Vec_IntCap( Vec_WecEntry(p, i) );
+    return Mem;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Frees the vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecZero( Vec_Wec_t * p )
+{
+    p->pArray = NULL;
+    p->nSize = 0;
+    p->nCap = 0;
+}
+static inline void Vec_WecErase( Vec_Wec_t * p )
+{
+    int i;
+    for ( i = 0; i < p->nCap; i++ )
+        ABC_FREE( p->pArray[i].pArray );
+    ABC_FREE( p->pArray );
+    p->nSize = 0;
+    p->nCap = 0;
+}
+static inline void Vec_WecFree( Vec_Wec_t * p )
+{
+    Vec_WecErase( p );
+    ABC_FREE( p );
+}
+static inline void Vec_WecFreeP( Vec_Wec_t ** p )
+{
+    if ( *p == NULL )
+        return;
+    Vec_WecFree( *p );
+    *p = NULL;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecPushUnique( Vec_Wec_t * p, int Level, int Entry )
+{
+    if ( p->nSize < Level + 1 )
+        Vec_WecPush( p, Level, Entry );
+    else
+        Vec_IntPushUnique( Vec_WecEntry(p, Level), Entry );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Frees the vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Wec_t * Vec_WecDup( Vec_Wec_t * p )
+{
+    Vec_Wec_t * vNew;
+    Vec_Int_t * vVec;
+    int i, k, Entry;
+    vNew = Vec_WecAlloc( Vec_WecSize(p) );
+    Vec_WecForEachLevel( p, vVec, i )
+        Vec_IntForEachEntry( vVec, Entry, k )
+            Vec_WecPush( vNew, i, Entry );
+    return vNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting by array size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Vec_WecSortCompare1( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntSize(p1) < Vec_IntSize(p2) )
+        return -1;
+    if ( Vec_IntSize(p1) > Vec_IntSize(p2) ) 
+        return 1;
+    return 0; 
+}
+static int Vec_WecSortCompare2( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntSize(p1) > Vec_IntSize(p2) )
+        return -1;
+    if ( Vec_IntSize(p1) < Vec_IntSize(p2) ) 
+        return 1;
+    return 0; 
+}
+static inline void Vec_WecSort( Vec_Wec_t * p, int fReverse )
+{
+    if ( fReverse ) 
+        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare2 );
+    else
+        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare1 );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting by the first entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Vec_WecSortCompare3( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntEntry(p1,0) < Vec_IntEntry(p2,0) )
+        return -1;
+    if ( Vec_IntEntry(p1,0) > Vec_IntEntry(p2,0) ) 
+        return 1;
+    return 0; 
+}
+static int Vec_WecSortCompare4( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntEntry(p1,0) > Vec_IntEntry(p2,0) )
+        return -1;
+    if ( Vec_IntEntry(p1,0) < Vec_IntEntry(p2,0) ) 
+        return 1;
+    return 0; 
+}
+static inline void Vec_WecSortByFirstInt( Vec_Wec_t * p, int fReverse )
+{
+    if ( fReverse ) 
+        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare4 );
+    else
+        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare3 );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting by the last entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Vec_WecSortCompare5( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntEntryLast(p1) < Vec_IntEntryLast(p2) )
+        return -1;
+    if ( Vec_IntEntryLast(p1) > Vec_IntEntryLast(p2) ) 
+        return 1;
+    return 0; 
+}
+static int Vec_WecSortCompare6( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntEntryLast(p1) > Vec_IntEntryLast(p2) )
+        return -1;
+    if ( Vec_IntEntryLast(p1) < Vec_IntEntryLast(p2) ) 
+        return 1;
+    return 0; 
+}
+static inline void Vec_WecSortByLastInt( Vec_Wec_t * p, int fReverse )
+{
+    if ( fReverse ) 
+        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare6 );
+    else
+        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare5 );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+  
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecPrint( Vec_Wec_t * p, int fSkipSingles )
+{
+    Vec_Int_t * vVec;
+    int i, k, Entry;
+    Vec_WecForEachLevel( p, vVec, i )
+    {
+        if ( fSkipSingles && Vec_IntSize(vVec) == 1 )
+            continue;
+        printf( " %4d : {", i );
+        Vec_IntForEachEntry( vVec, Entry, k )
+            printf( " %d", Entry );
+        printf( " }\n" );
+    }
+}
+static inline void Vec_WecPrintLits( Vec_Wec_t * p )
+{
+    Vec_Int_t * vVec;
+    int i, k, iLit;
+    Vec_WecForEachLevel( p, vVec, i )
+    {
+        printf( " %4d : %2d  {", i, Vec_IntSize(vVec) );
+        Vec_IntForEachEntry( vVec, iLit, k )
+            printf( " %c%d", Abc_LitIsCompl(iLit) ? '-' : '+', Abc_Lit2Var(iLit) );
+        printf( " }\n" );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Derives the set of equivalence classes.]
+
+  Description []
+  
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Wec_t * Vec_WecCreateClasses( Vec_Int_t * vMap )
+{
+    Vec_Wec_t * vClasses;
+    int i, Entry;
+    vClasses = Vec_WecStart( Vec_IntFindMax(vMap) + 1 );
+    Vec_IntForEachEntry( vMap, Entry, i )
+        Vec_WecPush( vClasses, Entry, i );
+    return vClasses;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_WecCountNonTrivial( Vec_Wec_t * p, int * pnUsed )
+{
+    Vec_Int_t * vClass;
+    int i, nClasses = 0;
+    *pnUsed = 0;
+    Vec_WecForEachLevel( p, vClass, i )
+    {
+        if ( Vec_IntSize(vClass) < 2 )
+            continue;
+        nClasses++;
+        (*pnUsed) += Vec_IntSize(vClass);
+    }
+    return nClasses;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_WecCollectFirsts( Vec_Wec_t * p )
+{
+    Vec_Int_t * vFirsts, * vLevel;
+    int i;
+    vFirsts = Vec_IntAlloc( Vec_WecSize(p) );
+    Vec_WecForEachLevel( p, vLevel, i )
+        if ( Vec_IntSize(vLevel) > 0 )
+            Vec_IntPush( vFirsts, Vec_IntEntry(vLevel, 0) );
+    return vFirsts;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Temporary vector marking.]
+
+  Description [The vector should be static when the marking is used.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int  Vec_WecIntHasMark( Vec_Int_t * vVec ) { return (vVec->nCap >> 30) & 1; }
+static inline void Vec_WecIntSetMark( Vec_Int_t * vVec ) { vVec->nCap |= (1<<30);         }
+static inline void Vec_WecIntXorMark( Vec_Int_t * vVec ) { vVec->nCap ^= (1<<30);         }
+static inline void Vec_WecMarkLevels( Vec_Wec_t * vCubes, Vec_Int_t * vLevels )
+{
+    Vec_Int_t * vCube;
+    int i;
+    Vec_WecForEachLevelVec( vLevels, vCubes, vCube, i )
+    {
+        assert( !Vec_WecIntHasMark( vCube ) );
+        Vec_WecIntXorMark( vCube );
+    }
+}
+static inline void Vec_WecUnmarkLevels( Vec_Wec_t * vCubes, Vec_Int_t * vLevels )
+{
+    Vec_Int_t * vCube;
+    int i;
+    Vec_WecForEachLevelVec( vLevels, vCubes, vCube, i )
+    {
+        assert( Vec_WecIntHasMark( vCube ) );
+        Vec_WecIntXorMark( vCube );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Removes 0-size vectors.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecRemoveEmpty( Vec_Wec_t * vCubes )
+{
+    Vec_Int_t * vCube;
+    int i, k = 0;
+    Vec_WecForEachLevel( vCubes, vCube, i )
+        if ( Vec_IntSize(vCube) > 0 )
+            vCubes->pArray[k++] = *vCube;
+        else
+            ABC_FREE( vCube->pArray );
+    for ( i = k; i < Vec_WecSize(vCubes); i++ )
+        Vec_IntZero( Vec_WecEntry(vCubes, i) );
+    Vec_WecShrink( vCubes, k );
+//    Vec_WecSortByFirstInt( vCubes, 0 );
+}
+
+
+ABC_NAMESPACE_HEADER_END
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
diff --git a/lib/abcsat/satSolver.cpp b/lib/abcsat/satSolver.cpp
new file mode 100644
index 0000000..f9a2898
--- /dev/null
+++ b/lib/abcsat/satSolver.cpp
@@ -0,0 +1,2498 @@
+/**************************************************************************************************
+MiniSat -- Copyright (c) 2005, Niklas Sorensson
+http://www.cs.chalmers.se/Cs/Research/FormalMethods/MiniSat/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+// Modified to compile with MS Visual Studio 6.0 by Alan Mishchenko
+
+#include <stdio.h>
+#include <assert.h>
+#include <string.h>
+#include <math.h>
+
+#include <abc/satSolver.h>
+#include <abc/satStore.h>
+
+ABC_NAMESPACE_IMPL_START
+
+#define SAT_USE_ANALYZE_FINAL
+
+//=================================================================================================
+// Debug:
+
+//#define VERBOSEDEBUG
+
+
+/**Function*************************************************************
+
+  Synopsis    [Merging two lists of entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_MergeSortCostMerge( int * p1Beg, int * p1End, int * p2Beg, int * p2End, int * pOut )
+{
+    int nEntries = (p1End - p1Beg) + (p2End - p2Beg);
+    int * pOutBeg = pOut;
+    while ( p1Beg < p1End && p2Beg < p2End )
+    {
+        if ( p1Beg[1] == p2Beg[1] )
+            *pOut++ = *p1Beg++, *pOut++ = *p1Beg++, *pOut++ = *p2Beg++, *pOut++ = *p2Beg++; 
+        else if ( p1Beg[1] < p2Beg[1] )
+            *pOut++ = *p1Beg++, *pOut++ = *p1Beg++; 
+        else // if ( p1Beg[1] > p2Beg[1] )
+            *pOut++ = *p2Beg++, *pOut++ = *p2Beg++; 
+    }
+    while ( p1Beg < p1End )
+        *pOut++ = *p1Beg++, *pOut++ = *p1Beg++; 
+    while ( p2Beg < p2End )
+        *pOut++ = *p2Beg++, *pOut++ = *p2Beg++;
+    assert( pOut - pOutBeg == nEntries );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Recursive sorting.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_MergeSortCost_rec( int * pInBeg, int * pInEnd, int * pOutBeg )
+{
+    int nSize = (pInEnd - pInBeg)/2;
+    assert( nSize > 0 );
+    if ( nSize == 1 )
+        return;
+    if ( nSize == 2 )
+    {
+         if ( pInBeg[1] > pInBeg[3] )
+         {
+             pInBeg[1] ^= pInBeg[3];
+             pInBeg[3] ^= pInBeg[1];
+             pInBeg[1] ^= pInBeg[3];
+             pInBeg[0] ^= pInBeg[2];
+             pInBeg[2] ^= pInBeg[0];
+             pInBeg[0] ^= pInBeg[2];
+         }
+    }
+    else if ( nSize < 8 )
+    {
+        int temp, i, j, best_i;
+        for ( i = 0; i < nSize-1; i++ )
+        {
+            best_i = i;
+            for ( j = i+1; j < nSize; j++ )
+                if ( pInBeg[2*j+1] < pInBeg[2*best_i+1] )
+                    best_i = j;
+            temp = pInBeg[2*i]; 
+            pInBeg[2*i] = pInBeg[2*best_i]; 
+            pInBeg[2*best_i] = temp;
+            temp = pInBeg[2*i+1]; 
+            pInBeg[2*i+1] = pInBeg[2*best_i+1]; 
+            pInBeg[2*best_i+1] = temp;
+        }
+    }
+    else
+    {
+        Abc_MergeSortCost_rec( pInBeg, pInBeg + 2*(nSize/2), pOutBeg );
+        Abc_MergeSortCost_rec( pInBeg + 2*(nSize/2), pInEnd, pOutBeg + 2*(nSize/2) );
+        Abc_MergeSortCostMerge( pInBeg, pInBeg + 2*(nSize/2), pInBeg + 2*(nSize/2), pInEnd, pOutBeg );
+        memcpy( pInBeg, pOutBeg, sizeof(int) * 2 * nSize );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting procedure.]
+
+  Description [Returns permutation for the non-decreasing order of costs.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int * Abc_MergeSortCost( int * pCosts, int nSize )
+{
+    int i, * pResult, * pInput, * pOutput;
+    pResult = (int *) calloc( sizeof(int), nSize );
+    if ( nSize < 2 )
+        return pResult;
+    pInput  = (int *) malloc( sizeof(int) * 2 * nSize );
+    pOutput = (int *) malloc( sizeof(int) * 2 * nSize );
+    for ( i = 0; i < nSize; i++ )
+        pInput[2*i] = i, pInput[2*i+1] = pCosts[i];
+    Abc_MergeSortCost_rec( pInput, pInput + 2*nSize, pOutput );
+    for ( i = 0; i < nSize; i++ )
+        pResult[i] = pInput[2*i];
+    free( pOutput );
+    free( pInput );
+    return pResult;
+}
+
+
+
+// For derivation output (verbosity level 2)
+#define L_IND    "%-*d"
+#define L_ind    sat_solver_dl(s)*2+2,sat_solver_dl(s)
+#define L_LIT    "%sx%d"
+#define L_lit(p) lit_sign(p)?"~":"", (lit_var(p))
+
+// Just like 'assert()' but expression will be evaluated in the release version as well.
+static inline void check(int expr) { assert(expr); }
+
+//static void printlits(lit* begin, lit* end)
+//{
+//    int i;
+//    for (i = 0; i < end - begin; i++)
+//        printf(L_LIT" ",L_lit(begin[i]));
+//}
+
+//=================================================================================================
+// Random numbers:
+
+
+// Returns a random float 0 <= x < 1. Seed must never be 0.
+static inline double drand(double* seed) {
+    int q;
+    *seed *= 1389796;
+    q = (int)(*seed / 2147483647);
+    *seed -= (double)q * 2147483647;
+    return *seed / 2147483647; }
+
+
+// Returns a random integer 0 <= x < size. Seed must never be 0.
+static inline int irand(double* seed, int size) {
+    return (int)(drand(seed) * size); }
+
+
+//=================================================================================================
+// Variable datatype + minor functions:
+
+static const int var0  = 1;
+static const int var1  = 0;
+static const int varX  = 3;
+
+struct varinfo_t
+{
+    unsigned val    :  2;  // variable value 
+    unsigned pol    :  1;  // last polarity
+    unsigned tag    :  1;  // conflict analysis tag
+    unsigned lev    : 28;  // variable level
+};
+
+static inline int     var_level     (sat_solver* s, int v)            { return s->levels[v];   }
+static inline int     var_value     (sat_solver* s, int v)            { return s->assigns[v];  }
+static inline int     var_polar     (sat_solver* s, int v)            { return s->polarity[v]; }
+
+static inline void    var_set_level (sat_solver* s, int v, int lev)   { s->levels[v] = lev;    }
+static inline void    var_set_value (sat_solver* s, int v, int val)   { s->assigns[v] = val;   }
+static inline void    var_set_polar (sat_solver* s, int v, int pol)   { s->polarity[v] = pol;  }
+
+// variable tags
+static inline int     var_tag       (sat_solver* s, int v)            { return s->tags[v]; }
+static inline void    var_set_tag   (sat_solver* s, int v, int tag)   { 
+    assert( tag > 0 && tag < 16 );
+    if ( s->tags[v] == 0 )
+        veci_push( &s->tagged, v );
+    s->tags[v] = tag;                           
+}
+static inline void    var_add_tag   (sat_solver* s, int v, int tag)   { 
+    assert( tag > 0 && tag < 16 );
+    if ( s->tags[v] == 0 )
+        veci_push( &s->tagged, v );
+    s->tags[v] |= tag;                           
+}
+static inline void    solver2_clear_tags(sat_solver* s, int start)    { 
+    int i, * tagged = veci_begin(&s->tagged);
+    for (i = start; i < veci_size(&s->tagged); i++)
+        s->tags[tagged[i]] = 0;
+    veci_resize(&s->tagged,start);
+}
+
+int sat_solver_get_var_value(sat_solver* s, int v)
+{
+    if ( var_value(s, v) == var0 )
+        return l_False;
+    if ( var_value(s, v) == var1 )
+        return l_True;
+    if ( var_value(s, v) == varX )
+        return l_Undef;
+    assert( 0 );
+    return 0;
+}
+
+//=================================================================================================
+// Simple helpers:
+
+static inline int      sat_solver_dl(sat_solver* s)                { return veci_size(&s->trail_lim); }
+static inline veci*    sat_solver_read_wlist(sat_solver* s, lit l) { return &s->wlists[l];            }
+
+//=================================================================================================
+// Variable order functions:
+
+static inline void order_update(sat_solver* s, int v) // updateorder
+{
+    int*    orderpos = s->orderpos;
+    int*    heap     = veci_begin(&s->order);
+    int     i        = orderpos[v];
+    int     x        = heap[i];
+    int     parent   = (i - 1) / 2;
+
+    assert(s->orderpos[v] != -1);
+
+    while (i != 0 && s->activity[x] > s->activity[heap[parent]]){
+        heap[i]           = heap[parent];
+        orderpos[heap[i]] = i;
+        i                 = parent;
+        parent            = (i - 1) / 2;
+    }
+
+    heap[i]     = x;
+    orderpos[x] = i;
+}
+
+static inline void order_assigned(sat_solver* s, int v) 
+{
+}
+
+static inline void order_unassigned(sat_solver* s, int v) // undoorder
+{
+    int* orderpos = s->orderpos;
+    if (orderpos[v] == -1){
+        orderpos[v] = veci_size(&s->order);
+        veci_push(&s->order,v);
+        order_update(s,v);
+//printf( "+%d ", v );
+    }
+}
+
+static inline int  order_select(sat_solver* s, float random_var_freq) // selectvar
+{
+    int*      heap     = veci_begin(&s->order);
+    int*      orderpos = s->orderpos;
+    // Random decision:
+    if (drand(&s->random_seed) < random_var_freq){
+        int next = irand(&s->random_seed,s->size);
+        assert(next >= 0 && next < s->size);
+        if (var_value(s, next) == varX)
+            return next;
+    }
+    // Activity based decision:
+    while (veci_size(&s->order) > 0){
+        int    next  = heap[0];
+        int    size  = veci_size(&s->order)-1;
+        int    x     = heap[size];
+        veci_resize(&s->order,size);
+        orderpos[next] = -1;
+        if (size > 0){
+            int    i     = 0;
+            int    child = 1;
+            while (child < size){
+
+                if (child+1 < size && s->activity[heap[child]] < s->activity[heap[child+1]])
+                    child++;
+                assert(child < size);
+                if (s->activity[x] >= s->activity[heap[child]])
+                    break;
+
+                heap[i]           = heap[child];
+                orderpos[heap[i]] = i;
+                i                 = child;
+                child             = 2 * child + 1;
+            }
+            heap[i]           = x;
+            orderpos[heap[i]] = i;
+        }
+        if (var_value(s, next) == varX)
+            return next;
+    }
+    return var_Undef;
+}
+
+void sat_solver_set_var_activity(sat_solver* s, int * pVars, int nVars) 
+{
+    int i;
+    assert( s->VarActType == 1 );
+    for (i = 0; i < s->size; i++)
+        s->activity[i] = 0;
+    s->var_inc = Abc_Dbl2Word(1);
+    for ( i = 0; i < nVars; i++ )
+    {
+        int iVar = pVars ? pVars[i] : i;
+        s->activity[iVar] = Abc_Dbl2Word(nVars-i);
+        order_update( s, iVar );
+    }
+}
+
+//=================================================================================================
+// variable activities
+
+void solver_init_activities(sat_solver* s)  
+{
+    // variable activities
+    if ( s->VarActType == 0 )
+    {
+        s->var_inc            = (1 <<  5);
+        s->var_decay          = -1;
+    }
+    else if ( s->VarActType == 1 )
+    {
+        s->var_inc            = Abc_Dbl2Word(1.0);
+        s->var_decay          = Abc_Dbl2Word(1.0 / 0.95);
+    }
+    else if ( s->VarActType == 2 )
+    {
+        s->var_inc            = Xdbl_FromDouble(1.0);
+        s->var_decay          = Xdbl_FromDouble(1.0 / 0.950);
+    }
+    else assert(0);
+
+    // clause activities
+    if ( s->ClaActType == 0 )
+    {
+        s->cla_inc            = (1 << 11);
+        s->cla_decay          = -1;
+    }
+    else
+    {
+        s->cla_inc            = 1;
+        s->cla_decay          = (float)(1 / 0.999);
+    }
+}
+
+static inline void act_var_rescale(sat_solver* s)  
+{
+    if ( s->VarActType == 0 )
+    {
+        word* activity = s->activity;
+        int i;
+        for (i = 0; i < s->size; i++)
+            activity[i] >>= 19;
+        s->var_inc >>= 19;
+        s->var_inc = Abc_MaxInt( (unsigned)s->var_inc, (1<<4) );
+    }
+    else if ( s->VarActType == 1 )
+    {
+        double* activity = (double*)s->activity;
+        int i;
+        for (i = 0; i < s->size; i++)
+            activity[i] *= 1e-100;
+        s->var_inc = Abc_Dbl2Word( Abc_Word2Dbl(s->var_inc) * 1e-100 );
+        //printf( "Rescaling var activity...\n" ); 
+    }
+    else if ( s->VarActType == 2 )
+    {
+        xdbl * activity = s->activity;
+        int i;
+        for (i = 0; i < s->size; i++)
+            activity[i] = Xdbl_Div( activity[i], 200 ); // activity[i] / 2^200
+        s->var_inc = Xdbl_Div( s->var_inc, 200 ); 
+    }
+    else assert(0);
+}
+static inline void act_var_bump(sat_solver* s, int v) 
+{
+    if ( s->VarActType == 0 )
+    {
+        s->activity[v] += s->var_inc;
+        if ((unsigned)s->activity[v] & 0x80000000)
+            act_var_rescale(s);
+        if (s->orderpos[v] != -1)
+            order_update(s,v);
+    }
+    else if ( s->VarActType == 1 )
+    {
+        double act = Abc_Word2Dbl(s->activity[v]) + Abc_Word2Dbl(s->var_inc);
+        s->activity[v] = Abc_Dbl2Word(act);
+        if (act > 1e100)
+            act_var_rescale(s);
+        if (s->orderpos[v] != -1)
+            order_update(s,v);
+    }
+    else if ( s->VarActType == 2 )
+    {
+	    s->activity[v] = Xdbl_Add( s->activity[v], s->var_inc );
+	    if (s->activity[v] > ABC_CONST(0x014c924d692ca61b))
+		    act_var_rescale(s);
+        if (s->orderpos[v] != -1)
+            order_update(s,v);
+    }
+    else assert(0);
+}
+static inline void act_var_bump_global(sat_solver* s, int v) 
+{
+    if ( !s->pGlobalVars || !s->pGlobalVars[v] )
+        return;
+    if ( s->VarActType == 0 )
+    {
+        s->activity[v] += (int)((unsigned)s->var_inc * 3);
+        if (s->activity[v] & 0x80000000)
+            act_var_rescale(s);
+        if (s->orderpos[v] != -1)
+            order_update(s,v);
+    }
+    else if ( s->VarActType == 1 )
+    {
+        double act = Abc_Word2Dbl(s->activity[v]) + Abc_Word2Dbl(s->var_inc) * 3.0;
+        s->activity[v] = Abc_Dbl2Word(act);
+        if ( act > 1e100)
+            act_var_rescale(s);
+        if (s->orderpos[v] != -1)
+            order_update(s,v);
+    }
+    else if ( s->VarActType == 2 )
+    {
+        s->activity[v] = Xdbl_Add( s->activity[v], Xdbl_Mul(s->var_inc, Xdbl_FromDouble(3.0)) );
+	    if (s->activity[v] > ABC_CONST(0x014c924d692ca61b))
+		    act_var_rescale(s);
+        if (s->orderpos[v] != -1)
+            order_update(s,v);
+    }
+    else assert( 0 );
+}
+static inline void act_var_bump_factor(sat_solver* s, int v) 
+{
+    if ( !s->factors )
+        return;
+    if ( s->VarActType == 0 )
+    {
+        s->activity[v] += (int)((unsigned)s->var_inc * (float)s->factors[v]);
+        if (s->activity[v] & 0x80000000)
+            act_var_rescale(s);
+        if (s->orderpos[v] != -1)
+            order_update(s,v);
+    }
+    else if ( s->VarActType == 1 )
+    {
+        double act = Abc_Word2Dbl(s->activity[v]) + Abc_Word2Dbl(s->var_inc) * s->factors[v];
+        s->activity[v] = Abc_Dbl2Word(act);
+        if ( act > 1e100)
+            act_var_rescale(s);
+        if (s->orderpos[v] != -1)
+            order_update(s,v);
+    }
+    else if ( s->VarActType == 2 )
+    {
+        s->activity[v] = Xdbl_Add( s->activity[v], Xdbl_Mul(s->var_inc, Xdbl_FromDouble(s->factors[v])) );
+	    if (s->activity[v] > ABC_CONST(0x014c924d692ca61b))
+            act_var_rescale(s);
+        if (s->orderpos[v] != -1)
+            order_update(s,v);
+    }
+    else assert( 0 );
+}
+
+static inline void act_var_decay(sat_solver* s)    
+{ 
+    if ( s->VarActType == 0 )
+        s->var_inc += (s->var_inc >>  4); 
+    else if ( s->VarActType == 1 )
+        s->var_inc = Abc_Dbl2Word( Abc_Word2Dbl(s->var_inc) * Abc_Word2Dbl(s->var_decay) );
+    else if ( s->VarActType == 2 )
+        s->var_inc = Xdbl_Mul(s->var_inc, s->var_decay); 
+    else assert(0);
+}
+
+// clause activities
+static inline void act_clause_rescale(sat_solver* s) 
+{
+    if ( s->ClaActType == 0 )
+    {
+        unsigned* activity = (unsigned *)veci_begin(&s->act_clas);
+        int i;
+        for (i = 0; i < veci_size(&s->act_clas); i++)
+            activity[i] >>= 14;
+        s->cla_inc >>= 14;
+        s->cla_inc = Abc_MaxInt( s->cla_inc, (1<<10) );
+    }
+    else
+    {
+        float* activity = (float *)veci_begin(&s->act_clas);
+        int i;
+        for (i = 0; i < veci_size(&s->act_clas); i++)
+            activity[i] *= (float)1e-20;
+        s->cla_inc *= (float)1e-20;
+    }
+}
+static inline void act_clause_bump(sat_solver* s, clause *c) 
+{
+    if ( s->ClaActType == 0 )
+    {
+        unsigned* act = (unsigned *)veci_begin(&s->act_clas) + c->lits[c->size];
+        *act += s->cla_inc;
+        if ( *act & 0x80000000 )
+            act_clause_rescale(s);
+    }
+    else
+    {
+        float* act = (float *)veci_begin(&s->act_clas) + c->lits[c->size];
+        *act += s->cla_inc;
+        if (*act > 1e20) 
+            act_clause_rescale(s);
+    }
+}
+static inline void act_clause_decay(sat_solver* s)    
+{ 
+    if ( s->ClaActType == 0 )
+        s->cla_inc += (s->cla_inc >> 10);
+    else
+        s->cla_inc *= s->cla_decay;
+}
+
+
+//=================================================================================================
+// Sorting functions (sigh):
+
+static inline void selectionsort(void** array, int size, int(*comp)(const void *, const void *))
+{
+    int     i, j, best_i;
+    void*   tmp;
+
+    for (i = 0; i < size-1; i++){
+        best_i = i;
+        for (j = i+1; j < size; j++){
+            if (comp(array[j], array[best_i]) < 0)
+                best_i = j;
+        }
+        tmp = array[i]; array[i] = array[best_i]; array[best_i] = tmp;
+    }
+}
+
+//=================================================================================================
+// Clause functions:
+
+static inline int sat_clause_compute_lbd( sat_solver* s, clause* c )
+{
+    int i, lev, minl = 0, lbd = 0;
+    for (i = 0; i < (int)c->size; i++)
+    {
+        lev = var_level(s, lit_var(c->lits[i]));
+        if ( !(minl & (1 << (lev & 31))) )
+        {
+            minl |= 1 << (lev & 31);
+            lbd++;
+//            printf( "%d ", lev );
+        }
+    }
+//    printf( " -> %d\n", lbd );
+    return lbd;
+}
+
+/* pre: size > 1 && no variable occurs twice
+ */
+int sat_solver_clause_new(sat_solver* s, lit* begin, lit* end, int learnt)
+{
+    int fUseBinaryClauses = 1;
+    int size;
+    clause* c;
+    int h;
+
+    assert(end - begin > 1);
+    assert(learnt >= 0 && learnt < 2);
+    size           = end - begin;
+
+    // do not allocate memory for the two-literal problem clause
+    if ( fUseBinaryClauses && size == 2 && !learnt )
+    {
+        veci_push(sat_solver_read_wlist(s,lit_neg(begin[0])),(clause_from_lit(begin[1])));
+        veci_push(sat_solver_read_wlist(s,lit_neg(begin[1])),(clause_from_lit(begin[0])));
+        s->stats.clauses++;
+        s->stats.clauses_literals += size;
+        return 0;
+    }
+
+    // create new clause
+//    h = Vec_SetAppend( &s->Mem, NULL, size + learnt + 1 + 1 ) << 1;
+    h = Sat_MemAppend( &s->Mem, begin, size, learnt, 0 );
+    assert( !(h & 1) );
+    if ( s->hLearnts == -1 && learnt )
+        s->hLearnts = h;
+    if (learnt)
+    {
+        c = clause_read( s, h );
+        c->lbd = sat_clause_compute_lbd( s, c );
+        assert( clause_id(c) == veci_size(&s->act_clas) );
+//        veci_push(&s->learned, h);
+//        act_clause_bump(s,clause_read(s, h));
+        if ( s->ClaActType == 0 )
+            veci_push(&s->act_clas, (1<<10));
+        else
+            veci_push(&s->act_clas, s->cla_inc);
+        s->stats.learnts++;
+        s->stats.learnts_literals += size;
+    }
+    else
+    {
+        s->stats.clauses++;
+        s->stats.clauses_literals += size;
+    }
+
+    assert(begin[0] >= 0);
+    assert(begin[0] < s->size*2);
+    assert(begin[1] >= 0);
+    assert(begin[1] < s->size*2);
+
+    assert(lit_neg(begin[0]) < s->size*2);
+    assert(lit_neg(begin[1]) < s->size*2);
+
+    //veci_push(sat_solver_read_wlist(s,lit_neg(begin[0])),c);
+    //veci_push(sat_solver_read_wlist(s,lit_neg(begin[1])),c);
+    veci_push(sat_solver_read_wlist(s,lit_neg(begin[0])),(size > 2 ? h : clause_from_lit(begin[1])));
+    veci_push(sat_solver_read_wlist(s,lit_neg(begin[1])),(size > 2 ? h : clause_from_lit(begin[0])));
+
+    return h;
+}
+
+
+//=================================================================================================
+// Minor (solver) functions:
+
+static inline int sat_solver_enqueue(sat_solver* s, lit l, int from)
+{
+    int v  = lit_var(l);
+    if ( s->pFreqs[v] == 0 )
+//    {
+        s->pFreqs[v] = 1;
+//        s->nVarUsed++;
+//    }
+
+#ifdef VERBOSEDEBUG
+    printf(L_IND"enqueue("L_LIT")\n", L_ind, L_lit(l));
+#endif
+    if (var_value(s, v) != varX)
+        return var_value(s, v) == lit_sign(l);
+    else{
+/*
+        if ( s->pCnfFunc )
+        {
+            if ( lit_sign(l) )
+            {
+                if ( (s->loads[v] & 1) == 0 )
+                {
+                    s->loads[v] ^= 1;
+                    s->pCnfFunc( s->pCnfMan, l );
+                }
+            }
+            else
+            {
+                if ( (s->loads[v] & 2) == 0 )
+                {
+                    s->loads[v] ^= 2;
+                    s->pCnfFunc( s->pCnfMan, l );
+                }
+            }
+        }
+*/
+        // New fact -- store it.
+#ifdef VERBOSEDEBUG
+        printf(L_IND"bind("L_LIT")\n", L_ind, L_lit(l));
+#endif
+        var_set_value(s, v, lit_sign(l));
+        var_set_level(s, v, sat_solver_dl(s));
+        s->reasons[v] = from;
+        s->trail[s->qtail++] = l;
+        order_assigned(s, v);
+        return true;
+    }
+}
+
+
+static inline int sat_solver_decision(sat_solver* s, lit l){
+    assert(s->qtail == s->qhead);
+    assert(var_value(s, lit_var(l)) == varX);
+#ifdef VERBOSEDEBUG
+    printf(L_IND"assume("L_LIT")  ", L_ind, L_lit(l));
+    printf( "act = %.20f\n", s->activity[lit_var(l)] );
+#endif
+    veci_push(&s->trail_lim,s->qtail);
+    return sat_solver_enqueue(s,l,0);
+}
+
+
+static void sat_solver_canceluntil(sat_solver* s, int level) {
+    int      bound;
+    int      lastLev;
+    int      c;
+    
+    if (sat_solver_dl(s) <= level)
+        return;
+
+    assert( veci_size(&s->trail_lim) > 0 );
+    bound   = (veci_begin(&s->trail_lim))[level];
+    lastLev = (veci_begin(&s->trail_lim))[veci_size(&s->trail_lim)-1];
+
+    ////////////////////////////////////////
+    // added to cancel all assignments
+//    if ( level == -1 )
+//        bound = 0;
+    ////////////////////////////////////////
+
+    for (c = s->qtail-1; c >= bound; c--) {
+        int     x  = lit_var(s->trail[c]);
+        var_set_value(s, x, varX);
+        s->reasons[x] = 0;
+        if ( c < lastLev )
+            var_set_polar( s, x, !lit_sign(s->trail[c]) );
+    }
+    //printf( "\n" );
+
+    for (c = s->qhead-1; c >= bound; c--)
+        order_unassigned(s,lit_var(s->trail[c]));
+
+    s->qhead = s->qtail = bound;
+    veci_resize(&s->trail_lim,level);
+}
+
+static void sat_solver_canceluntil_rollback(sat_solver* s, int NewBound) {
+    int      c, x;
+   
+    assert( sat_solver_dl(s) == 0 );
+    assert( s->qtail == s->qhead );
+    assert( s->qtail >= NewBound );
+
+    for (c = s->qtail-1; c >= NewBound; c--) 
+    {
+        x = lit_var(s->trail[c]);
+        var_set_value(s, x, varX);
+        s->reasons[x] = 0;
+    }
+
+    for (c = s->qhead-1; c >= NewBound; c--)
+        order_unassigned(s,lit_var(s->trail[c]));
+
+    s->qhead = s->qtail = NewBound;
+}
+
+static void sat_solver_record(sat_solver* s, veci* cls)
+{
+    lit*    begin = veci_begin(cls);
+    lit*    end   = begin + veci_size(cls);
+    int     h     = (veci_size(cls) > 1) ? sat_solver_clause_new(s,begin,end,1) : 0;
+    sat_solver_enqueue(s,*begin,h);
+    assert(veci_size(cls) > 0);
+    if ( h == 0 )
+        veci_push( &s->unit_lits, *begin );
+
+    ///////////////////////////////////
+    // add clause to internal storage
+    if ( s->pStore )
+    {
+        int RetValue = Sto_ManAddClause( (Sto_Man_t *)s->pStore, begin, end );
+        assert( RetValue );
+        (void) RetValue;
+    }
+    ///////////////////////////////////
+/*
+    if (h != 0) {
+        act_clause_bump(s,clause_read(s, h));
+        s->stats.learnts++;
+        s->stats.learnts_literals += veci_size(cls);
+    }
+*/
+}
+
+int sat_solver_count_assigned(sat_solver* s)
+{
+    // count top-level assignments
+    int i, Count = 0;
+    assert(sat_solver_dl(s) == 0);
+    for ( i = 0; i < s->size; i++ )
+        if (var_value(s, i) != varX)
+            Count++;
+    return Count;
+}
+
+static double sat_solver_progress(sat_solver* s)
+{
+    int     i;
+    double  progress = 0;
+    double  F        = 1.0 / s->size;
+    for (i = 0; i < s->size; i++)
+        if (var_value(s, i) != varX)
+            progress += pow(F, var_level(s, i));
+    return progress / s->size;
+}
+
+//=================================================================================================
+// Major methods:
+
+static int sat_solver_lit_removable(sat_solver* s, int x, int minl)
+{
+    int      top     = veci_size(&s->tagged);
+
+    assert(s->reasons[x] != 0);
+    veci_resize(&s->stack,0);
+    veci_push(&s->stack,x);
+
+    while (veci_size(&s->stack)){
+        int v = veci_pop(&s->stack);
+        assert(s->reasons[v] != 0);
+        if (clause_is_lit(s->reasons[v])){
+            v = lit_var(clause_read_lit(s->reasons[v]));
+            if (!var_tag(s,v) && var_level(s, v)){
+                if (s->reasons[v] != 0 && ((1 << (var_level(s, v) & 31)) & minl)){
+                    veci_push(&s->stack,v);
+                    var_set_tag(s, v, 1);
+                }else{
+                    solver2_clear_tags(s, top);
+                    return 0;
+                }
+            }
+        }else{
+            clause* c = clause_read(s, s->reasons[v]);
+            lit* lits = clause_begin(c);
+            int  i;
+            for (i = 1; i < clause_size(c); i++){
+                int v = lit_var(lits[i]);
+                if (!var_tag(s,v) && var_level(s, v)){
+                    if (s->reasons[v] != 0 && ((1 << (var_level(s, v) & 31)) & minl)){
+                        veci_push(&s->stack,lit_var(lits[i]));
+                        var_set_tag(s, v, 1);
+                    }else{
+                        solver2_clear_tags(s, top);
+                        return 0;
+                    }
+                }
+            }
+        }
+    }
+    return 1;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  analyzeFinal : (p : Lit)  ->  [void]
+|  
+|  Description:
+|    Specialized analysis procedure to express the final conflict in terms of assumptions.
+|    Calculates the (possibly empty) set of assumptions that led to the assignment of 'p', and
+|    stores the result in 'out_conflict'.
+|________________________________________________________________________________________________@*/
+/*
+void Solver::analyzeFinal(Clause* confl, bool skip_first)
+{
+    // -- NOTE! This code is relatively untested. Please report bugs!
+    conflict.clear();
+    if (root_level == 0) return;
+
+    vec<char>& seen  = analyze_seen;
+    for (int i = skip_first ? 1 : 0; i < confl->size(); i++){
+        Var x = var((*confl)[i]);
+        if (level[x] > 0)
+            seen[x] = 1;
+    }
+
+    int start = (root_level >= trail_lim.size()) ? trail.size()-1 : trail_lim[root_level];
+    for (int i = start; i >= trail_lim[0]; i--){
+        Var     x = var(trail[i]);
+        if (seen[x]){
+            GClause r = reason[x];
+            if (r == GClause_NULL){
+                assert(level[x] > 0);
+                conflict.push(~trail[i]);
+            }else{
+                if (r.isLit()){
+                    Lit p = r.lit();
+                    if (level[var(p)] > 0)
+                        seen[var(p)] = 1;
+                }else{
+                    Clause& c = *r.clause();
+                    for (int j = 1; j < c.size(); j++)
+                        if (level[var(c[j])] > 0)
+                            seen[var(c[j])] = 1;
+                }
+            }
+            seen[x] = 0;
+        }
+    }
+}
+*/
+
+#ifdef SAT_USE_ANALYZE_FINAL
+
+static void sat_solver_analyze_final(sat_solver* s, int hConf, int skip_first)
+{
+    clause* conf = clause_read(s, hConf);
+    int i, j, start;
+    veci_resize(&s->conf_final,0);
+    if ( s->root_level == 0 )
+        return;
+    assert( veci_size(&s->tagged) == 0 );
+//    assert( s->tags[lit_var(p)] == l_Undef );
+//    s->tags[lit_var(p)] = l_True;
+    for (i = skip_first ? 1 : 0; i < clause_size(conf); i++)
+    {
+        int x = lit_var(clause_begin(conf)[i]);
+        if (var_level(s, x) > 0)
+            var_set_tag(s, x, 1);
+    }
+
+    start = (s->root_level >= veci_size(&s->trail_lim))? s->qtail-1 : (veci_begin(&s->trail_lim))[s->root_level];
+    for (i = start; i >= (veci_begin(&s->trail_lim))[0]; i--){
+        int x = lit_var(s->trail[i]);
+        if (var_tag(s,x)){
+            if (s->reasons[x] == 0){
+                assert(var_level(s, x) > 0);
+                veci_push(&s->conf_final,lit_neg(s->trail[i]));
+            }else{
+                if (clause_is_lit(s->reasons[x])){
+                    lit q = clause_read_lit(s->reasons[x]);
+                    assert(lit_var(q) >= 0 && lit_var(q) < s->size);
+                    if (var_level(s, lit_var(q)) > 0)
+                        var_set_tag(s, lit_var(q), 1);
+                }
+                else{
+                    clause* c = clause_read(s, s->reasons[x]);
+                    int* lits = clause_begin(c);
+                    for (j = 1; j < clause_size(c); j++)
+                        if (var_level(s, lit_var(lits[j])) > 0)
+                            var_set_tag(s, lit_var(lits[j]), 1);
+                }
+            }
+        }
+    }
+    solver2_clear_tags(s,0);
+}
+
+#endif
+
+static void sat_solver_analyze(sat_solver* s, int h, veci* learnt)
+{
+    lit*     trail   = s->trail;
+    int      cnt     = 0;
+    lit      p       = lit_Undef;
+    int      ind     = s->qtail-1;
+    lit*     lits;
+    int      i, j, minl;
+    veci_push(learnt,lit_Undef);
+    do{
+        assert(h != 0);
+        if (clause_is_lit(h)){
+            int x = lit_var(clause_read_lit(h));
+            if (var_tag(s, x) == 0 && var_level(s, x) > 0){
+                var_set_tag(s, x, 1);
+                act_var_bump(s,x);
+                if (var_level(s, x) == sat_solver_dl(s))
+                    cnt++;
+                else
+                    veci_push(learnt,clause_read_lit(h));
+            }
+        }else{
+            clause* c = clause_read(s, h);
+            
+            if (clause_learnt(c))
+                act_clause_bump(s,c);
+            lits = clause_begin(c);
+            //printlits(lits,lits+clause_size(c)); printf("\n");
+            for (j = (p == lit_Undef ? 0 : 1); j < clause_size(c); j++){
+                int x = lit_var(lits[j]);
+                if (var_tag(s, x) == 0 && var_level(s, x) > 0){
+                    var_set_tag(s, x, 1);
+                    act_var_bump(s,x);
+                    // bump variables propaged by the LBD=2 clause
+//                    if ( s->reasons[x] && clause_read(s, s->reasons[x])->lbd <= 2 )
+//                        act_var_bump(s,x);
+                    if (var_level(s,x) == sat_solver_dl(s))
+                        cnt++;
+                    else
+                        veci_push(learnt,lits[j]);
+                }
+            }
+        }
+
+        while ( !var_tag(s, lit_var(trail[ind--])) );
+
+        p = trail[ind+1];
+        h = s->reasons[lit_var(p)];
+        cnt--;
+
+    }while (cnt > 0);
+
+    *veci_begin(learnt) = lit_neg(p);
+
+    lits = veci_begin(learnt);
+    minl = 0;
+    for (i = 1; i < veci_size(learnt); i++){
+        int lev = var_level(s, lit_var(lits[i]));
+        minl    |= 1 << (lev & 31);
+    }
+
+    // simplify (full)
+    for (i = j = 1; i < veci_size(learnt); i++){
+        if (s->reasons[lit_var(lits[i])] == 0 || !sat_solver_lit_removable(s,lit_var(lits[i]),minl))
+            lits[j++] = lits[i];
+    }
+
+    // update size of learnt + statistics
+    veci_resize(learnt,j);
+    s->stats.tot_literals += j;
+
+
+    // clear tags
+    solver2_clear_tags(s,0);
+
+#ifdef DEBUG
+    for (i = 0; i < s->size; i++)
+        assert(!var_tag(s, i));
+#endif
+
+#ifdef VERBOSEDEBUG
+    printf(L_IND"Learnt {", L_ind);
+    for (i = 0; i < veci_size(learnt); i++) printf(" "L_LIT, L_lit(lits[i]));
+#endif
+    if (veci_size(learnt) > 1){
+        int max_i = 1;
+        int max   = var_level(s, lit_var(lits[1]));
+        lit tmp;
+
+        for (i = 2; i < veci_size(learnt); i++)
+            if (var_level(s, lit_var(lits[i])) > max){
+                max   = var_level(s, lit_var(lits[i]));
+                max_i = i;
+            }
+
+        tmp         = lits[1];
+        lits[1]     = lits[max_i];
+        lits[max_i] = tmp;
+    }
+#ifdef VERBOSEDEBUG
+    {
+        int lev = veci_size(learnt) > 1 ? var_level(s, lit_var(lits[1])) : 0;
+        printf(" } at level %d\n", lev);
+    }
+#endif
+}
+
+//#define TEST_CNF_LOAD
+
+int sat_solver_propagate(sat_solver* s)
+{
+    int     hConfl = 0;
+    lit*    lits;
+    lit false_lit;
+
+    //printf("sat_solver_propagate\n");
+    while (hConfl == 0 && s->qtail - s->qhead > 0){
+        lit p = s->trail[s->qhead++];
+
+#ifdef TEST_CNF_LOAD
+        int v = lit_var(p);
+        if ( s->pCnfFunc )
+        {
+            if ( lit_sign(p) )
+            {
+                if ( (s->loads[v] & 1) == 0 )
+                {
+                    s->loads[v] ^= 1;
+                    s->pCnfFunc( s->pCnfMan, p );
+                }
+            }
+            else
+            {
+                if ( (s->loads[v] & 2) == 0 )
+                {
+                    s->loads[v] ^= 2;
+                    s->pCnfFunc( s->pCnfMan, p );
+                }
+            }
+        }
+        {
+#endif
+
+        veci* ws    = sat_solver_read_wlist(s,p);
+        int*  begin = veci_begin(ws);
+        int*  end   = begin + veci_size(ws);
+        int*i, *j;
+
+        s->stats.propagations++;
+//        s->simpdb_props--;
+
+        //printf("checking lit %d: "L_LIT"\n", veci_size(ws), L_lit(p));
+        for (i = j = begin; i < end; ){
+            if (clause_is_lit(*i)){
+
+                int Lit = clause_read_lit(*i);
+                if (var_value(s, lit_var(Lit)) == lit_sign(Lit)){
+                    *j++ = *i++;
+                    continue;
+                }
+
+                *j++ = *i;
+                if (!sat_solver_enqueue(s,clause_read_lit(*i),clause_from_lit(p))){
+                    hConfl = s->hBinary;
+                    (clause_begin(s->binary))[1] = lit_neg(p);
+                    (clause_begin(s->binary))[0] = clause_read_lit(*i++);
+                    // Copy the remaining watches:
+                    while (i < end)
+                        *j++ = *i++;
+                }
+            }else{
+
+                clause* c = clause_read(s,*i);
+                lits = clause_begin(c);
+
+                // Make sure the false literal is data[1]:
+                false_lit = lit_neg(p);
+                if (lits[0] == false_lit){
+                    lits[0] = lits[1];
+                    lits[1] = false_lit;
+                }
+                assert(lits[1] == false_lit);
+
+                // If 0th watch is true, then clause is already satisfied.
+                if (var_value(s, lit_var(lits[0])) == lit_sign(lits[0]))
+                    *j++ = *i;
+                else{
+                    // Look for new watch:
+                    lit* stop = lits + clause_size(c);
+                    lit* k;
+                    for (k = lits + 2; k < stop; k++){
+                        if (var_value(s, lit_var(*k)) != !lit_sign(*k)){
+                            lits[1] = *k;
+                            *k = false_lit;
+                            veci_push(sat_solver_read_wlist(s,lit_neg(lits[1])),*i);
+                            goto next; }
+                    }
+
+                    *j++ = *i;
+                    // Clause is unit under assignment:
+                    if ( c->lrn )
+                        c->lbd = sat_clause_compute_lbd(s, c);
+                    if (!sat_solver_enqueue(s,lits[0], *i)){
+                        hConfl = *i++;
+                        // Copy the remaining watches:
+                        while (i < end)
+                            *j++ = *i++;
+                    }
+                }
+            }
+        next:
+            i++;
+        }
+
+        s->stats.inspects += j - veci_begin(ws);
+        veci_resize(ws,j - veci_begin(ws));
+#ifdef TEST_CNF_LOAD
+        }
+#endif
+    }
+
+    return hConfl;
+}
+
+//=================================================================================================
+// External solver functions:
+
+sat_solver* sat_solver_new(void)
+{
+    sat_solver* s = (sat_solver*)ABC_CALLOC( char, sizeof(sat_solver));
+
+//    Vec_SetAlloc_(&s->Mem, 15);
+    Sat_MemAlloc_(&s->Mem, 17);
+    s->hLearnts = -1;
+    s->hBinary = Sat_MemAppend( &s->Mem, NULL, 2, 0, 0 );
+    s->binary = clause_read( s, s->hBinary );
+
+    s->nLearntStart = LEARNT_MAX_START_DEFAULT;  // starting learned clause limit
+    s->nLearntDelta = LEARNT_MAX_INCRE_DEFAULT;  // delta of learned clause limit
+    s->nLearntRatio = LEARNT_MAX_RATIO_DEFAULT;  // ratio of learned clause limit
+    s->nLearntMax   = s->nLearntStart;
+
+    // initialize vectors
+    veci_new(&s->order);
+    veci_new(&s->trail_lim);
+    veci_new(&s->tagged);
+//    veci_new(&s->learned);
+    veci_new(&s->act_clas);
+    veci_new(&s->stack);
+//    veci_new(&s->model);
+    veci_new(&s->unit_lits);
+    veci_new(&s->temp_clause);
+    veci_new(&s->conf_final);
+
+    // initialize arrays
+    s->wlists    = 0;
+    s->activity  = 0;
+    s->orderpos  = 0;
+    s->reasons   = 0;
+    s->trail     = 0;
+
+    // initialize other vars
+    s->size                   = 0;
+    s->cap                    = 0;
+    s->qhead                  = 0;
+    s->qtail                  = 0;
+
+    solver_init_activities(s);
+    veci_new(&s->act_vars);
+
+    s->root_level             = 0;
+//    s->simpdb_assigns         = 0;
+//    s->simpdb_props           = 0;
+    s->progress_estimate      = 0;
+//    s->binary                 = (clause*)ABC_ALLOC( char, sizeof(clause) + sizeof(lit)*2);
+//    s->binary->size_learnt    = (2 << 1);
+    s->verbosity              = 0;
+
+    s->stats.starts           = 0;
+    s->stats.decisions        = 0;
+    s->stats.propagations     = 0;
+    s->stats.inspects         = 0;
+    s->stats.conflicts        = 0;
+    s->stats.clauses          = 0;
+    s->stats.clauses_literals = 0;
+    s->stats.learnts          = 0;
+    s->stats.learnts_literals = 0;
+    s->stats.tot_literals     = 0;
+    return s;
+}
+
+sat_solver* zsat_solver_new_seed(double seed)
+{
+    sat_solver* s = (sat_solver*)ABC_CALLOC( char, sizeof(sat_solver));
+
+//    Vec_SetAlloc_(&s->Mem, 15);
+    Sat_MemAlloc_(&s->Mem, 15);
+    s->hLearnts = -1;
+    s->hBinary = Sat_MemAppend( &s->Mem, NULL, 2, 0, 0 );
+    s->binary = clause_read( s, s->hBinary );
+
+    s->nLearntStart = LEARNT_MAX_START_DEFAULT;  // starting learned clause limit
+    s->nLearntDelta = LEARNT_MAX_INCRE_DEFAULT;  // delta of learned clause limit
+    s->nLearntRatio = LEARNT_MAX_RATIO_DEFAULT;  // ratio of learned clause limit
+    s->nLearntMax   = s->nLearntStart;
+
+    // initialize vectors
+    veci_new(&s->order);
+    veci_new(&s->trail_lim);
+    veci_new(&s->tagged);
+//    veci_new(&s->learned);
+    veci_new(&s->act_clas);
+    veci_new(&s->stack);
+//    veci_new(&s->model);
+    veci_new(&s->unit_lits);
+    veci_new(&s->temp_clause);
+    veci_new(&s->conf_final);
+
+    // initialize arrays
+    s->wlists    = 0;
+    s->activity  = 0;
+    s->orderpos  = 0;
+    s->reasons   = 0;
+    s->trail     = 0;
+
+    // initialize other vars
+    s->size                   = 0;
+    s->cap                    = 0;
+    s->qhead                  = 0;
+    s->qtail                  = 0;
+
+    solver_init_activities(s);
+    veci_new(&s->act_vars);
+
+    s->root_level             = 0;
+//    s->simpdb_assigns         = 0;
+//    s->simpdb_props           = 0;
+    s->random_seed            = seed;
+    s->progress_estimate      = 0;
+//    s->binary                 = (clause*)ABC_ALLOC( char, sizeof(clause) + sizeof(lit)*2);
+//    s->binary->size_learnt    = (2 << 1);
+    s->verbosity              = 0;
+
+    s->stats.starts           = 0;
+    s->stats.decisions        = 0;
+    s->stats.propagations     = 0;
+    s->stats.inspects         = 0;
+    s->stats.conflicts        = 0;
+    s->stats.clauses          = 0;
+    s->stats.clauses_literals = 0;
+    s->stats.learnts          = 0;
+    s->stats.learnts_literals = 0;
+    s->stats.tot_literals     = 0;
+    return s;
+}
+
+int sat_solver_addvar(sat_solver* s)
+{
+    sat_solver_setnvars(s, s->size+1);
+    return s->size-1;
+}
+void sat_solver_setnvars(sat_solver* s,int n)
+{
+    int var;
+
+    if (s->cap < n){
+        int old_cap = s->cap;
+        while (s->cap < n) s->cap = s->cap*2+1;
+        if ( s->cap < 50000 )
+            s->cap = 50000;
+
+        s->wlists    = ABC_REALLOC(veci,   s->wlists,   s->cap*2);
+//        s->vi        = ABC_REALLOC(varinfo,s->vi,       s->cap);
+        s->levels    = ABC_REALLOC(int,    s->levels,   s->cap);
+        s->assigns   = ABC_REALLOC(char,   s->assigns,  s->cap);
+        s->polarity  = ABC_REALLOC(char,   s->polarity, s->cap);
+        s->tags      = ABC_REALLOC(char,   s->tags,     s->cap);
+        s->loads     = ABC_REALLOC(char,   s->loads,    s->cap);
+        s->activity  = ABC_REALLOC(word,   s->activity, s->cap);
+        s->activity2 = ABC_REALLOC(word,   s->activity2,s->cap);
+        s->pFreqs    = ABC_REALLOC(char,   s->pFreqs,   s->cap);
+
+        if ( s->factors )
+        s->factors   = ABC_REALLOC(double, s->factors,  s->cap);
+        s->orderpos  = ABC_REALLOC(int,    s->orderpos, s->cap);
+        s->reasons   = ABC_REALLOC(int,    s->reasons,  s->cap);
+        s->trail     = ABC_REALLOC(lit,    s->trail,    s->cap);
+        s->model     = ABC_REALLOC(int,    s->model,    s->cap);
+        memset( s->wlists + 2*old_cap, 0, 2*(s->cap-old_cap)*sizeof(veci) );
+    } 
+
+    for (var = s->size; var < n; var++){
+        assert(!s->wlists[2*var].size);
+        assert(!s->wlists[2*var+1].size);
+        if ( s->wlists[2*var].ptr == NULL )
+            veci_new(&s->wlists[2*var]);
+        if ( s->wlists[2*var+1].ptr == NULL )
+            veci_new(&s->wlists[2*var+1]);
+
+        if ( s->VarActType == 0 )
+            s->activity[var] = (1<<10);
+        else if ( s->VarActType == 1 )
+            s->activity[var] = 0;
+        else if ( s->VarActType == 2 )
+            s->activity[var] = 0;
+        else assert(0);
+
+        s->pFreqs[var]   = 0;
+        if ( s->factors )
+        s->factors [var] = 0;
+//        *((int*)s->vi + var) = 0; s->vi[var].val = varX;
+        s->levels  [var] = 0;
+        s->assigns [var] = varX;
+        s->polarity[var] = 0;
+        s->tags    [var] = 0;
+        s->loads   [var] = 0;
+        s->orderpos[var] = veci_size(&s->order);
+        s->reasons [var] = 0;
+        s->model   [var] = 0; 
+        
+        /* does not hold because variables enqueued at top level will not be reinserted in the heap
+           assert(veci_size(&s->order) == var); 
+         */
+        veci_push(&s->order,var);
+        order_update(s, var);
+    }
+
+    s->size = n > s->size ? n : s->size;
+}
+
+void sat_solver_delete(sat_solver* s)
+{
+//    Vec_SetFree_( &s->Mem );
+    Sat_MemFree_( &s->Mem );
+
+    // delete vectors
+    veci_delete(&s->order);
+    veci_delete(&s->trail_lim);
+    veci_delete(&s->tagged);
+//    veci_delete(&s->learned);
+    veci_delete(&s->act_clas);
+    veci_delete(&s->stack);
+//    veci_delete(&s->model);
+    veci_delete(&s->act_vars);
+    veci_delete(&s->unit_lits);
+    veci_delete(&s->pivot_vars);
+    veci_delete(&s->temp_clause);
+    veci_delete(&s->conf_final);
+
+    veci_delete(&s->user_vars);
+    veci_delete(&s->user_values);
+
+    // delete arrays
+    if (s->reasons != 0){
+        int i;
+        for (i = 0; i < s->cap*2; i++)
+            veci_delete(&s->wlists[i]);
+        ABC_FREE(s->wlists   );
+//        ABC_FREE(s->vi       );
+        ABC_FREE(s->levels   );
+        ABC_FREE(s->assigns  );
+        ABC_FREE(s->polarity );
+        ABC_FREE(s->tags     );
+        ABC_FREE(s->loads    );
+        ABC_FREE(s->activity );
+        ABC_FREE(s->activity2);
+        ABC_FREE(s->pFreqs   );
+        ABC_FREE(s->factors  );
+        ABC_FREE(s->orderpos );
+        ABC_FREE(s->reasons  );
+        ABC_FREE(s->trail    );
+        ABC_FREE(s->model    );
+    }
+
+    sat_solver_store_free(s);
+    ABC_FREE(s);
+}
+
+void sat_solver_restart( sat_solver* s )
+{
+    int i;
+    Sat_MemRestart( &s->Mem );
+    s->hLearnts = -1;
+    s->hBinary = Sat_MemAppend( &s->Mem, NULL, 2, 0, 0 );
+    s->binary = clause_read( s, s->hBinary );
+
+    veci_resize(&s->trail_lim, 0);
+    veci_resize(&s->order, 0);
+    for ( i = 0; i < s->size*2; i++ )
+        s->wlists[i].size = 0;
+
+    s->nDBreduces = 0;
+
+    // initialize other vars
+    s->size                   = 0;
+//    s->cap                    = 0;
+    s->qhead                  = 0;
+    s->qtail                  = 0;
+
+
+    // variable activities
+    solver_init_activities(s);
+    veci_resize(&s->act_clas, 0);
+
+
+    s->root_level             = 0;
+//    s->simpdb_assigns         = 0;
+//    s->simpdb_props           = 0;
+    s->progress_estimate      = 0;
+    s->verbosity              = 0;
+
+    s->stats.starts           = 0;
+    s->stats.decisions        = 0;
+    s->stats.propagations     = 0;
+    s->stats.inspects         = 0;
+    s->stats.conflicts        = 0;
+    s->stats.clauses          = 0;
+    s->stats.clauses_literals = 0;
+    s->stats.learnts          = 0;
+    s->stats.learnts_literals = 0;
+    s->stats.tot_literals     = 0;
+}
+
+void zsat_solver_restart_seed( sat_solver* s, double seed )
+{
+    int i;
+    Sat_MemRestart( &s->Mem );
+    s->hLearnts = -1;
+    s->hBinary = Sat_MemAppend( &s->Mem, NULL, 2, 0, 0 );
+    s->binary = clause_read( s, s->hBinary );
+
+    veci_resize(&s->trail_lim, 0);
+    veci_resize(&s->order, 0);
+    for ( i = 0; i < s->size*2; i++ )
+        s->wlists[i].size = 0;
+
+    s->nDBreduces = 0;
+
+    // initialize other vars
+    s->size                   = 0;
+//    s->cap                    = 0;
+    s->qhead                  = 0;
+    s->qtail                  = 0;
+
+    solver_init_activities(s);
+    veci_resize(&s->act_clas, 0);
+
+    s->root_level             = 0;
+//    s->simpdb_assigns         = 0;
+//    s->simpdb_props           = 0;
+    s->random_seed            = seed;
+    s->progress_estimate      = 0;
+    s->verbosity              = 0;
+
+    s->stats.starts           = 0;
+    s->stats.decisions        = 0;
+    s->stats.propagations     = 0;
+    s->stats.inspects         = 0;
+    s->stats.conflicts        = 0;
+    s->stats.clauses          = 0;
+    s->stats.clauses_literals = 0;
+    s->stats.learnts          = 0;
+    s->stats.learnts_literals = 0;
+    s->stats.tot_literals     = 0;
+}
+
+// returns memory in bytes used by the SAT solver
+double sat_solver_memory( sat_solver* s )
+{
+    int i;
+    double Mem = sizeof(sat_solver);
+    for (i = 0; i < s->cap*2; i++)
+        Mem += s->wlists[i].cap * sizeof(int);
+    Mem += s->cap * sizeof(veci);     // ABC_FREE(s->wlists   );
+    Mem += s->cap * sizeof(int);      // ABC_FREE(s->levels   );
+    Mem += s->cap * sizeof(char);     // ABC_FREE(s->assigns  );
+    Mem += s->cap * sizeof(char);     // ABC_FREE(s->polarity );
+    Mem += s->cap * sizeof(char);     // ABC_FREE(s->tags     );
+    Mem += s->cap * sizeof(char);     // ABC_FREE(s->loads    );
+    Mem += s->cap * sizeof(word);     // ABC_FREE(s->activity );
+    if ( s->activity2 )
+    Mem += s->cap * sizeof(word);     // ABC_FREE(s->activity );
+    if ( s->factors )
+    Mem += s->cap * sizeof(double);   // ABC_FREE(s->factors  );
+    Mem += s->cap * sizeof(int);      // ABC_FREE(s->orderpos );
+    Mem += s->cap * sizeof(int);      // ABC_FREE(s->reasons  );
+    Mem += s->cap * sizeof(lit);      // ABC_FREE(s->trail    );
+    Mem += s->cap * sizeof(int);      // ABC_FREE(s->model    );
+
+    Mem += s->order.cap * sizeof(int);
+    Mem += s->trail_lim.cap * sizeof(int);
+    Mem += s->tagged.cap * sizeof(int);
+//    Mem += s->learned.cap * sizeof(int);
+    Mem += s->stack.cap * sizeof(int);
+    Mem += s->act_vars.cap * sizeof(int);
+    Mem += s->unit_lits.cap * sizeof(int);
+    Mem += s->act_clas.cap * sizeof(int);
+    Mem += s->temp_clause.cap * sizeof(int);
+    Mem += s->conf_final.cap * sizeof(int);
+    Mem += Sat_MemMemoryAll( &s->Mem );
+    return Mem;
+}
+
+int sat_solver_simplify(sat_solver* s)
+{
+    assert(sat_solver_dl(s) == 0);
+    if (sat_solver_propagate(s) != 0)
+        return false;
+    return true;
+}
+
+void sat_solver_reducedb(sat_solver* s)
+{
+    static abctime TimeTotal = 0;
+    abctime clk = Abc_Clock();
+    Sat_Mem_t * pMem = &s->Mem;
+    int nLearnedOld = veci_size(&s->act_clas);
+    int * act_clas = veci_begin(&s->act_clas);
+    int * pPerm, * pArray, * pSortValues, nCutoffValue;
+    int i, k, j, Id, Counter, CounterStart, nSelected;
+    clause * c;
+
+    assert( s->nLearntMax > 0 );
+    assert( nLearnedOld == Sat_MemEntryNum(pMem, 1) );
+    assert( nLearnedOld == (int)s->stats.learnts );
+
+    s->nDBreduces++;
+
+    //printf( "Calling reduceDB with %d learned clause limit.\n", s->nLearntMax );
+    s->nLearntMax = s->nLearntStart + s->nLearntDelta * s->nDBreduces;
+//    return;
+
+    // create sorting values
+    pSortValues = ABC_ALLOC( int, nLearnedOld );
+    Sat_MemForEachLearned( pMem, c, i, k )
+    {
+        Id = clause_id(c);
+//        pSortValues[Id] = act[Id];
+        if ( s->ClaActType == 0 )
+            pSortValues[Id] = ((7 - Abc_MinInt(c->lbd, 7)) << 28) | (act_clas[Id] >> 4);
+        else
+            pSortValues[Id] = ((7 - Abc_MinInt(c->lbd, 7)) << 28);// | (act_clas[Id] >> 4);
+        assert( pSortValues[Id] >= 0 );
+    }
+
+    // preserve 1/20 of last clauses
+    CounterStart  = nLearnedOld - (s->nLearntMax / 20);
+
+    // preserve 3/4 of most active clauses
+    nSelected = nLearnedOld*s->nLearntRatio/100;
+
+    // find non-decreasing permutation
+    pPerm = Abc_MergeSortCost( pSortValues, nLearnedOld );
+    assert( pSortValues[pPerm[0]] <= pSortValues[pPerm[nLearnedOld-1]] );
+    nCutoffValue = pSortValues[pPerm[nLearnedOld-nSelected]];
+    ABC_FREE( pPerm );
+//    ActCutOff = ABC_INFINITY;
+
+    // mark learned clauses to remove
+    Counter = j = 0;
+    Sat_MemForEachLearned( pMem, c, i, k )
+    {
+        assert( c->mark == 0 );
+        if ( Counter++ > CounterStart || clause_size(c) < 3 || pSortValues[clause_id(c)] > nCutoffValue || s->reasons[lit_var(c->lits[0])] == Sat_MemHand(pMem, i, k) )
+            act_clas[j++] = act_clas[clause_id(c)];
+        else // delete
+        {
+            c->mark = 1;
+            s->stats.learnts_literals -= clause_size(c);
+            s->stats.learnts--;
+        }
+    }
+    assert( s->stats.learnts == (unsigned)j );
+    assert( Counter == nLearnedOld );
+    veci_resize(&s->act_clas,j);
+    ABC_FREE( pSortValues );
+
+    // update ID of each clause to be its new handle
+    Counter = Sat_MemCompactLearned( pMem, 0 );
+    assert( Counter == (int)s->stats.learnts );
+
+    // update reasons
+    for ( i = 0; i < s->size; i++ )
+    {
+        if ( !s->reasons[i] ) // no reason
+            continue;
+        if ( clause_is_lit(s->reasons[i]) ) // 2-lit clause
+            continue;
+        if ( !clause_learnt_h(pMem, s->reasons[i]) ) // problem clause
+            continue;
+        c = clause_read( s, s->reasons[i] );
+        assert( c->mark == 0 );
+        s->reasons[i] = clause_id(c); // updating handle here!!!
+    }
+
+    // update watches
+    for ( i = 0; i < s->size*2; i++ )
+    {
+        pArray = veci_begin(&s->wlists[i]);
+        for ( j = k = 0; k < veci_size(&s->wlists[i]); k++ )
+        {
+            if ( clause_is_lit(pArray[k]) ) // 2-lit clause
+                pArray[j++] = pArray[k];
+            else if ( !clause_learnt_h(pMem, pArray[k]) ) // problem clause
+                pArray[j++] = pArray[k];
+            else 
+            {
+                c = clause_read(s, pArray[k]);
+                if ( !c->mark ) // useful learned clause
+                   pArray[j++] = clause_id(c); // updating handle here!!!
+            }
+        }
+        veci_resize(&s->wlists[i],j);
+    }
+
+    // perform final move of the clauses
+    Counter = Sat_MemCompactLearned( pMem, 1 );
+    assert( Counter == (int)s->stats.learnts );
+
+    // report the results
+    TimeTotal += Abc_Clock() - clk;
+}
+
+
+// reverses to the previously bookmarked point
+void sat_solver_rollback( sat_solver* s )
+{
+    Sat_Mem_t * pMem = &s->Mem;
+    int i, k, j;
+    static int Count = 0;
+    Count++;
+    assert( s->iVarPivot >= 0 && s->iVarPivot <= s->size );
+    assert( s->iTrailPivot >= 0 && s->iTrailPivot <= s->qtail );
+    // reset implication queue
+    sat_solver_canceluntil_rollback( s, s->iTrailPivot );
+    // update order 
+    if ( s->iVarPivot < s->size )
+    { 
+        if ( s->activity2 )
+        {
+            s->var_inc = s->var_inc2;
+            memcpy( s->activity, s->activity2, sizeof(word) * s->iVarPivot );
+        }
+        veci_resize(&s->order, 0);
+        for ( i = 0; i < s->iVarPivot; i++ )
+        {
+            if ( var_value(s, i) != varX )
+                continue;
+            s->orderpos[i] = veci_size(&s->order);
+            veci_push(&s->order,i);
+            order_update(s, i);
+        }
+    }
+    // compact watches
+    for ( i = 0; i < s->iVarPivot*2; i++ )
+    {
+        cla* pArray = veci_begin(&s->wlists[i]);
+        for ( j = k = 0; k < veci_size(&s->wlists[i]); k++ )
+        {
+            if ( clause_is_lit(pArray[k]) )
+            {
+                if ( clause_read_lit(pArray[k]) < s->iVarPivot*2 )
+                    pArray[j++] = pArray[k];
+            }
+            else if ( Sat_MemClauseUsed(pMem, pArray[k]) )
+                pArray[j++] = pArray[k];
+        }
+        veci_resize(&s->wlists[i],j);
+    }
+    // reset watcher lists
+    for ( i = 2*s->iVarPivot; i < 2*s->size; i++ )
+        s->wlists[i].size = 0;
+
+    // reset clause counts
+    s->stats.clauses = pMem->BookMarkE[0];
+    s->stats.learnts = pMem->BookMarkE[1];
+    // rollback clauses
+    Sat_MemRollBack( pMem );
+
+    // resize learned arrays
+    veci_resize(&s->act_clas,  s->stats.learnts);
+
+    // initialize other vars
+    s->size = s->iVarPivot;
+    if ( s->size == 0 )
+    {
+    //    s->size                   = 0;
+    //    s->cap                    = 0;
+        s->qhead                  = 0;
+        s->qtail                  = 0;
+
+        solver_init_activities(s);
+
+        s->root_level             = 0;
+        s->progress_estimate      = 0;
+        s->verbosity              = 0;
+
+        s->stats.starts           = 0;
+        s->stats.decisions        = 0;
+        s->stats.propagations     = 0;
+        s->stats.inspects         = 0;
+        s->stats.conflicts        = 0;
+        s->stats.clauses          = 0;
+        s->stats.clauses_literals = 0;
+        s->stats.learnts          = 0;
+        s->stats.learnts_literals = 0;
+        s->stats.tot_literals     = 0;
+
+        // initialize rollback
+        s->iVarPivot              =  0; // the pivot for variables
+        s->iTrailPivot            =  0; // the pivot for trail
+        s->hProofPivot            =  1; // the pivot for proof records
+    }
+}
+
+
+int sat_solver_addclause(sat_solver* s, lit* begin, lit* end)
+{
+    lit *i,*j;
+    int maxvar;
+    lit last;
+    assert( begin < end );
+    if ( s->fPrintClause )
+    {
+        for ( i = begin; i < end; i++ )
+            printf( "%s%d ", (*i)&1 ? "!":"", (*i)>>1 );
+        printf( "\n" );
+    }
+
+    veci_resize( &s->temp_clause, 0 );
+    for ( i = begin; i < end; i++ )
+        veci_push( &s->temp_clause, *i );
+    begin = veci_begin( &s->temp_clause );
+    end = begin + veci_size( &s->temp_clause );
+
+    // insertion sort
+    maxvar = lit_var(*begin);
+    for (i = begin + 1; i < end; i++){
+        lit l = *i;
+        maxvar = lit_var(l) > maxvar ? lit_var(l) : maxvar;
+        for (j = i; j > begin && *(j-1) > l; j--)
+            *j = *(j-1);
+        *j = l;
+    }
+    sat_solver_setnvars(s,maxvar+1);
+
+    ///////////////////////////////////
+    // add clause to internal storage
+    if ( s->pStore )
+    {
+        int RetValue = Sto_ManAddClause( (Sto_Man_t *)s->pStore, begin, end );
+        assert( RetValue );
+        (void) RetValue;
+    }
+    ///////////////////////////////////
+
+    // delete duplicates
+    last = lit_Undef;
+    for (i = j = begin; i < end; i++){
+        //printf("lit: "L_LIT", value = %d\n", L_lit(*i), (lit_sign(*i) ? -s->assignss[lit_var(*i)] : s->assignss[lit_var(*i)]));
+        if (*i == lit_neg(last) || var_value(s, lit_var(*i)) == lit_sign(*i))
+            return true;   // tautology
+        else if (*i != last && var_value(s, lit_var(*i)) == varX)
+            last = *j++ = *i;
+    }
+//    j = i;
+
+    if (j == begin)          // empty clause
+        return false;
+
+    if (j - begin == 1) // unit clause
+        return sat_solver_enqueue(s,*begin,0);
+
+    // create new clause
+    sat_solver_clause_new(s,begin,j,0);
+    return true;
+}
+
+double luby(double y, int x)
+{
+    int size, seq;
+    for (size = 1, seq = 0; size < x+1; seq++, size = 2*size + 1);
+    while (size-1 != x){
+        size = (size-1) >> 1;
+        seq--;
+        x = x % size;
+    }
+    return pow(y, (double)seq);
+} 
+
+void luby_test()
+{
+    int i;
+    for ( i = 0; i < 20; i++ )
+        printf( "%d ", (int)luby(2,i) );
+    printf( "\n" );
+}
+
+static lbool sat_solver_search(sat_solver* s, ABC_INT64_T nof_conflicts)
+{
+//    double  var_decay       = 0.95;
+//    double  clause_decay    = 0.999;
+    double  random_var_freq = s->fNotUseRandom ? 0.0 : 0.02;
+    ABC_INT64_T  conflictC  = 0;
+    veci    learnt_clause;
+    int     i;
+
+    assert(s->root_level == sat_solver_dl(s));
+
+    s->nRestarts++;
+    s->stats.starts++;
+//    s->var_decay = (float)(1 / var_decay   );  // move this to sat_solver_new()
+//    s->cla_decay = (float)(1 / clause_decay);  // move this to sat_solver_new()
+//    veci_resize(&s->model,0);
+    veci_new(&learnt_clause);
+
+    // use activity factors in every even restart
+    if ( (s->nRestarts & 1) && veci_size(&s->act_vars) > 0 )
+//    if ( veci_size(&s->act_vars) > 0 )
+        for ( i = 0; i < s->act_vars.size; i++ )
+            act_var_bump_factor(s, s->act_vars.ptr[i]);
+
+    // use activity factors in every restart
+    if ( s->pGlobalVars && veci_size(&s->act_vars) > 0 )
+        for ( i = 0; i < s->act_vars.size; i++ )
+            act_var_bump_global(s, s->act_vars.ptr[i]);
+
+    for (;;){
+        int hConfl = sat_solver_propagate(s);
+        if (hConfl != 0){
+            // CONFLICT
+            int blevel;
+
+#ifdef VERBOSEDEBUG
+            printf(L_IND"**CONFLICT**\n", L_ind);
+#endif
+            s->stats.conflicts++; conflictC++;
+            if (sat_solver_dl(s) == s->root_level){
+#ifdef SAT_USE_ANALYZE_FINAL
+                sat_solver_analyze_final(s, hConfl, 0);
+#endif
+                veci_delete(&learnt_clause);
+                return l_False;
+            }
+
+            veci_resize(&learnt_clause,0);
+            sat_solver_analyze(s, hConfl, &learnt_clause);
+            blevel = veci_size(&learnt_clause) > 1 ? var_level(s, lit_var(veci_begin(&learnt_clause)[1])) : s->root_level;
+            blevel = s->root_level > blevel ? s->root_level : blevel;
+            sat_solver_canceluntil(s,blevel);
+            sat_solver_record(s,&learnt_clause);
+#ifdef SAT_USE_ANALYZE_FINAL
+//            if (learnt_clause.size() == 1) level[var(learnt_clause[0])] = 0;    // (this is ugly (but needed for 'analyzeFinal()') -- in future versions, we will backtrack past the 'root_level' and redo the assumptions)
+            if ( learnt_clause.size == 1 ) 
+                var_set_level(s, lit_var(learnt_clause.ptr[0]), 0);
+#endif
+            act_var_decay(s);
+            act_clause_decay(s);
+
+        }else{
+            // NO CONFLICT
+            int next;
+
+            // Reached bound on number of conflicts:
+            if ( (!s->fNoRestarts && nof_conflicts >= 0 && conflictC >= nof_conflicts) || (s->nRuntimeLimit && (s->stats.conflicts & 63) == 0 && Abc_Clock() > s->nRuntimeLimit)){
+                s->progress_estimate = sat_solver_progress(s);
+                sat_solver_canceluntil(s,s->root_level);
+                veci_delete(&learnt_clause);
+                return l_Undef; }
+
+            // Reached bound on number of conflicts:
+            if ( (s->nConfLimit && s->stats.conflicts > s->nConfLimit) ||
+                 (s->nInsLimit  && s->stats.propagations > s->nInsLimit) )
+            {
+                s->progress_estimate = sat_solver_progress(s);
+                sat_solver_canceluntil(s,s->root_level);
+                veci_delete(&learnt_clause);
+                return l_Undef; 
+            }
+
+            // Simplify the set of problem clauses:
+            if (sat_solver_dl(s) == 0 && !s->fSkipSimplify)
+                sat_solver_simplify(s);
+
+            // Reduce the set of learnt clauses:
+//            if (s->nLearntMax && veci_size(&s->learned) - s->qtail >= s->nLearntMax)
+            if (s->nLearntMax && veci_size(&s->act_clas) >= s->nLearntMax)
+                sat_solver_reducedb(s);
+
+            // New variable decision:
+            s->stats.decisions++;
+            next = order_select(s,(float)random_var_freq);
+
+            if (next == var_Undef){
+                // Model found:
+                int i;
+                for (i = 0; i < s->size; i++)
+                    s->model[i] = (var_value(s,i)==var1 ? l_True : l_False);
+                sat_solver_canceluntil(s,s->root_level);
+                veci_delete(&learnt_clause);
+
+                /*
+                veci apa; veci_new(&apa);
+                for (i = 0; i < s->size; i++) 
+                    veci_push(&apa,(int)(s->model.ptr[i] == l_True ? toLit(i) : lit_neg(toLit(i))));
+                printf("model: "); printlits((lit*)apa.ptr, (lit*)apa.ptr + veci_size(&apa)); printf("\n");
+                veci_delete(&apa);
+                */
+
+                return l_True;
+            }
+
+            if ( var_polar(s, next) ) // positive polarity
+                sat_solver_decision(s,toLit(next));
+            else
+                sat_solver_decision(s,lit_neg(toLit(next)));
+        }
+    }
+
+    return l_Undef; // cannot happen
+}
+
+// internal call to the SAT solver
+int sat_solver_solve_internal(sat_solver* s)
+{
+    lbool status = l_Undef;
+    int restart_iter = 0;
+    veci_resize(&s->unit_lits, 0);
+    s->nCalls++;
+
+    if (s->verbosity >= 1){
+        printf("==================================[MINISAT]===================================\n");
+        printf("| Conflicts |     ORIGINAL     |              LEARNT              | Progress |\n");
+        printf("|           | Clauses Literals |   Limit Clauses Literals  Lit/Cl |          |\n");
+        printf("==============================================================================\n");
+    }
+
+    while (status == l_Undef){
+        ABC_INT64_T nof_conflicts;
+        double Ratio = (s->stats.learnts == 0)? 0.0 :
+            s->stats.learnts_literals / (double)s->stats.learnts;
+        if ( s->nRuntimeLimit && Abc_Clock() > s->nRuntimeLimit )
+            break;
+        if (s->verbosity >= 1)
+        {
+            printf("| %9.0f | %7.0f %8.0f | %7.0f %7.0f %8.0f %7.1f | %6.3f %% |\n", 
+                (double)s->stats.conflicts,
+                (double)s->stats.clauses, 
+                (double)s->stats.clauses_literals,
+                (double)0, 
+                (double)s->stats.learnts, 
+                (double)s->stats.learnts_literals,
+                Ratio,
+                s->progress_estimate*100);
+            fflush(stdout);
+        }
+        nof_conflicts = (ABC_INT64_T)( 100 * luby(2, restart_iter++) );
+        status = sat_solver_search(s, nof_conflicts);
+        // quit the loop if reached an external limit
+        if ( s->nConfLimit && s->stats.conflicts > s->nConfLimit )
+            break;
+        if ( s->nInsLimit  && s->stats.propagations > s->nInsLimit )
+            break;
+        if ( s->nRuntimeLimit && Abc_Clock() > s->nRuntimeLimit )
+            break;
+        if ( s->pFuncStop && s->pFuncStop(s->RunId) )
+            break;
+    }
+    if (s->verbosity >= 1)
+        printf("==============================================================================\n");
+
+    sat_solver_canceluntil(s,s->root_level);
+    // save variable values
+    if ( status == l_True && s->user_vars.size )
+    {
+        int v;
+        for ( v = 0; v < s->user_vars.size; v++ )
+            veci_push(&s->user_values, sat_solver_var_value(s, s->user_vars.ptr[v]));
+    }
+    return status;
+}
+
+// pushing one assumption to the stack of assumptions
+int sat_solver_push(sat_solver* s, int p)
+{
+    assert(lit_var(p) < s->size);
+    veci_push(&s->trail_lim,s->qtail);
+    s->root_level++;
+    if (!sat_solver_enqueue(s,p,0))
+    {
+        int h = s->reasons[lit_var(p)];
+        if (h)
+        {
+            if (clause_is_lit(h))
+            {
+                (clause_begin(s->binary))[1] = lit_neg(p);
+                (clause_begin(s->binary))[0] = clause_read_lit(h);
+                h = s->hBinary;
+            }
+            sat_solver_analyze_final(s, h, 1);
+            veci_push(&s->conf_final, lit_neg(p));
+        }
+        else
+        {
+            veci_resize(&s->conf_final,0);
+            veci_push(&s->conf_final, lit_neg(p));
+            // the two lines below are a bug fix by Siert Wieringa 
+            if (var_level(s, lit_var(p)) > 0)
+                veci_push(&s->conf_final, p);
+        }
+        //sat_solver_canceluntil(s, 0);
+        return false; 
+    }
+    else
+    {
+        int fConfl = sat_solver_propagate(s);
+        if (fConfl){
+            sat_solver_analyze_final(s, fConfl, 0);
+            //assert(s->conf_final.size > 0);
+            //sat_solver_canceluntil(s, 0);
+            return false; }
+    }
+    return true;
+}
+
+// removing one assumption from the stack of assumptions
+void sat_solver_pop(sat_solver* s)
+{
+    assert( sat_solver_dl(s) > 0 );
+    sat_solver_canceluntil(s, --s->root_level);
+}
+
+void sat_solver_set_resource_limits(sat_solver* s, ABC_INT64_T nConfLimit, ABC_INT64_T nInsLimit, ABC_INT64_T nConfLimitGlobal, ABC_INT64_T nInsLimitGlobal)
+{
+    // set the external limits
+    s->nRestarts  = 0;
+    s->nConfLimit = 0;
+    s->nInsLimit  = 0;
+    if ( nConfLimit )
+        s->nConfLimit = s->stats.conflicts + nConfLimit;
+    if ( nInsLimit )
+//        s->nInsLimit = s->stats.inspects + nInsLimit;
+        s->nInsLimit = s->stats.propagations + nInsLimit;
+    if ( nConfLimitGlobal && (s->nConfLimit == 0 || s->nConfLimit > nConfLimitGlobal) )
+        s->nConfLimit = nConfLimitGlobal;
+    if ( nInsLimitGlobal && (s->nInsLimit == 0 || s->nInsLimit > nInsLimitGlobal) )
+        s->nInsLimit = nInsLimitGlobal;
+}
+
+int sat_solver_solve(sat_solver* s, lit* begin, lit* end, ABC_INT64_T nConfLimit, ABC_INT64_T nInsLimit, ABC_INT64_T nConfLimitGlobal, ABC_INT64_T nInsLimitGlobal)
+{
+    lbool status;
+    lit * i;
+    ////////////////////////////////////////////////
+    if ( s->fSolved )
+    {
+        if ( s->pStore )
+        {
+            int RetValue = Sto_ManAddClause( (Sto_Man_t *)s->pStore, NULL, NULL );
+            assert( RetValue );
+            (void) RetValue;
+        }
+        return l_False;
+    }
+    ////////////////////////////////////////////////
+
+    if ( s->fVerbose )
+        printf( "Running SAT solver with parameters %d and %d and %d.\n", s->nLearntStart, s->nLearntDelta, s->nLearntRatio );
+
+    sat_solver_set_resource_limits( s, nConfLimit, nInsLimit, nConfLimitGlobal, nInsLimitGlobal );
+
+#ifdef SAT_USE_ANALYZE_FINAL
+    // Perform assumptions:
+    s->root_level = 0;
+    for ( i = begin; i < end; i++ )
+        if ( !sat_solver_push(s, *i) )
+        {
+            sat_solver_canceluntil(s,0);
+            s->root_level = 0;
+            return l_False;
+        }
+    assert(s->root_level == sat_solver_dl(s));
+#else
+    //printf("solve: "); printlits(begin, end); printf("\n");
+    for (i = begin; i < end; i++){
+//        switch (lit_sign(*i) ? -s->assignss[lit_var(*i)] : s->assignss[lit_var(*i)]){
+        switch (var_value(s, *i)) {
+        case var1: // l_True: 
+            break;
+        case varX: // l_Undef
+            sat_solver_decision(s, *i);
+            if (sat_solver_propagate(s) == 0)
+                break;
+            // fallthrough
+        case var0: // l_False 
+            sat_solver_canceluntil(s, 0);
+            return l_False;
+        }
+    }
+    s->root_level = sat_solver_dl(s);
+#endif
+
+    status = sat_solver_solve_internal(s);
+
+    sat_solver_canceluntil(s,0);
+    s->root_level = 0;
+
+    ////////////////////////////////////////////////
+    if ( status == l_False && s->pStore )
+    {
+        int RetValue = Sto_ManAddClause( (Sto_Man_t *)s->pStore, NULL, NULL );
+        assert( RetValue );
+        (void) RetValue;
+    }
+    ////////////////////////////////////////////////
+    return status;
+}
+
+// This LEXSAT procedure should be called with a set of literals (pLits, nLits),
+// which defines both (1) variable order, and (2) assignment to begin search from.
+// It retuns the LEXSAT assigment that is the same or larger than the given one.
+// (It assumes that there is no smaller assignment than the one given!)
+// The resulting assignment is returned in the same set of literals (pLits, nLits).
+// It pushes/pops assumptions internally and will undo them before terminating.
+int sat_solver_solve_lexsat( sat_solver* s, int * pLits, int nLits )
+{
+    int i, iLitFail = -1;
+    lbool status;
+    assert( nLits > 0 );
+    // help the SAT solver by setting desirable polarity
+    sat_solver_set_literal_polarity( s, pLits, nLits );
+    // check if there exists a satisfying assignment
+    status = sat_solver_solve_internal( s );
+    if ( status != l_True ) // no assignment
+        return status;
+    // there is at least one satisfying assignment
+    assert( status == l_True );
+    // find the first mismatching literal
+    for ( i = 0; i < nLits; i++ )
+        if ( pLits[i] != sat_solver_var_literal(s, Abc_Lit2Var(pLits[i])) )
+            break;
+    if ( i == nLits ) // no mismatch - the current assignment is the minimum one!
+        return l_True;
+    // mismatch happens in literal i
+    iLitFail = i;
+    // create assumptions up to this literal (as in pLits) - including this literal!
+    for ( i = 0; i <= iLitFail; i++ )
+        if ( !sat_solver_push(s, pLits[i]) ) // can become UNSAT while adding the last assumption
+            break;
+    if ( i < iLitFail + 1 ) // the solver became UNSAT while adding assumptions
+        status = l_False;
+    else // solve under the assumptions
+        status = sat_solver_solve_internal( s );
+    if ( status == l_True )
+    {
+        // we proved that there is a sat assignment with literal (iLitFail) having polarity as in pLits
+        // continue solving recursively
+        if ( iLitFail + 1 < nLits )
+            status = sat_solver_solve_lexsat( s, pLits + iLitFail + 1, nLits - iLitFail - 1 );
+    }
+    else if ( status == l_False )
+    {
+        // we proved that there is no assignment with iLitFail having polarity as in pLits
+        assert( Abc_LitIsCompl(pLits[iLitFail]) ); // literal is 0 
+        // (this assert may fail only if there is a sat assignment smaller than one originally given in pLits)
+        // now we flip this literal (make it 1), change the last assumption
+        // and contiue looking for the 000...0-assignment of other literals
+        sat_solver_pop( s );
+        pLits[iLitFail] = Abc_LitNot(pLits[iLitFail]);
+        if ( !sat_solver_push(s, pLits[iLitFail]) )
+            printf( "sat_solver_solve_lexsat(): A satisfying assignment should exist.\n" ); // because we know that the problem is satisfiable
+        // update other literals to be 000...0
+        for ( i = iLitFail + 1; i < nLits; i++ )
+            pLits[i] = Abc_LitNot( Abc_LitRegular(pLits[i]) );
+        // continue solving recursively
+        if ( iLitFail + 1 < nLits )
+            status = sat_solver_solve_lexsat( s, pLits + iLitFail + 1, nLits - iLitFail - 1 );
+        else
+            status = l_True;
+    }
+    // undo the assumptions
+    for ( i = iLitFail; i >= 0; i-- )
+        sat_solver_pop( s );
+    return status;
+}
+
+// This procedure is called on a set of assumptions to minimize their number.
+// The procedure relies on the fact that the current set of assumptions is UNSAT.  
+// It receives and returns SAT solver without assumptions. It returns the number 
+// of assumptions after minimization. The set of assumptions is returned in pLits.
+int sat_solver_minimize_assumptions( sat_solver* s, int * pLits, int nLits, int nConfLimit )
+{
+    int i, k, nLitsL, nLitsR, nResL, nResR, status;
+    if ( nLits == 1 )
+    {
+        // since the problem is UNSAT, we will try to solve it without assuming the last literal
+        // if the result is UNSAT, the last literal can be dropped; otherwise, it is needed
+        if ( nConfLimit ) s->nConfLimit = s->stats.conflicts + nConfLimit;
+        status = sat_solver_solve_internal( s );
+        //printf( "%c", status == l_False ? 'u' : 's' );
+        return (int)(status != l_False); // return 1 if the problem is not UNSAT
+    }
+    assert( nLits >= 2 );
+    nLitsL = nLits / 2;
+    nLitsR = nLits - nLitsL;
+    // assume the left lits
+    for ( i = 0; i < nLitsL; i++ )
+        if ( !sat_solver_push(s, pLits[i]) )
+        {
+            for ( k = i; k >= 0; k-- )
+                sat_solver_pop(s);
+            return sat_solver_minimize_assumptions( s, pLits, i+1, nConfLimit );
+        }
+    // solve with these assumptions
+    if ( nConfLimit ) s->nConfLimit = s->stats.conflicts + nConfLimit;
+    status = sat_solver_solve_internal( s );
+    if ( status == l_False ) // these are enough
+    {
+        for ( i = 0; i < nLitsL; i++ )
+            sat_solver_pop(s);
+        return sat_solver_minimize_assumptions( s, pLits, nLitsL, nConfLimit );
+    }
+    // solve for the right lits
+    nResL = nLitsR == 1 ? 1 : sat_solver_minimize_assumptions( s, pLits + nLitsL, nLitsR, nConfLimit );
+    for ( i = 0; i < nLitsL; i++ )
+        sat_solver_pop(s);
+    // swap literals
+//    assert( nResL <= nLitsL );
+//    for ( i = 0; i < nResL; i++ )
+//        ABC_SWAP( int, pLits[i], pLits[nLitsL+i] );
+    veci_resize( &s->temp_clause, 0 );
+    for ( i = 0; i < nLitsL; i++ )
+        veci_push( &s->temp_clause, pLits[i] );
+    for ( i = 0; i < nResL; i++ )
+        pLits[i] = pLits[nLitsL+i];
+    for ( i = 0; i < nLitsL; i++ )
+        pLits[nResL+i] = veci_begin(&s->temp_clause)[i];
+    // assume the right lits
+    for ( i = 0; i < nResL; i++ )
+        if ( !sat_solver_push(s, pLits[i]) )
+        {
+            for ( k = i; k >= 0; k-- )
+                sat_solver_pop(s);
+            return sat_solver_minimize_assumptions( s, pLits, i+1, nConfLimit );
+        }
+    // solve with these assumptions
+    if ( nConfLimit ) s->nConfLimit = s->stats.conflicts + nConfLimit;
+    status = sat_solver_solve_internal( s );
+    if ( status == l_False ) // these are enough
+    {
+        for ( i = 0; i < nResL; i++ )
+            sat_solver_pop(s);
+        return nResL;
+    }
+    // solve for the left lits
+    nResR = nLitsL == 1 ? 1 : sat_solver_minimize_assumptions( s, pLits + nResL, nLitsL, nConfLimit );
+    for ( i = 0; i < nResL; i++ )
+        sat_solver_pop(s);
+    return nResL + nResR;
+}
+
+// This is a specialized version of the above procedure with several custom changes:
+// - makes sure that at least one of the marked literals is preserved in the clause
+// - sets literals to zero when they do not have to be used
+// - sets literals to zero for disproved variables
+int sat_solver_minimize_assumptions2( sat_solver* s, int * pLits, int nLits, int nConfLimit )
+{
+    int i, k, nLitsL, nLitsR, nResL, nResR;
+    if ( nLits == 1 )
+    {
+        // since the problem is UNSAT, we will try to solve it without assuming the last literal
+        // if the result is UNSAT, the last literal can be dropped; otherwise, it is needed
+        int RetValue = 1, LitNot = Abc_LitNot(pLits[0]);
+        int status = l_False;
+        int Temp = s->nConfLimit; 
+        s->nConfLimit = nConfLimit;
+
+        RetValue = sat_solver_push( s, LitNot ); assert( RetValue );
+        status = sat_solver_solve_internal( s );
+        sat_solver_pop( s );
+
+        // if the problem is UNSAT, add clause
+        if ( status == l_False )
+        {
+            RetValue = sat_solver_addclause( s, &LitNot, &LitNot+1 );
+            assert( RetValue );
+        }
+
+        s->nConfLimit = Temp;
+        return (int)(status != l_False); // return 1 if the problem is not UNSAT
+    }
+    assert( nLits >= 2 );
+    nLitsL = nLits / 2;
+    nLitsR = nLits - nLitsL;
+    // assume the left lits
+    for ( i = 0; i < nLitsL; i++ )
+        if ( !sat_solver_push(s, pLits[i]) )
+        {
+            for ( k = i; k >= 0; k-- )
+                sat_solver_pop(s);
+
+            // add clauses for these literal
+            for ( k = i+1; k > nLitsL; k++ )
+            {
+                int LitNot = Abc_LitNot(pLits[i]);
+                int RetValue = sat_solver_addclause( s, &LitNot, &LitNot+1 );
+                assert( RetValue );
+            }
+
+            return sat_solver_minimize_assumptions2( s, pLits, i+1, nConfLimit );
+        }
+    // solve for the right lits
+    nResL = sat_solver_minimize_assumptions2( s, pLits + nLitsL, nLitsR, nConfLimit );
+    for ( i = 0; i < nLitsL; i++ )
+        sat_solver_pop(s);
+    // swap literals
+//    assert( nResL <= nLitsL );
+    veci_resize( &s->temp_clause, 0 );
+    for ( i = 0; i < nLitsL; i++ )
+        veci_push( &s->temp_clause, pLits[i] );
+    for ( i = 0; i < nResL; i++ )
+        pLits[i] = pLits[nLitsL+i];
+    for ( i = 0; i < nLitsL; i++ )
+        pLits[nResL+i] = veci_begin(&s->temp_clause)[i];
+    // assume the right lits
+    for ( i = 0; i < nResL; i++ )
+        if ( !sat_solver_push(s, pLits[i]) )
+        {
+            for ( k = i; k >= 0; k-- )
+                sat_solver_pop(s);
+
+            // add clauses for these literal
+            for ( k = i+1; k > nResL; k++ )
+            {
+                int LitNot = Abc_LitNot(pLits[i]);
+                int RetValue = sat_solver_addclause( s, &LitNot, &LitNot+1 );
+                assert( RetValue );
+            }
+
+            return sat_solver_minimize_assumptions2( s, pLits, i+1, nConfLimit );
+        }
+    // solve for the left lits
+    nResR = sat_solver_minimize_assumptions2( s, pLits + nResL, nLitsL, nConfLimit );
+    for ( i = 0; i < nResL; i++ )
+        sat_solver_pop(s);
+    return nResL + nResR;
+}
+
+
+
+int sat_solver_nvars(sat_solver* s)
+{
+    return s->size;
+}
+
+
+int sat_solver_nclauses(sat_solver* s)
+{
+    return s->stats.clauses;
+}
+
+
+int sat_solver_nconflicts(sat_solver* s)
+{
+    return (int)s->stats.conflicts;
+}
+
+//=================================================================================================
+// Clause storage functions:
+
+void sat_solver_store_alloc( sat_solver * s )
+{
+    assert( s->pStore == NULL );
+    s->pStore = Sto_ManAlloc();
+}
+
+void sat_solver_store_write( sat_solver * s, char * pFileName )
+{
+    if ( s->pStore ) Sto_ManDumpClauses( (Sto_Man_t *)s->pStore, pFileName );
+}
+
+void sat_solver_store_free( sat_solver * s )
+{
+    if ( s->pStore ) Sto_ManFree( (Sto_Man_t *)s->pStore );
+    s->pStore = NULL;
+}
+
+int sat_solver_store_change_last( sat_solver * s )
+{
+    if ( s->pStore ) return Sto_ManChangeLastClause( (Sto_Man_t *)s->pStore );
+    return -1;
+}
+ 
+void sat_solver_store_mark_roots( sat_solver * s )
+{
+    if ( s->pStore ) Sto_ManMarkRoots( (Sto_Man_t *)s->pStore );
+}
+
+void sat_solver_store_mark_clauses_a( sat_solver * s )
+{
+    if ( s->pStore ) Sto_ManMarkClausesA( (Sto_Man_t *)s->pStore );
+}
+
+void * sat_solver_store_release( sat_solver * s )
+{
+    void * pTemp;
+    if ( s->pStore == NULL )
+        return NULL;
+    pTemp = s->pStore;
+    s->pStore = NULL;
+    return pTemp;
+}
+
+
+ABC_NAMESPACE_IMPL_END
+
diff --git a/lib/abcsat/satStore.cpp b/lib/abcsat/satStore.cpp
new file mode 100644
index 0000000..1b382c0
--- /dev/null
+++ b/lib/abcsat/satStore.cpp
@@ -0,0 +1,469 @@
+/**CFile****************************************************************
+
+  FileName    [satStore.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SAT solver.]
+
+  Synopsis    [Records the trace of SAT solving in the CNF form.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: satStore.c,v 1.4 2005/09/16 22:55:03 casem Exp $]
+
+***********************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include <abc/satStore.h>
+
+ABC_NAMESPACE_IMPL_START
+
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Fetches memory.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+char * Sto_ManMemoryFetch( Sto_Man_t * p, int nBytes )
+{
+    char * pMem;
+    if ( p->pChunkLast == NULL || nBytes > p->nChunkSize - p->nChunkUsed )
+    {
+        pMem = (char *)ABC_ALLOC( char, p->nChunkSize );
+        *(char **)pMem = p->pChunkLast;
+        p->pChunkLast = pMem;
+        p->nChunkUsed = sizeof(char *);
+    }
+    pMem = p->pChunkLast + p->nChunkUsed;
+    p->nChunkUsed += nBytes;
+    return pMem;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Frees memory manager.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Sto_ManMemoryStop( Sto_Man_t * p )
+{
+    char * pMem, * pNext;
+    if ( p->pChunkLast == NULL )
+        return;
+    for ( pMem = p->pChunkLast; (pNext = *(char **)pMem); pMem = pNext )
+        ABC_FREE( pMem );
+    ABC_FREE( pMem );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Reports memory usage in bytes.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Sto_ManMemoryReport( Sto_Man_t * p )
+{
+    int Total;
+    char * pMem, * pNext;
+    if ( p->pChunkLast == NULL )
+        return 0;
+    Total = p->nChunkUsed; 
+    for ( pMem = p->pChunkLast; (pNext = *(char **)pMem); pMem = pNext )
+        Total += p->nChunkSize;
+    return Total;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Allocate proof manager.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Sto_Man_t * Sto_ManAlloc()
+{
+    Sto_Man_t * p;
+    // allocate the manager
+    p = (Sto_Man_t *)ABC_ALLOC( char, sizeof(Sto_Man_t) );
+    memset( p, 0, sizeof(Sto_Man_t) );
+    // memory management
+    p->nChunkSize = (1<<16); // use 64K chunks
+    return p;    
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Deallocate proof manager.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Sto_ManFree( Sto_Man_t * p )
+{
+    Sto_ManMemoryStop( p );
+    ABC_FREE( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Adds one clause to the manager.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Sto_ManAddClause( Sto_Man_t * p, lit * pBeg, lit * pEnd )
+{
+    Sto_Cls_t * pClause;
+    lit Lit, * i, * j;
+    int nSize;
+
+    // process the literals
+    if ( pBeg < pEnd )
+    {
+        // insertion sort
+        for ( i = pBeg + 1; i < pEnd; i++ )
+        {
+            Lit = *i;
+            for ( j = i; j > pBeg && *(j-1) > Lit; j-- )
+                *j = *(j-1);
+            *j = Lit;
+        }
+        // make sure there is no duplicated variables
+        for ( i = pBeg + 1; i < pEnd; i++ )
+            if ( lit_var(*(i-1)) == lit_var(*i) )
+            {
+                printf( "The clause contains two literals of the same variable: %d and %d.\n", *(i-1), *i );
+                return 0;
+            }
+        // check the largest var size
+        p->nVars = STO_MAX( p->nVars, lit_var(*(pEnd-1)) + 1 );
+    }
+
+    // get memory for the clause
+    nSize = sizeof(Sto_Cls_t) + sizeof(lit) * (pEnd - pBeg);
+    nSize = (nSize / sizeof(char*) + ((nSize % sizeof(char*)) > 0)) * sizeof(char*); // added by Saurabh on Sep 3, 2009
+    pClause = (Sto_Cls_t *)Sto_ManMemoryFetch( p, nSize );
+    memset( pClause, 0, sizeof(Sto_Cls_t) );
+
+    // assign the clause
+    pClause->Id = p->nClauses++;
+    pClause->nLits = pEnd - pBeg;
+    memcpy( pClause->pLits, pBeg, sizeof(lit) * (pEnd - pBeg) );
+//    assert( pClause->pLits[0] >= 0 );
+
+    // add the clause to the list
+    if ( p->pHead == NULL )
+        p->pHead = pClause;
+    if ( p->pTail == NULL )
+        p->pTail = pClause;
+    else
+    {
+        p->pTail->pNext = pClause;
+        p->pTail = pClause;
+    }
+
+    // add the empty clause
+    if ( pClause->nLits == 0 )
+    {
+        if ( p->pEmpty )
+        {
+            printf( "More than one empty clause!\n" );
+            return 0;
+        }
+        p->pEmpty = pClause;
+    }
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Mark all clauses added so far as root clauses.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Sto_ManMarkRoots( Sto_Man_t * p )
+{
+    Sto_Cls_t * pClause;
+    p->nRoots = 0;
+    Sto_ManForEachClause( p, pClause )
+    {
+        pClause->fRoot = 1;
+        p->nRoots++;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Mark all clauses added so far as clause of A.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Sto_ManMarkClausesA( Sto_Man_t * p )
+{
+    Sto_Cls_t * pClause;
+    p->nClausesA = 0;
+    Sto_ManForEachClause( p, pClause )
+    {
+        pClause->fA = 1;
+        p->nClausesA++;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the literal of the last clause.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Sto_ManChangeLastClause( Sto_Man_t * p )
+{
+    Sto_Cls_t * pClause, * pPrev;
+    pPrev = NULL;
+    Sto_ManForEachClause( p, pClause )
+        pPrev = pClause;
+    assert( pPrev != NULL );
+    assert( pPrev->fA == 1 );
+    assert( pPrev->nLits == 1 );
+    p->nClausesA--;
+    pPrev->fA = 0;
+    return pPrev->pLits[0] >> 1;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Writes the stored clauses into a file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Sto_ManDumpClauses( Sto_Man_t * p, char * pFileName )
+{
+    FILE * pFile;
+    Sto_Cls_t * pClause;
+    int i;
+    // start the file
+    pFile = fopen( pFileName, "w" );
+    if ( pFile == NULL )
+    {
+        printf( "Error: Cannot open output file (%s).\n", pFileName );
+        return;
+    }
+    // write the data
+    fprintf( pFile, "p %d %d %d %d\n", p->nVars, p->nClauses, p->nRoots, p->nClausesA );
+    Sto_ManForEachClause( p, pClause )
+    {
+        for ( i = 0; i < (int)pClause->nLits; i++ )
+            fprintf( pFile, " %d", lit_print(pClause->pLits[i]) );
+        fprintf( pFile, " 0\n" );
+    }
+//    fprintf( pFile, " 0\n" );
+    fclose( pFile );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Reads one literal from file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Sto_ManLoadNumber( FILE * pFile, int * pNumber )
+{
+    int Char, Number = 0, Sign = 0;
+    // skip space-like chars
+    do {
+        Char = fgetc( pFile );
+        if ( Char == EOF )
+            return 0;
+    } while ( Char == ' ' || Char == '\t' || Char == '\r' || Char == '\n' );
+    // read the literal
+    while ( 1 )
+    {
+        // get the next character
+        Char = fgetc( pFile );
+        if ( Char == ' ' || Char == '\t' || Char == '\r' || Char == '\n' )
+            break;
+        // check that the char is a digit
+        if ( (Char < '0' || Char > '9') && Char != '-' )
+        {
+            printf( "Error: Wrong char (%c) in the input file.\n", Char );
+            return 0;
+        }
+        // check if this is a minus
+        if ( Char == '-' )
+            Sign = 1;
+        else
+            Number = 10 * Number + Char;
+    }
+    // return the number
+    *pNumber = Sign? -Number : Number;
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Reads CNF from file.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Sto_Man_t * Sto_ManLoadClauses( char * pFileName )
+{
+    FILE * pFile;
+    Sto_Man_t * p;
+    Sto_Cls_t * pClause;
+    char pBuffer[1024];
+    int nLits, nLitsAlloc, Counter, Number;
+    lit * pLits;
+
+    // start the file
+    pFile = fopen( pFileName, "r" );
+    if ( pFile == NULL )
+    {
+        printf( "Error: Cannot open input file (%s).\n", pFileName );
+        return NULL;
+    }
+
+    // create the manager
+    p = Sto_ManAlloc();
+
+    // alloc the array of literals
+    nLitsAlloc = 1024;
+    pLits = (lit *)ABC_ALLOC( char, sizeof(lit) * nLitsAlloc );
+
+    // read file header
+    p->nVars = p->nClauses = p->nRoots = p->nClausesA = 0;
+    while ( fgets( pBuffer, 1024, pFile ) )
+    {
+        if ( pBuffer[0] == 'c' )
+            continue;
+        if ( pBuffer[0] == 'p' )
+        {
+            sscanf( pBuffer + 1, "%d %d %d %d", &p->nVars, &p->nClauses, &p->nRoots, &p->nClausesA );
+            break;
+        }
+        printf( "Warning: Skipping line: \"%s\"\n", pBuffer );
+    }
+
+    // read the clauses
+    nLits = 0;
+    while ( Sto_ManLoadNumber(pFile, &Number) )
+    {
+        if ( Number == 0 )
+        {
+            int RetValue;
+            RetValue = Sto_ManAddClause( p, pLits, pLits + nLits );
+            assert( RetValue );
+            nLits = 0;
+            continue;
+        }
+        if ( nLits == nLitsAlloc )
+        {
+            nLitsAlloc *= 2;
+            pLits = ABC_REALLOC( lit, pLits, nLitsAlloc );
+        }
+        pLits[ nLits++ ] = lit_read(Number);
+    }
+    if ( nLits > 0 )
+        printf( "Error: The last clause was not saved.\n" );
+
+    // count clauses
+    Counter = 0;
+    Sto_ManForEachClause( p, pClause )
+        Counter++;
+
+    // check the number of clauses
+    if ( p->nClauses != Counter )
+    {
+        printf( "Error: The actual number of clauses (%d) is different than declared (%d).\n", Counter, p->nClauses );
+        Sto_ManFree( p );
+        return NULL;
+    }
+
+    ABC_FREE( pLits );
+    fclose( pFile );
+    return p;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+
diff --git a/lib/bill/bill/bill.hpp b/lib/bill/bill/bill.hpp
new file mode 100644
index 0000000..9d0012b
--- /dev/null
+++ b/lib/bill/bill/bill.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <bill/utils/platforms.hpp>
+#include <bill/utils/hash.hpp>
+#include <bill/sat/interface/common.hpp>
+#include <bill/sat/interface/glucose.hpp>
+#include <bill/sat/interface/maple.hpp>
+#include <bill/sat/interface/abc_bsat2.hpp>
+#include <bill/sat/interface/types.hpp>
+#include <bill/sat/interface/z3.hpp>
+#include <bill/sat/interface/ghack.hpp>
+#include <bill/sat/interface/abc_bmcg.hpp>
+#include <bill/sat/cardinality.hpp>
+#include <bill/sat/solver.hpp>
+#include <bill/sat/solver/glucose.hpp>
+#include <bill/sat/solver/abc.hpp>
+#if !defined(BILL_WINDOWS_PLATFORM)
+#include <bill/sat/solver/maple.hpp>
+#endif
+#include <bill/sat/solver/ghack.hpp>
+#include <bill/sat/incremental_totalizer_cardinality.hpp>
+#include <bill/sat/xor_clauses.hpp>
+#include <bill/sat/tseytin.hpp>
+#include <bill/dd/zdd.hpp>
diff --git a/lib/bill/bill/dd/cudd_zdd.hpp b/lib/bill/bill/dd/cudd_zdd.hpp
new file mode 100644
index 0000000..e30ce9a
--- /dev/null
+++ b/lib/bill/bill/dd/cudd_zdd.hpp
@@ -0,0 +1,493 @@
+#include "cplusplus/cuddObj.hh"
+#include "cudd/cuddInt.h"
+#include <vector>
+#include <string>
+#include <iostream>
+#include <sstream>
+#include <unordered_map>
+#include <fmt/format.h>
+
+namespace cudd {
+
+class cudd_zdd 
+{
+public:
+  cudd_zdd( uint32_t num_variables ) 
+    : num_variables( num_variables ), empty( cudd.zddZero() ), base( cudd.zddOne( INT_MAX ) )
+  {
+    elementaries.reserve( num_variables );
+    for ( auto i = 0u; i < num_variables; ++i )
+    {
+      elementaries.emplace_back( base.Change( i ) );
+    }
+    tautologies.reserve( num_variables );
+    for ( auto i = 0u; i < num_variables; ++i )
+    {
+      tautologies.emplace_back( cudd.zddOne( i ) );
+    }
+    assert( cudd.ReadZddSize() == int( num_variables ) );
+    assert( Cudd_DebugCheck( cudd.getManager() ) == 0 );
+  }
+
+  ~cudd_zdd()
+  {
+  }
+
+  void print( ZDD const& node, std::string const& name = "", int verbosity = 4 )
+  {
+    std::cout << name << " (" << node.getNode() << ", level = " << Cudd_NodeReadIndex( node.getNode() ) << ")";
+    node.print( num_variables, verbosity );
+  }
+
+  ZDD ref( ZDD const& node )
+  {
+    Cudd_Ref( node.getNode() );
+    return node;
+  }
+
+  void deref_rec( ZDD const& node )
+  {
+    Cudd_RecursiveDerefZdd( cudd.getManager(), node.getNode() );
+    assert( Cudd_DebugCheck( cudd.getManager() ) == 0 );
+  }
+
+  /* only decrease ref count of `node` but not recursively on its children */
+  void deref( ZDD const& node )
+  {
+    Cudd_Deref( node.getNode() );
+  }
+
+  /* Create a node at level `var`, whose "then" child points to `T` and "else" child points to `E`,
+   * or return the node if it already exists.
+   * The result ZDD object is pass by copy, hence ref count is incresed by the copy constructor.
+   * 
+   * `T` and `E` should be lower than `var` (larger indices are lower)
+   * Note the order of `T` and `E` is the same as in `bill`, but different from CUDD.
+   */
+  ZDD unique( uint32_t var, ZDD const& E, ZDD const& T )
+  {
+    assert( T.NodeReadIndex() > var && E.NodeReadIndex() > var );
+    return ZDD( cudd, cuddZddGetNode( cudd.getManager(), var, T.getNode(), E.getNode() ) );
+  }
+
+public: /* basic getters; does NOT increase ref count */
+  ZDD& bottom() { return empty; }
+  ZDD& top() { return base; }
+
+  ZDD& elementary( uint32_t var )
+  {
+    assert( var < num_variables );
+    return elementaries[var];
+  }
+
+  ZDD& tautology( uint32_t var = 0 )
+  {
+    assert( var < num_variables );
+    return tautologies[var];
+  }
+
+public: /* operations provided by CUDD, wrapped with `bill` function names */
+  ZDD union_( ZDD const& f, ZDD const& g )
+  {
+    return f.Union( g );
+  }
+
+  ZDD intersection( ZDD const& f, ZDD const& g )
+  {
+    return f.Intersect( g );
+  }
+
+  ZDD difference( ZDD const& f, ZDD const& g )
+  {
+    return f.Diff( g );
+  }
+
+public: /* operations not provided by CUDD */
+  /* union every pair of subsets in f and g */
+  ZDD join( ZDD const& f, ZDD const& g )
+  {
+    assert( ( f == empty || f == base || f.NodeReadIndex() < num_variables) && ( g == empty || g == base || g.NodeReadIndex() < num_variables ) );
+    auto r = ZDD( cudd, join( f.getNode(), g.getNode() ) );
+    assert( Cudd_DebugCheck( cudd.getManager() ) == 0 );
+    return r;
+  }
+
+  /* resulting sets are elements in f, but not superset of any element in g */
+  /* \forall A \in result, A \in f and \forall B \in g, A \notsuperset B */
+  ZDD nonsupersets( ZDD const& f, ZDD const& g )
+  {
+    assert( ( f == empty || f == base || f.NodeReadIndex() < num_variables) && ( g == empty || g == base || g.NodeReadIndex() < num_variables ) );
+    auto r = ZDD( cudd, nonsupersets( f.getNode(), g.getNode() ) );
+    assert( Cudd_DebugCheck( cudd.getManager() ) == 0 );
+    return r;
+  }
+
+  ZDD choose( ZDD const& f, uint32_t k )
+  {
+    assert( f == empty || f == base || f.NodeReadIndex() < num_variables );
+    auto r = ZDD( cudd, choose( f.getNode(), k ) );
+    assert( Cudd_DebugCheck( cudd.getManager() ) == 0 );
+    return r;
+  }
+
+  /* builds an ZDD with one minterm, having '-' at variables in `vec`, and '0' at other variables
+   * `vec` is assumed to be sorted decreasingly
+   */
+  ZDD care( std::vector<uint32_t> const& vec )
+  {
+    DdNode* n1 = base.getNode();
+    DdNode* n2 = 0;
+
+    for ( auto i : vec )
+    {
+      assert( i < num_variables );
+      n2 = unique( i, n1, n1 ); ref( n2 );
+      if ( n1 != base.getNode() ) { Cudd_Deref( n1 ); }
+      n1 = n2;
+    }
+
+    Cudd_Deref( n2 );
+    auto r = ZDD( cudd, n2 );
+    assert( Cudd_DebugCheck( cudd.getManager() ) == 0 );
+    return r;
+  }
+
+  /* inverse of care */
+  ZDD dont_care( std::vector<uint32_t> const& vec )
+  {
+    std::vector<uint32_t> vec2;
+    for ( int i = num_variables - 1; i >= 0; --i )
+    {
+      bool found = false;
+      for ( auto j : vec )
+      {
+        if ( j == (unsigned)i )
+        {
+          found = true;
+          break;
+        }
+      }
+      if ( !found )
+      {
+        vec2.emplace_back( i );
+      } 
+    }
+
+    return care( vec2 );
+  }
+
+  //edivide
+  //maximal
+  //meet
+  //nonsubsets
+
+private: /* implementation details */
+  DdNode* lo( DdNode* f ) { return cuddE( f ); }
+  DdNode* hi( DdNode* f ) { return cuddT( f ); }
+  DdNode* ref( DdNode* node ) { Cudd_Ref( node ); return node; }
+  DdNode* deref( DdNode* node )
+  {
+    cuddSatDec( node->ref );
+    if ( node->ref == 0 )
+    {
+      DdManager * table = cudd.getManager();
+      table->deadZ++;
+      #ifdef DD_STATS
+        table->nodesDropped++;
+      #endif
+      assert( !cuddIsConstant( node ) );
+      int ord = table->permZ[node->index];
+      table->subtableZ[ord].dead++;
+      if ( !cuddIsConstant( cuddT( node ) ) ) { assert( cuddT( node )->ref != 0 ); Cudd_RecursiveDerefZdd( table, cuddT( node ) ); }
+      if ( !cuddIsConstant( cuddE( node ) ) ) { assert( cuddE( node )->ref != 0 ); Cudd_RecursiveDerefZdd( table, cuddE( node ) ); }
+    }
+    return node; 
+  }
+
+  DdNode* unique( uint32_t var, DdNode* lo, DdNode* hi )
+  { return cuddZddGetNode( cudd.getManager(), var, hi, lo ); }
+
+  DdNode* union_( DdNode* f, DdNode* g )
+  { return Cudd_zddUnion( cudd.getManager(), f, g ); }
+
+  DdNode* intersection( DdNode* f, DdNode* g )
+  { return Cudd_zddIntersect( cudd.getManager(), f, g ); }
+
+  DdNode* difference( DdNode* f, DdNode* g )
+  { return Cudd_zddDiff( cudd.getManager(), f, g ); }
+
+  /* replacement of function pointers to be used in the operation cache */
+  uint64_t join_ = 2;
+  uint64_t nonsupersets_ = 4;
+  uint64_t choose_ = 6;
+
+  DdNode* join( DdNode* f, DdNode* g )
+  {
+    /* terminal cases */
+    DdNode* e = empty.getNode();
+    DdNode* b = base.getNode();
+    if ( f == e || g == e ) { return e; }
+    if ( f == b ) { return g; }
+    if ( g == b ) { return f; }
+
+    if ( Cudd_NodeReadIndex( f ) < Cudd_NodeReadIndex( g ) ) { return join( g, f ); }
+
+    /* cache lookup */
+    auto res = cache_lookup( cudd.getManager(), join_, f, g );
+    if ( res != NULL ) { return res; }
+
+    uint32_t var = Cudd_NodeReadIndex( g );
+    DdNode* lo = 0;
+    DdNode* hi = 0;
+    
+    if ( Cudd_NodeReadIndex( f ) > Cudd_NodeReadIndex( g ) )
+    {
+      lo = join( f, cuddE( g ) ); ref( lo );
+      hi = join( f, cuddT( g ) ); ref( hi );
+    }
+    else /* f_var == g_var */
+    {
+      #if 1 /* Knuth's book */
+      DdNode* tmp0 = join( cuddE( f ), cuddT( g ) ); ref( tmp0 );
+      DdNode* tmp1 = join( cuddT( f ), cuddE( g ) ); ref( tmp1 );
+      DdNode* tmp2 = join( cuddT( f ), cuddT( g ) ); ref( tmp2 );
+      DdNode* tmp3 = union_( tmp0, tmp1 ); ref( tmp3 );
+      deref( tmp0 ); deref( tmp1 );
+      hi = union_( tmp2, tmp3 ); ref( hi );
+      deref( tmp2 ); deref( tmp3 );
+      #else /* Bruno's implementation */
+      DdNode* tmp0 = union_( cuddE( g ), cuddT( g ) ); ref( tmp0 );
+      DdNode* tmp1 = join( cuddT( f ), tmp0 ); ref( tmp1 );
+      deref( tmp0 );
+      DdNode* tmp2 = join( cuddE( f ), cuddT( g ) ); ref( tmp2 );
+      hi = union_( tmp1, tmp2 ); ref( hi );
+      deref( tmp1 ); deref( tmp2 );
+      #endif
+      lo = join( cuddE( f ), cuddE( g ) ); ref( lo );
+    }
+    auto r = unique( var, lo, hi );
+    deref( lo ); deref( hi );
+    
+    cache_insert( cudd.getManager(), join_, f, g, r );
+    return r;
+  }
+
+  DdNode* nonsupersets( DdNode* f, DdNode* g )
+  {
+    /* terminal cases */
+    DdNode* e = empty.getNode();
+    DdNode* b = base.getNode();
+    if ( g == e ) { return f; }
+    if ( f == e || g == b || f == g ) { return e; }
+
+    if ( Cudd_NodeReadIndex( f ) > Cudd_NodeReadIndex( g ) )
+      { return nonsupersets( f, cuddE( g ) ); }
+
+    /* cache lookup */
+    auto res = cache_lookup( cudd.getManager(), nonsupersets_, f, g );
+    if ( res != NULL ) { return res; }
+
+    /* recursive computation */
+    DdNode* lo = 0;
+    DdNode* hi = 0;
+    if ( Cudd_NodeReadIndex( f ) < Cudd_NodeReadIndex( g ) )
+    {
+      lo = nonsupersets( cuddE( f ), g ); ref( lo );
+      hi = nonsupersets( cuddT( f ), g ); ref( hi );
+    }
+    else /* f_var == g_var */
+    {
+      DdNode* tmp0 = nonsupersets( cuddT( f ), cuddT( g ) ); ref( tmp0 );
+      DdNode* tmp1 = nonsupersets( cuddT( f ), cuddE( g ) ); ref( tmp1 );
+      hi = intersection( tmp0, tmp1 ); ref( hi );
+      deref( tmp0 ); deref( tmp1 );
+      lo = nonsupersets( cuddE( f ), cuddE( g ) ); ref( lo );
+    }
+    auto r = unique( Cudd_NodeReadIndex( f ), lo, hi );
+    //deref( lo ); deref( hi );
+    
+    cache_insert( cudd.getManager(), nonsupersets_, f, g, r );
+    return r;
+  }
+
+  DdNode* choose( DdNode* f, uint64_t k )
+  {
+    if ( Cudd_NodeReadIndex( f ) >= num_variables )
+    {
+      return k > 0 ? empty.getNode() : base.getNode();
+    }
+    if ( k == 1 ) { return f; }
+    if ( k == 0 ) { return choose( cuddE( f ), k ); }
+
+    /* cache lookup */
+    auto res = cache_lookup( cudd.getManager(), choose_ + k * 2, f, f );
+    if ( res != NULL ) { return res; }
+
+    /* k > 0 */
+    DdNode* n = choose( cuddE( f ), k ); ref( n ); /* don't take this var */
+    DdNode* tmp = choose( cuddE( f ), k - 1 ); ref( tmp ); /* take this var */
+    auto r = unique( Cudd_NodeReadIndex( f ), n, tmp );
+    deref( n ); deref( tmp );
+
+    cache_insert( cudd.getManager(), choose_ + k * 2, f, f, r );
+    return r;
+  }
+
+private: /* iterator, counting, etc */
+  template<class Fn>
+  bool foreach_set_rec( DdNode* f, std::vector<uint32_t>& set, Fn&& fn ) const
+  {
+    if ( f == base.getNode() )
+    {
+      return fn(set);
+    }
+    if ( f != empty.getNode() )
+    {
+      if ( !foreach_set_rec( cuddE( f ), set, fn ) )
+      {
+        return false;
+      }
+      auto new_set = set;
+      new_set.push_back( Cudd_NodeReadIndex( f ) );
+      if ( !foreach_set_rec( cuddT( f ), new_set, fn ) )
+      {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  uint64_t count_sets_rec( DdNode* f, std::unordered_map<DdNode*, uint64_t>& visited ) const
+  {
+    if ( f == base.getNode() )
+    {
+      return 1;
+    }
+    if ( f == empty.getNode() )
+    {
+      return 0;
+    }
+
+    const auto it = visited.find( f );
+    if ( it != visited.end() )
+    {
+      return it->second;
+    }
+    return visited[f] = count_sets_rec( cuddE( f ), visited ) + count_sets_rec( cuddT( f ), visited );
+  }
+
+public:
+  /* a set is represented with a `std::vector<uint32_t>` of variable indices */
+  template<class Fn>
+  void foreach_set( ZDD const& f, Fn&& fn ) const
+  {
+    std::vector<uint32_t> set;
+    foreach_set_rec( f.getNode(), set, fn );
+  }
+
+  void print_sets( ZDD const& f, std::ostream& os = std::cout ) const
+  {
+    foreach_set( f, [&]( auto const& set ){
+      os << fmt::format("{{ {} }}\n", fmt::join( set, ", " ) );
+      return true;
+    });
+  }
+
+  /* \!brief Return the number of nodes in a ZDD. */
+  uint64_t count_nodes( DdNode* f ) const
+  {
+    return Cudd_zddDagSize(f);
+  }
+
+  /* \!brief Return the number of sets in a ZDD. */
+  uint64_t count_sets( ZDD const& f ) const
+  {
+    if ( f.getNode() == base.getNode() )
+    {
+      return 1;
+    }
+    if ( f.getNode() == empty.getNode() )
+    {
+      return 0;
+    }
+    std::unordered_map<DdNode*, uint64_t> visited;
+    return count_sets_rec( f.getNode(), visited );
+  }
+
+  std::vector<std::vector<uint32_t>> sets_as_vectors( ZDD const& f ) const
+  {
+    std::vector<std::vector<uint32_t>> sets_vectors;
+    foreach_set( f, [&]( auto const& set ){
+      sets_vectors.emplace_back( set );
+      return true;
+    });
+    return sets_vectors;
+  }
+
+private: /* operation cache */
+  DdNode * cache_lookup( DdManager * table, uint64_t op, DdNode * f, DdNode * g )
+  {
+    int posn;
+    DdCache *en,*cache;
+    DdNode *data;
+
+    cache = table->cache;
+    #ifdef DD_DEBUG
+      if (cache == NULL) {
+        return(NULL);
+      }
+    #endif
+
+    posn = ddCHash2(op,f,g,table->cacheShift);
+    en = &cache[posn];
+    if (en->data != NULL && en->f==f && en->g==g && en->h==(ptruint)op) {
+      data = Cudd_Regular(en->data);
+      table->cacheHits++;
+      if (data->ref == 0) {
+        cuddReclaimZdd(table,data);
+      }
+      return(en->data);
+    }
+
+    /* Cache miss: decide whether to resize. */
+    table->cacheMisses++;
+
+    if (table->cacheSlack >= 0 && table->cacheHits > table->cacheMisses * table->minHit) {
+      cuddCacheResize(table);
+    }
+
+    return(NULL);
+  }
+
+  void cache_insert( DdManager * table, uint64_t op, DdNode * f, DdNode * g, DdNode * data )
+  {
+    int posn;
+    DdCache *entry;
+
+    posn = ddCHash2(op,f,g,table->cacheShift);
+    entry = &table->cache[posn];
+
+    if (entry->data != NULL) {
+      table->cachecollisions++;
+    }
+    table->cacheinserts++;
+
+    entry->f = f;
+    entry->g = g;
+    entry->h = (ptruint) op;
+    entry->data = data;
+    #ifdef DD_CACHE_PROFILE
+      entry->count++;
+    #endif
+  } 
+
+private:
+  Cudd cudd; /* the CUDD manager */
+  uint32_t num_variables;
+  ZDD empty; /* the empty family {} (minterms: none; constant 0) */
+  ZDD base; /* the unit family {{}} (minterms: the all-zero cube) */
+  std::vector<ZDD> elementaries; /* the single-set family of the single-element set {{i}} (minterms: 0...010...0) */
+  std::vector<ZDD> tautologies; /* every combinations of variables >= var (minterms: 0...0-...-) */
+};
+
+} // namespace cudd
\ No newline at end of file
diff --git a/lib/bill/bill/dd/zdd.hpp b/lib/bill/bill/dd/zdd.hpp
new file mode 100644
index 0000000..763f73f
--- /dev/null
+++ b/lib/bill/bill/dd/zdd.hpp
@@ -0,0 +1,928 @@
+/*-------------------------------------------------------------------------------------------------
+| This file is distributed under the MIT License.
+| See accompanying file /LICENSE for details.
+*------------------------------------------------------------------------------------------------*/
+#pragma once
+
+#include "../utils/hash.hpp"
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstdint>
+#include <fmt/format.h>
+#include <iostream>
+#include <sstream>
+#include <stack>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace bill {
+
+/*! \brief A zero-suppressed decision diagram (ZDD).
+ *
+ *  NOTE: This is a simple implementation. I would advise against its use when high-performance
+ *        is a requirement.
+ * 
+ *  Limitations:
+ *  	- The number of variables `N` must be known at instantiation time. 
+ * 
+ * Variables are numbered from `0` to `N - 1`.
+ */
+
+// TODO: Implement complemented edges
+// TODO: Implement variable reordering
+// TODO: Implement Variable order heuristics
+// TODO: Implement Chain reduction
+// TODO: Implement subsets operator
+// TODO: Implement supersets operator
+class zdd_base {
+#pragma region Types and constructors
+private:
+	struct node_type {
+		node_type(uint32_t var, uint32_t lo, uint32_t hi)
+		    : marked(0)
+		    , var(var)
+		    , refs(0)
+		    , lo(lo)
+		    , hi(hi)
+		{}
+
+		uint32_t marked : 1;
+		uint32_t var : 31;
+		int32_t  refs; // Number of references - 1
+		uint32_t lo;
+		uint32_t hi;
+	};
+
+	enum operations : uint32_t {
+		zdd_choose,
+		zdd_difference,
+		zdd_edivide,
+		zdd_intersection,
+		zdd_join,
+		zdd_maximal,
+		zdd_meet,
+		zdd_nonsubsets,
+		zdd_nonsupersets,
+		zdd_union,
+		num_operations
+	};
+
+public:
+	using node_index = uint32_t;
+
+	/* \!brief Creates a new ZDD base.
+	 * 
+	 * \param num_vars Number of variables
+	 * \param log_num_objs Log number of nodes to pre-allocate (default: 16)
+	 */
+	explicit zdd_base(uint32_t num_vars, uint32_t log_num_objs = 16)
+	    : unique_tables_(num_vars)
+	    , num_dead_nodes_(0u)
+	    , num_cache_lookups_(0u)
+	    , num_cache_misses_(0u)
+	{
+		assert(num_variables() <= 4095);
+		nodes_.reserve(1u << log_num_objs);
+		nodes_.emplace_back(num_vars, 0, 0);
+		nodes_.emplace_back(num_vars, 1, 1);
+		build_elementary();
+		build_tautologies();
+	}
+#pragma endregion
+
+#pragma region ZDD base properties
+public:
+	/*! \brief Return the number of active nodes. */
+	uint32_t num_nodes() const
+	{
+		return nodes_.size() - 2 - num_dead_nodes_ - free_nodes_.size();
+	}
+
+	/*! \brief Return the number of active nodes. */
+	uint32_t num_variables() const
+	{
+		return unique_tables_.size();
+	}
+#pragma endregion
+
+#pragma region ZDD base operations
+private:
+
+	/* \!brief Returns an unique node for the tuple (var, lo, hi)
+	 *
+	 * Given a variable `var` and node indexes lo and hi, we want to see if the ZDD base
+	 * contains a node (var, lo, hi). If no such node exists, we create it. This function 
+	 * returns a index to this _unique_ node. One crucial technicality should be noted:
+	 * 
+	 * /!\ This operation can potentially invalidate pointers, iterators and references /!\
+	 * 
+	 * Indexes are not invalidated.
+	 */ 
+	node_index unique(uint32_t var, node_index lo, node_index hi)
+	{
+		assert(var < num_variables());
+		/* ZDD reduction rule */
+		if (hi == bottom()) {
+			--nodes_.at(hi).refs;
+			return lo;
+		}
+		assert(nodes_.at(lo).var > var);
+		assert(nodes_.at(hi).var > var);
+
+		/* Unique table lookup */
+		const auto it = unique_tables_.at(var).find({lo, hi});
+		if (it != unique_tables_.at(var).end()) {
+			if (nodes_.at(it->second).refs < 0) {
+				--num_dead_nodes_;
+				nodes_.at(it->second).refs = 0;
+				return it->second;
+			} else {
+				--nodes_.at(lo).refs;
+				--nodes_.at(hi).refs;
+			}
+			return ref(it->second);
+		}
+
+		/* Create new node */
+		node_index new_node_index;
+	restart:
+		if (!free_nodes_.empty()) {
+			new_node_index = free_nodes_.top();
+			free_nodes_.pop();
+			nodes_.at(new_node_index).marked = 0;
+			nodes_.at(new_node_index).var = var;
+			nodes_.at(new_node_index).refs = 0;
+			nodes_.at(new_node_index).lo = lo;
+			nodes_.at(new_node_index).hi = hi;
+		} else {
+			if (num_dead_nodes_ > num_nodes() / 8) {
+				collect_garbage();
+				goto restart;
+			}
+			new_node_index = nodes_.size();
+			nodes_.emplace_back(var, lo, hi);
+		} 
+		unique_tables_.at(var)[{lo, hi}] = new_node_index;
+		return new_node_index;
+	}
+
+	/* \! brief Recursively revives a dead, but unrecycled node
+	 *
+	 * When we discover that a node exists, but it is dead, i.e. all links to it have gone
+	 * away, but we haven’t recycled it yet. We bring it back to life!
+	 * 
+	 * It increases the reference counts of the node's children, and resuscitates them if they
+	 * were dead.
+	 */
+	void revive_node(node_index index)
+	{
+		assert(nodes_.at(index).refs < 0);
+	restart:
+		node_type& node = nodes_.at(index);
+		node.refs = 0;
+		--num_dead_nodes_;
+		if (nodes_.at(node.lo).refs < 0) {
+			revive_node(node.lo);
+		} else {
+			ref(node.lo);
+		}
+		if (nodes_.at(node.hi).refs < 0) {
+			index = node.hi;
+			goto restart;
+		}
+		ref(node.hi);
+	}
+
+	/* \!brief Recursively kills a node 
+	 *
+	 * When the reference count of a node reeaches -1, we kill it. It decreases the reference
+	 * counts of the node's children, and kill them too(!) if necessary, i.e. their reference
+	 * count reaches -1.
+	 */
+	void kill_node(node_index index)
+	{
+		assert(nodes_.at(index).refs == 0);
+	restart:
+		node_type& node = nodes_.at(index);
+		node.refs = -1;
+		++num_dead_nodes_;
+		if (nodes_.at(node.lo).refs == 0) {
+			kill_node(node.lo);
+		} else {
+			--nodes_.at(node.lo).refs;
+		}
+		if (nodes_.at(node.hi).refs == 0) {
+			index = node.hi;
+			goto restart;
+		}
+		--nodes_.at(node.hi).refs;
+	}
+
+	/* \!brief Return the tautology function */
+	node_index tautology(uint32_t var)
+	{
+		if (var == num_variables()) {
+			return top();
+		}
+		return (2 * num_variables()) + 1u - var;
+	}
+
+	void cache_cleanup()
+	{
+		auto check_nodes = [&](node_index a, node_index b, node_index c) -> bool {
+			if (nodes_.at(a).refs < 0) {
+				return true;
+			}
+			if (nodes_.at(b).refs < 0) {
+				return true;
+			}
+			return nodes_.at(c).refs < 0;
+		};
+		for (auto& table : computed_tables_) {
+			for (auto it = table.begin(); it != table.end();) {
+				auto [index_f, index_g] = it->first;
+				if (check_nodes(it->second, index_f, index_g)) {
+					it = table.erase(it);
+					continue;
+				} else {
+					++it;
+				}
+			}
+		}
+	}
+
+	void tables_cleanup()
+	{
+		/* Skip terminals and elementary nodes */
+		uint32_t const begin = (2 * num_variables()) + 2;
+		for (uint32_t index = begin; index < nodes_.size(); ++index) {
+			node_type& node = nodes_.at(index);
+			if (node.refs >= 0) {
+				continue;
+			}
+			auto const it = unique_tables_.at(node.var).find({node.lo, node.hi});
+			assert(it != unique_tables_.at(node.var).end());
+			unique_tables_.at(node.var).erase(it);
+			free_nodes_.push(index);
+			node.refs = 0;
+		}
+	}
+
+	/*! \brief Creates a node at each level that means "tautology from here on" */
+	void build_tautologies()
+	{
+		assert(nodes_.size() == num_variables() + 2u);
+		node_index last = top();
+		for (int var = num_variables() - 1; var >= 0; --var) {
+			ref(last, 2);
+			last = unique(var, last, last);
+			assert(last == (2 * num_variables()) + 1u - var);
+			if (var != 0) {
+				--nodes_.at(last).refs;
+			}
+		}
+	}
+
+	/*! \brief Create nodes corresponding to the elementary families */
+	void build_elementary()
+	{
+		for (auto var = 0u; var < num_variables(); ++var) {
+			unique(var, bottom(), top());
+			ref(bottom());
+			ref(top());
+		};
+		--nodes_.at(bottom()).refs;
+		--nodes_.at(top()).refs;
+	}
+
+public:
+	/*! \brief Returns the node index corresponding to the `empty family` */
+	node_index bottom() const
+	{
+		return 0u;
+	}
+
+	/*! \brief Returns the node index corresponding to the `unit family` */
+	node_index top() const
+	{
+		return 1u;
+	}
+
+	/*! \brief Returns the node-id corresponding to the elementary family `{{var}}` */
+	node_index elementary(uint32_t var)
+	{
+		assert(var < num_variables());
+		return var + 2u;
+	}
+
+	/*! \brief Increase the reference count of a node. */
+	node_index ref(node_index index, int32_t i = 1)
+	{
+		assert(index < nodes_.size());
+		nodes_.at(index).refs += i;
+		return index;
+	}
+
+	/*! \brief Decrease the reference count of a node. */
+	void deref(node_index index)
+	{
+		assert(index < nodes_.size());
+		assert(nodes_.at(index).refs >= 0);
+		if (nodes_.at(index).refs == 0) {
+			kill_node(index);
+			return;
+		}
+		--nodes_.at(index).refs;
+	}
+
+	/*! \brief Recycle all the dead nodes */
+	void collect_garbage()
+	{
+		cache_cleanup();
+		tables_cleanup();
+		num_dead_nodes_ = 0;
+	}
+#pragma endregion
+
+#pragma region ZDD Operations
+public:
+	/* \!brief Computes the family of all ``k``-combinations of a ZDD.  */
+	node_index choose(node_index index_f, uint32_t k)
+	{
+		constexpr operations op = operations::zdd_choose;
+		if (index_f <= top()) {
+			return k > 0 ? bottom() : top();
+		}
+		if (k == 1) {
+			return ref(index_f);
+		}
+
+		// Cache lookup
+		++num_cache_lookups_;
+		const auto it = computed_tables_.at(op).find({index_f, k});
+		if (it != computed_tables_.at(op).end()) {
+			if (nodes_.at(it->second).refs < 0) {
+				revive_node(it->second);
+				return it->second;
+			}
+			return ref(it->second);
+		}
+		++num_cache_misses_;
+
+		node_type node_f = nodes_.at(index_f);
+		node_index index_new = choose(node_f.lo, k);
+		if (k > 0) {
+			node_index temp = choose(node_f.lo, k - 1);
+			ref(index_new);
+			index_new = unique(node_f.var, index_new, temp);
+		} else {
+			deref(index_new);
+		}
+		computed_tables_.at(op)[{index_f, k}] = index_new;
+		return index_new;
+	}
+
+	/* \!brief Computes the difference of two ZDDs (`f - g`)
+	 *  Keep in mind that `f - g` is different from `g - f` !
+	 */
+	node_index difference(node_index index_f, node_index index_g)
+	{
+		constexpr operations op = operations::zdd_difference;
+		if (index_f == bottom()) {
+			return ref(bottom());
+		}
+		node_type& node_f = nodes_.at(index_f);
+	
+	restart:
+		if (index_f == index_g) {
+			return ref(bottom());
+		}
+		if (index_g == bottom()) {
+			return ref(index_f);
+		}
+		node_type& node_g = nodes_.at(index_g);
+		if (node_g.var < node_f.var) {
+			index_g = node_g.lo;
+			goto restart;
+		} 
+
+		// Cache lookup
+		++num_cache_lookups_;
+		const auto it = computed_tables_.at(op).find({index_f, index_g});
+		if (it != computed_tables_.at(op).end()) {
+			if (nodes_.at(it->second).refs < 0) {
+				revive_node(it->second);
+				return it->second;
+			}
+			return ref(it->second);
+		}
+		++num_cache_misses_;
+
+		node_index r_lo;
+		node_index r_hi;
+		if (node_f.var == node_g.var) {
+			r_lo = difference(node_f.lo, node_g.lo);
+			r_hi = difference(node_f.hi, node_g.hi);
+		} else {
+			r_lo = difference(node_f.lo, index_g);
+			r_hi = ref(node_f.hi);
+		}
+		node_index index_new = unique(node_f.var, r_lo, r_hi);
+		computed_tables_.at(op)[{index_f, index_g}] = index_new;
+		return index_new;
+	}
+
+	/* \!brief Computes the intersection of two ZDDs */
+	node_index intersection(node_index index_f, node_index index_g)
+	{
+		constexpr operations op = operations::zdd_intersection;
+		if (index_f == tautology()) {
+			return ref(index_g); 
+		}
+		if (index_g == tautology()) {
+			return ref(index_f); 
+		}
+	restart:
+		if (index_f > index_g) {
+			std::swap(index_f, index_g);
+		}
+		if (index_f == bottom()) {
+			return ref(bottom());
+		}
+		if (index_f == index_g) {
+			return ref(index_f);
+		}
+
+		node_type node_f = nodes_.at(index_f);
+		node_type node_g = nodes_.at(index_g);
+		if (node_f.var <node_g.var) {
+			index_f = node_f.lo;
+			goto restart;
+		} else if (node_f.var > node_g.var) {
+			index_g = node_g.lo;
+			goto restart;
+		}
+		if (index_f == tautology(node_f.var)) {
+			return ref(index_g); 
+		}
+		if (index_g == tautology(node_g.var)) {
+			return ref(index_f); 
+		}
+		assert(node_f.var == node_g.var);
+
+		// Cache lookup
+		++num_cache_lookups_;
+		const auto it = computed_tables_.at(op).find({index_f, index_g});
+		if (it != computed_tables_.at(op).end()) {
+			if (nodes_.at(it->second).refs < 0) {
+				revive_node(it->second);
+				return it->second;
+			}
+			return ref(it->second);
+		}
+		++num_cache_misses_;
+
+		node_index r_lo = intersection(node_f.lo, node_g.lo);
+		node_index r_hi = intersection(node_f.hi, node_g.hi);
+		node_index index_new = unique(node_f.var, r_lo, r_hi);
+		computed_tables_.at(op)[{index_f, index_g}] = index_new;
+		return index_new;
+	}
+
+	/* \!brief Computes the join of two ZDDs */
+	node_index join(node_index index_f, node_index index_g)
+	{
+		constexpr operations op = operations::zdd_join;
+		if (index_f > index_g) {
+			std::swap(index_f, index_g);
+		}
+		if (index_f == bottom()) {
+			return ref(bottom());
+		}
+		if (index_f == top()) {
+			return ref(index_g);
+		}
+
+		// Cache lookup
+		++num_cache_lookups_;
+		const auto it = computed_tables_.at(op).find({index_f, index_g});
+		if (it != computed_tables_.at(op).end()) {
+			if (nodes_.at(it->second).refs < 0) {
+				revive_node(it->second);
+				return it->second;
+			}
+			return ref(it->second);
+		}
+		++num_cache_misses_;
+
+		node_type node_f = nodes_.at(index_f);
+		node_type node_g = nodes_.at(index_g);
+		node_index r_lo;
+		node_index r_hi;
+		uint32_t var = node_f.var;
+		if (node_f.var < node_g.var) {
+			r_lo = join(node_f.lo, index_g);
+			r_hi = join(node_f.hi, index_g);
+		} else if (node_f.var > node_g.var) {
+			r_lo = join(node_g.lo, index_f);
+			r_hi = join(node_g.hi, index_f);
+			var = node_g.var;
+		} else {
+			// In this case node_f.var == node_g.var
+			r_lo = union_(node_g.lo, node_g.hi);
+			node_index const r_hl = join(node_f.hi, r_lo);
+			deref(r_lo);
+			node_index const r_lh = join(node_f.lo, node_g.hi);
+			r_hi = union_(r_hl, r_lh);
+			deref(r_hl);
+			deref(r_lh);
+			r_lo = join(node_f.lo, node_g.lo);
+		}
+		node_index index_new = unique(var, r_lo, r_hi);
+		computed_tables_.at(op)[{index_f, index_g}] = index_new;
+		return index_new;
+	}
+
+	/* \!brief Computes the maximal of a ZDD */
+	node_index maximal(node_index index_f)
+	{
+		constexpr operations op = operations::zdd_maximal;
+		if (index_f <= top()) {
+			return ref(index_f);
+		}
+		// Cache lookup
+		++num_cache_lookups_;
+		const auto it = computed_tables_.at(op).find({index_f, 0});
+		if (it != computed_tables_.at(op).end()) {
+			if (nodes_.at(it->second).refs < 0) {
+				revive_node(it->second);
+				return it->second;
+			}
+			return ref(it->second);
+		}
+		++num_cache_misses_;
+
+		node_type node_f = nodes_.at(index_f);
+		node_index r_hi = maximal(node_f.hi);
+		node_index temp = maximal(node_f.lo);
+		node_index r_lo = nonsubsets(temp, r_hi);
+		deref(temp);
+		node_index index_new = unique(node_f.var, r_lo, r_hi);
+		computed_tables_.at(op)[{index_f, 0}] = index_new;
+		return index_new;;
+	}
+
+	/* \!brief Computes the meet of two ZDDs */
+	node_index meet(node_index index_f, node_index index_g)
+	{
+		constexpr operations op = operations::zdd_meet;
+		if (index_f > index_g) {
+			std::swap(index_f, index_g);
+		}
+		if (index_f <= top()) {
+			return ref(index_f);
+		}
+
+		// Cache lookup
+		++num_cache_lookups_;
+		const auto it = computed_tables_.at(op).find({index_f, index_g});
+		if (it != computed_tables_.at(op).end()) {
+			if (nodes_.at(it->second).refs < 0) {
+				revive_node(it->second);
+				return it->second;
+			}
+			return ref(it->second);
+		}
+		++num_cache_misses_;
+
+		node_type node_f = nodes_.at(index_f);
+		node_type node_g = nodes_.at(index_g);
+		node_index r_lo;
+		node_index r_hi;
+		if (node_f.var < node_g.var) {
+			r_lo = union_(node_f.lo, node_f.hi);
+			r_hi = meet(r_lo, index_g);
+			deref(r_lo);
+			return r_hi;
+		} else if (node_f.var > node_g.var) {
+			r_lo = union_(node_g.lo, node_g.hi);
+			r_hi = meet(r_lo, index_f);
+			deref(r_lo);
+			return r_hi;
+		} else { 
+			// In this case node_f.var == node_g.var
+			r_hi = union_(node_f.lo, node_f.hi);
+			node_index r_hl = meet(r_hi, node_g.lo);
+			deref(r_hi);
+			node_index r_lh = meet(node_f.lo, node_g.hi);
+			r_lo = union_(r_hl, r_lh);
+			deref(r_hl);
+			deref(r_lh);
+			r_hi = meet(node_f.hi, node_g.hi);
+		}
+		node_index index_new = unique(node_f.var, r_lo, r_hi);
+		computed_tables_.at(op)[{index_f, index_g}] = index_new;
+		return index_new;
+	}
+
+	/* \!brief Computes the nonsubsets of two ZDDs */
+	node_index nonsubsets(node_index index_f, node_index index_g)
+	{
+		constexpr operations op = operations::zdd_nonsubsets;
+		if (index_g == bottom()) {
+			return ref(index_f);
+		}
+		if (index_f <= top()) {
+			return ref(bottom());
+		}
+		if (index_f == index_g) {
+			return ref(bottom());
+		}
+
+		if (nodes_.at(index_f).var > nodes_.at(index_g).var) {
+			return nonsubsets(index_f, nodes_.at(index_g).lo);
+		}
+
+		// Cache lookup
+		++num_cache_lookups_;
+		const auto it = computed_tables_.at(op).find({index_f, index_g});
+		if (it != computed_tables_.at(op).end()) {
+			if (nodes_.at(it->second).refs < 0) {
+				revive_node(it->second);
+				return it->second;
+			}
+			return ref(it->second);
+		}
+		++num_cache_misses_;
+
+		node_type node_f = nodes_.at(index_f);
+		node_type node_g = nodes_.at(index_g);
+		node_index r_lo;
+		node_index r_hi;
+		if (node_f.var < node_g.var) {
+			r_lo = nonsubsets(node_f.lo, index_g);
+			r_hi = ref(node_f.hi);
+		} else {
+			node_index const temp = nonsubsets(node_f.lo, node_g.hi);
+			r_hi = nonsubsets(node_f.lo, node_g.lo);
+			r_lo = intersection(temp, r_hi);
+			deref(temp);
+			deref(r_hi);
+			r_hi = nonsubsets(node_f.hi, node_g.hi);
+		}
+		node_index index_new = unique(node_f.var, r_lo, r_hi);
+		computed_tables_.at(op)[{index_f, index_g}] = index_new;
+		return index_new;
+	}
+
+	/* \!brief Computes the nonsupersets of two ZDDs */
+	node_index nonsupersets(node_index index_f, node_index index_g)
+	{
+		constexpr operations op = operations::zdd_nonsupersets;
+		if (index_g == bottom()) {
+			return ref(index_f);
+		}
+		if (index_f == bottom()) {
+			return ref(bottom());
+		}
+		// This operation can be potentially faster if instead I check for top \in g
+		// TODO: experiment!
+		if (index_g == top()) {
+			return ref(bottom());
+		}
+		if (index_f == index_g) {
+			return ref(bottom());
+		}
+
+		if (nodes_.at(index_f).var > nodes_.at(index_g).var) {
+			return nonsupersets(index_f, nodes_.at(index_g).lo);
+		}
+
+		// Cache lookup
+		++num_cache_lookups_;
+		const auto it = computed_tables_.at(op).find({index_f, index_g});
+		if (it != computed_tables_.at(op).end()) {
+			if (nodes_.at(it->second).refs < 0) {
+				revive_node(it->second);
+				return it->second;
+			}
+			return ref(it->second);
+		}
+		++num_cache_misses_;
+
+		node_type node_f = nodes_.at(index_f);
+		node_type node_g = nodes_.at(index_g);
+		node_index r_lo;
+		node_index r_hi;
+		uint32_t var = node_f.var;
+		if (node_f.var < node_g.var) {
+			r_lo = nonsupersets(node_f.lo, index_g);
+			r_hi = nonsupersets(node_f.hi, index_g);
+		} else {
+			r_lo = nonsupersets(node_f.hi, node_g.hi);
+			node_index temp = nonsupersets(node_f.hi, node_g.lo);
+			r_hi = intersection(temp, r_lo);
+			deref(temp);
+			deref(r_lo);
+			r_lo = nonsupersets(node_f.lo, node_g.lo);
+		}
+		node_index index_new = unique(var, r_lo, r_hi);
+		computed_tables_.at(op)[{index_f, index_g}] = index_new;
+		return index_new;
+	}
+
+	/* \!brief Return the tautology function */
+	node_index tautology()
+	{
+		return (2 * num_variables()) + 1u;
+	}
+
+	/* \!brief Computes the union of two ZDDs */
+	node_index union_(node_index index_f, node_index index_g)
+	{
+		constexpr operations op = operations::zdd_union;
+		if (index_f == index_g) {
+			return ref(index_f);
+		}
+		if (index_f > index_g) {
+			std::swap(index_f, index_g);
+		}
+		if (index_f == bottom()) {
+			return ref(index_g);
+		}
+
+		// Cache lookup
+		++num_cache_lookups_;
+		const auto it = computed_tables_.at(op).find({index_f, index_g});
+		if (it != computed_tables_.at(op).end()) {
+			if (nodes_.at(it->second).refs < 0) {
+				revive_node(it->second);
+				return it->second;
+			}
+			return ref(it->second);
+		}
+		++num_cache_misses_;;
+
+		node_type node_f = nodes_.at(index_f);
+		node_type node_g = nodes_.at(index_g);
+		node_index r_lo;
+		node_index r_hi;
+		uint32_t var = node_f.var;
+		if (node_f.var < node_g.var) {
+			if (index_f == tautology(node_f.var)) {
+				return ref(index_f); 
+			}
+			r_lo = union_(node_f.lo, index_g);
+			r_hi = ref(node_f.hi);
+		} else if (node_f.var > node_g.var) {
+			if (index_g == tautology(node_g.var)) {
+				return ref(index_g); 
+			}
+			r_lo = union_(index_f, node_g.lo);
+			r_hi = ref(node_g.hi);
+			var = node_g.var;
+		} else {
+			// In this case node_f.var == node_g.var
+			if (index_g == tautology(node_g.var)) {
+				return ref(index_g); 
+			}
+			r_lo = union_(node_f.lo, node_g.lo);
+			r_hi = union_(node_f.hi, node_g.hi);
+		}
+		node_index index_new = unique(var, r_lo, r_hi);
+		computed_tables_.at(op)[{index_f, index_g}] = index_new;
+		return index_new;
+	}
+#pragma endregion
+
+#pragma region ZDD iterators
+private:
+	template<class Fn>
+	bool foreach_set_rec(node_index index, std::vector<uint32_t>& set, Fn&& fn) const
+	{
+		if (index == 1u) {
+			return fn(set);
+		}
+		if (index != 0u) {
+			if (!foreach_set_rec(nodes_.at(index).lo, set, fn)) {
+				return false;
+			}
+			auto new_set = set;
+			new_set.push_back(nodes_.at(index).var);
+			if (!foreach_set_rec(nodes_.at(index).hi, new_set, fn)) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+public:
+	template<class Fn>
+	void foreach_set(node_index index, Fn&& fn) const
+	{
+		std::vector<uint32_t> set;
+		foreach_set_rec(index, set, fn);
+	}
+#pragma endregion
+
+#pragma region ZDD properties
+private:
+	void count_nodes_rec(node_index index, std::unordered_set<node_index>& visited) const
+	{
+		if (index <= 1 || visited.count(index)) {
+			return;
+		}
+		visited.insert(index);
+		node_type const& node = nodes_.at(index);
+		count_nodes_rec(node.lo, visited);
+		count_nodes_rec(node.hi, visited);
+	}
+
+	uint64_t count_sets_rec(node_index index, std::unordered_map<node_index, uint64_t>& visited) const
+	{
+		if (index <= 1) {
+			return index;
+		}
+		const auto it = visited.find(index);
+		if (it != visited.end()) {
+			return it->second;
+		}
+		node_type const& node = nodes_.at(index);
+		return visited[index] = count_sets_rec(node.lo, visited)
+		                      + count_sets_rec(node.hi, visited);
+	}
+
+public:
+	/* \!brief Return the number of nodes in a ZDD. */
+	uint64_t count_nodes(node_index index_root) const
+	{
+		if (index_root <= 1) {
+			return 0;
+		}
+		std::unordered_set<node_index> visited;
+		count_nodes_rec(index_root, visited);
+		return visited.size();
+	}
+
+	/* \!brief Return the number of sets in a ZDD. */
+	uint64_t count_sets(node_index index_root) const
+	{
+		if (index_root <= 1) {
+			return index_root;
+		}
+		std::unordered_map<node_index, uint64_t> visited;
+		return count_sets_rec(index_root, visited);
+	}
+
+	std::vector<std::vector<uint32_t>> sets_as_vectors(node_index index) const
+	{
+		std::vector<std::vector<uint32_t>> sets_vectors;
+		foreach_set(index, [&](auto const& set){
+			sets_vectors.emplace_back(set);
+			return true;
+		});
+		return sets_vectors;
+	}
+#pragma endregion
+
+#pragma region Debug
+public:
+	void print_debug(std::ostream& os = std::cout) const
+	{
+		os << "ZDD nodes:\n";
+		os << "    i     VAR    LO    HI   REF\n";
+		uint32_t i = 0u;
+		for (node_type const& node : nodes_) {
+			os << fmt::format("{:5} : {:5} {:5} {:5} {:5}\n", i++, node.var, node.lo,
+			                  node.hi, node.refs);
+		}
+	}
+
+	void print_sets(node_index index, std::ostream& os = std::cout) const
+	{
+		foreach_set(index, [&](auto const& set){
+			os << fmt::format("{{ {} }}\n", fmt::join(set, ", "));
+			return true;
+		});
+	}
+#pragma endregion
+
+private:
+	using children_type = std::pair<node_index, node_index>;
+	using unique_table_type = std::unordered_map<children_type, node_index>;
+
+	std::vector<node_type> nodes_;
+	std::stack<node_index> free_nodes_;
+	std::vector<unique_table_type> unique_tables_;
+	std::array<unique_table_type, operations::num_operations> computed_tables_;
+
+	// Stats
+	uint32_t num_dead_nodes_;
+	uint32_t num_cache_lookups_;
+	uint32_t num_cache_misses_;
+};
+
+} // namespace bill
diff --git a/lib/bill/bill/sat/cardinality.hpp b/lib/bill/bill/sat/cardinality.hpp
new file mode 100644
index 0000000..93eb294
--- /dev/null
+++ b/lib/bill/bill/sat/cardinality.hpp
@@ -0,0 +1,37 @@
+/*-------------------------------------------------------------------------------------------------
+| This file is distributed under the MIT License.
+| See accompanying file /LICENSE for details.
+*------------------------------------------------------------------------------------------------*/
+#pragma once
+
+#include "interface/types.hpp"
+
+#include <vector>
+
+namespace bill {
+
+template<typename Cnf>
+inline void at_least_one(std::vector<var_type> const& variables, Cnf& cnf_builder)
+{
+	std::vector<lit_type> clause;
+	for (auto var : variables) {
+		clause.emplace_back(var, positive_polarity);
+	}
+	cnf_builder.add_clause(clause);
+}
+
+template<typename Cnf>
+inline void at_most_one_pairwise(std::vector<var_type> const& variables, Cnf& cnf_builder)
+{
+	std::vector<lit_type> clause;
+	for (auto i = 0u; i < variables.size() - 1; ++i) {
+		for (auto j = i + 1u; j < variables.size(); ++j) {
+			clause.emplace_back(variables[i], negative_polarity);
+			clause.emplace_back(variables[j], negative_polarity);
+			cnf_builder.add_clause(clause);
+			clause.clear();
+		}
+	}
+}
+
+} // namespace bill
\ No newline at end of file
diff --git a/lib/bill/bill/sat/incremental_totalizer_cardinality.hpp b/lib/bill/bill/sat/incremental_totalizer_cardinality.hpp
new file mode 100644
index 0000000..d0e742b
--- /dev/null
+++ b/lib/bill/bill/sat/incremental_totalizer_cardinality.hpp
@@ -0,0 +1,181 @@
+/*
+ * This implementation is based on the code of Antonio Morgado and
+ * Alexey S. Ignatiev [1].  See [2] for a seminal reference.
+ *
+ * [1] https://github.com/pysathq/pysat/blob/master/cardenc/itot.hh.
+ * [2] Ruben Martins, Saurabh Joshi, Vasco M. Manquinho, Inês Lynce:
+ *     Incremental Cardinality Constraints for MaxSAT. CP 2014: 531-548
+ */
+#pragma once
+
+#include "interface/types.hpp"
+
+#include <deque>
+
+namespace bill {
+
+struct totalizer_tree {
+	std::vector<lit_type> vars;
+	uint32_t num_inputs;
+	std::shared_ptr<totalizer_tree> left;
+	std::shared_ptr<totalizer_tree> right;
+}; /* totalizer_tree */
+
+namespace detail {
+
+template<typename Solver>
+inline void create_totalizer_internal(Solver& solver, std::vector<std::vector<lit_type>>& dest,
+                                      std::vector<lit_type> const& ov, uint32_t rhs,
+                                      std::vector<lit_type> const& av,
+                                      std::vector<lit_type> const& bv)
+{
+	(void) solver;
+
+	/* i = 0 */
+	uint32_t kmin = std::min(rhs, uint32_t(bv.size()));
+	for (auto j = 0u; j < kmin; ++j) {
+		dest.emplace_back(std::vector{~bv[j], ov[j]});
+	}
+
+	/* j = 0 */
+	kmin = std::min(rhs, uint32_t(av.size()));
+	for (auto i = 0u; i < kmin; ++i) {
+		dest.emplace_back(std::vector{~av[i], ov[i]});
+	}
+
+	/* i, j > 0 */
+	for (auto i = 1u; i <= kmin; ++i) {
+		auto const min_j = std::min(rhs - i, uint32_t(bv.size()));
+		for (auto j = 1u; j <= min_j; ++j) {
+			dest.emplace_back(std::vector{~av[i - 1], ~bv[j - 1], ov[i + j - 1]});
+		}
+	}
+}
+
+template<typename Solver>
+inline void increase_totalizer_internal(Solver& solver, std::vector<std::vector<lit_type>>& dest,
+                                        std::vector<lit_type>& ov, uint32_t rhs,
+                                        std::vector<lit_type>& av, std::vector<lit_type>& bv)
+{
+	uint32_t last = ov.size();
+	for (auto i = last; i < rhs; ++i) {
+		ov.emplace_back(lit_type(solver.add_variable(), positive_polarity));
+	}
+
+	// add the constraints
+	/* i = 0 */
+	uint32_t const max_j = std::min(rhs, uint32_t(bv.size()));
+	for (auto j = last; j < max_j; ++j) {
+		dest.emplace_back(std::vector{~bv[j], ov[j]});
+	}
+
+	/* j = 0 */
+	uint32_t const max_i = std::min(rhs, uint32_t(av.size()));
+	for (auto i = last; i < max_i; ++i) {
+		dest.emplace_back(std::vector{~av[i], ov[i]});
+	}
+
+	/* i, j > 0 */
+	for (auto i = 1u; i <= max_i; ++i) {
+		auto const max_j = std::min(rhs - i, uint32_t(bv.size()));
+		auto const min_j = uint32_t(std::max(int(last) - int(i) + 1, 1));
+		for (auto j = min_j; j <= max_j; ++j) {
+			dest.emplace_back(std::vector{~av[i - 1], ~bv[j - 1], ov[i + j - 1]});
+		}
+	}
+}
+
+} // namespace detail
+
+template<typename Solver>
+inline std::shared_ptr<totalizer_tree> create_totalizer(Solver& solver,
+                                                        std::vector<std::vector<lit_type>>& dest,
+                                                        std::vector<lit_type> const& lhs,
+                                                        uint32_t rhs)
+{
+	auto const n = lhs.size();
+
+	std::deque<std::shared_ptr<totalizer_tree>> queue;
+	for (auto i = 0u; i < n; ++i) {
+		auto t = std::make_shared<totalizer_tree>();
+		t->vars.resize(1, lit_type(lhs[i].variable(), lhs[i].polarity()));
+		t->num_inputs = 1;
+		queue.push_back(t);
+	}
+
+	while (queue.size() > 1) {
+		auto const le = queue.front();
+		queue.pop_front();
+
+		auto const ri = queue.front();
+		queue.pop_front();
+
+		auto t = std::make_shared<totalizer_tree>();
+		t->num_inputs = le->num_inputs + ri->num_inputs;
+		t->left = le;
+		t->right = ri;
+
+		uint32_t kmin = std::min(rhs + 1, t->num_inputs);
+		t->vars.resize(kmin, lit_type(var_type(0), negative_polarity));
+		for (auto i = 0u; i < kmin; ++i) {
+			t->vars[i] = lit_type(solver.add_variable(), positive_polarity);
+		}
+		detail::create_totalizer_internal(solver, dest, t->vars, kmin, le->vars, ri->vars);
+		queue.push_back(t);
+	}
+	return queue.front();
+}
+
+template<typename Solver>
+inline void increase_totalizer(Solver& solver, std::vector<std::vector<lit_type>>& dest,
+                               std::shared_ptr<totalizer_tree>& t, uint32_t rhs)
+{
+	uint32_t const kmin = std::min(rhs + 1, t->num_inputs);
+	if (kmin <= t->vars.size())
+		return;
+
+	increase_totalizer(solver, dest, t->left, rhs);
+	increase_totalizer(solver, dest, t->right, rhs);
+	detail::increase_totalizer_internal(solver, dest, t->vars, kmin, t->left->vars,
+	                                    t->right->vars);
+}
+
+template<typename Solver>
+inline std::shared_ptr<totalizer_tree> merge_totalizer(Solver& solver,
+                                                       std::vector<std::vector<lit_type>>& dest,
+                                                       std::shared_ptr<totalizer_tree>& ta,
+                                                       std::shared_ptr<totalizer_tree>& tb,
+                                                       uint32_t rhs)
+{
+	increase_totalizer(solver, dest, ta, rhs);
+	increase_totalizer(solver, dest, tb, rhs);
+
+	uint32_t n = ta->num_inputs + tb->num_inputs;
+	uint32_t kmin = std::min(rhs, n);
+
+	auto t = std::make_shared<totalizer_tree>();
+	t->num_inputs = n;
+	t->left = ta;
+	t->right = tb;
+
+	t->vars.resize(kmin, lit_type(var_type(0), negative_polarity));
+	for (auto i = 0u; i < kmin; ++i) {
+		t->vars[i] = lit_type(solver.add_variable(), positive_polarity);
+	}
+
+	detail::create_totalizer_internal(solver, dest, t->vars, kmin, ta->vars, tb->vars);
+	return t;
+}
+
+template<typename Solver>
+inline std::shared_ptr<totalizer_tree> extend_totalizer(Solver& solver,
+                                                        std::vector<std::vector<lit_type>>& dest,
+                                                        std::shared_ptr<totalizer_tree>& ta,
+                                                        std::vector<lit_type> const& lhs,
+                                                        uint32_t rhs)
+{
+	auto tb = create_totalizer(solver, dest, lhs, rhs);
+	return merge_totalizer(solver, dest, ta, tb, rhs);
+}
+
+} // namespace bill
diff --git a/lib/bill/bill/sat/interface/abc_bmcg.hpp b/lib/bill/bill/sat/interface/abc_bmcg.hpp
new file mode 100644
index 0000000..73bbcf4
--- /dev/null
+++ b/lib/bill/bill/sat/interface/abc_bmcg.hpp
@@ -0,0 +1,175 @@
+/*-------------------------------------------------------------------------------------------------
+| This file is distributed under the MIT License.
+| See accompanying file /LICENSE for details.
+*------------------------------------------------------------------------------------------------*/
+#pragma once
+
+#include "common.hpp"
+#include "types.hpp"
+
+#include <memory>
+#include <variant>
+#include <vector>
+
+namespace bill {
+
+#if !defined(BILL_WINDOWS_PLATFORM)
+template<>
+class solver<solvers::bmcg> {
+	using solver_type = pabc::bmcg_sat_solver;
+
+public:
+#pragma region Constructors
+	solver()
+	{
+		solver_ = pabc::bmcg_sat_solver_start();
+	}
+
+	~solver()
+	{
+		pabc::bmcg_sat_solver_stop(solver_);
+		solver_ = nullptr;
+	}
+
+	/* disallow copying */
+	solver(solver<solvers::bmcg> const&) = delete;
+	solver<solvers::bmcg>& operator=(const solver<solvers::bmcg>&) = delete;
+#pragma endregion
+
+#pragma region Modifiers
+	void restart()
+	{
+		pabc::bmcg_sat_solver_reset(solver_);
+		state_ = result::states::undefined;
+		variable_counter_ = 0u;
+	}
+
+	var_type add_variable()
+	{
+		variable_counter_++;
+		return pabc::bmcg_sat_solver_addvar(solver_);
+	}
+
+	void add_variables(uint32_t num_variables = 1)
+	{
+		for (auto i = 0u; i < num_variables; ++i) {
+			pabc::bmcg_sat_solver_addvar(solver_);
+		}
+		variable_counter_ += num_variables;
+	}
+
+	auto add_clause(std::vector<lit_type>::const_iterator it,
+	                std::vector<lit_type>::const_iterator ie)
+	{
+		auto counter = 0u;
+		while (it != ie) {
+			literals[counter++] = pabc::Abc_Var2Lit(it->variable(),
+			                                        it->is_complemented());
+			++it;
+		}
+		auto const result = pabc::bmcg_sat_solver_addclause(solver_, literals, counter);
+		state_ = result ? result::states::dirty : result::states::unsatisfiable;
+		return result;
+	}
+
+	auto add_clause(std::vector<lit_type> const& clause)
+	{
+		return add_clause(clause.begin(), clause.end());
+	}
+
+	auto add_clause(lit_type lit)
+	{
+		return add_clause(std::vector<lit_type>{lit});
+	}
+
+	result get_model() const
+	{
+		assert(state_ == result::states::satisfiable);
+		result::model_type model;
+		for (auto i = 0u; i < num_variables(); ++i) {
+			auto const value = pabc::bmcg_sat_solver_read_cex_varvalue(solver_, i);
+			if (value == 1) {
+				model.emplace_back(lbool_type::true_);
+			} else {
+				model.emplace_back(lbool_type::false_);
+			}
+		}
+		return result(model);
+	}
+
+	result get_result() const
+	{
+		assert(state_ != result::states::dirty);
+		if (state_ == result::states::satisfiable) {
+			return get_model();
+		} else {
+			return result();
+		}
+	}
+
+	result::states solve(std::vector<lit_type> const& assumptions = {},
+	                     uint32_t conflict_limit = 0)
+	{
+		/* special case: empty solver state */
+		if (num_variables() == 0u)
+			return result::states::undefined;
+
+		if (conflict_limit > 0)
+			pabc::bmcg_sat_solver_set_conflict_budget(solver_, conflict_limit);
+
+		int result;
+		if (assumptions.size() > 0u) {
+			/* solve with assumptions */
+			uint32_t counter = 0u;
+			auto it = assumptions.begin();
+			while (it != assumptions.end()) {
+				literals[counter++] = pabc::Abc_Var2Lit(it->variable(),
+				                                        it->is_complemented());
+				++it;
+			}
+			result = pabc::bmcg_sat_solver_solve(solver_, literals, counter);
+		} else {
+			/* solve without assumptions */
+			result = pabc::bmcg_sat_solver_solve(solver_, 0, 0);
+		}
+
+		if (result == 1) {
+			state_ = result::states::satisfiable;
+		} else if (result == -1) {
+			state_ = result::states::unsatisfiable;
+		} else {
+			state_ = result::states::undefined;
+		}
+
+		return state_;
+	}
+#pragma endregion
+
+#pragma region Properties
+	uint32_t num_variables() const
+	{
+		return variable_counter_;
+	}
+
+	uint32_t num_clauses() const
+	{
+		return pabc::bmcg_sat_solver_clausenum(solver_);
+	}
+#pragma endregion
+
+private:
+	/*! \brief Backend solver */
+	solver_type* solver_ = nullptr;
+
+	/*! \brief Current state of the solver */
+	result::states state_ = result::states::undefined;
+
+	/*! \brief Temporary storage for one clause */
+	pabc::lit literals[2048];
+
+	/*! \brief Count the number of variables */
+	uint32_t variable_counter_ = 0u;
+};
+#endif
+
+} // namespace bill
diff --git a/lib/bill/bill/sat/interface/abc_bsat2.hpp b/lib/bill/bill/sat/interface/abc_bsat2.hpp
new file mode 100644
index 0000000..0a8fe76
--- /dev/null
+++ b/lib/bill/bill/sat/interface/abc_bsat2.hpp
@@ -0,0 +1,227 @@
+/*-------------------------------------------------------------------------------------------------
+| This file is distributed under the MIT License.
+| See accompanying file /LICENSE for details.
+*------------------------------------------------------------------------------------------------*/
+#pragma once
+
+#include "common.hpp"
+#include "types.hpp"
+
+#include <memory>
+#include <random>
+#include <variant>
+#include <vector>
+
+namespace bill {
+
+template<>
+class solver<solvers::bsat2> {
+	using solver_type = pabc::sat_solver;
+
+public:
+#pragma region Constructors
+	solver()
+	    : variable_counter(1, 0u)
+	    , clause_counter(1, 0)
+	{
+		solver_ = pabc::sat_solver_new();
+	}
+
+	~solver()
+	{
+		pabc::sat_solver_delete(solver_);
+		solver_ = nullptr;
+	}
+
+	/* disallow copying */
+	solver(solver<solvers::bsat2> const&) = delete;
+	solver<solvers::bsat2>& operator=(const solver<solvers::bsat2>&) = delete;
+#pragma endregion
+
+#pragma region Modifiers
+	void restart()
+	{
+		pabc::sat_solver_restart(solver_);
+		state_ = result::states::undefined;
+		randomize = false;
+		variable_counter.clear();
+		variable_counter.emplace_back(0u);
+		clause_counter.clear();
+		clause_counter.emplace_back(0);
+	}
+
+	var_type add_variable()
+	{
+		++variable_counter.back();
+		return pabc::sat_solver_addvar(solver_);
+	}
+
+	void add_variables(uint32_t num_variables = 1)
+	{
+		variable_counter.back() += num_variables;
+		for (auto i = 0u; i < num_variables; ++i) {
+			pabc::sat_solver_addvar(solver_);
+		}
+	}
+
+	auto add_clause(std::vector<lit_type>::const_iterator it,
+	                std::vector<lit_type>::const_iterator ie)
+	{
+		literals.resize(ie - it);
+		++clause_counter.back();
+		auto counter = 0u;
+		while (it != ie) {
+			literals[counter++] = pabc::Abc_Var2Lit(it->variable(),
+			                                        it->is_complemented());
+			++it;
+		}
+		auto const result = pabc::sat_solver_addclause(solver_, literals.data(), literals.data() + counter);
+		state_ = result ? result::states::dirty : result::states::unsatisfiable;
+		return result;
+	}
+
+	auto add_clause(std::vector<lit_type> const& clause)
+	{
+		return add_clause(clause.begin(), clause.end());
+	}
+
+	auto add_clause(lit_type lit)
+	{
+		--clause_counter.back(); /* do not count unit clauses */
+		return add_clause(std::vector<lit_type>{lit});
+	}
+
+	result get_model() const
+	{
+		assert(state_ == result::states::satisfiable);
+		result::model_type model;
+		for (auto i = 0u; i < num_variables(); ++i) {
+			auto const value = pabc::sat_solver_var_value(solver_, i);
+			if (value == 1) {
+				model.emplace_back(lbool_type::true_);
+			} else {
+				model.emplace_back(lbool_type::false_);
+			}
+		}
+		return result(model);
+	}
+
+	result get_result() const
+	{
+		assert(state_ != result::states::dirty);
+		if (state_ == result::states::satisfiable) {
+			return get_model();
+		} else {
+			return result();
+		}
+	}
+
+	result::states solve(std::vector<lit_type> const& assumptions = {},
+	                     uint32_t conflict_limit = 0)
+	{
+		/* special case: empty solver state */
+		if (num_variables() == 0u)
+			return result::states::undefined;
+
+		if (randomize) {
+			std::vector<uint32_t> vars;
+			for (auto i = 0u; i < num_variables(); ++i) {
+				if (random() % 2) {
+					vars.push_back(i);
+				}
+			}
+			pabc::sat_solver_set_polarity(solver_,
+			                              (int*) (const_cast<uint32_t*>(vars.data())),
+			                              vars.size());
+		}
+
+		int result;
+		if (assumptions.size() > 0u) {
+			/* solve with assumptions */
+			uint32_t counter = 0u;
+			literals.resize(assumptions.size());
+			auto it = assumptions.begin();
+			while (it != assumptions.end()) {
+				literals[counter++] = pabc::Abc_Var2Lit(it->variable(),
+				                                        it->is_complemented());
+				++it;
+			}
+			result = pabc::sat_solver_solve(solver_, literals.data(), literals.data() + counter,
+			                                conflict_limit, 0, 0, 0);
+		} else {
+			/* solve without assumptions */
+			result = pabc::sat_solver_solve(solver_, 0, 0, conflict_limit, 0, 0, 0);
+		}
+
+		if (result == 1) {
+			state_ = result::states::satisfiable;
+		} else if (result == -1) {
+			state_ = result::states::unsatisfiable;
+		} else {
+			state_ = result::states::undefined;
+		}
+
+		return state_;
+	}
+#pragma endregion
+
+#pragma region Properties
+	uint32_t num_variables() const
+	{
+		return variable_counter.back();
+		/* Note: `pabc::sat_solver_nvars(solver_)` is not correct when bookmark/rollback is used */
+	}
+
+	uint32_t num_clauses() const
+	{
+		return clause_counter.back();
+		/* Note: `pabc::sat_solver_nclauses(solver_)` is not correct when bookmark/rollback is used */
+	}
+#pragma endregion
+
+	void push()
+	{
+		pabc::sat_solver_bookmark(solver_);
+		variable_counter.emplace_back(variable_counter.back());
+		clause_counter.emplace_back(clause_counter.back());
+	}
+
+	void pop(uint32_t num_levels = 1u)
+	{
+		assert(num_levels == 1u && "bsat does not support multiple step pop");
+		assert(variable_counter.size() >= num_levels);
+		assert(clause_counter.size() >= num_levels);
+		pabc::sat_solver_rollback(solver_);
+		variable_counter.resize(uint32_t(variable_counter.size() - num_levels));
+		clause_counter.resize(uint32_t(clause_counter.size() - num_levels));
+	}
+
+	void set_random_phase(uint32_t seed = 0u)
+	{
+		randomize = true;
+		pabc::sat_solver_set_random(solver_, 1);
+		random.seed(seed);
+	}
+
+private:
+	/*! \brief Backend solver */
+	solver_type* solver_ = nullptr;
+
+	/*! \brief Current state of the solver */
+	result::states state_ = result::states::undefined;
+
+	/*! \brief Temporary storage for one clause */
+	std::vector<pabc::lit> literals;
+
+	/*! \brief Whether to randomize initial variable values */
+	bool randomize = false;
+	std::default_random_engine random;
+
+	/*! \brief Stacked counter for number of variables */
+	std::vector<uint32_t> variable_counter;
+
+	/*! \brief Stacked counter for number of clauses */
+	std::vector<int> clause_counter;
+};
+
+} // namespace bill
diff --git a/lib/bill/bill/sat/interface/common.hpp b/lib/bill/bill/sat/interface/common.hpp
new file mode 100644
index 0000000..7f17d15
--- /dev/null
+++ b/lib/bill/bill/sat/interface/common.hpp
@@ -0,0 +1,160 @@
+/*-------------------------------------------------------------------------------------------------
+| This file is distributed under the MIT License.
+| See accompanying file /LICENSE for details.
+*------------------------------------------------------------------------------------------------*/
+#pragma once
+
+#include "../../utils/platforms.hpp"
+
+#if defined(BILL_WINDOWS_PLATFORM)
+#pragma warning(push)
+#pragma warning( \
+    disable : 4018 4127 4189 4200 4242 4244 4245 4305 4365 4388 4389 4456 4457 4459 4514 4552 4571 4583 4619 4623 4625 4626 4706 4710 4711 4774 4820 4820 4996 5026 5027 5039)
+#include "../solver/ghack.hpp"
+#include "../solver/glucose.hpp"
+#define ABC_USE_NAMESPACE pabc
+#define ABC_NAMESPACE pabc
+#define ABC_USE_NO_READLINE
+#include "../solver/abc.hpp"
+#pragma warning(pop)
+#else
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdangling-else"
+#pragma GCC diagnostic ignored "-Wreorder"
+#pragma GCC diagnostic ignored "-Wsign-compare"
+#pragma GCC diagnostic ignored "-Wunused-comparison"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-value"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wzero-length-array"
+#include "../solver/ghack.hpp"
+#include "../solver/glucose.hpp"
+#include "../solver/maple.hpp"
+#ifndef LIN64
+#define LIN64
+#endif
+#define ABC_USE_NAMESPACE pabc
+#define ABC_NAMESPACE pabc
+#define ABC_USE_NO_READLINE
+#include "../solver/abc.hpp"
+#pragma GCC diagnostic pop
+#endif
+
+#include "types.hpp"
+
+#include <memory>
+#include <variant>
+#include <vector>
+
+namespace bill {
+
+class result {
+public:
+	using model_type = std::vector<lbool_type>;
+	using clause_type = std::vector<lit_type>;
+
+	enum class states : uint8_t {
+		satisfiable,
+		unsatisfiable,
+		undefined,
+		timeout,
+		dirty,
+	};
+
+	static std::string to_string(states const& state)
+	{
+		switch (state) {
+		case states::satisfiable:
+			return "satisfiable";
+		case states::unsatisfiable:
+			return "unsatisfiable";
+		case states::timeout:
+			return "timeout";
+		case states::dirty:
+			return "dirty";
+		case states::undefined:
+		default:
+			return "undefined";
+		}
+	}
+
+#pragma region Constructors
+	result(states state = states::undefined)
+	    : state_(state)
+	{}
+
+	result(model_type const& model)
+	    : state_(states::satisfiable)
+	    , data_(model)
+	{}
+
+	result(clause_type const& unsat_core)
+	    : state_(states::unsatisfiable)
+	    , data_(unsat_core)
+	{}
+#pragma endregion
+
+#pragma region Properties
+	inline bool is_satisfiable() const
+	{
+		return (state_ == states::satisfiable);
+	}
+
+	inline bool is_unsatisfiable() const
+	{
+		return (state_ == states::unsatisfiable);
+	}
+
+	inline bool is_undefined() const
+	{
+		return (state_ == states::undefined);
+	}
+
+	inline model_type model() const
+	{
+		return std::get<model_type>(data_);
+	}
+
+	inline clause_type core() const
+	{
+		return std::get<clause_type>(data_);
+	}
+#pragma endregion
+
+#pragma region Overloads
+	inline operator bool() const
+	{
+		return (state_ == states::satisfiable);
+	}
+
+	inline explicit operator std::string() const
+	{
+		return result::to_string(state_);
+	}
+#pragma endregion
+
+private:
+	states state_;
+	std::variant<model_type, clause_type> data_;
+};
+
+enum class solvers {
+	glucose_41,
+	ghack,
+	bsat2,
+#if !defined(BILL_WINDOWS_PLATFORM)
+	maple,
+	bmcg,
+#endif
+#if defined(BILL_HAS_Z3)
+	z3,
+#endif
+};
+
+/*! \brief Solver interface
+ */
+template<solvers Solver = solvers::ghack>
+class solver;
+
+} // namespace bill
diff --git a/lib/bill/bill/sat/interface/ghack.hpp b/lib/bill/bill/sat/interface/ghack.hpp
new file mode 100644
index 0000000..0d5b3b7
--- /dev/null
+++ b/lib/bill/bill/sat/interface/ghack.hpp
@@ -0,0 +1,167 @@
+/*-------------------------------------------------------------------------------------------------
+| This file is distributed under the MIT License.
+| See accompanying file /LICENSE for details.
+*------------------------------------------------------------------------------------------------*/
+#pragma once
+
+#include "common.hpp"
+#include "types.hpp"
+
+#include <memory>
+#include <variant>
+#include <vector>
+
+namespace bill {
+
+template<>
+class solver<solvers::ghack> {
+	using solver_type = GHack::Solver;
+
+public:
+#pragma region Constructors
+	solver()
+	    : solver_(std::make_unique<solver_type>())
+	{}
+
+	/* disallow copying */
+	solver(solver<solvers::ghack> const&) = delete;
+	solver<solvers::ghack>& operator=(const solver<solvers::ghack>&) = delete;
+#pragma endregion
+
+#pragma region Modifiers
+	void restart()
+	{
+		solver_.reset();
+		solver_ = std::make_unique<solver_type>();
+		state_ = result::states::undefined;
+	}
+
+	var_type add_variable()
+	{
+		return solver_->newVar();
+	}
+
+	void add_variables(uint32_t num_variables = 1)
+	{
+		for (auto i = 0u; i < num_variables; ++i) {
+			solver_->newVar();
+		}
+	}
+
+	auto add_clause(std::vector<lit_type>::const_iterator it,
+	                std::vector<lit_type>::const_iterator ie)
+	{
+		GHack::vec<GHack::Lit> literals;
+		while (it != ie) {
+			literals.push(GHack::mkLit(it->variable(), it->is_complemented()));
+			++it;
+		}
+		auto const result = solver_->addClause_(literals);
+		state_ = result ? result::states::dirty : result::states::unsatisfiable;
+		return result;
+	}
+
+	auto add_clause(std::vector<lit_type> const& clause)
+	{
+		return add_clause(clause.begin(), clause.end());
+	}
+
+	auto add_clause(lit_type lit)
+	{
+		auto const result = solver_->addClause(
+		    GHack::mkLit(lit.variable(), lit.is_complemented()));
+		state_ = result ? result::states::dirty : result::states::unsatisfiable;
+		return result;
+	}
+
+	result get_model() const
+	{
+		assert(state_ == result::states::satisfiable);
+		result::model_type model;
+		for (auto i = 0; i < solver_->model.size(); ++i) {
+			if (solver_->model[i] == GHack::l_False) {
+				model.emplace_back(lbool_type::false_);
+			} else if (solver_->model[i] == GHack::l_True) {
+				model.emplace_back(lbool_type::true_);
+			} else {
+				model.emplace_back(lbool_type::undefined);
+			}
+		}
+		return result(model);
+	}
+
+	result get_core() const
+	{
+		assert(state_ == result::states::unsatisfiable);
+		result::clause_type unsat_core;
+		for (auto i = 0; i < solver_->conflict.size(); ++i) {
+			unsat_core.emplace_back(GHack::var(solver_->conflict[i]),
+			                        GHack::sign(solver_->conflict[i]) ?
+			                            negative_polarity :
+			                            positive_polarity);
+		}
+		return result(unsat_core);
+	}
+
+	result get_result() const
+	{
+		assert(state_ != result::states::dirty);
+		if (state_ == result::states::satisfiable) {
+			return get_model();
+		} else if (state_ == result::states::unsatisfiable) {
+			return get_core();
+		} else {
+			return result();
+		}
+	}
+
+	result::states solve(std::vector<lit_type> const& assumptions = {},
+	                     uint32_t conflict_limit = 0)
+	{
+		if (state_ != result::states::dirty && assumptions.empty()) {
+			return state_;
+		}
+
+		assert(solver_->okay() == true);
+		if (conflict_limit) {
+			solver_->setConfBudget(conflict_limit);
+		}
+
+		GHack::vec<GHack::Lit> literals;
+		for (auto lit : assumptions) {
+			literals.push(GHack::mkLit(lit.variable(), lit.is_complemented()));
+		}
+
+		GHack::lbool state = solver_->solveLimited(literals);
+		if (state == GHack::l_True) {
+			state_ = result::states::satisfiable;
+		} else if (state == GHack::l_False) {
+			state_ = result::states::unsatisfiable;
+		} else {
+			state_ = result::states::undefined;
+		}
+		return state_;
+	}
+#pragma endregion
+
+#pragma region Properties
+	uint32_t num_variables() const
+	{
+		return solver_->nVars();
+	}
+
+	uint32_t num_clauses() const
+	{
+		return solver_->nClauses();
+	}
+#pragma endregion
+
+private:
+	/*! \brief Backend solver */
+	std::unique_ptr<solver_type> solver_;
+
+	/*! \brief Current state of the solver */
+	result::states state_ = result::states::undefined;
+};
+
+} // namespace bill
diff --git a/lib/bill/bill/sat/interface/glucose.hpp b/lib/bill/bill/sat/interface/glucose.hpp
new file mode 100644
index 0000000..0712dd4
--- /dev/null
+++ b/lib/bill/bill/sat/interface/glucose.hpp
@@ -0,0 +1,167 @@
+/*-------------------------------------------------------------------------------------------------
+| This file is distributed under the MIT License.
+| See accompanying file /LICENSE for details.
+*------------------------------------------------------------------------------------------------*/
+#pragma once
+
+#include "common.hpp"
+#include "types.hpp"
+
+#include <memory>
+#include <variant>
+#include <vector>
+
+namespace bill {
+
+template<>
+class solver<solvers::glucose_41> {
+	using solver_type = Glucose::Solver;
+
+public:
+#pragma region Constructors
+	solver()
+	    : solver_(std::make_unique<solver_type>())
+	{}
+
+	/* disallow copying */
+	solver(solver<solvers::glucose_41> const&) = delete;
+	solver<solvers::glucose_41>& operator=(const solver<solvers::glucose_41>&) = delete;
+#pragma endregion
+
+#pragma region Modifiers
+	void restart()
+	{
+		solver_.reset();
+		solver_ = std::make_unique<solver_type>();
+		state_ = result::states::undefined;
+	}
+
+	var_type add_variable()
+	{
+		return solver_->newVar();
+	}
+
+	void add_variables(uint32_t num_variables = 1)
+	{
+		for (auto i = 0u; i < num_variables; ++i) {
+			solver_->newVar();
+		}
+	}
+
+	auto add_clause(std::vector<lit_type>::const_iterator it,
+	                std::vector<lit_type>::const_iterator ie)
+	{
+		Glucose::vec<Glucose::Lit> literals;
+		while (it != ie) {
+			literals.push(Glucose::mkLit(it->variable(), it->is_complemented()));
+			++it;
+		}
+		auto const result = solver_->addClause_(literals);
+		state_ = result ? result::states::dirty : result::states::unsatisfiable;
+		return result;
+	}
+
+	auto add_clause(std::vector<lit_type> const& clause)
+	{
+		return add_clause(clause.begin(), clause.end());
+	}
+
+	auto add_clause(lit_type lit)
+	{
+		auto const result = solver_->addClause(
+		    Glucose::mkLit(lit.variable(), lit.is_complemented()));
+		state_ = result ? result::states::dirty : result::states::unsatisfiable;
+		return result;
+	}
+
+	result get_model() const
+	{
+		assert(state_ == result::states::satisfiable);
+		result::model_type model;
+		for (auto i = 0; i < solver_->model.size(); ++i) {
+			if (solver_->model[i] == Glucose::l_False) {
+				model.emplace_back(lbool_type::false_);
+			} else if (solver_->model[i] == Glucose::l_True) {
+				model.emplace_back(lbool_type::true_);
+			} else {
+				model.emplace_back(lbool_type::undefined);
+			}
+		}
+		return result(model);
+	}
+
+	result get_core() const
+	{
+		assert(state_ == result::states::unsatisfiable);
+		result::clause_type unsat_core;
+		for (auto i = 0; i < solver_->conflict.size(); ++i) {
+			unsat_core.emplace_back(Glucose::var(solver_->conflict[i]),
+			                        Glucose::sign(solver_->conflict[i]) ?
+			                            negative_polarity :
+			                            positive_polarity);
+		}
+		return result(unsat_core);
+	}
+
+	result get_result() const
+	{
+		assert(state_ != result::states::dirty);
+		if (state_ == result::states::satisfiable) {
+			return get_model();
+		} else if (state_ == result::states::unsatisfiable) {
+			return get_core();
+		} else {
+			return result();
+		}
+	}
+
+	result::states solve(std::vector<lit_type> const& assumptions = {},
+	                     uint32_t conflict_limit = 0)
+	{
+                if (state_ != result::states::dirty && assumptions.empty()) {
+			return state_;
+		}
+
+		assert(solver_->okay() == true);
+		if (conflict_limit) {
+			solver_->setConfBudget(conflict_limit);
+		}
+
+		Glucose::vec<Glucose::Lit> literals;
+		for (auto lit : assumptions) {
+			literals.push(Glucose::mkLit(lit.variable(), lit.is_complemented()));
+		}
+
+		Glucose::lbool state = solver_->solveLimited(literals);
+		if (state == Glucose::l_True) {
+			state_ = result::states::satisfiable;
+		} else if (state == Glucose::l_False) {
+			state_ = result::states::unsatisfiable;
+		} else {
+			state_ = result::states::undefined;
+		}
+		return state_;
+	}
+#pragma endregion
+
+#pragma region Properties
+	uint32_t num_variables() const
+	{
+		return solver_->nVars();
+	}
+
+	uint32_t num_clauses() const
+	{
+		return solver_->nClauses();
+	}
+#pragma endregion
+
+private:
+	/*! \brief Backend solver */
+	std::unique_ptr<solver_type> solver_;
+
+	/*! \brief Current state of the solver */
+	result::states state_ = result::states::undefined;
+};
+
+} // namespace bill
diff --git a/lib/bill/bill/sat/interface/maple.hpp b/lib/bill/bill/sat/interface/maple.hpp
new file mode 100644
index 0000000..08d807f
--- /dev/null
+++ b/lib/bill/bill/sat/interface/maple.hpp
@@ -0,0 +1,169 @@
+/*-------------------------------------------------------------------------------------------------
+| This file is distributed under the MIT License.
+| See accompanying file /LICENSE for details.
+*------------------------------------------------------------------------------------------------*/
+#pragma once
+
+#include "common.hpp"
+#include "types.hpp"
+
+#include <memory>
+#include <variant>
+#include <vector>
+
+namespace bill {
+
+#if !defined(BILL_WINDOWS_PLATFORM)
+template<>
+class solver<solvers::maple> {
+	using solver_type = Maple::Solver;
+
+public:
+#pragma region Constructors
+	solver()
+	    : solver_(std::make_unique<solver_type>())
+	{}
+
+	/* disallow copying */
+	solver(solver<solvers::maple> const&) = delete;
+	solver<solvers::maple>& operator=(const solver<solvers::maple>&) = delete;
+#pragma endregion
+
+#pragma region Modifiers
+	void restart()
+	{
+		solver_.reset();
+		solver_ = std::make_unique<solver_type>();
+		state_ = result::states::undefined;
+	}
+
+	var_type add_variable()
+	{
+		return solver_->newVar();
+	}
+
+	void add_variables(uint32_t num_variables = 1)
+	{
+		for (auto i = 0u; i < num_variables; ++i) {
+			solver_->newVar();
+		}
+	}
+
+	auto add_clause(std::vector<lit_type>::const_iterator it,
+	                std::vector<lit_type>::const_iterator ie)
+	{
+		Maple::vec<Maple::Lit> literals;
+		while (it != ie) {
+			literals.push(Maple::mkLit(it->variable(), it->is_complemented()));
+			++it;
+		}
+		auto const result = solver_->addClause_(literals);
+		state_ = result ? result::states::dirty : result::states::unsatisfiable;
+		return result;
+	}
+
+	auto add_clause(std::vector<lit_type> const& clause)
+	{
+		return add_clause(clause.begin(), clause.end());
+	}
+
+	auto add_clause(lit_type lit)
+	{
+		auto const result = solver_->addClause(
+		    Maple::mkLit(lit.variable(), lit.is_complemented()));
+		state_ = result ? result::states::dirty : result::states::unsatisfiable;
+		return result;
+	}
+
+	result get_model() const
+	{
+		assert(state_ == result::states::satisfiable);
+		result::model_type model;
+		for (auto i = 0; i < solver_->model.size(); ++i) {
+			if (solver_->model[i] == Maple::l_False) {
+				model.emplace_back(lbool_type::false_);
+			} else if (solver_->model[i] == Maple::l_True) {
+				model.emplace_back(lbool_type::true_);
+			} else {
+				model.emplace_back(lbool_type::undefined);
+			}
+		}
+		return result(model);
+	}
+
+	result get_core() const
+	{
+		assert(state_ == result::states::unsatisfiable);
+		result::clause_type unsat_core;
+		for (auto i = 0; i < solver_->conflict.size(); ++i) {
+			unsat_core.emplace_back(Maple::var(solver_->conflict[i]),
+			                        Maple::sign(solver_->conflict[i]) ?
+			                            negative_polarity :
+			                            positive_polarity);
+		}
+		return result(unsat_core);
+	}
+
+	result get_result() const
+	{
+		assert(state_ != result::states::dirty);
+		if (state_ == result::states::satisfiable) {
+			return get_model();
+		} else if (state_ == result::states::unsatisfiable) {
+			return get_core();
+		} else {
+			return result();
+		}
+	}
+
+	result::states solve(std::vector<lit_type> const& assumptions = {},
+	                     uint32_t conflict_limit = 0)
+	{
+		if (state_ != result::states::dirty && assumptions.empty()) {
+			return state_;
+		}
+
+		assert(solver_->okay() == true);
+		if (conflict_limit) {
+			solver_->setConfBudget(conflict_limit);
+		}
+
+		Maple::vec<Maple::Lit> literals;
+		for (auto lit : assumptions) {
+			literals.push(Maple::mkLit(lit.variable(), lit.is_complemented()));
+		}
+
+		Maple::lbool state = solver_->solveLimited(literals);
+		if (state == Maple::l_True) {
+			state_ = result::states::satisfiable;
+		} else if (state == Maple::l_False) {
+			state_ = result::states::unsatisfiable;
+		} else {
+			state_ = result::states::undefined;
+		}
+		return state_;
+	}
+#pragma endregion
+
+#pragma region Properties
+	uint32_t num_variables() const
+	{
+		return solver_->nVars();
+	}
+
+	uint32_t num_clauses() const
+	{
+		return solver_->nClauses();
+	}
+#pragma endregion
+
+private:
+	/*! \brief Backend solver */
+	std::unique_ptr<solver_type> solver_;
+
+	/*! \brief Current state of the solver */
+	result::states state_ = result::states::dirty;
+};
+#endif
+
+} // namespace bill
diff --git a/lib/bill/bill/sat/interface/types.hpp b/lib/bill/bill/sat/interface/types.hpp
new file mode 100644
index 0000000..23ae084
--- /dev/null
+++ b/lib/bill/bill/sat/interface/types.hpp
@@ -0,0 +1,146 @@
+/*-------------------------------------------------------------------------------------------------
+| This file is distributed under the MIT License.
+| See accompanying file /LICENSE for details.
+*------------------------------------------------------------------------------------------------*/
+#pragma once
+
+#include <cassert>
+#include <cstdint>
+#include <limits>
+
+namespace bill {
+
+/*! \brief Wrapper class to represent variables.
+ *
+ * A variable is an element of a convenient set.  They are often identified by symbols such as 
+ * x1, x2, ..., xn; of course, any other symbol can also be used, e.g., a, b, c.  In code, however,
+ * we use unsigned numerals 1, 2, 3, ..., n that stand for variables.
+ * 
+ * Because of its relation to literals (see below), using `uint32_t` to hold variable identifiers
+ * limits the number of possibles variables to 2^31 - 1 = 2,147,483,647.
+ */
+class var_type {
+	constexpr static uint32_t max_value = (std::numeric_limits<uint32_t>::max() >> 1);
+
+public:
+	constexpr var_type(uint32_t var = 0)
+	    : data_(var)
+	{
+		assert(var < max_value);
+	}
+
+#pragma region Overloads
+	constexpr operator uint32_t() const
+	{
+		return data_;
+	}
+
+	bool operator<(var_type other) const
+	{
+		return data_ < other.data_;
+	}
+
+	bool operator==(var_type other) const
+	{
+		return data_ == other.data_;
+	}
+
+	bool operator!=(var_type other) const
+	{
+		return data_ != other.data_;
+	}
+#pragma endregion
+
+private:
+	uint32_t data_;
+};
+
+/*! \brief Wrapper class to represent literals.
+ *
+ * A literal is either a variable or the complement of a variable. In other words, if x1 is a
+ * variable, both x1 and ~x1 are literals. If there are n possible variables in some problem, there
+ * are 2n possible literals. We call x1 and ~x1 the positive polarity literal and negative polarity
+ * literal of x1, respectively.
+ *
+ * We also use unsigned numerals to represent literals (though we could have used singed numerals
+ * and use the sign to represent each polarity). When using unsigned numerals, even numerals
+ * represent positive polarity and odd numerals represent negative polarity.
+ *
+ * Using `uint32_t` to hold literals identifiers limits the number of possible literals to
+ * 2^32 - 1 = 4,294,967,295.
+ */
+class lit_type {
+public:
+	enum class polarities : bool {
+		positive = 0,
+		negative = 1,
+	};
+
+	constexpr lit_type(var_type var = {}, polarities polarity = polarities::positive)
+	    : data_((var << 1) | ((polarity == polarities::positive) ? 0 : 1))
+	{}
+
+#pragma region Properties
+	var_type variable() const
+	{
+		return (data_ >> 1);
+	}
+
+	polarities polarity() const
+	{
+		return polarities((data_ & 1) == 1);
+	}
+
+	bool is_complemented() const
+	{
+		return (data_ & 1) == 1;
+	}
+#pragma endregion
+
+#pragma region Modifiers
+	void complement()
+	{
+		data_ ^= 1;
+	}
+#pragma endregion
+
+#pragma region Overloads
+	lit_type operator~() const
+	{
+		lit_type complemented(*this);
+		complemented.data_ ^= 1;
+		return complemented;
+	}
+
+	bool operator<(lit_type other) const
+	{
+		return data_ < other.data_;
+	}
+
+	bool operator==(lit_type other) const
+	{
+		return data_ == other.data_;
+	}
+
+	bool operator!=(lit_type other) const
+	{
+		return data_ != other.data_;
+	}
+#pragma endregion
+
+private:
+	uint32_t data_;
+};
+
+constexpr auto positive_polarity = lit_type::polarities::positive;
+constexpr auto negative_polarity = lit_type::polarities::negative;
+
+/*! \brief Lifted Boolean wrapper class.
+ */
+enum class lbool_type : uint8_t {
+	true_,
+	false_,
+	undefined,
+};
+
+} // namespace bill
diff --git a/lib/bill/bill/sat/interface/z3.hpp b/lib/bill/bill/sat/interface/z3.hpp
new file mode 100644
index 0000000..15e3061
--- /dev/null
+++ b/lib/bill/bill/sat/interface/z3.hpp
@@ -0,0 +1,196 @@
+/*-------------------------------------------------------------------------------------------------
+| This file is distributed under the MIT License.
+| See accompanying file /LICENSE for details.
+*------------------------------------------------------------------------------------------------*/
+#pragma once
+
+#if defined(BILL_HAS_Z3)
+
+#include "common.hpp"
+#include "types.hpp"
+
+#include <fmt/format.h>
+#include <limits>
+#include <vector>
+#include <z3++.h>
+
+namespace bill {
+
+template<>
+class solver<solvers::z3> {
+public:
+#pragma region Constructors
+	solver()
+	    : solver_(ctx_)
+	    , variable_counter_(1, 0u)
+	    , clause_counter_(1, 0u)
+	{}
+
+	~solver()
+	{}
+
+	/* disallow copying */
+	solver(solver<solvers::z3> const&) = delete;
+	solver<solvers::z3>& operator=(const solver<solvers::z3>&) = delete;
+#pragma endregion
+
+#pragma region Modifiers
+	void restart()
+	{
+		solver_.reset();
+		vars_.clear();
+		variable_counter_.clear();
+		variable_counter_.emplace_back(0u);
+		clause_counter_.clear();
+		clause_counter_.emplace_back(0u);
+		state_ = result::states::undefined;
+	}
+
+	var_type add_variable()
+	{
+		vars_.push_back(ctx_.bool_const(fmt::format("x{}", variable_counter_.back()).c_str()));
+		return variable_counter_.back()++;
+	}
+
+	void add_variables(uint32_t num_variables = 1)
+	{
+		for (auto i = 0u; i < num_variables; ++i) {
+			add_variable();
+		}
+	}
+
+	auto add_clause(std::vector<lit_type>::const_iterator it,
+	                std::vector<lit_type>::const_iterator ie)
+	{
+		z3::expr_vector vec(ctx_);
+		while (it != ie) {
+			vec.push_back(it->is_complemented() ? !vars_[it->variable()] :
+			                                      vars_[it->variable()]);
+			++it;
+		}
+		solver_.add(mk_or(vec));
+		++clause_counter_.back();
+		return result::states::dirty;
+	}
+
+	auto add_clause(std::vector<lit_type> const& clause)
+	{
+		return add_clause(std::begin(clause), std::end(clause));
+	}
+
+	auto add_clause(lit_type lit)
+	{
+		solver_.add(lit.is_complemented() ? !vars_[lit.variable()] : vars_[lit.variable()]);
+		return result::states::dirty;
+	}
+
+	result get_model() const
+	{
+		assert(state_ == result::states::satisfiable);
+		result::model_type model;
+		const auto m = solver_.get_model();
+		for (auto const& v : vars_) {
+			model.emplace_back(m.eval(v).is_true() ? lbool_type::true_ :
+			                                         lbool_type::false_);
+		}
+		return result(model);
+	}
+
+	result get_result() const
+	{
+		assert(state_ != result::states::dirty);
+		if (state_ == result::states::satisfiable) {
+			return get_model();
+		} else {
+			return result();
+		}
+	}
+
+	result::states solve(std::vector<lit_type> const& assumptions = {},
+	                     uint32_t conflict_limit = 0u)
+	{
+		z3::expr_vector vec(ctx_);
+		for (auto const& lit : assumptions)
+			vec.push_back(lit.is_complemented() ? !vars_[lit.variable()] :
+			                                      vars_[lit.variable()]);
+		solver_.set("sat.max_conflicts", conflict_limit == 0u ?
+		                                     std::numeric_limits<uint32_t>::max() :
+		                                     conflict_limit);
+		switch (solver_.check(vec)) {
+		case z3::sat:
+			state_ = result::states::satisfiable;
+			break;
+		case z3::unsat:
+			state_ = result::states::unsatisfiable;
+			break;
+		case z3::unknown:
+		default:
+			state_ = result::states::undefined;
+			break;
+		};
+		z3::reset_params();
+		return state_;
+	}
+#pragma endregion
+
+#pragma region Properties
+	uint32_t num_variables() const
+	{
+		return variable_counter_.back();
+	}
+
+	uint32_t num_clauses() const
+	{
+		return clause_counter_.back();
+	}
+#pragma endregion
+
+	void push()
+	{
+		solver_.push();
+		variable_counter_.emplace_back(variable_counter_.back());
+		clause_counter_.emplace_back(clause_counter_.back());
+	}
+
+	void pop(uint32_t num_levels = 1u)
+	{
+		assert(num_levels < variable_counter_.size());
+		assert(variable_counter_.size() >= num_levels);
+		assert(clause_counter_.size() >= num_levels);
+		solver_.pop(num_levels);
+		variable_counter_.resize(uint32_t(variable_counter_.size() - num_levels));
+		clause_counter_.resize(uint32_t(clause_counter_.size() - num_levels));
+		if (vars_.size() > variable_counter_.back()) {
+			vars_.erase(vars_.begin() + variable_counter_.back(), vars_.end());
+		}
+	}
+
+	void set_random_phase(uint32_t seed = 0u)
+	{
+		solver_.set("sat.random_seed", seed);
+		solver_.set("phase_selection", 5u);
+	}
+
+private:
+	/*! \brief Backend solver context object */
+	z3::context ctx_;
+
+	/*! \brief Backend solver */
+	z3::solver solver_;
+
+	/*! \brief Current state of the solver */
+	result::states state_ = result::states::undefined;
+
+	/*! \brief Variables */
+	std::vector<z3::expr> vars_;
+
+	/*! \brief Stacked counter for number of variables */
+	std::vector<uint32_t> variable_counter_;
+
+	/*! \brief Stacked counter for number of clauses */
+	std::vector<uint32_t> clause_counter_;
+};
+
+} // namespace bill
+
+#endif
diff --git a/lib/bill/bill/sat/solver.hpp b/lib/bill/bill/sat/solver.hpp
new file mode 100644
index 0000000..65afa0d
--- /dev/null
+++ b/lib/bill/bill/sat/solver.hpp
@@ -0,0 +1,12 @@
+/*-------------------------------------------------------------------------------------------------
+| This file is distributed under the MIT License.
+| See accompanying file /LICENSE for details.
+*------------------------------------------------------------------------------------------------*/
+#pragma once
+
+#include "interface/abc_bmcg.hpp"
+#include "interface/abc_bsat2.hpp"
+#include "interface/ghack.hpp"
+#include "interface/glucose.hpp"
+#include "interface/maple.hpp"
+#include "interface/z3.hpp"
diff --git a/lib/bill/bill/sat/solver/abc.hpp b/lib/bill/bill/sat/solver/abc.hpp
new file mode 100644
index 0000000..f1e9b83
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc.hpp
@@ -0,0 +1,5927 @@
+#pragma once
+
+/*** satStore.cpp ***/
+
+/**CFile****************************************************************
+
+  FileName    [satStore.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SAT solver.]
+
+  Synopsis    [Records the trace of SAT solving in the CNF form.]
+
+  Author      [Alan Mishchenko]
+
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: satStore.c,v 1.4 2005/09/16 22:55:03 casem Exp $]
+
+***********************************************************************/
+
+#include "abc/satStore.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Fetches memory.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline char* Sto_ManMemoryFetch(Sto_Man_t* p, int nBytes)
+{
+	char* pMem;
+	if (p->pChunkLast == NULL || nBytes > p->nChunkSize - p->nChunkUsed) {
+		pMem = (char*) ABC_ALLOC(char, p->nChunkSize);
+		*(char**) pMem = p->pChunkLast;
+		p->pChunkLast = pMem;
+		p->nChunkUsed = sizeof(char*);
+	}
+	pMem = p->pChunkLast + p->nChunkUsed;
+	p->nChunkUsed += nBytes;
+	return pMem;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Frees memory manager.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline void Sto_ManMemoryStop(Sto_Man_t* p)
+{
+	char *pMem, *pNext;
+	if (p->pChunkLast == NULL)
+		return;
+	for (pMem = p->pChunkLast; (pNext = *(char**) pMem); pMem = pNext)
+		ABC_FREE(pMem);
+	ABC_FREE(pMem);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Reports memory usage in bytes.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline int Sto_ManMemoryReport(Sto_Man_t* p)
+{
+	int Total;
+	char *pMem, *pNext;
+	if (p->pChunkLast == NULL)
+		return 0;
+	Total = p->nChunkUsed;
+	for (pMem = p->pChunkLast; (pNext = *(char**) pMem); pMem = pNext)
+		Total += p->nChunkSize;
+	return Total;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocate proof manager.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline Sto_Man_t* Sto_ManAlloc()
+{
+	Sto_Man_t* p;
+	// allocate the manager
+	p = (Sto_Man_t*) ABC_ALLOC(char, sizeof(Sto_Man_t));
+	memset(p, 0, sizeof(Sto_Man_t));
+	// memory management
+	p->nChunkSize = (1 << 16); // use 64K chunks
+	return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Deallocate proof manager.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline void Sto_ManFree(Sto_Man_t* p)
+{
+	Sto_ManMemoryStop(p);
+	ABC_FREE(p);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Adds one clause to the manager.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline int Sto_ManAddClause(Sto_Man_t* p, lit* pBeg, lit* pEnd)
+{
+	Sto_Cls_t* pClause;
+	lit Lit, *i, *j;
+	int nSize;
+
+	// process the literals
+	if (pBeg < pEnd) {
+		// insertion sort
+		for (i = pBeg + 1; i < pEnd; i++) {
+			Lit = *i;
+			for (j = i; j > pBeg && *(j - 1) > Lit; j--)
+				*j = *(j - 1);
+			*j = Lit;
+		}
+		// make sure there is no duplicated variables
+		for (i = pBeg + 1; i < pEnd; i++)
+			if (lit_var(*(i - 1)) == lit_var(*i)) {
+				printf("The clause contains two literals of the same variable: %d "
+				       "and %d.\n",
+				       *(i - 1), *i);
+				return 0;
+			}
+		// check the largest var size
+		p->nVars = STO_MAX(p->nVars, lit_var(*(pEnd - 1)) + 1);
+	}
+
+	// get memory for the clause
+	nSize = sizeof(Sto_Cls_t) + sizeof(lit) * (pEnd - pBeg);
+	nSize = (nSize / sizeof(char*) + ((nSize % sizeof(char*)) > 0))
+	        * sizeof(char*); // added by Saurabh on Sep 3, 2009
+	pClause = (Sto_Cls_t*) Sto_ManMemoryFetch(p, nSize);
+	memset(pClause, 0, sizeof(Sto_Cls_t));
+
+	// assign the clause
+	pClause->Id = p->nClauses++;
+	pClause->nLits = pEnd - pBeg;
+	memcpy(pClause->pLits, pBeg, sizeof(lit) * (pEnd - pBeg));
+	//    assert( pClause->pLits[0] >= 0 );
+
+	// add the clause to the list
+	if (p->pHead == NULL)
+		p->pHead = pClause;
+	if (p->pTail == NULL)
+		p->pTail = pClause;
+	else {
+		p->pTail->pNext = pClause;
+		p->pTail = pClause;
+	}
+
+	// add the empty clause
+	if (pClause->nLits == 0) {
+		if (p->pEmpty) {
+			printf("More than one empty clause!\n");
+			return 0;
+		}
+		p->pEmpty = pClause;
+	}
+	return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Mark all clauses added so far as root clauses.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline void Sto_ManMarkRoots(Sto_Man_t* p)
+{
+	Sto_Cls_t* pClause;
+	p->nRoots = 0;
+	Sto_ManForEachClause(p, pClause)
+	{
+		pClause->fRoot = 1;
+		p->nRoots++;
+	}
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Mark all clauses added so far as clause of A.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline void Sto_ManMarkClausesA(Sto_Man_t* p)
+{
+	Sto_Cls_t* pClause;
+	p->nClausesA = 0;
+	Sto_ManForEachClause(p, pClause)
+	{
+		pClause->fA = 1;
+		p->nClausesA++;
+	}
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the literal of the last clause.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline int Sto_ManChangeLastClause(Sto_Man_t* p)
+{
+	Sto_Cls_t *pClause, *pPrev;
+	pPrev = NULL;
+	Sto_ManForEachClause(p, pClause) pPrev = pClause;
+	assert(pPrev != NULL);
+	assert(pPrev->fA == 1);
+	assert(pPrev->nLits == 1);
+	p->nClausesA--;
+	pPrev->fA = 0;
+	return pPrev->pLits[0] >> 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Writes the stored clauses into a file.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline void Sto_ManDumpClauses(Sto_Man_t* p, char* pFileName)
+{
+	FILE* pFile;
+	Sto_Cls_t* pClause;
+	int i;
+	// start the file
+	pFile = fopen(pFileName, "w");
+	if (pFile == NULL) {
+		printf("Error: Cannot open output file (%s).\n", pFileName);
+		return;
+	}
+	// write the data
+	fprintf(pFile, "p %d %d %d %d\n", p->nVars, p->nClauses, p->nRoots, p->nClausesA);
+	Sto_ManForEachClause(p, pClause)
+	{
+		for (i = 0; i < (int) pClause->nLits; i++)
+			fprintf(pFile, " %d", lit_print(pClause->pLits[i]));
+		fprintf(pFile, " 0\n");
+	}
+	//    fprintf( pFile, " 0\n" );
+	fclose(pFile);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Reads one literal from file.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline int Sto_ManLoadNumber(FILE* pFile, int* pNumber)
+{
+	int Char, Number = 0, Sign = 0;
+	// skip space-like chars
+	do {
+		Char = fgetc(pFile);
+		if (Char == EOF)
+			return 0;
+	} while (Char == ' ' || Char == '\t' || Char == '\r' || Char == '\n');
+	// read the literal
+	while (1) {
+		// get the next character
+		Char = fgetc(pFile);
+		if (Char == ' ' || Char == '\t' || Char == '\r' || Char == '\n')
+			break;
+		// check that the char is a digit
+		if ((Char < '0' || Char > '9') && Char != '-') {
+			printf("Error: Wrong char (%c) in the input file.\n", Char);
+			return 0;
+		}
+		// check if this is a minus
+		if (Char == '-')
+			Sign = 1;
+		else
+			Number = 10 * Number + Char;
+	}
+	// return the number
+	*pNumber = Sign ? -Number : Number;
+	return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Reads CNF from file.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline Sto_Man_t* Sto_ManLoadClauses(char* pFileName)
+{
+	FILE* pFile;
+	Sto_Man_t* p;
+	Sto_Cls_t* pClause;
+	char pBuffer[1024];
+	int nLits, nLitsAlloc, Counter, Number;
+	lit* pLits;
+
+	// start the file
+	pFile = fopen(pFileName, "r");
+	if (pFile == NULL) {
+		printf("Error: Cannot open input file (%s).\n", pFileName);
+		return NULL;
+	}
+
+	// create the manager
+	p = Sto_ManAlloc();
+
+	// alloc the array of literals
+	nLitsAlloc = 1024;
+	pLits = (lit*) ABC_ALLOC(char, sizeof(lit) * nLitsAlloc);
+
+	// read file header
+	p->nVars = p->nClauses = p->nRoots = p->nClausesA = 0;
+	while (fgets(pBuffer, 1024, pFile)) {
+		if (pBuffer[0] == 'c')
+			continue;
+		if (pBuffer[0] == 'p') {
+			sscanf(pBuffer + 1, "%d %d %d %d", &p->nVars, &p->nClauses, &p->nRoots,
+			       &p->nClausesA);
+			break;
+		}
+		printf("Warning: Skipping line: \"%s\"\n", pBuffer);
+	}
+
+	// read the clauses
+	nLits = 0;
+	while (Sto_ManLoadNumber(pFile, &Number)) {
+		if (Number == 0) {
+			int RetValue;
+			RetValue = Sto_ManAddClause(p, pLits, pLits + nLits);
+			assert(RetValue);
+			nLits = 0;
+			continue;
+		}
+		if (nLits == nLitsAlloc) {
+			nLitsAlloc *= 2;
+			pLits = ABC_REALLOC(lit, pLits, nLitsAlloc);
+		}
+		pLits[nLits++] = lit_read(Number);
+	}
+	if (nLits > 0)
+		printf("Error: The last clause was not saved.\n");
+
+	// count clauses
+	Counter = 0;
+	Sto_ManForEachClause(p, pClause) Counter++;
+
+	// check the number of clauses
+	if (p->nClauses != Counter) {
+		printf(
+		    "Error: The actual number of clauses (%d) is different than declared (%d).\n",
+		    Counter, p->nClauses);
+		Sto_ManFree(p);
+		return NULL;
+	}
+
+	ABC_FREE(pLits);
+	fclose(pFile);
+	return p;
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+ABC_NAMESPACE_IMPL_END
+
+/*** satSolver.cpp ***/
+
+/**************************************************************************************************
+MiniSat -- Copyright (c) 2005, Niklas Sorensson
+http://www.cs.chalmers.se/Cs/Research/FormalMethods/MiniSat/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+// Modified to compile with MS Visual Studio 6.0 by Alan Mishchenko
+
+#include "abc/satSolver.h"
+#include "abc/satStore.h"
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+ABC_NAMESPACE_IMPL_START
+
+#define SAT_USE_ANALYZE_FINAL
+
+//=================================================================================================
+// Debug:
+
+//#define VERBOSEDEBUG
+
+/**Function*************************************************************
+
+  Synopsis    [Merging two lists of entries.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline void Abc_MergeSortCostMerge(int* p1Beg, int* p1End, int* p2Beg, int* p2End, int* pOut)
+{
+	int nEntries = (p1End - p1Beg) + (p2End - p2Beg);
+	int* pOutBeg = pOut;
+	while (p1Beg < p1End && p2Beg < p2End) {
+		if (p1Beg[1] == p2Beg[1])
+			*pOut++ = *p1Beg++, *pOut++ = *p1Beg++, *pOut++ = *p2Beg++,
+			*pOut++ = *p2Beg++;
+		else if (p1Beg[1] < p2Beg[1])
+			*pOut++ = *p1Beg++, *pOut++ = *p1Beg++;
+		else // if ( p1Beg[1] > p2Beg[1] )
+			*pOut++ = *p2Beg++, *pOut++ = *p2Beg++;
+	}
+	while (p1Beg < p1End)
+		*pOut++ = *p1Beg++, *pOut++ = *p1Beg++;
+	while (p2Beg < p2End)
+		*pOut++ = *p2Beg++, *pOut++ = *p2Beg++;
+	assert(pOut - pOutBeg == nEntries);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Recursive sorting.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline void Abc_MergeSortCost_rec(int* pInBeg, int* pInEnd, int* pOutBeg)
+{
+	int nSize = (pInEnd - pInBeg) / 2;
+	assert(nSize > 0);
+	if (nSize == 1)
+		return;
+	if (nSize == 2) {
+		if (pInBeg[1] > pInBeg[3]) {
+			pInBeg[1] ^= pInBeg[3];
+			pInBeg[3] ^= pInBeg[1];
+			pInBeg[1] ^= pInBeg[3];
+			pInBeg[0] ^= pInBeg[2];
+			pInBeg[2] ^= pInBeg[0];
+			pInBeg[0] ^= pInBeg[2];
+		}
+	} else if (nSize < 8) {
+		int temp, i, j, best_i;
+		for (i = 0; i < nSize - 1; i++) {
+			best_i = i;
+			for (j = i + 1; j < nSize; j++)
+				if (pInBeg[2 * j + 1] < pInBeg[2 * best_i + 1])
+					best_i = j;
+			temp = pInBeg[2 * i];
+			pInBeg[2 * i] = pInBeg[2 * best_i];
+			pInBeg[2 * best_i] = temp;
+			temp = pInBeg[2 * i + 1];
+			pInBeg[2 * i + 1] = pInBeg[2 * best_i + 1];
+			pInBeg[2 * best_i + 1] = temp;
+		}
+	} else {
+		Abc_MergeSortCost_rec(pInBeg, pInBeg + 2 * (nSize / 2), pOutBeg);
+		Abc_MergeSortCost_rec(pInBeg + 2 * (nSize / 2), pInEnd, pOutBeg + 2 * (nSize / 2));
+		Abc_MergeSortCostMerge(pInBeg, pInBeg + 2 * (nSize / 2), pInBeg + 2 * (nSize / 2),
+		                       pInEnd, pOutBeg);
+		memcpy(pInBeg, pOutBeg, sizeof(int) * 2 * nSize);
+	}
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting procedure.]
+
+  Description [Returns permutation for the non-decreasing order of costs.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline int* Abc_MergeSortCost(int* pCosts, int nSize)
+{
+	int i, *pResult, *pInput, *pOutput;
+	pResult = (int*) calloc(sizeof(int), nSize);
+	if (nSize < 2)
+		return pResult;
+	pInput = (int*) malloc(sizeof(int) * 2 * nSize);
+	pOutput = (int*) malloc(sizeof(int) * 2 * nSize);
+	for (i = 0; i < nSize; i++)
+		pInput[2 * i] = i, pInput[2 * i + 1] = pCosts[i];
+	Abc_MergeSortCost_rec(pInput, pInput + 2 * nSize, pOutput);
+	for (i = 0; i < nSize; i++)
+		pResult[i] = pInput[2 * i];
+	free(pOutput);
+	free(pInput);
+	return pResult;
+}
+
+// For derivation output (verbosity level 2)
+#define L_IND "%-*d"
+#define L_ind sat_solver_dl(s) * 2 + 2, sat_solver_dl(s)
+#define L_LIT "%sx%d"
+#define L_lit(p) lit_sign(p) ? "~" : "", (lit_var(p))
+
+// Just like 'assert()' but expression will be evaluated in the release version as well.
+static inline void check(int expr)
+{
+	assert(expr);
+}
+
+// static inline void printlits(lit* begin, lit* end)
+// {
+//     int i;
+//     for (i = 0; i < end - begin; i++)
+//         printf(L_LIT" ",L_lit(begin[i]));
+// }
+
+//=================================================================================================
+// Random numbers:
+
+// Returns a random float 0 <= x < 1. Seed must never be 0.
+static inline double drand(double* seed)
+{
+	int q;
+	*seed *= 1389796;
+	q = (int) (*seed / 2147483647);
+	*seed -= (double) q * 2147483647;
+	return *seed / 2147483647;
+}
+
+// Returns a random integer 0 <= x < size. Seed must never be 0.
+static inline int irand(double* seed, int size)
+{
+	return (int) (drand(seed) * size);
+}
+
+//=================================================================================================
+// Variable datatype + minor functions:
+
+static const int var0 = 1;
+static const int var1 = 0;
+static const int varX = 3;
+
+struct varinfo_t {
+	unsigned val : 2;  // variable value
+	unsigned pol : 1;  // last polarity
+	unsigned tag : 1;  // conflict analysis tag
+	unsigned lev : 28; // variable level
+};
+
+static inline int var_level(sat_solver* s, int v)
+{
+	return s->levels[v];
+}
+static inline int var_value(sat_solver* s, int v)
+{
+	return s->assigns[v];
+}
+static inline int var_polar(sat_solver* s, int v)
+{
+	return s->polarity[v];
+}
+
+static inline void var_set_level(sat_solver* s, int v, int lev)
+{
+	s->levels[v] = lev;
+}
+static inline void var_set_value(sat_solver* s, int v, int val)
+{
+	s->assigns[v] = val;
+}
+static inline void var_set_polar(sat_solver* s, int v, int pol)
+{
+	s->polarity[v] = pol;
+}
+
+// variable tags
+static inline int var_tag(sat_solver* s, int v)
+{
+	return s->tags[v];
+}
+static inline void var_set_tag(sat_solver* s, int v, int tag)
+{
+	assert(tag > 0 && tag < 16);
+	if (s->tags[v] == 0)
+		veci_push(&s->tagged, v);
+	s->tags[v] = tag;
+}
+static inline void var_add_tag(sat_solver* s, int v, int tag)
+{
+	assert(tag > 0 && tag < 16);
+	if (s->tags[v] == 0)
+		veci_push(&s->tagged, v);
+	s->tags[v] |= tag;
+}
+static inline void solver2_clear_tags(sat_solver* s, int start)
+{
+	int i, *tagged = veci_begin(&s->tagged);
+	for (i = start; i < veci_size(&s->tagged); i++)
+		s->tags[tagged[i]] = 0;
+	veci_resize(&s->tagged, start);
+}
+
+inline int sat_solver_get_var_value(sat_solver* s, int v)
+{
+	if (var_value(s, v) == var0)
+		return l_False;
+	if (var_value(s, v) == var1)
+		return l_True;
+	if (var_value(s, v) == varX)
+		return l_Undef;
+	assert(0);
+	return 0;
+}
+
+//=================================================================================================
+// Simple helpers:
+
+static inline int sat_solver_dl(sat_solver* s)
+{
+	return veci_size(&s->trail_lim);
+}
+static inline veci* sat_solver_read_wlist(sat_solver* s, lit l)
+{
+	return &s->wlists[l];
+}
+
+//=================================================================================================
+// Variable order functions:
+
+static inline void order_update(sat_solver* s, int v) // updateorder
+{
+	int* orderpos = s->orderpos;
+	int* heap = veci_begin(&s->order);
+	int i = orderpos[v];
+	int x = heap[i];
+	int parent = (i - 1) / 2;
+
+	assert(s->orderpos[v] != -1);
+
+	while (i != 0 && s->activity[x] > s->activity[heap[parent]]) {
+		heap[i] = heap[parent];
+		orderpos[heap[i]] = i;
+		i = parent;
+		parent = (i - 1) / 2;
+	}
+
+	heap[i] = x;
+	orderpos[x] = i;
+}
+
+static inline void order_assigned(sat_solver* s, int v)
+{}
+
+static inline void order_unassigned(sat_solver* s, int v) // undoorder
+{
+	int* orderpos = s->orderpos;
+	if (orderpos[v] == -1) {
+		orderpos[v] = veci_size(&s->order);
+		veci_push(&s->order, v);
+		order_update(s, v);
+		// printf( "+%d ", v );
+	}
+}
+
+static inline int order_select(sat_solver* s, float random_var_freq) // selectvar
+{
+	int* heap = veci_begin(&s->order);
+	int* orderpos = s->orderpos;
+	// Random decision:
+	if (drand(&s->random_seed) < random_var_freq) {
+		int next = irand(&s->random_seed, s->size);
+		assert(next >= 0 && next < s->size);
+		if (var_value(s, next) == varX)
+			return next;
+	}
+	// Activity based decision:
+	while (veci_size(&s->order) > 0) {
+		int next = heap[0];
+		int size = veci_size(&s->order) - 1;
+		int x = heap[size];
+		veci_resize(&s->order, size);
+		orderpos[next] = -1;
+		if (size > 0) {
+			int i = 0;
+			int child = 1;
+			while (child < size) {
+
+				if (child + 1 < size
+				    && s->activity[heap[child]] < s->activity[heap[child + 1]])
+					child++;
+				assert(child < size);
+				if (s->activity[x] >= s->activity[heap[child]])
+					break;
+
+				heap[i] = heap[child];
+				orderpos[heap[i]] = i;
+				i = child;
+				child = 2 * child + 1;
+			}
+			heap[i] = x;
+			orderpos[heap[i]] = i;
+		}
+		if (var_value(s, next) == varX)
+			return next;
+	}
+	return var_Undef;
+}
+
+inline void sat_solver_set_var_activity(sat_solver* s, int* pVars, int nVars)
+{
+	int i;
+	assert(s->VarActType == 1);
+	for (i = 0; i < s->size; i++)
+		s->activity[i] = 0;
+	s->var_inc = Abc_Dbl2Word(1);
+	for (i = 0; i < nVars; i++) {
+		int iVar = pVars ? pVars[i] : i;
+		s->activity[iVar] = Abc_Dbl2Word(nVars - i);
+		order_update(s, iVar);
+	}
+}
+
+//=================================================================================================
+// variable activities
+
+inline void solver_init_activities(sat_solver* s)
+{
+	// variable activities
+	if (s->VarActType == 0) {
+		s->var_inc = (1 << 5);
+		s->var_decay = -1;
+	} else if (s->VarActType == 1) {
+		s->var_inc = Abc_Dbl2Word(1.0);
+		s->var_decay = Abc_Dbl2Word(1.0 / 0.95);
+	} else if (s->VarActType == 2) {
+		s->var_inc = Xdbl_FromDouble(1.0);
+		s->var_decay = Xdbl_FromDouble(1.0 / 0.950);
+	} else
+		assert(0);
+
+	// clause activities
+	if (s->ClaActType == 0) {
+		s->cla_inc = (1 << 11);
+		s->cla_decay = -1;
+	} else {
+		s->cla_inc = 1;
+		s->cla_decay = (float) (1 / 0.999);
+	}
+}
+
+static inline void act_var_rescale(sat_solver* s)
+{
+	if (s->VarActType == 0) {
+		word* activity = s->activity;
+		int i;
+		for (i = 0; i < s->size; i++)
+			activity[i] >>= 19;
+		s->var_inc >>= 19;
+		s->var_inc = Abc_MaxInt((unsigned) s->var_inc, (1 << 4));
+	} else if (s->VarActType == 1) {
+		double* activity = (double*) s->activity;
+		int i;
+		for (i = 0; i < s->size; i++)
+			activity[i] *= 1e-100;
+		s->var_inc = Abc_Dbl2Word(Abc_Word2Dbl(s->var_inc) * 1e-100);
+		// printf( "Rescaling var activity...\n" );
+	} else if (s->VarActType == 2) {
+		xdbl* activity = s->activity;
+		int i;
+		for (i = 0; i < s->size; i++)
+			activity[i] = Xdbl_Div(activity[i], 200); // activity[i] / 2^200
+		s->var_inc = Xdbl_Div(s->var_inc, 200);
+	} else
+		assert(0);
+}
+static inline void act_var_bump(sat_solver* s, int v)
+{
+	if (s->VarActType == 0) {
+		s->activity[v] += s->var_inc;
+		if ((unsigned) s->activity[v] & 0x80000000)
+			act_var_rescale(s);
+		if (s->orderpos[v] != -1)
+			order_update(s, v);
+	} else if (s->VarActType == 1) {
+		double act = Abc_Word2Dbl(s->activity[v]) + Abc_Word2Dbl(s->var_inc);
+		s->activity[v] = Abc_Dbl2Word(act);
+		if (act > 1e100)
+			act_var_rescale(s);
+		if (s->orderpos[v] != -1)
+			order_update(s, v);
+	} else if (s->VarActType == 2) {
+		s->activity[v] = Xdbl_Add(s->activity[v], s->var_inc);
+		if (s->activity[v] > ABC_CONST(0x014c924d692ca61b))
+			act_var_rescale(s);
+		if (s->orderpos[v] != -1)
+			order_update(s, v);
+	} else
+		assert(0);
+}
+static inline void act_var_bump_global(sat_solver* s, int v)
+{
+	if (!s->pGlobalVars || !s->pGlobalVars[v])
+		return;
+	if (s->VarActType == 0) {
+		s->activity[v] += (int) ((unsigned) s->var_inc * 3);
+		if (s->activity[v] & 0x80000000)
+			act_var_rescale(s);
+		if (s->orderpos[v] != -1)
+			order_update(s, v);
+	} else if (s->VarActType == 1) {
+		double act = Abc_Word2Dbl(s->activity[v]) + Abc_Word2Dbl(s->var_inc) * 3.0;
+		s->activity[v] = Abc_Dbl2Word(act);
+		if (act > 1e100)
+			act_var_rescale(s);
+		if (s->orderpos[v] != -1)
+			order_update(s, v);
+	} else if (s->VarActType == 2) {
+		s->activity[v] = Xdbl_Add(s->activity[v], Xdbl_Mul(s->var_inc, Xdbl_FromDouble(3.0)));
+		if (s->activity[v] > ABC_CONST(0x014c924d692ca61b))
+			act_var_rescale(s);
+		if (s->orderpos[v] != -1)
+			order_update(s, v);
+	} else
+		assert(0);
+}
+static inline void act_var_bump_factor(sat_solver* s, int v)
+{
+	if (!s->factors)
+		return;
+	if (s->VarActType == 0) {
+		s->activity[v] += (int) ((unsigned) s->var_inc * (float) s->factors[v]);
+		if (s->activity[v] & 0x80000000)
+			act_var_rescale(s);
+		if (s->orderpos[v] != -1)
+			order_update(s, v);
+	} else if (s->VarActType == 1) {
+		double act = Abc_Word2Dbl(s->activity[v]) + Abc_Word2Dbl(s->var_inc) * s->factors[v];
+		s->activity[v] = Abc_Dbl2Word(act);
+		if (act > 1e100)
+			act_var_rescale(s);
+		if (s->orderpos[v] != -1)
+			order_update(s, v);
+	} else if (s->VarActType == 2) {
+		s->activity[v] = Xdbl_Add(s->activity[v],
+		                          Xdbl_Mul(s->var_inc, Xdbl_FromDouble(s->factors[v])));
+		if (s->activity[v] > ABC_CONST(0x014c924d692ca61b))
+			act_var_rescale(s);
+		if (s->orderpos[v] != -1)
+			order_update(s, v);
+	} else
+		assert(0);
+}
+
+static inline void act_var_decay(sat_solver* s)
+{
+	if (s->VarActType == 0)
+		s->var_inc += (s->var_inc >> 4);
+	else if (s->VarActType == 1)
+		s->var_inc = Abc_Dbl2Word(Abc_Word2Dbl(s->var_inc) * Abc_Word2Dbl(s->var_decay));
+	else if (s->VarActType == 2)
+		s->var_inc = Xdbl_Mul(s->var_inc, s->var_decay);
+	else
+		assert(0);
+}
+
+// clause activities
+static inline void act_clause_rescale(sat_solver* s)
+{
+	if (s->ClaActType == 0) {
+		unsigned* activity = (unsigned*) veci_begin(&s->act_clas);
+		int i;
+		for (i = 0; i < veci_size(&s->act_clas); i++)
+			activity[i] >>= 14;
+		s->cla_inc >>= 14;
+		s->cla_inc = Abc_MaxInt(s->cla_inc, (1 << 10));
+	} else {
+		float* activity = (float*) veci_begin(&s->act_clas);
+		int i;
+		for (i = 0; i < veci_size(&s->act_clas); i++)
+			activity[i] *= (float) 1e-20;
+		s->cla_inc *= (float) 1e-20;
+	}
+}
+static inline void act_clause_bump(sat_solver* s, clause* c)
+{
+	if (s->ClaActType == 0) {
+		unsigned* act = (unsigned*) veci_begin(&s->act_clas) + c->lits[c->size];
+		*act += s->cla_inc;
+		if (*act & 0x80000000)
+			act_clause_rescale(s);
+	} else {
+		float* act = (float*) veci_begin(&s->act_clas) + c->lits[c->size];
+		*act += s->cla_inc;
+		if (*act > 1e20)
+			act_clause_rescale(s);
+	}
+}
+static inline void act_clause_decay(sat_solver* s)
+{
+	if (s->ClaActType == 0)
+		s->cla_inc += (s->cla_inc >> 10);
+	else
+		s->cla_inc *= s->cla_decay;
+}
+
+//=================================================================================================
+// Sorting functions (sigh):
+
+static inline void selectionsort(void** array, int size, int (*comp)(const void*, const void*))
+{
+	int i, j, best_i;
+	void* tmp;
+
+	for (i = 0; i < size - 1; i++) {
+		best_i = i;
+		for (j = i + 1; j < size; j++) {
+			if (comp(array[j], array[best_i]) < 0)
+				best_i = j;
+		}
+		tmp = array[i];
+		array[i] = array[best_i];
+		array[best_i] = tmp;
+	}
+}
+
+static inline void sortrnd(void** array, int size, int (*comp)(const void*, const void*), double* seed)
+{
+	if (size <= 15)
+		selectionsort(array, size, comp);
+
+	else {
+		void* pivot = array[irand(seed, size)];
+		void* tmp;
+		int i = -1;
+		int j = size;
+
+		for (;;) {
+			do
+				i++;
+			while (comp(array[i], pivot) < 0);
+			do
+				j--;
+			while (comp(pivot, array[j]) < 0);
+
+			if (i >= j)
+				break;
+
+			tmp = array[i];
+			array[i] = array[j];
+			array[j] = tmp;
+		}
+
+		sortrnd(array, i, comp, seed);
+		sortrnd(&array[i], size - i, comp, seed);
+	}
+}
+
+//=================================================================================================
+// Clause functions:
+
+static inline int sat_clause_compute_lbd(sat_solver* s, clause* c)
+{
+	int i, lev, minl = 0, lbd = 0;
+	for (i = 0; i < (int) c->size; i++) {
+		lev = var_level(s, lit_var(c->lits[i]));
+		if (!(minl & (1 << (lev & 31)))) {
+			minl |= 1 << (lev & 31);
+			lbd++;
+			//            printf( "%d ", lev );
+		}
+	}
+	//    printf( " -> %d\n", lbd );
+	return lbd;
+}
+
+/* pre: size > 1 && no variable occurs twice
+ */
+inline int sat_solver_clause_new(sat_solver* s, lit* begin, lit* end, int learnt)
+{
+	int fUseBinaryClauses = 1;
+	int size;
+	clause* c;
+	int h;
+
+	assert(end - begin > 1);
+	assert(learnt >= 0 && learnt < 2);
+	size = end - begin;
+
+	// do not allocate memory for the two-literal problem clause
+	if (fUseBinaryClauses && size == 2 && !learnt) {
+		veci_push(sat_solver_read_wlist(s, lit_neg(begin[0])), (clause_from_lit(begin[1])));
+		veci_push(sat_solver_read_wlist(s, lit_neg(begin[1])), (clause_from_lit(begin[0])));
+		s->stats.clauses++;
+		s->stats.clauses_literals += size;
+		return 0;
+	}
+
+	// create new clause
+	//    h = Vec_SetAppend( &s->Mem, NULL, size + learnt + 1 + 1 ) << 1;
+	h = Sat_MemAppend(&s->Mem, begin, size, learnt, 0);
+	assert(!(h & 1));
+	if (s->hLearnts == -1 && learnt)
+		s->hLearnts = h;
+	if (learnt) {
+		c = clause_read(s, h);
+		c->lbd = sat_clause_compute_lbd(s, c);
+		assert(clause_id(c) == veci_size(&s->act_clas));
+		//        veci_push(&s->learned, h);
+		//        act_clause_bump(s,clause_read(s, h));
+		if (s->ClaActType == 0)
+			veci_push(&s->act_clas, (1 << 10));
+		else
+			veci_push(&s->act_clas, s->cla_inc);
+		s->stats.learnts++;
+		s->stats.learnts_literals += size;
+	} else {
+		s->stats.clauses++;
+		s->stats.clauses_literals += size;
+	}
+
+	assert(begin[0] >= 0);
+	assert(begin[0] < s->size * 2);
+	assert(begin[1] >= 0);
+	assert(begin[1] < s->size * 2);
+
+	assert(lit_neg(begin[0]) < s->size * 2);
+	assert(lit_neg(begin[1]) < s->size * 2);
+
+	// veci_push(sat_solver_read_wlist(s,lit_neg(begin[0])),c);
+	// veci_push(sat_solver_read_wlist(s,lit_neg(begin[1])),c);
+	veci_push(sat_solver_read_wlist(s, lit_neg(begin[0])),
+	          (size > 2 ? h : clause_from_lit(begin[1])));
+	veci_push(sat_solver_read_wlist(s, lit_neg(begin[1])),
+	          (size > 2 ? h : clause_from_lit(begin[0])));
+
+	return h;
+}
+
+//=================================================================================================
+// Minor (solver) functions:
+
+static inline int sat_solver_enqueue(sat_solver* s, lit l, int from)
+{
+	int v = lit_var(l);
+	if (s->pFreqs[v] == 0)
+		//    {
+		s->pFreqs[v] = 1;
+		//        s->nVarUsed++;
+		//    }
+
+#ifdef VERBOSEDEBUG
+	printf(L_IND "enqueue(" L_LIT ")\n", L_ind, L_lit(l));
+#endif
+	if (var_value(s, v) != varX)
+		return var_value(s, v) == lit_sign(l);
+	else {
+		/*
+		        if ( s->pCnfFunc )
+		        {
+		            if ( lit_sign(l) )
+		            {
+		                if ( (s->loads[v] & 1) == 0 )
+		                {
+		                    s->loads[v] ^= 1;
+		                    s->pCnfFunc( s->pCnfMan, l );
+		                }
+		            }
+		            else
+		            {
+		                if ( (s->loads[v] & 2) == 0 )
+		                {
+		                    s->loads[v] ^= 2;
+		                    s->pCnfFunc( s->pCnfMan, l );
+		                }
+		            }
+		        }
+		*/
+		// New fact -- store it.
+#ifdef VERBOSEDEBUG
+		printf(L_IND "bind(" L_LIT ")\n", L_ind, L_lit(l));
+#endif
+		var_set_value(s, v, lit_sign(l));
+		var_set_level(s, v, sat_solver_dl(s));
+		s->reasons[v] = from;
+		s->trail[s->qtail++] = l;
+		order_assigned(s, v);
+		return true;
+	}
+}
+
+static inline int sat_solver_decision(sat_solver* s, lit l)
+{
+	assert(s->qtail == s->qhead);
+	assert(var_value(s, lit_var(l)) == varX);
+#ifdef VERBOSEDEBUG
+	printf(L_IND "assume(" L_LIT ")  ", L_ind, L_lit(l));
+	printf("act = %.20f\n", s->activity[lit_var(l)]);
+#endif
+	veci_push(&s->trail_lim, s->qtail);
+	return sat_solver_enqueue(s, l, 0);
+}
+
+static void sat_solver_canceluntil(sat_solver* s, int level)
+{
+	int bound;
+	int lastLev;
+	int c;
+
+	if (sat_solver_dl(s) <= level)
+		return;
+
+	assert(veci_size(&s->trail_lim) > 0);
+	bound = (veci_begin(&s->trail_lim))[level];
+	lastLev = (veci_begin(&s->trail_lim))[veci_size(&s->trail_lim) - 1];
+
+	////////////////////////////////////////
+	// added to cancel all assignments
+	//    if ( level == -1 )
+	//        bound = 0;
+	////////////////////////////////////////
+
+	for (c = s->qtail - 1; c >= bound; c--) {
+		int x = lit_var(s->trail[c]);
+		var_set_value(s, x, varX);
+		s->reasons[x] = 0;
+		if (c < lastLev)
+			var_set_polar(s, x, !lit_sign(s->trail[c]));
+	}
+	// printf( "\n" );
+
+	for (c = s->qhead - 1; c >= bound; c--)
+		order_unassigned(s, lit_var(s->trail[c]));
+
+	s->qhead = s->qtail = bound;
+	veci_resize(&s->trail_lim, level);
+}
+
+static void sat_solver_canceluntil_rollback(sat_solver* s, int NewBound)
+{
+	int c, x;
+
+	assert(sat_solver_dl(s) == 0);
+	assert(s->qtail == s->qhead);
+	assert(s->qtail >= NewBound);
+
+	for (c = s->qtail - 1; c >= NewBound; c--) {
+		x = lit_var(s->trail[c]);
+		var_set_value(s, x, varX);
+		s->reasons[x] = 0;
+	}
+
+	for (c = s->qhead - 1; c >= NewBound; c--)
+		order_unassigned(s, lit_var(s->trail[c]));
+
+	s->qhead = s->qtail = NewBound;
+}
+
+static void sat_solver_record(sat_solver* s, veci* cls)
+{
+	lit* begin = veci_begin(cls);
+	lit* end = begin + veci_size(cls);
+	int h = (veci_size(cls) > 1) ? sat_solver_clause_new(s, begin, end, 1) : 0;
+	sat_solver_enqueue(s, *begin, h);
+	assert(veci_size(cls) > 0);
+	if (h == 0)
+		veci_push(&s->unit_lits, *begin);
+
+	///////////////////////////////////
+	// add clause to internal storage
+	if (s->pStore) {
+		int RetValue = Sto_ManAddClause((Sto_Man_t*) s->pStore, begin, end);
+		assert(RetValue);
+		(void) RetValue;
+	}
+	///////////////////////////////////
+	/*
+	    if (h != 0) {
+	        act_clause_bump(s,clause_read(s, h));
+	        s->stats.learnts++;
+	        s->stats.learnts_literals += veci_size(cls);
+	    }
+	*/
+}
+
+inline int sat_solver_count_assigned(sat_solver* s)
+{
+	// count top-level assignments
+	int i, Count = 0;
+	assert(sat_solver_dl(s) == 0);
+	for (i = 0; i < s->size; i++)
+		if (var_value(s, i) != varX)
+			Count++;
+	return Count;
+}
+
+static double sat_solver_progress(sat_solver* s)
+{
+	int i;
+	double progress = 0;
+	double F = 1.0 / s->size;
+	for (i = 0; i < s->size; i++)
+		if (var_value(s, i) != varX)
+			progress += pow(F, var_level(s, i));
+	return progress / s->size;
+}
+
+//=================================================================================================
+// Major methods:
+
+static int sat_solver_lit_removable(sat_solver* s, int x, int minl)
+{
+	int top = veci_size(&s->tagged);
+
+	assert(s->reasons[x] != 0);
+	veci_resize(&s->stack, 0);
+	veci_push(&s->stack, x);
+
+	while (veci_size(&s->stack)) {
+		int v = veci_pop(&s->stack);
+		assert(s->reasons[v] != 0);
+		if (clause_is_lit(s->reasons[v])) {
+			v = lit_var(clause_read_lit(s->reasons[v]));
+			if (!var_tag(s, v) && var_level(s, v)) {
+				if (s->reasons[v] != 0 && ((1 << (var_level(s, v) & 31)) & minl)) {
+					veci_push(&s->stack, v);
+					var_set_tag(s, v, 1);
+				} else {
+					solver2_clear_tags(s, top);
+					return 0;
+				}
+			}
+		} else {
+			clause* c = clause_read(s, s->reasons[v]);
+			lit* lits = clause_begin(c);
+			int i;
+			for (i = 1; i < clause_size(c); i++) {
+				int v = lit_var(lits[i]);
+				if (!var_tag(s, v) && var_level(s, v)) {
+					if (s->reasons[v] != 0
+					    && ((1 << (var_level(s, v) & 31)) & minl)) {
+						veci_push(&s->stack, lit_var(lits[i]));
+						var_set_tag(s, v, 1);
+					} else {
+						solver2_clear_tags(s, top);
+						return 0;
+					}
+				}
+			}
+		}
+	}
+	return 1;
+}
+
+/*_________________________________________________________________________________________________
+|
+|  analyzeFinal : (p : Lit)  ->  [void]
+|
+|  Description:
+|    Specialized analysis procedure to express the final conflict in terms of assumptions.
+|    Calculates the (possibly empty) set of assumptions that led to the assignment of 'p', and
+|    stores the result in 'out_conflict'.
+|________________________________________________________________________________________________@*/
+/*
+void Solver::analyzeFinal(Clause* confl, bool skip_first)
+{
+    // -- NOTE! This code is relatively untested. Please report bugs!
+    conflict.clear();
+    if (root_level == 0) return;
+
+    vec<char>& seen  = analyze_seen;
+    for (int i = skip_first ? 1 : 0; i < confl->size(); i++){
+        Var x = var((*confl)[i]);
+        if (level[x] > 0)
+            seen[x] = 1;
+    }
+
+    int start = (root_level >= trail_lim.size()) ? trail.size()-1 : trail_lim[root_level];
+    for (int i = start; i >= trail_lim[0]; i--){
+        Var     x = var(trail[i]);
+        if (seen[x]){
+            GClause r = reason[x];
+            if (r == GClause_NULL){
+                assert(level[x] > 0);
+                conflict.push(~trail[i]);
+            }else{
+                if (r.isLit()){
+                    Lit p = r.lit();
+                    if (level[var(p)] > 0)
+                        seen[var(p)] = 1;
+                }else{
+                    Clause& c = *r.clause();
+                    for (int j = 1; j < c.size(); j++)
+                        if (level[var(c[j])] > 0)
+                            seen[var(c[j])] = 1;
+                }
+            }
+            seen[x] = 0;
+        }
+    }
+}
+*/
+
+#ifdef SAT_USE_ANALYZE_FINAL
+
+static void sat_solver_analyze_final(sat_solver* s, int hConf, int skip_first)
+{
+	clause* conf = clause_read(s, hConf);
+	int i, j, start;
+	veci_resize(&s->conf_final, 0);
+	if (s->root_level == 0)
+		return;
+	assert(veci_size(&s->tagged) == 0);
+	//    assert( s->tags[lit_var(p)] == l_Undef );
+	//    s->tags[lit_var(p)] = l_True;
+	for (i = skip_first ? 1 : 0; i < clause_size(conf); i++) {
+		int x = lit_var(clause_begin(conf)[i]);
+		if (var_level(s, x) > 0)
+			var_set_tag(s, x, 1);
+	}
+
+	start = (s->root_level >= veci_size(&s->trail_lim)) ?
+	            s->qtail - 1 :
+	            (veci_begin(&s->trail_lim))[s->root_level];
+	for (i = start; i >= (veci_begin(&s->trail_lim))[0]; i--) {
+		int x = lit_var(s->trail[i]);
+		if (var_tag(s, x)) {
+			if (s->reasons[x] == 0) {
+				assert(var_level(s, x) > 0);
+				veci_push(&s->conf_final, lit_neg(s->trail[i]));
+			} else {
+				if (clause_is_lit(s->reasons[x])) {
+					lit q = clause_read_lit(s->reasons[x]);
+					assert(lit_var(q) >= 0 && lit_var(q) < s->size);
+					if (var_level(s, lit_var(q)) > 0)
+						var_set_tag(s, lit_var(q), 1);
+				} else {
+					clause* c = clause_read(s, s->reasons[x]);
+					int* lits = clause_begin(c);
+					for (j = 1; j < clause_size(c); j++)
+						if (var_level(s, lit_var(lits[j])) > 0)
+							var_set_tag(s, lit_var(lits[j]), 1);
+				}
+			}
+		}
+	}
+	solver2_clear_tags(s, 0);
+}
+
+#endif
+
+static void sat_solver_analyze(sat_solver* s, int h, veci* learnt)
+{
+	lit* trail = s->trail;
+	int cnt = 0;
+	lit p = lit_Undef;
+	int ind = s->qtail - 1;
+	lit* lits;
+	int i, j, minl;
+	veci_push(learnt, lit_Undef);
+	do {
+		assert(h != 0);
+		if (clause_is_lit(h)) {
+			int x = lit_var(clause_read_lit(h));
+			if (var_tag(s, x) == 0 && var_level(s, x) > 0) {
+				var_set_tag(s, x, 1);
+				act_var_bump(s, x);
+				if (var_level(s, x) == sat_solver_dl(s))
+					cnt++;
+				else
+					veci_push(learnt, clause_read_lit(h));
+			}
+		} else {
+			clause* c = clause_read(s, h);
+
+			if (clause_learnt(c))
+				act_clause_bump(s, c);
+			lits = clause_begin(c);
+			// printlits(lits,lits+clause_size(c)); printf("\n");
+			for (j = (p == lit_Undef ? 0 : 1); j < clause_size(c); j++) {
+				int x = lit_var(lits[j]);
+				if (var_tag(s, x) == 0 && var_level(s, x) > 0) {
+					var_set_tag(s, x, 1);
+					act_var_bump(s, x);
+					// bump variables propaged by the LBD=2 clause
+					//                    if ( s->reasons[x] && clause_read(s,
+					//                    s->reasons[x])->lbd <= 2 )
+					//                        act_var_bump(s,x);
+					if (var_level(s, x) == sat_solver_dl(s))
+						cnt++;
+					else
+						veci_push(learnt, lits[j]);
+				}
+			}
+		}
+
+		while (!var_tag(s, lit_var(trail[ind--])))
+			;
+
+		p = trail[ind + 1];
+		h = s->reasons[lit_var(p)];
+		cnt--;
+
+	} while (cnt > 0);
+
+	*veci_begin(learnt) = lit_neg(p);
+
+	lits = veci_begin(learnt);
+	minl = 0;
+	for (i = 1; i < veci_size(learnt); i++) {
+		int lev = var_level(s, lit_var(lits[i]));
+		minl |= 1 << (lev & 31);
+	}
+
+	// simplify (full)
+	for (i = j = 1; i < veci_size(learnt); i++) {
+		if (s->reasons[lit_var(lits[i])] == 0
+		    || !sat_solver_lit_removable(s, lit_var(lits[i]), minl))
+			lits[j++] = lits[i];
+	}
+
+	// update size of learnt + statistics
+	veci_resize(learnt, j);
+	s->stats.tot_literals += j;
+
+	// clear tags
+	solver2_clear_tags(s, 0);
+
+#ifdef DEBUG
+	for (i = 0; i < s->size; i++)
+		assert(!var_tag(s, i));
+#endif
+
+#ifdef VERBOSEDEBUG
+	printf(L_IND "Learnt {", L_ind);
+	for (i = 0; i < veci_size(learnt); i++)
+		printf(" " L_LIT, L_lit(lits[i]));
+#endif
+	if (veci_size(learnt) > 1) {
+		int max_i = 1;
+		int max = var_level(s, lit_var(lits[1]));
+		lit tmp;
+
+		for (i = 2; i < veci_size(learnt); i++)
+			if (var_level(s, lit_var(lits[i])) > max) {
+				max = var_level(s, lit_var(lits[i]));
+				max_i = i;
+			}
+
+		tmp = lits[1];
+		lits[1] = lits[max_i];
+		lits[max_i] = tmp;
+	}
+#ifdef VERBOSEDEBUG
+	{
+		int lev = veci_size(learnt) > 1 ? var_level(s, lit_var(lits[1])) : 0;
+		printf(" } at level %d\n", lev);
+	}
+#endif
+}
+
+//#define TEST_CNF_LOAD
+
+inline int sat_solver_propagate(sat_solver* s)
+{
+	int hConfl = 0;
+	lit* lits;
+	lit false_lit;
+
+	// printf("sat_solver_propagate\n");
+	while (hConfl == 0 && s->qtail - s->qhead > 0) {
+		lit p = s->trail[s->qhead++];
+
+#ifdef TEST_CNF_LOAD
+		int v = lit_var(p);
+		if (s->pCnfFunc) {
+			if (lit_sign(p)) {
+				if ((s->loads[v] & 1) == 0) {
+					s->loads[v] ^= 1;
+					s->pCnfFunc(s->pCnfMan, p);
+				}
+			} else {
+				if ((s->loads[v] & 2) == 0) {
+					s->loads[v] ^= 2;
+					s->pCnfFunc(s->pCnfMan, p);
+				}
+			}
+		}
+		{
+#endif
+
+			veci* ws = sat_solver_read_wlist(s, p);
+			int* begin = veci_begin(ws);
+			int* end = begin + veci_size(ws);
+			int *i, *j;
+
+			s->stats.propagations++;
+			//        s->simpdb_props--;
+
+			// printf("checking lit %d: "L_LIT"\n", veci_size(ws), L_lit(p));
+			for (i = j = begin; i < end;) {
+				if (clause_is_lit(*i)) {
+
+					int Lit = clause_read_lit(*i);
+					if (var_value(s, lit_var(Lit)) == lit_sign(Lit)) {
+						*j++ = *i++;
+						continue;
+					}
+
+					*j++ = *i;
+					if (!sat_solver_enqueue(s, clause_read_lit(*i),
+					                        clause_from_lit(p))) {
+						hConfl = s->hBinary;
+						(clause_begin(s->binary))[1] = lit_neg(p);
+						(clause_begin(s->binary))[0] = clause_read_lit(*i++);
+						// Copy the remaining watches:
+						while (i < end)
+							*j++ = *i++;
+					}
+				} else {
+
+					clause* c = clause_read(s, *i);
+					lits = clause_begin(c);
+
+					// Make sure the false literal is data[1]:
+					false_lit = lit_neg(p);
+					if (lits[0] == false_lit) {
+						lits[0] = lits[1];
+						lits[1] = false_lit;
+					}
+					assert(lits[1] == false_lit);
+
+					// If 0th watch is true, then clause is already satisfied.
+					if (var_value(s, lit_var(lits[0])) == lit_sign(lits[0]))
+						*j++ = *i;
+					else {
+						// Look for new watch:
+						lit* stop = lits + clause_size(c);
+						lit* k;
+						for (k = lits + 2; k < stop; k++) {
+							if (var_value(s, lit_var(*k))
+							    != !lit_sign(*k)) {
+								lits[1] = *k;
+								*k = false_lit;
+								veci_push(sat_solver_read_wlist(
+								              s, lit_neg(lits[1])),
+								          *i);
+								goto next;
+							}
+						}
+
+						*j++ = *i;
+						// Clause is unit under assignment:
+						if (c->lrn)
+							c->lbd = sat_clause_compute_lbd(s, c);
+						if (!sat_solver_enqueue(s, lits[0], *i)) {
+							hConfl = *i++;
+							// Copy the remaining watches:
+							while (i < end)
+								*j++ = *i++;
+						}
+					}
+				}
+			next:
+				i++;
+			}
+
+			s->stats.inspects += j - veci_begin(ws);
+			veci_resize(ws, j - veci_begin(ws));
+#ifdef TEST_CNF_LOAD
+		}
+#endif
+	}
+
+	return hConfl;
+}
+
+//=================================================================================================
+// External solver functions:
+
+inline sat_solver* sat_solver_new(void)
+{
+	sat_solver* s = (sat_solver*) ABC_CALLOC(char, sizeof(sat_solver));
+
+	//    Vec_SetAlloc_(&s->Mem, 15);
+	Sat_MemAlloc_(&s->Mem, 17);
+	s->hLearnts = -1;
+	s->hBinary = Sat_MemAppend(&s->Mem, NULL, 2, 0, 0);
+	s->binary = clause_read(s, s->hBinary);
+
+	s->nLearntStart = LEARNT_MAX_START_DEFAULT; // starting learned clause limit
+	s->nLearntDelta = LEARNT_MAX_INCRE_DEFAULT; // delta of learned clause limit
+	s->nLearntRatio = LEARNT_MAX_RATIO_DEFAULT; // ratio of learned clause limit
+	s->nLearntMax = s->nLearntStart;
+
+	// initialize vectors
+	veci_new(&s->order);
+	veci_new(&s->trail_lim);
+	veci_new(&s->tagged);
+	//    veci_new(&s->learned);
+	veci_new(&s->act_clas);
+	veci_new(&s->stack);
+	//    veci_new(&s->model);
+	veci_new(&s->unit_lits);
+	veci_new(&s->temp_clause);
+	veci_new(&s->conf_final);
+
+	// initialize arrays
+	s->wlists = 0;
+	s->activity = 0;
+	s->orderpos = 0;
+	s->reasons = 0;
+	s->trail = 0;
+
+	// initialize other vars
+	s->size = 0;
+	s->cap = 0;
+	s->qhead = 0;
+	s->qtail = 0;
+
+	solver_init_activities(s);
+	veci_new(&s->act_vars);
+
+	s->root_level = 0;
+	//    s->simpdb_assigns         = 0;
+	//    s->simpdb_props           = 0;
+	s->progress_estimate = 0;
+	//    s->binary                 = (clause*)ABC_ALLOC( char, sizeof(clause) + sizeof(lit)*2);
+	//    s->binary->size_learnt    = (2 << 1);
+	s->verbosity = 0;
+
+	s->stats.starts = 0;
+	s->stats.decisions = 0;
+	s->stats.propagations = 0;
+	s->stats.inspects = 0;
+	s->stats.conflicts = 0;
+	s->stats.clauses = 0;
+	s->stats.clauses_literals = 0;
+	s->stats.learnts = 0;
+	s->stats.learnts_literals = 0;
+	s->stats.tot_literals = 0;
+	return s;
+}
+
+inline sat_solver* zsat_solver_new_seed(double seed)
+{
+	sat_solver* s = (sat_solver*) ABC_CALLOC(char, sizeof(sat_solver));
+
+	//    Vec_SetAlloc_(&s->Mem, 15);
+	Sat_MemAlloc_(&s->Mem, 15);
+	s->hLearnts = -1;
+	s->hBinary = Sat_MemAppend(&s->Mem, NULL, 2, 0, 0);
+	s->binary = clause_read(s, s->hBinary);
+
+	s->nLearntStart = LEARNT_MAX_START_DEFAULT; // starting learned clause limit
+	s->nLearntDelta = LEARNT_MAX_INCRE_DEFAULT; // delta of learned clause limit
+	s->nLearntRatio = LEARNT_MAX_RATIO_DEFAULT; // ratio of learned clause limit
+	s->nLearntMax = s->nLearntStart;
+
+	// initialize vectors
+	veci_new(&s->order);
+	veci_new(&s->trail_lim);
+	veci_new(&s->tagged);
+	//    veci_new(&s->learned);
+	veci_new(&s->act_clas);
+	veci_new(&s->stack);
+	//    veci_new(&s->model);
+	veci_new(&s->unit_lits);
+	veci_new(&s->temp_clause);
+	veci_new(&s->conf_final);
+
+	// initialize arrays
+	s->wlists = 0;
+	s->activity = 0;
+	s->orderpos = 0;
+	s->reasons = 0;
+	s->trail = 0;
+
+	// initialize other vars
+	s->size = 0;
+	s->cap = 0;
+	s->qhead = 0;
+	s->qtail = 0;
+
+	solver_init_activities(s);
+	veci_new(&s->act_vars);
+
+	s->root_level = 0;
+	//    s->simpdb_assigns         = 0;
+	//    s->simpdb_props           = 0;
+	s->random_seed = seed;
+	s->progress_estimate = 0;
+	//    s->binary                 = (clause*)ABC_ALLOC( char, sizeof(clause) + sizeof(lit)*2);
+	//    s->binary->size_learnt    = (2 << 1);
+	s->verbosity = 0;
+
+	s->stats.starts = 0;
+	s->stats.decisions = 0;
+	s->stats.propagations = 0;
+	s->stats.inspects = 0;
+	s->stats.conflicts = 0;
+	s->stats.clauses = 0;
+	s->stats.clauses_literals = 0;
+	s->stats.learnts = 0;
+	s->stats.learnts_literals = 0;
+	s->stats.tot_literals = 0;
+	return s;
+}
+
+inline int sat_solver_addvar(sat_solver* s)
+{
+	sat_solver_setnvars(s, s->size + 1);
+	return s->size - 1;
+}
+inline void sat_solver_setnvars(sat_solver* s, int n)
+{
+	int var;
+
+	if (s->cap < n) {
+		int old_cap = s->cap;
+		while (s->cap < n)
+			s->cap = s->cap * 2 + 1;
+		if (s->cap < 50000)
+			s->cap = 50000;
+
+		s->wlists = ABC_REALLOC(veci, s->wlists, s->cap * 2);
+		//        s->vi        = ABC_REALLOC(varinfo,s->vi,       s->cap);
+		s->levels = ABC_REALLOC(int, s->levels, s->cap);
+		s->assigns = ABC_REALLOC(char, s->assigns, s->cap);
+		s->polarity = ABC_REALLOC(char, s->polarity, s->cap);
+		s->tags = ABC_REALLOC(char, s->tags, s->cap);
+		s->loads = ABC_REALLOC(char, s->loads, s->cap);
+		s->activity = ABC_REALLOC(word, s->activity, s->cap);
+		s->activity2 = ABC_REALLOC(word, s->activity2, s->cap);
+		s->pFreqs = ABC_REALLOC(char, s->pFreqs, s->cap);
+
+		if (s->factors)
+			s->factors = ABC_REALLOC(double, s->factors, s->cap);
+		s->orderpos = ABC_REALLOC(int, s->orderpos, s->cap);
+		s->reasons = ABC_REALLOC(int, s->reasons, s->cap);
+		s->trail = ABC_REALLOC(lit, s->trail, s->cap);
+		s->model = ABC_REALLOC(int, s->model, s->cap);
+		memset(s->wlists + 2 * old_cap, 0, 2 * (s->cap - old_cap) * sizeof(veci));
+	}
+
+	for (var = s->size; var < n; var++) {
+		assert(!s->wlists[2 * var].size);
+		assert(!s->wlists[2 * var + 1].size);
+		if (s->wlists[2 * var].ptr == NULL)
+			veci_new(&s->wlists[2 * var]);
+		if (s->wlists[2 * var + 1].ptr == NULL)
+			veci_new(&s->wlists[2 * var + 1]);
+
+		if (s->VarActType == 0)
+			s->activity[var] = (1 << 10);
+		else if (s->VarActType == 1)
+			s->activity[var] = 0;
+		else if (s->VarActType == 2)
+			s->activity[var] = 0;
+		else
+			assert(0);
+
+		s->pFreqs[var] = 0;
+		if (s->factors)
+			s->factors[var] = 0;
+		//        *((int*)s->vi + var) = 0; s->vi[var].val = varX;
+		s->levels[var] = 0;
+		s->assigns[var] = varX;
+		s->polarity[var] = 0;
+		s->tags[var] = 0;
+		s->loads[var] = 0;
+		s->orderpos[var] = veci_size(&s->order);
+		s->reasons[var] = 0;
+		s->model[var] = 0;
+
+		/* does not hold because variables enqueued at top level will not be reinserted in
+		   the heap assert(veci_size(&s->order) == var);
+		 */
+		veci_push(&s->order, var);
+		order_update(s, var);
+	}
+
+	s->size = n > s->size ? n : s->size;
+}
+
+inline void sat_solver_delete(sat_solver* s)
+{
+	//    Vec_SetFree_( &s->Mem );
+	Sat_MemFree_(&s->Mem);
+
+	// delete vectors
+	veci_delete(&s->order);
+	veci_delete(&s->trail_lim);
+	veci_delete(&s->tagged);
+	//    veci_delete(&s->learned);
+	veci_delete(&s->act_clas);
+	veci_delete(&s->stack);
+	//    veci_delete(&s->model);
+	veci_delete(&s->act_vars);
+	veci_delete(&s->unit_lits);
+	veci_delete(&s->pivot_vars);
+	veci_delete(&s->temp_clause);
+	veci_delete(&s->conf_final);
+
+	veci_delete(&s->user_vars);
+	veci_delete(&s->user_values);
+
+	// delete arrays
+	if (s->reasons != 0) {
+		int i;
+		for (i = 0; i < s->cap * 2; i++)
+			veci_delete(&s->wlists[i]);
+		ABC_FREE(s->wlists);
+		//        ABC_FREE(s->vi       );
+		ABC_FREE(s->levels);
+		ABC_FREE(s->assigns);
+		ABC_FREE(s->polarity);
+		ABC_FREE(s->tags);
+		ABC_FREE(s->loads);
+		ABC_FREE(s->activity);
+		ABC_FREE(s->activity2);
+		ABC_FREE(s->pFreqs);
+		ABC_FREE(s->factors);
+		ABC_FREE(s->orderpos);
+		ABC_FREE(s->reasons);
+		ABC_FREE(s->trail);
+		ABC_FREE(s->model);
+	}
+
+	sat_solver_store_free(s);
+	ABC_FREE(s);
+}
+
+inline void sat_solver_restart(sat_solver* s)
+{
+	int i;
+	Sat_MemRestart(&s->Mem);
+	s->hLearnts = -1;
+	s->hBinary = Sat_MemAppend(&s->Mem, NULL, 2, 0, 0);
+	s->binary = clause_read(s, s->hBinary);
+
+	veci_resize(&s->trail_lim, 0);
+	veci_resize(&s->order, 0);
+	for (i = 0; i < s->size * 2; i++)
+		s->wlists[i].size = 0;
+
+	s->nDBreduces = 0;
+
+	// initialize other vars
+	s->size = 0;
+	//    s->cap                    = 0;
+	s->qhead = 0;
+	s->qtail = 0;
+
+	// variable activities
+	solver_init_activities(s);
+	veci_resize(&s->act_clas, 0);
+
+	s->root_level = 0;
+	//    s->simpdb_assigns         = 0;
+	//    s->simpdb_props           = 0;
+	s->progress_estimate = 0;
+	s->verbosity = 0;
+
+	s->stats.starts = 0;
+	s->stats.decisions = 0;
+	s->stats.propagations = 0;
+	s->stats.inspects = 0;
+	s->stats.conflicts = 0;
+	s->stats.clauses = 0;
+	s->stats.clauses_literals = 0;
+	s->stats.learnts = 0;
+	s->stats.learnts_literals = 0;
+	s->stats.tot_literals = 0;
+}
+
+inline void zsat_solver_restart_seed(sat_solver* s, double seed)
+{
+	int i;
+	Sat_MemRestart(&s->Mem);
+	s->hLearnts = -1;
+	s->hBinary = Sat_MemAppend(&s->Mem, NULL, 2, 0, 0);
+	s->binary = clause_read(s, s->hBinary);
+
+	veci_resize(&s->trail_lim, 0);
+	veci_resize(&s->order, 0);
+	for (i = 0; i < s->size * 2; i++)
+		s->wlists[i].size = 0;
+
+	s->nDBreduces = 0;
+
+	// initialize other vars
+	s->size = 0;
+	//    s->cap                    = 0;
+	s->qhead = 0;
+	s->qtail = 0;
+
+	solver_init_activities(s);
+	veci_resize(&s->act_clas, 0);
+
+	s->root_level = 0;
+	//    s->simpdb_assigns         = 0;
+	//    s->simpdb_props           = 0;
+	s->random_seed = seed;
+	s->progress_estimate = 0;
+	s->verbosity = 0;
+
+	s->stats.starts = 0;
+	s->stats.decisions = 0;
+	s->stats.propagations = 0;
+	s->stats.inspects = 0;
+	s->stats.conflicts = 0;
+	s->stats.clauses = 0;
+	s->stats.clauses_literals = 0;
+	s->stats.learnts = 0;
+	s->stats.learnts_literals = 0;
+	s->stats.tot_literals = 0;
+}
+
+// returns memory in bytes used by the SAT solver
+inline double sat_solver_memory(sat_solver* s)
+{
+	int i;
+	double Mem = sizeof(sat_solver);
+	for (i = 0; i < s->cap * 2; i++)
+		Mem += s->wlists[i].cap * sizeof(int);
+	Mem += s->cap * sizeof(veci); // ABC_FREE(s->wlists   );
+	Mem += s->cap * sizeof(int);  // ABC_FREE(s->levels   );
+	Mem += s->cap * sizeof(char); // ABC_FREE(s->assigns  );
+	Mem += s->cap * sizeof(char); // ABC_FREE(s->polarity );
+	Mem += s->cap * sizeof(char); // ABC_FREE(s->tags     );
+	Mem += s->cap * sizeof(char); // ABC_FREE(s->loads    );
+	Mem += s->cap * sizeof(word); // ABC_FREE(s->activity );
+	if (s->activity2)
+		Mem += s->cap * sizeof(word); // ABC_FREE(s->activity );
+	if (s->factors)
+		Mem += s->cap * sizeof(double); // ABC_FREE(s->factors  );
+	Mem += s->cap * sizeof(int);            // ABC_FREE(s->orderpos );
+	Mem += s->cap * sizeof(int);            // ABC_FREE(s->reasons  );
+	Mem += s->cap * sizeof(lit);            // ABC_FREE(s->trail    );
+	Mem += s->cap * sizeof(int);            // ABC_FREE(s->model    );
+
+	Mem += s->order.cap * sizeof(int);
+	Mem += s->trail_lim.cap * sizeof(int);
+	Mem += s->tagged.cap * sizeof(int);
+	//    Mem += s->learned.cap * sizeof(int);
+	Mem += s->stack.cap * sizeof(int);
+	Mem += s->act_vars.cap * sizeof(int);
+	Mem += s->unit_lits.cap * sizeof(int);
+	Mem += s->act_clas.cap * sizeof(int);
+	Mem += s->temp_clause.cap * sizeof(int);
+	Mem += s->conf_final.cap * sizeof(int);
+	Mem += Sat_MemMemoryAll(&s->Mem);
+	return Mem;
+}
+
+inline int sat_solver_simplify(sat_solver* s)
+{
+	assert(sat_solver_dl(s) == 0);
+	if (sat_solver_propagate(s) != 0)
+		return false;
+	return true;
+}
+
+inline void sat_solver_reducedb(sat_solver* s)
+{
+	static abctime TimeTotal = 0;
+	abctime clk = Abc_Clock();
+	Sat_Mem_t* pMem = &s->Mem;
+	int nLearnedOld = veci_size(&s->act_clas);
+	int* act_clas = veci_begin(&s->act_clas);
+	int *pPerm, *pArray, *pSortValues, nCutoffValue;
+	int i, k, j, Id, Counter, CounterStart, nSelected;
+	clause* c;
+
+	assert(s->nLearntMax > 0);
+	assert(nLearnedOld == Sat_MemEntryNum(pMem, 1));
+	assert(nLearnedOld == (int) s->stats.learnts);
+
+	s->nDBreduces++;
+
+	// printf( "Calling reduceDB with %d learned clause limit.\n", s->nLearntMax );
+	s->nLearntMax = s->nLearntStart + s->nLearntDelta * s->nDBreduces;
+	//    return;
+
+	// create sorting values
+	pSortValues = ABC_ALLOC(int, nLearnedOld);
+	Sat_MemForEachLearned(pMem, c, i, k)
+	{
+		Id = clause_id(c);
+		//        pSortValues[Id] = act[Id];
+		if (s->ClaActType == 0)
+			pSortValues[Id] = ((7 - Abc_MinInt(c->lbd, 7)) << 28) | (act_clas[Id] >> 4);
+		else
+			pSortValues[Id] = ((7 - Abc_MinInt(c->lbd, 7))
+			                   << 28); // | (act_clas[Id] >> 4);
+		assert(pSortValues[Id] >= 0);
+	}
+
+	// preserve 1/20 of last clauses
+	CounterStart = nLearnedOld - (s->nLearntMax / 20);
+
+	// preserve 3/4 of most active clauses
+	nSelected = nLearnedOld * s->nLearntRatio / 100;
+
+	// find non-decreasing permutation
+	pPerm = Abc_MergeSortCost(pSortValues, nLearnedOld);
+	assert(pSortValues[pPerm[0]] <= pSortValues[pPerm[nLearnedOld - 1]]);
+	nCutoffValue = pSortValues[pPerm[nLearnedOld - nSelected]];
+	ABC_FREE(pPerm);
+	//    ActCutOff = ABC_INFINITY;
+
+	// mark learned clauses to remove
+	Counter = j = 0;
+	Sat_MemForEachLearned(pMem, c, i, k)
+	{
+		assert(c->mark == 0);
+		if (Counter++ > CounterStart || clause_size(c) < 3
+		    || pSortValues[clause_id(c)] > nCutoffValue
+		    || s->reasons[lit_var(c->lits[0])] == Sat_MemHand(pMem, i, k))
+			act_clas[j++] = act_clas[clause_id(c)];
+		else // delete
+		{
+			c->mark = 1;
+			s->stats.learnts_literals -= clause_size(c);
+			s->stats.learnts--;
+		}
+	}
+	assert(s->stats.learnts == (unsigned) j);
+	assert(Counter == nLearnedOld);
+	veci_resize(&s->act_clas, j);
+	ABC_FREE(pSortValues);
+
+	// update ID of each clause to be its new handle
+	Counter = Sat_MemCompactLearned(pMem, 0);
+	assert(Counter == (int) s->stats.learnts);
+
+	// update reasons
+	for (i = 0; i < s->size; i++) {
+		if (!s->reasons[i]) // no reason
+			continue;
+		if (clause_is_lit(s->reasons[i])) // 2-lit clause
+			continue;
+		if (!clause_learnt_h(pMem, s->reasons[i])) // problem clause
+			continue;
+		c = clause_read(s, s->reasons[i]);
+		assert(c->mark == 0);
+		s->reasons[i] = clause_id(c); // updating handle here!!!
+	}
+
+	// update watches
+	for (i = 0; i < s->size * 2; i++) {
+		pArray = veci_begin(&s->wlists[i]);
+		for (j = k = 0; k < veci_size(&s->wlists[i]); k++) {
+			if (clause_is_lit(pArray[k])) // 2-lit clause
+				pArray[j++] = pArray[k];
+			else if (!clause_learnt_h(pMem, pArray[k])) // problem clause
+				pArray[j++] = pArray[k];
+			else {
+				c = clause_read(s, pArray[k]);
+				if (!c->mark)                       // useful learned clause
+					pArray[j++] = clause_id(c); // updating handle here!!!
+			}
+		}
+		veci_resize(&s->wlists[i], j);
+	}
+
+	// perform final move of the clauses
+	Counter = Sat_MemCompactLearned(pMem, 1);
+	assert(Counter == (int) s->stats.learnts);
+
+	// report the results
+	TimeTotal += Abc_Clock() - clk;
+}
+
+// reverses to the previously bookmarked point
+inline void sat_solver_rollback(sat_solver* s)
+{
+	Sat_Mem_t* pMem = &s->Mem;
+	int i, k, j;
+	static int Count = 0;
+	Count++;
+	assert(s->iVarPivot >= 0 && s->iVarPivot <= s->size);
+	assert(s->iTrailPivot >= 0 && s->iTrailPivot <= s->qtail);
+	// reset implication queue
+	sat_solver_canceluntil_rollback(s, s->iTrailPivot);
+	// update order
+	if (s->iVarPivot < s->size) {
+		if (s->activity2) {
+			s->var_inc = s->var_inc2;
+			memcpy(s->activity, s->activity2, sizeof(word) * s->iVarPivot);
+		}
+		veci_resize(&s->order, 0);
+		for (i = 0; i < s->iVarPivot; i++) {
+			if (var_value(s, i) != varX)
+				continue;
+			s->orderpos[i] = veci_size(&s->order);
+			veci_push(&s->order, i);
+			order_update(s, i);
+		}
+	}
+	// compact watches
+	for (i = 0; i < s->iVarPivot * 2; i++) {
+		cla* pArray = veci_begin(&s->wlists[i]);
+		for (j = k = 0; k < veci_size(&s->wlists[i]); k++) {
+			if (clause_is_lit(pArray[k])) {
+				if (clause_read_lit(pArray[k]) < s->iVarPivot * 2)
+					pArray[j++] = pArray[k];
+			} else if (Sat_MemClauseUsed(pMem, pArray[k]))
+				pArray[j++] = pArray[k];
+		}
+		veci_resize(&s->wlists[i], j);
+	}
+	// reset watcher lists
+	for (i = 2 * s->iVarPivot; i < 2 * s->size; i++)
+		s->wlists[i].size = 0;
+
+	// reset clause counts
+	s->stats.clauses = pMem->BookMarkE[0];
+	s->stats.learnts = pMem->BookMarkE[1];
+	// rollback clauses
+	Sat_MemRollBack(pMem);
+
+	// resize learned arrays
+	veci_resize(&s->act_clas, s->stats.learnts);
+
+	// initialize other vars
+	s->size = s->iVarPivot;
+	if (s->size == 0) {
+		//    s->size                   = 0;
+		//    s->cap                    = 0;
+		s->qhead = 0;
+		s->qtail = 0;
+
+		solver_init_activities(s);
+
+		s->root_level = 0;
+		s->progress_estimate = 0;
+		s->verbosity = 0;
+
+		s->stats.starts = 0;
+		s->stats.decisions = 0;
+		s->stats.propagations = 0;
+		s->stats.inspects = 0;
+		s->stats.conflicts = 0;
+		s->stats.clauses = 0;
+		s->stats.clauses_literals = 0;
+		s->stats.learnts = 0;
+		s->stats.learnts_literals = 0;
+		s->stats.tot_literals = 0;
+
+		// initialize rollback
+		s->iVarPivot = 0;   // the pivot for variables
+		s->iTrailPivot = 0; // the pivot for trail
+		s->hProofPivot = 1; // the pivot for proof records
+	}
+}
+
+inline int sat_solver_addclause(sat_solver* s, lit* begin, lit* end)
+{
+	lit *i, *j;
+	int maxvar;
+	lit last;
+	assert(begin < end);
+	if (s->fPrintClause) {
+		for (i = begin; i < end; i++)
+			printf("%s%d ", (*i) & 1 ? "!" : "", (*i) >> 1);
+		printf("\n");
+	}
+
+	veci_resize(&s->temp_clause, 0);
+	for (i = begin; i < end; i++)
+		veci_push(&s->temp_clause, *i);
+	begin = veci_begin(&s->temp_clause);
+	end = begin + veci_size(&s->temp_clause);
+
+	// insertion sort
+	maxvar = lit_var(*begin);
+	for (i = begin + 1; i < end; i++) {
+		lit l = *i;
+		maxvar = lit_var(l) > maxvar ? lit_var(l) : maxvar;
+		for (j = i; j > begin && *(j - 1) > l; j--)
+			*j = *(j - 1);
+		*j = l;
+	}
+	sat_solver_setnvars(s, maxvar + 1);
+
+	///////////////////////////////////
+	// add clause to internal storage
+	if (s->pStore) {
+		int RetValue = Sto_ManAddClause((Sto_Man_t*) s->pStore, begin, end);
+		assert(RetValue);
+		(void) RetValue;
+	}
+	///////////////////////////////////
+
+	// delete duplicates
+	last = lit_Undef;
+	for (i = j = begin; i < end; i++) {
+		// printf("lit: "L_LIT", value = %d\n", L_lit(*i), (lit_sign(*i) ?
+		// -s->assignss[lit_var(*i)] : s->assignss[lit_var(*i)]));
+		if (*i == lit_neg(last) || var_value(s, lit_var(*i)) == lit_sign(*i))
+			return true; // tautology
+		else if (*i != last && var_value(s, lit_var(*i)) == varX)
+			last = *j++ = *i;
+	}
+	//    j = i;
+
+	if (j == begin) // empty clause
+		return false;
+
+	if (j - begin == 1) // unit clause
+		return sat_solver_enqueue(s, *begin, 0);
+
+	// create new clause
+	sat_solver_clause_new(s, begin, j, 0);
+	return true;
+}
+
+inline double luby(double y, int x)
+{
+	int size, seq;
+	for (size = 1, seq = 0; size < x + 1; seq++, size = 2 * size + 1)
+		;
+	while (size - 1 != x) {
+		size = (size - 1) >> 1;
+		seq--;
+		x = x % size;
+	}
+	return pow(y, (double) seq);
+}
+
+inline void luby_test()
+{
+	int i;
+	for (i = 0; i < 20; i++)
+		printf("%d ", (int) luby(2, i));
+	printf("\n");
+}
+
+static lbool sat_solver_search(sat_solver* s, ABC_INT64_T nof_conflicts)
+{
+	//    double  var_decay       = 0.95;
+	//    double  clause_decay    = 0.999;
+	double random_var_freq = s->fNotUseRandom ? 0.0 : 0.02;
+	ABC_INT64_T conflictC = 0;
+	veci learnt_clause;
+	int i;
+
+	assert(s->root_level == sat_solver_dl(s));
+
+	s->nRestarts++;
+	s->stats.starts++;
+	//    s->var_decay = (float)(1 / var_decay   );  // move this to sat_solver_new()
+	//    s->cla_decay = (float)(1 / clause_decay);  // move this to sat_solver_new()
+	//    veci_resize(&s->model,0);
+	veci_new(&learnt_clause);
+
+	// use activity factors in every even restart
+	if ((s->nRestarts & 1) && veci_size(&s->act_vars) > 0)
+		//    if ( veci_size(&s->act_vars) > 0 )
+		for (i = 0; i < s->act_vars.size; i++)
+			act_var_bump_factor(s, s->act_vars.ptr[i]);
+
+	// use activity factors in every restart
+	if (s->pGlobalVars && veci_size(&s->act_vars) > 0)
+		for (i = 0; i < s->act_vars.size; i++)
+			act_var_bump_global(s, s->act_vars.ptr[i]);
+
+	for (;;) {
+		int hConfl = sat_solver_propagate(s);
+		if (hConfl != 0) {
+			// CONFLICT
+			int blevel;
+
+#ifdef VERBOSEDEBUG
+			printf(L_IND "**CONFLICT**\n", L_ind);
+#endif
+			s->stats.conflicts++;
+			conflictC++;
+			if (sat_solver_dl(s) == s->root_level) {
+#ifdef SAT_USE_ANALYZE_FINAL
+				sat_solver_analyze_final(s, hConfl, 0);
+#endif
+				veci_delete(&learnt_clause);
+				return l_False;
+			}
+
+			veci_resize(&learnt_clause, 0);
+			sat_solver_analyze(s, hConfl, &learnt_clause);
+			blevel = veci_size(&learnt_clause) > 1 ?
+			             var_level(s, lit_var(veci_begin(&learnt_clause)[1])) :
+			             s->root_level;
+			blevel = s->root_level > blevel ? s->root_level : blevel;
+			sat_solver_canceluntil(s, blevel);
+			sat_solver_record(s, &learnt_clause);
+#ifdef SAT_USE_ANALYZE_FINAL
+			//            if (learnt_clause.size() == 1) level[var(learnt_clause[0])] =
+			//            0;    // (this is ugly (but needed for 'analyzeFinal()') -- in
+			//            future versions, we will backtrack past the 'root_level' and redo the assumptions)
+			if (learnt_clause.size == 1)
+				var_set_level(s, lit_var(learnt_clause.ptr[0]), 0);
+#endif
+			act_var_decay(s);
+			act_clause_decay(s);
+
+		} else {
+			// NO CONFLICT
+			int next;
+
+			// Reached bound on number of conflicts:
+			if ((!s->fNoRestarts && nof_conflicts >= 0 && conflictC >= nof_conflicts)
+			    || (s->nRuntimeLimit && (s->stats.conflicts & 63) == 0
+			        && Abc_Clock() > s->nRuntimeLimit)) {
+				s->progress_estimate = sat_solver_progress(s);
+				sat_solver_canceluntil(s, s->root_level);
+				veci_delete(&learnt_clause);
+				return l_Undef;
+			}
+
+			// Reached bound on number of conflicts:
+			if ((s->nConfLimit && s->stats.conflicts > s->nConfLimit)
+			    || (s->nInsLimit && s->stats.propagations > s->nInsLimit)) {
+				s->progress_estimate = sat_solver_progress(s);
+				sat_solver_canceluntil(s, s->root_level);
+				veci_delete(&learnt_clause);
+				return l_Undef;
+			}
+
+			// Simplify the set of problem clauses:
+			if (sat_solver_dl(s) == 0 && !s->fSkipSimplify)
+				sat_solver_simplify(s);
+
+			// Reduce the set of learnt clauses:
+			//            if (s->nLearntMax && veci_size(&s->learned) - s->qtail >= s->nLearntMax)
+			if (s->nLearntMax && veci_size(&s->act_clas) >= s->nLearntMax)
+				sat_solver_reducedb(s);
+
+			// New variable decision:
+			s->stats.decisions++;
+			next = order_select(s, (float) random_var_freq);
+
+			if (next == var_Undef) {
+				// Model found:
+				int i;
+				for (i = 0; i < s->size; i++)
+					s->model[i] = (var_value(s, i) == var1 ? l_True : l_False);
+				sat_solver_canceluntil(s, s->root_level);
+				veci_delete(&learnt_clause);
+
+				/*
+				veci apa; veci_new(&apa);
+				for (i = 0; i < s->size; i++)
+				    veci_push(&apa,(int)(s->model.ptr[i] == l_True ? toLit(i) :
+				lit_neg(toLit(i)))); printf("model: "); printlits((lit*)apa.ptr,
+				(lit*)apa.ptr + veci_size(&apa)); printf("\n"); veci_delete(&apa);
+				*/
+
+				return l_True;
+			}
+
+			if (var_polar(s, next)) // positive polarity
+				sat_solver_decision(s, toLit(next));
+			else
+				sat_solver_decision(s, lit_neg(toLit(next)));
+		}
+	}
+
+	return l_Undef; // cannot happen
+}
+
+// internal call to the SAT solver
+inline int sat_solver_solve_internal(sat_solver* s)
+{
+	lbool status = l_Undef;
+	int restart_iter = 0;
+	veci_resize(&s->unit_lits, 0);
+	s->nCalls++;
+
+	if (s->verbosity >= 1) {
+		printf("==================================[MINISAT]================================"
+		       "===\n");
+		printf("| Conflicts |     ORIGINAL     |              LEARNT              | "
+		       "Progress |\n");
+		printf("|           | Clauses Literals |   Limit Clauses Literals  Lit/Cl |        "
+		       "  |\n");
+		printf("==========================================================================="
+		       "===\n");
+	}
+
+	while (status == l_Undef) {
+		ABC_INT64_T nof_conflicts;
+		double Ratio = (s->stats.learnts == 0) ?
+		                   0.0 :
+		                   s->stats.learnts_literals / (double) s->stats.learnts;
+		if (s->nRuntimeLimit && Abc_Clock() > s->nRuntimeLimit)
+			break;
+		if (s->verbosity >= 1) {
+			printf("| %9.0f | %7.0f %8.0f | %7.0f %7.0f %8.0f %7.1f | %6.3f %% |\n",
+			       (double) s->stats.conflicts, (double) s->stats.clauses,
+			       (double) s->stats.clauses_literals, (double) 0,
+			       (double) s->stats.learnts, (double) s->stats.learnts_literals, Ratio,
+			       s->progress_estimate * 100);
+			fflush(stdout);
+		}
+		nof_conflicts = (ABC_INT64_T)(100 * luby(2, restart_iter++));
+		status = sat_solver_search(s, nof_conflicts);
+		// quit the loop if reached an external limit
+		if (s->nConfLimit && s->stats.conflicts > s->nConfLimit)
+			break;
+		if (s->nInsLimit && s->stats.propagations > s->nInsLimit)
+			break;
+		if (s->nRuntimeLimit && Abc_Clock() > s->nRuntimeLimit)
+			break;
+		if (s->pFuncStop && s->pFuncStop(s->RunId))
+			break;
+	}
+	if (s->verbosity >= 1)
+		printf("==========================================================================="
+		       "===\n");
+
+	sat_solver_canceluntil(s, s->root_level);
+	// save variable values
+	if (status == l_True && s->user_vars.size) {
+		int v;
+		for (v = 0; v < s->user_vars.size; v++)
+			veci_push(&s->user_values, sat_solver_var_value(s, s->user_vars.ptr[v]));
+	}
+	return status;
+}
+
+// pushing one assumption to the stack of assumptions
+inline int sat_solver_push(sat_solver* s, int p)
+{
+	assert(lit_var(p) < s->size);
+	veci_push(&s->trail_lim, s->qtail);
+	s->root_level++;
+	if (!sat_solver_enqueue(s, p, 0)) {
+		int h = s->reasons[lit_var(p)];
+		if (h) {
+			if (clause_is_lit(h)) {
+				(clause_begin(s->binary))[1] = lit_neg(p);
+				(clause_begin(s->binary))[0] = clause_read_lit(h);
+				h = s->hBinary;
+			}
+			sat_solver_analyze_final(s, h, 1);
+			veci_push(&s->conf_final, lit_neg(p));
+		} else {
+			veci_resize(&s->conf_final, 0);
+			veci_push(&s->conf_final, lit_neg(p));
+			// the two lines below are a bug fix by Siert Wieringa
+			if (var_level(s, lit_var(p)) > 0)
+				veci_push(&s->conf_final, p);
+		}
+		// sat_solver_canceluntil(s, 0);
+		return false;
+	} else {
+		int fConfl = sat_solver_propagate(s);
+		if (fConfl) {
+			sat_solver_analyze_final(s, fConfl, 0);
+			// assert(s->conf_final.size > 0);
+			// sat_solver_canceluntil(s, 0);
+			return false;
+		}
+	}
+	return true;
+}
+
+// removing one assumption from the stack of assumptions
+inline void sat_solver_pop(sat_solver* s)
+{
+	assert(sat_solver_dl(s) > 0);
+	sat_solver_canceluntil(s, --s->root_level);
+}
+
+inline void sat_solver_set_resource_limits(sat_solver* s, ABC_INT64_T nConfLimit,
+                                           ABC_INT64_T nInsLimit, ABC_INT64_T nConfLimitGlobal,
+                                           ABC_INT64_T nInsLimitGlobal)
+{
+	// set the external limits
+	s->nRestarts = 0;
+	s->nConfLimit = 0;
+	s->nInsLimit = 0;
+	if (nConfLimit)
+		s->nConfLimit = s->stats.conflicts + nConfLimit;
+	if (nInsLimit)
+		//        s->nInsLimit = s->stats.inspects + nInsLimit;
+		s->nInsLimit = s->stats.propagations + nInsLimit;
+	if (nConfLimitGlobal && (s->nConfLimit == 0 || s->nConfLimit > nConfLimitGlobal))
+		s->nConfLimit = nConfLimitGlobal;
+	if (nInsLimitGlobal && (s->nInsLimit == 0 || s->nInsLimit > nInsLimitGlobal))
+		s->nInsLimit = nInsLimitGlobal;
+}
+
+inline int sat_solver_solve(sat_solver* s, lit* begin, lit* end, ABC_INT64_T nConfLimit,
+                            ABC_INT64_T nInsLimit, ABC_INT64_T nConfLimitGlobal,
+                            ABC_INT64_T nInsLimitGlobal)
+{
+	lbool status;
+	lit* i;
+	////////////////////////////////////////////////
+	if (s->fSolved) {
+		if (s->pStore) {
+			int RetValue = Sto_ManAddClause((Sto_Man_t*) s->pStore, NULL, NULL);
+			assert(RetValue);
+			(void) RetValue;
+		}
+		return l_False;
+	}
+	////////////////////////////////////////////////
+
+	if (s->fVerbose)
+		printf("Running SAT solver with parameters %d and %d and %d.\n", s->nLearntStart,
+		       s->nLearntDelta, s->nLearntRatio);
+
+	sat_solver_set_resource_limits(s, nConfLimit, nInsLimit, nConfLimitGlobal, nInsLimitGlobal);
+
+#ifdef SAT_USE_ANALYZE_FINAL
+	// Perform assumptions:
+	s->root_level = 0;
+	for (i = begin; i < end; i++)
+		if (!sat_solver_push(s, *i)) {
+			sat_solver_canceluntil(s, 0);
+			s->root_level = 0;
+			return l_False;
+		}
+	assert(s->root_level == sat_solver_dl(s));
+#else
+	// printf("solve: "); printlits(begin, end); printf("\n");
+	for (i = begin; i < end; i++) {
+		//        switch (lit_sign(*i) ? -s->assignss[lit_var(*i)] : s->assignss[lit_var(*i)]){
+		switch (var_value(s, *i)) {
+		case var1: // l_True:
+			break;
+		case varX: // l_Undef
+			sat_solver_decision(s, *i);
+			if (sat_solver_propagate(s) == 0)
+				break;
+			// fallthrough
+		case var0: // l_False
+			sat_solver_canceluntil(s, 0);
+			return l_False;
+		}
+	}
+	s->root_level = sat_solver_dl(s);
+#endif
+
+	status = sat_solver_solve_internal(s);
+
+	sat_solver_canceluntil(s, 0);
+	s->root_level = 0;
+
+	////////////////////////////////////////////////
+	if (status == l_False && s->pStore) {
+		int RetValue = Sto_ManAddClause((Sto_Man_t*) s->pStore, NULL, NULL);
+		assert(RetValue);
+		(void) RetValue;
+	}
+	////////////////////////////////////////////////
+	return status;
+}
+
+// This LEXSAT procedure should be called with a set of literals (pLits, nLits),
+// which defines both (1) variable order, and (2) assignment to begin search from.
+// It retuns the LEXSAT assigment that is the same or larger than the given one.
+// (It assumes that there is no smaller assignment than the one given!)
+// The resulting assignment is returned in the same set of literals (pLits, nLits).
+// It pushes/pops assumptions internally and will undo them before terminating.
+inline int sat_solver_solve_lexsat(sat_solver* s, int* pLits, int nLits)
+{
+	int i, iLitFail = -1;
+	lbool status;
+	assert(nLits > 0);
+	// help the SAT solver by setting desirable polarity
+	sat_solver_set_literal_polarity(s, pLits, nLits);
+	// check if there exists a satisfying assignment
+	status = sat_solver_solve_internal(s);
+	if (status != l_True) // no assignment
+		return status;
+	// there is at least one satisfying assignment
+	assert(status == l_True);
+	// find the first mismatching literal
+	for (i = 0; i < nLits; i++)
+		if (pLits[i] != sat_solver_var_literal(s, Abc_Lit2Var(pLits[i])))
+			break;
+	if (i == nLits) // no mismatch - the current assignment is the minimum one!
+		return l_True;
+	// mismatch happens in literal i
+	iLitFail = i;
+	// create assumptions up to this literal (as in pLits) - including this literal!
+	for (i = 0; i <= iLitFail; i++)
+		if (!sat_solver_push(s, pLits[i])) // can become UNSAT while adding the last assumption
+			break;
+	if (i < iLitFail + 1) // the solver became UNSAT while adding assumptions
+		status = l_False;
+	else // solve under the assumptions
+		status = sat_solver_solve_internal(s);
+	if (status == l_True) {
+		// we proved that there is a sat assignment with literal (iLitFail) having polarity
+		// as in pLits continue solving recursively
+		if (iLitFail + 1 < nLits)
+			status = sat_solver_solve_lexsat(s, pLits + iLitFail + 1,
+			                                 nLits - iLitFail - 1);
+	} else if (status == l_False) {
+		// we proved that there is no assignment with iLitFail having polarity as in pLits
+		assert(Abc_LitIsCompl(pLits[iLitFail])); // literal is 0
+		// (this assert may fail only if there is a sat assignment smaller than one
+		// originally given in pLits) now we flip this literal (make it 1), change the last
+		// assumption and contiue looking for the 000...0-assignment of other literals
+		sat_solver_pop(s);
+		pLits[iLitFail] = Abc_LitNot(pLits[iLitFail]);
+		if (!sat_solver_push(s, pLits[iLitFail]))
+			printf(
+			    "sat_solver_solve_lexsat(): A satisfying assignment should exist.\n"); // because we know that the problem is satisfiable
+		// update other literals to be 000...0
+		for (i = iLitFail + 1; i < nLits; i++)
+			pLits[i] = Abc_LitNot(Abc_LitRegular(pLits[i]));
+		// continue solving recursively
+		if (iLitFail + 1 < nLits)
+			status = sat_solver_solve_lexsat(s, pLits + iLitFail + 1,
+			                                 nLits - iLitFail - 1);
+		else
+			status = l_True;
+	}
+	// undo the assumptions
+	for (i = iLitFail; i >= 0; i--)
+		sat_solver_pop(s);
+	return status;
+}
+
+// This procedure is called on a set of assumptions to minimize their number.
+// The procedure relies on the fact that the current set of assumptions is UNSAT.
+// It receives and returns SAT solver without assumptions. It returns the number
+// of assumptions after minimization. The set of assumptions is returned in pLits.
+inline int sat_solver_minimize_assumptions(sat_solver* s, int* pLits, int nLits, int nConfLimit)
+{
+	int i, k, nLitsL, nLitsR, nResL, nResR, status;
+	if (nLits == 1) {
+		// since the problem is UNSAT, we will try to solve it without assuming the last literal
+		// if the result is UNSAT, the last literal can be dropped; otherwise, it is needed
+		if (nConfLimit)
+			s->nConfLimit = s->stats.conflicts + nConfLimit;
+		status = sat_solver_solve_internal(s);
+		// printf( "%c", status == l_False ? 'u' : 's' );
+		return (int) (status != l_False); // return 1 if the problem is not UNSAT
+	}
+	assert(nLits >= 2);
+	nLitsL = nLits / 2;
+	nLitsR = nLits - nLitsL;
+	// assume the left lits
+	for (i = 0; i < nLitsL; i++)
+		if (!sat_solver_push(s, pLits[i])) {
+			for (k = i; k >= 0; k--)
+				sat_solver_pop(s);
+			return sat_solver_minimize_assumptions(s, pLits, i + 1, nConfLimit);
+		}
+	// solve with these assumptions
+	if (nConfLimit)
+		s->nConfLimit = s->stats.conflicts + nConfLimit;
+	status = sat_solver_solve_internal(s);
+	if (status == l_False) // these are enough
+	{
+		for (i = 0; i < nLitsL; i++)
+			sat_solver_pop(s);
+		return sat_solver_minimize_assumptions(s, pLits, nLitsL, nConfLimit);
+	}
+	// solve for the right lits
+	nResL = nLitsR == 1 ? 1 :
+	                      sat_solver_minimize_assumptions(s, pLits + nLitsL, nLitsR, nConfLimit);
+	for (i = 0; i < nLitsL; i++)
+		sat_solver_pop(s);
+	// swap literals
+	//    assert( nResL <= nLitsL );
+	//    for ( i = 0; i < nResL; i++ )
+	//        ABC_SWAP( int, pLits[i], pLits[nLitsL+i] );
+	veci_resize(&s->temp_clause, 0);
+	for (i = 0; i < nLitsL; i++)
+		veci_push(&s->temp_clause, pLits[i]);
+	for (i = 0; i < nResL; i++)
+		pLits[i] = pLits[nLitsL + i];
+	for (i = 0; i < nLitsL; i++)
+		pLits[nResL + i] = veci_begin(&s->temp_clause)[i];
+	// assume the right lits
+	for (i = 0; i < nResL; i++)
+		if (!sat_solver_push(s, pLits[i])) {
+			for (k = i; k >= 0; k--)
+				sat_solver_pop(s);
+			return sat_solver_minimize_assumptions(s, pLits, i + 1, nConfLimit);
+		}
+	// solve with these assumptions
+	if (nConfLimit)
+		s->nConfLimit = s->stats.conflicts + nConfLimit;
+	status = sat_solver_solve_internal(s);
+	if (status == l_False) // these are enough
+	{
+		for (i = 0; i < nResL; i++)
+			sat_solver_pop(s);
+		return nResL;
+	}
+	// solve for the left lits
+	nResR = nLitsL == 1 ? 1 :
+	                      sat_solver_minimize_assumptions(s, pLits + nResL, nLitsL, nConfLimit);
+	for (i = 0; i < nResL; i++)
+		sat_solver_pop(s);
+	return nResL + nResR;
+}
+
+// This is a specialized version of the above procedure with several custom changes:
+// - makes sure that at least one of the marked literals is preserved in the clause
+// - sets literals to zero when they do not have to be used
+// - sets literals to zero for disproved variables
+inline int sat_solver_minimize_assumptions2(sat_solver* s, int* pLits, int nLits, int nConfLimit)
+{
+	int i, k, nLitsL, nLitsR, nResL, nResR;
+	if (nLits == 1) {
+		// since the problem is UNSAT, we will try to solve it without assuming the last literal
+		// if the result is UNSAT, the last literal can be dropped; otherwise, it is needed
+		int RetValue = 1, LitNot = Abc_LitNot(pLits[0]);
+		int status = l_False;
+		int Temp = s->nConfLimit;
+		s->nConfLimit = nConfLimit;
+
+		RetValue = sat_solver_push(s, LitNot);
+		assert(RetValue);
+		status = sat_solver_solve_internal(s);
+		sat_solver_pop(s);
+
+		// if the problem is UNSAT, add clause
+		if (status == l_False) {
+			RetValue = sat_solver_addclause(s, &LitNot, &LitNot + 1);
+			assert(RetValue);
+		}
+
+		s->nConfLimit = Temp;
+		return (int) (status != l_False); // return 1 if the problem is not UNSAT
+	}
+	assert(nLits >= 2);
+	nLitsL = nLits / 2;
+	nLitsR = nLits - nLitsL;
+	// assume the left lits
+	for (i = 0; i < nLitsL; i++)
+		if (!sat_solver_push(s, pLits[i])) {
+			for (k = i; k >= 0; k--)
+				sat_solver_pop(s);
+
+			// add clauses for these literal
+			for (k = i + 1; k > nLitsL; k++) {
+				int LitNot = Abc_LitNot(pLits[i]);
+				int RetValue = sat_solver_addclause(s, &LitNot, &LitNot + 1);
+				assert(RetValue);
+			}
+
+			return sat_solver_minimize_assumptions2(s, pLits, i + 1, nConfLimit);
+		}
+	// solve for the right lits
+	nResL = sat_solver_minimize_assumptions2(s, pLits + nLitsL, nLitsR, nConfLimit);
+	for (i = 0; i < nLitsL; i++)
+		sat_solver_pop(s);
+	// swap literals
+	//    assert( nResL <= nLitsL );
+	veci_resize(&s->temp_clause, 0);
+	for (i = 0; i < nLitsL; i++)
+		veci_push(&s->temp_clause, pLits[i]);
+	for (i = 0; i < nResL; i++)
+		pLits[i] = pLits[nLitsL + i];
+	for (i = 0; i < nLitsL; i++)
+		pLits[nResL + i] = veci_begin(&s->temp_clause)[i];
+	// assume the right lits
+	for (i = 0; i < nResL; i++)
+		if (!sat_solver_push(s, pLits[i])) {
+			for (k = i; k >= 0; k--)
+				sat_solver_pop(s);
+
+			// add clauses for these literal
+			for (k = i + 1; k > nResL; k++) {
+				int LitNot = Abc_LitNot(pLits[i]);
+				int RetValue = sat_solver_addclause(s, &LitNot, &LitNot + 1);
+				assert(RetValue);
+			}
+
+			return sat_solver_minimize_assumptions2(s, pLits, i + 1, nConfLimit);
+		}
+	// solve for the left lits
+	nResR = sat_solver_minimize_assumptions2(s, pLits + nResL, nLitsL, nConfLimit);
+	for (i = 0; i < nResL; i++)
+		sat_solver_pop(s);
+	return nResL + nResR;
+}
+
+inline int sat_solver_nvars(sat_solver* s)
+{
+	return s->size;
+}
+
+inline int sat_solver_nclauses(sat_solver* s)
+{
+	return s->stats.clauses;
+}
+
+inline int sat_solver_nconflicts(sat_solver* s)
+{
+	return (int) s->stats.conflicts;
+}
+
+//=================================================================================================
+// Clause storage functions:
+
+inline void sat_solver_store_alloc(sat_solver* s)
+{
+	assert(s->pStore == NULL);
+	s->pStore = Sto_ManAlloc();
+}
+
+inline void sat_solver_store_write(sat_solver* s, char* pFileName)
+{
+	if (s->pStore)
+		Sto_ManDumpClauses((Sto_Man_t*) s->pStore, pFileName);
+}
+
+inline void sat_solver_store_free(sat_solver* s)
+{
+	if (s->pStore)
+		Sto_ManFree((Sto_Man_t*) s->pStore);
+	s->pStore = NULL;
+}
+
+inline int sat_solver_store_change_last(sat_solver* s)
+{
+	if (s->pStore)
+		return Sto_ManChangeLastClause((Sto_Man_t*) s->pStore);
+	return -1;
+}
+
+inline void sat_solver_store_mark_roots(sat_solver* s)
+{
+	if (s->pStore)
+		Sto_ManMarkRoots((Sto_Man_t*) s->pStore);
+}
+
+inline void sat_solver_store_mark_clauses_a(sat_solver* s)
+{
+	if (s->pStore)
+		Sto_ManMarkClausesA((Sto_Man_t*) s->pStore);
+}
+
+inline void* sat_solver_store_release(sat_solver* s)
+{
+	void* pTemp;
+	if (s->pStore == NULL)
+		return NULL;
+	pTemp = s->pStore;
+	s->pStore = NULL;
+	return pTemp;
+}
+
+ABC_NAMESPACE_IMPL_END
+
+/*** SimpSolver.cpp */
+
+/***********************************************************************************[SimpSolver.cc]
+Copyright (c) 2006,      Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#include "abc/SimpSolver.h"
+#include "abc/Sort.h"
+#include "abc/system.h"
+
+ABC_NAMESPACE_IMPL_START
+
+namespace Gluco {
+
+//=================================================================================================
+// Options:
+
+static const char* _cat = "SIMP";
+
+//=================================================================================================
+// Constructor/Destructor:
+
+inline SimpSolver::SimpSolver()
+    : grow(0)
+    , clause_lim(20)
+    , subsumption_lim(1000)
+    , simp_garbage_frac(0.5)
+    , use_asymm(false)
+    , use_rcheck(false)
+    , use_elim(true)
+    , merges(0)
+    , asymm_lits(0)
+    , eliminated_vars(0)
+    , eliminated_clauses(0)
+    , elimorder(1)
+    , use_simplification(true)
+    , occurs(ClauseDeleted(ca))
+    , elim_heap(ElimLt(n_occ))
+    , bwdsub_assigns(0)
+    , n_touched(0)
+{
+	vec<Lit> dummy(1, lit_Undef);
+	ca.extra_clause_field = true; // NOTE: must happen before allocating the dummy clause below.
+	bwdsub_tmpunit = ca.alloc(dummy);
+	remove_satisfied = false;
+}
+
+inline SimpSolver::~SimpSolver()
+{}
+
+inline Var SimpSolver::newVar(bool sign, bool dvar)
+{
+	Var v = Solver::newVar(sign, dvar);
+
+	frozen.push((char) false);
+	eliminated.push((char) false);
+
+	if (use_simplification) {
+		n_occ.push(0);
+		n_occ.push(0);
+		occurs.init(v);
+		touched.push(0);
+		elim_heap.insert(v);
+	}
+	return v;
+}
+
+inline lbool SimpSolver::solve_(bool do_simp, bool turn_off_simp)
+{
+	vec<Var> extra_frozen;
+	lbool result = l_True;
+
+	do_simp &= use_simplification;
+
+	if (do_simp) {
+		// Assumptions must be temporarily frozen to run variable elimination:
+		for (int i = 0; i < assumptions.size(); i++) {
+			Var v = var(assumptions[i]);
+
+			// If an assumption has been eliminated, remember it.
+			assert(!isEliminated(v));
+
+			if (!frozen[v]) {
+				// Freeze and store.
+				setFrozen(v, true);
+				extra_frozen.push(v);
+			}
+		}
+
+		result = lbool(eliminate(turn_off_simp));
+	}
+
+	if (result == l_True)
+		result = Solver::solve_();
+	else if (verbosity >= 1)
+		printf("==========================================================================="
+		       "====\n");
+
+	if (result == l_True)
+		extendModel();
+
+	if (do_simp)
+		// Unfreeze the assumptions that were frozen:
+		for (int i = 0; i < extra_frozen.size(); i++)
+			setFrozen(extra_frozen[i], false);
+
+	return result;
+}
+
+inline bool SimpSolver::addClause_(vec<Lit>& ps)
+{
+#ifndef NDEBUG
+	for (int i = 0; i < ps.size(); i++)
+		assert(!isEliminated(var(ps[i])));
+#endif
+	int nclauses = clauses.size();
+
+	if (use_rcheck && implied(ps))
+		return true;
+
+	if (!Solver::addClause_(ps))
+		return false;
+
+	if (use_simplification && clauses.size() == nclauses + 1) {
+		CRef cr = clauses.last();
+		const Clause& c = ca[cr];
+
+		// NOTE: the clause is added to the queue immediately and then
+		// again during 'gatherTouchedClauses()'. If nothing happens
+		// in between, it will only be checked once. Otherwise, it may
+		// be checked twice unnecessarily. This is an unfortunate
+		// consequence of how backward subsumption is used to mimic
+		// forward subsumption.
+		subsumption_queue.insert(cr);
+		for (int i = 0; i < c.size(); i++) {
+			occurs[var(c[i])].push(cr);
+			n_occ[toInt(c[i])]++;
+			touched[var(c[i])] = 1;
+			n_touched++;
+			if (elim_heap.inHeap(var(c[i])))
+				elim_heap.increase(var(c[i]));
+		}
+	}
+
+	return true;
+}
+
+inline void SimpSolver::removeClause(CRef cr)
+{
+	const Clause& c = ca[cr];
+
+	if (use_simplification)
+		for (int i = 0; i < c.size(); i++) {
+			n_occ[toInt(c[i])]--;
+			updateElimHeap(var(c[i]));
+			occurs.smudge(var(c[i]));
+		}
+
+	Solver::removeClause(cr);
+}
+
+inline bool SimpSolver::strengthenClause(CRef cr, Lit l)
+{
+	Clause& c = ca[cr];
+	assert(decisionLevel() == 0);
+	assert(use_simplification);
+
+	// FIX: this is too inefficient but would be nice to have (properly implemented)
+	// if (!find(subsumption_queue, &c))
+	subsumption_queue.insert(cr);
+
+	if (certifiedUNSAT) {
+		for (int i = 0; i < c.size(); i++)
+			if (c[i] != l)
+				fprintf(certifiedOutput, "%i ",
+				        (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+		fprintf(certifiedOutput, "0\n");
+	}
+
+	if (c.size() == 2) {
+		removeClause(cr);
+		c.strengthen(l);
+	} else {
+		if (certifiedUNSAT) {
+			fprintf(certifiedOutput, "d ");
+			for (int i = 0; i < c.size(); i++)
+				fprintf(certifiedOutput, "%i ",
+				        (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+			fprintf(certifiedOutput, "0\n");
+		}
+
+		detachClause(cr, true);
+		c.strengthen(l);
+		attachClause(cr);
+		remove(occurs[var(l)], cr);
+		n_occ[toInt(l)]--;
+		updateElimHeap(var(l));
+	}
+
+	return c.size() == 1 ? enqueue(c[0]) && propagate() == CRef_Undef : true;
+}
+
+// Returns FALSE if clause is always satisfied ('out_clause' should not be used).
+inline bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, vec<Lit>& out_clause)
+{
+	merges++;
+	out_clause.clear();
+
+	bool ps_smallest = _ps.size() < _qs.size();
+	const Clause& ps = ps_smallest ? _qs : _ps;
+	const Clause& qs = ps_smallest ? _ps : _qs;
+
+	int i, j;
+	for (i = 0; i < qs.size(); i++) {
+		if (var(qs[i]) != v) {
+			for (j = 0; j < ps.size(); j++)
+				if (var(ps[j]) == var(qs[i])) {
+					if (ps[j] == ~qs[i])
+						return false;
+					else
+						goto next;
+				}
+			out_clause.push(qs[i]);
+		}
+	next:;
+	}
+
+	for (i = 0; i < ps.size(); i++)
+		if (var(ps[i]) != v)
+			out_clause.push(ps[i]);
+
+	return true;
+}
+
+// Returns FALSE if clause is always satisfied.
+inline bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, int& size)
+{
+	merges++;
+
+	bool ps_smallest = _ps.size() < _qs.size();
+	const Clause& ps = ps_smallest ? _qs : _ps;
+	const Clause& qs = ps_smallest ? _ps : _qs;
+	const Lit* __ps = (const Lit*) ps;
+	const Lit* __qs = (const Lit*) qs;
+
+	size = ps.size() - 1;
+
+	for (int i = 0; i < qs.size(); i++) {
+		if (var(__qs[i]) != v) {
+			for (int j = 0; j < ps.size(); j++)
+				if (var(__ps[j]) == var(__qs[i])) {
+					if (__ps[j] == ~__qs[i])
+						return false;
+					else
+						goto next;
+				}
+			size++;
+		}
+	next:;
+	}
+
+	return true;
+}
+
+inline void SimpSolver::gatherTouchedClauses()
+{
+	if (n_touched == 0)
+		return;
+
+	int i, j;
+	for (i = j = 0; i < subsumption_queue.size(); i++)
+		if (ca[subsumption_queue[i]].mark() == 0)
+			ca[subsumption_queue[i]].mark(2);
+
+	for (i = 0; i < touched.size(); i++)
+		if (touched[i]) {
+			const vec<CRef>& cs = occurs.lookup(i);
+			for (j = 0; j < cs.size(); j++)
+				if (ca[cs[j]].mark() == 0) {
+					subsumption_queue.insert(cs[j]);
+					ca[cs[j]].mark(2);
+				}
+			touched[i] = 0;
+		}
+
+	for (i = 0; i < subsumption_queue.size(); i++)
+		if (ca[subsumption_queue[i]].mark() == 2)
+			ca[subsumption_queue[i]].mark(0);
+
+	n_touched = 0;
+}
+
+inline bool SimpSolver::implied(const vec<Lit>& c)
+{
+	assert(decisionLevel() == 0);
+
+	trail_lim.push(trail.size());
+	for (int i = 0; i < c.size(); i++)
+		if (value(c[i]) == l_True) {
+			cancelUntil(0);
+			return false;
+		} else if (value(c[i]) != l_False) {
+			assert(value(c[i]) == l_Undef);
+			uncheckedEnqueue(~c[i]);
+		}
+
+	bool result = propagate() != CRef_Undef;
+	cancelUntil(0);
+	return result;
+}
+
+// Backward subsumption + backward subsumption resolution
+inline bool SimpSolver::backwardSubsumptionCheck(bool verbose)
+{
+	int cnt = 0;
+	int subsumed = 0;
+	int deleted_literals = 0;
+	assert(decisionLevel() == 0);
+
+	while (subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()) {
+
+		// Empty subsumption queue and return immediately on user-interrupt:
+		if (asynch_interrupt) {
+			subsumption_queue.clear();
+			bwdsub_assigns = trail.size();
+			break;
+		}
+
+		// Check top-level assignments by creating a dummy clause and placing it in the queue:
+		if (subsumption_queue.size() == 0 && bwdsub_assigns < trail.size()) {
+			Lit l = trail[bwdsub_assigns++];
+			ca[bwdsub_tmpunit][0] = l;
+			ca[bwdsub_tmpunit].calcAbstraction();
+			subsumption_queue.insert(bwdsub_tmpunit);
+		}
+
+		CRef cr = subsumption_queue.peek();
+		subsumption_queue.pop();
+		Clause& c = ca[cr];
+
+		if (c.mark())
+			continue;
+
+		if (verbose && verbosity >= 2 && cnt++ % 1000 == 0)
+			printf("subsumption left: %10d (%10d subsumed, %10d deleted literals)\r",
+			       subsumption_queue.size(), subsumed, deleted_literals);
+
+		assert(c.size() > 1
+		       || value(c[0])
+		              == l_True); // Unit-clauses should have been propagated before this point.
+
+		// Find best variable to scan:
+		Var best = var(c[0]);
+		for (int i = 1; i < c.size(); i++)
+			if (occurs[var(c[i])].size() < occurs[best].size())
+				best = var(c[i]);
+
+		// Search all candidates:
+		vec<CRef>& _cs = occurs.lookup(best);
+		CRef* cs = (CRef*) _cs;
+
+		for (int j = 0; j < _cs.size(); j++)
+			if (c.mark())
+				break;
+			else if (!ca[cs[j]].mark() && cs[j] != cr
+			         && (subsumption_lim == -1 || ca[cs[j]].size() < subsumption_lim)) {
+				Lit l = c.subsumes(ca[cs[j]]);
+
+				if (l == lit_Undef)
+					subsumed++, removeClause(cs[j]);
+				else if (l != lit_Error) {
+					deleted_literals++;
+
+					if (!strengthenClause(cs[j], ~l))
+						return false;
+
+					// Did current candidate get deleted from cs? Then check
+					// candidate at index j again:
+					if (var(l) == best)
+						j--;
+				}
+			}
+	}
+
+	return true;
+}
+
+inline bool SimpSolver::asymm(Var v, CRef cr)
+{
+	Clause& c = ca[cr];
+	assert(decisionLevel() == 0);
+
+	if (c.mark() || satisfied(c))
+		return true;
+
+	trail_lim.push(trail.size());
+	Lit l = lit_Undef;
+	for (int i = 0; i < c.size(); i++)
+		if (var(c[i]) != v && value(c[i]) != l_False)
+			uncheckedEnqueue(~c[i]);
+		else
+			l = c[i];
+
+	if (propagate() != CRef_Undef) {
+		cancelUntil(0);
+		asymm_lits++;
+		if (!strengthenClause(cr, l))
+			return false;
+	} else
+		cancelUntil(0);
+
+	return true;
+}
+
+inline bool SimpSolver::asymmVar(Var v)
+{
+	assert(use_simplification);
+
+	const vec<CRef>& cls = occurs.lookup(v);
+
+	if (value(v) != l_Undef || cls.size() == 0)
+		return true;
+
+	for (int i = 0; i < cls.size(); i++)
+		if (!asymm(v, cls[i]))
+			return false;
+
+	return backwardSubsumptionCheck();
+}
+
+static void mkElimClause(vec<uint32_t>& elimclauses, Lit x)
+{
+	elimclauses.push(toInt(x));
+	elimclauses.push(1);
+}
+
+static void mkElimClause(vec<uint32_t>& elimclauses, Var v, Clause& c)
+{
+	int first = elimclauses.size();
+	int v_pos = -1;
+
+	// Copy clause to elimclauses-vector. Remember position where the
+	// variable 'v' occurs:
+	for (int i = 0; i < c.size(); i++) {
+		elimclauses.push(toInt(c[i]));
+		if (var(c[i]) == v)
+			v_pos = i + first;
+	}
+	assert(v_pos != -1);
+
+	// Swap the first literal with the 'v' literal, so that the literal
+	// containing 'v' will occur first in the clause:
+	uint32_t tmp = elimclauses[v_pos];
+	elimclauses[v_pos] = elimclauses[first];
+	elimclauses[first] = tmp;
+
+	// Store the length of the clause last:
+	elimclauses.push(c.size());
+}
+
+inline bool SimpSolver::eliminateVar(Var v)
+{
+	int i, j;
+	assert(!frozen[v]);
+	assert(!isEliminated(v));
+	assert(value(v) == l_Undef);
+
+	// Split the occurrences into positive and negative:
+	//
+	const vec<CRef>& cls = occurs.lookup(v);
+	vec<CRef> pos, neg;
+	for (i = 0; i < cls.size(); i++)
+		(find(ca[cls[i]], mkLit(v)) ? pos : neg).push(cls[i]);
+
+	// Check wether the increase in number of clauses stays within the allowed ('grow').
+	// Moreover, no clause must exceed the limit on the maximal clause size (if it is set):
+	//
+	int cnt = 0;
+	int clause_size = 0;
+
+	for (i = 0; i < pos.size(); i++)
+		for (j = 0; j < neg.size(); j++)
+			if (merge(ca[pos[i]], ca[neg[j]], v, clause_size)
+			    && (++cnt > cls.size() + grow
+			        || (clause_lim != -1 && clause_size > clause_lim)))
+				return true;
+
+	// Delete and store old clauses:
+	eliminated[v] = true;
+	setDecisionVar(v, false);
+	eliminated_vars++;
+
+	if (pos.size() > neg.size()) {
+		for (i = 0; i < neg.size(); i++)
+			mkElimClause(elimclauses, v, ca[neg[i]]);
+		mkElimClause(elimclauses, mkLit(v));
+		eliminated_clauses += neg.size();
+	} else {
+		for (i = 0; i < pos.size(); i++)
+			mkElimClause(elimclauses, v, ca[pos[i]]);
+		mkElimClause(elimclauses, ~mkLit(v));
+		eliminated_clauses += pos.size();
+	}
+
+	// Produce clauses in cross product:
+	vec<Lit>& resolvent = add_tmp;
+	for (i = 0; i < pos.size(); i++)
+		for (j = 0; j < neg.size(); j++)
+			if (merge(ca[pos[i]], ca[neg[j]], v, resolvent) && !addClause_(resolvent))
+				return false;
+
+	for (i = 0; i < cls.size(); i++)
+		removeClause(cls[i]);
+
+	// Free occurs list for this variable:
+	occurs[v].clear(true);
+
+	// Free watchers lists for this variable, if possible:
+	if (watches[mkLit(v)].size() == 0)
+		watches[mkLit(v)].clear(true);
+	if (watches[~mkLit(v)].size() == 0)
+		watches[~mkLit(v)].clear(true);
+
+	return backwardSubsumptionCheck();
+}
+
+inline bool SimpSolver::substitute(Var v, Lit x)
+{
+	assert(!frozen[v]);
+	assert(!isEliminated(v));
+	assert(value(v) == l_Undef);
+
+	if (!ok)
+		return false;
+
+	eliminated[v] = true;
+	setDecisionVar(v, false);
+	const vec<CRef>& cls = occurs.lookup(v);
+
+	vec<Lit>& subst_clause = add_tmp;
+	for (int i = 0; i < cls.size(); i++) {
+		Clause& c = ca[cls[i]];
+
+		subst_clause.clear();
+		for (int j = 0; j < c.size(); j++) {
+			Lit p = c[j];
+			subst_clause.push(var(p) == v ? x ^ sign(p) : p);
+		}
+
+		if (!addClause_(subst_clause))
+			return ok = false;
+
+		removeClause(cls[i]);
+	}
+
+	return true;
+}
+
+inline void SimpSolver::extendModel()
+{
+	int i, j;
+	Lit x;
+
+	for (i = elimclauses.size() - 1; i > 0; i -= j) {
+		for (j = elimclauses[i--]; j > 1; j--, i--)
+			if (modelValue(toLit(elimclauses[i])) != l_False)
+				goto next;
+
+		x = toLit(elimclauses[i]);
+		model[var(x)] = lbool(!sign(x));
+	next:;
+	}
+}
+
+inline bool SimpSolver::eliminate(bool turn_off_elim)
+{
+	// abctime clk = Abc_Clock();
+	if (!simplify())
+		return false;
+	else if (!use_simplification)
+		return true;
+
+	// Main simplification loop:
+	//
+
+	int toPerform = clauses.size() <= 4800000;
+
+	if (!toPerform) {
+		printf("c Too many clauses... No preprocessing\n");
+	}
+
+	while (toPerform && (n_touched > 0 || bwdsub_assigns < trail.size() || elim_heap.size() > 0)) {
+
+		gatherTouchedClauses();
+		// printf("  ## (time = %6.2f s) BWD-SUB: queue = %d, trail = %d\n", cpuTime(),
+		// subsumption_queue.size(), trail.size() - bwdsub_assigns);
+		if ((subsumption_queue.size() > 0 || bwdsub_assigns < trail.size())
+		    && !backwardSubsumptionCheck(true)) {
+			ok = false;
+			goto cleanup;
+		}
+
+		// Empty elim_heap and return immediately on user-interrupt:
+		if (asynch_interrupt) {
+			assert(bwdsub_assigns == trail.size());
+			assert(subsumption_queue.size() == 0);
+			assert(n_touched == 0);
+			elim_heap.clear();
+			goto cleanup;
+		}
+
+		// printf("  ## (time = %6.2f s) ELIM: vars = %d\n", cpuTime(), elim_heap.size());
+		for (int cnt = 0; !elim_heap.empty(); cnt++) {
+			Var elim = elim_heap.removeMin();
+
+			if (asynch_interrupt)
+				break;
+
+			if (isEliminated(elim) || value(elim) != l_Undef)
+				continue;
+
+			if (verbosity >= 2 && cnt % 100 == 0)
+				printf("elimination left: %10d\r", elim_heap.size());
+
+			if (use_asymm) {
+				// Temporarily freeze variable. Otherwise, it would immediately end up on the queue again:
+				bool was_frozen = frozen[elim] != 0;
+				frozen[elim] = true;
+				if (!asymmVar(elim)) {
+					ok = false;
+					goto cleanup;
+				}
+				frozen[elim] = was_frozen;
+			}
+
+			// At this point, the variable may have been set by assymetric branching, so
+			// check it again. Also, don't eliminate frozen variables:
+			if (use_elim && value(elim) == l_Undef && !frozen[elim]
+			    && !eliminateVar(elim)) {
+				ok = false;
+				goto cleanup;
+			}
+
+			checkGarbage(simp_garbage_frac);
+		}
+
+		assert(subsumption_queue.size() == 0);
+	}
+cleanup:
+
+	// If no more simplification is needed, free all simplification-related data structures:
+	if (turn_off_elim) {
+		touched.clear(true);
+		occurs.clear(true);
+		n_occ.clear(true);
+		elim_heap.clear(true);
+		subsumption_queue.clear(true);
+
+		use_simplification = false;
+		remove_satisfied = true;
+		ca.extra_clause_field = false;
+
+		// Force full cleanup (this is safe and desirable since it only happens once):
+		rebuildOrderHeap();
+		garbageCollect();
+	} else {
+		// Cheaper cleanup:
+		cleanUpClauses(); // TODO: can we make 'cleanUpClauses()' not be linear in the problem size somehow?
+		checkGarbage();
+	}
+
+	if (verbosity >= 1 && elimclauses.size() > 0)
+		printf("c |  Eliminated clauses:     %10.2f Mb                                     "
+		       "                           |\n",
+		       double(elimclauses.size() * sizeof(uint32_t)) / (1024 * 1024));
+	return ok;
+}
+
+inline void SimpSolver::cleanUpClauses()
+{
+	occurs.cleanAll();
+	int i, j;
+	for (i = j = 0; i < clauses.size(); i++)
+		if (ca[clauses[i]].mark() == 0)
+			clauses[j++] = clauses[i];
+	clauses.shrink(i - j);
+}
+
+//=================================================================================================
+// Garbage Collection methods:
+
+inline void SimpSolver::relocAll(ClauseAllocator& to)
+{
+	int i;
+	if (!use_simplification)
+		return;
+
+	// All occurs lists:
+	//
+	for (i = 0; i < nVars(); i++) {
+		vec<CRef>& cs = occurs[i];
+		for (int j = 0; j < cs.size(); j++)
+			ca.reloc(cs[j], to);
+	}
+
+	// Subsumption queue:
+	//
+	for (i = 0; i < subsumption_queue.size(); i++)
+		ca.reloc(subsumption_queue[i], to);
+
+	// Temporary clause:
+	//
+	ca.reloc(bwdsub_tmpunit, to);
+}
+
+inline void SimpSolver::garbageCollect()
+{
+	// Initialize the next region to a size corresponding to the estimated utilization degree.
+	// This is not precise but should avoid some unnecessary reallocations for the new region:
+	ClauseAllocator to(ca.size() - ca.wasted());
+
+	cleanUpClauses();
+	to.extra_clause_field
+	    = ca.extra_clause_field; // NOTE: this is important to keep (or lose) the extra fields.
+	relocAll(to);
+	Solver::relocAll(to);
+	if (verbosity >= 2)
+		printf("|  Garbage collection:   %12d bytes => %12d bytes             |\n",
+		       ca.size() * ClauseAllocator::Unit_Size,
+		       to.size() * ClauseAllocator::Unit_Size);
+	to.moveTo(ca);
+}
+
+inline void SimpSolver::reset()
+{
+	Solver::reset();
+	grow = 0;
+	asymm_lits = eliminated_vars = bwdsub_assigns = n_touched = 0;
+	elimclauses.clear(false);
+	touched.clear(false);
+	occurs.clear(false);
+	n_occ.clear(false);
+	elim_heap.clear(false);
+	subsumption_queue.clear(false);
+	frozen.clear(false);
+	eliminated.clear(false);
+	vec<Lit> dummy(1, lit_Undef);
+	ca.extra_clause_field = true; // NOTE: must happen before allocating the dummy clause below.
+	bwdsub_tmpunit = ca.alloc(dummy);
+	remove_satisfied = false;
+}
+
+} /* namespace Gluco */
+
+ABC_NAMESPACE_IMPL_END
+
+/*** Glucose.cpp ***/
+
+/***************************************************************************************[Solver.cc]
+ Glucose -- Copyright (c) 2013, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                LRI  - Univ. Paris Sud, France
+
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose are exactly the same as Minisat on which it is based on. (see below).
+
+---------------
+
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#include "abc/Constants.h"
+#include "abc/Solver.h"
+#include "abc/Sort.h"
+#include "abc/system.h"
+
+#include <math.h>
+
+ABC_NAMESPACE_IMPL_START
+
+//=================================================================================================
+// Options:
+
+static const char* _cat = "CORE";
+static const char* _cr = "CORE -- RESTART";
+static const char* _cred = "CORE -- REDUCE";
+static const char* _cm = "CORE -- MINIMIZE";
+static const char* _certified = "CORE -- CERTIFIED UNSAT";
+
+const bool opt_incremental = false;
+const double opt_K = 0.8;
+const double opt_R = 1.4;
+const int opt_size_lbd_queue = 50;
+
+const int opt_first_reduce_db = 2000;
+const int opt_inc_reduce_db = 300;
+const int opt_spec_inc_reduce_db = 1000;
+const int opt_lb_lbd_frozen_clause = 30;
+
+const int opt_lb_size_minimzing_clause = 30;
+const int opt_lb_lbd_minimzing_clause = 6;
+
+const double opt_var_decay = 0.8;
+const double opt_clause_decay = 0.999;
+const double opt_random_var_freq = 0;
+const double opt_random_seed = 91648253;
+const int opt_ccmin_mode = 2;
+const int opt_phase_saving = 2;
+const bool opt_rnd_init_act = false;
+/*
+static IntOption     opt_restart_first     (_cat, "rfirst",      "The base restart interval", 100,
+IntRange(1, INT32_MAX)); static DoubleOption  opt_restart_inc       (_cat, "rinc",        "Restart
+interval increase factor",                                                         2, DoubleRange(1,
+false, HUGE_VAL, false));
+*/
+const double opt_garbage_frac = 0.20;
+
+const bool opt_certified_ = false;
+const char* const opt_certified_file_ = "NULL";
+
+namespace Gluco {
+
+//=================================================================================================
+// Constructor/Destructor:
+
+inline Solver::Solver()
+    :
+
+    // Parameters (user settable):
+    //
+    SolverType(0)
+    , pCnfFunc(NULL)
+    , nCallConfl(1000)
+    , terminate_search_early(false)
+    , pstop(NULL)
+    , nRuntimeLimit(0)
+
+    , verbosity(0)
+    , verbEveryConflicts(10000)
+    , showModel(0)
+    , K(opt_K)
+    , R(opt_R)
+    , sizeLBDQueue(50)
+    , sizeTrailQueue(5000)
+    , firstReduceDB(opt_first_reduce_db)
+    , incReduceDB(opt_inc_reduce_db)
+    , specialIncReduceDB(opt_spec_inc_reduce_db)
+    , lbLBDFrozenClause(opt_lb_lbd_frozen_clause)
+    , lbSizeMinimizingClause(opt_lb_size_minimzing_clause)
+    , lbLBDMinimizingClause(opt_lb_lbd_minimzing_clause)
+    , var_decay(opt_var_decay)
+    , clause_decay(opt_clause_decay)
+    , random_var_freq(opt_random_var_freq)
+    , random_seed(opt_random_seed)
+    , ccmin_mode(opt_ccmin_mode)
+    , phase_saving(opt_phase_saving)
+    , rnd_pol(false)
+    , rnd_init_act(opt_rnd_init_act)
+    , garbage_frac(opt_garbage_frac)
+    , certifiedOutput(NULL)
+    , certifiedUNSAT(opt_certified_)
+    // Statistics: (formerly in 'SolverStats')
+    //
+    , nbRemovedClauses(0)
+    , nbReducedClauses(0)
+    , nbDL2(0)
+    , nbBin(0)
+    , nbUn(0)
+    , nbReduceDB(0)
+    , solves(0)
+    , starts(0)
+    , decisions(0)
+    , rnd_decisions(0)
+    , propagations(0)
+    , conflicts(0)
+    , conflictsRestarts(0)
+    , nbstopsrestarts(0)
+    , nbstopsrestartssame(0)
+    , lastblockatrestart(0)
+    , dec_vars(0)
+    , clauses_literals(0)
+    , learnts_literals(0)
+    , max_literals(0)
+    , tot_literals(0)
+    , curRestart(1)
+
+    , ok(true)
+    , cla_inc(1)
+    , var_inc(1)
+    , watches(WatcherDeleted(ca))
+    , watchesBin(WatcherDeleted(ca))
+    , qhead(0)
+    , simpDB_assigns(-1)
+    , simpDB_props(0)
+    , order_heap(VarOrderLt(activity))
+    , progress_estimate(0)
+    , remove_satisfied(true)
+
+    // Resource constraints:
+    //
+    , conflict_budget(-1)
+    , propagation_budget(-1)
+    , asynch_interrupt(false)
+    , incremental(opt_incremental)
+    , nbVarsInitialFormula(INT32_MAX)
+{
+	MYFLAG = 0;
+	// Initialize only first time. Useful for incremental solving, useless otherwise
+	lbdQueue.initSize(sizeLBDQueue);
+	trailQueue.initSize(sizeTrailQueue);
+	sumLBD = 0;
+	nbclausesbeforereduce = firstReduceDB;
+	totalTime4Sat = 0;
+	totalTime4Unsat = 0;
+	nbSatCalls = 0;
+	nbUnsatCalls = 0;
+
+	if (certifiedUNSAT) {
+		if (!strcmp(opt_certified_file_, "NULL")) {
+			certifiedOutput = fopen("/dev/stdout", "wb");
+		} else {
+			certifiedOutput = fopen(opt_certified_file_, "wb");
+		}
+		//    fprintf(certifiedOutput,"o proof DRUP\n");
+	}
+}
+
+inline Solver::~Solver()
+{}
+
+/****************************************************************
+ Set the incremental mode
+****************************************************************/
+
+// This function set the incremental mode to true.
+// You can add special code for this mode here.
+
+inline void Solver::setIncrementalMode()
+{
+	incremental = true;
+}
+
+// Number of variables without selectors
+inline void Solver::initNbInitialVars(int nb)
+{
+	nbVarsInitialFormula = nb;
+}
+
+//=================================================================================================
+// Minor methods:
+
+// Creates a new SAT variable in the solver. If 'decision' is cleared, variable will not be
+// used as a decision variable (NOTE! This has effects on the meaning of a SATISFIABLE result).
+//
+inline Var Solver::newVar(bool sign, bool dvar)
+{
+	int v = nVars();
+	watches.init(mkLit(v, false));
+	watches.init(mkLit(v, true));
+	watchesBin.init(mkLit(v, false));
+	watchesBin.init(mkLit(v, true));
+	assigns.push(l_Undef);
+	vardata.push(mkVarData(CRef_Undef, 0));
+	// activity .push(0);
+	activity.push(rnd_init_act ? drand(random_seed) * 0.00001 : 0);
+	seen.push(0);
+	permDiff.push(0);
+	polarity.push(sign);
+	decision.push();
+	trail.capacity(v + 1);
+	setDecisionVar(v, dvar);
+	return v;
+}
+
+inline bool Solver::addClause_(vec<Lit>& ps)
+{
+	assert(decisionLevel() == 0);
+	if (!ok)
+		return false;
+
+	if (0) {
+		for (int i = 0; i < ps.size(); i++)
+			printf("%s%d ", (toInt(ps[i]) & 1) ? "-" : "", toInt(ps[i]) >> 1);
+		printf("\n");
+	}
+
+	// Check if clause is satisfied and remove false/duplicate literals:
+	sort(ps);
+
+	vec<Lit> oc;
+	oc.clear();
+
+	Lit p;
+	int i, j, flag = 0;
+	if (certifiedUNSAT) {
+		for (i = j = 0, p = lit_Undef; i < ps.size(); i++) {
+			oc.push(ps[i]);
+			if (value(ps[i]) == l_True || ps[i] == ~p || value(ps[i]) == l_False)
+				flag = 1;
+		}
+	}
+
+	for (i = j = 0, p = lit_Undef; i < ps.size(); i++)
+		if (value(ps[i]) == l_True || ps[i] == ~p)
+			return true;
+		else if (value(ps[i]) != l_False && ps[i] != p)
+			ps[j++] = p = ps[i];
+	ps.shrink(i - j);
+
+	if (0) {
+		for (int i = 0; i < ps.size(); i++)
+			printf("%s%d ", (toInt(ps[i]) & 1) ? "-" : "", toInt(ps[i]) >> 1);
+		printf("\n");
+	}
+
+	if (flag && (certifiedUNSAT)) {
+		for (i = j = 0, p = lit_Undef; i < ps.size(); i++)
+			fprintf(certifiedOutput, "%i ", (var(ps[i]) + 1) * (-2 * sign(ps[i]) + 1));
+		fprintf(certifiedOutput, "0\n");
+
+		fprintf(certifiedOutput, "d ");
+		for (i = j = 0, p = lit_Undef; i < oc.size(); i++)
+			fprintf(certifiedOutput, "%i ", (var(oc[i]) + 1) * (-2 * sign(oc[i]) + 1));
+		fprintf(certifiedOutput, "0\n");
+	}
+
+	if (ps.size() == 0)
+		return ok = false;
+	else if (ps.size() == 1) {
+		uncheckedEnqueue(ps[0]);
+		return ok = (propagate() == CRef_Undef);
+	} else {
+		CRef cr = ca.alloc(ps, false);
+		clauses.push(cr);
+		attachClause(cr);
+	}
+
+	return true;
+}
+
+inline void Solver::attachClause(CRef cr)
+{
+	const Clause& c = ca[cr];
+
+	assert(c.size() > 1);
+	if (c.size() == 2) {
+		watchesBin[~c[0]].push(Watcher(cr, c[1]));
+		watchesBin[~c[1]].push(Watcher(cr, c[0]));
+	} else {
+		watches[~c[0]].push(Watcher(cr, c[1]));
+		watches[~c[1]].push(Watcher(cr, c[0]));
+	}
+	if (c.learnt())
+		learnts_literals += c.size();
+	else
+		clauses_literals += c.size();
+}
+
+inline void Solver::detachClause(CRef cr, bool strict)
+{
+	const Clause& c = ca[cr];
+
+	assert(c.size() > 1);
+	if (c.size() == 2) {
+		if (strict) {
+			remove(watchesBin[~c[0]], Watcher(cr, c[1]));
+			remove(watchesBin[~c[1]], Watcher(cr, c[0]));
+		} else {
+			// Lazy detaching: (NOTE! Must clean all watcher lists before garbage collecting this clause)
+			watchesBin.smudge(~c[0]);
+			watchesBin.smudge(~c[1]);
+		}
+	} else {
+		if (strict) {
+			remove(watches[~c[0]], Watcher(cr, c[1]));
+			remove(watches[~c[1]], Watcher(cr, c[0]));
+		} else {
+			// Lazy detaching: (NOTE! Must clean all watcher lists before garbage collecting this clause)
+			watches.smudge(~c[0]);
+			watches.smudge(~c[1]);
+		}
+	}
+	if (c.learnt())
+		learnts_literals -= c.size();
+	else
+		clauses_literals -= c.size();
+}
+
+inline void Solver::removeClause(CRef cr)
+{
+
+	Clause& c = ca[cr];
+
+	if (certifiedUNSAT) {
+		fprintf(certifiedOutput, "d ");
+		for (int i = 0; i < c.size(); i++)
+			fprintf(certifiedOutput, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+		fprintf(certifiedOutput, "0\n");
+	}
+
+	detachClause(cr);
+	// Don't leave pointers to free'd memory!
+	if (locked(c))
+		vardata[var(c[0])].reason = CRef_Undef;
+	c.mark(1);
+	ca.free_(cr);
+}
+
+inline bool Solver::satisfied(const Clause& c) const
+{
+	if (incremental) // Check clauses with many selectors is too time consuming
+		return (value(c[0]) == l_True) || (value(c[1]) == l_True);
+
+	// Default mode.
+	for (int i = 0; i < c.size(); i++)
+		if (value(c[i]) == l_True)
+			return true;
+	return false;
+}
+
+/************************************************************
+ * Compute LBD functions
+ *************************************************************/
+
+inline unsigned int Solver::computeLBD(const vec<Lit>& lits, int end)
+{
+	int nblevels = 0;
+	MYFLAG++;
+
+	if (incremental) { // ----------------- INCREMENTAL MODE
+		if (end == -1)
+			end = lits.size();
+		unsigned int nbDone = 0;
+		for (int i = 0; i < lits.size(); i++) {
+			if (nbDone >= end)
+				break;
+			if (isSelector(var(lits[i])))
+				continue;
+			nbDone++;
+			int l = level(var(lits[i]));
+			if (permDiff[l] != MYFLAG) {
+				permDiff[l] = MYFLAG;
+				nblevels++;
+			}
+		}
+	} else { // -------- DEFAULT MODE. NOT A LOT OF DIFFERENCES... BUT EASIER TO READ
+		for (int i = 0; i < lits.size(); i++) {
+			int l = level(var(lits[i]));
+			if (permDiff[l] != MYFLAG) {
+				permDiff[l] = MYFLAG;
+				nblevels++;
+			}
+		}
+	}
+
+	return nblevels;
+}
+
+inline unsigned int Solver::computeLBD(const Clause& c)
+{
+	int nblevels = 0;
+	MYFLAG++;
+
+	if (incremental) { // ----------------- INCREMENTAL MODE
+		int nbDone = 0;
+		for (int i = 0; i < c.size(); i++) {
+			if (nbDone >= c.sizeWithoutSelectors())
+				break;
+			if (isSelector(var(c[i])))
+				continue;
+			nbDone++;
+			int l = level(var(c[i]));
+			if (permDiff[l] != MYFLAG) {
+				permDiff[l] = MYFLAG;
+				nblevels++;
+			}
+		}
+	} else { // -------- DEFAULT MODE. NOT A LOT OF DIFFERENCES... BUT EASIER TO READ
+		for (int i = 0; i < c.size(); i++) {
+			int l = level(var(c[i]));
+			if (permDiff[l] != MYFLAG) {
+				permDiff[l] = MYFLAG;
+				nblevels++;
+			}
+		}
+	}
+	return nblevels;
+}
+
+/******************************************************************
+ * Minimisation with binary reolution
+ ******************************************************************/
+inline void Solver::minimisationWithBinaryResolution(vec<Lit>& out_learnt)
+{
+
+	// Find the LBD measure
+	unsigned int lbd = computeLBD(out_learnt);
+	Lit p = ~out_learnt[0];
+
+	if (lbd <= lbLBDMinimizingClause) {
+		MYFLAG++;
+
+		for (int i = 1; i < out_learnt.size(); i++) {
+			permDiff[var(out_learnt[i])] = MYFLAG;
+		}
+
+		vec<Watcher>& wbin = watchesBin[p];
+		int nb = 0;
+		for (int k = 0; k < wbin.size(); k++) {
+			Lit imp = wbin[k].blocker;
+			if (permDiff[var(imp)] == MYFLAG && value(imp) == l_True) {
+				nb++;
+				permDiff[var(imp)] = MYFLAG - 1;
+			}
+		}
+		int l = out_learnt.size() - 1;
+		if (nb > 0) {
+			nbReducedClauses++;
+			for (int i = 1; i < out_learnt.size() - nb; i++) {
+				if (permDiff[var(out_learnt[i])] != MYFLAG) {
+					Lit p = out_learnt[l];
+					out_learnt[l] = out_learnt[i];
+					out_learnt[i] = p;
+					l--;
+					i--;
+				}
+			}
+
+			out_learnt.shrink(nb);
+		}
+	}
+}
+
+// Revert to the state at given level (keeping all assignment at 'level' but not beyond).
+//
+inline void Solver::cancelUntil(int level)
+{
+	if (decisionLevel() > level) {
+		for (int c = trail.size() - 1; c >= trail_lim[level]; c--) {
+			Var x = var(trail[c]);
+			assigns[x] = l_Undef;
+			if (phase_saving > 1 || ((phase_saving == 1) && c > trail_lim.last()))
+				polarity[x] = sign(trail[c]);
+			insertVarOrder(x);
+		}
+		qhead = trail_lim[level];
+		trail.shrink(trail.size() - trail_lim[level]);
+		trail_lim.shrink(trail_lim.size() - level);
+	}
+}
+
+//=================================================================================================
+// Major methods:
+
+inline Lit Solver::pickBranchLit()
+{
+	Var next = var_Undef;
+
+	// Random decision:
+	if (drand(random_seed) < random_var_freq && !order_heap.empty()) {
+		next = order_heap[irand(random_seed, order_heap.size())];
+		if (value(next) == l_Undef && decision[next])
+			rnd_decisions++;
+	}
+
+	// Activity based decision:
+	while (next == var_Undef || value(next) != l_Undef || !decision[next])
+		if (order_heap.empty()) {
+			next = var_Undef;
+			break;
+		} else
+			next = order_heap.removeMin();
+
+	return next == var_Undef ?
+	           lit_Undef :
+	           mkLit(next, rnd_pol ? drand(random_seed) < 0.5 : (polarity[next] != 0));
+}
+
+/*_________________________________________________________________________________________________
+|
+|  analyze : (confl : Clause*) (out_learnt : vec<Lit>&) (out_btlevel : int&)  ->  [void]
+|
+|  Description:
+|    Analyze conflict and produce a reason clause.
+|
+|    Pre-conditions:
+|      * 'out_learnt' is assumed to be cleared.
+|      * Current decision level must be greater than root level.
+|
+|    Post-conditions:
+|      * 'out_learnt[0]' is the asserting literal at level 'out_btlevel'.
+|      * If out_learnt.size() > 1 then 'out_learnt[1]' has the greatest decision level of the
+|        rest of literals. There may be others from the same level though.
+|
+|________________________________________________________________________________________________@*/
+inline void Solver::analyze(CRef confl, vec<Lit>& out_learnt, vec<Lit>& selectors, int& out_btlevel,
+                            unsigned int& lbd, unsigned int& szWithoutSelectors)
+{
+	int pathC = 0;
+	Lit p = lit_Undef;
+
+	// Generate conflict clause:
+	//
+	out_learnt.push(); // (leave room for the asserting literal)
+	int index = trail.size() - 1;
+
+	do {
+		assert(confl != CRef_Undef); // (otherwise should be UIP)
+		Clause& c = ca[confl];
+
+		// Special case for binary clauses
+		// The first one has to be SAT
+		if (p != lit_Undef && c.size() == 2 && value(c[0]) == l_False) {
+
+			assert(value(c[1]) == l_True);
+			Lit tmp = c[0];
+			c[0] = c[1], c[1] = tmp;
+		}
+
+		if (c.learnt())
+			claBumpActivity(c);
+
+#ifdef DYNAMICNBLEVEL
+		// DYNAMIC NBLEVEL trick (see competition'09 companion paper)
+		if (c.learnt() && c.lbd() > 2) {
+			unsigned int nblevels = computeLBD(c);
+			if (nblevels + 1 < c.lbd()) { // improve the LBD
+				if (c.lbd() <= lbLBDFrozenClause) {
+					c.setCanBeDel(false);
+				}
+				// seems to be interesting : keep it for the next round
+				c.setLBD(nblevels); // Update it
+			}
+		}
+#endif
+
+		for (int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++) {
+			Lit q = c[j];
+
+			if (!seen[var(q)] && level(var(q)) > 0) {
+				if (!isSelector(var(q)))
+					varBumpActivity(var(q));
+				seen[var(q)] = 1;
+				if (level(var(q)) >= decisionLevel()) {
+					pathC++;
+#ifdef UPDATEVARACTIVITY
+					// UPDATEVARACTIVITY trick (see competition'09 companion paper)
+					if (!isSelector(var(q)) && (reason(var(q)) != CRef_Undef)
+					    && ca[reason(var(q))].learnt())
+						lastDecisionLevel.push(q);
+#endif
+
+				} else {
+					if (isSelector(var(q))) {
+						assert(value(q) == l_False);
+						selectors.push(q);
+					} else
+						out_learnt.push(q);
+				}
+			}
+		}
+
+		// Select next clause to look at:
+		while (!seen[var(trail[index--])])
+			;
+		p = trail[index + 1];
+		confl = reason(var(p));
+		seen[var(p)] = 0;
+		pathC--;
+
+	} while (pathC > 0);
+	out_learnt[0] = ~p;
+
+	// Simplify conflict clause:
+	//
+	int i, j;
+
+	for (i = 0; i < selectors.size(); i++)
+		out_learnt.push(selectors[i]);
+
+	out_learnt.copyTo(analyze_toclear);
+	if (ccmin_mode == 2) {
+		uint32_t abstract_level = 0;
+		for (i = 1; i < out_learnt.size(); i++)
+			abstract_level |= abstractLevel(var(
+			    out_learnt[i])); // (maintain an abstraction of levels involved in conflict)
+
+		for (i = j = 1; i < out_learnt.size(); i++)
+			if (reason(var(out_learnt[i])) == CRef_Undef
+			    || !litRedundant(out_learnt[i], abstract_level))
+				out_learnt[j++] = out_learnt[i];
+
+	} else if (ccmin_mode == 1) {
+		for (i = j = 1; i < out_learnt.size(); i++) {
+			Var x = var(out_learnt[i]);
+
+			if (reason(x) == CRef_Undef)
+				out_learnt[j++] = out_learnt[i];
+			else {
+				Clause& c = ca[reason(var(out_learnt[i]))];
+				// Thanks to Siert Wieringa for this bug fix!
+				for (int k = ((c.size() == 2) ? 0 : 1); k < c.size(); k++)
+					if (!seen[var(c[k])] && level(var(c[k])) > 0) {
+						out_learnt[j++] = out_learnt[i];
+						break;
+					}
+			}
+		}
+	} else
+		i = j = out_learnt.size();
+
+	max_literals += out_learnt.size();
+	out_learnt.shrink(i - j);
+	tot_literals += out_learnt.size();
+
+	/* ***************************************
+	  Minimisation with binary clauses of the asserting clause
+	  First of all : we look for small clauses
+	  Then, we reduce clauses with small LBD.
+	  Otherwise, this can be useless
+	 */
+	if (!incremental && out_learnt.size() <= lbSizeMinimizingClause) {
+		minimisationWithBinaryResolution(out_learnt);
+	}
+	// Find correct backtrack level:
+	//
+	if (out_learnt.size() == 1)
+		out_btlevel = 0;
+	else {
+		int max_i = 1;
+		// Find the first literal assigned at the next-highest level:
+		for (int i = 2; i < out_learnt.size(); i++)
+			if (level(var(out_learnt[i])) > level(var(out_learnt[max_i])))
+				max_i = i;
+		// Swap-in this literal at index 1:
+		Lit p = out_learnt[max_i];
+		out_learnt[max_i] = out_learnt[1];
+		out_learnt[1] = p;
+		out_btlevel = level(var(p));
+	}
+
+	// Compute the size of the clause without selectors (incremental mode)
+	if (incremental) {
+		szWithoutSelectors = 0;
+		for (int i = 0; i < out_learnt.size(); i++) {
+			if (!isSelector(var((out_learnt[i]))))
+				szWithoutSelectors++;
+			else if (i > 0)
+				break;
+		}
+	} else
+		szWithoutSelectors = out_learnt.size();
+
+	// Compute LBD
+	lbd = computeLBD(out_learnt, out_learnt.size() - selectors.size());
+
+#ifdef UPDATEVARACTIVITY
+	// UPDATEVARACTIVITY trick (see competition'09 companion paper)
+	if (lastDecisionLevel.size() > 0) {
+		for (int i = 0; i < lastDecisionLevel.size(); i++) {
+			if (ca[reason(var(lastDecisionLevel[i]))].lbd() < lbd)
+				varBumpActivity(var(lastDecisionLevel[i]));
+		}
+		lastDecisionLevel.clear();
+	}
+#endif
+
+	for (j = 0; j < analyze_toclear.size(); j++)
+		seen[var(analyze_toclear[j])] = 0; // ('seen[]' is now cleared)
+	for (j = 0; j < selectors.size(); j++)
+		seen[var(selectors[j])] = 0;
+}
+
+// Check if 'p' can be removed. 'abstract_levels' is used to abort early if the algorithm is
+// visiting literals at levels that cannot be removed later.
+inline bool Solver::litRedundant(Lit p, uint32_t abstract_levels)
+{
+	analyze_stack.clear();
+	analyze_stack.push(p);
+	int top = analyze_toclear.size();
+	while (analyze_stack.size() > 0) {
+		assert(reason(var(analyze_stack.last())) != CRef_Undef);
+		Clause& c = ca[reason(var(analyze_stack.last()))];
+		analyze_stack.pop();
+		if (c.size() == 2 && value(c[0]) == l_False) {
+			assert(value(c[1]) == l_True);
+			Lit tmp = c[0];
+			c[0] = c[1], c[1] = tmp;
+		}
+
+		for (int i = 1; i < c.size(); i++) {
+			Lit p = c[i];
+			if (!seen[var(p)] && level(var(p)) > 0) {
+				if (reason(var(p)) != CRef_Undef
+				    && (abstractLevel(var(p)) & abstract_levels) != 0) {
+					seen[var(p)] = 1;
+					analyze_stack.push(p);
+					analyze_toclear.push(p);
+				} else {
+					for (int j = top; j < analyze_toclear.size(); j++)
+						seen[var(analyze_toclear[j])] = 0;
+					analyze_toclear.shrink(analyze_toclear.size() - top);
+					return false;
+				}
+			}
+		}
+	}
+
+	return true;
+}
+
+/*_________________________________________________________________________________________________
+|
+|  analyzeFinal : (p : Lit)  ->  [void]
+|
+|  Description:
+|    Specialized analysis procedure to express the final conflict in terms of assumptions.
+|    Calculates the (possibly empty) set of assumptions that led to the assignment of 'p', and
+|    stores the result in 'out_conflict'.
+|________________________________________________________________________________________________@*/
+inline void Solver::analyzeFinal(Lit p, vec<Lit>& out_conflict)
+{
+	out_conflict.clear();
+	out_conflict.push(p);
+
+	if (decisionLevel() == 0)
+		return;
+
+	seen[var(p)] = 1;
+
+	for (int i = trail.size() - 1; i >= trail_lim[0]; i--) {
+		Var x = var(trail[i]);
+		if (seen[x]) {
+			if (reason(x) == CRef_Undef) {
+				assert(level(x) > 0);
+				out_conflict.push(~trail[i]);
+			} else {
+				Clause& c = ca[reason(x)];
+				//                for (int j = 1; j < c.size(); j++) Minisat (glucose 2.0) loop
+				// Bug in case of assumptions due to special data structures for Binary.
+				// Many thanks to Sam Bayless (sbayless@cs.ubc.ca) for discover this bug.
+				for (int j = ((c.size() == 2) ? 0 : 1); j < c.size(); j++)
+					if (level(var(c[j])) > 0)
+						seen[var(c[j])] = 1;
+			}
+
+			seen[x] = 0;
+		}
+	}
+
+	seen[var(p)] = 0;
+}
+
+inline void Solver::uncheckedEnqueue(Lit p, CRef from)
+{
+	assert(value(p) == l_Undef);
+	assigns[var(p)] = lbool(!sign(p));
+	vardata[var(p)] = mkVarData(from, decisionLevel());
+	trail.push_(p);
+}
+
+/*_________________________________________________________________________________________________
+|
+|  propagate : [void]  ->  [Clause*]
+|
+|  Description:
+|    Propagates all enqueued facts. If a conflict arises, the conflicting clause is returned,
+|    otherwise CRef_Undef.
+|
+|    Post-conditions:
+|      * the propagation queue is empty, even if there was a conflict.
+|________________________________________________________________________________________________@*/
+inline CRef Solver::propagate()
+{
+	CRef confl = CRef_Undef;
+	int num_props = 0;
+	watches.cleanAll();
+	watchesBin.cleanAll();
+	while (qhead < trail.size()) {
+		Lit p = trail[qhead++]; // 'p' is enqueued fact to propagate.
+		vec<Watcher>& ws = watches[p];
+		Watcher *i, *j, *end;
+		num_props++;
+
+		// First, Propagate binary clauses
+		vec<Watcher>& wbin = watchesBin[p];
+		for (int k = 0; k < wbin.size(); k++) {
+			Lit imp = wbin[k].blocker;
+			if (value(imp) == l_False) {
+				return wbin[k].cref;
+			}
+			if (value(imp) == l_Undef) {
+				uncheckedEnqueue(imp, wbin[k].cref);
+			}
+		}
+
+		for (i = j = (Watcher*) ws, end = i + ws.size(); i != end;) {
+			// Try to avoid inspecting the clause:
+			Lit blocker = i->blocker;
+			if (value(blocker) == l_True) {
+				*j++ = *i++;
+				continue;
+			}
+
+			// Make sure the false literal is data[1]:
+			CRef cr = i->cref;
+			Clause& c = ca[cr];
+			Lit false_lit = ~p;
+			if (c[0] == false_lit)
+				c[0] = c[1], c[1] = false_lit;
+			assert(c[1] == false_lit);
+			i++;
+
+			// If 0th watch is true, then clause is already satisfied.
+			Lit first = c[0];
+			Watcher w = Watcher(cr, first);
+			if (first != blocker && value(first) == l_True) {
+				*j++ = w;
+				continue;
+			}
+
+			// Look for new watch:
+			if (incremental) { // ----------------- INCREMENTAL MODE
+				int choosenPos = -1;
+				for (int k = 2; k < c.size(); k++) {
+
+					if (value(c[k]) != l_False) {
+						if (decisionLevel() > assumptions.size()) {
+							choosenPos = k;
+							break;
+						} else {
+							choosenPos = k;
+
+							if (value(c[k]) == l_True
+							    || !isSelector(var(c[k]))) {
+								break;
+							}
+						}
+					}
+				}
+				if (choosenPos != -1) {
+					c[1] = c[choosenPos];
+					c[choosenPos] = false_lit;
+					watches[~c[1]].push(w);
+					goto NextClause;
+				}
+			} else { // ----------------- DEFAULT  MODE (NOT INCREMENTAL)
+				for (int k = 2; k < c.size(); k++) {
+
+					if (value(c[k]) != l_False) {
+						c[1] = c[k];
+						c[k] = false_lit;
+						watches[~c[1]].push(w);
+						goto NextClause;
+					}
+				}
+			}
+
+			// Did not find watch -- clause is unit under assignment:
+			*j++ = w;
+			if (value(first) == l_False) {
+				confl = cr;
+				qhead = trail.size();
+				// Copy the remaining watches:
+				while (i < end)
+					*j++ = *i++;
+			} else {
+				uncheckedEnqueue(first, cr);
+			}
+		NextClause:;
+		}
+		ws.shrink(i - j);
+	}
+	propagations += num_props;
+	simpDB_props -= num_props;
+
+	return confl;
+}
+
+/*_________________________________________________________________________________________________
+|
+|  reduceDB : ()  ->  [void]
+|
+|  Description:
+|    Remove half of the learnt clauses, minus the clauses locked by the current assignment. Locked
+|    clauses are clauses that are reason to some assignment. Binary clauses are never removed.
+|________________________________________________________________________________________________@*/
+struct reduceDB_lt {
+	ClauseAllocator& ca;
+	reduceDB_lt(ClauseAllocator& ca_)
+	    : ca(ca_)
+	{}
+	bool operator()(CRef x, CRef y)
+	{
+
+		// Main criteria... Like in MiniSat we keep all binary clauses
+		if (ca[x].size() > 2 && ca[y].size() == 2)
+			return 1;
+
+		if (ca[y].size() > 2 && ca[x].size() == 2)
+			return 0;
+		if (ca[x].size() == 2 && ca[y].size() == 2)
+			return 0;
+
+		// Second one  based on literal block distance
+		if (ca[x].lbd() > ca[y].lbd())
+			return 1;
+		if (ca[x].lbd() < ca[y].lbd())
+			return 0;
+
+		// Finally we can use old activity or size, we choose the last one
+		return ca[x].activity() < ca[y].activity();
+		// return x->size() < y->size();
+		// return ca[x].size() > 2 && (ca[y].size() == 2 || ca[x].activity() < ca[y].activity()); }
+	}
+};
+
+inline void Solver::reduceDB()
+{
+	int i, j;
+	nbReduceDB++;
+	sort(learnts, reduceDB_lt(ca));
+
+	// We have a lot of "good" clauses, it is difficult to compare them. Keep more !
+	if (ca[learnts[learnts.size() / RATIOREMOVECLAUSES]].lbd() <= 3)
+		nbclausesbeforereduce += specialIncReduceDB;
+	// Useless :-)
+	if (ca[learnts.last()].lbd() <= 5)
+		nbclausesbeforereduce += specialIncReduceDB;
+
+	// Don't delete binary or locked clauses. From the rest, delete clauses from the first half
+	// Keep clauses which seem to be usefull (their lbd was reduce during this sequence)
+
+	int limit = learnts.size() / 2;
+	for (i = j = 0; i < learnts.size(); i++) {
+		Clause& c = ca[learnts[i]];
+		if (c.lbd() > 2 && c.size() > 2 && c.canBeDel() && !locked(c) && (i < limit)) {
+			removeClause(learnts[i]);
+			nbRemovedClauses++;
+		} else {
+			if (!c.canBeDel())
+				limit++;     // we keep c, so we can delete an other clause
+			c.setCanBeDel(true); // At the next step, c can be delete
+			learnts[j++] = learnts[i];
+		}
+	}
+	learnts.shrink(i - j);
+	checkGarbage();
+}
+
+inline void Solver::removeSatisfied(vec<CRef>& cs)
+{
+	int i, j;
+	for (i = j = 0; i < cs.size(); i++) {
+		Clause& c = ca[cs[i]];
+		if (satisfied(c))
+			removeClause(cs[i]);
+		else
+			cs[j++] = cs[i];
+	}
+	cs.shrink(i - j);
+}
+
+inline void Solver::rebuildOrderHeap()
+{
+	vec<Var> vs;
+	for (Var v = 0; v < nVars(); v++)
+		if (decision[v] && value(v) == l_Undef)
+			vs.push(v);
+	order_heap.build(vs);
+}
+
+/*_________________________________________________________________________________________________
+|
+|  simplify : [void]  ->  [bool]
+|
+|  Description:
+|    Simplify the clause database according to the current top-level assigment. Currently, the only
+|    thing done here is the removal of satisfied clauses, but more things can be put here.
+|________________________________________________________________________________________________@*/
+inline bool Solver::simplify()
+{
+	assert(decisionLevel() == 0);
+
+	if (!ok || propagate() != CRef_Undef)
+		return ok = false;
+
+	if (nAssigns() == simpDB_assigns || (simpDB_props > 0))
+		return true;
+
+	// Remove satisfied clauses:
+	removeSatisfied(learnts);
+	if (remove_satisfied) // Can be turned off.
+		removeSatisfied(clauses);
+
+	checkGarbage();
+
+	rebuildOrderHeap();
+
+	simpDB_assigns = nAssigns();
+	simpDB_props = clauses_literals
+	               + learnts_literals; // (shouldn't depend on stats really, but it will do for now)
+
+	return true;
+}
+
+/*_________________________________________________________________________________________________
+|
+|  search : (nof_conflicts : int) (params : const SearchParams&)  ->  [lbool]
+|
+|  Description:
+|    Search for a model the specified number of conflicts.
+|    NOTE! Use negative value for 'nof_conflicts' indicate infinity.
+|
+|  Output:
+|    'l_True' if a partial assigment that is consistent with respect to the clauseset is found. If
+|    all variables are decision variables, this means that the clause set is satisfiable. 'l_False'
+|    if the clause set is unsatisfiable. 'l_Undef' if the bound on number of conflicts is reached.
+|________________________________________________________________________________________________@*/
+inline lbool Solver::search(int nof_conflicts)
+{
+	assert(ok);
+	int backtrack_level;
+	int conflictC = 0;
+	vec<Lit> learnt_clause, selectors;
+	unsigned int nblevels, szWoutSelectors;
+	bool blocked = false;
+	starts++;
+	for (;;) {
+		CRef confl = propagate();
+		if (confl != CRef_Undef) {
+			// CONFLICT
+			conflicts++;
+			conflictC++;
+			conflictsRestarts++;
+			if (conflicts % 5000 == 0 && var_decay < 0.95)
+				var_decay += 0.01;
+
+			if (verbosity >= 1 && conflicts % verbEveryConflicts == 0) {
+				printf("c | %8d   %7d    %5d | %7d %8d %8d | %5d %8d   %6d %8d | "
+				       "%6.3f %% |\n",
+				       (int) starts, (int) nbstopsrestarts,
+				       (int) (conflicts / starts),
+				       (int) dec_vars
+				           - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]),
+				       nClauses(), (int) clauses_literals, (int) nbReduceDB,
+				       nLearnts(), (int) nbDL2, (int) nbRemovedClauses,
+				       progressEstimate() * 100);
+			}
+			if (decisionLevel() == 0) {
+				return l_False;
+			}
+
+			trailQueue.push(trail.size());
+			// BLOCK RESTART (CP 2012 paper)
+			if (conflictsRestarts > LOWER_BOUND_FOR_BLOCKING_RESTART
+			    && lbdQueue.isvalid() && trail.size() > R * trailQueue.getavg()) {
+				lbdQueue.fastclear();
+				nbstopsrestarts++;
+				if (!blocked) {
+					lastblockatrestart = starts;
+					nbstopsrestartssame++;
+					blocked = true;
+				}
+			}
+
+			learnt_clause.clear();
+			selectors.clear();
+			analyze(confl, learnt_clause, selectors, backtrack_level, nblevels,
+			        szWoutSelectors);
+
+			lbdQueue.push(nblevels);
+			sumLBD += nblevels;
+
+			cancelUntil(backtrack_level);
+
+			if (certifiedUNSAT) {
+				for (int i = 0; i < learnt_clause.size(); i++)
+					fprintf(certifiedOutput, "%i ",
+					        (var(learnt_clause[i]) + 1)
+					            * (-2 * sign(learnt_clause[i]) + 1));
+				fprintf(certifiedOutput, "0\n");
+			}
+
+			if (learnt_clause.size() == 1) {
+				uncheckedEnqueue(learnt_clause[0]);
+				nbUn++;
+			} else {
+				CRef cr = ca.alloc(learnt_clause, true);
+				ca[cr].setLBD(nblevels);
+				ca[cr].setSizeWithoutSelectors(szWoutSelectors);
+				if (nblevels <= 2)
+					nbDL2++; // stats
+				if (ca[cr].size() == 2)
+					nbBin++; // stats
+				learnts.push(cr);
+				attachClause(cr);
+
+				claBumpActivity(ca[cr]);
+				uncheckedEnqueue(learnt_clause[0], cr);
+			}
+			varDecayActivity();
+			claDecayActivity();
+
+		} else {
+
+			// Our dynamic restart, see the SAT09 competition compagnion paper
+			if ((conflictsRestarts && lbdQueue.isvalid()
+			     && lbdQueue.getavg() * K > sumLBD / conflictsRestarts)
+			    || (pstop && *pstop)) {
+				lbdQueue.fastclear();
+				progress_estimate = progressEstimate();
+				int bt = 0;
+				if (incremental) { // DO NOT BACKTRACK UNTIL 0.. USELESS
+					bt = (decisionLevel() < assumptions.size()) ?
+					         decisionLevel() :
+					         assumptions.size();
+				}
+				cancelUntil(bt);
+				return l_Undef;
+			}
+
+			// Simplify the set of problem clauses:
+			if (decisionLevel() == 0 && !simplify()) {
+				return l_False;
+			}
+			// Perform clause database reduction !
+			if (conflicts >= curRestart * nbclausesbeforereduce) {
+
+				assert(learnts.size() > 0);
+				curRestart = (conflicts / nbclausesbeforereduce) + 1;
+				reduceDB();
+				nbclausesbeforereduce += incReduceDB;
+			}
+
+			Lit next = lit_Undef;
+			while (decisionLevel() < assumptions.size()) {
+				// Perform user provided assumption:
+				Lit p = assumptions[decisionLevel()];
+				if (value(p) == l_True) {
+					// Dummy decision level:
+					newDecisionLevel();
+				} else if (value(p) == l_False) {
+					analyzeFinal(~p, conflict);
+					return l_False;
+				} else {
+					next = p;
+					break;
+				}
+			}
+
+			if (next == lit_Undef) {
+				// New variable decision:
+				decisions++;
+				next = pickBranchLit();
+
+				if (next == lit_Undef) {
+					// printf("c last restart ## conflicts  :  %d %d
+					// \n",conflictC,decisionLevel());
+					// Model found:
+					return l_True;
+				}
+			}
+
+			// Increase decision level and enqueue 'next'
+			newDecisionLevel();
+			uncheckedEnqueue(next);
+		}
+	}
+}
+
+inline double Solver::progressEstimate() const
+{
+	double progress = 0;
+	double F = 1.0 / nVars();
+
+	for (int i = 0; i <= decisionLevel(); i++) {
+		int beg = i == 0 ? 0 : trail_lim[i - 1];
+		int end = i == decisionLevel() ? trail.size() : trail_lim[i];
+		progress += pow(F, i) * (end - beg);
+	}
+
+	return progress / nVars();
+}
+
+inline void Solver::printIncrementalStats()
+{
+
+	printf("c---------- Glucose Stats -------------------------\n");
+	printf("c restarts              : %lld\n", starts);
+	printf("c nb ReduceDB           : %lld\n", nbReduceDB);
+	printf("c nb removed Clauses    : %lld\n", nbRemovedClauses);
+	printf("c nb learnts DL2        : %lld\n", nbDL2);
+	printf("c nb learnts size 2     : %lld\n", nbBin);
+	printf("c nb learnts size 1     : %lld\n", nbUn);
+
+	printf("c conflicts             : %lld\n", conflicts);
+	printf("c decisions             : %lld\n", decisions);
+	printf("c propagations          : %lld\n", propagations);
+
+	printf("c SAT Calls             : %d in %g seconds\n", nbSatCalls, totalTime4Sat);
+	printf("c UNSAT Calls           : %d in %g seconds\n", nbUnsatCalls, totalTime4Unsat);
+	printf("c--------------------------------------------------\n");
+}
+
+// NOTE: assumptions passed in member-variable 'assumptions'.
+inline lbool Solver::solve_()
+{
+
+	if (incremental && certifiedUNSAT) {
+		printf("Can not use incremental and certified unsat in the same time\n");
+		exit(-1);
+	}
+	model.clear();
+	conflict.clear();
+	if (!ok)
+		return l_False;
+	double curTime = cpuTime();
+
+	solves++;
+
+	lbool status = l_Undef;
+	if (!incremental && verbosity >= 1) {
+		printf("c ========================================[ MAGIC CONSTANTS "
+		       "]==============================================\n");
+		printf("c | Constants are supposed to work well together :-)                       "
+		       "                               |\n");
+		printf("c | however, if you find better choices, please let us known...            "
+		       "                               |\n");
+		printf("c "
+		       "|--------------------------------------------------------------------------"
+		       "-----------------------------|\n");
+		printf("c |                                |                                |      "
+		       "                               |\n");
+		printf("c | - Restarts:                    | - Reduce Clause DB:            | - "
+		       "Minimize Asserting:               |\n");
+		printf("c |   * LBD Queue    : %6d      |   * First     : %6d         |    * size "
+		       "< %3d                     |\n",
+		       lbdQueue.maxSize(), nbclausesbeforereduce, lbSizeMinimizingClause);
+		printf("c |   * Trail  Queue : %6d      |   * Inc       : %6d         |    * lbd  "
+		       "< %3d                     |\n",
+		       trailQueue.maxSize(), incReduceDB, lbLBDMinimizingClause);
+		printf("c |   * K            : %6.2f      |   * Special   : %6d         |          "
+		       "                           |\n",
+		       K, specialIncReduceDB);
+		printf("c |   * R            : %6.2f      |   * Protected :  (lbd)< %2d     |      "
+		       "                               |\n",
+		       R, lbLBDFrozenClause);
+		printf("c |                                |                                |      "
+		       "                               |\n");
+		printf("c ==================================[ Search Statistics (every %6d "
+		       "conflicts) ]=========================\n",
+		       verbEveryConflicts);
+		printf("c |                                                                        "
+		       "                               |\n");
+
+		printf("c |          RESTARTS           |          ORIGINAL         |              "
+		       "LEARNT              | Progress |\n");
+		printf("c |       NB   Blocked  Avg Cfc |    Vars  Clauses Literals |   Red   "
+		       "Learnts    LBD2  Removed |          |\n");
+		printf("c "
+		       "==========================================================================="
+		       "==============================\n");
+	}
+
+	// Search:
+	int curr_restarts = 0;
+	while (status == l_Undef) {
+		status = search(0); // the parameter is useless in glucose, kept to allow modifications
+		if (!withinBudget() || terminate_search_early || (pstop && *pstop))
+			break;
+		if (nRuntimeLimit && Abc_Clock() > nRuntimeLimit)
+			break;
+		curr_restarts++;
+	}
+
+	if (!incremental && verbosity >= 1)
+		printf("c "
+		       "==========================================================================="
+		       "==============================\n");
+
+	if (certifiedUNSAT) { // Want certified output
+		if (status == l_False)
+			fprintf(certifiedOutput, "0\n");
+		fclose(certifiedOutput);
+	}
+
+	if (status == l_True) {
+		// Extend & copy model:
+		model.growTo(nVars());
+		for (int i = 0; i < nVars(); i++)
+			model[i] = value(i);
+	} else if (status == l_False && conflict.size() == 0)
+		ok = false;
+
+	cancelUntil(0);
+
+	double finalTime = cpuTime();
+	if (status == l_True) {
+		nbSatCalls++;
+		totalTime4Sat += (finalTime - curTime);
+	}
+	if (status == l_False) {
+		nbUnsatCalls++;
+		totalTime4Unsat += (finalTime - curTime);
+	}
+
+	// ABC callback
+	if (pCnfFunc
+	    && !terminate_search_early) { // hack to avoid calling callback twise if the solver was terminated early
+		int* pCex = NULL;
+		int message = (status == l_True ? 1 : status == l_False ? 0 : -1);
+		if (status == l_True) {
+			pCex = new int[nVars()];
+			for (int i = 0; i < nVars(); i++)
+				pCex[i] = (model[i] == l_True);
+		}
+
+		int callback_result = pCnfFunc(pCnfMan, message, pCex);
+		assert(callback_result == 0);
+	} else if (pCnfFunc)
+		terminate_search_early = false; // for next run
+
+	return status;
+}
+
+//=================================================================================================
+// Writing CNF to DIMACS:
+//
+// FIXME: this needs to be rewritten completely.
+
+static Var mapVar(Var x, vec<Var>& map, Var& max)
+{
+	if (map.size() <= x || map[x] == -1) {
+		map.growTo(x + 1, -1);
+		map[x] = max++;
+	}
+	return map[x];
+}
+
+inline void Solver::toDimacs(FILE* f, Clause& c, vec<Var>& map, Var& max)
+{
+	if (satisfied(c))
+		return;
+
+	for (int i = 0; i < c.size(); i++)
+		if (value(c[i]) != l_False)
+			fprintf(f, "%s%d ", sign(c[i]) ? "-" : "", mapVar(var(c[i]), map, max) + 1);
+	fprintf(f, "0\n");
+}
+
+inline void Solver::toDimacs(const char* file, const vec<Lit>& assumps)
+{
+	FILE* f = fopen(file, "wr");
+	if (f == NULL)
+		fprintf(stderr, "could not open file %s\n", file), exit(1);
+	toDimacs(f, assumps);
+	fclose(f);
+}
+
+inline void Solver::toDimacs(FILE* f, const vec<Lit>& assumps)
+{
+	// Handle case when solver is in contradictory state:
+	if (!ok) {
+		fprintf(f, "p cnf 1 2\n1 0\n-1 0\n");
+		return;
+	}
+
+	vec<Var> map;
+	Var max = 0;
+
+	// Cannot use removeClauses here because it is not safe
+	// to deallocate them at this point. Could be improved.
+	int i, cnt = 0;
+	for (i = 0; i < clauses.size(); i++)
+		if (!satisfied(ca[clauses[i]]))
+			cnt++;
+
+	for (i = 0; i < clauses.size(); i++)
+		if (!satisfied(ca[clauses[i]])) {
+			Clause& c = ca[clauses[i]];
+			for (int j = 0; j < c.size(); j++)
+				if (value(c[j]) != l_False)
+					mapVar(var(c[j]), map, max);
+		}
+
+	// Assumptions are added as unit clauses:
+	cnt += assumptions.size();
+
+	fprintf(f, "p cnf %d %d\n", max, cnt);
+
+	for (i = 0; i < assumptions.size(); i++) {
+		assert(value(assumptions[i]) != l_False);
+		fprintf(f, "%s%d 0\n", sign(assumptions[i]) ? "-" : "",
+		        mapVar(var(assumptions[i]), map, max) + 1);
+	}
+
+	for (i = 0; i < clauses.size(); i++)
+		toDimacs(f, ca[clauses[i]], map, max);
+
+	if (verbosity > 0)
+		printf("Wrote %d clauses with %d variables.\n", cnt, max);
+}
+
+//=================================================================================================
+// Garbage Collection methods:
+
+inline void Solver::relocAll(ClauseAllocator& to)
+{
+	int v, s, i, j;
+	// All watchers:
+	//
+	// for (int i = 0; i < watches.size(); i++)
+	watches.cleanAll();
+	watchesBin.cleanAll();
+	for (v = 0; v < nVars(); v++)
+		for (s = 0; s < 2; s++) {
+			Lit p = mkLit(v, s != 0);
+			// printf(" >>> RELOCING: %s%d\n", sign(p)?"-":"", var(p)+1);
+			vec<Watcher>& ws = watches[p];
+			for (j = 0; j < ws.size(); j++)
+				ca.reloc(ws[j].cref, to);
+			vec<Watcher>& ws2 = watchesBin[p];
+			for (j = 0; j < ws2.size(); j++)
+				ca.reloc(ws2[j].cref, to);
+		}
+
+	// All reasons:
+	//
+	for (i = 0; i < trail.size(); i++) {
+		Var v = var(trail[i]);
+
+		if (reason(v) != CRef_Undef && (ca[reason(v)].reloced() || locked(ca[reason(v)])))
+			ca.reloc(vardata[v].reason, to);
+	}
+
+	// All learnt:
+	//
+	for (i = 0; i < learnts.size(); i++)
+		ca.reloc(learnts[i], to);
+
+	// All original:
+	//
+	for (i = 0; i < clauses.size(); i++)
+		ca.reloc(clauses[i], to);
+}
+
+inline void Solver::garbageCollect()
+{
+	// Initialize the next region to a size corresponding to the estimated utilization degree.
+	// This is not precise but should avoid some unnecessary reallocations for the new region:
+	ClauseAllocator to(ca.size() - ca.wasted());
+
+	relocAll(to);
+	if (verbosity >= 2)
+		printf("|  Garbage collection:   %12d bytes => %12d bytes             |\n",
+		       ca.size() * ClauseAllocator::Unit_Size,
+		       to.size() * ClauseAllocator::Unit_Size);
+	to.moveTo(ca);
+}
+
+inline void Solver::reset()
+{
+	// Reset everything
+	ok = true;
+	K = (double) opt_K;
+	R = (double) opt_R;
+	firstReduceDB = opt_first_reduce_db;
+	var_decay = (double) opt_var_decay;
+	// max_var_decay = opt_max_var_decay;
+	solves = starts = decisions = propagations = conflicts = conflictsRestarts = 0;
+	curRestart = 1;
+	cla_inc = var_inc = 1;
+	watches.clear(false); // We don't free the memory, new calls should be of the same size order.
+	watchesBin.clear(false);
+	// unaryWatches.clear(false);
+	qhead = 0;
+	simpDB_assigns = -1;
+	simpDB_props = 0;
+	order_heap.clear(false);
+	progress_estimate = 0;
+	// lastLearntClause = CRef_Undef;
+	conflict_budget = -1;
+	propagation_budget = -1;
+	nbVarsInitialFormula = INT32_MAX;
+	totalTime4Sat = 0.;
+	totalTime4Unsat = 0.;
+	nbSatCalls = nbUnsatCalls = 0;
+	MYFLAG = 0;
+	lbdQueue.clear(false);
+	lbdQueue.initSize(sizeLBDQueue);
+	trailQueue.clear(false);
+	trailQueue.initSize(sizeTrailQueue);
+	sumLBD = 0;
+	nbclausesbeforereduce = firstReduceDB;
+	// stats.clear();
+	// stats.growTo(coreStatsSize, 0);
+	clauses.clear(false);
+	learnts.clear(false);
+	// permanentLearnts.clear(false);
+	// unaryWatchedClauses.clear(false);
+	model.clear(false);
+	conflict.clear(false);
+	activity.clear(false);
+	assigns.clear(false);
+	polarity.clear(false);
+	// forceUNSAT.clear(false);
+	decision.clear(false);
+	trail.clear(false);
+	nbpos.clear(false);
+	trail_lim.clear(false);
+	vardata.clear(false);
+	assumptions.clear(false);
+	permDiff.clear(false);
+	lastDecisionLevel.clear(false);
+	ca.clear();
+	seen.clear(false);
+	analyze_stack.clear(false);
+	analyze_toclear.clear(false);
+	add_tmp.clear(false);
+	assumptionPositions.clear(false);
+	initialPositions.clear(false);
+}
+
+} /* namespace Gluco */
+
+ABC_NAMESPACE_IMPL_END
+
+/*** AbcGlucose.cpp */
+
+/**CFile****************************************************************
+
+  FileName    [AbcGlucose.cpp]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SAT solver Glucose 3.0 by Gilles Audemard and Laurent Simon.]
+
+  Synopsis    [Interface to Glucose.]
+
+  Author      [Alan Mishchenko]
+
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - September 6, 2017.]
+
+  Revision    [$Id: AbcGlucose.cpp,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "abc/AbcGlucose.h"
+#include "abc/Dimacs.h"
+#include "abc/SimpSolver.h"
+#include "abc/abc_global.h"
+#include "abc/system.h"
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+#define USE_SIMP_SOLVER 1
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+#ifdef USE_SIMP_SOLVER
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline Gluco::SimpSolver* glucose_solver_start()
+{
+	Gluco::SimpSolver* S = new Gluco::SimpSolver;
+	S->setIncrementalMode();
+	return S;
+}
+
+inline void glucose_solver_stop(Gluco::SimpSolver* S)
+{
+	delete S;
+}
+
+inline void glucose_solver_reset(Gluco::SimpSolver* S)
+{
+	S->reset();
+}
+
+inline int glucose_solver_addclause(Gluco::SimpSolver* S, int* plits, int nlits)
+{
+	Gluco::vec<Gluco::Lit> lits;
+	for (int i = 0; i < nlits; i++, plits++) {
+		// note: Glucose uses the same var->lit conventiaon as ABC
+		while ((*plits) / 2 >= S->nVars())
+			S->newVar();
+		assert((*plits) / 2
+		       < S->nVars()); // NOTE: since we explicitely use new function bmc_add_var
+		Gluco::Lit p;
+		p.x = *plits;
+		lits.push(p);
+	}
+	return S->addClause(lits); // returns 0 if the problem is UNSAT
+}
+
+inline void glucose_solver_setcallback(Gluco::SimpSolver* S, void* pman,
+                                       int (*pfunc)(void*, int, int*))
+{
+	S->pCnfMan = pman;
+	S->pCnfFunc = pfunc;
+	S->nCallConfl = 1000;
+}
+
+inline int glucose_solver_solve(Gluco::SimpSolver* S, int* plits, int nlits)
+{
+	Gluco::vec<Gluco::Lit> lits;
+	for (int i = 0; i < nlits; i++, plits++) {
+		Gluco::Lit p;
+		p.x = *plits;
+		lits.push(p);
+	}
+	Gluco::lbool res = S->solveLimited(lits, 0);
+	return (res == Gluco::l_True ? 1 : res == Gluco::l_False ? -1 : 0);
+}
+
+inline int glucose_solver_addvar(Gluco::SimpSolver* S)
+{
+	S->newVar();
+	return S->nVars() - 1;
+}
+
+inline int glucose_solver_read_cex_varvalue(Gluco::SimpSolver* S, int ivar)
+{
+	return S->model[ivar] == Gluco::l_True;
+}
+
+inline void glucose_solver_setstop(Gluco::SimpSolver* S, int* pstop)
+{
+	S->pstop = pstop;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Wrapper APIs to calling from ABC.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline bmcg_sat_solver* bmcg_sat_solver_start()
+{
+	return (bmcg_sat_solver*) glucose_solver_start();
+}
+inline void bmcg_sat_solver_stop(bmcg_sat_solver* s)
+{
+	glucose_solver_stop((Gluco::SimpSolver*) s);
+}
+inline void bmcg_sat_solver_reset(bmcg_sat_solver* s)
+{
+	glucose_solver_reset((Gluco::SimpSolver*) s);
+}
+
+inline int bmcg_sat_solver_addclause(bmcg_sat_solver* s, int* plits, int nlits)
+{
+	return glucose_solver_addclause((Gluco::SimpSolver*) s, plits, nlits);
+}
+
+inline void bmcg_sat_solver_setcallback(bmcg_sat_solver* s, void* pman,
+                                        int (*pfunc)(void*, int, int*))
+{
+	glucose_solver_setcallback((Gluco::SimpSolver*) s, pman, pfunc);
+}
+
+inline int bmcg_sat_solver_solve(bmcg_sat_solver* s, int* plits, int nlits)
+{
+	return glucose_solver_solve((Gluco::SimpSolver*) s, plits, nlits);
+}
+
+inline int bmcg_sat_solver_final(bmcg_sat_solver* s, int** ppArray)
+{
+	*ppArray = (int*) (Gluco::Lit*) ((Gluco::SimpSolver*) s)->conflict;
+	return ((Gluco::SimpSolver*) s)->conflict.size();
+}
+
+inline int bmcg_sat_solver_addvar(bmcg_sat_solver* s)
+{
+	return glucose_solver_addvar((Gluco::SimpSolver*) s);
+}
+
+inline void bmcg_sat_solver_set_nvars(bmcg_sat_solver* s, int nvars)
+{
+	int i;
+	for (i = bmcg_sat_solver_varnum(s); i < nvars; i++)
+		bmcg_sat_solver_addvar(s);
+}
+
+inline int bmcg_sat_solver_eliminate(bmcg_sat_solver* s, int turn_off_elim)
+{
+	//    return 1;
+	return ((Gluco::SimpSolver*) s)->eliminate(turn_off_elim != 0);
+}
+
+inline int bmcg_sat_solver_var_is_elim(bmcg_sat_solver* s, int v)
+{
+	//    return 0;
+	return ((Gluco::SimpSolver*) s)->isEliminated(v);
+}
+
+inline void bmcg_sat_solver_var_set_frozen(bmcg_sat_solver* s, int v, int freeze)
+{
+	((Gluco::SimpSolver*) s)->setFrozen(v, freeze != 0);
+}
+
+inline int bmcg_sat_solver_elim_varnum(bmcg_sat_solver* s)
+{
+	//    return 0;
+	return ((Gluco::SimpSolver*) s)->eliminated_vars;
+}
+
+inline int bmcg_sat_solver_read_cex_varvalue(bmcg_sat_solver* s, int ivar)
+{
+	return glucose_solver_read_cex_varvalue((Gluco::SimpSolver*) s, ivar);
+}
+
+inline void bmcg_sat_solver_set_stop(bmcg_sat_solver* s, int* pstop)
+{
+	glucose_solver_setstop((Gluco::SimpSolver*) s, pstop);
+}
+
+inline abctime bmcg_sat_solver_set_runtime_limit(bmcg_sat_solver* s, abctime Limit)
+{
+	abctime nRuntimeLimit = ((Gluco::SimpSolver*) s)->nRuntimeLimit;
+	((Gluco::SimpSolver*) s)->nRuntimeLimit = Limit;
+	return nRuntimeLimit;
+}
+
+inline void bmcg_sat_solver_set_conflict_budget(bmcg_sat_solver* s, int Limit)
+{
+	if (Limit > 0)
+		((Gluco::SimpSolver*) s)->setConfBudget((int64_t) Limit);
+	else
+		((Gluco::SimpSolver*) s)->budgetOff();
+}
+
+inline int bmcg_sat_solver_varnum(bmcg_sat_solver* s)
+{
+	return ((Gluco::SimpSolver*) s)->nVars();
+}
+inline int bmcg_sat_solver_clausenum(bmcg_sat_solver* s)
+{
+	return ((Gluco::SimpSolver*) s)->nClauses();
+}
+inline int bmcg_sat_solver_learntnum(bmcg_sat_solver* s)
+{
+	return ((Gluco::SimpSolver*) s)->nLearnts();
+}
+inline int bmcg_sat_solver_conflictnum(bmcg_sat_solver* s)
+{
+	return ((Gluco::SimpSolver*) s)->conflicts;
+}
+
+inline int bmcg_sat_solver_minimize_assumptions(bmcg_sat_solver* s, int* plits, int nlits, int pivot)
+{
+	Gluco::vec<int>* array = &((Gluco::SimpSolver*) s)->user_vec;
+	int i, nlitsL, nlitsR, nresL, nresR, status;
+	assert(pivot >= 0);
+	//    assert( nlits - pivot >= 2 );
+	assert(nlits - pivot >= 1);
+	if (nlits - pivot == 1) {
+		// since the problem is UNSAT, we try to solve it without assuming the last literal
+		// if the result is UNSAT, the last literal can be dropped; otherwise, it is needed
+		status = bmcg_sat_solver_solve(s, plits, pivot);
+		return status != GLUCOSE_UNSAT; // return 1 if the problem is not UNSAT
+	}
+	assert(nlits - pivot >= 2);
+	nlitsL = (nlits - pivot) / 2;
+	nlitsR = (nlits - pivot) - nlitsL;
+	assert(nlitsL + nlitsR == nlits - pivot);
+	// solve with these assumptions
+	status = bmcg_sat_solver_solve(s, plits, pivot + nlitsL);
+	if (status == GLUCOSE_UNSAT) // these are enough
+		return bmcg_sat_solver_minimize_assumptions(s, plits, pivot + nlitsL, pivot);
+	// these are not enough
+	// solve for the right lits
+	//    nResL = nLitsR == 1 ? 1 : sat_solver_minimize_assumptions( s, pLits + nLitsL, nLitsR, nConfLimit );
+	nresL = nlitsR == 1 ? 1 :
+	                      bmcg_sat_solver_minimize_assumptions(s, plits, nlits, pivot + nlitsL);
+	// swap literals
+	array->clear();
+	for (i = 0; i < nlitsL; i++)
+		array->push(plits[pivot + i]);
+	for (i = 0; i < nresL; i++)
+		plits[pivot + i] = plits[pivot + nlitsL + i];
+	for (i = 0; i < nlitsL; i++)
+		plits[pivot + nresL + i] = (*array)[i];
+	// solve with these assumptions
+	status = bmcg_sat_solver_solve(s, plits, pivot + nresL);
+	if (status == GLUCOSE_UNSAT) // these are enough
+		return nresL;
+	// solve for the left lits
+	//    nResR = nLitsL == 1 ? 1 : sat_solver_minimize_assumptions( s, pLits + nResL, nLitsL, nConfLimit );
+	nresR = nlitsL == 1 ? 1 :
+	                      bmcg_sat_solver_minimize_assumptions(s, plits, pivot + nresL + nlitsL,
+	                                                           pivot + nresL);
+	return nresL + nresR;
+}
+
+inline int bmcg_sat_solver_add_and(bmcg_sat_solver* s, int iVar, int iVar0, int iVar1, int fCompl0,
+                                   int fCompl1, int fCompl)
+{
+	int Lits[3];
+
+	Lits[0] = Abc_Var2Lit(iVar, !fCompl);
+	Lits[1] = Abc_Var2Lit(iVar0, fCompl0);
+	if (!bmcg_sat_solver_addclause(s, Lits, 2))
+		return 0;
+
+	Lits[0] = Abc_Var2Lit(iVar, !fCompl);
+	Lits[1] = Abc_Var2Lit(iVar1, fCompl1);
+	if (!bmcg_sat_solver_addclause(s, Lits, 2))
+		return 0;
+
+	Lits[0] = Abc_Var2Lit(iVar, fCompl);
+	Lits[1] = Abc_Var2Lit(iVar0, !fCompl0);
+	Lits[2] = Abc_Var2Lit(iVar1, !fCompl1);
+	if (!bmcg_sat_solver_addclause(s, Lits, 3))
+		return 0;
+
+	return 1;
+}
+
+#else
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline Gluco::Solver* glucose_solver_start()
+{
+	Gluco::Solver* S = new Gluco::Solver;
+	S->setIncrementalMode();
+	return S;
+}
+
+inline void glucose_solver_stop(Gluco::Solver* S)
+{
+	delete S;
+}
+
+inline int glucose_solver_addclause(Gluco::Solver* S, int* plits, int nlits)
+{
+	Gluco::vec<Gluco::Lit> lits;
+	for (int i = 0; i < nlits; i++, plits++) {
+		// note: Glucose uses the same var->lit conventiaon as ABC
+		while ((*plits) / 2 >= S->nVars())
+			S->newVar();
+		assert((*plits) / 2
+		       < S->nVars()); // NOTE: since we explicitely use new function bmc_add_var
+		Gluco::Lit p;
+		p.x = *plits;
+		lits.push(p);
+	}
+	return S->addClause(lits); // returns 0 if the problem is UNSAT
+}
+
+inline void glucose_solver_setcallback(Gluco::Solver* S, void* pman, int (*pfunc)(void*, int, int*))
+{
+	S->pCnfMan = pman;
+	S->pCnfFunc = pfunc;
+	S->nCallConfl = 1000;
+}
+
+inline int glucose_solver_solve(Gluco::Solver* S, int* plits, int nlits)
+{
+	vec<Lit> lits;
+	for (int i = 0; i < nlits; i++, plits++) {
+		Lit p;
+		p.x = *plits;
+		lits.push(p);
+	}
+	Gluco::lbool res = S->solveLimited(lits);
+	return (res == l_True ? 1 : res == l_False ? -1 : 0);
+}
+
+inline int glucose_solver_addvar(Gluco::Solver* S)
+{
+	S->newVar();
+	return S->nVars() - 1;
+}
+
+inline int glucose_solver_read_cex_varvalue(Gluco::Solver* S, int ivar)
+{
+	return S->model[ivar] == l_True;
+}
+
+inline void glucose_solver_setstop(Gluco::Solver* S, int* pstop)
+{
+	S->pstop = pstop;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Wrapper APIs to calling from ABC.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline bmcg_sat_solver* bmcg_sat_solver_start()
+{
+	return (bmcg_sat_solver*) glucose_solver_start();
+}
+inline void bmcg_sat_solver_stop(bmcg_sat_solver* s)
+{
+	glucose_solver_stop((Gluco::Solver*) s);
+}
+
+inline int bmcg_sat_solver_addclause(bmcg_sat_solver* s, int* plits, int nlits)
+{
+	return glucose_solver_addclause((Gluco::Solver*) s, plits, nlits);
+}
+
+inline void bmcg_sat_solver_setcallback(bmcg_sat_solver* s, void* pman,
+                                        int (*pfunc)(void*, int, int*))
+{
+	glucose_solver_setcallback((Gluco::Solver*) s, pman, pfunc);
+}
+
+inline int bmcg_sat_solver_solve(bmcg_sat_solver* s, int* plits, int nlits)
+{
+	return glucose_solver_solve((Gluco::Solver*) s, plits, nlits);
+}
+
+inline int bmcg_sat_solver_final(bmcg_sat_solver* s, int** ppArray)
+{
+	*ppArray = (int*) (Lit*) ((Gluco::Solver*) s)->conflict;
+	return ((Gluco::Solver*) s)->conflict.size();
+}
+
+inline int bmcg_sat_solver_addvar(bmcg_sat_solver* s)
+{
+	return glucose_solver_addvar((Gluco::Solver*) s);
+}
+
+inline void bmcg_sat_solver_set_nvars(bmcg_sat_solver* s, int nvars)
+{
+	int i;
+	for (i = bmcg_sat_solver_varnum(s); i < nvars; i++)
+		bmcg_sat_solver_addvar(s);
+}
+
+inline int bmcg_sat_solver_eliminate(bmcg_sat_solver* s, int turn_off_elim)
+{
+	return 1;
+	//    return ((Gluco::SimpSolver*)s)->eliminate(turn_off_elim != 0);
+}
+
+inline int bmcg_sat_solver_var_is_elim(bmcg_sat_solver* s, int v)
+{
+	return 0;
+	//    return ((Gluco::SimpSolver*)s)->isEliminated(v);
+}
+
+inline void bmcg_sat_solver_var_set_frozen(bmcg_sat_solver* s, int v, int freeze)
+{
+	//    ((Gluco::SimpSolver*)s)->setFrozen(v, freeze);
+}
+
+inline int bmcg_sat_solver_elim_varnum(bmcg_sat_solver* s)
+{
+	return 0;
+	//    return ((Gluco::SimpSolver*)s)->eliminated_vars;
+}
+
+inline int bmcg_sat_solver_read_cex_varvalue(bmcg_sat_solver* s, int ivar)
+{
+	return glucose_solver_read_cex_varvalue((Gluco::Solver*) s, ivar);
+}
+
+inline void bmcg_sat_solver_set_stop(bmcg_sat_solver* s, int* pstop)
+{
+	glucose_solver_setstop((Gluco::Solver*) s, pstop);
+}
+
+inline abctime bmcg_sat_solver_set_runtime_limit(bmcg_sat_solver* s, abctime Limit)
+{
+	abctime nRuntimeLimit = ((Gluco::Solver*) s)->nRuntimeLimit;
+	((Gluco::Solver*) s)->nRuntimeLimit = Limit;
+	return nRuntimeLimit;
+}
+
+inline void bmcg_sat_solver_set_conflict_budget(bmcg_sat_solver* s, int Limit)
+{
+	if (Limit > 0)
+		((Gluco::Solver*) s)->setConfBudget((int64_t) Limit);
+	else
+		((Gluco::Solver*) s)->budgetOff();
+}
+
+inline int bmcg_sat_solver_varnum(bmcg_sat_solver* s)
+{
+	return ((Gluco::Solver*) s)->nVars();
+}
+inline int bmcg_sat_solver_clausenum(bmcg_sat_solver* s)
+{
+	return ((Gluco::Solver*) s)->nClauses();
+}
+inline int bmcg_sat_solver_learntnum(bmcg_sat_solver* s)
+{
+	return ((Gluco::Solver*) s)->nLearnts();
+}
+inline int bmcg_sat_solver_conflictnum(bmcg_sat_solver* s)
+{
+	return ((Gluco::Solver*) s)->conflicts;
+}
+
+inline int bmcg_sat_solver_minimize_assumptions(bmcg_sat_solver* s, int* plits, int nlits, int pivot)
+{
+	vec<int>* array = &((Gluco::Solver*) s)->user_vec;
+	int i, nlitsL, nlitsR, nresL, nresR, status;
+	assert(pivot >= 0);
+	//    assert( nlits - pivot >= 2 );
+	assert(nlits - pivot >= 1);
+	if (nlits - pivot == 1) {
+		// since the problem is UNSAT, we try to solve it without assuming the last literal
+		// if the result is UNSAT, the last literal can be dropped; otherwise, it is needed
+		status = bmcg_sat_solver_solve(s, plits, pivot);
+		return status != GLUCOSE_UNSAT; // return 1 if the problem is not UNSAT
+	}
+	assert(nlits - pivot >= 2);
+	nlitsL = (nlits - pivot) / 2;
+	nlitsR = (nlits - pivot) - nlitsL;
+	assert(nlitsL + nlitsR == nlits - pivot);
+	// solve with these assumptions
+	status = bmcg_sat_solver_solve(s, plits, pivot + nlitsL);
+	if (status == GLUCOSE_UNSAT) // these are enough
+		return bmcg_sat_solver_minimize_assumptions(s, plits, pivot + nlitsL, pivot);
+	// these are not enough
+	// solve for the right lits
+	//    nResL = nLitsR == 1 ? 1 : sat_solver_minimize_assumptions( s, pLits + nLitsL, nLitsR, nConfLimit );
+	nresL = nlitsR == 1 ? 1 :
+	                      bmcg_sat_solver_minimize_assumptions(s, plits, nlits, pivot + nlitsL);
+	// swap literals
+	array->clear();
+	for (i = 0; i < nlitsL; i++)
+		array->push(plits[pivot + i]);
+	for (i = 0; i < nresL; i++)
+		plits[pivot + i] = plits[pivot + nlitsL + i];
+	for (i = 0; i < nlitsL; i++)
+		plits[pivot + nresL + i] = (*array)[i];
+	// solve with these assumptions
+	status = bmcg_sat_solver_solve(s, plits, pivot + nresL);
+	if (status == GLUCOSE_UNSAT) // these are enough
+		return nresL;
+	// solve for the left lits
+	//    nResR = nLitsL == 1 ? 1 : sat_solver_minimize_assumptions( s, pLits + nResL, nLitsL, nConfLimit );
+	nresR = nlitsL == 1 ? 1 :
+	                      bmcg_sat_solver_minimize_assumptions(s, plits, pivot + nresL + nlitsL,
+	                                                           pivot + nresL);
+	return nresL + nresR;
+}
+
+#endif
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+inline void glucose_print_stats(Gluco::SimpSolver& s, abctime clk)
+{
+	double cpu_time = (double) (unsigned) clk / CLOCKS_PER_SEC;
+	printf("c restarts              : %d (%d conflicts on average)\n", (int) s.starts,
+	       s.starts > 0 ? (int) (s.conflicts / s.starts) : 0);
+	printf("c blocked restarts      : %d (multiple: %d) \n", (int) s.nbstopsrestarts,
+	       (int) s.nbstopsrestartssame);
+	printf("c last block at restart : %d\n", (int) s.lastblockatrestart);
+	printf("c nb ReduceDB           : %-12d\n", (int) s.nbReduceDB);
+	printf("c nb removed Clauses    : %-12d\n", (int) s.nbRemovedClauses);
+	printf("c nb learnts DL2        : %-12d\n", (int) s.nbDL2);
+	printf("c nb learnts size 2     : %-12d\n", (int) s.nbBin);
+	printf("c nb learnts size 1     : %-12d\n", (int) s.nbUn);
+	printf("c conflicts             : %-12d  (%.0f /sec)\n", (int) s.conflicts,
+	       s.conflicts / cpu_time);
+	printf("c decisions             : %-12d  (%4.2f %% random) (%.0f /sec)\n", (int) s.decisions,
+	       (float) s.rnd_decisions * 100 / (float) s.decisions, s.decisions / cpu_time);
+	printf("c propagations          : %-12d  (%.0f /sec)\n", (int) s.propagations,
+	       s.propagations / cpu_time);
+	printf("c conflict literals     : %-12d  (%4.2f %% deleted)\n", (int) s.tot_literals,
+	       (s.max_literals - s.tot_literals) * 100 / (double) s.max_literals);
+	printf("c nb reduced Clauses    : %-12d\n", (int) s.nbReducedClauses);
+	// printf("c CPU time              : %.2f sec\n", cpu_time);
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+ABC_NAMESPACE_IMPL_END
+
+#undef SAT_USE_ANALYZE_FINAL
+#undef L_IND
+#undef L_ind
+#undef L_LIT
+#undef L_lit
+#undef USE_SIMP_SOLVER
diff --git a/lib/bill/bill/sat/solver/abc/AbcGlucose.h b/lib/bill/bill/sat/solver/abc/AbcGlucose.h
new file mode 100644
index 0000000..cc53db4
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/AbcGlucose.h
@@ -0,0 +1,107 @@
+/**CFile****************************************************************
+
+  FileName    [AbcGlucose.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SAT solver Glucose 3.0 by Gilles Audemard and Laurent Simon.]
+
+  Synopsis    [Interface to Glucose.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - September 6, 2017.]
+
+  Revision    [$Id: AbcGlucose.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#ifndef ABC_SAT_GLUCOSE_H_
+#define ABC_SAT_GLUCOSE_H_
+
+#include "abc_global.h"
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+#define GLUCOSE_UNSAT -1
+#define GLUCOSE_SAT    1
+#define GLUCOSE_UNDEC  0
+
+
+ABC_NAMESPACE_HEADER_START
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct Glucose_Pars_ Glucose_Pars;
+struct Glucose_Pars_ {
+    int pre;     // preprocessing
+    int verb;    // verbosity
+    int cust;    // customizable
+    int nConfls; // conflict limit (0 = no limit)
+};
+
+static inline Glucose_Pars Glucose_CreatePars(int p, int v, int c, int nConfls)
+{
+    Glucose_Pars pars;
+    pars.pre     = p;
+    pars.verb    = v;
+    pars.cust    = c;
+    pars.nConfls = nConfls;
+    return pars;
+}
+
+typedef void bmcg_sat_solver;
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                    FUNCTION DECLARATIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+extern bmcg_sat_solver * bmcg_sat_solver_start();
+extern void              bmcg_sat_solver_stop( bmcg_sat_solver* s );
+extern void              bmcg_sat_solver_reset( bmcg_sat_solver* s );
+extern int               bmcg_sat_solver_addclause( bmcg_sat_solver* s, int * plits, int nlits );
+extern void              bmcg_sat_solver_setcallback( bmcg_sat_solver* s, void * pman, int(*pfunc)(void*, int, int*) );
+extern int               bmcg_sat_solver_solve( bmcg_sat_solver* s, int * plits, int nlits );
+extern int               bmcg_sat_solver_final( bmcg_sat_solver* s, int ** ppArray );
+extern int               bmcg_sat_solver_addvar( bmcg_sat_solver* s );
+extern void              bmcg_sat_solver_set_nvars( bmcg_sat_solver* s, int nvars );
+extern int               bmcg_sat_solver_eliminate( bmcg_sat_solver* s, int turn_off_elim );
+extern int               bmcg_sat_solver_var_is_elim( bmcg_sat_solver* s, int v );
+extern void              bmcg_sat_solver_var_set_frozen( bmcg_sat_solver* s, int v, int freeze );
+extern int               bmcg_sat_solver_elim_varnum(bmcg_sat_solver* s);
+extern int               bmcg_sat_solver_read_cex_varvalue( bmcg_sat_solver* s, int );
+extern void              bmcg_sat_solver_set_stop( bmcg_sat_solver* s, int * pstop );
+extern abctime           bmcg_sat_solver_set_runtime_limit( bmcg_sat_solver* s, abctime Limit );
+extern void              bmcg_sat_solver_set_conflict_budget( bmcg_sat_solver* s, int Limit );
+extern int               bmcg_sat_solver_varnum( bmcg_sat_solver* s );
+extern int               bmcg_sat_solver_clausenum( bmcg_sat_solver* s );
+extern int               bmcg_sat_solver_learntnum( bmcg_sat_solver* s );
+extern int               bmcg_sat_solver_conflictnum( bmcg_sat_solver* s );
+extern int               bmcg_sat_solver_minimize_assumptions( bmcg_sat_solver * s, int * plits, int nlits, int pivot );
+extern int               bmcg_sat_solver_add_and( bmcg_sat_solver * s, int iVar, int iVar0, int iVar1, int fCompl0, int fCompl1, int fCompl );
+
+extern void              Glucose_SolveCnf( char * pFilename, Glucose_Pars * pPars );
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
diff --git a/lib/bill/bill/sat/solver/abc/Alg.h b/lib/bill/bill/sat/solver/abc/Alg.h
new file mode 100644
index 0000000..9a93489
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/Alg.h
@@ -0,0 +1,88 @@
+/*******************************************************************************************[Alg.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Abc_Glucose_Alg_h
+#define Abc_Glucose_Alg_h
+
+#include "Vec.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// Useful functions on vector-like types:
+
+//=================================================================================================
+// Removing and searching for elements:
+//
+
+template<class V, class T>
+static inline void remove(V& ts, const T& t)
+{
+    int j = 0;
+    for (; j < ts.size() && ts[j] != t; j++);
+    assert(j < ts.size());
+    for (; j < ts.size()-1; j++) ts[j] = ts[j+1];
+    ts.pop();
+}
+
+
+template<class V, class T>
+static inline bool find(V& ts, const T& t)
+{
+    int j = 0;
+    for (; j < ts.size() && ts[j] != t; j++);
+    return j < ts.size();
+}
+
+
+//=================================================================================================
+// Copying vectors with support for nested vector types:
+//
+
+// Base case:
+template<class T>
+static inline void copy(const T& from, T& to)
+{
+    to = from;
+}
+
+// Recursive case:
+template<class T>
+static inline void copy(const vec<T>& from, vec<T>& to, bool append = false)
+{
+    if (!append)
+        to.clear();
+    for (int i = 0; i < from.size(); i++){
+        to.push();
+        copy(from[i], to.last());
+    }
+}
+
+template<class T>
+static inline void append(const vec<T>& from, vec<T>& to){ copy(from, to, true); }
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/Alloc.h b/lib/bill/bill/sat/solver/abc/Alloc.h
new file mode 100644
index 0000000..fb9f01c
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/Alloc.h
@@ -0,0 +1,136 @@
+/*****************************************************************************************[Alloc.h]
+Copyright (c) 2008-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Abc_Glucose_Alloc_h
+#define Abc_Glucose_Alloc_h
+
+#include "XAlloc.h"
+#include "Vec.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// Simple Region-based memory allocator:
+
+template<class T>
+class RegionAllocator
+{
+    T*        memory;
+    uint32_t  sz;
+    uint32_t  cap;
+    uint32_t  wasted_;
+
+    void capacity(uint32_t min_cap);
+
+ public:
+    // TODO: make this a class for better type-checking?
+    typedef uint32_t Ref;
+    enum { Ref_Undef = UINT32_MAX };
+    enum { Unit_Size = sizeof(uint32_t) };
+
+    explicit RegionAllocator(uint32_t start_cap = 1024*1024) : memory(NULL), sz(0), cap(0), wasted_(0){ capacity(start_cap); }
+    ~RegionAllocator()
+    {
+        if (memory != NULL)
+            ::free(memory);
+    }
+
+
+    uint32_t size      () const      { return sz; }
+    uint32_t wasted    () const      { return wasted_; }
+
+    Ref      alloc     (int size); 
+    void     free_     (int size)    { wasted_ += size; }
+    void     clear     ()            { sz = 0; wasted_=0; }
+
+    // Deref, Load Effective Address (LEA), Inverse of LEA (AEL):
+    T&       operator[](Ref r)       { assert(r >= 0 && r < sz); return memory[r]; }
+    const T& operator[](Ref r) const { assert(r >= 0 && r < sz); return memory[r]; }
+
+    T*       lea       (Ref r)       { assert(r >= 0 && r < sz); return &memory[r]; }
+    const T* lea       (Ref r) const { assert(r >= 0 && r < sz); return &memory[r]; }
+    Ref      ael       (const T* t)  { assert((void*)t >= (void*)&memory[0] && (void*)t < (void*)&memory[sz-1]);
+        return  (Ref)(t - &memory[0]); }
+
+    void     moveTo(RegionAllocator& to) {
+        if (to.memory != NULL) ::free(to.memory);
+        to.memory = memory;
+        to.sz = sz;
+        to.cap = cap;
+        to.wasted_ = wasted_;
+
+        memory = NULL;
+        sz = cap = wasted_ = 0;
+    }
+
+
+};
+
+template<class T>
+void RegionAllocator<T>::capacity(uint32_t min_cap)
+{
+    if (cap >= min_cap) return;
+
+    uint32_t prev_cap = cap;
+    while (cap < min_cap){
+        // NOTE: Multiply by a factor (13/8) without causing overflow, then add 2 and make the
+        // result even by clearing the least significant bit. The resulting sequence of capacities
+        // is carefully chosen to hit a maximum capacity that is close to the '2^32-1' limit when
+        // using 'uint32_t' as indices so that as much as possible of this space can be used.
+        uint32_t delta = ((cap >> 1) + (cap >> 3) + 2) & ~1;
+        cap += delta;
+
+        if (cap <= prev_cap)
+            throw OutOfMemoryException();
+    }
+    //printf(" .. (%p) cap = %u\n", this, cap);
+
+    assert(cap > 0);
+    memory = (T*)xrealloc(memory, sizeof(T)*cap);
+}
+
+
+template<class T>
+typename RegionAllocator<T>::Ref
+RegionAllocator<T>::alloc(int size)
+{ 
+    //printf("ALLOC called (this = %p, size = %d)\n", this, size); fflush(stdout);
+    assert(size > 0);
+    capacity(sz + size);
+
+    uint32_t prev_sz = sz;
+    sz += size;
+    
+    // Handle overflow:
+    if (sz < prev_sz)
+        throw OutOfMemoryException();
+
+    return prev_sz;
+}
+
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/BoundedQueue.h b/lib/bill/bill/sat/solver/abc/BoundedQueue.h
new file mode 100644
index 0000000..1df17be
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/BoundedQueue.h
@@ -0,0 +1,114 @@
+/***********************************************************************************[BoundedQueue.h]
+ Glucose -- Copyright (c) 2009, Gilles Audemard, Laurent Simon
+                CRIL - Univ. Artois, France
+                LRI  - Univ. Paris Sud, France
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Abc_BoundedQueue_h
+#define Abc_BoundedQueue_h
+
+#include "Vec.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+//=================================================================================================
+
+namespace Gluco {
+
+template <class T>
+class bqueue {
+    vec<T>  elems;
+    int     first;
+    int        last;
+    uint64_t sumofqueue;
+    int     maxsize;
+    int     queuesize; // Number of current elements (must be < maxsize !)
+    bool expComputed;
+    double exp,value;
+public:
+ bqueue(void) : first(0), last(0), sumofqueue(0), maxsize(0), queuesize(0),expComputed(false) { } 
+    
+    void initSize(int size) {growTo(size);exp = 2.0/(size+1);} // Init size of bounded size queue
+    
+    void push(T x) {
+      expComputed = false;
+        if (queuesize==maxsize) {
+            assert(last==first); // The queue is full, next value to enter will replace oldest one
+            sumofqueue -= elems[last];
+            if ((++last) == maxsize) last = 0;
+        } else 
+            queuesize++;
+        sumofqueue += x;
+        elems[first] = x;
+        if ((++first) == maxsize) {first = 0;last = 0;}
+    }
+
+    T peek() { assert(queuesize>0); return elems[last]; }
+    void pop() {sumofqueue-=elems[last]; queuesize--; if ((++last) == maxsize) last = 0;}
+    
+    uint64_t getsum() const {return sumofqueue;}
+    unsigned int getavg() const {return (unsigned int)(sumofqueue/((uint64_t)queuesize));}
+    int maxSize() const {return maxsize;}
+    double getavgDouble() const {
+      double tmp = 0;
+      for(int i=0;i<elems.size();i++) {
+        tmp+=elems[i];
+      }
+      return tmp/elems.size();
+    }
+    int isvalid() const {return (queuesize==maxsize);}
+    
+    void growTo(int size) {
+        elems.growTo(size); 
+        first=0; maxsize=size; queuesize = 0;last = 0;
+        for(int i=0;i<size;i++) elems[i]=0; 
+    }
+    
+    double getAvgExp() {
+      if(expComputed) return value;
+      double a=exp;
+      value = elems[first];
+      for(int i  = first;i<maxsize;i++) {
+        value+=a*((double)elems[i]);
+        a=a*exp;
+      }
+      for(int i  = 0;i<last;i++) {
+        value+=a*((double)elems[i]);
+        a=a*exp;
+      }
+      value = value*(1-exp)/(1-a);
+      expComputed = true;
+      return value;
+      
+
+    }
+    void fastclear() {first = 0; last = 0; queuesize=0; sumofqueue=0;} // to be called after restarts... Discard the queue
+    
+    int  size(void)    { return queuesize; }
+
+    void clear(bool dealloc = false)   { elems.clear(dealloc); first = 0; maxsize=0; queuesize=0;sumofqueue=0;}
+
+
+};
+}
+//=================================================================================================
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/Constants.h b/lib/bill/bill/sat/solver/abc/Constants.h
new file mode 100644
index 0000000..4cccad2
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/Constants.h
@@ -0,0 +1,33 @@
+/************************************************************************************[Constants.h]
+ Glucose -- Copyright (c) 2009, Gilles Audemard, Laurent Simon
+                CRIL - Univ. Artois, France
+                LRI  - Univ. Paris Sud, France
+  
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#define DYNAMICNBLEVEL
+#define CONSTANTREMOVECLAUSE
+#define UPDATEVARACTIVITY
+
+// Constants for clauses reductions
+#define RATIOREMOVECLAUSES 2
+
+
+
+// Constants for restarts
+#define LOWER_BOUND_FOR_BLOCKING_RESTART 10000
+
diff --git a/lib/bill/bill/sat/solver/abc/Dimacs.h b/lib/bill/bill/sat/solver/abc/Dimacs.h
new file mode 100644
index 0000000..f57e729
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/Dimacs.h
@@ -0,0 +1,85 @@
+/****************************************************************************************[Dimacs.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Abc_Glucose_Dimacs_h
+#define Abc_Glucose_Dimacs_h
+
+#include <stdio.h>
+
+#include "SolverTypes.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// DIMACS Parser:
+
+template<class B, class Solver>
+static void readClause(B& in, Solver& S, vec<Lit>& lits) {
+    int     parsed_lit, var;
+    lits.clear();
+    for (;;){
+        parsed_lit = parseInt(in);
+        if (parsed_lit == 0) break;
+        var = abs(parsed_lit)-1;
+        while (var >= S.nVars()) S.newVar();
+        lits.push( (parsed_lit > 0) ? mkLit(var) : ~mkLit(var) );
+    }
+}
+
+template<class B, class Solver>
+static void parse_DIMACS_main(B& in, Solver& S) {
+    vec<Lit> lits;
+    int vars    = 0;
+    int clauses = 0;
+    int cnt     = 0;
+    for (;;){
+        skipWhitespace(in);
+        if (*in == EOF) break;
+        else if (*in == 'p'){
+            if (eagerMatch(in, "p cnf")){
+                vars    = parseInt(in);
+                clauses = parseInt(in);
+                // SATRACE'06 hack
+                // if (clauses > 4000000)
+                //     S.eliminate(true);
+            }else{
+                printf("PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
+            }
+        } else if (*in == 'c' || *in == 'p')
+            skipLine(in);
+        else{
+            cnt++;
+            readClause(in, S, lits);
+            S.addClause_(lits); }
+    }
+    if (vars != S.nVars())
+        fprintf(stderr, "WARNING! DIMACS header mismatch: wrong number of variables.\n");
+    if (cnt  != clauses)
+        fprintf(stderr, "WARNING! DIMACS header mismatch: wrong number of clauses.\n");
+}
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/Heap.h b/lib/bill/bill/sat/solver/abc/Heap.h
new file mode 100644
index 0000000..d52ec11
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/Heap.h
@@ -0,0 +1,154 @@
+/******************************************************************************************[Heap.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Abc_Glucose_Heap_h
+#define Abc_Glucose_Heap_h
+
+#include "Vec.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// A heap implementation with support for decrease/increase key.
+
+
+template<class Comp>
+class Heap {
+    Comp     lt;       // The heap is a minimum-heap with respect to this comparator
+    vec<int> heap;     // Heap of integers
+    vec<int> indices;  // Each integers position (index) in the Heap
+
+    // Index "traversal" functions
+    static inline int left  (int i) { return i*2+1; }
+    static inline int right (int i) { return (i+1)*2; }
+    static inline int parent(int i) { return (i-1) >> 1; }
+
+
+    void percolateUp(int i)
+    {
+        int x  = heap[i];
+        int p  = parent(i);
+        
+        while (i != 0 && lt(x, heap[p])){
+            heap[i]          = heap[p];
+            indices[heap[p]] = i;
+            i                = p;
+            p                = parent(p);
+        }
+        heap   [i] = x;
+        indices[x] = i;
+    }
+
+
+    void percolateDown(int i)
+    {
+        int x = heap[i];
+        while (left(i) < heap.size()){
+            int child = right(i) < heap.size() && lt(heap[right(i)], heap[left(i)]) ? right(i) : left(i);
+            if (!lt(heap[child], x)) break;
+            heap[i]          = heap[child];
+            indices[heap[i]] = i;
+            i                = child;
+        }
+        heap   [i] = x;
+        indices[x] = i;
+    }
+
+
+  public:
+    Heap(const Comp& c) : lt(c) { }
+
+    int  size      ()          const { return heap.size(); }
+    bool empty     ()          const { return heap.size() == 0; }
+    bool inHeap    (int n)     const { return n < indices.size() && indices[n] >= 0; }
+    int  operator[](int index) const { assert(index < heap.size()); return heap[index]; }
+
+
+    void decrease  (int n) { assert(inHeap(n)); percolateUp  (indices[n]); }
+    void increase  (int n) { assert(inHeap(n)); percolateDown(indices[n]); }
+
+
+    // Safe variant of insert/decrease/increase:
+    void update(int n)
+    {
+        if (!inHeap(n))
+            insert(n);
+        else {
+            percolateUp(indices[n]);
+            percolateDown(indices[n]); }
+    }
+
+
+    void insert(int n)
+    {
+        indices.growTo(n+1, -1);
+        assert(!inHeap(n));
+
+        indices[n] = heap.size();
+        heap.push(n);
+        percolateUp(indices[n]); 
+    }
+
+
+    int  removeMin()
+    {
+        int x            = heap[0];
+        heap[0]          = heap.last();
+        indices[heap[0]] = 0;
+        indices[x]       = -1;
+        heap.pop();
+        if (heap.size() > 1) percolateDown(0);
+        return x; 
+    }
+
+
+    // Rebuild the heap from scratch, using the elements in 'ns':
+    void build(vec<int>& ns) {
+        int i;
+        for (i = 0; i < heap.size(); i++)
+            indices[heap[i]] = -1;
+        heap.clear();
+
+        for (i = 0; i < ns.size(); i++){
+            indices[ns[i]] = i;
+            heap.push(ns[i]); }
+
+        for (i = heap.size() / 2 - 1; i >= 0; i--)
+            percolateDown(i);
+    }
+
+    void clear(bool dealloc = false) 
+    { 
+        int i;
+        for (i = 0; i < heap.size(); i++)
+            indices[heap[i]] = -1;
+        heap.clear(dealloc); 
+    }
+};
+
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/IntTypes.h b/lib/bill/bill/sat/solver/abc/IntTypes.h
new file mode 100644
index 0000000..101a366
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/IntTypes.h
@@ -0,0 +1,49 @@
+/**************************************************************************************[IntTypes.h]
+Copyright (c) 2009-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Abc_Glucose_IntTypes_h
+#define Abc_Glucose_IntTypes_h
+
+#ifdef __sun
+    // Not sure if there are newer versions that support C99 headers. The
+    // needed features are implemented in the headers below though:
+
+#   include <sys/int_types.h>
+#   include <sys/int_fmtio.h>
+#   include <sys/int_limits.h>
+
+#else
+
+#define __STDC_LIMIT_MACROS
+#   include "pstdint.h"
+//#   include <inttypes.h>
+
+#endif
+
+#include <limits.h>
+
+#ifndef PRIu64
+#define PRIu64 "lu"
+#define PRIi64 "ld"
+#endif
+//=================================================================================================
+
+#include "abc_namespaces.h"
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/Map.h b/lib/bill/bill/sat/solver/abc/Map.h
new file mode 100644
index 0000000..cd684f5
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/Map.h
@@ -0,0 +1,197 @@
+/*******************************************************************************************[Map.h]
+Copyright (c) 2006-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Abc_Glucose_Map_h
+#define Abc_Glucose_Map_h
+
+#include "IntTypes.h"
+#include "Vec.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// Default hash/equals functions
+//
+
+template<class K> struct Hash  { uint32_t operator()(const K& k)               const { return hash(k);  } };
+template<class K> struct Equal { bool     operator()(const K& k1, const K& k2) const { return k1 == k2; } };
+
+template<class K> struct DeepHash  { uint32_t operator()(const K* k)               const { return hash(*k);  } };
+template<class K> struct DeepEqual { bool     operator()(const K* k1, const K* k2) const { return *k1 == *k2; } };
+
+static inline uint32_t hash(uint32_t x){ return x; }
+static inline uint32_t hash(uint64_t x){ return (uint32_t)x; }
+static inline uint32_t hash(int32_t x) { return (uint32_t)x; }
+static inline uint32_t hash(int64_t x) { return (uint32_t)x; }
+
+
+//=================================================================================================
+// Some primes
+//
+
+static const int nprimes          = 25;
+static const int primes [nprimes] = { 31, 73, 151, 313, 643, 1291, 2593, 5233, 10501, 21013, 42073, 84181, 168451, 337219, 674701, 1349473, 2699299, 5398891, 10798093, 21596719, 43193641, 86387383, 172775299, 345550609, 691101253 };
+
+//=================================================================================================
+// Hash table implementation of Maps
+//
+
+template<class K, class D, class H = Hash<K>, class E = Equal<K> >
+class Map {
+ public:
+    struct Pair { K key; D data; };
+
+ private:
+    H          hash;
+    E          equals;
+
+    vec<Pair>* table;
+    int        cap;
+    int        size;
+
+    // Don't allow copying (error prone):
+    Map<K,D,H,E>&  operator = (Map<K,D,H,E>& other) { assert(0); }
+                   Map        (Map<K,D,H,E>& other) { assert(0); }
+
+    bool    checkCap(int new_size) const { return new_size > cap; }
+
+    int32_t index  (const K& k) const { return hash(k) % cap; }
+    void   _insert (const K& k, const D& d) { 
+        vec<Pair>& ps = table[index(k)];
+        ps.push(); ps.last().key = k; ps.last().data = d; }
+
+    void    rehash () {
+        const vec<Pair>* old = table;
+
+        int old_cap = cap;
+        int newsize = primes[0];
+        for (int i = 1; newsize <= cap && i < nprimes; i++)
+           newsize = primes[i];
+
+        table = new vec<Pair>[newsize];
+        cap   = newsize;
+
+        for (int i = 0; i < old_cap; i++){
+            for (int j = 0; j < old[i].size(); j++){
+                _insert(old[i][j].key, old[i][j].data); }}
+
+        delete [] old;
+
+        // printf(" --- rehashing, old-cap=%d, new-cap=%d\n", cap, newsize);
+    }
+
+    
+ public:
+
+    Map () : table(NULL), cap(0), size(0) {}
+    Map (const H& h, const E& e) : hash(h), equals(e), table(NULL), cap(0), size(0){}
+    ~Map () { delete [] table; }
+
+    // PRECONDITION: the key must already exist in the map.
+    const D& operator [] (const K& k) const
+    {
+        assert(size != 0);
+        const D*         res = NULL;
+        const vec<Pair>& ps  = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k))
+                res = &ps[i].data;
+        assert(res != NULL);
+        return *res;
+    }
+
+    // PRECONDITION: the key must already exist in the map.
+    D& operator [] (const K& k)
+    {
+        assert(size != 0);
+        D*         res = NULL;
+        vec<Pair>& ps  = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k))
+                res = &ps[i].data;
+        assert(res != NULL);
+        return *res;
+    }
+
+    // PRECONDITION: the key must *NOT* exist in the map.
+    void insert (const K& k, const D& d) { if (checkCap(size+1)) rehash(); _insert(k, d); size++; }
+    bool peek   (const K& k, D& d) const {
+        if (size == 0) return false;
+        const vec<Pair>& ps = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k)){
+                d = ps[i].data;
+                return true; } 
+        return false;
+    }
+
+    bool has   (const K& k) const {
+        if (size == 0) return false;
+        const vec<Pair>& ps = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k))
+                return true;
+        return false;
+    }
+
+    // PRECONDITION: the key must exist in the map.
+    void remove(const K& k) {
+        assert(table != NULL);
+        vec<Pair>& ps = table[index(k)];
+        int j = 0;
+        for (; j < ps.size() && !equals(ps[j].key, k); j++);
+        assert(j < ps.size());
+        ps[j] = ps.last();
+        ps.pop();
+        size--;
+    }
+
+    void clear  () {
+        cap = size = 0;
+        delete [] table;
+        table = NULL;
+    }
+
+    int  elems() const { return size; }
+    int  bucket_count() const { return cap; }
+
+    // NOTE: the hash and equality objects are not moved by this method:
+    void moveTo(Map& other){
+        delete [] other.table;
+
+        other.table = table;
+        other.cap   = cap;
+        other.size  = size;
+
+        table = NULL;
+        size = cap = 0;
+    }
+
+    // NOTE: given a bit more time, I could make a more C++-style iterator out of this:
+    const vec<Pair>& bucket(int i) const { return table[i]; }
+};
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/Queue.h b/lib/bill/bill/sat/solver/abc/Queue.h
new file mode 100644
index 0000000..4b18360
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/Queue.h
@@ -0,0 +1,73 @@
+/*****************************************************************************************[Queue.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Abc_Glucose_Queue_h
+#define Abc_Glucose_Queue_h
+
+#include "Vec.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+
+template<class T>
+class Queue {
+    vec<T>  buf;
+    int     first;
+    int     end;
+
+public:
+    typedef T Key;
+
+    Queue() : buf(1), first(0), end(0) {}
+
+    void clear (bool dealloc = false) { buf.clear(dealloc); buf.growTo(1); first = end = 0; }
+    int  size  () const { return (end >= first) ? end - first : end - first + buf.size(); }
+
+    const T& operator [] (int index) const  { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; }
+    T&       operator [] (int index)        { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; }
+
+    T    peek  () const { assert(first != end); return buf[first]; }
+    void pop   () { assert(first != end); first++; if (first == buf.size()) first = 0; }
+    void insert(T elem) {   // INVARIANT: buf[end] is always unused
+        buf[end++] = elem;
+        if (end == buf.size()) end = 0;
+        if (first == end){  // Resize:
+            vec<T>  tmp((buf.size()*3 + 1) >> 1);
+            //**/printf("queue alloc: %d elems (%.1f MB)\n", tmp.size(), tmp.size() * sizeof(T) / 1000000.0);
+            int j, i = 0;
+            for (j = first; j < buf.size(); j++) tmp[i++] = buf[j];
+            for (j = 0    ; j < end       ; j++) tmp[i++] = buf[j];
+            first = 0;
+            end   = buf.size();
+            tmp.moveTo(buf);
+        }
+    }
+};
+
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/SimpSolver.h b/lib/bill/bill/sat/solver/abc/SimpSolver.h
new file mode 100644
index 0000000..cbbfb64
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/SimpSolver.h
@@ -0,0 +1,208 @@
+/************************************************************************************[SimpSolver.h]
+Copyright (c) 2006,      Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Abc_Glucose_SimpSolver_h
+#define Abc_Glucose_SimpSolver_h
+
+#include "Queue.h"
+#include "Solver.h"
+#include "abc_global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+
+
+class SimpSolver : public Solver {
+ public:
+    // Constructor/Destructor:
+    //
+    SimpSolver();
+    ~SimpSolver();
+
+    // Problem specification:
+    //
+    Var     newVar    (bool polarity = true, bool dvar = true);
+    void    addVar    (Var v);               
+    bool    addClause (const vec<Lit>& ps);
+    bool    addEmptyClause();                // Add the empty clause to the solver.
+    bool    addClause (Lit p);               // Add a unit clause to the solver.
+    bool    addClause (Lit p, Lit q);        // Add a binary clause to the solver.
+    bool    addClause (Lit p, Lit q, Lit r); // Add a ternary clause to the solver.
+    bool    addClause_(      vec<Lit>& ps);
+    bool    substitute(Var v, Lit x);  // Replace all occurences of v with x (may cause a contradiction).
+
+    // Variable mode:
+    // 
+    void    setFrozen (Var v, bool b); // If a variable is frozen it will not be eliminated.
+    bool    isEliminated(Var v) const;
+
+    // Solving:
+    //
+    bool    solve       (const vec<Lit>& assumps, bool do_simp = true, bool turn_off_simp = false);
+    lbool   solveLimited(const vec<Lit>& assumps, bool do_simp = true, bool turn_off_simp = false);
+    bool    solve       (                     bool do_simp = true, bool turn_off_simp = false);
+    bool    solve       (Lit p       ,        bool do_simp = true, bool turn_off_simp = false);       
+    bool    solve       (Lit p, Lit q,        bool do_simp = true, bool turn_off_simp = false);
+    bool    solve       (Lit p, Lit q, Lit r, bool do_simp = true, bool turn_off_simp = false);
+    bool    eliminate   (bool turn_off_elim = false);  // Perform variable elimination based simplification. 
+
+    // Memory managment:
+    //
+    virtual void reset();
+    virtual void garbageCollect();
+
+
+    // Generate a (possibly simplified) DIMACS file:
+    //
+#if 0
+    void    toDimacs  (const char* file, const vec<Lit>& assumps);
+    void    toDimacs  (const char* file);
+    void    toDimacs  (const char* file, Lit p);
+    void    toDimacs  (const char* file, Lit p, Lit q);
+    void    toDimacs  (const char* file, Lit p, Lit q, Lit r);
+#endif
+
+    // Mode of operation:
+    //
+    int     parsing;
+    int     grow;              // Allow a variable elimination step to grow by a number of clauses (default to zero).
+    int     clause_lim;        // Variables are not eliminated if it produces a resolvent with a length above this limit.
+                               // -1 means no limit.
+    int     subsumption_lim;   // Do not check if subsumption against a clause larger than this. -1 means no limit.
+    double  simp_garbage_frac; // A different limit for when to issue a GC during simplification (Also see 'garbage_frac').
+
+    bool    use_asymm;         // Shrink clauses by asymmetric branching.
+    bool    use_rcheck;        // Check if a clause is already implied. Prett costly, and subsumes subsumptions :)
+    bool    use_elim;          // Perform variable elimination.
+
+    // Statistics:
+    //
+    int     merges;
+    int     asymm_lits;
+    int     eliminated_vars;
+    int     eliminated_clauses;
+
+ protected:
+
+    // Helper structures:
+    //
+    struct ElimLt {
+        const vec<int>& n_occ;
+        explicit ElimLt(const vec<int>& no) : n_occ(no) {}
+
+        // TODO: are 64-bit operations here noticably bad on 32-bit platforms? Could use a saturating
+        // 32-bit implementation instead then, but this will have to do for now.
+        uint64_t cost  (Var x)        const { return (uint64_t)n_occ[toInt(mkLit(x))] * (uint64_t)n_occ[toInt(~mkLit(x))]; }
+        bool operator()(Var x, Var y) const { return cost(x) < cost(y); }
+        
+        // TODO: investigate this order alternative more.
+        // bool operator()(Var x, Var y) const { 
+        //     int c_x = cost(x);
+        //     int c_y = cost(y);
+        //     return c_x < c_y || c_x == c_y && x < y; }
+    };
+
+    struct ClauseDeleted {
+        const ClauseAllocator& ca;
+        explicit ClauseDeleted(const ClauseAllocator& _ca) : ca(_ca) {}
+        bool operator()(const CRef& cr) const { return ca[cr].mark() == 1; } };
+
+    // Solver state:
+    //
+    int                 elimorder;
+    bool                use_simplification;
+    vec<uint32_t>       elimclauses;
+    vec<char>           touched;
+    OccLists<Var, vec<CRef>, ClauseDeleted>
+                        occurs;
+    vec<int>            n_occ;
+    Heap<ElimLt>        elim_heap;
+    Queue<CRef>         subsumption_queue;
+    vec<char>           frozen;
+    vec<char>           eliminated;
+    int                 bwdsub_assigns;
+    int                 n_touched;
+
+    // Temporaries:
+    //
+    CRef                bwdsub_tmpunit;
+
+    // Main internal methods:
+    //
+    lbool         solve_                   (bool do_simp = true, bool turn_off_simp = false);
+    bool          asymm                    (Var v, CRef cr);
+    bool          asymmVar                 (Var v);
+    void          updateElimHeap           (Var v);
+    void          gatherTouchedClauses     ();
+    bool          merge                    (const Clause& _ps, const Clause& _qs, Var v, vec<Lit>& out_clause);
+    bool          merge                    (const Clause& _ps, const Clause& _qs, Var v, int& size);
+    bool          backwardSubsumptionCheck (bool verbose = false);
+    bool          eliminateVar             (Var v);
+    void          extendModel              ();
+
+    void          removeClause             (CRef cr);
+    bool          strengthenClause         (CRef cr, Lit l);
+    void          cleanUpClauses           ();
+    bool          implied                  (const vec<Lit>& c);
+    void          relocAll                 (ClauseAllocator& to);
+};
+
+
+//=================================================================================================
+// Implementation of inline methods:
+
+
+//inline bool SimpSolver::isEliminated (Var v) const { return eliminated[v]; }
+inline bool SimpSolver::isEliminated (Var v) const { return eliminated.size() > 0 ? eliminated[v] != 0 : 0; }
+inline void SimpSolver::updateElimHeap(Var v) {
+    assert(use_simplification);
+    // if (!frozen[v] && !isEliminated(v) && value(v) == l_Undef)
+    if (elim_heap.inHeap(v) || (!frozen[v] && !isEliminated(v) && value(v) == l_Undef))
+        elim_heap.update(v); }
+
+
+inline bool SimpSolver::addClause    (const vec<Lit>& ps)  { ps.copyTo(add_tmp); return addClause_(add_tmp); }
+inline bool SimpSolver::addEmptyClause()                   { add_tmp.clear(); return addClause_(add_tmp); }
+inline bool SimpSolver::addClause    (Lit p)               { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); }
+inline bool SimpSolver::addClause    (Lit p, Lit q)        { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); }
+inline bool SimpSolver::addClause    (Lit p, Lit q, Lit r) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); }
+inline void SimpSolver::setFrozen    (Var v, bool b) { frozen[v] = (char)b; if (use_simplification && !b) { updateElimHeap(v); } }
+
+inline bool SimpSolver::solve        (                     bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (Lit p       ,        bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (Lit p, Lit q,        bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (Lit p, Lit q, Lit r, bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (const vec<Lit>& assumps, bool do_simp, bool turn_off_simp){ 
+    budgetOff(); assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp) == l_True; }
+
+inline lbool SimpSolver::solveLimited (const vec<Lit>& assumps, bool do_simp, bool turn_off_simp){ 
+    assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp); }
+
+inline void SimpSolver::addVar(Var v) { while (v >= nVars()) newVar(); }
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/Solver.h b/lib/bill/bill/sat/solver/abc/Solver.h
new file mode 100644
index 0000000..8238f1e
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/Solver.h
@@ -0,0 +1,493 @@
+/****************************************************************************************[Solver.h]
+ Glucose -- Copyright (c) 2009, Gilles Audemard, Laurent Simon
+                CRIL - Univ. Artois, France
+                LRI  - Univ. Paris Sud, France
+ 
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose are exactly the same as Minisat on which it is based on. (see below).
+
+---------------
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Abc_Glucose_Solver_h
+#define Abc_Glucose_Solver_h
+
+#include "Vec.h"
+#include "Heap.h"
+#include "Alg.h"
+#include "SolverTypes.h"
+#include "BoundedQueue.h"
+#include "Constants.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// Solver -- the main class:
+
+class Solver {
+public:
+
+    int SolverType; // ABC identifies Glucose's type as 0
+
+    // Constructor/Destructor:
+    //
+    Solver();
+    virtual ~Solver();
+
+    // ABC callbacks
+    void * pCnfMan;                      // external CNF manager
+    int(*pCnfFunc)(void * p, int, int*); // external callback. messages: 0: unsat; 1: sat; -1: still working
+    int nCallConfl;                      // callback will be called every this number of conflicts
+    bool terminate_search_early;         // used to stop the solver early if it as instructed by an external caller
+    int * pstop;                         // another callback
+    uint64_t nRuntimeLimit;              // runtime limit
+    vec<int> user_vec;
+    vec<Lit> user_lits;
+
+    // Problem specification:
+    //
+    Var     newVar    (bool polarity = true, bool dvar = true); // Add a new variable with parameters specifying variable mode.
+    void    addVar    (Var v);                                  // Add enough variables to make sure there is variable v.
+
+    bool    addClause (const vec<Lit>& ps);                     // Add a clause to the solver. 
+    bool    addEmptyClause();                                   // Add the empty clause, making the solver contradictory.
+    bool    addClause (Lit p);                                  // Add a unit clause to the solver. 
+    bool    addClause (Lit p, Lit q);                           // Add a binary clause to the solver. 
+    bool    addClause (Lit p, Lit q, Lit r);                    // Add a ternary clause to the solver. 
+    bool    addClause_(      vec<Lit>& ps);                     // Add a clause to the solver without making superflous internal copy. Will
+                                                                // change the passed vector 'ps'.
+
+    // Solving:
+    //
+    bool    simplify     ();                        // Removes already satisfied clauses.
+    bool    solve        (const vec<Lit>& assumps); // Search for a model that respects a given set of assumptions.
+    lbool   solveLimited (const vec<Lit>& assumps); // Search for a model that respects a given set of assumptions (With resource constraints).
+    bool    solve        ();                        // Search without assumptions.
+    bool    solve        (Lit p);                   // Search for a model that respects a single assumption.
+    bool    solve        (Lit p, Lit q);            // Search for a model that respects two assumptions.
+    bool    solve        (Lit p, Lit q, Lit r);     // Search for a model that respects three assumptions.
+    bool    okay         () const;                  // FALSE means solver is in a conflicting state
+
+    void    toDimacs     (FILE* f, const vec<Lit>& assumps);            // Write CNF to file in DIMACS-format.
+    void    toDimacs     (const char *file, const vec<Lit>& assumps);
+    void    toDimacs     (FILE* f, Clause& c, vec<Var>& map, Var& max);
+    void printLit(Lit l);
+    void printClause(CRef c);
+    void printInitialClause(CRef c);
+    // Convenience versions of 'toDimacs()':
+    void    toDimacs     (const char* file);
+    void    toDimacs     (const char* file, Lit p);
+    void    toDimacs     (const char* file, Lit p, Lit q);
+    void    toDimacs     (const char* file, Lit p, Lit q, Lit r);
+    
+    // Variable mode:
+    // 
+    void    setPolarity    (Var v, bool b); // Declare which polarity the decision heuristic should use for a variable. Requires mode 'polarity_user'.
+    void    setDecisionVar (Var v, bool b); // Declare if a variable should be eligible for selection in the decision heuristic.
+
+    // Read state:
+    //
+    lbool   value      (Var x) const;       // The current value of a variable.
+    lbool   value      (Lit p) const;       // The current value of a literal.
+    lbool   modelValue (Var x) const;       // The value of a variable in the last model. The last call to solve must have been satisfiable.
+    lbool   modelValue (Lit p) const;       // The value of a literal in the last model. The last call to solve must have been satisfiable.
+    int     nAssigns   ()      const;       // The current number of assigned literals.
+    int     nClauses   ()      const;       // The current number of original clauses.
+    int     nLearnts   ()      const;       // The current number of learnt clauses.
+    int     nVars      ()      const;       // The current number of variables.
+    int     nFreeVars  ()      const;
+
+    // Incremental mode
+    void setIncrementalMode();
+    void initNbInitialVars(int nb);
+    void printIncrementalStats();
+
+    // Resource contraints:
+    //
+    void    setConfBudget(int64_t x);
+    void    setPropBudget(int64_t x);
+    void    budgetOff();
+    void    interrupt();          // Trigger a (potentially asynchronous) interruption of the solver.
+    void    clearInterrupt();     // Clear interrupt indicator flag.
+
+    // Memory managment:
+    //
+    virtual void reset();
+    virtual void garbageCollect(); // virtuality causes segfault for some reason
+    void    checkGarbage(double gf);
+    void    checkGarbage();
+
+
+
+
+    // Extra results: (read-only member variable)
+    //
+    vec<lbool> model;             // If problem is satisfiable, this vector contains the model (if any).
+    vec<Lit>   conflict;          // If problem is unsatisfiable (possibly under assumptions),
+                                  // this vector represent the final conflict clause expressed in the assumptions.
+
+    // Mode of operation:
+    //
+    int       verbosity;
+    int       verbEveryConflicts;
+    int       showModel;
+    // Constants For restarts
+    double    K;
+    double    R;
+    double    sizeLBDQueue;
+    double    sizeTrailQueue;
+
+    // Constants for reduce DB
+    int firstReduceDB;
+    int incReduceDB;
+    int specialIncReduceDB;
+    unsigned int lbLBDFrozenClause;
+
+    // Constant for reducing clause
+    int lbSizeMinimizingClause;
+    unsigned int lbLBDMinimizingClause;
+
+    double    var_decay;
+    double    clause_decay;
+    double    random_var_freq;
+    double    random_seed;
+    int       ccmin_mode;         // Controls conflict clause minimization (0=none, 1=basic, 2=deep).
+    int       phase_saving;       // Controls the level of phase saving (0=none, 1=limited, 2=full).
+    bool      rnd_pol;            // Use random polarities for branching heuristics.
+    bool      rnd_init_act;       // Initialize variable activities with a small random value.
+    double    garbage_frac;       // The fraction of wasted memory allowed before a garbage collection is triggered.
+
+    // Certified UNSAT ( Thanks to Marijn Heule)
+    FILE*               certifiedOutput;
+    bool                certifiedUNSAT;
+
+    
+    // Statistics: (read-only member variable)
+    //
+    int64_t nbRemovedClauses,nbReducedClauses,nbDL2,nbBin,nbUn,nbReduceDB,solves, starts, decisions, rnd_decisions, propagations, conflicts,conflictsRestarts,nbstopsrestarts,nbstopsrestartssame,lastblockatrestart;
+    int64_t dec_vars, clauses_literals, learnts_literals, max_literals, tot_literals;
+
+protected:
+    long curRestart;
+    // Helper structures:
+    //
+    struct VarData { CRef reason; int level; };
+    static inline VarData mkVarData(CRef cr, int l){ VarData d = {cr, l}; return d; }
+
+    struct Watcher {
+        CRef cref;
+        Lit  blocker;
+        Watcher(CRef cr, Lit p) : cref(cr), blocker(p) {}
+        bool operator==(const Watcher& w) const { return cref == w.cref; }
+        bool operator!=(const Watcher& w) const { return cref != w.cref; }
+    };
+
+    struct WatcherDeleted
+    {
+        const ClauseAllocator& ca;
+        WatcherDeleted(const ClauseAllocator& _ca) : ca(_ca) {}
+        bool operator()(const Watcher& w) const { return ca[w.cref].mark() == 1; }
+    };
+
+    struct VarOrderLt {
+        const vec<double>&  activity;
+        bool operator () (Var x, Var y) const { return activity[x] > activity[y]; }
+        VarOrderLt(const vec<double>&  act) : activity(act) { }
+    };
+
+
+    // Solver state:
+    //
+    int lastIndexRed;
+    bool                ok;               // If FALSE, the constraints are already unsatisfiable. No part of the solver state may be used!
+    double              cla_inc;          // Amount to bump next clause with.
+    vec<double>         activity;         // A heuristic measurement of the activity of a variable.
+    double              var_inc;          // Amount to bump next variable with.
+    OccLists<Lit, vec<Watcher>, WatcherDeleted>
+                        watches;          // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true).
+    OccLists<Lit, vec<Watcher>, WatcherDeleted>
+                        watchesBin;          // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true).
+    vec<CRef>           clauses;          // List of problem clauses.
+    vec<CRef>           learnts;          // List of learnt clauses.
+
+    vec<lbool>          assigns;          // The current assignments.
+    vec<char>           polarity;         // The preferred polarity of each variable.
+    vec<char>           decision;         // Declares if a variable is eligible for selection in the decision heuristic.
+    vec<Lit>            trail;            // Assignment stack; stores all assigments made in the order they were made.
+    vec<int>            nbpos;
+    vec<int>            trail_lim;        // Separator indices for different decision levels in 'trail'.
+    vec<VarData>        vardata;          // Stores reason and level for each variable.
+    int                 qhead;            // Head of queue (as index into the trail -- no more explicit propagation queue in MiniSat).
+    int                 simpDB_assigns;   // Number of top-level assignments since last execution of 'simplify()'.
+    int64_t             simpDB_props;     // Remaining number of propagations that must be made before next execution of 'simplify()'.
+    vec<Lit>            assumptions;      // Current set of assumptions provided to solve by the user.
+    Heap<VarOrderLt>    order_heap;       // A priority queue of variables ordered with respect to the variable activity.
+    double              progress_estimate;// Set by 'search()'.
+    bool                remove_satisfied; // Indicates whether possibly inefficient linear scan for satisfied clauses should be performed in 'simplify'.
+    vec<unsigned int> permDiff;      // permDiff[var] contains the current conflict number... Used to count the number of  LBD
+    
+#ifdef UPDATEVARACTIVITY
+    // UPDATEVARACTIVITY trick (see competition'09 companion paper)
+    vec<Lit> lastDecisionLevel; 
+#endif
+
+    ClauseAllocator     ca;
+
+    int nbclausesbeforereduce;            // To know when it is time to reduce clause database
+    
+    bqueue<unsigned int> trailQueue,lbdQueue; // Bounded queues for restarts.
+    float sumLBD; // used to compute the global average of LBD. Restarts...
+    int sumAssumptions;
+
+
+    // Temporaries (to reduce allocation overhead). Each variable is prefixed by the method in which it is
+    // used, exept 'seen' wich is used in several places.
+    //
+    vec<char>           seen;
+    vec<Lit>            analyze_stack;
+    vec<Lit>            analyze_toclear;
+    vec<Lit>            add_tmp;
+    unsigned int  MYFLAG;
+
+
+    double              max_learnts;
+    double              learntsize_adjust_confl;
+    int                 learntsize_adjust_cnt;
+
+    // Resource contraints:
+    //
+    int64_t             conflict_budget;    // -1 means no budget.
+    int64_t             propagation_budget; // -1 means no budget.
+    bool                asynch_interrupt;
+
+
+    // Variables added for incremental mode
+    int incremental; // Use incremental SAT Solver
+    int nbVarsInitialFormula; // nb VAR in formula without assumptions (incremental SAT)
+    double totalTime4Sat,totalTime4Unsat;
+    int nbSatCalls,nbUnsatCalls;
+    vec<int> assumptionPositions,initialPositions;
+
+
+    // Main internal methods:
+    //
+    void     insertVarOrder   (Var x);                                                 // Insert a variable in the decision order priority queue.
+    Lit      pickBranchLit    ();                                                      // Return the next decision variable.
+    void     newDecisionLevel ();                                                      // Begins a new decision level.
+    void     uncheckedEnqueue (Lit p, CRef from = CRef_Undef);                         // Enqueue a literal. Assumes value of literal is undefined.
+    bool     enqueue          (Lit p, CRef from = CRef_Undef);                         // Test if fact 'p' contradicts current state, enqueue otherwise.
+    CRef     propagate        ();                                                      // Perform unit propagation. Returns possibly conflicting clause.
+    void     cancelUntil      (int level);                                             // Backtrack until a certain level.
+    void     analyze          (CRef confl, vec<Lit>& out_learnt, vec<Lit> & selectors, int& out_btlevel,unsigned int &nblevels,unsigned int &szWithoutSelectors);    // (bt = backtrack)
+    void     analyzeFinal     (Lit p, vec<Lit>& out_conflict);                         // COULD THIS BE IMPLEMENTED BY THE ORDINARIY "analyze" BY SOME REASONABLE GENERALIZATION?
+    bool     litRedundant     (Lit p, uint32_t abstract_levels);                       // (helper method for 'analyze()')
+    lbool    search           (int nof_conflicts);                                     // Search for a given number of conflicts.
+    lbool    solve_           ();                                                      // Main solve method (assumptions given in 'assumptions').
+    void     reduceDB         ();                                                      // Reduce the set of learnt clauses.
+    void     removeSatisfied  (vec<CRef>& cs);                                         // Shrink 'cs' to contain only non-satisfied clauses.
+    void     rebuildOrderHeap ();
+
+    // Maintaining Variable/Clause activity:
+    //
+    void     varDecayActivity ();                      // Decay all variables with the specified factor. Implemented by increasing the 'bump' value instead.
+    void     varBumpActivity  (Var v, double inc);     // Increase a variable with the current 'bump' value.
+    void     varBumpActivity  (Var v);                 // Increase a variable with the current 'bump' value.
+    void     claDecayActivity ();                      // Decay all clauses with the specified factor. Implemented by increasing the 'bump' value instead.
+    void     claBumpActivity  (Clause& c);             // Increase a clause with the current 'bump' value.
+
+    // Operations on clauses:
+    //
+    void     attachClause     (CRef cr);               // Attach a clause to watcher lists.
+    void     detachClause     (CRef cr, bool strict = false); // Detach a clause to watcher lists.
+    void     removeClause     (CRef cr);               // Detach and free a clause.
+    bool     locked           (const Clause& c) const; // Returns TRUE if a clause is a reason for some implication in the current state.
+    bool     satisfied        (const Clause& c) const; // Returns TRUE if a clause is satisfied in the current state.
+
+    unsigned int computeLBD(const vec<Lit> & lits,int end=-1);
+    unsigned int computeLBD(const Clause &c);
+    void minimisationWithBinaryResolution(vec<Lit> &out_learnt);
+
+    void     relocAll         (ClauseAllocator& to);
+
+    // Misc:
+    //
+    int      decisionLevel    ()      const; // Gives the current decisionlevel.
+    uint32_t abstractLevel    (Var x) const; // Used to represent an abstraction of sets of decision levels.
+    CRef     reason           (Var x) const;
+    int      level            (Var x) const;
+    double   progressEstimate ()      const; // DELETE THIS ?? IT'S NOT VERY USEFUL ...
+    bool     withinBudget     ()      const;
+    inline bool isSelector(Var v) {return (incremental && v>nbVarsInitialFormula);}
+
+    // Static helpers:
+    //
+
+    // Returns a random float 0 <= x < 1. Seed must never be 0.
+    static inline double drand(double& seed) {
+        seed *= 1389796;
+        int q = (int)(seed / 2147483647);
+        seed -= (double)q * 2147483647;
+        return seed / 2147483647; }
+
+    // Returns a random integer 0 <= x < size. Seed must never be 0.
+    static inline int irand(double& seed, int size) {
+        return (int)(drand(seed) * size); }
+};
+
+
+//=================================================================================================
+// Implementation of inline methods:
+
+inline CRef Solver::reason(Var x) const { return vardata[x].reason; }
+inline int  Solver::level (Var x) const { return vardata[x].level; }
+
+inline void Solver::insertVarOrder(Var x) {
+    if (!order_heap.inHeap(x) && decision[x]) order_heap.insert(x); }
+
+inline void Solver::varDecayActivity() { var_inc *= (1 / var_decay); }
+inline void Solver::varBumpActivity(Var v) { varBumpActivity(v, var_inc); }
+inline void Solver::varBumpActivity(Var v, double inc) {
+    if ( (activity[v] += inc) > 1e100 ) {
+        // Rescale:
+        for (int i = 0; i < nVars(); i++)
+            activity[i] *= 1e-100;
+        var_inc *= 1e-100; }
+
+    // Update order_heap with respect to new activity:
+    if (order_heap.inHeap(v))
+        order_heap.decrease(v); }
+
+inline void Solver::claDecayActivity() { cla_inc *= (1 / clause_decay); }
+inline void Solver::claBumpActivity (Clause& c) {
+        if ( (c.activity() += cla_inc) > 1e20 ) {
+            // Rescale:
+            for (int i = 0; i < learnts.size(); i++)
+                ca[learnts[i]].activity() *= (float)1e-20;
+            cla_inc *= 1e-20; } }
+
+inline void Solver::checkGarbage(void){ checkGarbage(garbage_frac); }
+inline void Solver::checkGarbage(double gf){
+    if (ca.wasted() > ca.size() * gf)
+        garbageCollect();}
+
+// NOTE: enqueue does not set the ok flag! (only public methods do)
+inline bool     Solver::enqueue         (Lit p, CRef from)      { return value(p) != l_Undef ? value(p) != l_False : (uncheckedEnqueue(p, from), true); }
+inline bool     Solver::addClause       (const vec<Lit>& ps)    { ps.copyTo(add_tmp); return addClause_(add_tmp); }
+inline bool     Solver::addEmptyClause  ()                      { add_tmp.clear(); return addClause_(add_tmp); }
+inline bool     Solver::addClause       (Lit p)                 { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); }
+inline bool     Solver::addClause       (Lit p, Lit q)          { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); }
+inline bool     Solver::addClause       (Lit p, Lit q, Lit r)   { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); }
+inline bool     Solver::locked          (const Clause& c) const { 
+   if(c.size()>2) 
+     return value(c[0]) == l_True && reason(var(c[0])) != CRef_Undef && ca.lea(reason(var(c[0]))) == &c; 
+   return 
+     (value(c[0]) == l_True && reason(var(c[0])) != CRef_Undef && ca.lea(reason(var(c[0]))) == &c)
+     || 
+     (value(c[1]) == l_True && reason(var(c[1])) != CRef_Undef && ca.lea(reason(var(c[1]))) == &c);
+ }
+inline void     Solver::newDecisionLevel()                      { trail_lim.push(trail.size()); }
+
+inline int      Solver::decisionLevel ()      const   { return trail_lim.size(); }
+inline uint32_t Solver::abstractLevel (Var x) const   { return 1 << (level(x) & 31); }
+inline lbool    Solver::value         (Var x) const   { return assigns[x]; }
+inline lbool    Solver::value         (Lit p) const   { return assigns[var(p)] ^ sign(p); }
+inline lbool    Solver::modelValue    (Var x) const   { return model[x]; }
+inline lbool    Solver::modelValue    (Lit p) const   { return model[var(p)] ^ sign(p); }
+inline int      Solver::nAssigns      ()      const   { return trail.size(); }
+inline int      Solver::nClauses      ()      const   { return clauses.size(); }
+inline int      Solver::nLearnts      ()      const   { return learnts.size(); }
+inline int      Solver::nVars         ()      const   { return vardata.size(); }
+inline int      Solver::nFreeVars     ()      const   { return (int)dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]); }
+inline void     Solver::setPolarity   (Var v, bool b) { polarity[v] = b; }
+inline void     Solver::setDecisionVar(Var v, bool b) 
+{ 
+    if      ( b && !decision[v]) dec_vars++;
+    else if (!b &&  decision[v]) dec_vars--;
+
+    decision[v] = b;
+    insertVarOrder(v);
+}
+inline void     Solver::setConfBudget(int64_t x){ conflict_budget    = conflicts    + x; }
+inline void     Solver::setPropBudget(int64_t x){ propagation_budget = propagations + x; }
+inline void     Solver::interrupt(){ asynch_interrupt = true; }
+inline void     Solver::clearInterrupt(){ asynch_interrupt = false; }
+inline void     Solver::budgetOff(){ conflict_budget = propagation_budget = -1; }
+inline bool     Solver::withinBudget() const {
+    return !asynch_interrupt &&
+           (conflict_budget    < 0 || conflicts < (uint64_t)conflict_budget) &&
+           (propagation_budget < 0 || propagations < (uint64_t)propagation_budget); }
+
+// FIXME: after the introduction of asynchronous interrruptions the solve-versions that return a
+// pure bool do not give a safe interface. Either interrupts must be possible to turn off here, or
+// all calls to solve must return an 'lbool'. I'm not yet sure which I prefer.
+inline bool     Solver::solve         ()                    { budgetOff(); assumptions.clear(); return solve_() == l_True; }
+inline bool     Solver::solve         (Lit p)               { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_() == l_True; }
+inline bool     Solver::solve         (Lit p, Lit q)        { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_() == l_True; }
+inline bool     Solver::solve         (Lit p, Lit q, Lit r) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_() == l_True; }
+inline bool     Solver::solve         (const vec<Lit>& assumps){ budgetOff(); assumps.copyTo(assumptions); return solve_() == l_True; }
+inline lbool    Solver::solveLimited  (const vec<Lit>& assumps){ assumps.copyTo(assumptions); return solve_(); }
+inline bool     Solver::okay          ()      const   { return ok; }
+
+inline void     Solver::toDimacs      (const char* file){ vec<Lit> as; toDimacs(file, as); }
+inline void     Solver::toDimacs      (const char* file, Lit p){ vec<Lit> as; as.push(p); toDimacs(file, as); }
+inline void     Solver::toDimacs      (const char* file, Lit p, Lit q){ vec<Lit> as; as.push(p); as.push(q); toDimacs(file, as); }
+inline void     Solver::toDimacs      (const char* file, Lit p, Lit q, Lit r){ vec<Lit> as; as.push(p); as.push(q); as.push(r); toDimacs(file, as); }
+
+inline void     Solver::addVar(Var v) { while (v >= nVars()) newVar(); }
+
+//=================================================================================================
+// Debug etc:
+
+
+inline void Solver::printLit(Lit l)
+{
+    printf("%s%d:%c", sign(l) ? "-" : "", var(l)+1, value(l) == l_True ? '1' : (value(l) == l_False ? '0' : 'X'));
+}
+
+
+inline void Solver::printClause(CRef cr)
+{
+  Clause &c = ca[cr];
+    for (int i = 0; i < c.size(); i++){
+        printLit(c[i]);
+        printf(" ");
+    }
+}
+
+inline void Solver::printInitialClause(CRef cr)
+{
+  Clause &c = ca[cr];
+    for (int i = 0; i < c.size(); i++){
+      if(!isSelector(var(c[i]))) {
+    printLit(c[i]);
+        printf(" ");
+      }
+    }
+}
+
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/SolverTypes.h b/lib/bill/bill/sat/solver/abc/SolverTypes.h
new file mode 100644
index 0000000..e8c1742
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/SolverTypes.h
@@ -0,0 +1,442 @@
+/***********************************************************************************[SolverTypes.h]
+ Glucose -- Copyright (c) 2009, Gilles Audemard, Laurent Simon
+                CRIL - Univ. Artois, France
+                LRI  - Univ. Paris Sud, France
+ 
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose are exactly the same as Minisat on which it is based on. (see below).
+
+---------------
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Abc_Glucose_SolverTypes_h
+#define Abc_Glucose_SolverTypes_h
+
+#include <assert.h>
+
+#include "IntTypes.h"
+#include "Alg.h"
+#include "Vec.h"
+#include "Map.h"
+#include "Alloc.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// Variables, literals, lifted booleans, clauses:
+
+
+// NOTE! Variables are just integers. No abstraction here. They should be chosen from 0..N,
+// so that they can be used as array indices.
+
+typedef int Var;
+#define var_Undef (-1)
+
+
+struct Lit {
+    int     x;
+
+    // Use this as a constructor:
+    friend Lit mkLit(Var var, bool sign);
+    bool operator == (Lit p) const { return x == p.x; }
+    bool operator != (Lit p) const { return x != p.x; }
+    bool operator <  (Lit p) const { return x < p.x;  } // '<' makes p, ~p adjacent in the ordering.
+};
+
+
+inline  Lit  mkLit     (Var var, bool sign = false) { Lit p; p.x = var + var + (int)sign; return p; }
+inline  Lit  operator ~(Lit p)              { Lit q; q.x = p.x ^ 1; return q; }
+inline  Lit  operator ^(Lit p, bool b)      { Lit q; q.x = p.x ^ (unsigned int)b; return q; }
+inline  bool sign      (Lit p)              { return p.x & 1; }
+inline  int  var       (Lit p)              { return p.x >> 1; }
+
+// Mapping Literals to and from compact integers suitable for array indexing:
+inline  int  toInt     (Var v)              { return v; } 
+inline  int  toInt     (Lit p)              { return p.x; } 
+inline  Lit  toLit     (int i)              { Lit p; p.x = i; return p; } 
+
+//const Lit lit_Undef = mkLit(var_Undef, false);  // }- Useful special constants.
+//const Lit lit_Error = mkLit(var_Undef, true );  // }
+
+const Lit lit_Undef = { -2 };  // }- Useful special constants.
+const Lit lit_Error = { -1 };  // }
+
+
+//=================================================================================================
+// Lifted booleans:
+//
+// NOTE: this implementation is optimized for the case when comparisons between values are mostly
+//       between one variable and one constant. Some care had to be taken to make sure that gcc 
+//       does enough constant propagation to produce sensible code, and this appears to be somewhat
+//       fragile unfortunately.
+
+ class lbool {
+    uint8_t value;
+
+public:
+    constexpr explicit lbool(uint8_t v) : value(v) { }
+
+    lbool()       : value(0) { }
+    explicit lbool(bool x) : value(!x) { }
+
+    bool  operator == (lbool b) const { return ((b.value&2) & (value&2)) | (!(b.value&2)&(value == b.value)); }
+    bool  operator != (lbool b) const { return !(*this == b); }
+    lbool operator ^  (bool  b) const { return lbool((uint8_t)(value^(uint8_t)b)); }
+
+    lbool operator && (lbool b) const { 
+        uint8_t sel = (this->value << 1) | (b.value << 3);
+        uint8_t v   = (0xF7F755F4 >> sel) & 3;
+        return lbool(v); }
+
+    lbool operator || (lbool b) const {
+        uint8_t sel = (this->value << 1) | (b.value << 3);
+        uint8_t v   = (0xFCFCF400 >> sel) & 3;
+        return lbool(v); }
+
+    friend int   toInt  (lbool l);
+    friend lbool toLbool(int   v);
+};
+inline int   toInt  (lbool l) { return l.value; }
+inline lbool toLbool(int   v) { return lbool((uint8_t)v);  }
+
+constexpr auto l_True = Gluco::lbool((uint8_t)0);
+constexpr auto l_False = Gluco::lbool((uint8_t)1);
+constexpr auto l_Undef = Gluco::lbool((uint8_t)2);
+
+// #define l_True  (Gluco::lbool((uint8_t)0)) // gcc does not do constant propagation if these are real constants.
+// #define l_False (Gluco::lbool((uint8_t)1))
+// #define l_Undef (Gluco::lbool((uint8_t)2))
+
+
+//=================================================================================================
+// Clause -- a simple class for representing a clause:
+
+class Clause;
+typedef RegionAllocator<uint32_t>::Ref CRef;
+
+class Clause {
+    struct {
+      unsigned mark      : 2;
+      unsigned learnt    : 1;
+      unsigned has_extra : 1;
+      unsigned reloced   : 1;
+      unsigned lbd       : 26;
+      unsigned canbedel  : 1;
+      unsigned size      : 32;
+      unsigned szWithoutSelectors : 32;
+
+    }                            header;
+    union { Lit lit; float act; uint32_t abs; CRef rel; } data[0];
+
+    friend class ClauseAllocator;
+
+    // NOTE: This constructor cannot be used directly (doesn't allocate enough memory).
+    template<class V>
+    Clause(const V& ps, bool use_extra, bool learnt) {
+        header.mark      = 0;
+        header.learnt    = learnt;
+        header.has_extra = use_extra;
+        header.reloced   = 0;
+        header.size      = ps.size();
+    header.lbd = 0;
+    header.canbedel = 1;
+        for (int i = 0; i < ps.size(); i++) 
+            data[i].lit = ps[i];
+    
+        if (header.has_extra){
+      if (header.learnt) 
+                data[header.size].act = 0; 
+            else 
+                calcAbstraction(); }
+    }
+
+public:
+    void calcAbstraction() {
+        assert(header.has_extra);
+        uint32_t abstraction = 0;
+        for (int i = 0; i < size(); i++)
+            abstraction |= 1 << (var(data[i].lit) & 31);
+        data[header.size].abs = abstraction;  }
+
+
+    int          size        ()      const   { return header.size; }
+    void         shrink      (int i)         { assert(i <= size()); if (header.has_extra) data[header.size-i] = data[header.size]; header.size -= i; }
+    void         pop         ()              { shrink(1); }
+    bool         learnt      ()      const   { return header.learnt; }
+    bool         has_extra   ()      const   { return header.has_extra; }
+    uint32_t     mark        ()      const   { return header.mark; }
+    void         mark        (uint32_t m)    { header.mark = m; }
+    const Lit&   last        ()      const   { return data[header.size-1].lit; }
+
+    bool         reloced     ()      const   { return header.reloced; }
+    CRef         relocation  ()      const   { return data[0].rel; }
+    void         relocate    (CRef c)        { header.reloced = 1; data[0].rel = c; }
+
+    // NOTE: somewhat unsafe to change the clause in-place! Must manually call 'calcAbstraction' afterwards for
+    //       subsumption operations to behave correctly.
+    Lit&         operator [] (int i)         { return data[i].lit; }
+    Lit          operator [] (int i) const   { return data[i].lit; }
+    operator const Lit* (void) const         { return (Lit*)data; }
+
+    float&       activity    ()              { assert(header.has_extra); return data[header.size].act; }
+    uint32_t     abstraction () const        { assert(header.has_extra); return data[header.size].abs; }
+
+    Lit          subsumes    (const Clause& other) const;
+    void         strengthen  (Lit p);
+    void         setLBD(int i)  {header.lbd = i;} 
+    // unsigned int&       lbd    ()              { return header.lbd; }
+    unsigned int        lbd    () const        { return header.lbd; }
+    void setCanBeDel(bool b) {header.canbedel = b;}
+    bool canBeDel() {return header.canbedel;}
+    void setSizeWithoutSelectors   (unsigned int n)              {header.szWithoutSelectors = n; }
+    unsigned int        sizeWithoutSelectors   () const        { return header.szWithoutSelectors; }
+
+};
+
+
+//=================================================================================================
+// ClauseAllocator -- a simple class for allocating memory for clauses:
+
+
+const CRef CRef_Undef = RegionAllocator<uint32_t>::Ref_Undef;
+class ClauseAllocator : public RegionAllocator<uint32_t>
+{
+    static int clauseWord32Size(int size, bool has_extra){
+        return (sizeof(Clause) + (sizeof(Lit) * (size + (int)has_extra))) / sizeof(uint32_t); }
+ public:
+    bool extra_clause_field;
+
+    ClauseAllocator(uint32_t start_cap) : RegionAllocator<uint32_t>(start_cap), extra_clause_field(false){}
+    ClauseAllocator() : extra_clause_field(false){}
+
+    void moveTo(ClauseAllocator& to){
+        to.extra_clause_field = extra_clause_field;
+        RegionAllocator<uint32_t>::moveTo(to); }
+
+    template<class Lits>
+    CRef alloc(const Lits& ps, bool learnt = false)
+    {
+        assert(sizeof(Lit)      == sizeof(uint32_t));
+        assert(sizeof(float)    == sizeof(uint32_t));
+        bool use_extra = learnt | extra_clause_field;
+
+        CRef cid = RegionAllocator<uint32_t>::alloc(clauseWord32Size(ps.size(), use_extra));
+        new (lea(cid)) Clause(ps, use_extra, learnt);
+
+        return cid;
+    }
+
+    // Deref, Load Effective Address (LEA), Inverse of LEA (AEL):
+    Clause&       operator[](Ref r)       { return (Clause&)RegionAllocator<uint32_t>::operator[](r); }
+    const Clause& operator[](Ref r) const { return (Clause&)RegionAllocator<uint32_t>::operator[](r); }
+    Clause*       lea       (Ref r)       { return (Clause*)RegionAllocator<uint32_t>::lea(r); }
+    const Clause* lea       (Ref r) const { return (Clause*)RegionAllocator<uint32_t>::lea(r); }
+    Ref           ael       (const Clause* t){ return RegionAllocator<uint32_t>::ael((uint32_t*)t); }
+
+    void free_(CRef cid)
+    {
+        Clause& c = operator[](cid);
+        RegionAllocator<uint32_t>::free_(clauseWord32Size(c.size(), c.has_extra()));
+    }
+
+    void reloc(CRef& cr, ClauseAllocator& to)
+    {
+        Clause& c = operator[](cr);
+        
+        if (c.reloced()) { cr = c.relocation(); return; }
+        
+        cr = to.alloc(c, c.learnt());
+        c.relocate(cr);
+        
+        // Copy extra data-fields: 
+        // (This could be cleaned-up. Generalize Clause-constructor to be applicable here instead?)
+        to[cr].mark(c.mark());
+        if (to[cr].learnt())        {
+      to[cr].activity() = c.activity();
+      to[cr].setLBD(c.lbd());
+      to[cr].setSizeWithoutSelectors(c.sizeWithoutSelectors());
+      to[cr].setCanBeDel(c.canBeDel());
+    }
+        else if (to[cr].has_extra()) to[cr].calcAbstraction();
+    }
+};
+
+
+//=================================================================================================
+// OccLists -- a class for maintaining occurence lists with lazy deletion:
+
+template<class Idx, class Vec, class Deleted>
+class OccLists
+{
+    vec<Vec>  occs;
+    vec<char> dirty;
+    vec<Idx>  dirties;
+    Deleted   deleted;
+
+ public:
+    OccLists(const Deleted& d) : deleted(d) {}
+    
+    void  init      (const Idx& idx){ occs.growTo(toInt(idx)+1); dirty.growTo(toInt(idx)+1, 0); }
+    // Vec&  operator[](const Idx& idx){ return occs[toInt(idx)]; }
+    Vec&  operator[](const Idx& idx){ return occs[toInt(idx)]; }
+    Vec&  lookup    (const Idx& idx){ if (dirty[toInt(idx)]) clean(idx); return occs[toInt(idx)]; }
+
+    void  cleanAll  ();
+    void  clean     (const Idx& idx);
+    void  smudge    (const Idx& idx){
+        if (dirty[toInt(idx)] == 0){
+            dirty[toInt(idx)] = 1;
+            dirties.push(idx);
+        }
+    }
+
+    void  clear(bool free = true){
+        occs   .clear(free);
+        dirty  .clear(free);
+        dirties.clear(free);
+    }
+};
+
+
+template<class Idx, class Vec, class Deleted>
+void OccLists<Idx,Vec,Deleted>::cleanAll()
+{
+    for (int i = 0; i < dirties.size(); i++)
+        // Dirties may contain duplicates so check here if a variable is already cleaned:
+        if (dirty[toInt(dirties[i])])
+            clean(dirties[i]);
+    dirties.clear();
+}
+
+
+template<class Idx, class Vec, class Deleted>
+void OccLists<Idx,Vec,Deleted>::clean(const Idx& idx)
+{
+    Vec& vec = occs[toInt(idx)];
+    int  i, j;
+    for (i = j = 0; i < vec.size(); i++)
+        if (!deleted(vec[i]))
+            vec[j++] = vec[i];
+    vec.shrink(i - j);
+    dirty[toInt(idx)] = 0;
+}
+
+
+//=================================================================================================
+// CMap -- a class for mapping clauses to values:
+
+
+template<class T>
+class CMap
+{
+    struct CRefHash {
+        uint32_t operator()(CRef cr) const { return (uint32_t)cr; } };
+
+    typedef Map<CRef, T, CRefHash> HashTable;
+    HashTable map;
+        
+ public:
+    // Size-operations:
+    void     clear       ()                           { map.clear(); }
+    int      size        ()                const      { return map.elems(); }
+
+    
+    // Insert/Remove/Test mapping:
+    void     insert      (CRef cr, const T& t){ map.insert(cr, t); }
+    void     growTo      (CRef cr, const T& t){ map.insert(cr, t); } // NOTE: for compatibility
+    void     remove      (CRef cr)            { map.remove(cr); }
+    bool     has         (CRef cr, T& t)      { return map.peek(cr, t); }
+
+    // Vector interface (the clause 'c' must already exist):
+    const T& operator [] (CRef cr) const      { return map[cr]; }
+    T&       operator [] (CRef cr)            { return map[cr]; }
+
+    // Iteration (not transparent at all at the moment):
+    int  bucket_count() const { return map.bucket_count(); }
+    const vec<typename HashTable::Pair>& bucket(int i) const { return map.bucket(i); }
+
+    // Move contents to other map:
+    void moveTo(CMap& other){ map.moveTo(other.map); }
+
+    // TMP debug:
+    void debug(){
+        printf(" --- size = %d, bucket_count = %d\n", size(), map.bucket_count()); }
+};
+
+
+/*_________________________________________________________________________________________________
+|
+|  subsumes : (other : const Clause&)  ->  Lit
+|  
+|  Description:
+|       Checks if clause subsumes 'other', and at the same time, if it can be used to simplify 'other'
+|       by subsumption resolution.
+|  
+|    Result:
+|       lit_Error  - No subsumption or simplification
+|       lit_Undef  - Clause subsumes 'other'
+|       p          - The literal p can be deleted from 'other'
+|________________________________________________________________________________________________@*/
+inline Lit Clause::subsumes(const Clause& other) const
+{
+    //if (other.size() < size() || (extra.abst & ~other.extra.abst) != 0)
+    //if (other.size() < size() || (!learnt() && !other.learnt() && (extra.abst & ~other.extra.abst) != 0))
+    assert(!header.learnt);   assert(!other.header.learnt);
+    assert(header.has_extra); assert(other.header.has_extra);
+    if (other.header.size < header.size || (data[header.size].abs & ~other.data[other.header.size].abs) != 0)
+        return lit_Error;
+
+    Lit        ret = lit_Undef;
+    const Lit* c   = (const Lit*)(*this);
+    const Lit* d   = (const Lit*)other;
+
+    for (unsigned i = 0; i < header.size; i++) {
+        // search for c[i] or ~c[i]
+        for (unsigned j = 0; j < other.header.size; j++)
+            if (c[i] == d[j])
+                goto ok;
+            else if (ret == lit_Undef && c[i] == ~d[j]){
+                ret = c[i];
+                goto ok;
+            }
+
+        // did not find it
+        return lit_Error;
+    ok:;
+    }
+
+    return ret;
+}
+
+inline void Clause::strengthen(Lit p)
+{
+    remove(*this, p);
+    calcAbstraction();
+}
+ 
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/Sort.h b/lib/bill/bill/sat/solver/abc/Sort.h
new file mode 100644
index 0000000..acbae7f
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/Sort.h
@@ -0,0 +1,101 @@
+/******************************************************************************************[Sort.h]
+Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Abc_Glucose_Sort_h
+#define Abc_Glucose_Sort_h
+
+#include "Vec.h"
+
+//=================================================================================================
+// Some sorting algorithms for vec's
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+template<class T>
+struct LessThan_default {
+    bool operator () (T x, T y) { return x < y; }
+};
+
+
+template <class T, class LessThan>
+void selectionSort(T* array, int size, LessThan lt)
+{
+    int     i, j, best_i;
+    T       tmp;
+
+    for (i = 0; i < size-1; i++){
+        best_i = i;
+        for (j = i+1; j < size; j++){
+            if (lt(array[j], array[best_i]))
+                best_i = j;
+        }
+        tmp = array[i]; array[i] = array[best_i]; array[best_i] = tmp;
+    }
+}
+template <class T> static inline void selectionSort(T* array, int size) {
+    selectionSort(array, size, LessThan_default<T>()); }
+
+template <class T, class LessThan>
+void sort(T* array, int size, LessThan lt)
+{
+    if (size <= 15)
+        selectionSort(array, size, lt);
+
+    else{
+        T           pivot = array[size / 2];
+        T           tmp;
+        int         i = -1;
+        int         j = size;
+
+        for(;;){
+            do i++; while(lt(array[i], pivot));
+            do j--; while(lt(pivot, array[j]));
+
+            if (i >= j) break;
+
+            tmp = array[i]; array[i] = array[j]; array[j] = tmp;
+        }
+
+        sort(array    , i     , lt);
+        sort(&array[i], size-i, lt);
+    }
+}
+template <class T> static inline void sort(T* array, int size) {
+    sort(array, size, LessThan_default<T>()); }
+
+
+//=================================================================================================
+// For 'vec's:
+
+
+template <class T, class LessThan> void sort(vec<T>& v, LessThan lt) {
+    sort((T*)v, v.size(), lt); }
+template <class T> void sort(vec<T>& v) {
+    sort(v, LessThan_default<T>()); }
+
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/Vec.h b/lib/bill/bill/sat/solver/abc/Vec.h
new file mode 100644
index 0000000..6abd8de
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/Vec.h
@@ -0,0 +1,135 @@
+/*******************************************************************************************[Vec.h]
+Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Abc_Glucose_Vec_h
+#define Abc_Glucose_Vec_h
+
+#include <assert.h>
+#include <new>
+
+#include "IntTypes.h"
+#include "XAlloc.h"
+#include "abc_global.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// Automatically resizable arrays
+//
+// NOTE! Don't use this vector on datatypes that cannot be re-located in memory (with realloc)
+
+template<class T>
+class vec {
+    T*  data;
+    int sz;
+    int cap;
+
+    // Don't allow copying (error prone):
+    vec<T>&  operator = (vec<T>& other) { assert(0); return *this; }
+             vec        (vec<T>& other) { assert(0); }
+             
+    // Helpers for calculating next capacity:
+    static inline int  imax   (int x, int y) { int mask = (y-x) >> (sizeof(int)*8-1); return (x&mask) + (y&(~mask)); }
+    //static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; }
+    static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; }
+
+public:
+    // Constructors:
+    vec()                       : data(NULL) , sz(0)   , cap(0)    { }
+    explicit vec(int size)      : data(NULL) , sz(0)   , cap(0)    { growTo(size); }
+    vec(int size, const T& pad) : data(NULL) , sz(0)   , cap(0)    { growTo(size, pad); }
+   ~vec()                                                          { clear(true); }
+
+    // Pointer to first element:
+    operator T*       (void)           { return data; }
+
+    // Size operations:
+    int      size     (void) const     { return sz; }
+    void     shrink   (int nelems)     { assert(nelems <= sz); for (int i = 0; i < nelems; i++) sz--, data[sz].~T(); }
+    void     shrink_  (int nelems)     { assert(nelems <= sz); sz -= nelems; }
+    int      capacity (void) const     { return cap; }
+    void     capacity (int min_cap);
+    void     growTo   (int size);
+    void     growTo   (int size, const T& pad);
+    void     clear    (bool dealloc = false);
+
+    // Stack interface:
+    void     push  (void)              { if (sz == cap) capacity(sz+1); new (&data[sz]) T(); sz++; }
+    void     push  (const T& elem)     { if (sz == cap) capacity(sz+1); data[sz++] = elem; }
+    void     push_ (const T& elem)     { assert(sz < cap); data[sz++] = elem; }
+    void     pop   (void)              { assert(sz > 0); sz--, data[sz].~T(); }
+    // NOTE: it seems possible that overflow can happen in the 'sz+1' expression of 'push()', but
+    // in fact it can not since it requires that 'cap' is equal to INT_MAX. This in turn can not
+    // happen given the way capacities are calculated (below). Essentially, all capacities are
+    // even, but INT_MAX is odd.
+
+    const T& last  (void) const        { return data[sz-1]; }
+    T&       last  (void)              { return data[sz-1]; }
+
+    // Vector interface:
+    const T& operator [] (int index) const { return data[index]; }
+    T&       operator [] (int index)       { return data[index]; }
+
+    // Duplicatation (preferred instead):
+    void copyTo(vec<T>& copy) const { copy.clear(); copy.growTo(sz); for (int i = 0; i < sz; i++) copy[i] = data[i]; }
+    void moveTo(vec<T>& dest) { dest.clear(true); dest.data = data; dest.sz = sz; dest.cap = cap; data = NULL; sz = 0; cap = 0; }
+};
+
+
+template<class T>
+void vec<T>::capacity(int min_cap) {
+    if (cap >= min_cap) return;
+    int add = imax((min_cap - cap + 1) & ~1, ((cap >> 1) + 2) & ~1);   // NOTE: grow by approximately 3/2
+    if (add > INT_MAX - cap || (((data = (T*)::realloc(data, (cap += add) * sizeof(T))) == NULL) && errno == ENOMEM))
+        throw OutOfMemoryException();
+ }
+
+
+template<class T>
+void vec<T>::growTo(int size, const T& pad) {
+    if (sz >= size) return;
+    capacity(size);
+    for (int i = sz; i < size; i++) data[i] = pad;
+    sz = size; }
+
+
+template<class T>
+void vec<T>::growTo(int size) {
+    if (sz >= size) return;
+    capacity(size);
+    for (int i = sz; i < size; i++) new (&data[i]) T();
+    sz = size; }
+
+
+template<class T>
+void vec<T>::clear(bool dealloc) {
+    if (data != NULL){
+        for (int i = 0; i < sz; i++) data[i].~T();
+        sz = 0;
+        if (dealloc) free(data), data = NULL, cap = 0; } }
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/XAlloc.h b/lib/bill/bill/sat/solver/abc/XAlloc.h
new file mode 100644
index 0000000..814cb1b
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/XAlloc.h
@@ -0,0 +1,53 @@
+/****************************************************************************************[XAlloc.h]
+Copyright (c) 2009-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Abc_Glucose_XAlloc_h
+#define Abc_Glucose_XAlloc_h
+
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "abc_namespaces.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+namespace Gluco {
+
+//=================================================================================================
+// Simple layer on top of malloc/realloc to catch out-of-memory situtaions and provide some typing:
+
+class OutOfMemoryException{};
+static inline void* xrealloc(void *ptr, size_t size)
+{
+    void* mem = realloc(ptr, size);
+    if (mem == NULL && errno == ENOMEM){
+        throw OutOfMemoryException();
+    }else {
+        return mem;
+    }
+}
+
+//=================================================================================================
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/abc_global.h b/lib/bill/bill/sat/solver/abc/abc_global.h
new file mode 100644
index 0000000..8d94179
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/abc_global.h
@@ -0,0 +1,416 @@
+/**CFile****************************************************************
+
+  FileName    [abc_global.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Global declarations.]
+
+  Synopsis    [Global declarations.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - Jan 30, 2009.]
+
+  Revision    [$Id: abc_global.h,v 1.00 2009/01/30 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#ifndef ABC__misc__util__abc_global_h
+#define ABC__misc__util__abc_global_h
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include <cstdint>
+#ifdef _WIN32
+#ifndef __MINGW32__
+//#define inline __inline // compatible with MS VS 6.0
+#pragma warning(disable : 4152) // warning C4152: nonstandard extension, function/data pointer conversion in expression
+#pragma warning(disable : 4200) // warning C4200: nonstandard extension used : zero-sized array in struct/union
+#pragma warning(disable : 4244) // warning C4244: '+=' : conversion from 'int ' to 'unsigned short ', possible loss of data
+#pragma warning(disable : 4514) // warning C4514: 'Vec_StrPop' : unreferenced inline function has been removed
+#pragma warning(disable : 4710) // warning C4710: function 'Vec_PtrGrow' not inlined
+//#pragma warning( disable : 4273 )
+#endif
+#endif
+
+#ifdef WIN32
+  #ifdef WIN32_NO_DLL
+    #define ABC_DLLEXPORT
+    #define ABC_DLLIMPORT
+  #else
+    #define ABC_DLLEXPORT __declspec(dllexport)
+    #define ABC_DLLIMPORT __declspec(dllimport)
+  #endif
+#else  /* defined(WIN32) */
+#define ABC_DLLIMPORT
+#endif /* defined(WIN32) */
+
+#ifndef ABC_DLL
+#define ABC_DLL ABC_DLLIMPORT
+#endif
+
+#if !defined(___unused)
+#if defined(__GNUC__)
+#define ___unused __attribute__ ((__unused__))
+#else
+#define ___unused
+#endif
+#endif
+
+/*
+#ifdef __cplusplus
+#error "C++ code"
+#else
+#error "C code"
+#endif
+*/
+
+#include <time.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+// catch memory leaks in Visual Studio
+#ifdef WIN32
+  #ifdef _DEBUG
+    #define _CRTDBG_MAP_ALLOC
+    #include <crtdbg.h>
+  #endif
+#endif
+
+#ifdef _WIN32
+#include <Windows.h>
+#endif
+
+#include "abc_namespaces.h"
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+ABC_NAMESPACE_HEADER_START
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+/**
+ * Pointer difference type; replacement for ptrdiff_t.
+ * This is a signed integral type that is the same size as a pointer.
+ * NOTE: This type may be different sizes on different platforms.
+ */
+#if       defined(__ccdoc__)
+typedef platform_dependent_type ABC_PTRDIFF_T;
+#elif     defined(LIN64)
+typedef long ABC_PTRDIFF_T;
+#elif     defined(NT64)
+typedef long long ABC_PTRDIFF_T;
+#elif     defined(NT) || defined(LIN) || defined(WIN32)
+typedef int ABC_PTRDIFF_T;
+#else
+   #error unknown platform
+#endif /* defined(PLATFORM) */
+
+/**
+ * Unsigned integral type that can contain a pointer.
+ * This is an unsigned integral type that is the same size as a pointer.
+ * NOTE: This type may be different sizes on different platforms.
+ */
+#if       defined(__ccdoc__)
+typedef platform_dependent_type ABC_PTRUINT_T;
+#elif     defined(LIN64)
+typedef unsigned long ABC_PTRUINT_T;
+#elif     defined(NT64)
+typedef unsigned long long ABC_PTRUINT_T;
+#elif     defined(NT) || defined(LIN) || defined(WIN32)
+typedef unsigned int ABC_PTRUINT_T;
+#else
+   #error unknown platform
+#endif /* defined(PLATFORM) */
+
+/**
+ * Signed integral type that can contain a pointer.
+ * This is a signed integral type that is the same size as a pointer.
+ * NOTE: This type may be different sizes on different platforms.
+ */
+#if       defined(__ccdoc__)
+typedef platform_dependent_type ABC_PTRINT_T;
+#elif     defined(LIN64)
+typedef long ABC_PTRINT_T;
+#elif     defined(NT64)
+typedef long long ABC_PTRINT_T;
+#elif     defined(NT) || defined(LIN) || defined(WIN32)
+typedef int ABC_PTRINT_T;
+#else
+   #error unknown platform
+#endif /* defined(PLATFORM) */
+
+/**
+ * 64-bit signed integral type.
+ */
+#if       defined(__ccdoc__)
+typedef platform_dependent_type ABC_INT64_T;
+#elif     defined(LIN64)
+typedef long ABC_INT64_T;
+#elif     defined(NT64) || defined(LIN)
+typedef long long ABC_INT64_T;
+#elif     defined(WIN32) || defined(NT)
+typedef signed __int64 ABC_INT64_T;
+#else
+   #error unknown platform
+#endif /* defined(PLATFORM) */
+
+/**
+ * 64-bit unsigned integral type.
+ */
+typedef uint64_t ABC_UINT64_T;
+
+#ifdef LIN
+  #define ABC_CONST(number) number ## ULL 
+#else // LIN64 and windows
+  #define ABC_CONST(number) number
+#endif
+
+typedef ABC_UINT64_T word;
+typedef ABC_INT64_T iword;
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+#define ABC_INFINITY    (1000000000)
+
+#define ABC_SWAP(Type, a, b)  { Type t = a; a = b; b = t; }
+
+#define ABC_PRT(a,t)    (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec\n", 1.0*(t)/(CLOCKS_PER_SEC)))
+#define ABC_PRTr(a,t)   (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec\r", 1.0*(t)/(CLOCKS_PER_SEC)))
+#define ABC_PRTn(a,t)   (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec  ", 1.0*(t)/(CLOCKS_PER_SEC)))
+#define ABC_PRTP(a,t,T) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec (%6.2f %%)\n", 1.0*(t)/(CLOCKS_PER_SEC), (T)? 100.0*(t)/(T) : 0.0))
+#define ABC_PRM(a,f)    (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB\n",    1.0*(f)/(1<<20)))
+#define ABC_PRMr(a,f)   (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB\r",    1.0*(f)/(1<<20)))
+#define ABC_PRMn(a,f)   (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB  ",    1.0*(f)/(1<<20)))
+#define ABC_PRMP(a,f,F) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB (%6.2f %%)\n",  (1.0*(f)/(1<<20)), ((F)? 100.0*(f)/(F) : 0.0) ) )
+
+#define ABC_ALLOC(type, num)     ((type *) malloc(sizeof(type) * (num)))
+#define ABC_CALLOC(type, num)    ((type *) calloc((num), sizeof(type)))
+#define ABC_FALLOC(type, num)    ((type *) memset(malloc(sizeof(type) * (num)), 0xff, sizeof(type) * (num)))
+#define ABC_FREE(obj)            ((obj) ? (free((char *) (obj)), (obj) = 0) : 0)
+#define ABC_REALLOC(type, obj, num) \
+        ((obj) ? ((type *) realloc((char *)(obj), sizeof(type) * (num))) : \
+         ((type *) malloc(sizeof(type) * (num))))
+
+static inline int      Abc_AbsInt( int a        )             { return a < 0 ? -a : a; }
+static inline int      Abc_MaxInt( int a, int b )             { return a > b ?  a : b; }
+static inline int      Abc_MinInt( int a, int b )             { return a < b ?  a : b; }
+static inline word     Abc_MaxWord( word a, word b )          { return a > b ?  a : b; }
+static inline word     Abc_MinWord( word a, word b )          { return a < b ?  a : b; }
+static inline float    Abc_AbsFloat( float a          )       { return a < 0 ? -a : a; }
+static inline float    Abc_MaxFloat( float a, float b )       { return a > b ?  a : b; }
+static inline float    Abc_MinFloat( float a, float b )       { return a < b ?  a : b; }
+static inline double   Abc_AbsDouble( double a           )    { return a < 0 ? -a : a; }
+static inline double   Abc_MaxDouble( double a, double b )    { return a > b ?  a : b; }
+static inline double   Abc_MinDouble( double a, double b )    { return a < b ?  a : b; }
+
+static inline int      Abc_Float2Int( float Val )             { union { int x; float y; } v; v.y = Val; return v.x;         }
+static inline float    Abc_Int2Float( int Num )               { union { int x; float y; } v; v.x = Num; return v.y;         }
+static inline word     Abc_Dbl2Word( double Dbl )             { union { word x; double y; } v; v.y = Dbl; return v.x;       }
+static inline double   Abc_Word2Dbl( word Num )               { union { word x; double y; } v; v.x = Num; return v.y;       }
+static inline int      Abc_Base2Log( unsigned n )             { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n >>= 1, r++ ) {}; return r; }
+static inline int      Abc_Base10Log( unsigned n )            { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n /= 10, r++ ) {}; return r; }
+static inline int      Abc_Base16Log( unsigned n )            { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n /= 16, r++ ) {}; return r; }
+static inline char *   Abc_UtilStrsav( char * s )             { return s ? strcpy(ABC_ALLOC(char, strlen(s)+1), s) : NULL;  }
+static inline int      Abc_BitWordNum( int nBits )            { return (nBits>>5) + ((nBits&31) > 0);                       }
+static inline int      Abc_Bit6WordNum( int nBits )           { return (nBits>>6) + ((nBits&63) > 0);                       }
+static inline int      Abc_TruthWordNum( int nVars )          { return nVars <= 5 ? 1 : (1 << (nVars - 5));                 }
+static inline int      Abc_Truth6WordNum( int nVars )         { return nVars <= 6 ? 1 : (1 << (nVars - 6));                 }
+static inline int      Abc_InfoHasBit( unsigned * p, int i )  { return (p[(i)>>5] & (1<<((i) & 31))) > 0;                   }
+static inline void     Abc_InfoSetBit( unsigned * p, int i )  { p[(i)>>5] |= (1<<((i) & 31));                               }
+static inline void     Abc_InfoXorBit( unsigned * p, int i )  { p[(i)>>5] ^= (1<<((i) & 31));                               }
+static inline unsigned Abc_InfoMask( int nVar )               { return (~(unsigned)0) >> (32-nVar);                         }
+
+static inline int      Abc_Var2Lit( int Var, int c )          { assert(Var >= 0 && !(c >> 1)); return Var + Var + c;        }
+static inline int      Abc_Lit2Var( int Lit )                 { assert(Lit >= 0); return Lit >> 1;                          }
+static inline int      Abc_LitIsCompl( int Lit )              { assert(Lit >= 0); return Lit & 1;                           }
+static inline int      Abc_LitNot( int Lit )                  { assert(Lit >= 0); return Lit ^ 1;                           }
+static inline int      Abc_LitNotCond( int Lit, int c )       { assert(Lit >= 0); return Lit ^ (int)(c > 0);                }
+static inline int      Abc_LitRegular( int Lit )              { assert(Lit >= 0); return Lit & ~01;                         }
+static inline int      Abc_Lit2LitV( int * pMap, int Lit )    { assert(Lit >= 0); return Abc_Var2Lit( pMap[Abc_Lit2Var(Lit)], Abc_LitIsCompl(Lit) );      }
+static inline int      Abc_Lit2LitL( int * pMap, int Lit )    { assert(Lit >= 0); return Abc_LitNotCond( pMap[Abc_Lit2Var(Lit)], Abc_LitIsCompl(Lit) );   }
+
+static inline int      Abc_Ptr2Int( void * p )                { return (int)(ABC_PTRINT_T)p;      }
+static inline void *   Abc_Int2Ptr( int i )                   { return (void *)(ABC_PTRINT_T)i;   }
+static inline word     Abc_Ptr2Wrd( void * p )                { return (word)(ABC_PTRUINT_T)p;    }
+static inline void *   Abc_Wrd2Ptr( word i )                  { return (void *)(ABC_PTRUINT_T)i;  }
+
+static inline int      Abc_Var2Lit2( int Var, int Att )       { assert(!(Att >> 2)); return (Var << 2) + Att; }
+static inline int      Abc_Lit2Var2( int Lit )                { assert(Lit >= 0);    return Lit >> 2;         }
+static inline int      Abc_Lit2Att2( int Lit )                { assert(Lit >= 0);    return Lit & 3;          }
+static inline int      Abc_Var2Lit3( int Var, int Att )       { assert(!(Att >> 3)); return (Var << 3) + Att; }
+static inline int      Abc_Lit2Var3( int Lit )                { assert(Lit >= 0);    return Lit >> 3;         }
+static inline int      Abc_Lit2Att3( int Lit )                { assert(Lit >= 0);    return Lit & 7;          }
+static inline int      Abc_Var2Lit4( int Var, int Att )       { assert(!(Att >> 4)); return (Var << 4) + Att; }
+static inline int      Abc_Lit2Var4( int Lit )                { assert(Lit >= 0);    return Lit >> 4;         }
+static inline int      Abc_Lit2Att4( int Lit )                { assert(Lit >= 0);    return Lit & 15;         }
+
+// time counting
+typedef ABC_INT64_T abctime;
+static inline abctime Abc_Clock()
+{
+#if (defined(LIN) || defined(LIN64)) && !(__APPLE__ & __MACH__) && !defined(__MINGW32__)
+    struct timespec ts;
+#ifdef _WIN32
+    if ( clock_gettime(0, &ts) < 0 ) 
+        return (abctime)-1;
+#else
+    if ( clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) < 0 ) 
+        return (abctime)-1;
+#endif
+    abctime res = ((abctime) ts.tv_sec) * CLOCKS_PER_SEC;
+    res += (((abctime) ts.tv_nsec) * CLOCKS_PER_SEC) / 1000000000;
+    return res;
+#else
+    return (abctime) clock();
+#endif
+}
+
+// bridge communication
+#define BRIDGE_NETLIST           106
+#define BRIDGE_ABS_NETLIST       107
+extern int Gia_ManToBridgeText( FILE * pFile, int Size, unsigned char * pBuffer );
+extern int Gia_ManToBridgeAbsNetlist( FILE * pFile, void * p, int pkg_type );
+
+// string printing
+extern char * vnsprintf(const char* format, va_list args);
+extern char * nsprintf(const char* format, ...);
+
+
+// misc printing procedures
+enum Abc_VerbLevel
+{
+    ABC_PROMPT   = -2,
+    ABC_ERROR    = -1,
+    ABC_WARNING  =  0,
+    ABC_STANDARD =  1,
+    ABC_VERBOSE  =  2
+};
+static inline void Abc_Print( int level, const char * format, ... )
+{
+    extern ABC_DLL int Abc_FrameIsBridgeMode();
+    va_list args;
+
+    if ( ! Abc_FrameIsBridgeMode() ){
+        if ( level == ABC_ERROR )
+            printf( "Error: " );
+        else if ( level == ABC_WARNING )
+            printf( "Warning: " );
+    }else{
+        if ( level == ABC_ERROR )
+            Gia_ManToBridgeText( stdout, (int)strlen("Error: "), (unsigned char*)"Error: " );
+        else if ( level == ABC_WARNING )
+            Gia_ManToBridgeText( stdout, (int)strlen("Warning: "), (unsigned char*)"Warning: " );
+    }
+
+    va_start( args, format );
+    if ( Abc_FrameIsBridgeMode() )
+    {
+        char * tmp = vnsprintf( format, args );
+        Gia_ManToBridgeText( stdout, (int)strlen(tmp), (unsigned char*)tmp );
+        free( tmp );
+    }
+    else
+        vprintf( format, args );
+    va_end( args );
+}
+
+static inline void Abc_PrintInt( int i )
+{
+    double v3 = (double)i/1000;
+    double v6 = (double)i/1000000;
+
+    Abc_Print( 1,  "  " );
+
+    if ( i > -1000 && i < 1000 )
+        Abc_Print( 1, " %4d", i );
+
+    else if ( v3 > -9.995 && v3 < 9.995 )
+        Abc_Print( 1, "%4.2fk", v3 );
+    else if ( v3 > -99.95 && v3 < 99.95 )
+        Abc_Print( 1, "%4.1fk", v3 );
+    else if ( v3 > -999.5 && v3 < 999.5 )
+        Abc_Print( 1, "%4.0fk", v3 );
+
+    else if ( v6 > -9.995 && v6 < 9.995 )
+        Abc_Print( 1, "%4.2fm", v6 );
+    else if ( v6 > -99.95 && v6 < 99.95 )
+        Abc_Print( 1, "%4.1fm", v6 );
+    else if ( v6 > -999.5 && v6 < 999.5 )
+        Abc_Print( 1, "%4.0fm", v6 );
+}
+
+static inline void Abc_PrintTime( int level, const char * pStr, abctime time )
+{
+    ABC_PRT( pStr, time );
+}
+
+static inline void Abc_PrintTimeP( int level, const char * pStr, abctime time, abctime Time )
+{
+    ABC_PRTP( pStr, time, Time );
+}
+
+static inline void Abc_PrintMemoryP( int level, const char * pStr, int mem, int Mem )
+{
+    ABC_PRMP( pStr, mem, Mem );
+}
+
+// Returns the next prime >= p
+static inline int Abc_PrimeCudd( unsigned int p )
+{
+    int i,pn;
+    p--;
+    do {
+        p++;
+        if (p&1)
+        {
+            pn = 1;
+            i = 3;
+            while ((unsigned) (i * i) <= p)
+            {
+                if (p % i == 0) {
+                    pn = 0;
+                    break;
+                }
+                i += 2;
+            }
+        }
+        else
+            pn = 0;
+    } while (!pn);
+    return(p);
+
+} // end of Cudd_Prime 
+
+
+// sorting
+extern void   Abc_MergeSort( int * pInput, int nSize );
+extern int *  Abc_MergeSortCost( int * pCosts, int nSize );
+extern void   Abc_QuickSort1( word * pData, int nSize, int fDecrease );
+extern void   Abc_QuickSort2( word * pData, int nSize, int fDecrease );
+extern void   Abc_QuickSort3( word * pData, int nSize, int fDecrease );
+extern void   Abc_QuickSortCostData( int * pCosts, int nSize, int fDecrease, word * pData, int * pResult );
+extern int *  Abc_QuickSortCost( int * pCosts, int nSize, int fDecrease );
+
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
diff --git a/lib/bill/bill/sat/solver/abc/abc_namespaces.h b/lib/bill/bill/sat/solver/abc/abc_namespaces.h
new file mode 100644
index 0000000..8cd681c
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/abc_namespaces.h
@@ -0,0 +1,74 @@
+/**CFile****************************************************************
+
+  FileName    [abc_namespaces.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Namespace logic.]
+
+  Synopsis    []
+
+  Author      [Alan Mishchenko]
+
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - Nov 20, 2015.]
+
+  Revision    []
+
+***********************************************************************/
+
+#ifndef ABC__misc__util__abc_namespaces_h
+#define ABC__misc__util__abc_namespaces_h
+
+
+////////////////////////////////////////////////////////////////////////
+///                         NAMESPACES                               ///
+////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+#  ifdef ABC_NAMESPACE
+#    define ABC_NAMESPACE_HEADER_START namespace ABC_NAMESPACE {
+#    define ABC_NAMESPACE_HEADER_END }
+#    define ABC_NAMESPACE_CXX_HEADER_START ABC_NAMESPACE_HEADER_START
+#    define ABC_NAMESPACE_CXX_HEADER_END ABC_NAMESPACE_HEADER_END
+#    define ABC_NAMESPACE_IMPL_START namespace ABC_NAMESPACE {
+#    define ABC_NAMESPACE_IMPL_END }
+#    define ABC_NAMESPACE_PREFIX ABC_NAMESPACE::
+#    define ABC_NAMESPACE_USING_NAMESPACE using namespace ABC_NAMESPACE;
+#  else
+#    define ABC_NAMESPACE_HEADER_START extern "C" {
+#    define ABC_NAMESPACE_HEADER_END }
+#    define ABC_NAMESPACE_CXX_HEADER_START
+#    define ABC_NAMESPACE_CXX_HEADER_END
+#    define ABC_NAMESPACE_IMPL_START
+#    define ABC_NAMESPACE_IMPL_END
+#    define ABC_NAMESPACE_PREFIX
+#    define ABC_NAMESPACE_USING_NAMESPACE
+#  endif // #ifdef ABC_NAMESPACE
+#ifdef SATOKO_NAMESPACE
+    #define SATOKO_NAMESPACE_HEADER_START namespace SATOKO_NAMESPACE {
+    #define SATOKO_NAMESPACE_HEADER_END }
+    #define SATOKO_NAMESPACE_CXX_HEADER_START ABC_NAMESPACE_HEADER_START
+    #define SATOKO_NAMESPACE_CXX_HEADER_END ABC_NAMESPACE_HEADER_END
+    #define SATOKO_NAMESPACE_IMPL_START namespace SATOKO_NAMESPACE {
+    #define SATOKO_NAMESPACE_IMPL_END }
+    #define SATOKO_NAMESPACE_PREFIX SATOKO_NAMESPACE::
+    #define SATOKO_NAMESPACE_USING_NAMESPACE using namespace SATOKO_NAMESPACE;
+#endif
+#else
+#  define ABC_NAMESPACE_HEADER_START
+#  define ABC_NAMESPACE_HEADER_END
+#  define ABC_NAMESPACE_CXX_HEADER_START
+#  define ABC_NAMESPACE_CXX_HEADER_END
+#  define ABC_NAMESPACE_IMPL_START
+#  define ABC_NAMESPACE_IMPL_END
+#  define ABC_NAMESPACE_PREFIX
+#  define ABC_NAMESPACE_USING_NAMESPACE
+#endif // #ifdef __cplusplus
+
+#endif // #ifndef ABC__misc__util__abc_namespaces_h
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
diff --git a/lib/bill/bill/sat/solver/abc/pstdint.h b/lib/bill/bill/sat/solver/abc/pstdint.h
new file mode 100644
index 0000000..989d016
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/pstdint.h
@@ -0,0 +1,919 @@
+/*  A portable stdint.h
+ ****************************************************************************
+ *  BSD License:
+ ****************************************************************************
+ *
+ *  Copyright (c) 2005-2016 Paul Hsieh
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, 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 name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS 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 AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 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.
+ *
+ ****************************************************************************
+ *
+ *  Version 0.1.16.0
+ *
+ *  The ANSI C standard committee, for the C99 standard, specified the
+ *  inclusion of a new standard include file called stdint.h.  This is
+ *  a very useful and long desired include file which contains several
+ *  very precise definitions for integer scalar types that is critically
+ *  important for making several classes of applications portable
+ *  including cryptography, hashing, variable length integer libraries
+ *  and so on.  But for most developers its likely useful just for
+ *  programming sanity.
+ *
+ *  The problem is that some compiler vendors chose to ignore the C99
+ *  standard and some older compilers have no opportunity to be updated.
+ *  Because of this situation, simply including stdint.h in your code
+ *  makes it unportable.
+ *
+ *  So that's what this file is all about.  It's an attempt to build a
+ *  single universal include file that works on as many platforms as
+ *  possible to deliver what stdint.h is supposed to.  Even compilers
+ *  that already come with stdint.h can use this file instead without
+ *  any loss of functionality.  A few things that should be noted about
+ *  this file:
+ *
+ *    1) It is not guaranteed to be portable and/or present an identical
+ *       interface on all platforms.  The extreme variability of the
+ *       ANSI C standard makes this an impossibility right from the
+ *       very get go. Its really only meant to be useful for the vast
+ *       majority of platforms that possess the capability of
+ *       implementing usefully and precisely defined, standard sized
+ *       integer scalars.  Systems which are not intrinsically 2s
+ *       complement may produce invalid constants.
+ *
+ *    2) There is an unavoidable use of non-reserved symbols.
+ *
+ *    3) Other standard include files are invoked.
+ *
+ *    4) This file may come in conflict with future platforms that do
+ *       include stdint.h.  The hope is that one or the other can be
+ *       used with no real difference.
+ *
+ *    5) In the current version, if your platform can't represent
+ *       int32_t, int16_t and int8_t, it just dumps out with a compiler
+ *       error.
+ *
+ *    6) 64 bit integers may or may not be defined.  Test for their
+ *       presence with the test: #ifdef INT64_MAX or #ifdef UINT64_MAX.
+ *       Note that this is different from the C99 specification which
+ *       requires the existence of 64 bit support in the compiler.  If
+ *       this is not defined for your platform, yet it is capable of
+ *       dealing with 64 bits then it is because this file has not yet
+ *       been extended to cover all of your system's capabilities.
+ *
+ *    7) (u)intptr_t may or may not be defined.  Test for its presence
+ *       with the test: #ifdef PTRDIFF_MAX.  If this is not defined
+ *       for your platform, then it is because this file has not yet
+ *       been extended to cover all of your system's capabilities, not
+ *       because its optional.
+ *
+ *    8) The following might not been defined even if your platform is
+ *       capable of defining it:
+ *
+ *       WCHAR_MIN
+ *       WCHAR_MAX
+ *       (u)int64_t
+ *       PTRDIFF_MIN
+ *       PTRDIFF_MAX
+ *       (u)intptr_t
+ *
+ *    9) The following have not been defined:
+ *
+ *       WINT_MIN
+ *       WINT_MAX
+ *
+ *   10) The criteria for defining (u)int_least(*)_t isn't clear,
+ *       except for systems which don't have a type that precisely
+ *       defined 8, 16, or 32 bit types (which this include file does
+ *       not support anyways). Default definitions have been given.
+ *
+ *   11) The criteria for defining (u)int_fast(*)_t isn't something I
+ *       would trust to any particular compiler vendor or the ANSI C
+ *       committee.  It is well known that "compatible systems" are
+ *       commonly created that have very different performance
+ *       characteristics from the systems they are compatible with,
+ *       especially those whose vendors make both the compiler and the
+ *       system.  Default definitions have been given, but its strongly
+ *       recommended that users never use these definitions for any
+ *       reason (they do *NOT* deliver any serious guarantee of
+ *       improved performance -- not in this file, nor any vendor's
+ *       stdint.h).
+ *
+ *   12) The following macros:
+ *
+ *       PRINTF_INTMAX_MODIFIER
+ *       PRINTF_INT64_MODIFIER
+ *       PRINTF_INT32_MODIFIER
+ *       PRINTF_INT16_MODIFIER
+ *       PRINTF_LEAST64_MODIFIER
+ *       PRINTF_LEAST32_MODIFIER
+ *       PRINTF_LEAST16_MODIFIER
+ *       PRINTF_INTPTR_MODIFIER
+ *
+ *       are strings which have been defined as the modifiers required
+ *       for the "d", "u" and "x" printf formats to correctly output
+ *       (u)intmax_t, (u)int64_t, (u)int32_t, (u)int16_t, (u)least64_t,
+ *       (u)least32_t, (u)least16_t and (u)intptr_t types respectively.
+ *       PRINTF_INTPTR_MODIFIER is not defined for some systems which
+ *       provide their own stdint.h.  PRINTF_INT64_MODIFIER is not
+ *       defined if INT64_MAX is not defined.  These are an extension
+ *       beyond what C99 specifies must be in stdint.h.
+ *
+ *       In addition, the following macros are defined:
+ *
+ *       PRINTF_INTMAX_HEX_WIDTH
+ *       PRINTF_INT64_HEX_WIDTH
+ *       PRINTF_INT32_HEX_WIDTH
+ *       PRINTF_INT16_HEX_WIDTH
+ *       PRINTF_INT8_HEX_WIDTH
+ *       PRINTF_INTMAX_DEC_WIDTH
+ *       PRINTF_INT64_DEC_WIDTH
+ *       PRINTF_INT32_DEC_WIDTH
+ *       PRINTF_INT16_DEC_WIDTH
+ *       PRINTF_UINT8_DEC_WIDTH
+ *       PRINTF_UINTMAX_DEC_WIDTH
+ *       PRINTF_UINT64_DEC_WIDTH
+ *       PRINTF_UINT32_DEC_WIDTH
+ *       PRINTF_UINT16_DEC_WIDTH
+ *       PRINTF_UINT8_DEC_WIDTH
+ *
+ *       Which specifies the maximum number of characters required to
+ *       print the number of that type in either hexadecimal or decimal.
+ *       These are an extension beyond what C99 specifies must be in
+ *       stdint.h.
+ *
+ *  Compilers tested (all with 0 warnings at their highest respective
+ *  settings): Borland Turbo C 2.0, WATCOM C/C++ 11.0 (16 bits and 32
+ *  bits), Microsoft Visual C++ 6.0 (32 bit), Microsoft Visual Studio
+ *  .net (VC7), Intel C++ 4.0, GNU gcc v3.3.3
+ *
+ *  This file should be considered a work in progress.  Suggestions for
+ *  improvements, especially those which increase coverage are strongly
+ *  encouraged.
+ *
+ *  Acknowledgements
+ *
+ *  The following people have made significant contributions to the
+ *  development and testing of this file:
+ *
+ *  Chris Howie
+ *  John Steele Scott
+ *  Dave Thorup
+ *  John Dill
+ *  Florian Wobbe
+ *  Christopher Sean Morrison
+ *  Mikkel Fahnoe Jorgensen
+ *
+ */
+
+#include <stddef.h>
+#include <limits.h>
+#include <signal.h>
+
+/*
+ *  For gcc with _STDINT_H, fill in the PRINTF_INT*_MODIFIER macros, and
+ *  do nothing else.  On the Mac OS X version of gcc this is _STDINT_H_.
+ */
+
+#if ((defined(__SUNPRO_C) && __SUNPRO_C >= 0x570) || (defined(_MSC_VER) && _MSC_VER >= 1600) || (defined(__STDC__) && __STDC__ && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || (defined (__WATCOMC__) && (defined (_STDINT_H_INCLUDED) || __WATCOMC__ >= 1250)) || (defined(__GNUC__) && (__GNUC__ > 3 || defined(_STDINT_H) || defined(_STDINT_H_) || defined (__UINT_FAST64_TYPE__)) )) && !defined (_PSTDINT_H_INCLUDED)
+#include <stdint.h>
+#define _PSTDINT_H_INCLUDED
+# if defined(__GNUC__) && (defined(__x86_64__) || defined(__ppc64__)) && !(defined(__APPLE__) && defined(__MACH__))
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "l"
+#  endif
+#  ifndef PRINTF_INT32_MODIFIER
+#   define PRINTF_INT32_MODIFIER ""
+#  endif
+# else
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "ll"
+#  endif
+#  ifndef PRINTF_INT32_MODIFIER
+#   if (UINT_MAX == UINT32_MAX)
+#    define PRINTF_INT32_MODIFIER ""
+#   else
+#    define PRINTF_INT32_MODIFIER "l"
+#   endif
+#  endif
+# endif
+# ifndef PRINTF_INT16_MODIFIER
+#  define PRINTF_INT16_MODIFIER "h"
+# endif
+# ifndef PRINTF_INTMAX_MODIFIER
+#  define PRINTF_INTMAX_MODIFIER PRINTF_INT64_MODIFIER
+# endif
+# ifndef PRINTF_INT64_HEX_WIDTH
+#  define PRINTF_INT64_HEX_WIDTH "16"
+# endif
+# ifndef PRINTF_UINT64_HEX_WIDTH
+#  define PRINTF_UINT64_HEX_WIDTH "16"
+# endif
+# ifndef PRINTF_INT32_HEX_WIDTH
+#  define PRINTF_INT32_HEX_WIDTH "8"
+# endif
+# ifndef PRINTF_UINT32_HEX_WIDTH
+#  define PRINTF_UINT32_HEX_WIDTH "8"
+# endif
+# ifndef PRINTF_INT16_HEX_WIDTH
+#  define PRINTF_INT16_HEX_WIDTH "4"
+# endif
+# ifndef PRINTF_UINT16_HEX_WIDTH
+#  define PRINTF_UINT16_HEX_WIDTH "4"
+# endif
+# ifndef PRINTF_INT8_HEX_WIDTH
+#  define PRINTF_INT8_HEX_WIDTH "2"
+# endif
+# ifndef PRINTF_UINT8_HEX_WIDTH
+#  define PRINTF_UINT8_HEX_WIDTH "2"
+# endif
+# ifndef PRINTF_INT64_DEC_WIDTH
+#  define PRINTF_INT64_DEC_WIDTH "19"
+# endif
+# ifndef PRINTF_UINT64_DEC_WIDTH
+#  define PRINTF_UINT64_DEC_WIDTH "20"
+# endif
+# ifndef PRINTF_INT32_DEC_WIDTH
+#  define PRINTF_INT32_DEC_WIDTH "10"
+# endif
+# ifndef PRINTF_UINT32_DEC_WIDTH
+#  define PRINTF_UINT32_DEC_WIDTH "10"
+# endif
+# ifndef PRINTF_INT16_DEC_WIDTH
+#  define PRINTF_INT16_DEC_WIDTH "5"
+# endif
+# ifndef PRINTF_UINT16_DEC_WIDTH
+#  define PRINTF_UINT16_DEC_WIDTH "5"
+# endif
+# ifndef PRINTF_INT8_DEC_WIDTH
+#  define PRINTF_INT8_DEC_WIDTH "3"
+# endif
+# ifndef PRINTF_UINT8_DEC_WIDTH
+#  define PRINTF_UINT8_DEC_WIDTH "3"
+# endif
+# ifndef PRINTF_INTMAX_HEX_WIDTH
+#  define PRINTF_INTMAX_HEX_WIDTH PRINTF_UINT64_HEX_WIDTH
+# endif
+# ifndef PRINTF_UINTMAX_HEX_WIDTH
+#  define PRINTF_UINTMAX_HEX_WIDTH PRINTF_UINT64_HEX_WIDTH
+# endif
+# ifndef PRINTF_INTMAX_DEC_WIDTH
+#  define PRINTF_INTMAX_DEC_WIDTH PRINTF_UINT64_DEC_WIDTH
+# endif
+# ifndef PRINTF_UINTMAX_DEC_WIDTH
+#  define PRINTF_UINTMAX_DEC_WIDTH PRINTF_UINT64_DEC_WIDTH
+# endif
+
+/*
+ *  Something really weird is going on with Open Watcom.  Just pull some of
+ *  these duplicated definitions from Open Watcom's stdint.h file for now.
+ */
+
+# if defined (__WATCOMC__) && __WATCOMC__ >= 1250
+#  if !defined (INT64_C)
+#   define INT64_C(x)   (x + (INT64_MAX - INT64_MAX))
+#  endif
+#  if !defined (UINT64_C)
+#   define UINT64_C(x)  (x + (UINT64_MAX - UINT64_MAX))
+#  endif
+#  if !defined (INT32_C)
+#   define INT32_C(x)   (x + (INT32_MAX - INT32_MAX))
+#  endif
+#  if !defined (UINT32_C)
+#   define UINT32_C(x)  (x + (UINT32_MAX - UINT32_MAX))
+#  endif
+#  if !defined (INT16_C)
+#   define INT16_C(x)   (x)
+#  endif
+#  if !defined (UINT16_C)
+#   define UINT16_C(x)  (x)
+#  endif
+#  if !defined (INT8_C)
+#   define INT8_C(x)   (x)
+#  endif
+#  if !defined (UINT8_C)
+#   define UINT8_C(x)  (x)
+#  endif
+#  if !defined (UINT64_MAX)
+#   define UINT64_MAX  18446744073709551615ULL
+#  endif
+#  if !defined (INT64_MAX)
+#   define INT64_MAX  9223372036854775807LL
+#  endif
+#  if !defined (UINT32_MAX)
+#   define UINT32_MAX  4294967295UL
+#  endif
+#  if !defined (INT32_MAX)
+#   define INT32_MAX  2147483647L
+#  endif
+#  if !defined (INTMAX_MAX)
+#   define INTMAX_MAX INT64_MAX
+#  endif
+#  if !defined (INTMAX_MIN)
+#   define INTMAX_MIN INT64_MIN
+#  endif
+# endif
+#endif
+
+/*
+ *  I have no idea what is the truly correct thing to do on older Solaris.
+ *  From some online discussions, this seems to be what is being
+ *  recommended.  For people who actually are developing on older Solaris,
+ *  what I would like to know is, does this define all of the relevant
+ *  macros of a complete stdint.h?  Remember, in pstdint.h 64 bit is
+ *  considered optional.
+ */
+
+#if (defined(__SUNPRO_C) && __SUNPRO_C >= 0x420) && !defined(_PSTDINT_H_INCLUDED)
+#include <sys/inttypes.h>
+#define _PSTDINT_H_INCLUDED
+#endif
+
+#ifndef _PSTDINT_H_INCLUDED
+#define _PSTDINT_H_INCLUDED
+
+#ifndef SIZE_MAX
+# define SIZE_MAX ((size_t)-1)
+#endif
+
+/*
+ *  Deduce the type assignments from limits.h under the assumption that
+ *  integer sizes in bits are powers of 2, and follow the ANSI
+ *  definitions.
+ */
+
+#ifndef UINT8_MAX
+# define UINT8_MAX 0xff
+#endif
+#if !defined(uint8_t) && !defined(_UINT8_T) && !defined(vxWorks)
+# if (UCHAR_MAX == UINT8_MAX) || defined (S_SPLINT_S)
+    typedef unsigned char uint8_t;
+#   define UINT8_C(v) ((uint8_t) v)
+# else
+#   error "Platform not supported"
+# endif
+#endif
+
+#ifndef INT8_MAX
+# define INT8_MAX 0x7f
+#endif
+#ifndef INT8_MIN
+# define INT8_MIN INT8_C(0x80)
+#endif
+#if !defined(int8_t) && !defined(_INT8_T) && !defined(vxWorks)
+# if (SCHAR_MAX == INT8_MAX) || defined (S_SPLINT_S)
+    typedef signed char int8_t;
+#   define INT8_C(v) ((int8_t) v)
+# else
+#   error "Platform not supported"
+# endif
+#endif
+
+#ifndef UINT16_MAX
+# define UINT16_MAX 0xffff
+#endif
+#if !defined(uint16_t) && !defined(_UINT16_T) && !defined(vxWorks)
+#if (UINT_MAX == UINT16_MAX) || defined (S_SPLINT_S)
+  typedef unsigned int uint16_t;
+# ifndef PRINTF_INT16_MODIFIER
+#  define PRINTF_INT16_MODIFIER ""
+# endif
+# define UINT16_C(v) ((uint16_t) (v))
+#elif (USHRT_MAX == UINT16_MAX)
+  typedef unsigned short uint16_t;
+# define UINT16_C(v) ((uint16_t) (v))
+# ifndef PRINTF_INT16_MODIFIER
+#  define PRINTF_INT16_MODIFIER "h"
+# endif
+#else
+#error "Platform not supported"
+#endif
+#endif
+
+#ifndef INT16_MAX
+# define INT16_MAX 0x7fff
+#endif
+#ifndef INT16_MIN
+# define INT16_MIN INT16_C(0x8000)
+#endif
+#if !defined(int16_t) && !defined(_INT16_T) && !defined(vxWorks)
+#if (INT_MAX == INT16_MAX) || defined (S_SPLINT_S)
+  typedef signed int int16_t;
+# define INT16_C(v) ((int16_t) (v))
+# ifndef PRINTF_INT16_MODIFIER
+#  define PRINTF_INT16_MODIFIER ""
+# endif
+#elif (SHRT_MAX == INT16_MAX)
+  typedef signed short int16_t;
+# define INT16_C(v) ((int16_t) (v))
+# ifndef PRINTF_INT16_MODIFIER
+#  define PRINTF_INT16_MODIFIER "h"
+# endif
+#else
+#error "Platform not supported"
+#endif
+#endif
+
+#ifndef UINT32_MAX
+# define UINT32_MAX (0xffffffffUL)
+#endif
+#if !defined(uint32_t) && !defined(_UINT32_T) && !defined(vxWorks)
+#if (ULONG_MAX == UINT32_MAX) || defined (S_SPLINT_S)
+  typedef unsigned long uint32_t;
+# define UINT32_C(v) v ## UL
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER "l"
+# endif
+#elif (UINT_MAX == UINT32_MAX)
+  typedef unsigned int uint32_t;
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER ""
+# endif
+# define UINT32_C(v) v ## U
+#elif (USHRT_MAX == UINT32_MAX)
+  typedef unsigned short uint32_t;
+# define UINT32_C(v) ((unsigned short) (v))
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER ""
+# endif
+#else
+#error "Platform not supported"
+#endif
+#endif
+
+#ifndef INT32_MAX
+# define INT32_MAX (0x7fffffffL)
+#endif
+#ifndef INT32_MIN
+# define INT32_MIN INT32_C(0x80000000)
+#endif
+#if !defined(int32_t) && !defined(_INT32_T) && !defined(vxWorks)
+#if (LONG_MAX == INT32_MAX) || defined (S_SPLINT_S)
+  typedef signed long int32_t;
+# define INT32_C(v) v ## L
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER "l"
+# endif
+#elif (INT_MAX == INT32_MAX)
+  typedef signed int int32_t;
+# define INT32_C(v) v
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER ""
+# endif
+#elif (SHRT_MAX == INT32_MAX)
+  typedef signed short int32_t;
+# define INT32_C(v) ((short) (v))
+# ifndef PRINTF_INT32_MODIFIER
+#  define PRINTF_INT32_MODIFIER ""
+# endif
+#else
+#error "Platform not supported"
+#endif
+#endif
+
+/*
+ *  The macro stdint_int64_defined is temporarily used to record
+ *  whether or not 64 integer support is available.  It must be
+ *  defined for any 64 integer extensions for new platforms that are
+ *  added.
+ */
+
+#undef stdint_int64_defined
+#if (defined(__STDC__) && defined(__STDC_VERSION__)) || defined (S_SPLINT_S)
+# if (__STDC__ && __STDC_VERSION__ >= 199901L) || defined (S_SPLINT_S)
+#  define stdint_int64_defined
+   typedef long long int64_t;
+   typedef unsigned long long uint64_t;
+#  define UINT64_C(v) v ## ULL
+#  define  INT64_C(v) v ## LL
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "ll"
+#  endif
+# endif
+#endif
+
+#if !defined (stdint_int64_defined)
+# if defined(__GNUC__) && !defined(vxWorks)
+#  define stdint_int64_defined
+   __extension__ typedef long long int64_t;
+   __extension__ typedef unsigned long long uint64_t;
+#  define UINT64_C(v) v ## ULL
+#  define  INT64_C(v) v ## LL
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "ll"
+#  endif
+# elif defined(__MWERKS__) || defined (__SUNPRO_C) || defined (__SUNPRO_CC) || defined (__APPLE_CC__) || defined (_LONG_LONG) || defined (_CRAYC) || defined (S_SPLINT_S)
+#  define stdint_int64_defined
+   typedef long long int64_t;
+   typedef unsigned long long uint64_t;
+#  define UINT64_C(v) v ## ULL
+#  define  INT64_C(v) v ## LL
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "ll"
+#  endif
+# elif (defined(__WATCOMC__) && defined(__WATCOM_INT64__)) || (defined(_MSC_VER) && _INTEGRAL_MAX_BITS >= 64) || (defined (__BORLANDC__) && __BORLANDC__ > 0x460) || defined (__alpha) || defined (__DECC)
+#  define stdint_int64_defined
+   typedef __int64 int64_t;
+   typedef unsigned __int64 uint64_t;
+#  define UINT64_C(v) v ## UI64
+#  define  INT64_C(v) v ## I64
+#  ifndef PRINTF_INT64_MODIFIER
+#   define PRINTF_INT64_MODIFIER "I64"
+#  endif
+# endif
+#endif
+
+#if !defined (LONG_LONG_MAX) && defined (INT64_C)
+# define LONG_LONG_MAX INT64_C (9223372036854775807)
+#endif
+#ifndef ULONG_LONG_MAX
+# define ULONG_LONG_MAX UINT64_C (18446744073709551615)
+#endif
+
+#if !defined (INT64_MAX) && defined (INT64_C)
+# define INT64_MAX INT64_C (9223372036854775807)
+#endif
+#if !defined (INT64_MIN) && defined (INT64_C)
+# define INT64_MIN INT64_C (-9223372036854775808)
+#endif
+#if !defined (UINT64_MAX) && defined (INT64_C)
+# define UINT64_MAX UINT64_C (18446744073709551615)
+#endif
+
+/*
+ *  Width of hexadecimal for number field.
+ */
+
+#ifndef PRINTF_INT64_HEX_WIDTH
+# define PRINTF_INT64_HEX_WIDTH "16"
+#endif
+#ifndef PRINTF_INT32_HEX_WIDTH
+# define PRINTF_INT32_HEX_WIDTH "8"
+#endif
+#ifndef PRINTF_INT16_HEX_WIDTH
+# define PRINTF_INT16_HEX_WIDTH "4"
+#endif
+#ifndef PRINTF_INT8_HEX_WIDTH
+# define PRINTF_INT8_HEX_WIDTH "2"
+#endif
+#ifndef PRINTF_INT64_DEC_WIDTH
+# define PRINTF_INT64_DEC_WIDTH "19"
+#endif
+#ifndef PRINTF_INT32_DEC_WIDTH
+# define PRINTF_INT32_DEC_WIDTH "10"
+#endif
+#ifndef PRINTF_INT16_DEC_WIDTH
+# define PRINTF_INT16_DEC_WIDTH "5"
+#endif
+#ifndef PRINTF_INT8_DEC_WIDTH
+# define PRINTF_INT8_DEC_WIDTH "3"
+#endif
+#ifndef PRINTF_UINT64_DEC_WIDTH
+# define PRINTF_UINT64_DEC_WIDTH "20"
+#endif
+#ifndef PRINTF_UINT32_DEC_WIDTH
+# define PRINTF_UINT32_DEC_WIDTH "10"
+#endif
+#ifndef PRINTF_UINT16_DEC_WIDTH
+# define PRINTF_UINT16_DEC_WIDTH "5"
+#endif
+#ifndef PRINTF_UINT8_DEC_WIDTH
+# define PRINTF_UINT8_DEC_WIDTH "3"
+#endif
+
+/*
+ *  Ok, lets not worry about 128 bit integers for now.  Moore's law says
+ *  we don't need to worry about that until about 2040 at which point
+ *  we'll have bigger things to worry about.
+ */
+
+#ifdef stdint_int64_defined
+  typedef int64_t intmax_t;
+  typedef uint64_t uintmax_t;
+# define  INTMAX_MAX   INT64_MAX
+# define  INTMAX_MIN   INT64_MIN
+# define UINTMAX_MAX  UINT64_MAX
+# define UINTMAX_C(v) UINT64_C(v)
+# define  INTMAX_C(v)  INT64_C(v)
+# ifndef PRINTF_INTMAX_MODIFIER
+#   define PRINTF_INTMAX_MODIFIER PRINTF_INT64_MODIFIER
+# endif
+# ifndef PRINTF_INTMAX_HEX_WIDTH
+#  define PRINTF_INTMAX_HEX_WIDTH PRINTF_INT64_HEX_WIDTH
+# endif
+# ifndef PRINTF_INTMAX_DEC_WIDTH
+#  define PRINTF_INTMAX_DEC_WIDTH PRINTF_INT64_DEC_WIDTH
+# endif
+#else
+  typedef int32_t intmax_t;
+  typedef uint32_t uintmax_t;
+# define  INTMAX_MAX   INT32_MAX
+# define UINTMAX_MAX  UINT32_MAX
+# define UINTMAX_C(v) UINT32_C(v)
+# define  INTMAX_C(v)  INT32_C(v)
+# ifndef PRINTF_INTMAX_MODIFIER
+#   define PRINTF_INTMAX_MODIFIER PRINTF_INT32_MODIFIER
+# endif
+# ifndef PRINTF_INTMAX_HEX_WIDTH
+#  define PRINTF_INTMAX_HEX_WIDTH PRINTF_INT32_HEX_WIDTH
+# endif
+# ifndef PRINTF_INTMAX_DEC_WIDTH
+#  define PRINTF_INTMAX_DEC_WIDTH PRINTF_INT32_DEC_WIDTH
+# endif
+#endif
+
+/*
+ *  Because this file currently only supports platforms which have
+ *  precise powers of 2 as bit sizes for the default integers, the
+ *  least definitions are all trivial.  Its possible that a future
+ *  version of this file could have different definitions.
+ */
+
+#ifndef stdint_least_defined
+  typedef   int8_t   int_least8_t;
+  typedef  uint8_t  uint_least8_t;
+  typedef  int16_t  int_least16_t;
+  typedef uint16_t uint_least16_t;
+  typedef  int32_t  int_least32_t;
+  typedef uint32_t uint_least32_t;
+# define PRINTF_LEAST32_MODIFIER PRINTF_INT32_MODIFIER
+# define PRINTF_LEAST16_MODIFIER PRINTF_INT16_MODIFIER
+# define  UINT_LEAST8_MAX  UINT8_MAX
+# define   INT_LEAST8_MAX   INT8_MAX
+# define UINT_LEAST16_MAX UINT16_MAX
+# define  INT_LEAST16_MAX  INT16_MAX
+# define UINT_LEAST32_MAX UINT32_MAX
+# define  INT_LEAST32_MAX  INT32_MAX
+# define   INT_LEAST8_MIN   INT8_MIN
+# define  INT_LEAST16_MIN  INT16_MIN
+# define  INT_LEAST32_MIN  INT32_MIN
+# ifdef stdint_int64_defined
+    typedef  int64_t  int_least64_t;
+    typedef uint64_t uint_least64_t;
+#   define PRINTF_LEAST64_MODIFIER PRINTF_INT64_MODIFIER
+#   define UINT_LEAST64_MAX UINT64_MAX
+#   define  INT_LEAST64_MAX  INT64_MAX
+#   define  INT_LEAST64_MIN  INT64_MIN
+# endif
+#endif
+#undef stdint_least_defined
+
+/*
+ *  The ANSI C committee has defined *int*_fast*_t types as well.  This,
+ *  of course, defies rationality -- you can't know what will be fast
+ *  just from the type itself.  Even for a given architecture, compatible
+ *  implementations might have different performance characteristics.
+ *  Developers are warned to stay away from these types when using this
+ *  or any other stdint.h.
+ */
+
+typedef   int_least8_t   int_fast8_t;
+typedef  uint_least8_t  uint_fast8_t;
+typedef  int_least16_t  int_fast16_t;
+typedef uint_least16_t uint_fast16_t;
+typedef  int_least32_t  int_fast32_t;
+typedef uint_least32_t uint_fast32_t;
+#define  UINT_FAST8_MAX  UINT_LEAST8_MAX
+#define   INT_FAST8_MAX   INT_LEAST8_MAX
+#define UINT_FAST16_MAX UINT_LEAST16_MAX
+#define  INT_FAST16_MAX  INT_LEAST16_MAX
+#define UINT_FAST32_MAX UINT_LEAST32_MAX
+#define  INT_FAST32_MAX  INT_LEAST32_MAX
+#define   INT_FAST8_MIN   INT_LEAST8_MIN
+#define  INT_FAST16_MIN  INT_LEAST16_MIN
+#define  INT_FAST32_MIN  INT_LEAST32_MIN
+#ifdef stdint_int64_defined
+  typedef  int_least64_t  int_fast64_t;
+  typedef uint_least64_t uint_fast64_t;
+# define UINT_FAST64_MAX UINT_LEAST64_MAX
+# define  INT_FAST64_MAX  INT_LEAST64_MAX
+# define  INT_FAST64_MIN  INT_LEAST64_MIN
+#endif
+
+#undef stdint_int64_defined
+
+/*
+ *  Whatever piecemeal, per compiler thing we can do about the wchar_t
+ *  type limits.
+ */
+
+#if defined(__WATCOMC__) || defined(_MSC_VER) || defined (__GNUC__) && !defined(vxWorks)
+# include <wchar.h>
+# ifndef WCHAR_MIN
+#  define WCHAR_MIN 0
+# endif
+# ifndef WCHAR_MAX
+#  define WCHAR_MAX ((wchar_t)-1)
+# endif
+#endif
+
+/*
+ *  Whatever piecemeal, per compiler/platform thing we can do about the
+ *  (u)intptr_t types and limits.
+ */
+
+#if (defined (_MSC_VER) && defined (_UINTPTR_T_DEFINED)) || defined (_UINTPTR_T)
+# define STDINT_H_UINTPTR_T_DEFINED
+#endif
+
+#ifndef STDINT_H_UINTPTR_T_DEFINED
+# if defined (__alpha__) || defined (__ia64__) || defined (__x86_64__) || defined (_WIN64) || defined (__ppc64__)
+#  define stdint_intptr_bits 64
+# elif defined (__WATCOMC__) || defined (__TURBOC__)
+#  if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
+#    define stdint_intptr_bits 16
+#  else
+#    define stdint_intptr_bits 32
+#  endif
+# elif defined (__i386__) || defined (_WIN32) || defined (WIN32) || defined (__ppc64__)
+#  define stdint_intptr_bits 32
+# elif defined (__INTEL_COMPILER)
+/* TODO -- what did Intel do about x86-64? */
+# else
+/* #error "This platform might not be supported yet" */
+# endif
+
+# ifdef stdint_intptr_bits
+#  define stdint_intptr_glue3_i(a,b,c)  a##b##c
+#  define stdint_intptr_glue3(a,b,c)    stdint_intptr_glue3_i(a,b,c)
+#  ifndef PRINTF_INTPTR_MODIFIER
+#    define PRINTF_INTPTR_MODIFIER      stdint_intptr_glue3(PRINTF_INT,stdint_intptr_bits,_MODIFIER)
+#  endif
+#  ifndef PTRDIFF_MAX
+#    define PTRDIFF_MAX                 stdint_intptr_glue3(INT,stdint_intptr_bits,_MAX)
+#  endif
+#  ifndef PTRDIFF_MIN
+#    define PTRDIFF_MIN                 stdint_intptr_glue3(INT,stdint_intptr_bits,_MIN)
+#  endif
+#  ifndef UINTPTR_MAX
+#    define UINTPTR_MAX                 stdint_intptr_glue3(UINT,stdint_intptr_bits,_MAX)
+#  endif
+#  ifndef INTPTR_MAX
+#    define INTPTR_MAX                  stdint_intptr_glue3(INT,stdint_intptr_bits,_MAX)
+#  endif
+#  ifndef INTPTR_MIN
+#    define INTPTR_MIN                  stdint_intptr_glue3(INT,stdint_intptr_bits,_MIN)
+#  endif
+#  ifndef INTPTR_C
+#    define INTPTR_C(x)                 stdint_intptr_glue3(INT,stdint_intptr_bits,_C)(x)
+#  endif
+#  ifndef UINTPTR_C
+#    define UINTPTR_C(x)                stdint_intptr_glue3(UINT,stdint_intptr_bits,_C)(x)
+#  endif
+  typedef stdint_intptr_glue3(uint,stdint_intptr_bits,_t) uintptr_t;
+  typedef stdint_intptr_glue3( int,stdint_intptr_bits,_t)  intptr_t;
+# else
+/* TODO -- This following is likely wrong for some platforms, and does
+   nothing for the definition of uintptr_t. */
+  typedef ptrdiff_t intptr_t;
+# endif
+# define STDINT_H_UINTPTR_T_DEFINED
+#endif
+
+/*
+ *  Assumes sig_atomic_t is signed and we have a 2s complement machine.
+ */
+
+#ifndef SIG_ATOMIC_MAX
+# define SIG_ATOMIC_MAX ((((sig_atomic_t) 1) << (sizeof (sig_atomic_t)*CHAR_BIT-1)) - 1)
+#endif
+
+#endif
+
+#if defined (__TEST_PSTDINT_FOR_CORRECTNESS)
+
+/*
+ *  Please compile with the maximum warning settings to make sure macros are
+ *  not defined more than once.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#define glue3_aux(x,y,z) x ## y ## z
+#define glue3(x,y,z) glue3_aux(x,y,z)
+
+#define DECLU(bits) glue3(uint,bits,_t) glue3(u,bits,) = glue3(UINT,bits,_C) (0);
+#define DECLI(bits) glue3(int,bits,_t) glue3(i,bits,) = glue3(INT,bits,_C) (0);
+
+#define DECL(us,bits) glue3(DECL,us,) (bits)
+
+#define TESTUMAX(bits) glue3(u,bits,) = ~glue3(u,bits,); if (glue3(UINT,bits,_MAX) != glue3(u,bits,)) printf ("Something wrong with UINT%d_MAX\n", bits)
+
+#define REPORTERROR(msg) { err_n++; if (err_first <= 0) err_first = __LINE__; printf msg; }
+
+#define X_SIZE_MAX ((size_t)-1)
+
+int main () {
+    int err_n = 0;
+    int err_first = 0;
+    DECL(I,8)
+    DECL(U,8)
+    DECL(I,16)
+    DECL(U,16)
+    DECL(I,32)
+    DECL(U,32)
+#ifdef INT64_MAX
+    DECL(I,64)
+    DECL(U,64)
+#endif
+    intmax_t imax = INTMAX_C(0);
+    uintmax_t umax = UINTMAX_C(0);
+    char str0[256], str1[256];
+
+    sprintf (str0, "%" PRINTF_INT32_MODIFIER "d", INT32_C(2147483647));
+    if (0 != strcmp (str0, "2147483647")) REPORTERROR (("Something wrong with PRINTF_INT32_MODIFIER : %s\n", str0));
+    if (atoi(PRINTF_INT32_DEC_WIDTH) != (int) strlen(str0)) REPORTERROR (("Something wrong with PRINTF_INT32_DEC_WIDTH : %s\n", PRINTF_INT32_DEC_WIDTH));
+    sprintf (str0, "%" PRINTF_INT32_MODIFIER "u", UINT32_C(4294967295));
+    if (0 != strcmp (str0, "4294967295")) REPORTERROR (("Something wrong with PRINTF_INT32_MODIFIER : %s\n", str0));
+    if (atoi(PRINTF_UINT32_DEC_WIDTH) != (int) strlen(str0)) REPORTERROR (("Something wrong with PRINTF_UINT32_DEC_WIDTH : %s\n", PRINTF_UINT32_DEC_WIDTH));
+#ifdef INT64_MAX
+    sprintf (str1, "%" PRINTF_INT64_MODIFIER "d", INT64_C(9223372036854775807));
+    if (0 != strcmp (str1, "9223372036854775807")) REPORTERROR (("Something wrong with PRINTF_INT32_MODIFIER : %s\n", str1));
+    if (atoi(PRINTF_INT64_DEC_WIDTH) != (int) strlen(str1)) REPORTERROR (("Something wrong with PRINTF_INT64_DEC_WIDTH : %s, %d\n", PRINTF_INT64_DEC_WIDTH, (int) strlen(str1)));
+    sprintf (str1, "%" PRINTF_INT64_MODIFIER "u", UINT64_C(18446744073709550591));
+    if (0 != strcmp (str1, "18446744073709550591")) REPORTERROR (("Something wrong with PRINTF_INT32_MODIFIER : %s\n", str1));
+    if (atoi(PRINTF_UINT64_DEC_WIDTH) != (int) strlen(str1)) REPORTERROR (("Something wrong with PRINTF_UINT64_DEC_WIDTH : %s, %d\n", PRINTF_UINT64_DEC_WIDTH, (int) strlen(str1)));
+#endif
+
+    sprintf (str0, "%d %x\n", 0, ~0);
+
+    sprintf (str1, "%d %x\n",  i8, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with i8 : %s\n", str1));
+    sprintf (str1, "%u %x\n",  u8, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with u8 : %s\n", str1));
+    sprintf (str1, "%d %x\n",  i16, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with i16 : %s\n", str1));
+    sprintf (str1, "%u %x\n",  u16, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with u16 : %s\n", str1));
+    sprintf (str1, "%" PRINTF_INT32_MODIFIER "d %x\n",  i32, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with i32 : %s\n", str1));
+    sprintf (str1, "%" PRINTF_INT32_MODIFIER "u %x\n",  u32, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with u32 : %s\n", str1));
+#ifdef INT64_MAX
+    sprintf (str1, "%" PRINTF_INT64_MODIFIER "d %x\n",  i64, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with i64 : %s\n", str1));
+#endif
+    sprintf (str1, "%" PRINTF_INTMAX_MODIFIER "d %x\n",  imax, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with imax : %s\n", str1));
+    sprintf (str1, "%" PRINTF_INTMAX_MODIFIER "u %x\n",  umax, ~0);
+    if (0 != strcmp (str0, str1)) REPORTERROR (("Something wrong with umax : %s\n", str1));
+
+    TESTUMAX(8);
+    TESTUMAX(16);
+    TESTUMAX(32);
+#ifdef INT64_MAX
+    TESTUMAX(64);
+#endif
+
+#define STR(v) #v
+#define Q(v) printf ("sizeof " STR(v) " = %u\n", (unsigned) sizeof (v));
+    if (err_n) {
+        printf ("pstdint.h is not correct.  Please use sizes below to correct it:\n");
+    }
+
+    Q(int)
+    Q(unsigned)
+    Q(long int)
+    Q(short int)
+    Q(int8_t)
+    Q(int16_t)
+    Q(int32_t)
+#ifdef INT64_MAX
+    Q(int64_t)
+#endif
+
+#if UINT_MAX < X_SIZE_MAX
+    printf ("UINT_MAX < X_SIZE_MAX\n");
+#else
+    printf ("UINT_MAX >= X_SIZE_MAX\n");
+#endif
+    printf ("%" PRINTF_INT64_MODIFIER "u vs %" PRINTF_INT64_MODIFIER "u\n", UINT_MAX, X_SIZE_MAX);
+
+    return EXIT_SUCCESS;
+}
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/satClause.h b/lib/bill/bill/sat/solver/abc/satClause.h
new file mode 100644
index 0000000..67d7f9d
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/satClause.h
@@ -0,0 +1,476 @@
+/**CFile****************************************************************
+
+  FileName    [satMem.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [SAT solver.]
+
+  Synopsis    [Memory management.]
+
+  Author      [Alan Mishchenko <alanmi@eecs.berkeley.edu>]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - January 1, 2004.]
+
+  Revision    [$Id: satMem.h,v 1.0 2004/01/01 1:00:00 alanmi Exp $]
+
+***********************************************************************/
+ 
+#ifndef ABC__sat__bsat__satMem_h
+#define ABC__sat__bsat__satMem_h
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include "abc_global.h"
+
+ABC_NAMESPACE_HEADER_START
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+//#define LEARNT_MAX_START_DEFAULT  0
+#define LEARNT_MAX_START_DEFAULT  10000
+#define LEARNT_MAX_INCRE_DEFAULT   1000
+#define LEARNT_MAX_RATIO_DEFAULT     50
+
+////////////////////////////////////////////////////////////////////////
+///                    STRUCTURE DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+ 
+//=================================================================================================
+// Clause datatype + minor functions:
+
+typedef struct clause_t clause;
+struct clause_t
+{
+    unsigned   lrn   :   1;
+    unsigned   mark  :   1;
+    unsigned   partA :   1;
+    unsigned   lbd   :   8;
+    unsigned   size  :  21;
+    lit        lits[0];
+};
+
+// learned clauses have "hidden" literal (c->lits[c->size]) to store clause ID
+
+// data-structure for logging entries
+// memory is allocated in 2^nPageSize word-sized pages
+// the first 'word' of each page are stores the word limit
+
+// although clause memory pieces are aligned to 64-bit words
+// the integer clause handles are in terms of 32-bit unsigneds
+// allowing for the first bit to be used for labeling 2-lit clauses
+
+
+typedef struct Sat_Mem_t_ Sat_Mem_t;
+struct Sat_Mem_t_
+{
+    int                 nEntries[2];  // entry count
+    int                 BookMarkH[2]; // bookmarks for handles
+    int                 BookMarkE[2]; // bookmarks for entries
+    int                 iPage[2];     // current memory page
+    int                 nPageSize;    // page log size in terms of ints
+    unsigned            uPageMask;    // page mask
+    unsigned            uLearnedMask; // learned mask
+    int                 nPagesAlloc;  // page count allocated
+    int **              pPages;       // page pointers
+}; 
+
+static inline int       Sat_MemLimit( int * p )                      { return p[0];                                 }
+static inline int       Sat_MemIncLimit( int * p, int nInts )        { return p[0] += nInts;                        }
+static inline void      Sat_MemWriteLimit( int * p, int nInts )      { p[0] = nInts;                                }
+
+static inline int       Sat_MemHandPage( Sat_Mem_t * p, cla h )      { return h >> p->nPageSize;                    }
+static inline int       Sat_MemHandShift( Sat_Mem_t * p, cla h )     { return h & p->uPageMask;                     }
+
+static inline int       Sat_MemIntSize( int size, int lrn )          { return (size + 2 + lrn) & ~01;               }
+static inline int       Sat_MemClauseSize( clause * p )              { return Sat_MemIntSize(p->size, p->lrn);      }
+static inline int       Sat_MemClauseSize2( clause * p )             { return Sat_MemIntSize(p->size, 1);           }
+
+//static inline clause *  Sat_MemClause( Sat_Mem_t * p, int i, int k ) { assert(i <= p->iPage[i&1] && k <= Sat_MemLimit(p->pPages[i]));  return (clause *)(p->pPages[i] + k ); }
+static inline clause *  Sat_MemClause( Sat_Mem_t * p, int i, int k ) { assert( k ); return (clause *)(p->pPages[i] + k);         }
+//static inline clause *  Sat_MemClauseHand( Sat_Mem_t * p, cla h )    { assert(Sat_MemHandPage(p, h) <= p->iPage[(h & p->uLearnedMask) > 0]); assert(Sat_MemHandShift(p, h) >= 2 && Sat_MemHandShift(p, h) < (int)p->uLearnedMask); return Sat_MemClause( p, Sat_MemHandPage(p, h), Sat_MemHandShift(p, h) );     }
+static inline clause *  Sat_MemClauseHand( Sat_Mem_t * p, cla h )    { return h ? Sat_MemClause( p, Sat_MemHandPage(p, h), Sat_MemHandShift(p, h) ) : NULL;                  }
+static inline int       Sat_MemEntryNum( Sat_Mem_t * p, int lrn )    { return p->nEntries[lrn];                                                                              }
+
+static inline cla       Sat_MemHand( Sat_Mem_t * p, int i, int k )   { return (i << p->nPageSize) | k;                                                                       }
+static inline cla       Sat_MemHandCurrent( Sat_Mem_t * p, int lrn ) { return (p->iPage[lrn] << p->nPageSize) | Sat_MemLimit( p->pPages[p->iPage[lrn]] );                    }
+
+static inline int       Sat_MemClauseUsed( Sat_Mem_t * p, cla h )    { return h < p->BookMarkH[(h & p->uLearnedMask) > 0];                                                   }
+
+static inline double    Sat_MemMemoryHand( Sat_Mem_t * p, cla h )    { return 1.0 * ((Sat_MemHandPage(p, h) + 2)/2 * (1 << (p->nPageSize+2)) + Sat_MemHandShift(p, h) * 4);  }
+static inline double    Sat_MemMemoryUsed( Sat_Mem_t * p, int lrn )  { return Sat_MemMemoryHand( p, Sat_MemHandCurrent(p, lrn) );                                            }
+static inline double    Sat_MemMemoryAllUsed( Sat_Mem_t * p )        { return Sat_MemMemoryUsed( p, 0 ) + Sat_MemMemoryUsed( p, 1 );                                         }
+static inline double    Sat_MemMemoryAll( Sat_Mem_t * p )            { return 1.0 * (p->iPage[0] + p->iPage[1] + 2) * (1 << (p->nPageSize+2));                               }
+
+// p is memory storage
+// c is clause pointer
+// i is page number
+// k is page offset
+
+// print problem clauses NOT in proof mode
+#define Sat_MemForEachClause( p, c, i, k )      \
+    for ( i = 0; i <= p->iPage[0]; i += 2 )     \
+        for ( k = 2; k < Sat_MemLimit(p->pPages[i]) && ((c) = Sat_MemClause( p, i, k )); k += Sat_MemClauseSize(c) ) if ( i == 0 && k == 2 ) {} else
+
+// print problem clauses in proof mode
+#define Sat_MemForEachClause2( p, c, i, k )      \
+    for ( i = 0; i <= p->iPage[0]; i += 2 )     \
+        for ( k = 2; k < Sat_MemLimit(p->pPages[i]) && ((c) = Sat_MemClause( p, i, k )); k += Sat_MemClauseSize2(c) ) if ( i == 0 && k == 2 ) {} else
+
+#define Sat_MemForEachLearned( p, c, i, k )     \
+    for ( i = 1; i <= p->iPage[1]; i += 2 )     \
+        for ( k = 2; k < Sat_MemLimit(p->pPages[i]) && ((c) = Sat_MemClause( p, i, k )); k += Sat_MemClauseSize(c) )
+
+////////////////////////////////////////////////////////////////////////
+///                       GLOBAL VARIABLES                           ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                       MACRO DEFINITIONS                          ///
+////////////////////////////////////////////////////////////////////////
+
+static inline int      clause_from_lit( lit l )                     { return l + l + 1;                            }
+static inline int      clause_is_lit( cla h )                       { return (h & 1);                              }
+static inline lit      clause_read_lit( cla h )                     { return (lit)(h >> 1);                        }
+
+static inline int      clause_learnt_h( Sat_Mem_t * p, cla h )      { return (h & p->uLearnedMask) > 0;            }
+static inline int      clause_learnt( clause * c )                  { return c->lrn;                               }
+static inline int      clause_id( clause * c )                      { return c->lits[c->size];                     }
+static inline void     clause_set_id( clause * c, int id )          { c->lits[c->size] = id;                       }
+static inline int      clause_size( clause * c )                    { return c->size;                              }
+static inline lit *    clause_begin( clause * c )                   { return c->lits;                              }
+static inline lit *    clause_end( clause * c )                     { return c->lits + c->size;                    }
+static inline void     clause_print_( clause * c )               
+{ 
+    int i;
+    printf( "{ " );
+    for ( i = 0; i < clause_size(c); i++ )
+        printf( "%d ", (clause_begin(c)[i] & 1)? -(clause_begin(c)[i] >> 1) : clause_begin(c)[i] >> 1 );
+    printf( "}\n" );
+}
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DECLARATIONS                        ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Allocating vector.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Sat_MemCountL( Sat_Mem_t * p )
+{
+    clause * c;
+    int i, k, Count = 0;
+    Sat_MemForEachLearned( p, c, i, k )
+        Count++;
+    return Count;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocating vector.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Sat_MemAlloc_( Sat_Mem_t * p, int nPageSize )
+{
+    assert( nPageSize > 8 && nPageSize < 32 );
+    memset( p, 0, sizeof(Sat_Mem_t) );
+    p->nPageSize    = nPageSize;
+    p->uLearnedMask = (unsigned)(1 << nPageSize);
+    p->uPageMask    = (unsigned)((1 << nPageSize) - 1);
+    p->nPagesAlloc  = 256;
+    p->pPages       = ABC_CALLOC( int *, p->nPagesAlloc );
+    p->pPages[0]    = ABC_ALLOC( int, (int)(((word)1) << p->nPageSize) );
+    p->pPages[1]    = ABC_ALLOC( int, (int)(((word)1) << p->nPageSize) );
+    p->iPage[0]     = 0;
+    p->iPage[1]     = 1;
+    Sat_MemWriteLimit( p->pPages[0], 2 );
+    Sat_MemWriteLimit( p->pPages[1], 2 );
+}
+static inline Sat_Mem_t * Sat_MemAlloc( int nPageSize )
+{
+    Sat_Mem_t * p;
+    p = ABC_CALLOC( Sat_Mem_t, 1 );
+    Sat_MemAlloc_( p, nPageSize );
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Resetting vector.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Sat_MemRestart( Sat_Mem_t * p )
+{
+    p->nEntries[0]  = 0;
+    p->nEntries[1]  = 0;
+    p->iPage[0]     = 0;
+    p->iPage[1]     = 1;
+    Sat_MemWriteLimit( p->pPages[0], 2 );
+    Sat_MemWriteLimit( p->pPages[1], 2 );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sets the bookmark.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Sat_MemBookMark( Sat_Mem_t * p )
+{
+    p->BookMarkE[0] = p->nEntries[0];
+    p->BookMarkE[1] = p->nEntries[1];
+    p->BookMarkH[0] = Sat_MemHandCurrent( p, 0 );
+    p->BookMarkH[1] = Sat_MemHandCurrent( p, 1 );
+}
+static inline void Sat_MemRollBack( Sat_Mem_t * p )
+{
+    p->nEntries[0]  = p->BookMarkE[0];
+    p->nEntries[1]  = p->BookMarkE[1];
+    p->iPage[0]     = Sat_MemHandPage( p, p->BookMarkH[0] );
+    p->iPage[1]     = Sat_MemHandPage( p, p->BookMarkH[1] );
+    Sat_MemWriteLimit( p->pPages[p->iPage[0]], Sat_MemHandShift( p, p->BookMarkH[0] ) );
+    Sat_MemWriteLimit( p->pPages[p->iPage[1]], Sat_MemHandShift( p, p->BookMarkH[1] ) );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Freeing vector.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Sat_MemFree_( Sat_Mem_t * p )
+{
+    int i;
+    for ( i = 0; i < p->nPagesAlloc; i++ )
+        ABC_FREE( p->pPages[i] );
+    ABC_FREE( p->pPages );
+}
+static inline void Sat_MemFree( Sat_Mem_t * p )
+{
+    Sat_MemFree_( p );
+    ABC_FREE( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Creates new clause.]
+
+  Description [The resulting clause is fully initialized.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Sat_MemAppend( Sat_Mem_t * p, int * pArray, int nSize, int lrn, int fPlus1 )
+{
+    clause * c;
+    int * pPage = p->pPages[p->iPage[lrn]];
+    int nInts = Sat_MemIntSize( nSize, lrn | fPlus1 );
+    assert( nInts + 3 < (1 << p->nPageSize) );
+    // need two extra at the begining of the page and one extra in the end
+    if ( Sat_MemLimit(pPage) + nInts + 2 >= (1 << p->nPageSize) )
+    { 
+        p->iPage[lrn] += 2;
+        if ( p->iPage[lrn] >= p->nPagesAlloc )
+        {
+            p->pPages = ABC_REALLOC( int *, p->pPages, p->nPagesAlloc * 2 );
+            memset( p->pPages + p->nPagesAlloc, 0, sizeof(int *) * p->nPagesAlloc );
+            p->nPagesAlloc *= 2;
+        }
+        if ( p->pPages[p->iPage[lrn]] == NULL )
+            p->pPages[p->iPage[lrn]] = ABC_ALLOC( int, (int)(((word)1) << p->nPageSize) );
+        pPage = p->pPages[p->iPage[lrn]];
+        Sat_MemWriteLimit( pPage, 2 );
+    }
+    pPage[Sat_MemLimit(pPage)] = 0;
+    c = (clause *)(pPage + Sat_MemLimit(pPage));
+    c->size = nSize;
+    c->lrn = lrn;
+    if ( pArray )
+        memcpy( c->lits, pArray, sizeof(int) * nSize );
+    if ( lrn | fPlus1 )
+        c->lits[c->size] = p->nEntries[lrn];
+    p->nEntries[lrn]++;
+    Sat_MemIncLimit( pPage, nInts );
+    return Sat_MemHandCurrent(p, lrn) - nInts;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Shrinking vector size.]
+
+  Description []
+
+  SideEffects [This procedure does not update the number of entries.]
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Sat_MemShrink( Sat_Mem_t * p, int h, int lrn )
+{
+    assert( clause_learnt_h(p, h) == lrn );
+    assert( h && h <= Sat_MemHandCurrent(p, lrn) );
+    p->iPage[lrn] = Sat_MemHandPage(p, h);
+    Sat_MemWriteLimit( p->pPages[p->iPage[lrn]], Sat_MemHandShift(p, h) );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Compacts learned clauses by removing marked entries.]
+
+  Description [Returns the number of remaining entries.]
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Sat_MemCompactLearned( Sat_Mem_t * p, int fDoMove )
+{
+    clause * c, * cPivot = NULL;
+    int i, k, iNew = 1, kNew = 2, nInts, fStartLooking, Counter = 0;
+    int hLimit = Sat_MemHandCurrent(p, 1);
+    if ( hLimit == Sat_MemHand(p, 1, 2) )
+        return 0;
+    if ( fDoMove && p->BookMarkH[1] )
+    {
+        // move the pivot
+        assert( p->BookMarkH[1] >= Sat_MemHand(p, 1, 2) && p->BookMarkH[1] <= hLimit );
+        // get the pivot and remember it may be pointed offlimit
+        cPivot = Sat_MemClauseHand( p, p->BookMarkH[1] );
+        if ( p->BookMarkH[1] < hLimit && !cPivot->mark )
+        {
+            p->BookMarkH[1] = cPivot->lits[cPivot->size];
+            cPivot = NULL;
+        }
+        // else find the next used clause after cPivot
+    }
+    // iterate through the learned clauses
+    fStartLooking = 0;
+    Sat_MemForEachLearned( p, c, i, k )
+    {
+        assert( c->lrn );
+        // skip marked entry
+        if ( c->mark )
+        {
+            // if pivot is a marked clause, start looking for the next non-marked one
+            if ( cPivot && cPivot == c )
+            {
+                fStartLooking = 1;
+                cPivot = NULL;
+            }
+            continue;
+        }
+        // if we started looking before, we found it!
+        if ( fStartLooking )
+        {
+            fStartLooking = 0;
+            p->BookMarkH[1] = c->lits[c->size];
+        }
+        // compute entry size
+        nInts = Sat_MemClauseSize(c);
+        assert( !(nInts & 1) );
+        // check if we need to scroll to the next page
+        if ( kNew + nInts >= (1 << p->nPageSize) )
+        {
+            // set the limit of the current page
+            if ( fDoMove )
+                Sat_MemWriteLimit( p->pPages[iNew], kNew );
+            // move writing position to the new page
+            iNew += 2;
+            kNew = 2;
+        }
+        if ( fDoMove )
+        {
+            // make sure the result is the same as previous dry run
+            assert( c->lits[c->size] == Sat_MemHand(p, iNew, kNew) );
+            // only copy the clause if it has changed
+            if ( i != iNew || k != kNew )
+            {
+                memmove( p->pPages[iNew] + kNew, c, sizeof(int) * nInts );
+//                c = Sat_MemClause( p, iNew, kNew ); // assersions do not hold during dry run
+                c = (clause *)(p->pPages[iNew] + kNew);
+                assert( nInts == Sat_MemClauseSize(c) );
+            }
+            // set the new ID value
+            c->lits[c->size] = Counter;
+        }
+        else // remember the address of the clause in the new location
+            c->lits[c->size] = Sat_MemHand(p, iNew, kNew);
+        // update writing position
+        kNew += nInts;
+        assert( iNew <= i && kNew < (1 << p->nPageSize) );
+        // update counter
+        Counter++;
+    }
+    if ( fDoMove )
+    {
+        // update the counter
+        p->nEntries[1] = Counter;
+        // update the page count
+        p->iPage[1] = iNew;
+        // set the limit of the last page
+        Sat_MemWriteLimit( p->pPages[iNew], kNew );
+        // check if the pivot need to be updated
+        if ( p->BookMarkH[1] )
+        {
+            if ( cPivot )
+            {
+                p->BookMarkH[1] = Sat_MemHandCurrent(p, 1);
+                p->BookMarkE[1] = p->nEntries[1];
+            }
+            else
+                p->BookMarkE[1] = clause_id(Sat_MemClauseHand( p, p->BookMarkH[1] ));
+        }
+
+    }
+    return Counter;
+}
+
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
diff --git a/lib/bill/bill/sat/solver/abc/satSolver.h b/lib/bill/bill/sat/solver/abc/satSolver.h
new file mode 100644
index 0000000..25f7528
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/satSolver.h
@@ -0,0 +1,651 @@
+/**************************************************************************************************
+MiniSat -- Copyright (c) 2005, Niklas Sorensson
+http://www.cs.chalmers.se/Cs/Research/FormalMethods/MiniSat/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+// Modified to compile with MS Visual Studio 6.0 by Alan Mishchenko
+
+#ifndef ABC__sat__bsat__satSolver_h
+#define ABC__sat__bsat__satSolver_h
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "satVec.h"
+#include "satClause.h"
+#include "utilDouble.h"
+
+ABC_NAMESPACE_HEADER_START
+
+//=================================================================================================
+// Public interface:
+
+struct sat_solver_t;
+typedef struct sat_solver_t sat_solver;
+
+extern sat_solver* sat_solver_new(void);
+extern sat_solver* zsat_solver_new_seed(double seed);
+extern void        sat_solver_delete(sat_solver* s);
+
+extern void        solver_init_activities(sat_solver* s);
+
+extern int         sat_solver_addclause(sat_solver* s, lit* begin, lit* end);
+extern int         sat_solver_clause_new(sat_solver* s, lit* begin, lit* end, int learnt);
+extern int         sat_solver_simplify(sat_solver* s);
+extern int         sat_solver_solve(sat_solver* s, lit* begin, lit* end, ABC_INT64_T nConfLimit, ABC_INT64_T nInsLimit, ABC_INT64_T nConfLimitGlobal, ABC_INT64_T nInsLimitGlobal);
+extern int         sat_solver_solve_internal(sat_solver* s);
+extern int         sat_solver_solve_lexsat(sat_solver* s, int * pLits, int nLits);
+extern int         sat_solver_minimize_assumptions( sat_solver* s, int * pLits, int nLits, int nConfLimit );
+extern int         sat_solver_minimize_assumptions2( sat_solver* s, int * pLits, int nLits, int nConfLimit );
+extern int         sat_solver_push(sat_solver* s, int p);
+extern void        sat_solver_pop(sat_solver* s);
+extern void        sat_solver_set_resource_limits(sat_solver* s, ABC_INT64_T nConfLimit, ABC_INT64_T nInsLimit, ABC_INT64_T nConfLimitGlobal, ABC_INT64_T nInsLimitGlobal);
+extern void        sat_solver_restart( sat_solver* s );
+extern void        zsat_solver_restart_seed( sat_solver* s, double seed );
+extern void        sat_solver_rollback( sat_solver* s );
+
+extern int         sat_solver_nvars(sat_solver* s);
+extern int         sat_solver_nclauses(sat_solver* s);
+extern int         sat_solver_nconflicts(sat_solver* s);
+extern double      sat_solver_memory(sat_solver* s);
+extern int         sat_solver_count_assigned(sat_solver* s);
+
+extern int         sat_solver_addvar(sat_solver* s);
+extern void        sat_solver_setnvars(sat_solver* s,int n);
+extern int         sat_solver_get_var_value(sat_solver* s, int v);
+extern void        sat_solver_set_var_activity(sat_solver* s, int * pVars, int nVars);
+
+extern void        Sat_SolverWriteDimacs( sat_solver * p, char * pFileName, lit* assumptionsBegin, lit* assumptionsEnd, int incrementVars );
+extern void        Sat_SolverPrintStats( FILE * pFile, sat_solver * p );
+extern int *       Sat_SolverGetModel( sat_solver * p, int * pVars, int nVars );
+extern void        Sat_SolverDoubleClauses( sat_solver * p, int iVar );
+
+// trace recording
+extern void        Sat_SolverTraceStart( sat_solver * pSat, char * pName );
+extern void        Sat_SolverTraceStop( sat_solver * pSat );
+extern void        Sat_SolverTraceWrite( sat_solver * pSat, int * pBeg, int * pEnd, int fRoot );
+
+// clause storage
+extern void        sat_solver_store_alloc( sat_solver * s );
+extern void        sat_solver_store_write( sat_solver * s, char * pFileName );
+extern void        sat_solver_store_free( sat_solver * s );
+extern void        sat_solver_store_mark_roots( sat_solver * s );
+extern void        sat_solver_store_mark_clauses_a( sat_solver * s );
+extern void *      sat_solver_store_release( sat_solver * s ); 
+
+//=================================================================================================
+// Solver representation:
+
+//struct clause_t;
+//typedef struct clause_t clause;
+
+struct varinfo_t;
+typedef struct varinfo_t varinfo;
+
+struct sat_solver_t
+{
+    int         size;          // nof variables
+    int         cap;           // size of varmaps
+    int         qhead;         // Head index of queue.
+    int         qtail;         // Tail index of queue.
+
+    // clauses
+    Sat_Mem_t   Mem;
+    int         hLearnts;      // the first learnt clause
+    int         hBinary;       // the special binary clause
+    clause *    binary;
+    veci*       wlists;        // watcher lists
+
+    // rollback
+    int         iVarPivot;     // the pivot for variables
+    int         iTrailPivot;   // the pivot for trail
+    int         hProofPivot;   // the pivot for proof records
+
+    // activities
+    int         VarActType = 0;
+    int         ClaActType = 0;
+    word        var_inc;       // Amount to bump next variable with.
+    word        var_inc2;      // Amount to bump next variable with.
+    word        var_decay;     // INVERSE decay factor for variable activity: stores 1/decay. 
+    word*       activity;      // A heuristic measurement of the activity of a variable.
+    word*       activity2;     // backup variable activity
+    unsigned    cla_inc;       // Amount to bump next clause with.
+    unsigned    cla_decay;     // INVERSE decay factor for clause activity: stores 1/decay.
+    veci        act_clas;      // contain clause activities
+
+    char *      pFreqs;        // how many times this variable was assigned a value
+    int         nVarUsed;
+
+//    varinfo *   vi;            // variable information
+    int*        levels;        //
+    char*       assigns;       // Current values of variables.
+    char*       polarity;      //
+    char*       tags;          //
+    char*       loads;         //
+
+    int*        orderpos;      // Index in variable order.
+    int*        reasons;       //
+    lit*        trail;
+    veci        tagged;        // (contains: var)
+    veci        stack;         // (contains: var)
+
+    veci        order;         // Variable order. (heap) (contains: var)
+    veci        trail_lim;     // Separator indices for different decision levels in 'trail'. (contains: int)
+//    veci        model;         // If problem is solved, this vector contains the model (contains: lbool).
+    int *       model;         // If problem is solved, this vector contains the model (contains: lbool).
+    veci        conf_final;    // If problem is unsatisfiable (possibly under assumptions),
+                               // this vector represent the final conflict clause expressed in the assumptions.
+
+    int         root_level;    // Level of first proper decision.
+    int         simpdb_assigns;// Number of top-level assignments at last 'simplifyDB()'.
+    int         simpdb_props;  // Number of propagations before next 'simplifyDB()'.
+    double      random_seed = 91648253;
+    double      progress_estimate;
+    int         verbosity;     // Verbosity level. 0=silent, 1=some progress report, 2=everything
+    int         fVerbose;
+    int         fPrintClause;
+
+    stats_t     stats;
+    int         nLearntMax;    // max number of learned clauses
+    int         nLearntStart;  // starting learned clause limit
+    int         nLearntDelta;  // delta of learned clause limit
+    int         nLearntRatio;  // ratio percentage of learned clauses
+    int         nDBreduces;    // number of DB reductions
+
+    ABC_INT64_T nConfLimit;    // external limit on the number of conflicts
+    ABC_INT64_T nInsLimit;     // external limit on the number of implications
+    abctime     nRuntimeLimit; // external limit on runtime
+
+    veci        act_vars;      // variables whose activity has changed
+    double*     factors;       // the activity factors
+    int         nRestarts;     // the number of local restarts
+    int         nCalls;        // the number of local restarts
+    int         nCalls2;       // the number of local restarts
+    veci        unit_lits;     // variables whose activity has changed
+    veci        pivot_vars;    // pivot variables
+
+    int         fSkipSimplify; // set to one to skip simplification of the clause database
+    int         fNotUseRandom; // do not allow random decisions with a fixed probability
+    int         fNoRestarts;   // disables periodic restarts
+
+    int *       pGlobalVars;   // for experiments with global vars during interpolation
+    // clause store
+    void *      pStore;
+    int         fSolved;
+
+    // trace recording
+    FILE *      pFile;
+    int         nClauses;
+    int         nRoots;
+
+    veci        temp_clause;    // temporary storage for a CNF clause
+
+    // assignment storage
+    veci        user_vars;      // variable IDs
+    veci        user_values;    // values of these variables
+
+    // CNF loading
+    void *      pCnfMan;           // external CNF manager
+    int(*pCnfFunc)(void * p, int); // external callback
+
+    // termination callback
+    int         RunId;          // SAT id in this run
+    int(*pFuncStop)(int);       // callback to terminate
+};
+
+static inline clause * clause_read( sat_solver * s, cla h )          
+{ 
+    return Sat_MemClauseHand( &s->Mem, h );      
+}
+
+static inline int sat_solver_var_value( sat_solver* s, int v )
+{
+    assert( v >= 0 && v < s->size );
+    return (int)(s->model[v] == l_True);
+}
+static inline int sat_solver_var_literal( sat_solver* s, int v )
+{
+    assert( v >= 0 && v < s->size );
+    return toLitCond( v, s->model[v] != l_True );
+}
+static inline void sat_solver_flip_print_clause( sat_solver* s )
+{
+    s->fPrintClause ^= 1;
+}
+static inline void sat_solver_act_var_clear(sat_solver* s) 
+{
+    int i;
+    if ( s->VarActType == 0 )
+    {
+        for (i = 0; i < s->size; i++)
+            s->activity[i] = (1 << 10);
+        s->var_inc = (1 << 5);
+    }
+    else if ( s->VarActType == 1 )
+    {
+        for (i = 0; i < s->size; i++)
+            s->activity[i] = 0;
+        s->var_inc = 1;
+    }
+    else if ( s->VarActType == 2 )
+    {
+        for (i = 0; i < s->size; i++)
+            s->activity[i] = Xdbl_Const1();
+        s->var_inc = Xdbl_Const1();
+    }
+    else assert(0);
+}
+static inline void sat_solver_compress(sat_solver* s) 
+{
+    if ( s->qtail != s->qhead )
+    {
+        int RetValue = sat_solver_simplify(s);
+        assert( RetValue != 0 );
+        (void) RetValue;
+    }
+}
+static inline void sat_solver_delete_p( sat_solver ** ps )
+{
+    if ( *ps )
+        sat_solver_delete( *ps );
+    *ps = NULL;
+}
+static inline void sat_solver_clean_polarity(sat_solver* s, int * pVars, int nVars )
+{
+    int i;
+    for ( i = 0; i < nVars; i++ )
+        s->polarity[pVars[i]] = 0;
+}
+static inline void sat_solver_set_polarity(sat_solver* s, int * pVars, int nVars )
+{
+    int i;
+    for ( i = 0; i < s->size; i++ )
+        s->polarity[i] = 0;
+    for ( i = 0; i < nVars; i++ )
+        s->polarity[pVars[i]] = 1;
+}
+static inline void sat_solver_set_literal_polarity(sat_solver* s, int * pLits, int nLits )
+{
+    int i;
+    for ( i = 0; i < nLits; i++ )
+        s->polarity[Abc_Lit2Var(pLits[i])] = !Abc_LitIsCompl(pLits[i]);
+}
+
+static inline int sat_solver_final(sat_solver* s, int ** ppArray)
+{
+    *ppArray = s->conf_final.ptr;
+    return s->conf_final.size;
+}
+
+static inline abctime sat_solver_set_runtime_limit(sat_solver* s, abctime Limit)
+{
+    abctime nRuntimeLimit = s->nRuntimeLimit;
+    s->nRuntimeLimit = Limit;
+    return nRuntimeLimit;
+}
+
+static inline int sat_solver_set_random(sat_solver* s, int fNotUseRandom)
+{
+    int fNotUseRandomOld = s->fNotUseRandom;
+    s->fNotUseRandom = fNotUseRandom;
+    return fNotUseRandomOld;
+}
+
+static inline void sat_solver_bookmark(sat_solver* s)
+{
+    if ( s->qtail != s->qhead )
+    {
+        int status = sat_solver_simplify( s );
+        assert( status != 0 ); (void)status;
+        assert( s->qtail == s->qhead );
+    }
+    s->iVarPivot    = s->size;
+    s->iTrailPivot  = s->qhead;
+    Sat_MemBookMark( &s->Mem );
+    if ( s->activity2 )
+    {
+        s->var_inc2 = s->var_inc;
+        memcpy( s->activity2, s->activity, sizeof(word) * s->iVarPivot );
+    }
+}
+static inline void sat_solver_set_pivot_variables( sat_solver* s, int * pPivots, int nPivots )
+{
+    s->pivot_vars.cap = nPivots;
+    s->pivot_vars.size = nPivots;
+    s->pivot_vars.ptr = pPivots;
+}
+static inline int sat_solver_count_usedvars(sat_solver* s)
+{
+    int i, nVars = 0;
+    for ( i = 0; i < s->size; i++ )
+        if ( s->pFreqs[i] )
+        {
+            s->pFreqs[i] = 0;
+            nVars++;
+        }
+    return nVars;
+}
+static inline void sat_solver_set_runid( sat_solver *s, int id )               
+{ 
+    s->RunId      = id;  
+}
+static inline void sat_solver_set_stop_func( sat_solver *s, int (*fnct)(int) ) 
+{ 
+    s->pFuncStop = fnct; 
+}
+
+static inline int sat_solver_add_const( sat_solver * pSat, int iVar, int fCompl )
+{
+    lit Lits[1];
+    int Cid;
+    assert( iVar >= 0 );
+
+    Lits[0] = toLitCond( iVar, fCompl );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 1 );
+    assert( Cid );
+    return 1;
+}
+static inline int sat_solver_add_buffer( sat_solver * pSat, int iVarA, int iVarB, int fCompl )
+{
+    lit Lits[2];
+    int Cid;
+    assert( iVarA >= 0 && iVarB >= 0 );
+
+    Lits[0] = toLitCond( iVarA, 0 );
+    Lits[1] = toLitCond( iVarB, !fCompl );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    if ( Cid == 0 )
+        return 0;
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarA, 1 );
+    Lits[1] = toLitCond( iVarB, fCompl );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    if ( Cid == 0 )
+        return 0;
+    assert( Cid );
+    return 2;
+}
+static inline int sat_solver_add_buffer_enable( sat_solver * pSat, int iVarA, int iVarB, int iVarEn, int fCompl )
+{
+    lit Lits[3];
+    int Cid;
+    assert( iVarA >= 0 && iVarB >= 0 && iVarEn >= 0 );
+
+    Lits[0] = toLitCond( iVarA, 0 );
+    Lits[1] = toLitCond( iVarB, !fCompl );
+    Lits[2] = toLitCond( iVarEn, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarA, 1 );
+    Lits[1] = toLitCond( iVarB, fCompl );
+    Lits[2] = toLitCond( iVarEn, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+    return 2;
+}
+static inline int sat_solver_add_and( sat_solver * pSat, int iVar, int iVar0, int iVar1, int fCompl0, int fCompl1, int fCompl )
+{
+    lit Lits[3];
+    int Cid;
+
+    Lits[0] = toLitCond( iVar, !fCompl );
+    Lits[1] = toLitCond( iVar0, fCompl0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVar, !fCompl );
+    Lits[1] = toLitCond( iVar1, fCompl1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVar, fCompl );
+    Lits[1] = toLitCond( iVar0, !fCompl0 );
+    Lits[2] = toLitCond( iVar1, !fCompl1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+    return 3;
+}
+static inline int sat_solver_add_xor( sat_solver * pSat, int iVarA, int iVarB, int iVarC, int fCompl )
+{
+    lit Lits[3];
+    int Cid;
+    assert( iVarA >= 0 && iVarB >= 0 && iVarC >= 0 );
+
+    Lits[0] = toLitCond( iVarA, !fCompl );
+    Lits[1] = toLitCond( iVarB, 1 );
+    Lits[2] = toLitCond( iVarC, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarA, !fCompl );
+    Lits[1] = toLitCond( iVarB, 0 );
+    Lits[2] = toLitCond( iVarC, 0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarA, fCompl );
+    Lits[1] = toLitCond( iVarB, 1 );
+    Lits[2] = toLitCond( iVarC, 0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarA, fCompl );
+    Lits[1] = toLitCond( iVarB, 0 );
+    Lits[2] = toLitCond( iVarC, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+    return 4;
+}
+static inline int sat_solver_add_mux( sat_solver * pSat, int iVarZ, int iVarC, int iVarT, int iVarE, int iComplC, int iComplT, int iComplE, int iComplZ )
+{
+    lit Lits[3];
+    int Cid;
+    assert( iVarC >= 0 && iVarT >= 0 && iVarE >= 0 && iVarZ >= 0 );
+
+    Lits[0] = toLitCond( iVarC, 1 ^ iComplC );
+    Lits[1] = toLitCond( iVarT, 1 ^ iComplT );
+    Lits[2] = toLitCond( iVarZ, 0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarC, 1 ^ iComplC );
+    Lits[1] = toLitCond( iVarT, 0 ^ iComplT );
+    Lits[2] = toLitCond( iVarZ, 1 ^ iComplZ );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarC, 0 ^ iComplC );
+    Lits[1] = toLitCond( iVarE, 1 ^ iComplE );
+    Lits[2] = toLitCond( iVarZ, 0 ^ iComplZ );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarC, 0 ^ iComplC );
+    Lits[1] = toLitCond( iVarE, 0 ^ iComplE );
+    Lits[2] = toLitCond( iVarZ, 1 ^ iComplZ );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    if ( iVarT == iVarE )
+        return 4;
+
+    Lits[0] = toLitCond( iVarT, 0 ^ iComplT );
+    Lits[1] = toLitCond( iVarE, 0 ^ iComplE );
+    Lits[2] = toLitCond( iVarZ, 1 ^ iComplZ );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarT, 1 ^ iComplT );
+    Lits[1] = toLitCond( iVarE, 1 ^ iComplE );
+    Lits[2] = toLitCond( iVarZ, 0 ^ iComplZ );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+    return 6;
+}
+static inline int sat_solver_add_mux41( sat_solver * pSat, int iVarZ, int iVarC0, int iVarC1, int iVarD0, int iVarD1, int iVarD2, int iVarD3 )
+{
+    lit Lits[4];
+    int Cid;
+    assert( iVarC0 >= 0 && iVarC1 >= 0 && iVarD0 >= 0 && iVarD1 >= 0 && iVarD2 >= 0 && iVarD3 >= 0 && iVarZ >= 0 );
+
+    Lits[0] = toLitCond( iVarD0, 1 );
+    Lits[1] = toLitCond( iVarC0, 0 );
+    Lits[2] = toLitCond( iVarC1, 0 );
+    Lits[3] = toLitCond( iVarZ,  0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarD1, 1 );
+    Lits[1] = toLitCond( iVarC0, 1 );
+    Lits[2] = toLitCond( iVarC1, 0 );
+    Lits[3] = toLitCond( iVarZ,  0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarD2, 1 );
+    Lits[1] = toLitCond( iVarC0, 0 );
+    Lits[2] = toLitCond( iVarC1, 1 );
+    Lits[3] = toLitCond( iVarZ,  0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarD3, 1 );
+    Lits[1] = toLitCond( iVarC0, 1 );
+    Lits[2] = toLitCond( iVarC1, 1 );
+    Lits[3] = toLitCond( iVarZ,  0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+
+
+    Lits[0] = toLitCond( iVarD0, 0 );
+    Lits[1] = toLitCond( iVarC0, 0 );
+    Lits[2] = toLitCond( iVarC1, 0 );
+    Lits[3] = toLitCond( iVarZ,  1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarD1, 0 );
+    Lits[1] = toLitCond( iVarC0, 1 );
+    Lits[2] = toLitCond( iVarC1, 0 );
+    Lits[3] = toLitCond( iVarZ,  1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarD2, 0 );
+    Lits[1] = toLitCond( iVarC0, 0 );
+    Lits[2] = toLitCond( iVarC1, 1 );
+    Lits[3] = toLitCond( iVarZ,  1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarD3, 0 );
+    Lits[1] = toLitCond( iVarC0, 1 );
+    Lits[2] = toLitCond( iVarC1, 1 );
+    Lits[3] = toLitCond( iVarZ,  1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+    return 8;
+}
+static inline int sat_solver_add_xor_and( sat_solver * pSat, int iVarF, int iVarA, int iVarB, int iVarC )
+{
+    // F = (a (+) b) * c
+    lit Lits[4];
+    int Cid;
+    assert( iVarF >= 0 && iVarA >= 0 && iVarB >= 0 && iVarC >= 0 );
+
+    Lits[0] = toLitCond( iVarF, 1 );
+    Lits[1] = toLitCond( iVarA, 1 );
+    Lits[2] = toLitCond( iVarB, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarF, 1 );
+    Lits[1] = toLitCond( iVarA, 0 );
+    Lits[2] = toLitCond( iVarB, 0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarF, 1 );
+    Lits[1] = toLitCond( iVarC, 0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarF, 0 );
+    Lits[1] = toLitCond( iVarA, 1 );
+    Lits[2] = toLitCond( iVarB, 0 );
+    Lits[3] = toLitCond( iVarC, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarF, 0 );
+    Lits[1] = toLitCond( iVarA, 0 );
+    Lits[2] = toLitCond( iVarB, 1 );
+    Lits[3] = toLitCond( iVarC, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 4 );
+    assert( Cid );
+    return 5;
+}
+static inline int sat_solver_add_constraint( sat_solver * pSat, int iVar, int iVar2, int fCompl )
+{
+    lit Lits[2];
+    int Cid;
+    assert( iVar >= 0 );
+
+    Lits[0] = toLitCond( iVar, fCompl );
+    Lits[1] = toLitCond( iVar2, 0 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVar, fCompl );
+    Lits[1] = toLitCond( iVar2, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    assert( Cid );
+    return 2;
+}
+
+static inline int sat_solver_add_half_sorter( sat_solver * pSat, int iVarA, int iVarB, int iVar0, int iVar1 )
+{
+    lit Lits[3];
+    int Cid;
+
+    Lits[0] = toLitCond( iVarA, 0 );
+    Lits[1] = toLitCond( iVar0, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarA, 0 );
+    Lits[1] = toLitCond( iVar1, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 2 );
+    assert( Cid );
+
+    Lits[0] = toLitCond( iVarB, 0 );
+    Lits[1] = toLitCond( iVar0, 1 );
+    Lits[2] = toLitCond( iVar1, 1 );
+    Cid = sat_solver_addclause( pSat, Lits, Lits + 3 );
+    assert( Cid );
+    return 3;
+}
+
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/satStore.h b/lib/bill/bill/sat/solver/abc/satStore.h
new file mode 100644
index 0000000..f2480a7
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/satStore.h
@@ -0,0 +1,158 @@
+/**CFile****************************************************************
+
+  FileName    [satStore.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Proof recording.]
+
+  Synopsis    [External declarations.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: pr.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+ 
+#ifndef ABC__sat__bsat__satStore_h
+#define ABC__sat__bsat__satStore_h
+
+
+/*
+    The trace of SAT solving contains the original clauses of the problem
+    along with the learned clauses derived during SAT solving.
+    The first line of the resulting file contains 3 numbers instead of 2:
+    c <num_vars> <num_all_clauses> <num_root_clauses>
+*/
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include "satSolver.h"
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+ABC_NAMESPACE_HEADER_START
+
+#ifdef _WIN32
+#define inline __inline // compatible with MS VS 6.0
+#endif
+
+#define STO_MAX(a,b)  ((a) > (b) ? (a) : (b))
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+/*
+typedef unsigned lit;
+// variable/literal conversions (taken from MiniSat)
+static inline lit   toLit    (int v)        { return v + v;  }
+static inline lit   toLitCond(int v, int c) { return v + v + (c != 0); }
+static inline lit   lit_neg  (lit l)        { return l ^ 1;  }
+static inline int   lit_var  (lit l)        { return l >> 1; }
+static inline int   lit_sign (lit l)        { return l & 1;  }
+static inline int   lit_print(lit l)        { return lit_sign(l)? -lit_var(l)-1 : lit_var(l)+1; }
+static inline lit   lit_read (int s)        { return s > 0 ? toLit(s-1) : lit_neg(toLit(-s-1)); }
+static inline int   lit_check(lit l, int n) { return l >= 0 && lit_var(l) < n;                  }
+*/
+
+typedef struct Sto_Cls_t_ Sto_Cls_t;
+struct Sto_Cls_t_
+{
+    Sto_Cls_t *     pNext;        // the next clause
+    Sto_Cls_t *     pNext0;       // the next 0-watch
+    Sto_Cls_t *     pNext1;       // the next 1-watch
+    int             Id;           // the clause ID
+    unsigned        fA     :  1;  // belongs to A
+    unsigned        fRoot  :  1;  // original clause
+    unsigned        fVisit :  1;  // visited clause
+    unsigned        nLits  : 24;  // the number of literals
+    lit             pLits[0];     // literals of this clause
+};
+
+typedef struct Sto_Man_t_ Sto_Man_t;
+struct Sto_Man_t_
+{
+    // general data
+    int             nVars;        // the number of variables
+    int             nRoots;       // the number of root clauses
+    int             nClauses;     // the number of all clauses
+    int             nClausesA;    // the number of clauses of A 
+    Sto_Cls_t *     pHead;        // the head clause
+    Sto_Cls_t *     pTail;        // the tail clause
+    Sto_Cls_t *     pEmpty;       // the empty clause
+    // memory management
+    int             nChunkSize;   // the number of bytes in a chunk
+    int             nChunkUsed;   // the number of bytes used in the last chunk
+    char *          pChunkLast;   // the last memory chunk
+};
+
+// iterators through the clauses
+#define Sto_ManForEachClause( p, pCls )      for( pCls = p->pHead; pCls; pCls = pCls->pNext )
+#define Sto_ManForEachClauseRoot( p, pCls )  for( pCls = p->pHead; pCls && pCls->fRoot; pCls = pCls->pNext )
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                    FUNCTION DECLARATIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/*=== satStore.c ==========================================================*/
+extern Sto_Man_t *  Sto_ManAlloc();
+extern void         Sto_ManFree( Sto_Man_t * p );
+extern int          Sto_ManAddClause( Sto_Man_t * p, lit * pBeg, lit * pEnd );
+extern int          Sto_ManMemoryReport( Sto_Man_t * p );
+extern void         Sto_ManMarkRoots( Sto_Man_t * p );
+extern void         Sto_ManMarkClausesA( Sto_Man_t * p );
+extern void         Sto_ManDumpClauses( Sto_Man_t * p, char * pFileName );
+extern int          Sto_ManChangeLastClause( Sto_Man_t * p );
+extern Sto_Man_t *  Sto_ManLoadClauses( char * pFileName );
+
+
+/*=== satInter.c ==========================================================*/
+typedef struct Int_Man_t_ Int_Man_t;
+extern Int_Man_t *  Int_ManAlloc();
+extern int *        Int_ManSetGlobalVars( Int_Man_t * p, int nGloVars );
+extern void         Int_ManFree( Int_Man_t * p );
+extern int          Int_ManInterpolate( Int_Man_t * p, Sto_Man_t * pCnf, int fVerbose, unsigned ** ppResult );
+
+/*=== satInterA.c ==========================================================*/
+typedef struct Inta_Man_t_ Inta_Man_t;
+extern Inta_Man_t * Inta_ManAlloc();
+extern void         Inta_ManFree( Inta_Man_t * p );
+extern void *       Inta_ManInterpolate( Inta_Man_t * p, Sto_Man_t * pCnf, abctime TimeToStop, void * vVarsAB, int fVerbose );
+
+/*=== satInterB.c ==========================================================*/
+typedef struct Intb_Man_t_ Intb_Man_t;
+extern Intb_Man_t * Intb_ManAlloc();
+extern void         Intb_ManFree( Intb_Man_t * p );
+extern void *       Intb_ManInterpolate( Intb_Man_t * p, Sto_Man_t * pCnf, void * vVarsAB, int fVerbose );
+
+/*=== satInterP.c ==========================================================*/
+typedef struct Intp_Man_t_ Intp_Man_t;
+extern Intp_Man_t * Intp_ManAlloc();
+extern void         Intp_ManFree( Intp_Man_t * p );
+extern void *       Intp_ManUnsatCore( Intp_Man_t * p, Sto_Man_t * pCnf, int fLearned, int fVerbose );
+extern void         Intp_ManUnsatCorePrintForBmc( FILE * pFile, Sto_Man_t * pCnf, void * vCore, void * vVarMap );
+
+
+ABC_NAMESPACE_HEADER_END
+
+
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
diff --git a/lib/bill/bill/sat/solver/abc/satVec.h b/lib/bill/bill/sat/solver/abc/satVec.h
new file mode 100644
index 0000000..121a649
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/satVec.h
@@ -0,0 +1,169 @@
+/**************************************************************************************************
+MiniSat -- Copyright (c) 2005, Niklas Sorensson
+http://www.cs.chalmers.se/Cs/Research/FormalMethods/MiniSat/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+// Modified to compile with MS Visual Studio 6.0 by Alan Mishchenko
+
+#ifndef ABC__sat__bsat__satVec_h
+#define ABC__sat__bsat__satVec_h
+
+#include "abc_global.h"
+
+ABC_NAMESPACE_HEADER_START
+
+
+// vector of 32-bit intergers (added for 64-bit portability)
+struct veci_t {
+    int    cap;
+    int    size;
+    int*   ptr;
+};
+typedef struct veci_t veci;
+
+static inline void veci_new (veci* v) {
+    v->cap  = 4;
+    v->size = 0;
+    v->ptr  = (int*)ABC_ALLOC( char, sizeof(int)*v->cap);
+}
+
+static inline void   veci_delete (veci* v)          { ABC_FREE(v->ptr);   }
+static inline int*   veci_begin  (veci* v)          { return v->ptr;  }
+static inline int    veci_size   (veci* v)          { return v->size; }
+static inline void   veci_resize (veci* v, int k)   { 
+    assert(k <= v->size); 
+//    memset( veci_begin(v) + k, -1, sizeof(int) * (veci_size(v) - k) );
+    v->size = k;         
+} // only safe to shrink !!
+static inline int    veci_pop    (veci* v)          { assert(v->size); return v->ptr[--v->size]; }
+static inline void   veci_push   (veci* v, int e)
+{
+    if (v->size == v->cap) {
+//        int newsize = v->cap * 2;//+1;
+        int newsize = (v->cap < 4) ? v->cap * 2 : (v->cap / 2) * 3;
+        v->ptr = ABC_REALLOC( int, v->ptr, newsize );
+        if ( v->ptr == NULL )
+        {
+            printf( "Failed to realloc memory from %.1f MB to %.1f MB.\n", 
+                1.0 * v->cap / (1<<20), 1.0 * newsize / (1<<20) );
+            fflush( stdout );
+        }
+        v->cap = newsize; }
+    v->ptr[v->size++] = e;
+}
+static inline void   veci_remove(veci* v, int e)
+{
+    int * ws = (int*)veci_begin(v);
+    int    j  = 0;
+    for (; ws[j] != e  ; j++);
+    assert(j < veci_size(v));
+    for (; j < veci_size(v)-1; j++) ws[j] = ws[j+1];
+    veci_resize(v,veci_size(v)-1);
+}
+
+
+// vector of 32- or 64-bit pointers
+struct vecp_t {
+    int    cap;
+    int    size;
+    void** ptr;
+};
+typedef struct vecp_t vecp;
+
+static inline void vecp_new (vecp* v) {
+    v->size = 0;
+    v->cap  = 4;
+    v->ptr  = (void**)ABC_ALLOC( char, sizeof(void*)*v->cap);
+}
+
+static inline void   vecp_delete (vecp* v)          { ABC_FREE(v->ptr);   }
+static inline void** vecp_begin  (vecp* v)          { return v->ptr;  }
+static inline int    vecp_size   (vecp* v)          { return v->size; }
+static inline void   vecp_resize (vecp* v, int   k) { assert(k <= v->size); v->size = k;    } // only safe to shrink !!
+static inline void   vecp_push   (vecp* v, void* e)
+{
+    if (v->size == v->cap) {
+//        int newsize = v->cap * 2;//+1;
+        int newsize = (v->cap < 4) ? v->cap * 2 : (v->cap / 2) * 3;
+        v->ptr = ABC_REALLOC( void*, v->ptr, newsize );
+        v->cap = newsize; }
+    v->ptr[v->size++] = e;
+}
+static inline void   vecp_remove(vecp* v, void* e)
+{
+    void** ws = vecp_begin(v);
+    int    j  = 0;
+    for (; ws[j] != e  ; j++);
+    assert(j < vecp_size(v));
+    for (; j < vecp_size(v)-1; j++) ws[j] = ws[j+1];
+    vecp_resize(v,vecp_size(v)-1);
+}
+
+
+
+//=================================================================================================
+// Simple types:
+
+#ifndef __cplusplus
+#ifndef false
+#  define false 0
+#endif
+#ifndef true
+#  define true 1
+#endif
+#endif
+
+typedef int    lit;
+typedef int    cla;
+
+// Explicitly make it signed so promotion-to-int behavior doesn't vary
+// across platforms that define signedness of char differently.
+typedef signed char lbool;
+
+// CryptoMinisat defines it's own var_Undef values.
+// When it's included we prefer the ABC version instead.
+#ifdef var_Undef
+#undef var_Undef
+#endif
+
+static const int   var_Undef = -1;
+static const lit   lit_Undef = -2;
+
+static const lbool l_Undef   =  0;
+static const lbool l_True    =  1;
+static const lbool l_False   = -1;
+
+static inline lit  toLit    (int v)        { return v + v; }
+static inline lit  toLitCond(int v, int c) { return v + v + (c != 0); }
+static inline lit  lit_neg  (lit l)        { return l ^ 1; }
+static inline int  lit_var  (lit l)        { return l >> 1; }
+static inline int  lit_sign (lit l)        { return l & 1; }
+static inline int  lit_print(lit l)        { return lit_sign(l)? -lit_var(l)-1 : lit_var(l)+1; }
+static inline lit  lit_read (int s)        { return s > 0 ? toLit(s-1) : lit_neg(toLit(-s-1)); }
+static inline int  lit_check(lit l, int n) { return l >= 0 && lit_var(l) < n;                  }
+
+struct stats_t
+{
+    unsigned starts, clauses, learnts;
+    ABC_INT64_T decisions, propagations, inspects, conflicts;
+    ABC_INT64_T clauses_literals, learnts_literals, tot_literals;
+};
+typedef struct stats_t stats_t;
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/system.h b/lib/bill/bill/sat/solver/abc/system.h
new file mode 100644
index 0000000..4a3bfd7
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/system.h
@@ -0,0 +1,67 @@
+/****************************************************************************************[System.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Abc_Glucose_System_h
+#define Abc_Glucose_System_h
+
+#include "IntTypes.h"
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+//-------------------------------------------------------------------------------------------------
+
+namespace Gluco {
+
+static inline double cpuTime(void); // CPU-time in seconds.
+
+}
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+//-------------------------------------------------------------------------------------------------
+// Implementation of inline functions:
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#include <time.h>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+static inline double Gluco::cpuTime(void) { return (double)clock() / CLOCKS_PER_SEC; }
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+
+#else
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <unistd.h>
+
+ABC_NAMESPACE_CXX_HEADER_START
+
+static inline double Gluco::cpuTime(void) {
+    struct rusage ru;
+    getrusage(RUSAGE_SELF, &ru);
+    return (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec / 1000000; }
+
+ABC_NAMESPACE_CXX_HEADER_END
+
+#endif
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/utilDouble.h b/lib/bill/bill/sat/solver/abc/utilDouble.h
new file mode 100644
index 0000000..8880882
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/utilDouble.h
@@ -0,0 +1,222 @@
+/**CFile****************************************************************
+
+  FileName    [utilDouble.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName []
+
+  Synopsis    [Double floating point number implementation.]
+
+  Author      [Alan Mishchenko, Bruno Schmitt]
+
+  Affiliation [UC Berkeley / UFRGS]
+
+  Date        [Ver. 1.0. Started - February 11, 2017.]
+
+  Revision    []
+
+***********************************************************************/
+
+#ifndef ABC__sat__Xdbl__Xdbl_h
+#define ABC__sat__Xdbl__Xdbl_h
+
+#include "abc_global.h"
+
+ABC_NAMESPACE_HEADER_START
+
+////////////////////////////////////////////////////////////////////////
+///                    STRUCTURE DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/* 
+    The xdbl floating-point number is represented as a 64-bit unsigned int.
+    The number is (2^Exp)*Mnt, where Exp is a 16-bit exponent and Mnt is a 
+    48-bit mantissa.  The decimal point is located between the MSB of Mnt,
+    which is always 1, and the remaining 15 digits of Mnt.
+
+    Currently, only positive numbers are represented.
+
+    The range of possible values is [1.0; 2^(2^16-1)*1.111111111111111]
+    that is, the smallest possible number is 1.0 and the largest possible 
+    number is 2^(---16 ones---).(1.---47 ones---)
+
+    Comparison of numbers can be done by comparing the underlying unsigned ints.
+
+    Only addition, multiplication, and division by 2^n are currently implemented.
+*/
+
+typedef word xdbl;
+
+static inline word   Xdbl_Exp( xdbl a )                 { return a >> 48;           }
+static inline word   Xdbl_Mnt( xdbl a )                 { return (a << 16) >> 16;   }
+
+static inline xdbl   Xdbl_Create( word Exp, word Mnt )  { assert(!(Exp>>16) && (Mnt>>47)==(word)1); return (Exp<<48) | Mnt;  }
+
+static inline xdbl   Xdbl_Const1()                      { return Xdbl_Create( (word)0, (word)1 << 47 );                      }
+static inline xdbl   Xdbl_Const2()                      { return Xdbl_Create( (word)1, (word)1 << 47 );                      }
+static inline xdbl   Xdbl_Const3()                      { return Xdbl_Create( (word)1, (word)3 << 46 );                      }
+static inline xdbl   Xdbl_Const12()                     { return Xdbl_Create( (word)3, (word)3 << 46 );                      }
+static inline xdbl   Xdbl_Const1point5()                { return Xdbl_Create( (word)0, (word)3 << 46 );                      }
+static inline xdbl   Xdbl_Const2point5()                { return Xdbl_Create( (word)1, (word)5 << 45 );                      }
+static inline xdbl   Xdbl_Maximum()                     { return ~(word)0;                                                   }
+
+static inline double Xdbl_ToDouble( xdbl a )            { assert(Xdbl_Exp(a) < 1023); return Abc_Word2Dbl(((Xdbl_Exp(a) + 1023) << 52) | (((a<<17)>>17) << 5));                  }
+static inline xdbl   Xdbl_FromDouble( double a )        { word A = Abc_Dbl2Word(a); assert(a >= 1.0); return Xdbl_Create((A >> 52)-1023, (((word)1) << 47) | ((A << 12) >> 17)); }
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Adding two floating-point numbers.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline xdbl Xdbl_Add( xdbl a, xdbl b )
+{
+    word Exp, Mnt;
+    if ( a < b ) a ^= b, b ^= a, a ^= b;
+    assert( a >= b );
+    Mnt = Xdbl_Mnt(a) + (Xdbl_Mnt(b) >> (Xdbl_Exp(a) - Xdbl_Exp(b)));
+    Exp = Xdbl_Exp(a);
+    if ( Mnt >> 48 ) // new MSB is created
+        Exp++, Mnt >>= 1;
+    if ( Exp >> 16 ) // overflow
+        return Xdbl_Maximum();
+    return Xdbl_Create( Exp, Mnt );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Multiplying two floating-point numbers.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline xdbl Xdbl_Mul( xdbl a, xdbl b )
+{
+    word Exp, Mnt, MntA, MntB, MntAh, MntBh, MntAl, MntBl;
+    if ( a < b ) a ^= b, b ^= a, a ^= b;
+    assert( a >= b );
+    MntA  = Xdbl_Mnt(a);
+    MntB  = Xdbl_Mnt(b);
+    MntAh = MntA>>32;
+    MntBh = MntB>>32;
+    MntAl = (MntA<<32)>>32;
+    MntBl = (MntB<<32)>>32;
+    Mnt = ((MntAh * MntBh) << 17) + ((MntAl * MntBl) >> 47) + ((MntAl * MntBh) >> 15) + ((MntAh * MntBl) >> 15);
+    Exp = Xdbl_Exp(a) + Xdbl_Exp(b);
+    if ( Mnt >> 48 ) // new MSB is created
+        Exp++, Mnt >>= 1;
+    if ( Exp >> 16 ) // overflow
+        return Xdbl_Maximum();
+    return Xdbl_Create( Exp, Mnt );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Dividing floating point number by a degree of 2.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline xdbl Xdbl_Div( xdbl a, unsigned Deg2 )
+{
+    if ( Xdbl_Exp(a) >= (word)Deg2 )
+        return Xdbl_Create( Xdbl_Exp(a) - Deg2, Xdbl_Mnt(a) );
+    return Xdbl_Const1(); // underflow
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Testing procedure.]
+
+  Description [Helpful link https://www.h-schmidt.net/FloatConverter/IEEE754.html]
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Xdbl_Test()
+{
+    xdbl c1   = Xdbl_Const1();
+    xdbl c2   = Xdbl_Const2();
+    xdbl c3   = Xdbl_Const3();
+    xdbl c12  = Xdbl_Const12();
+    xdbl c1p5 = Xdbl_Const1point5();
+    xdbl c2p5 = Xdbl_Const2point5();
+
+    xdbl c1_   = Xdbl_FromDouble(1.0);
+    xdbl c2_   = Xdbl_FromDouble(2.0);
+    xdbl c3_   = Xdbl_FromDouble(3.0);
+    xdbl c12_  = Xdbl_FromDouble(12.0);
+    xdbl c1p5_ = Xdbl_FromDouble(1.5);
+    xdbl c2p5_ = Xdbl_FromDouble(2.5);
+
+    xdbl sum1 = Xdbl_Add(c1, c1p5);
+    xdbl mul1 = Xdbl_Mul(c2, c1p5);
+
+    xdbl sum2 = Xdbl_Add(c1p5, c2p5);
+    xdbl mul2 = Xdbl_Mul(c1p5, c2p5);
+
+    xdbl a    = Xdbl_FromDouble(1.2929725);
+    xdbl b    = Xdbl_FromDouble(10.28828287);
+    xdbl ab   = Xdbl_Mul(a, b);
+
+    xdbl ten100 = Xdbl_FromDouble( 1e100 );
+    xdbl ten100_ = ABC_CONST(0x014c924d692ca61b);
+
+    assert( ten100 == ten100_ );
+
+//    float f1 = Xdbl_ToDouble(c1);
+//    Extra_PrintBinary( stdout, (int *)&c1, 32 ); printf( "\n" );
+//    Extra_PrintBinary( stdout, (int *)&f1, 32 ); printf( "\n" );
+
+    printf( "1 = %lf\n",   Xdbl_ToDouble(c1) );
+    printf( "2 = %lf\n",   Xdbl_ToDouble(c2) );
+    printf( "3 = %lf\n",   Xdbl_ToDouble(c3) );
+    printf( "12 = %lf\n",  Xdbl_ToDouble(c12) );
+    printf( "1.5 = %lf\n", Xdbl_ToDouble(c1p5) );
+    printf( "2.5 = %lf\n", Xdbl_ToDouble(c2p5) );
+
+    printf( "Converted 1 = %lf\n",   Xdbl_ToDouble(c1_) );
+    printf( "Converted 2 = %lf\n",   Xdbl_ToDouble(c2_) );
+    printf( "Converted 3 = %lf\n",   Xdbl_ToDouble(c3_) );
+    printf( "Converted 12 = %lf\n",  Xdbl_ToDouble(c12_) );
+    printf( "Converted 1.5 = %lf\n", Xdbl_ToDouble(c1p5_) );
+    printf( "Converted 2.5 = %lf\n", Xdbl_ToDouble(c2p5_) );
+
+    printf( "1.0 + 1.5 = %lf\n", Xdbl_ToDouble(sum1) );
+    printf( "2.0 * 1.5 = %lf\n", Xdbl_ToDouble(mul1) );
+
+    printf( "1.5 + 2.5 = %lf\n", Xdbl_ToDouble(sum2) );
+    printf( "1.5 * 2.5 = %lf\n", Xdbl_ToDouble(mul2) );
+    printf( "12 / 2^2  = %lf\n", Xdbl_ToDouble(Xdbl_Div(c12, 2)) );
+
+    printf( "12 / 2^2  = %lf\n", Xdbl_ToDouble(Xdbl_Div(c12, 2)) );
+
+    printf( "%.16lf * %.16lf = %.16lf (%.16lf)\n", Xdbl_ToDouble(a), Xdbl_ToDouble(b), Xdbl_ToDouble(ab), 1.2929725 * 10.28828287 );
+
+    assert( sum1 == c2p5 );
+    assert( mul1 == c3 );
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/lib/bill/bill/sat/solver/abc/vecInt.h b/lib/bill/bill/sat/solver/abc/vecInt.h
new file mode 100644
index 0000000..51740e7
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/vecInt.h
@@ -0,0 +1,2078 @@
+/**CFile****************************************************************
+
+  FileName    [vecInt.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Resizable arrays.]
+
+  Synopsis    [Resizable arrays of integers.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: vecInt.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+ 
+#ifndef ABC__misc__vec__vecInt_h
+#define ABC__misc__vec__vecInt_h
+
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include <stdio.h>
+
+ABC_NAMESPACE_HEADER_START
+
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct Vec_Int_t_       Vec_Int_t;
+struct Vec_Int_t_ 
+{
+    int              nCap;
+    int              nSize;
+    int *            pArray;
+};
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+#define Vec_IntForEachEntry( vVec, Entry, i )                                               \
+    for ( i = 0; (i < Vec_IntSize(vVec)) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ )
+#define Vec_IntForEachEntryStart( vVec, Entry, i, Start )                                   \
+    for ( i = Start; (i < Vec_IntSize(vVec)) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ )
+#define Vec_IntForEachEntryStop( vVec, Entry, i, Stop )                                     \
+    for ( i = 0; (i < Stop) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ )
+#define Vec_IntForEachEntryStartStop( vVec, Entry, i, Start, Stop )                         \
+    for ( i = Start; (i < Stop) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ )
+#define Vec_IntForEachEntryReverse( vVec, pEntry, i )                                       \
+    for ( i = Vec_IntSize(vVec) - 1; (i >= 0) && (((pEntry) = Vec_IntEntry(vVec, i)), 1); i-- )
+#define Vec_IntForEachEntryTwo( vVec1, vVec2, Entry1, Entry2, i )                           \
+    for ( i = 0; (i < Vec_IntSize(vVec1)) && (((Entry1) = Vec_IntEntry(vVec1, i)), 1) && (((Entry2) = Vec_IntEntry(vVec2, i)), 1); i++ )
+#define Vec_IntForEachEntryDouble( vVec, Entry1, Entry2, i )                                \
+    for ( i = 0; (i+1 < Vec_IntSize(vVec)) && (((Entry1) = Vec_IntEntry(vVec, i)), 1) && (((Entry2) = Vec_IntEntry(vVec, i+1)), 1); i += 2 )
+#define Vec_IntForEachEntryDoubleStart( vVec, Entry1, Entry2, i, Start )                    \
+    for ( i = Start; (i+1 < Vec_IntSize(vVec)) && (((Entry1) = Vec_IntEntry(vVec, i)), 1) && (((Entry2) = Vec_IntEntry(vVec, i+1)), 1); i += 2 )
+#define Vec_IntForEachEntryTriple( vVec, Entry1, Entry2, Entry3, i )                        \
+    for ( i = 0; (i+2 < Vec_IntSize(vVec)) && (((Entry1) = Vec_IntEntry(vVec, i)), 1) && (((Entry2) = Vec_IntEntry(vVec, i+1)), 1) && (((Entry3) = Vec_IntEntry(vVec, i+2)), 1); i += 3 )
+#define Vec_IntForEachEntryThisNext( vVec, This, Next, i )                                  \
+    for ( i = 0, (This) = (Next) = (Vec_IntSize(vVec) ? Vec_IntEntry(vVec, 0) : -1); (i+1 < Vec_IntSize(vVec)) && (((Next) = Vec_IntEntry(vVec, i+1)), 1); i += 2, (This) = (Next) )
+#define Vec_IntForEachEntryInVec( vVec2, vVec, Entry, i )                                   \
+    for ( i = 0; (i < Vec_IntSize(vVec)) && (((Entry) = Vec_IntEntry(vVec2, Vec_IntEntry(vVec, i))), 1); i++ )
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates a vector with the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntAlloc( int nCap )
+{
+    Vec_Int_t * p;
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    if ( nCap > 0 && nCap < 16 )
+        nCap = 16;
+    p->nSize  = 0;
+    p->nCap   = nCap;
+    p->pArray = p->nCap? ABC_ALLOC( int, p->nCap ) : NULL;
+    return p;
+}
+static inline Vec_Int_t * Vec_IntAllocExact( int nCap )
+{
+    Vec_Int_t * p;
+    assert( nCap >= 0 );
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    p->nSize  = 0;
+    p->nCap   = nCap;
+    p->pArray = p->nCap? ABC_ALLOC( int, p->nCap ) : NULL;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates a vector with the given size and cleans it.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntStart( int nSize )
+{
+    Vec_Int_t * p;
+    p = Vec_IntAlloc( nSize );
+    p->nSize = nSize;
+    memset( p->pArray, 0, sizeof(int) * nSize );
+    return p;
+}
+static inline Vec_Int_t * Vec_IntStartFull( int nSize )
+{
+    Vec_Int_t * p;
+    p = Vec_IntAlloc( nSize );
+    p->nSize = nSize;
+    memset( p->pArray, 0xff, sizeof(int) * nSize );
+    return p;
+}
+static inline Vec_Int_t * Vec_IntStartRange( int First, int Range )
+{
+    Vec_Int_t * p;
+    int i;
+    p = Vec_IntAlloc( Range );
+    p->nSize = Range;
+    for ( i = 0; i < Range; i++ )
+        p->pArray[i] = First + i;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates a vector with the given size and cleans it.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntStartNatural( int nSize )
+{
+    Vec_Int_t * p;
+    int i;
+    p = Vec_IntAlloc( nSize );
+    p->nSize = nSize;
+    for ( i = 0; i < nSize; i++ )
+        p->pArray[i] = i;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Creates the vector from an integer array of the given size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntAllocArray( int * pArray, int nSize )
+{
+    Vec_Int_t * p;
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    p->nSize  = nSize;
+    p->nCap   = nSize;
+    p->pArray = pArray;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Creates the vector from an integer array of the given size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntAllocArrayCopy( int * pArray, int nSize )
+{
+    Vec_Int_t * p;
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    p->nSize  = nSize;
+    p->nCap   = nSize;
+    p->pArray = ABC_ALLOC( int, nSize );
+    memcpy( p->pArray, pArray, sizeof(int) * nSize );
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Duplicates the integer array.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntDup( Vec_Int_t * pVec )
+{
+    Vec_Int_t * p;
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    p->nSize  = pVec->nSize;
+    p->nCap   = pVec->nSize;
+    p->pArray = p->nCap? ABC_ALLOC( int, p->nCap ) : NULL;
+    memcpy( p->pArray, pVec->pArray, sizeof(int) * pVec->nSize );
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Transfers the array into another vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntDupArray( Vec_Int_t * pVec )
+{
+    Vec_Int_t * p;
+    p = ABC_ALLOC( Vec_Int_t, 1 );
+    p->nSize  = pVec->nSize;
+    p->nCap   = pVec->nCap;
+    p->pArray = pVec->pArray;
+    pVec->nSize  = 0;
+    pVec->nCap   = 0;
+    pVec->pArray = NULL;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntZero( Vec_Int_t * p )
+{
+    p->pArray = NULL;
+    p->nSize = 0;
+    p->nCap = 0;
+}
+static inline void Vec_IntErase( Vec_Int_t * p )
+{
+    ABC_FREE( p->pArray );
+    p->nSize = 0;
+    p->nCap = 0;
+}
+static inline void Vec_IntFree( Vec_Int_t * p )
+{
+    ABC_FREE( p->pArray );
+    ABC_FREE( p );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntFreeP( Vec_Int_t ** p )
+{
+    if ( *p == NULL )
+        return;
+    ABC_FREE( (*p)->pArray );
+    ABC_FREE( (*p) );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int * Vec_IntReleaseArray( Vec_Int_t * p )
+{
+    int * pArray = p->pArray;
+    p->nCap = 0;
+    p->nSize = 0;
+    p->pArray = NULL;
+    return pArray;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int * Vec_IntArray( Vec_Int_t * p )
+{
+    return p->pArray;
+}
+static inline int ** Vec_IntArrayP( Vec_Int_t * p )
+{
+    return &p->pArray;
+}
+static inline int * Vec_IntLimit( Vec_Int_t * p )
+{
+    return p->pArray + p->nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntSize( Vec_Int_t * p )
+{
+    return p->nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntCap( Vec_Int_t * p )
+{
+    return p->nCap;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline double Vec_IntMemory( Vec_Int_t * p )
+{
+    return !p ? 0.0 : 1.0 * sizeof(int) * p->nCap + sizeof(Vec_Int_t) ;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntEntry( Vec_Int_t * p, int i )
+{
+    assert( i >= 0 && i < p->nSize );
+    return p->pArray[i];
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int * Vec_IntEntryP( Vec_Int_t * p, int i )
+{
+    assert( i >= 0 && i < p->nSize );
+    return p->pArray + i;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntWriteEntry( Vec_Int_t * p, int i, int Entry )
+{
+    assert( i >= 0 && i < p->nSize );
+    p->pArray[i] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntAddToEntry( Vec_Int_t * p, int i, int Addition )
+{
+    assert( i >= 0 && i < p->nSize );
+    return p->pArray[i] += Addition;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntUpdateEntry( Vec_Int_t * p, int i, int Value )
+{
+    if ( Vec_IntEntry( p, i ) < Value )
+        Vec_IntWriteEntry( p, i, Value );
+}
+static inline void Vec_IntDowndateEntry( Vec_Int_t * p, int i, int Value )
+{
+    if ( Vec_IntEntry( p, i ) > Value )
+        Vec_IntWriteEntry( p, i, Value );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntEntryLast( Vec_Int_t * p )
+{
+    assert( p->nSize > 0 );
+    return p->pArray[p->nSize-1];
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Resizes the vector to the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntGrow( Vec_Int_t * p, int nCapMin )
+{
+    if ( p->nCap >= nCapMin )
+        return;
+    p->pArray = ABC_REALLOC( int, p->pArray, nCapMin ); 
+    assert( p->pArray );
+    p->nCap   = nCapMin;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Resizes the vector to the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntGrowResize( Vec_Int_t * p, int nCapMin )
+{
+    p->nSize  = nCapMin;
+    if ( p->nCap >= nCapMin )
+        return;
+    p->pArray = ABC_REALLOC( int, p->pArray, nCapMin ); 
+    assert( p->pArray );
+    p->nCap   = nCapMin;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Fills the vector with given number of entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntFill( Vec_Int_t * p, int nSize, int Fill )
+{
+    int i;
+    Vec_IntGrow( p, nSize );
+    for ( i = 0; i < nSize; i++ )
+        p->pArray[i] = Fill;
+    p->nSize = nSize;
+}
+static inline void Vec_IntFillTwo( Vec_Int_t * p, int nSize, int FillEven, int FillOdd )
+{
+    int i;
+    Vec_IntGrow( p, nSize );
+    for ( i = 0; i < nSize; i++ )
+        p->pArray[i] = (i & 1) ? FillOdd : FillEven;
+    p->nSize = nSize;
+}
+static inline void Vec_IntFillNatural( Vec_Int_t * p, int nSize )
+{
+    int i;
+    Vec_IntGrow( p, nSize );
+    for ( i = 0; i < nSize; i++ )
+        p->pArray[i] = i;
+    p->nSize = nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Fills the vector with given number of entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntFillExtra( Vec_Int_t * p, int nSize, int Fill )
+{
+    int i;
+    if ( nSize <= p->nSize )
+        return;
+    if ( nSize > 2 * p->nCap )
+        Vec_IntGrow( p, nSize );
+    else if ( nSize > p->nCap )
+        Vec_IntGrow( p, 2 * p->nCap );
+    for ( i = p->nSize; i < nSize; i++ )
+        p->pArray[i] = Fill;
+    p->nSize = nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the entry even if the place not exist.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntGetEntry( Vec_Int_t * p, int i )
+{
+    Vec_IntFillExtra( p, i + 1, 0 );
+    return Vec_IntEntry( p, i );
+}
+static inline int Vec_IntGetEntryFull( Vec_Int_t * p, int i )
+{
+    Vec_IntFillExtra( p, i + 1, -1 );
+    return Vec_IntEntry( p, i );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the entry even if the place not exist.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int * Vec_IntGetEntryP( Vec_Int_t * p, int i )
+{
+    Vec_IntFillExtra( p, i + 1, 0 );
+    return Vec_IntEntryP( p, i );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the entry even if the place does not exist.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntSetEntry( Vec_Int_t * p, int i, int Entry )
+{
+    Vec_IntFillExtra( p, i + 1, 0 );
+    Vec_IntWriteEntry( p, i, Entry );
+}
+static inline void Vec_IntSetEntryFull( Vec_Int_t * p, int i, int Entry )
+{
+    Vec_IntFillExtra( p, i + 1, -1 );
+    Vec_IntWriteEntry( p, i, Entry );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntShrink( Vec_Int_t * p, int nSizeNew )
+{
+    assert( p->nSize >= nSizeNew );
+    p->nSize = nSizeNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntClear( Vec_Int_t * p )
+{
+    p->nSize = 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntPush( Vec_Int_t * p, int Entry )
+{
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_IntGrow( p, 16 );
+        else
+            Vec_IntGrow( p, 2 * p->nCap );
+    }
+    p->pArray[p->nSize++] = Entry;
+}
+static inline void Vec_IntPushTwo( Vec_Int_t * p, int Entry1, int Entry2 )
+{
+    Vec_IntPush( p, Entry1 );
+    Vec_IntPush( p, Entry2 );
+}
+static inline void Vec_IntPushThree( Vec_Int_t * p, int Entry1, int Entry2, int Entry3 )
+{
+    Vec_IntPush( p, Entry1 );
+    Vec_IntPush( p, Entry2 );
+    Vec_IntPush( p, Entry3 );
+}
+static inline void Vec_IntPushFour( Vec_Int_t * p, int Entry1, int Entry2, int Entry3, int Entry4 )
+{
+    Vec_IntPush( p, Entry1 );
+    Vec_IntPush( p, Entry2 );
+    Vec_IntPush( p, Entry3 );
+    Vec_IntPush( p, Entry4 );
+}
+static inline void Vec_IntPushArray( Vec_Int_t * p, int * pEntries, int nEntries )
+{
+    int i;
+    for ( i = 0; i < nEntries; i++ )
+        Vec_IntPush( p, pEntries[i] );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntPushFirst( Vec_Int_t * p, int Entry )
+{
+    int i;
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_IntGrow( p, 16 );
+        else
+            Vec_IntGrow( p, 2 * p->nCap );
+    }
+    p->nSize++;
+    for ( i = p->nSize - 1; i >= 1; i-- )
+        p->pArray[i] = p->pArray[i-1];
+    p->pArray[0] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the entry while preserving the increasing order.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntPushOrder( Vec_Int_t * p, int Entry )
+{
+    int i;
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_IntGrow( p, 16 );
+        else
+            Vec_IntGrow( p, 2 * p->nCap );
+    }
+    p->nSize++;
+    for ( i = p->nSize-2; i >= 0; i-- )
+        if ( p->pArray[i] > Entry )
+            p->pArray[i+1] = p->pArray[i];
+        else
+            break;
+    p->pArray[i+1] = Entry;
+}
+static inline void Vec_IntPushOrderCost( Vec_Int_t * p, int Entry, Vec_Int_t * vCost )
+{
+    int i;
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_IntGrow( p, 16 );
+        else
+            Vec_IntGrow( p, 2 * p->nCap );
+    }
+    p->nSize++;
+    for ( i = p->nSize-2; i >= 0; i-- )
+        if ( Vec_IntEntry(vCost, p->pArray[i]) > Vec_IntEntry(vCost, Entry) )
+            p->pArray[i+1] = p->pArray[i];
+        else
+            break;
+    p->pArray[i+1] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the entry while preserving the increasing order.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntPushOrderReverse( Vec_Int_t * p, int Entry )
+{
+    int i;
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_IntGrow( p, 16 );
+        else
+            Vec_IntGrow( p, 2 * p->nCap );
+    }
+    p->nSize++;
+    for ( i = p->nSize-2; i >= 0; i-- )
+        if ( p->pArray[i] < Entry )
+            p->pArray[i+1] = p->pArray[i];
+        else
+            break;
+    p->pArray[i+1] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Inserts the entry while preserving the increasing order.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntPushUniqueOrder( Vec_Int_t * p, int Entry )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            return 1;
+    Vec_IntPushOrder( p, Entry );
+    return 0;
+}
+static inline int Vec_IntPushUniqueOrderCost( Vec_Int_t * p, int Entry, Vec_Int_t * vCost )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            return 1;
+    Vec_IntPushOrderCost( p, Entry, vCost );
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntPushUnique( Vec_Int_t * p, int Entry )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            return 1;
+    Vec_IntPush( p, Entry );
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the pointer to the next nWords entries in the vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline unsigned * Vec_IntFetch( Vec_Int_t * p, int nWords )
+{
+    if ( nWords == 0 )
+        return NULL;
+    assert( nWords > 0 );
+    p->nSize += nWords;
+    if ( p->nSize > p->nCap )
+    {
+//         Vec_IntGrow( p, 2 * p->nSize );
+        return NULL;
+    }
+    return ((unsigned *)p->pArray) + p->nSize - nWords;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the last entry and removes it from the list.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntPop( Vec_Int_t * p )
+{
+    assert( p->nSize > 0 );
+    return p->pArray[--p->nSize];
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Find entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntFind( Vec_Int_t * p, int Entry )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            return i;
+    return -1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntRemove( Vec_Int_t * p, int Entry )
+{
+    int i;
+    for ( i = 0; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            break;
+    if ( i == p->nSize )
+        return 0;
+    assert( i < p->nSize );
+    for ( i++; i < p->nSize; i++ )
+        p->pArray[i-1] = p->pArray[i];
+    p->nSize--;
+    return 1;
+}
+static inline int Vec_IntRemove1( Vec_Int_t * p, int Entry )
+{
+    int i;
+    for ( i = 1; i < p->nSize; i++ )
+        if ( p->pArray[i] == Entry )
+            break;
+    if ( i >= p->nSize )
+        return 0;
+    assert( i < p->nSize );
+    for ( i++; i < p->nSize; i++ )
+        p->pArray[i-1] = p->pArray[i];
+    p->nSize--;
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntDrop( Vec_Int_t * p, int i )
+{
+    int k;
+    assert( i >= 0 && i < Vec_IntSize(p) );
+    p->nSize--;
+    for ( k = i; k < p->nSize; k++ )
+        p->pArray[k] = p->pArray[k+1];
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Interts entry at the index iHere. Shifts other entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntInsert( Vec_Int_t * p, int iHere, int Entry )
+{
+    int i;
+    assert( iHere >= 0 && iHere <= p->nSize );
+    Vec_IntPush( p, 0 );
+    for ( i = p->nSize - 1; i > iHere; i-- )
+        p->pArray[i] = p->pArray[i-1];
+    p->pArray[i] = Entry;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Find entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntFindMax( Vec_Int_t * p )
+{
+    int i, Best;
+    if ( p->nSize == 0 )
+        return 0;
+    Best = p->pArray[0];
+    for ( i = 1; i < p->nSize; i++ )
+        if ( Best < p->pArray[i] )
+            Best = p->pArray[i];
+    return Best;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Find entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntFindMin( Vec_Int_t * p )
+{
+    int i, Best;
+    if ( p->nSize == 0 )
+        return 0;
+    Best = p->pArray[0];
+    for ( i = 1; i < p->nSize; i++ )
+        if ( Best > p->pArray[i] )
+            Best = p->pArray[i];
+    return Best;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Reverses the order of entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntReverseOrder( Vec_Int_t * p )
+{
+    int i, Temp;
+    for ( i = 0; i < p->nSize/2; i++ )
+    {
+        Temp = p->pArray[i];
+        p->pArray[i] = p->pArray[p->nSize-1-i];
+        p->pArray[p->nSize-1-i] = Temp;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Removes odd entries.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntRemoveOdd( Vec_Int_t * p )
+{
+    int i;
+    assert( (p->nSize & 1) == 0 );
+    p->nSize >>= 1;
+    for ( i = 0; i < p->nSize; i++ )
+        p->pArray[i] = p->pArray[2*i];
+}
+static inline void Vec_IntRemoveEven( Vec_Int_t * p )
+{
+    int i;
+    assert( (p->nSize & 1) == 0 );
+    p->nSize >>= 1;
+    for ( i = 0; i < p->nSize; i++ )
+        p->pArray[i] = p->pArray[2*i+1];
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntInvert( Vec_Int_t * p, int Fill ) 
+{
+    int Entry, i;
+    Vec_Int_t * vRes = Vec_IntAlloc( 0 );
+    if ( Vec_IntSize(p) == 0 )
+        return vRes;
+    Vec_IntFill( vRes, Vec_IntFindMax(p) + 1, Fill );
+    Vec_IntForEachEntry( p, Entry, i )
+        if ( Entry != Fill )
+            Vec_IntWriteEntry( vRes, Entry, i );
+    return vRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_IntCondense( Vec_Int_t * p, int Fill ) 
+{
+    int Entry, i;
+    Vec_Int_t * vRes = Vec_IntAlloc( Vec_IntSize(p) );
+    Vec_IntForEachEntry( p, Entry, i )
+        if ( Entry != Fill )
+            Vec_IntPush( vRes, Entry );
+    return vRes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntSum( Vec_Int_t * p ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += p->pArray[i];
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntCountEntry( Vec_Int_t * p, int Entry ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += (p->pArray[i] == Entry);
+    return Counter;
+}
+static inline int Vec_IntCountLarger( Vec_Int_t * p, int Entry ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += (p->pArray[i] > Entry);
+    return Counter;
+}
+static inline int Vec_IntCountSmaller( Vec_Int_t * p, int Entry ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += (p->pArray[i] < Entry);
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntCountPositive( Vec_Int_t * p ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += (p->pArray[i] > 0);
+    return Counter;
+}
+static inline int Vec_IntCountZero( Vec_Int_t * p ) 
+{
+    int i, Counter = 0;
+    for ( i = 0; i < p->nSize; i++ )
+        Counter += (p->pArray[i] == 0);
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Checks if two vectors are equal.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntEqual( Vec_Int_t * p1, Vec_Int_t * p2 ) 
+{
+    int i;
+    if ( p1->nSize != p2->nSize )
+        return 0;
+    for ( i = 0; i < p1->nSize; i++ )
+        if ( p1->pArray[i] != p2->pArray[i] )
+            return 0;
+    return 1;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Counts the number of common entries.]
+
+  Description [Assumes that the entries are non-negative integers that
+  are not very large, so inversion of the array can be performed.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntCountCommon( Vec_Int_t * p1, Vec_Int_t * p2 ) 
+{
+    Vec_Int_t * vTemp;
+    int Entry, i, Counter = 0;
+    if ( Vec_IntSize(p1) < Vec_IntSize(p2) )
+        vTemp = p1, p1 = p2, p2 = vTemp;
+    assert( Vec_IntSize(p1) >= Vec_IntSize(p2) );
+    vTemp = Vec_IntInvert( p2, -1 );
+    Vec_IntFillExtra( vTemp, Vec_IntFindMax(p1) + 1, -1 );
+    Vec_IntForEachEntry( p1, Entry, i )
+        if ( Vec_IntEntry(vTemp, Entry) >= 0 )
+            Counter++;
+    Vec_IntFree( vTemp );
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Comparison procedure for two integers.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Vec_IntSortCompare1( int * pp1, int * pp2 )
+{
+    // for some reason commenting out lines (as shown) led to crashing of the release version
+    if ( *pp1 < *pp2 )
+        return -1;
+    if ( *pp1 > *pp2 ) //
+        return 1;
+    return 0; //
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Comparison procedure for two integers.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Vec_IntSortCompare2( int * pp1, int * pp2 )
+{
+    // for some reason commenting out lines (as shown) led to crashing of the release version
+    if ( *pp1 > *pp2 )
+        return -1;
+    if ( *pp1 < *pp2 ) //
+        return 1;
+    return 0; //
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting the entries by their integer value.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntSort( Vec_Int_t * p, int fReverse )
+{
+    if ( fReverse ) 
+        qsort( (void *)p->pArray, p->nSize, sizeof(int), 
+                (int (*)(const void *, const void *)) Vec_IntSortCompare2 );
+    else
+        qsort( (void *)p->pArray, p->nSize, sizeof(int), 
+                (int (*)(const void *, const void *)) Vec_IntSortCompare1 );
+}
+static inline void Vec_IntSortMulti( Vec_Int_t * p, int nMulti, int fReverse )
+{
+    assert( Vec_IntSize(p) % nMulti == 0 );
+    if ( fReverse ) 
+        qsort( (void *)p->pArray, p->nSize/nMulti, nMulti*sizeof(int), 
+                (int (*)(const void *, const void *)) Vec_IntSortCompare2 );
+    else
+        qsort( (void *)p->pArray, p->nSize/nMulti, nMulti*sizeof(int), 
+                (int (*)(const void *, const void *)) Vec_IntSortCompare1 );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Leaves only unique entries.]
+
+  Description [Returns the number of duplicated entried found.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntUniqify( Vec_Int_t * p )
+{
+    int i, k, RetValue;
+    if ( p->nSize < 2 )
+        return 0;
+    Vec_IntSort( p, 0 );
+    for ( i = k = 1; i < p->nSize; i++ )
+        if ( p->pArray[i] != p->pArray[i-1] )
+            p->pArray[k++] = p->pArray[i];
+    RetValue = p->nSize - k;
+    p->nSize = k;
+    return RetValue;
+}
+static inline int Vec_IntCountDuplicates( Vec_Int_t * p )
+{
+    int RetValue;
+    Vec_Int_t * pDup = Vec_IntDup( p );
+    Vec_IntUniqify( pDup );
+    RetValue = Vec_IntSize(p) - Vec_IntSize(pDup);
+    Vec_IntFree( pDup );
+    return RetValue;
+}
+static inline int Vec_IntCheckUniqueSmall( Vec_Int_t * p )
+{
+    int i, k;
+    for ( i = 0; i < p->nSize; i++ )
+        for ( k = i+1; k < p->nSize; k++ )
+            if ( p->pArray[i] == p->pArray[k] )
+                return 0;
+    return 1;
+}
+static inline int Vec_IntCountUnique( Vec_Int_t * p )
+{
+    int i, Count = 0, Max = Vec_IntFindMax(p);
+    unsigned char * pPres = ABC_CALLOC( unsigned char, Max+1 );
+    for ( i = 0; i < p->nSize; i++ )
+        if ( pPres[p->pArray[i]] == 0 )
+            pPres[p->pArray[i]] = 1, Count++;
+    ABC_FREE( pPres );
+    return Count;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Counts the number of unique pairs.]
+
+  Description []
+               
+  SideEffects [] 
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntUniqifyPairs( Vec_Int_t * p )
+{
+    int i, k, RetValue;
+    assert( p->nSize % 2 == 0 );
+    if ( p->nSize < 4 )
+        return 0;
+    Vec_IntSortMulti( p, 2, 0 );
+    for ( i = k = 1; i < p->nSize/2; i++ )
+        if ( p->pArray[2*i] != p->pArray[2*(i-1)] || p->pArray[2*i+1] != p->pArray[2*(i-1)+1] )
+        {
+            p->pArray[2*k]   = p->pArray[2*i];
+            p->pArray[2*k+1] = p->pArray[2*i+1];
+            k++;
+        }
+    RetValue = p->nSize/2 - k;
+    p->nSize = 2*k;
+    return RetValue;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Counts the number of unique entries.]
+
+  Description []
+               
+  SideEffects [] 
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline unsigned Vec_IntUniqueHashKeyDebug( unsigned char * pStr, int nChars, int TableMask )
+{
+    static unsigned s_BigPrimes[4] = {12582917, 25165843, 50331653, 100663319};
+    unsigned Key = 0; int c;
+    for ( c = 0; c < nChars; c++ )
+    {
+        Key += (unsigned)pStr[c] * s_BigPrimes[c & 3];
+        printf( "%d : ", c );
+        printf( "%3d  ", pStr[c] );
+        printf( "%12u ", Key );
+        printf( "%12u ", Key&TableMask );
+        printf( "\n" );
+    }
+    return Key;
+}
+static inline void Vec_IntUniqueProfile( Vec_Int_t * vData, int * pTable, int * pNexts, int TableMask, int nIntSize )
+{
+    int i, Key, Counter;
+    for ( i = 0; i <= TableMask; i++ )
+    {
+        Counter = 0;
+        for ( Key = pTable[i]; Key != -1; Key = pNexts[Key] )
+            Counter++;
+        if ( Counter < 7 )
+            continue;
+        printf( "%d\n", Counter );
+        for ( Key = pTable[i]; Key != -1; Key = pNexts[Key] )
+        {
+//            Extra_PrintBinary( stdout, (unsigned *)Vec_IntEntryP(vData, Key*nIntSize), 40 ), printf( "\n" );
+//            Vec_IntUniqueHashKeyDebug( (unsigned char *)Vec_IntEntryP(vData, Key*nIntSize), 4*nIntSize, TableMask );
+        }
+    }
+    printf( "\n" );
+}
+
+static inline unsigned Vec_IntUniqueHashKey2( unsigned char * pStr, int nChars )
+{
+    static unsigned s_BigPrimes[4] = {12582917, 25165843, 50331653, 100663319};
+    unsigned Key = 0; int c;
+    for ( c = 0; c < nChars; c++ )
+        Key += (unsigned)pStr[c] * s_BigPrimes[c & 3];
+    return Key;
+}
+
+static inline unsigned Vec_IntUniqueHashKey( unsigned char * pStr, int nChars )
+{
+    static unsigned s_BigPrimes[16] = 
+    {
+        0x984b6ad9,0x18a6eed3,0x950353e2,0x6222f6eb,0xdfbedd47,0xef0f9023,0xac932a26,0x590eaf55,
+        0x97d0a034,0xdc36cd2e,0x22736b37,0xdc9066b0,0x2eb2f98b,0x5d9c7baf,0x85747c9e,0x8aca1055
+    };
+    static unsigned s_BigPrimes2[16] = 
+    {
+        0x8d8a5ebe,0x1e6a15dc,0x197d49db,0x5bab9c89,0x4b55dea7,0x55dede49,0x9a6a8080,0xe5e51035,
+        0xe148d658,0x8a17eb3b,0xe22e4b38,0xe5be2a9a,0xbe938cbb,0x3b981069,0x7f9c0c8e,0xf756df10
+    };
+    unsigned Key = 0; int c;
+    for ( c = 0; c < nChars; c++ )
+        Key += s_BigPrimes2[(2*c)&15]   * s_BigPrimes[(unsigned)pStr[c] & 15] +
+               s_BigPrimes2[(2*c+1)&15] * s_BigPrimes[(unsigned)pStr[c] >> 4];
+    return Key;
+}
+static inline int * Vec_IntUniqueLookup( Vec_Int_t * vData, int i, int nIntSize, int * pNexts, int * pStart )
+{
+    int * pData = Vec_IntEntryP( vData, i*nIntSize );
+    for ( ; *pStart != -1; pStart = pNexts + *pStart )
+        if ( !memcmp( pData, Vec_IntEntryP(vData, *pStart*nIntSize), sizeof(int) * nIntSize ) )
+            return pStart;
+    return pStart;
+}
+static inline int Vec_IntUniqueCount( Vec_Int_t * vData, int nIntSize, Vec_Int_t ** pvMap )
+{
+    int nEntries  = Vec_IntSize(vData) / nIntSize;
+    int TableMask = (1 << pabc::Abc_Base2Log(nEntries)) - 1;
+    int * pTable  = ABC_FALLOC( int, TableMask+1 );
+    int * pNexts  = ABC_FALLOC( int, TableMask+1 );
+    int * pClass  = ABC_ALLOC( int, nEntries );
+    int i, Key, * pEnt, nUnique = 0;
+    assert( nEntries * nIntSize == Vec_IntSize(vData) );
+    for ( i = 0; i < nEntries; i++ )
+    {
+        pEnt = Vec_IntEntryP( vData, i*nIntSize );
+        Key  = TableMask & Vec_IntUniqueHashKey( (unsigned char *)pEnt, 4*nIntSize );
+        pEnt = Vec_IntUniqueLookup( vData, i, nIntSize, pNexts, pTable+Key );
+        if ( *pEnt == -1 )
+            *pEnt = i, nUnique++;
+        pClass[i] = *pEnt;
+    }
+//    Vec_IntUniqueProfile( vData, pTable, pNexts, TableMask, nIntSize );
+    ABC_FREE( pTable );
+    ABC_FREE( pNexts );
+    if ( pvMap )
+        *pvMap = Vec_IntAllocArray( pClass, nEntries );
+    else
+        ABC_FREE( pClass );
+    return nUnique;
+}
+static inline Vec_Int_t * Vec_IntUniqifyHash( Vec_Int_t * vData, int nIntSize )
+{
+    Vec_Int_t * vMap, * vUnique;
+    int i, Ent, nUnique = Vec_IntUniqueCount( vData, nIntSize, &vMap );
+    vUnique = Vec_IntAlloc( nUnique * nIntSize );
+    Vec_IntForEachEntry( vMap, Ent, i )
+    {
+        if ( Ent < i ) continue;
+        assert( Ent == i );
+        Vec_IntPushArray( vUnique, Vec_IntEntryP(vData, i*nIntSize), nIntSize );
+    }
+    assert( Vec_IntSize(vUnique) == nUnique * nIntSize );
+    Vec_IntFree( vMap );
+    return vUnique;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Comparison procedure for two integers.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntSortCompareUnsigned( unsigned * pp1, unsigned * pp2 )
+{
+    if ( *pp1 < *pp2 )
+        return -1;
+    if ( *pp1 > *pp2 )
+        return 1;
+    return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting the entries by their integer value.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntSortUnsigned( Vec_Int_t * p )
+{
+    qsort( (void *)p->pArray, p->nSize, sizeof(int), 
+            (int (*)(const void *, const void *)) Vec_IntSortCompareUnsigned );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the number of common entries.]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntTwoCountCommon( Vec_Int_t * vArr1, Vec_Int_t * vArr2 )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    int Counter = 0;
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            pBeg1++, pBeg2++, Counter++;
+        else if ( *pBeg1 < *pBeg2 )
+            pBeg1++;
+        else 
+            pBeg2++;
+    }
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Collects common entries.]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntTwoFindCommon( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    Vec_IntClear( vArr );
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            Vec_IntPush( vArr, *pBeg1 ), pBeg1++, pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            pBeg1++;
+        else 
+            pBeg2++;
+    }
+    return Vec_IntSize(vArr);
+}
+static inline int Vec_IntTwoFindCommonReverse( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    Vec_IntClear( vArr );
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            Vec_IntPush( vArr, *pBeg1 ), pBeg1++, pBeg2++;
+        else if ( *pBeg1 > *pBeg2 )
+            pBeg1++;
+        else 
+            pBeg2++;
+    }
+    return Vec_IntSize(vArr);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Collects and removes common entries]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntTwoRemoveCommon( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    int * pBeg1New = vArr1->pArray;
+    int * pBeg2New = vArr2->pArray;
+    Vec_IntClear( vArr );
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            Vec_IntPush( vArr, *pBeg1 ), pBeg1++, pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            *pBeg1New++ = *pBeg1++;
+        else 
+            *pBeg2New++ = *pBeg2++;
+    }
+    while ( pBeg1 < pEnd1 )
+        *pBeg1New++ = *pBeg1++;
+    while ( pBeg2 < pEnd2 )
+        *pBeg2New++ = *pBeg2++;
+    Vec_IntShrink( vArr1, pBeg1New - vArr1->pArray );
+    Vec_IntShrink( vArr2, pBeg2New - vArr2->pArray );
+    return Vec_IntSize(vArr);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Removes entries of the second one from the first one.]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntTwoRemove( Vec_Int_t * vArr1, Vec_Int_t * vArr2 )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    int * pBeg1New = vArr1->pArray;
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            pBeg1++, pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            *pBeg1New++ = *pBeg1++;
+        else 
+            pBeg2++;
+    }
+    while ( pBeg1 < pEnd1 )
+        *pBeg1New++ = *pBeg1++;
+    Vec_IntShrink( vArr1, pBeg1New - vArr1->pArray );
+    return Vec_IntSize(vArr1);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the result of merging the two vectors.]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntTwoMerge2Int( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr )
+{
+    int * pBeg  = vArr->pArray;
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            *pBeg++ = *pBeg1++, pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            *pBeg++ = *pBeg1++;
+        else 
+            *pBeg++ = *pBeg2++;
+    }
+    while ( pBeg1 < pEnd1 )
+        *pBeg++ = *pBeg1++;
+    while ( pBeg2 < pEnd2 )
+        *pBeg++ = *pBeg2++;
+    vArr->nSize = pBeg - vArr->pArray;
+    assert( vArr->nSize <= vArr->nCap );
+    assert( vArr->nSize >= vArr1->nSize );
+    assert( vArr->nSize >= vArr2->nSize );
+}
+static inline Vec_Int_t * Vec_IntTwoMerge( Vec_Int_t * vArr1, Vec_Int_t * vArr2 )
+{
+    Vec_Int_t * vArr = Vec_IntAlloc( vArr1->nSize + vArr2->nSize ); 
+    Vec_IntTwoMerge2Int( vArr1, vArr2, vArr );
+    return vArr;
+}
+static inline void Vec_IntTwoMerge2( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr )
+{
+    Vec_IntGrow( vArr, Vec_IntSize(vArr1) + Vec_IntSize(vArr2) );
+    Vec_IntTwoMerge2Int( vArr1, vArr2, vArr );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns the result of splitting of the two vectors.]
+
+  Description [Assumes that the vectors are sorted in the increasing order.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntTwoSplit( Vec_Int_t * vArr1, Vec_Int_t * vArr2, Vec_Int_t * vArr, Vec_Int_t * vArr1n, Vec_Int_t * vArr2n )
+{
+    int * pBeg1 = vArr1->pArray;
+    int * pBeg2 = vArr2->pArray;
+    int * pEnd1 = vArr1->pArray + vArr1->nSize;
+    int * pEnd2 = vArr2->pArray + vArr2->nSize;
+    while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+    {
+        if ( *pBeg1 == *pBeg2 )
+            Vec_IntPush( vArr, *pBeg1++ ), pBeg2++;
+        else if ( *pBeg1 < *pBeg2 )
+            Vec_IntPush( vArr1n, *pBeg1++ );
+        else 
+            Vec_IntPush( vArr2n, *pBeg2++ );
+    }
+    while ( pBeg1 < pEnd1 )
+        Vec_IntPush( vArr1n, *pBeg1++ );
+    while ( pBeg2 < pEnd2 )
+        Vec_IntPush( vArr2n, *pBeg2++ );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntSelectSort( int * pArray, int nSize )
+{
+    int temp, i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( pArray[j] < pArray[best_i] )
+                best_i = j;
+        temp = pArray[i]; 
+        pArray[i] = pArray[best_i]; 
+        pArray[best_i] = temp;
+    }
+}
+static inline void Vec_IntSelectSortReverse( int * pArray, int nSize )
+{
+    int temp, i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( pArray[j] > pArray[best_i] )
+                best_i = j;
+        temp = pArray[i]; 
+        pArray[i] = pArray[best_i]; 
+        pArray[best_i] = temp;
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntSelectSortCost( int * pArray, int nSize, Vec_Int_t * vCosts )
+{
+    int i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( Vec_IntEntry(vCosts, pArray[j]) < Vec_IntEntry(vCosts, pArray[best_i]) )
+                best_i = j;
+        ABC_SWAP( int, pArray[i], pArray[best_i] );
+    }
+}
+static inline void Vec_IntSelectSortCostReverse( int * pArray, int nSize, Vec_Int_t * vCosts )
+{
+    int i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( Vec_IntEntry(vCosts, pArray[j]) > Vec_IntEntry(vCosts, pArray[best_i]) )
+                best_i = j;
+        ABC_SWAP( int, pArray[i], pArray[best_i] );
+    }
+}
+
+static inline void Vec_IntSelectSortCost2( int * pArray, int nSize, int * pCosts )
+{
+    int i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( pCosts[j] < pCosts[best_i] )
+                best_i = j;
+        ABC_SWAP( int, pArray[i], pArray[best_i] );
+        ABC_SWAP( int, pCosts[i], pCosts[best_i] );
+    }
+}
+static inline void Vec_IntSelectSortCost2Reverse( int * pArray, int nSize, int * pCosts )
+{
+    int i, j, best_i;
+    for ( i = 0; i < nSize-1; i++ )
+    {
+        best_i = i;
+        for ( j = i+1; j < nSize; j++ )
+            if ( pCosts[j] > pCosts[best_i] )
+                best_i = j;
+        ABC_SWAP( int, pArray[i], pArray[best_i] );
+        ABC_SWAP( int, pCosts[i], pCosts[best_i] );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntPrint( Vec_Int_t * vVec )
+{
+    int i, Entry;
+    printf( "Vector has %d entries: {", Vec_IntSize(vVec) );
+    Vec_IntForEachEntry( vVec, Entry, i )
+        printf( " %d", Entry );
+    printf( " }\n" );
+}
+static inline void Vec_IntPrintBinary( Vec_Int_t * vVec )
+{
+    int i, Entry;
+    Vec_IntForEachEntry( vVec, Entry, i )
+        printf( "%d", (int)(Entry != 0) );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_IntCompareVec( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( p1 == NULL || p2 == NULL )
+        return (p1 != NULL) - (p2 != NULL);
+    if ( Vec_IntSize(p1) != Vec_IntSize(p2) )
+        return Vec_IntSize(p1) - Vec_IntSize(p2);
+    return memcmp( Vec_IntArray(p1), Vec_IntArray(p2), sizeof(int)*Vec_IntSize(p1) );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Appends the contents of the second vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntAppend( Vec_Int_t * vVec1, Vec_Int_t * vVec2 )
+{
+    int Entry, i;
+    Vec_IntForEachEntry( vVec2, Entry, i )
+        Vec_IntPush( vVec1, Entry );
+}
+static inline void Vec_IntAppendSkip( Vec_Int_t * vVec1, Vec_Int_t * vVec2, int iVar )
+{
+    int Entry, i;
+    Vec_IntForEachEntry( vVec2, Entry, i )
+        if ( i != iVar )
+            Vec_IntPush( vVec1, Entry );
+}
+static inline void Vec_IntAppendMinus( Vec_Int_t * vVec1, Vec_Int_t * vVec2, int fMinus )
+{
+    int Entry, i;
+    Vec_IntClear( vVec1 );
+    Vec_IntForEachEntry( vVec2, Entry, i )
+        Vec_IntPush( vVec1, fMinus ? -Entry : Entry );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Remapping attributes after objects were duplicated.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_IntRemapArray( Vec_Int_t * vOld2New, Vec_Int_t * vOld, Vec_Int_t * vNew, int nNew )
+{
+    int iOld, iNew;
+    if ( Vec_IntSize(vOld) == 0 )
+        return;
+    Vec_IntFill( vNew, nNew, 0 );
+    Vec_IntForEachEntry( vOld2New, iNew, iOld )
+        if ( iNew > 0 && iNew < nNew && iOld < Vec_IntSize(vOld) && Vec_IntEntry(vOld, iOld) != 0 )
+            Vec_IntWriteEntry( vNew, iNew, Vec_IntEntry(vOld, iOld) );
+}
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
diff --git a/lib/bill/bill/sat/solver/abc/vecWec.h b/lib/bill/bill/sat/solver/abc/vecWec.h
new file mode 100644
index 0000000..badc653
--- /dev/null
+++ b/lib/bill/bill/sat/solver/abc/vecWec.h
@@ -0,0 +1,716 @@
+/**CFile****************************************************************
+
+  FileName    [vecWec.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Resizable arrays.]
+
+  Synopsis    [Resizable vector of resizable vectors.]
+
+  Author      [Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - June 20, 2005.]
+
+  Revision    [$Id: vecWec.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+ 
+#ifndef ABC__misc__vec__vecWec_h
+#define ABC__misc__vec__vecWec_h
+
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include <stdio.h>
+
+ABC_NAMESPACE_HEADER_START
+
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct Vec_Wec_t_       Vec_Wec_t;
+struct Vec_Wec_t_ 
+{
+    int              nCap;
+    int              nSize;
+    Vec_Int_t *      pArray;
+};
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+// iterators through levels 
+#define Vec_WecForEachLevel( vGlob, vVec, i )                                              \
+    for ( i = 0; (i < Vec_WecSize(vGlob)) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ )
+#define Vec_WecForEachLevelVec( vLevels, vGlob, vVec, i )                                  \
+    for ( i = 0; (i < Vec_IntSize(vLevels)) && (((vVec) = Vec_WecEntry(vGlob, Vec_IntEntry(vLevels, i))), 1); i++ )
+#define Vec_WecForEachLevelStart( vGlob, vVec, i, LevelStart )                             \
+    for ( i = LevelStart; (i < Vec_WecSize(vGlob)) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ )
+#define Vec_WecForEachLevelStop( vGlob, vVec, i, LevelStop )                               \
+    for ( i = 0; (i < LevelStop) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ )
+#define Vec_WecForEachLevelStartStop( vGlob, vVec, i, LevelStart, LevelStop )              \
+    for ( i = LevelStart; (i < LevelStop) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i++ )
+#define Vec_WecForEachLevelReverse( vGlob, vVec, i )                                       \
+    for ( i = Vec_WecSize(vGlob)-1; (i >= 0) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i-- )
+#define Vec_WecForEachLevelReverseStartStop( vGlob, vVec, i, LevelStart, LevelStop )       \
+    for ( i = LevelStart-1; (i >= LevelStop) && (((vVec) = Vec_WecEntry(vGlob, i)), 1); i-- )
+#define Vec_WecForEachLevelTwo( vGlob1, vGlob2, vVec1, vVec2, i )                          \
+    for ( i = 0; (i < Vec_WecSize(vGlob1)) && (((vVec1) = Vec_WecEntry(vGlob1, i)), 1) && (((vVec2) = Vec_WecEntry(vGlob2, i)), 1); i++ )
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates a vector with the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Wec_t * Vec_WecAlloc( int nCap )
+{
+    Vec_Wec_t * p;
+    p = ABC_ALLOC( Vec_Wec_t, 1 );
+    if ( nCap > 0 && nCap < 8 )
+        nCap = 8;
+    p->nSize  = 0;
+    p->nCap   = nCap;
+    p->pArray = p->nCap? ABC_CALLOC( Vec_Int_t, p->nCap ) : NULL;
+    return p;
+}
+static inline Vec_Wec_t * Vec_WecAllocExact( int nCap )
+{
+    Vec_Wec_t * p;
+    assert( nCap >= 0 );
+    p = ABC_ALLOC( Vec_Wec_t, 1 );
+    p->nSize  = 0;
+    p->nCap   = nCap;
+    p->pArray = p->nCap? ABC_CALLOC( Vec_Int_t, p->nCap ) : NULL;
+    return p;
+}
+static inline Vec_Wec_t * Vec_WecStart( int nSize )
+{
+    Vec_Wec_t * p;
+    p = Vec_WecAlloc( nSize );
+    p->nSize = nSize;
+    return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Resizes the vector to the given capacity.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecGrow( Vec_Wec_t * p, int nCapMin )
+{
+    if ( p->nCap >= nCapMin )
+        return;
+    p->pArray = ABC_REALLOC( Vec_Int_t, p->pArray, nCapMin ); 
+    memset( p->pArray + p->nCap, 0, sizeof(Vec_Int_t) * (nCapMin - p->nCap) );
+    p->nCap   = nCapMin;
+}
+static inline void Vec_WecInit( Vec_Wec_t * p, int nSize )
+{
+    Vec_WecGrow( p, nSize );
+    p->nSize = nSize;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_WecEntry( Vec_Wec_t * p, int i )
+{
+    assert( i >= 0 && i < p->nSize );
+    return p->pArray + i;
+}
+static inline Vec_Int_t * Vec_WecEntryLast( Vec_Wec_t * p )
+{
+    assert( p->nSize > 0 );
+    return p->pArray + p->nSize - 1;
+}
+static inline int Vec_WecEntryEntry( Vec_Wec_t * p, int i, int k )
+{
+    return Vec_IntEntry( Vec_WecEntry(p, i), k );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_WecArray( Vec_Wec_t * p )
+{
+    return p->pArray;
+}
+static inline int Vec_WecLevelId( Vec_Wec_t * p, Vec_Int_t * vLevel )
+{
+    assert( p->pArray <= vLevel && vLevel < p->pArray + p->nSize );
+    return vLevel - p->pArray;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_WecCap( Vec_Wec_t * p )
+{
+    return p->nCap;
+}
+static inline int Vec_WecSize( Vec_Wec_t * p )
+{
+    return p->nSize;
+}
+static inline int Vec_WecLevelSize( Vec_Wec_t * p, int i )
+{
+    assert( i >= 0 && i < p->nSize );
+    return Vec_IntSize( p->pArray + i );
+}
+static inline int Vec_WecSizeSize( Vec_Wec_t * p )
+{
+    Vec_Int_t * vVec;
+    int i, Counter = 0;
+    Vec_WecForEachLevel( p, vVec, i )
+        Counter += Vec_IntSize(vVec);
+    return Counter;
+}
+static inline int Vec_WecSizeUsed( Vec_Wec_t * p )
+{
+    Vec_Int_t * vVec;
+    int i, Counter = 0;
+    Vec_WecForEachLevel( p, vVec, i )
+        Counter += (int)(Vec_IntSize(vVec) > 0);
+    return Counter;
+}
+static inline int Vec_WecSizeUsedLimits( Vec_Wec_t * p, int iStart, int iStop )
+{
+    Vec_Int_t * vVec;
+    int i, Counter = 0;
+    Vec_WecForEachLevelStartStop( p, vVec, i, iStart, iStop )
+        Counter += (int)(Vec_IntSize(vVec) > 0);
+    return Counter;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecShrink( Vec_Wec_t * p, int nSizeNew )
+{
+    assert( p->nSize >= nSizeNew );
+    p->nSize = nSizeNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecClear( Vec_Wec_t * p )
+{
+    Vec_Int_t * vVec;
+    int i;
+    Vec_WecForEachLevel( p, vVec, i )
+        Vec_IntClear( vVec );
+    p->nSize = 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecPush( Vec_Wec_t * p, int Level, int Entry )
+{
+    if ( p->nSize < Level + 1 )
+    {
+        Vec_WecGrow( p, Abc_MaxInt(2*p->nSize, Level + 1) );
+        p->nSize = Level + 1;
+    }
+    Vec_IntPush( Vec_WecEntry(p, Level), Entry );
+}
+static inline Vec_Int_t * Vec_WecPushLevel( Vec_Wec_t * p )
+{
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_WecGrow( p, 16 );
+        else
+            Vec_WecGrow( p, 2 * p->nCap );
+    }
+    ++p->nSize;
+    return Vec_WecEntryLast( p );
+}
+static inline Vec_Int_t * Vec_WecInsertLevel( Vec_Wec_t * p, int i )
+{
+    Vec_Int_t * pTemp;
+    if ( p->nSize == p->nCap )
+    {
+        if ( p->nCap < 16 )
+            Vec_WecGrow( p, 16 );
+        else
+            Vec_WecGrow( p, 2 * p->nCap );
+    }
+    ++p->nSize;
+    assert( i >= 0 && i < p->nSize );
+    for ( pTemp = p->pArray + p->nSize - 2; pTemp >= p->pArray + i; pTemp-- )
+        pTemp[1] = pTemp[0];
+    Vec_IntZero( p->pArray + i );
+    return p->pArray + i;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline double Vec_WecMemory( Vec_Wec_t * p )
+{
+    int i;
+    double Mem;
+    if ( p == NULL )  return 0.0;
+    Mem = sizeof(Vec_Int_t) * Vec_WecCap(p);
+    for ( i = 0; i < p->nSize; i++ )
+        Mem += sizeof(int) * Vec_IntCap( Vec_WecEntry(p, i) );
+    return Mem;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Frees the vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecZero( Vec_Wec_t * p )
+{
+    p->pArray = NULL;
+    p->nSize = 0;
+    p->nCap = 0;
+}
+static inline void Vec_WecErase( Vec_Wec_t * p )
+{
+    int i;
+    for ( i = 0; i < p->nCap; i++ )
+        ABC_FREE( p->pArray[i].pArray );
+    ABC_FREE( p->pArray );
+    p->nSize = 0;
+    p->nCap = 0;
+}
+static inline void Vec_WecFree( Vec_Wec_t * p )
+{
+    Vec_WecErase( p );
+    ABC_FREE( p );
+}
+static inline void Vec_WecFreeP( Vec_Wec_t ** p )
+{
+    if ( *p == NULL )
+        return;
+    Vec_WecFree( *p );
+    *p = NULL;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecPushUnique( Vec_Wec_t * p, int Level, int Entry )
+{
+    if ( p->nSize < Level + 1 )
+        Vec_WecPush( p, Level, Entry );
+    else
+        Vec_IntPushUnique( Vec_WecEntry(p, Level), Entry );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Frees the vector.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Wec_t * Vec_WecDup( Vec_Wec_t * p )
+{
+    Vec_Wec_t * vNew;
+    Vec_Int_t * vVec;
+    int i, k, Entry;
+    vNew = Vec_WecAlloc( Vec_WecSize(p) );
+    Vec_WecForEachLevel( p, vVec, i )
+        Vec_IntForEachEntry( vVec, Entry, k )
+            Vec_WecPush( vNew, i, Entry );
+    return vNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting by array size.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Vec_WecSortCompare1( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntSize(p1) < Vec_IntSize(p2) )
+        return -1;
+    if ( Vec_IntSize(p1) > Vec_IntSize(p2) ) 
+        return 1;
+    return 0; 
+}
+static int Vec_WecSortCompare2( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntSize(p1) > Vec_IntSize(p2) )
+        return -1;
+    if ( Vec_IntSize(p1) < Vec_IntSize(p2) ) 
+        return 1;
+    return 0; 
+}
+static inline void Vec_WecSort( Vec_Wec_t * p, int fReverse )
+{
+    if ( fReverse ) 
+        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare2 );
+    else
+        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare1 );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting by the first entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Vec_WecSortCompare3( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntEntry(p1,0) < Vec_IntEntry(p2,0) )
+        return -1;
+    if ( Vec_IntEntry(p1,0) > Vec_IntEntry(p2,0) ) 
+        return 1;
+    return 0; 
+}
+static int Vec_WecSortCompare4( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntEntry(p1,0) > Vec_IntEntry(p2,0) )
+        return -1;
+    if ( Vec_IntEntry(p1,0) < Vec_IntEntry(p2,0) ) 
+        return 1;
+    return 0; 
+}
+static inline void Vec_WecSortByFirstInt( Vec_Wec_t * p, int fReverse )
+{
+    if ( fReverse ) 
+        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare4 );
+    else
+        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare3 );
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Sorting by the last entry.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Vec_WecSortCompare5( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntEntryLast(p1) < Vec_IntEntryLast(p2) )
+        return -1;
+    if ( Vec_IntEntryLast(p1) > Vec_IntEntryLast(p2) ) 
+        return 1;
+    return 0; 
+}
+static int Vec_WecSortCompare6( Vec_Int_t * p1, Vec_Int_t * p2 )
+{
+    if ( Vec_IntEntryLast(p1) > Vec_IntEntryLast(p2) )
+        return -1;
+    if ( Vec_IntEntryLast(p1) < Vec_IntEntryLast(p2) ) 
+        return 1;
+    return 0; 
+}
+static inline void Vec_WecSortByLastInt( Vec_Wec_t * p, int fReverse )
+{
+    if ( fReverse ) 
+        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare6 );
+    else
+        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+                (int (*)(const void *, const void *)) Vec_WecSortCompare5 );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+  
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecPrint( Vec_Wec_t * p, int fSkipSingles )
+{
+    Vec_Int_t * vVec;
+    int i, k, Entry;
+    Vec_WecForEachLevel( p, vVec, i )
+    {
+        if ( fSkipSingles && Vec_IntSize(vVec) == 1 )
+            continue;
+        printf( " %4d : {", i );
+        Vec_IntForEachEntry( vVec, Entry, k )
+            printf( " %d", Entry );
+        printf( " }\n" );
+    }
+}
+static inline void Vec_WecPrintLits( Vec_Wec_t * p )
+{
+    Vec_Int_t * vVec;
+    int i, k, iLit;
+    Vec_WecForEachLevel( p, vVec, i )
+    {
+        printf( " %4d : %2d  {", i, Vec_IntSize(vVec) );
+        Vec_IntForEachEntry( vVec, iLit, k )
+            printf( " %c%d", Abc_LitIsCompl(iLit) ? '-' : '+', Abc_Lit2Var(iLit) );
+        printf( " }\n" );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Derives the set of equivalence classes.]
+
+  Description []
+  
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Wec_t * Vec_WecCreateClasses( Vec_Int_t * vMap )
+{
+    Vec_Wec_t * vClasses;
+    int i, Entry;
+    vClasses = Vec_WecStart( Vec_IntFindMax(vMap) + 1 );
+    Vec_IntForEachEntry( vMap, Entry, i )
+        Vec_WecPush( vClasses, Entry, i );
+    return vClasses;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Vec_WecCountNonTrivial( Vec_Wec_t * p, int * pnUsed )
+{
+    Vec_Int_t * vClass;
+    int i, nClasses = 0;
+    *pnUsed = 0;
+    Vec_WecForEachLevel( p, vClass, i )
+    {
+        if ( Vec_IntSize(vClass) < 2 )
+            continue;
+        nClasses++;
+        (*pnUsed) += Vec_IntSize(vClass);
+    }
+    return nClasses;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Vec_Int_t * Vec_WecCollectFirsts( Vec_Wec_t * p )
+{
+    Vec_Int_t * vFirsts, * vLevel;
+    int i;
+    vFirsts = Vec_IntAlloc( Vec_WecSize(p) );
+    Vec_WecForEachLevel( p, vLevel, i )
+        if ( Vec_IntSize(vLevel) > 0 )
+            Vec_IntPush( vFirsts, Vec_IntEntry(vLevel, 0) );
+    return vFirsts;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Temporary vector marking.]
+
+  Description [The vector should be static when the marking is used.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int  Vec_WecIntHasMark( Vec_Int_t * vVec ) { return (vVec->nCap >> 30) & 1; }
+static inline void Vec_WecIntSetMark( Vec_Int_t * vVec ) { vVec->nCap |= (1<<30);         }
+static inline void Vec_WecIntXorMark( Vec_Int_t * vVec ) { vVec->nCap ^= (1<<30);         }
+static inline void Vec_WecMarkLevels( Vec_Wec_t * vCubes, Vec_Int_t * vLevels )
+{
+    Vec_Int_t * vCube;
+    int i;
+    Vec_WecForEachLevelVec( vLevels, vCubes, vCube, i )
+    {
+        assert( !Vec_WecIntHasMark( vCube ) );
+        Vec_WecIntXorMark( vCube );
+    }
+}
+static inline void Vec_WecUnmarkLevels( Vec_Wec_t * vCubes, Vec_Int_t * vLevels )
+{
+    Vec_Int_t * vCube;
+    int i;
+    Vec_WecForEachLevelVec( vLevels, vCubes, vCube, i )
+    {
+        assert( Vec_WecIntHasMark( vCube ) );
+        Vec_WecIntXorMark( vCube );
+    }
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Removes 0-size vectors.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Vec_WecRemoveEmpty( Vec_Wec_t * vCubes )
+{
+    Vec_Int_t * vCube;
+    int i, k = 0;
+    Vec_WecForEachLevel( vCubes, vCube, i )
+        if ( Vec_IntSize(vCube) > 0 )
+            vCubes->pArray[k++] = *vCube;
+        else
+            ABC_FREE( vCube->pArray );
+    for ( i = k; i < Vec_WecSize(vCubes); i++ )
+        Vec_IntZero( Vec_WecEntry(vCubes, i) );
+    Vec_WecShrink( vCubes, k );
+//    Vec_WecSortByFirstInt( vCubes, 0 );
+}
+
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
diff --git a/lib/bill/bill/sat/solver/ghack.hpp b/lib/bill/bill/sat/solver/ghack.hpp
new file mode 100644
index 0000000..44c9bc0
--- /dev/null
+++ b/lib/bill/bill/sat/solver/ghack.hpp
@@ -0,0 +1,5086 @@
+/**************************************************************************************[IntTypes.h]
+Copyright (c) 2009-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#pragma once
+
+#ifndef Ghack_IntTypes_h
+#define Ghack_IntTypes_h
+
+#ifdef __sun
+    // Not sure if there are newer versions that support C99 headers. The
+    // needed features are implemented in the headers below though:
+
+#   include <sys/int_types.h>
+#   include <sys/int_fmtio.h>
+#   include <sys/int_limits.h>
+
+#else
+
+#   include <stdint.h>
+#   include <inttypes.h>
+
+#endif
+
+#include <limits.h>
+
+#ifndef PRIu64
+#define PRIu64 "lu"
+#define PRIi64 "ld"
+#endif
+//=================================================================================================
+
+#endif
+/****************************************************************************************[XAlloc.h]
+Copyright (c) 2009-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Ghack_XAlloc_h
+#define Ghack_XAlloc_h
+
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+namespace GHack {
+
+//=================================================================================================
+// Simple layer on top of malloc/realloc to catch out-of-memory situtaions and provide some typing:
+
+class OutOfMemoryException{};
+static inline void* xrealloc(void *ptr, size_t size)
+{
+    void* mem = realloc(ptr, size);
+    if (mem == NULL && errno == ENOMEM){
+        throw OutOfMemoryException();
+    }else {
+        return mem;
+	}
+}
+
+//=================================================================================================
+}
+
+#endif
+/*******************************************************************************************[Vec.h]
+Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Ghack_Vec_h
+#define Ghack_Vec_h
+
+#include <assert.h>
+#include <new>
+
+
+
+
+namespace GHack {
+
+//=================================================================================================
+// Automatically resizable arrays
+//
+// NOTE! Don't use this vector on datatypes that cannot be re-located in memory (with realloc)
+
+template<class T>
+class vec {
+    T*  data;
+    int sz;
+    int cap;
+
+    // Don't allow copying (error prone):
+    vec<T>&  operator = (vec<T>& other) { assert(0); return *this; }
+             vec        (vec<T>& other) { assert(0); }
+             
+    // Helpers for calculating next capacity:
+    static inline int  imax   (int x, int y) { int mask = (y-x) >> (sizeof(int)*8-1); return (x&mask) + (y&(~mask)); }
+    //static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; }
+    static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; }
+
+public:
+    // Constructors:
+    vec()                       : data(NULL) , sz(0)   , cap(0)    { }
+    explicit vec(int size)      : data(NULL) , sz(0)   , cap(0)    { growTo(size); }
+    vec(int size, const T& pad) : data(NULL) , sz(0)   , cap(0)    { growTo(size, pad); }
+   ~vec()                                                          { clear(true); }
+
+    // Pointer to first element:
+    operator T*       (void)           { return data; }
+
+    // Size operations:
+    int      size     (void) const     { return sz; }
+    void     shrink   (int nelems)     { assert(nelems <= sz); for (int i = 0; i < nelems; i++) sz--, data[sz].~T(); }
+    void     shrink_  (int nelems)     { assert(nelems <= sz); sz -= nelems; }
+    int      capacity (void) const     { return cap; }
+    void     capacity (int min_cap);
+    void     growTo   (int size);
+    void     growTo   (int size, const T& pad);
+    void     clear    (bool dealloc = false);
+
+    // Stack interface:
+    void     push  (void)              { if (sz == cap) capacity(sz+1); new (&data[sz]) T(); sz++; }
+    void     push  (const T& elem)     { if (sz == cap) capacity(sz+1); data[sz++] = elem; }
+    void     push_ (const T& elem)     { assert(sz < cap); data[sz++] = elem; }
+    void     pop   (void)              { assert(sz > 0); sz--, data[sz].~T(); }
+    // NOTE: it seems possible that overflow can happen in the 'sz+1' expression of 'push()', but
+    // in fact it can not since it requires that 'cap' is equal to INT_MAX. This in turn can not
+    // happen given the way capacities are calculated (below). Essentially, all capacities are
+    // even, but INT_MAX is odd.
+
+    const T& last  (void) const        { return data[sz-1]; }
+    T&       last  (void)              { return data[sz-1]; }
+
+    // Vector interface:
+    const T& operator [] (int index) const { return data[index]; }
+    T&       operator [] (int index)       { return data[index]; }
+
+    // Duplicatation (preferred instead):
+    void copyTo(vec<T>& copy) const { copy.clear(); copy.growTo(sz); for (int i = 0; i < sz; i++) copy[i] = data[i]; }
+    void moveTo(vec<T>& dest) { dest.clear(true); dest.data = data; dest.sz = sz; dest.cap = cap; data = NULL; sz = 0; cap = 0; }
+};
+
+
+template<class T>
+void vec<T>::capacity(int min_cap) {
+    if (cap >= min_cap) return;
+    int add = imax((min_cap - cap + 1) & ~1, ((cap >> 1) + 2) & ~1);   // NOTE: grow by approximately 3/2
+    if (add > INT_MAX - cap || (((data = (T*)::realloc(data, (cap += add) * sizeof(T))) == NULL) && errno == ENOMEM))
+        throw OutOfMemoryException();
+ }
+
+
+template<class T>
+void vec<T>::growTo(int size, const T& pad) {
+    if (sz >= size) return;
+    capacity(size);
+    for (int i = sz; i < size; i++) data[i] = pad;
+    sz = size; }
+
+
+template<class T>
+void vec<T>::growTo(int size) {
+    if (sz >= size) return;
+    capacity(size);
+    for (int i = sz; i < size; i++) new (&data[i]) T();
+    sz = size; }
+
+
+template<class T>
+void vec<T>::clear(bool dealloc) {
+    if (data != NULL){
+        for (int i = 0; i < sz; i++) data[i].~T();
+        sz = 0;
+        if (dealloc) free(data), data = NULL, cap = 0; } }
+
+//=================================================================================================
+}
+
+#endif
+/*******************************************************************************************[Alg.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Ghack_Alg_h
+#define Ghack_Alg_h
+
+
+
+namespace GHack {
+
+//=================================================================================================
+// Useful functions on vector-like types:
+
+//=================================================================================================
+// Removing and searching for elements:
+//
+
+template<class V, class T>
+static inline void remove(V& ts, const T& t)
+{
+    int j = 0;
+    for (; j < ts.size() && ts[j] != t; j++);
+    assert(j < ts.size());
+    for (; j < ts.size()-1; j++) ts[j] = ts[j+1];
+    ts.pop();
+}
+
+
+template<class V, class T>
+static inline bool find(V& ts, const T& t)
+{
+    int j = 0;
+    for (; j < ts.size() && ts[j] != t; j++);
+    return j < ts.size();
+}
+
+
+//=================================================================================================
+// Copying vectors with support for nested vector types:
+//
+
+// Base case:
+template<class T>
+static inline void copy(const T& from, T& to)
+{
+    to = from;
+}
+
+// Recursive case:
+template<class T>
+static inline void copy(const vec<T>& from, vec<T>& to, bool append = false)
+{
+    if (!append)
+        to.clear();
+    for (int i = 0; i < from.size(); i++){
+        to.push();
+        copy(from[i], to.last());
+    }
+}
+
+template<class T>
+static inline void append(const vec<T>& from, vec<T>& to){ copy(from, to, true); }
+
+//=================================================================================================
+}
+
+#endif
+/*****************************************************************************************[Alloc.h]
+Copyright (c) 2008-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Ghack_Alloc_h
+#define Ghack_Alloc_h
+
+
+
+
+namespace GHack {
+
+//=================================================================================================
+// Simple Region-based memory allocator:
+
+template<class T>
+class RegionAllocator
+{
+    T*        memory;
+    uint32_t  sz;
+    uint32_t  cap;
+    uint32_t  wasted_;
+
+    void capacity(uint32_t min_cap);
+
+ public:
+    // TODO: make this a class for better type-checking?
+    typedef uint32_t Ref;
+    enum { Ref_Undef = UINT32_MAX };
+    enum { Unit_Size = sizeof(uint32_t) };
+
+    explicit RegionAllocator(uint32_t start_cap = 1024*1024) : memory(NULL), sz(0), cap(0), wasted_(0){ capacity(start_cap); }
+    ~RegionAllocator()
+    {
+        if (memory != NULL)
+            ::free(memory);
+    }
+
+
+    uint32_t size      () const      { return sz; }
+    uint32_t wasted    () const      { return wasted_; }
+
+    Ref      alloc     (int size); 
+    void     free      (int size)    { wasted_ += size; }
+
+    // Deref, Load Effective Address (LEA), Inverse of LEA (AEL):
+    T&       operator[](Ref r)       { assert(r >= 0 && r < sz); return memory[r]; }
+    const T& operator[](Ref r) const { assert(r >= 0 && r < sz); return memory[r]; }
+
+    T*       lea       (Ref r)       { assert(r >= 0 && r < sz); return &memory[r]; }
+    const T* lea       (Ref r) const { assert(r >= 0 && r < sz); return &memory[r]; }
+    Ref      ael       (const T* t)  { assert((void*)t >= (void*)&memory[0] && (void*)t < (void*)&memory[sz-1]);
+        return  (Ref)(t - &memory[0]); }
+
+    void     moveTo(RegionAllocator& to) {
+        if (to.memory != NULL) ::free(to.memory);
+        to.memory = memory;
+        to.sz = sz;
+        to.cap = cap;
+        to.wasted_ = wasted_;
+
+        memory = NULL;
+        sz = cap = wasted_ = 0;
+    }
+
+
+};
+
+template<class T>
+void RegionAllocator<T>::capacity(uint32_t min_cap)
+{
+    if (cap >= min_cap) return;
+
+    uint32_t prev_cap = cap;
+    while (cap < min_cap){
+        // NOTE: Multiply by a factor (13/8) without causing overflow, then add 2 and make the
+        // result even by clearing the least significant bit. The resulting sequence of capacities
+        // is carefully chosen to hit a maximum capacity that is close to the '2^32-1' limit when
+        // using 'uint32_t' as indices so that as much as possible of this space can be used.
+        uint32_t delta = ((cap >> 1) + (cap >> 3) + 2) & ~1;
+        cap += delta;
+
+        if (cap <= prev_cap)
+            throw OutOfMemoryException();
+    }
+    //printf(" .. (%p) cap = %u\n", this, cap);
+
+    assert(cap > 0);
+    memory = (T*)xrealloc(memory, sizeof(T)*cap);
+}
+
+
+template<class T>
+typename RegionAllocator<T>::Ref
+RegionAllocator<T>::alloc(int size)
+{ 
+    //printf("ALLOC called (this = %p, size = %d)\n", this, size); fflush(stdout);
+    assert(size > 0);
+    capacity(sz + size);
+
+    uint32_t prev_sz = sz;
+    sz += size;
+    
+    // Handle overflow:
+    if (sz < prev_sz)
+        throw OutOfMemoryException();
+
+    return prev_sz;
+}
+
+
+//=================================================================================================
+}
+
+#endif
+/******************************************************************************************[Heap.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Ghack_Heap_h
+#define Ghack_Heap_h
+
+
+
+namespace GHack {
+
+//=================================================================================================
+// A heap implementation with support for decrease/increase key.
+
+
+template<class Comp>
+class Heap {
+    Comp     lt;       // The heap is a minimum-heap with respect to this comparator
+    vec<int> heap;     // Heap of integers
+    vec<int> indices;  // Each integers position (index) in the Heap
+
+    // Index "traversal" functions
+    static inline int left  (int i) { return i*2+1; }
+    static inline int right (int i) { return (i+1)*2; }
+    static inline int parent(int i) { return (i-1) >> 1; }
+
+
+    void percolateUp(int i)
+    {
+        int x  = heap[i];
+        int p  = parent(i);
+        
+        while (i != 0 && lt(x, heap[p])){
+            heap[i]          = heap[p];
+            indices[heap[p]] = i;
+            i                = p;
+            p                = parent(p);
+        }
+        heap   [i] = x;
+        indices[x] = i;
+    }
+
+
+    void percolateDown(int i)
+    {
+        int x = heap[i];
+        while (left(i) < heap.size()){
+            int child = right(i) < heap.size() && lt(heap[right(i)], heap[left(i)]) ? right(i) : left(i);
+            if (!lt(heap[child], x)) break;
+            heap[i]          = heap[child];
+            indices[heap[i]] = i;
+            i                = child;
+        }
+        heap   [i] = x;
+        indices[x] = i;
+    }
+
+
+  public:
+    Heap(const Comp& c) : lt(c) { }
+
+    int  size      ()          const { return heap.size(); }
+    bool empty     ()          const { return heap.size() == 0; }
+    bool inHeap    (int n)     const { return n < indices.size() && indices[n] >= 0; }
+    int  operator[](int index) const { assert(index < heap.size()); return heap[index]; }
+
+
+    void decrease  (int n) { assert(inHeap(n)); percolateUp  (indices[n]); }
+    void increase  (int n) { assert(inHeap(n)); percolateDown(indices[n]); }
+
+
+    // Safe variant of insert/decrease/increase:
+    void update(int n)
+    {
+        if (!inHeap(n))
+            insert(n);
+        else {
+            percolateUp(indices[n]);
+            percolateDown(indices[n]); }
+    }
+
+
+    void insert(int n)
+    {
+        indices.growTo(n+1, -1);
+        assert(!inHeap(n));
+
+        indices[n] = heap.size();
+        heap.push(n);
+        percolateUp(indices[n]); 
+    }
+
+
+    int  removeMin()
+    {
+        int x            = heap[0];
+        heap[0]          = heap.last();
+        indices[heap[0]] = 0;
+        indices[x]       = -1;
+        heap.pop();
+        if (heap.size() > 1) percolateDown(0);
+        return x; 
+    }
+
+
+    // Rebuild the heap from scratch, using the elements in 'ns':
+    void build(vec<int>& ns) {
+        for (int i = 0; i < heap.size(); i++)
+            indices[heap[i]] = -1;
+        heap.clear();
+
+        for (int i = 0; i < ns.size(); i++){
+            indices[ns[i]] = i;
+            heap.push(ns[i]); }
+
+        for (int i = heap.size() / 2 - 1; i >= 0; i--)
+            percolateDown(i);
+    }
+
+    void clear(bool dealloc = false) 
+    { 
+        for (int i = 0; i < heap.size(); i++)
+            indices[heap[i]] = -1;
+        heap.clear(dealloc); 
+    }
+};
+
+
+//=================================================================================================
+}
+
+#endif
+/*******************************************************************************************[Map.h]
+Copyright (c) 2006-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Ghack_Map_h
+#define Ghack_Map_h
+
+
+
+
+namespace GHack {
+
+//=================================================================================================
+// Default hash/equals functions
+//
+
+template<class K> struct Hash  { uint32_t operator()(const K& k)               const { return hash(k);  } };
+template<class K> struct Equal { bool     operator()(const K& k1, const K& k2) const { return k1 == k2; } };
+
+template<class K> struct DeepHash  { uint32_t operator()(const K* k)               const { return hash(*k);  } };
+template<class K> struct DeepEqual { bool     operator()(const K* k1, const K* k2) const { return *k1 == *k2; } };
+
+static inline uint32_t hash(uint32_t x){ return x; }
+static inline uint32_t hash(uint64_t x){ return (uint32_t)x; }
+static inline uint32_t hash(int32_t x) { return (uint32_t)x; }
+static inline uint32_t hash(int64_t x) { return (uint32_t)x; }
+
+
+//=================================================================================================
+// Some primes
+//
+
+static const int nprimes          = 25;
+static const int primes [nprimes] = { 31, 73, 151, 313, 643, 1291, 2593, 5233, 10501, 21013, 42073, 84181, 168451, 337219, 674701, 1349473, 2699299, 5398891, 10798093, 21596719, 43193641, 86387383, 172775299, 345550609, 691101253 };
+
+//=================================================================================================
+// Hash table implementation of Maps
+//
+
+template<class K, class D, class H = Hash<K>, class E = Equal<K> >
+class Map {
+ public:
+    struct Pair { K key; D data; };
+
+ private:
+    H          hash;
+    E          equals;
+
+    vec<Pair>* table;
+    int        cap;
+    int        size;
+
+    // Don't allow copying (error prone):
+    Map<K,D,H,E>&  operator = (Map<K,D,H,E>& other) { assert(0); }
+                   Map        (Map<K,D,H,E>& other) { assert(0); }
+
+    bool    checkCap(int new_size) const { return new_size > cap; }
+
+    int32_t index  (const K& k) const { return hash(k) % cap; }
+    void   _insert (const K& k, const D& d) { 
+        vec<Pair>& ps = table[index(k)];
+        ps.push(); ps.last().key = k; ps.last().data = d; }
+
+    void    rehash () {
+        const vec<Pair>* old = table;
+
+        int old_cap = cap;
+        int newsize = primes[0];
+        for (int i = 1; newsize <= cap && i < nprimes; i++)
+           newsize = primes[i];
+
+        table = new vec<Pair>[newsize];
+        cap   = newsize;
+
+        for (int i = 0; i < old_cap; i++){
+            for (int j = 0; j < old[i].size(); j++){
+                _insert(old[i][j].key, old[i][j].data); }}
+
+        delete [] old;
+
+        // printf(" --- rehashing, old-cap=%d, new-cap=%d\n", cap, newsize);
+    }
+
+    
+ public:
+
+    Map () : table(NULL), cap(0), size(0) {}
+    Map (const H& h, const E& e) : hash(h), equals(e), table(NULL), cap(0), size(0){}
+    ~Map () { delete [] table; }
+
+    // PRECONDITION: the key must already exist in the map.
+    const D& operator [] (const K& k) const
+    {
+        assert(size != 0);
+        const D*         res = NULL;
+        const vec<Pair>& ps  = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k))
+                res = &ps[i].data;
+        assert(res != NULL);
+        return *res;
+    }
+
+    // PRECONDITION: the key must already exist in the map.
+    D& operator [] (const K& k)
+    {
+        assert(size != 0);
+        D*         res = NULL;
+        vec<Pair>& ps  = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k))
+                res = &ps[i].data;
+        assert(res != NULL);
+        return *res;
+    }
+
+    // PRECONDITION: the key must *NOT* exist in the map.
+    void insert (const K& k, const D& d) { if (checkCap(size+1)) rehash(); _insert(k, d); size++; }
+    bool peek   (const K& k, D& d) const {
+        if (size == 0) return false;
+        const vec<Pair>& ps = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k)){
+                d = ps[i].data;
+                return true; } 
+        return false;
+    }
+
+    bool has   (const K& k) const {
+        if (size == 0) return false;
+        const vec<Pair>& ps = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k))
+                return true;
+        return false;
+    }
+
+    // PRECONDITION: the key must exist in the map.
+    void remove(const K& k) {
+        assert(table != NULL);
+        vec<Pair>& ps = table[index(k)];
+        int j = 0;
+        for (; j < ps.size() && !equals(ps[j].key, k); j++);
+        assert(j < ps.size());
+        ps[j] = ps.last();
+        ps.pop();
+        size--;
+    }
+
+    void clear  () {
+        cap = size = 0;
+        delete [] table;
+        table = NULL;
+    }
+
+    int  elems() const { return size; }
+    int  bucket_count() const { return cap; }
+
+    // NOTE: the hash and equality objects are not moved by this method:
+    void moveTo(Map& other){
+        delete [] other.table;
+
+        other.table = table;
+        other.cap   = cap;
+        other.size  = size;
+
+        table = NULL;
+        size = cap = 0;
+    }
+
+    // NOTE: given a bit more time, I could make a more C++-style iterator out of this:
+    const vec<Pair>& bucket(int i) const { return table[i]; }
+};
+
+//=================================================================================================
+}
+
+#endif
+/*****************************************************************************************[Queue.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Ghack_Queue_h
+#define Ghack_Queue_h
+
+
+
+namespace GHack {
+
+//=================================================================================================
+
+template<class T>
+class Queue {
+    vec<T>  buf;
+    int     first;
+    int     end;
+
+public:
+    typedef T Key;
+
+    Queue() : buf(1), first(0), end(0) {}
+
+    void clear (bool dealloc = false) { buf.clear(dealloc); buf.growTo(1); first = end = 0; }
+    int  size  () const { return (end >= first) ? end - first : end - first + buf.size(); }
+
+    const T& operator [] (int index) const  { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; }
+    T&       operator [] (int index)        { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; }
+
+    T    peek  () const { assert(first != end); return buf[first]; }
+    void pop   () { assert(first != end); first++; if (first == buf.size()) first = 0; }
+    void insert(T elem) {   // INVARIANT: buf[end] is always unused
+        buf[end++] = elem;
+        if (end == buf.size()) end = 0;
+        if (first == end){  // Resize:
+            vec<T>  tmp((buf.size()*3 + 1) >> 1);
+            //**/printf("queue alloc: %d elems (%.1f MB)\n", tmp.size(), tmp.size() * sizeof(T) / 1000000.0);
+            int     i = 0;
+            for (int j = first; j < buf.size(); j++) tmp[i++] = buf[j];
+            for (int j = 0    ; j < end       ; j++) tmp[i++] = buf[j];
+            first = 0;
+            end   = buf.size();
+            tmp.moveTo(buf);
+        }
+    }
+};
+
+
+//=================================================================================================
+}
+
+#endif
+/******************************************************************************************[Sort.h]
+Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Ghack_Sort_h
+#define Ghack_Sort_h
+
+
+
+//=================================================================================================
+// Some sorting algorithms for vec's
+
+
+namespace GHack {
+
+template<class T>
+struct LessThan_default {
+    bool operator () (T x, T y) { return x < y; }
+};
+
+
+template <class T, class LessThan>
+void selectionSort(T* array, int size, LessThan lt)
+{
+    int     i, j, best_i;
+    T       tmp;
+
+    for (i = 0; i < size-1; i++){
+        best_i = i;
+        for (j = i+1; j < size; j++){
+            if (lt(array[j], array[best_i]))
+                best_i = j;
+        }
+        tmp = array[i]; array[i] = array[best_i]; array[best_i] = tmp;
+    }
+}
+template <class T> static inline void selectionSort(T* array, int size) {
+    selectionSort(array, size, LessThan_default<T>()); }
+
+template <class T, class LessThan>
+void sort(T* array, int size, LessThan lt)
+{
+    if (size <= 15)
+        selectionSort(array, size, lt);
+
+    else{
+        T           pivot = array[size / 2];
+        T           tmp;
+        int         i = -1;
+        int         j = size;
+
+        for(;;){
+            do i++; while(lt(array[i], pivot));
+            do j--; while(lt(pivot, array[j]));
+
+            if (i >= j) break;
+
+            tmp = array[i]; array[i] = array[j]; array[j] = tmp;
+        }
+
+        sort(array    , i     , lt);
+        sort(&array[i], size-i, lt);
+    }
+}
+template <class T> static inline void sort(T* array, int size) {
+    sort(array, size, LessThan_default<T>()); }
+
+
+//=================================================================================================
+// For 'vec's:
+
+
+template <class T, class LessThan> void sort(vec<T>& v, LessThan lt) {
+    sort((T*)v, v.size(), lt); }
+template <class T> void sort(vec<T>& v) {
+    sort(v, LessThan_default<T>()); }
+
+
+//=================================================================================================
+}
+
+#endif
+/************************************************************************************[ParseUtils.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Ghack_ParseUtils_h
+#define Ghack_ParseUtils_h
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+
+namespace GHack {
+
+//-------------------------------------------------------------------------------------------------
+// End-of-file detection functions for StreamBuffer and char*:
+static inline bool isEof(const char*   in) { return *in == '\0'; }
+
+//-------------------------------------------------------------------------------------------------
+// Generic parse functions parametrized over the input-stream type.
+
+
+template<class B>
+static void skipWhitespace(B& in) {
+    while ((*in >= 9 && *in <= 13) || *in == 32)
+        ++in; }
+
+
+template<class B>
+static void skipLine(B& in) {
+    for (;;){
+        if (isEof(in)) return;
+        if (*in == '\n') { ++in; return; }
+        ++in; } }
+
+template<class B>
+static double parseDouble(B& in) { // only in the form X.XXXXXe-XX
+    bool    neg= false;
+	double accu = 0.0;
+	double currentExponent = 1;
+	int exponent;
+	
+    skipWhitespace(in);
+    if(*in == EOF) return 0;
+    if      (*in == '-') neg = true, ++in;
+    else if (*in == '+') ++in;
+    if (*in < '1' || *in > '9') printf("PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
+	accu = (double)(*in - '0');
+	++in;
+	if (*in != '.') printf("PARSE ERROR! Unexpected char: %c\n", *in),exit(3);
+	++in; // skip dot
+	currentExponent = 0.1;
+    while (*in >= '0' && *in <= '9')
+        accu = accu + currentExponent * ((double)(*in - '0')),
+		currentExponent /= 10,
+        ++in;
+	if (*in != 'e') printf("PARSE ERROR! Unexpected char: %c\n", *in),exit(3);
+	++in; // skip dot
+	exponent = parseInt(in); // read exponent
+	accu *= pow(10,exponent);
+	return neg ? -accu:accu;
+}
+
+template<class B>
+static int parseInt(B& in) {
+    int     val = 0;
+    bool    neg = false;
+    skipWhitespace(in);
+    if      (*in == '-') neg = true, ++in;
+    else if (*in == '+') ++in;
+    if (*in < '0' || *in > '9') fprintf(stderr, "PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
+    while (*in >= '0' && *in <= '9')
+        val = val*10 + (*in - '0'),
+        ++in;
+    return neg ? -val : val; }
+
+
+// String matching: in case of a match the input iterator will be advanced the corresponding
+// number of characters.
+template<class B>
+static bool match(B& in, const char* str) {
+    int i;
+    for (i = 0; str[i] != '\0'; i++)
+        if (in[i] != str[i])
+            return false;
+
+    in += i;
+
+    return true; 
+}
+
+// String matching: consumes characters eagerly, but does not require random access iterator.
+template<class B>
+static bool eagerMatch(B& in, const char* str) {
+    for (; *str != '\0'; ++str, ++in)
+        if (*str != *in)
+            return false;
+    return true; }
+
+
+//=================================================================================================
+}
+
+#endif
+/***************************************************************************************[Options.h]
+Copyright (c) 2008-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Ghack_Options_h
+#define Ghack_Options_h
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+
+
+
+
+
+namespace GHack {
+
+//==================================================================================================
+// Top-level option parse/help functions:
+
+
+extern void parseOptions     (int& argc, char** argv, bool strict = false);
+extern void printUsageAndExit(int  argc, char** argv, bool verbose = false);
+extern void setUsageHelp     (const char* str);
+extern void setHelpPrefixStr (const char* str);
+
+
+//==================================================================================================
+// Options is an abstract class that gives the interface for all types options:
+
+
+class Option
+{
+ protected:
+    const char* name;
+    const char* description;
+    const char* category;
+    const char* type_name;
+
+    static vec<Option*>& getOptionList () { static vec<Option*> options; return options; }
+    static const char*&  getUsageString() { static const char* usage_str; return usage_str; }
+    static const char*&  getHelpPrefixString() { static const char* help_prefix_str = ""; return help_prefix_str; }
+
+    struct OptionLt {
+        bool operator()(const Option* x, const Option* y) {
+            int test1 = strcmp(x->category, y->category);
+            return test1 < 0 || (test1 == 0 && strcmp(x->type_name, y->type_name) < 0);
+        }
+    };
+
+    Option(const char* name_, 
+           const char* desc_,
+           const char* cate_,
+           const char* type_) : 
+      name       (name_)
+    , description(desc_)
+    , category   (cate_)
+    , type_name  (type_)
+    { 
+        getOptionList().push(this); 
+    }
+
+ public:
+    virtual ~Option() {}
+
+    virtual bool parse             (const char* str)      = 0;
+    virtual void help              (bool verbose = false) = 0;
+
+    friend  void parseOptions      (int& argc, char** argv, bool strict);
+    friend  void printUsageAndExit (int  argc, char** argv, bool verbose);
+    friend  void setUsageHelp      (const char* str);
+    friend  void setHelpPrefixStr  (const char* str);
+};
+
+
+//==================================================================================================
+// Range classes with specialization for floating types:
+
+
+struct IntRange {
+    int begin;
+    int end;
+    IntRange(int b, int e) : begin(b), end(e) {}
+};
+
+struct Int64Range {
+    int64_t begin;
+    int64_t end;
+    Int64Range(int64_t b, int64_t e) : begin(b), end(e) {}
+};
+
+struct DoubleRange {
+    double begin;
+    double end;
+    bool  begin_inclusive;
+    bool  end_inclusive;
+    DoubleRange(double b, bool binc, double e, bool einc) : begin(b), end(e), begin_inclusive(binc), end_inclusive(einc) {}
+};
+
+
+//==================================================================================================
+// Double options:
+
+
+class DoubleOption : public Option
+{
+ protected:
+    DoubleRange range;
+    double      value;
+
+ public:
+    DoubleOption(const char* c, const char* n, const char* d, double def = double(), DoubleRange r = DoubleRange(-HUGE_VAL, false, HUGE_VAL, false))
+        : Option(n, d, c, "<double>"), range(r), value(def) {
+        // FIXME: set LC_NUMERIC to "C" to make sure that strtof/strtod parses decimal point correctly.
+    }
+
+    operator      double   (void) const { return value; }
+    operator      double&  (void)       { return value; }
+    DoubleOption& operator=(double x)   { value = x; return *this; }
+
+    virtual bool parse(const char* str){
+        const char* span = str; 
+
+        if (!match(span, "-") || !match(span, name) || !match(span, "="))
+            return false;
+
+        char*  end;
+        double tmp = strtod(span, &end);
+
+        if (end == NULL) 
+            return false;
+        else if (tmp >= range.end && (!range.end_inclusive || tmp != range.end)){
+            fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name);
+            exit(1);
+        }else if (tmp <= range.begin && (!range.begin_inclusive || tmp != range.begin)){
+            fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name);
+            exit(1); }
+
+        value = tmp;
+        // fprintf(stderr, "READ VALUE: %g\n", value);
+
+        return true;
+    }
+
+    virtual void help (bool verbose = false){
+        fprintf(stderr, "  -%-12s = %-8s %c%4.2g .. %4.2g%c (default: %g)\n", 
+                name, type_name, 
+                range.begin_inclusive ? '[' : '(', 
+                range.begin,
+                range.end,
+                range.end_inclusive ? ']' : ')', 
+                value);
+        if (verbose){
+            fprintf(stderr, "\n        %s\n", description);
+            fprintf(stderr, "\n");
+        }
+    }
+};
+
+
+//==================================================================================================
+// Int options:
+
+
+class IntOption : public Option
+{
+ protected:
+    IntRange range;
+    int32_t  value;
+
+ public:
+    IntOption(const char* c, const char* n, const char* d, int32_t def = int32_t(), IntRange r = IntRange(INT32_MIN, INT32_MAX))
+        : Option(n, d, c, "<int32>"), range(r), value(def) {}
+ 
+    operator   int32_t   (void) const { return value; }
+    operator   int32_t&  (void)       { return value; }
+    IntOption& operator= (int32_t x)  { value = x; return *this; }
+
+    virtual bool parse(const char* str){
+        const char* span = str; 
+
+        if (!match(span, "-") || !match(span, name) || !match(span, "="))
+            return false;
+
+        char*   end;
+        int32_t tmp = strtol(span, &end, 10);
+
+        if (end == NULL) 
+            return false;
+        else if (tmp > range.end){
+            fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name);
+            exit(1);
+        }else if (tmp < range.begin){
+            fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name);
+            exit(1); }
+
+        value = tmp;
+
+        return true;
+    }
+
+    virtual void help (bool verbose = false){
+        fprintf(stderr, "  -%-12s = %-8s [", name, type_name);
+        if (range.begin == INT32_MIN)
+            fprintf(stderr, "imin");
+        else
+            fprintf(stderr, "%4d", range.begin);
+
+        fprintf(stderr, " .. ");
+        if (range.end == INT32_MAX)
+            fprintf(stderr, "imax");
+        else
+            fprintf(stderr, "%4d", range.end);
+
+        fprintf(stderr, "] (default: %d)\n", value);
+        if (verbose){
+            fprintf(stderr, "\n        %s\n", description);
+            fprintf(stderr, "\n");
+        }
+    }
+};
+
+
+// Leave this out for visual C++ until Microsoft implements C99 and gets support for strtoll.
+#ifndef _MSC_VER
+
+class Int64Option : public Option
+{
+ protected:
+    Int64Range range;
+    int64_t  value;
+
+ public:
+    Int64Option(const char* c, const char* n, const char* d, int64_t def = int64_t(), Int64Range r = Int64Range(INT64_MIN, INT64_MAX))
+        : Option(n, d, c, "<int64>"), range(r), value(def) {}
+ 
+    operator     int64_t   (void) const { return value; }
+    operator     int64_t&  (void)       { return value; }
+    Int64Option& operator= (int64_t x)  { value = x; return *this; }
+
+    virtual bool parse(const char* str){
+        const char* span = str; 
+
+        if (!match(span, "-") || !match(span, name) || !match(span, "="))
+            return false;
+
+        char*   end;
+        int64_t tmp = strtoll(span, &end, 10);
+
+        if (end == NULL) 
+            return false;
+        else if (tmp > range.end){
+            fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name);
+            exit(1);
+        }else if (tmp < range.begin){
+            fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name);
+            exit(1); }
+
+        value = tmp;
+
+        return true;
+    }
+
+    virtual void help (bool verbose = false){
+        fprintf(stderr, "  -%-12s = %-8s [", name, type_name);
+        if (range.begin == INT64_MIN)
+            fprintf(stderr, "imin");
+        else
+            fprintf(stderr, "%4" PRIi64, range.begin);
+
+        fprintf(stderr, " .. ");
+        if (range.end == INT64_MAX)
+            fprintf(stderr, "imax");
+        else
+            fprintf(stderr, "%4" PRIi64, range.end);
+
+        fprintf(stderr, "] (default: %" PRIi64")\n", value);
+        if (verbose){
+            fprintf(stderr, "\n        %s\n", description);
+            fprintf(stderr, "\n");
+        }
+    }
+};
+#endif
+
+//==================================================================================================
+// String option:
+
+
+class StringOption : public Option
+{
+    const char* value;
+ public:
+    StringOption(const char* c, const char* n, const char* d, const char* def = NULL) 
+        : Option(n, d, c, "<string>"), value(def) {}
+
+    operator      const char*  (void) const     { return value; }
+    operator      const char*& (void)           { return value; }
+    StringOption& operator=    (const char* x)  { value = x; return *this; }
+
+    virtual bool parse(const char* str){
+        const char* span = str; 
+
+        if (!match(span, "-") || !match(span, name) || !match(span, "="))
+            return false;
+
+        value = span;
+        return true;
+    }
+
+    virtual void help (bool verbose = false){
+        fprintf(stderr, "  -%-10s = %8s\n", name, type_name);
+        if (verbose){
+            fprintf(stderr, "\n        %s\n", description);
+            fprintf(stderr, "\n");
+        }
+    }    
+};
+
+
+//==================================================================================================
+// Bool option:
+
+
+class BoolOption : public Option
+{
+    bool value;
+
+ public:
+    BoolOption(const char* c, const char* n, const char* d, bool v) 
+        : Option(n, d, c, "<bool>"), value(v) {}
+
+    operator    bool     (void) const { return value; }
+    operator    bool&    (void)       { return value; }
+    BoolOption& operator=(bool b)     { value = b; return *this; }
+
+    virtual bool parse(const char* str){
+        const char* span = str; 
+        
+        if (match(span, "-")){
+            bool b = !match(span, "no-");
+
+            if (strcmp(span, name) == 0){
+                value = b;
+                return true; }
+        }
+
+        return false;
+    }
+
+    virtual void help (bool verbose = false){
+
+        fprintf(stderr, "  -%s, -no-%s", name, name);
+
+        for (uint32_t i = 0; i < 32 - strlen(name)*2; i++)
+            fprintf(stderr, " ");
+
+        fprintf(stderr, " ");
+        fprintf(stderr, "(default: %s)\n", value ? "on" : "off");
+        if (verbose){
+            fprintf(stderr, "\n        %s\n", description);
+            fprintf(stderr, "\n");
+        }
+    }
+};
+
+//=================================================================================================
+}
+
+#endif
+/****************************************************************************************[System.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Ghack_System_h
+#define Ghack_System_h
+
+
+
+//-------------------------------------------------------------------------------------------------
+
+namespace GHack {
+
+static inline double cpuTime(void); // CPU-time in seconds.
+extern double memUsed();            // Memory in mega bytes (returns 0 for unsupported architectures).
+extern double memUsedPeak();        // Peak-memory in mega bytes (returns 0 for unsupported architectures).
+
+}
+
+//-------------------------------------------------------------------------------------------------
+// Implementation of inline functions:
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#include <time.h>
+
+static inline double GHack::cpuTime(void) { return (double)clock() / CLOCKS_PER_SEC; }
+
+#else
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <unistd.h>
+
+static inline double GHack::cpuTime(void) {
+    struct rusage ru;
+    getrusage(RUSAGE_SELF, &ru);
+    return (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec / 1000000; }
+
+#endif
+
+#endif
+/***********************************************************************************[SolverTypes.h]
+ Glucose -- Copyright (c) 2009, Gilles Audemard, Laurent Simon
+				CRIL - Univ. Artois, France
+				LRI  - Univ. Paris Sud, France
+ 
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose are exactly the same as Minisat on which it is based on. (see below).
+
+---------------
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Ghack_SolverTypes_h
+#define Ghack_SolverTypes_h
+
+#include <assert.h>
+
+
+
+
+
+
+
+namespace GHack {
+
+//=================================================================================================
+// Variables, literals, lifted booleans, clauses:
+
+
+// NOTE! Variables are just integers. No abstraction here. They should be chosen from 0..N,
+// so that they can be used as array indices.
+
+typedef int Var;
+#define var_Undef (-1)
+
+
+struct Lit {
+    int     x;
+
+    // Use this as a constructor:
+    friend Lit mkLit(Var var, bool sign);
+
+    bool operator == (Lit p) const { return x == p.x; }
+    bool operator != (Lit p) const { return x != p.x; }
+    bool operator <  (Lit p) const { return x < p.x;  } // '<' makes p, ~p adjacent in the ordering.
+};
+
+
+inline  Lit  mkLit     (Var var, bool sign = false) { Lit p; p.x = var + var + (int)sign; return p; }
+inline  Lit  operator ~(Lit p)              { Lit q; q.x = p.x ^ 1; return q; }
+inline  Lit  operator ^(Lit p, bool b)      { Lit q; q.x = p.x ^ (unsigned int)b; return q; }
+inline  bool sign      (Lit p)              { return p.x & 1; }
+inline  int  var       (Lit p)              { return p.x >> 1; }
+
+// Mapping Literals to and from compact integers suitable for array indexing:
+inline  int  toInt     (Var v)              { return v; } 
+inline  int  toInt     (Lit p)              { return p.x; } 
+inline  Lit  toLit     (int i)              { Lit p; p.x = i; return p; } 
+
+//const Lit lit_Undef = mkLit(var_Undef, false);  // }- Useful special constants.
+//const Lit lit_Error = mkLit(var_Undef, true );  // }
+
+const Lit lit_Undef = { -2 };  // }- Useful special constants.
+const Lit lit_Error = { -1 };  // }
+
+
+//=================================================================================================
+// Lifted booleans:
+//
+// NOTE: this implementation is optimized for the case when comparisons between values are mostly
+//       between one variable and one constant. Some care had to be taken to make sure that gcc 
+//       does enough constant propagation to produce sensible code, and this appears to be somewhat
+//       fragile unfortunately.
+
+class lbool {
+    uint8_t value;
+
+public:
+    constexpr explicit lbool(uint8_t v) : value(v) { }
+
+    lbool()       : value(0) { }
+    explicit lbool(bool x) : value(!x) { }
+
+    bool  operator == (lbool b) const { return ((b.value&2) & (value&2)) | (!(b.value&2)&(value == b.value)); }
+    bool  operator != (lbool b) const { return !(*this == b); }
+    lbool operator ^  (bool  b) const { return lbool((uint8_t)(value^(uint8_t)b)); }
+
+    lbool operator && (lbool b) const { 
+        uint8_t sel = (this->value << 1) | (b.value << 3);
+        uint8_t v   = (0xF7F755F4 >> sel) & 3;
+        return lbool(v); }
+
+    lbool operator || (lbool b) const {
+        uint8_t sel = (this->value << 1) | (b.value << 3);
+        uint8_t v   = (0xFCFCF400 >> sel) & 3;
+        return lbool(v); }
+
+    friend int   toInt  (lbool l);
+    friend lbool toLbool(int   v);
+};
+inline int   toInt  (lbool l) { return l.value; }
+inline lbool toLbool(int   v) { return lbool((uint8_t)v);  }
+
+constexpr auto l_True = GHack::lbool((uint8_t)0);
+constexpr auto l_False = GHack::lbool((uint8_t)1);
+constexpr auto l_Undef = GHack::lbool((uint8_t)2);
+
+//=================================================================================================
+// Clause -- a simple class for representing a clause:
+
+struct Clause;
+typedef RegionAllocator<uint32_t>::Ref CRef;
+
+struct Clause {
+    int t;
+    struct {
+      unsigned mark      : 2;
+      unsigned learnt    : 1;
+      unsigned has_extra : 1;
+      unsigned reloced   : 1;
+      unsigned lbd       : 26;
+      unsigned canbedel  : 1;
+      unsigned size      : 32;
+      unsigned szWithoutSelectors : 32;
+
+    }                            header;
+    union { Lit lit; float act; uint32_t abs; CRef rel; } data[0];
+
+    friend class ClauseAllocator;
+
+    // NOTE: This constructor cannot be used directly (doesn't allocate enough memory).
+    template<class V>
+    Clause(const V& ps, bool use_extra, bool learnt) {
+        header.mark      = t = 0;
+        header.learnt    = learnt;
+        header.has_extra = use_extra;
+        header.reloced   = 0;
+        header.size      = ps.size();
+	header.lbd = 0;
+	header.canbedel = 1;
+        for (int i = 0; i < ps.size(); i++) 
+            data[i].lit = ps[i];
+	
+        if (header.has_extra){
+	  if (header.learnt) 
+                data[header.size].act = 0; 
+            else 
+                calcAbstraction(); }
+    }
+
+public:
+    void calcAbstraction() {
+        assert(header.has_extra);
+        uint32_t abstraction = 0;
+        for (int i = 0; i < size(); i++)
+            abstraction |= 1 << (var(data[i].lit) & 31);
+        data[header.size].abs = abstraction;  }
+
+
+    int          size        ()      const   { return header.size; }
+    void         shrink      (int i)         { assert(i <= size()); if (header.has_extra) data[header.size-i] = data[header.size]; header.size -= i; }
+    void         pop         ()              { shrink(1); }
+    bool         learnt      ()      const   { return header.learnt; }
+    bool         has_extra   ()      const   { return header.has_extra; }
+    uint32_t     mark        ()      const   { return header.mark; }
+    void         mark        (uint32_t m)    { header.mark = m; }
+    const Lit&   last        ()      const   { return data[header.size-1].lit; }
+
+    bool         reloced     ()      const   { return header.reloced; }
+    CRef         relocation  ()      const   { return data[0].rel; }
+    void         relocate    (CRef c)        { header.reloced = 1; data[0].rel = c; }
+
+    // NOTE: somewhat unsafe to change the clause in-place! Must manually call 'calcAbstraction' afterwards for
+    //       subsumption operations to behave correctly.
+    Lit&         operator [] (int i)         { return data[i].lit; }
+    Lit          operator [] (int i) const   { return data[i].lit; }
+    operator const Lit* (void) const         { return (Lit*)data; }
+
+    float&       activity    ()              { assert(header.has_extra); return data[header.size].act; }
+    uint32_t     abstraction () const        { assert(header.has_extra); return data[header.size].abs; }
+
+    Lit          subsumes    (const Clause& other) const;
+    void         strengthen  (Lit p);
+    void         setLBD(int i)  {header.lbd = i;} 
+    // unsigned int&       lbd    ()              { return header.lbd; }
+    unsigned int        lbd    () const        { return header.lbd; }
+    void setCanBeDel(bool b) {header.canbedel = b;}
+    bool canBeDel() {return header.canbedel;}
+    void setSizeWithoutSelectors   (unsigned int n)              {header.szWithoutSelectors = n; }
+    unsigned int        sizeWithoutSelectors   () const        { return header.szWithoutSelectors; }
+
+};
+
+
+//=================================================================================================
+// ClauseAllocator -- a simple class for allocating memory for clauses:
+
+
+const CRef CRef_Undef = RegionAllocator<uint32_t>::Ref_Undef;
+class ClauseAllocator : public RegionAllocator<uint32_t>
+{
+    static int clauseWord32Size(int size, bool has_extra){
+        return (sizeof(Clause) + (sizeof(Lit) * (size + (int)has_extra))) / sizeof(uint32_t); }
+ public:
+    bool extra_clause_field;
+
+    ClauseAllocator(uint32_t start_cap) : RegionAllocator<uint32_t>(start_cap), extra_clause_field(false){}
+    ClauseAllocator() : extra_clause_field(false){}
+
+    void moveTo(ClauseAllocator& to){
+        to.extra_clause_field = extra_clause_field;
+        RegionAllocator<uint32_t>::moveTo(to); }
+
+    template<class Lits>
+    CRef alloc(const Lits& ps, bool learnt = false)
+    {
+        assert(sizeof(Lit)      == sizeof(uint32_t));
+        assert(sizeof(float)    == sizeof(uint32_t));
+        bool use_extra = learnt | extra_clause_field;
+
+        CRef cid = RegionAllocator<uint32_t>::alloc(clauseWord32Size(ps.size(), use_extra));
+        new (lea(cid)) Clause(ps, use_extra, learnt);
+
+        return cid;
+    }
+
+    // Deref, Load Effective Address (LEA), Inverse of LEA (AEL):
+    Clause&       operator[](Ref r)       { return (Clause&)RegionAllocator<uint32_t>::operator[](r); }
+    const Clause& operator[](Ref r) const { return (Clause&)RegionAllocator<uint32_t>::operator[](r); }
+    Clause*       lea       (Ref r)       { return (Clause*)RegionAllocator<uint32_t>::lea(r); }
+    const Clause* lea       (Ref r) const { return (Clause*)RegionAllocator<uint32_t>::lea(r); }
+    Ref           ael       (const Clause* t){ return RegionAllocator<uint32_t>::ael((uint32_t*)t); }
+
+    void free(CRef cid)
+    {
+        Clause& c = operator[](cid);
+        RegionAllocator<uint32_t>::free(clauseWord32Size(c.size(), c.has_extra()));
+    }
+
+    void reloc(CRef& cr, ClauseAllocator& to)
+    {
+        Clause& c = operator[](cr);
+        
+        if (c.reloced()) { cr = c.relocation(); return; }
+        
+        cr = to.alloc(c, c.learnt());
+        c.relocate(cr);
+        
+        // Copy extra data-fields: 
+        // (This could be cleaned-up. Generalize Clause-constructor to be applicable here instead?)
+        to[cr].mark(c.mark());
+        if (to[cr].learnt())        {
+          to[cr].t = c.t;
+	  to[cr].activity() = c.activity();
+	  to[cr].setLBD(c.lbd());
+	  to[cr].setSizeWithoutSelectors(c.sizeWithoutSelectors());
+	  to[cr].setCanBeDel(c.canBeDel());
+	}
+        else if (to[cr].has_extra()) to[cr].calcAbstraction();
+    }
+};
+
+
+//=================================================================================================
+// OccLists -- a class for maintaining occurence lists with lazy deletion:
+
+template<class Idx, class Vec, class Deleted>
+class OccLists
+{
+    vec<Vec>  occs;
+    vec<char> dirty;
+    vec<Idx>  dirties;
+    Deleted   deleted;
+
+ public:
+    OccLists(const Deleted& d) : deleted(d) {}
+    
+    void  init      (const Idx& idx){ occs.growTo(toInt(idx)+1); dirty.growTo(toInt(idx)+1, 0); }
+    // Vec&  operator[](const Idx& idx){ return occs[toInt(idx)]; }
+    Vec&  operator[](const Idx& idx){ return occs[toInt(idx)]; }
+    Vec&  lookup    (const Idx& idx){ if (dirty[toInt(idx)]) clean(idx); return occs[toInt(idx)]; }
+
+    void  cleanAll  ();
+    void  clean     (const Idx& idx);
+    void  smudge    (const Idx& idx){
+        if (dirty[toInt(idx)] == 0){
+            dirty[toInt(idx)] = 1;
+            dirties.push(idx);
+        }
+    }
+
+    void  clear(bool free = true){
+        occs   .clear(free);
+        dirty  .clear(free);
+        dirties.clear(free);
+    }
+};
+
+
+template<class Idx, class Vec, class Deleted>
+void OccLists<Idx,Vec,Deleted>::cleanAll()
+{
+    for (int i = 0; i < dirties.size(); i++)
+        // Dirties may contain duplicates so check here if a variable is already cleaned:
+        if (dirty[toInt(dirties[i])])
+            clean(dirties[i]);
+    dirties.clear();
+}
+
+
+template<class Idx, class Vec, class Deleted>
+void OccLists<Idx,Vec,Deleted>::clean(const Idx& idx)
+{
+    Vec& vec = occs[toInt(idx)];
+    int  i, j;
+    for (i = j = 0; i < vec.size(); i++)
+        if (!deleted(vec[i]))
+            vec[j++] = vec[i];
+    vec.shrink(i - j);
+    dirty[toInt(idx)] = 0;
+}
+
+
+//=================================================================================================
+// CMap -- a class for mapping clauses to values:
+
+
+template<class T>
+class CMap
+{
+    struct CRefHash {
+        uint32_t operator()(CRef cr) const { return (uint32_t)cr; } };
+
+    typedef Map<CRef, T, CRefHash> HashTable;
+    HashTable map;
+        
+ public:
+    // Size-operations:
+    void     clear       ()                           { map.clear(); }
+    int      size        ()                const      { return map.elems(); }
+
+    
+    // Insert/Remove/Test mapping:
+    void     insert      (CRef cr, const T& t){ map.insert(cr, t); }
+    void     growTo      (CRef cr, const T& t){ map.insert(cr, t); } // NOTE: for compatibility
+    void     remove      (CRef cr)            { map.remove(cr); }
+    bool     has         (CRef cr, T& t)      { return map.peek(cr, t); }
+
+    // Vector interface (the clause 'c' must already exist):
+    const T& operator [] (CRef cr) const      { return map[cr]; }
+    T&       operator [] (CRef cr)            { return map[cr]; }
+
+    // Iteration (not transparent at all at the moment):
+    int  bucket_count() const { return map.bucket_count(); }
+    const vec<typename HashTable::Pair>& bucket(int i) const { return map.bucket(i); }
+
+    // Move contents to other map:
+    void moveTo(CMap& other){ map.moveTo(other.map); }
+
+    // TMP debug:
+    void debug(){
+        printf(" --- size = %d, bucket_count = %d\n", size(), map.bucket_count()); }
+};
+
+
+/*_________________________________________________________________________________________________
+|
+|  subsumes : (other : const Clause&)  ->  Lit
+|  
+|  Description:
+|       Checks if clause subsumes 'other', and at the same time, if it can be used to simplify 'other'
+|       by subsumption resolution.
+|  
+|    Result:
+|       lit_Error  - No subsumption or simplification
+|       lit_Undef  - Clause subsumes 'other'
+|       p          - The literal p can be deleted from 'other'
+|________________________________________________________________________________________________@*/
+inline Lit Clause::subsumes(const Clause& other) const
+{
+    //if (other.size() < size() || (extra.abst & ~other.extra.abst) != 0)
+    //if (other.size() < size() || (!learnt() && !other.learnt() && (extra.abst & ~other.extra.abst) != 0))
+    assert(!header.learnt);   assert(!other.header.learnt);
+    assert(header.has_extra); assert(other.header.has_extra);
+    if (other.header.size < header.size || (data[header.size].abs & ~other.data[other.header.size].abs) != 0)
+        return lit_Error;
+
+    Lit        ret = lit_Undef;
+    const Lit* c   = (const Lit*)(*this);
+    const Lit* d   = (const Lit*)other;
+
+    for (unsigned i = 0; i < header.size; i++) {
+        // search for c[i] or ~c[i]
+        for (unsigned j = 0; j < other.header.size; j++)
+            if (c[i] == d[j])
+                goto ok;
+            else if (ret == lit_Undef && c[i] == ~d[j]){
+                ret = c[i];
+                goto ok;
+            }
+
+        // did not find it
+        return lit_Error;
+    ok:;
+    }
+
+    return ret;
+}
+
+inline void Clause::strengthen(Lit p)
+{
+    remove(*this, p);
+    calcAbstraction();
+}
+ 
+//=================================================================================================
+}
+
+ 
+#endif
+/***********************************************************************************[BoundedQueue.h]
+ Glucose -- Copyright (c) 2009, Gilles Audemard, Laurent Simon
+                CRIL - Univ. Artois, France
+                LRI  - Univ. Paris Sud, France
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef BoundedQueue_h
+#define BoundedQueue_h
+
+
+
+//=================================================================================================
+
+namespace GHack {
+
+template <class T>
+class bqueue {
+    vec<T>  elems;
+    int     first;
+	int		last;
+	unsigned long long sumofqueue;
+	int     maxsize;
+	int     queuesize; // Number of current elements (must be < maxsize !)
+	bool expComputed;
+	double exp,value;
+public:
+ bqueue(void) : first(0), last(0), sumofqueue(0), maxsize(0), queuesize(0),expComputed(false) { } 
+	
+	void initSize(int size) {growTo(size);exp = 2.0/(size+1);} // Init size of bounded size queue
+	
+	void push(T x) {
+	  expComputed = false;
+		if (queuesize==maxsize) {
+			assert(last==first); // The queue is full, next value to enter will replace oldest one
+			sumofqueue -= elems[last];
+			if ((++last) == maxsize) last = 0;
+		} else 
+			queuesize++;
+		sumofqueue += x;
+		elems[first] = x;
+		if ((++first) == maxsize) {first = 0;last = 0;}
+	}
+
+	T peek() { assert(queuesize>0); return elems[last]; }
+	void pop() {sumofqueue-=elems[last]; queuesize--; if ((++last) == maxsize) last = 0;}
+	
+	unsigned long long getsum() const {return sumofqueue;}
+	unsigned int getavg() const {return (unsigned int)(sumofqueue/((unsigned long long)queuesize));}
+	int maxSize() const {return maxsize;}
+	double getavgDouble() const {
+	  double tmp = 0;
+	  for(int i=0;i<elems.size();i++) {
+	    tmp+=elems[i];
+	  }
+	  return tmp/elems.size();
+	}
+	int isvalid() const {return (queuesize==maxsize);}
+	
+	void growTo(int size) {
+		elems.growTo(size); 
+		first=0; maxsize=size; queuesize = 0;last = 0;
+		for(int i=0;i<size;i++) elems[i]=0; 
+	}
+	
+	double getAvgExp() {
+	  if(expComputed) return value;
+	  double a=exp;
+	  value = elems[first];
+	  for(int i  = first;i<maxsize;i++) {
+	    value+=a*((double)elems[i]);
+	    a=a*exp;
+	  }
+	  for(int i  = 0;i<last;i++) {
+	    value+=a*((double)elems[i]);
+	    a=a*exp;
+	  }
+	  value = value*(1-exp)/(1-a);
+	  expComputed = true;
+	  return value;
+	  
+
+	}
+	void fastclear() {first = 0; last = 0; queuesize=0; sumofqueue=0;} // to be called after restarts... Discard the queue
+	
+    int  size(void)    { return queuesize; }
+
+    void clear(bool dealloc = false)   { elems.clear(dealloc); first = 0; maxsize=0; queuesize=0;sumofqueue=0;}
+
+
+};
+}
+//=================================================================================================
+
+#endif
+/************************************************************************************[Constants.h]
+ Glucose -- Copyright (c) 2009, Gilles Audemard, Laurent Simon
+                CRIL - Univ. Artois, France
+                LRI  - Univ. Paris Sud, France
+  
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#define DYNAMICNBLEVEL
+#define CONSTANTREMOVECLAUSE
+#define UPDATEVARACTIVITY
+
+// Constants for clauses reductions
+#define RATIOREMOVECLAUSES 2
+
+
+
+// Constants for restarts
+#define LOWER_BOUND_FOR_BLOCKING_RESTART 10000
+
+/****************************************************************************************[Solver.h]
+ Glucose -- Copyright (c) 2009, Gilles Audemard, Laurent Simon
+				CRIL - Univ. Artois, France
+				LRI  - Univ. Paris Sud, France
+ 
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose are exactly the same as Minisat on which it is based on. (see below).
+
+---------------
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Ghack_Solver_h
+#define Ghack_Solver_h
+
+
+
+
+
+
+
+
+
+
+namespace GHack {
+
+//=================================================================================================
+// Solver -- the main class:
+
+class Solver {
+public:
+
+    // Constructor/Destructor:
+    //
+    Solver();
+    virtual ~Solver();
+
+    // Problem specification:
+    //
+    Var     newVar    (bool polarity = true, bool dvar = true); // Add a new variable with parameters specifying variable mode.
+
+    bool    addClause (const vec<Lit>& ps);                     // Add a clause to the solver. 
+    bool    addEmptyClause();                                   // Add the empty clause, making the solver contradictory.
+    bool    addClause (Lit p);                                  // Add a unit clause to the solver. 
+    bool    addClause (Lit p, Lit q);                           // Add a binary clause to the solver. 
+    bool    addClause (Lit p, Lit q, Lit r);                    // Add a ternary clause to the solver. 
+    bool    addClause_(      vec<Lit>& ps);                     // Add a clause to the solver without making superflous internal copy. Will
+                                                                // change the passed vector 'ps'.
+
+    // Solving:
+    //
+    bool    simplify     ();                        // Removes already satisfied clauses.
+    bool    solve        (const vec<Lit>& assumps); // Search for a model that respects a given set of assumptions.
+    lbool   solveLimited (const vec<Lit>& assumps); // Search for a model that respects a given set of assumptions (With resource constraints).
+    bool    solve        ();                        // Search without assumptions.
+    bool    solve        (Lit p);                   // Search for a model that respects a single assumption.
+    bool    solve        (Lit p, Lit q);            // Search for a model that respects two assumptions.
+    bool    solve        (Lit p, Lit q, Lit r);     // Search for a model that respects three assumptions.
+    bool    okay         () const;                  // FALSE means solver is in a conflicting state
+
+    void    toDimacs     (FILE* f, const vec<Lit>& assumps);            // Write CNF to file in DIMACS-format.
+    void    toDimacs     (const char *file, const vec<Lit>& assumps);
+    void    toDimacs     (FILE* f, Clause& c, vec<Var>& map, Var& max);
+    void printLit(Lit l);
+    void printClause(CRef c);
+    void printInitialClause(CRef c);
+    // Convenience versions of 'toDimacs()':
+    void    toDimacs     (const char* file);
+    void    toDimacs     (const char* file, Lit p);
+    void    toDimacs     (const char* file, Lit p, Lit q);
+    void    toDimacs     (const char* file, Lit p, Lit q, Lit r);
+    
+    // Variable mode:
+    // 
+    void    setPolarity    (Var v, bool b); // Declare which polarity the decision heuristic should use for a variable. Requires mode 'polarity_user'.
+    void    setDecisionVar (Var v, bool b); // Declare if a variable should be eligible for selection in the decision heuristic.
+
+    // Read state:
+    //
+    lbool   value      (Var x) const;       // The current value of a variable.
+    lbool   value      (Lit p) const;       // The current value of a literal.
+    lbool   modelValue (Var x) const;       // The value of a variable in the last model. The last call to solve must have been satisfiable.
+    lbool   modelValue (Lit p) const;       // The value of a literal in the last model. The last call to solve must have been satisfiable.
+    int     nAssigns   ()      const;       // The current number of assigned literals.
+    int     nClauses   ()      const;       // The current number of original clauses.
+    int     nLearnts   ()      const;       // The current number of learnt clauses.
+    int     nVars      ()      const;       // The current number of variables.
+    int     nFreeVars  ()      const;
+
+    // Incremental mode
+    void setIncrementalMode();
+    void initNbInitialVars(int nb);
+    void printIncrementalStats();
+
+    // Resource contraints:
+    //
+    void    setConfBudget(int64_t x);
+    void    setPropBudget(int64_t x);
+    void    budgetOff();
+    void    interrupt();          // Trigger a (potentially asynchronous) interruption of the solver.
+    void    clearInterrupt();     // Clear interrupt indicator flag.
+
+    // Memory managment:
+    //
+    virtual void garbageCollect();
+    void    checkGarbage(double gf);
+    void    checkGarbage();
+
+
+
+
+    // Extra results: (read-only member variable)
+    //
+    vec<lbool> model;             // If problem is satisfiable, this vector contains the model (if any).
+    vec<Lit>   conflict;          // If problem is unsatisfiable (possibly under assumptions),
+                                  // this vector represent the final conflict clause expressed in the assumptions.
+
+    // Mode of operation:
+    //
+    int       verbosity;
+    int       verbEveryConflicts;
+    int       showModel;
+    // Constants For restarts
+    double    K;
+    double    R;
+    double    sizeLBDQueue;
+    double    sizeTrailQueue;
+
+    // Constants for reduce DB
+    int firstReduceDB;
+    int incReduceDB;
+    int specialIncReduceDB,I,O,G,H,Y,Z,A,e;
+    unsigned int lbLBDFrozenClause;
+
+    // Constant for reducing clause
+    int lbSizeMinimizingClause;
+    unsigned int lbLBDMinimizingClause;
+
+    double    var_decay;
+    double    clause_decay;
+    double    random_var_freq;
+    double    random_seed;
+    int       ccmin_mode;         // Controls conflict clause minimization (0=none, 1=basic, 2=deep).
+    int       phase_saving;       // Controls the level of phase saving (0=none, 1=limited, 2=full).
+    bool      rnd_pol;            // Use random polarities for branching heuristics.
+    bool      rnd_init_act;       // Initialize variable activities with a small random value.
+    double    garbage_frac;       // The fraction of wasted memory allowed before a garbage collection is triggered.
+
+    // Certified UNSAT ( Thanks to Marijn Heule)
+    FILE*               certifiedOutput;
+    bool                certifiedUNSAT;
+    bool                vbyte;
+
+    void write_char (unsigned char c);
+    void write_lit (int n);
+
+    
+    // Statistics: (read-only member variable)
+    //
+    uint64_t nbRemovedClauses,nbReducedClauses,nbDL2,nbBin,nbUn,nbReduceDB,solves, starts, decisions, rnd_decisions, propagations, conflicts,conflictsRestarts,nbstopsrestarts,nbstopsrestartssame,lastblockatrestart;
+    uint64_t dec_vars, clauses_literals, learnts_literals, max_literals, tot_literals;
+
+protected:
+    long curRestart;
+    // Helper structures:
+    //
+    struct VarData { CRef reason; int level; };
+    static inline VarData mkVarData(CRef cr, int l){ VarData d = {cr, l}; return d; }
+
+    struct Watcher {
+        CRef cref;
+        Lit  blocker;
+        Watcher(CRef cr, Lit p) : cref(cr), blocker(p) {}
+        bool operator==(const Watcher& w) const { return cref == w.cref; }
+        bool operator!=(const Watcher& w) const { return cref != w.cref; }
+    };
+
+    struct WatcherDeleted
+    {
+        const ClauseAllocator& ca;
+        WatcherDeleted(const ClauseAllocator& _ca) : ca(_ca) {}
+        bool operator()(const Watcher& w) const { return ca[w.cref].mark() == 1; }
+    };
+
+    struct VarOrderLt {
+        const vec<double>&  activity;
+        bool operator () (Var x, Var y) const { return activity[x] > activity[y]; }
+        VarOrderLt(const vec<double>&  act) : activity(act) { }
+    };
+
+
+    // Solver state:
+    //
+    int lastIndexRed;
+    bool                ok;               // If FALSE, the constraints are already unsatisfiable. No part of the solver state may be used!
+    double              cla_inc;          // Amount to bump next clause with.
+    vec<double>         activity;         // A heuristic measurement of the activity of a variable.
+    double              var_inc;          // Amount to bump next variable with.
+    OccLists<Lit, vec<Watcher>, WatcherDeleted>
+                        watches;          // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true).
+    OccLists<Lit, vec<Watcher>, WatcherDeleted>
+                        watchesBin;          // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true).
+    vec<CRef>           clauses;          // List of problem clauses.
+    vec<CRef>           learnts,C,T;          // List of learnt clauses.
+
+    vec<lbool>          assigns;          // The current assignments.
+    vec<char>           polarity;         // The preferred polarity of each variable.
+    vec<char>           decision;         // Declares if a variable is eligible for selection in the decision heuristic.
+    vec<Lit>            trail;            // Assignment stack; stores all assigments made in the order they were made.
+        vec<int>            nbpos;
+    vec<int>            trail_lim;        // Separator indices for different decision levels in 'trail'.
+    vec<VarData>        vardata;          // Stores reason and level for each variable.
+    int                 qhead;            // Head of queue (as index into the trail -- no more explicit propagation queue in MiniSat).
+    int                 simpDB_assigns;   // Number of top-level assignments since last execution of 'simplify()'.
+    int64_t             simpDB_props;     // Remaining number of propagations that must be made before next execution of 'simplify()'.
+    vec<Lit>            assumptions;      // Current set of assumptions provided to solve by the user.
+    Heap<VarOrderLt>    order_heap;       // A priority queue of variables ordered with respect to the variable activity.
+    double              progress_estimate;// Set by 'search()'.
+    bool                remove_satisfied; // Indicates whether possibly inefficient linear scan for satisfied clauses should be performed in 'simplify'.
+    vec<unsigned int> permDiff;      // permDiff[var] contains the current conflict number... Used to count the number of  LBD
+    
+#ifdef UPDATEVARACTIVITY
+    // UPDATEVARACTIVITY trick (see competition'09 companion paper)
+    vec<Lit> lastDecisionLevel; 
+#endif
+
+    ClauseAllocator     ca;
+
+    int nbclausesbeforereduce;            // To know when it is time to reduce clause database
+    
+    bqueue<unsigned int> trailQueue,lbdQueue; // Bounded queues for restarts.
+    float sumLBD; // used to compute the global average of LBD. Restarts...
+    int sumAssumptions;
+
+
+    // Temporaries (to reduce allocation overhead). Each variable is prefixed by the method in which it is
+    // used, exept 'seen' wich is used in several places.
+    //
+    vec<char>           seen;
+    vec<Lit>            analyze_stack;
+    vec<Lit>            analyze_toclear;
+    vec<Lit>            add_tmp;
+    unsigned int  MYFLAG;
+
+
+    double              max_learnts;
+    double              learntsize_adjust_confl;
+    int                 learntsize_adjust_cnt;
+
+    // Resource contraints:
+    //
+    int64_t             conflict_budget;    // -1 means no budget.
+    int64_t             propagation_budget; // -1 means no budget.
+    bool                asynch_interrupt;
+
+
+    // Variables added for incremental mode
+    int incremental; // Use incremental SAT Solver
+    int nbVarsInitialFormula; // nb VAR in formula without assumptions (incremental SAT)
+    double totalTime4Sat,totalTime4Unsat;
+    int nbSatCalls,nbUnsatCalls;
+    vec<int> assumptionPositions,initialPositions;
+
+
+    // Main internal methods:
+    //
+    void     insertVarOrder   (Var x);                                                 // Insert a variable in the decision order priority queue.
+    Lit      pickBranchLit    ();                                                      // Return the next decision variable.
+    void     newDecisionLevel ();                                                      // Begins a new decision level.
+    void     uncheckedEnqueue (Lit p, CRef from = CRef_Undef);                         // Enqueue a literal. Assumes value of literal is undefined.
+    bool     enqueue          (Lit p, CRef from = CRef_Undef);                         // Test if fact 'p' contradicts current state, enqueue otherwise.
+    CRef     propagate        ();                                                      // Perform unit propagation. Returns possibly conflicting clause.
+    void     cancelUntil      (int level);                                             // Backtrack until a certain level.
+    void     analyze          (CRef confl, vec<Lit>& out_learnt, vec<Lit> & selectors, int& out_btlevel,unsigned int &nblevels,unsigned int &szWithoutSelectors);    // (bt = backtrack)
+    void     analyzeFinal     (Lit p, vec<Lit>& out_conflict);                         // COULD THIS BE IMPLEMENTED BY THE ORDINARIY "analyze" BY SOME REASONABLE GENERALIZATION?
+    bool     litRedundant     (Lit p, uint32_t abstract_levels);                       // (helper method for 'analyze()')
+    lbool    search           (int& nof_conflicts);                                     // Search for a given number of conflicts.
+    lbool    solve_           ();                                                      // Main solve method (assumptions given in 'assumptions').
+    void     reduceDB         ();                                                      // Reduce the set of learnt clauses.
+    void     removeSatisfied  (vec<CRef>& cs);                                         // Shrink 'cs' to contain only non-satisfied clauses.
+    void     rebuildOrderHeap ();
+
+    // Maintaining Variable/Clause activity:
+    //
+    void     varDecayActivity ();                      // Decay all variables with the specified factor. Implemented by increasing the 'bump' value instead.
+    void     varBumpActivity  (Var v, double inc);     // Increase a variable with the current 'bump' value.
+    void     varBumpActivity  (Var v);                 // Increase a variable with the current 'bump' value.
+    void     claDecayActivity ();                      // Decay all clauses with the specified factor. Implemented by increasing the 'bump' value instead.
+    void     claBumpActivity  (Clause& c);             // Increase a clause with the current 'bump' value.
+
+    // Operations on clauses:
+    //
+    void     attachClause     (CRef cr);               // Attach a clause to watcher lists.
+    void     detachClause     (CRef cr, bool strict = false); // Detach a clause to watcher lists.
+    void     removeClause     (CRef cr);               // Detach and free a clause.
+    bool     locked           (const Clause& c) const; // Returns TRUE if a clause is a reason for some implication in the current state.
+    bool     satisfied        (const Clause& c) const; // Returns TRUE if a clause is satisfied in the current state.
+
+    unsigned int computeLBD(const vec<Lit> & lits,int end=-1);
+    unsigned int computeLBD(const Clause &c);
+    void minimisationWithBinaryResolution(vec<Lit> &out_learnt);
+
+    void     relocAll         (ClauseAllocator& to);
+
+    // Misc:
+    //
+    int      decisionLevel    ()      const; // Gives the current decisionlevel.
+    uint32_t abstractLevel    (Var x) const; // Used to represent an abstraction of sets of decision levels.
+    CRef     reason           (Var x) const;
+    int      level            (Var x) const;
+    double   progressEstimate ()      const; // DELETE THIS ?? IT'S NOT VERY USEFUL ...
+    bool     withinBudget     ()      const;
+    inline bool isSelector(Var v) {return (incremental && v>nbVarsInitialFormula);}
+
+    // Static helpers:
+    //
+
+    // Returns a random float 0 <= x < 1. Seed must never be 0.
+    static inline double drand(double& seed) {
+        seed *= 1389796;
+        int q = (int)(seed / 2147483647);
+        seed -= (double)q * 2147483647;
+        return seed / 2147483647; }
+
+    // Returns a random integer 0 <= x < size. Seed must never be 0.
+    static inline int irand(double& seed, int size) {
+        return (int)(drand(seed) * size); }
+};
+
+
+//=================================================================================================
+// Implementation of inline methods:
+
+inline CRef Solver::reason(Var x) const { return vardata[x].reason; }
+inline int  Solver::level (Var x) const { return vardata[x].level; }
+
+inline void Solver::insertVarOrder(Var x) {
+    if (!order_heap.inHeap(x) && decision[x]) order_heap.insert(x); }
+
+inline void Solver::varDecayActivity() { var_inc *= (1 / var_decay); }
+inline void Solver::varBumpActivity(Var v) { varBumpActivity(v, var_inc); }
+inline void Solver::varBumpActivity(Var v, double inc) {
+    if ( (activity[v] += inc) > 1e100 ) {
+        // Rescale:
+        for (int i = 0; i < nVars(); i++)
+            activity[i] *= 1e-100;
+        var_inc *= 1e-100; }
+
+    // Update order_heap with respect to new activity:
+    if (order_heap.inHeap(v))
+        order_heap.decrease(v); }
+
+inline void Solver::claDecayActivity() { cla_inc *= (1 / clause_decay); }
+inline void Solver::claBumpActivity (Clause& c) {
+        if ( (c.activity() += cla_inc) > 1e20 ) {
+            // Rescale:
+            for (int i = 0; i < learnts.size(); i++)
+                ca[learnts[i]].activity() *= 1e-20;
+            cla_inc *= 1e-20; } }
+
+inline void Solver::checkGarbage(void){ return checkGarbage(garbage_frac); }
+inline void Solver::checkGarbage(double gf){
+    if (ca.wasted() > ca.size() * gf)
+        garbageCollect(); }
+
+// NOTE: enqueue does not set the ok flag! (only public methods do)
+inline bool     Solver::enqueue         (Lit p, CRef from)      { return value(p) != l_Undef ? value(p) != l_False : (uncheckedEnqueue(p, from), true); }
+inline bool     Solver::addClause       (const vec<Lit>& ps)    { ps.copyTo(add_tmp); return addClause_(add_tmp); }
+inline bool     Solver::addEmptyClause  ()                      { add_tmp.clear(); return addClause_(add_tmp); }
+inline bool     Solver::addClause       (Lit p)                 { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); }
+inline bool     Solver::addClause       (Lit p, Lit q)          { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); }
+inline bool     Solver::addClause       (Lit p, Lit q, Lit r)   { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); }
+ inline bool     Solver::locked          (const Clause& c) const { 
+   if(c.size()>2) 
+     return value(c[0]) == l_True && reason(var(c[0])) != CRef_Undef && ca.lea(reason(var(c[0]))) == &c; 
+   return 
+     (value(c[0]) == l_True && reason(var(c[0])) != CRef_Undef && ca.lea(reason(var(c[0]))) == &c)
+     || 
+     (value(c[1]) == l_True && reason(var(c[1])) != CRef_Undef && ca.lea(reason(var(c[1]))) == &c);
+ }
+inline void     Solver::newDecisionLevel()                      { trail_lim.push(trail.size()); }
+
+inline int      Solver::decisionLevel ()      const   { return trail_lim.size(); }
+inline uint32_t Solver::abstractLevel (Var x) const   { return 1 << (level(x) & 31); }
+inline lbool    Solver::value         (Var x) const   { return assigns[x]; }
+inline lbool    Solver::value         (Lit p) const   { return assigns[var(p)] ^ sign(p); }
+inline lbool    Solver::modelValue    (Var x) const   { return model[x]; }
+inline lbool    Solver::modelValue    (Lit p) const   { return model[var(p)] ^ sign(p); }
+inline int      Solver::nAssigns      ()      const   { return trail.size(); }
+inline int      Solver::nClauses      ()      const   { return clauses.size(); }
+inline int      Solver::nLearnts      ()      const   { return learnts.size(); }
+inline int      Solver::nVars         ()      const   { return vardata.size(); }
+inline int      Solver::nFreeVars     ()      const   { return (int)dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]); }
+inline void     Solver::setPolarity   (Var v, bool b) { polarity[v] = b; }
+inline void     Solver::setDecisionVar(Var v, bool b) 
+{ 
+    if      ( b && !decision[v]) dec_vars++;
+    else if (!b &&  decision[v]) dec_vars--;
+
+    decision[v] = b;
+    insertVarOrder(v);
+}
+inline void     Solver::setConfBudget(int64_t x){ conflict_budget    = conflicts    + x; }
+inline void     Solver::setPropBudget(int64_t x){ propagation_budget = propagations + x; }
+inline void     Solver::interrupt(){ asynch_interrupt = true; }
+inline void     Solver::clearInterrupt(){ asynch_interrupt = false; }
+inline void     Solver::budgetOff(){ conflict_budget = propagation_budget = -1; }
+inline bool     Solver::withinBudget() const {
+    return !asynch_interrupt &&
+           (conflict_budget    < 0 || conflicts < (uint64_t)conflict_budget) &&
+           (propagation_budget < 0 || propagations < (uint64_t)propagation_budget); }
+
+// FIXME: after the introduction of asynchronous interrruptions the solve-versions that return a
+// pure bool do not give a safe interface. Either interrupts must be possible to turn off here, or
+// all calls to solve must return an 'lbool'. I'm not yet sure which I prefer.
+inline bool     Solver::solve         ()                    { budgetOff(); assumptions.clear(); return solve_() == l_True; }
+inline bool     Solver::solve         (Lit p)               { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_() == l_True; }
+inline bool     Solver::solve         (Lit p, Lit q)        { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_() == l_True; }
+inline bool     Solver::solve         (Lit p, Lit q, Lit r) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_() == l_True; }
+inline bool     Solver::solve         (const vec<Lit>& assumps){ budgetOff(); assumps.copyTo(assumptions); return solve_() == l_True; }
+inline lbool    Solver::solveLimited  (const vec<Lit>& assumps){ assumps.copyTo(assumptions); return solve_(); }
+inline bool     Solver::okay          ()      const   { return ok; }
+
+inline void     Solver::toDimacs     (const char* file){ vec<Lit> as; toDimacs(file, as); }
+inline void     Solver::toDimacs     (const char* file, Lit p){ vec<Lit> as; as.push(p); toDimacs(file, as); }
+inline void     Solver::toDimacs     (const char* file, Lit p, Lit q){ vec<Lit> as; as.push(p); as.push(q); toDimacs(file, as); }
+inline void     Solver::toDimacs     (const char* file, Lit p, Lit q, Lit r){ vec<Lit> as; as.push(p); as.push(q); as.push(r); toDimacs(file, as); }
+
+
+//=================================================================================================
+// Debug etc:
+
+
+inline void Solver::printLit(Lit l)
+{
+    printf("%s%d:%c", sign(l) ? "-" : "", var(l)+1, value(l) == l_True ? '1' : (value(l) == l_False ? '0' : 'X'));
+}
+
+
+inline void Solver::printClause(CRef cr)
+{
+  Clause &c = ca[cr];
+    for (int i = 0; i < c.size(); i++){
+        printLit(c[i]);
+        printf(" ");
+    }
+}
+
+inline void Solver::printInitialClause(CRef cr)
+{
+  Clause &c = ca[cr];
+    for (int i = 0; i < c.size(); i++){
+      if(!isSelector(var(c[i]))) {
+	printLit(c[i]);
+        printf(" ");
+      }
+    }
+}
+
+
+//=================================================================================================
+}
+
+#endif
+/***************************************************************************************[Solver.cc]
+ Glucose -- Copyright (c) 2013, Gilles Audemard, Laurent Simon
+				CRIL - Univ. Artois, France
+				LRI  - Univ. Paris Sud, France
+ 
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose are exactly the same as Minisat on which it is based on. (see below).
+
+---------------
+
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#include <math.h>
+
+
+
+
+
+
+#define M mark
+#define Q conflicts
+#define P push
+#define B claBumpActivity
+
+namespace GHack {
+
+//=================================================================================================
+// Options:
+
+static const char* _cat = "CORE";
+static const char* _cr = "CORE -- RESTART";
+static const char* _cred = "CORE -- REDUCE";
+static const char* _cm = "CORE -- MINIMIZE";
+static const char* _certified = "CORE -- CERTIFIED UNSAT";
+
+
+
+
+static BoolOption opt_incremental (_cat,"incremental", "Use incremental SAT solving",false);
+static DoubleOption opt_K                 (_cr, "K",           "The constant used to force restart",            0.8,     DoubleRange(0, false, 1, false));           
+static DoubleOption opt_R                 (_cr, "R",           "The constant used to block restart",            1.4,     DoubleRange(1, false, 5, false));           
+static IntOption     opt_size_lbd_queue     (_cr, "szLBDQueue",      "The size of moving average for LBD (restarts)", 50, IntRange(10, INT32_MAX));
+static IntOption     opt_size_trail_queue     (_cr, "szTrailQueue",      "The size of moving average for trail (block restarts)", 5000, IntRange(10, INT32_MAX));
+
+static IntOption     opt_first_reduce_db     (_cred, "firstReduceDB",      "The number of conflicts before the first reduce DB", 2000, IntRange(0, INT32_MAX));
+static IntOption     opt_inc_reduce_db     (_cred, "incReduceDB",      "Increment for reduce DB", 300, IntRange(0, INT32_MAX));
+static IntOption     opt_spec_inc_reduce_db     (_cred, "specialIncReduceDB",      "Special increment for reduce DB", 1000, IntRange(0, INT32_MAX));
+static IntOption    opt_lb_lbd_frozen_clause      (_cred, "minLBDFrozenClause",        "Protect clauses if their LBD decrease and is lower than (for one turn)", 30, IntRange(0, INT32_MAX));
+
+static IntOption     opt_lb_size_minimzing_clause     (_cm, "minSizeMinimizingClause",      "The min size required to minimize clause", 30, IntRange(3, INT32_MAX));
+static IntOption     opt_lb_lbd_minimzing_clause     (_cm, "minLBDMinimizingClause",      "The min LBD required to minimize clause", 6, IntRange(3, INT32_MAX));
+
+
+static DoubleOption  opt_var_decay         (_cat, "var-decay",   "The variable activity decay factor",            0.8,     DoubleRange(0, false, 1, false));
+static DoubleOption  opt_clause_decay      (_cat, "cla-decay",   "The clause activity decay factor",              0.999,    DoubleRange(0, false, 1, false));
+static DoubleOption  opt_random_var_freq   (_cat, "rnd-freq",    "The frequency with which the decision heuristic tries to choose a random variable", 0, DoubleRange(0, true, 1, true));
+static DoubleOption  opt_random_seed       (_cat, "rnd-seed",    "Used by the random variable selection",         91648253, DoubleRange(0, false, HUGE_VAL, false));
+static IntOption     opt_ccmin_mode        (_cat, "ccmin-mode",  "Controls conflict clause minimization (0=none, 1=basic, 2=deep)", 2, IntRange(0, 2));
+static IntOption     opt_phase_saving      (_cat, "phase-saving", "Controls the level of phase saving (0=none, 1=limited, 2=full)", 2, IntRange(0, 2));
+static BoolOption    opt_rnd_init_act      (_cat, "rnd-init",    "Randomize the initial activity", false);
+/*
+static IntOption     opt_restart_first     (_cat, "rfirst",      "The base restart interval", 100, IntRange(1, INT32_MAX));
+static DoubleOption  opt_restart_inc       (_cat, "rinc",        "Restart interval increase factor", 2, DoubleRange(1, false, HUGE_VAL, false));
+*/
+static DoubleOption  opt_garbage_frac      (_cat, "gc-frac",     "The fraction of wasted memory allowed before a garbage collection is triggered",  0.20, DoubleRange(0, false, HUGE_VAL, false));
+
+
+static BoolOption    opt_certified         (_certified, "certified",    "Certified UNSAT using DRUP format", false);
+static StringOption  opt_certified_file    (_certified, "certified-output",    "Certified UNSAT output file", "NULL");
+static BoolOption    opt_vbyte             (_certified, "vbyte",    "Emit proof in variable-byte encoding", false);
+
+
+//=================================================================================================
+// Constructor/Destructor:
+
+
+inline Solver::Solver() :
+
+    // Parameters (user settable):
+    //
+    verbosity        (0)
+    , showModel        (0)
+    , K              (opt_K)
+    , R              (opt_R)
+    , sizeLBDQueue   (opt_size_lbd_queue)
+    , sizeTrailQueue   (opt_size_trail_queue)
+    , firstReduceDB  (opt_first_reduce_db)
+    , incReduceDB    (opt_inc_reduce_db)
+    , specialIncReduceDB    (opt_spec_inc_reduce_db)
+    , lbLBDFrozenClause (opt_lb_lbd_frozen_clause)
+    , lbSizeMinimizingClause (opt_lb_size_minimzing_clause)
+    , lbLBDMinimizingClause (opt_lb_lbd_minimzing_clause)
+  , var_decay        (opt_var_decay)
+  , clause_decay     (opt_clause_decay)
+  , random_var_freq  (opt_random_var_freq)
+  , random_seed      (opt_random_seed)
+  , ccmin_mode       (opt_ccmin_mode)
+  , phase_saving     (opt_phase_saving)
+  , rnd_pol          (false)
+  , rnd_init_act     (opt_rnd_init_act)
+  , garbage_frac     (opt_garbage_frac)
+  , certifiedOutput  (NULL)
+  , certifiedUNSAT   (opt_certified)
+  , vbyte            (opt_vbyte)
+    // Statistics: (formerly in 'SolverStats')
+    //
+  ,  nbRemovedClauses(0),nbReducedClauses(0), nbDL2(0),nbBin(0),nbUn(0) , nbReduceDB(0)
+    , solves(0), starts(0), decisions(0), rnd_decisions(0), propagations(0),conflicts(0),conflictsRestarts(0),nbstopsrestarts(0),nbstopsrestartssame(0),lastblockatrestart(0)
+  , dec_vars(0), clauses_literals(0), learnts_literals(0), max_literals(0), tot_literals(0)
+    , curRestart(1)
+
+  , ok                 (true)
+  , cla_inc            (1)
+  , var_inc            (1)
+  , watches            (WatcherDeleted(ca))
+  , watchesBin            (WatcherDeleted(ca))
+  , qhead              (0)
+  , simpDB_assigns     (-1)
+  , simpDB_props       (0)
+  , order_heap         (VarOrderLt(activity))
+  , progress_estimate  (0)
+  , remove_satisfied   (true)
+    // Resource constraints:
+    //
+  , conflict_budget    (-1)
+  , propagation_budget (-1)
+  , asynch_interrupt   (false)
+  , incremental(opt_incremental)
+  , nbVarsInitialFormula(INT32_MAX)
+{
+  MYFLAG=H=Y=O=e=0; 
+  G=1; A=4; Z=15000;
+  // Initialize only first time. Useful for incremental solving, useless otherwise
+  lbdQueue.initSize(sizeLBDQueue);
+  trailQueue.initSize(sizeTrailQueue);
+  sumLBD = 0;
+  nbclausesbeforereduce = firstReduceDB;
+  totalTime4Sat=0;totalTime4Unsat=0;
+  nbSatCalls=0;nbUnsatCalls=0;
+
+
+  if(certifiedUNSAT) {
+    if(!strcmp(opt_certified_file,"NULL")) {
+      vbyte           =  false;  // Cannot write binary to stdout
+      certifiedOutput =  fopen("/dev/stdout", "wb");
+    } else {
+      certifiedOutput =  fopen(opt_certified_file, "wb");	    
+    }
+    //    fprintf(certifiedOutput,"o proof DRUP\n");
+  }
+}
+
+
+inline Solver::~Solver()
+{
+}
+
+
+/****************************************************************
+ Set the incremental mode
+****************************************************************/
+
+// This function set the incremental mode to true.
+// You can add special code for this mode here.
+
+inline void Solver::setIncrementalMode() {
+  incremental = true;
+}
+
+// Number of variables without selectors
+inline void Solver::initNbInitialVars(int nb) {
+  nbVarsInitialFormula = nb;
+}
+
+
+//=================================================================================================
+// Minor methods:
+
+
+// Creates a new SAT variable in the solver. If 'decision' is cleared, variable will not be
+// used as a decision variable (NOTE! This has effects on the meaning of a SATISFIABLE result).
+//
+inline Var Solver::newVar(bool sign, bool dvar)
+{
+    int v = nVars();
+    watches  .init(mkLit(v, false));
+    watches  .init(mkLit(v, true ));
+    watchesBin  .init(mkLit(v, false));
+    watchesBin  .init(mkLit(v, true ));
+    assigns  .push(l_Undef);
+    vardata  .push(mkVarData(CRef_Undef, 0));
+    //activity .push(0);
+    activity .push(rnd_init_act ? drand(random_seed) * 0.00001 : 0);
+    seen     .push(0);
+    permDiff  .push(0);
+    polarity .push(sign);
+    decision .push();
+    trail    .capacity(v+1);
+    setDecisionVar(v, dvar);
+    return v;
+}
+
+inline unsigned char b[2097152];
+inline void Solver::write_char (unsigned char ch) {
+  b[e++] = ch; }
+  //if (putc_unlocked ((int)
+#define write_char b[e++] =
+  //= EOF) exit(1); }
+
+inline void Solver::write_lit (int n) {
+  for (; n > 127; n >>= 7)
+    write_char (128 | (n & 127));
+   write_char (n); if (e > 1048576) fwrite(b, 1, e, certifiedOutput), e = 0; }
+
+inline bool Solver::addClause_(vec<Lit>& ps)
+{
+    assert(decisionLevel() == 0);
+    if (!ok) return false;
+
+    // Check if clause is satisfied and remove false/duplicate literals:
+    sort(ps);
+
+    vec<Lit>    oc;
+    oc.clear();
+
+    Lit p; int i, j, flag = 0;
+    if(certifiedUNSAT) {
+      for (i = j = 0, p = lit_Undef; i < ps.size(); i++) {
+        oc.push(ps[i]);
+        if (value(ps[i]) == l_True || ps[i] == ~p || value(ps[i]) == l_False)
+          flag = 1;
+      }
+    }
+
+    for (i = j = 0, p = lit_Undef; i < ps.size(); i++)
+      if (value(ps[i]) == l_True || ps[i] == ~p)
+	return true;
+      else if (value(ps[i]) != l_False && ps[i] != p)
+	ps[j++] = p = ps[i];
+    ps.shrink(i - j);
+    
+    if (i != j && (certifiedUNSAT)) {
+      if (vbyte) {
+        write_char('a');
+        for (i = j = 0, p = lit_Undef; i < ps.size(); i++)
+          write_lit(2*(var(ps[i])+1) + sign(ps[i]));
+        write_lit(0);
+
+        write_char('d');
+        for (i = j = 0, p = lit_Undef; i < oc.size(); i++)
+          write_lit(2*(var(oc[i])+1) + sign(oc[i]));
+        write_lit(0);
+      }
+      else {
+        for (i = j = 0, p = lit_Undef; i < ps.size(); i++)
+          fprintf(certifiedOutput, "%i ", (var(ps[i]) + 1) * (-2 * sign(ps[i]) + 1));
+        fprintf(certifiedOutput, "0\n");
+
+        fprintf(certifiedOutput, "d ");
+        for (i = j = 0, p = lit_Undef; i < oc.size(); i++)
+          fprintf(certifiedOutput, "%i ", (var(oc[i]) + 1) * (-2 * sign(oc[i]) + 1));
+        fprintf(certifiedOutput, "0\n");
+      }
+    }
+
+    if (ps.size() == 0)
+        return ok = false;
+    else if (ps.size() == 1){
+        uncheckedEnqueue(ps[0]);
+        return ok = (propagate() == CRef_Undef);
+    }else{
+        CRef cr = ca.alloc(ps, false);
+        clauses.push(cr);
+        attachClause(cr);
+    }
+
+    return true;
+}
+
+
+inline void Solver::attachClause(CRef cr) {
+    const Clause& c = ca[cr];
+
+    assert(c.size() > 1);
+    if(c.size()==2) {
+      watchesBin[~c[0]].push(Watcher(cr, c[1]));
+      watchesBin[~c[1]].push(Watcher(cr, c[0]));
+    } else {
+      watches[~c[0]].push(Watcher(cr, c[1]));
+      watches[~c[1]].push(Watcher(cr, c[0]));
+    }
+    if (c.learnt()) learnts_literals += c.size();
+    else            clauses_literals += c.size(); }
+
+
+
+
+inline void Solver::detachClause(CRef cr, bool strict) {
+    const Clause& c = ca[cr];
+    
+    assert(c.size() > 1);
+    if(c.size()==2) {
+      if (strict){
+        remove(watchesBin[~c[0]], Watcher(cr, c[1]));
+        remove(watchesBin[~c[1]], Watcher(cr, c[0]));
+      }else{
+        // Lazy detaching: (NOTE! Must clean all watcher lists before garbage collecting this clause)
+        watchesBin.smudge(~c[0]);
+        watchesBin.smudge(~c[1]);
+      }
+    } else {
+      if (strict){
+        remove(watches[~c[0]], Watcher(cr, c[1]));
+        remove(watches[~c[1]], Watcher(cr, c[0]));
+      }else{
+        // Lazy detaching: (NOTE! Must clean all watcher lists before garbage collecting this clause)
+        watches.smudge(~c[0]);
+        watches.smudge(~c[1]);
+      }
+    }
+    if (c.learnt()) learnts_literals -= c.size();
+    else            clauses_literals -= c.size(); }
+
+
+inline void Solver::removeClause(CRef cr) {
+
+  Clause& c = ca[cr];
+
+  if (certifiedUNSAT) {
+    if (vbyte) {
+      write_char ('d');
+      for (int i = 0; i < c.size(); i++)
+        write_lit(2*(var(c[i])+1) + sign(c[i]));
+      write_lit (0);
+    }
+    else {
+      fprintf(certifiedOutput, "d ");
+      for (int i = 0; i < c.size(); i++)
+        fprintf(certifiedOutput, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+      fprintf(certifiedOutput, "0\n");
+    }
+  }
+
+  detachClause(cr);
+  // Don't leave pointers to free'd memory!
+  if (locked(c)) vardata[var(c[0])].reason = CRef_Undef;
+  c.mark(1);
+  ca.free(cr);
+}
+
+
+inline bool Solver::satisfied(const Clause& c) const {
+  if(incremental)  // Check clauses with many selectors is too time consuming
+    return (value(c[0]) == l_True) || (value(c[1]) == l_True);
+
+  // Default mode.
+    for (int i = 0; i < c.size(); i++)
+        if (value(c[i]) == l_True)
+            return true;
+    return false; 
+}
+
+/************************************************************
+ * Compute LBD functions
+ *************************************************************/
+
+inline unsigned int Solver::computeLBD(const vec<Lit> & lits,int end) {
+  int nblevels = 0;
+  MYFLAG++;
+
+  if(incremental) { // ----------------- INCREMENTAL MODE
+    if(end==-1) end = lits.size();
+    unsigned int nbDone = 0;
+    for(int i=0;i<lits.size();i++) {
+      if(nbDone>=end) break;
+      if(isSelector(var(lits[i]))) continue;
+      nbDone++;
+      int l = level(var(lits[i]));
+      if (permDiff[l] != MYFLAG) {
+	permDiff[l] = MYFLAG;
+	nblevels++;
+      }
+    }
+  } else { // -------- DEFAULT MODE. NOT A LOT OF DIFFERENCES... BUT EASIER TO READ
+    for(int i=0;i<lits.size();i++) {
+      int l = level(var(lits[i]));
+      if (l && permDiff[l] != MYFLAG) {
+	permDiff[l] = MYFLAG;
+	nblevels++;
+      }
+    }
+  }
+
+  return nblevels;
+}
+
+inline unsigned int Solver::computeLBD(const Clause &c) {
+  int nblevels = 0;
+  MYFLAG++;
+
+  if(incremental) { // ----------------- INCREMENTAL MODE
+     int nbDone = 0;
+    for(int i=0;i<c.size();i++) {
+      if(nbDone>=c.sizeWithoutSelectors()) break;
+      if(isSelector(var(c[i]))) continue;
+      nbDone++;
+      int l = level(var(c[i]));
+      if (permDiff[l] != MYFLAG) {
+	permDiff[l] = MYFLAG;
+	nblevels++;
+      }
+    }
+  } else { // -------- DEFAULT MODE. NOT A LOT OF DIFFERENCES... BUT EASIER TO READ
+    for(int i=0;i<c.size();i++) {
+      int l = level(var(c[i]));
+      if (l && permDiff[l] != MYFLAG) {
+	permDiff[l] = MYFLAG;
+	nblevels++;
+      }
+    }
+  }
+  return nblevels;
+}
+
+
+/******************************************************************
+ * Minimisation with binary reolution
+ ******************************************************************/
+inline void Solver::minimisationWithBinaryResolution(vec<Lit> &out_learnt) {
+  
+  // Find the LBD measure                                                                                                         
+  unsigned int lbd = computeLBD(out_learnt);
+  Lit p = ~out_learnt[0];
+  
+  if(lbd<=lbLBDMinimizingClause){
+    MYFLAG++;
+    
+    for(int i = 1;i<out_learnt.size();i++) {
+      permDiff[var(out_learnt[i])] = MYFLAG;
+    }
+
+    vec<Watcher>&  wbin  = watchesBin[p];
+    int nb = 0;
+    for(int k = 0;k<wbin.size();k++) {
+      Lit imp = wbin[k].blocker;
+      if(permDiff[var(imp)]==MYFLAG && value(imp)==l_True) {
+	nb++;
+	permDiff[var(imp)]= MYFLAG-1;
+      }
+      }
+    int l = out_learnt.size()-1;
+    if(nb>0) {
+      nbReducedClauses++;
+      for(int i = 1;i<out_learnt.size()-nb;i++) {
+	if(permDiff[var(out_learnt[i])]!=MYFLAG) {
+	  Lit p = out_learnt[l];
+	  out_learnt[l] = out_learnt[i];
+	  out_learnt[i] = p;
+	  l--;i--;
+	}
+      }
+      
+      out_learnt.shrink(nb);
+      
+    }
+  }
+}
+
+// Revert to the state at given level (keeping all assignment at 'level' but not beyond).
+//
+inline void Solver::cancelUntil(int level) {
+    if (decisionLevel() > level){
+        for (int c = trail.size()-1; c >= trail_lim[level]; c--){
+            Var      x  = var(trail[c]);
+            assigns [x] = l_Undef;
+	    if (phase_saving > 1 || ((phase_saving == 1) && c > trail_lim.last()))
+                polarity[x] = sign(trail[c]);
+            insertVarOrder(x); }
+        qhead = trail_lim[level];
+        trail.shrink(trail.size() - trail_lim[level]);
+        trail_lim.shrink(trail_lim.size() - level);
+    } 
+}
+
+
+//=================================================================================================
+// Major methods:
+
+
+inline Lit Solver::pickBranchLit()
+{
+    Var next = var_Undef;
+
+    // Random decision:
+    if (drand(random_seed) < random_var_freq && !order_heap.empty()){
+        next = order_heap[irand(random_seed,order_heap.size())];
+        if (value(next) == l_Undef && decision[next])
+            rnd_decisions++; }
+
+    // Activity based decision:
+    while (next == var_Undef || value(next) != l_Undef || !decision[next])
+        if (order_heap.empty()){
+            next = var_Undef;
+            break;
+        }else
+            next = order_heap.removeMin();
+
+    return next == var_Undef ? lit_Undef : mkLit(next, rnd_pol ? drand(random_seed) < 0.5 : polarity[next]);
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  analyze : (confl : Clause*) (out_learnt : vec<Lit>&) (out_btlevel : int&)  ->  [void]
+|  
+|  Description:
+|    Analyze conflict and produce a reason clause.
+|  
+|    Pre-conditions:
+|      * 'out_learnt' is assumed to be cleared.
+|      * Current decision level must be greater than root level.
+|  
+|    Post-conditions:
+|      * 'out_learnt[0]' is the asserting literal at level 'out_btlevel'.
+|      * If out_learnt.size() > 1 then 'out_learnt[1]' has the greatest decision level of the 
+|        rest of literals. There may be others from the same level though.
+|  
+|________________________________________________________________________________________________@*/
+inline void Solver::analyze(CRef confl, vec<Lit>& out_learnt,vec<Lit>&selectors, int& out_btlevel,unsigned int &lbd,unsigned int &szWithoutSelectors)
+{
+    int pathC = 0;
+    Lit p     = lit_Undef;
+
+    // Generate conflict clause:
+    //
+    out_learnt.push();      // (leave room for the asserting literal)
+    int index   = trail.size() - 1;
+
+    do{
+        assert(confl != CRef_Undef); // (otherwise should be UIP)
+        Clause& c = ca[confl];
+
+	// Special case for binary clauses
+	// The first one has to be SAT
+	if( p != lit_Undef && c.size()==2 && value(c[0])==l_False) {
+	  
+	  assert(value(c[1])==l_True);
+	  Lit tmp = c[0];
+	  c[0] =  c[1], c[1] = tmp;
+	}
+	
+	if (0 && c.learnt()) 
+            claBumpActivity(c);
+
+#ifdef DYNAMICNBLEVEL		    
+	// DYNAMIC NBLEVEL trick (see competition'09 companion paper)
+	if(c.learnt()  && c.M() != 3) { 
+	  unsigned int nblevels = I = computeLBD(c);
+	  if(nblevels<c.lbd() ) { // improve the LBD
+	    if(c.lbd()<=lbLBDFrozenClause) {
+	      c.setCanBeDel(false); 
+	    }
+	    // seems to be interesting : keep it for the next round
+	    c.setLBD(nblevels); // Update it
+            if (I < A){
+                C.P(confl);
+                c.M(3);
+            }else if (I < 7 && !c.M()){
+                T.P(confl);
+                c.M(2); }
+	  }
+          if (c.M() == 2) c.t = Q;
+          if (!c.M()) B(c);
+	}
+#endif
+
+
+        for (int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++){
+            Lit q = c[j];
+
+            if (!seen[var(q)] && level(var(q)) > 0){
+	      if(!isSelector(var(q)))
+                varBumpActivity(var(q));
+	      seen[var(q)] = 1;
+	      if (level(var(q)) >= decisionLevel()) {
+		pathC++;
+#ifdef UPDATEVARACTIVITY
+		// UPDATEVARACTIVITY trick (see competition'09 companion paper)
+		if(!isSelector(var(q)) && (reason(var(q))!= CRef_Undef)  && ca[reason(var(q))].learnt()) 
+		  lastDecisionLevel.push(q);
+#endif
+		
+	      } else {
+		if(isSelector(var(q))) {
+		  assert(value(q) == l_False);
+		  selectors.push(q);
+		} else 
+		  out_learnt.push(q);
+	      }
+	    }
+        }
+        
+        // Select next clause to look at:
+        while (!seen[var(trail[index--])]);
+        p     = trail[index+1];
+        confl = reason(var(p));
+        seen[var(p)] = 0;
+        pathC--;
+
+    }while (pathC > 0);
+    out_learnt[0] = ~p;
+
+    // Simplify conflict clause:
+    //
+    int i, j;
+
+    for(int i = 0;i<selectors.size();i++)  
+      out_learnt.push(selectors[i]);       
+
+    out_learnt.copyTo(analyze_toclear);
+    if (ccmin_mode == 2){
+        uint32_t abstract_level = 0;
+        for (i = 1; i < out_learnt.size(); i++)
+            abstract_level |= abstractLevel(var(out_learnt[i])); // (maintain an abstraction of levels involved in conflict)
+
+        for (i = j = 1; i < out_learnt.size(); i++)
+            if (reason(var(out_learnt[i])) == CRef_Undef || !litRedundant(out_learnt[i], abstract_level))
+                out_learnt[j++] = out_learnt[i];
+        
+    }else if (ccmin_mode == 1){
+        for (i = j = 1; i < out_learnt.size(); i++){
+            Var x = var(out_learnt[i]);
+
+            if (reason(x) == CRef_Undef)
+                out_learnt[j++] = out_learnt[i];
+            else{
+                Clause& c = ca[reason(var(out_learnt[i]))];
+                // Thanks to Siert Wieringa for this bug fix!
+                for (int k = ((c.size()==2) ? 0:1); k < c.size(); k++)
+                    if (!seen[var(c[k])] && level(var(c[k])) > 0){
+                        out_learnt[j++] = out_learnt[i];
+                        break; }
+            }
+        }
+    }else
+        i = j = out_learnt.size();
+
+    max_literals += out_learnt.size();
+    out_learnt.shrink(i - j);
+    tot_literals += out_learnt.size();
+
+
+    /* ***************************************
+      Minimisation with binary clauses of the asserting clause
+      First of all : we look for small clauses
+      Then, we reduce clauses with small LBD.
+      Otherwise, this can be useless
+     */
+    if(!incremental && out_learnt.size()<=lbSizeMinimizingClause) {
+      minimisationWithBinaryResolution(out_learnt);
+    }
+    // Find correct backtrack level:
+    //
+    if (out_learnt.size() == 1)
+        out_btlevel = 0;
+    else{
+        int max_i = 1;
+        // Find the first literal assigned at the next-highest level:
+        for (int i = 2; i < out_learnt.size(); i++)
+            if (level(var(out_learnt[i])) > level(var(out_learnt[max_i])))
+                max_i = i;
+        // Swap-in this literal at index 1:
+        Lit p             = out_learnt[max_i];
+        out_learnt[max_i] = out_learnt[1];
+        out_learnt[1]     = p;
+        out_btlevel       = level(var(p));
+    }
+
+
+    // Compute the size of the clause without selectors (incremental mode)
+    if(incremental) {
+      szWithoutSelectors = 0;
+      for(int i=0;i<out_learnt.size();i++) {
+	if(!isSelector(var((out_learnt[i])))) szWithoutSelectors++; 
+	else if(i>0) break;
+      }
+    } else 
+      szWithoutSelectors = out_learnt.size();
+    
+    // Compute LBD
+    lbd = computeLBD(out_learnt,out_learnt.size()-selectors.size());
+
+  
+#ifdef UPDATEVARACTIVITY
+  // UPDATEVARACTIVITY trick (see competition'09 companion paper)
+  if(lastDecisionLevel.size()>0) {
+    for(int i = 0;i<lastDecisionLevel.size();i++) {
+      if(ca[reason(var(lastDecisionLevel[i]))].lbd()<lbd)
+	varBumpActivity(var(lastDecisionLevel[i]));
+    }
+    lastDecisionLevel.clear();
+  } 
+#endif	    
+
+  lbd--;
+
+
+  for (int j = 0; j < analyze_toclear.size(); j++) seen[var(analyze_toclear[j])] = 0;    // ('seen[]' is now cleared)
+  for(int j = 0 ; j<selectors.size() ; j++) seen[var(selectors[j])] = 0;  
+}
+
+
+// Check if 'p' can be removed. 'abstract_levels' is used to abort early if the algorithm is
+// visiting literals at levels that cannot be removed later.
+inline bool Solver::litRedundant(Lit p, uint32_t abstract_levels)
+{
+    analyze_stack.clear(); analyze_stack.push(p);
+    int top = analyze_toclear.size();
+    while (analyze_stack.size() > 0){
+        assert(reason(var(analyze_stack.last())) != CRef_Undef);
+        Clause& c = ca[reason(var(analyze_stack.last()))]; analyze_stack.pop();
+	if(c.size()==2 && value(c[0])==l_False) {
+	  assert(value(c[1])==l_True);
+	  Lit tmp = c[0];
+	  c[0] =  c[1], c[1] = tmp;
+	}
+
+        for (int i = 1; i < c.size(); i++){
+            Lit p  = c[i];
+            if (!seen[var(p)] && level(var(p)) > 0){
+                if (reason(var(p)) != CRef_Undef && (abstractLevel(var(p)) & abstract_levels) != 0){
+                    seen[var(p)] = 1;
+                    analyze_stack.push(p);
+                    analyze_toclear.push(p);
+                }else{
+                    for (int j = top; j < analyze_toclear.size(); j++)
+                        seen[var(analyze_toclear[j])] = 0;
+                    analyze_toclear.shrink(analyze_toclear.size() - top);
+                    return false;
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  analyzeFinal : (p : Lit)  ->  [void]
+|  
+|  Description:
+|    Specialized analysis procedure to express the final conflict in terms of assumptions.
+|    Calculates the (possibly empty) set of assumptions that led to the assignment of 'p', and
+|    stores the result in 'out_conflict'.
+|________________________________________________________________________________________________@*/
+inline void Solver::analyzeFinal(Lit p, vec<Lit>& out_conflict)
+{
+    out_conflict.clear();
+    out_conflict.push(p);
+
+    if (decisionLevel() == 0)
+        return;
+
+    seen[var(p)] = 1;
+
+    for (int i = trail.size()-1; i >= trail_lim[0]; i--){
+        Var x = var(trail[i]);
+        if (seen[x]){
+            if (reason(x) == CRef_Undef){
+                assert(level(x) > 0);
+                out_conflict.push(~trail[i]);
+            }else{
+                Clause& c = ca[reason(x)];
+		//                for (int j = 1; j < c.size(); j++) Minisat (glucose 2.0) loop 
+		// Bug in case of assumptions due to special data structures for Binary.
+		// Many thanks to Sam Bayless (sbayless@cs.ubc.ca) for discover this bug.
+		for (int j = ((c.size()==2) ? 0:1); j < c.size(); j++)
+                    if (level(var(c[j])) > 0)
+                        seen[var(c[j])] = 1;
+            }  
+
+            seen[x] = 0;
+        }
+    }
+
+    seen[var(p)] = 0;
+}
+
+
+inline void Solver::uncheckedEnqueue(Lit p, CRef from)
+{
+    assert(value(p) == l_Undef);
+    assigns[var(p)] = lbool(!sign(p));
+    vardata[var(p)] = mkVarData(from, decisionLevel());
+    trail.push_(p);
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  propagate : [void]  ->  [Clause*]
+|  
+|  Description:
+|    Propagates all enqueued facts. If a conflict arises, the conflicting clause is returned,
+|    otherwise CRef_Undef.
+|  
+|    Post-conditions:
+|      * the propagation queue is empty, even if there was a conflict.
+|________________________________________________________________________________________________@*/
+inline CRef Solver::propagate()
+{
+    CRef    confl     = CRef_Undef;
+    int     num_props = 0;
+    watches.cleanAll();
+    watchesBin.cleanAll();
+    while (qhead < trail.size()){
+        Lit            p   = trail[qhead++];     // 'p' is enqueued fact to propagate.
+        vec<Watcher>&  ws  = watches[p];
+        Watcher        *i, *j, *end;
+        num_props++;
+
+	
+	    // First, Propagate binary clauses 
+	vec<Watcher>&  wbin  = watchesBin[p];
+	
+	for(int k = 0;k<wbin.size();k++) {
+	  
+	  Lit imp = wbin[k].blocker;
+	  
+	  if(value(imp) == l_False) {
+	    return wbin[k].cref;
+	  }
+	  
+	  if(value(imp) == l_Undef) {
+	    uncheckedEnqueue(imp,wbin[k].cref);
+	  }
+	}
+    
+
+
+        for (i = j = (Watcher*)ws, end = i + ws.size();  i != end;){
+            // Try to avoid inspecting the clause:
+            Lit blocker = i->blocker;
+            if (value(blocker) == l_True){
+                *j++ = *i++; continue; }
+
+            // Make sure the false literal is data[1]:
+            CRef     cr        = i->cref;
+            Clause&  c         = ca[cr];
+            Lit      false_lit = ~p;
+            if (c[0] == false_lit)
+                c[0] = c[1], c[1] = false_lit;
+            assert(c[1] == false_lit);
+            i++;
+
+            // If 0th watch is true, then clause is already satisfied.
+            Lit     first = c[0];
+            Watcher w     = Watcher(cr, first);
+            if (first != blocker && value(first) == l_True){
+	      
+	      *j++ = w; continue; }
+
+            // Look for new watch:
+	    if(incremental) { // ----------------- INCREMENTAL MODE
+	      int choosenPos = -1;
+	      for (int k = 2; k < c.size(); k++) {
+		
+		if (value(c[k]) != l_False){
+		  if(decisionLevel()>assumptions.size()) {
+		    choosenPos = k;
+		    break;
+		  } else {
+		    choosenPos = k;
+		    
+		    if(value(c[k])==l_True || !isSelector(var(c[k]))) {
+		      break;
+		    }
+		  }
+
+		}
+	      }
+	      if(choosenPos!=-1) {
+		c[1] = c[choosenPos]; c[choosenPos] = false_lit;
+		watches[~c[1]].push(w);
+		goto NextClause; }
+	    } else {  // ----------------- DEFAULT  MODE (NOT INCREMENTAL)
+	      for (int k = 2; k < c.size(); k++) {
+		
+		if (value(c[k]) != l_False){
+		  c[1] = c[k]; c[k] = false_lit;
+		  watches[~c[1]].push(w);
+		  goto NextClause; }
+	      }
+	    }
+
+            // Did not find watch -- clause is unit under assignment:
+            *j++ = w;
+            if (value(first) == l_False){
+                confl = cr;
+                qhead = trail.size();
+                // Copy the remaining watches:
+                while (i < end)
+                    *j++ = *i++;
+            }else {
+                uncheckedEnqueue(first, cr);
+	  
+		
+	    }
+        NextClause:;
+        }
+        ws.shrink(i - j);
+    }
+    propagations += num_props;
+    simpDB_props -= num_props;
+    
+    return confl;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  reduceDB : ()  ->  [void]
+|  
+|  Description:
+|    Remove half of the learnt clauses, minus the clauses locked by the current assignment. Locked
+|    clauses are clauses that are reason to some assignment. Binary clauses are never removed.
+|________________________________________________________________________________________________@*/
+struct reduceDB_lt { 
+    ClauseAllocator& ca;
+    reduceDB_lt(ClauseAllocator& ca_) : ca(ca_) {}
+    bool operator () (CRef x, CRef y) { 
+/*
+ 
+    // Main criteria... Like in MiniSat we keep all binary clauses
+    if(ca[x].size()> 2 && ca[y].size()==2) return 1;
+    
+    if(ca[y].size()>2 && ca[x].size()==2) return 0;
+    if(ca[x].size()==2 && ca[y].size()==2) return 0;
+    
+    // Second one  based on literal block distance
+    if(ca[x].lbd()> ca[y].lbd()) return 1;
+    if(ca[x].lbd()< ca[y].lbd()) return 0;    
+*/
+    
+    
+    // Finally we can use old activity or size, we choose the last one
+        return ca[x].activity() < ca[y].activity();
+	//return x->size() < y->size();
+
+        //return ca[x].size() > 2 && (ca[y].size() == 2 || ca[x].activity() < ca[y].activity()); } 
+    }    
+};
+
+inline void Solver::reduceDB()
+{
+ 
+  int     i, j;
+  nbReduceDB++;
+  sort(learnts, reduceDB_lt(ca));
+
+  // We have a lot of "good" clauses, it is difficult to compare them. Keep more !
+  //if(ca[learnts[learnts.size() / RATIOREMOVECLAUSES]].lbd()<=3) nbclausesbeforereduce +=specialIncReduceDB; 
+  // Useless :-)
+  //if(ca[learnts.last()].lbd()<=5)  nbclausesbeforereduce +=specialIncReduceDB; 
+  
+  
+  // Don't delete binary or locked clauses. From the rest, delete clauses from the first half
+  // Keep clauses which seem to be usefull (their lbd was reduce during this sequence)
+
+  int limit = learnts.size() / 2;
+
+  for (i = j = 0; i < learnts.size(); i++){
+    Clause& c = ca[learnts[i]];
+  if (!c.M())
+    if (c.lbd()>2 && c.size() > 2 && c.canBeDel() &&  !locked(c) && (i < limit)) {
+      removeClause(learnts[i]);
+      nbRemovedClauses++;
+    }
+    else {
+      if(!c.canBeDel()) limit++; //we keep c, so we can delete an other clause
+      c.setCanBeDel(true);       // At the next step, c can be delete
+      learnts[j++] = learnts[i];
+    }
+  }
+  learnts.shrink(i - j);
+  checkGarbage();
+}
+
+
+inline void Solver::removeSatisfied(vec<CRef>& cs)
+{
+  
+    int i, j;
+    for (i = j = 0; i < cs.size(); i++){
+        Clause& c = ca[cs[i]];
+      if (c.M() == O)
+
+
+        if (satisfied(c)) 
+            removeClause(cs[i]);
+        else
+            cs[j++] = cs[i];
+    }
+    cs.shrink(i - j);
+}
+
+
+inline void Solver::rebuildOrderHeap()
+{
+    vec<Var> vs;
+    for (Var v = 0; v < nVars(); v++)
+        if (decision[v] && value(v) == l_Undef)
+            vs.push(v);
+    order_heap.build(vs);
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  simplify : [void]  ->  [bool]
+|  
+|  Description:
+|    Simplify the clause database according to the current top-level assigment. Currently, the only
+|    thing done here is the removal of satisfied clauses, but more things can be put here.
+|________________________________________________________________________________________________@*/
+inline bool Solver::simplify()
+{
+    assert(decisionLevel() == 0);
+
+    if (!ok || propagate() != CRef_Undef)
+        return ok = false;
+
+    if (nAssigns() == simpDB_assigns || (simpDB_props > 0))
+        return true;
+
+    // Remove satisfied clauses:
+    #define S removeSatisfied
+    O = 3; S(C);
+    O = 2; S(T);
+    O = 0;
+    removeSatisfied(learnts);
+    if (remove_satisfied)        // Can be turned off.
+        removeSatisfied(clauses);
+    checkGarbage();
+    rebuildOrderHeap();
+
+    simpDB_assigns = nAssigns();
+    simpDB_props   = clauses_literals + learnts_literals;   // (shouldn't depend on stats really, but it will do for now)
+
+    return true;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  search : (nof_conflicts : int) (params : const SearchParams&)  ->  [lbool]
+|  
+|  Description:
+|    Search for a model the specified number of conflicts. 
+|    NOTE! Use negative value for 'nof_conflicts' indicate infinity.
+|  
+|  Output:
+|    'l_True' if a partial assigment that is consistent with respect to the clauseset is found. If
+|    all variables are decision variables, this means that the clause set is satisfiable. 'l_False'
+|    if the clause set is unsatisfiable. 'l_Undef' if the bound on number of conflicts is reached.
+|________________________________________________________________________________________________@*/
+inline lbool Solver::search(int& n//of_conflicts
+  )
+{
+    assert(ok);
+    int         backtrack_level;
+    int         conflictC = 0;
+    vec<Lit>    learnt_clause,selectors;
+    unsigned int nblevels,szWoutSelectors;
+    bool blocked=false;
+    starts++;
+    for (;;){
+        CRef confl = propagate();
+        if (confl != CRef_Undef){
+            // CONFLICT
+	  conflicts++; conflictC++;conflictsRestarts++;
+	  Y--; Z--; n--;
+	  if (Q == 100000 && C.size() < 100) A = 6;
+	  if(0 && conflicts%5000==0 && var_decay<0.95)
+            var_decay += 0.01;
+
+	  if (0 && verbosity >= 1 && conflicts%verbEveryConflicts==0){
+	    printf("c | %8d   %7d    %5d | %7d %8d %8d | %5d %8d   %6d %8d | %6.3f %% |\n", 
+		   (int)starts,(int)nbstopsrestarts, (int)(conflicts/starts), 
+		   (int)dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]), nClauses(), (int)clauses_literals, 
+		   (int)nbReduceDB, nLearnts(), (int)nbDL2,(int)nbRemovedClauses, progressEstimate()*100);
+	  }
+	  if (decisionLevel() == 0) {
+	    return l_False;
+	    
+	  }
+	  
+	  /*
+	  trailQueue.push(trail.size());
+	  // BLOCK RESTART (CP 2012 paper)
+	  if( conflictsRestarts>LOWER_BOUND_FOR_BLOCKING_RESTART && lbdQueue.isvalid()  && trail.size()>R*trailQueue.getavg()) {
+	    lbdQueue.fastclear();
+	    nbstopsrestarts++;
+	    if(!blocked) {lastblockatrestart=starts;nbstopsrestartssame++;blocked=true;}
+	  }
+	  */
+
+            learnt_clause.clear();
+	    selectors.clear();
+            analyze(confl, learnt_clause, selectors,backtrack_level,nblevels,szWoutSelectors);
+
+        if (G){
+            H++;
+	    lbdQueue.push(nblevels);
+	    sumLBD += nblevels > 50 ? 50 : nblevels;
+        }
+ 
+
+            cancelUntil(backtrack_level);
+
+            if (certifiedUNSAT) {
+              if (vbyte) {
+                write_char('a');
+                for (int i = 0; i < learnt_clause.size(); i++)
+                  write_lit(2*(var(learnt_clause[i])+1) + sign(learnt_clause[i]));
+                write_lit(0);
+              }
+              else {
+                for (int i = 0; i < learnt_clause.size(); i++)
+                  fprintf(certifiedOutput, "%i " , (var(learnt_clause[i]) + 1) *
+                              (-2 * sign(learnt_clause[i]) + 1) );
+                fprintf(certifiedOutput, "0\n");
+              }
+            }
+
+            if (learnt_clause.size() == 1){
+	      uncheckedEnqueue(learnt_clause[0]);nbUn++;
+            }else{
+                #define EE ca[cr]
+                CRef cr = ca.alloc(learnt_clause, true);
+		ca[cr].setLBD(I = nblevels); 
+		ca[cr].setSizeWithoutSelectors(szWoutSelectors);
+		if(nblevels<=2) nbDL2++; // stats
+		if(ca[cr].size()==2) nbBin++; // stats
+              if (I < A){
+                C.P(cr);
+                EE.M(3);
+              }else if (I < 7){
+                T.P(cr);
+                EE.M(2);
+                EE.t = Q;
+              }else{
+                learnts.push(cr); B(EE); }
+                attachClause(cr);
+
+                //claBumpActivity(ca[cr]);
+                uncheckedEnqueue(learnt_clause[0], cr);
+            }
+            varDecayActivity();
+            claDecayActivity();
+
+           
+        }else{
+	  // Our dynamic restart, see the SAT09 competition compagnion paper 
+	  if ((!G && n <= 0) || (G &&
+	      ( lbdQueue.isvalid() && ((lbdQueue.getavg()*(n > 0 ? K : .9)) > (sumLBD / H//conflictsRestarts
+              ))))) {
+	    lbdQueue.fastclear();
+	    progress_estimate = progressEstimate();
+	    int bt = 0;
+	    if(incremental) { // DO NOT BACKTRACK UNTIL 0.. USELESS
+	      bt = (decisionLevel()<assumptions.size()) ? decisionLevel() : assumptions.size();
+	    }
+	    cancelUntil(bt);
+	    return l_Undef; }
+
+
+           // Simplify the set of problem clauses:
+	  if (decisionLevel() == 0 && !simplify()) {
+	    return l_False;
+	  }
+
+            if (Y <= 0){
+                for (I = Y = 0; I < T.size(); I++){
+                    Clause& c = ca[T[I]];
+                    if (c.M() == 2)
+                        if (!locked(c) && c.t + 30000 < Q){
+                            learnts.P(T[I]);
+                            c.M(0);
+                            c.activity() = 0;
+                            B(c);
+                        }else
+                            T[Y++] = T[I];
+                }
+                T.shrink(I - Y);
+                Y = 10000;
+            }
+
+	    // Perform clause database reduction !
+	    if(Z <= 0)//conflicts>=curRestart* nbclausesbeforereduce) 
+	      {
+	
+		assert(learnts.size()>0);
+		curRestart = (conflicts/ nbclausesbeforereduce)+1;
+		reduceDB();
+		nbclausesbeforereduce += incReduceDB;
+                Z = 15000;
+	      }
+	    
+            Lit next = lit_Undef;
+            while (decisionLevel() < assumptions.size()){
+                // Perform user provided assumption:
+                Lit p = assumptions[decisionLevel()];
+                if (value(p) == l_True){
+                    // Dummy decision level:
+                    newDecisionLevel();
+                }else if (value(p) == l_False){
+                    analyzeFinal(~p, conflict);
+                    return l_False;
+                }else{
+                    next = p;
+                    break;
+                }
+            }
+
+            if (next == lit_Undef){
+                // New variable decision:
+                decisions++;
+                next = pickBranchLit();
+
+                if (next == lit_Undef){
+		  // printf("c last restart ## conflicts  :  %d %d \n",conflictC,decisionLevel());
+		  // Model found:
+		  return l_True;
+		}
+            }
+
+            // Increase decision level and enqueue 'next'
+            newDecisionLevel();
+            uncheckedEnqueue(next);
+        }
+    }
+}
+
+
+inline double Solver::progressEstimate() const
+{
+    double  progress = 0;
+    double  F = 1.0 / nVars();
+
+    for (int i = 0; i <= decisionLevel(); i++){
+        int beg = i == 0 ? 0 : trail_lim[i - 1];
+        int end = i == decisionLevel() ? trail.size() : trail_lim[i];
+        progress += pow(F, i) * (end - beg);
+    }
+
+    return progress / nVars();
+}
+
+inline void Solver::printIncrementalStats() {
+
+  printf("c---------- Glucose Stats -------------------------\n");
+  printf("c restarts              : %lld\n", starts);
+  printf("c nb ReduceDB           : %lld\n", nbReduceDB);
+  printf("c nb removed Clauses    : %lld\n",nbRemovedClauses);
+  printf("c nb learnts DL2        : %lld\n", nbDL2);
+  printf("c nb learnts size 2     : %lld\n", nbBin);
+  printf("c nb learnts size 1     : %lld\n", nbUn);
+
+  printf("c conflicts             : %lld \n",conflicts);
+  printf("c decisions             : %lld\n",decisions);
+  printf("c propagations          : %lld\n",propagations);
+
+  printf("c SAT Calls             : %d in %g seconds\n",nbSatCalls,totalTime4Sat);
+  printf("c UNSAT Calls           : %d in %g seconds\n",nbUnsatCalls,totalTime4Unsat);
+  printf("c--------------------------------------------------\n");
+
+
+}
+
+
+// NOTE: assumptions passed in member-variable 'assumptions'.
+inline lbool Solver::solve_()
+{
+
+  if(incremental && certifiedUNSAT) {
+    printf("Can not use incremental and certified unsat in the same time\n");
+    exit(-1);
+  }
+    model.clear();
+    conflict.clear();
+    if (!ok) return l_False;
+    double curTime = cpuTime();
+
+    
+    solves++;
+            
+
+    
+    lbool   status        = l_Undef;
+    if(!incremental && verbosity>=1) {
+      printf("c ========================================[ MAGIC CONSTANTS ]==============================================\n");
+      printf("c | Constants are supposed to work well together :-)                                                      |\n");
+      printf("c | however, if you find better choices, please let us known...                                           |\n");
+      printf("c |-------------------------------------------------------------------------------------------------------|\n");
+    printf("c |                                |                                |                                     |\n"); 
+    printf("c | - Restarts:                    | - Reduce Clause DB:            | - Minimize Asserting:               |\n");
+    printf("c |   * LBD Queue    : %6d      |   * First     : %6d         |    * size < %3d                     |\n",lbdQueue.maxSize(),nbclausesbeforereduce,lbSizeMinimizingClause);
+    printf("c |   * Trail  Queue : %6d      |   * Inc       : %6d         |    * lbd  < %3d                     |\n",trailQueue.maxSize(),incReduceDB,lbLBDMinimizingClause);
+    printf("c |   * K            : %6.2f      |   * Special   : %6d         |                                     |\n",K,specialIncReduceDB);
+    printf("c |   * R            : %6.2f      |   * Protected :  (lbd)< %2d     |                                     |\n",R,lbLBDFrozenClause);
+    printf("c |                                |                                |                                     |\n"); 
+printf("c ==================================[ Search Statistics (every %6d conflicts) ]=========================\n",verbEveryConflicts);
+      printf("c |                                                                                                       |\n"); 
+
+      printf("c |          RESTARTS           |          ORIGINAL         |              LEARNT              | Progress |\n");
+      printf("c |       NB   Blocked  Avg Cfc |    Vars  Clauses Literals |   Red   Learnts    LBD2  Removed |          |\n");
+      printf("c =========================================================================================================\n");
+    }
+
+    // Search:
+    int curr_restarts = 0, a = 91, w;
+    while (status == l_Undef){
+     w = !H ? 10000 : a + G * a;
+
+     var_decay = G ? .95 : .999;
+     while (status == l_Undef && w > 0)
+      status = search(w); // the parameter is useless in glucose, kept to allow modifications
+
+        //if (!withinBudget()) break;
+        curr_restarts++;
+
+        if (!(G = !G)) a += a / 10;
+    }
+
+    if (!incremental && verbosity >= 1)
+      printf("c =========================================================================================================\n");
+
+
+    if (certifiedUNSAT){ // Want certified output
+      if (status == l_False) {
+        if (vbyte) {
+          write_char('a');
+          write_lit(0);
+          fwrite(b, 1, e, certifiedOutput), e = 0;
+        }
+        else {
+  	  fprintf(certifiedOutput, "0\n");
+        }
+      }
+      fclose(certifiedOutput);
+    }
+
+
+    if (status == l_True){
+        // Extend & copy model:
+        model.growTo(nVars());
+        for (int i = 0; i < nVars(); i++) model[i] = value(i);
+    }else if (status == l_False && conflict.size() == 0)
+        ok = false;
+
+
+
+    cancelUntil(0);
+
+    double finalTime = cpuTime();
+    if(status==l_True) {
+      nbSatCalls++; 
+      totalTime4Sat +=(finalTime-curTime);
+    }
+    if(status==l_False) {
+      nbUnsatCalls++; 
+      totalTime4Unsat +=(finalTime-curTime);
+    }
+
+
+    return status;
+}
+
+//=================================================================================================
+// Writing CNF to DIMACS:
+// 
+// FIXME: this needs to be rewritten completely.
+
+static Var mapVar(Var x, vec<Var>& map, Var& max)
+{
+    if (map.size() <= x || map[x] == -1){
+        map.growTo(x+1, -1);
+        map[x] = max++;
+    }
+    return map[x];
+}
+
+
+inline void Solver::toDimacs(FILE* f, Clause& c, vec<Var>& map, Var& max)
+{
+    if (satisfied(c)) return;
+
+    for (int i = 0; i < c.size(); i++)
+        if (value(c[i]) != l_False)
+            fprintf(f, "%s%d ", sign(c[i]) ? "-" : "", mapVar(var(c[i]), map, max)+1);
+    fprintf(f, "0\n");
+}
+
+
+inline void Solver::toDimacs(const char *file, const vec<Lit>& assumps)
+{
+    FILE* f = fopen(file, "wr");
+    if (f == NULL)
+        fprintf(stderr, "could not open file %s\n", file), exit(1);
+    toDimacs(f, assumps);
+    fclose(f);
+}
+
+
+inline void Solver::toDimacs(FILE* f, const vec<Lit>& assumps)
+{
+    // Handle case when solver is in contradictory state:
+    if (!ok){
+        fprintf(f, "p cnf 1 2\n1 0\n-1 0\n");
+        return; }
+    assumps.copyTo(assumptions);
+
+    vec<Var> map; Var max = 0;
+
+    // Cannot use removeClauses here because it is not safe
+    // to deallocate them at this point. Could be improved.
+    int cnt = 0;
+    for (int i = 0; i < clauses.size(); i++)
+        if (!satisfied(ca[clauses[i]]))
+            cnt++;
+        
+    for (int i = 0; i < clauses.size(); i++)
+        if (!satisfied(ca[clauses[i]])){
+            Clause& c = ca[clauses[i]];
+            for (int j = 0; j < c.size(); j++)
+                if (value(c[j]) != l_False)
+                    mapVar(var(c[j]), map, max);
+        }
+
+    // Assumptions are added as unit clauses:
+    cnt += assumptions.size();
+
+    fprintf(f, "p cnf %d %d\n", max, cnt);
+
+    for (int i = 0; i < assumptions.size(); i++){
+        assert(value(assumptions[i]) != l_False);
+        fprintf(f, "%s%d 0\n", sign(assumptions[i]) ? "-" : "", mapVar(var(assumptions[i]), map, max)+1);
+    }
+
+    for (int i = 0; i < clauses.size(); i++)
+        toDimacs(f, ca[clauses[i]], map, max);
+
+    if (verbosity > 0)
+        printf("Wrote %d clauses with %d variables.\n", cnt, max);
+}
+
+
+//=================================================================================================
+// Garbage Collection methods:
+
+inline void Solver::relocAll(ClauseAllocator& to)
+{
+    // All watchers:
+    //
+    // for (int i = 0; i < watches.size(); i++)
+    watches.cleanAll();
+    watchesBin.cleanAll();
+    for (int v = 0; v < nVars(); v++)
+        for (int s = 0; s < 2; s++){
+            Lit p = mkLit(v, s);
+            // printf(" >>> RELOCING: %s%d\n", sign(p)?"-":"", var(p)+1);
+            vec<Watcher>& ws = watches[p];
+            for (int j = 0; j < ws.size(); j++)
+                ca.reloc(ws[j].cref, to);
+            vec<Watcher>& ws2 = watchesBin[p];
+            for (int j = 0; j < ws2.size(); j++)
+                ca.reloc(ws2[j].cref, to);
+        }
+
+    // All reasons:
+    //
+    for (int i = 0; i < trail.size(); i++){
+        Var v = var(trail[i]);
+
+        if (reason(v) != CRef_Undef && (ca[reason(v)].reloced() || locked(ca[reason(v)])))
+            ca.reloc(vardata[v].reason, to);
+    }
+
+    // All learnt:
+    //
+    #define X(V) for (I = 0; I < V.size();) ca.reloc(V[I++], to);
+    X(C);
+    X(T);
+    for (int i = 0; i < learnts.size(); i++)
+        ca.reloc(learnts[i], to);
+
+    // All original:
+    //
+    for (int i = 0; i < clauses.size(); i++)
+        ca.reloc(clauses[i], to);
+}
+
+
+inline void Solver::garbageCollect()
+{
+    // Initialize the next region to a size corresponding to the estimated utilization degree. This
+    // is not precise but should avoid some unnecessary reallocations for the new region:
+    ClauseAllocator to(ca.size() - ca.wasted()); 
+
+    relocAll(to);
+    if (verbosity >= 2)
+        printf("|  Garbage collection:   %12d bytes => %12d bytes             |\n", 
+               ca.size()*ClauseAllocator::Unit_Size, to.size()*ClauseAllocator::Unit_Size);
+    to.moveTo(ca);
+}
+}
+/************************************************************************************[SimpSolver.h]
+Copyright (c) 2006,      Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Ghack_SimpSolver_h
+#define Ghack_SimpSolver_h
+
+
+
+
+
+namespace GHack {
+
+//=================================================================================================
+
+
+class SimpSolver : public Solver {
+ public:
+    // Constructor/Destructor:
+    //
+    SimpSolver();
+    ~SimpSolver();
+
+    // Problem specification:
+    //
+    Var     newVar    (bool polarity = true, bool dvar = true);
+    bool    addClause (const vec<Lit>& ps);
+    bool    addEmptyClause();                // Add the empty clause to the solver.
+    bool    addClause (Lit p);               // Add a unit clause to the solver.
+    bool    addClause (Lit p, Lit q);        // Add a binary clause to the solver.
+    bool    addClause (Lit p, Lit q, Lit r); // Add a ternary clause to the solver.
+    bool    addClause_(      vec<Lit>& ps);
+    bool    substitute(Var v, Lit x);  // Replace all occurences of v with x (may cause a contradiction).
+
+    // Variable mode:
+    // 
+    void    setFrozen (Var v, bool b); // If a variable is frozen it will not be eliminated.
+    bool    isEliminated(Var v) const;
+
+    // Solving:
+    //
+    bool    solve       (const vec<Lit>& assumps, bool do_simp = true, bool turn_off_simp = false);
+    lbool   solveLimited(const vec<Lit>& assumps, bool do_simp = true, bool turn_off_simp = false);
+    bool    solve       (                     bool do_simp = true, bool turn_off_simp = false);
+    bool    solve       (Lit p       ,        bool do_simp = true, bool turn_off_simp = false);       
+    bool    solve       (Lit p, Lit q,        bool do_simp = true, bool turn_off_simp = false);
+    bool    solve       (Lit p, Lit q, Lit r, bool do_simp = true, bool turn_off_simp = false);
+    bool    eliminate   (bool turn_off_elim = false);  // Perform variable elimination based simplification. 
+
+    // Memory managment:
+    //
+    virtual void garbageCollect();
+
+
+    // Generate a (possibly simplified) DIMACS file:
+    //
+#if 0
+    void    toDimacs  (const char* file, const vec<Lit>& assumps);
+    void    toDimacs  (const char* file);
+    void    toDimacs  (const char* file, Lit p);
+    void    toDimacs  (const char* file, Lit p, Lit q);
+    void    toDimacs  (const char* file, Lit p, Lit q, Lit r);
+#endif
+
+    // Mode of operation:
+    //
+    int     parsing;
+    int     grow;              // Allow a variable elimination step to grow by a number of clauses (default to zero).
+    int     clause_lim;        // Variables are not eliminated if it produces a resolvent with a length above this limit.
+                               // -1 means no limit.
+    int     subsumption_lim;   // Do not check if subsumption against a clause larger than this. -1 means no limit.
+    double  simp_garbage_frac; // A different limit for when to issue a GC during simplification (Also see 'garbage_frac').
+
+    bool    use_asymm;         // Shrink clauses by asymmetric branching.
+    bool    use_rcheck;        // Check if a clause is already implied. Prett costly, and subsumes subsumptions :)
+    bool    use_elim;          // Perform variable elimination.
+
+    // Statistics:
+    //
+    int     merges;
+    int     asymm_lits;
+    int     eliminated_vars;
+
+ protected:
+
+    // Helper structures:
+    //
+    struct ElimLt {
+        const vec<int>& n_occ;
+        explicit ElimLt(const vec<int>& no) : n_occ(no) {}
+
+        // TODO: are 64-bit operations here noticably bad on 32-bit platforms? Could use a saturating
+        // 32-bit implementation instead then, but this will have to do for now.
+        uint64_t cost  (Var x)        const { return (uint64_t)n_occ[toInt(mkLit(x))] * (uint64_t)n_occ[toInt(~mkLit(x))]; }
+        bool operator()(Var x, Var y) const { return cost(x) < cost(y); }
+        
+        // TODO: investigate this order alternative more.
+        // bool operator()(Var x, Var y) const { 
+        //     int c_x = cost(x);
+        //     int c_y = cost(y);
+        //     return c_x < c_y || c_x == c_y && x < y; }
+    };
+
+    struct ClauseDeleted {
+        const ClauseAllocator& ca;
+        explicit ClauseDeleted(const ClauseAllocator& _ca) : ca(_ca) {}
+        bool operator()(const CRef& cr) const { return ca[cr].mark() == 1; } };
+
+    // Solver state:
+    //
+    int                 elimorder;
+    bool                use_simplification;
+    vec<uint32_t>       elimclauses;
+    vec<char>           touched;
+    OccLists<Var, vec<CRef>, ClauseDeleted>
+                        occurs;
+    vec<int>            n_occ;
+    Heap<ElimLt>        elim_heap;
+    Queue<CRef>         subsumption_queue;
+    vec<char>           frozen;
+    vec<char>           eliminated;
+    int                 bwdsub_assigns;
+    int                 n_touched;
+
+    // Temporaries:
+    //
+    CRef                bwdsub_tmpunit;
+
+    // Main internal methods:
+    //
+    lbool         solve_                   (bool do_simp = true, bool turn_off_simp = false);
+    bool          asymm                    (Var v, CRef cr);
+    bool          asymmVar                 (Var v);
+    void          updateElimHeap           (Var v);
+    void          gatherTouchedClauses     ();
+    bool          merge                    (const Clause& _ps, const Clause& _qs, Var v, vec<Lit>& out_clause);
+    bool          merge                    (const Clause& _ps, const Clause& _qs, Var v, int& size);
+    bool          backwardSubsumptionCheck (bool verbose = false);
+    bool          eliminateVar             (Var v);
+    void          extendModel              ();
+
+    void          removeClause             (CRef cr);
+    bool          strengthenClause         (CRef cr, Lit l);
+    void          cleanUpClauses           ();
+    bool          implied                  (const vec<Lit>& c);
+    void          relocAll                 (ClauseAllocator& to);
+};
+
+
+//=================================================================================================
+// Implementation of inline methods:
+
+
+inline bool SimpSolver::isEliminated (Var v) const { return eliminated[v]; }
+inline void SimpSolver::updateElimHeap(Var v) {
+    assert(use_simplification);
+    // if (!frozen[v] && !isEliminated(v) && value(v) == l_Undef)
+    if (elim_heap.inHeap(v) || (!frozen[v] && !isEliminated(v) && value(v) == l_Undef))
+        elim_heap.update(v); }
+
+
+inline bool SimpSolver::addClause    (const vec<Lit>& ps)    { ps.copyTo(add_tmp); return addClause_(add_tmp); }
+inline bool SimpSolver::addEmptyClause()                     { add_tmp.clear(); return addClause_(add_tmp); }
+inline bool SimpSolver::addClause    (Lit p)                 { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); }
+inline bool SimpSolver::addClause    (Lit p, Lit q)          { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); }
+inline bool SimpSolver::addClause    (Lit p, Lit q, Lit r)   { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); }
+inline void SimpSolver::setFrozen    (Var v, bool b) { frozen[v] = (char)b; if (use_simplification && !b) { updateElimHeap(v); } }
+
+inline bool SimpSolver::solve        (                     bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (Lit p       ,        bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (Lit p, Lit q,        bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (Lit p, Lit q, Lit r, bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (const vec<Lit>& assumps, bool do_simp, bool turn_off_simp){ 
+    budgetOff(); assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp) == l_True; }
+
+inline lbool SimpSolver::solveLimited (const vec<Lit>& assumps, bool do_simp, bool turn_off_simp){ 
+    assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp); }
+
+//=================================================================================================
+}
+
+#endif
+/***********************************************************************************[SimpSolver.cc]
+Copyright (c) 2006,      Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+
+
+
+namespace GHack {
+
+//=================================================================================================
+// Options:
+
+
+static BoolOption   opt_use_asymm        ("SIMP", "asymm",        "Shrink clauses by asymmetric branching.", false);
+static BoolOption   opt_use_rcheck       ("SIMP", "rcheck",       "Check if a clause is already implied. (costly)", false);
+static BoolOption   opt_use_elim         ("SIMP", "elim",         "Perform variable elimination.", true);
+static IntOption    opt_grow             ("SIMP", "grow",         "Allow a variable elimination step to grow by a number of clauses.", 0);
+static IntOption    opt_clause_lim       ("SIMP", "cl-lim",       "Variables are not eliminated if it produces a resolvent with a length above this limit. -1 means no limit", 20,   IntRange(-1, INT32_MAX));
+static IntOption    opt_subsumption_lim  ("SIMP", "sub-lim",      "Do not check if subsumption against a clause larger than this. -1 means no limit.", 1000, IntRange(-1, INT32_MAX));
+static DoubleOption opt_simp_garbage_frac("SIMP", "simp-gc-frac", "The fraction of wasted memory allowed before a garbage collection is triggered during simplification.",  0.5, DoubleRange(0, false, HUGE_VAL, false));
+
+
+//=================================================================================================
+// Constructor/Destructor:
+
+
+inline SimpSolver::SimpSolver() :
+    grow               (opt_grow)
+  , clause_lim         (opt_clause_lim)
+  , subsumption_lim    (opt_subsumption_lim)
+  , simp_garbage_frac  (opt_simp_garbage_frac)
+  , use_asymm          (opt_use_asymm)
+  , use_rcheck         (opt_use_rcheck)
+  , use_elim           (opt_use_elim)
+  , merges             (0)
+  , asymm_lits         (0)
+  , eliminated_vars    (0)
+  , elimorder          (1)
+  , use_simplification (true)
+  , occurs             (ClauseDeleted(ca))
+  , elim_heap          (ElimLt(n_occ))
+  , bwdsub_assigns     (0)
+  , n_touched          (0)
+{
+    vec<Lit> dummy(1,lit_Undef);
+    ca.extra_clause_field = true; // NOTE: must happen before allocating the dummy clause below.
+    bwdsub_tmpunit        = ca.alloc(dummy);
+    remove_satisfied      = false;
+}
+
+
+inline SimpSolver::~SimpSolver()
+{
+}
+
+
+inline Var SimpSolver::newVar(bool sign, bool dvar) {
+    Var v = Solver::newVar(sign, dvar);
+
+    frozen    .push((char)false);
+    eliminated.push((char)false);
+
+    if (use_simplification){
+        n_occ     .push(0);
+        n_occ     .push(0);
+        occurs    .init(v);
+        touched   .push(0);
+        elim_heap .insert(v);
+    }
+    return v; }
+
+
+
+inline lbool SimpSolver::solve_(bool do_simp, bool turn_off_simp)
+{
+    vec<Var> extra_frozen;
+    lbool    result = l_True;
+
+    do_simp &= use_simplification;
+
+    if (do_simp){
+        // Assumptions must be temporarily frozen to run variable elimination:
+        for (int i = 0; i < assumptions.size(); i++){
+            Var v = var(assumptions[i]);
+
+            // If an assumption has been eliminated, remember it.
+            assert(!isEliminated(v));
+
+            if (!frozen[v]){
+                // Freeze and store.
+                setFrozen(v, true);
+                extra_frozen.push(v);
+            } }
+
+        result = lbool(eliminate(turn_off_simp));
+    }
+
+    if (result == l_True)
+        result = Solver::solve_();
+    else if (verbosity >= 1)
+        printf("===============================================================================\n");
+
+    if (result == l_True)
+        extendModel();
+
+    if (do_simp)
+        // Unfreeze the assumptions that were frozen:
+        for (int i = 0; i < extra_frozen.size(); i++)
+            setFrozen(extra_frozen[i], false);
+
+    return result;
+}
+
+
+
+inline bool SimpSolver::addClause_(vec<Lit>& ps)
+{
+#ifndef NDEBUG
+    for (int i = 0; i < ps.size(); i++)
+        assert(!isEliminated(var(ps[i])));
+#endif
+    int nclauses = clauses.size();
+
+    if (use_rcheck && implied(ps))
+        return true;
+
+    if (!Solver::addClause_(ps))
+        return false;
+
+    if(!parsing && certifiedUNSAT) {
+      if (vbyte) {
+        write_char('a');
+        for (int i = 0; i < ps.size(); i++)
+          write_lit(2*(var(ps[i])+1) + sign(ps[i]));
+        write_lit(0);
+      }
+      else {
+        for (int i = 0; i < ps.size(); i++)
+          fprintf(certifiedOutput, "%i " , (var(ps[i]) + 1) * (-2 * sign(ps[i]) + 1) );
+        fprintf(certifiedOutput, "0\n");
+      }
+    }
+
+    if (use_simplification && clauses.size() == nclauses + 1){
+        CRef          cr = clauses.last();
+        const Clause& c  = ca[cr];
+
+        // NOTE: the clause is added to the queue immediately and then
+        // again during 'gatherTouchedClauses()'. If nothing happens
+        // in between, it will only be checked once. Otherwise, it may
+        // be checked twice unnecessarily. This is an unfortunate
+        // consequence of how backward subsumption is used to mimic
+        // forward subsumption.
+        subsumption_queue.insert(cr);
+        for (int i = 0; i < c.size(); i++){
+            occurs[var(c[i])].push(cr);
+            n_occ[toInt(c[i])]++;
+            touched[var(c[i])] = 1;
+            n_touched++;
+            if (elim_heap.inHeap(var(c[i])))
+                elim_heap.increase(var(c[i]));
+        }
+    }
+
+    return true;
+}
+
+
+inline void SimpSolver::removeClause(CRef cr)
+{
+    const Clause& c = ca[cr];
+
+    if (use_simplification)
+        for (int i = 0; i < c.size(); i++){
+            n_occ[toInt(c[i])]--;
+            updateElimHeap(var(c[i]));
+            occurs.smudge(var(c[i]));
+        }
+
+    Solver::removeClause(cr);
+}
+
+
+inline bool SimpSolver::strengthenClause(CRef cr, Lit l)
+{
+    Clause& c = ca[cr];
+    assert(decisionLevel() == 0);
+    assert(use_simplification);
+
+    // FIX: this is too inefficient but would be nice to have (properly implemented)
+    // if (!find(subsumption_queue, &c))
+    subsumption_queue.insert(cr);
+
+    if (certifiedUNSAT) {
+      if (vbyte) {
+        write_char('a');
+        for (int i = 0; i < c.size(); i++)
+          if (c[i] != l) write_lit(2*(var(c[i])+1) + sign(c[i]));
+        write_lit(0);
+      }
+      else {
+        for (int i = 0; i < c.size(); i++)
+          if (c[i] != l) fprintf(certifiedOutput, "%i " , (var(c[i]) + 1) * (-2 * sign(c[i]) + 1) );
+        fprintf(certifiedOutput, "0\n");
+      }
+    }
+
+    if (c.size() == 2){
+        removeClause(cr);
+        c.strengthen(l);
+    }else{
+        if (certifiedUNSAT) {
+          if (vbyte) {
+            write_char('d');
+            for (int i = 0; i < c.size(); i++)
+              write_lit(2*(var(c[i])+1) + sign(c[i]));
+            write_lit(0);
+          }
+          else {
+            fprintf(certifiedOutput, "d ");
+            for (int i = 0; i < c.size(); i++)
+              fprintf(certifiedOutput, "%i " , (var(c[i]) + 1) * (-2 * sign(c[i]) + 1) );
+            fprintf(certifiedOutput, "0\n");
+          }
+        }
+
+        detachClause(cr, true);
+        c.strengthen(l);
+        attachClause(cr);
+        remove(occurs[var(l)], cr);
+        n_occ[toInt(l)]--;
+        updateElimHeap(var(l));
+    }
+
+    return c.size() == 1 ? enqueue(c[0]) && propagate() == CRef_Undef : true;
+}
+
+
+// Returns FALSE if clause is always satisfied ('out_clause' should not be used).
+inline bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, vec<Lit>& out_clause)
+{
+    merges++;
+    out_clause.clear();
+
+    bool  ps_smallest = _ps.size() < _qs.size();
+    const Clause& ps  =  ps_smallest ? _qs : _ps;
+    const Clause& qs  =  ps_smallest ? _ps : _qs;
+
+    for (int i = 0; i < qs.size(); i++){
+        if (var(qs[i]) != v){
+            for (int j = 0; j < ps.size(); j++)
+                if (var(ps[j]) == var(qs[i]))
+                    if (ps[j] == ~qs[i])
+                        return false;
+                    else
+                        goto next;
+            out_clause.push(qs[i]);
+        }
+        next:;
+    }
+
+    for (int i = 0; i < ps.size(); i++)
+        if (var(ps[i]) != v)
+            out_clause.push(ps[i]);
+
+    return true;
+}
+
+
+// Returns FALSE if clause is always satisfied.
+inline bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, int& size)
+{
+    merges++;
+
+    bool  ps_smallest = _ps.size() < _qs.size();
+    const Clause& ps  =  ps_smallest ? _qs : _ps;
+    const Clause& qs  =  ps_smallest ? _ps : _qs;
+    const Lit*  __ps  = (const Lit*)ps;
+    const Lit*  __qs  = (const Lit*)qs;
+
+    size = ps.size()-1;
+
+    for (int i = 0; i < qs.size(); i++){
+        if (var(__qs[i]) != v){
+            for (int j = 0; j < ps.size(); j++)
+                if (var(__ps[j]) == var(__qs[i]))
+                    if (__ps[j] == ~__qs[i])
+                        return false;
+                    else
+                        goto next;
+            size++;
+        }
+        next:;
+    }
+
+    return true;
+}
+
+
+inline void SimpSolver::gatherTouchedClauses()
+{
+    if (n_touched == 0) return;
+
+    int i,j;
+    for (i = j = 0; i < subsumption_queue.size(); i++)
+        if (ca[subsumption_queue[i]].mark() == 0)
+            ca[subsumption_queue[i]].mark(2);
+
+    for (i = 0; i < touched.size(); i++)
+        if (touched[i]){
+            const vec<CRef>& cs = occurs.lookup(i);
+            for (j = 0; j < cs.size(); j++)
+                if (ca[cs[j]].mark() == 0){
+                    subsumption_queue.insert(cs[j]);
+                    ca[cs[j]].mark(2);
+                }
+            touched[i] = 0;
+        }
+
+    for (i = 0; i < subsumption_queue.size(); i++)
+        if (ca[subsumption_queue[i]].mark() == 2)
+            ca[subsumption_queue[i]].mark(0);
+
+    n_touched = 0;
+}
+
+
+inline bool SimpSolver::implied(const vec<Lit>& c)
+{
+    assert(decisionLevel() == 0);
+
+    trail_lim.push(trail.size());
+    for (int i = 0; i < c.size(); i++)
+        if (value(c[i]) == l_True){
+            cancelUntil(0);
+            return false;
+        }else if (value(c[i]) != l_False){
+            assert(value(c[i]) == l_Undef);
+            uncheckedEnqueue(~c[i]);
+        }
+
+    bool result = propagate() != CRef_Undef;
+    cancelUntil(0);
+    return result;
+}
+
+
+// Backward subsumption + backward subsumption resolution
+inline bool SimpSolver::backwardSubsumptionCheck(bool verbose)
+{
+    int cnt = 0;
+    int subsumed = 0;
+    int deleted_literals = 0;
+    assert(decisionLevel() == 0);
+
+    while (subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()){
+
+        // Empty subsumption queue and return immediately on user-interrupt:
+        if (asynch_interrupt){
+            subsumption_queue.clear();
+            bwdsub_assigns = trail.size();
+            break; }
+
+        // Check top-level assignments by creating a dummy clause and placing it in the queue:
+        if (subsumption_queue.size() == 0 && bwdsub_assigns < trail.size()){
+            Lit l = trail[bwdsub_assigns++];
+            ca[bwdsub_tmpunit][0] = l;
+            ca[bwdsub_tmpunit].calcAbstraction();
+            subsumption_queue.insert(bwdsub_tmpunit); }
+
+        CRef    cr = subsumption_queue.peek(); subsumption_queue.pop();
+        Clause& c  = ca[cr];
+
+        if (c.mark()) continue;
+
+        if (verbose && verbosity >= 2 && cnt++ % 1000 == 0)
+            printf("subsumption left: %10d (%10d subsumed, %10d deleted literals)\r", subsumption_queue.size(), subsumed, deleted_literals);
+
+        assert(c.size() > 1 || value(c[0]) == l_True);    // Unit-clauses should have been propagated before this point.
+
+        // Find best variable to scan:
+        Var best = var(c[0]);
+        for (int i = 1; i < c.size(); i++)
+            if (occurs[var(c[i])].size() < occurs[best].size())
+                best = var(c[i]);
+
+        // Search all candidates:
+        vec<CRef>& _cs = occurs.lookup(best);
+        CRef*       cs = (CRef*)_cs;
+
+        for (int j = 0; j < _cs.size(); j++)
+            if (c.mark())
+                break;
+            else if (!ca[cs[j]].mark() &&  cs[j] != cr && (subsumption_lim == -1 || ca[cs[j]].size() < subsumption_lim)){
+                Lit l = c.subsumes(ca[cs[j]]);
+
+                if (l == lit_Undef)
+                    subsumed++, removeClause(cs[j]);
+                else if (l != lit_Error){
+                    deleted_literals++;
+
+                    if (!strengthenClause(cs[j], ~l))
+                        return false;
+
+                    // Did current candidate get deleted from cs? Then check candidate at index j again:
+                    if (var(l) == best)
+                        j--;
+                }
+            }
+    }
+
+    return true;
+}
+
+
+inline bool SimpSolver::asymm(Var v, CRef cr)
+{
+    Clause& c = ca[cr];
+    assert(decisionLevel() == 0);
+
+    if (c.mark() || satisfied(c)) return true;
+
+    trail_lim.push(trail.size());
+    Lit l = lit_Undef;
+    for (int i = 0; i < c.size(); i++)
+        if (var(c[i]) != v && value(c[i]) != l_False)
+            uncheckedEnqueue(~c[i]);
+        else
+            l = c[i];
+
+    if (propagate() != CRef_Undef){
+        cancelUntil(0);
+        asymm_lits++;
+        if (!strengthenClause(cr, l))
+            return false;
+    }else
+        cancelUntil(0);
+
+    return true;
+}
+
+
+inline bool SimpSolver::asymmVar(Var v)
+{
+    assert(use_simplification);
+
+    const vec<CRef>& cls = occurs.lookup(v);
+
+    if (value(v) != l_Undef || cls.size() == 0)
+        return true;
+
+    for (int i = 0; i < cls.size(); i++)
+        if (!asymm(v, cls[i]))
+            return false;
+
+    return backwardSubsumptionCheck();
+}
+
+
+static void mkElimClause(vec<uint32_t>& elimclauses, Lit x)
+{
+    elimclauses.push(toInt(x));
+    elimclauses.push(1);
+}
+
+
+static void mkElimClause(vec<uint32_t>& elimclauses, Var v, Clause& c)
+{
+    int first = elimclauses.size();
+    int v_pos = -1;
+
+    // Copy clause to elimclauses-vector. Remember position where the
+    // variable 'v' occurs:
+    for (int i = 0; i < c.size(); i++){
+        elimclauses.push(toInt(c[i]));
+        if (var(c[i]) == v)
+            v_pos = i + first;
+    }
+    assert(v_pos != -1);
+
+    // Swap the first literal with the 'v' literal, so that the literal
+    // containing 'v' will occur first in the clause:
+    uint32_t tmp = elimclauses[v_pos];
+    elimclauses[v_pos] = elimclauses[first];
+    elimclauses[first] = tmp;
+
+    // Store the length of the clause last:
+    elimclauses.push(c.size());
+}
+
+
+
+inline bool SimpSolver::eliminateVar(Var v)
+{
+    assert(!frozen[v]);
+    assert(!isEliminated(v));
+    assert(value(v) == l_Undef);
+
+    // Split the occurrences into positive and negative:
+    //
+    const vec<CRef>& cls = occurs.lookup(v);
+    vec<CRef>        pos, neg;
+    for (int i = 0; i < cls.size(); i++)
+        (find(ca[cls[i]], mkLit(v)) ? pos : neg).push(cls[i]);
+
+    // Check wether the increase in number of clauses stays within the allowed ('grow'). Moreover, no
+    // clause must exceed the limit on the maximal clause size (if it is set):
+    //
+    int cnt         = 0;
+    int clause_size = 0;
+
+    for (int i = 0; i < pos.size(); i++)
+        for (int j = 0; j < neg.size(); j++)
+            if (merge(ca[pos[i]], ca[neg[j]], v, clause_size) && 
+                (++cnt > cls.size() + grow || (clause_lim != -1 && clause_size > clause_lim)))
+                return true;
+
+    // Delete and store old clauses:
+    eliminated[v] = true;
+    setDecisionVar(v, false);
+    eliminated_vars++;
+
+    if (pos.size() > neg.size()){
+        for (int i = 0; i < neg.size(); i++)
+            mkElimClause(elimclauses, v, ca[neg[i]]);
+        mkElimClause(elimclauses, mkLit(v));
+    }else{
+        for (int i = 0; i < pos.size(); i++)
+            mkElimClause(elimclauses, v, ca[pos[i]]);
+        mkElimClause(elimclauses, ~mkLit(v));
+    }
+
+
+    // Produce clauses in cross product:
+    vec<Lit>& resolvent = add_tmp;
+    for (int i = 0; i < pos.size(); i++)
+        for (int j = 0; j < neg.size(); j++)
+            if (merge(ca[pos[i]], ca[neg[j]], v, resolvent) && !addClause_(resolvent))
+                return false;
+
+    for (int i = 0; i < cls.size(); i++)
+        removeClause(cls[i]);
+
+    // Free occurs list for this variable:
+    occurs[v].clear(true);
+
+    // Free watchers lists for this variable, if possible:
+    if (watches[ mkLit(v)].size() == 0) watches[ mkLit(v)].clear(true);
+    if (watches[~mkLit(v)].size() == 0) watches[~mkLit(v)].clear(true);
+
+    return backwardSubsumptionCheck();
+}
+
+
+inline bool SimpSolver::substitute(Var v, Lit x)
+{
+    assert(!frozen[v]);
+    assert(!isEliminated(v));
+    assert(value(v) == l_Undef);
+
+    if (!ok) return false;
+
+    eliminated[v] = true;
+    setDecisionVar(v, false);
+    const vec<CRef>& cls = occurs.lookup(v);
+    
+    vec<Lit>& subst_clause = add_tmp;
+    for (int i = 0; i < cls.size(); i++){
+        Clause& c = ca[cls[i]];
+
+        subst_clause.clear();
+        for (int j = 0; j < c.size(); j++){
+            Lit p = c[j];
+            subst_clause.push(var(p) == v ? x ^ sign(p) : p);
+        }
+
+ 
+        if (!addClause_(subst_clause))
+            return ok = false;
+
+       removeClause(cls[i]);
+ 
+   }
+
+    return true;
+}
+
+
+inline void SimpSolver::extendModel()
+{
+    int i, j;
+    Lit x;
+
+    for (i = elimclauses.size()-1; i > 0; i -= j){
+        for (j = elimclauses[i--]; j > 1; j--, i--)
+            if (modelValue(toLit(elimclauses[i])) != l_False)
+                goto next;
+
+        x = toLit(elimclauses[i]);
+        model[var(x)] = lbool(!sign(x));
+    next:;
+    }
+}
+
+
+inline bool SimpSolver::eliminate(bool turn_off_elim)
+{
+    if (!simplify())
+        return false;
+    else if (!use_simplification)
+        return true;
+
+    // Main simplification loop:
+    //
+
+    int toPerform = 1; clauses.size()<=4800000;
+    
+    if(!toPerform) {
+      printf("c Too many clauses... No preprocessing\n");
+    }
+
+    while (toPerform && (n_touched > 0 || bwdsub_assigns < trail.size() || elim_heap.size() > 0)){
+
+        gatherTouchedClauses();
+        // printf("  ## (time = %6.2f s) BWD-SUB: queue = %d, trail = %d\n", cpuTime(), subsumption_queue.size(), trail.size() - bwdsub_assigns);
+        if ((subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()) && 
+            !backwardSubsumptionCheck(true)){
+            ok = false; goto cleanup; }
+
+        // Empty elim_heap and return immediately on user-interrupt:
+        if (asynch_interrupt){
+            assert(bwdsub_assigns == trail.size());
+            assert(subsumption_queue.size() == 0);
+            assert(n_touched == 0);
+            elim_heap.clear();
+            goto cleanup; }
+
+        // printf("  ## (time = %6.2f s) ELIM: vars = %d\n", cpuTime(), elim_heap.size());
+        for (int cnt = 0; !elim_heap.empty(); cnt++){
+            Var elim = elim_heap.removeMin();
+            
+            if (asynch_interrupt) break;
+
+            if (isEliminated(elim) || value(elim) != l_Undef) continue;
+
+            if (verbosity >= 2 && cnt % 100 == 0)
+                printf("elimination left: %10d\r", elim_heap.size());
+
+            if (use_asymm){
+                // Temporarily freeze variable. Otherwise, it would immediately end up on the queue again:
+                bool was_frozen = frozen[elim];
+                frozen[elim] = true;
+                if (!asymmVar(elim)){
+                    ok = false; goto cleanup; }
+                frozen[elim] = was_frozen; }
+
+            // At this point, the variable may have been set by assymetric branching, so check it
+            // again. Also, don't eliminate frozen variables:
+            if (use_elim && value(elim) == l_Undef && !frozen[elim] && !eliminateVar(elim)){
+                ok = false; goto cleanup; }
+
+            checkGarbage(simp_garbage_frac);
+        }
+
+        assert(subsumption_queue.size() == 0);
+    }
+ cleanup:
+
+    // If no more simplification is needed, free all simplification-related data structures:
+    if (turn_off_elim){
+        touched  .clear(true);
+        occurs   .clear(true);
+        n_occ    .clear(true);
+        elim_heap.clear(true);
+        subsumption_queue.clear(true);
+
+        use_simplification    = false;
+        remove_satisfied      = true;
+        ca.extra_clause_field = false;
+
+        // Force full cleanup (this is safe and desirable since it only happens once):
+        rebuildOrderHeap();
+        garbageCollect();
+    }else{
+        // Cheaper cleanup:
+        cleanUpClauses(); // TODO: can we make 'cleanUpClauses()' not be linear in the problem size somehow?
+        checkGarbage();
+    }
+
+    if (verbosity >= 1 && elimclauses.size() > 0)
+        printf("c |  Eliminated clauses:     %10.2f Mb                                                                |\n", 
+               double(elimclauses.size() * sizeof(uint32_t)) / (1024*1024));
+
+    return ok;
+}
+
+
+inline void SimpSolver::cleanUpClauses()
+{
+    occurs.cleanAll();
+    int i,j;
+    for (i = j = 0; i < clauses.size(); i++)
+        if (ca[clauses[i]].mark() == 0)
+            clauses[j++] = clauses[i];
+    clauses.shrink(i - j);
+}
+
+
+//=================================================================================================
+// Garbage Collection methods:
+
+
+inline void SimpSolver::relocAll(ClauseAllocator& to)
+{
+    if (!use_simplification) return;
+
+    // All occurs lists:
+    //
+    for (int i = 0; i < nVars(); i++){
+        vec<CRef>& cs = occurs[i];
+        for (int j = 0; j < cs.size(); j++)
+            ca.reloc(cs[j], to);
+    }
+
+    // Subsumption queue:
+    //
+    for (int i = 0; i < subsumption_queue.size(); i++)
+        ca.reloc(subsumption_queue[i], to);
+
+    // Temporary clause:
+    //
+    ca.reloc(bwdsub_tmpunit, to);
+}
+
+
+inline void SimpSolver::garbageCollect()
+{
+    // Initialize the next region to a size corresponding to the estimated utilization degree. This
+    // is not precise but should avoid some unnecessary reallocations for the new region:
+    ClauseAllocator to(ca.size() - ca.wasted()); 
+
+    cleanUpClauses();
+    to.extra_clause_field = ca.extra_clause_field; // NOTE: this is important to keep (or lose) the extra fields.
+    relocAll(to);
+    Solver::relocAll(to);
+    if (verbosity >= 2)
+        printf("|  Garbage collection:   %12d bytes => %12d bytes             |\n", 
+               ca.size()*ClauseAllocator::Unit_Size, to.size()*ClauseAllocator::Unit_Size);
+    to.moveTo(ca);
+}
+}
+
+#undef write_char
+#undef var_Undef
+#undef DYNAMICNBLEVEL
+#undef CONSTANTREMOVECLAUSE
+#undef UPDATEVARACTIVITY
+#undef RATIOREMOVECLAUSES
+#undef LOWER_BOUND_FOR_BLOCKING_RESTART
+#undef M
+#undef Q
+#undef P
+#undef B
+#undef S
+#undef EE
+#undef X
diff --git a/lib/bill/bill/sat/solver/glucose.hpp b/lib/bill/bill/sat/solver/glucose.hpp
new file mode 100644
index 0000000..6494557
--- /dev/null
+++ b/lib/bill/bill/sat/solver/glucose.hpp
@@ -0,0 +1,6178 @@
+/**************************************************************************************[IntTypes.h]
+Copyright (c) 2009-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#pragma once
+
+#ifndef Glucose_IntTypes_h
+#define Glucose_IntTypes_h
+
+#ifdef __sun
+    // Not sure if there are newer versions that support C99 headers. The
+    // needed features are implemented in the headers below though:
+
+#   include <sys/int_types.h>
+#   include <sys/int_fmtio.h>
+#   include <sys/int_limits.h>
+
+#else
+
+#   include <stdint.h>
+#   include <inttypes.h>
+
+#endif
+
+#include <limits.h>
+
+#ifndef PRIu64
+#define PRIu64 "lu"
+#define PRIi64 "ld"
+#endif
+//=================================================================================================
+
+#endif
+/****************************************************************************************[XAlloc.h]
+Copyright (c) 2009-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Glucose_XAlloc_h
+#define Glucose_XAlloc_h
+
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+namespace Glucose {
+
+//=================================================================================================
+// Simple layer on top of malloc/realloc to catch out-of-memory situtaions and provide some typing:
+
+class OutOfMemoryException{};
+static inline void* xrealloc(void *ptr, size_t size)
+{
+    void* mem = realloc(ptr, size);
+    if (mem == NULL && errno == ENOMEM){
+        throw OutOfMemoryException();
+    }else {
+        return mem;
+	}
+}
+
+//=================================================================================================
+}
+
+#endif
+/*******************************************************************************************[Vec.h]
+Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_Vec_h
+#define Glucose_Vec_h
+
+#include <assert.h>
+#include <new>
+
+
+
+#include<string.h>
+
+namespace Glucose {
+
+//=================================================================================================
+// Automatically resizable arrays
+//
+// NOTE! Don't use this vector on datatypes that cannot be re-located in memory (with realloc)
+
+template<class T>
+class vec {
+    T*  data;
+    int sz;
+    int cap;
+
+    // Don't allow copying (error prone):
+    vec<T>&  operator = (vec<T>& other) { assert(0); return *this; }
+             vec        (vec<T>& other) { assert(0); }
+             
+    // Helpers for calculating next capacity:
+    static inline int  imax   (int x, int y) { int mask = (y-x) >> (sizeof(int)*8-1); return (x&mask) + (y&(~mask)); }
+    //static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; }
+    static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; }
+
+public:
+    // Constructors:
+    vec()                       : data(NULL) , sz(0)   , cap(0)    { }
+    explicit vec(int size)      : data(NULL) , sz(0)   , cap(0)    { growTo(size); }
+    vec(int size, const T& pad) : data(NULL) , sz(0)   , cap(0)    { growTo(size, pad); }
+   ~vec()                                                          { clear(true); }
+
+    // Pointer to first element:
+    operator T*       (void)           { return data; }
+
+    // Size operations:
+    int      size     (void) const     { return sz; }
+    void     shrink   (int nelems)     { assert(nelems <= sz); for (int i = 0; i < nelems; i++) sz--, data[sz].~T(); }
+    void     shrink_  (int nelems)     { assert(nelems <= sz); sz -= nelems; }
+    int      capacity (void) const     { return cap; }
+    void     capacity (int min_cap);
+    void     growTo   (int size);
+    void     growTo   (int size, const T& pad);
+    void     clear    (bool dealloc = false);
+
+    // Stack interface:
+    void     push  (void)              { if (sz == cap) capacity(sz+1); new (&data[sz]) T(); sz++; }
+    void     push  (const T& elem)     { if (sz == cap) capacity(sz+1); data[sz++] = elem; }
+    void     push_ (const T& elem)     { assert(sz < cap); data[sz++] = elem; }
+    void     pop   (void)              { assert(sz > 0); sz--, data[sz].~T(); }
+    
+    void     remove(const T &elem) {
+        int tmp;
+        for(tmp = 0;tmp<sz;tmp++) {
+            if(data[tmp]==elem) 
+                break;
+        }
+        if(tmp<sz) {
+            assert(data[tmp] == elem);
+            data[tmp] = data[sz-1];
+            sz = sz - 1;
+        }
+        
+    }
+    
+    // NOTE: it seems possible that overflow can happen in the 'sz+1' expression of 'push()', but
+    // in fact it can not since it requires that 'cap' is equal to INT_MAX. This in turn can not
+    // happen given the way capacities are calculated (below). Essentially, all capacities are
+    // even, but INT_MAX is odd.
+
+    const T& last  (void) const        { return data[sz-1]; }
+    T&       last  (void)              { return data[sz-1]; }
+
+    // Vector interface:
+    const T& operator [] (int index) const { return data[index]; }
+    T&       operator [] (int index)       { return data[index]; }
+
+    // Duplicatation (preferred instead):
+    void copyTo(vec<T>& copy) const { copy.clear(); copy.growTo(sz); for (int i = 0; i < sz; i++) copy[i] = data[i]; }
+    void moveTo(vec<T>& dest) { dest.clear(true); dest.data = data; dest.sz = sz; dest.cap = cap; data = NULL; sz = 0; cap = 0; }
+    void memCopyTo(vec<T>& copy) const{
+        copy.capacity(cap);
+        copy.sz = sz;
+        memcpy(copy.data,data,sizeof(T)*cap);
+    }
+
+};
+
+
+template<class T>
+void vec<T>::capacity(int min_cap) {
+    if (cap >= min_cap) return;
+    int add = imax((min_cap - cap + 1) & ~1, ((cap >> 1) + 2) & ~1);   // NOTE: grow by approximately 3/2
+    if (add > INT_MAX - cap || (((data = (T*)::realloc(data, (cap += add) * sizeof(T))) == NULL) && errno == ENOMEM))
+        throw OutOfMemoryException();
+ }
+
+
+template<class T>
+void vec<T>::growTo(int size, const T& pad) {
+    if (sz >= size) return;
+    capacity(size);
+    for (int i = sz; i < size; i++) data[i] = pad;
+    sz = size; }
+
+
+template<class T>
+void vec<T>::growTo(int size) {
+    if (sz >= size) return;
+    capacity(size);
+    for (int i = sz; i < size; i++) new (&data[i]) T();
+    sz = size; }
+
+
+template<class T>
+void vec<T>::clear(bool dealloc) {
+    if (data != NULL){
+        for (int i = 0; i < sz; i++) data[i].~T();
+        sz = 0;
+        if (dealloc) free(data), data = NULL, cap = 0; } }
+
+//=================================================================================================
+}
+
+#endif
+/*******************************************************************************************[Alg.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_Alg_h
+#define Glucose_Alg_h
+
+
+
+namespace Glucose {
+
+//=================================================================================================
+// Useful functions on vector-like types:
+
+//=================================================================================================
+// Removing and searching for elements:
+//
+
+template<class V, class T>
+static inline void remove(V& ts, const T& t)
+{
+    int j = 0;
+    for (; j < ts.size() && ts[j] != t; j++);
+    assert(j < ts.size());
+    for (; j < ts.size()-1; j++) ts[j] = ts[j+1];
+    ts.pop();
+}
+
+
+template<class V, class T>
+static inline bool find(V& ts, const T& t)
+{
+    int j = 0;
+    for (; j < ts.size() && ts[j] != t; j++);
+    return j < ts.size();
+}
+
+
+//=================================================================================================
+// Copying vectors with support for nested vector types:
+//
+
+// Base case:
+template<class T>
+static inline void copy(const T& from, T& to)
+{
+    to = from;
+}
+
+// Recursive case:
+template<class T>
+static inline void copy(const vec<T>& from, vec<T>& to, bool append = false)
+{
+    if (!append)
+        to.clear();
+    for (int i = 0; i < from.size(); i++){
+        to.push();
+        copy(from[i], to.last());
+    }
+}
+
+template<class T>
+static inline void append(const vec<T>& from, vec<T>& to){ copy(from, to, true); }
+
+//=================================================================================================
+}
+
+#endif
+/*****************************************************************************************[Alloc.h]
+Copyright (c) 2008-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Glucose_Alloc_h
+#define Glucose_Alloc_h
+
+
+
+
+namespace Glucose {
+
+//=================================================================================================
+// Simple Region-based memory allocator:
+
+template<class T>
+class RegionAllocator
+{
+    T*        memory;
+    uint32_t  sz;
+    uint32_t  cap;
+    uint32_t  wasted_;
+
+    void capacity(uint32_t min_cap);
+
+ public:
+    // TODO: make this a class for better type-checking?
+    typedef uint32_t Ref;
+    enum { Ref_Undef = UINT32_MAX };
+    enum { Unit_Size = sizeof(uint32_t) };
+
+    explicit RegionAllocator(uint32_t start_cap = 1024*1024) : memory(NULL), sz(0), cap(0), wasted_(0){ capacity(start_cap); }
+    ~RegionAllocator()
+    {
+        if (memory != NULL)
+            ::free(memory);
+    }
+
+
+    uint32_t size      () const      { return sz; }
+    uint32_t getCap    () const      { return cap;}
+    uint32_t wasted    () const      { return wasted_; }
+
+    Ref      alloc     (int size); 
+    void     free      (int size)    { wasted_ += size; }
+
+    // Deref, Load Effective Address (LEA), Inverse of LEA (AEL):
+    T&       operator[](Ref r)       { assert(r >= 0 && r < sz); return memory[r]; }
+    const T& operator[](Ref r) const { assert(r >= 0 && r < sz); return memory[r]; }
+
+    T*       lea       (Ref r)       { assert(r >= 0 && r < sz); return &memory[r]; }
+    const T* lea       (Ref r) const { assert(r >= 0 && r < sz); return &memory[r]; }
+    Ref      ael       (const T* t)  { assert((void*)t >= (void*)&memory[0] && (void*)t < (void*)&memory[sz-1]);
+        return  (Ref)(t - &memory[0]); }
+
+    void     moveTo(RegionAllocator& to) {
+        if (to.memory != NULL) ::free(to.memory);
+        to.memory = memory;
+        to.sz = sz;
+        to.cap = cap;
+        to.wasted_ = wasted_;
+
+        memory = NULL;
+        sz = cap = wasted_ = 0;
+    }
+
+    void copyTo(RegionAllocator& to) const {
+     //   if (to.memory != NULL) ::free(to.memory);
+        to.memory = (T*)xrealloc(to.memory, sizeof(T)*cap);
+        memcpy(to.memory,memory,sizeof(T)*cap);        
+        to.sz = sz;
+        to.cap = cap;
+        to.wasted_ = wasted_;
+    }
+
+
+
+};
+
+template<class T>
+void RegionAllocator<T>::capacity(uint32_t min_cap)
+{
+    if (cap >= min_cap) return;
+    uint32_t prev_cap = cap;
+    while (cap < min_cap){
+        // NOTE: Multiply by a factor (13/8) without causing overflow, then add 2 and make the
+        // result even by clearing the least significant bit. The resulting sequence of capacities
+        // is carefully chosen to hit a maximum capacity that is close to the '2^32-1' limit when
+        // using 'uint32_t' as indices so that as much as possible of this space can be used.
+        uint32_t delta = ((cap >> 1) + (cap >> 3) + 2) & ~1;
+        cap += delta;
+
+        if (cap <= prev_cap)
+            throw OutOfMemoryException();
+    }
+    //printf(" .. (%p) cap = %u\n", this, cap);
+
+    assert(cap > 0);
+    memory = (T*)xrealloc(memory, sizeof(T)*cap);
+}
+
+
+template<class T>
+typename RegionAllocator<T>::Ref
+RegionAllocator<T>::alloc(int size)
+{ 
+    //printf("ALLOC called (this = %p, size = %d)\n", this, size); fflush(stdout);
+    assert(size > 0);
+    capacity(sz + size);
+
+    uint32_t prev_sz = sz;
+    sz += size;
+    
+    // Handle overflow:
+    if (sz < prev_sz)
+        throw OutOfMemoryException();
+
+    return prev_sz;
+}
+
+
+//=================================================================================================
+}
+
+#endif
+#ifndef Glucose_Clone_h
+#define Glucose_Clone_h
+
+
+namespace Glucose {
+
+    class Clone {
+        public:
+          virtual Clone* clone() const = 0;
+    };
+};
+
+#endif/******************************************************************************************[Heap.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_Heap_h
+#define Glucose_Heap_h
+
+
+
+namespace Glucose {
+
+//=================================================================================================
+// A heap implementation with support for decrease/increase key.
+
+
+template<class Comp>
+class Heap {
+    Comp     lt;       // The heap is a minimum-heap with respect to this comparator
+    vec<int> heap;     // Heap of integers
+    vec<int> indices;  // Each integers position (index) in the Heap
+
+    // Index "traversal" functions
+    static inline int left  (int i) { return i*2+1; }
+    static inline int right (int i) { return (i+1)*2; }
+    static inline int parent(int i) { return (i-1) >> 1; }
+
+
+
+    void percolateUp(int i)
+    {
+        int x  = heap[i];
+        int p  = parent(i);
+        
+        while (i != 0 && lt(x, heap[p])){
+            heap[i]          = heap[p];
+            indices[heap[p]] = i;
+            i                = p;
+            p                = parent(p);
+        }
+        heap   [i] = x;
+        indices[x] = i;
+    }
+
+
+    void percolateDown(int i)
+    {
+        int x = heap[i];
+        while (left(i) < heap.size()){
+            int child = right(i) < heap.size() && lt(heap[right(i)], heap[left(i)]) ? right(i) : left(i);
+            if (!lt(heap[child], x)) break;
+            heap[i]          = heap[child];
+            indices[heap[i]] = i;
+            i                = child;
+        }
+        heap   [i] = x;
+        indices[x] = i;
+    }
+
+
+  public:
+    Heap(const Comp& c) : lt(c) { }
+
+    int  size      ()          const { return heap.size(); }
+    bool empty     ()          const { return heap.size() == 0; }
+    bool inHeap    (int n)     const { return n < indices.size() && indices[n] >= 0; }
+    int  operator[](int index) const { assert(index < heap.size()); return heap[index]; }
+
+
+    void decrease  (int n) { assert(inHeap(n)); percolateUp  (indices[n]); }
+    void increase  (int n) { assert(inHeap(n)); percolateDown(indices[n]); }
+
+    void copyTo(Heap& copy) const {heap.copyTo(copy.heap);indices.copyTo(copy.indices);}
+
+    // Safe variant of insert/decrease/increase:
+    void update(int n)
+    {
+        if (!inHeap(n))
+            insert(n);
+        else {
+            percolateUp(indices[n]);
+            percolateDown(indices[n]); }
+    }
+
+
+    void insert(int n)
+    {
+        indices.growTo(n+1, -1);
+        assert(!inHeap(n));
+
+        indices[n] = heap.size();
+        heap.push(n);
+        percolateUp(indices[n]); 
+    }
+
+
+    int  removeMin()
+    {
+        int x            = heap[0];
+        heap[0]          = heap.last();
+        indices[heap[0]] = 0;
+        indices[x]       = -1;
+        heap.pop();
+        if (heap.size() > 1) percolateDown(0);
+        return x; 
+    }
+
+
+    // Rebuild the heap from scratch, using the elements in 'ns':
+    void build(vec<int>& ns) {
+        for (int i = 0; i < heap.size(); i++)
+            indices[heap[i]] = -1;
+        heap.clear();
+
+        for (int i = 0; i < ns.size(); i++){
+            indices[ns[i]] = i;
+            heap.push(ns[i]); }
+
+        for (int i = heap.size() / 2 - 1; i >= 0; i--)
+            percolateDown(i);
+    }
+
+    void clear(bool dealloc = false) 
+    { 
+        for (int i = 0; i < heap.size(); i++)
+            indices[heap[i]] = -1;
+        heap.clear(dealloc); 
+    }
+};
+
+
+//=================================================================================================
+}
+
+#endif
+/*******************************************************************************************[Map.h]
+Copyright (c) 2006-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_Map_h
+#define Glucose_Map_h
+
+
+
+#include <string>
+#include <unordered_map>
+
+namespace Glucose {
+
+//=================================================================================================
+// Default hash/equals functions
+//
+
+static inline uint32_t hash(std::string x) {std::hash<std::string> hasher;return static_cast<uint32_t>(hasher(x)); }
+
+template<class K> struct Hash  { uint32_t operator()(const K& k)               const { return hash(k);  } };
+template<class K> struct Equal { bool     operator()(const K& k1, const K& k2) const { return k1 == k2; } };
+
+template<class K> struct DeepHash  { uint32_t operator()(const K* k)               const { return hash(*k);  } };
+template<class K> struct DeepEqual { bool     operator()(const K* k1, const K* k2) const { return *k1 == *k2; } };
+
+static inline uint32_t hash(uint32_t x){ return x; }
+static inline uint32_t hash(uint64_t x){ return (uint32_t)x; }
+static inline uint32_t hash(int32_t x) { return (uint32_t)x; }
+static inline uint32_t hash(int64_t x) { return (uint32_t)x; }
+
+
+//=================================================================================================
+// Some primes
+//
+
+static const int nprimes          = 25;
+static const int primes [nprimes] = { 31, 73, 151, 313, 643, 1291, 2593, 5233, 10501, 21013, 42073, 84181, 168451, 337219, 674701, 1349473, 2699299, 5398891, 10798093, 21596719, 43193641, 86387383, 172775299, 345550609, 691101253 };
+
+//=================================================================================================
+// Hash table implementation of Maps
+//
+
+template<class K, class D, class H = Hash<K>, class E = Equal<K> >
+class Map {
+ public:
+    struct Pair { K key; D data; };
+
+ private:
+    H          hash;
+    E          equals;
+
+    vec<Pair>* table;
+    int        cap;
+    int        size;
+
+    // Don't allow copying (error prone):
+    Map<K,D,H,E>&  operator = (Map<K,D,H,E>& other) { assert(0); }
+                   Map        (Map<K,D,H,E>& other) { assert(0); }
+
+    bool    checkCap(int new_size) const { return new_size > cap; }
+
+    int32_t index  (const K& k) const { return hash(k) % cap; }
+    void   _insert (const K& k, const D& d) { 
+        vec<Pair>& ps = table[index(k)];
+        ps.push(); ps.last().key = k; ps.last().data = d; }
+
+    void    rehash () {
+        const vec<Pair>* old = table;
+
+        int old_cap = cap;
+        int newsize = primes[0];
+        for (int i = 1; newsize <= cap && i < nprimes; i++)
+           newsize = primes[i];
+
+        table = new vec<Pair>[newsize];
+        cap   = newsize;
+
+        for (int i = 0; i < old_cap; i++){
+            for (int j = 0; j < old[i].size(); j++){
+                _insert(old[i][j].key, old[i][j].data); }}
+
+        delete [] old;
+
+        // printf(" --- rehashing, old-cap=%d, new-cap=%d\n", cap, newsize);
+    }
+
+    
+ public:
+
+    Map () : table(NULL), cap(0), size(0) {}
+    Map (const H& h, const E& e) : hash(h), equals(e), table(NULL), cap(0), size(0){}
+    ~Map () { delete [] table; }
+
+    // PRECONDITION: the key must already exist in the map.
+    const D& operator [] (const K& k) const
+    {
+        assert(size != 0);
+        const D*         res = NULL;
+        const vec<Pair>& ps  = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k))
+                res = &ps[i].data;
+//        if(res==NULL) printf("%s\n",k.c_str());
+        assert(res != NULL);
+        return *res;
+    }
+
+    // PRECONDITION: the key must already exist in the map.
+    D& operator [] (const K& k)
+    {
+        assert(size != 0);
+        D*         res = NULL;
+        vec<Pair>& ps  = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k))
+                res = &ps[i].data;
+//        if(res==NULL) printf("%s\n",k.c_str());
+
+        assert(res != NULL);
+        return *res;
+    }
+
+    // PRECONDITION: the key must *NOT* exist in the map.
+    void insert (const K& k, const D& d) { if (checkCap(size+1)) rehash(); _insert(k, d); size++; }
+    bool peek   (const K& k, D& d) const {
+        if (size == 0) return false;
+        const vec<Pair>& ps = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k)){
+                d = ps[i].data;
+                return true; } 
+        return false;
+    }
+
+    bool has   (const K& k) const {
+        if (size == 0) return false;
+        const vec<Pair>& ps = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k))
+                return true;
+        return false;
+    }
+
+    // PRECONDITION: the key must exist in the map.
+    void remove(const K& k) {
+        assert(table != NULL);
+        vec<Pair>& ps = table[index(k)];
+        int j = 0;
+        for (; j < ps.size() && !equals(ps[j].key, k); j++);
+        assert(j < ps.size());
+        ps[j] = ps.last();
+        ps.pop();
+        size--;
+    }
+
+    void clear  () {
+        cap = size = 0;
+        delete [] table;
+        table = NULL;
+    }
+
+    int  elems() const { return size; }
+    int  bucket_count() const { return cap; }
+
+    // NOTE: the hash and equality objects are not moved by this method:
+    void moveTo(Map& other){
+        delete [] other.table;
+
+        other.table = table;
+        other.cap   = cap;
+        other.size  = size;
+
+        table = NULL;
+        size = cap = 0;
+    }
+
+    // NOTE: given a bit more time, I could make a more C++-style iterator out of this:
+    const vec<Pair>& bucket(int i) const { return table[i]; }
+};
+
+//=================================================================================================
+}
+
+#endif
+/*****************************************************************************************[Queue.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_Queue_h
+#define Glucose_Queue_h
+
+
+
+namespace Glucose {
+
+//=================================================================================================
+
+template<class T>
+class Queue {
+    vec<T>  buf;
+    int     first;
+    int     end;
+
+public:
+    typedef T Key;
+
+    Queue() : buf(1), first(0), end(0) {}
+
+    void clear (bool dealloc = false) { buf.clear(dealloc); buf.growTo(1); first = end = 0; }
+    int  size  () const { return (end >= first) ? end - first : end - first + buf.size(); }
+
+    
+    
+    const T& operator [] (int index) const  { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; }
+    T&       operator [] (int index)        { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; }
+
+    T    peek  () const { assert(first != end); return buf[first]; }
+    void pop   () { assert(first != end); first++; if (first == buf.size()) first = 0; }
+    
+    
+    void copyTo(Queue<T>& copy) const {
+        copy.first = first;
+        copy.end = end;
+        buf.memCopyTo(copy.buf);
+    }
+    
+    
+    void insert(T elem) {   // INVARIANT: buf[end] is always unused
+        buf[end++] = elem;
+        if (end == buf.size()) end = 0;
+        if (first == end){  // Resize:
+            vec<T>  tmp((buf.size()*3 + 1) >> 1);
+            //**/printf("queue alloc: %d elems (%.1f MB)\n", tmp.size(), tmp.size() * sizeof(T) / 1000000.0);
+            int     i = 0;
+            for (int j = first; j < buf.size(); j++) tmp[i++] = buf[j];
+            for (int j = 0    ; j < end       ; j++) tmp[i++] = buf[j];
+            first = 0;
+            end   = buf.size();
+            tmp.moveTo(buf);
+        }
+    }
+};
+
+
+//=================================================================================================
+}
+
+#endif
+/******************************************************************************************[Sort.h]
+Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_Sort_h
+#define Glucose_Sort_h
+
+
+
+//=================================================================================================
+// Some sorting algorithms for vec's
+
+
+namespace Glucose {
+
+template<class T>
+struct LessThan_default {
+    bool operator () (T x, T y) { return x < y; }
+};
+
+
+template <class T, class LessThan>
+void selectionSort(T* array, int size, LessThan lt)
+{
+    int     i, j, best_i;
+    T       tmp;
+
+    for (i = 0; i < size-1; i++){
+        best_i = i;
+        for (j = i+1; j < size; j++){
+            if (lt(array[j], array[best_i]))
+                best_i = j;
+        }
+        tmp = array[i]; array[i] = array[best_i]; array[best_i] = tmp;
+    }
+}
+template <class T> static inline void selectionSort(T* array, int size) {
+    selectionSort(array, size, LessThan_default<T>()); }
+
+template <class T, class LessThan>
+void sort(T* array, int size, LessThan lt)
+{
+    if (size <= 15)
+        selectionSort(array, size, lt);
+
+    else{
+        T           pivot = array[size / 2];
+        T           tmp;
+        int         i = -1;
+        int         j = size;
+
+        for(;;){
+            do i++; while(lt(array[i], pivot));
+            do j--; while(lt(pivot, array[j]));
+
+            if (i >= j) break;
+
+            tmp = array[i]; array[i] = array[j]; array[j] = tmp;
+        }
+
+        sort(array    , i     , lt);
+        sort(&array[i], size-i, lt);
+    }
+}
+template <class T> static inline void sort(T* array, int size) {
+    sort(array, size, LessThan_default<T>()); }
+
+
+//=================================================================================================
+// For 'vec's:
+
+
+template <class T, class LessThan> void sort(vec<T>& v, LessThan lt) {
+    sort((T*)v, v.size(), lt); }
+template <class T> void sort(vec<T>& v) {
+    sort(v, LessThan_default<T>()); }
+
+
+//=================================================================================================
+}
+
+#endif
+/************************************************************************************[ParseUtils.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_ParseUtils_h
+#define Glucose_ParseUtils_h
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+
+namespace Glucose {
+
+static inline bool isEof(const char*   in) { return *in == '\0'; }
+
+//-------------------------------------------------------------------------------------------------
+// Generic parse functions parametrized over the input-stream type.
+
+
+template<class B>
+static void skipWhitespace(B& in) {
+    while ((*in >= 9 && *in <= 13) || *in == 32)
+        ++in; }
+
+
+template<class B>
+static void skipLine(B& in) {
+    for (;;){
+        if (isEof(in)) return;
+        if (*in == '\n') { ++in; return; }
+        ++in; } }
+
+template<class B>
+static double parseDouble(B& in) { // only in the form X.XXXXXe-XX
+    bool    neg= false;
+	double accu = 0.0;
+	double currentExponent = 1;
+	int exponent;
+	
+    skipWhitespace(in);
+    if(*in == EOF) return 0;
+    if      (*in == '-') neg = true, ++in;
+    else if (*in == '+') ++in;
+    if (*in < '1' || *in > '9') printf("PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
+	accu = (double)(*in - '0');
+	++in;
+	if (*in != '.') printf("PARSE ERROR! Unexpected char: %c\n", *in),exit(3);
+	++in; // skip dot
+	currentExponent = 0.1;
+    while (*in >= '0' && *in <= '9')
+        accu = accu + currentExponent * ((double)(*in - '0')),
+		currentExponent /= 10,
+        ++in;
+	if (*in != 'e') printf("PARSE ERROR! Unexpected char: %c\n", *in),exit(3);
+	++in; // skip dot
+	exponent = parseInt(in); // read exponent
+	accu *= pow(10,exponent);
+	return neg ? -accu:accu;
+}
+
+
+template<class B>
+static int parseInt(B& in) {
+    int     val = 0;
+    bool    neg = false;
+    skipWhitespace(in);
+    if      (*in == '-') neg = true, ++in;
+    else if (*in == '+') ++in;
+    if (*in < '0' || *in > '9') fprintf(stderr, "PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
+    while (*in >= '0' && *in <= '9')
+        val = val*10 + (*in - '0'),
+        ++in;
+    return neg ? -val : val; }
+
+
+// String matching: in case of a match the input iterator will be advanced the corresponding
+// number of characters.
+template<class B>
+static bool match(B& in, const char* str) {
+    int i;
+    for (i = 0; str[i] != '\0'; i++)
+        if (in[i] != str[i])
+            return false;
+
+    in += i;
+
+    return true; 
+}
+
+// String matching: consumes characters eagerly, but does not require random access iterator.
+template<class B>
+static bool eagerMatch(B& in, const char* str) {
+    for (; *str != '\0'; ++str, ++in)
+        if (*str != *in)
+            return false;
+    return true; }
+
+
+//=================================================================================================
+}
+
+#endif
+/***************************************************************************************[Options.h]
+Copyright (c) 2008-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_Options_h
+#define Glucose_Options_h
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+
+
+
+
+
+namespace Glucose {
+
+//==================================================================================================
+// Top-level option parse/help functions:
+
+
+extern void parseOptions     (int& argc, char** argv, bool strict = false);
+extern void printUsageAndExit(int  argc, char** argv, bool verbose = false);
+extern void setUsageHelp     (const char* str);
+extern void setHelpPrefixStr (const char* str);
+
+
+//==================================================================================================
+// Options is an abstract class that gives the interface for all types options:
+
+
+class Option
+{
+ protected:
+    const char* name;
+    const char* description;
+    const char* category;
+    const char* type_name;
+
+    static vec<Option*>& getOptionList () { static vec<Option*> options; return options; }
+    static const char*&  getUsageString() { static const char* usage_str; return usage_str; }
+    static const char*&  getHelpPrefixString() { static const char* help_prefix_str = ""; return help_prefix_str; }
+
+    struct OptionLt {
+        bool operator()(const Option* x, const Option* y) {
+            int test1 = strcmp(x->category, y->category);
+            return test1 < 0 || (test1 == 0 && strcmp(x->type_name, y->type_name) < 0);
+        }
+    };
+
+    Option(const char* name_, 
+           const char* desc_,
+           const char* cate_,
+           const char* type_) : 
+      name       (name_)
+    , description(desc_)
+    , category   (cate_)
+    , type_name  (type_)
+    { 
+        getOptionList().push(this); 
+    }
+
+ public:
+    virtual ~Option() {}
+
+    virtual bool parse             (const char* str)      = 0;
+    virtual void help              (bool verbose = false) = 0;
+
+    friend  void parseOptions      (int& argc, char** argv, bool strict);
+    friend  void printUsageAndExit (int  argc, char** argv, bool verbose);
+    friend  void setUsageHelp      (const char* str);
+    friend  void setHelpPrefixStr  (const char* str);
+};
+
+
+//==================================================================================================
+// Range classes with specialization for floating types:
+
+
+struct IntRange {
+    int begin;
+    int end;
+    IntRange(int b, int e) : begin(b), end(e) {}
+};
+
+struct Int64Range {
+    int64_t begin;
+    int64_t end;
+    Int64Range(int64_t b, int64_t e) : begin(b), end(e) {}
+};
+
+struct DoubleRange {
+    double begin;
+    double end;
+    bool  begin_inclusive;
+    bool  end_inclusive;
+    DoubleRange(double b, bool binc, double e, bool einc) : begin(b), end(e), begin_inclusive(binc), end_inclusive(einc) {}
+};
+
+
+//==================================================================================================
+// Double options:
+
+
+class DoubleOption : public Option
+{
+ protected:
+    DoubleRange range;
+    double      value;
+
+ public:
+    DoubleOption(const char* c, const char* n, const char* d, double def = double(), DoubleRange r = DoubleRange(-HUGE_VAL, false, HUGE_VAL, false))
+        : Option(n, d, c, "<double>"), range(r), value(def) {
+        // FIXME: set LC_NUMERIC to "C" to make sure that strtof/strtod parses decimal point correctly.
+    }
+
+    operator      double   (void) const { return value; }
+    operator      double&  (void)       { return value; }
+    DoubleOption& operator=(double x)   { value = x; return *this; }
+
+    virtual bool parse(const char* str){
+        const char* span = str; 
+
+        if (!match(span, "-") || !match(span, name) || !match(span, "="))
+            return false;
+
+        char*  end;
+        double tmp = strtod(span, &end);
+
+        if (end == NULL) 
+            return false;
+        else if (tmp >= range.end && (!range.end_inclusive || tmp != range.end)){
+            fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name);
+            exit(1);
+        }else if (tmp <= range.begin && (!range.begin_inclusive || tmp != range.begin)){
+            fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name);
+            exit(1); }
+
+        value = tmp;
+        // fprintf(stderr, "READ VALUE: %g\n", value);
+
+        return true;
+    }
+
+    virtual void help (bool verbose = false){
+        fprintf(stderr, "  -%-12s = %-8s %c%4.2g .. %4.2g%c (default: %g)\n", 
+                name, type_name, 
+                range.begin_inclusive ? '[' : '(', 
+                range.begin,
+                range.end,
+                range.end_inclusive ? ']' : ')', 
+                value);
+        if (verbose){
+            fprintf(stderr, "\n        %s\n", description);
+            fprintf(stderr, "\n");
+        }
+    }
+};
+
+
+//==================================================================================================
+// Int options:
+
+
+class IntOption : public Option
+{
+ protected:
+    IntRange range;
+    int32_t  value;
+
+ public:
+    IntOption(const char* c, const char* n, const char* d, int32_t def = int32_t(), IntRange r = IntRange(INT32_MIN, INT32_MAX))
+        : Option(n, d, c, "<int32>"), range(r), value(def) {}
+ 
+    operator   int32_t   (void) const { return value; }
+    operator   int32_t&  (void)       { return value; }
+    IntOption& operator= (int32_t x)  { value = x; return *this; }
+
+    virtual bool parse(const char* str){
+        const char* span = str; 
+
+        if (!match(span, "-") || !match(span, name) || !match(span, "="))
+            return false;
+
+        char*   end;
+        int32_t tmp = strtol(span, &end, 10);
+
+        if (end == NULL) 
+            return false;
+        else if (tmp > range.end){
+            fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name);
+            exit(1);
+        }else if (tmp < range.begin){
+            fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name);
+            exit(1); }
+
+        value = tmp;
+
+        return true;
+    }
+
+    virtual void help (bool verbose = false){
+        fprintf(stderr, "  -%-12s = %-8s [", name, type_name);
+        if (range.begin == INT32_MIN)
+            fprintf(stderr, "imin");
+        else
+            fprintf(stderr, "%4d", range.begin);
+
+        fprintf(stderr, " .. ");
+        if (range.end == INT32_MAX)
+            fprintf(stderr, "imax");
+        else
+            fprintf(stderr, "%4d", range.end);
+
+        fprintf(stderr, "] (default: %d)\n", value);
+        if (verbose){
+            fprintf(stderr, "\n        %s\n", description);
+            fprintf(stderr, "\n");
+        }
+    }
+};
+
+
+// Leave this out for visual C++ until Microsoft implements C99 and gets support for strtoll.
+#ifndef _MSC_VER
+
+class Int64Option : public Option
+{
+ protected:
+    Int64Range range;
+    int64_t  value;
+
+ public:
+    Int64Option(const char* c, const char* n, const char* d, int64_t def = int64_t(), Int64Range r = Int64Range(INT64_MIN, INT64_MAX))
+        : Option(n, d, c, "<int64>"), range(r), value(def) {}
+ 
+    operator     int64_t   (void) const { return value; }
+    operator     int64_t&  (void)       { return value; }
+    Int64Option& operator= (int64_t x)  { value = x; return *this; }
+
+    virtual bool parse(const char* str){
+        const char* span = str; 
+
+        if (!match(span, "-") || !match(span, name) || !match(span, "="))
+            return false;
+
+        char*   end;
+        int64_t tmp = strtoll(span, &end, 10);
+
+        if (end == NULL) 
+            return false;
+        else if (tmp > range.end){
+            fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name);
+            exit(1);
+        }else if (tmp < range.begin){
+            fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name);
+            exit(1); }
+
+        value = tmp;
+
+        return true;
+    }
+
+    virtual void help (bool verbose = false){
+        fprintf(stderr, "  -%-12s = %-8s [", name, type_name);
+        if (range.begin == INT64_MIN)
+            fprintf(stderr, "imin");
+        else
+            fprintf(stderr, "%4" PRIi64, range.begin);
+
+        fprintf(stderr, " .. ");
+        if (range.end == INT64_MAX)
+            fprintf(stderr, "imax");
+        else
+            fprintf(stderr, "%4" PRIi64, range.end);
+
+        fprintf(stderr, "] (default: %" PRIi64")\n", value);
+        if (verbose){
+            fprintf(stderr, "\n        %s\n", description);
+            fprintf(stderr, "\n");
+        }
+    }
+};
+#endif
+
+//==================================================================================================
+// String option:
+
+
+class StringOption : public Option
+{
+    const char* value;
+ public:
+    StringOption(const char* c, const char* n, const char* d, const char* def = NULL) 
+        : Option(n, d, c, "<string>"), value(def) {}
+
+    operator      const char*  (void) const     { return value; }
+    operator      const char*& (void)           { return value; }
+    StringOption& operator=    (const char* x)  { value = x; return *this; }
+
+    virtual bool parse(const char* str){
+        const char* span = str; 
+
+        if (!match(span, "-") || !match(span, name) || !match(span, "="))
+            return false;
+
+        value = span;
+        return true;
+    }
+
+    virtual void help (bool verbose = false){
+        fprintf(stderr, "  -%-10s = %8s\n", name, type_name);
+        if (verbose){
+            fprintf(stderr, "\n        %s\n", description);
+            fprintf(stderr, "\n");
+        }
+    }    
+};
+
+
+//==================================================================================================
+// Bool option:
+
+
+class BoolOption : public Option
+{
+    bool value;
+
+ public:
+    BoolOption(const char* c, const char* n, const char* d, bool v) 
+        : Option(n, d, c, "<bool>"), value(v) {}
+
+    operator    bool     (void) const { return value; }
+    operator    bool&    (void)       { return value; }
+    BoolOption& operator=(bool b)     { value = b; return *this; }
+
+    virtual bool parse(const char* str){
+        const char* span = str; 
+        
+        if (match(span, "-")){
+            bool b = !match(span, "no-");
+
+            if (strcmp(span, name) == 0){
+                value = b;
+                return true; }
+        }
+
+        return false;
+    }
+
+    virtual void help (bool verbose = false){
+
+        fprintf(stderr, "  -%s, -no-%s", name, name);
+
+        for (uint32_t i = 0; i < 32 - strlen(name)*2; i++)
+            fprintf(stderr, " ");
+
+        fprintf(stderr, " ");
+        fprintf(stderr, "(default: %s)\n", value ? "on" : "off");
+        if (verbose){
+            fprintf(stderr, "\n        %s\n", description);
+            fprintf(stderr, "\n");
+        }
+    }
+};
+
+//=================================================================================================
+}
+
+#endif
+/****************************************************************************************[System.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Glucose_System_h
+#define Glucose_System_h
+
+
+
+//-------------------------------------------------------------------------------------------------
+
+namespace Glucose {
+
+static inline double cpuTime(void); // CPU-time in seconds.
+
+#ifndef _WIN32
+static inline double realTime(void);
+#endif
+extern double memUsed();            // Memory in mega bytes (returns 0 for unsupported architectures).
+extern double memUsedPeak();        // Peak-memory in mega bytes (returns 0 for unsupported architectures).
+
+}
+
+//-------------------------------------------------------------------------------------------------
+// Implementation of inline functions:
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#include <time.h>
+
+static inline double Glucose::cpuTime(void) { return (double)clock() / CLOCKS_PER_SEC; }
+
+#else
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <unistd.h>
+
+static inline double Glucose::cpuTime(void) {
+    struct rusage ru;
+    getrusage(RUSAGE_SELF, &ru);
+    return (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec / 1000000; }
+
+#endif
+
+#ifndef _WIN32
+// Laurent: I know that this will not compile directly under Windows... sorry for that
+static inline double Glucose::realTime() {
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return (double)tv.tv_sec + (double) tv.tv_usec / 1000000; }
+#endif
+#endif
+/***************************************************************************************[SolverTypes.h]
+ Glucose -- Copyright (c) 2009-2014, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                LRI  - Univ. Paris Sud, France (2009-2013)
+                                Labri - Univ. Bordeaux, France
+
+ Syrup (Glucose Parallel) -- Copyright (c) 2013-2014, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                Labri - Univ. Bordeaux, France
+
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose (sources until 2013, Glucose 3.0, single core) are exactly the same as Minisat on which it 
+is based on. (see below).
+
+Glucose-Syrup sources are based on another copyright. Permissions and copyrights for the parallel
+version of Glucose-Syrup (the "Software") are granted, free of charge, to deal with the Software
+without restriction, including the rights to use, copy, modify, merge, publish, distribute,
+sublicence, and/or sell copies of the Software, and to permit persons to whom the Software is 
+furnished to do so, subject to the following conditions:
+
+- The above and below copyrights notices and this permission notice shall be included in all
+copies or substantial portions of the Software;
+- The parallel version of Glucose (all files modified since Glucose 3.0 releases, 2013) cannot
+be used in any competitive event (sat competitions/evaluations) without the express permission of 
+the authors (Gilles Audemard / Laurent Simon). This is also the case for any competitive event
+using Glucose Parallel as an embedded SAT engine (single core or not).
+
+
+--------------- Original Minisat Copyrights
+
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ **************************************************************************************************/
+
+
+#ifndef Glucose_SolverTypes_h
+#define Glucose_SolverTypes_h
+
+#include <assert.h>
+#include <stdint.h>
+#ifndef _WIN32
+#include <pthread.h>
+#endif
+
+
+
+
+
+
+
+namespace Glucose {
+
+//=================================================================================================
+// Variables, literals, lifted booleans, clauses:
+
+
+// NOTE! Variables are just integers. No abstraction here. They should be chosen from 0..N,
+// so that they can be used as array indices.
+
+typedef int Var;
+#define var_Undef (-1)
+
+
+struct Lit {
+    int     x;
+
+    // Use this as a constructor:
+    friend Lit mkLit(Var var, bool sign);
+
+    bool operator == (Lit p) const { return x == p.x; }
+    bool operator != (Lit p) const { return x != p.x; }
+    bool operator <  (Lit p) const { return x < p.x;  } // '<' makes p, ~p adjacent in the ordering.
+};
+
+
+inline  Lit  mkLit     (Var var, bool sign = false) { Lit p; p.x = var + var + (int)sign; return p; }
+inline  Lit  operator ~(Lit p)              { Lit q; q.x = p.x ^ 1; return q; }
+inline  Lit  operator ^(Lit p, bool b)      { Lit q; q.x = p.x ^ (unsigned int)b; return q; }
+inline  bool sign      (Lit p)              { return p.x & 1; }
+inline  int  var       (Lit p)              { return p.x >> 1; }
+
+// Mapping Literals to and from compact integers suitable for array indexing:
+inline  int  toInt     (Var v)              { return v; } 
+inline  int  toInt     (Lit p)              { return p.x; } 
+inline  Lit  toLit     (int i)              { Lit p; p.x = i; return p; } 
+
+//const Lit lit_Undef = mkLit(var_Undef, false);  // }- Useful special constants.
+//const Lit lit_Error = mkLit(var_Undef, true );  // }
+
+const Lit lit_Undef = { -2 };  // }- Useful special constants.
+const Lit lit_Error = { -1 };  // }
+
+
+//=================================================================================================
+// Lifted booleans:
+//
+// NOTE: this implementation is optimized for the case when comparisons between values are mostly
+//       between one variable and one constant. Some care had to be taken to make sure that gcc 
+//       does enough constant propagation to produce sensible code, and this appears to be somewhat
+//       fragile unfortunately.
+
+class lbool {
+    uint8_t value;
+
+public:
+    constexpr explicit lbool(uint8_t v) : value(v) { }
+
+    lbool()       : value(0) { }
+    explicit lbool(bool x) : value(!x) { }
+
+    bool  operator == (lbool b) const { return ((b.value&2) & (value&2)) | (!(b.value&2)&(value == b.value)); }
+    bool  operator != (lbool b) const { return !(*this == b); }
+    lbool operator ^  (bool  b) const { return lbool((uint8_t)(value^(uint8_t)b)); }
+
+    lbool operator && (lbool b) const { 
+        uint8_t sel = (this->value << 1) | (b.value << 3);
+        uint8_t v   = (0xF7F755F4 >> sel) & 3;
+        return lbool(v); }
+
+    lbool operator || (lbool b) const {
+        uint8_t sel = (this->value << 1) | (b.value << 3);
+        uint8_t v   = (0xFCFCF400 >> sel) & 3;
+        return lbool(v); }
+
+    friend int   toInt  (lbool l);
+    friend lbool toLbool(int   v);
+};
+inline int   toInt  (lbool l) { return l.value; }
+inline lbool toLbool(int   v) { return lbool((uint8_t)v);  }
+
+constexpr auto l_True = Glucose::lbool((uint8_t)0);
+constexpr auto l_False = Glucose::lbool((uint8_t)1);
+constexpr auto l_Undef = Glucose::lbool((uint8_t)2);
+
+//=================================================================================================
+// Clause -- a simple class for representing a clause:
+
+class Clause;
+typedef RegionAllocator<uint32_t>::Ref CRef;
+
+#define BITS_LBD 20 
+#ifdef INCREMENTAL
+  #define BITS_SIZEWITHOUTSEL 19
+#endif
+#define BITS_REALSIZE 32
+class Clause {
+    struct {
+      unsigned mark       : 2;
+      unsigned learnt     : 1;
+      unsigned canbedel   : 1;
+      unsigned extra_size : 2; // extra size (end of 32bits) 0..3       
+      unsigned seen       : 1;
+      unsigned reloced    : 1;
+      unsigned exported   : 2; // Values to keep track of the clause status for exportations
+      unsigned oneWatched : 1;
+      unsigned lbd : BITS_LBD;
+
+      unsigned size       : BITS_REALSIZE;
+
+#ifdef INCREMENTAL
+      unsigned szWithoutSelectors : BITS_SIZEWITHOUTSEL;
+#endif
+    }  header;
+
+    union { Lit lit; float act; uint32_t abs; CRef rel; } data[0];
+
+    friend class ClauseAllocator;
+
+    // NOTE: This constructor cannot be used directly (doesn't allocate enough memory).
+    template<class V>
+    Clause(const V& ps, int _extra_size, bool learnt) {
+	assert(_extra_size < (1<<2));
+        header.mark      = 0;
+        header.learnt    = learnt;
+        header.extra_size = _extra_size;
+            header.reloced   = 0;
+        header.size      = ps.size();
+	header.lbd = 0;
+	header.canbedel = 1;
+	header.exported = 0; 
+	header.oneWatched = 0;
+	header.seen = 0;
+        for (int i = 0; i < ps.size(); i++) 
+            data[i].lit = ps[i];
+	
+        if (header.extra_size > 0){
+	  if (header.learnt) 
+                data[header.size].act = 0; 
+            else 
+                calcAbstraction();
+	  if (header.extra_size > 1) {
+	      data[header.size+1].abs = 0; // learntFrom
+	  }	      
+	}
+    }
+
+public:
+    void calcAbstraction() {
+        assert(header.extra_size > 0);
+        uint32_t abstraction = 0;
+        for (int i = 0; i < size(); i++)
+            abstraction |= 1 << (var(data[i].lit) & 31);
+        data[header.size].abs = abstraction;  }
+
+    int          size        ()      const   { return header.size; }
+    void         shrink      (int i)         { assert(i <= size()); 
+						if (header.extra_size > 0) {
+						    data[header.size-i] = data[header.size];
+						    if (header.extra_size > 1) { // Special case for imported clauses
+							data[header.size-i-1] = data[header.size-1];
+						    }
+						}
+    header.size -= i; }
+    void         pop         ()              { shrink(1); }
+    bool         learnt      ()      const   { return header.learnt; }
+    void         nolearnt    ()              { header.learnt = false;}
+    bool         has_extra   ()      const   { return header.extra_size > 0; }
+    uint32_t     mark        ()      const   { return header.mark; }
+    void         mark        (uint32_t m)    { header.mark = m; }
+    const Lit&   last        ()      const   { return data[header.size-1].lit; }
+
+    bool         reloced     ()      const   { return header.reloced; }
+    CRef         relocation  ()      const   { return data[0].rel; }
+    void         relocate    (CRef c)        { header.reloced = 1; data[0].rel = c; }
+
+    // NOTE: somewhat unsafe to change the clause in-place! Must manually call 'calcAbstraction' afterwards for
+    //       subsumption operations to behave correctly.
+    Lit&         operator [] (int i)         { return data[i].lit; }
+    Lit          operator [] (int i) const   { return data[i].lit; }
+    operator const Lit* (void) const         { return (Lit*)data; }
+
+    float&       activity    ()              { assert(header.extra_size > 0); return data[header.size].act; }
+    uint32_t     abstraction () const        { assert(header.extra_size > 0); return data[header.size].abs; }
+
+    // Handle imported clauses lazy sharing
+    bool        wasImported() const {return header.extra_size > 1;}
+    uint32_t    importedFrom () const       { assert(header.extra_size > 1); return data[header.size + 1].abs;}
+    void setImportedFrom(uint32_t ifrom) {assert(header.extra_size > 1); data[header.size+1].abs = ifrom;}
+
+    Lit          subsumes    (const Clause& other) const;
+    void         strengthen  (Lit p);
+    void         setLBD(int i)  {header.lbd=i; /*if (i < (1<<(BITS_LBD-1))) header.lbd = i; else header.lbd = (1<<(BITS_LBD-1));*/} 
+    // unsigned int&       lbd    ()              { return header.lbd; }
+    unsigned int        lbd    () const        { return header.lbd; }
+    void setCanBeDel(bool b) {header.canbedel = b;}
+    bool canBeDel() {return header.canbedel;}
+    void setSeen(bool b) {header.seen = b;}
+    bool getSeen() {return header.seen;}
+    void setExported(unsigned int b) {header.exported = b;}
+    unsigned int getExported() {return header.exported;}
+    void setOneWatched(bool b) {header.oneWatched = b;}
+    bool getOneWatched() {return header.oneWatched;}
+#ifdef INCREMNENTAL
+    void setSizeWithoutSelectors   (unsigned int n)              {header.szWithoutSelectors = n; }
+    unsigned int        sizeWithoutSelectors   () const        { return header.szWithoutSelectors; }
+#endif
+
+};
+
+
+//=================================================================================================
+// ClauseAllocator -- a simple class for allocating memory for clauses:
+
+
+    const CRef CRef_Undef = RegionAllocator<uint32_t>::Ref_Undef;
+    class ClauseAllocator : public RegionAllocator<uint32_t>
+    {
+        static int clauseWord32Size(int size, int extra_size){
+            return (sizeof(Clause) + (sizeof(Lit) * (size + extra_size))) / sizeof(uint32_t); }
+    public:
+        bool extra_clause_field;
+
+        ClauseAllocator(uint32_t start_cap) : RegionAllocator<uint32_t>(start_cap), extra_clause_field(false){}
+        ClauseAllocator() : extra_clause_field(false){}
+
+        void moveTo(ClauseAllocator& to){
+            to.extra_clause_field = extra_clause_field;
+            RegionAllocator<uint32_t>::moveTo(to); }
+
+        template<class Lits>
+        CRef alloc(const Lits& ps, bool learnt = false, bool imported = false)
+        {
+            assert(sizeof(Lit)      == sizeof(uint32_t));
+            assert(sizeof(float)    == sizeof(uint32_t));
+
+            bool use_extra = learnt | extra_clause_field;
+            int extra_size = imported?3:(use_extra?1:0);
+            CRef cid = RegionAllocator<uint32_t>::alloc(clauseWord32Size(ps.size(), extra_size));
+            new (lea(cid)) Clause(ps, extra_size, learnt);
+
+            return cid;
+        }
+
+        // Deref, Load Effective Address (LEA), Inverse of LEA (AEL):
+        Clause&       operator[](Ref r)       { return (Clause&)RegionAllocator<uint32_t>::operator[](r); }
+        const Clause& operator[](Ref r) const { return (Clause&)RegionAllocator<uint32_t>::operator[](r); }
+        Clause*       lea       (Ref r)       { return (Clause*)RegionAllocator<uint32_t>::lea(r); }
+        const Clause* lea       (Ref r) const { return (Clause*)RegionAllocator<uint32_t>::lea(r); }
+        Ref           ael       (const Clause* t){ return RegionAllocator<uint32_t>::ael((uint32_t*)t); }
+
+        void free(CRef cid)
+        {
+            Clause& c = operator[](cid);
+            RegionAllocator<uint32_t>::free(clauseWord32Size(c.size(), c.has_extra()));
+        }
+
+        void reloc(CRef& cr, ClauseAllocator& to)
+        {
+            Clause& c = operator[](cr);
+
+            if (c.reloced()) { cr = c.relocation(); return; }
+
+            cr = to.alloc(c, c.learnt(), c.wasImported());
+            c.relocate(cr);
+
+            // Copy extra data-fields:
+            // (This could be cleaned-up. Generalize Clause-constructor to be applicable here instead?)
+            to[cr].mark(c.mark());
+            if (to[cr].learnt())        {
+                to[cr].activity() = c.activity();
+                to[cr].setLBD(c.lbd());
+                to[cr].setExported(c.getExported());
+                to[cr].setOneWatched(c.getOneWatched());
+#ifdef INCREMENTAL
+                to[cr].setSizeWithoutSelectors(c.sizeWithoutSelectors());
+#endif
+                to[cr].setCanBeDel(c.canBeDel());
+                if (c.wasImported()) {
+                    to[cr].setImportedFrom(c.importedFrom());
+                }
+            }
+            else {
+                to[cr].setSeen(c.getSeen());
+                if (to[cr].has_extra()) to[cr].calcAbstraction();
+            }
+        }
+    };
+
+
+//=================================================================================================
+// OccLists -- a class for maintaining occurence lists with lazy deletion:
+
+template<class Idx, class Vec, class Deleted>
+class OccLists
+{
+    vec<Vec>  occs;
+    vec<char> dirty;
+    vec<Idx>  dirties;
+    Deleted   deleted;
+
+ public:
+    OccLists(const Deleted& d) : deleted(d) {}
+    
+    void  init      (const Idx& idx){ occs.growTo(toInt(idx)+1); dirty.growTo(toInt(idx)+1, 0); }
+    // Vec&  operator[](const Idx& idx){ return occs[toInt(idx)]; }
+    Vec&  operator[](const Idx& idx){ return occs[toInt(idx)]; }
+    Vec&  lookup    (const Idx& idx){ if (dirty[toInt(idx)]) clean(idx); return occs[toInt(idx)]; }
+
+    void  cleanAll  ();
+    void copyTo(OccLists &copy) const {
+	
+	copy.occs.growTo(occs.size());
+	for(int i = 0;i<occs.size();i++)
+	    occs[i].memCopyTo(copy.occs[i]);
+	dirty.memCopyTo(copy.dirty);
+	dirties.memCopyTo(copy.dirties);
+    }
+
+    void  clean     (const Idx& idx);
+    void  smudge    (const Idx& idx){
+        if (dirty[toInt(idx)] == 0){
+            dirty[toInt(idx)] = 1;
+            dirties.push(idx);
+        }
+    }
+
+    void  clear(bool free = true){
+        occs   .clear(free);
+        dirty  .clear(free);
+        dirties.clear(free);
+    }
+};
+
+
+template<class Idx, class Vec, class Deleted>
+void OccLists<Idx,Vec,Deleted>::cleanAll()
+{
+    for (int i = 0; i < dirties.size(); i++)
+        // Dirties may contain duplicates so check here if a variable is already cleaned:
+        if (dirty[toInt(dirties[i])])
+            clean(dirties[i]);
+    dirties.clear();
+}
+
+
+template<class Idx, class Vec, class Deleted>
+void OccLists<Idx,Vec,Deleted>::clean(const Idx& idx)
+{
+    Vec& vec = occs[toInt(idx)];
+    int  i, j;
+    for (i = j = 0; i < vec.size(); i++)
+        if (!deleted(vec[i]))
+            vec[j++] = vec[i];
+    vec.shrink(i - j);
+    dirty[toInt(idx)] = 0;
+}
+
+
+//=================================================================================================
+// CMap -- a class for mapping clauses to values:
+
+
+template<class T>
+class CMap
+{
+    struct CRefHash {
+        uint32_t operator()(CRef cr) const { return (uint32_t)cr; } };
+
+    typedef Map<CRef, T, CRefHash> HashTable;
+    HashTable map;
+        
+ public:
+    // Size-operations:
+    void     clear       ()                           { map.clear(); }
+    int      size        ()                const      { return map.elems(); }
+
+    
+    // Insert/Remove/Test mapping:
+    void     insert      (CRef cr, const T& t){ map.insert(cr, t); }
+    void     growTo      (CRef cr, const T& t){ map.insert(cr, t); } // NOTE: for compatibility
+    void     remove      (CRef cr)            { map.remove(cr); }
+    bool     has         (CRef cr, T& t)      { return map.peek(cr, t); }
+
+    // Vector interface (the clause 'c' must already exist):
+    const T& operator [] (CRef cr) const      { return map[cr]; }
+    T&       operator [] (CRef cr)            { return map[cr]; }
+
+    // Iteration (not transparent at all at the moment):
+    int  bucket_count() const { return map.bucket_count(); }
+    const vec<typename HashTable::Pair>& bucket(int i) const { return map.bucket(i); }
+
+    // Move contents to other map:
+    void moveTo(CMap& other){ map.moveTo(other.map); }
+
+    // TMP debug:
+    void debug(){
+        printf(" --- size = %d, bucket_count = %d\n", size(), map.bucket_count()); }
+};
+
+
+/*_________________________________________________________________________________________________
+|
+|  subsumes : (other : const Clause&)  ->  Lit
+|  
+|  Description:
+|       Checks if clause subsumes 'other', and at the same time, if it can be used to simplify 'other'
+|       by subsumption resolution.
+|  
+|    Result:
+|       lit_Error  - No subsumption or simplification
+|       lit_Undef  - Clause subsumes 'other'
+|       p          - The literal p can be deleted from 'other'
+|________________________________________________________________________________________________@*/
+inline Lit Clause::subsumes(const Clause& other) const
+{
+    //if (other.size() < size() || (extra.abst & ~other.extra.abst) != 0)
+    //if (other.size() < size() || (!learnt() && !other.learnt() && (extra.abst & ~other.extra.abst) != 0))
+    assert(!header.learnt);   assert(!other.header.learnt);
+    assert(header.extra_size > 0); assert(other.header.extra_size > 0);
+    if (other.header.size < header.size || (data[header.size].abs & ~other.data[other.header.size].abs) != 0)
+        return lit_Error;
+
+    Lit        ret = lit_Undef;
+    const Lit* c   = (const Lit*)(*this);
+    const Lit* d   = (const Lit*)other;
+
+    for (unsigned i = 0; i < header.size; i++) {
+        // search for c[i] or ~c[i]
+        for (unsigned j = 0; j < other.header.size; j++)
+            if (c[i] == d[j])
+                goto ok;
+            else if (ret == lit_Undef && c[i] == ~d[j]){
+                ret = c[i];
+                goto ok;
+            }
+
+        // did not find it
+        return lit_Error;
+    ok:;
+    }
+
+    return ret;
+}
+
+inline void Clause::strengthen(Lit p)
+{
+    remove(*this, p);
+    calcAbstraction();
+}
+ 
+//=================================================================================================
+}
+
+ 
+#endif
+/***************************************************************************************[BoundedQueue.h]
+ Glucose -- Copyright (c) 2009-2014, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                LRI  - Univ. Paris Sud, France (2009-2013)
+                                Labri - Univ. Bordeaux, France
+
+ Syrup (Glucose Parallel) -- Copyright (c) 2013-2014, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                Labri - Univ. Bordeaux, France
+
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose (sources until 2013, Glucose 3.0, single core) are exactly the same as Minisat on which it 
+is based on. (see below).
+
+Glucose-Syrup sources are based on another copyright. Permissions and copyrights for the parallel
+version of Glucose-Syrup (the "Software") are granted, free of charge, to deal with the Software
+without restriction, including the rights to use, copy, modify, merge, publish, distribute,
+sublicence, and/or sell copies of the Software, and to permit persons to whom the Software is 
+furnished to do so, subject to the following conditions:
+
+- The above and below copyrights notices and this permission notice shall be included in all
+copies or substantial portions of the Software;
+- The parallel version of Glucose (all files modified since Glucose 3.0 releases, 2013) cannot
+be used in any competitive event (sat competitions/evaluations) without the express permission of 
+the authors (Gilles Audemard / Laurent Simon). This is also the case for any competitive event
+using Glucose Parallel as an embedded SAT engine (single core or not).
+
+
+--------------- Original Minisat Copyrights
+
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ **************************************************************************************************/
+
+
+#ifndef Glucose_BoundedQueue_h
+#define Glucose_BoundedQueue_h
+
+
+
+//=================================================================================================
+
+namespace Glucose {
+
+template <class T>
+class bqueue {
+    vec<T>  elems;
+    int     first;
+	int		last;
+	unsigned long long sumofqueue;
+	int     maxsize;
+	int     queuesize; // Number of current elements (must be < maxsize !)
+	bool expComputed;
+	double exp,value;
+public:
+ bqueue(void) : first(0), last(0), sumofqueue(0), maxsize(0), queuesize(0),expComputed(false) { } 
+	
+	void initSize(int size) {growTo(size);exp = 2.0/(size+1);} // Init size of bounded size queue
+	
+	void push(T x) {
+	  expComputed = false;
+		if (queuesize==maxsize) {
+			assert(last==first); // The queue is full, next value to enter will replace oldest one
+			sumofqueue -= elems[last];
+			if ((++last) == maxsize) last = 0;
+		} else 
+			queuesize++;
+		sumofqueue += x;
+		elems[first] = x;
+		if ((++first) == maxsize) {first = 0;last = 0;}
+	}
+
+	T peek() { assert(queuesize>0); return elems[last]; }
+	void pop() {sumofqueue-=elems[last]; queuesize--; if ((++last) == maxsize) last = 0;}
+	
+	unsigned long long getsum() const {return sumofqueue;}
+	unsigned int getavg() const {return (unsigned int)(sumofqueue/((unsigned long long)queuesize));}
+	int maxSize() const {return maxsize;}
+	double getavgDouble() const {
+	  double tmp = 0;
+	  for(int i=0;i<elems.size();i++) {
+	    tmp+=elems[i];
+	  }
+	  return tmp/elems.size();
+	}
+	int isvalid() const {return (queuesize==maxsize);}
+	
+	void growTo(int size) {
+		elems.growTo(size); 
+		first=0; maxsize=size; queuesize = 0;last = 0;
+		for(int i=0;i<size;i++) elems[i]=0; 
+	}
+	
+	double getAvgExp() {
+	  if(expComputed) return value;
+	  double a=exp;
+	  value = elems[first];
+	  for(int i  = first;i<maxsize;i++) {
+	    value+=a*((double)elems[i]);
+	    a=a*exp;
+	  }
+	  for(int i  = 0;i<last;i++) {
+	    value+=a*((double)elems[i]);
+	    a=a*exp;
+	  }
+	  value = value*(1-exp)/(1-a);
+	  expComputed = true;
+	  return value;
+	  
+
+	}
+	void fastclear() {first = 0; last = 0; queuesize=0; sumofqueue=0;} // to be called after restarts... Discard the queue
+	
+    int  size(void)    { return queuesize; }
+
+    void clear(bool dealloc = false)   { elems.clear(dealloc); first = 0; maxsize=0; queuesize=0;sumofqueue=0;}
+
+    void copyTo(bqueue &dest) const {
+        dest.last = last;
+        dest.sumofqueue = sumofqueue;
+        dest.maxsize = maxsize;
+        dest.queuesize = queuesize;
+        dest.expComputed = expComputed;
+        dest.exp = exp;
+        dest.value = value;
+        dest.first = first;        
+        elems.copyTo(dest.elems);
+    }
+};
+}
+//=================================================================================================
+
+#endif
+/***************************************************************************************[Constants.h]
+ Glucose -- Copyright (c) 2009-2014, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                LRI  - Univ. Paris Sud, France (2009-2013)
+                                Labri - Univ. Bordeaux, France
+
+ Syrup (Glucose Parallel) -- Copyright (c) 2013-2014, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                Labri - Univ. Bordeaux, France
+
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose (sources until 2013, Glucose 3.0, single core) are exactly the same as Minisat on which it 
+is based on. (see below).
+
+Glucose-Syrup sources are based on another copyright. Permissions and copyrights for the parallel
+version of Glucose-Syrup (the "Software") are granted, free of charge, to deal with the Software
+without restriction, including the rights to use, copy, modify, merge, publish, distribute,
+sublicence, and/or sell copies of the Software, and to permit persons to whom the Software is 
+furnished to do so, subject to the following conditions:
+
+- The above and below copyrights notices and this permission notice shall be included in all
+copies or substantial portions of the Software;
+- The parallel version of Glucose (all files modified since Glucose 3.0 releases, 2013) cannot
+be used in any competitive event (sat competitions/evaluations) without the express permission of 
+the authors (Gilles Audemard / Laurent Simon). This is also the case for any competitive event
+using Glucose Parallel as an embedded SAT engine (single core or not).
+
+
+--------------- Original Minisat Copyrights
+
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ **************************************************************************************************/
+
+#define DYNAMICNBLEVEL
+#define CONSTANTREMOVECLAUSE
+
+// Constants for clauses reductions
+#define RATIOREMOVECLAUSES 2
+
+
+// Constants for restarts
+#define LOWER_BOUND_FOR_BLOCKING_RESTART 10000
+
+/***************************************************************************************[Solver.h]
+ Glucose -- Copyright (c) 2009-2014, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                LRI  - Univ. Paris Sud, France (2009-2013)
+                                Labri - Univ. Bordeaux, France
+
+ Syrup (Glucose Parallel) -- Copyright (c) 2013-2014, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                Labri - Univ. Bordeaux, France
+
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose (sources until 2013, Glucose 3.0, single core) are exactly the same as Minisat on which it 
+is based on. (see below).
+
+Glucose-Syrup sources are based on another copyright. Permissions and copyrights for the parallel
+version of Glucose-Syrup (the "Software") are granted, free of charge, to deal with the Software
+without restriction, including the rights to use, copy, modify, merge, publish, distribute,
+sublicence, and/or sell copies of the Software, and to permit persons to whom the Software is 
+furnished to do so, subject to the following conditions:
+
+- The above and below copyrights notices and this permission notice shall be included in all
+copies or substantial portions of the Software;
+- The parallel version of Glucose (all files modified since Glucose 3.0 releases, 2013) cannot
+be used in any competitive event (sat competitions/evaluations) without the express permission of 
+the authors (Gilles Audemard / Laurent Simon). This is also the case for any competitive event
+using Glucose Parallel as an embedded SAT engine (single core or not).
+
+
+--------------- Original Minisat Copyrights
+
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ **************************************************************************************************/
+
+#ifndef SOLVERSTATS_H
+#define	SOLVERSTATS_H
+
+
+#include <string>
+namespace Glucose {
+
+    class SolverStats {
+    protected:
+        Map<std::string, uint64_t> map;
+
+    public:
+
+        SolverStats(std::string all[],int sz) : map() {
+            addStats(all,sz);
+        }
+
+        void addStats(std::string names[],int sz) {
+            for(int i = 0;i<sz;i++)
+                addStat(names[i]);
+        }
+        
+        void addStat(std::string name) {
+            map.insert(name, 0);
+        }
+
+        const uint64_t& operator [] (const std::string name) const {
+            return map[name];
+        }
+
+         uint64_t& operator [] (const std::string name)  {
+            return map[name];
+        }
+
+        void maximize(const std::string name,uint64_t val) {
+            if(val > map[name])
+                map[name] = val;
+        } 
+         
+        void minimize(const std::string name,uint64_t val) {
+            if(val < map[name])
+                map[name] = val;
+        } 
+
+};
+
+}
+
+#endif	/* SOLVERSTATS_H */
+
+/***************************************************************************************[Solver.h]
+ Glucose -- Copyright (c) 2009-2014, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                LRI  - Univ. Paris Sud, France (2009-2013)
+                                Labri - Univ. Bordeaux, France
+
+ Syrup (Glucose Parallel) -- Copyright (c) 2013-2014, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                Labri - Univ. Bordeaux, France
+
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose (sources until 2013, Glucose 3.0, single core) are exactly the same as Minisat on which it 
+is based on. (see below).
+
+Glucose-Syrup sources are based on another copyright. Permissions and copyrights for the parallel
+version of Glucose-Syrup (the "Software") are granted, free of charge, to deal with the Software
+without restriction, including the rights to use, copy, modify, merge, publish, distribute,
+sublicence, and/or sell copies of the Software, and to permit persons to whom the Software is 
+furnished to do so, subject to the following conditions:
+
+- The above and below copyrights notices and this permission notice shall be included in all
+copies or substantial portions of the Software;
+- The parallel version of Glucose (all files modified since Glucose 3.0 releases, 2013) cannot
+be used in any competitive event (sat competitions/evaluations) without the express permission of 
+the authors (Gilles Audemard / Laurent Simon). This is also the case for any competitive event
+using Glucose Parallel as an embedded SAT engine (single core or not).
+
+
+--------------- Original Minisat Copyrights
+
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ **************************************************************************************************/
+
+#ifndef Glucose_Solver_h
+#define Glucose_Solver_h
+
+
+
+
+
+
+
+
+
+
+
+namespace Glucose {
+// Core stats 
+    
+enum CoreStats {
+  sumResSeen,
+  sumRes,
+  sumTrail,  
+  nbPromoted,
+  originalClausesSeen,
+  sumDecisionLevels,
+  nbPermanentLearnts,
+  nbRemovedClauses,
+  nbRemovedUnaryWatchedClauses,
+  nbReducedClauses,
+  nbDL2,
+  nbBin,
+  nbUn,
+  nbReduceDB,
+  rnd_decisions,
+  nbstopsrestarts,
+  nbstopsrestartssame,
+  lastblockatrestart,
+  dec_vars,
+  clauses_literals,
+  learnts_literals,
+  max_literals,
+  tot_literals,
+  noDecisionConflict
+} ;
+
+#define coreStatsSize 24
+//=================================================================================================
+// Solver -- the main class:
+
+class Solver : public Clone {
+
+    friend class SolverConfiguration;
+
+public:
+
+    // Constructor/Destructor:
+    //
+    Solver();
+    Solver(const  Solver &s);
+    
+    virtual ~Solver();
+    
+    /**
+     * Clone function
+     */
+    virtual Clone* clone() const {
+        return  new Solver(*this);
+    }   
+
+    // Problem specification:
+    //
+    virtual Var     newVar    (bool polarity = true, bool dvar = true); // Add a new variable with parameters specifying variable mode.
+    bool    addClause (const vec<Lit>& ps);                     // Add a clause to the solver. 
+    bool    addEmptyClause();                                   // Add the empty clause, making the solver contradictory.
+    bool    addClause (Lit p);                                  // Add a unit clause to the solver. 
+    bool    addClause (Lit p, Lit q);                           // Add a binary clause to the solver. 
+    bool    addClause (Lit p, Lit q, Lit r);                    // Add a ternary clause to the solver. 
+    virtual bool    addClause_(      vec<Lit>& ps);                     // Add a clause to the solver without making superflous internal copy. Will
+                                                                // change the passed vector 'ps'.
+    // Solving:
+    //
+    bool    simplify     ();                        // Removes already satisfied clauses.
+    bool    solve        (const vec<Lit>& assumps); // Search for a model that respects a given set of assumptions.
+    lbool   solveLimited (const vec<Lit>& assumps); // Search for a model that respects a given set of assumptions (With resource constraints).
+    bool    solve        ();                        // Search without assumptions.
+    bool    solve        (Lit p);                   // Search for a model that respects a single assumption.
+    bool    solve        (Lit p, Lit q);            // Search for a model that respects two assumptions.
+    bool    solve        (Lit p, Lit q, Lit r);     // Search for a model that respects three assumptions.
+    bool    okay         () const;                  // FALSE means solver is in a conflicting state
+
+       // Convenience versions of 'toDimacs()':
+    void    toDimacs     (FILE* f, const vec<Lit>& assumps);            // Write CNF to file in DIMACS-format.
+    void    toDimacs     (const char *file, const vec<Lit>& assumps);
+    void    toDimacs     (FILE* f, Clause& c, vec<Var>& map, Var& max);
+    void    toDimacs     (const char* file);
+    void    toDimacs     (const char* file, Lit p);
+    void    toDimacs     (const char* file, Lit p, Lit q);
+    void    toDimacs     (const char* file, Lit p, Lit q, Lit r);
+ 
+    // Display clauses and literals
+    void printLit(Lit l);
+    void printClause(CRef c);
+    void printInitialClause(CRef c);
+    
+    // Variable mode:
+    // 
+    void    setPolarity    (Var v, bool b); // Declare which polarity the decision heuristic should use for a variable. Requires mode 'polarity_user'.
+    void    setDecisionVar (Var v, bool b); // Declare if a variable should be eligible for selection in the decision heuristic.
+
+    // Read state:
+    //
+    lbool   value      (Var x) const;       // The current value of a variable.
+    lbool   value      (Lit p) const;       // The current value of a literal.
+    lbool   modelValue (Var x) const;       // The value of a variable in the last model. The last call to solve must have been satisfiable.
+    lbool   modelValue (Lit p) const;       // The value of a literal in the last model. The last call to solve must have been satisfiable.
+    int     nAssigns   ()      const;       // The current number of assigned literals.
+    int     nClauses   ()      const;       // The current number of original clauses.
+    int     nLearnts   ()      const;       // The current number of learnt clauses.
+    int     nVars      ()      const;       // The current number of variables.
+    int     nFreeVars  ()      ;
+
+    inline char valuePhase(Var v) {return polarity[v];}
+
+    // Incremental mode
+    void setIncrementalMode();
+    void initNbInitialVars(int nb);
+    void printIncrementalStats();
+    bool isIncremental();
+    // Resource contraints:
+    //
+    void    setConfBudget(int64_t x);
+    void    setPropBudget(int64_t x);
+    void    budgetOff();
+    void    interrupt();          // Trigger a (potentially asynchronous) interruption of the solver.
+    void    clearInterrupt();     // Clear interrupt indicator flag.
+
+    // Memory managment:
+    //
+    virtual void garbageCollect();
+    void    checkGarbage(double gf);
+    void    checkGarbage();
+
+    // Extra results: (read-only member variable)
+    //
+    vec<lbool> model;             // If problem is satisfiable, this vector contains the model (if any).
+    vec<Lit>   conflict;          // If problem is unsatisfiable (possibly under assumptions),
+                                  // this vector represent the final conflict clause expressed in the assumptions.
+
+    // Mode of operation:
+    //
+    int       verbosity;
+    int       verbEveryConflicts;
+    int       showModel;
+    
+    // Constants For restarts
+    double    K;
+    double    R;
+    double    sizeLBDQueue;
+    double    sizeTrailQueue;
+
+    // Constants for reduce DB
+    int          firstReduceDB;
+    int          incReduceDB;
+    int          specialIncReduceDB;
+    unsigned int lbLBDFrozenClause;
+    bool         chanseokStrategy;
+    int          coLBDBound; // Keep all learnts with lbd<=coLBDBound
+    // Constant for reducing clause
+    int          lbSizeMinimizingClause;
+    unsigned int lbLBDMinimizingClause;
+
+    // Constant for heuristic
+    double    var_decay;
+    double    max_var_decay;
+    double    clause_decay;
+    double    random_var_freq;
+    double    random_seed;
+    int       ccmin_mode;         // Controls conflict clause minimization (0=none, 1=basic, 2=deep).
+    int       phase_saving;       // Controls the level of phase saving (0=none, 1=limited, 2=full).
+    bool      rnd_pol;            // Use random polarities for branching heuristics.
+    bool      rnd_init_act;       // Initialize variable activities with a small random value.
+    bool      randomizeFirstDescent; // the first decisions (until first cnflict) are made randomly
+                                     // Useful for syrup!
+    
+    // Constant for Memory managment
+    double    garbage_frac;       // The fraction of wasted memory allowed before a garbage collection is triggered.
+
+    // Certified UNSAT ( Thanks to Marijn Heule
+    // New in 2016 : proof in DRAT format, possibility to use binary output
+    FILE*               certifiedOutput;
+    bool                certifiedUNSAT;
+    bool                vbyte;
+
+    void write_char (unsigned char c);
+    void write_lit (int n);
+
+
+    // Panic mode. 
+    // Save memory
+    uint32_t panicModeLastRemoved, panicModeLastRemovedShared;
+    
+    bool useUnaryWatched;            // Enable unary watched literals
+    bool promoteOneWatchedClause;    // One watched clauses are promotted to two watched clauses if found empty
+    
+    // Functions useful for multithread solving
+    // Useless in the sequential case 
+    // Overide in ParallelSolver
+    virtual void parallelImportClauseDuringConflictAnalysis(Clause &c,CRef confl);
+    virtual bool parallelImportClauses(); // true if the empty clause was received
+    virtual void parallelImportUnaryClauses();
+    virtual void parallelExportUnaryClause(Lit p);
+    virtual void parallelExportClauseDuringSearch(Clause &c);
+    virtual bool parallelJobIsFinished();
+    virtual bool panicModeIsEnabled();
+    
+    
+    double luby(double y, int x);
+    
+    // Statistics 
+    vec<uint64_t> stats;
+    
+    // Important stats completely related to search. Keep here
+    uint64_t solves,starts,decisions,propagations,conflicts,conflictsRestarts;
+
+protected:
+
+    long curRestart;
+
+    // Alpha variables
+    bool glureduce;
+    uint32_t restart_inc;
+    bool  luby_restart;
+    bool adaptStrategies;
+    uint32_t luby_restart_factor;
+    bool randomize_on_restarts, fixed_randomize_on_restarts, newDescent;
+    uint32_t randomDescentAssignments;
+    bool forceUnsatOnNewDescent;
+    // Helper structures:
+    //
+    struct VarData { CRef reason; int level; };
+    static inline VarData mkVarData(CRef cr, int l){ VarData d = {cr, l}; return d; }
+
+    struct Watcher {
+        CRef cref;
+        Lit  blocker;
+        Watcher(CRef cr, Lit p) : cref(cr), blocker(p) {}
+        bool operator==(const Watcher& w) const { return cref == w.cref; }
+        bool operator!=(const Watcher& w) const { return cref != w.cref; }
+/*        Watcher &operator=(Watcher w) {
+            this->cref = w.cref;
+            this->blocker = w.blocker;
+            return *this;
+        }
+*/
+    };
+
+    struct WatcherDeleted
+    {
+        const ClauseAllocator& ca;
+        WatcherDeleted(const ClauseAllocator& _ca) : ca(_ca) {}
+        bool operator()(const Watcher& w) const { return ca[w.cref].mark() == 1; }
+    };
+
+    struct VarOrderLt {
+        const vec<double>&  activity;
+        bool operator () (Var x, Var y) const { return activity[x] > activity[y]; }
+        VarOrderLt(const vec<double>&  act) : activity(act) { }
+    };
+
+
+    // Solver state:
+    //
+    int                lastIndexRed;
+    bool                ok;               // If FALSE, the constraints are already unsatisfiable. No part of the solver state may be used!
+    double              cla_inc;          // Amount to bump next clause with.
+    vec<double>         activity;         // A heuristic measurement of the activity of a variable.
+    double              var_inc;          // Amount to bump next variable with.
+    OccLists<Lit, vec<Watcher>, WatcherDeleted>
+                        watches;          // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true).
+    OccLists<Lit, vec<Watcher>, WatcherDeleted>
+                        watchesBin;          // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true).
+    OccLists<Lit, vec<Watcher>, WatcherDeleted>
+                        unaryWatches;       //  Unary watch scheme (clauses are seen when they become empty
+    vec<CRef>           clauses;          // List of problem clauses.
+    vec<CRef>           learnts;          // List of learnt clauses.
+    vec<CRef>           permanentLearnts; // The list of learnts clauses kept permanently
+    vec<CRef>           unaryWatchedClauses;  // List of imported clauses (after the purgatory) // TODO put inside ParallelSolver
+
+    vec<lbool>          assigns;          // The current assignments.
+    vec<char>           polarity;         // The preferred polarity of each variable.
+    vec<char>           forceUNSAT;
+    void                bumpForceUNSAT(Lit q); // Handles the forces
+
+    vec<char>           decision;         // Declares if a variable is eligible for selection in the decision heuristic.
+    vec<Lit>            trail;            // Assignment stack; stores all assigments made in the order they were made.
+    vec<int>            nbpos;
+    vec<int>            trail_lim;        // Separator indices for different decision levels in 'trail'.
+    vec<VarData>        vardata;          // Stores reason and level for each variable.
+    int                 qhead;            // Head of queue (as index into the trail -- no more explicit propagation queue in MiniSat).
+    int                 simpDB_assigns;   // Number of top-level assignments since last execution of 'simplify()'.
+    int64_t             simpDB_props;     // Remaining number of propagations that must be made before next execution of 'simplify()'.
+    vec<Lit>            assumptions;      // Current set of assumptions provided to solve by the user.
+    Heap<VarOrderLt>    order_heap;       // A priority queue of variables ordered with respect to the variable activity.
+    double              progress_estimate;// Set by 'search()'.
+    bool                remove_satisfied; // Indicates whether possibly inefficient linear scan for satisfied clauses should be performed in 'simplify'.
+    vec<unsigned int>   permDiff;           // permDiff[var] contains the current conflict number... Used to count the number of  LBD
+    
+
+    // UPDATEVARACTIVITY trick (see competition'09 companion paper)
+    vec<Lit> lastDecisionLevel; 
+
+    ClauseAllocator     ca;
+
+    int nbclausesbeforereduce;            // To know when it is time to reduce clause database
+    
+    // Used for restart strategies
+    bqueue<unsigned int> trailQueue,lbdQueue; // Bounded queues for restarts.
+    float sumLBD; // used to compute the global average of LBD. Restarts...
+    int sumAssumptions;
+    CRef lastLearntClause;
+
+
+    // Temporaries (to reduce allocation overhead). Each variable is prefixed by the method in which it is
+    // used, exept 'seen' wich is used in several places.
+    //
+    vec<char>           seen;
+    vec<Lit>            analyze_stack;
+    vec<Lit>            analyze_toclear;
+    vec<Lit>            add_tmp;
+    unsigned int  MYFLAG;
+
+    // Initial reduceDB strategy
+    double              max_learnts;
+    double              learntsize_adjust_confl;
+    int                 learntsize_adjust_cnt;
+
+    // Resource contraints:
+    //
+    int64_t             conflict_budget;    // -1 means no budget.
+    int64_t             propagation_budget; // -1 means no budget.
+    bool                asynch_interrupt;
+
+    // Variables added for incremental mode
+    int incremental; // Use incremental SAT Solver
+    int nbVarsInitialFormula; // nb VAR in formula without assumptions (incremental SAT)
+    double totalTime4Sat,totalTime4Unsat;
+    int nbSatCalls,nbUnsatCalls;
+    vec<int> assumptionPositions,initialPositions;
+
+
+    // Main internal methods:
+    //
+    void     insertVarOrder   (Var x);                                                 // Insert a variable in the decision order priority queue.
+    Lit      pickBranchLit    ();                                                      // Return the next decision variable.
+    void     newDecisionLevel ();                                                      // Begins a new decision level.
+    void     uncheckedEnqueue (Lit p, CRef from = CRef_Undef);                         // Enqueue a literal. Assumes value of literal is undefined.
+    bool     enqueue          (Lit p, CRef from = CRef_Undef);                         // Test if fact 'p' contradicts current state, enqueue otherwise.
+    CRef     propagate        ();                                                      // Perform unit propagation. Returns possibly conflicting clause.
+    CRef     propagateUnaryWatches(Lit p);                                                  // Perform propagation on unary watches of p, can find only conflicts
+    void     cancelUntil      (int level);                                             // Backtrack until a certain level.
+    void     analyze          (CRef confl, vec<Lit>& out_learnt, vec<Lit> & selectors, int& out_btlevel,unsigned int &nblevels,unsigned int &szWithoutSelectors);    // (bt = backtrack)
+    void     analyzeFinal     (Lit p, vec<Lit>& out_conflict);                         // COULD THIS BE IMPLEMENTED BY THE ORDINARIY "analyze" BY SOME REASONABLE GENERALIZATION?
+    bool     litRedundant     (Lit p, uint32_t abstract_levels);                       // (helper method for 'analyze()')
+    lbool    search           (int nof_conflicts);                                     // Search for a given number of conflicts.
+    virtual lbool    solve_           (bool do_simp = true, bool turn_off_simp = false);                                                      // Main solve method (assumptions given in 'assumptions').
+    virtual void     reduceDB         ();                                              // Reduce the set of learnt clauses.
+    void     removeSatisfied  (vec<CRef>& cs);                                         // Shrink 'cs' to contain only non-satisfied clauses.
+    void     rebuildOrderHeap ();
+
+    void     adaptSolver();                                                            // Adapt solver strategies
+
+    // Maintaining Variable/Clause activity:
+    //
+    void     varDecayActivity ();                      // Decay all variables with the specified factor. Implemented by increasing the 'bump' value instead.
+    void     varBumpActivity  (Var v, double inc);     // Increase a variable with the current 'bump' value.
+    void     varBumpActivity  (Var v);                 // Increase a variable with the current 'bump' value.
+    void     claDecayActivity ();                      // Decay all clauses with the specified factor. Implemented by increasing the 'bump' value instead.
+    void     claBumpActivity  (Clause& c);             // Increase a clause with the current 'bump' value.
+
+    // Operations on clauses:
+    //
+    void     attachClause     (CRef cr);               // Attach a clause to watcher lists.
+    void     detachClause     (CRef cr, bool strict = false); // Detach a clause to watcher lists.
+    void     detachClausePurgatory(CRef cr, bool strict = false);
+    void     attachClausePurgatory(CRef cr);
+    void     removeClause     (CRef cr, bool inPurgatory = false);               // Detach and free a clause.
+    bool     locked           (const Clause& c) const; // Returns TRUE if a clause is a reason for some implication in the current state.
+    bool     satisfied        (const Clause& c) const; // Returns TRUE if a clause is satisfied in the current state.
+
+    template <typename T> unsigned int computeLBD(const T & lits,int end=-1);
+    void minimisationWithBinaryResolution(vec<Lit> &out_learnt);
+
+    virtual void     relocAll         (ClauseAllocator& to);
+
+    // Misc:
+    //
+    int      decisionLevel    ()      const; // Gives the current decisionlevel.
+    uint32_t abstractLevel    (Var x) const; // Used to represent an abstraction of sets of decision levels.
+    CRef     reason           (Var x) const;
+    int      level            (Var x) const;
+    double   progressEstimate ()      const; // DELETE THIS ?? IT'S NOT VERY USEFUL ...
+    bool     withinBudget     ()      const;
+    inline bool isSelector(Var v) {return (incremental && v>nbVarsInitialFormula);}
+
+    // Static helpers:
+    //
+
+    // Returns a random float 0 <= x < 1. Seed must never be 0.
+    static inline double drand(double& seed) {
+        seed *= 1389796;
+        int q = (int)(seed / 2147483647);
+        seed -= (double)q * 2147483647;
+        return seed / 2147483647; }
+
+    // Returns a random integer 0 <= x < size. Seed must never be 0.
+    static inline int irand(double& seed, int size) {
+        return (int)(drand(seed) * size); }
+};
+
+
+//=================================================================================================
+// Implementation of inline methods:
+
+inline CRef Solver::reason(Var x) const { return vardata[x].reason; }
+inline int  Solver::level (Var x) const { return vardata[x].level; }
+
+inline void Solver::insertVarOrder(Var x) {
+    if (!order_heap.inHeap(x) && decision[x]) order_heap.insert(x); }
+
+inline void Solver::varDecayActivity() { var_inc *= (1 / var_decay); }
+inline void Solver::varBumpActivity(Var v) { varBumpActivity(v, var_inc); }
+inline void Solver::varBumpActivity(Var v, double inc) {
+    if ( (activity[v] += inc) > 1e100 ) {
+        // Rescale:
+        for (int i = 0; i < nVars(); i++)
+            activity[i] *= 1e-100;
+        var_inc *= 1e-100; }
+
+    // Update order_heap with respect to new activity:
+    if (order_heap.inHeap(v))
+        order_heap.decrease(v); }
+
+inline void Solver::claDecayActivity() { cla_inc *= (1 / clause_decay); }
+inline void Solver::claBumpActivity (Clause& c) {
+        if ( (c.activity() += cla_inc) > 1e20 ) {
+            // Rescale:
+            for (int i = 0; i < learnts.size(); i++)
+                ca[learnts[i]].activity() *= 1e-20;
+            cla_inc *= 1e-20; } }
+
+inline void Solver::checkGarbage(void){ return checkGarbage(garbage_frac); }
+inline void Solver::checkGarbage(double gf){
+    if (ca.wasted() > ca.size() * gf)
+        garbageCollect(); }
+
+// NOTE: enqueue does not set the ok flag! (only public methods do)
+inline bool     Solver::enqueue         (Lit p, CRef from)      { return value(p) != l_Undef ? value(p) != l_False : (uncheckedEnqueue(p, from), true); }
+inline bool     Solver::addClause       (const vec<Lit>& ps)    { ps.copyTo(add_tmp); return addClause_(add_tmp); }
+inline bool     Solver::addEmptyClause  ()                      { add_tmp.clear(); return addClause_(add_tmp); }
+inline bool     Solver::addClause       (Lit p)                 { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); }
+inline bool     Solver::addClause       (Lit p, Lit q)          { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); }
+inline bool     Solver::addClause       (Lit p, Lit q, Lit r)   { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); }
+ inline bool     Solver::locked          (const Clause& c) const { 
+   if(c.size()>2) 
+     return value(c[0]) == l_True && reason(var(c[0])) != CRef_Undef && ca.lea(reason(var(c[0]))) == &c; 
+   return 
+     (value(c[0]) == l_True && reason(var(c[0])) != CRef_Undef && ca.lea(reason(var(c[0]))) == &c)
+     || 
+     (value(c[1]) == l_True && reason(var(c[1])) != CRef_Undef && ca.lea(reason(var(c[1]))) == &c);
+ }
+inline void     Solver::newDecisionLevel()                      { trail_lim.push(trail.size()); }
+
+inline int      Solver::decisionLevel ()      const   { return trail_lim.size(); }
+inline uint32_t Solver::abstractLevel (Var x) const   { return 1 << (level(x) & 31); }
+inline lbool    Solver::value         (Var x) const   { return assigns[x]; }
+inline lbool    Solver::value         (Lit p) const   { return assigns[var(p)] ^ sign(p); }
+inline lbool    Solver::modelValue    (Var x) const   { return model[x]; }
+inline lbool    Solver::modelValue    (Lit p) const   { return model[var(p)] ^ sign(p); }
+inline int      Solver::nAssigns      ()      const   { return trail.size(); }
+inline int      Solver::nClauses      ()      const   { return clauses.size(); }
+inline int      Solver::nLearnts      ()      const   { return learnts.size(); }
+inline int      Solver::nVars         ()      const   { return vardata.size(); }
+inline int      Solver::nFreeVars     ()         { 
+    int a = stats[dec_vars];
+    return (int)(a) - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]); }
+inline void     Solver::setPolarity   (Var v, bool b) { polarity[v] = b; }
+inline void     Solver::setDecisionVar(Var v, bool b) 
+{ 
+    if      ( b && !decision[v]) stats[dec_vars]++;
+    else if (!b &&  decision[v]) stats[dec_vars]--;
+
+    decision[v] = b;
+    insertVarOrder(v);
+}
+inline void     Solver::setConfBudget(int64_t x){ conflict_budget    = conflicts    + x; }
+inline void     Solver::setPropBudget(int64_t x){ propagation_budget = propagations + x; }
+inline void     Solver::interrupt(){ asynch_interrupt = true; }
+inline void     Solver::clearInterrupt(){ asynch_interrupt = false; }
+inline void     Solver::budgetOff(){ conflict_budget = propagation_budget = -1; }
+inline bool     Solver::withinBudget() const {
+    return !asynch_interrupt &&
+           (conflict_budget    < 0 || conflicts < (uint64_t)conflict_budget) &&
+           (propagation_budget < 0 || propagations < (uint64_t)propagation_budget); }
+
+// FIXME: after the introduction of asynchronous interrruptions the solve-versions that return a
+// pure bool do not give a safe interface. Either interrupts must be possible to turn off here, or
+// all calls to solve must return an 'lbool'. I'm not yet sure which I prefer.
+inline bool     Solver::solve         ()                    { budgetOff(); assumptions.clear(); return solve_() == l_True; }
+inline bool     Solver::solve         (Lit p)               { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_() == l_True; }
+inline bool     Solver::solve         (Lit p, Lit q)        { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_() == l_True; }
+inline bool     Solver::solve         (Lit p, Lit q, Lit r) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_() == l_True; }
+inline bool     Solver::solve         (const vec<Lit>& assumps){ budgetOff(); assumps.copyTo(assumptions); return solve_() == l_True; }
+inline lbool    Solver::solveLimited  (const vec<Lit>& assumps){ assumps.copyTo(assumptions); return solve_(); }
+inline bool     Solver::okay          ()      const   { return ok; }
+
+inline void     Solver::toDimacs     (const char* file){ vec<Lit> as; toDimacs(file, as); }
+inline void     Solver::toDimacs     (const char* file, Lit p){ vec<Lit> as; as.push(p); toDimacs(file, as); }
+inline void     Solver::toDimacs     (const char* file, Lit p, Lit q){ vec<Lit> as; as.push(p); as.push(q); toDimacs(file, as); }
+inline void     Solver::toDimacs     (const char* file, Lit p, Lit q, Lit r){ vec<Lit> as; as.push(p); as.push(q); as.push(r); toDimacs(file, as); }
+
+
+
+//=================================================================================================
+// Debug etc:
+
+
+inline void Solver::printLit(Lit l)
+{
+    printf("%s%d:%c", sign(l) ? "-" : "", var(l)+1, value(l) == l_True ? '1' : (value(l) == l_False ? '0' : 'X'));
+}
+
+
+inline void Solver::printClause(CRef cr)
+{
+  Clause &c = ca[cr];
+    for (int i = 0; i < c.size(); i++){
+        printLit(c[i]);
+        printf(" ");
+    }
+}
+
+inline void Solver::printInitialClause(CRef cr)
+{
+  Clause &c = ca[cr];
+    for (int i = 0; i < c.size(); i++){
+      if(!isSelector(var(c[i]))) {
+	printLit(c[i]);
+        printf(" ");
+      }
+    }
+}
+
+//=================================================================================================
+struct reduceDBAct_lt {
+    ClauseAllocator& ca;
+
+    reduceDBAct_lt(ClauseAllocator& ca_) : ca(ca_) {
+    }
+
+    bool operator()(CRef x, CRef y) {
+
+        // Main criteria... Like in MiniSat we keep all binary clauses
+        if (ca[x].size() > 2 && ca[y].size() == 2) return 1;
+
+        if (ca[y].size() > 2 && ca[x].size() == 2) return 0;
+        if (ca[x].size() == 2 && ca[y].size() == 2) return 0;
+
+        return ca[x].activity() < ca[y].activity();
+    }
+};
+
+struct reduceDB_lt {
+    ClauseAllocator& ca;
+
+    reduceDB_lt(ClauseAllocator& ca_) : ca(ca_) {
+    }
+
+    bool operator()(CRef x, CRef y) {
+
+        // Main criteria... Like in MiniSat we keep all binary clauses
+        if (ca[x].size() > 2 && ca[y].size() == 2) return 1;
+
+        if (ca[y].size() > 2 && ca[x].size() == 2) return 0;
+        if (ca[x].size() == 2 && ca[y].size() == 2) return 0;
+
+        // Second one  based on literal block distance
+        if (ca[x].lbd() > ca[y].lbd()) return 1;
+        if (ca[x].lbd() < ca[y].lbd()) return 0;
+
+
+        // Finally we can use old activity or size, we choose the last one
+        return ca[x].activity() < ca[y].activity();
+        //return x->size() < y->size();
+
+        //return ca[x].size() > 2 && (ca[y].size() == 2 || ca[x].activity() < ca[y].activity()); } 
+    }
+};
+
+
+}
+
+
+#endif
+/***************************************************************************************[Solver.cc]
+ Glucose -- Copyright (c) 2009-2014, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                LRI  - Univ. Paris Sud, France (2009-2013)
+                                Labri - Univ. Bordeaux, France
+
+ Syrup (Glucose Parallel) -- Copyright (c) 2013-2014, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                Labri - Univ. Bordeaux, France
+
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose (sources until 2013, Glucose 3.0, single core) are exactly the same as Minisat on which it 
+is based on. (see below).
+
+Glucose-Syrup sources are based on another copyright. Permissions and copyrights for the parallel
+version of Glucose-Syrup (the "Software") are granted, free of charge, to deal with the Software
+without restriction, including the rights to use, copy, modify, merge, publish, distribute,
+sublicence, and/or sell copies of the Software, and to permit persons to whom the Software is 
+furnished to do so, subject to the following conditions:
+
+- The above and below copyrights notices and this permission notice shall be included in all
+copies or substantial portions of the Software;
+- The parallel version of Glucose (all files modified since Glucose 3.0 releases, 2013) cannot
+be used in any competitive event (sat competitions/evaluations) without the express permission of 
+the authors (Gilles Audemard / Laurent Simon). This is also the case for any competitive event
+using Glucose Parallel as an embedded SAT engine (single core or not).
+
+
+--------------- Original Minisat Copyrights
+
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ **************************************************************************************************/
+
+#include <math.h>
+
+
+
+
+
+
+
+namespace Glucose {
+
+
+//=================================================================================================
+// Statistics
+//=================================================================================================
+
+
+
+//=================================================================================================
+// Options:
+
+static const char *_cat = "CORE";
+static const char *_cr = "CORE -- RESTART";
+static const char *_cred = "CORE -- REDUCE";
+static const char *_cm = "CORE -- MINIMIZE";
+
+
+static DoubleOption opt_K(_cr, "K", "The constant used to force restart", 0.8, DoubleRange(0, false, 1, false));
+static DoubleOption opt_R(_cr, "R", "The constant used to block restart", 1.4, DoubleRange(1, false, 5, false));
+static IntOption opt_size_lbd_queue(_cr, "szLBDQueue", "The size of moving average for LBD (restarts)", 50, IntRange(10, INT32_MAX));
+static IntOption opt_size_trail_queue(_cr, "szTrailQueue", "The size of moving average for trail (block restarts)", 5000, IntRange(10, INT32_MAX));
+
+static IntOption opt_first_reduce_db(_cred, "firstReduceDB", "The number of conflicts before the first reduce DB (or the size of leernts if chanseok is used)",
+                                     2000, IntRange(0, INT32_MAX));
+static IntOption opt_inc_reduce_db(_cred, "incReduceDB", "Increment for reduce DB", 300, IntRange(0, INT32_MAX));
+static IntOption opt_spec_inc_reduce_db(_cred, "specialIncReduceDB", "Special increment for reduce DB", 1000, IntRange(0, INT32_MAX));
+static IntOption opt_lb_lbd_frozen_clause(_cred, "minLBDFrozenClause", "Protect clauses if their LBD decrease and is lower than (for one turn)", 30,
+                                          IntRange(0, INT32_MAX));
+static BoolOption opt_chanseok_hack(_cred, "chanseok",
+                                    "Use Chanseok Oh strategy for LBD (keep all LBD<=co and remove half of firstreduceDB other learnt clauses", false);
+static IntOption opt_chanseok_limit(_cred, "co", "Chanseok Oh: all learnt clauses with LBD<=co are permanent", 5, IntRange(2, INT32_MAX));
+
+
+static IntOption opt_lb_size_minimzing_clause(_cm, "minSizeMinimizingClause", "The min size required to minimize clause", 30, IntRange(3, INT32_MAX));
+static IntOption opt_lb_lbd_minimzing_clause(_cm, "minLBDMinimizingClause", "The min LBD required to minimize clause", 6, IntRange(3, INT32_MAX));
+
+
+static DoubleOption opt_var_decay(_cat, "var-decay", "The variable activity decay factor (starting point)", 0.8, DoubleRange(0, false, 1, false));
+static DoubleOption opt_max_var_decay(_cat, "max-var-decay", "The variable activity decay factor", 0.95, DoubleRange(0, false, 1, false));
+static DoubleOption opt_clause_decay(_cat, "cla-decay", "The clause activity decay factor", 0.999, DoubleRange(0, false, 1, false));
+static DoubleOption opt_random_var_freq(_cat, "rnd-freq", "The frequency with which the decision heuristic tries to choose a random variable", 0,
+                                        DoubleRange(0, true, 1, true));
+static DoubleOption opt_random_seed(_cat, "rnd-seed", "Used by the random variable selection", 91648253, DoubleRange(0, false, HUGE_VAL, false));
+static IntOption opt_ccmin_mode(_cat, "ccmin-mode", "Controls conflict clause minimization (0=none, 1=basic, 2=deep)", 2, IntRange(0, 2));
+static IntOption opt_phase_saving(_cat, "phase-saving", "Controls the level of phase saving (0=none, 1=limited, 2=full)", 2, IntRange(0, 2));
+static BoolOption opt_rnd_init_act(_cat, "rnd-init", "Randomize the initial activity", false);
+static DoubleOption opt_garbage_frac(_cat, "gc-frac", "The fraction of wasted memory allowed before a garbage collection is triggered", 0.20,
+                                     DoubleRange(0, false, HUGE_VAL, false));
+static BoolOption opt_glu_reduction(_cat, "gr", "glucose strategy to fire clause database reduction (must be false to fire Chanseok strategy)", true);
+static BoolOption opt_luby_restart(_cat, "luby", "Use the Luby restart sequence", false);
+static DoubleOption opt_restart_inc(_cat, "rinc", "Restart interval increase factor", 2, DoubleRange(1, false, HUGE_VAL, false));
+static IntOption opt_luby_restart_factor(_cred, "luby-factor", "Luby restart factor", 100, IntRange(1, INT32_MAX));
+
+static IntOption opt_randomize_phase_on_restarts(_cat, "phase-restart",
+                                                 "The amount of randomization for the phase at each restart (0=none, 1=first branch, 2=first branch (no bad clauses), 3=first branch (only initial clauses)",
+                                                 0, IntRange(0, 3));
+static BoolOption opt_fixed_randomize_phase_on_restarts(_cat, "fix-phas-rest", "Fixes the first 7 levels at random phase", false);
+
+static BoolOption opt_adapt(_cat, "adapt", "Adapt dynamically stategies after 100000 conflicts", true);
+
+static BoolOption opt_forceunsat(_cat,"forceunsat","Force the phase for UNSAT",true);
+//=================================================================================================
+// Constructor/Destructor:
+
+inline Solver::Solver() :
+
+// Parameters (user settable):
+//
+verbosity(0)
+, showModel(0)
+, K(opt_K)
+, R(opt_R)
+, sizeLBDQueue(opt_size_lbd_queue)
+, sizeTrailQueue(opt_size_trail_queue)
+, firstReduceDB(opt_first_reduce_db)
+, incReduceDB(opt_chanseok_hack ? 0 : opt_inc_reduce_db)
+, specialIncReduceDB(opt_chanseok_hack ? 0 : opt_spec_inc_reduce_db)
+, lbLBDFrozenClause(opt_lb_lbd_frozen_clause)
+, chanseokStrategy(opt_chanseok_hack)
+, coLBDBound (opt_chanseok_limit)
+, lbSizeMinimizingClause(opt_lb_size_minimzing_clause)
+, lbLBDMinimizingClause(opt_lb_lbd_minimzing_clause)
+, var_decay(opt_var_decay)
+, max_var_decay(opt_max_var_decay)
+, clause_decay(opt_clause_decay)
+, random_var_freq(opt_random_var_freq)
+, random_seed(opt_random_seed)
+, ccmin_mode(opt_ccmin_mode)
+, phase_saving(opt_phase_saving)
+, rnd_pol(false)
+, rnd_init_act(opt_rnd_init_act)
+, randomizeFirstDescent(false)
+, garbage_frac(opt_garbage_frac)
+, certifiedOutput(NULL)
+, certifiedUNSAT(false) // Not in the first parallel version
+, vbyte(false)
+, panicModeLastRemoved(0), panicModeLastRemovedShared(0)
+, useUnaryWatched(false)
+, promoteOneWatchedClause(true)
+,solves(0),starts(0),decisions(0),propagations(0),conflicts(0),conflictsRestarts(0)
+, curRestart(1)
+, glureduce(opt_glu_reduction)
+, restart_inc(opt_restart_inc)
+, luby_restart(opt_luby_restart)
+, adaptStrategies(opt_adapt)
+, luby_restart_factor(opt_luby_restart_factor)
+, randomize_on_restarts(opt_randomize_phase_on_restarts)
+, fixed_randomize_on_restarts(opt_fixed_randomize_phase_on_restarts)
+, newDescent(0)
+, randomDescentAssignments(0)
+, forceUnsatOnNewDescent(opt_forceunsat)
+
+, ok(true)
+, cla_inc(1)
+, var_inc(1)
+, watches(WatcherDeleted(ca))
+, watchesBin(WatcherDeleted(ca))
+, unaryWatches(WatcherDeleted(ca))
+, qhead(0)
+, simpDB_assigns(-1)
+, simpDB_props(0)
+, order_heap(VarOrderLt(activity))
+, progress_estimate(0)
+, remove_satisfied(true)
+,lastLearntClause(CRef_Undef)
+// Resource constraints:
+//
+, conflict_budget(-1)
+, propagation_budget(-1)
+, asynch_interrupt(false)
+, incremental(false)
+, nbVarsInitialFormula(INT32_MAX)
+, totalTime4Sat(0.)
+, totalTime4Unsat(0.)
+, nbSatCalls(0)
+, nbUnsatCalls(0)
+{
+    MYFLAG = 0;
+    // Initialize only first time. Useful for incremental solving (not in // version), useless otherwise
+    // Kept here for simplicity
+    lbdQueue.initSize(sizeLBDQueue);
+    trailQueue.initSize(sizeTrailQueue);
+    sumLBD = 0;
+    nbclausesbeforereduce = firstReduceDB;
+    stats.growTo(coreStatsSize, 0);
+}
+
+//-------------------------------------------------------
+// Special constructor used for cloning solvers
+//-------------------------------------------------------
+
+inline Solver::Solver(const Solver &s) :
+  verbosity(s.verbosity)
+, showModel(s.showModel)
+, K(s.K)
+, R(s.R)
+, sizeLBDQueue(s.sizeLBDQueue)
+, sizeTrailQueue(s.sizeTrailQueue)
+, firstReduceDB(s.firstReduceDB)
+, incReduceDB(s.incReduceDB)
+, specialIncReduceDB(s.specialIncReduceDB)
+, lbLBDFrozenClause(s.lbLBDFrozenClause)
+, chanseokStrategy(opt_chanseok_hack)
+, coLBDBound (opt_chanseok_limit)
+, lbSizeMinimizingClause(s.lbSizeMinimizingClause)
+, lbLBDMinimizingClause(s.lbLBDMinimizingClause)
+, var_decay(s.var_decay)
+, max_var_decay(s.max_var_decay)
+, clause_decay(s.clause_decay)
+, random_var_freq(s.random_var_freq)
+, random_seed(s.random_seed)
+, ccmin_mode(s.ccmin_mode)
+, phase_saving(s.phase_saving)
+, rnd_pol(s.rnd_pol)
+, rnd_init_act(s.rnd_init_act)
+, randomizeFirstDescent(s.randomizeFirstDescent)
+, garbage_frac(s.garbage_frac)
+, certifiedOutput(NULL)
+, certifiedUNSAT(false) // Not in the first parallel version
+, panicModeLastRemoved(s.panicModeLastRemoved), panicModeLastRemovedShared(s.panicModeLastRemovedShared)
+, useUnaryWatched(s.useUnaryWatched)
+, promoteOneWatchedClause(s.promoteOneWatchedClause)
+// Statistics: (formerly in 'SolverStats')
+//
+,solves(0),starts(0),decisions(0),propagations(0),conflicts(0),conflictsRestarts(0)
+
+, curRestart(s.curRestart)
+, glureduce(s.glureduce)
+, restart_inc(s.restart_inc)
+, luby_restart(s.luby_restart)
+, adaptStrategies(s.adaptStrategies)
+, luby_restart_factor(s.luby_restart_factor)
+, randomize_on_restarts(s.randomize_on_restarts)
+, fixed_randomize_on_restarts(s.fixed_randomize_on_restarts)
+, newDescent(s.newDescent)
+, randomDescentAssignments(s.randomDescentAssignments)
+, forceUnsatOnNewDescent(s.forceUnsatOnNewDescent)
+, ok(true)
+, cla_inc(s.cla_inc)
+, var_inc(s.var_inc)
+, watches(WatcherDeleted(ca))
+, watchesBin(WatcherDeleted(ca))
+, unaryWatches(WatcherDeleted(ca))
+, qhead(s.qhead)
+, simpDB_assigns(s.simpDB_assigns)
+, simpDB_props(s.simpDB_props)
+, order_heap(VarOrderLt(activity))
+, progress_estimate(s.progress_estimate)
+, remove_satisfied(s.remove_satisfied)
+,lastLearntClause(CRef_Undef)
+// Resource constraints:
+//
+, conflict_budget(s.conflict_budget)
+, propagation_budget(s.propagation_budget)
+, asynch_interrupt(s.asynch_interrupt)
+, incremental(s.incremental)
+, nbVarsInitialFormula(s.nbVarsInitialFormula)
+, totalTime4Sat(s.totalTime4Sat)
+, totalTime4Unsat(s.totalTime4Unsat)
+, nbSatCalls(s.nbSatCalls)
+, nbUnsatCalls(s.nbUnsatCalls)
+{
+    // Copy clauses.
+    s.ca.copyTo(ca);
+    ca.extra_clause_field = s.ca.extra_clause_field;
+
+    // Initialize  other variables
+    MYFLAG = 0;
+    // Initialize only first time. Useful for incremental solving (not in // version), useless otherwise
+    // Kept here for simplicity
+    sumLBD = s.sumLBD;
+    nbclausesbeforereduce = s.nbclausesbeforereduce;
+
+    // Copy all search vectors
+    s.watches.copyTo(watches);
+    s.watchesBin.copyTo(watchesBin);
+    s.unaryWatches.copyTo(unaryWatches);
+    s.assigns.memCopyTo(assigns);
+    s.vardata.memCopyTo(vardata);
+    s.activity.memCopyTo(activity);
+    s.seen.memCopyTo(seen);
+    s.permDiff.memCopyTo(permDiff);
+    s.polarity.memCopyTo(polarity);
+    s.decision.memCopyTo(decision);
+    s.trail.memCopyTo(trail);
+    s.order_heap.copyTo(order_heap);
+    s.clauses.memCopyTo(clauses);
+    s.learnts.memCopyTo(learnts);
+    s.permanentLearnts.memCopyTo(permanentLearnts);
+
+    s.lbdQueue.copyTo(lbdQueue);
+    s.trailQueue.copyTo(trailQueue);
+    s.forceUNSAT.copyTo(forceUNSAT);
+    s.stats.copyTo(stats);
+}
+
+
+inline Solver::~Solver() {
+}
+
+
+/****************************************************************
+ Certified UNSAT proof in binary format
+****************************************************************/
+
+inline void Solver::write_char(unsigned char ch) {
+#ifdef _WIN32
+    if(putc((int) ch, certifiedOutput) == EOF)
+        exit(1);
+#else
+    if(putc_unlocked((int) ch, certifiedOutput) == EOF)
+        exit(1);
+#endif
+}
+
+
+inline void Solver::write_lit(int n) {
+    for(; n > 127; n >>= 7)
+        write_char(128 | (n & 127));
+    write_char(n);
+}
+
+/****************************************************************
+ Set the incremental mode
+****************************************************************/
+
+// This function set the incremental mode to true.
+// You can add special code for this mode here.
+
+inline void Solver::setIncrementalMode() {
+#ifdef INCREMENTAL
+    incremental = true;
+#else
+    fprintf(stderr, "c Trying to set incremental mode, but not compiled properly for this.\n");
+    exit(1);
+#endif
+}
+
+
+// Number of variables without selectors
+inline void Solver::initNbInitialVars(int nb) {
+    nbVarsInitialFormula = nb;
+}
+
+
+inline bool Solver::isIncremental() {
+    return incremental;
+}
+
+
+//=================================================================================================
+// Minor methods:
+
+
+// Creates a new SAT variable in the solver. If 'decision' is cleared, variable will not be
+// used as a decision variable (NOTE! This has effects on the meaning of a SATISFIABLE result).
+//
+
+inline Var Solver::newVar(bool sign, bool dvar) {
+    int v = nVars();
+    watches.init(mkLit(v, false));
+    watches.init(mkLit(v, true));
+    watchesBin.init(mkLit(v, false));
+    watchesBin.init(mkLit(v, true));
+    unaryWatches.init(mkLit(v, false));
+    unaryWatches.init(mkLit(v, true));
+    assigns.push(l_Undef);
+    vardata.push(mkVarData(CRef_Undef, 0));
+    activity.push(rnd_init_act ? drand(random_seed) * 0.00001 : 0);
+    seen.push(0);
+    permDiff.push(0);
+    polarity.push(sign);
+    forceUNSAT.push(0);
+    decision.push();
+    trail.capacity(v + 1);
+    setDecisionVar(v, dvar);
+    return v;
+}
+
+
+inline bool Solver::addClause_(vec <Lit> &ps) {
+
+    assert(decisionLevel() == 0);
+    if(!ok) return false;
+
+    // Check if clause is satisfied and remove false/duplicate literals:
+    sort(ps);
+
+    vec <Lit> oc;
+    oc.clear();
+
+    Lit p;
+    int i, j, flag = 0;
+    if(certifiedUNSAT) {
+        for(i = j = 0, p = lit_Undef; i < ps.size(); i++) {
+            oc.push(ps[i]);
+            if(value(ps[i]) == l_True || ps[i] == ~p || value(ps[i]) == l_False)
+                flag = 1;
+        }
+    }
+
+    for(i = j = 0, p = lit_Undef; i < ps.size(); i++)
+        if(value(ps[i]) == l_True || ps[i] == ~p)
+            return true;
+        else if(value(ps[i]) != l_False && ps[i] != p)
+            ps[j++] = p = ps[i];
+    ps.shrink(i - j);
+
+    if(flag && (certifiedUNSAT)) {
+        if(vbyte) {
+            write_char('a');
+            for(i = j = 0, p = lit_Undef; i < ps.size(); i++)
+                write_lit(2 * (var(ps[i]) + 1) + sign(ps[i]));
+            write_lit(0);
+
+            write_char('d');
+            for(i = j = 0, p = lit_Undef; i < oc.size(); i++)
+                write_lit(2 * (var(oc[i]) + 1) + sign(oc[i]));
+            write_lit(0);
+        }
+        else {
+            for(i = j = 0, p = lit_Undef; i < ps.size(); i++)
+                fprintf(certifiedOutput, "%i ", (var(ps[i]) + 1) * (-2 * sign(ps[i]) + 1));
+            fprintf(certifiedOutput, "0\n");
+
+            fprintf(certifiedOutput, "d ");
+            for(i = j = 0, p = lit_Undef; i < oc.size(); i++)
+                fprintf(certifiedOutput, "%i ", (var(oc[i]) + 1) * (-2 * sign(oc[i]) + 1));
+            fprintf(certifiedOutput, "0\n");
+        }
+    }
+
+
+    if(ps.size() == 0)
+        return ok = false;
+    else if(ps.size() == 1) {
+        uncheckedEnqueue(ps[0]);
+        return ok = (propagate() == CRef_Undef);
+    } else {
+        CRef cr = ca.alloc(ps, false);
+        clauses.push(cr);
+        attachClause(cr);
+    }
+
+    return true;
+}
+
+
+inline void Solver::attachClause(CRef cr) {
+    const Clause &c = ca[cr];
+
+    assert(c.size() > 1);
+    if(c.size() == 2) {
+        watchesBin[~c[0]].push(Watcher(cr, c[1]));
+        watchesBin[~c[1]].push(Watcher(cr, c[0]));
+    } else {
+        watches[~c[0]].push(Watcher(cr, c[1]));
+        watches[~c[1]].push(Watcher(cr, c[0]));
+    }
+    if(c.learnt()) stats[learnts_literals] += c.size();
+    else stats[clauses_literals] += c.size();
+}
+
+
+inline void Solver::attachClausePurgatory(CRef cr) {
+    const Clause &c = ca[cr];
+
+    assert(c.size() > 1);
+    unaryWatches[~c[0]].push(Watcher(cr, c[1]));
+
+}
+
+
+inline void Solver::detachClause(CRef cr, bool strict) {
+    const Clause &c = ca[cr];
+
+    assert(c.size() > 1);
+    if(c.size() == 2) {
+        if(strict) {
+            remove(watchesBin[~c[0]], Watcher(cr, c[1]));
+            remove(watchesBin[~c[1]], Watcher(cr, c[0]));
+        } else {
+            // Lazy detaching: (NOTE! Must clean all watcher lists before garbage collecting this clause)
+            watchesBin.smudge(~c[0]);
+            watchesBin.smudge(~c[1]);
+        }
+    } else {
+        if(strict) {
+            remove(watches[~c[0]], Watcher(cr, c[1]));
+            remove(watches[~c[1]], Watcher(cr, c[0]));
+        } else {
+            // Lazy detaching: (NOTE! Must clean all watcher lists before garbage collecting this clause)
+            watches.smudge(~c[0]);
+            watches.smudge(~c[1]);
+        }
+    }
+    if(c.learnt()) stats[learnts_literals] -= c.size();
+    else stats[clauses_literals] -= c.size();
+}
+
+
+// The purgatory is the 1-Watched scheme for imported clauses
+
+inline void Solver::detachClausePurgatory(CRef cr, bool strict) {
+    const Clause &c = ca[cr];
+
+    assert(c.size() > 1);
+    if(strict)
+        remove(unaryWatches[~c[0]], Watcher(cr, c[1]));
+    else
+        unaryWatches.smudge(~c[0]);
+}
+
+
+inline void Solver::removeClause(CRef cr, bool inPurgatory) {
+
+    Clause &c = ca[cr];
+
+    if(certifiedUNSAT) {
+        if(vbyte) {
+            write_char('d');
+            for(int i = 0; i < c.size(); i++)
+                write_lit(2 * (var(c[i]) + 1) + sign(c[i]));
+            write_lit(0);
+        }
+        else {
+            fprintf(certifiedOutput, "d ");
+            for(int i = 0; i < c.size(); i++)
+                fprintf(certifiedOutput, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+            fprintf(certifiedOutput, "0\n");
+        }
+    }
+
+    if(inPurgatory)
+        detachClausePurgatory(cr);
+    else
+        detachClause(cr);
+    // Don't leave pointers to free'd memory!
+    if(locked(c)) vardata[var(c[0])].reason = CRef_Undef;
+    c.mark(1);
+    ca.free(cr);
+}
+
+
+inline bool Solver::satisfied(const Clause &c) const {
+#ifdef INCREMENTAL
+    if(incremental)
+        return (value(c[0]) == l_True) || (value(c[1]) == l_True);
+#endif
+
+    // Default mode
+    for(int i = 0; i < c.size(); i++)
+        if(value(c[i]) == l_True)
+            return true;
+    return false;
+}
+
+
+/************************************************************
+ * Compute LBD functions
+ *************************************************************/
+
+template <typename T>inline unsigned int Solver::computeLBD(const T &lits, int end) {
+    int nblevels = 0;
+    MYFLAG++;
+#ifdef INCREMENTAL
+    if(incremental) { // ----------------- INCREMENTAL MODE
+      if(end==-1) end = lits.size();
+      int nbDone = 0;
+      for(int i=0;i<lits.size();i++) {
+        if(nbDone>=end) break;
+        if(isSelector(var(lits[i]))) continue;
+        nbDone++;
+        int l = level(var(lits[i]));
+        if (permDiff[l] != MYFLAG) {
+      permDiff[l] = MYFLAG;
+      nblevels++;
+        }
+      }
+    } else { // -------- DEFAULT MODE. NOT A LOT OF DIFFERENCES... BUT EASIER TO READ
+#endif
+    for(int i = 0; i < lits.size(); i++) {
+        int l = level(var(lits[i]));
+        if(permDiff[l] != MYFLAG) {
+            permDiff[l] = MYFLAG;
+            nblevels++;
+        }
+    }
+#ifdef INCREMENTAL
+    }
+#endif
+    return nblevels;
+}
+
+
+
+/******************************************************************
+ * Minimisation with binary reolution
+ ******************************************************************/
+inline void Solver::minimisationWithBinaryResolution(vec <Lit> &out_learnt) {
+
+    // Find the LBD measure
+    unsigned int lbd = computeLBD(out_learnt);
+    Lit p = ~out_learnt[0];
+
+    if(lbd <= lbLBDMinimizingClause) {
+        MYFLAG++;
+
+        for(int i = 1; i < out_learnt.size(); i++) {
+            permDiff[var(out_learnt[i])] = MYFLAG;
+        }
+
+        vec <Watcher> &wbin = watchesBin[p];
+        int nb = 0;
+        for(int k = 0; k < wbin.size(); k++) {
+            Lit imp = wbin[k].blocker;
+            if(permDiff[var(imp)] == MYFLAG && value(imp) == l_True) {
+                nb++;
+                permDiff[var(imp)] = MYFLAG - 1;
+            }
+        }
+        int l = out_learnt.size() - 1;
+        if(nb > 0) {
+            stats[nbReducedClauses]++;
+            for(int i = 1; i < out_learnt.size() - nb; i++) {
+                if(permDiff[var(out_learnt[i])] != MYFLAG) {
+                    Lit p = out_learnt[l];
+                    out_learnt[l] = out_learnt[i];
+                    out_learnt[i] = p;
+                    l--;
+                    i--;
+                }
+            }
+
+            out_learnt.shrink(nb);
+
+        }
+    }
+}
+
+// Revert to the state at given level (keeping all assignment at 'level' but not beyond).
+//
+
+inline void Solver::cancelUntil(int level) {
+    if(decisionLevel() > level) {
+        for(int c = trail.size() - 1; c >= trail_lim[level]; c--) {
+            Var x = var(trail[c]);
+            assigns[x] = l_Undef;
+            if(phase_saving > 1 || ((phase_saving == 1) && c > trail_lim.last())) {
+                polarity[x] = sign(trail[c]);
+            }
+            insertVarOrder(x);
+        }
+        qhead = trail_lim[level];
+        trail.shrink(trail.size() - trail_lim[level]);
+        trail_lim.shrink(trail_lim.size() - level);
+    }
+}
+
+
+//=================================================================================================
+// Major methods:
+
+inline Lit Solver::pickBranchLit() {
+    Var next = var_Undef;
+
+    // Random decision:
+    if(((randomizeFirstDescent && conflicts == 0) || drand(random_seed) < random_var_freq) && !order_heap.empty()) {
+        next = order_heap[irand(random_seed, order_heap.size())];
+        if(value(next) == l_Undef && decision[next])
+            stats[rnd_decisions]++;
+    }
+
+    // Activity based decision:
+    while(next == var_Undef || value(next) != l_Undef || !decision[next])
+        if(order_heap.empty()) {
+            next = var_Undef;
+            break;
+        } else {
+            next = order_heap.removeMin();
+        }
+
+    if(randomize_on_restarts && !fixed_randomize_on_restarts && newDescent && (decisionLevel() % 2 == 0)) {
+        return mkLit(next, (randomDescentAssignments >> (decisionLevel() % 32)) & 1);
+    }
+
+    if(fixed_randomize_on_restarts && decisionLevel() < 7) {
+        return mkLit(next, (randomDescentAssignments >> (decisionLevel() % 32)) & 1);
+    }
+
+    if(next == var_Undef) return lit_Undef;
+
+    if(forceUnsatOnNewDescent && newDescent) {
+        if(forceUNSAT[next] != 0)
+            return mkLit(next, forceUNSAT[next] < 0);
+        return mkLit(next, polarity[next]);
+
+    }
+
+    return next == var_Undef ? lit_Undef : mkLit(next, rnd_pol ? drand(random_seed) < 0.5 : polarity[next]);
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  analyze : (confl : Clause*) (out_learnt : vec<Lit>&) (out_btlevel : int&)  ->  [void]
+|  
+|  Description:
+|    Analyze conflict and produce a reason clause.
+|  
+|    Pre-conditions:
+|      * 'out_learnt' is assumed to be cleared.
+|      * Current decision level must be greater than root level.
+|  
+|    Post-conditions:
+|      * 'out_learnt[0]' is the asserting literal at level 'out_btlevel'.
+|      * If out_learnt.size() > 1 then 'out_learnt[1]' has the greatest decision level of the 
+|        rest of literals. There may be others from the same level though.
+|  
+|________________________________________________________________________________________________@*/
+inline void Solver::analyze(CRef confl, vec <Lit> &out_learnt, vec <Lit> &selectors, int &out_btlevel, unsigned int &lbd, unsigned int &szWithoutSelectors) {
+    int pathC = 0;
+    Lit p = lit_Undef;
+
+
+    // Generate conflict clause:
+    //
+    out_learnt.push(); // (leave room for the asserting literal)
+    int index = trail.size() - 1;
+    do {
+        assert(confl != CRef_Undef); // (otherwise should be UIP)
+        Clause &c = ca[confl];
+        // Special case for binary clauses
+        // The first one has to be SAT
+        if(p != lit_Undef && c.size() == 2 && value(c[0]) == l_False) {
+
+            assert(value(c[1]) == l_True);
+            Lit tmp = c[0];
+            c[0] = c[1], c[1] = tmp;
+        }
+
+        if(c.learnt()) {
+            parallelImportClauseDuringConflictAnalysis(c, confl);
+            claBumpActivity(c);
+        } else { // original clause
+            if(!c.getSeen()) {
+                stats[originalClausesSeen]++;
+                c.setSeen(true);
+            }
+        }
+
+        // DYNAMIC NBLEVEL trick (see competition'09 companion paper)
+        if(c.learnt() && c.lbd() > 2) {
+            unsigned int nblevels = computeLBD(c);
+            if(nblevels + 1 < c.lbd()) { // improve the LBD
+                if(c.lbd() <= lbLBDFrozenClause) {
+                    // seems to be interesting : keep it for the next round
+                    c.setCanBeDel(false);
+                }
+                if(chanseokStrategy && nblevels <= coLBDBound) {
+                    c.nolearnt();
+                    learnts.remove(confl);
+                    permanentLearnts.push(confl);
+                    stats[nbPermanentLearnts]++;
+
+                } else {
+                    c.setLBD(nblevels); // Update it
+                }
+            }
+        }
+
+
+        for(int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++) {
+            Lit q = c[j];
+
+            if(!seen[var(q)]) {
+                if(level(var(q)) == 0) {
+                } else { // Here, the old case
+                    if(!isSelector(var(q)))
+                        varBumpActivity(var(q));
+
+                    // This variable was responsible for a conflict,
+                    // consider it as a UNSAT assignation for this literal
+                    bumpForceUNSAT(~q); // Negation because q is false here
+
+                    seen[var(q)] = 1;
+                    if(level(var(q)) >= decisionLevel()) {
+                        pathC++;
+                        // UPDATEVARACTIVITY trick (see competition'09 companion paper)
+                        if(!isSelector(var(q)) && (reason(var(q)) != CRef_Undef) && ca[reason(var(q))].learnt())
+                            lastDecisionLevel.push(q);
+                    } else {
+                        if(isSelector(var(q))) {
+                            assert(value(q) == l_False);
+                            selectors.push(q);
+                        } else
+                            out_learnt.push(q);
+                    }
+                }
+            } //else stats[sumResSeen]++;
+        }
+
+        // Select next clause to look at:
+        while (!seen[var(trail[index--])]);
+        p = trail[index + 1];
+        //stats[sumRes]++;
+        confl = reason(var(p));
+        seen[var(p)] = 0;
+        pathC--;
+
+    } while(pathC > 0);
+    out_learnt[0] = ~p;
+
+    // Simplify conflict clause:
+    //
+    int i, j;
+
+    for(int i = 0; i < selectors.size(); i++)
+        out_learnt.push(selectors[i]);
+
+    out_learnt.copyTo(analyze_toclear);
+    if(ccmin_mode == 2) {
+        uint32_t abstract_level = 0;
+        for(i = 1; i < out_learnt.size(); i++)
+            abstract_level |= abstractLevel(var(out_learnt[i])); // (maintain an abstraction of levels involved in conflict)
+
+        for(i = j = 1; i < out_learnt.size(); i++)
+            if(reason(var(out_learnt[i])) == CRef_Undef || !litRedundant(out_learnt[i], abstract_level))
+                out_learnt[j++] = out_learnt[i];
+
+    } else if(ccmin_mode == 1) {
+        for(i = j = 1; i < out_learnt.size(); i++) {
+            Var x = var(out_learnt[i]);
+
+            if(reason(x) == CRef_Undef)
+                out_learnt[j++] = out_learnt[i];
+            else {
+                Clause &c = ca[reason(var(out_learnt[i]))];
+                // Thanks to Siert Wieringa for this bug fix!
+                for(int k = ((c.size() == 2) ? 0 : 1); k < c.size(); k++)
+                    if(!seen[var(c[k])] && level(var(c[k])) > 0) {
+                        out_learnt[j++] = out_learnt[i];
+                        break;
+                    }
+            }
+        }
+    } else
+        i = j = out_learnt.size();
+
+    //    stats[max_literals]+=out_learnt.size();
+    out_learnt.shrink(i - j);
+    //    stats[tot_literals]+=out_learnt.size();
+
+
+    /* ***************************************
+      Minimisation with binary clauses of the asserting clause
+      First of all : we look for small clauses
+      Then, we reduce clauses with small LBD.
+      Otherwise, this can be useless
+     */
+    if(!incremental && out_learnt.size() <= lbSizeMinimizingClause) {
+        minimisationWithBinaryResolution(out_learnt);
+    }
+    // Find correct backtrack level:
+    //
+    if(out_learnt.size() == 1)
+        out_btlevel = 0;
+    else {
+        int max_i = 1;
+        // Find the first literal assigned at the next-highest level:
+        for(int i = 2; i < out_learnt.size(); i++)
+            if(level(var(out_learnt[i])) > level(var(out_learnt[max_i])))
+                max_i = i;
+        // Swap-in this literal at index 1:
+        Lit p = out_learnt[max_i];
+        out_learnt[max_i] = out_learnt[1];
+        out_learnt[1] = p;
+        out_btlevel = level(var(p));
+    }
+#ifdef INCREMENTAL
+    if(incremental) {
+       szWithoutSelectors = 0;
+       for(int i=0;i<out_learnt.size();i++) {
+     if(!isSelector(var((out_learnt[i])))) szWithoutSelectors++;
+     else if(i>0) break;
+       }
+     } else
+#endif
+    szWithoutSelectors = out_learnt.size();
+
+    // Compute LBD
+    lbd = computeLBD(out_learnt, out_learnt.size() - selectors.size());
+
+    // UPDATEVARACTIVITY trick (see competition'09 companion paper)
+    if(lastDecisionLevel.size() > 0) {
+        for(int i = 0; i < lastDecisionLevel.size(); i++) {
+            if(ca[reason(var(lastDecisionLevel[i]))].lbd() < lbd)
+                varBumpActivity(var(lastDecisionLevel[i]));
+        }
+        lastDecisionLevel.clear();
+    }
+
+
+    for(int j = 0; j < analyze_toclear.size(); j++) seen[var(analyze_toclear[j])] = 0; // ('seen[]' is now cleared)
+    for(int j = 0; j < selectors.size(); j++) seen[var(selectors[j])] = 0;
+}
+
+
+// Check if 'p' can be removed. 'abstract_levels' is used to abort early if the algorithm is
+// visiting literals at levels that cannot be removed later.
+
+inline bool Solver::litRedundant(Lit p, uint32_t abstract_levels) {
+    analyze_stack.clear();
+    analyze_stack.push(p);
+    int top = analyze_toclear.size();
+    while(analyze_stack.size() > 0) {
+        assert(reason(var(analyze_stack.last())) != CRef_Undef);
+        Clause &c = ca[reason(var(analyze_stack.last()))];
+        analyze_stack.pop(); //
+        if(c.size() == 2 && value(c[0]) == l_False) {
+            assert(value(c[1]) == l_True);
+            Lit tmp = c[0];
+            c[0] = c[1], c[1] = tmp;
+        }
+
+        for(int i = 1; i < c.size(); i++) {
+            Lit p = c[i];
+            if(!seen[var(p)]) {
+                if(level(var(p)) > 0) {
+                    if(reason(var(p)) != CRef_Undef && (abstractLevel(var(p)) & abstract_levels) != 0) {
+                        seen[var(p)] = 1;
+                        analyze_stack.push(p);
+                        analyze_toclear.push(p);
+                    } else {
+                        for(int j = top; j < analyze_toclear.size(); j++)
+                            seen[var(analyze_toclear[j])] = 0;
+                        analyze_toclear.shrink(analyze_toclear.size() - top);
+                        return false;
+                    }
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  analyzeFinal : (p : Lit)  ->  [void]
+|  
+|  Description:
+|    Specialized analysis procedure to express the final conflict in terms of assumptions.
+|    Calculates the (possibly empty) set of assumptions that led to the assignment of 'p', and
+|    stores the result in 'out_conflict'.
+|________________________________________________________________________________________________@*/
+inline void Solver::analyzeFinal(Lit p, vec <Lit> &out_conflict) {
+    out_conflict.clear();
+    out_conflict.push(p);
+
+    if(decisionLevel() == 0)
+        return;
+
+    seen[var(p)] = 1;
+
+    for(int i = trail.size() - 1; i >= trail_lim[0]; i--) {
+        Var x = var(trail[i]);
+        if(seen[x]) {
+            if(reason(x) == CRef_Undef) {
+                assert(level(x) > 0);
+                out_conflict.push(~trail[i]);
+            } else {
+                Clause &c = ca[reason(x)];
+                //                for (int j = 1; j < c.size(); j++) Minisat (glucose 2.0) loop
+                // Bug in case of assumptions due to special data structures for Binary.
+                // Many thanks to Sam Bayless (sbayless@cs.ubc.ca) for discover this bug.
+                for(int j = ((c.size() == 2) ? 0 : 1); j < c.size(); j++)
+                    if(level(var(c[j])) > 0)
+                        seen[var(c[j])] = 1;
+            }
+
+            seen[x] = 0;
+        }
+    }
+
+    seen[var(p)] = 0;
+}
+
+
+inline void Solver::uncheckedEnqueue(Lit p, CRef from) {
+    assert(value(p) == l_Undef);
+    assigns[var(p)] = lbool(!sign(p));
+    vardata[var(p)] = mkVarData(from, decisionLevel());
+    trail.push_(p);
+}
+
+
+inline void Solver::bumpForceUNSAT(Lit q) {
+    forceUNSAT[var(q)] = sign(q) ? -1 : +1;
+    return;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  propagate : [void]  ->  [Clause*]
+|  
+|  Description:
+|    Propagates all enqueued facts. If a conflict arises, the conflicting clause is returned,
+|    otherwise CRef_Undef.
+|  
+|    Post-conditions:
+|      * the propagation queue is empty, even if there was a conflict.
+|________________________________________________________________________________________________@*/
+inline CRef Solver::propagate() {
+    CRef confl = CRef_Undef;
+    int num_props = 0;
+    watches.cleanAll();
+    watchesBin.cleanAll();
+    unaryWatches.cleanAll();
+    while(qhead < trail.size()) {
+        Lit p = trail[qhead++]; // 'p' is enqueued fact to propagate.
+        vec <Watcher> &ws = watches[p];
+        Watcher *i, *j, *end;
+        num_props++;
+
+
+        // First, Propagate binary clauses
+        vec <Watcher> &wbin = watchesBin[p];
+        for(int k = 0; k < wbin.size(); k++) {
+
+            Lit imp = wbin[k].blocker;
+
+            if(value(imp) == l_False) {
+                return wbin[k].cref;
+            }
+
+            if(value(imp) == l_Undef) {
+                uncheckedEnqueue(imp, wbin[k].cref);
+            }
+        }
+
+        // Now propagate other 2-watched clauses
+        for(i = j = (Watcher *) ws, end = i + ws.size(); i != end;) {
+            // Try to avoid inspecting the clause:
+            Lit blocker = i->blocker;
+            if(value(blocker) == l_True) {
+                *j++ = *i++;
+                continue;
+            }
+
+            // Make sure the false literal is data[1]:
+            CRef cr = i->cref;
+            Clause &c = ca[cr];
+            assert(!c.getOneWatched());
+            Lit false_lit = ~p;
+            if(c[0] == false_lit)
+                c[0] = c[1], c[1] = false_lit;
+            assert(c[1] == false_lit);
+            i++;
+
+            // If 0th watch is true, then clause is already satisfied.
+            Lit first = c[0];
+            Watcher w = Watcher(cr, first);
+            if(first != blocker && value(first) == l_True) {
+
+                *j++ = w;
+                continue;
+            }
+#ifdef INCREMENTAL
+            if(incremental) { // ----------------- INCREMENTAL MODE
+              int choosenPos = -1;
+              for (int k = 2; k < c.size(); k++) {
+
+            if (value(c[k]) != l_False){
+              if(decisionLevel()>assumptions.size()) {
+                choosenPos = k;
+                break;
+              } else {
+                choosenPos = k;
+
+                if(value(c[k])==l_True || !isSelector(var(c[k]))) {
+                  break;
+                }
+              }
+
+            }
+              }
+              if(choosenPos!=-1) {
+            c[1] = c[choosenPos]; c[choosenPos] = false_lit;
+            watches[~c[1]].push(w);
+            goto NextClause; }
+            } else {  // ----------------- DEFAULT  MODE (NOT INCREMENTAL)
+#endif
+            for(int k = 2; k < c.size(); k++) {
+
+                if(value(c[k]) != l_False) {
+                    c[1] = c[k];
+                    c[k] = false_lit;
+                    watches[~c[1]].push(w);
+                    goto NextClause;
+                }
+            }
+#ifdef INCREMENTAL
+            }
+#endif
+            // Did not find watch -- clause is unit under assignment:
+            *j++ = w;
+            if(value(first) == l_False) {
+                confl = cr;
+                qhead = trail.size();
+                // Copy the remaining watches:
+                while(i < end)
+                    *j++ = *i++;
+            } else {
+                uncheckedEnqueue(first, cr);
+
+
+            }
+            NextClause:;
+        }
+        ws.shrink(i - j);
+
+        // unaryWatches "propagation"
+        if(useUnaryWatched && confl == CRef_Undef) {
+            confl = propagateUnaryWatches(p);
+
+        }
+
+    }
+
+
+    propagations += num_props;
+    simpDB_props -= num_props;
+
+    return confl;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  propagateUnaryWatches : [Lit]  ->  [Clause*]
+|  
+|  Description:
+|    Propagates unary watches of Lit p, return a conflict 
+|    otherwise CRef_Undef
+|  
+|________________________________________________________________________________________________@*/
+
+inline CRef Solver::propagateUnaryWatches(Lit p) {
+    CRef confl = CRef_Undef;
+    Watcher *i, *j, *end;
+    vec <Watcher> &ws = unaryWatches[p];
+    for(i = j = (Watcher *) ws, end = i + ws.size(); i != end;) {
+        // Try to avoid inspecting the clause:
+        Lit blocker = i->blocker;
+        if(value(blocker) == l_True) {
+            *j++ = *i++;
+            continue;
+        }
+
+        // Make sure the false literal is data[1]:
+        CRef cr = i->cref;
+        Clause &c = ca[cr];
+        assert(c.getOneWatched());
+        Lit false_lit = ~p;
+        assert(c[0] == false_lit); // this is unary watch... No other choice if "propagated"
+        //if (c[0] == false_lit)
+        //c[0] = c[1], c[1] = false_lit;
+        //assert(c[1] == false_lit);
+        i++;
+        Watcher w = Watcher(cr, c[0]);
+        for(int k = 1; k < c.size(); k++) {
+            if(value(c[k]) != l_False) {
+                c[0] = c[k];
+                c[k] = false_lit;
+                unaryWatches[~c[0]].push(w);
+                goto NextClauseUnary;
+            }
+        }
+
+        // Did not find watch -- clause is empty under assignment:
+        *j++ = w;
+
+        confl = cr;
+        qhead = trail.size();
+        // Copy the remaining watches:
+        while(i < end)
+            *j++ = *i++;
+
+        // We can add it now to the set of clauses when backtracking
+        //printf("*");
+        if(promoteOneWatchedClause) {
+            stats[nbPromoted]++;
+            // Let's find the two biggest decision levels in the clause s.t. it will correctly be propagated when we'll backtrack
+            int maxlevel = -1;
+            int index = -1;
+            for(int k = 1; k < c.size(); k++) {
+                assert(value(c[k]) == l_False);
+                assert(level(var(c[k])) <= level(var(c[0])));
+                if(level(var(c[k])) > maxlevel) {
+                    index = k;
+                    maxlevel = level(var(c[k]));
+                }
+            }
+            detachClausePurgatory(cr, true); // TODO: check that the cleanAll is ok (use ",true" otherwise)
+            assert(index != -1);
+            Lit tmp = c[1];
+            c[1] = c[index], c[index] = tmp;
+            attachClause(cr);
+            // TODO used in function ParallelSolver::reportProgressArrayImports
+            //Override :-(
+            //goodImportsFromThreads[ca[cr].importedFrom()]++;
+            ca[cr].setOneWatched(false);
+            ca[cr].setExported(2);
+        }
+        NextClauseUnary:;
+    }
+    ws.shrink(i - j);
+
+    return confl;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  reduceDB : ()  ->  [void]
+|  
+|  Description:
+|    Remove half of the learnt clauses, minus the clauses locked by the current assignment. Locked
+|    clauses are clauses that are reason to some assignment. Binary clauses are never removed.
+|________________________________________________________________________________________________@*/
+
+
+inline void Solver::reduceDB() {
+
+    int i, j;
+    stats[nbReduceDB]++;
+    if(chanseokStrategy)
+        sort(learnts, reduceDBAct_lt(ca));
+    else {
+        sort(learnts, reduceDB_lt(ca));
+
+        // We have a lot of "good" clauses, it is difficult to compare them. Keep more !
+        if(ca[learnts[learnts.size() / RATIOREMOVECLAUSES]].lbd() <= 3) nbclausesbeforereduce += specialIncReduceDB;
+        // Useless :-)
+        if(ca[learnts.last()].lbd() <= 5) nbclausesbeforereduce += specialIncReduceDB;
+
+    }
+    // Don't delete binary or locked clauses. From the rest, delete clauses from the first half
+    // Keep clauses which seem to be usefull (their lbd was reduce during this sequence)
+
+    int limit = learnts.size() / 2;
+
+    for(i = j = 0; i < learnts.size(); i++) {
+        Clause &c = ca[learnts[i]];
+        if(c.lbd() > 2 && c.size() > 2 && c.canBeDel() && !locked(c) && (i < limit)) {
+            removeClause(learnts[i]);
+            stats[nbRemovedClauses]++;
+        }
+        else {
+            if(!c.canBeDel()) limit++; //we keep c, so we can delete an other clause
+            c.setCanBeDel(true);       // At the next step, c can be delete
+            learnts[j++] = learnts[i];
+        }
+    }
+    learnts.shrink(i - j);
+    checkGarbage();
+}
+
+
+inline void Solver::removeSatisfied(vec <CRef> &cs) {
+
+    int i, j;
+    for(i = j = 0; i < cs.size(); i++) {
+        Clause &c = ca[cs[i]];
+
+
+        if(satisfied(c)) if(c.getOneWatched())
+            removeClause(cs[i], true);
+        else
+            removeClause(cs[i]);
+        else
+            cs[j++] = cs[i];
+    }
+    cs.shrink(i - j);
+}
+
+
+inline void Solver::rebuildOrderHeap() {
+    vec <Var> vs;
+    for(Var v = 0; v < nVars(); v++)
+        if(decision[v] && value(v) == l_Undef)
+            vs.push(v);
+    order_heap.build(vs);
+
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  simplify : [void]  ->  [bool]
+|  
+|  Description:
+|    Simplify the clause database according to the current top-level assigment. Currently, the only
+|    thing done here is the removal of satisfied clauses, but more things can be put here.
+|________________________________________________________________________________________________@*/
+inline bool Solver::simplify() {
+    assert(decisionLevel() == 0);
+
+    if(!ok) return ok = false;
+    else {
+        CRef cr = propagate();
+        if(cr != CRef_Undef) {
+            return ok = false;
+        }
+    }
+
+
+    if(nAssigns() == simpDB_assigns || (simpDB_props > 0))
+        return true;
+
+    // Remove satisfied clauses:
+    removeSatisfied(learnts);
+    removeSatisfied(permanentLearnts);
+    removeSatisfied(unaryWatchedClauses);
+    if(remove_satisfied) // Can be turned off.
+        removeSatisfied(clauses);
+    checkGarbage();
+    rebuildOrderHeap();
+
+    simpDB_assigns = nAssigns();
+    simpDB_props = stats[clauses_literals] + stats[learnts_literals]; // (shouldn't depend on stats really, but it will do for now)
+
+    return true;
+}
+
+
+inline void Solver::adaptSolver() {
+    bool adjusted = false;
+    bool reinit = false;
+    // printf("c\nc Try to adapt solver strategies\nc \n");
+    /*  printf("c Adjusting solver for the SAT Race 2015 (alpha feature)\n");
+    printf("c key successive Conflicts       : %" PRIu64"\n",stats[noDecisionConflict]);
+    printf("c nb unary clauses learnt        : %" PRIu64"\n",stats[nbUn]);
+    printf("c key avg dec per conflicts      : %.2f\n", (float)decisions / (float)conflicts);*/
+    float decpc = (float) decisions / (float) conflicts;
+    if(decpc <= 1.2) {
+        chanseokStrategy = true;
+        coLBDBound = 4;
+        glureduce = true;
+        adjusted = true;
+        // printf("c Adjusting for low decision levels.\n");
+        reinit = true;
+        firstReduceDB = 2000;
+        nbclausesbeforereduce = firstReduceDB;
+        curRestart = (conflicts / nbclausesbeforereduce) + 1;
+        incReduceDB = 0;
+    }
+    if(stats[noDecisionConflict] < 30000) {
+        luby_restart = true;
+        luby_restart_factor = 100;
+
+        var_decay = 0.999;
+        max_var_decay = 0.999;
+        adjusted = true;
+        // printf("c Adjusting for low successive conflicts.\n");
+    }
+    if(stats[noDecisionConflict] > 54400) {
+        // printf("c Adjusting for high successive conflicts.\n");
+        chanseokStrategy = true;
+        glureduce = true;
+        coLBDBound = 3;
+        firstReduceDB = 30000;
+        var_decay = 0.99;
+        max_var_decay = 0.99;
+        randomize_on_restarts = 1;
+        adjusted = true;
+    }
+    if(stats[nbDL2] - stats[nbBin] > 20000) {
+        var_decay = 0.91;
+        max_var_decay = 0.91;
+        adjusted = true;
+        // printf("c Adjusting for a very large number of true glue clauses found.\n");
+    }
+    if(!adjusted) {
+        // printf("c Nothing extreme in this problem, continue with glucose default strategies.\n");
+    }
+    printf("c\n");
+    if(adjusted) { // Let's reinitialize the glucose restart strategy counters
+        lbdQueue.fastclear();
+        sumLBD = 0;
+        conflictsRestarts = 0;
+    }
+
+    if(chanseokStrategy && adjusted) {
+        int moved = 0;
+        int i, j;
+        for(i = j = 0; i < learnts.size(); i++) {
+            Clause &c = ca[learnts[i]];
+            if(c.lbd() <= coLBDBound) {
+                permanentLearnts.push(learnts[i]);
+                moved++;
+            }
+            else {
+                learnts[j++] = learnts[i];
+            }
+        }
+        learnts.shrink(i - j);
+        // printf("c Activating Chanseok Strategy: moved %d clauses to the permanent set.\n", moved);
+    }
+
+    if(reinit) {
+        assert(decisionLevel() == 0);
+        for(int i = 0; i < learnts.size(); i++) {
+            removeClause(learnts[i]);
+        }
+        learnts.shrink(learnts.size());
+        checkGarbage();
+/*
+	order_heap.clear();
+	for(int i=0;i<nVars();i++) {
+	    polarity[i] = true; 
+	    activity[i]=0.0;
+	    if (decision[i]) order_heap.insert(i);
+	}
+	printf("c reinitialization of all variables activity/phase/learnt clauses.\n");
+*/
+        // printf("c Removing of non permanent clauses.\n");
+    }
+
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  search : (nof_conflicts : int) (params : const SearchParams&)  ->  [lbool]
+|  
+|  Description:
+|    Search for a model the specified number of conflicts. 
+|    NOTE! Use negative value for 'nof_conflicts' indicate infinity.
+|  
+|  Output:
+|    'l_True' if a partial assigment that is consistent with respect to the clauseset is found. If
+|    all variables are decision variables, this means that the clause set is satisfiable. 'l_False'
+|    if the clause set is unsatisfiable. 'l_Undef' if the bound on number of conflicts is reached.
+|________________________________________________________________________________________________@*/
+inline lbool Solver::search(int nof_conflicts) {
+    assert(ok);
+    int backtrack_level;
+    int conflictC = 0;
+    vec <Lit> learnt_clause, selectors;
+    unsigned int nblevels, szWithoutSelectors = 0;
+    bool blocked = false;
+    bool aDecisionWasMade = false;
+
+    starts++;
+    for(; ;) {
+        if(decisionLevel() == 0) { // We import clauses FIXME: ensure that we will import clauses enventually (restart after some point)
+            parallelImportUnaryClauses();
+
+            if(parallelImportClauses())
+                return l_False;
+
+        }
+        CRef confl = propagate();
+
+        if(confl != CRef_Undef) {
+            newDescent = false;
+            if(parallelJobIsFinished())
+                return l_Undef;
+
+            if(!aDecisionWasMade)
+                stats[noDecisionConflict]++;
+            aDecisionWasMade = false;
+
+            stats[sumDecisionLevels] += decisionLevel();
+            stats[sumTrail] += trail.size();
+            // CONFLICT
+            conflicts++;
+            conflictC++;
+            conflictsRestarts++;
+            if(conflicts % 5000 == 0 && var_decay < max_var_decay)
+                var_decay += 0.01;
+
+            if(verbosity >= 1 && starts>0 && conflicts % verbEveryConflicts == 0) {
+                printf("c | %8d   %7d    %5d | %7d %8d %8d | %5d %8d   %6d %8d | %6.3f %% |\n",
+                       (int) starts, (int) stats[nbstopsrestarts], (int) (conflicts / starts),
+                       (int) stats[dec_vars] - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]), nClauses(), (int) stats[clauses_literals],
+                       (int) stats[nbReduceDB], nLearnts(), (int) stats[nbDL2], (int) stats[nbRemovedClauses], progressEstimate() * 100);
+            }
+            if(decisionLevel() == 0) {
+                return l_False;
+
+            }
+            if(adaptStrategies && conflicts == 100000) {
+                cancelUntil(0);
+                adaptSolver();
+                adaptStrategies = false;
+                return l_Undef;
+            }
+
+            trailQueue.push(trail.size());
+            // BLOCK RESTART (CP 2012 paper)
+            if(conflictsRestarts > LOWER_BOUND_FOR_BLOCKING_RESTART && lbdQueue.isvalid() && trail.size() > R * trailQueue.getavg()) {
+                lbdQueue.fastclear();
+                stats[nbstopsrestarts]++;
+                if(!blocked) {
+                    stats[lastblockatrestart] = starts;
+                    stats[nbstopsrestartssame]++;
+                    blocked = true;
+                }
+            }
+
+            learnt_clause.clear();
+            selectors.clear();
+
+            analyze(confl, learnt_clause, selectors, backtrack_level, nblevels, szWithoutSelectors);
+
+            lbdQueue.push(nblevels);
+            sumLBD += nblevels;
+
+            cancelUntil(backtrack_level);
+
+            if(certifiedUNSAT) {
+                if(vbyte) {
+                    write_char('a');
+                    for(int i = 0; i < learnt_clause.size(); i++)
+                        write_lit(2 * (var(learnt_clause[i]) + 1) + sign(learnt_clause[i]));
+                    write_lit(0);
+                }
+                else {
+                    for(int i = 0; i < learnt_clause.size(); i++)
+                        fprintf(certifiedOutput, "%i ", (var(learnt_clause[i]) + 1) *
+                                                        (-2 * sign(learnt_clause[i]) + 1));
+                    fprintf(certifiedOutput, "0\n");
+                }
+            }
+
+
+            if(learnt_clause.size() == 1) {
+                uncheckedEnqueue(learnt_clause[0]);
+                stats[nbUn]++;
+                parallelExportUnaryClause(learnt_clause[0]);
+            } else {
+                CRef cr;
+                if(chanseokStrategy && nblevels <= coLBDBound) {
+                    cr = ca.alloc(learnt_clause, false);
+                    permanentLearnts.push(cr);
+                    stats[nbPermanentLearnts]++;
+                } else {
+                    cr = ca.alloc(learnt_clause, true);
+                    ca[cr].setLBD(nblevels);
+                    ca[cr].setOneWatched(false);
+                    learnts.push(cr);
+                    claBumpActivity(ca[cr]);
+                }
+#ifdef INCREMENTAL
+                ca[cr].setSizeWithoutSelectors(szWithoutSelectors);
+#endif
+                if(nblevels <= 2) { stats[nbDL2]++; } // stats
+                if(ca[cr].size() == 2) stats[nbBin]++; // stats
+                attachClause(cr);
+                lastLearntClause = cr; // Use in multithread (to hard to put inside ParallelSolver)
+                parallelExportClauseDuringSearch(ca[cr]);
+                uncheckedEnqueue(learnt_clause[0], cr);
+
+            }
+            varDecayActivity();
+            claDecayActivity();
+
+
+        } else {
+            // Our dynamic restart, see the SAT09 competition compagnion paper
+            if((luby_restart && nof_conflicts <= conflictC) ||
+               (!luby_restart && (lbdQueue.isvalid() && ((lbdQueue.getavg() * K) > (sumLBD / conflictsRestarts))))) {
+                lbdQueue.fastclear();
+                progress_estimate = progressEstimate();
+                int bt = 0;
+#ifdef INCREMENTAL
+                if(incremental) // DO NOT BACKTRACK UNTIL 0.. USELESS
+                    bt = (decisionLevel()<assumptions.size()) ? decisionLevel() : assumptions.size();
+#endif
+                newDescent = true;
+
+                if(randomize_on_restarts || fixed_randomize_on_restarts) {
+                    randomDescentAssignments = (uint32_t) drand(random_seed);
+                }
+
+                cancelUntil(bt);
+                return l_Undef;
+            }
+
+
+            // Simplify the set of problem clauses:
+            if(decisionLevel() == 0 && !simplify()) {
+                return l_False;
+            }
+            // Perform clause database reduction !
+            if((chanseokStrategy && !glureduce && learnts.size() > firstReduceDB) ||
+               (glureduce && conflicts >= ((unsigned int) curRestart * nbclausesbeforereduce))) {
+
+                if(learnts.size() > 0) {
+                    curRestart = (conflicts / nbclausesbeforereduce) + 1;
+                    reduceDB();
+                    if(!panicModeIsEnabled())
+                        nbclausesbeforereduce += incReduceDB;
+                }
+            }
+
+            lastLearntClause = CRef_Undef;
+            Lit next = lit_Undef;
+            while(decisionLevel() < assumptions.size()) {
+                // Perform user provided assumption:
+                Lit p = assumptions[decisionLevel()];
+                if(value(p) == l_True) {
+                    // Dummy decision level:
+                    newDecisionLevel();
+                } else if(value(p) == l_False) {
+                    analyzeFinal(~p, conflict);
+                    return l_False;
+                } else {
+                    next = p;
+                    break;
+                }
+            }
+
+            if(next == lit_Undef) {
+                // New variable decision:
+                decisions++;
+                next = pickBranchLit();
+                if(next == lit_Undef) {
+                    // printf("c last restart ## conflicts  :  %d %d \n", conflictC, decisionLevel());
+                    // Model found:
+                    return l_True;
+                }
+            }
+
+            // Increase decision level and enqueue 'next'
+            aDecisionWasMade = true;
+            newDecisionLevel();
+            uncheckedEnqueue(next);
+        }
+    }
+}
+
+
+inline double Solver::progressEstimate() const {
+    double progress = 0;
+    double F = 1.0 / nVars();
+
+    for(int i = 0; i <= decisionLevel(); i++) {
+        int beg = i == 0 ? 0 : trail_lim[i - 1];
+        int end = i == decisionLevel() ? trail.size() : trail_lim[i];
+        progress += pow(F, i) * (end - beg);
+    }
+
+    return progress / nVars();
+}
+
+
+inline void Solver::printIncrementalStats() {
+
+    printf("c---------- Glucose Stats -------------------------\n");
+    printf("c restarts              : %"
+    PRIu64
+    "\n", starts);
+    printf("c nb ReduceDB           : %"
+    PRIu64
+    "\n", stats[nbReduceDB]);
+    printf("c nb removed Clauses    : %"
+    PRIu64
+    "\n", stats[nbRemovedClauses]);
+    printf("c nb learnts DL2        : %"
+    PRIu64
+    "\n", stats[nbDL2]);
+    printf("c nb learnts size 2     : %"
+    PRIu64
+    "\n", stats[nbBin]);
+    printf("c nb learnts size 1     : %"
+    PRIu64
+    "\n", stats[nbUn]);
+
+    printf("c conflicts             : %"
+    PRIu64
+    "\n", conflicts);
+    printf("c decisions             : %"
+    PRIu64
+    "\n", decisions);
+    printf("c propagations          : %"
+    PRIu64
+    "\n", propagations);
+
+    printf("\nc SAT Calls             : %d in %g seconds\n", nbSatCalls, totalTime4Sat);
+    printf("c UNSAT Calls           : %d in %g seconds\n", nbUnsatCalls, totalTime4Unsat);
+
+    printf("c--------------------------------------------------\n");
+}
+
+
+inline double Solver::luby(double y, int x) {
+
+    // Find the finite subsequence that contains index 'x', and the
+    // size of that subsequence:
+    int size, seq;
+    for(size = 1, seq = 0; size < x + 1; seq++, size = 2 * size + 1);
+
+    while(size - 1 != x) {
+        size = (size - 1) >> 1;
+        seq--;
+        x = x % size;
+    }
+
+    return pow(y, seq);
+}
+
+
+// NOTE: assumptions passed in member-variable 'assumptions'.
+
+inline lbool Solver::solve_(bool do_simp, bool turn_off_simp) // Parameters are useless in core but useful for SimpSolver....
+{
+
+    if(incremental && certifiedUNSAT) {
+        printf("Can not use incremental and certified unsat in the same time\n");
+        exit(-1);
+    }
+
+    model.clear();
+    conflict.clear();
+    if(!ok) return l_False;
+    double curTime = cpuTime();
+
+    solves++;
+
+
+    lbool status = l_Undef;
+    if(!incremental && verbosity >= 1) {
+        printf("c ========================================[ MAGIC CONSTANTS ]==============================================\n");
+        printf("c | Constants are supposed to work well together :-)                                                      |\n");
+        printf("c | however, if you find better choices, please let us known...                                           |\n");
+        printf("c |-------------------------------------------------------------------------------------------------------|\n");
+        if(adaptStrategies) {
+            printf("c | Adapt dynamically the solver after 100000 conflicts (restarts, reduction strategies...)               |\n");
+            printf("c |-------------------------------------------------------------------------------------------------------|\n");
+        }
+        printf("c |                                |                                |                                     |\n");
+        printf("c | - Restarts:                    | - Reduce Clause DB:            | - Minimize Asserting:               |\n");
+        if(chanseokStrategy) {
+            printf("c |   * LBD Queue    : %6d      |     chanseok Strategy          |    * size < %3d                     |\n", lbdQueue.maxSize(),
+                   lbSizeMinimizingClause);
+            printf("c |   * Trail  Queue : %6d      |   * learnts size     : %6d  |    * lbd  < %3d                     |\n", trailQueue.maxSize(),
+                   firstReduceDB, lbLBDMinimizingClause);
+            printf("c |   * K            : %6.2f      |   * Bound LBD   : %6d       |                                     |\n", K, coLBDBound);
+            printf("c |   * R            : %6.2f      |   * Protected :  (lbd)< %2d     |                                     |\n", R, lbLBDFrozenClause);
+        } else {
+            printf("c |   * LBD Queue    : %6d      |   * First     : %6d         |    * size < %3d                     |\n", lbdQueue.maxSize(),
+                   nbclausesbeforereduce, lbSizeMinimizingClause);
+            printf("c |   * Trail  Queue : %6d      |   * Inc       : %6d         |    * lbd  < %3d                     |\n", trailQueue.maxSize(), incReduceDB,
+                   lbLBDMinimizingClause);
+            printf("c |   * K            : %6.2f      |   * Special   : %6d         |                                     |\n", K, specialIncReduceDB);
+            printf("c |   * R            : %6.2f      |   * Protected :  (lbd)< %2d     |                                     |\n", R, lbLBDFrozenClause);
+        }
+        printf("c |                                |                                |                                     |\n");
+        printf("c ==================================[ Search Statistics (every %6d conflicts) ]=========================\n", verbEveryConflicts);
+        printf("c |                                                                                                       |\n");
+
+        printf("c |          RESTARTS           |          ORIGINAL         |              LEARNT              | Progress |\n");
+        printf("c |       NB   Blocked  Avg Cfc |    Vars  Clauses Literals |   Red   Learnts    LBD2  Removed |          |\n");
+        printf("c =========================================================================================================\n");
+    }
+
+    // Search:
+    int curr_restarts = 0;
+    while(status == l_Undef) {
+        status = search(
+                luby_restart ? luby(restart_inc, curr_restarts) * luby_restart_factor : 0); // the parameter is useless in glucose, kept to allow modifications
+
+        if(!withinBudget()) break;
+        curr_restarts++;
+    }
+
+    if(!incremental && verbosity >= 1)
+        printf("c =========================================================================================================\n");
+
+    if(certifiedUNSAT) { // Want certified output
+        if(status == l_False) {
+            if(vbyte) {
+                write_char('a');
+                write_lit(0);
+            }
+            else {
+                fprintf(certifiedOutput, "0\n");
+            }
+        }
+        fclose(certifiedOutput);
+    }
+
+
+    if(status == l_True) {
+        // Extend & copy model:
+        model.growTo(nVars());
+        for(int i = 0; i < nVars(); i++) model[i] = value(i);
+    } else if(status == l_False && conflict.size() == 0)
+        ok = false;
+
+
+    cancelUntil(0);
+
+
+    double finalTime = cpuTime();
+    if(status == l_True) {
+        nbSatCalls++;
+        totalTime4Sat += (finalTime - curTime);
+    }
+    if(status == l_False) {
+        nbUnsatCalls++;
+        totalTime4Unsat += (finalTime - curTime);
+    }
+
+
+    return status;
+
+}
+
+
+
+
+
+//=================================================================================================
+// Writing CNF to DIMACS:
+// 
+// FIXME: this needs to be rewritten completely.
+
+static Var mapVar(Var x, vec <Var> &map, Var &max) {
+    if(map.size() <= x || map[x] == -1) {
+        map.growTo(x + 1, -1);
+        map[x] = max++;
+    }
+    return map[x];
+}
+
+
+inline void Solver::toDimacs(FILE *f, Clause &c, vec <Var> &map, Var &max) {
+    if(satisfied(c)) return;
+
+    for(int i = 0; i < c.size(); i++)
+        if(value(c[i]) != l_False)
+            fprintf(f, "%s%d ", sign(c[i]) ? "-" : "", mapVar(var(c[i]), map, max) + 1);
+    fprintf(f, "0\n");
+}
+
+
+inline void Solver::toDimacs(const char *file, const vec <Lit> &assumps) {
+    FILE *f = fopen(file, "wr");
+    if(f == NULL)
+        fprintf(stderr, "could not open file %s\n", file), exit(1);
+    toDimacs(f, assumps);
+    fclose(f);
+}
+
+
+inline void Solver::toDimacs(FILE *f, const vec <Lit> &assumps) {
+    // Handle case when solver is in contradictory state:
+    if(!ok) {
+        fprintf(f, "p cnf 1 2\n1 0\n-1 0\n");
+        return;
+    }
+
+    vec <Var> map;
+    Var max = 0;
+
+    // Cannot use removeClauses here because it is not safe
+    // to deallocate them at this point. Could be improved.
+    int cnt = 0;
+    for(int i = 0; i < clauses.size(); i++)
+        if(!satisfied(ca[clauses[i]]))
+            cnt++;
+
+    for(int i = 0; i < clauses.size(); i++)
+        if(!satisfied(ca[clauses[i]])) {
+            Clause &c = ca[clauses[i]];
+            for(int j = 0; j < c.size(); j++)
+                if(value(c[j]) != l_False)
+                    mapVar(var(c[j]), map, max);
+        }
+
+    // Assumptions are added as unit clauses:
+    cnt += assumps.size();
+
+    fprintf(f, "p cnf %d %d\n", max, cnt);
+
+    for(int i = 0; i < clauses.size(); i++)
+        toDimacs(f, ca[clauses[i]], map, max);
+
+    for(int i = 0; i < assumps.size(); i++) {
+        assert(value(assumps[i]) != l_False);
+        fprintf(f, "%s%d 0\n", sign(assumps[i]) ? "-" : "", mapVar(var(assumps[i]), map, max) + 1);
+    }
+
+    if(verbosity > 0)
+        printf("Wrote %d clauses with %d variables.\n", cnt, max);
+}
+
+
+//=================================================================================================
+// Garbage Collection methods:
+
+inline void Solver::relocAll(ClauseAllocator &to) {
+    // All watchers:
+    // for (int i = 0; i < watches.size(); i++)
+    watches.cleanAll();
+    watchesBin.cleanAll();
+    unaryWatches.cleanAll();
+    for(int v = 0; v < nVars(); v++)
+        for(int s = 0; s < 2; s++) {
+            Lit p = mkLit(v, s);
+            // printf(" >>> RELOCING: %s%d\n", sign(p)?"-":"", var(p)+1);
+            vec <Watcher> &ws = watches[p];
+            for(int j = 0; j < ws.size(); j++)
+                ca.reloc(ws[j].cref, to);
+            vec <Watcher> &ws2 = watchesBin[p];
+            for(int j = 0; j < ws2.size(); j++)
+                ca.reloc(ws2[j].cref, to);
+            vec <Watcher> &ws3 = unaryWatches[p];
+            for(int j = 0; j < ws3.size(); j++)
+                ca.reloc(ws3[j].cref, to);
+        }
+
+    // All reasons:
+    //
+    for(int i = 0; i < trail.size(); i++) {
+        Var v = var(trail[i]);
+
+        if(reason(v) != CRef_Undef && (ca[reason(v)].reloced() || locked(ca[reason(v)])))
+            ca.reloc(vardata[v].reason, to);
+    }
+
+    // All learnt:
+    //
+    for(int i = 0; i < learnts.size(); i++)
+        ca.reloc(learnts[i], to);
+
+    for(int i = 0; i < permanentLearnts.size(); i++)
+        ca.reloc(permanentLearnts[i], to);
+
+    // All original:
+    //
+    for(int i = 0; i < clauses.size(); i++)
+        ca.reloc(clauses[i], to);
+
+    for(int i = 0; i < unaryWatchedClauses.size(); i++)
+        ca.reloc(unaryWatchedClauses[i], to);
+}
+
+
+inline void Solver::garbageCollect() {
+    // Initialize the next region to a size corresponding to the estimated utilization degree. This
+    // is not precise but should avoid some unnecessary reallocations for the new region:
+    ClauseAllocator to(ca.size() - ca.wasted());
+    relocAll(to);
+    if(verbosity >= 2)
+        printf("|  Garbage collection:   %12d bytes => %12d bytes             |\n",
+               ca.size() * ClauseAllocator::Unit_Size, to.size() * ClauseAllocator::Unit_Size);
+    to.moveTo(ca);
+}
+
+//--------------------------------------------------------------
+// Functions related to MultiThread.
+// Useless in case of single core solver (aka original glucose)
+// Keep them empty if you just use core solver
+//--------------------------------------------------------------
+
+inline bool Solver::panicModeIsEnabled() {
+    return false;
+}
+
+
+inline void Solver::parallelImportUnaryClauses() {
+}
+
+
+inline bool Solver::parallelImportClauses() {
+    return false;
+}
+
+
+inline void Solver::parallelExportUnaryClause(Lit p) {
+}
+
+
+inline void Solver::parallelExportClauseDuringSearch(Clause &c) {
+}
+
+inline bool Solver::parallelJobIsFinished() {
+    // Parallel: another job has finished let's quit
+    return false;
+}
+
+
+inline void Solver::parallelImportClauseDuringConflictAnalysis(Clause &c, CRef confl) {
+}
+} // using namespace Glucose
+/***************************************************************************************[SimpSolver.h]
+ Glucose -- Copyright (c) 2009-2014, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                LRI  - Univ. Paris Sud, France (2009-2013)
+                                Labri - Univ. Bordeaux, France
+
+ Syrup (Glucose Parallel) -- Copyright (c) 2013-2014, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                Labri - Univ. Bordeaux, France
+
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose (sources until 2013, Glucose 3.0, single core) are exactly the same as Minisat on which it 
+is based on. (see below).
+
+Glucose-Syrup sources are based on another copyright. Permissions and copyrights for the parallel
+version of Glucose-Syrup (the "Software") are granted, free of charge, to deal with the Software
+without restriction, including the rights to use, copy, modify, merge, publish, distribute,
+sublicence, and/or sell copies of the Software, and to permit persons to whom the Software is 
+furnished to do so, subject to the following conditions:
+
+- The above and below copyrights notices and this permission notice shall be included in all
+copies or substantial portions of the Software;
+- The parallel version of Glucose (all files modified since Glucose 3.0 releases, 2013) cannot
+be used in any competitive event (sat competitions/evaluations) without the express permission of 
+the authors (Gilles Audemard / Laurent Simon). This is also the case for any competitive event
+using Glucose Parallel as an embedded SAT engine (single core or not).
+
+
+--------------- Original Minisat Copyrights
+
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ **************************************************************************************************/
+
+#ifndef Glucose_SimpSolver_h
+#define Glucose_SimpSolver_h
+
+
+
+
+
+namespace Glucose {
+
+//=================================================================================================
+
+
+class SimpSolver : public Solver {
+ public:
+    // Constructor/Destructor:
+    //
+    SimpSolver();
+    ~SimpSolver();
+    
+    SimpSolver(const  SimpSolver &s);
+    
+
+    /**
+     * Clone function
+    */
+    virtual Clone* clone() const {
+        return  new SimpSolver(*this);
+    }   
+
+    
+    // Problem specification:
+    //
+    virtual Var     newVar    (bool polarity = true, bool dvar = true); // Add a new variable with parameters specifying variable mode.
+    bool    addClause (const vec<Lit>& ps);
+    bool    addEmptyClause();                // Add the empty clause to the solver.
+    bool    addClause (Lit p);               // Add a unit clause to the solver.
+    bool    addClause (Lit p, Lit q);        // Add a binary clause to the solver.
+    bool    addClause (Lit p, Lit q, Lit r); // Add a ternary clause to the solver.
+    virtual bool    addClause_(      vec<Lit>& ps);
+    bool    substitute(Var v, Lit x);  // Replace all occurences of v with x (may cause a contradiction).
+
+    // Variable mode:
+    // 
+    void    setFrozen (Var v, bool b); // If a variable is frozen it will not be eliminated.
+    bool    isEliminated(Var v) const;
+
+    // Solving:
+    //
+    bool    solve       (const vec<Lit>& assumps, bool do_simp = true, bool turn_off_simp = false);
+    lbool   solveLimited(const vec<Lit>& assumps, bool do_simp = true, bool turn_off_simp = false);
+    bool    solve       (                     bool do_simp = true, bool turn_off_simp = false);
+    bool    solve       (Lit p       ,        bool do_simp = true, bool turn_off_simp = false);       
+    bool    solve       (Lit p, Lit q,        bool do_simp = true, bool turn_off_simp = false);
+    bool    solve       (Lit p, Lit q, Lit r, bool do_simp = true, bool turn_off_simp = false);
+    bool    eliminate   (bool turn_off_elim = false);  // Perform variable elimination based simplification. 
+
+    // Memory managment:
+    //
+    virtual void garbageCollect();
+
+
+    // Generate a (possibly simplified) DIMACS file:
+    //
+#if 0
+    void    toDimacs  (const char* file, const vec<Lit>& assumps);
+    void    toDimacs  (const char* file);
+    void    toDimacs  (const char* file, Lit p);
+    void    toDimacs  (const char* file, Lit p, Lit q);
+    void    toDimacs  (const char* file, Lit p, Lit q, Lit r);
+#endif
+
+    // Mode of operation:
+    //
+    int     parsing;
+    int     grow;              // Allow a variable elimination step to grow by a number of clauses (default to zero).
+    int     clause_lim;        // Variables are not eliminated if it produces a resolvent with a length above this limit.
+                               // -1 means no limit.
+    int     subsumption_lim;   // Do not check if subsumption against a clause larger than this. -1 means no limit.
+    double  simp_garbage_frac; // A different limit for when to issue a GC during simplification (Also see 'garbage_frac').
+
+    bool    use_asymm;         // Shrink clauses by asymmetric branching.
+    bool    use_rcheck;        // Check if a clause is already implied. Prett costly, and subsumes subsumptions :)
+    bool    use_elim;          // Perform variable elimination.
+    // Statistics:
+    //
+    int     merges;
+    int     asymm_lits;
+    int     eliminated_vars;
+    bool                use_simplification;
+
+ protected:
+
+    // Helper structures:
+    //
+    struct ElimLt {
+        const vec<int>& n_occ;
+        explicit ElimLt(const vec<int>& no) : n_occ(no) {}
+
+        // TODO: are 64-bit operations here noticably bad on 32-bit platforms? Could use a saturating
+        // 32-bit implementation instead then, but this will have to do for now.
+        uint64_t cost  (Var x)        const { return (uint64_t)n_occ[toInt(mkLit(x))] * (uint64_t)n_occ[toInt(~mkLit(x))]; }
+        bool operator()(Var x, Var y) const { return cost(x) < cost(y); }
+        
+        // TODO: investigate this order alternative more.
+        // bool operator()(Var x, Var y) const { 
+        //     int c_x = cost(x);
+        //     int c_y = cost(y);
+        //     return c_x < c_y || c_x == c_y && x < y; }
+    };
+
+    struct ClauseDeleted {
+        const ClauseAllocator& ca;
+        explicit ClauseDeleted(const ClauseAllocator& _ca) : ca(_ca) {}
+        bool operator()(const CRef& cr) const { return ca[cr].mark() == 1; } };
+
+    // Solver state:
+    //
+    int                 elimorder;
+    vec<uint32_t>       elimclauses;
+    vec<char>           touched;
+    OccLists<Var, vec<CRef>, ClauseDeleted>
+                        occurs;
+    vec<int>            n_occ;
+    Heap<ElimLt>        elim_heap;
+    Queue<CRef>         subsumption_queue;
+    vec<char>           frozen;
+    vec<char>           eliminated;
+    int                 bwdsub_assigns;
+    int                 n_touched;
+
+    // Temporaries:
+    //
+    CRef                bwdsub_tmpunit;
+
+    // Main internal methods:
+    //
+    virtual lbool         solve_                   (bool do_simp = true, bool turn_off_simp = false);
+    bool          asymm                    (Var v, CRef cr);
+    bool          asymmVar                 (Var v);
+    void          updateElimHeap           (Var v);
+    void          gatherTouchedClauses     ();
+    bool          merge                    (const Clause& _ps, const Clause& _qs, Var v, vec<Lit>& out_clause);
+    bool          merge                    (const Clause& _ps, const Clause& _qs, Var v, int& size);
+    bool          backwardSubsumptionCheck (bool verbose = false);
+    bool          eliminateVar             (Var v);
+    void          extendModel              ();
+
+    void          removeClause             (CRef cr,bool inPurgatory=false);
+    bool          strengthenClause         (CRef cr, Lit l);
+    void          cleanUpClauses           ();
+    bool          implied                  (const vec<Lit>& c);
+    virtual void          relocAll                 (ClauseAllocator& to);
+};
+
+
+//=================================================================================================
+// Implementation of inline methods:
+
+
+inline bool SimpSolver::isEliminated (Var v) const { return eliminated[v]; }
+inline void SimpSolver::updateElimHeap(Var v) {
+    assert(use_simplification);
+    // if (!frozen[v] && !isEliminated(v) && value(v) == l_Undef)
+    if (elim_heap.inHeap(v) || (!frozen[v] && !isEliminated(v) && value(v) == l_Undef))
+        elim_heap.update(v); }
+
+
+inline bool SimpSolver::addClause    (const vec<Lit>& ps)    { ps.copyTo(add_tmp); return addClause_(add_tmp); }
+inline bool SimpSolver::addEmptyClause()                     { add_tmp.clear(); return addClause_(add_tmp); }
+inline bool SimpSolver::addClause    (Lit p)                 { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); }
+inline bool SimpSolver::addClause    (Lit p, Lit q)          { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); }
+inline bool SimpSolver::addClause    (Lit p, Lit q, Lit r)   { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); }
+inline void SimpSolver::setFrozen    (Var v, bool b) { frozen[v] = (char)b; if (use_simplification && !b) { updateElimHeap(v); } }
+
+inline bool SimpSolver::solve        (                     bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (Lit p       ,        bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (Lit p, Lit q,        bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (Lit p, Lit q, Lit r, bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (const vec<Lit>& assumps, bool do_simp, bool turn_off_simp){ 
+    budgetOff(); assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp) == l_True; }
+
+inline lbool SimpSolver::solveLimited (const vec<Lit>& assumps, bool do_simp, bool turn_off_simp){ 
+    assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp); }
+
+//=================================================================================================
+}
+
+#endif
+/***************************************************************************************[SimpSolver.cc]
+ Glucose -- Copyright (c) 2009-2014, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                LRI  - Univ. Paris Sud, France (2009-2013)
+                                Labri - Univ. Bordeaux, France
+
+ Syrup (Glucose Parallel) -- Copyright (c) 2013-2014, Gilles Audemard, Laurent Simon
+                                CRIL - Univ. Artois, France
+                                Labri - Univ. Bordeaux, France
+
+Glucose sources are based on MiniSat (see below MiniSat copyrights). Permissions and copyrights of
+Glucose (sources until 2013, Glucose 3.0, single core) are exactly the same as Minisat on which it
+is based on. (see below).
+
+Glucose-Syrup sources are based on another copyright. Permissions and copyrights for the parallel
+version of Glucose-Syrup (the "Software") are granted, free of charge, to deal with the Software
+without restriction, including the rights to use, copy, modify, merge, publish, distribute,
+sublicence, and/or sell copies of the Software, and to permit persons to whom the Software is 
+furnished to do so, subject to the following conditions:
+
+- The above and below copyrights notices and this permission notice shall be included in all
+copies or substantial portions of the Software;
+- The parallel version of Glucose (all files modified since Glucose 3.0 releases, 2013) cannot
+be used in any competitive event (sat competitions/evaluations) without the express permission of 
+the authors (Gilles Audemard / Laurent Simon). This is also the case for any competitive event
+using Glucose Parallel as an embedded SAT engine (single core or not).
+
+
+--------------- Original Minisat Copyrights
+
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ **************************************************************************************************/
+
+
+
+
+
+namespace Glucose {
+
+//=================================================================================================
+// Options:
+
+
+static BoolOption   opt_use_asymm        ("SIMP", "asymm",        "Shrink clauses by asymmetric branching.", false);
+static BoolOption   opt_use_rcheck       ("SIMP", "rcheck",       "Check if a clause is already implied. (costly)", false);
+static BoolOption   opt_use_elim         ("SIMP", "elim",         "Perform variable elimination.", true);
+static IntOption    opt_grow             ("SIMP", "grow",         "Allow a variable elimination step to grow by a number of clauses.", 0);
+static IntOption    opt_clause_lim       ("SIMP", "cl-lim",       "Variables are not eliminated if it produces a resolvent with a length above this limit. -1 means no limit", 20,   IntRange(-1, INT32_MAX));
+static IntOption    opt_subsumption_lim  ("SIMP", "sub-lim",      "Do not check if subsumption against a clause larger than this. -1 means no limit.", 1000, IntRange(-1, INT32_MAX));
+static DoubleOption opt_simp_garbage_frac("SIMP", "simp-gc-frac", "The fraction of wasted memory allowed before a garbage collection is triggered during simplification.",  0.5, DoubleRange(0, false, HUGE_VAL, false));
+
+
+//=================================================================================================
+// Constructor/Destructor:
+
+
+inline SimpSolver::SimpSolver() :
+   Solver()
+  , grow               (opt_grow)
+  , clause_lim         (opt_clause_lim)
+  , subsumption_lim    (opt_subsumption_lim)
+  , simp_garbage_frac  (opt_simp_garbage_frac)
+  , use_asymm          (opt_use_asymm)
+  , use_rcheck         (opt_use_rcheck)
+  , use_elim           (opt_use_elim)
+  , merges             (0)
+  , asymm_lits         (0)
+  , eliminated_vars    (0)
+  , use_simplification (true)
+  , elimorder          (1)
+  , occurs             (ClauseDeleted(ca))
+  , elim_heap          (ElimLt(n_occ))
+  , bwdsub_assigns     (0)
+  , n_touched          (0)
+{
+    vec<Lit> dummy(1,lit_Undef);
+    ca.extra_clause_field = true; // NOTE: must happen before allocating the dummy clause below.
+    bwdsub_tmpunit        = ca.alloc(dummy);
+    remove_satisfied      = false;
+}
+
+
+inline SimpSolver::~SimpSolver()
+{
+}
+
+
+
+inline SimpSolver::SimpSolver(const SimpSolver &s) : Solver(s)
+  , grow               (s.grow)
+  , clause_lim         (s.clause_lim)
+  , subsumption_lim    (s.subsumption_lim)
+  , simp_garbage_frac  (s.simp_garbage_frac)
+  , use_asymm          (s.use_asymm)
+  , use_rcheck         (s.use_rcheck)
+  , use_elim           (s.use_elim)
+  , merges             (s.merges)
+  , asymm_lits         (s.asymm_lits)
+  , eliminated_vars    (s.eliminated_vars)
+  , use_simplification (s.use_simplification)
+  , elimorder          (s.elimorder)
+  , occurs             (ClauseDeleted(ca))
+  , elim_heap          (ElimLt(n_occ))
+  , bwdsub_assigns     (s.bwdsub_assigns)
+  , n_touched          (s.n_touched)
+{
+    // TODO: Copy dummy... what is it???
+    vec<Lit> dummy(1,lit_Undef);
+    ca.extra_clause_field = true; // NOTE: must happen before allocating the dummy clause below.
+    bwdsub_tmpunit        = ca.alloc(dummy);
+    remove_satisfied      = false;
+    //End TODO  
+    
+
+    s.elimclauses.memCopyTo(elimclauses);
+    s.touched.memCopyTo(touched);
+    s.occurs.copyTo(occurs);
+    s.n_occ.memCopyTo(n_occ);
+    s.elim_heap.copyTo(elim_heap);
+    s.subsumption_queue.copyTo(subsumption_queue);
+    s.frozen.memCopyTo(frozen);
+    s.eliminated.memCopyTo(eliminated);
+
+    use_simplification = s.use_simplification;
+    bwdsub_assigns = s.bwdsub_assigns;
+    n_touched = s.n_touched;
+    bwdsub_tmpunit = s.bwdsub_tmpunit;
+    qhead = s.qhead;
+    ok = s.ok;
+}
+
+
+
+inline Var SimpSolver::newVar(bool sign, bool dvar) {
+    Var v = Solver::newVar(sign, dvar);
+    frozen    .push((char)false);
+    eliminated.push((char)false);
+
+    if (use_simplification){
+        n_occ     .push(0);
+        n_occ     .push(0);
+        occurs    .init(v);
+        touched   .push(0);
+        elim_heap .insert(v);
+    }
+    return v; }
+
+inline lbool SimpSolver::solve_(bool do_simp, bool turn_off_simp)
+{
+    vec<Var> extra_frozen;
+    lbool    result = l_True;
+    do_simp &= use_simplification;
+
+    if (do_simp){
+        // Assumptions must be temporarily frozen to run variable elimination:
+        for (int i = 0; i < assumptions.size(); i++){
+            Var v = var(assumptions[i]);
+
+            // If an assumption has been eliminated, remember it.
+            assert(!isEliminated(v));
+
+            if (!frozen[v]){
+                // Freeze and store.
+                setFrozen(v, true);
+                extra_frozen.push(v);
+            } }
+
+        result = lbool(eliminate(turn_off_simp));
+    }
+
+    if (result == l_True)
+        result = Solver::solve_();
+    else if (verbosity >= 1)
+        printf("===============================================================================\n");
+
+    if (result == l_True)
+        extendModel();
+
+    if (do_simp)
+        // Unfreeze the assumptions that were frozen:
+        for (int i = 0; i < extra_frozen.size(); i++)
+            setFrozen(extra_frozen[i], false);
+
+
+    return result;
+}
+
+
+
+inline bool SimpSolver::addClause_(vec<Lit>& ps)
+{
+#ifndef NDEBUG
+    for (int i = 0; i < ps.size(); i++)
+        assert(!isEliminated(var(ps[i])));
+#endif
+    int nclauses = clauses.size();
+
+    if (use_rcheck && implied(ps))
+        return true;
+
+    if (!Solver::addClause_(ps))
+        return false;
+
+    if(!parsing && certifiedUNSAT) {
+        if (vbyte) {
+            write_char('a');
+            for (int i = 0; i < ps.size(); i++)
+                write_lit(2*(var(ps[i])+1) + sign(ps[i]));
+            write_lit(0);
+        }
+        else {
+            for (int i = 0; i < ps.size(); i++)
+                fprintf(certifiedOutput, "%i " , (var(ps[i]) + 1) * (-2 * sign(ps[i]) + 1) );
+            fprintf(certifiedOutput, "0\n");
+        }
+    }
+
+    if (use_simplification && clauses.size() == nclauses + 1){
+        CRef          cr = clauses.last();
+        const Clause& c  = ca[cr];
+
+        // NOTE: the clause is added to the queue immediately and then
+        // again during 'gatherTouchedClauses()'. If nothing happens
+        // in between, it will only be checked once. Otherwise, it may
+        // be checked twice unnecessarily. This is an unfortunate
+        // consequence of how backward subsumption is used to mimic
+        // forward subsumption.
+        subsumption_queue.insert(cr);
+        for (int i = 0; i < c.size(); i++){
+            occurs[var(c[i])].push(cr);
+            n_occ[toInt(c[i])]++;
+            touched[var(c[i])] = 1;
+            n_touched++;
+            if (elim_heap.inHeap(var(c[i])))
+                elim_heap.increase(var(c[i]));
+        }
+    }
+
+    return true;
+}
+
+
+
+inline void SimpSolver::removeClause(CRef cr,bool inPurgatory)
+{
+    const Clause& c = ca[cr];
+
+    if (use_simplification)
+        for (int i = 0; i < c.size(); i++){
+            n_occ[toInt(c[i])]--;
+            updateElimHeap(var(c[i]));
+            occurs.smudge(var(c[i]));
+        }
+
+    Solver::removeClause(cr,inPurgatory);
+}
+
+
+inline bool SimpSolver::strengthenClause(CRef cr, Lit l)
+{
+    Clause& c = ca[cr];
+    assert(decisionLevel() == 0);
+    assert(use_simplification);
+
+    // FIX: this is too inefficient but would be nice to have (properly implemented)
+    // if (!find(subsumption_queue, &c))
+    subsumption_queue.insert(cr);
+
+    if (certifiedUNSAT) {
+        if (vbyte) {
+            write_char('a');
+            for (int i = 0; i < c.size(); i++)
+                if (c[i] != l) write_lit(2*(var(c[i])+1) + sign(c[i]));
+            write_lit(0);
+        }
+        else {
+            for (int i = 0; i < c.size(); i++)
+                if (c[i] != l) fprintf(certifiedOutput, "%i " , (var(c[i]) + 1) * (-2 * sign(c[i]) + 1) );
+            fprintf(certifiedOutput, "0\n");
+        }
+    }
+
+    if (c.size() == 2){
+        removeClause(cr);
+        c.strengthen(l);
+    }else{
+        if (certifiedUNSAT) {
+            if (vbyte) {
+                write_char('d');
+                for (int i = 0; i < c.size(); i++)
+                    write_lit(2*(var(c[i])+1) + sign(c[i]));
+                write_lit(0);
+            }
+            else {
+                fprintf(certifiedOutput, "d ");
+                for (int i = 0; i < c.size(); i++)
+                    fprintf(certifiedOutput, "%i " , (var(c[i]) + 1) * (-2 * sign(c[i]) + 1) );
+                fprintf(certifiedOutput, "0\n");
+            }
+        }
+
+        detachClause(cr, true);
+        c.strengthen(l);
+        attachClause(cr);
+        remove(occurs[var(l)], cr);
+        n_occ[toInt(l)]--;
+        updateElimHeap(var(l));
+    }
+
+    return c.size() == 1 ? enqueue(c[0]) && propagate() == CRef_Undef : true;
+}
+
+
+// Returns FALSE if clause is always satisfied ('out_clause' should not be used).
+inline bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, vec<Lit>& out_clause)
+{
+    merges++;
+    out_clause.clear();
+
+    bool  ps_smallest = _ps.size() < _qs.size();
+    const Clause& ps  =  ps_smallest ? _qs : _ps;
+    const Clause& qs  =  ps_smallest ? _ps : _qs;
+
+    for (int i = 0; i < qs.size(); i++){
+        if (var(qs[i]) != v){
+            for (int j = 0; j < ps.size(); j++)
+                if (var(ps[j]) == var(qs[i]))
+                    if (ps[j] == ~qs[i])
+                        return false;
+                    else
+                        goto next;
+            out_clause.push(qs[i]);
+        }
+        next:;
+    }
+
+    for (int i = 0; i < ps.size(); i++)
+        if (var(ps[i]) != v)
+            out_clause.push(ps[i]);
+
+    return true;
+}
+
+
+// Returns FALSE if clause is always satisfied.
+inline bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, int& size)
+{
+    merges++;
+
+    bool  ps_smallest = _ps.size() < _qs.size();
+    const Clause& ps  =  ps_smallest ? _qs : _ps;
+    const Clause& qs  =  ps_smallest ? _ps : _qs;
+    const Lit*  __ps  = (const Lit*)ps;
+    const Lit*  __qs  = (const Lit*)qs;
+
+    size = ps.size()-1;
+
+    for (int i = 0; i < qs.size(); i++){
+        if (var(__qs[i]) != v){
+            for (int j = 0; j < ps.size(); j++)
+                if (var(__ps[j]) == var(__qs[i]))
+                    if (__ps[j] == ~__qs[i])
+                        return false;
+                    else
+                        goto next;
+            size++;
+        }
+        next:;
+    }
+
+    return true;
+}
+
+
+inline void SimpSolver::gatherTouchedClauses()
+{
+    if (n_touched == 0) return;
+
+    int i,j;
+    for (i = j = 0; i < subsumption_queue.size(); i++)
+        if (ca[subsumption_queue[i]].mark() == 0)
+            ca[subsumption_queue[i]].mark(2);
+
+    for (i = 0; i < touched.size(); i++)
+        if (touched[i]){
+            const vec<CRef>& cs = occurs.lookup(i);
+            for (j = 0; j < cs.size(); j++)
+                if (ca[cs[j]].mark() == 0){
+                    subsumption_queue.insert(cs[j]);
+                    ca[cs[j]].mark(2);
+                }
+            touched[i] = 0;
+        }
+
+    for (i = 0; i < subsumption_queue.size(); i++)
+        if (ca[subsumption_queue[i]].mark() == 2)
+            ca[subsumption_queue[i]].mark(0);
+
+    n_touched = 0;
+}
+
+
+inline bool SimpSolver::implied(const vec<Lit>& c)
+{
+    assert(decisionLevel() == 0);
+
+    trail_lim.push(trail.size());
+    for (int i = 0; i < c.size(); i++)
+        if (value(c[i]) == l_True){
+            cancelUntil(0);
+            return false;
+        }else if (value(c[i]) != l_False){
+            assert(value(c[i]) == l_Undef);
+            uncheckedEnqueue(~c[i]);
+        }
+
+    bool result = propagate() != CRef_Undef;
+    cancelUntil(0);
+    return result;
+}
+
+
+// Backward subsumption + backward subsumption resolution
+inline bool SimpSolver::backwardSubsumptionCheck(bool verbose)
+{
+    int cnt = 0;
+    int subsumed = 0;
+    int deleted_literals = 0;
+    assert(decisionLevel() == 0);
+
+    while (subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()){
+
+        // Empty subsumption queue and return immediately on user-interrupt:
+        if (asynch_interrupt){
+            subsumption_queue.clear();
+            bwdsub_assigns = trail.size();
+            break; }
+
+        // Check top-level assignments by creating a dummy clause and placing it in the queue:
+        if (subsumption_queue.size() == 0 && bwdsub_assigns < trail.size()){
+            Lit l = trail[bwdsub_assigns++];
+            ca[bwdsub_tmpunit][0] = l;
+            ca[bwdsub_tmpunit].calcAbstraction();
+            subsumption_queue.insert(bwdsub_tmpunit); }
+
+        CRef    cr = subsumption_queue.peek(); subsumption_queue.pop();
+        Clause& c  = ca[cr];
+
+        if (c.mark()) continue;
+
+        if (verbose && verbosity >= 2 && cnt++ % 1000 == 0)
+            printf("subsumption left: %10d (%10d subsumed, %10d deleted literals)\r", subsumption_queue.size(), subsumed, deleted_literals);
+
+        assert(c.size() > 1 || value(c[0]) == l_True);    // Unit-clauses should have been propagated before this point.
+
+        // Find best variable to scan:
+        Var best = var(c[0]);
+        for (int i = 1; i < c.size(); i++)
+            if (occurs[var(c[i])].size() < occurs[best].size())
+                best = var(c[i]);
+
+        // Search all candidates:
+        vec<CRef>& _cs = occurs.lookup(best);
+        CRef*       cs = (CRef*)_cs;
+
+        for (int j = 0; j < _cs.size(); j++)
+            if (c.mark())
+                break;
+            else if (!ca[cs[j]].mark() &&  cs[j] != cr && (subsumption_lim == -1 || ca[cs[j]].size() < subsumption_lim)){
+                Lit l = c.subsumes(ca[cs[j]]);
+
+                if (l == lit_Undef)
+                    subsumed++, removeClause(cs[j]);
+                else if (l != lit_Error){
+                    deleted_literals++;
+
+                    if (!strengthenClause(cs[j], ~l))
+                        return false;
+
+                    // Did current candidate get deleted from cs? Then check candidate at index j again:
+                    if (var(l) == best)
+                        j--;
+                }
+            }
+    }
+
+    return true;
+}
+
+
+inline bool SimpSolver::asymm(Var v, CRef cr)
+{
+    Clause& c = ca[cr];
+    assert(decisionLevel() == 0);
+
+    if (c.mark() || satisfied(c)) return true;
+
+    trail_lim.push(trail.size());
+    Lit l = lit_Undef;
+    for (int i = 0; i < c.size(); i++)
+        if (var(c[i]) != v && value(c[i]) != l_False)
+            uncheckedEnqueue(~c[i]);
+        else
+            l = c[i];
+
+    if (propagate() != CRef_Undef){
+        cancelUntil(0);
+        asymm_lits++;
+        if (!strengthenClause(cr, l))
+            return false;
+    }else
+        cancelUntil(0);
+
+    return true;
+}
+
+
+inline bool SimpSolver::asymmVar(Var v)
+{
+    assert(use_simplification);
+
+    const vec<CRef>& cls = occurs.lookup(v);
+
+    if (value(v) != l_Undef || cls.size() == 0)
+        return true;
+
+    for (int i = 0; i < cls.size(); i++)
+        if (!asymm(v, cls[i]))
+            return false;
+
+    return backwardSubsumptionCheck();
+}
+
+
+static void mkElimClause(vec<uint32_t>& elimclauses, Lit x)
+{
+    elimclauses.push(toInt(x));
+    elimclauses.push(1);
+}
+
+
+static void mkElimClause(vec<uint32_t>& elimclauses, Var v, Clause& c)
+{
+    int first = elimclauses.size();
+    int v_pos = -1;
+
+    // Copy clause to elimclauses-vector. Remember position where the
+    // variable 'v' occurs:
+    for (int i = 0; i < c.size(); i++){
+        elimclauses.push(toInt(c[i]));
+        if (var(c[i]) == v)
+            v_pos = i + first;
+    }
+    assert(v_pos != -1);
+
+    // Swap the first literal with the 'v' literal, so that the literal
+    // containing 'v' will occur first in the clause:
+    uint32_t tmp = elimclauses[v_pos];
+    elimclauses[v_pos] = elimclauses[first];
+    elimclauses[first] = tmp;
+
+    // Store the length of the clause last:
+    elimclauses.push(c.size());
+}
+
+
+
+inline bool SimpSolver::eliminateVar(Var v)
+{
+    assert(!frozen[v]);
+    assert(!isEliminated(v));
+    assert(value(v) == l_Undef);
+
+    // Split the occurrences into positive and negative:
+    //
+    const vec<CRef>& cls = occurs.lookup(v);
+    vec<CRef>        pos, neg;
+    for (int i = 0; i < cls.size(); i++)
+        (find(ca[cls[i]], mkLit(v)) ? pos : neg).push(cls[i]);
+
+    // Check wether the increase in number of clauses stays within the allowed ('grow'). Moreover, no
+    // clause must exceed the limit on the maximal clause size (if it is set):
+    //
+    int cnt         = 0;
+    int clause_size = 0;
+
+    for (int i = 0; i < pos.size(); i++)
+        for (int j = 0; j < neg.size(); j++)
+            if (merge(ca[pos[i]], ca[neg[j]], v, clause_size) && 
+                (++cnt > cls.size() + grow || (clause_lim != -1 && clause_size > clause_lim)))
+                return true;
+
+    // Delete and store old clauses
+    eliminated[v] = true;
+    setDecisionVar(v, false);
+    eliminated_vars++;
+
+    if (pos.size() > neg.size()){
+        for (int i = 0; i < neg.size(); i++)
+            mkElimClause(elimclauses, v, ca[neg[i]]);
+        mkElimClause(elimclauses, mkLit(v));
+    }else{
+        for (int i = 0; i < pos.size(); i++)
+            mkElimClause(elimclauses, v, ca[pos[i]]);
+        mkElimClause(elimclauses, ~mkLit(v));
+    }
+
+
+    // Produce clauses in cross product:
+    vec<Lit>& resolvent = add_tmp;
+    for (int i = 0; i < pos.size(); i++)
+        for (int j = 0; j < neg.size(); j++)
+            if (merge(ca[pos[i]], ca[neg[j]], v, resolvent) && !addClause_(resolvent))
+                return false;
+
+    for (int i = 0; i < cls.size(); i++)
+        removeClause(cls[i]);
+
+    // Free occurs list for this variable:
+    occurs[v].clear(true);
+
+    // Free watchers lists for this variable, if possible:
+    if (watches[ mkLit(v)].size() == 0) watches[ mkLit(v)].clear(true);
+    if (watches[~mkLit(v)].size() == 0) watches[~mkLit(v)].clear(true);
+
+    return backwardSubsumptionCheck();
+}
+
+
+inline bool SimpSolver::substitute(Var v, Lit x)
+{
+    assert(!frozen[v]);
+    assert(!isEliminated(v));
+    assert(value(v) == l_Undef);
+
+    if (!ok) return false;
+
+    eliminated[v] = true;
+    setDecisionVar(v, false);
+    const vec<CRef>& cls = occurs.lookup(v);
+    
+    vec<Lit>& subst_clause = add_tmp;
+    for (int i = 0; i < cls.size(); i++){
+        Clause& c = ca[cls[i]];
+
+        subst_clause.clear();
+        for (int j = 0; j < c.size(); j++){
+            Lit p = c[j];
+            subst_clause.push(var(p) == v ? x ^ sign(p) : p);
+        }
+
+ 
+        if (!addClause_(subst_clause))
+            return ok = false;
+
+       removeClause(cls[i]);
+ 
+   }
+
+    return true;
+}
+
+
+inline void SimpSolver::extendModel()
+{
+    int i, j;
+    Lit x;
+
+    if(model.size()==0) model.growTo(nVars());
+
+    for (i = elimclauses.size()-1; i > 0; i -= j){
+        for (j = elimclauses[i--]; j > 1; j--, i--)
+            if (modelValue(toLit(elimclauses[i])) != l_False)
+                goto next;
+
+        x = toLit(elimclauses[i]);
+        model[var(x)] = lbool(!sign(x));
+    next:;
+    }
+}
+
+
+inline bool SimpSolver::eliminate(bool turn_off_elim)
+{
+    if (!simplify()) {
+        ok = false;
+        return false;
+    }
+    else if (!use_simplification)
+        return true;
+
+    // Main simplification loop:
+    //
+
+    int toPerform = clauses.size()<=4800000;
+    
+    if(!toPerform) {
+      printf("c Too many clauses... No preprocessing\n");
+    }
+
+    while (toPerform && (n_touched > 0 || bwdsub_assigns < trail.size() || elim_heap.size() > 0)){
+
+        gatherTouchedClauses();
+        // printf("  ## (time = %6.2f s) BWD-SUB: queue = %d, trail = %d\n", cpuTime(), subsumption_queue.size(), trail.size() - bwdsub_assigns);
+        if ((subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()) && 
+            !backwardSubsumptionCheck(true)){
+            ok = false; goto cleanup; }
+
+        // Empty elim_heap and return immediately on user-interrupt:
+        if (asynch_interrupt){
+            assert(bwdsub_assigns == trail.size());
+            assert(subsumption_queue.size() == 0);
+            assert(n_touched == 0);
+            elim_heap.clear();
+            goto cleanup; }
+
+        // printf("  ## (time = %6.2f s) ELIM: vars = %d\n", cpuTime(), elim_heap.size());
+        for (int cnt = 0; !elim_heap.empty(); cnt++){
+            Var elim = elim_heap.removeMin();
+            
+            if (asynch_interrupt) break;
+
+            if (isEliminated(elim) || value(elim) != l_Undef) continue;
+
+            if (verbosity >= 2 && cnt % 100 == 0)
+                printf("elimination left: %10d\r", elim_heap.size());
+
+            if (use_asymm){
+                // Temporarily freeze variable. Otherwise, it would immediately end up on the queue again:
+                bool was_frozen = frozen[elim];
+                frozen[elim] = true;
+                if (!asymmVar(elim)){
+                    ok = false; goto cleanup; }
+                frozen[elim] = was_frozen; }
+
+            // At this point, the variable may have been set by assymetric branching, so check it
+            // again. Also, don't eliminate frozen variables:
+            if (use_elim && value(elim) == l_Undef && !frozen[elim] && !eliminateVar(elim)){
+                ok = false; goto cleanup; }
+
+            checkGarbage(simp_garbage_frac);
+        }
+
+        assert(subsumption_queue.size() == 0);
+    }
+ cleanup:
+
+    // If no more simplification is needed, free all simplification-related data structures:
+    if (turn_off_elim){
+        touched  .clear(true);
+        occurs   .clear(true);
+        n_occ    .clear(true);
+        elim_heap.clear(true);
+        subsumption_queue.clear(true);
+
+        use_simplification    = false;
+        remove_satisfied      = true;
+        ca.extra_clause_field = false;
+
+        // Force full cleanup (this is safe and desirable since it only happens once):
+        rebuildOrderHeap();
+        garbageCollect();
+    }else{
+        // Cheaper cleanup:
+        cleanUpClauses(); // TODO: can we make 'cleanUpClauses()' not be linear in the problem size somehow?
+        checkGarbage();
+    }
+
+    if (verbosity >= 0 && elimclauses.size() > 0)
+        printf("c |  Eliminated clauses:     %10.2f Mb                                                                |\n", 
+               double(elimclauses.size() * sizeof(uint32_t)) / (1024*1024));
+
+               
+    return ok;
+
+    
+}
+
+
+inline void SimpSolver::cleanUpClauses()
+{
+    occurs.cleanAll();
+    int i,j;
+    for (i = j = 0; i < clauses.size(); i++)
+        if (ca[clauses[i]].mark() == 0)
+            clauses[j++] = clauses[i];
+    clauses.shrink(i - j);
+}
+
+
+//=================================================================================================
+// Garbage Collection methods:
+
+
+inline void SimpSolver::relocAll(ClauseAllocator& to)
+{
+    if (!use_simplification) return;
+
+    // All occurs lists:
+    //
+    for (int i = 0; i < nVars(); i++){
+        vec<CRef>& cs = occurs[i];
+        for (int j = 0; j < cs.size(); j++)
+            ca.reloc(cs[j], to);
+    }
+
+    // Subsumption queue:
+    //
+    for (int i = 0; i < subsumption_queue.size(); i++)
+        ca.reloc(subsumption_queue[i], to);
+
+    // Temporary clause:
+    //
+    ca.reloc(bwdsub_tmpunit, to);
+}
+
+
+inline void SimpSolver::garbageCollect()
+{
+    // Initialize the next region to a size corresponding to the estimated utilization degree. This
+    // is not precise but should avoid some unnecessary reallocations for the new region:
+    ClauseAllocator to(ca.size() - ca.wasted()); 
+
+    cleanUpClauses();
+    to.extra_clause_field = ca.extra_clause_field; // NOTE: this is important to keep (or lose) the extra fields.
+    relocAll(to);
+    Solver::relocAll(to);
+    if (verbosity >= 2)
+        printf("|  Garbage collection:   %12d bytes => %12d bytes             |\n", 
+               ca.size()*ClauseAllocator::Unit_Size, to.size()*ClauseAllocator::Unit_Size);
+    to.moveTo(ca);
+}
+} // using namespace Glucose
+
+#undef BITS_LBD
+#ifdef INCREMENTAL
+  #undef BITS_SIZEWITHOUTSEL
+  #undef INCREMENTAL
+#endif
+#undef BITS_REALSIZE
+#undef DYNAMICNBLEVEL
+#undef CONSTANTREMOVECLAUSE
+#undef RATIOREMOVECLAUSES
+#undef LOWER_BOUND_FOR_BLOCKING_RESTART
+#undef coreStatsSize
diff --git a/lib/bill/bill/sat/solver/maple.hpp b/lib/bill/bill/sat/solver/maple.hpp
new file mode 100644
index 0000000..0572f2a
--- /dev/null
+++ b/lib/bill/bill/sat/solver/maple.hpp
@@ -0,0 +1,5839 @@
+/**************************************************************************************[IntTypes.h]
+Copyright (c) 2009-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#pragma once
+
+#ifndef Minisat_IntTypes_h
+#define Minisat_IntTypes_h
+
+#ifdef __sun
+    // Not sure if there are newer versions that support C99 headers. The
+    // needed features are implemented in the headers below though:
+
+#   include <sys/int_types.h>
+#   include <sys/int_fmtio.h>
+#   include <sys/int_limits.h>
+
+#else
+
+#   include <stdint.h>
+#   include <inttypes.h>
+
+#endif
+
+#include <limits.h>
+
+//=================================================================================================
+
+#endif
+/****************************************************************************************[XAlloc.h]
+Copyright (c) 2009-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Minisat_XAlloc_h
+#define Minisat_XAlloc_h
+
+#include <errno.h>
+#include <stdlib.h>
+
+namespace Maple {
+
+//=================================================================================================
+// Simple layer on top of malloc/realloc to catch out-of-memory situtaions and provide some typing:
+
+class OutOfMemoryException{};
+static inline void* xrealloc(void *ptr, size_t size)
+{
+    void* mem = realloc(ptr, size);
+    if (mem == NULL && errno == ENOMEM){
+        throw OutOfMemoryException();
+    }else
+        return mem;
+}
+
+//=================================================================================================
+}
+
+#endif
+/*******************************************************************************************[Vec.h]
+Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_Vec_h
+#define Minisat_Vec_h
+
+#include <assert.h>
+#include <new>
+
+
+
+
+namespace Maple {
+
+//=================================================================================================
+// Automatically resizable arrays
+//
+// NOTE! Don't use this vector on datatypes that cannot be re-located in memory (with realloc)
+
+template<class T>
+class vec {
+    T*  data;
+    int sz;
+    int cap;
+
+    // Don't allow copying (error prone):
+    vec<T>&  operator = (vec<T>& other) { assert(0); return *this; }
+             vec        (vec<T>& other) { assert(0); }
+             
+    // Helpers for calculating next capacity:
+    static inline int  imax   (int x, int y) { int mask = (y-x) >> (sizeof(int)*8-1); return (x&mask) + (y&(~mask)); }
+    //static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; }
+    static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; }
+
+public:
+    // Constructors:
+    vec()                       : data(NULL) , sz(0)   , cap(0)    { }
+    explicit vec(int size)      : data(NULL) , sz(0)   , cap(0)    { growTo(size); }
+    vec(int size, const T& pad) : data(NULL) , sz(0)   , cap(0)    { growTo(size, pad); }
+   ~vec()                                                          { clear(true); }
+
+    // Pointer to first element:
+    operator T*       (void)           { return data; }
+
+    // Size operations:
+    int      size     (void) const     { return sz; }
+    void     shrink   (int nelems)     { assert(nelems <= sz); for (int i = 0; i < nelems; i++) sz--, data[sz].~T(); }
+    void     shrink_  (int nelems)     { assert(nelems <= sz); sz -= nelems; }
+    int      capacity (void) const     { return cap; }
+    void     capacity (int min_cap);
+    void     growTo   (int size);
+    void     growTo   (int size, const T& pad);
+    void     clear    (bool dealloc = false);
+
+    // Stack interface:
+    void     push  (void)              { if (sz == cap) capacity(sz+1); new (&data[sz]) T(); sz++; }
+    void     push  (const T& elem)     { if (sz == cap) capacity(sz+1); data[sz++] = elem; }
+    void     push_ (const T& elem)     { assert(sz < cap); data[sz++] = elem; }
+    void     pop   (void)              { assert(sz > 0); sz--, data[sz].~T(); }
+    // NOTE: it seems possible that overflow can happen in the 'sz+1' expression of 'push()', but
+    // in fact it can not since it requires that 'cap' is equal to INT_MAX. This in turn can not
+    // happen given the way capacities are calculated (below). Essentially, all capacities are
+    // even, but INT_MAX is odd.
+
+    const T& last  (void) const        { return data[sz-1]; }
+    T&       last  (void)              { return data[sz-1]; }
+
+    // Vector interface:
+    const T& operator [] (int index) const { return data[index]; }
+    T&       operator [] (int index)       { return data[index]; }
+
+    // Duplicatation (preferred instead):
+    void copyTo(vec<T>& copy) const { copy.clear(); copy.growTo(sz); for (int i = 0; i < sz; i++) copy[i] = data[i]; }
+    void moveTo(vec<T>& dest) { dest.clear(true); dest.data = data; dest.sz = sz; dest.cap = cap; data = NULL; sz = 0; cap = 0; }
+};
+
+
+template<class T>
+void vec<T>::capacity(int min_cap) {
+    if (cap >= min_cap) return;
+    int add = imax((min_cap - cap + 1) & ~1, ((cap >> 1) + 2) & ~1);   // NOTE: grow by approximately 3/2
+    if (add > INT_MAX - cap || (((data = (T*)::realloc(data, (cap += add) * sizeof(T))) == NULL) && errno == ENOMEM))
+        throw OutOfMemoryException();
+ }
+
+
+template<class T>
+void vec<T>::growTo(int size, const T& pad) {
+    if (sz >= size) return;
+    capacity(size);
+    for (int i = sz; i < size; i++) data[i] = pad;
+    sz = size; }
+
+
+template<class T>
+void vec<T>::growTo(int size) {
+    if (sz >= size) return;
+    capacity(size);
+    for (int i = sz; i < size; i++) new (&data[i]) T();
+    sz = size; }
+
+
+template<class T>
+void vec<T>::clear(bool dealloc) {
+    if (data != NULL){
+        for (int i = 0; i < sz; i++) data[i].~T();
+        sz = 0;
+        if (dealloc) free(data), data = NULL, cap = 0; } }
+
+//=================================================================================================
+}
+
+#endif
+/*******************************************************************************************[Alg.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_Alg_h
+#define Minisat_Alg_h
+
+
+
+namespace Maple {
+
+//=================================================================================================
+// Useful functions on vector-like types:
+
+//=================================================================================================
+// Removing and searching for elements:
+//
+
+template<class V, class T>
+static inline void remove(V& ts, const T& t)
+{
+    int j = 0;
+    for (; j < ts.size() && ts[j] != t; j++);
+    assert(j < ts.size());
+    for (; j < ts.size()-1; j++) ts[j] = ts[j+1];
+    ts.pop();
+}
+
+
+template<class V, class T>
+static inline bool find(V& ts, const T& t)
+{
+    int j = 0;
+    for (; j < ts.size() && ts[j] != t; j++);
+    return j < ts.size();
+}
+
+
+//=================================================================================================
+// Copying vectors with support for nested vector types:
+//
+
+// Base case:
+template<class T>
+static inline void copy(const T& from, T& to)
+{
+    to = from;
+}
+
+// Recursive case:
+template<class T>
+static inline void copy(const vec<T>& from, vec<T>& to, bool append = false)
+{
+    if (!append)
+        to.clear();
+    for (int i = 0; i < from.size(); i++){
+        to.push();
+        copy(from[i], to.last());
+    }
+}
+
+template<class T>
+static inline void append(const vec<T>& from, vec<T>& to){ copy(from, to, true); }
+
+//=================================================================================================
+}
+
+#endif
+/*****************************************************************************************[Alloc.h]
+Copyright (c) 2008-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Minisat_Alloc_h
+#define Minisat_Alloc_h
+
+
+
+
+namespace Maple {
+
+//=================================================================================================
+// Simple Region-based memory allocator:
+
+template<class T>
+class RegionAllocator
+{
+    T*        memory;
+    uint32_t  sz;
+    uint32_t  cap;
+    uint32_t  wasted_;
+
+    void capacity(uint32_t min_cap);
+
+ public:
+    // TODO: make this a class for better type-checking?
+    typedef uint32_t Ref;
+    enum { Ref_Undef = UINT32_MAX };
+    enum { Unit_Size = sizeof(uint32_t) };
+
+    explicit RegionAllocator(uint32_t start_cap = 1024*1024) : memory(NULL), sz(0), cap(0), wasted_(0){ capacity(start_cap); }
+    ~RegionAllocator()
+    {
+        if (memory != NULL)
+            ::free(memory);
+    }
+
+
+    uint32_t size      () const      { return sz; }
+    uint32_t wasted    () const      { return wasted_; }
+
+    Ref      alloc     (int size); 
+    void     free      (int size)    { wasted_ += size; }
+
+    // Deref, Load Effective Address (LEA), Inverse of LEA (AEL):
+    T&       operator[](Ref r)       { assert(r >= 0 && r < sz); return memory[r]; }
+    const T& operator[](Ref r) const { assert(r >= 0 && r < sz); return memory[r]; }
+
+    T*       lea       (Ref r)       { assert(r >= 0 && r < sz); return &memory[r]; }
+    const T* lea       (Ref r) const { assert(r >= 0 && r < sz); return &memory[r]; }
+    Ref      ael       (const T* t)  { assert((void*)t >= (void*)&memory[0] && (void*)t < (void*)&memory[sz-1]);
+        return  (Ref)(t - &memory[0]); }
+
+    void     moveTo(RegionAllocator& to) {
+        if (to.memory != NULL) ::free(to.memory);
+        to.memory = memory;
+        to.sz = sz;
+        to.cap = cap;
+        to.wasted_ = wasted_;
+
+        memory = NULL;
+        sz = cap = wasted_ = 0;
+    }
+
+
+};
+
+template<class T>
+void RegionAllocator<T>::capacity(uint32_t min_cap)
+{
+    if (cap >= min_cap) return;
+
+    uint32_t prev_cap = cap;
+    while (cap < min_cap){
+        // NOTE: Multiply by a factor (13/8) without causing overflow, then add 2 and make the
+        // result even by clearing the least significant bit. The resulting sequence of capacities
+        // is carefully chosen to hit a maximum capacity that is close to the '2^32-1' limit when
+        // using 'uint32_t' as indices so that as much as possible of this space can be used.
+        uint32_t delta = ((cap >> 1) + (cap >> 3) + 2) & ~1;
+        cap += delta;
+
+        if (cap <= prev_cap)
+            throw OutOfMemoryException();
+    }
+    // printf(" .. (%p) cap = %u\n", this, cap);
+
+    assert(cap > 0);
+    memory = (T*)xrealloc(memory, sizeof(T)*cap);
+}
+
+
+template<class T>
+typename RegionAllocator<T>::Ref
+RegionAllocator<T>::alloc(int size)
+{ 
+    // printf("ALLOC called (this = %p, size = %d)\n", this, size); fflush(stdout);
+    assert(size > 0);
+    capacity(sz + size);
+
+    uint32_t prev_sz = sz;
+    sz += size;
+    
+    // Handle overflow:
+    if (sz < prev_sz)
+        throw OutOfMemoryException();
+
+    return prev_sz;
+}
+
+
+//=================================================================================================
+}
+
+#endif
+/******************************************************************************************[Heap.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_Heap_h
+#define Minisat_Heap_h
+
+
+
+namespace Maple {
+
+//=================================================================================================
+// A heap implementation with support for decrease/increase key.
+
+
+template<class Comp>
+class Heap {
+    Comp     lt;       // The heap is a minimum-heap with respect to this comparator
+    vec<int> heap;     // Heap of integers
+    vec<int> indices;  // Each integers position (index) in the Heap
+
+    // Index "traversal" functions
+    static inline int left  (int i) { return i*2+1; }
+    static inline int right (int i) { return (i+1)*2; }
+    static inline int parent(int i) { return (i-1) >> 1; }
+
+
+    void percolateUp(int i)
+    {
+        int x  = heap[i];
+        int p  = parent(i);
+        
+        while (i != 0 && lt(x, heap[p])){
+            heap[i]          = heap[p];
+            indices[heap[p]] = i;
+            i                = p;
+            p                = parent(p);
+        }
+        heap   [i] = x;
+        indices[x] = i;
+    }
+
+
+    void percolateDown(int i)
+    {
+        int x = heap[i];
+        while (left(i) < heap.size()){
+            int child = right(i) < heap.size() && lt(heap[right(i)], heap[left(i)]) ? right(i) : left(i);
+            if (!lt(heap[child], x)) break;
+            heap[i]          = heap[child];
+            indices[heap[i]] = i;
+            i                = child;
+        }
+        heap   [i] = x;
+        indices[x] = i;
+    }
+
+
+  public:
+    Heap(const Comp& c) : lt(c) { }
+
+    int  size      ()          const { return heap.size(); }
+    bool empty     ()          const { return heap.size() == 0; }
+    bool inHeap    (int n)     const { return n < indices.size() && indices[n] >= 0; }
+    int  operator[](int index) const { assert(index < heap.size()); return heap[index]; }
+
+
+    void decrease  (int n) { assert(inHeap(n)); percolateUp  (indices[n]); }
+    void increase  (int n) { assert(inHeap(n)); percolateDown(indices[n]); }
+
+
+    // Safe variant of insert/decrease/increase:
+    void update(int n)
+    {
+        if (!inHeap(n))
+            insert(n);
+        else {
+            percolateUp(indices[n]);
+            percolateDown(indices[n]); }
+    }
+
+
+    void insert(int n)
+    {
+        indices.growTo(n+1, -1);
+        assert(!inHeap(n));
+
+        indices[n] = heap.size();
+        heap.push(n);
+        percolateUp(indices[n]); 
+    }
+
+
+    int  removeMin()
+    {
+        int x            = heap[0];
+        heap[0]          = heap.last();
+        indices[heap[0]] = 0;
+        indices[x]       = -1;
+        heap.pop();
+        if (heap.size() > 1) percolateDown(0);
+        return x; 
+    }
+
+
+    // Rebuild the heap from scratch, using the elements in 'ns':
+    void build(const vec<int>& ns) {
+        for (int i = 0; i < heap.size(); i++)
+            indices[heap[i]] = -1;
+        heap.clear();
+
+        for (int i = 0; i < ns.size(); i++){
+            indices[ns[i]] = i;
+            heap.push(ns[i]); }
+
+        for (int i = heap.size() / 2 - 1; i >= 0; i--)
+            percolateDown(i);
+    }
+
+    void clear(bool dealloc = false) 
+    { 
+        for (int i = 0; i < heap.size(); i++)
+            indices[heap[i]] = -1;
+        heap.clear(dealloc); 
+    }
+};
+
+
+//=================================================================================================
+}
+
+#endif
+/*******************************************************************************************[Map.h]
+Copyright (c) 2006-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_Map_h
+#define Minisat_Map_h
+
+
+
+
+namespace Maple {
+
+//=================================================================================================
+// Default hash/equals functions
+//
+
+template<class K> struct Hash  { uint32_t operator()(const K& k)               const { return hash(k);  } };
+template<class K> struct Equal { bool     operator()(const K& k1, const K& k2) const { return k1 == k2; } };
+
+template<class K> struct DeepHash  { uint32_t operator()(const K* k)               const { return hash(*k);  } };
+template<class K> struct DeepEqual { bool     operator()(const K* k1, const K* k2) const { return *k1 == *k2; } };
+
+static inline uint32_t hash(uint32_t x){ return x; }
+static inline uint32_t hash(uint64_t x){ return (uint32_t)x; }
+static inline uint32_t hash(int32_t x) { return (uint32_t)x; }
+static inline uint32_t hash(int64_t x) { return (uint32_t)x; }
+
+
+//=================================================================================================
+// Some primes
+//
+
+static const int nprimes          = 25;
+static const int primes [nprimes] = { 31, 73, 151, 313, 643, 1291, 2593, 5233, 10501, 21013, 42073, 84181, 168451, 337219, 674701, 1349473, 2699299, 5398891, 10798093, 21596719, 43193641, 86387383, 172775299, 345550609, 691101253 };
+
+//=================================================================================================
+// Hash table implementation of Maps
+//
+
+template<class K, class D, class H = Hash<K>, class E = Equal<K> >
+class Map {
+ public:
+    struct Pair { K key; D data; };
+
+ private:
+    H          hash;
+    E          equals;
+
+    vec<Pair>* table;
+    int        cap;
+    int        size;
+
+    // Don't allow copying (error prone):
+    Map<K,D,H,E>&  operator = (Map<K,D,H,E>& other) { assert(0); }
+                   Map        (Map<K,D,H,E>& other) { assert(0); }
+
+    bool    checkCap(int new_size) const { return new_size > cap; }
+
+    int32_t index  (const K& k) const { return hash(k) % cap; }
+    void   _insert (const K& k, const D& d) { 
+        vec<Pair>& ps = table[index(k)];
+        ps.push(); ps.last().key = k; ps.last().data = d; }
+
+    void    rehash () {
+        const vec<Pair>* old = table;
+
+        int old_cap = cap;
+        int newsize = primes[0];
+        for (int i = 1; newsize <= cap && i < nprimes; i++)
+           newsize = primes[i];
+
+        table = new vec<Pair>[newsize];
+        cap   = newsize;
+
+        for (int i = 0; i < old_cap; i++){
+            for (int j = 0; j < old[i].size(); j++){
+                _insert(old[i][j].key, old[i][j].data); }}
+
+        delete [] old;
+
+        // printf(" --- rehashing, old-cap=%d, new-cap=%d\n", cap, newsize);
+    }
+
+    
+ public:
+
+    Map () : table(NULL), cap(0), size(0) {}
+    Map (const H& h, const E& e) : hash(h), equals(e), table(NULL), cap(0), size(0){}
+    ~Map () { delete [] table; }
+
+    // PRECONDITION: the key must already exist in the map.
+    const D& operator [] (const K& k) const
+    {
+        assert(size != 0);
+        const D*         res = NULL;
+        const vec<Pair>& ps  = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k))
+                res = &ps[i].data;
+        assert(res != NULL);
+        return *res;
+    }
+
+    // PRECONDITION: the key must already exist in the map.
+    D& operator [] (const K& k)
+    {
+        assert(size != 0);
+        D*         res = NULL;
+        vec<Pair>& ps  = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k))
+                res = &ps[i].data;
+        assert(res != NULL);
+        return *res;
+    }
+
+    // PRECONDITION: the key must *NOT* exist in the map.
+    void insert (const K& k, const D& d) { if (checkCap(size+1)) rehash(); _insert(k, d); size++; }
+    bool peek   (const K& k, D& d) const {
+        if (size == 0) return false;
+        const vec<Pair>& ps = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k)){
+                d = ps[i].data;
+                return true; } 
+        return false;
+    }
+
+    bool has   (const K& k) const {
+        if (size == 0) return false;
+        const vec<Pair>& ps = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k))
+                return true;
+        return false;
+    }
+
+    // PRECONDITION: the key must exist in the map.
+    void remove(const K& k) {
+        assert(table != NULL);
+        vec<Pair>& ps = table[index(k)];
+        int j = 0;
+        for (; j < ps.size() && !equals(ps[j].key, k); j++);
+        assert(j < ps.size());
+        ps[j] = ps.last();
+        ps.pop();
+        size--;
+    }
+
+    void clear  () {
+        cap = size = 0;
+        delete [] table;
+        table = NULL;
+    }
+
+    int  elems() const { return size; }
+    int  bucket_count() const { return cap; }
+
+    // NOTE: the hash and equality objects are not moved by this method:
+    void moveTo(Map& other){
+        delete [] other.table;
+
+        other.table = table;
+        other.cap   = cap;
+        other.size  = size;
+
+        table = NULL;
+        size = cap = 0;
+    }
+
+    // NOTE: given a bit more time, I could make a more C++-style iterator out of this:
+    const vec<Pair>& bucket(int i) const { return table[i]; }
+};
+
+//=================================================================================================
+}
+
+#endif
+/*****************************************************************************************[Queue.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_Queue_h
+#define Minisat_Queue_h
+
+
+
+namespace Maple {
+
+//=================================================================================================
+
+template<class T>
+class Queue {
+    vec<T>  buf;
+    int     first;
+    int     end;
+
+public:
+    typedef T Key;
+
+    Queue() : buf(1), first(0), end(0) {}
+
+    void clear (bool dealloc = false) { buf.clear(dealloc); buf.growTo(1); first = end = 0; }
+    int  size  () const { return (end >= first) ? end - first : end - first + buf.size(); }
+
+    const T& operator [] (int index) const  { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; }
+    T&       operator [] (int index)        { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; }
+
+    T    peek  () const { assert(first != end); return buf[first]; }
+    void pop   () { assert(first != end); first++; if (first == buf.size()) first = 0; }
+    void insert(T elem) {   // INVARIANT: buf[end] is always unused
+        buf[end++] = elem;
+        if (end == buf.size()) end = 0;
+        if (first == end){  // Resize:
+            vec<T>  tmp((buf.size()*3 + 1) >> 1);
+            //**/printf("queue alloc: %d elems (%.1f MB)\n", tmp.size(), tmp.size() * sizeof(T) / 1000000.0);
+            int     i = 0;
+            for (int j = first; j < buf.size(); j++) tmp[i++] = buf[j];
+            for (int j = 0    ; j < end       ; j++) tmp[i++] = buf[j];
+            first = 0;
+            end   = buf.size();
+            tmp.moveTo(buf);
+        }
+    }
+};
+
+
+//=================================================================================================
+}
+
+#endif
+/******************************************************************************************[Sort.h]
+Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_Sort_h
+#define Minisat_Sort_h
+
+
+
+//=================================================================================================
+// Some sorting algorithms for vec's
+
+
+namespace Maple {
+
+template<class T>
+struct LessThan_default {
+    bool operator () (T x, T y) { return x < y; }
+};
+
+
+template <class T, class LessThan>
+void selectionSort(T* array, int size, LessThan lt)
+{
+    int     i, j, best_i;
+    T       tmp;
+
+    for (i = 0; i < size-1; i++){
+        best_i = i;
+        for (j = i+1; j < size; j++){
+            if (lt(array[j], array[best_i]))
+                best_i = j;
+        }
+        tmp = array[i]; array[i] = array[best_i]; array[best_i] = tmp;
+    }
+}
+template <class T> static inline void selectionSort(T* array, int size) {
+    selectionSort(array, size, LessThan_default<T>()); }
+
+template <class T, class LessThan>
+void sort(T* array, int size, LessThan lt)
+{
+    if (size <= 15)
+        selectionSort(array, size, lt);
+
+    else{
+        T           pivot = array[size / 2];
+        T           tmp;
+        int         i = -1;
+        int         j = size;
+
+        for(;;){
+            do i++; while(lt(array[i], pivot));
+            do j--; while(lt(pivot, array[j]));
+
+            if (i >= j) break;
+
+            tmp = array[i]; array[i] = array[j]; array[j] = tmp;
+        }
+
+        sort(array    , i     , lt);
+        sort(&array[i], size-i, lt);
+    }
+}
+template <class T> static inline void sort(T* array, int size) {
+    sort(array, size, LessThan_default<T>()); }
+
+
+//=================================================================================================
+// For 'vec's:
+
+
+template <class T, class LessThan> void sort(vec<T>& v, LessThan lt) {
+    sort((T*)v, v.size(), lt); }
+template <class T> void sort(vec<T>& v) {
+    sort(v, LessThan_default<T>()); }
+
+
+//=================================================================================================
+}
+
+#endif
+/************************************************************************************[ParseUtils.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_ParseUtils_h
+#define Minisat_ParseUtils_h
+
+#include <stdlib.h>
+#include <stdio.h>
+
+namespace Maple {
+
+static inline bool isEof(const char*   in) { return *in == '\0'; }
+
+//-------------------------------------------------------------------------------------------------
+// Generic parse functions parametrized over the input-stream type.
+
+template<class B>
+static void skipWhitespace(B& in) {
+    while ((*in >= 9 && *in <= 13) || *in == 32)
+        ++in; }
+
+
+template<class B>
+static void skipLine(B& in) {
+    for (;;){
+        if (isEof(in)) return;
+        if (*in == '\n') { ++in; return; }
+        ++in; } }
+
+
+template<class B>
+static int parseInt(B& in) {
+    int     val = 0;
+    bool    neg = false;
+    skipWhitespace(in);
+    if      (*in == '-') neg = true, ++in;
+    else if (*in == '+') ++in;
+    if (*in < '0' || *in > '9') fprintf(stderr, "PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
+    while (*in >= '0' && *in <= '9')
+        val = val*10 + (*in - '0'),
+        ++in;
+    return neg ? -val : val; }
+
+
+// String matching: in case of a match the input iterator will be advanced the corresponding
+// number of characters.
+template<class B>
+static bool match(B& in, const char* str) {
+    int i;
+    for (i = 0; str[i] != '\0'; i++)
+        if (in[i] != str[i])
+            return false;
+
+    in += i;
+
+    return true; 
+}
+
+// String matching: consumes characters eagerly, but does not require random access iterator.
+template<class B>
+static bool eagerMatch(B& in, const char* str) {
+    for (; *str != '\0'; ++str, ++in)
+        if (*str != *in)
+            return false;
+    return true; }
+
+
+//=================================================================================================
+}
+
+#endif
+/***************************************************************************************[Options.h]
+Copyright (c) 2008-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_Options_h
+#define Minisat_Options_h
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+
+
+
+
+
+namespace Maple {
+
+//==================================================================================================
+// Top-level option parse/help functions:
+
+
+extern void parseOptions     (int& argc, char** argv, bool strict = false);
+extern void printUsageAndExit(int  argc, char** argv, bool verbose = false);
+extern void setUsageHelp     (const char* str);
+extern void setHelpPrefixStr (const char* str);
+
+
+//==================================================================================================
+// Options is an abstract class that gives the interface for all types options:
+
+
+class Option
+{
+ protected:
+    const char* name;
+    const char* description;
+    const char* category;
+    const char* type_name;
+
+    static vec<Option*>& getOptionList () { static vec<Option*> options; return options; }
+    static const char*&  getUsageString() { static const char* usage_str; return usage_str; }
+    static const char*&  getHelpPrefixString() { static const char* help_prefix_str = ""; return help_prefix_str; }
+
+    struct OptionLt {
+        bool operator()(const Option* x, const Option* y) {
+            int test1 = strcmp(x->category, y->category);
+            return test1 < 0 || (test1 == 0 && strcmp(x->type_name, y->type_name) < 0);
+        }
+    };
+
+    Option(const char* name_, 
+           const char* desc_,
+           const char* cate_,
+           const char* type_) : 
+      name       (name_)
+    , description(desc_)
+    , category   (cate_)
+    , type_name  (type_)
+    { 
+        getOptionList().push(this); 
+    }
+
+ public:
+    virtual ~Option() {}
+
+    virtual bool parse             (const char* str)      = 0;
+    virtual void help              (bool verbose = false) = 0;
+
+    friend  void parseOptions      (int& argc, char** argv, bool strict);
+    friend  void printUsageAndExit (int  argc, char** argv, bool verbose);
+    friend  void setUsageHelp      (const char* str);
+    friend  void setHelpPrefixStr  (const char* str);
+};
+
+
+//==================================================================================================
+// Range classes with specialization for floating types:
+
+
+struct IntRange {
+    int begin;
+    int end;
+    IntRange(int b, int e) : begin(b), end(e) {}
+};
+
+struct Int64Range {
+    int64_t begin;
+    int64_t end;
+    Int64Range(int64_t b, int64_t e) : begin(b), end(e) {}
+};
+
+struct DoubleRange {
+    double begin;
+    double end;
+    bool  begin_inclusive;
+    bool  end_inclusive;
+    DoubleRange(double b, bool binc, double e, bool einc) : begin(b), end(e), begin_inclusive(binc), end_inclusive(einc) {}
+};
+
+
+//==================================================================================================
+// Double options:
+
+
+class DoubleOption : public Option
+{
+ protected:
+    DoubleRange range;
+    double      value;
+
+ public:
+    DoubleOption(const char* c, const char* n, const char* d, double def = double(), DoubleRange r = DoubleRange(-HUGE_VAL, false, HUGE_VAL, false))
+        : Option(n, d, c, "<double>"), range(r), value(def) {
+        // FIXME: set LC_NUMERIC to "C" to make sure that strtof/strtod parses decimal point correctly.
+    }
+
+    operator      double   (void) const { return value; }
+    operator      double&  (void)       { return value; }
+    DoubleOption& operator=(double x)   { value = x; return *this; }
+
+    virtual bool parse(const char* str){
+        const char* span = str; 
+
+        if (!match(span, "-") || !match(span, name) || !match(span, "="))
+            return false;
+
+        char*  end;
+        double tmp = strtod(span, &end);
+
+        if (end == NULL) 
+            return false;
+        else if (tmp >= range.end && (!range.end_inclusive || tmp != range.end)){
+            fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name);
+            exit(1);
+        }else if (tmp <= range.begin && (!range.begin_inclusive || tmp != range.begin)){
+            fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name);
+            exit(1); }
+
+        value = tmp;
+        // fprintf(stderr, "READ VALUE: %g\n", value);
+
+        return true;
+    }
+
+    virtual void help (bool verbose = false){
+        fprintf(stderr, "  -%-12s = %-8s %c%4.2g .. %4.2g%c (default: %g)\n", 
+                name, type_name, 
+                range.begin_inclusive ? '[' : '(', 
+                range.begin,
+                range.end,
+                range.end_inclusive ? ']' : ')', 
+                value);
+        if (verbose){
+            fprintf(stderr, "\n        %s\n", description);
+            fprintf(stderr, "\n");
+        }
+    }
+};
+
+
+//==================================================================================================
+// Int options:
+
+
+class IntOption : public Option
+{
+ protected:
+    IntRange range;
+    int32_t  value;
+
+ public:
+    IntOption(const char* c, const char* n, const char* d, int32_t def = int32_t(), IntRange r = IntRange(INT32_MIN, INT32_MAX))
+        : Option(n, d, c, "<int32>"), range(r), value(def) {}
+ 
+    operator   int32_t   (void) const { return value; }
+    operator   int32_t&  (void)       { return value; }
+    IntOption& operator= (int32_t x)  { value = x; return *this; }
+
+    virtual bool parse(const char* str){
+        const char* span = str; 
+
+        if (!match(span, "-") || !match(span, name) || !match(span, "="))
+            return false;
+
+        char*   end;
+        int32_t tmp = strtol(span, &end, 10);
+
+        if (end == NULL) 
+            return false;
+        else if (tmp > range.end){
+            fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name);
+            exit(1);
+        }else if (tmp < range.begin){
+            fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name);
+            exit(1); }
+
+        value = tmp;
+
+        return true;
+    }
+
+    virtual void help (bool verbose = false){
+        fprintf(stderr, "  -%-12s = %-8s [", name, type_name);
+        if (range.begin == INT32_MIN)
+            fprintf(stderr, "imin");
+        else
+            fprintf(stderr, "%4d", range.begin);
+
+        fprintf(stderr, " .. ");
+        if (range.end == INT32_MAX)
+            fprintf(stderr, "imax");
+        else
+            fprintf(stderr, "%4d", range.end);
+
+        fprintf(stderr, "] (default: %d)\n", value);
+        if (verbose){
+            fprintf(stderr, "\n        %s\n", description);
+            fprintf(stderr, "\n");
+        }
+    }
+};
+
+
+// Leave this out for visual C++ until Microsoft implements C99 and gets support for strtoll.
+#ifndef _MSC_VER
+
+class Int64Option : public Option
+{
+ protected:
+    Int64Range range;
+    int64_t  value;
+
+ public:
+    Int64Option(const char* c, const char* n, const char* d, int64_t def = int64_t(), Int64Range r = Int64Range(INT64_MIN, INT64_MAX))
+        : Option(n, d, c, "<int64>"), range(r), value(def) {}
+ 
+    operator     int64_t   (void) const { return value; }
+    operator     int64_t&  (void)       { return value; }
+    Int64Option& operator= (int64_t x)  { value = x; return *this; }
+
+    virtual bool parse(const char* str){
+        const char* span = str; 
+
+        if (!match(span, "-") || !match(span, name) || !match(span, "="))
+            return false;
+
+        char*   end;
+        int64_t tmp = strtoll(span, &end, 10);
+
+        if (end == NULL) 
+            return false;
+        else if (tmp > range.end){
+            fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name);
+            exit(1);
+        }else if (tmp < range.begin){
+            fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name);
+            exit(1); }
+
+        value = tmp;
+
+        return true;
+    }
+
+    virtual void help (bool verbose = false){
+        fprintf(stderr, "  -%-12s = %-8s [", name, type_name);
+        if (range.begin == INT64_MIN)
+            fprintf(stderr, "imin");
+        else
+            fprintf(stderr, "%4" PRIi64, range.begin);
+
+        fprintf(stderr, " .. ");
+        if (range.end == INT64_MAX)
+            fprintf(stderr, "imax");
+        else
+            fprintf(stderr, "%4" PRIi64, range.end);
+
+        fprintf(stderr, "] (default: %" PRIi64")\n", value);
+        if (verbose){
+            fprintf(stderr, "\n        %s\n", description);
+            fprintf(stderr, "\n");
+        }
+    }
+};
+#endif
+
+//==================================================================================================
+// String option:
+
+
+class StringOption : public Option
+{
+    const char* value;
+ public:
+    StringOption(const char* c, const char* n, const char* d, const char* def = NULL) 
+        : Option(n, d, c, "<string>"), value(def) {}
+
+    operator      const char*  (void) const     { return value; }
+    operator      const char*& (void)           { return value; }
+    StringOption& operator=    (const char* x)  { value = x; return *this; }
+
+    virtual bool parse(const char* str){
+        const char* span = str; 
+
+        if (!match(span, "-") || !match(span, name) || !match(span, "="))
+            return false;
+
+        value = span;
+        return true;
+    }
+
+    virtual void help (bool verbose = false){
+        fprintf(stderr, "  -%-10s = %8s\n", name, type_name);
+        if (verbose){
+            fprintf(stderr, "\n        %s\n", description);
+            fprintf(stderr, "\n");
+        }
+    }    
+};
+
+
+//==================================================================================================
+// Bool option:
+
+
+class BoolOption : public Option
+{
+    bool value;
+
+ public:
+    BoolOption(const char* c, const char* n, const char* d, bool v) 
+        : Option(n, d, c, "<bool>"), value(v) {}
+
+    operator    bool     (void) const { return value; }
+    operator    bool&    (void)       { return value; }
+    BoolOption& operator=(bool b)     { value = b; return *this; }
+
+    virtual bool parse(const char* str){
+        const char* span = str; 
+        
+        if (match(span, "-")){
+            bool b = !match(span, "no-");
+
+            if (strcmp(span, name) == 0){
+                value = b;
+                return true; }
+        }
+
+        return false;
+    }
+
+    virtual void help (bool verbose = false){
+
+        fprintf(stderr, "  -%s, -no-%s", name, name);
+
+        for (uint32_t i = 0; i < 32 - strlen(name)*2; i++)
+            fprintf(stderr, " ");
+
+        fprintf(stderr, " ");
+        fprintf(stderr, "(default: %s)\n", value ? "on" : "off");
+        if (verbose){
+            fprintf(stderr, "\n        %s\n", description);
+            fprintf(stderr, "\n");
+        }
+    }
+};
+
+//=================================================================================================
+}
+
+#endif
+/****************************************************************************************[System.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_System_h
+#define Minisat_System_h
+
+
+//-------------------------------------------------------------------------------------------------
+
+namespace Maple {
+
+static inline double cpuTime(void); // CPU-time in seconds.
+extern double memUsed();            // Memory in mega bytes (returns 0 for unsupported architectures).
+extern double memUsedPeak();        // Peak-memory in mega bytes (returns 0 for unsupported architectures).
+
+}
+
+//-------------------------------------------------------------------------------------------------
+// Implementation of inline functions:
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#include <time.h>
+
+static inline double Maple::cpuTime(void) { return (double)clock() / CLOCKS_PER_SEC; }
+
+#else
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <unistd.h>
+
+static inline double Maple::cpuTime(void) {
+    struct rusage ru;
+    getrusage(RUSAGE_SELF, &ru);
+    return (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec / 1000000; }
+
+#endif
+
+#endif
+/***********************************************************************************[SolverTypes.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+           Copyright (c) 2007-2010, Niklas Sorensson
+ 
+Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
+
+Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach
+Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear.
+ 
+Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search
+ 
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef Minisat_SolverTypes_h
+#define Minisat_SolverTypes_h
+
+#include <assert.h>
+
+
+
+
+
+
+#include <iostream>
+
+namespace Maple {
+
+//=================================================================================================
+// Variables, literals, lifted booleans, clauses:
+
+
+// NOTE! Variables are just integers. No abstraction here. They should be chosen from 0..N,
+// so that they can be used as array indices.
+
+typedef int Var;
+#define var_Undef (-1)
+
+
+struct Lit {
+    int     x;
+
+    // Use this as a constructor:
+    friend Lit mkLit(Var var, bool sign );
+
+    bool operator == (Lit p) const { return x == p.x; }
+    bool operator != (Lit p) const { return x != p.x; }
+    bool operator <  (Lit p) const { return x < p.x;  } // '<' makes p, ~p adjacent in the ordering.
+};
+
+inline  Lit  mkLit     (Var var, bool sign= false) { Lit p; p.x = var + var + (int)sign; return p; }
+inline  Lit  operator ~(Lit p)              { Lit q; q.x = p.x ^ 1; return q; }
+inline  Lit  operator ^(Lit p, bool b)      { Lit q; q.x = p.x ^ (unsigned int)b; return q; }
+inline  bool sign      (Lit p)              { return p.x & 1; }
+inline  int  var       (Lit p)              { return p.x >> 1; }
+
+// Mapping Literals to and from compact integers suitable for array indexing:
+inline  int  toInt     (Var v)              { return v; } 
+inline  int  toInt     (Lit p)              { return p.x; } 
+inline  Lit  toLit     (int i)              { Lit p; p.x = i; return p; } 
+
+//const Lit lit_Undef = mkLit(var_Undef, false);  // }- Useful special constants.
+//const Lit lit_Error = mkLit(var_Undef, true );  // }
+
+const Lit lit_Undef = { -2 };  // }- Useful special constants.
+const Lit lit_Error = { -1 };  // }
+
+inline std::ostream& operator<<(std::ostream& out, const Lit& val) 
+{
+    out << (sign(val) ? -var(val) : var(val)) << std::flush;
+    return out;
+}
+
+
+
+//=================================================================================================
+// Lifted booleans:
+//
+// NOTE: this implementation is optimized for the case when comparisons between values are mostly
+//       between one variable and one constant. Some care had to be taken to make sure that gcc 
+//       does enough constant propagation to produce sensible code, and this appears to be somewhat
+//       fragile unfortunately.
+
+class lbool {
+    uint8_t value;
+
+public:
+    constexpr explicit lbool(uint8_t v) : value(v) { }
+
+    lbool()       : value(0) { }
+    explicit lbool(bool x) : value(!x) { }
+
+    bool  operator == (lbool b) const { return ((b.value&2) & (value&2)) | (!(b.value&2)&(value == b.value)); }
+    bool  operator != (lbool b) const { return !(*this == b); }
+    lbool operator ^  (bool  b) const { return lbool((uint8_t)(value^(uint8_t)b)); }
+
+    lbool operator && (lbool b) const {
+        uint8_t sel = (this->value << 1) | (b.value << 3);
+        uint8_t v   = (0xF7F755F4 >> sel) & 3;
+        return lbool(v); }
+
+    lbool operator || (lbool b) const {
+        uint8_t sel = (this->value << 1) | (b.value << 3);
+        uint8_t v   = (0xFCFCF400 >> sel) & 3;
+        return lbool(v); }
+
+    friend int   toInt  (lbool l);
+    friend lbool toLbool(int   v);
+};
+inline int   toInt  (lbool l) { return l.value; }
+inline lbool toLbool(int   v) { return lbool((uint8_t)v);  }
+
+constexpr auto l_True = Maple::lbool((uint8_t)0);
+constexpr auto l_False = Maple::lbool((uint8_t)1);
+constexpr auto l_Undef = Maple::lbool((uint8_t)2);
+
+//=================================================================================================
+// Clause -- a simple class for representing a clause:
+
+class Clause;
+typedef RegionAllocator<uint32_t>::Ref CRef;
+
+class Clause {
+    struct {
+        unsigned mark      : 2;
+        unsigned learnt    : 1;
+        unsigned has_extra : 1;
+        unsigned reloced   : 1;
+        unsigned lbd       : 26;
+        unsigned removable : 1;
+        unsigned size      : 32;
+        //simplify
+        unsigned simplified : 1;}                            header;
+    union { Lit lit; float act; uint32_t abs; uint32_t touched; CRef rel; } data[0];
+
+    friend class ClauseAllocator;
+
+    // NOTE: This constructor cannot be used directly (doesn't allocate enough memory).
+    template<class V>
+    Clause(const V& ps, bool use_extra, bool learnt) {
+        header.mark      = 0;
+        header.learnt    = learnt;
+        header.has_extra = learnt | use_extra;
+        header.reloced   = 0;
+        header.size      = ps.size();
+        header.lbd       = 0;
+        header.removable = 1;
+        //simplify
+        //
+        header.simplified = 0;
+
+        for (int i = 0; i < ps.size(); i++)
+            data[i].lit = ps[i];
+
+        if (header.has_extra){
+            if (header.learnt){
+                data[header.size].act = 0;
+                data[header.size+1].touched = 0;
+            }else
+                calcAbstraction(); }
+    }
+
+public:
+    void calcAbstraction() {
+        assert(header.has_extra);
+        uint32_t abstraction = 0;
+        for (int i = 0; i < size(); i++)
+            abstraction |= 1 << (var(data[i].lit) & 31);
+        data[header.size].abs = abstraction;  }
+
+
+    int          size        ()      const   { return header.size; }
+    void         shrink      (int i)         { assert(i <= size()); if (header.has_extra) data[header.size-i] = data[header.size]; header.size -= i; }
+    void         pop         ()              { shrink(1); }
+    bool         learnt      ()      const   { return header.learnt; }
+    bool         has_extra   ()      const   { return header.has_extra; }
+    uint32_t     mark        ()      const   { return header.mark; }
+    void         mark        (uint32_t m)    { header.mark = m; }
+    const Lit&   last        ()      const   { return data[header.size-1].lit; }
+
+    bool         reloced     ()      const   { return header.reloced; }
+    CRef         relocation  ()      const   { return data[0].rel; }
+    void         relocate    (CRef c)        { header.reloced = 1; data[0].rel = c; }
+
+    int          lbd         ()      const   { return header.lbd; }
+    void         set_lbd     (int lbd)       { header.lbd = lbd; }
+    bool         removable   ()      const   { return header.removable; }
+    void         removable   (bool b)        { header.removable = b; }
+
+    // NOTE: somewhat unsafe to change the clause in-place! Must manually call 'calcAbstraction' afterwards for
+    //       subsumption operations to behave correctly.
+    Lit&         operator [] (int i)         { return data[i].lit; }
+    Lit          operator [] (int i) const   { return data[i].lit; }
+    operator const Lit* (void) const         { return (Lit*)data; }
+
+    uint32_t&    touched     ()              { assert(header.has_extra && header.learnt); return data[header.size+1].touched; }
+    float&       activity    ()              { assert(header.has_extra); return data[header.size].act; }
+    uint32_t     abstraction () const        { assert(header.has_extra); return data[header.size].abs; }
+
+    Lit          subsumes    (const Clause& other) const;
+    void         strengthen  (Lit p);
+    // simplify
+    //
+    void setSimplified(bool b) { header.simplified = b; }
+    bool simplified() { return header.simplified; }
+};
+
+
+//=================================================================================================
+// ClauseAllocator -- a simple class for allocating memory for clauses:
+
+
+const CRef CRef_Undef = RegionAllocator<uint32_t>::Ref_Undef;
+class ClauseAllocator : public RegionAllocator<uint32_t>
+{
+    static int clauseWord32Size(int size, int extras){
+        return (sizeof(Clause) + (sizeof(Lit) * (size + extras))) / sizeof(uint32_t); }
+public:
+    bool extra_clause_field;
+
+    ClauseAllocator(uint32_t start_cap) : RegionAllocator<uint32_t>(start_cap), extra_clause_field(false){}
+    ClauseAllocator() : extra_clause_field(false){}
+
+    void moveTo(ClauseAllocator& to){
+        to.extra_clause_field = extra_clause_field;
+        RegionAllocator<uint32_t>::moveTo(to); }
+
+    template<class Lits>
+    CRef alloc(const Lits& ps, bool learnt = false)
+    {
+        assert(sizeof(Lit)      == sizeof(uint32_t));
+        assert(sizeof(float)    == sizeof(uint32_t));
+        int extras = learnt ? 2 : (int)extra_clause_field;
+
+        CRef cid = RegionAllocator<uint32_t>::alloc(clauseWord32Size(ps.size(), extras));
+        new (lea(cid)) Clause(ps, extra_clause_field, learnt);
+
+        return cid;
+    }
+
+    // Deref, Load Effective Address (LEA), Inverse of LEA (AEL):
+    Clause&       operator[](Ref r)       { return (Clause&)RegionAllocator<uint32_t>::operator[](r); }
+    const Clause& operator[](Ref r) const { return (Clause&)RegionAllocator<uint32_t>::operator[](r); }
+    Clause*       lea       (Ref r)       { return (Clause*)RegionAllocator<uint32_t>::lea(r); }
+    const Clause* lea       (Ref r) const { return (Clause*)RegionAllocator<uint32_t>::lea(r); }
+    Ref           ael       (const Clause* t){ return RegionAllocator<uint32_t>::ael((uint32_t*)t); }
+
+    void free(CRef cid)
+    {
+        Clause& c = operator[](cid);
+        int extras = c.learnt() ? 2 : (int)c.has_extra();
+        RegionAllocator<uint32_t>::free(clauseWord32Size(c.size(), extras));
+    }
+
+    void reloc(CRef& cr, ClauseAllocator& to)
+    {
+        Clause& c = operator[](cr);
+        
+        if (c.reloced()) { cr = c.relocation(); return; }
+        
+        cr = to.alloc(c, c.learnt());
+        c.relocate(cr);
+        
+        // Copy extra data-fields:
+        // (This could be cleaned-up. Generalize Clause-constructor to be applicable here instead?)
+        to[cr].mark(c.mark());
+        if (to[cr].learnt()){
+            to[cr].touched() = c.touched();
+            to[cr].activity() = c.activity();
+            to[cr].set_lbd(c.lbd());
+            to[cr].removable(c.removable());
+            // simplify
+            //
+            to[cr].setSimplified(c.simplified());
+        }
+        else if (to[cr].has_extra()) to[cr].calcAbstraction();
+    }
+};
+
+
+inline std::ostream& operator<<(std::ostream& out, const Clause& cls) 
+{
+    for (int i = 0; i < cls.size(); ++i)
+    {
+		out << cls[i] << " ";
+	}
+	
+    return out;
+}
+
+//=================================================================================================
+// OccLists -- a class for maintaining occurence lists with lazy deletion:
+
+template<class Idx, class Vec, class Deleted>
+class OccLists
+{
+    vec<Vec>  occs;
+    vec<char> dirty;
+    vec<Idx>  dirties;
+    Deleted   deleted;
+
+public:
+    OccLists(const Deleted& d) : deleted(d) {}
+    
+    void  init      (const Idx& idx){ occs.growTo(toInt(idx)+1); dirty.growTo(toInt(idx)+1, 0); }
+    // Vec&  operator[](const Idx& idx){ return occs[toInt(idx)]; }
+    Vec&  operator[](const Idx& idx){ return occs[toInt(idx)]; }
+    Vec&  lookup    (const Idx& idx){ if (dirty[toInt(idx)]) clean(idx); return occs[toInt(idx)]; }
+
+    void  cleanAll  ();
+    void  clean     (const Idx& idx);
+    void  smudge    (const Idx& idx){
+        if (dirty[toInt(idx)] == 0){
+            dirty[toInt(idx)] = 1;
+            dirties.push(idx);
+        }
+    }
+
+    void  clear(bool free = true){
+        occs   .clear(free);
+        dirty  .clear(free);
+        dirties.clear(free);
+    }
+};
+
+
+template<class Idx, class Vec, class Deleted>
+void OccLists<Idx,Vec,Deleted>::cleanAll()
+{
+    for (int i = 0; i < dirties.size(); i++)
+        // Dirties may contain duplicates so check here if a variable is already cleaned:
+        if (dirty[toInt(dirties[i])])
+            clean(dirties[i]);
+    dirties.clear();
+}
+
+
+template<class Idx, class Vec, class Deleted>
+void OccLists<Idx,Vec,Deleted>::clean(const Idx& idx)
+{
+    Vec& vec = occs[toInt(idx)];
+    int  i, j;
+    for (i = j = 0; i < vec.size(); i++)
+        if (!deleted(vec[i]))
+            vec[j++] = vec[i];
+    vec.shrink(i - j);
+    dirty[toInt(idx)] = 0;
+}
+
+
+//=================================================================================================
+// CMap -- a class for mapping clauses to values:
+
+
+template<class T>
+class CMap
+{
+    struct CRefHash {
+        uint32_t operator()(CRef cr) const { return (uint32_t)cr; } };
+
+    typedef Map<CRef, T, CRefHash> HashTable;
+    HashTable map;
+
+public:
+    // Size-operations:
+    void     clear       ()                           { map.clear(); }
+    int      size        ()                const      { return map.elems(); }
+
+    
+    // Insert/Remove/Test mapping:
+    void     insert      (CRef cr, const T& t){ map.insert(cr, t); }
+    void     growTo      (CRef cr, const T& t){ map.insert(cr, t); } // NOTE: for compatibility
+    void     remove      (CRef cr)            { map.remove(cr); }
+    bool     has         (CRef cr, T& t)      { return map.peek(cr, t); }
+
+    // Vector interface (the clause 'c' must already exist):
+    const T& operator [] (CRef cr) const      { return map[cr]; }
+    T&       operator [] (CRef cr)            { return map[cr]; }
+
+    // Iteration (not transparent at all at the moment):
+    int  bucket_count() const { return map.bucket_count(); }
+    const vec<typename HashTable::Pair>& bucket(int i) const { return map.bucket(i); }
+
+    // Move contents to other map:
+    void moveTo(CMap& other){ map.moveTo(other.map); }
+
+    // TMP debug:
+    void debug(){
+        printf("c --- size = %d, bucket_count = %d\n", size(), map.bucket_count()); }
+};
+
+
+/*_________________________________________________________________________________________________
+|
+|  subsumes : (other : const Clause&)  ->  Lit
+|  
+|  Description:
+|       Checks if clause subsumes 'other', and at the same time, if it can be used to simplify 'other'
+|       by subsumption resolution.
+|  
+|    Result:
+|       lit_Error  - No subsumption or simplification
+|       lit_Undef  - Clause subsumes 'other'
+|       p          - The literal p can be deleted from 'other'
+|________________________________________________________________________________________________@*/
+inline Lit Clause::subsumes(const Clause& other) const
+{
+    //if (other.size() < size() || (extra.abst & ~other.extra.abst) != 0)
+    //if (other.size() < size() || (!learnt() && !other.learnt() && (extra.abst & ~other.extra.abst) != 0))
+    assert(!header.learnt);   assert(!other.header.learnt);
+    assert(header.has_extra); assert(other.header.has_extra);
+    if (other.header.size < header.size || (data[header.size].abs & ~other.data[other.header.size].abs) != 0)
+        return lit_Error;
+
+    Lit        ret = lit_Undef;
+    const Lit* c   = (const Lit*)(*this);
+    const Lit* d   = (const Lit*)other;
+
+    for (unsigned i = 0; i < header.size; i++) {
+        // search for c[i] or ~c[i]
+        for (unsigned j = 0; j < other.header.size; j++)
+            if (c[i] == d[j])
+                goto ok;
+            else if (ret == lit_Undef && c[i] == ~d[j]){
+                ret = c[i];
+                goto ok;
+            }
+
+        // did not find it
+        return lit_Error;
+ok:;
+    }
+
+    return ret;
+}
+
+inline void Clause::strengthen(Lit p)
+{
+    remove(*this, p);
+    calcAbstraction();
+}
+
+//=================================================================================================
+}
+
+#endif
+/****************************************************************************************[Solver.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+           Copyright (c) 2007-2010, Niklas Sorensson
+
+Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
+ 
+Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach
+Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear.
+ 
+Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search
+ 
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_Solver_h
+#define Minisat_Solver_h
+
+#define ANTI_EXPLORATION
+#define BIN_DRUP
+
+#define GLUCOSE23
+//#define INT_QUEUE_AVG
+//#define LOOSE_PROP_STAT
+
+#ifdef GLUCOSE23
+#define INT_QUEUE_AVG
+#define LOOSE_PROP_STAT
+#endif
+
+
+
+
+
+
+
+
+// Don't change the actual numbers.
+#define LOCAL 0
+#define TIER2 2
+#define CORE  3
+
+namespace Maple {
+
+//=================================================================================================
+// Solver -- the main class:
+
+class Solver {
+private:
+    template<typename T>
+    class MyQueue {
+        int max_sz, q_sz;
+        int ptr;
+        int64_t sum;
+        vec<T> q;
+    public:
+        MyQueue(int sz) : max_sz(sz), q_sz(0), ptr(0), sum(0) { assert(sz > 0); q.growTo(sz); }
+        inline bool   full () const { return q_sz == max_sz; }
+#ifdef INT_QUEUE_AVG
+        inline T      avg  () const { assert(full()); return sum / max_sz; }
+#else
+        inline double avg  () const { assert(full()); return sum / (double) max_sz; }
+#endif
+        inline void   clear()       { sum = 0; q_sz = 0; ptr = 0; }
+        void push(T e) {
+            if (q_sz < max_sz) q_sz++;
+            else sum -= q[ptr];
+            sum += e;
+            q[ptr++] = e;
+            if (ptr == max_sz) ptr = 0;
+        }
+    };
+
+inline void printLit(Lit l)
+{
+    printf("%s%d:%c", sign(l) ? "-" : "", var(l)+1, value(l) == l_True ? '1' : (value(l) == l_False ? '0' : 'X'));
+}
+
+
+inline void printClause(CRef cr)
+{
+  Clause &c = ca[cr];
+    for (int i = 0; i < c.size(); i++){
+        printLit(c[i]);
+        printf(" ");
+    }
+    printf("\n");
+}
+public:
+
+    // Constructor/Destructor:
+    //
+    Solver();
+    virtual ~Solver();
+
+    // Problem specification:
+    //
+    Var     newVar    (bool polarity = true, bool dvar = true); // Add a new variable with parameters specifying variable mode.
+
+    bool    addClause (const vec<Lit>& ps);                     // Add a clause to the solver.
+    bool    addEmptyClause();                                   // Add the empty clause, making the solver contradictory.
+    bool    addClause (Lit p);                                  // Add a unit clause to the solver.
+    bool    addClause (Lit p, Lit q);                           // Add a binary clause to the solver.
+    bool    addClause (Lit p, Lit q, Lit r);                    // Add a ternary clause to the solver.
+    bool    addClause_(      vec<Lit>& ps);                     // Add a clause to the solver without making superflous internal copy. Will
+    // change the passed vector 'ps'.
+
+    // Solving:
+    //
+    bool    simplify     ();                        // Removes already satisfied clauses.
+    bool    solve        (const vec<Lit>& assumps); // Search for a model that respects a given set of assumptions.
+    lbool   solveLimited (const vec<Lit>& assumps); // Search for a model that respects a given set of assumptions (With resource constraints).
+    bool    solve        ();                        // Search without assumptions.
+    bool    solve        (Lit p);                   // Search for a model that respects a single assumption.
+    bool    solve        (Lit p, Lit q);            // Search for a model that respects two assumptions.
+    bool    solve        (Lit p, Lit q, Lit r);     // Search for a model that respects three assumptions.
+    bool    okay         () const;                  // FALSE means solver is in a conflicting state
+
+    void    toDimacs     (FILE* f, const vec<Lit>& assumps);            // Write CNF to file in DIMACS-format.
+    void    toDimacs     (const char *file, const vec<Lit>& assumps);
+    void    toDimacs     (FILE* f, Clause& c, vec<Var>& map, Var& max);
+
+    // Convenience versions of 'toDimacs()':
+    void    toDimacs     (const char* file);
+    void    toDimacs     (const char* file, Lit p);
+    void    toDimacs     (const char* file, Lit p, Lit q);
+    void    toDimacs     (const char* file, Lit p, Lit q, Lit r);
+    
+    // Variable mode:
+    //
+    void    setPolarity    (Var v, bool b); // Declare which polarity the decision heuristic should use for a variable. Requires mode 'polarity_user'.
+    void    setDecisionVar (Var v, bool b); // Declare if a variable should be eligible for selection in the decision heuristic.
+
+    // Read state:
+    //
+    lbool   value      (Var x) const;       // The current value of a variable.
+    lbool   value      (Lit p) const;       // The current value of a literal.
+    lbool   modelValue (Var x) const;       // The value of a variable in the last model. The last call to solve must have been satisfiable.
+    lbool   modelValue (Lit p) const;       // The value of a literal in the last model. The last call to solve must have been satisfiable.
+    int     nAssigns   ()      const;       // The current number of assigned literals.
+    int     nClauses   ()      const;       // The current number of original clauses.
+    int     nLearnts   ()      const;       // The current number of learnt clauses.
+    int     nVars      ()      const;       // The current number of variables.
+    int     nFreeVars  ()      const;
+
+    // Resource contraints:
+    //
+    void    setConfBudget(int64_t x);
+    void    setPropBudget(int64_t x);
+    void    budgetOff();
+    void    interrupt();          // Trigger a (potentially asynchronous) interruption of the solver.
+    void    clearInterrupt();     // Clear interrupt indicator flag.
+
+    // Memory managment:
+    //
+    virtual void garbageCollect();
+    void    checkGarbage(double gf);
+    void    checkGarbage();
+
+    // Extra results: (read-only member variable)
+    //
+    vec<lbool> model;             // If problem is satisfiable, this vector contains the model (if any).
+    vec<Lit>   conflict;          // If problem is unsatisfiable (possibly under assumptions),
+    // this vector represent the final conflict clause expressed in the assumptions.
+
+    // Mode of operation:
+    //
+    FILE*     drup_file;
+    int       verbosity;
+    double    step_size;
+    double    step_size_dec;
+    double    min_step_size;
+    int       timer;
+    double    var_decay;
+    double    clause_decay;
+    double    random_var_freq;
+    double    random_seed;
+    bool      VSIDS;
+    int       ccmin_mode;         // Controls conflict clause minimization (0=none, 1=basic, 2=deep).
+    int       phase_saving;       // Controls the level of phase saving (0=none, 1=limited, 2=full).
+    bool      rnd_pol;            // Use random polarities for branching heuristics.
+    bool      rnd_init_act;       // Initialize variable activities with a small random value.
+    double    garbage_frac;       // The fraction of wasted memory allowed before a garbage collection is triggered.
+
+    int       restart_first;      // The initial restart limit.                                                                (default 100)
+    double    restart_inc;        // The factor with which the restart limit is multiplied in each restart.                    (default 1.5)
+    double    learntsize_factor;  // The intitial limit for learnt clauses is a factor of the original clauses.                (default 1 / 3)
+    double    learntsize_inc;     // The limit for learnt clauses is multiplied with this factor each restart.                 (default 1.1)
+
+    int       learntsize_adjust_start_confl;
+    double    learntsize_adjust_inc;
+
+    // Statistics: (read-only member variable)
+    //
+    uint64_t solves, starts, decisions, rnd_decisions, propagations, conflicts, conflicts_VSIDS;
+    uint64_t dec_vars, clauses_literals, learnts_literals, max_literals, tot_literals;
+    uint64_t chrono_backtrack, non_chrono_backtrack;
+
+    vec<uint32_t> picked;
+    vec<uint32_t> conflicted;
+    vec<uint32_t> almost_conflicted;
+#ifdef ANTI_EXPLORATION
+    vec<uint32_t> canceled;
+#endif
+
+protected:
+
+    // Helper structures:
+    //
+    struct VarData { CRef reason; int level; };
+    static inline VarData mkVarData(CRef cr, int l){ VarData d = {cr, l}; return d; }
+
+    struct Watcher {
+        CRef cref;
+        Lit  blocker;
+        Watcher(CRef cr, Lit p) : cref(cr), blocker(p) {}
+        bool operator==(const Watcher& w) const { return cref == w.cref; }
+        bool operator!=(const Watcher& w) const { return cref != w.cref; }
+    };
+
+    struct WatcherDeleted
+    {
+        const ClauseAllocator& ca;
+        WatcherDeleted(const ClauseAllocator& _ca) : ca(_ca) {}
+        bool operator()(const Watcher& w) const { return ca[w.cref].mark() == 1; }
+    };
+
+    struct VarOrderLt {
+        const vec<double>&  activity;
+        bool operator () (Var x, Var y) const { return activity[x] > activity[y]; }
+        VarOrderLt(const vec<double>&  act) : activity(act) { }
+    };
+    
+    struct ConflictData
+	{
+		ConflictData() :
+			nHighestLevel(-1),
+			bOnlyOneLitFromHighest(false)
+		{}
+
+		int nHighestLevel;
+		bool bOnlyOneLitFromHighest;
+	};
+
+    // Solver state:
+    //
+    bool                ok;               // If FALSE, the constraints are already unsatisfiable. No part of the solver state may be used!
+    vec<CRef>           clauses;          // List of problem clauses.
+    vec<CRef>           learnts_core,     // List of learnt clauses.
+    learnts_tier2,
+    learnts_local;
+    double              cla_inc;          // Amount to bump next clause with.
+    vec<double>         activity_CHB,     // A heuristic measurement of the activity of a variable.
+    activity_VSIDS,activity_distance;
+    double              var_inc;          // Amount to bump next variable with.
+    OccLists<Lit, vec<Watcher>, WatcherDeleted>
+    watches_bin,      // Watches for binary clauses only.
+    watches;          // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true).
+    vec<lbool>          assigns;          // The current assignments.
+    vec<char>           polarity;         // The preferred polarity of each variable.
+    vec<char>           decision;         // Declares if a variable is eligible for selection in the decision heuristic.
+    vec<Lit>            trail;            // Assignment stack; stores all assigments made in the order they were made.
+    vec<int>            trail_lim;        // Separator indices for different decision levels in 'trail'.
+    vec<VarData>        vardata;          // Stores reason and level for each variable.
+    int                 qhead;            // Head of queue (as index into the trail -- no more explicit propagation queue in MiniSat).
+    int                 simpDB_assigns;   // Number of top-level assignments since last execution of 'simplify()'.
+    int64_t             simpDB_props;     // Remaining number of propagations that must be made before next execution of 'simplify()'.
+    vec<Lit>            assumptions;      // Current set of assumptions provided to solve by the user.
+    Heap<VarOrderLt>    order_heap_CHB,   // A priority queue of variables ordered with respect to the variable activity.
+    order_heap_VSIDS,order_heap_distance;
+    double              progress_estimate;// Set by 'search()'.
+    bool                remove_satisfied; // Indicates whether possibly inefficient linear scan for satisfied clauses should be performed in 'simplify'.
+
+    int                 core_lbd_cut;
+    float               global_lbd_sum;
+    MyQueue<int>        lbd_queue;  // For computing moving averages of recent LBD values.
+
+    uint64_t            next_T2_reduce,
+    next_L_reduce;
+
+    ClauseAllocator     ca;
+    
+    int 				confl_to_chrono;
+    int 				chrono;
+
+    // Temporaries (to reduce allocation overhead). Each variable is prefixed by the method in which it is
+    // used, exept 'seen' wich is used in several places.
+    //
+    vec<char>           seen;
+    vec<Lit>            analyze_stack;
+    vec<Lit>            analyze_toclear;
+    vec<Lit>            add_tmp;
+    vec<Lit>            add_oc;
+
+    vec<uint64_t>       seen2;    // Mostly for efficient LBD computation. 'seen2[i]' will indicate if decision level or variable 'i' has been seen.
+    uint64_t            counter;  // Simple counter for marking purpose with 'seen2'.
+
+    double              max_learnts;
+    double              learntsize_adjust_confl;
+    int                 learntsize_adjust_cnt;
+
+    // Resource contraints:
+    //
+    int64_t             conflict_budget;    // -1 means no budget.
+    int64_t             propagation_budget; // -1 means no budget.
+    bool                asynch_interrupt;
+
+    // Main internal methods:
+    //
+    void     insertVarOrder   (Var x);                                                 // Insert a variable in the decision order priority queue.
+    Lit      pickBranchLit    ();                                                      // Return the next decision variable.
+    void     newDecisionLevel ();                                                      // Begins a new decision level.
+    void     uncheckedEnqueue (Lit p, int level = 0, CRef from = CRef_Undef);                         // Enqueue a literal. Assumes value of literal is undefined.
+    bool     enqueue          (Lit p, CRef from = CRef_Undef);                         // Test if fact 'p' contradicts current state, enqueue otherwise.
+    CRef     propagate        ();                                                      // Perform unit propagation. Returns possibly conflicting clause.
+    void     cancelUntil      (int level);                                             // Backtrack until a certain level.
+    void     analyze          (CRef confl, vec<Lit>& out_learnt, int& out_btlevel, int& out_lbd);    // (bt = backtrack)
+    void     analyzeFinal     (Lit p, vec<Lit>& out_conflict);                         // COULD THIS BE IMPLEMENTED BY THE ORDINARIY "analyze" BY SOME REASONABLE GENERALIZATION?
+    bool     litRedundant     (Lit p, uint32_t abstract_levels);                       // (helper method for 'analyze()')
+    lbool    search           (int& nof_conflicts);                                    // Search for a given number of conflicts.
+    lbool    solve_           ();                                                      // Main solve method (assumptions given in 'assumptions').
+    void     reduceDB         ();                                                      // Reduce the set of learnt clauses.
+    void     reduceDB_Tier2   ();
+    void     removeSatisfied  (vec<CRef>& cs);                                         // Shrink 'cs' to contain only non-satisfied clauses.
+    void     safeRemoveSatisfied(vec<CRef>& cs, unsigned valid_mark);
+    void     rebuildOrderHeap ();
+    bool     binResMinimize   (vec<Lit>& out_learnt);                                  // Further learnt clause minimization by binary resolution.
+
+    // Maintaining Variable/Clause activity:
+    //
+    void     varDecayActivity ();                      // Decay all variables with the specified factor. Implemented by increasing the 'bump' value instead.
+    void     varBumpActivity  (Var v, double mult);    // Increase a variable with the current 'bump' value.
+    void     claDecayActivity ();                      // Decay all clauses with the specified factor. Implemented by increasing the 'bump' value instead.
+    void     claBumpActivity  (Clause& c);             // Increase a clause with the current 'bump' value.
+
+    // Operations on clauses:
+    //
+    void     attachClause     (CRef cr);               // Attach a clause to watcher lists.
+    void     detachClause     (CRef cr, bool strict = false); // Detach a clause to watcher lists.
+    void     removeClause     (CRef cr);               // Detach and free a clause.
+    bool     locked           (const Clause& c) const; // Returns TRUE if a clause is a reason for some implication in the current state.
+    bool     satisfied        (const Clause& c) const; // Returns TRUE if a clause is satisfied in the current state.
+
+    void     relocAll         (ClauseAllocator& to);
+
+    // Misc:
+    //
+    int      decisionLevel    ()      const; // Gives the current decisionlevel.
+    uint32_t abstractLevel    (Var x) const; // Used to represent an abstraction of sets of decision levels.
+    CRef     reason           (Var x) const;
+    
+    ConflictData FindConflictLevel(CRef cind);
+    
+public:
+    int      level            (Var x) const;
+protected:
+    double   progressEstimate ()      const; // DELETE THIS ?? IT'S NOT VERY USEFUL ...
+    bool     withinBudget     ()      const;
+
+    template<class V> int computeLBD(const V& c) {
+        int lbd = 0;
+
+        counter++;
+        for (int i = 0; i < c.size(); i++){
+            int l = level(var(c[i]));
+            if (l != 0 && seen2[l] != counter){
+                seen2[l] = counter;
+                lbd++; } }
+
+        return lbd;
+    }
+
+#ifdef BIN_DRUP
+    static inline int buf_len = 0;
+    static inline unsigned char drup_buf[2 * 1024 * 1024];
+    static inline unsigned char* buf_ptr = drup_buf;
+
+    static inline void byteDRUP(Lit l){
+        unsigned int u = 2 * (var(l) + 1) + sign(l);
+        do{
+            *buf_ptr++ = (u & 0x7f) | 0x80; buf_len++;
+            u = u >> 7;
+        }while (u);
+        *(buf_ptr - 1) &= 0x7f; // End marker of this unsigned number.
+    }
+
+    template<class V>
+    static inline void binDRUP(unsigned char op, const V& c, FILE* drup_file){
+        assert(op == 'a' || op == 'd');
+        *buf_ptr++ = op; buf_len++;
+        for (int i = 0; i < c.size(); i++) byteDRUP(c[i]);
+        *buf_ptr++ = 0; buf_len++;
+        if (buf_len > 1048576) binDRUP_flush(drup_file);
+    }
+
+    static inline void binDRUP_strengthen(const Clause& c, Lit l, FILE* drup_file){
+        *buf_ptr++ = 'a'; buf_len++;
+        for (int i = 0; i < c.size(); i++)
+            if (c[i] != l) byteDRUP(c[i]);
+        *buf_ptr++ = 0; buf_len++;
+        if (buf_len > 1048576) binDRUP_flush(drup_file);
+    }
+
+    static inline void binDRUP_flush(FILE* drup_file){
+       fwrite(drup_buf, sizeof(unsigned char), buf_len, drup_file);
+        // fwrite_unlocked(drup_buf, sizeof(unsigned char), buf_len, drup_file);
+        buf_ptr = drup_buf; buf_len = 0;
+    }
+#endif
+
+    // Static helpers:
+    //
+
+    // Returns a random float 0 <= x < 1. Seed must never be 0.
+    static inline double drand(double& seed) {
+        seed *= 1389796;
+        int q = (int)(seed / 2147483647);
+        seed -= (double)q * 2147483647;
+        return seed / 2147483647; }
+
+    // Returns a random integer 0 <= x < size. Seed must never be 0.
+    static inline int irand(double& seed, int size) {
+        return (int)(drand(seed) * size); }
+
+
+    // simplify
+    //
+public:
+    bool	simplifyAll();
+    void	simplifyLearnt(Clause& c);
+    bool	simplifyLearnt_x(vec<CRef>& learnts_x);
+    bool	simplifyLearnt_core();
+    bool	simplifyLearnt_tier2();
+    int		trailRecord;
+    void	litsEnqueue(int cutP, Clause& c);
+    void	cancelUntilTrailRecord();
+    void	simpleUncheckEnqueue(Lit p, CRef from = CRef_Undef);
+    CRef    simplePropagate();
+    uint64_t nbSimplifyAll;
+    uint64_t simplified_length_record, original_length_record;
+    uint64_t s_propagations;
+
+    vec<Lit> simp_learnt_clause;
+    vec<CRef> simp_reason_clause;
+    void	simpleAnalyze(CRef confl, vec<Lit>& out_learnt, vec<CRef>& reason_clause, bool True_confl);
+
+    // in redundant
+    bool removed(CRef cr);
+    // adjust simplifyAll occasion
+    long curSimplify;
+    int nbconfbeforesimplify;
+    int incSimplify;
+
+    bool collectFirstUIP(CRef confl);
+    vec<double> var_iLevel,var_iLevel_tmp;
+    uint64_t nbcollectfirstuip, nblearntclause, nbDoubleConflicts, nbTripleConflicts;
+    int uip1, uip2;
+    vec<int> pathCs;
+    CRef propagateLits(vec<Lit>& lits);
+    uint64_t previousStarts;
+    double var_iLevel_inc;
+    vec<Lit> involved_lits;
+    double    my_var_decay;
+    bool   DISTANCE;
+};
+
+
+//=================================================================================================
+// Implementation of inline methods:
+
+inline CRef Solver::reason(Var x) const { return vardata[x].reason; }
+inline int  Solver::level (Var x) const { return vardata[x].level; }
+
+inline void Solver::insertVarOrder(Var x) {
+    //    Heap<VarOrderLt>& order_heap = VSIDS ? order_heap_VSIDS : order_heap_CHB;
+    Heap<VarOrderLt>& order_heap = DISTANCE ? order_heap_distance : ((!VSIDS)? order_heap_CHB:order_heap_VSIDS);
+    if (!order_heap.inHeap(x) && decision[x]) order_heap.insert(x); }
+
+inline void Solver::varDecayActivity() {
+    var_inc *= (1 / var_decay); }
+
+inline void Solver::varBumpActivity(Var v, double mult) {
+    if ( (activity_VSIDS[v] += var_inc * mult) > 1e100 ) {
+        // Rescale:
+        for (int i = 0; i < nVars(); i++)
+            activity_VSIDS[i] *= 1e-100;
+        var_inc *= 1e-100; }
+
+    // Update order_heap with respect to new activity:
+    if (order_heap_VSIDS.inHeap(v)) order_heap_VSIDS.decrease(v); }
+
+inline void Solver::claDecayActivity() { cla_inc *= (1 / clause_decay); }
+inline void Solver::claBumpActivity (Clause& c) {
+    if ( (c.activity() += cla_inc) > 1e20 ) {
+        // Rescale:
+        for (int i = 0; i < learnts_local.size(); i++)
+            ca[learnts_local[i]].activity() *= 1e-20;
+        cla_inc *= 1e-20; } }
+
+inline void Solver::checkGarbage(void){ return checkGarbage(garbage_frac); }
+inline void Solver::checkGarbage(double gf){
+    if (ca.wasted() > ca.size() * gf)
+        garbageCollect(); }
+
+// NOTE: enqueue does not set the ok flag! (only public methods do)
+inline bool     Solver::enqueue         (Lit p, CRef from)      { return value(p) != l_Undef ? value(p) != l_False : (uncheckedEnqueue(p, decisionLevel(), from), true); }
+inline bool     Solver::addClause       (const vec<Lit>& ps)    { ps.copyTo(add_tmp); return addClause_(add_tmp); }
+inline bool     Solver::addEmptyClause  ()                      { add_tmp.clear(); return addClause_(add_tmp); }
+inline bool     Solver::addClause       (Lit p)                 { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); }
+inline bool     Solver::addClause       (Lit p, Lit q)          { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); }
+inline bool     Solver::addClause       (Lit p, Lit q, Lit r)   { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); }
+inline bool     Solver::locked          (const Clause& c) const {
+    int i = c.size() != 2 ? 0 : (value(c[0]) == l_True ? 0 : 1);
+    return value(c[i]) == l_True && reason(var(c[i])) != CRef_Undef && ca.lea(reason(var(c[i]))) == &c;
+}
+inline void     Solver::newDecisionLevel()                      { trail_lim.push(trail.size()); }
+
+inline int      Solver::decisionLevel ()      const   { return trail_lim.size(); }
+inline uint32_t Solver::abstractLevel (Var x) const   { return 1 << (level(x) & 31); }
+inline lbool    Solver::value         (Var x) const   { return assigns[x]; }
+inline lbool    Solver::value         (Lit p) const   { return assigns[var(p)] ^ sign(p); }
+inline lbool    Solver::modelValue    (Var x) const   { return model[x]; }
+inline lbool    Solver::modelValue    (Lit p) const   { return model[var(p)] ^ sign(p); }
+inline int      Solver::nAssigns      ()      const   { return trail.size(); }
+inline int      Solver::nClauses      ()      const   { return clauses.size(); }
+inline int      Solver::nLearnts      ()      const   { return learnts_core.size() + learnts_tier2.size() + learnts_local.size(); }
+inline int      Solver::nVars         ()      const   { return vardata.size(); }
+inline int      Solver::nFreeVars     ()      const   { return (int)dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]); }
+inline void     Solver::setPolarity   (Var v, bool b) { polarity[v] = b; }
+inline void     Solver::setDecisionVar(Var v, bool b) 
+{ 
+    if      ( b && !decision[v]) dec_vars++;
+    else if (!b &&  decision[v]) dec_vars--;
+
+    decision[v] = b;
+    if (b && !order_heap_CHB.inHeap(v)){
+        order_heap_CHB.insert(v);
+        order_heap_VSIDS.insert(v);
+        order_heap_distance.insert(v);}
+}
+inline void     Solver::setConfBudget(int64_t x){ conflict_budget    = conflicts    + x; }
+inline void     Solver::setPropBudget(int64_t x){ propagation_budget = propagations + x; }
+inline void     Solver::interrupt(){ asynch_interrupt = true; }
+inline void     Solver::clearInterrupt(){ asynch_interrupt = false; }
+inline void     Solver::budgetOff(){ conflict_budget = propagation_budget = -1; }
+inline bool     Solver::withinBudget() const {
+    return !asynch_interrupt &&
+            (conflict_budget    < 0 || conflicts < (uint64_t)conflict_budget) &&
+            (propagation_budget < 0 || propagations < (uint64_t)propagation_budget); }
+
+// FIXME: after the introduction of asynchronous interrruptions the solve-versions that return a
+// pure bool do not give a safe interface. Either interrupts must be possible to turn off here, or
+// all calls to solve must return an 'lbool'. I'm not yet sure which I prefer.
+inline bool     Solver::solve         ()                    { budgetOff(); assumptions.clear(); return solve_() == l_True; }
+inline bool     Solver::solve         (Lit p)               { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_() == l_True; }
+inline bool     Solver::solve         (Lit p, Lit q)        { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_() == l_True; }
+inline bool     Solver::solve         (Lit p, Lit q, Lit r) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_() == l_True; }
+inline bool     Solver::solve         (const vec<Lit>& assumps){ budgetOff(); assumps.copyTo(assumptions); return solve_() == l_True; }
+inline lbool    Solver::solveLimited  (const vec<Lit>& assumps){ assumps.copyTo(assumptions); return solve_(); }
+inline bool     Solver::okay          ()      const   { return ok; }
+
+inline void     Solver::toDimacs     (const char* file){ vec<Lit> as; toDimacs(file, as); }
+inline void     Solver::toDimacs     (const char* file, Lit p){ vec<Lit> as; as.push(p); toDimacs(file, as); }
+inline void     Solver::toDimacs     (const char* file, Lit p, Lit q){ vec<Lit> as; as.push(p); as.push(q); toDimacs(file, as); }
+inline void     Solver::toDimacs     (const char* file, Lit p, Lit q, Lit r){ vec<Lit> as; as.push(p); as.push(q); as.push(r); toDimacs(file, as); }
+
+//=================================================================================================
+// Debug etc:
+
+
+//=================================================================================================
+}
+
+#endif
+/***************************************************************************************[Solver.cc]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+           Copyright (c) 2007-2010, Niklas Sorensson
+ 
+Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
+ 
+Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach
+Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear.
+
+Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#include <math.h>
+#include <algorithm>
+#include <csignal>
+// #include <unistd.h>
+
+
+
+
+namespace Maple {
+
+//#define PRINT_OUT
+
+//=================================================================================================
+// Options:
+
+
+static const char* _cat = "CORE";
+
+static DoubleOption  opt_step_size         (_cat, "step-size",   "Initial step size",                             0.40,     DoubleRange(0, false, 1, false));
+static DoubleOption  opt_step_size_dec     (_cat, "step-size-dec","Step size decrement",                          0.000001, DoubleRange(0, false, 1, false));
+static DoubleOption  opt_min_step_size     (_cat, "min-step-size","Minimal step size",                            0.06,     DoubleRange(0, false, 1, false));
+static DoubleOption  opt_var_decay         (_cat, "var-decay",   "The variable activity decay factor",            0.80,     DoubleRange(0, false, 1, false));
+static DoubleOption  opt_clause_decay      (_cat, "cla-decay",   "The clause activity decay factor",              0.999,    DoubleRange(0, false, 1, false));
+static DoubleOption  opt_random_var_freq   (_cat, "rnd-freq",    "The frequency with which the decision heuristic tries to choose a random variable", 0, DoubleRange(0, true, 1, true));
+static DoubleOption  opt_random_seed       (_cat, "rnd-seed",    "Used by the random variable selection",         91648253, DoubleRange(0, false, HUGE_VAL, false));
+static IntOption     opt_ccmin_mode        (_cat, "ccmin-mode",  "Controls conflict clause minimization (0=none, 1=basic, 2=deep)", 2, IntRange(0, 2));
+static IntOption     opt_phase_saving      (_cat, "phase-saving", "Controls the level of phase saving (0=none, 1=limited, 2=full)", 2, IntRange(0, 2));
+static BoolOption    opt_rnd_init_act      (_cat, "rnd-init",    "Randomize the initial activity", false);
+static IntOption     opt_restart_first     (_cat, "rfirst",      "The base restart interval", 100, IntRange(1, INT32_MAX));
+static DoubleOption  opt_restart_inc       (_cat, "rinc",        "Restart interval increase factor", 2, DoubleRange(1, false, HUGE_VAL, false));
+static DoubleOption  opt_garbage_frac      (_cat, "gc-frac",     "The fraction of wasted memory allowed before a garbage collection is triggered",  0.20, DoubleRange(0, false, HUGE_VAL, false));
+static IntOption     opt_chrono            (_cat, "chrono",  "Controls if to perform chrono backtrack", 100, IntRange(-1, INT32_MAX));
+static IntOption     opt_conf_to_chrono    (_cat, "confl-to-chrono",  "Controls number of conflicts to perform chrono backtrack", 4000, IntRange(-1, INT32_MAX));
+
+
+//=================================================================================================
+// Constructor/Destructor:
+
+
+inline Solver::Solver() :
+
+    // Parameters (user settable):
+    //
+    drup_file        (NULL)
+  , verbosity        (0)
+  , step_size        (opt_step_size)
+  , step_size_dec    (opt_step_size_dec)
+  , min_step_size    (opt_min_step_size)
+  , timer            (5000)
+  , var_decay        (opt_var_decay)
+  , clause_decay     (opt_clause_decay)
+  , random_var_freq  (opt_random_var_freq)
+  , random_seed      (opt_random_seed)
+  , VSIDS            (false)
+  , ccmin_mode       (opt_ccmin_mode)
+  , phase_saving     (opt_phase_saving)
+  , rnd_pol          (false)
+  , rnd_init_act     (opt_rnd_init_act)
+  , garbage_frac     (opt_garbage_frac)
+  , restart_first    (opt_restart_first)
+  , restart_inc      (opt_restart_inc)
+
+  // Parameters (the rest):
+  //
+  , learntsize_factor((double)1/(double)3), learntsize_inc(1.1)
+
+  // Parameters (experimental):
+  //
+  , learntsize_adjust_start_confl (100)
+  , learntsize_adjust_inc         (1.5)
+
+  // Statistics: (formerly in 'SolverStats')
+  //
+  , solves(0), starts(0), decisions(0), rnd_decisions(0), propagations(0), conflicts(0), conflicts_VSIDS(0)
+  , dec_vars(0), clauses_literals(0), learnts_literals(0), max_literals(0), tot_literals(0)
+  , chrono_backtrack(0), non_chrono_backtrack(0)
+
+  , ok                 (true)
+  , cla_inc            (1)
+  , var_inc            (1)
+  , watches_bin        (WatcherDeleted(ca))
+  , watches            (WatcherDeleted(ca))
+  , qhead              (0)
+  , simpDB_assigns     (-1)
+  , simpDB_props       (0)
+  , order_heap_CHB     (VarOrderLt(activity_CHB))
+  , order_heap_VSIDS   (VarOrderLt(activity_VSIDS))
+  , progress_estimate  (0)
+  , remove_satisfied   (true)
+
+  , core_lbd_cut       (3)
+  , global_lbd_sum     (0)
+  , lbd_queue          (50)
+  , next_T2_reduce     (10000)
+  , next_L_reduce      (15000)
+  , confl_to_chrono    (opt_conf_to_chrono)
+  , chrono			   (opt_chrono)
+  
+  , counter            (0)
+
+  // Resource constraints:
+  //
+  , conflict_budget    (-1)
+  , propagation_budget (-1)
+  , asynch_interrupt   (false)
+
+  // simplfiy
+  , nbSimplifyAll(0)
+  , s_propagations(0)
+
+  // simplifyAll adjust occasion
+  , curSimplify(1)
+  , nbconfbeforesimplify(1000)
+  , incSimplify(1000)
+
+  , my_var_decay       (0.6)
+  , DISTANCE           (true)
+  , var_iLevel_inc     (1)
+  , order_heap_distance(VarOrderLt(activity_distance))
+
+{}
+
+
+inline Solver::~Solver()
+{
+}
+
+
+// simplify All
+//
+inline CRef Solver::simplePropagate()
+{
+    CRef    confl = CRef_Undef;
+    int     num_props = 0;
+    watches.cleanAll();
+    watches_bin.cleanAll();
+    while (qhead < trail.size())
+    {
+        Lit            p = trail[qhead++];     // 'p' is enqueued fact to propagate.
+        vec<Watcher>&  ws = watches[p];
+        Watcher        *i, *j, *end;
+        num_props++;
+
+
+        // First, Propagate binary clauses
+        vec<Watcher>&  wbin = watches_bin[p];
+
+        for (int k = 0; k<wbin.size(); k++)
+        {
+
+            Lit imp = wbin[k].blocker;
+
+            if (value(imp) == l_False)
+            {
+                return wbin[k].cref;
+            }
+
+            if (value(imp) == l_Undef)
+            {
+                simpleUncheckEnqueue(imp, wbin[k].cref);
+            }
+        }
+        for (i = j = (Watcher*)ws, end = i + ws.size(); i != end;)
+        {
+            // Try to avoid inspecting the clause:
+            Lit blocker = i->blocker;
+            if (value(blocker) == l_True)
+            {
+                *j++ = *i++; continue;
+            }
+
+            // Make sure the false literal is data[1]:
+            CRef     cr = i->cref;
+            Clause&  c = ca[cr];
+            Lit      false_lit = ~p;
+            if (c[0] == false_lit)
+                c[0] = c[1], c[1] = false_lit;
+            assert(c[1] == false_lit);
+            //  i++;
+
+            // If 0th watch is true, then clause is already satisfied.
+            // However, 0th watch is not the blocker, make it blocker using a new watcher w
+            // why not simply do i->blocker=first in this case?
+            Lit     first = c[0];
+            //  Watcher w     = Watcher(cr, first);
+            if (first != blocker && value(first) == l_True)
+            {
+                i->blocker = first;
+                *j++ = *i++; continue;
+            }
+
+            // Look for new watch:
+            //if (incremental)
+            //{ // ----------------- INCREMENTAL MODE
+            //	int choosenPos = -1;
+            //	for (int k = 2; k < c.size(); k++)
+            //	{
+            //		if (value(c[k]) != l_False)
+            //		{
+            //			if (decisionLevel()>assumptions.size())
+            //			{
+            //				choosenPos = k;
+            //				break;
+            //			}
+            //			else
+            //			{
+            //				choosenPos = k;
+
+            //				if (value(c[k]) == l_True || !isSelector(var(c[k]))) {
+            //					break;
+            //				}
+            //			}
+
+            //		}
+            //	}
+            //	if (choosenPos != -1)
+            //	{
+            //		// watcher i is abandonned using i++, because cr watches now ~c[k] instead of p
+            //		// the blocker is first in the watcher. However,
+            //		// the blocker in the corresponding watcher in ~first is not c[1]
+            //		Watcher w = Watcher(cr, first); i++;
+            //		c[1] = c[choosenPos]; c[choosenPos] = false_lit;
+            //		watches[~c[1]].push(w);
+            //		goto NextClause;
+            //	}
+            //}
+            else
+            {  // ----------------- DEFAULT  MODE (NOT INCREMENTAL)
+                for (int k = 2; k < c.size(); k++)
+                {
+
+                    if (value(c[k]) != l_False)
+                    {
+                        // watcher i is abandonned using i++, because cr watches now ~c[k] instead of p
+                        // the blocker is first in the watcher. However,
+                        // the blocker in the corresponding watcher in ~first is not c[1]
+                        Watcher w = Watcher(cr, first); i++;
+                        c[1] = c[k]; c[k] = false_lit;
+                        watches[~c[1]].push(w);
+                        goto NextClause;
+                    }
+                }
+            }
+
+            // Did not find watch -- clause is unit under assignment:
+            i->blocker = first;
+            *j++ = *i++;
+            if (value(first) == l_False)
+            {
+                confl = cr;
+                qhead = trail.size();
+                // Copy the remaining watches:
+                while (i < end)
+                    *j++ = *i++;
+            }
+            else
+            {
+                simpleUncheckEnqueue(first, cr);
+            }
+NextClause:;
+        }
+        ws.shrink(i - j);
+    }
+
+    s_propagations += num_props;
+
+    return confl;
+}
+
+inline void Solver::simpleUncheckEnqueue(Lit p, CRef from){
+    assert(value(p) == l_Undef);
+    assigns[var(p)] = lbool(!sign(p)); // this makes a lbool object whose value is sign(p)
+    vardata[var(p)].reason = from;
+    trail.push_(p);
+}
+
+inline void Solver::cancelUntilTrailRecord()
+{
+    for (int c = trail.size() - 1; c >= trailRecord; c--)
+    {
+        Var x = var(trail[c]);
+        assigns[x] = l_Undef;
+
+    }
+    qhead = trailRecord;
+    trail.shrink(trail.size() - trailRecord);
+
+}
+
+inline void Solver::litsEnqueue(int cutP, Clause& c)
+{
+    for (int i = cutP; i < c.size(); i++)
+    {
+        simpleUncheckEnqueue(~c[i]);
+    }
+}
+
+inline bool Solver::removed(CRef cr) {
+    return ca[cr].mark() == 1;
+}
+
+inline void Solver::simpleAnalyze(CRef confl, vec<Lit>& out_learnt, vec<CRef>& reason_clause, bool True_confl)
+{
+    int pathC = 0;
+    Lit p = lit_Undef;
+    int index = trail.size() - 1;
+
+    do{
+        if (confl != CRef_Undef){
+            reason_clause.push(confl);
+            Clause& c = ca[confl];
+            // Special case for binary clauses
+            // The first one has to be SAT
+            if (p != lit_Undef && c.size() == 2 && value(c[0]) == l_False) {
+
+                assert(value(c[1]) == l_True);
+                Lit tmp = c[0];
+                c[0] = c[1], c[1] = tmp;
+            }
+            // if True_confl==true, then choose p begin with the 1th index of c;
+            for (int j = (p == lit_Undef && True_confl == false) ? 0 : 1; j < c.size(); j++){
+                Lit q = c[j];
+                if (!seen[var(q)]){
+                    seen[var(q)] = 1;
+                    pathC++;
+                }
+            }
+        }
+        else if (confl == CRef_Undef){
+            out_learnt.push(~p);
+        }
+        // if not break, while() will come to the index of trail blow 0, and fatal error occur;
+        if (pathC == 0) break;
+        // Select next clause to look at:
+        while (!seen[var(trail[index--])]);
+        // if the reason cr from the 0-level assigned var, we must break avoid move forth further;
+        // but attention that maybe seen[x]=1 and never be clear. However makes no matter;
+        if (trailRecord > index + 1) break;
+        p = trail[index + 1];
+        confl = reason(var(p));
+        seen[var(p)] = 0;
+        pathC--;
+
+    } while (pathC >= 0);
+}
+
+inline void Solver::simplifyLearnt(Clause& c)
+{
+    ////
+    original_length_record += c.size();
+
+    trailRecord = trail.size();// record the start pointer
+
+    vec<Lit> falseLit;
+    falseLit.clear();
+
+    //sort(&c[0], c.size(), VarOrderLevelLt(vardata));
+
+    bool True_confl = false;
+    int beforeSize, afterSize;
+    beforeSize = c.size();
+    int i, j;
+    CRef confl;
+
+    for (i = 0, j = 0; i < c.size(); i++){
+        if (value(c[i]) == l_Undef){
+            //printf("///@@@ uncheckedEnqueue:index = %d. l_Undef\n", i);
+            simpleUncheckEnqueue(~c[i]);
+            c[j++] = c[i];
+            confl = simplePropagate();
+            if (confl != CRef_Undef){
+                break;
+            }
+        }
+        else{
+            if (value(c[i]) == l_True){
+                //printf("///@@@ uncheckedEnqueue:index = %d. l_True\n", i);
+                c[j++] = c[i];
+                True_confl = true;
+                confl = reason(var(c[i]));
+                break;
+            }
+            else{
+                //printf("///@@@ uncheckedEnqueue:index = %d. l_False\n", i);
+                falseLit.push(c[i]);
+            }
+        }
+    }
+    c.shrink(c.size() - j);
+    afterSize = c.size();
+    //printf("\nbefore : %d, after : %d ", beforeSize, afterSize);
+
+
+    if (confl != CRef_Undef || True_confl == true){
+        simp_learnt_clause.clear();
+        simp_reason_clause.clear();
+        if (True_confl == true){
+            simp_learnt_clause.push(c.last());
+        }
+        simpleAnalyze(confl, simp_learnt_clause, simp_reason_clause, True_confl);
+
+        if (simp_learnt_clause.size() < c.size()){
+            for (i = 0; i < simp_learnt_clause.size(); i++){
+                c[i] = simp_learnt_clause[i];
+            }
+            c.shrink(c.size() - i);
+        }
+    }
+
+    cancelUntilTrailRecord();
+
+    ////
+    simplified_length_record += c.size();
+
+}
+
+inline bool Solver::simplifyLearnt_x(vec<CRef>& learnts_x)
+{
+    int beforeSize, afterSize;
+    int learnts_x_size_before = learnts_x.size();
+
+    int ci, cj, li, lj;
+    bool sat, false_lit;
+    unsigned int nblevels;
+    ////
+    //printf("learnts_x size : %d\n", learnts_x.size());
+
+    ////
+    int nbSimplified = 0;
+    int nbSimplifing = 0;
+
+    for (ci = 0, cj = 0; ci < learnts_x.size(); ci++){
+        CRef cr = learnts_x[ci];
+        Clause& c = ca[cr];
+
+        if (removed(cr)) continue;
+        else if (c.simplified()){
+            learnts_x[cj++] = learnts_x[ci];
+            ////
+            nbSimplified++;
+        }
+        else{
+            ////
+            nbSimplifing++;
+            sat = false_lit = false;
+            for (int i = 0; i < c.size(); i++){
+                if (value(c[i]) == l_True){
+                    sat = true;
+                    break;
+                }
+                else if (value(c[i]) == l_False){
+                    false_lit = true;
+                }
+            }
+            if (sat){
+                removeClause(cr);
+            }
+            else{
+                detachClause(cr, true);
+
+                if (false_lit){
+                    for (li = lj = 0; li < c.size(); li++){
+                        if (value(c[li]) != l_False){
+                            c[lj++] = c[li];
+                        }
+                    }
+                    c.shrink(li - lj);
+                }
+
+                beforeSize = c.size();
+                assert(c.size() > 1);
+                // simplify a learnt clause c
+                simplifyLearnt(c);
+                assert(c.size() > 0);
+                afterSize = c.size();
+
+                //printf("beforeSize: %2d, afterSize: %2d\n", beforeSize, afterSize);
+
+                if (c.size() == 1){
+                    // when unit clause occur, enqueue and propagate
+                    uncheckedEnqueue(c[0]);
+                    if (propagate() != CRef_Undef){
+                        ok = false;
+                        return false;
+                    }
+                    // delete the clause memory in logic
+                    c.mark(1);
+                    ca.free(cr);
+                }
+                else{
+                    attachClause(cr);
+                    learnts_x[cj++] = learnts_x[ci];
+
+                    nblevels = computeLBD(c);
+                    if (nblevels < c.lbd()){
+                        //printf("lbd-before: %d, lbd-after: %d\n", c.lbd(), nblevels);
+                        c.set_lbd(nblevels);
+                    }
+                    if (c.mark() != CORE){
+                        if (c.lbd() <= core_lbd_cut){
+                            //if (c.mark() == LOCAL) local_learnts_dirty = true;
+                            //else tier2_learnts_dirty = true;
+                            cj--;
+                            learnts_core.push(cr);
+                            c.mark(CORE);
+                        }
+                        else if (c.mark() == LOCAL && c.lbd() <= 6){
+                            //local_learnts_dirty = true;
+                            cj--;
+                            learnts_tier2.push(cr);
+                            c.mark(TIER2);
+                        }
+                    }
+
+                    c.setSimplified(true);
+                }
+            }
+        }
+    }
+    learnts_x.shrink(ci - cj);
+
+    //   printf("c nbLearnts_x %d / %d, nbSimplified: %d, nbSimplifing: %d\n",
+    //          learnts_x_size_before, learnts_x.size(), nbSimplified, nbSimplifing);
+
+    return true;
+}
+
+inline bool Solver::simplifyLearnt_core()
+{
+    int beforeSize, afterSize;
+    int learnts_core_size_before = learnts_core.size();
+
+    int ci, cj, li, lj;
+    bool sat, false_lit;
+    unsigned int nblevels;
+    ////
+    //printf("learnts_x size : %d\n", learnts_x.size());
+
+    ////
+    int nbSimplified = 0;
+    int nbSimplifing = 0;
+
+    for (ci = 0, cj = 0; ci < learnts_core.size(); ci++){
+        CRef cr = learnts_core[ci];
+        Clause& c = ca[cr];
+
+        if (removed(cr)) continue;
+        else if (c.simplified()){
+            learnts_core[cj++] = learnts_core[ci];
+            ////
+            nbSimplified++;
+        }
+        else{
+            int saved_size=c.size();
+            //         if (drup_file){
+            //                 add_oc.clear();
+            //                 for (int i = 0; i < c.size(); i++) add_oc.push(c[i]); }
+            ////
+            nbSimplifing++;
+            sat = false_lit = false;
+            for (int i = 0; i < c.size(); i++){
+                if (value(c[i]) == l_True){
+                    sat = true;
+                    break;
+                }
+                else if (value(c[i]) == l_False){
+                    false_lit = true;
+                }
+            }
+            if (sat){
+                removeClause(cr);
+            }
+            else{
+                detachClause(cr, true);
+
+                if (false_lit){
+                    for (li = lj = 0; li < c.size(); li++){
+                        if (value(c[li]) != l_False){
+                            c[lj++] = c[li];
+                        }
+                    }
+                    c.shrink(li - lj);
+                }
+
+                beforeSize = c.size();
+                assert(c.size() > 1);
+                // simplify a learnt clause c
+                simplifyLearnt(c);
+                assert(c.size() > 0);
+                afterSize = c.size();
+                
+                if(drup_file && saved_size !=c.size()){
+#ifdef BIN_DRUP
+                    binDRUP('a', c , drup_file);
+                    //                    binDRUP('d', add_oc, drup_file);
+#else
+                    for (int i = 0; i < c.size(); i++)
+                        fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+                    fprintf(drup_file, "0\n");
+
+                    //                    fprintf(drup_file, "d ");
+                    //                    for (int i = 0; i < add_oc.size(); i++)
+                    //                        fprintf(drup_file, "%i ", (var(add_oc[i]) + 1) * (-2 * sign(add_oc[i]) + 1));
+                    //                    fprintf(drup_file, "0\n");
+#endif
+                }
+
+                //printf("beforeSize: %2d, afterSize: %2d\n", beforeSize, afterSize);
+
+                if (c.size() == 1){
+                    // when unit clause occur, enqueue and propagate
+                    uncheckedEnqueue(c[0]);
+                    if (propagate() != CRef_Undef){
+                        ok = false;
+                        return false;
+                    }
+                    // delete the clause memory in logic
+                    c.mark(1);
+                    ca.free(cr);
+//#ifdef BIN_DRUP
+//                    binDRUP('d', c, drup_file);
+//#else
+//                    fprintf(drup_file, "d ");
+//                    for (int i = 0; i < c.size(); i++)
+//                        fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+//                    fprintf(drup_file, "0\n");
+//#endif
+                }
+                else{
+                    attachClause(cr);
+                    learnts_core[cj++] = learnts_core[ci];
+
+                    nblevels = computeLBD(c);
+                    if (nblevels < c.lbd()){
+                        //printf("lbd-before: %d, lbd-after: %d\n", c.lbd(), nblevels);
+                        c.set_lbd(nblevels);
+                    }
+
+                    c.setSimplified(true);
+                }
+            }
+        }
+    }
+    learnts_core.shrink(ci - cj);
+
+    //    printf("c nbLearnts_core %d / %d, nbSimplified: %d, nbSimplifing: %d\n",
+    //           learnts_core_size_before, learnts_core.size(), nbSimplified, nbSimplifing);
+
+    return true;
+
+}
+
+inline bool Solver::simplifyLearnt_tier2()
+{
+    int beforeSize, afterSize;
+    int learnts_tier2_size_before = learnts_tier2.size();
+
+    int ci, cj, li, lj;
+    bool sat, false_lit;
+    unsigned int nblevels;
+    ////
+    //printf("learnts_x size : %d\n", learnts_x.size());
+
+    ////
+    int nbSimplified = 0;
+    int nbSimplifing = 0;
+
+    for (ci = 0, cj = 0; ci < learnts_tier2.size(); ci++){
+        CRef cr = learnts_tier2[ci];
+        Clause& c = ca[cr];
+
+        if (removed(cr)) continue;
+        else if (c.simplified()){
+            learnts_tier2[cj++] = learnts_tier2[ci];
+            ////
+            nbSimplified++;
+        }
+        else{
+            int saved_size=c.size();
+            //            if (drup_file){
+            //                    add_oc.clear();
+            //                    for (int i = 0; i < c.size(); i++) add_oc.push(c[i]); }
+            ////
+            nbSimplifing++;
+            sat = false_lit = false;
+            for (int i = 0; i < c.size(); i++){
+                if (value(c[i]) == l_True){
+                    sat = true;
+                    break;
+                }
+                else if (value(c[i]) == l_False){
+                    false_lit = true;
+                }
+            }
+            if (sat){
+                removeClause(cr);
+            }
+            else{
+                detachClause(cr, true);
+
+                if (false_lit){
+                    for (li = lj = 0; li < c.size(); li++){
+                        if (value(c[li]) != l_False){
+                            c[lj++] = c[li];
+                        }
+                    }
+                    c.shrink(li - lj);
+                }
+
+                beforeSize = c.size();
+                assert(c.size() > 1);
+                // simplify a learnt clause c
+                simplifyLearnt(c);
+                assert(c.size() > 0);
+                afterSize = c.size();
+                
+                if(drup_file && saved_size!=c.size()){
+
+#ifdef BIN_DRUP
+                    binDRUP('a', c , drup_file);
+                    //                    binDRUP('d', add_oc, drup_file);
+#else
+                    for (int i = 0; i < c.size(); i++)
+                        fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+                    fprintf(drup_file, "0\n");
+
+                    //                    fprintf(drup_file, "d ");
+                    //                    for (int i = 0; i < add_oc.size(); i++)
+                    //                        fprintf(drup_file, "%i ", (var(add_oc[i]) + 1) * (-2 * sign(add_oc[i]) + 1));
+                    //                    fprintf(drup_file, "0\n");
+#endif
+                }
+
+                //printf("beforeSize: %2d, afterSize: %2d\n", beforeSize, afterSize);
+
+                if (c.size() == 1){
+                    // when unit clause occur, enqueue and propagate
+                    uncheckedEnqueue(c[0]);
+                    if (propagate() != CRef_Undef){
+                        ok = false;
+                        return false;
+                    }
+                    // delete the clause memory in logic
+                    c.mark(1);
+                    ca.free(cr);
+//#ifdef BIN_DRUP
+//                    binDRUP('d', c, drup_file);
+//#else
+//                    fprintf(drup_file, "d ");
+//                    for (int i = 0; i < c.size(); i++)
+//                        fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+//                    fprintf(drup_file, "0\n");
+//#endif
+                }
+                else{
+                    attachClause(cr);
+                    learnts_tier2[cj++] = learnts_tier2[ci];
+
+                    nblevels = computeLBD(c);
+                    if (nblevels < c.lbd()){
+                        //printf("lbd-before: %d, lbd-after: %d\n", c.lbd(), nblevels);
+                        c.set_lbd(nblevels);
+                    }
+
+                    if (c.lbd() <= core_lbd_cut){
+                        cj--;
+                        learnts_core.push(cr);
+                        c.mark(CORE);
+                    }
+
+                    c.setSimplified(true);
+                }
+            }
+        }
+    }
+    learnts_tier2.shrink(ci - cj);
+
+    //    printf("c nbLearnts_tier2 %d / %d, nbSimplified: %d, nbSimplifing: %d\n",
+    //           learnts_tier2_size_before, learnts_tier2.size(), nbSimplified, nbSimplifing);
+
+    return true;
+
+}
+
+inline bool Solver::simplifyAll()
+{
+    ////
+    simplified_length_record = original_length_record = 0;
+
+    if (!ok || propagate() != CRef_Undef)
+        return ok = false;
+
+    //// cleanLearnts(also can delete these code), here just for analyzing
+    //if (local_learnts_dirty) cleanLearnts(learnts_local, LOCAL);
+    //if (tier2_learnts_dirty) cleanLearnts(learnts_tier2, TIER2);
+    //local_learnts_dirty = tier2_learnts_dirty = false;
+
+    if (!simplifyLearnt_core()) return ok = false;
+    if (!simplifyLearnt_tier2()) return ok = false;
+    //if (!simplifyLearnt_x(learnts_local)) return ok = false;
+
+    checkGarbage();
+
+    ////
+    //  printf("c size_reduce_ratio     : %4.2f%%\n",
+    //         original_length_record == 0 ? 0 : (original_length_record - simplified_length_record) * 100 / (double)original_length_record);
+
+    return true;
+}
+//=================================================================================================
+// Minor methods:
+
+
+// Creates a new SAT variable in the solver. If 'decision' is cleared, variable will not be
+// used as a decision variable (NOTE! This has effects on the meaning of a SATISFIABLE result).
+//
+inline Var Solver::newVar(bool sign, bool dvar)
+{
+    int v = nVars();
+    watches_bin.init(mkLit(v, false));
+    watches_bin.init(mkLit(v, true ));
+    watches  .init(mkLit(v, false));
+    watches  .init(mkLit(v, true ));
+    assigns  .push(l_Undef);
+    vardata  .push(mkVarData(CRef_Undef, 0));
+    activity_CHB  .push(0);
+    activity_VSIDS.push(rnd_init_act ? drand(random_seed) * 0.00001 : 0);
+
+    picked.push(0);
+    conflicted.push(0);
+    almost_conflicted.push(0);
+#ifdef ANTI_EXPLORATION
+    canceled.push(0);
+#endif
+
+    seen     .push(0);
+    seen2    .push(0);
+    polarity .push(sign);
+    decision .push();
+    trail    .capacity(v+1);
+    setDecisionVar(v, dvar);
+
+    activity_distance.push(0);
+    var_iLevel.push(0);
+    var_iLevel_tmp.push(0);
+    pathCs.push(0);
+    return v;
+}
+
+
+inline bool Solver::addClause_(vec<Lit>& ps)
+{
+    assert(decisionLevel() == 0);
+    if (!ok) return false;
+
+    // Check if clause is satisfied and remove false/duplicate literals:
+    sort(ps);
+    Lit p; int i, j;
+
+    if (drup_file){
+        add_oc.clear();
+        for (int i = 0; i < ps.size(); i++) add_oc.push(ps[i]); }
+
+    for (i = j = 0, p = lit_Undef; i < ps.size(); i++)
+        if (value(ps[i]) == l_True || ps[i] == ~p)
+            return true;
+        else if (value(ps[i]) != l_False && ps[i] != p)
+            ps[j++] = p = ps[i];
+    ps.shrink(i - j);
+
+    if (drup_file && i != j){
+#ifdef BIN_DRUP
+        binDRUP('a', ps, drup_file);
+        binDRUP('d', add_oc, drup_file);
+#else
+        for (int i = 0; i < ps.size(); i++)
+            fprintf(drup_file, "%i ", (var(ps[i]) + 1) * (-2 * sign(ps[i]) + 1));
+        fprintf(drup_file, "0\n");
+
+        fprintf(drup_file, "d ");
+        for (int i = 0; i < add_oc.size(); i++)
+            fprintf(drup_file, "%i ", (var(add_oc[i]) + 1) * (-2 * sign(add_oc[i]) + 1));
+        fprintf(drup_file, "0\n");
+#endif
+    }
+
+    if (ps.size() == 0)
+        return ok = false;
+    else if (ps.size() == 1){
+        uncheckedEnqueue(ps[0]);
+        return ok = (propagate() == CRef_Undef);
+    }else{
+        CRef cr = ca.alloc(ps, false);
+        clauses.push(cr);
+        attachClause(cr);
+    }
+
+    return true;
+}
+
+
+inline void Solver::attachClause(CRef cr) {
+    const Clause& c = ca[cr];
+    assert(c.size() > 1);
+    OccLists<Lit, vec<Watcher>, WatcherDeleted>& ws = c.size() == 2 ? watches_bin : watches;
+    ws[~c[0]].push(Watcher(cr, c[1]));
+    ws[~c[1]].push(Watcher(cr, c[0]));
+    if (c.learnt()) learnts_literals += c.size();
+    else            clauses_literals += c.size(); }
+
+
+inline void Solver::detachClause(CRef cr, bool strict) {
+    const Clause& c = ca[cr];
+    assert(c.size() > 1);
+    OccLists<Lit, vec<Watcher>, WatcherDeleted>& ws = c.size() == 2 ? watches_bin : watches;
+    
+    if (strict){
+        remove(ws[~c[0]], Watcher(cr, c[1]));
+        remove(ws[~c[1]], Watcher(cr, c[0]));
+    }else{
+        // Lazy detaching: (NOTE! Must clean all watcher lists before garbage collecting this clause)
+        ws.smudge(~c[0]);
+        ws.smudge(~c[1]);
+    }
+
+    if (c.learnt()) learnts_literals -= c.size();
+    else            clauses_literals -= c.size(); }
+
+
+inline void Solver::removeClause(CRef cr) {
+    Clause& c = ca[cr];
+
+    if (drup_file){
+        if (c.mark() != 1){
+#ifdef BIN_DRUP
+            binDRUP('d', c, drup_file);
+#else
+            fprintf(drup_file, "d ");
+            for (int i = 0; i < c.size(); i++)
+                fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+            fprintf(drup_file, "0\n");
+#endif
+        }else
+            printf("c Bug. I don't expect this to happen.\n");
+    }
+
+    detachClause(cr);
+    // Don't leave pointers to free'd memory!
+    if (locked(c)){
+        Lit implied = c.size() != 2 ? c[0] : (value(c[0]) == l_True ? c[0] : c[1]);
+        vardata[var(implied)].reason = CRef_Undef; }
+    c.mark(1);
+    ca.free(cr);
+}
+
+
+inline bool Solver::satisfied(const Clause& c) const {
+    for (int i = 0; i < c.size(); i++)
+        if (value(c[i]) == l_True)
+            return true;
+    return false; }
+
+
+// Revert to the state at given level (keeping all assignment at 'level' but not beyond).
+//
+inline void Solver::cancelUntil(int bLevel) {
+	
+    if (decisionLevel() > bLevel){
+#ifdef PRINT_OUT
+		std::cout << "bt " << bLevel << "\n";
+#endif				
+		add_tmp.clear();
+        for (int c = trail.size()-1; c >= trail_lim[bLevel]; c--)
+        {
+            Var      x  = var(trail[c]);
+
+			if (level(x) <= bLevel)
+			{
+				add_tmp.push(trail[c]);
+			}
+			else
+			{
+				 if (!VSIDS){
+					uint32_t age = conflicts - picked[x];
+					if (age > 0){
+						double adjusted_reward = ((double) (conflicted[x] + almost_conflicted[x])) / ((double) age);
+						double old_activity = activity_CHB[x];
+						activity_CHB[x] = step_size * adjusted_reward + ((1 - step_size) * old_activity);
+						if (order_heap_CHB.inHeap(x)){
+							if (activity_CHB[x] > old_activity)
+								order_heap_CHB.decrease(x);
+							else
+								order_heap_CHB.increase(x);
+						}
+					}
+#ifdef ANTI_EXPLORATION
+					canceled[x] = conflicts;
+#endif
+				}
+				
+				assigns [x] = l_Undef;
+#ifdef PRINT_OUT
+				std::cout << "undo " << x << "\n";
+#endif				
+	            if (phase_saving > 1 || ((phase_saving == 1) && c > trail_lim.last()))
+					polarity[x] = sign(trail[c]);
+				insertVarOrder(x);
+			}
+        }
+        qhead = trail_lim[bLevel];
+        trail.shrink(trail.size() - trail_lim[bLevel]);
+        trail_lim.shrink(trail_lim.size() - bLevel);
+        for (int nLitId = add_tmp.size() - 1; nLitId >= 0; --nLitId)
+		{
+			trail.push_(add_tmp[nLitId]);
+		}
+		
+		add_tmp.clear();
+    } }
+
+
+//=================================================================================================
+// Major methods:
+
+
+inline Lit Solver::pickBranchLit()
+{
+    Var next = var_Undef;
+    //    Heap<VarOrderLt>& order_heap = VSIDS ? order_heap_VSIDS : order_heap_CHB;
+    Heap<VarOrderLt>& order_heap = DISTANCE ? order_heap_distance : ((!VSIDS)? order_heap_CHB:order_heap_VSIDS);
+
+    // Random decision:
+    /*if (drand(random_seed) < random_var_freq && !order_heap.empty()){
+        next = order_heap[irand(random_seed,order_heap.size())];
+        if (value(next) == l_Undef && decision[next])
+            rnd_decisions++; }*/
+
+    // Activity based decision:
+    while (next == var_Undef || value(next) != l_Undef || !decision[next])
+        if (order_heap.empty())
+            return lit_Undef;
+        else{
+#ifdef ANTI_EXPLORATION
+            if (!VSIDS){
+                Var v = order_heap_CHB[0];
+                uint32_t age = conflicts - canceled[v];
+                while (age > 0){
+                    double decay = pow(0.95, age);
+                    activity_CHB[v] *= decay;
+                    if (order_heap_CHB.inHeap(v))
+                        order_heap_CHB.increase(v);
+                    canceled[v] = conflicts;
+                    v = order_heap_CHB[0];
+                    age = conflicts - canceled[v];
+                }
+            }
+#endif
+            next = order_heap.removeMin();
+        }
+
+    return mkLit(next, polarity[next]);
+}
+
+inline Solver::ConflictData Solver::FindConflictLevel(CRef cind)
+{
+	ConflictData data;
+	Clause& conflCls = ca[cind];
+	data.nHighestLevel = level(var(conflCls[0]));
+	if (data.nHighestLevel == decisionLevel() && level(var(conflCls[1])) == decisionLevel())
+	{
+		return data;
+	}
+
+	int highestId = 0;
+    data.bOnlyOneLitFromHighest = true;
+	// find the largest decision level in the clause
+	for (int nLitId = 1; nLitId < conflCls.size(); ++nLitId)
+	{
+		int nLevel = level(var(conflCls[nLitId]));
+		if (nLevel > data.nHighestLevel)
+		{
+			highestId = nLitId;
+			data.nHighestLevel = nLevel;
+			data.bOnlyOneLitFromHighest = true;
+		}
+		else if (nLevel == data.nHighestLevel && data.bOnlyOneLitFromHighest == true)
+		{
+			data.bOnlyOneLitFromHighest = false;
+		}
+	}
+
+	if (highestId != 0)
+	{
+		std::swap(conflCls[0], conflCls[highestId]);
+		if (highestId > 1)
+		{
+			OccLists<Lit, vec<Watcher>, WatcherDeleted>& ws = conflCls.size() == 2 ? watches_bin : watches;
+			//ws.smudge(~conflCls[highestId]);
+			remove(ws[~conflCls[highestId]], Watcher(cind, conflCls[1]));
+			ws[~conflCls[0]].push(Watcher(cind, conflCls[1]));
+		}
+	}
+
+	return data;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  analyze : (confl : Clause*) (out_learnt : vec<Lit>&) (out_btlevel : int&)  ->  [void]
+|  
+|  Description:
+|    Analyze conflict and produce a reason clause.
+|  
+|    Pre-conditions:
+|      * 'out_learnt' is assumed to be cleared.
+|      * Current decision level must be greater than root level.
+|  
+|    Post-conditions:
+|      * 'out_learnt[0]' is the asserting literal at level 'out_btlevel'.
+|      * If out_learnt.size() > 1 then 'out_learnt[1]' has the greatest decision level of the 
+|        rest of literals. There may be others from the same level though.
+|  
+|________________________________________________________________________________________________@*/
+inline void Solver::analyze(CRef confl, vec<Lit>& out_learnt, int& out_btlevel, int& out_lbd)
+{
+    int pathC = 0;
+    Lit p     = lit_Undef;
+
+    // Generate conflict clause:
+    //
+    out_learnt.push();      // (leave room for the asserting literal)
+    int index   = trail.size() - 1;
+    int nDecisionLevel = level(var(ca[confl][0]));
+    assert(nDecisionLevel == level(var(ca[confl][0])));
+
+    do{
+        assert(confl != CRef_Undef); // (otherwise should be UIP)
+        Clause& c = ca[confl];
+
+        // For binary clauses, we don't rearrange literals in propagate(), so check and make sure the first is an implied lit.
+        if (p != lit_Undef && c.size() == 2 && value(c[0]) == l_False){
+            assert(value(c[1]) == l_True);
+            Lit tmp = c[0];
+            c[0] = c[1], c[1] = tmp; }
+
+        // Update LBD if improved.
+        if (c.learnt() && c.mark() != CORE){
+            int lbd = computeLBD(c);
+            if (lbd < c.lbd()){
+                if (c.lbd() <= 30) c.removable(false); // Protect once from reduction.
+                c.set_lbd(lbd);
+                if (lbd <= core_lbd_cut){
+                    learnts_core.push(confl);
+                    c.mark(CORE);
+                }else if (lbd <= 6 && c.mark() == LOCAL){
+                    // Bug: 'cr' may already be in 'learnts_tier2', e.g., if 'cr' was demoted from TIER2
+                    // to LOCAL previously and if that 'cr' is not cleaned from 'learnts_tier2' yet.
+                    learnts_tier2.push(confl);
+                    c.mark(TIER2); }
+            }
+
+            if (c.mark() == TIER2)
+                c.touched() = conflicts;
+            else if (c.mark() == LOCAL)
+                claBumpActivity(c);
+        }
+
+        for (int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++){
+            Lit q = c[j];
+
+            if (!seen[var(q)] && level(var(q)) > 0){
+                if (VSIDS){
+                    varBumpActivity(var(q), .5);
+                    add_tmp.push(q);
+                }else
+                    conflicted[var(q)]++;
+                seen[var(q)] = 1;
+                if (level(var(q)) >= nDecisionLevel){
+                    pathC++;
+                }else
+                    out_learnt.push(q);
+            }
+        }
+        
+        // Select next clause to look at:
+		do {
+			while (!seen[var(trail[index--])]);
+			p  = trail[index+1];
+		} while (level(var(p)) < nDecisionLevel);
+		
+        confl = reason(var(p));
+        seen[var(p)] = 0;
+        pathC--;
+
+    }while (pathC > 0);
+    out_learnt[0] = ~p;
+
+    // Simplify conflict clause:
+    //
+    int i, j;
+    out_learnt.copyTo(analyze_toclear);
+    if (ccmin_mode == 2){
+        uint32_t abstract_level = 0;
+        for (i = 1; i < out_learnt.size(); i++)
+            abstract_level |= abstractLevel(var(out_learnt[i])); // (maintain an abstraction of levels involved in conflict)
+
+        for (i = j = 1; i < out_learnt.size(); i++)
+            if (reason(var(out_learnt[i])) == CRef_Undef || !litRedundant(out_learnt[i], abstract_level))
+                out_learnt[j++] = out_learnt[i];
+        
+    }else if (ccmin_mode == 1){
+        for (i = j = 1; i < out_learnt.size(); i++){
+            Var x = var(out_learnt[i]);
+
+            if (reason(x) == CRef_Undef)
+                out_learnt[j++] = out_learnt[i];
+            else{
+                Clause& c = ca[reason(var(out_learnt[i]))];
+                for (int k = c.size() == 2 ? 0 : 1; k < c.size(); k++)
+                    if (!seen[var(c[k])] && level(var(c[k])) > 0){
+                        out_learnt[j++] = out_learnt[i];
+                        break; }
+            }
+        }
+    }else
+        i = j = out_learnt.size();
+
+    max_literals += out_learnt.size();
+    out_learnt.shrink(i - j);
+    tot_literals += out_learnt.size();
+
+    out_lbd = computeLBD(out_learnt);
+    if (out_lbd <= 6 && out_learnt.size() <= 30) // Try further minimization?
+        if (binResMinimize(out_learnt))
+            out_lbd = computeLBD(out_learnt); // Recompute LBD if minimized.
+
+    // Find correct backtrack level:
+    //
+    if (out_learnt.size() == 1)
+        out_btlevel = 0;
+    else{
+        int max_i = 1;
+        // Find the first literal assigned at the next-highest level:
+        for (int i = 2; i < out_learnt.size(); i++)
+            if (level(var(out_learnt[i])) > level(var(out_learnt[max_i])))
+                max_i = i;
+        // Swap-in this literal at index 1:
+        Lit p             = out_learnt[max_i];
+        out_learnt[max_i] = out_learnt[1];
+        out_learnt[1]     = p;
+        out_btlevel       = level(var(p));
+    }
+
+    if (VSIDS){
+        for (int i = 0; i < add_tmp.size(); i++){
+            Var v = var(add_tmp[i]);
+            if (level(v) >= out_btlevel - 1)
+                varBumpActivity(v, 1);
+        }
+        add_tmp.clear();
+    }else{
+        seen[var(p)] = true;
+        for(int i = out_learnt.size() - 1; i >= 0; i--){
+            Var v = var(out_learnt[i]);
+            CRef rea = reason(v);
+            if (rea != CRef_Undef){
+                const Clause& reaC = ca[rea];
+                for (int i = 0; i < reaC.size(); i++){
+                    Lit l = reaC[i];
+                    if (!seen[var(l)]){
+                        seen[var(l)] = true;
+                        almost_conflicted[var(l)]++;
+                        analyze_toclear.push(l); } } } } }
+
+    for (int j = 0; j < analyze_toclear.size(); j++) seen[var(analyze_toclear[j])] = 0;    // ('seen[]' is now cleared)
+}
+
+
+// Try further learnt clause minimization by means of binary clause resolution.
+inline bool Solver::binResMinimize(vec<Lit>& out_learnt)
+{
+    // Preparation: remember which false variables we have in 'out_learnt'.
+    counter++;
+    for (int i = 1; i < out_learnt.size(); i++)
+        seen2[var(out_learnt[i])] = counter;
+
+    // Get the list of binary clauses containing 'out_learnt[0]'.
+    const vec<Watcher>& ws = watches_bin[~out_learnt[0]];
+
+    int to_remove = 0;
+    for (int i = 0; i < ws.size(); i++){
+        Lit the_other = ws[i].blocker;
+        // Does 'the_other' appear negatively in 'out_learnt'?
+        if (seen2[var(the_other)] == counter && value(the_other) == l_True){
+            to_remove++;
+            seen2[var(the_other)] = counter - 1; // Remember to remove this variable.
+        }
+    }
+
+    // Shrink.
+    if (to_remove > 0){
+        int last = out_learnt.size() - 1;
+        for (int i = 1; i < out_learnt.size() - to_remove; i++)
+            if (seen2[var(out_learnt[i])] != counter)
+                out_learnt[i--] = out_learnt[last--];
+        out_learnt.shrink(to_remove);
+    }
+    return to_remove != 0;
+}
+
+
+// Check if 'p' can be removed. 'abstract_levels' is used to abort early if the algorithm is
+// visiting literals at levels that cannot be removed later.
+inline bool Solver::litRedundant(Lit p, uint32_t abstract_levels)
+{
+    analyze_stack.clear(); analyze_stack.push(p);
+    int top = analyze_toclear.size();
+    while (analyze_stack.size() > 0){
+        assert(reason(var(analyze_stack.last())) != CRef_Undef);
+        Clause& c = ca[reason(var(analyze_stack.last()))]; analyze_stack.pop();
+
+        // Special handling for binary clauses like in 'analyze()'.
+        if (c.size() == 2 && value(c[0]) == l_False){
+            assert(value(c[1]) == l_True);
+            Lit tmp = c[0];
+            c[0] = c[1], c[1] = tmp; }
+
+        for (int i = 1; i < c.size(); i++){
+            Lit p  = c[i];
+            if (!seen[var(p)] && level(var(p)) > 0){
+                if (reason(var(p)) != CRef_Undef && (abstractLevel(var(p)) & abstract_levels) != 0){
+                    seen[var(p)] = 1;
+                    analyze_stack.push(p);
+                    analyze_toclear.push(p);
+                }else{
+                    for (int j = top; j < analyze_toclear.size(); j++)
+                        seen[var(analyze_toclear[j])] = 0;
+                    analyze_toclear.shrink(analyze_toclear.size() - top);
+                    return false;
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  analyzeFinal : (p : Lit)  ->  [void]
+|  
+|  Description:
+|    Specialized analysis procedure to express the final conflict in terms of assumptions.
+|    Calculates the (possibly empty) set of assumptions that led to the assignment of 'p', and
+|    stores the result in 'out_conflict'.
+|________________________________________________________________________________________________@*/
+inline void Solver::analyzeFinal(Lit p, vec<Lit>& out_conflict)
+{
+    out_conflict.clear();
+    out_conflict.push(p);
+
+    if (decisionLevel() == 0)
+        return;
+
+    seen[var(p)] = 1;
+
+    for (int i = trail.size()-1; i >= trail_lim[0]; i--){
+        Var x = var(trail[i]);
+        if (seen[x]){
+            if (reason(x) == CRef_Undef){
+                assert(level(x) > 0);
+                out_conflict.push(~trail[i]);
+            }else{
+                Clause& c = ca[reason(x)];
+                for (int j = c.size() == 2 ? 0 : 1; j < c.size(); j++)
+                    if (level(var(c[j])) > 0)
+                        seen[var(c[j])] = 1;
+            }
+            seen[x] = 0;
+        }
+    }
+
+    seen[var(p)] = 0;
+}
+
+
+inline void Solver::uncheckedEnqueue(Lit p, int level, CRef from)
+{
+    assert(value(p) == l_Undef);
+    Var x = var(p);
+    if (!VSIDS){
+        picked[x] = conflicts;
+        conflicted[x] = 0;
+        almost_conflicted[x] = 0;
+#ifdef ANTI_EXPLORATION
+        uint32_t age = conflicts - canceled[var(p)];
+        if (age > 0){
+            double decay = pow(0.95, age);
+            activity_CHB[var(p)] *= decay;
+            if (order_heap_CHB.inHeap(var(p)))
+                order_heap_CHB.increase(var(p));
+        }
+#endif
+    }
+
+    assigns[x] = lbool(!sign(p));
+    vardata[x] = mkVarData(from, level);
+    trail.push_(p);
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  propagate : [void]  ->  [Clause*]
+|  
+|  Description:
+|    Propagates all enqueued facts. If a conflict arises, the conflicting clause is returned,
+|    otherwise CRef_Undef.
+|  
+|    Post-conditions:
+|      * the propagation queue is empty, even if there was a conflict.
+|________________________________________________________________________________________________@*/
+inline CRef Solver::propagate()
+{
+    CRef    confl     = CRef_Undef;
+    int     num_props = 0;
+    watches.cleanAll();
+    watches_bin.cleanAll();
+
+    while (qhead < trail.size()){
+        Lit            p   = trail[qhead++];     // 'p' is enqueued fact to propagate.
+        int currLevel = level(var(p));
+        vec<Watcher>&  ws  = watches[p];
+        Watcher        *i, *j, *end;
+        num_props++;
+
+        vec<Watcher>& ws_bin = watches_bin[p];  // Propagate binary clauses first.
+        for (int k = 0; k < ws_bin.size(); k++){
+            Lit the_other = ws_bin[k].blocker;
+            if (value(the_other) == l_False){
+                confl = ws_bin[k].cref;
+#ifdef LOOSE_PROP_STAT
+                return confl;
+#else
+                goto ExitProp;
+#endif
+            }else if(value(the_other) == l_Undef)
+            {
+                uncheckedEnqueue(the_other, currLevel, ws_bin[k].cref);
+#ifdef  PRINT_OUT                
+                std::cout << "i " << the_other << " l " << currLevel << "\n";
+#endif                
+			}
+        }
+
+        for (i = j = (Watcher*)ws, end = i + ws.size();  i != end;){
+            // Try to avoid inspecting the clause:
+            Lit blocker = i->blocker;
+            if (value(blocker) == l_True){
+                *j++ = *i++; continue; }
+
+            // Make sure the false literal is data[1]:
+            CRef     cr        = i->cref;
+            Clause&  c         = ca[cr];
+            Lit      false_lit = ~p;
+            if (c[0] == false_lit)
+                c[0] = c[1], c[1] = false_lit;
+            assert(c[1] == false_lit);
+            i++;
+
+            // If 0th watch is true, then clause is already satisfied.
+            Lit     first = c[0];
+            Watcher w     = Watcher(cr, first);
+            if (first != blocker && value(first) == l_True){
+                *j++ = w; continue; }
+
+            // Look for new watch:
+            for (int k = 2; k < c.size(); k++)
+                if (value(c[k]) != l_False){
+                    c[1] = c[k]; c[k] = false_lit;
+                    watches[~c[1]].push(w);
+                    goto NextClause; }
+
+            // Did not find watch -- clause is unit under assignment:
+            *j++ = w;
+            if (value(first) == l_False){
+                confl = cr;
+                qhead = trail.size();
+                // Copy the remaining watches:
+                while (i < end)
+                    *j++ = *i++;
+            }else
+            {
+				if (currLevel == decisionLevel())
+				{
+					uncheckedEnqueue(first, currLevel, cr);
+#ifdef PRINT_OUT					
+					std::cout << "i " << first << " l " << currLevel << "\n";
+#endif					
+				}
+				else
+				{
+					int nMaxLevel = currLevel;
+					int nMaxInd = 1;
+					// pass over all the literals in the clause and find the one with the biggest level
+					for (int nInd = 2; nInd < c.size(); ++nInd)
+					{
+						int nLevel = level(var(c[nInd]));
+						if (nLevel > nMaxLevel)
+						{
+							nMaxLevel = nLevel;
+							nMaxInd = nInd;
+						}
+					}
+
+					if (nMaxInd != 1)
+					{
+						std::swap(c[1], c[nMaxInd]);
+						*j--; // undo last watch
+						watches[~c[1]].push(w);
+					}
+					
+					uncheckedEnqueue(first, nMaxLevel, cr);
+#ifdef PRINT_OUT					
+					std::cout << "i " << first << " l " << nMaxLevel << "\n";
+#endif	
+				}
+			}
+
+NextClause:;
+        }
+        ws.shrink(i - j);
+    }
+
+ExitProp:;
+    propagations += num_props;
+    simpDB_props -= num_props;
+
+    return confl;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  reduceDB : ()  ->  [void]
+|  
+|  Description:
+|    Remove half of the learnt clauses, minus the clauses locked by the current assignment. Locked
+|    clauses are clauses that are reason to some assignment. Binary clauses are never removed.
+|________________________________________________________________________________________________@*/
+struct reduceDB_lt { 
+    ClauseAllocator& ca;
+    reduceDB_lt(ClauseAllocator& ca_) : ca(ca_) {}
+    bool operator () (CRef x, CRef y) const { return ca[x].activity() < ca[y].activity(); }
+};
+inline void Solver::reduceDB()
+{
+    int     i, j;
+    //if (local_learnts_dirty) cleanLearnts(learnts_local, LOCAL);
+    //local_learnts_dirty = false;
+
+    sort(learnts_local, reduceDB_lt(ca));
+
+    int limit = learnts_local.size() / 2;
+    for (i = j = 0; i < learnts_local.size(); i++){
+        Clause& c = ca[learnts_local[i]];
+        if (c.mark() == LOCAL)
+            if (c.removable() && !locked(c) && i < limit)
+                removeClause(learnts_local[i]);
+            else{
+                if (!c.removable()) limit++;
+                c.removable(true);
+                learnts_local[j++] = learnts_local[i]; }
+    }
+    learnts_local.shrink(i - j);
+
+    checkGarbage();
+}
+inline void Solver::reduceDB_Tier2()
+{
+    int i, j;
+    for (i = j = 0; i < learnts_tier2.size(); i++){
+        Clause& c = ca[learnts_tier2[i]];
+        if (c.mark() == TIER2)
+            if (!locked(c) && c.touched() + 30000 < conflicts){
+                learnts_local.push(learnts_tier2[i]);
+                c.mark(LOCAL);
+                //c.removable(true);
+                c.activity() = 0;
+                claBumpActivity(c);
+            }else
+                learnts_tier2[j++] = learnts_tier2[i];
+    }
+    learnts_tier2.shrink(i - j);
+}
+
+
+inline void Solver::removeSatisfied(vec<CRef>& cs)
+{
+    int i, j;
+    for (i = j = 0; i < cs.size(); i++){
+        Clause& c = ca[cs[i]];
+        if (satisfied(c))
+            removeClause(cs[i]);
+        else
+            cs[j++] = cs[i];
+    }
+    cs.shrink(i - j);
+}
+
+inline void Solver::safeRemoveSatisfied(vec<CRef>& cs, unsigned valid_mark)
+{
+    int i, j;
+    for (i = j = 0; i < cs.size(); i++){
+        Clause& c = ca[cs[i]];
+        if (c.mark() == valid_mark)
+            if (satisfied(c))
+                removeClause(cs[i]);
+            else
+                cs[j++] = cs[i];
+    }
+    cs.shrink(i - j);
+}
+
+inline void Solver::rebuildOrderHeap()
+{
+    vec<Var> vs;
+    for (Var v = 0; v < nVars(); v++)
+        if (decision[v] && value(v) == l_Undef)
+            vs.push(v);
+
+    order_heap_CHB  .build(vs);
+    order_heap_VSIDS.build(vs);
+    order_heap_distance.build(vs);
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  simplify : [void]  ->  [bool]
+|  
+|  Description:
+|    Simplify the clause database according to the current top-level assigment. Currently, the only
+|    thing done here is the removal of satisfied clauses, but more things can be put here.
+|________________________________________________________________________________________________@*/
+inline bool Solver::simplify()
+{
+    assert(decisionLevel() == 0);
+
+    if (!ok || propagate() != CRef_Undef)
+        return ok = false;
+
+    if (nAssigns() == simpDB_assigns || (simpDB_props > 0))
+        return true;
+
+    // Remove satisfied clauses:
+    removeSatisfied(learnts_core); // Should clean core first.
+    safeRemoveSatisfied(learnts_tier2, TIER2);
+    safeRemoveSatisfied(learnts_local, LOCAL);
+    if (remove_satisfied)        // Can be turned off.
+        removeSatisfied(clauses);
+    checkGarbage();
+    rebuildOrderHeap();
+
+    simpDB_assigns = nAssigns();
+    simpDB_props   = clauses_literals + learnts_literals;   // (shouldn't depend on stats really, but it will do for now)
+
+    return true;
+}
+
+// pathCs[k] is the number of variables assigned at level k,
+// it is initialized to 0 at the begining and reset to 0 after the function execution
+inline bool Solver::collectFirstUIP(CRef confl){
+    involved_lits.clear();
+    int max_level=1;
+    Clause& c=ca[confl]; int minLevel=decisionLevel();
+    for(int i=0; i<c.size(); i++) {
+        Var v=var(c[i]);
+        //        assert(!seen[v]);
+        if (level(v)>0) {
+            seen[v]=1;
+            var_iLevel_tmp[v]=1;
+            pathCs[level(v)]++;
+            if (minLevel>level(v)) {
+                minLevel=level(v);
+                assert(minLevel>0);
+            }
+            //    varBumpActivity(v);
+        }
+    }
+
+    int limit=trail_lim[minLevel-1];
+    for(int i=trail.size()-1; i>=limit; i--) {
+        Lit p=trail[i]; Var v=var(p);
+        if (seen[v]) {
+            int currentDecLevel=level(v);
+            //      if (currentDecLevel==decisionLevel())
+            //      	varBumpActivity(v);
+            seen[v]=0;
+            if (--pathCs[currentDecLevel]!=0) {
+                Clause& rc=ca[reason(v)];
+                int reasonVarLevel=var_iLevel_tmp[v]+1;
+                if(reasonVarLevel>max_level) max_level=reasonVarLevel;
+                if (rc.size()==2 && value(rc[0])==l_False) {
+                    // Special case for binary clauses
+                    // The first one has to be SAT
+                    assert(value(rc[1]) != l_False);
+                    Lit tmp = rc[0];
+                    rc[0] =  rc[1], rc[1] = tmp;
+                }
+                for (int j = 1; j < rc.size(); j++){
+                    Lit q = rc[j]; Var v1=var(q);
+                    if (level(v1) > 0) {
+                        if (minLevel>level(v1)) {
+                            minLevel=level(v1); limit=trail_lim[minLevel-1]; 	assert(minLevel>0);
+                        }
+                        if (seen[v1]) {
+                            if (var_iLevel_tmp[v1]<reasonVarLevel)
+                                var_iLevel_tmp[v1]=reasonVarLevel;
+                        }
+                        else {
+                            var_iLevel_tmp[v1]=reasonVarLevel;
+                            //   varBumpActivity(v1);
+                            seen[v1] = 1;
+                            pathCs[level(v1)]++;
+                        }
+                    }
+                }
+            }
+            involved_lits.push(p);
+        }
+    }
+    double inc=var_iLevel_inc;
+    vec<int> level_incs; level_incs.clear();
+    for(int i=0;i<max_level;i++){
+        level_incs.push(inc);
+        inc = inc/my_var_decay;
+    }
+
+    for(int i=0;i<involved_lits.size();i++){
+        Var v =var(involved_lits[i]);
+        //        double old_act=activity_distance[v];
+        //        activity_distance[v] +=var_iLevel_inc * var_iLevel_tmp[v];
+        activity_distance[v]+=var_iLevel_tmp[v]*level_incs[var_iLevel_tmp[v]-1];
+
+        if(activity_distance[v]>1e100){
+            for(int vv=0;vv<nVars();vv++)
+                activity_distance[vv] *= 1e-100;
+            var_iLevel_inc*=1e-100;
+            for(int j=0; j<max_level; j++) level_incs[j]*=1e-100;
+        }
+        if (order_heap_distance.inHeap(v))
+            order_heap_distance.decrease(v);
+
+        //        var_iLevel_inc *= (1 / my_var_decay);
+    }
+    var_iLevel_inc=level_incs[level_incs.size()-1];
+    return true;
+}
+
+struct UIPOrderByILevel_Lt {
+    Solver& solver;
+    const vec<double>&  var_iLevel;
+    bool operator () (Lit x, Lit y) const
+    {
+        return var_iLevel[var(x)] < var_iLevel[var(y)] ||
+                (var_iLevel[var(x)]==var_iLevel[var(y)]&& solver.level(var(x))>solver.level(var(y)));
+    }
+    UIPOrderByILevel_Lt(const vec<double>&  iLevel, Solver& para_solver) : solver(para_solver), var_iLevel(iLevel) { }
+};
+
+inline CRef Solver::propagateLits(vec<Lit>& lits) {
+    Lit lit;
+    int i;
+
+    for(i=lits.size()-1; i>=0; i--) {
+        lit=lits[i];
+        if (value(lit) == l_Undef) {
+            newDecisionLevel();
+            uncheckedEnqueue(lit);
+            CRef confl = propagate();
+            if (confl != CRef_Undef) {
+                return confl;
+            }
+        }
+    }
+    return CRef_Undef;
+}
+/*_________________________________________________________________________________________________
+|
+|  search : (nof_conflicts : int) (params : const SearchParams&)  ->  [lbool]
+|  
+|  Description:
+|    Search for a model the specified number of conflicts. 
+|  
+|  Output:
+|    'l_True' if a partial assigment that is consistent with respect to the clauseset is found. If
+|    all variables are decision variables, this means that the clause set is satisfiable. 'l_False'
+|    if the clause set is unsatisfiable. 'l_Undef' if the bound on number of conflicts is reached.
+|________________________________________________________________________________________________@*/
+inline lbool Solver::search(int& nof_conflicts)
+{
+    assert(ok);
+    int         backtrack_level;
+    int         lbd;
+    vec<Lit>    learnt_clause;
+    bool        cached = false;
+    starts++;
+
+    // simplify
+    //
+    if (conflicts >= curSimplify * nbconfbeforesimplify){
+        //        printf("c ### simplifyAll on conflict : %lld\n", conflicts);
+        //printf("nbClauses: %d, nbLearnts_core: %d, nbLearnts_tier2: %d, nbLearnts_local: %d, nbLearnts: %d\n",
+        //	clauses.size(), learnts_core.size(), learnts_tier2.size(), learnts_local.size(),
+        //	learnts_core.size() + learnts_tier2.size() + learnts_local.size());
+        nbSimplifyAll++;
+        if (!simplifyAll()){
+            return l_False;
+        }
+        curSimplify = (conflicts / nbconfbeforesimplify) + 1;
+        nbconfbeforesimplify += incSimplify;
+    }
+
+    for (;;){
+        CRef confl = propagate();
+
+        if (confl != CRef_Undef){
+            // CONFLICT
+            if (VSIDS){
+                if (--timer == 0 && var_decay < 0.95) timer = 5000, var_decay += 0.01;
+            }else
+                if (step_size > min_step_size) step_size -= step_size_dec;
+
+            conflicts++; nof_conflicts--;
+            if (conflicts == 100000 && learnts_core.size() < 100) core_lbd_cut = 5;
+            ConflictData data = FindConflictLevel(confl);
+            if (data.nHighestLevel == 0) return l_False;
+            if (data.bOnlyOneLitFromHighest)
+            {
+				cancelUntil(data.nHighestLevel - 1);
+				continue;
+			}
+			
+            learnt_clause.clear();
+            if(conflicts>50000) DISTANCE=0;
+            else DISTANCE=1;
+            if(VSIDS && DISTANCE)
+                collectFirstUIP(confl);
+
+            analyze(confl, learnt_clause, backtrack_level, lbd);
+            // check chrono backtrack condition
+            if ((confl_to_chrono < 0 || confl_to_chrono <= conflicts) && chrono > -1 && (decisionLevel() - backtrack_level) >= chrono)
+            {
+				++chrono_backtrack;
+				cancelUntil(data.nHighestLevel -1);
+			}
+			else // default behavior
+			{
+				++non_chrono_backtrack;
+				cancelUntil(backtrack_level);
+			}
+
+            lbd--;
+            if (VSIDS){
+                cached = false;
+                conflicts_VSIDS++;
+                lbd_queue.push(lbd);
+                global_lbd_sum += (lbd > 50 ? 50 : lbd); }
+
+            if (learnt_clause.size() == 1){
+                uncheckedEnqueue(learnt_clause[0]);
+            }else{
+                CRef cr = ca.alloc(learnt_clause, true);
+                ca[cr].set_lbd(lbd);
+                if (lbd <= core_lbd_cut){
+                    learnts_core.push(cr);
+                    ca[cr].mark(CORE);
+                }else if (lbd <= 6){
+                    learnts_tier2.push(cr);
+                    ca[cr].mark(TIER2);
+                    ca[cr].touched() = conflicts;
+                }else{
+                    learnts_local.push(cr);
+                    claBumpActivity(ca[cr]); }
+                attachClause(cr);
+
+                uncheckedEnqueue(learnt_clause[0], backtrack_level, cr);
+#ifdef PRINT_OUT
+                std::cout << "new " << ca[cr] << "\n";
+                std::cout << "ci " << learnt_clause[0] << " l " << backtrack_level << "\n";
+#endif                
+            }
+            if (drup_file){
+#ifdef BIN_DRUP
+                binDRUP('a', learnt_clause, drup_file);
+#else
+                for (int i = 0; i < learnt_clause.size(); i++)
+                    fprintf(drup_file, "%i ", (var(learnt_clause[i]) + 1) * (-2 * sign(learnt_clause[i]) + 1));
+                fprintf(drup_file, "0\n");
+#endif
+            }
+
+            if (VSIDS) varDecayActivity();
+            claDecayActivity();
+
+            /*if (--learntsize_adjust_cnt == 0){
+                learntsize_adjust_confl *= learntsize_adjust_inc;
+                learntsize_adjust_cnt    = (int)learntsize_adjust_confl;
+                max_learnts             *= learntsize_inc;
+
+                if (verbosity >= 1)
+                    printf("c | %9d | %7d %8d %8d | %8d %8d %6.0f | %6.3f %% |\n",
+                           (int)conflicts,
+                           (int)dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]), nClauses(), (int)clauses_literals,
+                           (int)max_learnts, nLearnts(), (double)learnts_literals/nLearnts(), progressEstimate()*100);
+            }*/
+
+        }else{
+            // NO CONFLICT
+            bool restart = false;
+            if (!VSIDS)
+                restart = nof_conflicts <= 0;
+            else if (!cached){
+                restart = lbd_queue.full() && (lbd_queue.avg() * 0.8 > global_lbd_sum / conflicts_VSIDS);
+                cached = true;
+            }
+            if (restart /*|| !withinBudget()*/){
+                lbd_queue.clear();
+                cached = false;
+                // Reached bound on number of conflicts:
+                progress_estimate = progressEstimate();
+                cancelUntil(0);
+                return l_Undef; }
+
+            // Simplify the set of problem clauses:
+            if (decisionLevel() == 0 && !simplify())
+                return l_False;
+
+            if (conflicts >= next_T2_reduce){
+                next_T2_reduce = conflicts + 10000;
+                reduceDB_Tier2(); }
+            if (conflicts >= next_L_reduce){
+                next_L_reduce = conflicts + 15000;
+                reduceDB(); }
+
+            Lit next = lit_Undef;
+            while (decisionLevel() < assumptions.size()){
+                // Perform user provided assumption:
+                Lit p = assumptions[decisionLevel()];
+                if (value(p) == l_True){
+                    // Dummy decision level:
+                    newDecisionLevel();
+                }else if (value(p) == l_False){
+                    analyzeFinal(~p, conflict);
+                    return l_False;
+                }else{
+                    next = p;
+                    break;
+                }
+            }
+
+            if (next == lit_Undef){
+                // New variable decision:
+                decisions++;
+                next = pickBranchLit();
+
+                if (next == lit_Undef)
+                    // Model found:
+                    return l_True;
+            }
+
+            // Increase decision level and enqueue 'next'
+            newDecisionLevel();
+            uncheckedEnqueue(next, decisionLevel());
+#ifdef PRINT_OUT            
+            std::cout << "d " << next << " l " << decisionLevel() << "\n";
+#endif            
+        }
+    }
+}
+
+
+inline double Solver::progressEstimate() const
+{
+    double  progress = 0;
+    double  F = 1.0 / nVars();
+
+    for (int i = 0; i <= decisionLevel(); i++){
+        int beg = i == 0 ? 0 : trail_lim[i - 1];
+        int end = i == decisionLevel() ? trail.size() : trail_lim[i];
+        progress += pow(F, i) * (end - beg);
+    }
+
+    return progress / nVars();
+}
+
+/*
+  Finite subsequences of the Luby-sequence:
+
+  0: 1
+  1: 1 1 2
+  2: 1 1 2 1 1 2 4
+  3: 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8
+  ...
+
+
+ */
+
+static double luby(double y, int x){
+
+    // Find the finite subsequence that contains index 'x', and the
+    // size of that subsequence:
+    int size, seq;
+    for (size = 1, seq = 0; size < x+1; seq++, size = 2*size+1);
+
+    while (size-1 != x){
+        size = (size-1)>>1;
+        seq--;
+        x = x % size;
+    }
+
+    return pow(y, seq);
+}
+
+static bool switch_mode = false;
+static void SIGALRM_switch(int signum) { switch_mode = true; }
+
+// NOTE: assumptions passed in member-variable 'assumptions'.
+inline lbool Solver::solve_()
+{
+    ::signal(SIGALRM, SIGALRM_switch);
+    alarm(2500);
+
+    model.clear();
+    conflict.clear();
+    if (!ok) return l_False;
+
+    solves++;
+
+    max_learnts               = nClauses() * learntsize_factor;
+    learntsize_adjust_confl   = learntsize_adjust_start_confl;
+    learntsize_adjust_cnt     = (int)learntsize_adjust_confl;
+    lbool   status            = l_Undef;
+
+    if (verbosity >= 1){
+        printf("c ============================[ Search Statistics ]==============================\n");
+        printf("c | Conflicts |          ORIGINAL         |          LEARNT          | Progress |\n");
+        printf("c |           |    Vars  Clauses Literals |    Limit  Clauses Lit/Cl |          |\n");
+        printf("c ===============================================================================\n");
+    }
+
+    add_tmp.clear();
+
+    VSIDS = true;
+    int init = 10000;
+    while (status == l_Undef && init > 0 /*&& withinBudget()*/)
+        status = search(init);
+    VSIDS = false;
+
+    // Search:
+    int curr_restarts = 0;
+    while (status == l_Undef /*&& withinBudget()*/){
+        if (VSIDS){
+            int weighted = INT32_MAX;
+            status = search(weighted);
+        }else{
+            int nof_conflicts = luby(restart_inc, curr_restarts) * restart_first;
+            curr_restarts++;
+            status = search(nof_conflicts);
+        }
+        if (!VSIDS && switch_mode){
+            VSIDS = true;
+            printf("c Switched to VSIDS.\n");
+            fflush(stdout);
+            picked.clear();
+            conflicted.clear();
+            almost_conflicted.clear();
+#ifdef ANTI_EXPLORATION
+            canceled.clear();
+#endif
+        }
+    }
+
+    if (verbosity >= 1)
+        printf("c ===============================================================================\n");
+
+#ifdef BIN_DRUP
+    if (drup_file && status == l_False) binDRUP_flush(drup_file);
+#endif
+
+    if (status == l_True){
+        // Extend & copy model:
+        model.growTo(nVars());
+        for (int i = 0; i < nVars(); i++) model[i] = value(i);
+    }else if (status == l_False && conflict.size() == 0)
+        ok = false;
+
+    cancelUntil(0);
+    return status;
+}
+
+//=================================================================================================
+// Writing CNF to DIMACS:
+// 
+// FIXME: this needs to be rewritten completely.
+
+static Var mapVar(Var x, vec<Var>& map, Var& max)
+{
+    if (map.size() <= x || map[x] == -1){
+        map.growTo(x+1, -1);
+        map[x] = max++;
+    }
+    return map[x];
+}
+
+
+inline void Solver::toDimacs(FILE* f, Clause& c, vec<Var>& map, Var& max)
+{
+    if (satisfied(c)) return;
+
+    for (int i = 0; i < c.size(); i++)
+        if (value(c[i]) != l_False)
+            fprintf(f, "%s%d ", sign(c[i]) ? "-" : "", mapVar(var(c[i]), map, max)+1);
+    fprintf(f, "0\n");
+}
+
+
+inline void Solver::toDimacs(const char *file, const vec<Lit>& assumps)
+{
+    FILE* f = fopen(file, "wr");
+    if (f == NULL)
+        fprintf(stderr, "could not open file %s\n", file), exit(1);
+    toDimacs(f, assumps);
+    fclose(f);
+}
+
+
+inline void Solver::toDimacs(FILE* f, const vec<Lit>& assumps)
+{
+    // Handle case when solver is in contradictory state:
+    if (!ok){
+        fprintf(f, "p cnf 1 2\n1 0\n-1 0\n");
+        return; }
+
+    vec<Var> map; Var max = 0;
+
+    // Cannot use removeClauses here because it is not safe
+    // to deallocate them at this point. Could be improved.
+    int cnt = 0;
+    for (int i = 0; i < clauses.size(); i++)
+        if (!satisfied(ca[clauses[i]]))
+            cnt++;
+
+    for (int i = 0; i < clauses.size(); i++)
+        if (!satisfied(ca[clauses[i]])){
+            Clause& c = ca[clauses[i]];
+            for (int j = 0; j < c.size(); j++)
+                if (value(c[j]) != l_False)
+                    mapVar(var(c[j]), map, max);
+        }
+
+    // Assumptions are added as unit clauses:
+    cnt += assumptions.size();
+
+    fprintf(f, "p cnf %d %d\n", max, cnt);
+
+    for (int i = 0; i < assumptions.size(); i++){
+        assert(value(assumptions[i]) != l_False);
+        fprintf(f, "%s%d 0\n", sign(assumptions[i]) ? "-" : "", mapVar(var(assumptions[i]), map, max)+1);
+    }
+
+    for (int i = 0; i < clauses.size(); i++)
+        toDimacs(f, ca[clauses[i]], map, max);
+
+    if (verbosity > 0)
+        printf("c Wrote %d clauses with %d variables.\n", cnt, max);
+}
+
+
+//=================================================================================================
+// Garbage Collection methods:
+
+inline void Solver::relocAll(ClauseAllocator& to)
+{
+    // All watchers:
+    //
+    // for (int i = 0; i < watches.size(); i++)
+    watches.cleanAll();
+    watches_bin.cleanAll();
+    for (int v = 0; v < nVars(); v++)
+        for (int s = 0; s < 2; s++){
+            Lit p = mkLit(v, s);
+            // printf(" >>> RELOCING: %s%d\n", sign(p)?"-":"", var(p)+1);
+            vec<Watcher>& ws = watches[p];
+            for (int j = 0; j < ws.size(); j++)
+                ca.reloc(ws[j].cref, to);
+            vec<Watcher>& ws_bin = watches_bin[p];
+            for (int j = 0; j < ws_bin.size(); j++)
+                ca.reloc(ws_bin[j].cref, to);
+        }
+
+    // All reasons:
+    //
+    for (int i = 0; i < trail.size(); i++){
+        Var v = var(trail[i]);
+
+        if (reason(v) != CRef_Undef && (ca[reason(v)].reloced() || locked(ca[reason(v)])))
+            ca.reloc(vardata[v].reason, to);
+    }
+
+    // All learnt:
+    //
+    for (int i = 0; i < learnts_core.size(); i++)
+        ca.reloc(learnts_core[i], to);
+    for (int i = 0; i < learnts_tier2.size(); i++)
+        ca.reloc(learnts_tier2[i], to);
+    for (int i = 0; i < learnts_local.size(); i++)
+        ca.reloc(learnts_local[i], to);
+
+    // All original:
+    //
+    int i, j;
+    for (i = j = 0; i < clauses.size(); i++)
+        if (ca[clauses[i]].mark() != 1){
+            ca.reloc(clauses[i], to);
+            clauses[j++] = clauses[i]; }
+    clauses.shrink(i - j);
+}
+
+
+inline void Solver::garbageCollect()
+{
+    // Initialize the next region to a size corresponding to the estimated utilization degree. This
+    // is not precise but should avoid some unnecessary reallocations for the new region:
+    ClauseAllocator to(ca.size() - ca.wasted());
+
+    relocAll(to);
+    if (verbosity >= 2)
+        printf("c |  Garbage collection:   %12d bytes => %12d bytes             |\n",
+               ca.size()*ClauseAllocator::Unit_Size, to.size()*ClauseAllocator::Unit_Size);
+    to.moveTo(ca);
+}
+}
+/************************************************************************************[SimpSolver.h]
+MiniSat -- Copyright (c) 2006,      Niklas Een, Niklas Sorensson
+           Copyright (c) 2007-2010, Niklas Sorensson
+
+Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
+ 
+Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach
+Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear.
+
+Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search
+ 
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Minisat_SimpSolver_h
+#define Minisat_SimpSolver_h
+
+
+
+
+
+namespace Maple {
+
+//=================================================================================================
+
+
+class SimpSolver : public Solver {
+ public:
+    // Constructor/Destructor:
+    //
+    SimpSolver();
+    ~SimpSolver();
+
+    // Problem specification:
+    //
+    Var     newVar    (bool polarity = true, bool dvar = true);
+    bool    addClause (const vec<Lit>& ps);
+    bool    addEmptyClause();                // Add the empty clause to the solver.
+    bool    addClause (Lit p);               // Add a unit clause to the solver.
+    bool    addClause (Lit p, Lit q);        // Add a binary clause to the solver.
+    bool    addClause (Lit p, Lit q, Lit r); // Add a ternary clause to the solver.
+    bool    addClause_(      vec<Lit>& ps);
+    bool    substitute(Var v, Lit x);  // Replace all occurences of v with x (may cause a contradiction).
+
+    // Variable mode:
+    // 
+    void    setFrozen (Var v, bool b); // If a variable is frozen it will not be eliminated.
+    bool    isEliminated(Var v) const;
+
+    // Solving:
+    //
+    bool    solve       (const vec<Lit>& assumps, bool do_simp = true, bool turn_off_simp = false);
+    lbool   solveLimited(const vec<Lit>& assumps, bool do_simp = true, bool turn_off_simp = false);
+    bool    solve       (                     bool do_simp = true, bool turn_off_simp = false);
+    bool    solve       (Lit p       ,        bool do_simp = true, bool turn_off_simp = false);       
+    bool    solve       (Lit p, Lit q,        bool do_simp = true, bool turn_off_simp = false);
+    bool    solve       (Lit p, Lit q, Lit r, bool do_simp = true, bool turn_off_simp = false);
+    bool    eliminate   (bool turn_off_elim = false);  // Perform variable elimination based simplification. 
+    bool    eliminate_  ();
+    void    removeSatisfied();
+
+    // Memory managment:
+    //
+    virtual void garbageCollect();
+
+
+    // Generate a (possibly simplified) DIMACS file:
+    //
+#if 0
+    void    toDimacs  (const char* file, const vec<Lit>& assumps);
+    void    toDimacs  (const char* file);
+    void    toDimacs  (const char* file, Lit p);
+    void    toDimacs  (const char* file, Lit p, Lit q);
+    void    toDimacs  (const char* file, Lit p, Lit q, Lit r);
+#endif
+
+    // Mode of operation:
+    //
+    bool    parsing;
+    int     grow;              // Allow a variable elimination step to grow by a number of clauses (default to zero).
+    int     clause_lim;        // Variables are not eliminated if it produces a resolvent with a length above this limit.
+                               // -1 means no limit.
+    int     subsumption_lim;   // Do not check if subsumption against a clause larger than this. -1 means no limit.
+    double  simp_garbage_frac; // A different limit for when to issue a GC during simplification (Also see 'garbage_frac').
+
+    bool    use_asymm;         // Shrink clauses by asymmetric branching.
+    bool    use_rcheck;        // Check if a clause is already implied. Prett costly, and subsumes subsumptions :)
+    bool    use_elim;          // Perform variable elimination.
+
+    // Statistics:
+    //
+    int     merges;
+    int     asymm_lits;
+    int     eliminated_vars;
+
+ protected:
+
+    // Helper structures:
+    //
+    struct ElimLt {
+        const vec<int>& n_occ;
+        explicit ElimLt(const vec<int>& no) : n_occ(no) {}
+
+        // TODO: are 64-bit operations here noticably bad on 32-bit platforms? Could use a saturating
+        // 32-bit implementation instead then, but this will have to do for now.
+        uint64_t cost  (Var x)        const { return (uint64_t)n_occ[toInt(mkLit(x))] * (uint64_t)n_occ[toInt(~mkLit(x))]; }
+        bool operator()(Var x, Var y) const { return cost(x) < cost(y); }
+        
+        // TODO: investigate this order alternative more.
+        // bool operator()(Var x, Var y) const { 
+        //     int c_x = cost(x);
+        //     int c_y = cost(y);
+        //     return c_x < c_y || c_x == c_y && x < y; }
+    };
+
+    struct ClauseDeleted {
+        const ClauseAllocator& ca;
+        explicit ClauseDeleted(const ClauseAllocator& _ca) : ca(_ca) {}
+        bool operator()(const CRef& cr) const { return ca[cr].mark() == 1; } };
+
+    // Solver state:
+    //
+    int                 elimorder;
+    bool                use_simplification;
+    vec<uint32_t>       elimclauses;
+    vec<char>           touched;
+    OccLists<Var, vec<CRef>, ClauseDeleted>
+                        occurs;
+    vec<int>            n_occ;
+    Heap<ElimLt>        elim_heap;
+    Queue<CRef>         subsumption_queue;
+    vec<char>           frozen;
+    vec<char>           eliminated;
+    int                 bwdsub_assigns;
+    int                 n_touched;
+
+    // Temporaries:
+    //
+    CRef                bwdsub_tmpunit;
+
+    // Main internal methods:
+    //
+    lbool         solve_                   (bool do_simp = true, bool turn_off_simp = false);
+    bool          asymm                    (Var v, CRef cr);
+    bool          asymmVar                 (Var v);
+    void          updateElimHeap           (Var v);
+    void          gatherTouchedClauses     ();
+    bool          merge                    (const Clause& _ps, const Clause& _qs, Var v, vec<Lit>& out_clause);
+    bool          merge                    (const Clause& _ps, const Clause& _qs, Var v, int& size);
+    bool          backwardSubsumptionCheck (bool verbose = false);
+    bool          eliminateVar             (Var v);
+    void          extendModel              ();
+
+    void          removeClause             (CRef cr);
+    bool          strengthenClause         (CRef cr, Lit l);
+    bool          implied                  (const vec<Lit>& c);
+    void          relocAll                 (ClauseAllocator& to);
+};
+
+
+//=================================================================================================
+// Implementation of inline methods:
+
+
+inline bool SimpSolver::isEliminated (Var v) const { return eliminated[v]; }
+inline void SimpSolver::updateElimHeap(Var v) {
+    assert(use_simplification);
+    // if (!frozen[v] && !isEliminated(v) && value(v) == l_Undef)
+    if (elim_heap.inHeap(v) || (!frozen[v] && !isEliminated(v) && value(v) == l_Undef))
+        elim_heap.update(v); }
+
+
+inline bool SimpSolver::addClause    (const vec<Lit>& ps)    { ps.copyTo(add_tmp); return addClause_(add_tmp); }
+inline bool SimpSolver::addEmptyClause()                     { add_tmp.clear(); return addClause_(add_tmp); }
+inline bool SimpSolver::addClause    (Lit p)                 { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); }
+inline bool SimpSolver::addClause    (Lit p, Lit q)          { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); }
+inline bool SimpSolver::addClause    (Lit p, Lit q, Lit r)   { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); }
+inline void SimpSolver::setFrozen    (Var v, bool b) { frozen[v] = (char)b; if (use_simplification && !b) { updateElimHeap(v); } }
+
+inline bool SimpSolver::solve        (                     bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (Lit p       ,        bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (Lit p, Lit q,        bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (Lit p, Lit q, Lit r, bool do_simp, bool turn_off_simp)  { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_(do_simp, turn_off_simp) == l_True; }
+inline bool SimpSolver::solve        (const vec<Lit>& assumps, bool do_simp, bool turn_off_simp){ 
+    budgetOff(); assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp) == l_True; }
+
+inline lbool SimpSolver::solveLimited (const vec<Lit>& assumps, bool do_simp, bool turn_off_simp){ 
+    assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp); }
+
+//=================================================================================================
+}
+
+#endif
+/***********************************************************************************[SimpSolver.cc]
+MiniSat -- Copyright (c) 2006,      Niklas Een, Niklas Sorensson
+           Copyright (c) 2007-2010, Niklas Sorensson
+
+Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
+ 
+Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach
+Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear.
+ 
+Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search
+ 
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+
+
+
+namespace Maple {
+
+//=================================================================================================
+// Options:
+
+
+static const char* _simp_cat = "SIMP";
+
+static BoolOption   opt_use_asymm        (_simp_cat, "asymm",        "Shrink clauses by asymmetric branching.", false);
+static BoolOption   opt_use_rcheck       (_simp_cat, "rcheck",       "Check if a clause is already implied. (costly)", false);
+static BoolOption   opt_use_elim         (_simp_cat, "elim",         "Perform variable elimination.", true);
+static IntOption    opt_grow             (_simp_cat, "grow",         "Allow a variable elimination step to grow by a number of clauses.", 0);
+static IntOption    opt_clause_lim       (_simp_cat, "cl-lim",       "Variables are not eliminated if it produces a resolvent with a length above this limit. -1 means no limit", 20,   IntRange(-1, INT32_MAX));
+static IntOption    opt_subsumption_lim  (_simp_cat, "sub-lim",      "Do not check if subsumption against a clause larger than this. -1 means no limit.", 1000, IntRange(-1, INT32_MAX));
+static DoubleOption opt_simp_garbage_frac(_simp_cat, "simp-gc-frac", "The fraction of wasted memory allowed before a garbage collection is triggered during simplification.",  0.5, DoubleRange(0, false, HUGE_VAL, false));
+
+
+//=================================================================================================
+// Constructor/Destructor:
+
+
+inline SimpSolver::SimpSolver() :
+    parsing            (false)
+  , grow               (opt_grow)
+  , clause_lim         (opt_clause_lim)
+  , subsumption_lim    (opt_subsumption_lim)
+  , simp_garbage_frac  (opt_simp_garbage_frac)
+  , use_asymm          (opt_use_asymm)
+  , use_rcheck         (opt_use_rcheck)
+  , use_elim           (opt_use_elim)
+  , merges             (0)
+  , asymm_lits         (0)
+  , eliminated_vars    (0)
+  , elimorder          (1)
+  , use_simplification (true)
+  , occurs             (ClauseDeleted(ca))
+  , elim_heap          (ElimLt(n_occ))
+  , bwdsub_assigns     (0)
+  , n_touched          (0)
+{
+    vec<Lit> dummy(1,lit_Undef);
+    ca.extra_clause_field = true; // NOTE: must happen before allocating the dummy clause below.
+    bwdsub_tmpunit        = ca.alloc(dummy);
+    remove_satisfied      = false;
+}
+
+
+inline SimpSolver::~SimpSolver()
+{
+}
+
+
+inline Var SimpSolver::newVar(bool sign, bool dvar) {
+    Var v = Solver::newVar(sign, dvar);
+
+    frozen    .push((char)false);
+    eliminated.push((char)false);
+
+    if (use_simplification){
+        n_occ     .push(0);
+        n_occ     .push(0);
+        occurs    .init(v);
+        touched   .push(0);
+        elim_heap .insert(v);
+    }
+    return v; }
+
+
+
+inline lbool SimpSolver::solve_(bool do_simp, bool turn_off_simp)
+{
+    vec<Var> extra_frozen;
+    lbool    result = l_True;
+
+    do_simp &= use_simplification;
+
+    if (do_simp){
+        // Assumptions must be temporarily frozen to run variable elimination:
+        for (int i = 0; i < assumptions.size(); i++){
+            Var v = var(assumptions[i]);
+
+            // If an assumption has been eliminated, remember it.
+            assert(!isEliminated(v));
+
+            if (!frozen[v]){
+                // Freeze and store.
+                setFrozen(v, true);
+                extra_frozen.push(v);
+            } }
+
+        result = lbool(eliminate(turn_off_simp));
+    }
+
+    if (result == l_True)
+        result = Solver::solve_();
+    else if (verbosity >= 1)
+        printf("c ===============================================================================\n");
+
+    if (result == l_True)
+        extendModel();
+
+    if (do_simp)
+        // Unfreeze the assumptions that were frozen:
+        for (int i = 0; i < extra_frozen.size(); i++)
+            setFrozen(extra_frozen[i], false);
+
+    return result;
+}
+
+
+
+inline bool SimpSolver::addClause_(vec<Lit>& ps)
+{
+#ifndef NDEBUG
+    for (int i = 0; i < ps.size(); i++)
+        assert(!isEliminated(var(ps[i])));
+#endif
+
+    int nclauses = clauses.size();
+
+    if (use_rcheck && implied(ps))
+        return true;
+
+    if (!Solver::addClause_(ps))
+        return false;
+
+    if (!parsing && drup_file) {
+#ifdef BIN_DRUP
+        binDRUP('a', ps, drup_file);
+#else
+        for (int i = 0; i < ps.size(); i++)
+            fprintf(drup_file, "%i ", (var(ps[i]) + 1) * (-2 * sign(ps[i]) + 1));
+        fprintf(drup_file, "0\n");
+#endif
+    }
+
+    if (use_simplification && clauses.size() == nclauses + 1){
+        CRef          cr = clauses.last();
+        const Clause& c  = ca[cr];
+
+        // NOTE: the clause is added to the queue immediately and then
+        // again during 'gatherTouchedClauses()'. If nothing happens
+        // in between, it will only be checked once. Otherwise, it may
+        // be checked twice unnecessarily. This is an unfortunate
+        // consequence of how backward subsumption is used to mimic
+        // forward subsumption.
+        subsumption_queue.insert(cr);
+        for (int i = 0; i < c.size(); i++){
+            occurs[var(c[i])].push(cr);
+            n_occ[toInt(c[i])]++;
+            touched[var(c[i])] = 1;
+            n_touched++;
+            if (elim_heap.inHeap(var(c[i])))
+                elim_heap.increase(var(c[i]));
+        }
+    }
+
+    return true;
+}
+
+
+inline void SimpSolver::removeClause(CRef cr)
+{
+    const Clause& c = ca[cr];
+
+    if (use_simplification)
+        for (int i = 0; i < c.size(); i++){
+            n_occ[toInt(c[i])]--;
+            updateElimHeap(var(c[i]));
+            occurs.smudge(var(c[i]));
+        }
+
+    Solver::removeClause(cr);
+}
+
+
+inline bool SimpSolver::strengthenClause(CRef cr, Lit l)
+{
+    Clause& c = ca[cr];
+    assert(decisionLevel() == 0);
+    assert(use_simplification);
+
+    // FIX: this is too inefficient but would be nice to have (properly implemented)
+    // if (!find(subsumption_queue, &c))
+    subsumption_queue.insert(cr);
+
+    if (drup_file){
+#ifdef BIN_DRUP
+        binDRUP_strengthen(c, l, drup_file);
+#else
+        for (int i = 0; i < c.size(); i++)
+            if (c[i] != l) fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+        fprintf(drup_file, "0\n");
+#endif
+    }
+
+    if (c.size() == 2){
+        removeClause(cr);
+        c.strengthen(l);
+    }else{
+        if (drup_file){
+#ifdef BIN_DRUP
+            binDRUP('d', c, drup_file);
+#else
+            fprintf(drup_file, "d ");
+            for (int i = 0; i < c.size(); i++)
+                fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
+            fprintf(drup_file, "0\n");
+#endif
+        }
+
+        detachClause(cr, true);
+        c.strengthen(l);
+        attachClause(cr);
+        remove(occurs[var(l)], cr);
+        n_occ[toInt(l)]--;
+        updateElimHeap(var(l));
+    }
+
+    return c.size() == 1 ? enqueue(c[0]) && propagate() == CRef_Undef : true;
+}
+
+
+// Returns FALSE if clause is always satisfied ('out_clause' should not be used).
+inline bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, vec<Lit>& out_clause)
+{
+    merges++;
+    out_clause.clear();
+
+    bool  ps_smallest = _ps.size() < _qs.size();
+    const Clause& ps  =  ps_smallest ? _qs : _ps;
+    const Clause& qs  =  ps_smallest ? _ps : _qs;
+
+    for (int i = 0; i < qs.size(); i++){
+        if (var(qs[i]) != v){
+            for (int j = 0; j < ps.size(); j++)
+                if (var(ps[j]) == var(qs[i]))
+                    if (ps[j] == ~qs[i])
+                        return false;
+                    else
+                        goto next;
+            out_clause.push(qs[i]);
+        }
+        next:;
+    }
+
+    for (int i = 0; i < ps.size(); i++)
+        if (var(ps[i]) != v)
+            out_clause.push(ps[i]);
+
+    return true;
+}
+
+
+// Returns FALSE if clause is always satisfied.
+inline bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, int& size)
+{
+    merges++;
+
+    bool  ps_smallest = _ps.size() < _qs.size();
+    const Clause& ps  =  ps_smallest ? _qs : _ps;
+    const Clause& qs  =  ps_smallest ? _ps : _qs;
+    const Lit*  __ps  = (const Lit*)ps;
+    const Lit*  __qs  = (const Lit*)qs;
+
+    size = ps.size()-1;
+
+    for (int i = 0; i < qs.size(); i++){
+        if (var(__qs[i]) != v){
+            for (int j = 0; j < ps.size(); j++)
+                if (var(__ps[j]) == var(__qs[i]))
+                    if (__ps[j] == ~__qs[i])
+                        return false;
+                    else
+                        goto next;
+            size++;
+        }
+        next:;
+    }
+
+    return true;
+}
+
+
+inline void SimpSolver::gatherTouchedClauses()
+{
+    if (n_touched == 0) return;
+
+    int i,j;
+    for (i = j = 0; i < subsumption_queue.size(); i++)
+        if (ca[subsumption_queue[i]].mark() == 0)
+            ca[subsumption_queue[i]].mark(2);
+
+    for (i = 0; i < touched.size(); i++)
+        if (touched[i]){
+            const vec<CRef>& cs = occurs.lookup(i);
+            for (j = 0; j < cs.size(); j++)
+                if (ca[cs[j]].mark() == 0){
+                    subsumption_queue.insert(cs[j]);
+                    ca[cs[j]].mark(2);
+                }
+            touched[i] = 0;
+        }
+
+    for (i = 0; i < subsumption_queue.size(); i++)
+        if (ca[subsumption_queue[i]].mark() == 2)
+            ca[subsumption_queue[i]].mark(0);
+
+    n_touched = 0;
+}
+
+
+inline bool SimpSolver::implied(const vec<Lit>& c)
+{
+    assert(decisionLevel() == 0);
+
+    trail_lim.push(trail.size());
+    for (int i = 0; i < c.size(); i++)
+        if (value(c[i]) == l_True){
+            cancelUntil(0);
+            return true;
+        }else if (value(c[i]) != l_False){
+            assert(value(c[i]) == l_Undef);
+            uncheckedEnqueue(~c[i]);
+        }
+
+    bool result = propagate() != CRef_Undef;
+    cancelUntil(0);
+    return result;
+}
+
+
+// Backward subsumption + backward subsumption resolution
+inline bool SimpSolver::backwardSubsumptionCheck(bool verbose)
+{
+    int cnt = 0;
+    int subsumed = 0;
+    int deleted_literals = 0;
+    assert(decisionLevel() == 0);
+
+    while (subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()){
+
+        // Empty subsumption queue and return immediately on user-interrupt:
+        if (asynch_interrupt){
+            subsumption_queue.clear();
+            bwdsub_assigns = trail.size();
+            break; }
+
+        // Check top-level assignments by creating a dummy clause and placing it in the queue:
+        if (subsumption_queue.size() == 0 && bwdsub_assigns < trail.size()){
+            Lit l = trail[bwdsub_assigns++];
+            ca[bwdsub_tmpunit][0] = l;
+            ca[bwdsub_tmpunit].calcAbstraction();
+            subsumption_queue.insert(bwdsub_tmpunit); }
+
+        CRef    cr = subsumption_queue.peek(); subsumption_queue.pop();
+        Clause& c  = ca[cr];
+
+        if (c.mark()) continue;
+
+        if (verbose && verbosity >= 2 && cnt++ % 1000 == 0)
+            printf("c subsumption left: %10d (%10d subsumed, %10d deleted literals)\r", subsumption_queue.size(), subsumed, deleted_literals);
+
+        assert(c.size() > 1 || value(c[0]) == l_True);    // Unit-clauses should have been propagated before this point.
+
+        // Find best variable to scan:
+        Var best = var(c[0]);
+        for (int i = 1; i < c.size(); i++)
+            if (occurs[var(c[i])].size() < occurs[best].size())
+                best = var(c[i]);
+
+        // Search all candidates:
+        vec<CRef>& _cs = occurs.lookup(best);
+        CRef*       cs = (CRef*)_cs;
+
+        for (int j = 0; j < _cs.size(); j++)
+            if (c.mark())
+                break;
+            else if (!ca[cs[j]].mark() &&  cs[j] != cr && (subsumption_lim == -1 || ca[cs[j]].size() < subsumption_lim)){
+                Lit l = c.subsumes(ca[cs[j]]);
+
+                if (l == lit_Undef)
+                    subsumed++, removeClause(cs[j]);
+                else if (l != lit_Error){
+                    deleted_literals++;
+
+                    if (!strengthenClause(cs[j], ~l))
+                        return false;
+
+                    // Did current candidate get deleted from cs? Then check candidate at index j again:
+                    if (var(l) == best)
+                        j--;
+                }
+            }
+    }
+
+    return true;
+}
+
+
+inline bool SimpSolver::asymm(Var v, CRef cr)
+{
+    Clause& c = ca[cr];
+    assert(decisionLevel() == 0);
+
+    if (c.mark() || satisfied(c)) return true;
+
+    trail_lim.push(trail.size());
+    Lit l = lit_Undef;
+    for (int i = 0; i < c.size(); i++)
+        if (var(c[i]) != v){
+            if (value(c[i]) != l_False)
+                uncheckedEnqueue(~c[i]);
+        }else
+            l = c[i];
+
+    if (propagate() != CRef_Undef){
+        cancelUntil(0);
+        asymm_lits++;
+        if (!strengthenClause(cr, l))
+            return false;
+    }else
+        cancelUntil(0);
+
+    return true;
+}
+
+
+inline bool SimpSolver::asymmVar(Var v)
+{
+    assert(use_simplification);
+
+    const vec<CRef>& cls = occurs.lookup(v);
+
+    if (value(v) != l_Undef || cls.size() == 0)
+        return true;
+
+    for (int i = 0; i < cls.size(); i++)
+        if (!asymm(v, cls[i]))
+            return false;
+
+    return backwardSubsumptionCheck();
+}
+
+
+static void mkElimClause(vec<uint32_t>& elimclauses, Lit x)
+{
+    elimclauses.push(toInt(x));
+    elimclauses.push(1);
+}
+
+
+static void mkElimClause(vec<uint32_t>& elimclauses, Var v, Clause& c)
+{
+    int first = elimclauses.size();
+    int v_pos = -1;
+
+    // Copy clause to elimclauses-vector. Remember position where the
+    // variable 'v' occurs:
+    for (int i = 0; i < c.size(); i++){
+        elimclauses.push(toInt(c[i]));
+        if (var(c[i]) == v)
+            v_pos = i + first;
+    }
+    assert(v_pos != -1);
+
+    // Swap the first literal with the 'v' literal, so that the literal
+    // containing 'v' will occur first in the clause:
+    uint32_t tmp = elimclauses[v_pos];
+    elimclauses[v_pos] = elimclauses[first];
+    elimclauses[first] = tmp;
+
+    // Store the length of the clause last:
+    elimclauses.push(c.size());
+}
+
+
+
+inline bool SimpSolver::eliminateVar(Var v)
+{
+    assert(!frozen[v]);
+    assert(!isEliminated(v));
+    assert(value(v) == l_Undef);
+
+    // Split the occurrences into positive and negative:
+    //
+    const vec<CRef>& cls = occurs.lookup(v);
+    vec<CRef>        pos, neg;
+    for (int i = 0; i < cls.size(); i++)
+        (find(ca[cls[i]], mkLit(v)) ? pos : neg).push(cls[i]);
+
+    // Check wether the increase in number of clauses stays within the allowed ('grow'). Moreover, no
+    // clause must exceed the limit on the maximal clause size (if it is set):
+    //
+    int cnt         = 0;
+    int clause_size = 0;
+
+    for (int i = 0; i < pos.size(); i++)
+        for (int j = 0; j < neg.size(); j++)
+            if (merge(ca[pos[i]], ca[neg[j]], v, clause_size) && 
+                (++cnt > cls.size() + grow || (clause_lim != -1 && clause_size > clause_lim)))
+                return true;
+
+    // Delete and store old clauses:
+    eliminated[v] = true;
+    setDecisionVar(v, false);
+    eliminated_vars++;
+
+    if (pos.size() > neg.size()){
+        for (int i = 0; i < neg.size(); i++)
+            mkElimClause(elimclauses, v, ca[neg[i]]);
+        mkElimClause(elimclauses, mkLit(v));
+    }else{
+        for (int i = 0; i < pos.size(); i++)
+            mkElimClause(elimclauses, v, ca[pos[i]]);
+        mkElimClause(elimclauses, ~mkLit(v));
+    }
+
+    // Produce clauses in cross product:
+    vec<Lit>& resolvent = add_tmp;
+    for (int i = 0; i < pos.size(); i++)
+        for (int j = 0; j < neg.size(); j++)
+            if (merge(ca[pos[i]], ca[neg[j]], v, resolvent) && !addClause_(resolvent))
+                return false;
+
+    for (int i = 0; i < cls.size(); i++)
+        removeClause(cls[i]); 
+
+    // Free occurs list for this variable:
+    occurs[v].clear(true);
+    
+    // Free watchers lists for this variable, if possible:
+    watches_bin[ mkLit(v)].clear(true);
+    watches_bin[~mkLit(v)].clear(true);
+    watches[ mkLit(v)].clear(true);
+    watches[~mkLit(v)].clear(true);
+
+    return backwardSubsumptionCheck();
+}
+
+
+inline bool SimpSolver::substitute(Var v, Lit x)
+{
+    assert(!frozen[v]);
+    assert(!isEliminated(v));
+    assert(value(v) == l_Undef);
+
+    if (!ok) return false;
+
+    eliminated[v] = true;
+    setDecisionVar(v, false);
+    const vec<CRef>& cls = occurs.lookup(v);
+    
+    vec<Lit>& subst_clause = add_tmp;
+    for (int i = 0; i < cls.size(); i++){
+        Clause& c = ca[cls[i]];
+
+        subst_clause.clear();
+        for (int j = 0; j < c.size(); j++){
+            Lit p = c[j];
+            subst_clause.push(var(p) == v ? x ^ sign(p) : p);
+        }
+
+        if (!addClause_(subst_clause))
+            return ok = false;
+
+        removeClause(cls[i]);
+    }
+
+    return true;
+}
+
+
+inline void SimpSolver::extendModel()
+{
+    int i, j;
+    Lit x;
+
+    for (i = elimclauses.size()-1; i > 0; i -= j){
+        for (j = elimclauses[i--]; j > 1; j--, i--)
+            if (modelValue(toLit(elimclauses[i])) != l_False)
+                goto next;
+
+        x = toLit(elimclauses[i]);
+        model[var(x)] = lbool(!sign(x));
+    next:;
+    }
+}
+
+// Almost duplicate of Solver::removeSatisfied. Didn't want to make the base method 'virtual'.
+inline void SimpSolver::removeSatisfied()
+{
+    int i, j;
+    for (i = j = 0; i < clauses.size(); i++){
+        const Clause& c = ca[clauses[i]];
+        if (c.mark() == 0)
+            if (satisfied(c))
+                removeClause(clauses[i]);
+            else
+                clauses[j++] = clauses[i];
+    }
+    clauses.shrink(i - j);
+}
+
+// The technique and code are by the courtesy of the GlueMiniSat team. Thank you!
+// It helps solving certain types of huge problems tremendously.
+inline bool SimpSolver::eliminate(bool turn_off_elim)
+{
+    bool res = true;
+    int iter = 0;
+    int n_cls, n_cls_init, n_vars;
+
+    if (nVars() == 0) goto cleanup; // User disabling preprocessing.
+
+    // Get an initial number of clauses (more accurately).
+    if (trail.size() != 0) removeSatisfied();
+    n_cls_init = nClauses();
+
+    res = eliminate_(); // The first, usual variable elimination of MiniSat.
+    if (!res) goto cleanup;
+
+    n_cls  = nClauses();
+    n_vars = nFreeVars();
+
+    // printf("c Reduced to %d vars, %d cls (grow=%d)\n", n_vars, n_cls, grow);
+
+    if ((double)n_cls / n_vars >= 10 || n_vars < 10000){
+        // printf("c No iterative elimination performed. (vars=%d, c/v ratio=%.1f)\n", n_vars, (double)n_cls / n_vars);
+        goto cleanup; }
+
+    grow = grow ? grow * 2 : 8;
+    for (; grow < 10000; grow *= 2){
+        // Rebuild elimination variable heap.
+        for (int i = 0; i < clauses.size(); i++){
+            const Clause& c = ca[clauses[i]];
+            for (int j = 0; j < c.size(); j++)
+                if (!elim_heap.inHeap(var(c[j])))
+                    elim_heap.insert(var(c[j]));
+                else
+                    elim_heap.update(var(c[j])); }
+
+        int n_cls_last = nClauses();
+        int n_vars_last = nFreeVars();
+
+        res = eliminate_();
+        if (!res || n_vars_last == nFreeVars()) break;
+        iter++;
+
+        int n_cls_now  = nClauses();
+        int n_vars_now = nFreeVars();
+
+        double cl_inc_rate  = (double)n_cls_now   / n_cls_last;
+        double var_dec_rate = (double)n_vars_last / n_vars_now;
+
+        printf("c Reduced to %d vars, %d cls (grow=%d)\n", n_vars_now, n_cls_now, grow);
+        printf("c cl_inc_rate=%.3f, var_dec_rate=%.3f\n", cl_inc_rate, var_dec_rate);
+
+        if (n_cls_now > n_cls_init || cl_inc_rate > var_dec_rate) break;
+    }
+    printf("c No. effective iterative eliminations: %d\n", iter);
+
+cleanup:
+    touched  .clear(true);
+    occurs   .clear(true);
+    n_occ    .clear(true);
+    elim_heap.clear(true);
+    subsumption_queue.clear(true);
+
+    use_simplification    = false;
+    remove_satisfied      = true;
+    ca.extra_clause_field = false;
+
+    // Force full cleanup (this is safe and desirable since it only happens once):
+    rebuildOrderHeap();
+    garbageCollect();
+
+    return res;
+}
+
+
+inline bool SimpSolver::eliminate_()
+{
+    if (!simplify())
+        return false;
+    else if (!use_simplification)
+        return true;
+
+    int trail_size_last = trail.size();
+
+    // Main simplification loop:
+    //
+    while (n_touched > 0 || bwdsub_assigns < trail.size() || elim_heap.size() > 0){
+
+        gatherTouchedClauses();
+        // printf("  ## (time = %6.2f s) BWD-SUB: queue = %d, trail = %d\n", cpuTime(), subsumption_queue.size(), trail.size() - bwdsub_assigns);
+        if ((subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()) && 
+            !backwardSubsumptionCheck(true)){
+            ok = false; goto cleanup; }
+
+        // Empty elim_heap and return immediately on user-interrupt:
+        if (asynch_interrupt){
+            assert(bwdsub_assigns == trail.size());
+            assert(subsumption_queue.size() == 0);
+            assert(n_touched == 0);
+            elim_heap.clear();
+            goto cleanup; }
+
+        // printf("  ## (time = %6.2f s) ELIM: vars = %d\n", cpuTime(), elim_heap.size());
+        for (int cnt = 0; !elim_heap.empty(); cnt++){
+            Var elim = elim_heap.removeMin();
+            
+            if (asynch_interrupt) break;
+
+            if (isEliminated(elim) || value(elim) != l_Undef) continue;
+
+            if (verbosity >= 2 && cnt % 100 == 0)
+                printf("c elimination left: %10d\r", elim_heap.size());
+
+            if (use_asymm){
+                // Temporarily freeze variable. Otherwise, it would immediately end up on the queue again:
+                bool was_frozen = frozen[elim];
+                frozen[elim] = true;
+                if (!asymmVar(elim)){
+                    ok = false; goto cleanup; }
+                frozen[elim] = was_frozen; }
+
+            // At this point, the variable may have been set by assymetric branching, so check it
+            // again. Also, don't eliminate frozen variables:
+            if (use_elim && value(elim) == l_Undef && !frozen[elim] && !eliminateVar(elim)){
+                ok = false; goto cleanup; }
+
+            checkGarbage(simp_garbage_frac);
+        }
+
+        assert(subsumption_queue.size() == 0);
+    }
+ cleanup:
+    // To get an accurate number of clauses.
+    if (trail_size_last != trail.size())
+        removeSatisfied();
+    else{
+        int i,j;
+        for (i = j = 0; i < clauses.size(); i++)
+            if (ca[clauses[i]].mark() == 0)
+                clauses[j++] = clauses[i];
+        clauses.shrink(i - j);
+    }
+    checkGarbage();
+
+    if (verbosity >= 1 && elimclauses.size() > 0)
+        printf("c |  Eliminated clauses:     %10.2f Mb                                      |\n", 
+               double(elimclauses.size() * sizeof(uint32_t)) / (1024*1024));
+
+    return ok;
+}
+
+
+//=================================================================================================
+// Garbage Collection methods:
+
+
+inline void SimpSolver::relocAll(ClauseAllocator& to)
+{
+    if (!use_simplification) return;
+
+    // All occurs lists:
+    //
+    occurs.cleanAll();
+    for (int i = 0; i < nVars(); i++){
+        vec<CRef>& cs = occurs[i];
+        for (int j = 0; j < cs.size(); j++)
+            ca.reloc(cs[j], to);
+    }
+
+    // Subsumption queue:
+    //
+    for (int i = 0; i < subsumption_queue.size(); i++)
+        ca.reloc(subsumption_queue[i], to);
+
+    // Temporary clause:
+    //
+    ca.reloc(bwdsub_tmpunit, to);
+}
+
+
+inline void SimpSolver::garbageCollect()
+{
+    // Initialize the next region to a size corresponding to the estimated utilization degree. This
+    // is not precise but should avoid some unnecessary reallocations for the new region:
+    ClauseAllocator to(ca.size() - ca.wasted()); 
+
+    to.extra_clause_field = ca.extra_clause_field; // NOTE: this is important to keep (or lose) the extra fields.
+    relocAll(to);
+    Solver::relocAll(to);
+    if (verbosity >= 2)
+        printf("c |  Garbage collection:   %12d bytes => %12d bytes             |\n", 
+               ca.size()*ClauseAllocator::Unit_Size, to.size()*ClauseAllocator::Unit_Size);
+    to.moveTo(ca);
+}
+}
+
+#undef ANTI_EXPLORATION
+#undef BIN_DRUP
+#undef INT_QUEUE_AVG
+#undef LOOSE_PROP_STAT
+#undef LOCAL
+#undef TIER2
+#undef COR
diff --git a/lib/bill/bill/sat/tseytin.hpp b/lib/bill/bill/sat/tseytin.hpp
new file mode 100644
index 0000000..c94d229
--- /dev/null
+++ b/lib/bill/bill/sat/tseytin.hpp
@@ -0,0 +1,120 @@
+/*-------------------------------------------------------------------------------------------------
+| This file is distributed under the MIT License.
+| See accompanying file /LICENSE for details.
+*------------------------------------------------------------------------------------------------*/
+#pragma once
+
+#include "interface/types.hpp"
+#include <vector>
+
+namespace bill {
+
+/*! \brief Adds CNF clauses for `y = (a and b)` to the solver.
+ *
+ * \param solver Solver
+ * \param a Literal
+ * \param b Literal
+ * \return Literal y
+ */
+template<typename Solver>
+lit_type add_tseytin_and(Solver& solver, lit_type const& a, lit_type const& b)
+{
+	auto const r = solver.add_variable();
+	solver.add_clause(std::vector{~a, ~b, lit_type(r, lit_type::polarities::positive)});
+	solver.add_clause(std::vector{a, lit_type(r, lit_type::polarities::negative)});
+	solver.add_clause(std::vector{b, lit_type(r, lit_type::polarities::negative)});
+	return lit_type(r, lit_type::polarities::positive);
+}
+
+/*! \brief Adds CNF clauses for `y = (l_0 and ... and l_{n-1})` to the solver.
+ *
+ * \param solver Solver
+ * \param ls List of literals
+ * \return Literal y
+ */
+template<typename Solver>
+lit_type add_tseytin_and(Solver& solver, std::vector<lit_type> const& ls)
+{
+	auto const r = solver.add_variable();
+	std::vector<lit_type> cls;
+	for (const auto& l : ls)
+		cls.emplace_back(~l);
+	cls.emplace_back(lit_type(r, lit_type::polarities::positive));
+	solver.add_clause(cls);
+	for (const auto& l : ls)
+		solver.add_clause(std::vector{l, lit_type(r, lit_type::polarities::negative)});
+	return lit_type(r, lit_type::polarities::positive);
+}
+
+/*! \brief Adds CNF clauses for `y = a or b` to the solver.
+ *
+ * \param solver Solver
+ * \param a Literal
+ * \param b Literal
+ * \return Literal y
+ */
+template<typename Solver>
+lit_type add_tseytin_or(Solver& solver, lit_type const& a, lit_type const& b)
+{
+	auto const r = solver.add_variable();
+	solver.add_clause(std::vector{a, b, lit_type(r, lit_type::polarities::negative)});
+	solver.add_clause(std::vector{~a, lit_type(r, lit_type::polarities::positive)});
+	solver.add_clause(std::vector{~b, lit_type(r, lit_type::polarities::positive)});
+	return lit_type(r, lit_type::polarities::positive);
+}
+
+/*! \brief Adds CNF clauses for `y = (l_0 or ... or l_{n-1})` to the solver.
+ *
+ * \param solver Solver
+ * \param ls List of literals
+ * \return Literal y
+ */
+template<typename Solver>
+lit_type add_tseytin_or(Solver& solver, std::vector<lit_type> const& ls)
+{
+	auto const r = solver.add_variable();
+	std::vector<lit_type> cls(ls);
+	cls.emplace_back(lit_type(r, lit_type::polarities::negative));
+	solver.add_clause(cls);
+	for (const auto& l : ls)
+		solver.add_clause(std::vector{~l, lit_type(r, lit_type::polarities::positive)});
+	return lit_type(r, lit_type::polarities::positive);
+}
+
+/*! \brief Adds CNF clauses for `y = (a xor b)` to the solver.
+ *
+ * \param solver Solver
+ * \param a Literal
+ * \param b Literal
+ * \return Literal y
+ */
+template<typename Solver>
+lit_type add_tseytin_xor(Solver& solver, lit_type const& a, lit_type const& b)
+{
+	auto const r = solver.add_variable();
+	solver.add_clause(std::vector{~a, ~b, lit_type(r, lit_type::polarities::negative)});
+	solver.add_clause(std::vector{~a, b, lit_type(r, lit_type::polarities::positive)});
+	solver.add_clause(std::vector{a, ~b, lit_type(r, lit_type::polarities::positive)});
+	solver.add_clause(std::vector{a, b, lit_type(r, lit_type::polarities::negative)});
+	return lit_type(r, lit_type::polarities::positive);
+}
+
+/*! \brief Adds CNF clauses for `y = (a == b)` to the solver.
+ *
+ * \param solver Solver
+ * \param a Literal
+ * \param b Literal
+ * \return Literal y
+ */
+template<typename Solver>
+lit_type add_tseytin_equals(Solver& solver, lit_type const& a, lit_type const& b)
+{
+	auto const r = solver.add_variable();
+	solver.add_clause(std::vector{~a, ~b, lit_type(r, lit_type::polarities::positive)});
+	solver.add_clause(std::vector{~a, b, lit_type(r, lit_type::polarities::negative)});
+	solver.add_clause(std::vector{a, ~b, lit_type(r, lit_type::polarities::negative)});
+	solver.add_clause(std::vector{a, b, lit_type(r, lit_type::polarities::positive)});
+	return lit_type(r, lit_type::polarities::positive);
+}
+
+} /* namespace bill */
diff --git a/lib/bill/bill/sat/unsat_cores.hpp b/lib/bill/bill/sat/unsat_cores.hpp
new file mode 100644
index 0000000..a08a636
--- /dev/null
+++ b/lib/bill/bill/sat/unsat_cores.hpp
@@ -0,0 +1,73 @@
+#pragma once
+
+namespace bill {
+
+namespace detail {
+
+template<typename T>
+inline std::vector<T> copy_vector_without_index(std::vector<T> const& vs, uint32_t index)
+{
+	assert(index < vs.size());
+	std::vector<T> copy(vs);
+	copy.erase(std::begin(copy) + index);
+	return copy;
+}
+
+} // namespace detail
+
+template<typename Solver>
+inline result::clause_type trim_core_copy(Solver& solver, result::clause_type const& core,
+                                          uint32_t num_tries = 8u)
+{
+	auto current = core;
+
+	uint32_t counter = 0u;
+	while (counter++ < num_tries && solver.solve(current) == result::states::unsatisfiable) {
+		auto const new_core = solver.get_core().core();
+		if (new_core.size() == current.size())
+			break;
+
+		current = new_core;
+	}
+
+	return current;
+}
+
+template<typename Solver>
+inline void trim_core(Solver& solver, result::clause_type& core, uint32_t num_tries = 0u)
+{
+	core = trim_core_copy(solver, core, num_tries);
+}
+
+template<typename Solver>
+inline result::clause_type minimize_core_copy(Solver& solver, result::clause_type& core,
+                                              int64_t budget = 1000)
+{
+	auto pos = 0u;
+	auto current = core;
+
+	while (pos < current.size()) {
+		auto temp = detail::copy_vector_without_index(current, pos);
+
+		auto result = solver.solve(temp, budget);
+		if (result == result::states::unsatisfiable) {
+			current = temp;
+		} else {
+			++pos;
+		}
+	}
+
+	if (current.size() < core.size()) {
+		return current;
+	} else {
+		return core;
+	}
+}
+
+template<typename Solver>
+inline void minimize_core(Solver& solver, result::clause_type& core, int64_t budget = 1000)
+{
+	core = minimize_core_copy(solver, core, budget);
+}
+
+} // namespace bill
diff --git a/lib/bill/bill/sat/xor_clauses.hpp b/lib/bill/bill/sat/xor_clauses.hpp
new file mode 100644
index 0000000..b6794b3
--- /dev/null
+++ b/lib/bill/bill/sat/xor_clauses.hpp
@@ -0,0 +1,49 @@
+/*-------------------------------------------------------------------------------------------------
+| This file is distributed under the MIT License.
+| See accompanying file /LICENSE for details.
+*------------------------------------------------------------------------------------------------*/
+#pragma once
+
+#include "interface/types.hpp"
+
+#include <queue>
+#include <vector>
+
+namespace bill {
+
+/*! \brief Adds CNF clauses for `y = ((l_0 ^ ... ^ l_{n-1}) == pol)` to the solver.
+ *
+ * \param solver Solver
+ * \param clause List of literals
+ * \param pol Clause polarity
+ * \return Literal y
+ */
+template<typename Solver>
+lit_type add_xor_clause(Solver& solver, std::vector<lit_type> const& clause,
+                        lit_type::polarities pol = lit_type::polarities::positive)
+{
+	std::queue<lit_type> lits;
+	bool first = pol == lit_type::polarities::negative;
+	for (const auto& l : clause) {
+		if (first) {
+			lits.push(~l);
+			first = false;
+		} else {
+			lits.push(l);
+		}
+	}
+
+	while (lits.size() > 1) {
+		auto const a = lits.front();
+		lits.pop();
+		auto const b = lits.front();
+		lits.pop();
+
+		lits.push(add_tseytin_xor(solver, a, b));
+	}
+
+	assert(lits.size() == 1u);
+	return lits.front();
+}
+
+} /* namespace bill */
diff --git a/lib/bill/bill/utils/hash.hpp b/lib/bill/bill/utils/hash.hpp
new file mode 100644
index 0000000..fa401b6
--- /dev/null
+++ b/lib/bill/bill/utils/hash.hpp
@@ -0,0 +1,48 @@
+/*--------------------------------------------------------------------------------------------------
+| This file is distributed under the MIT License.
+| See accompanying file /LICENSE for details.
+*-------------------------------------------------------------------------------------------------*/
+#pragma once
+
+#include <set>
+#include <utility>
+
+
+// TODO: this is a bit of a hack!
+
+namespace std {
+
+template<class T>
+inline void hash_combine(std::size_t& seed, T const& v)
+{
+	seed ^= std::hash<T>()(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+}
+
+template<typename T>
+struct hash<set<T>> {
+	using argument_type = set<T>;
+	using result_type = size_t;
+	result_type operator()(argument_type const& in) const
+	{
+		result_type seed = 0;
+		for (auto& element : in) {
+			hash_combine(seed, element);
+		}
+		return seed;
+	}
+};
+
+template<>
+struct hash<pair<uint32_t, uint32_t>> {
+	using argument_type = pair<uint32_t, uint32_t>;
+	using result_type = size_t;
+	result_type operator()(argument_type const& in) const
+	{
+		result_type seed = 0;
+		hash_combine(seed, in.first);
+		hash_combine(seed, in.second);
+		return seed;
+	}
+};
+
+} // namespace std
diff --git a/lib/bill/bill/utils/platforms.hpp b/lib/bill/bill/utils/platforms.hpp
new file mode 100644
index 0000000..2c31736
--- /dev/null
+++ b/lib/bill/bill/utils/platforms.hpp
@@ -0,0 +1,9 @@
+/*-------------------------------------------------------------------------------------------------
+| This file is distributed under the MIT License.
+| See accompanying file /LICENSE for details.
+*------------------------------------------------------------------------------------------------*/
+#pragma once
+
+#if defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
+#define BILL_WINDOWS_PLATFORM
+#endif
diff --git a/lib/fmt/LICENSE.rst b/lib/fmt/LICENSE.rst
new file mode 100644
index 0000000..eb6be65
--- /dev/null
+++ b/lib/fmt/LICENSE.rst
@@ -0,0 +1,23 @@
+Copyright (c) 2012 - 2016, Victor Zverovich
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, 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.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS 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 COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, 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.
diff --git a/lib/fmt/fmt/chrono.h b/lib/fmt/fmt/chrono.h
new file mode 100644
index 0000000..421d464
--- /dev/null
+++ b/lib/fmt/fmt/chrono.h
@@ -0,0 +1,1119 @@
+// Formatting library for C++ - chrono support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_CHRONO_H_
+#define FMT_CHRONO_H_
+
+#include <chrono>
+#include <ctime>
+#include <locale>
+#include <sstream>
+
+#include "format.h"
+#include "locale.h"
+
+FMT_BEGIN_NAMESPACE
+
+// Enable safe chrono durations, unless explicitly disabled.
+#ifndef FMT_SAFE_DURATION_CAST
+#  define FMT_SAFE_DURATION_CAST 1
+#endif
+#if FMT_SAFE_DURATION_CAST
+
+// For conversion between std::chrono::durations without undefined
+// behaviour or erroneous results.
+// This is a stripped down version of duration_cast, for inclusion in fmt.
+// See https://github.com/pauldreik/safe_duration_cast
+//
+// Copyright Paul Dreik 2019
+namespace safe_duration_cast {
+
+template <typename To, typename From,
+          FMT_ENABLE_IF(!std::is_same<From, To>::value &&
+                        std::numeric_limits<From>::is_signed ==
+                            std::numeric_limits<To>::is_signed)>
+FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
+  ec = 0;
+  using F = std::numeric_limits<From>;
+  using T = std::numeric_limits<To>;
+  static_assert(F::is_integer, "From must be integral");
+  static_assert(T::is_integer, "To must be integral");
+
+  // A and B are both signed, or both unsigned.
+  if (F::digits <= T::digits) {
+    // From fits in To without any problem.
+  } else {
+    // From does not always fit in To, resort to a dynamic check.
+    if (from < T::min() || from > T::max()) {
+      // outside range.
+      ec = 1;
+      return {};
+    }
+  }
+  return static_cast<To>(from);
+}
+
+/**
+ * converts From to To, without loss. If the dynamic value of from
+ * can't be converted to To without loss, ec is set.
+ */
+template <typename To, typename From,
+          FMT_ENABLE_IF(!std::is_same<From, To>::value &&
+                        std::numeric_limits<From>::is_signed !=
+                            std::numeric_limits<To>::is_signed)>
+FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
+  ec = 0;
+  using F = std::numeric_limits<From>;
+  using T = std::numeric_limits<To>;
+  static_assert(F::is_integer, "From must be integral");
+  static_assert(T::is_integer, "To must be integral");
+
+  if (F::is_signed && !T::is_signed) {
+    // From may be negative, not allowed!
+    if (fmt::internal::is_negative(from)) {
+      ec = 1;
+      return {};
+    }
+
+    // From is positive. Can it always fit in To?
+    if (F::digits <= T::digits) {
+      // yes, From always fits in To.
+    } else {
+      // from may not fit in To, we have to do a dynamic check
+      if (from > static_cast<From>(T::max())) {
+        ec = 1;
+        return {};
+      }
+    }
+  }
+
+  if (!F::is_signed && T::is_signed) {
+    // can from be held in To?
+    if (F::digits < T::digits) {
+      // yes, From always fits in To.
+    } else {
+      // from may not fit in To, we have to do a dynamic check
+      if (from > static_cast<From>(T::max())) {
+        // outside range.
+        ec = 1;
+        return {};
+      }
+    }
+  }
+
+  // reaching here means all is ok for lossless conversion.
+  return static_cast<To>(from);
+
+}  // function
+
+template <typename To, typename From,
+          FMT_ENABLE_IF(std::is_same<From, To>::value)>
+FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {
+  ec = 0;
+  return from;
+}  // function
+
+// clang-format off
+/**
+ * converts From to To if possible, otherwise ec is set.
+ *
+ * input                            |    output
+ * ---------------------------------|---------------
+ * NaN                              | NaN
+ * Inf                              | Inf
+ * normal, fits in output           | converted (possibly lossy)
+ * normal, does not fit in output   | ec is set
+ * subnormal                        | best effort
+ * -Inf                             | -Inf
+ */
+// clang-format on
+template <typename To, typename From,
+          FMT_ENABLE_IF(!std::is_same<From, To>::value)>
+FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {
+  ec = 0;
+  using T = std::numeric_limits<To>;
+  static_assert(std::is_floating_point<From>::value, "From must be floating");
+  static_assert(std::is_floating_point<To>::value, "To must be floating");
+
+  // catch the only happy case
+  if (std::isfinite(from)) {
+    if (from >= T::lowest() && from <= T::max()) {
+      return static_cast<To>(from);
+    }
+    // not within range.
+    ec = 1;
+    return {};
+  }
+
+  // nan and inf will be preserved
+  return static_cast<To>(from);
+}  // function
+
+template <typename To, typename From,
+          FMT_ENABLE_IF(std::is_same<From, To>::value)>
+FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {
+  ec = 0;
+  static_assert(std::is_floating_point<From>::value, "From must be floating");
+  return from;
+}
+
+/**
+ * safe duration cast between integral durations
+ */
+template <typename To, typename FromRep, typename FromPeriod,
+          FMT_ENABLE_IF(std::is_integral<FromRep>::value),
+          FMT_ENABLE_IF(std::is_integral<typename To::rep>::value)>
+To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
+                      int& ec) {
+  using From = std::chrono::duration<FromRep, FromPeriod>;
+  ec = 0;
+  // the basic idea is that we need to convert from count() in the from type
+  // to count() in the To type, by multiplying it with this:
+  struct Factor
+      : std::ratio_divide<typename From::period, typename To::period> {};
+
+  static_assert(Factor::num > 0, "num must be positive");
+  static_assert(Factor::den > 0, "den must be positive");
+
+  // the conversion is like this: multiply from.count() with Factor::num
+  // /Factor::den and convert it to To::rep, all this without
+  // overflow/underflow. let's start by finding a suitable type that can hold
+  // both To, From and Factor::num
+  using IntermediateRep =
+      typename std::common_type<typename From::rep, typename To::rep,
+                                decltype(Factor::num)>::type;
+
+  // safe conversion to IntermediateRep
+  IntermediateRep count =
+      lossless_integral_conversion<IntermediateRep>(from.count(), ec);
+  if (ec) {
+    return {};
+  }
+  // multiply with Factor::num without overflow or underflow
+  if (Factor::num != 1) {
+    const auto max1 = internal::max_value<IntermediateRep>() / Factor::num;
+    if (count > max1) {
+      ec = 1;
+      return {};
+    }
+    const auto min1 = std::numeric_limits<IntermediateRep>::min() / Factor::num;
+    if (count < min1) {
+      ec = 1;
+      return {};
+    }
+    count *= Factor::num;
+  }
+
+  // this can't go wrong, right? den>0 is checked earlier.
+  if (Factor::den != 1) {
+    count /= Factor::den;
+  }
+  // convert to the to type, safely
+  using ToRep = typename To::rep;
+  const ToRep tocount = lossless_integral_conversion<ToRep>(count, ec);
+  if (ec) {
+    return {};
+  }
+  return To{tocount};
+}
+
+/**
+ * safe duration_cast between floating point durations
+ */
+template <typename To, typename FromRep, typename FromPeriod,
+          FMT_ENABLE_IF(std::is_floating_point<FromRep>::value),
+          FMT_ENABLE_IF(std::is_floating_point<typename To::rep>::value)>
+To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
+                      int& ec) {
+  using From = std::chrono::duration<FromRep, FromPeriod>;
+  ec = 0;
+  if (std::isnan(from.count())) {
+    // nan in, gives nan out. easy.
+    return To{std::numeric_limits<typename To::rep>::quiet_NaN()};
+  }
+  // maybe we should also check if from is denormal, and decide what to do about
+  // it.
+
+  // +-inf should be preserved.
+  if (std::isinf(from.count())) {
+    return To{from.count()};
+  }
+
+  // the basic idea is that we need to convert from count() in the from type
+  // to count() in the To type, by multiplying it with this:
+  struct Factor
+      : std::ratio_divide<typename From::period, typename To::period> {};
+
+  static_assert(Factor::num > 0, "num must be positive");
+  static_assert(Factor::den > 0, "den must be positive");
+
+  // the conversion is like this: multiply from.count() with Factor::num
+  // /Factor::den and convert it to To::rep, all this without
+  // overflow/underflow. let's start by finding a suitable type that can hold
+  // both To, From and Factor::num
+  using IntermediateRep =
+      typename std::common_type<typename From::rep, typename To::rep,
+                                decltype(Factor::num)>::type;
+
+  // force conversion of From::rep -> IntermediateRep to be safe,
+  // even if it will never happen be narrowing in this context.
+  IntermediateRep count =
+      safe_float_conversion<IntermediateRep>(from.count(), ec);
+  if (ec) {
+    return {};
+  }
+
+  // multiply with Factor::num without overflow or underflow
+  if (Factor::num != 1) {
+    constexpr auto max1 = internal::max_value<IntermediateRep>() /
+                          static_cast<IntermediateRep>(Factor::num);
+    if (count > max1) {
+      ec = 1;
+      return {};
+    }
+    constexpr auto min1 = std::numeric_limits<IntermediateRep>::lowest() /
+                          static_cast<IntermediateRep>(Factor::num);
+    if (count < min1) {
+      ec = 1;
+      return {};
+    }
+    count *= static_cast<IntermediateRep>(Factor::num);
+  }
+
+  // this can't go wrong, right? den>0 is checked earlier.
+  if (Factor::den != 1) {
+    using common_t = typename std::common_type<IntermediateRep, intmax_t>::type;
+    count /= static_cast<common_t>(Factor::den);
+  }
+
+  // convert to the to type, safely
+  using ToRep = typename To::rep;
+
+  const ToRep tocount = safe_float_conversion<ToRep>(count, ec);
+  if (ec) {
+    return {};
+  }
+  return To{tocount};
+}
+}  // namespace safe_duration_cast
+#endif
+
+// Prevents expansion of a preceding token as a function-style macro.
+// Usage: f FMT_NOMACRO()
+#define FMT_NOMACRO
+
+namespace internal {
+inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); }
+inline null<> localtime_s(...) { return null<>(); }
+inline null<> gmtime_r(...) { return null<>(); }
+inline null<> gmtime_s(...) { return null<>(); }
+}  // namespace internal
+
+// Thread-safe replacement for std::localtime
+inline std::tm localtime(std::time_t time) {
+  struct dispatcher {
+    std::time_t time_;
+    std::tm tm_;
+
+    dispatcher(std::time_t t) : time_(t) {}
+
+    bool run() {
+      using namespace fmt::internal;
+      return handle(localtime_r(&time_, &tm_));
+    }
+
+    bool handle(std::tm* tm) { return tm != nullptr; }
+
+    bool handle(internal::null<>) {
+      using namespace fmt::internal;
+      return fallback(localtime_s(&tm_, &time_));
+    }
+
+    bool fallback(int res) { return res == 0; }
+
+#if !FMT_MSC_VER
+    bool fallback(internal::null<>) {
+      using namespace fmt::internal;
+      std::tm* tm = std::localtime(&time_);
+      if (tm) tm_ = *tm;
+      return tm != nullptr;
+    }
+#endif
+  };
+  dispatcher lt(time);
+  // Too big time values may be unsupported.
+  if (!lt.run()) FMT_THROW(format_error("time_t value out of range"));
+  return lt.tm_;
+}
+
+// Thread-safe replacement for std::gmtime
+inline std::tm gmtime(std::time_t time) {
+  struct dispatcher {
+    std::time_t time_;
+    std::tm tm_;
+
+    dispatcher(std::time_t t) : time_(t) {}
+
+    bool run() {
+      using namespace fmt::internal;
+      return handle(gmtime_r(&time_, &tm_));
+    }
+
+    bool handle(std::tm* tm) { return tm != nullptr; }
+
+    bool handle(internal::null<>) {
+      using namespace fmt::internal;
+      return fallback(gmtime_s(&tm_, &time_));
+    }
+
+    bool fallback(int res) { return res == 0; }
+
+#if !FMT_MSC_VER
+    bool fallback(internal::null<>) {
+      std::tm* tm = std::gmtime(&time_);
+      if (tm) tm_ = *tm;
+      return tm != nullptr;
+    }
+#endif
+  };
+  dispatcher gt(time);
+  // Too big time values may be unsupported.
+  if (!gt.run()) FMT_THROW(format_error("time_t value out of range"));
+  return gt.tm_;
+}
+
+namespace internal {
+inline std::size_t strftime(char* str, std::size_t count, const char* format,
+                            const std::tm* time) {
+  return std::strftime(str, count, format, time);
+}
+
+inline std::size_t strftime(wchar_t* str, std::size_t count,
+                            const wchar_t* format, const std::tm* time) {
+  return std::wcsftime(str, count, format, time);
+}
+}  // namespace internal
+
+template <typename Char> struct formatter<std::tm, Char> {
+  template <typename ParseContext>
+  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    auto it = ctx.begin();
+    if (it != ctx.end() && *it == ':') ++it;
+    auto end = it;
+    while (end != ctx.end() && *end != '}') ++end;
+    tm_format.reserve(internal::to_unsigned(end - it + 1));
+    tm_format.append(it, end);
+    tm_format.push_back('\0');
+    return end;
+  }
+
+  template <typename FormatContext>
+  auto format(const std::tm& tm, FormatContext& ctx) -> decltype(ctx.out()) {
+    basic_memory_buffer<Char> buf;
+    std::size_t start = buf.size();
+    for (;;) {
+      std::size_t size = buf.capacity() - start;
+      std::size_t count =
+          internal::strftime(&buf[start], size, &tm_format[0], &tm);
+      if (count != 0) {
+        buf.resize(start + count);
+        break;
+      }
+      if (size >= tm_format.size() * 256) {
+        // If the buffer is 256 times larger than the format string, assume
+        // that `strftime` gives an empty result. There doesn't seem to be a
+        // better way to distinguish the two cases:
+        // https://github.com/fmtlib/fmt/issues/367
+        break;
+      }
+      const std::size_t MIN_GROWTH = 10;
+      buf.reserve(buf.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
+    }
+    return std::copy(buf.begin(), buf.end(), ctx.out());
+  }
+
+  basic_memory_buffer<Char> tm_format;
+};
+
+namespace internal {
+template <typename Period> FMT_CONSTEXPR const char* get_units() {
+  return nullptr;
+}
+template <> FMT_CONSTEXPR const char* get_units<std::atto>() { return "as"; }
+template <> FMT_CONSTEXPR const char* get_units<std::femto>() { return "fs"; }
+template <> FMT_CONSTEXPR const char* get_units<std::pico>() { return "ps"; }
+template <> FMT_CONSTEXPR const char* get_units<std::nano>() { return "ns"; }
+template <> FMT_CONSTEXPR const char* get_units<std::micro>() { return "µs"; }
+template <> FMT_CONSTEXPR const char* get_units<std::milli>() { return "ms"; }
+template <> FMT_CONSTEXPR const char* get_units<std::centi>() { return "cs"; }
+template <> FMT_CONSTEXPR const char* get_units<std::deci>() { return "ds"; }
+template <> FMT_CONSTEXPR const char* get_units<std::ratio<1>>() { return "s"; }
+template <> FMT_CONSTEXPR const char* get_units<std::deca>() { return "das"; }
+template <> FMT_CONSTEXPR const char* get_units<std::hecto>() { return "hs"; }
+template <> FMT_CONSTEXPR const char* get_units<std::kilo>() { return "ks"; }
+template <> FMT_CONSTEXPR const char* get_units<std::mega>() { return "Ms"; }
+template <> FMT_CONSTEXPR const char* get_units<std::giga>() { return "Gs"; }
+template <> FMT_CONSTEXPR const char* get_units<std::tera>() { return "Ts"; }
+template <> FMT_CONSTEXPR const char* get_units<std::peta>() { return "Ps"; }
+template <> FMT_CONSTEXPR const char* get_units<std::exa>() { return "Es"; }
+template <> FMT_CONSTEXPR const char* get_units<std::ratio<60>>() {
+  return "m";
+}
+template <> FMT_CONSTEXPR const char* get_units<std::ratio<3600>>() {
+  return "h";
+}
+
+enum class numeric_system {
+  standard,
+  // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale.
+  alternative
+};
+
+// Parses a put_time-like format string and invokes handler actions.
+template <typename Char, typename Handler>
+FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin,
+                                              const Char* end,
+                                              Handler&& handler) {
+  auto ptr = begin;
+  while (ptr != end) {
+    auto c = *ptr;
+    if (c == '}') break;
+    if (c != '%') {
+      ++ptr;
+      continue;
+    }
+    if (begin != ptr) handler.on_text(begin, ptr);
+    ++ptr;  // consume '%'
+    if (ptr == end) FMT_THROW(format_error("invalid format"));
+    c = *ptr++;
+    switch (c) {
+    case '%':
+      handler.on_text(ptr - 1, ptr);
+      break;
+    case 'n': {
+      const Char newline[] = {'\n'};
+      handler.on_text(newline, newline + 1);
+      break;
+    }
+    case 't': {
+      const Char tab[] = {'\t'};
+      handler.on_text(tab, tab + 1);
+      break;
+    }
+    // Day of the week:
+    case 'a':
+      handler.on_abbr_weekday();
+      break;
+    case 'A':
+      handler.on_full_weekday();
+      break;
+    case 'w':
+      handler.on_dec0_weekday(numeric_system::standard);
+      break;
+    case 'u':
+      handler.on_dec1_weekday(numeric_system::standard);
+      break;
+    // Month:
+    case 'b':
+      handler.on_abbr_month();
+      break;
+    case 'B':
+      handler.on_full_month();
+      break;
+    // Hour, minute, second:
+    case 'H':
+      handler.on_24_hour(numeric_system::standard);
+      break;
+    case 'I':
+      handler.on_12_hour(numeric_system::standard);
+      break;
+    case 'M':
+      handler.on_minute(numeric_system::standard);
+      break;
+    case 'S':
+      handler.on_second(numeric_system::standard);
+      break;
+    // Other:
+    case 'c':
+      handler.on_datetime(numeric_system::standard);
+      break;
+    case 'x':
+      handler.on_loc_date(numeric_system::standard);
+      break;
+    case 'X':
+      handler.on_loc_time(numeric_system::standard);
+      break;
+    case 'D':
+      handler.on_us_date();
+      break;
+    case 'F':
+      handler.on_iso_date();
+      break;
+    case 'r':
+      handler.on_12_hour_time();
+      break;
+    case 'R':
+      handler.on_24_hour_time();
+      break;
+    case 'T':
+      handler.on_iso_time();
+      break;
+    case 'p':
+      handler.on_am_pm();
+      break;
+    case 'Q':
+      handler.on_duration_value();
+      break;
+    case 'q':
+      handler.on_duration_unit();
+      break;
+    case 'z':
+      handler.on_utc_offset();
+      break;
+    case 'Z':
+      handler.on_tz_name();
+      break;
+    // Alternative representation:
+    case 'E': {
+      if (ptr == end) FMT_THROW(format_error("invalid format"));
+      c = *ptr++;
+      switch (c) {
+      case 'c':
+        handler.on_datetime(numeric_system::alternative);
+        break;
+      case 'x':
+        handler.on_loc_date(numeric_system::alternative);
+        break;
+      case 'X':
+        handler.on_loc_time(numeric_system::alternative);
+        break;
+      default:
+        FMT_THROW(format_error("invalid format"));
+      }
+      break;
+    }
+    case 'O':
+      if (ptr == end) FMT_THROW(format_error("invalid format"));
+      c = *ptr++;
+      switch (c) {
+      case 'w':
+        handler.on_dec0_weekday(numeric_system::alternative);
+        break;
+      case 'u':
+        handler.on_dec1_weekday(numeric_system::alternative);
+        break;
+      case 'H':
+        handler.on_24_hour(numeric_system::alternative);
+        break;
+      case 'I':
+        handler.on_12_hour(numeric_system::alternative);
+        break;
+      case 'M':
+        handler.on_minute(numeric_system::alternative);
+        break;
+      case 'S':
+        handler.on_second(numeric_system::alternative);
+        break;
+      default:
+        FMT_THROW(format_error("invalid format"));
+      }
+      break;
+    default:
+      FMT_THROW(format_error("invalid format"));
+    }
+    begin = ptr;
+  }
+  if (begin != ptr) handler.on_text(begin, ptr);
+  return ptr;
+}
+
+struct chrono_format_checker {
+  FMT_NORETURN void report_no_date() { FMT_THROW(format_error("no date")); }
+
+  template <typename Char> void on_text(const Char*, const Char*) {}
+  FMT_NORETURN void on_abbr_weekday() { report_no_date(); }
+  FMT_NORETURN void on_full_weekday() { report_no_date(); }
+  FMT_NORETURN void on_dec0_weekday(numeric_system) { report_no_date(); }
+  FMT_NORETURN void on_dec1_weekday(numeric_system) { report_no_date(); }
+  FMT_NORETURN void on_abbr_month() { report_no_date(); }
+  FMT_NORETURN void on_full_month() { report_no_date(); }
+  void on_24_hour(numeric_system) {}
+  void on_12_hour(numeric_system) {}
+  void on_minute(numeric_system) {}
+  void on_second(numeric_system) {}
+  FMT_NORETURN void on_datetime(numeric_system) { report_no_date(); }
+  FMT_NORETURN void on_loc_date(numeric_system) { report_no_date(); }
+  FMT_NORETURN void on_loc_time(numeric_system) { report_no_date(); }
+  FMT_NORETURN void on_us_date() { report_no_date(); }
+  FMT_NORETURN void on_iso_date() { report_no_date(); }
+  void on_12_hour_time() {}
+  void on_24_hour_time() {}
+  void on_iso_time() {}
+  void on_am_pm() {}
+  void on_duration_value() {}
+  void on_duration_unit() {}
+  FMT_NORETURN void on_utc_offset() { report_no_date(); }
+  FMT_NORETURN void on_tz_name() { report_no_date(); }
+};
+
+template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+inline bool isnan(T) {
+  return false;
+}
+template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+inline bool isnan(T value) {
+  return std::isnan(value);
+}
+
+template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+inline bool isfinite(T) {
+  return true;
+}
+template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+inline bool isfinite(T value) {
+  return std::isfinite(value);
+}
+
+// Converts value to int and checks that it's in the range [0, upper).
+template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+inline int to_nonnegative_int(T value, int upper) {
+  FMT_ASSERT(value >= 0 && value <= upper, "invalid value");
+  (void)upper;
+  return static_cast<int>(value);
+}
+template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+inline int to_nonnegative_int(T value, int upper) {
+  FMT_ASSERT(
+      std::isnan(value) || (value >= 0 && value <= static_cast<T>(upper)),
+      "invalid value");
+  (void)upper;
+  return static_cast<int>(value);
+}
+
+template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+inline T mod(T x, int y) {
+  return x % static_cast<T>(y);
+}
+template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+inline T mod(T x, int y) {
+  return std::fmod(x, static_cast<T>(y));
+}
+
+// If T is an integral type, maps T to its unsigned counterpart, otherwise
+// leaves it unchanged (unlike std::make_unsigned).
+template <typename T, bool INTEGRAL = std::is_integral<T>::value>
+struct make_unsigned_or_unchanged {
+  using type = T;
+};
+
+template <typename T> struct make_unsigned_or_unchanged<T, true> {
+  using type = typename std::make_unsigned<T>::type;
+};
+
+#if FMT_SAFE_DURATION_CAST
+// throwing version of safe_duration_cast
+template <typename To, typename FromRep, typename FromPeriod>
+To fmt_safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) {
+  int ec;
+  To to = safe_duration_cast::safe_duration_cast<To>(from, ec);
+  if (ec) FMT_THROW(format_error("cannot format duration"));
+  return to;
+}
+#endif
+
+template <typename Rep, typename Period,
+          FMT_ENABLE_IF(std::is_integral<Rep>::value)>
+inline std::chrono::duration<Rep, std::milli> get_milliseconds(
+    std::chrono::duration<Rep, Period> d) {
+  // this may overflow and/or the result may not fit in the
+  // target type.
+#if FMT_SAFE_DURATION_CAST
+  using CommonSecondsType =
+      typename std::common_type<decltype(d), std::chrono::seconds>::type;
+  const auto d_as_common = fmt_safe_duration_cast<CommonSecondsType>(d);
+  const auto d_as_whole_seconds =
+      fmt_safe_duration_cast<std::chrono::seconds>(d_as_common);
+  // this conversion should be nonproblematic
+  const auto diff = d_as_common - d_as_whole_seconds;
+  const auto ms =
+      fmt_safe_duration_cast<std::chrono::duration<Rep, std::milli>>(diff);
+  return ms;
+#else
+  auto s = std::chrono::duration_cast<std::chrono::seconds>(d);
+  return std::chrono::duration_cast<std::chrono::milliseconds>(d - s);
+#endif
+}
+
+template <typename Rep, typename Period,
+          FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
+inline std::chrono::duration<Rep, std::milli> get_milliseconds(
+    std::chrono::duration<Rep, Period> d) {
+  using common_type = typename std::common_type<Rep, std::intmax_t>::type;
+  auto ms = mod(d.count() * static_cast<common_type>(Period::num) /
+                    static_cast<common_type>(Period::den) * 1000,
+                1000);
+  return std::chrono::duration<Rep, std::milli>(static_cast<Rep>(ms));
+}
+
+template <typename Char, typename Rep, typename OutputIt>
+OutputIt format_duration_value(OutputIt out, Rep val, int precision) {
+  const Char pr_f[] = {'{', ':', '.', '{', '}', 'f', '}', 0};
+  if (precision >= 0) return format_to(out, pr_f, val, precision);
+  const Char fp_f[] = {'{', ':', 'g', '}', 0};
+  const Char format[] = {'{', '}', 0};
+  return format_to(out, std::is_floating_point<Rep>::value ? fp_f : format,
+                   val);
+}
+
+template <typename Char, typename Period, typename OutputIt>
+OutputIt format_duration_unit(OutputIt out) {
+  if (const char* unit = get_units<Period>()) {
+    string_view s(unit);
+    if (const_check(std::is_same<Char, wchar_t>())) {
+      utf8_to_utf16 u(s);
+      return std::copy(u.c_str(), u.c_str() + u.size(), out);
+    }
+    return std::copy(s.begin(), s.end(), out);
+  }
+  const Char num_f[] = {'[', '{', '}', ']', 's', 0};
+  if (Period::den == 1) return format_to(out, num_f, Period::num);
+  const Char num_def_f[] = {'[', '{', '}', '/', '{', '}', ']', 's', 0};
+  return format_to(out, num_def_f, Period::num, Period::den);
+}
+
+template <typename FormatContext, typename OutputIt, typename Rep,
+          typename Period>
+struct chrono_formatter {
+  FormatContext& context;
+  OutputIt out;
+  int precision;
+  // rep is unsigned to avoid overflow.
+  using rep =
+      conditional_t<std::is_integral<Rep>::value && sizeof(Rep) < sizeof(int),
+                    unsigned, typename make_unsigned_or_unchanged<Rep>::type>;
+  rep val;
+  using seconds = std::chrono::duration<rep>;
+  seconds s;
+  using milliseconds = std::chrono::duration<rep, std::milli>;
+  bool negative;
+
+  using char_type = typename FormatContext::char_type;
+
+  explicit chrono_formatter(FormatContext& ctx, OutputIt o,
+                            std::chrono::duration<Rep, Period> d)
+      : context(ctx),
+        out(o),
+        val(static_cast<rep>(d.count())),
+        negative(false) {
+    if (d.count() < 0) {
+      val = 0 - val;
+      negative = true;
+    }
+
+    // this may overflow and/or the result may not fit in the
+    // target type.
+#if FMT_SAFE_DURATION_CAST
+    // might need checked conversion (rep!=Rep)
+    auto tmpval = std::chrono::duration<rep, Period>(val);
+    s = fmt_safe_duration_cast<seconds>(tmpval);
+#else
+    s = std::chrono::duration_cast<seconds>(
+        std::chrono::duration<rep, Period>(val));
+#endif
+  }
+
+  // returns true if nan or inf, writes to out.
+  bool handle_nan_inf() {
+    if (isfinite(val)) {
+      return false;
+    }
+    if (isnan(val)) {
+      write_nan();
+      return true;
+    }
+    // must be +-inf
+    if (val > 0) {
+      write_pinf();
+    } else {
+      write_ninf();
+    }
+    return true;
+  }
+
+  Rep hour() const { return static_cast<Rep>(mod((s.count() / 3600), 24)); }
+
+  Rep hour12() const {
+    Rep hour = static_cast<Rep>(mod((s.count() / 3600), 12));
+    return hour <= 0 ? 12 : hour;
+  }
+
+  Rep minute() const { return static_cast<Rep>(mod((s.count() / 60), 60)); }
+  Rep second() const { return static_cast<Rep>(mod(s.count(), 60)); }
+
+  std::tm time() const {
+    auto time = std::tm();
+    time.tm_hour = to_nonnegative_int(hour(), 24);
+    time.tm_min = to_nonnegative_int(minute(), 60);
+    time.tm_sec = to_nonnegative_int(second(), 60);
+    return time;
+  }
+
+  void write_sign() {
+    if (negative) {
+      *out++ = '-';
+      negative = false;
+    }
+  }
+
+  void write(Rep value, int width) {
+    write_sign();
+    if (isnan(value)) return write_nan();
+    uint32_or_64_or_128_t<int> n =
+        to_unsigned(to_nonnegative_int(value, max_value<int>()));
+    int num_digits = internal::count_digits(n);
+    if (width > num_digits) out = std::fill_n(out, width - num_digits, '0');
+    out = format_decimal<char_type>(out, n, num_digits);
+  }
+
+  void write_nan() { std::copy_n("nan", 3, out); }
+  void write_pinf() { std::copy_n("inf", 3, out); }
+  void write_ninf() { std::copy_n("-inf", 4, out); }
+
+  void format_localized(const tm& time, char format, char modifier = 0) {
+    if (isnan(val)) return write_nan();
+    auto locale = context.locale().template get<std::locale>();
+    auto& facet = std::use_facet<std::time_put<char_type>>(locale);
+    std::basic_ostringstream<char_type> os;
+    os.imbue(locale);
+    facet.put(os, os, ' ', &time, format, modifier);
+    auto str = os.str();
+    std::copy(str.begin(), str.end(), out);
+  }
+
+  void on_text(const char_type* begin, const char_type* end) {
+    std::copy(begin, end, out);
+  }
+
+  // These are not implemented because durations don't have date information.
+  void on_abbr_weekday() {}
+  void on_full_weekday() {}
+  void on_dec0_weekday(numeric_system) {}
+  void on_dec1_weekday(numeric_system) {}
+  void on_abbr_month() {}
+  void on_full_month() {}
+  void on_datetime(numeric_system) {}
+  void on_loc_date(numeric_system) {}
+  void on_loc_time(numeric_system) {}
+  void on_us_date() {}
+  void on_iso_date() {}
+  void on_utc_offset() {}
+  void on_tz_name() {}
+
+  void on_24_hour(numeric_system ns) {
+    if (handle_nan_inf()) return;
+
+    if (ns == numeric_system::standard) return write(hour(), 2);
+    auto time = tm();
+    time.tm_hour = to_nonnegative_int(hour(), 24);
+    format_localized(time, 'H', 'O');
+  }
+
+  void on_12_hour(numeric_system ns) {
+    if (handle_nan_inf()) return;
+
+    if (ns == numeric_system::standard) return write(hour12(), 2);
+    auto time = tm();
+    time.tm_hour = to_nonnegative_int(hour12(), 12);
+    format_localized(time, 'I', 'O');
+  }
+
+  void on_minute(numeric_system ns) {
+    if (handle_nan_inf()) return;
+
+    if (ns == numeric_system::standard) return write(minute(), 2);
+    auto time = tm();
+    time.tm_min = to_nonnegative_int(minute(), 60);
+    format_localized(time, 'M', 'O');
+  }
+
+  void on_second(numeric_system ns) {
+    if (handle_nan_inf()) return;
+
+    if (ns == numeric_system::standard) {
+      write(second(), 2);
+#if FMT_SAFE_DURATION_CAST
+      // convert rep->Rep
+      using duration_rep = std::chrono::duration<rep, Period>;
+      using duration_Rep = std::chrono::duration<Rep, Period>;
+      auto tmpval = fmt_safe_duration_cast<duration_Rep>(duration_rep{val});
+#else
+      auto tmpval = std::chrono::duration<Rep, Period>(val);
+#endif
+      auto ms = get_milliseconds(tmpval);
+      if (ms != std::chrono::milliseconds(0)) {
+        *out++ = '.';
+        write(ms.count(), 3);
+      }
+      return;
+    }
+    auto time = tm();
+    time.tm_sec = to_nonnegative_int(second(), 60);
+    format_localized(time, 'S', 'O');
+  }
+
+  void on_12_hour_time() {
+    if (handle_nan_inf()) return;
+    format_localized(time(), 'r');
+  }
+
+  void on_24_hour_time() {
+    if (handle_nan_inf()) {
+      *out++ = ':';
+      handle_nan_inf();
+      return;
+    }
+
+    write(hour(), 2);
+    *out++ = ':';
+    write(minute(), 2);
+  }
+
+  void on_iso_time() {
+    on_24_hour_time();
+    *out++ = ':';
+    if (handle_nan_inf()) return;
+    write(second(), 2);
+  }
+
+  void on_am_pm() {
+    if (handle_nan_inf()) return;
+    format_localized(time(), 'p');
+  }
+
+  void on_duration_value() {
+    if (handle_nan_inf()) return;
+    write_sign();
+    out = format_duration_value<char_type>(out, val, precision);
+  }
+
+  void on_duration_unit() {
+    out = format_duration_unit<char_type, Period>(out);
+  }
+};
+}  // namespace internal
+
+template <typename Rep, typename Period, typename Char>
+struct formatter<std::chrono::duration<Rep, Period>, Char> {
+ private:
+  basic_format_specs<Char> specs;
+  int precision;
+  using arg_ref_type = internal::arg_ref<Char>;
+  arg_ref_type width_ref;
+  arg_ref_type precision_ref;
+  mutable basic_string_view<Char> format_str;
+  using duration = std::chrono::duration<Rep, Period>;
+
+  struct spec_handler {
+    formatter& f;
+    basic_format_parse_context<Char>& context;
+    basic_string_view<Char> format_str;
+
+    template <typename Id> FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id) {
+      context.check_arg_id(arg_id);
+      return arg_ref_type(arg_id);
+    }
+
+    FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<Char> arg_id) {
+      context.check_arg_id(arg_id);
+      return arg_ref_type(arg_id);
+    }
+
+    FMT_CONSTEXPR arg_ref_type make_arg_ref(internal::auto_id) {
+      return arg_ref_type(context.next_arg_id());
+    }
+
+    void on_error(const char* msg) { FMT_THROW(format_error(msg)); }
+    void on_fill(basic_string_view<Char> fill) { f.specs.fill = fill; }
+    void on_align(align_t align) { f.specs.align = align; }
+    void on_width(int width) { f.specs.width = width; }
+    void on_precision(int _precision) { f.precision = _precision; }
+    void end_precision() {}
+
+    template <typename Id> void on_dynamic_width(Id arg_id) {
+      f.width_ref = make_arg_ref(arg_id);
+    }
+
+    template <typename Id> void on_dynamic_precision(Id arg_id) {
+      f.precision_ref = make_arg_ref(arg_id);
+    }
+  };
+
+  using iterator = typename basic_format_parse_context<Char>::iterator;
+  struct parse_range {
+    iterator begin;
+    iterator end;
+  };
+
+  FMT_CONSTEXPR parse_range do_parse(basic_format_parse_context<Char>& ctx) {
+    auto begin = ctx.begin(), end = ctx.end();
+    if (begin == end || *begin == '}') return {begin, begin};
+    spec_handler handler{*this, ctx, format_str};
+    begin = internal::parse_align(begin, end, handler);
+    if (begin == end) return {begin, begin};
+    begin = internal::parse_width(begin, end, handler);
+    if (begin == end) return {begin, begin};
+    if (*begin == '.') {
+      if (std::is_floating_point<Rep>::value)
+        begin = internal::parse_precision(begin, end, handler);
+      else
+        handler.on_error("precision not allowed for this argument type");
+    }
+    end = parse_chrono_format(begin, end, internal::chrono_format_checker());
+    return {begin, end};
+  }
+
+ public:
+  formatter() : precision(-1) {}
+
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    auto range = do_parse(ctx);
+    format_str = basic_string_view<Char>(
+        &*range.begin, internal::to_unsigned(range.end - range.begin));
+    return range.end;
+  }
+
+  template <typename FormatContext>
+  auto format(const duration& d, FormatContext& ctx) -> decltype(ctx.out()) {
+    auto begin = format_str.begin(), end = format_str.end();
+    // As a possible future optimization, we could avoid extra copying if width
+    // is not specified.
+    basic_memory_buffer<Char> buf;
+    auto out = std::back_inserter(buf);
+    using range = internal::output_range<decltype(ctx.out()), Char>;
+    internal::basic_writer<range> w(range(ctx.out()));
+    internal::handle_dynamic_spec<internal::width_checker>(specs.width,
+                                                           width_ref, ctx);
+    internal::handle_dynamic_spec<internal::precision_checker>(
+        precision, precision_ref, ctx);
+    if (begin == end || *begin == '}') {
+      out = internal::format_duration_value<Char>(out, d.count(), precision);
+      internal::format_duration_unit<Char, Period>(out);
+    } else {
+      internal::chrono_formatter<FormatContext, decltype(out), Rep, Period> f(
+          ctx, out, d);
+      f.precision = precision;
+      parse_chrono_format(begin, end, f);
+    }
+    w.write(buf.data(), buf.size(), specs);
+    return w.out();
+  }
+};
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_CHRONO_H_
diff --git a/lib/fmt/fmt/color.h b/lib/fmt/fmt/color.h
new file mode 100644
index 0000000..96d9ab6
--- /dev/null
+++ b/lib/fmt/fmt/color.h
@@ -0,0 +1,568 @@
+// Formatting library for C++ - color support
+//
+// Copyright (c) 2018 - present, Victor Zverovich and fmt contributors
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_COLOR_H_
+#define FMT_COLOR_H_
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+
+enum class color : uint32_t {
+  alice_blue = 0xF0F8FF,               // rgb(240,248,255)
+  antique_white = 0xFAEBD7,            // rgb(250,235,215)
+  aqua = 0x00FFFF,                     // rgb(0,255,255)
+  aquamarine = 0x7FFFD4,               // rgb(127,255,212)
+  azure = 0xF0FFFF,                    // rgb(240,255,255)
+  beige = 0xF5F5DC,                    // rgb(245,245,220)
+  bisque = 0xFFE4C4,                   // rgb(255,228,196)
+  black = 0x000000,                    // rgb(0,0,0)
+  blanched_almond = 0xFFEBCD,          // rgb(255,235,205)
+  blue = 0x0000FF,                     // rgb(0,0,255)
+  blue_violet = 0x8A2BE2,              // rgb(138,43,226)
+  brown = 0xA52A2A,                    // rgb(165,42,42)
+  burly_wood = 0xDEB887,               // rgb(222,184,135)
+  cadet_blue = 0x5F9EA0,               // rgb(95,158,160)
+  chartreuse = 0x7FFF00,               // rgb(127,255,0)
+  chocolate = 0xD2691E,                // rgb(210,105,30)
+  coral = 0xFF7F50,                    // rgb(255,127,80)
+  cornflower_blue = 0x6495ED,          // rgb(100,149,237)
+  cornsilk = 0xFFF8DC,                 // rgb(255,248,220)
+  crimson = 0xDC143C,                  // rgb(220,20,60)
+  cyan = 0x00FFFF,                     // rgb(0,255,255)
+  dark_blue = 0x00008B,                // rgb(0,0,139)
+  dark_cyan = 0x008B8B,                // rgb(0,139,139)
+  dark_golden_rod = 0xB8860B,          // rgb(184,134,11)
+  dark_gray = 0xA9A9A9,                // rgb(169,169,169)
+  dark_green = 0x006400,               // rgb(0,100,0)
+  dark_khaki = 0xBDB76B,               // rgb(189,183,107)
+  dark_magenta = 0x8B008B,             // rgb(139,0,139)
+  dark_olive_green = 0x556B2F,         // rgb(85,107,47)
+  dark_orange = 0xFF8C00,              // rgb(255,140,0)
+  dark_orchid = 0x9932CC,              // rgb(153,50,204)
+  dark_red = 0x8B0000,                 // rgb(139,0,0)
+  dark_salmon = 0xE9967A,              // rgb(233,150,122)
+  dark_sea_green = 0x8FBC8F,           // rgb(143,188,143)
+  dark_slate_blue = 0x483D8B,          // rgb(72,61,139)
+  dark_slate_gray = 0x2F4F4F,          // rgb(47,79,79)
+  dark_turquoise = 0x00CED1,           // rgb(0,206,209)
+  dark_violet = 0x9400D3,              // rgb(148,0,211)
+  deep_pink = 0xFF1493,                // rgb(255,20,147)
+  deep_sky_blue = 0x00BFFF,            // rgb(0,191,255)
+  dim_gray = 0x696969,                 // rgb(105,105,105)
+  dodger_blue = 0x1E90FF,              // rgb(30,144,255)
+  fire_brick = 0xB22222,               // rgb(178,34,34)
+  floral_white = 0xFFFAF0,             // rgb(255,250,240)
+  forest_green = 0x228B22,             // rgb(34,139,34)
+  fuchsia = 0xFF00FF,                  // rgb(255,0,255)
+  gainsboro = 0xDCDCDC,                // rgb(220,220,220)
+  ghost_white = 0xF8F8FF,              // rgb(248,248,255)
+  gold = 0xFFD700,                     // rgb(255,215,0)
+  golden_rod = 0xDAA520,               // rgb(218,165,32)
+  gray = 0x808080,                     // rgb(128,128,128)
+  green = 0x008000,                    // rgb(0,128,0)
+  green_yellow = 0xADFF2F,             // rgb(173,255,47)
+  honey_dew = 0xF0FFF0,                // rgb(240,255,240)
+  hot_pink = 0xFF69B4,                 // rgb(255,105,180)
+  indian_red = 0xCD5C5C,               // rgb(205,92,92)
+  indigo = 0x4B0082,                   // rgb(75,0,130)
+  ivory = 0xFFFFF0,                    // rgb(255,255,240)
+  khaki = 0xF0E68C,                    // rgb(240,230,140)
+  lavender = 0xE6E6FA,                 // rgb(230,230,250)
+  lavender_blush = 0xFFF0F5,           // rgb(255,240,245)
+  lawn_green = 0x7CFC00,               // rgb(124,252,0)
+  lemon_chiffon = 0xFFFACD,            // rgb(255,250,205)
+  light_blue = 0xADD8E6,               // rgb(173,216,230)
+  light_coral = 0xF08080,              // rgb(240,128,128)
+  light_cyan = 0xE0FFFF,               // rgb(224,255,255)
+  light_golden_rod_yellow = 0xFAFAD2,  // rgb(250,250,210)
+  light_gray = 0xD3D3D3,               // rgb(211,211,211)
+  light_green = 0x90EE90,              // rgb(144,238,144)
+  light_pink = 0xFFB6C1,               // rgb(255,182,193)
+  light_salmon = 0xFFA07A,             // rgb(255,160,122)
+  light_sea_green = 0x20B2AA,          // rgb(32,178,170)
+  light_sky_blue = 0x87CEFA,           // rgb(135,206,250)
+  light_slate_gray = 0x778899,         // rgb(119,136,153)
+  light_steel_blue = 0xB0C4DE,         // rgb(176,196,222)
+  light_yellow = 0xFFFFE0,             // rgb(255,255,224)
+  lime = 0x00FF00,                     // rgb(0,255,0)
+  lime_green = 0x32CD32,               // rgb(50,205,50)
+  linen = 0xFAF0E6,                    // rgb(250,240,230)
+  magenta = 0xFF00FF,                  // rgb(255,0,255)
+  maroon = 0x800000,                   // rgb(128,0,0)
+  medium_aquamarine = 0x66CDAA,        // rgb(102,205,170)
+  medium_blue = 0x0000CD,              // rgb(0,0,205)
+  medium_orchid = 0xBA55D3,            // rgb(186,85,211)
+  medium_purple = 0x9370DB,            // rgb(147,112,219)
+  medium_sea_green = 0x3CB371,         // rgb(60,179,113)
+  medium_slate_blue = 0x7B68EE,        // rgb(123,104,238)
+  medium_spring_green = 0x00FA9A,      // rgb(0,250,154)
+  medium_turquoise = 0x48D1CC,         // rgb(72,209,204)
+  medium_violet_red = 0xC71585,        // rgb(199,21,133)
+  midnight_blue = 0x191970,            // rgb(25,25,112)
+  mint_cream = 0xF5FFFA,               // rgb(245,255,250)
+  misty_rose = 0xFFE4E1,               // rgb(255,228,225)
+  moccasin = 0xFFE4B5,                 // rgb(255,228,181)
+  navajo_white = 0xFFDEAD,             // rgb(255,222,173)
+  navy = 0x000080,                     // rgb(0,0,128)
+  old_lace = 0xFDF5E6,                 // rgb(253,245,230)
+  olive = 0x808000,                    // rgb(128,128,0)
+  olive_drab = 0x6B8E23,               // rgb(107,142,35)
+  orange = 0xFFA500,                   // rgb(255,165,0)
+  orange_red = 0xFF4500,               // rgb(255,69,0)
+  orchid = 0xDA70D6,                   // rgb(218,112,214)
+  pale_golden_rod = 0xEEE8AA,          // rgb(238,232,170)
+  pale_green = 0x98FB98,               // rgb(152,251,152)
+  pale_turquoise = 0xAFEEEE,           // rgb(175,238,238)
+  pale_violet_red = 0xDB7093,          // rgb(219,112,147)
+  papaya_whip = 0xFFEFD5,              // rgb(255,239,213)
+  peach_puff = 0xFFDAB9,               // rgb(255,218,185)
+  peru = 0xCD853F,                     // rgb(205,133,63)
+  pink = 0xFFC0CB,                     // rgb(255,192,203)
+  plum = 0xDDA0DD,                     // rgb(221,160,221)
+  powder_blue = 0xB0E0E6,              // rgb(176,224,230)
+  purple = 0x800080,                   // rgb(128,0,128)
+  rebecca_purple = 0x663399,           // rgb(102,51,153)
+  red = 0xFF0000,                      // rgb(255,0,0)
+  rosy_brown = 0xBC8F8F,               // rgb(188,143,143)
+  royal_blue = 0x4169E1,               // rgb(65,105,225)
+  saddle_brown = 0x8B4513,             // rgb(139,69,19)
+  salmon = 0xFA8072,                   // rgb(250,128,114)
+  sandy_brown = 0xF4A460,              // rgb(244,164,96)
+  sea_green = 0x2E8B57,                // rgb(46,139,87)
+  sea_shell = 0xFFF5EE,                // rgb(255,245,238)
+  sienna = 0xA0522D,                   // rgb(160,82,45)
+  silver = 0xC0C0C0,                   // rgb(192,192,192)
+  sky_blue = 0x87CEEB,                 // rgb(135,206,235)
+  slate_blue = 0x6A5ACD,               // rgb(106,90,205)
+  slate_gray = 0x708090,               // rgb(112,128,144)
+  snow = 0xFFFAFA,                     // rgb(255,250,250)
+  spring_green = 0x00FF7F,             // rgb(0,255,127)
+  steel_blue = 0x4682B4,               // rgb(70,130,180)
+  tan = 0xD2B48C,                      // rgb(210,180,140)
+  teal = 0x008080,                     // rgb(0,128,128)
+  thistle = 0xD8BFD8,                  // rgb(216,191,216)
+  tomato = 0xFF6347,                   // rgb(255,99,71)
+  turquoise = 0x40E0D0,                // rgb(64,224,208)
+  violet = 0xEE82EE,                   // rgb(238,130,238)
+  wheat = 0xF5DEB3,                    // rgb(245,222,179)
+  white = 0xFFFFFF,                    // rgb(255,255,255)
+  white_smoke = 0xF5F5F5,              // rgb(245,245,245)
+  yellow = 0xFFFF00,                   // rgb(255,255,0)
+  yellow_green = 0x9ACD32              // rgb(154,205,50)
+};                                     // enum class color
+
+enum class terminal_color : uint8_t {
+  black = 30,
+  red,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  white,
+  bright_black = 90,
+  bright_red,
+  bright_green,
+  bright_yellow,
+  bright_blue,
+  bright_magenta,
+  bright_cyan,
+  bright_white
+};
+
+enum class emphasis : uint8_t {
+  bold = 1,
+  italic = 1 << 1,
+  underline = 1 << 2,
+  strikethrough = 1 << 3
+};
+
+// rgb is a struct for red, green and blue colors.
+// Using the name "rgb" makes some editors show the color in a tooltip.
+struct rgb {
+  FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {}
+  FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {}
+  FMT_CONSTEXPR rgb(uint32_t hex)
+      : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}
+  FMT_CONSTEXPR rgb(color hex)
+      : r((uint32_t(hex) >> 16) & 0xFF),
+        g((uint32_t(hex) >> 8) & 0xFF),
+        b(uint32_t(hex) & 0xFF) {}
+  uint8_t r;
+  uint8_t g;
+  uint8_t b;
+};
+
+namespace internal {
+
+// color is a struct of either a rgb color or a terminal color.
+struct color_type {
+  FMT_CONSTEXPR color_type() FMT_NOEXCEPT : is_rgb(), value{} {}
+  FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT : is_rgb(true),
+                                                           value{} {
+    value.rgb_color = static_cast<uint32_t>(rgb_color);
+  }
+  FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT : is_rgb(true), value{} {
+    value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
+                      (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
+  }
+  FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT : is_rgb(),
+                                                                     value{} {
+    value.term_color = static_cast<uint8_t>(term_color);
+  }
+  bool is_rgb;
+  union color_union {
+    uint8_t term_color;
+    uint32_t rgb_color;
+  } value;
+};
+}  // namespace internal
+
+// Experimental text formatting support.
+class text_style {
+ public:
+  FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT
+      : set_foreground_color(),
+        set_background_color(),
+        ems(em) {}
+
+  FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) {
+    if (!set_foreground_color) {
+      set_foreground_color = rhs.set_foreground_color;
+      foreground_color = rhs.foreground_color;
+    } else if (rhs.set_foreground_color) {
+      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
+        FMT_THROW(format_error("can't OR a terminal color"));
+      foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
+    }
+
+    if (!set_background_color) {
+      set_background_color = rhs.set_background_color;
+      background_color = rhs.background_color;
+    } else if (rhs.set_background_color) {
+      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
+        FMT_THROW(format_error("can't OR a terminal color"));
+      background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
+    }
+
+    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) |
+                                static_cast<uint8_t>(rhs.ems));
+    return *this;
+  }
+
+  friend FMT_CONSTEXPR text_style operator|(text_style lhs,
+                                            const text_style& rhs) {
+    return lhs |= rhs;
+  }
+
+  FMT_CONSTEXPR text_style& operator&=(const text_style& rhs) {
+    if (!set_foreground_color) {
+      set_foreground_color = rhs.set_foreground_color;
+      foreground_color = rhs.foreground_color;
+    } else if (rhs.set_foreground_color) {
+      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
+        FMT_THROW(format_error("can't AND a terminal color"));
+      foreground_color.value.rgb_color &= rhs.foreground_color.value.rgb_color;
+    }
+
+    if (!set_background_color) {
+      set_background_color = rhs.set_background_color;
+      background_color = rhs.background_color;
+    } else if (rhs.set_background_color) {
+      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
+        FMT_THROW(format_error("can't AND a terminal color"));
+      background_color.value.rgb_color &= rhs.background_color.value.rgb_color;
+    }
+
+    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) &
+                                static_cast<uint8_t>(rhs.ems));
+    return *this;
+  }
+
+  friend FMT_CONSTEXPR text_style operator&(text_style lhs,
+                                            const text_style& rhs) {
+    return lhs &= rhs;
+  }
+
+  FMT_CONSTEXPR bool has_foreground() const FMT_NOEXCEPT {
+    return set_foreground_color;
+  }
+  FMT_CONSTEXPR bool has_background() const FMT_NOEXCEPT {
+    return set_background_color;
+  }
+  FMT_CONSTEXPR bool has_emphasis() const FMT_NOEXCEPT {
+    return static_cast<uint8_t>(ems) != 0;
+  }
+  FMT_CONSTEXPR internal::color_type get_foreground() const FMT_NOEXCEPT {
+    FMT_ASSERT(has_foreground(), "no foreground specified for this style");
+    return foreground_color;
+  }
+  FMT_CONSTEXPR internal::color_type get_background() const FMT_NOEXCEPT {
+    FMT_ASSERT(has_background(), "no background specified for this style");
+    return background_color;
+  }
+  FMT_CONSTEXPR emphasis get_emphasis() const FMT_NOEXCEPT {
+    FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
+    return ems;
+  }
+
+ private:
+  FMT_CONSTEXPR text_style(bool is_foreground,
+                           internal::color_type text_color) FMT_NOEXCEPT
+      : set_foreground_color(),
+        set_background_color(),
+        ems() {
+    if (is_foreground) {
+      foreground_color = text_color;
+      set_foreground_color = true;
+    } else {
+      background_color = text_color;
+      set_background_color = true;
+    }
+  }
+
+  friend FMT_CONSTEXPR_DECL text_style fg(internal::color_type foreground)
+      FMT_NOEXCEPT;
+  friend FMT_CONSTEXPR_DECL text_style bg(internal::color_type background)
+      FMT_NOEXCEPT;
+
+  internal::color_type foreground_color;
+  internal::color_type background_color;
+  bool set_foreground_color;
+  bool set_background_color;
+  emphasis ems;
+};
+
+FMT_CONSTEXPR text_style fg(internal::color_type foreground) FMT_NOEXCEPT {
+  return text_style(/*is_foreground=*/true, foreground);
+}
+
+FMT_CONSTEXPR text_style bg(internal::color_type background) FMT_NOEXCEPT {
+  return text_style(/*is_foreground=*/false, background);
+}
+
+FMT_CONSTEXPR text_style operator|(emphasis lhs, emphasis rhs) FMT_NOEXCEPT {
+  return text_style(lhs) | rhs;
+}
+
+namespace internal {
+
+template <typename Char> struct ansi_color_escape {
+  FMT_CONSTEXPR ansi_color_escape(internal::color_type text_color,
+                                  const char* esc) FMT_NOEXCEPT {
+    // If we have a terminal color, we need to output another escape code
+    // sequence.
+    if (!text_color.is_rgb) {
+      bool is_background = esc == internal::data::background_color;
+      uint32_t value = text_color.value.term_color;
+      // Background ASCII codes are the same as the foreground ones but with
+      // 10 more.
+      if (is_background) value += 10u;
+
+      std::size_t index = 0;
+      buffer[index++] = static_cast<Char>('\x1b');
+      buffer[index++] = static_cast<Char>('[');
+
+      if (value >= 100u) {
+        buffer[index++] = static_cast<Char>('1');
+        value %= 100u;
+      }
+      buffer[index++] = static_cast<Char>('0' + value / 10u);
+      buffer[index++] = static_cast<Char>('0' + value % 10u);
+
+      buffer[index++] = static_cast<Char>('m');
+      buffer[index++] = static_cast<Char>('\0');
+      return;
+    }
+
+    for (int i = 0; i < 7; i++) {
+      buffer[i] = static_cast<Char>(esc[i]);
+    }
+    rgb color(text_color.value.rgb_color);
+    to_esc(color.r, buffer + 7, ';');
+    to_esc(color.g, buffer + 11, ';');
+    to_esc(color.b, buffer + 15, 'm');
+    buffer[19] = static_cast<Char>(0);
+  }
+  FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT {
+    uint8_t em_codes[4] = {};
+    uint8_t em_bits = static_cast<uint8_t>(em);
+    if (em_bits & static_cast<uint8_t>(emphasis::bold)) em_codes[0] = 1;
+    if (em_bits & static_cast<uint8_t>(emphasis::italic)) em_codes[1] = 3;
+    if (em_bits & static_cast<uint8_t>(emphasis::underline)) em_codes[2] = 4;
+    if (em_bits & static_cast<uint8_t>(emphasis::strikethrough))
+      em_codes[3] = 9;
+
+    std::size_t index = 0;
+    for (int i = 0; i < 4; ++i) {
+      if (!em_codes[i]) continue;
+      buffer[index++] = static_cast<Char>('\x1b');
+      buffer[index++] = static_cast<Char>('[');
+      buffer[index++] = static_cast<Char>('0' + em_codes[i]);
+      buffer[index++] = static_cast<Char>('m');
+    }
+    buffer[index++] = static_cast<Char>(0);
+  }
+  FMT_CONSTEXPR operator const Char*() const FMT_NOEXCEPT { return buffer; }
+
+  FMT_CONSTEXPR const Char* begin() const FMT_NOEXCEPT { return buffer; }
+  FMT_CONSTEXPR const Char* end() const FMT_NOEXCEPT {
+    return buffer + std::char_traits<Char>::length(buffer);
+  }
+
+ private:
+  Char buffer[7u + 3u * 4u + 1u];
+
+  static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,
+                                   char delimiter) FMT_NOEXCEPT {
+    out[0] = static_cast<Char>('0' + c / 100);
+    out[1] = static_cast<Char>('0' + c / 10 % 10);
+    out[2] = static_cast<Char>('0' + c % 10);
+    out[3] = static_cast<Char>(delimiter);
+  }
+};
+
+template <typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
+    internal::color_type foreground) FMT_NOEXCEPT {
+  return ansi_color_escape<Char>(foreground, internal::data::foreground_color);
+}
+
+template <typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
+    internal::color_type background) FMT_NOEXCEPT {
+  return ansi_color_escape<Char>(background, internal::data::background_color);
+}
+
+template <typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) FMT_NOEXCEPT {
+  return ansi_color_escape<Char>(em);
+}
+
+template <typename Char>
+inline void fputs(const Char* chars, FILE* stream) FMT_NOEXCEPT {
+  std::fputs(chars, stream);
+}
+
+template <>
+inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) FMT_NOEXCEPT {
+  std::fputws(chars, stream);
+}
+
+template <typename Char> inline void reset_color(FILE* stream) FMT_NOEXCEPT {
+  fputs(internal::data::reset_color, stream);
+}
+
+template <> inline void reset_color<wchar_t>(FILE* stream) FMT_NOEXCEPT {
+  fputs(internal::data::wreset_color, stream);
+}
+
+template <typename Char>
+inline void reset_color(basic_memory_buffer<Char>& buffer) FMT_NOEXCEPT {
+  const char* begin = data::reset_color;
+  const char* end = begin + sizeof(data::reset_color) - 1;
+  buffer.append(begin, end);
+}
+
+template <typename Char>
+void vformat_to(basic_memory_buffer<Char>& buf, const text_style& ts,
+                basic_string_view<Char> format_str,
+                basic_format_args<buffer_context<Char>> args) {
+  bool has_style = false;
+  if (ts.has_emphasis()) {
+    has_style = true;
+    auto emphasis = internal::make_emphasis<Char>(ts.get_emphasis());
+    buf.append(emphasis.begin(), emphasis.end());
+  }
+  if (ts.has_foreground()) {
+    has_style = true;
+    auto foreground =
+        internal::make_foreground_color<Char>(ts.get_foreground());
+    buf.append(foreground.begin(), foreground.end());
+  }
+  if (ts.has_background()) {
+    has_style = true;
+    auto background =
+        internal::make_background_color<Char>(ts.get_background());
+    buf.append(background.begin(), background.end());
+  }
+  internal::vformat_to(buf, format_str, args);
+  if (has_style) internal::reset_color<Char>(buf);
+}
+}  // namespace internal
+
+template <typename S, typename Char = char_t<S>>
+void vprint(std::FILE* f, const text_style& ts, const S& format,
+            basic_format_args<buffer_context<Char>> args) {
+  basic_memory_buffer<Char> buf;
+  internal::vformat_to(buf, ts, to_string_view(format), args);
+  buf.push_back(Char(0));
+  internal::fputs(buf.data(), f);
+}
+
+/**
+  Formats a string and prints it to the specified file stream using ANSI
+  escape sequences to specify text formatting.
+  Example:
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+ */
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(internal::is_string<S>::value)>
+void print(std::FILE* f, const text_style& ts, const S& format_str,
+           const Args&... args) {
+  internal::check_format_string<Args...>(format_str);
+  using context = buffer_context<char_t<S>>;
+  format_arg_store<context, Args...> as{args...};
+  vprint(f, ts, format_str, basic_format_args<context>(as));
+}
+
+/**
+  Formats a string and prints it to stdout using ANSI escape sequences to
+  specify text formatting.
+  Example:
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+ */
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(internal::is_string<S>::value)>
+void print(const text_style& ts, const S& format_str, const Args&... args) {
+  return print(stdout, ts, format_str, args...);
+}
+
+template <typename S, typename Char = char_t<S>>
+inline std::basic_string<Char> vformat(
+    const text_style& ts, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buf;
+  internal::vformat_to(buf, ts, to_string_view(format_str), args);
+  return fmt::to_string(buf);
+}
+
+/**
+  \rst
+  Formats arguments and returns the result as a string using ANSI
+  escape sequences to specify text formatting.
+
+  **Example**::
+
+    #include <fmt/color.h>
+    std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
+                                      "The answer is {}", 42);
+  \endrst
+*/
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
+                                      const Args&... args) {
+  return vformat(ts, to_string_view(format_str),
+                 internal::make_args_checked<Args...>(format_str, args...));
+}
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_COLOR_H_
diff --git a/lib/fmt/fmt/compile.h b/lib/fmt/fmt/compile.h
new file mode 100644
index 0000000..e4b12f3
--- /dev/null
+++ b/lib/fmt/fmt/compile.h
@@ -0,0 +1,595 @@
+// Formatting library for C++ - experimental format string compilation
+//
+// Copyright (c) 2012 - present, Victor Zverovich and fmt contributors
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_COMPILE_H_
+#define FMT_COMPILE_H_
+
+#include <vector>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace internal {
+
+// Part of a compiled format string. It can be either literal text or a
+// replacement field.
+template <typename Char> struct format_part {
+  enum class kind { arg_index, arg_name, text, replacement };
+
+  struct replacement {
+    arg_ref<Char> arg_id;
+    dynamic_format_specs<Char> specs;
+  };
+
+  kind part_kind;
+  union value {
+    int arg_index;
+    basic_string_view<Char> str;
+    replacement repl;
+
+    FMT_CONSTEXPR value(int index = 0) : arg_index(index) {}
+    FMT_CONSTEXPR value(basic_string_view<Char> s) : str(s) {}
+    FMT_CONSTEXPR value(replacement r) : repl(r) {}
+  } val;
+  // Position past the end of the argument id.
+  const Char* arg_id_end = nullptr;
+
+  FMT_CONSTEXPR format_part(kind k = kind::arg_index, value v = {})
+      : part_kind(k), val(v) {}
+
+  static FMT_CONSTEXPR format_part make_arg_index(int index) {
+    return format_part(kind::arg_index, index);
+  }
+  static FMT_CONSTEXPR format_part make_arg_name(basic_string_view<Char> name) {
+    return format_part(kind::arg_name, name);
+  }
+  static FMT_CONSTEXPR format_part make_text(basic_string_view<Char> text) {
+    return format_part(kind::text, text);
+  }
+  static FMT_CONSTEXPR format_part make_replacement(replacement repl) {
+    return format_part(kind::replacement, repl);
+  }
+};
+
+template <typename Char> struct part_counter {
+  unsigned num_parts = 0;
+
+  FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) {
+    if (begin != end) ++num_parts;
+  }
+
+  FMT_CONSTEXPR void on_arg_id() { ++num_parts; }
+  FMT_CONSTEXPR void on_arg_id(int) { ++num_parts; }
+  FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) { ++num_parts; }
+
+  FMT_CONSTEXPR void on_replacement_field(const Char*) {}
+
+  FMT_CONSTEXPR const Char* on_format_specs(const Char* begin,
+                                            const Char* end) {
+    // Find the matching brace.
+    unsigned brace_counter = 0;
+    for (; begin != end; ++begin) {
+      if (*begin == '{') {
+        ++brace_counter;
+      } else if (*begin == '}') {
+        if (brace_counter == 0u) break;
+        --brace_counter;
+      }
+    }
+    return begin;
+  }
+
+  FMT_CONSTEXPR void on_error(const char*) {}
+};
+
+// Counts the number of parts in a format string.
+template <typename Char>
+FMT_CONSTEXPR unsigned count_parts(basic_string_view<Char> format_str) {
+  part_counter<Char> counter;
+  parse_format_string<true>(format_str, counter);
+  return counter.num_parts;
+}
+
+template <typename Char, typename PartHandler>
+class format_string_compiler : public error_handler {
+ private:
+  using part = format_part<Char>;
+
+  PartHandler handler_;
+  part part_;
+  basic_string_view<Char> format_str_;
+  basic_format_parse_context<Char> parse_context_;
+
+ public:
+  FMT_CONSTEXPR format_string_compiler(basic_string_view<Char> format_str,
+                                       PartHandler handler)
+      : handler_(handler),
+        format_str_(format_str),
+        parse_context_(format_str) {}
+
+  FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) {
+    if (begin != end)
+      handler_(part::make_text({begin, to_unsigned(end - begin)}));
+  }
+
+  FMT_CONSTEXPR void on_arg_id() {
+    part_ = part::make_arg_index(parse_context_.next_arg_id());
+  }
+
+  FMT_CONSTEXPR void on_arg_id(int id) {
+    parse_context_.check_arg_id(id);
+    part_ = part::make_arg_index(id);
+  }
+
+  FMT_CONSTEXPR void on_arg_id(basic_string_view<Char> id) {
+    part_ = part::make_arg_name(id);
+  }
+
+  FMT_CONSTEXPR void on_replacement_field(const Char* ptr) {
+    part_.arg_id_end = ptr;
+    handler_(part_);
+  }
+
+  FMT_CONSTEXPR const Char* on_format_specs(const Char* begin,
+                                            const Char* end) {
+    auto repl = typename part::replacement();
+    dynamic_specs_handler<basic_format_parse_context<Char>> handler(
+        repl.specs, parse_context_);
+    auto it = parse_format_specs(begin, end, handler);
+    if (*it != '}') on_error("missing '}' in format string");
+    repl.arg_id = part_.part_kind == part::kind::arg_index
+                      ? arg_ref<Char>(part_.val.arg_index)
+                      : arg_ref<Char>(part_.val.str);
+    auto part = part::make_replacement(repl);
+    part.arg_id_end = begin;
+    handler_(part);
+    return it;
+  }
+};
+
+// Compiles a format string and invokes handler(part) for each parsed part.
+template <bool IS_CONSTEXPR, typename Char, typename PartHandler>
+FMT_CONSTEXPR void compile_format_string(basic_string_view<Char> format_str,
+                                         PartHandler handler) {
+  parse_format_string<IS_CONSTEXPR>(
+      format_str,
+      format_string_compiler<Char, PartHandler>(format_str, handler));
+}
+
+template <typename Range, typename Context, typename Id>
+void format_arg(
+    basic_format_parse_context<typename Range::value_type>& parse_ctx,
+    Context& ctx, Id arg_id) {
+  ctx.advance_to(
+      visit_format_arg(arg_formatter<Range>(ctx, &parse_ctx), ctx.arg(arg_id)));
+}
+
+// vformat_to is defined in a subnamespace to prevent ADL.
+namespace cf {
+template <typename Context, typename Range, typename CompiledFormat>
+auto vformat_to(Range out, CompiledFormat& cf, basic_format_args<Context> args)
+    -> typename Context::iterator {
+  using char_type = typename Context::char_type;
+  basic_format_parse_context<char_type> parse_ctx(
+      to_string_view(cf.format_str_));
+  Context ctx(out.begin(), args);
+
+  const auto& parts = cf.parts();
+  for (auto part_it = std::begin(parts); part_it != std::end(parts);
+       ++part_it) {
+    const auto& part = *part_it;
+    const auto& value = part.val;
+
+    using format_part_t = format_part<char_type>;
+    switch (part.part_kind) {
+    case format_part_t::kind::text: {
+      const auto text = value.str;
+      auto output = ctx.out();
+      auto&& it = reserve(output, text.size());
+      it = std::copy_n(text.begin(), text.size(), it);
+      ctx.advance_to(output);
+      break;
+    }
+
+    case format_part_t::kind::arg_index:
+      advance_to(parse_ctx, part.arg_id_end);
+      internal::format_arg<Range>(parse_ctx, ctx, value.arg_index);
+      break;
+
+    case format_part_t::kind::arg_name:
+      advance_to(parse_ctx, part.arg_id_end);
+      internal::format_arg<Range>(parse_ctx, ctx, value.str);
+      break;
+
+    case format_part_t::kind::replacement: {
+      const auto& arg_id_value = value.repl.arg_id.val;
+      const auto arg = value.repl.arg_id.kind == arg_id_kind::index
+                           ? ctx.arg(arg_id_value.index)
+                           : ctx.arg(arg_id_value.name);
+
+      auto specs = value.repl.specs;
+
+      handle_dynamic_spec<width_checker>(specs.width, specs.width_ref, ctx);
+      handle_dynamic_spec<precision_checker>(specs.precision,
+                                             specs.precision_ref, ctx);
+
+      error_handler h;
+      numeric_specs_checker<error_handler> checker(h, arg.type());
+      if (specs.align == align::numeric) checker.require_numeric_argument();
+      if (specs.sign != sign::none) checker.check_sign();
+      if (specs.alt) checker.require_numeric_argument();
+      if (specs.precision >= 0) checker.check_precision();
+
+      advance_to(parse_ctx, part.arg_id_end);
+      ctx.advance_to(
+          visit_format_arg(arg_formatter<Range>(ctx, nullptr, &specs), arg));
+      break;
+    }
+    }
+  }
+  return ctx.out();
+}
+}  // namespace cf
+
+struct basic_compiled_format {};
+
+template <typename S, typename = void>
+struct compiled_format_base : basic_compiled_format {
+  using char_type = char_t<S>;
+  using parts_container = std::vector<internal::format_part<char_type>>;
+
+  parts_container compiled_parts;
+
+  explicit compiled_format_base(basic_string_view<char_type> format_str) {
+    compile_format_string<false>(format_str,
+                                 [this](const format_part<char_type>& part) {
+                                   compiled_parts.push_back(part);
+                                 });
+  }
+
+  const parts_container& parts() const { return compiled_parts; }
+};
+
+template <typename Char, unsigned N> struct format_part_array {
+  format_part<Char> data[N] = {};
+  FMT_CONSTEXPR format_part_array() = default;
+};
+
+template <typename Char, unsigned N>
+FMT_CONSTEXPR format_part_array<Char, N> compile_to_parts(
+    basic_string_view<Char> format_str) {
+  format_part_array<Char, N> parts;
+  unsigned counter = 0;
+  // This is not a lambda for compatibility with older compilers.
+  struct {
+    format_part<Char>* parts;
+    unsigned* counter;
+    FMT_CONSTEXPR void operator()(const format_part<Char>& part) {
+      parts[(*counter)++] = part;
+    }
+  } collector{parts.data, &counter};
+  compile_format_string<true>(format_str, collector);
+  if (counter < N) {
+    parts.data[counter] =
+        format_part<Char>::make_text(basic_string_view<Char>());
+  }
+  return parts;
+}
+
+template <typename T> constexpr const T& constexpr_max(const T& a, const T& b) {
+  return (a < b) ? b : a;
+}
+
+template <typename S>
+struct compiled_format_base<S, enable_if_t<is_compile_string<S>::value>>
+    : basic_compiled_format {
+  using char_type = char_t<S>;
+
+  FMT_CONSTEXPR explicit compiled_format_base(basic_string_view<char_type>) {}
+
+// Workaround for old compilers. Format string compilation will not be
+// performed there anyway.
+#if FMT_USE_CONSTEXPR
+  static FMT_CONSTEXPR_DECL const unsigned num_format_parts =
+      constexpr_max(count_parts(to_string_view(S())), 1u);
+#else
+  static const unsigned num_format_parts = 1;
+#endif
+
+  using parts_container = format_part<char_type>[num_format_parts];
+
+  const parts_container& parts() const {
+    static FMT_CONSTEXPR_DECL const auto compiled_parts =
+        compile_to_parts<char_type, num_format_parts>(
+            internal::to_string_view(S()));
+    return compiled_parts.data;
+  }
+};
+
+template <typename S, typename... Args>
+class compiled_format : private compiled_format_base<S> {
+ public:
+  using typename compiled_format_base<S>::char_type;
+
+ private:
+  basic_string_view<char_type> format_str_;
+
+  template <typename Context, typename Range, typename CompiledFormat>
+  friend auto cf::vformat_to(Range out, CompiledFormat& cf,
+                             basic_format_args<Context> args) ->
+      typename Context::iterator;
+
+ public:
+  compiled_format() = delete;
+  explicit constexpr compiled_format(basic_string_view<char_type> format_str)
+      : compiled_format_base<S>(format_str), format_str_(format_str) {}
+};
+
+#ifdef __cpp_if_constexpr
+template <typename... Args> struct type_list {};
+
+// Returns a reference to the argument at index N from [first, rest...].
+template <int N, typename T, typename... Args>
+constexpr const auto& get(const T& first, const Args&... rest) {
+  static_assert(N < 1 + sizeof...(Args), "index is out of bounds");
+  if constexpr (N == 0)
+    return first;
+  else
+    return get<N - 1>(rest...);
+}
+
+template <int N, typename> struct get_type_impl;
+
+template <int N, typename... Args> struct get_type_impl<N, type_list<Args...>> {
+  using type = remove_cvref_t<decltype(get<N>(std::declval<Args>()...))>;
+};
+
+template <int N, typename T>
+using get_type = typename get_type_impl<N, T>::type;
+
+template <typename T> struct is_compiled_format : std::false_type {};
+
+template <typename Char> struct text {
+  basic_string_view<Char> data;
+  using char_type = Char;
+
+  template <typename OutputIt, typename... Args>
+  OutputIt format(OutputIt out, const Args&...) const {
+    // TODO: reserve
+    return copy_str<Char>(data.begin(), data.end(), out);
+  }
+};
+
+template <typename Char>
+struct is_compiled_format<text<Char>> : std::true_type {};
+
+template <typename Char>
+constexpr text<Char> make_text(basic_string_view<Char> s, size_t pos,
+                               size_t size) {
+  return {{&s[pos], size}};
+}
+
+template <typename Char, typename OutputIt, typename T,
+          std::enable_if_t<std::is_integral_v<T>, int> = 0>
+OutputIt format_default(OutputIt out, T value) {
+  // TODO: reserve
+  format_int fi(value);
+  return std::copy(fi.data(), fi.data() + fi.size(), out);
+}
+
+template <typename Char, typename OutputIt>
+OutputIt format_default(OutputIt out, double value) {
+  writer w(out);
+  w.write(value);
+  return w.out();
+}
+
+template <typename Char, typename OutputIt>
+OutputIt format_default(OutputIt out, Char value) {
+  *out++ = value;
+  return out;
+}
+
+template <typename Char, typename OutputIt>
+OutputIt format_default(OutputIt out, const Char* value) {
+  auto length = std::char_traits<Char>::length(value);
+  return copy_str<Char>(value, value + length, out);
+}
+
+// A replacement field that refers to argument N.
+template <typename Char, typename T, int N> struct field {
+  using char_type = Char;
+
+  template <typename OutputIt, typename... Args>
+  OutputIt format(OutputIt out, const Args&... args) const {
+    // This ensures that the argument type is convertile to `const T&`.
+    const T& arg = get<N>(args...);
+    return format_default<Char>(out, arg);
+  }
+};
+
+template <typename Char, typename T, int N>
+struct is_compiled_format<field<Char, T, N>> : std::true_type {};
+
+template <typename L, typename R> struct concat {
+  L lhs;
+  R rhs;
+  using char_type = typename L::char_type;
+
+  template <typename OutputIt, typename... Args>
+  OutputIt format(OutputIt out, const Args&... args) const {
+    out = lhs.format(out, args...);
+    return rhs.format(out, args...);
+  }
+};
+
+template <typename L, typename R>
+struct is_compiled_format<concat<L, R>> : std::true_type {};
+
+template <typename L, typename R>
+constexpr concat<L, R> make_concat(L lhs, R rhs) {
+  return {lhs, rhs};
+}
+
+struct unknown_format {};
+
+template <typename Char>
+constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) {
+  for (size_t size = str.size(); pos != size; ++pos) {
+    if (str[pos] == '{' || str[pos] == '}') break;
+  }
+  return pos;
+}
+
+template <typename Args, size_t POS, int ID, typename S>
+constexpr auto compile_format_string(S format_str);
+
+template <typename Args, size_t POS, int ID, typename T, typename S>
+constexpr auto parse_tail(T head, S format_str) {
+  if constexpr (POS != to_string_view(format_str).size()) {
+    constexpr auto tail = compile_format_string<Args, POS, ID>(format_str);
+    if constexpr (std::is_same<remove_cvref_t<decltype(tail)>,
+                               unknown_format>())
+      return tail;
+    else
+      return make_concat(head, tail);
+  } else {
+    return head;
+  }
+}
+
+// Compiles a non-empty format string and returns the compiled representation
+// or unknown_format() on unrecognized input.
+template <typename Args, size_t POS, int ID, typename S>
+constexpr auto compile_format_string(S format_str) {
+  using char_type = typename S::char_type;
+  constexpr basic_string_view<char_type> str = format_str;
+  if constexpr (str[POS] == '{') {
+    if (POS + 1 == str.size())
+      throw format_error("unmatched '{' in format string");
+    if constexpr (str[POS + 1] == '{') {
+      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+    } else if constexpr (str[POS + 1] == '}') {
+      using type = get_type<ID, Args>;
+      if constexpr (std::is_same<type, int>::value) {
+        return parse_tail<Args, POS + 2, ID + 1>(field<char_type, type, ID>(),
+                                                 format_str);
+      } else {
+        return unknown_format();
+      }
+    } else {
+      return unknown_format();
+    }
+  } else if constexpr (str[POS] == '}') {
+    if (POS + 1 == str.size())
+      throw format_error("unmatched '}' in format string");
+    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+  } else {
+    constexpr auto end = parse_text(str, POS + 1);
+    return parse_tail<Args, end, ID>(make_text(str, POS, end - POS),
+                                     format_str);
+  }
+}
+#endif  // __cpp_if_constexpr
+}  // namespace internal
+
+#if FMT_USE_CONSTEXPR
+#  ifdef __cpp_if_constexpr
+template <typename... Args, typename S,
+          FMT_ENABLE_IF(is_compile_string<S>::value)>
+constexpr auto compile(S format_str) {
+  constexpr basic_string_view<typename S::char_type> str = format_str;
+  if constexpr (str.size() == 0) {
+    return internal::make_text(str, 0, 0);
+  } else {
+    constexpr auto result =
+        internal::compile_format_string<internal::type_list<Args...>, 0, 0>(
+            format_str);
+    if constexpr (std::is_same<remove_cvref_t<decltype(result)>,
+                               internal::unknown_format>()) {
+      return internal::compiled_format<S, Args...>(to_string_view(format_str));
+    } else {
+      return result;
+    }
+  }
+}
+
+template <typename CompiledFormat, typename... Args,
+          typename Char = typename CompiledFormat::char_type,
+          FMT_ENABLE_IF(internal::is_compiled_format<CompiledFormat>::value)>
+std::basic_string<Char> format(const CompiledFormat& cf, const Args&... args) {
+  basic_memory_buffer<Char> buffer;
+  cf.format(std::back_inserter(buffer), args...);
+  return to_string(buffer);
+}
+
+template <typename OutputIt, typename CompiledFormat, typename... Args,
+          FMT_ENABLE_IF(internal::is_compiled_format<CompiledFormat>::value)>
+OutputIt format_to(OutputIt out, const CompiledFormat& cf,
+                   const Args&... args) {
+  return cf.format(out, args...);
+}
+#  else
+template <typename... Args, typename S,
+          FMT_ENABLE_IF(is_compile_string<S>::value)>
+constexpr auto compile(S format_str) -> internal::compiled_format<S, Args...> {
+  return internal::compiled_format<S, Args...>(to_string_view(format_str));
+}
+#  endif  // __cpp_if_constexpr
+#endif    // FMT_USE_CONSTEXPR
+
+// Compiles the format string which must be a string literal.
+template <typename... Args, typename Char, size_t N>
+auto compile(const Char (&format_str)[N])
+    -> internal::compiled_format<const Char*, Args...> {
+  return internal::compiled_format<const Char*, Args...>(
+      basic_string_view<Char>(format_str, N - 1));
+}
+
+template <typename CompiledFormat, typename... Args,
+          typename Char = typename CompiledFormat::char_type,
+          FMT_ENABLE_IF(std::is_base_of<internal::basic_compiled_format,
+                                        CompiledFormat>::value)>
+std::basic_string<Char> format(const CompiledFormat& cf, const Args&... args) {
+  basic_memory_buffer<Char> buffer;
+  using range = buffer_range<Char>;
+  using context = buffer_context<Char>;
+  internal::cf::vformat_to<context>(range(buffer), cf,
+                                    make_format_args<context>(args...));
+  return to_string(buffer);
+}
+
+template <typename OutputIt, typename CompiledFormat, typename... Args,
+          FMT_ENABLE_IF(std::is_base_of<internal::basic_compiled_format,
+                                        CompiledFormat>::value)>
+OutputIt format_to(OutputIt out, const CompiledFormat& cf,
+                   const Args&... args) {
+  using char_type = typename CompiledFormat::char_type;
+  using range = internal::output_range<OutputIt, char_type>;
+  using context = format_context_t<OutputIt, char_type>;
+  return internal::cf::vformat_to<context>(range(out), cf,
+                                           make_format_args<context>(args...));
+}
+
+template <typename OutputIt, typename CompiledFormat, typename... Args,
+          FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value)>
+format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n,
+                                         const CompiledFormat& cf,
+                                         const Args&... args) {
+  auto it =
+      format_to(internal::truncating_iterator<OutputIt>(out, n), cf, args...);
+  return {it.base(), it.count()};
+}
+
+template <typename CompiledFormat, typename... Args>
+std::size_t formatted_size(const CompiledFormat& cf, const Args&... args) {
+  return format_to(internal::counting_iterator(), cf, args...).count();
+}
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_COMPILE_H_
diff --git a/lib/fmt/fmt/core.h b/lib/fmt/fmt/core.h
new file mode 100644
index 0000000..6df2875
--- /dev/null
+++ b/lib/fmt/fmt/core.h
@@ -0,0 +1,1789 @@
+// Formatting library for C++ - the core API
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_CORE_H_
+#define FMT_CORE_H_
+
+#include <cstdio>  // std::FILE
+#include <cstring>
+#include <functional>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+// The fmt library version in the form major * 10000 + minor * 100 + patch.
+#define FMT_VERSION 60200
+
+#ifdef __has_feature
+#  define FMT_HAS_FEATURE(x) __has_feature(x)
+#else
+#  define FMT_HAS_FEATURE(x) 0
+#endif
+
+#if defined(__has_include) && !defined(__INTELLISENSE__) && \
+    !(defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1600)
+#  define FMT_HAS_INCLUDE(x) __has_include(x)
+#else
+#  define FMT_HAS_INCLUDE(x) 0
+#endif
+
+#ifdef __has_cpp_attribute
+#  define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#else
+#  define FMT_HAS_CPP_ATTRIBUTE(x) 0
+#endif
+
+#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \
+  (__cplusplus >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))
+
+#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \
+  (__cplusplus >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))
+
+#ifdef __clang__
+#  define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
+#else
+#  define FMT_CLANG_VERSION 0
+#endif
+
+#if defined(__GNUC__) && !defined(__clang__)
+#  define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+#else
+#  define FMT_GCC_VERSION 0
+#endif
+
+#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
+#else
+#  define FMT_HAS_GXX_CXX11 0
+#endif
+
+#ifdef __NVCC__
+#  define FMT_NVCC __NVCC__
+#else
+#  define FMT_NVCC 0
+#endif
+
+#ifdef _MSC_VER
+#  define FMT_MSC_VER _MSC_VER
+#else
+#  define FMT_MSC_VER 0
+#endif
+
+// Check if relaxed C++14 constexpr is supported.
+// GCC doesn't allow throw in constexpr until version 6 (bug 67371).
+#ifndef FMT_USE_CONSTEXPR
+#  define FMT_USE_CONSTEXPR                                           \
+    (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \
+     (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) &&           \
+        !FMT_NVCC
+#endif
+#if FMT_USE_CONSTEXPR
+#  define FMT_CONSTEXPR constexpr
+#  define FMT_CONSTEXPR_DECL constexpr
+#else
+#  define FMT_CONSTEXPR inline
+#  define FMT_CONSTEXPR_DECL
+#endif
+
+#ifndef FMT_OVERRIDE
+#  if FMT_HAS_FEATURE(cxx_override) || \
+      (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
+#    define FMT_OVERRIDE override
+#  else
+#    define FMT_OVERRIDE
+#  endif
+#endif
+
+// Check if exceptions are disabled.
+#ifndef FMT_EXCEPTIONS
+#  if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \
+      FMT_MSC_VER && !_HAS_EXCEPTIONS
+#    define FMT_EXCEPTIONS 0
+#  else
+#    define FMT_EXCEPTIONS 1
+#  endif
+#endif
+
+// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).
+#ifndef FMT_USE_NOEXCEPT
+#  define FMT_USE_NOEXCEPT 0
+#endif
+
+#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
+    (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
+#  define FMT_DETECTED_NOEXCEPT noexcept
+#  define FMT_HAS_CXX11_NOEXCEPT 1
+#else
+#  define FMT_DETECTED_NOEXCEPT throw()
+#  define FMT_HAS_CXX11_NOEXCEPT 0
+#endif
+
+#ifndef FMT_NOEXCEPT
+#  if FMT_EXCEPTIONS || FMT_HAS_CXX11_NOEXCEPT
+#    define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
+#  else
+#    define FMT_NOEXCEPT
+#  endif
+#endif
+
+// [[noreturn]] is disabled on MSVC and NVCC because of bogus unreachable code
+// warnings.
+#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VER && \
+    !FMT_NVCC
+#  define FMT_NORETURN [[noreturn]]
+#else
+#  define FMT_NORETURN
+#endif
+
+#ifndef FMT_MAYBE_UNUSED
+#  if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused)
+#    define FMT_MAYBE_UNUSED [[maybe_unused]]
+#  else
+#    define FMT_MAYBE_UNUSED
+#  endif
+#endif
+
+#ifndef FMT_DEPRECATED
+#  if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VER >= 1900
+#    define FMT_DEPRECATED [[deprecated]]
+#  else
+#    if defined(__GNUC__) || defined(__clang__)
+#      define FMT_DEPRECATED __attribute__((deprecated))
+#    elif FMT_MSC_VER
+#      define FMT_DEPRECATED __declspec(deprecated)
+#    else
+#      define FMT_DEPRECATED /* deprecated */
+#    endif
+#  endif
+#endif
+
+// Workaround broken [[deprecated]] in the Intel, PGI and NVCC compilers.
+#if defined(__INTEL_COMPILER) || defined(__PGI) || FMT_NVCC
+#  define FMT_DEPRECATED_ALIAS
+#else
+#  define FMT_DEPRECATED_ALIAS FMT_DEPRECATED
+#endif
+
+#ifndef FMT_BEGIN_NAMESPACE
+#  if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \
+      FMT_MSC_VER >= 1900
+#    define FMT_INLINE_NAMESPACE inline namespace
+#    define FMT_END_NAMESPACE \
+      }                       \
+      }
+#  else
+#    define FMT_INLINE_NAMESPACE namespace
+#    define FMT_END_NAMESPACE \
+      }                       \
+      using namespace v6;     \
+      }
+#  endif
+#  define FMT_BEGIN_NAMESPACE \
+    namespace fmt {           \
+    FMT_INLINE_NAMESPACE v6 {
+#endif
+
+#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
+#  if FMT_MSC_VER
+#    define FMT_NO_W4275 __pragma(warning(suppress : 4275))
+#  else
+#    define FMT_NO_W4275
+#  endif
+#  define FMT_CLASS_API FMT_NO_W4275
+#  ifdef FMT_EXPORT
+#    define FMT_API __declspec(dllexport)
+#  elif defined(FMT_SHARED)
+#    define FMT_API __declspec(dllimport)
+#    define FMT_EXTERN_TEMPLATE_API FMT_API
+#  endif
+#endif
+#ifndef FMT_CLASS_API
+#  define FMT_CLASS_API
+#endif
+#ifndef FMT_API
+#  if FMT_GCC_VERSION || FMT_CLANG_VERSION
+#    define FMT_API __attribute__((visibility("default")))
+#    define FMT_EXTERN_TEMPLATE_API FMT_API
+#    define FMT_INSTANTIATION_DEF_API
+#  else
+#    define FMT_API
+#  endif
+#endif
+#ifndef FMT_EXTERN_TEMPLATE_API
+#  define FMT_EXTERN_TEMPLATE_API
+#endif
+#ifndef FMT_INSTANTIATION_DEF_API
+#  define FMT_INSTANTIATION_DEF_API FMT_API
+#endif
+
+#ifndef FMT_HEADER_ONLY
+#  define FMT_EXTERN extern
+#else
+#  define FMT_EXTERN
+#endif
+
+// libc++ supports string_view in pre-c++17.
+#if (FMT_HAS_INCLUDE(<string_view>) &&                       \
+     (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \
+    (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
+#  include <string_view>
+#  define FMT_USE_STRING_VIEW
+#elif FMT_HAS_INCLUDE("experimental/string_view") && __cplusplus >= 201402L
+#  include <experimental/string_view>
+#  define FMT_USE_EXPERIMENTAL_STRING_VIEW
+#endif
+
+#ifndef FMT_UNICODE
+#  define FMT_UNICODE !FMT_MSC_VER
+#endif
+#if FMT_UNICODE && FMT_MSC_VER
+#  pragma execution_character_set("utf-8")
+#endif
+
+FMT_BEGIN_NAMESPACE
+
+// Implementations of enable_if_t and other metafunctions for older systems.
+template <bool B, class T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+template <bool B, class T, class F>
+using conditional_t = typename std::conditional<B, T, F>::type;
+template <bool B> using bool_constant = std::integral_constant<bool, B>;
+template <typename T>
+using remove_reference_t = typename std::remove_reference<T>::type;
+template <typename T>
+using remove_const_t = typename std::remove_const<T>::type;
+template <typename T>
+using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
+template <typename T> struct type_identity { using type = T; };
+template <typename T> using type_identity_t = typename type_identity<T>::type;
+
+struct monostate {};
+
+// An enable_if helper to be used in template parameters which results in much
+// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed
+// to workaround a bug in MSVC 2019 (see #1140 and #1186).
+#define FMT_ENABLE_IF(...) enable_if_t<(__VA_ARGS__), int> = 0
+
+namespace internal {
+
+// A helper function to suppress bogus "conditional expression is constant"
+// warnings.
+template <typename T> FMT_CONSTEXPR T const_check(T value) { return value; }
+
+// A workaround for gcc 4.8 to make void_t work in a SFINAE context.
+template <typename... Ts> struct void_t_impl { using type = void; };
+
+FMT_NORETURN FMT_API void assert_fail(const char* file, int line,
+                                      const char* message);
+
+#ifndef FMT_ASSERT
+#  ifdef NDEBUG
+// FMT_ASSERT is not empty to avoid -Werror=empty-body.
+#    define FMT_ASSERT(condition, message) ((void)0)
+#  else
+#    define FMT_ASSERT(condition, message)                                    \
+      ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
+           ? (void)0                                                          \
+           : ::fmt::internal::assert_fail(__FILE__, __LINE__, (message)))
+#  endif
+#endif
+
+#if defined(FMT_USE_STRING_VIEW)
+template <typename Char> using std_string_view = std::basic_string_view<Char>;
+#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW)
+template <typename Char>
+using std_string_view = std::experimental::basic_string_view<Char>;
+#else
+template <typename T> struct std_string_view {};
+#endif
+
+#ifdef FMT_USE_INT128
+// Do nothing.
+#elif defined(__SIZEOF_INT128__) && !FMT_NVCC
+#  define FMT_USE_INT128 1
+using int128_t = __int128_t;
+using uint128_t = __uint128_t;
+#else
+#  define FMT_USE_INT128 0
+#endif
+#if !FMT_USE_INT128
+struct int128_t {};
+struct uint128_t {};
+#endif
+
+// Casts a nonnegative integer to unsigned.
+template <typename Int>
+FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value) {
+  FMT_ASSERT(value >= 0, "negative value");
+  return static_cast<typename std::make_unsigned<Int>::type>(value);
+}
+
+constexpr unsigned char micro[] = "\u00B5";
+
+template <typename Char> constexpr bool is_unicode() {
+  return FMT_UNICODE || sizeof(Char) != 1 ||
+         (sizeof(micro) == 3 && micro[0] == 0xC2 && micro[1] == 0xB5);
+}
+
+#ifdef __cpp_char8_t
+using char8_type = char8_t;
+#else
+enum char8_type : unsigned char {};
+#endif
+}  // namespace internal
+
+template <typename... Ts>
+using void_t = typename internal::void_t_impl<Ts...>::type;
+
+/**
+  An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
+  subset of the API. ``fmt::basic_string_view`` is used for format strings even
+  if ``std::string_view`` is available to prevent issues when a library is
+  compiled with a different ``-std`` option than the client code (which is not
+  recommended).
+ */
+template <typename Char> class basic_string_view {
+ private:
+  const Char* data_;
+  size_t size_;
+
+ public:
+  using char_type FMT_DEPRECATED_ALIAS = Char;
+  using value_type = Char;
+  using iterator = const Char*;
+
+  FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(nullptr), size_(0) {}
+
+  /** Constructs a string reference object from a C string and a size. */
+  FMT_CONSTEXPR basic_string_view(const Char* s, size_t count) FMT_NOEXCEPT
+      : data_(s),
+        size_(count) {}
+
+  /**
+    \rst
+    Constructs a string reference object from a C string computing
+    the size with ``std::char_traits<Char>::length``.
+    \endrst
+   */
+#if __cplusplus >= 201703L  // C++17's char_traits::length() is constexpr.
+  FMT_CONSTEXPR
+#endif
+  basic_string_view(const Char* s)
+      : data_(s), size_(std::char_traits<Char>::length(s)) {}
+
+  /** Constructs a string reference from a ``std::basic_string`` object. */
+  template <typename Traits, typename Alloc>
+  FMT_CONSTEXPR basic_string_view(
+      const std::basic_string<Char, Traits, Alloc>& s) FMT_NOEXCEPT
+      : data_(s.data()),
+        size_(s.size()) {}
+
+  template <
+      typename S,
+      FMT_ENABLE_IF(std::is_same<S, internal::std_string_view<Char>>::value)>
+  FMT_CONSTEXPR basic_string_view(S s) FMT_NOEXCEPT : data_(s.data()),
+                                                      size_(s.size()) {}
+
+  /** Returns a pointer to the string data. */
+  FMT_CONSTEXPR const Char* data() const { return data_; }
+
+  /** Returns the string size. */
+  FMT_CONSTEXPR size_t size() const { return size_; }
+
+  FMT_CONSTEXPR iterator begin() const { return data_; }
+  FMT_CONSTEXPR iterator end() const { return data_ + size_; }
+
+  FMT_CONSTEXPR const Char& operator[](size_t pos) const { return data_[pos]; }
+
+  FMT_CONSTEXPR void remove_prefix(size_t n) {
+    data_ += n;
+    size_ -= n;
+  }
+
+  // Lexicographically compare this string reference to other.
+  int compare(basic_string_view other) const {
+    size_t str_size = size_ < other.size_ ? size_ : other.size_;
+    int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
+    if (result == 0)
+      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
+    return result;
+  }
+
+  friend bool operator==(basic_string_view lhs, basic_string_view rhs) {
+    return lhs.compare(rhs) == 0;
+  }
+  friend bool operator!=(basic_string_view lhs, basic_string_view rhs) {
+    return lhs.compare(rhs) != 0;
+  }
+  friend bool operator<(basic_string_view lhs, basic_string_view rhs) {
+    return lhs.compare(rhs) < 0;
+  }
+  friend bool operator<=(basic_string_view lhs, basic_string_view rhs) {
+    return lhs.compare(rhs) <= 0;
+  }
+  friend bool operator>(basic_string_view lhs, basic_string_view rhs) {
+    return lhs.compare(rhs) > 0;
+  }
+  friend bool operator>=(basic_string_view lhs, basic_string_view rhs) {
+    return lhs.compare(rhs) >= 0;
+  }
+};
+
+using string_view = basic_string_view<char>;
+using wstring_view = basic_string_view<wchar_t>;
+
+#ifndef __cpp_char8_t
+// char8_t is deprecated; use char instead.
+using char8_t FMT_DEPRECATED_ALIAS = internal::char8_type;
+#endif
+
+/** Specifies if ``T`` is a character type. Can be specialized by users. */
+template <typename T> struct is_char : std::false_type {};
+template <> struct is_char<char> : std::true_type {};
+template <> struct is_char<wchar_t> : std::true_type {};
+template <> struct is_char<internal::char8_type> : std::true_type {};
+template <> struct is_char<char16_t> : std::true_type {};
+template <> struct is_char<char32_t> : std::true_type {};
+
+/**
+  \rst
+  Returns a string view of `s`. In order to add custom string type support to
+  {fmt} provide an overload of `to_string_view` for it in the same namespace as
+  the type for the argument-dependent lookup to work.
+
+  **Example**::
+
+    namespace my_ns {
+    inline string_view to_string_view(const my_string& s) {
+      return {s.data(), s.length()};
+    }
+    }
+    std::string message = fmt::format(my_string("The answer is {}"), 42);
+  \endrst
+ */
+template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)>
+inline basic_string_view<Char> to_string_view(const Char* s) {
+  return s;
+}
+
+template <typename Char, typename Traits, typename Alloc>
+inline basic_string_view<Char> to_string_view(
+    const std::basic_string<Char, Traits, Alloc>& s) {
+  return s;
+}
+
+template <typename Char>
+inline basic_string_view<Char> to_string_view(basic_string_view<Char> s) {
+  return s;
+}
+
+template <typename Char,
+          FMT_ENABLE_IF(!std::is_empty<internal::std_string_view<Char>>::value)>
+inline basic_string_view<Char> to_string_view(
+    internal::std_string_view<Char> s) {
+  return s;
+}
+
+// A base class for compile-time strings. It is defined in the fmt namespace to
+// make formatting functions visible via ADL, e.g. format(fmt("{}"), 42).
+struct compile_string {};
+
+template <typename S>
+struct is_compile_string : std::is_base_of<compile_string, S> {};
+
+template <typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
+constexpr basic_string_view<typename S::char_type> to_string_view(const S& s) {
+  return s;
+}
+
+namespace internal {
+void to_string_view(...);
+using fmt::v6::to_string_view;
+
+// Specifies whether S is a string type convertible to fmt::basic_string_view.
+// It should be a constexpr function but MSVC 2017 fails to compile it in
+// enable_if and MSVC 2015 fails to compile it as an alias template.
+template <typename S>
+struct is_string : std::is_class<decltype(to_string_view(std::declval<S>()))> {
+};
+
+template <typename S, typename = void> struct char_t_impl {};
+template <typename S> struct char_t_impl<S, enable_if_t<is_string<S>::value>> {
+  using result = decltype(to_string_view(std::declval<S>()));
+  using type = typename result::value_type;
+};
+
+struct error_handler {
+  FMT_CONSTEXPR error_handler() = default;
+  FMT_CONSTEXPR error_handler(const error_handler&) = default;
+
+  // This function is intentionally not constexpr to give a compile-time error.
+  FMT_NORETURN FMT_API void on_error(const char* message);
+};
+}  // namespace internal
+
+/** String's character type. */
+template <typename S> using char_t = typename internal::char_t_impl<S>::type;
+
+/**
+  \rst
+  Parsing context consisting of a format string range being parsed and an
+  argument counter for automatic indexing.
+
+  You can use one of the following type aliases for common character types:
+
+  +-----------------------+-------------------------------------+
+  | Type                  | Definition                          |
+  +=======================+=====================================+
+  | format_parse_context  | basic_format_parse_context<char>    |
+  +-----------------------+-------------------------------------+
+  | wformat_parse_context | basic_format_parse_context<wchar_t> |
+  +-----------------------+-------------------------------------+
+  \endrst
+ */
+template <typename Char, typename ErrorHandler = internal::error_handler>
+class basic_format_parse_context : private ErrorHandler {
+ private:
+  basic_string_view<Char> format_str_;
+  int next_arg_id_;
+
+ public:
+  using char_type = Char;
+  using iterator = typename basic_string_view<Char>::iterator;
+
+  explicit FMT_CONSTEXPR basic_format_parse_context(
+      basic_string_view<Char> format_str, ErrorHandler eh = ErrorHandler())
+      : ErrorHandler(eh), format_str_(format_str), next_arg_id_(0) {}
+
+  /**
+    Returns an iterator to the beginning of the format string range being
+    parsed.
+   */
+  FMT_CONSTEXPR iterator begin() const FMT_NOEXCEPT {
+    return format_str_.begin();
+  }
+
+  /**
+    Returns an iterator past the end of the format string range being parsed.
+   */
+  FMT_CONSTEXPR iterator end() const FMT_NOEXCEPT { return format_str_.end(); }
+
+  /** Advances the begin iterator to ``it``. */
+  FMT_CONSTEXPR void advance_to(iterator it) {
+    format_str_.remove_prefix(internal::to_unsigned(it - begin()));
+  }
+
+  /**
+    Reports an error if using the manual argument indexing; otherwise returns
+    the next argument index and switches to the automatic indexing.
+   */
+  FMT_CONSTEXPR int next_arg_id() {
+    if (next_arg_id_ >= 0) return next_arg_id_++;
+    on_error("cannot switch from manual to automatic argument indexing");
+    return 0;
+  }
+
+  /**
+    Reports an error if using the automatic argument indexing; otherwise
+    switches to the manual indexing.
+   */
+  FMT_CONSTEXPR void check_arg_id(int) {
+    if (next_arg_id_ > 0)
+      on_error("cannot switch from automatic to manual argument indexing");
+    else
+      next_arg_id_ = -1;
+  }
+
+  FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {}
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    ErrorHandler::on_error(message);
+  }
+
+  FMT_CONSTEXPR ErrorHandler error_handler() const { return *this; }
+};
+
+using format_parse_context = basic_format_parse_context<char>;
+using wformat_parse_context = basic_format_parse_context<wchar_t>;
+
+template <typename Char, typename ErrorHandler = internal::error_handler>
+using basic_parse_context FMT_DEPRECATED_ALIAS =
+    basic_format_parse_context<Char, ErrorHandler>;
+using parse_context FMT_DEPRECATED_ALIAS = basic_format_parse_context<char>;
+using wparse_context FMT_DEPRECATED_ALIAS = basic_format_parse_context<wchar_t>;
+
+template <typename Context> class basic_format_arg;
+template <typename Context> class basic_format_args;
+
+// A formatter for objects of type T.
+template <typename T, typename Char = char, typename Enable = void>
+struct formatter {
+  // A deleted default constructor indicates a disabled formatter.
+  formatter() = delete;
+};
+
+template <typename T, typename Char, typename Enable = void>
+struct FMT_DEPRECATED convert_to_int
+    : bool_constant<!std::is_arithmetic<T>::value &&
+                    std::is_convertible<T, int>::value> {};
+
+// Specifies if T has an enabled formatter specialization. A type can be
+// formattable even if it doesn't have a formatter e.g. via a conversion.
+template <typename T, typename Context>
+using has_formatter =
+    std::is_constructible<typename Context::template formatter_type<T>>;
+
+namespace internal {
+
+/** A contiguous memory buffer with an optional growing ability. */
+template <typename T> class buffer {
+ private:
+  T* ptr_;
+  std::size_t size_;
+  std::size_t capacity_;
+
+ protected:
+  // Don't initialize ptr_ since it is not accessed to save a few cycles.
+  buffer(std::size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {}
+
+  buffer(T* p = nullptr, std::size_t sz = 0, std::size_t cap = 0) FMT_NOEXCEPT
+      : ptr_(p),
+        size_(sz),
+        capacity_(cap) {}
+
+  /** Sets the buffer data and capacity. */
+  void set(T* buf_data, std::size_t buf_capacity) FMT_NOEXCEPT {
+    ptr_ = buf_data;
+    capacity_ = buf_capacity;
+  }
+
+  /** Increases the buffer capacity to hold at least *capacity* elements. */
+  virtual void grow(std::size_t capacity) = 0;
+
+ public:
+  using value_type = T;
+  using const_reference = const T&;
+
+  buffer(const buffer&) = delete;
+  void operator=(const buffer&) = delete;
+  virtual ~buffer() = default;
+
+  T* begin() FMT_NOEXCEPT { return ptr_; }
+  T* end() FMT_NOEXCEPT { return ptr_ + size_; }
+
+  const T* begin() const FMT_NOEXCEPT { return ptr_; }
+  const T* end() const FMT_NOEXCEPT { return ptr_ + size_; }
+
+  /** Returns the size of this buffer. */
+  std::size_t size() const FMT_NOEXCEPT { return size_; }
+
+  /** Returns the capacity of this buffer. */
+  std::size_t capacity() const FMT_NOEXCEPT { return capacity_; }
+
+  /** Returns a pointer to the buffer data. */
+  T* data() FMT_NOEXCEPT { return ptr_; }
+
+  /** Returns a pointer to the buffer data. */
+  const T* data() const FMT_NOEXCEPT { return ptr_; }
+
+  /**
+    Resizes the buffer. If T is a POD type new elements may not be initialized.
+   */
+  void resize(std::size_t new_size) {
+    reserve(new_size);
+    size_ = new_size;
+  }
+
+  /** Clears this buffer. */
+  void clear() { size_ = 0; }
+
+  /** Reserves space to store at least *capacity* elements. */
+  void reserve(std::size_t new_capacity) {
+    if (new_capacity > capacity_) grow(new_capacity);
+  }
+
+  void push_back(const T& value) {
+    reserve(size_ + 1);
+    ptr_[size_++] = value;
+  }
+
+  /** Appends data to the end of the buffer. */
+  template <typename U> void append(const U* begin, const U* end);
+
+  template <typename I> T& operator[](I index) { return ptr_[index]; }
+  template <typename I> const T& operator[](I index) const {
+    return ptr_[index];
+  }
+};
+
+// A container-backed buffer.
+template <typename Container>
+class container_buffer : public buffer<typename Container::value_type> {
+ private:
+  Container& container_;
+
+ protected:
+  void grow(std::size_t capacity) FMT_OVERRIDE {
+    container_.resize(capacity);
+    this->set(&container_[0], capacity);
+  }
+
+ public:
+  explicit container_buffer(Container& c)
+      : buffer<typename Container::value_type>(c.size()), container_(c) {}
+};
+
+// Extracts a reference to the container from back_insert_iterator.
+template <typename Container>
+inline Container& get_container(std::back_insert_iterator<Container> it) {
+  using bi_iterator = std::back_insert_iterator<Container>;
+  struct accessor : bi_iterator {
+    accessor(bi_iterator iter) : bi_iterator(iter) {}
+    using bi_iterator::container;
+  };
+  return *accessor(it).container;
+}
+
+template <typename T, typename Char = char, typename Enable = void>
+struct fallback_formatter {
+  fallback_formatter() = delete;
+};
+
+// Specifies if T has an enabled fallback_formatter specialization.
+template <typename T, typename Context>
+using has_fallback_formatter =
+    std::is_constructible<fallback_formatter<T, typename Context::char_type>>;
+
+template <typename Char> struct named_arg_base;
+template <typename T, typename Char> struct named_arg;
+
+enum class type {
+  none_type,
+  named_arg_type,
+  // Integer types should go first,
+  int_type,
+  uint_type,
+  long_long_type,
+  ulong_long_type,
+  int128_type,
+  uint128_type,
+  bool_type,
+  char_type,
+  last_integer_type = char_type,
+  // followed by floating-point types.
+  float_type,
+  double_type,
+  long_double_type,
+  last_numeric_type = long_double_type,
+  cstring_type,
+  string_type,
+  pointer_type,
+  custom_type
+};
+
+// Maps core type T to the corresponding type enum constant.
+template <typename T, typename Char>
+struct type_constant : std::integral_constant<type, type::custom_type> {};
+
+#define FMT_TYPE_CONSTANT(Type, constant) \
+  template <typename Char>                \
+  struct type_constant<Type, Char>        \
+      : std::integral_constant<type, type::constant> {}
+
+FMT_TYPE_CONSTANT(const named_arg_base<Char>&, named_arg_type);
+FMT_TYPE_CONSTANT(int, int_type);
+FMT_TYPE_CONSTANT(unsigned, uint_type);
+FMT_TYPE_CONSTANT(long long, long_long_type);
+FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);
+FMT_TYPE_CONSTANT(int128_t, int128_type);
+FMT_TYPE_CONSTANT(uint128_t, uint128_type);
+FMT_TYPE_CONSTANT(bool, bool_type);
+FMT_TYPE_CONSTANT(Char, char_type);
+FMT_TYPE_CONSTANT(float, float_type);
+FMT_TYPE_CONSTANT(double, double_type);
+FMT_TYPE_CONSTANT(long double, long_double_type);
+FMT_TYPE_CONSTANT(const Char*, cstring_type);
+FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
+FMT_TYPE_CONSTANT(const void*, pointer_type);
+
+FMT_CONSTEXPR bool is_integral_type(type t) {
+  FMT_ASSERT(t != type::named_arg_type, "invalid argument type");
+  return t > type::none_type && t <= type::last_integer_type;
+}
+
+FMT_CONSTEXPR bool is_arithmetic_type(type t) {
+  FMT_ASSERT(t != type::named_arg_type, "invalid argument type");
+  return t > type::none_type && t <= type::last_numeric_type;
+}
+
+template <typename Char> struct string_value {
+  const Char* data;
+  std::size_t size;
+};
+
+template <typename Context> struct custom_value {
+  using parse_context = basic_format_parse_context<typename Context::char_type>;
+  const void* value;
+  void (*format)(const void* arg, parse_context& parse_ctx, Context& ctx);
+};
+
+// A formatting argument value.
+template <typename Context> class value {
+ public:
+  using char_type = typename Context::char_type;
+
+  union {
+    int int_value;
+    unsigned uint_value;
+    long long long_long_value;
+    unsigned long long ulong_long_value;
+    int128_t int128_value;
+    uint128_t uint128_value;
+    bool bool_value;
+    char_type char_value;
+    float float_value;
+    double double_value;
+    long double long_double_value;
+    const void* pointer;
+    string_value<char_type> string;
+    custom_value<Context> custom;
+    const named_arg_base<char_type>* named_arg;
+  };
+
+  FMT_CONSTEXPR value(int val = 0) : int_value(val) {}
+  FMT_CONSTEXPR value(unsigned val) : uint_value(val) {}
+  value(long long val) : long_long_value(val) {}
+  value(unsigned long long val) : ulong_long_value(val) {}
+  value(int128_t val) : int128_value(val) {}
+  value(uint128_t val) : uint128_value(val) {}
+  value(float val) : float_value(val) {}
+  value(double val) : double_value(val) {}
+  value(long double val) : long_double_value(val) {}
+  value(bool val) : bool_value(val) {}
+  value(char_type val) : char_value(val) {}
+  value(const char_type* val) { string.data = val; }
+  value(basic_string_view<char_type> val) {
+    string.data = val.data();
+    string.size = val.size();
+  }
+  value(const void* val) : pointer(val) {}
+
+  template <typename T> value(const T& val) {
+    custom.value = &val;
+    // Get the formatter type through the context to allow different contexts
+    // have different extension points, e.g. `formatter<T>` for `format` and
+    // `printf_formatter<T>` for `printf`.
+    custom.format = format_custom_arg<
+        T, conditional_t<has_formatter<T, Context>::value,
+                         typename Context::template formatter_type<T>,
+                         fallback_formatter<T, char_type>>>;
+  }
+
+  value(const named_arg_base<char_type>& val) { named_arg = &val; }
+
+ private:
+  // Formats an argument of a custom type, such as a user-defined class.
+  template <typename T, typename Formatter>
+  static void format_custom_arg(
+      const void* arg, basic_format_parse_context<char_type>& parse_ctx,
+      Context& ctx) {
+    Formatter f;
+    parse_ctx.advance_to(f.parse(parse_ctx));
+    ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
+  }
+};
+
+template <typename Context, typename T>
+FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T& value);
+
+// To minimize the number of types we need to deal with, long is translated
+// either to int or to long long depending on its size.
+enum { long_short = sizeof(long) == sizeof(int) };
+using long_type = conditional_t<long_short, int, long long>;
+using ulong_type = conditional_t<long_short, unsigned, unsigned long long>;
+
+// Maps formatting arguments to core types.
+template <typename Context> struct arg_mapper {
+  using char_type = typename Context::char_type;
+
+  FMT_CONSTEXPR int map(signed char val) { return val; }
+  FMT_CONSTEXPR unsigned map(unsigned char val) { return val; }
+  FMT_CONSTEXPR int map(short val) { return val; }
+  FMT_CONSTEXPR unsigned map(unsigned short val) { return val; }
+  FMT_CONSTEXPR int map(int val) { return val; }
+  FMT_CONSTEXPR unsigned map(unsigned val) { return val; }
+  FMT_CONSTEXPR long_type map(long val) { return val; }
+  FMT_CONSTEXPR ulong_type map(unsigned long val) { return val; }
+  FMT_CONSTEXPR long long map(long long val) { return val; }
+  FMT_CONSTEXPR unsigned long long map(unsigned long long val) { return val; }
+  FMT_CONSTEXPR int128_t map(int128_t val) { return val; }
+  FMT_CONSTEXPR uint128_t map(uint128_t val) { return val; }
+  FMT_CONSTEXPR bool map(bool val) { return val; }
+
+  template <typename T, FMT_ENABLE_IF(is_char<T>::value)>
+  FMT_CONSTEXPR char_type map(T val) {
+    static_assert(
+        std::is_same<T, char>::value || std::is_same<T, char_type>::value,
+        "mixing character types is disallowed");
+    return val;
+  }
+
+  FMT_CONSTEXPR float map(float val) { return val; }
+  FMT_CONSTEXPR double map(double val) { return val; }
+  FMT_CONSTEXPR long double map(long double val) { return val; }
+
+  FMT_CONSTEXPR const char_type* map(char_type* val) { return val; }
+  FMT_CONSTEXPR const char_type* map(const char_type* val) { return val; }
+  template <typename T, FMT_ENABLE_IF(is_string<T>::value)>
+  FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
+    static_assert(std::is_same<char_type, char_t<T>>::value,
+                  "mixing character types is disallowed");
+    return to_string_view(val);
+  }
+  template <typename T,
+            FMT_ENABLE_IF(
+                std::is_constructible<basic_string_view<char_type>, T>::value &&
+                !is_string<T>::value && !has_formatter<T, Context>::value &&
+                !has_fallback_formatter<T, Context>::value)>
+  FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
+    return basic_string_view<char_type>(val);
+  }
+  template <
+      typename T,
+      FMT_ENABLE_IF(
+          std::is_constructible<std_string_view<char_type>, T>::value &&
+          !std::is_constructible<basic_string_view<char_type>, T>::value &&
+          !is_string<T>::value && !has_formatter<T, Context>::value &&
+          !has_fallback_formatter<T, Context>::value)>
+  FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
+    return std_string_view<char_type>(val);
+  }
+  FMT_CONSTEXPR const char* map(const signed char* val) {
+    static_assert(std::is_same<char_type, char>::value, "invalid string type");
+    return reinterpret_cast<const char*>(val);
+  }
+  FMT_CONSTEXPR const char* map(const unsigned char* val) {
+    static_assert(std::is_same<char_type, char>::value, "invalid string type");
+    return reinterpret_cast<const char*>(val);
+  }
+
+  FMT_CONSTEXPR const void* map(void* val) { return val; }
+  FMT_CONSTEXPR const void* map(const void* val) { return val; }
+  FMT_CONSTEXPR const void* map(std::nullptr_t val) { return val; }
+  template <typename T> FMT_CONSTEXPR int map(const T*) {
+    // Formatting of arbitrary pointers is disallowed. If you want to output
+    // a pointer cast it to "void *" or "const void *". In particular, this
+    // forbids formatting of "[const] volatile char *" which is printed as bool
+    // by iostreams.
+    static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
+    return 0;
+  }
+
+  template <typename T,
+            FMT_ENABLE_IF(std::is_enum<T>::value &&
+                          !has_formatter<T, Context>::value &&
+                          !has_fallback_formatter<T, Context>::value)>
+  FMT_CONSTEXPR auto map(const T& val)
+      -> decltype(std::declval<arg_mapper>().map(
+          static_cast<typename std::underlying_type<T>::type>(val))) {
+    return map(static_cast<typename std::underlying_type<T>::type>(val));
+  }
+  template <typename T,
+            FMT_ENABLE_IF(!is_string<T>::value && !is_char<T>::value &&
+                          (has_formatter<T, Context>::value ||
+                           has_fallback_formatter<T, Context>::value))>
+  FMT_CONSTEXPR const T& map(const T& val) {
+    return val;
+  }
+
+  template <typename T>
+  FMT_CONSTEXPR const named_arg_base<char_type>& map(
+      const named_arg<T, char_type>& val) {
+    auto arg = make_arg<Context>(val.value);
+    std::memcpy(val.data, &arg, sizeof(arg));
+    return val;
+  }
+
+  int map(...) {
+    constexpr bool formattable = sizeof(Context) == 0;
+    static_assert(
+        formattable,
+        "Cannot format argument. To make type T formattable provide a "
+        "formatter<T> specialization: "
+        "https://fmt.dev/latest/api.html#formatting-user-defined-types");
+    return 0;
+  }
+};
+
+// A type constant after applying arg_mapper<Context>.
+template <typename T, typename Context>
+using mapped_type_constant =
+    type_constant<decltype(arg_mapper<Context>().map(std::declval<const T&>())),
+                  typename Context::char_type>;
+
+enum { packed_arg_bits = 5 };
+// Maximum number of arguments with packed types.
+enum { max_packed_args = 63 / packed_arg_bits };
+enum : unsigned long long { is_unpacked_bit = 1ULL << 63 };
+
+template <typename Context> class arg_map;
+}  // namespace internal
+
+// A formatting argument. It is a trivially copyable/constructible type to
+// allow storage in basic_memory_buffer.
+template <typename Context> class basic_format_arg {
+ private:
+  internal::value<Context> value_;
+  internal::type type_;
+
+  template <typename ContextType, typename T>
+  friend FMT_CONSTEXPR basic_format_arg<ContextType> internal::make_arg(
+      const T& value);
+
+  template <typename Visitor, typename Ctx>
+  friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
+                                             const basic_format_arg<Ctx>& arg)
+      -> decltype(vis(0));
+
+  friend class basic_format_args<Context>;
+  friend class internal::arg_map<Context>;
+
+  using char_type = typename Context::char_type;
+
+ public:
+  class handle {
+   public:
+    explicit handle(internal::custom_value<Context> custom) : custom_(custom) {}
+
+    void format(basic_format_parse_context<char_type>& parse_ctx,
+                Context& ctx) const {
+      custom_.format(custom_.value, parse_ctx, ctx);
+    }
+
+   private:
+    internal::custom_value<Context> custom_;
+  };
+
+  FMT_CONSTEXPR basic_format_arg() : type_(internal::type::none_type) {}
+
+  FMT_CONSTEXPR explicit operator bool() const FMT_NOEXCEPT {
+    return type_ != internal::type::none_type;
+  }
+
+  internal::type type() const { return type_; }
+
+  bool is_integral() const { return internal::is_integral_type(type_); }
+  bool is_arithmetic() const { return internal::is_arithmetic_type(type_); }
+};
+
+/**
+  \rst
+  Visits an argument dispatching to the appropriate visit method based on
+  the argument type. For example, if the argument type is ``double`` then
+  ``vis(value)`` will be called with the value of type ``double``.
+  \endrst
+ */
+template <typename Visitor, typename Context>
+FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
+                                    const basic_format_arg<Context>& arg)
+    -> decltype(vis(0)) {
+  using char_type = typename Context::char_type;
+  switch (arg.type_) {
+  case internal::type::none_type:
+    break;
+  case internal::type::named_arg_type:
+    FMT_ASSERT(false, "invalid argument type");
+    break;
+  case internal::type::int_type:
+    return vis(arg.value_.int_value);
+  case internal::type::uint_type:
+    return vis(arg.value_.uint_value);
+  case internal::type::long_long_type:
+    return vis(arg.value_.long_long_value);
+  case internal::type::ulong_long_type:
+    return vis(arg.value_.ulong_long_value);
+#if FMT_USE_INT128
+  case internal::type::int128_type:
+    return vis(arg.value_.int128_value);
+  case internal::type::uint128_type:
+    return vis(arg.value_.uint128_value);
+#else
+  case internal::type::int128_type:
+  case internal::type::uint128_type:
+    break;
+#endif
+  case internal::type::bool_type:
+    return vis(arg.value_.bool_value);
+  case internal::type::char_type:
+    return vis(arg.value_.char_value);
+  case internal::type::float_type:
+    return vis(arg.value_.float_value);
+  case internal::type::double_type:
+    return vis(arg.value_.double_value);
+  case internal::type::long_double_type:
+    return vis(arg.value_.long_double_value);
+  case internal::type::cstring_type:
+    return vis(arg.value_.string.data);
+  case internal::type::string_type:
+    return vis(basic_string_view<char_type>(arg.value_.string.data,
+                                            arg.value_.string.size));
+  case internal::type::pointer_type:
+    return vis(arg.value_.pointer);
+  case internal::type::custom_type:
+    return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
+  }
+  return vis(monostate());
+}
+
+namespace internal {
+// A map from argument names to their values for named arguments.
+template <typename Context> class arg_map {
+ private:
+  using char_type = typename Context::char_type;
+
+  struct entry {
+    basic_string_view<char_type> name;
+    basic_format_arg<Context> arg;
+  };
+
+  entry* map_;
+  unsigned size_;
+
+  void push_back(value<Context> val) {
+    const auto& named = *val.named_arg;
+    map_[size_] = {named.name, named.template deserialize<Context>()};
+    ++size_;
+  }
+
+ public:
+  arg_map(const arg_map&) = delete;
+  void operator=(const arg_map&) = delete;
+  arg_map() : map_(nullptr), size_(0) {}
+  void init(const basic_format_args<Context>& args);
+  ~arg_map() { delete[] map_; }
+
+  basic_format_arg<Context> find(basic_string_view<char_type> name) const {
+    // The list is unsorted, so just return the first matching name.
+    for (entry *it = map_, *end = map_ + size_; it != end; ++it) {
+      if (it->name == name) return it->arg;
+    }
+    return {};
+  }
+};
+
+// A type-erased reference to an std::locale to avoid heavy <locale> include.
+class locale_ref {
+ private:
+  const void* locale_;  // A type-erased pointer to std::locale.
+
+ public:
+  locale_ref() : locale_(nullptr) {}
+  template <typename Locale> explicit locale_ref(const Locale& loc);
+
+  explicit operator bool() const FMT_NOEXCEPT { return locale_ != nullptr; }
+
+  template <typename Locale> Locale get() const;
+};
+
+template <typename> constexpr unsigned long long encode_types() { return 0; }
+
+template <typename Context, typename Arg, typename... Args>
+constexpr unsigned long long encode_types() {
+  return static_cast<unsigned>(mapped_type_constant<Arg, Context>::value) |
+         (encode_types<Context, Args...>() << packed_arg_bits);
+}
+
+template <typename Context, typename T>
+FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T& value) {
+  basic_format_arg<Context> arg;
+  arg.type_ = mapped_type_constant<T, Context>::value;
+  arg.value_ = arg_mapper<Context>().map(value);
+  return arg;
+}
+
+template <bool IS_PACKED, typename Context, typename T,
+          FMT_ENABLE_IF(IS_PACKED)>
+inline value<Context> make_arg(const T& val) {
+  return arg_mapper<Context>().map(val);
+}
+
+template <bool IS_PACKED, typename Context, typename T,
+          FMT_ENABLE_IF(!IS_PACKED)>
+inline basic_format_arg<Context> make_arg(const T& value) {
+  return make_arg<Context>(value);
+}
+
+template <typename T> struct is_reference_wrapper : std::false_type {};
+
+template <typename T>
+struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
+
+class dynamic_arg_list {
+  // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
+  // templates it doesn't complain about inability to deduce single translation
+  // unit for placing vtable. So storage_node_base is made a fake template.
+  template <typename = void> struct node {
+    virtual ~node() = default;
+    std::unique_ptr<node<>> next;
+  };
+
+  template <typename T> struct typed_node : node<> {
+    T value;
+
+    template <typename Arg>
+    FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}
+
+    template <typename Char>
+    FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg)
+        : value(arg.data(), arg.size()) {}
+  };
+
+  std::unique_ptr<node<>> head_;
+
+ public:
+  template <typename T, typename Arg> const T& push(const Arg& arg) {
+    auto node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
+    auto& value = node->value;
+    node->next = std::move(head_);
+    head_ = std::move(node);
+    return value;
+  }
+};
+}  // namespace internal
+
+// Formatting context.
+template <typename OutputIt, typename Char> class basic_format_context {
+ public:
+  /** The character type for the output. */
+  using char_type = Char;
+
+ private:
+  OutputIt out_;
+  basic_format_args<basic_format_context> args_;
+  internal::arg_map<basic_format_context> map_;
+  internal::locale_ref loc_;
+
+ public:
+  using iterator = OutputIt;
+  using format_arg = basic_format_arg<basic_format_context>;
+  template <typename T> using formatter_type = formatter<T, char_type>;
+
+  basic_format_context(const basic_format_context&) = delete;
+  void operator=(const basic_format_context&) = delete;
+  /**
+   Constructs a ``basic_format_context`` object. References to the arguments are
+   stored in the object so make sure they have appropriate lifetimes.
+   */
+  basic_format_context(OutputIt out,
+                       basic_format_args<basic_format_context> ctx_args,
+                       internal::locale_ref loc = internal::locale_ref())
+      : out_(out), args_(ctx_args), loc_(loc) {}
+
+  format_arg arg(int id) const { return args_.get(id); }
+
+  // Checks if manual indexing is used and returns the argument with the
+  // specified name.
+  format_arg arg(basic_string_view<char_type> name);
+
+  internal::error_handler error_handler() { return {}; }
+  void on_error(const char* message) { error_handler().on_error(message); }
+
+  // Returns an iterator to the beginning of the output range.
+  iterator out() { return out_; }
+
+  // Advances the begin iterator to ``it``.
+  void advance_to(iterator it) { out_ = it; }
+
+  internal::locale_ref locale() { return loc_; }
+};
+
+template <typename Char>
+using buffer_context =
+    basic_format_context<std::back_insert_iterator<internal::buffer<Char>>,
+                         Char>;
+using format_context = buffer_context<char>;
+using wformat_context = buffer_context<wchar_t>;
+
+/**
+  \rst
+  An array of references to arguments. It can be implicitly converted into
+  `~fmt::basic_format_args` for passing into type-erased formatting functions
+  such as `~fmt::vformat`.
+  \endrst
+ */
+template <typename Context, typename... Args>
+class format_arg_store
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+    // Workaround a GCC template argument substitution bug.
+    : public basic_format_args<Context>
+#endif
+{
+ private:
+  static const size_t num_args = sizeof...(Args);
+  static const bool is_packed = num_args < internal::max_packed_args;
+
+  using value_type = conditional_t<is_packed, internal::value<Context>,
+                                   basic_format_arg<Context>>;
+
+  // If the arguments are not packed, add one more element to mark the end.
+  value_type data_[num_args + (num_args == 0 ? 1 : 0)];
+
+  friend class basic_format_args<Context>;
+
+ public:
+  static constexpr unsigned long long types =
+      is_packed ? internal::encode_types<Context, Args...>()
+                : internal::is_unpacked_bit | num_args;
+
+  format_arg_store(const Args&... args)
+      :
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+        basic_format_args<Context>(*this),
+#endif
+        data_{internal::make_arg<is_packed, Context>(args)...} {
+  }
+};
+
+/**
+  \rst
+  Constructs an `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::format_args`. `Context`
+  can be omitted in which case it defaults to `~fmt::context`.
+  See `~fmt::arg` for lifetime considerations.
+  \endrst
+ */
+template <typename Context = format_context, typename... Args>
+inline format_arg_store<Context, Args...> make_format_args(
+    const Args&... args) {
+  return {args...};
+}
+
+/**
+  \rst
+  A dynamic version of `fmt::format_arg_store<>`.
+  It's equipped with a storage to potentially temporary objects which lifetime
+  could be shorter than the format arguments object.
+
+  It can be implicitly converted into `~fmt::basic_format_args` for passing
+  into type-erased formatting functions such as `~fmt::vformat`.
+  \endrst
+ */
+template <typename Context>
+class dynamic_format_arg_store
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+    // Workaround a GCC template argument substitution bug.
+    : public basic_format_args<Context>
+#endif
+{
+ private:
+  using char_type = typename Context::char_type;
+
+  template <typename T> struct need_copy {
+    static constexpr internal::type mapped_type =
+        internal::mapped_type_constant<T, Context>::value;
+
+    enum {
+      value = !(internal::is_reference_wrapper<T>::value ||
+                std::is_same<T, basic_string_view<char_type>>::value ||
+                std::is_same<T, internal::std_string_view<char_type>>::value ||
+                (mapped_type != internal::type::cstring_type &&
+                 mapped_type != internal::type::string_type &&
+                 mapped_type != internal::type::custom_type &&
+                 mapped_type != internal::type::named_arg_type))
+    };
+  };
+
+  template <typename T>
+  using stored_type = conditional_t<internal::is_string<T>::value,
+                                    std::basic_string<char_type>, T>;
+
+  // Storage of basic_format_arg must be contiguous.
+  std::vector<basic_format_arg<Context>> data_;
+
+  // Storage of arguments not fitting into basic_format_arg must grow
+  // without relocation because items in data_ refer to it.
+  internal::dynamic_arg_list dynamic_args_;
+
+  friend class basic_format_args<Context>;
+
+  unsigned long long get_types() const {
+    return internal::is_unpacked_bit | data_.size();
+  }
+
+  template <typename T> void emplace_arg(const T& arg) {
+    data_.emplace_back(internal::make_arg<Context>(arg));
+  }
+
+ public:
+  /**
+    \rst
+    Adds an argument into the dynamic store for later passing to a formating
+    function.
+
+    Note that custom types and string types (but not string views!) are copied
+    into the store with dynamic memory (in addition to resizing vector).
+
+    **Example**::
+
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
+      store.push_back(42);
+      store.push_back("abc");
+      store.push_back(1.5f);
+      std::string result = fmt::vformat("{} and {} and {}", store);
+    \endrst
+  */
+  template <typename T> void push_back(const T& arg) {
+    static_assert(
+        !std::is_base_of<internal::named_arg_base<char_type>, T>::value,
+        "named arguments are not supported yet");
+    if (internal::const_check(need_copy<T>::value))
+      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
+    else
+      emplace_arg(arg);
+  }
+
+  /**
+    Adds a reference to the argument into the dynamic store for later passing to
+    a formating function.
+  */
+  template <typename T> void push_back(std::reference_wrapper<T> arg) {
+    static_assert(
+        need_copy<T>::value,
+        "objects of built-in types and string views are always copied");
+    emplace_arg(arg.get());
+  }
+};
+
+/**
+  \rst
+  A view of a collection of formatting arguments. To avoid lifetime issues it
+  should only be used as a parameter type in type-erased functions such as
+  ``vformat``::
+
+    void vlog(string_view format_str, format_args args);  // OK
+    format_args args = make_format_args(42);  // Error: dangling reference
+  \endrst
+ */
+template <typename Context> class basic_format_args {
+ public:
+  using size_type = int;
+  using format_arg = basic_format_arg<Context>;
+
+ private:
+  // To reduce compiled code size per formatting function call, types of first
+  // max_packed_args arguments are passed in the types_ field.
+  unsigned long long types_;
+  union {
+    // If the number of arguments is less than max_packed_args, the argument
+    // values are stored in values_, otherwise they are stored in args_.
+    // This is done to reduce compiled code size as storing larger objects
+    // may require more code (at least on x86-64) even if the same amount of
+    // data is actually copied to stack. It saves ~10% on the bloat test.
+    const internal::value<Context>* values_;
+    const format_arg* args_;
+  };
+
+  bool is_packed() const { return (types_ & internal::is_unpacked_bit) == 0; }
+
+  internal::type type(int index) const {
+    int shift = index * internal::packed_arg_bits;
+    unsigned int mask = (1 << internal::packed_arg_bits) - 1;
+    return static_cast<internal::type>((types_ >> shift) & mask);
+  }
+
+  friend class internal::arg_map<Context>;
+
+  void set_data(const internal::value<Context>* values) { values_ = values; }
+  void set_data(const format_arg* args) { args_ = args; }
+
+  format_arg do_get(int index) const {
+    format_arg arg;
+    if (!is_packed()) {
+      auto num_args = max_size();
+      if (index < num_args) arg = args_[index];
+      return arg;
+    }
+    if (index > internal::max_packed_args) return arg;
+    arg.type_ = type(index);
+    if (arg.type_ == internal::type::none_type) return arg;
+    internal::value<Context>& val = arg.value_;
+    val = values_[index];
+    return arg;
+  }
+
+ public:
+  basic_format_args() : types_(0) {}
+
+  /**
+   \rst
+   Constructs a `basic_format_args` object from `~fmt::format_arg_store`.
+   \endrst
+   */
+  template <typename... Args>
+  basic_format_args(const format_arg_store<Context, Args...>& store)
+      : types_(store.types) {
+    set_data(store.data_);
+  }
+
+  /**
+   \rst
+   Constructs a `basic_format_args` object from
+   `~fmt::dynamic_format_arg_store`.
+   \endrst
+   */
+  basic_format_args(const dynamic_format_arg_store<Context>& store)
+      : types_(store.get_types()) {
+    set_data(store.data_.data());
+  }
+
+  /**
+   \rst
+   Constructs a `basic_format_args` object from a dynamic set of arguments.
+   \endrst
+   */
+  basic_format_args(const format_arg* args, int count)
+      : types_(internal::is_unpacked_bit | internal::to_unsigned(count)) {
+    set_data(args);
+  }
+
+  /** Returns the argument at specified index. */
+  format_arg get(int index) const {
+    format_arg arg = do_get(index);
+    if (arg.type_ == internal::type::named_arg_type)
+      arg = arg.value_.named_arg->template deserialize<Context>();
+    return arg;
+  }
+
+  int max_size() const {
+    unsigned long long max_packed = internal::max_packed_args;
+    return static_cast<int>(is_packed() ? max_packed
+                                        : types_ & ~internal::is_unpacked_bit);
+  }
+};
+
+/** An alias to ``basic_format_args<context>``. */
+// It is a separate type rather than an alias to make symbols readable.
+struct format_args : basic_format_args<format_context> {
+  template <typename... Args>
+  format_args(Args&&... args)
+      : basic_format_args<format_context>(static_cast<Args&&>(args)...) {}
+};
+struct wformat_args : basic_format_args<wformat_context> {
+  template <typename... Args>
+  wformat_args(Args&&... args)
+      : basic_format_args<wformat_context>(static_cast<Args&&>(args)...) {}
+};
+
+template <typename Container> struct is_contiguous : std::false_type {};
+
+template <typename Char>
+struct is_contiguous<std::basic_string<Char>> : std::true_type {};
+
+template <typename Char>
+struct is_contiguous<internal::buffer<Char>> : std::true_type {};
+
+namespace internal {
+
+template <typename OutputIt>
+struct is_contiguous_back_insert_iterator : std::false_type {};
+template <typename Container>
+struct is_contiguous_back_insert_iterator<std::back_insert_iterator<Container>>
+    : is_contiguous<Container> {};
+
+template <typename Char> struct named_arg_base {
+  basic_string_view<Char> name;
+
+  // Serialized value<context>.
+  mutable char data[sizeof(basic_format_arg<buffer_context<Char>>)];
+
+  named_arg_base(basic_string_view<Char> nm) : name(nm) {}
+
+  template <typename Context> basic_format_arg<Context> deserialize() const {
+    basic_format_arg<Context> arg;
+    std::memcpy(&arg, data, sizeof(basic_format_arg<Context>));
+    return arg;
+  }
+};
+
+struct view {};
+
+template <typename T, typename Char>
+struct named_arg : view, named_arg_base<Char> {
+  const T& value;
+
+  named_arg(basic_string_view<Char> name, const T& val)
+      : named_arg_base<Char>(name), value(val) {}
+};
+
+template <typename..., typename S, FMT_ENABLE_IF(!is_compile_string<S>::value)>
+inline void check_format_string(const S&) {
+#if defined(FMT_ENFORCE_COMPILE_STRING)
+  static_assert(is_compile_string<S>::value,
+                "FMT_ENFORCE_COMPILE_STRING requires all format strings to "
+                "utilize FMT_STRING() or fmt().");
+#endif
+}
+template <typename..., typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
+void check_format_string(S);
+
+template <bool...> struct bool_pack;
+template <bool... Args>
+using all_true =
+    std::is_same<bool_pack<Args..., true>, bool_pack<true, Args...>>;
+
+template <typename... Args, typename S, typename Char = char_t<S>>
+inline format_arg_store<buffer_context<Char>, remove_reference_t<Args>...>
+make_args_checked(const S& format_str,
+                  const remove_reference_t<Args>&... args) {
+  static_assert(
+      all_true<(!std::is_base_of<view, remove_reference_t<Args>>::value ||
+                !std::is_reference<Args>::value)...>::value,
+      "passing views as lvalues is disallowed");
+  check_format_string<Args...>(format_str);
+  return {args...};
+}
+
+template <typename Char>
+std::basic_string<Char> vformat(
+    basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args);
+
+template <typename Char>
+typename buffer_context<Char>::iterator vformat_to(
+    buffer<Char>& buf, basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args);
+
+template <typename Char, typename Args,
+          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+inline void vprint_mojibake(std::FILE*, basic_string_view<Char>, const Args&) {}
+
+FMT_API void vprint_mojibake(std::FILE*, string_view, format_args);
+#ifndef _WIN32
+inline void vprint_mojibake(std::FILE*, string_view, format_args) {}
+#endif
+}  // namespace internal
+
+/**
+  \rst
+  Returns a named argument to be used in a formatting function. It should only
+  be used in a call to a formatting function.
+
+  **Example**::
+
+    fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
+  \endrst
+ */
+template <typename S, typename T, typename Char = char_t<S>>
+inline internal::named_arg<T, Char> arg(const S& name, const T& arg) {
+  static_assert(internal::is_string<S>::value, "");
+  return {name, arg};
+}
+
+// Disable nested named arguments, e.g. ``arg("a", arg("b", 42))``.
+template <typename S, typename T, typename Char>
+void arg(S, internal::named_arg<T, Char>) = delete;
+
+/** Formats a string and writes the output to ``out``. */
+// GCC 8 and earlier cannot handle std::back_insert_iterator<Container> with
+// vformat_to<ArgFormatter>(...) overload, so SFINAE on iterator type instead.
+template <typename OutputIt, typename S, typename Char = char_t<S>,
+          FMT_ENABLE_IF(
+              internal::is_contiguous_back_insert_iterator<OutputIt>::value)>
+OutputIt vformat_to(
+    OutputIt out, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  using container = remove_reference_t<decltype(internal::get_container(out))>;
+  internal::container_buffer<container> buf((internal::get_container(out)));
+  internal::vformat_to(buf, to_string_view(format_str), args);
+  return out;
+}
+
+template <typename Container, typename S, typename... Args,
+          FMT_ENABLE_IF(
+              is_contiguous<Container>::value&& internal::is_string<S>::value)>
+inline std::back_insert_iterator<Container> format_to(
+    std::back_insert_iterator<Container> out, const S& format_str,
+    Args&&... args) {
+  return vformat_to(out, to_string_view(format_str),
+                    internal::make_args_checked<Args...>(format_str, args...));
+}
+
+template <typename S, typename Char = char_t<S>>
+inline std::basic_string<Char> vformat(
+    const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  return internal::vformat(to_string_view(format_str), args);
+}
+
+/**
+  \rst
+  Formats arguments and returns the result as a string.
+
+  **Example**::
+
+    #include <fmt/core.h>
+    std::string message = fmt::format("The answer is {}", 42);
+  \endrst
+*/
+// Pass char_t as a default template parameter instead of using
+// std::basic_string<char_t<S>> to reduce the symbol size.
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline std::basic_string<Char> format(const S& format_str, Args&&... args) {
+  return internal::vformat(
+      to_string_view(format_str),
+      internal::make_args_checked<Args...>(format_str, args...));
+}
+
+FMT_API void vprint(string_view, format_args);
+FMT_API void vprint(std::FILE*, string_view, format_args);
+
+/**
+  \rst
+  Formats ``args`` according to specifications in ``format_str`` and writes the
+  output to the file ``f``. Strings are assumed to be Unicode-encoded unless the
+  ``FMT_UNICODE`` macro is set to 0.
+
+  **Example**::
+
+    fmt::print(stderr, "Don't {}!", "panic");
+  \endrst
+ */
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline void print(std::FILE* f, const S& format_str, Args&&... args) {
+  return internal::is_unicode<Char>()
+             ? vprint(f, to_string_view(format_str),
+                      internal::make_args_checked<Args...>(format_str, args...))
+             : internal::vprint_mojibake(
+                   f, to_string_view(format_str),
+                   internal::make_args_checked<Args...>(format_str, args...));
+}
+
+/**
+  \rst
+  Formats ``args`` according to specifications in ``format_str`` and writes
+  the output to ``stdout``. Strings are assumed to be Unicode-encoded unless
+  the ``FMT_UNICODE`` macro is set to 0.
+
+  **Example**::
+
+    fmt::print("Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
+ */
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline void print(const S& format_str, Args&&... args) {
+  return internal::is_unicode<Char>()
+             ? vprint(to_string_view(format_str),
+                      internal::make_args_checked<Args...>(format_str, args...))
+             : internal::vprint_mojibake(
+                   stdout, to_string_view(format_str),
+                   internal::make_args_checked<Args...>(format_str, args...));
+}
+FMT_END_NAMESPACE
+
+#endif  // FMT_CORE_H_
diff --git a/lib/fmt/fmt/format-inl.h b/lib/fmt/fmt/format-inl.h
new file mode 100644
index 0000000..f632714
--- /dev/null
+++ b/lib/fmt/fmt/format-inl.h
@@ -0,0 +1,1403 @@
+// Formatting library for C++ - implementation
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_FORMAT_INL_H_
+#define FMT_FORMAT_INL_H_
+
+#include <cassert>
+#include <cctype>
+#include <climits>
+#include <cmath>
+#include <cstdarg>
+#include <cstring>  // for std::memmove
+#include <cwchar>
+
+#include "format.h"
+#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
+#  include <locale>
+#endif
+
+#ifdef _WIN32
+#  include <io.h>
+#  include <windows.h>
+#endif
+
+#ifdef _MSC_VER
+#  pragma warning(push)
+#  pragma warning(disable : 4702)  // unreachable code
+#endif
+
+// Dummy implementations of strerror_r and strerror_s called if corresponding
+// system functions are not available.
+inline fmt::internal::null<> strerror_r(int, char*, ...) { return {}; }
+inline fmt::internal::null<> strerror_s(char*, std::size_t, ...) { return {}; }
+
+FMT_BEGIN_NAMESPACE
+namespace internal {
+
+FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
+  print(stderr, "{}:{}: assertion failed: {}", file, line, message);
+  std::abort();
+}
+
+#ifndef _MSC_VER
+#  define FMT_SNPRINTF snprintf
+#else  // _MSC_VER
+inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
+  va_end(args);
+  return result;
+}
+#  define FMT_SNPRINTF fmt_snprintf
+#endif  // _MSC_VER
+
+// A portable thread-safe version of strerror.
+// Sets buffer to point to a string describing the error code.
+// This can be either a pointer to a string stored in buffer,
+// or a pointer to some static immutable string.
+// Returns one of the following values:
+//   0      - success
+//   ERANGE - buffer is not large enough to store the error message
+//   other  - failure
+// Buffer should be at least of size 1.
+FMT_FUNC int safe_strerror(int error_code, char*& buffer,
+                           std::size_t buffer_size) FMT_NOEXCEPT {
+  FMT_ASSERT(buffer != nullptr && buffer_size != 0, "invalid buffer");
+
+  class dispatcher {
+   private:
+    int error_code_;
+    char*& buffer_;
+    std::size_t buffer_size_;
+
+    // A noop assignment operator to avoid bogus warnings.
+    void operator=(const dispatcher&) {}
+
+    // Handle the result of XSI-compliant version of strerror_r.
+    int handle(int result) {
+      // glibc versions before 2.13 return result in errno.
+      return result == -1 ? errno : result;
+    }
+
+    // Handle the result of GNU-specific version of strerror_r.
+    FMT_MAYBE_UNUSED
+    int handle(char* message) {
+      // If the buffer is full then the message is probably truncated.
+      if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
+        return ERANGE;
+      buffer_ = message;
+      return 0;
+    }
+
+    // Handle the case when strerror_r is not available.
+    FMT_MAYBE_UNUSED
+    int handle(internal::null<>) {
+      return fallback(strerror_s(buffer_, buffer_size_, error_code_));
+    }
+
+    // Fallback to strerror_s when strerror_r is not available.
+    FMT_MAYBE_UNUSED
+    int fallback(int result) {
+      // If the buffer is full then the message is probably truncated.
+      return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE
+                                                                : result;
+    }
+
+#if !FMT_MSC_VER
+    // Fallback to strerror if strerror_r and strerror_s are not available.
+    int fallback(internal::null<>) {
+      errno = 0;
+      buffer_ = strerror(error_code_);
+      return errno;
+    }
+#endif
+
+   public:
+    dispatcher(int err_code, char*& buf, std::size_t buf_size)
+        : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
+
+    int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); }
+  };
+  return dispatcher(error_code, buffer, buffer_size).run();
+}
+
+FMT_FUNC void format_error_code(internal::buffer<char>& out, int error_code,
+                                string_view message) FMT_NOEXCEPT {
+  // Report error code making sure that the output fits into
+  // inline_buffer_size to avoid dynamic memory allocation and potential
+  // bad_alloc.
+  out.resize(0);
+  static const char SEP[] = ": ";
+  static const char ERROR_STR[] = "error ";
+  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
+  std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
+  auto abs_value = static_cast<uint32_or_64_or_128_t<int>>(error_code);
+  if (internal::is_negative(error_code)) {
+    abs_value = 0 - abs_value;
+    ++error_code_size;
+  }
+  error_code_size += internal::to_unsigned(internal::count_digits(abs_value));
+  internal::writer w(out);
+  if (message.size() <= inline_buffer_size - error_code_size) {
+    w.write(message);
+    w.write(SEP);
+  }
+  w.write(ERROR_STR);
+  w.write(error_code);
+  assert(out.size() <= inline_buffer_size);
+}
+
+FMT_FUNC void report_error(format_func func, int error_code,
+                           string_view message) FMT_NOEXCEPT {
+  memory_buffer full_message;
+  func(full_message, error_code, message);
+  // Don't use fwrite_fully because the latter may throw.
+  (void)std::fwrite(full_message.data(), full_message.size(), 1, stderr);
+  std::fputc('\n', stderr);
+}
+
+// A wrapper around fwrite that throws on error.
+FMT_FUNC void fwrite_fully(const void* ptr, size_t size, size_t count,
+                           FILE* stream) {
+  size_t written = std::fwrite(ptr, size, count, stream);
+  if (written < count) FMT_THROW(system_error(errno, "cannot write to file"));
+}
+}  // namespace internal
+
+#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
+namespace internal {
+
+template <typename Locale>
+locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
+  static_assert(std::is_same<Locale, std::locale>::value, "");
+}
+
+template <typename Locale> Locale locale_ref::get() const {
+  static_assert(std::is_same<Locale, std::locale>::value, "");
+  return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
+}
+
+template <typename Char> FMT_FUNC std::string grouping_impl(locale_ref loc) {
+  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>()).grouping();
+}
+template <typename Char> FMT_FUNC Char thousands_sep_impl(locale_ref loc) {
+  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
+      .thousands_sep();
+}
+template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
+  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
+      .decimal_point();
+}
+}  // namespace internal
+#else
+template <typename Char>
+FMT_FUNC std::string internal::grouping_impl(locale_ref) {
+  return "\03";
+}
+template <typename Char>
+FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
+  return FMT_STATIC_THOUSANDS_SEPARATOR;
+}
+template <typename Char>
+FMT_FUNC Char internal::decimal_point_impl(locale_ref) {
+  return '.';
+}
+#endif
+
+FMT_API FMT_FUNC format_error::~format_error() FMT_NOEXCEPT = default;
+FMT_API FMT_FUNC system_error::~system_error() FMT_NOEXCEPT = default;
+
+FMT_FUNC void system_error::init(int err_code, string_view format_str,
+                                 format_args args) {
+  error_code_ = err_code;
+  memory_buffer buffer;
+  format_system_error(buffer, err_code, vformat(format_str, args));
+  std::runtime_error& base = *this;
+  base = std::runtime_error(to_string(buffer));
+}
+
+namespace internal {
+
+template <> FMT_FUNC int count_digits<4>(internal::fallback_uintptr n) {
+  // fallback_uintptr is always stored in little endian.
+  int i = static_cast<int>(sizeof(void*)) - 1;
+  while (i > 0 && n.value[i] == 0) --i;
+  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
+  return i >= 0 ? i * char_digits + count_digits<4, unsigned>(n.value[i]) : 1;
+}
+
+template <typename T>
+const char basic_data<T>::digits[] =
+    "0001020304050607080910111213141516171819"
+    "2021222324252627282930313233343536373839"
+    "4041424344454647484950515253545556575859"
+    "6061626364656667686970717273747576777879"
+    "8081828384858687888990919293949596979899";
+
+template <typename T>
+const char basic_data<T>::hex_digits[] = "0123456789abcdef";
+
+#define FMT_POWERS_OF_10(factor)                                             \
+  factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \
+      (factor)*1000000, (factor)*10000000, (factor)*100000000,               \
+      (factor)*1000000000
+
+template <typename T>
+const uint64_t basic_data<T>::powers_of_10_64[] = {
+    1, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),
+    10000000000000000000ULL};
+
+template <typename T>
+const uint32_t basic_data<T>::zero_or_powers_of_10_32[] = {0,
+                                                           FMT_POWERS_OF_10(1)};
+
+template <typename T>
+const uint64_t basic_data<T>::zero_or_powers_of_10_64[] = {
+    0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),
+    10000000000000000000ULL};
+
+// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
+// These are generated by support/compute-powers.py.
+template <typename T>
+const uint64_t basic_data<T>::pow10_significands[] = {
+    0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
+    0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
+    0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
+    0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
+    0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
+    0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
+    0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
+    0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
+    0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
+    0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
+    0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
+    0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
+    0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
+    0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
+    0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
+    0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
+    0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
+    0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
+    0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
+    0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
+    0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
+    0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
+    0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
+    0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
+    0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
+    0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
+    0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
+    0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
+    0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
+};
+
+// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
+// to significands above.
+template <typename T>
+const int16_t basic_data<T>::pow10_exponents[] = {
+    -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,
+    -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688, -661,
+    -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396, -369,
+    -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103, -77,
+    -50,   -24,   3,     30,    56,    83,    109,   136,   162,   189,  216,
+    242,   269,   295,   322,   348,   375,   402,   428,   455,   481,  508,
+    534,   561,   588,   614,   641,   667,   694,   720,   747,   774,  800,
+    827,   853,   880,   907,   933,   960,   986,   1013,  1039,  1066};
+
+template <typename T>
+const char basic_data<T>::foreground_color[] = "\x1b[38;2;";
+template <typename T>
+const char basic_data<T>::background_color[] = "\x1b[48;2;";
+template <typename T> const char basic_data<T>::reset_color[] = "\x1b[0m";
+template <typename T> const wchar_t basic_data<T>::wreset_color[] = L"\x1b[0m";
+template <typename T> const char basic_data<T>::signs[] = {0, '-', '+', ' '};
+
+template <typename T> struct bits {
+  static FMT_CONSTEXPR_DECL const int value =
+      static_cast<int>(sizeof(T) * std::numeric_limits<unsigned char>::digits);
+};
+
+class fp;
+template <int SHIFT = 0> fp normalize(fp value);
+
+// Lower (upper) boundary is a value half way between a floating-point value
+// and its predecessor (successor). Boundaries have the same exponent as the
+// value so only significands are stored.
+struct boundaries {
+  uint64_t lower;
+  uint64_t upper;
+};
+
+// A handmade floating-point number f * pow(2, e).
+class fp {
+ private:
+  using significand_type = uint64_t;
+
+ public:
+  significand_type f;
+  int e;
+
+  // All sizes are in bits.
+  // Subtract 1 to account for an implicit most significant bit in the
+  // normalized form.
+  static FMT_CONSTEXPR_DECL const int double_significand_size =
+      std::numeric_limits<double>::digits - 1;
+  static FMT_CONSTEXPR_DECL const uint64_t implicit_bit =
+      1ULL << double_significand_size;
+  static FMT_CONSTEXPR_DECL const int significand_size =
+      bits<significand_type>::value;
+
+  fp() : f(0), e(0) {}
+  fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}
+
+  // Constructs fp from an IEEE754 double. It is a template to prevent compile
+  // errors on platforms where double is not IEEE754.
+  template <typename Double> explicit fp(Double d) { assign(d); }
+
+  // Assigns d to this and return true iff predecessor is closer than successor.
+  template <typename Double, FMT_ENABLE_IF(sizeof(Double) == sizeof(uint64_t))>
+  bool assign(Double d) {
+    // Assume double is in the format [sign][exponent][significand].
+    using limits = std::numeric_limits<Double>;
+    const int exponent_size =
+        bits<Double>::value - double_significand_size - 1;  // -1 for sign
+    const uint64_t significand_mask = implicit_bit - 1;
+    const uint64_t exponent_mask = (~0ULL >> 1) & ~significand_mask;
+    const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
+    auto u = bit_cast<uint64_t>(d);
+    f = u & significand_mask;
+    int biased_e =
+        static_cast<int>((u & exponent_mask) >> double_significand_size);
+    // Predecessor is closer if d is a normalized power of 2 (f == 0) other than
+    // the smallest normalized number (biased_e > 1).
+    bool is_predecessor_closer = f == 0 && biased_e > 1;
+    if (biased_e != 0)
+      f += implicit_bit;
+    else
+      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
+    e = biased_e - exponent_bias - double_significand_size;
+    return is_predecessor_closer;
+  }
+
+  template <typename Double, FMT_ENABLE_IF(sizeof(Double) != sizeof(uint64_t))>
+  bool assign(Double) {
+    *this = fp();
+    return false;
+  }
+
+  // Assigns d to this together with computing lower and upper boundaries,
+  // where a boundary is a value half way between the number and its predecessor
+  // (lower) or successor (upper). The upper boundary is normalized and lower
+  // has the same exponent but may be not normalized.
+  template <typename Double> boundaries assign_with_boundaries(Double d) {
+    bool is_lower_closer = assign(d);
+    fp lower =
+        is_lower_closer ? fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1);
+    // 1 in normalize accounts for the exponent shift above.
+    fp upper = normalize<1>(fp((f << 1) + 1, e - 1));
+    lower.f <<= lower.e - upper.e;
+    return boundaries{lower.f, upper.f};
+  }
+
+  template <typename Double> boundaries assign_float_with_boundaries(Double d) {
+    assign(d);
+    constexpr int min_normal_e = std::numeric_limits<float>::min_exponent -
+                                 std::numeric_limits<double>::digits;
+    significand_type half_ulp = 1 << (std::numeric_limits<double>::digits -
+                                      std::numeric_limits<float>::digits - 1);
+    if (min_normal_e > e) half_ulp <<= min_normal_e - e;
+    fp upper = normalize<0>(fp(f + half_ulp, e));
+    fp lower = fp(
+        f - (half_ulp >> ((f == implicit_bit && e > min_normal_e) ? 1 : 0)), e);
+    lower.f <<= lower.e - upper.e;
+    return boundaries{lower.f, upper.f};
+  }
+};
+
+// Normalizes the value converted from double and multiplied by (1 << SHIFT).
+template <int SHIFT> fp normalize(fp value) {
+  // Handle subnormals.
+  const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;
+  while ((value.f & shifted_implicit_bit) == 0) {
+    value.f <<= 1;
+    --value.e;
+  }
+  // Subtract 1 to account for hidden bit.
+  const auto offset =
+      fp::significand_size - fp::double_significand_size - SHIFT - 1;
+  value.f <<= offset;
+  value.e -= offset;
+  return value;
+}
+
+inline bool operator==(fp x, fp y) { return x.f == y.f && x.e == y.e; }
+
+// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
+inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
+#if FMT_USE_INT128
+  auto product = static_cast<__uint128_t>(lhs) * rhs;
+  auto f = static_cast<uint64_t>(product >> 64);
+  return (static_cast<uint64_t>(product) & (1ULL << 63)) != 0 ? f + 1 : f;
+#else
+  // Multiply 32-bit parts of significands.
+  uint64_t mask = (1ULL << 32) - 1;
+  uint64_t a = lhs >> 32, b = lhs & mask;
+  uint64_t c = rhs >> 32, d = rhs & mask;
+  uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
+  // Compute mid 64-bit of result and round.
+  uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
+  return ac + (ad >> 32) + (bc >> 32) + (mid >> 32);
+#endif
+}
+
+inline fp operator*(fp x, fp y) { return {multiply(x.f, y.f), x.e + y.e + 64}; }
+
+// Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its
+// (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`.
+inline fp get_cached_power(int min_exponent, int& pow10_exponent) {
+  const int64_t one_over_log2_10 = 0x4d104d42;  // round(pow(2, 32) / log2(10))
+  int index = static_cast<int>(
+      ((min_exponent + fp::significand_size - 1) * one_over_log2_10 +
+       ((int64_t(1) << 32) - 1))  // ceil
+      >> 32                       // arithmetic shift
+  );
+  // Decimal exponent of the first (smallest) cached power of 10.
+  const int first_dec_exp = -348;
+  // Difference between 2 consecutive decimal exponents in cached powers of 10.
+  const int dec_exp_step = 8;
+  index = (index - first_dec_exp - 1) / dec_exp_step + 1;
+  pow10_exponent = first_dec_exp + index * dec_exp_step;
+  return {data::pow10_significands[index], data::pow10_exponents[index]};
+}
+
+// A simple accumulator to hold the sums of terms in bigint::square if uint128_t
+// is not available.
+struct accumulator {
+  uint64_t lower;
+  uint64_t upper;
+
+  accumulator() : lower(0), upper(0) {}
+  explicit operator uint32_t() const { return static_cast<uint32_t>(lower); }
+
+  void operator+=(uint64_t n) {
+    lower += n;
+    if (lower < n) ++upper;
+  }
+  void operator>>=(int shift) {
+    assert(shift == 32);
+    (void)shift;
+    lower = (upper << 32) | (lower >> 32);
+    upper >>= 32;
+  }
+};
+
+class bigint {
+ private:
+  // A bigint is stored as an array of bigits (big digits), with bigit at index
+  // 0 being the least significant one.
+  using bigit = uint32_t;
+  using double_bigit = uint64_t;
+  enum { bigits_capacity = 32 };
+  basic_memory_buffer<bigit, bigits_capacity> bigits_;
+  int exp_;
+
+  bigit operator[](int index) const { return bigits_[to_unsigned(index)]; }
+  bigit& operator[](int index) { return bigits_[to_unsigned(index)]; }
+
+  static FMT_CONSTEXPR_DECL const int bigit_bits = bits<bigit>::value;
+
+  friend struct formatter<bigint>;
+
+  void subtract_bigits(int index, bigit other, bigit& borrow) {
+    auto result = static_cast<double_bigit>((*this)[index]) - other - borrow;
+    (*this)[index] = static_cast<bigit>(result);
+    borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
+  }
+
+  void remove_leading_zeros() {
+    int num_bigits = static_cast<int>(bigits_.size()) - 1;
+    while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits;
+    bigits_.resize(to_unsigned(num_bigits + 1));
+  }
+
+  // Computes *this -= other assuming aligned bigints and *this >= other.
+  void subtract_aligned(const bigint& other) {
+    FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
+    FMT_ASSERT(compare(*this, other) >= 0, "");
+    bigit borrow = 0;
+    int i = other.exp_ - exp_;
+    for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j) {
+      subtract_bigits(i, other.bigits_[j], borrow);
+    }
+    while (borrow > 0) subtract_bigits(i, 0, borrow);
+    remove_leading_zeros();
+  }
+
+  void multiply(uint32_t value) {
+    const double_bigit wide_value = value;
+    bigit carry = 0;
+    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
+      double_bigit result = bigits_[i] * wide_value + carry;
+      bigits_[i] = static_cast<bigit>(result);
+      carry = static_cast<bigit>(result >> bigit_bits);
+    }
+    if (carry != 0) bigits_.push_back(carry);
+  }
+
+  void multiply(uint64_t value) {
+    const bigit mask = ~bigit(0);
+    const double_bigit lower = value & mask;
+    const double_bigit upper = value >> bigit_bits;
+    double_bigit carry = 0;
+    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
+      double_bigit result = bigits_[i] * lower + (carry & mask);
+      carry =
+          bigits_[i] * upper + (result >> bigit_bits) + (carry >> bigit_bits);
+      bigits_[i] = static_cast<bigit>(result);
+    }
+    while (carry != 0) {
+      bigits_.push_back(carry & mask);
+      carry >>= bigit_bits;
+    }
+  }
+
+ public:
+  bigint() : exp_(0) {}
+  explicit bigint(uint64_t n) { assign(n); }
+  ~bigint() { assert(bigits_.capacity() <= bigits_capacity); }
+
+  bigint(const bigint&) = delete;
+  void operator=(const bigint&) = delete;
+
+  void assign(const bigint& other) {
+    bigits_.resize(other.bigits_.size());
+    auto data = other.bigits_.data();
+    std::copy(data, data + other.bigits_.size(), bigits_.data());
+    exp_ = other.exp_;
+  }
+
+  void assign(uint64_t n) {
+    size_t num_bigits = 0;
+    do {
+      bigits_[num_bigits++] = n & ~bigit(0);
+      n >>= bigit_bits;
+    } while (n != 0);
+    bigits_.resize(num_bigits);
+    exp_ = 0;
+  }
+
+  int num_bigits() const { return static_cast<int>(bigits_.size()) + exp_; }
+
+  bigint& operator<<=(int shift) {
+    assert(shift >= 0);
+    exp_ += shift / bigit_bits;
+    shift %= bigit_bits;
+    if (shift == 0) return *this;
+    bigit carry = 0;
+    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
+      bigit c = bigits_[i] >> (bigit_bits - shift);
+      bigits_[i] = (bigits_[i] << shift) + carry;
+      carry = c;
+    }
+    if (carry != 0) bigits_.push_back(carry);
+    return *this;
+  }
+
+  template <typename Int> bigint& operator*=(Int value) {
+    FMT_ASSERT(value > 0, "");
+    multiply(uint32_or_64_or_128_t<Int>(value));
+    return *this;
+  }
+
+  friend int compare(const bigint& lhs, const bigint& rhs) {
+    int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
+    if (num_lhs_bigits != num_rhs_bigits)
+      return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
+    int i = static_cast<int>(lhs.bigits_.size()) - 1;
+    int j = static_cast<int>(rhs.bigits_.size()) - 1;
+    int end = i - j;
+    if (end < 0) end = 0;
+    for (; i >= end; --i, --j) {
+      bigit lhs_bigit = lhs[i], rhs_bigit = rhs[j];
+      if (lhs_bigit != rhs_bigit) return lhs_bigit > rhs_bigit ? 1 : -1;
+    }
+    if (i != j) return i > j ? 1 : -1;
+    return 0;
+  }
+
+  // Returns compare(lhs1 + lhs2, rhs).
+  friend int add_compare(const bigint& lhs1, const bigint& lhs2,
+                         const bigint& rhs) {
+    int max_lhs_bigits = (std::max)(lhs1.num_bigits(), lhs2.num_bigits());
+    int num_rhs_bigits = rhs.num_bigits();
+    if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;
+    if (max_lhs_bigits > num_rhs_bigits) return 1;
+    auto get_bigit = [](const bigint& n, int i) -> bigit {
+      return i >= n.exp_ && i < n.num_bigits() ? n[i - n.exp_] : 0;
+    };
+    double_bigit borrow = 0;
+    int min_exp = (std::min)((std::min)(lhs1.exp_, lhs2.exp_), rhs.exp_);
+    for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
+      double_bigit sum =
+          static_cast<double_bigit>(get_bigit(lhs1, i)) + get_bigit(lhs2, i);
+      bigit rhs_bigit = get_bigit(rhs, i);
+      if (sum > rhs_bigit + borrow) return 1;
+      borrow = rhs_bigit + borrow - sum;
+      if (borrow > 1) return -1;
+      borrow <<= bigit_bits;
+    }
+    return borrow != 0 ? -1 : 0;
+  }
+
+  // Assigns pow(10, exp) to this bigint.
+  void assign_pow10(int exp) {
+    assert(exp >= 0);
+    if (exp == 0) return assign(1);
+    // Find the top bit.
+    int bitmask = 1;
+    while (exp >= bitmask) bitmask <<= 1;
+    bitmask >>= 1;
+    // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
+    // repeated squaring and multiplication.
+    assign(5);
+    bitmask >>= 1;
+    while (bitmask != 0) {
+      square();
+      if ((exp & bitmask) != 0) *this *= 5;
+      bitmask >>= 1;
+    }
+    *this <<= exp;  // Multiply by pow(2, exp) by shifting.
+  }
+
+  void square() {
+    basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
+    int num_bigits = static_cast<int>(bigits_.size());
+    int num_result_bigits = 2 * num_bigits;
+    bigits_.resize(to_unsigned(num_result_bigits));
+    using accumulator_t = conditional_t<FMT_USE_INT128, uint128_t, accumulator>;
+    auto sum = accumulator_t();
+    for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
+      // Compute bigit at position bigit_index of the result by adding
+      // cross-product terms n[i] * n[j] such that i + j == bigit_index.
+      for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
+        // Most terms are multiplied twice which can be optimized in the future.
+        sum += static_cast<double_bigit>(n[i]) * n[j];
+      }
+      (*this)[bigit_index] = static_cast<bigit>(sum);
+      sum >>= bits<bigit>::value;  // Compute the carry.
+    }
+    // Do the same for the top half.
+    for (int bigit_index = num_bigits; bigit_index < num_result_bigits;
+         ++bigit_index) {
+      for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
+        sum += static_cast<double_bigit>(n[i++]) * n[j--];
+      (*this)[bigit_index] = static_cast<bigit>(sum);
+      sum >>= bits<bigit>::value;
+    }
+    --num_result_bigits;
+    remove_leading_zeros();
+    exp_ *= 2;
+  }
+
+  // Divides this bignum by divisor, assigning the remainder to this and
+  // returning the quotient.
+  int divmod_assign(const bigint& divisor) {
+    FMT_ASSERT(this != &divisor, "");
+    if (compare(*this, divisor) < 0) return 0;
+    int num_bigits = static_cast<int>(bigits_.size());
+    FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
+    int exp_difference = exp_ - divisor.exp_;
+    if (exp_difference > 0) {
+      // Align bigints by adding trailing zeros to simplify subtraction.
+      bigits_.resize(to_unsigned(num_bigits + exp_difference));
+      for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
+        bigits_[j] = bigits_[i];
+      std::uninitialized_fill_n(bigits_.data(), exp_difference, 0);
+      exp_ -= exp_difference;
+    }
+    int quotient = 0;
+    do {
+      subtract_aligned(divisor);
+      ++quotient;
+    } while (compare(*this, divisor) >= 0);
+    return quotient;
+  }
+};
+
+enum class round_direction { unknown, up, down };
+
+// Given the divisor (normally a power of 10), the remainder = v % divisor for
+// some number v and the error, returns whether v should be rounded up, down, or
+// whether the rounding direction can't be determined due to error.
+// error should be less than divisor / 2.
+inline round_direction get_round_direction(uint64_t divisor, uint64_t remainder,
+                                           uint64_t error) {
+  FMT_ASSERT(remainder < divisor, "");  // divisor - remainder won't overflow.
+  FMT_ASSERT(error < divisor, "");      // divisor - error won't overflow.
+  FMT_ASSERT(error < divisor - error, "");  // error * 2 won't overflow.
+  // Round down if (remainder + error) * 2 <= divisor.
+  if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
+    return round_direction::down;
+  // Round up if (remainder - error) * 2 >= divisor.
+  if (remainder >= error &&
+      remainder - error >= divisor - (remainder - error)) {
+    return round_direction::up;
+  }
+  return round_direction::unknown;
+}
+
+namespace digits {
+enum result {
+  more,  // Generate more digits.
+  done,  // Done generating digits.
+  error  // Digit generation cancelled due to an error.
+};
+}
+
+// A version of count_digits optimized for grisu_gen_digits.
+inline int grisu_count_digits(uint32_t n) {
+  if (n < 10) return 1;
+  if (n < 100) return 2;
+  if (n < 1000) return 3;
+  if (n < 10000) return 4;
+  if (n < 100000) return 5;
+  if (n < 1000000) return 6;
+  if (n < 10000000) return 7;
+  if (n < 100000000) return 8;
+  if (n < 1000000000) return 9;
+  return 10;
+}
+
+// Generates output using the Grisu digit-gen algorithm.
+// error: the size of the region (lower, upper) outside of which numbers
+// definitely do not round to value (Delta in Grisu3).
+template <typename Handler>
+FMT_ALWAYS_INLINE digits::result grisu_gen_digits(fp value, uint64_t error,
+                                                  int& exp, Handler& handler) {
+  const fp one(1ULL << -value.e, value.e);
+  // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be
+  // zero because it contains a product of two 64-bit numbers with MSB set (due
+  // to normalization) - 1, shifted right by at most 60 bits.
+  auto integral = static_cast<uint32_t>(value.f >> -one.e);
+  FMT_ASSERT(integral != 0, "");
+  FMT_ASSERT(integral == value.f >> -one.e, "");
+  // The fractional part of scaled value (p2 in Grisu) c = value % one.
+  uint64_t fractional = value.f & (one.f - 1);
+  exp = grisu_count_digits(integral);  // kappa in Grisu.
+  // Divide by 10 to prevent overflow.
+  auto result = handler.on_start(data::powers_of_10_64[exp - 1] << -one.e,
+                                 value.f / 10, error * 10, exp);
+  if (result != digits::more) return result;
+  // Generate digits for the integral part. This can produce up to 10 digits.
+  do {
+    uint32_t digit = 0;
+    auto divmod_integral = [&](uint32_t divisor) {
+      digit = integral / divisor;
+      integral %= divisor;
+    };
+    // This optimization by Milo Yip reduces the number of integer divisions by
+    // one per iteration.
+    switch (exp) {
+    case 10:
+      divmod_integral(1000000000);
+      break;
+    case 9:
+      divmod_integral(100000000);
+      break;
+    case 8:
+      divmod_integral(10000000);
+      break;
+    case 7:
+      divmod_integral(1000000);
+      break;
+    case 6:
+      divmod_integral(100000);
+      break;
+    case 5:
+      divmod_integral(10000);
+      break;
+    case 4:
+      divmod_integral(1000);
+      break;
+    case 3:
+      divmod_integral(100);
+      break;
+    case 2:
+      divmod_integral(10);
+      break;
+    case 1:
+      digit = integral;
+      integral = 0;
+      break;
+    default:
+      FMT_ASSERT(false, "invalid number of digits");
+    }
+    --exp;
+    uint64_t remainder =
+        (static_cast<uint64_t>(integral) << -one.e) + fractional;
+    result = handler.on_digit(static_cast<char>('0' + digit),
+                              data::powers_of_10_64[exp] << -one.e, remainder,
+                              error, exp, true);
+    if (result != digits::more) return result;
+  } while (exp > 0);
+  // Generate digits for the fractional part.
+  for (;;) {
+    fractional *= 10;
+    error *= 10;
+    char digit =
+        static_cast<char>('0' + static_cast<char>(fractional >> -one.e));
+    fractional &= one.f - 1;
+    --exp;
+    result = handler.on_digit(digit, one.f, fractional, error, exp, false);
+    if (result != digits::more) return result;
+  }
+}
+
+// The fixed precision digit handler.
+struct fixed_handler {
+  char* buf;
+  int size;
+  int precision;
+  int exp10;
+  bool fixed;
+
+  digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error,
+                          int& exp) {
+    // Non-fixed formats require at least one digit and no precision adjustment.
+    if (!fixed) return digits::more;
+    // Adjust fixed precision by exponent because it is relative to decimal
+    // point.
+    precision += exp + exp10;
+    // Check if precision is satisfied just by leading zeros, e.g.
+    // format("{:.2f}", 0.001) gives "0.00" without generating any digits.
+    if (precision > 0) return digits::more;
+    if (precision < 0) return digits::done;
+    auto dir = get_round_direction(divisor, remainder, error);
+    if (dir == round_direction::unknown) return digits::error;
+    buf[size++] = dir == round_direction::up ? '1' : '0';
+    return digits::done;
+  }
+
+  digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
+                          uint64_t error, int, bool integral) {
+    FMT_ASSERT(remainder < divisor, "");
+    buf[size++] = digit;
+    if (size < precision) return digits::more;
+    if (!integral) {
+      // Check if error * 2 < divisor with overflow prevention.
+      // The check is not needed for the integral part because error = 1
+      // and divisor > (1 << 32) there.
+      if (error >= divisor || error >= divisor - error) return digits::error;
+    } else {
+      FMT_ASSERT(error == 1 && divisor > 2, "");
+    }
+    auto dir = get_round_direction(divisor, remainder, error);
+    if (dir != round_direction::up)
+      return dir == round_direction::down ? digits::done : digits::error;
+    ++buf[size - 1];
+    for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
+      buf[i] = '0';
+      ++buf[i - 1];
+    }
+    if (buf[0] > '9') {
+      buf[0] = '1';
+      buf[size++] = '0';
+    }
+    return digits::done;
+  }
+};
+
+// The shortest representation digit handler.
+struct grisu_shortest_handler {
+  char* buf;
+  int size;
+  // Distance between scaled value and upper bound (wp_W in Grisu3).
+  uint64_t diff;
+
+  digits::result on_start(uint64_t, uint64_t, uint64_t, int&) {
+    return digits::more;
+  }
+
+  // Decrement the generated number approaching value from above.
+  void round(uint64_t d, uint64_t divisor, uint64_t& remainder,
+             uint64_t error) {
+    while (
+        remainder < d && error - remainder >= divisor &&
+        (remainder + divisor < d || d - remainder >= remainder + divisor - d)) {
+      --buf[size - 1];
+      remainder += divisor;
+    }
+  }
+
+  // Implements Grisu's round_weed.
+  digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
+                          uint64_t error, int exp, bool integral) {
+    buf[size++] = digit;
+    if (remainder >= error) return digits::more;
+    uint64_t unit = integral ? 1 : data::powers_of_10_64[-exp];
+    uint64_t up = (diff - 1) * unit;  // wp_Wup
+    round(up, divisor, remainder, error);
+    uint64_t down = (diff + 1) * unit;  // wp_Wdown
+    if (remainder < down && error - remainder >= divisor &&
+        (remainder + divisor < down ||
+         down - remainder > remainder + divisor - down)) {
+      return digits::error;
+    }
+    return 2 * unit <= remainder && remainder <= error - 4 * unit
+               ? digits::done
+               : digits::error;
+  }
+};
+
+// Formats value using a variation of the Fixed-Precision Positive
+// Floating-Point Printout ((FPP)^2) algorithm by Steele & White:
+// https://fmt.dev/p372-steele.pdf.
+template <typename Double>
+void fallback_format(Double d, buffer<char>& buf, int& exp10) {
+  bigint numerator;    // 2 * R in (FPP)^2.
+  bigint denominator;  // 2 * S in (FPP)^2.
+  // lower and upper are differences between value and corresponding boundaries.
+  bigint lower;             // (M^- in (FPP)^2).
+  bigint upper_store;       // upper's value if different from lower.
+  bigint* upper = nullptr;  // (M^+ in (FPP)^2).
+  fp value;
+  // Shift numerator and denominator by an extra bit or two (if lower boundary
+  // is closer) to make lower and upper integers. This eliminates multiplication
+  // by 2 during later computations.
+  // TODO: handle float
+  int shift = value.assign(d) ? 2 : 1;
+  uint64_t significand = value.f << shift;
+  if (value.e >= 0) {
+    numerator.assign(significand);
+    numerator <<= value.e;
+    lower.assign(1);
+    lower <<= value.e;
+    if (shift != 1) {
+      upper_store.assign(1);
+      upper_store <<= value.e + 1;
+      upper = &upper_store;
+    }
+    denominator.assign_pow10(exp10);
+    denominator <<= 1;
+  } else if (exp10 < 0) {
+    numerator.assign_pow10(-exp10);
+    lower.assign(numerator);
+    if (shift != 1) {
+      upper_store.assign(numerator);
+      upper_store <<= 1;
+      upper = &upper_store;
+    }
+    numerator *= significand;
+    denominator.assign(1);
+    denominator <<= shift - value.e;
+  } else {
+    numerator.assign(significand);
+    denominator.assign_pow10(exp10);
+    denominator <<= shift - value.e;
+    lower.assign(1);
+    if (shift != 1) {
+      upper_store.assign(1ULL << 1);
+      upper = &upper_store;
+    }
+  }
+  if (!upper) upper = &lower;
+  // Invariant: value == (numerator / denominator) * pow(10, exp10).
+  bool even = (value.f & 1) == 0;
+  int num_digits = 0;
+  char* data = buf.data();
+  for (;;) {
+    int digit = numerator.divmod_assign(denominator);
+    bool low = compare(numerator, lower) - even < 0;  // numerator <[=] lower.
+    // numerator + upper >[=] pow10:
+    bool high = add_compare(numerator, *upper, denominator) + even > 0;
+    data[num_digits++] = static_cast<char>('0' + digit);
+    if (low || high) {
+      if (!low) {
+        ++data[num_digits - 1];
+      } else if (high) {
+        int result = add_compare(numerator, numerator, denominator);
+        // Round half to even.
+        if (result > 0 || (result == 0 && (digit % 2) != 0))
+          ++data[num_digits - 1];
+      }
+      buf.resize(to_unsigned(num_digits));
+      exp10 -= num_digits - 1;
+      return;
+    }
+    numerator *= 10;
+    lower *= 10;
+    if (upper != &lower) *upper *= 10;
+  }
+}
+
+// Formats value using the Grisu algorithm
+// (https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf)
+// if T is a IEEE754 binary32 or binary64 and snprintf otherwise.
+template <typename T>
+int format_float(T value, int precision, float_specs specs, buffer<char>& buf) {
+  static_assert(!std::is_same<T, float>::value, "");
+  FMT_ASSERT(value >= 0, "value is negative");
+
+  const bool fixed = specs.format == float_format::fixed;
+  if (value <= 0) {  // <= instead of == to silence a warning.
+    if (precision <= 0 || !fixed) {
+      buf.push_back('0');
+      return 0;
+    }
+    buf.resize(to_unsigned(precision));
+    std::uninitialized_fill_n(buf.data(), precision, '0');
+    return -precision;
+  }
+
+  if (!specs.use_grisu) return snprintf_float(value, precision, specs, buf);
+
+  int exp = 0;
+  const int min_exp = -60;  // alpha in Grisu.
+  int cached_exp10 = 0;     // K in Grisu.
+  if (precision < 0) {
+    fp fp_value;
+    auto boundaries = specs.binary32
+                          ? fp_value.assign_float_with_boundaries(value)
+                          : fp_value.assign_with_boundaries(value);
+    fp_value = normalize(fp_value);
+    // Find a cached power of 10 such that multiplying value by it will bring
+    // the exponent in the range [min_exp, -32].
+    const fp cached_pow = get_cached_power(
+        min_exp - (fp_value.e + fp::significand_size), cached_exp10);
+    // Multiply value and boundaries by the cached power of 10.
+    fp_value = fp_value * cached_pow;
+    boundaries.lower = multiply(boundaries.lower, cached_pow.f);
+    boundaries.upper = multiply(boundaries.upper, cached_pow.f);
+    assert(min_exp <= fp_value.e && fp_value.e <= -32);
+    --boundaries.lower;  // \tilde{M}^- - 1 ulp -> M^-_{\downarrow}.
+    ++boundaries.upper;  // \tilde{M}^+ + 1 ulp -> M^+_{\uparrow}.
+    // Numbers outside of (lower, upper) definitely do not round to value.
+    grisu_shortest_handler handler{buf.data(), 0,
+                                   boundaries.upper - fp_value.f};
+    auto result =
+        grisu_gen_digits(fp(boundaries.upper, fp_value.e),
+                         boundaries.upper - boundaries.lower, exp, handler);
+    if (result == digits::error) {
+      exp += handler.size - cached_exp10 - 1;
+      fallback_format(value, buf, exp);
+      return exp;
+    }
+    buf.resize(to_unsigned(handler.size));
+  } else {
+    if (precision > 17) return snprintf_float(value, precision, specs, buf);
+    fp normalized = normalize(fp(value));
+    const auto cached_pow = get_cached_power(
+        min_exp - (normalized.e + fp::significand_size), cached_exp10);
+    normalized = normalized * cached_pow;
+    fixed_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
+    if (grisu_gen_digits(normalized, 1, exp, handler) == digits::error)
+      return snprintf_float(value, precision, specs, buf);
+    int num_digits = handler.size;
+    if (!fixed) {
+      // Remove trailing zeros.
+      while (num_digits > 0 && buf[num_digits - 1] == '0') {
+        --num_digits;
+        ++exp;
+      }
+    }
+    buf.resize(to_unsigned(num_digits));
+  }
+  return exp - cached_exp10;
+}
+
+template <typename T>
+int snprintf_float(T value, int precision, float_specs specs,
+                   buffer<char>& buf) {
+  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
+  FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer");
+  static_assert(!std::is_same<T, float>::value, "");
+
+  // Subtract 1 to account for the difference in precision since we use %e for
+  // both general and exponent format.
+  if (specs.format == float_format::general ||
+      specs.format == float_format::exp)
+    precision = (precision >= 0 ? precision : 6) - 1;
+
+  // Build the format string.
+  enum { max_format_size = 7 };  // Ths longest format is "%#.*Le".
+  char format[max_format_size];
+  char* format_ptr = format;
+  *format_ptr++ = '%';
+  if (specs.showpoint && specs.format == float_format::hex) *format_ptr++ = '#';
+  if (precision >= 0) {
+    *format_ptr++ = '.';
+    *format_ptr++ = '*';
+  }
+  if (std::is_same<T, long double>()) *format_ptr++ = 'L';
+  *format_ptr++ = specs.format != float_format::hex
+                      ? (specs.format == float_format::fixed ? 'f' : 'e')
+                      : (specs.upper ? 'A' : 'a');
+  *format_ptr = '\0';
+
+  // Format using snprintf.
+  auto offset = buf.size();
+  for (;;) {
+    auto begin = buf.data() + offset;
+    auto capacity = buf.capacity() - offset;
+#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
+    if (precision > 100000)
+      throw std::runtime_error(
+          "fuzz mode - avoid large allocation inside snprintf");
+#endif
+    // Suppress the warning about a nonliteral format string.
+    // Cannot use auto becase of a bug in MinGW (#1532).
+    int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF;
+    int result = precision >= 0
+                     ? snprintf_ptr(begin, capacity, format, precision, value)
+                     : snprintf_ptr(begin, capacity, format, value);
+    if (result < 0) {
+      buf.reserve(buf.capacity() + 1);  // The buffer will grow exponentially.
+      continue;
+    }
+    auto size = to_unsigned(result);
+    // Size equal to capacity means that the last character was truncated.
+    if (size >= capacity) {
+      buf.reserve(size + offset + 1);  // Add 1 for the terminating '\0'.
+      continue;
+    }
+    auto is_digit = [](char c) { return c >= '0' && c <= '9'; };
+    if (specs.format == float_format::fixed) {
+      if (precision == 0) {
+        buf.resize(size);
+        return 0;
+      }
+      // Find and remove the decimal point.
+      auto end = begin + size, p = end;
+      do {
+        --p;
+      } while (is_digit(*p));
+      int fraction_size = static_cast<int>(end - p - 1);
+      std::memmove(p, p + 1, to_unsigned(fraction_size));
+      buf.resize(size - 1);
+      return -fraction_size;
+    }
+    if (specs.format == float_format::hex) {
+      buf.resize(size + offset);
+      return 0;
+    }
+    // Find and parse the exponent.
+    auto end = begin + size, exp_pos = end;
+    do {
+      --exp_pos;
+    } while (*exp_pos != 'e');
+    char sign = exp_pos[1];
+    assert(sign == '+' || sign == '-');
+    int exp = 0;
+    auto p = exp_pos + 2;  // Skip 'e' and sign.
+    do {
+      assert(is_digit(*p));
+      exp = exp * 10 + (*p++ - '0');
+    } while (p != end);
+    if (sign == '-') exp = -exp;
+    int fraction_size = 0;
+    if (exp_pos != begin + 1) {
+      // Remove trailing zeros.
+      auto fraction_end = exp_pos - 1;
+      while (*fraction_end == '0') --fraction_end;
+      // Move the fractional part left to get rid of the decimal point.
+      fraction_size = static_cast<int>(fraction_end - begin - 1);
+      std::memmove(begin + 1, begin + 2, to_unsigned(fraction_size));
+    }
+    buf.resize(to_unsigned(fraction_size) + offset + 1);
+    return exp - fraction_size;
+  }
+}
+
+// A public domain branchless UTF-8 decoder by Christopher Wellons:
+// https://github.com/skeeto/branchless-utf8
+/* Decode the next character, c, from buf, reporting errors in e.
+ *
+ * Since this is a branchless decoder, four bytes will be read from the
+ * buffer regardless of the actual length of the next character. This
+ * means the buffer _must_ have at least three bytes of zero padding
+ * following the end of the data stream.
+ *
+ * Errors are reported in e, which will be non-zero if the parsed
+ * character was somehow invalid: invalid byte sequence, non-canonical
+ * encoding, or a surrogate half.
+ *
+ * The function returns a pointer to the next character. When an error
+ * occurs, this pointer will be a guess that depends on the particular
+ * error, but it will always advance at least one byte.
+ */
+FMT_FUNC const char* utf8_decode(const char* buf, uint32_t* c, int* e) {
+  static const char lengths[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+                                 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+                                 0, 0, 2, 2, 2, 2, 3, 3, 4, 0};
+  static const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07};
+  static const uint32_t mins[] = {4194304, 0, 128, 2048, 65536};
+  static const int shiftc[] = {0, 18, 12, 6, 0};
+  static const int shifte[] = {0, 6, 4, 2, 0};
+
+  auto s = reinterpret_cast<const unsigned char*>(buf);
+  int len = lengths[s[0] >> 3];
+
+  // Compute the pointer to the next character early so that the next
+  // iteration can start working on the next character. Neither Clang
+  // nor GCC figure out this reordering on their own.
+  const char* next = buf + len + !len;
+
+  // Assume a four-byte character and load four bytes. Unused bits are
+  // shifted out.
+  *c = uint32_t(s[0] & masks[len]) << 18;
+  *c |= uint32_t(s[1] & 0x3f) << 12;
+  *c |= uint32_t(s[2] & 0x3f) << 6;
+  *c |= uint32_t(s[3] & 0x3f) << 0;
+  *c >>= shiftc[len];
+
+  // Accumulate the various error conditions.
+  *e = (*c < mins[len]) << 6;       // non-canonical encoding
+  *e |= ((*c >> 11) == 0x1b) << 7;  // surrogate half?
+  *e |= (*c > 0x10FFFF) << 8;       // out of range?
+  *e |= (s[1] & 0xc0) >> 2;
+  *e |= (s[2] & 0xc0) >> 4;
+  *e |= (s[3]) >> 6;
+  *e ^= 0x2a;  // top two bits of each tail byte correct?
+  *e >>= shifte[len];
+
+  return next;
+}
+}  // namespace internal
+
+template <> struct formatter<internal::bigint> {
+  format_parse_context::iterator parse(format_parse_context& ctx) {
+    return ctx.begin();
+  }
+
+  format_context::iterator format(const internal::bigint& n,
+                                  format_context& ctx) {
+    auto out = ctx.out();
+    bool first = true;
+    for (auto i = n.bigits_.size(); i > 0; --i) {
+      auto value = n.bigits_[i - 1u];
+      if (first) {
+        out = format_to(out, "{:x}", value);
+        first = false;
+        continue;
+      }
+      out = format_to(out, "{:08x}", value);
+    }
+    if (n.exp_ > 0)
+      out = format_to(out, "p{}", n.exp_ * internal::bigint::bigit_bits);
+    return out;
+  }
+};
+
+FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
+  auto transcode = [this](const char* p) {
+    auto cp = uint32_t();
+    auto error = 0;
+    p = utf8_decode(p, &cp, &error);
+    if (error != 0) FMT_THROW(std::runtime_error("invalid utf8"));
+    if (cp <= 0xFFFF) {
+      buffer_.push_back(static_cast<wchar_t>(cp));
+    } else {
+      cp -= 0x10000;
+      buffer_.push_back(static_cast<wchar_t>(0xD800 + (cp >> 10)));
+      buffer_.push_back(static_cast<wchar_t>(0xDC00 + (cp & 0x3FF)));
+    }
+    return p;
+  };
+  auto p = s.data();
+  const size_t block_size = 4;  // utf8_decode always reads blocks of 4 chars.
+  if (s.size() >= block_size) {
+    for (auto end = p + s.size() - block_size + 1; p < end;) p = transcode(p);
+  }
+  if (auto num_chars_left = s.data() + s.size() - p) {
+    char buf[2 * block_size - 1] = {};
+    memcpy(buf, p, to_unsigned(num_chars_left));
+    p = buf;
+    do {
+      p = transcode(p);
+    } while (p - buf < num_chars_left);
+  }
+  buffer_.push_back(0);
+}
+
+FMT_FUNC void format_system_error(internal::buffer<char>& out, int error_code,
+                                  string_view message) FMT_NOEXCEPT {
+  FMT_TRY {
+    memory_buffer buf;
+    buf.resize(inline_buffer_size);
+    for (;;) {
+      char* system_message = &buf[0];
+      int result =
+          internal::safe_strerror(error_code, system_message, buf.size());
+      if (result == 0) {
+        internal::writer w(out);
+        w.write(message);
+        w.write(": ");
+        w.write(system_message);
+        return;
+      }
+      if (result != ERANGE)
+        break;  // Can't get error message, report error code instead.
+      buf.resize(buf.size() * 2);
+    }
+  }
+  FMT_CATCH(...) {}
+  format_error_code(out, error_code, message);
+}
+
+FMT_FUNC void internal::error_handler::on_error(const char* message) {
+  FMT_THROW(format_error(message));
+}
+
+FMT_FUNC void report_system_error(int error_code,
+                                  fmt::string_view message) FMT_NOEXCEPT {
+  report_error(format_system_error, error_code, message);
+}
+
+FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
+  memory_buffer buffer;
+  internal::vformat_to(buffer, format_str,
+                       basic_format_args<buffer_context<char>>(args));
+#ifdef _WIN32
+  auto fd = _fileno(f);
+  if (_isatty(fd)) {
+    internal::utf8_to_utf16 u16(string_view(buffer.data(), buffer.size()));
+    auto written = DWORD();
+    if (!WriteConsoleW(reinterpret_cast<HANDLE>(_get_osfhandle(fd)),
+                       u16.c_str(), static_cast<DWORD>(u16.size()), &written,
+                       nullptr)) {
+      FMT_THROW(format_error("failed to write to console"));
+    }
+    return;
+  }
+#endif
+  internal::fwrite_fully(buffer.data(), 1, buffer.size(), f);
+}
+
+#ifdef _WIN32
+// Print assuming legacy (non-Unicode) encoding.
+FMT_FUNC void internal::vprint_mojibake(std::FILE* f, string_view format_str,
+                                        format_args args) {
+  memory_buffer buffer;
+  internal::vformat_to(buffer, format_str,
+                       basic_format_args<buffer_context<char>>(args));
+  fwrite_fully(buffer.data(), 1, buffer.size(), f);
+}
+#endif
+
+FMT_FUNC void vprint(string_view format_str, format_args args) {
+  vprint(stdout, format_str, args);
+}
+
+FMT_END_NAMESPACE
+
+#ifdef _MSC_VER
+#  pragma warning(pop)
+#endif
+
+#endif  // FMT_FORMAT_INL_H_
diff --git a/lib/fmt/fmt/format.cc b/lib/fmt/fmt/format.cc
new file mode 100644
index 0000000..9a9abf8
--- /dev/null
+++ b/lib/fmt/fmt/format.cc
@@ -0,0 +1,176 @@
+// Formatting library for C++
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/format-inl.h"
+
+FMT_BEGIN_NAMESPACE
+namespace internal {
+
+template <typename T>
+int format_float(char* buf, std::size_t size, const char* format, int precision,
+                 T value) {
+#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
+  if (precision > 100000)
+    throw std::runtime_error(
+        "fuzz mode - avoid large allocation inside snprintf");
+#endif
+  // Suppress the warning about nonliteral format string.
+  int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF;
+  return precision < 0 ? snprintf_ptr(buf, size, format, value)
+                       : snprintf_ptr(buf, size, format, precision, value);
+}
+struct sprintf_specs {
+  int precision;
+  char type;
+  bool alt : 1;
+
+  template <typename Char>
+  constexpr sprintf_specs(basic_format_specs<Char> specs)
+      : precision(specs.precision), type(specs.type), alt(specs.alt) {}
+
+  constexpr bool has_precision() const { return precision >= 0; }
+};
+
+// This is deprecated and is kept only to preserve ABI compatibility.
+template <typename Double>
+char* sprintf_format(Double value, internal::buffer<char>& buf,
+                     sprintf_specs specs) {
+  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
+  FMT_ASSERT(buf.capacity() != 0, "empty buffer");
+
+  // Build format string.
+  enum { max_format_size = 10 };  // longest format: %#-*.*Lg
+  char format[max_format_size];
+  char* format_ptr = format;
+  *format_ptr++ = '%';
+  if (specs.alt || !specs.type) *format_ptr++ = '#';
+  if (specs.precision >= 0) {
+    *format_ptr++ = '.';
+    *format_ptr++ = '*';
+  }
+  if (std::is_same<Double, long double>::value) *format_ptr++ = 'L';
+
+  char type = specs.type;
+
+  if (type == '%')
+    type = 'f';
+  else if (type == 0 || type == 'n')
+    type = 'g';
+#if FMT_MSC_VER
+  if (type == 'F') {
+    // MSVC's printf doesn't support 'F'.
+    type = 'f';
+  }
+#endif
+  *format_ptr++ = type;
+  *format_ptr = '\0';
+
+  // Format using snprintf.
+  char* start = nullptr;
+  char* decimal_point_pos = nullptr;
+  for (;;) {
+    std::size_t buffer_size = buf.capacity();
+    start = &buf[0];
+    int result =
+        format_float(start, buffer_size, format, specs.precision, value);
+    if (result >= 0) {
+      unsigned n = internal::to_unsigned(result);
+      if (n < buf.capacity()) {
+        // Find the decimal point.
+        auto p = buf.data(), end = p + n;
+        if (*p == '+' || *p == '-') ++p;
+        if (specs.type != 'a' && specs.type != 'A') {
+          while (p < end && *p >= '0' && *p <= '9') ++p;
+          if (p < end && *p != 'e' && *p != 'E') {
+            decimal_point_pos = p;
+            if (!specs.type) {
+              // Keep only one trailing zero after the decimal point.
+              ++p;
+              if (*p == '0') ++p;
+              while (p != end && *p >= '1' && *p <= '9') ++p;
+              char* where = p;
+              while (p != end && *p == '0') ++p;
+              if (p == end || *p < '0' || *p > '9') {
+                if (p != end) std::memmove(where, p, to_unsigned(end - p));
+                n -= static_cast<unsigned>(p - where);
+              }
+            }
+          }
+        }
+        buf.resize(n);
+        break;  // The buffer is large enough - continue with formatting.
+      }
+      buf.reserve(n + 1);
+    } else {
+      // If result is negative we ask to increase the capacity by at least 1,
+      // but as std::vector, the buffer grows exponentially.
+      buf.reserve(buf.capacity() + 1);
+    }
+  }
+  return decimal_point_pos;
+}
+}  // namespace internal
+
+template FMT_API char* internal::sprintf_format(double, internal::buffer<char>&,
+                                                sprintf_specs);
+template FMT_API char* internal::sprintf_format(long double,
+                                                internal::buffer<char>&,
+                                                sprintf_specs);
+
+template struct FMT_INSTANTIATION_DEF_API internal::basic_data<void>;
+
+// Workaround a bug in MSVC2013 that prevents instantiation of format_float.
+int (*instantiate_format_float)(double, int, internal::float_specs,
+                                internal::buffer<char>&) =
+    internal::format_float;
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+template FMT_API internal::locale_ref::locale_ref(const std::locale& loc);
+template FMT_API std::locale internal::locale_ref::get<std::locale>() const;
+#endif
+
+// Explicit instantiations for char.
+
+template FMT_API std::string internal::grouping_impl<char>(locale_ref);
+template FMT_API char internal::thousands_sep_impl(locale_ref);
+template FMT_API char internal::decimal_point_impl(locale_ref);
+
+template FMT_API void internal::buffer<char>::append(const char*, const char*);
+
+template FMT_API void internal::arg_map<format_context>::init(
+    const basic_format_args<format_context>& args);
+
+template FMT_API std::string internal::vformat<char>(
+    string_view, basic_format_args<format_context>);
+
+template FMT_API format_context::iterator internal::vformat_to(
+    internal::buffer<char>&, string_view, basic_format_args<format_context>);
+
+template FMT_API int internal::snprintf_float(double, int,
+                                              internal::float_specs,
+                                              internal::buffer<char>&);
+template FMT_API int internal::snprintf_float(long double, int,
+                                              internal::float_specs,
+                                              internal::buffer<char>&);
+template FMT_API int internal::format_float(double, int, internal::float_specs,
+                                            internal::buffer<char>&);
+template FMT_API int internal::format_float(long double, int,
+                                            internal::float_specs,
+                                            internal::buffer<char>&);
+
+// Explicit instantiations for wchar_t.
+
+template FMT_API std::string internal::grouping_impl<wchar_t>(locale_ref);
+template FMT_API wchar_t internal::thousands_sep_impl(locale_ref);
+template FMT_API wchar_t internal::decimal_point_impl(locale_ref);
+
+template FMT_API void internal::buffer<wchar_t>::append(const wchar_t*,
+                                                        const wchar_t*);
+
+template FMT_API std::wstring internal::vformat<wchar_t>(
+    wstring_view, basic_format_args<wformat_context>);
+FMT_END_NAMESPACE
diff --git a/lib/fmt/fmt/format.h b/lib/fmt/fmt/format.h
new file mode 100644
index 0000000..4e96539
--- /dev/null
+++ b/lib/fmt/fmt/format.h
@@ -0,0 +1,3648 @@
+/*
+ Formatting library for C++
+
+ Copyright (c) 2012 - present, Victor Zverovich
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ --- Optional exception to the license ---
+
+ As an exception, if, as a result of your compiling your source code, portions
+ of this Software are embedded into a machine-executable object form of such
+ source code, you may redistribute such embedded portions in such object form
+ without including the above copyright and permission notices.
+ */
+
+#ifndef FMT_FORMAT_H_
+#define FMT_FORMAT_H_
+
+#include <algorithm>
+#include <cerrno>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <stdexcept>
+
+#include "core.h"
+
+#ifdef FMT_DEPRECATED_INCLUDE_OS
+#  include "os.h"
+#endif
+
+#ifdef __INTEL_COMPILER
+#  define FMT_ICC_VERSION __INTEL_COMPILER
+#elif defined(__ICL)
+#  define FMT_ICC_VERSION __ICL
+#else
+#  define FMT_ICC_VERSION 0
+#endif
+
+#ifdef __NVCC__
+#  define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__)
+#else
+#  define FMT_CUDA_VERSION 0
+#endif
+
+#ifdef __has_builtin
+#  define FMT_HAS_BUILTIN(x) __has_builtin(x)
+#else
+#  define FMT_HAS_BUILTIN(x) 0
+#endif
+
+#if FMT_GCC_VERSION || FMT_CLANG_VERSION
+#  define FMT_NOINLINE __attribute__((noinline))
+#else
+#  define FMT_NOINLINE
+#endif
+
+#if __cplusplus == 201103L || __cplusplus == 201402L
+#  if defined(__clang__)
+#    define FMT_FALLTHROUGH [[clang::fallthrough]]
+#  elif FMT_GCC_VERSION >= 700 && !defined(__PGI)
+#    define FMT_FALLTHROUGH [[gnu::fallthrough]]
+#  else
+#    define FMT_FALLTHROUGH
+#  endif
+#elif FMT_HAS_CPP17_ATTRIBUTE(fallthrough) || \
+    (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+#  define FMT_FALLTHROUGH [[fallthrough]]
+#else
+#  define FMT_FALLTHROUGH
+#endif
+
+#ifndef FMT_THROW
+#  if FMT_EXCEPTIONS
+#    if FMT_MSC_VER || FMT_NVCC
+FMT_BEGIN_NAMESPACE
+namespace internal {
+template <typename Exception> inline void do_throw(const Exception& x) {
+  // Silence unreachable code warnings in MSVC and NVCC because these
+  // are nearly impossible to fix in a generic code.
+  volatile bool b = true;
+  if (b) throw x;
+}
+}  // namespace internal
+FMT_END_NAMESPACE
+#      define FMT_THROW(x) internal::do_throw(x)
+#    else
+#      define FMT_THROW(x) throw x
+#    endif
+#  else
+#    define FMT_THROW(x)              \
+      do {                            \
+        static_cast<void>(sizeof(x)); \
+        FMT_ASSERT(false, "");        \
+      } while (false)
+#  endif
+#endif
+
+#if FMT_EXCEPTIONS
+#  define FMT_TRY try
+#  define FMT_CATCH(x) catch (x)
+#else
+#  define FMT_TRY if (true)
+#  define FMT_CATCH(x) if (false)
+#endif
+
+#ifndef FMT_USE_USER_DEFINED_LITERALS
+// For Intel and NVIDIA compilers both they and the system gcc/msc support UDLs.
+#  if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 ||      \
+       FMT_MSC_VER >= 1900) &&                                              \
+      (!(FMT_ICC_VERSION || FMT_CUDA_VERSION) || FMT_ICC_VERSION >= 1500 || \
+       FMT_CUDA_VERSION >= 700)
+#    define FMT_USE_USER_DEFINED_LITERALS 1
+#  else
+#    define FMT_USE_USER_DEFINED_LITERALS 0
+#  endif
+#endif
+
+#ifndef FMT_USE_UDL_TEMPLATE
+// EDG front end based compilers (icc, nvcc) and GCC < 6.4 do not propertly
+// support UDL templates and GCC >= 9 warns about them.
+#  if FMT_USE_USER_DEFINED_LITERALS && FMT_ICC_VERSION == 0 && \
+      FMT_CUDA_VERSION == 0 &&                                 \
+      ((FMT_GCC_VERSION >= 604 && FMT_GCC_VERSION <= 900 &&    \
+        __cplusplus >= 201402L) ||                             \
+       FMT_CLANG_VERSION >= 304)
+#    define FMT_USE_UDL_TEMPLATE 1
+#  else
+#    define FMT_USE_UDL_TEMPLATE 0
+#  endif
+#endif
+
+#ifndef FMT_USE_FLOAT
+#  define FMT_USE_FLOAT 1
+#endif
+
+#ifndef FMT_USE_DOUBLE
+#  define FMT_USE_DOUBLE 1
+#endif
+
+#ifndef FMT_USE_LONG_DOUBLE
+#  define FMT_USE_LONG_DOUBLE 1
+#endif
+
+// __builtin_clz is broken in clang with Microsoft CodeGen:
+// https://github.com/fmtlib/fmt/issues/519
+#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clz)) && !FMT_MSC_VER
+#  define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
+#endif
+#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clzll)) && !FMT_MSC_VER
+#  define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
+#endif
+
+// Some compilers masquerade as both MSVC and GCC-likes or otherwise support
+// __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the
+// MSVC intrinsics if the clz and clzll builtins are not available.
+#if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED)
+#  include <intrin.h>  // _BitScanReverse, _BitScanReverse64
+
+FMT_BEGIN_NAMESPACE
+namespace internal {
+// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.
+#  ifndef __clang__
+#    pragma intrinsic(_BitScanReverse)
+#  endif
+inline uint32_t clz(uint32_t x) {
+  unsigned long r = 0;
+  _BitScanReverse(&r, x);
+
+  FMT_ASSERT(x != 0, "");
+  // Static analysis complains about using uninitialized data
+  // "r", but the only way that can happen is if "x" is 0,
+  // which the callers guarantee to not happen.
+#  pragma warning(suppress : 6102)
+  return 31 - r;
+}
+#  define FMT_BUILTIN_CLZ(n) internal::clz(n)
+
+#  if defined(_WIN64) && !defined(__clang__)
+#    pragma intrinsic(_BitScanReverse64)
+#  endif
+
+inline uint32_t clzll(uint64_t x) {
+  unsigned long r = 0;
+#  ifdef _WIN64
+  _BitScanReverse64(&r, x);
+#  else
+  // Scan the high 32 bits.
+  if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32))) return 63 - (r + 32);
+
+  // Scan the low 32 bits.
+  _BitScanReverse(&r, static_cast<uint32_t>(x));
+#  endif
+
+  FMT_ASSERT(x != 0, "");
+  // Static analysis complains about using uninitialized data
+  // "r", but the only way that can happen is if "x" is 0,
+  // which the callers guarantee to not happen.
+#  pragma warning(suppress : 6102)
+  return 63 - r;
+}
+#  define FMT_BUILTIN_CLZLL(n) internal::clzll(n)
+}  // namespace internal
+FMT_END_NAMESPACE
+#endif
+
+// Enable the deprecated numeric alignment.
+#ifndef FMT_NUMERIC_ALIGN
+#  define FMT_NUMERIC_ALIGN 1
+#endif
+
+// Enable the deprecated percent specifier.
+#ifndef FMT_DEPRECATED_PERCENT
+#  define FMT_DEPRECATED_PERCENT 0
+#endif
+
+FMT_BEGIN_NAMESPACE
+namespace internal {
+
+// An equivalent of `*reinterpret_cast<Dest*>(&source)` that doesn't have
+// undefined behavior (e.g. due to type aliasing).
+// Example: uint64_t d = bit_cast<uint64_t>(2.718);
+template <typename Dest, typename Source>
+inline Dest bit_cast(const Source& source) {
+  static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");
+  Dest dest;
+  std::memcpy(&dest, &source, sizeof(dest));
+  return dest;
+}
+
+inline bool is_big_endian() {
+  const auto u = 1u;
+  struct bytes {
+    char data[sizeof(u)];
+  };
+  return bit_cast<bytes>(u).data[0] == 0;
+}
+
+// A fallback implementation of uintptr_t for systems that lack it.
+struct fallback_uintptr {
+  unsigned char value[sizeof(void*)];
+
+  fallback_uintptr() = default;
+  explicit fallback_uintptr(const void* p) {
+    *this = bit_cast<fallback_uintptr>(p);
+    if (is_big_endian()) {
+      for (size_t i = 0, j = sizeof(void*) - 1; i < j; ++i, --j)
+        std::swap(value[i], value[j]);
+    }
+  }
+};
+#ifdef UINTPTR_MAX
+using uintptr_t = ::uintptr_t;
+inline uintptr_t to_uintptr(const void* p) { return bit_cast<uintptr_t>(p); }
+#else
+using uintptr_t = fallback_uintptr;
+inline fallback_uintptr to_uintptr(const void* p) {
+  return fallback_uintptr(p);
+}
+#endif
+
+// Returns the largest possible value for type T. Same as
+// std::numeric_limits<T>::max() but shorter and not affected by the max macro.
+template <typename T> constexpr T max_value() {
+  return (std::numeric_limits<T>::max)();
+}
+template <typename T> constexpr int num_bits() {
+  return std::numeric_limits<T>::digits;
+}
+template <> constexpr int num_bits<fallback_uintptr>() {
+  return static_cast<int>(sizeof(void*) *
+                          std::numeric_limits<unsigned char>::digits);
+}
+
+// An approximation of iterator_t for pre-C++20 systems.
+template <typename T>
+using iterator_t = decltype(std::begin(std::declval<T&>()));
+
+// Detect the iterator category of *any* given type in a SFINAE-friendly way.
+// Unfortunately, older implementations of std::iterator_traits are not safe
+// for use in a SFINAE-context.
+template <typename It, typename Enable = void>
+struct iterator_category : std::false_type {};
+
+template <typename T> struct iterator_category<T*> {
+  using type = std::random_access_iterator_tag;
+};
+
+template <typename It>
+struct iterator_category<It, void_t<typename It::iterator_category>> {
+  using type = typename It::iterator_category;
+};
+
+// Detect if *any* given type models the OutputIterator concept.
+template <typename It> class is_output_iterator {
+  // Check for mutability because all iterator categories derived from
+  // std::input_iterator_tag *may* also meet the requirements of an
+  // OutputIterator, thereby falling into the category of 'mutable iterators'
+  // [iterator.requirements.general] clause 4. The compiler reveals this
+  // property only at the point of *actually dereferencing* the iterator!
+  template <typename U>
+  static decltype(*(std::declval<U>())) test(std::input_iterator_tag);
+  template <typename U> static char& test(std::output_iterator_tag);
+  template <typename U> static const char& test(...);
+
+  using type = decltype(test<It>(typename iterator_category<It>::type{}));
+
+ public:
+  enum { value = !std::is_const<remove_reference_t<type>>::value };
+};
+
+// A workaround for std::string not having mutable data() until C++17.
+template <typename Char> inline Char* get_data(std::basic_string<Char>& s) {
+  return &s[0];
+}
+template <typename Container>
+inline typename Container::value_type* get_data(Container& c) {
+  return c.data();
+}
+
+#if defined(_SECURE_SCL) && _SECURE_SCL
+// Make a checked iterator to avoid MSVC warnings.
+template <typename T> using checked_ptr = stdext::checked_array_iterator<T*>;
+template <typename T> checked_ptr<T> make_checked(T* p, std::size_t size) {
+  return {p, size};
+}
+#else
+template <typename T> using checked_ptr = T*;
+template <typename T> inline T* make_checked(T* p, std::size_t) { return p; }
+#endif
+
+template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
+inline checked_ptr<typename Container::value_type> reserve(
+    std::back_insert_iterator<Container>& it, std::size_t n) {
+  Container& c = get_container(it);
+  std::size_t size = c.size();
+  c.resize(size + n);
+  return make_checked(get_data(c) + size, n);
+}
+
+template <typename Iterator>
+inline Iterator& reserve(Iterator& it, std::size_t) {
+  return it;
+}
+
+// An output iterator that counts the number of objects written to it and
+// discards them.
+class counting_iterator {
+ private:
+  std::size_t count_;
+
+ public:
+  using iterator_category = std::output_iterator_tag;
+  using difference_type = std::ptrdiff_t;
+  using pointer = void;
+  using reference = void;
+  using _Unchecked_type = counting_iterator;  // Mark iterator as checked.
+
+  struct value_type {
+    template <typename T> void operator=(const T&) {}
+  };
+
+  counting_iterator() : count_(0) {}
+
+  std::size_t count() const { return count_; }
+
+  counting_iterator& operator++() {
+    ++count_;
+    return *this;
+  }
+
+  counting_iterator operator++(int) {
+    auto it = *this;
+    ++*this;
+    return it;
+  }
+
+  value_type operator*() const { return {}; }
+};
+
+template <typename OutputIt> class truncating_iterator_base {
+ protected:
+  OutputIt out_;
+  std::size_t limit_;
+  std::size_t count_;
+
+  truncating_iterator_base(OutputIt out, std::size_t limit)
+      : out_(out), limit_(limit), count_(0) {}
+
+ public:
+  using iterator_category = std::output_iterator_tag;
+  using value_type = typename std::iterator_traits<OutputIt>::value_type;
+  using difference_type = void;
+  using pointer = void;
+  using reference = void;
+  using _Unchecked_type =
+      truncating_iterator_base;  // Mark iterator as checked.
+
+  OutputIt base() const { return out_; }
+  std::size_t count() const { return count_; }
+};
+
+// An output iterator that truncates the output and counts the number of objects
+// written to it.
+template <typename OutputIt,
+          typename Enable = typename std::is_void<
+              typename std::iterator_traits<OutputIt>::value_type>::type>
+class truncating_iterator;
+
+template <typename OutputIt>
+class truncating_iterator<OutputIt, std::false_type>
+    : public truncating_iterator_base<OutputIt> {
+  mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_;
+
+ public:
+  using value_type = typename truncating_iterator_base<OutputIt>::value_type;
+
+  truncating_iterator(OutputIt out, std::size_t limit)
+      : truncating_iterator_base<OutputIt>(out, limit) {}
+
+  truncating_iterator& operator++() {
+    if (this->count_++ < this->limit_) ++this->out_;
+    return *this;
+  }
+
+  truncating_iterator operator++(int) {
+    auto it = *this;
+    ++*this;
+    return it;
+  }
+
+  value_type& operator*() const {
+    return this->count_ < this->limit_ ? *this->out_ : blackhole_;
+  }
+};
+
+template <typename OutputIt>
+class truncating_iterator<OutputIt, std::true_type>
+    : public truncating_iterator_base<OutputIt> {
+ public:
+  truncating_iterator(OutputIt out, std::size_t limit)
+      : truncating_iterator_base<OutputIt>(out, limit) {}
+
+  template <typename T> truncating_iterator& operator=(T val) {
+    if (this->count_++ < this->limit_) *this->out_++ = val;
+    return *this;
+  }
+
+  truncating_iterator& operator++() { return *this; }
+  truncating_iterator& operator++(int) { return *this; }
+  truncating_iterator& operator*() { return *this; }
+};
+
+// A range with the specified output iterator and value type.
+template <typename OutputIt, typename T = typename OutputIt::value_type>
+class output_range {
+ private:
+  OutputIt it_;
+
+ public:
+  using value_type = T;
+  using iterator = OutputIt;
+  struct sentinel {};
+
+  explicit output_range(OutputIt it) : it_(it) {}
+  OutputIt begin() const { return it_; }
+  sentinel end() const { return {}; }  // Sentinel is not used yet.
+};
+
+template <typename Char>
+inline size_t count_code_points(basic_string_view<Char> s) {
+  return s.size();
+}
+
+// Counts the number of code points in a UTF-8 string.
+inline size_t count_code_points(basic_string_view<char> s) {
+  const char* data = s.data();
+  size_t num_code_points = 0;
+  for (size_t i = 0, size = s.size(); i != size; ++i) {
+    if ((data[i] & 0xc0) != 0x80) ++num_code_points;
+  }
+  return num_code_points;
+}
+
+inline size_t count_code_points(basic_string_view<char8_type> s) {
+  return count_code_points(basic_string_view<char>(
+      reinterpret_cast<const char*>(s.data()), s.size()));
+}
+
+template <typename Char>
+inline size_t code_point_index(basic_string_view<Char> s, size_t n) {
+  size_t size = s.size();
+  return n < size ? n : size;
+}
+
+// Calculates the index of the nth code point in a UTF-8 string.
+inline size_t code_point_index(basic_string_view<char8_type> s, size_t n) {
+  const char8_type* data = s.data();
+  size_t num_code_points = 0;
+  for (size_t i = 0, size = s.size(); i != size; ++i) {
+    if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) {
+      return i;
+    }
+  }
+  return s.size();
+}
+
+inline char8_type to_char8_t(char c) { return static_cast<char8_type>(c); }
+
+template <typename InputIt, typename OutChar>
+using needs_conversion = bool_constant<
+    std::is_same<typename std::iterator_traits<InputIt>::value_type,
+                 char>::value &&
+    std::is_same<OutChar, char8_type>::value>;
+
+template <typename OutChar, typename InputIt, typename OutputIt,
+          FMT_ENABLE_IF(!needs_conversion<InputIt, OutChar>::value)>
+OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
+  return std::copy(begin, end, it);
+}
+
+template <typename OutChar, typename InputIt, typename OutputIt,
+          FMT_ENABLE_IF(needs_conversion<InputIt, OutChar>::value)>
+OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
+  return std::transform(begin, end, it, to_char8_t);
+}
+
+#ifndef FMT_USE_GRISU
+#  define FMT_USE_GRISU 1
+#endif
+
+template <typename T> constexpr bool use_grisu() {
+  return FMT_USE_GRISU && std::numeric_limits<double>::is_iec559 &&
+         sizeof(T) <= sizeof(double);
+}
+
+template <typename T>
+template <typename U>
+void buffer<T>::append(const U* begin, const U* end) {
+  std::size_t new_size = size_ + to_unsigned(end - begin);
+  reserve(new_size);
+  std::uninitialized_copy(begin, end, make_checked(ptr_, capacity_) + size_);
+  size_ = new_size;
+}
+}  // namespace internal
+
+// A range with an iterator appending to a buffer.
+template <typename T>
+class buffer_range : public internal::output_range<
+                         std::back_insert_iterator<internal::buffer<T>>, T> {
+ public:
+  using iterator = std::back_insert_iterator<internal::buffer<T>>;
+  using internal::output_range<iterator, T>::output_range;
+  buffer_range(internal::buffer<T>& buf)
+      : internal::output_range<iterator, T>(std::back_inserter(buf)) {}
+};
+
+class FMT_DEPRECATED u8string_view
+    : public basic_string_view<internal::char8_type> {
+ public:
+  u8string_view(const char* s)
+      : basic_string_view<internal::char8_type>(
+            reinterpret_cast<const internal::char8_type*>(s)) {}
+  u8string_view(const char* s, size_t count) FMT_NOEXCEPT
+      : basic_string_view<internal::char8_type>(
+            reinterpret_cast<const internal::char8_type*>(s), count) {}
+};
+
+#if FMT_USE_USER_DEFINED_LITERALS
+inline namespace literals {
+FMT_DEPRECATED inline basic_string_view<internal::char8_type> operator"" _u(
+    const char* s, std::size_t n) {
+  return {reinterpret_cast<const internal::char8_type*>(s), n};
+}
+}  // namespace literals
+#endif
+
+// The number of characters to store in the basic_memory_buffer object itself
+// to avoid dynamic memory allocation.
+enum { inline_buffer_size = 500 };
+
+/**
+  \rst
+  A dynamically growing memory buffer for trivially copyable/constructible types
+  with the first ``SIZE`` elements stored in the object itself.
+
+  You can use one of the following type aliases for common character types:
+
+  +----------------+------------------------------+
+  | Type           | Definition                   |
+  +================+==============================+
+  | memory_buffer  | basic_memory_buffer<char>    |
+  +----------------+------------------------------+
+  | wmemory_buffer | basic_memory_buffer<wchar_t> |
+  +----------------+------------------------------+
+
+  **Example**::
+
+     fmt::memory_buffer out;
+     format_to(out, "The answer is {}.", 42);
+
+  This will append the following output to the ``out`` object:
+
+  .. code-block:: none
+
+     The answer is 42.
+
+  The output can be converted to an ``std::string`` with ``to_string(out)``.
+  \endrst
+ */
+template <typename T, std::size_t SIZE = inline_buffer_size,
+          typename Allocator = std::allocator<T>>
+class basic_memory_buffer : private Allocator, public internal::buffer<T> {
+ private:
+  T store_[SIZE];
+
+  // Deallocate memory allocated by the buffer.
+  void deallocate() {
+    T* data = this->data();
+    if (data != store_) Allocator::deallocate(data, this->capacity());
+  }
+
+ protected:
+  void grow(std::size_t size) FMT_OVERRIDE;
+
+ public:
+  using value_type = T;
+  using const_reference = const T&;
+
+  explicit basic_memory_buffer(const Allocator& alloc = Allocator())
+      : Allocator(alloc) {
+    this->set(store_, SIZE);
+  }
+  ~basic_memory_buffer() FMT_OVERRIDE { deallocate(); }
+
+ private:
+  // Move data from other to this buffer.
+  void move(basic_memory_buffer& other) {
+    Allocator &this_alloc = *this, &other_alloc = other;
+    this_alloc = std::move(other_alloc);
+    T* data = other.data();
+    std::size_t size = other.size(), capacity = other.capacity();
+    if (data == other.store_) {
+      this->set(store_, capacity);
+      std::uninitialized_copy(other.store_, other.store_ + size,
+                              internal::make_checked(store_, capacity));
+    } else {
+      this->set(data, capacity);
+      // Set pointer to the inline array so that delete is not called
+      // when deallocating.
+      other.set(other.store_, 0);
+    }
+    this->resize(size);
+  }
+
+ public:
+  /**
+    \rst
+    Constructs a :class:`fmt::basic_memory_buffer` object moving the content
+    of the other object to it.
+    \endrst
+   */
+  basic_memory_buffer(basic_memory_buffer&& other) FMT_NOEXCEPT { move(other); }
+
+  /**
+    \rst
+    Moves the content of the other ``basic_memory_buffer`` object to this one.
+    \endrst
+   */
+  basic_memory_buffer& operator=(basic_memory_buffer&& other) FMT_NOEXCEPT {
+    FMT_ASSERT(this != &other, "");
+    deallocate();
+    move(other);
+    return *this;
+  }
+
+  // Returns a copy of the allocator associated with this buffer.
+  Allocator get_allocator() const { return *this; }
+};
+
+template <typename T, std::size_t SIZE, typename Allocator>
+void basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t size) {
+#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
+  if (size > 1000) throw std::runtime_error("fuzz mode - won't grow that much");
+#endif
+  std::size_t old_capacity = this->capacity();
+  std::size_t new_capacity = old_capacity + old_capacity / 2;
+  if (size > new_capacity) new_capacity = size;
+  T* old_data = this->data();
+  T* new_data = std::allocator_traits<Allocator>::allocate(*this, new_capacity);
+  // The following code doesn't throw, so the raw pointer above doesn't leak.
+  std::uninitialized_copy(old_data, old_data + this->size(),
+                          internal::make_checked(new_data, new_capacity));
+  this->set(new_data, new_capacity);
+  // deallocate must not throw according to the standard, but even if it does,
+  // the buffer already uses the new storage and will deallocate it in
+  // destructor.
+  if (old_data != store_) Allocator::deallocate(old_data, old_capacity);
+}
+
+using memory_buffer = basic_memory_buffer<char>;
+using wmemory_buffer = basic_memory_buffer<wchar_t>;
+
+/** A formatting error such as invalid format string. */
+FMT_CLASS_API
+class FMT_API format_error : public std::runtime_error {
+ public:
+  explicit format_error(const char* message) : std::runtime_error(message) {}
+  explicit format_error(const std::string& message)
+      : std::runtime_error(message) {}
+  format_error(const format_error&) = default;
+  format_error& operator=(const format_error&) = default;
+  format_error(format_error&&) = default;
+  format_error& operator=(format_error&&) = default;
+  ~format_error() FMT_NOEXCEPT FMT_OVERRIDE;
+};
+
+namespace internal {
+
+// Returns true if value is negative, false otherwise.
+// Same as `value < 0` but doesn't produce warnings if T is an unsigned type.
+template <typename T, FMT_ENABLE_IF(std::numeric_limits<T>::is_signed)>
+FMT_CONSTEXPR bool is_negative(T value) {
+  return value < 0;
+}
+template <typename T, FMT_ENABLE_IF(!std::numeric_limits<T>::is_signed)>
+FMT_CONSTEXPR bool is_negative(T) {
+  return false;
+}
+
+template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+FMT_CONSTEXPR bool is_supported_floating_point(T) {
+  return (std::is_same<T, float>::value && FMT_USE_FLOAT) ||
+         (std::is_same<T, double>::value && FMT_USE_DOUBLE) ||
+         (std::is_same<T, long double>::value && FMT_USE_LONG_DOUBLE);
+}
+
+// Smallest of uint32_t, uint64_t, uint128_t that is large enough to
+// represent all values of T.
+template <typename T>
+using uint32_or_64_or_128_t = conditional_t<
+    std::numeric_limits<T>::digits <= 32, uint32_t,
+    conditional_t<std::numeric_limits<T>::digits <= 64, uint64_t, uint128_t>>;
+
+// Static data is placed in this class template for the header-only config.
+template <typename T = void> struct FMT_EXTERN_TEMPLATE_API basic_data {
+  static const uint64_t powers_of_10_64[];
+  static const uint32_t zero_or_powers_of_10_32[];
+  static const uint64_t zero_or_powers_of_10_64[];
+  static const uint64_t pow10_significands[];
+  static const int16_t pow10_exponents[];
+  static const char digits[];
+  static const char hex_digits[];
+  static const char foreground_color[];
+  static const char background_color[];
+  static const char reset_color[5];
+  static const wchar_t wreset_color[5];
+  static const char signs[];
+};
+
+FMT_EXTERN template struct basic_data<void>;
+
+// This is a struct rather than an alias to avoid shadowing warnings in gcc.
+struct data : basic_data<> {};
+
+#ifdef FMT_BUILTIN_CLZLL
+// Returns the number of decimal digits in n. Leading zeros are not counted
+// except for n == 0 in which case count_digits returns 1.
+inline int count_digits(uint64_t n) {
+  // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
+  // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
+  int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
+  return t - (n < data::zero_or_powers_of_10_64[t]) + 1;
+}
+#else
+// Fallback version of count_digits used when __builtin_clz is not available.
+inline int count_digits(uint64_t n) {
+  int count = 1;
+  for (;;) {
+    // Integer division is slow so do it for a group of four digits instead
+    // of for every digit. The idea comes from the talk by Alexandrescu
+    // "Three Optimization Tips for C++". See speed-test for a comparison.
+    if (n < 10) return count;
+    if (n < 100) return count + 1;
+    if (n < 1000) return count + 2;
+    if (n < 10000) return count + 3;
+    n /= 10000u;
+    count += 4;
+  }
+}
+#endif
+
+#if FMT_USE_INT128
+inline int count_digits(uint128_t n) {
+  int count = 1;
+  for (;;) {
+    // Integer division is slow so do it for a group of four digits instead
+    // of for every digit. The idea comes from the talk by Alexandrescu
+    // "Three Optimization Tips for C++". See speed-test for a comparison.
+    if (n < 10) return count;
+    if (n < 100) return count + 1;
+    if (n < 1000) return count + 2;
+    if (n < 10000) return count + 3;
+    n /= 10000U;
+    count += 4;
+  }
+}
+#endif
+
+// Counts the number of digits in n. BITS = log2(radix).
+template <unsigned BITS, typename UInt> inline int count_digits(UInt n) {
+  int num_digits = 0;
+  do {
+    ++num_digits;
+  } while ((n >>= BITS) != 0);
+  return num_digits;
+}
+
+template <> int count_digits<4>(internal::fallback_uintptr n);
+
+#if FMT_GCC_VERSION || FMT_CLANG_VERSION
+#  define FMT_ALWAYS_INLINE inline __attribute__((always_inline))
+#else
+#  define FMT_ALWAYS_INLINE
+#endif
+
+#ifdef FMT_BUILTIN_CLZ
+// Optional version of count_digits for better performance on 32-bit platforms.
+inline int count_digits(uint32_t n) {
+  int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
+  return t - (n < data::zero_or_powers_of_10_32[t]) + 1;
+}
+#endif
+
+template <typename Char> FMT_API std::string grouping_impl(locale_ref loc);
+template <typename Char> inline std::string grouping(locale_ref loc) {
+  return grouping_impl<char>(loc);
+}
+template <> inline std::string grouping<wchar_t>(locale_ref loc) {
+  return grouping_impl<wchar_t>(loc);
+}
+
+template <typename Char> FMT_API Char thousands_sep_impl(locale_ref loc);
+template <typename Char> inline Char thousands_sep(locale_ref loc) {
+  return Char(thousands_sep_impl<char>(loc));
+}
+template <> inline wchar_t thousands_sep(locale_ref loc) {
+  return thousands_sep_impl<wchar_t>(loc);
+}
+
+template <typename Char> FMT_API Char decimal_point_impl(locale_ref loc);
+template <typename Char> inline Char decimal_point(locale_ref loc) {
+  return Char(decimal_point_impl<char>(loc));
+}
+template <> inline wchar_t decimal_point(locale_ref loc) {
+  return decimal_point_impl<wchar_t>(loc);
+}
+
+// Formats a decimal unsigned integer value writing into buffer.
+// add_thousands_sep is called after writing each char to add a thousands
+// separator if necessary.
+template <typename UInt, typename Char, typename F>
+inline Char* format_decimal(Char* buffer, UInt value, int num_digits,
+                            F add_thousands_sep) {
+  FMT_ASSERT(num_digits >= 0, "invalid digit count");
+  buffer += num_digits;
+  Char* end = buffer;
+  while (value >= 100) {
+    // Integer division is slow so do it for a group of two digits instead
+    // of for every digit. The idea comes from the talk by Alexandrescu
+    // "Three Optimization Tips for C++". See speed-test for a comparison.
+    auto index = static_cast<unsigned>((value % 100) * 2);
+    value /= 100;
+    *--buffer = static_cast<Char>(data::digits[index + 1]);
+    add_thousands_sep(buffer);
+    *--buffer = static_cast<Char>(data::digits[index]);
+    add_thousands_sep(buffer);
+  }
+  if (value < 10) {
+    *--buffer = static_cast<Char>('0' + value);
+    return end;
+  }
+  auto index = static_cast<unsigned>(value * 2);
+  *--buffer = static_cast<Char>(data::digits[index + 1]);
+  add_thousands_sep(buffer);
+  *--buffer = static_cast<Char>(data::digits[index]);
+  return end;
+}
+
+template <typename Int> constexpr int digits10() FMT_NOEXCEPT {
+  return std::numeric_limits<Int>::digits10;
+}
+template <> constexpr int digits10<int128_t>() FMT_NOEXCEPT { return 38; }
+template <> constexpr int digits10<uint128_t>() FMT_NOEXCEPT { return 38; }
+
+template <typename Char, typename UInt, typename Iterator, typename F>
+inline Iterator format_decimal(Iterator out, UInt value, int num_digits,
+                               F add_thousands_sep) {
+  FMT_ASSERT(num_digits >= 0, "invalid digit count");
+  // Buffer should be large enough to hold all digits (<= digits10 + 1).
+  enum { max_size = digits10<UInt>() + 1 };
+  Char buffer[2 * max_size];
+  auto end = format_decimal(buffer, value, num_digits, add_thousands_sep);
+  return internal::copy_str<Char>(buffer, end, out);
+}
+
+template <typename Char, typename It, typename UInt>
+inline It format_decimal(It out, UInt value, int num_digits) {
+  return format_decimal<Char>(out, value, num_digits, [](Char*) {});
+}
+
+template <unsigned BASE_BITS, typename Char, typename UInt>
+inline Char* format_uint(Char* buffer, UInt value, int num_digits,
+                         bool upper = false) {
+  buffer += num_digits;
+  Char* end = buffer;
+  do {
+    const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
+    unsigned digit = (value & ((1 << BASE_BITS) - 1));
+    *--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
+                                                : digits[digit]);
+  } while ((value >>= BASE_BITS) != 0);
+  return end;
+}
+
+template <unsigned BASE_BITS, typename Char>
+Char* format_uint(Char* buffer, internal::fallback_uintptr n, int num_digits,
+                  bool = false) {
+  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
+  int start = (num_digits + char_digits - 1) / char_digits - 1;
+  if (int start_digits = num_digits % char_digits) {
+    unsigned value = n.value[start--];
+    buffer = format_uint<BASE_BITS>(buffer, value, start_digits);
+  }
+  for (; start >= 0; --start) {
+    unsigned value = n.value[start];
+    buffer += char_digits;
+    auto p = buffer;
+    for (int i = 0; i < char_digits; ++i) {
+      unsigned digit = (value & ((1 << BASE_BITS) - 1));
+      *--p = static_cast<Char>(data::hex_digits[digit]);
+      value >>= BASE_BITS;
+    }
+  }
+  return buffer;
+}
+
+template <unsigned BASE_BITS, typename Char, typename It, typename UInt>
+inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
+  // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
+  char buffer[num_bits<UInt>() / BASE_BITS + 1];
+  format_uint<BASE_BITS>(buffer, value, num_digits, upper);
+  return internal::copy_str<Char>(buffer, buffer + num_digits, out);
+}
+
+// A converter from UTF-8 to UTF-16.
+class utf8_to_utf16 {
+ private:
+  wmemory_buffer buffer_;
+
+ public:
+  FMT_API explicit utf8_to_utf16(string_view s);
+  operator wstring_view() const { return {&buffer_[0], size()}; }
+  size_t size() const { return buffer_.size() - 1; }
+  const wchar_t* c_str() const { return &buffer_[0]; }
+  std::wstring str() const { return {&buffer_[0], size()}; }
+};
+
+template <typename T = void> struct null {};
+
+// Workaround an array initialization issue in gcc 4.8.
+template <typename Char> struct fill_t {
+ private:
+  enum { max_size = 4 };
+  Char data_[max_size];
+  unsigned char size_;
+
+ public:
+  FMT_CONSTEXPR void operator=(basic_string_view<Char> s) {
+    auto size = s.size();
+    if (size > max_size) {
+      FMT_THROW(format_error("invalid fill"));
+      return;
+    }
+    for (size_t i = 0; i < size; ++i) data_[i] = s[i];
+    size_ = static_cast<unsigned char>(size);
+  }
+
+  size_t size() const { return size_; }
+  const Char* data() const { return data_; }
+
+  FMT_CONSTEXPR Char& operator[](size_t index) { return data_[index]; }
+  FMT_CONSTEXPR const Char& operator[](size_t index) const {
+    return data_[index];
+  }
+
+  static FMT_CONSTEXPR fill_t<Char> make() {
+    auto fill = fill_t<Char>();
+    fill[0] = Char(' ');
+    fill.size_ = 1;
+    return fill;
+  }
+};
+}  // namespace internal
+
+// We cannot use enum classes as bit fields because of a gcc bug
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414.
+namespace align {
+enum type { none, left, right, center, numeric };
+}
+using align_t = align::type;
+
+namespace sign {
+enum type { none, minus, plus, space };
+}
+using sign_t = sign::type;
+
+// Format specifiers for built-in and string types.
+template <typename Char> struct basic_format_specs {
+  int width;
+  int precision;
+  char type;
+  align_t align : 4;
+  sign_t sign : 3;
+  bool alt : 1;  // Alternate form ('#').
+  internal::fill_t<Char> fill;
+
+  constexpr basic_format_specs()
+      : width(0),
+        precision(-1),
+        type(0),
+        align(align::none),
+        sign(sign::none),
+        alt(false),
+        fill(internal::fill_t<Char>::make()) {}
+};
+
+using format_specs = basic_format_specs<char>;
+
+namespace internal {
+
+// A floating-point presentation format.
+enum class float_format : unsigned char {
+  general,  // General: exponent notation or fixed point based on magnitude.
+  exp,      // Exponent notation with the default precision of 6, e.g. 1.2e-3.
+  fixed,    // Fixed point with the default precision of 6, e.g. 0.0012.
+  hex
+};
+
+struct float_specs {
+  int precision;
+  float_format format : 8;
+  sign_t sign : 8;
+  bool upper : 1;
+  bool locale : 1;
+  bool percent : 1;
+  bool binary32 : 1;
+  bool use_grisu : 1;
+  bool showpoint : 1;
+};
+
+// Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
+template <typename Char, typename It> It write_exponent(int exp, It it) {
+  FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
+  if (exp < 0) {
+    *it++ = static_cast<Char>('-');
+    exp = -exp;
+  } else {
+    *it++ = static_cast<Char>('+');
+  }
+  if (exp >= 100) {
+    const char* top = data::digits + (exp / 100) * 2;
+    if (exp >= 1000) *it++ = static_cast<Char>(top[0]);
+    *it++ = static_cast<Char>(top[1]);
+    exp %= 100;
+  }
+  const char* d = data::digits + exp * 2;
+  *it++ = static_cast<Char>(d[0]);
+  *it++ = static_cast<Char>(d[1]);
+  return it;
+}
+
+template <typename Char> class float_writer {
+ private:
+  // The number is given as v = digits_ * pow(10, exp_).
+  const char* digits_;
+  int num_digits_;
+  int exp_;
+  size_t size_;
+  float_specs specs_;
+  Char decimal_point_;
+
+  template <typename It> It prettify(It it) const {
+    // pow(10, full_exp - 1) <= v <= pow(10, full_exp).
+    int full_exp = num_digits_ + exp_;
+    if (specs_.format == float_format::exp) {
+      // Insert a decimal point after the first digit and add an exponent.
+      *it++ = static_cast<Char>(*digits_);
+      int num_zeros = specs_.precision - num_digits_;
+      if (num_digits_ > 1 || specs_.showpoint) *it++ = decimal_point_;
+      it = copy_str<Char>(digits_ + 1, digits_ + num_digits_, it);
+      if (num_zeros > 0 && specs_.showpoint)
+        it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
+      *it++ = static_cast<Char>(specs_.upper ? 'E' : 'e');
+      return write_exponent<Char>(full_exp - 1, it);
+    }
+    if (num_digits_ <= full_exp) {
+      // 1234e7 -> 12340000000[.0+]
+      it = copy_str<Char>(digits_, digits_ + num_digits_, it);
+      it = std::fill_n(it, full_exp - num_digits_, static_cast<Char>('0'));
+      if (specs_.showpoint || specs_.precision < 0) {
+        *it++ = decimal_point_;
+        int num_zeros = specs_.precision - full_exp;
+        if (num_zeros <= 0) {
+          if (specs_.format != float_format::fixed)
+            *it++ = static_cast<Char>('0');
+          return it;
+        }
+#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
+        if (num_zeros > 1000)
+          throw std::runtime_error("fuzz mode - avoiding excessive cpu use");
+#endif
+        it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
+      }
+    } else if (full_exp > 0) {
+      // 1234e-2 -> 12.34[0+]
+      it = copy_str<Char>(digits_, digits_ + full_exp, it);
+      if (!specs_.showpoint) {
+        // Remove trailing zeros.
+        int num_digits = num_digits_;
+        while (num_digits > full_exp && digits_[num_digits - 1] == '0')
+          --num_digits;
+        if (num_digits != full_exp) *it++ = decimal_point_;
+        return copy_str<Char>(digits_ + full_exp, digits_ + num_digits, it);
+      }
+      *it++ = decimal_point_;
+      it = copy_str<Char>(digits_ + full_exp, digits_ + num_digits_, it);
+      if (specs_.precision > num_digits_) {
+        // Add trailing zeros.
+        int num_zeros = specs_.precision - num_digits_;
+        it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
+      }
+    } else {
+      // 1234e-6 -> 0.001234
+      *it++ = static_cast<Char>('0');
+      int num_zeros = -full_exp;
+      int num_digits = num_digits_;
+      if (num_digits == 0 && specs_.precision >= 0 &&
+          specs_.precision < num_zeros) {
+        num_zeros = specs_.precision;
+      }
+      // Remove trailing zeros.
+      if (!specs_.showpoint)
+        while (num_digits > 0 && digits_[num_digits - 1] == '0') --num_digits;
+      if (num_zeros != 0 || num_digits != 0 || specs_.showpoint) {
+        *it++ = decimal_point_;
+        it = std::fill_n(it, num_zeros, static_cast<Char>('0'));
+        it = copy_str<Char>(digits_, digits_ + num_digits, it);
+      }
+    }
+    return it;
+  }
+
+ public:
+  float_writer(const char* digits, int num_digits, int exp, float_specs specs,
+               Char decimal_point)
+      : digits_(digits),
+        num_digits_(num_digits),
+        exp_(exp),
+        specs_(specs),
+        decimal_point_(decimal_point) {
+    int full_exp = num_digits + exp - 1;
+    int precision = specs.precision > 0 ? specs.precision : 16;
+    if (specs_.format == float_format::general &&
+        !(full_exp >= -4 && full_exp < precision)) {
+      specs_.format = float_format::exp;
+    }
+    size_ = prettify(counting_iterator()).count();
+    size_ += specs.sign ? 1 : 0;
+  }
+
+  size_t size() const { return size_; }
+  size_t width() const { return size(); }
+
+  template <typename It> void operator()(It&& it) {
+    if (specs_.sign) *it++ = static_cast<Char>(data::signs[specs_.sign]);
+    it = prettify(it);
+  }
+};
+
+template <typename T>
+int format_float(T value, int precision, float_specs specs, buffer<char>& buf);
+
+// Formats a floating-point number with snprintf.
+template <typename T>
+int snprintf_float(T value, int precision, float_specs specs,
+                   buffer<char>& buf);
+
+template <typename T> T promote_float(T value) { return value; }
+inline double promote_float(float value) { return static_cast<double>(value); }
+
+template <typename Handler>
+FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) {
+  switch (spec) {
+  case 0:
+  case 'd':
+    handler.on_dec();
+    break;
+  case 'x':
+  case 'X':
+    handler.on_hex();
+    break;
+  case 'b':
+  case 'B':
+    handler.on_bin();
+    break;
+  case 'o':
+    handler.on_oct();
+    break;
+  case 'n':
+  case 'L':
+    handler.on_num();
+    break;
+  default:
+    handler.on_error();
+  }
+}
+
+template <typename ErrorHandler = error_handler, typename Char>
+FMT_CONSTEXPR float_specs parse_float_type_spec(
+    const basic_format_specs<Char>& specs, ErrorHandler&& eh = {}) {
+  auto result = float_specs();
+  result.showpoint = specs.alt;
+  switch (specs.type) {
+  case 0:
+    result.format = float_format::general;
+    result.showpoint |= specs.precision > 0;
+    break;
+  case 'G':
+    result.upper = true;
+    FMT_FALLTHROUGH;
+  case 'g':
+    result.format = float_format::general;
+    break;
+  case 'E':
+    result.upper = true;
+    FMT_FALLTHROUGH;
+  case 'e':
+    result.format = float_format::exp;
+    result.showpoint |= specs.precision != 0;
+    break;
+  case 'F':
+    result.upper = true;
+    FMT_FALLTHROUGH;
+  case 'f':
+    result.format = float_format::fixed;
+    result.showpoint |= specs.precision != 0;
+    break;
+#if FMT_DEPRECATED_PERCENT
+  case '%':
+    result.format = float_format::fixed;
+    result.percent = true;
+    break;
+#endif
+  case 'A':
+    result.upper = true;
+    FMT_FALLTHROUGH;
+  case 'a':
+    result.format = float_format::hex;
+    break;
+  case 'n':
+    result.locale = true;
+    break;
+  default:
+    eh.on_error("invalid type specifier");
+    break;
+  }
+  return result;
+}
+
+template <typename Char, typename Handler>
+FMT_CONSTEXPR void handle_char_specs(const basic_format_specs<Char>* specs,
+                                     Handler&& handler) {
+  if (!specs) return handler.on_char();
+  if (specs->type && specs->type != 'c') return handler.on_int();
+  if (specs->align == align::numeric || specs->sign != sign::none || specs->alt)
+    handler.on_error("invalid format specifier for char");
+  handler.on_char();
+}
+
+template <typename Char, typename Handler>
+FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler&& handler) {
+  if (spec == 0 || spec == 's')
+    handler.on_string();
+  else if (spec == 'p')
+    handler.on_pointer();
+  else
+    handler.on_error("invalid type specifier");
+}
+
+template <typename Char, typename ErrorHandler>
+FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler&& eh) {
+  if (spec != 0 && spec != 's') eh.on_error("invalid type specifier");
+}
+
+template <typename Char, typename ErrorHandler>
+FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler&& eh) {
+  if (spec != 0 && spec != 'p') eh.on_error("invalid type specifier");
+}
+
+template <typename ErrorHandler> class int_type_checker : private ErrorHandler {
+ public:
+  FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}
+
+  FMT_CONSTEXPR void on_dec() {}
+  FMT_CONSTEXPR void on_hex() {}
+  FMT_CONSTEXPR void on_bin() {}
+  FMT_CONSTEXPR void on_oct() {}
+  FMT_CONSTEXPR void on_num() {}
+
+  FMT_CONSTEXPR void on_error() {
+    ErrorHandler::on_error("invalid type specifier");
+  }
+};
+
+template <typename ErrorHandler>
+class char_specs_checker : public ErrorHandler {
+ private:
+  char type_;
+
+ public:
+  FMT_CONSTEXPR char_specs_checker(char type, ErrorHandler eh)
+      : ErrorHandler(eh), type_(type) {}
+
+  FMT_CONSTEXPR void on_int() {
+    handle_int_type_spec(type_, int_type_checker<ErrorHandler>(*this));
+  }
+  FMT_CONSTEXPR void on_char() {}
+};
+
+template <typename ErrorHandler>
+class cstring_type_checker : public ErrorHandler {
+ public:
+  FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh)
+      : ErrorHandler(eh) {}
+
+  FMT_CONSTEXPR void on_string() {}
+  FMT_CONSTEXPR void on_pointer() {}
+};
+
+template <typename Context>
+void arg_map<Context>::init(const basic_format_args<Context>& args) {
+  if (map_) return;
+  map_ = new entry[internal::to_unsigned(args.max_size())];
+  if (args.is_packed()) {
+    for (int i = 0;; ++i) {
+      internal::type arg_type = args.type(i);
+      if (arg_type == internal::type::none_type) return;
+      if (arg_type == internal::type::named_arg_type)
+        push_back(args.values_[i]);
+    }
+  }
+  for (int i = 0, n = args.max_size(); i < n; ++i) {
+    auto type = args.args_[i].type_;
+    if (type == internal::type::named_arg_type) push_back(args.args_[i].value_);
+  }
+}
+
+template <typename Char> struct nonfinite_writer {
+  sign_t sign;
+  const char* str;
+  static constexpr size_t str_size = 3;
+
+  size_t size() const { return str_size + (sign ? 1 : 0); }
+  size_t width() const { return size(); }
+
+  template <typename It> void operator()(It&& it) const {
+    if (sign) *it++ = static_cast<Char>(data::signs[sign]);
+    it = copy_str<Char>(str, str + str_size, it);
+  }
+};
+
+template <typename OutputIt, typename Char>
+FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t<Char>& fill) {
+  auto fill_size = fill.size();
+  if (fill_size == 1) return std::fill_n(it, n, fill[0]);
+  for (size_t i = 0; i < n; ++i) it = std::copy_n(fill.data(), fill_size, it);
+  return it;
+}
+
+// This template provides operations for formatting and writing data into a
+// character range.
+template <typename Range> class basic_writer {
+ public:
+  using char_type = typename Range::value_type;
+  using iterator = typename Range::iterator;
+  using format_specs = basic_format_specs<char_type>;
+
+ private:
+  iterator out_;  // Output iterator.
+  locale_ref locale_;
+
+  // Attempts to reserve space for n extra characters in the output range.
+  // Returns a pointer to the reserved range or a reference to out_.
+  auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) {
+    return internal::reserve(out_, n);
+  }
+
+  template <typename F> struct padded_int_writer {
+    size_t size_;
+    string_view prefix;
+    char_type fill;
+    std::size_t padding;
+    F f;
+
+    size_t size() const { return size_; }
+    size_t width() const { return size_; }
+
+    template <typename It> void operator()(It&& it) const {
+      if (prefix.size() != 0)
+        it = copy_str<char_type>(prefix.begin(), prefix.end(), it);
+      it = std::fill_n(it, padding, fill);
+      f(it);
+    }
+  };
+
+  // Writes an integer in the format
+  //   <left-padding><prefix><numeric-padding><digits><right-padding>
+  // where <digits> are written by f(it).
+  template <typename F>
+  void write_int(int num_digits, string_view prefix, format_specs specs, F f) {
+    std::size_t size = prefix.size() + to_unsigned(num_digits);
+    char_type fill = specs.fill[0];
+    std::size_t padding = 0;
+    if (specs.align == align::numeric) {
+      auto unsiged_width = to_unsigned(specs.width);
+      if (unsiged_width > size) {
+        padding = unsiged_width - size;
+        size = unsiged_width;
+      }
+    } else if (specs.precision > num_digits) {
+      size = prefix.size() + to_unsigned(specs.precision);
+      padding = to_unsigned(specs.precision - num_digits);
+      fill = static_cast<char_type>('0');
+    }
+    if (specs.align == align::none) specs.align = align::right;
+    write_padded(specs, padded_int_writer<F>{size, prefix, fill, padding, f});
+  }
+
+  // Writes a decimal integer.
+  template <typename Int> void write_decimal(Int value) {
+    auto abs_value = static_cast<uint32_or_64_or_128_t<Int>>(value);
+    bool negative = is_negative(value);
+    // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
+    if (negative) abs_value = ~abs_value + 1;
+    int num_digits = count_digits(abs_value);
+    auto&& it = reserve((negative ? 1 : 0) + static_cast<size_t>(num_digits));
+    if (negative) *it++ = static_cast<char_type>('-');
+    it = format_decimal<char_type>(it, abs_value, num_digits);
+  }
+
+  // The handle_int_type_spec handler that writes an integer.
+  template <typename Int, typename Specs> struct int_writer {
+    using unsigned_type = uint32_or_64_or_128_t<Int>;
+
+    basic_writer<Range>& writer;
+    const Specs& specs;
+    unsigned_type abs_value;
+    char prefix[4];
+    unsigned prefix_size;
+
+    string_view get_prefix() const { return string_view(prefix, prefix_size); }
+
+    int_writer(basic_writer<Range>& w, Int value, const Specs& s)
+        : writer(w),
+          specs(s),
+          abs_value(static_cast<unsigned_type>(value)),
+          prefix_size(0) {
+      if (is_negative(value)) {
+        prefix[0] = '-';
+        ++prefix_size;
+        abs_value = 0 - abs_value;
+      } else if (specs.sign != sign::none && specs.sign != sign::minus) {
+        prefix[0] = specs.sign == sign::plus ? '+' : ' ';
+        ++prefix_size;
+      }
+    }
+
+    struct dec_writer {
+      unsigned_type abs_value;
+      int num_digits;
+
+      template <typename It> void operator()(It&& it) const {
+        it = internal::format_decimal<char_type>(it, abs_value, num_digits);
+      }
+    };
+
+    void on_dec() {
+      int num_digits = count_digits(abs_value);
+      writer.write_int(num_digits, get_prefix(), specs,
+                       dec_writer{abs_value, num_digits});
+    }
+
+    struct hex_writer {
+      int_writer& self;
+      int num_digits;
+
+      template <typename It> void operator()(It&& it) const {
+        it = format_uint<4, char_type>(it, self.abs_value, num_digits,
+                                       self.specs.type != 'x');
+      }
+    };
+
+    void on_hex() {
+      if (specs.alt) {
+        prefix[prefix_size++] = '0';
+        prefix[prefix_size++] = specs.type;
+      }
+      int num_digits = count_digits<4>(abs_value);
+      writer.write_int(num_digits, get_prefix(), specs,
+                       hex_writer{*this, num_digits});
+    }
+
+    template <int BITS> struct bin_writer {
+      unsigned_type abs_value;
+      int num_digits;
+
+      template <typename It> void operator()(It&& it) const {
+        it = format_uint<BITS, char_type>(it, abs_value, num_digits);
+      }
+    };
+
+    void on_bin() {
+      if (specs.alt) {
+        prefix[prefix_size++] = '0';
+        prefix[prefix_size++] = static_cast<char>(specs.type);
+      }
+      int num_digits = count_digits<1>(abs_value);
+      writer.write_int(num_digits, get_prefix(), specs,
+                       bin_writer<1>{abs_value, num_digits});
+    }
+
+    void on_oct() {
+      int num_digits = count_digits<3>(abs_value);
+      if (specs.alt && specs.precision <= num_digits && abs_value != 0) {
+        // Octal prefix '0' is counted as a digit, so only add it if precision
+        // is not greater than the number of digits.
+        prefix[prefix_size++] = '0';
+      }
+      writer.write_int(num_digits, get_prefix(), specs,
+                       bin_writer<3>{abs_value, num_digits});
+    }
+
+    enum { sep_size = 1 };
+
+    struct num_writer {
+      unsigned_type abs_value;
+      int size;
+      const std::string& groups;
+      char_type sep;
+
+      template <typename It> void operator()(It&& it) const {
+        basic_string_view<char_type> s(&sep, sep_size);
+        // Index of a decimal digit with the least significant digit having
+        // index 0.
+        int digit_index = 0;
+        std::string::const_iterator group = groups.cbegin();
+        it = format_decimal<char_type>(
+            it, abs_value, size,
+            [this, s, &group, &digit_index](char_type*& buffer) {
+              if (*group <= 0 || ++digit_index % *group != 0 ||
+                  *group == max_value<char>())
+                return;
+              if (group + 1 != groups.cend()) {
+                digit_index = 0;
+                ++group;
+              }
+              buffer -= s.size();
+              std::uninitialized_copy(s.data(), s.data() + s.size(),
+                                      make_checked(buffer, s.size()));
+            });
+      }
+    };
+
+    void on_num() {
+      std::string groups = grouping<char_type>(writer.locale_);
+      if (groups.empty()) return on_dec();
+      auto sep = thousands_sep<char_type>(writer.locale_);
+      if (!sep) return on_dec();
+      int num_digits = count_digits(abs_value);
+      int size = num_digits;
+      std::string::const_iterator group = groups.cbegin();
+      while (group != groups.cend() && num_digits > *group && *group > 0 &&
+             *group != max_value<char>()) {
+        size += sep_size;
+        num_digits -= *group;
+        ++group;
+      }
+      if (group == groups.cend())
+        size += sep_size * ((num_digits - 1) / groups.back());
+      writer.write_int(size, get_prefix(), specs,
+                       num_writer{abs_value, size, groups, sep});
+    }
+
+    FMT_NORETURN void on_error() {
+      FMT_THROW(format_error("invalid type specifier"));
+    }
+  };
+
+  template <typename Char> struct str_writer {
+    const Char* s;
+    size_t size_;
+
+    size_t size() const { return size_; }
+    size_t width() const {
+      return count_code_points(basic_string_view<Char>(s, size_));
+    }
+
+    template <typename It> void operator()(It&& it) const {
+      it = copy_str<char_type>(s, s + size_, it);
+    }
+  };
+
+  struct bytes_writer {
+    string_view bytes;
+
+    size_t size() const { return bytes.size(); }
+    size_t width() const { return bytes.size(); }
+
+    template <typename It> void operator()(It&& it) const {
+      const char* data = bytes.data();
+      it = copy_str<char>(data, data + size(), it);
+    }
+  };
+
+  template <typename UIntPtr> struct pointer_writer {
+    UIntPtr value;
+    int num_digits;
+
+    size_t size() const { return to_unsigned(num_digits) + 2; }
+    size_t width() const { return size(); }
+
+    template <typename It> void operator()(It&& it) const {
+      *it++ = static_cast<char_type>('0');
+      *it++ = static_cast<char_type>('x');
+      it = format_uint<4, char_type>(it, value, num_digits);
+    }
+  };
+
+ public:
+  explicit basic_writer(Range out, locale_ref loc = locale_ref())
+      : out_(out.begin()), locale_(loc) {}
+
+  iterator out() const { return out_; }
+
+  // Writes a value in the format
+  //   <left-padding><value><right-padding>
+  // where <value> is written by f(it).
+  template <typename F> void write_padded(const format_specs& specs, F&& f) {
+    // User-perceived width (in code points).
+    unsigned width = to_unsigned(specs.width);
+    size_t size = f.size();  // The number of code units.
+    size_t num_code_points = width != 0 ? f.width() : size;
+    if (width <= num_code_points) return f(reserve(size));
+    size_t padding = width - num_code_points;
+    size_t fill_size = specs.fill.size();
+    auto&& it = reserve(size + padding * fill_size);
+    if (specs.align == align::right) {
+      it = fill(it, padding, specs.fill);
+      f(it);
+    } else if (specs.align == align::center) {
+      std::size_t left_padding = padding / 2;
+      it = fill(it, left_padding, specs.fill);
+      f(it);
+      it = fill(it, padding - left_padding, specs.fill);
+    } else {
+      f(it);
+      it = fill(it, padding, specs.fill);
+    }
+  }
+
+  void write(int value) { write_decimal(value); }
+  void write(long value) { write_decimal(value); }
+  void write(long long value) { write_decimal(value); }
+
+  void write(unsigned value) { write_decimal(value); }
+  void write(unsigned long value) { write_decimal(value); }
+  void write(unsigned long long value) { write_decimal(value); }
+
+#if FMT_USE_INT128
+  void write(int128_t value) { write_decimal(value); }
+  void write(uint128_t value) { write_decimal(value); }
+#endif
+
+  template <typename T, typename Spec>
+  void write_int(T value, const Spec& spec) {
+    handle_int_type_spec(spec.type, int_writer<T, Spec>(*this, value, spec));
+  }
+
+  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+  void write(T value, format_specs specs = {}) {
+    if (const_check(!is_supported_floating_point(value))) {
+      return;
+    }
+    float_specs fspecs = parse_float_type_spec(specs);
+    fspecs.sign = specs.sign;
+    if (std::signbit(value)) {  // value < 0 is false for NaN so use signbit.
+      fspecs.sign = sign::minus;
+      value = -value;
+    } else if (fspecs.sign == sign::minus) {
+      fspecs.sign = sign::none;
+    }
+
+    if (!std::isfinite(value)) {
+      auto str = std::isinf(value) ? (fspecs.upper ? "INF" : "inf")
+                                   : (fspecs.upper ? "NAN" : "nan");
+      return write_padded(specs, nonfinite_writer<char_type>{fspecs.sign, str});
+    }
+
+    if (specs.align == align::none) {
+      specs.align = align::right;
+    } else if (specs.align == align::numeric) {
+      if (fspecs.sign) {
+        auto&& it = reserve(1);
+        *it++ = static_cast<char_type>(data::signs[fspecs.sign]);
+        fspecs.sign = sign::none;
+        if (specs.width != 0) --specs.width;
+      }
+      specs.align = align::right;
+    }
+
+    memory_buffer buffer;
+    if (fspecs.format == float_format::hex) {
+      if (fspecs.sign) buffer.push_back(data::signs[fspecs.sign]);
+      snprintf_float(promote_float(value), specs.precision, fspecs, buffer);
+      write_padded(specs, str_writer<char>{buffer.data(), buffer.size()});
+      return;
+    }
+    int precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;
+    if (fspecs.format == float_format::exp) {
+      if (precision == max_value<int>())
+        FMT_THROW(format_error("number is too big"));
+      else
+        ++precision;
+    }
+    if (const_check(std::is_same<T, float>())) fspecs.binary32 = true;
+    fspecs.use_grisu = use_grisu<T>();
+    if (const_check(FMT_DEPRECATED_PERCENT) && fspecs.percent) value *= 100;
+    int exp = format_float(promote_float(value), precision, fspecs, buffer);
+    if (const_check(FMT_DEPRECATED_PERCENT) && fspecs.percent) {
+      buffer.push_back('%');
+      --exp;  // Adjust decimal place position.
+    }
+    fspecs.precision = precision;
+    char_type point = fspecs.locale ? decimal_point<char_type>(locale_)
+                                    : static_cast<char_type>('.');
+    write_padded(specs, float_writer<char_type>(buffer.data(),
+                                                static_cast<int>(buffer.size()),
+                                                exp, fspecs, point));
+  }
+
+  void write(char value) {
+    auto&& it = reserve(1);
+    *it++ = value;
+  }
+
+  template <typename Char, FMT_ENABLE_IF(std::is_same<Char, char_type>::value)>
+  void write(Char value) {
+    auto&& it = reserve(1);
+    *it++ = value;
+  }
+
+  void write(string_view value) {
+    auto&& it = reserve(value.size());
+    it = copy_str<char_type>(value.begin(), value.end(), it);
+  }
+  void write(wstring_view value) {
+    static_assert(std::is_same<char_type, wchar_t>::value, "");
+    auto&& it = reserve(value.size());
+    it = std::copy(value.begin(), value.end(), it);
+  }
+
+  template <typename Char>
+  void write(const Char* s, std::size_t size, const format_specs& specs) {
+    write_padded(specs, str_writer<Char>{s, size});
+  }
+
+  template <typename Char>
+  void write(basic_string_view<Char> s, const format_specs& specs = {}) {
+    const Char* data = s.data();
+    std::size_t size = s.size();
+    if (specs.precision >= 0 && to_unsigned(specs.precision) < size)
+      size = code_point_index(s, to_unsigned(specs.precision));
+    write(data, size, specs);
+  }
+
+  void write_bytes(string_view bytes, const format_specs& specs) {
+    write_padded(specs, bytes_writer{bytes});
+  }
+
+  template <typename UIntPtr>
+  void write_pointer(UIntPtr value, const format_specs* specs) {
+    int num_digits = count_digits<4>(value);
+    auto pw = pointer_writer<UIntPtr>{value, num_digits};
+    if (!specs) return pw(reserve(to_unsigned(num_digits) + 2));
+    format_specs specs_copy = *specs;
+    if (specs_copy.align == align::none) specs_copy.align = align::right;
+    write_padded(specs_copy, pw);
+  }
+};
+
+using writer = basic_writer<buffer_range<char>>;
+
+template <typename T> struct is_integral : std::is_integral<T> {};
+template <> struct is_integral<int128_t> : std::true_type {};
+template <> struct is_integral<uint128_t> : std::true_type {};
+
+template <typename Range, typename ErrorHandler = internal::error_handler>
+class arg_formatter_base {
+ public:
+  using char_type = typename Range::value_type;
+  using iterator = typename Range::iterator;
+  using format_specs = basic_format_specs<char_type>;
+
+ private:
+  using writer_type = basic_writer<Range>;
+  writer_type writer_;
+  format_specs* specs_;
+
+  struct char_writer {
+    char_type value;
+
+    size_t size() const { return 1; }
+    size_t width() const { return 1; }
+
+    template <typename It> void operator()(It&& it) const { *it++ = value; }
+  };
+
+  void write_char(char_type value) {
+    if (specs_)
+      writer_.write_padded(*specs_, char_writer{value});
+    else
+      writer_.write(value);
+  }
+
+  void write_pointer(const void* p) {
+    writer_.write_pointer(internal::to_uintptr(p), specs_);
+  }
+
+ protected:
+  writer_type& writer() { return writer_; }
+  FMT_DEPRECATED format_specs* spec() { return specs_; }
+  format_specs* specs() { return specs_; }
+  iterator out() { return writer_.out(); }
+
+  void write(bool value) {
+    string_view sv(value ? "true" : "false");
+    specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
+  }
+
+  void write(const char_type* value) {
+    if (!value) {
+      FMT_THROW(format_error("string pointer is null"));
+    } else {
+      auto length = std::char_traits<char_type>::length(value);
+      basic_string_view<char_type> sv(value, length);
+      specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
+    }
+  }
+
+ public:
+  arg_formatter_base(Range r, format_specs* s, locale_ref loc)
+      : writer_(r, loc), specs_(s) {}
+
+  iterator operator()(monostate) {
+    FMT_ASSERT(false, "invalid argument type");
+    return out();
+  }
+
+  template <typename T, FMT_ENABLE_IF(is_integral<T>::value)>
+  iterator operator()(T value) {
+    if (specs_)
+      writer_.write_int(value, *specs_);
+    else
+      writer_.write(value);
+    return out();
+  }
+
+  iterator operator()(char_type value) {
+    internal::handle_char_specs(
+        specs_, char_spec_handler(*this, static_cast<char_type>(value)));
+    return out();
+  }
+
+  iterator operator()(bool value) {
+    if (specs_ && specs_->type) return (*this)(value ? 1 : 0);
+    write(value != 0);
+    return out();
+  }
+
+  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+  iterator operator()(T value) {
+    if (const_check(is_supported_floating_point(value)))
+      writer_.write(value, specs_ ? *specs_ : format_specs());
+    else
+      FMT_ASSERT(false, "unsupported float argument type");
+    return out();
+  }
+
+  struct char_spec_handler : ErrorHandler {
+    arg_formatter_base& formatter;
+    char_type value;
+
+    char_spec_handler(arg_formatter_base& f, char_type val)
+        : formatter(f), value(val) {}
+
+    void on_int() {
+      if (formatter.specs_)
+        formatter.writer_.write_int(value, *formatter.specs_);
+      else
+        formatter.writer_.write(value);
+    }
+    void on_char() { formatter.write_char(value); }
+  };
+
+  struct cstring_spec_handler : internal::error_handler {
+    arg_formatter_base& formatter;
+    const char_type* value;
+
+    cstring_spec_handler(arg_formatter_base& f, const char_type* val)
+        : formatter(f), value(val) {}
+
+    void on_string() { formatter.write(value); }
+    void on_pointer() { formatter.write_pointer(value); }
+  };
+
+  iterator operator()(const char_type* value) {
+    if (!specs_) return write(value), out();
+    internal::handle_cstring_type_spec(specs_->type,
+                                       cstring_spec_handler(*this, value));
+    return out();
+  }
+
+  iterator operator()(basic_string_view<char_type> value) {
+    if (specs_) {
+      internal::check_string_type_spec(specs_->type, internal::error_handler());
+      writer_.write(value, *specs_);
+    } else {
+      writer_.write(value);
+    }
+    return out();
+  }
+
+  iterator operator()(const void* value) {
+    if (specs_)
+      check_pointer_type_spec(specs_->type, internal::error_handler());
+    write_pointer(value);
+    return out();
+  }
+};
+
+template <typename Char> FMT_CONSTEXPR bool is_name_start(Char c) {
+  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
+}
+
+// Parses the range [begin, end) as an unsigned integer. This function assumes
+// that the range is non-empty and the first character is a digit.
+template <typename Char, typename ErrorHandler>
+FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end,
+                                        ErrorHandler&& eh) {
+  FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
+  unsigned value = 0;
+  // Convert to unsigned to prevent a warning.
+  constexpr unsigned max_int = max_value<int>();
+  unsigned big = max_int / 10;
+  do {
+    // Check for overflow.
+    if (value > big) {
+      value = max_int + 1;
+      break;
+    }
+    value = value * 10 + unsigned(*begin - '0');
+    ++begin;
+  } while (begin != end && '0' <= *begin && *begin <= '9');
+  if (value > max_int) eh.on_error("number is too big");
+  return static_cast<int>(value);
+}
+
+template <typename Context> class custom_formatter {
+ private:
+  using char_type = typename Context::char_type;
+
+  basic_format_parse_context<char_type>& parse_ctx_;
+  Context& ctx_;
+
+ public:
+  explicit custom_formatter(basic_format_parse_context<char_type>& parse_ctx,
+                            Context& ctx)
+      : parse_ctx_(parse_ctx), ctx_(ctx) {}
+
+  bool operator()(typename basic_format_arg<Context>::handle h) const {
+    h.format(parse_ctx_, ctx_);
+    return true;
+  }
+
+  template <typename T> bool operator()(T) const { return false; }
+};
+
+template <typename T>
+using is_integer =
+    bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value &&
+                  !std::is_same<T, char>::value &&
+                  !std::is_same<T, wchar_t>::value>;
+
+template <typename ErrorHandler> class width_checker {
+ public:
+  explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {}
+
+  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
+  FMT_CONSTEXPR unsigned long long operator()(T value) {
+    if (is_negative(value)) handler_.on_error("negative width");
+    return static_cast<unsigned long long>(value);
+  }
+
+  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
+  FMT_CONSTEXPR unsigned long long operator()(T) {
+    handler_.on_error("width is not integer");
+    return 0;
+  }
+
+ private:
+  ErrorHandler& handler_;
+};
+
+template <typename ErrorHandler> class precision_checker {
+ public:
+  explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {}
+
+  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
+  FMT_CONSTEXPR unsigned long long operator()(T value) {
+    if (is_negative(value)) handler_.on_error("negative precision");
+    return static_cast<unsigned long long>(value);
+  }
+
+  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
+  FMT_CONSTEXPR unsigned long long operator()(T) {
+    handler_.on_error("precision is not integer");
+    return 0;
+  }
+
+ private:
+  ErrorHandler& handler_;
+};
+
+// A format specifier handler that sets fields in basic_format_specs.
+template <typename Char> class specs_setter {
+ public:
+  explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char>& specs)
+      : specs_(specs) {}
+
+  FMT_CONSTEXPR specs_setter(const specs_setter& other)
+      : specs_(other.specs_) {}
+
+  FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; }
+  FMT_CONSTEXPR void on_fill(basic_string_view<Char> fill) {
+    specs_.fill = fill;
+  }
+  FMT_CONSTEXPR void on_plus() { specs_.sign = sign::plus; }
+  FMT_CONSTEXPR void on_minus() { specs_.sign = sign::minus; }
+  FMT_CONSTEXPR void on_space() { specs_.sign = sign::space; }
+  FMT_CONSTEXPR void on_hash() { specs_.alt = true; }
+
+  FMT_CONSTEXPR void on_zero() {
+    specs_.align = align::numeric;
+    specs_.fill[0] = Char('0');
+  }
+
+  FMT_CONSTEXPR void on_width(int width) { specs_.width = width; }
+  FMT_CONSTEXPR void on_precision(int precision) {
+    specs_.precision = precision;
+  }
+  FMT_CONSTEXPR void end_precision() {}
+
+  FMT_CONSTEXPR void on_type(Char type) {
+    specs_.type = static_cast<char>(type);
+  }
+
+ protected:
+  basic_format_specs<Char>& specs_;
+};
+
+template <typename ErrorHandler> class numeric_specs_checker {
+ public:
+  FMT_CONSTEXPR numeric_specs_checker(ErrorHandler& eh, internal::type arg_type)
+      : error_handler_(eh), arg_type_(arg_type) {}
+
+  FMT_CONSTEXPR void require_numeric_argument() {
+    if (!is_arithmetic_type(arg_type_))
+      error_handler_.on_error("format specifier requires numeric argument");
+  }
+
+  FMT_CONSTEXPR void check_sign() {
+    require_numeric_argument();
+    if (is_integral_type(arg_type_) && arg_type_ != type::int_type &&
+        arg_type_ != type::long_long_type && arg_type_ != type::char_type) {
+      error_handler_.on_error("format specifier requires signed argument");
+    }
+  }
+
+  FMT_CONSTEXPR void check_precision() {
+    if (is_integral_type(arg_type_) || arg_type_ == type::pointer_type)
+      error_handler_.on_error("precision not allowed for this argument type");
+  }
+
+ private:
+  ErrorHandler& error_handler_;
+  internal::type arg_type_;
+};
+
+// A format specifier handler that checks if specifiers are consistent with the
+// argument type.
+template <typename Handler> class specs_checker : public Handler {
+ public:
+  FMT_CONSTEXPR specs_checker(const Handler& handler, internal::type arg_type)
+      : Handler(handler), checker_(*this, arg_type) {}
+
+  FMT_CONSTEXPR specs_checker(const specs_checker& other)
+      : Handler(other), checker_(*this, other.arg_type_) {}
+
+  FMT_CONSTEXPR void on_align(align_t align) {
+    if (align == align::numeric) checker_.require_numeric_argument();
+    Handler::on_align(align);
+  }
+
+  FMT_CONSTEXPR void on_plus() {
+    checker_.check_sign();
+    Handler::on_plus();
+  }
+
+  FMT_CONSTEXPR void on_minus() {
+    checker_.check_sign();
+    Handler::on_minus();
+  }
+
+  FMT_CONSTEXPR void on_space() {
+    checker_.check_sign();
+    Handler::on_space();
+  }
+
+  FMT_CONSTEXPR void on_hash() {
+    checker_.require_numeric_argument();
+    Handler::on_hash();
+  }
+
+  FMT_CONSTEXPR void on_zero() {
+    checker_.require_numeric_argument();
+    Handler::on_zero();
+  }
+
+  FMT_CONSTEXPR void end_precision() { checker_.check_precision(); }
+
+ private:
+  numeric_specs_checker<Handler> checker_;
+};
+
+template <template <typename> class Handler, typename FormatArg,
+          typename ErrorHandler>
+FMT_CONSTEXPR int get_dynamic_spec(FormatArg arg, ErrorHandler eh) {
+  unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
+  if (value > to_unsigned(max_value<int>())) eh.on_error("number is too big");
+  return static_cast<int>(value);
+}
+
+struct auto_id {};
+
+template <typename Context>
+FMT_CONSTEXPR typename Context::format_arg get_arg(Context& ctx, int id) {
+  auto arg = ctx.arg(id);
+  if (!arg) ctx.on_error("argument index out of range");
+  return arg;
+}
+
+// The standard format specifier handler with checking.
+template <typename ParseContext, typename Context>
+class specs_handler : public specs_setter<typename Context::char_type> {
+ public:
+  using char_type = typename Context::char_type;
+
+  FMT_CONSTEXPR specs_handler(basic_format_specs<char_type>& specs,
+                              ParseContext& parse_ctx, Context& ctx)
+      : specs_setter<char_type>(specs),
+        parse_context_(parse_ctx),
+        context_(ctx) {}
+
+  template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
+    this->specs_.width = get_dynamic_spec<width_checker>(
+        get_arg(arg_id), context_.error_handler());
+  }
+
+  template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
+    this->specs_.precision = get_dynamic_spec<precision_checker>(
+        get_arg(arg_id), context_.error_handler());
+  }
+
+  void on_error(const char* message) { context_.on_error(message); }
+
+ private:
+  // This is only needed for compatibility with gcc 4.4.
+  using format_arg = typename Context::format_arg;
+
+  FMT_CONSTEXPR format_arg get_arg(auto_id) {
+    return internal::get_arg(context_, parse_context_.next_arg_id());
+  }
+
+  FMT_CONSTEXPR format_arg get_arg(int arg_id) {
+    parse_context_.check_arg_id(arg_id);
+    return internal::get_arg(context_, arg_id);
+  }
+
+  FMT_CONSTEXPR format_arg get_arg(basic_string_view<char_type> arg_id) {
+    parse_context_.check_arg_id(arg_id);
+    return context_.arg(arg_id);
+  }
+
+  ParseContext& parse_context_;
+  Context& context_;
+};
+
+enum class arg_id_kind { none, index, name };
+
+// An argument reference.
+template <typename Char> struct arg_ref {
+  FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}
+
+  FMT_CONSTEXPR explicit arg_ref(int index)
+      : kind(arg_id_kind::index), val(index) {}
+  FMT_CONSTEXPR explicit arg_ref(basic_string_view<Char> name)
+      : kind(arg_id_kind::name), val(name) {}
+
+  FMT_CONSTEXPR arg_ref& operator=(int idx) {
+    kind = arg_id_kind::index;
+    val.index = idx;
+    return *this;
+  }
+
+  arg_id_kind kind;
+  union value {
+    FMT_CONSTEXPR value(int id = 0) : index{id} {}
+    FMT_CONSTEXPR value(basic_string_view<Char> n) : name(n) {}
+
+    int index;
+    basic_string_view<Char> name;
+  } val;
+};
+
+// Format specifiers with width and precision resolved at formatting rather
+// than parsing time to allow re-using the same parsed specifiers with
+// different sets of arguments (precompilation of format strings).
+template <typename Char>
+struct dynamic_format_specs : basic_format_specs<Char> {
+  arg_ref<Char> width_ref;
+  arg_ref<Char> precision_ref;
+};
+
+// Format spec handler that saves references to arguments representing dynamic
+// width and precision to be resolved at formatting time.
+template <typename ParseContext>
+class dynamic_specs_handler
+    : public specs_setter<typename ParseContext::char_type> {
+ public:
+  using char_type = typename ParseContext::char_type;
+
+  FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs<char_type>& specs,
+                                      ParseContext& ctx)
+      : specs_setter<char_type>(specs), specs_(specs), context_(ctx) {}
+
+  FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler& other)
+      : specs_setter<char_type>(other),
+        specs_(other.specs_),
+        context_(other.context_) {}
+
+  template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
+    specs_.width_ref = make_arg_ref(arg_id);
+  }
+
+  template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
+    specs_.precision_ref = make_arg_ref(arg_id);
+  }
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    context_.on_error(message);
+  }
+
+ private:
+  using arg_ref_type = arg_ref<char_type>;
+
+  FMT_CONSTEXPR arg_ref_type make_arg_ref(int arg_id) {
+    context_.check_arg_id(arg_id);
+    return arg_ref_type(arg_id);
+  }
+
+  FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id) {
+    return arg_ref_type(context_.next_arg_id());
+  }
+
+  FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<char_type> arg_id) {
+    context_.check_arg_id(arg_id);
+    basic_string_view<char_type> format_str(
+        context_.begin(), to_unsigned(context_.end() - context_.begin()));
+    return arg_ref_type(arg_id);
+  }
+
+  dynamic_format_specs<char_type>& specs_;
+  ParseContext& context_;
+};
+
+template <typename Char, typename IDHandler>
+FMT_CONSTEXPR const Char* parse_arg_id(const Char* begin, const Char* end,
+                                       IDHandler&& handler) {
+  FMT_ASSERT(begin != end, "");
+  Char c = *begin;
+  if (c == '}' || c == ':') {
+    handler();
+    return begin;
+  }
+  if (c >= '0' && c <= '9') {
+    int index = 0;
+    if (c != '0')
+      index = parse_nonnegative_int(begin, end, handler);
+    else
+      ++begin;
+    if (begin == end || (*begin != '}' && *begin != ':'))
+      handler.on_error("invalid format string");
+    else
+      handler(index);
+    return begin;
+  }
+  if (!is_name_start(c)) {
+    handler.on_error("invalid format string");
+    return begin;
+  }
+  auto it = begin;
+  do {
+    ++it;
+  } while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
+  handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
+  return it;
+}
+
+// Adapts SpecHandler to IDHandler API for dynamic width.
+template <typename SpecHandler, typename Char> struct width_adapter {
+  explicit FMT_CONSTEXPR width_adapter(SpecHandler& h) : handler(h) {}
+
+  FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
+  FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_width(id); }
+  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
+    handler.on_dynamic_width(id);
+  }
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    handler.on_error(message);
+  }
+
+  SpecHandler& handler;
+};
+
+// Adapts SpecHandler to IDHandler API for dynamic precision.
+template <typename SpecHandler, typename Char> struct precision_adapter {
+  explicit FMT_CONSTEXPR precision_adapter(SpecHandler& h) : handler(h) {}
+
+  FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
+  FMT_CONSTEXPR void operator()(int id) { handler.on_dynamic_precision(id); }
+  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
+    handler.on_dynamic_precision(id);
+  }
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    handler.on_error(message);
+  }
+
+  SpecHandler& handler;
+};
+
+template <typename Char>
+FMT_CONSTEXPR const Char* next_code_point(const Char* begin, const Char* end) {
+  if (const_check(sizeof(Char) != 1) || (*begin & 0x80) == 0) return begin + 1;
+  do {
+    ++begin;
+  } while (begin != end && (*begin & 0xc0) == 0x80);
+  return begin;
+}
+
+// Parses fill and alignment.
+template <typename Char, typename Handler>
+FMT_CONSTEXPR const Char* parse_align(const Char* begin, const Char* end,
+                                      Handler&& handler) {
+  FMT_ASSERT(begin != end, "");
+  auto align = align::none;
+  auto p = next_code_point(begin, end);
+  if (p == end) p = begin;
+  for (;;) {
+    switch (static_cast<char>(*p)) {
+    case '<':
+      align = align::left;
+      break;
+    case '>':
+      align = align::right;
+      break;
+#if FMT_NUMERIC_ALIGN
+    case '=':
+      align = align::numeric;
+      break;
+#endif
+    case '^':
+      align = align::center;
+      break;
+    }
+    if (align != align::none) {
+      if (p != begin) {
+        auto c = *begin;
+        if (c == '{')
+          return handler.on_error("invalid fill character '{'"), begin;
+        handler.on_fill(basic_string_view<Char>(begin, to_unsigned(p - begin)));
+        begin = p + 1;
+      } else
+        ++begin;
+      handler.on_align(align);
+      break;
+    } else if (p == begin) {
+      break;
+    }
+    p = begin;
+  }
+  return begin;
+}
+
+template <typename Char, typename Handler>
+FMT_CONSTEXPR const Char* parse_width(const Char* begin, const Char* end,
+                                      Handler&& handler) {
+  FMT_ASSERT(begin != end, "");
+  if ('0' <= *begin && *begin <= '9') {
+    handler.on_width(parse_nonnegative_int(begin, end, handler));
+  } else if (*begin == '{') {
+    ++begin;
+    if (begin != end)
+      begin = parse_arg_id(begin, end, width_adapter<Handler, Char>(handler));
+    if (begin == end || *begin != '}')
+      return handler.on_error("invalid format string"), begin;
+    ++begin;
+  }
+  return begin;
+}
+
+template <typename Char, typename Handler>
+FMT_CONSTEXPR const Char* parse_precision(const Char* begin, const Char* end,
+                                          Handler&& handler) {
+  ++begin;
+  auto c = begin != end ? *begin : Char();
+  if ('0' <= c && c <= '9') {
+    handler.on_precision(parse_nonnegative_int(begin, end, handler));
+  } else if (c == '{') {
+    ++begin;
+    if (begin != end) {
+      begin =
+          parse_arg_id(begin, end, precision_adapter<Handler, Char>(handler));
+    }
+    if (begin == end || *begin++ != '}')
+      return handler.on_error("invalid format string"), begin;
+  } else {
+    return handler.on_error("missing precision specifier"), begin;
+  }
+  handler.end_precision();
+  return begin;
+}
+
+// Parses standard format specifiers and sends notifications about parsed
+// components to handler.
+template <typename Char, typename SpecHandler>
+FMT_CONSTEXPR const Char* parse_format_specs(const Char* begin, const Char* end,
+                                             SpecHandler&& handler) {
+  if (begin == end || *begin == '}') return begin;
+
+  begin = parse_align(begin, end, handler);
+  if (begin == end) return begin;
+
+  // Parse sign.
+  switch (static_cast<char>(*begin)) {
+  case '+':
+    handler.on_plus();
+    ++begin;
+    break;
+  case '-':
+    handler.on_minus();
+    ++begin;
+    break;
+  case ' ':
+    handler.on_space();
+    ++begin;
+    break;
+  }
+  if (begin == end) return begin;
+
+  if (*begin == '#') {
+    handler.on_hash();
+    if (++begin == end) return begin;
+  }
+
+  // Parse zero flag.
+  if (*begin == '0') {
+    handler.on_zero();
+    if (++begin == end) return begin;
+  }
+
+  begin = parse_width(begin, end, handler);
+  if (begin == end) return begin;
+
+  // Parse precision.
+  if (*begin == '.') {
+    begin = parse_precision(begin, end, handler);
+  }
+
+  // Parse type.
+  if (begin != end && *begin != '}') handler.on_type(*begin++);
+  return begin;
+}
+
+// Return the result via the out param to workaround gcc bug 77539.
+template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
+FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr& out) {
+  for (out = first; out != last; ++out) {
+    if (*out == value) return true;
+  }
+  return false;
+}
+
+template <>
+inline bool find<false, char>(const char* first, const char* last, char value,
+                              const char*& out) {
+  out = static_cast<const char*>(
+      std::memchr(first, value, internal::to_unsigned(last - first)));
+  return out != nullptr;
+}
+
+template <typename Handler, typename Char> struct id_adapter {
+  FMT_CONSTEXPR void operator()() { handler.on_arg_id(); }
+  FMT_CONSTEXPR void operator()(int id) { handler.on_arg_id(id); }
+  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
+    handler.on_arg_id(id);
+  }
+  FMT_CONSTEXPR void on_error(const char* message) {
+    handler.on_error(message);
+  }
+  Handler& handler;
+};
+
+template <bool IS_CONSTEXPR, typename Char, typename Handler>
+FMT_CONSTEXPR void parse_format_string(basic_string_view<Char> format_str,
+                                       Handler&& handler) {
+  struct pfs_writer {
+    FMT_CONSTEXPR void operator()(const Char* begin, const Char* end) {
+      if (begin == end) return;
+      for (;;) {
+        const Char* p = nullptr;
+        if (!find<IS_CONSTEXPR>(begin, end, '}', p))
+          return handler_.on_text(begin, end);
+        ++p;
+        if (p == end || *p != '}')
+          return handler_.on_error("unmatched '}' in format string");
+        handler_.on_text(begin, p);
+        begin = p + 1;
+      }
+    }
+    Handler& handler_;
+  } write{handler};
+  auto begin = format_str.data();
+  auto end = begin + format_str.size();
+  while (begin != end) {
+    // Doing two passes with memchr (one for '{' and another for '}') is up to
+    // 2.5x faster than the naive one-pass implementation on big format strings.
+    const Char* p = begin;
+    if (*begin != '{' && !find<IS_CONSTEXPR>(begin + 1, end, '{', p))
+      return write(begin, end);
+    write(begin, p);
+    ++p;
+    if (p == end) return handler.on_error("invalid format string");
+    if (static_cast<char>(*p) == '}') {
+      handler.on_arg_id();
+      handler.on_replacement_field(p);
+    } else if (*p == '{') {
+      handler.on_text(p, p + 1);
+    } else {
+      p = parse_arg_id(p, end, id_adapter<Handler, Char>{handler});
+      Char c = p != end ? *p : Char();
+      if (c == '}') {
+        handler.on_replacement_field(p);
+      } else if (c == ':') {
+        p = handler.on_format_specs(p + 1, end);
+        if (p == end || *p != '}')
+          return handler.on_error("unknown format specifier");
+      } else {
+        return handler.on_error("missing '}' in format string");
+      }
+    }
+    begin = p + 1;
+  }
+}
+
+template <typename T, typename ParseContext>
+FMT_CONSTEXPR const typename ParseContext::char_type* parse_format_specs(
+    ParseContext& ctx) {
+  using char_type = typename ParseContext::char_type;
+  using context = buffer_context<char_type>;
+  using mapped_type =
+      conditional_t<internal::mapped_type_constant<T, context>::value !=
+                        type::custom_type,
+                    decltype(arg_mapper<context>().map(std::declval<T>())), T>;
+  auto f = conditional_t<has_formatter<mapped_type, context>::value,
+                         formatter<mapped_type, char_type>,
+                         internal::fallback_formatter<T, char_type>>();
+  return f.parse(ctx);
+}
+
+template <typename Char, typename ErrorHandler, typename... Args>
+class format_string_checker {
+ public:
+  explicit FMT_CONSTEXPR format_string_checker(
+      basic_string_view<Char> format_str, ErrorHandler eh)
+      : arg_id_(-1),
+        context_(format_str, eh),
+        parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
+
+  FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
+
+  FMT_CONSTEXPR void on_arg_id() {
+    arg_id_ = context_.next_arg_id();
+    check_arg_id();
+  }
+  FMT_CONSTEXPR void on_arg_id(int id) {
+    arg_id_ = id;
+    context_.check_arg_id(id);
+    check_arg_id();
+  }
+  FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) {
+    on_error("compile-time checks don't support named arguments");
+  }
+
+  FMT_CONSTEXPR void on_replacement_field(const Char*) {}
+
+  FMT_CONSTEXPR const Char* on_format_specs(const Char* begin, const Char*) {
+    advance_to(context_, begin);
+    return arg_id_ < num_args ? parse_funcs_[arg_id_](context_) : begin;
+  }
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    context_.on_error(message);
+  }
+
+ private:
+  using parse_context_type = basic_format_parse_context<Char, ErrorHandler>;
+  enum { num_args = sizeof...(Args) };
+
+  FMT_CONSTEXPR void check_arg_id() {
+    if (arg_id_ >= num_args) context_.on_error("argument index out of range");
+  }
+
+  // Format specifier parsing function.
+  using parse_func = const Char* (*)(parse_context_type&);
+
+  int arg_id_;
+  parse_context_type context_;
+  parse_func parse_funcs_[num_args > 0 ? num_args : 1];
+};
+
+template <typename Char, typename ErrorHandler, typename... Args>
+FMT_CONSTEXPR bool do_check_format_string(basic_string_view<Char> s,
+                                          ErrorHandler eh = ErrorHandler()) {
+  format_string_checker<Char, ErrorHandler, Args...> checker(s, eh);
+  parse_format_string<true>(s, checker);
+  return true;
+}
+
+template <typename... Args, typename S,
+          enable_if_t<(is_compile_string<S>::value), int>>
+void check_format_string(S format_str) {
+  FMT_CONSTEXPR_DECL bool invalid_format = internal::do_check_format_string<
+      typename S::char_type, internal::error_handler,
+      remove_const_t<remove_reference_t<Args>>...>(to_string_view(format_str));
+  (void)invalid_format;
+}
+
+template <template <typename> class Handler, typename Context>
+void handle_dynamic_spec(int& value, arg_ref<typename Context::char_type> ref,
+                         Context& ctx) {
+  switch (ref.kind) {
+  case arg_id_kind::none:
+    break;
+  case arg_id_kind::index:
+    value = internal::get_dynamic_spec<Handler>(ctx.arg(ref.val.index),
+                                                ctx.error_handler());
+    break;
+  case arg_id_kind::name:
+    value = internal::get_dynamic_spec<Handler>(ctx.arg(ref.val.name),
+                                                ctx.error_handler());
+    break;
+  }
+}
+
+using format_func = void (*)(internal::buffer<char>&, int, string_view);
+
+FMT_API void format_error_code(buffer<char>& out, int error_code,
+                               string_view message) FMT_NOEXCEPT;
+
+FMT_API void report_error(format_func func, int error_code,
+                          string_view message) FMT_NOEXCEPT;
+}  // namespace internal
+
+template <typename Range>
+using basic_writer FMT_DEPRECATED_ALIAS = internal::basic_writer<Range>;
+using writer FMT_DEPRECATED_ALIAS = internal::writer;
+using wwriter FMT_DEPRECATED_ALIAS =
+    internal::basic_writer<buffer_range<wchar_t>>;
+
+/** The default argument formatter. */
+template <typename Range>
+class arg_formatter : public internal::arg_formatter_base<Range> {
+ private:
+  using char_type = typename Range::value_type;
+  using base = internal::arg_formatter_base<Range>;
+  using context_type = basic_format_context<typename base::iterator, char_type>;
+
+  context_type& ctx_;
+  basic_format_parse_context<char_type>* parse_ctx_;
+
+ public:
+  using range = Range;
+  using iterator = typename base::iterator;
+  using format_specs = typename base::format_specs;
+
+  /**
+    \rst
+    Constructs an argument formatter object.
+    *ctx* is a reference to the formatting context,
+    *specs* contains format specifier information for standard argument types.
+    \endrst
+   */
+  explicit arg_formatter(
+      context_type& ctx,
+      basic_format_parse_context<char_type>* parse_ctx = nullptr,
+      format_specs* specs = nullptr)
+      : base(Range(ctx.out()), specs, ctx.locale()),
+        ctx_(ctx),
+        parse_ctx_(parse_ctx) {}
+
+  using base::operator();
+
+  /** Formats an argument of a user-defined type. */
+  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
+    handle.format(*parse_ctx_, ctx_);
+    return ctx_.out();
+  }
+};
+
+/**
+ An error returned by an operating system or a language runtime,
+ for example a file opening error.
+*/
+FMT_CLASS_API
+class FMT_API system_error : public std::runtime_error {
+ private:
+  void init(int err_code, string_view format_str, format_args args);
+
+ protected:
+  int error_code_;
+
+  system_error() : std::runtime_error(""), error_code_(0) {}
+
+ public:
+  /**
+   \rst
+   Constructs a :class:`fmt::system_error` object with a description
+   formatted with `fmt::format_system_error`. *message* and additional
+   arguments passed into the constructor are formatted similarly to
+   `fmt::format`.
+
+   **Example**::
+
+     // This throws a system_error with the description
+     //   cannot open file 'madeup': No such file or directory
+     // or similar (system message may vary).
+     const char *filename = "madeup";
+     std::FILE *file = std::fopen(filename, "r");
+     if (!file)
+       throw fmt::system_error(errno, "cannot open file '{}'", filename);
+   \endrst
+  */
+  template <typename... Args>
+  system_error(int error_code, string_view message, const Args&... args)
+      : std::runtime_error("") {
+    init(error_code, message, make_format_args(args...));
+  }
+  system_error(const system_error&) = default;
+  system_error& operator=(const system_error&) = default;
+  system_error(system_error&&) = default;
+  system_error& operator=(system_error&&) = default;
+  ~system_error() FMT_NOEXCEPT FMT_OVERRIDE;
+
+  int error_code() const { return error_code_; }
+};
+
+/**
+  \rst
+  Formats an error returned by an operating system or a language runtime,
+  for example a file opening error, and writes it to *out* in the following
+  form:
+
+  .. parsed-literal::
+     *<message>*: *<system-message>*
+
+  where *<message>* is the passed message and *<system-message>* is
+  the system message corresponding to the error code.
+  *error_code* is a system error code as given by ``errno``.
+  If *error_code* is not a valid error code such as -1, the system message
+  may look like "Unknown error -1" and is platform-dependent.
+  \endrst
+ */
+FMT_API void format_system_error(internal::buffer<char>& out, int error_code,
+                                 string_view message) FMT_NOEXCEPT;
+
+// Reports a system error without throwing an exception.
+// Can be used to report errors from destructors.
+FMT_API void report_system_error(int error_code,
+                                 string_view message) FMT_NOEXCEPT;
+
+/** Fast integer formatter. */
+class format_int {
+ private:
+  // Buffer should be large enough to hold all digits (digits10 + 1),
+  // a sign and a null character.
+  enum { buffer_size = std::numeric_limits<unsigned long long>::digits10 + 3 };
+  mutable char buffer_[buffer_size];
+  char* str_;
+
+  // Formats value in reverse and returns a pointer to the beginning.
+  char* format_decimal(unsigned long long value) {
+    char* ptr = buffer_ + (buffer_size - 1);  // Parens to workaround MSVC bug.
+    while (value >= 100) {
+      // Integer division is slow so do it for a group of two digits instead
+      // of for every digit. The idea comes from the talk by Alexandrescu
+      // "Three Optimization Tips for C++". See speed-test for a comparison.
+      auto index = static_cast<unsigned>((value % 100) * 2);
+      value /= 100;
+      *--ptr = internal::data::digits[index + 1];
+      *--ptr = internal::data::digits[index];
+    }
+    if (value < 10) {
+      *--ptr = static_cast<char>('0' + value);
+      return ptr;
+    }
+    auto index = static_cast<unsigned>(value * 2);
+    *--ptr = internal::data::digits[index + 1];
+    *--ptr = internal::data::digits[index];
+    return ptr;
+  }
+
+  void format_signed(long long value) {
+    auto abs_value = static_cast<unsigned long long>(value);
+    bool negative = value < 0;
+    if (negative) abs_value = 0 - abs_value;
+    str_ = format_decimal(abs_value);
+    if (negative) *--str_ = '-';
+  }
+
+ public:
+  explicit format_int(int value) { format_signed(value); }
+  explicit format_int(long value) { format_signed(value); }
+  explicit format_int(long long value) { format_signed(value); }
+  explicit format_int(unsigned value) : str_(format_decimal(value)) {}
+  explicit format_int(unsigned long value) : str_(format_decimal(value)) {}
+  explicit format_int(unsigned long long value) : str_(format_decimal(value)) {}
+
+  /** Returns the number of characters written to the output buffer. */
+  std::size_t size() const {
+    return internal::to_unsigned(buffer_ - str_ + buffer_size - 1);
+  }
+
+  /**
+    Returns a pointer to the output buffer content. No terminating null
+    character is appended.
+   */
+  const char* data() const { return str_; }
+
+  /**
+    Returns a pointer to the output buffer content with terminating null
+    character appended.
+   */
+  const char* c_str() const {
+    buffer_[buffer_size - 1] = '\0';
+    return str_;
+  }
+
+  /**
+    \rst
+    Returns the content of the output buffer as an ``std::string``.
+    \endrst
+   */
+  std::string str() const { return std::string(str_, size()); }
+};
+
+// A formatter specialization for the core types corresponding to internal::type
+// constants.
+template <typename T, typename Char>
+struct formatter<T, Char,
+                 enable_if_t<internal::type_constant<T, Char>::value !=
+                             internal::type::custom_type>> {
+  FMT_CONSTEXPR formatter() = default;
+
+  // Parses format specifiers stopping either at the end of the range or at the
+  // terminating '}'.
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    using handler_type = internal::dynamic_specs_handler<ParseContext>;
+    auto type = internal::type_constant<T, Char>::value;
+    internal::specs_checker<handler_type> handler(handler_type(specs_, ctx),
+                                                  type);
+    auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
+    auto eh = ctx.error_handler();
+    switch (type) {
+    case internal::type::none_type:
+    case internal::type::named_arg_type:
+      FMT_ASSERT(false, "invalid argument type");
+      break;
+    case internal::type::int_type:
+    case internal::type::uint_type:
+    case internal::type::long_long_type:
+    case internal::type::ulong_long_type:
+    case internal::type::int128_type:
+    case internal::type::uint128_type:
+    case internal::type::bool_type:
+      handle_int_type_spec(specs_.type,
+                           internal::int_type_checker<decltype(eh)>(eh));
+      break;
+    case internal::type::char_type:
+      handle_char_specs(
+          &specs_, internal::char_specs_checker<decltype(eh)>(specs_.type, eh));
+      break;
+    case internal::type::float_type:
+      if (internal::const_check(FMT_USE_FLOAT)) {
+        internal::parse_float_type_spec(specs_, eh);
+      } else {
+        FMT_ASSERT(false, "float support disabled");
+      }
+      break;
+    case internal::type::double_type:
+      if (internal::const_check(FMT_USE_DOUBLE)) {
+        internal::parse_float_type_spec(specs_, eh);
+      } else {
+        FMT_ASSERT(false, "double support disabled");
+      }
+      break;
+    case internal::type::long_double_type:
+      if (internal::const_check(FMT_USE_LONG_DOUBLE)) {
+        internal::parse_float_type_spec(specs_, eh);
+      } else {
+        FMT_ASSERT(false, "long double support disabled");
+      }
+      break;
+    case internal::type::cstring_type:
+      internal::handle_cstring_type_spec(
+          specs_.type, internal::cstring_type_checker<decltype(eh)>(eh));
+      break;
+    case internal::type::string_type:
+      internal::check_string_type_spec(specs_.type, eh);
+      break;
+    case internal::type::pointer_type:
+      internal::check_pointer_type_spec(specs_.type, eh);
+      break;
+    case internal::type::custom_type:
+      // Custom format specifiers should be checked in parse functions of
+      // formatter specializations.
+      break;
+    }
+    return it;
+  }
+
+  template <typename FormatContext>
+  auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
+    internal::handle_dynamic_spec<internal::width_checker>(
+        specs_.width, specs_.width_ref, ctx);
+    internal::handle_dynamic_spec<internal::precision_checker>(
+        specs_.precision, specs_.precision_ref, ctx);
+    using range_type =
+        internal::output_range<typename FormatContext::iterator,
+                               typename FormatContext::char_type>;
+    return visit_format_arg(arg_formatter<range_type>(ctx, nullptr, &specs_),
+                            internal::make_arg<FormatContext>(val));
+  }
+
+ private:
+  internal::dynamic_format_specs<Char> specs_;
+};
+
+#define FMT_FORMAT_AS(Type, Base)                                             \
+  template <typename Char>                                                    \
+  struct formatter<Type, Char> : formatter<Base, Char> {                      \
+    template <typename FormatContext>                                         \
+    auto format(Type const& val, FormatContext& ctx) -> decltype(ctx.out()) { \
+      return formatter<Base, Char>::format(val, ctx);                         \
+    }                                                                         \
+  }
+
+FMT_FORMAT_AS(signed char, int);
+FMT_FORMAT_AS(unsigned char, unsigned);
+FMT_FORMAT_AS(short, int);
+FMT_FORMAT_AS(unsigned short, unsigned);
+FMT_FORMAT_AS(long, long long);
+FMT_FORMAT_AS(unsigned long, unsigned long long);
+FMT_FORMAT_AS(Char*, const Char*);
+FMT_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>);
+FMT_FORMAT_AS(std::nullptr_t, const void*);
+FMT_FORMAT_AS(internal::std_string_view<Char>, basic_string_view<Char>);
+
+template <typename Char>
+struct formatter<void*, Char> : formatter<const void*, Char> {
+  template <typename FormatContext>
+  auto format(void* val, FormatContext& ctx) -> decltype(ctx.out()) {
+    return formatter<const void*, Char>::format(val, ctx);
+  }
+};
+
+template <typename Char, size_t N>
+struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {
+  template <typename FormatContext>
+  auto format(const Char* val, FormatContext& ctx) -> decltype(ctx.out()) {
+    return formatter<basic_string_view<Char>, Char>::format(val, ctx);
+  }
+};
+
+// A formatter for types known only at run time such as variant alternatives.
+//
+// Usage:
+//   using variant = std::variant<int, std::string>;
+//   template <>
+//   struct formatter<variant>: dynamic_formatter<> {
+//     void format(buffer &buf, const variant &v, context &ctx) {
+//       visit([&](const auto &val) { format(buf, val, ctx); }, v);
+//     }
+//   };
+template <typename Char = char> class dynamic_formatter {
+ private:
+  struct null_handler : internal::error_handler {
+    void on_align(align_t) {}
+    void on_plus() {}
+    void on_minus() {}
+    void on_space() {}
+    void on_hash() {}
+  };
+
+ public:
+  template <typename ParseContext>
+  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    format_str_ = ctx.begin();
+    // Checks are deferred to formatting time when the argument type is known.
+    internal::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
+    return parse_format_specs(ctx.begin(), ctx.end(), handler);
+  }
+
+  template <typename T, typename FormatContext>
+  auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
+    handle_specs(ctx);
+    internal::specs_checker<null_handler> checker(
+        null_handler(),
+        internal::mapped_type_constant<T, FormatContext>::value);
+    checker.on_align(specs_.align);
+    switch (specs_.sign) {
+    case sign::none:
+      break;
+    case sign::plus:
+      checker.on_plus();
+      break;
+    case sign::minus:
+      checker.on_minus();
+      break;
+    case sign::space:
+      checker.on_space();
+      break;
+    }
+    if (specs_.alt) checker.on_hash();
+    if (specs_.precision >= 0) checker.end_precision();
+    using range = internal::output_range<typename FormatContext::iterator,
+                                         typename FormatContext::char_type>;
+    visit_format_arg(arg_formatter<range>(ctx, nullptr, &specs_),
+                     internal::make_arg<FormatContext>(val));
+    return ctx.out();
+  }
+
+ private:
+  template <typename Context> void handle_specs(Context& ctx) {
+    internal::handle_dynamic_spec<internal::width_checker>(
+        specs_.width, specs_.width_ref, ctx);
+    internal::handle_dynamic_spec<internal::precision_checker>(
+        specs_.precision, specs_.precision_ref, ctx);
+  }
+
+  internal::dynamic_format_specs<Char> specs_;
+  const Char* format_str_;
+};
+
+template <typename Range, typename Char>
+typename basic_format_context<Range, Char>::format_arg
+basic_format_context<Range, Char>::arg(basic_string_view<char_type> name) {
+  map_.init(args_);
+  format_arg arg = map_.find(name);
+  if (arg.type() == internal::type::none_type)
+    this->on_error("argument not found");
+  return arg;
+}
+
+template <typename Char, typename ErrorHandler>
+FMT_CONSTEXPR void advance_to(
+    basic_format_parse_context<Char, ErrorHandler>& ctx, const Char* p) {
+  ctx.advance_to(ctx.begin() + (p - &*ctx.begin()));
+}
+
+template <typename ArgFormatter, typename Char, typename Context>
+struct format_handler : internal::error_handler {
+  using range = typename ArgFormatter::range;
+
+  format_handler(range r, basic_string_view<Char> str,
+                 basic_format_args<Context> format_args,
+                 internal::locale_ref loc)
+      : parse_context(str), context(r.begin(), format_args, loc) {}
+
+  void on_text(const Char* begin, const Char* end) {
+    auto size = internal::to_unsigned(end - begin);
+    auto out = context.out();
+    auto&& it = internal::reserve(out, size);
+    it = std::copy_n(begin, size, it);
+    context.advance_to(out);
+  }
+
+  void get_arg(int id) { arg = internal::get_arg(context, id); }
+
+  void on_arg_id() { get_arg(parse_context.next_arg_id()); }
+  void on_arg_id(int id) {
+    parse_context.check_arg_id(id);
+    get_arg(id);
+  }
+  void on_arg_id(basic_string_view<Char> id) { arg = context.arg(id); }
+
+  void on_replacement_field(const Char* p) {
+    advance_to(parse_context, p);
+    context.advance_to(
+        visit_format_arg(ArgFormatter(context, &parse_context), arg));
+  }
+
+  const Char* on_format_specs(const Char* begin, const Char* end) {
+    advance_to(parse_context, begin);
+    internal::custom_formatter<Context> f(parse_context, context);
+    if (visit_format_arg(f, arg)) return parse_context.begin();
+    basic_format_specs<Char> specs;
+    using internal::specs_handler;
+    using parse_context_t = basic_format_parse_context<Char>;
+    internal::specs_checker<specs_handler<parse_context_t, Context>> handler(
+        specs_handler<parse_context_t, Context>(specs, parse_context, context),
+        arg.type());
+    begin = parse_format_specs(begin, end, handler);
+    if (begin == end || *begin != '}') on_error("missing '}' in format string");
+    advance_to(parse_context, begin);
+    context.advance_to(
+        visit_format_arg(ArgFormatter(context, &parse_context, &specs), arg));
+    return begin;
+  }
+
+  basic_format_parse_context<Char> parse_context;
+  Context context;
+  basic_format_arg<Context> arg;
+};
+
+/** Formats arguments and writes the output to the range. */
+template <typename ArgFormatter, typename Char, typename Context>
+typename Context::iterator vformat_to(
+    typename ArgFormatter::range out, basic_string_view<Char> format_str,
+    basic_format_args<Context> args,
+    internal::locale_ref loc = internal::locale_ref()) {
+  format_handler<ArgFormatter, Char, Context> h(out, format_str, args, loc);
+  internal::parse_format_string<false>(format_str, h);
+  return h.context.out();
+}
+
+// Casts ``p`` to ``const void*`` for pointer formatting.
+// Example:
+//   auto s = format("{}", ptr(p));
+template <typename T> inline const void* ptr(const T* p) { return p; }
+template <typename T> inline const void* ptr(const std::unique_ptr<T>& p) {
+  return p.get();
+}
+template <typename T> inline const void* ptr(const std::shared_ptr<T>& p) {
+  return p.get();
+}
+
+class bytes {
+ private:
+  string_view data_;
+  friend struct formatter<bytes>;
+
+ public:
+  explicit bytes(string_view data) : data_(data) {}
+};
+
+template <> struct formatter<bytes> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    using handler_type = internal::dynamic_specs_handler<ParseContext>;
+    internal::specs_checker<handler_type> handler(handler_type(specs_, ctx),
+                                                  internal::type::string_type);
+    auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
+    internal::check_string_type_spec(specs_.type, ctx.error_handler());
+    return it;
+  }
+
+  template <typename FormatContext>
+  auto format(bytes b, FormatContext& ctx) -> decltype(ctx.out()) {
+    internal::handle_dynamic_spec<internal::width_checker>(
+        specs_.width, specs_.width_ref, ctx);
+    internal::handle_dynamic_spec<internal::precision_checker>(
+        specs_.precision, specs_.precision_ref, ctx);
+    using range_type =
+        internal::output_range<typename FormatContext::iterator, char>;
+    internal::basic_writer<range_type> writer(range_type(ctx.out()));
+    writer.write_bytes(b.data_, specs_);
+    return writer.out();
+  }
+
+ private:
+  internal::dynamic_format_specs<char> specs_;
+};
+
+template <typename It, typename Char> struct arg_join : internal::view {
+  It begin;
+  It end;
+  basic_string_view<Char> sep;
+
+  arg_join(It b, It e, basic_string_view<Char> s) : begin(b), end(e), sep(s) {}
+};
+
+template <typename It, typename Char>
+struct formatter<arg_join<It, Char>, Char>
+    : formatter<typename std::iterator_traits<It>::value_type, Char> {
+  template <typename FormatContext>
+  auto format(const arg_join<It, Char>& value, FormatContext& ctx)
+      -> decltype(ctx.out()) {
+    using base = formatter<typename std::iterator_traits<It>::value_type, Char>;
+    auto it = value.begin;
+    auto out = ctx.out();
+    if (it != value.end) {
+      out = base::format(*it++, ctx);
+      while (it != value.end) {
+        out = std::copy(value.sep.begin(), value.sep.end(), out);
+        ctx.advance_to(out);
+        out = base::format(*it++, ctx);
+      }
+    }
+    return out;
+  }
+};
+
+/**
+  Returns an object that formats the iterator range `[begin, end)` with elements
+  separated by `sep`.
+ */
+template <typename It>
+arg_join<It, char> join(It begin, It end, string_view sep) {
+  return {begin, end, sep};
+}
+
+template <typename It>
+arg_join<It, wchar_t> join(It begin, It end, wstring_view sep) {
+  return {begin, end, sep};
+}
+
+/**
+  \rst
+  Returns an object that formats `range` with elements separated by `sep`.
+
+  **Example**::
+
+    std::vector<int> v = {1, 2, 3};
+    fmt::print("{}", fmt::join(v, ", "));
+    // Output: "1, 2, 3"
+
+  ``fmt::join`` applies passed format specifiers to the range elements::
+
+    fmt::print("{:02}", fmt::join(v, ", "));
+    // Output: "01, 02, 03"
+  \endrst
+ */
+template <typename Range>
+arg_join<internal::iterator_t<const Range>, char> join(const Range& range,
+                                                       string_view sep) {
+  return join(std::begin(range), std::end(range), sep);
+}
+
+template <typename Range>
+arg_join<internal::iterator_t<const Range>, wchar_t> join(const Range& range,
+                                                          wstring_view sep) {
+  return join(std::begin(range), std::end(range), sep);
+}
+
+/**
+  \rst
+  Converts *value* to ``std::string`` using the default format for type *T*.
+
+  **Example**::
+
+    #include <fmt/format.h>
+
+    std::string answer = fmt::to_string(42);
+  \endrst
+ */
+template <typename T> inline std::string to_string(const T& value) {
+  return format("{}", value);
+}
+
+/**
+  Converts *value* to ``std::wstring`` using the default format for type *T*.
+ */
+template <typename T> inline std::wstring to_wstring(const T& value) {
+  return format(L"{}", value);
+}
+
+template <typename Char, std::size_t SIZE>
+std::basic_string<Char> to_string(const basic_memory_buffer<Char, SIZE>& buf) {
+  return std::basic_string<Char>(buf.data(), buf.size());
+}
+
+template <typename Char>
+typename buffer_context<Char>::iterator internal::vformat_to(
+    internal::buffer<Char>& buf, basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  using range = buffer_range<Char>;
+  return vformat_to<arg_formatter<range>>(buf, to_string_view(format_str),
+                                          args);
+}
+
+template <typename S, typename Char = char_t<S>,
+          FMT_ENABLE_IF(internal::is_string<S>::value)>
+inline typename buffer_context<Char>::iterator vformat_to(
+    internal::buffer<Char>& buf, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  return internal::vformat_to(buf, to_string_view(format_str), args);
+}
+
+template <typename S, typename... Args, std::size_t SIZE = inline_buffer_size,
+          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
+inline typename buffer_context<Char>::iterator format_to(
+    basic_memory_buffer<Char, SIZE>& buf, const S& format_str, Args&&... args) {
+  internal::check_format_string<Args...>(format_str);
+  using context = buffer_context<Char>;
+  return internal::vformat_to(buf, to_string_view(format_str),
+                              make_format_args<context>(args...));
+}
+
+template <typename OutputIt, typename Char = char>
+using format_context_t = basic_format_context<OutputIt, Char>;
+
+template <typename OutputIt, typename Char = char>
+using format_args_t = basic_format_args<format_context_t<OutputIt, Char>>;
+
+template <typename S, typename OutputIt, typename... Args,
+          FMT_ENABLE_IF(
+              internal::is_output_iterator<OutputIt>::value &&
+              !internal::is_contiguous_back_insert_iterator<OutputIt>::value)>
+inline OutputIt vformat_to(
+    OutputIt out, const S& format_str,
+    format_args_t<type_identity_t<OutputIt>, char_t<S>> args) {
+  using range = internal::output_range<OutputIt, char_t<S>>;
+  return vformat_to<arg_formatter<range>>(range(out),
+                                          to_string_view(format_str), args);
+}
+
+/**
+ \rst
+ Formats arguments, writes the result to the output iterator ``out`` and returns
+ the iterator past the end of the output range.
+
+ **Example**::
+
+   std::vector<char> out;
+   fmt::format_to(std::back_inserter(out), "{}", 42);
+ \endrst
+ */
+template <typename OutputIt, typename S, typename... Args,
+          FMT_ENABLE_IF(
+              internal::is_output_iterator<OutputIt>::value &&
+              !internal::is_contiguous_back_insert_iterator<OutputIt>::value &&
+              internal::is_string<S>::value)>
+inline OutputIt format_to(OutputIt out, const S& format_str, Args&&... args) {
+  internal::check_format_string<Args...>(format_str);
+  using context = format_context_t<OutputIt, char_t<S>>;
+  return vformat_to(out, to_string_view(format_str),
+                    make_format_args<context>(args...));
+}
+
+template <typename OutputIt> struct format_to_n_result {
+  /** Iterator past the end of the output range. */
+  OutputIt out;
+  /** Total (not truncated) output size. */
+  std::size_t size;
+};
+
+template <typename OutputIt, typename Char = typename OutputIt::value_type>
+using format_to_n_context =
+    format_context_t<internal::truncating_iterator<OutputIt>, Char>;
+
+template <typename OutputIt, typename Char = typename OutputIt::value_type>
+using format_to_n_args = basic_format_args<format_to_n_context<OutputIt, Char>>;
+
+template <typename OutputIt, typename Char, typename... Args>
+inline format_arg_store<format_to_n_context<OutputIt, Char>, Args...>
+make_format_to_n_args(const Args&... args) {
+  return format_arg_store<format_to_n_context<OutputIt, Char>, Args...>(
+      args...);
+}
+
+template <typename OutputIt, typename Char, typename... Args,
+          FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value)>
+inline format_to_n_result<OutputIt> vformat_to_n(
+    OutputIt out, std::size_t n, basic_string_view<Char> format_str,
+    format_to_n_args<type_identity_t<OutputIt>, type_identity_t<Char>> args) {
+  auto it = vformat_to(internal::truncating_iterator<OutputIt>(out, n),
+                       format_str, args);
+  return {it.base(), it.count()};
+}
+
+/**
+ \rst
+ Formats arguments, writes up to ``n`` characters of the result to the output
+ iterator ``out`` and returns the total output size and the iterator past the
+ end of the output range.
+ \endrst
+ */
+template <typename OutputIt, typename S, typename... Args,
+          FMT_ENABLE_IF(internal::is_string<S>::value&&
+                            internal::is_output_iterator<OutputIt>::value)>
+inline format_to_n_result<OutputIt> format_to_n(OutputIt out, std::size_t n,
+                                                const S& format_str,
+                                                const Args&... args) {
+  internal::check_format_string<Args...>(format_str);
+  using context = format_to_n_context<OutputIt, char_t<S>>;
+  return vformat_to_n(out, n, to_string_view(format_str),
+                      make_format_args<context>(args...));
+}
+
+template <typename Char>
+inline std::basic_string<Char> internal::vformat(
+    basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buffer;
+  internal::vformat_to(buffer, format_str, args);
+  return to_string(buffer);
+}
+
+/**
+  Returns the number of characters in the output of
+  ``format(format_str, args...)``.
+ */
+template <typename... Args>
+inline std::size_t formatted_size(string_view format_str, const Args&... args) {
+  return format_to(internal::counting_iterator(), format_str, args...).count();
+}
+
+template <typename Char, FMT_ENABLE_IF(std::is_same<Char, wchar_t>::value)>
+void vprint(std::FILE* f, basic_string_view<Char> format_str,
+            wformat_args args) {
+  wmemory_buffer buffer;
+  internal::vformat_to(buffer, format_str, args);
+  buffer.push_back(L'\0');
+  if (std::fputws(buffer.data(), f) == -1)
+    FMT_THROW(system_error(errno, "cannot write to file"));
+}
+
+template <typename Char, FMT_ENABLE_IF(std::is_same<Char, wchar_t>::value)>
+void vprint(basic_string_view<Char> format_str, wformat_args args) {
+  vprint(stdout, format_str, args);
+}
+
+#if FMT_USE_USER_DEFINED_LITERALS
+namespace internal {
+
+#  if FMT_USE_UDL_TEMPLATE
+template <typename Char, Char... CHARS> class udl_formatter {
+ public:
+  template <typename... Args>
+  std::basic_string<Char> operator()(Args&&... args) const {
+    FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'};
+    FMT_CONSTEXPR_DECL bool invalid_format =
+        do_check_format_string<Char, error_handler, remove_cvref_t<Args>...>(
+            basic_string_view<Char>(s, sizeof...(CHARS)));
+    (void)invalid_format;
+    return format(s, std::forward<Args>(args)...);
+  }
+};
+#  else
+template <typename Char> struct udl_formatter {
+  basic_string_view<Char> str;
+
+  template <typename... Args>
+  std::basic_string<Char> operator()(Args&&... args) const {
+    return format(str, std::forward<Args>(args)...);
+  }
+};
+#  endif  // FMT_USE_UDL_TEMPLATE
+
+template <typename Char> struct udl_arg {
+  basic_string_view<Char> str;
+
+  template <typename T> named_arg<T, Char> operator=(T&& value) const {
+    return {str, std::forward<T>(value)};
+  }
+};
+
+// Converts string literals to basic_string_view.
+template <typename Char, size_t N>
+FMT_CONSTEXPR basic_string_view<Char> compile_string_to_view(
+    const Char (&s)[N]) {
+  // Remove trailing null character if needed. Won't be present if this is used
+  // with raw character array (i.e. not defined as a string).
+  return {s,
+          N - ((std::char_traits<Char>::to_int_type(s[N - 1]) == 0) ? 1 : 0)};
+}
+
+// Converts string_view to basic_string_view.
+template <typename Char>
+FMT_CONSTEXPR basic_string_view<Char> compile_string_to_view(
+    const std_string_view<Char>& s) {
+  return {s.data(), s.size()};
+}
+}  // namespace internal
+
+inline namespace literals {
+#  if FMT_USE_UDL_TEMPLATE
+#    pragma GCC diagnostic push
+#    if FMT_CLANG_VERSION
+#      pragma GCC diagnostic ignored "-Wgnu-string-literal-operator-template"
+#    endif
+template <typename Char, Char... CHARS>
+FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format() {
+  return {};
+}
+#    pragma GCC diagnostic pop
+#  else
+/**
+  \rst
+  User-defined literal equivalent of :func:`fmt::format`.
+
+  **Example**::
+
+    using namespace fmt::literals;
+    std::string message = "The answer is {}"_format(42);
+  \endrst
+ */
+FMT_CONSTEXPR internal::udl_formatter<char> operator"" _format(const char* s,
+                                                               std::size_t n) {
+  return {{s, n}};
+}
+FMT_CONSTEXPR internal::udl_formatter<wchar_t> operator"" _format(
+    const wchar_t* s, std::size_t n) {
+  return {{s, n}};
+}
+#  endif  // FMT_USE_UDL_TEMPLATE
+
+/**
+  \rst
+  User-defined literal equivalent of :func:`fmt::arg`.
+
+  **Example**::
+
+    using namespace fmt::literals;
+    fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
+  \endrst
+ */
+FMT_CONSTEXPR internal::udl_arg<char> operator"" _a(const char* s,
+                                                    std::size_t n) {
+  return {{s, n}};
+}
+FMT_CONSTEXPR internal::udl_arg<wchar_t> operator"" _a(const wchar_t* s,
+                                                       std::size_t n) {
+  return {{s, n}};
+}
+}  // namespace literals
+#endif  // FMT_USE_USER_DEFINED_LITERALS
+FMT_END_NAMESPACE
+
+#define FMT_STRING_IMPL(s, ...)                                     \
+  [] {                                                              \
+    /* Use a macro-like name to avoid shadowing warnings. */        \
+    struct FMT_COMPILE_STRING : fmt::compile_string {               \
+      using char_type = fmt::remove_cvref_t<decltype(s[0])>;        \
+      FMT_MAYBE_UNUSED __VA_ARGS__ FMT_CONSTEXPR                    \
+      operator fmt::basic_string_view<char_type>() const {          \
+        return fmt::internal::compile_string_to_view<char_type>(s); \
+      }                                                             \
+    };                                                              \
+    return FMT_COMPILE_STRING();                                    \
+  }()
+
+/**
+  \rst
+  Constructs a compile-time format string from a string literal *s*.
+
+  **Example**::
+
+    // A compile-time error because 'd' is an invalid specifier for strings.
+    std::string s = format(FMT_STRING("{:d}"), "foo");
+  \endrst
+ */
+#define FMT_STRING(s) FMT_STRING_IMPL(s, )
+
+#if defined(FMT_STRING_ALIAS) && FMT_STRING_ALIAS
+#  define fmt(s) FMT_STRING_IMPL(s, [[deprecated]])
+#endif
+
+#ifdef FMT_HEADER_ONLY
+#  define FMT_FUNC inline
+#  include "format-inl.h"
+#else
+#  define FMT_FUNC
+#endif
+
+#endif  // FMT_FORMAT_H_
diff --git a/lib/fmt/fmt/locale.h b/lib/fmt/fmt/locale.h
new file mode 100644
index 0000000..70bc193
--- /dev/null
+++ b/lib/fmt/fmt/locale.h
@@ -0,0 +1,78 @@
+// Formatting library for C++ - std::locale support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_LOCALE_H_
+#define FMT_LOCALE_H_
+
+#include <locale>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+
+namespace internal {
+template <typename Char>
+typename buffer_context<Char>::iterator vformat_to(
+    const std::locale& loc, buffer<Char>& buf,
+    basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  using range = buffer_range<Char>;
+  return vformat_to<arg_formatter<range>>(buf, to_string_view(format_str), args,
+                                          internal::locale_ref(loc));
+}
+
+template <typename Char>
+std::basic_string<Char> vformat(
+    const std::locale& loc, basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buffer;
+  internal::vformat_to(loc, buffer, format_str, args);
+  return fmt::to_string(buffer);
+}
+}  // namespace internal
+
+template <typename S, typename Char = char_t<S>>
+inline std::basic_string<Char> vformat(
+    const std::locale& loc, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  return internal::vformat(loc, to_string_view(format_str), args);
+}
+
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline std::basic_string<Char> format(const std::locale& loc,
+                                      const S& format_str, Args&&... args) {
+  return internal::vformat(
+      loc, to_string_view(format_str),
+      internal::make_args_checked<Args...>(format_str, args...));
+}
+
+template <typename S, typename OutputIt, typename... Args,
+          typename Char = enable_if_t<
+              internal::is_output_iterator<OutputIt>::value, char_t<S>>>
+inline OutputIt vformat_to(
+    OutputIt out, const std::locale& loc, const S& format_str,
+    format_args_t<type_identity_t<OutputIt>, Char> args) {
+  using range = internal::output_range<OutputIt, Char>;
+  return vformat_to<arg_formatter<range>>(
+      range(out), to_string_view(format_str), args, internal::locale_ref(loc));
+}
+
+template <typename OutputIt, typename S, typename... Args,
+          FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value&&
+                            internal::is_string<S>::value)>
+inline OutputIt format_to(OutputIt out, const std::locale& loc,
+                          const S& format_str, Args&&... args) {
+  internal::check_format_string<Args...>(format_str);
+  using context = format_context_t<OutputIt, char_t<S>>;
+  format_arg_store<context, Args...> as{args...};
+  return vformat_to(out, loc, to_string_view(format_str),
+                    basic_format_args<context>(as));
+}
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_LOCALE_H_
diff --git a/lib/fmt/fmt/os.cc b/lib/fmt/fmt/os.cc
new file mode 100644
index 0000000..10a372a
--- /dev/null
+++ b/lib/fmt/fmt/os.cc
@@ -0,0 +1,316 @@
+// Formatting library for C++ - optional OS-specific functionality
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+// Disable bogus MSVC warnings.
+#if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER)
+#  define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "fmt/os.h"
+
+#include <climits>
+
+#if FMT_USE_FCNTL
+#  include <sys/stat.h>
+#  include <sys/types.h>
+
+#  ifndef _WIN32
+#    include <unistd.h>
+#  else
+#    ifndef WIN32_LEAN_AND_MEAN
+#      define WIN32_LEAN_AND_MEAN
+#    endif
+#    include <io.h>
+#    include <windows.h>
+
+#    define O_CREAT _O_CREAT
+#    define O_TRUNC _O_TRUNC
+
+#    ifndef S_IRUSR
+#      define S_IRUSR _S_IREAD
+#    endif
+
+#    ifndef S_IWUSR
+#      define S_IWUSR _S_IWRITE
+#    endif
+
+#    ifdef __MINGW32__
+#      define _SH_DENYNO 0x40
+#    endif
+#  endif  // _WIN32
+#endif    // FMT_USE_FCNTL
+
+#ifdef _WIN32
+#  include <windows.h>
+#endif
+
+#ifdef fileno
+#  undef fileno
+#endif
+
+namespace {
+#ifdef _WIN32
+// Return type of read and write functions.
+using RWResult = int;
+
+// On Windows the count argument to read and write is unsigned, so convert
+// it from size_t preventing integer overflow.
+inline unsigned convert_rwcount(std::size_t count) {
+  return count <= UINT_MAX ? static_cast<unsigned>(count) : UINT_MAX;
+}
+#else
+// Return type of read and write functions.
+using RWResult = ssize_t;
+
+inline std::size_t convert_rwcount(std::size_t count) { return count; }
+#endif
+}  // namespace
+
+FMT_BEGIN_NAMESPACE
+
+#ifdef _WIN32
+internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) {
+  if (int error_code = convert(s)) {
+    FMT_THROW(windows_error(error_code,
+                            "cannot convert string from UTF-16 to UTF-8"));
+  }
+}
+
+int internal::utf16_to_utf8::convert(wstring_view s) {
+  if (s.size() > INT_MAX) return ERROR_INVALID_PARAMETER;
+  int s_size = static_cast<int>(s.size());
+  if (s_size == 0) {
+    // WideCharToMultiByte does not support zero length, handle separately.
+    buffer_.resize(1);
+    buffer_[0] = 0;
+    return 0;
+  }
+
+  int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, nullptr, 0,
+                                   nullptr, nullptr);
+  if (length == 0) return GetLastError();
+  buffer_.resize(length + 1);
+  length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0],
+                               length, nullptr, nullptr);
+  if (length == 0) return GetLastError();
+  buffer_[length] = 0;
+  return 0;
+}
+
+void windows_error::init(int err_code, string_view format_str,
+                         format_args args) {
+  error_code_ = err_code;
+  memory_buffer buffer;
+  internal::format_windows_error(buffer, err_code, vformat(format_str, args));
+  std::runtime_error& base = *this;
+  base = std::runtime_error(to_string(buffer));
+}
+
+void internal::format_windows_error(internal::buffer<char>& out, int error_code,
+                                    string_view message) FMT_NOEXCEPT {
+  FMT_TRY {
+    wmemory_buffer buf;
+    buf.resize(inline_buffer_size);
+    for (;;) {
+      wchar_t* system_message = &buf[0];
+      int result = FormatMessageW(
+          FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr,
+          error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), system_message,
+          static_cast<uint32_t>(buf.size()), nullptr);
+      if (result != 0) {
+        utf16_to_utf8 utf8_message;
+        if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
+          internal::writer w(out);
+          w.write(message);
+          w.write(": ");
+          w.write(utf8_message);
+          return;
+        }
+        break;
+      }
+      if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+        break;  // Can't get error message, report error code instead.
+      buf.resize(buf.size() * 2);
+    }
+  }
+  FMT_CATCH(...) {}
+  format_error_code(out, error_code, message);
+}
+
+void report_windows_error(int error_code,
+                          fmt::string_view message) FMT_NOEXCEPT {
+  report_error(internal::format_windows_error, error_code, message);
+}
+#endif  // _WIN32
+
+buffered_file::~buffered_file() FMT_NOEXCEPT {
+  if (file_ && FMT_SYSTEM(fclose(file_)) != 0)
+    report_system_error(errno, "cannot close file");
+}
+
+buffered_file::buffered_file(cstring_view filename, cstring_view mode) {
+  FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())),
+                nullptr);
+  if (!file_)
+    FMT_THROW(system_error(errno, "cannot open file {}", filename.c_str()));
+}
+
+void buffered_file::close() {
+  if (!file_) return;
+  int result = FMT_SYSTEM(fclose(file_));
+  file_ = nullptr;
+  if (result != 0) FMT_THROW(system_error(errno, "cannot close file"));
+}
+
+// A macro used to prevent expansion of fileno on broken versions of MinGW.
+#define FMT_ARGS
+
+int buffered_file::fileno() const {
+  int fd = FMT_POSIX_CALL(fileno FMT_ARGS(file_));
+  if (fd == -1) FMT_THROW(system_error(errno, "cannot get file descriptor"));
+  return fd;
+}
+
+#if FMT_USE_FCNTL
+file::file(cstring_view path, int oflag) {
+  int mode = S_IRUSR | S_IWUSR;
+#  if defined(_WIN32) && !defined(__MINGW32__)
+  fd_ = -1;
+  FMT_POSIX_CALL(sopen_s(&fd_, path.c_str(), oflag, _SH_DENYNO, mode));
+#  else
+  FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, mode)));
+#  endif
+  if (fd_ == -1)
+    FMT_THROW(system_error(errno, "cannot open file {}", path.c_str()));
+}
+
+file::~file() FMT_NOEXCEPT {
+  // Don't retry close in case of EINTR!
+  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
+  if (fd_ != -1 && FMT_POSIX_CALL(close(fd_)) != 0)
+    report_system_error(errno, "cannot close file");
+}
+
+void file::close() {
+  if (fd_ == -1) return;
+  // Don't retry close in case of EINTR!
+  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
+  int result = FMT_POSIX_CALL(close(fd_));
+  fd_ = -1;
+  if (result != 0) FMT_THROW(system_error(errno, "cannot close file"));
+}
+
+long long file::size() const {
+#  ifdef _WIN32
+  // Use GetFileSize instead of GetFileSizeEx for the case when _WIN32_WINNT
+  // is less than 0x0500 as is the case with some default MinGW builds.
+  // Both functions support large file sizes.
+  DWORD size_upper = 0;
+  HANDLE handle = reinterpret_cast<HANDLE>(_get_osfhandle(fd_));
+  DWORD size_lower = FMT_SYSTEM(GetFileSize(handle, &size_upper));
+  if (size_lower == INVALID_FILE_SIZE) {
+    DWORD error = GetLastError();
+    if (error != NO_ERROR)
+      FMT_THROW(windows_error(GetLastError(), "cannot get file size"));
+  }
+  unsigned long long long_size = size_upper;
+  return (long_size << sizeof(DWORD) * CHAR_BIT) | size_lower;
+#  else
+  using Stat = struct stat;
+  Stat file_stat = Stat();
+  if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1)
+    FMT_THROW(system_error(errno, "cannot get file attributes"));
+  static_assert(sizeof(long long) >= sizeof(file_stat.st_size),
+                "return type of file::size is not large enough");
+  return file_stat.st_size;
+#  endif
+}
+
+std::size_t file::read(void* buffer, std::size_t count) {
+  RWResult result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
+  if (result < 0) FMT_THROW(system_error(errno, "cannot read from file"));
+  return internal::to_unsigned(result);
+}
+
+std::size_t file::write(const void* buffer, std::size_t count) {
+  RWResult result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count))));
+  if (result < 0) FMT_THROW(system_error(errno, "cannot write to file"));
+  return internal::to_unsigned(result);
+}
+
+file file::dup(int fd) {
+  // Don't retry as dup doesn't return EINTR.
+  // http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html
+  int new_fd = FMT_POSIX_CALL(dup(fd));
+  if (new_fd == -1)
+    FMT_THROW(system_error(errno, "cannot duplicate file descriptor {}", fd));
+  return file(new_fd);
+}
+
+void file::dup2(int fd) {
+  int result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
+  if (result == -1) {
+    FMT_THROW(system_error(errno, "cannot duplicate file descriptor {} to {}",
+                           fd_, fd));
+  }
+}
+
+void file::dup2(int fd, error_code& ec) FMT_NOEXCEPT {
+  int result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
+  if (result == -1) ec = error_code(errno);
+}
+
+void file::pipe(file& read_end, file& write_end) {
+  // Close the descriptors first to make sure that assignments don't throw
+  // and there are no leaks.
+  read_end.close();
+  write_end.close();
+  int fds[2] = {};
+#  ifdef _WIN32
+  // Make the default pipe capacity same as on Linux 2.6.11+.
+  enum { DEFAULT_CAPACITY = 65536 };
+  int result = FMT_POSIX_CALL(pipe(fds, DEFAULT_CAPACITY, _O_BINARY));
+#  else
+  // Don't retry as the pipe function doesn't return EINTR.
+  // http://pubs.opengroup.org/onlinepubs/009696799/functions/pipe.html
+  int result = FMT_POSIX_CALL(pipe(fds));
+#  endif
+  if (result != 0) FMT_THROW(system_error(errno, "cannot create pipe"));
+  // The following assignments don't throw because read_fd and write_fd
+  // are closed.
+  read_end = file(fds[0]);
+  write_end = file(fds[1]);
+}
+
+buffered_file file::fdopen(const char* mode) {
+  // Don't retry as fdopen doesn't return EINTR.
+  FILE* f = FMT_POSIX_CALL(fdopen(fd_, mode));
+  if (!f)
+    FMT_THROW(
+        system_error(errno, "cannot associate stream with file descriptor"));
+  buffered_file bf(f);
+  fd_ = -1;
+  return bf;
+}
+
+long getpagesize() {
+#  ifdef _WIN32
+  SYSTEM_INFO si;
+  GetSystemInfo(&si);
+  return si.dwPageSize;
+#  else
+  long size = FMT_POSIX_CALL(sysconf(_SC_PAGESIZE));
+  if (size < 0) FMT_THROW(system_error(errno, "cannot get memory page size"));
+  return size;
+#  endif
+}
+#endif  // FMT_USE_FCNTL
+FMT_END_NAMESPACE
diff --git a/lib/fmt/fmt/os.h b/lib/fmt/fmt/os.h
new file mode 100644
index 0000000..a1a0d03
--- /dev/null
+++ b/lib/fmt/fmt/os.h
@@ -0,0 +1,392 @@
+// Formatting library for C++ - optional OS-specific functionality
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_OS_H_
+#define FMT_OS_H_
+
+#if defined(__MINGW32__) || defined(__CYGWIN__)
+// Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/.
+#  undef __STRICT_ANSI__
+#endif
+
+#include <cerrno>
+#include <clocale>  // for locale_t
+#include <cstddef>
+#include <cstdio>
+#include <cstdlib>  // for strtod_l
+
+#if defined __APPLE__ || defined(__FreeBSD__)
+#  include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
+#endif
+
+#include "format.h"
+
+// UWP doesn't provide _pipe.
+#if FMT_HAS_INCLUDE("winapifamily.h")
+#  include <winapifamily.h>
+#endif
+#if FMT_HAS_INCLUDE("fcntl.h") && \
+    (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
+#  include <fcntl.h>  // for O_RDONLY
+#  define FMT_USE_FCNTL 1
+#else
+#  define FMT_USE_FCNTL 0
+#endif
+
+#ifndef FMT_POSIX
+#  if defined(_WIN32) && !defined(__MINGW32__)
+// Fix warnings about deprecated symbols.
+#    define FMT_POSIX(call) _##call
+#  else
+#    define FMT_POSIX(call) call
+#  endif
+#endif
+
+// Calls to system functions are wrapped in FMT_SYSTEM for testability.
+#ifdef FMT_SYSTEM
+#  define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
+#else
+#  define FMT_SYSTEM(call) call
+#  ifdef _WIN32
+// Fix warnings about deprecated symbols.
+#    define FMT_POSIX_CALL(call) ::_##call
+#  else
+#    define FMT_POSIX_CALL(call) ::call
+#  endif
+#endif
+
+// Retries the expression while it evaluates to error_result and errno
+// equals to EINTR.
+#ifndef _WIN32
+#  define FMT_RETRY_VAL(result, expression, error_result) \
+    do {                                                  \
+      (result) = (expression);                            \
+    } while ((result) == (error_result) && errno == EINTR)
+#else
+#  define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
+#endif
+
+#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
+
+FMT_BEGIN_NAMESPACE
+
+/**
+  \rst
+  A reference to a null-terminated string. It can be constructed from a C
+  string or ``std::string``.
+
+  You can use one of the following type aliases for common character types:
+
+  +---------------+-----------------------------+
+  | Type          | Definition                  |
+  +===============+=============================+
+  | cstring_view  | basic_cstring_view<char>    |
+  +---------------+-----------------------------+
+  | wcstring_view | basic_cstring_view<wchar_t> |
+  +---------------+-----------------------------+
+
+  This class is most useful as a parameter type to allow passing
+  different types of strings to a function, for example::
+
+    template <typename... Args>
+    std::string format(cstring_view format_str, const Args & ... args);
+
+    format("{}", 42);
+    format(std::string("{}"), 42);
+  \endrst
+ */
+template <typename Char> class basic_cstring_view {
+ private:
+  const Char* data_;
+
+ public:
+  /** Constructs a string reference object from a C string. */
+  basic_cstring_view(const Char* s) : data_(s) {}
+
+  /**
+    \rst
+    Constructs a string reference from an ``std::string`` object.
+    \endrst
+   */
+  basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {}
+
+  /** Returns the pointer to a C string. */
+  const Char* c_str() const { return data_; }
+};
+
+using cstring_view = basic_cstring_view<char>;
+using wcstring_view = basic_cstring_view<wchar_t>;
+
+// An error code.
+class error_code {
+ private:
+  int value_;
+
+ public:
+  explicit error_code(int value = 0) FMT_NOEXCEPT : value_(value) {}
+
+  int get() const FMT_NOEXCEPT { return value_; }
+};
+
+#ifdef _WIN32
+namespace internal {
+// A converter from UTF-16 to UTF-8.
+// It is only provided for Windows since other systems support UTF-8 natively.
+class utf16_to_utf8 {
+ private:
+  memory_buffer buffer_;
+
+ public:
+  utf16_to_utf8() {}
+  FMT_API explicit utf16_to_utf8(wstring_view s);
+  operator string_view() const { return string_view(&buffer_[0], size()); }
+  size_t size() const { return buffer_.size() - 1; }
+  const char* c_str() const { return &buffer_[0]; }
+  std::string str() const { return std::string(&buffer_[0], size()); }
+
+  // Performs conversion returning a system error code instead of
+  // throwing exception on conversion error. This method may still throw
+  // in case of memory allocation error.
+  FMT_API int convert(wstring_view s);
+};
+
+FMT_API void format_windows_error(buffer<char>& out, int error_code,
+                                  string_view message) FMT_NOEXCEPT;
+}  // namespace internal
+
+/** A Windows error. */
+class windows_error : public system_error {
+ private:
+  FMT_API void init(int error_code, string_view format_str, format_args args);
+
+ public:
+  /**
+   \rst
+   Constructs a :class:`fmt::windows_error` object with the description
+   of the form
+
+   .. parsed-literal::
+     *<message>*: *<system-message>*
+
+   where *<message>* is the formatted message and *<system-message>* is the
+   system message corresponding to the error code.
+   *error_code* is a Windows error code as given by ``GetLastError``.
+   If *error_code* is not a valid error code such as -1, the system message
+   will look like "error -1".
+
+   **Example**::
+
+     // This throws a windows_error with the description
+     //   cannot open file 'madeup': The system cannot find the file specified.
+     // or similar (system message may vary).
+     const char *filename = "madeup";
+     LPOFSTRUCT of = LPOFSTRUCT();
+     HFILE file = OpenFile(filename, &of, OF_READ);
+     if (file == HFILE_ERROR) {
+       throw fmt::windows_error(GetLastError(),
+                                "cannot open file '{}'", filename);
+     }
+   \endrst
+  */
+  template <typename... Args>
+  windows_error(int error_code, string_view message, const Args&... args) {
+    init(error_code, message, make_format_args(args...));
+  }
+};
+
+// Reports a Windows error without throwing an exception.
+// Can be used to report errors from destructors.
+FMT_API void report_windows_error(int error_code,
+                                  string_view message) FMT_NOEXCEPT;
+#endif  // _WIN32
+
+// A buffered file.
+class buffered_file {
+ private:
+  FILE* file_;
+
+  friend class file;
+
+  explicit buffered_file(FILE* f) : file_(f) {}
+
+ public:
+  buffered_file(const buffered_file&) = delete;
+  void operator=(const buffered_file&) = delete;
+
+  // Constructs a buffered_file object which doesn't represent any file.
+  buffered_file() FMT_NOEXCEPT : file_(nullptr) {}
+
+  // Destroys the object closing the file it represents if any.
+  FMT_API ~buffered_file() FMT_NOEXCEPT;
+
+ public:
+  buffered_file(buffered_file&& other) FMT_NOEXCEPT : file_(other.file_) {
+    other.file_ = nullptr;
+  }
+
+  buffered_file& operator=(buffered_file&& other) {
+    close();
+    file_ = other.file_;
+    other.file_ = nullptr;
+    return *this;
+  }
+
+  // Opens a file.
+  FMT_API buffered_file(cstring_view filename, cstring_view mode);
+
+  // Closes the file.
+  FMT_API void close();
+
+  // Returns the pointer to a FILE object representing this file.
+  FILE* get() const FMT_NOEXCEPT { return file_; }
+
+  // We place parentheses around fileno to workaround a bug in some versions
+  // of MinGW that define fileno as a macro.
+  FMT_API int(fileno)() const;
+
+  void vprint(string_view format_str, format_args args) {
+    fmt::vprint(file_, format_str, args);
+  }
+
+  template <typename... Args>
+  inline void print(string_view format_str, const Args&... args) {
+    vprint(format_str, make_format_args(args...));
+  }
+};
+
+#if FMT_USE_FCNTL
+// A file. Closed file is represented by a file object with descriptor -1.
+// Methods that are not declared with FMT_NOEXCEPT may throw
+// fmt::system_error in case of failure. Note that some errors such as
+// closing the file multiple times will cause a crash on Windows rather
+// than an exception. You can get standard behavior by overriding the
+// invalid parameter handler with _set_invalid_parameter_handler.
+class file {
+ private:
+  int fd_;  // File descriptor.
+
+  // Constructs a file object with a given descriptor.
+  explicit file(int fd) : fd_(fd) {}
+
+ public:
+  // Possible values for the oflag argument to the constructor.
+  enum {
+    RDONLY = FMT_POSIX(O_RDONLY),  // Open for reading only.
+    WRONLY = FMT_POSIX(O_WRONLY),  // Open for writing only.
+    RDWR = FMT_POSIX(O_RDWR)       // Open for reading and writing.
+  };
+
+  // Constructs a file object which doesn't represent any file.
+  file() FMT_NOEXCEPT : fd_(-1) {}
+
+  // Opens a file and constructs a file object representing this file.
+  FMT_API file(cstring_view path, int oflag);
+
+ public:
+  file(const file&) = delete;
+  void operator=(const file&) = delete;
+
+  file(file&& other) FMT_NOEXCEPT : fd_(other.fd_) { other.fd_ = -1; }
+
+  file& operator=(file&& other) FMT_NOEXCEPT {
+    close();
+    fd_ = other.fd_;
+    other.fd_ = -1;
+    return *this;
+  }
+
+  // Destroys the object closing the file it represents if any.
+  FMT_API ~file() FMT_NOEXCEPT;
+
+  // Returns the file descriptor.
+  int descriptor() const FMT_NOEXCEPT { return fd_; }
+
+  // Closes the file.
+  FMT_API void close();
+
+  // Returns the file size. The size has signed type for consistency with
+  // stat::st_size.
+  FMT_API long long size() const;
+
+  // Attempts to read count bytes from the file into the specified buffer.
+  FMT_API std::size_t read(void* buffer, std::size_t count);
+
+  // Attempts to write count bytes from the specified buffer to the file.
+  FMT_API std::size_t write(const void* buffer, std::size_t count);
+
+  // Duplicates a file descriptor with the dup function and returns
+  // the duplicate as a file object.
+  FMT_API static file dup(int fd);
+
+  // Makes fd be the copy of this file descriptor, closing fd first if
+  // necessary.
+  FMT_API void dup2(int fd);
+
+  // Makes fd be the copy of this file descriptor, closing fd first if
+  // necessary.
+  FMT_API void dup2(int fd, error_code& ec) FMT_NOEXCEPT;
+
+  // Creates a pipe setting up read_end and write_end file objects for reading
+  // and writing respectively.
+  FMT_API static void pipe(file& read_end, file& write_end);
+
+  // Creates a buffered_file object associated with this file and detaches
+  // this file object from the file.
+  FMT_API buffered_file fdopen(const char* mode);
+};
+
+// Returns the memory page size.
+long getpagesize();
+#endif  // FMT_USE_FCNTL
+
+#ifdef FMT_LOCALE
+// A "C" numeric locale.
+class locale {
+ private:
+#  ifdef _WIN32
+  using locale_t = _locale_t;
+
+  static void freelocale(locale_t loc) { _free_locale(loc); }
+
+  static double strtod_l(const char* nptr, char** endptr, _locale_t loc) {
+    return _strtod_l(nptr, endptr, loc);
+  }
+#  endif
+
+  locale_t locale_;
+
+ public:
+  using type = locale_t;
+  locale(const locale&) = delete;
+  void operator=(const locale&) = delete;
+
+  locale() {
+#  ifndef _WIN32
+    locale_ = FMT_SYSTEM(newlocale(LC_NUMERIC_MASK, "C", nullptr));
+#  else
+    locale_ = _create_locale(LC_NUMERIC, "C");
+#  endif
+    if (!locale_) FMT_THROW(system_error(errno, "cannot create locale"));
+  }
+  ~locale() { freelocale(locale_); }
+
+  type get() const { return locale_; }
+
+  // Converts string to floating-point number and advances str past the end
+  // of the parsed input.
+  double strtod(const char*& str) const {
+    char* end = nullptr;
+    double result = strtod_l(str, &end, locale_);
+    str = end;
+    return result;
+  }
+};
+using Locale FMT_DEPRECATED_ALIAS = locale;
+#endif  // FMT_LOCALE
+FMT_END_NAMESPACE
+
+#endif  // FMT_OS_H_
diff --git a/lib/fmt/fmt/ostream.h b/lib/fmt/fmt/ostream.h
new file mode 100644
index 0000000..c483153
--- /dev/null
+++ b/lib/fmt/fmt/ostream.h
@@ -0,0 +1,143 @@
+// Formatting library for C++ - std::ostream support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_OSTREAM_H_
+#define FMT_OSTREAM_H_
+
+#include <ostream>
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace internal {
+
+template <class Char> class formatbuf : public std::basic_streambuf<Char> {
+ private:
+  using int_type = typename std::basic_streambuf<Char>::int_type;
+  using traits_type = typename std::basic_streambuf<Char>::traits_type;
+
+  buffer<Char>& buffer_;
+
+ public:
+  formatbuf(buffer<Char>& buf) : buffer_(buf) {}
+
+ protected:
+  // The put-area is actually always empty. This makes the implementation
+  // simpler and has the advantage that the streambuf and the buffer are always
+  // in sync and sputc never writes into uninitialized memory. The obvious
+  // disadvantage is that each call to sputc always results in a (virtual) call
+  // to overflow. There is no disadvantage here for sputn since this always
+  // results in a call to xsputn.
+
+  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
+    if (!traits_type::eq_int_type(ch, traits_type::eof()))
+      buffer_.push_back(static_cast<Char>(ch));
+    return ch;
+  }
+
+  std::streamsize xsputn(const Char* s, std::streamsize count) FMT_OVERRIDE {
+    buffer_.append(s, s + count);
+    return count;
+  }
+};
+
+template <typename Char> struct test_stream : std::basic_ostream<Char> {
+ private:
+  // Hide all operator<< from std::basic_ostream<Char>.
+  void_t<> operator<<(null<>);
+  void_t<> operator<<(const Char*);
+
+  template <typename T, FMT_ENABLE_IF(std::is_convertible<T, int>::value &&
+                                      !std::is_enum<T>::value)>
+  void_t<> operator<<(T);
+};
+
+// Checks if T has a user-defined operator<< (e.g. not a member of
+// std::ostream).
+template <typename T, typename Char> class is_streamable {
+ private:
+  template <typename U>
+  static bool_constant<!std::is_same<decltype(std::declval<test_stream<Char>&>()
+                                              << std::declval<U>()),
+                                     void_t<>>::value>
+  test(int);
+
+  template <typename> static std::false_type test(...);
+
+  using result = decltype(test<T>(0));
+
+ public:
+  static const bool value = result::value;
+};
+
+// Write the content of buf to os.
+template <typename Char>
+void write(std::basic_ostream<Char>& os, buffer<Char>& buf) {
+  const Char* buf_data = buf.data();
+  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
+  unsigned_streamsize size = buf.size();
+  unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
+  do {
+    unsigned_streamsize n = size <= max_size ? size : max_size;
+    os.write(buf_data, static_cast<std::streamsize>(n));
+    buf_data += n;
+    size -= n;
+  } while (size != 0);
+}
+
+template <typename Char, typename T>
+void format_value(buffer<Char>& buf, const T& value,
+                  locale_ref loc = locale_ref()) {
+  formatbuf<Char> format_buf(buf);
+  std::basic_ostream<Char> output(&format_buf);
+  #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
+  if (loc) output.imbue(loc.get<std::locale>());
+  #endif
+  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+  output << value;
+  buf.resize(buf.size());
+}
+
+// Formats an object of type T that has an overloaded ostream operator<<.
+template <typename T, typename Char>
+struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
+    : formatter<basic_string_view<Char>, Char> {
+  template <typename Context>
+  auto format(const T& value, Context& ctx) -> decltype(ctx.out()) {
+    basic_memory_buffer<Char> buffer;
+    format_value(buffer, value, ctx.locale());
+    basic_string_view<Char> str(buffer.data(), buffer.size());
+    return formatter<basic_string_view<Char>, Char>::format(str, ctx);
+  }
+};
+}  // namespace internal
+
+template <typename Char>
+void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
+            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buffer;
+  internal::vformat_to(buffer, format_str, args);
+  internal::write(os, buffer);
+}
+
+/**
+  \rst
+  Prints formatted data to the stream *os*.
+
+  **Example**::
+
+    fmt::print(cerr, "Don't {}!", "panic");
+  \endrst
+ */
+template <typename S, typename... Args,
+          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
+void print(std::basic_ostream<Char>& os, const S& format_str, Args&&... args) {
+  vprint(os, to_string_view(format_str),
+         internal::make_args_checked<Args...>(format_str, args...));
+}
+FMT_END_NAMESPACE
+
+#endif  // FMT_OSTREAM_H_
diff --git a/lib/fmt/fmt/posix.h b/lib/fmt/fmt/posix.h
new file mode 100644
index 0000000..0e7bc64
--- /dev/null
+++ b/lib/fmt/fmt/posix.h
@@ -0,0 +1,2 @@
+#include "os.h"
+#warning "fmt/posix.h is deprecated; use fmt/os.h instead"
\ No newline at end of file
diff --git a/lib/fmt/fmt/printf.h b/lib/fmt/fmt/printf.h
new file mode 100644
index 0000000..a790228
--- /dev/null
+++ b/lib/fmt/fmt/printf.h
@@ -0,0 +1,721 @@
+// Formatting library for C++ - legacy printf implementation
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_PRINTF_H_
+#define FMT_PRINTF_H_
+
+#include <algorithm>  // std::max
+#include <limits>     // std::numeric_limits
+
+#include "ostream.h"
+
+FMT_BEGIN_NAMESPACE
+namespace internal {
+
+// Checks if a value fits in int - used to avoid warnings about comparing
+// signed and unsigned integers.
+template <bool IsSigned> struct int_checker {
+  template <typename T> static bool fits_in_int(T value) {
+    unsigned max = max_value<int>();
+    return value <= max;
+  }
+  static bool fits_in_int(bool) { return true; }
+};
+
+template <> struct int_checker<true> {
+  template <typename T> static bool fits_in_int(T value) {
+    return value >= (std::numeric_limits<int>::min)() &&
+           value <= max_value<int>();
+  }
+  static bool fits_in_int(int) { return true; }
+};
+
+class printf_precision_handler {
+ public:
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  int operator()(T value) {
+    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
+      FMT_THROW(format_error("number is too big"));
+    return (std::max)(static_cast<int>(value), 0);
+  }
+
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  int operator()(T) {
+    FMT_THROW(format_error("precision is not integer"));
+    return 0;
+  }
+};
+
+// An argument visitor that returns true iff arg is a zero integer.
+class is_zero_int {
+ public:
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  bool operator()(T value) {
+    return value == 0;
+  }
+
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  bool operator()(T) {
+    return false;
+  }
+};
+
+template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
+
+template <> struct make_unsigned_or_bool<bool> { using type = bool; };
+
+template <typename T, typename Context> class arg_converter {
+ private:
+  using char_type = typename Context::char_type;
+
+  basic_format_arg<Context>& arg_;
+  char_type type_;
+
+ public:
+  arg_converter(basic_format_arg<Context>& arg, char_type type)
+      : arg_(arg), type_(type) {}
+
+  void operator()(bool value) {
+    if (type_ != 's') operator()<bool>(value);
+  }
+
+  template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)>
+  void operator()(U value) {
+    bool is_signed = type_ == 'd' || type_ == 'i';
+    using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
+    if (const_check(sizeof(target_type) <= sizeof(int))) {
+      // Extra casts are used to silence warnings.
+      if (is_signed) {
+        arg_ = internal::make_arg<Context>(
+            static_cast<int>(static_cast<target_type>(value)));
+      } else {
+        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
+        arg_ = internal::make_arg<Context>(
+            static_cast<unsigned>(static_cast<unsigned_type>(value)));
+      }
+    } else {
+      if (is_signed) {
+        // glibc's printf doesn't sign extend arguments of smaller types:
+        //   std::printf("%lld", -42);  // prints "4294967254"
+        // but we don't have to do the same because it's a UB.
+        arg_ = internal::make_arg<Context>(static_cast<long long>(value));
+      } else {
+        arg_ = internal::make_arg<Context>(
+            static_cast<typename make_unsigned_or_bool<U>::type>(value));
+      }
+    }
+  }
+
+  template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
+  void operator()(U) {}  // No conversion needed for non-integral types.
+};
+
+// Converts an integer argument to T for printf, if T is an integral type.
+// If T is void, the argument is converted to corresponding signed or unsigned
+// type depending on the type specifier: 'd' and 'i' - signed, other -
+// unsigned).
+template <typename T, typename Context, typename Char>
+void convert_arg(basic_format_arg<Context>& arg, Char type) {
+  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
+}
+
+// Converts an integer argument to char for printf.
+template <typename Context> class char_converter {
+ private:
+  basic_format_arg<Context>& arg_;
+
+ public:
+  explicit char_converter(basic_format_arg<Context>& arg) : arg_(arg) {}
+
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  void operator()(T value) {
+    arg_ = internal::make_arg<Context>(
+        static_cast<typename Context::char_type>(value));
+  }
+
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  void operator()(T) {}  // No conversion needed for non-integral types.
+};
+
+// Checks if an argument is a valid printf width specifier and sets
+// left alignment if it is negative.
+template <typename Char> class printf_width_handler {
+ private:
+  using format_specs = basic_format_specs<Char>;
+
+  format_specs& specs_;
+
+ public:
+  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
+
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  unsigned operator()(T value) {
+    auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
+    if (internal::is_negative(value)) {
+      specs_.align = align::left;
+      width = 0 - width;
+    }
+    unsigned int_max = max_value<int>();
+    if (width > int_max) FMT_THROW(format_error("number is too big"));
+    return static_cast<unsigned>(width);
+  }
+
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  unsigned operator()(T) {
+    FMT_THROW(format_error("width is not integer"));
+    return 0;
+  }
+};
+
+template <typename Char, typename Context>
+void printf(buffer<Char>& buf, basic_string_view<Char> format,
+            basic_format_args<Context> args) {
+  Context(std::back_inserter(buf), format, args).format();
+}
+
+template <typename OutputIt, typename Char, typename Context>
+internal::truncating_iterator<OutputIt> printf(
+    internal::truncating_iterator<OutputIt> it, basic_string_view<Char> format,
+    basic_format_args<Context> args) {
+  return Context(it, format, args).format();
+}
+}  // namespace internal
+
+using internal::printf;  // For printing into memory_buffer.
+
+template <typename Range> class printf_arg_formatter;
+
+template <typename OutputIt, typename Char> class basic_printf_context;
+
+/**
+  \rst
+  The ``printf`` argument formatter.
+  \endrst
+ */
+template <typename Range>
+class printf_arg_formatter : public internal::arg_formatter_base<Range> {
+ public:
+  using iterator = typename Range::iterator;
+
+ private:
+  using char_type = typename Range::value_type;
+  using base = internal::arg_formatter_base<Range>;
+  using context_type = basic_printf_context<iterator, char_type>;
+
+  context_type& context_;
+
+  void write_null_pointer(char) {
+    this->specs()->type = 0;
+    this->write("(nil)");
+  }
+
+  void write_null_pointer(wchar_t) {
+    this->specs()->type = 0;
+    this->write(L"(nil)");
+  }
+
+ public:
+  using format_specs = typename base::format_specs;
+
+  /**
+    \rst
+    Constructs an argument formatter object.
+    *buffer* is a reference to the output buffer and *specs* contains format
+    specifier information for standard argument types.
+    \endrst
+   */
+  printf_arg_formatter(iterator iter, format_specs& specs, context_type& ctx)
+      : base(Range(iter), &specs, internal::locale_ref()), context_(ctx) {}
+
+  template <typename T, FMT_ENABLE_IF(fmt::internal::is_integral<T>::value)>
+  iterator operator()(T value) {
+    // MSVC2013 fails to compile separate overloads for bool and char_type so
+    // use std::is_same instead.
+    if (std::is_same<T, bool>::value) {
+      format_specs& fmt_specs = *this->specs();
+      if (fmt_specs.type != 's') return base::operator()(value ? 1 : 0);
+      fmt_specs.type = 0;
+      this->write(value != 0);
+    } else if (std::is_same<T, char_type>::value) {
+      format_specs& fmt_specs = *this->specs();
+      if (fmt_specs.type && fmt_specs.type != 'c')
+        return (*this)(static_cast<int>(value));
+      fmt_specs.sign = sign::none;
+      fmt_specs.alt = false;
+      fmt_specs.align = align::right;
+      return base::operator()(value);
+    } else {
+      return base::operator()(value);
+    }
+    return this->out();
+  }
+
+  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+  iterator operator()(T value) {
+    return base::operator()(value);
+  }
+
+  /** Formats a null-terminated C string. */
+  iterator operator()(const char* value) {
+    if (value)
+      base::operator()(value);
+    else if (this->specs()->type == 'p')
+      write_null_pointer(char_type());
+    else
+      this->write("(null)");
+    return this->out();
+  }
+
+  /** Formats a null-terminated wide C string. */
+  iterator operator()(const wchar_t* value) {
+    if (value)
+      base::operator()(value);
+    else if (this->specs()->type == 'p')
+      write_null_pointer(char_type());
+    else
+      this->write(L"(null)");
+    return this->out();
+  }
+
+  iterator operator()(basic_string_view<char_type> value) {
+    return base::operator()(value);
+  }
+
+  iterator operator()(monostate value) { return base::operator()(value); }
+
+  /** Formats a pointer. */
+  iterator operator()(const void* value) {
+    if (value) return base::operator()(value);
+    this->specs()->type = 0;
+    write_null_pointer(char_type());
+    return this->out();
+  }
+
+  /** Formats an argument of a custom (user-defined) type. */
+  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
+    handle.format(context_.parse_context(), context_);
+    return this->out();
+  }
+};
+
+template <typename T> struct printf_formatter {
+  printf_formatter() = delete;
+
+  template <typename ParseContext>
+  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const T& value, FormatContext& ctx) -> decltype(ctx.out()) {
+    internal::format_value(internal::get_container(ctx.out()), value);
+    return ctx.out();
+  }
+};
+
+/** This template formats data and writes the output to a writer. */
+template <typename OutputIt, typename Char> class basic_printf_context {
+ public:
+  /** The character type for the output. */
+  using char_type = Char;
+  using iterator = OutputIt;
+  using format_arg = basic_format_arg<basic_printf_context>;
+  template <typename T> using formatter_type = printf_formatter<T>;
+
+ private:
+  using format_specs = basic_format_specs<char_type>;
+
+  OutputIt out_;
+  basic_format_args<basic_printf_context> args_;
+  basic_format_parse_context<Char> parse_ctx_;
+
+  static void parse_flags(format_specs& specs, const Char*& it,
+                          const Char* end);
+
+  // Returns the argument with specified index or, if arg_index is -1, the next
+  // argument.
+  format_arg get_arg(int arg_index = -1);
+
+  // Parses argument index, flags and width and returns the argument index.
+  int parse_header(const Char*& it, const Char* end, format_specs& specs);
+
+ public:
+  /**
+   \rst
+   Constructs a ``printf_context`` object. References to the arguments and
+   the writer are stored in the context object so make sure they have
+   appropriate lifetimes.
+   \endrst
+   */
+  basic_printf_context(OutputIt out, basic_string_view<char_type> format_str,
+                       basic_format_args<basic_printf_context> args)
+      : out_(out), args_(args), parse_ctx_(format_str) {}
+
+  OutputIt out() { return out_; }
+  void advance_to(OutputIt it) { out_ = it; }
+
+  internal::locale_ref locale() { return {}; }
+
+  format_arg arg(int id) const { return args_.get(id); }
+
+  basic_format_parse_context<Char>& parse_context() { return parse_ctx_; }
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    parse_ctx_.on_error(message);
+  }
+
+  /** Formats stored arguments and writes the output to the range. */
+  template <typename ArgFormatter = printf_arg_formatter<buffer_range<Char>>>
+  OutputIt format();
+};
+
+template <typename OutputIt, typename Char>
+void basic_printf_context<OutputIt, Char>::parse_flags(format_specs& specs,
+                                                       const Char*& it,
+                                                       const Char* end) {
+  for (; it != end; ++it) {
+    switch (*it) {
+    case '-':
+      specs.align = align::left;
+      break;
+    case '+':
+      specs.sign = sign::plus;
+      break;
+    case '0':
+      specs.fill[0] = '0';
+      break;
+    case ' ':
+      specs.sign = sign::space;
+      break;
+    case '#':
+      specs.alt = true;
+      break;
+    default:
+      return;
+    }
+  }
+}
+
+template <typename OutputIt, typename Char>
+typename basic_printf_context<OutputIt, Char>::format_arg
+basic_printf_context<OutputIt, Char>::get_arg(int arg_index) {
+  if (arg_index < 0)
+    arg_index = parse_ctx_.next_arg_id();
+  else
+    parse_ctx_.check_arg_id(--arg_index);
+  return internal::get_arg(*this, arg_index);
+}
+
+template <typename OutputIt, typename Char>
+int basic_printf_context<OutputIt, Char>::parse_header(const Char*& it,
+                                                       const Char* end,
+                                                       format_specs& specs) {
+  int arg_index = -1;
+  char_type c = *it;
+  if (c >= '0' && c <= '9') {
+    // Parse an argument index (if followed by '$') or a width possibly
+    // preceded with '0' flag(s).
+    internal::error_handler eh;
+    int value = parse_nonnegative_int(it, end, eh);
+    if (it != end && *it == '$') {  // value is an argument index
+      ++it;
+      arg_index = value;
+    } else {
+      if (c == '0') specs.fill[0] = '0';
+      if (value != 0) {
+        // Nonzero value means that we parsed width and don't need to
+        // parse it or flags again, so return now.
+        specs.width = value;
+        return arg_index;
+      }
+    }
+  }
+  parse_flags(specs, it, end);
+  // Parse width.
+  if (it != end) {
+    if (*it >= '0' && *it <= '9') {
+      internal::error_handler eh;
+      specs.width = parse_nonnegative_int(it, end, eh);
+    } else if (*it == '*') {
+      ++it;
+      specs.width = static_cast<int>(visit_format_arg(
+          internal::printf_width_handler<char_type>(specs), get_arg()));
+    }
+  }
+  return arg_index;
+}
+
+template <typename OutputIt, typename Char>
+template <typename ArgFormatter>
+OutputIt basic_printf_context<OutputIt, Char>::format() {
+  auto out = this->out();
+  const Char* start = parse_ctx_.begin();
+  const Char* end = parse_ctx_.end();
+  auto it = start;
+  while (it != end) {
+    char_type c = *it++;
+    if (c != '%') continue;
+    if (it != end && *it == c) {
+      out = std::copy(start, it, out);
+      start = ++it;
+      continue;
+    }
+    out = std::copy(start, it - 1, out);
+
+    format_specs specs;
+    specs.align = align::right;
+
+    // Parse argument index, flags and width.
+    int arg_index = parse_header(it, end, specs);
+    if (arg_index == 0) on_error("argument index out of range");
+
+    // Parse precision.
+    if (it != end && *it == '.') {
+      ++it;
+      c = it != end ? *it : 0;
+      if ('0' <= c && c <= '9') {
+        internal::error_handler eh;
+        specs.precision = parse_nonnegative_int(it, end, eh);
+      } else if (c == '*') {
+        ++it;
+        specs.precision = static_cast<int>(
+            visit_format_arg(internal::printf_precision_handler(), get_arg()));
+      } else {
+        specs.precision = 0;
+      }
+    }
+
+    format_arg arg = get_arg(arg_index);
+    if (specs.alt && visit_format_arg(internal::is_zero_int(), arg))
+      specs.alt = false;
+    if (specs.fill[0] == '0') {
+      if (arg.is_arithmetic())
+        specs.align = align::numeric;
+      else
+        specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types.
+    }
+
+    // Parse length and convert the argument to the required type.
+    c = it != end ? *it++ : 0;
+    char_type t = it != end ? *it : 0;
+    using internal::convert_arg;
+    switch (c) {
+    case 'h':
+      if (t == 'h') {
+        ++it;
+        t = it != end ? *it : 0;
+        convert_arg<signed char>(arg, t);
+      } else {
+        convert_arg<short>(arg, t);
+      }
+      break;
+    case 'l':
+      if (t == 'l') {
+        ++it;
+        t = it != end ? *it : 0;
+        convert_arg<long long>(arg, t);
+      } else {
+        convert_arg<long>(arg, t);
+      }
+      break;
+    case 'j':
+      convert_arg<intmax_t>(arg, t);
+      break;
+    case 'z':
+      convert_arg<std::size_t>(arg, t);
+      break;
+    case 't':
+      convert_arg<std::ptrdiff_t>(arg, t);
+      break;
+    case 'L':
+      // printf produces garbage when 'L' is omitted for long double, no
+      // need to do the same.
+      break;
+    default:
+      --it;
+      convert_arg<void>(arg, c);
+    }
+
+    // Parse type.
+    if (it == end) FMT_THROW(format_error("invalid format string"));
+    specs.type = static_cast<char>(*it++);
+    if (arg.is_integral()) {
+      // Normalize type.
+      switch (specs.type) {
+      case 'i':
+      case 'u':
+        specs.type = 'd';
+        break;
+      case 'c':
+        visit_format_arg(internal::char_converter<basic_printf_context>(arg),
+                         arg);
+        break;
+      }
+    }
+
+    start = it;
+
+    // Format argument.
+    visit_format_arg(ArgFormatter(out, specs, *this), arg);
+  }
+  return std::copy(start, it, out);
+}
+
+template <typename Char>
+using basic_printf_context_t =
+    basic_printf_context<std::back_insert_iterator<internal::buffer<Char>>,
+                         Char>;
+
+using printf_context = basic_printf_context_t<char>;
+using wprintf_context = basic_printf_context_t<wchar_t>;
+
+using printf_args = basic_format_args<printf_context>;
+using wprintf_args = basic_format_args<wprintf_context>;
+
+/**
+  \rst
+  Constructs an `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::printf_args`.
+  \endrst
+ */
+template <typename... Args>
+inline format_arg_store<printf_context, Args...> make_printf_args(
+    const Args&... args) {
+  return {args...};
+}
+
+/**
+  \rst
+  Constructs an `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::wprintf_args`.
+  \endrst
+ */
+template <typename... Args>
+inline format_arg_store<wprintf_context, Args...> make_wprintf_args(
+    const Args&... args) {
+  return {args...};
+}
+
+template <typename S, typename Char = char_t<S>>
+inline std::basic_string<Char> vsprintf(
+    const S& format,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buffer;
+  printf(buffer, to_string_view(format), args);
+  return to_string(buffer);
+}
+
+/**
+  \rst
+  Formats arguments and returns the result as a string.
+
+  **Example**::
+
+    std::string message = fmt::sprintf("The answer is %d", 42);
+  \endrst
+*/
+template <typename S, typename... Args,
+          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
+inline std::basic_string<Char> sprintf(const S& format, const Args&... args) {
+  using context = basic_printf_context_t<Char>;
+  return vsprintf(to_string_view(format), make_format_args<context>(args...));
+}
+
+template <typename S, typename Char = char_t<S>>
+inline int vfprintf(
+    std::FILE* f, const S& format,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buffer;
+  printf(buffer, to_string_view(format), args);
+  std::size_t size = buffer.size();
+  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
+             ? -1
+             : static_cast<int>(size);
+}
+
+/**
+  \rst
+  Prints formatted data to the file *f*.
+
+  **Example**::
+
+    fmt::fprintf(stderr, "Don't %s!", "panic");
+  \endrst
+ */
+template <typename S, typename... Args,
+          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
+inline int fprintf(std::FILE* f, const S& format, const Args&... args) {
+  using context = basic_printf_context_t<Char>;
+  return vfprintf(f, to_string_view(format),
+                  make_format_args<context>(args...));
+}
+
+template <typename S, typename Char = char_t<S>>
+inline int vprintf(
+    const S& format,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) {
+  return vfprintf(stdout, to_string_view(format), args);
+}
+
+/**
+  \rst
+  Prints formatted data to ``stdout``.
+
+  **Example**::
+
+    fmt::printf("Elapsed time: %.2f seconds", 1.23);
+  \endrst
+ */
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(internal::is_string<S>::value)>
+inline int printf(const S& format_str, const Args&... args) {
+  using context = basic_printf_context_t<char_t<S>>;
+  return vprintf(to_string_view(format_str),
+                 make_format_args<context>(args...));
+}
+
+template <typename S, typename Char = char_t<S>>
+inline int vfprintf(
+    std::basic_ostream<Char>& os, const S& format,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buffer;
+  printf(buffer, to_string_view(format), args);
+  internal::write(os, buffer);
+  return static_cast<int>(buffer.size());
+}
+
+/** Formats arguments and writes the output to the range. */
+template <typename ArgFormatter, typename Char,
+          typename Context =
+              basic_printf_context<typename ArgFormatter::iterator, Char>>
+typename ArgFormatter::iterator vprintf(
+    internal::buffer<Char>& out, basic_string_view<Char> format_str,
+    basic_format_args<type_identity_t<Context>> args) {
+  typename ArgFormatter::iterator iter(out);
+  Context(iter, format_str, args).template format<ArgFormatter>();
+  return iter;
+}
+
+/**
+  \rst
+  Prints formatted data to the stream *os*.
+
+  **Example**::
+
+    fmt::fprintf(cerr, "Don't %s!", "panic");
+  \endrst
+ */
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline int fprintf(std::basic_ostream<Char>& os, const S& format_str,
+                   const Args&... args) {
+  using context = basic_printf_context_t<Char>;
+  return vfprintf(os, to_string_view(format_str),
+                  make_format_args<context>(args...));
+}
+FMT_END_NAMESPACE
+
+#endif  // FMT_PRINTF_H_
diff --git a/lib/fmt/fmt/ranges.h b/lib/fmt/fmt/ranges.h
new file mode 100644
index 0000000..f8f9adb
--- /dev/null
+++ b/lib/fmt/fmt/ranges.h
@@ -0,0 +1,387 @@
+// Formatting library for C++ - experimental range support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+//
+// Copyright (c) 2018 - present, Remotion (Igor Schulz)
+// All Rights Reserved
+// {fmt} support for ranges, containers and types tuple interface.
+
+#ifndef FMT_RANGES_H_
+#define FMT_RANGES_H_
+
+#include <initializer_list>
+#include <type_traits>
+
+#include "format.h"
+
+// output only up to N items from the range.
+#ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT
+#  define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
+#endif
+
+FMT_BEGIN_NAMESPACE
+
+template <typename Char> struct formatting_base {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+};
+
+template <typename Char, typename Enable = void>
+struct formatting_range : formatting_base<Char> {
+  static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
+      FMT_RANGE_OUTPUT_LENGTH_LIMIT;  // output only up to N items from the
+                                      // range.
+  Char prefix;
+  Char delimiter;
+  Char postfix;
+  formatting_range() : prefix('{'), delimiter(','), postfix('}') {}
+  static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
+  static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
+};
+
+template <typename Char, typename Enable = void>
+struct formatting_tuple : formatting_base<Char> {
+  Char prefix;
+  Char delimiter;
+  Char postfix;
+  formatting_tuple() : prefix('('), delimiter(','), postfix(')') {}
+  static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
+  static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
+};
+
+namespace internal {
+
+template <typename RangeT, typename OutputIterator>
+OutputIterator copy(const RangeT& range, OutputIterator out) {
+  for (auto it = range.begin(), end = range.end(); it != end; ++it)
+    *out++ = *it;
+  return out;
+}
+
+template <typename OutputIterator>
+OutputIterator copy(const char* str, OutputIterator out) {
+  while (*str) *out++ = *str++;
+  return out;
+}
+
+template <typename OutputIterator>
+OutputIterator copy(char ch, OutputIterator out) {
+  *out++ = ch;
+  return out;
+}
+
+/// Return true value if T has std::string interface, like std::string_view.
+template <typename T> class is_like_std_string {
+  template <typename U>
+  static auto check(U* p)
+      -> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
+  template <typename> static void check(...);
+
+ public:
+  static FMT_CONSTEXPR_DECL const bool value =
+      is_string<T>::value || !std::is_void<decltype(check<T>(nullptr))>::value;
+};
+
+template <typename Char>
+struct is_like_std_string<fmt::basic_string_view<Char>> : std::true_type {};
+
+template <typename... Ts> struct conditional_helper {};
+
+template <typename T, typename _ = void> struct is_range_ : std::false_type {};
+
+#if !FMT_MSC_VER || FMT_MSC_VER > 1800
+template <typename T>
+struct is_range_<
+    T, conditional_t<false,
+                     conditional_helper<decltype(std::declval<T>().begin()),
+                                        decltype(std::declval<T>().end())>,
+                     void>> : std::true_type {};
+#endif
+
+/// tuple_size and tuple_element check.
+template <typename T> class is_tuple_like_ {
+  template <typename U>
+  static auto check(U* p) -> decltype(std::tuple_size<U>::value, int());
+  template <typename> static void check(...);
+
+ public:
+  static FMT_CONSTEXPR_DECL const bool value =
+      !std::is_void<decltype(check<T>(nullptr))>::value;
+};
+
+// Check for integer_sequence
+#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900
+template <typename T, T... N>
+using integer_sequence = std::integer_sequence<T, N...>;
+template <std::size_t... N> using index_sequence = std::index_sequence<N...>;
+template <std::size_t N>
+using make_index_sequence = std::make_index_sequence<N>;
+#else
+template <typename T, T... N> struct integer_sequence {
+  using value_type = T;
+
+  static FMT_CONSTEXPR std::size_t size() { return sizeof...(N); }
+};
+
+template <std::size_t... N>
+using index_sequence = integer_sequence<std::size_t, N...>;
+
+template <typename T, std::size_t N, T... Ns>
+struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
+template <typename T, T... Ns>
+struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
+
+template <std::size_t N>
+using make_index_sequence = make_integer_sequence<std::size_t, N>;
+#endif
+
+template <class Tuple, class F, size_t... Is>
+void for_each(index_sequence<Is...>, Tuple&& tup, F&& f) FMT_NOEXCEPT {
+  using std::get;
+  // using free function get<I>(T) now.
+  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
+  (void)_;  // blocks warnings
+}
+
+template <class T>
+FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
+    T const&) {
+  return {};
+}
+
+template <class Tuple, class F> void for_each(Tuple&& tup, F&& f) {
+  const auto indexes = get_indexes(tup);
+  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
+}
+
+template <typename Arg, FMT_ENABLE_IF(!is_like_std_string<
+                                      typename std::decay<Arg>::type>::value)>
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&) {
+  return add_space ? " {}" : "{}";
+}
+
+template <typename Arg, FMT_ENABLE_IF(is_like_std_string<
+                                      typename std::decay<Arg>::type>::value)>
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&) {
+  return add_space ? " \"{}\"" : "\"{}\"";
+}
+
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char*) {
+  return add_space ? " \"{}\"" : "\"{}\"";
+}
+FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t*) {
+  return add_space ? L" \"{}\"" : L"\"{}\"";
+}
+
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char) {
+  return add_space ? " '{}'" : "'{}'";
+}
+FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t) {
+  return add_space ? L" '{}'" : L"'{}'";
+}
+
+}  // namespace internal
+
+template <typename T> struct is_tuple_like {
+  static FMT_CONSTEXPR_DECL const bool value =
+      internal::is_tuple_like_<T>::value && !internal::is_range_<T>::value;
+};
+
+template <typename TupleT, typename Char>
+struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>> {
+ private:
+  // C++11 generic lambda for format()
+  template <typename FormatContext> struct format_each {
+    template <typename T> void operator()(const T& v) {
+      if (i > 0) {
+        if (formatting.add_prepostfix_space) {
+          *out++ = ' ';
+        }
+        out = internal::copy(formatting.delimiter, out);
+      }
+      out = format_to(out,
+                      internal::format_str_quoted(
+                          (formatting.add_delimiter_spaces && i > 0), v),
+                      v);
+      ++i;
+    }
+
+    formatting_tuple<Char>& formatting;
+    std::size_t& i;
+    typename std::add_lvalue_reference<decltype(
+        std::declval<FormatContext>().out())>::type out;
+  };
+
+ public:
+  formatting_tuple<Char> formatting;
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return formatting.parse(ctx);
+  }
+
+  template <typename FormatContext = format_context>
+  auto format(const TupleT& values, FormatContext& ctx) -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    std::size_t i = 0;
+    internal::copy(formatting.prefix, out);
+
+    internal::for_each(values, format_each<FormatContext>{formatting, i, out});
+    if (formatting.add_prepostfix_space) {
+      *out++ = ' ';
+    }
+    internal::copy(formatting.postfix, out);
+
+    return ctx.out();
+  }
+};
+
+template <typename T, typename Char> struct is_range {
+  static FMT_CONSTEXPR_DECL const bool value =
+      internal::is_range_<T>::value &&
+      !internal::is_like_std_string<T>::value &&
+      !std::is_convertible<T, std::basic_string<Char>>::value &&
+      !std::is_constructible<internal::std_string_view<Char>, T>::value;
+};
+
+template <typename RangeT, typename Char>
+struct formatter<RangeT, Char,
+                 enable_if_t<fmt::is_range<RangeT, Char>::value>> {
+  formatting_range<Char> formatting;
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return formatting.parse(ctx);
+  }
+
+  template <typename FormatContext>
+  typename FormatContext::iterator format(const RangeT& values,
+                                          FormatContext& ctx) {
+    auto out = internal::copy(formatting.prefix, ctx.out());
+    std::size_t i = 0;
+    for (auto it = values.begin(), end = values.end(); it != end; ++it) {
+      if (i > 0) {
+        if (formatting.add_prepostfix_space) *out++ = ' ';
+        out = internal::copy(formatting.delimiter, out);
+      }
+      out = format_to(out,
+                      internal::format_str_quoted(
+                          (formatting.add_delimiter_spaces && i > 0), *it),
+                      *it);
+      if (++i > formatting.range_length_limit) {
+        out = format_to(out, " ... <other elements>");
+        break;
+      }
+    }
+    if (formatting.add_prepostfix_space) *out++ = ' ';
+    return internal::copy(formatting.postfix, out);
+  }
+};
+
+template <typename Char, typename... T> struct tuple_arg_join : internal::view {
+  const std::tuple<T...>& tuple;
+  basic_string_view<Char> sep;
+
+  tuple_arg_join(const std::tuple<T...>& t, basic_string_view<Char> s)
+      : tuple{t}, sep{s} {}
+};
+
+template <typename Char, typename... T>
+struct formatter<tuple_arg_join<Char, T...>, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  typename FormatContext::iterator format(
+      const tuple_arg_join<Char, T...>& value, FormatContext& ctx) {
+    return format(value, ctx, internal::make_index_sequence<sizeof...(T)>{});
+  }
+
+ private:
+  template <typename FormatContext, size_t... N>
+  typename FormatContext::iterator format(
+      const tuple_arg_join<Char, T...>& value, FormatContext& ctx,
+      internal::index_sequence<N...>) {
+    return format_args(value, ctx, std::get<N>(value.tuple)...);
+  }
+
+  template <typename FormatContext>
+  typename FormatContext::iterator format_args(
+      const tuple_arg_join<Char, T...>&, FormatContext& ctx) {
+    // NOTE: for compilers that support C++17, this empty function instantiation
+    // can be replaced with a constexpr branch in the variadic overload.
+    return ctx.out();
+  }
+
+  template <typename FormatContext, typename Arg, typename... Args>
+  typename FormatContext::iterator format_args(
+      const tuple_arg_join<Char, T...>& value, FormatContext& ctx,
+      const Arg& arg, const Args&... args) {
+    using base = formatter<typename std::decay<Arg>::type, Char>;
+    auto out = ctx.out();
+    out = base{}.format(arg, ctx);
+    if (sizeof...(Args) > 0) {
+      out = std::copy(value.sep.begin(), value.sep.end(), out);
+      ctx.advance_to(out);
+      return format_args(value, ctx, args...);
+    }
+    return out;
+  }
+};
+
+/**
+  \rst
+  Returns an object that formats `tuple` with elements separated by `sep`.
+
+  **Example**::
+
+    std::tuple<int, char> t = {1, 'a'};
+    fmt::print("{}", fmt::join(t, ", "));
+    // Output: "1, a"
+  \endrst
+ */
+template <typename... T>
+FMT_CONSTEXPR tuple_arg_join<char, T...> join(const std::tuple<T...>& tuple,
+                                              string_view sep) {
+  return {tuple, sep};
+}
+
+template <typename... T>
+FMT_CONSTEXPR tuple_arg_join<wchar_t, T...> join(const std::tuple<T...>& tuple,
+                                                 wstring_view sep) {
+  return {tuple, sep};
+}
+
+/**
+  \rst
+  Returns an object that formats `initializer_list` with elements separated by
+  `sep`.
+
+  **Example**::
+
+    fmt::print("{}", fmt::join({1, 2, 3}, ", "));
+    // Output: "1, 2, 3"
+  \endrst
+ */
+template <typename T>
+arg_join<internal::iterator_t<const std::initializer_list<T>>, char> join(
+    std::initializer_list<T> list, string_view sep) {
+  return join(std::begin(list), std::end(list), sep);
+}
+
+template <typename T>
+arg_join<internal::iterator_t<const std::initializer_list<T>>, wchar_t> join(
+    std::initializer_list<T> list, wstring_view sep) {
+  return join(std::begin(list), std::end(list), sep);
+}
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_RANGES_H_
diff --git a/lib/json/nlohmann/json.hpp b/lib/json/nlohmann/json.hpp
new file mode 100644
index 0000000..a70aaf8
--- /dev/null
+++ b/lib/json/nlohmann/json.hpp
@@ -0,0 +1,25447 @@
+/*
+    __ _____ _____ _____
+ __|  |   __|     |   | |  JSON for Modern C++
+|  |  |__   |  |  | | | |  version 3.9.1
+|_____|_____|_____|_|___|  https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
+
+Permission is hereby  granted, free of charge, to any  person obtaining a copy
+of this software and associated  documentation files (the "Software"), to deal
+in the Software  without restriction, including without  limitation the rights
+to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#ifndef INCLUDE_NLOHMANN_JSON_HPP_
+#define INCLUDE_NLOHMANN_JSON_HPP_
+
+#define NLOHMANN_JSON_VERSION_MAJOR 3
+#define NLOHMANN_JSON_VERSION_MINOR 9
+#define NLOHMANN_JSON_VERSION_PATCH 1
+
+#include <algorithm> // all_of, find, for_each
+#include <cstddef> // nullptr_t, ptrdiff_t, size_t
+#include <functional> // hash, less
+#include <initializer_list> // initializer_list
+#include <iosfwd> // istream, ostream
+#include <iterator> // random_access_iterator_tag
+#include <memory> // unique_ptr
+#include <numeric> // accumulate
+#include <string> // string, stoi, to_string
+#include <utility> // declval, forward, move, pair, swap
+#include <vector> // vector
+
+// #include <nlohmann/adl_serializer.hpp>
+
+
+#include <utility>
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+
+
+#include <algorithm> // transform
+#include <array> // array
+#include <forward_list> // forward_list
+#include <iterator> // inserter, front_inserter, end
+#include <map> // map
+#include <string> // string
+#include <tuple> // tuple, make_tuple
+#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
+#include <unordered_map> // unordered_map
+#include <utility> // pair, declval
+#include <valarray> // valarray
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+
+#include <exception> // exception
+#include <stdexcept> // runtime_error
+#include <string> // to_string
+
+// #include <nlohmann/detail/input/position_t.hpp>
+
+
+#include <cstddef> // size_t
+
+namespace nlohmann
+{
+namespace detail
+{
+/// struct to capture the start position of the current token
+struct position_t
+{
+    /// the total number of characters read
+    std::size_t chars_read_total = 0;
+    /// the number of characters read in the current line
+    std::size_t chars_read_current_line = 0;
+    /// the number of lines read
+    std::size_t lines_read = 0;
+
+    /// conversion to size_t to preserve SAX interface
+    constexpr operator size_t() const
+    {
+        return chars_read_total;
+    }
+};
+
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+#include <utility> // pair
+// #include <nlohmann/thirdparty/hedley/hedley.hpp>
+/* Hedley - https://nemequ.github.io/hedley
+ * Created by Evan Nemerson <evan@nemerson.com>
+ *
+ * To the extent possible under law, the author(s) have dedicated all
+ * copyright and related and neighboring rights to this software to
+ * the public domain worldwide. This software is distributed without
+ * any warranty.
+ *
+ * For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+ * SPDX-License-Identifier: CC0-1.0
+ */
+
+#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 13)
+#if defined(JSON_HEDLEY_VERSION)
+    #undef JSON_HEDLEY_VERSION
+#endif
+#define JSON_HEDLEY_VERSION 13
+
+#if defined(JSON_HEDLEY_STRINGIFY_EX)
+    #undef JSON_HEDLEY_STRINGIFY_EX
+#endif
+#define JSON_HEDLEY_STRINGIFY_EX(x) #x
+
+#if defined(JSON_HEDLEY_STRINGIFY)
+    #undef JSON_HEDLEY_STRINGIFY
+#endif
+#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
+
+#if defined(JSON_HEDLEY_CONCAT_EX)
+    #undef JSON_HEDLEY_CONCAT_EX
+#endif
+#define JSON_HEDLEY_CONCAT_EX(a,b) a##b
+
+#if defined(JSON_HEDLEY_CONCAT)
+    #undef JSON_HEDLEY_CONCAT
+#endif
+#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
+
+#if defined(JSON_HEDLEY_CONCAT3_EX)
+    #undef JSON_HEDLEY_CONCAT3_EX
+#endif
+#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
+
+#if defined(JSON_HEDLEY_CONCAT3)
+    #undef JSON_HEDLEY_CONCAT3
+#endif
+#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
+
+#if defined(JSON_HEDLEY_VERSION_ENCODE)
+    #undef JSON_HEDLEY_VERSION_ENCODE
+#endif
+#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
+    #undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
+
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #undef JSON_HEDLEY_GNUC_VERSION
+#endif
+#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#elif defined(__GNUC__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION)
+    #undef JSON_HEDLEY_MSVC_VERSION
+#endif
+#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
+#elif defined(_MSC_FULL_VER)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
+#elif defined(_MSC_VER)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
+    #undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#endif
+#if !defined(_MSC_VER)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
+#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
+#else
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #undef JSON_HEDLEY_INTEL_VERSION
+#endif
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
+#elif defined(__INTEL_COMPILER)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
+    #undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #undef JSON_HEDLEY_PGI_VERSION
+#endif
+#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
+    #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
+    #undef JSON_HEDLEY_PGI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #undef JSON_HEDLEY_SUNPRO_VERSION
+#endif
+#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
+#elif defined(__SUNPRO_C)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
+#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
+#elif defined(__SUNPRO_CC)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
+    #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#endif
+#if defined(__EMSCRIPTEN__)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #undef JSON_HEDLEY_ARM_VERSION
+#endif
+#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
+#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
+    #undef JSON_HEDLEY_ARM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #undef JSON_HEDLEY_IBM_VERSION
+#endif
+#if defined(__ibmxl__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
+#elif defined(__xlC__) && defined(__xlC_ver__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
+#elif defined(__xlC__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
+    #undef JSON_HEDLEY_IBM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #undef JSON_HEDLEY_TI_VERSION
+#endif
+#if \
+    defined(__TI_COMPILER_VERSION__) && \
+    ( \
+      defined(__TMS470__) || defined(__TI_ARM__) || \
+      defined(__MSP430__) || \
+      defined(__TMS320C2000__) \
+    )
+#if (__TI_COMPILER_VERSION__ >= 16000000)
+    #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
+    #undef JSON_HEDLEY_TI_CL2000_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
+    #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
+    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL430_VERSION)
+    #undef JSON_HEDLEY_TI_CL430_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
+    #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL430_VERSION)
+    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
+    #undef JSON_HEDLEY_TI_ARMCL_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
+    #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
+    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
+    #undef JSON_HEDLEY_TI_CL6X_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
+    #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
+    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
+    #undef JSON_HEDLEY_TI_CL7X_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
+    #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
+    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
+    #undef JSON_HEDLEY_TI_CLPRU_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
+    #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
+    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #undef JSON_HEDLEY_CRAY_VERSION
+#endif
+#if defined(_CRAYC)
+    #if defined(_RELEASE_PATCHLEVEL)
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
+    #else
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
+    #undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #undef JSON_HEDLEY_IAR_VERSION
+#endif
+#if defined(__IAR_SYSTEMS_ICC__)
+    #if __VER__ > 1000
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
+    #else
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(VER / 100, __VER__ % 100, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
+    #undef JSON_HEDLEY_IAR_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #undef JSON_HEDLEY_TINYC_VERSION
+#endif
+#if defined(__TINYC__)
+    #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
+    #undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #undef JSON_HEDLEY_DMC_VERSION
+#endif
+#if defined(__DMC__)
+    #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
+    #undef JSON_HEDLEY_DMC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #undef JSON_HEDLEY_COMPCERT_VERSION
+#endif
+#if defined(__COMPCERT_VERSION__)
+    #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
+    #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #undef JSON_HEDLEY_PELLES_VERSION
+#endif
+#if defined(__POCC__)
+    #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
+    #undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #undef JSON_HEDLEY_GCC_VERSION
+#endif
+#if \
+    defined(JSON_HEDLEY_GNUC_VERSION) && \
+    !defined(__clang__) && \
+    !defined(JSON_HEDLEY_INTEL_VERSION) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_ARM_VERSION) && \
+    !defined(JSON_HEDLEY_TI_VERSION) && \
+    !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
+    !defined(__COMPCERT__)
+    #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#endif
+#if \
+    defined(__has_cpp_attribute) && \
+    defined(__cplusplus) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+#endif
+#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
+#elif \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_IAR_VERSION) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
+    (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_BUILTIN)
+    #undef JSON_HEDLEY_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_FEATURE)
+    #undef JSON_HEDLEY_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GCC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_EXTENSION)
+    #undef JSON_HEDLEY_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_WARNING)
+    #undef JSON_HEDLEY_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_HAS_WARNING(warning) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
+    #undef JSON_HEDLEY_GNUC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
+    #undef JSON_HEDLEY_GCC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
+   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+#endif
+#if defined(__cplusplus)
+#  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
+#    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
+#      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    else
+#      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    endif
+#  endif
+#endif
+#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
+#endif
+
+#if defined(JSON_HEDLEY_CONST_CAST)
+    #undef JSON_HEDLEY_CONST_CAST
+#endif
+#if defined(__cplusplus)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
+#elif \
+  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_REINTERPRET_CAST)
+    #undef JSON_HEDLEY_REINTERPRET_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_CAST)
+    #undef JSON_HEDLEY_STATIC_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_CPP_CAST)
+    #undef JSON_HEDLEY_CPP_CAST
+#endif
+#if defined(__cplusplus)
+#  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
+#    define JSON_HEDLEY_CPP_CAST(T, expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
+    ((T) (expr)) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
+#    define JSON_HEDLEY_CPP_CAST(T, expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("diag_suppress=Pe137") \
+    JSON_HEDLEY_DIAGNOSTIC_POP \
+#  else
+#    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
+#  endif
+#else
+#  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
+#endif
+
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    defined(__clang__) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
+    #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
+#else
+    #define JSON_HEDLEY_PRAGMA(value)
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
+    #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#endif
+#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
+    #undef JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
+    #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
+#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH
+    #define JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+
+#if defined(JSON_HEDLEY_DEPRECATED)
+    #undef JSON_HEDLEY_DEPRECATED
+#endif
+#if defined(JSON_HEDLEY_DEPRECATED_FOR)
+    #undef JSON_HEDLEY_DEPRECATED_FOR
+#endif
+#if JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
+#elif defined(__cplusplus) && (__cplusplus >= 201402L)
+    #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
+#elif \
+    JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
+#else
+    #define JSON_HEDLEY_DEPRECATED(since)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
+#endif
+
+#if defined(JSON_HEDLEY_UNAVAILABLE)
+    #undef JSON_HEDLEY_UNAVAILABLE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
+#else
+    #define JSON_HEDLEY_UNAVAILABLE(available_since)
+#endif
+
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#endif
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+#endif
+#if (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
+#elif defined(_Check_return_) /* SAL */
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
+#else
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
+#endif
+
+#if defined(JSON_HEDLEY_SENTINEL)
+    #undef JSON_HEDLEY_SENTINEL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0)
+    #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
+#else
+    #define JSON_HEDLEY_SENTINEL(position)
+#endif
+
+#if defined(JSON_HEDLEY_NO_RETURN)
+    #undef JSON_HEDLEY_NO_RETURN
+#endif
+#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NO_RETURN __noreturn
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+    #define JSON_HEDLEY_NO_RETURN _Noreturn
+#elif defined(__cplusplus) && (__cplusplus >= 201103L)
+    #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#else
+    #define JSON_HEDLEY_NO_RETURN
+#endif
+
+#if defined(JSON_HEDLEY_NO_ESCAPE)
+    #undef JSON_HEDLEY_NO_ESCAPE
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
+    #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
+#else
+    #define JSON_HEDLEY_NO_ESCAPE
+#endif
+
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #undef JSON_HEDLEY_UNREACHABLE
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
+    #undef JSON_HEDLEY_UNREACHABLE_RETURN
+#endif
+#if defined(JSON_HEDLEY_ASSUME)
+    #undef JSON_HEDLEY_ASSUME
+#endif
+#if \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
+#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
+    #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
+#elif \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
+    #if defined(__cplusplus)
+        #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
+    #endif
+#endif
+#if \
+    (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5)
+    #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
+#elif defined(JSON_HEDLEY_ASSUME)
+    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
+#endif
+#if !defined(JSON_HEDLEY_ASSUME)
+    #if defined(JSON_HEDLEY_UNREACHABLE)
+        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
+    #endif
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #if  \
+        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
+        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
+    #else
+        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
+    #endif
+#else
+    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
+#endif
+#if !defined(JSON_HEDLEY_UNREACHABLE)
+    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
+#endif
+
+JSON_HEDLEY_DIAGNOSTIC_PUSH
+#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
+    #pragma clang diagnostic ignored "-Wpedantic"
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
+    #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#endif
+#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
+    #if defined(__clang__)
+        #pragma clang diagnostic ignored "-Wvariadic-macros"
+    #elif defined(JSON_HEDLEY_GCC_VERSION)
+        #pragma GCC diagnostic ignored "-Wvariadic-macros"
+    #endif
+#endif
+#if defined(JSON_HEDLEY_NON_NULL)
+    #undef JSON_HEDLEY_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
+#else
+    #define JSON_HEDLEY_NON_NULL(...)
+#endif
+JSON_HEDLEY_DIAGNOSTIC_POP
+
+#if defined(JSON_HEDLEY_PRINTF_FORMAT)
+    #undef JSON_HEDLEY_PRINTF_FORMAT
+#endif
+#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
+#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
+#else
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
+#endif
+
+#if defined(JSON_HEDLEY_CONSTEXPR)
+    #undef JSON_HEDLEY_CONSTEXPR
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
+    #endif
+#endif
+#if !defined(JSON_HEDLEY_CONSTEXPR)
+    #define JSON_HEDLEY_CONSTEXPR
+#endif
+
+#if defined(JSON_HEDLEY_PREDICT)
+    #undef JSON_HEDLEY_PREDICT
+#endif
+#if defined(JSON_HEDLEY_LIKELY)
+    #undef JSON_HEDLEY_LIKELY
+#endif
+#if defined(JSON_HEDLEY_UNLIKELY)
+    #undef JSON_HEDLEY_UNLIKELY
+#endif
+#if defined(JSON_HEDLEY_UNPREDICTABLE)
+    #undef JSON_HEDLEY_UNPREDICTABLE
+#endif
+#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
+#endif
+#if \
+  JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0)
+#  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))
+#  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )
+#  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )
+#elif \
+  JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
+  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0)
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
+    (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
+    (__extension__ ({ \
+        double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
+    (__extension__ ({ \
+        double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
+#  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
+#else
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
+#  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
+#endif
+#if !defined(JSON_HEDLEY_UNPREDICTABLE)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
+#endif
+
+#if defined(JSON_HEDLEY_MALLOC)
+    #undef JSON_HEDLEY_MALLOC
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(14, 0, 0)
+    #define JSON_HEDLEY_MALLOC __declspec(restrict)
+#else
+    #define JSON_HEDLEY_MALLOC
+#endif
+
+#if defined(JSON_HEDLEY_PURE)
+    #undef JSON_HEDLEY_PURE
+#endif
+#if \
+  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+#  define JSON_HEDLEY_PURE __attribute__((__pure__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+#  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
+#elif defined(__cplusplus) && \
+    ( \
+      JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
+      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
+      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
+    )
+#  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
+#else
+#  define JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_CONST)
+    #undef JSON_HEDLEY_CONST
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_CONST __attribute__((__const__))
+#elif \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
+#else
+    #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_RESTRICT)
+    #undef JSON_HEDLEY_RESTRICT
+#endif
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT restrict
+#elif \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    defined(__clang__)
+    #define JSON_HEDLEY_RESTRICT __restrict
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT _Restrict
+#else
+    #define JSON_HEDLEY_RESTRICT
+#endif
+
+#if defined(JSON_HEDLEY_INLINE)
+    #undef JSON_HEDLEY_INLINE
+#endif
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    (defined(__cplusplus) && (__cplusplus >= 199711L))
+    #define JSON_HEDLEY_INLINE inline
+#elif \
+    defined(JSON_HEDLEY_GCC_VERSION) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
+    #define JSON_HEDLEY_INLINE __inline__
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_INLINE __inline
+#else
+    #define JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_ALWAYS_INLINE)
+    #undef JSON_HEDLEY_ALWAYS_INLINE
+#endif
+#if \
+  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE __forceinline
+#elif defined(__cplusplus) && \
+    ( \
+      JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+      JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+      JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+      JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
+    )
+#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
+#else
+#  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_NEVER_INLINE)
+    #undef JSON_HEDLEY_NEVER_INLINE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#else
+    #define JSON_HEDLEY_NEVER_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_PRIVATE)
+    #undef JSON_HEDLEY_PRIVATE
+#endif
+#if defined(JSON_HEDLEY_PUBLIC)
+    #undef JSON_HEDLEY_PUBLIC
+#endif
+#if defined(JSON_HEDLEY_IMPORT)
+    #undef JSON_HEDLEY_IMPORT
+#endif
+#if defined(_WIN32) || defined(__CYGWIN__)
+#  define JSON_HEDLEY_PRIVATE
+#  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
+#  define JSON_HEDLEY_IMPORT   __declspec(dllimport)
+#else
+#  if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    ( \
+      defined(__TI_EABI__) && \
+      ( \
+        (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
+      ) \
+    )
+#    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
+#    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
+#  else
+#    define JSON_HEDLEY_PRIVATE
+#    define JSON_HEDLEY_PUBLIC
+#  endif
+#  define JSON_HEDLEY_IMPORT    extern
+#endif
+
+#if defined(JSON_HEDLEY_NO_THROW)
+    #undef JSON_HEDLEY_NO_THROW
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
+#else
+    #define JSON_HEDLEY_NO_THROW
+#endif
+
+#if defined(JSON_HEDLEY_FALL_THROUGH)
+    #undef JSON_HEDLEY_FALL_THROUGH
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0)
+    #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
+    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
+    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
+#elif defined(__fallthrough) /* SAL */
+    #define JSON_HEDLEY_FALL_THROUGH __fallthrough
+#else
+    #define JSON_HEDLEY_FALL_THROUGH
+#endif
+
+#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
+    #undef JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
+#elif defined(_Ret_notnull_) /* SAL */
+    #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
+#else
+    #define JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+
+#if defined(JSON_HEDLEY_ARRAY_PARAM)
+    #undef JSON_HEDLEY_ARRAY_PARAM
+#endif
+#if \
+    defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
+    !defined(__STDC_NO_VLA__) && \
+    !defined(__cplusplus) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
+#else
+    #define JSON_HEDLEY_ARRAY_PARAM(name)
+#endif
+
+#if defined(JSON_HEDLEY_IS_CONSTANT)
+    #undef JSON_HEDLEY_IS_CONSTANT
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
+    #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#endif
+/* JSON_HEDLEY_IS_CONSTEXPR_ is for
+   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
+#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
+    #undef JSON_HEDLEY_IS_CONSTEXPR_
+#endif
+#if \
+    JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0)
+    #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
+#endif
+#if !defined(__cplusplus)
+#  if \
+       JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+       JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
+       JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
+#endif
+#  elif \
+       ( \
+          defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
+          !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
+          !defined(JSON_HEDLEY_PGI_VERSION) && \
+          !defined(JSON_HEDLEY_IAR_VERSION)) || \
+       JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
+#endif
+#  elif \
+       defined(JSON_HEDLEY_GCC_VERSION) || \
+       defined(JSON_HEDLEY_INTEL_VERSION) || \
+       defined(JSON_HEDLEY_TINYC_VERSION) || \
+       defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
+       JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
+       defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
+       defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
+       defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
+       defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
+       defined(__clang__)
+#    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
+        sizeof(void) != \
+        sizeof(*( \
+                  1 ? \
+                  ((void*) ((expr) * 0L) ) : \
+((struct { char v[sizeof(void) * 2]; } *) 1) \
+                ) \
+              ) \
+                                            )
+#  endif
+#endif
+#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
+#else
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
+    #undef JSON_HEDLEY_BEGIN_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_END_C_DECLS)
+    #undef JSON_HEDLEY_END_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_C_DECL)
+    #undef JSON_HEDLEY_C_DECL
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
+    #define JSON_HEDLEY_END_C_DECLS }
+    #define JSON_HEDLEY_C_DECL extern "C"
+#else
+    #define JSON_HEDLEY_BEGIN_C_DECLS
+    #define JSON_HEDLEY_END_C_DECLS
+    #define JSON_HEDLEY_C_DECL
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_ASSERT)
+    #undef JSON_HEDLEY_STATIC_ASSERT
+#endif
+#if \
+  !defined(__cplusplus) && ( \
+      (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
+      JSON_HEDLEY_HAS_FEATURE(c_static_assert) || \
+      JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
+      JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+      defined(_Static_assert) \
+    )
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
+#elif \
+  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0)
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
+#else
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
+#endif
+
+#if defined(JSON_HEDLEY_NULL)
+    #undef JSON_HEDLEY_NULL
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
+    #elif defined(NULL)
+        #define JSON_HEDLEY_NULL NULL
+    #else
+        #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
+    #endif
+#elif defined(NULL)
+    #define JSON_HEDLEY_NULL NULL
+#else
+    #define JSON_HEDLEY_NULL ((void*) 0)
+#endif
+
+#if defined(JSON_HEDLEY_MESSAGE)
+    #undef JSON_HEDLEY_MESSAGE
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_MESSAGE(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(message msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
+#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_WARNING)
+    #undef JSON_HEDLEY_WARNING
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_WARNING(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(clang warning msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_REQUIRE)
+    #undef JSON_HEDLEY_REQUIRE
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_MSG)
+    #undef JSON_HEDLEY_REQUIRE_MSG
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
+#  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
+#    define JSON_HEDLEY_REQUIRE(expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((diagnose_if(!(expr), #expr, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((diagnose_if(!(expr), msg, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  else
+#    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
+#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
+#  endif
+#else
+#  define JSON_HEDLEY_REQUIRE(expr)
+#  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS)
+    #undef JSON_HEDLEY_FLAGS
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum)
+    #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS_CAST)
+    #undef JSON_HEDLEY_FLAGS_CAST
+#endif
+#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        _Pragma("warning(disable:188)") \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
+#endif
+
+#if defined(JSON_HEDLEY_EMPTY_BASES)
+    #undef JSON_HEDLEY_EMPTY_BASES
+#endif
+#if JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)
+    #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
+#else
+    #define JSON_HEDLEY_EMPTY_BASES
+#endif
+
+/* Remaining macros are deprecated. */
+
+#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
+#else
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
+    #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#endif
+#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
+    #undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
+    #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#endif
+#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
+    #undef JSON_HEDLEY_CLANG_HAS_WARNING
+#endif
+#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
+
+#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
+
+
+// This file contains all internal macro definitions
+// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
+
+// exclude unsupported compilers
+#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
+    #if defined(__clang__)
+        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
+            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
+        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
+            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #endif
+#endif
+
+// C++ language standard detection
+#if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
+    #define JSON_HAS_CPP_20
+    #define JSON_HAS_CPP_17
+    #define JSON_HAS_CPP_14
+#elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+    #define JSON_HAS_CPP_17
+    #define JSON_HAS_CPP_14
+#elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
+    #define JSON_HAS_CPP_14
+#endif
+
+// disable float-equal warnings on GCC/clang
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+
+// disable documentation warnings on clang
+#if defined(__clang__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wdocumentation"
+#endif
+
+// allow to disable exceptions
+#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
+    #define JSON_THROW(exception) throw exception
+    #define JSON_TRY try
+    #define JSON_CATCH(exception) catch(exception)
+    #define JSON_INTERNAL_CATCH(exception) catch(exception)
+#else
+    #include <cstdlib>
+    #define JSON_THROW(exception) std::abort()
+    #define JSON_TRY if(true)
+    #define JSON_CATCH(exception) if(false)
+    #define JSON_INTERNAL_CATCH(exception) if(false)
+#endif
+
+// override exception macros
+#if defined(JSON_THROW_USER)
+    #undef JSON_THROW
+    #define JSON_THROW JSON_THROW_USER
+#endif
+#if defined(JSON_TRY_USER)
+    #undef JSON_TRY
+    #define JSON_TRY JSON_TRY_USER
+#endif
+#if defined(JSON_CATCH_USER)
+    #undef JSON_CATCH
+    #define JSON_CATCH JSON_CATCH_USER
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_CATCH_USER
+#endif
+#if defined(JSON_INTERNAL_CATCH_USER)
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
+#endif
+
+// allow to override assert
+#if !defined(JSON_ASSERT)
+    #include <cassert> // assert
+    #define JSON_ASSERT(x) assert(x)
+#endif
+
+/*!
+@brief macro to briefly define a mapping between an enum and JSON
+@def NLOHMANN_JSON_SERIALIZE_ENUM
+@since version 3.4.0
+*/
+#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                            \
+    template<typename BasicJsonType>                                                            \
+    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                   \
+    {                                                                                           \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        auto it = std::find_if(std::begin(m), std::end(m),                                      \
+                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \
+        {                                                                                       \
+            return ej_pair.first == e;                                                          \
+        });                                                                                     \
+        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \
+    }                                                                                           \
+    template<typename BasicJsonType>                                                            \
+    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
+    {                                                                                           \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        auto it = std::find_if(std::begin(m), std::end(m),                                      \
+                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
+        {                                                                                       \
+            return ej_pair.second == j;                                                         \
+        });                                                                                     \
+        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                  \
+    }
+
+// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
+// may be removed in the future once the class is split.
+
+#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \
+    template<template<typename, typename, typename...> class ObjectType,   \
+             template<typename, typename...> class ArrayType,              \
+             class StringType, class BooleanType, class NumberIntegerType, \
+             class NumberUnsignedType, class NumberFloatType,              \
+             template<typename> class AllocatorType,                       \
+             template<typename, typename = void> class JSONSerializer,     \
+             class BinaryType>
+
+#define NLOHMANN_BASIC_JSON_TPL                                            \
+    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
+    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
+    AllocatorType, JSONSerializer, BinaryType>
+
+// Macros to simplify conversion from/to types
+
+#define NLOHMANN_JSON_EXPAND( x ) x
+#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
+#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
+        NLOHMANN_JSON_PASTE64, \
+        NLOHMANN_JSON_PASTE63, \
+        NLOHMANN_JSON_PASTE62, \
+        NLOHMANN_JSON_PASTE61, \
+        NLOHMANN_JSON_PASTE60, \
+        NLOHMANN_JSON_PASTE59, \
+        NLOHMANN_JSON_PASTE58, \
+        NLOHMANN_JSON_PASTE57, \
+        NLOHMANN_JSON_PASTE56, \
+        NLOHMANN_JSON_PASTE55, \
+        NLOHMANN_JSON_PASTE54, \
+        NLOHMANN_JSON_PASTE53, \
+        NLOHMANN_JSON_PASTE52, \
+        NLOHMANN_JSON_PASTE51, \
+        NLOHMANN_JSON_PASTE50, \
+        NLOHMANN_JSON_PASTE49, \
+        NLOHMANN_JSON_PASTE48, \
+        NLOHMANN_JSON_PASTE47, \
+        NLOHMANN_JSON_PASTE46, \
+        NLOHMANN_JSON_PASTE45, \
+        NLOHMANN_JSON_PASTE44, \
+        NLOHMANN_JSON_PASTE43, \
+        NLOHMANN_JSON_PASTE42, \
+        NLOHMANN_JSON_PASTE41, \
+        NLOHMANN_JSON_PASTE40, \
+        NLOHMANN_JSON_PASTE39, \
+        NLOHMANN_JSON_PASTE38, \
+        NLOHMANN_JSON_PASTE37, \
+        NLOHMANN_JSON_PASTE36, \
+        NLOHMANN_JSON_PASTE35, \
+        NLOHMANN_JSON_PASTE34, \
+        NLOHMANN_JSON_PASTE33, \
+        NLOHMANN_JSON_PASTE32, \
+        NLOHMANN_JSON_PASTE31, \
+        NLOHMANN_JSON_PASTE30, \
+        NLOHMANN_JSON_PASTE29, \
+        NLOHMANN_JSON_PASTE28, \
+        NLOHMANN_JSON_PASTE27, \
+        NLOHMANN_JSON_PASTE26, \
+        NLOHMANN_JSON_PASTE25, \
+        NLOHMANN_JSON_PASTE24, \
+        NLOHMANN_JSON_PASTE23, \
+        NLOHMANN_JSON_PASTE22, \
+        NLOHMANN_JSON_PASTE21, \
+        NLOHMANN_JSON_PASTE20, \
+        NLOHMANN_JSON_PASTE19, \
+        NLOHMANN_JSON_PASTE18, \
+        NLOHMANN_JSON_PASTE17, \
+        NLOHMANN_JSON_PASTE16, \
+        NLOHMANN_JSON_PASTE15, \
+        NLOHMANN_JSON_PASTE14, \
+        NLOHMANN_JSON_PASTE13, \
+        NLOHMANN_JSON_PASTE12, \
+        NLOHMANN_JSON_PASTE11, \
+        NLOHMANN_JSON_PASTE10, \
+        NLOHMANN_JSON_PASTE9, \
+        NLOHMANN_JSON_PASTE8, \
+        NLOHMANN_JSON_PASTE7, \
+        NLOHMANN_JSON_PASTE6, \
+        NLOHMANN_JSON_PASTE5, \
+        NLOHMANN_JSON_PASTE4, \
+        NLOHMANN_JSON_PASTE3, \
+        NLOHMANN_JSON_PASTE2, \
+        NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
+#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
+#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
+#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
+#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
+#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
+#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
+#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
+#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
+#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
+#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
+#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
+#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
+#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
+#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
+#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
+#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
+#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
+#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
+#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
+#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
+#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
+#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
+#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
+#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
+#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
+#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
+#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
+#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
+#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
+#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
+#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)
+#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)
+#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)
+#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
+#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)
+#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)
+#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)
+#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)
+#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)
+#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)
+#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)
+#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)
+#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
+#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
+#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)
+#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)
+#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
+#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
+#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
+#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)
+#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)
+#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)
+#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)
+#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
+#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
+#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
+#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
+#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)
+#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)
+#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)
+#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)
+#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)
+
+#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
+#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
+@since version 3.9.0
+*/
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
+@since version 3.9.0
+*/
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+#ifndef JSON_USE_IMPLICIT_CONVERSIONS
+    #define JSON_USE_IMPLICIT_CONVERSIONS 1
+#endif
+
+#if JSON_USE_IMPLICIT_CONVERSIONS
+    #define JSON_EXPLICIT
+#else
+    #define JSON_EXPLICIT explicit
+#endif
+
+
+namespace nlohmann
+{
+namespace detail
+{
+////////////////
+// exceptions //
+////////////////
+
+/*!
+@brief general exception of the @ref basic_json class
+
+This class is an extension of `std::exception` objects with a member @a id for
+exception ids. It is used as the base class for all exceptions thrown by the
+@ref basic_json class. This class can hence be used as "wildcard" to catch
+exceptions.
+
+Subclasses:
+- @ref parse_error for exceptions indicating a parse error
+- @ref invalid_iterator for exceptions indicating errors with iterators
+- @ref type_error for exceptions indicating executing a member function with
+                  a wrong type
+- @ref out_of_range for exceptions indicating access out of the defined range
+- @ref other_error for exceptions indicating other library errors
+
+@internal
+@note To have nothrow-copy-constructible exceptions, we internally use
+      `std::runtime_error` which can cope with arbitrary-length error messages.
+      Intermediate strings are built with static functions and then passed to
+      the actual constructor.
+@endinternal
+
+@liveexample{The following code shows how arbitrary library exceptions can be
+caught.,exception}
+
+@since version 3.0.0
+*/
+class exception : public std::exception
+{
+  public:
+    /// returns the explanatory string
+    JSON_HEDLEY_RETURNS_NON_NULL
+    const char* what() const noexcept override
+    {
+        return m.what();
+    }
+
+    /// the id of the exception
+    const int id;
+
+  protected:
+    JSON_HEDLEY_NON_NULL(3)
+    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {}
+
+    static std::string name(const std::string& ename, int id_)
+    {
+        return "[json.exception." + ename + "." + std::to_string(id_) + "] ";
+    }
+
+  private:
+    /// an exception object as storage for error messages
+    std::runtime_error m;
+};
+
+/*!
+@brief exception indicating a parse error
+
+This exception is thrown by the library when a parse error occurs. Parse errors
+can occur during the deserialization of JSON text, CBOR, MessagePack, as well
+as when using JSON Patch.
+
+Member @a byte holds the byte index of the last read character in the input
+file.
+
+Exceptions have ids 1xx.
+
+name / id                      | example message | description
+------------------------------ | --------------- | -------------------------
+json.exception.parse_error.101 | parse error at 2: unexpected end of input; expected string literal | This error indicates a syntax error while deserializing a JSON text. The error message describes that an unexpected token (character) was encountered, and the member @a byte indicates the error position.
+json.exception.parse_error.102 | parse error at 14: missing or wrong low surrogate | JSON uses the `\uxxxx` format to describe Unicode characters. Code points above above 0xFFFF are split into two `\uxxxx` entries ("surrogate pairs"). This error indicates that the surrogate pair is incomplete or contains an invalid code point.
+json.exception.parse_error.103 | parse error: code points above 0x10FFFF are invalid | Unicode supports code points up to 0x10FFFF. Code points above 0x10FFFF are invalid.
+json.exception.parse_error.104 | parse error: JSON patch must be an array of objects | [RFC 6902](https://tools.ietf.org/html/rfc6902) requires a JSON Patch document to be a JSON document that represents an array of objects.
+json.exception.parse_error.105 | parse error: operation must have string member 'op' | An operation of a JSON Patch document must contain exactly one "op" member, whose value indicates the operation to perform. Its value must be one of "add", "remove", "replace", "move", "copy", or "test"; other values are errors.
+json.exception.parse_error.106 | parse error: array index '01' must not begin with '0' | An array index in a JSON Pointer ([RFC 6901](https://tools.ietf.org/html/rfc6901)) may be `0` or any number without a leading `0`.
+json.exception.parse_error.107 | parse error: JSON pointer must be empty or begin with '/' - was: 'foo' | A JSON Pointer must be a Unicode string containing a sequence of zero or more reference tokens, each prefixed by a `/` character.
+json.exception.parse_error.108 | parse error: escape character '~' must be followed with '0' or '1' | In a JSON Pointer, only `~0` and `~1` are valid escape sequences.
+json.exception.parse_error.109 | parse error: array index 'one' is not a number | A JSON Pointer array index must be a number.
+json.exception.parse_error.110 | parse error at 1: cannot read 2 bytes from vector | When parsing CBOR or MessagePack, the byte vector ends before the complete value has been read.
+json.exception.parse_error.112 | parse error at 1: error reading CBOR; last byte: 0xF8 | Not all types of CBOR or MessagePack are supported. This exception occurs if an unsupported byte was read.
+json.exception.parse_error.113 | parse error at 2: expected a CBOR string; last byte: 0x98 | While parsing a map key, a value that is not a string has been read.
+json.exception.parse_error.114 | parse error: Unsupported BSON record type 0x0F | The parsing of the corresponding BSON record type is not implemented (yet).
+json.exception.parse_error.115 | parse error at byte 5: syntax error while parsing UBJSON high-precision number: invalid number text: 1A | A UBJSON high-precision number could not be parsed.
+
+@note For an input with n bytes, 1 is the index of the first character and n+1
+      is the index of the terminating null byte or the end of file. This also
+      holds true when reading a byte vector (CBOR or MessagePack).
+
+@liveexample{The following code shows how a `parse_error` exception can be
+caught.,parse_error}
+
+@sa - @ref exception for the base class of the library exceptions
+@sa - @ref invalid_iterator for exceptions indicating errors with iterators
+@sa - @ref type_error for exceptions indicating executing a member function with
+                    a wrong type
+@sa - @ref out_of_range for exceptions indicating access out of the defined range
+@sa - @ref other_error for exceptions indicating other library errors
+
+@since version 3.0.0
+*/
+class parse_error : public exception
+{
+  public:
+    /*!
+    @brief create a parse error exception
+    @param[in] id_       the id of the exception
+    @param[in] pos       the position where the error occurred (or with
+                         chars_read_total=0 if the position cannot be
+                         determined)
+    @param[in] what_arg  the explanatory string
+    @return parse_error object
+    */
+    static parse_error create(int id_, const position_t& pos, const std::string& what_arg)
+    {
+        std::string w = exception::name("parse_error", id_) + "parse error" +
+                        position_string(pos) + ": " + what_arg;
+        return parse_error(id_, pos.chars_read_total, w.c_str());
+    }
+
+    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg)
+    {
+        std::string w = exception::name("parse_error", id_) + "parse error" +
+                        (byte_ != 0 ? (" at byte " + std::to_string(byte_)) : "") +
+                        ": " + what_arg;
+        return parse_error(id_, byte_, w.c_str());
+    }
+
+    /*!
+    @brief byte index of the parse error
+
+    The byte index of the last read character in the input file.
+
+    @note For an input with n bytes, 1 is the index of the first character and
+          n+1 is the index of the terminating null byte or the end of file.
+          This also holds true when reading a byte vector (CBOR or MessagePack).
+    */
+    const std::size_t byte;
+
+  private:
+    parse_error(int id_, std::size_t byte_, const char* what_arg)
+        : exception(id_, what_arg), byte(byte_) {}
+
+    static std::string position_string(const position_t& pos)
+    {
+        return " at line " + std::to_string(pos.lines_read + 1) +
+               ", column " + std::to_string(pos.chars_read_current_line);
+    }
+};
+
+/*!
+@brief exception indicating errors with iterators
+
+This exception is thrown if iterators passed to a library function do not match
+the expected semantics.
+
+Exceptions have ids 2xx.
+
+name / id                           | example message | description
+----------------------------------- | --------------- | -------------------------
+json.exception.invalid_iterator.201 | iterators are not compatible | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.
+json.exception.invalid_iterator.202 | iterator does not fit current value | In an erase or insert function, the passed iterator @a pos does not belong to the JSON value for which the function was called. It hence does not define a valid position for the deletion/insertion.
+json.exception.invalid_iterator.203 | iterators do not fit current value | Either iterator passed to function @ref erase(IteratorType first, IteratorType last) does not belong to the JSON value from which values shall be erased. It hence does not define a valid range to delete values from.
+json.exception.invalid_iterator.204 | iterators out of range | When an iterator range for a primitive type (number, boolean, or string) is passed to a constructor or an erase function, this range has to be exactly (@ref begin(), @ref end()), because this is the only way the single stored value is expressed. All other ranges are invalid.
+json.exception.invalid_iterator.205 | iterator out of range | When an iterator for a primitive type (number, boolean, or string) is passed to an erase function, the iterator has to be the @ref begin() iterator, because it is the only way to address the stored value. All other iterators are invalid.
+json.exception.invalid_iterator.206 | cannot construct with iterators from null | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) belong to a JSON null value and hence to not define a valid range.
+json.exception.invalid_iterator.207 | cannot use key() for non-object iterators | The key() member function can only be used on iterators belonging to a JSON object, because other types do not have a concept of a key.
+json.exception.invalid_iterator.208 | cannot use operator[] for object iterators | The operator[] to specify a concrete offset cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
+json.exception.invalid_iterator.209 | cannot use offsets with object iterators | The offset operators (+, -, +=, -=) cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
+json.exception.invalid_iterator.210 | iterators do not fit | The iterator range passed to the insert function are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.
+json.exception.invalid_iterator.211 | passed iterators may not belong to container | The iterator range passed to the insert function must not be a subrange of the container to insert to.
+json.exception.invalid_iterator.212 | cannot compare iterators of different containers | When two iterators are compared, they must belong to the same container.
+json.exception.invalid_iterator.213 | cannot compare order of object iterators | The order of object iterators cannot be compared, because JSON objects are unordered.
+json.exception.invalid_iterator.214 | cannot get value | Cannot get value for iterator: Either the iterator belongs to a null value or it is an iterator to a primitive type (number, boolean, or string), but the iterator is different to @ref begin().
+
+@liveexample{The following code shows how an `invalid_iterator` exception can be
+caught.,invalid_iterator}
+
+@sa - @ref exception for the base class of the library exceptions
+@sa - @ref parse_error for exceptions indicating a parse error
+@sa - @ref type_error for exceptions indicating executing a member function with
+                    a wrong type
+@sa - @ref out_of_range for exceptions indicating access out of the defined range
+@sa - @ref other_error for exceptions indicating other library errors
+
+@since version 3.0.0
+*/
+class invalid_iterator : public exception
+{
+  public:
+    static invalid_iterator create(int id_, const std::string& what_arg)
+    {
+        std::string w = exception::name("invalid_iterator", id_) + what_arg;
+        return invalid_iterator(id_, w.c_str());
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    invalid_iterator(int id_, const char* what_arg)
+        : exception(id_, what_arg) {}
+};
+
+/*!
+@brief exception indicating executing a member function with a wrong type
+
+This exception is thrown in case of a type error; that is, a library function is
+executed on a JSON value whose type does not match the expected semantics.
+
+Exceptions have ids 3xx.
+
+name / id                     | example message | description
+----------------------------- | --------------- | -------------------------
+json.exception.type_error.301 | cannot create object from initializer list | To create an object from an initializer list, the initializer list must consist only of a list of pairs whose first element is a string. When this constraint is violated, an array is created instead.
+json.exception.type_error.302 | type must be object, but is array | During implicit or explicit value conversion, the JSON type must be compatible to the target type. For instance, a JSON string can only be converted into string types, but not into numbers or boolean types.
+json.exception.type_error.303 | incompatible ReferenceType for get_ref, actual type is object | To retrieve a reference to a value stored in a @ref basic_json object with @ref get_ref, the type of the reference must match the value type. For instance, for a JSON array, the @a ReferenceType must be @ref array_t &.
+json.exception.type_error.304 | cannot use at() with string | The @ref at() member functions can only be executed for certain JSON types.
+json.exception.type_error.305 | cannot use operator[] with string | The @ref operator[] member functions can only be executed for certain JSON types.
+json.exception.type_error.306 | cannot use value() with string | The @ref value() member functions can only be executed for certain JSON types.
+json.exception.type_error.307 | cannot use erase() with string | The @ref erase() member functions can only be executed for certain JSON types.
+json.exception.type_error.308 | cannot use push_back() with string | The @ref push_back() and @ref operator+= member functions can only be executed for certain JSON types.
+json.exception.type_error.309 | cannot use insert() with | The @ref insert() member functions can only be executed for certain JSON types.
+json.exception.type_error.310 | cannot use swap() with number | The @ref swap() member functions can only be executed for certain JSON types.
+json.exception.type_error.311 | cannot use emplace_back() with string | The @ref emplace_back() member function can only be executed for certain JSON types.
+json.exception.type_error.312 | cannot use update() with string | The @ref update() member functions can only be executed for certain JSON types.
+json.exception.type_error.313 | invalid value to unflatten | The @ref unflatten function converts an object whose keys are JSON Pointers back into an arbitrary nested JSON value. The JSON Pointers must not overlap, because then the resulting value would not be well defined.
+json.exception.type_error.314 | only objects can be unflattened | The @ref unflatten function only works for an object whose keys are JSON Pointers.
+json.exception.type_error.315 | values in object must be primitive | The @ref unflatten function only works for an object whose keys are JSON Pointers and whose values are primitive.
+json.exception.type_error.316 | invalid UTF-8 byte at index 10: 0x7E | The @ref dump function only works with UTF-8 encoded strings; that is, if you assign a `std::string` to a JSON value, make sure it is UTF-8 encoded. |
+json.exception.type_error.317 | JSON value cannot be serialized to requested format | The dynamic type of the object cannot be represented in the requested serialization format (e.g. a raw `true` or `null` JSON object cannot be serialized to BSON) |
+
+@liveexample{The following code shows how a `type_error` exception can be
+caught.,type_error}
+
+@sa - @ref exception for the base class of the library exceptions
+@sa - @ref parse_error for exceptions indicating a parse error
+@sa - @ref invalid_iterator for exceptions indicating errors with iterators
+@sa - @ref out_of_range for exceptions indicating access out of the defined range
+@sa - @ref other_error for exceptions indicating other library errors
+
+@since version 3.0.0
+*/
+class type_error : public exception
+{
+  public:
+    static type_error create(int id_, const std::string& what_arg)
+    {
+        std::string w = exception::name("type_error", id_) + what_arg;
+        return type_error(id_, w.c_str());
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/*!
+@brief exception indicating access out of the defined range
+
+This exception is thrown in case a library function is called on an input
+parameter that exceeds the expected range, for instance in case of array
+indices or nonexisting object keys.
+
+Exceptions have ids 4xx.
+
+name / id                       | example message | description
+------------------------------- | --------------- | -------------------------
+json.exception.out_of_range.401 | array index 3 is out of range | The provided array index @a i is larger than @a size-1.
+json.exception.out_of_range.402 | array index '-' (3) is out of range | The special array index `-` in a JSON Pointer never describes a valid element of the array, but the index past the end. That is, it can only be used to add elements at this position, but not to read it.
+json.exception.out_of_range.403 | key 'foo' not found | The provided key was not found in the JSON object.
+json.exception.out_of_range.404 | unresolved reference token 'foo' | A reference token in a JSON Pointer could not be resolved.
+json.exception.out_of_range.405 | JSON pointer has no parent | The JSON Patch operations 'remove' and 'add' can not be applied to the root element of the JSON value.
+json.exception.out_of_range.406 | number overflow parsing '10E1000' | A parsed number could not be stored as without changing it to NaN or INF.
+json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON and BSON only support integer numbers up to 9223372036854775807. (until version 3.8.0) |
+json.exception.out_of_range.408 | excessive array size: 8658170730974374167 | The size (following `#`) of an UBJSON array or object exceeds the maximal capacity. |
+json.exception.out_of_range.409 | BSON key cannot contain code point U+0000 (at byte 2) | Key identifiers to be serialized to BSON cannot contain code point U+0000, since the key is stored as zero-terminated c-string |
+
+@liveexample{The following code shows how an `out_of_range` exception can be
+caught.,out_of_range}
+
+@sa - @ref exception for the base class of the library exceptions
+@sa - @ref parse_error for exceptions indicating a parse error
+@sa - @ref invalid_iterator for exceptions indicating errors with iterators
+@sa - @ref type_error for exceptions indicating executing a member function with
+                    a wrong type
+@sa - @ref other_error for exceptions indicating other library errors
+
+@since version 3.0.0
+*/
+class out_of_range : public exception
+{
+  public:
+    static out_of_range create(int id_, const std::string& what_arg)
+    {
+        std::string w = exception::name("out_of_range", id_) + what_arg;
+        return out_of_range(id_, w.c_str());
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/*!
+@brief exception indicating other library errors
+
+This exception is thrown in case of errors that cannot be classified with the
+other exception types.
+
+Exceptions have ids 5xx.
+
+name / id                      | example message | description
+------------------------------ | --------------- | -------------------------
+json.exception.other_error.501 | unsuccessful: {"op":"test","path":"/baz", "value":"bar"} | A JSON Patch operation 'test' failed. The unsuccessful operation is also printed.
+
+@sa - @ref exception for the base class of the library exceptions
+@sa - @ref parse_error for exceptions indicating a parse error
+@sa - @ref invalid_iterator for exceptions indicating errors with iterators
+@sa - @ref type_error for exceptions indicating executing a member function with
+                    a wrong type
+@sa - @ref out_of_range for exceptions indicating access out of the defined range
+
+@liveexample{The following code shows how an `other_error` exception can be
+caught.,other_error}
+
+@since version 3.0.0
+*/
+class other_error : public exception
+{
+  public:
+    static other_error create(int id_, const std::string& what_arg)
+    {
+        std::string w = exception::name("other_error", id_) + what_arg;
+        return other_error(id_, w.c_str());
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+
+#include <cstddef> // size_t
+#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
+
+namespace nlohmann
+{
+namespace detail
+{
+// alias templates to reduce boilerplate
+template<bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+template<typename T>
+using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+// implementation of C++14 index_sequence and affiliates
+// source: https://stackoverflow.com/a/32223343
+template<std::size_t... Ints>
+struct index_sequence
+{
+    using type = index_sequence;
+    using value_type = std::size_t;
+    static constexpr std::size_t size() noexcept
+    {
+        return sizeof...(Ints);
+    }
+};
+
+template<class Sequence1, class Sequence2>
+struct merge_and_renumber;
+
+template<std::size_t... I1, std::size_t... I2>
+struct merge_and_renumber<index_sequence<I1...>, index_sequence<I2...>>
+        : index_sequence < I1..., (sizeof...(I1) + I2)... > {};
+
+template<std::size_t N>
+struct make_index_sequence
+    : merge_and_renumber < typename make_index_sequence < N / 2 >::type,
+      typename make_index_sequence < N - N / 2 >::type > {};
+
+template<> struct make_index_sequence<0> : index_sequence<> {};
+template<> struct make_index_sequence<1> : index_sequence<0> {};
+
+template<typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+// dispatch utility (taken from ranges-v3)
+template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
+template<> struct priority_tag<0> {};
+
+// taken from ranges-v3
+template<typename T>
+struct static_const
+{
+    static constexpr T value{};
+};
+
+template<typename T>
+constexpr T static_const<T>::value;
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+#include <limits> // numeric_limits
+#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
+#include <utility> // declval
+
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+
+
+#include <iterator> // random_access_iterator_tag
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename ...Ts> struct make_void
+{
+    using type = void;
+};
+template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
+} // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename It, typename = void>
+struct iterator_types {};
+
+template<typename It>
+struct iterator_types <
+    It,
+    void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
+    typename It::reference, typename It::iterator_category >>
+{
+    using difference_type = typename It::difference_type;
+    using value_type = typename It::value_type;
+    using pointer = typename It::pointer;
+    using reference = typename It::reference;
+    using iterator_category = typename It::iterator_category;
+};
+
+// This is required as some compilers implement std::iterator_traits in a way that
+// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
+template<typename T, typename = void>
+struct iterator_traits
+{
+};
+
+template<typename T>
+struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
+            : iterator_types<T>
+{
+};
+
+template<typename T>
+struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
+{
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = T;
+    using difference_type = ptrdiff_t;
+    using pointer = T*;
+    using reference = T&;
+};
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+
+#include <type_traits>
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+
+
+// https://en.cppreference.com/w/cpp/experimental/is_detected
+namespace nlohmann
+{
+namespace detail
+{
+struct nonesuch
+{
+    nonesuch() = delete;
+    ~nonesuch() = delete;
+    nonesuch(nonesuch const&) = delete;
+    nonesuch(nonesuch const&&) = delete;
+    void operator=(nonesuch const&) = delete;
+    void operator=(nonesuch&&) = delete;
+};
+
+template<class Default,
+         class AlwaysVoid,
+         template<class...> class Op,
+         class... Args>
+struct detector
+{
+    using value_t = std::false_type;
+    using type = Default;
+};
+
+template<class Default, template<class...> class Op, class... Args>
+struct detector<Default, void_t<Op<Args...>>, Op, Args...>
+{
+    using value_t = std::true_type;
+    using type = Op<Args...>;
+};
+
+template<template<class...> class Op, class... Args>
+using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
+
+template<template<class...> class Op, class... Args>
+using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
+
+template<class Default, template<class...> class Op, class... Args>
+using detected_or = detector<Default, void, Op, Args...>;
+
+template<class Default, template<class...> class Op, class... Args>
+using detected_or_t = typename detected_or<Default, Op, Args...>::type;
+
+template<class Expected, template<class...> class Op, class... Args>
+using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
+
+template<class To, template<class...> class Op, class... Args>
+using is_detected_convertible =
+    std::is_convertible<detected_t<Op, Args...>, To>;
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/json_fwd.hpp>
+#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
+#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+#include <cstdint> // int64_t, uint64_t
+#include <map> // map
+#include <memory> // allocator
+#include <string> // string
+#include <vector> // vector
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+namespace nlohmann
+{
+/*!
+@brief default JSONSerializer template argument
+
+This serializer ignores the template arguments and uses ADL
+([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
+for serialization.
+*/
+template<typename T = void, typename SFINAE = void>
+struct adl_serializer;
+
+template<template<typename U, typename V, typename... Args> class ObjectType =
+         std::map,
+         template<typename U, typename... Args> class ArrayType = std::vector,
+         class StringType = std::string, class BooleanType = bool,
+         class NumberIntegerType = std::int64_t,
+         class NumberUnsignedType = std::uint64_t,
+         class NumberFloatType = double,
+         template<typename U> class AllocatorType = std::allocator,
+         template<typename T, typename SFINAE = void> class JSONSerializer =
+         adl_serializer,
+         class BinaryType = std::vector<std::uint8_t>>
+class basic_json;
+
+/*!
+@brief JSON Pointer
+
+A JSON pointer defines a string syntax for identifying a specific value
+within a JSON document. It can be used with functions `at` and
+`operator[]`. Furthermore, JSON pointers are the base for JSON patches.
+
+@sa [RFC 6901](https://tools.ietf.org/html/rfc6901)
+
+@since version 2.0.0
+*/
+template<typename BasicJsonType>
+class json_pointer;
+
+/*!
+@brief default JSON class
+
+This type is the default specialization of the @ref basic_json class which
+uses the standard template types.
+
+@since version 1.0.0
+*/
+using json = basic_json<>;
+
+template<class Key, class T, class IgnoredLess, class Allocator>
+struct ordered_map;
+
+/*!
+@brief ordered JSON class
+
+This type preserves the insertion order of object keys.
+
+@since version 3.9.0
+*/
+using ordered_json = basic_json<nlohmann::ordered_map>;
+
+}  // namespace nlohmann
+
+#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+
+namespace nlohmann
+{
+/*!
+@brief detail namespace with internal helper functions
+
+This namespace collects functions that should not be exposed,
+implementations of some @ref basic_json methods, and meta-programming helpers.
+
+@since version 2.1.0
+*/
+namespace detail
+{
+/////////////
+// helpers //
+/////////////
+
+// Note to maintainers:
+//
+// Every trait in this file expects a non CV-qualified type.
+// The only exceptions are in the 'aliases for detected' section
+// (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
+//
+// In this case, T has to be properly CV-qualified to constraint the function arguments
+// (e.g. to_json(BasicJsonType&, const T&))
+
+template<typename> struct is_basic_json : std::false_type {};
+
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
+
+//////////////////////
+// json_ref helpers //
+//////////////////////
+
+template<typename>
+class json_ref;
+
+template<typename>
+struct is_json_ref : std::false_type {};
+
+template<typename T>
+struct is_json_ref<json_ref<T>> : std::true_type {};
+
+//////////////////////////
+// aliases for detected //
+//////////////////////////
+
+template<typename T>
+using mapped_type_t = typename T::mapped_type;
+
+template<typename T>
+using key_type_t = typename T::key_type;
+
+template<typename T>
+using value_type_t = typename T::value_type;
+
+template<typename T>
+using difference_type_t = typename T::difference_type;
+
+template<typename T>
+using pointer_t = typename T::pointer;
+
+template<typename T>
+using reference_t = typename T::reference;
+
+template<typename T>
+using iterator_category_t = typename T::iterator_category;
+
+template<typename T>
+using iterator_t = typename T::iterator;
+
+template<typename T, typename... Args>
+using to_json_function = decltype(T::to_json(std::declval<Args>()...));
+
+template<typename T, typename... Args>
+using from_json_function = decltype(T::from_json(std::declval<Args>()...));
+
+template<typename T, typename U>
+using get_template_function = decltype(std::declval<T>().template get<U>());
+
+// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
+template<typename BasicJsonType, typename T, typename = void>
+struct has_from_json : std::false_type {};
+
+// trait checking if j.get<T> is valid
+// use this trait instead of std::is_constructible or std::is_convertible,
+// both rely on, or make use of implicit conversions, and thus fail when T
+// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
+template <typename BasicJsonType, typename T>
+struct is_getable
+{
+    static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
+};
+
+template<typename BasicJsonType, typename T>
+struct has_from_json < BasicJsonType, T,
+           enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, from_json_function, serializer,
+        const BasicJsonType&, T&>::value;
+};
+
+// This trait checks if JSONSerializer<T>::from_json(json const&) exists
+// this overload is used for non-default-constructible user-defined-types
+template<typename BasicJsonType, typename T, typename = void>
+struct has_non_default_from_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<T, from_json_function, serializer,
+        const BasicJsonType&>::value;
+};
+
+// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
+// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
+template<typename BasicJsonType, typename T, typename = void>
+struct has_to_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
+        T>::value;
+};
+
+
+///////////////////
+// is_ functions //
+///////////////////
+
+template<typename T, typename = void>
+struct is_iterator_traits : std::false_type {};
+
+template<typename T>
+struct is_iterator_traits<iterator_traits<T>>
+{
+  private:
+    using traits = iterator_traits<T>;
+
+  public:
+    static constexpr auto value =
+        is_detected<value_type_t, traits>::value &&
+        is_detected<difference_type_t, traits>::value &&
+        is_detected<pointer_t, traits>::value &&
+        is_detected<iterator_category_t, traits>::value &&
+        is_detected<reference_t, traits>::value;
+};
+
+// source: https://stackoverflow.com/a/37193089/4116453
+
+template<typename T, typename = void>
+struct is_complete_type : std::false_type {};
+
+template<typename T>
+struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
+
+template<typename BasicJsonType, typename CompatibleObjectType,
+         typename = void>
+struct is_compatible_object_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type_impl <
+    BasicJsonType, CompatibleObjectType,
+    enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
+    is_detected<key_type_t, CompatibleObjectType>::value >>
+{
+
+    using object_t = typename BasicJsonType::object_t;
+
+    // macOS's is_constructible does not play well with nonesuch...
+    static constexpr bool value =
+        std::is_constructible<typename object_t::key_type,
+        typename CompatibleObjectType::key_type>::value &&
+        std::is_constructible<typename object_t::mapped_type,
+        typename CompatibleObjectType::mapped_type>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type
+    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         typename = void>
+struct is_constructible_object_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type_impl <
+    BasicJsonType, ConstructibleObjectType,
+    enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
+    is_detected<key_type_t, ConstructibleObjectType>::value >>
+{
+    using object_t = typename BasicJsonType::object_t;
+
+    static constexpr bool value =
+        (std::is_default_constructible<ConstructibleObjectType>::value &&
+         (std::is_move_assignable<ConstructibleObjectType>::value ||
+          std::is_copy_assignable<ConstructibleObjectType>::value) &&
+         (std::is_constructible<typename ConstructibleObjectType::key_type,
+          typename object_t::key_type>::value &&
+          std::is_same <
+          typename object_t::mapped_type,
+          typename ConstructibleObjectType::mapped_type >::value)) ||
+        (has_from_json<BasicJsonType,
+         typename ConstructibleObjectType::mapped_type>::value ||
+         has_non_default_from_json <
+         BasicJsonType,
+         typename ConstructibleObjectType::mapped_type >::value);
+};
+
+template<typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type
+    : is_constructible_object_type_impl<BasicJsonType,
+      ConstructibleObjectType> {};
+
+template<typename BasicJsonType, typename CompatibleStringType,
+         typename = void>
+struct is_compatible_string_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleStringType>
+struct is_compatible_string_type_impl <
+    BasicJsonType, CompatibleStringType,
+    enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
+    value_type_t, CompatibleStringType>::value >>
+{
+    static constexpr auto value =
+        std::is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
+};
+
+template<typename BasicJsonType, typename ConstructibleStringType>
+struct is_compatible_string_type
+    : is_compatible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
+
+template<typename BasicJsonType, typename ConstructibleStringType,
+         typename = void>
+struct is_constructible_string_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleStringType>
+struct is_constructible_string_type_impl <
+    BasicJsonType, ConstructibleStringType,
+    enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
+    value_type_t, ConstructibleStringType>::value >>
+{
+    static constexpr auto value =
+        std::is_constructible<ConstructibleStringType,
+        typename BasicJsonType::string_t>::value;
+};
+
+template<typename BasicJsonType, typename ConstructibleStringType>
+struct is_constructible_string_type
+    : is_constructible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
+
+template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
+struct is_compatible_array_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type_impl <
+    BasicJsonType, CompatibleArrayType,
+    enable_if_t < is_detected<value_type_t, CompatibleArrayType>::value&&
+    is_detected<iterator_t, CompatibleArrayType>::value&&
+// This is needed because json_reverse_iterator has a ::iterator type...
+// Therefore it is detected as a CompatibleArrayType.
+// The real fix would be to have an Iterable concept.
+    !is_iterator_traits <
+    iterator_traits<CompatibleArrayType >>::value >>
+{
+    static constexpr bool value =
+        std::is_constructible<BasicJsonType,
+        typename CompatibleArrayType::value_type>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type
+    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
+struct is_constructible_array_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t<std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value >>
+            : std::true_type {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t < !std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value&&
+    std::is_default_constructible<ConstructibleArrayType>::value&&
+(std::is_move_assignable<ConstructibleArrayType>::value ||
+ std::is_copy_assignable<ConstructibleArrayType>::value)&&
+is_detected<value_type_t, ConstructibleArrayType>::value&&
+is_detected<iterator_t, ConstructibleArrayType>::value&&
+is_complete_type <
+detected_t<value_type_t, ConstructibleArrayType >>::value >>
+{
+    static constexpr bool value =
+        // This is needed because json_reverse_iterator has a ::iterator type,
+        // furthermore, std::back_insert_iterator (and other iterators) have a
+        // base class `iterator`... Therefore it is detected as a
+        // ConstructibleArrayType. The real fix would be to have an Iterable
+        // concept.
+        !is_iterator_traits<iterator_traits<ConstructibleArrayType>>::value &&
+
+        (std::is_same<typename ConstructibleArrayType::value_type,
+         typename BasicJsonType::array_t::value_type>::value ||
+         has_from_json<BasicJsonType,
+         typename ConstructibleArrayType::value_type>::value ||
+         has_non_default_from_json <
+         BasicJsonType, typename ConstructibleArrayType::value_type >::value);
+};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type
+    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType,
+         typename = void>
+struct is_compatible_integer_type_impl : std::false_type {};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type_impl <
+    RealIntegerType, CompatibleNumberIntegerType,
+    enable_if_t < std::is_integral<RealIntegerType>::value&&
+    std::is_integral<CompatibleNumberIntegerType>::value&&
+    !std::is_same<bool, CompatibleNumberIntegerType>::value >>
+{
+    // is there an assert somewhere on overflows?
+    using RealLimits = std::numeric_limits<RealIntegerType>;
+    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
+
+    static constexpr auto value =
+        std::is_constructible<RealIntegerType,
+        CompatibleNumberIntegerType>::value &&
+        CompatibleLimits::is_integer &&
+        RealLimits::is_signed == CompatibleLimits::is_signed;
+};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type
+    : is_compatible_integer_type_impl<RealIntegerType,
+      CompatibleNumberIntegerType> {};
+
+template<typename BasicJsonType, typename CompatibleType, typename = void>
+struct is_compatible_type_impl: std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type_impl <
+    BasicJsonType, CompatibleType,
+    enable_if_t<is_complete_type<CompatibleType>::value >>
+{
+    static constexpr bool value =
+        has_to_json<BasicJsonType, CompatibleType>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type
+    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
+
+// https://en.cppreference.com/w/cpp/types/conjunction
+template<class...> struct conjunction : std::true_type { };
+template<class B1> struct conjunction<B1> : B1 { };
+template<class B1, class... Bn>
+struct conjunction<B1, Bn...>
+: std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
+
+template<typename T1, typename T2>
+struct is_constructible_tuple : std::false_type {};
+
+template<typename T1, typename... Args>
+struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<std::is_constructible<T1, Args>...> {};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t
+#include <string> // string
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////////////
+// JSON type enumeration //
+///////////////////////////
+
+/*!
+@brief the JSON type enumeration
+
+This enumeration collects the different JSON types. It is internally used to
+distinguish the stored values, and the functions @ref basic_json::is_null(),
+@ref basic_json::is_object(), @ref basic_json::is_array(),
+@ref basic_json::is_string(), @ref basic_json::is_boolean(),
+@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
+@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
+@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
+@ref basic_json::is_structured() rely on it.
+
+@note There are three enumeration entries (number_integer, number_unsigned, and
+number_float), because the library distinguishes these three types for numbers:
+@ref basic_json::number_unsigned_t is used for unsigned integers,
+@ref basic_json::number_integer_t is used for signed integers, and
+@ref basic_json::number_float_t is used for floating-point numbers or to
+approximate integers which do not fit in the limits of their respective type.
+
+@sa @ref basic_json::basic_json(const value_t value_type) -- create a JSON
+value with the default value for a given type
+
+@since version 1.0.0
+*/
+enum class value_t : std::uint8_t
+{
+    null,             ///< null value
+    object,           ///< object (unordered set of name/value pairs)
+    array,            ///< array (ordered collection of values)
+    string,           ///< string value
+    boolean,          ///< boolean value
+    number_integer,   ///< number value (signed integer)
+    number_unsigned,  ///< number value (unsigned integer)
+    number_float,     ///< number value (floating-point)
+    binary,           ///< binary array (ordered collection of bytes)
+    discarded         ///< discarded by the parser callback function
+};
+
+/*!
+@brief comparison operator for JSON types
+
+Returns an ordering that is similar to Python:
+- order: null < boolean < number < object < array < string < binary
+- furthermore, each type is not smaller than itself
+- discarded values are not comparable
+- binary is represented as a b"" string in python and directly comparable to a
+  string; however, making a binary array directly comparable with a string would
+  be surprising behavior in a JSON file.
+
+@since version 1.0.0
+*/
+inline bool operator<(const value_t lhs, const value_t rhs) noexcept
+{
+    static constexpr std::array<std::uint8_t, 9> order = {{
+            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
+            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
+            6 /* binary */
+        }
+    };
+
+    const auto l_index = static_cast<std::size_t>(lhs);
+    const auto r_index = static_cast<std::size_t>(rhs);
+    return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
+}
+}  // namespace detail
+}  // namespace nlohmann
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
+    {
+        JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name())));
+    }
+    n = nullptr;
+}
+
+// overloads for basic_json template parameters
+template < typename BasicJsonType, typename ArithmeticType,
+           enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
+                         !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+                         int > = 0 >
+void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+
+        default:
+            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
+    }
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
+    {
+        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
+    }
+    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
+    }
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template <
+    typename BasicJsonType, typename ConstructibleStringType,
+    enable_if_t <
+        is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
+        !std::is_same<typename BasicJsonType::string_t,
+                      ConstructibleStringType>::value,
+        int > = 0 >
+void from_json(const BasicJsonType& j, ConstructibleStringType& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
+    }
+
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+void from_json(const BasicJsonType& j, EnumType& e)
+{
+    typename std::underlying_type<EnumType>::type val;
+    get_arithmetic_value(j, val);
+    e = static_cast<EnumType>(val);
+}
+
+// forward_list doesn't have an insert method
+template<typename BasicJsonType, typename T, typename Allocator,
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    l.clear();
+    std::transform(j.rbegin(), j.rend(),
+                   std::front_inserter(l), [](const BasicJsonType & i)
+    {
+        return i.template get<T>();
+    });
+}
+
+// valarray doesn't have an insert method
+template<typename BasicJsonType, typename T,
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+void from_json(const BasicJsonType& j, std::valarray<T>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    l.resize(j.size());
+    std::transform(j.begin(), j.end(), std::begin(l),
+                   [](const BasicJsonType & elem)
+    {
+        return elem.template get<T>();
+    });
+}
+
+template<typename BasicJsonType, typename T, std::size_t N>
+auto from_json(const BasicJsonType& j, T (&arr)[N])
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType>
+void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
+{
+    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
+}
+
+template<typename BasicJsonType, typename T, std::size_t N>
+auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
+                          priority_tag<2> /*unused*/)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
+-> decltype(
+    arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
+    j.template get<typename ConstructibleArrayType::value_type>(),
+    void())
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    ret.reserve(j.size());
+    std::transform(j.begin(), j.end(),
+                   std::inserter(ret, end(ret)), [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
+                          priority_tag<0> /*unused*/)
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    std::transform(
+        j.begin(), j.end(), std::inserter(ret, end(ret)),
+        [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template < typename BasicJsonType, typename ConstructibleArrayType,
+           enable_if_t <
+               is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
+               !is_basic_json<ConstructibleArrayType>::value,
+               int > = 0 >
+auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
+-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
+j.template get<typename ConstructibleArrayType::value_type>(),
+void())
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " +
+                                      std::string(j.type_name())));
+    }
+
+    from_json_array_impl(j, arr, priority_tag<3> {});
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
+    {
+        JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(j.type_name())));
+    }
+
+    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
+}
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
+void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
+    {
+        JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
+    }
+
+    ConstructibleObjectType ret;
+    auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
+    using value_type = typename ConstructibleObjectType::value_type;
+    std::transform(
+        inner_object->begin(), inner_object->end(),
+        std::inserter(ret, ret.begin()),
+        [](typename BasicJsonType::object_t::value_type const & p)
+    {
+        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
+    });
+    obj = std::move(ret);
+}
+
+// overload for arithmetic types, not chosen for basic_json template arguments
+// (BooleanType, etc..); note: Is it really necessary to provide explicit
+// overloads for boolean_t etc. in case of a custom BooleanType which is not
+// an arithmetic type?
+template < typename BasicJsonType, typename ArithmeticType,
+           enable_if_t <
+               std::is_arithmetic<ArithmeticType>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+               int > = 0 >
+void from_json(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+        case value_t::boolean:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
+            break;
+        }
+
+        default:
+            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
+    }
+}
+
+template<typename BasicJsonType, typename A1, typename A2>
+void from_json(const BasicJsonType& j, std::pair<A1, A2>& p)
+{
+    p = {j.at(0).template get<A1>(), j.at(1).template get<A2>()};
+}
+
+template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
+void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...> /*unused*/)
+{
+    t = std::make_tuple(j.at(Idx).template get<typename std::tuple_element<Idx, Tuple>::type>()...);
+}
+
+template<typename BasicJsonType, typename... Args>
+void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
+{
+    from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
+}
+
+template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
+           typename = enable_if_t < !std::is_constructible <
+                                        typename BasicJsonType::string_t, Key >::value >>
+void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
+           typename = enable_if_t < !std::is_constructible <
+                                        typename BasicJsonType::string_t, Key >::value >>
+void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+struct from_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(const BasicJsonType& j, T& val) const
+    noexcept(noexcept(from_json(j, val)))
+    -> decltype(from_json(j, val), void())
+    {
+        return from_json(j, val);
+    }
+};
+}  // namespace detail
+
+/// namespace to hold default `from_json` function
+/// to see why this is required:
+/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
+namespace
+{
+constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;
+} // namespace
+} // namespace nlohmann
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+
+
+#include <algorithm> // copy
+#include <iterator> // begin, end
+#include <string> // string
+#include <tuple> // tuple, get
+#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
+#include <utility> // move, forward, declval, pair
+#include <valarray> // valarray
+#include <vector> // vector
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+
+
+#include <cstddef> // size_t
+#include <iterator> // input_iterator_tag
+#include <string> // string, to_string
+#include <tuple> // tuple_size, get, tuple_element
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename string_type>
+void int_to_string( string_type& target, std::size_t value )
+{
+    // For ADL
+    using std::to_string;
+    target = to_string(value);
+}
+template<typename IteratorType> class iteration_proxy_value
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    using value_type = iteration_proxy_value;
+    using pointer = value_type * ;
+    using reference = value_type & ;
+    using iterator_category = std::input_iterator_tag;
+    using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
+
+  private:
+    /// the iterator
+    IteratorType anchor;
+    /// an index for arrays (used to create key names)
+    std::size_t array_index = 0;
+    /// last stringified array index
+    mutable std::size_t array_index_last = 0;
+    /// a string representation of the array index
+    mutable string_type array_index_str = "0";
+    /// an empty string (to return a reference for primitive values)
+    const string_type empty_str = "";
+
+  public:
+    explicit iteration_proxy_value(IteratorType it) noexcept : anchor(it) {}
+
+    /// dereference operator (needed for range-based for)
+    iteration_proxy_value& operator*()
+    {
+        return *this;
+    }
+
+    /// increment operator (needed for range-based for)
+    iteration_proxy_value& operator++()
+    {
+        ++anchor;
+        ++array_index;
+
+        return *this;
+    }
+
+    /// equality operator (needed for InputIterator)
+    bool operator==(const iteration_proxy_value& o) const
+    {
+        return anchor == o.anchor;
+    }
+
+    /// inequality operator (needed for range-based for)
+    bool operator!=(const iteration_proxy_value& o) const
+    {
+        return anchor != o.anchor;
+    }
+
+    /// return key of the iterator
+    const string_type& key() const
+    {
+        JSON_ASSERT(anchor.m_object != nullptr);
+
+        switch (anchor.m_object->type())
+        {
+            // use integer array index as key
+            case value_t::array:
+            {
+                if (array_index != array_index_last)
+                {
+                    int_to_string( array_index_str, array_index );
+                    array_index_last = array_index;
+                }
+                return array_index_str;
+            }
+
+            // use key from the object
+            case value_t::object:
+                return anchor.key();
+
+            // use an empty key for all primitive types
+            default:
+                return empty_str;
+        }
+    }
+
+    /// return value of the iterator
+    typename IteratorType::reference value() const
+    {
+        return anchor.value();
+    }
+};
+
+/// proxy class for the items() function
+template<typename IteratorType> class iteration_proxy
+{
+  private:
+    /// the container to iterate
+    typename IteratorType::reference container;
+
+  public:
+    /// construct iteration proxy from a container
+    explicit iteration_proxy(typename IteratorType::reference cont) noexcept
+        : container(cont) {}
+
+    /// return iterator begin (needed for range-based for)
+    iteration_proxy_value<IteratorType> begin() noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container.begin());
+    }
+
+    /// return iterator end (needed for range-based for)
+    iteration_proxy_value<IteratorType> end() noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container.end());
+    }
+};
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
+{
+    return i.key();
+}
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
+{
+    return i.value();
+}
+}  // namespace detail
+}  // namespace nlohmann
+
+// The Addition to the STD Namespace is required to add
+// Structured Bindings Support to the iteration_proxy_value class
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+namespace std
+{
+#if defined(__clang__)
+    // Fix: https://github.com/nlohmann/json/issues/1401
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+template<typename IteratorType>
+class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
+            : public std::integral_constant<std::size_t, 2> {};
+
+template<std::size_t N, typename IteratorType>
+class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
+{
+  public:
+    using type = decltype(
+                     get<N>(std::declval <
+                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
+};
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+} // namespace std
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+//////////////////
+// constructors //
+//////////////////
+
+template<value_t> struct external_constructor;
+
+template<>
+struct external_constructor<value_t::boolean>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
+    {
+        j.m_type = value_t::boolean;
+        j.m_value = b;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::string>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
+    {
+        j.m_type = value_t::string;
+        j.m_value = s;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+    {
+        j.m_type = value_t::string;
+        j.m_value = std::move(s);
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleStringType,
+               enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
+                             int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleStringType& str)
+    {
+        j.m_type = value_t::string;
+        j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::binary>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
+    {
+        j.m_type = value_t::binary;
+        typename BasicJsonType::binary_t value{b};
+        j.m_value = value;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
+    {
+        j.m_type = value_t::binary;
+        typename BasicJsonType::binary_t value{std::move(b)};
+        j.m_value = value;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_float>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
+    {
+        j.m_type = value_t::number_float;
+        j.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_unsigned>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
+    {
+        j.m_type = value_t::number_unsigned;
+        j.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_integer>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
+    {
+        j.m_type = value_t::number_integer;
+        j.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::array>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
+    {
+        j.m_type = value_t::array;
+        j.m_value = arr;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+    {
+        j.m_type = value_t::array;
+        j.m_value = std::move(arr);
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleArrayType,
+               enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
+                             int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
+    {
+        using std::begin;
+        using std::end;
+        j.m_type = value_t::array;
+        j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
+    {
+        j.m_type = value_t::array;
+        j.m_value = value_t::array;
+        j.m_value.array->reserve(arr.size());
+        for (const bool x : arr)
+        {
+            j.m_value.array->push_back(x);
+        }
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType, typename T,
+             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
+    {
+        j.m_type = value_t::array;
+        j.m_value = value_t::array;
+        j.m_value.array->resize(arr.size());
+        if (arr.size() > 0)
+        {
+            std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
+        }
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::object>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
+    {
+        j.m_type = value_t::object;
+        j.m_value = obj;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+    {
+        j.m_type = value_t::object;
+        j.m_value = std::move(obj);
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleObjectType,
+               enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
+    {
+        using std::begin;
+        using std::end;
+
+        j.m_type = value_t::object;
+        j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
+        j.assert_invariant();
+    }
+};
+
+/////////////
+// to_json //
+/////////////
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
+void to_json(BasicJsonType& j, T b) noexcept
+{
+    external_constructor<value_t::boolean>::construct(j, b);
+}
+
+template<typename BasicJsonType, typename CompatibleString,
+         enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
+void to_json(BasicJsonType& j, const CompatibleString& s)
+{
+    external_constructor<value_t::string>::construct(j, s);
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+{
+    external_constructor<value_t::string>::construct(j, std::move(s));
+}
+
+template<typename BasicJsonType, typename FloatType,
+         enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
+void to_json(BasicJsonType& j, FloatType val) noexcept
+{
+    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
+void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
+{
+    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberIntegerType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
+void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
+{
+    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
+}
+
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+void to_json(BasicJsonType& j, EnumType e) noexcept
+{
+    using underlying_type = typename std::underlying_type<EnumType>::type;
+    external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, const std::vector<bool>& e)
+{
+    external_constructor<value_t::array>::construct(j, e);
+}
+
+template < typename BasicJsonType, typename CompatibleArrayType,
+           enable_if_t < is_compatible_array_type<BasicJsonType,
+                         CompatibleArrayType>::value&&
+                         !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
+                         !is_basic_json<CompatibleArrayType>::value,
+                         int > = 0 >
+void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
+{
+    external_constructor<value_t::binary>::construct(j, bin);
+}
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+void to_json(BasicJsonType& j, const std::valarray<T>& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template < typename BasicJsonType, typename CompatibleObjectType,
+           enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
+void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
+{
+    external_constructor<value_t::object>::construct(j, obj);
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+{
+    external_constructor<value_t::object>::construct(j, std::move(obj));
+}
+
+template <
+    typename BasicJsonType, typename T, std::size_t N,
+    enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
+                  const T(&)[N]>::value,
+                  int > = 0 >
+void to_json(BasicJsonType& j, const T(&arr)[N])
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
+void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
+{
+    j = { p.first, p.second };
+}
+
+// for https://github.com/nlohmann/json/pull/1134
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
+void to_json(BasicJsonType& j, const T& b)
+{
+    j = { {b.key(), b.value()} };
+}
+
+template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
+void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
+{
+    j = { std::get<Idx>(t)... };
+}
+
+template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>
+void to_json(BasicJsonType& j, const T& t)
+{
+    to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
+}
+
+struct to_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
+    -> decltype(to_json(j, std::forward<T>(val)), void())
+    {
+        return to_json(j, std::forward<T>(val));
+    }
+};
+}  // namespace detail
+
+/// namespace to hold default `to_json` function
+namespace
+{
+constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value;
+} // namespace
+} // namespace nlohmann
+
+
+namespace nlohmann
+{
+
+template<typename, typename>
+struct adl_serializer
+{
+    /*!
+    @brief convert a JSON value to any value type
+
+    This function is usually called by the `get()` function of the
+    @ref basic_json class (either explicit or via conversion operators).
+
+    @param[in] j        JSON value to read from
+    @param[in,out] val  value to write to
+    */
+    template<typename BasicJsonType, typename ValueType>
+    static auto from_json(BasicJsonType&& j, ValueType& val) noexcept(
+        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
+    {
+        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
+    }
+
+    /*!
+    @brief convert any value type to a JSON value
+
+    This function is usually called by the constructors of the @ref basic_json
+    class.
+
+    @param[in,out] j  JSON value to write to
+    @param[in] val    value to read from
+    */
+    template<typename BasicJsonType, typename ValueType>
+    static auto to_json(BasicJsonType& j, ValueType&& val) noexcept(
+        noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))
+    -> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)), void())
+    {
+        ::nlohmann::to_json(j, std::forward<ValueType>(val));
+    }
+};
+
+}  // namespace nlohmann
+
+// #include <nlohmann/byte_container_with_subtype.hpp>
+
+
+#include <cstdint> // uint8_t
+#include <tuple> // tie
+#include <utility> // move
+
+namespace nlohmann
+{
+
+/*!
+@brief an internal type for a backed binary type
+
+This type extends the template parameter @a BinaryType provided to `basic_json`
+with a subtype used by BSON and MessagePack. This type exists so that the user
+does not have to specify a type themselves with a specific naming scheme in
+order to override the binary type.
+
+@tparam BinaryType container to store bytes (`std::vector<std::uint8_t>` by
+                   default)
+
+@since version 3.8.0
+*/
+template<typename BinaryType>
+class byte_container_with_subtype : public BinaryType
+{
+  public:
+    /// the type of the underlying container
+    using container_type = BinaryType;
+
+    byte_container_with_subtype() noexcept(noexcept(container_type()))
+        : container_type()
+    {}
+
+    byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+    {}
+
+    byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+    {}
+
+    byte_container_with_subtype(const container_type& b, std::uint8_t subtype) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+        , m_subtype(subtype)
+        , m_has_subtype(true)
+    {}
+
+    byte_container_with_subtype(container_type&& b, std::uint8_t subtype) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+        , m_subtype(subtype)
+        , m_has_subtype(true)
+    {}
+
+    bool operator==(const byte_container_with_subtype& rhs) const
+    {
+        return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
+               std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
+    }
+
+    bool operator!=(const byte_container_with_subtype& rhs) const
+    {
+        return !(rhs == *this);
+    }
+
+    /*!
+    @brief sets the binary subtype
+
+    Sets the binary subtype of the value, also flags a binary JSON value as
+    having a subtype, which has implications for serialization.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @sa @ref subtype() -- return the binary subtype
+    @sa @ref clear_subtype() -- clears the binary subtype
+    @sa @ref has_subtype() -- returns whether or not the binary value has a
+    subtype
+
+    @since version 3.8.0
+    */
+    void set_subtype(std::uint8_t subtype) noexcept
+    {
+        m_subtype = subtype;
+        m_has_subtype = true;
+    }
+
+    /*!
+    @brief return the binary subtype
+
+    Returns the numerical subtype of the value if it has a subtype. If it does
+    not have a subtype, this function will return size_t(-1) as a sentinel
+    value.
+
+    @return the numerical subtype of the binary value
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @sa @ref set_subtype() -- sets the binary subtype
+    @sa @ref clear_subtype() -- clears the binary subtype
+    @sa @ref has_subtype() -- returns whether or not the binary value has a
+    subtype
+
+    @since version 3.8.0
+    */
+    constexpr std::uint8_t subtype() const noexcept
+    {
+        return m_subtype;
+    }
+
+    /*!
+    @brief return whether the value has a subtype
+
+    @return whether the value has a subtype
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @sa @ref subtype() -- return the binary subtype
+    @sa @ref set_subtype() -- sets the binary subtype
+    @sa @ref clear_subtype() -- clears the binary subtype
+
+    @since version 3.8.0
+    */
+    constexpr bool has_subtype() const noexcept
+    {
+        return m_has_subtype;
+    }
+
+    /*!
+    @brief clears the binary subtype
+
+    Clears the binary subtype and flags the value as not having a subtype, which
+    has implications for serialization; for instance MessagePack will prefer the
+    bin family over the ext family.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @sa @ref subtype() -- return the binary subtype
+    @sa @ref set_subtype() -- sets the binary subtype
+    @sa @ref has_subtype() -- returns whether or not the binary value has a
+    subtype
+
+    @since version 3.8.0
+    */
+    void clear_subtype() noexcept
+    {
+        m_subtype = 0;
+        m_has_subtype = false;
+    }
+
+  private:
+    std::uint8_t m_subtype = 0;
+    bool m_has_subtype = false;
+};
+
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/hash.hpp>
+
+
+#include <cstddef> // size_t, uint8_t
+#include <functional> // hash
+
+namespace nlohmann
+{
+namespace detail
+{
+
+// boost::hash_combine
+inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
+{
+    seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
+    return seed;
+}
+
+/*!
+@brief hash a JSON value
+
+The hash function tries to rely on std::hash where possible. Furthermore, the
+type of the JSON value is taken into account to have different hash values for
+null, 0, 0U, and false, etc.
+
+@tparam BasicJsonType basic_json specialization
+@param j JSON value to hash
+@return hash value of j
+*/
+template<typename BasicJsonType>
+std::size_t hash(const BasicJsonType& j)
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+    const auto type = static_cast<std::size_t>(j.type());
+    switch (j.type())
+    {
+        case BasicJsonType::value_t::null:
+        case BasicJsonType::value_t::discarded:
+        {
+            return combine(type, 0);
+        }
+
+        case BasicJsonType::value_t::object:
+        {
+            auto seed = combine(type, j.size());
+            for (const auto& element : j.items())
+            {
+                const auto h = std::hash<string_t> {}(element.key());
+                seed = combine(seed, h);
+                seed = combine(seed, hash(element.value()));
+            }
+            return seed;
+        }
+
+        case BasicJsonType::value_t::array:
+        {
+            auto seed = combine(type, j.size());
+            for (const auto& element : j)
+            {
+                seed = combine(seed, hash(element));
+            }
+            return seed;
+        }
+
+        case BasicJsonType::value_t::string:
+        {
+            const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::boolean:
+        {
+            const auto h = std::hash<bool> {}(j.template get<bool>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_integer:
+        {
+            const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
+            return combine(type, h);
+        }
+
+        case nlohmann::detail::value_t::number_unsigned:
+        {
+            const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
+            return combine(type, h);
+        }
+
+        case nlohmann::detail::value_t::number_float:
+        {
+            const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
+            return combine(type, h);
+        }
+
+        case nlohmann::detail::value_t::binary:
+        {
+            auto seed = combine(type, j.get_binary().size());
+            const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
+            seed = combine(seed, h);
+            seed = combine(seed, j.get_binary().subtype());
+            for (const auto byte : j.get_binary())
+            {
+                seed = combine(seed, std::hash<std::uint8_t> {}(byte));
+            }
+            return seed;
+        }
+
+        default: // LCOV_EXCL_LINE
+            JSON_ASSERT(false); // LCOV_EXCL_LINE
+    }
+}
+
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+
+
+#include <algorithm> // generate_n
+#include <array> // array
+#include <cmath> // ldexp
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstdio> // snprintf
+#include <cstring> // memcpy
+#include <iterator> // back_inserter
+#include <limits> // numeric_limits
+#include <string> // char_traits, string
+#include <utility> // make_pair, move
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstdio> //FILE *
+#include <cstring> // strlen
+#include <istream> // istream
+#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
+#include <memory> // shared_ptr, make_shared, addressof
+#include <numeric> // accumulate
+#include <string> // string, char_traits
+#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
+#include <utility> // pair, declval
+
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+/// the supported input formats
+enum class input_format_t { json, cbor, msgpack, ubjson, bson };
+
+////////////////////
+// input adapters //
+////////////////////
+
+/*!
+Input adapter for stdio file access. This adapter read only 1 byte and do not use any
+ buffer. This adapter is a very low level adapter.
+*/
+class file_input_adapter
+{
+  public:
+    using char_type = char;
+
+    JSON_HEDLEY_NON_NULL(2)
+    explicit file_input_adapter(std::FILE* f) noexcept
+        : m_file(f)
+    {}
+
+    // make class move-only
+    file_input_adapter(const file_input_adapter&) = delete;
+    file_input_adapter(file_input_adapter&&) = default;
+    file_input_adapter& operator=(const file_input_adapter&) = delete;
+    file_input_adapter& operator=(file_input_adapter&&) = delete;
+
+    std::char_traits<char>::int_type get_character() noexcept
+    {
+        return std::fgetc(m_file);
+    }
+
+  private:
+    /// the file pointer to read from
+    std::FILE* m_file;
+};
+
+
+/*!
+Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
+beginning of input. Does not support changing the underlying std::streambuf
+in mid-input. Maintains underlying std::istream and std::streambuf to support
+subsequent use of standard std::istream operations to process any input
+characters following those used in parsing the JSON input.  Clears the
+std::istream flags; any input errors (e.g., EOF) will be detected by the first
+subsequent call for input from the std::istream.
+*/
+class input_stream_adapter
+{
+  public:
+    using char_type = char;
+
+    ~input_stream_adapter()
+    {
+        // clear stream flags; we use underlying streambuf I/O, do not
+        // maintain ifstream flags, except eof
+        if (is != nullptr)
+        {
+            is->clear(is->rdstate() & std::ios::eofbit);
+        }
+    }
+
+    explicit input_stream_adapter(std::istream& i)
+        : is(&i), sb(i.rdbuf())
+    {}
+
+    // delete because of pointer members
+    input_stream_adapter(const input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&& rhs) = delete;
+
+    input_stream_adapter(input_stream_adapter&& rhs) noexcept : is(rhs.is), sb(rhs.sb)
+    {
+        rhs.is = nullptr;
+        rhs.sb = nullptr;
+    }
+
+    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
+    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
+    // end up as the same value, eg. 0xFFFFFFFF.
+    std::char_traits<char>::int_type get_character()
+    {
+        auto res = sb->sbumpc();
+        // set eof manually, as we don't use the istream interface.
+        if (JSON_HEDLEY_UNLIKELY(res == EOF))
+        {
+            is->clear(is->rdstate() | std::ios::eofbit);
+        }
+        return res;
+    }
+
+  private:
+    /// the associated input stream
+    std::istream* is = nullptr;
+    std::streambuf* sb = nullptr;
+};
+
+// General-purpose iterator-based adapter. It might not be as fast as
+// theoretically possible for some containers, but it is extremely versatile.
+template<typename IteratorType>
+class iterator_input_adapter
+{
+  public:
+    using char_type = typename std::iterator_traits<IteratorType>::value_type;
+
+    iterator_input_adapter(IteratorType first, IteratorType last)
+        : current(std::move(first)), end(std::move(last)) {}
+
+    typename std::char_traits<char_type>::int_type get_character()
+    {
+        if (JSON_HEDLEY_LIKELY(current != end))
+        {
+            auto result = std::char_traits<char_type>::to_int_type(*current);
+            std::advance(current, 1);
+            return result;
+        }
+        else
+        {
+            return std::char_traits<char_type>::eof();
+        }
+    }
+
+  private:
+    IteratorType current;
+    IteratorType end;
+
+    template<typename BaseInputAdapter, size_t T>
+    friend struct wide_string_input_helper;
+
+    bool empty() const
+    {
+        return current == end;
+    }
+
+};
+
+
+template<typename BaseInputAdapter, size_t T>
+struct wide_string_input_helper;
+
+template<typename BaseInputAdapter>
+struct wide_string_input_helper<BaseInputAdapter, 4>
+{
+    // UTF-32
+    static void fill_buffer(BaseInputAdapter& input,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (JSON_HEDLEY_UNLIKELY(input.empty()))
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = input.get_character();
+
+            // UTF-32 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (wc <= 0xFFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else if (wc <= 0x10FFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 4;
+            }
+            else
+            {
+                // unknown character
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+        }
+    }
+};
+
+template<typename BaseInputAdapter>
+struct wide_string_input_helper<BaseInputAdapter, 2>
+{
+    // UTF-16
+    static void fill_buffer(BaseInputAdapter& input,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (JSON_HEDLEY_UNLIKELY(input.empty()))
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = input.get_character();
+
+            // UTF-16 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (0xD800 > wc || wc >= 0xE000)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else
+            {
+                if (JSON_HEDLEY_UNLIKELY(!input.empty()))
+                {
+                    const auto wc2 = static_cast<unsigned int>(input.get_character());
+                    const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
+                    utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
+                    utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
+                    utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
+                    utf8_bytes_filled = 4;
+                }
+                else
+                {
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                    utf8_bytes_filled = 1;
+                }
+            }
+        }
+    }
+};
+
+// Wraps another input apdater to convert wide character types into individual bytes.
+template<typename BaseInputAdapter, typename WideCharType>
+class wide_string_input_adapter
+{
+  public:
+    using char_type = char;
+
+    wide_string_input_adapter(BaseInputAdapter base)
+        : base_adapter(base) {}
+
+    typename std::char_traits<char>::int_type get_character() noexcept
+    {
+        // check if buffer needs to be filled
+        if (utf8_bytes_index == utf8_bytes_filled)
+        {
+            fill_buffer<sizeof(WideCharType)>();
+
+            JSON_ASSERT(utf8_bytes_filled > 0);
+            JSON_ASSERT(utf8_bytes_index == 0);
+        }
+
+        // use buffer
+        JSON_ASSERT(utf8_bytes_filled > 0);
+        JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
+        return utf8_bytes[utf8_bytes_index++];
+    }
+
+  private:
+    BaseInputAdapter base_adapter;
+
+    template<size_t T>
+    void fill_buffer()
+    {
+        wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
+    }
+
+    /// a buffer for UTF-8 bytes
+    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
+
+    /// index to the utf8_codes array for the next valid byte
+    std::size_t utf8_bytes_index = 0;
+    /// number of valid bytes in the utf8_codes array
+    std::size_t utf8_bytes_filled = 0;
+};
+
+
+template<typename IteratorType, typename Enable = void>
+struct iterator_input_adapter_factory
+{
+    using iterator_type = IteratorType;
+    using char_type = typename std::iterator_traits<iterator_type>::value_type;
+    using adapter_type = iterator_input_adapter<iterator_type>;
+
+    static adapter_type create(IteratorType first, IteratorType last)
+    {
+        return adapter_type(std::move(first), std::move(last));
+    }
+};
+
+template<typename T>
+struct is_iterator_of_multibyte
+{
+    using value_type = typename std::iterator_traits<T>::value_type;
+    enum
+    {
+        value = sizeof(value_type) > 1
+    };
+};
+
+template<typename IteratorType>
+struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
+{
+    using iterator_type = IteratorType;
+    using char_type = typename std::iterator_traits<iterator_type>::value_type;
+    using base_adapter_type = iterator_input_adapter<iterator_type>;
+    using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
+
+    static adapter_type create(IteratorType first, IteratorType last)
+    {
+        return adapter_type(base_adapter_type(std::move(first), std::move(last)));
+    }
+};
+
+// General purpose iterator-based input
+template<typename IteratorType>
+typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
+{
+    using factory_type = iterator_input_adapter_factory<IteratorType>;
+    return factory_type::create(first, last);
+}
+
+// Convenience shorthand from container to iterator
+template<typename ContainerType>
+auto input_adapter(const ContainerType& container) -> decltype(input_adapter(begin(container), end(container)))
+{
+    // Enable ADL
+    using std::begin;
+    using std::end;
+
+    return input_adapter(begin(container), end(container));
+}
+
+// Special cases with fast paths
+inline file_input_adapter input_adapter(std::FILE* file)
+{
+    return file_input_adapter(file);
+}
+
+inline input_stream_adapter input_adapter(std::istream& stream)
+{
+    return input_stream_adapter(stream);
+}
+
+inline input_stream_adapter input_adapter(std::istream&& stream)
+{
+    return input_stream_adapter(stream);
+}
+
+using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
+
+// Null-delimited strings, and the like.
+template < typename CharT,
+           typename std::enable_if <
+               std::is_pointer<CharT>::value&&
+               !std::is_array<CharT>::value&&
+               std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+               sizeof(typename std::remove_pointer<CharT>::type) == 1,
+               int >::type = 0 >
+contiguous_bytes_input_adapter input_adapter(CharT b)
+{
+    auto length = std::strlen(reinterpret_cast<const char*>(b));
+    const auto* ptr = reinterpret_cast<const char*>(b);
+    return input_adapter(ptr, ptr + length);
+}
+
+template<typename T, std::size_t N>
+auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N))
+{
+    return input_adapter(array, array + N);
+}
+
+// This class only handles inputs of input_buffer_adapter type.
+// It's required so that expressions like {ptr, len} can be implicitely casted
+// to the correct adapter.
+class span_input_adapter
+{
+  public:
+    template < typename CharT,
+               typename std::enable_if <
+                   std::is_pointer<CharT>::value&&
+                   std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+                   sizeof(typename std::remove_pointer<CharT>::type) == 1,
+                   int >::type = 0 >
+    span_input_adapter(CharT b, std::size_t l)
+        : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
+
+    template<class IteratorType,
+             typename std::enable_if<
+                 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
+                 int>::type = 0>
+    span_input_adapter(IteratorType first, IteratorType last)
+        : ia(input_adapter(first, last)) {}
+
+    contiguous_bytes_input_adapter&& get()
+    {
+        return std::move(ia);
+    }
+
+  private:
+    contiguous_bytes_input_adapter ia;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+
+
+#include <cstddef>
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+
+/*!
+@brief SAX interface
+
+This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
+Each function is called in different situations while the input is parsed. The
+boolean return value informs the parser whether to continue processing the
+input.
+*/
+template<typename BasicJsonType>
+struct json_sax
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    /*!
+    @brief a null value was read
+    @return whether parsing should proceed
+    */
+    virtual bool null() = 0;
+
+    /*!
+    @brief a boolean value was read
+    @param[in] val  boolean value
+    @return whether parsing should proceed
+    */
+    virtual bool boolean(bool val) = 0;
+
+    /*!
+    @brief an integer number was read
+    @param[in] val  integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_integer(number_integer_t val) = 0;
+
+    /*!
+    @brief an unsigned integer number was read
+    @param[in] val  unsigned integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_unsigned(number_unsigned_t val) = 0;
+
+    /*!
+    @brief an floating-point number was read
+    @param[in] val  floating-point value
+    @param[in] s    raw token value
+    @return whether parsing should proceed
+    */
+    virtual bool number_float(number_float_t val, const string_t& s) = 0;
+
+    /*!
+    @brief a string was read
+    @param[in] val  string value
+    @return whether parsing should proceed
+    @note It is safe to move the passed string.
+    */
+    virtual bool string(string_t& val) = 0;
+
+    /*!
+    @brief a binary string was read
+    @param[in] val  binary value
+    @return whether parsing should proceed
+    @note It is safe to move the passed binary.
+    */
+    virtual bool binary(binary_t& val) = 0;
+
+    /*!
+    @brief the beginning of an object was read
+    @param[in] elements  number of object elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_object(std::size_t elements) = 0;
+
+    /*!
+    @brief an object key was read
+    @param[in] val  object key
+    @return whether parsing should proceed
+    @note It is safe to move the passed string.
+    */
+    virtual bool key(string_t& val) = 0;
+
+    /*!
+    @brief the end of an object was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_object() = 0;
+
+    /*!
+    @brief the beginning of an array was read
+    @param[in] elements  number of array elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_array(std::size_t elements) = 0;
+
+    /*!
+    @brief the end of an array was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_array() = 0;
+
+    /*!
+    @brief a parse error occurred
+    @param[in] position    the position in the input where the error occurs
+    @param[in] last_token  the last read token
+    @param[in] ex          an exception object describing the error
+    @return whether parsing should proceed (must return false)
+    */
+    virtual bool parse_error(std::size_t position,
+                             const std::string& last_token,
+                             const detail::exception& ex) = 0;
+
+    virtual ~json_sax() = default;
+};
+
+
+namespace detail
+{
+/*!
+@brief SAX implementation to create a JSON value from SAX events
+
+This class implements the @ref json_sax interface and processes the SAX events
+to create a JSON value which makes it basically a DOM parser. The structure or
+hierarchy of the JSON value is managed by the stack `ref_stack` which contains
+a pointer to the respective array or object for each recursion depth.
+
+After successful parsing, the value that is passed by reference to the
+constructor contains the parsed value.
+
+@tparam BasicJsonType  the JSON type
+*/
+template<typename BasicJsonType>
+class json_sax_dom_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    /*!
+    @param[in, out] r  reference to a JSON value that is manipulated while
+                       parsing
+    @param[in] allow_exceptions_  whether parse errors yield exceptions
+    */
+    explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
+        : root(r), allow_exceptions(allow_exceptions_)
+    {}
+
+    // make class move-only
+    json_sax_dom_parser(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser(json_sax_dom_parser&&) = default;
+    json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default;
+    ~json_sax_dom_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool binary(binary_t& val)
+    {
+        handle_value(std::move(val));
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
+
+        if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408,
+                                            "excessive object size: " + std::to_string(len)));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        // add null at given key and store the reference for later
+        object_element = &(ref_stack.back()->m_value.object->operator[](val));
+        return true;
+    }
+
+    bool end_object()
+    {
+        ref_stack.pop_back();
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
+
+        if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408,
+                                            "excessive array size: " + std::to_string(len)));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        ref_stack.pop_back();
+        return true;
+    }
+
+    template<class Exception>
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const Exception& ex)
+    {
+        errored = true;
+        static_cast<void>(ex);
+        if (allow_exceptions)
+        {
+            JSON_THROW(ex);
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+    /*!
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+    */
+    template<typename Value>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    BasicJsonType* handle_value(Value&& v)
+    {
+        if (ref_stack.empty())
+        {
+            root = BasicJsonType(std::forward<Value>(v));
+            return &root;
+        }
+
+        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
+
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
+            return &(ref_stack.back()->m_value.array->back());
+        }
+
+        JSON_ASSERT(ref_stack.back()->is_object());
+        JSON_ASSERT(object_element);
+        *object_element = BasicJsonType(std::forward<Value>(v));
+        return object_element;
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+
+template<typename BasicJsonType>
+class json_sax_dom_callback_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using parser_callback_t = typename BasicJsonType::parser_callback_t;
+    using parse_event_t = typename BasicJsonType::parse_event_t;
+
+    json_sax_dom_callback_parser(BasicJsonType& r,
+                                 const parser_callback_t cb,
+                                 const bool allow_exceptions_ = true)
+        : root(r), callback(cb), allow_exceptions(allow_exceptions_)
+    {
+        keep_stack.push_back(true);
+    }
+
+    // make class move-only
+    json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default;
+    json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default;
+    ~json_sax_dom_callback_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool binary(binary_t& val)
+    {
+        handle_value(std::move(val));
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        // check callback for object start
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::object, true);
+        ref_stack.push_back(val.second);
+
+        // check object limit
+        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len)));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        BasicJsonType k = BasicJsonType(val);
+
+        // check callback for key
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
+        key_keep_stack.push_back(keep);
+
+        // add discarded value at given key and store the reference for later
+        if (keep && ref_stack.back())
+        {
+            object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
+        }
+
+        return true;
+    }
+
+    bool end_object()
+    {
+        if (ref_stack.back() && !callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
+        {
+            // discard object
+            *ref_stack.back() = discarded;
+        }
+
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
+        {
+            // remove discarded value
+            for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
+            {
+                if (it->is_discarded())
+                {
+                    ref_stack.back()->erase(it);
+                    break;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::array, true);
+        ref_stack.push_back(val.second);
+
+        // check array limit
+        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len)));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        bool keep = true;
+
+        if (ref_stack.back())
+        {
+            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
+            if (!keep)
+            {
+                // discard array
+                *ref_stack.back() = discarded;
+            }
+        }
+
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        // remove discarded value
+        if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_value.array->pop_back();
+        }
+
+        return true;
+    }
+
+    template<class Exception>
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const Exception& ex)
+    {
+        errored = true;
+        static_cast<void>(ex);
+        if (allow_exceptions)
+        {
+            JSON_THROW(ex);
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+    /*!
+    @param[in] v  value to add to the JSON value we build during parsing
+    @param[in] skip_callback  whether we should skip calling the callback
+               function; this is required after start_array() and
+               start_object() SAX events, because otherwise we would call the
+               callback function with an empty array or object, respectively.
+
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+
+    @return pair of boolean (whether value should be kept) and pointer (to the
+            passed value in the ref_stack hierarchy; nullptr if not kept)
+    */
+    template<typename Value>
+    std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
+    {
+        JSON_ASSERT(!keep_stack.empty());
+
+        // do not handle this value if we know it would be added to a discarded
+        // container
+        if (!keep_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // create value
+        auto value = BasicJsonType(std::forward<Value>(v));
+
+        // check callback
+        const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
+
+        // do not handle this value if we just learnt it shall be discarded
+        if (!keep)
+        {
+            return {false, nullptr};
+        }
+
+        if (ref_stack.empty())
+        {
+            root = std::move(value);
+            return {true, &root};
+        }
+
+        // skip this value if we already decided to skip the parent
+        // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
+        if (!ref_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // we now only expect arrays and objects
+        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
+
+        // array
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_value.array->push_back(std::move(value));
+            return {true, &(ref_stack.back()->m_value.array->back())};
+        }
+
+        // object
+        JSON_ASSERT(ref_stack.back()->is_object());
+        // check if we should store an element for the current key
+        JSON_ASSERT(!key_keep_stack.empty());
+        const bool store_element = key_keep_stack.back();
+        key_keep_stack.pop_back();
+
+        if (!store_element)
+        {
+            return {false, nullptr};
+        }
+
+        JSON_ASSERT(object_element);
+        *object_element = std::move(value);
+        return {true, object_element};
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// stack to manage which values to keep
+    std::vector<bool> keep_stack {};
+    /// stack to manage which object keys to keep
+    std::vector<bool> key_keep_stack {};
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// callback function
+    const parser_callback_t callback = nullptr;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+    /// a discarded value for the callback
+    BasicJsonType discarded = BasicJsonType::value_t::discarded;
+};
+
+template<typename BasicJsonType>
+class json_sax_acceptor
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    bool null()
+    {
+        return true;
+    }
+
+    bool boolean(bool /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_integer(number_integer_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool string(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool binary(binary_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool start_object(std::size_t /*unused*/ = std::size_t(-1))
+    {
+        return true;
+    }
+
+    bool key(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool end_object()
+    {
+        return true;
+    }
+
+    bool start_array(std::size_t /*unused*/ = std::size_t(-1))
+    {
+        return true;
+    }
+
+    bool end_array()
+    {
+        return true;
+    }
+
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
+    {
+        return false;
+    }
+};
+}  // namespace detail
+
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+
+#include <array> // array
+#include <clocale> // localeconv
+#include <cstddef> // size_t
+#include <cstdio> // snprintf
+#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
+#include <initializer_list> // initializer_list
+#include <string> // char_traits, string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/position_t.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////
+// lexer //
+///////////
+
+template<typename BasicJsonType>
+class lexer_base
+{
+  public:
+    /// token types for the parser
+    enum class token_type
+    {
+        uninitialized,    ///< indicating the scanner is uninitialized
+        literal_true,     ///< the `true` literal
+        literal_false,    ///< the `false` literal
+        literal_null,     ///< the `null` literal
+        value_string,     ///< a string -- use get_string() for actual value
+        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value
+        value_integer,    ///< a signed integer -- use get_number_integer() for actual value
+        value_float,      ///< an floating point number -- use get_number_float() for actual value
+        begin_array,      ///< the character for array begin `[`
+        begin_object,     ///< the character for object begin `{`
+        end_array,        ///< the character for array end `]`
+        end_object,       ///< the character for object end `}`
+        name_separator,   ///< the name separator `:`
+        value_separator,  ///< the value separator `,`
+        parse_error,      ///< indicating a parse error
+        end_of_input,     ///< indicating the end of the input buffer
+        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)
+    };
+
+    /// return name of values of type token_type (only used for errors)
+    JSON_HEDLEY_RETURNS_NON_NULL
+    JSON_HEDLEY_CONST
+    static const char* token_type_name(const token_type t) noexcept
+    {
+        switch (t)
+        {
+            case token_type::uninitialized:
+                return "<uninitialized>";
+            case token_type::literal_true:
+                return "true literal";
+            case token_type::literal_false:
+                return "false literal";
+            case token_type::literal_null:
+                return "null literal";
+            case token_type::value_string:
+                return "string literal";
+            case token_type::value_unsigned:
+            case token_type::value_integer:
+            case token_type::value_float:
+                return "number literal";
+            case token_type::begin_array:
+                return "'['";
+            case token_type::begin_object:
+                return "'{'";
+            case token_type::end_array:
+                return "']'";
+            case token_type::end_object:
+                return "'}'";
+            case token_type::name_separator:
+                return "':'";
+            case token_type::value_separator:
+                return "','";
+            case token_type::parse_error:
+                return "<parse error>";
+            case token_type::end_of_input:
+                return "end of input";
+            case token_type::literal_or_value:
+                return "'[', '{', or a literal";
+            // LCOV_EXCL_START
+            default: // catch non-enum values
+                return "unknown token";
+                // LCOV_EXCL_STOP
+        }
+    }
+};
+/*!
+@brief lexical analysis
+
+This class organizes the lexical analysis during JSON deserialization.
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class lexer : public lexer_base<BasicJsonType>
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using char_type = typename InputAdapterType::char_type;
+    using char_int_type = typename std::char_traits<char_type>::int_type;
+
+  public:
+    using token_type = typename lexer_base<BasicJsonType>::token_type;
+
+    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false)
+        : ia(std::move(adapter))
+        , ignore_comments(ignore_comments_)
+        , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
+    {}
+
+    // delete because of pointer members
+    lexer(const lexer&) = delete;
+    lexer(lexer&&) = default;
+    lexer& operator=(lexer&) = delete;
+    lexer& operator=(lexer&&) = default;
+    ~lexer() = default;
+
+  private:
+    /////////////////////
+    // locales
+    /////////////////////
+
+    /// return the locale-dependent decimal point
+    JSON_HEDLEY_PURE
+    static char get_decimal_point() noexcept
+    {
+        const auto* loc = localeconv();
+        JSON_ASSERT(loc != nullptr);
+        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
+    }
+
+    /////////////////////
+    // scan functions
+    /////////////////////
+
+    /*!
+    @brief get codepoint from 4 hex characters following `\u`
+
+    For input "\u c1 c2 c3 c4" the codepoint is:
+      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
+    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
+
+    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
+    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
+    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
+    between the ASCII value of the character and the desired integer value.
+
+    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
+            non-hex character)
+    */
+    int get_codepoint()
+    {
+        // this function only makes sense after reading `\u`
+        JSON_ASSERT(current == 'u');
+        int codepoint = 0;
+
+        const auto factors = { 12u, 8u, 4u, 0u };
+        for (const auto factor : factors)
+        {
+            get();
+
+            if (current >= '0' && current <= '9')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
+            }
+            else if (current >= 'A' && current <= 'F')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
+            }
+            else if (current >= 'a' && current <= 'f')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
+            }
+            else
+            {
+                return -1;
+            }
+        }
+
+        JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
+        return codepoint;
+    }
+
+    /*!
+    @brief check if the next byte(s) are inside a given range
+
+    Adds the current byte and, for each passed range, reads a new byte and
+    checks if it is inside the range. If a violation was detected, set up an
+    error message and return false. Otherwise, return true.
+
+    @param[in] ranges  list of integers; interpreted as list of pairs of
+                       inclusive lower and upper bound, respectively
+
+    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
+         1, 2, or 3 pairs. This precondition is enforced by an assertion.
+
+    @return true if and only if no range violation was detected
+    */
+    bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
+    {
+        JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
+        add(current);
+
+        for (auto range = ranges.begin(); range != ranges.end(); ++range)
+        {
+            get();
+            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
+            {
+                add(current);
+            }
+            else
+            {
+                error_message = "invalid string: ill-formed UTF-8 byte";
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief scan a string literal
+
+    This function scans a string according to Sect. 7 of RFC 7159. While
+    scanning, bytes are escaped and copied into buffer token_buffer. Then the
+    function returns successfully, token_buffer is *not* null-terminated (as it
+    may contain \0 bytes), and token_buffer.size() is the number of bytes in the
+    string.
+
+    @return token_type::value_string if string could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note In case of errors, variable error_message contains a textual
+          description.
+    */
+    token_type scan_string()
+    {
+        // reset token_buffer (ignore opening quote)
+        reset();
+
+        // we entered the function by reading an open quote
+        JSON_ASSERT(current == '\"');
+
+        while (true)
+        {
+            // get next character
+            switch (get())
+            {
+                // end of file while parsing string
+                case std::char_traits<char_type>::eof():
+                {
+                    error_message = "invalid string: missing closing quote";
+                    return token_type::parse_error;
+                }
+
+                // closing quote
+                case '\"':
+                {
+                    return token_type::value_string;
+                }
+
+                // escapes
+                case '\\':
+                {
+                    switch (get())
+                    {
+                        // quotation mark
+                        case '\"':
+                            add('\"');
+                            break;
+                        // reverse solidus
+                        case '\\':
+                            add('\\');
+                            break;
+                        // solidus
+                        case '/':
+                            add('/');
+                            break;
+                        // backspace
+                        case 'b':
+                            add('\b');
+                            break;
+                        // form feed
+                        case 'f':
+                            add('\f');
+                            break;
+                        // line feed
+                        case 'n':
+                            add('\n');
+                            break;
+                        // carriage return
+                        case 'r':
+                            add('\r');
+                            break;
+                        // tab
+                        case 't':
+                            add('\t');
+                            break;
+
+                        // unicode escapes
+                        case 'u':
+                        {
+                            const int codepoint1 = get_codepoint();
+                            int codepoint = codepoint1; // start with codepoint1
+
+                            if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
+                            {
+                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                return token_type::parse_error;
+                            }
+
+                            // check if code point is a high surrogate
+                            if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
+                            {
+                                // expect next \uxxxx entry
+                                if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
+                                {
+                                    const int codepoint2 = get_codepoint();
+
+                                    if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
+                                    {
+                                        error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                        return token_type::parse_error;
+                                    }
+
+                                    // check if codepoint2 is a low surrogate
+                                    if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
+                                    {
+                                        // overwrite codepoint
+                                        codepoint = static_cast<int>(
+                                                        // high surrogate occupies the most significant 22 bits
+                                                        (static_cast<unsigned int>(codepoint1) << 10u)
+                                                        // low surrogate occupies the least significant 15 bits
+                                                        + static_cast<unsigned int>(codepoint2)
+                                                        // there is still the 0xD800, 0xDC00 and 0x10000 noise
+                                                        // in the result so we have to subtract with:
+                                                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+                                                        - 0x35FDC00u);
+                                    }
+                                    else
+                                    {
+                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                        return token_type::parse_error;
+                                    }
+                                }
+                                else
+                                {
+                                    error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+                            else
+                            {
+                                if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
+                                {
+                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+
+                            // result of the above calculation yields a proper codepoint
+                            JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
+
+                            // translate codepoint into bytes
+                            if (codepoint < 0x80)
+                            {
+                                // 1-byte characters: 0xxxxxxx (ASCII)
+                                add(static_cast<char_int_type>(codepoint));
+                            }
+                            else if (codepoint <= 0x7FF)
+                            {
+                                // 2-byte characters: 110xxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else if (codepoint <= 0xFFFF)
+                            {
+                                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else
+                            {
+                                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+
+                            break;
+                        }
+
+                        // other characters after escape
+                        default:
+                            error_message = "invalid string: forbidden character after backslash";
+                            return token_type::parse_error;
+                    }
+
+                    break;
+                }
+
+                // invalid control characters
+                case 0x00:
+                {
+                    error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
+                    return token_type::parse_error;
+                }
+
+                case 0x01:
+                {
+                    error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
+                    return token_type::parse_error;
+                }
+
+                case 0x02:
+                {
+                    error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
+                    return token_type::parse_error;
+                }
+
+                case 0x03:
+                {
+                    error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
+                    return token_type::parse_error;
+                }
+
+                case 0x04:
+                {
+                    error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
+                    return token_type::parse_error;
+                }
+
+                case 0x05:
+                {
+                    error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
+                    return token_type::parse_error;
+                }
+
+                case 0x06:
+                {
+                    error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
+                    return token_type::parse_error;
+                }
+
+                case 0x07:
+                {
+                    error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
+                    return token_type::parse_error;
+                }
+
+                case 0x08:
+                {
+                    error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
+                    return token_type::parse_error;
+                }
+
+                case 0x09:
+                {
+                    error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
+                    return token_type::parse_error;
+                }
+
+                case 0x0A:
+                {
+                    error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
+                    return token_type::parse_error;
+                }
+
+                case 0x0B:
+                {
+                    error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
+                    return token_type::parse_error;
+                }
+
+                case 0x0C:
+                {
+                    error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
+                    return token_type::parse_error;
+                }
+
+                case 0x0D:
+                {
+                    error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
+                    return token_type::parse_error;
+                }
+
+                case 0x0E:
+                {
+                    error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
+                    return token_type::parse_error;
+                }
+
+                case 0x0F:
+                {
+                    error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
+                    return token_type::parse_error;
+                }
+
+                case 0x10:
+                {
+                    error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
+                    return token_type::parse_error;
+                }
+
+                case 0x11:
+                {
+                    error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
+                    return token_type::parse_error;
+                }
+
+                case 0x12:
+                {
+                    error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
+                    return token_type::parse_error;
+                }
+
+                case 0x13:
+                {
+                    error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
+                    return token_type::parse_error;
+                }
+
+                case 0x14:
+                {
+                    error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
+                    return token_type::parse_error;
+                }
+
+                case 0x15:
+                {
+                    error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
+                    return token_type::parse_error;
+                }
+
+                case 0x16:
+                {
+                    error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
+                    return token_type::parse_error;
+                }
+
+                case 0x17:
+                {
+                    error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
+                    return token_type::parse_error;
+                }
+
+                case 0x18:
+                {
+                    error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
+                    return token_type::parse_error;
+                }
+
+                case 0x19:
+                {
+                    error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
+                    return token_type::parse_error;
+                }
+
+                case 0x1A:
+                {
+                    error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
+                    return token_type::parse_error;
+                }
+
+                case 0x1B:
+                {
+                    error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
+                    return token_type::parse_error;
+                }
+
+                case 0x1C:
+                {
+                    error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
+                    return token_type::parse_error;
+                }
+
+                case 0x1D:
+                {
+                    error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
+                    return token_type::parse_error;
+                }
+
+                case 0x1E:
+                {
+                    error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
+                    return token_type::parse_error;
+                }
+
+                case 0x1F:
+                {
+                    error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
+                    return token_type::parse_error;
+                }
+
+                // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
+                case 0x20:
+                case 0x21:
+                case 0x23:
+                case 0x24:
+                case 0x25:
+                case 0x26:
+                case 0x27:
+                case 0x28:
+                case 0x29:
+                case 0x2A:
+                case 0x2B:
+                case 0x2C:
+                case 0x2D:
+                case 0x2E:
+                case 0x2F:
+                case 0x30:
+                case 0x31:
+                case 0x32:
+                case 0x33:
+                case 0x34:
+                case 0x35:
+                case 0x36:
+                case 0x37:
+                case 0x38:
+                case 0x39:
+                case 0x3A:
+                case 0x3B:
+                case 0x3C:
+                case 0x3D:
+                case 0x3E:
+                case 0x3F:
+                case 0x40:
+                case 0x41:
+                case 0x42:
+                case 0x43:
+                case 0x44:
+                case 0x45:
+                case 0x46:
+                case 0x47:
+                case 0x48:
+                case 0x49:
+                case 0x4A:
+                case 0x4B:
+                case 0x4C:
+                case 0x4D:
+                case 0x4E:
+                case 0x4F:
+                case 0x50:
+                case 0x51:
+                case 0x52:
+                case 0x53:
+                case 0x54:
+                case 0x55:
+                case 0x56:
+                case 0x57:
+                case 0x58:
+                case 0x59:
+                case 0x5A:
+                case 0x5B:
+                case 0x5D:
+                case 0x5E:
+                case 0x5F:
+                case 0x60:
+                case 0x61:
+                case 0x62:
+                case 0x63:
+                case 0x64:
+                case 0x65:
+                case 0x66:
+                case 0x67:
+                case 0x68:
+                case 0x69:
+                case 0x6A:
+                case 0x6B:
+                case 0x6C:
+                case 0x6D:
+                case 0x6E:
+                case 0x6F:
+                case 0x70:
+                case 0x71:
+                case 0x72:
+                case 0x73:
+                case 0x74:
+                case 0x75:
+                case 0x76:
+                case 0x77:
+                case 0x78:
+                case 0x79:
+                case 0x7A:
+                case 0x7B:
+                case 0x7C:
+                case 0x7D:
+                case 0x7E:
+                case 0x7F:
+                {
+                    add(current);
+                    break;
+                }
+
+                // U+0080..U+07FF: bytes C2..DF 80..BF
+                case 0xC2:
+                case 0xC3:
+                case 0xC4:
+                case 0xC5:
+                case 0xC6:
+                case 0xC7:
+                case 0xC8:
+                case 0xC9:
+                case 0xCA:
+                case 0xCB:
+                case 0xCC:
+                case 0xCD:
+                case 0xCE:
+                case 0xCF:
+                case 0xD0:
+                case 0xD1:
+                case 0xD2:
+                case 0xD3:
+                case 0xD4:
+                case 0xD5:
+                case 0xD6:
+                case 0xD7:
+                case 0xD8:
+                case 0xD9:
+                case 0xDA:
+                case 0xDB:
+                case 0xDC:
+                case 0xDD:
+                case 0xDE:
+                case 0xDF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
+                case 0xE0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
+                // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
+                case 0xE1:
+                case 0xE2:
+                case 0xE3:
+                case 0xE4:
+                case 0xE5:
+                case 0xE6:
+                case 0xE7:
+                case 0xE8:
+                case 0xE9:
+                case 0xEA:
+                case 0xEB:
+                case 0xEC:
+                case 0xEE:
+                case 0xEF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+D000..U+D7FF: bytes ED 80..9F 80..BF
+                case 0xED:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
+                case 0xF0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
+                case 0xF1:
+                case 0xF2:
+                case 0xF3:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
+                case 0xF4:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // remaining bytes (80..C1 and F5..FF) are ill-formed
+                default:
+                {
+                    error_message = "invalid string: ill-formed UTF-8 byte";
+                    return token_type::parse_error;
+                }
+            }
+        }
+    }
+
+    /*!
+     * @brief scan a comment
+     * @return whether comment could be scanned successfully
+     */
+    bool scan_comment()
+    {
+        switch (get())
+        {
+            // single-line comments skip input until a newline or EOF is read
+            case '/':
+            {
+                while (true)
+                {
+                    switch (get())
+                    {
+                        case '\n':
+                        case '\r':
+                        case std::char_traits<char_type>::eof():
+                        case '\0':
+                            return true;
+
+                        default:
+                            break;
+                    }
+                }
+            }
+
+            // multi-line comments skip input until */ is read
+            case '*':
+            {
+                while (true)
+                {
+                    switch (get())
+                    {
+                        case std::char_traits<char_type>::eof():
+                        case '\0':
+                        {
+                            error_message = "invalid comment; missing closing '*/'";
+                            return false;
+                        }
+
+                        case '*':
+                        {
+                            switch (get())
+                            {
+                                case '/':
+                                    return true;
+
+                                default:
+                                {
+                                    unget();
+                                    continue;
+                                }
+                            }
+                        }
+
+                        default:
+                            continue;
+                    }
+                }
+            }
+
+            // unexpected character after reading '/'
+            default:
+            {
+                error_message = "invalid comment; expecting '/' or '*' after '/'";
+                return false;
+            }
+        }
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(float& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtof(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtod(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(long double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtold(str, endptr);
+    }
+
+    /*!
+    @brief scan a number literal
+
+    This function scans a string according to Sect. 6 of RFC 7159.
+
+    The function is realized with a deterministic finite state machine derived
+    from the grammar described in RFC 7159. Starting in state "init", the
+    input is read and used to determined the next state. Only state "done"
+    accepts the number. State "error" is a trap state to model errors. In the
+    table below, "anything" means any character but the ones listed before.
+
+    state    | 0        | 1-9      | e E      | +       | -       | .        | anything
+    ---------|----------|----------|----------|---------|---------|----------|-----------
+    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
+    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
+    zero     | done     | done     | exponent | done    | done    | decimal1 | done
+    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
+    decimal1 | decimal2 | decimal2 | [error]  | [error] | [error] | [error]  | [error]
+    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
+    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
+    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
+    any2     | any2     | any2     | done     | done    | done    | done     | done
+
+    The state machine is realized with one label per state (prefixed with
+    "scan_number_") and `goto` statements between them. The state machine
+    contains cycles, but any cycle can be left when EOF is read. Therefore,
+    the function is guaranteed to terminate.
+
+    During scanning, the read bytes are stored in token_buffer. This string is
+    then converted to a signed integer, an unsigned integer, or a
+    floating-point number.
+
+    @return token_type::value_unsigned, token_type::value_integer, or
+            token_type::value_float if number could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note The scanner is independent of the current locale. Internally, the
+          locale's decimal point is used instead of `.` to work with the
+          locale-dependent converters.
+    */
+    token_type scan_number()  // lgtm [cpp/use-of-goto]
+    {
+        // reset token_buffer to store the number's bytes
+        reset();
+
+        // the type of the parsed number; initially set to unsigned; will be
+        // changed if minus sign, decimal point or exponent is read
+        token_type number_type = token_type::value_unsigned;
+
+        // state (init): we just found out we need to scan a number
+        switch (current)
+        {
+            case '-':
+            {
+                add(current);
+                goto scan_number_minus;
+            }
+
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            // all other characters are rejected outside scan_number()
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false);  // LCOV_EXCL_LINE
+        }
+
+scan_number_minus:
+        // state: we just parsed a leading minus sign
+        number_type = token_type::value_integer;
+        switch (get())
+        {
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '-'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_zero:
+        // state: we just parse a zero (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '.':
+            {
+                add(decimal_point_char);
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_any1:
+        // state: we just parsed a number 0-9 (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            case '.':
+            {
+                add(decimal_point_char);
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_decimal1:
+        // state: we just parsed a decimal point
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '.'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_decimal2:
+        // we just parsed at least one number after a decimal point
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_exponent:
+        // we just parsed an exponent
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '+':
+            case '-':
+            {
+                add(current);
+                goto scan_number_sign;
+            }
+
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message =
+                    "invalid number; expected '+', '-', or digit after exponent";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_sign:
+        // we just parsed an exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after exponent sign";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_any2:
+        // we just parsed a number after the exponent or exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_done:
+        // unget the character after the number (we only read it to know that
+        // we are done scanning a number)
+        unget();
+
+        char* endptr = nullptr;
+        errno = 0;
+
+        // try to parse integers first and fall back to floats
+        if (number_type == token_type::value_unsigned)
+        {
+            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno == 0)
+            {
+                value_unsigned = static_cast<number_unsigned_t>(x);
+                if (value_unsigned == x)
+                {
+                    return token_type::value_unsigned;
+                }
+            }
+        }
+        else if (number_type == token_type::value_integer)
+        {
+            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno == 0)
+            {
+                value_integer = static_cast<number_integer_t>(x);
+                if (value_integer == x)
+                {
+                    return token_type::value_integer;
+                }
+            }
+        }
+
+        // this code is reached if we parse a floating-point number or if an
+        // integer conversion above failed
+        strtof(value_float, token_buffer.data(), &endptr);
+
+        // we checked the number format before
+        JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+        return token_type::value_float;
+    }
+
+    /*!
+    @param[in] literal_text  the literal text to expect
+    @param[in] length        the length of the passed literal text
+    @param[in] return_type   the token type to return on success
+    */
+    JSON_HEDLEY_NON_NULL(2)
+    token_type scan_literal(const char_type* literal_text, const std::size_t length,
+                            token_type return_type)
+    {
+        JSON_ASSERT(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
+        for (std::size_t i = 1; i < length; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))
+            {
+                error_message = "invalid literal";
+                return token_type::parse_error;
+            }
+        }
+        return return_type;
+    }
+
+    /////////////////////
+    // input management
+    /////////////////////
+
+    /// reset token_buffer; current character is beginning of token
+    void reset() noexcept
+    {
+        token_buffer.clear();
+        token_string.clear();
+        token_string.push_back(std::char_traits<char_type>::to_char_type(current));
+    }
+
+    /*
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a
+    `std::char_traits<char>::eof()` in that case.  Stores the scanned characters
+    for use in error messages.
+
+    @return character read from the input
+    */
+    char_int_type get()
+    {
+        ++position.chars_read_total;
+        ++position.chars_read_current_line;
+
+        if (next_unget)
+        {
+            // just reset the next_unget variable and work with current
+            next_unget = false;
+        }
+        else
+        {
+            current = ia.get_character();
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
+        {
+            token_string.push_back(std::char_traits<char_type>::to_char_type(current));
+        }
+
+        if (current == '\n')
+        {
+            ++position.lines_read;
+            position.chars_read_current_line = 0;
+        }
+
+        return current;
+    }
+
+    /*!
+    @brief unget current character (read it again on next get)
+
+    We implement unget by setting variable next_unget to true. The input is not
+    changed - we just simulate ungetting by modifying chars_read_total,
+    chars_read_current_line, and token_string. The next call to get() will
+    behave as if the unget character is read again.
+    */
+    void unget()
+    {
+        next_unget = true;
+
+        --position.chars_read_total;
+
+        // in case we "unget" a newline, we have to also decrement the lines_read
+        if (position.chars_read_current_line == 0)
+        {
+            if (position.lines_read > 0)
+            {
+                --position.lines_read;
+            }
+        }
+        else
+        {
+            --position.chars_read_current_line;
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
+        {
+            JSON_ASSERT(!token_string.empty());
+            token_string.pop_back();
+        }
+    }
+
+    /// add a character to token_buffer
+    void add(char_int_type c)
+    {
+        token_buffer.push_back(static_cast<typename string_t::value_type>(c));
+    }
+
+  public:
+    /////////////////////
+    // value getters
+    /////////////////////
+
+    /// return integer value
+    constexpr number_integer_t get_number_integer() const noexcept
+    {
+        return value_integer;
+    }
+
+    /// return unsigned integer value
+    constexpr number_unsigned_t get_number_unsigned() const noexcept
+    {
+        return value_unsigned;
+    }
+
+    /// return floating-point value
+    constexpr number_float_t get_number_float() const noexcept
+    {
+        return value_float;
+    }
+
+    /// return current string value (implicitly resets the token; useful only once)
+    string_t& get_string()
+    {
+        return token_buffer;
+    }
+
+    /////////////////////
+    // diagnostics
+    /////////////////////
+
+    /// return position of last read token
+    constexpr position_t get_position() const noexcept
+    {
+        return position;
+    }
+
+    /// return the last read token (for errors only).  Will never contain EOF
+    /// (an arbitrary value that is not a valid char value, often -1), because
+    /// 255 may legitimately occur.  May contain NUL, which should be escaped.
+    std::string get_token_string() const
+    {
+        // escape control characters
+        std::string result;
+        for (const auto c : token_string)
+        {
+            if (static_cast<unsigned char>(c) <= '\x1F')
+            {
+                // escape control characters
+                std::array<char, 9> cs{{}};
+                (std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c));
+                result += cs.data();
+            }
+            else
+            {
+                // add character as is
+                result.push_back(static_cast<std::string::value_type>(c));
+            }
+        }
+
+        return result;
+    }
+
+    /// return syntax error message
+    JSON_HEDLEY_RETURNS_NON_NULL
+    constexpr const char* get_error_message() const noexcept
+    {
+        return error_message;
+    }
+
+    /////////////////////
+    // actual scanner
+    /////////////////////
+
+    /*!
+    @brief skip the UTF-8 byte order mark
+    @return true iff there is no BOM or the correct BOM has been skipped
+    */
+    bool skip_bom()
+    {
+        if (get() == 0xEF)
+        {
+            // check if we completely parse the BOM
+            return get() == 0xBB && get() == 0xBF;
+        }
+
+        // the first character is not the beginning of the BOM; unget it to
+        // process is later
+        unget();
+        return true;
+    }
+
+    void skip_whitespace()
+    {
+        do
+        {
+            get();
+        }
+        while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
+    }
+
+    token_type scan()
+    {
+        // initially, skip the BOM
+        if (position.chars_read_total == 0 && !skip_bom())
+        {
+            error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
+            return token_type::parse_error;
+        }
+
+        // read next character and ignore whitespace
+        skip_whitespace();
+
+        // ignore comments
+        while (ignore_comments && current == '/')
+        {
+            if (!scan_comment())
+            {
+                return token_type::parse_error;
+            }
+
+            // skip following whitespace
+            skip_whitespace();
+        }
+
+        switch (current)
+        {
+            // structural characters
+            case '[':
+                return token_type::begin_array;
+            case ']':
+                return token_type::end_array;
+            case '{':
+                return token_type::begin_object;
+            case '}':
+                return token_type::end_object;
+            case ':':
+                return token_type::name_separator;
+            case ',':
+                return token_type::value_separator;
+
+            // literals
+            case 't':
+            {
+                std::array<char_type, 4> true_literal = {{'t', 'r', 'u', 'e'}};
+                return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
+            }
+            case 'f':
+            {
+                std::array<char_type, 5> false_literal = {{'f', 'a', 'l', 's', 'e'}};
+                return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
+            }
+            case 'n':
+            {
+                std::array<char_type, 4> null_literal = {{'n', 'u', 'l', 'l'}};
+                return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
+            }
+
+            // string
+            case '\"':
+                return scan_string();
+
+            // number
+            case '-':
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                return scan_number();
+
+            // end of input (the null byte is needed when parsing from
+            // string literals)
+            case '\0':
+            case std::char_traits<char_type>::eof():
+                return token_type::end_of_input;
+
+            // error
+            default:
+                error_message = "invalid literal";
+                return token_type::parse_error;
+        }
+    }
+
+  private:
+    /// input adapter
+    InputAdapterType ia;
+
+    /// whether comments should be ignored (true) or signaled as errors (false)
+    const bool ignore_comments = false;
+
+    /// the current character
+    char_int_type current = std::char_traits<char_type>::eof();
+
+    /// whether the next get() call should just return current
+    bool next_unget = false;
+
+    /// the start position of the current token
+    position_t position {};
+
+    /// raw input token string (for error messages)
+    std::vector<char_type> token_string {};
+
+    /// buffer for variable-length tokens (numbers, strings)
+    string_t token_buffer {};
+
+    /// a description of occurred lexer errors
+    const char* error_message = "";
+
+    // number values
+    number_integer_t value_integer = 0;
+    number_unsigned_t value_unsigned = 0;
+    number_float_t value_float = 0;
+
+    /// the decimal point
+    const char_int_type decimal_point_char = '.';
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+
+
+#include <cstdint> // size_t
+#include <utility> // declval
+#include <string> // string
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename T>
+using null_function_t = decltype(std::declval<T&>().null());
+
+template<typename T>
+using boolean_function_t =
+    decltype(std::declval<T&>().boolean(std::declval<bool>()));
+
+template<typename T, typename Integer>
+using number_integer_function_t =
+    decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
+
+template<typename T, typename Unsigned>
+using number_unsigned_function_t =
+    decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
+
+template<typename T, typename Float, typename String>
+using number_float_function_t = decltype(std::declval<T&>().number_float(
+                                    std::declval<Float>(), std::declval<const String&>()));
+
+template<typename T, typename String>
+using string_function_t =
+    decltype(std::declval<T&>().string(std::declval<String&>()));
+
+template<typename T, typename Binary>
+using binary_function_t =
+    decltype(std::declval<T&>().binary(std::declval<Binary&>()));
+
+template<typename T>
+using start_object_function_t =
+    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
+
+template<typename T, typename String>
+using key_function_t =
+    decltype(std::declval<T&>().key(std::declval<String&>()));
+
+template<typename T>
+using end_object_function_t = decltype(std::declval<T&>().end_object());
+
+template<typename T>
+using start_array_function_t =
+    decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
+
+template<typename T>
+using end_array_function_t = decltype(std::declval<T&>().end_array());
+
+template<typename T, typename Exception>
+using parse_error_function_t = decltype(std::declval<T&>().parse_error(
+        std::declval<std::size_t>(), std::declval<const std::string&>(),
+        std::declval<const Exception&>()));
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static constexpr bool value =
+        is_detected_exact<bool, null_function_t, SAX>::value &&
+        is_detected_exact<bool, boolean_function_t, SAX>::value &&
+        is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
+        is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
+        is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
+        is_detected_exact<bool, start_object_function_t, SAX>::value &&
+        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, end_object_function_t, SAX>::value &&
+        is_detected_exact<bool, start_array_function_t, SAX>::value &&
+        is_detected_exact<bool, end_array_function_t, SAX>::value &&
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
+};
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax_static_asserts
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
+                  "Missing/invalid function: bool null()");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(
+        is_detected_exact<bool, number_integer_function_t, SAX,
+        number_integer_t>::value,
+        "Missing/invalid function: bool number_integer(number_integer_t)");
+    static_assert(
+        is_detected_exact<bool, number_unsigned_function_t, SAX,
+        number_unsigned_t>::value,
+        "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
+    static_assert(is_detected_exact<bool, number_float_function_t, SAX,
+                  number_float_t, string_t>::value,
+                  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
+    static_assert(
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value,
+        "Missing/invalid function: bool string(string_t&)");
+    static_assert(
+        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
+        "Missing/invalid function: bool binary(binary_t&)");
+    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_object(std::size_t)");
+    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
+                  "Missing/invalid function: bool key(string_t&)");
+    static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_object()");
+    static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_array(std::size_t)");
+    static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_array()");
+    static_assert(
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
+        "Missing/invalid function: bool parse_error(std::size_t, const "
+        "std::string&, const exception&)");
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+
+/// how to treat CBOR tags
+enum class cbor_tag_handler_t
+{
+    error,  ///< throw a parse_error exception in case of a tag
+    ignore   ///< ignore tags
+};
+
+/*!
+@brief determine system byte order
+
+@return true if and only if system's byte order is little endian
+
+@note from https://stackoverflow.com/a/1001328/266378
+*/
+static inline bool little_endianess(int num = 1) noexcept
+{
+    return *reinterpret_cast<char*>(&num) == 1;
+}
+
+
+///////////////////
+// binary reader //
+///////////////////
+
+/*!
+@brief deserialization of CBOR, MessagePack, and UBJSON values
+*/
+template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>
+class binary_reader
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using json_sax_t = SAX;
+    using char_type = typename InputAdapterType::char_type;
+    using char_int_type = typename std::char_traits<char_type>::int_type;
+
+  public:
+    /*!
+    @brief create a binary reader
+
+    @param[in] adapter  input adapter to read from
+    */
+    explicit binary_reader(InputAdapterType&& adapter) : ia(std::move(adapter))
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+    }
+
+    // make class move-only
+    binary_reader(const binary_reader&) = delete;
+    binary_reader(binary_reader&&) = default;
+    binary_reader& operator=(const binary_reader&) = delete;
+    binary_reader& operator=(binary_reader&&) = default;
+    ~binary_reader() = default;
+
+    /*!
+    @param[in] format  the binary format to parse
+    @param[in] sax_    a SAX event processor
+    @param[in] strict  whether to expect the input to be consumed completed
+    @param[in] tag_handler  how to treat CBOR tags
+
+    @return
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool sax_parse(const input_format_t format,
+                   json_sax_t* sax_,
+                   const bool strict = true,
+                   const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        sax = sax_;
+        bool result = false;
+
+        switch (format)
+        {
+            case input_format_t::bson:
+                result = parse_bson_internal();
+                break;
+
+            case input_format_t::cbor:
+                result = parse_cbor_internal(true, tag_handler);
+                break;
+
+            case input_format_t::msgpack:
+                result = parse_msgpack_internal();
+                break;
+
+            case input_format_t::ubjson:
+                result = parse_ubjson_internal();
+                break;
+
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false);  // LCOV_EXCL_LINE
+        }
+
+        // strict mode: next byte must be EOF
+        if (result && strict)
+        {
+            if (format == input_format_t::ubjson)
+            {
+                get_ignore_noop();
+            }
+            else
+            {
+                get();
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))
+            {
+                return sax->parse_error(chars_read, get_token_string(),
+                                        parse_error::create(110, chars_read, exception_message(format, "expected end of input; last byte: 0x" + get_token_string(), "value")));
+            }
+        }
+
+        return result;
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @brief Reads in a BSON-object and passes it to the SAX-parser.
+    @return whether a valid BSON-value was passed to the SAX parser
+    */
+    bool parse_bson_internal()
+    {
+        std::int32_t document_size{};
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
+        {
+            return false;
+        }
+
+        return sax->end_object();
+    }
+
+    /*!
+    @brief Parses a C-style string from the BSON input.
+    @param[in, out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @return `true` if the \x00-byte indicating the end of the string was
+             encountered before the EOF; false` indicates an unexpected EOF.
+    */
+    bool get_bson_cstr(string_t& result)
+    {
+        auto out = std::back_inserter(result);
+        while (true)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
+            {
+                return false;
+            }
+            if (current == 0x00)
+            {
+                return true;
+            }
+            *out++ = static_cast<typename string_t::value_type>(current);
+        }
+    }
+
+    /*!
+    @brief Parses a zero-terminated string of length @a len from the BSON
+           input.
+    @param[in] len  The length (including the zero-byte at the end) of the
+                    string to be read.
+    @param[in, out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 1
+    @return `true` if the string was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_string(const NumberType len, string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 1))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string")));
+        }
+
+        return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != std::char_traits<char_type>::eof();
+    }
+
+    /*!
+    @brief Parses a byte array input of length @a len from the BSON input.
+    @param[in] len  The length of the byte array to be read.
+    @param[in, out] result  A reference to the binary variable where the read
+                            array is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 0
+    @return `true` if the byte array was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_binary(const NumberType len, binary_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 0))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "byte array length cannot be negative, is " + std::to_string(len), "binary")));
+        }
+
+        // All BSON binary values have a subtype
+        std::uint8_t subtype{};
+        get_number<std::uint8_t>(input_format_t::bson, subtype);
+        result.set_subtype(subtype);
+
+        return get_binary(input_format_t::bson, len, result);
+    }
+
+    /*!
+    @brief Read a BSON document element of the given @a element_type.
+    @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
+    @param[in] element_type_parse_position The position in the input stream,
+               where the `element_type` was read.
+    @warning Not all BSON element types are supported yet. An unsupported
+             @a element_type will give rise to a parse_error.114:
+             Unsupported BSON record type 0x...
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_internal(const char_int_type element_type,
+                                     const std::size_t element_type_parse_position)
+    {
+        switch (element_type)
+        {
+            case 0x01: // double
+            {
+                double number{};
+                return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0x02: // string
+            {
+                std::int32_t len{};
+                string_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
+            }
+
+            case 0x03: // object
+            {
+                return parse_bson_internal();
+            }
+
+            case 0x04: // array
+            {
+                return parse_bson_array();
+            }
+
+            case 0x05: // binary
+            {
+                std::int32_t len{};
+                binary_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
+            }
+
+            case 0x08: // boolean
+            {
+                return sax->boolean(get() != 0);
+            }
+
+            case 0x0A: // null
+            {
+                return sax->null();
+            }
+
+            case 0x10: // int32
+            {
+                std::int32_t value{};
+                return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+            }
+
+            case 0x12: // int64
+            {
+                std::int64_t value{};
+                return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+            }
+
+            default: // anything else not supported (yet)
+            {
+                std::array<char, 3> cr{{}};
+                (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type));
+                return sax->parse_error(element_type_parse_position, std::string(cr.data()), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr.data())));
+            }
+        }
+    }
+
+    /*!
+    @brief Read a BSON element list (as specified in the BSON-spec)
+
+    The same binary layout is used for objects and arrays, hence it must be
+    indicated with the argument @a is_array which one is expected
+    (true --> array, false --> object).
+
+    @param[in] is_array Determines if the element list being read is to be
+                        treated as an object (@a is_array == false), or as an
+                        array (@a is_array == true).
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_list(const bool is_array)
+    {
+        string_t key;
+
+        while (auto element_type = get())
+        {
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
+            {
+                return false;
+            }
+
+            const std::size_t element_type_parse_position = chars_read;
+            if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
+            {
+                return false;
+            }
+
+            if (!is_array && !sax->key(key))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
+            {
+                return false;
+            }
+
+            // get_bson_cstr only appends
+            key.clear();
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief Reads an array from the BSON input and passes it to the SAX-parser.
+    @return whether a valid BSON-array was passed to the SAX parser
+    */
+    bool parse_bson_array()
+    {
+        std::int32_t document_size{};
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
+        {
+            return false;
+        }
+
+        return sax->end_array();
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true) or whether the last read character should
+                         be considered instead (false)
+    @param[in] tag_handler how CBOR tags should be treated
+
+    @return whether a valid CBOR value was passed to the SAX parser
+    */
+    bool parse_cbor_internal(const bool get_char,
+                             const cbor_tag_handler_t tag_handler)
+    {
+        switch (get_char ? get() : current)
+        {
+            // EOF
+            case std::char_traits<char_type>::eof():
+                return unexpect_eof(input_format_t::cbor, "value");
+
+            // Integer 0x00..0x17 (0..23)
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            case 0x18: // Unsigned integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x19: // Unsigned integer (two-byte uint16_t follows)
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x1A: // Unsigned integer (four-byte uint32_t follows)
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            // Negative integer -1-0x00..-1-0x17 (-1..-24)
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+                return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
+
+            case 0x38: // Negative integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
+                        - static_cast<number_integer_t>(number));
+            }
+
+            // Binary data (0x00..0x17 bytes follow)
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58: // Binary data (one-byte uint8_t for n follows)
+            case 0x59: // Binary data (two-byte uint16_t for n follow)
+            case 0x5A: // Binary data (four-byte uint32_t for n follow)
+            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+            case 0x5F: // Binary data (indefinite length)
+            {
+                binary_t b;
+                return get_cbor_binary(b) && sax->binary(b);
+            }
+
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                string_t s;
+                return get_cbor_string(s) && sax->string(s);
+            }
+
+            // array (0x00..0x17 data items follow)
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+                return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+            case 0x98: // array (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x99: // array (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9A: // array (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9B: // array (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9F: // array (indefinite length)
+                return get_cbor_array(std::size_t(-1), tag_handler);
+
+            // map (0x00..0x17 pairs of data items follow)
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+                return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+            case 0xB8: // map (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xB9: // map (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBA: // map (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBB: // map (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBF: // map (indefinite length)
+                return get_cbor_object(std::size_t(-1), tag_handler);
+
+            case 0xC6: // tagged item
+            case 0xC7:
+            case 0xC8:
+            case 0xC9:
+            case 0xCA:
+            case 0xCB:
+            case 0xCC:
+            case 0xCD:
+            case 0xCE:
+            case 0xCF:
+            case 0xD0:
+            case 0xD1:
+            case 0xD2:
+            case 0xD3:
+            case 0xD4:
+            case 0xD8: // tagged item (1 bytes follow)
+            case 0xD9: // tagged item (2 bytes follow)
+            case 0xDA: // tagged item (4 bytes follow)
+            case 0xDB: // tagged item (8 bytes follow)
+            {
+                switch (tag_handler)
+                {
+                    case cbor_tag_handler_t::error:
+                    {
+                        auto last_token = get_token_string();
+                        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
+                    }
+
+                    case cbor_tag_handler_t::ignore:
+                    {
+                        switch (current)
+                        {
+                            case 0xD8:
+                            {
+                                std::uint8_t len{};
+                                get_number(input_format_t::cbor, len);
+                                break;
+                            }
+                            case 0xD9:
+                            {
+                                std::uint16_t len{};
+                                get_number(input_format_t::cbor, len);
+                                break;
+                            }
+                            case 0xDA:
+                            {
+                                std::uint32_t len{};
+                                get_number(input_format_t::cbor, len);
+                                break;
+                            }
+                            case 0xDB:
+                            {
+                                std::uint64_t len{};
+                                get_number(input_format_t::cbor, len);
+                                break;
+                            }
+                            default:
+                                break;
+                        }
+                        return parse_cbor_internal(true, tag_handler);
+                    }
+
+                    default:            // LCOV_EXCL_LINE
+                        JSON_ASSERT(false);  // LCOV_EXCL_LINE
+                }
+            }
+
+            case 0xF4: // false
+                return sax->boolean(false);
+
+            case 0xF5: // true
+                return sax->boolean(true);
+
+            case 0xF6: // null
+                return sax->null();
+
+            case 0xF9: // Half-Precision Float (two-byte IEEE 754)
+            {
+                const auto byte1_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+                const auto byte2_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+
+                const auto byte1 = static_cast<unsigned char>(byte1_raw);
+                const auto byte2 = static_cast<unsigned char>(byte2_raw);
+
+                // code from RFC 7049, Appendix D, Figure 3:
+                // As half-precision floating-point numbers were only added
+                // to IEEE 754 in 2008, today's programming platforms often
+                // still only have limited support for them. It is very
+                // easy to include at least decoding support for them even
+                // without such support. An example of a small decoder for
+                // half-precision floating-point numbers in the C language
+                // is shown in Fig. 3.
+                const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
+                const double val = [&half]
+                {
+                    const int exp = (half >> 10u) & 0x1Fu;
+                    const unsigned int mant = half & 0x3FFu;
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
+                    JSON_ASSERT(mant <= 1024);
+                    switch (exp)
+                    {
+                        case 0:
+                            return std::ldexp(mant, -24);
+                        case 31:
+                            return (mant == 0)
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
+                return sax->number_float((half & 0x8000u) != 0
+                                         ? static_cast<number_float_t>(-val)
+                                         : static_cast<number_float_t>(val), "");
+            }
+
+            case 0xFA: // Single-Precision Float (four-byte IEEE 754)
+            {
+                float number{};
+                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
+            {
+                double number{};
+                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            default: // anything else (0xFF is handled inside the other types)
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+    Additionally, CBOR's strings with indefinite lengths are supported.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_cbor_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            {
+                return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    string_t chunk;
+                    if (!get_cbor_string(chunk))
+                    {
+                        return false;
+                    }
+                    result.append(chunk);
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x" + last_token, "string")));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR byte array
+
+    This function first reads starting bytes to determine the expected
+    byte array length and then copies this number of bytes into the byte array.
+    Additionally, CBOR's byte arrays with indefinite lengths are supported.
+
+    @param[out] result  created byte array
+
+    @return whether byte array creation completed
+    */
+    bool get_cbor_binary(binary_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // Binary data (0x00..0x17 bytes follow)
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            {
+                return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x58: // Binary data (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x59: // Binary data (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5A: // Binary data (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5F: // Binary data (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    binary_t chunk;
+                    if (!get_cbor_binary(chunk))
+                    {
+                        return false;
+                    }
+                    result.insert(result.end(), chunk.begin(), chunk.end());
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x" + last_token, "binary")));
+            }
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array or std::size_t(-1) for an
+                    array of indefinite size
+    @param[in] tag_handler how CBOR tags should be treated
+    @return whether array creation completed
+    */
+    bool get_cbor_array(const std::size_t len,
+                        const cbor_tag_handler_t tag_handler)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        {
+            return false;
+        }
+
+        if (len != std::size_t(-1))
+        {
+            for (std::size_t i = 0; i < len; ++i)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                {
+                    return false;
+                }
+            }
+        }
+        else
+        {
+            while (get() != 0xFF)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
+                {
+                    return false;
+                }
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object or std::size_t(-1) for an
+                    object of indefinite size
+    @param[in] tag_handler how CBOR tags should be treated
+    @return whether object creation completed
+    */
+    bool get_cbor_object(const std::size_t len,
+                         const cbor_tag_handler_t tag_handler)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+        {
+            return false;
+        }
+
+        string_t key;
+        if (len != std::size_t(-1))
+        {
+            for (std::size_t i = 0; i < len; ++i)
+            {
+                get();
+                if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+                {
+                    return false;
+                }
+
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                {
+                    return false;
+                }
+                key.clear();
+            }
+        }
+        else
+        {
+            while (get() != 0xFF)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+                {
+                    return false;
+                }
+
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                {
+                    return false;
+                }
+                key.clear();
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    /*!
+    @return whether a valid MessagePack value was passed to the SAX parser
+    */
+    bool parse_msgpack_internal()
+    {
+        switch (get())
+        {
+            // EOF
+            case std::char_traits<char_type>::eof():
+                return unexpect_eof(input_format_t::msgpack, "value");
+
+            // positive fixint
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+            case 0x18:
+            case 0x19:
+            case 0x1A:
+            case 0x1B:
+            case 0x1C:
+            case 0x1D:
+            case 0x1E:
+            case 0x1F:
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+            case 0x38:
+            case 0x39:
+            case 0x3A:
+            case 0x3B:
+            case 0x3C:
+            case 0x3D:
+            case 0x3E:
+            case 0x3F:
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58:
+            case 0x59:
+            case 0x5A:
+            case 0x5B:
+            case 0x5C:
+            case 0x5D:
+            case 0x5E:
+            case 0x5F:
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78:
+            case 0x79:
+            case 0x7A:
+            case 0x7B:
+            case 0x7C:
+            case 0x7D:
+            case 0x7E:
+            case 0x7F:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            // fixmap
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+                return get_msgpack_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixarray
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+            case 0x98:
+            case 0x99:
+            case 0x9A:
+            case 0x9B:
+            case 0x9C:
+            case 0x9D:
+            case 0x9E:
+            case 0x9F:
+                return get_msgpack_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            case 0xD9: // str 8
+            case 0xDA: // str 16
+            case 0xDB: // str 32
+            {
+                string_t s;
+                return get_msgpack_string(s) && sax->string(s);
+            }
+
+            case 0xC0: // nil
+                return sax->null();
+
+            case 0xC2: // false
+                return sax->boolean(false);
+
+            case 0xC3: // true
+                return sax->boolean(true);
+
+            case 0xC4: // bin 8
+            case 0xC5: // bin 16
+            case 0xC6: // bin 32
+            case 0xC7: // ext 8
+            case 0xC8: // ext 16
+            case 0xC9: // ext 32
+            case 0xD4: // fixext 1
+            case 0xD5: // fixext 2
+            case 0xD6: // fixext 4
+            case 0xD7: // fixext 8
+            case 0xD8: // fixext 16
+            {
+                binary_t b;
+                return get_msgpack_binary(b) && sax->binary(b);
+            }
+
+            case 0xCA: // float 32
+            {
+                float number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCB: // float 64
+            {
+                double number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCC: // uint 8
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCD: // uint 16
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCE: // uint 32
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCF: // uint 64
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xD0: // int 8
+            {
+                std::int8_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD1: // int 16
+            {
+                std::int16_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD2: // int 32
+            {
+                std::int32_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD3: // int 64
+            {
+                std::int64_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xDC: // array 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
+            }
+
+            case 0xDD: // array 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
+            }
+
+            case 0xDE: // map 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xDF: // map 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
+            }
+
+            // negative fixint
+            case 0xE0:
+            case 0xE1:
+            case 0xE2:
+            case 0xE3:
+            case 0xE4:
+            case 0xE5:
+            case 0xE6:
+            case 0xE7:
+            case 0xE8:
+            case 0xE9:
+            case 0xEA:
+            case 0xEB:
+            case 0xEC:
+            case 0xED:
+            case 0xEE:
+            case 0xEF:
+            case 0xF0:
+            case 0xF1:
+            case 0xF2:
+            case 0xF3:
+            case 0xF4:
+            case 0xF5:
+            case 0xF6:
+            case 0xF7:
+            case 0xF8:
+            case 0xF9:
+            case 0xFA:
+            case 0xFB:
+            case 0xFC:
+            case 0xFD:
+            case 0xFE:
+            case 0xFF:
+                return sax->number_integer(static_cast<std::int8_t>(current));
+
+            default: // anything else
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::msgpack, "invalid byte: 0x" + last_token, "value")));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_msgpack_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            {
+                return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0xD9: // str 8
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDA: // str 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDB: // str 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::msgpack, "expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x" + last_token, "string")));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack byte array
+
+    This function first reads starting bytes to determine the expected
+    byte array length and then copies this number of bytes into a byte array.
+
+    @param[out] result  created byte array
+
+    @return whether byte array creation completed
+    */
+    bool get_msgpack_binary(binary_t& result)
+    {
+        // helper function to set the subtype
+        auto assign_and_return_true = [&result](std::int8_t subtype)
+        {
+            result.set_subtype(static_cast<std::uint8_t>(subtype));
+            return true;
+        };
+
+        switch (current)
+        {
+            case 0xC4: // bin 8
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC5: // bin 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC6: // bin 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC7: // ext 8
+            {
+                std::uint8_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xC8: // ext 16
+            {
+                std::uint16_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xC9: // ext 32
+            {
+                std::uint32_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD4: // fixext 1
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 1, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD5: // fixext 2
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 2, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD6: // fixext 4
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 4, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD7: // fixext 8
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 8, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD8: // fixext 16
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 16, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            default:           // LCOV_EXCL_LINE
+                return false;  // LCOV_EXCL_LINE
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array
+    @return whether array creation completed
+    */
+    bool get_msgpack_array(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        {
+            return false;
+        }
+
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            {
+                return false;
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object
+    @return whether object creation completed
+    */
+    bool get_msgpack_object(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+        {
+            return false;
+        }
+
+        string_t key;
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            {
+                return false;
+            }
+            key.clear();
+        }
+
+        return sax->end_object();
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether a valid UBJSON value was passed to the SAX parser
+    */
+    bool parse_ubjson_internal(const bool get_char = true)
+    {
+        return get_ubjson_value(get_char ? get_ignore_noop() : current);
+    }
+
+    /*!
+    @brief reads a UBJSON string
+
+    This function is either called after reading the 'S' byte explicitly
+    indicating a string, or in case of an object key where the 'S' byte can be
+    left out.
+
+    @param[out] result   created string
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether string creation completed
+    */
+    bool get_ubjson_string(string_t& result, const bool get_char = true)
+    {
+        if (get_char)
+        {
+            get();  // TODO(niels): may we ignore N here?
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            case 'U':
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'i':
+            {
+                std::int8_t len{};
+                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'I':
+            {
+                std::int16_t len{};
+                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'l':
+            {
+                std::int32_t len{};
+                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'L':
+            {
+                std::int64_t len{};
+                return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
+            }
+
+            default:
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token, "string")));
+        }
+    }
+
+    /*!
+    @param[out] result  determined size
+    @return whether size determination completed
+    */
+    bool get_ubjson_size_value(std::size_t& result)
+    {
+        switch (get_ignore_noop())
+        {
+            case 'U':
+            {
+                std::uint8_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'i':
+            {
+                std::int8_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'I':
+            {
+                std::int16_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'l':
+            {
+                std::int32_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'L':
+            {
+                std::int64_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token, "size")));
+            }
+        }
+    }
+
+    /*!
+    @brief determine the type and size for a container
+
+    In the optimized UBJSON format, a type and a size can be provided to allow
+    for a more compact representation.
+
+    @param[out] result  pair of the size and the type
+
+    @return whether pair creation completed
+    */
+    bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result)
+    {
+        result.first = string_t::npos; // size
+        result.second = 0; // type
+
+        get_ignore_noop();
+
+        if (current == '$')
+        {
+            result.second = get();  // must not ignore 'N', because 'N' maybe the type
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "type")))
+            {
+                return false;
+            }
+
+            get_ignore_noop();
+            if (JSON_HEDLEY_UNLIKELY(current != '#'))
+            {
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
+                {
+                    return false;
+                }
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "expected '#' after type information; last byte: 0x" + last_token, "size")));
+            }
+
+            return get_ubjson_size_value(result.first);
+        }
+
+        if (current == '#')
+        {
+            return get_ubjson_size_value(result.first);
+        }
+
+        return true;
+    }
+
+    /*!
+    @param prefix  the previously read or set type prefix
+    @return whether value creation completed
+    */
+    bool get_ubjson_value(const char_int_type prefix)
+    {
+        switch (prefix)
+        {
+            case std::char_traits<char_type>::eof():  // EOF
+                return unexpect_eof(input_format_t::ubjson, "value");
+
+            case 'T':  // true
+                return sax->boolean(true);
+            case 'F':  // false
+                return sax->boolean(false);
+
+            case 'Z':  // null
+                return sax->null();
+
+            case 'U':
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_unsigned(number);
+            }
+
+            case 'i':
+            {
+                std::int8_t number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
+            }
+
+            case 'I':
+            {
+                std::int16_t number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
+            }
+
+            case 'l':
+            {
+                std::int32_t number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
+            }
+
+            case 'L':
+            {
+                std::int64_t number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
+            }
+
+            case 'd':
+            {
+                float number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'D':
+            {
+                double number{};
+                return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'H':
+            {
+                return get_ubjson_high_precision_number();
+            }
+
+            case 'C':  // char
+            {
+                get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "char")))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(current > 127))
+                {
+                    auto last_token = get_token_string();
+                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + last_token, "char")));
+                }
+                string_t s(1, static_cast<typename string_t::value_type>(current));
+                return sax->string(s);
+            }
+
+            case 'S':  // string
+            {
+                string_t s;
+                return get_ubjson_string(s) && sax->string(s);
+            }
+
+            case '[':  // array
+                return get_ubjson_array();
+
+            case '{':  // object
+                return get_ubjson_object();
+
+            default: // anything else
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "invalid byte: 0x" + last_token, "value")));
+            }
+        }
+    }
+
+    /*!
+    @return whether array creation completed
+    */
+    bool get_ubjson_array()
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        if (size_and_type.first != string_t::npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                if (size_and_type.second != 'N')
+                {
+                    for (std::size_t i = 0; i < size_and_type.first; ++i)
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                        {
+                            return false;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
+            {
+                return false;
+            }
+
+            while (current != ']')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @return whether object creation completed
+    */
+    bool get_ubjson_object()
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        string_t key;
+        if (size_and_type.first != string_t::npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
+            {
+                return false;
+            }
+
+            while (current != '}')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+                key.clear();
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    // Note, no reader for UBJSON binary types is implemented because they do
+    // not exist
+
+    bool get_ubjson_high_precision_number()
+    {
+        // get size of following number string
+        std::size_t size{};
+        auto res = get_ubjson_size_value(size);
+        if (JSON_HEDLEY_UNLIKELY(!res))
+        {
+            return res;
+        }
+
+        // get number string
+        std::vector<char> number_vector;
+        for (std::size_t i = 0; i < size; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "number")))
+            {
+                return false;
+            }
+            number_vector.push_back(static_cast<char>(current));
+        }
+
+        // parse number string
+        auto number_ia = detail::input_adapter(std::forward<decltype(number_vector)>(number_vector));
+        auto number_lexer = detail::lexer<BasicJsonType, decltype(number_ia)>(std::move(number_ia), false);
+        const auto result_number = number_lexer.scan();
+        const auto number_string = number_lexer.get_token_string();
+        const auto result_remainder = number_lexer.scan();
+
+        using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
+
+        if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
+        {
+            return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number")));
+        }
+
+        switch (result_number)
+        {
+            case token_type::value_integer:
+                return sax->number_integer(number_lexer.get_number_integer());
+            case token_type::value_unsigned:
+                return sax->number_unsigned(number_lexer.get_number_unsigned());
+            case token_type::value_float:
+                return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
+            default:
+                return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number")));
+        }
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*!
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a -'ve valued
+    `std::char_traits<char_type>::eof()` in that case.
+
+    @return character read from the input
+    */
+    char_int_type get()
+    {
+        ++chars_read;
+        return current = ia.get_character();
+    }
+
+    /*!
+    @return character read from the input after ignoring all 'N' entries
+    */
+    char_int_type get_ignore_noop()
+    {
+        do
+        {
+            get();
+        }
+        while (current == 'N');
+
+        return current;
+    }
+
+    /*
+    @brief read a number from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format   the current format (for diagnostics)
+    @param[out] result  number of type @a NumberType
+
+    @return whether conversion completed
+
+    @note This function needs to respect the system's endianess, because
+          bytes in CBOR, MessagePack, and UBJSON are stored in network order
+          (big endian) and therefore need reordering on little endian systems.
+    */
+    template<typename NumberType, bool InputIsLittleEndian = false>
+    bool get_number(const input_format_t format, NumberType& result)
+    {
+        // step 1: read input into array with system's byte order
+        std::array<std::uint8_t, sizeof(NumberType)> vec;
+        for (std::size_t i = 0; i < sizeof(NumberType); ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
+            {
+                return false;
+            }
+
+            // reverse byte order prior to conversion if necessary
+            if (is_little_endian != InputIsLittleEndian)
+            {
+                vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
+            }
+            else
+            {
+                vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
+            }
+        }
+
+        // step 2: convert array into number of type T and return
+        std::memcpy(&result, vec.data(), sizeof(NumberType));
+        return true;
+    }
+
+    /*!
+    @brief create a string by reading characters from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of characters to read
+    @param[out] result string created by reading @a len bytes
+
+    @return whether string creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of string memory.
+    */
+    template<typename NumberType>
+    bool get_string(const input_format_t format,
+                    const NumberType len,
+                    string_t& result)
+    {
+        bool success = true;
+        for (NumberType i = 0; i < len; i++)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
+            {
+                success = false;
+                break;
+            }
+            result.push_back(static_cast<typename string_t::value_type>(current));
+        };
+        return success;
+    }
+
+    /*!
+    @brief create a byte array by reading bytes from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of bytes to read
+    @param[out] result byte array created by reading @a len bytes
+
+    @return whether byte array creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of memory.
+    */
+    template<typename NumberType>
+    bool get_binary(const input_format_t format,
+                    const NumberType len,
+                    binary_t& result)
+    {
+        bool success = true;
+        for (NumberType i = 0; i < len; i++)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
+            {
+                success = false;
+                break;
+            }
+            result.push_back(static_cast<std::uint8_t>(current));
+        }
+        return success;
+    }
+
+    /*!
+    @param[in] format   the current format (for diagnostics)
+    @param[in] context  further context information (for diagnostics)
+    @return whether the last read character is not EOF
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool unexpect_eof(const input_format_t format, const char* context) const
+    {
+        if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))
+        {
+            return sax->parse_error(chars_read, "<end of file>",
+                                    parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context)));
+        }
+        return true;
+    }
+
+    /*!
+    @return a string representation of the last read byte
+    */
+    std::string get_token_string() const
+    {
+        std::array<char, 3> cr{{}};
+        (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current));
+        return std::string{cr.data()};
+    }
+
+    /*!
+    @param[in] format   the current format
+    @param[in] detail   a detailed error message
+    @param[in] context  further context information
+    @return a message string to use in the parse_error exceptions
+    */
+    std::string exception_message(const input_format_t format,
+                                  const std::string& detail,
+                                  const std::string& context) const
+    {
+        std::string error_msg = "syntax error while parsing ";
+
+        switch (format)
+        {
+            case input_format_t::cbor:
+                error_msg += "CBOR";
+                break;
+
+            case input_format_t::msgpack:
+                error_msg += "MessagePack";
+                break;
+
+            case input_format_t::ubjson:
+                error_msg += "UBJSON";
+                break;
+
+            case input_format_t::bson:
+                error_msg += "BSON";
+                break;
+
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false);  // LCOV_EXCL_LINE
+        }
+
+        return error_msg + " " + context + ": " + detail;
+    }
+
+  private:
+    /// input adapter
+    InputAdapterType ia;
+
+    /// the current character
+    char_int_type current = std::char_traits<char_type>::eof();
+
+    /// the number of characters read
+    std::size_t chars_read = 0;
+
+    /// whether we can assume little endianess
+    const bool is_little_endian = little_endianess();
+
+    /// the SAX parser
+    json_sax_t* sax = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/input/parser.hpp>
+
+
+#include <cmath> // isfinite
+#include <cstdint> // uint8_t
+#include <functional> // function
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+////////////
+// parser //
+////////////
+
+enum class parse_event_t : uint8_t
+{
+    /// the parser read `{` and started to process a JSON object
+    object_start,
+    /// the parser read `}` and finished processing a JSON object
+    object_end,
+    /// the parser read `[` and started to process a JSON array
+    array_start,
+    /// the parser read `]` and finished processing a JSON array
+    array_end,
+    /// the parser read a key of a value in an object
+    key,
+    /// the parser finished reading a JSON value
+    value
+};
+
+template<typename BasicJsonType>
+using parser_callback_t =
+    std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>;
+
+/*!
+@brief syntax analysis
+
+This class implements a recursive descent parser.
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class parser
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
+    using token_type = typename lexer_t::token_type;
+
+  public:
+    /// a parser reading from an input adapter
+    explicit parser(InputAdapterType&& adapter,
+                    const parser_callback_t<BasicJsonType> cb = nullptr,
+                    const bool allow_exceptions_ = true,
+                    const bool skip_comments = false)
+        : callback(cb)
+        , m_lexer(std::move(adapter), skip_comments)
+        , allow_exceptions(allow_exceptions_)
+    {
+        // read first token
+        get_token();
+    }
+
+    /*!
+    @brief public parser interface
+
+    @param[in] strict      whether to expect the last token to be EOF
+    @param[in,out] result  parsed JSON value
+
+    @throw parse_error.101 in case of an unexpected token
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+    */
+    void parse(const bool strict, BasicJsonType& result)
+    {
+        if (callback)
+        {
+            json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
+            sax_parse_internal(&sdp);
+            result.assert_invariant();
+
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value")));
+            }
+
+            // in case of an error, return discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+
+            // set top-level value to null if it was discarded by the callback
+            // function
+            if (result.is_discarded())
+            {
+                result = nullptr;
+            }
+        }
+        else
+        {
+            json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
+            sax_parse_internal(&sdp);
+            result.assert_invariant();
+
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value")));
+            }
+
+            // in case of an error, return discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+        }
+    }
+
+    /*!
+    @brief public accept interface
+
+    @param[in] strict  whether to expect the last token to be EOF
+    @return whether the input is a proper JSON text
+    */
+    bool accept(const bool strict = true)
+    {
+        json_sax_acceptor<BasicJsonType> sax_acceptor;
+        return sax_parse(&sax_acceptor, strict);
+    }
+
+    template<typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse(SAX* sax, const bool strict = true)
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+        const bool result = sax_parse_internal(sax);
+
+        // strict mode: next byte must be EOF
+        if (result && strict && (get_token() != token_type::end_of_input))
+        {
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(),
+                                            exception_message(token_type::end_of_input, "value")));
+        }
+
+        return result;
+    }
+
+  private:
+    template<typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse_internal(SAX* sax)
+    {
+        // stack to remember the hierarchy of structured values we are parsing
+        // true = array; false = object
+        std::vector<bool> states;
+        // value to avoid a goto (see comment where set to true)
+        bool skip_to_state_evaluation = false;
+
+        while (true)
+        {
+            if (!skip_to_state_evaluation)
+            {
+                // invariant: get_token() was called before each iteration
+                switch (last_token)
+                {
+                    case token_type::begin_object:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
+                        {
+                            return false;
+                        }
+
+                        // closing } -> we are done
+                        if (get_token() == token_type::end_object)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // parse key
+                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(),
+                                                            exception_message(token_type::value_string, "object key")));
+                        }
+                        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        // parse separator (:)
+                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(),
+                                                            exception_message(token_type::name_separator, "object separator")));
+                        }
+
+                        // remember we are now inside an object
+                        states.push_back(false);
+
+                        // parse values
+                        get_token();
+                        continue;
+                    }
+
+                    case token_type::begin_array:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
+                        {
+                            return false;
+                        }
+
+                        // closing ] -> we are done
+                        if (get_token() == token_type::end_array)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // remember we are now inside an array
+                        states.push_back(true);
+
+                        // parse values (no need to call get_token)
+                        continue;
+                    }
+
+                    case token_type::value_float:
+                    {
+                        const auto res = m_lexer.get_number_float();
+
+                        if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));
+                        }
+
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        break;
+                    }
+
+                    case token_type::literal_false:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_null:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_true:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_integer:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_string:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_unsigned:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::parse_error:
+                    {
+                        // using "uninitialized" to avoid "expected" message
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(),
+                                                        exception_message(token_type::uninitialized, "value")));
+                    }
+
+                    default: // the last token was unexpected
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(),
+                                                        exception_message(token_type::literal_or_value, "value")));
+                    }
+                }
+            }
+            else
+            {
+                skip_to_state_evaluation = false;
+            }
+
+            // we reached this line after we successfully parsed a value
+            if (states.empty())
+            {
+                // empty stack: we reached the end of the hierarchy: done
+                return true;
+            }
+
+            if (states.back())  // array
+            {
+                // comma -> next value
+                if (get_token() == token_type::value_separator)
+                {
+                    // parse a new value
+                    get_token();
+                    continue;
+                }
+
+                // closing ]
+                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                    {
+                        return false;
+                    }
+
+                    // We are done with this array. Before we can parse a
+                    // new value, we need to evaluate the new state first.
+                    // By setting skip_to_state_evaluation to false, we
+                    // are effectively jumping to the beginning of this if.
+                    JSON_ASSERT(!states.empty());
+                    states.pop_back();
+                    skip_to_state_evaluation = true;
+                    continue;
+                }
+
+                return sax->parse_error(m_lexer.get_position(),
+                                        m_lexer.get_token_string(),
+                                        parse_error::create(101, m_lexer.get_position(),
+                                                exception_message(token_type::end_array, "array")));
+            }
+            else  // object
+            {
+                // comma -> next value
+                if (get_token() == token_type::value_separator)
+                {
+                    // parse key
+                    if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(),
+                                                        exception_message(token_type::value_string, "object key")));
+                    }
+
+                    if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+                    {
+                        return false;
+                    }
+
+                    // parse separator (:)
+                    if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(),
+                                                        exception_message(token_type::name_separator, "object separator")));
+                    }
+
+                    // parse values
+                    get_token();
+                    continue;
+                }
+
+                // closing }
+                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                    {
+                        return false;
+                    }
+
+                    // We are done with this object. Before we can parse a
+                    // new value, we need to evaluate the new state first.
+                    // By setting skip_to_state_evaluation to false, we
+                    // are effectively jumping to the beginning of this if.
+                    JSON_ASSERT(!states.empty());
+                    states.pop_back();
+                    skip_to_state_evaluation = true;
+                    continue;
+                }
+
+                return sax->parse_error(m_lexer.get_position(),
+                                        m_lexer.get_token_string(),
+                                        parse_error::create(101, m_lexer.get_position(),
+                                                exception_message(token_type::end_object, "object")));
+            }
+        }
+    }
+
+    /// get next token from lexer
+    token_type get_token()
+    {
+        return last_token = m_lexer.scan();
+    }
+
+    std::string exception_message(const token_type expected, const std::string& context)
+    {
+        std::string error_msg = "syntax error ";
+
+        if (!context.empty())
+        {
+            error_msg += "while parsing " + context + " ";
+        }
+
+        error_msg += "- ";
+
+        if (last_token == token_type::parse_error)
+        {
+            error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" +
+                         m_lexer.get_token_string() + "'";
+        }
+        else
+        {
+            error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token));
+        }
+
+        if (expected != token_type::uninitialized)
+        {
+            error_msg += "; expected " + std::string(lexer_t::token_type_name(expected));
+        }
+
+        return error_msg;
+    }
+
+  private:
+    /// callback function
+    const parser_callback_t<BasicJsonType> callback = nullptr;
+    /// the type of the last read token
+    token_type last_token = token_type::uninitialized;
+    /// the lexer
+    lexer_t m_lexer;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+
+#include <cstddef> // ptrdiff_t
+#include <limits>  // numeric_limits
+
+namespace nlohmann
+{
+namespace detail
+{
+/*
+@brief an iterator for primitive JSON types
+
+This class models an iterator for primitive JSON types (boolean, number,
+string). It's only purpose is to allow the iterator/const_iterator classes
+to "iterate" over primitive values. Internally, the iterator is modeled by
+a `difference_type` variable. Value begin_value (`0`) models the begin,
+end_value (`1`) models past the end.
+*/
+class primitive_iterator_t
+{
+  private:
+    using difference_type = std::ptrdiff_t;
+    static constexpr difference_type begin_value = 0;
+    static constexpr difference_type end_value = begin_value + 1;
+
+    /// iterator as signed integer type
+    difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
+
+  public:
+    constexpr difference_type get_value() const noexcept
+    {
+        return m_it;
+    }
+
+    /// set iterator to a defined beginning
+    void set_begin() noexcept
+    {
+        m_it = begin_value;
+    }
+
+    /// set iterator to a defined past the end
+    void set_end() noexcept
+    {
+        m_it = end_value;
+    }
+
+    /// return whether the iterator can be dereferenced
+    constexpr bool is_begin() const noexcept
+    {
+        return m_it == begin_value;
+    }
+
+    /// return whether the iterator is at end
+    constexpr bool is_end() const noexcept
+    {
+        return m_it == end_value;
+    }
+
+    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it == rhs.m_it;
+    }
+
+    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it < rhs.m_it;
+    }
+
+    primitive_iterator_t operator+(difference_type n) noexcept
+    {
+        auto result = *this;
+        result += n;
+        return result;
+    }
+
+    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it - rhs.m_it;
+    }
+
+    primitive_iterator_t& operator++() noexcept
+    {
+        ++m_it;
+        return *this;
+    }
+
+    primitive_iterator_t const operator++(int) noexcept
+    {
+        auto result = *this;
+        ++m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator--() noexcept
+    {
+        --m_it;
+        return *this;
+    }
+
+    primitive_iterator_t const operator--(int) noexcept
+    {
+        auto result = *this;
+        --m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator+=(difference_type n) noexcept
+    {
+        m_it += n;
+        return *this;
+    }
+
+    primitive_iterator_t& operator-=(difference_type n) noexcept
+    {
+        m_it -= n;
+        return *this;
+    }
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+
+namespace nlohmann
+{
+namespace detail
+{
+/*!
+@brief an iterator value
+
+@note This structure could easily be a union, but MSVC currently does not allow
+unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
+*/
+template<typename BasicJsonType> struct internal_iterator
+{
+    /// iterator for JSON objects
+    typename BasicJsonType::object_t::iterator object_iterator {};
+    /// iterator for JSON arrays
+    typename BasicJsonType::array_t::iterator array_iterator {};
+    /// generic iterator for all other types
+    primitive_iterator_t primitive_iterator {};
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/iter_impl.hpp>
+
+
+#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
+#include <type_traits> // conditional, is_const, remove_const
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+// forward declare, to be able to friend it later on
+template<typename IteratorType> class iteration_proxy;
+template<typename IteratorType> class iteration_proxy_value;
+
+/*!
+@brief a template for a bidirectional iterator for the @ref basic_json class
+This class implements a both iterators (iterator and const_iterator) for the
+@ref basic_json class.
+@note An iterator is called *initialized* when a pointer to a JSON value has
+      been set (e.g., by a constructor or a copy assignment). If the iterator is
+      default-constructed, it is *uninitialized* and most methods are undefined.
+      **The library uses assertions to detect calls on uninitialized iterators.**
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
+       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
+*/
+template<typename BasicJsonType>
+class iter_impl
+{
+    /// allow basic_json to access private members
+    friend iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
+    friend BasicJsonType;
+    friend iteration_proxy<iter_impl>;
+    friend iteration_proxy_value<iter_impl>;
+
+    using object_t = typename BasicJsonType::object_t;
+    using array_t = typename BasicJsonType::array_t;
+    // make sure BasicJsonType is basic_json or const basic_json
+    static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
+                  "iter_impl only accepts (const) basic_json");
+
+  public:
+
+    /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
+    /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
+    /// A user-defined iterator should provide publicly accessible typedefs named
+    /// iterator_category, value_type, difference_type, pointer, and reference.
+    /// Note that value_type is required to be non-const, even for constant iterators.
+    using iterator_category = std::bidirectional_iterator_tag;
+
+    /// the type of the values when the iterator is dereferenced
+    using value_type = typename BasicJsonType::value_type;
+    /// a type to represent differences between iterators
+    using difference_type = typename BasicJsonType::difference_type;
+    /// defines a pointer to the type iterated over (value_type)
+    using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
+          typename BasicJsonType::const_pointer,
+          typename BasicJsonType::pointer>::type;
+    /// defines a reference to the type iterated over (value_type)
+    using reference =
+        typename std::conditional<std::is_const<BasicJsonType>::value,
+        typename BasicJsonType::const_reference,
+        typename BasicJsonType::reference>::type;
+
+    /// default constructor
+    iter_impl() = default;
+
+    /*!
+    @brief constructor for a given JSON instance
+    @param[in] object  pointer to a JSON object for this iterator
+    @pre object != nullptr
+    @post The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    explicit iter_impl(pointer object) noexcept : m_object(object)
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = typename object_t::iterator();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = typename array_t::iterator();
+                break;
+            }
+
+            default:
+            {
+                m_it.primitive_iterator = primitive_iterator_t();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @note The conventional copy constructor and copy assignment are implicitly
+          defined. Combined with the following converting constructor and
+          assignment, they support: (1) copy from iterator to iterator, (2)
+          copy from const iterator to const iterator, and (3) conversion from
+          iterator to const iterator. However conversion from const iterator
+          to iterator is not defined.
+    */
+
+    /*!
+    @brief const copy constructor
+    @param[in] other const iterator to copy from
+    @note This copy constructor had to be defined explicitly to circumvent a bug
+          occurring on msvc v19.0 compiler (VS 2015) debug build. For more
+          information refer to: https://github.com/nlohmann/json/issues/1608
+    */
+    iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
+    {
+        m_object = other.m_object;
+        m_it = other.m_it;
+        return *this;
+    }
+
+    /*!
+    @brief converting constructor
+    @param[in] other  non-const iterator to copy from
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other  non-const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
+    {
+        m_object = other.m_object;
+        m_it = other.m_it;
+        return *this;
+    }
+
+  private:
+    /*!
+    @brief set the iterator to the first value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_begin() noexcept
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_value.object->begin();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_value.array->begin();
+                break;
+            }
+
+            case value_t::null:
+            {
+                // set to end so begin()==end() is true: null is empty
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+
+            default:
+            {
+                m_it.primitive_iterator.set_begin();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @brief set the iterator past the last value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_end() noexcept
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_value.object->end();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_value.array->end();
+                break;
+            }
+
+            default:
+            {
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+        }
+    }
+
+  public:
+    /*!
+    @brief return a reference to the value pointed to by the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator*() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
+                return m_it.object_iterator->second;
+            }
+
+            case value_t::array:
+            {
+                JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
+                return *m_it.array_iterator;
+            }
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+            }
+        }
+    }
+
+    /*!
+    @brief dereference the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    pointer operator->() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
+                return &(m_it.object_iterator->second);
+            }
+
+            case value_t::array:
+            {
+                JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
+                return &*m_it.array_iterator;
+            }
+
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+            }
+        }
+    }
+
+    /*!
+    @brief post-increment (it++)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl const operator++(int)
+    {
+        auto result = *this;
+        ++(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-increment (++it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator++()
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, 1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, 1);
+                break;
+            }
+
+            default:
+            {
+                ++m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief post-decrement (it--)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl const operator--(int)
+    {
+        auto result = *this;
+        --(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-decrement (--it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator--()
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, -1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, -1);
+                break;
+            }
+
+            default:
+            {
+                --m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief  comparison: equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator==(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
+        }
+
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                return (m_it.object_iterator == other.m_it.object_iterator);
+
+            case value_t::array:
+                return (m_it.array_iterator == other.m_it.array_iterator);
+
+            default:
+                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief  comparison: not equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator!=(const iter_impl& other) const
+    {
+        return !operator==(other);
+    }
+
+    /*!
+    @brief  comparison: smaller
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
+        }
+
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators"));
+
+            case value_t::array:
+                return (m_it.array_iterator < other.m_it.array_iterator);
+
+            default:
+                return (m_it.primitive_iterator < other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief  comparison: less than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<=(const iter_impl& other) const
+    {
+        return !other.operator < (*this);
+    }
+
+    /*!
+    @brief  comparison: greater than
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>(const iter_impl& other) const
+    {
+        return !operator<=(other);
+    }
+
+    /*!
+    @brief  comparison: greater than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>=(const iter_impl& other) const
+    {
+        return !operator<(other);
+    }
+
+    /*!
+    @brief  add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator+=(difference_type i)
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, i);
+                break;
+            }
+
+            default:
+            {
+                m_it.primitive_iterator += i;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief  subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator-=(difference_type i)
+    {
+        return operator+=(-i);
+    }
+
+    /*!
+    @brief  add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator+(difference_type i) const
+    {
+        auto result = *this;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief  addition of distance and iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    friend iter_impl operator+(difference_type i, const iter_impl& it)
+    {
+        auto result = it;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief  subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator-(difference_type i) const
+    {
+        auto result = *this;
+        result -= i;
+        return result;
+    }
+
+    /*!
+    @brief  return difference
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    difference_type operator-(const iter_impl& other) const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
+
+            case value_t::array:
+                return m_it.array_iterator - other.m_it.array_iterator;
+
+            default:
+                return m_it.primitive_iterator - other.m_it.primitive_iterator;
+        }
+    }
+
+    /*!
+    @brief  access to successor
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator[](difference_type n) const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators"));
+
+            case value_t::array:
+                return *std::next(m_it.array_iterator, n);
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+            }
+        }
+    }
+
+    /*!
+    @brief  return the key of an object iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    const typename object_t::key_type& key() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
+        {
+            return m_it.object_iterator->first;
+        }
+
+        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));
+    }
+
+    /*!
+    @brief  return the value of an iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference value() const
+    {
+        return operator*();
+    }
+
+  private:
+    /// associated JSON instance
+    pointer m_object = nullptr;
+    /// the actual iterator of the associated instance
+    internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
+};
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+
+// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
+
+
+#include <cstddef> // ptrdiff_t
+#include <iterator> // reverse_iterator
+#include <utility> // declval
+
+namespace nlohmann
+{
+namespace detail
+{
+//////////////////////
+// reverse_iterator //
+//////////////////////
+
+/*!
+@brief a template for a reverse iterator class
+
+@tparam Base the base iterator type to reverse. Valid types are @ref
+iterator (to create @ref reverse_iterator) and @ref const_iterator (to
+create @ref const_reverse_iterator).
+
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
+  It is possible to write to the pointed-to element (only if @a Base is
+  @ref iterator).
+
+@since version 1.0.0
+*/
+template<typename Base>
+class json_reverse_iterator : public std::reverse_iterator<Base>
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    /// shortcut to the reverse iterator adapter
+    using base_iterator = std::reverse_iterator<Base>;
+    /// the reference type for the pointed-to element
+    using reference = typename Base::reference;
+
+    /// create reverse iterator from iterator
+    explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
+        : base_iterator(it) {}
+
+    /// create reverse iterator from base class
+    explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
+
+    /// post-increment (it++)
+    json_reverse_iterator const operator++(int)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
+    }
+
+    /// pre-increment (++it)
+    json_reverse_iterator& operator++()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator++());
+    }
+
+    /// post-decrement (it--)
+    json_reverse_iterator const operator--(int)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
+    }
+
+    /// pre-decrement (--it)
+    json_reverse_iterator& operator--()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator--());
+    }
+
+    /// add to iterator
+    json_reverse_iterator& operator+=(difference_type i)
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
+    }
+
+    /// add to iterator
+    json_reverse_iterator operator+(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
+    }
+
+    /// subtract from iterator
+    json_reverse_iterator operator-(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
+    }
+
+    /// return difference
+    difference_type operator-(const json_reverse_iterator& other) const
+    {
+        return base_iterator(*this) - base_iterator(other);
+    }
+
+    /// access to successor
+    reference operator[](difference_type n) const
+    {
+        return *(this->operator+(n));
+    }
+
+    /// return the key of an object iterator
+    auto key() const -> decltype(std::declval<Base>().key())
+    {
+        auto it = --this->base();
+        return it.key();
+    }
+
+    /// return the value of an iterator
+    reference value() const
+    {
+        auto it = --this->base();
+        return it.operator * ();
+    }
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/json_pointer.hpp>
+
+
+#include <algorithm> // all_of
+#include <cctype> // isdigit
+#include <limits> // max
+#include <numeric> // accumulate
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+template<typename BasicJsonType>
+class json_pointer
+{
+    // allow basic_json to access private members
+    NLOHMANN_BASIC_JSON_TPL_DECLARATION
+    friend class basic_json;
+
+  public:
+    /*!
+    @brief create JSON pointer
+
+    Create a JSON pointer according to the syntax described in
+    [Section 3 of RFC6901](https://tools.ietf.org/html/rfc6901#section-3).
+
+    @param[in] s  string representing the JSON pointer; if omitted, the empty
+                  string is assumed which references the whole JSON value
+
+    @throw parse_error.107 if the given JSON pointer @a s is nonempty and does
+                           not begin with a slash (`/`); see example below
+
+    @throw parse_error.108 if a tilde (`~`) in the given JSON pointer @a s is
+    not followed by `0` (representing `~`) or `1` (representing `/`); see
+    example below
+
+    @liveexample{The example shows the construction several valid JSON pointers
+    as well as the exceptional behavior.,json_pointer}
+
+    @since version 2.0.0
+    */
+    explicit json_pointer(const std::string& s = "")
+        : reference_tokens(split(s))
+    {}
+
+    /*!
+    @brief return a string representation of the JSON pointer
+
+    @invariant For each JSON pointer `ptr`, it holds:
+    @code {.cpp}
+    ptr == json_pointer(ptr.to_string());
+    @endcode
+
+    @return a string representation of the JSON pointer
+
+    @liveexample{The example shows the result of `to_string`.,json_pointer__to_string}
+
+    @since version 2.0.0
+    */
+    std::string to_string() const
+    {
+        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
+                               std::string{},
+                               [](const std::string & a, const std::string & b)
+        {
+            return a + "/" + escape(b);
+        });
+    }
+
+    /// @copydoc to_string()
+    operator std::string() const
+    {
+        return to_string();
+    }
+
+    /*!
+    @brief append another JSON pointer at the end of this JSON pointer
+
+    @param[in] ptr  JSON pointer to append
+    @return JSON pointer with @a ptr appended
+
+    @liveexample{The example shows the usage of `operator/=`.,json_pointer__operator_add}
+
+    @complexity Linear in the length of @a ptr.
+
+    @sa @ref operator/=(std::string) to append a reference token
+    @sa @ref operator/=(std::size_t) to append an array index
+    @sa @ref operator/(const json_pointer&, const json_pointer&) for a binary operator
+
+    @since version 3.6.0
+    */
+    json_pointer& operator/=(const json_pointer& ptr)
+    {
+        reference_tokens.insert(reference_tokens.end(),
+                                ptr.reference_tokens.begin(),
+                                ptr.reference_tokens.end());
+        return *this;
+    }
+
+    /*!
+    @brief append an unescaped reference token at the end of this JSON pointer
+
+    @param[in] token  reference token to append
+    @return JSON pointer with @a token appended without escaping @a token
+
+    @liveexample{The example shows the usage of `operator/=`.,json_pointer__operator_add}
+
+    @complexity Amortized constant.
+
+    @sa @ref operator/=(const json_pointer&) to append a JSON pointer
+    @sa @ref operator/=(std::size_t) to append an array index
+    @sa @ref operator/(const json_pointer&, std::size_t) for a binary operator
+
+    @since version 3.6.0
+    */
+    json_pointer& operator/=(std::string token)
+    {
+        push_back(std::move(token));
+        return *this;
+    }
+
+    /*!
+    @brief append an array index at the end of this JSON pointer
+
+    @param[in] array_idx  array index to append
+    @return JSON pointer with @a array_idx appended
+
+    @liveexample{The example shows the usage of `operator/=`.,json_pointer__operator_add}
+
+    @complexity Amortized constant.
+
+    @sa @ref operator/=(const json_pointer&) to append a JSON pointer
+    @sa @ref operator/=(std::string) to append a reference token
+    @sa @ref operator/(const json_pointer&, std::string) for a binary operator
+
+    @since version 3.6.0
+    */
+    json_pointer& operator/=(std::size_t array_idx)
+    {
+        return *this /= std::to_string(array_idx);
+    }
+
+    /*!
+    @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
+
+    @param[in] lhs  JSON pointer
+    @param[in] rhs  JSON pointer
+    @return a new JSON pointer with @a rhs appended to @a lhs
+
+    @liveexample{The example shows the usage of `operator/`.,json_pointer__operator_add_binary}
+
+    @complexity Linear in the length of @a lhs and @a rhs.
+
+    @sa @ref operator/=(const json_pointer&) to append a JSON pointer
+
+    @since version 3.6.0
+    */
+    friend json_pointer operator/(const json_pointer& lhs,
+                                  const json_pointer& rhs)
+    {
+        return json_pointer(lhs) /= rhs;
+    }
+
+    /*!
+    @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
+
+    @param[in] ptr  JSON pointer
+    @param[in] token  reference token
+    @return a new JSON pointer with unescaped @a token appended to @a ptr
+
+    @liveexample{The example shows the usage of `operator/`.,json_pointer__operator_add_binary}
+
+    @complexity Linear in the length of @a ptr.
+
+    @sa @ref operator/=(std::string) to append a reference token
+
+    @since version 3.6.0
+    */
+    friend json_pointer operator/(const json_pointer& ptr, std::string token)
+    {
+        return json_pointer(ptr) /= std::move(token);
+    }
+
+    /*!
+    @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
+
+    @param[in] ptr  JSON pointer
+    @param[in] array_idx  array index
+    @return a new JSON pointer with @a array_idx appended to @a ptr
+
+    @liveexample{The example shows the usage of `operator/`.,json_pointer__operator_add_binary}
+
+    @complexity Linear in the length of @a ptr.
+
+    @sa @ref operator/=(std::size_t) to append an array index
+
+    @since version 3.6.0
+    */
+    friend json_pointer operator/(const json_pointer& ptr, std::size_t array_idx)
+    {
+        return json_pointer(ptr) /= array_idx;
+    }
+
+    /*!
+    @brief returns the parent of this JSON pointer
+
+    @return parent of this JSON pointer; in case this JSON pointer is the root,
+            the root itself is returned
+
+    @complexity Linear in the length of the JSON pointer.
+
+    @liveexample{The example shows the result of `parent_pointer` for different
+    JSON Pointers.,json_pointer__parent_pointer}
+
+    @since version 3.6.0
+    */
+    json_pointer parent_pointer() const
+    {
+        if (empty())
+        {
+            return *this;
+        }
+
+        json_pointer res = *this;
+        res.pop_back();
+        return res;
+    }
+
+    /*!
+    @brief remove last reference token
+
+    @pre not `empty()`
+
+    @liveexample{The example shows the usage of `pop_back`.,json_pointer__pop_back}
+
+    @complexity Constant.
+
+    @throw out_of_range.405 if JSON pointer has no parent
+
+    @since version 3.6.0
+    */
+    void pop_back()
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
+        }
+
+        reference_tokens.pop_back();
+    }
+
+    /*!
+    @brief return last reference token
+
+    @pre not `empty()`
+    @return last reference token
+
+    @liveexample{The example shows the usage of `back`.,json_pointer__back}
+
+    @complexity Constant.
+
+    @throw out_of_range.405 if JSON pointer has no parent
+
+    @since version 3.6.0
+    */
+    const std::string& back() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
+        }
+
+        return reference_tokens.back();
+    }
+
+    /*!
+    @brief append an unescaped token at the end of the reference pointer
+
+    @param[in] token  token to add
+
+    @complexity Amortized constant.
+
+    @liveexample{The example shows the result of `push_back` for different
+    JSON Pointers.,json_pointer__push_back}
+
+    @since version 3.6.0
+    */
+    void push_back(const std::string& token)
+    {
+        reference_tokens.push_back(token);
+    }
+
+    /// @copydoc push_back(const std::string&)
+    void push_back(std::string&& token)
+    {
+        reference_tokens.push_back(std::move(token));
+    }
+
+    /*!
+    @brief return whether pointer points to the root document
+
+    @return true iff the JSON pointer points to the root document
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example shows the result of `empty` for different JSON
+    Pointers.,json_pointer__empty}
+
+    @since version 3.6.0
+    */
+    bool empty() const noexcept
+    {
+        return reference_tokens.empty();
+    }
+
+  private:
+    /*!
+    @param[in] s  reference token to be converted into an array index
+
+    @return integer representation of @a s
+
+    @throw parse_error.106  if an array index begins with '0'
+    @throw parse_error.109  if an array index begins not with a digit
+    @throw out_of_range.404 if string @a s could not be converted to an integer
+    @throw out_of_range.410 if an array index exceeds size_type
+    */
+    static typename BasicJsonType::size_type array_index(const std::string& s)
+    {
+        using size_type = typename BasicJsonType::size_type;
+
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
+        {
+            JSON_THROW(detail::parse_error::create(106, 0,
+                                                   "array index '" + s +
+                                                   "' must not begin with '0'"));
+        }
+
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
+        {
+            JSON_THROW(detail::parse_error::create(109, 0, "array index '" + s + "' is not a number"));
+        }
+
+        std::size_t processed_chars = 0;
+        unsigned long long res = 0;
+        JSON_TRY
+        {
+            res = std::stoull(s, &processed_chars);
+        }
+        JSON_CATCH(std::out_of_range&)
+        {
+            JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
+        }
+
+        // check if the string was completely read
+        if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
+        {
+            JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
+        }
+
+        // only triggered on special platforms (like 32bit), see also
+        // https://github.com/nlohmann/json/pull/2203
+        if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))
+        {
+            JSON_THROW(detail::out_of_range::create(410, "array index " + s + " exceeds size_type")); // LCOV_EXCL_LINE
+        }
+
+        return static_cast<size_type>(res);
+    }
+
+    json_pointer top() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
+        }
+
+        json_pointer result = *this;
+        result.reference_tokens = {reference_tokens[0]};
+        return result;
+    }
+
+    /*!
+    @brief create and return a reference to the pointed to value
+
+    @complexity Linear in the number of reference tokens.
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.313 if value cannot be unflattened
+    */
+    BasicJsonType& get_and_create(BasicJsonType& j) const
+    {
+        auto result = &j;
+
+        // in case no reference tokens exist, return a reference to the JSON value
+        // j which will be overwritten by a primitive value
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (result->type())
+            {
+                case detail::value_t::null:
+                {
+                    if (reference_token == "0")
+                    {
+                        // start a new array if reference token is 0
+                        result = &result->operator[](0);
+                    }
+                    else
+                    {
+                        // start a new object otherwise
+                        result = &result->operator[](reference_token);
+                    }
+                    break;
+                }
+
+                case detail::value_t::object:
+                {
+                    // create an entry in the object
+                    result = &result->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    // create an entry in the array
+                    result = &result->operator[](array_index(reference_token));
+                    break;
+                }
+
+                /*
+                The following code is only reached if there exists a reference
+                token _and_ the current value is primitive. In this case, we have
+                an error situation, because primitive values may only occur as
+                single value; that is, with an empty list of reference tokens.
+                */
+                default:
+                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten"));
+            }
+        }
+
+        return *result;
+    }
+
+    /*!
+    @brief return a reference to the pointed to value
+
+    @note This version does not throw if a value is not present, but tries to
+          create nested values instead. For instance, calling this function
+          with pointer `"/this/that"` on a null value is equivalent to calling
+          `operator[]("this").operator[]("that")` on that value, effectively
+          changing the null value to an object.
+
+    @param[in] ptr  a JSON value
+
+    @return reference to the JSON value pointed to by the JSON pointer
+
+    @complexity Linear in the length of the JSON pointer.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    BasicJsonType& get_unchecked(BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            // convert null values to arrays or objects before continuing
+            if (ptr->is_null())
+            {
+                // check if reference token is a number
+                const bool nums =
+                    std::all_of(reference_token.begin(), reference_token.end(),
+                                [](const unsigned char x)
+                {
+                    return std::isdigit(x);
+                });
+
+                // change value to array for numbers or "-" or to object otherwise
+                *ptr = (nums || reference_token == "-")
+                       ? detail::value_t::array
+                       : detail::value_t::object;
+            }
+
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (reference_token == "-")
+                    {
+                        // explicitly treat "-" as index beyond the end
+                        ptr = &ptr->operator[](ptr->m_value.array->size());
+                    }
+                    else
+                    {
+                        // convert array index to number; unchecked access
+                        ptr = &ptr->operator[](array_index(reference_token));
+                    }
+                    break;
+                }
+
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    BasicJsonType& get_checked(BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402,
+                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                                ") is out of range"));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(array_index(reference_token));
+                    break;
+                }
+
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @brief return a const reference to the pointed to value
+
+    @param[in] ptr  a JSON value
+
+    @return const reference to the JSON value pointed to by the JSON
+    pointer
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" cannot be used for const access
+                        JSON_THROW(detail::out_of_range::create(402,
+                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                                ") is out of range"));
+                    }
+
+                    // use unchecked array access
+                    ptr = &ptr->operator[](array_index(reference_token));
+                    break;
+                }
+
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    const BasicJsonType& get_checked(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402,
+                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                                ") is out of range"));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(array_index(reference_token));
+                    break;
+                }
+
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    */
+    bool contains(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    if (!ptr->contains(reference_token))
+                    {
+                        // we did not find the key in the object
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
+                    {
+                        // invalid char
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
+                        {
+                            // first char should be between '1' and '9'
+                            return false;
+                        }
+                        for (std::size_t i = 1; i < reference_token.size(); i++)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
+                            {
+                                // other char should be between '0' and '9'
+                                return false;
+                            }
+                        }
+                    }
+
+                    const auto idx = array_index(reference_token);
+                    if (idx >= ptr->size())
+                    {
+                        // index out of range
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](idx);
+                    break;
+                }
+
+                default:
+                {
+                    // we do not expect primitive values if there is still a
+                    // reference token to process
+                    return false;
+                }
+            }
+        }
+
+        // no reference token left means we found a primitive value
+        return true;
+    }
+
+    /*!
+    @brief split the string input to reference tokens
+
+    @note This function is only called by the json_pointer constructor.
+          All exceptions below are documented there.
+
+    @throw parse_error.107  if the pointer is not empty or begins with '/'
+    @throw parse_error.108  if character '~' is not followed by '0' or '1'
+    */
+    static std::vector<std::string> split(const std::string& reference_string)
+    {
+        std::vector<std::string> result;
+
+        // special case: empty reference string -> no reference tokens
+        if (reference_string.empty())
+        {
+            return result;
+        }
+
+        // check if nonempty reference string begins with slash
+        if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
+        {
+            JSON_THROW(detail::parse_error::create(107, 1,
+                                                   "JSON pointer must be empty or begin with '/' - was: '" +
+                                                   reference_string + "'"));
+        }
+
+        // extract the reference tokens:
+        // - slash: position of the last read slash (or end of string)
+        // - start: position after the previous slash
+        for (
+            // search for the first slash after the first character
+            std::size_t slash = reference_string.find_first_of('/', 1),
+            // set the beginning of the first reference token
+            start = 1;
+            // we can stop if start == 0 (if slash == std::string::npos)
+            start != 0;
+            // set the beginning of the next reference token
+            // (will eventually be 0 if slash == std::string::npos)
+            start = (slash == std::string::npos) ? 0 : slash + 1,
+            // find next slash
+            slash = reference_string.find_first_of('/', start))
+        {
+            // use the text between the beginning of the reference token
+            // (start) and the last slash (slash).
+            auto reference_token = reference_string.substr(start, slash - start);
+
+            // check reference tokens are properly escaped
+            for (std::size_t pos = reference_token.find_first_of('~');
+                    pos != std::string::npos;
+                    pos = reference_token.find_first_of('~', pos + 1))
+            {
+                JSON_ASSERT(reference_token[pos] == '~');
+
+                // ~ must be followed by 0 or 1
+                if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
+                                         (reference_token[pos + 1] != '0' &&
+                                          reference_token[pos + 1] != '1')))
+                {
+                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
+                }
+            }
+
+            // finally, store the reference token
+            unescape(reference_token);
+            result.push_back(reference_token);
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief replace all occurrences of a substring by another string
+
+    @param[in,out] s  the string to manipulate; changed so that all
+                   occurrences of @a f are replaced with @a t
+    @param[in]     f  the substring to replace with @a t
+    @param[in]     t  the string to replace @a f
+
+    @pre The search string @a f must not be empty. **This precondition is
+    enforced with an assertion.**
+
+    @since version 2.0.0
+    */
+    static void replace_substring(std::string& s, const std::string& f,
+                                  const std::string& t)
+    {
+        JSON_ASSERT(!f.empty());
+        for (auto pos = s.find(f);                // find first occurrence of f
+                pos != std::string::npos;         // make sure f was found
+                s.replace(pos, f.size(), t),      // replace with t, and
+                pos = s.find(f, pos + t.size()))  // find next occurrence of f
+        {}
+    }
+
+    /// escape "~" to "~0" and "/" to "~1"
+    static std::string escape(std::string s)
+    {
+        replace_substring(s, "~", "~0");
+        replace_substring(s, "/", "~1");
+        return s;
+    }
+
+    /// unescape "~1" to tilde and "~0" to slash (order is important!)
+    static void unescape(std::string& s)
+    {
+        replace_substring(s, "~1", "/");
+        replace_substring(s, "~0", "~");
+    }
+
+    /*!
+    @param[in] reference_string  the reference string to the current value
+    @param[in] value             the value to consider
+    @param[in,out] result        the result object to insert values to
+
+    @note Empty objects or arrays are flattened to `null`.
+    */
+    static void flatten(const std::string& reference_string,
+                        const BasicJsonType& value,
+                        BasicJsonType& result)
+    {
+        switch (value.type())
+        {
+            case detail::value_t::array:
+            {
+                if (value.m_value.array->empty())
+                {
+                    // flatten empty array as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate array and use index as reference string
+                    for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
+                    {
+                        flatten(reference_string + "/" + std::to_string(i),
+                                value.m_value.array->operator[](i), result);
+                    }
+                }
+                break;
+            }
+
+            case detail::value_t::object:
+            {
+                if (value.m_value.object->empty())
+                {
+                    // flatten empty object as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate object and use keys as reference string
+                    for (const auto& element : *value.m_value.object)
+                    {
+                        flatten(reference_string + "/" + escape(element.first), element.second, result);
+                    }
+                }
+                break;
+            }
+
+            default:
+            {
+                // add primitive value with its reference string
+                result[reference_string] = value;
+                break;
+            }
+        }
+    }
+
+    /*!
+    @param[in] value  flattened JSON
+
+    @return unflattened JSON
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.314  if value is not an object
+    @throw type_error.315  if object values are not primitive
+    @throw type_error.313  if value cannot be unflattened
+    */
+    static BasicJsonType
+    unflatten(const BasicJsonType& value)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
+        {
+            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
+        }
+
+        BasicJsonType result;
+
+        // iterate the JSON object values
+        for (const auto& element : *value.m_value.object)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
+            {
+                JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
+            }
+
+            // assign value to reference pointed to by JSON pointer; Note that if
+            // the JSON pointer is "" (i.e., points to the whole value), function
+            // get_and_create returns a reference to result itself. An assignment
+            // will then create a primitive value.
+            json_pointer(element.first).get_and_create(result) = element.second;
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief compares two JSON pointers for equality
+
+    @param[in] lhs  JSON pointer to compare
+    @param[in] rhs  JSON pointer to compare
+    @return whether @a lhs is equal to @a rhs
+
+    @complexity Linear in the length of the JSON pointer
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+    */
+    friend bool operator==(json_pointer const& lhs,
+                           json_pointer const& rhs) noexcept
+    {
+        return lhs.reference_tokens == rhs.reference_tokens;
+    }
+
+    /*!
+    @brief compares two JSON pointers for inequality
+
+    @param[in] lhs  JSON pointer to compare
+    @param[in] rhs  JSON pointer to compare
+    @return whether @a lhs is not equal @a rhs
+
+    @complexity Linear in the length of the JSON pointer
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+    */
+    friend bool operator!=(json_pointer const& lhs,
+                           json_pointer const& rhs) noexcept
+    {
+        return !(lhs == rhs);
+    }
+
+    /// the reference tokens
+    std::vector<std::string> reference_tokens;
+};
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/json_ref.hpp>
+
+
+#include <initializer_list>
+#include <utility>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename BasicJsonType>
+class json_ref
+{
+  public:
+    using value_type = BasicJsonType;
+
+    json_ref(value_type&& value)
+        : owned_value(std::move(value))
+        , value_ref(&owned_value)
+        , is_rvalue(true)
+    {}
+
+    json_ref(const value_type& value)
+        : value_ref(const_cast<value_type*>(&value))
+        , is_rvalue(false)
+    {}
+
+    json_ref(std::initializer_list<json_ref> init)
+        : owned_value(init)
+        , value_ref(&owned_value)
+        , is_rvalue(true)
+    {}
+
+    template <
+        class... Args,
+        enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
+    json_ref(Args && ... args)
+        : owned_value(std::forward<Args>(args)...)
+        , value_ref(&owned_value)
+        , is_rvalue(true)
+    {}
+
+    // class should be movable only
+    json_ref(json_ref&&) = default;
+    json_ref(const json_ref&) = delete;
+    json_ref& operator=(const json_ref&) = delete;
+    json_ref& operator=(json_ref&&) = delete;
+    ~json_ref() = default;
+
+    value_type moved_or_copied() const
+    {
+        if (is_rvalue)
+        {
+            return std::move(*value_ref);
+        }
+        return *value_ref;
+    }
+
+    value_type const& operator*() const
+    {
+        return *static_cast<value_type const*>(value_ref);
+    }
+
+    value_type const* operator->() const
+    {
+        return static_cast<value_type const*>(value_ref);
+    }
+
+  private:
+    mutable value_type owned_value = nullptr;
+    value_type* value_ref = nullptr;
+    const bool is_rvalue = true;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+
+
+#include <algorithm> // reverse
+#include <array> // array
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstring> // memcpy
+#include <limits> // numeric_limits
+#include <string> // string
+#include <cmath> // isnan, isinf
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+
+#include <algorithm> // copy
+#include <cstddef> // size_t
+#include <ios> // streamsize
+#include <iterator> // back_inserter
+#include <memory> // shared_ptr, make_shared
+#include <ostream> // basic_ostream
+#include <string> // basic_string
+#include <vector> // vector
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+/// abstract output adapter interface
+template<typename CharType> struct output_adapter_protocol
+{
+    virtual void write_character(CharType c) = 0;
+    virtual void write_characters(const CharType* s, std::size_t length) = 0;
+    virtual ~output_adapter_protocol() = default;
+};
+
+/// a type to simplify interfaces
+template<typename CharType>
+using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
+
+/// output adapter for byte vectors
+template<typename CharType>
+class output_vector_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_vector_adapter(std::vector<CharType>& vec) noexcept
+        : v(vec)
+    {}
+
+    void write_character(CharType c) override
+    {
+        v.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        std::copy(s, s + length, std::back_inserter(v));
+    }
+
+  private:
+    std::vector<CharType>& v;
+};
+
+/// output adapter for output streams
+template<typename CharType>
+class output_stream_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
+        : stream(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        stream.put(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        stream.write(s, static_cast<std::streamsize>(length));
+    }
+
+  private:
+    std::basic_ostream<CharType>& stream;
+};
+
+/// output adapter for basic_string
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_string_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_string_adapter(StringType& s) noexcept
+        : str(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        str.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        str.append(s, length);
+    }
+
+  private:
+    StringType& str;
+};
+
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_adapter
+{
+  public:
+    output_adapter(std::vector<CharType>& vec)
+        : oa(std::make_shared<output_vector_adapter<CharType>>(vec)) {}
+
+    output_adapter(std::basic_ostream<CharType>& s)
+        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
+
+    output_adapter(StringType& s)
+        : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
+
+    operator output_adapter_t<CharType>()
+    {
+        return oa;
+    }
+
+  private:
+    output_adapter_t<CharType> oa = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////
+// binary writer //
+///////////////////
+
+/*!
+@brief serialization to CBOR and MessagePack values
+*/
+template<typename BasicJsonType, typename CharType>
+class binary_writer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+  public:
+    /*!
+    @brief create a binary writer
+
+    @param[in] adapter  output adapter to write to
+    */
+    explicit binary_writer(output_adapter_t<CharType> adapter) : oa(adapter)
+    {
+        JSON_ASSERT(oa);
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    void write_bson(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+            {
+                write_bson_object(*j.m_value.object);
+                break;
+            }
+
+            default:
+            {
+                JSON_THROW(type_error::create(317, "to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name())));
+            }
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_cbor(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                oa->write_character(to_char_type(0xF6));
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                oa->write_character(j.m_value.boolean
+                                    ? to_char_type(0xF5)
+                                    : to_char_type(0xF4));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_value.number_integer >= 0)
+                {
+                    // CBOR does not differentiate between positive signed
+                    // integers and unsigned integers. Therefore, we used the
+                    // code from the value_t::number_unsigned case here.
+                    if (j.m_value.number_integer <= 0x17)
+                    {
+                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x18));
+                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x19));
+                        write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x1A));
+                        write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x1B));
+                        write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    // The conversions below encode the sign in the first
+                    // byte, and the value is converted to a positive number.
+                    const auto positive_number = -1 - j.m_value.number_integer;
+                    if (j.m_value.number_integer >= -24)
+                    {
+                        write_number(static_cast<std::uint8_t>(0x20 + positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x38));
+                        write_number(static_cast<std::uint8_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x39));
+                        write_number(static_cast<std::uint16_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x3A));
+                        write_number(static_cast<std::uint32_t>(positive_number));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x3B));
+                        write_number(static_cast<std::uint64_t>(positive_number));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_value.number_unsigned <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x18));
+                    write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x19));
+                    write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x1A));
+                    write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));
+                }
+                else
+                {
+                    oa->write_character(to_char_type(0x1B));
+                    write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                if (std::isnan(j.m_value.number_float))
+                {
+                    // NaN is 0xf97e00 in CBOR
+                    oa->write_character(to_char_type(0xF9));
+                    oa->write_character(to_char_type(0x7E));
+                    oa->write_character(to_char_type(0x00));
+                }
+                else if (std::isinf(j.m_value.number_float))
+                {
+                    // Infinity is 0xf97c00, -Infinity is 0xf9fc00
+                    oa->write_character(to_char_type(0xf9));
+                    oa->write_character(j.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
+                    oa->write_character(to_char_type(0x00));
+                }
+                else
+                {
+                    write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
+                }
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_value.string->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x60 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x78));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x79));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
+                    j.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_value.array->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x80 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x98));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x99));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.array)
+                {
+                    write_cbor(el);
+                }
+                break;
+            }
+
+            case value_t::binary:
+            {
+                if (j.m_value.binary->has_subtype())
+                {
+                    write_number(static_cast<std::uint8_t>(0xd8));
+                    write_number(j.m_value.binary->subtype());
+                }
+
+                // step 1: write control byte and the binary array size
+                const auto N = j.m_value.binary->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x40 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x58));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x59));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x5A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x5B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.binary->data()),
+                    N);
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_value.object->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0xA0 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB8));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB9));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBA));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBB));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.object)
+                {
+                    write_cbor(el.first);
+                    write_cbor(el.second);
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_msgpack(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null: // nil
+            {
+                oa->write_character(to_char_type(0xC0));
+                break;
+            }
+
+            case value_t::boolean: // true and false
+            {
+                oa->write_character(j.m_value.boolean
+                                    ? to_char_type(0xC3)
+                                    : to_char_type(0xC2));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_value.number_integer >= 0)
+                {
+                    // MessagePack does not differentiate between positive
+                    // signed integers and unsigned integers. Therefore, we used
+                    // the code from the value_t::number_unsigned case here.
+                    if (j.m_value.number_unsigned < 128)
+                    {
+                        // positive fixnum
+                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        // uint 8
+                        oa->write_character(to_char_type(0xCC));
+                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        // uint 16
+                        oa->write_character(to_char_type(0xCD));
+                        write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        // uint 32
+                        oa->write_character(to_char_type(0xCE));
+                        write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                    {
+                        // uint 64
+                        oa->write_character(to_char_type(0xCF));
+                        write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    if (j.m_value.number_integer >= -32)
+                    {
+                        // negative fixnum
+                        write_number(static_cast<std::int8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
+                             j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                    {
+                        // int 8
+                        oa->write_character(to_char_type(0xD0));
+                        write_number(static_cast<std::int8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
+                             j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                    {
+                        // int 16
+                        oa->write_character(to_char_type(0xD1));
+                        write_number(static_cast<std::int16_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
+                             j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                    {
+                        // int 32
+                        oa->write_character(to_char_type(0xD2));
+                        write_number(static_cast<std::int32_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
+                             j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                    {
+                        // int 64
+                        oa->write_character(to_char_type(0xD3));
+                        write_number(static_cast<std::int64_t>(j.m_value.number_integer));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_value.number_unsigned < 128)
+                {
+                    // positive fixnum
+                    write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // uint 8
+                    oa->write_character(to_char_type(0xCC));
+                    write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // uint 16
+                    oa->write_character(to_char_type(0xCD));
+                    write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // uint 32
+                    oa->write_character(to_char_type(0xCE));
+                    write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    // uint 64
+                    oa->write_character(to_char_type(0xCF));
+                    write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_value.string->size();
+                if (N <= 31)
+                {
+                    // fixstr
+                    write_number(static_cast<std::uint8_t>(0xA0 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // str 8
+                    oa->write_character(to_char_type(0xD9));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // str 16
+                    oa->write_character(to_char_type(0xDA));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // str 32
+                    oa->write_character(to_char_type(0xDB));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
+                    j.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_value.array->size();
+                if (N <= 15)
+                {
+                    // fixarray
+                    write_number(static_cast<std::uint8_t>(0x90 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // array 16
+                    oa->write_character(to_char_type(0xDC));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // array 32
+                    oa->write_character(to_char_type(0xDD));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.array)
+                {
+                    write_msgpack(el);
+                }
+                break;
+            }
+
+            case value_t::binary:
+            {
+                // step 0: determine if the binary type has a set subtype to
+                // determine whether or not to use the ext or fixext types
+                const bool use_ext = j.m_value.binary->has_subtype();
+
+                // step 1: write control byte and the byte string length
+                const auto N = j.m_value.binary->size();
+                if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    std::uint8_t output_type{};
+                    bool fixed = true;
+                    if (use_ext)
+                    {
+                        switch (N)
+                        {
+                            case 1:
+                                output_type = 0xD4; // fixext 1
+                                break;
+                            case 2:
+                                output_type = 0xD5; // fixext 2
+                                break;
+                            case 4:
+                                output_type = 0xD6; // fixext 4
+                                break;
+                            case 8:
+                                output_type = 0xD7; // fixext 8
+                                break;
+                            case 16:
+                                output_type = 0xD8; // fixext 16
+                                break;
+                            default:
+                                output_type = 0xC7; // ext 8
+                                fixed = false;
+                                break;
+                        }
+
+                    }
+                    else
+                    {
+                        output_type = 0xC4; // bin 8
+                        fixed = false;
+                    }
+
+                    oa->write_character(to_char_type(output_type));
+                    if (!fixed)
+                    {
+                        write_number(static_cast<std::uint8_t>(N));
+                    }
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    std::uint8_t output_type = use_ext
+                                               ? 0xC8 // ext 16
+                                               : 0xC5; // bin 16
+
+                    oa->write_character(to_char_type(output_type));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    std::uint8_t output_type = use_ext
+                                               ? 0xC9 // ext 32
+                                               : 0xC6; // bin 32
+
+                    oa->write_character(to_char_type(output_type));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 1.5: if this is an ext type, write the subtype
+                if (use_ext)
+                {
+                    write_number(static_cast<std::int8_t>(j.m_value.binary->subtype()));
+                }
+
+                // step 2: write the byte string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.binary->data()),
+                    N);
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_value.object->size();
+                if (N <= 15)
+                {
+                    // fixmap
+                    write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // map 16
+                    oa->write_character(to_char_type(0xDE));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // map 32
+                    oa->write_character(to_char_type(0xDF));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.object)
+                {
+                    write_msgpack(el.first);
+                    write_msgpack(el.second);
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @param[in] use_count   whether to use '#' prefixes (optimized format)
+    @param[in] use_type    whether to use '$' prefixes (optimized format)
+    @param[in] add_prefix  whether prefixes need to be used for this value
+    */
+    void write_ubjson(const BasicJsonType& j, const bool use_count,
+                      const bool use_type, const bool add_prefix = true)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('Z'));
+                }
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(j.m_value.boolean
+                                        ? to_char_type('T')
+                                        : to_char_type('F'));
+                }
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
+                break;
+            }
+
+            case value_t::string:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('S'));
+                }
+                write_number_with_ubjson_prefix(j.m_value.string->size(), true);
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
+                    j.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                bool prefix_required = true;
+                if (use_type && !j.m_value.array->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front());
+                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
+                                                         [this, first_prefix](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v) == first_prefix;
+                    });
+
+                    if (same_prefix)
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_value.array->size(), true);
+                }
+
+                for (const auto& el : *j.m_value.array)
+                {
+                    write_ubjson(el, use_count, use_type, prefix_required);
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::binary:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                if (use_type && !j.m_value.binary->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    oa->write_character(to_char_type('$'));
+                    oa->write_character('U');
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_value.binary->size(), true);
+                }
+
+                if (use_type)
+                {
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(j.m_value.binary->data()),
+                        j.m_value.binary->size());
+                }
+                else
+                {
+                    for (size_t i = 0; i < j.m_value.binary->size(); ++i)
+                    {
+                        oa->write_character(to_char_type('U'));
+                        oa->write_character(j.m_value.binary->data()[i]);
+                    }
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('{'));
+                }
+
+                bool prefix_required = true;
+                if (use_type && !j.m_value.object->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front());
+                    const bool same_prefix = std::all_of(j.begin(), j.end(),
+                                                         [this, first_prefix](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v) == first_prefix;
+                    });
+
+                    if (same_prefix)
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_value.object->size(), true);
+                }
+
+                for (const auto& el : *j.m_value.object)
+                {
+                    write_number_with_ubjson_prefix(el.first.size(), true);
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(el.first.c_str()),
+                        el.first.size());
+                    write_ubjson(el.second, use_count, use_type, prefix_required);
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type('}'));
+                }
+
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @return The size of a BSON document entry header, including the id marker
+            and the entry name size (and its null-terminator).
+    */
+    static std::size_t calc_bson_entry_header_size(const string_t& name)
+    {
+        const auto it = name.find(static_cast<typename string_t::value_type>(0));
+        if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
+        {
+            JSON_THROW(out_of_range::create(409,
+                                            "BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) + ")"));
+        }
+
+        return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
+    }
+
+    /*!
+    @brief Writes the given @a element_type and @a name to the output adapter
+    */
+    void write_bson_entry_header(const string_t& name,
+                                 const std::uint8_t element_type)
+    {
+        oa->write_character(to_char_type(element_type)); // boolean
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(name.c_str()),
+            name.size() + 1u);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and boolean value @a value
+    */
+    void write_bson_boolean(const string_t& name,
+                            const bool value)
+    {
+        write_bson_entry_header(name, 0x08);
+        oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and double value @a value
+    */
+    void write_bson_double(const string_t& name,
+                           const double value)
+    {
+        write_bson_entry_header(name, 0x01);
+        write_number<double, true>(value);
+    }
+
+    /*!
+    @return The size of the BSON-encoded string in @a value
+    */
+    static std::size_t calc_bson_string_size(const string_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and string value @a value
+    */
+    void write_bson_string(const string_t& name,
+                           const string_t& value)
+    {
+        write_bson_entry_header(name, 0x02);
+
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size() + 1ul));
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(value.c_str()),
+            value.size() + 1);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and null value
+    */
+    void write_bson_null(const string_t& name)
+    {
+        write_bson_entry_header(name, 0x0A);
+    }
+
+    /*!
+    @return The size of the BSON-encoded integer @a value
+    */
+    static std::size_t calc_bson_integer_size(const std::int64_t value)
+    {
+        return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and integer @a value
+    */
+    void write_bson_integer(const string_t& name,
+                            const std::int64_t value)
+    {
+        if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            write_bson_entry_header(name, 0x10); // int32
+            write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
+        }
+        else
+        {
+            write_bson_entry_header(name, 0x12); // int64
+            write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
+        }
+    }
+
+    /*!
+    @return The size of the BSON-encoded unsigned integer in @a j
+    */
+    static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
+    {
+        return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and unsigned @a value
+    */
+    void write_bson_unsigned(const string_t& name,
+                             const std::uint64_t value)
+    {
+        if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x10 /* int32 */);
+            write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
+        }
+        else if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x12 /* int64 */);
+            write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
+        }
+        else
+        {
+            JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(value) + " cannot be represented by BSON as it does not fit int64"));
+        }
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and object @a value
+    */
+    void write_bson_object_entry(const string_t& name,
+                                 const typename BasicJsonType::object_t& value)
+    {
+        write_bson_entry_header(name, 0x03); // object
+        write_bson_object(value);
+    }
+
+    /*!
+    @return The size of the BSON-encoded array @a value
+    */
+    static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
+    {
+        std::size_t array_index = 0ul;
+
+        const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), std::size_t(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
+        {
+            return result + calc_bson_element_size(std::to_string(array_index++), el);
+        });
+
+        return sizeof(std::int32_t) + embedded_document_size + 1ul;
+    }
+
+    /*!
+    @return The size of the BSON-encoded binary array @a value
+    */
+    static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and array @a value
+    */
+    void write_bson_array(const string_t& name,
+                          const typename BasicJsonType::array_t& value)
+    {
+        write_bson_entry_header(name, 0x04); // array
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_array_size(value)));
+
+        std::size_t array_index = 0ul;
+
+        for (const auto& el : value)
+        {
+            write_bson_element(std::to_string(array_index++), el);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and binary value @a value
+    */
+    void write_bson_binary(const string_t& name,
+                           const binary_t& value)
+    {
+        write_bson_entry_header(name, 0x05);
+
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size()));
+        write_number(value.has_subtype() ? value.subtype() : std::uint8_t(0x00));
+
+        oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
+    }
+
+    /*!
+    @brief Calculates the size necessary to serialize the JSON value @a j with its @a name
+    @return The calculated size for the BSON document entry for @a j with the given @a name.
+    */
+    static std::size_t calc_bson_element_size(const string_t& name,
+            const BasicJsonType& j)
+    {
+        const auto header_size = calc_bson_entry_header_size(name);
+        switch (j.type())
+        {
+            case value_t::object:
+                return header_size + calc_bson_object_size(*j.m_value.object);
+
+            case value_t::array:
+                return header_size + calc_bson_array_size(*j.m_value.array);
+
+            case value_t::binary:
+                return header_size + calc_bson_binary_size(*j.m_value.binary);
+
+            case value_t::boolean:
+                return header_size + 1ul;
+
+            case value_t::number_float:
+                return header_size + 8ul;
+
+            case value_t::number_integer:
+                return header_size + calc_bson_integer_size(j.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
+
+            case value_t::string:
+                return header_size + calc_bson_string_size(*j.m_value.string);
+
+            case value_t::null:
+                return header_size + 0ul;
+
+            // LCOV_EXCL_START
+            default:
+                JSON_ASSERT(false);
+                return 0ul;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Serializes the JSON value @a j to BSON and associates it with the
+           key @a name.
+    @param name The name to associate with the JSON entity @a j within the
+                current BSON document
+    @return The size of the BSON entry
+    */
+    void write_bson_element(const string_t& name,
+                            const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+                return write_bson_object_entry(name, *j.m_value.object);
+
+            case value_t::array:
+                return write_bson_array(name, *j.m_value.array);
+
+            case value_t::binary:
+                return write_bson_binary(name, *j.m_value.binary);
+
+            case value_t::boolean:
+                return write_bson_boolean(name, j.m_value.boolean);
+
+            case value_t::number_float:
+                return write_bson_double(name, j.m_value.number_float);
+
+            case value_t::number_integer:
+                return write_bson_integer(name, j.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return write_bson_unsigned(name, j.m_value.number_unsigned);
+
+            case value_t::string:
+                return write_bson_string(name, *j.m_value.string);
+
+            case value_t::null:
+                return write_bson_null(name);
+
+            // LCOV_EXCL_START
+            default:
+                JSON_ASSERT(false);
+                return;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Calculates the size of the BSON serialization of the given
+           JSON-object @a j.
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
+    {
+        std::size_t document_size = std::accumulate(value.begin(), value.end(), std::size_t(0),
+                                    [](size_t result, const typename BasicJsonType::object_t::value_type & el)
+        {
+            return result += calc_bson_element_size(el.first, el.second);
+        });
+
+        return sizeof(std::int32_t) + document_size + 1ul;
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    void write_bson_object(const typename BasicJsonType::object_t& value)
+    {
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_object_size(value)));
+
+        for (const auto& el : value)
+        {
+            write_bson_element(el.first, el.second);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    static constexpr CharType get_cbor_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xFA);  // Single-Precision Float
+    }
+
+    static constexpr CharType get_cbor_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xFB);  // Double-Precision Float
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xCA);  // float 32
+    }
+
+    static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xCB);  // float 64
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    // UBJSON: write number (floating point)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_floating_point<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix)
+    {
+        if (add_prefix)
+        {
+            oa->write_character(get_ubjson_float_prefix(n));
+        }
+        write_number(n);
+    }
+
+    // UBJSON: write number (unsigned integer)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_unsigned<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix)
+    {
+        if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::uint8_t>(n));
+        }
+        else if (n <= (std::numeric_limits<std::uint8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n));
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n));
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n));
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n));
+        }
+        else
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('H'));  // high-precision number
+            }
+
+            const auto number = BasicJsonType(n).dump();
+            write_number_with_ubjson_prefix(number.size(), true);
+            for (std::size_t i = 0; i < number.size(); ++i)
+            {
+                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+            }
+        }
+    }
+
+    // UBJSON: write number (signed integer)
+    template < typename NumberType, typename std::enable_if <
+                   std::is_signed<NumberType>::value&&
+                   !std::is_floating_point<NumberType>::value, int >::type = 0 >
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix)
+    {
+        if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::int8_t>(n));
+        }
+        else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n));
+        }
+        else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n));
+        }
+        else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n));
+        }
+        else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n));
+        }
+        // LCOV_EXCL_START
+        else
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('H'));  // high-precision number
+            }
+
+            const auto number = BasicJsonType(n).dump();
+            write_number_with_ubjson_prefix(number.size(), true);
+            for (std::size_t i = 0; i < number.size(); ++i)
+            {
+                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+            }
+        }
+        // LCOV_EXCL_STOP
+    }
+
+    /*!
+    @brief determine the type prefix of container values
+    */
+    CharType ubjson_prefix(const BasicJsonType& j) const noexcept
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+                return 'Z';
+
+            case value_t::boolean:
+                return j.m_value.boolean ? 'T' : 'F';
+
+            case value_t::number_integer:
+            {
+                if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                {
+                    return 'i';
+                }
+                if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    return 'U';
+                }
+                if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                {
+                    return 'I';
+                }
+                if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                {
+                    return 'l';
+                }
+                if ((std::numeric_limits<std::int64_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                {
+                    return 'L';
+                }
+                // anything else is treated as high-precision number
+                return 'H'; // LCOV_EXCL_LINE
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+                {
+                    return 'i';
+                }
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
+                {
+                    return 'U';
+                }
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+                {
+                    return 'I';
+                }
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+                {
+                    return 'l';
+                }
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+                {
+                    return 'L';
+                }
+                // anything else is treated as high-precision number
+                return 'H'; // LCOV_EXCL_LINE
+            }
+
+            case value_t::number_float:
+                return get_ubjson_float_prefix(j.m_value.number_float);
+
+            case value_t::string:
+                return 'S';
+
+            case value_t::array: // fallthrough
+            case value_t::binary:
+                return '[';
+
+            case value_t::object:
+                return '{';
+
+            default:  // discarded values
+                return 'N';
+        }
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
+    {
+        return 'd';  // float 32
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
+    {
+        return 'D';  // float 64
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*
+    @brief write a number to output input
+    @param[in] n number of type @a NumberType
+    @tparam NumberType the type of the number
+    @tparam OutputIsLittleEndian Set to true if output data is
+                                 required to be little endian
+
+    @note This function needs to respect the system's endianess, because bytes
+          in CBOR, MessagePack, and UBJSON are stored in network order (big
+          endian) and therefore need reordering on little endian systems.
+    */
+    template<typename NumberType, bool OutputIsLittleEndian = false>
+    void write_number(const NumberType n)
+    {
+        // step 1: write number to array of length NumberType
+        std::array<CharType, sizeof(NumberType)> vec;
+        std::memcpy(vec.data(), &n, sizeof(NumberType));
+
+        // step 2: write array to output (with possible reordering)
+        if (is_little_endian != OutputIsLittleEndian)
+        {
+            // reverse byte order prior to conversion if necessary
+            std::reverse(vec.begin(), vec.end());
+        }
+
+        oa->write_characters(vec.data(), sizeof(NumberType));
+    }
+
+    void write_compact_float(const number_float_t n, detail::input_format_t format)
+    {
+        if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
+                static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
+                static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
+        {
+            oa->write_character(format == detail::input_format_t::cbor
+                                ? get_cbor_float_prefix(static_cast<float>(n))
+                                : get_msgpack_float_prefix(static_cast<float>(n)));
+            write_number(static_cast<float>(n));
+        }
+        else
+        {
+            oa->write_character(format == detail::input_format_t::cbor
+                                ? get_cbor_float_prefix(n)
+                                : get_msgpack_float_prefix(n));
+            write_number(n);
+        }
+    }
+
+  public:
+    // The following to_char_type functions are implement the conversion
+    // between uint8_t and CharType. In case CharType is not unsigned,
+    // such a conversion is required to allow values greater than 128.
+    // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return *reinterpret_cast<char*>(&x);
+    }
+
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
+    static CharType to_char_type(std::uint8_t x) noexcept
+    {
+        static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
+        static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
+        CharType result;
+        std::memcpy(&result, &x, sizeof(x));
+        return result;
+    }
+
+    template<typename C = CharType,
+             enable_if_t<std::is_unsigned<C>::value>* = nullptr>
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return x;
+    }
+
+    template < typename InputCharType, typename C = CharType,
+               enable_if_t <
+                   std::is_signed<C>::value &&
+                   std::is_signed<char>::value &&
+                   std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
+                   > * = nullptr >
+    static constexpr CharType to_char_type(InputCharType x) noexcept
+    {
+        return x;
+    }
+
+  private:
+    /// whether we can assume little endianess
+    const bool is_little_endian = little_endianess();
+
+    /// the output
+    output_adapter_t<CharType> oa = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/output/serializer.hpp>
+
+
+#include <algorithm> // reverse, remove, fill, find, none_of
+#include <array> // array
+#include <clocale> // localeconv, lconv
+#include <cmath> // labs, isfinite, isnan, signbit
+#include <cstddef> // size_t, ptrdiff_t
+#include <cstdint> // uint8_t
+#include <cstdio> // snprintf
+#include <limits> // numeric_limits
+#include <string> // string, char_traits
+#include <type_traits> // is_same
+#include <utility> // move
+
+// #include <nlohmann/detail/conversions/to_chars.hpp>
+
+
+#include <array> // array
+#include <cmath>   // signbit, isfinite
+#include <cstdint> // intN_t, uintN_t
+#include <cstring> // memcpy, memmove
+#include <limits> // numeric_limits
+#include <type_traits> // conditional
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+
+/*!
+@brief implements the Grisu2 algorithm for binary to decimal floating-point
+conversion.
+
+This implementation is a slightly modified version of the reference
+implementation which may be obtained from
+http://florian.loitsch.com/publications (bench.tar.gz).
+
+The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
+
+For a detailed description of the algorithm see:
+
+[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
+    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
+    Language Design and Implementation, PLDI 2010
+[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
+    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
+    Design and Implementation, PLDI 1996
+*/
+namespace dtoa_impl
+{
+
+template<typename Target, typename Source>
+Target reinterpret_bits(const Source source)
+{
+    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
+
+    Target target;
+    std::memcpy(&target, &source, sizeof(Source));
+    return target;
+}
+
+struct diyfp // f * 2^e
+{
+    static constexpr int kPrecision = 64; // = q
+
+    std::uint64_t f = 0;
+    int e = 0;
+
+    constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
+
+    /*!
+    @brief returns x - y
+    @pre x.e == y.e and x.f >= y.f
+    */
+    static diyfp sub(const diyfp& x, const diyfp& y) noexcept
+    {
+        JSON_ASSERT(x.e == y.e);
+        JSON_ASSERT(x.f >= y.f);
+
+        return {x.f - y.f, x.e};
+    }
+
+    /*!
+    @brief returns x * y
+    @note The result is rounded. (Only the upper q bits are returned.)
+    */
+    static diyfp mul(const diyfp& x, const diyfp& y) noexcept
+    {
+        static_assert(kPrecision == 64, "internal error");
+
+        // Computes:
+        //  f = round((x.f * y.f) / 2^q)
+        //  e = x.e + y.e + q
+
+        // Emulate the 64-bit * 64-bit multiplication:
+        //
+        // p = u * v
+        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
+        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
+        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
+        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
+        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
+        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
+        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
+        //
+        // (Since Q might be larger than 2^32 - 1)
+        //
+        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
+        //
+        // (Q_hi + H does not overflow a 64-bit int)
+        //
+        //   = p_lo + 2^64 p_hi
+
+        const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
+        const std::uint64_t u_hi = x.f >> 32u;
+        const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
+        const std::uint64_t v_hi = y.f >> 32u;
+
+        const std::uint64_t p0 = u_lo * v_lo;
+        const std::uint64_t p1 = u_lo * v_hi;
+        const std::uint64_t p2 = u_hi * v_lo;
+        const std::uint64_t p3 = u_hi * v_hi;
+
+        const std::uint64_t p0_hi = p0 >> 32u;
+        const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
+        const std::uint64_t p1_hi = p1 >> 32u;
+        const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
+        const std::uint64_t p2_hi = p2 >> 32u;
+
+        std::uint64_t Q = p0_hi + p1_lo + p2_lo;
+
+        // The full product might now be computed as
+        //
+        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
+        // p_lo = p0_lo + (Q << 32)
+        //
+        // But in this particular case here, the full p_lo is not required.
+        // Effectively we only need to add the highest bit in p_lo to p_hi (and
+        // Q_hi + 1 does not overflow).
+
+        Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
+
+        const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
+
+        return {h, x.e + y.e + 64};
+    }
+
+    /*!
+    @brief normalize x such that the significand is >= 2^(q-1)
+    @pre x.f != 0
+    */
+    static diyfp normalize(diyfp x) noexcept
+    {
+        JSON_ASSERT(x.f != 0);
+
+        while ((x.f >> 63u) == 0)
+        {
+            x.f <<= 1u;
+            x.e--;
+        }
+
+        return x;
+    }
+
+    /*!
+    @brief normalize x such that the result has the exponent E
+    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
+    */
+    static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
+    {
+        const int delta = x.e - target_exponent;
+
+        JSON_ASSERT(delta >= 0);
+        JSON_ASSERT(((x.f << delta) >> delta) == x.f);
+
+        return {x.f << delta, target_exponent};
+    }
+};
+
+struct boundaries
+{
+    diyfp w;
+    diyfp minus;
+    diyfp plus;
+};
+
+/*!
+Compute the (normalized) diyfp representing the input number 'value' and its
+boundaries.
+
+@pre value must be finite and positive
+*/
+template<typename FloatType>
+boundaries compute_boundaries(FloatType value)
+{
+    JSON_ASSERT(std::isfinite(value));
+    JSON_ASSERT(value > 0);
+
+    // Convert the IEEE representation into a diyfp.
+    //
+    // If v is denormal:
+    //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
+    // If v is normalized:
+    //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
+
+    static_assert(std::numeric_limits<FloatType>::is_iec559,
+                  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
+
+    constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
+    constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
+    constexpr int      kMinExp    = 1 - kBias;
+    constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
+
+    using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
+
+    const std::uint64_t bits = reinterpret_bits<bits_type>(value);
+    const std::uint64_t E = bits >> (kPrecision - 1);
+    const std::uint64_t F = bits & (kHiddenBit - 1);
+
+    const bool is_denormal = E == 0;
+    const diyfp v = is_denormal
+                    ? diyfp(F, kMinExp)
+                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
+
+    // Compute the boundaries m- and m+ of the floating-point value
+    // v = f * 2^e.
+    //
+    // Determine v- and v+, the floating-point predecessor and successor if v,
+    // respectively.
+    //
+    //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
+    //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
+    //
+    //      v+ = v + 2^e
+    //
+    // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
+    // between m- and m+ round to v, regardless of how the input rounding
+    // algorithm breaks ties.
+    //
+    //      ---+-------------+-------------+-------------+-------------+---  (A)
+    //         v-            m-            v             m+            v+
+    //
+    //      -----------------+------+------+-------------+-------------+---  (B)
+    //                       v-     m-     v             m+            v+
+
+    const bool lower_boundary_is_closer = F == 0 && E > 1;
+    const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
+    const diyfp m_minus = lower_boundary_is_closer
+                          ? diyfp(4 * v.f - 1, v.e - 2)  // (B)
+                          : diyfp(2 * v.f - 1, v.e - 1); // (A)
+
+    // Determine the normalized w+ = m+.
+    const diyfp w_plus = diyfp::normalize(m_plus);
+
+    // Determine w- = m- such that e_(w-) = e_(w+).
+    const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
+
+    return {diyfp::normalize(v), w_minus, w_plus};
+}
+
+// Given normalized diyfp w, Grisu needs to find a (normalized) cached
+// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
+// within a certain range [alpha, gamma] (Definition 3.2 from [1])
+//
+//      alpha <= e = e_c + e_w + q <= gamma
+//
+// or
+//
+//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
+//                          <= f_c * f_w * 2^gamma
+//
+// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
+//
+//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
+//
+// or
+//
+//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
+//
+// The choice of (alpha,gamma) determines the size of the table and the form of
+// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
+// in practice:
+//
+// The idea is to cut the number c * w = f * 2^e into two parts, which can be
+// processed independently: An integral part p1, and a fractional part p2:
+//
+//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
+//              = (f div 2^-e) + (f mod 2^-e) * 2^e
+//              = p1 + p2 * 2^e
+//
+// The conversion of p1 into decimal form requires a series of divisions and
+// modulos by (a power of) 10. These operations are faster for 32-bit than for
+// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
+// achieved by choosing
+//
+//      -e >= 32   or   e <= -32 := gamma
+//
+// In order to convert the fractional part
+//
+//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
+//
+// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
+// d[-i] are extracted in order:
+//
+//      (10 * p2) div 2^-e = d[-1]
+//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
+//
+// The multiplication by 10 must not overflow. It is sufficient to choose
+//
+//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
+//
+// Since p2 = f mod 2^-e < 2^-e,
+//
+//      -e <= 60   or   e >= -60 := alpha
+
+constexpr int kAlpha = -60;
+constexpr int kGamma = -32;
+
+struct cached_power // c = f * 2^e ~= 10^k
+{
+    std::uint64_t f;
+    int e;
+    int k;
+};
+
+/*!
+For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
+power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
+satisfies (Definition 3.2 from [1])
+
+     alpha <= e_c + e + q <= gamma.
+*/
+inline cached_power get_cached_power_for_binary_exponent(int e)
+{
+    // Now
+    //
+    //      alpha <= e_c + e + q <= gamma                                    (1)
+    //      ==> f_c * 2^alpha <= c * 2^e * 2^q
+    //
+    // and since the c's are normalized, 2^(q-1) <= f_c,
+    //
+    //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
+    //      ==> 2^(alpha - e - 1) <= c
+    //
+    // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
+    //
+    //      k = ceil( log_10( 2^(alpha - e - 1) ) )
+    //        = ceil( (alpha - e - 1) * log_10(2) )
+    //
+    // From the paper:
+    // "In theory the result of the procedure could be wrong since c is rounded,
+    //  and the computation itself is approximated [...]. In practice, however,
+    //  this simple function is sufficient."
+    //
+    // For IEEE double precision floating-point numbers converted into
+    // normalized diyfp's w = f * 2^e, with q = 64,
+    //
+    //      e >= -1022      (min IEEE exponent)
+    //           -52        (p - 1)
+    //           -52        (p - 1, possibly normalize denormal IEEE numbers)
+    //           -11        (normalize the diyfp)
+    //         = -1137
+    //
+    // and
+    //
+    //      e <= +1023      (max IEEE exponent)
+    //           -52        (p - 1)
+    //           -11        (normalize the diyfp)
+    //         = 960
+    //
+    // This binary exponent range [-1137,960] results in a decimal exponent
+    // range [-307,324]. One does not need to store a cached power for each
+    // k in this range. For each such k it suffices to find a cached power
+    // such that the exponent of the product lies in [alpha,gamma].
+    // This implies that the difference of the decimal exponents of adjacent
+    // table entries must be less than or equal to
+    //
+    //      floor( (gamma - alpha) * log_10(2) ) = 8.
+    //
+    // (A smaller distance gamma-alpha would require a larger table.)
+
+    // NB:
+    // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
+
+    constexpr int kCachedPowersMinDecExp = -300;
+    constexpr int kCachedPowersDecStep = 8;
+
+    static constexpr std::array<cached_power, 79> kCachedPowers =
+    {
+        {
+            { 0xAB70FE17C79AC6CA, -1060, -300 },
+            { 0xFF77B1FCBEBCDC4F, -1034, -292 },
+            { 0xBE5691EF416BD60C, -1007, -284 },
+            { 0x8DD01FAD907FFC3C,  -980, -276 },
+            { 0xD3515C2831559A83,  -954, -268 },
+            { 0x9D71AC8FADA6C9B5,  -927, -260 },
+            { 0xEA9C227723EE8BCB,  -901, -252 },
+            { 0xAECC49914078536D,  -874, -244 },
+            { 0x823C12795DB6CE57,  -847, -236 },
+            { 0xC21094364DFB5637,  -821, -228 },
+            { 0x9096EA6F3848984F,  -794, -220 },
+            { 0xD77485CB25823AC7,  -768, -212 },
+            { 0xA086CFCD97BF97F4,  -741, -204 },
+            { 0xEF340A98172AACE5,  -715, -196 },
+            { 0xB23867FB2A35B28E,  -688, -188 },
+            { 0x84C8D4DFD2C63F3B,  -661, -180 },
+            { 0xC5DD44271AD3CDBA,  -635, -172 },
+            { 0x936B9FCEBB25C996,  -608, -164 },
+            { 0xDBAC6C247D62A584,  -582, -156 },
+            { 0xA3AB66580D5FDAF6,  -555, -148 },
+            { 0xF3E2F893DEC3F126,  -529, -140 },
+            { 0xB5B5ADA8AAFF80B8,  -502, -132 },
+            { 0x87625F056C7C4A8B,  -475, -124 },
+            { 0xC9BCFF6034C13053,  -449, -116 },
+            { 0x964E858C91BA2655,  -422, -108 },
+            { 0xDFF9772470297EBD,  -396, -100 },
+            { 0xA6DFBD9FB8E5B88F,  -369,  -92 },
+            { 0xF8A95FCF88747D94,  -343,  -84 },
+            { 0xB94470938FA89BCF,  -316,  -76 },
+            { 0x8A08F0F8BF0F156B,  -289,  -68 },
+            { 0xCDB02555653131B6,  -263,  -60 },
+            { 0x993FE2C6D07B7FAC,  -236,  -52 },
+            { 0xE45C10C42A2B3B06,  -210,  -44 },
+            { 0xAA242499697392D3,  -183,  -36 },
+            { 0xFD87B5F28300CA0E,  -157,  -28 },
+            { 0xBCE5086492111AEB,  -130,  -20 },
+            { 0x8CBCCC096F5088CC,  -103,  -12 },
+            { 0xD1B71758E219652C,   -77,   -4 },
+            { 0x9C40000000000000,   -50,    4 },
+            { 0xE8D4A51000000000,   -24,   12 },
+            { 0xAD78EBC5AC620000,     3,   20 },
+            { 0x813F3978F8940984,    30,   28 },
+            { 0xC097CE7BC90715B3,    56,   36 },
+            { 0x8F7E32CE7BEA5C70,    83,   44 },
+            { 0xD5D238A4ABE98068,   109,   52 },
+            { 0x9F4F2726179A2245,   136,   60 },
+            { 0xED63A231D4C4FB27,   162,   68 },
+            { 0xB0DE65388CC8ADA8,   189,   76 },
+            { 0x83C7088E1AAB65DB,   216,   84 },
+            { 0xC45D1DF942711D9A,   242,   92 },
+            { 0x924D692CA61BE758,   269,  100 },
+            { 0xDA01EE641A708DEA,   295,  108 },
+            { 0xA26DA3999AEF774A,   322,  116 },
+            { 0xF209787BB47D6B85,   348,  124 },
+            { 0xB454E4A179DD1877,   375,  132 },
+            { 0x865B86925B9BC5C2,   402,  140 },
+            { 0xC83553C5C8965D3D,   428,  148 },
+            { 0x952AB45CFA97A0B3,   455,  156 },
+            { 0xDE469FBD99A05FE3,   481,  164 },
+            { 0xA59BC234DB398C25,   508,  172 },
+            { 0xF6C69A72A3989F5C,   534,  180 },
+            { 0xB7DCBF5354E9BECE,   561,  188 },
+            { 0x88FCF317F22241E2,   588,  196 },
+            { 0xCC20CE9BD35C78A5,   614,  204 },
+            { 0x98165AF37B2153DF,   641,  212 },
+            { 0xE2A0B5DC971F303A,   667,  220 },
+            { 0xA8D9D1535CE3B396,   694,  228 },
+            { 0xFB9B7CD9A4A7443C,   720,  236 },
+            { 0xBB764C4CA7A44410,   747,  244 },
+            { 0x8BAB8EEFB6409C1A,   774,  252 },
+            { 0xD01FEF10A657842C,   800,  260 },
+            { 0x9B10A4E5E9913129,   827,  268 },
+            { 0xE7109BFBA19C0C9D,   853,  276 },
+            { 0xAC2820D9623BF429,   880,  284 },
+            { 0x80444B5E7AA7CF85,   907,  292 },
+            { 0xBF21E44003ACDD2D,   933,  300 },
+            { 0x8E679C2F5E44FF8F,   960,  308 },
+            { 0xD433179D9C8CB841,   986,  316 },
+            { 0x9E19DB92B4E31BA9,  1013,  324 },
+        }
+    };
+
+    // This computation gives exactly the same results for k as
+    //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
+    // for |e| <= 1500, but doesn't require floating-point operations.
+    // NB: log_10(2) ~= 78913 / 2^18
+    JSON_ASSERT(e >= -1500);
+    JSON_ASSERT(e <=  1500);
+    const int f = kAlpha - e - 1;
+    const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
+
+    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
+    JSON_ASSERT(index >= 0);
+    JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
+
+    const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
+    JSON_ASSERT(kAlpha <= cached.e + e + 64);
+    JSON_ASSERT(kGamma >= cached.e + e + 64);
+
+    return cached;
+}
+
+/*!
+For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
+For n == 0, returns 1 and sets pow10 := 1.
+*/
+inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
+{
+    // LCOV_EXCL_START
+    if (n >= 1000000000)
+    {
+        pow10 = 1000000000;
+        return 10;
+    }
+    // LCOV_EXCL_STOP
+    else if (n >= 100000000)
+    {
+        pow10 = 100000000;
+        return  9;
+    }
+    else if (n >= 10000000)
+    {
+        pow10 = 10000000;
+        return  8;
+    }
+    else if (n >= 1000000)
+    {
+        pow10 = 1000000;
+        return  7;
+    }
+    else if (n >= 100000)
+    {
+        pow10 = 100000;
+        return  6;
+    }
+    else if (n >= 10000)
+    {
+        pow10 = 10000;
+        return  5;
+    }
+    else if (n >= 1000)
+    {
+        pow10 = 1000;
+        return  4;
+    }
+    else if (n >= 100)
+    {
+        pow10 = 100;
+        return  3;
+    }
+    else if (n >= 10)
+    {
+        pow10 = 10;
+        return  2;
+    }
+    else
+    {
+        pow10 = 1;
+        return 1;
+    }
+}
+
+inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
+                         std::uint64_t rest, std::uint64_t ten_k)
+{
+    JSON_ASSERT(len >= 1);
+    JSON_ASSERT(dist <= delta);
+    JSON_ASSERT(rest <= delta);
+    JSON_ASSERT(ten_k > 0);
+
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    //                                  ten_k
+    //                                <------>
+    //                                       <---- rest ---->
+    // --------------[------------------+----+--------------]--------------
+    //                                  w    V
+    //                                       = buf * 10^k
+    //
+    // ten_k represents a unit-in-the-last-place in the decimal representation
+    // stored in buf.
+    // Decrement buf by ten_k while this takes buf closer to w.
+
+    // The tests are written in this order to avoid overflow in unsigned
+    // integer arithmetic.
+
+    while (rest < dist
+            && delta - rest >= ten_k
+            && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
+    {
+        JSON_ASSERT(buf[len - 1] != '0');
+        buf[len - 1]--;
+        rest += ten_k;
+    }
+}
+
+/*!
+Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
+M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
+*/
+inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
+                             diyfp M_minus, diyfp w, diyfp M_plus)
+{
+    static_assert(kAlpha >= -60, "internal error");
+    static_assert(kGamma <= -32, "internal error");
+
+    // Generates the digits (and the exponent) of a decimal floating-point
+    // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
+    // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
+    //
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    // Grisu2 generates the digits of M+ from left to right and stops as soon as
+    // V is in [M-,M+].
+
+    JSON_ASSERT(M_plus.e >= kAlpha);
+    JSON_ASSERT(M_plus.e <= kGamma);
+
+    std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
+    std::uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)
+
+    // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
+    //
+    //      M+ = f * 2^e
+    //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
+    //         = ((p1        ) * 2^-e + (p2        )) * 2^e
+    //         = p1 + p2 * 2^e
+
+    const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
+
+    auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
+    std::uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e
+
+    // 1)
+    //
+    // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
+
+    JSON_ASSERT(p1 > 0);
+
+    std::uint32_t pow10;
+    const int k = find_largest_pow10(p1, pow10);
+
+    //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
+    //
+    //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
+    //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
+    //
+    //      M+ = p1                                             + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
+    //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
+    //
+    // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
+    //
+    //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
+    //
+    // but stop as soon as
+    //
+    //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
+
+    int n = k;
+    while (n > 0)
+    {
+        // Invariants:
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        //
+        const std::uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)
+        const std::uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)
+        //
+        //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
+        //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
+        //
+        JSON_ASSERT(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
+        //
+        p1 = r;
+        n--;
+        //
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
+        //      pow10 = 10^n
+        //
+
+        // Now check if enough digits have been generated.
+        // Compute
+        //
+        //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
+        //
+        // Note:
+        // Since rest and delta share the same exponent e, it suffices to
+        // compare the significands.
+        const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
+        if (rest <= delta)
+        {
+            // V = buffer * 10^n, with M- <= V <= M+.
+
+            decimal_exponent += n;
+
+            // We may now just stop. But instead look if the buffer could be
+            // decremented to bring V closer to w.
+            //
+            // pow10 = 10^n is now 1 ulp in the decimal representation V.
+            // The rounding procedure works with diyfp's with an implicit
+            // exponent of e.
+            //
+            //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
+            //
+            const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
+            grisu2_round(buffer, length, dist, delta, rest, ten_n);
+
+            return;
+        }
+
+        pow10 /= 10;
+        //
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        // Invariants restored.
+    }
+
+    // 2)
+    //
+    // The digits of the integral part have been generated:
+    //
+    //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
+    //         = buffer            + p2 * 2^e
+    //
+    // Now generate the digits of the fractional part p2 * 2^e.
+    //
+    // Note:
+    // No decimal point is generated: the exponent is adjusted instead.
+    //
+    // p2 actually represents the fraction
+    //
+    //      p2 * 2^e
+    //          = p2 / 2^-e
+    //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
+    //
+    // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
+    //
+    //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
+    //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
+    //
+    // using
+    //
+    //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
+    //                = (                   d) * 2^-e + (                   r)
+    //
+    // or
+    //      10^m * p2 * 2^e = d + r * 2^e
+    //
+    // i.e.
+    //
+    //      M+ = buffer + p2 * 2^e
+    //         = buffer + 10^-m * (d + r * 2^e)
+    //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
+    //
+    // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
+
+    JSON_ASSERT(p2 > delta);
+
+    int m = 0;
+    for (;;)
+    {
+        // Invariant:
+        //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
+        //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
+        //
+        JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
+        p2 *= 10;
+        const std::uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
+        const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
+        //
+        //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
+        //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        JSON_ASSERT(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        p2 = r;
+        m++;
+        //
+        //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
+        // Invariant restored.
+
+        // Check if enough digits have been generated.
+        //
+        //      10^-m * p2 * 2^e <= delta * 2^e
+        //              p2 * 2^e <= 10^m * delta * 2^e
+        //                    p2 <= 10^m * delta
+        delta *= 10;
+        dist  *= 10;
+        if (p2 <= delta)
+        {
+            break;
+        }
+    }
+
+    // V = buffer * 10^-m, with M- <= V <= M+.
+
+    decimal_exponent -= m;
+
+    // 1 ulp in the decimal representation is now 10^-m.
+    // Since delta and dist are now scaled by 10^m, we need to do the
+    // same with ulp in order to keep the units in sync.
+    //
+    //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
+    //
+    const std::uint64_t ten_m = one.f;
+    grisu2_round(buffer, length, dist, delta, p2, ten_m);
+
+    // By construction this algorithm generates the shortest possible decimal
+    // number (Loitsch, Theorem 6.2) which rounds back to w.
+    // For an input number of precision p, at least
+    //
+    //      N = 1 + ceil(p * log_10(2))
+    //
+    // decimal digits are sufficient to identify all binary floating-point
+    // numbers (Matula, "In-and-Out conversions").
+    // This implies that the algorithm does not produce more than N decimal
+    // digits.
+    //
+    //      N = 17 for p = 53 (IEEE double precision)
+    //      N = 9  for p = 24 (IEEE single precision)
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+JSON_HEDLEY_NON_NULL(1)
+inline void grisu2(char* buf, int& len, int& decimal_exponent,
+                   diyfp m_minus, diyfp v, diyfp m_plus)
+{
+    JSON_ASSERT(m_plus.e == m_minus.e);
+    JSON_ASSERT(m_plus.e == v.e);
+
+    //  --------(-----------------------+-----------------------)--------    (A)
+    //          m-                      v                       m+
+    //
+    //  --------------------(-----------+-----------------------)--------    (B)
+    //                      m-          v                       m+
+    //
+    // First scale v (and m- and m+) such that the exponent is in the range
+    // [alpha, gamma].
+
+    const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
+
+    const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
+
+    // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
+    const diyfp w       = diyfp::mul(v,       c_minus_k);
+    const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
+    const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);
+
+    //  ----(---+---)---------------(---+---)---------------(---+---)----
+    //          w-                      w                       w+
+    //          = c*m-                  = c*v                   = c*m+
+    //
+    // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
+    // w+ are now off by a small amount.
+    // In fact:
+    //
+    //      w - v * 10^k < 1 ulp
+    //
+    // To account for this inaccuracy, add resp. subtract 1 ulp.
+    //
+    //  --------+---[---------------(---+---)---------------]---+--------
+    //          w-  M-                  w                   M+  w+
+    //
+    // Now any number in [M-, M+] (bounds included) will round to w when input,
+    // regardless of how the input rounding algorithm breaks ties.
+    //
+    // And digit_gen generates the shortest possible such number in [M-, M+].
+    // Note that this does not mean that Grisu2 always generates the shortest
+    // possible number in the interval (m-, m+).
+    const diyfp M_minus(w_minus.f + 1, w_minus.e);
+    const diyfp M_plus (w_plus.f  - 1, w_plus.e );
+
+    decimal_exponent = -cached.k; // = -(-k) = k
+
+    grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+template<typename FloatType>
+JSON_HEDLEY_NON_NULL(1)
+void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
+{
+    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
+                  "internal error: not enough precision");
+
+    JSON_ASSERT(std::isfinite(value));
+    JSON_ASSERT(value > 0);
+
+    // If the neighbors (and boundaries) of 'value' are always computed for double-precision
+    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
+    // decimal representations are not exactly "short".
+    //
+    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
+    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
+    // and since sprintf promotes float's to double's, I think this is exactly what 'std::to_chars'
+    // does.
+    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
+    // representation using the corresponding std::from_chars function recovers value exactly". That
+    // indicates that single precision floating-point numbers should be recovered using
+    // 'std::strtof'.
+    //
+    // NB: If the neighbors are computed for single-precision numbers, there is a single float
+    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
+    //     value is off by 1 ulp.
+#if 0
+    const boundaries w = compute_boundaries(static_cast<double>(value));
+#else
+    const boundaries w = compute_boundaries(value);
+#endif
+
+    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
+}
+
+/*!
+@brief appends a decimal representation of e to buf
+@return a pointer to the element following the exponent.
+@pre -1000 < e < 1000
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* append_exponent(char* buf, int e)
+{
+    JSON_ASSERT(e > -1000);
+    JSON_ASSERT(e <  1000);
+
+    if (e < 0)
+    {
+        e = -e;
+        *buf++ = '-';
+    }
+    else
+    {
+        *buf++ = '+';
+    }
+
+    auto k = static_cast<std::uint32_t>(e);
+    if (k < 10)
+    {
+        // Always print at least two digits in the exponent.
+        // This is for compatibility with printf("%g").
+        *buf++ = '0';
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else if (k < 100)
+    {
+        *buf++ = static_cast<char>('0' + k / 10);
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else
+    {
+        *buf++ = static_cast<char>('0' + k / 100);
+        k %= 100;
+        *buf++ = static_cast<char>('0' + k / 10);
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+
+    return buf;
+}
+
+/*!
+@brief prettify v = buf * 10^decimal_exponent
+
+If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
+notation. Otherwise it will be printed in exponential notation.
+
+@pre min_exp < 0
+@pre max_exp > 0
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* format_buffer(char* buf, int len, int decimal_exponent,
+                           int min_exp, int max_exp)
+{
+    JSON_ASSERT(min_exp < 0);
+    JSON_ASSERT(max_exp > 0);
+
+    const int k = len;
+    const int n = len + decimal_exponent;
+
+    // v = buf * 10^(n-k)
+    // k is the length of the buffer (number of decimal digits)
+    // n is the position of the decimal point relative to the start of the buffer.
+
+    if (k <= n && n <= max_exp)
+    {
+        // digits[000]
+        // len <= max_exp + 2
+
+        std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
+        // Make it look like a floating-point number (#362, #378)
+        buf[n + 0] = '.';
+        buf[n + 1] = '0';
+        return buf + (static_cast<size_t>(n) + 2);
+    }
+
+    if (0 < n && n <= max_exp)
+    {
+        // dig.its
+        // len <= max_digits10 + 1
+
+        JSON_ASSERT(k > n);
+
+        std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
+        buf[n] = '.';
+        return buf + (static_cast<size_t>(k) + 1U);
+    }
+
+    if (min_exp < n && n <= 0)
+    {
+        // 0.[000]digits
+        // len <= 2 + (-min_exp - 1) + max_digits10
+
+        std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
+        buf[0] = '0';
+        buf[1] = '.';
+        std::memset(buf + 2, '0', static_cast<size_t>(-n));
+        return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
+    }
+
+    if (k == 1)
+    {
+        // dE+123
+        // len <= 1 + 5
+
+        buf += 1;
+    }
+    else
+    {
+        // d.igitsE+123
+        // len <= max_digits10 + 1 + 5
+
+        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
+        buf[1] = '.';
+        buf += 1 + static_cast<size_t>(k);
+    }
+
+    *buf++ = 'e';
+    return append_exponent(buf, n - 1);
+}
+
+} // namespace dtoa_impl
+
+/*!
+@brief generates a decimal representation of the floating-point number value in [first, last).
+
+The format of the resulting decimal representation is similar to printf's %g
+format. Returns an iterator pointing past-the-end of the decimal representation.
+
+@note The input number must be finite, i.e. NaN's and Inf's are not supported.
+@note The buffer must be large enough.
+@note The result is NOT null-terminated.
+*/
+template<typename FloatType>
+JSON_HEDLEY_NON_NULL(1, 2)
+JSON_HEDLEY_RETURNS_NON_NULL
+char* to_chars(char* first, const char* last, FloatType value)
+{
+    static_cast<void>(last); // maybe unused - fix warning
+    JSON_ASSERT(std::isfinite(value));
+
+    // Use signbit(value) instead of (value < 0) since signbit works for -0.
+    if (std::signbit(value))
+    {
+        value = -value;
+        *first++ = '-';
+    }
+
+    if (value == 0) // +-0
+    {
+        *first++ = '0';
+        // Make it look like a floating-point number (#362, #378)
+        *first++ = '.';
+        *first++ = '0';
+        return first;
+    }
+
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
+
+    // Compute v = buffer * 10^decimal_exponent.
+    // The decimal digits are stored in the buffer, which needs to be interpreted
+    // as an unsigned decimal integer.
+    // len is the length of the buffer, i.e. the number of decimal digits.
+    int len = 0;
+    int decimal_exponent = 0;
+    dtoa_impl::grisu2(first, len, decimal_exponent, value);
+
+    JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
+
+    // Format the buffer like printf("%.*g", prec, value)
+    constexpr int kMinExp = -4;
+    // Use digits10 here to increase compatibility with version 2.
+    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
+
+    JSON_ASSERT(last - first >= kMaxExp + 2);
+    JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
+
+    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
+}
+
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////
+// serialization //
+///////////////////
+
+/// how to treat decoding errors
+enum class error_handler_t
+{
+    strict,  ///< throw a type_error exception in case of invalid UTF-8
+    replace, ///< replace invalid UTF-8 sequences with U+FFFD
+    ignore   ///< ignore invalid UTF-8 sequences
+};
+
+template<typename BasicJsonType>
+class serializer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using binary_char_t = typename BasicJsonType::binary_t::value_type;
+    static constexpr std::uint8_t UTF8_ACCEPT = 0;
+    static constexpr std::uint8_t UTF8_REJECT = 1;
+
+  public:
+    /*!
+    @param[in] s  output stream to serialize to
+    @param[in] ichar  indentation character to use
+    @param[in] error_handler_  how to react on decoding errors
+    */
+    serializer(output_adapter_t<char> s, const char ichar,
+               error_handler_t error_handler_ = error_handler_t::strict)
+        : o(std::move(s))
+        , loc(std::localeconv())
+        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
+        , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
+        , indent_char(ichar)
+        , indent_string(512, indent_char)
+        , error_handler(error_handler_)
+    {}
+
+    // delete because of pointer members
+    serializer(const serializer&) = delete;
+    serializer& operator=(const serializer&) = delete;
+    serializer(serializer&&) = delete;
+    serializer& operator=(serializer&&) = delete;
+    ~serializer() = default;
+
+    /*!
+    @brief internal implementation of the serialization function
+
+    This function is called by the public member function dump and organizes
+    the serialization internally. The indentation level is propagated as
+    additional parameter. In case of arrays and objects, the function is
+    called recursively.
+
+    - strings and object keys are escaped using `escape_string()`
+    - integer numbers are converted implicitly via `operator<<`
+    - floating-point numbers are converted to a string using `"%g"` format
+    - binary values are serialized as objects containing the subtype and the
+      byte array
+
+    @param[in] val               value to serialize
+    @param[in] pretty_print      whether the output shall be pretty-printed
+    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
+    in the output are escaped with `\uXXXX` sequences, and the result consists
+    of ASCII characters only.
+    @param[in] indent_step       the indent level
+    @param[in] current_indent    the current indent level (only used internally)
+    */
+    void dump(const BasicJsonType& val,
+              const bool pretty_print,
+              const bool ensure_ascii,
+              const unsigned int indent_step,
+              const unsigned int current_indent = 0)
+    {
+        switch (val.m_type)
+        {
+            case value_t::object:
+            {
+                if (val.m_value.object->empty())
+                {
+                    o->write_characters("{}", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    auto i = val.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\": ", 3);
+                        dump(i->second, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    JSON_ASSERT(i != val.m_value.object->cend());
+                    JSON_ASSERT(std::next(i) == val.m_value.object->cend());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\": ", 3);
+                    dump(i->second, true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_character('{');
+
+                    // first n-1 elements
+                    auto i = val.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\":", 2);
+                        dump(i->second, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    JSON_ASSERT(i != val.m_value.object->cend());
+                    JSON_ASSERT(std::next(i) == val.m_value.object->cend());
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\":", 2);
+                    dump(i->second, false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character('}');
+                }
+
+                return;
+            }
+
+            case value_t::array:
+            {
+                if (val.m_value.array->empty())
+                {
+                    o->write_characters("[]", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("[\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    for (auto i = val.m_value.array->cbegin();
+                            i != val.m_value.array->cend() - 1; ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        dump(*i, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    JSON_ASSERT(!val.m_value.array->empty());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character(']');
+                }
+                else
+                {
+                    o->write_character('[');
+
+                    // first n-1 elements
+                    for (auto i = val.m_value.array->cbegin();
+                            i != val.m_value.array->cend() - 1; ++i)
+                    {
+                        dump(*i, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    JSON_ASSERT(!val.m_value.array->empty());
+                    dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character(']');
+                }
+
+                return;
+            }
+
+            case value_t::string:
+            {
+                o->write_character('\"');
+                dump_escaped(*val.m_value.string, ensure_ascii);
+                o->write_character('\"');
+                return;
+            }
+
+            case value_t::binary:
+            {
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    o->write_characters(indent_string.c_str(), new_indent);
+
+                    o->write_characters("\"bytes\": [", 10);
+
+                    if (!val.m_value.binary->empty())
+                    {
+                        for (auto i = val.m_value.binary->cbegin();
+                                i != val.m_value.binary->cend() - 1; ++i)
+                        {
+                            dump_integer(*i);
+                            o->write_characters(", ", 2);
+                        }
+                        dump_integer(val.m_value.binary->back());
+                    }
+
+                    o->write_characters("],\n", 3);
+                    o->write_characters(indent_string.c_str(), new_indent);
+
+                    o->write_characters("\"subtype\": ", 11);
+                    if (val.m_value.binary->has_subtype())
+                    {
+                        dump_integer(val.m_value.binary->subtype());
+                    }
+                    else
+                    {
+                        o->write_characters("null", 4);
+                    }
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_characters("{\"bytes\":[", 10);
+
+                    if (!val.m_value.binary->empty())
+                    {
+                        for (auto i = val.m_value.binary->cbegin();
+                                i != val.m_value.binary->cend() - 1; ++i)
+                        {
+                            dump_integer(*i);
+                            o->write_character(',');
+                        }
+                        dump_integer(val.m_value.binary->back());
+                    }
+
+                    o->write_characters("],\"subtype\":", 12);
+                    if (val.m_value.binary->has_subtype())
+                    {
+                        dump_integer(val.m_value.binary->subtype());
+                        o->write_character('}');
+                    }
+                    else
+                    {
+                        o->write_characters("null}", 5);
+                    }
+                }
+                return;
+            }
+
+            case value_t::boolean:
+            {
+                if (val.m_value.boolean)
+                {
+                    o->write_characters("true", 4);
+                }
+                else
+                {
+                    o->write_characters("false", 5);
+                }
+                return;
+            }
+
+            case value_t::number_integer:
+            {
+                dump_integer(val.m_value.number_integer);
+                return;
+            }
+
+            case value_t::number_unsigned:
+            {
+                dump_integer(val.m_value.number_unsigned);
+                return;
+            }
+
+            case value_t::number_float:
+            {
+                dump_float(val.m_value.number_float);
+                return;
+            }
+
+            case value_t::discarded:
+            {
+                o->write_characters("<discarded>", 11);
+                return;
+            }
+
+            case value_t::null:
+            {
+                o->write_characters("null", 4);
+                return;
+            }
+
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false);  // LCOV_EXCL_LINE
+        }
+    }
+
+  private:
+    /*!
+    @brief dump escaped string
+
+    Escape a string by replacing certain special characters by a sequence of an
+    escape character (backslash) and another character and other control
+    characters by a sequence of "\u" followed by a four-digit hex
+    representation. The escaped string is written to output stream @a o.
+
+    @param[in] s  the string to escape
+    @param[in] ensure_ascii  whether to escape non-ASCII characters with
+                             \uXXXX sequences
+
+    @complexity Linear in the length of string @a s.
+    */
+    void dump_escaped(const string_t& s, const bool ensure_ascii)
+    {
+        std::uint32_t codepoint;
+        std::uint8_t state = UTF8_ACCEPT;
+        std::size_t bytes = 0;  // number of bytes written to string_buffer
+
+        // number of bytes written at the point of the last valid byte
+        std::size_t bytes_after_last_accept = 0;
+        std::size_t undumped_chars = 0;
+
+        for (std::size_t i = 0; i < s.size(); ++i)
+        {
+            const auto byte = static_cast<uint8_t>(s[i]);
+
+            switch (decode(state, codepoint, byte))
+            {
+                case UTF8_ACCEPT:  // decode found a new code point
+                {
+                    switch (codepoint)
+                    {
+                        case 0x08: // backspace
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'b';
+                            break;
+                        }
+
+                        case 0x09: // horizontal tab
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 't';
+                            break;
+                        }
+
+                        case 0x0A: // newline
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'n';
+                            break;
+                        }
+
+                        case 0x0C: // formfeed
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'f';
+                            break;
+                        }
+
+                        case 0x0D: // carriage return
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'r';
+                            break;
+                        }
+
+                        case 0x22: // quotation mark
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\"';
+                            break;
+                        }
+
+                        case 0x5C: // reverse solidus
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\\';
+                            break;
+                        }
+
+                        default:
+                        {
+                            // escape control characters (0x00..0x1F) or, if
+                            // ensure_ascii parameter is used, non-ASCII characters
+                            if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
+                            {
+                                if (codepoint <= 0xFFFF)
+                                {
+                                    (std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
+                                                    static_cast<std::uint16_t>(codepoint));
+                                    bytes += 6;
+                                }
+                                else
+                                {
+                                    (std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
+                                                    static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
+                                                    static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu)));
+                                    bytes += 12;
+                                }
+                            }
+                            else
+                            {
+                                // copy byte to buffer (all previous bytes
+                                // been copied have in default case above)
+                                string_buffer[bytes++] = s[i];
+                            }
+                            break;
+                        }
+                    }
+
+                    // write buffer and reset index; there must be 13 bytes
+                    // left, as this is the maximal number of bytes to be
+                    // written ("\uxxxx\uxxxx\0") for one code point
+                    if (string_buffer.size() - bytes < 13)
+                    {
+                        o->write_characters(string_buffer.data(), bytes);
+                        bytes = 0;
+                    }
+
+                    // remember the byte position of this accept
+                    bytes_after_last_accept = bytes;
+                    undumped_chars = 0;
+                    break;
+                }
+
+                case UTF8_REJECT:  // decode found invalid UTF-8 byte
+                {
+                    switch (error_handler)
+                    {
+                        case error_handler_t::strict:
+                        {
+                            std::string sn(3, '\0');
+                            (std::snprintf)(&sn[0], sn.size(), "%.2X", byte);
+                            JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + sn));
+                        }
+
+                        case error_handler_t::ignore:
+                        case error_handler_t::replace:
+                        {
+                            // in case we saw this character the first time, we
+                            // would like to read it again, because the byte
+                            // may be OK for itself, but just not OK for the
+                            // previous sequence
+                            if (undumped_chars > 0)
+                            {
+                                --i;
+                            }
+
+                            // reset length buffer to the last accepted index;
+                            // thus removing/ignoring the invalid characters
+                            bytes = bytes_after_last_accept;
+
+                            if (error_handler == error_handler_t::replace)
+                            {
+                                // add a replacement character
+                                if (ensure_ascii)
+                                {
+                                    string_buffer[bytes++] = '\\';
+                                    string_buffer[bytes++] = 'u';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'd';
+                                }
+                                else
+                                {
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
+                                }
+
+                                // write buffer and reset index; there must be 13 bytes
+                                // left, as this is the maximal number of bytes to be
+                                // written ("\uxxxx\uxxxx\0") for one code point
+                                if (string_buffer.size() - bytes < 13)
+                                {
+                                    o->write_characters(string_buffer.data(), bytes);
+                                    bytes = 0;
+                                }
+
+                                bytes_after_last_accept = bytes;
+                            }
+
+                            undumped_chars = 0;
+
+                            // continue processing the string
+                            state = UTF8_ACCEPT;
+                            break;
+                        }
+
+                        default:            // LCOV_EXCL_LINE
+                            JSON_ASSERT(false);  // LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+
+                default:  // decode found yet incomplete multi-byte code point
+                {
+                    if (!ensure_ascii)
+                    {
+                        // code point will not be escaped - copy byte to buffer
+                        string_buffer[bytes++] = s[i];
+                    }
+                    ++undumped_chars;
+                    break;
+                }
+            }
+        }
+
+        // we finished processing the string
+        if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
+        {
+            // write buffer
+            if (bytes > 0)
+            {
+                o->write_characters(string_buffer.data(), bytes);
+            }
+        }
+        else
+        {
+            // we finish reading, but do not accept: string was incomplete
+            switch (error_handler)
+            {
+                case error_handler_t::strict:
+                {
+                    std::string sn(3, '\0');
+                    (std::snprintf)(&sn[0], sn.size(), "%.2X", static_cast<std::uint8_t>(s.back()));
+                    JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + sn));
+                }
+
+                case error_handler_t::ignore:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    break;
+                }
+
+                case error_handler_t::replace:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    // add a replacement character
+                    if (ensure_ascii)
+                    {
+                        o->write_characters("\\ufffd", 6);
+                    }
+                    else
+                    {
+                        o->write_characters("\xEF\xBF\xBD", 3);
+                    }
+                    break;
+                }
+
+                default:            // LCOV_EXCL_LINE
+                    JSON_ASSERT(false);  // LCOV_EXCL_LINE
+            }
+        }
+    }
+
+    /*!
+    @brief count digits
+
+    Count the number of decimal (base 10) digits for an input unsigned integer.
+
+    @param[in] x  unsigned integer number to count its digits
+    @return    number of decimal digits
+    */
+    inline unsigned int count_digits(number_unsigned_t x) noexcept
+    {
+        unsigned int n_digits = 1;
+        for (;;)
+        {
+            if (x < 10)
+            {
+                return n_digits;
+            }
+            if (x < 100)
+            {
+                return n_digits + 1;
+            }
+            if (x < 1000)
+            {
+                return n_digits + 2;
+            }
+            if (x < 10000)
+            {
+                return n_digits + 3;
+            }
+            x = x / 10000u;
+            n_digits += 4;
+        }
+    }
+
+    /*!
+    @brief dump an integer
+
+    Dump a given integer to output stream @a o. Works internally with
+    @a number_buffer.
+
+    @param[in] x  integer number (signed or unsigned) to dump
+    @tparam NumberType either @a number_integer_t or @a number_unsigned_t
+    */
+    template < typename NumberType, detail::enable_if_t <
+                   std::is_same<NumberType, number_unsigned_t>::value ||
+                   std::is_same<NumberType, number_integer_t>::value ||
+                   std::is_same<NumberType, binary_char_t>::value,
+                   int > = 0 >
+    void dump_integer(NumberType x)
+    {
+        static constexpr std::array<std::array<char, 2>, 100> digits_to_99
+        {
+            {
+                {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
+                {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
+                {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
+                {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
+                {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
+                {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
+                {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
+                {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
+                {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
+                {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
+            }
+        };
+
+        // special case for "0"
+        if (x == 0)
+        {
+            o->write_character('0');
+            return;
+        }
+
+        // use a pointer to fill the buffer
+        auto buffer_ptr = number_buffer.begin();
+
+        const bool is_negative = std::is_same<NumberType, number_integer_t>::value && !(x >= 0); // see issue #755
+        number_unsigned_t abs_value;
+
+        unsigned int n_chars;
+
+        if (is_negative)
+        {
+            *buffer_ptr = '-';
+            abs_value = remove_sign(static_cast<number_integer_t>(x));
+
+            // account one more byte for the minus sign
+            n_chars = 1 + count_digits(abs_value);
+        }
+        else
+        {
+            abs_value = static_cast<number_unsigned_t>(x);
+            n_chars = count_digits(abs_value);
+        }
+
+        // spare 1 byte for '\0'
+        JSON_ASSERT(n_chars < number_buffer.size() - 1);
+
+        // jump to the end to generate the string from backward
+        // so we later avoid reversing the result
+        buffer_ptr += n_chars;
+
+        // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
+        // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
+        while (abs_value >= 100)
+        {
+            const auto digits_index = static_cast<unsigned>((abs_value % 100));
+            abs_value /= 100;
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+
+        if (abs_value >= 10)
+        {
+            const auto digits_index = static_cast<unsigned>(abs_value);
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+        else
+        {
+            *(--buffer_ptr) = static_cast<char>('0' + abs_value);
+        }
+
+        o->write_characters(number_buffer.data(), n_chars);
+    }
+
+    /*!
+    @brief dump a floating-point number
+
+    Dump a given floating-point number to output stream @a o. Works internally
+    with @a number_buffer.
+
+    @param[in] x  floating-point number to dump
+    */
+    void dump_float(number_float_t x)
+    {
+        // NaN / inf
+        if (!std::isfinite(x))
+        {
+            o->write_characters("null", 4);
+            return;
+        }
+
+        // If number_float_t is an IEEE-754 single or double precision number,
+        // use the Grisu2 algorithm to produce short numbers which are
+        // guaranteed to round-trip, using strtof and strtod, resp.
+        //
+        // NB: The test below works if <long double> == <double>.
+        static constexpr bool is_ieee_single_or_double
+            = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
+              (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
+
+        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
+    }
+
+    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
+    {
+        char* begin = number_buffer.data();
+        char* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
+
+        o->write_characters(begin, static_cast<size_t>(end - begin));
+    }
+
+    void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
+    {
+        // get number of digits for a float -> text -> float round-trip
+        static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
+
+        // the actual conversion
+        std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
+
+        // negative value indicates an error
+        JSON_ASSERT(len > 0);
+        // check if buffer was large enough
+        JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
+
+        // erase thousands separator
+        if (thousands_sep != '\0')
+        {
+            const auto end = std::remove(number_buffer.begin(),
+                                         number_buffer.begin() + len, thousands_sep);
+            std::fill(end, number_buffer.end(), '\0');
+            JSON_ASSERT((end - number_buffer.begin()) <= len);
+            len = (end - number_buffer.begin());
+        }
+
+        // convert decimal point to '.'
+        if (decimal_point != '\0' && decimal_point != '.')
+        {
+            const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
+            if (dec_pos != number_buffer.end())
+            {
+                *dec_pos = '.';
+            }
+        }
+
+        o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
+
+        // determine if need to append ".0"
+        const bool value_is_int_like =
+            std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
+                         [](char c)
+        {
+            return c == '.' || c == 'e';
+        });
+
+        if (value_is_int_like)
+        {
+            o->write_characters(".0", 2);
+        }
+    }
+
+    /*!
+    @brief check whether a string is UTF-8 encoded
+
+    The function checks each byte of a string whether it is UTF-8 encoded. The
+    result of the check is stored in the @a state parameter. The function must
+    be called initially with state 0 (accept). State 1 means the string must
+    be rejected, because the current byte is not allowed. If the string is
+    completely processed, but the state is non-zero, the string ended
+    prematurely; that is, the last byte indicated more bytes should have
+    followed.
+
+    @param[in,out] state  the state of the decoding
+    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
+    @param[in] byte       next byte to decode
+    @return               new state
+
+    @note The function has been edited: a std::array is used.
+
+    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
+    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+    */
+    static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
+    {
+        static const std::array<std::uint8_t, 400> utf8d =
+        {
+            {
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
+                7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
+                8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
+                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
+                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
+                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
+                1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
+                1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
+                1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
+            }
+        };
+
+        const std::uint8_t type = utf8d[byte];
+
+        codep = (state != UTF8_ACCEPT)
+                ? (byte & 0x3fu) | (codep << 6u)
+                : (0xFFu >> type) & (byte);
+
+        std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
+        JSON_ASSERT(index < 400);
+        state = utf8d[index];
+        return state;
+    }
+
+    /*
+     * Overload to make the compiler happy while it is instantiating
+     * dump_integer for number_unsigned_t.
+     * Must never be called.
+     */
+    number_unsigned_t remove_sign(number_unsigned_t x)
+    {
+        JSON_ASSERT(false); // LCOV_EXCL_LINE
+        return x; // LCOV_EXCL_LINE
+    }
+
+    /*
+     * Helper function for dump_integer
+     *
+     * This function takes a negative signed integer and returns its absolute
+     * value as unsigned integer. The plus/minus shuffling is necessary as we can
+     * not directly remove the sign of an arbitrary signed integer as the
+     * absolute values of INT_MIN and INT_MAX are usually not the same. See
+     * #1708 for details.
+     */
+    inline number_unsigned_t remove_sign(number_integer_t x) noexcept
+    {
+        JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)());
+        return static_cast<number_unsigned_t>(-(x + 1)) + 1;
+    }
+
+  private:
+    /// the output of the serializer
+    output_adapter_t<char> o = nullptr;
+
+    /// a (hopefully) large enough character buffer
+    std::array<char, 64> number_buffer{{}};
+
+    /// the locale
+    const std::lconv* loc = nullptr;
+    /// the locale's thousand separator character
+    const char thousands_sep = '\0';
+    /// the locale's decimal point character
+    const char decimal_point = '\0';
+
+    /// string buffer
+    std::array<char, 512> string_buffer{{}};
+
+    /// the indentation character
+    const char indent_char;
+    /// the indentation string
+    string_t indent_string;
+
+    /// error_handler how to react on decoding errors
+    const error_handler_t error_handler;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/value_t.hpp>
+
+// #include <nlohmann/json_fwd.hpp>
+
+// #include <nlohmann/ordered_map.hpp>
+
+
+#include <functional> // less
+#include <memory> // allocator
+#include <utility> // pair
+#include <vector> // vector
+
+namespace nlohmann
+{
+
+/// ordered_map: a minimal map-like container that preserves insertion order
+/// for use within nlohmann::basic_json<ordered_map>
+template <class Key, class T, class IgnoredLess = std::less<Key>,
+          class Allocator = std::allocator<std::pair<const Key, T>>>
+                  struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
+{
+    using key_type = Key;
+    using mapped_type = T;
+    using Container = std::vector<std::pair<const Key, T>, Allocator>;
+    using typename Container::iterator;
+    using typename Container::const_iterator;
+    using typename Container::size_type;
+    using typename Container::value_type;
+
+    // Explicit constructors instead of `using Container::Container`
+    // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
+    ordered_map(const Allocator& alloc = Allocator()) : Container{alloc} {}
+    template <class It>
+    ordered_map(It first, It last, const Allocator& alloc = Allocator())
+        : Container{first, last, alloc} {}
+    ordered_map(std::initializer_list<T> init, const Allocator& alloc = Allocator() )
+        : Container{init, alloc} {}
+
+    std::pair<iterator, bool> emplace(const key_type& key, T&& t)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return {it, false};
+            }
+        }
+        Container::emplace_back(key, t);
+        return {--this->end(), true};
+    }
+
+    T& operator[](const Key& key)
+    {
+        return emplace(key, T{}).first->second;
+    }
+
+    const T& operator[](const Key& key) const
+    {
+        return at(key);
+    }
+
+    T& at(const Key& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return it->second;
+            }
+        }
+
+        throw std::out_of_range("key not found");
+    }
+
+    const T& at(const Key& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return it->second;
+            }
+        }
+
+        throw std::out_of_range("key not found");
+    }
+
+    size_type erase(const Key& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                // Since we cannot move const Keys, re-construct them in place
+                for (auto next = it; ++next != this->end(); ++it)
+                {
+                    it->~value_type(); // Destroy but keep allocation
+                    new (&*it) value_type{std::move(*next)};
+                }
+                Container::pop_back();
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    iterator erase(iterator pos)
+    {
+        auto it = pos;
+
+        // Since we cannot move const Keys, re-construct them in place
+        for (auto next = it; ++next != this->end(); ++it)
+        {
+            it->~value_type(); // Destroy but keep allocation
+            new (&*it) value_type{std::move(*next)};
+        }
+        Container::pop_back();
+        return pos;
+    }
+
+    size_type count(const Key& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    iterator find(const Key& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    const_iterator find(const Key& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == key)
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    std::pair<iterator, bool> insert( value_type&& value )
+    {
+        return emplace(value.first, std::move(value.second));
+    }
+
+    std::pair<iterator, bool> insert( const value_type& value )
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (it->first == value.first)
+            {
+                return {it, false};
+            }
+        }
+        Container::push_back(value);
+        return {--this->end(), true};
+    }
+};
+
+}  // namespace nlohmann
+
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+namespace nlohmann
+{
+
+/*!
+@brief a class to store JSON values
+
+@tparam ObjectType type for JSON objects (`std::map` by default; will be used
+in @ref object_t)
+@tparam ArrayType type for JSON arrays (`std::vector` by default; will be used
+in @ref array_t)
+@tparam StringType type for JSON strings and object keys (`std::string` by
+default; will be used in @ref string_t)
+@tparam BooleanType type for JSON booleans (`bool` by default; will be used
+in @ref boolean_t)
+@tparam NumberIntegerType type for JSON integer numbers (`int64_t` by
+default; will be used in @ref number_integer_t)
+@tparam NumberUnsignedType type for JSON unsigned integer numbers (@c
+`uint64_t` by default; will be used in @ref number_unsigned_t)
+@tparam NumberFloatType type for JSON floating-point numbers (`double` by
+default; will be used in @ref number_float_t)
+@tparam BinaryType type for packed binary data for compatibility with binary
+serialization formats (`std::vector<std::uint8_t>` by default; will be used in
+@ref binary_t)
+@tparam AllocatorType type of the allocator to use (`std::allocator` by
+default)
+@tparam JSONSerializer the serializer to resolve internal calls to `to_json()`
+and `from_json()` (@ref adl_serializer by default)
+
+@requirement The class satisfies the following concept requirements:
+- Basic
+ - [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible):
+   JSON values can be default constructed. The result will be a JSON null
+   value.
+ - [MoveConstructible](https://en.cppreference.com/w/cpp/named_req/MoveConstructible):
+   A JSON value can be constructed from an rvalue argument.
+ - [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible):
+   A JSON value can be copy-constructed from an lvalue expression.
+ - [MoveAssignable](https://en.cppreference.com/w/cpp/named_req/MoveAssignable):
+   A JSON value van be assigned from an rvalue argument.
+ - [CopyAssignable](https://en.cppreference.com/w/cpp/named_req/CopyAssignable):
+   A JSON value can be copy-assigned from an lvalue expression.
+ - [Destructible](https://en.cppreference.com/w/cpp/named_req/Destructible):
+   JSON values can be destructed.
+- Layout
+ - [StandardLayoutType](https://en.cppreference.com/w/cpp/named_req/StandardLayoutType):
+   JSON values have
+   [standard layout](https://en.cppreference.com/w/cpp/language/data_members#Standard_layout):
+   All non-static data members are private and standard layout types, the
+   class has no virtual functions or (virtual) base classes.
+- Library-wide
+ - [EqualityComparable](https://en.cppreference.com/w/cpp/named_req/EqualityComparable):
+   JSON values can be compared with `==`, see @ref
+   operator==(const_reference,const_reference).
+ - [LessThanComparable](https://en.cppreference.com/w/cpp/named_req/LessThanComparable):
+   JSON values can be compared with `<`, see @ref
+   operator<(const_reference,const_reference).
+ - [Swappable](https://en.cppreference.com/w/cpp/named_req/Swappable):
+   Any JSON lvalue or rvalue of can be swapped with any lvalue or rvalue of
+   other compatible types, using unqualified function call @ref swap().
+ - [NullablePointer](https://en.cppreference.com/w/cpp/named_req/NullablePointer):
+   JSON values can be compared against `std::nullptr_t` objects which are used
+   to model the `null` value.
+- Container
+ - [Container](https://en.cppreference.com/w/cpp/named_req/Container):
+   JSON values can be used like STL containers and provide iterator access.
+ - [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer);
+   JSON values can be used like STL containers and provide reverse iterator
+   access.
+
+@invariant The member variables @a m_value and @a m_type have the following
+relationship:
+- If `m_type == value_t::object`, then `m_value.object != nullptr`.
+- If `m_type == value_t::array`, then `m_value.array != nullptr`.
+- If `m_type == value_t::string`, then `m_value.string != nullptr`.
+The invariants are checked by member function assert_invariant().
+
+@internal
+@note ObjectType trick from https://stackoverflow.com/a/9860911
+@endinternal
+
+@see [RFC 7159: The JavaScript Object Notation (JSON) Data Interchange
+Format](http://rfc7159.net/rfc7159)
+
+@since version 1.0.0
+
+@nosubgrouping
+*/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+class basic_json
+{
+  private:
+    template<detail::value_t> friend struct detail::external_constructor;
+    friend ::nlohmann::json_pointer<basic_json>;
+
+    template<typename BasicJsonType, typename InputType>
+    friend class ::nlohmann::detail::parser;
+    friend ::nlohmann::detail::serializer<basic_json>;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::iter_impl;
+    template<typename BasicJsonType, typename CharType>
+    friend class ::nlohmann::detail::binary_writer;
+    template<typename BasicJsonType, typename InputType, typename SAX>
+    friend class ::nlohmann::detail::binary_reader;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::json_sax_dom_parser;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::json_sax_dom_callback_parser;
+
+    /// workaround type for MSVC
+    using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
+
+    // convenience aliases for types residing in namespace detail;
+    using lexer = ::nlohmann::detail::lexer_base<basic_json>;
+
+    template<typename InputAdapterType>
+    static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
+        InputAdapterType adapter,
+        detail::parser_callback_t<basic_json>cb = nullptr,
+        const bool allow_exceptions = true,
+        const bool ignore_comments = false
+                                 )
+    {
+        return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
+                std::move(cb), allow_exceptions, ignore_comments);
+    }
+
+    using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
+    template<typename BasicJsonType>
+    using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
+    template<typename BasicJsonType>
+    using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
+    template<typename Iterator>
+    using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
+    template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
+
+    template<typename CharType>
+    using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
+
+    template<typename InputType>
+    using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
+    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
+
+    using serializer = ::nlohmann::detail::serializer<basic_json>;
+
+  public:
+    using value_t = detail::value_t;
+    /// JSON Pointer, see @ref nlohmann::json_pointer
+    using json_pointer = ::nlohmann::json_pointer<basic_json>;
+    template<typename T, typename SFINAE>
+    using json_serializer = JSONSerializer<T, SFINAE>;
+    /// how to treat decoding errors
+    using error_handler_t = detail::error_handler_t;
+    /// how to treat CBOR tags
+    using cbor_tag_handler_t = detail::cbor_tag_handler_t;
+    /// helper type for initializer lists of basic_json values
+    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
+
+    using input_format_t = detail::input_format_t;
+    /// SAX interface type, see @ref nlohmann::json_sax
+    using json_sax_t = json_sax<basic_json>;
+
+    ////////////////
+    // exceptions //
+    ////////////////
+
+    /// @name exceptions
+    /// Classes to implement user-defined exceptions.
+    /// @{
+
+    /// @copydoc detail::exception
+    using exception = detail::exception;
+    /// @copydoc detail::parse_error
+    using parse_error = detail::parse_error;
+    /// @copydoc detail::invalid_iterator
+    using invalid_iterator = detail::invalid_iterator;
+    /// @copydoc detail::type_error
+    using type_error = detail::type_error;
+    /// @copydoc detail::out_of_range
+    using out_of_range = detail::out_of_range;
+    /// @copydoc detail::other_error
+    using other_error = detail::other_error;
+
+    /// @}
+
+
+    /////////////////////
+    // container types //
+    /////////////////////
+
+    /// @name container types
+    /// The canonic container types to use @ref basic_json like any other STL
+    /// container.
+    /// @{
+
+    /// the type of elements in a basic_json container
+    using value_type = basic_json;
+
+    /// the type of an element reference
+    using reference = value_type&;
+    /// the type of an element const reference
+    using const_reference = const value_type&;
+
+    /// a type to represent differences between iterators
+    using difference_type = std::ptrdiff_t;
+    /// a type to represent container sizes
+    using size_type = std::size_t;
+
+    /// the allocator type
+    using allocator_type = AllocatorType<basic_json>;
+
+    /// the type of an element pointer
+    using pointer = typename std::allocator_traits<allocator_type>::pointer;
+    /// the type of an element const pointer
+    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
+
+    /// an iterator for a basic_json container
+    using iterator = iter_impl<basic_json>;
+    /// a const iterator for a basic_json container
+    using const_iterator = iter_impl<const basic_json>;
+    /// a reverse iterator for a basic_json container
+    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
+    /// a const reverse iterator for a basic_json container
+    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
+
+    /// @}
+
+
+    /*!
+    @brief returns the allocator associated with the container
+    */
+    static allocator_type get_allocator()
+    {
+        return allocator_type();
+    }
+
+    /*!
+    @brief returns version information on the library
+
+    This function returns a JSON object with information about the library,
+    including the version number and information on the platform and compiler.
+
+    @return JSON object holding version information
+    key         | description
+    ----------- | ---------------
+    `compiler`  | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version).
+    `copyright` | The copyright line for the library as string.
+    `name`      | The name of the library as string.
+    `platform`  | The used platform as string. Possible values are `win32`, `linux`, `apple`, `unix`, and `unknown`.
+    `url`       | The URL of the project as string.
+    `version`   | The version of the library. It is an object with the following keys: `major`, `minor`, and `patch` as defined by [Semantic Versioning](http://semver.org), and `string` (the version string).
+
+    @liveexample{The following code shows an example output of the `meta()`
+    function.,meta}
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @complexity Constant.
+
+    @since 2.1.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json meta()
+    {
+        basic_json result;
+
+        result["copyright"] = "(C) 2013-2020 Niels Lohmann";
+        result["name"] = "JSON for Modern C++";
+        result["url"] = "https://github.com/nlohmann/json";
+        result["version"]["string"] =
+            std::to_string(NLOHMANN_JSON_VERSION_MAJOR) + "." +
+            std::to_string(NLOHMANN_JSON_VERSION_MINOR) + "." +
+            std::to_string(NLOHMANN_JSON_VERSION_PATCH);
+        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
+        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
+        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
+
+#ifdef _WIN32
+        result["platform"] = "win32";
+#elif defined __linux__
+        result["platform"] = "linux";
+#elif defined __APPLE__
+        result["platform"] = "apple";
+#elif defined __unix__
+        result["platform"] = "unix";
+#else
+        result["platform"] = "unknown";
+#endif
+
+#if defined(__ICC) || defined(__INTEL_COMPILER)
+        result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
+#elif defined(__clang__)
+        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
+#elif defined(__GNUC__) || defined(__GNUG__)
+        result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};
+#elif defined(__HP_cc) || defined(__HP_aCC)
+        result["compiler"] = "hp"
+#elif defined(__IBMCPP__)
+        result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
+#elif defined(_MSC_VER)
+        result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
+#elif defined(__PGI)
+        result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
+#elif defined(__SUNPRO_CC)
+        result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
+#else
+        result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
+#endif
+
+#ifdef __cplusplus
+        result["compiler"]["c++"] = std::to_string(__cplusplus);
+#else
+        result["compiler"]["c++"] = "unknown";
+#endif
+        return result;
+    }
+
+
+    ///////////////////////////
+    // JSON value data types //
+    ///////////////////////////
+
+    /// @name JSON value data types
+    /// The data types to store a JSON value. These types are derived from
+    /// the template arguments passed to class @ref basic_json.
+    /// @{
+
+#if defined(JSON_HAS_CPP_14)
+    // Use transparent comparator if possible, combined with perfect forwarding
+    // on find() and count() calls prevents unnecessary string construction.
+    using object_comparator_t = std::less<>;
+#else
+    using object_comparator_t = std::less<StringType>;
+#endif
+
+    /*!
+    @brief a type for an object
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON objects as follows:
+    > An object is an unordered collection of zero or more name/value pairs,
+    > where a name is a string and a value is a string, number, boolean, null,
+    > object, or array.
+
+    To store objects in C++, a type is defined by the template parameters
+    described below.
+
+    @tparam ObjectType  the container to store objects (e.g., `std::map` or
+    `std::unordered_map`)
+    @tparam StringType the type of the keys or names (e.g., `std::string`).
+    The comparison function `std::less<StringType>` is used to order elements
+    inside the container.
+    @tparam AllocatorType the allocator to use for objects (e.g.,
+    `std::allocator`)
+
+    #### Default type
+
+    With the default values for @a ObjectType (`std::map`), @a StringType
+    (`std::string`), and @a AllocatorType (`std::allocator`), the default
+    value for @a object_t is:
+
+    @code {.cpp}
+    std::map<
+      std::string, // key_type
+      basic_json, // value_type
+      std::less<std::string>, // key_compare
+      std::allocator<std::pair<const std::string, basic_json>> // allocator_type
+    >
+    @endcode
+
+    #### Behavior
+
+    The choice of @a object_t influences the behavior of the JSON class. With
+    the default type, objects have the following behavior:
+
+    - When all names are unique, objects will be interoperable in the sense
+      that all software implementations receiving that object will agree on
+      the name-value mappings.
+    - When the names within an object are not unique, it is unspecified which
+      one of the values for a given key will be chosen. For instance,
+      `{"key": 2, "key": 1}` could be equal to either `{"key": 1}` or
+      `{"key": 2}`.
+    - Internally, name/value pairs are stored in lexicographical order of the
+      names. Objects will also be serialized (see @ref dump) in this order.
+      For instance, `{"b": 1, "a": 2}` and `{"a": 2, "b": 1}` will be stored
+      and serialized as `{"a": 2, "b": 1}`.
+    - When comparing objects, the order of the name/value pairs is irrelevant.
+      This makes objects interoperable in the sense that they will not be
+      affected by these differences. For instance, `{"b": 1, "a": 2}` and
+      `{"a": 2, "b": 1}` will be treated as equal.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the maximum depth of nesting.
+
+    In this class, the object's limit of nesting is not explicitly constrained.
+    However, a maximum depth of nesting may be introduced by the compiler or
+    runtime environment. A theoretical limit can be queried by calling the
+    @ref max_size function of a JSON object.
+
+    #### Storage
+
+    Objects are stored as pointers in a @ref basic_json type. That is, for any
+    access to object values, a pointer of type `object_t*` must be
+    dereferenced.
+
+    @sa @ref array_t -- type for an array value
+
+    @since version 1.0.0
+
+    @note The order name/value pairs are added to the object is *not*
+    preserved by the library. Therefore, iterating an object may return
+    name/value pairs in a different order than they were originally stored. In
+    fact, keys will be traversed in alphabetical order as `std::map` with
+    `std::less` is used by default. Please note this behavior conforms to [RFC
+    7159](http://rfc7159.net/rfc7159), because any order implements the
+    specified "unordered" nature of JSON objects.
+    */
+    using object_t = ObjectType<StringType,
+          basic_json,
+          object_comparator_t,
+          AllocatorType<std::pair<const StringType,
+          basic_json>>>;
+
+    /*!
+    @brief a type for an array
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON arrays as follows:
+    > An array is an ordered sequence of zero or more values.
+
+    To store objects in C++, a type is defined by the template parameters
+    explained below.
+
+    @tparam ArrayType  container type to store arrays (e.g., `std::vector` or
+    `std::list`)
+    @tparam AllocatorType allocator to use for arrays (e.g., `std::allocator`)
+
+    #### Default type
+
+    With the default values for @a ArrayType (`std::vector`) and @a
+    AllocatorType (`std::allocator`), the default value for @a array_t is:
+
+    @code {.cpp}
+    std::vector<
+      basic_json, // value_type
+      std::allocator<basic_json> // allocator_type
+    >
+    @endcode
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the maximum depth of nesting.
+
+    In this class, the array's limit of nesting is not explicitly constrained.
+    However, a maximum depth of nesting may be introduced by the compiler or
+    runtime environment. A theoretical limit can be queried by calling the
+    @ref max_size function of a JSON array.
+
+    #### Storage
+
+    Arrays are stored as pointers in a @ref basic_json type. That is, for any
+    access to array values, a pointer of type `array_t*` must be dereferenced.
+
+    @sa @ref object_t -- type for an object value
+
+    @since version 1.0.0
+    */
+    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
+
+    /*!
+    @brief a type for a string
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON strings as follows:
+    > A string is a sequence of zero or more Unicode characters.
+
+    To store objects in C++, a type is defined by the template parameter
+    described below. Unicode values are split by the JSON class into
+    byte-sized characters during deserialization.
+
+    @tparam StringType  the container to store strings (e.g., `std::string`).
+    Note this container is used for keys/names in objects, see @ref object_t.
+
+    #### Default type
+
+    With the default values for @a StringType (`std::string`), the default
+    value for @a string_t is:
+
+    @code {.cpp}
+    std::string
+    @endcode
+
+    #### Encoding
+
+    Strings are stored in UTF-8 encoding. Therefore, functions like
+    `std::string::size()` or `std::string::length()` return the number of
+    bytes in the string rather than the number of characters or glyphs.
+
+    #### String comparison
+
+    [RFC 7159](http://rfc7159.net/rfc7159) states:
+    > Software implementations are typically required to test names of object
+    > members for equality. Implementations that transform the textual
+    > representation into sequences of Unicode code units and then perform the
+    > comparison numerically, code unit by code unit, are interoperable in the
+    > sense that implementations will agree in all cases on equality or
+    > inequality of two strings. For example, implementations that compare
+    > strings with escaped characters unconverted may incorrectly find that
+    > `"a\\b"` and `"a\u005Cb"` are not equal.
+
+    This implementation is interoperable as it does compare strings code unit
+    by code unit.
+
+    #### Storage
+
+    String values are stored as pointers in a @ref basic_json type. That is,
+    for any access to string values, a pointer of type `string_t*` must be
+    dereferenced.
+
+    @since version 1.0.0
+    */
+    using string_t = StringType;
+
+    /*!
+    @brief a type for a boolean
+
+    [RFC 7159](http://rfc7159.net/rfc7159) implicitly describes a boolean as a
+    type which differentiates the two literals `true` and `false`.
+
+    To store objects in C++, a type is defined by the template parameter @a
+    BooleanType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a BooleanType (`bool`), the default value for
+    @a boolean_t is:
+
+    @code {.cpp}
+    bool
+    @endcode
+
+    #### Storage
+
+    Boolean values are stored directly inside a @ref basic_json type.
+
+    @since version 1.0.0
+    */
+    using boolean_t = BooleanType;
+
+    /*!
+    @brief a type for a number (integer)
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
+    > The representation of numbers is similar to that used in most
+    > programming languages. A number is represented in base 10 using decimal
+    > digits. It contains an integer component that may be prefixed with an
+    > optional minus sign, which may be followed by a fraction part and/or an
+    > exponent part. Leading zeros are not allowed. (...) Numeric values that
+    > cannot be represented in the grammar below (such as Infinity and NaN)
+    > are not permitted.
+
+    This description includes both integer and floating-point numbers.
+    However, C++ allows more precise storage if it is known whether the number
+    is a signed integer, an unsigned integer or a floating-point number.
+    Therefore, three different types, @ref number_integer_t, @ref
+    number_unsigned_t and @ref number_float_t are used.
+
+    To store integer numbers in C++, a type is defined by the template
+    parameter @a NumberIntegerType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a NumberIntegerType (`int64_t`), the default
+    value for @a number_integer_t is:
+
+    @code {.cpp}
+    int64_t
+    @endcode
+
+    #### Default behavior
+
+    - The restrictions about leading zeros is not enforced in C++. Instead,
+      leading zeros in integer literals lead to an interpretation as octal
+      number. Internally, the value will be stored as decimal number. For
+      instance, the C++ integer literal `010` will be serialized to `8`.
+      During deserialization, leading zeros yield an error.
+    - Not-a-number (NaN) values will be serialized to `null`.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the range and precision of numbers.
+
+    When the default type is used, the maximal integer number that can be
+    stored is `9223372036854775807` (INT64_MAX) and the minimal integer number
+    that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers
+    that are out of range will yield over/underflow when used in a
+    constructor. During deserialization, too large or small integer numbers
+    will be automatically be stored as @ref number_unsigned_t or @ref
+    number_float_t.
+
+    [RFC 7159](http://rfc7159.net/rfc7159) further states:
+    > Note that when such software is used, numbers that are integers and are
+    > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
+    > that implementations will agree exactly on their numeric values.
+
+    As this range is a subrange of the exactly supported range [INT64_MIN,
+    INT64_MAX], this class's integer type is interoperable.
+
+    #### Storage
+
+    Integer number values are stored directly inside a @ref basic_json type.
+
+    @sa @ref number_float_t -- type for number values (floating-point)
+
+    @sa @ref number_unsigned_t -- type for number values (unsigned integer)
+
+    @since version 1.0.0
+    */
+    using number_integer_t = NumberIntegerType;
+
+    /*!
+    @brief a type for a number (unsigned)
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
+    > The representation of numbers is similar to that used in most
+    > programming languages. A number is represented in base 10 using decimal
+    > digits. It contains an integer component that may be prefixed with an
+    > optional minus sign, which may be followed by a fraction part and/or an
+    > exponent part. Leading zeros are not allowed. (...) Numeric values that
+    > cannot be represented in the grammar below (such as Infinity and NaN)
+    > are not permitted.
+
+    This description includes both integer and floating-point numbers.
+    However, C++ allows more precise storage if it is known whether the number
+    is a signed integer, an unsigned integer or a floating-point number.
+    Therefore, three different types, @ref number_integer_t, @ref
+    number_unsigned_t and @ref number_float_t are used.
+
+    To store unsigned integer numbers in C++, a type is defined by the
+    template parameter @a NumberUnsignedType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a NumberUnsignedType (`uint64_t`), the
+    default value for @a number_unsigned_t is:
+
+    @code {.cpp}
+    uint64_t
+    @endcode
+
+    #### Default behavior
+
+    - The restrictions about leading zeros is not enforced in C++. Instead,
+      leading zeros in integer literals lead to an interpretation as octal
+      number. Internally, the value will be stored as decimal number. For
+      instance, the C++ integer literal `010` will be serialized to `8`.
+      During deserialization, leading zeros yield an error.
+    - Not-a-number (NaN) values will be serialized to `null`.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the range and precision of numbers.
+
+    When the default type is used, the maximal integer number that can be
+    stored is `18446744073709551615` (UINT64_MAX) and the minimal integer
+    number that can be stored is `0`. Integer numbers that are out of range
+    will yield over/underflow when used in a constructor. During
+    deserialization, too large or small integer numbers will be automatically
+    be stored as @ref number_integer_t or @ref number_float_t.
+
+    [RFC 7159](http://rfc7159.net/rfc7159) further states:
+    > Note that when such software is used, numbers that are integers and are
+    > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
+    > that implementations will agree exactly on their numeric values.
+
+    As this range is a subrange (when considered in conjunction with the
+    number_integer_t type) of the exactly supported range [0, UINT64_MAX],
+    this class's integer type is interoperable.
+
+    #### Storage
+
+    Integer number values are stored directly inside a @ref basic_json type.
+
+    @sa @ref number_float_t -- type for number values (floating-point)
+    @sa @ref number_integer_t -- type for number values (integer)
+
+    @since version 2.0.0
+    */
+    using number_unsigned_t = NumberUnsignedType;
+
+    /*!
+    @brief a type for a number (floating-point)
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
+    > The representation of numbers is similar to that used in most
+    > programming languages. A number is represented in base 10 using decimal
+    > digits. It contains an integer component that may be prefixed with an
+    > optional minus sign, which may be followed by a fraction part and/or an
+    > exponent part. Leading zeros are not allowed. (...) Numeric values that
+    > cannot be represented in the grammar below (such as Infinity and NaN)
+    > are not permitted.
+
+    This description includes both integer and floating-point numbers.
+    However, C++ allows more precise storage if it is known whether the number
+    is a signed integer, an unsigned integer or a floating-point number.
+    Therefore, three different types, @ref number_integer_t, @ref
+    number_unsigned_t and @ref number_float_t are used.
+
+    To store floating-point numbers in C++, a type is defined by the template
+    parameter @a NumberFloatType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a NumberFloatType (`double`), the default
+    value for @a number_float_t is:
+
+    @code {.cpp}
+    double
+    @endcode
+
+    #### Default behavior
+
+    - The restrictions about leading zeros is not enforced in C++. Instead,
+      leading zeros in floating-point literals will be ignored. Internally,
+      the value will be stored as decimal number. For instance, the C++
+      floating-point literal `01.2` will be serialized to `1.2`. During
+      deserialization, leading zeros yield an error.
+    - Not-a-number (NaN) values will be serialized to `null`.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) states:
+    > This specification allows implementations to set limits on the range and
+    > precision of numbers accepted. Since software that implements IEEE
+    > 754-2008 binary64 (double precision) numbers is generally available and
+    > widely used, good interoperability can be achieved by implementations
+    > that expect no more precision or range than these provide, in the sense
+    > that implementations will approximate JSON numbers within the expected
+    > precision.
+
+    This implementation does exactly follow this approach, as it uses double
+    precision floating-point numbers. Note values smaller than
+    `-1.79769313486232e+308` and values greater than `1.79769313486232e+308`
+    will be stored as NaN internally and be serialized to `null`.
+
+    #### Storage
+
+    Floating-point number values are stored directly inside a @ref basic_json
+    type.
+
+    @sa @ref number_integer_t -- type for number values (integer)
+
+    @sa @ref number_unsigned_t -- type for number values (unsigned integer)
+
+    @since version 1.0.0
+    */
+    using number_float_t = NumberFloatType;
+
+    /*!
+    @brief a type for a packed binary type
+
+    This type is a type designed to carry binary data that appears in various
+    serialized formats, such as CBOR's Major Type 2, MessagePack's bin, and
+    BSON's generic binary subtype. This type is NOT a part of standard JSON and
+    exists solely for compatibility with these binary types. As such, it is
+    simply defined as an ordered sequence of zero or more byte values.
+
+    Additionally, as an implementation detail, the subtype of the binary data is
+    carried around as a `std::uint8_t`, which is compatible with both of the
+    binary data formats that use binary subtyping, (though the specific
+    numbering is incompatible with each other, and it is up to the user to
+    translate between them).
+
+    [CBOR's RFC 7049](https://tools.ietf.org/html/rfc7049) describes this type
+    as:
+    > Major type 2: a byte string. The string's length in bytes is represented
+    > following the rules for positive integers (major type 0).
+
+    [MessagePack's documentation on the bin type
+    family](https://github.com/msgpack/msgpack/blob/master/spec.md#bin-format-family)
+    describes this type as:
+    > Bin format family stores an byte array in 2, 3, or 5 bytes of extra bytes
+    > in addition to the size of the byte array.
+
+    [BSON's specifications](http://bsonspec.org/spec.html) describe several
+    binary types; however, this type is intended to represent the generic binary
+    type which has the description:
+    > Generic binary subtype - This is the most commonly used binary subtype and
+    > should be the 'default' for drivers and tools.
+
+    None of these impose any limitations on the internal representation other
+    than the basic unit of storage be some type of array whose parts are
+    decomposable into bytes.
+
+    The default representation of this binary format is a
+    `std::vector<std::uint8_t>`, which is a very common way to represent a byte
+    array in modern C++.
+
+    #### Default type
+
+    The default values for @a BinaryType is `std::vector<std::uint8_t>`
+
+    #### Storage
+
+    Binary Arrays are stored as pointers in a @ref basic_json type. That is,
+    for any access to array values, a pointer of the type `binary_t*` must be
+    dereferenced.
+
+    #### Notes on subtypes
+
+    - CBOR
+       - Binary values are represented as byte strings. No subtypes are
+         supported and will be ignored when CBOR is written.
+    - MessagePack
+       - If a subtype is given and the binary array contains exactly 1, 2, 4, 8,
+         or 16 elements, the fixext family (fixext1, fixext2, fixext4, fixext8)
+         is used. For other sizes, the ext family (ext8, ext16, ext32) is used.
+         The subtype is then added as singed 8-bit integer.
+       - If no subtype is given, the bin family (bin8, bin16, bin32) is used.
+    - BSON
+       - If a subtype is given, it is used and added as unsigned 8-bit integer.
+       - If no subtype is given, the generic binary subtype 0x00 is used.
+
+    @sa @ref binary -- create a binary array
+
+    @since version 3.8.0
+    */
+    using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
+    /// @}
+
+  private:
+
+    /// helper for exception-safe object creation
+    template<typename T, typename... Args>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    static T* create(Args&& ... args)
+    {
+        AllocatorType<T> alloc;
+        using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
+
+        auto deleter = [&](T * object)
+        {
+            AllocatorTraits::deallocate(alloc, object, 1);
+        };
+        std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
+        AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
+        JSON_ASSERT(object != nullptr);
+        return object.release();
+    }
+
+    ////////////////////////
+    // JSON value storage //
+    ////////////////////////
+
+    /*!
+    @brief a JSON value
+
+    The actual storage for a JSON value of the @ref basic_json class. This
+    union combines the different storage types for the JSON value types
+    defined in @ref value_t.
+
+    JSON type | value_t type    | used type
+    --------- | --------------- | ------------------------
+    object    | object          | pointer to @ref object_t
+    array     | array           | pointer to @ref array_t
+    string    | string          | pointer to @ref string_t
+    boolean   | boolean         | @ref boolean_t
+    number    | number_integer  | @ref number_integer_t
+    number    | number_unsigned | @ref number_unsigned_t
+    number    | number_float    | @ref number_float_t
+    binary    | binary          | pointer to @ref binary_t
+    null      | null            | *no value is stored*
+
+    @note Variable-length types (objects, arrays, and strings) are stored as
+    pointers. The size of the union should not exceed 64 bits if the default
+    value types are used.
+
+    @since version 1.0.0
+    */
+    union json_value
+    {
+        /// object (stored with pointer to save storage)
+        object_t* object;
+        /// array (stored with pointer to save storage)
+        array_t* array;
+        /// string (stored with pointer to save storage)
+        string_t* string;
+        /// binary (stored with pointer to save storage)
+        binary_t* binary;
+        /// boolean
+        boolean_t boolean;
+        /// number (integer)
+        number_integer_t number_integer;
+        /// number (unsigned integer)
+        number_unsigned_t number_unsigned;
+        /// number (floating-point)
+        number_float_t number_float;
+
+        /// default constructor (for null values)
+        json_value() = default;
+        /// constructor for booleans
+        json_value(boolean_t v) noexcept : boolean(v) {}
+        /// constructor for numbers (integer)
+        json_value(number_integer_t v) noexcept : number_integer(v) {}
+        /// constructor for numbers (unsigned)
+        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
+        /// constructor for numbers (floating-point)
+        json_value(number_float_t v) noexcept : number_float(v) {}
+        /// constructor for empty values of a given type
+        json_value(value_t t)
+        {
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    object = create<object_t>();
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    array = create<array_t>();
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    string = create<string_t>("");
+                    break;
+                }
+
+                case value_t::binary:
+                {
+                    binary = create<binary_t>();
+                    break;
+                }
+
+                case value_t::boolean:
+                {
+                    boolean = boolean_t(false);
+                    break;
+                }
+
+                case value_t::number_integer:
+                {
+                    number_integer = number_integer_t(0);
+                    break;
+                }
+
+                case value_t::number_unsigned:
+                {
+                    number_unsigned = number_unsigned_t(0);
+                    break;
+                }
+
+                case value_t::number_float:
+                {
+                    number_float = number_float_t(0.0);
+                    break;
+                }
+
+                case value_t::null:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    break;
+                }
+
+                default:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
+                    {
+                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.9.1")); // LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+            }
+        }
+
+        /// constructor for strings
+        json_value(const string_t& value)
+        {
+            string = create<string_t>(value);
+        }
+
+        /// constructor for rvalue strings
+        json_value(string_t&& value)
+        {
+            string = create<string_t>(std::move(value));
+        }
+
+        /// constructor for objects
+        json_value(const object_t& value)
+        {
+            object = create<object_t>(value);
+        }
+
+        /// constructor for rvalue objects
+        json_value(object_t&& value)
+        {
+            object = create<object_t>(std::move(value));
+        }
+
+        /// constructor for arrays
+        json_value(const array_t& value)
+        {
+            array = create<array_t>(value);
+        }
+
+        /// constructor for rvalue arrays
+        json_value(array_t&& value)
+        {
+            array = create<array_t>(std::move(value));
+        }
+
+        /// constructor for binary arrays
+        json_value(const typename binary_t::container_type& value)
+        {
+            binary = create<binary_t>(value);
+        }
+
+        /// constructor for rvalue binary arrays
+        json_value(typename binary_t::container_type&& value)
+        {
+            binary = create<binary_t>(std::move(value));
+        }
+
+        /// constructor for binary arrays (internal type)
+        json_value(const binary_t& value)
+        {
+            binary = create<binary_t>(value);
+        }
+
+        /// constructor for rvalue binary arrays (internal type)
+        json_value(binary_t&& value)
+        {
+            binary = create<binary_t>(std::move(value));
+        }
+
+        void destroy(value_t t) noexcept
+        {
+            // flatten the current json_value to a heap-allocated stack
+            std::vector<basic_json> stack;
+
+            // move the top-level items to stack
+            if (t == value_t::array)
+            {
+                stack.reserve(array->size());
+                std::move(array->begin(), array->end(), std::back_inserter(stack));
+            }
+            else if (t == value_t::object)
+            {
+                stack.reserve(object->size());
+                for (auto&& it : *object)
+                {
+                    stack.push_back(std::move(it.second));
+                }
+            }
+
+            while (!stack.empty())
+            {
+                // move the last item to local variable to be processed
+                basic_json current_item(std::move(stack.back()));
+                stack.pop_back();
+
+                // if current_item is array/object, move
+                // its children to the stack to be processed later
+                if (current_item.is_array())
+                {
+                    std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(),
+                              std::back_inserter(stack));
+
+                    current_item.m_value.array->clear();
+                }
+                else if (current_item.is_object())
+                {
+                    for (auto&& it : *current_item.m_value.object)
+                    {
+                        stack.push_back(std::move(it.second));
+                    }
+
+                    current_item.m_value.object->clear();
+                }
+
+                // it's now safe that current_item get destructed
+                // since it doesn't have any children
+            }
+
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    AllocatorType<object_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    AllocatorType<array_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
+                    break;
+                }
+
+                case value_t::binary:
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
+                    break;
+                }
+
+                default:
+                {
+                    break;
+                }
+            }
+        }
+    };
+
+    /*!
+    @brief checks the class invariants
+
+    This function asserts the class invariants. It needs to be called at the
+    end of every constructor to make sure that created objects respect the
+    invariant. Furthermore, it has to be called each time the type of a JSON
+    value is changed, because the invariant expresses a relationship between
+    @a m_type and @a m_value.
+    */
+    void assert_invariant() const noexcept
+    {
+        JSON_ASSERT(m_type != value_t::object || m_value.object != nullptr);
+        JSON_ASSERT(m_type != value_t::array || m_value.array != nullptr);
+        JSON_ASSERT(m_type != value_t::string || m_value.string != nullptr);
+        JSON_ASSERT(m_type != value_t::binary || m_value.binary != nullptr);
+    }
+
+  public:
+    //////////////////////////
+    // JSON parser callback //
+    //////////////////////////
+
+    /*!
+    @brief parser event types
+
+    The parser callback distinguishes the following events:
+    - `object_start`: the parser read `{` and started to process a JSON object
+    - `key`: the parser read a key of a value in an object
+    - `object_end`: the parser read `}` and finished processing a JSON object
+    - `array_start`: the parser read `[` and started to process a JSON array
+    - `array_end`: the parser read `]` and finished processing a JSON array
+    - `value`: the parser finished reading a JSON value
+
+    @image html callback_events.png "Example when certain parse events are triggered"
+
+    @sa @ref parser_callback_t for more information and examples
+    */
+    using parse_event_t = detail::parse_event_t;
+
+    /*!
+    @brief per-element parser callback type
+
+    With a parser callback function, the result of parsing a JSON text can be
+    influenced. When passed to @ref parse, it is called on certain events
+    (passed as @ref parse_event_t via parameter @a event) with a set recursion
+    depth @a depth and context JSON value @a parsed. The return value of the
+    callback function is a boolean indicating whether the element that emitted
+    the callback shall be kept or not.
+
+    We distinguish six scenarios (determined by the event type) in which the
+    callback function can be called. The following table describes the values
+    of the parameters @a depth, @a event, and @a parsed.
+
+    parameter @a event | description | parameter @a depth | parameter @a parsed
+    ------------------ | ----------- | ------------------ | -------------------
+    parse_event_t::object_start | the parser read `{` and started to process a JSON object | depth of the parent of the JSON object | a JSON value with type discarded
+    parse_event_t::key | the parser read a key of a value in an object | depth of the currently parsed JSON object | a JSON string containing the key
+    parse_event_t::object_end | the parser read `}` and finished processing a JSON object | depth of the parent of the JSON object | the parsed JSON object
+    parse_event_t::array_start | the parser read `[` and started to process a JSON array | depth of the parent of the JSON array | a JSON value with type discarded
+    parse_event_t::array_end | the parser read `]` and finished processing a JSON array | depth of the parent of the JSON array | the parsed JSON array
+    parse_event_t::value | the parser finished reading a JSON value | depth of the value | the parsed JSON value
+
+    @image html callback_events.png "Example when certain parse events are triggered"
+
+    Discarding a value (i.e., returning `false`) has different effects
+    depending on the context in which function was called:
+
+    - Discarded values in structured types are skipped. That is, the parser
+      will behave as if the discarded value was never read.
+    - In case a value outside a structured type is skipped, it is replaced
+      with `null`. This case happens if the top-level element is skipped.
+
+    @param[in] depth  the depth of the recursion during parsing
+
+    @param[in] event  an event of type parse_event_t indicating the context in
+    the callback function has been called
+
+    @param[in,out] parsed  the current intermediate parse result; note that
+    writing to this value has no effect for parse_event_t::key events
+
+    @return Whether the JSON value which called the function during parsing
+    should be kept (`true`) or not (`false`). In the latter case, it is either
+    skipped completely or replaced by an empty discarded object.
+
+    @sa @ref parse for examples
+
+    @since version 1.0.0
+    */
+    using parser_callback_t = detail::parser_callback_t<basic_json>;
+
+    //////////////////
+    // constructors //
+    //////////////////
+
+    /// @name constructors and destructors
+    /// Constructors of class @ref basic_json, copy/move constructor, copy
+    /// assignment, static functions creating objects, and the destructor.
+    /// @{
+
+    /*!
+    @brief create an empty value with a given type
+
+    Create an empty JSON value with a given type. The value will be default
+    initialized with an empty value which depends on the type:
+
+    Value type  | initial value
+    ----------- | -------------
+    null        | `null`
+    boolean     | `false`
+    string      | `""`
+    number      | `0`
+    object      | `{}`
+    array       | `[]`
+    binary      | empty array
+
+    @param[in] v  the type of the value to create
+
+    @complexity Constant.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The following code shows the constructor for different @ref
+    value_t values,basic_json__value_t}
+
+    @sa @ref clear() -- restores the postcondition of this constructor
+
+    @since version 1.0.0
+    */
+    basic_json(const value_t v)
+        : m_type(v), m_value(v)
+    {
+        assert_invariant();
+    }
+
+    /*!
+    @brief create a null object
+
+    Create a `null` JSON value. It either takes a null pointer as parameter
+    (explicitly creating `null`) or no parameter (implicitly creating `null`).
+    The passed null pointer itself is not read -- it is only used to choose
+    the right constructor.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this constructor never throws
+    exceptions.
+
+    @liveexample{The following code shows the constructor with and without a
+    null pointer parameter.,basic_json__nullptr_t}
+
+    @since version 1.0.0
+    */
+    basic_json(std::nullptr_t = nullptr) noexcept
+        : basic_json(value_t::null)
+    {
+        assert_invariant();
+    }
+
+    /*!
+    @brief create a JSON value
+
+    This is a "catch all" constructor for all compatible JSON types; that is,
+    types for which a `to_json()` method exists. The constructor forwards the
+    parameter @a val to that method (to `json_serializer<U>::to_json` method
+    with `U = uncvref_t<CompatibleType>`, to be exact).
+
+    Template type @a CompatibleType includes, but is not limited to, the
+    following types:
+    - **arrays**: @ref array_t and all kinds of compatible containers such as
+      `std::vector`, `std::deque`, `std::list`, `std::forward_list`,
+      `std::array`, `std::valarray`, `std::set`, `std::unordered_set`,
+      `std::multiset`, and `std::unordered_multiset` with a `value_type` from
+      which a @ref basic_json value can be constructed.
+    - **objects**: @ref object_t and all kinds of compatible associative
+      containers such as `std::map`, `std::unordered_map`, `std::multimap`,
+      and `std::unordered_multimap` with a `key_type` compatible to
+      @ref string_t and a `value_type` from which a @ref basic_json value can
+      be constructed.
+    - **strings**: @ref string_t, string literals, and all compatible string
+      containers can be used.
+    - **numbers**: @ref number_integer_t, @ref number_unsigned_t,
+      @ref number_float_t, and all convertible number types such as `int`,
+      `size_t`, `int64_t`, `float` or `double` can be used.
+    - **boolean**: @ref boolean_t / `bool` can be used.
+    - **binary**: @ref binary_t / `std::vector<uint8_t>` may be used,
+      unfortunately because string literals cannot be distinguished from binary
+      character arrays by the C++ type system, all types compatible with `const
+      char*` will be directed to the string constructor instead.  This is both
+      for backwards compatibility, and due to the fact that a binary type is not
+      a standard JSON type.
+
+    See the examples below.
+
+    @tparam CompatibleType a type such that:
+    - @a CompatibleType is not derived from `std::istream`,
+    - @a CompatibleType is not @ref basic_json (to avoid hijacking copy/move
+         constructors),
+    - @a CompatibleType is not a different @ref basic_json type (i.e. with different template arguments)
+    - @a CompatibleType is not a @ref basic_json nested type (e.g.,
+         @ref json_pointer, @ref iterator, etc ...)
+    - @ref @ref json_serializer<U> has a
+         `to_json(basic_json_t&, CompatibleType&&)` method
+
+    @tparam U = `uncvref_t<CompatibleType>`
+
+    @param[in] val the value to be forwarded to the respective constructor
+
+    @complexity Usually linear in the size of the passed @a val, also
+                depending on the implementation of the called `to_json()`
+                method.
+
+    @exceptionsafety Depends on the called constructor. For types directly
+    supported by the library (i.e., all types for which no `to_json()` function
+    was provided), strong guarantee holds: if an exception is thrown, there are
+    no changes to any JSON value.
+
+    @liveexample{The following code shows the constructor with several
+    compatible types.,basic_json__CompatibleType}
+
+    @since version 2.1.0
+    */
+    template < typename CompatibleType,
+               typename U = detail::uncvref_t<CompatibleType>,
+               detail::enable_if_t <
+                   !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
+    basic_json(CompatibleType && val) noexcept(noexcept(
+                JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
+                                           std::forward<CompatibleType>(val))))
+    {
+        JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
+        assert_invariant();
+    }
+
+    /*!
+    @brief create a JSON value from an existing one
+
+    This is a constructor for existing @ref basic_json types.
+    It does not hijack copy/move constructors, since the parameter has different
+    template arguments than the current ones.
+
+    The constructor tries to convert the internal @ref m_value of the parameter.
+
+    @tparam BasicJsonType a type such that:
+    - @a BasicJsonType is a @ref basic_json type.
+    - @a BasicJsonType has different template arguments than @ref basic_json_t.
+
+    @param[in] val the @ref basic_json value to be converted.
+
+    @complexity Usually linear in the size of the passed @a val, also
+                depending on the implementation of the called `to_json()`
+                method.
+
+    @exceptionsafety Depends on the called constructor. For types directly
+    supported by the library (i.e., all types for which no `to_json()` function
+    was provided), strong guarantee holds: if an exception is thrown, there are
+    no changes to any JSON value.
+
+    @since version 3.2.0
+    */
+    template < typename BasicJsonType,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
+    basic_json(const BasicJsonType& val)
+    {
+        using other_boolean_t = typename BasicJsonType::boolean_t;
+        using other_number_float_t = typename BasicJsonType::number_float_t;
+        using other_number_integer_t = typename BasicJsonType::number_integer_t;
+        using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+        using other_string_t = typename BasicJsonType::string_t;
+        using other_object_t = typename BasicJsonType::object_t;
+        using other_array_t = typename BasicJsonType::array_t;
+        using other_binary_t = typename BasicJsonType::binary_t;
+
+        switch (val.type())
+        {
+            case value_t::boolean:
+                JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
+                break;
+            case value_t::number_float:
+                JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
+                break;
+            case value_t::number_integer:
+                JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
+                break;
+            case value_t::number_unsigned:
+                JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
+                break;
+            case value_t::string:
+                JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
+                break;
+            case value_t::object:
+                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
+                break;
+            case value_t::array:
+                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
+                break;
+            case value_t::binary:
+                JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
+                break;
+            case value_t::null:
+                *this = nullptr;
+                break;
+            case value_t::discarded:
+                m_type = value_t::discarded;
+                break;
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false);  // LCOV_EXCL_LINE
+        }
+        assert_invariant();
+    }
+
+    /*!
+    @brief create a container (array or object) from an initializer list
+
+    Creates a JSON value of type array or object from the passed initializer
+    list @a init. In case @a type_deduction is `true` (default), the type of
+    the JSON value to be created is deducted from the initializer list @a init
+    according to the following rules:
+
+    1. If the list is empty, an empty JSON object value `{}` is created.
+    2. If the list consists of pairs whose first element is a string, a JSON
+       object value is created where the first elements of the pairs are
+       treated as keys and the second elements are as values.
+    3. In all other cases, an array is created.
+
+    The rules aim to create the best fit between a C++ initializer list and
+    JSON values. The rationale is as follows:
+
+    1. The empty initializer list is written as `{}` which is exactly an empty
+       JSON object.
+    2. C++ has no way of describing mapped types other than to list a list of
+       pairs. As JSON requires that keys must be of type string, rule 2 is the
+       weakest constraint one can pose on initializer lists to interpret them
+       as an object.
+    3. In all other cases, the initializer list could not be interpreted as
+       JSON object type, so interpreting it as JSON array type is safe.
+
+    With the rules described above, the following JSON values cannot be
+    expressed by an initializer list:
+
+    - the empty array (`[]`): use @ref array(initializer_list_t)
+      with an empty initializer list in this case
+    - arrays whose elements satisfy rule 2: use @ref
+      array(initializer_list_t) with the same initializer list
+      in this case
+
+    @note When used without parentheses around an empty initializer list, @ref
+    basic_json() is called instead of this function, yielding the JSON null
+    value.
+
+    @param[in] init  initializer list with JSON values
+
+    @param[in] type_deduction internal parameter; when set to `true`, the type
+    of the JSON value is deducted from the initializer list @a init; when set
+    to `false`, the type provided via @a manual_type is forced. This mode is
+    used by the functions @ref array(initializer_list_t) and
+    @ref object(initializer_list_t).
+
+    @param[in] manual_type internal parameter; when @a type_deduction is set
+    to `false`, the created JSON value will use the provided type (only @ref
+    value_t::array and @ref value_t::object are valid); when @a type_deduction
+    is set to `true`, this parameter has no effect
+
+    @throw type_error.301 if @a type_deduction is `false`, @a manual_type is
+    `value_t::object`, but @a init contains an element which is not a pair
+    whose first element is a string. In this case, the constructor could not
+    create an object. If @a type_deduction would have be `true`, an array
+    would have been created. See @ref object(initializer_list_t)
+    for an example.
+
+    @complexity Linear in the size of the initializer list @a init.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The example below shows how JSON values are created from
+    initializer lists.,basic_json__list_init_t}
+
+    @sa @ref array(initializer_list_t) -- create a JSON array
+    value from an initializer list
+    @sa @ref object(initializer_list_t) -- create a JSON object
+    value from an initializer list
+
+    @since version 1.0.0
+    */
+    basic_json(initializer_list_t init,
+               bool type_deduction = true,
+               value_t manual_type = value_t::array)
+    {
+        // check if each element is an array with two elements whose first
+        // element is a string
+        bool is_an_object = std::all_of(init.begin(), init.end(),
+                                        [](const detail::json_ref<basic_json>& element_ref)
+        {
+            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
+        });
+
+        // adjust type if type deduction is not wanted
+        if (!type_deduction)
+        {
+            // if array is wanted, do not create an object though possible
+            if (manual_type == value_t::array)
+            {
+                is_an_object = false;
+            }
+
+            // if object is wanted but impossible, throw an exception
+            if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
+            {
+                JSON_THROW(type_error::create(301, "cannot create object from initializer list"));
+            }
+        }
+
+        if (is_an_object)
+        {
+            // the initializer list is a list of pairs -> create object
+            m_type = value_t::object;
+            m_value = value_t::object;
+
+            std::for_each(init.begin(), init.end(), [this](const detail::json_ref<basic_json>& element_ref)
+            {
+                auto element = element_ref.moved_or_copied();
+                m_value.object->emplace(
+                    std::move(*((*element.m_value.array)[0].m_value.string)),
+                    std::move((*element.m_value.array)[1]));
+            });
+        }
+        else
+        {
+            // the initializer list describes an array -> create array
+            m_type = value_t::array;
+            m_value.array = create<array_t>(init.begin(), init.end());
+        }
+
+        assert_invariant();
+    }
+
+    /*!
+    @brief explicitly create a binary array (without subtype)
+
+    Creates a JSON binary array value from a given binary container. Binary
+    values are part of various binary formats, such as CBOR, MessagePack, and
+    BSON. This constructor is used to create a value for serialization to those
+    formats.
+
+    @note Note, this function exists because of the difficulty in correctly
+    specifying the correct template overload in the standard value ctor, as both
+    JSON arrays and JSON binary arrays are backed with some form of a
+    `std::vector`. Because JSON binary arrays are a non-standard extension it
+    was decided that it would be best to prevent automatic initialization of a
+    binary array type, for backwards compatibility and so it does not happen on
+    accident.
+
+    @param[in] init container containing bytes to use as binary type
+
+    @return JSON binary array value
+
+    @complexity Linear in the size of @a init.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @since version 3.8.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(const typename binary_t::container_type& init)
+    {
+        auto res = basic_json();
+        res.m_type = value_t::binary;
+        res.m_value = init;
+        return res;
+    }
+
+    /*!
+    @brief explicitly create a binary array (with subtype)
+
+    Creates a JSON binary array value from a given binary container. Binary
+    values are part of various binary formats, such as CBOR, MessagePack, and
+    BSON. This constructor is used to create a value for serialization to those
+    formats.
+
+    @note Note, this function exists because of the difficulty in correctly
+    specifying the correct template overload in the standard value ctor, as both
+    JSON arrays and JSON binary arrays are backed with some form of a
+    `std::vector`. Because JSON binary arrays are a non-standard extension it
+    was decided that it would be best to prevent automatic initialization of a
+    binary array type, for backwards compatibility and so it does not happen on
+    accident.
+
+    @param[in] init container containing bytes to use as binary type
+    @param[in] subtype subtype to use in MessagePack and BSON
+
+    @return JSON binary array value
+
+    @complexity Linear in the size of @a init.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @since version 3.8.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(const typename binary_t::container_type& init, std::uint8_t subtype)
+    {
+        auto res = basic_json();
+        res.m_type = value_t::binary;
+        res.m_value = binary_t(init, subtype);
+        return res;
+    }
+
+    /// @copydoc binary(const typename binary_t::container_type&)
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(typename binary_t::container_type&& init)
+    {
+        auto res = basic_json();
+        res.m_type = value_t::binary;
+        res.m_value = std::move(init);
+        return res;
+    }
+
+    /// @copydoc binary(const typename binary_t::container_type&, std::uint8_t)
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(typename binary_t::container_type&& init, std::uint8_t subtype)
+    {
+        auto res = basic_json();
+        res.m_type = value_t::binary;
+        res.m_value = binary_t(std::move(init), subtype);
+        return res;
+    }
+
+    /*!
+    @brief explicitly create an array from an initializer list
+
+    Creates a JSON array value from a given initializer list. That is, given a
+    list of values `a, b, c`, creates the JSON value `[a, b, c]`. If the
+    initializer list is empty, the empty array `[]` is created.
+
+    @note This function is only needed to express two edge cases that cannot
+    be realized with the initializer list constructor (@ref
+    basic_json(initializer_list_t, bool, value_t)). These cases
+    are:
+    1. creating an array whose elements are all pairs whose first element is a
+    string -- in this case, the initializer list constructor would create an
+    object, taking the first elements as keys
+    2. creating an empty array -- passing the empty initializer list to the
+    initializer list constructor yields an empty object
+
+    @param[in] init  initializer list with JSON values to create an array from
+    (optional)
+
+    @return JSON array value
+
+    @complexity Linear in the size of @a init.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The following code shows an example for the `array`
+    function.,array}
+
+    @sa @ref basic_json(initializer_list_t, bool, value_t) --
+    create a JSON value from an initializer list
+    @sa @ref object(initializer_list_t) -- create a JSON object
+    value from an initializer list
+
+    @since version 1.0.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json array(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::array);
+    }
+
+    /*!
+    @brief explicitly create an object from an initializer list
+
+    Creates a JSON object value from a given initializer list. The initializer
+    lists elements must be pairs, and their first elements must be strings. If
+    the initializer list is empty, the empty object `{}` is created.
+
+    @note This function is only added for symmetry reasons. In contrast to the
+    related function @ref array(initializer_list_t), there are
+    no cases which can only be expressed by this function. That is, any
+    initializer list @a init can also be passed to the initializer list
+    constructor @ref basic_json(initializer_list_t, bool, value_t).
+
+    @param[in] init  initializer list to create an object from (optional)
+
+    @return JSON object value
+
+    @throw type_error.301 if @a init is not a list of pairs whose first
+    elements are strings. In this case, no object can be created. When such a
+    value is passed to @ref basic_json(initializer_list_t, bool, value_t),
+    an array would have been created from the passed initializer list @a init.
+    See example below.
+
+    @complexity Linear in the size of @a init.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The following code shows an example for the `object`
+    function.,object}
+
+    @sa @ref basic_json(initializer_list_t, bool, value_t) --
+    create a JSON value from an initializer list
+    @sa @ref array(initializer_list_t) -- create a JSON array
+    value from an initializer list
+
+    @since version 1.0.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json object(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::object);
+    }
+
+    /*!
+    @brief construct an array with count copies of given value
+
+    Constructs a JSON array value by creating @a cnt copies of a passed value.
+    In case @a cnt is `0`, an empty array is created.
+
+    @param[in] cnt  the number of JSON copies of @a val to create
+    @param[in] val  the JSON value to copy
+
+    @post `std::distance(begin(),end()) == cnt` holds.
+
+    @complexity Linear in @a cnt.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The following code shows examples for the @ref
+    basic_json(size_type\, const basic_json&)
+    constructor.,basic_json__size_type_basic_json}
+
+    @since version 1.0.0
+    */
+    basic_json(size_type cnt, const basic_json& val)
+        : m_type(value_t::array)
+    {
+        m_value.array = create<array_t>(cnt, val);
+        assert_invariant();
+    }
+
+    /*!
+    @brief construct a JSON container given an iterator range
+
+    Constructs the JSON value with the contents of the range `[first, last)`.
+    The semantics depends on the different types a JSON value can have:
+    - In case of a null type, invalid_iterator.206 is thrown.
+    - In case of other primitive types (number, boolean, or string), @a first
+      must be `begin()` and @a last must be `end()`. In this case, the value is
+      copied. Otherwise, invalid_iterator.204 is thrown.
+    - In case of structured types (array, object), the constructor behaves as
+      similar versions for `std::vector` or `std::map`; that is, a JSON array
+      or object is constructed from the values in the range.
+
+    @tparam InputIT an input iterator type (@ref iterator or @ref
+    const_iterator)
+
+    @param[in] first begin of the range to copy from (included)
+    @param[in] last end of the range to copy from (excluded)
+
+    @pre Iterators @a first and @a last must be initialized. **This
+         precondition is enforced with an assertion (see warning).** If
+         assertions are switched off, a violation of this precondition yields
+         undefined behavior.
+
+    @pre Range `[first, last)` is valid. Usually, this precondition cannot be
+         checked efficiently. Only certain edge cases are detected; see the
+         description of the exceptions below. A violation of this precondition
+         yields undefined behavior.
+
+    @warning A precondition is enforced with a runtime assertion that will
+             result in calling `std::abort` if this precondition is not met.
+             Assertions can be disabled by defining `NDEBUG` at compile time.
+             See https://en.cppreference.com/w/cpp/error/assert for more
+             information.
+
+    @throw invalid_iterator.201 if iterators @a first and @a last are not
+    compatible (i.e., do not belong to the same JSON value). In this case,
+    the range `[first, last)` is undefined.
+    @throw invalid_iterator.204 if iterators @a first and @a last belong to a
+    primitive type (number, boolean, or string), but @a first does not point
+    to the first element any more. In this case, the range `[first, last)` is
+    undefined. See example code below.
+    @throw invalid_iterator.206 if iterators @a first and @a last belong to a
+    null value. In this case, the range `[first, last)` is undefined.
+
+    @complexity Linear in distance between @a first and @a last.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The example below shows several ways to create JSON values by
+    specifying a subrange with iterators.,basic_json__InputIt_InputIt}
+
+    @since version 1.0.0
+    */
+    template < class InputIT, typename std::enable_if <
+                   std::is_same<InputIT, typename basic_json_t::iterator>::value ||
+                   std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
+    basic_json(InputIT first, InputIT last)
+    {
+        JSON_ASSERT(first.m_object != nullptr);
+        JSON_ASSERT(last.m_object != nullptr);
+
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible"));
+        }
+
+        // copy type from first iterator
+        m_type = first.m_object->m_type;
+
+        // check if iterator range is complete for primitive values
+        switch (m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            {
+                if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
+                                         || !last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+
+        switch (m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_value.number_integer = first.m_object->m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_value.number_unsigned = first.m_object->m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_value.number_float = first.m_object->m_value.number_float;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_value.boolean = first.m_object->m_value.boolean;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_value = *first.m_object->m_value.string;
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_value.object = create<object_t>(first.m_it.object_iterator,
+                                                  last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_value.array = create<array_t>(first.m_it.array_iterator,
+                                                last.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_value = *first.m_object->m_value.binary;
+                break;
+            }
+
+            default:
+                JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " +
+                                                    std::string(first.m_object->type_name())));
+        }
+
+        assert_invariant();
+    }
+
+
+    ///////////////////////////////////////
+    // other constructors and destructor //
+    ///////////////////////////////////////
+
+    template<typename JsonRef,
+             detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
+                                 std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
+    basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
+
+    /*!
+    @brief copy constructor
+
+    Creates a copy of a given JSON value.
+
+    @param[in] other  the JSON value to copy
+
+    @post `*this == other`
+
+    @complexity Linear in the size of @a other.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is linear.
+    - As postcondition, it holds: `other == basic_json(other)`.
+
+    @liveexample{The following code shows an example for the copy
+    constructor.,basic_json__basic_json}
+
+    @since version 1.0.0
+    */
+    basic_json(const basic_json& other)
+        : m_type(other.m_type)
+    {
+        // check of passed value is valid
+        other.assert_invariant();
+
+        switch (m_type)
+        {
+            case value_t::object:
+            {
+                m_value = *other.m_value.object;
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_value = *other.m_value.array;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_value = *other.m_value.string;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_value = other.m_value.boolean;
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                m_value = other.m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_value = other.m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_value = other.m_value.number_float;
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_value = *other.m_value.binary;
+                break;
+            }
+
+            default:
+                break;
+        }
+
+        assert_invariant();
+    }
+
+    /*!
+    @brief move constructor
+
+    Move constructor. Constructs a JSON value with the contents of the given
+    value @a other using move semantics. It "steals" the resources from @a
+    other and leaves it as JSON null value.
+
+    @param[in,out] other  value to move to this object
+
+    @post `*this` has the same value as @a other before the call.
+    @post @a other is a JSON null value.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this constructor never throws
+    exceptions.
+
+    @requirement This function helps `basic_json` satisfying the
+    [MoveConstructible](https://en.cppreference.com/w/cpp/named_req/MoveConstructible)
+    requirements.
+
+    @liveexample{The code below shows the move constructor explicitly called
+    via std::move.,basic_json__moveconstructor}
+
+    @since version 1.0.0
+    */
+    basic_json(basic_json&& other) noexcept
+        : m_type(std::move(other.m_type)),
+          m_value(std::move(other.m_value))
+    {
+        // check that passed value is valid
+        other.assert_invariant();
+
+        // invalidate payload
+        other.m_type = value_t::null;
+        other.m_value = {};
+
+        assert_invariant();
+    }
+
+    /*!
+    @brief copy assignment
+
+    Copy assignment operator. Copies a JSON value via the "copy and swap"
+    strategy: It is expressed in terms of the copy constructor, destructor,
+    and the `swap()` member function.
+
+    @param[in] other  value to copy from
+
+    @complexity Linear.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is linear.
+
+    @liveexample{The code below shows and example for the copy assignment. It
+    creates a copy of value `a` which is then swapped with `b`. Finally\, the
+    copy of `a` (which is the null value after the swap) is
+    destroyed.,basic_json__copyassignment}
+
+    @since version 1.0.0
+    */
+    basic_json& operator=(basic_json other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        // check that passed value is valid
+        other.assert_invariant();
+
+        using std::swap;
+        swap(m_type, other.m_type);
+        swap(m_value, other.m_value);
+
+        assert_invariant();
+        return *this;
+    }
+
+    /*!
+    @brief destructor
+
+    Destroys the JSON value and frees all allocated memory.
+
+    @complexity Linear.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is linear.
+    - All stored elements are destroyed and all memory is freed.
+
+    @since version 1.0.0
+    */
+    ~basic_json() noexcept
+    {
+        assert_invariant();
+        m_value.destroy(m_type);
+    }
+
+    /// @}
+
+  public:
+    ///////////////////////
+    // object inspection //
+    ///////////////////////
+
+    /// @name object inspection
+    /// Functions to inspect the type of a JSON value.
+    /// @{
+
+    /*!
+    @brief serialization
+
+    Serialization function for JSON values. The function tries to mimic
+    Python's `json.dumps()` function, and currently supports its @a indent
+    and @a ensure_ascii parameters.
+
+    @param[in] indent If indent is nonnegative, then array elements and object
+    members will be pretty-printed with that indent level. An indent level of
+    `0` will only insert newlines. `-1` (the default) selects the most compact
+    representation.
+    @param[in] indent_char The character to use for indentation if @a indent is
+    greater than `0`. The default is ` ` (space).
+    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
+    in the output are escaped with `\uXXXX` sequences, and the result consists
+    of ASCII characters only.
+    @param[in] error_handler  how to react on decoding errors; there are three
+    possible values: `strict` (throws and exception in case a decoding error
+    occurs; default), `replace` (replace invalid UTF-8 sequences with U+FFFD),
+    and `ignore` (ignore invalid UTF-8 sequences during serialization; all
+    bytes are copied to the output unchanged).
+
+    @return string containing the serialization of the JSON value
+
+    @throw type_error.316 if a string stored inside the JSON value is not
+                          UTF-8 encoded and @a error_handler is set to strict
+
+    @note Binary values are serialized as object containing two keys:
+      - "bytes": an array of bytes as integers
+      - "subtype": the subtype as integer or "null" if the binary has no subtype
+
+    @complexity Linear.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @liveexample{The following example shows the effect of different @a indent\,
+    @a indent_char\, and @a ensure_ascii parameters to the result of the
+    serialization.,dump}
+
+    @see https://docs.python.org/2/library/json.html#json.dump
+
+    @since version 1.0.0; indentation character @a indent_char, option
+           @a ensure_ascii and exceptions added in version 3.0.0; error
+           handlers added in version 3.4.0; serialization of binary values added
+           in version 3.8.0.
+    */
+    string_t dump(const int indent = -1,
+                  const char indent_char = ' ',
+                  const bool ensure_ascii = false,
+                  const error_handler_t error_handler = error_handler_t::strict) const
+    {
+        string_t result;
+        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
+
+        if (indent >= 0)
+        {
+            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
+        }
+        else
+        {
+            s.dump(*this, false, ensure_ascii, 0);
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief return the type of the JSON value (explicit)
+
+    Return the type of the JSON value as a value from the @ref value_t
+    enumeration.
+
+    @return the type of the JSON value
+            Value type                | return value
+            ------------------------- | -------------------------
+            null                      | value_t::null
+            boolean                   | value_t::boolean
+            string                    | value_t::string
+            number (integer)          | value_t::number_integer
+            number (unsigned integer) | value_t::number_unsigned
+            number (floating-point)   | value_t::number_float
+            object                    | value_t::object
+            array                     | value_t::array
+            binary                    | value_t::binary
+            discarded                 | value_t::discarded
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `type()` for all JSON
+    types.,type}
+
+    @sa @ref operator value_t() -- return the type of the JSON value (implicit)
+    @sa @ref type_name() -- return the type as string
+
+    @since version 1.0.0
+    */
+    constexpr value_t type() const noexcept
+    {
+        return m_type;
+    }
+
+    /*!
+    @brief return whether type is primitive
+
+    This function returns true if and only if the JSON type is primitive
+    (string, number, boolean, or null).
+
+    @return `true` if type is primitive (string, number, boolean, or null),
+    `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_primitive()` for all JSON
+    types.,is_primitive}
+
+    @sa @ref is_structured() -- returns whether JSON value is structured
+    @sa @ref is_null() -- returns whether JSON value is `null`
+    @sa @ref is_string() -- returns whether JSON value is a string
+    @sa @ref is_boolean() -- returns whether JSON value is a boolean
+    @sa @ref is_number() -- returns whether JSON value is a number
+    @sa @ref is_binary() -- returns whether JSON value is a binary array
+
+    @since version 1.0.0
+    */
+    constexpr bool is_primitive() const noexcept
+    {
+        return is_null() || is_string() || is_boolean() || is_number() || is_binary();
+    }
+
+    /*!
+    @brief return whether type is structured
+
+    This function returns true if and only if the JSON type is structured
+    (array or object).
+
+    @return `true` if type is structured (array or object), `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_structured()` for all JSON
+    types.,is_structured}
+
+    @sa @ref is_primitive() -- returns whether value is primitive
+    @sa @ref is_array() -- returns whether value is an array
+    @sa @ref is_object() -- returns whether value is an object
+
+    @since version 1.0.0
+    */
+    constexpr bool is_structured() const noexcept
+    {
+        return is_array() || is_object();
+    }
+
+    /*!
+    @brief return whether value is null
+
+    This function returns true if and only if the JSON value is null.
+
+    @return `true` if type is null, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_null()` for all JSON
+    types.,is_null}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_null() const noexcept
+    {
+        return m_type == value_t::null;
+    }
+
+    /*!
+    @brief return whether value is a boolean
+
+    This function returns true if and only if the JSON value is a boolean.
+
+    @return `true` if type is boolean, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_boolean()` for all JSON
+    types.,is_boolean}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_boolean() const noexcept
+    {
+        return m_type == value_t::boolean;
+    }
+
+    /*!
+    @brief return whether value is a number
+
+    This function returns true if and only if the JSON value is a number. This
+    includes both integer (signed and unsigned) and floating-point values.
+
+    @return `true` if type is number (regardless whether integer, unsigned
+    integer or floating-type), `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_number()` for all JSON
+    types.,is_number}
+
+    @sa @ref is_number_integer() -- check if value is an integer or unsigned
+    integer number
+    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
+    number
+    @sa @ref is_number_float() -- check if value is a floating-point number
+
+    @since version 1.0.0
+    */
+    constexpr bool is_number() const noexcept
+    {
+        return is_number_integer() || is_number_float();
+    }
+
+    /*!
+    @brief return whether value is an integer number
+
+    This function returns true if and only if the JSON value is a signed or
+    unsigned integer number. This excludes floating-point values.
+
+    @return `true` if type is an integer or unsigned integer number, `false`
+    otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_number_integer()` for all
+    JSON types.,is_number_integer}
+
+    @sa @ref is_number() -- check if value is a number
+    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
+    number
+    @sa @ref is_number_float() -- check if value is a floating-point number
+
+    @since version 1.0.0
+    */
+    constexpr bool is_number_integer() const noexcept
+    {
+        return m_type == value_t::number_integer || m_type == value_t::number_unsigned;
+    }
+
+    /*!
+    @brief return whether value is an unsigned integer number
+
+    This function returns true if and only if the JSON value is an unsigned
+    integer number. This excludes floating-point and signed integer values.
+
+    @return `true` if type is an unsigned integer number, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_number_unsigned()` for all
+    JSON types.,is_number_unsigned}
+
+    @sa @ref is_number() -- check if value is a number
+    @sa @ref is_number_integer() -- check if value is an integer or unsigned
+    integer number
+    @sa @ref is_number_float() -- check if value is a floating-point number
+
+    @since version 2.0.0
+    */
+    constexpr bool is_number_unsigned() const noexcept
+    {
+        return m_type == value_t::number_unsigned;
+    }
+
+    /*!
+    @brief return whether value is a floating-point number
+
+    This function returns true if and only if the JSON value is a
+    floating-point number. This excludes signed and unsigned integer values.
+
+    @return `true` if type is a floating-point number, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_number_float()` for all
+    JSON types.,is_number_float}
+
+    @sa @ref is_number() -- check if value is number
+    @sa @ref is_number_integer() -- check if value is an integer number
+    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
+    number
+
+    @since version 1.0.0
+    */
+    constexpr bool is_number_float() const noexcept
+    {
+        return m_type == value_t::number_float;
+    }
+
+    /*!
+    @brief return whether value is an object
+
+    This function returns true if and only if the JSON value is an object.
+
+    @return `true` if type is object, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_object()` for all JSON
+    types.,is_object}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_object() const noexcept
+    {
+        return m_type == value_t::object;
+    }
+
+    /*!
+    @brief return whether value is an array
+
+    This function returns true if and only if the JSON value is an array.
+
+    @return `true` if type is array, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_array()` for all JSON
+    types.,is_array}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_array() const noexcept
+    {
+        return m_type == value_t::array;
+    }
+
+    /*!
+    @brief return whether value is a string
+
+    This function returns true if and only if the JSON value is a string.
+
+    @return `true` if type is string, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_string()` for all JSON
+    types.,is_string}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_string() const noexcept
+    {
+        return m_type == value_t::string;
+    }
+
+    /*!
+    @brief return whether value is a binary array
+
+    This function returns true if and only if the JSON value is a binary array.
+
+    @return `true` if type is binary array, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_binary()` for all JSON
+    types.,is_binary}
+
+    @since version 3.8.0
+    */
+    constexpr bool is_binary() const noexcept
+    {
+        return m_type == value_t::binary;
+    }
+
+    /*!
+    @brief return whether value is discarded
+
+    This function returns true if and only if the JSON value was discarded
+    during parsing with a callback function (see @ref parser_callback_t).
+
+    @note This function will always be `false` for JSON values after parsing.
+    That is, discarded values can only occur during parsing, but will be
+    removed when inside a structured value or replaced by null in other cases.
+
+    @return `true` if type is discarded, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_discarded()` for all JSON
+    types.,is_discarded}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_discarded() const noexcept
+    {
+        return m_type == value_t::discarded;
+    }
+
+    /*!
+    @brief return the type of the JSON value (implicit)
+
+    Implicitly return the type of the JSON value as a value from the @ref
+    value_t enumeration.
+
+    @return the type of the JSON value
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies the @ref value_t operator for
+    all JSON types.,operator__value_t}
+
+    @sa @ref type() -- return the type of the JSON value (explicit)
+    @sa @ref type_name() -- return the type as string
+
+    @since version 1.0.0
+    */
+    constexpr operator value_t() const noexcept
+    {
+        return m_type;
+    }
+
+    /// @}
+
+  private:
+    //////////////////
+    // value access //
+    //////////////////
+
+    /// get a boolean (explicit)
+    boolean_t get_impl(boolean_t* /*unused*/) const
+    {
+        if (JSON_HEDLEY_LIKELY(is_boolean()))
+        {
+            return m_value.boolean;
+        }
+
+        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name())));
+    }
+
+    /// get a pointer to the value (object)
+    object_t* get_impl_ptr(object_t* /*unused*/) noexcept
+    {
+        return is_object() ? m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (object)
+    constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
+    {
+        return is_object() ? m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    array_t* get_impl_ptr(array_t* /*unused*/) noexcept
+    {
+        return is_array() ? m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
+    {
+        return is_array() ? m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    string_t* get_impl_ptr(string_t* /*unused*/) noexcept
+    {
+        return is_string() ? m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
+    {
+        return is_string() ? m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
+    {
+        return is_boolean() ? &m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
+    {
+        return is_boolean() ? &m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
+    {
+        return is_number_integer() ? &m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
+    {
+        return is_number_integer() ? &m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
+    {
+        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
+    {
+        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
+    {
+        return is_number_float() ? &m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
+    {
+        return is_number_float() ? &m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (binary)
+    binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
+    {
+        return is_binary() ? m_value.binary : nullptr;
+    }
+
+    /// get a pointer to the value (binary)
+    constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
+    {
+        return is_binary() ? m_value.binary : nullptr;
+    }
+
+    /*!
+    @brief helper function to implement get_ref()
+
+    This function helps to implement get_ref() without code duplication for
+    const and non-const overloads
+
+    @tparam ThisType will be deduced as `basic_json` or `const basic_json`
+
+    @throw type_error.303 if ReferenceType does not match underlying value
+    type of the current JSON
+    */
+    template<typename ReferenceType, typename ThisType>
+    static ReferenceType get_ref_impl(ThisType& obj)
+    {
+        // delegate the call to get_ptr<>()
+        auto ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
+
+        if (JSON_HEDLEY_LIKELY(ptr != nullptr))
+        {
+            return *ptr;
+        }
+
+        JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name())));
+    }
+
+  public:
+    /// @name value access
+    /// Direct access to the stored value of a JSON value.
+    /// @{
+
+    /*!
+    @brief get special-case overload
+
+    This overloads avoids a lot of template boilerplate, it can be seen as the
+    identity method
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this
+
+    @complexity Constant.
+
+    @since version 2.1.0
+    */
+    template<typename BasicJsonType, detail::enable_if_t<
+                 std::is_same<typename std::remove_const<BasicJsonType>::type, basic_json_t>::value,
+                 int> = 0>
+    basic_json get() const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get special-case overload
+
+    This overloads converts the current @ref basic_json in a different
+    @ref basic_json type
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this, converted into @tparam BasicJsonType
+
+    @complexity Depending on the implementation of the called `from_json()`
+                method.
+
+    @since version 3.2.0
+    */
+    template < typename BasicJsonType, detail::enable_if_t <
+                   !std::is_same<BasicJsonType, basic_json>::value&&
+                   detail::is_basic_json<BasicJsonType>::value, int > = 0 >
+    BasicJsonType get() const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get a value (explicit)
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    ValueType ret;
+    JSONSerializer<ValueType>::from_json(*this, ret);
+    return ret;
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json,
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `void from_json(const basic_json&, ValueType&)`, and
+    - @ref json_serializer<ValueType> does not have a `from_json()` method of
+      the form `ValueType from_json(const basic_json&)`
+
+    @tparam ValueTypeCV the provided value type
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,get__ValueType_const}
+
+    @since version 2.1.0
+    */
+    template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
+               detail::enable_if_t <
+                   !detail::is_basic_json<ValueType>::value &&
+                   detail::has_from_json<basic_json_t, ValueType>::value &&
+                   !detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType get() const noexcept(noexcept(
+                                       JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
+    {
+        // we cannot static_assert on ValueTypeCV being non-const, because
+        // there is support for get<const basic_json_t>(), which is why we
+        // still need the uncvref
+        static_assert(!std::is_reference<ValueTypeCV>::value,
+                      "get() cannot be used with reference types, you might want to use get_ref()");
+        static_assert(std::is_default_constructible<ValueType>::value,
+                      "types must be DefaultConstructible when used with get()");
+
+        ValueType ret;
+        JSONSerializer<ValueType>::from_json(*this, ret);
+        return ret;
+    }
+
+    /*!
+    @brief get a value (explicit); special case
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    return JSONSerializer<ValueTypeCV>::from_json(*this);
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json and
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `ValueType from_json(const basic_json&)`
+
+    @note If @ref json_serializer<ValueType> has both overloads of
+    `from_json()`, this one is chosen.
+
+    @tparam ValueTypeCV the provided value type
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @since version 2.1.0
+    */
+    template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
+               detail::enable_if_t < !std::is_same<basic_json_t, ValueType>::value &&
+                                     detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+                                     int > = 0 >
+    ValueType get() const noexcept(noexcept(
+                                       JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
+    {
+        static_assert(!std::is_reference<ValueTypeCV>::value,
+                      "get() cannot be used with reference types, you might want to use get_ref()");
+        return JSONSerializer<ValueType>::from_json(*this);
+    }
+
+    /*!
+    @brief get a value (explicit)
+
+    Explicit type conversion between the JSON value and a compatible value.
+    The value is filled into the input parameter by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    ValueType v;
+    JSONSerializer<ValueType>::from_json(*this, v);
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json,
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `void from_json(const basic_json&, ValueType&)`, and
+
+    @tparam ValueType the input parameter type.
+
+    @return the input parameter, allowing chaining calls.
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,get_to}
+
+    @since version 3.3.0
+    */
+    template < typename ValueType,
+               detail::enable_if_t <
+                   !detail::is_basic_json<ValueType>::value&&
+                   detail::has_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType & get_to(ValueType& v) const noexcept(noexcept(
+                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<ValueType>::from_json(*this, v);
+        return v;
+    }
+
+    // specialization to allow to call get_to with a basic_json value
+    // see https://github.com/nlohmann/json/issues/2175
+    template<typename ValueType,
+             detail::enable_if_t <
+                 detail::is_basic_json<ValueType>::value,
+                 int> = 0>
+    ValueType & get_to(ValueType& v) const
+    {
+        v = *this;
+        return v;
+    }
+
+    template <
+        typename T, std::size_t N,
+        typename Array = T (&)[N],
+        detail::enable_if_t <
+            detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
+    Array get_to(T (&v)[N]) const
+    noexcept(noexcept(JSONSerializer<Array>::from_json(
+                          std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<Array>::from_json(*this, v);
+        return v;
+    }
+
+
+    /*!
+    @brief get a pointer value (implicit)
+
+    Implicit pointer access to the internally stored JSON value. No copies are
+    made.
+
+    @warning Writing data to the pointee of the result yields an undefined
+    state.
+
+    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
+    @ref number_unsigned_t, or @ref number_float_t. Enforced by a static
+    assertion.
+
+    @return pointer to the internally stored JSON value if the requested
+    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how pointers to internal values of a
+    JSON value can be requested. Note that no type conversions are made and a
+    `nullptr` is returned if the value and the requested pointer type does not
+    match.,get_ptr}
+
+    @since version 1.0.0
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>()
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+    /*!
+    @brief get a pointer value (implicit)
+    @copydoc get_ptr()
+    */
+    template < typename PointerType, typename std::enable_if <
+                   std::is_pointer<PointerType>::value&&
+                   std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
+    constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>() const
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+
+    Explicit pointer access to the internally stored JSON value. No copies are
+    made.
+
+    @warning The pointer becomes invalid if the underlying JSON object
+    changes.
+
+    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
+    @ref number_unsigned_t, or @ref number_float_t.
+
+    @return pointer to the internally stored JSON value if the requested
+    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how pointers to internal values of a
+    JSON value can be requested. Note that no type conversions are made and a
+    `nullptr` is returned if the value and the requested pointer type does not
+    match.,get__PointerType}
+
+    @sa @ref get_ptr() for explicit pointer-member access
+
+    @since version 1.0.0
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+    @copydoc get()
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    constexpr auto get() const noexcept -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+    /*!
+    @brief get a reference value (implicit)
+
+    Implicit reference access to the internally stored JSON value. No copies
+    are made.
+
+    @warning Writing data to the referee of the result yields an undefined
+    state.
+
+    @tparam ReferenceType reference type; must be a reference to @ref array_t,
+    @ref object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, or
+    @ref number_float_t. Enforced by static assertion.
+
+    @return reference to the internally stored JSON value if the requested
+    reference type @a ReferenceType fits to the JSON value; throws
+    type_error.303 otherwise
+
+    @throw type_error.303 in case passed type @a ReferenceType is incompatible
+    with the stored JSON value; see example below
+
+    @complexity Constant.
+
+    @liveexample{The example shows several calls to `get_ref()`.,get_ref}
+
+    @since version 1.1.0
+    */
+    template<typename ReferenceType, typename std::enable_if<
+                 std::is_reference<ReferenceType>::value, int>::type = 0>
+    ReferenceType get_ref()
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /*!
+    @brief get a reference value (implicit)
+    @copydoc get_ref()
+    */
+    template < typename ReferenceType, typename std::enable_if <
+                   std::is_reference<ReferenceType>::value&&
+                   std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
+    ReferenceType get_ref() const
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /*!
+    @brief get a value (implicit)
+
+    Implicit type conversion between the JSON value and a compatible value.
+    The call is realized by calling @ref get() const.
+
+    @tparam ValueType non-pointer type compatible to the JSON value, for
+    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
+    `std::vector` types for JSON arrays. The character type of @ref string_t
+    as well as an initializer list of this type is excluded to avoid
+    ambiguities as these types implicitly convert to `std::string`.
+
+    @return copy of the JSON value, converted to type @a ValueType
+
+    @throw type_error.302 in case passed type @a ValueType is incompatible
+    to the JSON value type (e.g., the JSON value is of type boolean, but a
+    string is requested); see example below
+
+    @complexity Linear in the size of the JSON value.
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,operator__ValueType}
+
+    @since version 1.0.0
+    */
+    template < typename ValueType, typename std::enable_if <
+                   !std::is_pointer<ValueType>::value&&
+                   !std::is_same<ValueType, detail::json_ref<basic_json>>::value&&
+                   !std::is_same<ValueType, typename string_t::value_type>::value&&
+                   !detail::is_basic_json<ValueType>::value
+                   && !std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
+#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
+                   && !std::is_same<ValueType, typename std::string_view>::value
+#endif
+                   && detail::is_detected<detail::get_template_function, const basic_json_t&, ValueType>::value
+                   , int >::type = 0 >
+    JSON_EXPLICIT operator ValueType() const
+    {
+        // delegate the call to get<>() const
+        return get<ValueType>();
+    }
+
+    /*!
+    @return reference to the binary value
+
+    @throw type_error.302 if the value is not binary
+
+    @sa @ref is_binary() to check if the value is binary
+
+    @since version 3.8.0
+    */
+    binary_t& get_binary()
+    {
+        if (!is_binary())
+        {
+            JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name())));
+        }
+
+        return *get_ptr<binary_t*>();
+    }
+
+    /// @copydoc get_binary()
+    const binary_t& get_binary() const
+    {
+        if (!is_binary())
+        {
+            JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name())));
+        }
+
+        return *get_ptr<const binary_t*>();
+    }
+
+    /// @}
+
+
+    ////////////////////
+    // element access //
+    ////////////////////
+
+    /// @name element access
+    /// Access to the JSON value.
+    /// @{
+
+    /*!
+    @brief access specified array element with bounds checking
+
+    Returns a reference to the element at specified location @a idx, with
+    bounds checking.
+
+    @param[in] idx  index of the element to access
+
+    @return reference to the element at index @a idx
+
+    @throw type_error.304 if the JSON value is not an array; in this case,
+    calling `at` with an index makes no sense. See example below.
+    @throw out_of_range.401 if the index @a idx is out of range of the array;
+    that is, `idx >= size()`. See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 1.0.0
+
+    @liveexample{The example below shows how array elements can be read and
+    written using `at()`. It also demonstrates the different exceptions that
+    can be thrown.,at__size_type}
+    */
+    reference at(size_type idx)
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return m_value.array->at(idx);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief access specified array element with bounds checking
+
+    Returns a const reference to the element at specified location @a idx,
+    with bounds checking.
+
+    @param[in] idx  index of the element to access
+
+    @return const reference to the element at index @a idx
+
+    @throw type_error.304 if the JSON value is not an array; in this case,
+    calling `at` with an index makes no sense. See example below.
+    @throw out_of_range.401 if the index @a idx is out of range of the array;
+    that is, `idx >= size()`. See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 1.0.0
+
+    @liveexample{The example below shows how array elements can be read using
+    `at()`. It also demonstrates the different exceptions that can be thrown.,
+    at__size_type_const}
+    */
+    const_reference at(size_type idx) const
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return m_value.array->at(idx);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief access specified object element with bounds checking
+
+    Returns a reference to the element at with specified key @a key, with
+    bounds checking.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw type_error.304 if the JSON value is not an object; in this case,
+    calling `at` with a key makes no sense. See example below.
+    @throw out_of_range.403 if the key @a key is is not stored in the object;
+    that is, `find(key) == end()`. See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Logarithmic in the size of the container.
+
+    @sa @ref operator[](const typename object_t::key_type&) for unchecked
+    access by reference
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.0.0
+
+    @liveexample{The example below shows how object elements can be read and
+    written using `at()`. It also demonstrates the different exceptions that
+    can be thrown.,at__object_t_key_type}
+    */
+    reference at(const typename object_t::key_type& key)
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            JSON_TRY
+            {
+                return m_value.object->at(key);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief access specified object element with bounds checking
+
+    Returns a const reference to the element at with specified key @a key,
+    with bounds checking.
+
+    @param[in] key  key of the element to access
+
+    @return const reference to the element at key @a key
+
+    @throw type_error.304 if the JSON value is not an object; in this case,
+    calling `at` with a key makes no sense. See example below.
+    @throw out_of_range.403 if the key @a key is is not stored in the object;
+    that is, `find(key) == end()`. See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Logarithmic in the size of the container.
+
+    @sa @ref operator[](const typename object_t::key_type&) for unchecked
+    access by reference
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.0.0
+
+    @liveexample{The example below shows how object elements can be read using
+    `at()`. It also demonstrates the different exceptions that can be thrown.,
+    at__object_t_key_type_const}
+    */
+    const_reference at(const typename object_t::key_type& key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            JSON_TRY
+            {
+                return m_value.object->at(key);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief access specified array element
+
+    Returns a reference to the element at specified location @a idx.
+
+    @note If @a idx is beyond the range of the array (i.e., `idx >= size()`),
+    then the array is silently filled up with `null` values to make `idx` a
+    valid reference to the last stored element.
+
+    @param[in] idx  index of the element to access
+
+    @return reference to the element at index @a idx
+
+    @throw type_error.305 if the JSON value is not an array or null; in that
+    cases, using the [] operator with an index makes no sense.
+
+    @complexity Constant if @a idx is in the range of the array. Otherwise
+    linear in `idx - size()`.
+
+    @liveexample{The example below shows how array elements can be read and
+    written using `[]` operator. Note the addition of `null`
+    values.,operatorarray__size_type}
+
+    @since version 1.0.0
+    */
+    reference operator[](size_type idx)
+    {
+        // implicitly convert null value to an empty array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value.array = create<array_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // fill up array with null values if given idx is outside range
+            if (idx >= m_value.array->size())
+            {
+                m_value.array->insert(m_value.array->end(),
+                                      idx - m_value.array->size() + 1,
+                                      basic_json());
+            }
+
+            return m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief access specified array element
+
+    Returns a const reference to the element at specified location @a idx.
+
+    @param[in] idx  index of the element to access
+
+    @return const reference to the element at index @a idx
+
+    @throw type_error.305 if the JSON value is not an array; in that case,
+    using the [] operator with an index makes no sense.
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how array elements can be read using
+    the `[]` operator.,operatorarray__size_type_const}
+
+    @since version 1.0.0
+    */
+    const_reference operator[](size_type idx) const
+    {
+        // const operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            return m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief access specified object element
+
+    Returns a reference to the element at with specified key @a key.
+
+    @note If @a key is not found in the object, then it is silently added to
+    the object and filled with a `null` value to make `key` a valid reference.
+    In case the value was `null` before, it is converted to an object.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw type_error.305 if the JSON value is not an object or null; in that
+    cases, using the [] operator with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read and
+    written using the `[]` operator.,operatorarray__key_type}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.0.0
+    */
+    reference operator[](const typename object_t::key_type& key)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            return m_value.object->operator[](key);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief read-only access specified object element
+
+    Returns a const reference to the element at with specified key @a key. No
+    bounds checking is performed.
+
+    @warning If the element with key @a key does not exist, the behavior is
+    undefined.
+
+    @param[in] key  key of the element to access
+
+    @return const reference to the element at key @a key
+
+    @pre The element with key @a key must exist. **This precondition is
+         enforced with an assertion.**
+
+    @throw type_error.305 if the JSON value is not an object; in that case,
+    using the [] operator with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read using
+    the `[]` operator.,operatorarray__key_type_const}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.0.0
+    */
+    const_reference operator[](const typename object_t::key_type& key) const
+    {
+        // const operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
+            return m_value.object->find(key)->second;
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief access specified object element
+
+    Returns a reference to the element at with specified key @a key.
+
+    @note If @a key is not found in the object, then it is silently added to
+    the object and filled with a `null` value to make `key` a valid reference.
+    In case the value was `null` before, it is converted to an object.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw type_error.305 if the JSON value is not an object or null; in that
+    cases, using the [] operator with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read and
+    written using the `[]` operator.,operatorarray__key_type}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.1.0
+    */
+    template<typename T>
+    JSON_HEDLEY_NON_NULL(2)
+    reference operator[](T* key)
+    {
+        // implicitly convert null to object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            return m_value.object->operator[](key);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief read-only access specified object element
+
+    Returns a const reference to the element at with specified key @a key. No
+    bounds checking is performed.
+
+    @warning If the element with key @a key does not exist, the behavior is
+    undefined.
+
+    @param[in] key  key of the element to access
+
+    @return const reference to the element at key @a key
+
+    @pre The element with key @a key must exist. **This precondition is
+         enforced with an assertion.**
+
+    @throw type_error.305 if the JSON value is not an object; in that case,
+    using the [] operator with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read using
+    the `[]` operator.,operatorarray__key_type_const}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.1.0
+    */
+    template<typename T>
+    JSON_HEDLEY_NON_NULL(2)
+    const_reference operator[](T* key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
+            return m_value.object->find(key)->second;
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief access specified object element with default value
+
+    Returns either a copy of an object's element at the specified key @a key
+    or a given default value if no element with key @a key exists.
+
+    The function is basically equivalent to executing
+    @code {.cpp}
+    try {
+        return at(key);
+    } catch(out_of_range) {
+        return default_value;
+    }
+    @endcode
+
+    @note Unlike @ref at(const typename object_t::key_type&), this function
+    does not throw if the given key @a key was not found.
+
+    @note Unlike @ref operator[](const typename object_t::key_type& key), this
+    function does not implicitly add an element to the position defined by @a
+    key. This function is furthermore also applicable to const objects.
+
+    @param[in] key  key of the element to access
+    @param[in] default_value  the value to return if @a key is not found
+
+    @tparam ValueType type compatible to JSON values, for instance `int` for
+    JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
+    JSON arrays. Note the type of the expected value at @a key and the default
+    value @a default_value must be compatible.
+
+    @return copy of the element at key @a key or @a default_value if @a key
+    is not found
+
+    @throw type_error.302 if @a default_value does not match the type of the
+    value at @a key
+    @throw type_error.306 if the JSON value is not an object; in that case,
+    using `value()` with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be queried
+    with a default value.,basic_json__value}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref operator[](const typename object_t::key_type&) for unchecked
+    access by reference
+
+    @since version 1.0.0
+    */
+    // using std::is_convertible in a std::enable_if will fail when using explicit conversions
+    template < class ValueType, typename std::enable_if <
+                   detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, ValueType>::value, int >::type = 0 >
+    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(key);
+            if (it != end())
+            {
+                return it->template get<ValueType>();
+            }
+
+            return default_value;
+        }
+
+        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief overload for a default value of type const char*
+    @copydoc basic_json::value(const typename object_t::key_type&, const ValueType&) const
+    */
+    string_t value(const typename object_t::key_type& key, const char* default_value) const
+    {
+        return value(key, string_t(default_value));
+    }
+
+    /*!
+    @brief access specified object element via JSON Pointer with default value
+
+    Returns either a copy of an object's element at the specified key @a key
+    or a given default value if no element with key @a key exists.
+
+    The function is basically equivalent to executing
+    @code {.cpp}
+    try {
+        return at(ptr);
+    } catch(out_of_range) {
+        return default_value;
+    }
+    @endcode
+
+    @note Unlike @ref at(const json_pointer&), this function does not throw
+    if the given key @a key was not found.
+
+    @param[in] ptr  a JSON pointer to the element to access
+    @param[in] default_value  the value to return if @a ptr found no value
+
+    @tparam ValueType type compatible to JSON values, for instance `int` for
+    JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
+    JSON arrays. Note the type of the expected value at @a key and the default
+    value @a default_value must be compatible.
+
+    @return copy of the element at key @a key or @a default_value if @a key
+    is not found
+
+    @throw type_error.302 if @a default_value does not match the type of the
+    value at @a ptr
+    @throw type_error.306 if the JSON value is not an object; in that case,
+    using `value()` with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be queried
+    with a default value.,basic_json__value_ptr}
+
+    @sa @ref operator[](const json_pointer&) for unchecked access by reference
+
+    @since version 2.0.2
+    */
+    template<class ValueType, typename std::enable_if<
+                 detail::is_getable<basic_json_t, ValueType>::value, int>::type = 0>
+    ValueType value(const json_pointer& ptr, const ValueType& default_value) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if pointer resolves a value, return it or use default value
+            JSON_TRY
+            {
+                return ptr.get_checked(this).template get<ValueType>();
+            }
+            JSON_INTERNAL_CATCH (out_of_range&)
+            {
+                return default_value;
+            }
+        }
+
+        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief overload for a default value of type const char*
+    @copydoc basic_json::value(const json_pointer&, ValueType) const
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    string_t value(const json_pointer& ptr, const char* default_value) const
+    {
+        return value(ptr, string_t(default_value));
+    }
+
+    /*!
+    @brief access the first element
+
+    Returns a reference to the first element in the container. For a JSON
+    container `c`, the expression `c.front()` is equivalent to `*c.begin()`.
+
+    @return In case of a structured type (array or object), a reference to the
+    first element is returned. In case of number, string, boolean, or binary
+    values, a reference to the value is returned.
+
+    @complexity Constant.
+
+    @pre The JSON value must not be `null` (would throw `std::out_of_range`)
+    or an empty array or object (undefined behavior, **guarded by
+    assertions**).
+    @post The JSON value remains unchanged.
+
+    @throw invalid_iterator.214 when called on `null` value
+
+    @liveexample{The following code shows an example for `front()`.,front}
+
+    @sa @ref back() -- access the last element
+
+    @since version 1.0.0
+    */
+    reference front()
+    {
+        return *begin();
+    }
+
+    /*!
+    @copydoc basic_json::front()
+    */
+    const_reference front() const
+    {
+        return *cbegin();
+    }
+
+    /*!
+    @brief access the last element
+
+    Returns a reference to the last element in the container. For a JSON
+    container `c`, the expression `c.back()` is equivalent to
+    @code {.cpp}
+    auto tmp = c.end();
+    --tmp;
+    return *tmp;
+    @endcode
+
+    @return In case of a structured type (array or object), a reference to the
+    last element is returned. In case of number, string, boolean, or binary
+    values, a reference to the value is returned.
+
+    @complexity Constant.
+
+    @pre The JSON value must not be `null` (would throw `std::out_of_range`)
+    or an empty array or object (undefined behavior, **guarded by
+    assertions**).
+    @post The JSON value remains unchanged.
+
+    @throw invalid_iterator.214 when called on a `null` value. See example
+    below.
+
+    @liveexample{The following code shows an example for `back()`.,back}
+
+    @sa @ref front() -- access the first element
+
+    @since version 1.0.0
+    */
+    reference back()
+    {
+        auto tmp = end();
+        --tmp;
+        return *tmp;
+    }
+
+    /*!
+    @copydoc basic_json::back()
+    */
+    const_reference back() const
+    {
+        auto tmp = cend();
+        --tmp;
+        return *tmp;
+    }
+
+    /*!
+    @brief remove element given an iterator
+
+    Removes the element specified by iterator @a pos. The iterator @a pos must
+    be valid and dereferenceable. Thus the `end()` iterator (which is valid,
+    but is not dereferenceable) cannot be used as a value for @a pos.
+
+    If called on a primitive type other than `null`, the resulting JSON value
+    will be `null`.
+
+    @param[in] pos iterator to the element to remove
+    @return Iterator following the last removed element. If the iterator @a
+    pos refers to the last element, the `end()` iterator is returned.
+
+    @tparam IteratorType an @ref iterator or @ref const_iterator
+
+    @post Invalidates iterators and references at or after the point of the
+    erase, including the `end()` iterator.
+
+    @throw type_error.307 if called on a `null` value; example: `"cannot use
+    erase() with null"`
+    @throw invalid_iterator.202 if called on an iterator which does not belong
+    to the current JSON value; example: `"iterator does not fit current
+    value"`
+    @throw invalid_iterator.205 if called on a primitive type with invalid
+    iterator (i.e., any iterator which is not `begin()`); example: `"iterator
+    out of range"`
+
+    @complexity The complexity depends on the type:
+    - objects: amortized constant
+    - arrays: linear in distance between @a pos and the end of the container
+    - strings and binary: linear in the length of the member
+    - other types: constant
+
+    @liveexample{The example shows the result of `erase()` for different JSON
+    types.,erase__IteratorType}
+
+    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
+    the given range
+    @sa @ref erase(const typename object_t::key_type&) -- removes the element
+    from an object at the given key
+    @sa @ref erase(const size_type) -- removes the element from an array at
+    the given index
+
+    @since version 1.0.0
+    */
+    template < class IteratorType, typename std::enable_if <
+                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
+               = 0 >
+    IteratorType erase(IteratorType pos)
+    {
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+        }
+
+        IteratorType result = end();
+
+        switch (m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            case value_t::binary:
+            {
+                if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
+                {
+                    JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
+                    m_value.string = nullptr;
+                }
+                else if (is_binary())
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
+                    m_value.binary = nullptr;
+                }
+
+                m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
+                break;
+            }
+
+            default:
+                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief remove elements given an iterator range
+
+    Removes the element specified by the range `[first; last)`. The iterator
+    @a first does not need to be dereferenceable if `first == last`: erasing
+    an empty range is a no-op.
+
+    If called on a primitive type other than `null`, the resulting JSON value
+    will be `null`.
+
+    @param[in] first iterator to the beginning of the range to remove
+    @param[in] last iterator past the end of the range to remove
+    @return Iterator following the last removed element. If the iterator @a
+    second refers to the last element, the `end()` iterator is returned.
+
+    @tparam IteratorType an @ref iterator or @ref const_iterator
+
+    @post Invalidates iterators and references at or after the point of the
+    erase, including the `end()` iterator.
+
+    @throw type_error.307 if called on a `null` value; example: `"cannot use
+    erase() with null"`
+    @throw invalid_iterator.203 if called on iterators which does not belong
+    to the current JSON value; example: `"iterators do not fit current value"`
+    @throw invalid_iterator.204 if called on a primitive type with invalid
+    iterators (i.e., if `first != begin()` and `last != end()`); example:
+    `"iterators out of range"`
+
+    @complexity The complexity depends on the type:
+    - objects: `log(size()) + std::distance(first, last)`
+    - arrays: linear in the distance between @a first and @a last, plus linear
+      in the distance between @a last and end of the container
+    - strings and binary: linear in the length of the member
+    - other types: constant
+
+    @liveexample{The example shows the result of `erase()` for different JSON
+    types.,erase__IteratorType_IteratorType}
+
+    @sa @ref erase(IteratorType) -- removes the element at a given position
+    @sa @ref erase(const typename object_t::key_type&) -- removes the element
+    from an object at the given key
+    @sa @ref erase(const size_type) -- removes the element from an array at
+    the given index
+
+    @since version 1.0.0
+    */
+    template < class IteratorType, typename std::enable_if <
+                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
+               = 0 >
+    IteratorType erase(IteratorType first, IteratorType last)
+    {
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value"));
+        }
+
+        IteratorType result = end();
+
+        switch (m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            case value_t::binary:
+            {
+                if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
+                                       || !last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
+                    m_value.string = nullptr;
+                }
+                else if (is_binary())
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
+                    m_value.binary = nullptr;
+                }
+
+                m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
+                                              last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
+                                             last.m_it.array_iterator);
+                break;
+            }
+
+            default:
+                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief remove element from a JSON object given a key
+
+    Removes elements from a JSON object with the key value @a key.
+
+    @param[in] key value of the elements to remove
+
+    @return Number of elements removed. If @a ObjectType is the default
+    `std::map` type, the return value will always be `0` (@a key was not
+    found) or `1` (@a key was found).
+
+    @post References and iterators to the erased elements are invalidated.
+    Other references and iterators are not affected.
+
+    @throw type_error.307 when called on a type other than JSON object;
+    example: `"cannot use erase() with null"`
+
+    @complexity `log(size()) + count(key)`
+
+    @liveexample{The example shows the effect of `erase()`.,erase__key_type}
+
+    @sa @ref erase(IteratorType) -- removes the element at a given position
+    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
+    the given range
+    @sa @ref erase(const size_type) -- removes the element from an array at
+    the given index
+
+    @since version 1.0.0
+    */
+    size_type erase(const typename object_t::key_type& key)
+    {
+        // this erase only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            return m_value.object->erase(key);
+        }
+
+        JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief remove element from a JSON array given an index
+
+    Removes element from a JSON array at the index @a idx.
+
+    @param[in] idx index of the element to remove
+
+    @throw type_error.307 when called on a type other than JSON object;
+    example: `"cannot use erase() with null"`
+    @throw out_of_range.401 when `idx >= size()`; example: `"array index 17
+    is out of range"`
+
+    @complexity Linear in distance between @a idx and the end of the container.
+
+    @liveexample{The example shows the effect of `erase()`.,erase__size_type}
+
+    @sa @ref erase(IteratorType) -- removes the element at a given position
+    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
+    the given range
+    @sa @ref erase(const typename object_t::key_type&) -- removes the element
+    from an object at the given key
+
+    @since version 1.0.0
+    */
+    void erase(const size_type idx)
+    {
+        // this erase only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            if (JSON_HEDLEY_UNLIKELY(idx >= size()))
+            {
+                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
+            }
+
+            m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
+        }
+        else
+        {
+            JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
+        }
+    }
+
+    /// @}
+
+
+    ////////////
+    // lookup //
+    ////////////
+
+    /// @name lookup
+    /// @{
+
+    /*!
+    @brief find an element in a JSON object
+
+    Finds an element in a JSON object with key equivalent to @a key. If the
+    element is not found or the JSON value is not an object, end() is
+    returned.
+
+    @note This method always returns @ref end() when executed on a JSON type
+          that is not an object.
+
+    @param[in] key key value of the element to search for.
+
+    @return Iterator to an element with key equivalent to @a key. If no such
+    element is found or the JSON value is not an object, past-the-end (see
+    @ref end()) iterator is returned.
+
+    @complexity Logarithmic in the size of the JSON object.
+
+    @liveexample{The example shows how `find()` is used.,find__key_type}
+
+    @sa @ref contains(KeyT&&) const -- checks whether a key exists
+
+    @since version 1.0.0
+    */
+    template<typename KeyT>
+    iterator find(KeyT&& key)
+    {
+        auto result = end();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief find an element in a JSON object
+    @copydoc find(KeyT&&)
+    */
+    template<typename KeyT>
+    const_iterator find(KeyT&& key) const
+    {
+        auto result = cend();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief returns the number of occurrences of a key in a JSON object
+
+    Returns the number of elements with key @a key. If ObjectType is the
+    default `std::map` type, the return value will always be `0` (@a key was
+    not found) or `1` (@a key was found).
+
+    @note This method always returns `0` when executed on a JSON type that is
+          not an object.
+
+    @param[in] key key value of the element to count
+
+    @return Number of elements with key @a key. If the JSON value is not an
+    object, the return value will be `0`.
+
+    @complexity Logarithmic in the size of the JSON object.
+
+    @liveexample{The example shows how `count()` is used.,count}
+
+    @since version 1.0.0
+    */
+    template<typename KeyT>
+    size_type count(KeyT&& key) const
+    {
+        // return 0 for all nonobject types
+        return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;
+    }
+
+    /*!
+    @brief check the existence of an element in a JSON object
+
+    Check whether an element exists in a JSON object with key equivalent to
+    @a key. If the element is not found or the JSON value is not an object,
+    false is returned.
+
+    @note This method always returns false when executed on a JSON type
+          that is not an object.
+
+    @param[in] key key value to check its existence.
+
+    @return true if an element with specified @a key exists. If no such
+    element with such key is found or the JSON value is not an object,
+    false is returned.
+
+    @complexity Logarithmic in the size of the JSON object.
+
+    @liveexample{The following code shows an example for `contains()`.,contains}
+
+    @sa @ref find(KeyT&&) -- returns an iterator to an object element
+    @sa @ref contains(const json_pointer&) const -- checks the existence for a JSON pointer
+
+    @since version 3.6.0
+    */
+    template < typename KeyT, typename std::enable_if <
+                   !std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int >::type = 0 >
+    bool contains(KeyT && key) const
+    {
+        return is_object() && m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
+    }
+
+    /*!
+    @brief check the existence of an element in a JSON object given a JSON pointer
+
+    Check whether the given JSON pointer @a ptr can be resolved in the current
+    JSON value.
+
+    @note This method can be executed on any JSON value type.
+
+    @param[in] ptr JSON pointer to check its existence.
+
+    @return true if the JSON pointer can be resolved to a stored value, false
+    otherwise.
+
+    @post If `j.contains(ptr)` returns true, it is safe to call `j[ptr]`.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+
+    @complexity Logarithmic in the size of the JSON object.
+
+    @liveexample{The following code shows an example for `contains()`.,contains_json_pointer}
+
+    @sa @ref contains(KeyT &&) const -- checks the existence of a key
+
+    @since version 3.7.0
+    */
+    bool contains(const json_pointer& ptr) const
+    {
+        return ptr.contains(this);
+    }
+
+    /// @}
+
+
+    ///////////////
+    // iterators //
+    ///////////////
+
+    /// @name iterators
+    /// @{
+
+    /*!
+    @brief returns an iterator to the first element
+
+    Returns an iterator to the first element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return iterator to the first element
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+
+    @liveexample{The following code shows an example for `begin()`.,begin}
+
+    @sa @ref cbegin() -- returns a const iterator to the beginning
+    @sa @ref end() -- returns an iterator to the end
+    @sa @ref cend() -- returns a const iterator to the end
+
+    @since version 1.0.0
+    */
+    iterator begin() noexcept
+    {
+        iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /*!
+    @copydoc basic_json::cbegin()
+    */
+    const_iterator begin() const noexcept
+    {
+        return cbegin();
+    }
+
+    /*!
+    @brief returns a const iterator to the first element
+
+    Returns a const iterator to the first element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return const iterator to the first element
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).begin()`.
+
+    @liveexample{The following code shows an example for `cbegin()`.,cbegin}
+
+    @sa @ref begin() -- returns an iterator to the beginning
+    @sa @ref end() -- returns an iterator to the end
+    @sa @ref cend() -- returns a const iterator to the end
+
+    @since version 1.0.0
+    */
+    const_iterator cbegin() const noexcept
+    {
+        const_iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /*!
+    @brief returns an iterator to one past the last element
+
+    Returns an iterator to one past the last element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return iterator one past the last element
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+
+    @liveexample{The following code shows an example for `end()`.,end}
+
+    @sa @ref cend() -- returns a const iterator to the end
+    @sa @ref begin() -- returns an iterator to the beginning
+    @sa @ref cbegin() -- returns a const iterator to the beginning
+
+    @since version 1.0.0
+    */
+    iterator end() noexcept
+    {
+        iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /*!
+    @copydoc basic_json::cend()
+    */
+    const_iterator end() const noexcept
+    {
+        return cend();
+    }
+
+    /*!
+    @brief returns a const iterator to one past the last element
+
+    Returns a const iterator to one past the last element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return const iterator one past the last element
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).end()`.
+
+    @liveexample{The following code shows an example for `cend()`.,cend}
+
+    @sa @ref end() -- returns an iterator to the end
+    @sa @ref begin() -- returns an iterator to the beginning
+    @sa @ref cbegin() -- returns a const iterator to the beginning
+
+    @since version 1.0.0
+    */
+    const_iterator cend() const noexcept
+    {
+        const_iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /*!
+    @brief returns an iterator to the reverse-beginning
+
+    Returns an iterator to the reverse-beginning; that is, the last element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `reverse_iterator(end())`.
+
+    @liveexample{The following code shows an example for `rbegin()`.,rbegin}
+
+    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
+    @sa @ref rend() -- returns a reverse iterator to the end
+    @sa @ref crend() -- returns a const reverse iterator to the end
+
+    @since version 1.0.0
+    */
+    reverse_iterator rbegin() noexcept
+    {
+        return reverse_iterator(end());
+    }
+
+    /*!
+    @copydoc basic_json::crbegin()
+    */
+    const_reverse_iterator rbegin() const noexcept
+    {
+        return crbegin();
+    }
+
+    /*!
+    @brief returns an iterator to the reverse-end
+
+    Returns an iterator to the reverse-end; that is, one before the first
+    element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `reverse_iterator(begin())`.
+
+    @liveexample{The following code shows an example for `rend()`.,rend}
+
+    @sa @ref crend() -- returns a const reverse iterator to the end
+    @sa @ref rbegin() -- returns a reverse iterator to the beginning
+    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
+
+    @since version 1.0.0
+    */
+    reverse_iterator rend() noexcept
+    {
+        return reverse_iterator(begin());
+    }
+
+    /*!
+    @copydoc basic_json::crend()
+    */
+    const_reverse_iterator rend() const noexcept
+    {
+        return crend();
+    }
+
+    /*!
+    @brief returns a const reverse iterator to the last element
+
+    Returns a const iterator to the reverse-beginning; that is, the last
+    element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).rbegin()`.
+
+    @liveexample{The following code shows an example for `crbegin()`.,crbegin}
+
+    @sa @ref rbegin() -- returns a reverse iterator to the beginning
+    @sa @ref rend() -- returns a reverse iterator to the end
+    @sa @ref crend() -- returns a const reverse iterator to the end
+
+    @since version 1.0.0
+    */
+    const_reverse_iterator crbegin() const noexcept
+    {
+        return const_reverse_iterator(cend());
+    }
+
+    /*!
+    @brief returns a const reverse iterator to one before the first
+
+    Returns a const reverse iterator to the reverse-end; that is, one before
+    the first element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).rend()`.
+
+    @liveexample{The following code shows an example for `crend()`.,crend}
+
+    @sa @ref rend() -- returns a reverse iterator to the end
+    @sa @ref rbegin() -- returns a reverse iterator to the beginning
+    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
+
+    @since version 1.0.0
+    */
+    const_reverse_iterator crend() const noexcept
+    {
+        return const_reverse_iterator(cbegin());
+    }
+
+  public:
+    /*!
+    @brief wrapper to access iterator member functions in range-based for
+
+    This function allows to access @ref iterator::key() and @ref
+    iterator::value() during range-based for loops. In these loops, a
+    reference to the JSON values is returned, so there is no access to the
+    underlying iterator.
+
+    For loop without iterator_wrapper:
+
+    @code{cpp}
+    for (auto it = j_object.begin(); it != j_object.end(); ++it)
+    {
+        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
+    }
+    @endcode
+
+    Range-based for loop without iterator proxy:
+
+    @code{cpp}
+    for (auto it : j_object)
+    {
+        // "it" is of type json::reference and has no key() member
+        std::cout << "value: " << it << '\n';
+    }
+    @endcode
+
+    Range-based for loop with iterator proxy:
+
+    @code{cpp}
+    for (auto it : json::iterator_wrapper(j_object))
+    {
+        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
+    }
+    @endcode
+
+    @note When iterating over an array, `key()` will return the index of the
+          element as string (see example).
+
+    @param[in] ref  reference to a JSON value
+    @return iteration proxy object wrapping @a ref with an interface to use in
+            range-based for loops
+
+    @liveexample{The following code shows how the wrapper is used,iterator_wrapper}
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @note The name of this function is not yet final and may change in the
+    future.
+
+    @deprecated This stream operator is deprecated and will be removed in
+                future 4.0.0 of the library. Please use @ref items() instead;
+                that is, replace `json::iterator_wrapper(j)` with `j.items()`.
+    */
+    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
+    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /*!
+    @copydoc iterator_wrapper(reference)
+    */
+    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
+    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /*!
+    @brief helper to access iterator member functions in range-based for
+
+    This function allows to access @ref iterator::key() and @ref
+    iterator::value() during range-based for loops. In these loops, a
+    reference to the JSON values is returned, so there is no access to the
+    underlying iterator.
+
+    For loop without `items()` function:
+
+    @code{cpp}
+    for (auto it = j_object.begin(); it != j_object.end(); ++it)
+    {
+        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
+    }
+    @endcode
+
+    Range-based for loop without `items()` function:
+
+    @code{cpp}
+    for (auto it : j_object)
+    {
+        // "it" is of type json::reference and has no key() member
+        std::cout << "value: " << it << '\n';
+    }
+    @endcode
+
+    Range-based for loop with `items()` function:
+
+    @code{cpp}
+    for (auto& el : j_object.items())
+    {
+        std::cout << "key: " << el.key() << ", value:" << el.value() << '\n';
+    }
+    @endcode
+
+    The `items()` function also allows to use
+    [structured bindings](https://en.cppreference.com/w/cpp/language/structured_binding)
+    (C++17):
+
+    @code{cpp}
+    for (auto& [key, val] : j_object.items())
+    {
+        std::cout << "key: " << key << ", value:" << val << '\n';
+    }
+    @endcode
+
+    @note When iterating over an array, `key()` will return the index of the
+          element as string (see example). For primitive types (e.g., numbers),
+          `key()` returns an empty string.
+
+    @warning Using `items()` on temporary objects is dangerous. Make sure the
+             object's lifetime exeeds the iteration. See
+             <https://github.com/nlohmann/json/issues/2040> for more
+             information.
+
+    @return iteration proxy object wrapping @a ref with an interface to use in
+            range-based for loops
+
+    @liveexample{The following code shows how the function is used.,items}
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 3.1.0, structured bindings support since 3.5.0.
+    */
+    iteration_proxy<iterator> items() noexcept
+    {
+        return iteration_proxy<iterator>(*this);
+    }
+
+    /*!
+    @copydoc items()
+    */
+    iteration_proxy<const_iterator> items() const noexcept
+    {
+        return iteration_proxy<const_iterator>(*this);
+    }
+
+    /// @}
+
+
+    //////////////
+    // capacity //
+    //////////////
+
+    /// @name capacity
+    /// @{
+
+    /*!
+    @brief checks whether the container is empty.
+
+    Checks if a JSON value has no elements (i.e. whether its @ref size is `0`).
+
+    @return The return value depends on the different types and is
+            defined as follows:
+            Value type  | return value
+            ----------- | -------------
+            null        | `true`
+            boolean     | `false`
+            string      | `false`
+            number      | `false`
+            binary      | `false`
+            object      | result of function `object_t::empty()`
+            array       | result of function `array_t::empty()`
+
+    @liveexample{The following code uses `empty()` to check if a JSON
+    object contains any elements.,empty}
+
+    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
+    the Container concept; that is, their `empty()` functions have constant
+    complexity.
+
+    @iterators No changes.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @note This function does not return whether a string stored as JSON value
+    is empty - it returns whether the JSON container itself is empty which is
+    false in the case of a string.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `begin() == end()`.
+
+    @sa @ref size() -- returns the number of elements
+
+    @since version 1.0.0
+    */
+    bool empty() const noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return true;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::empty()
+                return m_value.array->empty();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::empty()
+                return m_value.object->empty();
+            }
+
+            default:
+            {
+                // all other types are nonempty
+                return false;
+            }
+        }
+    }
+
+    /*!
+    @brief returns the number of elements
+
+    Returns the number of elements in a JSON value.
+
+    @return The return value depends on the different types and is
+            defined as follows:
+            Value type  | return value
+            ----------- | -------------
+            null        | `0`
+            boolean     | `1`
+            string      | `1`
+            number      | `1`
+            binary      | `1`
+            object      | result of function object_t::size()
+            array       | result of function array_t::size()
+
+    @liveexample{The following code calls `size()` on the different value
+    types.,size}
+
+    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
+    the Container concept; that is, their size() functions have constant
+    complexity.
+
+    @iterators No changes.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @note This function does not return the length of a string stored as JSON
+    value - it returns the number of elements in the JSON value which is 1 in
+    the case of a string.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `std::distance(begin(), end())`.
+
+    @sa @ref empty() -- checks whether the container is empty
+    @sa @ref max_size() -- returns the maximal number of elements
+
+    @since version 1.0.0
+    */
+    size_type size() const noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return 0;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::size()
+                return m_value.array->size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::size()
+                return m_value.object->size();
+            }
+
+            default:
+            {
+                // all other types have size 1
+                return 1;
+            }
+        }
+    }
+
+    /*!
+    @brief returns the maximum possible number of elements
+
+    Returns the maximum number of elements a JSON value is able to hold due to
+    system or library implementation limitations, i.e. `std::distance(begin(),
+    end())` for the JSON value.
+
+    @return The return value depends on the different types and is
+            defined as follows:
+            Value type  | return value
+            ----------- | -------------
+            null        | `0` (same as `size()`)
+            boolean     | `1` (same as `size()`)
+            string      | `1` (same as `size()`)
+            number      | `1` (same as `size()`)
+            binary      | `1` (same as `size()`)
+            object      | result of function `object_t::max_size()`
+            array       | result of function `array_t::max_size()`
+
+    @liveexample{The following code calls `max_size()` on the different value
+    types. Note the output is implementation specific.,max_size}
+
+    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
+    the Container concept; that is, their `max_size()` functions have constant
+    complexity.
+
+    @iterators No changes.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of returning `b.size()` where `b` is the largest
+      possible JSON value.
+
+    @sa @ref size() -- returns the number of elements
+
+    @since version 1.0.0
+    */
+    size_type max_size() const noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::array:
+            {
+                // delegate call to array_t::max_size()
+                return m_value.array->max_size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::max_size()
+                return m_value.object->max_size();
+            }
+
+            default:
+            {
+                // all other types have max_size() == size()
+                return size();
+            }
+        }
+    }
+
+    /// @}
+
+
+    ///////////////
+    // modifiers //
+    ///////////////
+
+    /// @name modifiers
+    /// @{
+
+    /*!
+    @brief clears the contents
+
+    Clears the content of a JSON value and resets it to the default value as
+    if @ref basic_json(value_t) would have been called with the current value
+    type from @ref type():
+
+    Value type  | initial value
+    ----------- | -------------
+    null        | `null`
+    boolean     | `false`
+    string      | `""`
+    number      | `0`
+    binary      | An empty byte vector
+    object      | `{}`
+    array       | `[]`
+
+    @post Has the same effect as calling
+    @code {.cpp}
+    *this = basic_json(type());
+    @endcode
+
+    @liveexample{The example below shows the effect of `clear()` to different
+    JSON types.,clear}
+
+    @complexity Linear in the size of the JSON value.
+
+    @iterators All iterators, pointers and references related to this container
+               are invalidated.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @sa @ref basic_json(value_t) -- constructor that creates an object with the
+        same value than calling `clear()`
+
+    @since version 1.0.0
+    */
+    void clear() noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_value.number_integer = 0;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_value.number_unsigned = 0;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_value.number_float = 0.0;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_value.boolean = false;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_value.string->clear();
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_value.binary->clear();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_value.array->clear();
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_value.object->clear();
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @brief add an object to an array
+
+    Appends the given element @a val to the end of the JSON value. If the
+    function is called on a JSON null value, an empty array is created before
+    appending @a val.
+
+    @param[in] val the value to add to the JSON array
+
+    @throw type_error.308 when called on a type other than JSON array or
+    null; example: `"cannot use push_back() with number"`
+
+    @complexity Amortized constant.
+
+    @liveexample{The example shows how `push_back()` and `+=` can be used to
+    add elements to a JSON array. Note how the `null` value was silently
+    converted to a JSON array.,push_back}
+
+    @since version 1.0.0
+    */
+    void push_back(basic_json&& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array (move semantics)
+        m_value.array->push_back(std::move(val));
+        // if val is moved from, basic_json move constructor marks it null so we do not call the destructor
+    }
+
+    /*!
+    @brief add an object to an array
+    @copydoc push_back(basic_json&&)
+    */
+    reference operator+=(basic_json&& val)
+    {
+        push_back(std::move(val));
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an array
+    @copydoc push_back(basic_json&&)
+    */
+    void push_back(const basic_json& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array
+        m_value.array->push_back(val);
+    }
+
+    /*!
+    @brief add an object to an array
+    @copydoc push_back(basic_json&&)
+    */
+    reference operator+=(const basic_json& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an object
+
+    Inserts the given element @a val to the JSON object. If the function is
+    called on a JSON null value, an empty object is created before inserting
+    @a val.
+
+    @param[in] val the value to add to the JSON object
+
+    @throw type_error.308 when called on a type other than JSON object or
+    null; example: `"cannot use push_back() with number"`
+
+    @complexity Logarithmic in the size of the container, O(log(`size()`)).
+
+    @liveexample{The example shows how `push_back()` and `+=` can be used to
+    add elements to a JSON object. Note how the `null` value was silently
+    converted to a JSON object.,push_back__object_t__value}
+
+    @since version 1.0.0
+    */
+    void push_back(const typename object_t::value_type& val)
+    {
+        // push_back only works for null objects or objects
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
+        {
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
+        }
+
+        // transform null object into an object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add element to array
+        m_value.object->insert(val);
+    }
+
+    /*!
+    @brief add an object to an object
+    @copydoc push_back(const typename object_t::value_type&)
+    */
+    reference operator+=(const typename object_t::value_type& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an object
+
+    This function allows to use `push_back` with an initializer list. In case
+
+    1. the current value is an object,
+    2. the initializer list @a init contains only two elements, and
+    3. the first element of @a init is a string,
+
+    @a init is converted into an object element and added using
+    @ref push_back(const typename object_t::value_type&). Otherwise, @a init
+    is converted to a JSON value and added using @ref push_back(basic_json&&).
+
+    @param[in] init  an initializer list
+
+    @complexity Linear in the size of the initializer list @a init.
+
+    @note This function is required to resolve an ambiguous overload error,
+          because pairs like `{"key", "value"}` can be both interpreted as
+          `object_t::value_type` or `std::initializer_list<basic_json>`, see
+          https://github.com/nlohmann/json/issues/235 for more information.
+
+    @liveexample{The example shows how initializer lists are treated as
+    objects when possible.,push_back__initializer_list}
+    */
+    void push_back(initializer_list_t init)
+    {
+        if (is_object() && init.size() == 2 && (*init.begin())->is_string())
+        {
+            basic_json&& key = init.begin()->moved_or_copied();
+            push_back(typename object_t::value_type(
+                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
+        }
+        else
+        {
+            push_back(basic_json(init));
+        }
+    }
+
+    /*!
+    @brief add an object to an object
+    @copydoc push_back(initializer_list_t)
+    */
+    reference operator+=(initializer_list_t init)
+    {
+        push_back(init);
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an array
+
+    Creates a JSON value from the passed parameters @a args to the end of the
+    JSON value. If the function is called on a JSON null value, an empty array
+    is created before appending the value created from @a args.
+
+    @param[in] args arguments to forward to a constructor of @ref basic_json
+    @tparam Args compatible types to create a @ref basic_json object
+
+    @return reference to the inserted element
+
+    @throw type_error.311 when called on a type other than JSON array or
+    null; example: `"cannot use emplace_back() with number"`
+
+    @complexity Amortized constant.
+
+    @liveexample{The example shows how `push_back()` can be used to add
+    elements to a JSON array. Note how the `null` value was silently converted
+    to a JSON array.,emplace_back}
+
+    @since version 2.0.8, returns reference since 3.7.0
+    */
+    template<class... Args>
+    reference emplace_back(Args&& ... args)
+    {
+        // emplace_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name())));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array (perfect forwarding)
+#ifdef JSON_HAS_CPP_17
+        return m_value.array->emplace_back(std::forward<Args>(args)...);
+#else
+        m_value.array->emplace_back(std::forward<Args>(args)...);
+        return m_value.array->back();
+#endif
+    }
+
+    /*!
+    @brief add an object to an object if key does not exist
+
+    Inserts a new element into a JSON object constructed in-place with the
+    given @a args if there is no element with the key in the container. If the
+    function is called on a JSON null value, an empty object is created before
+    appending the value created from @a args.
+
+    @param[in] args arguments to forward to a constructor of @ref basic_json
+    @tparam Args compatible types to create a @ref basic_json object
+
+    @return a pair consisting of an iterator to the inserted element, or the
+            already-existing element if no insertion happened, and a bool
+            denoting whether the insertion took place.
+
+    @throw type_error.311 when called on a type other than JSON object or
+    null; example: `"cannot use emplace() with number"`
+
+    @complexity Logarithmic in the size of the container, O(log(`size()`)).
+
+    @liveexample{The example shows how `emplace()` can be used to add elements
+    to a JSON object. Note how the `null` value was silently converted to a
+    JSON object. Further note how no value is added if there was already one
+    value stored with the same key.,emplace}
+
+    @since version 2.0.8
+    */
+    template<class... Args>
+    std::pair<iterator, bool> emplace(Args&& ... args)
+    {
+        // emplace only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
+        {
+            JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name())));
+        }
+
+        // transform null object into an object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add element to array (perfect forwarding)
+        auto res = m_value.object->emplace(std::forward<Args>(args)...);
+        // create result iterator and set iterator to the result of emplace
+        auto it = begin();
+        it.m_it.object_iterator = res.first;
+
+        // return pair of iterator and boolean
+        return {it, res.second};
+    }
+
+    /// Helper for insertion of an iterator
+    /// @note: This uses std::distance to support GCC 4.8,
+    ///        see https://github.com/nlohmann/json/pull/1257
+    template<typename... Args>
+    iterator insert_iterator(const_iterator pos, Args&& ... args)
+    {
+        iterator result(this);
+        JSON_ASSERT(m_value.array != nullptr);
+
+        auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
+        m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
+        result.m_it.array_iterator = m_value.array->begin() + insert_pos;
+
+        // This could have been written as:
+        // result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
+        // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
+
+        return result;
+    }
+
+    /*!
+    @brief inserts element
+
+    Inserts element @a val before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] val element to insert
+    @return iterator pointing to the inserted @a val.
+
+    @throw type_error.309 if called on JSON values other than arrays;
+    example: `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
+    example: `"iterator does not fit current value"`
+
+    @complexity Constant plus linear in the distance between @a pos and end of
+    the container.
+
+    @liveexample{The example shows how `insert()` is used.,insert}
+
+    @since version 1.0.0
+    */
+    iterator insert(const_iterator pos, const basic_json& val)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, val);
+        }
+
+        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief inserts element
+    @copydoc insert(const_iterator, const basic_json&)
+    */
+    iterator insert(const_iterator pos, basic_json&& val)
+    {
+        return insert(pos, val);
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts @a cnt copies of @a val before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] cnt number of copies of @a val to insert
+    @param[in] val element to insert
+    @return iterator pointing to the first element inserted, or @a pos if
+    `cnt==0`
+
+    @throw type_error.309 if called on JSON values other than arrays; example:
+    `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
+    example: `"iterator does not fit current value"`
+
+    @complexity Linear in @a cnt plus linear in the distance between @a pos
+    and end of the container.
+
+    @liveexample{The example shows how `insert()` is used.,insert__count}
+
+    @since version 1.0.0
+    */
+    iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, cnt, val);
+        }
+
+        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts elements from range `[first, last)` before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] first begin of the range of elements to insert
+    @param[in] last end of the range of elements to insert
+
+    @throw type_error.309 if called on JSON values other than arrays; example:
+    `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
+    example: `"iterator does not fit current value"`
+    @throw invalid_iterator.210 if @a first and @a last do not belong to the
+    same JSON value; example: `"iterators do not fit"`
+    @throw invalid_iterator.211 if @a first or @a last are iterators into
+    container for which insert is called; example: `"passed iterators may not
+    belong to container"`
+
+    @return iterator pointing to the first element inserted, or @a pos if
+    `first==last`
+
+    @complexity Linear in `std::distance(first, last)` plus linear in the
+    distance between @a pos and end of the container.
+
+    @liveexample{The example shows how `insert()` is used.,insert__range}
+
+    @since version 1.0.0
+    */
+    iterator insert(const_iterator pos, const_iterator first, const_iterator last)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        {
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
+        {
+            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container"));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts elements from initializer list @a ilist before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] ilist initializer list to insert the values from
+
+    @throw type_error.309 if called on JSON values other than arrays; example:
+    `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
+    example: `"iterator does not fit current value"`
+
+    @return iterator pointing to the first element inserted, or @a pos if
+    `ilist` is empty
+
+    @complexity Linear in `ilist.size()` plus linear in the distance between
+    @a pos and end of the container.
+
+    @liveexample{The example shows how `insert()` is used.,insert__ilist}
+
+    @since version 1.0.0
+    */
+    iterator insert(const_iterator pos, initializer_list_t ilist)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        {
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, ilist.begin(), ilist.end());
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts elements from range `[first, last)`.
+
+    @param[in] first begin of the range of elements to insert
+    @param[in] last end of the range of elements to insert
+
+    @throw type_error.309 if called on JSON values other than objects; example:
+    `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if iterator @a first or @a last does does not
+    point to an object; example: `"iterators first and last must point to
+    objects"`
+    @throw invalid_iterator.210 if @a first and @a last do not belong to the
+    same JSON value; example: `"iterators do not fit"`
+
+    @complexity Logarithmic: `O(N*log(size() + N))`, where `N` is the number
+    of elements to insert.
+
+    @liveexample{The example shows how `insert()` is used.,insert__range_object}
+
+    @since version 3.0.0
+    */
+    void insert(const_iterator first, const_iterator last)
+    {
+        // insert only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
+        }
+
+        m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
+    }
+
+    /*!
+    @brief updates a JSON object from another object, overwriting existing keys
+
+    Inserts all values from JSON object @a j and overwrites existing keys.
+
+    @param[in] j  JSON object to read values from
+
+    @throw type_error.312 if called on JSON values other than objects; example:
+    `"cannot use update() with string"`
+
+    @complexity O(N*log(size() + N)), where N is the number of elements to
+                insert.
+
+    @liveexample{The example shows how `update()` is used.,update}
+
+    @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update
+
+    @since version 3.0.0
+    */
+    void update(const_reference j)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
+        }
+        if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
+        {
+            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name())));
+        }
+
+        for (auto it = j.cbegin(); it != j.cend(); ++it)
+        {
+            m_value.object->operator[](it.key()) = it.value();
+        }
+    }
+
+    /*!
+    @brief updates a JSON object from another object, overwriting existing keys
+
+    Inserts all values from from range `[first, last)` and overwrites existing
+    keys.
+
+    @param[in] first begin of the range of elements to insert
+    @param[in] last end of the range of elements to insert
+
+    @throw type_error.312 if called on JSON values other than objects; example:
+    `"cannot use update() with string"`
+    @throw invalid_iterator.202 if iterator @a first or @a last does does not
+    point to an object; example: `"iterators first and last must point to
+    objects"`
+    @throw invalid_iterator.210 if @a first and @a last do not belong to the
+    same JSON value; example: `"iterators do not fit"`
+
+    @complexity O(N*log(size() + N)), where N is the number of elements to
+                insert.
+
+    @liveexample{The example shows how `update()` is used__range.,update}
+
+    @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update
+
+    @since version 3.0.0
+    */
+    void update(const_iterator first, const_iterator last)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()
+                                 || !last.m_object->is_object()))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
+        }
+
+        for (auto it = first; it != last; ++it)
+        {
+            m_value.object->operator[](it.key()) = it.value();
+        }
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of the JSON value with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other JSON value to exchange the contents with
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how JSON values can be swapped with
+    `swap()`.,swap__reference}
+
+    @since version 1.0.0
+    */
+    void swap(reference other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        std::swap(m_type, other.m_type);
+        std::swap(m_value, other.m_value);
+        assert_invariant();
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of the JSON value from @a left with those of @a right. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated. implemented as a friend function callable via ADL.
+
+    @param[in,out] left JSON value to exchange the contents with
+    @param[in,out] right JSON value to exchange the contents with
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how JSON values can be swapped with
+    `swap()`.,swap__reference}
+
+    @since version 1.0.0
+    */
+    friend void swap(reference left, reference right) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        left.swap(right);
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON array with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other array to exchange the contents with
+
+    @throw type_error.310 when JSON value is not an array; example: `"cannot
+    use swap() with string"`
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how arrays can be swapped with
+    `swap()`.,swap__array_t}
+
+    @since version 1.0.0
+    */
+    void swap(array_t& other)
+    {
+        // swap only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            std::swap(*(m_value.array), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON object with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other object to exchange the contents with
+
+    @throw type_error.310 when JSON value is not an object; example:
+    `"cannot use swap() with string"`
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how objects can be swapped with
+    `swap()`.,swap__object_t}
+
+    @since version 1.0.0
+    */
+    void swap(object_t& other)
+    {
+        // swap only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            std::swap(*(m_value.object), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON string with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other string to exchange the contents with
+
+    @throw type_error.310 when JSON value is not a string; example: `"cannot
+    use swap() with boolean"`
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how strings can be swapped with
+    `swap()`.,swap__string_t}
+
+    @since version 1.0.0
+    */
+    void swap(string_t& other)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_string()))
+        {
+            std::swap(*(m_value.string), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON string with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other binary to exchange the contents with
+
+    @throw type_error.310 when JSON value is not a string; example: `"cannot
+    use swap() with boolean"`
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how strings can be swapped with
+    `swap()`.,swap__binary_t}
+
+    @since version 3.8.0
+    */
+    void swap(binary_t& other)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_binary()))
+        {
+            std::swap(*(m_value.binary), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+        }
+    }
+
+    /// @copydoc swap(binary_t)
+    void swap(typename binary_t::container_type& other)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_binary()))
+        {
+            std::swap(*(m_value.binary), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+        }
+    }
+
+    /// @}
+
+  public:
+    //////////////////////////////////////////
+    // lexicographical comparison operators //
+    //////////////////////////////////////////
+
+    /// @name lexicographical comparison operators
+    /// @{
+
+    /*!
+    @brief comparison: equal
+
+    Compares two JSON values for equality according to the following rules:
+    - Two JSON values are equal if (1) they are from the same type and (2)
+      their stored values are the same according to their respective
+      `operator==`.
+    - Integer and floating-point numbers are automatically converted before
+      comparison. Note that two NaN values are always treated as unequal.
+    - Two JSON null values are equal.
+
+    @note Floating-point inside JSON values numbers are compared with
+    `json::number_float_t::operator==` which is `double::operator==` by
+    default. To compare floating-point while respecting an epsilon, an alternative
+    [comparison function](https://github.com/mariokonrad/marnav/blob/master/include/marnav/math/floatingpoint.hpp#L34-#L39)
+    could be used, for instance
+    @code {.cpp}
+    template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value, T>::type>
+    inline bool is_same(T a, T b, T epsilon = std::numeric_limits<T>::epsilon()) noexcept
+    {
+        return std::abs(a - b) <= epsilon;
+    }
+    @endcode
+    Or you can self-defined operator equal function like this:
+    @code {.cpp}
+    bool my_equal(const_reference lhs, const_reference rhs) {
+    const auto lhs_type lhs.type();
+    const auto rhs_type rhs.type();
+    if (lhs_type == rhs_type) {
+        switch(lhs_type)
+            // self_defined case
+            case value_t::number_float:
+                return std::abs(lhs - rhs) <= std::numeric_limits<float>::epsilon();
+            // other cases remain the same with the original
+            ...
+    }
+    ...
+    }
+    @endcode
+
+    @note NaN values never compare equal to themselves or to other NaN values.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether the values @a lhs and @a rhs are equal
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @complexity Linear.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__equal}
+
+    @since version 1.0.0
+    */
+    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
+    {
+        const auto lhs_type = lhs.type();
+        const auto rhs_type = rhs.type();
+
+        if (lhs_type == rhs_type)
+        {
+            switch (lhs_type)
+            {
+                case value_t::array:
+                    return *lhs.m_value.array == *rhs.m_value.array;
+
+                case value_t::object:
+                    return *lhs.m_value.object == *rhs.m_value.object;
+
+                case value_t::null:
+                    return true;
+
+                case value_t::string:
+                    return *lhs.m_value.string == *rhs.m_value.string;
+
+                case value_t::boolean:
+                    return lhs.m_value.boolean == rhs.m_value.boolean;
+
+                case value_t::number_integer:
+                    return lhs.m_value.number_integer == rhs.m_value.number_integer;
+
+                case value_t::number_unsigned:
+                    return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
+
+                case value_t::number_float:
+                    return lhs.m_value.number_float == rhs.m_value.number_float;
+
+                case value_t::binary:
+                    return *lhs.m_value.binary == *rhs.m_value.binary;
+
+                default:
+                    return false;
+            }
+        }
+        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
+        {
+            return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
+        }
+        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
+        }
+        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
+        {
+            return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
+        }
+        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
+        }
+
+        return false;
+    }
+
+    /*!
+    @brief comparison: equal
+    @copydoc operator==(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs == basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: equal
+    @copydoc operator==(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) == rhs;
+    }
+
+    /*!
+    @brief comparison: not equal
+
+    Compares two JSON values for inequality by calculating `not (lhs == rhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether the values @a lhs and @a rhs are not equal
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__notequal}
+
+    @since version 1.0.0
+    */
+    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return !(lhs == rhs);
+    }
+
+    /*!
+    @brief comparison: not equal
+    @copydoc operator!=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs != basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: not equal
+    @copydoc operator!=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) != rhs;
+    }
+
+    /*!
+    @brief comparison: less than
+
+    Compares whether one JSON value @a lhs is less than another JSON value @a
+    rhs according to the following rules:
+    - If @a lhs and @a rhs have the same type, the values are compared using
+      the default `<` operator.
+    - Integer and floating-point numbers are automatically converted before
+      comparison
+    - In case @a lhs and @a rhs have different types, the values are ignored
+      and the order of the types is considered, see
+      @ref operator<(const value_t, const value_t).
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is less than @a rhs
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__less}
+
+    @since version 1.0.0
+    */
+    friend bool operator<(const_reference lhs, const_reference rhs) noexcept
+    {
+        const auto lhs_type = lhs.type();
+        const auto rhs_type = rhs.type();
+
+        if (lhs_type == rhs_type)
+        {
+            switch (lhs_type)
+            {
+                case value_t::array:
+                    // note parentheses are necessary, see
+                    // https://github.com/nlohmann/json/issues/1530
+                    return (*lhs.m_value.array) < (*rhs.m_value.array);
+
+                case value_t::object:
+                    return (*lhs.m_value.object) < (*rhs.m_value.object);
+
+                case value_t::null:
+                    return false;
+
+                case value_t::string:
+                    return (*lhs.m_value.string) < (*rhs.m_value.string);
+
+                case value_t::boolean:
+                    return (lhs.m_value.boolean) < (rhs.m_value.boolean);
+
+                case value_t::number_integer:
+                    return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
+
+                case value_t::number_unsigned:
+                    return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
+
+                case value_t::number_float:
+                    return (lhs.m_value.number_float) < (rhs.m_value.number_float);
+
+                case value_t::binary:
+                    return (*lhs.m_value.binary) < (*rhs.m_value.binary);
+
+                default:
+                    return false;
+            }
+        }
+        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
+        {
+            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
+        }
+        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
+        }
+        else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
+        }
+        else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
+        {
+            return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
+        }
+
+        // We only reach this line if we cannot compare values. In that case,
+        // we compare types. Note we have to call the operator explicitly,
+        // because MSVC has problems otherwise.
+        return operator<(lhs_type, rhs_type);
+    }
+
+    /*!
+    @brief comparison: less than
+    @copydoc operator<(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs < basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: less than
+    @copydoc operator<(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) < rhs;
+    }
+
+    /*!
+    @brief comparison: less than or equal
+
+    Compares whether one JSON value @a lhs is less than or equal to another
+    JSON value by calculating `not (rhs < lhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is less than or equal to @a rhs
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__greater}
+
+    @since version 1.0.0
+    */
+    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return !(rhs < lhs);
+    }
+
+    /*!
+    @brief comparison: less than or equal
+    @copydoc operator<=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs <= basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: less than or equal
+    @copydoc operator<=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) <= rhs;
+    }
+
+    /*!
+    @brief comparison: greater than
+
+    Compares whether one JSON value @a lhs is greater than another
+    JSON value by calculating `not (lhs <= rhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is greater than to @a rhs
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__lessequal}
+
+    @since version 1.0.0
+    */
+    friend bool operator>(const_reference lhs, const_reference rhs) noexcept
+    {
+        return !(lhs <= rhs);
+    }
+
+    /*!
+    @brief comparison: greater than
+    @copydoc operator>(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs > basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: greater than
+    @copydoc operator>(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) > rhs;
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+
+    Compares whether one JSON value @a lhs is greater than or equal to another
+    JSON value by calculating `not (lhs < rhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is greater than or equal to @a rhs
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__greaterequal}
+
+    @since version 1.0.0
+    */
+    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return !(lhs < rhs);
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+    @copydoc operator>=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs >= basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+    @copydoc operator>=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) >= rhs;
+    }
+
+    /// @}
+
+    ///////////////////
+    // serialization //
+    ///////////////////
+
+    /// @name serialization
+    /// @{
+
+    /*!
+    @brief serialize to stream
+
+    Serialize the given JSON value @a j to the output stream @a o. The JSON
+    value will be serialized using the @ref dump member function.
+
+    - The indentation of the output can be controlled with the member variable
+      `width` of the output stream @a o. For instance, using the manipulator
+      `std::setw(4)` on @a o sets the indentation level to `4` and the
+      serialization result is the same as calling `dump(4)`.
+
+    - The indentation character can be controlled with the member variable
+      `fill` of the output stream @a o. For instance, the manipulator
+      `std::setfill('\\t')` sets indentation to use a tab character rather than
+      the default space character.
+
+    @param[in,out] o  stream to serialize to
+    @param[in] j  JSON value to serialize
+
+    @return the stream @a o
+
+    @throw type_error.316 if a string stored inside the JSON value is not
+                          UTF-8 encoded
+
+    @complexity Linear.
+
+    @liveexample{The example below shows the serialization with different
+    parameters to `width` to adjust the indentation level.,operator_serialize}
+
+    @since version 1.0.0; indentation character added in version 3.0.0
+    */
+    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
+    {
+        // read width member and use it as indentation parameter if nonzero
+        const bool pretty_print = o.width() > 0;
+        const auto indentation = pretty_print ? o.width() : 0;
+
+        // reset width to 0 for subsequent calls to this stream
+        o.width(0);
+
+        // do the actual serialization
+        serializer s(detail::output_adapter<char>(o), o.fill());
+        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
+        return o;
+    }
+
+    /*!
+    @brief serialize to stream
+    @deprecated This stream operator is deprecated and will be removed in
+                future 4.0.0 of the library. Please use
+                @ref operator<<(std::ostream&, const basic_json&)
+                instead; that is, replace calls like `j >> o;` with `o << j;`.
+    @since version 1.0.0; deprecated since version 3.0.0
+    */
+    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
+    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
+    {
+        return o << j;
+    }
+
+    /// @}
+
+
+    /////////////////////
+    // deserialization //
+    /////////////////////
+
+    /// @name deserialization
+    /// @{
+
+    /*!
+    @brief deserialize from a compatible input
+
+    @tparam InputType A compatible input, for instance
+    - an std::istream object
+    - a FILE pointer
+    - a C-style array of characters
+    - a pointer to a null-terminated string of single byte characters
+    - an object obj for which begin(obj) and end(obj) produces a valid pair of
+      iterators.
+
+    @param[in] i  input to read from
+    @param[in] cb  a parser callback function of type @ref parser_callback_t
+    which is used to control the deserialization by filtering unwanted values
+    (optional)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+    @param[in] ignore_comments  whether comments should be ignored and treated
+    like whitespace (true) or yield a parse error (true); (optional, false by
+    default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.101 if a parse error occurs; example: `""unexpected end
+    of input; expected string literal""`
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser. The complexity can be higher if the parser callback function
+    @a cb or reading from the input @a i has a super-linear complexity.
+
+    @note A UTF-8 byte order mark is silently ignored.
+
+    @liveexample{The example below demonstrates the `parse()` function reading
+    from an array.,parse__array__parser_callback_t}
+
+    @liveexample{The example below demonstrates the `parse()` function with
+    and without callback function.,parse__string__parser_callback_t}
+
+    @liveexample{The example below demonstrates the `parse()` function with
+    and without callback function.,parse__istream__parser_callback_t}
+
+    @liveexample{The example below demonstrates the `parse()` function reading
+    from a contiguous container.,parse__contiguouscontainer__parser_callback_t}
+
+    @since version 2.0.3 (contiguous containers); version 3.9.0 allowed to
+    ignore comments.
+    */
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(InputType&& i,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    /*!
+    @brief deserialize from a pair of character iterators
+
+    The value_type of the iterator must be a integral type with size of 1, 2 or
+    4 bytes, which will be interpreted respectively as UTF-8, UTF-16 and UTF-32.
+
+    @param[in] first iterator to start of character range
+    @param[in] last  iterator to end of character range
+    @param[in] cb  a parser callback function of type @ref parser_callback_t
+    which is used to control the deserialization by filtering unwanted values
+    (optional)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+    @param[in] ignore_comments  whether comments should be ignored and treated
+    like whitespace (true) or yield a parse error (true); (optional, false by
+    default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.101 if a parse error occurs; example: `""unexpected end
+    of input; expected string literal""`
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+    */
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(IteratorType first,
+                            IteratorType last,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
+    static basic_json parse(detail::span_input_adapter&& i,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    /*!
+    @brief check if the input is valid JSON
+
+    Unlike the @ref parse(InputType&&, const parser_callback_t,const bool)
+    function, this function neither throws an exception in case of invalid JSON
+    input (i.e., a parse error) nor creates diagnostic information.
+
+    @tparam InputType A compatible input, for instance
+    - an std::istream object
+    - a FILE pointer
+    - a C-style array of characters
+    - a pointer to a null-terminated string of single byte characters
+    - an object obj for which begin(obj) and end(obj) produces a valid pair of
+      iterators.
+
+    @param[in] i input to read from
+    @param[in] ignore_comments  whether comments should be ignored and treated
+    like whitespace (true) or yield a parse error (true); (optional, false by
+    default)
+
+    @return Whether the input read from @a i is valid JSON.
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser.
+
+    @note A UTF-8 byte order mark is silently ignored.
+
+    @liveexample{The example below demonstrates the `accept()` function reading
+    from a string.,accept__string}
+    */
+    template<typename InputType>
+    static bool accept(InputType&& i,
+                       const bool ignore_comments = false)
+    {
+        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
+    }
+
+    template<typename IteratorType>
+    static bool accept(IteratorType first, IteratorType last,
+                       const bool ignore_comments = false)
+    {
+        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
+    static bool accept(detail::span_input_adapter&& i,
+                       const bool ignore_comments = false)
+    {
+        return parser(i.get(), nullptr, false, ignore_comments).accept(true);
+    }
+
+    /*!
+    @brief generate SAX events
+
+    The SAX event lister must follow the interface of @ref json_sax.
+
+    This function reads from a compatible input. Examples are:
+    - an std::istream object
+    - a FILE pointer
+    - a C-style array of characters
+    - a pointer to a null-terminated string of single byte characters
+    - an object obj for which begin(obj) and end(obj) produces a valid pair of
+      iterators.
+
+    @param[in] i  input to read from
+    @param[in,out] sax  SAX event listener
+    @param[in] format  the format to parse (JSON, CBOR, MessagePack, or UBJSON)
+    @param[in] strict  whether the input has to be consumed completely
+    @param[in] ignore_comments  whether comments should be ignored and treated
+    like whitespace (true) or yield a parse error (true); (optional, false by
+    default); only applies to the JSON file format.
+
+    @return return value of the last processed SAX event
+
+    @throw parse_error.101 if a parse error occurs; example: `""unexpected end
+    of input; expected string literal""`
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser. The complexity can be higher if the SAX consumer @a sax has
+    a super-linear complexity.
+
+    @note A UTF-8 byte order mark is silently ignored.
+
+    @liveexample{The example below demonstrates the `sax_parse()` function
+    reading from string and processing the events with a user-defined SAX
+    event consumer.,sax_parse}
+
+    @since version 3.2.0
+    */
+    template <typename InputType, typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(InputType&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
+    }
+
+    template<class IteratorType, class SAX>
+    JSON_HEDLEY_NON_NULL(3)
+    static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
+    }
+
+    template <typename SAX>
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = i.get();
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
+    }
+
+    /*!
+    @brief deserialize from stream
+    @deprecated This stream operator is deprecated and will be removed in
+                version 4.0.0 of the library. Please use
+                @ref operator>>(std::istream&, basic_json&)
+                instead; that is, replace calls like `j << i;` with `i >> j;`.
+    @since version 1.0.0; deprecated since version 3.0.0
+    */
+    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
+    friend std::istream& operator<<(basic_json& j, std::istream& i)
+    {
+        return operator>>(i, j);
+    }
+
+    /*!
+    @brief deserialize from stream
+
+    Deserializes an input stream to a JSON value.
+
+    @param[in,out] i  input stream to read a serialized JSON value from
+    @param[in,out] j  JSON value to write the deserialized input to
+
+    @throw parse_error.101 in case of an unexpected token
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser.
+
+    @note A UTF-8 byte order mark is silently ignored.
+
+    @liveexample{The example below shows how a JSON value is constructed by
+    reading a serialization from a stream.,operator_deserialize}
+
+    @sa parse(std::istream&, const parser_callback_t) for a variant with a
+    parser callback function to filter values while parsing
+
+    @since version 1.0.0
+    */
+    friend std::istream& operator>>(std::istream& i, basic_json& j)
+    {
+        parser(detail::input_adapter(i)).parse(false, j);
+        return i;
+    }
+
+    /// @}
+
+    ///////////////////////////
+    // convenience functions //
+    ///////////////////////////
+
+    /*!
+    @brief return the type as string
+
+    Returns the type name as string to be used in error messages - usually to
+    indicate that a function was called on a wrong JSON type.
+
+    @return a string representation of a the @a m_type member:
+            Value type  | return value
+            ----------- | -------------
+            null        | `"null"`
+            boolean     | `"boolean"`
+            string      | `"string"`
+            number      | `"number"` (for all number types)
+            object      | `"object"`
+            array       | `"array"`
+            binary      | `"binary"`
+            discarded   | `"discarded"`
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies `type_name()` for all JSON
+    types.,type_name}
+
+    @sa @ref type() -- return the type of the JSON value
+    @sa @ref operator value_t() -- return the type of the JSON value (implicit)
+
+    @since version 1.0.0, public since 2.1.0, `const char*` and `noexcept`
+    since 3.0.0
+    */
+    JSON_HEDLEY_RETURNS_NON_NULL
+    const char* type_name() const noexcept
+    {
+        {
+            switch (m_type)
+            {
+                case value_t::null:
+                    return "null";
+                case value_t::object:
+                    return "object";
+                case value_t::array:
+                    return "array";
+                case value_t::string:
+                    return "string";
+                case value_t::boolean:
+                    return "boolean";
+                case value_t::binary:
+                    return "binary";
+                case value_t::discarded:
+                    return "discarded";
+                default:
+                    return "number";
+            }
+        }
+    }
+
+
+  private:
+    //////////////////////
+    // member variables //
+    //////////////////////
+
+    /// the type of the current element
+    value_t m_type = value_t::null;
+
+    /// the value of the current element
+    json_value m_value = {};
+
+    //////////////////////////////////////////
+    // binary serialization/deserialization //
+    //////////////////////////////////////////
+
+    /// @name binary serialization/deserialization support
+    /// @{
+
+  public:
+    /*!
+    @brief create a CBOR serialization of a given JSON value
+
+    Serializes a given JSON value @a j to a byte vector using the CBOR (Concise
+    Binary Object Representation) serialization format. CBOR is a binary
+    serialization format which aims to be more compact than JSON itself, yet
+    more efficient to parse.
+
+    The library uses the following mapping from JSON values types to
+    CBOR types according to the CBOR specification (RFC 7049):
+
+    JSON value type | value/range                                | CBOR type                          | first byte
+    --------------- | ------------------------------------------ | ---------------------------------- | ---------------
+    null            | `null`                                     | Null                               | 0xF6
+    boolean         | `true`                                     | True                               | 0xF5
+    boolean         | `false`                                    | False                              | 0xF4
+    number_integer  | -9223372036854775808..-2147483649          | Negative integer (8 bytes follow)  | 0x3B
+    number_integer  | -2147483648..-32769                        | Negative integer (4 bytes follow)  | 0x3A
+    number_integer  | -32768..-129                               | Negative integer (2 bytes follow)  | 0x39
+    number_integer  | -128..-25                                  | Negative integer (1 byte follow)   | 0x38
+    number_integer  | -24..-1                                    | Negative integer                   | 0x20..0x37
+    number_integer  | 0..23                                      | Integer                            | 0x00..0x17
+    number_integer  | 24..255                                    | Unsigned integer (1 byte follow)   | 0x18
+    number_integer  | 256..65535                                 | Unsigned integer (2 bytes follow)  | 0x19
+    number_integer  | 65536..4294967295                          | Unsigned integer (4 bytes follow)  | 0x1A
+    number_integer  | 4294967296..18446744073709551615           | Unsigned integer (8 bytes follow)  | 0x1B
+    number_unsigned | 0..23                                      | Integer                            | 0x00..0x17
+    number_unsigned | 24..255                                    | Unsigned integer (1 byte follow)   | 0x18
+    number_unsigned | 256..65535                                 | Unsigned integer (2 bytes follow)  | 0x19
+    number_unsigned | 65536..4294967295                          | Unsigned integer (4 bytes follow)  | 0x1A
+    number_unsigned | 4294967296..18446744073709551615           | Unsigned integer (8 bytes follow)  | 0x1B
+    number_float    | *any value representable by a float*       | Single-Precision Float             | 0xFA
+    number_float    | *any value NOT representable by a float*   | Double-Precision Float             | 0xFB
+    string          | *length*: 0..23                            | UTF-8 string                       | 0x60..0x77
+    string          | *length*: 23..255                          | UTF-8 string (1 byte follow)       | 0x78
+    string          | *length*: 256..65535                       | UTF-8 string (2 bytes follow)      | 0x79
+    string          | *length*: 65536..4294967295                | UTF-8 string (4 bytes follow)      | 0x7A
+    string          | *length*: 4294967296..18446744073709551615 | UTF-8 string (8 bytes follow)      | 0x7B
+    array           | *size*: 0..23                              | array                              | 0x80..0x97
+    array           | *size*: 23..255                            | array (1 byte follow)              | 0x98
+    array           | *size*: 256..65535                         | array (2 bytes follow)             | 0x99
+    array           | *size*: 65536..4294967295                  | array (4 bytes follow)             | 0x9A
+    array           | *size*: 4294967296..18446744073709551615   | array (8 bytes follow)             | 0x9B
+    object          | *size*: 0..23                              | map                                | 0xA0..0xB7
+    object          | *size*: 23..255                            | map (1 byte follow)                | 0xB8
+    object          | *size*: 256..65535                         | map (2 bytes follow)               | 0xB9
+    object          | *size*: 65536..4294967295                  | map (4 bytes follow)               | 0xBA
+    object          | *size*: 4294967296..18446744073709551615   | map (8 bytes follow)               | 0xBB
+    binary          | *size*: 0..23                              | byte string                        | 0x40..0x57
+    binary          | *size*: 23..255                            | byte string (1 byte follow)        | 0x58
+    binary          | *size*: 256..65535                         | byte string (2 bytes follow)       | 0x59
+    binary          | *size*: 65536..4294967295                  | byte string (4 bytes follow)       | 0x5A
+    binary          | *size*: 4294967296..18446744073709551615   | byte string (8 bytes follow)       | 0x5B
+
+    @note The mapping is **complete** in the sense that any JSON value type
+          can be converted to a CBOR value.
+
+    @note If NaN or Infinity are stored inside a JSON number, they are
+          serialized properly. This behavior differs from the @ref dump()
+          function which serializes NaN or Infinity to `null`.
+
+    @note The following CBOR types are not used in the conversion:
+          - UTF-8 strings terminated by "break" (0x7F)
+          - arrays terminated by "break" (0x9F)
+          - maps terminated by "break" (0xBF)
+          - byte strings terminated by "break" (0x5F)
+          - date/time (0xC0..0xC1)
+          - bignum (0xC2..0xC3)
+          - decimal fraction (0xC4)
+          - bigfloat (0xC5)
+          - expected conversions (0xD5..0xD7)
+          - simple values (0xE0..0xF3, 0xF8)
+          - undefined (0xF7)
+          - half-precision floats (0xF9)
+          - break (0xFF)
+
+    @param[in] j  JSON value to serialize
+    @return CBOR serialization as byte vector
+
+    @complexity Linear in the size of the JSON value @a j.
+
+    @liveexample{The example shows the serialization of a JSON value to a byte
+    vector in CBOR format.,to_cbor}
+
+    @sa http://cbor.io
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
+        analogous deserialization
+    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
+    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
+             related UBJSON format
+
+    @since version 2.0.9; compact representation of floating-point numbers
+           since version 3.8.0
+    */
+    static std::vector<uint8_t> to_cbor(const basic_json& j)
+    {
+        std::vector<uint8_t> result;
+        to_cbor(j, result);
+        return result;
+    }
+
+    static void to_cbor(const basic_json& j, detail::output_adapter<uint8_t> o)
+    {
+        binary_writer<uint8_t>(o).write_cbor(j);
+    }
+
+    static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_cbor(j);
+    }
+
+    /*!
+    @brief create a MessagePack serialization of a given JSON value
+
+    Serializes a given JSON value @a j to a byte vector using the MessagePack
+    serialization format. MessagePack is a binary serialization format which
+    aims to be more compact than JSON itself, yet more efficient to parse.
+
+    The library uses the following mapping from JSON values types to
+    MessagePack types according to the MessagePack specification:
+
+    JSON value type | value/range                       | MessagePack type | first byte
+    --------------- | --------------------------------- | ---------------- | ----------
+    null            | `null`                            | nil              | 0xC0
+    boolean         | `true`                            | true             | 0xC3
+    boolean         | `false`                           | false            | 0xC2
+    number_integer  | -9223372036854775808..-2147483649 | int64            | 0xD3
+    number_integer  | -2147483648..-32769               | int32            | 0xD2
+    number_integer  | -32768..-129                      | int16            | 0xD1
+    number_integer  | -128..-33                         | int8             | 0xD0
+    number_integer  | -32..-1                           | negative fixint  | 0xE0..0xFF
+    number_integer  | 0..127                            | positive fixint  | 0x00..0x7F
+    number_integer  | 128..255                          | uint 8           | 0xCC
+    number_integer  | 256..65535                        | uint 16          | 0xCD
+    number_integer  | 65536..4294967295                 | uint 32          | 0xCE
+    number_integer  | 4294967296..18446744073709551615  | uint 64          | 0xCF
+    number_unsigned | 0..127                            | positive fixint  | 0x00..0x7F
+    number_unsigned | 128..255                          | uint 8           | 0xCC
+    number_unsigned | 256..65535                        | uint 16          | 0xCD
+    number_unsigned | 65536..4294967295                 | uint 32          | 0xCE
+    number_unsigned | 4294967296..18446744073709551615  | uint 64          | 0xCF
+    number_float    | *any value representable by a float*     | float 32 | 0xCA
+    number_float    | *any value NOT representable by a float* | float 64 | 0xCB
+    string          | *length*: 0..31                   | fixstr           | 0xA0..0xBF
+    string          | *length*: 32..255                 | str 8            | 0xD9
+    string          | *length*: 256..65535              | str 16           | 0xDA
+    string          | *length*: 65536..4294967295       | str 32           | 0xDB
+    array           | *size*: 0..15                     | fixarray         | 0x90..0x9F
+    array           | *size*: 16..65535                 | array 16         | 0xDC
+    array           | *size*: 65536..4294967295         | array 32         | 0xDD
+    object          | *size*: 0..15                     | fix map          | 0x80..0x8F
+    object          | *size*: 16..65535                 | map 16           | 0xDE
+    object          | *size*: 65536..4294967295         | map 32           | 0xDF
+    binary          | *size*: 0..255                    | bin 8            | 0xC4
+    binary          | *size*: 256..65535                | bin 16           | 0xC5
+    binary          | *size*: 65536..4294967295         | bin 32           | 0xC6
+
+    @note The mapping is **complete** in the sense that any JSON value type
+          can be converted to a MessagePack value.
+
+    @note The following values can **not** be converted to a MessagePack value:
+          - strings with more than 4294967295 bytes
+          - byte strings with more than 4294967295 bytes
+          - arrays with more than 4294967295 elements
+          - objects with more than 4294967295 elements
+
+    @note Any MessagePack output created @ref to_msgpack can be successfully
+          parsed by @ref from_msgpack.
+
+    @note If NaN or Infinity are stored inside a JSON number, they are
+          serialized properly. This behavior differs from the @ref dump()
+          function which serializes NaN or Infinity to `null`.
+
+    @param[in] j  JSON value to serialize
+    @return MessagePack serialization as byte vector
+
+    @complexity Linear in the size of the JSON value @a j.
+
+    @liveexample{The example shows the serialization of a JSON value to a byte
+    vector in MessagePack format.,to_msgpack}
+
+    @sa http://msgpack.org
+    @sa @ref from_msgpack for the analogous deserialization
+    @sa @ref to_cbor(const basic_json& for the related CBOR format
+    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
+             related UBJSON format
+
+    @since version 2.0.9
+    */
+    static std::vector<uint8_t> to_msgpack(const basic_json& j)
+    {
+        std::vector<uint8_t> result;
+        to_msgpack(j, result);
+        return result;
+    }
+
+    static void to_msgpack(const basic_json& j, detail::output_adapter<uint8_t> o)
+    {
+        binary_writer<uint8_t>(o).write_msgpack(j);
+    }
+
+    static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_msgpack(j);
+    }
+
+    /*!
+    @brief create a UBJSON serialization of a given JSON value
+
+    Serializes a given JSON value @a j to a byte vector using the UBJSON
+    (Universal Binary JSON) serialization format. UBJSON aims to be more compact
+    than JSON itself, yet more efficient to parse.
+
+    The library uses the following mapping from JSON values types to
+    UBJSON types according to the UBJSON specification:
+
+    JSON value type | value/range                       | UBJSON type | marker
+    --------------- | --------------------------------- | ----------- | ------
+    null            | `null`                            | null        | `Z`
+    boolean         | `true`                            | true        | `T`
+    boolean         | `false`                           | false       | `F`
+    number_integer  | -9223372036854775808..-2147483649 | int64       | `L`
+    number_integer  | -2147483648..-32769               | int32       | `l`
+    number_integer  | -32768..-129                      | int16       | `I`
+    number_integer  | -128..127                         | int8        | `i`
+    number_integer  | 128..255                          | uint8       | `U`
+    number_integer  | 256..32767                        | int16       | `I`
+    number_integer  | 32768..2147483647                 | int32       | `l`
+    number_integer  | 2147483648..9223372036854775807   | int64       | `L`
+    number_unsigned | 0..127                            | int8        | `i`
+    number_unsigned | 128..255                          | uint8       | `U`
+    number_unsigned | 256..32767                        | int16       | `I`
+    number_unsigned | 32768..2147483647                 | int32       | `l`
+    number_unsigned | 2147483648..9223372036854775807   | int64       | `L`
+    number_unsigned | 2147483649..18446744073709551615  | high-precision | `H`
+    number_float    | *any value*                       | float64     | `D`
+    string          | *with shortest length indicator*  | string      | `S`
+    array           | *see notes on optimized format*   | array       | `[`
+    object          | *see notes on optimized format*   | map         | `{`
+
+    @note The mapping is **complete** in the sense that any JSON value type
+          can be converted to a UBJSON value.
+
+    @note The following values can **not** be converted to a UBJSON value:
+          - strings with more than 9223372036854775807 bytes (theoretical)
+
+    @note The following markers are not used in the conversion:
+          - `Z`: no-op values are not created.
+          - `C`: single-byte strings are serialized with `S` markers.
+
+    @note Any UBJSON output created @ref to_ubjson can be successfully parsed
+          by @ref from_ubjson.
+
+    @note If NaN or Infinity are stored inside a JSON number, they are
+          serialized properly. This behavior differs from the @ref dump()
+          function which serializes NaN or Infinity to `null`.
+
+    @note The optimized formats for containers are supported: Parameter
+          @a use_size adds size information to the beginning of a container and
+          removes the closing marker. Parameter @a use_type further checks
+          whether all elements of a container have the same type and adds the
+          type marker to the beginning of the container. The @a use_type
+          parameter must only be used together with @a use_size = true. Note
+          that @a use_size = true alone may result in larger representations -
+          the benefit of this parameter is that the receiving side is
+          immediately informed on the number of elements of the container.
+
+    @note If the JSON data contains the binary type, the value stored is a list
+          of integers, as suggested by the UBJSON documentation.  In particular,
+          this means that serialization and the deserialization of a JSON
+          containing binary values into UBJSON and back will result in a
+          different JSON object.
+
+    @param[in] j  JSON value to serialize
+    @param[in] use_size  whether to add size annotations to container types
+    @param[in] use_type  whether to add type annotations to container types
+                         (must be combined with @a use_size = true)
+    @return UBJSON serialization as byte vector
+
+    @complexity Linear in the size of the JSON value @a j.
+
+    @liveexample{The example shows the serialization of a JSON value to a byte
+    vector in UBJSON format.,to_ubjson}
+
+    @sa http://ubjson.org
+    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
+        analogous deserialization
+    @sa @ref to_cbor(const basic_json& for the related CBOR format
+    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
+
+    @since version 3.1.0
+    */
+    static std::vector<uint8_t> to_ubjson(const basic_json& j,
+                                          const bool use_size = false,
+                                          const bool use_type = false)
+    {
+        std::vector<uint8_t> result;
+        to_ubjson(j, result, use_size, use_type);
+        return result;
+    }
+
+    static void to_ubjson(const basic_json& j, detail::output_adapter<uint8_t> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<uint8_t>(o).write_ubjson(j, use_size, use_type);
+    }
+
+    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type);
+    }
+
+
+    /*!
+    @brief Serializes the given JSON object `j` to BSON and returns a vector
+           containing the corresponding BSON-representation.
+
+    BSON (Binary JSON) is a binary format in which zero or more ordered key/value pairs are
+    stored as a single entity (a so-called document).
+
+    The library uses the following mapping from JSON values types to BSON types:
+
+    JSON value type | value/range                       | BSON type   | marker
+    --------------- | --------------------------------- | ----------- | ------
+    null            | `null`                            | null        | 0x0A
+    boolean         | `true`, `false`                   | boolean     | 0x08
+    number_integer  | -9223372036854775808..-2147483649 | int64       | 0x12
+    number_integer  | -2147483648..2147483647           | int32       | 0x10
+    number_integer  | 2147483648..9223372036854775807   | int64       | 0x12
+    number_unsigned | 0..2147483647                     | int32       | 0x10
+    number_unsigned | 2147483648..9223372036854775807   | int64       | 0x12
+    number_unsigned | 9223372036854775808..18446744073709551615| --   | --
+    number_float    | *any value*                       | double      | 0x01
+    string          | *any value*                       | string      | 0x02
+    array           | *any value*                       | document    | 0x04
+    object          | *any value*                       | document    | 0x03
+    binary          | *any value*                       | binary      | 0x05
+
+    @warning The mapping is **incomplete**, since only JSON-objects (and things
+    contained therein) can be serialized to BSON.
+    Also, integers larger than 9223372036854775807 cannot be serialized to BSON,
+    and the keys may not contain U+0000, since they are serialized a
+    zero-terminated c-strings.
+
+    @throw out_of_range.407  if `j.is_number_unsigned() && j.get<std::uint64_t>() > 9223372036854775807`
+    @throw out_of_range.409  if a key in `j` contains a NULL (U+0000)
+    @throw type_error.317    if `!j.is_object()`
+
+    @pre The input `j` is required to be an object: `j.is_object() == true`.
+
+    @note Any BSON output created via @ref to_bson can be successfully parsed
+          by @ref from_bson.
+
+    @param[in] j  JSON value to serialize
+    @return BSON serialization as byte vector
+
+    @complexity Linear in the size of the JSON value @a j.
+
+    @liveexample{The example shows the serialization of a JSON value to a byte
+    vector in BSON format.,to_bson}
+
+    @sa http://bsonspec.org/spec.html
+    @sa @ref from_bson(detail::input_adapter&&, const bool strict) for the
+        analogous deserialization
+    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
+             related UBJSON format
+    @sa @ref to_cbor(const basic_json&) for the related CBOR format
+    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
+    */
+    static std::vector<uint8_t> to_bson(const basic_json& j)
+    {
+        std::vector<uint8_t> result;
+        to_bson(j, result);
+        return result;
+    }
+
+    /*!
+    @brief Serializes the given JSON object `j` to BSON and forwards the
+           corresponding BSON-representation to the given output_adapter `o`.
+    @param j The JSON object to convert to BSON.
+    @param o The output adapter that receives the binary BSON representation.
+    @pre The input `j` shall be an object: `j.is_object() == true`
+    @sa @ref to_bson(const basic_json&)
+    */
+    static void to_bson(const basic_json& j, detail::output_adapter<uint8_t> o)
+    {
+        binary_writer<uint8_t>(o).write_bson(j);
+    }
+
+    /*!
+    @copydoc to_bson(const basic_json&, detail::output_adapter<uint8_t>)
+    */
+    static void to_bson(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_bson(j);
+    }
+
+
+    /*!
+    @brief create a JSON value from an input in CBOR format
+
+    Deserializes a given input @a i to a JSON value using the CBOR (Concise
+    Binary Object Representation) serialization format.
+
+    The library maps CBOR types to JSON value types as follows:
+
+    CBOR type              | JSON value type | first byte
+    ---------------------- | --------------- | ----------
+    Integer                | number_unsigned | 0x00..0x17
+    Unsigned integer       | number_unsigned | 0x18
+    Unsigned integer       | number_unsigned | 0x19
+    Unsigned integer       | number_unsigned | 0x1A
+    Unsigned integer       | number_unsigned | 0x1B
+    Negative integer       | number_integer  | 0x20..0x37
+    Negative integer       | number_integer  | 0x38
+    Negative integer       | number_integer  | 0x39
+    Negative integer       | number_integer  | 0x3A
+    Negative integer       | number_integer  | 0x3B
+    Byte string            | binary          | 0x40..0x57
+    Byte string            | binary          | 0x58
+    Byte string            | binary          | 0x59
+    Byte string            | binary          | 0x5A
+    Byte string            | binary          | 0x5B
+    UTF-8 string           | string          | 0x60..0x77
+    UTF-8 string           | string          | 0x78
+    UTF-8 string           | string          | 0x79
+    UTF-8 string           | string          | 0x7A
+    UTF-8 string           | string          | 0x7B
+    UTF-8 string           | string          | 0x7F
+    array                  | array           | 0x80..0x97
+    array                  | array           | 0x98
+    array                  | array           | 0x99
+    array                  | array           | 0x9A
+    array                  | array           | 0x9B
+    array                  | array           | 0x9F
+    map                    | object          | 0xA0..0xB7
+    map                    | object          | 0xB8
+    map                    | object          | 0xB9
+    map                    | object          | 0xBA
+    map                    | object          | 0xBB
+    map                    | object          | 0xBF
+    False                  | `false`         | 0xF4
+    True                   | `true`          | 0xF5
+    Null                   | `null`          | 0xF6
+    Half-Precision Float   | number_float    | 0xF9
+    Single-Precision Float | number_float    | 0xFA
+    Double-Precision Float | number_float    | 0xFB
+
+    @warning The mapping is **incomplete** in the sense that not all CBOR
+             types can be converted to a JSON value. The following CBOR types
+             are not supported and will yield parse errors (parse_error.112):
+             - date/time (0xC0..0xC1)
+             - bignum (0xC2..0xC3)
+             - decimal fraction (0xC4)
+             - bigfloat (0xC5)
+             - expected conversions (0xD5..0xD7)
+             - simple values (0xE0..0xF3, 0xF8)
+             - undefined (0xF7)
+
+    @warning CBOR allows map keys of any type, whereas JSON only allows
+             strings as keys in object values. Therefore, CBOR maps with keys
+             other than UTF-8 strings are rejected (parse_error.113).
+
+    @note Any CBOR output created @ref to_cbor can be successfully parsed by
+          @ref from_cbor.
+
+    @param[in] i  an input in CBOR format convertible to an input adapter
+    @param[in] strict  whether to expect the input to be consumed until EOF
+                       (true by default)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+    @param[in] tag_handler how to treat CBOR tags (optional, error by default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.110 if the given input ends prematurely or the end of
+    file was not reached when @a strict was set to true
+    @throw parse_error.112 if unsupported features from CBOR were
+    used in the given input @a v or if the input is not valid CBOR
+    @throw parse_error.113 if a string was expected as map key, but not found
+
+    @complexity Linear in the size of the input @a i.
+
+    @liveexample{The example shows the deserialization of a byte vector in CBOR
+    format to a JSON value.,from_cbor}
+
+    @sa http://cbor.io
+    @sa @ref to_cbor(const basic_json&) for the analogous serialization
+    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for the
+        related MessagePack format
+    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
+        related UBJSON format
+
+    @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
+           consume input adapters, removed start_index parameter, and added
+           @a strict parameter since 3.0.0; added @a allow_exceptions parameter
+           since 3.2.0; added @a tag_handler parameter since 3.9.0.
+    */
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(InputType&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @copydoc from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t)
+    */
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(IteratorType first, IteratorType last,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
+    static basic_json from_cbor(const T* ptr, std::size_t len,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
+    }
+
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
+    static basic_json from_cbor(detail::span_input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @brief create a JSON value from an input in MessagePack format
+
+    Deserializes a given input @a i to a JSON value using the MessagePack
+    serialization format.
+
+    The library maps MessagePack types to JSON value types as follows:
+
+    MessagePack type | JSON value type | first byte
+    ---------------- | --------------- | ----------
+    positive fixint  | number_unsigned | 0x00..0x7F
+    fixmap           | object          | 0x80..0x8F
+    fixarray         | array           | 0x90..0x9F
+    fixstr           | string          | 0xA0..0xBF
+    nil              | `null`          | 0xC0
+    false            | `false`         | 0xC2
+    true             | `true`          | 0xC3
+    float 32         | number_float    | 0xCA
+    float 64         | number_float    | 0xCB
+    uint 8           | number_unsigned | 0xCC
+    uint 16          | number_unsigned | 0xCD
+    uint 32          | number_unsigned | 0xCE
+    uint 64          | number_unsigned | 0xCF
+    int 8            | number_integer  | 0xD0
+    int 16           | number_integer  | 0xD1
+    int 32           | number_integer  | 0xD2
+    int 64           | number_integer  | 0xD3
+    str 8            | string          | 0xD9
+    str 16           | string          | 0xDA
+    str 32           | string          | 0xDB
+    array 16         | array           | 0xDC
+    array 32         | array           | 0xDD
+    map 16           | object          | 0xDE
+    map 32           | object          | 0xDF
+    bin 8            | binary          | 0xC4
+    bin 16           | binary          | 0xC5
+    bin 32           | binary          | 0xC6
+    ext 8            | binary          | 0xC7
+    ext 16           | binary          | 0xC8
+    ext 32           | binary          | 0xC9
+    fixext 1         | binary          | 0xD4
+    fixext 2         | binary          | 0xD5
+    fixext 4         | binary          | 0xD6
+    fixext 8         | binary          | 0xD7
+    fixext 16        | binary          | 0xD8
+    negative fixint  | number_integer  | 0xE0-0xFF
+
+    @note Any MessagePack output created @ref to_msgpack can be successfully
+          parsed by @ref from_msgpack.
+
+    @param[in] i  an input in MessagePack format convertible to an input
+                  adapter
+    @param[in] strict  whether to expect the input to be consumed until EOF
+                       (true by default)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.110 if the given input ends prematurely or the end of
+    file was not reached when @a strict was set to true
+    @throw parse_error.112 if unsupported features from MessagePack were
+    used in the given input @a i or if the input is not valid MessagePack
+    @throw parse_error.113 if a string was expected as map key, but not found
+
+    @complexity Linear in the size of the input @a i.
+
+    @liveexample{The example shows the deserialization of a byte vector in
+    MessagePack format to a JSON value.,from_msgpack}
+
+    @sa http://msgpack.org
+    @sa @ref to_msgpack(const basic_json&) for the analogous serialization
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
+        related CBOR format
+    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for
+        the related UBJSON format
+    @sa @ref from_bson(detail::input_adapter&&, const bool, const bool) for
+        the related BSON format
+
+    @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
+           consume input adapters, removed start_index parameter, and added
+           @a strict parameter since 3.0.0; added @a allow_exceptions parameter
+           since 3.2.0
+    */
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(InputType&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @copydoc from_msgpack(detail::input_adapter&&, const bool, const bool)
+    */
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(IteratorType first, IteratorType last,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
+    static basic_json from_msgpack(const T* ptr, std::size_t len,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
+    static basic_json from_msgpack(detail::span_input_adapter&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+
+    /*!
+    @brief create a JSON value from an input in UBJSON format
+
+    Deserializes a given input @a i to a JSON value using the UBJSON (Universal
+    Binary JSON) serialization format.
+
+    The library maps UBJSON types to JSON value types as follows:
+
+    UBJSON type | JSON value type                         | marker
+    ----------- | --------------------------------------- | ------
+    no-op       | *no value, next value is read*          | `N`
+    null        | `null`                                  | `Z`
+    false       | `false`                                 | `F`
+    true        | `true`                                  | `T`
+    float32     | number_float                            | `d`
+    float64     | number_float                            | `D`
+    uint8       | number_unsigned                         | `U`
+    int8        | number_integer                          | `i`
+    int16       | number_integer                          | `I`
+    int32       | number_integer                          | `l`
+    int64       | number_integer                          | `L`
+    high-precision number | number_integer, number_unsigned, or number_float - depends on number string | 'H'
+    string      | string                                  | `S`
+    char        | string                                  | `C`
+    array       | array (optimized values are supported)  | `[`
+    object      | object (optimized values are supported) | `{`
+
+    @note The mapping is **complete** in the sense that any UBJSON value can
+          be converted to a JSON value.
+
+    @param[in] i  an input in UBJSON format convertible to an input adapter
+    @param[in] strict  whether to expect the input to be consumed until EOF
+                       (true by default)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.110 if the given input ends prematurely or the end of
+    file was not reached when @a strict was set to true
+    @throw parse_error.112 if a parse error occurs
+    @throw parse_error.113 if a string could not be parsed successfully
+
+    @complexity Linear in the size of the input @a i.
+
+    @liveexample{The example shows the deserialization of a byte vector in
+    UBJSON format to a JSON value.,from_ubjson}
+
+    @sa http://ubjson.org
+    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
+             analogous serialization
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
+        related CBOR format
+    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
+        the related MessagePack format
+    @sa @ref from_bson(detail::input_adapter&&, const bool, const bool) for
+        the related BSON format
+
+    @since version 3.1.0; added @a allow_exceptions parameter since 3.2.0
+    */
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(InputType&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @copydoc from_ubjson(detail::input_adapter&&, const bool, const bool)
+    */
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(IteratorType first, IteratorType last,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
+    static basic_json from_ubjson(const T* ptr, std::size_t len,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
+    static basic_json from_ubjson(detail::span_input_adapter&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+
+    /*!
+    @brief Create a JSON value from an input in BSON format
+
+    Deserializes a given input @a i to a JSON value using the BSON (Binary JSON)
+    serialization format.
+
+    The library maps BSON record types to JSON value types as follows:
+
+    BSON type       | BSON marker byte | JSON value type
+    --------------- | ---------------- | ---------------------------
+    double          | 0x01             | number_float
+    string          | 0x02             | string
+    document        | 0x03             | object
+    array           | 0x04             | array
+    binary          | 0x05             | still unsupported
+    undefined       | 0x06             | still unsupported
+    ObjectId        | 0x07             | still unsupported
+    boolean         | 0x08             | boolean
+    UTC Date-Time   | 0x09             | still unsupported
+    null            | 0x0A             | null
+    Regular Expr.   | 0x0B             | still unsupported
+    DB Pointer      | 0x0C             | still unsupported
+    JavaScript Code | 0x0D             | still unsupported
+    Symbol          | 0x0E             | still unsupported
+    JavaScript Code | 0x0F             | still unsupported
+    int32           | 0x10             | number_integer
+    Timestamp       | 0x11             | still unsupported
+    128-bit decimal float | 0x13       | still unsupported
+    Max Key         | 0x7F             | still unsupported
+    Min Key         | 0xFF             | still unsupported
+
+    @warning The mapping is **incomplete**. The unsupported mappings
+             are indicated in the table above.
+
+    @param[in] i  an input in BSON format convertible to an input adapter
+    @param[in] strict  whether to expect the input to be consumed until EOF
+                       (true by default)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.114 if an unsupported BSON record type is encountered
+
+    @complexity Linear in the size of the input @a i.
+
+    @liveexample{The example shows the deserialization of a byte vector in
+    BSON format to a JSON value.,from_bson}
+
+    @sa http://bsonspec.org/spec.html
+    @sa @ref to_bson(const basic_json&) for the analogous serialization
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
+        related CBOR format
+    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
+        the related MessagePack format
+    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
+        related UBJSON format
+    */
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(InputType&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @copydoc from_bson(detail::input_adapter&&, const bool, const bool)
+    */
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(IteratorType first, IteratorType last,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
+    static basic_json from_bson(const T* ptr, std::size_t len,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        return from_bson(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
+    static basic_json from_bson(detail::span_input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+    /// @}
+
+    //////////////////////////
+    // JSON Pointer support //
+    //////////////////////////
+
+    /// @name JSON Pointer functions
+    /// @{
+
+    /*!
+    @brief access specified element via JSON Pointer
+
+    Uses a JSON pointer to retrieve a reference to the respective JSON value.
+    No bound checking is performed. Similar to @ref operator[](const typename
+    object_t::key_type&), `null` values are created in arrays and objects if
+    necessary.
+
+    In particular:
+    - If the JSON pointer points to an object key that does not exist, it
+      is created an filled with a `null` value before a reference to it
+      is returned.
+    - If the JSON pointer points to an array index that does not exist, it
+      is created an filled with a `null` value before a reference to it
+      is returned. All indices between the current maximum and the given
+      index are also filled with `null`.
+    - The special value `-` is treated as a synonym for the index past the
+      end.
+
+    @param[in] ptr  a JSON pointer
+
+    @return reference to the element pointed to by @a ptr
+
+    @complexity Constant.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+
+    @liveexample{The behavior is shown in the example.,operatorjson_pointer}
+
+    @since version 2.0.0
+    */
+    reference operator[](const json_pointer& ptr)
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /*!
+    @brief access specified element via JSON Pointer
+
+    Uses a JSON pointer to retrieve a reference to the respective JSON value.
+    No bound checking is performed. The function does not change the JSON
+    value; no `null` values are created. In particular, the special value
+    `-` yields an exception.
+
+    @param[in] ptr  JSON pointer to the desired element
+
+    @return const reference to the element pointed to by @a ptr
+
+    @complexity Constant.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+
+    @liveexample{The behavior is shown in the example.,operatorjson_pointer_const}
+
+    @since version 2.0.0
+    */
+    const_reference operator[](const json_pointer& ptr) const
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /*!
+    @brief access specified element via JSON Pointer
+
+    Returns a reference to the element at with specified JSON pointer @a ptr,
+    with bounds checking.
+
+    @param[in] ptr  JSON pointer to the desired element
+
+    @return reference to the element pointed to by @a ptr
+
+    @throw parse_error.106 if an array index in the passed JSON pointer @a ptr
+    begins with '0'. See example below.
+
+    @throw parse_error.109 if an array index in the passed JSON pointer @a ptr
+    is not a number. See example below.
+
+    @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr
+    is out of range. See example below.
+
+    @throw out_of_range.402 if the array index '-' is used in the passed JSON
+    pointer @a ptr. As `at` provides checked access (and no elements are
+    implicitly inserted), the index '-' is always invalid. See example below.
+
+    @throw out_of_range.403 if the JSON pointer describes a key of an object
+    which cannot be found. See example below.
+
+    @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.
+    See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 2.0.0
+
+    @liveexample{The behavior is shown in the example.,at_json_pointer}
+    */
+    reference at(const json_pointer& ptr)
+    {
+        return ptr.get_checked(this);
+    }
+
+    /*!
+    @brief access specified element via JSON Pointer
+
+    Returns a const reference to the element at with specified JSON pointer @a
+    ptr, with bounds checking.
+
+    @param[in] ptr  JSON pointer to the desired element
+
+    @return reference to the element pointed to by @a ptr
+
+    @throw parse_error.106 if an array index in the passed JSON pointer @a ptr
+    begins with '0'. See example below.
+
+    @throw parse_error.109 if an array index in the passed JSON pointer @a ptr
+    is not a number. See example below.
+
+    @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr
+    is out of range. See example below.
+
+    @throw out_of_range.402 if the array index '-' is used in the passed JSON
+    pointer @a ptr. As `at` provides checked access (and no elements are
+    implicitly inserted), the index '-' is always invalid. See example below.
+
+    @throw out_of_range.403 if the JSON pointer describes a key of an object
+    which cannot be found. See example below.
+
+    @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.
+    See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 2.0.0
+
+    @liveexample{The behavior is shown in the example.,at_json_pointer_const}
+    */
+    const_reference at(const json_pointer& ptr) const
+    {
+        return ptr.get_checked(this);
+    }
+
+    /*!
+    @brief return flattened JSON value
+
+    The function creates a JSON object whose keys are JSON pointers (see [RFC
+    6901](https://tools.ietf.org/html/rfc6901)) and whose values are all
+    primitive. The original JSON value can be restored using the @ref
+    unflatten() function.
+
+    @return an object that maps JSON pointers to primitive values
+
+    @note Empty objects and arrays are flattened to `null` and will not be
+          reconstructed correctly by the @ref unflatten() function.
+
+    @complexity Linear in the size the JSON value.
+
+    @liveexample{The following code shows how a JSON object is flattened to an
+    object whose keys consist of JSON pointers.,flatten}
+
+    @sa @ref unflatten() for the reverse function
+
+    @since version 2.0.0
+    */
+    basic_json flatten() const
+    {
+        basic_json result(value_t::object);
+        json_pointer::flatten("", *this, result);
+        return result;
+    }
+
+    /*!
+    @brief unflatten a previously flattened JSON value
+
+    The function restores the arbitrary nesting of a JSON value that has been
+    flattened before using the @ref flatten() function. The JSON value must
+    meet certain constraints:
+    1. The value must be an object.
+    2. The keys must be JSON pointers (see
+       [RFC 6901](https://tools.ietf.org/html/rfc6901))
+    3. The mapped values must be primitive JSON types.
+
+    @return the original JSON from a flattened version
+
+    @note Empty objects and arrays are flattened by @ref flatten() to `null`
+          values and can not unflattened to their original type. Apart from
+          this example, for a JSON value `j`, the following is always true:
+          `j == j.flatten().unflatten()`.
+
+    @complexity Linear in the size the JSON value.
+
+    @throw type_error.314  if value is not an object
+    @throw type_error.315  if object values are not primitive
+
+    @liveexample{The following code shows how a flattened JSON object is
+    unflattened into the original nested JSON object.,unflatten}
+
+    @sa @ref flatten() for the reverse function
+
+    @since version 2.0.0
+    */
+    basic_json unflatten() const
+    {
+        return json_pointer::unflatten(*this);
+    }
+
+    /// @}
+
+    //////////////////////////
+    // JSON Patch functions //
+    //////////////////////////
+
+    /// @name JSON Patch functions
+    /// @{
+
+    /*!
+    @brief applies a JSON patch
+
+    [JSON Patch](http://jsonpatch.com) defines a JSON document structure for
+    expressing a sequence of operations to apply to a JSON) document. With
+    this function, a JSON Patch is applied to the current JSON value by
+    executing all operations from the patch.
+
+    @param[in] json_patch  JSON patch document
+    @return patched document
+
+    @note The application of a patch is atomic: Either all operations succeed
+          and the patched document is returned or an exception is thrown. In
+          any case, the original value is not changed: the patch is applied
+          to a copy of the value.
+
+    @throw parse_error.104 if the JSON patch does not consist of an array of
+    objects
+
+    @throw parse_error.105 if the JSON patch is malformed (e.g., mandatory
+    attributes are missing); example: `"operation add must have member path"`
+
+    @throw out_of_range.401 if an array index is out of range.
+
+    @throw out_of_range.403 if a JSON pointer inside the patch could not be
+    resolved successfully in the current JSON value; example: `"key baz not
+    found"`
+
+    @throw out_of_range.405 if JSON pointer has no parent ("add", "remove",
+    "move")
+
+    @throw other_error.501 if "test" operation was unsuccessful
+
+    @complexity Linear in the size of the JSON value and the length of the
+    JSON patch. As usually only a fraction of the JSON value is affected by
+    the patch, the complexity can usually be neglected.
+
+    @liveexample{The following code shows how a JSON patch is applied to a
+    value.,patch}
+
+    @sa @ref diff -- create a JSON patch by comparing two JSON values
+
+    @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
+    @sa [RFC 6901 (JSON Pointer)](https://tools.ietf.org/html/rfc6901)
+
+    @since version 2.0.0
+    */
+    basic_json patch(const basic_json& json_patch) const
+    {
+        // make a working copy to apply the patch to
+        basic_json result = *this;
+
+        // the valid JSON Patch operations
+        enum class patch_operations {add, remove, replace, move, copy, test, invalid};
+
+        const auto get_op = [](const std::string & op)
+        {
+            if (op == "add")
+            {
+                return patch_operations::add;
+            }
+            if (op == "remove")
+            {
+                return patch_operations::remove;
+            }
+            if (op == "replace")
+            {
+                return patch_operations::replace;
+            }
+            if (op == "move")
+            {
+                return patch_operations::move;
+            }
+            if (op == "copy")
+            {
+                return patch_operations::copy;
+            }
+            if (op == "test")
+            {
+                return patch_operations::test;
+            }
+
+            return patch_operations::invalid;
+        };
+
+        // wrapper for "add" operation; add value at ptr
+        const auto operation_add = [&result](json_pointer & ptr, basic_json val)
+        {
+            // adding to the root of the target document means replacing it
+            if (ptr.empty())
+            {
+                result = val;
+                return;
+            }
+
+            // make sure the top element of the pointer exists
+            json_pointer top_pointer = ptr.top();
+            if (top_pointer != ptr)
+            {
+                result.at(top_pointer);
+            }
+
+            // get reference to parent of JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            basic_json& parent = result[ptr];
+
+            switch (parent.m_type)
+            {
+                case value_t::null:
+                case value_t::object:
+                {
+                    // use operator[] to add value
+                    parent[last_path] = val;
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    if (last_path == "-")
+                    {
+                        // special case: append to back
+                        parent.push_back(val);
+                    }
+                    else
+                    {
+                        const auto idx = json_pointer::array_index(last_path);
+                        if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
+                        {
+                            // avoid undefined behavior
+                            JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
+                        }
+
+                        // default case: insert add offset
+                        parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
+                    }
+                    break;
+                }
+
+                // if there exists a parent it cannot be primitive
+                default:            // LCOV_EXCL_LINE
+                    JSON_ASSERT(false);  // LCOV_EXCL_LINE
+            }
+        };
+
+        // wrapper for "remove" operation; remove value at ptr
+        const auto operation_remove = [&result](json_pointer & ptr)
+        {
+            // get reference to parent of JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            basic_json& parent = result.at(ptr);
+
+            // remove child
+            if (parent.is_object())
+            {
+                // perform range check
+                auto it = parent.find(last_path);
+                if (JSON_HEDLEY_LIKELY(it != parent.end()))
+                {
+                    parent.erase(it);
+                }
+                else
+                {
+                    JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found"));
+                }
+            }
+            else if (parent.is_array())
+            {
+                // note erase performs range check
+                parent.erase(json_pointer::array_index(last_path));
+            }
+        };
+
+        // type check: top level value must be an array
+        if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
+        {
+            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
+        }
+
+        // iterate and apply the operations
+        for (const auto& val : json_patch)
+        {
+            // wrapper to get a value for an operation
+            const auto get_value = [&val](const std::string & op,
+                                          const std::string & member,
+                                          bool string_type) -> basic_json &
+            {
+                // find value
+                auto it = val.m_value.object->find(member);
+
+                // context-sensitive error message
+                const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
+
+                // check if desired value is present
+                if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
+                {
+                    JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'"));
+                }
+
+                // check if result is of type string
+                if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
+                {
+                    JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'"));
+                }
+
+                // no error: return value
+                return it->second;
+            };
+
+            // type check: every element of the array must be an object
+            if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
+            {
+                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
+            }
+
+            // collect mandatory members
+            const auto op = get_value("op", "op", true).template get<std::string>();
+            const auto path = get_value(op, "path", true).template get<std::string>();
+            json_pointer ptr(path);
+
+            switch (get_op(op))
+            {
+                case patch_operations::add:
+                {
+                    operation_add(ptr, get_value("add", "value", false));
+                    break;
+                }
+
+                case patch_operations::remove:
+                {
+                    operation_remove(ptr);
+                    break;
+                }
+
+                case patch_operations::replace:
+                {
+                    // the "path" location must exist - use at()
+                    result.at(ptr) = get_value("replace", "value", false);
+                    break;
+                }
+
+                case patch_operations::move:
+                {
+                    const auto from_path = get_value("move", "from", true).template get<std::string>();
+                    json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json v = result.at(from_ptr);
+
+                    // The move operation is functionally identical to a
+                    // "remove" operation on the "from" location, followed
+                    // immediately by an "add" operation at the target
+                    // location with the value that was just removed.
+                    operation_remove(from_ptr);
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::copy:
+                {
+                    const auto from_path = get_value("copy", "from", true).template get<std::string>();
+                    const json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json v = result.at(from_ptr);
+
+                    // The copy is functionally identical to an "add"
+                    // operation at the target location using the value
+                    // specified in the "from" member.
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::test:
+                {
+                    bool success = false;
+                    JSON_TRY
+                    {
+                        // check if "value" matches the one at "path"
+                        // the "path" location must exist - use at()
+                        success = (result.at(ptr) == get_value("test", "value", false));
+                    }
+                    JSON_INTERNAL_CATCH (out_of_range&)
+                    {
+                        // ignore out of range errors: success remains false
+                    }
+
+                    // throw an exception if test fails
+                    if (JSON_HEDLEY_UNLIKELY(!success))
+                    {
+                        JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump()));
+                    }
+
+                    break;
+                }
+
+                default:
+                {
+                    // op must be "add", "remove", "replace", "move", "copy", or
+                    // "test"
+                    JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid"));
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief creates a diff as a JSON patch
+
+    Creates a [JSON Patch](http://jsonpatch.com) so that value @a source can
+    be changed into the value @a target by calling @ref patch function.
+
+    @invariant For two JSON values @a source and @a target, the following code
+    yields always `true`:
+    @code {.cpp}
+    source.patch(diff(source, target)) == target;
+    @endcode
+
+    @note Currently, only `remove`, `add`, and `replace` operations are
+          generated.
+
+    @param[in] source  JSON value to compare from
+    @param[in] target  JSON value to compare against
+    @param[in] path    helper value to create JSON pointers
+
+    @return a JSON patch to convert the @a source to @a target
+
+    @complexity Linear in the lengths of @a source and @a target.
+
+    @liveexample{The following code shows how a JSON patch is created as a
+    diff for two JSON values.,diff}
+
+    @sa @ref patch -- apply a JSON patch
+    @sa @ref merge_patch -- apply a JSON Merge Patch
+
+    @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
+
+    @since version 2.0.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json diff(const basic_json& source, const basic_json& target,
+                           const std::string& path = "")
+    {
+        // the patch
+        basic_json result(value_t::array);
+
+        // if the values are the same, return empty patch
+        if (source == target)
+        {
+            return result;
+        }
+
+        if (source.type() != target.type())
+        {
+            // different types: replace value
+            result.push_back(
+            {
+                {"op", "replace"}, {"path", path}, {"value", target}
+            });
+            return result;
+        }
+
+        switch (source.type())
+        {
+            case value_t::array:
+            {
+                // first pass: traverse common elements
+                std::size_t i = 0;
+                while (i < source.size() && i < target.size())
+                {
+                    // recursive call to compare array values at index i
+                    auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
+                    result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    ++i;
+                }
+
+                // i now reached the end of at least one array
+                // in a second pass, traverse the remaining elements
+
+                // remove my remaining elements
+                const auto end_index = static_cast<difference_type>(result.size());
+                while (i < source.size())
+                {
+                    // add operations in reverse order to avoid invalid
+                    // indices
+                    result.insert(result.begin() + end_index, object(
+                    {
+                        {"op", "remove"},
+                        {"path", path + "/" + std::to_string(i)}
+                    }));
+                    ++i;
+                }
+
+                // add other remaining elements
+                while (i < target.size())
+                {
+                    result.push_back(
+                    {
+                        {"op", "add"},
+                        {"path", path + "/-"},
+                        {"value", target[i]}
+                    });
+                    ++i;
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // first pass: traverse this object's elements
+                for (auto it = source.cbegin(); it != source.cend(); ++it)
+                {
+                    // escape the key name to be used in a JSON patch
+                    const auto key = json_pointer::escape(it.key());
+
+                    if (target.find(it.key()) != target.end())
+                    {
+                        // recursive call to compare object values at key it
+                        auto temp_diff = diff(it.value(), target[it.key()], path + "/" + key);
+                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    }
+                    else
+                    {
+                        // found a key that is not in o -> remove it
+                        result.push_back(object(
+                        {
+                            {"op", "remove"}, {"path", path + "/" + key}
+                        }));
+                    }
+                }
+
+                // second pass: traverse other object's elements
+                for (auto it = target.cbegin(); it != target.cend(); ++it)
+                {
+                    if (source.find(it.key()) == source.end())
+                    {
+                        // found a key that is not in this -> add it
+                        const auto key = json_pointer::escape(it.key());
+                        result.push_back(
+                        {
+                            {"op", "add"}, {"path", path + "/" + key},
+                            {"value", it.value()}
+                        });
+                    }
+                }
+
+                break;
+            }
+
+            default:
+            {
+                // both primitive type: replace value
+                result.push_back(
+                {
+                    {"op", "replace"}, {"path", path}, {"value", target}
+                });
+                break;
+            }
+        }
+
+        return result;
+    }
+
+    /// @}
+
+    ////////////////////////////////
+    // JSON Merge Patch functions //
+    ////////////////////////////////
+
+    /// @name JSON Merge Patch functions
+    /// @{
+
+    /*!
+    @brief applies a JSON Merge Patch
+
+    The merge patch format is primarily intended for use with the HTTP PATCH
+    method as a means of describing a set of modifications to a target
+    resource's content. This function applies a merge patch to the current
+    JSON value.
+
+    The function implements the following algorithm from Section 2 of
+    [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396):
+
+    ```
+    define MergePatch(Target, Patch):
+      if Patch is an Object:
+        if Target is not an Object:
+          Target = {} // Ignore the contents and set it to an empty Object
+        for each Name/Value pair in Patch:
+          if Value is null:
+            if Name exists in Target:
+              remove the Name/Value pair from Target
+          else:
+            Target[Name] = MergePatch(Target[Name], Value)
+        return Target
+      else:
+        return Patch
+    ```
+
+    Thereby, `Target` is the current object; that is, the patch is applied to
+    the current value.
+
+    @param[in] apply_patch  the patch to apply
+
+    @complexity Linear in the lengths of @a patch.
+
+    @liveexample{The following code shows how a JSON Merge Patch is applied to
+    a JSON document.,merge_patch}
+
+    @sa @ref patch -- apply a JSON patch
+    @sa [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396)
+
+    @since version 3.0.0
+    */
+    void merge_patch(const basic_json& apply_patch)
+    {
+        if (apply_patch.is_object())
+        {
+            if (!is_object())
+            {
+                *this = object();
+            }
+            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
+            {
+                if (it.value().is_null())
+                {
+                    erase(it.key());
+                }
+                else
+                {
+                    operator[](it.key()).merge_patch(it.value());
+                }
+            }
+        }
+        else
+        {
+            *this = apply_patch;
+        }
+    }
+
+    /// @}
+};
+
+/*!
+@brief user-defined to_string function for JSON values
+
+This function implements a user-defined to_string  for JSON objects.
+
+@param[in] j  a JSON object
+@return a std::string object
+*/
+
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
+{
+    return j.dump();
+}
+} // namespace nlohmann
+
+///////////////////////
+// nonmember support //
+///////////////////////
+
+// specialization of std::swap, and std::hash
+namespace std
+{
+
+/// hash value for JSON objects
+template<>
+struct hash<nlohmann::json>
+{
+    /*!
+    @brief return a hash value for a JSON object
+
+    @since version 1.0.0
+    */
+    std::size_t operator()(const nlohmann::json& j) const
+    {
+        return nlohmann::detail::hash(j);
+    }
+};
+
+/// specialization for std::less<value_t>
+/// @note: do not remove the space after '<',
+///        see https://github.com/nlohmann/json/pull/679
+template<>
+struct less<::nlohmann::detail::value_t>
+{
+    /*!
+    @brief compare two value_t enum values
+    @since version 3.0.0
+    */
+    bool operator()(nlohmann::detail::value_t lhs,
+                    nlohmann::detail::value_t rhs) const noexcept
+    {
+        return nlohmann::detail::operator<(lhs, rhs);
+    }
+};
+
+// C++20 prohibit function specialization in the std namespace.
+#ifndef JSON_HAS_CPP_20
+
+/*!
+@brief exchanges the values of two JSON objects
+
+@since version 1.0.0
+*/
+template<>
+inline void swap<nlohmann::json>(nlohmann::json& j1, nlohmann::json& j2) noexcept(
+    is_nothrow_move_constructible<nlohmann::json>::value&&
+    is_nothrow_move_assignable<nlohmann::json>::value
+                              )
+{
+    j1.swap(j2);
+}
+
+#endif
+
+} // namespace std
+
+/*!
+@brief user-defined string literal for JSON values
+
+This operator implements a user-defined string literal for JSON objects. It
+can be used by adding `"_json"` to a string literal and returns a JSON object
+if no parse error occurred.
+
+@param[in] s  a string representation of a JSON object
+@param[in] n  the length of string @a s
+@return a JSON object
+
+@since version 1.0.0
+*/
+JSON_HEDLEY_NON_NULL(1)
+inline nlohmann::json operator "" _json(const char* s, std::size_t n)
+{
+    return nlohmann::json::parse(s, s + n);
+}
+
+/*!
+@brief user-defined string literal for JSON pointer
+
+This operator implements a user-defined string literal for JSON Pointers. It
+can be used by adding `"_json_pointer"` to a string literal and returns a JSON pointer
+object if no parse error occurred.
+
+@param[in] s  a string representation of a JSON Pointer
+@param[in] n  the length of string @a s
+@return a JSON pointer object
+
+@since version 2.0.0
+*/
+JSON_HEDLEY_NON_NULL(1)
+inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
+{
+    return nlohmann::json::json_pointer(std::string(s, n));
+}
+
+// #include <nlohmann/detail/macro_unscope.hpp>
+
+
+// restore GCC/clang diagnostic settings
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+    #pragma GCC diagnostic pop
+#endif
+#if defined(__clang__)
+    #pragma GCC diagnostic pop
+#endif
+
+// clean up
+#undef JSON_ASSERT
+#undef JSON_INTERNAL_CATCH
+#undef JSON_CATCH
+#undef JSON_THROW
+#undef JSON_TRY
+#undef JSON_HAS_CPP_14
+#undef JSON_HAS_CPP_17
+#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
+#undef NLOHMANN_BASIC_JSON_TPL
+#undef JSON_EXPLICIT
+
+// #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
+#undef JSON_HEDLEY_ALWAYS_INLINE
+#undef JSON_HEDLEY_ARM_VERSION
+#undef JSON_HEDLEY_ARM_VERSION_CHECK
+#undef JSON_HEDLEY_ARRAY_PARAM
+#undef JSON_HEDLEY_ASSUME
+#undef JSON_HEDLEY_BEGIN_C_DECLS
+#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#undef JSON_HEDLEY_CLANG_HAS_WARNING
+#undef JSON_HEDLEY_COMPCERT_VERSION
+#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#undef JSON_HEDLEY_CONCAT
+#undef JSON_HEDLEY_CONCAT3
+#undef JSON_HEDLEY_CONCAT3_EX
+#undef JSON_HEDLEY_CONCAT_EX
+#undef JSON_HEDLEY_CONST
+#undef JSON_HEDLEY_CONSTEXPR
+#undef JSON_HEDLEY_CONST_CAST
+#undef JSON_HEDLEY_CPP_CAST
+#undef JSON_HEDLEY_CRAY_VERSION
+#undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#undef JSON_HEDLEY_C_DECL
+#undef JSON_HEDLEY_DEPRECATED
+#undef JSON_HEDLEY_DEPRECATED_FOR
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#undef JSON_HEDLEY_DIAGNOSTIC_POP
+#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#undef JSON_HEDLEY_DMC_VERSION
+#undef JSON_HEDLEY_DMC_VERSION_CHECK
+#undef JSON_HEDLEY_EMPTY_BASES
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#undef JSON_HEDLEY_END_C_DECLS
+#undef JSON_HEDLEY_FLAGS
+#undef JSON_HEDLEY_FLAGS_CAST
+#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#undef JSON_HEDLEY_GCC_HAS_FEATURE
+#undef JSON_HEDLEY_GCC_HAS_WARNING
+#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#undef JSON_HEDLEY_GCC_VERSION
+#undef JSON_HEDLEY_GCC_VERSION_CHECK
+#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#undef JSON_HEDLEY_GNUC_HAS_WARNING
+#undef JSON_HEDLEY_GNUC_VERSION
+#undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#undef JSON_HEDLEY_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_BUILTIN
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_EXTENSION
+#undef JSON_HEDLEY_HAS_FEATURE
+#undef JSON_HEDLEY_HAS_WARNING
+#undef JSON_HEDLEY_IAR_VERSION
+#undef JSON_HEDLEY_IAR_VERSION_CHECK
+#undef JSON_HEDLEY_IBM_VERSION
+#undef JSON_HEDLEY_IBM_VERSION_CHECK
+#undef JSON_HEDLEY_IMPORT
+#undef JSON_HEDLEY_INLINE
+#undef JSON_HEDLEY_INTEL_VERSION
+#undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#undef JSON_HEDLEY_IS_CONSTANT
+#undef JSON_HEDLEY_IS_CONSTEXPR_
+#undef JSON_HEDLEY_LIKELY
+#undef JSON_HEDLEY_MALLOC
+#undef JSON_HEDLEY_MESSAGE
+#undef JSON_HEDLEY_MSVC_VERSION
+#undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#undef JSON_HEDLEY_NEVER_INLINE
+#undef JSON_HEDLEY_NON_NULL
+#undef JSON_HEDLEY_NO_ESCAPE
+#undef JSON_HEDLEY_NO_RETURN
+#undef JSON_HEDLEY_NO_THROW
+#undef JSON_HEDLEY_NULL
+#undef JSON_HEDLEY_PELLES_VERSION
+#undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#undef JSON_HEDLEY_PGI_VERSION
+#undef JSON_HEDLEY_PGI_VERSION_CHECK
+#undef JSON_HEDLEY_PREDICT
+#undef JSON_HEDLEY_PRINTF_FORMAT
+#undef JSON_HEDLEY_PRIVATE
+#undef JSON_HEDLEY_PUBLIC
+#undef JSON_HEDLEY_PURE
+#undef JSON_HEDLEY_REINTERPRET_CAST
+#undef JSON_HEDLEY_REQUIRE
+#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#undef JSON_HEDLEY_REQUIRE_MSG
+#undef JSON_HEDLEY_RESTRICT
+#undef JSON_HEDLEY_RETURNS_NON_NULL
+#undef JSON_HEDLEY_SENTINEL
+#undef JSON_HEDLEY_STATIC_ASSERT
+#undef JSON_HEDLEY_STATIC_CAST
+#undef JSON_HEDLEY_STRINGIFY
+#undef JSON_HEDLEY_STRINGIFY_EX
+#undef JSON_HEDLEY_SUNPRO_VERSION
+#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#undef JSON_HEDLEY_TINYC_VERSION
+#undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#undef JSON_HEDLEY_TI_ARMCL_VERSION
+#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL2000_VERSION
+#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL430_VERSION
+#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL6X_VERSION
+#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL7X_VERSION
+#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CLPRU_VERSION
+#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+#undef JSON_HEDLEY_TI_VERSION
+#undef JSON_HEDLEY_TI_VERSION_CHECK
+#undef JSON_HEDLEY_UNAVAILABLE
+#undef JSON_HEDLEY_UNLIKELY
+#undef JSON_HEDLEY_UNPREDICTABLE
+#undef JSON_HEDLEY_UNREACHABLE
+#undef JSON_HEDLEY_UNREACHABLE_RETURN
+#undef JSON_HEDLEY_VERSION
+#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#undef JSON_HEDLEY_VERSION_ENCODE
+#undef JSON_HEDLEY_WARNING
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+#undef JSON_HEDLEY_FALL_THROUGH
+
+
+
+#endif  // INCLUDE_NLOHMANN_JSON_HPP_
diff --git a/lib/kitty/kitty/affine.hpp b/lib/kitty/kitty/affine.hpp
new file mode 100644
index 0000000..7811ca7
--- /dev/null
+++ b/lib/kitty/kitty/affine.hpp
@@ -0,0 +1,217 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file affine.hpp
+  \brief Implements affine canonization algorithms
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include "dynamic_truth_table.hpp"
+#include "operators.hpp"
+#include "static_truth_table.hpp"
+#include "spectral.hpp"
+#include "traits.hpp"
+
+/*! \cond PRIVATE */
+#include "detail/linear_constants.hpp"
+/*! \endcond */
+
+namespace kitty
+{
+
+/*! \cond PRIVATE */
+namespace detail
+{
+/* all delta-swap operations have been optimized to work with integer masks omega */
+template<typename TT>
+inline void delta_swap_inplace_opt( TT& tt, uint64_t delta, uint64_t omega )
+{
+  assert( tt.num_vars() <= 6 );
+  const uint64_t y = ( tt._bits[0] ^ ( tt._bits[0] >> delta ) ) & omega;
+  tt._bits[0] = tt._bits[0] ^ y ^ ( y << delta );
+}
+
+template<uint32_t NumVars>
+inline void delta_swap_inplace_opt( static_truth_table<NumVars, true>& tt, uint64_t delta, uint64_t omega )
+{
+  assert( NumVars <= 6 );
+  const uint64_t y = ( tt._bits ^ ( tt._bits >> delta ) ) & omega;
+  tt._bits = tt._bits ^ y ^ ( y << delta );
+}
+
+template<typename TT>
+void permute_with_masks_inplace_opt( TT& tt, uint64_t const* masks )
+{
+  for ( auto k = 0u; k < tt.num_vars(); ++k )
+  {
+    delta_swap_inplace_opt( tt, uint64_t( 1 ) << k, masks[k] );
+  }
+
+  for ( int k = tt.num_vars() - 2, i = tt.num_vars(); k >= 0; --k, ++i )
+  {
+    delta_swap_inplace_opt( tt, uint64_t( 1 ) << k, masks[i] );
+  }
+}
+
+template<typename TT>
+TT permute_with_masks_opt( const TT& tt, uint64_t const* masks )
+{
+  auto copy = tt;
+  permute_with_masks_inplace_opt( copy, masks );
+  return copy;
+}
+
+template<typename Fn>
+inline void for_each_permutation_mask( unsigned num_vars, Fn&& fn )
+{
+  assert( num_vars >= 2 && num_vars <= 4 );
+
+  const auto offset = 2 * num_vars - 1;
+
+  const auto s = detail::masks_start[num_vars - 2u];
+  const auto e = detail::masks_end[num_vars - 2u];
+
+  for ( auto i = s; i < e; i += offset )
+  {
+    fn( &detail::linear_masks[i] );
+  }
+}
+} /* namespace detail */
+/*! \endcond */
+
+/*! \brief Applies exact linear classification
+
+  This algorithms applies all linear input transformations to a function and
+  returns the function with the smallest integer representation as
+  representative of the equivalence class.
+
+  \param tt Truth table
+*/
+template<typename TT, typename Callback = decltype( detail::exact_spectral_canonization_null_callback )>
+TT exact_linear_canonization( const TT& tt, Callback&& fn = detail::exact_spectral_canonization_null_callback )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  detail::miller_spectral_canonization_impl<TT> impl( tt, false, false, false );
+  return impl.run( fn ).first;
+}
+
+/*! \cond PRIVATE */
+template<typename TT>
+TT exact_linear_canonization_old( const TT& tt )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  auto min = tt;
+
+  detail::for_each_permutation_mask( tt.num_vars(), [&min, &tt]( const auto* mask )
+                                     { min = std::min( min, detail::permute_with_masks_opt( tt, mask ) ); } );
+
+  return min;
+}
+/*! \endcond */
+
+/*! \brief Applies exact linear classification and output negation
+
+  This algorithms applies all linear input transformations to a function and its
+  complement and returns the function with the smallest integer representation
+  as representative of the equivalence class.
+
+  \param tt Truth table
+*/
+template<typename TT>
+TT exact_linear_output_canonization( const TT& tt )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  return std::min( exact_linear_canonization_old( tt ), exact_linear_canonization_old( ~tt ) );
+}
+
+/*! \brief Applies exact affine classification
+
+  This algorithms applies all linear input transformations and input
+  complementations to a function and returns the function with the smallest
+  integer representation as representative of the equivalence class.
+
+  \param tt Truth table
+*/
+template<typename TT, typename Callback = decltype( detail::exact_spectral_canonization_null_callback )>
+TT exact_affine_canonization( const TT& tt, Callback&& fn = detail::exact_spectral_canonization_null_callback )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  detail::miller_spectral_canonization_impl<TT> impl( tt, true, false, false );
+  return impl.run( fn ).first;
+}
+
+/*! \cond PRIVATE */
+template<typename TT>
+TT exact_affine_canonization_old( const TT& tt )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  const auto num_vars = tt.num_vars();
+
+  assert( num_vars >= 2 && num_vars <= 4 );
+
+  auto copy = tt;
+
+  const auto& flips = detail::flips[num_vars - 2u];
+
+  auto min = exact_linear_canonization_old( copy );
+
+  for ( int j = static_cast<int>( flips.size() ) - 1; j >= 0; --j )
+  {
+    const auto pos = flips[j];
+    flip_inplace( copy, pos );
+    min = std::min( min, exact_linear_canonization_old( copy ) );
+  }
+
+  return min;
+}
+/*! \endcond */
+
+/*! \brief Applies exact affine classification and output negation
+
+  This algorithms applies all linear input transformations and input
+  complementations to a function and its complement and returns the function
+  with the smallest integer representation as representative of the equivalence
+  class.
+
+  \param tt Truth table
+*/
+template<typename TT>
+TT exact_affine_output_canonization( const TT& tt )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  return std::min( exact_affine_canonization_old( tt ), exact_affine_canonization_old( ~tt ) );
+}
+
+} /* namespace kitty */
\ No newline at end of file
diff --git a/lib/kitty/kitty/algorithm.hpp b/lib/kitty/kitty/algorithm.hpp
new file mode 100644
index 0000000..9a090ce
--- /dev/null
+++ b/lib/kitty/kitty/algorithm.hpp
@@ -0,0 +1,489 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file algorithm.hpp
+  \brief Implements several generic algorithms on truth tables
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include "bit_operations.hpp"
+#include "detail/constants.hpp"
+#include "static_truth_table.hpp"
+#include "partial_truth_table.hpp"
+
+#include <algorithm>
+#include <cassert>
+
+namespace kitty
+{
+
+/*! \brief Perform bitwise unary operation on truth table
+
+  \param tt Truth table
+  \param op Unary operation that takes as input a word (`uint64_t`) and returns a word
+
+  \return new constructed truth table of same type and dimensions
+ */
+template<typename TT, typename Fn>
+auto unary_operation( const TT& tt, Fn&& op )
+{
+  auto result = tt.construct();
+  std::transform( tt.cbegin(), tt.cend(), result.begin(), op );
+  result.mask_bits();
+  return result;
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars, typename Fn>
+auto unary_operation( const static_truth_table<NumVars, true>& tt, Fn&& op )
+{
+  auto result = tt.construct();
+  result._bits = op( tt._bits );
+  result.mask_bits();
+  return result;
+}
+/*! \endcond */
+
+/*! \cond PRIVATE */
+/*!
+    \param num_blocks_offset Number of blocks that don't need to be computed
+    (the first `num_blocks_offset` blocks of `result` will remain the same before computation)
+ */
+template<typename Fn>
+void unary_operation( partial_truth_table& result, const partial_truth_table& tt, Fn&& op, int const& num_blocks_offset = 0 )
+{
+  result.resize( tt.num_bits() );
+  std::transform( tt.cbegin() + num_blocks_offset, tt.cend(), result.begin() + num_blocks_offset, op );
+}
+/*! \endcond */
+
+/*! \brief Perform bitwise binary operation on two truth tables
+
+  The dimensions of `first` and `second` must match.  This is ensured
+  at compile-time for static truth tables, but at run-time for dynamic
+  truth tables.
+
+  \param first First truth table
+  \param second Second truth table
+  \param op Binary operation that takes as input two words (`uint64_t`) and returns a word
+
+  \return new constructed truth table of same type and dimensions
+ */
+template<typename TT, typename Fn>
+auto binary_operation( const TT& first, const TT& second, Fn&& op )
+{
+  assert( first.num_vars() == second.num_vars() );
+
+  auto result = first.construct();
+  std::transform( first.cbegin(), first.cend(), second.cbegin(), result.begin(), op );
+  result.mask_bits();
+  return result;
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars, typename Fn>
+auto binary_operation( const static_truth_table<NumVars, true>& first, const static_truth_table<NumVars, true>& second, Fn&& op )
+{
+  auto result = first.construct();
+  result._bits = op( first._bits, second._bits );
+  result.mask_bits();
+  return result;
+}
+/*! \endcond */
+
+/*! \cond PRIVATE */
+template<typename Fn>
+auto binary_operation( const partial_truth_table& first, const partial_truth_table& second, Fn&& op )
+{
+  assert( first.num_bits() == second.num_bits() );
+
+  auto result = first.construct();
+  std::transform( first.cbegin(), first.cend(), second.cbegin(), result.begin(), op );
+  result.mask_bits();
+  return result;
+}
+/*! \endcond */
+
+/*! \cond PRIVATE */
+/*!
+    \param num_blocks_offset Number of blocks that don't need to be computed
+    (the first `num_blocks_offset` blocks of `result` will remain the same before computation)
+ */
+template<typename Fn>
+void binary_operation( partial_truth_table& result, const partial_truth_table& first, const partial_truth_table& second, Fn&& op, int const& num_blocks_offset = 0 )
+{
+  assert( first.num_bits() == second.num_bits() );
+
+  result.resize( first.num_bits() );
+  std::transform( first.cbegin() + num_blocks_offset, first.cend(), second.cbegin() + num_blocks_offset, result.begin() + num_blocks_offset, op );
+}
+/*! \endcond */
+
+/*! \brief Perform bitwise ternary operation on three truth tables
+
+  The dimensions of `first`, `second`, and `third` must match.  This
+  is ensured at compile-time for static truth tables, but at run-time
+  for dynamic truth tables.
+
+  \param first First truth table
+  \param second Second truth table
+  \param third Third truth table
+  \param op Ternary operation that takes as input three words (`uint64_t`) and returns a word
+
+  \return new constructed truth table of same type and dimensions
+ */
+template<typename TT, typename Fn>
+auto ternary_operation( const TT& first, const TT& second, const TT& third, Fn&& op )
+{
+  assert( first.num_vars() == second.num_vars() && second.num_vars() == third.num_vars() );
+
+  auto result = first.construct();
+  auto it1 = first.cbegin();
+  const auto it1_e = first.cend();
+  auto it2 = second.cbegin();
+  auto it3 = third.cbegin();
+  auto it = result.begin();
+
+  while ( it1 != it1_e )
+  {
+    *it++ = op( *it1++, *it2++, *it3++ );
+  }
+
+  result.mask_bits();
+  return result;
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars, typename Fn>
+auto ternary_operation( const static_truth_table<NumVars, true>& first, const static_truth_table<NumVars, true>& second, const static_truth_table<NumVars, true>& third, Fn&& op )
+{
+  auto result = first.construct();
+  result._bits = op( first._bits, second._bits, third._bits );
+  result.mask_bits();
+  return result;
+}
+/*! \endcond */
+
+/*! \cond PRIVATE */
+template<typename Fn>
+auto ternary_operation( const partial_truth_table& first, const partial_truth_table& second, const partial_truth_table& third, Fn&& op )
+{
+  assert( first.num_bits() == second.num_bits() && second.num_bits() == third.num_bits() );
+
+  auto result = first.construct();
+  auto it1 = first.cbegin();
+  const auto it1_e = first.cend();
+  auto it2 = second.cbegin();
+  auto it3 = third.cbegin();
+  auto it = result.begin();
+
+  while ( it1 != it1_e )
+  {
+    *it++ = op( *it1++, *it2++, *it3++ );
+  }
+
+  result.mask_bits();
+  return result;
+}
+/*! \endcond */
+
+/*! \brief Perform bitwise quaternary operation on four truth tables
+
+  The dimensions of all truth tables must match.  This
+  is ensured at compile-time for static truth tables, but at run-time
+  for dynamic truth tables.
+
+  \param first First truth table
+  \param second Second truth table
+  \param third Third truth table
+  \param fourth Fourth truth table
+  \param op Quaternary operation that takes as input four words (`uint64_t`) and returns a word
+
+  \return new constructed truth table of same type and dimensions
+ */
+template<typename TT, typename Fn>
+auto quaternary_operation( const TT& first, const TT& second, const TT& third, const TT& fourth, Fn&& op )
+{
+  assert( first.num_vars() == second.num_vars() && second.num_vars() == third.num_vars() && third.num_vars() == fourth.num_vars() );
+
+  auto result = first.construct();
+  auto it1 = first.cbegin();
+  const auto it1_e = first.cend();
+  auto it2 = second.cbegin();
+  auto it3 = third.cbegin();
+  auto it4 = fourth.cbegin();
+  auto it = result.begin();
+
+  while ( it1 != it1_e )
+  {
+    *it++ = op( *it1++, *it2++, *it3++, *it4++ );
+  }
+
+  result.mask_bits();
+  return result;
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars, typename Fn>
+auto quaternary_operation( const static_truth_table<NumVars, true>& first, const static_truth_table<NumVars, true>& second, const static_truth_table<NumVars, true>& third, const static_truth_table<NumVars, true>& fourth, Fn&& op )
+{
+  auto result = first.construct();
+  result._bits = op( first._bits, second._bits, third._bits, fourth._bits );
+  result.mask_bits();
+  return result;
+}
+/*! \endcond */
+
+/*! \cond PRIVATE */
+template<typename Fn>
+auto quaternary_operation( const partial_truth_table& first, const partial_truth_table& second, const partial_truth_table& third, const partial_truth_table& fourth, Fn&& op )
+{
+  assert( first.num_bits() == second.num_bits() && second.num_bits() == third.num_bits() && third.num_bits() == fourth.num_bits() );
+
+  auto result = first.construct();
+  auto it1 = first.cbegin();
+  const auto it1_e = first.cend();
+  auto it2 = second.cbegin();
+  auto it3 = third.cbegin();
+  auto it4 = fourth.cbegin();
+  auto it = result.begin();
+
+  while ( it1 != it1_e )
+  {
+    *it++ = op( *it1++, *it2++, *it3++, *it4++ );
+  }
+
+  result.mask_bits();
+  return result;
+}
+/*! \endcond */
+
+/*! \brief Computes a predicate based on two truth tables
+
+  The dimensions of `first` and `second` must match.  This is ensured
+  at compile-time for static truth tables, but at run-time for dynamic
+  truth tables.
+
+  \param first First truth table
+  \param second Second truth table
+  \param op Binary operation that takes as input two words (`uint64_t`) and returns a Boolean
+
+  \return true or false based on the predicate
+ */
+template<typename TT, typename Fn>
+bool binary_predicate( const TT& first, const TT& second, Fn&& op )
+{
+  assert( first.num_vars() == second.num_vars() );
+
+  return std::equal( first.begin(), first.end(), second.begin(), op );
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars, typename Fn>
+bool binary_predicate( const static_truth_table<NumVars, true>& first, const static_truth_table<NumVars, true>& second, Fn&& op )
+{
+  return op( first._bits, second._bits );
+}
+/*! \endcond */
+
+/*! \cond PRIVATE */
+template<typename Fn>
+bool binary_predicate( const partial_truth_table& first, const partial_truth_table& second, Fn&& op )
+{
+  assert( first.num_bits() == second.num_bits() );
+
+  return std::equal( first.begin(), first.end(), second.begin(), op );
+}
+/*! \endcond */
+
+/*! \brief Computes a predicate based on three truth tables
+
+  The dimensions of `first`, `second` and `third` must match.  This is ensured
+  at compile-time for static truth tables, but at run-time for dynamic
+  truth tables.
+
+  \param first First truth table
+  \param second Second truth table
+  \param third Third truth table
+  \param op Ternary operation that takes as input three words (`uint64_t`) and returns a Boolean
+
+  \return true or false based on the predicate
+ */
+template<typename TT, typename Fn>
+bool ternary_predicate( const TT& first, const TT& second, const TT& third, Fn&& op )
+{
+  assert( first.num_blocks() == second.num_blocks() && first.num_blocks() == third.num_blocks() );
+
+  for ( auto i = 0u; i < first.num_blocks(); ++i )
+  {
+    if ( !op( first._bits[i], second._bits[i], third._bits[i] ) )
+    {
+      return false;
+    }
+  }
+  return true;
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars, typename Fn>
+bool ternary_predicate( const static_truth_table<NumVars, true>& first, const static_truth_table<NumVars, true>& second, const static_truth_table<NumVars, true>& third, Fn&& op )
+{
+  return op( first._bits, second._bits, third._bits );
+}
+/*! \endcond */
+
+/*! \brief Assign computed values to bits
+
+  The functor `op` computes bits which are assigned to the bits of the
+  truth table.
+
+  \param tt Truth table
+  \param op Unary operation that takes no input and returns a word (`uint64_t`)
+*/
+template<typename TT, typename Fn>
+void assign_operation( TT& tt, Fn&& op )
+{
+  std::generate( tt.begin(), tt.end(), op );
+  tt.mask_bits();
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars, typename Fn>
+void assign_operation( static_truth_table<NumVars, true>& tt, Fn&& op )
+{
+  tt._bits = op();
+  tt.mask_bits();
+}
+/*! \endcond */
+
+/*! \brief Iterates through each block of a truth table
+
+ The functor `op` is called for every block of the truth table.
+
+ \param tt Truth table
+ \param op Unary operation that takes as input a word (`uint64_t`) and returns void
+*/
+template<typename TT, typename Fn>
+void for_each_block( const TT& tt, Fn&& op )
+{
+  std::for_each( tt.cbegin(), tt.cend(), op );
+}
+
+/*! \brief Iterates through each block of a truth table in reverse
+    order
+
+ The functor `op` is called for every block of the truth table in
+ reverse order.
+
+ \param tt Truth table
+ \param op Unary operation that takes as input a word (`uint64_t`) and returns void
+*/
+template<typename TT, typename Fn>
+void for_each_block_reversed( const TT& tt, Fn&& op )
+{
+  std::for_each( tt.crbegin(), tt.crend(), op );
+}
+
+/*! \cond PRIVATE */
+template<typename TT, typename Fn>
+void for_each_one_bit_naive( const TT& tt, Fn&& op )
+{
+  for ( uint64_t bit = 0u; bit < tt.num_bits(); ++bit )
+  {
+    if ( get_bit( tt, bit ) )
+    {
+      op( bit );
+    }
+  }
+}
+/*! \endcond */
+
+/*! \cond PRIVATE */
+template<typename TT, typename Fn>
+void for_each_one_bit_jump( const TT& tt, Fn&& op )
+{
+  uint64_t offset = 0, low_bit, value;
+
+  for ( auto block : tt._bits )
+  {
+    while ( block )
+    {
+      low_bit = value = block - ( block & ( block - 1 ) );
+
+      value |= value >> 1;
+      value |= value >> 2;
+      value |= value >> 4;
+      value |= value >> 8;
+      value |= value >> 16;
+      value |= value >> 32;
+      op( offset + detail::de_bruijn64[( static_cast<uint64_t>( ( value - ( value >> 1 ) ) * UINT64_C( 0x07EDD5E59A4E28C2 ) ) ) >> 58] );
+
+      block ^= low_bit;
+    }
+    offset += 64;
+  }
+}
+
+template<uint32_t NumVars, typename Fn>
+void for_each_one_bit_jump( const static_truth_table<NumVars, true>& tt, Fn&& op )
+{
+  uint64_t block = tt._bits;
+
+  while ( block )
+  {
+    uint64_t low_bit = block - ( block & ( block - 1 ) );
+    uint64_t value = low_bit;
+
+    value |= value >> 1;
+    value |= value >> 2;
+    value |= value >> 4;
+    value |= value >> 8;
+    value |= value >> 16;
+    value |= value >> 32;
+    op( detail::de_bruijn64[( static_cast<uint64_t>( ( value - ( value >> 1 ) ) * UINT64_C( 0x07EDD5E59A4E28C2 ) ) ) >> 58] );
+
+    block ^= low_bit;
+  }
+}
+/*! \endcond */
+
+/*! \brief Iterates through each 1-bit in the truth table
+
+  The functor `op` is called for every bit position of the truth table
+  for which the bit is assigned 1.
+
+  \param tt Truth table
+  \param op Unary operation that takes as input a word (`uint64_t`) and returns void
+*/
+template<typename TT, typename Fn>
+inline void for_each_one_bit( const TT& tt, Fn&& op )
+{
+  for_each_one_bit_naive( tt, op );
+}
+} /* namespace kitty */
\ No newline at end of file
diff --git a/lib/kitty/kitty/bit_operations.hpp b/lib/kitty/kitty/bit_operations.hpp
new file mode 100644
index 0000000..7a0ef2b
--- /dev/null
+++ b/lib/kitty/kitty/bit_operations.hpp
@@ -0,0 +1,570 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file bit_operations.hpp
+  \brief Implements bit manipulation on truth tables
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <cassert>
+#include <numeric>
+#include <algorithm>
+
+#include "static_truth_table.hpp"
+#include "ternary_truth_table.hpp"
+#include "quaternary_truth_table.hpp"
+#include "partial_truth_table.hpp"
+#include "detail/mscfix.hpp"
+
+namespace kitty
+{
+
+/*! \brief Sets bit at index to true
+
+  \param tt Truth table
+  \param index Bit index
+*/
+template<typename TT>
+void set_bit( TT& tt, uint64_t index )
+{
+  tt._bits[index >> 6] |= uint64_t( 1 ) << ( index & 0x3f );
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+void set_bit( static_truth_table<NumVars, true>& tt, uint64_t index )
+{
+  tt._bits |= uint64_t( 1 ) << index;
+}
+
+template<typename TT>
+void set_bit( ternary_truth_table<TT>& tt, uint64_t index, bool value = true )
+{
+  set_bit( tt._care, index );
+  if ( value )
+    set_bit( tt._bits, index );
+  else
+    clear_bit( tt._bits, index );
+}
+
+template<typename TT>
+void set_bit( quaternary_truth_table<TT>& tt, uint64_t index, bool value = true )
+{
+  if ( value )
+  {
+    set_bit( tt._onset, index );
+    clear_bit( tt._offset, index );
+  }
+  else
+  {
+    clear_bit( tt._onset, index );
+    set_bit( tt._offset, index );
+  }
+}
+
+/*! \endcond */
+
+/*! \brief Gets bit at index
+
+  \param tt Truth table
+  \param index Bit index
+
+  \return 1 if bit is set, otherwise 0
+*/
+template<typename TT>
+auto get_bit( const TT& tt, uint64_t index )
+{
+  return ( tt._bits[index >> 6] >> ( index & 0x3f ) ) & 0x1;
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+auto get_bit( const static_truth_table<NumVars, true>& tt, uint64_t index )
+{
+  return ( tt._bits >> index ) & 0x1;
+}
+
+/*! \brief Gets bit at index
+
+\param tt Ternary truth table
+\param index Bit index
+
+\return 1 if bit is set, 0 if it is reset or if it is a don't care
+*/
+template<typename TT>
+auto get_bit( const ternary_truth_table<TT>& tt, uint64_t index )
+{
+  return get_bit( tt._bits, index );
+}
+
+/*! \brief Gets bit at index
+
+\param tt Ternary truth table
+\param index Bit index
+
+\return 1 if bit is set, 0 if it is reset, if it is a don't care, or if it is a don't know
+*/
+template<typename TT>
+auto get_bit( const quaternary_truth_table<TT>& tt, uint64_t index )
+{
+  return get_bit( tt._onset, index ) && !get_bit( tt._offset, index );
+}
+
+/*! \endcond */
+
+/*! \brief Clears bit at index (sets bit at index to false)
+
+  \param tt Truth table
+  \param index Bit index
+*/
+template<typename TT>
+void clear_bit( TT& tt, uint64_t index )
+{
+  tt._bits[index >> 6] &= ~( uint64_t( 1 ) << ( index & 0x3f ) );
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+void clear_bit( static_truth_table<NumVars, true>& tt, uint64_t index )
+{
+  tt._bits &= ~( uint64_t( 1 ) << index );
+}
+/*! \endcond */
+
+/*! \brief Flips bit at index
+
+  \param tt Truth table
+  \param index Bit index
+*/
+template<typename TT>
+void flip_bit( TT& tt, uint64_t index )
+{
+  tt._bits[index >> 6] ^= uint64_t( 1 ) << ( index & 0x3f );
+}
+
+template<typename TT>
+void flip_bit( ternary_truth_table<TT>& tt, uint64_t index )
+{
+  if ( !get_bit( tt._care, index ) )
+    return;
+  flip_bit( tt._bits, index );
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+void flip_bit( static_truth_table<NumVars, true>& tt, uint64_t index )
+{
+  tt._bits ^= uint64_t( 1 ) << index;
+}
+
+/*! \brief Checks if a bit in a ternary truth table is a don't care
+
+  \param tt Ternary truth table
+  \param index Bit index
+*/
+template<typename TT>
+bool is_dont_care( const ternary_truth_table<TT>& tt, uint64_t index )
+{
+  return !get_bit( tt._care, index );
+}
+
+/*! \brief Checks if a bit in a quaternary truth table is a don't care
+
+  \param tt Quaternary truth table
+  \param index Bit index
+*/
+template<typename TT>
+bool is_dont_care( const quaternary_truth_table<TT>& tt, uint64_t index )
+{
+  return get_bit( tt._onset, index ) && get_bit( tt._offset, index );
+}
+
+/*! \cond PRIVATE */
+template<typename TT>
+bool is_dont_care( const TT& tt, uint64_t index )
+{
+  return false;
+}
+
+/*! \brief Sets a bit in a ternary truth table as a don't care
+
+  \param tt Ternary truth table
+  \param index Bit index
+*/
+template<typename TT>
+void set_dont_care( ternary_truth_table<TT>& tt, uint64_t index )
+{
+  clear_bit( tt._care, index );
+  clear_bit( tt._bits, index );
+}
+
+/*! \brief Sets a bit in a quaternary truth table as a don't care
+
+  \param tt Ternary truth table
+  \param index Bit index
+*/
+template<typename TT>
+void set_dont_care( quaternary_truth_table<TT>& tt, uint64_t index )
+{
+  set_bit( tt._onset, index );
+  set_bit( tt._offset, index );
+}
+
+/*! \brief Checks if a bit in a ternary truth table is a don't know
+
+  \param tt Ternary truth table
+  \param index Bit index
+*/
+template<typename TT>
+bool is_dont_know( const ternary_truth_table<TT>& tt, uint64_t index )
+{
+  return !get_bit( tt._care, index );
+}
+
+/*! \brief Checks if a bit in a quaternary truth table is a don't care
+
+  \param tt Ternary truth table
+  \param index Bit index
+*/
+template<typename TT>
+bool is_dont_know( const quaternary_truth_table<TT>& tt, uint64_t index )
+{
+  return !get_bit( tt._onset, index ) && !get_bit( tt._offset, index );
+}
+
+/*! \cond PRIVATE */
+template<typename TT>
+bool is_dont_know( const TT& tt, uint64_t index )
+{
+  return false;
+}
+
+template<typename TT>
+void set_dont_know( quaternary_truth_table<TT>& tt, uint64_t index )
+{
+  clear_bit( tt._onset, index );
+  clear_bit( tt._offset, index );
+}
+
+/*! Returns a block of bits vector.
+ */
+template<typename TT>
+uint64_t get_block( const TT& tt, uint64_t block_index )
+{
+  return tt._bits[block_index];
+}
+
+template<uint32_t NumVars>
+uint64_t get_block( const static_truth_table<NumVars, true>& tt, uint64_t block_index )
+{
+  return tt._bits;
+}
+
+/*! \brief Copies bit at index
+
+  Copy the bit from `tt_from` at index `index_from` to `tt_to` at index `index_to`.
+
+  \param tt_from Truth table to copy from
+  \param index_from Bit index to copy from
+  \param tt_to Truth table to write to
+  \param index_to Bit index to write to
+*/
+template<typename TTfrom, typename TTto>
+void copy_bit( const TTfrom& tt_from, uint64_t index_from, TTto& tt_to, uint64_t index_to )
+{
+  if ( get_bit( tt_from, index_from ) )
+  {
+    set_bit( tt_to, index_to );
+  }
+  else
+  {
+    clear_bit( tt_to, index_to );
+  }
+}
+
+/*! \brief Clears all bits
+
+  \param tt Truth table
+*/
+template<typename TT>
+void clear( TT& tt )
+{
+  std::fill( std::begin( tt._bits ), std::end( tt._bits ), 0 );
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+void clear( static_truth_table<NumVars, true>& tt )
+{
+  tt._bits = 0;
+}
+/*! \endcond */
+
+/*! \brief Count ones in truth table
+
+  \param tt Truth table
+*/
+template<typename TT>
+inline uint64_t count_ones( const TT& tt )
+{
+  return std::accumulate( tt.cbegin(), tt.cend(), uint64_t( 0 ),
+                          []( auto accu, auto word )
+                          {
+                            return accu + __builtin_popcount( word & 0xffffffff ) + __builtin_popcount( word >> 32 );
+                          } );
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+inline uint64_t count_ones( const static_truth_table<NumVars, true>& tt )
+{
+  return __builtin_popcount( tt._bits & 0xffffffff ) + __builtin_popcount( tt._bits >> 32 );
+}
+/*! \endcond */
+
+/*! \brief Count zeros in truth table
+
+  \param tt Truth table
+*/
+template<typename TT>
+inline uint64_t count_zeros( const TT& tt )
+{
+  return count_ones( ~tt );
+}
+
+/*! \cond PRIVATE */
+inline int64_t find_first_bit_in_word( uint64_t word )
+{
+  int64_t n = 0;
+  if ( word == 0 )
+  {
+    return -1;
+  }
+
+  if ( ( word & UINT64_C( 0x00000000FFFFFFFF ) ) == 0 )
+  {
+    n += 32;
+    word >>= 32;
+  }
+  if ( ( word & UINT64_C( 0x000000000000FFFF ) ) == 0 )
+  {
+    n += 16;
+    word >>= 16;
+  }
+  if ( ( word & UINT64_C( 0x00000000000000FF ) ) == 0 )
+  {
+    n += 8;
+    word >>= 8;
+  }
+  if ( ( word & UINT64_C( 0x000000000000000F ) ) == 0 )
+  {
+    n += 4;
+    word >>= 4;
+  }
+  if ( ( word & UINT64_C( 0x0000000000000003 ) ) == 0 )
+  {
+    n += 2;
+    word >>= 2;
+  }
+  if ( ( word & UINT64_C( 0x0000000000000001 ) ) == 0 )
+  {
+    n++;
+  }
+
+  return n;
+}
+
+inline int64_t find_last_bit_in_word( uint64_t word )
+{
+  int64_t n = 0;
+  if ( word == 0 )
+  {
+    return -1;
+  }
+
+  if ( ( word & UINT64_C( 0xFFFFFFFF00000000 ) ) == 0 )
+  {
+    n += 32;
+    word <<= 32;
+  }
+  if ( ( word & UINT64_C( 0xFFFF000000000000 ) ) == 0 )
+  {
+    n += 16;
+    word <<= 16;
+  }
+  if ( ( word & UINT64_C( 0xFF00000000000000 ) ) == 0 )
+  {
+    n += 8;
+    word <<= 8;
+  }
+  if ( ( word & UINT64_C( 0xF000000000000000 ) ) == 0 )
+  {
+    n += 4;
+    word <<= 4;
+  }
+  if ( ( word & UINT64_C( 0xC000000000000000 ) ) == 0 )
+  {
+    n += 2;
+    word <<= 2;
+  }
+  if ( ( word & UINT64_C( 0x8000000000000000 ) ) == 0 )
+  {
+    n++;
+  }
+
+  return 63 - n;
+}
+/*! \endcond */
+
+/*! \brief Finds least-significant one-bit
+
+  Returns -1, if truth table is constant 0.
+
+  \param tt Truth table
+  \param start Bit to start from (default is 0)
+*/
+template<typename TT>
+int64_t find_first_one_bit( const TT& tt, int64_t start = 0 )
+{
+  uint64_t mask = ~( ( UINT64_C( 1 ) << uint64_t( start % 64 ) ) - 1u );
+  auto it = tt.cbegin() + ( start >> 6 );
+  if ( it != tt.cend() && ( *it & mask ) != 0 )
+  {
+    return 64 * std::distance( tt.cbegin(), it ) + find_first_bit_in_word( *it & mask );
+  }
+  else if ( it == tt.cend() )
+  {
+    return -1;
+  }
+
+  it = std::find_if( it + 1, tt.cend(), []( auto word )
+                     { return word != 0; } );
+
+  if ( it == tt.cend() )
+  {
+    return -1;
+  }
+
+  return 64 * std::distance( tt.cbegin(), it ) + find_first_bit_in_word( *it );
+}
+
+/*! \brief Finds most-significant one-bit
+
+  Returns -1, if truth table is constant 0.
+
+  \param tt Truth table
+*/
+template<typename TT>
+int64_t find_last_one_bit( const TT& tt )
+{
+  const auto it = std::find_if( tt.crbegin(), tt.crend(), []( auto word )
+                                { return word != 0; } );
+
+  if ( it == tt.crend() )
+  {
+    return -1;
+  }
+
+  return 64 * ( std::distance( it, tt.crend() ) - 1 ) + find_last_bit_in_word( *it );
+}
+
+/*! \brief Finds least-significant bit difference
+
+  Returns -1, if truth tables are the same
+
+  \param first First truth table
+  \param second Second truth table
+*/
+template<typename TT>
+int64_t find_first_bit_difference( const TT& first, const TT& second )
+{
+  if constexpr ( std::is_same<TT, partial_truth_table>::value )
+  {
+    assert( first.num_bits() == second.num_bits() );
+  }
+  else
+  {
+    assert( first.num_vars() == second.num_vars() );
+  }
+
+  auto it = first.cbegin();
+  auto it2 = second.cbegin();
+  auto w = 0;
+
+  while ( it != first.cend() )
+  {
+    if ( *it ^ *it2 )
+    {
+      return 64 * w + find_first_bit_in_word( *it ^ *it2 );
+    }
+    ++it;
+    ++it2;
+    ++w;
+  }
+  return -1;
+}
+
+/*! \brief Finds most-significant bit difference
+
+  Returns -1, if truth tables are the same
+
+  \param first First truth table
+  \param second Second truth table
+*/
+template<typename TT>
+int64_t find_last_bit_difference( const TT& first, const TT& second )
+{
+  if constexpr ( std::is_same<TT, partial_truth_table>::value )
+  {
+    assert( first.num_bits() == second.num_bits() );
+  }
+  else
+  {
+    assert( first.num_vars() == second.num_vars() );
+  }
+
+  auto it = first.crbegin();
+  auto it2 = second.crbegin();
+  auto w = first.num_blocks() - 1;
+
+  while ( it != first.crend() )
+  {
+    if ( *it ^ *it2 )
+    {
+      return 64 * w + find_last_bit_in_word( *it ^ *it2 );
+    }
+    ++it;
+    ++it2;
+    --w;
+  }
+  return -1;
+}
+
+} // namespace kitty
\ No newline at end of file
diff --git a/lib/kitty/kitty/cnf.hpp b/lib/kitty/kitty/cnf.hpp
new file mode 100644
index 0000000..5073354
--- /dev/null
+++ b/lib/kitty/kitty/cnf.hpp
@@ -0,0 +1,79 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cnf.hpp
+  \brief Implements methods to compute conjunctive normal forms (CNF)
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <vector>
+
+#include "cube.hpp"
+#include "isop.hpp"
+#include "operators.hpp"
+#include "traits.hpp"
+
+namespace kitty
+{
+
+/*! \brief Create CNF of the characteristic function
+
+  Creates a CNF representation for the characteritic function of the input
+  function, also known as Tseytin transformation.  To obtain small CNF,
+  an ISOP is computed.
+
+  \param tt Truth table
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+std::vector<cube> cnf_characteristic( const TT& tt )
+{
+  std::vector<cube> cubes;
+  detail::isop_rec( tt, tt, tt.num_vars(), cubes );
+
+  for ( auto& cube : cubes )
+  {
+    cube._bits = ~cube._bits & cube._mask;
+    cube.add_literal( tt.num_vars(), true );
+  }
+
+  const auto end = cubes.size();
+
+  detail::isop_rec( ~tt, ~tt, tt.num_vars(), cubes );
+
+  for ( auto i = end; i < cubes.size(); ++i )
+  {
+    auto& cube = cubes[i];
+    cube._bits = ~cube._bits & cube._mask;
+    cube.add_literal( tt.num_vars(), false );
+  }
+
+  return cubes;
+}
+
+} // namespace kitty
\ No newline at end of file
diff --git a/lib/kitty/kitty/constructors.hpp b/lib/kitty/kitty/constructors.hpp
new file mode 100644
index 0000000..61f7262
--- /dev/null
+++ b/lib/kitty/kitty/constructors.hpp
@@ -0,0 +1,1577 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file constructors.hpp
+  \brief Implements operations to construct truth tables
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cctype>
+#include <chrono>
+#include <istream>
+#include <random>
+#include <stack>
+#include <string>
+
+#include "cube.hpp"
+#include "detail/constants.hpp"
+#include "detail/mscfix.hpp"
+#include "detail/utils.hpp"
+#include "dynamic_truth_table.hpp"
+#include "operations.hpp"
+#include "operators.hpp"
+#include "static_truth_table.hpp"
+#include "partial_truth_table.hpp"
+
+namespace kitty
+{
+
+/*! \brief Creates truth table with number of variables
+
+  If some truth table instance is given, one can create a truth table with the
+  same type by calling the `construct()` method on it.  This function helps if
+  only the number of variables is known and the base type and uniforms the
+  creation of static and dynamic truth tables.  Note, however, that for static
+  truth tables `num_vars` must be consistent to the number of variables in the
+  truth table type.
+
+  \param num_vars Number of variables
+*/
+template<typename TT>
+inline TT create( unsigned num_vars )
+{
+  (void)num_vars;
+  TT tt;
+  assert( tt.num_vars() == num_vars );
+  return tt;
+}
+
+/*! \cond PRIVATE */
+template<>
+inline dynamic_truth_table create<dynamic_truth_table>( unsigned num_vars )
+{
+  return dynamic_truth_table( num_vars );
+}
+/*! \endcond */
+
+/*! \cond PRIVATE */
+template<>
+inline partial_truth_table create<partial_truth_table>( unsigned num_vars )
+{
+  return partial_truth_table( 1 << num_vars );
+}
+/*! \endcond */
+
+/*! \brief Constructs projections (single-variable functions)
+
+  \param tt Truth table
+  \param var_index Index of the variable, must be smaller than the truth table's number of variables
+  \param complement If true, realize inverse projection
+*/
+template<typename TT>
+void create_nth_var( TT& tt, uint8_t var_index, bool complement = false )
+{
+  if constexpr ( std::is_same<TT, partial_truth_table>::value )
+  {
+    assert( tt.num_bits() >= ( UINT64_C( 1 ) << var_index ) );
+    if ( tt.num_bits() <= 64 )
+    {
+      /* assign from precomputed table */
+      tt._bits[0] = complement ? ~detail::projections[var_index] : detail::projections[var_index];
+
+      /* mask if truth table does not require all bits */
+      tt.mask_bits();
+      return;
+    }
+  }
+  else
+  {
+    if ( tt.num_vars() <= 6 )
+    {
+      /* assign from precomputed table */
+      tt._bits[0] = complement ? ~detail::projections[var_index] : detail::projections[var_index];
+
+      /* mask if truth table does not require all bits */
+      tt.mask_bits();
+      return;
+    }
+  }
+
+  if ( var_index < 6 )
+  {
+    std::fill( std::begin( tt._bits ), std::end( tt._bits ), complement ? ~detail::projections[var_index] : detail::projections[var_index] );
+  }
+  else
+  {
+    const auto c = 1 << ( var_index - 6 );
+    const auto zero = uint64_t( 0 );
+    const auto one = ~zero;
+    auto block = uint64_t( 0u );
+
+    while ( block < tt.num_blocks() )
+    {
+      for ( auto i = 0; i < c; ++i )
+      {
+        tt._bits[block++] = complement ? one : zero;
+      }
+      for ( auto i = 0; i < c; ++i )
+      {
+        tt._bits[block++] = complement ? zero : one;
+      }
+    }
+  }
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+void create_nth_var( static_truth_table<NumVars, true>& tt, uint8_t var_index, bool complement = false )
+{
+  /* assign from precomputed table */
+  tt._bits = complement ? ~detail::projections[var_index] : detail::projections[var_index];
+
+  /* mask if truth table does not require all bits */
+  tt.mask_bits();
+}
+/*! \endcond */
+
+/*! \brief Constructs projections (single-variable functions) out-of-place
+
+  \param tt Truth table
+  \param var_index Index of the variable, must be smaller than the truth table's number of variables
+  \param complement If true, realize inverse projection
+*/
+template<class TT>
+TT nth_var( uint8_t num_vars, uint8_t var_index, bool complement = false )
+{
+  TT tt = create<TT>( num_vars );
+  create_nth_var( tt, var_index, complement );
+  return tt;
+}
+
+/*! \brief Constructs truth table from binary string
+
+  Note that the first character in the string represents the most
+  significant bit in the truth table.  For example, the 2-input AND
+  function is represented by the binary string "1000".  The number of
+  characters in `binary` must match the number of bits in `tt`.
+
+  \param tt Truth table
+  \param binary Binary string with as many characters as bits in the truth table
+*/
+template<typename TT>
+void create_from_binary_string( TT& tt, const std::string& binary )
+{
+  assert( binary.size() == tt.num_bits() );
+
+  clear( tt );
+
+  size_t i = 0u, j = binary.size();
+  do
+  {
+    --j;
+    if ( binary[i++] == '1' )
+    {
+      set_bit( tt, j );
+    }
+  } while ( j );
+}
+
+/*! \brief Constructs truth table from hexadecimal string
+
+  Note that the first character in the string represents the four most
+  significant bit in the truth table.  For example, the 3-input
+  majority function is represented by the binary string "E8" or "e8".
+  The number of characters in `hex` must be one fourth the number of
+  bits in `tt`.
+
+  \param tt Truth table
+  \param hex Hexadecimal string
+*/
+template<typename TT>
+void create_from_hex_string( TT& tt, const std::string& hex )
+{
+  clear( tt );
+
+  /* special case for small truth tables */
+  if ( tt.num_vars() < 2 )
+  {
+    assert( hex.size() == 1 );
+    const auto i = detail::hex_to_int[static_cast<unsigned char>( hex[0] )];
+    if ( i & 1 )
+    {
+      set_bit( tt, 0 );
+    }
+    if ( tt.num_vars() == 1u && ( i & 2 ) )
+    {
+      set_bit( tt, 1 );
+    }
+    return;
+  }
+
+  assert( ( hex.size() << 2 ) == tt.num_bits() );
+
+  auto j = tt.num_bits() - 1;
+
+  for ( unsigned char c : hex )
+  {
+    const auto i = detail::hex_to_int[c];
+    if ( i & 8 )
+    {
+      set_bit( tt, j );
+    }
+    if ( i & 4 )
+    {
+      set_bit( tt, j - 1 );
+    }
+    if ( i & 2 )
+    {
+      set_bit( tt, j - 2 );
+    }
+    if ( i & 1 )
+    {
+      set_bit( tt, j - 3 );
+    }
+    j -= 4;
+  }
+}
+
+/*! \cond PRIVATE */
+template<typename = std::void_t<>>
+void create_from_hex_string( partial_truth_table& tt, const std::string& hex )
+{
+  clear( tt );
+
+  const auto len = hex.size() << 2;
+  assert( len >= tt.num_bits() && "truth table length too long" );
+  assert( ( len - 4 ) < tt.num_bits() && "truth table length too short" );
+
+  auto j = tt.num_bits() - 1;
+
+  /* the first char; may not use all 4 bits */
+  auto i = detail::hex_to_int[static_cast<unsigned char>( hex[0] )];
+
+  auto s = len - tt.num_bits(); /* number of leading bits not used. 0 <= s < 4 */
+
+  if ( ( s <= 0u ) && ( i & 8 ) )
+  {
+    set_bit( tt, j );
+  }
+  if ( ( s <= 1u ) && ( i & 4 ) )
+  {
+    set_bit( tt, j + s - 1 );
+  }
+  if ( ( s <= 2u ) && ( i & 2 ) )
+  {
+    set_bit( tt, j + s - 2 );
+  }
+  if ( ( s <= 3u ) && ( i & 1 ) )
+  {
+    set_bit( tt, j + s - 3 );
+  }
+  j -= static_cast<uint32_t>( 4u - s );
+
+  for ( auto c = 1u; c < hex.size(); ++c )
+  {
+    i = detail::hex_to_int[static_cast<unsigned char>( hex[c] )];
+    if ( i & 8 )
+    {
+      set_bit( tt, j );
+    }
+    if ( i & 4 )
+    {
+      set_bit( tt, j - 1 );
+    }
+    if ( i & 2 )
+    {
+      set_bit( tt, j - 2 );
+    }
+    if ( i & 1 )
+    {
+      set_bit( tt, j - 3 );
+    }
+    j -= 4;
+  }
+}
+/*! \endcond */
+
+/*! \brief Creates string from raw character data
+
+  Can create a truth table from the data that is produced by
+  `print_raw`, e.g., from binary files or `std::stringstream`.
+
+  \param tt Truth table
+  \param in Input stream
+*/
+template<typename TT>
+void create_from_raw( TT& tt, std::istream& in )
+{
+  std::for_each( tt.begin(), tt.end(), [&in]( auto& word )
+                 { in.read( reinterpret_cast<char*>( &word ), sizeof( word ) ); } );
+}
+
+/*! \brief Constructs a truth table from random value
+
+  Computes random words and assigns them to the truth table.  The
+  number of variables is determined from the truth table.
+
+  \param tt Truth table
+  \param seed Random seed
+*/
+template<typename TT>
+void create_random( TT& tt, std::default_random_engine::result_type seed )
+{
+  std::default_random_engine gen( seed );
+  std::uniform_int_distribution<uint64_t> dist( 0ul, std::numeric_limits<uint64_t>::max() );
+
+  assign_operation( tt, [&dist, &gen]()
+                    { return dist( gen ); } );
+}
+
+/*! \brief Constructs a truth table from random value
+
+  Computes random words and assigns them to the truth table.  The
+  number of variables is determined from the truth table.  Seed is
+  taken from current time.
+
+  \param tt Truth table
+*/
+template<typename TT>
+void create_random( TT& tt )
+{
+  create_random( tt, static_cast<std::default_random_engine::result_type>( std::chrono::system_clock::now().time_since_epoch().count() ) );
+}
+
+/*! \brief Constructs a truth table from a range of words
+
+  The range of words is given in terms of a begin and end iterator.
+  Hence, it's possible to copy words from a C++ container or a C
+  array.
+
+  \param tt Truth table
+  \param begin Begin iterator
+  \param end End iterator
+*/
+template<typename TT, typename InputIt>
+void create_from_words( TT& tt, InputIt begin, InputIt end )
+{
+  assert( std::distance( begin, end ) == static_cast<unsigned>( tt.num_blocks() ) );
+  std::copy( begin, end, tt.begin() );
+}
+
+/*! \brief Creates truth table from cubes representation
+
+  A sum-of-product is represented as a vector of products (called
+  cubes).
+
+  An empty truth table is given as first argument to determine type
+  and number of variables.  Literals in products that do not fit the
+  number of variables of the truth table are ignored.
+
+  The cube representation only allows truth table sizes up to 32
+  variables.
+
+  \param tt Truth table
+  \param cubes Vector of cubes
+  \param esop Use ESOP instead of SOP
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void create_from_cubes( TT& tt, const std::vector<cube>& cubes, bool esop = false )
+{
+  /* we collect product terms for an (E)SOP, start with const0 */
+  clear( tt );
+
+  for ( auto cube : cubes )
+  {
+    auto product = ~tt.construct(); /* const1 of same size */
+
+    auto bits = cube._bits;
+    auto mask = cube._mask;
+
+    for ( auto i = 0u; i < tt.num_vars(); ++i )
+    {
+      if ( mask & 1 )
+      {
+        auto var = tt.construct();
+        create_nth_var( var, i, !( bits & 1 ) );
+        product &= var;
+      }
+      bits >>= 1;
+      mask >>= 1;
+    }
+
+    if ( esop )
+    {
+      tt ^= product;
+    }
+    else
+    {
+      tt |= product;
+    }
+  }
+}
+
+/*! \brief Creates truth table from clause representation
+
+  A product-of-sum is represented as a vector of sums (called clauses).
+
+  An empty truth table is given as first argument to determine type
+  and number of variables.  Literals in sums that do not fit the
+  number of variables of the truth table are ignored.
+
+  The clause representation only allows truth table sizes up to 32
+  variables.
+
+  \param tt Truth table
+  \param clauses Vector of clauses
+  \param esop Use product of exclusive sums instead of POS
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void create_from_clauses( TT& tt, const std::vector<cube>& clauses, bool esop = false )
+{
+  /* we collect product terms for an (E)SOP, start with const0 */
+  clear( tt );
+  tt = ~tt;
+
+  for ( auto clause : clauses )
+  {
+    auto sum = tt.construct(); /* const1 of same size */
+
+    auto bits = clause._bits;
+    auto mask = clause._mask;
+
+    for ( auto i = 0u; i < tt.num_vars(); ++i )
+    {
+      if ( mask & 1 )
+      {
+        auto var = tt.construct();
+        create_nth_var( var, i, !( bits & 1 ) );
+
+        if ( esop )
+        {
+          sum ^= var;
+        }
+        else
+        {
+          sum |= var;
+        }
+      }
+      bits >>= 1;
+      mask >>= 1;
+    }
+
+    tt &= sum;
+  }
+}
+
+/*! \brief Constructs majority-n function
+
+  The number of variables is determined from the truth table.
+
+  \param tt Truth table
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+inline void create_majority( TT& tt )
+{
+  create_threshold( tt, tt.num_vars() >> 1 );
+}
+
+/*! \brief Constructs threshold function
+
+  The resulting function is true, if strictly more than `threshold` inputs are
+  1. The number of variables is determined from the truth table.
+
+  \param tt Truth table
+  \param threshold threshold value
+*/
+template<typename TT>
+void create_threshold( TT& tt, uint8_t threshold )
+{
+  clear( tt );
+
+  for ( uint64_t x = 0; x < tt.num_bits(); ++x )
+  {
+    if ( __builtin_popcount( static_cast<uint32_t>( x ) ) > threshold )
+    {
+      set_bit( tt, x );
+    }
+  }
+}
+
+/*! \brief Constructs equals-k function
+
+  The resulting function is true, if exactly `bitcount` bits are 1.  The number
+  of variables is determiend from the truth table.
+
+  \param tt Truth table
+  \param bitcount equals-k value
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void create_equals( TT& tt, uint8_t bitcount )
+{
+  clear( tt );
+  if ( bitcount > tt.num_vars() )
+    return;
+
+  if ( tt.num_vars() <= 6 )
+  {
+    const auto word = detail::onehots[tt.num_vars()][bitcount];
+    create_from_words( tt, &word, &word + 1 );
+  }
+  else
+  {
+    for ( uint64_t x = 0; x < tt.num_bits(); ++x )
+    {
+      if ( __builtin_popcount( static_cast<uint32_t>( x ) ) == bitcount )
+      {
+        set_bit( tt, x );
+      }
+    }
+  }
+}
+
+/*! \brief Constructs symmetric function
+
+  Bits in `counts` are numbered from 0 to 63.  If bit `i` is set in `counts`,
+  the created truth table will evaluate to true, if `i` bits are set in the
+  input assignment.
+
+  \param tt Truth table
+  \param counts Bitcount mask
+*/
+template<typename TT>
+void create_symmetric( TT& tt, uint64_t counts )
+{
+  clear( tt );
+
+  for ( uint64_t x = 0; x < tt.num_bits(); ++x )
+  {
+    if ( ( counts >> __builtin_popcount( static_cast<uint32_t>( x ) ) ) & 1 )
+    {
+      set_bit( tt, x );
+    }
+  }
+}
+
+/*! \brief Constructs parity function over n variables
+
+  The number of variables is determined from the truth table.
+
+  \param tt Truth table
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void create_parity( TT& tt )
+{
+  clear( tt );
+
+  *tt.begin() = UINT64_C( 0x6996966996696996 );
+
+  if ( tt.num_vars() < 6 )
+  {
+    tt.mask_bits();
+  }
+  else if ( tt.num_vars() > 6 )
+  {
+    for ( auto i = 1u; i < tt.num_blocks(); i <<= 1 )
+    {
+      std::transform( tt.begin(), tt.begin() + i, tt.begin() + i, []( auto const& block )
+                      { return ~block; } );
+    }
+  }
+}
+
+/*! \cond PRIVATE */
+template<typename TT, typename Fn, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+bool create_from_chain( TT& tt, Fn&& next_line, std::vector<TT>& steps, std::string* error )
+{
+  /* in case of error (makes code more readable) */
+  auto fail_with = [&error]( const std::string& line, const std::string& message )
+  {
+    if ( error )
+    {
+      *error = "error in \"" + line + "\": " + message;
+    }
+    return false;
+  };
+
+  /* initialize variable steps */
+  steps.clear();
+  for ( auto i = 0u; i < tt.num_vars(); ++i )
+  {
+    auto var = tt.construct();
+    create_nth_var( var, i );
+    steps.push_back( var );
+  }
+
+  auto next_step = tt.num_vars() + 1;
+
+  std::string line;
+  while ( !( line = next_line() ).empty() )
+  {
+    detail::trim( line );
+
+    /* first character must be an x */
+    if ( line[0] != 'x' )
+    {
+      return fail_with( line, "variables must be prefixed with x" );
+    }
+
+    /* find equals sign */
+    const auto eq = line.find( '=' );
+    if ( eq == std::string::npos )
+    {
+      return fail_with( line, "no equal sign found" );
+    }
+
+    /* next step id */
+    const auto step = static_cast<uint32_t>( std::stoul( line.substr( 1, eq - 1 ) ) );
+    if ( step != next_step )
+    {
+      return fail_with( line, "steps are not in order" );
+    }
+
+    line = detail::trim_copy( line.substr( eq + 1 ) );
+
+    if ( line.empty() )
+    {
+      return fail_with( line, "line uncompleted" );
+    }
+
+    /* first character must be an x */
+    if ( line[0] != 'x' )
+    {
+      return fail_with( line, "variables must be prefixed with x" );
+    }
+
+    std::size_t op_pos = 0;
+    const auto op1 = static_cast<uint32_t>( std::stoul( line.substr( 1 ), &op_pos ) );
+
+    if ( op1 < 1 || op1 >= step )
+    {
+      return fail_with( line, "invalid operand index" );
+    }
+
+    line = detail::trim_copy( line.substr( op_pos + 1 ) );
+
+    if ( line.empty() )
+    {
+      return fail_with( line, "line uncompleted" );
+    }
+
+    const auto next_x = line.find( 'x' );
+
+    if ( next_x == std::string::npos )
+    {
+      return fail_with( line, "variables must be prefixed with x" );
+    }
+
+    const auto op_code = detail::trim_copy( line.substr( 0, next_x ) );
+
+    line = detail::trim_copy( line.substr( next_x ) );
+
+    if ( line.empty() )
+    {
+      return fail_with( line, "line uncompleted" );
+    }
+
+    /* first character must be an x */
+    if ( line[0] != 'x' )
+    {
+      return fail_with( line, "variables must be prefixed with x" );
+    }
+
+    const auto op2 = static_cast<uint32_t>( std::stoul( line.substr( 1 ) ) );
+
+    if ( op2 < 1 || op2 >= step )
+    {
+      return fail_with( line, "invalid operand index" );
+    }
+
+    /* now process arguments */
+    auto tt_step = tt.construct();
+
+    if ( op_code == "!|" )
+    {
+      tt_step = ~binary_or( steps[op1 - 1], steps[op2 - 1] );
+    }
+    else if ( op_code == ">" )
+    {
+      tt_step = binary_and( steps[op1 - 1], ~steps[op2 - 1] );
+    }
+    else if ( op_code == "<" )
+    {
+      tt_step = binary_and( ~steps[op1 - 1], steps[op2 - 1] );
+    }
+    else if ( op_code == "^" )
+    {
+      tt_step = binary_xor( steps[op1 - 1], steps[op2 - 1] );
+    }
+    else if ( op_code == "!&" )
+    {
+      tt_step = ~binary_and( steps[op1 - 1], steps[op2 - 1] );
+    }
+    else if ( op_code == "&" )
+    {
+      tt_step = binary_and( steps[op1 - 1], steps[op2 - 1] );
+    }
+    else if ( op_code == "=" )
+    {
+      tt_step = ~binary_xor( steps[op1 - 1], steps[op2 - 1] );
+    }
+    else if ( op_code == "<=" )
+    {
+      tt_step = binary_or( ~steps[op1 - 1], steps[op2 - 1] );
+    }
+    else if ( op_code == ">=" )
+    {
+      tt_step = binary_or( steps[op1 - 1], ~steps[op2 - 1] );
+    }
+    else if ( op_code == "|" )
+    {
+      tt_step = binary_or( steps[op1 - 1], steps[op2 - 1] );
+    }
+    else
+    {
+      return fail_with( op_code, "invalid operator" );
+    }
+    steps.push_back( tt_step );
+    ++next_step;
+  }
+
+  return true;
+}
+/*! \endcond */
+
+/*! \brief Constructs truth table from Boolean chain
+
+  If ``tt`` has \f$n\f$ variables, then each string in ``steps`` is of the form
+
+  \verbatim embed:rst
+      ::
+
+        x<i> = x<j> <op> x<k>
+  \endverbatim
+
+  where ``<i>`` is an increasing number starting from \f$n + 1\f$, and ``<j>``
+  and ``<k>`` refer to previous steps or primary inputs where \f$j < i\f$ and
+  \f$k < i\f$.  Primary inputs are indexed from \f$1\f$ to \f$n\f$.  The last
+  computed step will be assigned to ``tt``.  The following operators are
+  supported:
+
+  \verbatim embed:rst
+      +----------+-------------------------+-------------+
+      | ``<op>`` | Operation               | Truth table |
+      +==========+=========================+=============+
+      | ``"!|"`` | Nondisjunction          | 0001        |
+      +----------+-------------------------+-------------+
+      | ``">"``  | Nonimplication          | 0010        |
+      +----------+-------------------------+-------------+
+      | ``"<"``  | Converse nonimplication | 0100        |
+      +----------+-------------------------+-------------+
+      | ``"^"``  | Exclusive disjunction   | 0110        |
+      +----------+-------------------------+-------------+
+      | ``"!&"`` | Nonconjunction          | 0111        |
+      +----------+-------------------------+-------------+
+      | ``"&"``  | Conjunction             | 1000        |
+      +----------+-------------------------+-------------+
+      | ``"="``  | Equivalence             | 1001        |
+      +----------+-------------------------+-------------+
+      | ``">="`` | Nonimplication          | 1011        |
+      +----------+-------------------------+-------------+
+      | ``"<="`` | Implication             | 1101        |
+      +----------+-------------------------+-------------+
+      | ``"|"``  | Disjunction             | 1110        |
+      +----------+-------------------------+-------------+
+  \endverbatim
+
+  The following example will generate the majority function:
+
+  \verbatim embed:rst
+      .. code-block:: cpp
+
+         kitty::static_truth_table<3> tt;
+         kitty::create_from_chain( tt, {"x4 = x1 & x2",
+                                        "x5 = x1 & x3",
+                                        "x6 = x2 & x3",
+                                        "x7 = x4 | x5",
+                                        "x8 = x6 | x7"} );
+  \endverbatim
+
+  If parsing fails, the function returns ``false``, and if ``error`` is not
+  ``nullptr``, it contains a descriptive reason, why parsing failed.  Otherwise,
+  the function returns ``true``.
+
+  \param tt Truth table
+  \param steps Vector of steps
+  \param error If not null, a pointer to store the error message
+
+  \return True on success
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+bool create_from_chain( TT& tt, const std::vector<std::string>& steps, std::string* error = nullptr )
+{
+  std::vector<TT> vec_steps;
+  auto it = steps.begin();
+  if ( !create_from_chain(
+           tt, [&it, &steps]()
+           { return ( it != steps.end() ) ? *it++ : std::string(); },
+           vec_steps, error ) )
+  {
+    return false;
+  }
+
+  tt = vec_steps.back();
+  return true;
+}
+
+/*! \brief Constructs truth tables from Boolean chain
+
+  Like ``create_from_chain``, but also returns all internally computed steps.
+
+  \param num_vars Number of input variables
+  \param tts Truth table for all steps, tt[i] corresponds to step x\f$(i + 1)\f$
+  \param steps Vector of steps
+  \param error If not null, a pointer to store the error message
+
+  \return True on success
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+bool create_multiple_from_chain( unsigned num_vars, std::vector<TT>& tts, const std::vector<std::string>& steps, std::string* error = nullptr )
+{
+  auto tt = create<TT>( num_vars );
+  tts.clear();
+  auto it = steps.begin();
+  if ( !create_from_chain(
+           tt, [&it, &steps]()
+           { return ( it != steps.end() ) ? *it++ : std::string(); },
+           tts, error ) )
+  {
+    return false;
+  }
+
+  tt = tts.back();
+  return true;
+}
+
+/*! \brief Constructs truth table from Boolean chain
+
+  Like the other ``create_from_chain`` function, but reads chain from an input
+  stream instead of a vector of strings.  Lines are separated by a new line.
+  Empty lines are skipped over.
+
+  \param tt Truth table
+  \param in Input stream to read chain
+  \param error If not null, a pointer to store the error message
+
+  \return True on success
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+bool create_from_chain( TT& tt, std::istream& in, std::string* error = nullptr )
+{
+  std::vector<TT> vec_steps;
+  if ( !create_from_chain(
+           tt, [&in]()
+           {
+    std::string line;
+    while ( true )
+    {
+      if ( std::getline( in, line ) )
+      {
+        detail::trim( line );
+        if ( !line.empty() )
+        {
+          return line;
+        }
+      }
+      else
+      {
+        return std::string();
+      }
+    } },
+           vec_steps, error ) )
+  {
+    return false;
+  }
+
+  tt = vec_steps.back();
+  return true;
+}
+
+/*! \brief Constructs truth tables from Boolean chain
+
+  Like ``create_from_chain``, but also returns all internally computed steps.
+
+  \param num_vars Number of input variables
+  \param tts Truth table for all steps, tt[i] corresponds to step x\f$(i + 1)\f$
+  \param in Input stream to read chain
+  \param error If not null, a pointer to store the error message
+
+  \return True on success
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+bool create_multiple_from_chain( unsigned num_vars, std::vector<TT>& tts, std::istream& in, std::string* error = nullptr )
+{
+  auto tt = create<TT>( num_vars );
+  tts.clear();
+  if ( !create_from_chain(
+           tt, [&in]()
+           {
+    std::string line;
+    while ( true )
+    {
+      if ( std::getline( in, line ) )
+      {
+        detail::trim( line );
+        if ( !line.empty() )
+        {
+          return line;
+        }
+      }
+      else
+      {
+        return std::string();
+      }
+    } },
+           tts, error ) )
+  {
+    return false;
+  }
+
+  tt = tts.back();
+  return true;
+}
+
+/*! \brief Creates characteristic function
+
+  Creates the truth table of the characteristic function, which contains one
+  additional variable.  The new output variable will be the most-significant
+  variable of the new function.
+
+  \param tt Truth table for characteristic function
+  \param from Input truth table
+*/
+template<typename TT, typename TTFrom, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+inline void create_characteristic( TT& tt, const TTFrom& from )
+{
+  assert( tt.num_vars() == from.num_vars() + 1 );
+
+  auto var = tt.construct();
+  create_nth_var( var, from.num_vars() );
+
+  auto ext = tt.construct();
+  extend_to_inplace( ext, from );
+
+  tt = ~var ^ ext;
+}
+
+/*! \brief Creates truth table from textual expression
+
+  An expression `E` is a constant `0` or `1`, or a truth table `a`,
+  `b`, ..., `p` from the vector `input_tts`, the negation of an
+  expression `!E`, the conjunction of multiple expressions `(E...E)`,
+  the disjunction of multiple expressions `{E...E}`, the exclusive OR
+  of multiple expressions `[E...E]`, or the majority of three
+  expressions `<EEE>`.
+
+  \param tt Truth table
+  \param from Expression as string
+  \param input_tts Input truth tables assigned to a, b, ...
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+bool create_from_expression( TT& tt, const std::string& expression, std::vector<TT> const& input_tts )
+{
+  enum stack_symbols
+  {
+    FUNC,
+    AND,
+    OR,
+    XOR,
+    MAJ,
+    NEG
+  };
+  std::stack<stack_symbols> symbols;
+  std::stack<TT> truth_tables;
+
+  const auto push_tt = [&]( TT& func )
+  {
+    while ( !symbols.empty() && symbols.top() == NEG )
+    {
+      func = ~func;
+      symbols.pop();
+    }
+    symbols.push( FUNC );
+    truth_tables.push( func );
+  };
+
+  for ( auto const& c : expression )
+  {
+    switch ( c )
+    {
+    default:
+      if ( c >= 'a' && c <= 'p' )
+      {
+        assert( input_tts.size() > uint64_t( c - 'a' ) );
+        auto var = input_tts[c - 'a'];
+        push_tt( var );
+      }
+      else
+      {
+        std::cerr << "[e] unexpected symbol in expression: " << c << "\n";
+        return false;
+      }
+      break;
+    case '0':
+    {
+      auto func = tt.construct();
+      push_tt( func );
+    }
+    break;
+    case '1':
+    {
+      auto func = ~tt.construct();
+      push_tt( func );
+    }
+    break;
+    case '!':
+      symbols.push( NEG );
+      break;
+    case '(':
+      symbols.push( AND );
+      break;
+    case '{':
+      symbols.push( OR );
+      break;
+    case '[':
+      symbols.push( XOR );
+      break;
+    case '<':
+      symbols.push( MAJ );
+      break;
+    case ')':
+    {
+      auto func = ~tt.construct();
+      while ( !symbols.empty() && symbols.top() == FUNC )
+      {
+        func &= truth_tables.top();
+        symbols.pop();
+        truth_tables.pop();
+      }
+      if ( symbols.empty() || symbols.top() != AND )
+      {
+        std::cerr << "[e] could not parse AND expression\n";
+        return false;
+      }
+      symbols.pop();
+      push_tt( func );
+    }
+    break;
+    case '}':
+    {
+      auto func = tt.construct();
+      while ( !symbols.empty() && symbols.top() == FUNC )
+      {
+        func |= truth_tables.top();
+        symbols.pop();
+        truth_tables.pop();
+      }
+      if ( symbols.empty() || symbols.top() != OR )
+      {
+        std::cerr << "[e] could not parse OR expression\n";
+        return false;
+      }
+      symbols.pop();
+      push_tt( func );
+    }
+    break;
+    case ']':
+    {
+      auto func = tt.construct();
+      while ( !symbols.empty() && symbols.top() == FUNC )
+      {
+        func ^= truth_tables.top();
+        symbols.pop();
+        truth_tables.pop();
+      }
+      if ( symbols.empty() || symbols.top() != XOR )
+      {
+        std::cerr << "[e] could not parse XOR expression\n";
+        return false;
+      }
+      symbols.pop();
+      push_tt( func );
+    }
+    break;
+    case '>':
+    {
+      std::vector<TT> children;
+      while ( !symbols.empty() && symbols.top() == FUNC )
+      {
+        children.push_back( truth_tables.top() );
+        symbols.pop();
+        truth_tables.pop();
+      }
+      if ( symbols.empty() || symbols.top() != MAJ )
+      {
+        std::cerr << "[e] could not parse MAJ expression\n";
+        return false;
+      }
+      if ( children.size() != 3u )
+      {
+        std::cerr << "[e] MAJ expression must have three children\n";
+        return false;
+      }
+      symbols.pop();
+      auto func = ternary_majority( children[0], children[1], children[2] );
+      push_tt( func );
+    }
+    break;
+    }
+  }
+
+  if ( symbols.size() != 1 || truth_tables.size() != 1 )
+  {
+    std::cerr << "[e] expression parsing incomplete\n";
+    return false;
+  }
+
+  tt = truth_tables.top();
+  return true;
+}
+
+/*! \brief Creates truth table from textual expression
+
+  An expression `E` is a constant `0` or `1`, or a variable `a`, `b`, ..., `p`,
+  the negation of an expression `!E`, the conjunction of multiple expressions
+  `(E...E)`, the disjunction of multiple expressions `{E...E}`, the exclusive
+  OR of multiple expressions `[E...E]`, or the majority of three expressions
+  `<EEE>`.  Examples are `[(ab)(!ac)]` to describe if-then-else, or `!{!a!b}`
+  to describe the application of De Morgan's law to `(ab)`.  The size of the
+  truth table must fit the largest variable in the expression, e.g., if `c` is
+  the largest variable, then the truth table have at least three variables.
+
+  \param tt Truth table
+  \param from Expression as string
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+bool create_from_expression( TT& tt, const std::string& expression )
+{
+  std::vector<TT> inputs_tts( tt.num_vars() );
+  for ( uint8_t i = 0u; i < tt.num_vars(); ++i )
+  {
+    auto var = tt.construct();
+    create_nth_var( var, i );
+    inputs_tts[i] = var;
+  }
+  return create_from_expression( tt, expression, inputs_tts );
+}
+
+namespace detail
+{
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+bool formula_execute_operation( std::stack<TT>& truth_tables, unsigned const op )
+{
+  auto fn1 = truth_tables.top();
+  truth_tables.pop();
+  auto fn2 = truth_tables.top();
+  truth_tables.pop();
+
+  if ( op == 3 ) /* AND */
+  {
+    truth_tables.push( fn1 & fn2 );
+  }
+  else if ( op == 2 ) /* XOR */
+  {
+    truth_tables.push( fn1 ^ fn2 );
+  }
+  else if ( op == 1 ) /* OR */
+  {
+    truth_tables.push( fn1 | fn2 );
+  }
+  else
+  {
+    return false;
+  }
+  return true;
+}
+} /* namespace detail */
+
+/*! \brief Creates a truth table from a Boolean formula
+
+  Translates a Boolean expression to a truth table with
+  the variable names and ordering defined by `var_names`.
+  The supported Boolean operations are the negation `!a`
+  or `a&apos;`, the conjunction `a*b` or `a&b` or `a b`,
+  the disjunction `a+b`, or `a|b`, and the exclusive OR
+  `a^b`. Brackets `()` can be used for the operation
+  order.
+
+  \param tt Truth table
+  \param from Expression as string
+  \param input_tts Variable names
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+bool create_from_formula( TT& tt, const std::string& expression, const std::vector<std::string>& var_names )
+{
+  enum stack_symbols
+  {
+    MARK = 0,
+    OR = 1,
+    XOR = 2,
+    AND = 3,
+    NEG = 4
+  };
+
+  enum stack_op
+  {
+    START,
+    VAR,
+    OPER,
+    F_ERROR
+  };
+
+  /* create input truth tables */
+  std::vector<TT> inputs_tts( tt.num_vars() );
+  assert( tt.num_vars() < 256 );
+  for ( uint32_t i = 0u; i < tt.num_vars(); ++i )
+  {
+    auto var = tt.construct();
+    create_nth_var( var, static_cast<uint8_t>( i ) );
+    inputs_tts[i] = var;
+  }
+
+  std::stack<stack_symbols> symbols;
+  std::stack<TT> truth_tables;
+
+  /* check brackets */
+  unsigned nbrackets = 0;
+  for ( char const& c : expression )
+  {
+    if ( c == '(' )
+    {
+      ++nbrackets;
+    }
+    else if ( c == ')' )
+    {
+      --nbrackets;
+    }
+  }
+
+  if ( nbrackets != 0 )
+  {
+    std::cerr << "[e] different number of opening and closing brackets.\n";
+    return false;
+  }
+
+  stack_op flag = START;
+  auto temp_tt = tt.construct();
+  for ( auto i = 0u; i < expression.length(); ++i )
+  {
+    char const c = expression.at( i );
+    switch ( c )
+    {
+    case ' ':
+    case '\t':
+    case '\r':
+    case '\n':
+      continue;
+
+    case '0':
+      if ( flag == VAR )
+      {
+        std::cerr << "[e] symbol before constant.\n";
+        flag = F_ERROR;
+        break;
+      }
+      truth_tables.push( tt.construct() );
+      flag = VAR;
+      break;
+
+    case '1':
+      if ( flag == VAR )
+      {
+        std::cerr << "[e] symbol before constant.\n";
+        flag = F_ERROR;
+        break;
+      }
+      truth_tables.push( ~tt.construct() );
+      flag = VAR;
+      break;
+
+    case '!':
+      if ( flag == VAR )
+      {
+        /* assuming an AND op */
+        symbols.push( AND );
+        flag = OPER;
+      }
+      symbols.push( NEG );
+      break;
+
+    case '\'':
+      if ( flag != VAR )
+      {
+        std::cerr << "[e] no variable specified before negation.\n";
+        flag = F_ERROR;
+        break;
+      }
+      temp_tt = truth_tables.top();
+      truth_tables.pop();
+      truth_tables.push( ~temp_tt );
+      break;
+
+    case '*':
+    case '&':
+      if ( flag != VAR )
+      {
+        std::cerr << "[e] no variable specified before binary operation.\n";
+        flag = F_ERROR;
+        break;
+      }
+      symbols.push( AND );
+      flag = OPER;
+      break;
+
+    case '+':
+    case '|':
+      if ( flag != VAR )
+      {
+        std::cerr << "[e] no variable specified before binary operation.\n";
+        flag = F_ERROR;
+        break;
+      }
+      symbols.push( OR );
+      flag = OPER;
+      break;
+
+    case '^':
+      if ( flag != VAR )
+      {
+        std::cerr << "[e] no variable specified before binary operation.\n";
+        flag = F_ERROR;
+        break;
+      }
+      symbols.push( XOR );
+      flag = OPER;
+      break;
+
+    case '(':
+      if ( flag == VAR )
+      {
+        /* assuming an AND op */
+        symbols.push( AND );
+      }
+      symbols.push( MARK );
+      flag = START;
+      break;
+
+    case ')':
+      if ( symbols.size() != 0 )
+      {
+        while ( 1 )
+        {
+          stack_symbols oper = symbols.top();
+          symbols.pop();
+          if ( oper == MARK )
+            break;
+
+          if ( !detail::formula_execute_operation( truth_tables, oper ) )
+          {
+            std::cerr << "[e] unknown operation.\n";
+            flag = F_ERROR;
+            break;
+          }
+        }
+      }
+      if ( flag != F_ERROR )
+      {
+        flag = VAR;
+      }
+      break;
+
+    default:
+      /* read variable name */
+      auto j = 1u;
+      while ( i + j < expression.length() &&
+              expression[i + j] != ' ' && expression[i + j] != '\t' && expression[i + j] != '\r' &&
+              expression[i + j] != '\n' && expression[i + j] != '*' && expression[i + j] != '&' &&
+              expression[i + j] != '+' && expression[i + j] != '|' && expression[i + j] != '^' &&
+              expression[i + j] != '\'' && expression[i + j] != ')' )
+      {
+        if ( expression[i + j] == '!' || expression[i + j] == '(' )
+        {
+          std::cerr << "[e] negation sign or open bracket inside variable name.\n";
+          flag = F_ERROR;
+          break;
+        }
+        ++j;
+      }
+
+      uint32_t var_index = 0;
+      bool match = false;
+      for ( auto const& v : var_names )
+      {
+        if ( expression.compare( i, j, v ) == 0 )
+        {
+          match = true;
+          break;
+        }
+        ++var_index;
+      }
+
+      if ( !match )
+      {
+        std::cerr << "[e] cannot find variable " << expression.substr( i, j ) << " in variables list.\n";
+        flag = F_ERROR;
+        break;
+      }
+
+      if ( flag == VAR )
+      {
+        symbols.push( AND );
+      }
+
+      /* increase pointer index */
+      i += j - 1;
+
+      truth_tables.push( inputs_tts[var_index] );
+
+      flag = VAR;
+      break;
+    }
+
+    if ( flag == F_ERROR )
+    {
+      break;
+    }
+    else if ( flag == START )
+    {
+      continue;
+    }
+    else if ( flag == VAR )
+    {
+      /* check if there are negations */
+      while ( 1 )
+      {
+        if ( symbols.size() == 0 )
+        {
+          break;
+        }
+        auto oper = symbols.top();
+        if ( oper == NEG )
+        {
+          temp_tt = truth_tables.top();
+          truth_tables.pop();
+          truth_tables.push( ~temp_tt );
+          symbols.pop();
+        }
+        else
+        {
+          break;
+        }
+      }
+    }
+    else if ( flag == OPER )
+    {
+      while ( 1 )
+      {
+        /* execute the ops with the a higher priority than the last op */
+        if ( symbols.size() == 1 )
+        {
+          break;
+        }
+        auto op1 = symbols.top();
+        symbols.pop();
+        auto op2 = symbols.top();
+        if ( op2 >= op1 )
+        {
+          symbols.pop();
+          /* execute previous op */
+          if ( !detail::formula_execute_operation( truth_tables, op2 ) )
+          {
+            std::cerr << "[e] unknown operation.\n";
+            flag = F_ERROR;
+            break;
+          }
+          symbols.push( op1 );
+        }
+        else
+        {
+          /* push operations back */
+          symbols.push( op1 );
+          break;
+        }
+      }
+    }
+  }
+
+  if ( flag != F_ERROR )
+  {
+    /* last operation if present */
+    while ( symbols.size() > 0 )
+    {
+      if ( !detail::formula_execute_operation( truth_tables, symbols.top() ) )
+      {
+        std::cerr << "[e] unknown operation.\n";
+        flag = F_ERROR;
+        break;
+      }
+      symbols.pop();
+    }
+
+    /* assign truth table */
+    tt = truth_tables.top();
+  }
+
+  return true;
+}
+
+/*! \brief Creates function where on-set corresponds to prime numbers
+
+  This creates a function in which \f$f(x) = 1\f$, if and only if \f$x\f$ is
+  a prime number in its integer representation.  The function only works for
+  truth tables with at most 10 variables.  The number of variables is determined
+  from the truth table.
+
+  \param tt Truth table
+*/
+template<class TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void create_prime( TT& tt )
+{
+  if ( tt.num_vars() > 10 )
+    return;
+
+  clear( tt );
+  auto p = detail::primes;
+
+  while ( *p < tt.num_bits() )
+  {
+    set_bit( tt, *p++ );
+  }
+}
+
+} // namespace kitty
\ No newline at end of file
diff --git a/lib/kitty/kitty/cube.hpp b/lib/kitty/kitty/cube.hpp
new file mode 100644
index 0000000..eedfa4e
--- /dev/null
+++ b/lib/kitty/kitty/cube.hpp
@@ -0,0 +1,333 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file cube.hpp
+  \brief A cube data structure for up to 32 variables
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <functional>
+#include <iostream>
+#include <string>
+
+#include "hash.hpp"
+#include "detail/mscfix.hpp"
+
+namespace kitty
+{
+class cube
+{
+public:
+  /*! \brief Constructs the empty cube
+
+    Represents the one-cube
+  */
+  cube() : _value( 0 ) {} /* NOLINT */
+
+  /*! \brief Constructs a cube from bits and mask
+
+    For a valid cube and to be consistent in the ternary values, we
+    assume that whenever a bit in the care bitmask is set to 0, also
+    the polarity bitmask must be 0.
+
+    \param bits Polarity bitmask of variables (0: negative, 1: positive)
+    \param mask Care bitmask of variables (1: part of cube, 0: not part of cube)
+  */
+  cube( uint32_t bits, uint32_t mask ) : _bits( bits ), _mask( mask ) {} /* NOLINT */
+
+  /*! \brief Constructs a cube from a string
+
+    Each character corresponds to one literal in the cube.  Only up to first 32
+    characters of the string will be considered, since this data structure
+    cannot represent cubes with more than 32 literals.  A '1' in the string
+    corresponds to a postive literal, a '0' corresponds to a negative literal.
+    All other characters represent don't care, but it is customary to use '-'.
+
+    \param str String representing a cube
+  */
+  // cppcheck-suppress noExplicitConstructor
+  cube( const std::string& str ) /* NOLINT */
+  {
+    _bits = _mask = 0u;
+
+    auto p = str.begin();
+    if ( p == str.end() )
+    {
+      return;
+    }
+
+    for ( uint64_t i = 1; i <= ( uint64_t( 1u ) << 32u ); i <<= 1 )
+    {
+      switch ( *p )
+      {
+      default: /* don't care */
+        break;
+      case '1':
+        _bits |= i;
+        /* no break on purpose, jump to 0 and set mask */
+      case '0':
+        _mask |= i;
+        break;
+      }
+
+      if ( ++p == str.end() )
+      {
+        return;
+      }
+    }
+  }
+
+  /*! \brief Returns number of literals */
+  inline int num_literals() const
+  {
+    return __builtin_popcount( _mask );
+  }
+
+  /*! \brief Returns the difference to another cube */
+  inline int difference( const cube& that ) const
+  {
+    return ( _bits ^ that._bits ) | ( _mask ^ that._mask );
+  }
+
+  /*! \brief Returns the distance to another cube */
+  inline int distance( const cube& that ) const
+  {
+    return __builtin_popcount( difference( that ) );
+  }
+
+  /*! \brief Checks whether two cubes are equivalent */
+  inline bool operator==( const cube& that ) const
+  {
+    return _value == that._value;
+  }
+
+  /*! \brief Checks whether two cubes are not equivalent */
+  inline bool operator!=( const cube& that ) const
+  {
+    return _value != that._value;
+  }
+
+  /*! \brief Default comparison operator */
+  inline bool operator<( const cube& that ) const
+  {
+    return _value < that._value;
+  }
+
+  /*! \brief Returns the negated cube */
+  inline cube operator~() const
+  {
+    return { ~_bits, _mask };
+  }
+
+  /*! \brief Merges two cubes of distance-1 */
+  inline cube merge( const cube& that ) const
+  {
+    const auto d = difference( that );
+    return { _bits ^ ( ~that._bits & d ), _mask ^ ( that._mask & d ) };
+  }
+
+  /*! \brief Adds literal to cube */
+  inline void add_literal( uint8_t var_index, bool polarity = true )
+  {
+    set_mask( var_index );
+
+    if ( polarity )
+    {
+      set_bit( var_index );
+    }
+    else
+    {
+      clear_bit( var_index );
+    }
+  }
+
+  /*! \brief Removes literal from cube */
+  inline void remove_literal( uint8_t var_index )
+  {
+    clear_mask( var_index );
+    clear_bit( var_index );
+  }
+
+  /*! \brief Constructs the elementary cube representing a single variable */
+  static cube nth_var_cube( uint8_t var_index )
+  {
+    const auto _bits = uint32_t( 1 ) << var_index;
+    return { _bits, _bits };
+  }
+
+  /*! \brief Constructs the elementary cube containing the first k positive literals */
+  static cube pos_cube( uint8_t k )
+  {
+    const uint32_t _bits = ( uint64_t( 1 ) << k ) - 1;
+    return { _bits, _bits };
+  }
+
+  /*! \brief Constructs the elementary cube containing the first k negative literals */
+  static cube neg_cube( uint8_t k )
+  {
+    const uint32_t _bits = ( uint64_t( 1 ) << k ) - 1;
+    return { 0u, _bits };
+  }
+
+  /*! \brief Prints a cube */
+  inline void print( unsigned length = 32u, std::ostream& os = std::cout ) const
+  {
+    for ( auto i = 0u; i < length; ++i )
+    {
+      os << ( get_mask( i ) ? ( get_bit( i ) ? '1' : '0' ) : '-' );
+    }
+  }
+
+  /*! \brief Gets bit at index */
+  inline bool get_bit( uint8_t index ) const
+  {
+    return ( ( _bits >> index ) & 1 ) != 0;
+  }
+
+  /*! \brief Gets mask at index */
+  inline bool get_mask( uint8_t index ) const
+  {
+    return ( ( _mask >> index ) & 1 ) != 0;
+  }
+
+  /*! \brief Sets bit at index */
+  inline void set_bit( uint8_t index )
+  {
+    _bits |= ( 1 << index );
+  }
+
+  /*! \brief Sets mask at index */
+  inline void set_mask( uint8_t index )
+  {
+    _mask |= ( 1 << index );
+  }
+
+  /*! \brief Clears bit at index */
+  inline void clear_bit( uint8_t index )
+  {
+    _bits &= ~( 1 << index );
+  }
+
+  /*! \brief Clears mask at index */
+  inline void clear_mask( uint8_t index )
+  {
+    _mask &= ~( 1 << index );
+  }
+
+  /*! \brief Flips bit at index */
+  inline void flip_bit( uint8_t index )
+  {
+    _bits ^= ( 1 << index );
+  }
+
+  /*! \brief Flips mask at index */
+  inline void flip_mask( uint8_t index )
+  {
+    _mask ^= ( 1 << index );
+  }
+
+  /*! \brief Iterates over all minterms in the cube
+   *
+   * The callback function takes a cube as input, which is actually
+   * a minterm (i.e., all variables are set), and returns a boolean.
+   * The loop terminates when the callback returns false.
+   *
+   * \param length Number of variables in the cube
+   * \param fn Callback function on each minterm
+   */
+  template<class Fn>
+  void foreach_minterm( uint8_t length, Fn&& fn ) const
+  {
+    foreach_minterm_rec( *this, length, fn );
+  }
+
+  template<class Fn>
+  bool foreach_minterm_rec( cube const& c, uint8_t prev_index, Fn&& fn ) const
+  {
+    if ( prev_index == 0 )
+    {
+      return fn( c );
+    }
+
+    uint8_t index = prev_index - 1;
+    if ( !get_mask( index ) )
+    {
+      cube c0 = c;
+      c0.set_mask( index );
+      if ( !foreach_minterm_rec( c0, index, fn ) )
+      {
+        return false;
+      }
+      c0.set_bit( index );
+      return foreach_minterm_rec( c0, index, fn );
+    }
+    else
+    {
+      return foreach_minterm_rec( c, index, fn );
+    }
+  }
+
+  /* cube data */
+  union
+  {
+    struct
+    {
+      uint32_t _bits;
+      uint32_t _mask;
+    };
+    uint64_t _value;
+  };
+};
+
+/*! \brief Prints all cubes in a vector
+
+  \param cubes Vector of cubes
+  \param length Number of variables in each cube
+  \param os Output stream
+*/
+inline void print_cubes( const std::vector<cube>& cubes, unsigned length = 32u, std::ostream& os = std::cout )
+{
+  for ( const auto& cube : cubes )
+  {
+    cube.print( length, os );
+    os << '\n';
+  }
+
+  os << std::flush;
+}
+
+template<>
+struct hash<cube>
+{
+  std::size_t operator()( const cube& c ) const
+  {
+    return std::hash<uint64_t>{}( c._value );
+  }
+};
+} // namespace kitty
\ No newline at end of file
diff --git a/lib/kitty/kitty/decomposition.hpp b/lib/kitty/kitty/decomposition.hpp
new file mode 100644
index 0000000..3dfa935
--- /dev/null
+++ b/lib/kitty/kitty/decomposition.hpp
@@ -0,0 +1,956 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file decomposition.hpp
+  \brief Check decomposition properties (and perform decomposition) of a function
+
+  \author Mahyar Emami (mahyar.emami@epfl.ch)
+  \author Mathias Soeken
+  \author Eleonora Testa
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <unordered_map>
+
+#include "constructors.hpp"
+#include "operations.hpp"
+#include "implicant.hpp"
+#include "traits.hpp"
+
+namespace kitty
+{
+
+enum class top_decomposition
+{
+  none,
+  and_,
+  or_,
+  lt_,
+  le_,
+  xor_
+};
+
+enum class bottom_decomposition
+{
+  none,
+  and_,
+  or_,
+  lt_,
+  le_,
+  xor_
+};
+
+enum class bi_decomposition
+{
+  none,
+  and_,
+  or_,
+  xor_,
+  weak_and_,
+  weak_or_
+};
+
+/*! \brief Checks, whether function is top disjoint decomposable
+
+  \verbatim embed:rst
+  Checks whether the input function ``tt`` can be represented by the function
+  :math:`f = g(h(X_1), a)`, where :math:`a \notin X_1`.  The return value
+  is :math:`g`:
+
+  * ``top_decomposition::and_``: :math:`g = a \land h(X_1)`
+  * ``top_decomposition::or_``: :math:`g = a \lor h(X_1)`
+  * ``top_decomposition::lt_``: :math:`g = \bar a \land h(X_1)`
+  * ``top_decomposition::le_``: :math:`g = \bar a \lor h(X_1)`
+  * ``top_decomposition::xor_``: :math:`g = a \oplus h(X_1)`
+  * ``top_decomposition::none``: decomposition does not exist
+
+  The function can return the remainder function :math:`h`, whic will not depend
+  on :math:`a`.
+  \endverbatim
+
+  \param tt Input function \f$f\f$
+  \param var_index Variable \f$a\f$
+  \param func If not ``null`` and decomposition exists, its value is assigned the remainder \f$h\f$
+  \param allow_xor Set to false to disable XOR decomposition
+*/
+template<class TT>
+top_decomposition is_top_decomposable( const TT& tt, uint32_t var_index, TT* func = nullptr, bool allow_xor = true )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  auto var = tt.construct();
+  kitty::create_nth_var( var, var_index );
+
+  if ( implies( tt, var ) )
+  {
+    if ( func )
+    {
+      *func = cofactor1( tt, var_index );
+    }
+    return top_decomposition::and_;
+  }
+  else if ( implies( var, tt ) )
+  {
+    if ( func )
+    {
+      *func = cofactor0( tt, var_index );
+    }
+    return top_decomposition::or_;
+  }
+  else if ( implies( tt, ~var ) )
+  {
+    if ( func )
+    {
+      *func = cofactor0( tt, var_index );
+    }
+    return top_decomposition::lt_;
+  }
+  else if ( implies( ~var, tt ) )
+  {
+    if ( func )
+    {
+      *func = cofactor1( tt, var_index );
+    }
+    return top_decomposition::le_;
+  }
+
+  if ( allow_xor )
+  {
+    /* try XOR */
+    const auto co0 = cofactor0( tt, var_index );
+    const auto co1 = cofactor1( tt, var_index );
+
+    if ( equal( co0, ~co1 ) )
+    {
+      if ( func )
+      {
+        *func = co0;
+      }
+      return top_decomposition::xor_;
+    }
+  }
+
+  return top_decomposition::none;
+}
+
+/*! \brief Checks, whether function is bottom disjoint decomposable
+
+  \verbatim embed:rst
+  Checks whether the input function ``tt`` can be represented by the function
+  :math:`f = h(X_1, g(a, b))`, where :math:`a, b \notin X_1`.  The return value
+  is :math:`g`:
+
+  * ``bottom_decomposition::and_``: :math:`g = a \land b`
+  * ``bottom_decomposition::or_``: :math:`g = a \lor b`
+  * ``bottom_decomposition::lt_``: :math:`g = \bar a \land b`
+  * ``bottom_decomposition::le_``: :math:`g = \bar a \lor b`
+  * ``bottom_decomposition::xor_``: :math:`g = a \oplus b`
+  * ``bottom_decomposition::none``: decomposition does not exist
+
+  The function can return the remainder function :math:`h` in where :math:`g`
+  is substituted by :math:`a`.  The remainder function will not depend on
+  :math:`b`.
+  \endverbatim
+
+  \param tt Input function \f$f\f$
+  \param var_index1 Variable \f$a\f$
+  \param var_index2 Variable \f$b\f$
+  \param func If not ``null`` and decomposition exists, its value is assigned the remainder \f$h\f$
+  \param allow_xor Set to false to disable XOR decomposition
+*/
+template<class TT>
+bottom_decomposition is_bottom_decomposable( const TT& tt, uint32_t var_index1, uint32_t var_index2, TT* func = nullptr, bool allow_xor = true )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  const auto tt0 = cofactor0( tt, var_index1 );
+  const auto tt1 = cofactor1( tt, var_index1 );
+
+  const auto tt00 = cofactor0( tt0, var_index2 );
+  const auto tt01 = cofactor1( tt0, var_index2 );
+  const auto tt10 = cofactor0( tt1, var_index2 );
+  const auto tt11 = cofactor1( tt1, var_index2 );
+
+  const auto eq01 = equal( tt00, tt01 );
+  const auto eq02 = equal( tt00, tt10 );
+  const auto eq03 = equal( tt00, tt11 );
+  const auto eq12 = equal( tt01, tt10 );
+  const auto eq13 = equal( tt01, tt11 );
+  const auto eq23 = equal( tt10, tt11 );
+
+  const auto num_pairs =
+      static_cast<uint32_t>( eq01 ) +
+      static_cast<uint32_t>( eq02 ) +
+      static_cast<uint32_t>( eq03 ) +
+      static_cast<uint32_t>( eq12 ) +
+      static_cast<uint32_t>( eq13 ) +
+      static_cast<uint32_t>( eq23 );
+
+  if ( num_pairs != 2u && num_pairs != 3 )
+  {
+    return bottom_decomposition::none;
+  }
+
+  if ( !eq01 && !eq02 && !eq03 ) // 00 is different
+  {
+    if ( func )
+    {
+      *func = mux_var( var_index1, tt11, tt00 );
+    }
+    return bottom_decomposition::or_;
+  }
+  else if ( !eq01 && !eq12 && !eq13 ) // 01 is different
+  {
+    if ( func )
+    {
+      *func = mux_var( var_index1, tt01, tt10 );
+    }
+    return bottom_decomposition::lt_;
+  }
+  else if ( !eq02 && !eq12 && !eq23 ) // 10 is different
+  {
+    if ( func )
+    {
+      *func = mux_var( var_index1, tt01, tt10 );
+    }
+    return bottom_decomposition::le_;
+  }
+  else if ( !eq03 && !eq13 && !eq23 ) // 11 is different
+  {
+    if ( func )
+    {
+      *func = mux_var( var_index1, tt11, tt00 );
+    }
+    return bottom_decomposition::and_;
+  }
+  else if ( allow_xor ) // XOR
+  {
+    if ( func )
+    {
+      *func = mux_var( var_index1, tt01, tt00 );
+    }
+    return bottom_decomposition::xor_;
+  }
+
+  return bottom_decomposition::none;
+}
+
+/*! \cond PRIVATE */
+namespace detail
+{
+
+template<class TT>
+TT exist_set( const TT& tt, const std::vector<int>& set )
+{
+  auto exist = tt;
+  for ( auto x = 0u; x < set.size(); x++ )
+  {
+    auto ra_0 = cofactor0( exist, set[x] );
+    auto ra_1 = cofactor1( exist, set[x] );
+    exist = binary_or( ra_0, ra_1 );
+  }
+  return exist;
+}
+
+template<class TT>
+TT select_one_cube( const TT& q )
+{
+  auto m = q.construct();
+  auto minterms = kitty::get_minterms( q );
+  const uint64_t min = minterms[0];
+  set_bit( m, min );
+  for ( auto i = 0u; i < q.num_vars(); i++ )
+  {
+    std::vector<int> h( 1, i );
+    auto m_p = exist_set( m, h );
+    if ( binary_and( m_p, q ) == m_p )
+    {
+      m = m_p;
+    }
+  }
+  return m;
+}
+
+template<class TT>
+bool check_or_decomp( const TT& tt, const TT& dc, const std::vector<int>& i, const std::vector<int>& j )
+{
+  auto q = binary_and( tt, dc );
+  auto r = binary_and( ~tt, dc );
+  auto p = binary_and( q, binary_and( exist_set( r, i ), exist_set( r, j ) ) );
+
+  return is_const0( p );
+}
+
+template<class TT>
+std::pair<bool, std::vector<TT>> check_xor_decomp( const TT& tt, const TT& dc, const std::vector<int>& i, const std::vector<int>& j )
+{
+  auto q = binary_and( tt, dc );
+  auto r = binary_and( ~tt, dc );
+
+  auto qa = tt.construct();
+  auto ra = tt.construct();
+  auto qb = tt.construct();
+  auto rb = tt.construct();
+
+  std::vector<TT> q_and_rs{ qa, ra, qb, rb };
+  while ( !is_const0( q ) )
+  {
+    auto cube = select_one_cube( q );
+    qa = binary_or( qa, exist_set( cube, j ) );
+    while ( !is_const0( binary_or( qa, ra ) ) )
+    {
+      qb = exist_set( binary_or( binary_and( q, ra ), binary_and( r, qa ) ), i );
+      rb = exist_set( binary_or( binary_and( q, qa ), binary_and( r, ra ) ), i );
+      if ( !is_const0( binary_and( qb, rb ) ) )
+      {
+        return { false, q_and_rs };
+      }
+      q = binary_and( q, ~binary_or( qa, ra ) );
+      r = binary_and( r, ~binary_or( qa, ra ) );
+
+      q_and_rs[0] = binary_or( q_and_rs[0], qa );
+      q_and_rs[1] = binary_or( q_and_rs[1], ra );
+
+      qa = exist_set( binary_or( binary_and( q, rb ), binary_and( r, qb ) ), j );
+      ra = exist_set( binary_or( binary_and( q, qb ), binary_and( r, rb ) ), j );
+      if ( !is_const0( binary_and( qa, ra ) ) )
+      {
+        return { false, q_and_rs };
+      }
+      q = binary_and( q, ~binary_or( qb, rb ) );
+      r = binary_and( r, ~binary_or( qb, rb ) );
+
+      q_and_rs[2] = binary_or( q_and_rs[2], qb );
+      q_and_rs[3] = binary_or( q_and_rs[3], rb );
+    }
+  }
+  if ( !is_const0( r ) )
+  {
+    q_and_rs[1] = binary_or( q_and_rs[1], exist_set( r, j ) );
+    q_and_rs[3] = binary_or( q_and_rs[3], exist_set( r, i ) );
+  }
+  return { true, q_and_rs };
+}
+
+template<class TT>
+bool check_weak_decomp( const TT& tt, const TT& dc, const std::vector<int>& i )
+{
+  auto p = exist_set( binary_and( ~tt, dc ), i );
+  return !is_const0( binary_and( binary_and( tt, dc ), ~p ) );
+}
+
+template<class TT>
+std::pair<std::vector<int>, std::vector<int>> find_initial_or( const TT& tt, const TT& dc, const std::vector<int>& s )
+{
+  std::vector<int> var_a_vect, var_b_vect;
+  for ( auto& i : s )
+  {
+    for ( auto& j : s )
+    {
+      if ( j == i )
+      {
+        continue;
+      }
+      std::vector<int> var_a_p( 1, i );
+      std::vector<int> var_b_p( 1, j );
+      if ( check_or_decomp( tt, dc, var_a_p, var_b_p ) )
+      {
+        var_a_vect.push_back( i );
+        var_b_vect.push_back( j );
+        return { var_a_vect, var_b_vect };
+      }
+    }
+  }
+  return { var_a_vect, var_b_vect };
+}
+
+template<class TT>
+std::tuple<std::vector<int>, std::vector<int>, std::vector<TT>> find_initial_xor( const TT& tt, const TT& dc, const std::vector<int>& s )
+{
+  std::vector<int> var_a_vect, var_b_vect;
+  std::vector<TT> q_and_r;
+
+  for ( auto& i : s )
+  {
+    for ( auto& j : s )
+    {
+      if ( j == i )
+      {
+        continue;
+      }
+      std::vector<int> var_a_p( 1, i );
+      std::vector<int> var_b_p( 1, j );
+      auto f = check_xor_decomp( tt, dc, var_a_p, var_b_p );
+      if ( f.first )
+      {
+        var_a_vect.push_back( i );
+        var_b_vect.push_back( j );
+        q_and_r = f.second;
+        return std::make_tuple( var_a_vect, var_b_vect, q_and_r );
+      }
+    }
+  }
+  return std::make_tuple( var_a_vect, var_b_vect, q_and_r );
+}
+
+template<class TT>
+std::pair<std::vector<int>, std::vector<int>> find_initial_weak_or( const TT& tt, const TT& dc, const std::vector<int>& s )
+{
+  std::vector<int> var_a_vect, var_b_vect;
+  for ( auto& i : s )
+  {
+    std::vector<int> var_a_p( 1, i );
+    var_a_p.push_back( i );
+    if ( check_weak_decomp( tt, dc, var_a_p ) )
+    {
+      var_a_vect.push_back( i );
+      var_b_vect.push_back( i );
+      return { var_a_vect, var_b_vect };
+    }
+  }
+  return { var_a_vect, var_b_vect };
+}
+
+template<class TT>
+std::pair<std::vector<int>, std::vector<int>> group_variables_or( const TT& tt, const TT& dc, const std::vector<int>& s )
+{
+  std::vector<int> xa, xb;
+  auto var_x = find_initial_or( tt, dc, s );
+  xa = var_x.first;
+  xb = var_x.second;
+  if ( ( xa.size() == 0 ) && ( xb.size() == 0 ) )
+  {
+    return var_x;
+  }
+  for ( auto h : s )
+  {
+    auto it = std::find( xa.begin(), xa.end(), h );
+    if ( it != xa.end() )
+    {
+      continue;
+    }
+    it = std::find( xb.begin(), xb.end(), h );
+    if ( it != xb.end() )
+    {
+      continue;
+    }
+
+    if ( xa.size() <= xb.size() )
+    {
+      auto xa_p = xa;
+      auto xb_p = xb;
+      xa_p.push_back( h );
+      xb_p.push_back( h );
+      if ( check_or_decomp( tt, dc, xa_p, xb ) )
+      {
+        xa.push_back( h );
+      }
+      else if ( check_or_decomp( tt, dc, xa, xb_p ) )
+      {
+        xb.push_back( h );
+      }
+    }
+    else
+    {
+      auto xa_p = xa;
+      auto xb_p = xb;
+      xa_p.push_back( h );
+      xb_p.push_back( h );
+      if ( check_or_decomp( tt, dc, xa, xb_p ) )
+      {
+        xb.push_back( h );
+      }
+      else if ( check_or_decomp( tt, dc, xa_p, xb ) )
+      {
+        xa.push_back( h );
+      }
+    }
+  }
+  return { xa, xb };
+}
+
+template<class TT>
+std::pair<std::vector<int>, std::vector<int>> group_variables_weak_or( const TT& tt, const TT& dc, const std::vector<int>& s )
+{
+  std::vector<int> xa, xb;
+  auto var_x = find_initial_weak_or( tt, dc, s );
+  xa = var_x.first;
+  xb = var_x.second;
+  if ( ( xa.size() == 0 ) && ( xb.size() == 0 ) )
+  {
+    return var_x;
+  }
+  for ( auto h : s )
+  {
+    auto it = std::find( xa.begin(), xa.end(), h );
+    if ( it != xa.end() )
+    {
+      continue;
+    }
+    auto xa_p = xa;
+    xa_p.push_back( h );
+    if ( check_weak_decomp( tt, dc, xa_p ) )
+    {
+      xa.push_back( h );
+    }
+  }
+  return { xa, xb };
+}
+
+template<class TT>
+std::tuple<std::vector<int>, std::vector<int>, std::vector<TT>> group_variables_xor( const TT& tt, const TT& dc, const std::vector<int>& s )
+{
+  std::vector<int> xa, xb;
+  std::vector<TT> q_and_r;
+  auto var_x = find_initial_xor( tt, dc, s );
+  xa = std::get<0>( var_x );
+  xb = std::get<1>( var_x );
+  q_and_r = std::get<2>( var_x );
+  if ( ( xa.size() == 0 ) && ( xb.size() == 0 ) )
+  {
+    return var_x;
+  }
+  for ( auto h : s )
+  {
+    auto it = std::find( xa.begin(), xa.end(), h );
+    if ( it != xa.end() )
+    {
+      continue;
+    }
+    it = std::find( xb.begin(), xb.end(), h );
+    if ( it != xb.end() )
+    {
+      continue;
+    }
+
+    if ( xa.size() <= xb.size() )
+    {
+      auto xa_p = xa;
+      auto xb_p = xb;
+      xa_p.push_back( h );
+      xb_p.push_back( h );
+      auto f = check_xor_decomp( tt, dc, xa_p, xb );
+      auto f2 = check_xor_decomp( tt, dc, xa, xb_p );
+      if ( f.first )
+      {
+        xa.push_back( h );
+        q_and_r = f.second;
+      }
+      else if ( f2.first )
+      {
+        xb.push_back( h );
+        q_and_r = f2.second;
+      }
+    }
+    else
+    {
+      auto xa_p = xa;
+      auto xb_p = xb;
+      xa_p.push_back( h );
+      xb_p.push_back( h );
+      auto f = check_xor_decomp( tt, dc, xa_p, xb );
+      auto f2 = check_xor_decomp( tt, dc, xa, xb_p );
+      if ( f2.first )
+      {
+        xb.push_back( h );
+        q_and_r = f2.second;
+      }
+      else if ( f.first )
+      {
+        xa.push_back( h );
+        q_and_r = f.second;
+      }
+    }
+  }
+  return std::make_tuple( xa, xb, q_and_r );
+}
+
+inline std::tuple<std::vector<int>, std::vector<int>, bi_decomposition> best_variable_grouping( const std::pair<std::vector<int>, std::vector<int>>& x_or, const std::pair<std::vector<int>, std::vector<int>>& x_and, const std::pair<std::vector<int>, std::vector<int>>& x_xor, bool xor_cost )
+{
+  if ( xor_cost )
+  {
+    if ( ( x_xor.first.size() != 0 ) & ( x_xor.second.size() != 0 ) )
+    {
+      return std::make_tuple( x_xor.first, x_xor.second, bi_decomposition::xor_ );
+    }
+  }
+
+  int diff_or = static_cast<int>( x_or.first.size() ) - static_cast<int>( x_or.second.size() );
+  if ( ( x_or.first.size() == 0 ) || ( x_or.second.size() == 0 ) )
+  {
+    diff_or = 100;
+  }
+  if ( diff_or < 0 )
+  {
+    diff_or = -diff_or;
+  }
+
+  int diff_and = static_cast<int>( x_and.first.size() ) - static_cast<int>( x_and.second.size() );
+  if ( ( x_and.first.size() == 0 ) || ( x_and.second.size() == 0 ) )
+  {
+    diff_and = 100;
+  }
+  if ( diff_and < 0 )
+  {
+    diff_and = -diff_and;
+  }
+
+  int diff_xor = static_cast<int>( x_xor.first.size() ) - static_cast<int>( x_xor.second.size() );
+  if ( ( x_xor.first.size() == 0 ) || ( x_xor.second.size() == 0 ) )
+  {
+    diff_xor = 100;
+  }
+  if ( diff_xor < 0 )
+  {
+    diff_xor = -diff_xor;
+  }
+  if ( ( diff_or == 100 ) && ( diff_and == 100 ) && ( diff_xor == 100 ) )
+  {
+    return std::make_tuple( x_or.first, x_or.second, bi_decomposition::none );
+  }
+  if ( ( diff_xor <= diff_and ) && ( diff_xor <= diff_or ) )
+  {
+    return std::make_tuple( x_xor.first, x_xor.second, bi_decomposition::xor_ );
+  }
+  else if ( ( diff_and <= diff_xor ) && ( diff_and <= diff_or ) )
+  {
+    return std::make_tuple( x_and.first, x_and.second, bi_decomposition::and_ );
+  }
+  else // if ( ( diff_xor <= diff_or ) && ( diff_xor <= diff_and ) )
+  {
+    return std::make_tuple( x_or.first, x_or.second, bi_decomposition::or_ );
+  }
+}
+
+template<typename TT>
+std::vector<TT> derive_b( const TT& tt, const TT& dc, const std::tuple<std::vector<int>, std::vector<int>, bi_decomposition>& x_best, const TT& fa )
+{
+  std::vector<TT> qb;
+  if ( ( std::get<2>( x_best ) == bi_decomposition::or_ ) || ( std::get<2>( x_best ) == bi_decomposition::weak_or_ ) )
+  {
+    auto rb = exist_set( binary_and( ~tt, dc ), std::get<0>( x_best ) );
+    qb.push_back( exist_set( binary_and( binary_and( tt, dc ), ~fa ), std::get<0>( x_best ) ) );
+    assert( !is_const0( rb ) );
+    qb.push_back( binary_or( qb[0], rb ) );
+    return qb;
+  }
+  else // (( std::get<2>( x_best ) == bi_decomposition::and_) || ( std::get<2>( x_best ) == bi_decomposition::weak_and_) )
+  {
+    qb.push_back( exist_set( binary_and( tt, dc ), std::get<0>( x_best ) ) );
+    auto rb = exist_set( binary_and( binary_and( ~tt, dc ), ~fa ), std::get<0>( x_best ) );
+    qb.push_back( binary_or( qb[0], rb ) );
+    assert( !is_const0( qb[0] ) );
+    return qb;
+  }
+}
+
+template<class TT>
+std::vector<TT> derive_a( const TT& tt, const TT& dc, const std::tuple<std::vector<int>, std::vector<int>, bi_decomposition>& x_best )
+{
+  std::vector<TT> qa;
+  if ( std::get<2>( x_best ) == bi_decomposition::or_ )
+  {
+    qa.push_back( exist_set( binary_and( binary_and( tt, dc ), exist_set( binary_and( ~tt, dc ), std::get<0>( x_best ) ) ), std::get<1>( x_best ) ) );
+    auto ra = exist_set( binary_and( ~tt, dc ), std::get<1>( x_best ) );
+    qa.push_back( binary_or( qa[0], ra ) );
+    return qa;
+  }
+  else if ( std::get<2>( x_best ) == bi_decomposition::and_ )
+  {
+    auto ra = exist_set( binary_and( binary_and( ~tt, dc ), exist_set( binary_and( tt, dc ), std::get<0>( x_best ) ) ), std::get<1>( x_best ) );
+    qa.push_back( exist_set( binary_and( tt, dc ), std::get<1>( x_best ) ) );
+    qa.push_back( binary_or( qa[0], ra ) );
+    return qa;
+  }
+  else if ( std::get<2>( x_best ) == bi_decomposition::weak_or_ )
+  {
+    qa.push_back( binary_and( binary_and( tt, dc ), exist_set( binary_and( ~tt, dc ), std::get<0>( x_best ) ) ) );
+    auto ra = binary_and( ~tt, dc );
+    qa.push_back( binary_or( qa[0], ra ) );
+    return qa;
+  }
+  else // if ( std::get<2>( x_best ) == bi_decomposition::weak_and_ )
+  {
+    qa.push_back( binary_and( tt, dc ) );
+    auto ra = binary_and( binary_and( ~tt, dc ), exist_set( binary_and( tt, dc ), std::get<0>( x_best ) ) );
+    qa.push_back( binary_or( qa[0], ra ) );
+    return qa;
+  }
+}
+
+template<class TT>
+std::tuple<TT, bi_decomposition, std::vector<TT>> is_bi_decomposable( const TT& tt, const TT& dc, bool cost )
+{
+
+  auto fa = tt.construct();
+  auto fb = tt.construct();
+  std::vector<TT> qa, qb;
+
+  if ( is_const0( dc ) )
+  {
+    return std::make_tuple( dc, bi_decomposition::none, qa );
+  }
+
+  std::vector<int> support;
+  for ( auto x = 0u; x < tt.num_vars(); x++ )
+  {
+    if ( has_var( binary_and( tt, dc ), x ) )
+    {
+      support.push_back( x );
+    }
+  }
+
+  if ( support.size() <= 1 )
+  {
+    return std::make_tuple( tt, bi_decomposition::none, qa );
+  }
+
+  auto x_or = detail::group_variables_or( tt, dc, support );
+  auto x_and = detail::group_variables_or( ~tt, dc, support );
+  auto x_xor = detail::group_variables_xor( tt, dc, support );
+  auto x_best = detail::best_variable_grouping( x_or, x_and, std::make_pair( std::get<0>( x_xor ), std::get<1>( x_xor ) ), cost );
+
+  if ( std::get<2>( x_best ) == bi_decomposition::none )
+  {
+    x_or = detail::group_variables_weak_or( tt, dc, support );
+    if ( x_or.first.size() == 0 )
+    {
+      x_and = detail::group_variables_weak_or( ~tt, dc, support );
+      x_best = make_tuple( x_and.first, x_and.second, bi_decomposition::weak_and_ );
+    }
+    else
+      x_best = make_tuple( x_or.first, x_or.second, bi_decomposition::weak_or_ );
+  }
+  else if ( std::get<2>( x_best ) == bi_decomposition::xor_ )
+  {
+    fa = std::get<2>( x_xor )[0];
+    fb = std::get<2>( x_xor )[2];
+
+    qa = std::get<2>( x_xor );
+    qa[1] = binary_or( qa[1], qa[0] );
+    qa[3] = binary_or( qa[3], qa[2] );
+    return std::make_tuple( binary_xor( fa, fb ), bi_decomposition::xor_, qa );
+  }
+
+  qa = detail::derive_a( tt, dc, x_best );
+  if ( ( std::get<2>( x_best ) == bi_decomposition::or_ ) || ( std::get<2>( x_best ) == bi_decomposition::weak_or_ ) )
+  {
+    qb = detail::derive_b( tt, dc, x_best, qa[0] );
+  }
+  else
+  {
+    qb = detail::derive_b( tt, dc, x_best, binary_and( ~qa[0], qa[1] ) );
+  }
+
+  fa = qa[0];
+  fb = qb[0];
+
+  qa.push_back( qb[0] );
+  qa.push_back( qb[1] );
+
+  if ( ( std::get<2>( x_best ) == bi_decomposition::and_ ) || ( std::get<2>( x_best ) == bi_decomposition::weak_and_ ) )
+  {
+    return std::make_tuple( binary_and( fa, fb ), std::get<2>( x_best ), qa );
+  }
+  else
+  {
+    return std::make_tuple( binary_or( fa, fb ), std::get<2>( x_best ), qa );
+  }
+}
+
+} /* namespace detail */
+/* \endcond */
+
+/*! \brief Checks whether a function is bi-decomposable.
+
+  \verbatim embed:rst
+  Checks whether an incompletely specified function (ISF) ``tt`` can be represented by the function
+  :math:`f = h(l(X_1, X_3), g(X_2, X_3))`.
+  It returns a tuple of:
+  1. :math:'f', which is a completely specified Boolean function compatible with the input ISF
+  2. :math:'h', which is the type of decomposition (and, or, xor, weak and, weak or)
+  3. :math:'l' and :math:'g', given as ISF (ON-set and DC-set)
+
+  The algorithm is inspired by "An Algorithm for Bi-Decomposition of Logic Functions" by A. Mishchenko et al.
+  presented in DAC 2001.
+
+  \endverbatim
+
+  \param tt ON-set of the input function \f$f\f$
+  \param dc DC-set of the input function \f$f\f$
+*/
+
+template<class TT>
+std::tuple<TT, bi_decomposition, std::vector<TT>> is_bi_decomposable( const TT& tt, const TT& dc )
+{
+  return detail::is_bi_decomposable( tt, dc, false );
+}
+
+/*! \brief Checks whether a function is bi-decomposable using XOR as preferred operation.
+
+  \verbatim embed:rst
+  Checks whether an incompletely specified function (ISF) ``tt`` can be represented by the function
+  :math:`f = h(l(X_1, X_3), g(X_2, X_3))`.
+  It returns a tuple of:
+  1. :math:'f', which is a completely specified Boolean function compatible with the input ISF
+  2. :math:'h', which is the type of decomposition (and, or, xor, weak and, weak or)
+  3. :math:'l' and :math:'g', given as ISF (ON-set and DC-set)
+
+  The algorithm is inspired by "An Algorithm for Bi-Decomposition of Logic Functions" by A. Mishchenko et al.
+  presented in DAC 2001.
+
+  The cost is changed to add more XOR gates compared to AND/OR gates. This cost function is motivated by
+  minimizing the number of AND gates in XAGs for cryptography and security applications. For these applications
+  XOR gates are "free".
+
+  \endverbatim
+
+  \param tt ON-set of the input function \f$f\f$
+  \param dc DC-set of the input function \f$f\f$
+*/
+
+template<class TT>
+std::tuple<TT, bi_decomposition, std::vector<TT>> is_bi_decomposable_mc( const TT& tt, const TT& dc )
+{
+  return detail::is_bi_decomposable( tt, dc, true );
+}
+
+namespace detail
+{
+
+/*! \brief A helper function to enumerate missing indices.
+
+  \param ys_index A list of already selected indices
+  \param max_index The maximum value for an index
+  \return Remaining indices
+*/
+inline std::vector<uint32_t> enumerate_zs_index( const std::vector<uint32_t>& ys_index, uint32_t max_index )
+{
+  std::vector<uint32_t> zs_index;
+  for ( uint32_t i = 0u; i <= max_index; ++i )
+  {
+    if ( std::find( ys_index.begin(), ys_index.end(), i ) == ys_index.end() )
+    {
+      zs_index.push_back( i );
+    }
+  }
+
+  return zs_index;
+}
+
+} // namespace detail
+
+/*! \brief Checks, whether a function is Ashenhurst decomposable.
+
+  Given functions f(.), g(.), and h(.) and a partition
+  on arguments into z and y. This function determines whether
+  f(x) is decomposable into g(z, h(y)) where x = union(z,y) and
+  intersect(z, y) = null.
+  This function does not check for permutation of variables given by
+  zs_index and ys_index. The elements in these vectors are treated as ordered
+  values.
+
+  \param tt The function to the check the decomposition on (function f)
+  \param zs_index The ordered set of indices of vector x (input to f) that
+                  are the inputs to outer_func (g).
+  \param ys_index The ordered set of indices of vector x (input to f) that are
+                  input to the inner_func (h).
+  \param outer_func The outer decomposition function (function g).
+  \param inner_func The inner decomposition function (function h).
+  \return true if the given decomposition is a valid one, false otherwise.
+*/
+template<class TTf, class TTg, class TTh>
+bool is_ashenhurst_decomposable( const TTf& tt,
+                                 const std::vector<uint32_t>& zs_index,
+                                 const std::vector<uint32_t>& ys_index,
+                                 const TTg& outer_func,
+                                 const TTh& inner_func )
+{
+  static_assert( is_complete_truth_table<TTf>::value, "Can only be applied on complete truth tables." );
+  static_assert( is_complete_truth_table<TTg>::value, "Can only be applied on complete truth tables." );
+  static_assert( is_complete_truth_table<TTh>::value, "Can only be applied on complete truth tables." );
+
+  std::vector<TTf> y_vars;
+  std::vector<TTf> z_vars;
+
+  for ( const auto idx : ys_index )
+  {
+    auto var = tt.construct();
+    create_nth_var( var, idx );
+    y_vars.push_back( var );
+  }
+  for ( const auto idx : zs_index )
+  {
+    auto var = tt.construct();
+    create_nth_var( var, idx );
+    z_vars.push_back( var );
+  }
+  auto h = compose_truth_table( inner_func, y_vars );
+  z_vars.push_back( h );
+  auto f = compose_truth_table( outer_func, z_vars );
+  return equal( f, tt );
+}
+
+/*! \brief Finds all of the possible Ashenhurst decompositions of a function
+  given an input partitioning.
+
+  \param tt The function to find all of its decompositions
+  \param ys_index Indices indicating the partitioning of inputs
+  \param decomposition A vector of decomposition pairs. This serves as a return
+                       return container.
+  \return Returns the number of possible decompositions.
+*/
+template<class TTf, class TTg, class TTh>
+uint32_t ashenhurst_decomposition( const TTf& tt, const std::vector<uint32_t>& ys_index, std::vector<std::pair<TTg, TTh>>& decomposition )
+{
+  static_assert( is_complete_truth_table<TTf>::value, "Can only be applied on complete truth tables." );
+  static_assert( is_complete_truth_table<TTg>::value, "Can only be applied on complete truth tables." );
+  static_assert( is_complete_truth_table<TTh>::value, "Can only be applied on complete truth tables." );
+
+  std::vector<uint32_t> zs_index = detail::enumerate_zs_index( ys_index, tt.num_vars() - 1 );
+  decomposition.clear();
+
+  // TODO: this does not work for dynamic_truth_table (number of variables not known)
+  TTg g;
+  do
+  {
+    TTh h;
+    do
+    {
+      if ( is_ashenhurst_decomposable( tt, zs_index, ys_index, g, h ) )
+      {
+        decomposition.emplace_back( g, h );
+      }
+      next_inplace( h );
+    } while ( !is_const0( h ) );
+    next_inplace( g );
+  } while ( !is_const0( g ) );
+  return static_cast<uint32_t>( decomposition.size() );
+}
+
+} // namespace kitty
\ No newline at end of file
diff --git a/lib/kitty/kitty/detail/constants.hpp b/lib/kitty/kitty/detail/constants.hpp
new file mode 100644
index 0000000..4579b4e
--- /dev/null
+++ b/lib/kitty/kitty/detail/constants.hpp
@@ -0,0 +1,196 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file constants.hpp
+  \brief Collects several important constants
+
+  \author Mathias Soeken
+*/
+
+/*! \cond PRIVATE */
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+namespace kitty
+{
+
+namespace detail
+{
+
+static constexpr uint64_t projections[] = {
+    UINT64_C( 0xaaaaaaaaaaaaaaaa ),
+    UINT64_C( 0xcccccccccccccccc ),
+    UINT64_C( 0xf0f0f0f0f0f0f0f0 ),
+    UINT64_C( 0xff00ff00ff00ff00 ),
+    UINT64_C( 0xffff0000ffff0000 ),
+    UINT64_C( 0xffffffff00000000 ) };
+
+static constexpr uint64_t projections_neg[] = {
+    UINT64_C( 0x5555555555555555 ),
+    UINT64_C( 0x3333333333333333 ),
+    UINT64_C( 0x0f0f0f0f0f0f0f0f ),
+    UINT64_C( 0x00ff00ff00ff00ff ),
+    UINT64_C( 0x0000ffff0000ffff ),
+    UINT64_C( 0x00000000ffffffff ) };
+
+static constexpr uint64_t masks[] = {
+    UINT64_C( 0x0000000000000001 ),
+    UINT64_C( 0x0000000000000003 ),
+    UINT64_C( 0x000000000000000f ),
+    UINT64_C( 0x00000000000000ff ),
+    UINT64_C( 0x000000000000ffff ),
+    UINT64_C( 0x00000000ffffffff ),
+    UINT64_C( 0xffffffffffffffff ) };
+
+static constexpr uint64_t permutation_masks[][3] = {
+    { UINT64_C( 0x9999999999999999 ), UINT64_C( 0x2222222222222222 ), UINT64_C( 0x4444444444444444 ) },
+    { UINT64_C( 0xc3c3c3c3c3c3c3c3 ), UINT64_C( 0x0c0c0c0c0c0c0c0c ), UINT64_C( 0x3030303030303030 ) },
+    { UINT64_C( 0xf00ff00ff00ff00f ), UINT64_C( 0x00f000f000f000f0 ), UINT64_C( 0x0f000f000f000f00 ) },
+    { UINT64_C( 0xff0000ffff0000ff ), UINT64_C( 0x0000ff000000ff00 ), UINT64_C( 0x00ff000000ff0000 ) },
+    { UINT64_C( 0xffff00000000ffff ), UINT64_C( 0x00000000ffff0000 ), UINT64_C( 0x0000ffff00000000 ) } };
+
+static constexpr uint64_t ppermutation_masks[][6][3] = {
+    { { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) },
+      { UINT64_C( 0x9999999999999999 ), UINT64_C( 0x2222222222222222 ), UINT64_C( 0x4444444444444444 ) },
+      { UINT64_C( 0xa5a5a5a5a5a5a5a5 ), UINT64_C( 0x0a0a0a0a0a0a0a0a ), UINT64_C( 0x5050505050505050 ) },
+      { UINT64_C( 0xaa55aa55aa55aa55 ), UINT64_C( 0x00aa00aa00aa00aa ), UINT64_C( 0x5500550055005500 ) },
+      { UINT64_C( 0xaaaa5555aaaa5555 ), UINT64_C( 0x0000aaaa0000aaaa ), UINT64_C( 0x5555000055550000 ) },
+      { UINT64_C( 0xaaaaaaaa55555555 ), UINT64_C( 0x00000000aaaaaaaa ), UINT64_C( 0x5555555500000000 ) } },
+    { { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) },
+      { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) },
+      { UINT64_C( 0xc3c3c3c3c3c3c3c3 ), UINT64_C( 0x0c0c0c0c0c0c0c0c ), UINT64_C( 0x3030303030303030 ) },
+      { UINT64_C( 0xcc33cc33cc33cc33 ), UINT64_C( 0x00cc00cc00cc00cc ), UINT64_C( 0x3300330033003300 ) },
+      { UINT64_C( 0xcccc3333cccc3333 ), UINT64_C( 0x0000cccc0000cccc ), UINT64_C( 0x3333000033330000 ) },
+      { UINT64_C( 0xcccccccc33333333 ), UINT64_C( 0x00000000cccccccc ), UINT64_C( 0x3333333300000000 ) } },
+    { { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) },
+      { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) },
+      { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) },
+      { UINT64_C( 0xf00ff00ff00ff00f ), UINT64_C( 0x00f000f000f000f0 ), UINT64_C( 0x0f000f000f000f00 ) },
+      { UINT64_C( 0xf0f00f0ff0f00f0f ), UINT64_C( 0x0000f0f00000f0f0 ), UINT64_C( 0x0f0f00000f0f0000 ) },
+      { UINT64_C( 0xf0f0f0f00f0f0f0f ), UINT64_C( 0x00000000f0f0f0f0 ), UINT64_C( 0x0f0f0f0f00000000 ) } },
+    { { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) },
+      { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) },
+      { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) },
+      { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) },
+      { UINT64_C( 0xff0000ffff0000ff ), UINT64_C( 0x0000ff000000ff00 ), UINT64_C( 0x00ff000000ff0000 ) },
+      { UINT64_C( 0xff00ff0000ff00ff ), UINT64_C( 0x00000000ff00ff00 ), UINT64_C( 0x00ff00ff00000000 ) } },
+    { { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) },
+      { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) },
+      { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) },
+      { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) },
+      { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) },
+      { UINT64_C( 0xffff00000000ffff ), UINT64_C( 0x00000000ffff0000 ), UINT64_C( 0x0000ffff00000000 ) } } };
+
+static std::vector<uint64_t> onehots[] = {
+    { UINT64_C( 0x1 ) },
+    { UINT64_C( 0x1 ), UINT64_C( 0x2 ) },
+    { UINT64_C( 0x1 ), UINT64_C( 0x6 ), UINT64_C( 0x8 ) },
+    { UINT64_C( 0x01 ), UINT64_C( 0x16 ), UINT64_C( 0x68 ), UINT64_C( 0x80 ) },
+    { UINT64_C( 0x0001 ), UINT64_C( 0x0116 ), UINT64_C( 0x1668 ), UINT64_C( 0x6880 ), UINT64_C( 0x8000 ) },
+    { UINT64_C( 0x00000001 ), UINT64_C( 0x00010116 ), UINT64_C( 0x01161668 ), UINT64_C( 0x16686880 ), UINT64_C( 0x68808000 ), UINT64_C( 0x80000000 ) },
+    { UINT64_C( 0x0000000000000001 ),
+      UINT64_C( 0x0000000100010116 ),
+      UINT64_C( 0x0001011601161668 ),
+      UINT64_C( 0x0116166816686880 ),
+      UINT64_C( 0x1668688068808000 ),
+      UINT64_C( 0x6880800080000000 ),
+      UINT64_C( 0x8000000000000000 ) } };
+
+static constexpr int32_t hex_to_int[] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+                                          -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+                                          -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+                                          0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
+                                          -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+                                          -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+                                          -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+                                          -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
+
+/*! adjacent swap sequences (from 2 to 7 variables) */
+static std::vector<uint8_t> swaps[] = { { 0 },
+                                        { 1, 0, 1, 0, 1 },
+                                        { 2, 1, 0, 2, 0, 1, 2, 0, 2, 1, 0, 2, 0, 1, 2, 0, 2, 1, 0, 2, 0, 1, 2 },
+                                        { 3, 2, 1, 0, 3, 0, 1, 2, 3, 1, 3, 2, 1, 0, 1, 0, 1, 2, 3, 2, 3, 2, 1, 0, 1, 0, 1, 2, 3, 1, 3, 2, 1, 0, 3, 0, 1, 2, 3, 0, 3, 2, 1, 0, 3, 0, 1, 2, 3, 1, 3, 2, 1, 0, 1, 0, 1, 2, 3, 2, 3, 2, 1, 0, 1, 0, 1, 2, 3, 1, 3, 2, 1, 0, 3, 0, 1, 2, 3, 0, 3, 2, 1, 0, 3, 0, 1, 2, 3, 1, 3, 2, 1, 0, 1, 0, 1, 2, 3, 2, 3, 2, 1, 0, 1, 0, 1, 2, 3, 1, 3, 2, 1, 0, 3, 0, 1, 2, 3 },
+                                        { 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 1, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 1, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 1, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 1, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 1, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 1, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4, 0, 4, 3, 2, 1, 0, 2, 0, 1, 2, 3, 4, 2, 4, 3, 2, 1, 0, 4, 0, 1, 2, 3, 4 },
+                                        { 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1,
+                                          0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2,
+                                          3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5,
+                                          4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0,
+                                          3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3,
+                                          4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4,
+                                          3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 0, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 2, 5, 4, 3, 2, 1, 0, 5, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 5, 4, 3, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 1, 5, 4, 3, 2, 1, 0, 3, 0, 1, 2, 3, 4, 5, 3, 5, 4, 3, 2, 1, 0, 5,
+                                          0, 1, 2, 3, 4, 5 } };
+
+/*! flip sequences (from 2 to 6 variables) */
+static std::vector<uint8_t> flips[] = { { 0, 1, 0 },
+                                        { 0, 1, 0, 2, 0, 1, 0 },
+                                        { 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0 },
+                                        { 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0 },
+                                        { 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0 } };
+
+static constexpr uint8_t de_bruijn64[] = { 63, 0, 58, 1, 59, 47, 53, 2,
+                                           60, 39, 48, 27, 54, 33, 42, 3,
+                                           61, 51, 37, 40, 49, 18, 28, 20,
+                                           55, 30, 34, 11, 43, 14, 22, 4,
+                                           62, 57, 46, 52, 38, 26, 32, 41,
+                                           50, 36, 17, 19, 29, 10, 13, 21,
+                                           56, 45, 25, 31, 35, 16, 9, 12,
+                                           44, 24, 15, 8, 23, 7, 6, 5 };
+
+static constexpr uint16_t primes[] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31,
+                                       37, 41, 43, 47, 53, 59, 61, 67, 71, 73,
+                                       79, 83, 89, 97, 101, 103, 107, 109, 113,
+                                       127, 131, 137, 139, 149, 151, 157, 163,
+                                       167, 173, 179, 181, 191, 193, 197, 199,
+                                       211, 223, 227, 229, 233, 239, 241, 251,
+                                       257, 263, 269, 271, 277, 281, 283, 293,
+                                       307, 311, 313, 317, 331, 337, 347, 349,
+                                       353, 359, 367, 373, 379, 383, 389, 397,
+                                       401, 409, 419, 421, 431, 433, 439, 443,
+                                       449, 457, 461, 463, 467, 479, 487, 491,
+                                       499, 503, 509, 521, 523, 541, 547, 557,
+                                       563, 569, 571, 577, 587, 593, 599, 601,
+                                       607, 613, 617, 619, 631, 641, 643, 647,
+                                       653, 659, 661, 673, 677, 683, 691, 701,
+                                       709, 719, 727, 733, 739, 743, 751, 757,
+                                       761, 769, 773, 787, 797, 809, 811, 821,
+                                       823, 827, 829, 839, 853, 857, 859, 863,
+                                       877, 881, 883, 887, 907, 911, 919, 929,
+                                       937, 941, 947, 953, 967, 971, 977, 983,
+                                       991, 997, 1009, 1013, 1019, 1021, 1031 };
+
+static constexpr int8_t log2[] = { -1, 0, 1, -1, 2, -1, -1, -1, 3, -1,
+                                   -1, -1, -1, -1, -1, -1, 4, -1, -1, -1,
+                                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+                                   -1, -1, 5, -1, -1, -1, -1, -1, -1, -1,
+                                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+                                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+                                   -1, -1, -1, -1, 6 };
+
+} // namespace detail
+} // namespace kitty
+  /*! \endcond */
\ No newline at end of file
diff --git a/lib/kitty/kitty/detail/linear_constants.hpp b/lib/kitty/kitty/detail/linear_constants.hpp
new file mode 100644
index 0000000..946b3d4
--- /dev/null
+++ b/lib/kitty/kitty/detail/linear_constants.hpp
@@ -0,0 +1,51 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file linear_constants.hpp
+  \brief Collects several constants for permutation and linear classification
+
+  \author Mathias Soeken
+*/
+
+/*! \cond PRIVATE */
+#pragma once
+
+#include <cstdint>
+
+namespace kitty
+{
+
+namespace detail
+{
+const uint64_t linear_masks[] = { 0x4, 0x2, 0x4, 0x0, 0x2, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x0, 0x2, 0x0, 0x4, 0x2, 0x0, 0x50, 0x0, 0xa, 0x0, 0x50, 0x0, 0x0, 0xa, 0x0, 0x50, 0x50, 0x0, 0x6, 0x0, 0x14, 0x0, 0x0, 0x6, 0x0, 0x14, 0x50, 0x0, 0xa, 0x12, 0x50, 0x0, 0x0, 0xa, 0x12, 0x50, 0x50, 0x30, 0x6, 0x0, 0x14, 0x0, 0x30, 0x6, 0x0, 0x14, 0x50, 0x30, 0xc, 0x12, 0x44, 0x0, 0x30, 0xc, 0x12, 0x44, 0x50, 0x30, 0xc, 0x22, 0x14, 0x0, 0x30, 0xc, 0x22, 0x14, 0x50, 0x0, 0xc, 0x12, 0x44, 0x0, 0x0, 0xc, 0x12, 0x44, 0x50, 0x0, 0xc, 0x22, 0x14, 0x0, 0x0, 0xc, 0x22, 0x14, 0x50, 0x0, 0x6, 0x30, 0x44, 0x0, 0x0, 0x6, 0x30, 0x44, 0x50, 0x0, 0xa, 0x30, 0x50, 0x0, 0x0, 0xa, 0x30, 0x50, 0x50, 0x30, 0x6, 0x30, 0x44, 0x0, 0x30, 0x6, 0x30, 0x44, 0x50, 0x0, 0xa, 0x22, 0x50, 0x0, 0x0, 0xa, 0x22, 0x50, 0x44, 0x30, 0x6, 0x12, 0x50, 0x0, 0x30, 0x6, 0x12, 0x50, 0x44, 0x0, 0x6, 0x12, 0x14, 0x0, 0x0, 0x6, 0x12, 0x14, 0x44, 0x30, 0x6, 0x12, 0x14, 0x0, 0x0, 0x6, 0x12, 0x50, 0x44, 0x0, 0x6, 0x12, 0x50, 0x0, 0x30, 0x6, 0x12, 0x14, 0x0, 0x30, 0xc, 0x30, 0x0, 0x0, 0x30, 0xc, 0x30, 0x44, 0x0, 0x30, 0xc, 0x30, 0x50, 0x0, 0x30, 0xc, 0x30, 0x14, 0x0, 0x30, 0x6, 0x12, 0x0, 0x0, 0x0, 0x6, 0x12, 0x44, 0x44, 0x30, 0x6, 0x12, 0x0, 0x44, 0x0, 0x6, 0x12, 0x44, 0x0, 0x0, 0xc, 0x30, 0x0, 0x0, 0x0, 0xc, 0x30, 0x44, 0x0, 0x0, 0xc, 0x30, 0x50, 0x0, 0x0, 0xc, 0x30, 0x14, 0x0, 0x0, 0x6, 0x12, 0x0, 0x0, 0x30, 0x6, 0x12, 0x44, 0x44, 0x30, 0x6, 0x12, 0x44, 0x44, 0x0, 0x6, 0x12, 0x0, 0x50, 0x0, 0xa, 0x12, 0x14, 0x0, 0x30, 0x6, 0x0, 0x50, 0x50, 0x30, 0x6, 0x0, 0x50, 0x0, 0x0, 0xa, 0x12, 0x14, 0x50, 0x0, 0xa, 0x0, 0x14, 0x0, 0x0, 0x6, 0x0, 0x50, 0x50, 0x0, 0x6, 0x0, 0x50, 0x0, 0x0, 0xa, 0x0, 0x14, 0x0, 0x30, 0xc, 0x12, 0x0, 0x50, 0x30, 0xc, 0x12, 0x0, 0x0, 0x30, 0xc, 0x22, 0x50, 0x50, 0x30, 0xc, 0x22, 0x50, 0x0, 0x30, 0x6, 0x30, 0x0, 0x50, 0x30, 0x6, 0x30, 0x0, 0x50, 0x0, 0xa, 0x22, 0x14, 0x0, 0x0, 0xa, 0x22, 0x14, 0x0, 0x0, 0x6, 0x30, 0x0, 0x50, 0x0, 0x6, 0x30, 0x0, 0x50, 0x0, 0xa, 0x30, 0x14, 0x0, 0x0, 0xa, 0x30, 0x14, 0x0, 0x0, 0xc, 0x12, 0x0, 0x50, 0x0, 0xc, 0x12, 0x0, 0x0, 0x0, 0xc, 0x22, 0x50, 0x50, 0x0, 0xc, 0x22, 0x50, 0x44, 0x0, 0x0, 0x22, 0x44, 0x0, 0x0, 0x0, 0x22, 0x44, 0x44, 0x0, 0x0, 0x12, 0x14, 0x0, 0x0, 0x0, 0x12, 0x14, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x44, 0x0, 0x0, 0x0, 0x0, 0x50, 0x0, 0x0, 0x0, 0x0, 0x14, 0x0, 0x0, 0x0, 0x22, 0x0, 0x44, 0x0, 0x0, 0x22, 0x0, 0x0, 0x0, 0x0, 0x12, 0x50, 0x44, 0x0, 0x0, 0x12, 0x50, 0x44, 0x0, 0x0, 0x22, 0x14, 0x0, 0x0, 0x0, 0x12, 0x44, 0x44, 0x0, 0x0, 0x12, 0x44, 0x0, 0x0, 0x0, 0x22, 0x14, 0x0, 0x0, 0x0, 0x30, 0x0, 0x0, 0x0, 0x0, 0x30, 0x44, 0x0, 0x0, 0x0, 0x30, 0x50, 0x0, 0x0, 0x0, 0x30, 0x14, 0x0, 0x0, 0x0, 0x12, 0x0, 0x44, 0x0, 0x0, 0x22, 0x50, 0x0, 0x0, 0x0, 0x22, 0x50, 0x44, 0x0, 0x0, 0x12, 0x0, 0x50, 0x0, 0xc, 0x12, 0x14, 0x0, 0x0, 0xc, 0x22, 0x44, 0x50, 0x0, 0xc, 0x22, 0x44, 0x0, 0x0, 0xc, 0x12, 0x14, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x0, 0x6, 0x0, 0x44, 0x50, 0x0, 0xa, 0x0, 0x0, 0x50, 0x0, 0x6, 0x0, 0x44, 0x0, 0x0, 0xa, 0x22, 0x0, 0x50, 0x30, 0x6, 0x30, 0x14, 0x50, 0x0, 0xa, 0x22, 0x0, 0x0, 0x30, 0x6, 0x30, 0x14, 0x50, 0x30, 0xc, 0x12, 0x14, 0x0, 0x30, 0xc, 0x22, 0x44, 0x50, 0x30, 0xc, 0x22, 0x44, 0x0, 0x30, 0xc, 0x12, 0x14, 0x0, 0x0, 0xa, 0x30, 0x0, 0x50, 0x0, 0x6, 0x30, 0x14, 0x50, 0x0, 0xa, 0x30, 0x0, 0x0, 0x0, 0x6, 0x30, 0x14, 0x0, 0x0, 0xa, 0x12, 0x0, 0x0, 0x30, 0x6, 0x0, 0x44, 0x50, 0x0, 0xa, 0x12, 0x0, 0x50, 0x30, 0x6, 0x0, 0x44, 0x44, 0x0, 0x6, 0x22, 0x44, 0x0, 0x0, 0x6, 0x22, 0x44, 0x44, 0x30, 0x6, 0x22, 0x50, 0x0, 0x30, 0x6, 0x22, 0x50, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x0, 0xc, 0x0, 0x44, 0x0, 0x0, 0xc, 0x0, 0x50, 0x0, 0x0, 0xc, 0x0, 0x14, 0x0, 0x0, 0x6, 0x22, 0x0, 0x44, 0x0, 0x6, 0x22, 0x0, 0x44, 0x30, 0x6, 0x22, 0x14, 0x0, 0x30, 0x6, 0x22, 0x14, 0x0, 0x30, 0xc, 0x0, 0x0, 0x0, 0x30, 0xc, 0x0, 0x44, 0x0, 0x30, 0xc, 0x0, 0x50, 0x0, 0x30, 0xc, 0x0, 0x14, 0x0, 0x30, 0x6, 0x22, 0x0, 0x44, 0x0, 0x6, 0x22, 0x14, 0x44, 0x30, 0x6, 0x22, 0x0, 0x0, 0x0, 0x6, 0x22, 0x14, 0x44, 0x0, 0x6, 0x22, 0x50, 0x0, 0x30, 0x6, 0x22, 0x44, 0x44, 0x30, 0x6, 0x22, 0x44, 0x0, 0x0, 0x6, 0x22, 0x50, 0x50, 0x30, 0x6, 0x30, 0x50, 0x0, 0x0, 0xa, 0x22, 0x44, 0x50, 0x0, 0xa, 0x22, 0x44, 0x0, 0x30, 0x6, 0x30, 0x50, 0x0, 0x0, 0x6, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x44, 0x50, 0x0, 0xa, 0x0, 0x44, 0x50, 0x0, 0x6, 0x0, 0x0, 0x0, 0x0, 0xc, 0x22, 0x0, 0x50, 0x0, 0xc, 0x12, 0x50, 0x0, 0x0, 0xc, 0x12, 0x50, 0x50, 0x0, 0xc, 0x22, 0x0, 0x0, 0x30, 0xc, 0x22, 0x0, 0x50, 0x30, 0xc, 0x12, 0x50, 0x0, 0x30, 0xc, 0x12, 0x50, 0x50, 0x30, 0xc, 0x22, 0x0, 0x0, 0x30, 0x6, 0x0, 0x0, 0x0, 0x0, 0xa, 0x12, 0x44, 0x50, 0x0, 0xa, 0x12, 0x44, 0x50, 0x30, 0x6, 0x0, 0x0, 0x50, 0x0, 0x6, 0x30, 0x50, 0x0, 0x0, 0xa, 0x30, 0x44, 0x50, 0x0, 0xa, 0x30, 0x44, 0x0, 0x0, 0x6, 0x30, 0x50,
+                                  0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x3030, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x2112, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x3030, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x3030, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x2112, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x2112, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x1122, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x3030, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x3300, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x3300, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x2112, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x3300, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x1212, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x1212, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x3300, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x3300, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x2112, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3300, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x1212, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x3300, 0x4114, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x330, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x330, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x330, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x330, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x1212, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x1122, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x330, 0x1144, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x2112, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x2112, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x3030, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x2112, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x3030, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x3030, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x2112, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x2112, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x1212, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x1212, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x3300, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x3300, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x3300, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x3300, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x3300, 0x4114, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x1212, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x1212, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x1212, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x330, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x330, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x1212, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x330, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x0, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x0, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x0, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x0, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x3030, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x2112, 0x1414, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x2222, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x2222, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x0, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x0, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x3300, 0x4444, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x1212, 0x1144, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x0, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x0, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x330, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x330, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x906, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x906, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x3030, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x2112, 0x1414, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x2222, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x2222, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x906, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x3300, 0x4444, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x3300, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x2222, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x1212, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x2112, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x2112, 0x4444, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x1122, 0x1414, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x1212, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x1212, 0x1144, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x2222, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x2112, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x1122, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x2222, 0x4114, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x906, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x330, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x330, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x330, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x1212, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x0, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x0, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x0, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x0, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x2112, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x2112, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x0, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x0, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x1122, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x2112, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x2112, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x1122, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x1122, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x330, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x2222, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x330, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x330, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x3300, 0x4114, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x2112, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x2112, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x3300, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x3300, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x3300, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x3300, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x2222, 0x4114, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x2112, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x2112, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x2112, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x2222, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x330, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x330, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x330, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x1122, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x330, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x0, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x2112, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x0, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x2112, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x0, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x1122, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x1122, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x2222, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x2222, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x330, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x330, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x330, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x2222, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x2112, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x2112, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x2222, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x2112, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x3300, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x3300, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x3300, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x330, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x330, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x2222, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x0, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x0, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x0, 0x4114, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x1212, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x2222, 0x1414, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x2112, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x2112, 0x1144, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x1122, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x1212, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x1212, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x2222, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x2112, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x1122, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x3030, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x3030, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x3030, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x2222, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x1122, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x3300, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x3300, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x2112, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x3300, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x3300, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x1212, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x3300, 0x4114, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2112, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2112, 0x4444, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1122, 0x1414, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1212, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1212, 0x1144, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2222, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x2112, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x1122, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x2222, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x330, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x330, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x330, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x1122, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x330, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x0, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x2112, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x0, 0x4114, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x2222, 0x1414, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x2112, 0x1144, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x1122, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x1122, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x3300, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x1212, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x1212, 0x1144, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x330, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x2222, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x2222, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x0, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x0, 0x4114, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x330, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x330, 0x5500, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x330, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x330, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x1212, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x1212, 0x5500, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x2222, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x3030, 0x4114, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x3030, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x0, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x0, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x2112, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x0, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x0, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x1212, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x1212, 0x4114, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x2112, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x3030, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x3030, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x3030, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x3030, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x2112, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x2222, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x2112, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x330, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x330, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x1212, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x0, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x0, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x0, 0x4114, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x1212, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x1212, 0x5500, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x2222, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x1212, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x330, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x330, 0x5500, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x330, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x330, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x3030, 0x4114, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x3030, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x3030, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x1212, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x2112, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x2112, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x1212, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x0, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x0, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x0, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x1212, 0x4114, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x2112, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x2112, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x2222, 0x4114, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x2112, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x3030, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x3030, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x3030, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x2222, 0x4114, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x330, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x330, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x330, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x0, 0x1144, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x2222, 0x1414, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x2112, 0x1144, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x3030, 0x4114, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x3030, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x2112, 0x1414, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x2222, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x2222, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x3300, 0x4114, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x606, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x0, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x0, 0x1144, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x1212, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x2222, 0x1414, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x2112, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x2112, 0x1144, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x1122, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x1212, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x1212, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x2222, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x2112, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x1122, 0x4114, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x606, 0x3030, 0x4114, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x3030, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x3030, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x2112, 0x1414, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x2222, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x2222, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x606, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x2222, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x3300, 0x4114, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x606, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x1212, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x330, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x0, 0x1144, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x1212, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x3300, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x3300, 0x5500, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x3300, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x1212, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x2222, 0x5500, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x1212, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x1212, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x3030, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x3030, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x3030, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x2222, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x1122, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x3030, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x3030, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x2222, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x3030, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x1122, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x3300, 0x4444, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x2222, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x1212, 0x550, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x0, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x0, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x0, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x0, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x1212, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x1212, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x1212, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x1122, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x0, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x0, 0x1144, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x2222, 0x5500, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x1212, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x3300, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x3300, 0x5500, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x3300, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x1122, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x2222, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x2222, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x1122, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x3030, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x3030, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x3300, 0x4444, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3300, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x1212, 0x550, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x1212, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x0, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x0, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x1212, 0x1144, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x3030, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x3030, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x3030, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x3030, 0x550, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x3030, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x3030, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2112, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x2112, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x1122, 0x550, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x1122, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x3030, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x2112, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x1122, 0x550, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x1122, 0x4114, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x3300, 0x5050, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x3300, 0x1414, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x3300, 0x550, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x3300, 0x4114, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x2112, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x2112, 0x1414, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x1212, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x1212, 0x4114, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x3300, 0x5050, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x3300, 0x1414, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x3300, 0x4114, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x2112, 0x5050, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2112, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2112, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x1212, 0x550, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x1212, 0x4114, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x330, 0x5050, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x330, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x330, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x330, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x330, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x330, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x1122, 0x5050, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x1122, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x1212, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x1122, 0x5050, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x1122, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x1212, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x1212, 0x1144, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x3030, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x3030, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x3030, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x3030, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x3030, 0x550, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x3030, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x2112, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x1122, 0x550, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x1122, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x3030, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x2112, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2112, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x1122, 0x550, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x1122, 0x4114, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x3300, 0x5050, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x3300, 0x1414, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x3300, 0x550, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x3300, 0x4114, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x2112, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2112, 0x5050, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x2112, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x1212, 0x550, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x1212, 0x4114, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x3300, 0x5050, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x3300, 0x1414, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x3300, 0x4114, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x2112, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x2112, 0x1414, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x1212, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x1212, 0x4114, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x330, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x330, 0x5050, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x330, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x330, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x330, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x1122, 0x5050, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x1122, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x1212, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x330, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x1122, 0x5050, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x1122, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x1212, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x1212, 0x1144, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x0, 0x1122, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x0, 0x2112, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x0, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x1122, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x0, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x2112, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x0, 0x2112, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x0, 0x1122, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x0, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x2112, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x0, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x3300, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0x0, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x0, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x1122, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x0, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x0, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x1122, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x1122, 0x0, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x2112, 0x1414, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x330, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x330, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x96, 0x0, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x0, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x330, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x330, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x330, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x0, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x0, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x1122, 0x1414, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x1122, 0x5050, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x2112, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x2112, 0x0, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x1122, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x1122, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2112, 0x550, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x2112, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x1122, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x2112, 0x550, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x2112, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x3030, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x3030, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x3030, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x3030, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x3030, 0x550, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x3030, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x3300, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x3300, 0x0, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x3300, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x3300, 0x5500, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x3300, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x1122, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x1122, 0x0, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x1122, 0x4444, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x1212, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x3300, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x1122, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x1122, 0x4444, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x1212, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x330, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x330, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x330, 0x0, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x330, 0x4444, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x330, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x330, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x330, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x2112, 0x4444, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x2112, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x1212, 0x1144, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x1212, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x330, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x330, 0x4444, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x330, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x2112, 0x0, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x1212, 0x5500, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x1212, 0x1144, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x906, 0x1122, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x2112, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x2112, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x906, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x1122, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x2112, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x2112, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x1122, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x2112, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x1122, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x906, 0x1122, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x1122, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x2112, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x906, 0x1122, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x3300, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0x906, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x1122, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x2112, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x906, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x1122, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x1122, 0x0, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x2112, 0x1414, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x330, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x330, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x330, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x330, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x330, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x330, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x330, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x330, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x906, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x1122, 0x1414, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x2112, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x906, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x1122, 0x1414, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x1122, 0x5050, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x2112, 0x4444, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x2112, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x1122, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x2112, 0x550, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x2112, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x1122, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x1122, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x2112, 0x550, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2112, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x3030, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x3030, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x3030, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x3030, 0x550, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x3030, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x3030, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x3300, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x3300, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x3300, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x3300, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x1122, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x1122, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x1212, 0x4114, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x1122, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x1122, 0x0, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x1212, 0x4114, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x330, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x330, 0x4444, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x330, 0x0, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x330, 0x4114, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x330, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x330, 0x550, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x330, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x2112, 0x4444, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x1212, 0x1144, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x330, 0x0, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x330, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x330, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x330, 0x4114, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x2112, 0x4444, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x2112, 0x4444, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x1212, 0x1144, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x1212, 0x1144, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x1212, 0x5500, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x1212, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x1212, 0x1414, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x2112, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x2112, 0x4114, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x1212, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x1212, 0x1414, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x2112, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x3030, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x3030, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x3030, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x3030, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x3030, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x3030, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x3030, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x1212, 0x4444, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x1212, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x1212, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x2112, 0x1144, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x2112, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x1212, 0x4444, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x1212, 0x4444, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x2112, 0x1144, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x2112, 0x1144, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x2112, 0x5500, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x2112, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x2112, 0x1414, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x1212, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x1212, 0x4114, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x2112, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x2112, 0x1414, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x1212, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x330, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x330, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x330, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x330, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x330, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x330, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x330, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x330, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x2112, 0x4444, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x1212, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x1212, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x1212, 0x1144, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x2112, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x330, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x2112, 0x4444, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x1212, 0x1144, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x1212, 0x1144, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x2112, 0x4444, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x2112, 0x0, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x1212, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x1212, 0x1414, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x2112, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x2112, 0x4114, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x1212, 0x5050, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x1212, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x2112, 0x550, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x3030, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x3030, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x3030, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x3030, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x3030, 0x5050, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x3030, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x1212, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x1122, 0x550, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x1122, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x1212, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x3030, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x1122, 0x550, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x1122, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x1212, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x1122, 0x4114, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x3300, 0x5050, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x3300, 0x1414, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x3300, 0x550, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x3300, 0x4114, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x3300, 0x5050, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x3300, 0x1414, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x330, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x330, 0x550, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x330, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x330, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x330, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x330, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x1122, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x2112, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x1122, 0x5050, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x330, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x330, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x330, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x1122, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x2112, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x1122, 0x5050, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x2112, 0x4114, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x3030, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x1212, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x1212, 0x4444, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x2112, 0x1144, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x1212, 0x4444, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x1212, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x2112, 0x1144, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x2112, 0x1144, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x2112, 0x5500, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x1212, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x1212, 0x4114, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x1212, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x330, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x330, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x330, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x2112, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x2112, 0x4444, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x1212, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x1212, 0x1144, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x330, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x2112, 0x4444, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x1212, 0x1144, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x1212, 0x1144, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x2112, 0x4444, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x1212, 0x5050, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x1212, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2112, 0x550, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x2112, 0x4114, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x1212, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x1212, 0x1414, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x2112, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x3030, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x3030, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x3030, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x3030, 0x4444, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x3030, 0x0, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x3030, 0x1414, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x1122, 0x4114, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x1122, 0x550, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x1212, 0x4444, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x1212, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x1122, 0x550, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x1122, 0x4114, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x3300, 0x5050, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x3300, 0x1414, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x3300, 0x550, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x3300, 0x4114, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x3300, 0x5050, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x3300, 0x1414, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x330, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x330, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x330, 0x4114, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x330, 0x550, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x330, 0x4444, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x330, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x330, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x1122, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x2112, 0x4444, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x1122, 0x1414, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x330, 0x4114, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x330, 0x550, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x1122, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x2112, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x1122, 0x1414, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x1122, 0x5050, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x1122, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x3030, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x1212, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x1212, 0x4444, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x1212, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x1212, 0x0, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x1122, 0x4114, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x3300, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x1122, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x1212, 0x550, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x1212, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x1122, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x1212, 0x4114, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x1212, 0x550, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x1122, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x1212, 0x4114, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x1212, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x1212, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x1212, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x1212, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x1212, 0x5050, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x1212, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x1122, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x1212, 0x5050, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x1212, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x1122, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x3030, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x3030, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x3030, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x3030, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x3030, 0x1414, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x3030, 0x0, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x1212, 0x4444, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x2112, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x2112, 0x1144, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x1212, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x3030, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x3030, 0x1414, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x3030, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x2112, 0x5500, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x1212, 0x0, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x3300, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x3300, 0x5500, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x3300, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x3300, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x3300, 0x0, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x2112, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2112, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x2112, 0x1414, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x1122, 0x0, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x3300, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x2112, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x2112, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x2112, 0x1414, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x1122, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x1122, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x330, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x330, 0x5050, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x330, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x330, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x330, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x330, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x1212, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x606, 0x1122, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x1212, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x606, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x3030, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x3030, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x3030, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x3030, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x3030, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x3030, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x3030, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x1212, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x1212, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x1212, 0x4444, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x66, 0x606, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x1212, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x1212, 0x4444, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x1212, 0x0, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x1122, 0x4114, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x66, 0x606, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x3300, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0x606, 0x1122, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x1212, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x1212, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x606, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x1122, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x1212, 0x4114, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x1212, 0x550, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x1122, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x1212, 0x4114, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x1122, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x606, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x1122, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x1212, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x1212, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x606, 0x1122, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x1212, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x1122, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x1212, 0x5050, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x1212, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x1122, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x1122, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x1212, 0x5050, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x1212, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x1122, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x3030, 0x5050, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x3030, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x3030, 0x1414, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x3030, 0x5050, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x3030, 0x4444, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x3030, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x2112, 0x1144, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x1212, 0x4444, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x3030, 0x1414, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x3030, 0x5050, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x3030, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x1212, 0x4444, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x2112, 0x1144, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x2112, 0x1144, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x1212, 0x4444, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x3300, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x3300, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x3300, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x3300, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x2112, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x2112, 0x1414, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x2112, 0x5050, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x1122, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x1122, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2112, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2112, 0x1414, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x2112, 0x5050, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x1122, 0x0, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x330, 0x5050, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x330, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x330, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x330, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x330, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x330, 0x1144, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x2112, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x2112, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x2112, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3030, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x3030, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x2112, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x3030, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x1122, 0x550, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x3030, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x2112, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x2112, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x1212, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x1212, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x3300, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x2112, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x3300, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x3300, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x3300, 0x4114, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x1212, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x1212, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x1212, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x330, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x330, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x330, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x1212, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x330, 0x1144, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x3030, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x3030, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x1122, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x2112, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x3030, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x2112, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x2112, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x1122, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x1122, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x2112, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x3300, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x1212, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x3300, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x2112, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3300, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x3300, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x1212, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x3300, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x3300, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x1212, 0x4114, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x330, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x1122, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x330, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x330, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x330, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x1122, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x0, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x0, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x0, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x0, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x0, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x3300, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x2222, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x0, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x96, 0x0, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x1122, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x1122, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x330, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x0, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x330, 0x0, 0x0, 0x0, 0x0, 0x66, 0x0, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x2112, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x0, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x0, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x0, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x1122, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x1122, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x2112, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x2112, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x0, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x1122, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x1122, 0x0, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x1122, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x2222, 0x5500, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x2222, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x3300, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x3300, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x1122, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x1122, 0x0, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x330, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x2222, 0x5500, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x330, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x2112, 0x0, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x2112, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x2222, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x330, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x330, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x2112, 0x0, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x2112, 0x0, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x3300, 0x1414, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x3300, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x3300, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x2222, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x0, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x0, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x0, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x0, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x0, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x2112, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x1122, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x1122, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x1122, 0x0, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x330, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x2222, 0x5500, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x330, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x3300, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x1122, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x1122, 0x0, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x2222, 0x5500, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x2112, 0x0, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x3300, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x3300, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x3300, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x3300, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x330, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x330, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x2112, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x2112, 0x0, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x2112, 0x1414, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x0, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x906, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x2112, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x3030, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x2112, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x906, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x3300, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x3300, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x2222, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x906, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x1122, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x1122, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x1122, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x1122, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x1212, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x2222, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x330, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x330, 0x0, 0x0, 0x0, 0x0, 0x66, 0x906, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x2112, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x1122, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x1212, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x2222, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x2222, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x0, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x1212, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x0, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x0, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x2112, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x0, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x2222, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x2222, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x1122, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x1122, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x3030, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x3030, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x1212, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x2222, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x2112, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x1122, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x1122, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x2112, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x3300, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x2112, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x3300, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x1212, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x3300, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1122, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1122, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1212, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2222, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x330, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x330, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x2112, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x1122, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x1212, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x2222, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x2222, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x0, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x1212, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x0, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x1212, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x1212, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x3030, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x1212, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x330, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x330, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x330, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x330, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x2112, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x1212, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x1212, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x2112, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x0, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x2112, 0x0, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x330, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x330, 0x0, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x2112, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x2112, 0x0, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x3030, 0x1414, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x3030, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x3030, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x0, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x0, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x2112, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x2222, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x330, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x330, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x330, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x3030, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x1212, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x2222, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x1212, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x1212, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x2222, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x2222, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x2112, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x0, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x0, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x2112, 0x0, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x3030, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x3030, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x3030, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x2222, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x330, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x330, 0x0, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x2112, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x2112, 0x0, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x2222, 0x1414, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x2222, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x0, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x0, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x0, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x0, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x0, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x3030, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x1212, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x1212, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x2112, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x1122, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x1122, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x3300, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x330, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x330, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x2112, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x2112, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x0, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x3030, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x1212, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x2112, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x1122, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x1122, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x1122, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x330, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x0, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x2222, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x3030, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x1212, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x2222, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x3300, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x3300, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x3300, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x1122, 0x0, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x2222, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x2222, 0x5500, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x1122, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x3300, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3300, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x2222, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x1122, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x1122, 0x0, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x3030, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x2222, 0x5500, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x3030, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x3030, 0x4114, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x1122, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x1122, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x1122, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x0, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x0, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x3300, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x3300, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x3030, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3030, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x1212, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x2222, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x1212, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x1122, 0x0, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x3030, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x2222, 0x5500, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x3030, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x3300, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x2222, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x1122, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x1122, 0x0, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x2222, 0x5500, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x1122, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x0, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x1212, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x0, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x1212, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x0, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x606, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x2222, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x2222, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x1122, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x1122, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x3030, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x606, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x1212, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x2222, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x2112, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x1122, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x3300, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x3300, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x66, 0x606, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x3300, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x1122, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x1122, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x1212, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x1212, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x330, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x606, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x330, 0x1144, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x0, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x0, 0x550, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x906, 0x0, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x1122, 0x5500, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x0, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x2112, 0x550, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x0, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x0, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x906, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x3030, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x2112, 0x5500, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x3030, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x1122, 0x550, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x3030, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x3030, 0x4114, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x1122, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x1122, 0x4444, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x2112, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x2112, 0x1414, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x2222, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x2222, 0x1144, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x1212, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x1212, 0x4114, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x1122, 0x4444, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x2112, 0x1414, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x2222, 0x1144, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x1212, 0x4114, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x906, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x3300, 0x550, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x3300, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x3300, 0x4444, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x3300, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x2222, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x1212, 0x550, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x2112, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x2112, 0x4444, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x1122, 0x1414, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x1212, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x1212, 0x1144, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x2222, 0x4114, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x1122, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x2222, 0x4114, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x906, 0x330, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x330, 0x550, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x330, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x330, 0x4444, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x330, 0x1414, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x1212, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x2222, 0x550, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x1122, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x1122, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x1122, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x906, 0x2112, 0x4114, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x1122, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x1122, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x1122, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x906, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x2112, 0x4114, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x2112, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x906, 0x2112, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x2112, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x1122, 0x4114, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x906, 0x2112, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x2112, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x2112, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x1122, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x3300, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x3300, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x3300, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x3300, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x3300, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x3300, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x3300, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x3300, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x906, 0x2112, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x1122, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x1122, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x906, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x2112, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x1122, 0x4444, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x1122, 0x0, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x2112, 0x1414, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x330, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x330, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x330, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x330, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x330, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x330, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x330, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x330, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x96, 0x906, 0x2112, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x1122, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x1122, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x1122, 0x1414, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x330, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x906, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x1122, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x1122, 0x1414, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x1122, 0x5050, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x2112, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x2112, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x1122, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x0, 0x5500, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x2112, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x0, 0x550, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x2112, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x0, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x906, 0x0, 0x550, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x0, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x3030, 0x5500, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x1122, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x3030, 0x550, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x1122, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x906, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x3030, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x1122, 0x0, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x2112, 0x5050, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x2112, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x2222, 0x5500, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x2222, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x1212, 0x550, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x1212, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x3300, 0x0, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x3300, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x3300, 0x5050, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x3300, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x2222, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x96, 0x906, 0x3300, 0x5050, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x3300, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x1122, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x2112, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x2222, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x1212, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x2112, 0x0, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x1122, 0x5050, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x1212, 0x5500, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x2222, 0x550, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x330, 0x0, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x330, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x330, 0x5050, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x906, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x1122, 0x5050, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x1212, 0x5500, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x2222, 0x550, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x2222, 0x550, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x0, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x906, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x0, 0x550, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x0, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x1122, 0x5500, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x3030, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x2112, 0x550, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x3030, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x3030, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x906, 0x3030, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x2112, 0x5500, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x0, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x1122, 0x550, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x0, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x0, 0x4114, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x1122, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x2112, 0x4444, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x2112, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x1122, 0x1414, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x2222, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x1212, 0x1144, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x1212, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x2222, 0x4114, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x2112, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x2222, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x1212, 0x4114, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x906, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x3300, 0x550, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x330, 0x1414, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x330, 0x4444, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x330, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x2222, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x1212, 0x550, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x2112, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x1122, 0x4444, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x2112, 0x1414, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x2222, 0x1144, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x1212, 0x4114, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x2112, 0x4444, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x1122, 0x1414, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x1212, 0x1144, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x2222, 0x4114, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x330, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x906, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x330, 0x550, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x3300, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x3300, 0x4444, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x3300, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x1212, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x2222, 0x550, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x2112, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x906, 0x1122, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x1122, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x2112, 0x4114, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x906, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x1122, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x2112, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x2112, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x1122, 0x4114, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x2112, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x1122, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x2112, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x906, 0x1122, 0x4114, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x1122, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x906, 0x1122, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x2112, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x2112, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x330, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x330, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x330, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x330, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x330, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x330, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x330, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x330, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x96, 0x906, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x2112, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x1122, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x1122, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x906, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x1122, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x2112, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x1122, 0x0, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x1122, 0x1414, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x3300, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x3300, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x3300, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x3300, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x3300, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x3300, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x3300, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x2112, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x906, 0x1122, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x1122, 0x1414, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x1122, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x906, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x2112, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x2112, 0x1414, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x1122, 0x5050, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x1122, 0x4444, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x2112, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x2112, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x3030, 0x5500, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x1122, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x3030, 0x550, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x2112, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x906, 0x0, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x0, 0x550, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x0, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x1122, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x0, 0x5500, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x0, 0x550, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x1122, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x906, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x3030, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x2112, 0x0, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x1122, 0x5050, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x2112, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x1212, 0x5500, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x2222, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x2222, 0x550, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x1212, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x330, 0x0, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x330, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x330, 0x5050, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x330, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x2222, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x906, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x3300, 0x5050, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x1122, 0x0, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x2112, 0x5050, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x2222, 0x5500, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x1212, 0x550, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x1122, 0x0, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x2112, 0x5050, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x1122, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x2222, 0x5500, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x1212, 0x550, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x3300, 0x0, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x3300, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x3300, 0x5050, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x906, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x330, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x2112, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x1122, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x1212, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x2222, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x1212, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x2222, 0x4444, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x1212, 0x1414, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x1122, 0x1144, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x0, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x0, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x2222, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x1212, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x1122, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x2112, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x2112, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x1212, 0x4444, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x1212, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x2222, 0x1414, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x2112, 0x1144, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x1212, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x2222, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x2112, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x1122, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x2112, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x1122, 0x4444, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x2112, 0x1414, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x2222, 0x1144, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x1122, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x2112, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x2222, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x1212, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x2112, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x2112, 0x4444, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x1122, 0x1414, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x1212, 0x1144, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x330, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x330, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x2112, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x1122, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x1212, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0xf00, 0x2222, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0xf00, 0x2112, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x2222, 0x4444, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x1212, 0x1414, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x1122, 0x1144, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x906, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x0, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x2222, 0x0, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x1212, 0x5050, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x3300, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x2222, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x3300, 0x4114, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x2222, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x96, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x3030, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x1212, 0x0, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x2222, 0x5050, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x330, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x2222, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x330, 0x4114, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x1122, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x2222, 0x4444, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x2112, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x1212, 0x1414, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x2222, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x1122, 0x1144, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x1212, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x3300, 0x5050, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x3300, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x1122, 0x0, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x2112, 0x5050, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x0, 0x1414, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x1212, 0x4444, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x1122, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x2222, 0x1414, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x1212, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x2112, 0x1144, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x330, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x330, 0x0, 0x0, 0x0, 0x0, 0x96, 0x906, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x2112, 0x0, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x1122, 0x5050, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x3030, 0x1414, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x2222, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x906, 0x1212, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x2222, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x2222, 0x5500, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x2222, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x96, 0x906, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x1212, 0x5050, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x2222, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x2222, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x1212, 0x4114, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x906, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x1212, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x2222, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x1212, 0x5500, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x1212, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x906, 0x1212, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x1212, 0x0, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x1212, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x1212, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x2222, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x0, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x0, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x0, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x0, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x0, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x0, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x0, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x0, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x2222, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x1212, 0x4114, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x2222, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x906, 0x1212, 0x4114, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x2222, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x2222, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x1212, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x2222, 0x5500, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x3030, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x3030, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x3030, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x3030, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x3030, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x3030, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x3030, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x3030, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x1212, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x2222, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x1212, 0x1144, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x906, 0x1212, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x2222, 0x4114, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x1212, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x2222, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x906, 0x1212, 0x5500, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x1212, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x2222, 0x550, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x2222, 0x4444, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x1212, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x2222, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x1212, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x906, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x0, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x0, 0x1414, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x2222, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x1212, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x1122, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x2112, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x1212, 0x5050, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x1212, 0x4444, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x2222, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x1212, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x2222, 0x1414, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0x906, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x1212, 0x0, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x2222, 0x5050, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x2112, 0x5500, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x1122, 0x550, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x2222, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x2222, 0x0, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x1122, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x1212, 0x5050, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x2112, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x1122, 0x5500, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x2222, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x2112, 0x550, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x1212, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x2112, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x1122, 0x4444, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x2112, 0x1414, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x0, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x906, 0x3300, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x1212, 0x0, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x2222, 0x5050, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x2112, 0x5500, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x1122, 0x550, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x2112, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x1122, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x2112, 0x4444, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x1122, 0x1414, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x3030, 0x5050, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x330, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x906, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x330, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x2222, 0x4444, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x1212, 0x1414, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x1122, 0x1144, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x0, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x0, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x2222, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x2222, 0x1414, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x2112, 0x1144, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x1212, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x1122, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x1122, 0x4444, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x2112, 0x1414, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x2222, 0x1144, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x1212, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x1122, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x1212, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x2112, 0x4444, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x1122, 0x1414, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x1212, 0x1144, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x330, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x330, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x2222, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x1212, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0xf00, 0x2222, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0xf00, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x1212, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x96, 0x906, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x0, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x0, 0x1414, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x2222, 0x0, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x1212, 0x5050, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x330, 0x1144, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x1212, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x2222, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x330, 0x4114, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x1212, 0x4444, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x2222, 0x1414, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x2112, 0x1144, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x1212, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x906, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x3030, 0x5050, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x3030, 0x1414, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x3030, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x1212, 0x0, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x2222, 0x5050, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x3300, 0x1144, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x1212, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x3300, 0x4114, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x1122, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x1212, 0x4444, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x2222, 0x1414, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x2222, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x2112, 0x1144, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x1212, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x3300, 0x5050, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x3300, 0x1144, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x906, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x2112, 0x5050, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x3030, 0x1414, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x1122, 0x0, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x3030, 0x4444, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x2112, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x2222, 0x4444, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x1122, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x1212, 0x1414, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x1212, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x1122, 0x1144, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x2222, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x330, 0x1144, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x330, 0x0, 0x0, 0x0, 0x0, 0x96, 0x906, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x1122, 0x5050, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x0, 0x1414, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x2112, 0x0, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x0, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x906, 0x2222, 0x4444, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x1212, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x1212, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x1212, 0x5500, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x0, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x906, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x1212, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x1212, 0x5050, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x1212, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x1212, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x2222, 0x4114, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x1212, 0x4444, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x906, 0x2222, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x2222, 0x5500, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x2222, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x906, 0x2222, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x1212, 0x0, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x2222, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x2222, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x1212, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x3030, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x3030, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x3030, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x3030, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x3030, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x3030, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x3030, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x3030, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x2222, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x1212, 0x4114, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x96, 0x906, 0x2222, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x1212, 0x4114, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x2222, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x1212, 0x4444, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x2222, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x906, 0x2222, 0x5500, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x0, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x0, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x0, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x0, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x0, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x0, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x0, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x0, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x2222, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x1212, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x1212, 0x1144, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x1212, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x96, 0x906, 0x2222, 0x4114, 0x4444, 0x0, 0x0, 0x96, 0x906, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x2222, 0x4444, 0x4444, 0x0, 0xf00, 0x96, 0x906, 0x1212, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x1212, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x1212, 0x5500, 0x4444, 0x3030, 0x0, 0x96, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x906, 0x2222, 0x550, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x2222, 0x4444, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x1212, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x1212, 0x1414, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x2222, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x2222, 0x0, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x1212, 0x5050, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x1122, 0x5500, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x30c, 0x2112, 0x550, 0x5050, 0x0, 0x0, 0x3c, 0x30c, 0x2222, 0x0, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x1212, 0x4444, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x2222, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x1212, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x3030, 0x1414, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x3030, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x3030, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x1212, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x2222, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x2112, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x30c, 0x1122, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0x30c, 0x1212, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x1212, 0x0, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x2222, 0x5050, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x2112, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x2112, 0x5500, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x2222, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x30c, 0x1122, 0x550, 0x5050, 0x3030, 0xf00, 0x3c, 0x30c, 0x1212, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x2112, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x2112, 0x1414, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x3030, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x1122, 0x4444, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x3030, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x906, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x3300, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x2222, 0x0, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x1212, 0x5050, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x1122, 0x5500, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x30c, 0x2112, 0x550, 0x5050, 0x3030, 0x0, 0x3c, 0x30c, 0x2222, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x2112, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0x906, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x1122, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x1122, 0x1414, 0x5050, 0x3030, 0xf00, 0x96, 0x906, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x2112, 0x4444, 0x5050, 0x3030, 0x0, 0x96, 0x906, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x96, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x50a, 0x330, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0x906, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x50a, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x906, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x50a, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x906, 0x330, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x906, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x906, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x1122, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x0, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x1212, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x2222, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x1122, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x2112, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x2222, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x906, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x3300, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x330, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x330, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x2222, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x1212, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x2112, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x1122, 0x4444, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x2112, 0x1414, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x2222, 0x1144, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x2222, 0x4114, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x906, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x330, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x3300, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x3300, 0x4444, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x1212, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x2222, 0x550, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x2112, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x1122, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x2112, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x3030, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x3030, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x1122, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x3030, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x3030, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x3030, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x2112, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x2112, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x1212, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x3300, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x1212, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x1122, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x1122, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x3300, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x330, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x330, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x330, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x330, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x330, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x2112, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x2112, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x2112, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x2112, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x1212, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x330, 0x0, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x330, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x1212, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x3300, 0x1144, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x0, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x1122, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x0, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x0, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x1122, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x1122, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x1122, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x0, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x1122, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x1122, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x2222, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x2222, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x2112, 0x1414, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x3300, 0x1414, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x330, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x330, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x330, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x2222, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x330, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x2222, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x330, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x330, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x2222, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x0, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x0, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x0, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x0, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x0, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x1212, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x2222, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x0, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x0, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x330, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x2112, 0x1414, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x2222, 0x1144, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x0, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x0, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x330, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x3300, 0x4444, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x2222, 0x550, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x2112, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x1122, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x1122, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x0, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x0, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x0, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x0, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x1122, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x0, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x0, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x0, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x330, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x1122, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x330, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x1122, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x330, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x2222, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x330, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x2222, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x2112, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x2112, 0x1414, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x1122, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x1122, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x2222, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x330, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x3300, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x3300, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x1122, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x1122, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x2222, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x330, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x330, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x3300, 0x1414, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x3300, 0x1144, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x3030, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x1122, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x3030, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3030, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x1122, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x3030, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x2112, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x2112, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x1212, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x1212, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x330, 0x0, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x1122, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x330, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x1212, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x330, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x1212, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x2112, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x2112, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x1212, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x330, 0x0, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x330, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x2222, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x1212, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x0, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x0, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x3030, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x3030, 0x4114, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x2222, 0x4444, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x1212, 0x1414, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x1122, 0x1144, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x3030, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x1122, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x2112, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x2222, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x3300, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x1122, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x330, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x1122, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x2222, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x330, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x330, 0x4114, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2112, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1122, 0x4444, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2112, 0x1414, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2222, 0x1144, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x330, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x330, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x330, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x1212, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x2222, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x1212, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0x0, 0x66, 0x606, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x3030, 0x1144, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x2222, 0x4444, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x1212, 0x1414, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x1122, 0x1144, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x66, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x0, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x1212, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x3300, 0x1414, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0x606, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x1212, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x330, 0x0, 0x0, 0x0, 0x0, 0x66, 0x606, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x330, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x3300, 0x1414, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x2222, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x2222, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x2222, 0x5500, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x0, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x3030, 0x1144, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x2222, 0x4444, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x330, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x330, 0x5500, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x330, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x0, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x0, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x2112, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x0, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x2112, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x1212, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x1212, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x2112, 0x1414, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x2112, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x2222, 0x1144, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x330, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x2222, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x3030, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x3030, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x3030, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x1212, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x2112, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x1212, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x2112, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x1212, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x2112, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x330, 0x550, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x2222, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x3300, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x3300, 0x5500, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x3300, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x0, 0x550, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x3030, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x3030, 0x4114, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x2222, 0x4444, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x1212, 0x5500, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x0, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x1122, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x1122, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x2222, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x2222, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x1122, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x0, 0x550, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x3300, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x2222, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x2222, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x3300, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3300, 0x4444, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x0, 0x0, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x0, 0x550, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x3030, 0x1144, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x1212, 0x1414, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x1122, 0x1144, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x0, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x1212, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x330, 0x0, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x330, 0x550, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x0, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x0, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x3030, 0x4114, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x1212, 0x1414, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x1122, 0x1144, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x2222, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x330, 0x4114, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x2112, 0x1414, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x2222, 0x1144, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x330, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x2222, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x1212, 0x5500, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x0, 0x550, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3030, 0x4114, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x3300, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x3300, 0x5500, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x3300, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x3030, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x0, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x3030, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x1122, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x1122, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x2222, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x3030, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x2222, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x1122, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x1212, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x1122, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x3300, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x0, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x0, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x0, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x0, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x2222, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x2222, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x2222, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x3300, 0x4444, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x1212, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x2222, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x330, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x330, 0x5500, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x330, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x3030, 0x1144, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x2222, 0x5500, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x0, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x2112, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x2112, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x1212, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x1212, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x2112, 0x1414, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x2222, 0x1144, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x330, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x330, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x2112, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x0, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x2112, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x1212, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x330, 0x550, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x0, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x0, 0x550, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x0, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x0, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x1122, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x2112, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x1122, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x0, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x0, 0x5500, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x0, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x0, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x0, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x0, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1122, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x2112, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x2112, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x1122, 0x4114, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x330, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x330, 0x5050, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x330, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x330, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x330, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x1122, 0x4444, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x1122, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x2222, 0x1144, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x2222, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x3300, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x3300, 0x4114, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x2112, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x2222, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x2222, 0x4114, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x3300, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x3300, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x3300, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x3300, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x3300, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x3300, 0x4114, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x2112, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x2112, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x2222, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x2222, 0x4114, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x330, 0x5050, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x330, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x330, 0x550, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x1122, 0x5050, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x2222, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x2222, 0x550, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x2112, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x1122, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x1122, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x906, 0x2112, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x1122, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x2112, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x906, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x1122, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x1122, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x906, 0x2112, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x1122, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x906, 0x2112, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x1122, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x1122, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x330, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x330, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x330, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x906, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x2112, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x1122, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x906, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x2112, 0x4444, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x1122, 0x0, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x1122, 0x1414, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x3300, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x3300, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x3300, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x3300, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x3300, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x3300, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x3300, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0x906, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x2112, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x1122, 0x1414, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x330, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x330, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x906, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x2112, 0x1414, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x1122, 0x5050, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x1122, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x2112, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x2112, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x1122, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x2112, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x0, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x0, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x0, 0x550, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x0, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x0, 0x5500, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x0, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x0, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x0, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x0, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x0, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x2112, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1122, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x1122, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x330, 0x0, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x330, 0x0, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x330, 0x5500, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x330, 0x5500, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x2112, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x2112, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x2222, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x3300, 0x0, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x1122, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x1122, 0x0, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x2222, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x2222, 0x5500, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x3300, 0x0, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x3300, 0x0, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x3300, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x3300, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x3300, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x3300, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x3300, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1122, 0x0, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1122, 0x0, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x2222, 0x5500, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x2222, 0x5500, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x330, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x330, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x2112, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x2112, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x2222, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x2222, 0x550, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x0, 0x1122, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x0, 0x2112, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x0, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x2112, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x0, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x1122, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x0, 0x2112, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x0, 0x1122, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x0, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x1122, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x0, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x330, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x330, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x330, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x96, 0x0, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x0, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x1122, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x0, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x0, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x2112, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x1122, 0x0, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x1122, 0x1414, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x3300, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0x0, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x0, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x330, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x330, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x0, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x0, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x2112, 0x1414, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x1122, 0x5050, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x1122, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x2112, 0x0, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x2112, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x1122, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1122, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x2112, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x0, 0x550, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x0, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x0, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x0, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x0, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x0, 0x5500, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x0, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x0, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x0, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x0, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x2112, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x1122, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x330, 0x0, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x330, 0x1414, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x330, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x330, 0x5500, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x330, 0x4114, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x330, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x2112, 0x1414, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x2112, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x2222, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x3300, 0x1414, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x1122, 0x0, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1122, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x1122, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x2222, 0x5500, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x2222, 0x4114, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x3300, 0x0, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x3300, 0x1414, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x3300, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x3300, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x3300, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x3300, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x3300, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x1122, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x1122, 0x1414, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x2222, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x2222, 0x4114, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x330, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x330, 0x1414, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x330, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x330, 0x4114, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x2112, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x2112, 0x1414, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x2112, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x2222, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x2222, 0x1144, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x0, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x0, 0x550, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x0, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x0, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x1122, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x2112, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x2112, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1122, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x0, 0x5500, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x0, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x0, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x0, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x0, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x0, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x1122, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x2112, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x1122, 0x4114, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x330, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x330, 0x5050, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x330, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x330, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x330, 0x550, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1122, 0x5050, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x2222, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x2222, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x3300, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x3300, 0x4114, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x2112, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x2112, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x2222, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x2222, 0x4114, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x3300, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x3300, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x3300, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x3300, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x3300, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x3300, 0x4114, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x2112, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x2222, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x2222, 0x4114, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x330, 0x5050, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x330, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x330, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x1122, 0x4444, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x1122, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x2222, 0x1144, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x2222, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x2222, 0x4444, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x2222, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x2222, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x1122, 0x1144, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x1122, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x0, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x0, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x2222, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x2222, 0x0, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x1122, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x1122, 0x5500, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x0, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x0, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x0, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x0, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x0, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x0, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x2222, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x2222, 0x1414, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x1122, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x1122, 0x4114, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x1122, 0x4114, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x2222, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x2222, 0x4444, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x2222, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x1122, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x1122, 0x1144, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x1122, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x1122, 0x4444, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x1122, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x2222, 0x1144, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x1122, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x1122, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x2222, 0x5500, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x2222, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x1122, 0x0, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x3300, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x3300, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x3300, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x3300, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x3300, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x3300, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x3300, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x1122, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x2222, 0x4114, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x2222, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x1122, 0x1414, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x2222, 0x4114, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x1122, 0x4444, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x1122, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x1122, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x2222, 0x1144, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x2222, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x2222, 0x4444, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x2222, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x1122, 0x1144, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x0, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x2222, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x2222, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x2112, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x0, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x0, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x0, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x0, 0x0, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x0, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x0, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x0, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x2222, 0x0, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x2112, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x2222, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x2112, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x2222, 0x1414, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x2222, 0x5050, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x1122, 0x550, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x330, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x330, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x330, 0x5050, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x330, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x1122, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x1122, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x2112, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x3300, 0x0, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x3300, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x3300, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x3300, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x3300, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x3300, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x3300, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x1122, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1122, 0x0, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x2112, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x2112, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x1122, 0x1414, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x330, 0x5050, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x330, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x2222, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x2222, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x2222, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x2222, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x2222, 0x0, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x606, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x0, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x0, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x0, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x0, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x0, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x0, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x2222, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x2222, 0x1414, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x66, 0x606, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x2112, 0x1144, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x2222, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x2222, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x2222, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x606, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x330, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x330, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x330, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x2112, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x2222, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x66, 0x606, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x2222, 0x550, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x2112, 0x1414, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x2112, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x606, 0x2112, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x2222, 0x4114, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x606, 0x2112, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x2112, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x330, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x606, 0x2112, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x2222, 0x550, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x2112, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x2222, 0x550, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x2112, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x2222, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x2112, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x0, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x0, 0x1414, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x2222, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x1122, 0x5500, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x1122, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x2222, 0x0, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x0, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x0, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x0, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x0, 0x4444, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x0, 0x0, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x0, 0x1414, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x0, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x2222, 0x0, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1122, 0x5500, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1122, 0x5500, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x2222, 0x0, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x2222, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x2222, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x2112, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x330, 0x0, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x330, 0x5500, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x330, 0x5500, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x330, 0x0, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x2112, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x1122, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x2112, 0x1414, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x1122, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x3300, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x3300, 0x4114, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x3300, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x3300, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x3300, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x3300, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x3300, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x330, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x330, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x2112, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x2112, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x2112, 0x1414, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x2222, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x2222, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x0, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x2222, 0x0, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x0, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x0, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x0, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x2112, 0x1144, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x2222, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x2222, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x330, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x330, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x330, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x2222, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x2222, 0x550, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x2112, 0x1414, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x2112, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x2112, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x2222, 0x4114, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x2112, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x2112, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x330, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x330, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x2222, 0x550, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x2222, 0x550, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x2222, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x2222, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x2112, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x0, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x0, 0x1414, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x2222, 0x0, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x1122, 0x5500, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x2222, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x0, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x0, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x0, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x0, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x0, 0x5050, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x0, 0x1414, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x0, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x0, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x2222, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x1122, 0x4114, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x1122, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x2222, 0x1414, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x1122, 0x4114, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x2222, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x2112, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x330, 0x0, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x330, 0x4114, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x330, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x330, 0x5500, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x330, 0x1414, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x330, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x2112, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1122, 0x5050, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x2112, 0x1414, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x1122, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x3300, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x3300, 0x4114, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x3300, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x3300, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x3300, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x3300, 0x5500, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x3300, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x330, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x330, 0x4114, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x330, 0x1414, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x330, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x2112, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x1122, 0x5050, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x2112, 0x1414, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x2112, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x1122, 0x4444, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x2222, 0x4444, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x1122, 0x1144, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x1122, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x0, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x2222, 0x0, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x1122, 0x5500, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x0, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x0, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x0, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x2222, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x1122, 0x4114, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x1122, 0x4114, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x2222, 0x4444, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x1122, 0x1144, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x1122, 0x4444, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x2222, 0x1144, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x2222, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x2222, 0x5500, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x1122, 0x0, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x3300, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x2222, 0x4114, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x1122, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x2222, 0x4114, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x1122, 0x4444, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x2222, 0x1144, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x2222, 0x550, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x2222, 0x5050, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x2222, 0x0, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x2112, 0x550, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x2112, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x2222, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x2112, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x0, 0x0, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x0, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x0, 0x5050, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x0, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x0, 0x1414, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x0, 0x5050, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x0, 0x4444, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x0, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x2222, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x2112, 0x550, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x2222, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x2112, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x2222, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x2222, 0x4444, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x2222, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x1122, 0x1144, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x1122, 0x550, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x330, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x330, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x330, 0x5050, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x330, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1122, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1122, 0x1414, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x2112, 0x5050, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x3300, 0x0, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x3300, 0x550, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x3300, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x3300, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x3300, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x3300, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x1122, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x1122, 0x1414, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x2112, 0x5050, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x2112, 0x4444, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x1122, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x330, 0x5050, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x330, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x0, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x2112, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x0, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x2112, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x0, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x2112, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x0, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x0, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x1122, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x1122, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x2222, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x2222, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x1122, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x2222, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x330, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x3300, 0x4114, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x2112, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x3300, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x2112, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x2222, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x2112, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x2112, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x2222, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x2222, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x3300, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x330, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x330, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x330, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x330, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x2112, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x2112, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x1122, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x2112, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x2112, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x3030, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x3030, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x2112, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x3300, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x3300, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x1212, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x3300, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x3300, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x1122, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x1212, 0x4114, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x330, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x330, 0x550, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x1122, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x1122, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x1122, 0x0, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x1122, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x330, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x330, 0x4444, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x1122, 0x0, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x330, 0x4114, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x330, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x2112, 0x4444, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3300, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x1212, 0x1144, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x330, 0x0, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x330, 0x550, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x2112, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x2112, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x1212, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x3030, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x906, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x2112, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x0, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x906, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x330, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x330, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x2222, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x906, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x1122, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x2112, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x2222, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x1212, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x1122, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x2112, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x1122, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x2222, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x1212, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x3300, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x906, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x2112, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x2112, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x2222, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x0, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x0, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x0, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x0, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x0, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x330, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x2222, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x0, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x0, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x1122, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x3300, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x0, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x0, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x2112, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x2112, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x2222, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x3030, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x2112, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x1122, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x2112, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x3030, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x3030, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x1122, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x2112, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x2112, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x1212, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x1212, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x1212, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x330, 0x0, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x1212, 0x4114, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x330, 0x550, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x330, 0x550, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x330, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x1122, 0x0, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x330, 0x4114, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x1122, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x1122, 0x0, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x1212, 0x4114, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x2112, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x1212, 0x1144, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x330, 0x4114, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x330, 0x550, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x3300, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x2112, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x3300, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x0, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x0, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x1122, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x2112, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x2112, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x0, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x2112, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x0, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x1122, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x330, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x2222, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x330, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x2222, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x330, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x330, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x2222, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x330, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x3300, 0x4114, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x2112, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x2112, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x2112, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x2222, 0x4114, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x3300, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x3300, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x2112, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x2112, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x3300, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x2222, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x330, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x330, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x2222, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x2222, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x3030, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x0, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x0, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x2222, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x1212, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x1122, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x2112, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x0, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x1212, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x0, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x2112, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x2112, 0x1144, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x0, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x3030, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x3030, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x1122, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x330, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x330, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x2222, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x330, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x1122, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x2112, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x2222, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x1212, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1122, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2112, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1122, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2222, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1212, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x2112, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x2112, 0x4444, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x3300, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x1212, 0x1144, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x330, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x330, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x330, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x2222, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x3030, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x0, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x1212, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x2222, 0x0, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x3300, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x3300, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x3300, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x2222, 0x0, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x1212, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x1212, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x0, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x1122, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x0, 0x550, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x2222, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x2222, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x1122, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x0, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x1122, 0x0, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x1122, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x1212, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x1122, 0x0, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x1122, 0x4114, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x3300, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x3030, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x3030, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x2222, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x1212, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x2222, 0x0, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x1212, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x2222, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x2222, 0x0, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x330, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x330, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x330, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x330, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x0, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x2112, 0x1144, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x2112, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x0, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x0, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x1212, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x0, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x0, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x330, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x2222, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x2112, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x2222, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x2112, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x2222, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x2112, 0x4114, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x3030, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x2112, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x3030, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x2222, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x1212, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x2112, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x2112, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x1212, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x2222, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x0, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x0, 0x550, 0x0, 0x0, 0x0, 0x66, 0x606, 0x0, 0x550, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x2222, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x1212, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x1122, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x2112, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x1212, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x0, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x1122, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x0, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x0, 0x550, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x1122, 0x4114, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x606, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x1122, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x1212, 0x4114, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x330, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x330, 0x550, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x606, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x2112, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x3300, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x606, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x330, 0x4114, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x330, 0x550, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x2112, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x2112, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x2222, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x0, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x0, 0x550, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x0, 0x550, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x0, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x1122, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x0, 0x550, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x0, 0x550, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x330, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x1212, 0x4114, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x330, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x330, 0x550, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x3300, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x330, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x330, 0x550, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x2112, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x2112, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x2222, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x1212, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x2222, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x2222, 0x0, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x330, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x330, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x330, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x2222, 0x0, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x1212, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x0, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x2112, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x2112, 0x1144, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x0, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x2112, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x1212, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x1212, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x2112, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x2112, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x330, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x330, 0x5050, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x2222, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x1212, 0x4114, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x2112, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x3030, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x2112, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x3030, 0x4114, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x2222, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x2112, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x0, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x2112, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x0, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x1212, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x3030, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x0, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x0, 0x550, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x0, 0x550, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x2222, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x2222, 0x0, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x2222, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x1212, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x1212, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x2222, 0x0, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x3300, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x3300, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x1212, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x0, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x1122, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x0, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x0, 0x550, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x1122, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x3030, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x3030, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x2222, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x3030, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x1212, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x1122, 0x0, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x1122, 0x4114, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x1122, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x0, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x0, 0x4444, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x1122, 0x0, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x0, 0x4114, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x3300, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x2222, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x1122, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x3030, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x2222, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x2112, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x0, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x2112, 0x1144, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x2222, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x1122, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x1122, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x1212, 0x1144, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x330, 0x550, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x606, 0x0, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x0, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x0, 0x550, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x906, 0x0, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x1212, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x0, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x0, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x2112, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x0, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x0, 0x4114, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x1212, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x1212, 0x4444, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x2222, 0x1414, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x2112, 0x1144, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x1122, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x2222, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x606, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x3030, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x906, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x3030, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x3030, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x2222, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x3030, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x1122, 0x550, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x3300, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x906, 0x3300, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x606, 0x3300, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x2112, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x3300, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x3300, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x1212, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x3300, 0x4114, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x2112, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x2112, 0x4444, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x1122, 0x1414, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x1212, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x1212, 0x1144, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x2222, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x1122, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x2222, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x906, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x330, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x606, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x330, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x330, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x330, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x1122, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x330, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x2222, 0x550, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x606, 0x1212, 0x1414, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x906, 0x2112, 0x4114, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x606, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x1212, 0x1414, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x906, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x2112, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x3030, 0x0, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x3030, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x3030, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x3030, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x3030, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x3030, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x3030, 0x550, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x3030, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x0, 0x606, 0x1212, 0x4444, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x1212, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x906, 0x2112, 0x1144, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x606, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x1212, 0x4444, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x0, 0x906, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x2112, 0x1144, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x2112, 0x1144, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x2112, 0x5500, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x906, 0x2112, 0x1414, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x1212, 0x550, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x606, 0x1212, 0x4114, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x906, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x2112, 0x1414, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x606, 0x1212, 0x550, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x330, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x330, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x330, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x330, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x330, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x330, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x330, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x330, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x0, 0x906, 0x2112, 0x4444, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x1212, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x1212, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x606, 0x1212, 0x1144, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x330, 0x0, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x906, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x2112, 0x4444, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x1212, 0x1144, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x606, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x1212, 0x1144, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x2112, 0x4444, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x1212, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x0, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x1212, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x2112, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x0, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x0, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x2112, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x606, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x0, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x906, 0x0, 0x550, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x0, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x0, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x1212, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x2222, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x2112, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x1122, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x3030, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x3030, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x606, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x906, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x1212, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x2222, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x2112, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x1122, 0x550, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x1122, 0x550, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x2112, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x3300, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x2112, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x3300, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x1212, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x906, 0x3300, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x3300, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x606, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x2112, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x1122, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x1212, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x2222, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x330, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x330, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x906, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x606, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x1122, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x1212, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x2222, 0x550, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x2222, 0x550, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2222, 0x4444, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1212, 0x1414, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1122, 0x1144, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x550, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2222, 0x1414, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2112, 0x1144, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1122, 0x4444, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2112, 0x1414, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2222, 0x1144, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1212, 0x550, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2112, 0x4444, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1122, 0x1414, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1212, 0x1144, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x0, 0x330, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x0, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x0, 0x0, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x0, 0x330, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x0, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x0, 0x330, 0x550, 0x0, 0x0, 0x0, 0x0, 0x0, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1212, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2222, 0x550, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x1212, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x606, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x906, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x0, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x2222, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x3030, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x2222, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x1122, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x3030, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x3030, 0x4114, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x1212, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x2222, 0x4444, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x2222, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x1212, 0x1414, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x2112, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x1122, 0x1144, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x1122, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x3030, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x0, 0x606, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x3030, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x906, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x1212, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x2112, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x2112, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x2222, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x0, 0x906, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x3300, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x606, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x1122, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x330, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x1122, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x2222, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x330, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x330, 0x4114, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x2112, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x1122, 0x4444, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x2112, 0x1414, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x2222, 0x1144, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x330, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x330, 0x0, 0x0, 0x0, 0x0, 0x0, 0x906, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x330, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x330, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x606, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x2112, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x1212, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x3300, 0x1144, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x606, 0x2222, 0x4444, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x906, 0x1122, 0x1144, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x0, 0x550, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x606, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x2222, 0x0, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x906, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x1122, 0x5500, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x1122, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x1122, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x0, 0x0, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x0, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x0, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x0, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x0, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x0, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x0, 0x550, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x0, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x2222, 0x1414, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x0, 0x606, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x1122, 0x4114, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x906, 0x1122, 0x4114, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x2222, 0x4444, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x606, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x1122, 0x1144, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x906, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x906, 0x1122, 0x4444, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x606, 0x2222, 0x1144, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x906, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x2222, 0x5500, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x606, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x1122, 0x0, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x3300, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x3300, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x3300, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x3300, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x3300, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x3300, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x3300, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x2222, 0x4114, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x906, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x1122, 0x1414, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x0, 0x606, 0x2222, 0x4114, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x1122, 0x4444, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x906, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x2222, 0x1144, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x606, 0x2222, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x2222, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x3030, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x1122, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x0, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x906, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x2222, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x1212, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x1122, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x2112, 0x550, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x2222, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x1212, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x2222, 0x0, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x1122, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x2112, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x1212, 0x4444, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x0, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x2112, 0x1144, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x0, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x606, 0x3030, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x906, 0x3030, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x330, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x330, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x2222, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x330, 0x550, 0x0, 0x0, 0x0, 0x0, 0x906, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x0, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x1122, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x2112, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x2222, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x1212, 0x550, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x1122, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x2112, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x1122, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x2222, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x1212, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x2112, 0x4444, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x3300, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x1212, 0x1144, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x906, 0x330, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x330, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x606, 0x330, 0x550, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x906, 0x0, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x0, 0x550, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x606, 0x0, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x1212, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x3300, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x2112, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x3300, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x3300, 0x4114, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x1212, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x2112, 0x4444, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x1122, 0x1414, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x2112, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x1212, 0x1144, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x2222, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x2222, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x906, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x3030, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x606, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x3030, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x330, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x2222, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x330, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x1122, 0x550, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x3300, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x606, 0x3300, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x906, 0x3300, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x2112, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x0, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x0, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x1212, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x0, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x0, 0x4114, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x1212, 0x4444, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x1122, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x2222, 0x1414, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x1212, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x2112, 0x1144, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x1122, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x2222, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x606, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x330, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x906, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x330, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x3030, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x1122, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x3030, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x2222, 0x550, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x906, 0x1212, 0x1414, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x1212, 0x550, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x606, 0x2112, 0x4114, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x906, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x2112, 0x1414, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x606, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x330, 0x0, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x330, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x330, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x330, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x330, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x330, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x330, 0x550, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x330, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x0, 0x906, 0x1212, 0x4444, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x1212, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x606, 0x2112, 0x1144, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x1212, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x906, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x2112, 0x4444, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x2112, 0x4444, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x0, 0x606, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x1212, 0x1144, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x1212, 0x1144, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x2112, 0x5500, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x606, 0x2112, 0x1414, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x906, 0x1212, 0x4114, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x606, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x1212, 0x1414, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x906, 0x1212, 0x550, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x2112, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x3030, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x3030, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x3030, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x3030, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x3030, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x3030, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x3030, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x3030, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x0, 0x606, 0x2112, 0x4444, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x1212, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x906, 0x1212, 0x1144, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x330, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x606, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x1212, 0x4444, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x2112, 0x1144, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x906, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x2112, 0x1144, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x2112, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x3300, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x1212, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x1212, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x3300, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x2112, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x906, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x0, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x0, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x606, 0x0, 0x550, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x0, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x2112, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x1122, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x1212, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x2222, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x330, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x330, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x906, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x606, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x1212, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x2222, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x2112, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x1122, 0x550, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x2222, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x0, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x0, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x2112, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x2112, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x0, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x1212, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x606, 0x3300, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x3300, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x906, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x1212, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x2222, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x2112, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x1122, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x3030, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x3030, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x606, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x906, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x1122, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x1212, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x2222, 0x550, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x2222, 0x4444, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x1212, 0x1414, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x1122, 0x1144, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x0, 0x550, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x2222, 0x1414, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x2112, 0x1144, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x1122, 0x4444, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x2112, 0x1414, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x2222, 0x1144, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x1212, 0x550, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x2112, 0x4444, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x1122, 0x1414, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x1212, 0x1144, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x330, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x330, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x330, 0x550, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x1212, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x2222, 0x550, 0x4444, 0x0, 0x0, 0x0, 0xf00, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x1212, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x906, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x0, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x606, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x2222, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x330, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x1122, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x330, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x2222, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x330, 0x4114, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x1122, 0x4444, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x2112, 0x1414, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x2112, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x2222, 0x1144, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x3030, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x906, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x3030, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x0, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x2112, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x1212, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x2112, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x2222, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x0, 0x606, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x906, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x3300, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x1122, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x3030, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x2222, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x3030, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x1122, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x3030, 0x4114, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x2112, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x2222, 0x4444, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x1122, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x1212, 0x1414, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x1212, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x1122, 0x1144, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x2222, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x330, 0x4114, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x330, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x606, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x330, 0x1414, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x330, 0x0, 0x0, 0x0, 0x0, 0x0, 0x906, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x1212, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x2112, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x0, 0x4444, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x906, 0x2222, 0x4444, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x606, 0x1122, 0x1144, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x0, 0x550, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x906, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x2222, 0x0, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x606, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x1122, 0x5500, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x3300, 0x0, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x3300, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x3300, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x3300, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x3300, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x3300, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x3300, 0x550, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x2222, 0x1414, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x0, 0x906, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x1122, 0x4114, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x606, 0x1122, 0x4114, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x1122, 0x4444, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x906, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x2222, 0x1144, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x606, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x606, 0x1122, 0x4444, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x906, 0x2222, 0x1144, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x0, 0x606, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x2222, 0x5500, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x1122, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x0, 0x906, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x1122, 0x0, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x1122, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x0, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x0, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x0, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x0, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x0, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x0, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x0, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x0, 0x4114, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x2222, 0x4114, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x606, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x1122, 0x1414, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x0, 0x906, 0x2222, 0x4114, 0x4444, 0x0, 0x0, 0x0, 0x906, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x2222, 0x4444, 0x4444, 0x3030, 0x0, 0x0, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x606, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x0, 0x606, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x1122, 0x1144, 0x4444, 0x3030, 0x0, 0x0, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x906, 0x2222, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x1122, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x330, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x2222, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0x0, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x606, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x2222, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x1212, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x1122, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x0, 0x30c, 0x2112, 0x550, 0x5050, 0x0, 0x0, 0x0, 0x30c, 0x2222, 0x0, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x1122, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x2112, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x2222, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0xc0c, 0x1212, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0xc0c, 0x1122, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x2112, 0x1144, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x3300, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x1212, 0x4444, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x3300, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x906, 0x3030, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x606, 0x3030, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x3030, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x2222, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x0, 0x606, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x0, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x1122, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x2112, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x2222, 0x5500, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xc0c, 0x1212, 0x550, 0x5050, 0x0, 0x0, 0x0, 0xc0c, 0x1122, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x2222, 0x0, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x1212, 0x5050, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x1122, 0x5500, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x0, 0x30c, 0x2112, 0x550, 0x5050, 0x3030, 0x0, 0x0, 0x30c, 0x2222, 0x0, 0x0, 0x3030, 0x0, 0x0, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x1212, 0x1144, 0x5050, 0x3030, 0x0, 0x0, 0x606, 0x0, 0x5500, 0x0, 0x3030, 0x0, 0x0, 0x606, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x2112, 0x4444, 0x5050, 0x3030, 0x0, 0x0, 0x906, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0x0, 0x50a, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x0, 0xa0a, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x0, 0x606, 0x330, 0x5050, 0x5050, 0x0, 0x0, 0x0, 0x606, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x0, 0xa0a, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x0, 0x50a, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x0, 0x906, 0x330, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x0, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x0, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x2112, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x1212, 0x1144, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x1122, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x1122, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x3300, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x1212, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x0, 0x4114, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x2222, 0x1414, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x2112, 0x1144, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x330, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x330, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x2222, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x2222, 0x550, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x3300, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x2112, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x3030, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x3030, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x2112, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x3030, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x1212, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x1122, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x1212, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x1212, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x330, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x3300, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x3300, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x1212, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x3300, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x2112, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x3300, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x1212, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x330, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x330, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x1212, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x330, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x1122, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x2112, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x2112, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x2112, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x1122, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x330, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x330, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x3030, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x0, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x0, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x0, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x0, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x0, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x1212, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x2222, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x1212, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x2112, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x330, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x1212, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x2112, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x2112, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x0, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x2112, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x1212, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x2222, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x1212, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x66, 0x0, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x0, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x3300, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x3300, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x96, 0x0, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x330, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x1212, 0x1414, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x1122, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x3300, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0x0, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x0, 0x1414, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x2222, 0x1414, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x2112, 0x1144, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x330, 0x0, 0x0, 0x0, 0x0, 0x96, 0x0, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x0, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x66, 0x606, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x3300, 0x1414, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x1212, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x2112, 0x4444, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x1122, 0x1414, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x2112, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x1212, 0x1144, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x66, 0x606, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x330, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x1212, 0x1414, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x1122, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x1212, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x0, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x2112, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x1122, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x330, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x330, 0x550, 0x0, 0x0, 0x0, 0x66, 0x606, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x2222, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x1122, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x1122, 0x550, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x3300, 0x1414, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x0, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x2112, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x0, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x2112, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x0, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x2222, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x2112, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x2222, 0x1414, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x330, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x2222, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x330, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x2222, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x330, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x1122, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x330, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x0, 0x1414, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x3300, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x2112, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x3300, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x2112, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x1122, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x2112, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x1122, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x330, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x330, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x2222, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x3030, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x1122, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x3030, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3300, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x1212, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x2222, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x1212, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x1212, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x1212, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x2222, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x2222, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x1122, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x2222, 0x550, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x3300, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x1212, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x0, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x1212, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x1212, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x1212, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x1122, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x1212, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x2222, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x1212, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x2222, 0x4114, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x2222, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x0, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x0, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x3300, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x3300, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x3300, 0x4114, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x1212, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x2112, 0x4444, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x1122, 0x1414, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x2112, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x1212, 0x1144, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x2222, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x1212, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x2222, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x1212, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x2112, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x1122, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x3030, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x3030, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x330, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x2222, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x330, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x1122, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x3300, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x3300, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x2112, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x1212, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x0, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x0, 0x4114, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2112, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2222, 0x1414, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1212, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2112, 0x1144, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1122, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x2112, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x1122, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x2222, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x330, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x330, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x330, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x1122, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x3030, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x2222, 0x550, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x2112, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x0, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x330, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x1212, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x330, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x2222, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x1212, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x330, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x2112, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x2112, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x2222, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x330, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x0, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x0, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x1212, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x0, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x0, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x2112, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x1212, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x0, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x0, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x3030, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x2112, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x3030, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x3030, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x1212, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x1212, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x2222, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x2222, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x1212, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x330, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x3030, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x3300, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x3300, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x2112, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x3300, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x2112, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x2112, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x1212, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x330, 0x550, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x1212, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x330, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x2112, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x1212, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x1212, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x1212, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x1212, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x1122, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x2112, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x2112, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x330, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x0, 0x0, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x0, 0x550, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x3300, 0x1414, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x1212, 0x1144, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x330, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x1212, 0x1414, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x1122, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x330, 0x0, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x330, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x330, 0x550, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x66, 0x906, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x3300, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x3300, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x1212, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x2222, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x1212, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x2112, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x906, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x330, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x1212, 0x1414, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x1122, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x3300, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0x906, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x2112, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x0, 0x1414, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x2112, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x2222, 0x1414, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x1212, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x2112, 0x1144, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x906, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x2222, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x1122, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x2222, 0x550, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x3300, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x3300, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x1212, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x3300, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x2222, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x3300, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x1212, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x1212, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x1122, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x1212, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x1122, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x3030, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x2222, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x3030, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x3030, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x1122, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x3030, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x3300, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x0, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x0, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x1212, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x0, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x0, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x1212, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x0, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x1122, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x2222, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x1212, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x2222, 0x4114, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x1212, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x2222, 0x4114, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x1122, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3030, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x2222, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x330, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x1122, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x330, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x3300, 0x1414, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x2112, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x2112, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x2112, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x2112, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x2222, 0x1414, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x2222, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x1122, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x2222, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x1122, 0x550, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x2112, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x0, 0x1414, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x2112, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x2112, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x2112, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x330, 0x550, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x0, 0x1414, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x0, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x0, 0x550, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x0, 0x4114, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x1212, 0x5050, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x2112, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x2112, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x2112, 0x550, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1212, 0x4114, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x330, 0x4444, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x330, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x330, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x330, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x330, 0x5500, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x330, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x330, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x2222, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1212, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x2222, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x3030, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x3030, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x3030, 0x4114, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x2222, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x2112, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x2222, 0x4114, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x0, 0x5050, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x0, 0x1414, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x0, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x0, 0x550, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x0, 0x4114, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x1212, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x2112, 0x1414, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x2112, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x1212, 0x4114, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x3030, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x3030, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x3030, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x3030, 0x5500, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x3030, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x3030, 0x4114, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x2112, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x2222, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x2112, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x2222, 0x4114, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x330, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x330, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x1212, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x2222, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x1212, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x2222, 0x550, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x1212, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x2112, 0x4114, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x330, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x330, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x330, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x2112, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x1212, 0x4444, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x2112, 0x1144, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x1212, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x2112, 0x4444, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x2112, 0x4444, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x1212, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x1212, 0x1144, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x1212, 0x1144, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x2112, 0x5500, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x1212, 0x4114, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x1212, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x3030, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x1212, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x2112, 0x4444, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x1212, 0x1144, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x330, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x330, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x1212, 0x4444, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x2112, 0x1144, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x2112, 0x1144, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x2112, 0x5050, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x1212, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1212, 0x550, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x2112, 0x4114, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x0, 0x1414, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x0, 0x550, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x0, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x330, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x330, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x330, 0x5050, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x330, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x330, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x330, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x2112, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x2222, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x2222, 0x550, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x1212, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x2222, 0x5050, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x2222, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1212, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1212, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x2222, 0x4114, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x0, 0x5050, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x0, 0x1414, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x0, 0x550, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x0, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x0, 0x4114, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x2112, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x1212, 0x1414, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x1212, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x3030, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x3030, 0x0, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x3030, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x3030, 0x550, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x1212, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x2222, 0x5050, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x2222, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x2112, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x2222, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x2112, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x2222, 0x550, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x2222, 0x550, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x0, 0x2222, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x0, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x2222, 0x5500, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x1212, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x0, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x96, 0x0, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x1212, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x2222, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x1212, 0x4114, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x0, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x0, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x1212, 0x5500, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x0, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x0, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x1212, 0x0, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x1212, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x0, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x0, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x0, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x1212, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x66, 0x0, 0x2222, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x0, 0x1212, 0x4114, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x2222, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x0, 0x2222, 0x5500, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x0, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x3030, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x1212, 0x1144, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x0, 0x1212, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x66, 0x0, 0x2222, 0x4114, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x0, 0x1212, 0x5500, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x0, 0x2222, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x1212, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x2222, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x0, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x0, 0x5500, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x2222, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x2112, 0x1414, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x2112, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x2112, 0x550, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x2222, 0x1144, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x330, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x330, 0x4444, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x330, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x330, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x330, 0x5500, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x330, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x3030, 0x1414, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x1212, 0x0, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x2112, 0x5500, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x0, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x0, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x0, 0x0, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x0, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x0, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x0, 0x5500, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x2222, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x2112, 0x1414, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x2112, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x2112, 0x550, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x2222, 0x1144, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x2222, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x1212, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x2222, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x3030, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x3030, 0x1414, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x3030, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x3030, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x3030, 0x550, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x2112, 0x4444, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x1212, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x1212, 0x1144, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x2112, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x330, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x330, 0x550, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x606, 0x2222, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x2112, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x2222, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x0, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x606, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x2222, 0x0, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x2112, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x2112, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x330, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x330, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x330, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x330, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x330, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x330, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x330, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x330, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x2222, 0x1414, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x66, 0x606, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x2222, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x2112, 0x1144, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x2222, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x2112, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x606, 0x2222, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x2112, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x0, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x0, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x0, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x2222, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x66, 0x606, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x2112, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x2112, 0x1414, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x2222, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x2112, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x606, 0x2222, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x2112, 0x4114, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x2112, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x2222, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x2222, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x2112, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x2222, 0x550, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x606, 0x2222, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x2112, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x2112, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x2222, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x2222, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x1212, 0x5050, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x2222, 0x0, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x2222, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x330, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x330, 0x5050, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x330, 0x0, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x330, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x330, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x330, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x1212, 0x4444, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x2112, 0x1144, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1212, 0x5500, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x3030, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x3030, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x0, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x0, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x0, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x0, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x0, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x0, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x2222, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x1212, 0x5050, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x2222, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x2222, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x1212, 0x4114, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x2222, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x2112, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x2222, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x2112, 0x4114, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x3030, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x3030, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x3030, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x3030, 0x5500, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x3030, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x330, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x1212, 0x4444, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x1212, 0x4444, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x2112, 0x1144, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x2112, 0x1144, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x1212, 0x5500, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x2112, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x1212, 0x1414, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x1212, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x2112, 0x4114, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x1212, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x2112, 0x1414, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x2112, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x330, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x330, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x330, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x330, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x330, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x330, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x330, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x330, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x1212, 0x4444, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x2112, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x1212, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x2112, 0x1144, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x1212, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x2112, 0x4444, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x2112, 0x4444, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x1212, 0x1144, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x1212, 0x1144, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x2112, 0x5500, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x1212, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x2112, 0x1414, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x2112, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x1212, 0x4114, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x2112, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x1212, 0x1414, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x1212, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x3030, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x3030, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x3030, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x3030, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x3030, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x3030, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x3030, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x2112, 0x4444, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x2112, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x1212, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x1212, 0x1144, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x1212, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x330, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x330, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x1212, 0x4444, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x2112, 0x1144, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x2112, 0x1144, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x1212, 0x4444, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x2112, 0x0, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x2112, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x1212, 0x1414, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x1212, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x2112, 0x4114, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x0, 0x1414, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x0, 0x550, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x330, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x330, 0x5050, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x330, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x330, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x330, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x330, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x2112, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x2222, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x2222, 0x550, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x1212, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x2222, 0x5050, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x2222, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x2222, 0x4114, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x0, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x0, 0x5050, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x0, 0x1414, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x0, 0x550, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x0, 0x4114, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x2112, 0x5050, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1212, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x1212, 0x550, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x3030, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x3030, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x3030, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x3030, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x3030, 0x550, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x3030, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1212, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x2222, 0x5050, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x2222, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x1212, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x330, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x330, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x2112, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x2222, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x2222, 0x550, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x2222, 0x1414, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x0, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x0, 0x1414, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x0, 0x550, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x0, 0x4114, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x1212, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x2112, 0x1414, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x2112, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x1212, 0x4114, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x330, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x330, 0x4444, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x330, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x330, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x330, 0x5500, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x330, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x330, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x1212, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x2222, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x1212, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x2222, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x3030, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x3030, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x3030, 0x4114, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x2112, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x2222, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x2112, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x2222, 0x4114, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x0, 0x5050, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x0, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x0, 0x1414, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x0, 0x550, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x0, 0x4114, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1212, 0x5050, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x2112, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x2112, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x2112, 0x550, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x1212, 0x4114, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x3030, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x3030, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x3030, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x3030, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x3030, 0x5500, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x3030, 0x4114, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x2222, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x2112, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x2222, 0x4114, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x330, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x330, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x2222, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x1212, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x2222, 0x550, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x2222, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x2112, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x0, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x0, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x2222, 0x0, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x330, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x330, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x330, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x2222, 0x550, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x2112, 0x1144, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x2112, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x2222, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x0, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x0, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x0, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x2222, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x2112, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x2112, 0x1414, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x2222, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x2112, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x2112, 0x4114, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x2112, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x2222, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x330, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x330, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x330, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x2222, 0x550, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x2222, 0x550, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x2222, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x2112, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x2222, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x0, 0x5500, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x0, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x0, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x2222, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x1212, 0x5050, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x2222, 0x1144, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x2222, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x330, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x330, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x330, 0x5050, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x330, 0x1144, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x330, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x330, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x1212, 0x4444, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x1212, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x2112, 0x1144, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x2112, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x3030, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x3030, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x0, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x0, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x0, 0x5500, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x0, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x0, 0x0, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x0, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x2222, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1212, 0x5050, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x2222, 0x1144, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x2222, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x1212, 0x4114, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x2112, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x2222, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x2112, 0x4114, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x3030, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x3030, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x3030, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x3030, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x3030, 0x5500, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x330, 0x1144, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x330, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x1212, 0x5500, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x2112, 0x0, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x906, 0x2222, 0x4444, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x2222, 0x5500, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x1212, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x0, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x906, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x1212, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x1212, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x2222, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x1212, 0x4114, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x1212, 0x4444, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x906, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x1212, 0x5500, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x906, 0x2222, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x1212, 0x0, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x1212, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x0, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x0, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x0, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x1212, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x1212, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x66, 0x906, 0x2222, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x1212, 0x4114, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x2222, 0x4444, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x906, 0x2222, 0x5500, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x3030, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x3030, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x3030, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x3030, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x3030, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x3030, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x3030, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x2222, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x1212, 0x1144, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x1212, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x66, 0x906, 0x2222, 0x4114, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x1212, 0x4444, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x1212, 0x5500, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x906, 0x2222, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x2222, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x1212, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x2222, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x2222, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x2112, 0x550, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x2112, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x2112, 0x550, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x2222, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x330, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x330, 0x4444, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x330, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x330, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x330, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x330, 0x5500, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x3030, 0x550, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x2112, 0x4444, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x1212, 0x1144, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x1212, 0x1144, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x2112, 0x4444, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x0, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x0, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x0, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x0, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x0, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x0, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x2222, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x2112, 0x550, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x2112, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x2112, 0x550, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x2222, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1212, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x2222, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x3030, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x3030, 0x550, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x3030, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x3030, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x3030, 0x550, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x3030, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x1212, 0x1144, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x2112, 0x4444, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x1212, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x330, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x330, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x0, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x0, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x0, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x0, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x0, 0x4114, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x1212, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x1212, 0x5500, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x2222, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x1212, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x330, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x3030, 0x4114, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x3030, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x2112, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x2222, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x3030, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x2112, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x2112, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x1212, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x1212, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x0, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x2112, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x0, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x1212, 0x4114, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x2112, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x2112, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x2222, 0x4114, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x2112, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x2222, 0x4114, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x330, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x2222, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x330, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x1212, 0x5500, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x3300, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3300, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x2112, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x3030, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x3030, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x3030, 0x4444, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x2112, 0x0, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x3030, 0x1414, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x330, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x1212, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x1122, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x330, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x1212, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x1122, 0x4114, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x1122, 0x550, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x1122, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x2112, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x3300, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x1212, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x3300, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x3300, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x330, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x330, 0x4114, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x1122, 0x550, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x330, 0x4444, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x330, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x330, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x330, 0x0, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x2112, 0x0, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x1122, 0x1414, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x3300, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x0, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x0, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x330, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x330, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x1212, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x1122, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x2112, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x1212, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x1122, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x0, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x0, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x0, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x3030, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x2112, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x2222, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x2112, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x66, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x2112, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x2222, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0x0, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x0, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x1212, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x2112, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x1122, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x2112, 0x1414, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x0, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x0, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x0, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x0, 0x330, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x2222, 0x4444, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x0, 0x4114, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x0, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x1122, 0x5500, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x3030, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x2222, 0x0, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x3030, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x3030, 0x4114, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x2222, 0x4444, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x1212, 0x5500, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x0, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x0, 0x4114, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x1122, 0x550, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x1122, 0x5500, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x2222, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x2222, 0x0, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x1122, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x1212, 0x4114, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x0, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x0, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x0, 0x550, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x1212, 0x4114, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x1122, 0x550, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x3030, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x2222, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x3300, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x1212, 0x5500, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x2222, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x3300, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x1122, 0x5500, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x1122, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x2222, 0x0, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x0, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x0, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x0, 0x4444, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x2112, 0x0, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x0, 0x1414, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x1122, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x330, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x330, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x1122, 0x4114, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x2222, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x2112, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x2222, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x1122, 0x5500, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x330, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x2222, 0x0, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x330, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x2112, 0x1414, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x3300, 0x4114, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x3300, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x3300, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x1122, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x2112, 0x0, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x2222, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x3300, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x0, 0x4114, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x0, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x2112, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x2222, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x1122, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x1212, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x2222, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x1122, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x330, 0x0, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x1212, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x1122, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x330, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x1122, 0x4114, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x606, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x1122, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x1212, 0x4114, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x0, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x0, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x606, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x3300, 0x4114, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x2112, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x2112, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x330, 0x0, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x330, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x330, 0x0, 0x0, 0x0, 0x0, 0x66, 0x606, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x2112, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x1122, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x1212, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x2222, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x1122, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x3300, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x1212, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x3300, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x2112, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x0, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x1122, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x1212, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x2222, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x1122, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x330, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x330, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x1212, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x2222, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x2112, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x1122, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x2222, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x0, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x0, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x2112, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x2112, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x0, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x1212, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x3300, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2222, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1122, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1122, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2222, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x3030, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x3030, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x2112, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x1122, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x1212, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x2222, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x1122, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x3300, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x1212, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x2112, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x3300, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x2112, 0x4444, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x2112, 0x0, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x1122, 0x5050, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x330, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x1122, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x330, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x330, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x1122, 0x550, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x330, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x2112, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x1212, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x1212, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x2112, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x1212, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x1122, 0x4114, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x1122, 0x550, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x2112, 0x4444, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x330, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x330, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x330, 0x0, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x3030, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x2112, 0x0, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x1122, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x0, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x0, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x1212, 0x4114, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x330, 0x4444, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x330, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x1212, 0x5500, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x330, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x330, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x2112, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x2112, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x2222, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x2222, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x2112, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x0, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x1212, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x0, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x0, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x2112, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x0, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x1212, 0x4114, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x3030, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x3030, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x3030, 0x4114, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x2112, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x2222, 0x4114, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x330, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x1212, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x2222, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x1212, 0x5500, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x3300, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x0, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x0, 0x0, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x2112, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x2222, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x330, 0x0, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x1122, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x330, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x1212, 0x4114, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x0, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x0, 0x0, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x330, 0x0, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x330, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x330, 0x0, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x2112, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x2222, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x3300, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x1122, 0x5500, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x330, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x2222, 0x0, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x330, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x330, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x2112, 0x0, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x2112, 0x1414, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x330, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x330, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x3300, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x2112, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x2222, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x1122, 0x5500, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x1122, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x2222, 0x0, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x2222, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x2112, 0x1414, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x2222, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x0, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x2112, 0x0, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x0, 0x4114, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x0, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x0, 0x550, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x1122, 0x5500, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x2222, 0x0, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x2222, 0x4114, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x3300, 0x4444, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x3300, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x3300, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x1212, 0x5500, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x1122, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x1122, 0x550, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x1122, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x1122, 0x5500, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x3030, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x2222, 0x0, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x3030, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x1122, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x1212, 0x4114, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x0, 0x550, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x0, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x3300, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x0, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x0, 0x4114, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x1122, 0x550, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x0, 0x4444, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3030, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x3030, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x2222, 0x4114, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x2222, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x1212, 0x5500, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x2222, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x2222, 0x4444, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x66, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x2112, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x2222, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x1212, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x1212, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x2222, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x2112, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x1122, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x2112, 0x1414, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x906, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x3300, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x2222, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x1122, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x1122, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x2222, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x2112, 0x4444, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x3030, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x906, 0x330, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x606, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x0, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x1212, 0x5050, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x0, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x1122, 0x5500, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x0, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x0, 0x1144, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x1212, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x1212, 0x4444, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x2222, 0x1414, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x2112, 0x1144, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x1122, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x2222, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x2112, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x606, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x3030, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x3030, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x3030, 0x4114, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x3030, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x2222, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x2112, 0x5500, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x3030, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x3030, 0x4114, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1122, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1122, 0x4444, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2112, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2112, 0x1414, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2222, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2222, 0x1144, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1212, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1212, 0x4114, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x1122, 0x4444, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x2112, 0x1414, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x2222, 0x1144, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x1212, 0x4114, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x3300, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x606, 0x3300, 0x4114, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x3300, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x2112, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x2222, 0x5500, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x3300, 0x4114, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x606, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x1122, 0x5050, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x330, 0x1414, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x1212, 0x5500, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x330, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x330, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x606, 0x1212, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x1122, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x1122, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x1122, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x606, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x1212, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x1122, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x1122, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x1122, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x3030, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x3030, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x3030, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x3030, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x3030, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x3030, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x3030, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x3030, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x96, 0x606, 0x1212, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x1212, 0x4444, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x1122, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x1122, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x606, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x1212, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x1212, 0x0, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x1122, 0x4114, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x1122, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x3300, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x3300, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x3300, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x3300, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x3300, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x3300, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x3300, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x3300, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x1122, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x1212, 0x550, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x1212, 0x4114, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x1122, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x96, 0x606, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x1122, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x1212, 0x4114, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x1212, 0x550, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x1122, 0x4444, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x96, 0x606, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x1212, 0x4114, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x1212, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x1122, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x1212, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x606, 0x1212, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x1212, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x1122, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x606, 0x1212, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x1212, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x0, 0x5050, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x1212, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x1122, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x0, 0x5500, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x606, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x0, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x0, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x1212, 0x0, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x2222, 0x5050, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x2112, 0x5500, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x1122, 0x550, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x3030, 0x0, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x2222, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x3030, 0x550, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x96, 0x606, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x1212, 0x0, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x2222, 0x5050, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x2112, 0x5500, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x1122, 0x550, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1122, 0x0, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2112, 0x5050, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2112, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2222, 0x5500, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2222, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1212, 0x550, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1212, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x3300, 0x0, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x3300, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x2112, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x3300, 0x550, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x3300, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x606, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x1122, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x2112, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x2222, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x1212, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x1212, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x1122, 0x1414, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x330, 0x5050, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x1122, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x1212, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x330, 0x5500, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x606, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x330, 0x1144, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x2222, 0x4444, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x1212, 0x1414, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x1122, 0x1144, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x0, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x0, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x2222, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x2222, 0x1414, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x2112, 0x1144, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x1212, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x1122, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x1122, 0x4444, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x2112, 0x1414, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x2222, 0x1144, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x1212, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x1122, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x1212, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x2112, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x2112, 0x4444, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x1122, 0x1414, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x1212, 0x1144, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x330, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x330, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x2222, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x1212, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x2222, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0x0, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x1212, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x96, 0x606, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x0, 0x4444, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x0, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x2222, 0x0, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x3030, 0x1414, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x2222, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x2112, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x2112, 0x550, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x3030, 0x1144, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x1212, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x2222, 0x4444, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x2222, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x1212, 0x1414, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x2112, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x1122, 0x1144, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x1122, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x3030, 0x1414, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x96, 0x606, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x1212, 0x0, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x0, 0x4444, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x1122, 0x550, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x0, 0x4114, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1122, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2112, 0x4444, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2112, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1122, 0x1414, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2222, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1212, 0x1144, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1212, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x3300, 0x1414, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x96, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x1122, 0x0, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x330, 0x4444, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x1212, 0x550, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x330, 0x4114, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x2112, 0x4444, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x1122, 0x1414, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x1212, 0x1144, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x330, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x330, 0x4444, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x330, 0x550, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0x606, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x2112, 0x0, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x3300, 0x1414, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x2112, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x2222, 0x550, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x3300, 0x1144, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x606, 0x2222, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x2222, 0x5050, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x2112, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x2112, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x0, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x606, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x2222, 0x0, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x2222, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x2112, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x0, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x0, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x0, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x0, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x0, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x0, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x0, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x0, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x2222, 0x1414, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x96, 0x606, 0x2222, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x2112, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x2112, 0x1144, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x2222, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x606, 0x2222, 0x5050, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x2112, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x2112, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x2112, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x330, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x330, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x330, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x330, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x330, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x330, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x330, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x330, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x2222, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x2112, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x96, 0x606, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x2222, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x2112, 0x1414, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x2222, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x2112, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x2112, 0x5050, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x606, 0x2222, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x2222, 0x4114, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x2112, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x2222, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x2112, 0x5050, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x2222, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x2112, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x2222, 0x550, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x2222, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x2112, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x2112, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x606, 0x2222, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x2112, 0x0, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x2222, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x3030, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x2112, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x3030, 0x5500, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x0, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x0, 0x4114, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x2222, 0x0, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x1212, 0x5050, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x1122, 0x5500, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x2112, 0x550, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x2222, 0x0, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x1212, 0x5050, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x2222, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x1122, 0x5500, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x2112, 0x550, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x1212, 0x4444, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x0, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x1122, 0x4114, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x0, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x606, 0x3030, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x3030, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x3030, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2112, 0x0, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1122, 0x5050, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2112, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1212, 0x5500, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2222, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2222, 0x550, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1212, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x330, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x1122, 0x4444, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x330, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x1212, 0x4114, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x330, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x1212, 0x4114, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x3300, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x606, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x3300, 0x4114, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x2112, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x3300, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x3300, 0x5500, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x330, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x330, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x330, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x330, 0x4114, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0x606, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x2112, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x1122, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x1212, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x2222, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x1212, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x2222, 0x4444, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x1212, 0x1414, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x1122, 0x1144, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x0, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x2222, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x1212, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x1122, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x2112, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x2112, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x1212, 0x4444, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x1212, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x2222, 0x1414, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x2112, 0x1144, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x1212, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x2222, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x2112, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x1122, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x2112, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x1122, 0x4444, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x2112, 0x1414, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x2222, 0x1144, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x1122, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x2112, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x2222, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x1212, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x2112, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x2112, 0x4444, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x1122, 0x1414, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x1212, 0x1144, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x330, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x330, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x2112, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x1122, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x1212, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x0, 0x2222, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x0, 0x2112, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x2222, 0x4444, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x1212, 0x1414, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x1122, 0x1144, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x0, 0x550, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x0, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x0, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0x0, 0x96, 0x606, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x2222, 0x0, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x2222, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x2112, 0x550, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x3300, 0x1414, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x1212, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x2112, 0x4444, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x2222, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x1122, 0x1414, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x2112, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x1212, 0x1144, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x96, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x1122, 0x550, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x330, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x1212, 0x0, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x330, 0x4114, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1122, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2222, 0x4444, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2112, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1212, 0x1414, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2222, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1122, 0x1144, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1212, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x96, 0x606, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x1212, 0x550, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x0, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x1122, 0x0, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x0, 0x4114, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x1122, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x2112, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x330, 0x0, 0x0, 0x0, 0x0, 0x96, 0x606, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x330, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x330, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x330, 0x0, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x2112, 0x0, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x2222, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x2222, 0x550, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x3030, 0x1414, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x2222, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x2112, 0x5050, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x2222, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x2222, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x2222, 0x0, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x2112, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x2112, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x2222, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x606, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x2112, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x330, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x330, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x330, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x330, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x330, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x330, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x330, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x330, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x2112, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x2222, 0x1414, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x2112, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x2222, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x96, 0x606, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x2222, 0x550, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x2112, 0x1144, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x2112, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x2222, 0x5050, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x606, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x2112, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x2222, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x0, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x0, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x0, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x0, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x0, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x0, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x0, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x0, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x2222, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x2222, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x96, 0x606, 0x2112, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x2112, 0x550, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x2112, 0x1414, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x2222, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x2222, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x606, 0x2112, 0x5050, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x2112, 0x4114, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x606, 0x2112, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x2112, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x2222, 0x5050, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x2112, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x330, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x606, 0x2112, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x2222, 0x550, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x2222, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x2222, 0x550, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x2112, 0x0, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x2112, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x3300, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x2222, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x3300, 0x5500, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x0, 0x4114, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x0, 0x550, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x0, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0x96, 0x606, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x2222, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x1212, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x1122, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x2112, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x2112, 0x0, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x1122, 0x5050, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x2222, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x1212, 0x5500, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x2112, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x2222, 0x550, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x1122, 0x4114, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x330, 0x550, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x1212, 0x4444, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x330, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x3030, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x606, 0x3030, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x3030, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2222, 0x0, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1122, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1212, 0x5050, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2112, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1122, 0x5500, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2222, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2112, 0x550, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1212, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x1212, 0x4114, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x0, 0x550, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x1122, 0x4444, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x0, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x1212, 0x4114, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x606, 0x3300, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x3300, 0x4114, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x2112, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x2222, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x3030, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x2112, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x3030, 0x5500, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x606, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x330, 0x4114, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x330, 0x550, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x330, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x2112, 0x0, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x1122, 0x5050, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x1212, 0x5500, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x2222, 0x550, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x1122, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x0, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x606, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x1212, 0x5050, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x330, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x1122, 0x5500, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x330, 0x1414, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x330, 0x1144, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x1122, 0x4444, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x2112, 0x1414, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x2112, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x2222, 0x1144, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x1212, 0x4114, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x1212, 0x4444, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x2222, 0x1414, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x2112, 0x1144, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x1212, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x3030, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x3030, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x606, 0x3030, 0x4114, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x2222, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x2112, 0x5500, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x3300, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x3300, 0x4114, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1122, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1212, 0x4444, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2222, 0x1414, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2222, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2112, 0x1144, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1212, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x2112, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x2222, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x1212, 0x4114, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x606, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x3300, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x3300, 0x4114, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x3030, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x2112, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x2222, 0x5500, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x3030, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x3030, 0x4114, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x606, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x1122, 0x5050, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x0, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x1212, 0x5500, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x0, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x0, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x1122, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x1212, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x1212, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x1212, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x606, 0x1122, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x1212, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x1122, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x606, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x1122, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x1212, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x3300, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x3300, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x3300, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x3300, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x3300, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x3300, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x3300, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x3300, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x1212, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x1122, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x1212, 0x4444, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x1212, 0x550, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x1122, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x96, 0x606, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x1122, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x1122, 0x4444, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x1212, 0x0, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x1212, 0x4114, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x96, 0x606, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x1212, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x3030, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x3030, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x3030, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x3030, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x3030, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x3030, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x3030, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x3030, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x96, 0x606, 0x1122, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x1122, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x1212, 0x4114, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x606, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x1212, 0x4444, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x1122, 0x4114, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x1212, 0x550, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x1122, 0x4114, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x1122, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x1212, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x606, 0x1122, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x1212, 0x1144, 0x4444, 0x3030, 0x0, 0x96, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x606, 0x1122, 0x5050, 0x4444, 0x0, 0xf00, 0x96, 0x606, 0x1212, 0x5500, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x1212, 0x1414, 0x4444, 0x3030, 0xf00, 0x96, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x1212, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0x606, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x1122, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x330, 0x5050, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x1212, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x1212, 0x1414, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x330, 0x5500, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x606, 0x0, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x0, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x1122, 0x0, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x2112, 0x5050, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x2222, 0x5500, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0xc0c, 0x1212, 0x550, 0x5050, 0x3030, 0x0, 0x3c, 0xc0c, 0x1122, 0x0, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x3300, 0x0, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x2222, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x3300, 0x550, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x3030, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x3030, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x606, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x1212, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x2222, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x2112, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x2112, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0xc0c, 0x1122, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0xc0c, 0x1212, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1212, 0x0, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2222, 0x5050, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2112, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2112, 0x5500, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x2222, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1122, 0x550, 0x5050, 0x3030, 0xf00, 0x3c, 0xc0c, 0x1212, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x3030, 0x0, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x3030, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x2112, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x3030, 0x550, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x96, 0x606, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x1122, 0x0, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x2112, 0x5050, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x2222, 0x5500, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xc0c, 0x1212, 0x550, 0x5050, 0x0, 0x0, 0x3c, 0xc0c, 0x1122, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x1212, 0x1144, 0x0, 0x3030, 0xf00, 0x96, 0x606, 0x0, 0x5050, 0x5050, 0x3030, 0x0, 0x96, 0x606, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x1122, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x1122, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x606, 0x0, 0x5500, 0x5050, 0x3030, 0xf00, 0x96, 0x606, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x5a, 0xa0a, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x606, 0x330, 0x5050, 0x5050, 0x0, 0xf00, 0x96, 0x606, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xa0a, 0x330, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x606, 0x330, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x606, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xa0a, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x606, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x330, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x330, 0x1144, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x1122, 0x4444, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x2112, 0x1414, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x2112, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x2222, 0x1144, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x1122, 0x4114, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x606, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x3030, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x2222, 0x1414, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x2112, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x1122, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x1122, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x2112, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x2222, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x606, 0x3300, 0x4114, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x3030, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x3030, 0x4114, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x606, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x1122, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x0, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x0, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x1212, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x1212, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x330, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x3030, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x3030, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x3030, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x1212, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x1212, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x2112, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x2112, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x1212, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x3300, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x1212, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x3300, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x2112, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x1212, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x2112, 0x1414, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x1122, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x3300, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x3030, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x330, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x330, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x330, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x330, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x330, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x0, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x0, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x0, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x2222, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x2222, 0x5050, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x2222, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x2222, 0x5050, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x3300, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x1122, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x2222, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x2222, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x1122, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x2222, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x3030, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x3030, 0x4114, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x1122, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x1122, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x1122, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x0, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x96, 0x0, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x0, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x66, 0x0, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x2222, 0x1414, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x2112, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x0, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0x0, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x3030, 0x4444, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x1212, 0x1414, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x1122, 0x1144, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x0, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x330, 0x0, 0x0, 0x0, 0x0, 0x96, 0x0, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x0, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x0, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x330, 0x4114, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x2112, 0x1414, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x2222, 0x1144, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x2222, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x3030, 0x4114, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x1212, 0x1414, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x1122, 0x1144, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x330, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x330, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x0, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x2222, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x2222, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x2112, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x330, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x0, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x0, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x0, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x0, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x2222, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x1122, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x3300, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x330, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x1122, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x330, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x2222, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x330, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x2222, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x330, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x1122, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x2112, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x1122, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x2112, 0x1414, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x2112, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x3300, 0x4114, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x2222, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x3300, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x3300, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x3300, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x3300, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x330, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x330, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x2222, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x3030, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x3030, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x3030, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x330, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x1212, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x2112, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x0, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x1212, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x3030, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x1212, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x2112, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x1212, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x2222, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x1212, 0x4114, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x3030, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x3030, 0x4114, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x2112, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x2222, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x2112, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x2112, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x2112, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x2222, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x1212, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x0, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x330, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x330, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x330, 0x4114, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x1122, 0x4444, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x2112, 0x1414, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x2112, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x2222, 0x1144, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x3030, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x2112, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x1212, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x1122, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x2112, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x2222, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x3300, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x1122, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x3030, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x2222, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x1122, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x3030, 0x4114, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2222, 0x4444, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1212, 0x1414, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1122, 0x1144, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x330, 0x4114, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x330, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x330, 0x1414, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x330, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x1212, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x2222, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x1212, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x906, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x66, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x3030, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x2222, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x2222, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x2222, 0x1414, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x2112, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x3300, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x2112, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x3030, 0x4444, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x2222, 0x4444, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x1212, 0x1414, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x1212, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x1122, 0x1144, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x330, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x906, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x330, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x330, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x2222, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x2112, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x2112, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x2222, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x0, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x330, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x330, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x330, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x330, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x330, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x2112, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x1212, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x1212, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x2112, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x2112, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x3030, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x0, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x1212, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x2112, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x0, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x1212, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x1212, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x2222, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x1212, 0x4114, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x3030, 0x4114, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x2222, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x3030, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x3030, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x3030, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x3030, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x330, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x1212, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x2222, 0x4444, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x3300, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x3300, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x3300, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x2112, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x0, 0x1414, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x330, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x330, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x330, 0x4114, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x330, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x330, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x1122, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x3300, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x1122, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x2222, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x2222, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x1122, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x2112, 0x1414, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x2112, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x2222, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x2222, 0x5050, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x2112, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x2112, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x330, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x330, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x330, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x330, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x330, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x2112, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x2112, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x330, 0x1144, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x2112, 0x1414, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x2112, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x2222, 0x1144, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x3030, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x3030, 0x4114, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x2222, 0x1414, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x2112, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x1122, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x2222, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x1212, 0x4114, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x3300, 0x4114, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x0, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x1212, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x1122, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x1122, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x1212, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x0, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x3300, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x3300, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x3300, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x1122, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x1122, 0x4114, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x1122, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x1122, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x3030, 0x4114, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x3030, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x3030, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x3030, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x3300, 0x4114, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x3030, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x1122, 0x4114, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x3030, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x2222, 0x1414, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x3030, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x2222, 0x1414, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x1122, 0x4114, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x1212, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x1212, 0x4114, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x2222, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x3300, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x1122, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x3030, 0x4114, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x2222, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x1122, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x3030, 0x4114, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x0, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x0, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x0, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x0, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x1212, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x1122, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x1122, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x1212, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x0, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x330, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x330, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x330, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x330, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x330, 0x1144, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x2112, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x1212, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x2112, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x1212, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x3030, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x3300, 0x4444, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x1212, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x2112, 0x1144, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x2112, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x1212, 0x4444, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x1122, 0x4444, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x3030, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x2112, 0x1414, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x2112, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x3030, 0x4444, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x330, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x0, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x1212, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x1122, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x1122, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x1212, 0x1144, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x3300, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x3300, 0x4444, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x3300, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x3300, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x3300, 0x5500, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x2222, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2222, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x1212, 0x550, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x3030, 0x5050, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x3030, 0x550, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x2222, 0x5050, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2222, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x1122, 0x550, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x3030, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x3030, 0x5050, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x3030, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x1122, 0x4444, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x2222, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x2222, 0x1144, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x1122, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x3300, 0x550, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x1212, 0x4444, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x2222, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x2222, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x1212, 0x550, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x0, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x0, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x0, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x0, 0x5500, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x0, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x1212, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x1122, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x1122, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x1212, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x1122, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x606, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x1212, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x1122, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x606, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x1122, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x1212, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x3300, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x3300, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x3300, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x3300, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x3300, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x3300, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x3300, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0x606, 0x1212, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x1212, 0x4444, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x1212, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x606, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x1122, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x1122, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x1212, 0x0, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x1212, 0x4114, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x3030, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x1122, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x1212, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x1212, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x66, 0x606, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x1212, 0x4444, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x1122, 0x4114, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x1212, 0x550, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x1212, 0x4444, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0x606, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x1122, 0x4114, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x1122, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x606, 0x1212, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0xf00, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0x606, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x606, 0x1212, 0x5500, 0x4444, 0x0, 0xf00, 0x96, 0xf00, 0x1122, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x1122, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x1212, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x1212, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x0, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x3300, 0x0, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x3300, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x3300, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x3300, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x3300, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x1122, 0x0, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x1122, 0x0, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2222, 0x5500, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2222, 0x5500, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x1212, 0x0, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x2222, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x2222, 0x5050, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2222, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x3030, 0x0, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x3030, 0x0, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x3030, 0x5500, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x3030, 0x5500, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x1212, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x2222, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x2222, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x2222, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x3300, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x3300, 0x5050, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x1122, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x1122, 0x0, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x2222, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x2222, 0x5500, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x1122, 0x4114, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x0, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x0, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x0, 0x5500, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x0, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x0, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x1122, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x1212, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x1212, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x1122, 0x1144, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x0, 0x2222, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x0, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x1212, 0x5500, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x0, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x0, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x66, 0x0, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x1212, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x1212, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x2222, 0x4114, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x0, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x0, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x2222, 0x5500, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x1212, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x0, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x0, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x1212, 0x0, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x2222, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x3030, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x1212, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x96, 0x0, 0x2222, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x0, 0x1212, 0x4114, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x0, 0x2222, 0x5500, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x0, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x0, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x0, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x0, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x1212, 0x1144, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x0, 0x1212, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x96, 0x0, 0x2222, 0x4114, 0x4444, 0x0, 0x0, 0x96, 0x0, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x2222, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0x0, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x0, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x0, 0x1212, 0x5500, 0x4444, 0x3300, 0x0, 0x96, 0x0, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x0, 0x2222, 0x550, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x1212, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x1212, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x0, 0x4444, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x0, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x2222, 0x0, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x1122, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x1122, 0x5500, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2222, 0x4114, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2222, 0x4114, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x3300, 0x4444, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x3300, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x3300, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x3300, 0x5500, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x3300, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x3030, 0x1414, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x3030, 0x4114, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x1212, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x1122, 0x4444, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x1122, 0x550, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x3030, 0x0, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x3030, 0x1414, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x3030, 0x5500, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x3030, 0x4114, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x3030, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x1122, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x1212, 0x0, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x1122, 0x4444, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x1122, 0x550, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x1212, 0x4114, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x0, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x0, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x0, 0x0, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x0, 0x4444, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x0, 0x550, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x0, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x2222, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x1122, 0x1414, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x1122, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x2222, 0x4114, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x2222, 0x4114, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x2222, 0x4444, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x1212, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x1212, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x2222, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x2222, 0x4444, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x1122, 0x1144, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x2222, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x0, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x0, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x0, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x2222, 0x0, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x1122, 0x5500, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x3300, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x1122, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x1122, 0x4114, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x1122, 0x4114, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x1122, 0x4444, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x2222, 0x1144, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x1122, 0x4444, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x2222, 0x1144, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x1122, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x2222, 0x5500, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x2222, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x1122, 0x0, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x0, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x0, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x0, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x2222, 0x0, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x2222, 0x4114, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x2222, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x2222, 0x4114, 0x4444, 0x0, 0x0, 0xf0, 0x606, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x2222, 0x4444, 0x4444, 0x3300, 0x0, 0xf0, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0xf0, 0x906, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x1122, 0x1144, 0x4444, 0x3300, 0x0, 0xf0, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x2222, 0x550, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x1122, 0x5050, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x0, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x0, 0x4114, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x0, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x2222, 0x0, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x1212, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x2222, 0x0, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x1212, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x1212, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x3300, 0x0, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x3300, 0x5050, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x3300, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x3300, 0x0, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x3300, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x3300, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x1212, 0x4444, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x1122, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x1122, 0x4114, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x3030, 0x5050, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x3030, 0x550, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x3030, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x3030, 0x5050, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x3030, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x3300, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x1212, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x1122, 0x0, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x0, 0x0, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x0, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x0, 0x4444, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x0, 0x0, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x0, 0x4114, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x0, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x0, 0x550, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x0, 0x4114, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x2222, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x1212, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x2222, 0x0, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x2222, 0x4114, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x2222, 0x4444, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x1122, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x1122, 0x1144, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x2222, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x2222, 0x4444, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x1122, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x1122, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x1122, 0x1144, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x0, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x2222, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x2222, 0x0, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x1122, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x1122, 0x5500, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x3300, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x3300, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x3300, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x3300, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x3300, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x3300, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x3300, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x1122, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x2222, 0x1414, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x2222, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x1122, 0x4114, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x1122, 0x4114, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x2222, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x1122, 0x4444, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x2222, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x1122, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x2222, 0x1144, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x1122, 0x550, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x1122, 0x4444, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x1122, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x2222, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x2222, 0x1144, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x2222, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x3300, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x1122, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x2222, 0x5500, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x2222, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x1122, 0x0, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x0, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x0, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x0, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x0, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x0, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x0, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x2222, 0x0, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x2222, 0x4114, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x1122, 0x5500, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x1122, 0x1414, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x2222, 0x4114, 0x4444, 0x0, 0xf00, 0xf0, 0x606, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x2222, 0x4444, 0x4444, 0x3300, 0xf00, 0xf0, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x1122, 0x5050, 0x4444, 0x0, 0xf00, 0xf0, 0x906, 0x1122, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x1122, 0x1144, 0x4444, 0x3300, 0xf00, 0xf0, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x2222, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x1122, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x2222, 0x4444, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x1122, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x1122, 0x1144, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x0, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x0, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x0, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x0, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x2222, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x1212, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x2222, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x1212, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x3300, 0x0, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x3300, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x3300, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x3300, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x3300, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x3300, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x1212, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x1212, 0x550, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x1122, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x1122, 0x0, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x3030, 0x5050, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x3030, 0x550, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x3030, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x3030, 0x5050, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x3030, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x3300, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x3300, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x1212, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x1122, 0x4114, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x1122, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x1122, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x0, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x0, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x0, 0x550, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x0, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x0, 0x0, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x0, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x0, 0x550, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2222, 0x0, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x1212, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x2222, 0x4114, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x1212, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x2222, 0x4114, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x1122, 0x5050, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x2222, 0x550, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x2222, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x906, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x1212, 0x5500, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x0, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x0, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x2222, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x2222, 0x0, 0x0, 0x0, 0x0, 0x66, 0x906, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x1212, 0x5050, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x1212, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x2222, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x2222, 0x4114, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x906, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x1212, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x2222, 0x5500, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x1212, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x906, 0x1212, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x2222, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x1212, 0x0, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x2222, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x3030, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x1212, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x2222, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x1212, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x2222, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x906, 0x1212, 0x4114, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x2222, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x1212, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x2222, 0x5500, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x906, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x0, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x0, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x0, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x0, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x0, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x0, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x2222, 0x0, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x1212, 0x1144, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x66, 0x906, 0x1212, 0x1144, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x2222, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x2222, 0x4114, 0x4444, 0x0, 0xf00, 0x96, 0x0, 0x2222, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x2222, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0x906, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x906, 0x1212, 0x5500, 0x4444, 0x3300, 0xf00, 0x96, 0x0, 0x2222, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x2222, 0x550, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x2222, 0x4444, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x2222, 0x550, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x1212, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x1212, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x2222, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x0, 0x4444, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x0, 0x4114, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x0, 0x550, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x0, 0x4444, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x0, 0x550, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x0, 0x4114, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x2222, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x1122, 0x5500, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x2222, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x1122, 0x1414, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x1122, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x2222, 0x0, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x2222, 0x4114, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x3300, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x3300, 0x4444, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x3300, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x3300, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x3300, 0x5500, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x3300, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x1212, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x1122, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x1212, 0x4114, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x1122, 0x550, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x3030, 0x0, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x3030, 0x5500, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x3030, 0x5500, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x3030, 0x0, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x1212, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x1212, 0x4114, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x1122, 0x550, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x1122, 0x4444, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x1212, 0x4114, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x3300, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x0, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x0, 0x4444, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x0, 0x4114, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x0, 0x550, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x0, 0x4444, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x0, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x0, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x0, 0x4114, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2222, 0x0, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x1122, 0x5500, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x2222, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x1122, 0x5500, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2222, 0x0, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x2222, 0x4114, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2222, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x2222, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x1212, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x1212, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x2222, 0x550, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x1212, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x1122, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x3300, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x3300, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x3300, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x1212, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x1122, 0x0, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x1212, 0x4444, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x1212, 0x550, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x1122, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x1122, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x1122, 0x4444, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x1212, 0x0, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x1212, 0x4114, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x3030, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x1122, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x1122, 0x550, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x1212, 0x4114, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x1212, 0x0, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x1212, 0x4444, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x1122, 0x4114, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x1212, 0x550, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x1212, 0x4444, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x1122, 0x0, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x1122, 0x4114, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x1212, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x1122, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x1122, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x1212, 0x1144, 0x4444, 0x3300, 0x0, 0x96, 0xf00, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x1122, 0x5050, 0x4444, 0x0, 0x0, 0x66, 0xf00, 0x1212, 0x5500, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x1212, 0x1414, 0x4444, 0x3300, 0x0, 0x66, 0xf00, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x1212, 0x5500, 0x4444, 0x0, 0x0, 0x96, 0xf00, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x1122, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x1212, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x1122, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x1212, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x1122, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x1212, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x1212, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x0, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x3300, 0x0, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x3300, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x3300, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x3300, 0x1144, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x3300, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x3300, 0x1144, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x3300, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x3300, 0x4114, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x1122, 0x0, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x1122, 0x4114, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x2222, 0x5500, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x2222, 0x1414, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x1122, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x1122, 0x4114, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x3030, 0x0, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x3030, 0x4114, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x3030, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x3030, 0x5500, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x3030, 0x1414, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x3030, 0x4114, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x1212, 0x0, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x2222, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x2222, 0x1144, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x2222, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x1212, 0x4114, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x3030, 0x0, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x3030, 0x4114, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x3030, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x3030, 0x1414, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x3030, 0x5500, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x3030, 0x1414, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x3030, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x3030, 0x4114, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x1212, 0x0, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x1212, 0x4114, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2222, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x2222, 0x1144, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x2222, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x1212, 0x0, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x1212, 0x4114, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x3300, 0x0, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x3300, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x3300, 0x1144, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x3300, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x3300, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x3300, 0x4114, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x1122, 0x0, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x1122, 0x4114, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x2222, 0x5500, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2222, 0x1414, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x1122, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x1122, 0x4114, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x0, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x0, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x0, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x0, 0x5500, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x1212, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x1122, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x1212, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x1122, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x1212, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x1122, 0x1144, 0x5050, 0x0, 0x0, 0x96, 0xa0a, 0x0, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x0, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x606, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x0, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x606, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x0, 0x5500, 0x5050, 0x0, 0xf00, 0x96, 0xa0a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x0, 0x1144, 0x5050, 0x3300, 0x0, 0x66, 0xa0a, 0x1212, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x1212, 0x5050, 0x5050, 0x0, 0x0, 0x5a, 0x30c, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x1122, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x30c, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x1122, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0x30c, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x1212, 0x1144, 0x5050, 0x3300, 0xf00, 0x96, 0x50a, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x3300, 0x4444, 0x5050, 0x3300, 0x0, 0x5a, 0x906, 0x3300, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x3300, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x906, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x3300, 0x5500, 0x5050, 0x3300, 0x0, 0x96, 0x50a, 0x3300, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x3300, 0x550, 0x5050, 0x3300, 0x0, 0x66, 0xc0c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x1212, 0x4444, 0x5050, 0x3300, 0x0, 0x5a, 0xc0c, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x2222, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0xc0c, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x2222, 0x5500, 0x5050, 0x0, 0x0, 0x66, 0x50a, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x1212, 0x550, 0x5050, 0x0, 0x0, 0xcc, 0x606, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x3030, 0x4444, 0x5050, 0x0, 0x0, 0xcc, 0xa0a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x3030, 0x5050, 0x5050, 0x0, 0x0, 0xcc, 0x906, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x3030, 0x1144, 0x5050, 0x0, 0x0, 0xcc, 0x50a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x3030, 0x550, 0x5050, 0x0, 0xf00, 0x3c, 0x50a, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x1122, 0x4444, 0x5050, 0x3300, 0x0, 0x3c, 0xa0a, 0x2222, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x2222, 0x5050, 0x5050, 0x0, 0xf00, 0x3c, 0xa0a, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x2222, 0x1144, 0x5050, 0x3300, 0x0, 0x3c, 0x50a, 0x1122, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x1122, 0x550, 0x5050, 0x3300, 0x0, 0xcc, 0x606, 0x3030, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x3030, 0x4444, 0x5050, 0x3300, 0x0, 0xcc, 0xa0a, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x3030, 0x5050, 0x5050, 0x3300, 0x0, 0xcc, 0x906, 0x3030, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x3030, 0x1144, 0x5050, 0x3300, 0x0, 0xcc, 0x50a, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x3030, 0x550, 0x5050, 0x3300, 0xf00, 0x3c, 0x50a, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x1122, 0x4444, 0x5050, 0x0, 0x0, 0x3c, 0xa0a, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2222, 0x5050, 0x5050, 0x3300, 0xf00, 0x3c, 0xa0a, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x2222, 0x1144, 0x5050, 0x0, 0x0, 0x3c, 0x50a, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x1122, 0x550, 0x5050, 0x0, 0xf00, 0x96, 0x50a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x3300, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0x906, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x3300, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x906, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x3300, 0x5500, 0x5050, 0x0, 0x0, 0x96, 0x50a, 0x3300, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x3300, 0x550, 0x5050, 0x0, 0x0, 0x66, 0xc0c, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x1212, 0x4444, 0x5050, 0x0, 0x0, 0x5a, 0xc0c, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2222, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0xc0c, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x2222, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0x50a, 0x1212, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x1212, 0x550, 0x5050, 0x3300, 0x0, 0x96, 0xa0a, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x0, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0x606, 0x0, 0x5500, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x0, 0x1414, 0x5050, 0x3300, 0xf00, 0x5a, 0x606, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x0, 0x5500, 0x5050, 0x3300, 0xf00, 0x96, 0xa0a, 0x0, 0x5050, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x0, 0x1144, 0x5050, 0x0, 0x0, 0x66, 0xa0a, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x1212, 0x5050, 0x5050, 0x3300, 0x0, 0x5a, 0x30c, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x1122, 0x1414, 0x5050, 0x0, 0xf00, 0x5a, 0x30c, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x1122, 0x5500, 0x5050, 0x3300, 0x0, 0x66, 0x30c, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x0, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x1212, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x0, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x1212, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x0, 0x1144, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x2222, 0x5500, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x3030, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x3030, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x1122, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x2222, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x2222, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x1122, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x3030, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x2222, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x1212, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x3300, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x2222, 0x5500, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x1212, 0x550, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x0, 0x5050, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x330, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x1122, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x1212, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x1212, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x1122, 0x0, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x3030, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x3030, 0x1414, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x2112, 0x5050, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x3030, 0x4444, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x1122, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x2112, 0x1144, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3300, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x1212, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x2112, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x1212, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x3300, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x3300, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x2112, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x3300, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x3300, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x2112, 0x1414, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x3030, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x2112, 0x5050, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x1122, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x1122, 0x0, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x330, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x330, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x330, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x606, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x0, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x1122, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x2112, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x2222, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0xf00, 0x1212, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0xf00, 0x1122, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x3300, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0x606, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x3030, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x1212, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x1122, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x2112, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xc0c, 0x1122, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0xc0c, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xc0c, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0xc0c, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x3030, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x3030, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x606, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x1122, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x2112, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x2222, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0xf00, 0x1212, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0xf00, 0x1122, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x606, 0x0, 0x5050, 0x5500, 0x3300, 0xf00, 0x96, 0xf00, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x1122, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0xf00, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x606, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0x5a, 0xf00, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xf00, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0x606, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xa0a, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xa0a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x606, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xf00, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x5a, 0xf00, 0x330, 0x1144, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x2112, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0x0, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x66, 0x0, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x0, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x1212, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x1122, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x2112, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x0, 0x1122, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x0, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0x0, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x0, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x2112, 0x1414, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x0, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x0, 0x3300, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0x0, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0x0, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x96, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x0, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0x66, 0x0, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0x96, 0x0, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x96, 0x0, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x0, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x0, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x0, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x0, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x5a, 0x0, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x0, 0x330, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x2222, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x2112, 0x550, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x3030, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x3030, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x3030, 0x1414, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x2222, 0x5500, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x3030, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x3030, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x0, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x0, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x1212, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x2112, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x1212, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x2112, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x1212, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x3030, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x3030, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x330, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x2222, 0x5500, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x2112, 0x550, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x2112, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x2112, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x1212, 0x1144, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x330, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x330, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x2222, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x2112, 0x550, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x2222, 0x1414, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x2112, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x1122, 0x0, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x0, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x0, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x0, 0x1414, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x2112, 0x5050, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x0, 0x4444, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x2222, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x2222, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x1122, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x1122, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x330, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x2222, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x330, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x1122, 0x550, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x2112, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x1122, 0x1414, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x2112, 0x5050, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x2112, 0x550, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x3300, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x3300, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x3300, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x3300, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x330, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x330, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x330, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x2222, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x330, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x0, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x0, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x2112, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x1122, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x1122, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x1212, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0xc0c, 0x2112, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0xc0c, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0x30c, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x30c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x2112, 0x1144, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x2112, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x3030, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x3030, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x3030, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x2222, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x1122, 0x4444, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x3030, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x3300, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x1122, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x1212, 0x550, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x30c, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0xf0, 0x30c, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x2112, 0x550, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x1122, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x1122, 0x5500, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x1212, 0x5050, 0x0, 0x3300, 0x0, 0xf0, 0xc0c, 0x2112, 0x550, 0x5500, 0x3300, 0x0, 0xf0, 0xc0c, 0x2222, 0x0, 0x0, 0x3300, 0x0, 0xf0, 0x606, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x1212, 0x1144, 0x5500, 0x3300, 0x0, 0xf0, 0x906, 0x0, 0x5500, 0x0, 0x3300, 0x0, 0xf0, 0x906, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x2112, 0x4444, 0x5500, 0x3300, 0x0, 0xf0, 0x606, 0x0, 0x0, 0x5500, 0x0, 0x0, 0xf0, 0x606, 0x330, 0x550, 0x0, 0x0, 0x0, 0xf0, 0xa0a, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0xf0, 0x50a, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xf0, 0x906, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0xf0, 0x906, 0x330, 0x5050, 0x0, 0x0, 0x0, 0xf0, 0x50a, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0xf0, 0xa0a, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xf0, 0x606, 0x330, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x330, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x2222, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x330, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x330, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x0, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x0, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x2222, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x1212, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x1122, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0xc0c, 0x2112, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0xc0c, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x1122, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x2112, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x2222, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x2222, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x2112, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0x30c, 0x1212, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x30c, 0x1122, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x1212, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x2112, 0x1144, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x3300, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x2112, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x3300, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x3030, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x3030, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x1122, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x3030, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x2222, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x3300, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x1122, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x1212, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x2112, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x2222, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x2222, 0x5500, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x2112, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x30c, 0x1212, 0x550, 0x5500, 0x0, 0xf00, 0xf0, 0x30c, 0x1122, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0xf0, 0xc0c, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0xf0, 0x606, 0x0, 0x0, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x2112, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x1212, 0x1144, 0x5500, 0x3300, 0xf00, 0xf0, 0x906, 0x0, 0x5500, 0x0, 0x3300, 0xf00, 0xf0, 0x906, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x1212, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x2112, 0x4444, 0x5500, 0x3300, 0xf00, 0xf0, 0x606, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0xf0, 0x606, 0x330, 0x550, 0x0, 0x0, 0xf00, 0xf0, 0xa0a, 0x330, 0x4444, 0x5500, 0x0, 0xf00, 0xf0, 0x50a, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0xf0, 0x906, 0x330, 0x5050, 0x5500, 0x0, 0xf00, 0xf0, 0x906, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0xf0, 0x50a, 0x330, 0x1144, 0x5500, 0x0, 0xf00, 0xf0, 0xa0a, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0xf0, 0x606, 0x330, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x2222, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x2112, 0x550, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x3300, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x3300, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x3300, 0x1414, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x2112, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x1122, 0x0, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x2112, 0x5050, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x2112, 0x4444, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x1122, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x3300, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x330, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x330, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x330, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x330, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x2222, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x2222, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x1122, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x1122, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x0, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x2112, 0x5050, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x1122, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x2112, 0x550, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x2112, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x2222, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x0, 0x0, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x2112, 0x4444, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x330, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x330, 0x550, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x2222, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x2222, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x2112, 0x550, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x2222, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x2112, 0x1414, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x2112, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x330, 0x4444, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x330, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x330, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x2222, 0x5500, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x330, 0x4444, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x2112, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x1212, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x1212, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x0, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x0, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x2112, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x0, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x0, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x3030, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x3030, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x2112, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x1212, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x2222, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x1212, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x2222, 0x5500, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x2222, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x1212, 0x550, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x2112, 0x550, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x3030, 0x1144, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x3030, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x3030, 0x1414, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x2112, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x1212, 0x1144, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x0, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x0, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x2112, 0x4444, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x0, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x330, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x330, 0x4444, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x330, 0x550, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x2222, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x2222, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x0, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x906, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x0, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x2222, 0x0, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x2112, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x1212, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x1122, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x1122, 0x5500, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x1212, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x0, 0x2112, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0x0, 0x2222, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x1212, 0x4444, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x2222, 0x1414, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x66, 0x906, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x3030, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x1212, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x1122, 0x550, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x2112, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0x30c, 0x1122, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x30c, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0x30c, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x30c, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x2112, 0x1414, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x3030, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x3300, 0x4444, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x3300, 0x1414, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0x906, 0x3300, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x2222, 0x0, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x2112, 0x550, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x1212, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x1122, 0x5500, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x1212, 0x5050, 0x0, 0x3300, 0xf00, 0x3c, 0x0, 0x2112, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0x0, 0x2222, 0x0, 0x0, 0x3300, 0xf00, 0x96, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x2112, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0x906, 0x0, 0x5050, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x1122, 0x1414, 0x5500, 0x3300, 0x0, 0x66, 0x906, 0x0, 0x5050, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x2112, 0x4444, 0x5500, 0x3300, 0xf00, 0x96, 0x0, 0x0, 0x0, 0x5500, 0x0, 0xf00, 0x96, 0x0, 0x330, 0x550, 0x0, 0x0, 0xf00, 0x5a, 0x0, 0x330, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x906, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x50a, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x50a, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0x906, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x0, 0x330, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x0, 0x330, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x1122, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x330, 0x5500, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x1122, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x0, 0x1144, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x1122, 0x0, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x1212, 0x550, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x2112, 0x5050, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x2222, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x2222, 0x5500, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x2112, 0x5050, 0x0, 0x3300, 0x0, 0x3c, 0xf00, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0x3c, 0xf00, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x3300, 0x0, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x2112, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x2112, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x3300, 0x550, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x3030, 0x0, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x3030, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x3030, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x1212, 0x0, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x1122, 0x550, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x2112, 0x5500, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x2222, 0x5050, 0x0, 0x0, 0x0, 0xcc, 0xf00, 0x1122, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0xf00, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x1212, 0x0, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x1122, 0x550, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x2112, 0x5500, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x2222, 0x5050, 0x0, 0x3300, 0x0, 0xcc, 0xf00, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0xf00, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x3030, 0x0, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x2112, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x2222, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x3030, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x3300, 0x0, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x3300, 0x1144, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x3300, 0x550, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x1122, 0x0, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x1212, 0x550, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x2112, 0x5050, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x2222, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x2222, 0x5500, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x2112, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0xf00, 0x1212, 0x550, 0x5500, 0x0, 0x0, 0x3c, 0xf00, 0x1122, 0x0, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0xf00, 0x0, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0xf00, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0xf00, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0xf00, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x1212, 0x1144, 0x5500, 0x0, 0x0, 0x5a, 0xf00, 0x330, 0x1144, 0x0, 0x0, 0x0, 0x96, 0xf00, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0xf00, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xf00, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xf00, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xf00, 0x330, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xf00, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x5a, 0xf00, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x30c, 0x330, 0x5050, 0x5500, 0x3300, 0x0, 0x66, 0xa0a, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x1212, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x66, 0xa0a, 0x330, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x30c, 0x330, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x1122, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x606, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0xa0a, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x330, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x96, 0xa0a, 0x1122, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x606, 0x1212, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x330, 0x1144, 0x0, 0x3300, 0x0, 0x96, 0x50a, 0x1122, 0x0, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0x906, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x2112, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x2112, 0x1414, 0x5500, 0x3300, 0xf00, 0x5a, 0x906, 0x2112, 0x5050, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x96, 0x50a, 0x1122, 0x0, 0x0, 0x3300, 0x0, 0x3c, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x1212, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x2112, 0x1144, 0x5500, 0x3300, 0x0, 0x3c, 0xa0a, 0x3300, 0x5500, 0x0, 0x3300, 0x0, 0x3c, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x2112, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x3c, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x66, 0x50a, 0x3030, 0x0, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x3030, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0x5a, 0xc0c, 0x3030, 0x5050, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x66, 0x50a, 0x3030, 0x0, 0x0, 0x0, 0x0, 0xcc, 0x50a, 0x1212, 0x0, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x3300, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0xcc, 0xa0a, 0x2112, 0x5500, 0x0, 0x0, 0x0, 0xcc, 0xa0a, 0x2112, 0x5500, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x3300, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0xcc, 0x50a, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0xcc, 0x50a, 0x1212, 0x0, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x1212, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x2112, 0x1144, 0x5500, 0x3300, 0x0, 0xcc, 0xa0a, 0x2112, 0x5500, 0x0, 0x3300, 0x0, 0xcc, 0xa0a, 0x2112, 0x5500, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x2112, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0xcc, 0x50a, 0x1212, 0x0, 0x0, 0x3300, 0x0, 0x66, 0x50a, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x2112, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x2112, 0x1414, 0x5500, 0x3300, 0xf00, 0x5a, 0xc0c, 0x3030, 0x5050, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x1122, 0x4444, 0x5500, 0x3300, 0x0, 0x66, 0x50a, 0x3030, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0xa0a, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x3300, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x50a, 0x3300, 0x0, 0x0, 0x0, 0x0, 0x96, 0x50a, 0x1122, 0x0, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x5a, 0x906, 0x2112, 0x5050, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x3030, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x3030, 0x1414, 0x5500, 0x0, 0xf00, 0x5a, 0x906, 0x2112, 0x5050, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x3030, 0x4444, 0x5500, 0x0, 0x0, 0x96, 0x50a, 0x1122, 0x0, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x1122, 0x1144, 0x0, 0x3300, 0xf00, 0x5a, 0x606, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x96, 0xa0a, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x1212, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x1212, 0x1414, 0x0, 0x3300, 0x0, 0x96, 0xa0a, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0x5a, 0x606, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x1122, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x330, 0x1144, 0x0, 0x0, 0xf00, 0x5a, 0x30c, 0x330, 0x5050, 0x5500, 0x0, 0x0, 0x66, 0xa0a, 0x330, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x330, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x330, 0x1414, 0x0, 0x0, 0x0, 0x66, 0xa0a, 0x330, 0x5500, 0x5500, 0x0, 0xf00, 0x5a, 0x30c, 0x330, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x330, 0x1144, 0x5500, 0x0, 0x0, 0x96, 0x30c, 0x0, 0x1144, 0x0, 0x0, 0x0, 0x66, 0x30c, 0x0, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x30c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x30c, 0x0, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x30c, 0x0, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x30c, 0x0, 0x5500, 0x5500, 0x0, 0x0, 0x66, 0x30c, 0x0, 0x5050, 0x0, 0x0, 0x0, 0x96, 0x30c, 0x0, 0x1144, 0x5500, 0x3030, 0xf00, 0x96, 0x30c, 0x1212, 0x1144, 0x0, 0x0, 0xf00, 0x96, 0xa0a, 0x1212, 0x5050, 0x5500, 0x0, 0x0, 0x5a, 0x606, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x606, 0x1122, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x606, 0x1122, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x606, 0x1122, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xa0a, 0x1212, 0x5050, 0x0, 0x3030, 0xf00, 0x96, 0x30c, 0x1212, 0x1144, 0x5500, 0x3300, 0xf00, 0x96, 0x50a, 0x1212, 0x550, 0x0, 0x3030, 0x0, 0x96, 0xc0c, 0x3300, 0x4444, 0x5500, 0x3300, 0x0, 0x5a, 0x906, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0xc0c, 0x3300, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0xc0c, 0x3300, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x906, 0x2222, 0x5500, 0x5500, 0x3030, 0x0, 0x96, 0xc0c, 0x3300, 0x4444, 0x0, 0x3300, 0xf00, 0x96, 0x50a, 0x1212, 0x550, 0x5500, 0x3300, 0x0, 0x66, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0xf00, 0x96, 0xc0c, 0x1212, 0x4444, 0x5500, 0x3300, 0x0, 0x5a, 0xc0c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x906, 0x2222, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x906, 0x2222, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0xc0c, 0x3300, 0x5500, 0x5500, 0x0, 0xf00, 0x96, 0xc0c, 0x1212, 0x4444, 0x0, 0x3300, 0x0, 0x66, 0xc0c, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x3c, 0x50a, 0x3030, 0x550, 0x0, 0x0, 0xf00, 0x3c, 0x606, 0x3030, 0x4444, 0x5500, 0x0, 0xf00, 0x3c, 0x906, 0x3030, 0x1144, 0x0, 0x0, 0xf00, 0x3c, 0xa0a, 0x3030, 0x5050, 0x5500, 0x0, 0xf00, 0x3c, 0xa0a, 0x3030, 0x5050, 0x0, 0x0, 0xf00, 0x3c, 0x906, 0x3030, 0x1144, 0x5500, 0x0, 0xf00, 0x3c, 0x606, 0x3030, 0x4444, 0x0, 0x0, 0xf00, 0x3c, 0x50a, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0xcc, 0x606, 0x1122, 0x550, 0x0, 0x3030, 0x0, 0x3c, 0x606, 0x1122, 0x4444, 0x5500, 0x3030, 0x0, 0x3c, 0x906, 0x2222, 0x1144, 0x0, 0x0, 0x0, 0xcc, 0x906, 0x2222, 0x5050, 0x5500, 0x0, 0x0, 0xcc, 0x906, 0x2222, 0x5050, 0x0, 0x3030, 0x0, 0x3c, 0x906, 0x2222, 0x1144, 0x5500, 0x3030, 0x0, 0x3c, 0x606, 0x1122, 0x4444, 0x0, 0x0, 0x0, 0xcc, 0x606, 0x1122, 0x550, 0x5500, 0x3300, 0x0, 0xcc, 0x606, 0x1122, 0x550, 0x0, 0x3030, 0xf00, 0x3c, 0x606, 0x3030, 0x4444, 0x5500, 0x3030, 0xf00, 0x3c, 0x906, 0x3030, 0x1144, 0x0, 0x3300, 0x0, 0xcc, 0x906, 0x2222, 0x5050, 0x5500, 0x3300, 0x0, 0xcc, 0x906, 0x2222, 0x5050, 0x0, 0x3030, 0xf00, 0x3c, 0x906, 0x3030, 0x1144, 0x5500, 0x3030, 0xf00, 0x3c, 0x606, 0x3030, 0x4444, 0x0, 0x3300, 0x0, 0xcc, 0x606, 0x1122, 0x550, 0x5500, 0x3300, 0xf00, 0x3c, 0x50a, 0x3030, 0x550, 0x0, 0x0, 0x0, 0x3c, 0x606, 0x1122, 0x4444, 0x5500, 0x0, 0x0, 0x3c, 0x906, 0x2222, 0x1144, 0x0, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3030, 0x5050, 0x5500, 0x3300, 0xf00, 0x3c, 0xa0a, 0x3030, 0x5050, 0x0, 0x0, 0x0, 0x3c, 0x906, 0x2222, 0x1144, 0x5500, 0x0, 0x0, 0x3c, 0x606, 0x1122, 0x4444, 0x0, 0x3300, 0xf00, 0x3c, 0x50a, 0x3030, 0x550, 0x5500, 0x0, 0x0, 0x66, 0xc0c, 0x3300, 0x550, 0x0, 0x0, 0x0, 0x96, 0xc0c, 0x3300, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0xc0c, 0x3300, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0xc0c, 0x3300, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0xc0c, 0x3300, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0xc0c, 0x3300, 0x5500, 0x5500, 0x0, 0x0, 0x96, 0xc0c, 0x3300, 0x4444, 0x0, 0x0, 0x0, 0x66, 0xc0c, 0x3300, 0x550, 0x5500, 0x0, 0xf00, 0x96, 0x50a, 0x1212, 0x550, 0x0, 0x3030, 0xf00, 0x96, 0xc0c, 0x1212, 0x4444, 0x5500, 0x0, 0x0, 0x5a, 0x906, 0x2222, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x906, 0x2222, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x906, 0x2222, 0x1414, 0x0, 0x0, 0x0, 0x5a, 0x906, 0x2222, 0x5500, 0x5500, 0x3030, 0xf00, 0x96, 0xc0c, 0x1212, 0x4444, 0x0, 0x0, 0xf00, 0x96, 0x50a, 0x1212, 0x550, 0x5500, 0x3030, 0x0, 0x96, 0x30c, 0x0, 0x1144, 0x0, 0x3300, 0xf00, 0x96, 0xa0a, 0x1212, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0x606, 0x1122, 0x5500, 0x0, 0x3030, 0x0, 0xaa, 0x30c, 0x0, 0x1414, 0x5500, 0x3030, 0x0, 0xaa, 0x30c, 0x0, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x606, 0x1122, 0x5500, 0x5500, 0x3300, 0xf00, 0x96, 0xa0a, 0x1212, 0x5050, 0x0, 0x3030, 0x0, 0x96, 0x30c, 0x0, 0x1144, 0x5500, 0x0, 0xf00, 0x96, 0x30c, 0x1212, 0x1144, 0x0, 0x3300, 0x0, 0x66, 0x30c, 0x0, 0x5050, 0x5500, 0x3300, 0x0, 0x5a, 0x30c, 0x0, 0x5500, 0x0, 0x0, 0x0, 0xaa, 0x606, 0x1122, 0x1414, 0x5500, 0x0, 0x0, 0xaa, 0x606, 0x1122, 0x1414, 0x0, 0x3300, 0x0, 0x5a, 0x30c, 0x0, 0x5500, 0x5500, 0x3300, 0x0, 0x66, 0x30c, 0x0, 0x5050, 0x0, 0x0, 0xf00, 0x96, 0x30c, 0x1212, 0x1144 };
+
+const unsigned masks_start[] = { 0u, 18u, 858u };
+
+const unsigned masks_end[] = { 18u, 858u, 141978u };
+} // namespace detail
+} // namespace kitty
+  /*! \endcond */
\ No newline at end of file
diff --git a/lib/kitty/kitty/detail/mscfix.hpp b/lib/kitty/kitty/detail/mscfix.hpp
new file mode 100644
index 0000000..d712a7f
--- /dev/null
+++ b/lib/kitty/kitty/detail/mscfix.hpp
@@ -0,0 +1,39 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file mscfix.hpp
+  \brief Fixes some compatibility issues with MS VC compilers
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+// Use Windows popcount version where appropriate
+#ifdef _MSC_VER
+#include <intrin.h>
+#define __builtin_popcount __popcnt
+#endif
\ No newline at end of file
diff --git a/lib/kitty/kitty/detail/shift.hpp b/lib/kitty/kitty/detail/shift.hpp
new file mode 100644
index 0000000..a5d7086
--- /dev/null
+++ b/lib/kitty/kitty/detail/shift.hpp
@@ -0,0 +1,1002 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file shift.hpp
+  \brief Shift helper functions
+
+  \author Mathias Soeken
+*/
+
+/*! \cond PRIVATE */
+#pragma once
+
+#include <cassert>
+#include <cstdint>
+
+namespace kitty
+{
+namespace detail
+{
+
+// This code has been auto-generated by Nikolaj Bjorner
+// https://github.com/NikolajBjorner/z3/blob/17a256eca1a375f023bb98c3e4e728845d92dfb2/src/ast/expr_network.cpp#L22
+inline uint64_t compute_shift( uint64_t x, unsigned code )
+{
+  switch ( code )
+  {
+#define _x0 ( x & 1 )
+#define _x1 _x0
+  case 1:
+    return _x1;
+#define _x2 ( _x1 | ( _x1 << 1 ) )
+  case 2:
+    return _x2;
+#define _x3 ( x & 3 )
+#define _x4 _x3
+  case 3:
+    return _x4;
+#define _x5 ( _x2 | ( _x2 << 2 ) )
+  case 4:
+    return _x5;
+#define _x6 ( _x4 | ( _x4 << 2 ) )
+  case 5:
+    return _x6;
+#define _x7 ( x & 2 )
+#define _x8 ( _x7 << 1 )
+#define _x9 ( _x8 | ( _x8 << 1 ) )
+#define _x10 ( _x2 | _x9 )
+  case 6:
+    return _x10;
+#define _x11 ( x & 15 )
+#define _x12 _x11
+  case 7:
+    return _x12;
+#define _x13 ( _x5 | ( _x5 << 4 ) )
+  case 8:
+    return _x13;
+#define _x14 ( _x6 | ( _x6 << 4 ) )
+  case 9:
+    return _x14;
+#define _x15 ( _x10 | ( _x10 << 4 ) )
+  case 10:
+    return _x15;
+#define _x16 ( _x12 | ( _x12 << 4 ) )
+  case 11:
+    return _x16;
+#define _x17 ( _x7 << 3 )
+#define _x18 ( _x17 | ( _x17 << 1 ) )
+#define _x19 ( _x18 | ( _x18 << 2 ) )
+#define _x20 ( _x5 | _x19 )
+  case 12:
+    return _x20;
+#define _x21 ( x & 12 )
+#define _x22 ( _x21 << 2 )
+#define _x23 ( _x22 | ( _x22 << 2 ) )
+#define _x24 ( _x6 | _x23 )
+  case 13:
+    return _x24;
+#define _x25 ( x & 4 )
+#define _x26 ( _x25 << 2 )
+#define _x27 ( _x26 | ( _x26 << 1 ) )
+#define _x28 ( x & 8 )
+#define _x29 ( _x28 << 3 )
+#define _x30 ( _x29 | ( _x29 << 1 ) )
+#define _x31 ( _x27 | _x30 )
+#define _x32 ( _x10 | _x31 )
+  case 14:
+    return _x32;
+#define _x33 ( x & 255 )
+#define _x34 _x33
+  case 15:
+    return _x34;
+#define _x35 ( _x13 | ( _x13 << 8 ) )
+  case 16:
+    return _x35;
+#define _x36 ( _x14 | ( _x14 << 8 ) )
+  case 17:
+    return _x36;
+#define _x37 ( _x15 | ( _x15 << 8 ) )
+  case 18:
+    return _x37;
+#define _x38 ( _x16 | ( _x16 << 8 ) )
+  case 19:
+    return _x38;
+#define _x39 ( _x20 | ( _x20 << 8 ) )
+  case 20:
+    return _x39;
+#define _x40 ( _x24 | ( _x24 << 8 ) )
+  case 21:
+    return _x40;
+#define _x41 ( _x32 | ( _x32 << 8 ) )
+  case 22:
+    return _x41;
+#define _x42 ( _x34 | ( _x34 << 8 ) )
+  case 23:
+    return _x42;
+#define _x43 ( _x7 << 7 )
+#define _x44 ( _x43 | ( _x43 << 1 ) )
+#define _x45 ( _x44 | ( _x44 << 2 ) )
+#define _x46 ( _x45 | ( _x45 << 4 ) )
+#define _x47 ( _x13 | _x46 )
+  case 24:
+    return _x47;
+#define _x48 ( _x21 << 6 )
+#define _x49 ( _x48 | ( _x48 << 2 ) )
+#define _x50 ( _x49 | ( _x49 << 4 ) )
+#define _x51 ( _x14 | _x50 )
+  case 25:
+    return _x51;
+#define _x52 ( _x25 << 6 )
+#define _x53 ( _x52 | ( _x52 << 1 ) )
+#define _x54 ( _x28 << 7 )
+#define _x55 ( _x54 | ( _x54 << 1 ) )
+#define _x56 ( _x53 | _x55 )
+#define _x57 ( _x56 | ( _x56 << 4 ) )
+#define _x58 ( _x15 | _x57 )
+  case 26:
+    return _x58;
+#define _x59 ( x & 240 )
+#define _x60 ( _x59 << 4 )
+#define _x61 ( _x60 | ( _x60 << 4 ) )
+#define _x62 ( _x16 | _x61 )
+  case 27:
+    return _x62;
+#define _x63 ( _x53 | ( _x53 << 2 ) )
+#define _x64 ( _x28 << 9 )
+#define _x65 ( _x64 | ( _x64 << 1 ) )
+#define _x66 ( _x65 | ( _x65 << 2 ) )
+#define _x67 ( _x63 | _x66 )
+#define _x68 ( _x20 | _x67 )
+  case 28:
+    return _x68;
+#define _x69 ( x & 48 )
+#define _x70 ( _x69 << 4 )
+#define _x71 ( _x70 | ( _x70 << 2 ) )
+#define _x72 ( x & 192 )
+#define _x73 ( _x72 << 6 )
+#define _x74 ( _x73 | ( _x73 << 2 ) )
+#define _x75 ( _x71 | _x74 )
+#define _x76 ( _x24 | _x75 )
+  case 29:
+    return _x76;
+#define _x77 ( x & 16 )
+#define _x78 ( _x77 << 4 )
+#define _x79 ( _x78 | ( _x78 << 1 ) )
+#define _x80 ( x & 32 )
+#define _x81 ( _x80 << 5 )
+#define _x82 ( _x81 | ( _x81 << 1 ) )
+#define _x83 ( _x79 | _x82 )
+#define _x84 ( x & 64 )
+#define _x85 ( _x84 << 6 )
+#define _x86 ( _x85 | ( _x85 << 1 ) )
+#define _x87 ( x & 128 )
+#define _x88 ( _x87 << 7 )
+#define _x89 ( _x88 | ( _x88 << 1 ) )
+#define _x90 ( _x86 | _x89 )
+#define _x91 ( _x83 | _x90 )
+#define _x92 ( _x32 | _x91 )
+  case 30:
+    return _x92;
+#define _x93 ( x & 65535 )
+#define _x94 _x93
+  case 31:
+    return _x94;
+#define _x95 ( _x35 | ( _x35 << 16 ) )
+  case 32:
+    return _x95;
+#define _x96 ( _x36 | ( _x36 << 16 ) )
+  case 33:
+    return _x96;
+#define _x97 ( _x37 | ( _x37 << 16 ) )
+  case 34:
+    return _x97;
+#define _x98 ( _x38 | ( _x38 << 16 ) )
+  case 35:
+    return _x98;
+#define _x99 ( _x39 | ( _x39 << 16 ) )
+  case 36:
+    return _x99;
+#define _x100 ( _x40 | ( _x40 << 16 ) )
+  case 37:
+    return _x100;
+#define _x101 ( _x41 | ( _x41 << 16 ) )
+  case 38:
+    return _x101;
+#define _x102 ( _x42 | ( _x42 << 16 ) )
+  case 39:
+    return _x102;
+#define _x103 ( _x47 | ( _x47 << 16 ) )
+  case 40:
+    return _x103;
+#define _x104 ( _x51 | ( _x51 << 16 ) )
+  case 41:
+    return _x104;
+#define _x105 ( _x58 | ( _x58 << 16 ) )
+  case 42:
+    return _x105;
+#define _x106 ( _x62 | ( _x62 << 16 ) )
+  case 43:
+    return _x106;
+#define _x107 ( _x68 | ( _x68 << 16 ) )
+  case 44:
+    return _x107;
+#define _x108 ( _x76 | ( _x76 << 16 ) )
+  case 45:
+    return _x108;
+#define _x109 ( _x92 | ( _x92 << 16 ) )
+  case 46:
+    return _x109;
+#define _x110 ( _x94 | ( _x94 << 16 ) )
+  case 47:
+    return _x110;
+#define _x111 ( _x7 << 15 )
+#define _x112 ( _x111 | ( _x111 << 1 ) )
+#define _x113 ( _x112 | ( _x112 << 2 ) )
+#define _x114 ( _x113 | ( _x113 << 4 ) )
+#define _x115 ( _x114 | ( _x114 << 8 ) )
+#define _x116 ( _x35 | _x115 )
+  case 48:
+    return _x116;
+#define _x117 ( _x21 << 14 )
+#define _x118 ( _x117 | ( _x117 << 2 ) )
+#define _x119 ( _x118 | ( _x118 << 4 ) )
+#define _x120 ( _x119 | ( _x119 << 8 ) )
+#define _x121 ( _x36 | _x120 )
+  case 49:
+    return _x121;
+#define _x122 ( _x25 << 14 )
+#define _x123 ( _x122 | ( _x122 << 1 ) )
+#define _x124 ( _x28 << 15 )
+#define _x125 ( _x124 | ( _x124 << 1 ) )
+#define _x126 ( _x123 | _x125 )
+#define _x127 ( _x126 | ( _x126 << 4 ) )
+#define _x128 ( _x127 | ( _x127 << 8 ) )
+#define _x129 ( _x37 | _x128 )
+  case 50:
+    return _x129;
+#define _x130 ( _x59 << 12 )
+#define _x131 ( _x130 | ( _x130 << 4 ) )
+#define _x132 ( _x131 | ( _x131 << 8 ) )
+#define _x133 ( _x38 | _x132 )
+  case 51:
+    return _x133;
+#define _x134 ( _x123 | ( _x123 << 2 ) )
+#define _x135 ( _x28 << 17 )
+#define _x136 ( _x135 | ( _x135 << 1 ) )
+#define _x137 ( _x136 | ( _x136 << 2 ) )
+#define _x138 ( _x134 | _x137 )
+#define _x139 ( _x138 | ( _x138 << 8 ) )
+#define _x140 ( _x39 | _x139 )
+  case 52:
+    return _x140;
+#define _x141 ( _x69 << 12 )
+#define _x142 ( _x141 | ( _x141 << 2 ) )
+#define _x143 ( _x72 << 14 )
+#define _x144 ( _x143 | ( _x143 << 2 ) )
+#define _x145 ( _x142 | _x144 )
+#define _x146 ( _x145 | ( _x145 << 8 ) )
+#define _x147 ( _x40 | _x146 )
+  case 53:
+    return _x147;
+#define _x148 ( _x77 << 12 )
+#define _x149 ( _x148 | ( _x148 << 1 ) )
+#define _x150 ( _x80 << 13 )
+#define _x151 ( _x150 | ( _x150 << 1 ) )
+#define _x152 ( _x149 | _x151 )
+#define _x153 ( _x84 << 14 )
+#define _x154 ( _x153 | ( _x153 << 1 ) )
+#define _x155 ( _x87 << 15 )
+#define _x156 ( _x155 | ( _x155 << 1 ) )
+#define _x157 ( _x154 | _x156 )
+#define _x158 ( _x152 | _x157 )
+#define _x159 ( _x158 | ( _x158 << 8 ) )
+#define _x160 ( _x41 | _x159 )
+  case 54:
+    return _x160;
+#define _x161 ( x & 65280 )
+#define _x162 ( _x161 << 8 )
+#define _x163 ( _x162 | ( _x162 << 8 ) )
+#define _x164 ( _x42 | _x163 )
+  case 55:
+    return _x164;
+#define _x165 ( _x134 | ( _x134 << 4 ) )
+#define _x166 ( _x28 << 21 )
+#define _x167 ( _x166 | ( _x166 << 1 ) )
+#define _x168 ( _x167 | ( _x167 << 2 ) )
+#define _x169 ( _x168 | ( _x168 << 4 ) )
+#define _x170 ( _x165 | _x169 )
+#define _x171 ( _x47 | _x170 )
+  case 56:
+    return _x171;
+#define _x172 ( _x142 | ( _x142 << 4 ) )
+#define _x173 ( _x72 << 18 )
+#define _x174 ( _x173 | ( _x173 << 2 ) )
+#define _x175 ( _x174 | ( _x174 << 4 ) )
+#define _x176 ( _x172 | _x175 )
+#define _x177 ( _x51 | _x176 )
+  case 57:
+    return _x177;
+#define _x178 ( _x152 | ( _x152 << 4 ) )
+#define _x179 ( _x84 << 18 )
+#define _x180 ( _x179 | ( _x179 << 1 ) )
+#define _x181 ( _x87 << 19 )
+#define _x182 ( _x181 | ( _x181 << 1 ) )
+#define _x183 ( _x180 | _x182 )
+#define _x184 ( _x183 | ( _x183 << 4 ) )
+#define _x185 ( _x178 | _x184 )
+#define _x186 ( _x58 | _x185 )
+  case 58:
+    return _x186;
+#define _x187 ( x & 3840 )
+#define _x188 ( _x187 << 8 )
+#define _x189 ( _x188 | ( _x188 << 4 ) )
+#define _x190 ( x & 61440 )
+#define _x191 ( _x190 << 12 )
+#define _x192 ( _x191 | ( _x191 << 4 ) )
+#define _x193 ( _x189 | _x192 )
+#define _x194 ( _x62 | _x193 )
+  case 59:
+    return _x194;
+#define _x195 ( _x149 | ( _x149 << 2 ) )
+#define _x196 ( _x80 << 15 )
+#define _x197 ( _x196 | ( _x196 << 1 ) )
+#define _x198 ( _x197 | ( _x197 << 2 ) )
+#define _x199 ( _x195 | _x198 )
+#define _x200 ( _x180 | ( _x180 << 2 ) )
+#define _x201 ( _x87 << 21 )
+#define _x202 ( _x201 | ( _x201 << 1 ) )
+#define _x203 ( _x202 | ( _x202 << 2 ) )
+#define _x204 ( _x200 | _x203 )
+#define _x205 ( _x199 | _x204 )
+#define _x206 ( _x68 | _x205 )
+  case 60:
+    return _x206;
+#define _x207 ( x & 768 )
+#define _x208 ( _x207 << 8 )
+#define _x209 ( _x208 | ( _x208 << 2 ) )
+#define _x210 ( x & 3072 )
+#define _x211 ( _x210 << 10 )
+#define _x212 ( _x211 | ( _x211 << 2 ) )
+#define _x213 ( _x209 | _x212 )
+#define _x214 ( x & 12288 )
+#define _x215 ( _x214 << 12 )
+#define _x216 ( _x215 | ( _x215 << 2 ) )
+#define _x217 ( x & 49152 )
+#define _x218 ( _x217 << 14 )
+#define _x219 ( _x218 | ( _x218 << 2 ) )
+#define _x220 ( _x216 | _x219 )
+#define _x221 ( _x213 | _x220 )
+#define _x222 ( _x76 | _x221 )
+  case 61:
+    return _x222;
+#define _x223 ( x & 256 )
+#define _x224 ( _x223 << 8 )
+#define _x225 ( _x224 | ( _x224 << 1 ) )
+#define _x226 ( x & 512 )
+#define _x227 ( _x226 << 9 )
+#define _x228 ( _x227 | ( _x227 << 1 ) )
+#define _x229 ( _x225 | _x228 )
+#define _x230 ( x & 1024 )
+#define _x231 ( _x230 << 10 )
+#define _x232 ( _x231 | ( _x231 << 1 ) )
+#define _x233 ( x & 2048 )
+#define _x234 ( _x233 << 11 )
+#define _x235 ( _x234 | ( _x234 << 1 ) )
+#define _x236 ( _x232 | _x235 )
+#define _x237 ( _x229 | _x236 )
+#define _x238 ( x & 4096 )
+#define _x239 ( _x238 << 12 )
+#define _x240 ( _x239 | ( _x239 << 1 ) )
+#define _x241 ( x & 8192 )
+#define _x242 ( _x241 << 13 )
+#define _x243 ( _x242 | ( _x242 << 1 ) )
+#define _x244 ( _x240 | _x243 )
+#define _x245 ( x & 16384 )
+#define _x246 ( _x245 << 14 )
+#define _x247 ( _x246 | ( _x246 << 1 ) )
+#define _x248 ( x & 32768 )
+#define _x249 ( _x248 << 15 )
+#define _x250 ( _x249 | ( _x249 << 1 ) )
+#define _x251 ( _x247 | _x250 )
+#define _x252 ( _x244 | _x251 )
+#define _x253 ( _x237 | _x252 )
+#define _x254 ( _x92 | _x253 )
+  case 62:
+    return _x254;
+#define _x255 ( x & 4294967295 )
+#define _x256 _x255
+  case 63:
+    return _x256;
+#define _x257 ( _x95 | ( _x95 << 32 ) )
+  case 64:
+    return _x257;
+#define _x258 ( _x96 | ( _x96 << 32 ) )
+  case 65:
+    return _x258;
+#define _x259 ( _x97 | ( _x97 << 32 ) )
+  case 66:
+    return _x259;
+#define _x260 ( _x98 | ( _x98 << 32 ) )
+  case 67:
+    return _x260;
+#define _x261 ( _x99 | ( _x99 << 32 ) )
+  case 68:
+    return _x261;
+#define _x262 ( _x100 | ( _x100 << 32 ) )
+  case 69:
+    return _x262;
+#define _x263 ( _x101 | ( _x101 << 32 ) )
+  case 70:
+    return _x263;
+#define _x264 ( _x102 | ( _x102 << 32 ) )
+  case 71:
+    return _x264;
+#define _x265 ( _x103 | ( _x103 << 32 ) )
+  case 72:
+    return _x265;
+#define _x266 ( _x104 | ( _x104 << 32 ) )
+  case 73:
+    return _x266;
+#define _x267 ( _x105 | ( _x105 << 32 ) )
+  case 74:
+    return _x267;
+#define _x268 ( _x106 | ( _x106 << 32 ) )
+  case 75:
+    return _x268;
+#define _x269 ( _x107 | ( _x107 << 32 ) )
+  case 76:
+    return _x269;
+#define _x270 ( _x108 | ( _x108 << 32 ) )
+  case 77:
+    return _x270;
+#define _x271 ( _x109 | ( _x109 << 32 ) )
+  case 78:
+    return _x271;
+#define _x272 ( _x110 | ( _x110 << 32 ) )
+  case 79:
+    return _x272;
+#define _x273 ( _x116 | ( _x116 << 32 ) )
+  case 80:
+    return _x273;
+#define _x274 ( _x121 | ( _x121 << 32 ) )
+  case 81:
+    return _x274;
+#define _x275 ( _x129 | ( _x129 << 32 ) )
+  case 82:
+    return _x275;
+#define _x276 ( _x133 | ( _x133 << 32 ) )
+  case 83:
+    return _x276;
+#define _x277 ( _x140 | ( _x140 << 32 ) )
+  case 84:
+    return _x277;
+#define _x278 ( _x147 | ( _x147 << 32 ) )
+  case 85:
+    return _x278;
+#define _x279 ( _x160 | ( _x160 << 32 ) )
+  case 86:
+    return _x279;
+#define _x280 ( _x164 | ( _x164 << 32 ) )
+  case 87:
+    return _x280;
+#define _x281 ( _x171 | ( _x171 << 32 ) )
+  case 88:
+    return _x281;
+#define _x282 ( _x177 | ( _x177 << 32 ) )
+  case 89:
+    return _x282;
+#define _x283 ( _x186 | ( _x186 << 32 ) )
+  case 90:
+    return _x283;
+#define _x284 ( _x194 | ( _x194 << 32 ) )
+  case 91:
+    return _x284;
+#define _x285 ( _x206 | ( _x206 << 32 ) )
+  case 92:
+    return _x285;
+#define _x286 ( _x222 | ( _x222 << 32 ) )
+  case 93:
+    return _x286;
+#define _x287 ( _x254 | ( _x254 << 32 ) )
+  case 94:
+    return _x287;
+#define _x288 ( _x256 | ( _x256 << 32 ) )
+  case 95:
+    return _x288;
+#define _x289 ( _x7 << 31 )
+#define _x290 ( _x289 | ( _x289 << 1 ) )
+#define _x291 ( _x290 | ( _x290 << 2 ) )
+#define _x292 ( _x291 | ( _x291 << 4 ) )
+#define _x293 ( _x292 | ( _x292 << 8 ) )
+#define _x294 ( _x293 | ( _x293 << 16 ) )
+#define _x295 ( _x95 | _x294 )
+  case 96:
+    return _x295;
+#define _x296 ( _x21 << 30 )
+#define _x297 ( _x296 | ( _x296 << 2 ) )
+#define _x298 ( _x297 | ( _x297 << 4 ) )
+#define _x299 ( _x298 | ( _x298 << 8 ) )
+#define _x300 ( _x299 | ( _x299 << 16 ) )
+#define _x301 ( _x96 | _x300 )
+  case 97:
+    return _x301;
+#define _x302 ( _x25 << 30 )
+#define _x303 ( _x302 | ( _x302 << 1 ) )
+#define _x304 ( _x28 << 31 )
+#define _x305 ( _x304 | ( _x304 << 1 ) )
+#define _x306 ( _x303 | _x305 )
+#define _x307 ( _x306 | ( _x306 << 4 ) )
+#define _x308 ( _x307 | ( _x307 << 8 ) )
+#define _x309 ( _x308 | ( _x308 << 16 ) )
+#define _x310 ( _x97 | _x309 )
+  case 98:
+    return _x310;
+#define _x311 ( _x59 << 28 )
+#define _x312 ( _x311 | ( _x311 << 4 ) )
+#define _x313 ( _x312 | ( _x312 << 8 ) )
+#define _x314 ( _x313 | ( _x313 << 16 ) )
+#define _x315 ( _x98 | _x314 )
+  case 99:
+    return _x315;
+#define _x316 ( _x303 | ( _x303 << 2 ) )
+#define _x317 ( _x28 << 33 )
+#define _x318 ( _x317 | ( _x317 << 1 ) )
+#define _x319 ( _x318 | ( _x318 << 2 ) )
+#define _x320 ( _x316 | _x319 )
+#define _x321 ( _x320 | ( _x320 << 8 ) )
+#define _x322 ( _x321 | ( _x321 << 16 ) )
+#define _x323 ( _x99 | _x322 )
+  case 100:
+    return _x323;
+#define _x324 ( _x69 << 28 )
+#define _x325 ( _x324 | ( _x324 << 2 ) )
+#define _x326 ( _x72 << 30 )
+#define _x327 ( _x326 | ( _x326 << 2 ) )
+#define _x328 ( _x325 | _x327 )
+#define _x329 ( _x328 | ( _x328 << 8 ) )
+#define _x330 ( _x329 | ( _x329 << 16 ) )
+#define _x331 ( _x100 | _x330 )
+  case 101:
+    return _x331;
+#define _x332 ( _x77 << 28 )
+#define _x333 ( _x332 | ( _x332 << 1 ) )
+#define _x334 ( _x80 << 29 )
+#define _x335 ( _x334 | ( _x334 << 1 ) )
+#define _x336 ( _x333 | _x335 )
+#define _x337 ( _x84 << 30 )
+#define _x338 ( _x337 | ( _x337 << 1 ) )
+#define _x339 ( _x87 << 31 )
+#define _x340 ( _x339 | ( _x339 << 1 ) )
+#define _x341 ( _x338 | _x340 )
+#define _x342 ( _x336 | _x341 )
+#define _x343 ( _x342 | ( _x342 << 8 ) )
+#define _x344 ( _x343 | ( _x343 << 16 ) )
+#define _x345 ( _x101 | _x344 )
+  case 102:
+    return _x345;
+#define _x346 ( _x161 << 24 )
+#define _x347 ( _x346 | ( _x346 << 8 ) )
+#define _x348 ( _x347 | ( _x347 << 16 ) )
+#define _x349 ( _x102 | _x348 )
+  case 103:
+    return _x349;
+#define _x350 ( _x316 | ( _x316 << 4 ) )
+#define _x351 ( _x28 << 37 )
+#define _x352 ( _x351 | ( _x351 << 1 ) )
+#define _x353 ( _x352 | ( _x352 << 2 ) )
+#define _x354 ( _x353 | ( _x353 << 4 ) )
+#define _x355 ( _x350 | _x354 )
+#define _x356 ( _x355 | ( _x355 << 16 ) )
+#define _x357 ( _x103 | _x356 )
+  case 104:
+    return _x357;
+#define _x358 ( _x325 | ( _x325 << 4 ) )
+#define _x359 ( _x72 << 34 )
+#define _x360 ( _x359 | ( _x359 << 2 ) )
+#define _x361 ( _x360 | ( _x360 << 4 ) )
+#define _x362 ( _x358 | _x361 )
+#define _x363 ( _x362 | ( _x362 << 16 ) )
+#define _x364 ( _x104 | _x363 )
+  case 105:
+    return _x364;
+#define _x365 ( _x336 | ( _x336 << 4 ) )
+#define _x366 ( _x84 << 34 )
+#define _x367 ( _x366 | ( _x366 << 1 ) )
+#define _x368 ( _x87 << 35 )
+#define _x369 ( _x368 | ( _x368 << 1 ) )
+#define _x370 ( _x367 | _x369 )
+#define _x371 ( _x370 | ( _x370 << 4 ) )
+#define _x372 ( _x365 | _x371 )
+#define _x373 ( _x372 | ( _x372 << 16 ) )
+#define _x374 ( _x105 | _x373 )
+  case 106:
+    return _x374;
+#define _x375 ( _x187 << 24 )
+#define _x376 ( _x375 | ( _x375 << 4 ) )
+#define _x377 ( _x190 << 28 )
+#define _x378 ( _x377 | ( _x377 << 4 ) )
+#define _x379 ( _x376 | _x378 )
+#define _x380 ( _x379 | ( _x379 << 16 ) )
+#define _x381 ( _x106 | _x380 )
+  case 107:
+    return _x381;
+#define _x382 ( _x333 | ( _x333 << 2 ) )
+#define _x383 ( _x80 << 31 )
+#define _x384 ( _x383 | ( _x383 << 1 ) )
+#define _x385 ( _x384 | ( _x384 << 2 ) )
+#define _x386 ( _x382 | _x385 )
+#define _x387 ( _x367 | ( _x367 << 2 ) )
+#define _x388 ( _x87 << 37 )
+#define _x389 ( _x388 | ( _x388 << 1 ) )
+#define _x390 ( _x389 | ( _x389 << 2 ) )
+#define _x391 ( _x387 | _x390 )
+#define _x392 ( _x386 | _x391 )
+#define _x393 ( _x392 | ( _x392 << 16 ) )
+#define _x394 ( _x107 | _x393 )
+  case 108:
+    return _x394;
+#define _x395 ( _x207 << 24 )
+#define _x396 ( _x395 | ( _x395 << 2 ) )
+#define _x397 ( _x210 << 26 )
+#define _x398 ( _x397 | ( _x397 << 2 ) )
+#define _x399 ( _x396 | _x398 )
+#define _x400 ( _x214 << 28 )
+#define _x401 ( _x400 | ( _x400 << 2 ) )
+#define _x402 ( _x217 << 30 )
+#define _x403 ( _x402 | ( _x402 << 2 ) )
+#define _x404 ( _x401 | _x403 )
+#define _x405 ( _x399 | _x404 )
+#define _x406 ( _x405 | ( _x405 << 16 ) )
+#define _x407 ( _x108 | _x406 )
+  case 109:
+    return _x407;
+#define _x408 ( _x223 << 24 )
+#define _x409 ( _x408 | ( _x408 << 1 ) )
+#define _x410 ( _x226 << 25 )
+#define _x411 ( _x410 | ( _x410 << 1 ) )
+#define _x412 ( _x409 | _x411 )
+#define _x413 ( _x230 << 26 )
+#define _x414 ( _x413 | ( _x413 << 1 ) )
+#define _x415 ( _x233 << 27 )
+#define _x416 ( _x415 | ( _x415 << 1 ) )
+#define _x417 ( _x414 | _x416 )
+#define _x418 ( _x412 | _x417 )
+#define _x419 ( _x238 << 28 )
+#define _x420 ( _x419 | ( _x419 << 1 ) )
+#define _x421 ( _x241 << 29 )
+#define _x422 ( _x421 | ( _x421 << 1 ) )
+#define _x423 ( _x420 | _x422 )
+#define _x424 ( _x245 << 30 )
+#define _x425 ( _x424 | ( _x424 << 1 ) )
+#define _x426 ( _x248 << 31 )
+#define _x427 ( _x426 | ( _x426 << 1 ) )
+#define _x428 ( _x425 | _x427 )
+#define _x429 ( _x423 | _x428 )
+#define _x430 ( _x418 | _x429 )
+#define _x431 ( _x430 | ( _x430 << 16 ) )
+#define _x432 ( _x109 | _x431 )
+  case 110:
+    return _x432;
+#define _x433 ( x & 4294901760 )
+#define _x434 ( _x433 << 16 )
+#define _x435 ( _x434 | ( _x434 << 16 ) )
+#define _x436 ( _x110 | _x435 )
+  case 111:
+    return _x436;
+#define _x437 ( _x350 | ( _x350 << 8 ) )
+#define _x438 ( _x28 << 45 )
+#define _x439 ( _x438 | ( _x438 << 1 ) )
+#define _x440 ( _x439 | ( _x439 << 2 ) )
+#define _x441 ( _x440 | ( _x440 << 4 ) )
+#define _x442 ( _x441 | ( _x441 << 8 ) )
+#define _x443 ( _x437 | _x442 )
+#define _x444 ( _x116 | _x443 )
+  case 112:
+    return _x444;
+#define _x445 ( _x358 | ( _x358 << 8 ) )
+#define _x446 ( _x72 << 42 )
+#define _x447 ( _x446 | ( _x446 << 2 ) )
+#define _x448 ( _x447 | ( _x447 << 4 ) )
+#define _x449 ( _x448 | ( _x448 << 8 ) )
+#define _x450 ( _x445 | _x449 )
+#define _x451 ( _x121 | _x450 )
+  case 113:
+    return _x451;
+#define _x452 ( _x365 | ( _x365 << 8 ) )
+#define _x453 ( _x84 << 42 )
+#define _x454 ( _x453 | ( _x453 << 1 ) )
+#define _x455 ( _x87 << 43 )
+#define _x456 ( _x455 | ( _x455 << 1 ) )
+#define _x457 ( _x454 | _x456 )
+#define _x458 ( _x457 | ( _x457 << 4 ) )
+#define _x459 ( _x458 | ( _x458 << 8 ) )
+#define _x460 ( _x452 | _x459 )
+#define _x461 ( _x129 | _x460 )
+  case 114:
+    return _x461;
+#define _x462 ( _x376 | ( _x376 << 8 ) )
+#define _x463 ( _x190 << 36 )
+#define _x464 ( _x463 | ( _x463 << 4 ) )
+#define _x465 ( _x464 | ( _x464 << 8 ) )
+#define _x466 ( _x462 | _x465 )
+#define _x467 ( _x133 | _x466 )
+  case 115:
+    return _x467;
+#define _x468 ( _x386 | ( _x386 << 8 ) )
+#define _x469 ( _x454 | ( _x454 << 2 ) )
+#define _x470 ( _x87 << 45 )
+#define _x471 ( _x470 | ( _x470 << 1 ) )
+#define _x472 ( _x471 | ( _x471 << 2 ) )
+#define _x473 ( _x469 | _x472 )
+#define _x474 ( _x473 | ( _x473 << 8 ) )
+#define _x475 ( _x468 | _x474 )
+#define _x476 ( _x140 | _x475 )
+  case 116:
+    return _x476;
+#define _x477 ( _x399 | ( _x399 << 8 ) )
+#define _x478 ( _x214 << 36 )
+#define _x479 ( _x478 | ( _x478 << 2 ) )
+#define _x480 ( _x217 << 38 )
+#define _x481 ( _x480 | ( _x480 << 2 ) )
+#define _x482 ( _x479 | _x481 )
+#define _x483 ( _x482 | ( _x482 << 8 ) )
+#define _x484 ( _x477 | _x483 )
+#define _x485 ( _x147 | _x484 )
+  case 117:
+    return _x485;
+#define _x486 ( _x418 | ( _x418 << 8 ) )
+#define _x487 ( _x238 << 36 )
+#define _x488 ( _x487 | ( _x487 << 1 ) )
+#define _x489 ( _x241 << 37 )
+#define _x490 ( _x489 | ( _x489 << 1 ) )
+#define _x491 ( _x488 | _x490 )
+#define _x492 ( _x245 << 38 )
+#define _x493 ( _x492 | ( _x492 << 1 ) )
+#define _x494 ( _x248 << 39 )
+#define _x495 ( _x494 | ( _x494 << 1 ) )
+#define _x496 ( _x493 | _x495 )
+#define _x497 ( _x491 | _x496 )
+#define _x498 ( _x497 | ( _x497 << 8 ) )
+#define _x499 ( _x486 | _x498 )
+#define _x500 ( _x160 | _x499 )
+  case 118:
+    return _x500;
+#define _x501 ( x & 16711680 )
+#define _x502 ( _x501 << 16 )
+#define _x503 ( _x502 | ( _x502 << 8 ) )
+#define _x504 ( x & 4278190080 )
+#define _x505 ( _x504 << 24 )
+#define _x506 ( _x505 | ( _x505 << 8 ) )
+#define _x507 ( _x503 | _x506 )
+#define _x508 ( _x164 | _x507 )
+  case 119:
+    return _x508;
+#define _x509 ( _x382 | ( _x382 << 4 ) )
+#define _x510 ( _x80 << 35 )
+#define _x511 ( _x510 | ( _x510 << 1 ) )
+#define _x512 ( _x511 | ( _x511 << 2 ) )
+#define _x513 ( _x512 | ( _x512 << 4 ) )
+#define _x514 ( _x509 | _x513 )
+#define _x515 ( _x469 | ( _x469 << 4 ) )
+#define _x516 ( _x87 << 49 )
+#define _x517 ( _x516 | ( _x516 << 1 ) )
+#define _x518 ( _x517 | ( _x517 << 2 ) )
+#define _x519 ( _x518 | ( _x518 << 4 ) )
+#define _x520 ( _x515 | _x519 )
+#define _x521 ( _x514 | _x520 )
+#define _x522 ( _x171 | _x521 )
+  case 120:
+    return _x522;
+#define _x523 ( _x396 | ( _x396 << 4 ) )
+#define _x524 ( _x210 << 30 )
+#define _x525 ( _x524 | ( _x524 << 2 ) )
+#define _x526 ( _x525 | ( _x525 << 4 ) )
+#define _x527 ( _x523 | _x526 )
+#define _x528 ( _x479 | ( _x479 << 4 ) )
+#define _x529 ( _x217 << 42 )
+#define _x530 ( _x529 | ( _x529 << 2 ) )
+#define _x531 ( _x530 | ( _x530 << 4 ) )
+#define _x532 ( _x528 | _x531 )
+#define _x533 ( _x527 | _x532 )
+#define _x534 ( _x177 | _x533 )
+  case 121:
+    return _x534;
+#define _x535 ( _x412 | ( _x412 << 4 ) )
+#define _x536 ( _x230 << 30 )
+#define _x537 ( _x536 | ( _x536 << 1 ) )
+#define _x538 ( _x233 << 31 )
+#define _x539 ( _x538 | ( _x538 << 1 ) )
+#define _x540 ( _x537 | _x539 )
+#define _x541 ( _x540 | ( _x540 << 4 ) )
+#define _x542 ( _x535 | _x541 )
+#define _x543 ( _x491 | ( _x491 << 4 ) )
+#define _x544 ( _x245 << 42 )
+#define _x545 ( _x544 | ( _x544 << 1 ) )
+#define _x546 ( _x248 << 43 )
+#define _x547 ( _x546 | ( _x546 << 1 ) )
+#define _x548 ( _x545 | _x547 )
+#define _x549 ( _x548 | ( _x548 << 4 ) )
+#define _x550 ( _x543 | _x549 )
+#define _x551 ( _x542 | _x550 )
+#define _x552 ( _x186 | _x551 )
+  case 122:
+    return _x552;
+#define _x553 ( x & 983040 )
+#define _x554 ( _x553 << 16 )
+#define _x555 ( _x554 | ( _x554 << 4 ) )
+#define _x556 ( x & 15728640 )
+#define _x557 ( _x556 << 20 )
+#define _x558 ( _x557 | ( _x557 << 4 ) )
+#define _x559 ( _x555 | _x558 )
+#define _x560 ( x & 251658240 )
+#define _x561 ( _x560 << 24 )
+#define _x562 ( _x561 | ( _x561 << 4 ) )
+#define _x563 ( x & 4026531840 )
+#define _x564 ( _x563 << 28 )
+#define _x565 ( _x564 | ( _x564 << 4 ) )
+#define _x566 ( _x562 | _x565 )
+#define _x567 ( _x559 | _x566 )
+#define _x568 ( _x194 | _x567 )
+  case 123:
+    return _x568;
+#define _x569 ( _x409 | ( _x409 << 2 ) )
+#define _x570 ( _x226 << 27 )
+#define _x571 ( _x570 | ( _x570 << 1 ) )
+#define _x572 ( _x571 | ( _x571 << 2 ) )
+#define _x573 ( _x569 | _x572 )
+#define _x574 ( _x537 | ( _x537 << 2 ) )
+#define _x575 ( _x233 << 33 )
+#define _x576 ( _x575 | ( _x575 << 1 ) )
+#define _x577 ( _x576 | ( _x576 << 2 ) )
+#define _x578 ( _x574 | _x577 )
+#define _x579 ( _x573 | _x578 )
+#define _x580 ( _x488 | ( _x488 << 2 ) )
+#define _x581 ( _x241 << 39 )
+#define _x582 ( _x581 | ( _x581 << 1 ) )
+#define _x583 ( _x582 | ( _x582 << 2 ) )
+#define _x584 ( _x580 | _x583 )
+#define _x585 ( _x545 | ( _x545 << 2 ) )
+#define _x586 ( _x248 << 45 )
+#define _x587 ( _x586 | ( _x586 << 1 ) )
+#define _x588 ( _x587 | ( _x587 << 2 ) )
+#define _x589 ( _x585 | _x588 )
+#define _x590 ( _x584 | _x589 )
+#define _x591 ( _x579 | _x590 )
+#define _x592 ( _x206 | _x591 )
+  case 124:
+    return _x592;
+#define _x593 ( x & 196608 )
+#define _x594 ( _x593 << 16 )
+#define _x595 ( _x594 | ( _x594 << 2 ) )
+#define _x596 ( x & 786432 )
+#define _x597 ( _x596 << 18 )
+#define _x598 ( _x597 | ( _x597 << 2 ) )
+#define _x599 ( _x595 | _x598 )
+#define _x600 ( x & 3145728 )
+#define _x601 ( _x600 << 20 )
+#define _x602 ( _x601 | ( _x601 << 2 ) )
+#define _x603 ( x & 12582912 )
+#define _x604 ( _x603 << 22 )
+#define _x605 ( _x604 | ( _x604 << 2 ) )
+#define _x606 ( _x602 | _x605 )
+#define _x607 ( _x599 | _x606 )
+#define _x608 ( x & 50331648 )
+#define _x609 ( _x608 << 24 )
+#define _x610 ( _x609 | ( _x609 << 2 ) )
+#define _x611 ( x & 201326592 )
+#define _x612 ( _x611 << 26 )
+#define _x613 ( _x612 | ( _x612 << 2 ) )
+#define _x614 ( _x610 | _x613 )
+#define _x615 ( x & 805306368 )
+#define _x616 ( _x615 << 28 )
+#define _x617 ( _x616 | ( _x616 << 2 ) )
+#define _x618 ( x & 3221225472 )
+#define _x619 ( _x618 << 30 )
+#define _x620 ( _x619 | ( _x619 << 2 ) )
+#define _x621 ( _x617 | _x620 )
+#define _x622 ( _x614 | _x621 )
+#define _x623 ( _x607 | _x622 )
+#define _x624 ( _x222 | _x623 )
+  case 125:
+    return _x624;
+#define _x625 ( x & 65536 )
+#define _x626 ( _x625 << 16 )
+#define _x627 ( _x626 | ( _x626 << 1 ) )
+#define _x628 ( x & 131072 )
+#define _x629 ( _x628 << 17 )
+#define _x630 ( _x629 | ( _x629 << 1 ) )
+#define _x631 ( _x627 | _x630 )
+#define _x632 ( x & 262144 )
+#define _x633 ( _x632 << 18 )
+#define _x634 ( _x633 | ( _x633 << 1 ) )
+#define _x635 ( x & 524288 )
+#define _x636 ( _x635 << 19 )
+#define _x637 ( _x636 | ( _x636 << 1 ) )
+#define _x638 ( _x634 | _x637 )
+#define _x639 ( _x631 | _x638 )
+#define _x640 ( x & 1048576 )
+#define _x641 ( _x640 << 20 )
+#define _x642 ( _x641 | ( _x641 << 1 ) )
+#define _x643 ( x & 2097152 )
+#define _x644 ( _x643 << 21 )
+#define _x645 ( _x644 | ( _x644 << 1 ) )
+#define _x646 ( _x642 | _x645 )
+#define _x647 ( x & 4194304 )
+#define _x648 ( _x647 << 22 )
+#define _x649 ( _x648 | ( _x648 << 1 ) )
+#define _x650 ( x & 8388608 )
+#define _x651 ( _x650 << 23 )
+#define _x652 ( _x651 | ( _x651 << 1 ) )
+#define _x653 ( _x649 | _x652 )
+#define _x654 ( _x646 | _x653 )
+#define _x655 ( _x639 | _x654 )
+#define _x656 ( x & 16777216 )
+#define _x657 ( _x656 << 24 )
+#define _x658 ( _x657 | ( _x657 << 1 ) )
+#define _x659 ( x & 33554432 )
+#define _x660 ( _x659 << 25 )
+#define _x661 ( _x660 | ( _x660 << 1 ) )
+#define _x662 ( _x658 | _x661 )
+#define _x663 ( x & 67108864 )
+#define _x664 ( _x663 << 26 )
+#define _x665 ( _x664 | ( _x664 << 1 ) )
+#define _x666 ( x & 134217728 )
+#define _x667 ( _x666 << 27 )
+#define _x668 ( _x667 | ( _x667 << 1 ) )
+#define _x669 ( _x665 | _x668 )
+#define _x670 ( _x662 | _x669 )
+#define _x671 ( x & 268435456 )
+#define _x672 ( _x671 << 28 )
+#define _x673 ( _x672 | ( _x672 << 1 ) )
+#define _x674 ( x & 536870912 )
+#define _x675 ( _x674 << 29 )
+#define _x676 ( _x675 | ( _x675 << 1 ) )
+#define _x677 ( _x673 | _x676 )
+#define _x678 ( x & 1073741824 )
+#define _x679 ( _x678 << 30 )
+#define _x680 ( _x679 | ( _x679 << 1 ) )
+#define _x681 ( x & 2147483648 )
+#define _x682 ( _x681 << 31 )
+#define _x683 ( _x682 | ( _x682 << 1 ) )
+#define _x684 ( _x680 | _x683 )
+#define _x685 ( _x677 | _x684 )
+#define _x686 ( _x670 | _x685 )
+#define _x687 ( _x655 | _x686 )
+#define _x688 ( _x254 | _x687 )
+  case 126:
+    return _x688;
+  case 127:
+    return x;
+  default:
+    assert( false );
+    return 0;
+  }
+}
+
+} // namespace detail
+} // namespace kitty
+
+/*! \endcond */
\ No newline at end of file
diff --git a/lib/kitty/kitty/detail/utils.hpp b/lib/kitty/kitty/detail/utils.hpp
new file mode 100644
index 0000000..2def8cd
--- /dev/null
+++ b/lib/kitty/kitty/detail/utils.hpp
@@ -0,0 +1,85 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file utils.hpp
+  \brief Helper functions
+
+  \author Mathias Soeken
+*/
+
+/*! \cond PRIVATE */
+#pragma once
+
+#include <algorithm>
+#include <string>
+
+namespace kitty
+{
+
+namespace detail
+{
+
+/* string utils are from https://stackoverflow.com/a/217605 */
+inline void ltrim( std::string& s )
+{
+  s.erase( s.begin(), std::find_if( s.begin(), s.end(), []( int ch )
+                                    { return std::isspace( ch ) == 0; } ) );
+}
+
+inline void rtrim( std::string& s )
+{
+  s.erase( std::find_if( s.rbegin(), s.rend(), []( int ch )
+                         { return std::isspace( ch ) == 0; } )
+               .base(),
+           s.end() );
+}
+
+inline void trim( std::string& s )
+{
+  ltrim( s );
+  rtrim( s );
+}
+
+inline std::string ltrim_copy( std::string s )
+{
+  ltrim( s );
+  return s;
+}
+
+inline std::string rtrim_copy( std::string s )
+{
+  rtrim( s );
+  return s;
+}
+
+inline std::string trim_copy( std::string s )
+{
+  trim( s );
+  return s;
+}
+} /* namespace detail */
+} /* namespace kitty */
+  /*! \endcond */
\ No newline at end of file
diff --git a/lib/kitty/kitty/dynamic_truth_table.hpp b/lib/kitty/kitty/dynamic_truth_table.hpp
new file mode 100644
index 0000000..8757960
--- /dev/null
+++ b/lib/kitty/kitty/dynamic_truth_table.hpp
@@ -0,0 +1,191 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file dynamic_truth_table.hpp
+  \brief Implements dynamic_truth_table
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <type_traits>
+#include <vector>
+
+#include "detail/constants.hpp"
+#include "traits.hpp"
+
+namespace kitty
+{
+
+/*! Truth table in which number of variables is known at runtime.
+ */
+struct dynamic_truth_table
+{
+  /*! Standard constructor.
+
+    The number of variables provided to the truth table can be
+    computed at runtime.  However, once the truth table is constructed
+    its number of variables cannot change anymore.
+
+    The constructor computes the number of blocks and resizes the
+    vector accordingly.
+
+    \param num_vars Number of variables
+  */
+  explicit dynamic_truth_table( uint32_t num_vars )
+      : _bits( ( num_vars <= 6 ) ? 1u : ( 1u << ( num_vars - 6 ) ) ),
+        _num_vars( num_vars )
+  {
+  }
+
+  /*! Empty constructor.
+
+    Creates an empty truth table. It has 0 variables, but no bits, i.e., it is
+    different from a truth table for the constant function.  This constructor is
+    only used for convenience, if algorithms require the existence of default
+    constructable classes.
+   */
+  dynamic_truth_table() : _num_vars( 0 ) {}
+
+  /*! Constructs a new dynamic truth table instance with the same number of variables. */
+  inline dynamic_truth_table construct() const
+  {
+    return dynamic_truth_table( _num_vars );
+  }
+
+  /*! Returns number of variables.
+   */
+  inline auto num_vars() const noexcept { return _num_vars; }
+
+  /*! Returns number of blocks.
+   */
+  inline auto num_blocks() const noexcept { return _bits.size(); }
+
+  /*! Returns number of bits.
+   */
+  inline auto num_bits() const noexcept { return uint64_t( 1 ) << _num_vars; }
+
+  /*! \brief Begin iterator to bits.
+   */
+  inline auto begin() noexcept { return _bits.begin(); }
+
+  /*! \brief End iterator to bits.
+   */
+  inline auto end() noexcept { return _bits.end(); }
+
+  /*! \brief Begin iterator to bits.
+   */
+  inline auto begin() const noexcept { return _bits.begin(); }
+
+  /*! \brief End iterator to bits.
+   */
+  inline auto end() const noexcept { return _bits.end(); }
+
+  /*! \brief Reverse begin iterator to bits.
+   */
+  inline auto rbegin() noexcept { return _bits.rbegin(); }
+
+  /*! \brief Reverse end iterator to bits.
+   */
+  inline auto rend() noexcept { return _bits.rend(); }
+
+  /*! \brief Constant begin iterator to bits.
+   */
+  inline auto cbegin() const noexcept { return _bits.cbegin(); }
+
+  /*! \brief Constant end iterator to bits.
+   */
+  inline auto cend() const noexcept { return _bits.cend(); }
+
+  /*! \brief Constant reverse begin iterator to bits.
+   */
+  inline auto crbegin() const noexcept { return _bits.crbegin(); }
+
+  /*! \brief Constant teverse end iterator to bits.
+   */
+  inline auto crend() const noexcept { return _bits.crend(); }
+
+  /*! \brief Assign other truth table.
+
+    This replaces the current truth table with another truth table.  The truth
+    table type has to be complete.  The vector of bits is resized accordingly.
+
+    \param other Other truth table
+  */
+  template<class TT, typename = std::enable_if_t<is_truth_table<TT>::value && is_complete_truth_table<TT>::value>>
+  dynamic_truth_table& operator=( const TT& other )
+  {
+    _bits.resize( other.num_blocks() );
+    std::copy( other.begin(), other.end(), begin() );
+    _num_vars = other.num_vars();
+
+    if ( _num_vars < 6 )
+    {
+      mask_bits();
+    }
+
+    return *this;
+  }
+
+  /*! Masks the number of valid truth table bits.
+
+    If the truth table has less than 6 variables, it may not use all
+    the bits.  This operation makes sure to zero out all non-valid
+    bits.
+  */
+  inline void mask_bits() noexcept
+  {
+    if ( _num_vars < 6 )
+    {
+      _bits[0u] &= detail::masks[_num_vars];
+    }
+  }
+
+  /*! \cond PRIVATE */
+public: /* fields */
+  std::vector<uint64_t> _bits;
+  uint32_t _num_vars;
+  /*! \endcond */
+};
+
+template<>
+struct is_truth_table<kitty::dynamic_truth_table> : std::true_type
+{
+};
+
+template<>
+struct is_complete_truth_table<kitty::dynamic_truth_table> : std::true_type
+{
+};
+
+template<>
+struct is_completely_specified_truth_table<kitty::dynamic_truth_table> : std::true_type
+{
+};
+
+} // namespace kitty
\ No newline at end of file
diff --git a/lib/kitty/kitty/enumeration.hpp b/lib/kitty/kitty/enumeration.hpp
new file mode 100644
index 0000000..102da83
--- /dev/null
+++ b/lib/kitty/kitty/enumeration.hpp
@@ -0,0 +1,105 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file enumeration.hpp
+  \brief Enumeration routines
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <stack>
+#include <vector>
+
+#include "operators.hpp"
+
+namespace kitty
+{
+
+/*! \brief Enumerate all representatives using 1-neighborhood search.
+
+  This function is based on Algorithm 4.2.1 in the PhD thesis
+  "Analysis of Affine Equivalent Boolean Functions for Cryptography"
+  by J.E. Fuller (Queensland University of Technology)
+
+  \param functions Vector must be initialized with single seed function, will
+                   contain all enumerated functions after call
+  \param canonization_fn A canonization function, which takes as input a truth
+                         table and returns a truth table
+*/
+template<class TT, class CanonizationFn>
+void fuller_neighborhood_enumeration( std::vector<TT>& functions, CanonizationFn&& canonization_fn )
+{
+  /* there must be one seed truth table given */
+  assert( functions.size() == 1u );
+
+  /* classify seed function */
+  functions.front() = canonization_fn( functions.front() );
+
+  /* get number of bits from seed truth table */
+  const auto num_bits = static_cast<uint64_t>( functions.front().num_bits() );
+  std::vector<TT> neighborhood( num_bits );
+  uint32_t num{ 1 };
+  std::stack<TT> stack;
+  stack.push( functions.front() );
+
+  while ( !stack.empty() )
+  {
+    const auto g = stack.top();
+    stack.pop();
+
+    /* Finding connecting classes */
+    for ( auto j = 0u; j < num_bits; ++j )
+    {
+      neighborhood[j] = g;
+      flip_bit( neighborhood[j], j );
+      neighborhood[j] = canonization_fn( neighborhood[j] );
+    }
+
+    for ( auto j = 0u; j < num_bits; ++j )
+    {
+      bool flag{ false };
+      for ( auto i = 0u; i < num; ++i )
+      {
+        if ( neighborhood[j] == functions[i] )
+        {
+          flag = true;
+          break;
+        }
+      }
+      if ( !flag )
+      {
+        ++num;
+        functions.push_back( neighborhood[j] );
+        stack.push( neighborhood[j] );
+      }
+    }
+  }
+}
+
+} /* namespace kitty */
\ No newline at end of file
diff --git a/lib/kitty/kitty/esop.hpp b/lib/kitty/kitty/esop.hpp
new file mode 100644
index 0000000..6cf98ba
--- /dev/null
+++ b/lib/kitty/kitty/esop.hpp
@@ -0,0 +1,349 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file esop.hpp
+  \brief Implements methods to compute exclusive sum-of-products (ESOP) representations
+
+  \author Mathias Soeken
+  \author Winston Haaswijk
+*/
+
+#pragma once
+
+// #ifndef _MSC_VER
+// #warning "DEPRECATED: the functions in this file are marked as deprecated.  Most recent implementation can be found in https://github.com/hriener/easy/ in the file src/esop/constructors.hpp"
+// #endif
+
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "algorithm.hpp"
+#include "constructors.hpp"
+#include "cube.hpp"
+#include "hash.hpp"
+#include "operations.hpp"
+#include "operators.hpp"
+#include "traits.hpp"
+
+namespace kitty
+{
+
+/*! \cond PRIVATE */
+namespace detail
+{
+
+enum class pkrm_decomposition
+{
+  positive_davio,
+  negative_davio,
+  shannon
+};
+
+template<typename TT>
+using expansion_cache = std::unordered_map<TT, std::pair<uint32_t, pkrm_decomposition>, hash<TT>>;
+
+template<typename TT>
+uint32_t find_pkrm_expansions( const TT& tt, expansion_cache<TT>& cache, uint8_t var_index )
+{
+  /* terminal cases */
+  if ( is_const0( tt ) )
+  {
+    return 0;
+  }
+  if ( is_const0( ~tt ) )
+  {
+    return 1;
+  }
+
+  /* already computed */
+  const auto it = cache.find( tt );
+  if ( it != cache.end() )
+  {
+    return it->second.first;
+  }
+
+  const auto tt0 = cofactor0( tt, var_index );
+  const auto tt1 = cofactor1( tt, var_index );
+
+  const auto ex0 = find_pkrm_expansions( tt0, cache, var_index + 1 );
+  const auto ex1 = find_pkrm_expansions( tt1, cache, var_index + 1 );
+  const auto ex2 = find_pkrm_expansions( tt0 ^ tt1, cache, var_index + 1 );
+
+  const auto ex_max = std::max( std::max( ex0, ex1 ), ex2 );
+
+  uint32_t cost{};
+  pkrm_decomposition decomp;
+
+  if ( ex_max == ex0 )
+  {
+    cost = ex1 + ex2;
+    decomp = pkrm_decomposition::positive_davio;
+  }
+  else if ( ex_max == ex1 )
+  {
+    cost = ex0 + ex2;
+    decomp = pkrm_decomposition::negative_davio;
+  }
+  else
+  {
+    cost = ex0 + ex1;
+    decomp = pkrm_decomposition::shannon;
+  }
+  cache.insert( { tt, { cost, decomp } } );
+  return cost;
+}
+
+inline void add_to_cubes( std::unordered_set<cube, hash<cube>>& pkrm, const cube& c, bool distance_one_merging = true )
+{
+  /* first check whether cube is already contained; if so, delete it */
+  const auto it = pkrm.find( c );
+  if ( it != pkrm.end() )
+  {
+    pkrm.erase( it );
+    return;
+  }
+
+  /* otherwise, check if there is a distance-1 cube; if so, merge it */
+  if ( distance_one_merging )
+  {
+    for ( auto it = pkrm.begin(); it != pkrm.end(); ++it )
+    {
+      if ( c.distance( *it ) == 1 )
+      {
+        auto new_cube = c.merge( *it );
+        pkrm.erase( it );
+        add_to_cubes( pkrm, new_cube );
+        return;
+      }
+    }
+  }
+
+  /* otherwise, just add the cube */
+  pkrm.insert( c );
+}
+
+inline cube with_literal( const cube& c, uint8_t var_index, bool polarity )
+{
+  auto copy = c;
+  copy.add_literal( var_index, polarity );
+  return copy;
+}
+
+template<typename TT>
+void optimum_pkrm_rec( std::unordered_set<cube, hash<cube>>& pkrm, const TT& tt, const expansion_cache<TT>& cache, uint8_t var_index, const cube& c )
+{
+  /* terminal cases */
+  if ( is_const0( tt ) )
+  {
+    return;
+  }
+  if ( is_const0( ~tt ) )
+  {
+    add_to_cubes( pkrm, c );
+    return;
+  }
+
+  const auto& p = cache.at( tt );
+
+  const auto tt0 = cofactor0( tt, var_index );
+  const auto tt1 = cofactor1( tt, var_index );
+
+  switch ( p.second )
+  {
+  case pkrm_decomposition::positive_davio:
+    optimum_pkrm_rec( pkrm, tt0, cache, var_index + 1, c );
+    optimum_pkrm_rec( pkrm, tt0 ^ tt1, cache, var_index + 1, with_literal( c, var_index, true ) );
+    break;
+  case pkrm_decomposition::negative_davio:
+    optimum_pkrm_rec( pkrm, tt1, cache, var_index + 1, c );
+    optimum_pkrm_rec( pkrm, tt0 ^ tt1, cache, var_index + 1, with_literal( c, var_index, false ) );
+    break;
+  case pkrm_decomposition::shannon:
+    optimum_pkrm_rec( pkrm, tt0, cache, var_index + 1, with_literal( c, var_index, false ) );
+    optimum_pkrm_rec( pkrm, tt1, cache, var_index + 1, with_literal( c, var_index, true ) );
+    break;
+  }
+}
+
+template<typename TT>
+void esop_from_pprm_rec( std::unordered_set<cube, hash<cube>>& cubes, const TT& tt, uint8_t var_index, const cube& c )
+{
+  /* terminal cases */
+  if ( is_const0( tt ) )
+  {
+    return;
+  }
+  if ( is_const0( ~tt ) )
+  {
+    /* add to cubes, but do not apply distance-1 merging */
+    add_to_cubes( cubes, c, false );
+    return;
+  }
+
+  const auto tt0 = cofactor0( tt, var_index );
+  const auto tt1 = cofactor1( tt, var_index );
+
+  esop_from_pprm_rec( cubes, tt0, var_index + 1, c );
+  esop_from_pprm_rec( cubes, tt0 ^ tt1, var_index + 1, with_literal( c, var_index, true ) );
+}
+
+static constexpr uint64_t ANF1[] = { 0, 3, 2, 1 };
+static constexpr uint64_t ANF2[] = { 0, 15, 10, 5, 12, 3, 6, 9, 8, 7, 2, 13, 4, 11, 14, 1 };
+static constexpr uint64_t ANF3[] = { 0, 255, 170, 85, 204, 51, 102, 153, 136, 119, 34, 221, 68, 187, 238, 17, 240, 15, 90, 165, 60, 195, 150, 105, 120, 135, 210, 45, 180, 75, 30, 225, 160, 95, 10, 245, 108, 147, 198, 57, 40, 215, 130, 125, 228, 27, 78, 177, 80, 175, 250, 5, 156, 99, 54, 201, 216, 39, 114, 141, 20, 235, 190, 65, 192, 63, 106, 149, 12, 243, 166, 89, 72, 183, 226, 29, 132, 123, 46, 209, 48, 207, 154, 101, 252, 3, 86, 169, 184, 71, 18, 237, 116, 139, 222, 33, 96, 159, 202, 53, 172, 83, 6, 249, 232, 23, 66, 189, 36, 219, 142, 113, 144, 111, 58, 197, 92, 163, 246, 9, 24, 231, 178, 77, 212, 43, 126, 129, 128, 127, 42, 213, 76, 179, 230, 25, 8, 247, 162, 93, 196, 59, 110, 145, 112, 143, 218, 37, 188, 67, 22, 233, 248, 7, 82, 173, 52, 203, 158, 97, 32, 223, 138, 117, 236, 19, 70, 185, 168, 87, 2, 253, 100, 155, 206, 49, 208, 47, 122, 133, 28, 227, 182, 73, 88, 167, 242, 13, 148, 107, 62, 193, 64, 191, 234, 21, 140, 115, 38, 217, 200, 55, 98, 157, 4, 251, 174, 81, 176, 79, 26, 229, 124, 131, 214, 41, 56, 199, 146, 109, 244, 11, 94, 161, 224, 31, 74, 181, 44, 211, 134, 121, 104, 151, 194, 61, 164, 91, 14, 241, 16, 239, 186, 69, 220, 35, 118, 137, 152, 103, 50, 205, 84, 171, 254, 1 };
+
+template<class TT>
+TT algebraic_normal_form( const TT& func )
+{
+  switch ( func.num_vars() )
+  {
+  case 0:
+    return func;
+  case 1:
+  {
+    auto r = func.construct();
+    kitty::create_from_words( r, &ANF1[*func.begin()], &ANF1[*func.begin()] + 1 );
+    return r;
+  }
+  case 2:
+  {
+    auto r = func.construct();
+    kitty::create_from_words( r, &ANF2[*func.begin()], &ANF2[*func.begin()] + 1 );
+    return r;
+  }
+  case 3:
+  {
+    auto r = func.construct();
+    kitty::create_from_words( r, &ANF3[*func.begin()], &ANF3[*func.begin()] + 1 );
+    return r;
+  }
+  case 4:
+    return unary_operation( func, []( uint64_t word )
+                            {
+      const auto b0 = ANF3[word & 0x000000FF];
+      const auto b1 = ANF3[( word & 0x0000FF00 ) >> 8];
+
+      return b0 | ( ( b0 ^ b1 ) << 8 ); } );
+  case 5:
+    return unary_operation( func, []( uint64_t word )
+                            {
+      const auto b0 = ANF3[word & 0xFF];
+      const auto b1 = ANF3[( word >> 010 ) & 0xFF];
+      const auto b2 = ANF3[( word >> 020 ) & 0xFF];
+      const auto b3 = ANF3[( word >> 030 ) & 0xFF];
+
+      return b0 | ( ( b0 ^ b1 ) << 010 ) | ( ( b0 ^ b2 ) << 020 ) | ( ( b0 ^ b1 ^ b2 ^ b3 ) << 030 ); } );
+  default:
+    auto r = unary_operation( func, []( uint64_t word )
+                              {
+      const auto b0 = ANF3[word & 0xFF];
+      const auto b1 = ANF3[( word >> 010 ) & 0xFF];
+      const auto b2 = ANF3[( word >> 020 ) & 0xFF];
+      const auto b3 = ANF3[( word >> 030 ) & 0xFF];
+      const auto b4 = ANF3[( word >> 040 ) & 0xFF];
+      const auto b5 = ANF3[( word >> 050 ) & 0xFF];
+      const auto b6 = ANF3[( word >> 060 ) & 0xFF];
+      const auto b7 = ANF3[( word >> 070 ) & 0xFF];
+
+      return b0 |
+             ( ( b0 ^ b1 ) << 010 ) |
+             ( ( b0 ^ b2 ) << 020 ) |
+             ( ( b0 ^ b1 ^ b2 ^ b3 ) << 030 ) |
+             ( ( b0 ^ b4 ) << 040 ) |
+             ( ( b0 ^ b1 ^ b4 ^ b5 ) << 050 ) |
+             ( ( b0 ^ b2 ^ b4 ^ b6 ) << 060 ) |
+             ( ( b0 ^ b1 ^ b2 ^ b3 ^ b4 ^ b5 ^ b6 ^ b7 ) << 070 ); } );
+
+    for ( auto i = 1u; i < (uint32_t)func.num_blocks(); i = i << 1u )
+    {
+      for ( auto j = 0u; j < (uint32_t)func.num_blocks(); j += i << 1u )
+      {
+        for ( auto k = j; k < j + i; ++k )
+        {
+          *( r.begin() + k + i ) ^= *( r.begin() + k );
+        }
+      }
+    }
+
+    return r;
+  }
+}
+} // namespace detail
+/*! \endcond */
+
+/*! \brief Computes ESOP representation using optimum PKRM
+
+  This algorithm first computes an ESOP using the algorithm described
+  in [R. Drechsler, IEEE Trans. C 48(9), 1999, 987–990].
+
+  The algorithm applies post-optimization to merge distance-1 cubes.
+
+  \param tt Truth table
+*/
+template<typename TT>
+inline std::vector<cube> esop_from_optimum_pkrm( const TT& tt )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  std::unordered_set<cube, hash<cube>> cubes;
+  detail::expansion_cache<TT> cache;
+
+  detail::find_pkrm_expansions( tt, cache, 0 );
+  detail::optimum_pkrm_rec( cubes, tt, cache, 0, cube() );
+
+  return std::vector<cube>( cubes.begin(), cubes.end() );
+}
+
+template<typename TT>
+inline std::vector<cube> esop_from_pprm_slow( const TT& tt )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  std::unordered_set<cube, hash<cube>> cubes;
+  detail::esop_from_pprm_rec( cubes, tt, 0, cube() );
+
+  return std::vector<cube>( cubes.begin(), cubes.end() );
+}
+
+/*! \brief Computes PPRM representation for a function
+
+  This algorithm applies recursively the positive Davio decomposition which
+  eventually leads into the PPRM representation of a function.
+
+  \param tt Truth table
+*/
+template<class TT>
+std::vector<cube> esop_from_pprm( const TT& func )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  std::vector<cube> cubes;
+  for_each_one_bit( detail::algebraic_normal_form( func ), [&]( auto bit )
+                    { cubes.emplace_back( (uint32_t)bit, (uint32_t)bit ); } );
+  return cubes;
+}
+
+} // namespace kitty
\ No newline at end of file
diff --git a/lib/kitty/kitty/hash.hpp b/lib/kitty/kitty/hash.hpp
new file mode 100644
index 0000000..25901ae
--- /dev/null
+++ b/lib/kitty/kitty/hash.hpp
@@ -0,0 +1,95 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file hash.hpp
+  \brief Implements hash functions for truth tables
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <cstdlib>
+
+#include "static_truth_table.hpp"
+
+namespace kitty
+{
+
+/*! \brief Hash function for 64-bit word */
+inline std::size_t hash_block( uint64_t word )
+{
+  /* from boost::hash_detail::hash_value_unsigned */
+  return word ^ ( word + ( word << 6 ) + ( word >> 2 ) );
+}
+
+/*! \brief Combines two hash values */
+inline void hash_combine( std::size_t& seed, std::size_t other )
+{
+  /* from boost::hash_detail::hash_combine_impl */
+  const uint64_t m = UINT64_C( 0xc6a4a7935bd1e995 );
+  const int r = 47;
+
+  other *= m;
+  other ^= other >> r;
+  other *= m;
+
+  seed ^= other;
+  seed *= m;
+
+  seed += 0xe6546b64;
+}
+
+/*! \brief Computes hash values for truth tables */
+template<typename TT>
+struct hash
+{
+  std::size_t operator()( const TT& tt ) const
+  {
+    auto it = std::begin( tt._bits );
+    auto seed = hash_block( *it++ );
+
+    while ( it != std::end( tt._bits ) )
+    {
+      hash_combine( seed, hash_block( *it++ ) );
+    }
+
+    return seed;
+  }
+};
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+struct hash<static_truth_table<NumVars, true>>
+{
+  inline std::size_t operator()( const static_truth_table<NumVars, true>& tt ) const
+  {
+    return hash_block( tt._bits );
+  }
+};
+/*! \endcond */
+} // namespace kitty
\ No newline at end of file
diff --git a/lib/kitty/kitty/implicant.hpp b/lib/kitty/kitty/implicant.hpp
new file mode 100644
index 0000000..07cc7c0
--- /dev/null
+++ b/lib/kitty/kitty/implicant.hpp
@@ -0,0 +1,244 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file implicant.hpp
+  \brief Find implicants and prime implicants
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include "algorithm.hpp"
+#include "cube.hpp"
+#include "traits.hpp"
+
+namespace kitty
+{
+
+/*! \brief Computes all minterms
+
+  \param tt Truth table
+*/
+template<typename TT>
+std::vector<uint32_t> get_minterms( const TT& tt )
+{
+  std::vector<uint32_t> m;
+  m.reserve( count_ones( tt ) );
+  for_each_one_bit( tt, [&m]( auto index )
+                    { m.emplace_back( static_cast<uint32_t>( index ) ); } );
+  return m;
+}
+
+/*! \cond PRIVATE */
+template<typename Iterator>
+inline std::vector<std::pair<Iterator, Iterator>> get_jbuddies( Iterator begin, Iterator end, uint32_t j )
+{
+  std::vector<std::pair<Iterator, Iterator>> buddies;
+
+  auto mask = uint32_t( 1 ) << j;
+  auto k = begin;
+  auto kk = begin;
+
+  while ( true )
+  {
+    k = std::find_if( k, end, [mask]( auto m )
+                      { return ( m & mask ) == 0; } );
+    if ( k == end )
+      break;
+
+    if ( kk <= k )
+    {
+      kk = k + 1;
+    }
+
+    kk = std::find_if( kk, end, [mask, &k]( auto m )
+                       { return m >= ( *k | mask ); } );
+    if ( kk == end )
+      break;
+
+    if ( ( *k ^ *kk ) >= ( mask << 1 ) )
+    {
+      k = kk;
+      continue;
+    }
+
+    if ( *kk == ( *k | mask ) )
+    {
+      buddies.emplace_back( k, kk );
+    }
+
+    ++k;
+  }
+
+  return buddies;
+}
+/*! \endcond */
+
+/*! \brief Computes all j-buddies in a list of minterms
+
+  Computes all pairs \f$(k, k')\f$ such that \f$k < k'\f$ and the two minterms
+  at indexes \f$k\f$ and \f$k'\f$ only differ in bit \f$j\f$.
+
+  This algorithm is described by Knuth in Exercise TAOCP 7.1.1-29.
+
+  \param minterms Vector of minterms
+  \param j Bit position
+*/
+inline std::vector<std::pair<std::vector<uint32_t>::const_iterator, std::vector<uint32_t>::const_iterator>> get_jbuddies( const std::vector<uint32_t>& minterms, uint32_t j )
+{
+  return get_jbuddies( minterms.begin(), minterms.end(), j );
+}
+
+/*! \brief Computes all prime implicants (from minterms)
+
+  This algorithm computes all prime implicants for a list of minterms.  The
+  running time is at most proportional to \f$mn\f$, where \f$m\f$ is the number
+  of minterms and \f$n\f$ is the number of variables.
+
+  The algorithm is described in Exercise TAOCP 7.1.1-30 by Knuth and is inspired
+  by the algorithm described in [E. Morreale, IEEE Trans. EC 16(5), 1967,
+  611–620].
+
+  \param minterms Vector of minterms (as integer values)
+  \param num_vars Number of variables
+*/
+inline std::vector<cube> get_prime_implicants_morreale( const std::vector<uint32_t>& minterms, unsigned num_vars )
+{
+  std::vector<cube> cubes;
+
+  const auto n = num_vars;
+  const auto m = minterms.size();
+
+  std::vector<uint32_t> tags( 2 * m + n, 0 );
+  std::vector<uint32_t> stack( 2 * m + n, 0 );
+
+  uint32_t mask = ( 1 << n ) - 1;
+  uint32_t A{};
+
+  /* P1 */
+
+  /* Update tags using j-buddy algorithm */
+  for ( auto j = 0u; j < n; ++j )
+  {
+    for ( const auto& p : get_jbuddies( minterms, j ) )
+    {
+      const auto k = std::distance( minterms.begin(), p.first );
+      const auto kk = std::distance( minterms.begin(), p.second );
+
+      tags[k] |= ( 1 << j );
+      tags[kk] |= ( 1 << j );
+    }
+  }
+
+  auto t = 0u;
+  for ( auto s = 0u; s < m; ++s )
+  {
+    if ( tags[s] == 0u )
+    {
+      cubes.emplace_back( minterms[s], mask );
+    }
+    else
+    {
+      stack[t] = minterms[s];
+      tags[t] = tags[s];
+      t++;
+    }
+  }
+
+  stack.push_back( 0 );
+
+  while ( true )
+  {
+    /* P2 */
+    auto j = 0u;
+    if ( stack[t] == t )
+    {
+      while ( j < n && ( ( A >> j ) & 1 ) == 0 )
+      {
+        ++j;
+      }
+    }
+
+    while ( j < n && ( ( A >> j ) & 1 ) != 0 )
+    {
+      t = stack[t] - 1;
+      A &= ~( 1 << j );
+      ++j;
+    }
+
+    if ( j >= n )
+    {
+      /* terminate */
+      return cubes;
+    }
+
+    A |= ( 1 << j );
+
+    /* P3 */
+    const auto r = t;
+    const auto s = stack.begin() + stack[t];
+
+    for ( const auto& p : get_jbuddies( s, stack.begin() + r, j ) )
+    {
+      const auto k = std::distance( stack.begin(), p.first );
+      const auto kk = std::distance( stack.begin(), p.second );
+      const auto x = tags[k] & tags[kk] & ~( 1 << j );
+
+      if ( x == 0 )
+      {
+        cubes.emplace_back( stack[k], ~A & mask );
+      }
+      else
+      {
+        ++t;
+        stack[t] = stack[k];
+        tags[t] = x;
+      }
+    }
+
+    ++t;
+    stack[t] = r + 1;
+  }
+}
+
+/*! \brief Computes all prime implicants (from truth table)
+
+  Computes minterms from truth table and calls overloaded function.
+
+  \param tt Truth table
+*/
+template<typename TT>
+std::vector<cube> get_prime_implicants_morreale( const TT& tt )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  return get_prime_implicants_morreale( get_minterms( tt ), tt.num_vars() );
+}
+} // namespace kitty
\ No newline at end of file
diff --git a/lib/kitty/kitty/isop.hpp b/lib/kitty/kitty/isop.hpp
new file mode 100644
index 0000000..dcb5d08
--- /dev/null
+++ b/lib/kitty/kitty/isop.hpp
@@ -0,0 +1,130 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file isop.hpp
+  \brief Implements methods to compute irredundant sum-of-products (ISOP) representations
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include "cube.hpp"
+#include "operations.hpp"
+#include "operators.hpp"
+#include "traits.hpp"
+
+namespace kitty
+{
+
+/*! \cond PRIVATE */
+namespace detail
+{
+template<typename TT>
+TT isop_rec( const TT& tt, const TT& dc, uint8_t var_index, std::vector<cube>& cubes )
+{
+  assert( var_index <= tt.num_vars() );
+  assert( is_const0( tt & ~dc ) );
+
+  if ( is_const0( tt ) )
+  {
+    return tt;
+  }
+
+  if ( is_const0( ~dc ) )
+  {
+    cubes.emplace_back(); /* add empty cube */
+    return dc;
+  }
+
+  assert( var_index > 0 );
+
+  int var = var_index - 1;
+  for ( ; var >= 0; --var )
+  {
+    if ( has_var( tt, var ) || has_var( dc, var ) )
+    {
+      break;
+    }
+  }
+
+  assert( var >= 0 );
+
+  /* co-factor */
+  const auto tt0 = cofactor0( tt, var );
+  const auto tt1 = cofactor1( tt, var );
+  const auto dc0 = cofactor0( dc, var );
+  const auto dc1 = cofactor1( dc, var );
+
+  const auto beg0 = cubes.size();
+  const auto res0 = isop_rec( tt0 & ~dc1, dc0, var, cubes );
+  const auto end0 = cubes.size();
+  const auto res1 = isop_rec( tt1 & ~dc0, dc1, var, cubes );
+  const auto end1 = cubes.size();
+  auto res2 = isop_rec( ( tt0 & ~res0 ) | ( tt1 & ~res1 ), dc0 & dc1, var, cubes );
+
+  auto var0 = tt.construct();
+  create_nth_var( var0, var, true );
+  auto var1 = tt.construct();
+  create_nth_var( var1, var );
+  res2 |= ( res0 & var0 ) | ( res1 & var1 );
+
+  for ( auto c = beg0; c < end0; ++c )
+  {
+    cubes[c].add_literal( var, false );
+  }
+  for ( auto c = end0; c < end1; ++c )
+  {
+    cubes[c].add_literal( var, true );
+  }
+
+  assert( is_const0( tt & ~res2 ) );
+  assert( is_const0( res2 & ~dc ) );
+
+  return res2;
+}
+} /* namespace detail */
+/* \endcond */
+
+/*! \brief Computes ISOP representation
+
+  Computes the irredundant sum-of-products representation using the
+  Minato-Morreale algorithm [S. Minato, IEEE Trans. CAD 15(4), 1996,
+  377-384].
+
+  \param tt Truth table
+*/
+template<typename TT>
+inline std::vector<cube> isop( const TT& tt )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  std::vector<cube> cubes;
+  detail::isop_rec( tt, tt, tt.num_vars(), cubes );
+  return cubes;
+}
+
+} /* namespace kitty */
\ No newline at end of file
diff --git a/lib/kitty/kitty/karnaugh_map.hpp b/lib/kitty/kitty/karnaugh_map.hpp
new file mode 100644
index 0000000..221cfd1
--- /dev/null
+++ b/lib/kitty/kitty/karnaugh_map.hpp
@@ -0,0 +1,188 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file karnaugh_map.hpp
+  \brief karnaugh maps visualizer
+
+  \author Gianluca Radi
+*/
+
+#pragma once
+
+#include "bit_operations.hpp"
+#include "constructors.hpp"
+#include "operators.hpp"
+#include <algorithm>
+#include <cmath>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace kitty
+{
+template<typename TT>
+class karnaugh_map
+{
+public:
+  /*! \brief Destroys K-map
+   */
+  karnaugh_map() = delete;
+
+  /*! \brief Construncts K-map from truth table
+      \param tt truth table
+  */
+  karnaugh_map( TT tt ) : truth_table( tt )
+  {
+    uint64_t num_var = log2( (double)tt.num_bits() );
+    vars_col = num_var >> 1;
+    vars_row = num_var - vars_col;
+    col_seq = compute_seq_1ham_dist( vars_col );
+    row_seq = compute_seq_1ham_dist( vars_row );
+  }
+
+  /*! \brief Prints K-map
+      \param os output stream (default = cout)
+ */
+
+  void print( std::ostream& os = std::cout )
+  {
+    print_space( vars_col, os );
+    os << "    ";
+    for ( const auto& i : row_seq )
+    {
+      os << binary( i, vars_row );
+      print_space( vars_row, os );
+      os << "    ";
+    }
+    os << std::endl
+       << std::endl;
+
+    for ( const auto& j : col_seq )
+    {
+      os << binary( j, vars_col );
+      os << "    ";
+      for ( const auto& i : row_seq )
+      {
+        uint8_t middle_space = 0;
+        if ( vars_row > 2 )
+          middle_space = vars_row / 2;
+        print_space( middle_space, os );
+        if ( is_dont_care( truth_table, ( j << vars_row ) + i ) )
+          os << "-";
+        else
+        {
+          if ( is_dont_know( truth_table, ( j << vars_row ) + i ) )
+            os << "x";
+          else
+            os << get_bit( truth_table, ( j << vars_row ) + i );
+        }
+        print_space( ( vars_row << 1 ) - 1 - middle_space, os );
+        os << "    ";
+      }
+      os << std::endl
+         << std::endl;
+    }
+  }
+
+  /*! \brief Get sequence of values for the least significant variables
+   */
+  std::vector<uint8_t> get_row_seq() const { return row_seq; }
+
+  /*! \brief Get sequence of values for the most significant variables
+   */
+  std::vector<uint8_t> get_col_seq() const { return col_seq; }
+
+private:
+  TT truth_table;
+  unsigned vars_row;
+  unsigned vars_col;
+  std::vector<uint8_t> row_seq;
+  std::vector<uint8_t> col_seq;
+
+  /*! \brief Converts unsigned into binary string
+      \param n unsigned to convert
+      \param max_var number of bits of the string
+  */
+  std::string binary( uint8_t n, uint8_t max_var )
+  {
+    std::string result;
+    uint8_t count = 0u;
+
+    do
+    {
+      result.insert( result.begin(), '0' + ( n & 1 ) );
+      count++;
+    } while ( n >>= 1 );
+
+    for ( uint8_t i = 0; i < max_var - count; i++ )
+    {
+      result.insert( result.begin(), '0' );
+    }
+
+    return result;
+  }
+
+  /*! \brief Prints white space.
+      \param val number of white space to print
+      \param os output stream
+  */
+  void print_space( uint8_t val, std::ostream& os )
+  {
+    for ( uint8_t i = 0; i < val; i++ )
+    {
+      os << " ";
+    }
+  }
+
+  /*! \brief Computes sequence of values with unitary Hamming distance for a
+     certain number of values
+
+      For example, for 2 as the number of variables, the sequence would be = {0,
+     1, 3, 2} (= {00, 01, 11, 10})
+
+      \param num_var number of variables
+  */
+  std::vector<uint8_t> compute_seq_1ham_dist( uint8_t num_var )
+  {
+    if ( num_var == 1 )
+    {
+      return { 0, 1 };
+    }
+    else
+    {
+      std::vector<uint8_t> res = compute_seq_1ham_dist( num_var - 1 );
+      std::vector<uint8_t> res_rev( res.rbegin(), res.rend() );
+      for ( auto& i : res_rev )
+      {
+        i += ( 1 << ( num_var - 1 ) );
+      }
+      res.insert( res.end(), res_rev.begin(), res_rev.end() );
+      return res;
+    }
+  }
+};
+
+} // namespace kitty
\ No newline at end of file
diff --git a/lib/kitty/kitty/kitty.hpp b/lib/kitty/kitty/kitty.hpp
new file mode 100644
index 0000000..39b0cae
--- /dev/null
+++ b/lib/kitty/kitty/kitty.hpp
@@ -0,0 +1,70 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file kitty.hpp
+  \brief Main header for kitty
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include "static_truth_table.hpp"
+#include "dynamic_truth_table.hpp"
+#include "partial_truth_table.hpp"
+
+#include "affine.hpp"
+#include "algorithm.hpp"
+#include "bit_operations.hpp"
+#include "cnf.hpp"
+#include "constructors.hpp"
+#include "cube.hpp"
+#include "decomposition.hpp"
+#include "enumeration.hpp"
+//#include "esop.hpp" // deprecated!
+#include "hash.hpp"
+#include "implicant.hpp"
+#include "isop.hpp"
+#include "karnaugh_map.hpp"
+#include "npn.hpp"
+#include "operations.hpp"
+#include "operators.hpp"
+#include "permutation.hpp"
+#include "print.hpp"
+#include "properties.hpp"
+#include "spectral.hpp"
+#include "spp.hpp"
+#include "traits.hpp"
+
+/*
+         /\___/\
+        (  o o  )
+        /   *   \
+        \__\_/__/
+          /   \
+         / ___ \
+         \/___\/
+*/
\ No newline at end of file
diff --git a/lib/kitty/kitty/npn.hpp b/lib/kitty/kitty/npn.hpp
new file mode 100644
index 0000000..fefad24
--- /dev/null
+++ b/lib/kitty/kitty/npn.hpp
@@ -0,0 +1,1327 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file npn.hpp
+  \brief Implements NPN canonization algorithms
+
+  \author Alessandro Tempia Calvino
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <numeric>
+
+#include "detail/constants.hpp"
+#include "operators.hpp"
+#include "traits.hpp"
+
+namespace kitty
+{
+
+/*! \cond PRIVATE */
+
+namespace detail
+{
+template<typename TT>
+void exact_npn_canonization_null_callback( const TT& tt )
+{
+  (void)tt;
+}
+} /* namespace detail */
+/*! \endcond */
+
+/*! \brief Exact P canonization
+
+  Given a truth table, this function finds the lexicographically smallest truth
+  table in its P class, called P representative. Two functions are in the
+  same P class, if one can obtain one from the other by input permutation.
+
+  The function can accept a callback as second parameter which is called for
+  every visited function when trying out all combinations.  This allows to
+  exhaustively visit the whole P class.
+
+  The function returns a NPN configuration which contains the necessary
+  transformations to obtain the representative.  It is a tuple of
+
+  - the P representative
+  - input negations and output negation, which is 0 in this case
+  - input permutation to apply
+
+  \param tt The truth table
+  \param fn Callback for each visited truth table in the class (default does nothing)
+  \return NPN configuration
+*/
+template<typename TT, typename Callback = decltype( detail::exact_npn_canonization_null_callback<TT> )>
+std::tuple<TT, uint32_t, std::vector<uint8_t>> exact_p_canonization( const TT& tt, Callback&& fn = detail::exact_npn_canonization_null_callback<TT> )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  const auto num_vars = tt.num_vars();
+
+  /* Special case for n = 0 */
+  if ( num_vars == 0 )
+  {
+    return std::make_tuple( tt, 0u, std::vector<uint8_t>{} );
+  }
+
+  /* Special case for n = 1 */
+  if ( num_vars == 1 )
+  {
+    return std::make_tuple( tt, 0u, std::vector<uint8_t>{ 0 } );
+  }
+
+  assert( num_vars >= 2 && num_vars <= 7 );
+
+  auto t1 = tt;
+  auto tmin = t1;
+
+  fn( t1 );
+
+  const auto& swaps = detail::swaps[num_vars - 2u];
+
+  int best_swap = -1;
+
+  for ( std::size_t i = 0; i < swaps.size(); ++i )
+  {
+    const auto pos = swaps[i];
+    swap_adjacent_inplace( t1, pos );
+
+    fn( t1 );
+
+    if ( t1 < tmin )
+    {
+      best_swap = static_cast<int>( i );
+      tmin = t1;
+    }
+  }
+
+  std::vector<uint8_t> perm( num_vars );
+  std::iota( perm.begin(), perm.end(), 0u );
+
+  for ( auto i = 0; i <= best_swap; ++i )
+  {
+    const auto pos = swaps[i];
+    std::swap( perm[pos], perm[pos + 1] );
+  }
+
+  return std::make_tuple( tmin, 0u, perm );
+}
+
+/*! \brief Exact NPN canonization
+
+  Given a truth table, this function finds the lexicographically smallest truth
+  table in its NPN class, called NPN representative. Two functions are in the
+  same NPN class, if one can obtain one from the other by input negation, input
+  permutation, and output negation.
+
+  The function can accept a callback as second parameter which is called for
+  every visited function when trying out all combinations.  This allows to
+  exhaustively visit the whole NPN class.
+
+  The function returns a NPN configuration which contains the necessary
+  transformations to obtain the representative.  It is a tuple of
+
+  - the NPN representative
+  - input negations and output negation, output negation is stored as bit *n*,
+    where *n* is the number of variables in `tt`
+  - input permutation to apply
+
+  \param tt The truth table (with at most 6 variables)
+  \param fn Callback for each visited truth table in the class (default does nothing)
+  \return NPN configuration
+*/
+template<typename TT, typename Callback = decltype( detail::exact_npn_canonization_null_callback<TT> )>
+std::tuple<TT, uint32_t, std::vector<uint8_t>> exact_npn_canonization( const TT& tt, Callback&& fn = detail::exact_npn_canonization_null_callback<TT> )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  const auto num_vars = tt.num_vars();
+
+  /* Special case for n = 0 */
+  if ( num_vars == 0 )
+  {
+    const auto bit = get_bit( tt, 0 );
+    return std::make_tuple( unary_not_if( tt, bit ), static_cast<uint32_t>( bit ), std::vector<uint8_t>{} );
+  }
+
+  /* Special case for n = 1 */
+  if ( num_vars == 1 )
+  {
+    const auto bit1 = get_bit( tt, 1 );
+    return std::make_tuple( unary_not_if( tt, bit1 ), static_cast<uint32_t>( bit1 << 1 ), std::vector<uint8_t>{ 0 } );
+  }
+
+  assert( num_vars >= 2 && num_vars <= 6 );
+
+  auto t1 = tt, t2 = ~tt;
+  auto tmin = std::min( t1, t2 );
+  auto invo = tmin == t2;
+
+  fn( t1 );
+  fn( t2 );
+
+  const auto& swaps = detail::swaps[num_vars - 2u];
+  const auto& flips = detail::flips[num_vars - 2u];
+
+  int best_swap = -1;
+  int best_flip = -1;
+
+  for ( std::size_t i = 0; i < swaps.size(); ++i )
+  {
+    const auto pos = swaps[i];
+    swap_adjacent_inplace( t1, pos );
+    swap_adjacent_inplace( t2, pos );
+
+    fn( t1 );
+    fn( t2 );
+
+    if ( t1 < tmin || t2 < tmin )
+    {
+      best_swap = static_cast<int>( i );
+      tmin = std::min( t1, t2 );
+      invo = tmin == t2;
+    }
+  }
+
+  for ( std::size_t j = 0; j < flips.size(); ++j )
+  {
+    const auto pos = flips[j];
+    swap_adjacent_inplace( t1, 0 );
+    flip_inplace( t1, pos );
+    swap_adjacent_inplace( t2, 0 );
+    flip_inplace( t2, pos );
+
+    fn( t1 );
+    fn( t2 );
+
+    if ( t1 < tmin || t2 < tmin )
+    {
+      best_swap = -1;
+      best_flip = static_cast<int>( j );
+      tmin = std::min( t1, t2 );
+      invo = tmin == t2;
+    }
+
+    for ( std::size_t i = 0; i < swaps.size(); ++i )
+    {
+      const auto pos = swaps[i];
+      swap_adjacent_inplace( t1, pos );
+      swap_adjacent_inplace( t2, pos );
+
+      fn( t1 );
+      fn( t2 );
+
+      if ( t1 < tmin || t2 < tmin )
+      {
+        best_swap = static_cast<int>( i );
+        best_flip = static_cast<int>( j );
+        tmin = std::min( t1, t2 );
+        invo = tmin == t2;
+      }
+    }
+  }
+
+  std::vector<uint8_t> perm( num_vars );
+  std::iota( perm.begin(), perm.end(), 0u );
+
+  for ( auto i = 0; i <= best_swap; ++i )
+  {
+    const auto pos = swaps[i];
+    std::swap( perm[pos], perm[pos + 1] );
+  }
+
+  uint32_t phase = uint32_t( invo ) << num_vars;
+  for ( auto i = 0; i <= best_flip; ++i )
+  {
+    phase ^= 1 << flips[i];
+  }
+
+  return std::make_tuple( tmin, phase, perm );
+}
+
+/*! \brief Exact N canonization
+
+  Given a truth table, this function finds the lexicographically smallest truth
+  table in its N class, called N representative. Two functions are in the
+  same N class, if one can obtain one from the other by input negations.
+
+  The function can accept a callback as second parameter which is called for
+  every visited function when trying out all combinations.  This allows to
+  exhaustively visit the whole N class.
+
+  The function returns a N configuration which contains the necessary
+  transformations to obtain the representative.  It is a tuple of
+
+  - the N representative
+  - input negations that lead to the representative
+
+  \param tt The truth table
+  \param fn Callback for each visited truth table in the class (default does nothing)
+  \return N configurations
+*/
+template<typename TT, typename Callback = decltype( detail::exact_npn_canonization_null_callback<TT> )>
+std::tuple<TT, uint32_t> exact_n_canonization( const TT& tt, Callback&& fn = detail::exact_npn_canonization_null_callback<TT> )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  const auto num_vars = tt.num_vars();
+
+  /* Special case for n = 0 */
+  if ( num_vars == 0 )
+  {
+    return std::make_tuple( tt, 0 );
+  }
+
+  /* Special case for n = 1 */
+  if ( num_vars == 1 )
+  {
+    return std::make_tuple( tt, 0 );
+  }
+
+  assert( num_vars >= 2 && num_vars <= 6 );
+
+  auto t1 = tt;
+  auto tmin = t1;
+
+  fn( t1 );
+
+  const auto& flips = detail::flips[num_vars - 2u];
+  int best_flip = -1;
+
+  for ( std::size_t j = 0; j < flips.size(); ++j )
+  {
+    const auto pos = flips[j];
+    flip_inplace( t1, pos );
+
+    fn( t1 );
+
+    if ( t1 < tmin )
+    {
+      best_flip = static_cast<int>( j );
+      tmin = t1;
+    }
+  }
+
+  uint32_t phase = 0;
+  for ( auto i = 0; i <= best_flip; ++i )
+  {
+    phase ^= 1 << flips[i];
+  }
+
+  return std::make_tuple( tmin, phase );
+}
+
+/*! \brief Exact N canonization given a support size
+
+  Given a truth table, this function finds the lexicographically smallest truth
+  table in its N class, called N representative. Two functions are in the
+  same N class, if one can obtain one from the other by input negations.
+
+  The function can accept a callback as second parameter which is called for
+  every visited function when trying out all combinations.  This allows to
+  exhaustively visit the whole N class.
+
+  The function returns a N configuration which contains the necessary
+  transformations to obtain the representative.  It is a tuple of
+
+  - the N representative
+  - input negations that lead to the representative
+
+  \param tt The truth table
+  \param support_size Support size used for the canonization
+  \param fn Callback for each visited truth table in the class (default does nothing)
+  \return N configurations
+*/
+template<typename TT, typename Callback = decltype( detail::exact_npn_canonization_null_callback<TT> )>
+std::tuple<TT, uint32_t> exact_n_canonization_support( const TT& tt, uint32_t support_size, Callback&& fn = detail::exact_npn_canonization_null_callback<TT> )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  assert( support_size <= tt.num_vars() );
+
+  const auto num_vars = support_size;
+
+  /* Special case for n = 0 */
+  if ( num_vars == 0 )
+  {
+    return std::make_tuple( tt, 0 );
+  }
+
+  /* Special case for n = 1 */
+  if ( num_vars == 1 )
+  {
+    return std::make_tuple( tt, 0 );
+  }
+
+  assert( num_vars >= 2 && num_vars <= 6 );
+
+  auto t1 = tt;
+  auto tmin = t1;
+
+  fn( t1 );
+
+  const auto& flips = detail::flips[num_vars - 2u];
+  int best_flip = -1;
+
+  for ( std::size_t j = 0; j < flips.size(); ++j )
+  {
+    const auto pos = flips[j];
+    flip_inplace( t1, pos );
+
+    fn( t1 );
+
+    if ( t1 < tmin )
+    {
+      best_flip = static_cast<int>( j );
+      tmin = t1;
+    }
+  }
+
+  uint32_t phase = 0;
+  for ( auto i = 0; i <= best_flip; ++i )
+  {
+    phase ^= 1 << flips[i];
+  }
+
+  return std::make_tuple( tmin, phase );
+}
+
+/*! \brief Flip-swap NPN heuristic
+
+  This algorithm will iteratively try to reduce the numeric value of the truth
+  table by first inverting each input, then inverting the output, and then
+  swapping each pair of inputs.  Every improvement is accepted, the algorithm
+  stops, if no more improvement can be achieved.
+
+  The function returns a NPN configuration which contains the
+  necessary transformations to obtain the representative.  It is a
+  tuple of
+
+  - the NPN representative
+  - input negations and output negation, output negation is stored as
+    bit *n*, where *n* is the number of variables in `tt`
+  - input permutation to apply
+
+  \param tt Truth table
+  \return NPN configuration
+*/
+template<typename TT>
+std::tuple<TT, uint32_t, std::vector<uint8_t>> flip_swap_npn_canonization( const TT& tt )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  const auto num_vars = tt.num_vars();
+
+  /* initialize permutation and phase */
+  std::vector<uint8_t> perm( num_vars );
+  std::iota( perm.begin(), perm.end(), 0u );
+
+  uint32_t phase{ 0u };
+
+  auto npn = tt;
+  auto improvement = true;
+
+  while ( improvement )
+  {
+    improvement = false;
+
+    /* input inversion */
+    for ( auto i = 0u; i < num_vars; ++i )
+    {
+      const auto flipped = flip( npn, i );
+      if ( flipped < npn )
+      {
+        npn = flipped;
+        phase ^= 1 << perm[i];
+        improvement = true;
+      }
+    }
+
+    /* output inversion */
+    const auto flipped = ~npn;
+    if ( flipped < npn )
+    {
+      npn = flipped;
+      phase ^= 1 << num_vars;
+      improvement = true;
+    }
+
+    /* permute inputs */
+    for ( auto d = 1u; d < num_vars - 1; ++d )
+    {
+      for ( auto i = 0u; i < num_vars - d; ++i )
+      {
+        auto j = i + d;
+
+        const auto permuted = swap( npn, i, j );
+        if ( permuted < npn )
+        {
+          npn = permuted;
+          std::swap( perm[i], perm[j] );
+
+          improvement = true;
+        }
+      }
+    }
+  }
+
+  return std::make_tuple( npn, phase, perm );
+}
+
+/*! \cond PRIVATE */
+namespace detail
+{
+
+template<typename TT>
+void sifting_npn_canonization_loop( TT& npn, uint32_t& phase, std::vector<uint8_t>& perm )
+{
+  auto improvement = true;
+  auto forward = true;
+
+  const auto n = npn.num_vars();
+
+  while ( improvement )
+  {
+    improvement = false;
+
+    for ( int i = forward ? 0 : n - 2; forward ? i < static_cast<int>( n - 1 ) : i >= 0; forward ? ++i : --i )
+    {
+      auto local_improvement = false;
+      for ( auto k = 1u; k < 8u; ++k )
+      {
+        if ( k % 4u == 0u )
+        {
+          const auto next_t = swap( npn, i, i + 1 );
+          if ( next_t < npn )
+          {
+            npn = next_t;
+            std::swap( perm[i], perm[i + 1] );
+            local_improvement = true;
+          }
+        }
+        else if ( k % 2u == 0u )
+        {
+          const auto next_t = flip( npn, i + 1 );
+          if ( next_t < npn )
+          {
+            npn = next_t;
+            phase ^= 1 << perm[i + 1];
+            local_improvement = true;
+          }
+        }
+        else
+        {
+          const auto next_t = flip( npn, i );
+          if ( next_t < npn )
+          {
+            npn = next_t;
+            phase ^= 1 << perm[i];
+            local_improvement = true;
+          }
+        }
+      }
+
+      if ( local_improvement )
+      {
+        improvement = true;
+      }
+    }
+
+    forward = !forward;
+  }
+}
+template<typename TT>
+void sifting_p_canonization_loop( TT& p, uint32_t& phase, std::vector<uint8_t>& perm )
+{
+  (void)phase;
+  auto improvement = true;
+  auto forward = true;
+
+  const auto n = p.num_vars();
+
+  while ( improvement )
+  {
+    improvement = false;
+
+    for ( int i = forward ? 0 : n - 2; forward ? i < static_cast<int>( n - 1 ) : i >= 0; forward ? ++i : --i )
+    {
+      auto local_improvement = false;
+
+      const auto next_t = swap( p, i, i + 1 );
+      if ( next_t < p )
+      {
+        p = next_t;
+        std::swap( perm[i], perm[i + 1] );
+        local_improvement = true;
+      }
+
+      if ( local_improvement )
+      {
+        improvement = true;
+      }
+    }
+    forward = !forward;
+  }
+}
+} /* namespace detail */
+/*! \endcond */
+
+/*! \brief Sifting NPN heuristic
+
+  The algorithm will always consider two adjacent variables and try all possible
+  transformations on these two.  It will try once in forward direction and once
+  in backward direction.  It will try for the regular function and inverted
+  function.
+
+  The function returns a NPN configuration which contains the necessary
+  transformations to obtain the representative.  It is a tuple of
+
+  - the NPN representative
+  - input negations and output negation, output negation is stored as bit *n*,
+    where *n* is the number of variables in `tt`
+  - input permutation to apply
+
+  \param tt Truth table
+  \return NPN configuration
+*/
+template<typename TT>
+std::tuple<TT, uint32_t, std::vector<uint8_t>> sifting_npn_canonization( const TT& tt )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  const auto num_vars = tt.num_vars();
+
+  /* initialize permutation and phase */
+  std::vector<uint8_t> perm( num_vars );
+  std::iota( perm.begin(), perm.end(), 0u );
+  uint32_t phase{ 0u };
+
+  if ( num_vars < 2 )
+  {
+    return std::make_tuple( tt, phase, perm );
+  }
+
+  auto npn = tt;
+
+  detail::sifting_npn_canonization_loop( npn, phase, perm );
+
+  const auto best_perm = perm;
+  const auto best_phase = phase;
+  const auto best_npn = npn;
+
+  npn = ~tt;
+  phase = 1 << num_vars;
+  std::iota( perm.begin(), perm.end(), 0u );
+
+  detail::sifting_npn_canonization_loop( npn, phase, perm );
+
+  if ( best_npn < npn )
+  {
+    perm = best_perm;
+    phase = best_phase;
+    npn = best_npn;
+  }
+
+  return std::make_tuple( npn, phase, perm );
+}
+
+/*! \brief Sifting P heuristic
+
+  The algorithm will always consider two adjacent variables and try all possible
+  transformations on these two.  It will try once in forward direction and once
+  in backward direction.  It will try for the regular function.
+
+  The function returns a P configuration which contains the necessary
+  transformations to obtain the representative.  It is a tuple of
+
+  - the P representative
+  - input negations and output negation, which is 0 in this case
+  - input permutation to apply
+
+  \param tt Truth table
+  \return NPN configuration
+*/
+template<typename TT>
+std::tuple<TT, uint32_t, std::vector<uint8_t>> sifting_p_canonization( const TT& tt )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  const auto num_vars = tt.num_vars();
+
+  /* initialize permutation and phase */
+  std::vector<uint8_t> perm( num_vars );
+  std::iota( perm.begin(), perm.end(), 0u );
+  uint32_t phase{ 0u };
+
+  if ( num_vars < 2u )
+  {
+    return std::make_tuple( tt, phase, perm );
+  }
+
+  auto npn = tt;
+
+  detail::sifting_p_canonization_loop( npn, phase, perm );
+
+  return std::make_tuple( npn, phase, perm );
+}
+
+/*! \brief Exact NPN enumeration
+
+  Given a truth table, this function enumerates all the functions in its
+  NPN class. Two functions are in the same NP class, if one can be obtained
+  from the other by input negation, input permutation, and output negation.
+
+  The function takes a callback as second parameter which is called for
+  every enumerated function. The callback should take as parameters:
+  - NPN-enumerated truth table
+  - input and output negations
+  - input permutation to apply
+
+  \param tt Truth table
+  \param fn Callback for each enumerated truth table in the NP class
+*/
+template<typename TT, typename Callback>
+void exact_npn_enumeration( const TT& tt, Callback&& fn )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  const auto num_vars = tt.num_vars();
+
+  /* Special case for n = 0 */
+  if ( num_vars == 0 )
+  {
+    fn( tt, 0u, std::vector<uint8_t>{} );
+    fn( ~tt, 1u, std::vector<uint8_t>{} );
+    return;
+  }
+
+  /* Special case for n = 1 */
+  if ( num_vars == 1 )
+  {
+    fn( tt, 0u, std::vector<uint8_t>{ 0 } );
+    fn( ~tt, 2u, std::vector<uint8_t>{ 0 } );
+    return;
+  }
+
+  assert( num_vars >= 2 && num_vars <= 6 );
+
+  auto t1 = tt;
+
+  std::vector<uint8_t> perm( num_vars );
+  std::iota( perm.begin(), perm.end(), 0u );
+
+  uint32_t phase = 0;
+
+  fn( t1, phase, perm );
+
+  const auto& swaps = detail::swaps[num_vars - 2u];
+  const auto& flips = detail::flips[num_vars - 2u];
+
+  for ( std::size_t i = 0; i < swaps.size(); ++i )
+  {
+    const auto pos = swaps[i];
+    swap_adjacent_inplace( t1, pos );
+
+    std::swap( perm[pos], perm[pos + 1] );
+
+    fn( t1, phase, perm );
+    fn( ~t1, phase | ( 1u << num_vars ), perm );
+  }
+
+  for ( std::size_t j = 0; j < flips.size(); ++j )
+  {
+    const auto pos = flips[j];
+    swap_adjacent_inplace( t1, 0 );
+    flip_inplace( t1, pos );
+
+    std::swap( perm[0], perm[1] );
+    phase ^= 1 << perm[pos];
+
+    fn( t1, phase, perm );
+    fn( ~t1, phase | ( 1u << num_vars ), perm );
+
+    for ( std::size_t i = 0; i < swaps.size(); ++i )
+    {
+      const auto pos = swaps[i];
+      swap_adjacent_inplace( t1, pos );
+
+      std::swap( perm[pos], perm[pos + 1] );
+
+      fn( t1, phase, perm );
+      fn( ~t1, phase | ( 1u << num_vars ), perm );
+    }
+  }
+}
+
+/*! \brief Exact NP enumeration
+
+  Given a truth table, this function enumerates all the functions in its
+  NP class. Two functions are in the same NP class, if one can be obtained
+  from the other by input negation and input permutation.
+
+  The function takes a callback as second parameter which is called for
+  every enumerated function. The callback should take as parameters:
+  - NP-enumerated truth table
+  - input negations
+  - input permutation to apply
+
+  \param tt Truth table
+  \param fn Callback for each enumerated truth table in the NP class
+*/
+template<typename TT, typename Callback>
+void exact_np_enumeration( const TT& tt, Callback&& fn )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  const auto num_vars = tt.num_vars();
+
+  /* Special case for n = 0 */
+  if ( num_vars == 0 )
+  {
+    fn( tt, 0u, std::vector<uint8_t>{} );
+    return;
+  }
+
+  /* Special case for n = 1 */
+  if ( num_vars == 1 )
+  {
+    fn( tt, 0u, std::vector<uint8_t>{ 0 } );
+    return;
+  }
+
+  assert( num_vars >= 2 && num_vars <= 6 );
+
+  auto t1 = tt;
+
+  std::vector<uint8_t> perm( num_vars );
+  std::iota( perm.begin(), perm.end(), 0u );
+
+  uint32_t phase = 0;
+
+  fn( t1, phase, perm );
+
+  const auto& swaps = detail::swaps[num_vars - 2u];
+  const auto& flips = detail::flips[num_vars - 2u];
+
+  for ( std::size_t i = 0; i < swaps.size(); ++i )
+  {
+    const auto pos = swaps[i];
+    swap_adjacent_inplace( t1, pos );
+
+    std::swap( perm[pos], perm[pos + 1] );
+
+    fn( t1, phase, perm );
+  }
+
+  for ( std::size_t j = 0; j < flips.size(); ++j )
+  {
+    const auto pos = flips[j];
+    swap_adjacent_inplace( t1, 0 );
+    flip_inplace( t1, pos );
+
+    std::swap( perm[0], perm[1] );
+    phase ^= 1 << perm[pos];
+
+    fn( t1, phase, perm );
+
+    for ( std::size_t i = 0; i < swaps.size(); ++i )
+    {
+      const auto pos = swaps[i];
+      swap_adjacent_inplace( t1, pos );
+
+      std::swap( perm[pos], perm[pos + 1] );
+
+      fn( t1, phase, perm );
+    }
+  }
+}
+
+/*! \brief Exact multi NP enumeration
+
+  Given multiple truth tables, this function enumerates all the functions in their
+  NP class. Two functions are in the same NP class, if one can be obtained
+  from the other by input negation and input permutation.
+
+  The function takes a callback as second parameter which is called for
+  every enumerated function. The callback should take as parameters:
+  - NP-enumerated truth tables
+  - input negations
+  - input permutation to apply
+
+  \param tts Truth tables
+  \param fn Callback for each enumerated truth table in the NP class
+*/
+template<typename TT, typename Callback>
+void exact_multi_np_enumeration( const std::vector<TT>& tts, Callback&& fn )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  assert( tts.size() > 0 );
+
+  const auto num_vars = tts[0].num_vars();
+
+  for ( auto i = 0; i < tts.size(); ++i )
+    assert( tts[i].num_vars() == num_vars );
+
+  /* Special case for n = 0 */
+  if ( num_vars == 0 )
+  {
+    fn( tts, 0u, std::vector<uint8_t>{} );
+    return;
+  }
+
+  /* Special case for n = 1 */
+  if ( num_vars == 1 )
+  {
+    fn( tts, 0u, std::vector<uint8_t>{ 0 } );
+    return;
+  }
+
+  assert( num_vars >= 2 && num_vars <= 6 );
+
+  auto t1 = tts;
+
+  std::vector<uint8_t> perm( num_vars );
+  std::iota( perm.begin(), perm.end(), 0u );
+
+  uint32_t phase = 0;
+
+  fn( t1, phase, perm );
+
+  const auto& swaps = detail::swaps[num_vars - 2u];
+  const auto& flips = detail::flips[num_vars - 2u];
+
+  for ( std::size_t i = 0; i < swaps.size(); ++i )
+  {
+    const auto pos = swaps[i];
+
+    for ( auto& tt : t1 )
+      swap_adjacent_inplace( tt, pos );
+
+    std::swap( perm[pos], perm[pos + 1] );
+
+    fn( t1, phase, perm );
+  }
+
+  for ( std::size_t j = 0; j < flips.size(); ++j )
+  {
+    const auto pos = flips[j];
+
+    for ( auto& tt : t1 )
+    {
+      swap_adjacent_inplace( tt, 0 );
+      flip_inplace( tt, pos );
+    }
+
+    std::swap( perm[0], perm[1] );
+    phase ^= 1 << perm[pos];
+
+    fn( t1, phase, perm );
+
+    for ( std::size_t i = 0; i < swaps.size(); ++i )
+    {
+      const auto pos = swaps[i];
+
+      for ( auto& tt : t1 )
+        swap_adjacent_inplace( tt, pos );
+
+      std::swap( perm[pos], perm[pos + 1] );
+
+      fn( t1, phase, perm );
+    }
+  }
+}
+
+/*! \brief Exact P enumeration
+
+  Given a truth table, this function enumerates all the functions in its
+  P class. Two functions are in the same P class, if one can be obtained
+  from the other by input permutation.
+
+  The function takes a callback as second parameter which is called for
+  every enumerated function. The callback should take as parameters:
+  - P-enumerated truth table
+  - input permutation to apply
+
+  \param tt Truth table
+  \param fn Callback for each enumerated truth table in the P class
+*/
+template<typename TT, typename Callback>
+void exact_p_enumeration( const TT& tt, Callback&& fn )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  const auto num_vars = tt.num_vars();
+
+  /* Special case for n = 0 */
+  if ( num_vars == 0 )
+  {
+    fn( tt, std::vector<uint8_t>{} );
+    return;
+  }
+
+  /* Special case for n = 1 */
+  if ( num_vars == 1 )
+  {
+    fn( tt, std::vector<uint8_t>{ 0 } );
+    return;
+  }
+
+  assert( num_vars >= 2 && num_vars <= 6 );
+
+  auto t1 = tt;
+
+  std::vector<uint8_t> perm( num_vars );
+  std::iota( perm.begin(), perm.end(), 0u );
+
+  fn( t1, perm );
+
+  const auto& swaps = detail::swaps[num_vars - 2u];
+
+  for ( std::size_t i = 0; i < swaps.size(); ++i )
+  {
+    const auto pos = swaps[i];
+    swap_adjacent_inplace( t1, pos );
+
+    std::swap( perm[pos], perm[pos + 1] );
+
+    fn( t1, perm );
+  }
+}
+
+/*! \brief Exact multi P enumeration
+
+  Given multiple truth tables, this function enumerates all the functions in their
+  P class. Two functions are in the same P class, if one can be obtained
+  from the other by input permutation.
+
+  The function takes a callback as second parameter which is called for
+  every enumerated function. The callback should take as parameters:
+  - P-enumerated truth tables
+  - input permutation to apply
+
+  \param tt Truth tables
+  \param fn Callback for each enumerated truth table in the P class
+*/
+template<typename TT, typename Callback>
+void exact_multi_p_enumeration( const std::vector<TT>& tts, Callback&& fn )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  assert( tts.size() > 0 );
+
+  const auto num_vars = tts[0].num_vars();
+
+  for ( auto i = 0; i < tts.size(); ++i )
+    assert( tts[i].num_vars == num_vars );
+
+  /* Special case for n = 0 */
+  if ( num_vars == 0 )
+  {
+    fn( tts, std::vector<uint8_t>{} );
+    return;
+  }
+
+  /* Special case for n = 1 */
+  if ( num_vars == 1 )
+  {
+    fn( tts, std::vector<uint8_t>{ 0 } );
+    return;
+  }
+
+  assert( num_vars >= 2 && num_vars <= 6 );
+
+  auto t1 = tts;
+
+  std::vector<uint8_t> perm( num_vars );
+  std::iota( perm.begin(), perm.end(), 0u );
+
+  fn( t1, perm );
+
+  const auto& swaps = detail::swaps[num_vars - 2u];
+
+  for ( std::size_t i = 0; i < swaps.size(); ++i )
+  {
+    const auto pos = swaps[i];
+
+    for ( auto& tt : t1 )
+      swap_adjacent_inplace( tt, pos );
+
+    std::swap( perm[pos], perm[pos + 1] );
+
+    fn( t1, perm );
+  }
+}
+
+/*! \brief Exact N enumeration
+
+  Given a truth table, this function enumerates all the functions in its
+  N class. Two functions are in the same N class, if one can be obtained
+  from the other by input negation.
+
+  The function takes a callback as second parameter which is called for
+  every enumerated function. The callback should take as parameters:
+  - N-enumerated truth table
+  - input negation to apply
+
+  \param tt Truth table
+  \param fn Callback for each enumerated truth table in the N class
+*/
+template<typename TT, typename Callback>
+void exact_n_enumeration( const TT& tt, Callback&& fn )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  const auto num_vars = tt.num_vars();
+
+  /* Special case for n = 0 */
+  if ( num_vars == 0 )
+  {
+    fn( tt, 0 );
+    return;
+  }
+
+  /* Special case for n = 1 */
+  if ( num_vars == 1 )
+  {
+    fn( tt, 0 );
+    return;
+  }
+
+  assert( num_vars >= 2 && num_vars <= 6 );
+
+  auto t1 = tt;
+  fn( t1, 0 );
+
+  const auto& flips = detail::flips[num_vars - 2u];
+  uint32_t phase = 0;
+
+  for ( std::size_t j = 0; j < flips.size(); ++j )
+  {
+    const auto pos = flips[j];
+    flip_inplace( t1, pos );
+
+    phase ^= 1 << pos;
+
+    fn( t1, phase );
+  }
+}
+
+/*! \brief Exact N canonization complete
+
+  Given a truth table, this function finds the lexicographically smallest truth
+  table in its N class, called N representative. Two functions are in the
+  same N class, if one can obtain one from the other by input negations.
+
+  The function can accept a callback as second parameter which is called for
+  every visited function when trying out all combinations.  This allows to
+  exhaustively visit the whole N class.
+
+  The function returns all the N configurations which contains the necessary
+  transformations to obtain the representative.  It is a tuple of
+
+  - the N representative
+  - a vector of all input negations that lead to the representative
+
+  \param tt The truth table
+  \param fn Callback for each visited truth table in the class (default does nothing)
+  \return N configurations
+*/
+template<typename TT, typename Callback = decltype( detail::exact_npn_canonization_null_callback<TT> )>
+std::tuple<TT, std::vector<uint32_t>> exact_n_canonization_complete( const TT& tt, Callback&& fn = detail::exact_npn_canonization_null_callback<TT> )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  const auto num_vars = tt.num_vars();
+
+  /* Special case for n = 0 */
+  if ( num_vars == 0 )
+  {
+    return std::make_tuple( tt, std::vector<uint32_t>{ 0 } );
+  }
+
+  /* Special case for n = 1 */
+  if ( num_vars == 1 )
+  {
+    return std::make_tuple( tt, std::vector<uint32_t>{ 0 } );
+  }
+
+  assert( num_vars >= 2 && num_vars <= 6 );
+
+  auto t1 = tt;
+  auto tmin = t1;
+
+  fn( t1 );
+
+  const auto& flips = detail::flips[num_vars - 2u];
+
+  std::vector<int> best_flip{ -1 };
+
+  for ( std::size_t j = 0; j < flips.size(); ++j )
+  {
+    const auto pos = flips[j];
+    flip_inplace( t1, pos );
+
+    fn( t1 );
+
+    if ( t1 < tmin )
+    {
+      best_flip.erase( best_flip.begin() + 1, best_flip.end() );
+      best_flip[0] = static_cast<int>( j );
+      tmin = t1;
+    }
+    else if ( t1 == tmin )
+    {
+      best_flip.push_back( static_cast<int>( j ) );
+    }
+  }
+
+  std::vector<uint32_t> phases( best_flip.size() );
+  uint32_t phase = 0;
+  int cnt = 0;
+  for ( auto i = 0u; i < best_flip.size(); ++i )
+  {
+    auto flip = best_flip[i];
+    for ( ; cnt <= flip; ++cnt )
+    {
+      phase ^= 1 << flips[cnt];
+    }
+    phases[i] = phase;
+  }
+
+  return std::make_tuple( tmin, phases );
+}
+
+/*! \brief Obtain truth table from NPN configuration
+
+  Given an NPN configuration, which contains a representative
+  function, input/output negations, and input permutations this
+  function computes the original truth table.
+
+  \param config NPN configuration
+*/
+template<typename TT>
+TT create_from_npn_config( const std::tuple<TT, uint32_t, std::vector<uint8_t>>& config )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  const auto& from = std::get<0>( config );
+  const auto& phase = std::get<1>( config );
+  auto perm = std::get<2>( config );
+  const auto num_vars = from.num_vars();
+
+  /* is output complemented? */
+  auto res = ( ( phase >> num_vars ) & 1 ) ? ~from : from;
+
+  /* input permutations */
+  for ( auto i = 0u; i < num_vars; ++i )
+  {
+    if ( perm[i] == i )
+    {
+      continue;
+    }
+
+    int k = i;
+    while ( perm[k] != i )
+    {
+      ++k;
+    }
+
+    swap_inplace( res, i, k );
+    std::swap( perm[i], perm[k] );
+  }
+
+  /* input complementations */
+  for ( auto i = 0u; i < num_vars; ++i )
+  {
+    if ( ( phase >> i ) & 1 )
+    {
+      flip_inplace( res, i );
+    }
+  }
+
+  return res;
+}
+
+/*! \brief Obtain truth table applying a NPN configuration
+
+  Given an NPN configuration composed of input/output negations,
+  and input permutations this function applies the transformation
+  to the input truth table. This function can be used to obtain
+  the NPN representative function given the NPN transformation.
+  This function is the inverse of `create_from_npn_config`.
+
+  \param from truth table
+  \param phase input/output negations to apply
+  \param perm input permutations to apply
+*/
+template<typename TT>
+TT apply_npn_transformation( TT const& from, uint32_t phase, std::vector<uint8_t> const& perm )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  /* transpose the permutation vector */
+  std::vector<uint8_t> perm_transposed( perm.size() );
+  for ( auto i = 0; i < perm.size(); ++i )
+    perm_transposed[perm[i]] = i;
+
+  const auto num_vars = from.num_vars();
+
+  /* is output complemented? */
+  auto res = ( ( phase >> num_vars ) & 1 ) ? ~from : from;
+
+  /* input complementations */
+  for ( auto i = 0u; i < num_vars; ++i )
+  {
+    if ( ( phase >> i ) & 1 )
+    {
+      flip_inplace( res, i );
+    }
+  }
+
+  /* input permutations */
+  for ( auto i = 0u; i < num_vars; ++i )
+  {
+    if ( perm_transposed[i] == i )
+    {
+      continue;
+    }
+
+    int k = i;
+    while ( perm_transposed[k] != i )
+    {
+      ++k;
+    }
+
+    swap_inplace( res, i, k );
+    std::swap( perm_transposed[i], perm_transposed[k] );
+  }
+
+  return res;
+}
+
+} /* namespace kitty */
\ No newline at end of file
diff --git a/lib/kitty/kitty/operations.hpp b/lib/kitty/kitty/operations.hpp
new file mode 100644
index 0000000..007f6ac
--- /dev/null
+++ b/lib/kitty/kitty/operations.hpp
@@ -0,0 +1,2428 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file operations.hpp
+  \brief Implements several operations on truth tables
+
+  \author Mathias Soeken
+  \author Mahyar Emami (mahyar.emami@epfl.ch)
+*/
+
+#pragma once
+
+#include "algorithm.hpp"
+#include "dynamic_truth_table.hpp"
+#include "static_truth_table.hpp"
+#include "partial_truth_table.hpp"
+#include "ternary_truth_table.hpp"
+#include "quaternary_truth_table.hpp"
+#include "detail/shift.hpp"
+#include "traits.hpp"
+
+#include <algorithm>
+#include <cassert>
+#include <functional>
+#include <iterator>
+#include <optional>
+
+namespace kitty
+{
+
+/* forward declarations */
+/*! \cond PRIVATE */
+template<typename TT>
+TT create( unsigned num_vars );
+
+template<>
+dynamic_truth_table create<dynamic_truth_table>( unsigned num_vars );
+/*! \endcond */
+
+/*! \brief Inverts all bits in a truth table */
+template<typename TT>
+inline TT unary_not( const TT& tt )
+{
+  return unary_operation( tt, []( auto a )
+                          { return ~a; } );
+}
+
+template<typename TT>
+inline ternary_truth_table<TT> unary_not( const ternary_truth_table<TT>& tt )
+{
+  return ternary_truth_table<TT>( ~( tt._bits ) & tt._care, tt._care );
+}
+
+template<typename TT>
+inline quaternary_truth_table<TT> unary_not( const quaternary_truth_table<TT>& tt )
+{
+  return quaternary_truth_table<TT>( tt._offset, tt._onset );
+}
+
+/*! Inverts all bits in a truth table, based on a condition */
+template<typename TT>
+inline TT unary_not_if( const TT& tt, bool cond )
+{
+#ifdef _MSC_VER
+#pragma warning( push )
+#pragma warning( disable : 4146 )
+#endif
+  const auto mask = -static_cast<uint64_t>( cond );
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+  return unary_operation( tt, [mask]( auto a )
+                          { return a ^ mask; } );
+}
+
+/*! \brief Bitwise AND of two truth tables */
+template<typename TT>
+
+inline TT binary_and( const TT& first, const TT& second )
+{
+  return binary_operation( first, second, std::bit_and<>() );
+}
+
+/*! \brief Bitwise AND of two ternary truth tables
+ *
+ * Computation rules:
+ * - `0 & 0 = 0 & 1 = 1 & 0 = 0`
+ * - `1 & 1 = 1`
+ * - `0 & - = - & 0 = 0`
+ * - `1 & x = x & 1 = x & - = - & x = x & x = x`
+ */
+template<typename TT>
+inline ternary_truth_table<TT> binary_and( const ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second )
+{
+  auto const op_bits = []( auto b1, auto c1, auto b2, auto c2 )
+  {
+    return b1 & b2;
+  };
+  auto const op_care = []( auto b1, auto c1, auto b2, auto c2 )
+  {
+    return ( c1 & c2 ) | ( ~b1 & c1 ) | ( ~b2 & c2 );
+  };
+
+  return ternary_truth_table<TT>( quaternary_operation( first._bits, first._care, second._bits, second._care, op_bits ),
+                                  quaternary_operation( first._bits, first._care, second._bits, second._care, op_care ) );
+}
+
+/*! \brief Bitwise OR of two quaternary truth tables
+ *
+ * Computation rules:
+ * - `0 & 0 = 0 & 1 = 1 & 0 = 0`
+ * - `1 & 1 = 1`
+ * - `0 & - = - & 0 = x & 0 = 0 & x = 0`
+ * - `1 & - = - & 1 = - & - = -`
+ * - `1 & x = x & 1 = x & - = - & x = x & x = x`
+ */
+template<typename TT>
+inline quaternary_truth_table<TT> binary_and( const quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second )
+{
+  auto const op_on = []( auto a, auto b )
+  {
+    return a & b;
+  };
+  auto const op_off = []( auto a, auto b, auto c, auto d )
+  {
+    return ( ~a & b ) | ( b & c ) | ( a & d ) | ( ~b & ~c & d );
+  };
+
+  return quaternary_truth_table<TT>( binary_operation( first._onset, second._onset, op_on ),
+                                     quaternary_operation( first._onset, first._offset, second._onset, second._offset, op_off ) );
+}
+
+/*! \brief Bitwise OR of two truth tables */
+template<typename TT>
+inline TT binary_or( const TT& first, const TT& second )
+{
+  return binary_operation( first, second, std::bit_or<>() );
+}
+
+/*! \brief Bitwise OR of two ternary truth tables
+ *
+ * Computation rules:
+ * - `0 | 0 = 0`
+ * - `0 | 1 = 1 | 0 = 1 | 1 = 1`
+ * - `1 | - = - | 1 = 1`
+ * - `0 | - = - | 0 = - | - = -`
+ */
+template<typename TT>
+inline ternary_truth_table<TT> binary_or( const ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second )
+{
+  auto const op_bits = []( auto b1, auto c1, auto b2, auto c2 )
+  {
+    return b1 | b2;
+  };
+  auto const op_care = []( auto b1, auto c1, auto b2, auto c2 )
+  {
+    return b1 | b2 | ( c1 & c2 );
+  };
+
+  return ternary_truth_table<TT>( quaternary_operation( first._bits, first._care, second._bits, second._care, op_bits ),
+                                  quaternary_operation( first._bits, first._care, second._bits, second._care, op_care ) );
+}
+
+/*! \brief Bitwise OR of two quaternary truth tables
+ *
+ * Computation rules:
+ * - `0 | 0 = 0`
+ * - `0 | 1 = 1 | 0 = 1 | 1 = 1`
+ * - `1 | - = - | 1 = x | 1 = 1 | x = 1`
+ * - `0 | - = - | 0 = - | - = -`
+ * - `0 | x = x | 0 = x | - = - | x = x | x = x`
+ */
+template<typename TT>
+inline quaternary_truth_table<TT> binary_or( const quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second )
+{
+  auto const op_on = []( auto a, auto b, auto c, auto d )
+  {
+    return ( a & ~b ) | ( b & c ) | ( c & ~d ) | ( a & b & d );
+  };
+  auto const op_off = []( auto a, auto b )
+  {
+    return a & b;
+  };
+
+  return quaternary_truth_table<TT>( quaternary_operation( first._onset, first._offset, second._onset, second._offset, op_on ),
+                                     binary_operation( first._offset, second._offset, op_off ) );
+}
+
+/*! \brief Bitwise XOR of two truth tables */
+template<typename TT>
+inline TT binary_xor( const TT& first, const TT& second )
+{
+  return binary_operation( first, second, std::bit_xor<>() );
+}
+
+/*! \brief Bitwise XOR of two ternary truth tables
+ *
+ * Computation rules:
+ * - `0 ^ 0 = 1 ^ 1 = 0`
+ * - `0 ^ 1 = 1 ^ 0 = 1`
+ * - `0 ^ - = - ^ 0 = 1 ^ - = - ^ 1 = - ^ - = -`
+ */
+template<typename TT>
+inline ternary_truth_table<TT> binary_xor( const ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second )
+{
+  auto const op_bits = []( auto b1, auto c1, auto b2, auto c2 )
+  {
+    return ( b1 ^ b2 ) & ( c1 & c2 );
+  };
+  auto const op_care = []( auto b1, auto c1, auto b2, auto c2 )
+  {
+    return c1 & c2;
+  };
+
+  return ternary_truth_table<TT>( quaternary_operation( first._bits, first._care, second._bits, second._care, op_bits ),
+                                  quaternary_operation( first._bits, first._care, second._bits, second._care, op_care ) );
+}
+
+/*! \brief Bitwise XOR of two ternary truth tables
+ *
+ * Computation rules:
+ * - `0 ^ 0 = 1 ^ 1 = 0`
+ * - `0 ^ 1 = 1 ^ 0 = 1`
+ * - `0 ^ - = - ^ 0 = 1 ^ - = - ^ 1 = - ^ - = -`
+ * - `0 ^ x = x ^ 0 = 1 ^ x = x ^ 1 = - ^ x = x ^ - = x ^ x = x`
+ */
+template<typename TT>
+inline quaternary_truth_table<TT> binary_xor( const quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second )
+{
+  auto const op_on = []( auto a, auto b, auto c, auto d )
+  {
+    return ( b & c ) | ( a & d );
+  };
+  auto const op_off = []( auto a, auto b, auto c, auto d )
+  {
+    return ( a & c ) | ( b & d );
+  };
+
+  return quaternary_truth_table<TT>( quaternary_operation( first._onset, first._offset, second._onset, second._offset, op_on ),
+                                     quaternary_operation( first._onset, first._offset, second._onset, second._offset, op_off ) );
+}
+
+/*! \brief Ternary majority of three truth tables */
+template<typename TT>
+inline TT ternary_majority( const TT& first, const TT& second, const TT& third )
+{
+  return ternary_operation( first, second, third, []( auto a, auto b, auto c )
+                            { return ( a & ( b ^ c ) ) ^ ( b & c ); } );
+}
+
+/*! \brief Ternary majority of three truth tables */
+template<typename TT>
+inline ternary_truth_table<TT> ternary_majority( const ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second, const ternary_truth_table<TT>& third )
+{
+  auto const op_bits = []( auto a, auto b, auto c )
+  {
+    return ( a & ( b ^ c ) ) ^ ( b & c );
+  };
+  auto const op_care = []( auto b1, auto c1, auto b2, auto c2 )
+  {
+    return ( b1 & c1 & b2 & c2 ) | ( ( ~b1 ) & c1 & ( ~b2 ) & c2 );
+  };
+  TT care12 = quaternary_operation( first._bits, first._care, second._bits, second._care, op_care );
+  TT care23 = quaternary_operation( second._bits, second._care, third._bits, third._care, op_care );
+  TT care13 = quaternary_operation( first._bits, first._care, third._bits, third._care, op_care );
+  auto const ternary_or = []( auto a, auto b, auto c )
+  {
+    return a | b | c;
+  };
+  return ternary_truth_table<TT>( ternary_operation( first._bits, second._bits, third._bits, op_bits ),
+                                  ternary_operation( care12, care23, care13, ternary_or ) );
+}
+
+/*! \brief Ternary majority of three quaternary truth tables
+ *
+ * Computation rules:
+ * When there are two 0, 1, or x the result is 0, 1, x
+ * - ternary_majority(0, 1, -) = ternary_majority(0, -, -) =  ternary_majority(1, -, -) =  -
+ * - ternary_majority(0, 1, x) = ternary_majority(0, x, -) = ternary_majority(1, x, -) = ternary_majority(x, -, -) = x
+ * - ternary_majority is commutative
+ */
+template<typename TT>
+inline quaternary_truth_table<TT> ternary_majority( quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second, const quaternary_truth_table<TT>& third )
+{
+  return ( ( first & second ) | ( second & third ) ) | ( first & third );
+}
+
+/*! \brief Performs ternary if-then-else of three truth tables
+
+  \param first Truth table for condition
+  \param second Truth table for then-case
+  \param third Truth table for else-case
+ */
+template<typename TT>
+inline TT ternary_ite( const TT& first, const TT& second, const TT& third )
+{
+  return ternary_operation( first, second, third, []( auto a, auto b, auto c )
+                            { return ( a & b ) ^ ( ~a & c ); } );
+}
+
+template<typename TT>
+inline ternary_truth_table<TT> ternary_ite( const ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second, const ternary_truth_table<TT>& third )
+{
+  auto const op_bits = []( auto a, auto b, auto c )
+  {
+    return ( a & b ) ^ ( ~a & c );
+  };
+  auto const op_care1 = []( auto b2, auto c2, auto b3, auto c3 )
+  {
+    return ( ( ~b2 ) & c2 & b3 ) | ( b2 & c2 & ( ~b3 ) ) | ( c2 & ( ~c3 ) ) | ( c3 & ( ~c2 ) ) | ( ( ~c3 ) & ( ~c2 ) );
+  };
+  auto const op_care2 = []( auto b1, auto c1, auto c2, auto c3 )
+  {
+    return c1 & ( ( ( ~c2 ) & b1 ) | ( ( ~b1 ) & ( ~c3 ) ) | ( ( ~c3 ) & ( ~c2 ) ) );
+  };
+  TT care1 = quaternary_operation( second._bits, second._care, third._bits, third._care, op_care1 );
+  TT care2 = quaternary_operation( first._bits, first._care, second._care, third._care, op_care2 );
+  auto const final_op = []( auto c1, auto res1, auto res2 )
+  {
+    return ~( ( ( ~c1 ) & res1 ) | res2 );
+  };
+  return ternary_truth_table<TT>( ternary_operation( first._bits, second._bits, third._bits, op_bits ),
+                                  ternary_operation( first._care, care1, care2, final_op ) );
+}
+
+/*! \brief Performs ternary if-then-else of three quaternary truth tables
+
+   In general, each time the result would depend from a x, x is the result.
+   For example, ternary_ite( -, 0, x ) = x
+   However, ternary_ite( x, 0, 0 ) = ternary_ite( -, 0, 0 ) = 0
+            ternary_ite( x, 1, 1 ) = ternary_ite( -, 1, 1 ) = 1
+            ternary_ite( x, -, - ) = ternary_ite( -, -, - ) = -
+
+  \param first Truth table for condition
+  \param second Truth table for then-case
+  \param third Truth table for else-case
+ */
+template<typename TT>
+inline quaternary_truth_table<TT> ternary_ite( const quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second, const quaternary_truth_table<TT>& third )
+{
+  auto const op_1 = []( auto a, auto b, auto c, auto d )
+  {
+    return ( a & b ) & ( ( c & d ) | ( ~c & ~d ) );
+  };
+  auto const op_2 = []( auto a, auto b, auto c )
+  {
+    return ( a & b & c );
+  };
+  auto const op_3 = []( auto a, auto b, auto c )
+  {
+    return ( a & b & ~c );
+  };
+  auto const or_4 = []( auto a, auto b, auto c, auto d )
+  {
+    return ( a | b | c | d );
+  };
+  auto const or_3 = []( auto a, auto b, auto c )
+  {
+    return ( a | b | c );
+  };
+  TT on1 = ternary_operation( first._offset, third._onset, first._onset, op_3 );
+  TT on2 = ternary_operation( first._onset, second._onset, first._offset, op_3 );
+  TT on3 = ternary_operation( first._offset, second._onset, third._onset, op_2 );
+  TT on4 = ternary_operation( first._offset, second._offset, third._onset, op_2 );
+  TT on5 = ternary_operation( first._onset, second._onset, third._offset, op_2 );
+  TT on6 = quaternary_operation( second._onset, third._onset, second._offset, third._offset, op_1 );
+  TT on7 = quaternary_operation( on1, on2, on3, on4, or_4 );
+  TT res_onset = ternary_operation( on7, on5, on6, or_3 );
+
+  TT off1 = ternary_operation( third._offset, first._offset, first._onset, op_3 );
+  TT off2 = ternary_operation( first._onset, second._offset, first._offset, op_3 );
+  TT off3 = ternary_operation( first._offset, second._offset, third._offset, op_2 );
+  TT off4 = ternary_operation( first._offset, second._onset, third._offset, op_2 );
+  TT off5 = ternary_operation( first._onset, second._offset, third._onset, op_2 );
+  TT off6 = quaternary_operation( second._offset, third._offset, second._onset, third._onset, op_1 );
+  TT off7 = quaternary_operation( off1, off2, off3, off4, or_4 );
+  TT res_offset = ternary_operation( off7, off5, off6, or_3 );
+
+  return quaternary_truth_table<TT>( res_onset, res_offset );
+}
+
+/*! \brief Muxes two truth tables based on a variable
+
+  \param var_index Variable index
+  \param then_ Truth table for the then-case
+  \param else_ Truth table for the else-case
+*/
+template<typename TT>
+inline TT mux_var( uint8_t var_index, const TT& then_, const TT& else_ )
+{
+  if ( var_index < 6u )
+  {
+    return binary_operation( then_, else_,
+                             [&]( auto a, auto b )
+                             { return ( a & detail::projections[var_index] ) |
+                                      ( b & detail::projections_neg[var_index] ); } );
+  }
+  else
+  {
+    const auto step = 1u << ( var_index - 6u );
+    auto j = 0u;
+    auto res = then_.construct();
+
+    std::transform( then_.begin(), then_.end(), else_.begin(), res.begin(),
+                    [&]( auto a, auto b )
+                    {
+                      return ( j++ % ( 2 * step ) ) < step ? b : a;
+                    } );
+
+    return res;
+  }
+}
+
+/*! \brief Muxes two ternary truth tables based on a variable
+
+ * Values that are not taken by the projections become 0s.
+
+  \param var_index Variable index
+  \param then_ Truth table for the then-case
+  \param else_ Truth table for the else-case
+*/
+template<typename TT>
+inline ternary_truth_table<TT> mux_var( uint8_t var_index, const ternary_truth_table<TT>& then_, const ternary_truth_table<TT>& else_ )
+{
+  auto const projection = [&var_index]( auto a )
+  {
+    return ( a & detail::projections[var_index] );
+  };
+  auto const projection_care = [&var_index]( auto a )
+  {
+    return ( ( a & detail::projections[var_index] ) | detail::projections_neg[var_index] );
+  };
+  auto const projection_neg = [&var_index]( auto a )
+  {
+    return ( a & detail::projections_neg[var_index] );
+  };
+  auto const projection_neg_care = [&var_index]( auto a )
+  {
+    return ( ( a & detail::projections_neg[var_index] ) | detail::projections[var_index] );
+  };
+  ternary_truth_table<TT> then_new( unary_operation( then_._bits, projection ), unary_operation( then_._care, projection_care ) );
+  ternary_truth_table<TT> else_new( unary_operation( else_._bits, projection_neg ), unary_operation( else_._care, projection_neg_care ) );
+  return then_new | else_new;
+}
+
+/*! \brief Muxes two ternary truth tables based on a variable
+
+ * Values that are not taken by the projections become 0s.
+
+  \param var_index Variable index
+  \param then_ Truth table for the then-case
+  \param else_ Truth table for the else-case
+*/
+template<typename TT>
+inline quaternary_truth_table<TT> mux_var( uint8_t var_index, const quaternary_truth_table<TT>& then_, const quaternary_truth_table<TT>& else_ )
+{
+  auto const projection = [&var_index]( auto a )
+  {
+    return ( a & detail::projections[var_index] );
+  };
+  auto const projection_off = [&var_index]( auto a )
+  {
+    return ( ( a & detail::projections[var_index] ) | detail::projections_neg[var_index] );
+  };
+  auto const projection_neg = [&var_index]( auto a )
+  {
+    return ( a & detail::projections_neg[var_index] );
+  };
+  auto const projection_neg_off = [&var_index]( auto a )
+  {
+    return ( ( a & detail::projections_neg[var_index] ) | detail::projections[var_index] );
+  };
+  quaternary_truth_table<TT> then_new( unary_operation( then_._onset, projection ), unary_operation( then_._offset, projection_off ) );
+  quaternary_truth_table<TT> else_new( unary_operation( else_._onset, projection_neg ), unary_operation( else_._offset, projection_neg_off ) );
+  return then_new | else_new;
+}
+
+/*! \brief Checks whether two truth tables are equal
+
+  \param first First truth table
+  \param second Second truth table
+*/
+template<typename TT>
+inline bool equal( const TT& first, const TT& second )
+{
+  if ( first.num_vars() != second.num_vars() )
+  {
+    return false;
+  }
+
+  return binary_predicate( first, second, std::equal_to<>() );
+}
+
+/*! \cond PRIVATE */
+inline bool equal( const partial_truth_table& first, const partial_truth_table& second )
+{
+  if ( first.num_bits() != second.num_bits() )
+  {
+    return false;
+  }
+
+  return binary_predicate( first, second, std::equal_to<>() );
+} /*! \endcond */
+
+template<typename TT>
+inline bool equal( const ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second )
+{
+  return equal( first._bits, second._bits ) && equal( first._care, second._care );
+}
+
+template<typename TT>
+inline bool equal( const quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second )
+{
+  return equal( first._onset, second._onset ) && equal( first._offset, second._offset );
+}
+
+/*! \brief Checks if first truth table implies a second truth table
+
+  \param first First truth table
+  \param second Second truth table
+*/
+template<typename TT>
+inline bool implies( const TT& first, const TT& second )
+{
+  return binary_predicate( first, second, []( uint64_t a, uint64_t b )
+                           { return ( a & ~b ) == 0u; } );
+}
+
+/*! \brief Checks if first ternary truth table implies a second ternary truth table
+
+  \param first First truth table
+  \param second Second truth table
+*/
+template<typename TT>
+inline bool implies( const ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second )
+{
+  return is_const0( first & ~second );
+}
+
+/*! \brief Checks if first quaternary truth table implies a second quaternary truth table
+
+  \param first First truth table
+  \param second Second truth table
+*/
+template<typename TT>
+inline bool implies( const quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second )
+{
+  return is_const0( first & ~second );
+}
+
+/*! \brief Checks whether a truth table is lexicographically smaller than another
+
+  Comparison is initiated from most-significant bit.
+  \param first First truth table
+  \param second Second truth table
+*/
+template<typename TT>
+inline bool less_than( const TT& first, const TT& second )
+{
+  return std::lexicographical_compare( first._bits.rbegin(), first._bits.rend(),
+                                       second._bits.rbegin(), second._bits.rend() );
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+inline bool less_than( const static_truth_table<NumVars, true>& first, const static_truth_table<NumVars, true>& second )
+{
+  return first._bits < second._bits;
+}
+/*! \endcond */
+
+/*! \brief Checks whether a ternary truth table is lexicographically smaller than another
+
+  Comparison is initiated from most-significant bit and don't cares are considered as 0.
+  \param first First truth table
+  \param second Second truth table
+*/
+template<typename TT>
+inline bool less_than( const ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second )
+{
+  return first._bits < second._bits;
+}
+
+/*! \brief Checks whether a quaternary truth table is lexicographically smaller than another
+
+  Comparison is initiated from most-significant bit
+  Don't cares are considered as 0 and don't knows are considered as 1.
+  \param first First truth table
+  \param second Second truth table
+*/
+template<typename TT>
+inline bool less_than( const quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second )
+{
+  return first._onset < second._onset;
+}
+
+/*! \brief Checks whether truth table is contant 0
+
+  \param tt Truth table
+*/
+template<typename TT>
+inline bool is_const0( const TT& tt )
+{
+  return std::all_of( std::begin( tt._bits ), std::end( tt._bits ), []( uint64_t word )
+                      { return word == 0; } );
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+inline bool is_const0( const static_truth_table<NumVars, true>& tt )
+{
+  return tt._bits == 0;
+}
+
+/*! \brief Checks whether a ternary truth table is contant 0
+
+  \param tt Truth table
+*/
+template<typename TT>
+inline bool is_const0( const ternary_truth_table<TT>& tt )
+{
+  return is_const0( tt._bits | ~tt._care );
+}
+
+/*! \brief Checks whether a quaternary truth table is constant composed by only - and 0.
+
+  \param tt Truth table
+*/
+template<typename TT>
+inline bool is_const0( const quaternary_truth_table<TT>& tt )
+{
+  return is_const0( ~tt._offset );
+}
+
+/*! \endcond */
+
+/*! \brief Checks whether the intersection of two truth tables is empty
+
+  \param first First truth table
+  \param second Second truth table
+  \param polarity1 Polarity of the first truth table
+  \param polarity2 Polarity of the second truth table
+*/
+template<typename TT, bool polarity1 = true, bool polarity2 = true, typename = std::enable_if_t<is_completely_specified_truth_table<TT>::value>>
+bool intersection_is_empty( const TT& first, const TT& second )
+{
+  if constexpr ( polarity1 && polarity2 )
+    return binary_predicate( first, second, []( uint64_t a, uint64_t b )
+                             { return ( a & b ) == 0u; } );
+  else if constexpr ( !polarity1 && polarity2 )
+    return binary_predicate( first, second, []( uint64_t a, uint64_t b )
+                             { return ( ~a & b ) == 0u; } );
+  else if constexpr ( polarity1 && !polarity2 )
+    return binary_predicate( first, second, []( uint64_t a, uint64_t b )
+                             { return ( a & ~b ) == 0u; } );
+  else // !polarity1 && !polarity2
+    return binary_predicate( first, second, []( uint64_t a, uint64_t b )
+                             { return ( ~a & ~b ) == 0u; } );
+}
+
+/*! \brief Checks whether the intersection of three truth tables is empty
+
+  \param first First truth table
+  \param second Second truth table
+  \param third Third truth table
+  \param polarity1 Polarity of the first truth table
+  \param polarity2 Polarity of the second truth table
+  \param polarity3 Polarity of the first truth table
+*/
+template<typename TT, bool polarity1 = true, bool polarity2 = true, bool polarity3 = true, typename = std::enable_if_t<is_completely_specified_truth_table<TT>::value>>
+bool intersection_is_empty( const TT& first, const TT& second, const TT& third )
+{
+  if constexpr ( polarity1 && polarity2 && polarity3 )
+    return ternary_predicate( first, second, third, []( uint64_t a, uint64_t b, uint64_t c )
+                              { return ( a & b & c ) == 0u; } );
+  else if constexpr ( !polarity1 && polarity2 && polarity3 )
+    return ternary_predicate( first, second, third, []( uint64_t a, uint64_t b, uint64_t c )
+                              { return ( ~a & b & c ) == 0u; } );
+  else if constexpr ( polarity1 && !polarity2 && polarity3 )
+    return ternary_predicate( first, second, third, []( uint64_t a, uint64_t b, uint64_t c )
+                              { return ( a & ~b & c ) == 0u; } );
+  else if constexpr ( polarity1 && polarity2 && !polarity3 )
+    return ternary_predicate( first, second, third, []( uint64_t a, uint64_t b, uint64_t c )
+                              { return ( a & b & ~c ) == 0u; } );
+  else if constexpr ( !polarity1 && !polarity2 && polarity3 )
+    return ternary_predicate( first, second, third, []( uint64_t a, uint64_t b, uint64_t c )
+                              { return ( ~a & ~b & c ) == 0u; } );
+  else if constexpr ( polarity1 && !polarity2 && !polarity3 )
+    return ternary_predicate( first, second, third, []( uint64_t a, uint64_t b, uint64_t c )
+                              { return ( a & ~b & ~c ) == 0u; } );
+  else if constexpr ( !polarity1 && polarity2 && !polarity3 )
+    return ternary_predicate( first, second, third, []( uint64_t a, uint64_t b, uint64_t c )
+                              { return ( ~a & b & ~c ) == 0u; } );
+  else // !polarity1 && !polarity2 && !polarity3
+    return ternary_predicate( first, second, third, []( uint64_t a, uint64_t b, uint64_t c )
+                              { return ( ~a & ~b & ~c ) == 0u; } );
+}
+
+/*! \brief Checks whether truth table depends on given variable index
+
+  \param tt Truth table
+  \param var_index Variable index
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+bool has_var( const TT& tt, uint8_t var_index )
+{
+  assert( var_index < tt.num_vars() );
+
+  if ( tt.num_vars() <= 6 || var_index < 6 )
+  {
+    return std::any_of( std::begin( tt._bits ), std::end( tt._bits ),
+                        [var_index]( uint64_t word )
+                        { return ( ( word >> ( uint64_t( 1 ) << var_index ) ) & detail::projections_neg[var_index] ) !=
+                                 ( word & detail::projections_neg[var_index] ); } );
+  }
+
+  const auto step = 1 << ( var_index - 6 );
+  for ( auto i = 0u; i < static_cast<uint32_t>( tt.num_blocks() ); i += 2 * step )
+  {
+    for ( auto j = 0; j < step; ++j )
+    {
+      if ( tt._bits[i + j] != tt._bits[i + j + step] )
+      {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+bool has_var( const static_truth_table<NumVars, true>& tt, uint8_t var_index )
+{
+  assert( var_index < tt.num_vars() );
+
+  return ( ( tt._bits >> ( 1 << var_index ) ) & detail::projections_neg[var_index] ) !=
+         ( tt._bits & detail::projections_neg[var_index] );
+}
+/*! \endcond */
+
+/*! \brief Checks whether a ternary truth table depends on given variable index
+           Don't cares are treated like zeros.
+
+  \param tt Truth table
+  \param var_index Variable index
+*/
+template<typename TT>
+bool has_var( const ternary_truth_table<TT>& tt, uint8_t var_index )
+{
+  return has_var( tt._bits, var_index );
+}
+
+/*! \brief Checks whether a quaternary truth table depends on given variable index.
+           This function returns false if the truth table potentially does not depend
+           on the variable (due to don't cares) and returns true if the truth table potentially
+           depends on the variable (due to don't knows).
+
+           For example, has_var( -01-, 0 ) = has_var( -01-, 1 ) = false.
+           In the first case the truth table is considered to be 0011 and
+           in the second case the truth table is considered to be 1010.
+
+           Yet, has_var( x01-, 0 ) = has_var( x01-, 1 ) = true.
+           In the first case we cannot assume x = 0 and
+           in the second case we cannot assume x = 1.
+
+           Finally, has_var( x0-0, 1 ) = true, since the don't care should be
+           equal to an unknown value.
+
+  \param tt Truth table
+  \param var_index Variable index
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+bool has_var( const quaternary_truth_table<TT>& tt, uint8_t var_index )
+{
+  auto const compare_func = []( auto a, auto b, auto c, auto d )
+  {
+    return ( ~a & ~b & ~c & ~d ) | ( b & d ) | ( a & c );
+  };
+  if ( tt.num_vars() <= 6 || var_index < 6 )
+  {
+    auto const projection = [&var_index]( auto a )
+    {
+      return ( a & detail::projections[var_index] );
+    };
+    auto const projection_neg = [&var_index]( auto a )
+    {
+      return ( a & detail::projections_neg[var_index] );
+    };
+    auto proj_pos_on = unary_operation( tt._onset, projection );
+    auto proj_pos_off = unary_operation( tt._offset, projection );
+    auto proj_neg_on = unary_operation( tt._onset, projection_neg ) << ( 1 << var_index );
+    auto proj_neg_off = unary_operation( tt._offset, projection_neg ) << ( 1 << var_index );
+    return !is_const0( ~quaternary_operation( proj_pos_on, proj_pos_off, proj_neg_on, proj_neg_off, compare_func ) );
+  }
+  const auto step = 1 << ( var_index - 6 );
+  for ( auto i = 0u; i < static_cast<uint32_t>( tt.num_blocks() ); i += 2 * step )
+  {
+    for ( auto j = 0; j < step; ++j )
+    {
+      auto tta = create<dynamic_truth_table>( tt._onset.num_vars() );
+      auto ttb = create<dynamic_truth_table>( tt._onset.num_vars() );
+      auto ttc = create<dynamic_truth_table>( tt._onset.num_vars() );
+      auto ttd = create<dynamic_truth_table>( tt._onset.num_vars() );
+      tta._bits[0] = get_block( tt._onset, i + j );
+      ttb._bits[0] = get_block( tt._offset, i + j );
+      ttc._bits[0] = get_block( tt._onset, i + j + step );
+      ttd._bits[0] = get_block( tt._offset, i + j + step );
+      if ( !is_const0( ~quaternary_operation( tta, ttb, ttc, ttd, compare_func ) ) )
+      {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/*! \brief Computes the next lexicographically larger truth table
+
+  This methods updates `tt` to become the next lexicographically
+  larger truth table. If `tt` is already the largest truth table, the
+  updated truth table will contain all zeros.
+
+  \param tt Truth table
+*/
+template<typename TT>
+void next_inplace( TT& tt )
+{
+  if ( tt.num_vars() <= 6u )
+  {
+    tt._bits[0]++;
+    tt.mask_bits();
+  }
+  else
+  {
+    for ( auto i = 0u; i < static_cast<uint32_t>( tt.num_blocks() ); ++i )
+    {
+      /* If incrementing the word does not lead to an overflow, we're done*/
+      if ( ++tt._bits[i] != 0 )
+      {
+        break;
+      }
+    }
+  }
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+inline void next_inplace( static_truth_table<NumVars, true>& tt )
+{
+  tt._bits++;
+  tt.mask_bits();
+}
+/*! \endcond */
+
+/*! \cond PRIVATE */
+inline void next_inplace( partial_truth_table& tt )
+{
+  for ( auto i = 0u; i < static_cast<uint32_t>( tt.num_blocks() ); ++i )
+  {
+    /* If incrementing the word does not lead to an overflow, we're done*/
+    if ( ++tt._bits[i] != 0u )
+    {
+      break;
+    }
+  }
+  tt.mask_bits();
+}
+/*! \endcond */
+
+/*! \brief Computes the next lexicographically larger truth table
+
+  This methods updates `tt` to become the next lexicographically
+  larger truth table. If `tt` is already the largest truth table, the
+  updated truth table will contain all zeros.
+
+  Don't cares are treated like zeros, so the truth tables 1110 and 111- will become 1111.
+
+  This method never increase the number of don't cares of the input truth table.
+
+  For example, truth table -101 will become -110, not -11-.
+
+  \param tt Truth table
+*/
+template<typename TT>
+void next_inplace( ternary_truth_table<TT>& tt )
+{
+  auto copy = tt;
+  next_inplace( tt._bits );
+  tt._care = tt._care | ( tt._bits ^ copy._bits );
+}
+
+/*! \brief Computes the next lexicographically larger truth table
+
+  This methods updates `tt` to become the next lexicographically
+  larger truth table. If `tt` is already the largest truth table, the
+  updated truth table will contain all zeros.
+
+  Lexicographical increasing order for quaternary truth table:
+
+  0, 1, -, x
+
+  \param tt Truth table
+*/
+
+template<typename TT>
+void next_inplace( quaternary_truth_table<TT>& tt )
+{
+  auto copy = tt;
+  auto first_bit_on = find_first_one_bit( tt._onset );
+  auto first_bit_of = find_first_one_bit( tt._offset );
+  if ( first_bit_on == -1 )
+    first_bit_on = tt._onset.num_bits();
+  if ( first_bit_of == -1 )
+    first_bit_of = tt._offset.num_bits();
+  if ( first_bit_of < first_bit_on )
+  {
+    clear_bit( tt._offset, first_bit_of );
+    set_bit( tt._onset, first_bit_of );
+    for ( uint64_t i = 0; i < first_bit_of; i++ )
+    {
+      set_bit( tt._offset, i );
+      clear_bit( tt._onset, i );
+    }
+  }
+  else
+  {
+    if ( first_bit_of > first_bit_on )
+    {
+      set_bit( tt._offset, first_bit_on );
+      for ( uint64_t i = 0; i < first_bit_on; i++ )
+      {
+        set_bit( tt._offset, i );
+        clear_bit( tt._onset, i );
+      }
+    }
+    else
+    {
+      if ( first_bit_of == tt._offset.num_bits() && first_bit_on == tt._onset.num_bits() )
+        set_bit( tt._offset, first_bit_of - 1 );
+      else
+      {
+        clear_bit( tt._onset, first_bit_on );
+        clear_bit( tt._offset, first_bit_on );
+      }
+      for ( uint64_t i = 0; i < first_bit_of; i++ )
+      {
+        set_bit( tt._offset, i );
+        clear_bit( tt._onset, i );
+      }
+    }
+  }
+}
+
+/*! \brief Returns the next lexicographically larger truth table
+
+  Out-of-place variant for `next_inplace`.
+
+  \param tt Truth table
+*/
+template<typename TT>
+inline TT next( const TT& tt )
+{
+  auto copy = tt;
+  next_inplace( copy );
+  return copy;
+}
+
+/*! \brief Computes co-factor with respect to 0
+
+  \param tt Truth table
+  \param var_index Variable index
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void cofactor0_inplace( TT& tt, uint8_t var_index )
+{
+  if ( tt.num_vars() <= 6 || var_index < 6 )
+  {
+    std::transform( std::begin( tt._bits ), std::end( tt._bits ),
+                    std::begin( tt._bits ),
+                    [var_index]( uint64_t word )
+                    { return ( ( word & detail::projections_neg[var_index] ) << ( uint64_t( 1 ) << var_index ) ) |
+                             ( word & detail::projections_neg[var_index] ); } );
+  }
+  else
+  {
+    const auto step = 1 << ( var_index - 6 );
+    for ( auto i = 0u; i < static_cast<uint32_t>( tt.num_blocks() ); i += 2 * step )
+    {
+      for ( auto j = 0; j < step; ++j )
+      {
+        tt._bits[i + j + step] = tt._bits[i + j];
+      }
+    }
+  }
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+void cofactor0_inplace( static_truth_table<NumVars, true>& tt, uint8_t var_index )
+{
+  tt._bits = ( ( tt._bits & detail::projections_neg[var_index] ) << ( 1 << var_index ) ) |
+             ( tt._bits & detail::projections_neg[var_index] );
+}
+/*! \endcond */
+
+/*! \brief Computes co-factor with respect to 0
+
+  \param tt Ternary truth table
+  \param var_index Variable index
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void cofactor0_inplace( ternary_truth_table<TT>& tt, uint8_t var_index )
+{
+  cofactor0_inplace( tt._bits, var_index );
+  cofactor0_inplace( tt._care, var_index );
+}
+
+/*! \brief Computes co-factor with respect to 0
+
+  \param tt Ternary truth table
+  \param var_index Variable index
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void cofactor0_inplace( quaternary_truth_table<TT>& tt, uint8_t var_index )
+{
+  cofactor0_inplace( tt._onset, var_index );
+  cofactor0_inplace( tt._offset, var_index );
+}
+
+/*! \brief Returns co-factor with respect to 0
+
+ \param tt Truth table
+ \param var_index Variable index
+*/
+template<typename TT>
+TT cofactor0( const TT& tt, uint8_t var_index )
+{
+  auto copy = tt;
+  cofactor0_inplace( copy, var_index );
+  return copy;
+}
+
+/*! \brief Computes co-factor with respect to 1
+
+  \param tt Truth table
+  \param var_index Variable index
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void cofactor1_inplace( TT& tt, uint8_t var_index )
+{
+  if ( tt.num_vars() <= 6 || var_index < 6 )
+  {
+    std::transform( std::begin( tt._bits ), std::end( tt._bits ),
+                    std::begin( tt._bits ),
+                    [var_index]( uint64_t word )
+                    { return ( word & detail::projections[var_index] ) |
+                             ( ( word & detail::projections[var_index] ) >> ( uint64_t( 1 ) << var_index ) ); } );
+  }
+  else
+  {
+    const auto step = 1 << ( var_index - 6 );
+    for ( auto i = 0u; i < static_cast<uint32_t>( tt.num_blocks() ); i += 2 * step )
+    {
+      for ( auto j = 0; j < step; ++j )
+      {
+        tt._bits[i + j] = tt._bits[i + j + step];
+      }
+    }
+  }
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+void cofactor1_inplace( static_truth_table<NumVars, true>& tt, uint8_t var_index )
+{
+  tt._bits = ( tt._bits & detail::projections[var_index] ) | ( ( tt._bits & detail::projections[var_index] ) >> ( 1 << var_index ) );
+}
+/*! \endcond */
+
+/*! \brief Computes co-factor with respect to 1
+
+  \param tt Ternary truth table
+  \param var_index Variable index
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void cofactor1_inplace( ternary_truth_table<TT>& tt, uint8_t var_index )
+{
+  cofactor1_inplace( tt._bits, var_index );
+  cofactor1_inplace( tt._care, var_index );
+}
+
+/*! \brief Computes co-factor with respect to 1
+
+  \param tt Ternary truth table
+  \param var_index Variable index
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void cofactor1_inplace( quaternary_truth_table<TT>& tt, uint8_t var_index )
+{
+  cofactor1_inplace( tt._onset, var_index );
+  cofactor1_inplace( tt._offset, var_index );
+}
+
+/*! \brief Returns co-factor with respect to 1
+
+ \param tt Truth table
+ \param var_index Variable index
+*/
+template<typename TT>
+TT cofactor1( const TT& tt, uint8_t var_index )
+{
+  auto copy = tt;
+  cofactor1_inplace( copy, var_index );
+  return copy;
+}
+
+/*! \brief Swaps two adjacent variables in a truth table
+
+  The function swaps variable `var_index` with `var_index + 1`.  The
+  function will change `tt` in-place.  If `tt` should not be changed,
+  one can use `swap_adjacent` instead.
+
+  \param tt Truth table
+  \param var_index A variable
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void swap_adjacent_inplace( TT& tt, uint8_t var_index )
+{
+  assert( var_index < tt.num_vars() - 1 );
+
+  /* permute within each word */
+  if ( var_index < 5 )
+  {
+    const auto shift = uint64_t( 1 ) << var_index;
+    std::transform( std::begin( tt._bits ), std::end( tt._bits ), std::begin( tt._bits ),
+                    [shift, var_index]( uint64_t word )
+                    {
+                      return ( word & detail::permutation_masks[var_index][0] ) |
+                             ( ( word & detail::permutation_masks[var_index][1] ) << shift ) |
+                             ( ( word & detail::permutation_masks[var_index][2] ) >> shift );
+                    } );
+  }
+  /* permute (half) parts of words */
+  else if ( var_index == 5 )
+  {
+    auto it = std::begin( tt._bits );
+    while ( it != std::end( tt._bits ) )
+    {
+      const auto tmp = *it;
+      auto it2 = it + 1;
+      *it = ( tmp & 0xffffffff ) | ( *it2 << 0x20 );
+      *it2 = ( *it2 & UINT64_C( 0xffffffff00000000 ) ) | ( tmp >> 0x20 );
+      it += 2;
+    }
+  }
+  /* permute comlete words */
+  else
+  {
+    const auto step = 1 << ( var_index - 6 );
+    auto it = std::begin( tt._bits );
+    while ( it != std::end( tt._bits ) )
+    {
+      for ( auto i = decltype( step ){ 0 }; i < step; ++i )
+      {
+        std::swap( *( it + i + step ), *( it + i + 2 * step ) );
+      }
+      it += 4 * step;
+    }
+  }
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+void swap_adjacent_inplace( static_truth_table<NumVars, true>& tt, uint8_t var_index )
+{
+  assert( var_index < tt.num_vars() );
+
+  const auto shift = uint64_t( 1 ) << var_index;
+
+  tt._bits = ( tt._bits & detail::permutation_masks[var_index][0] ) |
+             ( ( tt._bits & detail::permutation_masks[var_index][1] ) << shift ) |
+             ( ( tt._bits & detail::permutation_masks[var_index][2] ) >> shift );
+}
+/*! \endcond */
+
+/*! \brief Swaps two adjacent variables in a truth table
+
+  The function swaps variable `var_index` with `var_index + 1`.  The
+  function will change `tt` in-place.  If `tt` should not be changed,
+  one can use `swap_adjacent` instead.
+
+  \param tt Truth table
+  \param var_index A variable
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void swap_adjacent_inplace( ternary_truth_table<TT>& tt, uint8_t var_index )
+{
+  swap_adjacent_inplace( tt._bits, var_index );
+  swap_adjacent_inplace( tt._care, var_index );
+}
+
+/*! \brief Swaps two adjacent variables in a truth table
+
+  The function swaps variable `var_index` with `var_index + 1`.  The
+  function will change `tt` in-place.  If `tt` should not be changed,
+  one can use `swap_adjacent` instead.
+
+  \param tt Truth table
+  \param var_index A variable
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void swap_adjacent_inplace( quaternary_truth_table<TT>& tt, uint8_t var_index )
+{
+  swap_adjacent_inplace( tt._onset, var_index );
+  swap_adjacent_inplace( tt._offset, var_index );
+}
+
+/*! \brief Swaps two adjacent variables in a truth table
+
+  The function swaps variable `var_index` with `var_index + 1`.  The
+  function will return a new truth table with the result.
+
+  \param tt Truth table
+  \param var_index A variable
+*/
+template<typename TT>
+inline TT swap_adjacent( const TT& tt, uint8_t var_index )
+{
+  auto copy = tt;
+  swap_adjacent_inplace( copy, var_index );
+  return copy;
+}
+
+/*! \brief Swaps two variables in a truth table
+
+  The function swaps variable `var_index1` with `var_index2`.  The
+  function will change `tt` in-place.  If `tt` should not be changed,
+  one can use `swap` instead.
+
+  \param tt Truth table
+  \param var_index1 First variable
+  \param var_index2 Second variable
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void swap_inplace( TT& tt, uint8_t var_index1, uint8_t var_index2 )
+{
+  if ( var_index1 == var_index2 )
+  {
+    return;
+  }
+
+  if ( var_index1 > var_index2 )
+  {
+    std::swap( var_index1, var_index2 );
+  }
+
+  if ( tt.num_vars() <= 6 )
+  {
+    const auto& pmask = detail::ppermutation_masks[var_index1][var_index2];
+    const auto shift = ( 1 << var_index2 ) - ( 1 << var_index1 );
+    tt._bits[0] = ( tt._bits[0] & pmask[0] ) | ( ( tt._bits[0] & pmask[1] ) << shift ) | ( ( tt._bits[0] & pmask[2] ) >> shift );
+  }
+  else if ( var_index2 <= 5 )
+  {
+    const auto& pmask = detail::ppermutation_masks[var_index1][var_index2];
+    const auto shift = ( 1 << var_index2 ) - ( 1 << var_index1 );
+    std::transform( std::begin( tt._bits ), std::end( tt._bits ), std::begin( tt._bits ),
+                    [shift, &pmask]( uint64_t word )
+                    {
+                      return ( word & pmask[0] ) | ( ( word & pmask[1] ) << shift ) | ( ( word & pmask[2] ) >> shift );
+                    } );
+  }
+  else if ( var_index1 <= 5 ) /* in this case, var_index2 > 5 */
+  {
+    const auto step = 1 << ( var_index2 - 6 );
+    const auto shift = 1 << var_index1;
+    auto it = std::begin( tt._bits );
+    while ( it != std::end( tt._bits ) )
+    {
+      for ( auto i = decltype( step ){ 0 }; i < step; ++i )
+      {
+        const auto low_to_high = ( *( it + i ) & detail::projections[var_index1] ) >> shift;
+        const auto high_to_low = ( *( it + i + step ) << shift ) & detail::projections[var_index1];
+        *( it + i ) = ( *( it + i ) & ~detail::projections[var_index1] ) | high_to_low;
+        *( it + i + step ) = ( *( it + i + step ) & detail::projections[var_index1] ) | low_to_high;
+      }
+      it += 2 * step;
+    }
+  }
+  else
+  {
+    const auto step1 = 1 << ( var_index1 - 6 );
+    const auto step2 = 1 << ( var_index2 - 6 );
+    auto it = std::begin( tt._bits );
+    while ( it != std::end( tt._bits ) )
+    {
+      for ( auto i = 0; i < step2; i += 2 * step1 )
+      {
+        for ( auto j = 0; j < step1; ++j )
+        {
+          std::swap( *( it + i + j + step1 ), *( it + i + j + step2 ) );
+        }
+      }
+      it += 2 * step2;
+    }
+  }
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+inline void swap_inplace( static_truth_table<NumVars, true>& tt, uint8_t var_index1, uint8_t var_index2 )
+{
+  if ( var_index1 == var_index2 )
+  {
+    return;
+  }
+
+  if ( var_index1 > var_index2 )
+  {
+    std::swap( var_index1, var_index2 );
+  }
+
+  const auto& pmask = detail::ppermutation_masks[var_index1][var_index2];
+  const auto shift = ( 1 << var_index2 ) - ( 1 << var_index1 );
+  tt._bits = ( tt._bits & pmask[0] ) | ( ( tt._bits & pmask[1] ) << shift ) | ( ( tt._bits & pmask[2] ) >> shift );
+}
+/* \endcond */
+
+/*! \brief Swaps two variables in a truth table
+
+  The function swaps variable `var_index1` with `var_index2`.  The
+  function will change `tt` in-place.  If `tt` should not be changed,
+  one can use `swap` instead.
+
+  \param tt Ternary truth table
+  \param var_index1 First variable
+  \param var_index2 Second variable
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void swap_inplace( ternary_truth_table<TT>& tt, uint8_t var_index1, uint8_t var_index2 )
+{
+  swap_inplace( tt._bits, var_index1, var_index2 );
+  swap_inplace( tt._care, var_index1, var_index2 );
+}
+
+/*! \brief Swaps two variables in a truth table
+
+  The function swaps variable `var_index1` with `var_index2`.  The
+  function will change `tt` in-place.  If `tt` should not be changed,
+  one can use `swap` instead.
+
+  \param tt Ternary truth table
+  \param var_index1 First variable
+  \param var_index2 Second variable
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void swap_inplace( quaternary_truth_table<TT>& tt, uint8_t var_index1, uint8_t var_index2 )
+{
+  swap_inplace( tt._onset, var_index1, var_index2 );
+  swap_inplace( tt._offset, var_index1, var_index2 );
+}
+
+/*! \brief Swaps two adjacent variables in a truth table
+
+  The function swaps variable `var_index1` with `var_index2`.  The
+  function will return a new truth table with the result.
+
+  \param tt Truth table
+  \param var_index1 First variable
+  \param var_index2 Second variable
+*/
+template<typename TT>
+inline TT swap( const TT& tt, uint8_t var_index1, uint8_t var_index2 )
+{
+  auto copy = tt;
+  swap_inplace( copy, var_index1, var_index2 );
+  return copy;
+}
+
+/*! \brief Flips a variable in a truth table
+
+  The function flips variable `var_index` in `tt`.  The function will
+  change `tt` in-place.  If `tt` should not be changed, one can use
+  `flip` instead.
+
+  \param tt Truth table
+  \param var_index A variable
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void flip_inplace( TT& tt, uint8_t var_index )
+{
+  assert( var_index < tt.num_vars() );
+
+  if ( tt.num_blocks() == 1 )
+  {
+    const auto shift = 1 << var_index;
+    tt._bits[0] = ( ( tt._bits[0] << shift ) & detail::projections[var_index] ) | ( ( tt._bits[0] & detail::projections[var_index] ) >> shift );
+  }
+  else if ( var_index < 6 )
+  {
+    const auto shift = 1 << var_index;
+    std::transform( std::begin( tt._bits ), std::end( tt._bits ), std::begin( tt._bits ),
+                    [var_index, shift]( uint64_t word )
+                    {
+                      return ( ( word << shift ) & detail::projections[var_index] ) | ( ( word & detail::projections[var_index] ) >> shift );
+                    } );
+  }
+  else
+  {
+    const auto step = 1 << ( var_index - 6 );
+    auto it = std::begin( tt._bits );
+    while ( it != std::end( tt._bits ) )
+    {
+      for ( auto i = decltype( step ){ 0 }; i < step; ++i )
+      {
+        std::swap( *( it + i ), *( it + i + step ) );
+      }
+      it += 2 * step;
+    }
+  }
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+inline void flip_inplace( static_truth_table<NumVars, true>& tt, uint8_t var_index )
+{
+  assert( var_index < tt.num_vars() );
+
+  const auto shift = 1 << var_index;
+  tt._bits = ( ( tt._bits << shift ) & detail::projections[var_index] ) | ( ( tt._bits & detail::projections[var_index] ) >> shift );
+}
+/* \endcond */
+
+/*! \brief Flips a variable in a ternary truth table
+
+  The function flips variable `var_index` in `tt`.  The function will
+  change `tt` in-place.  If `tt` should not be changed, one can use
+  `flip` instead.
+
+  \param tt Ternary truth table
+  \param var_index A variable
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void flip_inplace( ternary_truth_table<TT>& tt, uint8_t var_index )
+{
+  flip_inplace( tt._bits, var_index );
+  flip_inplace( tt._care, var_index );
+}
+
+/*! \brief Flips a variable in a ternary truth table
+
+  The function flips variable `var_index` in `tt`.  The function will
+  change `tt` in-place.  If `tt` should not be changed, one can use
+  `flip` instead.
+
+  \param tt Ternary truth table
+  \param var_index A variable
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void flip_inplace( quaternary_truth_table<TT>& tt, uint8_t var_index )
+{
+  flip_inplace( tt._onset, var_index );
+  flip_inplace( tt._offset, var_index );
+}
+
+/*! \brief Flips a variable in a truth table
+
+  The function flips variable `var_index` in `tt`.  The function will
+  not change `tt` and return the result as a copy.
+
+  \param tt Truth table
+  \param var_index A variable
+*/
+template<typename TT>
+inline TT flip( const TT& tt, uint8_t var_index )
+{
+  auto copy = tt;
+  flip_inplace( copy, var_index );
+  return copy;
+}
+
+/*! \brief Reorders truth table to have minimum base
+
+  This function will reorder variables, such that there are no
+  "holes".  For example, the function \f$ x_0 \land x_2 \f$ will be
+  changed to \f$ x_0 \land x_1 \f$ by swapping \f$ x_1 \f$ with \f$
+  x_2 \f$.  That is all variables that are not in the functional
+  support will be moved to the back.  Note that the size of the truth
+  table is not changed, because for `static_truth_table` one cannot
+  compute it at compile-time.
+
+  The function changes the truth table and returns a vector with all
+  variable indexes that were in the functional support of the original
+  function.
+
+  \param tt Truth table
+ */
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+std::vector<uint8_t> min_base_inplace( TT& tt )
+{
+  std::vector<uint8_t> support;
+
+  auto k = 0u;
+  for ( auto i = 0u; i < tt.num_vars(); ++i )
+  {
+    if ( !has_var( tt, i ) )
+    {
+      continue;
+    }
+    if ( k < i )
+    {
+      swap_inplace( tt, k, i );
+    }
+    support.push_back( i );
+    ++k;
+  }
+
+  return support;
+}
+
+/*! \brief Expands truth table from minimum base to original based on support
+
+  This is the inverse operation to `min_base_inplace`, where the
+  support is used to swap variables back to their original positions.
+
+  \param tt Truth table
+  \param support Original indexes of support variables
+*/
+template<typename TT>
+void expand_inplace( TT& tt, const std::vector<uint8_t>& support )
+{
+  for ( int i = static_cast<int>( support.size() ) - 1; i >= 0; --i )
+  {
+    assert( i <= support[i] );
+    swap_inplace( tt, i, support[i] );
+  }
+}
+
+/*! \brief Extends smaller truth table to larger one
+
+  The most significant variables will not be in the functional support of the
+  resulting truth table, but the method is helpful to align a truth table when
+  being used with another one.
+
+  \param tt Larger truth table to create
+  \param from Smaller truth table to copy from
+*/
+template<typename TT, typename TTFrom, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void extend_to_inplace( TT& tt, const TTFrom& from )
+{
+  assert( tt.num_vars() >= from.num_vars() );
+
+  if ( from.num_vars() < 6 )
+  {
+    auto mask = *from.begin();
+
+    for ( auto i = from.num_vars(); i < std::min<uint8_t>( 6, tt.num_vars() ); ++i )
+    {
+      mask |= ( mask << ( 1 << i ) );
+    }
+
+    std::fill( tt.begin(), tt.end(), mask );
+  }
+  else
+  {
+    auto it = tt.begin();
+    while ( it != tt.end() )
+    {
+      it = std::copy( from.cbegin(), from.cend(), it );
+    }
+  }
+}
+
+/*! \brief Extends smaller ternary truth table to larger one
+
+  The most significant variables will not be in the functional support of the
+  resulting truth table, but the method is helpful to align a truth table when
+  being used with another one.
+
+  \param tt Larger ternary truth table to create
+  \param from Smaller ternary truth table to copy from
+*/
+template<typename TT, typename TTFrom, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void extend_to_inplace( ternary_truth_table<TT>& tt, const ternary_truth_table<TTFrom>& from )
+{
+  extend_to_inplace( tt._bits, from._bits );
+  extend_to_inplace( tt._care, from._care );
+}
+
+/*! \brief Extends smaller ternary truth table to larger one
+
+  The most significant variables will not be in the functional support of the
+  resulting truth table, but the method is helpful to align a truth table when
+  being used with another one.
+
+  \param tt Larger ternary truth table to create
+  \param from Smaller ternary truth table to copy from
+*/
+template<typename TT, typename TTFrom, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void extend_to_inplace( quaternary_truth_table<TT>& tt, const quaternary_truth_table<TTFrom>& from )
+{
+  extend_to_inplace( tt._onset, from._onset );
+  extend_to_inplace( tt._offset, from._offset );
+}
+
+/*! \brief Extends smaller truth table to larger static one
+
+  This is an out-of-place version of `extend_to_inplace` that has the truth
+  table as a return value.  It only works for creating static truth tables.  The
+  template parameter `NumVars` must be equal or larger to the number of
+  variables in `from`.
+
+  \param from Smaller truth table to copy from
+*/
+template<uint32_t NumVars, typename TTFrom>
+inline static_truth_table<NumVars> extend_to( const TTFrom& from )
+{
+  static_truth_table<NumVars> tt;
+  extend_to_inplace( tt, from );
+  return tt;
+}
+
+/*! \brief Extends smaller truth table to larger dynamic one
+
+  This is an out-of-place version of `extend_to_inplace` that has the truth
+  table as a return value.  It only works for creating dynamic truth tables.
+  The parameter `num_vars` must be equal or larger to the number of variables in
+  `from`.
+
+  \param from Smaller truth table to copy from
+*/
+template<typename TTFrom>
+inline dynamic_truth_table extend_to( const TTFrom& from, unsigned num_vars )
+{
+  auto tt = create<dynamic_truth_table>( num_vars );
+  extend_to_inplace( tt, from );
+  return tt;
+}
+
+/*! \brief Extends smaller ternary truth table to larger one of the same underlying type
+
+  This is an out-of-place version of `extend_to_inplace` that has the truth
+  table as a return value.  It only works for creating dynamic truth tables.
+  The parameter `num_vars` must be equal or larger to the number of variables in
+  `from`.
+
+  \param from Smaller truth table to copy from
+*/
+template<typename TTFrom>
+inline ternary_truth_table<TTFrom> extend_to( const ternary_truth_table<TTFrom>& from, unsigned num_vars )
+{
+  auto tt = ternary_truth_table<TTFrom>( num_vars );
+  extend_to_inplace( tt, from );
+  return tt;
+}
+
+/*! \brief Extends smaller ternary truth table to larger one of the same underlying type
+
+  This is an out-of-place version of `extend_to_inplace` that has the truth
+  table as a return value.  It only works for creating dynamic truth tables.
+  The parameter `num_vars` must be equal or larger to the number of variables in
+  `from`.
+
+  \param from Smaller truth table to copy from
+*/
+template<typename TTFrom>
+inline quaternary_truth_table<TTFrom> extend_to( const quaternary_truth_table<TTFrom>& from, unsigned num_vars )
+{
+  auto tt = quaternary_truth_table<TTFrom>( num_vars );
+  extend_to_inplace( tt, from );
+  return tt;
+}
+
+/*! \brief Shrinks larger truth table to smaller one
+
+  The function expects that the most significant bits, which are cut off, are
+  not in the functional support of the original function.  Only then it is
+  ensured that the resulting function is equivalent.
+
+  \param tt Smaller truth table to create
+  \param from Larger truth table to copy from
+*/
+template<typename TT, typename TTFrom, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void shrink_to_inplace( TT& tt, const TTFrom& from )
+{
+  assert( tt.num_vars() <= from.num_vars() );
+
+  std::copy( from.begin(), from.begin() + tt.num_blocks(), tt.begin() );
+
+  if ( tt.num_vars() < 6 )
+  {
+    tt.mask_bits();
+  }
+}
+
+/*! \brief Shrinks larger ternary truth table to smaller one
+
+  The function expects that the most significant bits, which are cut off, are
+  not in the functional support of the original function.  Only then it is
+  ensured that the resulting function is equivalent.
+
+  \param tt Smaller ternary truth table to create
+  \param from Larger ternary truth table to copy from
+*/
+template<typename TT, typename TTFrom, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void shrink_to_inplace( ternary_truth_table<TT>& tt, const ternary_truth_table<TTFrom>& from )
+{
+  shrink_to_inplace( tt._bits, from._bits );
+  shrink_to_inplace( tt._care, from._care );
+}
+
+/*! \brief Shrinks larger ternary truth table to smaller one
+
+  The function expects that the most significant bits, which are cut off, are
+  not in the functional support of the original function.  Only then it is
+  ensured that the resulting function is equivalent.
+
+  \param tt Smaller ternary truth table to create
+  \param from Larger ternary truth table to copy from
+*/
+template<typename TT, typename TTFrom, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+void shrink_to_inplace( quaternary_truth_table<TT>& tt, const quaternary_truth_table<TTFrom>& from )
+{
+  shrink_to_inplace( tt._onset, from._onset );
+  shrink_to_inplace( tt._offset, from._offset );
+}
+
+/*! \brief Shrinks larger truth table to smaller static one
+
+  This is an out-of-place version of `shrink_to` that has the truth table as a
+  return value.  It only works for creating static truth tables.  The template
+  parameter `NumVars` must be equal or smaller to the number of variables in
+  `from`.
+
+  \param from Smaller truth table to copy from
+*/
+template<uint32_t NumVars, typename TTFrom>
+inline static_truth_table<NumVars> shrink_to( const TTFrom& from )
+{
+  static_truth_table<NumVars> tt;
+  shrink_to_inplace( tt, from );
+  return tt;
+}
+
+/*! \brief Shrinks larger truth table to smaller dynamic one
+
+  This is an out-of-place version of `shrink_to` that has the truth table as a
+  return value.  It only works for creating dynamic tables.  The parameter
+  `num_vars` must be equal or smaller to the number of variables in `from`.
+
+  \param from Smaller truth table to copy from
+*/
+template<typename TTFrom>
+inline dynamic_truth_table shrink_to( const TTFrom& from, unsigned num_vars )
+{
+  auto tt = create<dynamic_truth_table>( num_vars );
+  shrink_to_inplace( tt, from );
+  return tt;
+}
+
+/*! \brief Shrinks larger ternary truth table to smaller one of the same underlying type
+
+  This is an out-of-place version of `shrink_to` that has the truth table as a
+  return value.  It only works for creating dynamic tables.  The parameter
+  `num_vars` must be equal or smaller to the number of variables in `from`.
+
+  \param from Smaller truth table to copy from
+*/
+template<typename TTFrom>
+inline ternary_truth_table<TTFrom> shrink_to( const ternary_truth_table<TTFrom>& from, unsigned num_vars )
+{
+  auto tt = ternary_truth_table<TTFrom>( num_vars );
+  shrink_to_inplace( tt, from );
+  return tt;
+}
+
+/*! \brief Shrinks larger ternary truth table to smaller one of the same underlying type
+
+  This is an out-of-place version of `shrink_to` that has the truth table as a
+  return value.  It only works for creating dynamic tables.  The parameter
+  `num_vars` must be equal or smaller to the number of variables in `from`.
+
+  \param from Smaller truth table to copy from
+*/
+template<typename TTFrom>
+inline quaternary_truth_table<TTFrom> shrink_to( const quaternary_truth_table<TTFrom>& from, unsigned num_vars )
+{
+  auto tt = quaternary_truth_table<TTFrom>( num_vars );
+  shrink_to_inplace( tt, from );
+  return tt;
+}
+
+/*! \brief Left-shift truth table
+
+  Drops overflowing most-significant bits and fills up least-significant bits
+  with zeroes.
+
+  \param tt Truth table
+  \param shift Number of bits to shift
+*/
+template<typename TT>
+void shift_left_inplace( TT& tt, uint64_t shift )
+{
+  /* small truth table */
+  if ( tt.num_vars() <= 6 )
+  {
+    tt._bits[0] <<= shift;
+    tt.mask_bits();
+    return;
+  }
+
+  /* large shift */
+  if ( shift >= tt.num_bits() )
+  {
+    clear( tt );
+    return;
+  }
+
+  if ( shift > 0 )
+  {
+    const auto last = tt.num_blocks() - 1u;
+    const auto div = shift / 64u;
+    const auto rem = shift % 64u;
+
+    if ( rem != 0 )
+    {
+      const auto rshift = 64u - rem;
+      for ( auto i = last - div; i > 0; --i )
+      {
+        tt._bits[i + div] = ( tt._bits[i] << rem ) | ( tt._bits[i - 1] >> rshift );
+      }
+      tt._bits[div] = tt._bits[0] << rem;
+    }
+    else
+    {
+      for ( auto i = last - div; i > 0; --i )
+      {
+        tt._bits[i + div] = tt._bits[i];
+      }
+      tt._bits[div] = tt._bits[0];
+    }
+
+    std::fill_n( std::begin( tt._bits ), div, 0u );
+  }
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+inline void shift_left_inplace( static_truth_table<NumVars, true>& tt, uint64_t shift )
+{
+  tt._bits <<= shift;
+  tt.mask_bits();
+}
+/*! \endcond */
+
+/*! \cond PRIVATE */
+inline void shift_left_inplace( partial_truth_table& tt, uint64_t shift )
+{
+  if ( shift >= tt.num_bits() )
+  {
+    clear( tt );
+    return;
+  }
+
+  if ( shift > 0u )
+  {
+    const auto last = tt.num_blocks() - 1u;
+    const auto div = shift / 64u;
+    const auto rem = shift % 64u;
+
+    if ( rem != 0u )
+    {
+      const auto rshift = 64u - rem;
+      for ( auto i = last - div; i > 0; --i )
+      {
+        tt._bits[i + div] = ( tt._bits[i] << rem ) | ( tt._bits[i - 1] >> rshift );
+      }
+      tt._bits[div] = tt._bits[0] << rem;
+    }
+    else
+    {
+      for ( auto i = last - div; i > 0; --i )
+      {
+        tt._bits[i + div] = tt._bits[i];
+      }
+      tt._bits[div] = tt._bits[0];
+    }
+
+    std::fill_n( std::begin( tt._bits ), div, 0u );
+    tt.mask_bits();
+  }
+}
+/*! \endcond */
+
+/*! \brief Left-shift ternary truth table
+
+  Drops overflowing most-significant bits and fills up least-significant bits
+  with zeroes.
+
+  \param tt Truth table
+  \param shift Number of bits to shift
+*/
+template<typename TT>
+inline void shift_left_inplace( ternary_truth_table<TT>& tt, uint64_t shift )
+{
+  shift_left_inplace( tt._bits, shift );
+  shift_left_inplace( tt._care, shift );
+  for ( auto i = 0u; i < shift; i++ )
+  {
+    set_bit( tt._care, i );
+  }
+}
+
+/*! \brief Left-shift quaternary truth table
+
+  Drops overflowing most-significant bits and fills up least-significant bits
+  with zeroes.
+
+  \param tt Truth table
+  \param shift Number of bits to shift
+*/
+template<typename TT>
+inline void shift_left_inplace( quaternary_truth_table<TT>& tt, uint64_t shift )
+{
+  shift_left_inplace( tt._onset, shift );
+  shift_left_inplace( tt._offset, shift );
+  for ( auto i = 0u; i < shift; i++ )
+  {
+    set_bit( tt._offset, i );
+  }
+}
+
+/*! \brief Left-shift truth table
+
+  Out-of-place variant of `shift_left_inplace`.
+
+  \param tt Truth table
+  \param shift Number of bits to shift
+*/
+template<typename TT>
+inline TT shift_left( const TT& tt, uint64_t shift )
+{
+  auto copy = tt;
+  shift_left_inplace( copy, shift );
+  return copy;
+}
+
+/*! \brief Right-shift truth table
+
+  Drops overflowing least-significant bits and fills up most-significant bits
+  with zeroes.
+
+  \param tt Truth table
+  \param shift Number of bits to shift
+*/
+template<typename TT>
+void shift_right_inplace( TT& tt, uint64_t shift )
+{
+  /* small truth table */
+  if ( tt.num_vars() <= 6 )
+  {
+    tt._bits[0] >>= shift;
+    tt.mask_bits();
+    return;
+  }
+
+  /* large shift */
+  if ( shift >= tt.num_bits() )
+  {
+    clear( tt );
+    return;
+  }
+
+  if ( shift > 0 )
+  {
+    const auto last = tt.num_blocks() - 1u;
+    const auto div = shift / 64u;
+    const auto rem = shift % 64u;
+
+    if ( rem != 0 )
+    {
+      const auto rshift = 64u - rem;
+      for ( auto i = div; i < last; ++i )
+      {
+        tt._bits[i - div] = ( tt._bits[i] >> rem ) | ( tt._bits[i + 1] << rshift );
+      }
+      tt._bits[last - div] = tt._bits[last] >> rem;
+    }
+    else
+    {
+      for ( auto i = div; i <= last; ++i )
+      {
+        tt._bits[i - div] = tt._bits[i];
+      }
+    }
+
+    std::fill_n( std::begin( tt._bits ) + ( tt.num_blocks() - div ), div, 0u );
+  }
+}
+
+/*! \cond PRIVATE */
+template<uint32_t NumVars>
+inline void shift_right_inplace( static_truth_table<NumVars, true>& tt, uint64_t shift )
+{
+  tt._bits >>= shift;
+}
+/*! \endcond */
+
+/*! \cond PRIVATE */
+inline void shift_right_inplace( partial_truth_table& tt, uint64_t shift )
+{
+  if ( shift >= tt.num_bits() )
+  {
+    clear( tt );
+    return;
+  }
+
+  if ( shift > 0u )
+  {
+    tt.mask_bits();
+
+    const auto last = tt.num_blocks() - 1u;
+    const auto div = shift / 64u;
+    const auto rem = shift % 64u;
+
+    if ( rem != 0u )
+    {
+      const auto rshift = 64u - rem;
+      for ( auto i = div; i < last; ++i )
+      {
+        tt._bits[i - div] = ( tt._bits[i] >> rem ) | ( tt._bits[i + 1] << rshift );
+      }
+      tt._bits[last - div] = tt._bits[last] >> rem;
+    }
+    else
+    {
+      for ( auto i = div; i <= last; ++i )
+      {
+        tt._bits[i - div] = tt._bits[i];
+      }
+    }
+
+    std::fill_n( std::begin( tt._bits ) + ( tt.num_blocks() - div ), div, 0u );
+  }
+}
+/*! \endcond */
+
+/*! \brief Right-shift ternary truth table
+
+  Drops overflowing most-significant bits and fills up least-significant bits
+  with zeroes.
+
+  \param tt Truth table
+  \param shift Number of bits to shift
+*/
+template<typename TT>
+inline void shift_right_inplace( ternary_truth_table<TT>& tt, uint64_t shift )
+{
+  shift_right_inplace( tt._bits, shift );
+  shift_right_inplace( tt._care, shift );
+  for ( auto i = 0u; i < shift; i++ )
+  {
+    set_bit( tt._care, tt._care.num_bits() - 1 - i );
+  }
+}
+
+/*! \brief Right-shift quaternary truth table
+
+  Drops overflowing most-significant bits and fills up least-significant bits
+  with zeroes.
+
+  \param tt Truth table
+  \param shift Number of bits to shift
+*/
+template<typename TT>
+inline void shift_right_inplace( quaternary_truth_table<TT>& tt, uint64_t shift )
+{
+  shift_right_inplace( tt._onset, shift );
+  shift_right_inplace( tt._offset, shift );
+  for ( auto i = 0u; i < shift; i++ )
+  {
+    set_bit( tt._offset, tt._offset.num_bits() - 1 - i );
+  }
+}
+
+/*! \brief Right-shift truth table
+
+  Out-of-place variant of `shift_right_inplace`.
+
+  \param tt Truth table
+  \param shift Number of bits to shift
+*/
+template<typename TT>
+inline TT shift_right( const TT& tt, uint64_t shift )
+{
+  auto copy = tt;
+  shift_right_inplace( copy, shift );
+  return copy;
+}
+
+/*! \brief Composes a truth table.
+
+  Given a function `f`, and a set of truth tables as arguments, computes the
+  composed truth table.  For example, if `f(x1, x2) = 1001` and
+  `vars = {x1 = 1001, x2= 1010}`, the function returns 1100. This function can
+  be regarded as a general operator with arity `vars.size()` where the behavior
+  of the operator is given by f.
+
+  \param f The outer function
+  \param vars The ordered set of input variables
+  \return The composed truth table with vars.size() variables
+*/
+template<class TTf, class TTv, typename = std::enable_if_t<is_complete_truth_table<TTf>::value>>
+inline auto compose_truth_table( const TTf& f, const std::vector<TTv>& vars )
+{
+  assert( vars.size() == static_cast<std::size_t>( f.num_vars() ) );
+  auto composed = vars[0].construct();
+
+  for ( uint64_t i = 0u; i < composed.num_bits(); ++i )
+  {
+    uint64_t index = 0u;
+    for ( uint64_t j = 0u; j < vars.size(); ++j )
+    {
+      index += get_bit( vars[j], i ) << j;
+    }
+    if ( get_bit( f, index ) )
+    {
+      set_bit( composed, i );
+    }
+    else
+    {
+      clear_bit( composed, i );
+    }
+  }
+
+  return composed;
+}
+
+/*! \brief Composes a truth table.
+
+  Given a function `f`, and a set of truth tables as arguments, computes the
+  composed truth table.  For example, if `f(x1, x2) = 1001` and
+  `vars = {x1 = 1001, x2= 1010}`, the function returns 1000.
+  In case of don't cares this method treats them as "don't knows".
+  For example, if `f(x1, x2) = 1-00` and
+  `vars = {x1 = 1001, x2= 1010}`, the function returns 100-.
+  For example, if `f(x1, x2) = 1-00` and
+  `vars = {x1 = 1001, x2= -010}`, the function returns -00-.
+  However, if `f(x1, x2) = 1100` and
+  `vars = {x1 = 1001, x2= -010}`, the function returns 1001.
+
+  This function does not support truth quaternary table with more than 6 variables.
+
+  \param f The outer function
+  \param vars The ordered set of input variables
+  \return The composed truth table with vars.size() variables
+*/
+template<class TTf, class TTv, typename = std::enable_if_t<is_complete_truth_table<TTf>::value>>
+inline auto compose_truth_table( const ternary_truth_table<TTf>& f, const std::vector<ternary_truth_table<TTv>>& vars )
+{
+  assert( vars.size() == static_cast<std::size_t>( f.num_vars() ) );
+  auto a = create<TTv>( vars[0].num_vars() );
+  auto b = create<TTv>( vars[0].num_vars() );
+  auto composed = ternary_truth_table<TTv>( a, b );
+
+  for ( uint64_t i = 0u; i < composed.num_bits(); ++i )
+  {
+    auto f_copy = f;
+    uint64_t cnt_care = 0u;
+    for ( uint64_t j = 0u; j < vars.size(); ++j )
+    {
+      auto tt_mask = f._bits.construct();
+      auto const projection = [&j, &f]( auto a )
+      {
+        return ( a | detail::projections[f.num_vars() - 1 - j] );
+      };
+      auto const projection_neg = [&j, &f]( auto a )
+      {
+        return ( a | detail::projections_neg[f.num_vars() - j - 1] );
+      };
+      if ( !is_dont_care( vars[j], i ) )
+      {
+        auto bit = get_bit( vars[j], i );
+        if ( bit )
+        {
+          auto ttt_mask = ternary_truth_table<TTf>( unary_operation( tt_mask, projection ) );
+          f_copy &= ttt_mask;
+        }
+        else
+        {
+          auto ttt_mask = ternary_truth_table<TTf>( unary_operation( tt_mask, projection_neg ) );
+          f_copy &= ttt_mask;
+        }
+      }
+      else
+      {
+        ++cnt_care;
+      }
+    }
+    if ( is_const0( f_copy ) )
+    {
+      set_bit( composed, i, false );
+    }
+    else
+    {
+      if ( count_ones( f_copy._bits ) == ( 1 << cnt_care ) ) // count_ones( f_copy._onset & ~f_copy._offset ) count real ones in f_copy
+      {
+        set_bit( composed, i );
+      }
+      else
+      {
+        set_dont_care( composed, i );
+      }
+    }
+  }
+
+  return composed;
+}
+
+/*! \brief Composes a truth table.
+
+  Given a function `f`, and a set of truth tables as arguments, computes the
+  composed truth table.  For example, if `f(x1, x2) = 1001` and
+  `vars = {x1 = 1001, x2= 1010}`, the function returns 1000.
+  For example, if `f(x1, x2) = 1-00` and
+  `vars = {x1 = 1001, x2= 1010}`, the function returns 100-.
+  For example, if `f(x1, x2) = 1-00` and
+  `vars = {x1 = 1001, x2= -010}`, the function returns 100-.
+  If `f(x1, x2) = 1100` and
+  `vars = {x1 = 1x01, x2= -01x}`, the function returns 1x01.
+
+  This function does not support truth quaternary table with more than 6 variables.
+
+  \param f The outer function
+  \param vars The ordered set of input variables
+  \return The composed truth table with vars.size() variables
+*/
+template<class TTf, class TTv, typename = std::enable_if_t<is_complete_truth_table<TTf>::value>>
+inline auto compose_truth_table( const quaternary_truth_table<TTf>& f, const std::vector<quaternary_truth_table<TTv>>& vars )
+{
+  assert( vars.size() == static_cast<std::size_t>( f.num_vars() ) );
+  auto a = create<TTv>( vars[0].num_vars() );
+  auto b = create<TTv>( vars[0].num_vars() );
+  auto composed = quaternary_truth_table<TTv>( a, b );
+
+  for ( uint64_t i = 0u; i < composed.num_bits(); ++i )
+  {
+    auto f_copy = f;
+    uint64_t cnt_care = 0u;
+    bool dont_know_found = false;
+    for ( uint64_t j = 0u; j < vars.size(); ++j )
+    {
+      auto tt_mask = f._onset.construct();
+      auto const projection = [&j, &f]( auto a )
+      {
+        return ( a | detail::projections[f.num_vars() - 1 - j] );
+      };
+      auto const projection_neg = [&j, &f]( auto a )
+      {
+        return ( a | detail::projections_neg[f.num_vars() - j - 1] );
+      };
+      if ( !is_dont_care( vars[j], i ) && !is_dont_know( vars[j], i ) )
+      {
+        auto bit = get_bit( vars[j], i );
+        if ( bit )
+        {
+          auto ttt_mask = quaternary_truth_table<TTf>( unary_operation( tt_mask, projection ) );
+          f_copy &= ttt_mask;
+        }
+        else
+        {
+          auto ttt_mask = quaternary_truth_table<TTf>( unary_operation( tt_mask, projection_neg ) );
+          f_copy &= ttt_mask;
+        }
+      }
+      else
+      {
+        ++cnt_care;
+        if ( is_dont_know( vars[j], i ) )
+          dont_know_found = true;
+      }
+    }
+    if ( is_const0( f_copy ) )
+    {
+      if ( count_ones( f_copy._onset ) == ( 1 << cnt_care ) )
+        set_dont_care( composed, i );
+      else
+        set_bit( composed, i, false );
+    }
+    else
+    {
+      if ( count_ones( f_copy._onset ) == ( 1 << cnt_care ) )
+      {
+        set_bit( composed, i );
+      }
+      else
+      {
+        if ( ( !dont_know_found && is_const0( ~f_copy._onset & ~f_copy._offset ) ) )
+          set_dont_care( composed, i );
+        else
+          set_dont_know( composed, i );
+      }
+    }
+  }
+
+  return composed;
+}
+
+/*! \brief Shifts a small truth table with respect to a mask
+
+  This function only works for truth tables with up to 6 inputs.  The function
+  rearranges the variables according to a mask.  For example, assume the 3-input
+  truth table \f$ x_0 \land x_1 \f$, which is not defined on \f$ x_2 \f$.
+  Applying this funtion with a mask `0b101` yields the function
+  \f$ x_0 \land x_2 \f$, and the mask `0b110` yields the function
+  \f$ x_1 \land x_2 \f$.  The bits in the mask provide the new positions.  It
+  is important that the positions in the mask do not exceed the truth table
+  size, since all operations are performed in-place and cannot change the
+  number of variables of the truth table.
+
+  \param tt Truth table
+  \param mask Shift mask
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+inline void shift_with_mask_inplace( TT& f, uint8_t mask )
+{
+  assert( f.num_vars() <= 6 );
+
+  *f.begin() = detail::compute_shift( *f.begin(), mask | ( 1 << f.num_vars() ) );
+}
+
+/*! \brief Shifts a small truth table with respect to a mask
+
+  This function only works for truth tables with up to 6 inputs.  The function
+  rearranges the variables according to a mask.  For example, assume the 3-input
+  truth table \f$ x_0 \land x_1 \f$, which is not defined on \f$ x_2 \f$.
+  Applying this funtion with a mask `0b101` yields the function
+  \f$ x_0 \land x_2 \f$, and the mask `0b110` yields the function
+  \f$ x_1 \land x_2 \f$.  The bits in the mask provide the new positions.  It
+  is important that the positions in the mask do not exceed the truth table
+  size, since all operations are performed in-place and cannot change the
+  number of variables of the truth table.
+  The final result will not contain don't cares, they are all turned into 0s.
+
+  \param tt Truth table
+  \param mask Shift mask
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+inline void shift_with_mask_inplace( ternary_truth_table<TT>& f, uint8_t mask )
+{
+  assert( f.num_vars() <= 6 );
+
+  shift_with_mask_inplace( f._bits, mask );
+  f._care = ~f._care.construct();
+}
+
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+inline void shift_with_mask_inplace( quaternary_truth_table<TT>& f, uint8_t mask )
+{
+  std::vector<uint8_t> mask_from = {};
+  std::vector<uint8_t> mask_to = {};
+  for ( auto i = 0u; i < f.num_vars(); i++ )
+  {
+    if ( has_var( f, i ) )
+      mask_from.push_back( i );
+  }
+  for ( uint64_t count = 0u; mask > 0; mask = (int)mask / 2, count++ )
+  {
+    if ( mask % 2 )
+      mask_to.push_back( count );
+  }
+  assert( mask_to.size() == mask_from.size() );
+  std::vector<uint8_t> index_remove = {};
+  for ( auto i = 0; i < mask_from.size(); i++ )
+  {
+    int index = std::find( begin( mask_to ), end( mask_to ), mask_from[i] ) - mask_to.begin();
+    if ( index < mask_to.size() )
+    {
+      mask_to.erase( mask_to.begin() + index );
+      mask_from.erase( mask_from.begin() + i );
+    }
+  }
+  for ( auto i = 0; i < mask_from.size(); i++ )
+  {
+    swap_inplace( f, mask_from[i], mask_to[i] );
+  }
+}
+
+/*! \brief Shifts a small truth table with respect to a mask
+
+  Out-of-place variant of `shift_with_mask_inplace`.
+
+  \param tt Truth table
+  \param mask Shift mask
+*/
+template<class TT>
+inline TT shift_with_mask( const TT& f, uint8_t mask )
+{
+  auto copy = f;
+  shift_with_mask_inplace( copy, mask );
+  return copy;
+}
+
+} // namespace kitty
diff --git a/lib/kitty/kitty/operators.hpp b/lib/kitty/kitty/operators.hpp
new file mode 100644
index 0000000..7b23f8d
--- /dev/null
+++ b/lib/kitty/kitty/operators.hpp
@@ -0,0 +1,507 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file operators.hpp
+  \brief Implements operator shortcuts to operations
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include "dynamic_truth_table.hpp"
+#include "operations.hpp"
+#include "static_truth_table.hpp"
+#include "partial_truth_table.hpp"
+#include "ternary_truth_table.hpp"
+#include "quaternary_truth_table.hpp"
+
+namespace kitty
+{
+
+/*! \brief Operator for unary_not */
+inline dynamic_truth_table operator~( const dynamic_truth_table& tt )
+{
+  return unary_not( tt );
+}
+
+/*! \brief Operator for unary_not */
+template<uint32_t NumVars>
+inline static_truth_table<NumVars> operator~( const static_truth_table<NumVars>& tt )
+{
+  return unary_not( tt );
+}
+
+/*! \brief Operator for unary_not */
+inline partial_truth_table operator~( const partial_truth_table& tt )
+{
+  return unary_not( tt );
+}
+
+/*! \brief Operator for unary_not */
+template<typename TT>
+inline ternary_truth_table<TT> operator~( const ternary_truth_table<TT>& tt )
+{
+  return unary_not( tt );
+}
+
+/*! \brief Operator for unary_not */
+template<typename TT>
+inline quaternary_truth_table<TT> operator~( const quaternary_truth_table<TT>& tt )
+{
+  return unary_not( tt );
+}
+
+/*! \brief Operator for binary_and */
+inline dynamic_truth_table operator&( const dynamic_truth_table& first, const dynamic_truth_table& second )
+{
+  return binary_and( first, second );
+}
+
+/*! \brief Operator for binary_and */
+template<uint32_t NumVars>
+inline static_truth_table<NumVars> operator&( const static_truth_table<NumVars>& first, const static_truth_table<NumVars>& second )
+{
+  return binary_and( first, second );
+}
+
+/*! \brief Operator for binary_and */
+inline partial_truth_table operator&( const partial_truth_table& first, const partial_truth_table& second )
+{
+  return binary_and( first, second );
+}
+
+/*! \brief Operator for binary_and */
+template<typename TT>
+inline ternary_truth_table<TT> operator&( const ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second )
+{
+  return binary_and( first, second );
+}
+
+/*! \brief Operator for binary_and */
+template<typename TT>
+inline quaternary_truth_table<TT> operator&( const quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second )
+{
+  return binary_and( first, second );
+}
+
+/*! \brief Operator for binary_and and assign */
+inline void operator&=( dynamic_truth_table& first, const dynamic_truth_table& second )
+{
+  first = binary_and( first, second );
+}
+
+/*! \brief Operator for binary_and and assign */
+template<uint32_t NumVars>
+inline void operator&=( static_truth_table<NumVars>& first, const static_truth_table<NumVars>& second )
+{
+  first = binary_and( first, second );
+}
+
+/*! \brief Operator for binary_and and assign */
+inline void operator&=( partial_truth_table& first, const partial_truth_table& second )
+{
+  first = binary_and( first, second );
+}
+
+/*! \brief Operator for binary_and and assign */
+template<typename TT>
+inline void operator&=( ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second )
+{
+  first = binary_and( first, second );
+}
+
+/*! \brief Operator for binary_and and assign */
+template<typename TT>
+inline void operator&=( quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second )
+{
+  first = binary_and( first, second );
+}
+
+/*! \brief Operator for binary_or */
+inline dynamic_truth_table operator|( const dynamic_truth_table& first, const dynamic_truth_table& second )
+{
+  return binary_or( first, second );
+}
+
+/*! \brief Operator for binary_or */
+template<uint32_t NumVars>
+inline static_truth_table<NumVars> operator|( const static_truth_table<NumVars>& first, const static_truth_table<NumVars>& second )
+{
+  return binary_or( first, second );
+}
+
+/*! \brief Operator for binary_or */
+inline partial_truth_table operator|( const partial_truth_table& first, const partial_truth_table& second )
+{
+  return binary_or( first, second );
+}
+
+/*! \brief Operator for binary_or */
+template<typename TT>
+inline ternary_truth_table<TT> operator|( const ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second )
+{
+  return binary_or( first, second );
+}
+
+/*! \brief Operator for binary_or */
+template<typename TT>
+inline quaternary_truth_table<TT> operator|( const quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second )
+{
+  return binary_or( first, second );
+}
+
+/*! \brief Operator for binary_or and assign */
+inline void operator|=( dynamic_truth_table& first, const dynamic_truth_table& second )
+{
+  first = binary_or( first, second );
+}
+
+/*! \brief Operator for binary_or and assign */
+template<uint32_t NumVars>
+inline void operator|=( static_truth_table<NumVars>& first, const static_truth_table<NumVars>& second )
+{
+  first = binary_or( first, second );
+}
+
+/*! \brief Operator for binary_or and assign */
+inline void operator|=( partial_truth_table& first, const partial_truth_table& second )
+{
+  first = binary_or( first, second );
+}
+
+/*! \brief Operator for binary_or and assign */
+template<typename TT>
+inline void operator|=( ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second )
+{
+  first = binary_or( first, second );
+}
+
+/*! \brief Operator for binary_or and assign */
+template<typename TT>
+inline void operator|=( quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second )
+{
+  first = binary_or( first, second );
+}
+
+/*! \brief Operator for binary_xor */
+inline dynamic_truth_table operator^( const dynamic_truth_table& first, const dynamic_truth_table& second )
+{
+  return binary_xor( first, second );
+}
+
+/*! \brief Operator for binary_xor */
+template<uint32_t NumVars>
+inline static_truth_table<NumVars> operator^( const static_truth_table<NumVars>& first, const static_truth_table<NumVars>& second )
+{
+  return binary_xor( first, second );
+}
+
+/*! \brief Operator for binary_xor */
+inline partial_truth_table operator^( const partial_truth_table& first, const partial_truth_table& second )
+{
+  return binary_xor( first, second );
+}
+
+/*! \brief Operator for binary_xor */
+template<typename TT>
+inline ternary_truth_table<TT> operator^( const ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second )
+{
+  return binary_xor( first, second );
+}
+
+/*! \brief Operator for binary_xor */
+template<typename TT>
+inline quaternary_truth_table<TT> operator^( const quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second )
+{
+  return binary_xor( first, second );
+}
+
+/*! \brief Operator for binary_xor and assign */
+inline void operator^=( dynamic_truth_table& first, const dynamic_truth_table& second )
+{
+  first = binary_xor( first, second );
+}
+
+/*! \brief Operator for binary_xor and assign */
+template<uint32_t NumVars>
+inline void operator^=( static_truth_table<NumVars>& first, const static_truth_table<NumVars>& second )
+{
+  first = binary_xor( first, second );
+}
+
+/*! \brief Operator for binary_xor and assign */
+inline void operator^=( partial_truth_table& first, const partial_truth_table& second )
+{
+  first = binary_xor( first, second );
+}
+
+/*! \brief Operator for binary_xor and assign */
+template<typename TT>
+inline void operator^=( ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second )
+{
+  first = binary_xor( first, second );
+}
+
+/*! \brief Operator for binary_xor and assign */
+template<typename TT>
+inline void operator^=( quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second )
+{
+  first = binary_xor( first, second );
+}
+
+/*! \brief Operator for equal */
+inline bool operator==( const dynamic_truth_table& first, const dynamic_truth_table& second )
+{
+  return equal( first, second );
+}
+
+/*! \brief Operator for equal */
+template<uint32_t NumVars>
+inline bool operator==( const static_truth_table<NumVars>& first, const static_truth_table<NumVars>& second )
+{
+  return equal( first, second );
+}
+
+/*! \brief Operator for equal */
+inline bool operator==( const partial_truth_table& first, const partial_truth_table& second )
+{
+  return equal( first, second );
+}
+
+/*! \brief Operator for equal */
+template<typename TT>
+inline bool operator==( const ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second )
+{
+  return equal( first, second );
+}
+
+/*! \brief Operator for equal */
+template<typename TT>
+inline bool operator==( const quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second )
+{
+  return equal( first, second );
+}
+
+/*! \brief Operator for not equals (!equal) */
+inline bool operator!=( const dynamic_truth_table& first, const dynamic_truth_table& second )
+{
+  return !equal( first, second );
+}
+
+/*! \brief Operator for not equals (!equal) */
+template<uint32_t NumVars>
+inline bool operator!=( const static_truth_table<NumVars>& first, const static_truth_table<NumVars>& second )
+{
+  return !equal( first, second );
+}
+
+/*! \brief Operator for not equal */
+inline bool operator!=( const partial_truth_table& first, const partial_truth_table& second )
+{
+  return !equal( first, second );
+}
+
+/*! \brief Operator for not equals (!equal) */
+template<typename TT>
+inline bool operator!=( const ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second )
+{
+  return !equal( first, second );
+}
+
+/*! \brief Operator for not equals (!equal) */
+template<typename TT>
+inline bool operator!=( const quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second )
+{
+  return !equal( first, second );
+}
+
+/*! \brief Operator for less_than */
+inline bool operator<( const dynamic_truth_table& first, const dynamic_truth_table& second )
+{
+  return less_than( first, second );
+}
+
+/*! \brief Operator for less_than */
+template<uint32_t NumVars>
+inline bool operator<( const static_truth_table<NumVars>& first, const static_truth_table<NumVars>& second )
+{
+  return less_than( first, second );
+}
+
+/*! \brief Operator for less_than */
+inline bool operator<( const partial_truth_table& first, const partial_truth_table& second )
+{
+  return less_than( first, second );
+}
+
+/*! \brief Operator for less_than */
+template<typename TT>
+inline bool operator<( const ternary_truth_table<TT>& first, const ternary_truth_table<TT>& second )
+{
+  return less_than( first, second );
+}
+
+/*! \brief Operator for less_than */
+template<typename TT>
+inline bool operator<( const quaternary_truth_table<TT>& first, const quaternary_truth_table<TT>& second )
+{
+  return less_than( first, second );
+}
+
+/*! \brief Operator for left_shift */
+inline dynamic_truth_table operator<<( const dynamic_truth_table& tt, uint64_t shift )
+{
+  return shift_left( tt, shift );
+}
+
+/*! \brief Operator for left_shift */
+template<uint32_t NumVars>
+inline static_truth_table<NumVars> operator<<( const static_truth_table<NumVars>& tt, uint64_t shift )
+{
+  return shift_left( tt, shift );
+}
+
+/*! \brief Operator for left_shift */
+inline partial_truth_table operator<<( const partial_truth_table& tt, uint64_t shift )
+{
+  return shift_left( tt, shift );
+}
+
+/*! \brief Operator for left_shift */
+template<typename TT>
+inline ternary_truth_table<TT> operator<<( const ternary_truth_table<TT>& tt, uint64_t shift )
+{
+  return shift_left( tt, shift );
+}
+
+/*! \brief Operator for left_shift */
+template<typename TT>
+inline quaternary_truth_table<TT> operator<<( const quaternary_truth_table<TT>& tt, uint64_t shift )
+{
+  return shift_left( tt, shift );
+}
+
+/*! \brief Operator for left_shift_inplace */
+inline void operator<<=( dynamic_truth_table& tt, uint64_t shift )
+{
+  shift_left_inplace( tt, shift );
+}
+
+/*! \brief Operator for left_shift_inplace */
+template<uint32_t NumVars>
+inline void operator<<=( static_truth_table<NumVars>& tt, uint64_t shift )
+{
+  shift_left_inplace( tt, shift );
+}
+
+/*! \brief Operator for left_shift_inplace */
+inline void operator<<=( partial_truth_table& tt, uint64_t shift )
+{
+  shift_left_inplace( tt, shift );
+}
+
+/*! \brief Operator for left_shift_inplace */
+template<typename TT>
+inline void operator<<=( ternary_truth_table<TT>& tt, uint64_t shift )
+{
+  shift_left_inplace( tt, shift );
+}
+
+/*! \brief Operator for left_shift_inplace */
+template<typename TT>
+inline void operator<<=( quaternary_truth_table<TT>& tt, uint64_t shift )
+{
+  shift_left_inplace( tt, shift );
+}
+
+/*! \brief Operator for right_shift */
+inline dynamic_truth_table operator>>( const dynamic_truth_table& tt, uint64_t shift )
+{
+  return shift_right( tt, shift );
+}
+
+/*! \brief Operator for right_shift */
+template<uint32_t NumVars>
+inline static_truth_table<NumVars> operator>>( const static_truth_table<NumVars>& tt, uint64_t shift )
+{
+  return shift_right( tt, shift );
+}
+
+/*! \brief Operator for right_shift */
+inline partial_truth_table operator>>( const partial_truth_table& tt, uint64_t shift )
+{
+  return shift_right( tt, shift );
+}
+
+/*! \brief Operator for right_shift */
+template<typename TT>
+inline ternary_truth_table<TT> operator>>( const ternary_truth_table<TT>& tt, uint64_t shift )
+{
+  return shift_right( tt, shift );
+}
+
+/*! \brief Operator for right_shift */
+template<typename TT>
+inline quaternary_truth_table<TT> operator>>( const quaternary_truth_table<TT>& tt, uint64_t shift )
+{
+  return shift_right( tt, shift );
+}
+
+/*! \brief Operator for right_shift_inplace */
+inline void operator>>=( dynamic_truth_table& tt, uint64_t shift )
+{
+  shift_right_inplace( tt, shift );
+}
+
+/*! \brief Operator for right_shift_inplace */
+template<uint32_t NumVars>
+inline void operator>>=( static_truth_table<NumVars>& tt, uint64_t shift )
+{
+  shift_right_inplace( tt, shift );
+}
+
+/*! \brief Operator for right_shift_inplace */
+inline void operator>>=( partial_truth_table& tt, uint64_t shift )
+{
+  shift_right_inplace( tt, shift );
+}
+
+/*! \brief Operator for right_shift_inplace */
+template<typename TT>
+inline void operator>>=( ternary_truth_table<TT>& tt, uint64_t shift )
+{
+  shift_right_inplace( tt, shift );
+}
+
+/*! \brief Operator for right_shift_inplace */
+template<typename TT>
+inline void operator>>=( quaternary_truth_table<TT>& tt, uint64_t shift )
+{
+  shift_right_inplace( tt, shift );
+}
+
+} // namespace kitty
diff --git a/lib/kitty/kitty/partial_truth_table.hpp b/lib/kitty/kitty/partial_truth_table.hpp
new file mode 100644
index 0000000..fa0bca8
--- /dev/null
+++ b/lib/kitty/kitty/partial_truth_table.hpp
@@ -0,0 +1,300 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file partial_truth_table.hpp
+  \brief Implements partial_truth_table
+
+  \author Siang-Yun Lee
+*/
+
+#pragma once
+
+#include "detail/constants.hpp"
+#include "traits.hpp"
+
+#include <cstdint>
+#include <type_traits>
+#include <vector>
+#include <iostream>
+#include <iomanip>
+#include <cassert>
+
+namespace kitty
+{
+
+/*! Truth table with resizable, arbitrary number of bits
+ */
+struct partial_truth_table
+{
+  /*! \brief Standard constructor.
+    \param num_bits Number of bits in use initially
+  */
+  explicit partial_truth_table( uint32_t num_bits )
+      : _bits( num_bits ? ( ( ( num_bits - 1 ) >> 6 ) + 1 ) : 0 ),
+        _num_bits( num_bits )
+  {
+  }
+
+  /*! \brief Empty constructor.
+
+    Creates an empty truth table. It has no bit in use. This constructor is
+    only used for convenience, if algorithms require the existence of default
+    constructable classes.
+   */
+  partial_truth_table() : _num_bits( 0 ) {}
+
+  /*! \brief Constructs a new partial truth table instance with the same number of bits and blocks. */
+  inline partial_truth_table construct() const
+  {
+    return partial_truth_table( _num_bits );
+  }
+
+  /*! \brief Returns number of (allocated) blocks.
+   */
+  inline auto num_blocks() const noexcept { return _bits.size(); }
+
+  /*! \brief Returns number of (used) bits.
+   */
+  inline auto num_bits() const noexcept { return _num_bits; }
+
+  /*! \brief Begin iterator to bits.
+   */
+  inline auto begin() noexcept { return _bits.begin(); }
+
+  /*! \brief End iterator to bits.
+   */
+  inline auto end() noexcept { return _bits.end(); }
+
+  /*! \brief Begin iterator to bits.
+   */
+  inline auto begin() const noexcept { return _bits.begin(); }
+
+  /*! \brief End iterator to bits.
+   */
+  inline auto end() const noexcept { return _bits.end(); }
+
+  /*! \brief Reverse begin iterator to bits.
+   */
+  inline auto rbegin() noexcept { return _bits.rbegin(); }
+
+  /*! \brief Reverse end iterator to bits.
+   */
+  inline auto rend() noexcept { return _bits.rend(); }
+
+  /*! \brief Constant begin iterator to bits.
+   */
+  inline auto cbegin() const noexcept { return _bits.cbegin(); }
+
+  /*! \brief Constant end iterator to bits.
+   */
+  inline auto cend() const noexcept { return _bits.cend(); }
+
+  /*! \brief Constant reverse begin iterator to bits.
+   */
+  inline auto crbegin() const noexcept { return _bits.crbegin(); }
+
+  /*! \brief Constant teverse end iterator to bits.
+   */
+  inline auto crend() const noexcept { return _bits.crend(); }
+
+  /*! \brief Assign other truth table.
+
+    This replaces the current truth table with another truth table.  The truth
+    table type is arbitrary.  The vector of bits is resized accordingly.
+
+    \param other Other truth table
+  */
+  template<class TT, typename = std::enable_if_t<is_truth_table<TT>::value>>
+  partial_truth_table& operator=( const TT& other )
+  {
+    _bits.resize( other.num_blocks() );
+    std::copy( other.begin(), other.end(), begin() );
+    _num_bits = 1 << other.num_vars();
+
+    return *this;
+  }
+
+  /*! \brief Masks the number of valid truth table bits.
+
+    If not all the bits in the last block are used up,
+    we block out the remaining bits (fill with zero).
+    Bits are used from LSB.
+  */
+  inline void mask_bits() noexcept
+  {
+    if ( _num_bits & 0x3f )
+    {
+      _bits.back() &= 0xFFFFFFFFFFFFFFFF >> ( 64 - ( _num_bits & 0x3f ) );
+    }
+  }
+
+  /*! \brief Resize the truth table to have the given number of bits.
+
+    If the desired length is larger than the current length, zeros will
+    be filled up in the end of the truth table. If the desired length
+    is shorter than the current length, extra bits in the end of the
+    truth table will be discarded.
+
+    \param num_bits Desired length (number of bits)
+  */
+  inline void resize( int num_bits ) noexcept
+  {
+    _num_bits = num_bits;
+
+    unsigned needed_blocks = num_bits ? ( ( ( num_bits - 1 ) >> 6 ) + 1 ) : 0;
+    _bits.resize( needed_blocks, 0u );
+
+    mask_bits();
+  }
+
+  /*! \brief Add a bit to the end of the truth table.
+    \param bit Bit to be added
+  */
+  inline void add_bit( bool bit ) noexcept
+  {
+    resize( _num_bits + 1 );
+    if ( bit )
+    {
+      _bits.back() |= (uint64_t)1 << ( ( _num_bits & 0x3f ) - 1 );
+    }
+  }
+
+  /*! \brief Add several bits to the end of the truth table.
+    \param bits Bits to be added
+  */
+  inline void add_bits( std::vector<bool>& bits ) noexcept
+  {
+    for ( unsigned i = 0; i < bits.size(); ++i )
+    {
+      add_bit( bits.at( i ) );
+    }
+  }
+
+  /*! \brief Add several bits to the end of the truth table.
+    \param bits Bits to be added
+    \param num_bits Number of bits in `bits` to be added (counted from LSB)
+  */
+  inline void add_bits( uint64_t bits, int num_bits = 64 ) noexcept
+  {
+    assert( num_bits <= 64 );
+
+    if ( ( _num_bits & 0x3f ) + num_bits <= 64 ) /* no need for a new block */
+    {
+      if ( _bits.size() == 0u )
+      {
+        _bits.emplace_back( 0u );
+      }
+      _bits.back() |= bits << ( _num_bits & 0x3f );
+    }
+    else
+    {
+      auto first_half_len = 64 - ( _num_bits & 0x3f );
+      _bits.back() |= bits << ( _num_bits & 0x3f );
+      _bits.emplace_back( 0u );
+      _bits.back() |= ( bits & ( 0xFFFFFFFFFFFFFFFF >> ( 64 - num_bits ) ) ) >> first_half_len;
+    }
+    _num_bits += num_bits;
+  }
+
+  /*! \brief Overwrite the value at position `from` to position `to`.
+    \param from Position of the bit to be copied
+    \param to Position of the bit to be overwritten
+  */
+  inline void copy_bit( uint32_t from, uint32_t to )
+  {
+    if ( ( _bits[from >> 6] >> ( from & 0x3f ) ) & 0x1 )
+    {
+      /* set_bit( to ) */
+      _bits[to >> 6] |= uint64_t( 1 ) << ( to & 0x3f );
+    }
+    else
+    {
+      /* clear_bit( to ) */
+      _bits[to >> 6] &= ~( uint64_t( 1 ) << ( to & 0x3f ) );
+    }
+  }
+
+  /*! \brief Erase the bit at the given position by swapping with the
+             last bit and shrinking the truth table.
+
+    This method is faster than `erase_bit` but do not keep the order
+    of the bits.
+
+    \param position Position of the bit to be erased
+  */
+  inline void erase_bit_swap( uint32_t position )
+  {
+    assert( position < _num_bits );
+    /* move the last bit (`_num_bits - 1`) to `position` */
+    copy_bit( _num_bits - 1, position );
+    resize( _num_bits - 1 );
+  }
+
+  /*! \brief Erase the bit at the given position and shift all the following bits.
+
+    This method keeps the order of the bits but is slower and
+    do not keep the position of the bits.
+
+    \param position Position of the bit to be erased
+  */
+  inline void erase_bit_shift( uint32_t position )
+  {
+    assert( position < _num_bits );
+    uint64_t mask = 0xFFFFFFFFFFFFFFFF << ( position & 0x3f );
+    _bits[position >> 6] = ( _bits[position >> 6] & ~mask ) | ( _bits[position >> 6] >> 1 & mask );
+    uint32_t hole = position | 0x3f;
+    while ( hole < _num_bits - 1 )
+    {
+      copy_bit( hole + 1, hole );
+      hole += 64;
+      _bits[hole >> 6] >>= 1;
+    }
+    resize( _num_bits - 1 );
+  }
+
+  /*! \cond PRIVATE */
+public: /* fields */
+  std::vector<uint64_t> _bits;
+  uint32_t _num_bits;
+  /*! \endcond */
+};
+
+template<>
+struct is_truth_table<kitty::partial_truth_table> : std::true_type
+{
+};
+
+template<>
+struct is_complete_truth_table<kitty::partial_truth_table> : std::false_type
+{
+};
+
+template<>
+struct is_completely_specified_truth_table<kitty::partial_truth_table> : std::true_type
+{
+};
+
+} // namespace kitty
\ No newline at end of file
diff --git a/lib/kitty/kitty/permutation.hpp b/lib/kitty/kitty/permutation.hpp
new file mode 100644
index 0000000..cedc44d
--- /dev/null
+++ b/lib/kitty/kitty/permutation.hpp
@@ -0,0 +1,286 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file permutation.hpp
+  \brief Efficient permutation of truth tables
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <numeric>
+#include <vector>
+
+#include "bit_operations.hpp"
+#include "operators.hpp"
+#include "print.hpp"
+
+namespace kitty
+{
+
+namespace detail
+{
+template<typename TT>
+std::pair<TT, TT> compute_permutation_masks_pair( const TT& tt, std::vector<uint32_t>& left, std::vector<uint32_t>& right, unsigned step )
+{
+  const auto n = tt.num_vars();
+  const auto loops = ( 1 << ( n - 1 - step ) );
+  const auto diff = ( 1 << step );
+
+  const auto offset = 1 << ( n - 1 );
+
+  struct node_t
+  {
+    std::vector<uint32_t>::iterator a, b; /* numbers in left or right */
+    unsigned lf{}, rf{};                  /* left field right field */
+    bool visited = false;
+  };
+
+  std::vector<node_t> nodes( tt.num_bits() );
+
+  /* compute graph */
+  auto idx1 = 0u, idx2 = 0u;
+  auto it1 = std::begin( left );
+  for ( auto l1 = 0; l1 < loops; ++l1 )
+  {
+    for ( auto c1 = 0; c1 < diff; ++c1 )
+    {
+      auto it2 = std::begin( right );
+      idx2 = offset;
+
+      nodes[idx1].a = it1;
+      nodes[idx1].b = it1 + diff;
+
+      for ( auto l2 = 0; l2 < loops; ++l2 )
+      {
+        for ( auto c2 = 0; c2 < diff; ++c2 )
+        {
+          if ( idx1 == 0u )
+          {
+            nodes[idx2].a = it2;
+            nodes[idx2].b = it2 + diff;
+          }
+
+          /* pair elements */
+          auto& n1 = nodes[idx1];
+          auto& n2 = nodes[idx2];
+
+          /* connect graph */
+          if ( *n1.a == *n2.a )
+          {
+            n1.lf = idx2;
+            n2.lf = idx1;
+          }
+          else if ( *n1.a == *n2.b )
+          {
+            n1.lf = idx2;
+            n2.rf = idx1;
+          }
+          if ( *n1.b == *n2.a )
+          {
+            n1.rf = idx2;
+            n2.lf = idx1;
+          }
+          else if ( *n1.b == *n2.b )
+          {
+            n1.rf = idx2;
+            n2.rf = idx1;
+          }
+
+          ++it2;
+          ++idx2;
+        }
+        it2 += diff;
+      }
+      ++it1;
+      ++idx1;
+    }
+    it1 += diff;
+  }
+
+  /* traverse graph and compute masks */
+  auto mask_left = tt.construct();
+  auto mask_right = tt.construct();
+
+  while ( true )
+  {
+    auto idx = 0;
+
+    while ( idx < offset && nodes[idx].visited )
+    {
+      ++idx;
+    }
+
+    if ( idx == offset )
+    {
+      break;
+    }
+
+    auto left_side = true;
+    auto nr = *nodes[idx].a;
+    auto start = idx;
+
+    do
+    {
+      auto& n = nodes[idx];
+
+      auto match = *n.a == nr;
+
+      nr = match ? *n.b : *n.a;
+      idx = match ? n.rf : n.lf;
+      n.visited = true;
+
+      if ( left_side != match )
+      {
+        std::swap( *n.a, *n.b );
+
+        if ( left_side )
+        {
+          set_bit( mask_left, std::distance( left.begin(), n.a ) );
+        }
+        else
+        {
+          set_bit( mask_right, std::distance( right.begin(), n.a ) );
+        }
+      }
+
+      left_side = !left_side;
+
+    } while ( idx != start );
+  }
+
+  return std::make_pair( mask_left, mask_right );
+}
+} /* namespace detail */
+
+/*! \brief Applies delta-swap operation
+
+  The delta-swap operation swaps all position pairs \f$(i, i+\delta)\f$, for
+  which \f$\omega\f$ is set 1 at position \f$i\f$.
+
+  See also Eq. 7.1.3-(69) in The Art of Computer Programming.
+
+  \param tt Truth table
+  \param delta Index distance delta
+  \param omega Enable mask
+*/
+template<typename TT>
+inline void delta_swap_inplace( TT& tt, uint64_t delta, const TT& omega )
+{
+  const auto y = ( tt ^ ( tt >> delta ) ) & omega;
+  tt = tt ^ y ^ ( y << delta );
+}
+
+/*! \brief Applies delta-swap operation
+
+  Out-of-place variant for `delta_swap_inplace`.
+*/
+template<typename TT>
+TT delta_swap( const TT& tt, uint64_t delta, const TT& omega )
+{
+  auto copy = tt;
+  delta_swap_inplace( copy, delta, omega );
+  return copy;
+}
+
+/*! \brief Permutes a truth table using a sequence of delta-swaps
+
+  Masks is an array containing the \f$\omega\f$ masks.  The \f$\delta\f$ values
+  are chosen as increasing and decreasing powers of 2, as described in Eq.
+  7.1.3-(71) of The Art of Computer Programming.
+
+  \param tt Truth table
+  \param masks Array of omega-masks
+*/
+template<typename TT>
+void permute_with_masks_inplace( TT& tt, const std::vector<TT>& masks )
+{
+  for ( auto k = 0u; k < tt.num_vars(); ++k )
+  {
+    delta_swap_inplace( tt, uint64_t( 1 ) << k, masks[k] );
+  }
+
+  for ( int k = tt.num_vars() - 2, i = tt.num_vars(); k >= 0; --k, ++i )
+  {
+    delta_swap_inplace( tt, uint64_t( 1 ) << k, masks[i] );
+  }
+}
+
+/*! \brief Permutes a truth table using a sequence of delta-swaps
+
+  Out-of-place variant of `permute_with_masks_inplace`.
+*/
+template<typename TT>
+TT permute_with_masks( const TT& tt, const std::vector<TT>& masks )
+{
+  auto copy = tt;
+  permute_with_masks_inplace( copy, masks );
+  return copy;
+}
+
+/*! \brief Computes permutation bitmasks
+
+  These bitmasks can be used with the `permute_with_masks` algorithm.  The
+  algorithm to compute these masks is described in The Art of Computer
+  Programming, Section 7.1.3 'Bit permutation in general'.
+
+  The input truth table can be arbitrary but is used to determine the type and
+  size of of the returned permutation masks.
+
+  \param tt Base truth table to derive types and size
+  \param permutation Permutation
+*/
+template<typename TT>
+std::vector<TT> compute_permutation_masks( const TT& tt, const std::vector<uint32_t>& permutation )
+{
+  std::vector<TT> masks;
+
+  std::vector<uint32_t> left( permutation.size() ), right = permutation;
+  std::iota( left.begin(), left.end(), 0u );
+
+  for ( auto i = 0u; i < tt.num_vars() - 1u; ++i )
+  {
+    const auto pair = detail::compute_permutation_masks_pair( tt, left, right, i );
+
+    masks.insert( masks.begin() + i, pair.second );
+    masks.insert( masks.begin() + i, pair.first );
+  }
+
+  auto mask = tt.construct();
+  for ( uint64_t i = 0u; i < ( static_cast<uint64_t>( tt.num_bits() ) >> 1 ); ++i )
+  {
+    if ( left[i] != right[i] )
+    {
+      set_bit( mask, i );
+    }
+  }
+  masks.insert( masks.begin() + tt.num_vars() - 1, mask );
+
+  return masks;
+}
+
+} /* namespace kitty */
\ No newline at end of file
diff --git a/lib/kitty/kitty/print.hpp b/lib/kitty/kitty/print.hpp
new file mode 100644
index 0000000..8c45551
--- /dev/null
+++ b/lib/kitty/kitty/print.hpp
@@ -0,0 +1,481 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file print.hpp
+  \brief Implements functions to print truth tables
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <functional>
+#include <iostream>
+#include <iterator>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "algorithm.hpp"
+#include "karnaugh_map.hpp"
+#include "operations.hpp"
+#include "constructors.hpp"
+
+namespace kitty
+{
+
+namespace detail
+{
+
+inline std::string to_binary( uint16_t value, uint32_t num_vars )
+{
+  std::string res( num_vars, '0' );
+  auto it = res.end() - 1;
+  while ( value )
+  {
+    if ( value & 1 )
+    {
+      *it = '1';
+    }
+    value >>= 1;
+    if ( it == res.begin() )
+    {
+      break;
+    }
+    --it;
+  }
+  return res;
+}
+
+inline void print_xmas_tree(
+    std::ostream& os, uint32_t num_vars,
+    const std::vector<std::pair<std::function<bool( uint16_t )>,
+                                std::vector<int>>>& style_predicates = {} )
+{
+  /* create rows */
+  std::vector<std::vector<uint16_t>> current( 1, { 0 } ), next;
+
+  for ( auto i = 0u; i < num_vars; ++i )
+  {
+    for ( const auto& row : current )
+    {
+      if ( row.size() != 1u )
+      {
+        next.emplace_back();
+
+        std::transform( row.begin() + 1, row.end(),
+                        std::back_inserter( next.back() ),
+                        []( auto cell )
+                        { return cell << 1; } );
+      }
+      next.emplace_back( 1, row.front() << 1 );
+      std::transform( row.begin(), row.end(), std::back_inserter( next.back() ),
+                      []( auto cell )
+                      { return ( cell << 1 ) ^ 1; } );
+    }
+
+    std::swap( current, next );
+    next.clear();
+  }
+
+  for ( const auto& row : current )
+  {
+    /* white space padding to center columns */
+    os << std::string( ( ( num_vars + 1 ) - row.size() ) / 2 * ( num_vars + 1 ), ' ' );
+    for ( const auto& col : row )
+    {
+      os << " ";
+      for ( const auto& pred : style_predicates )
+      {
+        if ( pred.first( col ) )
+        {
+          for ( auto style : pred.second )
+          {
+            os << "\033[" << style << "m";
+          }
+        }
+      }
+      os << to_binary( col, num_vars ) << "\033[0m";
+    }
+    os << "\n";
+  }
+}
+
+} // namespace detail
+
+/*! \brief Prints truth table in binary representation
+
+  The most-significant bit will be the first character of the string.
+
+  \param tt Truth table
+  \param os Output stream
+*/
+template<typename TT>
+void print_binary( const TT& tt, std::ostream& os = std::cout )
+{
+  auto const chunk_size = std::min<uint64_t>( tt.num_bits(), 64 );
+  for_each_block_reversed( tt, [&os, chunk_size]( auto word )
+                           {
+    std::string chunk( chunk_size, '0' );
+
+    auto it = chunk.rbegin();
+    while (word && it != chunk.rend()) {
+      if (word & 1) {
+        *it = '1';
+      }
+      ++it;
+      word >>= 1;
+    }
+    os << chunk; } );
+}
+
+/*! \cond PRIVATE */
+inline void print_binary( const partial_truth_table& tt,
+                          std::ostream& os = std::cout )
+{
+  auto const chunk_size = std::min<uint64_t>( tt.num_bits(), 64 );
+  bool first = true;
+  for_each_block_reversed( tt, [&tt, &os, chunk_size, &first]( auto word )
+                           {
+    std::string chunk( chunk_size, '0' );
+    auto it = chunk.rbegin();
+    while (word && it != chunk.rend()) {
+      if (word & 1) {
+        *it = '1';
+      }
+      ++it;
+      word >>= 1;
+    }
+
+    if (first && (chunk_size == 64) && (tt.num_bits() % 64)) {
+      first = false;
+      os << chunk.substr(64 - (tt.num_bits() % 64));
+    } else {
+      os << chunk;
+    } } );
+}
+/*! \endcond */
+
+template<typename TT>
+void print_binary( const ternary_truth_table<TT>& tt, std::ostream& os = std::cout )
+{
+  auto const chunk_size = std::min<uint64_t>( tt.num_bits(), 64 );
+  std::string tt_string = "";
+  for_each_block_reversed( tt._bits, [&os, &tt_string, chunk_size]( auto word )
+                           {
+    std::string chunk( chunk_size, '0' );
+    auto it = chunk.rbegin();
+    while ( word && it != chunk.rend() )
+    {
+      if ( word & 1 )
+      {
+        *it = '1';
+      }
+      ++it;
+      word >>= 1;
+    }
+    tt_string += chunk; } );
+  for ( auto i = 0; i < tt.num_bits(); i++ )
+  {
+    if ( is_dont_care( tt, tt.num_bits() - 1 - i ) )
+    {
+      tt_string[i] = '-';
+    }
+  }
+  os << tt_string;
+}
+
+template<typename TT>
+void print_binary( const quaternary_truth_table<TT>& tt, std::ostream& os = std::cout )
+{
+  auto const chunk_size = std::min<uint64_t>( tt.num_bits(), 64 );
+  std::string tt_string = "";
+  for_each_block_reversed( tt._onset, [&os, &tt_string, chunk_size]( auto word )
+                           {
+    std::string chunk( chunk_size, '0' );
+    auto it = chunk.rbegin();
+    while ( word && it != chunk.rend() )
+    {
+      if ( word & 1 )
+      {
+        *it = '1';
+      }
+      ++it;
+      word >>= 1;
+    }
+    tt_string += chunk; } );
+  for ( auto i = 0; i < tt.num_bits(); i++ )
+  {
+    if ( is_dont_care( tt, tt.num_bits() - 1 - i ) )
+      tt_string[i] = '-';
+    if ( is_dont_know( tt, tt.num_bits() - 1 - i ) )
+      tt_string[i] = 'x';
+  }
+  os << tt_string;
+}
+
+/*! \brief Prints K-map of given truth table.
+
+  Columns represent the values of the least significant variables, rows of the
+  most significant ones.
+
+  \param tt Truth table
+  \param os Output stream (default = cout)
+*/
+template<typename TT>
+void print_kmap( const TT& tt, std::ostream& os = std::cout )
+{
+  karnaugh_map<TT> kmap( tt );
+  kmap.print( os );
+}
+
+/*! \brief Prints truth table in hexadecimal representation
+
+  The most-significant bit will be the first character of the string.
+
+  \param tt Truth table
+  \param os Output stream
+*/
+template<typename TT, typename = std::enable_if_t<is_completely_specified_truth_table<TT>::value>>
+void print_hex( const TT& tt, std::ostream& os = std::cout )
+{
+  auto const chunk_size =
+      std::min<uint64_t>( tt.num_vars() <= 1 ? 1 : ( tt.num_bits() >> 2 ), 16 );
+
+  for_each_block_reversed( tt, [&os, chunk_size]( auto word )
+                           {
+    std::string chunk( chunk_size, '0' );
+
+    auto it = chunk.rbegin();
+    while (word && it != chunk.rend()) {
+      auto hex = word & 0xf;
+      if (hex < 10) {
+        *it = '0' + static_cast<char>(hex);
+      } else {
+        *it = 'a' + static_cast<char>(hex - 10);
+      }
+      ++it;
+      word >>= 4;
+    }
+    os << chunk; } );
+}
+
+/*! \cond PRIVATE */
+inline void print_hex( const partial_truth_table& tt,
+                       std::ostream& os = std::cout )
+{
+  bool first = true;
+  for_each_block_reversed( tt, [&tt, &os, &first]( auto word )
+                           {
+    std::string chunk( 16, '0' );
+
+    auto it = chunk.rbegin();
+    while (word && it != chunk.rend()) {
+      auto hex = word & 0xf;
+      if (hex < 10) {
+        *it = '0' + static_cast<char>(hex);
+      } else {
+        *it = 'a' + static_cast<char>(hex - 10);
+      }
+      ++it;
+      word >>= 4;
+    }
+
+    if (first && (tt.num_bits() % 64)) {
+      first = false;
+      os << chunk.substr((tt.num_bits() % 4)
+                             ? (15 - ((tt.num_bits() >> 2) % 16))
+                             : (16 - ((tt.num_bits() >> 2) % 16)));
+    } else {
+      os << chunk;
+    } } );
+}
+/*! \endcond */
+
+/*! \brief Prints truth table in raw binary presentation (for file I/O)
+
+  This function is useful to store large truth tables in binary files
+  or `std::stringstream`. Each word is stored into 8 characters.
+
+  \param tt Truth table
+  \param os Output stream
+*/
+template<typename TT, typename = std::enable_if_t<!std::is_same<TT, ternary_truth_table<dynamic_truth_table>>::value>>
+void print_raw( const TT& tt, std::ostream& os )
+{
+  for_each_block( tt, [&os]( auto word )
+                  { os.write( reinterpret_cast<char*>( &word ), sizeof( word ) ); } );
+}
+
+/*! \brief Returns truth table as a string in binary representation
+
+  Calls `print_binary` internally on a string stream.
+
+  \param tt Truth table
+*/
+template<typename TT>
+inline std::string to_binary( const TT& tt )
+{
+  std::stringstream st;
+  print_binary( tt, st );
+  return st.str();
+}
+
+/*! \brief Returns truth table as a string in hexadecimal representation
+
+  Calls `print_hex` internally on a string stream.
+
+  \param tt Truth table
+*/
+template<typename TT, typename = std::enable_if_t<is_completely_specified_truth_table<TT>::value>>
+inline std::string to_hex( const TT& tt )
+{
+  std::stringstream st;
+  print_hex( tt, st );
+  return st.str();
+}
+
+/*! \brief Prints minterms of a Boolean function in christmas tree pattern
+
+  This function prints all minterms of a Boolean function and arranges them
+  according to the christmas tree pattern as described in Section 7.2.1.6 in
+  The Art of Computer Programming by Donald E. Knuth.  Minterms from the
+  off-set are printed in red, minterms from the on-set are printed in green.
+
+  \param tt Truth table
+  \param os Output stream
+*/
+template<typename TT, typename = std::enable_if_t<!std::is_same<TT, partial_truth_table>::value>, typename = std::enable_if_t<is_completely_specified_truth_table<TT>::value>>
+
+void print_xmas_tree_for_function( const TT& tt, std::ostream& os = std::cout )
+{
+  detail::print_xmas_tree( os, tt.num_vars(),
+                           { { [&]( auto v )
+                               { return get_bit( tt, v ); },
+                               { 32 } },
+                             { [&]( auto v )
+                               { return !get_bit( tt, v ); },
+                               { 31 } } } );
+}
+
+/*! \brief Prints all Boolean functions of n variables in christmas tree pattern
+
+  This function prints all Boolean functions of n variables and arranges them
+  according to the christmas tree pattern as described in Section 7.2.1.6 in
+  The Art of Computer Programming by Donald E. Knuth.  Functions can be printed
+  in different styles according to some properties.
+
+  \param tt Number of variables
+  \param style_predicates Each pair has a predicate `bool(TT const&)` to check
+                          whether a certain property holds for the truth table
+                          the element in the tree represents.  If this predicate
+                          evaluates to true, then the second element in the pair
+                          are indexes of style (ANSI term) to change the
+                          string in the output.
+  \param os Output stream
+*/
+template<class TT>
+void print_xmas_tree_for_functions(
+    uint32_t num_vars,
+    const std::vector<std::pair<std::function<bool( TT const& )>,
+                                std::vector<int>>>& style_predicates = {},
+    std::ostream& os = std::cout )
+{
+
+  std::vector<std::pair<std::function<bool( uint16_t )>, std::vector<int>>>
+      _preds;
+  std::transform( style_predicates.begin(), style_predicates.end(),
+                  std::back_inserter( _preds ), [&]( const auto& p )
+                  { return std::make_pair(
+                        [&]( uint16_t v )
+                        {
+                          auto tt = create<TT>( num_vars );
+                          std::copy( &v, &v + 1, tt.begin() );
+                          return p.first( tt );
+                        },
+                        p.second ); } );
+
+  detail::print_xmas_tree( os, 1 << num_vars, _preds );
+}
+
+/*! \brief Creates an expression for an ANF form
+ *
+ * \param anf Truth table in ANF encoding
+ */
+template<typename TT, typename = std::enable_if_t<
+                          !std::is_same<TT, partial_truth_table>::value>>
+std::string anf_to_expression( const TT& anf )
+{
+  const auto terms = count_ones( anf );
+
+  if ( terms == 0u )
+  {
+    return "0";
+  }
+
+  std::string expr;
+
+  for_each_one_bit( anf, [&]( auto bit )
+                    {
+    if ( bit == 0 )
+    {
+
+      expr += "1";
+      return;
+    }
+    auto weight = __builtin_popcount(static_cast<uint32_t>(bit));
+    if (weight != 1) {
+      expr += "(";
+    }
+    for (auto i = 0u; i < anf.num_vars(); ++i) {
+      if ((bit >> i) & 1) {
+        expr += std::string(1, 'a' + i);
+      }
+    }
+    if (weight != 1) {
+      expr += ")";
+    } } );
+
+  return terms == 1 ? expr : "[" + expr + "]";
+}
+
+/*! \brief Creates an expression for an ANF form
+
+  All don't cares are considered to be zero.
+
+  It is a "restricted" ANF for the ternary turth table.
+ *
+ * \param anf Ternary truth table in ANF encoding
+ */
+template<typename TT, typename = std::enable_if_t<!std::is_same<TT, partial_truth_table>::value>>
+std::string anf_to_expression( const ternary_truth_table<TT>& anf )
+{
+  return anf_to_expression( anf._bits );
+}
+
+} /* namespace kitty */
\ No newline at end of file
diff --git a/lib/kitty/kitty/properties.hpp b/lib/kitty/kitty/properties.hpp
new file mode 100644
index 0000000..d9a7c6b
--- /dev/null
+++ b/lib/kitty/kitty/properties.hpp
@@ -0,0 +1,374 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file properties.hpp
+  \brief Implements property checks for Boolean function
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <algorithm>
+#include <cinttypes>
+#include <utility>
+#include <vector>
+
+#include "bit_operations.hpp"
+#include "esop.hpp"
+#include "operations.hpp"
+#include "operators.hpp"
+#include "traits.hpp"
+
+namespace kitty
+{
+
+/*! \brief Returns the Chow parameter of a function
+  The Chow parameters is a set of values \f$N(f), \Sigma(f)\f$, where \f$N(f)\f$
+  is the size of the ON-set, and \f$\Sigma(f)\f$ is the sum of all input
+  assignments in the ON-set.  For example for \f$f = x_1 \lor x_2\f$ the
+  function returns \f$(3, (2,2))\f$.
+  \param tt Truth table
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+std::pair<uint32_t, std::vector<uint32_t>> chow_parameters( const TT& tt )
+{
+  assert( tt.num_vars() <= 32 );
+
+  const auto n = tt.num_vars();
+  const auto nf = static_cast<uint32_t>( count_ones( tt ) );
+
+  std::vector<uint32_t> sf( n, 0u );
+  for_each_one_bit( tt, [&sf]( auto minterm )
+                    {
+    for ( auto i = 0u; minterm; ++i )
+    {
+      if ( minterm & 1 )
+      {
+        ++sf[i];
+      }
+      minterm >>= 1;
+    } } );
+
+  return { nf, sf };
+}
+
+/*! \brief Checks whether a function is canalizing
+  \param tt Truth table
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+bool is_canalizing( const TT& tt )
+{
+  uint32_t f1or{}, f0or{};
+  uint32_t f1and, f0and;
+
+  uint32_t max = static_cast<uint32_t>( ( uint64_t( 1 ) << tt.num_vars() ) - 1 );
+  f1and = f0and = max;
+
+  for ( uint32_t i = 0u; i < static_cast<uint32_t>( tt.num_bits() ); ++i )
+  {
+    if ( get_bit( tt, i ) == 0 )
+    {
+      f0and &= i;
+      f0or |= i;
+    }
+    else
+    {
+      f1and &= i;
+      f1or |= i;
+    }
+
+    if ( f0and == 0 && f1and == 0 && f0or == max && f1or == max )
+    {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/*! \brief Checks whether a function is Horn
+  A function is Horn, if it can be represented using Horn clauses.
+  \param tt Truth table
+*/
+template<typename TT>
+bool is_horn( const TT& tt )
+{
+  for ( uint32_t i = 1u; i < static_cast<uint32_t>( tt.num_bits() ); ++i )
+  {
+    for ( uint32_t j = 0u; j < i; ++j )
+    {
+      if ( get_bit( tt, j ) && get_bit( tt, i ) && !get_bit( tt, i & j ) )
+      {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+/*! \brief Checks whether a function is Krom
+  A function is Krom, if it can be represented using Krom clauses.
+  \param tt Truth table
+*/
+template<typename TT>
+bool is_krom( const TT& tt )
+{
+  for ( uint32_t i = 2u; i < static_cast<uint32_t>( tt.num_bits() ); ++i )
+  {
+    for ( uint32_t j = 1u; j < i; ++j )
+    {
+      for ( uint32_t k = 0u; k < j; ++k )
+      {
+        const auto maj = ( i & j ) | ( i & k ) | ( j & k );
+        if ( get_bit( tt, k ) && get_bit( tt, j ) && get_bit( tt, i ) && !get_bit( tt, maj ) )
+        {
+          return false;
+        }
+      }
+    }
+  }
+
+  return true;
+}
+
+/*! \brief Checks whether a function is symmetric in a pair of variables
+  A function is symmetric in two variables, if it is invariant to swapping them.
+  \param tt Truth table
+  \param var_index1 Index of first variable
+  \param var_index2 Index of second variable
+*/
+template<typename TT>
+bool is_symmetric_in( const TT& tt, uint8_t var_index1, uint8_t var_index2 )
+{
+  return tt == swap( tt, var_index1, var_index2 );
+}
+
+/*! \brief Checks whether a function is monotone
+  A function is monotone if f(x) ≤ f(y) whenever x ⊆ y
+  \param tt Truth table
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+bool is_monotone( const TT& tt )
+{
+  auto numvars = tt.num_vars();
+
+  for ( auto i = 0u; i < numvars; i++ )
+  {
+    auto const tt1 = cofactor0( tt, i );
+    auto const tt2 = cofactor1( tt, i );
+    for ( auto bit = 0; bit < ( 2 << ( numvars - 1 ) ); bit++ )
+    {
+      if ( get_bit( tt1, bit ) <= get_bit( tt2, bit ) )
+      {
+        continue;
+      }
+      else
+      {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+/*! \brief Checks whether a function is selfdual
+  A function is selfdual if !f(x, y, ..., z) = f(!x, !y, ..., !z)
+  \param tt Truth table
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+bool is_selfdual( const TT& tt )
+{
+  auto numvars = tt.num_vars();
+  auto tt1 = tt;
+  auto tt2 = ~tt1;
+  for ( auto i = 0u; i < numvars; i++ )
+  {
+    tt1 = flip( tt1, i );
+  }
+
+  return tt2 == tt1;
+}
+
+/*! \brief Checks if a function is normal
+  A function is normal iff f(0, ..., 0) = 0.
+  \param tt Truth table
+*/
+template<typename TT>
+bool is_normal( const TT& tt )
+{
+  return !get_bit( tt, 0u );
+}
+
+/*! \brief Checks if a function is trivial
+  A function is trival if it is equal to (or the complement of) a
+  variable or constant zero.
+  \param tt Truth table
+*/
+template<typename TT, typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+bool is_trivial( const TT& tt )
+{
+  /* compare to constants */
+  if ( is_const0( tt ) || is_const0( ~tt ) )
+    return true;
+
+  /* compare to variables */
+  TT tt_check = tt;
+  for ( auto i = 0u; i < tt.num_vars(); ++i )
+  {
+    create_nth_var( tt_check, i );
+    if ( tt == tt_check || tt == ~tt_check )
+      return true;
+  }
+
+  return false;
+}
+
+/*! \brief Generate runlength encoding of a function
+  This function iterates through the bits of a function and calls a function
+  for each runlength and value.  For example, if this function is called for
+  the AND function 1000, it will call `fn` first with arguments `false` and `3`,
+  and then a second time with arguments `true`, and `1`.
+  \param tt Truth table
+  \param fn Function of signature `void(bool, uint32_t)`
+*/
+template<typename TT, typename Fn>
+void foreach_runlength( const TT& tt, Fn&& fn )
+{
+  bool current = get_bit( tt, 0 );
+  uint32_t length{ 1u };
+
+  for ( auto i = 1ull; i < tt.num_bits(); ++i )
+  {
+    if ( static_cast<bool>( get_bit( tt, i ) ) != current )
+    {
+      fn( current, length );
+      current = !current;
+      length = 1u;
+    }
+    else
+    {
+      ++length;
+    }
+  }
+
+  fn( current, length );
+}
+
+/*! \brief Returns the runlength encoding pattern of a function
+  This function does only count the lengths, e.g., for 1000 it will return
+  `{3, 1}`, and so it does for the NAND function 0111.
+  \param tt Truth table
+*/
+template<typename TT>
+std::vector<uint32_t> runlength_pattern( const TT& tt )
+{
+  std::vector<uint32_t> pattern;
+  foreach_runlength( tt, [&]( bool, uint32_t length )
+                     { pattern.push_back( length ); } );
+  return pattern;
+}
+
+/*! \brief Compute polynomial degree
+  The polyomial degree is the number of variables in the largest monomial in
+  the functoons ANF (PPRM).
+  \param tt Truth table
+*/
+template<typename TT>
+inline uint32_t polynomial_degree( const TT& tt )
+{
+  const auto cubes = esop_from_pprm( tt );
+  if ( cubes.empty() ) /* zero function */
+  {
+    return 0u;
+  }
+  const auto max = std::max_element( cubes.begin(), cubes.end(),
+                                     []( auto const& c1, auto const& c2 )
+                                     { return c1.num_literals() < c2.num_literals(); } );
+  return max->num_literals();
+}
+
+/*! \brief Returns the absolute distinguishing power of a function
+  The absolute distinguishing power of a function f is the number of
+  distinguishing bit pair {i,j} such that f(i) != f(j).
+  \param tt Truth table
+*/
+template<typename TT>
+inline uint64_t absolute_distinguishing_power( const TT& tt )
+{
+  return count_zeros( tt ) * count_ones( tt );
+}
+
+/*! \brief Returns the relative distinguishing power of a function wrt. to a target function
+  Quantifies the number of distinguishing bit pairs in the target function
+  that can be distinguished by another function.
+  \param tt Truth table of function
+  \param target_tt Truth table of target function
+*/
+template<typename TT>
+inline uint64_t relative_distinguishing_power( const TT& tt, const TT& target_tt )
+{
+  return count_ones( ~tt & ~target_tt ) * count_ones( tt & target_tt ) + count_ones( ~tt & target_tt ) * count_ones( tt & ~target_tt );
+}
+
+/*! \brief Return true iff each distinguishing bit pair of the target
+  function is also distinguishable by the divisor functions
+  \param target Truth table of the target functions
+  \param divisors Truth tables of the divisor functions
+*/
+template<typename TT>
+bool is_covered_with_divisors( TT const& target, std::vector<TT> const& divisors )
+{
+  /* iterate over all bit pairs of the target function */
+  for ( uint32_t j = 1u; j < target.num_bits(); ++j )
+  {
+    for ( uint32_t i = 0u; i < j; ++i )
+    {
+      /* check if the bit pair is distinguished by the target function */
+      if ( get_bit( target, i ) != get_bit( target, j ) )
+      {
+        /* check if this bit pair is also distinguished by a divisor function */
+        bool found = false;
+        for ( const auto& d : divisors )
+        {
+          if ( get_bit( d, i ) != get_bit( d, j ) )
+          {
+            found = true;
+            break;
+          }
+        }
+
+        if ( !found )
+        {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+} // namespace kitty
\ No newline at end of file
diff --git a/lib/kitty/kitty/quaternary_truth_table.hpp b/lib/kitty/kitty/quaternary_truth_table.hpp
new file mode 100644
index 0000000..8c91db4
--- /dev/null
+++ b/lib/kitty/kitty/quaternary_truth_table.hpp
@@ -0,0 +1,265 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file quaternary_truth_table.hpp
+  \brief Implements quaternary_truth_table
+
+  \author Siang-Yun Lee
+  \author Gianluca Radi
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <type_traits>
+#include <vector>
+
+#include "detail/constants.hpp"
+#include "traits.hpp"
+
+namespace kitty
+{
+
+template<class TT>
+struct quaternary_truth_table
+{
+  /*! \brief Standard constructor.
+
+    Initialize the truth table using the constructor of the inner
+    truth table type.
+
+    \param n Number of variables or number of bits (when `TT = partial_truth_table`)
+  */
+  explicit quaternary_truth_table( uint32_t n )
+      : _onset( n ), _offset( n )
+  {
+  }
+
+  /*! \brief Empty constructor.
+
+    Creates an empty truth table by calling the empty constructor
+    of the inner truth table type.
+   */
+  quaternary_truth_table() : _onset(), _offset() {}
+
+  /*! \brief Construct from onset and offset.
+
+    Meanings of the values of (offset, onset) at each bit position:
+    00 is a don't-know (x) or not involved in the cube,
+    01 is a positive literal (1), 10 is a negative literal (0), and
+    11 is a don't-care (-), meaning that both 0 and 1 are accepted.
+
+    \param onset Onset truth table.
+    \param offset Offset truth table.
+  */
+  quaternary_truth_table( TT const& onset, TT const& offset )
+      : _onset( onset ), _offset( offset )
+  {
+  }
+
+  /*! \brief Construct from a binary truth table.
+
+    Initialize the truth table as equivalent to a binary truth table.
+    (All bits are cared and known, being either `0` or `1`, without any
+    `-` or `x`.)
+
+    \param binary Binary truth table.
+  */
+  quaternary_truth_table( TT const& binary )
+      : _onset( binary ), _offset( ~binary )
+  {
+  }
+
+  /*! Constructs a new quaternary_truth_table instance of the same size. */
+  inline quaternary_truth_table<TT> construct() const
+  {
+    if constexpr ( std::is_same_v<TT, partial_truth_table> )
+      return quaternary_truth_table<TT>( _onset.num_bits() );
+    else
+      return quaternary_truth_table<TT>( _onset.num_vars() );
+  }
+
+  /*! Returns number of variables.
+   */
+  template<typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+  auto num_vars() const noexcept { return _onset.num_vars(); }
+
+  /*! Returns number of blocks.
+   */
+  inline auto num_blocks() const noexcept { return _onset.num_blocks(); }
+
+  /*! Returns number of bits.
+   */
+  inline auto num_bits() const noexcept { return _onset.num_bits(); }
+
+  /*! \brief Begin iterator to onset.
+   */
+  inline auto begin_onset() noexcept { return _onset.begin(); }
+
+  /*! \brief End iterator to onset.
+   */
+  inline auto end_onset() noexcept { return _onset.end(); }
+
+  /*! \brief Begin iterator to onset.
+   */
+  inline auto begin_onset() const noexcept { return _onset.begin(); }
+
+  /*! \brief End iterator to onset.
+   */
+  inline auto end_onset() const noexcept { return _onset.end(); }
+
+  /*! \brief Reverse begin iterator to onset.
+   */
+  inline auto rbegin_onset() noexcept { return _onset.rbegin(); }
+
+  /*! \brief Reverse end iterator to onset.
+   */
+  inline auto rend_onset() noexcept { return _onset.rend(); }
+
+  /*! \brief Constant begin iterator to onset.
+   */
+  inline auto cbegin_onset() const noexcept { return _onset.cbegin(); }
+
+  /*! \brief Constant end iterator to onset.
+   */
+  inline auto cend_onset() const noexcept { return _onset.cend(); }
+
+  /*! \brief Constant reverse begin iterator to onset.
+   */
+  inline auto crbegin_onset() const noexcept { return _onset.crbegin(); }
+
+  /*! \brief Constant teverse end iterator to onset.
+   */
+  inline auto crend_onset() const noexcept { return _onset.crend(); }
+
+  /*! \brief Begin iterator to offset.
+   */
+  inline auto begin_offset() noexcept { return _offset.begin(); }
+
+  /*! \brief End iterator to offset.
+   */
+  inline auto end_offset() noexcept { return _offset.end(); }
+
+  /*! \brief Begin iterator to offset.
+   */
+  inline auto begin_offset() const noexcept { return _offset.begin(); }
+
+  /*! \brief End iterator to offset.
+   */
+  inline auto end_offset() const noexcept { return _offset.end(); }
+
+  /*! \brief Reverse begin iterator to offset.
+   */
+  inline auto rbegin_offset() noexcept { return _offset.rbegin(); }
+
+  /*! \brief Reverse end iterator to offset.
+   */
+  inline auto rend_offset() noexcept { return _offset.rend(); }
+
+  /*! \brief Constant begin iterator to offset.
+   */
+  inline auto cbegin_offset() const noexcept { return _offset.cbegin(); }
+
+  /*! \brief Constant end iterator to offset.
+   */
+  inline auto cend_offset() const noexcept { return _offset.cend(); }
+
+  /*! \brief Constant reverse begin iterator to offset.
+   */
+  inline auto crbegin_offset() const noexcept { return _offset.crbegin(); }
+
+  /*! \brief Constant teverse end iterator to offset.
+   */
+  inline auto crend_offset() const noexcept { return _offset.crend(); }
+
+  /*! \brief Assign other truth table.
+
+    This replaces the current truth table with another truth table.
+    The other truth table must also be quaternary, and the inner type of
+    the other truth table must be assignable to the inner type of this
+    truth table.
+
+    \param other Other truth table
+  */
+  template<class TT2>
+  quaternary_truth_table<TT>& operator=( const quaternary_truth_table<TT2>& other )
+  {
+    _onset = other._onset;
+    _offset = other._offset;
+
+    return *this;
+  }
+
+  /*! \brief Assigned by a binary truth table.
+
+    Replaces with a truth table equivalent to a binary truth table.
+    (All bits are cared and known, being either `0` or `1`, without any
+    `-` or `x`.)
+
+    \param other Binary truth table.
+  */
+  template<class TT2>
+  quaternary_truth_table<TT>& operator=( TT const& other )
+  {
+    _onset = other;
+    _offset = ~other;
+
+    return *this;
+  }
+
+  /*! \brief Masks valid truth table bits.
+
+    This operation makes sure to zero out all unused bits.
+  */
+  inline void mask_bits() noexcept
+  {
+    _onset.mask_bits();
+    _offset.mask_bits();
+  }
+
+  /*! \cond PRIVATE */
+public: /* fields */
+  TT _onset;
+  TT _offset;
+  /*! \endcond */
+};
+
+template<class TT>
+struct is_truth_table<kitty::quaternary_truth_table<TT>> : is_truth_table<TT>
+{
+};
+
+template<class TT>
+struct is_complete_truth_table<kitty::quaternary_truth_table<TT>> : is_complete_truth_table<TT>
+{
+};
+
+template<class TT>
+struct is_completely_specified_truth_table<kitty::quaternary_truth_table<TT>> : std::false_type
+{
+};
+
+} // namespace kitty
diff --git a/lib/kitty/kitty/spectral.hpp b/lib/kitty/kitty/spectral.hpp
new file mode 100644
index 0000000..9afd936
--- /dev/null
+++ b/lib/kitty/kitty/spectral.hpp
@@ -0,0 +1,1204 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ * Copyright (C) 2017-2021  University of Victoria
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file spectral.hpp
+  \brief Implements methods for spectral classification
+
+  Original implementation by D. Michael Miller (University of
+  Victoria, BC, Canada).  Modified C++ implementation and integration
+  into kitty by Mathias Soeken.
+
+  \author D. Michael Miller
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include "bit_operations.hpp"
+#include "constructors.hpp"
+#include "esop.hpp"
+#include "detail/mscfix.hpp"
+#include "traits.hpp"
+
+#include <cmath>
+#include <iomanip>
+#include <iostream>
+#include <unordered_map>
+
+namespace kitty
+{
+
+namespace detail
+{
+struct spectral_operation
+{
+  enum class kind : uint16_t
+  {
+    none,
+    permutation,
+    input_negation,
+    output_negation,
+    spectral_translation,
+    disjoint_translation
+  };
+
+  spectral_operation() = default;
+  explicit spectral_operation( kind _kind, uint16_t _var1 = 0, uint16_t _var2 = 0 ) : _kind( _kind ), _var1( _var1 ), _var2( _var2 ) {}
+
+  kind _kind{ kind::none };
+  uint16_t _var1{ 0 };
+  uint16_t _var2{ 0 };
+};
+
+inline void fast_hadamard_transform( std::vector<int32_t>& s, bool reverse = false )
+{
+  unsigned k{};
+  int t{};
+
+  for ( auto m = 1u; m < s.size(); m <<= 1u )
+  {
+    for ( auto i = 0u; i < s.size(); i += ( m << 1u ) )
+    {
+      for ( auto j = i, p = k = i + m; j < p; ++j, ++k )
+      {
+        t = s[j];
+        s[j] += s[k];
+        s[k] = t - s[k];
+      }
+    }
+  }
+
+  if ( reverse )
+  {
+    for ( auto i = 0u; i < s.size(); ++i )
+    {
+      s[i] /= static_cast<int>( s.size() );
+    }
+  }
+}
+
+class spectrum
+{
+public:
+  spectrum() = delete;
+  ~spectrum() = default;
+
+  spectrum( const spectrum& other ) : _s( std::begin( other._s ), std::end( other._s ) ) {}
+  spectrum( spectrum&& other ) noexcept : _s( std::move( other._s ) ) {}
+
+  spectrum& operator=( const spectrum& other )
+  {
+    if ( this != &other )
+    {
+      _s = other._s;
+    }
+    return *this;
+  }
+
+  spectrum& operator=( spectrum&& other ) noexcept
+  {
+    _s = std::move( other._s );
+    return *this;
+  }
+
+private:
+  explicit spectrum( std::vector<int32_t> _s ) : _s( std::move( _s ) ) {}
+
+public:
+  template<typename TT>
+  static spectrum from_truth_table( const TT& tt )
+  {
+    std::vector<int32_t> _s( tt.num_bits(), 1 );
+    for_each_one_bit( tt, [&_s]( auto bit )
+                      { _s[bit] = -1; } );
+    fast_hadamard_transform( _s );
+    return spectrum( _s );
+  }
+
+  template<typename TT>
+  void to_truth_table( TT& tt ) const
+  {
+    auto copy = _s;
+    fast_hadamard_transform( copy, true );
+
+    clear( tt );
+    for ( auto i = 0u; i < copy.size(); ++i )
+    {
+      if ( copy[i] == -1 )
+      {
+        set_bit( tt, i );
+      }
+    }
+  }
+
+  auto permutation( unsigned i, unsigned j )
+  {
+    spectral_operation op( spectral_operation::kind::permutation, i, j );
+
+    for ( auto k = 0u; k < _s.size(); ++k )
+    {
+      if ( ( k & i ) > 0 && ( k & j ) == 0 )
+      {
+        std::swap( _s[k], _s[k - i + j] );
+      }
+    }
+
+    return op;
+  }
+
+  auto input_negation( unsigned i )
+  {
+    spectral_operation op( spectral_operation::kind::input_negation, i );
+    for ( auto k = 0u; k < _s.size(); ++k )
+    {
+      if ( ( k & i ) > 0 )
+      {
+        _s[k] = -_s[k];
+      }
+    }
+
+    return op;
+  }
+
+  auto output_negation()
+  {
+    for ( auto& coeff : _s )
+    {
+      coeff = -coeff;
+    }
+    return spectral_operation( spectral_operation::kind::output_negation );
+  }
+
+  auto spectral_translation( int i, int j )
+  {
+    spectral_operation op( spectral_operation::kind::spectral_translation, i, j );
+
+    for ( auto k = 0u; k < _s.size(); ++k )
+    {
+      if ( ( k & i ) > 0 && ( k & j ) == 0 )
+      {
+        std::swap( _s[k], _s[k + j] );
+      }
+    }
+
+    return op;
+  }
+
+  auto disjoint_translation( int i )
+  {
+    spectral_operation op( spectral_operation::kind::disjoint_translation, i );
+
+    for ( auto k = 0u; k < _s.size(); ++k )
+    {
+      if ( ( k & i ) > 0 )
+      {
+        std::swap( _s[k], _s[k - i] );
+      }
+    }
+
+    return op;
+  }
+
+  void apply( const spectral_operation& op )
+  {
+    switch ( op._kind )
+    {
+    case spectral_operation::kind::none:
+      assert( false );
+      break;
+    case spectral_operation::kind::permutation:
+      permutation( op._var1, op._var2 );
+      break;
+    case spectral_operation::kind::input_negation:
+      input_negation( op._var1 );
+      break;
+    case spectral_operation::kind::output_negation:
+      output_negation();
+      break;
+    case spectral_operation::kind::spectral_translation:
+      spectral_translation( op._var1, op._var2 );
+      break;
+    case spectral_operation::kind::disjoint_translation:
+      disjoint_translation( op._var1 );
+      break;
+    }
+  }
+
+  inline auto operator[]( std::vector<int32_t>::size_type pos )
+  {
+    return _s[pos];
+  }
+
+  inline auto operator[]( std::vector<int32_t>::size_type pos ) const
+  {
+    return _s[pos];
+  }
+
+  inline auto size() const
+  {
+    return _s.size();
+  }
+
+  inline auto cbegin() const
+  {
+    return _s.cbegin();
+  }
+
+  inline auto cend() const
+  {
+    return _s.cend();
+  }
+
+  void print( std::ostream& os, const std::vector<uint32_t>& order ) const
+  {
+    os << std::setw( 4 ) << _s[order.front()];
+
+    for ( auto it = order.begin() + 1; it != order.end(); ++it )
+    {
+      os << " " << std::setw( 4 ) << _s[*it];
+    }
+  }
+
+  inline const auto& coefficients() const
+  {
+    return _s;
+  }
+
+private:
+  std::vector<int32_t> _s;
+};
+
+inline std::vector<uint32_t> get_rw_coeffecient_order( uint32_t num_vars )
+{
+  auto size = uint32_t( 1 ) << num_vars;
+  std::vector<uint32_t> map( size, 0u );
+  auto p = std::begin( map ) + 1;
+
+  for ( uint32_t i = 1u; i <= num_vars; ++i )
+  {
+    for ( uint32_t j = 1u; j < size; ++j )
+    {
+      if ( __builtin_popcount( j ) == static_cast<int>( i ) )
+      {
+        *p++ = j;
+      }
+    }
+  }
+
+  return map;
+}
+
+template<typename TT>
+class miller_spectral_canonization_impl
+{
+public:
+  explicit miller_spectral_canonization_impl( const TT& func, bool hasInputNegation = true, bool hasOutputNegation = true, bool hasDisjointTranslation = true )
+      : func( func ),
+        num_vars( func.num_vars() ),
+        num_vars_exp( 1 << num_vars ),
+        spec( spectrum::from_truth_table( func ) ),
+        best_spec( spec ),
+        transforms( 100u ),
+        hasInputNegation( hasInputNegation ),
+        hasOutputNegation( hasOutputNegation ),
+        hasDisjointTranslation( hasDisjointTranslation )
+  {
+  }
+
+  template<typename Callback>
+  std::pair<TT, bool> run( Callback&& fn )
+  {
+    order = get_rw_coeffecient_order( num_vars );
+    const auto exact = normalize();
+
+    fn( best_transforms );
+
+    TT tt = func.construct();
+    spec.to_truth_table<TT>( tt );
+    return { tt, exact };
+  }
+
+  void set_limit( unsigned limit )
+  {
+    step_limit = limit;
+  }
+
+private:
+  unsigned transformation_costs( const std::vector<spectral_operation>& transforms )
+  {
+    auto costs = 0u;
+    for ( const auto& t : transforms )
+    {
+      costs += ( t._kind == spectral_operation::kind::permutation ) ? 3u : 1u;
+    }
+    return costs;
+  }
+
+  void closer( spectrum& lspec )
+  {
+    for ( auto i = 0u; i < lspec.size(); ++i )
+    {
+      const auto j = order[i];
+      if ( lspec[j] == best_spec[j] )
+      {
+        continue;
+      }
+      if ( abs( lspec[j] ) > abs( best_spec[j] ) ||
+           ( abs( lspec[j] ) == abs( best_spec[j] ) && lspec[j] > best_spec[j] ) )
+      {
+        update_best( lspec );
+        return;
+      }
+
+      if ( abs( lspec[j] ) < abs( best_spec[j] ) ||
+           ( abs( lspec[j] ) == abs( best_spec[j] ) && lspec[j] < best_spec[j] ) )
+      {
+        return;
+      }
+    }
+
+    if ( transformation_costs( transforms ) < transformation_costs( best_transforms ) )
+    {
+      update_best( lspec );
+    }
+  }
+
+  bool normalize_rec( spectrum& lspec, unsigned v )
+  {
+    if ( ++step_counter == step_limit )
+      return false;
+
+    if ( v == num_vars_exp ) /* leaf case */
+    {
+      /* invert function if necessary */
+      if ( hasOutputNegation && lspec[0u] < 0 )
+      {
+        insert( lspec.output_negation() );
+      }
+      /* invert any variable as necessary */
+      if ( hasInputNegation )
+      {
+        for ( auto i = 1u; i < num_vars_exp; i <<= 1 )
+        {
+          if ( lspec[i] < 0 )
+          {
+            insert( lspec.input_negation( i ) );
+          }
+        }
+      }
+
+      closer( lspec );
+      return true;
+    }
+
+    auto min = 0, max = 0;
+    const auto p = std::accumulate( lspec.cbegin() + v, lspec.cend(),
+                                    std::make_pair( min, max ),
+                                    []( auto a, auto sv )
+                                    {
+                                      return std::make_pair( std::min( a.first, abs( sv ) ), std::max( a.second, abs( sv ) ) );
+                                    } );
+    min = p.first;
+    max = p.second;
+
+    if ( max == 0 )
+    {
+      auto& spec2 = specs.at( num_vars_exp );
+      spec2 = lspec;
+      if ( !normalize_rec( spec2, num_vars_exp ) )
+        return false;
+    }
+    else
+    {
+      for ( auto i = 1u; i < lspec.size(); ++i )
+      {
+        auto j = order[i];
+        if ( abs( lspec[j] ) != max )
+        {
+          continue;
+        }
+
+        /* k = first one bit in j starting from pos v */
+        auto k = j & ~( v - 1 ); /* remove 1 bits until v */
+        if ( k == 0 )
+        {
+          continue; /* are there bit left? */
+        }
+        k = k - ( k & ( k - 1 ) ); /* extract lowest bit */
+        j ^= k;                    /* remove bit k from j */
+
+        auto& spec2 = specs.at( v << 1 );
+        spec2 = lspec;
+
+        const auto save = transform_index;
+
+        /* spectral translation to all other 1s in j */
+        while ( j )
+        {
+          auto p = j - ( j & ( j - 1 ) );
+          insert( spec2.spectral_translation( k, p ) );
+          j ^= p;
+        }
+
+        if ( k != v )
+        {
+          insert( spec2.permutation( k, v ) );
+        }
+
+        if ( !normalize_rec( spec2, v << 1 ) )
+          return false;
+
+        if ( v == 1 && min == max )
+        {
+          return true;
+        }
+        transform_index = save;
+      }
+    }
+
+    return true;
+  }
+
+  bool normalize()
+  {
+    /* find maximum absolute element index in spectrum (by order) */
+    auto j = *std::max_element( order.cbegin(), order.cend(), [this]( auto p1, auto p2 )
+                                { return abs( spec[p1] ) < abs( spec[p2] ); } );
+
+    /* if max element is not the first element */
+    if ( j )
+    {
+      auto k = j - ( j & ( j - 1 ) ); /* LSB of j */
+      j ^= k;                         /* delete bit in j */
+
+      while ( j )
+      {
+        auto p = j - ( j & ( j - 1 ) ); /* next LSB of j */
+        j ^= p;                         /* delete bit in j */
+        insert( spec.spectral_translation( k, p ) );
+      }
+      if ( hasDisjointTranslation )
+      {
+        insert( spec.disjoint_translation( k ) );
+      }
+    }
+
+    for ( auto v = 1u; v <= num_vars_exp; v <<= 1 )
+    {
+      specs.insert( { v, spec } );
+    }
+
+    update_best( spec );
+    const auto result = normalize_rec( spec, 1 );
+    spec = best_spec;
+    return result;
+  }
+
+  void insert( const spectral_operation& trans )
+  {
+    if ( transform_index >= transforms.size() )
+    {
+      transforms.resize( transforms.size() << 1 );
+    }
+    assert( transform_index < transforms.size() );
+    transforms[transform_index++] = trans;
+  }
+
+  void update_best( const spectrum& lspec )
+  {
+    best_spec = lspec;
+    best_transforms.resize( transform_index );
+    std::copy( transforms.begin(), transforms.begin() + transform_index, best_transforms.begin() );
+  }
+
+  std::ostream& print_spectrum( std::ostream& os )
+  {
+    os << "[i]";
+
+    for ( auto i = 0u; i < spec.size(); ++i )
+    {
+      auto j = order[i];
+      if ( j > 0 && __builtin_popcount( order[i - 1] ) < __builtin_popcount( j ) )
+      {
+        os << " |";
+      }
+      os << " " << std::setw( 3 ) << spec[j];
+    }
+    return os << std::endl;
+  }
+
+private:
+  const TT& func;
+
+  unsigned num_vars;
+  unsigned num_vars_exp;
+  spectrum spec;
+  spectrum best_spec;
+  std::unordered_map<uint64_t, spectrum> specs;
+
+  std::vector<uint32_t> order;
+  std::vector<spectral_operation> transforms;
+  std::vector<spectral_operation> best_transforms;
+  unsigned transform_index{ 0u };
+
+  unsigned step_counter{ 0u };
+  unsigned step_limit{ 0u };
+
+  bool hasInputNegation{ true };
+  bool hasOutputNegation{ true };
+  bool hasDisjointTranslation{ true };
+};
+
+inline void exact_spectral_canonization_null_callback( const std::vector<spectral_operation>& operations )
+{
+  (void)operations;
+}
+} /* namespace detail */
+
+/*! \brief Exact spectral canonization
+
+  The function can be passed as second argument a callback that is called with a
+  vector of spectral operations necessary to transform the input function into
+  the representative.
+
+  \param tt Truth table
+  \param fn Callback to retrieve list of transformations (optional)
+ */
+template<typename TT, typename Callback = decltype( detail::exact_spectral_canonization_null_callback )>
+inline TT exact_spectral_canonization( const TT& tt, Callback&& fn = detail::exact_spectral_canonization_null_callback )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  detail::miller_spectral_canonization_impl<TT> impl( tt );
+  return impl.run( fn ).first;
+}
+
+/*! \brief Exact spectral canonization (with recursion limit)
+
+  This function gets as additional argument a recursion limit.  The canonization
+  is stopped once this limit is reached and the current representative at this
+  point is being returned.  The return value is a pair, where the first
+  entry is the representative, and the second entry indicates whether the
+  solution is known to be exact or not.
+
+  A function can be passed as second argument that is callback called with a
+  vector of spectral operations necessary to transform the input function into
+  the representative.
+
+  \param tt Truth table
+  \param limit Recursion limit
+  \param fn Callback to retrieve list of transformations (optional)
+ */
+template<typename TT, typename Callback = decltype( detail::exact_spectral_canonization_null_callback )>
+inline std::pair<TT, bool> exact_spectral_canonization_limit( const TT& tt, unsigned step_limit, Callback&& fn = detail::exact_spectral_canonization_null_callback )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  detail::miller_spectral_canonization_impl<TT> impl( tt );
+  impl.set_limit( step_limit );
+  return impl.run( fn );
+}
+
+namespace detail
+{
+
+template<class TT>
+struct anf_spectrum
+{
+public:
+  explicit anf_spectrum( const TT& tt )
+      : _anf( detail::algebraic_normal_form( tt ) ),
+        _khots( tt.num_vars() + 1, tt.construct() )
+  {
+    for ( auto i = 0u; i <= tt.num_vars(); ++i )
+    {
+      create_equals( _khots[i], i );
+    }
+  }
+
+private:
+  auto permutation( unsigned i, unsigned j )
+  {
+    spectral_operation op( spectral_operation::kind::permutation, 1 << i, 1 << j );
+
+    swap_inplace( _anf, i, j );
+
+    return op;
+  }
+
+  auto input_negation( unsigned i )
+  {
+    spectral_operation op( spectral_operation::kind::input_negation, 1 << i );
+
+    _anf ^= cofactor1( _anf, i ) & nth_var<TT>( _anf.num_vars(), i, true );
+
+    return op;
+  }
+
+  auto output_negation()
+  {
+    flip_bit( _anf, 0 );
+
+    return spectral_operation( spectral_operation::kind::output_negation );
+  }
+
+  auto spectral_translation( int i, int j )
+  {
+    spectral_operation op( spectral_operation::kind::spectral_translation, 1 << i, 1 << j );
+
+    _anf ^= ( cofactor1( _anf, i ) ^ cofactor0( cofactor1( _anf, i ), j ) ) & nth_var<TT>( _anf.num_vars(), j ) & nth_var<TT>( _anf.num_vars(), i, true );
+
+    return op;
+  }
+
+  auto disjoint_translation( int i )
+  {
+    spectral_operation op( spectral_operation::kind::disjoint_translation, 1 << i );
+
+    flip_bit( _anf, UINT64_C( 1 ) << i );
+
+    return op;
+  }
+
+  template<class Fn>
+  void foreach_term_of_size( uint32_t k, Fn&& fn, int64_t start = 0 )
+  {
+    auto term = find_first_one_bit( _anf & _khots[k], start );
+
+    while ( term != -1 )
+    {
+      fn( term );
+      term = find_first_one_bit( _anf & _khots[k], term + 1 );
+    }
+  }
+
+  void insert( const spectral_operation& op )
+  {
+    _transforms.push_back( op );
+  }
+
+public:
+  bool classify()
+  {
+    bool repeat = true;
+    auto rounds = 0u;
+    while ( repeat && rounds++ < 2u )
+    {
+      if ( count_ones( _anf ) < 2 )
+      {
+        break;
+      }
+
+      repeat = false;
+      for ( auto k = 2u; k < _anf.num_vars(); ++k )
+      {
+        foreach_term_of_size( k, [&]( auto term )
+                              {
+          auto mask = _anf.construct();
+          create_from_cubes( mask, {cube( static_cast<uint32_t>( term ), static_cast<uint32_t>( term ) )} );
+
+          const auto i = find_first_one_bit( _anf & _khots[k + 1] & mask );
+          if ( i != -1 )
+          {
+            insert( input_negation( detail::log2[i & ~term] ) );
+            repeat = true;
+          }
+          else
+          {
+            foreach_term_of_size( k, [&]( auto term2 ) {
+              if ( __builtin_popcount( static_cast<uint32_t>( term ^ term2 ) ) == 2 )
+              {
+                const auto vari = detail::log2[term & ~term2];
+                const auto varj = detail::log2[term2 & ~term];
+
+                insert( spectral_translation( vari, varj ) );
+                repeat = true;
+              }
+            }, term + 1 );
+          } } );
+      }
+    }
+
+    if ( get_bit( _anf, 0 ) )
+    {
+      insert( output_negation() );
+    }
+
+    for ( auto i = 0u; i < _anf.num_vars(); ++i )
+    {
+      if ( get_bit( _anf, UINT64_C( 1 ) << i ) )
+      {
+        insert( disjoint_translation( i ) );
+      }
+    }
+
+    auto mask = 0u;
+    bool disjoint = true;
+    for_each_one_bit( _anf, [&]( auto word )
+                      {
+      if ( word & mask ) {
+        disjoint = false;
+      } else {
+        mask |= word;
+      } } );
+
+    if ( disjoint )
+    {
+      auto dest_var = 0;
+      for ( auto k = 2u; k < _anf.num_vars(); ++k )
+      {
+        foreach_term_of_size( k, [&]( auto term )
+                              {
+          while ( term != 0 )
+          {
+            const auto vari = detail::log2[term & ~( term - 1 )];
+
+            // swap i with dest_var
+            if ( vari != dest_var )
+            {
+              insert( permutation( vari, dest_var ) );
+            }
+            ++dest_var;
+
+            term &= ( term - 1 );
+          } } );
+      }
+
+      return true;
+    }
+
+    return false;
+  }
+
+  const TT& anf() const
+  {
+    return _anf;
+  }
+
+  TT truth_table() const
+  {
+    return detail::algebraic_normal_form( _anf );
+  }
+
+  template<class Callback>
+  void get_transformations( Callback&& fn ) const
+  {
+    fn( _transforms );
+  }
+
+private:
+  TT _anf;
+  std::vector<TT> _khots;
+  std::vector<spectral_operation> _transforms;
+};
+
+} // namespace detail
+
+/*! \brief Exact spectral canonization (with Reed-Muller preprocessor)
+
+  A function can be passed as second argument that is callback called with a
+  vector of spectral operations necessary to transform the input function into
+  the representative.
+
+  The algorithm is based on the paper: M. Soeken, E. Testa, D.M. Miller: A
+  hybrid spectral method for checking Boolean function equivalence, PACRIM 2019.
+
+  \param tt Truth table
+  \param fn Callback to retrieve list of transformations (optional)
+ */
+template<typename TT, typename Callback = decltype( detail::exact_spectral_canonization_null_callback )>
+inline TT hybrid_exact_spectral_canonization( const TT& tt, Callback&& fn = detail::exact_spectral_canonization_null_callback )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  (void)fn;
+
+  std::vector<detail::spectral_operation> transforms;
+
+  detail::anf_spectrum<TT> anf( tt );
+
+  bool is_disjoint = anf.classify();
+  anf.get_transformations( [&]( const auto& t )
+                           { std::copy( t.begin(), t.end(), std::back_inserter( transforms ) ); } );
+
+  if ( !is_disjoint )
+  {
+    const auto miller_repr = exact_spectral_canonization( anf.truth_table(), [&]( const auto& t )
+                                                          { std::copy( t.begin(), t.end(), std::back_inserter( transforms ) ); } );
+    detail::anf_spectrum<TT> anf_post( miller_repr );
+    anf_post.classify();
+    anf_post.get_transformations( [&]( const auto& t )
+                                  { std::copy( t.begin(), t.end(), std::back_inserter( transforms ) ); } );
+    fn( transforms );
+    return anf_post.truth_table();
+  }
+  else
+  {
+    fn( transforms );
+    return anf.truth_table();
+  }
+}
+
+/*! \brief Print spectral representation of a function in RW order
+
+  \param tt Truth table
+  \param os Output stream
+ */
+template<typename TT>
+inline void print_spectrum( const TT& tt, std::ostream& os = std::cout )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  const auto spectrum = detail::spectrum::from_truth_table( tt );
+  spectrum.print( os, detail::get_rw_coeffecient_order( tt.num_vars() ) );
+}
+
+/*! \brief Returns the Rademacher-Walsh spectrum of a truth table
+
+  The order of coefficients is in the same order as input assignments
+  to the truth table.
+
+  \param tt Truth table
+ */
+template<typename TT>
+inline std::vector<int32_t> rademacher_walsh_spectrum( const TT& tt )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  const auto spectrum = detail::spectrum::from_truth_table( tt );
+  return spectrum.coefficients();
+}
+
+/*! \brief Returns the autocorrelation spectrum of a truth table
+
+  The autocorrelation spectrum gives an indication of the imbalance of all first
+  order derivates of a Boolean function.
+
+  The spectral coefficient \f$r(x)\f$ for input \f$x \in \{0,1\}^n\f$ is
+  computed by \f$r(x) = \sum_{y\in\{0,1\}^n}\hat f(y)\hat f(x \oplus y)\f$,
+  where \f$\hat f\f$ is the \f$\{-1,1\}\f$ encoding of the input function
+  \f$f\f$.
+
+  \param tt Truth table for input function \f$f\f$
+ */
+template<typename TT>
+inline std::vector<int32_t> autocorrelation_spectrum( const TT& tt )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  std::vector<int32_t> spectrum( 1, static_cast<uint32_t>( tt.num_bits() ) );
+  spectrum.reserve( tt.num_bits() );
+
+  for ( uint64_t i = 1; i < tt.num_bits(); ++i )
+  {
+    int32_t sum{ 0 };
+    for ( uint64_t j = 0; j < tt.num_bits(); ++j )
+    {
+      sum += ( get_bit( tt, j ) ? -1 : 1 ) * ( get_bit( tt, i ^ j ) ? -1 : 1 );
+    }
+
+    spectrum.push_back( sum );
+  }
+
+  return spectrum;
+}
+
+/*! \brief Returns distribution of absolute spectrum coefficients
+
+  This functions returns a vector with \f$2^{n-1} + 1\f$ nonnegative entries,
+  in which the entry at position \f$i\f$ indicates how many coeffecients in
+  the spectum have absolute value \f$2i\f$.  The compression is possible, since
+  all spectra in this package have positive coefficients.
+
+  \param spectrum Spectrum
+*/
+inline std::vector<uint32_t> spectrum_distribution( const std::vector<int32_t>& spectrum )
+{
+  std::vector<uint32_t> dist( spectrum.size() / 2 + 1 );
+
+  for ( auto c : spectrum )
+  {
+    dist[abs( c ) >> 1]++;
+  }
+
+  return dist;
+}
+
+/*! \brief Returns unique index for a spectral equivalence class
+
+  This functions works for functions with up to 5 inputs.  It uses the
+  distribution of coefficients in the Rademacher Walsh spectrum, and in case
+  of ambiguity also the coeffcienents in the auto-correlation spectrum.  It
+  does not compute the transformation sequences in order to get to the
+  class representative and is therefore faster than canoninization.
+
+  \param tt Truth table
+*/
+template<typename TT>
+inline uint32_t get_spectral_class( const TT& tt )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  assert( tt.num_vars() <= 5 );
+
+  const auto rwd = spectrum_distribution( rademacher_walsh_spectrum( tt ) );
+
+  switch ( tt.num_vars() )
+  {
+  case 0u:
+  case 1u:
+    return 0;
+  case 2u:
+    return rwd[2] ? 0 : 1;
+    break;
+  case 3u:
+  {
+    if ( rwd[4] )
+      return 0;
+    else if ( rwd[3] )
+      return 1;
+    else if ( rwd[2] )
+      return 2;
+  }
+  case 4u:
+  {
+    if ( rwd[8] )
+      return 0;
+    else if ( rwd[7] )
+      return 1;
+    else if ( rwd[6] )
+      return 2;
+    else if ( rwd[5] )
+      return 3;
+    else if ( rwd[4] )
+      return rwd[4] == 4 ? 4 : 5;
+    else if ( rwd[3] )
+      return 6;
+    else if ( rwd[2] )
+      return 7;
+  }
+  break;
+
+  case 5u:
+  {
+    if ( rwd[16] )
+      return 0;
+    else if ( rwd[15] )
+      return 1;
+    else if ( rwd[14] )
+      return 2;
+    else if ( rwd[13] )
+      return 3;
+    else if ( rwd[12] )
+      return rwd[4] == 7 ? 4 : 5;
+    else if ( rwd[11] )
+      return rwd[5] == 1 ? 6 : 7;
+    else if ( rwd[10] )
+    {
+      switch ( rwd[2] )
+      {
+      case 30:
+        return 8;
+      case 15:
+        return 9;
+      case 14:
+        return 10;
+      default:
+        return 11;
+      }
+    }
+    else if ( rwd[9] )
+    {
+      switch ( rwd[3] )
+      {
+      case 15:
+        return 12;
+      case 12:
+        return 13;
+      case 9:
+        return 14;
+      case 6:
+        return 15;
+      default:
+        return 16;
+      }
+    }
+    else if ( rwd[8] )
+    {
+      switch ( rwd[0] )
+      {
+      case 28:
+        return 17;
+      case 19:
+        return 18;
+      case 22:
+        return 19;
+      case 7:
+        return 20;
+      case 9:
+        return 21;
+      case 10:
+        return 22;
+      case 11:
+        return 23;
+      default:
+        return 24;
+      }
+    }
+    else if ( rwd[7] )
+    {
+      switch ( rwd[1] )
+      {
+      case 15:
+      {
+        const auto acd = spectrum_distribution( autocorrelation_spectrum( tt ) );
+        return acd[2] == 22 ? 25 : 26;
+      }
+      break;
+      case 18:
+        return 27;
+      case 19:
+        return 28;
+      case 21:
+        return 29;
+      default:
+        return 30;
+      }
+    }
+    else if ( rwd[6] )
+    {
+      switch ( rwd[2] )
+      {
+      case 28:
+      {
+        const auto acd = spectrum_distribution( autocorrelation_spectrum( tt ) );
+        return acd[0] == 12 ? 31 : 32;
+      }
+      break;
+      case 15:
+        return 33;
+      case 14:
+      {
+        const auto acd = spectrum_distribution( autocorrelation_spectrum( tt ) );
+        return acd[0] == 15 ? 34 : 35;
+      }
+      break;
+      case 13:
+        return 36;
+      case 12:
+      {
+        const auto acd = spectrum_distribution( autocorrelation_spectrum( tt ) );
+        return acd[0] == 18 ? 37 : 38;
+      }
+      break;
+      default:
+        return 39;
+      }
+    }
+    else if ( rwd[5] )
+    {
+      switch ( rwd[3] )
+      {
+      case 16:
+        return 40;
+      default:
+      {
+        const auto acd = spectrum_distribution( autocorrelation_spectrum( tt ) );
+        switch ( acd[2] )
+        {
+        case 25:
+          return 41;
+        case 27:
+          return 42;
+        default:
+          return 43;
+        }
+      }
+      break;
+      }
+    }
+    else if ( rwd[4] )
+    {
+      switch ( rwd[0] )
+      {
+      case 16:
+      {
+        const auto acd = spectrum_distribution( autocorrelation_spectrum( tt ) );
+        switch ( acd[0] )
+        {
+        case 30:
+          return 44;
+        case 15:
+          return 45;
+        default:
+          return 46;
+        }
+      }
+      break;
+      default:
+        return 47;
+      }
+    }
+  }
+  break;
+  }
+
+  return 48;
+}
+
+namespace detail
+{
+static std::vector<uint64_t> spectral_repr[] = {
+    { 0x0 },
+    { 0x0 },
+    { 0x0, 0x8 },
+    { 0x00, 0x80, 0x88 },
+    { 0x0000, 0x8000, 0x8080, 0x0888, 0x8888, 0x2a80, 0xf888, 0x7888 },
+    { 0x00000000, 0x80000000, 0x80008000, 0x00808080, 0x80808080, 0x08888000, 0xaa2a2a80, 0x88080808, 0x2888a000, 0xf7788000, 0xa8202020, 0x08880888, 0xbd686868, 0xaa808080, 0x7e686868, 0x2208a208, 0x08888888, 0x88888888, 0xea404040, 0x2a802a80, 0x73d28c88, 0xea808080, 0xa28280a0, 0x13284c88, 0xa2220888, 0xaae6da80, 0x58d87888, 0x8c88ac28, 0x8880f880, 0x9ee8e888, 0x4268c268, 0x16704c80, 0x78888888, 0x4966bac0, 0x372840a0, 0x5208d288, 0x7ca00428, 0xf8880888, 0x2ec0ae40, 0xf888f888, 0x58362ec0, 0x0eb8f6c0, 0x567cea40, 0xf8887888, 0x78887888, 0xe72890a0, 0x268cea40, 0x6248eac0 } };
+}
+
+/*! \brief Returns spectral representative using lookup
+ *
+ * This function returns the spectral representative for functions with up to 5
+ * variables, but does not give the possibility to obtain the transformation
+ * sequence to obtain the function from the representative.
+ *
+ * \brief func Truth table for function with at most 5 variables.
+ */
+template<class TT>
+TT spectral_representative( const TT& func )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  auto r = func.construct();
+  const auto index = get_spectral_class( func );
+  const auto word = detail::spectral_repr[func.num_vars()][index];
+  kitty::create_from_words( r, &word, &word + 1 );
+  return r;
+}
+
+} /* namespace kitty */
\ No newline at end of file
diff --git a/lib/kitty/kitty/spp.hpp b/lib/kitty/kitty/spp.hpp
new file mode 100644
index 0000000..42ecf5c
--- /dev/null
+++ b/lib/kitty/kitty/spp.hpp
@@ -0,0 +1,156 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file spp.hpp
+  \brief Implements methods to compute SPP representations
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <utility>
+#include <vector>
+
+#include "cube.hpp"
+#include "traits.hpp"
+
+namespace kitty
+{
+
+/*! \brief Merges products in an ESOP into pseudo products
+
+  Given, e.g., the two cubes `abc` and `abd`, this algorithm will combine them
+  into a single cube `ab(c+d)`.  The term `(c+d)` is stored as a literal in the
+  first argument of the result pair, starting free indexes after `num_vars`.
+  Which literals are used is stored in the second argument of the result pair,
+  as bitpattern over the original inputs.
+
+  \param esop ESOP form
+  \param num_vars Number of variables in ESOP form
+*/
+inline std::pair<std::vector<cube>, std::vector<uint64_t>> simple_spp( const std::vector<cube>& esop, uint32_t num_vars )
+{
+  auto next_free = num_vars;
+  std::vector<uint64_t> sums;
+  auto e = esop.size();
+  auto copy = esop;
+  const auto var_mask = ( 1u << num_vars ) - 1;
+  for ( auto i = 0u; i < e; ++i )
+  {
+    auto& c = copy[i];
+    if ( ( c._mask & 0b1111 ) != c._mask )
+    {
+      continue;
+    }
+
+    const auto it = std::find_if( copy.begin() + i, copy.begin() + e,
+                                  [&]( auto const& c2 )
+                                  {
+                                    bool cnd1 = ( c2._mask & var_mask ) == c2._mask;
+                                    const auto same_mask = c._mask & c2._mask;
+                                    bool cnd2 = ( c._bits & same_mask ) == ( c2._bits & same_mask );
+                                    bool cnd3 = __builtin_popcount( c._mask & ~c2._mask ) == 1;
+                                    bool cnd4 = __builtin_popcount( ~c._mask & c2._mask ) == 1;
+
+                                    return cnd1 && cnd2 && cnd3 && cnd4;
+                                  } );
+    if ( it != copy.begin() + e )
+    {
+      auto to_delete = c._mask ^ it->_mask;
+      c._mask &= ~to_delete;
+      c.add_literal( next_free++, __builtin_popcount( ( c._bits | it->_bits ) & to_delete ) % 2 == 0 );
+      c._bits &= ~to_delete;
+      sums.push_back( to_delete );
+      --e;
+      std::swap( *it, copy[e] );
+    }
+  }
+
+  copy.resize( e );
+  return { copy, sums };
+}
+
+/*! \brief Creates truth table from SPP
+
+  This method is helpful to check which truth table is computed by an SPP form.
+*/
+template<typename TT>
+void create_from_spp( TT& tt, const std::vector<cube>& cubes, const std::vector<uint64_t>& sums )
+{
+  static_assert( is_complete_truth_table<TT>::value, "Can only be applied on complete truth tables." );
+
+  clear( tt );
+
+  for ( auto cube : cubes )
+  {
+    auto product = ~tt.construct(); /* const1 of same size */
+
+    auto bits = cube._bits;
+    auto mask = cube._mask;
+
+    for ( auto i = 0u; i < tt.num_vars(); ++i )
+    {
+      if ( mask & 1 )
+      {
+        auto var = tt.construct();
+        create_nth_var( var, i, !( bits & 1 ) );
+        product &= var;
+      }
+      bits >>= 1;
+      mask >>= 1;
+    }
+
+    for ( auto i = 0u; i < sums.size(); ++i )
+    {
+      if ( mask & 1 )
+      {
+        auto ssum = tt.construct();
+        for ( auto j = 0u; j < tt.num_vars(); ++j )
+        {
+          if ( ( sums[i] >> j ) & 1 )
+          {
+            auto var = tt.construct();
+            create_nth_var( var, j );
+            ssum ^= var;
+          }
+        }
+        if ( !( bits & 1 ) )
+        {
+          ssum = ~ssum;
+        }
+        product &= ssum;
+      }
+      bits >>= 1;
+      mask >>= 1;
+    }
+
+    tt ^= product;
+  }
+}
+
+} // namespace kitty
\ No newline at end of file
diff --git a/lib/kitty/kitty/static_truth_table.hpp b/lib/kitty/kitty/static_truth_table.hpp
new file mode 100644
index 0000000..90efcb5
--- /dev/null
+++ b/lib/kitty/kitty/static_truth_table.hpp
@@ -0,0 +1,290 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file static_truth_table.hpp
+  \brief Implements static_truth_table
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+
+#include "detail/constants.hpp"
+#include "traits.hpp"
+
+namespace kitty
+{
+
+/*! Truth table in which number of variables is known at compile time.
+
+  We dispatch on the Boolean template parameter to distinguish between
+  a small truth table (up to 6 variables) and a large truth table
+  (more than 6 variables).  A small truth table fits into a single
+  block and therefore dedicated optimizations are possible.
+ */
+template<uint32_t NumVars, bool = ( NumVars <= 6 )>
+struct static_truth_table;
+
+/*! Truth table (for up to 6 variables) in which number of variables is known at compile time.
+ */
+template<uint32_t NumVars>
+struct static_truth_table<NumVars, true>
+{
+  /*! \cond PRIVATE */
+  enum
+  {
+    NumBits = uint64_t( 1 ) << NumVars
+  };
+  /*! \endcond */
+
+  /*! Constructs a new static truth table instance with the same number of variables. */
+  inline static_truth_table<NumVars> construct() const
+  {
+    return static_truth_table<NumVars>();
+  }
+
+  /*! Returns number of variables.
+   */
+  inline auto num_vars() const noexcept { return NumVars; }
+
+  /*! Returns number of blocks.
+   */
+  inline auto num_blocks() const noexcept { return 1u; }
+
+  /*! Returns number of bits.
+   */
+  inline auto num_bits() const noexcept { return NumBits; }
+
+  /*! \brief Begin iterator to bits.
+   */
+  inline auto begin() noexcept { return &_bits; }
+
+  /*! \brief End iterator to bits.
+   */
+  inline auto end() noexcept { return ( &_bits ) + 1; }
+
+  /*! \brief Begin iterator to bits.
+   */
+  inline auto begin() const noexcept { return &_bits; }
+
+  /*! \brief End iterator to bits.
+   */
+  inline auto end() const noexcept { return ( &_bits ) + 1; }
+
+  /*! \brief Reverse begin iterator to bits.
+   */
+  inline auto rbegin() noexcept { return &_bits; }
+
+  /*! \brief Reverse end iterator to bits.
+   */
+  inline auto rend() noexcept { return ( &_bits ) + 1; }
+
+  /*! \brief Constant begin iterator to bits.
+   */
+  inline auto cbegin() const noexcept { return &_bits; }
+
+  /*! \brief Constant end iterator to bits.
+   */
+  inline auto cend() const noexcept { return ( &_bits ) + 1; }
+
+  /*! \brief Constant reverse begin iterator to bits.
+   */
+  inline auto crbegin() const noexcept { return &_bits; }
+
+  /*! \brief Constant everse end iterator to bits.
+   */
+  inline auto crend() const noexcept { return ( &_bits ) + 1; }
+
+  /*! \brief Assign other truth table if number of variables match.
+
+    This replaces the current truth table with another truth table, if `other`
+    has the same number of variables.  Otherwise, the truth table is not
+    changed.
+
+    \param other Other truth table
+  */
+  template<class TT, typename = std::enable_if_t<is_truth_table<TT>::value && is_complete_truth_table<TT>::value>>
+  static_truth_table<NumVars>& operator=( const TT& other )
+  {
+    if ( other.num_vars() == num_vars() )
+    {
+      std::copy( other.begin(), other.end(), begin() );
+    }
+
+    return *this;
+  }
+
+  /*! Masks the number of valid truth table bits.
+
+    If the truth table has less than 6 variables, it may not use all
+    the bits.  This operation makes sure to zero out all non-valid
+    bits.
+  */
+  inline void mask_bits() noexcept { _bits &= detail::masks[NumVars]; }
+
+  /*! \cond PRIVATE */
+public: /* fields */
+  uint64_t _bits = 0;
+  /*! \endcond */
+};
+
+/*! Truth table (more than 6 variables) in which number of variables is known at compile time.
+ */
+template<uint32_t NumVars>
+struct static_truth_table<NumVars, false>
+{
+  /*! \cond PRIVATE */
+  enum
+  {
+    NumBlocks = ( NumVars <= 6 ) ? 1u : ( 1u << ( NumVars - 6 ) )
+  };
+
+  enum
+  {
+    NumBits = uint64_t( 1 ) << NumVars
+  };
+  /*! \endcond */
+
+  /*! Standard constructor.
+
+    The number of variables provided to the truth table must be known
+    at runtime.  The number of blocks will be computed as a compile
+    time constant.
+  */
+  static_truth_table()
+  {
+    _bits.fill( 0 );
+  }
+
+  /*! Constructs a new static truth table instance with the same number of variables. */
+  inline static_truth_table<NumVars> construct() const
+  {
+    return static_truth_table<NumVars>();
+  }
+
+  /*! Returns number of variables.
+   */
+  inline auto num_vars() const noexcept { return NumVars; }
+
+  /*! Returns number of blocks.
+   */
+  inline auto num_blocks() const noexcept { return NumBlocks; }
+
+  /*! Returns number of bits.
+   */
+  inline auto num_bits() const noexcept { return NumBits; }
+
+  /*! \brief Begin iterator to bits.
+   */
+  inline auto begin() noexcept { return _bits.begin(); }
+
+  /*! \brief End iterator to bits.
+   */
+  inline auto end() noexcept { return _bits.end(); }
+
+  /*! \brief Begin iterator to bits.
+   */
+  inline auto begin() const noexcept { return _bits.begin(); }
+
+  /*! \brief End iterator to bits.
+   */
+  inline auto end() const noexcept { return _bits.end(); }
+
+  /*! \brief Reverse begin iterator to bits.
+   */
+  inline auto rbegin() noexcept { return _bits.rbegin(); }
+
+  /*! \brief Reverse end iterator to bits.
+   */
+  inline auto rend() noexcept { return _bits.rend(); }
+
+  /*! \brief Constant begin iterator to bits.
+   */
+  inline auto cbegin() const noexcept { return _bits.cbegin(); }
+
+  /*! \brief Constant end iterator to bits.
+   */
+  inline auto cend() const noexcept { return _bits.cend(); }
+
+  /*! \brief Constant reverse begin iterator to bits.
+   */
+  inline auto crbegin() const noexcept { return _bits.crbegin(); }
+
+  /*! \brief Constant teverse end iterator to bits.
+   */
+  inline auto crend() const noexcept { return _bits.crend(); }
+
+  /*! \brief Assign other truth table if number of variables match.
+
+    This replaces the current truth table with another truth table, if `other`
+    has the same number of variables.  Otherwise, the truth table is not
+    changed.
+
+    \param other Other truth table
+  */
+  template<class TT, typename = std::enable_if_t<is_truth_table<TT>::value>>
+  static_truth_table<NumVars>& operator=( const TT& other )
+  {
+    if ( other.num_bits() == num_bits() )
+    {
+      std::copy( other.begin(), other.end(), begin() );
+    }
+
+    return *this;
+  }
+
+  /*! Masks the number of valid truth table bits.
+
+    We know that we will have at least 7 variables in this data
+    structure.
+  */
+  inline void mask_bits() noexcept {}
+
+  /*! \cond PRIVATE */
+public: /* fields */
+  std::array<uint64_t, NumBlocks> _bits;
+  /*! \endcond */
+};
+
+template<uint32_t NumVars>
+struct is_truth_table<kitty::static_truth_table<NumVars>> : std::true_type
+{
+};
+
+template<uint32_t NumVars>
+struct is_complete_truth_table<kitty::static_truth_table<NumVars>> : std::true_type
+{
+};
+
+template<uint32_t NumVars>
+struct is_completely_specified_truth_table<kitty::static_truth_table<NumVars>> : std::true_type
+{
+};
+
+} // namespace kitty
\ No newline at end of file
diff --git a/lib/kitty/kitty/ternary_truth_table.hpp b/lib/kitty/kitty/ternary_truth_table.hpp
new file mode 100644
index 0000000..165c2a5
--- /dev/null
+++ b/lib/kitty/kitty/ternary_truth_table.hpp
@@ -0,0 +1,262 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file ternary_truth_table.hpp
+  \brief Implements ternary_truth_table
+
+  \author Siang-Yun Lee
+  \author Gianluca Radi
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <type_traits>
+#include <vector>
+#include <optional>
+
+#include "detail/constants.hpp"
+#include "traits.hpp"
+#include "partial_truth_table.hpp"
+
+namespace kitty
+{
+
+template<class TT>
+struct ternary_truth_table
+{
+  /*! \brief Standard constructor.
+
+    Initialize the truth table using the constructor of the inner
+    truth table type.
+
+    \param n Number of variables or number of bits (when `TT = partial_truth_table`)
+  */
+  explicit ternary_truth_table( uint32_t n )
+      : _care( n ), _bits( n )
+  {
+  }
+
+  /*! \brief Empty constructor.
+
+    Creates an empty truth table by calling the empty constructor
+    of the inner truth table type.
+   */
+  ternary_truth_table() : _care(), _bits() {}
+
+  /*! \brief Construct from bits and care.
+
+    When `care` bit is 0, `bits` bit must be 0, meaning a don't care bit.
+
+    \param bits Bits truth table.
+    \param care Care truth table.
+  */
+  ternary_truth_table( TT const& bits, TT const& care )
+      : _bits( bits ), _care( care )
+  {
+  }
+
+  /*! \brief Construct from a binary truth table.
+
+    Initialize the truth table as equivalent to a binary truth table.
+    (All bits are cared.)
+
+    \param binary Binary truth table.
+  */
+  ternary_truth_table( TT const& binary )
+      : _care( ~( binary.construct() ) ), _bits( binary )
+  {
+  }
+
+  /*! Constructs a new ternary_truth_table instance of the same size. */
+  inline ternary_truth_table<TT> construct() const
+  {
+    if constexpr ( std::is_same_v<TT, partial_truth_table> )
+      return ternary_truth_table<TT>( _bits.num_bits() );
+    else
+      return ternary_truth_table<TT>( _bits.num_vars() );
+  }
+
+  /*! Returns number of variables.
+   */
+  template<typename = std::enable_if_t<is_complete_truth_table<TT>::value>>
+  auto num_vars() const noexcept { return _bits.num_vars(); }
+
+  /*! Returns number of blocks.
+   */
+  inline auto num_blocks() const noexcept { return _bits.num_blocks(); }
+
+  /*! Returns number of bits.
+   */
+  inline auto num_bits() const noexcept { return _bits.num_bits(); }
+
+  /*! \brief Begin iterator to bits.
+   */
+  inline auto begin_bits() noexcept { return _bits.begin(); }
+
+  /*! \brief End iterator to bits.
+   */
+  inline auto end_bits() noexcept { return _bits.end(); }
+
+  /*! \brief Begin iterator to bits.
+   */
+  inline auto begin_bits() const noexcept { return _bits.begin(); }
+
+  /*! \brief End iterator to bits.
+   */
+  inline auto end_bits() const noexcept { return _bits.end(); }
+
+  /*! \brief Reverse begin iterator to bits.
+   */
+  inline auto rbegin_bits() noexcept { return _bits.rbegin(); }
+
+  /*! \brief Reverse end iterator to bits.
+   */
+  inline auto rend_bits() noexcept { return _bits.rend(); }
+
+  /*! \brief Constant begin iterator to bits.
+   */
+  inline auto cbegin_bits() const noexcept { return _bits.cbegin(); }
+
+  /*! \brief Constant end iterator to bits.
+   */
+  inline auto cend_bits() const noexcept { return _bits.cend(); }
+
+  /*! \brief Constant reverse begin iterator to bits.
+   */
+  inline auto crbegin_bits() const noexcept { return _bits.crbegin(); }
+
+  /*! \brief Constant teverse end iterator to bits.
+   */
+  inline auto crend_bits() const noexcept { return _bits.crend(); }
+
+  /*! \brief Begin iterator to care.
+   */
+  inline auto begin_care() noexcept { return _care.begin(); }
+
+  /*! \brief End iterator to care.
+   */
+  inline auto end_care() noexcept { return _care.end(); }
+
+  /*! \brief Begin iterator to care.
+   */
+  inline auto begin_care() const noexcept { return _care.begin(); }
+
+  /*! \brief End iterator to care.
+   */
+  inline auto end_care() const noexcept { return _care.end(); }
+
+  /*! \brief Reverse begin iterator to care.
+   */
+  inline auto rbegin_care() noexcept { return _care.rbegin(); }
+
+  /*! \brief Reverse end iterator to care.
+   */
+  inline auto rend_care() noexcept { return _care.rend(); }
+
+  /*! \brief Constant begin iterator to care.
+   */
+  inline auto cbegin_care() const noexcept { return _care.cbegin(); }
+
+  /*! \brief Constant end iterator to care.
+   */
+  inline auto cend_care() const noexcept { return _care.cend(); }
+
+  /*! \brief Constant reverse begin iterator to care.
+   */
+  inline auto crbegin_care() const noexcept { return _care.crbegin(); }
+
+  /*! \brief Constant teverse end iterator to care.
+   */
+  inline auto crend_care() const noexcept { return _care.crend(); }
+
+  /*! \brief Assign other truth table.
+
+    This replaces the current truth table with another truth table.
+    The other truth table must also be ternary, and the inner type of
+    the other truth table must be assignable to the inner type of this
+    truth table.
+
+    \param other Other truth table
+  */
+  template<class TT2>
+  ternary_truth_table<TT>& operator=( const ternary_truth_table<TT2>& other )
+  {
+    _bits = other._bits;
+    _care = other._care;
+
+    return *this;
+  }
+
+  /*! \brief Assigned by a binary truth table.
+
+    Replaces with a truth table equivalent to a binary truth table.
+    (All bits are cared.)
+
+    \param other Binary truth table.
+  */
+  template<class TT2>
+  ternary_truth_table<TT>& operator=( TT const& other )
+  {
+    _bits = other;
+    _care = ~( other.construct() );
+
+    return *this;
+  }
+
+  /*! \brief Masks valid truth table bits.
+
+  This operation makes sure to zero out all unused bits.
+  */
+  inline void mask_bits() noexcept
+  {
+    _care.mask_bits();
+    _bits.mask_bits();
+  }
+
+  /*! \cond PRIVATE */
+public: /* fields */
+  TT _care;
+  TT _bits;
+  /*! \endcond */
+};
+
+template<class TT>
+struct is_truth_table<kitty::ternary_truth_table<TT>> : is_truth_table<TT>
+{
+};
+
+template<class TT>
+struct is_complete_truth_table<kitty::ternary_truth_table<TT>> : is_complete_truth_table<TT>
+{
+};
+
+template<class TT>
+struct is_completely_specified_truth_table<kitty::ternary_truth_table<TT>> : std::false_type
+{
+};
+
+} // namespace kitty
diff --git a/lib/kitty/kitty/traits.hpp b/lib/kitty/kitty/traits.hpp
new file mode 100644
index 0000000..466f7de
--- /dev/null
+++ b/lib/kitty/kitty/traits.hpp
@@ -0,0 +1,55 @@
+/* kitty: C++ truth table library
+ * Copyright (C) 2017-2022  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file traits.hpp
+  \brief Type traits for truth tables
+
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <type_traits>
+
+namespace kitty
+{
+
+template<class TT>
+struct is_truth_table : std::false_type
+{
+};
+
+template<class TT>
+struct is_complete_truth_table : std::false_type
+{
+};
+
+template<class TT>
+struct is_completely_specified_truth_table : std::false_type
+{
+};
+
+} // namespace kitty
\ No newline at end of file
diff --git a/lib/lorina/lorina/aiger.hpp b/lib/lorina/lorina/aiger.hpp
new file mode 100644
index 0000000..c0384c1
--- /dev/null
+++ b/lib/lorina/lorina/aiger.hpp
@@ -0,0 +1,922 @@
+/* lorina: C++ parsing library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file aiger.hpp
+  \brief Implements Aiger parser
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "common.hpp"
+#include "diagnostics.hpp"
+#include "detail/utils.hpp"
+#include <fstream>
+#include <iostream>
+#include <regex>
+
+namespace lorina
+{
+
+/*! \brief A reader visitor for the binary AIGER format.
+ *
+ * Callbacks for the AIGER format.
+ */
+class aiger_reader
+{
+public:
+  /*! Latch input values */
+  enum latch_init_value
+  {
+    ZERO = 0 /*!< Initialized with 0 */
+  , ONE /*!< Initialized with 1 */
+  , NONDETERMINISTIC /*!< Not initialized (non-deterministic value) */
+  };
+
+public:
+  /*! \brief Callback method for parsed header.
+   *
+   * \param m Maximum variable index
+   * \param i Number of inputs
+   * \param l Number of latches
+   * \param o Number of outputs
+   * \param a Number of AND gates
+   */
+  virtual void on_header( uint64_t m, uint64_t i, uint64_t l, uint64_t o, uint64_t a ) const
+  {
+    (void)m;
+    (void)i;
+    (void)l;
+    (void)o;
+    (void)a;
+  }
+
+  /*! \brief Callback method for parsed header.
+   *
+   * \param m Maximum variable index
+   * \param i Number of inputs
+   * \param l Number of latches
+   * \param o Number of outputs
+   * \param a Number of AND gates
+   * \param b Number of bad states properties
+   * \param c Number of invariant constraints
+   * \param j Number of justice properties
+   * \param f Number of fairness constraints
+   */
+  virtual void on_header( uint64_t m, uint64_t i, uint64_t l, uint64_t o, uint64_t a,
+                          uint64_t b, uint64_t c, uint64_t j, uint64_t f ) const
+  {
+    on_header( m, i, l, o, a );
+    (void)b;
+    (void)c;
+    (void)j;
+    (void)f;
+  }
+
+  /*! \brief Callback method for parsed input.
+   *
+   * \param pos Position in input list
+   * \param lit Assigned literal
+   */
+  virtual void on_input( uint32_t pos, uint32_t lit ) const
+  {
+    (void)pos;
+    (void)lit;
+  }
+
+  /*! \brief Callback method for parsed output.
+   *
+   * \param pos Position in output list
+   * \param lit Assigned literal
+   */
+  virtual void on_output( uint32_t pos, uint32_t lit ) const
+  {
+    (void)pos;
+    (void)lit;
+  }
+
+  /*! \brief Callback method for parsed latch.
+   *
+   * \param index Index of the latch
+   * \param next Assigned (next) literal
+   * \param reset Initial value of the latch
+   */
+  virtual void on_latch( uint32_t index, uint32_t next, latch_init_value reset ) const
+  {
+    (void)index;
+    (void)next;
+    (void)reset;
+  }
+
+  /*! \brief Callback method for parsed AND gate.
+   *
+   * \param index Index of the AND gate
+   * \param left_lit Assigned left literal
+   * \param right_lit Assigned right literal
+   */
+  virtual void on_and( uint32_t index, uint32_t left_lit, uint32_t right_lit ) const
+  {
+    (void)index;
+    (void)left_lit;
+    (void)right_lit;
+  }
+
+  /*! \brief Callback method for parsed bad state property.
+   *
+   * \param index Position in the list of bad state property
+   * \param lit Assigned literal
+   */
+  virtual void on_bad_state( uint32_t pos, uint32_t lit ) const
+  {
+    (void)pos;
+    (void)lit;
+  }
+
+  /*! \brief Callback method for parsed constraint.
+   *
+   * \param index Position in the list of constraint
+   * \param lit Assigned literal
+   */
+  virtual void on_constraint( uint32_t pos, uint32_t lit ) const
+  {
+    (void)pos;
+    (void)lit;
+  }
+
+  /*! \brief Callback method for parsed fairness constraints.
+   *
+   * \param index Position in the list of fairness constraint
+   * \param lit Assigned literal
+   */
+  virtual void on_fairness( uint32_t pos, uint32_t lit ) const
+  {
+    (void)pos;
+    (void)lit;
+  }
+
+  /*! \brief Callback method for parsed header of justice property.
+   *
+   * \param index Position in the list of the justice property
+   * \param size Number of assigned literals
+   */
+  virtual void on_justice_header( uint32_t pos, uint64_t size ) const
+  {
+    (void)pos;
+    (void)size;
+  }
+
+  /*! \brief Callback method for parsed justice property.
+   *
+   * \param index Position in the list of the justice property
+   * \param lits Assigned literals
+   */
+  virtual void on_justice( uint32_t pos, const std::vector<uint32_t>& lits ) const
+  {
+    (void)pos;
+    (void)lits;
+  }
+
+  /*! \brief Callback method for parsed input name.
+   *
+   * \param pos Position in input list
+   * \param name Input name
+   */
+  virtual void on_input_name( uint32_t pos, const std::string& name ) const
+  {
+    (void)pos;
+    (void)name;
+  }
+
+  /*! \brief Callback method for parsed latch name.
+   *
+   * \param pos Position in latch list
+   * \param name Latch name
+   */
+  virtual void on_latch_name( uint32_t pos, const std::string& name ) const
+  {
+    (void)pos;
+    (void)name;
+  }
+
+  /*! \brief Callback method for parsed output name.
+   *
+   * \param pos Position in output list
+   * \param name Output name
+   */
+  virtual void on_output_name( uint32_t pos, const std::string& name ) const
+  {
+    (void)pos;
+    (void)name;
+  }
+
+  /*! \brief Callback method for a parsed name of a bad state property.
+   *
+   * \param pos Position in list of bad state property
+   * \param name Name of the bad state property
+   */
+  virtual void on_bad_state_name( uint32_t pos, const std::string& name ) const
+  {
+    (void)pos;
+    (void)name;
+  }
+
+  /*! \brief Callback method for a parsed name of an invariant constraint.
+   *
+   * \param pos Position in constraint list
+   * \param name Constraint name
+   */
+  virtual void on_constraint_name( uint32_t pos, const std::string& name ) const
+  {
+    (void)pos;
+    (void)name;
+  }
+
+  /*! \brief Callback method for a parsed name of a justice property.
+   *
+   * \param pos Position in the list of justice property
+   * \param name Name of the fairness constraint
+   */
+  virtual void on_justice_name( uint32_t pos, const std::string& name ) const
+  {
+    (void)pos;
+    (void)name;
+  }
+
+  /*! \brief Callback method for a parsed name of a fairness constraint.
+   *
+   * \param pos Position in list of fairness constraint
+   * \param name Name of the fairness constraint
+   */
+  virtual void on_fairness_name( uint32_t pos, const std::string& name ) const
+  {
+    (void)pos;
+    (void)name;
+  }
+
+  /*! \brief Callback method for parsed comment.
+   *
+   * \param comment Comment
+   */
+  virtual void on_comment( const std::string& comment ) const
+  {
+    (void)comment;
+  }
+}; /* aiger_reader */
+
+/*! \brief An AIGER reader for prettyprinting ASCII AIGER.
+ *
+ * Callbacks for prettyprinting of ASCII AIGER.
+ *
+ */
+class ascii_aiger_pretty_printer : public aiger_reader
+{
+public:
+  /*! \brief Constructor of the ASCII AIGER pretty printer.
+   *
+   * \param os Output stream
+   */
+  ascii_aiger_pretty_printer( std::ostream& os = std::cout )
+      : _os( os )
+  {
+  }
+
+  void on_header( uint64_t m, uint64_t i, uint64_t l, uint64_t o, uint64_t a,
+                  uint64_t b, uint64_t c, uint64_t j, uint64_t f ) const override
+  {
+    _os << fmt::format( "aag {0} {1} {2} {3} {4} {5} {6} {7} {8}",
+                        m, i, l, o, a, b, c, j, f )
+        << std::endl;
+  }
+
+  void on_input( uint32_t index, uint32_t lit ) const override
+  {
+    (void)index;
+    _os << lit << std::endl;
+  }
+
+  void on_output( uint32_t index, uint32_t lit ) const override
+  {
+    (void)index;
+    _os << lit << std::endl;
+  }
+
+  void on_latch( uint32_t index, uint32_t next, latch_init_value init_value ) const override
+  {
+    _os << ( 2u * index ) << ' ' << next;
+    switch( init_value )
+    {
+    case 0:
+      _os << '0';
+      break;
+    case 1:
+      _os << '1';
+      break;
+    default:
+      break;
+    }
+    _os << std::endl;
+  }
+
+  void on_and( uint32_t index, uint32_t left_lit, uint32_t right_lit ) const override
+  {
+    _os << ( 2u * index ) << ' ' << left_lit << ' ' << right_lit << std::endl;
+  }
+
+  void on_bad_state( uint32_t index, uint32_t lit ) const override
+  {
+    (void)index;
+    _os << lit << std::endl;
+  }
+
+  void on_constraint( uint32_t index, uint32_t lit ) const override
+  {
+    (void)index;
+    _os << lit << std::endl;
+  }
+
+  void on_justice_header( uint32_t index, uint64_t size ) const override
+  {
+    (void)index;
+    _os << size << std::endl;
+  }
+
+  void on_justice( uint32_t index, const std::vector<uint32_t>& lits ) const override
+  {
+    (void)index;
+    for ( const auto& l : lits )
+    {
+      _os << l << std::endl;
+    }
+  }
+
+  void on_fairness( uint32_t index, uint32_t lit ) const override
+  {
+    (void)index;
+    _os << lit << std::endl;
+  }
+
+  void on_input_name( uint32_t pos, const std::string& name ) const override
+  {
+    _os << "i" << pos << ' ' << name << std::endl;
+  }
+
+  void on_latch_name( uint32_t pos, const std::string& name ) const override
+  {
+    _os << "l" << pos << ' ' << name << std::endl;
+  }
+
+  void on_output_name( uint32_t pos, const std::string& name ) const override
+  {
+    _os << "o" << pos << ' ' << name << std::endl;
+  }
+
+  void on_bad_state_name( uint32_t pos, const std::string& name ) const override
+  {
+    _os << "b" << pos << ' ' << name << std::endl;
+  }
+
+  void on_constraint_name( uint32_t pos, const std::string& name ) const override
+  {
+    _os << "c" << pos << ' ' << name << std::endl;
+  }
+
+  void on_justice_name( uint32_t pos, const std::string& name ) const override
+  {
+    _os << "j" << pos << ' ' << name << std::endl;
+  }
+
+  void on_fairness_name( uint32_t pos, const std::string& name ) const override
+  {
+    _os << "f" << pos << ' ' << name << std::endl;
+  }
+
+  void on_comment( const std::string& comment ) const override
+  {
+    _os << "c" << std::endl
+        << comment << std::endl;
+  }
+
+  std::ostream& _os; /*!< Output stream */
+}; /* ascii_aiger_pretty_printer */
+
+namespace aig_regex
+{
+static std::regex header( R"(^aig (\d+) (\d+) (\d+) (\d+) (\d+)( \d+)?( \d+)?( \d+)?( \d+)?$)" );
+static std::regex ascii_header( R"(^aag (\d+) (\d+) (\d+) (\d+) (\d+)( \d+)?( \d+)?( \d+)?( \d+)?$)" );
+static std::regex input( R"(^i(\d+) (.*)$)" );
+static std::regex latch( R"(^l(\d+) (.*)$)" );
+static std::regex output( R"(^o(\d+) (.*)$)" );
+static std::regex bad_state( R"(^b(\d+) (.*)$)" );
+static std::regex constraint( R"(^c(\d+) (.*)$)" );
+static std::regex justice( R"(^j(\d+) (.*)$)" );
+static std::regex fairness( R"(^f(\d+) (.*)$)" );
+} // namespace aig_regex
+
+/*! \brief Reader function for ASCII AIGER format.
+ *
+ * Reads ASCII AIGER format from a stream and invokes a callback
+ * method for each parsed primitive and each detected parse error.
+ *
+ * \param in Input stream
+ * \param reader An AIGER reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_ascii_aiger( std::istream& in, const aiger_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  return_code result = return_code::success;
+
+  std::smatch m;
+  std::string header_line;
+  detail::getline( in, header_line );
+
+  uint64_t _m, _i, _l, _o, _a, _b, _c, _j, _f;
+
+  /* header */
+  if ( std::regex_search( header_line, m, aig_regex::ascii_header ) )
+  {
+    std::vector<uint64_t> header;
+    for ( const auto& i : m )
+    {
+      if ( i == "" )
+        continue;
+      header.push_back( std::atol( std::string( i ).c_str() ) );
+    }
+
+    assert( header.size() >= 6u );
+    assert( header.size() <= 10u );
+
+    _m = header[1u];
+    _i = header[2u];
+    _l = header[3u];
+    _o = header[4u];
+    _a = header[5u];
+    _b = header.size() > 6 ? header[6u] : 0ul;
+    _c = header.size() > 7 ? header[7u] : 0ul;
+    _j = header.size() > 8 ? header[8u] : 0ul;
+    _f = header.size() > 9 ? header[9u] : 0ul;
+    reader.on_header( _m, _i, _l, _o, _a, _b, _c, _j, _f );
+  }
+  else
+  {
+    if ( diag )
+    {
+      diag->report( diag_id::ERR_AIGER_HEADER ).add_argument( header_line );
+    }
+    return return_code::parse_error;
+  }
+
+  std::string line;
+
+  /* inputs */
+  for ( auto i = 0ul; i < _i; ++i )
+  {
+    detail::getline( in, line );
+    const auto index = std::atol( line.c_str() );
+    reader.on_input( i, index );
+  }
+
+  /* latches */
+  for ( auto i = 0ul; i < _l; ++i )
+  {
+    detail::getline( in, line );
+    const auto tokens = detail::split( line,  " " );
+
+    if ( !(tokens.size() <= 3u) )
+    {
+      if ( diag )
+      {
+        diag->report( diag_id::ERR_AIGER_LATCH_DECLARATION ).add_argument( line );
+      }
+      return return_code::parse_error;
+    }
+
+    const auto index = std::atol( std::string(tokens[0u]).c_str() ) / 2u;
+    const auto next_lit = std::atol( std::string(tokens[1u]).c_str() );
+
+    aiger_reader::latch_init_value init_value = aiger_reader::latch_init_value::NONDETERMINISTIC;
+    if ( tokens.size() == 3u )
+    {
+      if ( tokens[2u] == "0" )
+      {
+        init_value = aiger_reader::latch_init_value::ZERO;
+      }
+      else if ( tokens[1u] == "1" )
+      {
+        init_value = aiger_reader::latch_init_value::ONE;
+      }
+    }
+
+    reader.on_latch( index, next_lit, init_value );
+  }
+
+  /* outputs */
+  for ( auto i = 0ul; i < _o; ++i )
+  {
+    detail::getline( in, line );
+    const auto lit = std::atol( line.c_str() );
+    reader.on_output( i, lit );
+  }
+
+  /* bad state properties */
+  for ( auto i = 0ul; i < _b; ++i )
+  {
+    detail::getline( in, line );
+    const auto lit = std::atol( line.c_str() );
+    reader.on_bad_state( i, lit );
+  }
+
+  /* constraints */
+  for ( auto i = 0ul; i < _c; ++i )
+  {
+    detail::getline( in, line );
+    const auto lit = std::atol( line.c_str() );
+    reader.on_constraint( i, lit );
+  }
+
+  /* justice properties */
+  std::vector<uint64_t> justice_sizes;
+  for ( auto i = 0ul; i < _j; ++i )
+  {
+    detail::getline( in, line );
+    const auto justice_size = std::atol( line.c_str() );
+    justice_sizes.emplace_back( justice_size );
+    reader.on_justice_header( i, justice_size );
+  }
+
+  for ( auto i = 0ul; i < _j; ++i )
+  {
+    std::vector<uint32_t> lits;
+    for ( auto j = 0ul; j < justice_sizes[i]; ++j )
+    {
+      detail::getline( in, line );
+      const auto lit = std::atol( line.c_str() );
+      lits.emplace_back( lit );
+    }
+    reader.on_justice( i, lits );
+  }
+
+  /* fairness */
+  for ( auto i = 0ul; i < _f; ++i )
+  {
+    detail::getline( in, line );
+    const auto lit = std::atol( line.c_str() );
+    reader.on_fairness( i, lit );
+  }
+
+  /* ands */
+  for ( auto i = 0ul; i < _a; ++i )
+  {
+    detail::getline( in, line );
+    const auto tokens = detail::split( line, " " );
+
+    if ( !(tokens.size() == 3u) )
+    {
+      if ( diag )
+      {
+        diag->report( diag_id::ERR_AIGER_AND_DECLARATION ).add_argument( line );
+      }
+      return return_code::parse_error;
+    }
+
+    const auto index = std::atol( std::string(tokens[0u]).c_str() )/2u;
+    const auto left_lit = std::atol( std::string(tokens[1u]).c_str() );
+    const auto right_lit = std::atol( std::string(tokens[2u]).c_str() );
+    reader.on_and( index, left_lit, right_lit );
+  }
+
+  /* parse names and comments */
+  while ( detail::getline( in, line ) )
+  {
+    if ( std::regex_search( line, m, aig_regex::input ) )
+    {
+      reader.on_input_name( std::atol( std::string( m[1u] ).c_str() ), m[2u] );
+    }
+    else if ( std::regex_search( line, m, aig_regex::latch ) )
+    {
+      reader.on_latch_name( std::atol( std::string( m[1u] ).c_str() ), m[2u] );
+    }
+    else if ( std::regex_search( line, m, aig_regex::output ) )
+    {
+      reader.on_output_name( std::atol( std::string( m[1u] ).c_str() ), m[2u] );
+    }
+    else if ( std::regex_search( line, m, aig_regex::bad_state ) )
+    {
+      reader.on_bad_state_name( std::atol( std::string( m[1u] ).c_str() ), m[2u] );
+    }
+    else if ( std::regex_search( line, m, aig_regex::constraint ) )
+    {
+      reader.on_constraint_name( std::atol( std::string( m[1u] ).c_str() ), m[2u] );
+    }
+    else if ( std::regex_search( line, m, aig_regex::justice ) )
+    {
+      reader.on_justice_name( std::atol( std::string( m[1u] ).c_str() ), m[2u] );
+    }
+    else if ( std::regex_search( line, m, aig_regex::fairness ) )
+    {
+      reader.on_fairness_name( std::atol( std::string( m[1u] ).c_str() ), m[2u] );
+    }
+    else if ( line == "c" )
+    {
+      std::string comment = "";
+      while ( detail::getline( in, line ) )
+      {
+        comment += line;
+      }
+      reader.on_comment( comment );
+      break;
+    }
+  }
+
+  return result;
+}
+
+/*! \brief Reader function for ASCII AIGER format.
+ *
+ * Reads ASCII AIGER format from a file and invokes a callback
+ * method for each parsed primitive and each detected parse error.
+ *
+ * \param filename Name of the file
+ * \param reader An AIGER reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_ascii_aiger( const std::string& filename, const aiger_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  std::ifstream in( detail::word_exp_filename( filename ), std::ifstream::in );
+  if ( !in.is_open() )
+  {
+    if ( diag )
+    {
+      diag->report( diag_id::ERR_FILE_OPEN ).add_argument( filename );
+    }
+    return return_code::parse_error;
+  }
+  else
+  {
+    auto const ret = read_ascii_aiger( in, reader, diag );
+    in.close();
+    return ret;
+  }
+}
+
+/*! \brief Reader function for binary AIGER format.
+ *
+ * Reads binary AIGER format from a stream and invokes a callback
+ * method for each parsed primitive and each detected parse error.
+ *
+ * \param in Input stream
+ * \param reader An AIGER reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_aiger( std::istream& in, const aiger_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  return_code result = return_code::success;
+
+  std::smatch m;
+  std::string header_line;
+  detail::getline( in, header_line );
+
+  uint32_t _m, _i, _l, _o, _a, _b, _c, _j, _f;
+
+  /* parse header */
+  if ( std::regex_search( header_line, m, aig_regex::header ) )
+  {
+    std::vector<uint32_t> header;
+    for ( const auto& i : m )
+    {
+      if ( i == "" )
+        continue;
+      header.push_back( std::atol( std::string( i ).c_str() ) );
+    }
+
+    assert( header.size() >= 6u );
+    assert( header.size() <= 10u );
+
+    _m = header[1u];
+    _i = header[2u];
+    _l = header[3u];
+    _o = header[4u];
+    _a = header[5u];
+    _b = header.size() > 6 ? header[6u] : 0u;
+    _c = header.size() > 7 ? header[7u] : 0u;
+    _j = header.size() > 8 ? header[8u] : 0u;
+    _f = header.size() > 9 ? header[9u] : 0u;
+    reader.on_header( _m, _i, _l, _o, _a, _b, _c, _j, _f );
+  }
+  else
+  {
+    if ( diag )
+    {
+      diag->report( diag_id::ERR_AIGER_HEADER ).add_argument( header_line );
+    }
+    return return_code::parse_error;
+  }
+
+  std::string line;
+
+  /* inputs */
+  for ( auto i = 0u; i < _i; ++i )
+  {
+    reader.on_input( i, 2u*(i+1) );
+  }
+
+  /* latches */
+  for ( auto i = 0u; i < _l; ++i )
+  {
+    detail::getline( in, line );
+    const auto tokens = detail::split( line, " " );
+    const auto next = std::atoi( tokens[0u].c_str() );
+    aiger_reader::latch_init_value init_value = aiger_reader::latch_init_value::NONDETERMINISTIC;
+    if ( tokens.size() == 2u )
+    {
+      if ( tokens[1u] == "0" )
+      {
+        init_value = aiger_reader::latch_init_value::ZERO;
+      }
+      else if ( tokens[1u] == "1" )
+      {
+        init_value = aiger_reader::latch_init_value::ONE;
+      }
+    }
+
+    reader.on_latch( _i + i + 1u, next, init_value );
+  }
+
+  for ( auto i = 0u; i < _o; ++i )
+  {
+    detail::getline( in, line );
+    reader.on_output( i, std::atol( line.c_str() ) );
+  }
+
+  /* bad state properties */
+  for ( auto i = 0u; i < _b; ++i )
+  {
+    detail::getline( in, line );
+    reader.on_bad_state( i, std::atol( line.c_str() ) );
+  }
+
+  /* constraints */
+  for ( auto i = 0u; i < _c; ++i )
+  {
+    detail::getline( in, line );
+    reader.on_constraint( i, std::atol( line.c_str() ) );
+  }
+
+  /* justice properties */
+  std::vector<uint64_t> justice_sizes;
+  for ( auto i = 0u; i < _j; ++i )
+  {
+    detail::getline( in, line );
+    const auto justice_size = std::atol( line.c_str() );
+    justice_sizes.emplace_back( justice_size );
+    reader.on_justice_header( i, justice_size );
+  }
+
+  for ( auto i = 0u; i < _j; ++i )
+  {
+    std::vector<uint32_t> lits;
+    for ( auto j = 0u; j < justice_sizes[i]; ++j )
+    {
+      detail::getline( in, line );
+      const auto lit = std::atol( line.c_str() );
+      lits.emplace_back( lit );
+    }
+    reader.on_justice( i, lits );
+  }
+
+  /* fairness */
+  for ( auto i = 0u; i < _f; ++i )
+  {
+    detail::getline( in, line );
+    reader.on_fairness( i, std::atol( line.c_str() ) );
+  }
+
+  const auto decode = [&]() {
+    auto i = 0;
+    auto res = 0;
+    while ( true )
+    {
+      auto c = in.get();
+
+      res |= ( ( c & 0x7f ) << ( 7 * i ) );
+      if ( ( c & 0x80 ) == 0 )
+        break;
+
+      ++i;
+    }
+    return res;
+  };
+
+  /* and gates */
+  for ( auto i = _i + _l + 1; i < _i + _l + _a + 1; ++i )
+  {
+    const auto d1 = decode();
+    const auto d2 = decode();
+    const auto g = i << 1;
+    reader.on_and( i, ( g - d1 ), ( g - d1 - d2 ) );
+  }
+
+  /* parse names and comments */
+  while ( detail::getline( in, line ) )
+  {
+    if ( std::regex_search( line, m, aig_regex::input ) )
+    {
+      reader.on_input_name( std::atol( std::string( m[1u] ).c_str() ), m[2u] );
+    }
+    else if ( std::regex_search( line, m, aig_regex::latch ) )
+    {
+      reader.on_latch_name( std::atol( std::string( m[1u] ).c_str() ), m[2u] );
+    }
+    else if ( std::regex_search( line, m, aig_regex::output ) )
+    {
+      reader.on_output_name( std::atol( std::string( m[1u] ).c_str() ), m[2u] );
+    }
+    else if ( std::regex_search( line, m, aig_regex::bad_state ) )
+    {
+      reader.on_bad_state_name( std::atol( std::string( m[1u] ).c_str() ), m[2u] );
+    }
+    else if ( std::regex_search( line, m, aig_regex::constraint ) )
+    {
+      reader.on_constraint_name( std::atol( std::string( m[1u] ).c_str() ), m[2u] );
+    }
+    else if ( std::regex_search( line, m, aig_regex::justice ) )
+    {
+      reader.on_justice_name( std::atol( std::string( m[1u] ).c_str() ), m[2u] );
+    }
+    else if ( std::regex_search( line, m, aig_regex::fairness ) )
+    {
+      reader.on_fairness_name( std::atol( std::string( m[1u] ).c_str() ), m[2u] );
+    }
+    else if ( line == "c" )
+    {
+      std::string comment = "";
+      while ( detail::getline( in, line ) )
+      {
+        comment += line;
+      }
+      reader.on_comment( comment );
+      break;
+    }
+  }
+
+  return result;
+}
+
+/*! \brief Reader function for binary AIGER format.
+ *
+ * Reads binary AIGER format from a file and invokes a callback
+ * method for each parsed primitive and each detected parse error.
+ *
+ * \param filename Name of the file
+ * \param reader An AIGER reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_aiger( const std::string& filename, const aiger_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  std::ifstream in( detail::word_exp_filename( filename ), std::ifstream::binary );
+  if ( !in.is_open() )
+  {
+    if ( diag )
+    {
+      diag->report( diag_id::ERR_FILE_OPEN ).add_argument( filename );
+    }
+    return return_code::parse_error;
+  }
+  else
+  {
+    auto const ret = read_aiger( in, reader, diag );
+    in.close();
+    return ret;
+  }
+}
+
+} // namespace lorina
diff --git a/lib/lorina/lorina/bench.hpp b/lib/lorina/lorina/bench.hpp
new file mode 100644
index 0000000..7236e7d
--- /dev/null
+++ b/lib/lorina/lorina/bench.hpp
@@ -0,0 +1,345 @@
+/* lorina: C++ parsing library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file bench.hpp
+  \brief Implements bench parser
+
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "common.hpp"
+#include "diagnostics.hpp"
+#include "detail/utils.hpp"
+#include <fstream>
+#include <regex>
+#include <iostream>
+
+namespace lorina
+{
+
+/*! \brief A reader visitor for the BENCH format.
+ *
+ * Callbacks for the BENCH format.
+ */
+class bench_reader
+{
+public:
+  /*! \brief Callback method for parsed input.
+   *
+   * \param name Name of the input
+   */
+  virtual void on_input( const std::string& name ) const
+  {
+    (void)name;
+  }
+
+  /*! \brief Callback method for parsed output.
+   *
+   * \param name Name of the output
+   */
+  virtual void on_output( const std::string& name ) const
+  {
+    (void)name;
+  }
+
+  /*! \brief Callback method for parsed input of DFF (before output is available).
+   *
+   * \param input Name of the input
+   */
+  virtual void on_dff_input( const std::string& input ) const
+  {
+    (void)input;
+  }
+
+  /*! \brief Callback method for parsed DFF (when input and output are available).
+   *
+   * \param input Name of the input
+   * \param output Name of the output
+   */
+  virtual void on_dff( const std::string& input, const std::string& output ) const
+  {
+    (void)input;
+    (void)output;
+  }
+
+  /*! \brief Callback method for parsed gate.
+   *
+   * \param inputs A list of inputs
+   * \param output An output
+   * \param type Either a name that specified the gate or a hexadecimal number that describes the logic function of the gate.
+   */
+  virtual void on_gate( const std::vector<std::string>& inputs, const std::string& output, const std::string& type ) const
+  {
+    (void)inputs;
+    (void)output;
+    (void)type;
+  }
+
+  /*! \brief Callback method for parsed gate assignment.
+   *
+   * \param input An input
+   * \param output An output
+   */
+  virtual void on_assign( const std::string& input, const std::string& output ) const
+  {
+    (void)input;
+    (void)output;
+  }
+}; /* bench_reader */
+
+/*! \brief A BENCH reader for prettyprinting BENCH.
+ *
+ * Callbacks for prettyprinting of BENCH.
+ *
+ */
+class bench_pretty_printer : public bench_reader
+{
+public:
+  /*! \brief Constructor of the BENCH pretty printer.
+   *
+   * \param os Output stream
+   */
+  bench_pretty_printer( std::ostream& os = std::cout )
+      : _os( os )
+  {
+  }
+
+  virtual void on_input( const std::string& name ) const override
+  {
+    _os << fmt::format( "INPUT({0})", name ) << std::endl;
+  }
+
+  virtual void on_output( const std::string& name ) const override
+  {
+    _os << fmt::format( "OUTPUT({0})", name ) << std::endl;
+  }
+
+  virtual void on_gate( const std::vector<std::string>& inputs, const std::string& output, const std::string& type ) const override
+  {
+    _os << fmt::format( "{0} = {1}({2})", output, type, detail::join( inputs, "," ) ) << std::endl;
+  }
+
+  virtual void on_assign( const std::string& input, const std::string& output ) const override
+  {
+    _os << fmt::format( "{0} = {1}", output, input ) << std::endl;
+  }
+
+  std::ostream& _os; /*!< Output stream */
+}; /* bench_pretty_printer */
+
+namespace bench_regex
+{
+static std::regex input( R"(INPUT\((.*)\))" );
+static std::regex output( R"(OUTPUT\((.*)\))" );
+static std::regex gate( R"((.*)\s+=\s+(.*)\((.*)\))" );
+static std::regex dff( R"((.*)\s+=\s+DFF\((.+)\))" );
+static std::regex lut( R"((.*)\s+=\s+LUT\s+(.*)\((.*)\))" );
+static std::regex gate_asgn( R"((.*)\s+=\s+(.*))" );
+} // namespace bench_regex
+
+/*! \brief Reader function for the BENCH format.
+ *
+ * Reads BENCH format from a stream and invokes a callback
+ * method for each parsed primitive and each detected parse error.
+ *
+ * \param in Input stream
+ * \param reader A BENCH reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_bench( std::istream& in, const bench_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  return_code result = return_code::success;
+
+  /* Function signature */
+  using GateFn = detail::Func<
+                   std::vector<std::string>,
+                   std::string,
+                   std::string
+                 >;
+
+  /* Parameter maps */
+  using GateParamMap = detail::ParamPackMap<
+                         /* Key */
+                         std::string,
+                         /* Params */
+                         std::vector<std::string>,
+                         std::string,
+                         std::string
+                       >;
+
+  constexpr static const int GATE_FN{0};
+
+  using ParamMaps = detail::ParamPackMapN<GateParamMap>;
+  using PackedFns = detail::FuncPackN<GateFn>;
+
+  detail::call_in_topological_order<PackedFns, ParamMaps>
+    on_action( PackedFns( GateFn( [&]( std::vector<std::string> inputs,
+                                       std::string output,
+                                       std::string type )
+                                  {
+                                    if ( type == "" )
+                                    {
+                                      reader.on_assign( inputs.front(), output );
+                                    }
+                                    else if ( type == "DFF" )
+                                    {
+                                      reader.on_dff( inputs.front(), output );
+                                    }
+                                    else
+                                    {
+                                      reader.on_gate( inputs, output, type );
+                                    }
+                                  } ) ) );
+  on_action.declare_known( "vdd" );
+  on_action.declare_known( "gnd" );
+
+  std::smatch m;
+  detail::foreach_line_in_file_escape( in, [&]( const std::string& line ) {
+    /* empty line or comment */
+    if ( line.empty() || line[0] == '#' )
+      return true;
+
+    /* INPUT(<string>) */
+    if ( std::regex_search( line, m, bench_regex::input ) )
+    {
+      const auto s = detail::trim_copy( m[1] );
+      on_action.declare_known( s );
+      reader.on_input( s );
+      return true;
+    }
+
+    /* OUTPUT(<string>) */
+    if ( std::regex_search( line, m, bench_regex::output ) )
+    {
+      reader.on_output( detail::trim_copy( m[1] ) );
+      return true;
+    }
+
+    /* (<string> = LUT <HEX>(<list of strings>)) */
+    if ( std::regex_search( line, m, bench_regex::lut ) )
+    {
+      const auto output = detail::trim_copy( m[1] );
+      const auto type = detail::trim_copy( m[2] );
+      const auto args = detail::trim_copy( m[3] );
+      const auto inputs = detail::split( args, "," );
+      on_action.call_deferred<GATE_FN>( inputs, { output }, std::make_tuple( inputs, output, type ) );
+      return true;
+    }
+
+    /* (<string> = DFF(<string>)) */
+    if ( std::regex_search( line, m, bench_regex::dff ) )
+    {
+      const auto output = detail::trim_copy( m[1] );
+      const auto arg = detail::trim_copy( m[2] );
+      reader.on_dff_input( output );
+      on_action.declare_known( output );
+      on_action.call_deferred<GATE_FN>( { arg }, { output }, std::make_tuple( std::vector<std::string>{ arg }, output, "DFF" ) );
+      return true;
+    }
+
+    /* (<string> = <GATE_TYPE>(<list of strings>)) */
+    if ( std::regex_search( line, m, bench_regex::gate ) )
+    {
+      const auto output = detail::trim_copy( m[1] );
+      const auto type = detail::trim_copy( m[2] );
+      const auto args = detail::trim_copy( m[3] );
+      const auto inputs = detail::split( args, "," );
+      on_action.call_deferred<GATE_FN>( inputs, { output }, std::make_tuple( inputs, output, type ) );
+      return true;
+    }
+
+    /* (<string> = <string> */
+    if ( std::regex_search( line, m, bench_regex::gate_asgn ) )
+    {
+      const auto output = detail::trim_copy( m[1] );
+      const auto input = detail::trim_copy( m[2] );
+      on_action.call_deferred<GATE_FN>( { input }, { output }, std::make_tuple( std::vector<std::string>{ input }, output, "" ) );
+      return true;
+    }
+
+    if ( diag )
+    {
+      diag->report( diag_id::ERR_PARSE_LINE ).add_argument( line );
+    }
+
+    result = return_code::parse_error;
+    return true;
+  } );
+
+  /* check dangling objects */
+  const auto& deps = on_action.unresolved_dependencies();
+  if ( deps.size() > 0 )
+  {
+    result = return_code::parse_error;
+  }
+
+  for ( const auto& r : deps )
+  {
+    if ( diag )
+    {
+      diag->report( diag_id::WRN_UNRESOLVED_DEPENDENCY )
+        .add_argument( r.first )
+        .add_argument( r.second );
+    }
+  }
+
+  return result;
+}
+
+/*! \brief Reader function for BENCH format.
+ *
+ * Reads BENCH format from a file and invokes a callback
+ * method for each parsed primitive and each detected parse error.
+ *
+ * \param filename Name of the file
+ * \param reader A BENCH reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_bench( const std::string& filename, const bench_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  std::ifstream in( detail::word_exp_filename( filename ), std::ifstream::in );
+  if ( !in.is_open() )
+  {
+    if ( diag )
+    {
+      diag->report( diag_id::ERR_FILE_OPEN ).add_argument( filename );
+    }
+    return return_code::parse_error;
+  }
+  else
+  {
+    auto const ret = read_bench( in, reader, diag );
+    in.close();
+    return ret;
+  }
+}
+
+} // namespace lorina
diff --git a/lib/lorina/lorina/blif.hpp b/lib/lorina/lorina/blif.hpp
new file mode 100644
index 0000000..be49695
--- /dev/null
+++ b/lib/lorina/lorina/blif.hpp
@@ -0,0 +1,504 @@
+/* lorina: C++ parsing library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file blif.hpp
+  \brief Implements BLIF parser
+
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "common.hpp"
+#include "diagnostics.hpp"
+#include "detail/utils.hpp"
+#include <regex>
+#include <iostream>
+#include <optional>
+
+namespace lorina
+{
+
+/*! \brief A reader visitor for the BLIF format.
+ *
+ * Callbacks for the BLIF (Berkeley Logic Interchange Format) format.
+ */
+class blif_reader
+{
+public:
+  /*! \brief Type of the output cover as truth table. */
+  using output_cover_t = std::vector<std::pair<std::string, std::string>>;
+
+  /*! Latch input values */
+  enum latch_init_value
+  {
+    ZERO = 0 /*!< Initialized with 0 */
+  , ONE /*!< Initialized with 1 */
+  , NONDETERMINISTIC /*!< Not initialized (non-deterministic value) */
+  , UNKNOWN
+  };
+
+  enum latch_type
+  {
+    FALLING = 0
+  , RISING
+  , ACTIVE_HIGH
+  , ACTIVE_LOW
+  , ASYNC
+  , NONE
+  };
+
+public:
+  static std::optional<latch_init_value> latch_init_value_from_string( std::string const& s )
+  {
+    if ( s == "0" )
+    {
+      return blif_reader::latch_init_value::ZERO;
+    }
+    else if ( s == "1" )
+    {
+      return blif_reader::latch_init_value::ONE;
+    }
+    else if ( s == "2" )
+    {
+      return blif_reader::latch_init_value::NONDETERMINISTIC;
+    }
+    else
+    {
+      return blif_reader::latch_init_value::UNKNOWN;
+    }
+  }
+
+  static std::optional<latch_type> latch_type_from_string( std::string const& s )
+  {
+    if ( s == "fe" )
+    {
+      return blif_reader::latch_type::FALLING;
+    }
+    else if ( s == "re" )
+    {
+      return blif_reader::latch_type::RISING;
+    }
+    else if ( s == "ah" )
+    {
+      return blif_reader::latch_type::ACTIVE_HIGH;
+    }
+    else if ( s == "al" )
+    {
+      return blif_reader::latch_type::ACTIVE_LOW;
+    }
+    else
+    {
+      return blif_reader::latch_type::ASYNC;
+    }
+  }
+
+public:
+  /*! \brief Callback method for parsed model.
+   *
+   * \param model_name Name of the model
+   */
+  virtual void on_model( const std::string& model_name ) const
+  {
+    (void)model_name;
+  }
+
+  /*! \brief Callback method for parsed input.
+   *
+   * \param name Input name
+   */
+  virtual void on_input( const std::string& name ) const
+  {
+    (void)name;
+  }
+
+  /*! \brief Callback method for parsed output.
+   *
+   * \param name Output name
+   */
+  virtual void on_output( const std::string& name ) const
+  {
+    (void)name;
+  }
+
+  /*! \brief Callback method for parsed latch.
+   *
+   * \param input Input name
+   * \param output Output name
+   * \param type Optional type of the latch
+   * \param control Optional name of control signal
+   * \param reset Optional initial value of the latch
+   */
+  virtual void on_latch( const std::string& input, const std::string& output, const std::optional<latch_type>& type, const std::optional<std::string>& control, const std::optional<latch_init_value>& init_value ) const
+  {
+    (void)input;
+    (void)output;
+    (void)type;
+    (void)control;
+    (void)init_value;
+  }
+
+  /*! \brief Callback method for parsed gate.
+   *
+   * \param inputs A list of input names
+   * \param output Name of output of the gate
+   * \param cover N-input, 1-output PLA description of the logic function corresponding to the logic gate
+   */
+  virtual void on_gate( const std::vector<std::string>& inputs, const std::string& output, const output_cover_t& cover ) const
+  {
+    (void)inputs;
+    (void)output;
+    (void)cover;
+  }
+
+  /*! \brief Callback method for parsed end.
+   *
+   */
+  virtual void on_end() const {}
+
+  /*! \brief Callback method for parsed comment.
+   *
+   * \param comment Comment
+   */
+  virtual void on_comment( const std::string& comment ) const
+  {
+    (void)comment;
+  }
+}; /* blif_reader */
+
+/*! \brief A BLIF reader for prettyprinting BLIF.
+ *
+ * Callbacks for prettyprinting of BLIF.
+ *
+ */
+class blif_pretty_printer : public blif_reader
+{
+public:
+  /*! \brief Constructor of the BLIF pretty printer.
+   *
+   * \param os Output stream
+   */
+  blif_pretty_printer( std::ostream& os = std::cout )
+      : _os( os )
+  {
+  }
+
+  virtual void on_model( const std::string& model_name ) const
+  {
+    _os << ".model " << model_name << std::endl;
+  }
+
+  virtual void on_input( const std::string& name ) const
+  {
+    if ( first_input ) _os << std::endl << ".inputs ";
+    _os << name << " ";
+    first_input = false;
+  }
+
+  virtual void on_output( const std::string& name ) const
+  {
+    if ( first_output ) _os << std::endl << ".output ";
+    _os << name << " ";
+    first_output = false;
+  }
+
+  virtual void on_latch( const std::string& input, const std::string& output, const std::optional<latch_type>& type, const std::optional<std::string>& control, const std::optional<latch_init_value>& init_value ) const
+  {
+    _os << fmt::format( "\n.latch {0} {1} {2} {3} {4}", input, output,
+                        ( type ? *type : latch_type::NONE ), ( control ? *control : "" ), ( init_value ? *init_value : latch_init_value::UNKNOWN ) ) << std::endl;
+  }
+
+  virtual void on_gate( const std::vector<std::string>& inputs, const std::string& output, const output_cover_t& cover ) const
+  {
+    _os << std::endl << fmt::format( ".names {0} {1}", detail::join( inputs, "," ), output ) << std::endl;
+    for ( const auto& c : cover )
+    {
+      _os << c.first << ' ' << c.second << std::endl;
+    }
+  }
+
+  virtual void on_end() const
+  {
+    _os << std::endl << ".end" << std::endl;
+  }
+
+  virtual void on_comment( const std::string& comment ) const
+  {
+    _os << std::endl << "# " << comment << std::endl;
+  }
+
+  mutable bool first_input = true; /*!< Predicate that is true until the first input was parsed */
+  mutable bool first_output = true; /*!< Predicate that is true until the first output was parsed */
+  std::ostream& _os; /*!< Output stream */
+}; /* blif_pretty_printer */
+
+namespace blif_regex
+{
+static std::regex model( R"(.model\s+(.*))" );
+static std::regex names( R"(.names\s+(.*))" );
+static std::regex line_of_truthtable( R"(([01\-]*)\s*([01\-]))" );
+static std::regex end( R"(.end)" );
+} // namespace blif_regex
+
+/*! \brief Reader function for the BLIF format.
+ *
+ * Reads BLIF format from a stream and invokes a callback
+ * method for each parsed primitive and each detected parse error.
+ *
+ * \param in Input stream
+ * \param reader A BLIF reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_blif( std::istream& in, const blif_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  return_code result = return_code::success;
+
+  /* Function signature */
+  using GateFn = detail::Func<
+                   std::vector<std::string>,
+                   std::string,
+                   std::vector<std::pair<std::string, std::string>>
+                 >;
+
+  /* Parameter maps */
+  using GateParamMap = detail::ParamPackMap<
+                         /* Key */
+                         std::string,
+                         /* Params */
+                         std::vector<std::string>,
+                         std::string,
+                         std::vector<std::pair<std::string, std::string>>
+                       >;
+
+  constexpr static const int GATE_FN{0};
+
+  using ParamMaps = detail::ParamPackMapN<GateParamMap>;
+  using PackedFns = detail::FuncPackN<GateFn>;
+
+  detail::call_in_topological_order<PackedFns, ParamMaps>
+    on_action( PackedFns( GateFn( [&]( std::vector<std::string> inputs,
+				       std::string output,
+				       std::vector<std::pair<std::string, std::string>> tt )
+    {
+      /* ignore latches */
+      if ( output == "" )
+      {
+        assert( inputs.size() == 0u );
+        return;
+      }
+
+      reader.on_gate( inputs, output, tt );
+    } ) ) );
+
+  std::smatch m;
+  detail::foreach_line_in_file_escape( in, [&]( std::string line ) {
+    redo:
+      /* empty line or comment */
+      if ( line.empty() || line[0] == '#' )
+        return true;
+
+      /* names */
+      if ( std::regex_search( line, m, blif_regex::names ) )
+      {
+        auto args = detail::split( detail::trim_copy( m[1] ), " " );
+        const auto output = *( args.rbegin() );
+        args.pop_back();
+
+        std::vector<std::pair<std::string, std::string>> tt;
+        std::string copy_line;
+        detail::foreach_line_in_file_escape( in, [&]( const std::string& line ) {
+          copy_line = line;
+
+          /* terminate when the next '.' declaration starts */
+          if ( line[0] == '.' )
+            return false;
+
+          /* empty line or comment */
+          if ( line.empty() || line[0] == '#' )
+            return true;
+
+          if ( std::regex_search( line, m, blif_regex::line_of_truthtable ) )
+          {
+            tt.push_back( std::make_pair( detail::trim_copy( m[1] ), detail::trim_copy( m[2] ) ) );
+            return true;
+          }
+
+          return false;
+        } );
+
+        on_action.call_deferred<GATE_FN>( args, { output }, std::tuple( args, output, tt ) );
+
+        if ( in.eof() )
+        {
+          return true;
+        }
+        else
+        {
+          /* restart parsing with the line of the subparser */
+          line = copy_line;
+          goto redo;
+        }
+      }
+
+      /* .model <string> */
+      if ( std::regex_search( line, m, blif_regex::model ) )
+      {
+        reader.on_model( detail::trim_copy( m[1] ) );
+        return true;
+      }
+
+      /* .inputs <list of whitespace separated strings> */
+      if ( detail::starts_with( line, ".inputs" ) )
+      {
+        std::string const input_declaration = line.substr( 7 );
+        for ( const auto& input : detail::split( detail::trim_copy( input_declaration ), " " ) )
+        {
+          auto const s = detail::trim_copy( input );
+          on_action.declare_known( s );
+          reader.on_input( s );
+        }
+        return true;
+      }
+
+      /* .latch <list of whitespace separated strings> */
+      if ( detail::starts_with( line, ".latch" ) )
+      {
+        std::string const latch_declaration = line.substr( 6 );
+
+        std::vector<std::string> latch_elements = detail::split( detail::trim_copy( latch_declaration ), " " );
+        if ( latch_elements.size() >= 2 )
+        {
+          std::string const& input = latch_elements.at( 0 );
+          std::string const& output = latch_elements.at( 1 );
+          std::optional<blif_reader::latch_init_value> init_value;
+          std::optional<blif_reader::latch_type> type;
+          std::optional<std::string> control;
+
+          if ( latch_elements.size() == 3u )
+          {
+            init_value = blif_reader::latch_init_value_from_string( latch_elements.at( 2 ) );
+          }
+          else if ( latch_elements.size() == 4u )
+          {
+            type = blif_reader::latch_type_from_string( latch_elements.at( 2 ) );
+            control = latch_elements.at( 3 );
+          }
+          else if ( latch_elements.size() == 5u )
+          {
+            type = blif_reader::latch_type_from_string( latch_elements.at( 2 ) );
+            control = latch_elements.at( 3 );
+            init_value = blif_reader::latch_init_value_from_string( latch_elements.at( 4 ) );
+          }
+
+          on_action.declare_known( output );
+          reader.on_latch( input, output, type, control, init_value );
+          on_action.compute_dependencies<GATE_FN>( { output } );
+
+          return true;
+        }
+
+        diag->report( diag_id::ERR_BLIF_LATCH_FORMAT ).add_argument( line );
+
+        result = return_code::parse_error;
+      }
+
+      /* .outputs <list of whitespace separated strings> */
+      if ( detail::starts_with( line, ".outputs" ) )
+      {
+        std::string const output_declaration = line.substr( 8 );
+        for ( const auto& output : detail::split( detail::trim_copy( output_declaration ), " " ) )
+        {
+          reader.on_output( detail::trim_copy( output ) );
+        }
+        return true;
+      }
+
+      /* .end */
+      if ( std::regex_search( line, m, blif_regex::end ) )
+      {
+        reader.on_end();
+        return true;
+      }
+
+      if ( diag )
+      {
+        diag->report( diag_id::ERR_PARSE_LINE ).add_argument( line );
+      }
+
+      result = return_code::parse_error;
+      return true;
+    } );
+
+  /* check dangling objects */
+  auto const& deps = on_action.unresolved_dependencies();
+  if ( deps.size() > 0 )
+    result = return_code::parse_error;
+
+  for ( const auto& r : deps )
+  {
+    if ( diag )
+    {
+      diag->report( diag_id::WRN_UNRESOLVED_DEPENDENCY )
+        .add_argument( r.first )
+        .add_argument( r.second );
+    }
+  }
+
+  return result;
+}
+
+/*! \brief Reader function for BLIF format.
+ *
+ * Reads binary BLIF format from a file and invokes a callback
+ * method for each parsed primitive and each detected parse error.
+ *
+ * \param filename Name of the file
+ * \param reader A BLIF reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_blif( const std::string& filename, const blif_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  std::ifstream in( detail::word_exp_filename( filename ), std::ifstream::in );
+  if ( !in.is_open() )
+  {
+    if ( diag )
+    {
+      diag->report( diag_id::ERR_FILE_OPEN ).add_argument( filename );
+    }
+    return return_code::parse_error;
+  }
+  else
+  {
+    auto const ret = read_blif( in, reader, diag );
+    in.close();
+    return ret;
+  }
+}
+
+} // namespace lorina
diff --git a/lib/lorina/lorina/bristol.hpp b/lib/lorina/lorina/bristol.hpp
new file mode 100644
index 0000000..f53a6b4
--- /dev/null
+++ b/lib/lorina/lorina/bristol.hpp
@@ -0,0 +1,217 @@
+/* lorina: C++ parsing library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file bristol.hpp
+  \brief Implements a parser for Bristol fashion
+
+  Reference: https://homes.esat.kuleuven.be/~nsmart/MPC/
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "common.hpp"
+#include "diagnostics.hpp"
+#include "detail/utils.hpp"
+
+#include <algorithm>
+#include <cassert>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace lorina
+{
+
+class bristol_reader
+{
+public:
+  explicit bristol_reader() {}
+
+  virtual ~bristol_reader() {}
+
+  virtual void on_header( uint32_t num_gates, uint32_t num_wires, uint32_t num_inputs, std::vector<uint32_t> const& num_wires_per_input, uint32_t num_outputs, std::vector<uint32_t> const& num_wires_per_output ) const
+  {
+    (void)num_gates;
+    (void)num_wires;
+    (void)num_inputs;
+    (void)num_wires_per_input;
+    (void)num_outputs;
+    (void)num_wires_per_output;
+  }
+
+  virtual void on_gate( std::vector<uint32_t> const& in, uint32_t out, std::string const& gate ) const
+  {
+    (void)in;
+    (void)out;
+    (void)gate;
+  }
+};
+
+class bristol_parser
+{
+public:
+  explicit bristol_parser( std::istream& is, bristol_reader const& reader )
+    : is( is )
+    , reader( reader )
+  {
+  }
+
+  return_code run()
+  {
+    std::vector<std::string> tokens;
+
+    /* read header */
+    if ( !get_tokens_of_next_line( tokens ) || tokens.size() != 2u )
+      return return_code::parse_error;
+
+    uint32_t num_gates = static_cast<uint32_t>( std::stoul( tokens[0u] ) );
+    uint32_t num_wires = static_cast<uint32_t>( std::stoul( tokens[1u] ) );
+
+    if ( !get_tokens_of_next_line( tokens ) || tokens.empty() )
+      return return_code::parse_error;
+    uint32_t num_inputs = static_cast<uint32_t>( std::stoul( tokens[0u] ) );
+    if ( tokens.size() != num_inputs + 1 )
+      return return_code::parse_error;
+    std::vector<uint32_t> num_inputs_per_wire( num_inputs );
+    std::transform( tokens.begin() + 1, tokens.end(), num_inputs_per_wire.begin(), [&]( std::string const& s ) { return static_cast<uint32_t>( std::stoul( s ) ); } );
+
+    if ( !get_tokens_of_next_line( tokens ) || tokens.empty() )
+      return return_code::parse_error;
+    uint32_t num_outputs = static_cast<uint32_t>( std::stoul( tokens[0u] ) );
+    if ( tokens.size() != num_outputs + 1 )
+      return return_code::parse_error;
+    std::vector<uint32_t> num_outputs_per_wire( num_outputs );
+    std::transform( tokens.begin() + 1, tokens.end(), num_outputs_per_wire.begin(), [&]( std::string const& s ) { return static_cast<uint32_t>( std::stoul( s ) ); } );
+
+    reader.on_header( num_gates, num_wires, num_inputs, num_inputs_per_wire, num_outputs, num_outputs_per_wire );
+
+    /* parse gates */
+    while ( get_tokens_of_next_line( tokens ) )
+    {
+      uint32_t num_input_wires = std::atoi( tokens[0u].c_str() );
+      uint32_t num_output_wires = std::atoi( tokens[1u].c_str() );
+
+      assert( tokens.size() == num_input_wires + num_output_wires + 3u );
+      assert( num_output_wires == 1u );
+      (void)num_output_wires;
+
+      std::vector<uint32_t> inputs;
+      for ( uint32_t i = 0; i < num_input_wires; ++i )
+      {
+        inputs.push_back( std::atoi( tokens[ 2u + i ].c_str() ) );
+      }
+
+      uint32_t const output = std::atoi( tokens[ 2u + num_input_wires ].c_str() );
+      std::string const& gate = tokens[tokens.size() - 1];
+
+      reader.on_gate( inputs, output, gate );
+    }
+
+    return return_code::success;
+  }
+
+private:
+  bool get_tokens_of_next_line( std::vector<std::string>& tokens )
+  {
+    tokens.clear();
+
+    std::string line;
+    do
+    {
+      if ( is.eof() )
+        return false;
+
+      std::getline( is, line );
+      detail::trim( line );
+    } while ( line == "" );
+
+    std::istringstream iss( line );
+    std::string token;
+    while ( !iss.eof() )
+    {
+      iss >> token;
+      tokens.push_back( token );
+    }
+
+    return true;
+  }
+
+private:
+  std::istream& is;
+  bristol_reader const& reader;
+};
+
+/*! \brief Reads a Bristol fashion circuit from a stream
+ *
+ * A callback method of the reader visitor is invoked for each
+ * primitive object matched in the specification.
+ *
+ * \param in Input stream
+ * \param reader A BRISTOL reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_bristol( std::istream& is, const bristol_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  (void)diag;
+  return bristol_parser( is, reader ).run();
+}
+
+/*! \brief Reads a Bristol fashion circuit from a file
+ *
+ * A callback method of the reader visitor is invoked for each
+ * primitive object matched in the specification.
+ *
+ * \param filename Name of the file
+ * \param reader A BRISTOL reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_bristol( const std::string& filename, const bristol_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  std::ifstream in( filename, std::ifstream::in );
+  if ( !in.is_open() )
+  {
+    if ( diag )
+    {
+      diag->report( diag_id::ERR_FILE_OPEN ).add_argument( filename );
+    }    
+    return return_code::parse_error;
+  }
+  else
+  {
+    auto const ret = read_bristol( in, reader );
+    in.close();
+    return ret;
+  }
+}
+
+} // namespace lorina
diff --git a/lib/lorina/lorina/common.hpp b/lib/lorina/lorina/common.hpp
new file mode 100644
index 0000000..3dd1272
--- /dev/null
+++ b/lib/lorina/lorina/common.hpp
@@ -0,0 +1,44 @@
+/* lorina: C++ parsing library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file common.hpp
+  \brief Common data structures.
+
+  \author Heinz Riener
+*/
+
+#pragma once
+
+namespace lorina
+{
+
+enum class return_code
+{
+  success = 0,
+  parse_error,
+};
+
+} // namespace lorina
\ No newline at end of file
diff --git a/lib/lorina/lorina/detail/call_in_topological_order.hpp b/lib/lorina/lorina/detail/call_in_topological_order.hpp
new file mode 100644
index 0000000..cdf7645
--- /dev/null
+++ b/lib/lorina/lorina/detail/call_in_topological_order.hpp
@@ -0,0 +1,408 @@
+/* lorina: C++ parsing library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*! \cond PRIVATE */
+
+#pragma once
+
+#include <iostream>
+
+namespace lorina
+{
+
+namespace detail
+{
+
+/* std::apply in C++14 taken from https://stackoverflow.com/a/36656413 */
+template<typename Function, typename Tuple, size_t ... I>
+auto apply( Function f, Tuple t, std::index_sequence<I ...> )
+{
+  return f( std::get<I>(t)... );
+}
+
+template<typename Function, typename Tuple>
+auto apply( Function f, Tuple t )
+{
+  static constexpr auto size = std::tuple_size<Tuple>::value;
+  return apply( f, t, std::make_index_sequence<size>{} );
+}
+
+/* \brief Parameter pack
+ *
+ * A pack of parameters of different types
+ *
+ * Example:
+ *   using PackedParams = ParamPack<int, std::string, float>;
+ *
+ *   PackedParams params;
+ *   params.set( 10, "a", 10.5f );
+ */
+template<typename... Args>
+class ParamPack
+{
+public:
+  using Tuple = std::tuple<Args...>;
+
+public:
+  explicit ParamPack() {}
+
+  explicit ParamPack( Args... params )
+    : params_( std::make_tuple( params... ) )
+  {}
+
+  explicit ParamPack( const std::tuple<Args...>& tup )
+    : params_( tup )
+  {}
+
+  void set( Args... params )
+  {
+    params_ = std::make_tuple( params... );
+  }
+
+  auto get() const
+  {
+    return params_;
+  }
+
+private:
+  std::tuple<Args...> params_;
+}; // ParamPack
+
+/* \brief Multple parameter packs
+ *
+ * A vector of N parameter packs
+ *
+ * Example:
+ *   using PackedParamsA = ParamPack<int, std::string, int>;
+ *   using PackedParamsB = ParamPack<double, int>;
+ *
+ *   PackedParamsA params_a( 10, "a", 4 );
+ *   PackedParamsB params_b( 2.0, 3 );
+ *   ParamPackN<PackedParamsA, PackedParamsB>
+ *     params( params_a, params_b );
+ */
+template<typename... ParamPacks>
+class ParamPackN
+{
+public:
+  explicit ParamPackN()
+  {}
+
+  explicit ParamPackN( ParamPacks... packs )
+    : packs_( std::make_tuple( packs... ) )
+  {}
+
+  template<int I>
+  void set( typename std::tuple_element<I, std::tuple<ParamPacks...>>::type const& pack )
+  {
+    static_assert( I < sizeof...( ParamPacks ) );
+    std::get<I>( packs_ ) = pack;
+  }
+
+  template<int I>
+  auto get() const
+  {
+    static_assert( I < sizeof...( ParamPacks ) );
+    return std::get<I>( packs_ );
+  }
+
+private:
+  std::tuple<ParamPacks...> packs_;
+}; // ParamPackN
+
+/* \brief Parameter pack map
+ *
+ * A map from a KeyType to a parameter pack
+ *
+ * Example:
+ *   ParamPackMap<std::string, int, std::string, int> param_map;
+ *   param_map["a"] = ParamPack<int, std::string, int>( 10, "a", 10 );
+ *   param_map["b"] = ParamPack<int, std::string, int>( 10, "b", 10 );
+ */
+template<typename KeyType, typename... Args>
+class ParamPackMap
+{
+public:
+  using ValueType = typename detail::ParamPack<Args...>::Tuple;
+
+public:
+  explicit ParamPackMap() {}
+
+  auto& operator[]( const KeyType& key )
+  {
+    return map_[key];
+  }
+
+  const auto& operator[]( const KeyType& key ) const
+  {
+    return map_[key];
+  }
+
+  void insert( const KeyType& key, const std::tuple<Args...>& tup )
+  {
+    map_[key] = ParamPack<Args...>( tup );
+  }
+
+  void insert( const KeyType& key, Args... args )
+  {
+    map_[key] = ParamPack<Args...>( std::make_tuple( args... ) );
+  }
+
+private:
+  std::unordered_map<KeyType, ParamPack<Args...>> map_;
+};
+
+/* \brief Multiple parameter pack maps
+ *
+ * A vector of N parameter pack maps
+ *
+ * Example:
+ *   using StringToStringMap = ParamPackMap<std::string, std::string>;
+ *   using StringToIntMap = ParamPackMap<std::string, int>;
+ *
+ *   ParamPackMapN<StringToStringMap, StringToIntMap> maps;
+ *   maps.get<0>()["a"] = ParamPack<std::string>( std::string{"a"} );
+ *   maps.get<1>()["b"] = ParamPack<int>( 10 );
+ */
+template<typename... ParamMaps>
+class ParamPackMapN
+{
+public:
+  explicit ParamPackMapN() {}
+
+  template<int I>
+  auto& get()
+  {
+    static_assert( I < sizeof...( ParamMaps ) );
+    return std::get<I>( maps_ );
+  }
+
+  template<int I>
+  auto& get() const
+  {
+    static_assert( I < sizeof...( ParamMaps ) );
+    return std::get<I>( maps_ );
+  }
+
+private:
+  std::tuple<ParamMaps...> maps_;
+};
+
+/* \brief A callable function
+ *
+ * Example:
+ *   Func<int, std::string> f;
+ *   f( std::tuple( 10, "a" ) );
+ *   f( std::tuple( 12, "b" ) );
+ */
+template<typename... Args>
+class Func
+{
+public:
+  using Tuple = std::tuple<Args...>;
+
+public:
+  Func( std::function<void(Args...)> fn )
+    : fn_( fn )
+  {}
+
+  void operator()( Tuple const& tup )
+  {
+    detail::apply( fn_, tup );
+  }
+
+private:
+  std::function<void(Args...)> fn_;
+}; // FuncPack
+
+/* \brief Multiple packed functions
+ *
+ * A vector of N packed functions
+ *
+ * Example:
+ *   using Fn_A = Func<int, std::string>;
+ *   using Fn_B = Func<double, int>;
+ *
+ *   FuncPackN<Fn_A, Fn_B> functions(
+ *     Fn_A( []( int a, std::string b ){ std::cout << a << ' ' << b << std::endl; } ),
+ *     Fn_B( []( double a, int b ){ std::cout << a << ' ' << b << std::endl; } )
+ *   );
+ *
+ *   functions.apply<0>( std::tuple( 10, "foo" ) );
+ *   functions.apply<0>( std::tuple( 12, "bar" ) );
+ *   functions.apply<1>( std::tuple( 3.41, 0 ) );
+ *   functions.apply<1>( std::tuple( 2.58, 1 ) );
+ */
+template<typename... Fns>
+class FuncPackN
+{
+public:
+  explicit FuncPackN( std::tuple<Fns...> fns )
+    : fns_( fns )
+  {}
+
+  explicit FuncPackN( Fns... fns )
+    : fns_( std::make_tuple( fns... ) )
+  {}
+
+  template<int I>
+  void apply( typename std::tuple_element<I, std::tuple<Fns...>>::type::Tuple const& tup )
+  {
+    std::get<I>( fns_ )( tup );
+  }
+
+private:
+  std::tuple<Fns...> fns_;
+}; // FuncPackN
+
+template<typename TypeListOne, typename TypeListTwo>
+struct call_in_topological_order;
+
+template<typename... Fns, typename... Params>
+struct call_in_topological_order<FuncPackN<Fns...>, ParamPackMapN<Params...>>
+{
+public:
+  using dependency_type = std::pair<std::string, std::string>;
+
+public:
+  explicit call_in_topological_order( FuncPackN<Fns...> fns )
+    : fns_( fns )
+  {}
+
+  void declare_known( const std::string& name )
+  {
+    known_.emplace( name );
+  }
+
+  template<int I>
+  void call_deferred( const std::vector<std::string>& inputs,
+		      const std::vector<std::string>& outputs,
+		      const typename std::tuple_element<I, std::tuple<Params...>>::type::ValueType& tup )
+  {
+    /* do we have all inputs */
+    std::unordered_set<std::string> unknown;
+    for ( const auto& input : inputs )
+    {
+      if ( known_.find( input ) != std::end( known_ ) )
+	continue;
+
+      const auto it = waits_for_.find( input );
+      if ( it == std::end( waits_for_ ) || !it->second.empty() )
+      {
+	unknown.insert( input );
+      }
+    }
+
+    /* store the parameters */
+    for ( const auto& output : outputs )
+    {
+      param_maps_.template get<I>()[output] = ParamPack( tup );
+    }
+
+    if ( !unknown.empty() )
+    {
+      /* defer computation */
+      for ( const auto& input : unknown )
+      {
+	for ( const auto& output : outputs )
+	{
+	  triggers_[input].insert( output );
+	  waits_for_[output].insert( input );
+	}
+      }
+      return;
+    }
+
+    /* trigger dependency computation */
+    for ( const auto& output : outputs )
+    {
+      compute_dependencies<I>( output );
+    }
+  }
+
+  template<int I>
+  void compute_dependencies( const std::string& output )
+  {
+    /* init empty, makes sure nothing is waiting for this output */
+    waits_for_[output];
+
+    std::stack<std::string> computed;
+    computed.push( output );
+
+    while ( !computed.empty() )
+    {
+      auto const next = computed.top();
+      computed.pop();
+
+      // C++17: std::apply( f, _stored_params[next] );
+      // detail::apply( f_, stored_params_[next] );
+
+      fns_.template apply<I>( param_maps_.template get<I>()[next].get() );
+
+      /* activate all the triggers */
+      for ( const auto& other : triggers_[next] )
+      {
+	waits_for_[other].erase( next );
+	if ( waits_for_[other].empty() )
+	{
+	  computed.push( other );
+	}
+      }
+      triggers_[next].clear();
+    }
+  }
+
+  std::vector<dependency_type> unresolved_dependencies()
+  {
+    std::vector<dependency_type> deps;
+    for ( const auto& item : waits_for_ )
+    {
+      auto const& key = item.first;
+      auto const& wait_list = item.second;
+
+      if ( wait_list.empty() )
+	continue;
+
+      /* collect all keys that are still waiting for an item */
+      for ( const auto& entry : wait_list )
+      {
+	deps.emplace_back( key, entry );
+      }
+    }
+    return deps;
+  }
+
+private:
+  FuncPackN<Fns...> fns_;
+  ParamPackMapN<Params...> param_maps_;
+
+  std::unordered_set<std::string> known_;
+  std::unordered_map<std::string, std::unordered_set<std::string>> waits_for_;
+  std::unordered_map<std::string, std::unordered_set<std::string>> triggers_;
+}; // call_in_topological_order
+
+} // namespace detail
+
+} // namespace lorina
diff --git a/lib/lorina/lorina/detail/tokenizer.hpp b/lib/lorina/lorina/detail/tokenizer.hpp
new file mode 100644
index 0000000..ddec813
--- /dev/null
+++ b/lib/lorina/lorina/detail/tokenizer.hpp
@@ -0,0 +1,148 @@
+/* lorina: C++ parsing library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <lorina/detail/utils.hpp>
+#include <iostream>
+#include <string>
+
+namespace lorina
+{
+
+namespace detail
+{
+
+enum class tokenizer_return_code
+{
+  invalid = 0
+, valid   = 1
+, comment = 2
+};
+
+class tokenizer
+{
+public:
+  explicit tokenizer( std::istream& is )
+    : _is( is )
+  {}
+
+  bool get_char( char& c )
+  {
+    if ( !lookahead.empty() )
+    {
+      c = *lookahead.rbegin();
+      lookahead.pop_back();
+      return true;
+    }
+    else
+    {
+      return bool(_is.get( c ));
+    }
+  }
+
+  tokenizer_return_code get_token_internal( std::string& token )
+  {
+    if ( _done )
+    {
+      return tokenizer_return_code::invalid;
+    }
+    token = "";
+
+    char c;
+    while ( get_char( c ) )
+    {
+      if ( c == '\n' && _comment_mode )
+      {
+        _comment_mode = false;
+        return tokenizer_return_code::comment;
+      }
+      else if ( !_comment_mode )
+      {
+        if ( ( c == ' ' || c == '\\' || c == '\n' ) && !_quote_mode )
+        {
+          return tokenizer_return_code::valid;
+        }
+        if ( ( c == '(' || c == ')' || c == '{' || c == '}' || c == ';' || c == ':' || c == ',' || c == '~' || c == '&' || c == '|' || c == '^' || c == '#' || c == '[' || c == ']' ) && !_quote_mode )
+        {
+          if ( token.empty() )
+          {
+            token = std::string() + c;
+          }
+          else
+          {
+            lookahead += c;
+          }
+          return tokenizer_return_code::valid;
+        }
+
+        if ( c == '\"' )
+        {
+          _quote_mode = !_quote_mode;
+        }
+      }
+
+      token += c;
+    }
+
+    _done = true;
+    return tokenizer_return_code::valid;
+  }
+
+  bool get_token( std::string& token )
+  {
+    tokenizer_return_code result;
+    do
+    {
+      result = get_token_internal( token );
+      detail::trim( token );
+
+      /* keep parsing if token is empty */
+    } while ( token == "" && result == tokenizer_return_code::valid );
+
+    return ( result == tokenizer_return_code::valid );
+  }
+
+  void set_comment_mode( bool value = true )
+  {
+    _comment_mode = value;
+  }
+
+  bool get_comment_mode() const
+  {
+    return _comment_mode;
+  }
+
+protected:
+  bool _done = false;
+  bool _quote_mode = false;
+  bool _comment_mode = false;
+  std::istream& _is;
+  std::string lookahead;
+}; /* tokenizer */
+
+} // namespace detail
+
+} // namespace lorina
diff --git a/lib/lorina/lorina/detail/utils.hpp b/lib/lorina/lorina/detail/utils.hpp
new file mode 100644
index 0000000..15e9b7a
--- /dev/null
+++ b/lib/lorina/lorina/detail/utils.hpp
@@ -0,0 +1,242 @@
+/* lorina: C++ parsing library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*! \cond PRIVATE */
+
+#pragma once
+
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <cassert>
+#include <cctype>
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <functional>
+#include <locale>
+#include <memory>
+#include <numeric>
+#include <stack>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#ifndef _WIN32
+#include <libgen.h>
+#include <wordexp.h>
+#endif
+
+#include "call_in_topological_order.hpp"
+
+namespace lorina
+{
+
+namespace detail
+{
+
+/* https://stackoverflow.com/questions/6089231/getting-std-ifstream-to-handle-lf-cr-and-crlf */
+inline std::istream& getline( std::istream& is, std::string& t )
+{
+  t.clear();
+
+  /* The characters in the stream are read one-by-one using a std::streambuf.
+   * That is faster than reading them one-by-one using the std::istream.
+   * Code that uses streambuf this way must be guarded by a sentry object.
+   * The sentry object performs various tasks,
+   * such as thread synchronization and updating the stream state.
+   */
+
+  std::istream::sentry se( is, true );
+  std::streambuf* sb = is.rdbuf();
+
+  for ( ;; )
+  {
+    int const c = sb->sbumpc();
+    switch ( c )
+    {
+    /* deal with file endings */
+    case '\n':
+      return is;
+    case '\r':
+      if ( sb->sgetc() == '\n' )
+      {
+        sb->sbumpc();
+      }
+      return is;
+
+    /* handle the case when the last line has no line ending */
+    case std::streambuf::traits_type::eof():
+      if ( t.empty() )
+      {
+        is.setstate( std::ios::eofbit );
+      }
+      return is;
+
+    default:
+      t += (char)c;
+    }
+  }
+}
+
+template<typename T>
+inline std::string join( const T& t, const std::string& sep )
+{
+  return std::accumulate(
+      std::next( t.begin() ), t.end(), std::string( t[0] ),
+      [&]( const std::string& s, const typename T::value_type& v ) { return s + sep + std::string( v ); } );
+}
+
+/* string utils are from https://stackoverflow.com/a/217605 */
+
+inline void ltrim( std::string& s )
+{
+  s.erase( s.begin(), std::find_if( s.begin(), s.end(), []( int ch ) {
+             return !std::isspace( ch );
+           } ) );
+}
+
+inline void rtrim( std::string& s )
+{
+  s.erase( std::find_if( s.rbegin(), s.rend(), []( int ch ) {
+             return !std::isspace( ch );
+           } )
+               .base(),
+           s.end() );
+}
+
+inline void trim( std::string& s )
+{
+  ltrim( s );
+  rtrim( s );
+}
+
+inline std::string trim_copy( std::string s )
+{
+  trim( s );
+  return s;
+}
+
+inline void foreach_line_in_file_escape( std::istream& in, const std::function<bool( const std::string& )>& f )
+{
+  std::string line, line2;
+
+  while ( !getline( in, line ).eof() )
+  {
+    trim( line );
+
+    while ( line.back() == '\\' )
+    {
+      line.pop_back();
+      trim( line );
+
+      /* check if failbit has been set */
+      if ( !getline( in, line2 ) )
+      {
+        assert( false );
+        std::abort();
+      }
+      line += line2;
+    }
+
+    if ( !f( line ) )
+    {
+      break;
+    }
+  }
+}
+
+// https://stackoverflow.com/a/14266139
+inline std::vector<std::string> split( const std::string& str, const std::string& sep )
+{
+  std::vector<std::string> result;
+
+  size_t last = 0;
+  size_t next = 0;
+  std::string substring;
+  while ( ( next = str.find( sep, last ) ) != std::string::npos )
+  {
+    substring = str.substr( last, next - last );
+    if ( substring.length() > 0 )
+    {
+      std::string sub = str.substr( last, next - last );
+      sub.erase( std::remove( sub.begin(), sub.end(), ' ' ), sub.end() );
+      result.push_back( sub );
+    }
+    last = next + 1;
+  }
+
+  substring = str.substr( last );
+  substring.erase( std::remove( substring.begin(), substring.end(), ' ' ), substring.end() );
+  result.push_back( substring );
+
+  return result;
+}
+
+#ifndef _WIN32
+inline std::string word_exp_filename( const std::string& filename )
+{
+  std::string result;
+
+  wordexp_t p;
+  wordexp( filename.c_str(), &p, 0 );
+
+  for ( auto i = 0u; i < p.we_wordc; ++i )
+  {
+    if ( !result.empty() )
+    {
+      result += " ";
+    }
+    result += std::string( p.we_wordv[i] );
+  }
+
+  wordfree( &p );
+
+  return result;
+}
+#else
+inline const std::string& word_exp_filename( const std::string& filename )
+{
+  return filename;
+}
+#endif
+
+#ifndef _WIN32
+inline std::string basename( const std::string& filepath )
+{
+  return std::string( ::basename( const_cast<char*>( filepath.c_str() ) ) );
+}
+#endif
+
+inline bool starts_with( std::string const& s, std::string const& match )
+{
+  return ( s.substr( 0, match.size() ) == match );
+}
+
+} // namespace detail
+} // namespace lorina
+
+/*! \endcond */
diff --git a/lib/lorina/lorina/diagnostics.hpp b/lib/lorina/lorina/diagnostics.hpp
new file mode 100644
index 0000000..a1b111a
--- /dev/null
+++ b/lib/lorina/lorina/diagnostics.hpp
@@ -0,0 +1,322 @@
+/* lorina: C++ parsing library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file diagnostics.hpp
+  \brief Implements diagnostics.
+
+  \author Heinz Riener
+*/
+
+#pragma once
+
+#include <cassert>
+#include <iostream>
+#include <map>
+#include <fmt/format.h>
+#include <fmt/color.h>
+
+namespace lorina
+{
+
+class diagnostic_builder;
+class diagnostic_consumer;
+class diagnostic_engine;
+
+enum class diagnostic_level
+{
+  ignore = 1,
+  note = 2,
+  remark = 3,
+  warning = 4,
+  error = 5,
+  fatal = 6,
+};
+
+#include "diagnostics.inc"
+
+/*! \brief A diagnostic engine. */
+class diagnostic_engine
+{
+public:
+  using desc_type = std::pair<diagnostic_level, std::string>;
+
+public:
+  /*! \brief Constructs a diagnostic engine.
+   *
+   * \param client Diagnostic client
+   */
+  explicit diagnostic_engine( diagnostic_consumer *client );
+
+  /*! \brief Creates a diagnostic builder.
+   *
+   * \param id ID of diagnostic
+   */
+  virtual inline diagnostic_builder report( diag_id id );
+
+  /*! \brief Emits a diagnostic message.
+   *
+   * \param id ID of diagnostic
+   * \param args Arguments
+   */
+  virtual inline void emit( diag_id id, std::vector<std::string> const& args = {} ) const;
+
+  /*! \brief Create custom diagnostic.
+   *
+   * \param level Severity level
+   * \param message Diagnostic message
+   */
+  diag_id create_id( diagnostic_level level, std::string const& message );
+
+  /*! \brief Return the number of emitted diagnostics. */
+  uint64_t get_num_diagnostics() const;
+
+private:
+  /*! \brief Emit diagnostics with static ID.
+   *
+   * \param id ID of diagnostic
+   * \param args Arguments
+   */
+  void emit_static_diagnostic( diag_id id, std::vector<std::string> const& args ) const;
+
+  /*! \brief Emit diagnostics with custom ID.
+   *
+   * \param id ID of diagnostic
+   * \param args Arguments
+   */
+  void emit_custom_diagnostic( diag_id id, std::vector<std::string> const& args ) const;
+
+protected:
+  diagnostic_consumer *client_ = nullptr;  /*!< Diagnostic client. */
+  std::vector<desc_type> custom_diag_info; /*!< Custom diagnostics. */
+  std::map<desc_type, diag_id> custom_diag_ids; /*!< Map from custom ID to diagnostic. */
+  mutable uint64_t num_diagnostics{0};
+}; /* diagnostic_engine */
+
+/*! \brief A builder for diagnostics.
+ *
+ * An object that encapsulates a diagnostic.  The diagnostic may take
+ * additional parameters and is finally issued at the end of its
+ * life time.
+ */
+class diagnostic_builder
+{
+public:
+  /*! \brief Constructs a diagnostic builder.
+   *
+   * \param engine Diagnostic engine
+   * \param id ID of diagnostic
+   */
+  inline explicit diagnostic_builder( diagnostic_engine& engine, diag_id id );
+
+  /*! \brief Destructs the diagnostic builder and issues the diagnostic. */
+  inline ~diagnostic_builder();
+
+  /*! \brief Add argument.
+   *
+   * \param s String argument
+   */
+  inline diagnostic_builder& add_argument( std::string const& s );
+
+private:
+  diagnostic_engine& engine_; /*!< diagnostic engine */
+  diag_id id_; /*!< id of diagnostic */
+  std::vector<std::string> args_; /*!< arguments for diagnostic */
+}; /* diagnostic_builder */
+
+/*! \brief A consumer for diagnostics. */
+class diagnostic_consumer
+{
+public:
+  diagnostic_consumer() = default;
+  virtual ~diagnostic_consumer() = default;
+
+  /*! \brief Handle diagnostic.
+   *
+   * \param level Severity level
+   * \param message Diagnostic message
+   */
+  virtual void handle_diagnostic( diagnostic_level level, std::string const& message ) const
+  {
+    (void)level;
+    (void)message;
+  }
+};
+
+/*! \brief A consumer for diagnostics. */
+class text_diagnostics : public diagnostic_consumer
+{
+public:
+  text_diagnostics() = default;
+  virtual ~text_diagnostics() = default;
+
+  /*! \brief Handle diagnostic.
+   *
+   * \param level Severity level
+   * \param message Diagnostic message
+   */
+  void handle_diagnostic( diagnostic_level level, std::string const& message ) const override
+  {
+    switch ( level )
+    {
+    case diagnostic_level::ignore:
+      break;
+    case diagnostic_level::note:
+      {
+        fmt::print( stdout, fmt::emphasis::bold | fg( fmt::terminal_color::bright_green ), "[i]" );
+        fmt::print( stdout, fmt::emphasis::bold | fg( fmt::color::white ), " {}\n", message );
+      }
+      break;
+    case diagnostic_level::remark:
+      {
+        fmt::print( stderr, fmt::emphasis::bold | fg( fmt::terminal_color::bright_green ), "[I]" );
+        fmt::print( stderr, fmt::emphasis::bold | fg( fmt::color::white ), " {}\n", message );
+      }
+      break;
+    case diagnostic_level::warning:
+      {
+        fmt::print( stderr, fmt::emphasis::bold | fg( fmt::terminal_color::bright_magenta ),"[w]" );
+        fmt::print( stderr, fmt::emphasis::bold | fg( fmt::color::white ), " {}\n", message );
+      }
+      break;
+    case diagnostic_level::error:
+      {
+        fmt::print( stderr, fmt::emphasis::bold | fg( fmt::terminal_color::bright_red ), "[e]" );
+        fmt::print( stderr, fmt::emphasis::bold | fg( fmt::color::white ), " {}\n", message );
+      }
+      break;
+    case diagnostic_level::fatal:
+    default:
+      {
+        fmt::print( stderr, fmt::emphasis::bold | fg( fmt::terminal_color::bright_red ), "[E]" );
+        fmt::print( stderr, fmt::emphasis::bold | fg( fmt::color::white ), " {}\n", message );
+      }
+      break;
+    }
+  }
+};
+
+inline diagnostic_builder::diagnostic_builder( diagnostic_engine& engine, diag_id id )
+  : engine_( engine ), id_( id )
+{
+}
+
+inline diagnostic_builder::~diagnostic_builder()
+{
+  engine_.emit( id_, args_ );
+}
+
+inline diagnostic_builder& diagnostic_builder::add_argument( std::string const& s )
+{
+  args_.emplace_back( s );
+  return *this;
+}
+
+inline diagnostic_engine::diagnostic_engine( diagnostic_consumer *client )
+  : client_( client )
+{
+}
+
+inline diag_id diagnostic_engine::create_id( diagnostic_level level, std::string const& message )
+{
+  desc_type desc{level, message};
+  diag_id id{diag_id( custom_diag_info.size() )};
+  custom_diag_ids.emplace( desc, id );
+  custom_diag_info.emplace_back( desc );
+  return diag_id( uint32_t( diag_id::NUM_STATIC_ERROR_IDS ) + uint32_t( id ) );
+}
+
+inline uint64_t diagnostic_engine::get_num_diagnostics() const
+{
+  return num_diagnostics;
+}
+
+inline diagnostic_builder diagnostic_engine::report( diag_id id )
+{
+  return diagnostic_builder( *this, id );
+}
+
+inline void diagnostic_engine::emit_static_diagnostic( diag_id id, std::vector<std::string> const& args ) const
+{
+  assert( id < diag_id::NUM_STATIC_ERROR_IDS );
+  diagnostic_level const level = diag_info[uint32_t( id )].first;
+  std::string const message = diag_info[uint32_t( id )].second;
+  switch ( args.size() )
+  {
+  case 1:
+    client_->handle_diagnostic( level, fmt::format( message, args[0] ) );
+    break;
+  case 2:
+    client_->handle_diagnostic( level, fmt::format( message, args[0], args[1] ) );
+    break;
+  case 3:
+    client_->handle_diagnostic( level, fmt::format( message, args[0], args[1], args[2] ) );
+    break;
+  default:
+  case 0:
+    assert( args.size() == 0 );
+    client_->handle_diagnostic( level, message );
+  }
+}
+
+inline void diagnostic_engine::emit_custom_diagnostic( diag_id id, std::vector<std::string> const& args ) const
+{
+  uint32_t const custom_id = uint32_t( id ) - uint32_t( diag_id::NUM_STATIC_ERROR_IDS );
+  assert( uint32_t( custom_id ) < custom_diag_info.size() );
+  diagnostic_level const level = custom_diag_info[custom_id].first;
+  std::string const message = custom_diag_info[custom_id].second;
+  switch ( args.size() )
+  {
+  case 1:
+    client_->handle_diagnostic( level, fmt::format( message, args[0] ) );
+    break;
+  case 2:
+    client_->handle_diagnostic( level, fmt::format( message, args[0], args[1] ) );
+    break;
+  case 3:
+    client_->handle_diagnostic( level, fmt::format( message, args[0], args[1], args[2] ) );
+    break;
+  default:
+  case 0:
+    assert( args.size() == 0 );
+    client_->handle_diagnostic( level, message );
+  }
+}
+
+inline void diagnostic_engine::emit( diag_id id, std::vector<std::string> const& args ) const
+{
+  assert( client_ != nullptr );
+  ++num_diagnostics;
+  if ( id < diag_id::NUM_STATIC_ERROR_IDS )
+  {
+    emit_static_diagnostic( id, args );
+  }
+  else
+  {
+    emit_custom_diagnostic( id, args );
+  }
+}
+
+} // namespace lorina
diff --git a/lib/lorina/lorina/diagnostics.inc b/lib/lorina/lorina/diagnostics.inc
new file mode 100644
index 0000000..0c96e2d
--- /dev/null
+++ b/lib/lorina/lorina/diagnostics.inc
@@ -0,0 +1,91 @@
+/*! pre-defined static diagnostic IDs */
+enum class diag_id
+{
+  /* general */
+  ERR_FILE_OPEN,
+  ERR_PARSE_LINE,
+  WRN_UNRESOLVED_DEPENDENCY,
+  ERR_UNSUPPORTED_KEYWORD,
+
+  /* AIGER */
+  ERR_AIGER_HEADER,
+  ERR_AIGER_LATCH_DECLARATION,
+  ERR_AIGER_AND_DECLARATION,
+
+  /* BLIF */
+  ERR_BLIF_LATCH_FORMAT,
+
+  /* VERILOG */
+  ERR_VERILOG_MODULE_HEADER,
+  ERR_VERILOG_INPUT_DECLARATION,
+  ERR_VERILOG_OUTPUT_DECLARATION,
+  ERR_VERILOG_WIRE_DECLARATION,
+  ERR_VERILOG_ASSIGNMENT,
+  ERR_VERILOG_MODULE_INSTANTIATION_STATEMENT,
+  ERR_VERILOG_MODULE_INSTANTIATION_UNDECLARED_MODULE,
+  ERR_VERILOG_MODULE_INSTANTIATION_UNDECLARED_PIN,
+  ERR_VERILOG_ASSIGNMENT_RHS,
+
+  /* DIMACS */
+  ERR_DIMACS_MISSING_SPEC,
+
+  /* GENLIB */
+  ERR_GENLIB_UNEXPECTED_STRUCTURE,
+  ERR_GENLIB_GATE,
+  ERR_GENLIB_EXPRESSION,
+  ERR_GENLIB_PIN,
+  ERR_GENLIB_PIN_PHASE,
+  ERR_GENLIB_FAILED,
+
+  /* SUPER */
+  ERR_SUPER_INFO,
+  ERR_SUPER_UNEXPECTED_STRUCTURE,
+  ERR_SUPER_GATE,
+
+  /* sentinel element to mark the end */
+  NUM_STATIC_ERROR_IDS,
+};
+
+
+/*! pre-defined static diagnostics */
+static std::pair<diagnostic_level, std::string> const diag_info[] = {
+  { diagnostic_level::fatal,   "could not open file `{}`" },
+  { diagnostic_level::fatal,   "could not parse line `{}`" },
+  { diagnostic_level::warning, "unresolved dependencies: `{}` requires `{}`" },
+  { diagnostic_level::fatal,   "unsupported keyword `{}`" },
+
+  /* AIGER */
+  { diagnostic_level::fatal, "could not parse AIGER header `{}`" },
+  { diagnostic_level::fatal, "could not parse declaration of LATCH `{}`" },
+  { diagnostic_level::fatal, "could not parse declaration of AND gate `{}`" },
+
+  /* BLIF */
+  { diagnostic_level::fatal, "latch format not supported `{}`" },
+
+  /* VERILOG */
+  { diagnostic_level::fatal, "cannot parse module header" },
+  { diagnostic_level::fatal, "cannot parse input declaration" },
+  { diagnostic_level::fatal, "cannot parse output declaration" },
+  { diagnostic_level::fatal, "cannot parse wire declaration" },
+  { diagnostic_level::fatal, "cannot parse assign statement" },
+  { diagnostic_level::fatal, "cannot parse module instantiation statement" },
+  { diagnostic_level::fatal, "cannot instantiate module: module `{}` has not been declared (ensure that the module has been parsed before)" },
+  { diagnostic_level::fatal, "cannot instantiate module: pin `{}` has not been declared in module `{}`" },
+  { diagnostic_level::fatal, "cannot parse expression on right-hand side of assign `{}`" },
+
+  /* DIMACS */
+  { diagnostic_level::fatal, "missing problem specification line" },
+
+  /* GENLIB */
+  { diagnostic_level::fatal, "line `{}` has unexpected structure (expected `GATE <name> <area> <expression>;`)`" },
+  { diagnostic_level::fatal, "line `{}` does not start with keyword `GATE`" },
+  { diagnostic_level::fatal, "expression `{}` is not immediately terminated with `;`" },
+  { diagnostic_level::fatal, "unexpected `{}` token (expected `PIN`)" },
+  { diagnostic_level::fatal, "unknown PIN phase type `{}` (expected `INV`, `NONINV`, or `UNKNOWN`)" },
+  { diagnostic_level::fatal, "parsing failed at token `{}`" },
+
+  /* SUPER */
+  { diagnostic_level::fatal, "line `{}` has unexpected structure (expected only one data)" },
+  { diagnostic_level::fatal, "line `{}` has a wrong structure (too few fields or exceeding the limit)" },
+  { diagnostic_level::fatal, "gate `{}` has a wrong number of fanin (zero or exceeding the limit)" },
+};
diff --git a/lib/lorina/lorina/dimacs.hpp b/lib/lorina/lorina/dimacs.hpp
new file mode 100644
index 0000000..dc44b9a
--- /dev/null
+++ b/lib/lorina/lorina/dimacs.hpp
@@ -0,0 +1,221 @@
+/* lorina: C++ parsing library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file dimacs.hpp
+  \brief Implements DIMACS parser
+
+  \author Bruno Schmitt
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "common.hpp"
+#include "diagnostics.hpp"
+#include "detail/utils.hpp"
+#include <cassert>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <regex>
+
+namespace lorina
+{
+
+/*! \brief A reader visitor for the DIMACS format.
+ *
+ * Callbacks for reading the DIMACS format.
+ */
+class dimacs_reader
+{
+public:
+  /*! \brief Callback method for parsed format.
+   *
+   * \param format The format (cnf or dnf)
+   */
+  virtual void on_format( const std::string& format ) const
+  {
+    (void)format;
+  }
+
+  /*! \brief Callback method for parsed number of variables.
+   *
+   * \param number_of_variables Number of variables
+   */
+  virtual void on_number_of_variables( uint64_t number_of_variables ) const
+  {
+    (void)number_of_variables;
+  }
+
+  /*! \brief Callback method for parsed number of clauses.
+   *
+   * \param number_of_clauses Number of clauses
+   */
+  virtual void on_number_of_clauses( uint64_t number_of_clauses ) const
+  {
+    (void)number_of_clauses;
+  }
+
+  /*! \brief Callback method for parsed clause.
+   *
+   * \param clause A clause of a logic function
+   */
+  virtual void on_clause( const std::vector<int>& clause ) const
+  {
+    (void)clause;
+  }
+
+  /*! \brief Callback method for parse end.
+   *
+   */
+  virtual void on_end() const {}
+
+}; /* dimacs_reader */
+
+namespace dimacs_regex
+{
+static std::regex problem_spec( R"(^p\s+([cd]nf)\s+([0-9]+)\s+([0-9]+)$)" );
+static std::regex clause( R"(((-?[1-9]+)+ +)+0)" );
+
+} // namespace dimacs_regex
+
+/*! \brief Reader function for the DIMACS format.
+ *
+ * Reads DIMACS format from a stream and invokes a callback
+ * method for each parsed primitive and each detected parse error.
+ *
+ * \param in Input stream
+ * \param reader A DIMACS reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_dimacs( std::istream& in, const dimacs_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  auto loc = 0ul;
+  auto errors = 0ul;
+  bool found_spec = false;
+
+  std::smatch m;
+  detail::foreach_line_in_file_escape( in, [&]( const std::string& line ) {
+    ++loc;
+
+    /* empty line or comment */
+    if ( line.empty() || line[0u] == 'c' )
+      return true;
+
+    if ( std::regex_search( line, m, dimacs_regex::problem_spec ) )
+    {
+      reader.on_format( std::string( m[1] ) );
+      reader.on_number_of_variables( std::atol( std::string( m[2] ).c_str() ) );
+      reader.on_number_of_clauses( std::atol( std::string( m[3] ).c_str() ) );
+      found_spec = true;
+      return true;
+    }
+
+    if ( found_spec == false ) 
+    {
+      if ( diag )
+      {
+        diag->report( diag_id::ERR_DIMACS_MISSING_SPEC );
+      }
+      ++errors;
+      return false;
+    }
+
+    auto clauses_begin = std::sregex_iterator( line.begin(), line.end(), dimacs_regex::clause );
+    auto clauses_end = std::sregex_iterator();
+
+    if ( std::distance( clauses_begin, clauses_end ) == 0u )
+    {
+      if ( diag )
+      {
+        diag->report( diag_id::ERR_PARSE_LINE ).add_argument( line );
+      }
+      ++errors;
+      return false;
+    }
+
+    for ( std::sregex_iterator i = clauses_begin; i != clauses_end; ++i ) 
+    {
+      std::smatch match = *i;
+      std::stringstream ss( match[0].str() );
+      std::string lit_str;
+      std::vector<int> clause;
+      while ( std::getline( ss, lit_str, ' ' ) )
+      {
+        int const lit = std::atol( lit_str.c_str() );
+        if ( lit != 0 )
+        {
+          clause.push_back( lit );
+        }
+      }
+      reader.on_clause( clause );
+    } 
+    return true;
+  } );
+
+  if ( errors > 0 )
+  {
+    return return_code::parse_error;
+  }
+  else
+  {
+    reader.on_end();
+    return return_code::success;
+  }
+}
+
+/*! \brief Reader function for DIMACS format.
+ *
+ * Reads DIMACS format from a file and invokes a callback method for each
+ * parsed primitive and each detected parse error.
+ *
+ * \param filename Name of the file
+ * \param reader A DIMACS reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_dimacs( const std::string& filename, const dimacs_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  std::ifstream in( detail::word_exp_filename( filename ), std::ifstream::in );
+  if ( !in.is_open() )
+  {
+    if ( diag )
+    {
+      diag->report( diag_id::ERR_FILE_OPEN ).add_argument( filename );
+    }
+    return return_code::parse_error;
+  }
+  else
+  {
+    auto const ret = read_dimacs( in, reader, diag );
+    in.close();
+    return ret;
+  }
+}
+
+} // namespace lorina
diff --git a/lib/lorina/lorina/genlib.hpp b/lib/lorina/lorina/genlib.hpp
new file mode 100644
index 0000000..32583ba
--- /dev/null
+++ b/lib/lorina/lorina/genlib.hpp
@@ -0,0 +1,383 @@
+/* lorina: C++ parsing library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file genlib.hpp
+  \brief Implements GENLIB parser
+
+  \author Heinz Riener
+  \author Shubham Rai
+  \author Alessandro Tempia Calvino
+*/
+
+#pragma once
+
+#include "common.hpp"
+#include "detail/utils.hpp"
+#include "diagnostics.hpp"
+#include <fstream>
+#include <istream>
+#include <optional>
+#include <sstream>
+#include <string>
+
+namespace lorina
+{
+
+enum class phase_type : uint8_t
+{
+  INV = 0,
+  NONINV = 1,
+  UNKNOWN = 2,
+};
+
+// PIN <pin-name> <phase> <input-load> <max-load> <rise-block-delay> <rise-fanout-delay> <fall-block-delay> <fall-fanout-delay>
+struct pin_spec
+{
+  std::string name;
+  phase_type phase;
+  double input_load;
+  double max_load;
+  double rise_block_delay;
+  double rise_fanout_delay;
+  double fall_block_delay;
+  double fall_fanout_delay;
+}; /* pin_spec */
+
+/*! \brief A reader visitor for a GENLIB format.
+ *
+ * Callbacks for the GENLIB format.
+ */
+class genlib_reader
+{
+public:
+  virtual void on_gate( std::string const& name, std::string const& expression, double area, std::vector<pin_spec> const& pins, std::string const& output_pin ) const
+  {
+    (void)name;
+    (void)expression;
+    (void)area;
+    (void)pins;
+    (void)output_pin;
+  }
+}; /* genlib_reader */
+
+/*! \brief Parse for the GENLIB format.
+ *
+ */
+class genlib_parser
+{
+public:
+  explicit genlib_parser( std::istream& in, genlib_reader const& reader, diagnostic_engine* diag )
+    : in( in )
+    , reader( reader )
+    , diag( diag )
+  {}
+
+public:
+  bool run()
+  {
+    std::string line;
+    std::string entry;
+    bool new_line;
+
+    while ( true )
+    {
+      new_line = std::getline( in, line ) ? true : false;
+
+      if ( new_line == false )
+      {
+        break;
+      }
+
+      /* remove whitespaces */
+      detail::trim( line );
+
+      /* skip comments and empty lines */
+      if ( line[0] != '#' && !line.empty() )
+      {
+        entry = line + " ";
+        break;
+      }
+    }
+
+    while ( new_line )
+    {
+      new_line = std::getline( in, line ) ? true : false;
+
+      if ( new_line == false )
+      {
+        if ( !parse_gate_definition( entry ) )
+        {
+          return false;
+        }
+        break;
+      }
+
+      /* remove whitespaces */
+      detail::trim( line );
+
+      /* skip comments and empty lines */
+      if ( line[0] == '#' || line.empty() )
+      {
+        continue;
+      }
+
+      if ( line.find( "GATE" ) != std::string::npos )
+      {
+        if ( !parse_gate_definition( entry ) )
+        {
+          return false;
+        }
+        entry = line + " ";
+      }
+      else
+      {
+        entry.append( line + " " );
+      }
+    }
+
+    return true;
+  }
+
+private:
+  bool parse_gate_definition( std::string const& line )
+  {
+    std::stringstream ss( line );
+    std::string const deliminators{" \t\r\n"};
+
+    std::string token;
+    bool in_equation = false;
+
+    std::vector<std::string> tokens;
+    while ( std::getline( ss, token ) )
+    {
+      std::size_t prev = 0, pos, eq_pos;
+      while ( ( pos = line.find_first_of( deliminators, prev ) ) != std::string::npos )
+      {
+        /* equation */
+        if ( tokens.size() == 3 && !in_equation )
+        {
+          /* equation is not finished */
+          if ( token.substr( prev, pos - prev ).find_first_of( ";" ) == std::string::npos )
+          {
+            in_equation = true;
+            eq_pos = prev;
+            prev = pos + 1;
+            continue;
+          }
+        }
+        if ( in_equation )
+        {
+          if ( token.substr( prev, pos - prev ).find_first_of( ";" ) != std::string::npos )
+          {
+            in_equation = false;
+            prev = eq_pos;
+          }
+          else
+          {
+            prev = pos + 1;
+            continue;
+          }
+        }
+        if ( pos > prev )
+        {
+          tokens.emplace_back( token.substr( prev, pos - prev ) );
+        }
+        prev = pos + 1;
+      }
+
+      if ( prev < line.length() )
+      {
+        tokens.emplace_back( token.substr( prev, std::string::npos ) );
+      }
+    }
+
+    if ( tokens.size() < 4u )
+    {
+      if ( diag )
+      {
+        diag->report( diag_id::ERR_GENLIB_UNEXPECTED_STRUCTURE ).add_argument( line );
+      }
+      return false;
+    }
+
+    if ( tokens[0] != "GATE" )
+    {
+      if ( diag )
+      {
+        diag->report( diag_id::ERR_GENLIB_GATE ).add_argument( line );
+      }
+      return false;
+    }
+    auto const beg = tokens[3].find_first_of( "=" );
+    auto const end = tokens[3].find_first_of( ";" );
+    if ( beg == std::string::npos || end == std::string::npos )
+    {
+      if ( diag )
+      {
+        diag->report( diag_id::ERR_GENLIB_EXPRESSION ).add_argument( tokens[3] );
+      }
+      return false;
+    }
+
+    std::string const& name = tokens[1];
+    std::string const& expression = tokens[3].substr( beg + 1, end - beg - 1 );
+    std::string const& output_name = detail::trim_copy( tokens[3].substr( 0, beg ) );
+    double const area = std::stod( tokens[2] );
+
+    std::vector<pin_spec> pins;
+
+    bool generic_pin{false};
+    uint64_t i{4};
+    for ( ; i+8 < tokens.size(); i += 9 )
+    {
+      /* check PIN specification */
+      if ( tokens[i] != "PIN" )
+      {
+        if ( diag )
+        {
+          diag->report( diag_id::ERR_GENLIB_PIN ).add_argument( tokens[i] );
+        }
+        return false;
+      }
+
+      std::string const& name = tokens[i+1];
+      if ( tokens[i+1] == "*" )
+      {
+        generic_pin = true;
+      }
+      phase_type phase{phase_type::UNKNOWN};
+      if ( tokens[i+2] == "INV" )
+      {
+        phase = phase_type::INV;
+      }
+      else if ( tokens[i+2] == "NONINV" )
+      {
+        phase = phase_type::NONINV;
+      }
+      else
+      {
+        if ( tokens[i+2] != "UNKNOWN" )
+        {
+          if ( diag )
+          {
+            diag->report( diag_id::ERR_GENLIB_PIN_PHASE ).add_argument( tokens[i+1] );
+          }
+        }
+      }
+
+      double const input_load = std::stod( tokens[i+3] );
+      double const max_load = std::stod( tokens[i+4] );
+      double const rise_block_delay = std::stod( tokens[i+5] );
+      double const rise_fanout_delay = std::stod( tokens[i+6] );
+      double const fall_block_delay = std::stod( tokens[i+7] );
+      double const fall_fanout_delay = std::stod( tokens[i+8] );
+
+      pins.emplace_back( pin_spec{name,phase,input_load,max_load,rise_block_delay,rise_fanout_delay,fall_block_delay,fall_fanout_delay} );
+    }
+
+    if ( pins.size() > 1 && generic_pin )
+    {
+      if ( diag )
+      {
+        diag->report( diag_id::ERR_GENLIB_PIN ).add_argument( line );
+      }
+      return false;
+    }
+
+    if ( i != tokens.size() )
+    {
+      if ( diag )
+      {
+        diag->report( diag_id::ERR_GENLIB_FAILED ).add_argument( tokens[i] );
+      }
+      return false;
+    }
+
+    reader.on_gate( name, expression, area, pins, output_name );
+    return true;
+  }
+
+protected:
+  std::istream& in;
+  genlib_reader const& reader;
+  diagnostic_engine* diag;
+}; /* genlib_parser */
+
+
+/*! \brief Reader function for the GENLIB format.
+ *
+ * Reads GENLIB format from a stream and invokes a callback
+ * method for each parsed primitive and each detected parse error.
+ *
+ * \param in Input stream
+ * \param reader GENLIB reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_genlib( std::istream& in, const genlib_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  genlib_parser parser( in, reader, diag );
+  auto result = parser.run();
+  if ( !result )
+  {
+    return return_code::parse_error;
+  }
+  else
+  {
+    return return_code::success;
+  }
+}
+
+/*! \brief Reader function for the GENLIB format.
+ *
+ * Reads GENLIB format from a file and invokes a callback
+ * method for each parsed primitive and each detected parse error.
+ *
+ * \param filename Name of the file
+ * \param reader GENLIB reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_genlib( const std::string& filename, const genlib_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  std::ifstream in( detail::word_exp_filename( filename ), std::ifstream::in );
+  if ( !in.is_open() )
+  {
+    if ( diag )
+    {
+      diag->report( diag_id::ERR_FILE_OPEN ).add_argument( filename );
+    }
+    return return_code::parse_error;
+  }
+  else
+  {
+    auto const ret = read_genlib( in, reader, diag );
+    in.close();
+    return ret;
+  }
+}
+
+} /* lorina */
diff --git a/lib/lorina/lorina/lorina.hpp b/lib/lorina/lorina/lorina.hpp
new file mode 100644
index 0000000..928a131
--- /dev/null
+++ b/lib/lorina/lorina/lorina.hpp
@@ -0,0 +1,42 @@
+/* lorina: C++ parsing library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file lorina.hpp
+  \brief Main header for lorina
+
+  \author Heinz Riener
+*/
+
+#pragma once
+
+#include "aiger.hpp"
+#include "bench.hpp"
+#include "blif.hpp"
+#include "bristol.hpp"
+#include "dimacs.hpp"
+#include "genlib.hpp"
+#include "pla.hpp"
+#include "verilog.hpp"
diff --git a/lib/lorina/lorina/pla.hpp b/lib/lorina/lorina/pla.hpp
new file mode 100644
index 0000000..c8a9656
--- /dev/null
+++ b/lib/lorina/lorina/pla.hpp
@@ -0,0 +1,360 @@
+/* lorina: C++ parsing library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file pla.hpp
+  \brief Implements pla parser
+
+  \author Heinz Riener
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "common.hpp"
+#include "diagnostics.hpp"
+#include "detail/utils.hpp"
+#include <cassert>
+#include <fstream>
+#include <iostream>
+#include <regex>
+
+namespace lorina
+{
+
+/*! \brief A reader visitor for the PLA format.
+ *
+ * Callbacks for reading the PLA format.
+ */
+class pla_reader
+{
+public:
+  /*! \brief Callback method for parsed number of inputs.
+   *
+   * \param number_of_inputs Number of inputs
+   */
+  virtual void on_number_of_inputs( uint64_t number_of_inputs ) const
+  {
+    (void)number_of_inputs;
+  }
+
+  /*! \brief Callback method for parsed number of outputs.
+   *
+   * \param number_of_outputs Number of outputs
+   */
+  virtual void on_number_of_outputs( uint64_t number_of_outputs ) const
+  {
+    (void)number_of_outputs;
+  }
+
+  /*! \brief Callback method for parsed number of terms.
+   *
+   * \param number_of_terms Number of terms
+   */
+  virtual void on_number_of_terms( uint64_t number_of_terms ) const
+  {
+    (void)number_of_terms;
+  }
+
+  /*! \brief Callback method for parsed keyword-value pair.
+   *
+   * \param keyword Parsed keyword
+   * \param value Parsed value
+   * \return true if keyword is recognized and handled, false if keyword is not supported
+   */
+  virtual bool on_keyword( const std::string& keyword, const std::string& value ) const
+  {
+    (void)keyword;
+    (void)value;
+    return false;
+  }
+
+  /*! \brief Callback method for parsed end.
+   *
+   */
+  virtual void on_end() const {}
+
+  /*! \brief Callback method for parsed term.
+   *
+   * \param term A term of a logic function
+   * \param out Output bit of term
+   */
+  virtual void on_term( const std::string& term, const std::string& out ) const
+  {
+    (void)term;
+    (void)out;
+  }
+}; /* pla_reader */
+
+/*! \brief A writer for the PLA format.
+ *
+ * Callbacks for writing the PLA format.
+ *
+ */
+class pla_writer
+{
+public:
+  /*! \brief Constructs a PLA writer.
+   *
+   * \param os Output stream
+   */
+  explicit pla_writer( std::ostream& os )
+    : _os( os )
+  {}
+
+  /*! \brief Callback method for writing number of inputs.
+   *
+   * \param number_of_inputs Number of inputs
+   */
+  virtual void on_number_of_inputs( uint64_t number_of_inputs ) const
+  {
+    _os << fmt::format( ".i {}\n", number_of_inputs );
+  }
+
+  /*! \brief Callback method for writing number of outputs.
+   *
+   * \param number_of_outputs Number of outputs
+   */
+  virtual void on_number_of_outputs( uint64_t number_of_outputs ) const
+  {
+    _os << fmt::format( ".o {}\n", number_of_outputs );
+  }
+
+  /*! \brief Callback method for writing number of terms.
+   *
+   * \param number_of_terms Number of terms
+   */
+  virtual void on_number_of_terms( uint64_t number_of_terms ) const
+  {
+    _os << fmt::format( ".p {}\n", number_of_terms );
+  }
+
+  /*! \brief Callback method for writing keyword-value pair.
+   *
+   * \param keyword Keyword
+   * \param value Value
+   */
+  virtual void on_keyword( const std::string& keyword, const std::string& value ) const
+  {
+    _os << fmt::format( ".{} {}\n", keyword, value );
+  }
+
+  /*! \brief Callback method for writing end.
+   *
+   */
+  virtual void on_end() const
+  {
+    _os << ".e\n";
+  }
+
+  /*! \brief Callback method for writing term.
+   *
+   * \param term A term of a logic function
+   * \param out Output bit of term
+   */
+  virtual void on_term( const std::string& term, const std::string& out ) const
+  {
+    _os << term << ' ' << out << '\n';
+  }
+
+protected:
+  std::ostream& _os; /*!< Output stream */
+}; /* pla_writer */
+
+/*! \brief A PLA reader for prettyprinting PLA.
+ *
+ * Callbacks for prettyprinting of PLA.
+ *
+ */
+class pla_pretty_printer : public pla_reader
+{
+public:
+  /*! \brief Constructor of the PLA pretty printer.
+   *
+   * \param os Output stream
+   */
+  pla_pretty_printer( std::ostream& os = std::cout )
+      : _os( os )
+  {
+  }
+
+  virtual void on_number_of_inputs( uint64_t number_of_inputs ) const override
+  {
+    _os << ".i " << number_of_inputs << std::endl;
+  }
+
+  virtual void on_number_of_outputs( uint64_t number_of_outputs ) const override
+  {
+    _os << ".o " << number_of_outputs << std::endl;
+  }
+
+  virtual void on_number_of_terms( uint64_t number_of_terms ) const override
+  {
+    _os << ".p " << number_of_terms << std::endl;
+  }
+
+  virtual bool on_keyword( const std::string& keyword, const std::string& value ) const override
+  {
+    _os << fmt::format( ".{} {}", keyword, value ) << std::endl;
+    return true;
+  }
+
+  virtual void on_end() const override
+  {
+    _os << ".e" << std::endl;
+  }
+
+  virtual void on_term( const std::string& term, const std::string& out ) const override
+  {
+    _os << term << ' ' << out << std::endl;
+  }
+
+  std::ostream& _os; /*!< Output stream */
+}; /* pla_pretty_printer */
+
+namespace pla_regex
+{
+static std::regex keyword( R"(^\.([^\s]*)(?:\s+(.+))?$)" );
+static std::regex term( R"(^([01\-]+)\s+([01\-]+)$)" );
+
+} // namespace pla_regex
+
+/*! \brief Reader function for the PLA format.
+ *
+ * Reads PLA format from a stream and invokes a callback
+ * method for each parsed primitive and each detected parse error.
+ *
+ * \param in Input stream
+ * \param reader A PLA reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_pla( std::istream& in, const pla_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  auto loc = 0ul;
+  auto errors = 0ul;
+
+  std::smatch m;
+  detail::foreach_line_in_file_escape( in, [&]( const std::string& line ) {
+    ++loc;
+
+    /* empty line or comment */
+    if ( line.empty() || line[0u] == '#' )
+      return true;
+
+    if ( std::regex_search( line, m, pla_regex::keyword ) )
+    {
+      if ( m[1] == "i" )
+      {
+        reader.on_number_of_inputs( std::atol( std::string( m[2] ).c_str() ) );
+        return true;
+      }
+      else if ( m[1] == "o" )
+      {
+        reader.on_number_of_outputs( std::atol( std::string( m[2] ).c_str() ) );
+        return true;
+      }
+      else if ( m[1] == "p" )
+      {
+        reader.on_number_of_terms( std::atol( std::string( m[2] ).c_str() ) );
+        return true;
+      }
+      else if ( m[1] == "e" )
+      {
+        reader.on_end();
+        return true;
+      }
+      else
+      {
+        if ( reader.on_keyword( std::string( m[1] ), std::string( m[2] ) ) )
+        {
+          return true;
+        }
+
+        if ( diag )
+        {
+          diag->report( diag_id::ERR_UNSUPPORTED_KEYWORD ).add_argument( line );
+        }
+        ++errors;
+        return true; /* understood error case, go on parsing */
+      }
+    }
+
+    /* [01-]+ [01-]+ */
+    if ( std::regex_match( line, m, pla_regex::term ) )
+    {
+      std::string out = m[2];
+      reader.on_term( m[1], m[2] );
+      return true;
+    }
+
+    if ( diag )
+    {
+      diag->report( diag_id::ERR_PARSE_LINE ).add_argument( line );
+    }
+    ++errors;
+    return true; /* understood error case, go on parsing */
+  } );
+
+  if ( errors > 0 )
+  {
+    return return_code::parse_error;
+  }
+  else
+  {
+    return return_code::success;
+  }
+}
+
+/*! \brief Reader function for PLA format.
+ *
+ * Reads PLA format from a file and invokes a callback method for each
+ * parsed primitive and each detected parse error.
+ *
+ * \param filename Name of the file
+ * \param reader A PLA reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_pla( const std::string& filename, const pla_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  std::ifstream in( detail::word_exp_filename( filename ), std::ifstream::in );
+  if ( !in.is_open() )
+  {
+    if ( diag )
+    {
+      diag->report( diag_id::ERR_FILE_OPEN ).add_argument( filename );
+    }
+    return return_code::parse_error;
+  }
+  else
+  {
+    auto const ret = read_pla( in, reader, diag );
+    in.close();
+    return ret;
+  }
+}
+
+} // namespace lorina
diff --git a/lib/lorina/lorina/super.hpp b/lib/lorina/lorina/super.hpp
new file mode 100644
index 0000000..7cd0f44
--- /dev/null
+++ b/lib/lorina/lorina/super.hpp
@@ -0,0 +1,287 @@
+/* lorina: C++ parsing library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file super.hpp
+  \brief Implements SUPER parser for files generated by ABC
+
+  \author Alessandro Tempia Calvino
+  \author Shubham Rai
+*/
+
+#pragma once
+
+#include "common.hpp"
+#include "detail/utils.hpp"
+#include "diagnostics.hpp"
+#include <fstream>
+#include <istream>
+#include <optional>
+#include <sstream>
+#include <string>
+
+namespace lorina
+{
+
+/*! \brief A reader visitor for a super format.
+ *
+ * Callbacks for the super format.
+ */
+class super_reader
+{
+public:
+  virtual void on_super_info( std::string const& genlib_name, uint32_t max_num_vars, uint32_t max_supergates, uint32_t num_lines ) const
+  {
+    (void) genlib_name;
+    (void) max_num_vars;
+    (void) max_supergates;
+    (void) num_lines;
+  }
+
+  virtual void on_supergate( std::string const& name, bool const& is_super, std::vector<uint32_t> const& fanins_id ) const
+  {
+    (void)name;
+    (void)is_super;
+    (void)fanins_id;
+  }
+}; /* super_reader */
+
+/*! \brief Parse for the SUPER format.
+ *
+ */
+class super_parser
+{
+public:
+  explicit super_parser( std::istream& in, super_reader const& reader, diagnostic_engine* diag )
+      : in( in )
+      , reader( reader )
+      , diag( diag )
+  {
+  }
+
+public:
+  bool run()
+  {
+    std::string line;
+    uint32_t info_lines = 0u;
+    uint32_t max_num_vars = 0u;
+
+    std::vector<std::string> info_vec;
+
+    while ( std::getline( in, line ) )
+    {
+      /* remove whitespaces */
+      detail::trim( line );
+
+      /* skip comments and empty lines */
+      if ( line[0] == '#' || line[0] == '\0' || line.empty() )
+      {
+        continue;
+      }
+
+      if ( info_lines < 4 )
+      {
+        if ( !parse_file_info( line, info_vec ) )
+        {
+          return false;
+        }
+        if ( info_lines == 1 )
+        {
+          max_num_vars = std::stod( info_vec[1] );
+        }
+        ++info_lines;
+      }
+      else
+      {
+        if ( !parse_gate_definition( line, max_num_vars ) )
+        {
+          return false;
+        }
+      }
+    }
+
+    return true;
+  }
+
+private:
+  bool parse_file_info( std::string const& line, std::vector<std::string>& info_vec )
+  {
+    std::stringstream ss( line );
+    std::string token;
+
+    std::vector<std::string> tokens;
+
+    while ( std::getline( ss, token ) )
+    {
+      tokens.emplace_back( token );
+      info_vec.emplace_back( token );
+    }
+
+    if ( line.find_first_of( " " ) != std::string::npos )
+    {
+      if ( diag )
+      {
+        diag->report( diag_id::ERR_SUPER_INFO ).add_argument( line );
+      }
+      return false;
+    }
+
+    if ( info_vec.size() == 4 )
+    {
+      reader.on_super_info( info_vec[0], std::stoi( info_vec[1] ), std::stoi( info_vec[2] ), std::stoi( info_vec[3] ) );
+    }
+
+    return true;
+  }
+
+  bool parse_gate_definition( std::string const& line, uint32_t const& max_num_vars )
+  {
+    std::stringstream ss( line );
+    std::string const deliminators{ " \t\r\n" };
+
+    std::string token;
+    std::vector<std::string> tokens;
+
+    std::string name;
+    std::vector<uint32_t> fanins_id;
+
+    while ( std::getline( ss, token ) )
+    {
+      std::size_t prev = 0, pos;
+      while ( ( pos = line.find_first_of( deliminators, prev ) ) != std::string::npos )
+      {
+        if ( pos > prev )
+        {
+          tokens.emplace_back( token.substr( prev, pos - prev ) );
+        }
+        prev = pos + 1;
+      }
+
+      if ( prev < line.length() )
+      {
+        tokens.emplace_back( token.substr( prev, std::string::npos ) );
+      }
+    }
+
+    if ( tokens.size() < 2 || tokens.size() > max_num_vars + 2 )
+    {
+      if ( diag )
+      {
+        diag->report( diag_id::ERR_SUPER_UNEXPECTED_STRUCTURE ).add_argument( line );
+      }
+      return false;
+    }
+
+    bool is_super = false;
+    uint64_t i{2};
+    if ( tokens[0] == "*" )
+    {
+      is_super = true;
+      name = tokens[1];
+    }
+    else
+    {
+      name = tokens[0];
+      i = 1u;
+    }
+
+    for ( auto j = i; j < tokens.size(); ++j )
+    {
+      fanins_id.emplace_back( std::stod( tokens[j] ) );
+    }
+
+    if ( fanins_id.size() == 0 )
+    {
+      if ( diag )
+      {
+        diag->report( diag_id::ERR_SUPER_GATE ).add_argument( line );
+      }
+      return false;
+    }
+
+    reader.on_supergate( name, is_super, fanins_id );
+    return true;
+  }
+
+protected:
+  std::istream& in;
+  super_reader const& reader;
+  diagnostic_engine* diag;
+}; /* super_parser */
+
+/*! \brief Reader function for the SUPER format.
+ *
+ * Reads SUPER format from a stream and invokes a callback
+ * method for each parsed primitive and each detected parse error.
+ *
+ * \param in Input stream
+ * \param reader SUPER reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_super( std::istream& in, const super_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  super_parser parser( in, reader, diag );
+  auto result = parser.run();
+  if ( !result )
+  {
+    return return_code::parse_error;
+  }
+  else
+  {
+    return return_code::success;
+  }
+}
+
+/*! \brief Reader function for the SUPER format.
+ *
+ * Reads SUPER format from a .super file generated by ABC and invokes a callback
+ * method for each parsed primitive and each detected parse error.
+ *
+ * \param filename Name of the file
+ * \param reader SUPER reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_super( const std::string& filename, const super_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  std::ifstream in( detail::word_exp_filename( filename ), std::ifstream::in );
+  if ( !in.is_open() )
+  {
+    if ( diag )
+    {
+      diag->report( diag_id::ERR_FILE_OPEN ).add_argument( filename );
+    }
+    return return_code::parse_error;
+  }
+  else
+  {
+    auto const ret = read_super( in, reader, diag );
+    in.close();
+    return ret;
+  }
+}
+
+} // namespace lorina
diff --git a/lib/lorina/lorina/verilog.hpp b/lib/lorina/lorina/verilog.hpp
new file mode 100644
index 0000000..1e34ea5
--- /dev/null
+++ b/lib/lorina/lorina/verilog.hpp
@@ -0,0 +1,1774 @@
+/* lorina: C++ parsing library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file verilog.hpp
+  \brief Implements simplistic Verilog parser
+
+  \author Heinz Riener
+  \author Mathias Soeken
+  \author Siang-Yun (Sonia) Lee
+*/
+
+#pragma once
+
+#include "common.hpp"
+#include "detail/tokenizer.hpp"
+#include "detail/utils.hpp"
+#include "diagnostics.hpp"
+#include "verilog_regex.hpp"
+#include <iostream>
+#include <queue>
+
+namespace lorina
+{
+
+/*! \brief A reader visitor for a simplistic VERILOG format.
+ *
+ * Callbacks for the VERILOG format.
+ */
+class verilog_reader
+{
+public:
+  /*! \brief Callback method for parsed module.
+   *
+   * \param module_name Name of the module
+   * \param inouts Container for input and output names
+   */
+  virtual void on_module_header( const std::string& module_name, const std::vector<std::string>& inouts ) const
+  {
+    (void)module_name;
+    (void)inouts;
+  }
+
+  /*! \brief Callback method for parsed inputs.
+   *
+   * \param inputs Input names
+   * \param size Size modifier
+   */
+  virtual void on_inputs( const std::vector<std::string>& inputs, std::string const& size = "" ) const
+  {
+    (void)inputs;
+    (void)size;
+  }
+
+  /*! \brief Callback method for parsed outputs.
+   *
+   * \param outputs Output names
+   * \param size Size modifier
+   */
+  virtual void on_outputs( const std::vector<std::string>& outputs, std::string const& size = "" ) const
+  {
+    (void)outputs;
+    (void)size;
+  }
+
+  /*! \brief Callback method for parsed wires.
+   *
+   * \param wires Wire names
+   * \param size Size modifier
+   */
+  virtual void on_wires( const std::vector<std::string>& wires, std::string const& size = "" ) const
+  {
+    (void)wires;
+    (void)size;
+  }
+
+  /*! \brief Callback method for parsed parameter definition of form ` parameter M = 10;`.
+   *
+   * \param name Name of the parameter
+   * \param value Value of the parameter
+   */
+  virtual void on_parameter( const std::string& name, const std::string& value ) const
+  {
+    (void)name;
+    (void)value;
+  }
+
+  /*! \brief Callback method for parsed immediate assignment of form `LHS = RHS ;`.
+   *
+   * \param lhs Left-hand side of assignment
+   * \param rhs Right-hand side of assignment
+   */
+  virtual void on_assign( const std::string& lhs, const std::pair<std::string, bool>& rhs ) const
+  {
+    (void)lhs;
+    (void)rhs;
+  }
+
+  /*! \brief Callback method for parsed module instantiation of form `NAME #(P1,P2) NAME(.SIGNAL(SIGANL), ..., .SIGNAL(SIGNAL));`
+   *
+   * \param module_name Name of the module
+   * \param params List of parameters
+   * \param inst_name Name of the instantiation
+   * \param args List (a_1,b_1), ..., (a_n,b_n) of name pairs, where
+   *             a_i is a name of a signals in module_name and b_i is a name of a
+   *             signal in inst_name.
+   */
+  virtual void on_module_instantiation( std::string const& module_name, std::vector<std::string> const& params, std::string const& inst_name,
+                                        std::vector<std::pair<std::string, std::string>> const& args ) const
+  {
+    (void)module_name;
+    (void)params;
+    (void)inst_name;
+    (void)args;
+  }
+
+  /*! \brief Callback method for parsed AND-gate with 2 operands `LHS = OP1 & OP2 ;`.
+   *
+   * \param lhs Left-hand side of assignment
+   * \param op1 operand1 of assignment
+   * \param op2 operand2 of assignment
+   */
+  virtual void on_and( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2 ) const
+  {
+    (void)lhs;
+    (void)op1;
+    (void)op2;
+  }
+
+  /*! \brief Callback method for parsed NAND-gate with 2 operands `LHS = ~(OP1 & OP2) ;`.
+   *
+   * \param lhs Left-hand side of assignment
+   * \param op1 operand1 of assignment
+   * \param op2 operand2 of assignment
+   */
+  virtual void on_nand( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2 ) const
+  {
+    (void)lhs;
+    (void)op1;
+    (void)op2;
+  }
+
+  /*! \brief Callback method for parsed OR-gate with 2 operands `LHS = OP1 | OP2 ;`.
+   *
+   * \param lhs Left-hand side of assignment
+   * \param op1 operand1 of assignment
+   * \param op2 operand2 of assignment
+   */
+  virtual void on_or( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2 ) const
+  {
+    (void)lhs;
+    (void)op1;
+    (void)op2;
+  }
+
+  /*! \brief Callback method for parsed NOR-gate with 2 operands `LHS = ~(OP1 | OP2) ;`.
+   *
+   * \param lhs Left-hand side of assignment
+   * \param op1 operand1 of assignment
+   * \param op2 operand2 of assignment
+   */
+  virtual void on_nor( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2 ) const
+  {
+    (void)lhs;
+    (void)op1;
+    (void)op2;
+  }
+
+  /*! \brief Callback method for parsed XOR-gate with 2 operands `LHS = OP1 ^ OP2 ;`.
+   *
+   * \param lhs Left-hand side of assignment
+   * \param op1 operand1 of assignment
+   * \param op2 operand2 of assignment
+   */
+  virtual void on_xor( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2 ) const
+  {
+    (void)lhs;
+    (void)op1;
+    (void)op2;
+  }
+
+  /*! \brief Callback method for parsed XOR-gate with 2 operands `LHS = ~(OP1 ^ OP2) ;`.
+   *
+   * \param lhs Left-hand side of assignment
+   * \param op1 operand1 of assignment
+   * \param op2 operand2 of assignment
+   */
+  virtual void on_xnor( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2 ) const
+  {
+    (void)lhs;
+    (void)op1;
+    (void)op2;
+  }
+
+  /*! \brief Callback method for parsed AND-gate with 3 operands `LHS = OP1 & OP2 & OP3 ;`.
+   *
+   * \param lhs Left-hand side of assignment
+   * \param op1 operand1 of assignment
+   * \param op2 operand2 of assignment
+   * \param op3 operand3 of assignment
+   */
+  virtual void on_and3( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2, const std::pair<std::string, bool>& op3 ) const
+  {
+    (void)lhs;
+    (void)op1;
+    (void)op2;
+    (void)op3;
+  }
+
+  /*! \brief Callback method for parsed OR-gate with 3 operands `LHS = OP1 | OP2 | OP3 ;`.
+   *
+   * \param lhs Left-hand side of assignment
+   * \param op1 operand1 of assignment
+   * \param op2 operand2 of assignment
+   * \param op3 operand3 of assignment
+   */
+  virtual void on_or3( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2, const std::pair<std::string, bool>& op3 ) const
+  {
+    (void)lhs;
+    (void)op1;
+    (void)op2;
+    (void)op3;
+  }
+
+  /*! \brief Callback method for parsed XOR-gate with 3 operands `LHS = OP1 ^ OP2 ^ OP3 ;`.
+   *
+   * \param lhs Left-hand side of assignment
+   * \param op1 operand1 of assignment
+   * \param op2 operand2 of assignment
+   * \param op3 operand3 of assignment
+   */
+  virtual void on_xor3( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2, const std::pair<std::string, bool>& op3 ) const
+  {
+    (void)lhs;
+    (void)op1;
+    (void)op2;
+    (void)op3;
+  }
+
+  /*! \brief Callback method for parsed majority-of-3 gate `LHS = ( OP1 & OP2 ) | ( OP1 & OP3 ) | ( OP2 & OP3 ) ;`.
+   *
+   * \param lhs Left-hand side of assignment
+   * \param op1 operand1 of assignment
+   * \param op2 operand2 of assignment
+   * \param op3 operand3 of assignment
+   */
+  virtual void on_maj3( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2, const std::pair<std::string, bool>& op3 ) const
+  {
+    (void)lhs;
+    (void)op1;
+    (void)op2;
+    (void)op3;
+  }
+
+  /*! \brief Callback method for parsed 2-to-1 multiplexer gate `LHS = OP1 ? OP2 : OP3 ;`.
+   *
+   * \param lhs Left-hand side of assignment
+   * \param op1 operand1 of assignment
+   * \param op2 operand2 of assignment
+   * \param op3 operand3 of assignment
+   */
+  virtual void on_mux21( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2, const std::pair<std::string, bool>& op3 ) const
+  {
+    (void)lhs;
+    (void)op1;
+    (void)op2;
+    (void)op3;
+  }
+
+  /*! \brief Callback method for parsed comments `// comment string`.
+   *
+   * \param comment Comment string
+   */
+  virtual void on_comment( std::string const& comment ) const
+  {
+    (void)comment;
+  }
+
+  /*! \brief Callback method for parsed endmodule.
+   *
+   */
+  virtual void on_endmodule() const {}
+}; /* verilog_reader */
+
+/*! \brief A VERILOG reader for prettyprinting a simplistic VERILOG format.
+ *
+ * Callbacks for prettyprinting of BLIF.
+ *
+ */
+class verilog_pretty_printer : public verilog_reader
+{
+public:
+  /*! \brief Constructor of the VERILOG pretty printer.
+   *
+   * \param os Output stream
+   */
+  verilog_pretty_printer( std::ostream& os = std::cout )
+      : _os( os )
+  {
+  }
+
+  void on_module_header( const std::string& module_name, const std::vector<std::string>& inouts ) const override
+  {
+    std::string params;
+    if ( inouts.size() > 0 )
+    {
+      params = inouts[0];
+      for ( auto i = 1u; i < inouts.size(); ++i )
+      {
+        params += " , ";
+        params += inouts[i];
+      }
+    }
+    _os << fmt::format( "module {}( {} ) ;\n", module_name, params );
+  }
+
+  void on_inputs( const std::vector<std::string>& inputs, std::string const& size = "" ) const override
+  {
+    if ( inputs.size() == 0 )
+      return;
+    _os << "input ";
+    if ( size != "" )
+      _os << "[" << size << "] ";
+
+    _os << inputs[0];
+    for ( auto i = 1u; i < inputs.size(); ++i )
+    {
+      _os << " , ";
+      _os << inputs[i];
+    }
+    _os << " ;\n";
+  }
+
+  void on_outputs( const std::vector<std::string>& outputs, std::string const& size = "" ) const override
+  {
+    if ( outputs.size() == 0 )
+      return;
+    _os << "output ";
+    if ( size != "" )
+      _os << "[" << size << "] ";
+
+    _os << outputs[0];
+    for ( auto i = 1u; i < outputs.size(); ++i )
+    {
+      _os << " , ";
+      _os << outputs[i];
+    }
+    _os << " ;\n";
+  }
+
+  void on_wires( const std::vector<std::string>& wires, std::string const& size = "" ) const override
+  {
+    if ( wires.size() == 0 )
+      return;
+    _os << "wire ";
+    if ( size != "" )
+      _os << "[" << size << "] ";
+
+    _os << wires[0];
+    for ( auto i = 1u; i < wires.size(); ++i )
+    {
+      _os << " , ";
+      _os << wires[i];
+    }
+    _os << " ;\n";
+  }
+
+  void on_parameter( const std::string& name, const std::string& value ) const override
+  {
+    _os << "parameter " << name << " = " << value << ";\n";
+  }
+
+  void on_assign( const std::string& lhs, const std::pair<std::string, bool>& rhs ) const override
+  {
+    const std::string param = rhs.second ? fmt::format( "~{}", rhs.first ) : rhs.first;
+    _os << fmt::format( "assign {} = {} ;\n", lhs, param );
+  }
+
+  virtual void on_module_instantiation( std::string const& module_name, std::vector<std::string> const& params, std::string const& inst_name,
+                                        std::vector<std::pair<std::string, std::string>> const& args ) const override
+  {
+    _os << module_name << " ";
+    if ( params.size() > 0u )
+    {
+      _os << "#(";
+      for ( auto i = 0u; i < params.size(); ++i )
+      {
+        _os << params.at( i );
+        if ( i + 1 < params.size() )
+          _os << ", ";
+      }
+      _os << ")";
+    }
+
+    _os << " " << inst_name << "(";
+    for ( auto i = 0u; i < args.size(); ++i )
+    {
+      _os << args.at( i ).first << "(" << args.at( i ).second << ")";
+      if ( i + 1 < args.size() )
+        _os << ", ";
+    }
+    _os << ")";
+
+    _os << ";\n";
+  }
+
+  void on_and( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2 ) const override
+  {
+    const std::string p1 = op1.second ? fmt::format( "~{}", op1.first ) : op1.first;
+    const std::string p2 = op2.second ? fmt::format( "~{}", op2.first ) : op2.first;
+    _os << fmt::format( "assign {} = {} & {} ;\n", lhs, p1, p2 );
+  }
+
+  void on_nand( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2 ) const override
+  {
+    const std::string p1 = op1.second ? fmt::format( "~{}", op1.first ) : op1.first;
+    const std::string p2 = op2.second ? fmt::format( "~{}", op2.first ) : op2.first;
+    _os << fmt::format( "assign {} = ~({} & {}) ;\n", lhs, p1, p2 );
+  }
+
+  void on_or( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2 ) const override
+  {
+    const std::string p1 = op1.second ? fmt::format( "~{}", op1.first ) : op1.first;
+    const std::string p2 = op2.second ? fmt::format( "~{}", op2.first ) : op2.first;
+    _os << fmt::format( "assign {} = {} | {} ;\n", lhs, p1, p2 );
+  }
+
+  void on_nor( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2 ) const override
+  {
+    const std::string p1 = op1.second ? fmt::format( "~{}", op1.first ) : op1.first;
+    const std::string p2 = op2.second ? fmt::format( "~{}", op2.first ) : op2.first;
+    _os << fmt::format( "assign {} = ~({} | {}) ;\n", lhs, p1, p2 );
+  }
+
+  void on_xor( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2 ) const override
+  {
+    const std::string p1 = op1.second ? fmt::format( "~{}", op1.first ) : op1.first;
+    const std::string p2 = op2.second ? fmt::format( "~{}", op2.first ) : op2.first;
+    _os << fmt::format( "assign {} = {} ^ {} ;\n", lhs, p1, p2 );
+  }
+
+  void on_xnor( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2 ) const override
+  {
+    const std::string p1 = op1.second ? fmt::format( "~{}", op1.first ) : op1.first;
+    const std::string p2 = op2.second ? fmt::format( "~{}", op2.first ) : op2.first;
+    _os << fmt::format( "assign {} = ~({} ^ {}) ;\n", lhs, p1, p2 );
+  }
+
+  void on_and3( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2, const std::pair<std::string, bool>& op3 ) const override
+  {
+    const std::string p1 = op1.second ? fmt::format( "~{}", op1.first ) : op1.first;
+    const std::string p2 = op2.second ? fmt::format( "~{}", op2.first ) : op2.first;
+    const std::string p3 = op3.second ? fmt::format( "~{}", op3.first ) : op3.first;
+    _os << fmt::format( "assign {} = {} & {} & {} ;\n", lhs, p1, p2, p3 );
+  }
+
+  void on_or3( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2, const std::pair<std::string, bool>& op3 ) const override
+  {
+    const std::string p1 = op1.second ? fmt::format( "~{}", op1.first ) : op1.first;
+    const std::string p2 = op2.second ? fmt::format( "~{}", op2.first ) : op2.first;
+    const std::string p3 = op3.second ? fmt::format( "~{}", op3.first ) : op3.first;
+    _os << fmt::format( "assign {} = {} | {} | {} ;\n", lhs, p1, p2, p3 );
+  }
+
+  void on_xor3( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2, const std::pair<std::string, bool>& op3 ) const override
+  {
+    const std::string p1 = op1.second ? fmt::format( "~{}", op1.first ) : op1.first;
+    const std::string p2 = op2.second ? fmt::format( "~{}", op2.first ) : op2.first;
+    const std::string p3 = op3.second ? fmt::format( "~{}", op3.first ) : op3.first;
+    _os << fmt::format( "assign {} = {} ^ {} ^ {} ;\n", lhs, p1, p2, p3 );
+  }
+
+  void on_maj3( const std::string& lhs, const std::pair<std::string, bool>& op1, const std::pair<std::string, bool>& op2, const std::pair<std::string, bool>& op3 ) const override
+  {
+    const std::string p1 = op1.second ? fmt::format( "~{}", op1.first ) : op1.first;
+    const std::string p2 = op2.second ? fmt::format( "~{}", op2.first ) : op2.first;
+    const std::string p3 = op3.second ? fmt::format( "~{}", op3.first ) : op3.first;
+    _os << fmt::format( "assign {0} = ( {1} & {2} ) | ( {1} & {3} ) | ( {2} & {3} ) ;\n", lhs, p1, p2, p3 );
+  }
+
+  void on_endmodule() const override
+  {
+    _os << "endmodule\n"
+        << std::endl;
+  }
+
+  void on_comment( const std::string& comment ) const override
+  {
+    _os << "// " << comment << std::endl;
+  }
+
+  std::ostream& _os; /*!< Output stream */
+};                   /* verilog_pretty_printer */
+
+/*! \brief A writer for a simplistic VERILOG format.
+ *
+ * Callbacks for writing the VERILOG format.
+ *
+ */
+class verilog_writer
+{
+public:
+  /*! \brief Constructs a VERILOG writer.
+   *
+   * \param os Output stream
+   */
+  explicit verilog_writer( std::ostream& os )
+      : _os( os )
+  {
+  }
+
+  /*! \brief Callback method for writing begin of a module declaration.
+   *
+   * \param name Module name
+   * \param xs List of module inputs
+   * \param ys List of module outputs
+   */
+  virtual void on_module_begin( std::string const& name, std::vector<std::string> const& xs, std::vector<std::string> const& ys ) const
+  {
+    std::vector<std::string> names = xs;
+    std::copy( ys.begin(), ys.end(), std::back_inserter( names ) );
+
+    _os << fmt::format( "module {}( {} );\n", name, fmt::join( names, " , " ) );
+  }
+
+  /*! \brief Callback method for writing single 1-bit input.
+   *
+   * \param name Input name
+   */
+  virtual void on_input( std::string const& name ) const
+  {
+    _os << fmt::format( "  input {} ;\n", name );
+  }
+
+  /*! \brief Callback method for writing input register.
+   *
+   * \param width Register size
+   * \param name Input name
+   */
+  virtual void on_input( uint32_t width, std::string const& name ) const
+  {
+    _os << fmt::format( "  input [{}:0] {} ;\n", width - 1, name );
+  }
+
+  /*! \brief Callback method for writing multiple single 1-bit input.
+   *
+   * \param names Input names
+   */
+  virtual void on_input( std::vector<std::string> const& names ) const
+  {
+    _os << fmt::format( "  input {} ;\n", fmt::join( names, " , " ) );
+  }
+
+  /*! \brief Callback method for writing multiple input registers.
+   *
+   * \param width Register size
+   * \param names Input names
+   */
+  virtual void on_input( uint32_t width, std::vector<std::string> const& names ) const
+  {
+    _os << fmt::format( "  input [{}:0] {} ;\n", width - 1, fmt::join( names, " , " ) );
+  }
+
+  /*! \brief Callback method for writing single 1-bit output.
+   *
+   * \param name Output name
+   */
+  virtual void on_output( std::string const& name ) const
+  {
+    _os << fmt::format( "  output {} ;\n", name );
+  }
+
+  /*! \brief Callback method for writing output register.
+   *
+   * \param width Register size
+   * \param name Output name
+   */
+  virtual void on_output( uint32_t width, std::string const& name ) const
+  {
+    _os << fmt::format( "  output [{}:0] {} ;\n", width - 1, name );
+  }
+
+  /*! \brief Callback method for writing multiple single 1-bit output.
+   *
+   * \param names Output names
+   */
+  virtual void on_output( std::vector<std::string> const& names ) const
+  {
+    _os << fmt::format( "  output {} ;\n", fmt::join( names, " , " ) );
+  }
+
+  /*! \brief Callback method for writing multiple output registers.
+   *
+   * \param width Register size
+   * \param names Output names
+   */
+  virtual void on_output( uint32_t width, std::vector<std::string> const& names ) const
+  {
+    _os << fmt::format( "  output [{}:0] {} ;\n", width - 1, fmt::join( names, " , " ) );
+  }
+
+  /*! \brief Callback method for writing single 1-bit wire.
+   *
+   * \param name Wire name
+   */
+  virtual void on_wire( std::string const& name ) const
+  {
+    _os << fmt::format( "  wire {} ;\n", name );
+  }
+
+  /*! \brief Callback method for writing wire register.
+   *
+   * \param width Register size
+   * \param name Wire name
+   */
+  virtual void on_wire( uint32_t width, std::string const& name ) const
+  {
+    _os << fmt::format( "  wire [{}:0] {} ;\n", width - 1, name );
+  }
+
+  /*! \brief Callback method for writing multiple single 1-bit wire.
+   *
+   * \param names Wire names
+   */
+  virtual void on_wire( std::vector<std::string> const& names ) const
+  {
+    _os << fmt::format( "  wire {} ;\n", fmt::join( names, " , " ) );
+  }
+
+  /*! \brief Callback method for writing multiple wire registers.
+   *
+   * \param width Register size
+   * \param names Wire names
+   */
+  virtual void on_wire( uint32_t width, std::vector<std::string> const& names ) const
+  {
+    _os << fmt::format( "  wire [{}:0] {} ;\n", width - 1, fmt::join( names, " , " ) );
+  }
+
+  /*! \brief Callback method for writing end of a module declaration. */
+  virtual void on_module_end() const
+  {
+    _os << "endmodule" << std::endl;
+  }
+
+  /*! \brief Callback method for writing a module instantiation.
+   *
+   * \param module_name Module name
+   * \param params List of parameters
+   * \param inst_name Instance name
+   * \param args List of arguments (first: I/O pin name, second: wire name)
+   */
+  virtual void on_module_instantiation( std::string const& module_name, std::vector<std::string> const& params, std::string const& inst_name,
+                                        std::vector<std::pair<std::string, std::string>> const& args ) const
+  {
+    _os << fmt::format( "  {} ", module_name );
+    if ( params.size() > 0u )
+    {
+      _os << "#(";
+      for ( auto i = 0u; i < params.size(); ++i )
+      {
+        _os << params.at( i );
+        if ( i + 1 < params.size() )
+          _os << ", ";
+      }
+      _os << ") ";
+    }
+
+    _os << fmt::format( "{}( ", inst_name );
+    for ( auto i = 0u; i < args.size(); ++i )
+    {
+      _os << fmt::format( ".{} ({})", args.at( i ).first, args.at( i ).second );
+      if ( i + 1 < args.size() )
+        _os << ", ";
+    }
+    _os << " );\n";
+  }
+
+  /*! \brief Callback method for writing an assignment statement.
+   *
+   * \param out Output signal
+   * \param ins List of input signals
+   * \param op Operator
+   */
+  virtual void on_assign( std::string const& out, std::vector<std::pair<bool, std::string>> const& ins, std::string const& op ) const
+  {
+    std::string args;
+
+    /* assemble arguments */
+    for ( auto i = 0u; i < ins.size(); ++i )
+    {
+      args.append( fmt::format( "{}{}", ins.at( i ).first ? "~" : "", ins.at( i ).second ) );
+      if ( i != ins.size() - 1 )
+        args.append( fmt::format( " {} ", op ) );
+    }
+
+    _os << fmt::format( "  assign {} = {} ;\n", out, args );
+  }
+
+  /*! \brief Callback method for writing a maj3 assignment statement.
+   *
+   * \param out Output signal
+   * \param ins List of three input signals
+   */
+  virtual void on_assign_maj3( std::string const& out, std::vector<std::pair<bool, std::string>> const& ins ) const
+  {
+    assert( ins.size() == 3u );
+    _os << fmt::format( "  assign {0} = ( {1}{2} & {3}{4} ) | ( {1}{2} & {5}{6} ) | ( {3}{4} & {5}{6} ) ;\n",
+                        out,
+                        ins.at( 0 ).first ? "~" : "", ins.at( 0 ).second,
+                        ins.at( 1 ).first ? "~" : "", ins.at( 1 ).second,
+                        ins.at( 2 ).first ? "~" : "", ins.at( 2 ).second );
+  }
+
+  /*! \brief Callback method for writing a 2-to-1 multiplexer (ITE) assignment statement.
+   *
+   * \param out Output signal
+   * \param ins List of three input signals, in the order (if, then, else)
+   */
+  virtual void on_assign_mux21( std::string const& out, std::vector<std::pair<bool, std::string>> const& ins ) const
+  {
+    assert( ins.size() == 3u );
+    _os << fmt::format( "  assign {0} = {1}{2} ? {3}{4} : {5}{6} ;\n",
+                        out,
+                        ins.at( 0 ).first ? "~" : "", ins.at( 0 ).second,
+                        ins.at( 1 ).first ? "~" : "", ins.at( 1 ).second,
+                        ins.at( 2 ).first ? "~" : "", ins.at( 2 ).second );
+  }
+
+  /*! \brief Callback method for writing an assignment statement with unknown operator.
+   *
+   * \param out Output signal
+   */
+  virtual void on_assign_unknown_gate( std::string const& out ) const
+  {
+    _os << fmt::format( "  assign {} = unknown gate;\n", out );
+  }
+
+  /*! \brief Callback method for writing a maj3 assignment statement.
+   *
+   * \param out Output signal
+   * \param in An input signal
+   */
+  virtual void on_assign_po( std::string const& out, std::pair<bool, std::string> const& in ) const
+  {
+    _os << fmt::format( "  assign {} = {}{} ;\n",
+                        out,
+                        in.first ? "~" : "", in.second );
+  }
+
+protected:
+  std::ostream& _os; /*!< Output stream */
+};                   /* verilog_writer */
+
+/*! \brief Simple parser for VERILOG format.
+ *
+ * Simplistic grammar-oriented parser for a structural VERILOG format.
+ *
+ */
+class verilog_parser
+{
+public:
+  struct module_info
+  {
+    std::vector<std::string> inputs;
+    std::vector<std::string> outputs;
+  };
+
+public:
+  /*! \brief Construct a VERILOG parser
+   *
+   * \param in Input stream
+   * \param reader A verilog reader
+   * \param diag A diagnostic engine
+   */
+  verilog_parser( std::istream& in,
+                  const verilog_reader& reader,
+                  diagnostic_engine* diag = nullptr )
+    : tok( in )
+    , reader( reader )
+    , diag( diag )
+    , on_action( PackedFns( GateFn( [&]( const std::vector<std::pair<std::string, bool>>& inputs,
+                                         const std::string output,
+                                         const std::string type )
+                                    {
+                                      if ( type == "assign" )
+                                      {
+                                        assert( inputs.size() == 1u );
+                                        reader.on_assign( output, inputs[0] );
+                                      }
+                                      else if ( type == "and2" )
+                                      {
+                                        assert( inputs.size() == 2u );
+                                        reader.on_and( output, inputs[0], inputs[1] );
+                                      }
+                                      else if ( type == "nand2" )
+                                      {
+                                        assert( inputs.size() == 2u );
+                                        reader.on_nand( output, inputs[0], inputs[1] );
+                                      }
+                                      else if ( type == "or2" )
+                                      {
+                                        assert( inputs.size() == 2u );
+                                        reader.on_or( output, inputs[0], inputs[1] );
+                                      }
+                                      else if ( type == "nor2" )
+                                      {
+                                        assert( inputs.size() == 2u );
+                                        reader.on_nor( output, inputs[0], inputs[1] );
+                                      }
+                                      else if ( type == "xor2" )
+                                      {
+                                        assert( inputs.size() == 2u );
+                                        reader.on_xor( output, inputs[0], inputs[1] );
+                                      }
+                                      else if ( type == "xnor2" )
+                                      {
+                                        assert( inputs.size() == 2u );
+                                        reader.on_xnor( output, inputs[0], inputs[1] );
+                                      }
+                                      else if ( type == "and3" )
+                                      {
+                                        assert( inputs.size() == 3u );
+                                        reader.on_and3( output, inputs[0], inputs[1], inputs[2] );
+                                      }
+                                      else if ( type == "or3" )
+                                      {
+                                        assert( inputs.size() == 3u );
+                                        reader.on_or3( output, inputs[0], inputs[1], inputs[2] );
+                                      }
+                                      else if ( type == "xor3" )
+                                      {
+                                        assert( inputs.size() == 3u );
+                                        reader.on_xor3( output, inputs[0], inputs[1], inputs[2] );
+                                      }
+                                      else if ( type == "maj3" )
+                                      {
+                                        assert( inputs.size() == 3u );
+                                        reader.on_maj3( output, inputs[0], inputs[1], inputs[2] );
+                                      }
+                                      else if ( type == "mux21" )
+                                      {
+                                        assert( inputs.size() == 3u );
+                                        reader.on_mux21( output, inputs[0], inputs[1], inputs[2] );
+                                      }
+                                      else
+                                      {
+                                        assert( false && "unknown gate function" );
+                                        std::cerr << "unknown gate function" << std::endl;
+                                        std::abort();
+                                      }
+                                    } ),
+                      ModuleInstFn( [&]( const std::string module_name,
+                                         const std::vector<std::string>& params,
+                                         const std::string instance_name,
+                                         const std::vector<std::pair<std::string, std::string>>& pin_to_pin )
+                                    {
+                                      reader.on_module_instantiation( module_name, params, instance_name, pin_to_pin );
+                                    } )
+                      ) )
+  {
+    on_action.declare_known( "0" );
+    on_action.declare_known( "1" );
+    on_action.declare_known( "1'b0" );
+    on_action.declare_known( "1'b1" );
+  }
+
+  bool get_token( std::string& token )
+  {
+    detail::tokenizer_return_code result;
+    do
+    {
+      if ( tokens.empty() )
+      {
+        result = tok.get_token_internal( token );
+        detail::trim( token );
+      }
+      else
+      {
+        token = tokens.front();
+        tokens.pop();
+        return true;
+      }
+
+      /* switch to comment mode */
+      if ( token == "//" && result == detail::tokenizer_return_code::valid )
+      {
+        tok.set_comment_mode();
+      }
+      else if ( result == detail::tokenizer_return_code::comment )
+      {
+        reader.on_comment( token );
+      }
+      /* keep parsing if token is empty or if in the middle or at the end of a comment */
+    } while ( ( token == "" && result == detail::tokenizer_return_code::valid ) ||
+              tok.get_comment_mode() ||
+              result == detail::tokenizer_return_code::comment );
+
+    return ( result == detail::tokenizer_return_code::valid );
+  }
+
+  void push_token( std::string const& token )
+  {
+    tokens.push( token );
+  }
+
+  bool parse_signal_name()
+  {
+    valid = get_token( token ); // name
+    if ( !valid || token == "[" )
+      return false;
+    auto const name = token;
+
+    valid = get_token( token );
+    if ( token == "[" )
+    {
+      valid = get_token( token ); // size
+      if ( !valid )
+        return false;
+      auto const size = token;
+
+      valid = get_token( token ); // size
+      if ( !valid && token != "]" )
+        return false;
+      token = name + "[" + size + "]";
+
+      return true;
+    }
+
+    push_token( token );
+
+    token = name;
+    return true;
+  }
+
+  bool parse_modules()
+  {
+    while ( get_token( token ) )
+    {
+      if ( token != "module" )
+      {
+        return false;
+      }
+
+      if ( !parse_module() )
+      {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool parse_module()
+  {
+    bool success = parse_module_header();
+    if ( !success )
+    {
+      if ( diag )
+      {
+        diag->report( diag_id::ERR_VERILOG_MODULE_HEADER );
+      }
+      return false;
+    }
+
+    do
+    {
+      valid = get_token( token );
+      if ( !valid )
+        return false;
+
+      if ( token == "input" )
+      {
+        success = parse_inputs();
+        if ( !success )
+        {
+          if ( diag )
+          {
+            diag->report( diag_id::ERR_VERILOG_INPUT_DECLARATION );
+          }
+          return false;
+        }
+      }
+      else if ( token == "output" )
+      {
+        success = parse_outputs();
+        if ( !success )
+        {
+          if ( diag )
+          {
+            diag->report( diag_id::ERR_VERILOG_OUTPUT_DECLARATION );
+          }
+          return false;
+        }
+      }
+      else if ( token == "wire" )
+      {
+        success = parse_wires();
+        if ( !success )
+        {
+          if ( diag )
+          {
+            diag->report( diag_id::ERR_VERILOG_WIRE_DECLARATION );
+          }
+          return false;
+        }
+      }
+      else if ( token == "parameter" )
+      {
+        success = parse_parameter();
+        if ( !success )
+        {
+          if ( diag )
+          {
+            diag->report( diag_id::ERR_VERILOG_WIRE_DECLARATION );
+          }
+          return false;
+        }
+      }
+      else
+      {
+        break;
+      }
+    } while ( token != "assign" && token != "endmodule" );
+
+    while ( token != "endmodule" )
+    {
+      if ( token == "assign" )
+      {
+        success = parse_assign();
+        if ( !success )
+        {
+          if ( diag )
+          {
+            diag->report( diag_id::ERR_VERILOG_ASSIGNMENT );
+          }
+          return false;
+        }
+
+        valid = get_token( token );
+        if ( !valid )
+          return false;
+      }
+      else
+      {
+        success = parse_module_instantiation();
+        if ( !success )
+        {
+          if ( diag )
+          {
+            diag->report( diag_id::ERR_VERILOG_MODULE_INSTANTIATION_STATEMENT );
+          }
+          return false;
+        }
+
+        valid = get_token( token );
+        if ( !valid )
+          return false;
+      }
+    }
+
+    /* check dangling objects */
+    bool result = true;
+    const auto& deps = on_action.unresolved_dependencies();
+    if ( deps.size() > 0 )
+      result = false;
+
+    for ( const auto& r : deps )
+    {
+      if ( diag )
+      {
+        diag->report( diag_id::WRN_UNRESOLVED_DEPENDENCY )
+            .add_argument( r.first )
+            .add_argument( r.second );
+      }
+    }
+
+    if ( !result )
+      return false;
+
+    if ( token == "endmodule" )
+    {
+      /* callback */
+      reader.on_endmodule();
+
+      return true;
+    }
+    else
+    {
+      return false;
+    }
+  }
+
+  bool parse_module_header()
+  {
+    if ( token != "module" )
+      return false;
+
+    valid = get_token( token );
+    if ( !valid )
+      return false;
+
+    module_name = token;
+
+    valid = get_token( token );
+    if ( !valid || token != "(" )
+      return false;
+
+    std::vector<std::string> inouts;
+    do
+    {
+      if ( !parse_signal_name() )
+        return false;
+      inouts.emplace_back( token );
+
+      valid = get_token( token ); // , or )
+      if ( !valid || ( token != "," && token != ")" ) )
+        return false;
+    } while ( valid && token != ")" );
+
+    valid = get_token( token );
+    if ( !valid || token != ";" )
+      return false;
+
+    /* callback */
+    reader.on_module_header( module_name, inouts );
+
+    return true;
+  }
+
+  bool parse_inputs()
+  {
+    std::vector<std::string> inputs;
+    if ( token != "input" )
+      return false;
+
+    std::string size = "";
+    if ( !parse_signal_name() && token == "[" )
+    {
+      do
+      {
+        valid = get_token( token );
+        if ( !valid )
+          return false;
+
+        if ( token != "]" )
+          size += token;
+      } while ( valid && token != "]" );
+
+      if ( !parse_signal_name() )
+        return false;
+    }
+    inputs.emplace_back( token );
+
+    while ( true )
+    {
+      valid = get_token( token );
+
+      if ( !valid || ( token != "," && token != ";" ) )
+        return false;
+
+      if ( token == ";" )
+        break;
+
+      if ( !parse_signal_name() )
+        return false;
+
+      inputs.emplace_back( token );
+    }
+
+    /* callback */
+    reader.on_inputs( inputs, size );
+    modules[module_name].inputs = inputs;
+
+    for ( const auto& i : inputs )
+    {
+      on_action.declare_known( i );
+    }
+
+    if ( std::smatch m; std::regex_match( size, m, verilog_regex::const_size_range ) )
+    {
+      const auto a = std::stoul( m[1].str() );
+      const auto b = std::stoul( m[2].str() );
+      for ( auto j = std::min( a, b ); j <= std::max( a, b ); ++j )
+      {
+        for ( const auto& i : inputs )
+        {
+          on_action.declare_known( fmt::format( "{}[{}]", i, j ) );
+        }
+      }
+    }
+
+    return true;
+  }
+
+  bool parse_outputs()
+  {
+    std::vector<std::string> outputs;
+    if ( token != "output" )
+      return false;
+
+    std::string size = "";
+    if ( !parse_signal_name() && token == "[" )
+    {
+      do
+      {
+        valid = get_token( token );
+        if ( !valid )
+          return false;
+
+        if ( token != "]" )
+          size += token;
+      } while ( valid && token != "]" );
+
+      if ( !parse_signal_name() )
+        return false;
+    }
+    outputs.emplace_back( token );
+
+    while ( true )
+    {
+      valid = get_token( token );
+
+      if ( !valid || ( token != "," && token != ";" ) )
+        return false;
+
+      if ( token == ";" )
+        break;
+
+      if ( !parse_signal_name() )
+        return false;
+
+      outputs.emplace_back( token );
+    }
+
+    /* callback */
+    reader.on_outputs( outputs, size );
+    modules[module_name].outputs = outputs;
+
+    return true;
+  }
+
+  bool parse_wires()
+  {
+    std::vector<std::string> wires;
+    if ( token != "wire" )
+      return false;
+
+    std::string size = "";
+    if ( !parse_signal_name() && token == "[" )
+    {
+      do
+      {
+        valid = get_token( token );
+        if ( !valid )
+          return false;
+
+        if ( token != "]" )
+          size += token;
+      } while ( valid && token != "]" );
+
+      if ( !parse_signal_name() )
+        return false;
+    }
+    wires.emplace_back( token );
+
+    while ( true )
+    {
+      valid = get_token( token );
+
+      if ( !valid || ( token != "," && token != ";" ) )
+        return false;
+
+      if ( token == ";" )
+        break;
+
+      if ( !parse_signal_name() )
+        return false;
+
+      wires.emplace_back( token );
+    }
+
+    /* callback */
+    reader.on_wires( wires, size );
+
+    return true;
+  }
+
+  bool parse_parameter()
+  {
+    if ( token != "parameter" )
+      return false;
+
+    valid = get_token( token );
+    if ( !valid )
+      return false;
+    auto const name = token;
+
+    valid = get_token( token );
+    if ( !valid || ( token != "=" ) )
+      return false;
+
+    valid = get_token( token );
+    if ( !valid )
+      return false;
+    auto const value = token;
+
+    valid = get_token( token );
+    if ( !valid || ( token != ";" ) )
+      return false;
+
+    /* callback */
+    reader.on_parameter( name, value );
+
+    return true;
+  }
+
+  bool parse_assign()
+  {
+    if ( token != "assign" )
+      return false;
+
+    if ( !parse_signal_name() )
+      return false;
+
+    const std::string lhs = token;
+    valid = get_token( token );
+    if ( !valid || token != "=" )
+      return false;
+
+    /* expression */
+    bool success = parse_rhs_expression( lhs );
+    if ( !success )
+    {
+      if ( diag )
+      {
+        diag->report( diag_id::ERR_VERILOG_ASSIGNMENT_RHS )
+            .add_argument( lhs );
+      }
+      return false;
+    }
+
+    if ( token != ";" )
+      return false;
+    return true;
+  }
+
+  bool parse_module_instantiation()
+  {
+    bool success = true;
+    std::string const module_name{token}; // name of module
+
+    auto const it = modules.find( module_name );
+    if ( it == std::end( modules ) )
+    {
+      if ( diag )
+      {
+        diag->report( diag_id::ERR_VERILOG_MODULE_INSTANTIATION_UNDECLARED_MODULE )
+            .add_argument( module_name );
+      }
+      return false;
+    }
+
+    /* get module info */
+    auto const& info = modules[module_name];
+
+    valid = get_token( token );
+    if ( !valid )
+      return false;
+
+    std::vector<std::string> params;
+    if ( token == "#" )
+    {
+      valid = get_token( token ); // (
+      if ( !valid || token != "(" )
+        return false;
+
+      do
+      {
+        valid = get_token( token ); // param
+        if ( !valid )
+          return false;
+        params.emplace_back( token );
+
+        valid = get_token( token ); // ,
+        if ( !valid )
+          return false;
+      } while ( valid && token == "," );
+
+      if ( !valid || token != ")" )
+        return false;
+
+      valid = get_token( token );
+      if ( !valid )
+        return false;
+    }
+
+    std::string const inst_name = token; // name of instantiation
+
+    valid = get_token( token );
+    if ( !valid || token != "(" )
+      return false;
+
+    std::vector<std::pair<std::string, std::string>> args;
+    do
+    {
+      valid = get_token( token );
+
+      if ( !valid )
+        return false; // refers to signal
+      std::string const arg0{token};
+
+      /* check if a signal with this name exists in the module declaration */
+      if ( ( std::find( std::begin( info.inputs ), std::end( info.inputs ), arg0.substr( 1, arg0.size() ) ) == std::end( info.inputs ) ) &&
+           ( std::find( std::begin( info.outputs ), std::end( info.outputs ), arg0.substr( 1, arg0.size() ) ) == std::end( info.outputs ) ) )
+      {
+        if ( diag )
+        {
+          diag->report( diag_id::ERR_VERILOG_MODULE_INSTANTIATION_UNDECLARED_PIN )
+              .add_argument( arg0.substr( 1, arg0.size() ) )
+              .add_argument( module_name );
+        }
+
+        success = false;
+      }
+
+      valid = get_token( token );
+      if ( !valid || token != "(" )
+        return false; // (
+
+      valid = get_token( token );
+      if ( !valid )
+        return false; // signal name
+      auto const arg1 = token;
+
+      valid = get_token( token );
+      if ( !valid || token != ")" )
+        return false; // )
+
+      valid = get_token( token );
+      if ( !valid )
+        return false;
+
+      args.emplace_back( std::make_pair( arg0, arg1 ) );
+    } while ( token == "," );
+
+    if ( !valid || token != ")" )
+      return false;
+
+    valid = get_token( token );
+    if ( !valid || token != ";" )
+      return false;
+
+    std::vector<std::string> inputs;
+    for ( const auto& input : modules[module_name].inputs )
+    {
+      for ( const auto& a : args )
+      {
+        if ( a.first.substr( 1, a.first.length() - 1 ) == input )
+        {
+          inputs.emplace_back( a.second );
+        }
+      }
+    }
+
+    std::vector<std::string> outputs;
+    for ( const auto& output : modules[module_name].outputs )
+    {
+      for ( const auto& a : args )
+      {
+        if ( a.first.substr( 1, a.first.length() - 1 ) == output )
+        {
+          outputs.emplace_back( a.second );
+        }
+      }
+    }
+
+    /* callback */
+    on_action.call_deferred<MODULE_INST_FN>( inputs, outputs,
+                                             std::make_tuple( module_name, params, inst_name, args ) );
+
+    return success;
+  }
+
+  bool parse_rhs_expression( const std::string& lhs )
+  {
+    std::string s;
+    do
+    {
+      valid = get_token( token );
+      if ( !valid )
+        return false;
+
+      if ( token == ";" || token == "assign" || token == "endmodule" )
+        break;
+      s.append( token );
+    } while ( token != ";" && token != "assign" && token != "endmodule" );
+
+    std::smatch sm;
+    if ( std::regex_match( s, sm, verilog_regex::immediate_assign ) )
+    {
+      assert( sm.size() == 3u );
+      std::vector<std::pair<std::string, bool>> args{{sm[2], sm[1] == "~"}};
+
+      on_action.call_deferred<GATE_FN>( /* dependencies */ { sm[2] }, { lhs },
+                                        /* gate-function params */ std::make_tuple( args, lhs, "assign" )
+                                      );
+    }
+    else if ( std::regex_match( s, sm, verilog_regex::binary_expression ) )
+    {
+      assert( sm.size() == 6u );
+      std::pair<std::string, bool> arg0 = {sm[2], sm[1] == "~"};
+      std::pair<std::string, bool> arg1 = {sm[5], sm[4] == "~"};
+      std::vector<std::pair<std::string, bool>> args{arg0, arg1};
+
+      auto op = sm[3];
+
+      if ( op == "&" )
+      {
+        on_action.call_deferred<GATE_FN>( /* dependencies */ { arg0.first, arg1.first }, { lhs },
+                                          /* gate-function params */ std::make_tuple( args, lhs, "and2" )
+                                        );
+      }
+      else if ( op == "|" )
+      {
+        on_action.call_deferred<GATE_FN>( /* dependencies */ { arg0.first, arg1.first }, { lhs },
+                                          /* gate-function params */ std::make_tuple( args, lhs, "or2" )
+                                        );
+      }
+      else if ( op == "^" )
+      {
+        on_action.call_deferred<GATE_FN>( /* dependencies */ { arg0.first, arg1.first }, { lhs },
+                                          /* gate-function params */ std::make_tuple( args, lhs, "xor2" )
+                                        );
+      }
+      else
+      {
+        return false;
+      }
+    }
+    else if ( std::regex_match( s, sm, verilog_regex::negated_binary_expression ) )
+    {
+      assert( sm.size() == 6u );
+      std::pair<std::string, bool> arg0 = {sm[2], sm[1] == "~"};
+      std::pair<std::string, bool> arg1 = {sm[5], sm[4] == "~"};
+      std::vector<std::pair<std::string,bool>> args{arg0, arg1};
+
+      auto op = sm[3];
+      if ( op == "&" )
+      {
+        on_action.call_deferred<GATE_FN>( /* dependencies */ { arg0.first, arg1.first }, { lhs },
+                                          /* gate-function params */ std::make_tuple( args, lhs, "nand2" )
+                                        );
+      }
+      else if ( op == "|" )
+      {
+        on_action.call_deferred<GATE_FN>( /* dependencies */ { arg0.first, arg1.first }, { lhs },
+                                          /* gate-function params */ std::make_tuple( args, lhs, "nor2" )
+                                        );
+      }
+      else if ( op == "^" )
+      {
+        on_action.call_deferred<GATE_FN>( /* dependencies */ { arg0.first, arg1.first }, { lhs },
+                                          /* gate-function params */ std::make_tuple( args, lhs, "xnor2" )
+                                        );
+      }
+      else
+      {
+        return false;
+      }
+    }
+    else if ( std::regex_match( s, sm, verilog_regex::ternary_expression ) )
+    {
+      assert( sm.size() == 9u );
+      std::pair<std::string, bool> arg0 = {sm[2], sm[1] == "~"};
+      std::pair<std::string, bool> arg1 = {sm[5], sm[4] == "~"};
+      std::pair<std::string, bool> arg2 = {sm[8], sm[7] == "~"};
+      std::vector<std::pair<std::string,bool>> args{arg0, arg1, arg2};
+
+      auto op = sm[3];
+      if ( sm[6] != op )
+      {
+        if ( sm[3] == "?" && sm[6] == ":" )
+        {
+          on_action.call_deferred<GATE_FN>( /* dependencies */ { arg0.first, arg1.first, arg2.first }, { lhs },
+                                            /* gate-function params */ std::make_tuple( args, lhs, "mux21" )
+                                          );
+          return true;
+        }
+        return false;
+      }
+
+      if ( op == "&" )
+      {
+        on_action.call_deferred<GATE_FN>( /* dependencies */ { arg0.first, arg1.first, arg2.first }, { lhs },
+                                          /* gate-function params */ std::make_tuple( args, lhs, "and3" )
+                                        );
+      }
+      else if ( op == "|" )
+      {
+        on_action.call_deferred<GATE_FN>( /* dependencies */ { arg0.first, arg1.first, arg2.first }, { lhs },
+                                          /* gate-function params */ std::make_tuple( args, lhs, "or3" )
+                                        );
+      }
+      else if ( op == "^" )
+      {
+        on_action.call_deferred<GATE_FN>( /* dependencies */ { arg0.first, arg1.first, arg2.first }, { lhs },
+                                          /* gate-function params */ std::make_tuple( args, lhs, "xor3" )
+                                        );
+      }
+      else
+      {
+        return false;
+      }
+    }
+    else if ( std::regex_match( s, sm, verilog_regex::maj3_expression ) )
+    {
+      assert( sm.size() == 13u );
+      std::pair<std::string, bool> a0 = {sm[2], sm[1] == "~"};
+      std::pair<std::string, bool> b0 = {sm[4], sm[3] == "~"};
+      std::pair<std::string, bool> a1 = {sm[6], sm[5] == "~"};
+      std::pair<std::string, bool> c0 = {sm[8], sm[7] == "~"};
+      std::pair<std::string, bool> b1 = {sm[10], sm[9] == "~"};
+      std::pair<std::string, bool> c1 = {sm[12], sm[11] == "~"};
+
+      if ( a0 != a1 || b0 != b1 || c0 != c1 )
+        return false;
+
+      std::vector<std::pair<std::string, bool>> args;
+      args.push_back( a0 );
+      args.push_back( b0 );
+      args.push_back( c0 );
+
+      on_action.call_deferred<GATE_FN>( /* dependencies */ { a0.first, b0.first, c0.first }, { lhs },
+                                        /* gate-function params */ std::make_tuple( args, lhs, "maj3" )
+                                      );
+    }
+    else
+    {
+      return false;
+    }
+
+    return true;
+  }
+
+private:
+  /* Function signatures */
+  using GateFn = detail::Func<
+                   std::vector<std::pair<std::string,bool>>,
+                   std::string,
+                   std::string
+                 >;
+  using ModuleInstFn = detail::Func<
+                         std::string,
+                         std::vector<std::string>,
+                         std::string,
+                         std::vector<std::pair<std::string, std::string>>
+                       >;
+
+  /* Parameter maps */
+  using GateParamMap = detail::ParamPackMap<
+                         /* Key */
+                         std::string,
+                         /* Params */
+                         std::vector<std::pair<std::string,bool>>,
+                         std::string,
+                         std::string
+                       >;
+  using ModuleInstParamMap = detail::ParamPackMap<
+                               /* Key */
+                               std::string,
+                               /* Param */
+                               std::string,
+                               std::vector<std::string>,
+                               std::string,
+                               std::vector<std::pair<std::string, std::string>>
+                             >;
+
+  constexpr static const int GATE_FN{0};
+  constexpr static const int MODULE_INST_FN{1};
+
+  using ParamMaps = detail::ParamPackMapN<GateParamMap, ModuleInstParamMap>;
+  using PackedFns = detail::FuncPackN<GateFn, ModuleInstFn>;
+
+private:
+  detail::tokenizer tok;
+  const verilog_reader& reader;
+  diagnostic_engine* diag;
+
+  std::string token;
+  std::queue<std::string> tokens; /* lookahead */
+  std::string module_name;
+
+  bool valid = false;
+
+  detail::call_in_topological_order<PackedFns, ParamMaps> on_action;
+  std::unordered_map<std::string, module_info> modules;
+}; /* verilog_parser */
+
+/*! \brief Reader function for VERILOG format.
+ *
+ * Reads a simplistic VERILOG format from a stream and invokes a callback
+ * method for each parsed primitive and each detected parse error.
+ *
+ * \param in Input stream
+ * \param reader A VERILOG reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_verilog( std::istream& in, const verilog_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  verilog_parser parser( in, reader, diag );
+  auto result = parser.parse_modules();
+  if ( !result )
+  {
+    return return_code::parse_error;
+  }
+  else
+  {
+    return return_code::success;
+  }
+}
+
+/*! \brief Reader function for VERILOG format.
+ *
+ * Reads a simplistic VERILOG format from a file and invokes a callback
+ * method for each parsed primitive and each detected parse error.
+ *
+ * \param filename Name of the file
+ * \param reader A VERILOG reader with callback methods invoked for parsed primitives
+ * \param diag An optional diagnostic engine with callback methods for parse errors
+ * \return Success if parsing has been successful, or parse error if parsing has failed
+ */
+[[nodiscard]] inline return_code read_verilog( const std::string& filename, const verilog_reader& reader, diagnostic_engine* diag = nullptr )
+{
+  std::ifstream in( detail::word_exp_filename( filename ), std::ifstream::in );
+  if ( !in.is_open() )
+  {
+    if ( diag )
+    {
+      diag->report( diag_id::ERR_FILE_OPEN ).add_argument( filename );
+    }
+    return return_code::parse_error;
+  }
+  else
+  {
+    auto const ret = read_verilog( in, reader, diag );
+    in.close();
+    return ret;
+  }
+}
+
+} // namespace lorina
diff --git a/lib/lorina/lorina/verilog_regex.hpp b/lib/lorina/lorina/verilog_regex.hpp
new file mode 100644
index 0000000..1934713
--- /dev/null
+++ b/lib/lorina/lorina/verilog_regex.hpp
@@ -0,0 +1,51 @@
+/* lorina: C++ parsing library
+ * Copyright (C) 2018-2021  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file verilog_regex.hpp
+  \brief Regular expressions used by the Verilog parser.
+
+  \author Heinz Riener
+  \author Mathias Soeken
+*/
+
+#pragma once
+
+#include <regex>
+
+namespace lorina
+{
+
+namespace verilog_regex
+{
+static std::regex immediate_assign( R"(^(~)?\(?([[:alnum:]\[\]_']+)\)?$)" );
+static std::regex binary_expression( R"(^(~)?([[:alnum:]\[\]_']+)([&|^])(~)?([[:alnum:]\[\]_']+)$)" );
+static std::regex ternary_expression( R"(^(~)?([[:alnum:]\[\]_']+)([&|^?])(~)?([[:alnum:]\[\]_']+)([&|^:])(~)?([[:alnum:]\[\]_']+)$)" );
+static std::regex maj3_expression( R"(^\((~)?([[:alnum:]\[\]_']+)&(~)?([[:alnum:]\[\]_']+)\)\|\((~)?([[:alnum:]\[\]_']+)&(~)?([[:alnum:]\[\]_']+)\)\|\((~)?([[:alnum:]\[\]_']+)&(~)?([[:alnum:]\[\]_']+)\)$)" );
+static std::regex negated_binary_expression( R"(^~\((~)?([[:alnum:]\[\]_']+)([&|^])(~)?([[:alnum:]\[\]_']+)\)$)" );
+static std::regex const_size_range( R"(^(\d+):(\d+)$)" );
+} // namespace verilog_regex
+
+} // namespace lorina
\ No newline at end of file
diff --git a/lib/matplot/matplot/matplotlibcpp.h b/lib/matplot/matplot/matplotlibcpp.h
new file mode 100644
index 0000000..c5af12e
--- /dev/null
+++ b/lib/matplot/matplot/matplotlibcpp.h
@@ -0,0 +1,2554 @@
+#pragma once
+
+// Python headers must be included before any system headers, since
+// they define _POSIX_C_SOURCE
+#include <Python.h>
+
+#include <vector>
+#include <map>
+#include <array>
+#include <numeric>
+#include <algorithm>
+#include <stdexcept>
+#include <iostream>
+#include <cstdint> // <cstdint> requires c++11 support
+#include <functional>
+
+#ifndef WITHOUT_NUMPY
+#  define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#  include <numpy/arrayobject.h>
+
+#  ifdef WITH_OPENCV
+#    include <opencv2/opencv.hpp>
+#  endif // WITH_OPENCV
+
+/*
+ * A bunch of constants were removed in OpenCV 4 in favour of enum classes, so
+ * define the ones we need here.
+ */
+#  if CV_MAJOR_VERSION > 3
+#    define CV_BGR2RGB cv::COLOR_BGR2RGB
+#    define CV_BGRA2RGBA cv::COLOR_BGRA2RGBA
+#  endif
+#endif // WITHOUT_NUMPY
+
+#if PY_MAJOR_VERSION >= 3
+#  define PyString_FromString PyUnicode_FromString
+#  define PyInt_FromLong PyLong_FromLong
+#  define PyString_FromString PyUnicode_FromString
+#endif
+
+
+namespace matplotlibcpp {
+namespace detail {
+
+static std::string s_backend;
+
+struct _interpreter {
+    PyObject* s_python_function_arrow;
+    PyObject *s_python_function_show;
+    PyObject *s_python_function_close;
+    PyObject *s_python_function_draw;
+    PyObject *s_python_function_pause;
+    PyObject *s_python_function_save;
+    PyObject *s_python_function_figure;
+    PyObject *s_python_function_fignum_exists;
+    PyObject *s_python_function_plot;
+    PyObject *s_python_function_quiver;
+    PyObject* s_python_function_contour;
+    PyObject *s_python_function_semilogx;
+    PyObject *s_python_function_semilogy;
+    PyObject *s_python_function_loglog;
+    PyObject *s_python_function_fill;
+    PyObject *s_python_function_fill_between;
+    PyObject *s_python_function_hist;
+    PyObject *s_python_function_imshow;
+    PyObject *s_python_function_scatter;
+    PyObject *s_python_function_boxplot;
+    PyObject *s_python_function_subplot;
+    PyObject *s_python_function_subplot2grid;
+    PyObject *s_python_function_legend;
+    PyObject *s_python_function_xlim;
+    PyObject *s_python_function_ion;
+    PyObject *s_python_function_ginput;
+    PyObject *s_python_function_ylim;
+    PyObject *s_python_function_title;
+    PyObject *s_python_function_axis;
+    PyObject *s_python_function_axvline;
+    PyObject *s_python_function_axvspan;
+    PyObject *s_python_function_xlabel;
+    PyObject *s_python_function_ylabel;
+    PyObject *s_python_function_gca;
+    PyObject *s_python_function_xticks;
+    PyObject *s_python_function_yticks;
+    PyObject* s_python_function_margins;
+    PyObject *s_python_function_tick_params;
+    PyObject *s_python_function_grid;
+    PyObject* s_python_function_cla;
+    PyObject *s_python_function_clf;
+    PyObject *s_python_function_errorbar;
+    PyObject *s_python_function_annotate;
+    PyObject *s_python_function_tight_layout;
+    PyObject *s_python_colormap;
+    PyObject *s_python_empty_tuple;
+    PyObject *s_python_function_stem;
+    PyObject *s_python_function_xkcd;
+    PyObject *s_python_function_text;
+    PyObject *s_python_function_suptitle;
+    PyObject *s_python_function_bar;
+    PyObject *s_python_function_barh;
+    PyObject *s_python_function_colorbar;
+    PyObject *s_python_function_subplots_adjust;
+
+
+    /* For now, _interpreter is implemented as a singleton since its currently not possible to have
+       multiple independent embedded python interpreters without patching the python source code
+       or starting a separate process for each. [1]
+       Furthermore, many python objects expect that they are destructed in the same thread as they
+       were constructed. [2] So for advanced usage, a `kill()` function is provided so that library
+       users can manually ensure that the interpreter is constructed and destroyed within the
+       same thread.
+
+         1: http://bytes.com/topic/python/answers/793370-multiple-independent-python-interpreters-c-c-program
+         2: https://github.com/lava/matplotlib-cpp/pull/202#issue-436220256
+       */
+
+    static _interpreter& get() {
+        return interkeeper(false);
+    }
+
+    static _interpreter& kill() {
+        return interkeeper(true);
+    }
+
+    // Stores the actual singleton object referenced by `get()` and `kill()`.
+    static _interpreter& interkeeper(bool should_kill) {
+        static _interpreter ctx;
+        if (should_kill)
+            ctx.~_interpreter();
+        return ctx;
+    }
+
+    PyObject* safe_import(PyObject* module, std::string fname) {
+        PyObject* fn = PyObject_GetAttrString(module, fname.c_str());
+
+        if (!fn)
+            throw std::runtime_error(std::string("Couldn't find required function: ") + fname);
+
+        if (!PyFunction_Check(fn))
+            throw std::runtime_error(fname + std::string(" is unexpectedly not a PyFunction."));
+
+        return fn;
+    }
+
+private:
+
+#ifndef WITHOUT_NUMPY
+#  if PY_MAJOR_VERSION >= 3
+
+    void *import_numpy() {
+        import_array(); // initialize C-API
+        return NULL;
+    }
+
+#  else
+
+    void import_numpy() {
+        import_array(); // initialize C-API
+    }
+
+#  endif
+#endif
+
+    _interpreter() {
+
+        // optional but recommended
+#if PY_MAJOR_VERSION >= 3
+        wchar_t name[] = L"plotting";
+#else
+        char name[] = "plotting";
+#endif
+        Py_SetProgramName(name);
+        Py_Initialize();
+
+        wchar_t const *dummy_args[] = {L"Python", NULL};  // const is needed because literals must not be modified
+        wchar_t const **argv = dummy_args;
+        int             argc = sizeof(dummy_args)/sizeof(dummy_args[0])-1;
+        PySys_SetArgv(argc, const_cast<wchar_t **>(argv));
+
+#ifndef WITHOUT_NUMPY
+        import_numpy(); // initialize numpy C-API
+#endif
+
+        PyObject* matplotlibname = PyString_FromString("matplotlib");
+        PyObject* pyplotname = PyString_FromString("matplotlib.pyplot");
+        PyObject* cmname  = PyString_FromString("matplotlib.cm");
+        PyObject* pylabname  = PyString_FromString("pylab");
+        if (!pyplotname || !pylabname || !matplotlibname || !cmname) {
+            throw std::runtime_error("couldnt create string");
+        }
+
+        PyObject* matplotlib = PyImport_Import(matplotlibname);
+        Py_DECREF(matplotlibname);
+        if (!matplotlib) {
+            PyErr_Print();
+            throw std::runtime_error("Error loading module matplotlib!");
+        }
+
+        // matplotlib.use() must be called *before* pylab, matplotlib.pyplot,
+        // or matplotlib.backends is imported for the first time
+        if (!s_backend.empty()) {
+            PyObject_CallMethod(matplotlib, const_cast<char*>("use"), const_cast<char*>("s"), s_backend.c_str());
+        }
+
+        PyObject* pymod = PyImport_Import(pyplotname);
+        Py_DECREF(pyplotname);
+        if (!pymod) { throw std::runtime_error("Error loading module matplotlib.pyplot!"); }
+
+        s_python_colormap = PyImport_Import(cmname);
+        Py_DECREF(cmname);
+        if (!s_python_colormap) { throw std::runtime_error("Error loading module matplotlib.cm!"); }
+
+        PyObject* pylabmod = PyImport_Import(pylabname);
+        Py_DECREF(pylabname);
+        if (!pylabmod) { throw std::runtime_error("Error loading module pylab!"); }
+
+        s_python_function_arrow = safe_import(pymod, "arrow");
+        s_python_function_show = safe_import(pymod, "show");
+        s_python_function_close = safe_import(pymod, "close");
+        s_python_function_draw = safe_import(pymod, "draw");
+        s_python_function_pause = safe_import(pymod, "pause");
+        s_python_function_figure = safe_import(pymod, "figure");
+        s_python_function_fignum_exists = safe_import(pymod, "fignum_exists");
+        s_python_function_plot = safe_import(pymod, "plot");
+        s_python_function_quiver = safe_import(pymod, "quiver");
+        s_python_function_contour = safe_import(pymod, "contour");
+        s_python_function_semilogx = safe_import(pymod, "semilogx");
+        s_python_function_semilogy = safe_import(pymod, "semilogy");
+        s_python_function_loglog = safe_import(pymod, "loglog");
+        s_python_function_fill = safe_import(pymod, "fill");
+        s_python_function_fill_between = safe_import(pymod, "fill_between");
+        s_python_function_hist = safe_import(pymod,"hist");
+        s_python_function_scatter = safe_import(pymod,"scatter");
+        s_python_function_boxplot = safe_import(pymod,"boxplot");
+        s_python_function_subplot = safe_import(pymod, "subplot");
+        s_python_function_subplot2grid = safe_import(pymod, "subplot2grid");
+        s_python_function_legend = safe_import(pymod, "legend");
+        s_python_function_ylim = safe_import(pymod, "ylim");
+        s_python_function_title = safe_import(pymod, "title");
+        s_python_function_axis = safe_import(pymod, "axis");
+        s_python_function_axvline = safe_import(pymod, "axvline");
+        s_python_function_axvspan = safe_import(pymod, "axvspan");
+        s_python_function_xlabel = safe_import(pymod, "xlabel");
+        s_python_function_ylabel = safe_import(pymod, "ylabel");
+        s_python_function_gca = safe_import(pymod, "gca");
+        s_python_function_xticks = safe_import(pymod, "xticks");
+        s_python_function_yticks = safe_import(pymod, "yticks");
+        s_python_function_margins = safe_import(pymod, "margins");
+        s_python_function_tick_params = safe_import(pymod, "tick_params");
+        s_python_function_grid = safe_import(pymod, "grid");
+        s_python_function_xlim = safe_import(pymod, "xlim");
+        s_python_function_ion = safe_import(pymod, "ion");
+        s_python_function_ginput = safe_import(pymod, "ginput");
+        s_python_function_save = safe_import(pylabmod, "savefig");
+        s_python_function_annotate = safe_import(pymod,"annotate");
+        s_python_function_cla = safe_import(pymod, "cla");
+        s_python_function_clf = safe_import(pymod, "clf");
+        s_python_function_errorbar = safe_import(pymod, "errorbar");
+        s_python_function_tight_layout = safe_import(pymod, "tight_layout");
+        s_python_function_stem = safe_import(pymod, "stem");
+        s_python_function_xkcd = safe_import(pymod, "xkcd");
+        s_python_function_text = safe_import(pymod, "text");
+        s_python_function_suptitle = safe_import(pymod, "suptitle");
+        s_python_function_bar = safe_import(pymod,"bar");
+        s_python_function_barh = safe_import(pymod, "barh");
+        s_python_function_colorbar = PyObject_GetAttrString(pymod, "colorbar");
+        s_python_function_subplots_adjust = safe_import(pymod,"subplots_adjust");
+#ifndef WITHOUT_NUMPY
+        s_python_function_imshow = safe_import(pymod, "imshow");
+#endif
+        s_python_empty_tuple = PyTuple_New(0);
+    }
+
+    ~_interpreter() {
+        Py_Finalize();
+    }
+};
+
+} // end namespace detail
+
+/// Select the backend
+///
+/// **NOTE:** This must be called before the first plot command to have
+/// any effect.
+///
+/// Mainly useful to select the non-interactive 'Agg' backend when running
+/// matplotlibcpp in headless mode, for example on a machine with no display.
+///
+/// See also: https://matplotlib.org/2.0.2/api/matplotlib_configuration_api.html#matplotlib.use
+inline void backend(const std::string& name)
+{
+    detail::s_backend = name;
+}
+
+inline bool annotate(std::string annotation, double x, double y)
+{
+    detail::_interpreter::get();
+
+    PyObject * xy = PyTuple_New(2);
+    PyObject * str = PyString_FromString(annotation.c_str());
+
+    PyTuple_SetItem(xy,0,PyFloat_FromDouble(x));
+    PyTuple_SetItem(xy,1,PyFloat_FromDouble(y));
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "xy", xy);
+
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, str);
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_annotate, args, kwargs);
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+namespace detail {
+
+#ifndef WITHOUT_NUMPY
+// Type selector for numpy array conversion
+template <typename T> struct select_npy_type { const static NPY_TYPES type = NPY_NOTYPE; }; //Default
+template <> struct select_npy_type<double> { const static NPY_TYPES type = NPY_DOUBLE; };
+template <> struct select_npy_type<float> { const static NPY_TYPES type = NPY_FLOAT; };
+template <> struct select_npy_type<bool> { const static NPY_TYPES type = NPY_BOOL; };
+template <> struct select_npy_type<int8_t> { const static NPY_TYPES type = NPY_INT8; };
+template <> struct select_npy_type<int16_t> { const static NPY_TYPES type = NPY_SHORT; };
+template <> struct select_npy_type<int32_t> { const static NPY_TYPES type = NPY_INT; };
+template <> struct select_npy_type<int64_t> { const static NPY_TYPES type = NPY_INT64; };
+template <> struct select_npy_type<uint8_t> { const static NPY_TYPES type = NPY_UINT8; };
+template <> struct select_npy_type<uint16_t> { const static NPY_TYPES type = NPY_USHORT; };
+template <> struct select_npy_type<uint32_t> { const static NPY_TYPES type = NPY_ULONG; };
+template <> struct select_npy_type<uint64_t> { const static NPY_TYPES type = NPY_UINT64; };
+
+// Sanity checks; comment them out or change the numpy type below if you're compiling on
+// a platform where they don't apply
+// static_assert(sizeof(long long) == 8);
+// template <> struct select_npy_type<long long> { const static NPY_TYPES type = NPY_INT64; };
+// static_assert(sizeof(unsigned long long) == 8);
+// template <> struct select_npy_type<unsigned long long> { const static NPY_TYPES type = NPY_UINT64; };
+// TODO: add int, long, etc.
+
+template<typename Numeric>
+PyObject* get_array(const std::vector<Numeric>& v)
+{
+    npy_intp vsize = v.size();
+    NPY_TYPES type = select_npy_type<Numeric>::type;
+    if (type == NPY_NOTYPE) {
+        size_t memsize = v.size()*sizeof(double);
+        double* dp = static_cast<double*>(::malloc(memsize));
+        for (size_t i=0; i<v.size(); ++i)
+            dp[i] = v[i];
+        PyObject* varray = PyArray_SimpleNewFromData(1, &vsize, NPY_DOUBLE, dp);
+        PyArray_UpdateFlags(reinterpret_cast<PyArrayObject*>(varray), NPY_ARRAY_OWNDATA);
+        return varray;
+    }
+    
+    PyObject* varray = PyArray_SimpleNewFromData(1, &vsize, type, (void*)(v.data()));
+    return varray;
+}
+
+
+template<typename Numeric>
+PyObject* get_2darray(const std::vector<::std::vector<Numeric>>& v)
+{
+    if (v.size() < 1) throw std::runtime_error("get_2d_array v too small");
+
+    npy_intp vsize[2] = {static_cast<npy_intp>(v.size()),
+                         static_cast<npy_intp>(v[0].size())};
+
+    PyArrayObject *varray =
+        (PyArrayObject *)PyArray_SimpleNew(2, vsize, NPY_DOUBLE);
+
+    double *vd_begin = static_cast<double *>(PyArray_DATA(varray));
+
+    for (const ::std::vector<Numeric> &v_row : v) {
+      if (v_row.size() != static_cast<size_t>(vsize[1]))
+        throw std::runtime_error("Missmatched array size");
+      std::copy(v_row.begin(), v_row.end(), vd_begin);
+      vd_begin += vsize[1];
+    }
+
+    return reinterpret_cast<PyObject *>(varray);
+}
+
+#else // fallback if we don't have numpy: copy every element of the given vector
+
+template<typename Numeric>
+PyObject* get_array(const std::vector<Numeric>& v)
+{
+    PyObject* list = PyList_New(v.size());
+    for(size_t i = 0; i < v.size(); ++i) {
+        PyList_SetItem(list, i, PyFloat_FromDouble(v.at(i)));
+    }
+    return list;
+}
+
+#endif // WITHOUT_NUMPY
+
+// sometimes, for labels and such, we need string arrays
+inline PyObject * get_array(const std::vector<std::string>& strings)
+{
+  PyObject* list = PyList_New(strings.size());
+  for (std::size_t i = 0; i < strings.size(); ++i) {
+    PyList_SetItem(list, i, PyString_FromString(strings[i].c_str()));
+  }
+  return list;
+}
+
+// not all matplotlib need 2d arrays, some prefer lists of lists
+template<typename Numeric>
+PyObject* get_listlist(const std::vector<std::vector<Numeric>>& ll)
+{
+  PyObject* listlist = PyList_New(ll.size());
+  for (std::size_t i = 0; i < ll.size(); ++i) {
+    PyList_SetItem(listlist, i, get_array(ll[i]));
+  }
+  return listlist;
+}
+
+} // namespace detail
+
+/// Plot a line through the given x and y data points..
+/// 
+/// See: https://matplotlib.org/3.2.1/api/_as_gen/matplotlib.pyplot.plot.html
+template<typename Numeric>
+bool plot(const std::vector<Numeric> &x, const std::vector<Numeric> &y, const std::map<std::string, std::string>& keywords)
+{
+    assert(x.size() == y.size());
+
+    detail::_interpreter::get();
+
+    // using numpy arrays
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    // construct positional args
+    PyObject* args = PyTuple_New(2);
+    PyTuple_SetItem(args, 0, xarray);
+    PyTuple_SetItem(args, 1, yarray);
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, args, kwargs);
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+// TODO - it should be possible to make this work by implementing
+// a non-numpy alternative for `detail::get_2darray()`.
+#ifndef WITHOUT_NUMPY
+template <typename Numeric>
+void plot_surface(const std::vector<::std::vector<Numeric>> &x,
+                  const std::vector<::std::vector<Numeric>> &y,
+                  const std::vector<::std::vector<Numeric>> &z,
+                  const std::map<std::string, std::string> &keywords =
+                      std::map<std::string, std::string>())
+{
+  detail::_interpreter::get();
+
+  // We lazily load the modules here the first time this function is called
+  // because I'm not sure that we can assume "matplotlib installed" implies
+  // "mpl_toolkits installed" on all platforms, and we don't want to require
+  // it for people who don't need 3d plots.
+  static PyObject *mpl_toolkitsmod = nullptr, *axis3dmod = nullptr;
+  if (!mpl_toolkitsmod) {
+    detail::_interpreter::get();
+
+    PyObject* mpl_toolkits = PyString_FromString("mpl_toolkits");
+    PyObject* axis3d = PyString_FromString("mpl_toolkits.mplot3d");
+    if (!mpl_toolkits || !axis3d) { throw std::runtime_error("couldnt create string"); }
+
+    mpl_toolkitsmod = PyImport_Import(mpl_toolkits);
+    Py_DECREF(mpl_toolkits);
+    if (!mpl_toolkitsmod) { throw std::runtime_error("Error loading module mpl_toolkits!"); }
+
+    axis3dmod = PyImport_Import(axis3d);
+    Py_DECREF(axis3d);
+    if (!axis3dmod) { throw std::runtime_error("Error loading module mpl_toolkits.mplot3d!"); }
+  }
+
+  assert(x.size() == y.size());
+  assert(y.size() == z.size());
+
+  // using numpy arrays
+  PyObject *xarray = detail::get_2darray(x);
+  PyObject *yarray = detail::get_2darray(y);
+  PyObject *zarray = detail::get_2darray(z);
+
+  // construct positional args
+  PyObject *args = PyTuple_New(3);
+  PyTuple_SetItem(args, 0, xarray);
+  PyTuple_SetItem(args, 1, yarray);
+  PyTuple_SetItem(args, 2, zarray);
+
+  // Build up the kw args.
+  PyObject *kwargs = PyDict_New();
+  PyDict_SetItemString(kwargs, "rstride", PyInt_FromLong(1));
+  PyDict_SetItemString(kwargs, "cstride", PyInt_FromLong(1));
+
+  PyObject *python_colormap_coolwarm = PyObject_GetAttrString(
+      detail::_interpreter::get().s_python_colormap, "coolwarm");
+
+  PyDict_SetItemString(kwargs, "cmap", python_colormap_coolwarm);
+
+  for (std::map<std::string, std::string>::const_iterator it = keywords.begin();
+       it != keywords.end(); ++it) {
+    PyDict_SetItemString(kwargs, it->first.c_str(),
+                         PyString_FromString(it->second.c_str()));
+  }
+
+
+  PyObject *fig =
+      PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
+                          detail::_interpreter::get().s_python_empty_tuple);
+  if (!fig) throw std::runtime_error("Call to figure() failed.");
+
+  PyObject *gca_kwargs = PyDict_New();
+  PyDict_SetItemString(gca_kwargs, "projection", PyString_FromString("3d"));
+
+  PyObject *gca = PyObject_GetAttrString(fig, "gca");
+  if (!gca) throw std::runtime_error("No gca");
+  Py_INCREF(gca);
+  PyObject *axis = PyObject_Call(
+      gca, detail::_interpreter::get().s_python_empty_tuple, gca_kwargs);
+
+  if (!axis) throw std::runtime_error("No axis");
+  Py_INCREF(axis);
+
+  Py_DECREF(gca);
+  Py_DECREF(gca_kwargs);
+
+  PyObject *plot_surface = PyObject_GetAttrString(axis, "plot_surface");
+  if (!plot_surface) throw std::runtime_error("No surface");
+  Py_INCREF(plot_surface);
+  PyObject *res = PyObject_Call(plot_surface, args, kwargs);
+  if (!res) throw std::runtime_error("failed surface");
+  Py_DECREF(plot_surface);
+
+  Py_DECREF(axis);
+  Py_DECREF(args);
+  Py_DECREF(kwargs);
+  if (res) Py_DECREF(res);
+}
+#endif // WITHOUT_NUMPY
+
+template <typename Numeric>
+void plot3(const std::vector<Numeric> &x,
+                  const std::vector<Numeric> &y,
+                  const std::vector<Numeric> &z,
+                  const std::map<std::string, std::string> &keywords =
+                      std::map<std::string, std::string>())
+{
+  detail::_interpreter::get();
+
+  // Same as with plot_surface: We lazily load the modules here the first time 
+  // this function is called because I'm not sure that we can assume "matplotlib 
+  // installed" implies "mpl_toolkits installed" on all platforms, and we don't 
+  // want to require it for people who don't need 3d plots.
+  static PyObject *mpl_toolkitsmod = nullptr, *axis3dmod = nullptr;
+  if (!mpl_toolkitsmod) {
+    detail::_interpreter::get();
+
+    PyObject* mpl_toolkits = PyString_FromString("mpl_toolkits");
+    PyObject* axis3d = PyString_FromString("mpl_toolkits.mplot3d");
+    if (!mpl_toolkits || !axis3d) { throw std::runtime_error("couldnt create string"); }
+
+    mpl_toolkitsmod = PyImport_Import(mpl_toolkits);
+    Py_DECREF(mpl_toolkits);
+    if (!mpl_toolkitsmod) { throw std::runtime_error("Error loading module mpl_toolkits!"); }
+
+    axis3dmod = PyImport_Import(axis3d);
+    Py_DECREF(axis3d);
+    if (!axis3dmod) { throw std::runtime_error("Error loading module mpl_toolkits.mplot3d!"); }
+  }
+
+  assert(x.size() == y.size());
+  assert(y.size() == z.size());
+
+  PyObject *xarray = detail::get_array(x);
+  PyObject *yarray = detail::get_array(y);
+  PyObject *zarray = detail::get_array(z);
+
+  // construct positional args
+  PyObject *args = PyTuple_New(3);
+  PyTuple_SetItem(args, 0, xarray);
+  PyTuple_SetItem(args, 1, yarray);
+  PyTuple_SetItem(args, 2, zarray);
+
+  // Build up the kw args.
+  PyObject *kwargs = PyDict_New();
+
+  for (std::map<std::string, std::string>::const_iterator it = keywords.begin();
+       it != keywords.end(); ++it) {
+    PyDict_SetItemString(kwargs, it->first.c_str(),
+                         PyString_FromString(it->second.c_str()));
+  }
+
+  PyObject *fig =
+      PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
+                          detail::_interpreter::get().s_python_empty_tuple);
+  if (!fig) throw std::runtime_error("Call to figure() failed.");
+
+  PyObject *gca_kwargs = PyDict_New();
+  PyDict_SetItemString(gca_kwargs, "projection", PyString_FromString("3d"));
+
+  PyObject *gca = PyObject_GetAttrString(fig, "gca");
+  if (!gca) throw std::runtime_error("No gca");
+  Py_INCREF(gca);
+  PyObject *axis = PyObject_Call(
+      gca, detail::_interpreter::get().s_python_empty_tuple, gca_kwargs);
+
+  if (!axis) throw std::runtime_error("No axis");
+  Py_INCREF(axis);
+
+  Py_DECREF(gca);
+  Py_DECREF(gca_kwargs);
+
+  PyObject *plot3 = PyObject_GetAttrString(axis, "plot");
+  if (!plot3) throw std::runtime_error("No 3D line plot");
+  Py_INCREF(plot3);
+  PyObject *res = PyObject_Call(plot3, args, kwargs);
+  if (!res) throw std::runtime_error("Failed 3D line plot");
+  Py_DECREF(plot3);
+
+  Py_DECREF(axis);
+  Py_DECREF(args);
+  Py_DECREF(kwargs);
+  if (res) Py_DECREF(res);
+}
+
+template<typename Numeric>
+bool stem(const std::vector<Numeric> &x, const std::vector<Numeric> &y, const std::map<std::string, std::string>& keywords)
+{
+    assert(x.size() == y.size());
+
+    detail::_interpreter::get();
+
+    // using numpy arrays
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    // construct positional args
+    PyObject* args = PyTuple_New(2);
+    PyTuple_SetItem(args, 0, xarray);
+    PyTuple_SetItem(args, 1, yarray);
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for (std::map<std::string, std::string>::const_iterator it =
+            keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(),
+                PyString_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(
+            detail::_interpreter::get().s_python_function_stem, args, kwargs);
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    if (res)
+        Py_DECREF(res);
+
+    return res;
+}
+
+template< typename Numeric >
+bool fill(const std::vector<Numeric>& x, const std::vector<Numeric>& y, const std::map<std::string, std::string>& keywords)
+{
+    assert(x.size() == y.size());
+
+    detail::_interpreter::get();
+
+    // using numpy arrays
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    // construct positional args
+    PyObject* args = PyTuple_New(2);
+    PyTuple_SetItem(args, 0, xarray);
+    PyTuple_SetItem(args, 1, yarray);
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_fill, args, kwargs);
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+
+    if (res) Py_DECREF(res);
+
+    return res;
+}
+
+template< typename Numeric >
+bool fill_between(const std::vector<Numeric>& x, const std::vector<Numeric>& y1, const std::vector<Numeric>& y2, const std::map<std::string, std::string>& keywords)
+{
+    assert(x.size() == y1.size());
+    assert(x.size() == y2.size());
+
+    detail::_interpreter::get();
+
+    // using numpy arrays
+    PyObject* xarray = detail::get_array(x);
+    PyObject* y1array = detail::get_array(y1);
+    PyObject* y2array = detail::get_array(y2);
+
+    // construct positional args
+    PyObject* args = PyTuple_New(3);
+    PyTuple_SetItem(args, 0, xarray);
+    PyTuple_SetItem(args, 1, y1array);
+    PyTuple_SetItem(args, 2, y2array);
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_fill_between, args, kwargs);
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+template <typename Numeric>
+bool arrow(Numeric x, Numeric y, Numeric end_x, Numeric end_y, const std::string& fc = "r",
+           const std::string ec = "k", Numeric head_length = 0.25, Numeric head_width = 0.1625) {
+    PyObject* obj_x = PyFloat_FromDouble(x);
+    PyObject* obj_y = PyFloat_FromDouble(y);
+    PyObject* obj_end_x = PyFloat_FromDouble(end_x);
+    PyObject* obj_end_y = PyFloat_FromDouble(end_y);
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "fc", PyString_FromString(fc.c_str()));
+    PyDict_SetItemString(kwargs, "ec", PyString_FromString(ec.c_str()));
+    PyDict_SetItemString(kwargs, "head_width", PyFloat_FromDouble(head_width));
+    PyDict_SetItemString(kwargs, "head_length", PyFloat_FromDouble(head_length));
+
+    PyObject* plot_args = PyTuple_New(4);
+    PyTuple_SetItem(plot_args, 0, obj_x);
+    PyTuple_SetItem(plot_args, 1, obj_y);
+    PyTuple_SetItem(plot_args, 2, obj_end_x);
+    PyTuple_SetItem(plot_args, 3, obj_end_y);
+
+    PyObject* res =
+            PyObject_Call(detail::_interpreter::get().s_python_function_arrow, plot_args, kwargs);
+
+    Py_DECREF(plot_args);
+    Py_DECREF(kwargs);
+    if (res)
+        Py_DECREF(res);
+
+    return res;
+}
+
+template< typename Numeric>
+bool hist(const std::vector<Numeric>& y, long bins=10,std::string color="b",
+          double alpha=1.0, bool cumulative=false)
+{
+    detail::_interpreter::get();
+
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "bins", PyLong_FromLong(bins));
+    PyDict_SetItemString(kwargs, "color", PyString_FromString(color.c_str()));
+    PyDict_SetItemString(kwargs, "alpha", PyFloat_FromDouble(alpha));
+    PyDict_SetItemString(kwargs, "cumulative", cumulative ? Py_True : Py_False);
+
+    PyObject* plot_args = PyTuple_New(1);
+
+    PyTuple_SetItem(plot_args, 0, yarray);
+
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_hist, plot_args, kwargs);
+
+
+    Py_DECREF(plot_args);
+    Py_DECREF(kwargs);
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+#ifndef WITHOUT_NUMPY
+namespace detail {
+
+inline void imshow(void *ptr, const NPY_TYPES type, const int rows, const int columns, const int colors, const std::map<std::string, std::string> &keywords, PyObject** out)
+{
+    assert(type == NPY_UINT8 || type == NPY_FLOAT);
+    assert(colors == 1 || colors == 3 || colors == 4);
+
+    detail::_interpreter::get();
+
+    // construct args
+    npy_intp dims[3] = { rows, columns, colors };
+    PyObject *args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, PyArray_SimpleNewFromData(colors == 1 ? 2 : 3, dims, type, ptr));
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_imshow, args, kwargs);
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    if (!res)
+        throw std::runtime_error("Call to imshow() failed");
+    if (out)
+        *out = res;
+    else
+        Py_DECREF(res);
+}
+
+} // namespace detail
+
+inline void imshow(const unsigned char *ptr, const int rows, const int columns, const int colors, const std::map<std::string, std::string> &keywords = {}, PyObject** out = nullptr)
+{
+    detail::imshow((void *) ptr, NPY_UINT8, rows, columns, colors, keywords, out);
+}
+
+inline void imshow(const float *ptr, const int rows, const int columns, const int colors, const std::map<std::string, std::string> &keywords = {}, PyObject** out = nullptr)
+{
+    detail::imshow((void *) ptr, NPY_FLOAT, rows, columns, colors, keywords, out);
+}
+
+#ifdef WITH_OPENCV
+void imshow(const cv::Mat &image, const std::map<std::string, std::string> &keywords = {})
+{
+    // Convert underlying type of matrix, if needed
+    cv::Mat image2;
+    NPY_TYPES npy_type = NPY_UINT8;
+    switch (image.type() & CV_MAT_DEPTH_MASK) {
+    case CV_8U:
+        image2 = image;
+        break;
+    case CV_32F:
+        image2 = image;
+        npy_type = NPY_FLOAT;
+        break;
+    default:
+        image.convertTo(image2, CV_MAKETYPE(CV_8U, image.channels()));
+    }
+
+    // If color image, convert from BGR to RGB
+    switch (image2.channels()) {
+    case 3:
+        cv::cvtColor(image2, image2, CV_BGR2RGB);
+        break;
+    case 4:
+        cv::cvtColor(image2, image2, CV_BGRA2RGBA);
+    }
+
+    detail::imshow(image2.data, npy_type, image2.rows, image2.cols, image2.channels(), keywords);
+}
+#endif // WITH_OPENCV
+#endif // WITHOUT_NUMPY
+
+template<typename NumericX, typename NumericY>
+bool scatter(const std::vector<NumericX>& x,
+             const std::vector<NumericY>& y,
+             const double s=1.0, // The marker size in points**2
+             const std::map<std::string, std::string> & keywords = {})
+{
+    detail::_interpreter::get();
+
+    assert(x.size() == y.size());
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "s", PyLong_FromLong(s));
+    for (const auto& it : keywords)
+    {
+        PyDict_SetItemString(kwargs, it.first.c_str(), PyString_FromString(it.second.c_str()));
+    }
+
+    PyObject* plot_args = PyTuple_New(2);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_scatter, plot_args, kwargs);
+
+    Py_DECREF(plot_args);
+    Py_DECREF(kwargs);
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename Numeric>
+bool boxplot(const std::vector<std::vector<Numeric>>& data,
+             const std::vector<std::string>& labels = {},
+             const std::map<std::string, std::string> & keywords = {})
+{
+    detail::_interpreter::get();
+
+    PyObject* listlist = detail::get_listlist(data);
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, listlist);
+
+    PyObject* kwargs = PyDict_New();
+
+    // kwargs needs the labels, if there are (the correct number of) labels
+    if (!labels.empty() && labels.size() == data.size()) {
+        PyDict_SetItemString(kwargs, "labels", detail::get_array(labels));
+    }
+
+    // take care of the remaining keywords
+    for (const auto& it : keywords)
+    {
+        PyDict_SetItemString(kwargs, it.first.c_str(), PyString_FromString(it.second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_boxplot, args, kwargs);
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename Numeric>
+bool boxplot(const std::vector<Numeric>& data,
+             const std::map<std::string, std::string> & keywords = {})
+{
+    detail::_interpreter::get();
+
+    PyObject* vector = detail::get_array(data);
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, vector);
+
+    PyObject* kwargs = PyDict_New();
+    for (const auto& it : keywords)
+    {
+        PyDict_SetItemString(kwargs, it.first.c_str(), PyString_FromString(it.second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_boxplot, args, kwargs);
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+template <typename Numeric>
+bool bar(const std::vector<Numeric> &               x,
+         const std::vector<Numeric> &               y,
+         std::string                                ec       = "black",
+         std::string                                ls       = "-",
+         double                                     lw       = 1.0,
+         const std::map<std::string, std::string> & keywords = {})
+{
+  detail::_interpreter::get();
+
+  PyObject * xarray = detail::get_array(x);
+  PyObject * yarray = detail::get_array(y);
+
+  PyObject * kwargs = PyDict_New();
+
+  PyDict_SetItemString(kwargs, "ec", PyString_FromString(ec.c_str()));
+  PyDict_SetItemString(kwargs, "ls", PyString_FromString(ls.c_str()));
+  PyDict_SetItemString(kwargs, "lw", PyFloat_FromDouble(lw));
+
+  for (std::map<std::string, std::string>::const_iterator it =
+         keywords.begin();
+       it != keywords.end();
+       ++it) {
+    PyDict_SetItemString(
+      kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+  }
+
+  PyObject * plot_args = PyTuple_New(2);
+  PyTuple_SetItem(plot_args, 0, xarray);
+  PyTuple_SetItem(plot_args, 1, yarray);
+
+  PyObject * res = PyObject_Call(
+    detail::_interpreter::get().s_python_function_bar, plot_args, kwargs);
+
+  Py_DECREF(plot_args);
+  Py_DECREF(kwargs);
+  if (res) Py_DECREF(res);
+
+  return res;
+}
+
+template <typename Numeric>
+bool bar(const std::vector<Numeric> &               y,
+         std::string                                ec       = "black",
+         std::string                                ls       = "-",
+         double                                     lw       = 1.0,
+         const std::map<std::string, std::string> & keywords = {})
+{
+  using T = typename std::remove_reference<decltype(y)>::type::value_type;
+
+  detail::_interpreter::get();
+
+  std::vector<T> x;
+  for (std::size_t i = 0; i < y.size(); i++) { x.push_back(i); }
+
+  return bar(x, y, ec, ls, lw, keywords);
+}
+
+
+template<typename Numeric>
+bool barh(const std::vector<Numeric> &x, const std::vector<Numeric> &y, std::string ec = "black", std::string ls = "-", double lw = 1.0, const std::map<std::string, std::string> &keywords = { }) {
+    PyObject *xarray = detail::get_array(x);
+    PyObject *yarray = detail::get_array(y);
+
+    PyObject *kwargs = PyDict_New();
+
+    PyDict_SetItemString(kwargs, "ec", PyString_FromString(ec.c_str()));
+    PyDict_SetItemString(kwargs, "ls", PyString_FromString(ls.c_str()));
+    PyDict_SetItemString(kwargs, "lw", PyFloat_FromDouble(lw));
+
+    for (std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject *plot_args = PyTuple_New(2);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+
+    PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_barh, plot_args, kwargs);
+
+    Py_DECREF(plot_args);
+    Py_DECREF(kwargs);
+    if (res) Py_DECREF(res);
+
+    return res;
+}
+
+
+inline bool subplots_adjust(const std::map<std::string, double>& keywords = {})
+{
+    detail::_interpreter::get();
+
+    PyObject* kwargs = PyDict_New();
+    for (std::map<std::string, double>::const_iterator it =
+            keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(),
+                             PyFloat_FromDouble(it->second));
+    }
+
+
+    PyObject* plot_args = PyTuple_New(0);
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_subplots_adjust, plot_args, kwargs);
+
+    Py_DECREF(plot_args);
+    Py_DECREF(kwargs);
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+template< typename Numeric>
+bool named_hist(std::string label,const std::vector<Numeric>& y, long bins=10, std::string color="b", double alpha=1.0)
+{
+    detail::_interpreter::get();
+
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "label", PyString_FromString(label.c_str()));
+    PyDict_SetItemString(kwargs, "bins", PyLong_FromLong(bins));
+    PyDict_SetItemString(kwargs, "color", PyString_FromString(color.c_str()));
+    PyDict_SetItemString(kwargs, "alpha", PyFloat_FromDouble(alpha));
+
+
+    PyObject* plot_args = PyTuple_New(1);
+    PyTuple_SetItem(plot_args, 0, yarray);
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_hist, plot_args, kwargs);
+
+    Py_DECREF(plot_args);
+    Py_DECREF(kwargs);
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool plot(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& s = "")
+{
+    assert(x.size() == y.size());
+
+    detail::_interpreter::get();
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* pystring = PyString_FromString(s.c_str());
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_plot, plot_args);
+
+    Py_DECREF(plot_args);
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+template <typename NumericX, typename NumericY, typename NumericZ>
+bool contour(const std::vector<NumericX>& x, const std::vector<NumericY>& y,
+             const std::vector<NumericZ>& z,
+             const std::map<std::string, std::string>& keywords = {}) {
+    assert(x.size() == y.size() && x.size() == z.size());
+
+    PyObject* xarray = get_array(x);
+    PyObject* yarray = get_array(y);
+    PyObject* zarray = get_array(z);
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, zarray);
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for (std::map<std::string, std::string>::const_iterator it = keywords.begin();
+         it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject* res =
+            PyObject_Call(detail::_interpreter::get().s_python_function_contour, plot_args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(plot_args);
+    if (res)
+        Py_DECREF(res);
+
+    return res;
+}
+
+template<typename NumericX, typename NumericY, typename NumericU, typename NumericW>
+bool quiver(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::vector<NumericU>& u, const std::vector<NumericW>& w, const std::map<std::string, std::string>& keywords = {})
+{
+    assert(x.size() == y.size() && x.size() == u.size() && u.size() == w.size());
+
+    detail::_interpreter::get();
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+    PyObject* uarray = detail::get_array(u);
+    PyObject* warray = detail::get_array(w);
+
+    PyObject* plot_args = PyTuple_New(4);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, uarray);
+    PyTuple_SetItem(plot_args, 3, warray);
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(
+            detail::_interpreter::get().s_python_function_quiver, plot_args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(plot_args);
+    if (res)
+        Py_DECREF(res);
+
+    return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool stem(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& s = "")
+{
+    assert(x.size() == y.size());
+
+    detail::_interpreter::get();
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* pystring = PyString_FromString(s.c_str());
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
+
+    PyObject* res = PyObject_CallObject(
+            detail::_interpreter::get().s_python_function_stem, plot_args);
+
+    Py_DECREF(plot_args);
+    if (res)
+        Py_DECREF(res);
+
+    return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool semilogx(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& s = "")
+{
+    assert(x.size() == y.size());
+
+    detail::_interpreter::get();
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* pystring = PyString_FromString(s.c_str());
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_semilogx, plot_args);
+
+    Py_DECREF(plot_args);
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool semilogy(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& s = "")
+{
+    assert(x.size() == y.size());
+
+    detail::_interpreter::get();
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* pystring = PyString_FromString(s.c_str());
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_semilogy, plot_args);
+
+    Py_DECREF(plot_args);
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool loglog(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& s = "")
+{
+    assert(x.size() == y.size());
+
+    detail::_interpreter::get();
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* pystring = PyString_FromString(s.c_str());
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_loglog, plot_args);
+
+    Py_DECREF(plot_args);
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool errorbar(const std::vector<NumericX> &x, const std::vector<NumericY> &y, const std::vector<NumericX> &yerr, const std::map<std::string, std::string> &keywords = {})
+{
+    assert(x.size() == y.size());
+
+    detail::_interpreter::get();
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+    PyObject* yerrarray = detail::get_array(yerr);
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+    }
+
+    PyDict_SetItemString(kwargs, "yerr", yerrarray);
+
+    PyObject *plot_args = PyTuple_New(2);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+
+    PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_errorbar, plot_args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(plot_args);
+
+    if (res)
+        Py_DECREF(res);
+    else
+        throw std::runtime_error("Call to errorbar() failed.");
+
+    return res;
+}
+
+template<typename Numeric>
+bool named_plot(const std::string& name, const std::vector<Numeric>& y, const std::string& format = "")
+{
+    detail::_interpreter::get();
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* pystring = PyString_FromString(format.c_str());
+
+    PyObject* plot_args = PyTuple_New(2);
+
+    PyTuple_SetItem(plot_args, 0, yarray);
+    PyTuple_SetItem(plot_args, 1, pystring);
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, plot_args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(plot_args);
+    if (res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename Numeric>
+bool named_plot(const std::string& name, const std::vector<Numeric>& x, const std::vector<Numeric>& y, const std::string& format = "")
+{
+    detail::_interpreter::get();
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* pystring = PyString_FromString(format.c_str());
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, plot_args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(plot_args);
+    if (res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename Numeric>
+bool named_semilogx(const std::string& name, const std::vector<Numeric>& x, const std::vector<Numeric>& y, const std::string& format = "")
+{
+    detail::_interpreter::get();
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* pystring = PyString_FromString(format.c_str());
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_semilogx, plot_args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(plot_args);
+    if (res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename Numeric>
+bool named_semilogy(const std::string& name, const std::vector<Numeric>& x, const std::vector<Numeric>& y, const std::string& format = "")
+{
+    detail::_interpreter::get();
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* pystring = PyString_FromString(format.c_str());
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_semilogy, plot_args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(plot_args);
+    if (res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename Numeric>
+bool named_loglog(const std::string& name, const std::vector<Numeric>& x, const std::vector<Numeric>& y, const std::string& format = "")
+{
+    detail::_interpreter::get();
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* pystring = PyString_FromString(format.c_str());
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_loglog, plot_args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(plot_args);
+    if (res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename Numeric>
+bool plot(const std::vector<Numeric>& y, const std::string& format = "")
+{
+    std::vector<Numeric> x(y.size());
+    for(size_t i=0; i<x.size(); ++i) x.at(i) = i;
+    return plot(x,y,format);
+}
+
+template<typename Numeric>
+bool plot(const std::vector<Numeric>& y, const std::map<std::string, std::string>& keywords)
+{
+    std::vector<Numeric> x(y.size());
+    for(size_t i=0; i<x.size(); ++i) x.at(i) = i;
+    return plot(x,y,keywords);
+}
+
+template<typename Numeric>
+bool stem(const std::vector<Numeric>& y, const std::string& format = "")
+{
+    std::vector<Numeric> x(y.size());
+    for (size_t i = 0; i < x.size(); ++i) x.at(i) = i;
+    return stem(x, y, format);
+}
+
+template<typename Numeric>
+void text(Numeric x, Numeric y, const std::string& s = "")
+{
+    detail::_interpreter::get();
+
+    PyObject* args = PyTuple_New(3);
+    PyTuple_SetItem(args, 0, PyFloat_FromDouble(x));
+    PyTuple_SetItem(args, 1, PyFloat_FromDouble(y));
+    PyTuple_SetItem(args, 2, PyString_FromString(s.c_str()));
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_text, args);
+    if(!res) throw std::runtime_error("Call to text() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+inline void colorbar(PyObject* mappable = NULL, const std::map<std::string, float>& keywords = {})
+{
+    if (mappable == NULL)
+        throw std::runtime_error("Must call colorbar with PyObject* returned from an image, contour, surface, etc.");
+
+    detail::_interpreter::get();
+
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, mappable);
+
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, float>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyFloat_FromDouble(it->second));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_colorbar, args, kwargs);
+    if(!res) throw std::runtime_error("Call to colorbar() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    Py_DECREF(res);
+}
+
+
+inline long figure(long number = -1)
+{
+    detail::_interpreter::get();
+
+    PyObject *res;
+    if (number == -1)
+        res = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure, detail::_interpreter::get().s_python_empty_tuple);
+    else {
+        assert(number > 0);
+
+        // Make sure interpreter is initialised
+        detail::_interpreter::get();
+
+        PyObject *args = PyTuple_New(1);
+        PyTuple_SetItem(args, 0, PyLong_FromLong(number));
+        res = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure, args);
+        Py_DECREF(args);
+    }
+
+    if(!res) throw std::runtime_error("Call to figure() failed.");
+
+    PyObject* num = PyObject_GetAttrString(res, "number");
+    if (!num) throw std::runtime_error("Could not get number attribute of figure object");
+    const long figureNumber = PyLong_AsLong(num);
+
+    Py_DECREF(num);
+    Py_DECREF(res);
+
+    return figureNumber;
+}
+
+inline bool fignum_exists(long number)
+{
+    detail::_interpreter::get();
+
+    PyObject *args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, PyLong_FromLong(number));
+    PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_fignum_exists, args);
+    if(!res) throw std::runtime_error("Call to fignum_exists() failed.");
+
+    bool ret = PyObject_IsTrue(res);
+    Py_DECREF(res);
+    Py_DECREF(args);
+
+    return ret;
+}
+
+inline void figure_size(size_t w, size_t h)
+{
+    detail::_interpreter::get();
+
+    const size_t dpi = 100;
+    PyObject* size = PyTuple_New(2);
+    PyTuple_SetItem(size, 0, PyFloat_FromDouble((double)w / dpi));
+    PyTuple_SetItem(size, 1, PyFloat_FromDouble((double)h / dpi));
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "figsize", size);
+    PyDict_SetItemString(kwargs, "dpi", PyLong_FromSize_t(dpi));
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_figure,
+            detail::_interpreter::get().s_python_empty_tuple, kwargs);
+
+    Py_DECREF(kwargs);
+
+    if(!res) throw std::runtime_error("Call to figure_size() failed.");
+    Py_DECREF(res);
+}
+
+inline void legend()
+{
+    detail::_interpreter::get();
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_legend, detail::_interpreter::get().s_python_empty_tuple);
+    if(!res) throw std::runtime_error("Call to legend() failed.");
+
+    Py_DECREF(res);
+}
+
+inline void legend(const std::map<std::string, std::string>& keywords)
+{
+  detail::_interpreter::get();
+
+  // construct keyword args
+  PyObject* kwargs = PyDict_New();
+  for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+  {
+    PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+  }
+
+  PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_legend, detail::_interpreter::get().s_python_empty_tuple, kwargs);
+  if(!res) throw std::runtime_error("Call to legend() failed.");
+
+  Py_DECREF(kwargs);
+  Py_DECREF(res);  
+}
+
+template<typename Numeric>
+void ylim(Numeric left, Numeric right)
+{
+    detail::_interpreter::get();
+
+    PyObject* list = PyList_New(2);
+    PyList_SetItem(list, 0, PyFloat_FromDouble(left));
+    PyList_SetItem(list, 1, PyFloat_FromDouble(right));
+
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, list);
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_ylim, args);
+    if(!res) throw std::runtime_error("Call to ylim() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+template<typename Numeric>
+void xlim(Numeric left, Numeric right)
+{
+    detail::_interpreter::get();
+
+    PyObject* list = PyList_New(2);
+    PyList_SetItem(list, 0, PyFloat_FromDouble(left));
+    PyList_SetItem(list, 1, PyFloat_FromDouble(right));
+
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, list);
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_xlim, args);
+    if(!res) throw std::runtime_error("Call to xlim() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+
+inline double* xlim()
+{
+    detail::_interpreter::get();
+
+    PyObject* args = PyTuple_New(0);
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_xlim, args);
+    PyObject* left = PyTuple_GetItem(res,0);
+    PyObject* right = PyTuple_GetItem(res,1);
+
+    double* arr = new double[2];
+    arr[0] = PyFloat_AsDouble(left);
+    arr[1] = PyFloat_AsDouble(right);
+
+    if(!res) throw std::runtime_error("Call to xlim() failed.");
+
+    Py_DECREF(res);
+    return arr;
+}
+
+
+inline double* ylim()
+{
+    detail::_interpreter::get();
+
+    PyObject* args = PyTuple_New(0);
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_ylim, args);
+    PyObject* left = PyTuple_GetItem(res,0);
+    PyObject* right = PyTuple_GetItem(res,1);
+
+    double* arr = new double[2];
+    arr[0] = PyFloat_AsDouble(left);
+    arr[1] = PyFloat_AsDouble(right);
+
+    if(!res) throw std::runtime_error("Call to ylim() failed.");
+
+    Py_DECREF(res);
+    return arr;
+}
+
+template<typename Numeric>
+inline void xticks(const std::vector<Numeric> &ticks, const std::vector<std::string> &labels = {}, const std::map<std::string, std::string>& keywords = {})
+{
+    assert(labels.size() == 0 || ticks.size() == labels.size());
+
+    detail::_interpreter::get();
+
+    // using numpy array
+    PyObject* ticksarray = detail::get_array(ticks);
+
+    PyObject* args;
+    if(labels.size() == 0) {
+        // construct positional args
+        args = PyTuple_New(1);
+        PyTuple_SetItem(args, 0, ticksarray);
+    } else {
+        // make tuple of tick labels
+        PyObject* labelstuple = PyTuple_New(labels.size());
+        for (size_t i = 0; i < labels.size(); i++)
+            PyTuple_SetItem(labelstuple, i, PyUnicode_FromString(labels[i].c_str()));
+
+        // construct positional args
+        args = PyTuple_New(2);
+        PyTuple_SetItem(args, 0, ticksarray);
+        PyTuple_SetItem(args, 1, labelstuple);
+    }
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_xticks, args, kwargs);
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    if(!res) throw std::runtime_error("Call to xticks() failed");
+
+    Py_DECREF(res);
+}
+
+template<typename Numeric>
+inline void xticks(const std::vector<Numeric> &ticks, const std::map<std::string, std::string>& keywords)
+{
+    xticks(ticks, {}, keywords);
+}
+
+template<typename Numeric>
+inline void yticks(const std::vector<Numeric> &ticks, const std::vector<std::string> &labels = {}, const std::map<std::string, std::string>& keywords = {})
+{
+    assert(labels.size() == 0 || ticks.size() == labels.size());
+
+    detail::_interpreter::get();
+
+    // using numpy array
+    PyObject* ticksarray = detail::get_array(ticks);
+
+    PyObject* args;
+    if(labels.size() == 0) {
+        // construct positional args
+        args = PyTuple_New(1);
+        PyTuple_SetItem(args, 0, ticksarray);
+    } else {
+        // make tuple of tick labels
+        PyObject* labelstuple = PyTuple_New(labels.size());
+        for (size_t i = 0; i < labels.size(); i++)
+            PyTuple_SetItem(labelstuple, i, PyUnicode_FromString(labels[i].c_str()));
+
+        // construct positional args
+        args = PyTuple_New(2);
+        PyTuple_SetItem(args, 0, ticksarray);
+        PyTuple_SetItem(args, 1, labelstuple);
+    }
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_yticks, args, kwargs);
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    if(!res) throw std::runtime_error("Call to yticks() failed");
+
+    Py_DECREF(res);
+}
+
+template<typename Numeric>
+inline void yticks(const std::vector<Numeric> &ticks, const std::map<std::string, std::string>& keywords)
+{
+    yticks(ticks, {}, keywords);
+}
+
+template <typename Numeric> inline void margins(Numeric margin)
+{
+    // construct positional args
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, PyFloat_FromDouble(margin));
+
+    PyObject* res =
+            PyObject_CallObject(detail::_interpreter::get().s_python_function_margins, args);
+    if (!res)
+        throw std::runtime_error("Call to margins() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+template <typename Numeric> inline void margins(Numeric margin_x, Numeric margin_y)
+{
+    // construct positional args
+    PyObject* args = PyTuple_New(2);
+    PyTuple_SetItem(args, 0, PyFloat_FromDouble(margin_x));
+    PyTuple_SetItem(args, 1, PyFloat_FromDouble(margin_y));
+
+    PyObject* res =
+            PyObject_CallObject(detail::_interpreter::get().s_python_function_margins, args);
+    if (!res)
+        throw std::runtime_error("Call to margins() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+
+inline void tick_params(const std::map<std::string, std::string>& keywords, const std::string axis = "both")
+{
+  detail::_interpreter::get();
+
+  // construct positional args
+  PyObject* args;
+  args = PyTuple_New(1);
+  PyTuple_SetItem(args, 0, PyString_FromString(axis.c_str()));
+
+  // construct keyword args
+  PyObject* kwargs = PyDict_New();
+  for (std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+  {
+    PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+  }
+
+
+  PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_tick_params, args, kwargs);
+
+  Py_DECREF(args);
+  Py_DECREF(kwargs);
+  if (!res) throw std::runtime_error("Call to tick_params() failed");
+
+  Py_DECREF(res);
+}
+
+inline void subplot(long nrows, long ncols, long plot_number)
+{
+    detail::_interpreter::get();
+    
+    // construct positional args
+    PyObject* args = PyTuple_New(3);
+    PyTuple_SetItem(args, 0, PyFloat_FromDouble(nrows));
+    PyTuple_SetItem(args, 1, PyFloat_FromDouble(ncols));
+    PyTuple_SetItem(args, 2, PyFloat_FromDouble(plot_number));
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_subplot, args);
+    if(!res) throw std::runtime_error("Call to subplot() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+inline void subplot2grid(long nrows, long ncols, long rowid=0, long colid=0, long rowspan=1, long colspan=1)
+{
+    detail::_interpreter::get();
+
+    PyObject* shape = PyTuple_New(2);
+    PyTuple_SetItem(shape, 0, PyLong_FromLong(nrows));
+    PyTuple_SetItem(shape, 1, PyLong_FromLong(ncols));
+
+    PyObject* loc = PyTuple_New(2);
+    PyTuple_SetItem(loc, 0, PyLong_FromLong(rowid));
+    PyTuple_SetItem(loc, 1, PyLong_FromLong(colid));
+
+    PyObject* args = PyTuple_New(4);
+    PyTuple_SetItem(args, 0, shape);
+    PyTuple_SetItem(args, 1, loc);
+    PyTuple_SetItem(args, 2, PyLong_FromLong(rowspan));
+    PyTuple_SetItem(args, 3, PyLong_FromLong(colspan));
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_subplot2grid, args);
+    if(!res) throw std::runtime_error("Call to subplot2grid() failed.");
+
+    Py_DECREF(shape);
+    Py_DECREF(loc);
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+inline void title(const std::string &titlestr, const std::map<std::string, std::string> &keywords = {})
+{
+    detail::_interpreter::get();
+
+    PyObject* pytitlestr = PyString_FromString(titlestr.c_str());
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, pytitlestr);
+
+    PyObject* kwargs = PyDict_New();
+    for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_title, args, kwargs);
+    if(!res) throw std::runtime_error("Call to title() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    Py_DECREF(res);
+}
+
+inline void suptitle(const std::string &suptitlestr, const std::map<std::string, std::string> &keywords = {})
+{
+    detail::_interpreter::get();
+    
+    PyObject* pysuptitlestr = PyString_FromString(suptitlestr.c_str());
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, pysuptitlestr);
+
+    PyObject* kwargs = PyDict_New();
+    for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_suptitle, args, kwargs);
+    if(!res) throw std::runtime_error("Call to suptitle() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    Py_DECREF(res);
+}
+
+inline void axis(const std::string &axisstr)
+{
+    detail::_interpreter::get();
+
+    PyObject* str = PyString_FromString(axisstr.c_str());
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, str);
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_axis, args);
+    if(!res) throw std::runtime_error("Call to title() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+inline void axvline(double x, double ymin = 0., double ymax = 1., const std::map<std::string, std::string>& keywords = std::map<std::string, std::string>())
+{
+    detail::_interpreter::get();
+
+    // construct positional args
+    PyObject* args = PyTuple_New(3);
+    PyTuple_SetItem(args, 0, PyFloat_FromDouble(x));
+    PyTuple_SetItem(args, 1, PyFloat_FromDouble(ymin));
+    PyTuple_SetItem(args, 2, PyFloat_FromDouble(ymax));
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_axvline, args, kwargs);
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+
+    if(res) Py_DECREF(res);
+}
+
+inline void axvspan(double xmin, double xmax, double ymin = 0., double ymax = 1., const std::map<std::string, std::string>& keywords = std::map<std::string, std::string>())
+{
+    // construct positional args
+    PyObject* args = PyTuple_New(4);
+    PyTuple_SetItem(args, 0, PyFloat_FromDouble(xmin));
+    PyTuple_SetItem(args, 1, PyFloat_FromDouble(xmax));
+    PyTuple_SetItem(args, 2, PyFloat_FromDouble(ymin));
+    PyTuple_SetItem(args, 3, PyFloat_FromDouble(ymax));
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+    if (it->first == "linewidth" || it->first == "alpha")
+            PyDict_SetItemString(kwargs, it->first.c_str(), PyFloat_FromDouble(std::stod(it->second)));
+    else
+            PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_axvspan, args, kwargs);
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+
+    if(res) Py_DECREF(res);
+}
+
+inline void xlabel(const std::string &str, const std::map<std::string, std::string> &keywords = {})
+{
+    detail::_interpreter::get();
+
+    PyObject* pystr = PyString_FromString(str.c_str());
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, pystr);
+
+    PyObject* kwargs = PyDict_New();
+    for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_xlabel, args, kwargs);
+    if(!res) throw std::runtime_error("Call to xlabel() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    Py_DECREF(res);
+}
+
+inline void ylabel(const std::string &str, const std::map<std::string, std::string>& keywords = {})
+{
+    detail::_interpreter::get();
+
+    PyObject* pystr = PyString_FromString(str.c_str());
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, pystr);
+
+    PyObject* kwargs = PyDict_New();
+    for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_ylabel, args, kwargs);
+    if(!res) throw std::runtime_error("Call to ylabel() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    Py_DECREF(res);
+}
+
+inline void set_zlabel(const std::string &str, const std::map<std::string, std::string>& keywords = {})
+{
+    detail::_interpreter::get();
+
+    // Same as with plot_surface: We lazily load the modules here the first time 
+    // this function is called because I'm not sure that we can assume "matplotlib 
+    // installed" implies "mpl_toolkits installed" on all platforms, and we don't 
+    // want to require it for people who don't need 3d plots.
+    static PyObject *mpl_toolkitsmod = nullptr, *axis3dmod = nullptr;
+    if (!mpl_toolkitsmod) {
+        PyObject* mpl_toolkits = PyString_FromString("mpl_toolkits");
+        PyObject* axis3d = PyString_FromString("mpl_toolkits.mplot3d");
+        if (!mpl_toolkits || !axis3d) { throw std::runtime_error("couldnt create string"); }
+
+        mpl_toolkitsmod = PyImport_Import(mpl_toolkits);
+        Py_DECREF(mpl_toolkits);
+        if (!mpl_toolkitsmod) { throw std::runtime_error("Error loading module mpl_toolkits!"); }
+
+        axis3dmod = PyImport_Import(axis3d);
+        Py_DECREF(axis3d);
+        if (!axis3dmod) { throw std::runtime_error("Error loading module mpl_toolkits.mplot3d!"); }
+    }
+
+    PyObject* pystr = PyString_FromString(str.c_str());
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, pystr);
+
+    PyObject* kwargs = PyDict_New();
+    for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject *ax =
+    PyObject_CallObject(detail::_interpreter::get().s_python_function_gca,
+      detail::_interpreter::get().s_python_empty_tuple);
+    if (!ax) throw std::runtime_error("Call to gca() failed.");
+    Py_INCREF(ax);
+
+    PyObject *zlabel = PyObject_GetAttrString(ax, "set_zlabel");
+    if (!zlabel) throw std::runtime_error("Attribute set_zlabel not found.");
+    Py_INCREF(zlabel);
+
+    PyObject *res = PyObject_Call(zlabel, args, kwargs);
+    if (!res) throw std::runtime_error("Call to set_zlabel() failed.");
+    Py_DECREF(zlabel);
+
+    Py_DECREF(ax);
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    if (res) Py_DECREF(res);
+}
+
+inline void grid(bool flag)
+{
+    detail::_interpreter::get();
+
+    PyObject* pyflag = flag ? Py_True : Py_False;
+    Py_INCREF(pyflag);
+
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, pyflag);
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_grid, args);
+    if(!res) throw std::runtime_error("Call to grid() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+inline void show(const bool block = true)
+{
+    detail::_interpreter::get();
+
+    PyObject* res;
+    if(block)
+    {
+        res = PyObject_CallObject(
+                detail::_interpreter::get().s_python_function_show,
+                detail::_interpreter::get().s_python_empty_tuple);
+    }
+    else
+    {
+        PyObject *kwargs = PyDict_New();
+        PyDict_SetItemString(kwargs, "block", Py_False);
+        res = PyObject_Call( detail::_interpreter::get().s_python_function_show, detail::_interpreter::get().s_python_empty_tuple, kwargs);
+       Py_DECREF(kwargs);
+    }
+
+
+    if (!res) throw std::runtime_error("Call to show() failed.");
+
+    Py_DECREF(res);
+}
+
+inline void close()
+{
+    detail::_interpreter::get();
+
+    PyObject* res = PyObject_CallObject(
+            detail::_interpreter::get().s_python_function_close,
+            detail::_interpreter::get().s_python_empty_tuple);
+
+    if (!res) throw std::runtime_error("Call to close() failed.");
+
+    Py_DECREF(res);
+}
+
+inline void xkcd() {
+    detail::_interpreter::get();
+
+    PyObject* res;
+    PyObject *kwargs = PyDict_New();
+
+    res = PyObject_Call(detail::_interpreter::get().s_python_function_xkcd,
+            detail::_interpreter::get().s_python_empty_tuple, kwargs);
+
+    Py_DECREF(kwargs);
+
+    if (!res)
+        throw std::runtime_error("Call to show() failed.");
+
+    Py_DECREF(res);
+}
+
+inline void draw()
+{
+    detail::_interpreter::get();
+
+    PyObject* res = PyObject_CallObject(
+        detail::_interpreter::get().s_python_function_draw,
+        detail::_interpreter::get().s_python_empty_tuple);
+
+    if (!res) throw std::runtime_error("Call to draw() failed.");
+
+    Py_DECREF(res);
+}
+
+template<typename Numeric>
+inline void pause(Numeric interval)
+{
+    detail::_interpreter::get();
+
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, PyFloat_FromDouble(interval));
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_pause, args);
+    if(!res) throw std::runtime_error("Call to pause() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+inline void save(const std::string& filename)
+{
+    detail::_interpreter::get();
+
+    PyObject* pyfilename = PyString_FromString(filename.c_str());
+
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, pyfilename);
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_save, args);
+    if (!res) throw std::runtime_error("Call to save() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+inline void clf() {
+    detail::_interpreter::get();
+
+    PyObject *res = PyObject_CallObject(
+        detail::_interpreter::get().s_python_function_clf,
+        detail::_interpreter::get().s_python_empty_tuple);
+
+    if (!res) throw std::runtime_error("Call to clf() failed.");
+
+    Py_DECREF(res);
+}
+
+inline void cla() {
+    detail::_interpreter::get();
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_cla,
+                                        detail::_interpreter::get().s_python_empty_tuple);
+
+    if (!res)
+        throw std::runtime_error("Call to cla() failed.");
+
+    Py_DECREF(res);
+}
+
+inline void ion() {
+    detail::_interpreter::get();
+
+    PyObject *res = PyObject_CallObject(
+        detail::_interpreter::get().s_python_function_ion,
+        detail::_interpreter::get().s_python_empty_tuple);
+
+    if (!res) throw std::runtime_error("Call to ion() failed.");
+
+    Py_DECREF(res);
+}
+
+inline std::vector<std::array<double, 2>> ginput(const int numClicks = 1, const std::map<std::string, std::string>& keywords = {})
+{
+    detail::_interpreter::get();
+
+    PyObject *args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, PyLong_FromLong(numClicks));
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(
+        detail::_interpreter::get().s_python_function_ginput, args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(args);
+    if (!res) throw std::runtime_error("Call to ginput() failed.");
+
+    const size_t len = PyList_Size(res);
+    std::vector<std::array<double, 2>> out;
+    out.reserve(len);
+    for (size_t i = 0; i < len; i++) {
+        PyObject *current = PyList_GetItem(res, i);
+        std::array<double, 2> position;
+        position[0] = PyFloat_AsDouble(PyTuple_GetItem(current, 0));
+        position[1] = PyFloat_AsDouble(PyTuple_GetItem(current, 1));
+        out.push_back(position);
+    }
+    Py_DECREF(res);
+
+    return out;
+}
+
+// Actually, is there any reason not to call this automatically for every plot?
+inline void tight_layout() {
+    detail::_interpreter::get();
+
+    PyObject *res = PyObject_CallObject(
+        detail::_interpreter::get().s_python_function_tight_layout,
+        detail::_interpreter::get().s_python_empty_tuple);
+
+    if (!res) throw std::runtime_error("Call to tight_layout() failed.");
+
+    Py_DECREF(res);
+}
+
+// Support for variadic plot() and initializer lists:
+
+namespace detail {
+
+template<typename T>
+using is_function = typename std::is_function<std::remove_pointer<std::remove_reference<T>>>::type;
+
+template<bool obj, typename T>
+struct is_callable_impl;
+
+template<typename T>
+struct is_callable_impl<false, T>
+{
+    typedef is_function<T> type;
+}; // a non-object is callable iff it is a function
+
+template<typename T>
+struct is_callable_impl<true, T>
+{
+    struct Fallback { void operator()(); };
+    struct Derived : T, Fallback { };
+
+    template<typename U, U> struct Check;
+
+    template<typename U>
+    static std::true_type test( ... ); // use a variadic function to make sure (1) it accepts everything and (2) its always the worst match
+
+    template<typename U>
+    static std::false_type test( Check<void(Fallback::*)(), &U::operator()>* );
+
+public:
+    typedef decltype(test<Derived>(nullptr)) type;
+    typedef decltype(&Fallback::operator()) dtype;
+    static constexpr bool value = type::value;
+}; // an object is callable iff it defines operator()
+
+template<typename T>
+struct is_callable
+{
+    // dispatch to is_callable_impl<true, T> or is_callable_impl<false, T> depending on whether T is of class type or not
+    typedef typename is_callable_impl<std::is_class<T>::value, T>::type type;
+};
+
+template<typename IsYDataCallable>
+struct plot_impl { };
+
+template<>
+struct plot_impl<std::false_type>
+{
+    template<typename IterableX, typename IterableY>
+    bool operator()(const IterableX& x, const IterableY& y, const std::string& format)
+    {
+        detail::_interpreter::get();
+
+        // 2-phase lookup for distance, begin, end
+        using std::distance;
+        using std::begin;
+        using std::end;
+
+        auto xs = distance(begin(x), end(x));
+        auto ys = distance(begin(y), end(y));
+        assert(xs == ys && "x and y data must have the same number of elements!");
+
+        PyObject* xlist = PyList_New(xs);
+        PyObject* ylist = PyList_New(ys);
+        PyObject* pystring = PyString_FromString(format.c_str());
+
+        auto itx = begin(x), ity = begin(y);
+        for(size_t i = 0; i < xs; ++i) {
+            PyList_SetItem(xlist, i, PyFloat_FromDouble(*itx++));
+            PyList_SetItem(ylist, i, PyFloat_FromDouble(*ity++));
+        }
+
+        PyObject* plot_args = PyTuple_New(3);
+        PyTuple_SetItem(plot_args, 0, xlist);
+        PyTuple_SetItem(plot_args, 1, ylist);
+        PyTuple_SetItem(plot_args, 2, pystring);
+
+        PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_plot, plot_args);
+
+        Py_DECREF(plot_args);
+        if(res) Py_DECREF(res);
+
+        return res;
+    }
+};
+
+template<>
+struct plot_impl<std::true_type>
+{
+    template<typename Iterable, typename Callable>
+    bool operator()(const Iterable& ticks, const Callable& f, const std::string& format)
+    {
+        if(begin(ticks) == end(ticks)) return true;
+
+        // We could use additional meta-programming to deduce the correct element type of y,
+        // but all values have to be convertible to double anyways
+        std::vector<double> y;
+        for(auto x : ticks) y.push_back(f(x));
+        return plot_impl<std::false_type>()(ticks,y,format);
+    }
+};
+
+} // end namespace detail
+
+// recursion stop for the above
+template<typename... Args>
+bool plot() { return true; }
+
+template<typename A, typename B, typename... Args>
+bool plot(const A& a, const B& b, const std::string& format, Args... args)
+{
+    return detail::plot_impl<typename detail::is_callable<B>::type>()(a,b,format) && plot(args...);
+}
+
+/*
+ * This group of plot() functions is needed to support initializer lists, i.e. calling
+ *    plot( {1,2,3,4} )
+ */
+inline bool plot(const std::vector<double>& x, const std::vector<double>& y, const std::string& format = "") {
+    return plot<double,double>(x,y,format);
+}
+
+inline bool plot(const std::vector<double>& y, const std::string& format = "") {
+    return plot<double>(y,format);
+}
+
+inline bool plot(const std::vector<double>& x, const std::vector<double>& y, const std::map<std::string, std::string>& keywords) {
+    return plot<double>(x,y,keywords);
+}
+
+/*
+ * This class allows dynamic plots, ie changing the plotted data without clearing and re-plotting
+ */
+class Plot
+{
+public:
+    // default initialization with plot label, some data and format
+    template<typename Numeric>
+    Plot(const std::string& name, const std::vector<Numeric>& x, const std::vector<Numeric>& y, const std::string& format = "") {
+        detail::_interpreter::get();
+
+        assert(x.size() == y.size());
+
+        PyObject* kwargs = PyDict_New();
+        if(name != "")
+            PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+        PyObject* xarray = detail::get_array(x);
+        PyObject* yarray = detail::get_array(y);
+
+        PyObject* pystring = PyString_FromString(format.c_str());
+
+        PyObject* plot_args = PyTuple_New(3);
+        PyTuple_SetItem(plot_args, 0, xarray);
+        PyTuple_SetItem(plot_args, 1, yarray);
+        PyTuple_SetItem(plot_args, 2, pystring);
+
+        PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, plot_args, kwargs);
+
+        Py_DECREF(kwargs);
+        Py_DECREF(plot_args);
+
+        if(res)
+        {
+            line= PyList_GetItem(res, 0);
+
+            if(line)
+                set_data_fct = PyObject_GetAttrString(line,"set_data");
+            else
+                Py_DECREF(line);
+            Py_DECREF(res);
+        }
+    }
+
+    // shorter initialization with name or format only
+    // basically calls line, = plot([], [])
+    Plot(const std::string& name = "", const std::string& format = "")
+        : Plot(name, std::vector<double>(), std::vector<double>(), format) {}
+
+    template<typename Numeric>
+    bool update(const std::vector<Numeric>& x, const std::vector<Numeric>& y) {
+        assert(x.size() == y.size());
+        if(set_data_fct)
+        {
+            PyObject* xarray = detail::get_array(x);
+            PyObject* yarray = detail::get_array(y);
+
+            PyObject* plot_args = PyTuple_New(2);
+            PyTuple_SetItem(plot_args, 0, xarray);
+            PyTuple_SetItem(plot_args, 1, yarray);
+
+            PyObject* res = PyObject_CallObject(set_data_fct, plot_args);
+            if (res) Py_DECREF(res);
+            return res;
+        }
+        return false;
+    }
+
+    // clears the plot but keep it available
+    bool clear() {
+        return update(std::vector<double>(), std::vector<double>());
+    }
+
+    // definitely remove this line
+    void remove() {
+        if(line)
+        {
+            auto remove_fct = PyObject_GetAttrString(line,"remove");
+            PyObject* args = PyTuple_New(0);
+            PyObject* res = PyObject_CallObject(remove_fct, args);
+            if (res) Py_DECREF(res);
+        }
+        decref();
+    }
+
+    ~Plot() {
+        decref();
+    }
+private:
+
+    void decref() {
+        if(line)
+            Py_DECREF(line);
+        if(set_data_fct)
+            Py_DECREF(set_data_fct);
+    }
+
+
+    PyObject* line = nullptr;
+    PyObject* set_data_fct = nullptr;
+};
+
+} // end namespace matplotlibcpp
diff --git a/lib/nauty/.gitignore b/lib/nauty/.gitignore
new file mode 100644
index 0000000..8ad26a0
--- /dev/null
+++ b/lib/nauty/.gitignore
@@ -0,0 +1,2 @@
+config.log
+config.status
diff --git a/lib/nauty/CMakeLists.txt b/lib/nauty/CMakeLists.txt
new file mode 100644
index 0000000..2f6b296
--- /dev/null
+++ b/lib/nauty/CMakeLists.txt
@@ -0,0 +1,24 @@
+project(nauty LANGUAGES C)
+
+include_directories(${PROJECT_SOURCE_DIR})
+
+execute_process(COMMAND "./configure"
+		WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+		RESULT_VARIABLE CONF_RESULT
+		OUTPUT_VARIABLE CONF_OUTPUT)
+
+file(GLOB FILENAMES *.c)
+
+list(REMOVE_ITEM FILENAMES ${PROJECT_SOURCE_DIR}/poptest.c)
+list(REMOVE_ITEM FILENAMES ${PROJECT_SOURCE_DIR}/sorttemplates.c)
+list(REMOVE_ITEM FILENAMES ${PROJECT_SOURCE_DIR}/testg.c)
+list(REMOVE_ITEM FILENAMES ${PROJECT_SOURCE_DIR}/splay.c)
+list(REMOVE_ITEM FILENAMES ${PROJECT_SOURCE_DIR}/sumlines.c)
+
+# Surpress warnings from this external library
+if (UNIX)
+    set(CMAKE_C_FLAGS "-w")
+endif()
+
+add_library(nauty ${FILENAMES})
+target_include_directories(nauty INTERFACE ${PROJECT_SOURCE_DIR})
diff --git a/lib/nauty/COPYRIGHT b/lib/nauty/COPYRIGHT
new file mode 100644
index 0000000..46cfbff
--- /dev/null
+++ b/lib/nauty/COPYRIGHT
@@ -0,0 +1,39 @@
+This is the license for the software package Nauty and
+Traces, package versions 2.6r3 and later.
+
+Four categories of software are included in the package:
+A. All files not listed as B-D below, copyright Brendan McKay (1984-)
+B. Files traces.h, traces.c and dretodot.c, copyright Adolfo Piperno (2008-)
+C. File watercluster2.c, copyright Gunnar Brinkmann (2009-)
+D. Files planarity.h and planarity.c, copyright Magma project,
+   University of Sydney
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this software except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+Brendan McKay: Australian National University; Brendan.McKay@anu.edu.au
+Adolfo Piperno: University of Rome "Sapienza"; piperno@di.uniroma1.it
+Gunnar Brinkmann: University of Ghent; Gunnar.Brinkmann@UGent.be
+Magma Administration: University of Sydney; admin@maths.usyd.edu.au
+
+---END-OF-FORMAL-COPYRIGHT-NOTICE---
+
+Earlier (pre-2.6) versions of this package carried a different
+notice: "Permission is hereby given for use and/or distribution
+with the exception of sale for profit or application with nontrivial
+military significance." These days most people use nauty via a
+larger package such as Magma, Sage, or GAP, and often they don't
+even know they are using nauty. Due to the legal nonsense that
+large package distributors need to worry about, it has proved too
+much trouble to maintain an idiosyncratic licence. I didn't change
+my opinion about military use, but it is no longer part of the
+formal notice. Brendan McKay (Jan 20, 2016)
diff --git a/lib/nauty/NRswitchg.c b/lib/nauty/NRswitchg.c
new file mode 100644
index 0000000..074e583
--- /dev/null
+++ b/lib/nauty/NRswitchg.c
@@ -0,0 +1,198 @@
+/* NRswitchg.c  nauty version 2.4; B D McKay, Dec 2005 */
+
+#define USAGE "NRswitchg [-lq] [infile [outfile]]"
+
+#define HELPTEXT \
+" For each v, complement the edges from N(v) to V(G)-N(v)-v.\n\
+\n\
+    The output file has a header if and only if the input file does.\n\
+\n\
+    -l  Canonically label outputs.\n\
+    -q  Suppress auxiliary information.\n"
+
+/*************************************************************************/
+
+#include "gtools.h" 
+
+/**************************************************************************/
+
+void
+NRswitch(graph *g, int m, int n, int v, graph *h)
+/* h := g with N-R edge set complemented */
+{
+	register int i,j;
+	register setword *gv,*gi,*hi;
+#if MAXN
+	set Nset[MAXM];
+	set Rset[MAXM];
+#else
+	DYNALLSTAT(set,Nset,Nset_sz);
+	DYNALLSTAT(set,Rset,Rset_sz);
+	DYNALLOC1(set,Nset,Nset_sz,m,"NRswitchg");
+	DYNALLOC1(set,Rset,Rset_sz,m,"NRswitchg");
+#endif
+
+	EMPTYSET(Rset,m);
+	for (i = 0; i < n; ++i) ADDELEMENT(Rset,i);
+
+	gv = GRAPHROW(g,v,m);
+
+	for (j = 0; j < m; ++j)
+	{
+	    Nset[j] = gv[j];
+	    Rset[j] ^= gv[j];
+	}
+
+	FLIPELEMENT(Rset,v);
+
+	gi = (setword*) g;
+	hi = (setword*) h;
+
+	for (i = 0; i < n; ++i)
+	{
+	    if (i == v)
+	        for (j = 0; j < m; ++j) hi[j] = gi[j];
+	    else if (ISELEMENT(Nset,i))
+		for (j = 0; j < m; ++j) hi[j] = gi[j] ^ Rset[j];
+	    else
+		for (j = 0; j < m; ++j) hi[j] = gi[j] ^ Nset[j];
+
+	    gi += m;
+	    hi += m;
+	}
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+        char *infilename,*outfilename;
+        FILE *infile,*outfile;
+        boolean badargs,dolabel,quiet;
+	int j,m,n,v,argnum;
+	int codetype,outcode;
+	graph *g;
+	nauty_counter nin,nout;
+        char *arg,sw;
+	static graph *gq;
+	double t;
+#if MAXN
+	graph gc[MAXN*MAXM],h[MAXN*MAXM];
+#else
+	DYNALLSTAT(graph,gc,gc_sz);
+	DYNALLSTAT(graph,h,h_sz);
+#endif
+
+	HELP; PUTVERSION;
+
+        infilename = outfilename = NULL;
+	dolabel = quiet = FALSE;
+
+	argnum = 0;
+	badargs = FALSE;
+	for (j = 1; !badargs && j < argc; ++j)
+	{
+	    arg = argv[j];
+	    if (arg[0] == '-' && arg[1] != '\0')
+	    {
+		++arg;
+		while (*arg != '\0')
+		{
+		    sw = *arg++;
+		         SWBOOLEAN('l',dolabel)
+		    else SWBOOLEAN('q',quiet)
+		    else badargs = TRUE;
+		}
+	    }
+	    else
+	    {
+		++argnum;
+		if      (argnum == 1) infilename = arg;
+	        else if (argnum == 2) outfilename = arg;
+		else                  badargs = TRUE;
+	    }
+	}
+
+	if (badargs)
+	{
+	    fprintf(stderr,">E Usage: %s\n",USAGE);
+	    GETHELP;
+	    exit(1);
+	}
+
+	if (!quiet)
+	{
+	    fprintf(stderr,">A NRswitchg");
+	    if (dolabel) fprintf(stderr," -l");
+	    if (argnum > 0) fprintf(stderr," %s",infilename);
+	    if (argnum > 1) fprintf(stderr," %s",outfilename);
+	    fprintf(stderr,"\n");
+	    fflush(stderr);
+	}
+
+	if (infilename && infilename[0] == '-') infilename = NULL;
+	infile = opengraphfile(infilename,&codetype,FALSE,1);
+	if (!infile) exit(1);
+	if (!infilename) infilename = "stdin";
+
+	if (!outfilename || outfilename[0] == '-')
+	{
+	    outfilename = "stdout";
+	    outfile = stdout;
+	}
+	else if ((outfile = fopen(outfilename,"w")) == NULL)
+	{
+	    fprintf(stderr,"Can't open output file %s\n",outfilename);
+	    gt_abort(NULL);
+	}
+
+	if (codetype&SPARSE6) outcode = SPARSE6;
+	else                  outcode = GRAPH6;
+
+	if (codetype&HAS_HEADER)
+	{
+	    if (outcode == SPARSE6) writeline(outfile,SPARSE6_HEADER);
+	    else    		    writeline(outfile,GRAPH6_HEADER);
+	}
+
+	if (dolabel) nauty_check(WORDSIZE,1,1,NAUTYVERSIONID);
+
+	nin = nout = 0;
+	t = CPUTIME;
+	while (TRUE)
+	{
+	    if ((g = readg(infile,NULL,0,&m,&n)) == NULL) break;
+	    ++nin;
+#if !MAXN
+	    DYNALLOC2(graph,gc,gc_sz,n,m,"NRswitchg");
+#endif
+	    for (v = 0; v < n; ++v)
+	    {		
+	    	NRswitch(g,m,n,v,gc);
+		gq = gc;
+	    
+	        if (dolabel)
+	        {
+#if !MAXN
+		    DYNALLOC2(graph,h,h_sz,n,m,"compl");
+#endif
+	 	    fcanonise(gq,m,n,h,NULL,FALSE);
+		    gq = h;
+	        }
+	        if (outcode == SPARSE6) writes6(outfile,gq,m,n);
+	        else                    writeg6(outfile,gq,m,n);
+		++nout;
+	    }
+	    FREES(g);
+	}
+	t = CPUTIME - t;
+
+        if (!quiet)
+            fprintf(stderr,
+                ">Z  " COUNTER_FMT " graphs read from %s, "
+                       COUNTER_FMT " written to %s; %3.2f sec.\n",
+                    nin,infilename,nout,outfilename,t);
+
+	exit(0);
+}
diff --git a/lib/nauty/README b/lib/nauty/README
new file mode 100644
index 0000000..a163a0e
--- /dev/null
+++ b/lib/nauty/README
@@ -0,0 +1,118 @@
+README file for nauty 2.6 
+
+Brendan McKay, bdm@cs.anu.edu.au
+Adolfo Piperno, piperno@di.uniroma1.it
+
+------------------------------------------------------------
+
+The most recent distribution of nauty and Traces can be found at
+http://cs.anu.edu.au/~bdm/nauty and http://pallini.di.uniroma1.it .
+
+The manual nug26.pdf is available at that site and is also included
+in the distribution package.
+
+Note that nauty and Traces are copyright but free to use for most
+purposes. The details are in the file COPYRIGHT.
+
+------------------------------------------------------------
+
+INSTALLATION.
+
+See the manual for more information.
+
+If you have a working shell, and "make", you can run
+   ./configure
+followed by
+   make 
+to compile nauty and Traces for your system.
+
+If that succeeds without problem, you will have have the
+program dreadnaut ready to run.
+
+There are some options that can be specified at the ./configure
+step; see the manual.
+
+If you don't have a shell or make, manually edit the files nauty.h,
+naututil.h and gtools.h as distributed.  The parts between the lines
+======= near the start are the main things to look at.  After this
+manual editing, you can use makefile.basic as a guide to compilation.
+
+Programs which use an older version of nauty need to be
+recompiled (** not just relinked **). Make sure they define
+the options structure using one of
+DEFAULTOPTIONS_GRAPH
+DEFAULTOPTIONS_SPARSEGRAPH
+DEFAULTOPTIONS_DIGRAPH
+DEFAULTOPTIONS_SPARSEDIGRAPH
+DEFAULTOPTIONS_TRACES
+
+------------------------------------------------------------
+
+TESTING.
+
+After compiling nauty successfully, it is recommended that you run
+the included test programs.  The simplest way is
+    make checks
+
+------------------------------------------------------------
+
+MAILING LIST.
+
+There is a mailing list for announcements and discussion about
+nauty and related topics.  You can subscribe at
+http://mailman.anu.edu.au/mailman/listinfo/nauty
+
+------------------------------------------------------------
+
+OTHER FILES IN THE PACKAGE.
+
+Also in the package (documentation at the start of each source file).
+
+sumlines.c  -  This is a program designed to digest the outputs from
+  multiple runs of a program (such as a computation split into multiple
+  parts).  Lines matching given patterns can be counted and checked,
+  and numbers appearing in them can be accumulated.  Instructions appear
+  in the source file.  See the option GMP near the head of the program
+  before trying to compile.
+
+sorttemplates.c  - Some carefully tuned generic quicksort procedures.
+
+bliss2dre.c - A program which reads one file in Bliss format and writes
+  it in dreadnaut format.
+
+blisstog.c - A program which reads one or more files in Bliss format
+  and writes all the graphs in sparse6 format.
+
+poptest.c - A program for testing the POPCOUNT macro.
+
+dretodot.c - A program that reads files in dreadaut format and writes
+  dot files suitable for drawing with graphviz.
+
+------------------------------------------------------------
+
+Windows.
+
+For running nauty in Windows, Cygwin is recommended.
+
+If configure gives an error message similar to this:
+   can not guess host type: you must specify one
+then try
+   ./configure --build=unknown
+
+------------------------------------------------------------
+
+Making 32-bit executables on 64-bit Linux systems.
+
+(In bash or sh:)
+CFLAGS=-m32 CXXFLAGS=-m32 LDFLAGS=-m32 ./configure
+make clean; make
+
+This requires 32-bit libraries to be available.  On Ubuntu
+they are called ia32-libs and libc6-dev-i386.
+
+------------------------------------------------------------
+
+RECENT CHANGES.
+
+See the file changes24-26.txt for a longer list.
+See the file README_24 for a list of older changes.
diff --git a/lib/nauty/README_24 b/lib/nauty/README_24
new file mode 100644
index 0000000..4adec9e
--- /dev/null
+++ b/lib/nauty/README_24
@@ -0,0 +1,292 @@
+
+README file for nauty 2.4 
+
+Brendan McKay, bdm@cs.anu.edu.au
+
+------------------------------------------------------------
+
+The most recent distribution of nauty can be found at
+http://cs.anu.edu.au/~bdm/nauty .
+
+The manual nug.pdf is available at that site and is also included
+in the distribution package.
+
+Note that nauty is copyright but free to use for most purposes.
+The details are in the file nauty.h.
+
+The code in the file planarity.c (used by the planarg program)
+is copyright to the Magma project. 
+
+------------------------------------------------------------
+
+INSTALLATION.
+
+The first step is to unpack the archive.  On Unix-ish systems
+you can use one of these commands:
+
+   tar xzf nauty24.tar.gz
+or
+   gunzip -c nauty24.tar.gz | tar xf -
+
+This will write all the files into the subdirectory nauty24.
+Go to that directory.
+
+If you have a working shell, and make, you can run
+   ./configure
+followed by
+   make all
+to compile nauty for your system.
+
+If that succeeds without problem, you will have have the
+program dreadnaut ready to run.
+
+If you have problems during compilation, it may be that the
+configuration scripts are inadequate for your system.  Usually it
+is because of some missing system header, incompatible typedef,
+or similar.  Please send the details to the author.
+
+If you don't have a shell or make, manually edit the files nauty.h,
+naututil.h and gtools.h as distributed.  The parts between the lines
+======= near the start are the main things to look at.  After this
+manual editing, you can use makefile as a guide to compilation.
+
+Programs which use an older version of nauty need to be
+recompiled (** not just relinked **). Make sure they use the
+DEFAULTOPTIONS_GRAPH or DEFAULTOPTIONS_SPARSEGRAPH macro to define
+the fields of the options parameter.
+
+See below for compiling on a PC under DJGPP.
+
+If you are using Windows in an environment that needs Windows line
+endings (which is a configuration option in Cygwin, for example),
+then you might prefer to use nauty24.zip rather than
+nauty24.tar.gz.
+
+------------------------------------------------------------
+
+TESTING.
+
+After compiling nauty successfully, it is recommended that you run
+the included test programs.  The simplest way is
+    make checks
+
+------------------------------------------------------------
+
+MAILING LIST.
+
+There is a mailing list for announcements and discussion about
+nauty and related topics.  You can subscribe at
+http://dcsmail.anu.edu.au/cgi-bin/mailman/listinfo/nauty-list
+
+------------------------------------------------------------
+
+OTHER FILES IN THE PACKAGE.
+
+A few additional goodies are included.
+
+sumlines.c  -  This is a program designed to digest the outputs from
+  multiple runs of a program (such as a computation split into multiple
+  parts).  Lines matching given patterns can be counted and checked,
+  and numbers appearing in them can be accumulated.  Instructions appear
+  in the source file.  See the option GMP near the head of the program
+  before trying to compile.
+
+naugroup.h, naugroup.c  -  These define procedures for exhaustively
+  listing a group found by nauty.  This is done in a space-efficient way.
+  A sample program appears in nautyex3.c, but so far there is no
+  complete documentation.
+
+------------------------------------------------------------
+
+DJGPP.
+
+The Unix-like environment DJGPP can be used to run nauty and gtools on
+DOS/Win computers.  DJGPP is available at http://www.delorie.com/djgpp .
+The program shortg does not work since DJGPP does not provide a working
+pipe() system call.  Using the bash shell is recommended.  In DOS,
+Windows NT and early Windows editions, you will need to convert all
+long file names to the 8+3 limits.  Thanks to Guenter Sterntenbrink
+for helping with this.
+
+If configure gives an error message similar to this:
+   can not guess host type: you must specify one
+then try
+   ./configure --host=i686
+or use i586 for Pentium 2.  If all of those fail, try
+   ./configure --host=unknown
+
+------------------------------------------------------------
+
+Making 32-bit executables on 64-bit Linux systems.
+
+(In bash or sh:)
+CFLAGS=-m32 CXXFLAGS=-m32 LDFLAGS=-m32 ./configure
+make clean; make
+
+This requires the libraries ia32-libs and libc6-dev-i386.
+
+------------------------------------------------------------
+
+RECENT CHANGES.
+
+Here we list substantive changes made since the first 2.2 release.
+
+Nov 16, 2002:  Replaced rng.c after communication with Don Knuth.
+  The previous version had a bug (mine!) when there was no explicit
+  initialization done by the user.  It appears the error had no
+  impact on nauty (which only uses rng.c for the "s" command in
+  dreadnaut, and for genrang, but both always initialize).
+  No change to the nauty version number but beta=2.
+
+Nov 18, 2000:  Adjusted the makefile and countg/testg to work in
+  the DOS/Win environment DJGPPP (see the previous section).
+
+May 1, 2003:  Fixed PRUNE feature of genbg.
+
+May 3, 2003:  Added utility directg for making all orientations of graphs.
+
+Oct 4, 2003:  Added options -a, -Z, -d, -z to genbg.  Also, the -l
+              (canonical label) option now preserves the colouring.
+
+Nov 17, 2003: Renamed INFINITY to NAUTY_INFINITY since many C header
+              libraries define INFINITY.  If INFINITY is not defined by
+              the system, you can still use it.
+
+Nov 19, 2003: Added program biplabg to relabel bipartite graphs with the
+              colour classes contiguous.
+
+Feb 13, 2004: Revised C options for solaris on pentium
+
+Mar 1, 2004:  dretog knows !...\n type of comment
+
+May 7, 2004:  geng can be called from another program (see instructions
+              in geng.c.)
+
+May 29, 2004: added definition of SETWORD_FORMAT used to write a setword
+              with printf( ) - see nauty.h
+
+Sep 11, 2004: Added utility multig for making multigraphs based on
+              provided simple graphs; similar to directg
+
+Oct 16, 2004: To avoid problems caused by system-dependent handling of
+              external declarations, nauty() no longer accepts NULL as
+              the value of options.dispatch.  To get the previous
+              behaviour, use the value &graph_dispatch.  This will be
+              handled automatically if programs calling nauty use
+              DEFAULTOPTIONS to declare options and are recompiled.
+              Even better is to use DEFAULTOPTIONS_GRAPH.
+
+May 5, 2005:  A bug in the writing of sparse6 was found and fixed.
+              This is procedure ntos6() in gtools.c, which is invoked
+              by writes6().  The bug could only happen if all the
+              following are true:
+              1.  n = 2, 4, 8 or 16 (for n=2, only if the graph has loops)
+              2.  Vertex n-2 has non-zero degree, but vertex n-1 has
+                  zero degree.
+              These conditions never happen for graphs generated by
+              geng or genbg, nor for regular graphs or connected graphs,
+              nor for graphs canonically labelled by nauty (except maybe
+              with some unusual vertex colouring or invariant).
+              If the conditions do happen, the buggy routine may
+              (with some probability) add a spurious loop to vertex n-1.
+
+              In the package is a utility checks6:
+
+              Usage: checks6 [-w] [infile [outfile]]
+              Check a file of graphs, optionally write corrected version
+              -w  Write corrected graphs (default is not to write)
+
+------now we start version 2.3 (not released) and 2.4------
+
+Nov 10, 2004: Use faster routine getc_unlocked() for reading graphs if
+              available.  It can make a surprising difference.
+
+Nov 17, 2004: If putenv() or setenv() are available, we set LC_COLLATE to
+              "C" before executing "sort" in shortg.  This should alleviate
+	      collation issues with sort.  However, note that many
+              utilities use the locale these days so you are advised to
+	      have LC_COLLATE defined to be "C" always when you are dealing
+              with files of graphs.
+
+              Six counters in statsblk became "unsigned long" instead of
+              "long".  nauty doesn't actually use these, but we might as
+              well give them twice as long before they overflow.
+
+Nov 24, 2004: Made geng faster for generating trees.  The output labelling
+              may be different from before.  A very much faster tree
+              generator is in the works.
+
+Jan 17, 2005: Added two items to dispatch vectors:
+               init   : used for initialising something at the start
+              cleanup : used for doing something at the end, such as
+                        freeing space allocated by init()
+              See the manual for calling sequences.
+
+May 20, 2005: Update graph6 and sparse6 formats to allow much large sizes.
+              The limit is now 68719476735 vertices (best of luck getting
+              close to that!).
+
+Nov 12, 2005: Changed NAUTY_INFINITY to 2^30+2 in BIGNAUTY case
+
+2006 various: Procedures for sparse graphs implemented.
+
+              New program planarg to test for planarity and find
+              planar embeddings:   planarg -help  for details.
+	      The planarity code was written by Paulette Lieby for the
+              Magma project and used with permission.
+
+	      labelg got -S to use sparse graphs.
+              genbg -N changed to genbg -n (only Gordon uses this).
+              genrang gained -R switch for regular graphs in text format.
+              gtools.c has code for reading and writing planarcode.
+              listg got a compile time option to select "Matrix" or
+                 "array" for Maple output.
+              pickg/countg got -T for counting triangles
+
+	      Better configuration for MacOSX.
+
+Nov 22, 2006: Removed usertcellproc from options.  Greater functionality
+              is now available using the new targetcell field in the
+              dispatch vector.  The u8 command has gone from dreadnaut.
+
+              Changed bestcell to targetcell in dispatch vector.
+
+Nov 29, 2006: Added extraoptions field (currently unused) to optionblk
+
+Dec 9, 2006:  Added an invariant adjacencies_sg(), recommended for digraphs
+              when using sparse representation.
+
+Dec 10, 2006: Remove BIGNAUTY, whose usefulness has passed.  Now the types
+	      shortish and permutation are synonymous with int always.
+              The limit on the number of vertices is 2^30 unless int
+              has only 16 bits (still any of them around?) in which
+              case it is 2^15-3. Programs previously linked with
+              files like nautyB.o can now be linked with nauty.o.
+              Alternatively, "make bigs" will create files like
+              nautyB.o by copying.
+
+June 26, 2007:  Fixed an error in  listg -s  reported by Evan Heidtmann.
+
+July 12, 2007:  Added -f option to directg.
+
+Aug 14, 2007:  Added -i,-I,-K options to shortg, parallel to labelg.
+              Since -k is used in labelg in place of -I, changed labelg
+              to use -I also, with -k remaining as an undocumented
+              compatibility feature.
+
+Aug-Sep 2007: Minor things:
+              * naututil-h.in now defines CPUTIME=0.0 as a last resort
+              * gtools.c now implements EDGECODE (not used anywhere yet)
+              * fixed definition of SG_FREE in nausparse.h (not used)
+              * geng favours space over time for n > 28 
+
+Oct 14, 2007: Added -T switch to shortg to specify scratch directory.
+
+Mar 3, 2008:  Fixed makefile for compilation in a 64-bit environment.
+
+Oct 11, 2008: Added -l and -m to genrang
+
+Nov 29, 2008: Slightly improved -c for geng and genbg
+              Added tournament generator gentourng.
+
+Mar 3, 2009:  Added -V to directg.
diff --git a/lib/nauty/addedgeg.c b/lib/nauty/addedgeg.c
new file mode 100644
index 0000000..e9e0962
--- /dev/null
+++ b/lib/nauty/addedgeg.c
@@ -0,0 +1,282 @@
+/* addedgeg.c   nauty version 2.6; B D McKay, Jan 2013. */
+
+#define USAGE "addedgeg [-lq] [-D#] [-btfF] [-z#] [infile [outfile]]"
+
+#define HELPTEXT \
+" For each edge nonedge e, output G+e if it satisfies certain conditions\n\
+\n\
+    The output file has a header if and only if the input file does.\n\
+\n\
+    -l  Canonically label outputs\n\
+    -D# Specify an upper bound on the maximum degree of the output\n\
+    -b  Output has no new cycles of odd length\n\
+    -t  Output has no new 3-cycle if input doesn't\n\
+    -f  Output has no new 4-cycle if input doesn't\n\
+    -F  Output has no new 5-cycle if input doesn't\n\
+    -z# Output has no new cycles of length less than #\n\
+        -btfFz can be used in arbitrary combinations\n\
+    -q  Suppress auxiliary information\n"
+
+/*************************************************************************/
+
+#include "gtools.h" 
+#include "gutils.h"
+
+/*************************************************************************/
+
+static void
+no3path(graph *g, int m, int n, int v, int *dist)
+/* For each i, set dist[i]=0 if there is a 3-path from v to i */
+{
+	set *gv,*gv1,*gv2;
+	int v1,v2,v3;
+
+	gv = GRAPHROW(g,v,m);
+	for (v1 = -1; (v1 = nextelement(gv,m,v1)) >= 0; )
+	{
+	    gv1 = GRAPHROW(g,v1,m);
+	    for (v2 = -1; (v2 = nextelement(gv1,m,v2)) >= 0; )
+            {
+		if (v2 == v) continue;
+                gv2 = GRAPHROW(g,v2,m);
+		for (v3 = -1; (v3 = nextelement(gv2,m,v3)) >= 0; )
+                    if (v3 != v && v3 != v1) dist[v3] = 0;
+	    }
+	}
+}
+
+/*************************************************************************/
+
+static void
+no4path(graph *g, int m, int n, int v, int *dist)
+/* For each i, set dist[i]=0 if there is a 4-path from v to i */
+{
+        set *gv,*gv1,*gv2,*gv3;
+        int v1,v2,v3,v4;
+
+        gv = GRAPHROW(g,v,m);
+        for (v1 = -1; (v1 = nextelement(gv,m,v1)) >= 0; )
+        {   
+            gv1 = GRAPHROW(g,v1,m);
+            for (v2 = -1; (v2 = nextelement(gv1,m,v2)) >= 0; )
+            {   
+                if (v2 == v) continue;
+                gv2 = GRAPHROW(g,v2,m);
+                for (v3 = -1; (v3 = nextelement(gv2,m,v3)) >= 0; )
+		{
+		    if (v3 == v || v3 == v1) continue;
+		    gv3 = GRAPHROW(g,v3,m);
+		    for (v4 = -1; (v4 = nextelement(gv3,m,v4)) >= 0; )
+			if (v4 != v && v4 != v1 && v4 != v2) dist[v4] = 0;
+		}
+            }
+        }
+}
+
+/*************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+        char *infilename,*outfilename;
+        FILE *infile,*outfile;
+        boolean badargs,dolabel,quiet,Dswitch;
+	boolean bswitch,tswitch,fswitch,Fswitch,zswitch;
+	int mincycle;
+	int i,j,m,n,v,w,argnum;
+	int codetype,outcode;
+	graph *g,*gq;
+	nauty_counter nin,nout;
+        char *arg,sw;
+	setword *gv,*gw;
+	int maxdeg,actmaxdeg,degv;
+	double t;
+#if MAXN
+	graph h[MAXN*MAXM];
+	int deg[MAXN],dist[MAXN];
+	boolean okdist[MAXN+1];
+#else
+	DYNALLSTAT(graph,h,h_sz);
+	DYNALLSTAT(int,deg,deg_sz);
+	DYNALLSTAT(boolean,okdist,okdist_sz);
+	DYNALLSTAT(int,dist,dist_sz);
+#endif
+
+	HELP; PUTVERSION;
+
+        infilename = outfilename = NULL;
+	Dswitch = dolabel = quiet = zswitch = FALSE;
+	bswitch = tswitch = fswitch = Fswitch = FALSE;
+
+	argnum = 0;
+	badargs = FALSE;
+	for (j = 1; !badargs && j < argc; ++j)
+	{
+	    arg = argv[j];
+	    if (arg[0] == '-' && arg[1] != '\0')
+	    {
+		++arg;
+		while (*arg != '\0')
+		{
+		    sw = *arg++;
+		         SWBOOLEAN('l',dolabel)
+		    else SWBOOLEAN('q',quiet)
+		    else SWBOOLEAN('b',bswitch)
+		    else SWBOOLEAN('t',tswitch)
+		    else SWBOOLEAN('f',fswitch)
+		    else SWBOOLEAN('F',Fswitch)
+                    else SWINT('z',zswitch,mincycle,">E addedgeg -z")
+                    else SWINT('D',Dswitch,maxdeg,">E addedgeg -D")
+		    else badargs = TRUE;
+		}
+	    }
+	    else
+	    {
+		++argnum;
+		if      (argnum == 1) infilename = arg;
+	        else if (argnum == 2) outfilename = arg;
+		else                  badargs = TRUE;
+	    }
+	}
+
+	if (badargs)
+	{
+	    fprintf(stderr,">E Usage: %s\n",USAGE);
+	    GETHELP;
+	    exit(1);
+	}
+
+	if (!quiet)
+	{
+	    fprintf(stderr,">A addedgeg");
+	    if (dolabel) fprintf(stderr," -l");
+	    if (Dswitch) fprintf(stderr," -D%d",maxdeg);
+	    if (bswitch || tswitch || fswitch || Fswitch || zswitch)
+	    {
+		fprintf(stderr," -");
+		if (bswitch) fprintf(stderr,"b");
+		if (tswitch) fprintf(stderr,"t");
+		if (fswitch) fprintf(stderr,"f");
+		if (Fswitch) fprintf(stderr,"F");
+		if (zswitch) fprintf(stderr,"z%d",mincycle);
+	    }
+	    if (argnum > 0) fprintf(stderr," %s",infilename);
+	    if (argnum > 1) fprintf(stderr," %s",outfilename);
+	    fprintf(stderr,"\n");
+	    fflush(stderr);
+	}
+
+	if (infilename && infilename[0] == '-') infilename = NULL;
+	infile = opengraphfile(infilename,&codetype,FALSE,1);
+	if (!infile) exit(1);
+	if (!infilename) infilename = "stdin";
+
+	if (!outfilename || outfilename[0] == '-')
+	{
+	    outfilename = "stdout";
+	    outfile = stdout;
+	}
+	else if ((outfile = fopen(outfilename,"w")) == NULL)
+	{
+	    fprintf(stderr,"Can't open output file %s\n",outfilename);
+	    gt_abort(NULL);
+	}
+
+	if (codetype&SPARSE6) outcode = SPARSE6;
+	else                  outcode = GRAPH6;
+
+	if (codetype&HAS_HEADER)
+	{
+	    if (outcode == SPARSE6) writeline(outfile,SPARSE6_HEADER);
+	    else    		    writeline(outfile,GRAPH6_HEADER);
+	}
+
+	if (!Dswitch) maxdeg = NAUTY_INFINITY;
+
+	if (dolabel) nauty_check(WORDSIZE,1,1,NAUTYVERSIONID);
+
+	nin = nout = 0;
+	t = CPUTIME;
+	while (TRUE)
+	{
+	    if ((g = readg(infile,NULL,0,&m,&n)) == NULL) break;
+	    ++nin;
+
+#if !MAXN
+	    DYNALLOC1(int,deg,deg_sz,n,"addedgeg");
+	    DYNALLOC1(boolean,okdist,okdist_sz,n+1,"addedgeg");
+	    DYNALLOC1(int,dist,dist_sz,n,"addedgeg");
+#endif
+
+	    actmaxdeg = n;
+	    for (v = 0, gv = g; v < n; ++v, gv += m)
+	    {
+		degv = 0;
+		for (i = 0; i < m; ++i)
+		    degv += POPCOUNT(gv[i]);
+		if (degv < actmaxdeg) actmaxdeg = degv;
+		deg[v] = degv;
+	    }
+
+	    if (actmaxdeg > maxdeg) continue;
+
+	    okdist[0] = okdist[1] = FALSE;
+	    for (i = 2; i <= n; ++i) okdist[i] = TRUE;
+
+	    if (bswitch)
+	        for (i = 2; i < n; i += 2) okdist[i] = FALSE;
+
+	    if (tswitch && n >= 3) okdist[2] = FALSE;
+	    if (fswitch && n >= 4) okdist[3] = FALSE;
+	    if (Fswitch && n >= 5) okdist[4] = FALSE;
+	    if (zswitch)
+		for (i = 2; i < mincycle-1 && i < n; ++i) okdist[i] = FALSE;
+
+	    for (v = 0, gv = g; v < n-1; ++v, gv += m)
+	    {
+		if (deg[v] >= maxdeg) continue;
+
+		find_dist(g,m,n,v,dist);
+
+		for (w = v+1; w < n; ++w)
+		    dist[w] = okdist[dist[w]] && (deg[w] < maxdeg);
+
+		if (fswitch) no3path(g,m,n,v,dist);
+		if (Fswitch) no4path(g,m,n,v,dist);
+
+	    	for (w = v+1; w < n; ++w)
+	        {
+		    if (!dist[w]) continue;
+
+		    gw = GRAPHROW(g,w,m);
+		    ADDELEMENT(gv,w);
+		    ADDELEMENT(gw,v);
+		    gq = g;
+	    
+	            if (dolabel)
+	            {
+#if !MAXN
+		        DYNALLOC2(graph,h,h_sz,n,m,"addedgeg");
+#endif
+	 	        fcanonise(g,m,n,h,NULL,FALSE);  /*FIXME (loops)*/
+		        gq = h;
+	            }
+	            if (outcode == SPARSE6) writes6(outfile,gq,m,n);
+	            else                    writeg6(outfile,gq,m,n);
+		    ++nout;
+		    DELELEMENT(gv,w);
+                    DELELEMENT(gw,v);
+		}
+	    }
+	    FREES(g);
+	}
+	t = CPUTIME - t;
+
+        if (!quiet)
+            fprintf(stderr,
+              ">Z  " COUNTER_FMT " graphs read from %s, "
+                           COUNTER_FMT " written to %s; %3.2f sec.\n",
+                    nin,infilename,nout,outfilename,t);
+
+	 exit(0);
+}
diff --git a/lib/nauty/amtog.c b/lib/nauty/amtog.c
new file mode 100644
index 0000000..cf56cff
--- /dev/null
+++ b/lib/nauty/amtog.c
@@ -0,0 +1,274 @@
+/* amtog.c  version 2.0; B D McKay, Jun 2015. */
+
+#define USAGE "amtog [-n#sgzhq] [-o#] [infile [outfile]]"
+
+#define HELPTEXT \
+" Read graphs in matrix format.\n\
+\n\
+    -n#   Set the initial graph order to # (no default).\n\
+          This can be overridden in the input.\n\
+    -g    Write the output in graph6 format (default).\n\
+    -s    Write the output in sparse6 format.\n\
+    -z    Write the output in digraph6 format.\n\
+    -h    Write a header (according to -g or -s).\n\
+    -w    Don't warn about loops (which are suppressed for -g)\n\
+    -q    Suppress auxiliary information.\n\
+    -o#   Treat digit # as 1 and other digits as 0.\n\
+\n\
+   Input consists of a sequence of commands restricted to:\n\
+\n\
+    n=#   set number of vertices (no default)\n\
+          The = is optional.\n\
+    m     Matrix to follow\n\
+          An 'm' is also assumed if a digit is encountered.\n\
+    M     Complement of matrix to follow (as m)\n\
+    t     Upper triangle of matrix to follow, row by row\n\
+           excluding the diagonal.\n\
+    T     Complement of upper trangle to follow (as t)\n\
+    s     Upper triangle of matrix to follow, row by row\n\
+           excluding the diagonal; lower triangle is complement.\n\
+    q     exit (optional)\n"
+
+/*************************************************************************/
+
+#include "gtools.h"  /* which includes nauty.h and stdio.h */
+#include <ctype.h>
+
+/**************************************************************************/
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    int m,n,outdigit;
+    int argnum,i,j,outcode,val;
+    char *arg,sw,ochar;
+    boolean badargs;
+    boolean nswitch,sswitch,gswitch,hswitch,qswitch;
+    boolean warn,loop,unsymm,compl,triangle,tournament;
+    boolean zswitch,oswitch,nowarn;
+    char *infilename,*outfilename;
+    FILE *infile,*outfile;
+    nauty_counter nin;
+    char s[10];
+#if MAXN
+    graph g[MAXN*MAXM];
+#else
+    DYNALLSTAT(graph,g,g_sz);
+#endif
+
+    HELP; PUTVERSION;
+
+    sswitch = gswitch = zswitch = oswitch = FALSE;
+    nowarn = qswitch = nswitch = hswitch = FALSE;
+    infilename = outfilename = NULL;
+    n = -1;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('s',sswitch)
+                else SWBOOLEAN('g',gswitch)
+                else SWBOOLEAN('z',zswitch)
+                else SWBOOLEAN('h',hswitch)
+                else SWBOOLEAN('w',nowarn)
+                else SWBOOLEAN('q',qswitch)
+                else SWINT('n',nswitch,n,">E amtog -n")
+                else SWINT('o',oswitch,outdigit,">E amtog -o")
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if ((sswitch!=0) + (gswitch!=0) + (zswitch!=0) > 1)
+        gt_abort(">E amtog: -sgz are incompatible\n");
+
+    if (oswitch && (outdigit < 0 || outdigit > 9))
+        gt_abort(">E amtog: only digits are allowed for -o\n");
+
+    if (badargs || argnum > 2)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if (oswitch) ochar = outdigit + '0';
+    else         ochar = '1';
+
+    if (!infilename || infilename[0] == '-')
+    {
+        infilename = "stdin";
+        infile = stdin;
+    }
+    else if ((infile = fopen(infilename,"r")) == NULL)
+    {
+        fprintf(stderr,"Can't open input file %s\n",infilename);
+        gt_abort(NULL);
+    }
+
+    if (!outfilename || outfilename[0] == '-')
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename,"w")) == NULL)
+    {
+        fprintf(stderr,"Can't open output file %s\n",outfilename);
+        gt_abort(NULL);
+    }
+
+    if (sswitch)      outcode = SPARSE6;
+    else if (zswitch) outcode = DIGRAPH6;
+    else              outcode = GRAPH6;
+
+    if (hswitch)
+    {
+        if (outcode == SPARSE6)       writeline(outfile,SPARSE6_HEADER);
+        else if (outcode == DIGRAPH6) writeline(outfile,DIGRAPH6_HEADER);
+        else                          writeline(outfile,GRAPH6_HEADER);
+    }
+
+#if MAXN
+    if (nswitch && n > MAXN)
+    {
+        gt_abort(">E amtog: value of -n too large\n");
+        exit(2);
+    }
+#else
+    if (nswitch)
+    {
+        m = (n + WORDSIZE - 1) / WORDSIZE;
+        DYNALLOC2(graph,g,g_sz,n,m,"amtog");
+    }
+#endif
+    
+
+     /* perform scanning required */
+
+    warn = FALSE;
+    nin = 0;
+    while (fscanf(infile,"%1s",s) == 1)
+    {
+        if (s[0] == 'n')
+        {
+            if (fscanf(infile,"=%d",&n) != 1)
+            {
+                gt_abort(">E amtog: invalid n=# command\n");
+                exit(2);
+            }
+            m = (n + WORDSIZE - 1) / WORDSIZE;
+#if MAXN
+            if (n < 1 || n > MAXN || m > MAXM)
+                gt_abort(">E amtog: n<0 or n,m too big\n");
+#else
+            DYNALLOC2(graph,g,g_sz,n,m,"amtog");
+#endif
+        } 
+        else if (s[0] == 'm' || s[0] == 'M' || s[0] == 't' ||
+                 s[0] == 'T' || s[0] == 's' || s[0] == '0' ||
+                 s[0] == '1' || (oswitch && isdigit(s[0])))
+        {
+            if (n < 0)
+            {
+                fprintf(stderr,
+                    ">E amtog: matrix found before n is defined\n");
+                exit(2);
+            }
+            if (isdigit(s[0])) ungetc(s[0],infile);
+            m = (n + WORDSIZE - 1) / WORDSIZE;
+    
+            EMPTYSET(g,m*(size_t)n);
+
+            loop = unsymm = tournament = FALSE;
+            triangle = (s[0] == 't') || (s[0] == 'T') || (s[0] == 's');
+	    tournament = s[0] == 's';
+            compl = (s[0] == 'M') || (s[0] == 'T');
+
+            ++nin;
+            for (i = 0; i < n; ++i)
+            for (j = (triangle ? i+1 : 0); j < n; ++j)
+            {
+                if (fscanf(infile,"%1s",s) != 1)
+                {
+                    fprintf(stderr,">E amtog: incomplete matrix\n");
+                    ABORT(">E amtog");
+                }
+                if (s[0] == '0' || s[0] == '1'
+                      || (oswitch && isdigit(s[0])))
+                {
+                    val = ((i != j) & compl) ^ (s[0] == ochar);
+                    if (val == 1)
+                    {
+			if (tournament)
+			    ADDELEMENT(GRAPHROW(g,i,m),j);
+                        else if (triangle)
+                        {
+                            ADDELEMENT(GRAPHROW(g,i,m),j);
+                            ADDELEMENT(GRAPHROW(g,j,m),i);
+                        }
+                        else
+                        {
+                            if (j < i && !ISELEMENT(GRAPHROW(g,j,m),i))
+                                unsymm = TRUE;
+                            ADDELEMENT(GRAPHROW(g,i,m),j);
+                        }
+                        if (i == j) loop = TRUE;
+                    }
+		    else if (tournament)
+			ADDELEMENT(GRAPHROW(g,j,m),i);
+                    else if (j < i && ISELEMENT(GRAPHROW(g,j,m),i))
+                        unsymm = TRUE;
+                }
+                else
+                {
+                    fprintf(stderr,
+                      ">E amtog: illegal character in matrix: \"%c\"\n",
+                      s[0]);
+                    gt_abort(NULL);
+                }
+            }
+
+            if ((tournament || unsymm) && outcode != DIGRAPH6)
+ 		fprintf(stderr,">W amtog: warning, graph "
+                          COUNTER_FMT " is unsymmetric\n",nin);
+    
+            if (outcode == DIGRAPH6)     writed6(outfile,g,m,n);
+            else if (outcode == SPARSE6) writes6(outfile,g,m,n);
+            else                         writeg6(outfile,g,m,n);
+	    if (loop && outcode == GRAPH6) ++warn;
+        }
+        else if (s[0] == 'q')
+        {
+            exit(0);
+        }
+        else
+        {
+            fprintf(stderr,">E amtog: invalid command \"%c\"\n",s[0]);
+            gt_abort(NULL);
+        }
+    }
+
+    if (warn) fprintf(stderr,">Z complg: loops were lost\n");
+
+    if (!qswitch)
+        fprintf(stderr,">Z  " COUNTER_FMT " graphs converted from %s to %s.\n",
+                       nin,infilename,outfilename);
+
+    exit(0);
+}
diff --git a/lib/nauty/biplabg.c b/lib/nauty/biplabg.c
new file mode 100644
index 0000000..36d6480
--- /dev/null
+++ b/lib/nauty/biplabg.c
@@ -0,0 +1,170 @@
+/* biplabg.c  version 1.1; B D McKay, Nov 10, 2009. */
+
+#define USAGE "biplabg [-q] [infile [outfile]]"
+
+#define HELPTEXT \
+" Label bipartite graphs so that the colour classes are contiguous.\n\
+  The first vertex of each component is assigned the first colour.\n\
+  Vertices in each colour class have the same relative order as before.\n\
+  Non-bipartite graphs are rejected.\n\
+\n\
+    The output file has a header if and only if the input file does.\n\
+\n\
+    -q  Suppress auxiliary information.\n"
+
+/*************************************************************************/
+
+#include "gtools.h" 
+#include "gutils.h"
+
+/**************************************************************************/
+
+static boolean
+biplabel(graph *g, int m, int n, graph *h)
+/* h := bipartite labelling of g; else return FALSE */
+{
+	int i,j;
+#if MAXN
+	int colour[MAXN];
+	int lab[MAXN];
+#else
+	DYNALLSTAT(int,colour,colour_sz);
+	DYNALLSTAT(int,lab,lab_sz);
+
+	DYNALLOC1(int,colour,colour_sz,n,"biplabg");
+	DYNALLOC1(int,lab,lab_sz,n,"biplabg");
+#endif
+
+	if (!twocolouring(g,colour,m,n)) return FALSE;
+
+	j = 0;
+	for (i = 0; i < n; ++i) if (colour[i] == 0) lab[j++] = i;
+	for (i = 0; i < n; ++i) if (colour[i] == 1) lab[j++] = i;
+
+	updatecan(g,h,lab,0,m,n);
+
+	return TRUE;
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+        char *infilename,*outfilename;
+        FILE *infile,*outfile;
+        boolean badargs,quiet;
+	int j,m,n,argnum;
+	int codetype,outcode;
+	graph *g;
+	nauty_counter nin,nout;
+        char *arg,sw;
+	double t;
+#if MAXN
+	graph h[MAXN*MAXM];
+#else
+	DYNALLSTAT(graph,h,h_sz);
+#endif
+
+	HELP; PUTVERSION;
+
+        infilename = outfilename = NULL;
+	quiet = FALSE;
+
+	argnum = 0;
+	badargs = FALSE;
+	for (j = 1; !badargs && j < argc; ++j)
+	{
+	    arg = argv[j];
+	    if (arg[0] == '-' && arg[1] != '\0')
+	    {
+		++arg;
+		while (*arg != '\0')
+		{
+		    sw = *arg++;
+		         SWBOOLEAN('q',quiet)
+		    else badargs = TRUE;
+		}
+	    }
+	    else
+	    {
+		++argnum;
+		if      (argnum == 1) infilename = arg;
+	        else if (argnum == 2) outfilename = arg;
+		else                  badargs = TRUE;
+	    }
+	}
+
+	if (badargs)
+	{
+	    fprintf(stderr,">E Usage: %s\n",USAGE);
+	    GETHELP;
+	    exit(1);
+	}
+
+	if (!quiet)
+	{
+	    fprintf(stderr,">A biplabg");
+	    if (argnum > 0) fprintf(stderr," %s",infilename);
+	    if (argnum > 1) fprintf(stderr," %s",outfilename);
+	    fprintf(stderr,"\n");
+	    fflush(stderr);
+	}
+
+	NODIGRAPHSYET(codetype);
+
+	if (infilename && infilename[0] == '-') infilename = NULL;
+	infile = opengraphfile(infilename,&codetype,FALSE,1);
+	if (!infile) exit(1);
+	if (!infilename) infilename = "stdin";
+
+	if (!outfilename || outfilename[0] == '-')
+	{
+	    outfilename = "stdout";
+	    outfile = stdout;
+	}
+	else if ((outfile = fopen(outfilename,"w")) == NULL)
+	{
+	    fprintf(stderr,"Can't open output file %s\n",outfilename);
+	    gt_abort(NULL);
+	}
+
+	if (codetype&SPARSE6) outcode = SPARSE6;
+	else                  outcode = GRAPH6;
+
+	if (codetype&HAS_HEADER)
+	{
+	    if (outcode == SPARSE6) writeline(outfile,SPARSE6_HEADER);
+	    else    		    writeline(outfile,GRAPH6_HEADER);
+	}
+
+	nautil_check(WORDSIZE,1,1,NAUTYVERSIONID);
+
+	nin = nout = 0;
+	t = CPUTIME;
+	while (TRUE)
+	{
+	    if ((g = readg(infile,NULL,0,&m,&n)) == NULL) break;
+	    ++nin;
+
+#if !MAXN
+	    DYNALLOC2(graph,h,h_sz,n,m,"biplabg");
+#endif
+	    if (biplabel(g,m,n,h))
+	    {
+		++nout;
+	        if (outcode == SPARSE6) writes6(outfile,h,m,n);
+	        else                    writeg6(outfile,h,m,n);
+	    }
+	    FREES(g);
+	}
+	t = CPUTIME - t;
+
+        if (!quiet)
+            fprintf(stderr,
+                ">Z  " COUNTER_FMT " graphs read from %s; "
+                       COUNTER_FMT " written to %s; %3.2f sec.\n",
+                    nin,infilename,nout,outfilename,t);
+
+	exit(0);
+}
diff --git a/lib/nauty/bliss2dre.c b/lib/nauty/bliss2dre.c
new file mode 100644
index 0000000..4d1e8fb
--- /dev/null
+++ b/lib/nauty/bliss2dre.c
@@ -0,0 +1,161 @@
+#include <stdio.h>
+#include <stdlib.h>
+/* Reads a graph in Bliss format from stdin and writes it in dreadnaut
+ * format to stdout.  If there is an argument, it is written to the
+ * output before the graph.  If there are two arguments, they are
+ * written to the output before and after the graph.
+ */
+
+typedef struct 
+{
+   int v,w;
+} vpair;
+
+int comparedge(const void *p1, const void *p2)
+{
+    vpair *e1,*e2;
+
+    e1 = (vpair*)p1;
+    e2 = (vpair*)p2;
+    if      (e1->v < e2->v) return -1;
+    else if (e1->v > e2->v) return 1;
+    else if (e1->w < e2->w) return -1;
+    else if (e1->w > e2->w) return 1;
+    else                    return 0;
+}
+
+static int
+nextchar(void)
+{
+    char s[2];
+
+    if (scanf("%1s",s) != 1) return EOF;
+    else                     return s[0];
+}
+
+int
+main(int argc, char *argv[])
+{
+    int n,c;
+    unsigned long ne,j;
+    vpair *elist,*vlist;
+    int haven;
+    int i,v,w;
+    int haveptn;
+
+    haven = 0;
+    j = 0;
+    while ((c = nextchar()) >= 0)
+    {
+	switch (c)
+	{
+	case 'c':
+	    putchar('"');
+	    while ((c = getchar()) != '\n' && c != EOF) putchar(c);
+	    printf("\\n\"\n");
+	    break;
+
+	case 'p':
+	    if (haven)
+	    {
+		fprintf(stderr,"Duplicate p line\n");
+		exit(1);
+	    }
+	    if (scanf(" edge %d %lu",&n,&ne) != 2)
+	    {
+		fprintf(stderr,"Bad p line\n");
+		exit(1);
+	    }
+	    if ((elist = (vpair*)malloc(ne*sizeof(vpair))) == NULL
+               || (vlist = (vpair*)malloc(n*sizeof(vpair))) == NULL)
+	    {
+		fprintf(stderr,"Malloc failed\n");
+		exit(1);
+	    }
+	    haven = 1;
+	    for (i = 0; i < n; ++i)
+	    {
+		vlist[i].v = 0;  /* default colour */
+		vlist[i].w = i+1;
+	    }
+	    break;
+
+	case 'n':
+	    if (!haven)
+	    {
+                fprintf(stderr,"Missing p line\n");
+                exit(1);
+            }  
+            if (scanf("%d%d",&w,&v) != 2 || w < 1 || w > n)
+            {
+                fprintf(stderr,"Bad n line\n");
+                exit(1);
+            }
+	    vlist[w-1].v = v;
+	    break;
+
+	case 'e':
+	    if (!haven || j == ne)
+	    {
+		fprintf(stderr,"Missing p line or too many e lines\n");
+		exit(1);
+	    }
+	    if (scanf("%d%d",&v,&w) != 2 || v < 1 || w < 1 || v > n || w > n)
+	    {
+		fprintf(stderr,"Bad e line\n");
+		exit(1);
+	    }
+	    elist[j].v = v; elist[j].w = w;
+	    ++j;
+	    break;
+
+	default:
+	    fprintf(stderr,"Unknown line %c\n",c);
+	    exit(1);
+	}
+    }
+
+    if (j != ne)
+    {
+        fprintf(stderr,"Wrong number of e lines\n");
+        exit(1);
+    }
+
+    if (argc > 1) printf("%s\n",argv[1]);
+
+    printf("$=1 n=%d g\n",n);
+    qsort(elist,ne,sizeof(vpair),comparedge);
+    
+    v = -1;
+    for (j = 0; j < ne; ++j)
+    {
+        if (elist[j].v != v)
+        {
+    	    v = elist[j].v;
+    	    if (j > 0) printf("\n");
+	    printf("%d:",v);
+	}
+	printf(" %d",elist[j].w);
+    }
+    printf(".\n");
+
+    qsort(vlist,n,sizeof(vpair),comparedge);
+    for (i = 1; i < n; ++i)
+	if (vlist[i].v != vlist[i-1].v) break;
+    if (i < n)
+    {
+	printf("f=[");
+	for (i = 0; i < n; ++i)
+	{
+	   if (i > 0 && vlist[i].v != vlist[i-1].v)
+		printf("\n |");
+	   printf(" %d",vlist[i].w);
+	}
+	printf("]\n");
+    }
+
+    printf("$$\n");
+
+    if (argc > 2) printf("%s\n",argv[2]);
+    return 0;
+}
diff --git a/lib/nauty/blisstog.c b/lib/nauty/blisstog.c
new file mode 100644
index 0000000..f0ee117
--- /dev/null
+++ b/lib/nauty/blisstog.c
@@ -0,0 +1,214 @@
+/* blisstog.c  version 1.0; B D McKay, Sep 2012. */
+
+#define USAGE "blisstog [-n#:#] [infile]*"
+
+#define HELPTEXT \
+" Read files of graphs in Bliss (Dimacs) format and write\n\
+  them to stdout in sparse6 format.\n\
+\n\
+  -n#:#  Specify a range of n values for output\n\
+  Input files with name *.gz are ungzipped\n"
+
+#define ZCAT "gunzip -c"  /* name of zcat command (might be "gunzip -c") */
+
+/*************************************************************************/
+
+#include "gtools.h" 
+
+typedef struct 
+{
+   int v,w;
+} vpair;
+
+static int
+nextchar(FILE *f)
+{
+    char s[2];
+
+    if (fscanf(f,"%1s",s) != 1) return EOF;
+    else                        return s[0];
+}
+
+static boolean
+readblissgraph(FILE *f, sparsegraph *g)
+/* Reads a graph from Bliss format into a sparse graph */
+{
+    int n,c;
+    unsigned long ne,j;
+    int haven;
+    int i,v,w;
+    int haveptn;
+    DYNALLSTAT(vpair,elist,elist_sz);
+
+    haven = 0;
+    j = 0;
+    while ((c = nextchar(f)) >= 0)
+    {
+	switch (c)
+	{
+	case 'c':
+	    while ((c = getc(f)) != '\n' && c != EOF) {}
+	    break;
+
+	case 'p':
+	    if (haven)
+	    {
+		fprintf(stderr,"Duplicate p line\n");
+		exit(1);
+	    }
+	    if (fscanf(f," edge %d %lu",&n,&ne) != 2)
+	    {
+		fprintf(stderr,"Bad p line\n");
+		return FALSE;
+	    }
+	    haven = 1;
+            DYNALLOC1(vpair,elist,elist_sz,ne,"Alloc vpair");
+	    break;
+
+	case 'n':
+	    if (!haven)
+	    {
+                fprintf(stderr,"Missing p line\n");
+                return FALSE;
+            }  
+            if (fscanf(f,"%d%d",&w,&v) != 2 || w < 1 || w > n)
+            {
+                fprintf(stderr,"Bad n line\n");
+                return FALSE;
+            }
+	    break;
+
+	case 'e':
+	    if (!haven || j == ne)
+	    {
+		fprintf(stderr,"Missing p line or too many e lines\n");
+		return FALSE;
+	    }
+	    if (fscanf(f,"%d%d",&v,&w) != 2 || v < 1 || w < 1 || v > n || w > n)
+	    {
+		fprintf(stderr,"Bad e line\n");
+		return FALSE;
+	    }
+	    elist[j].v = v-1; elist[j].w = w-1;
+	    ++j;
+	    break;
+
+	default:
+	    fprintf(stderr,"Unknown line %c\n",c);
+	    return FALSE;
+	}
+    }
+
+    if (j != ne)
+    {
+        fprintf(stderr,"Wrong number of e lines\n");
+        exit(1);
+    }
+
+    SG_ALLOC(*g,n,2*ne,"SG_ALLOC");
+    g->nv = n;
+    g->nde = 2*ne;
+
+    for (i = 0; i < n; ++i) g->d[i] = 0;
+    for (j = 0; j < ne; ++j) 
+    {
+	++(g->d[elist[j].v]);
+	++(g->d[elist[j].w]);
+    }
+    g->v[0] = 0;
+    for (i = 1; i < n; ++i) g->v[i] = g->v[i-1] + g->d[i-1];
+    for (i = 0; i < n; ++i) g->d[i] = 0;
+
+    for (j = 0; j < ne; ++j) 
+    {
+	v = elist[j].v;
+	w = elist[j].w;
+        g->e[g->v[v]+(g->d[v])++] = w;
+        g->e[g->v[w]+(g->d[w])++] = v;
+    }
+
+    return TRUE;
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    FILE *infile;
+    int j,firstarg;
+    SG_DECL(g);
+    size_t flen;
+    boolean ispipe;
+    int nmin,nmax;
+    char zcmd[515];
+
+    HELP; PUTVERSION;
+
+    nmax = -1;
+    if (argc >= 2 && argv[1][0] == '-' && argv[1][1] == 'n')
+    {
+	if (sscanf(argv[1]+2,"%d:%d",&nmin,&nmax) == 2) {}
+        else if (sscanf(argv[1]+2,":%d",&nmax) == 1) { nmin = 1; }
+        else if (sscanf(argv[1]+2,"%d:",&nmin) == 1) { nmax = NAUTY_INFINITY; }
+        else  gt_abort(">E blisstog: bad -n switch\n");
+        
+	firstarg = 2;
+    }
+    else
+	firstarg = 1;
+
+    if (argc == firstarg)
+    {
+	if (!readblissgraph(stdin,&g))
+	{
+	    fprintf(stderr,">E Bliss error in file %s\n","stdin");
+	    gt_abort(NULL);
+	}
+	else
+	    writes6_sg(stdout,&g);
+    }
+    else
+    {
+        for (j = firstarg; j < argc; ++j)
+	{
+	    flen = strlen(argv[j]);
+            if (flen >= 3 && strcmp(argv[j]+flen-3,".gz") == 0)
+            {
+                sprintf(zcmd,"%s \"%s\"",ZCAT,argv[j]);
+                if ((infile = popen(zcmd,"r")) == NULL)
+                {
+                    fprintf(stderr,
+                         ">E blisstog: cannot open zcat pipe for \"%s\"\n",
+                         argv[j]);
+                    gt_abort(NULL);
+                }
+		ispipe = TRUE;
+            }
+            else
+            {
+	        if ((infile = fopen(argv[j],"r")) == NULL)
+	        {
+	            fprintf(stderr,">E Can't open file %s\n",argv[j]);
+		    gt_abort(NULL);
+	        }
+		ispipe = FALSE;
+	    }
+
+	    if (!readblissgraph(infile,&g))
+	    {
+	        fprintf(stderr,">E Bliss error in file %s\n",argv[j]);
+		gt_abort(NULL);
+	    }
+	    else if (nmax < 0 || (g.nv >= nmin && g.nv <= nmax))
+            {
+		sortlists_sg(&g);
+	        writes6_sg(stdout,&g);
+	    }
+
+	    if (ispipe) pclose(infile); else fclose(infile);
+        }
+    }
+
+    exit(0);
+}    
diff --git a/lib/nauty/callgeng.c b/lib/nauty/callgeng.c
new file mode 100644
index 0000000..77bf5a7
--- /dev/null
+++ b/lib/nauty/callgeng.c
@@ -0,0 +1,47 @@
+/* This is a sample of how to call geng as a procedure rather than
+ * running it as a separate process.  The basic idea is to construct
+ * an argument list for geng's main() function.  At compile time,
+ * assign a name to the macros OUTPROC and GENG_MAIN.  A typical
+ * Unix-style compilation command would be:
+     gcc -o callgeng -O3 -DMAXN=32 -DOUTPROC=myoutproc -DGENG_MAIN=geng_main \
+       callgeng.c geng.c nauty.a
+ */
+
+#include "gtools.h"
+
+static unsigned long counter;
+
+void
+OUTPROC(FILE *outfile, graph *g, int n)
+{
+ /* This will be called for each graph. */
+
+    ++counter;
+}
+
+
+int
+main(int argc, char *argv[])
+{
+    int geng_argc;
+    char *geng_argv[6];
+
+  /* Set up geng argument list.  The 0-th argument is the command name.
+   * There must be a NULL at the end.  This example is for connected
+   * bipartite graphs of order 10 and maximum degree at most 4. */
+
+    geng_argv[0] = "geng";
+    geng_argv[1] = "-q";
+    geng_argv[2] = "-cb";
+    geng_argv[3] = "-D4";
+    geng_argv[4] = "10";
+    geng_argv[5] = NULL;
+    geng_argc = 5;
+
+    counter = 0;
+    GENG_MAIN(geng_argc,geng_argv);
+
+    printf("Number of graphs = %lu.\n",counter);
+
+    return 0;
+}
diff --git a/lib/nauty/catg.c b/lib/nauty/catg.c
new file mode 100644
index 0000000..d7176f1
--- /dev/null
+++ b/lib/nauty/catg.c
@@ -0,0 +1,175 @@
+/* catg.c version 1.3; B D McKay, Jan 2013 */
+
+#define USAGE "catg [-xv] [infile]..."
+
+#define HELPTEXT \
+"  Copy files to stdout with all but the first header removed.\n\
+\n\
+     -x  Don't write a header.\n\
+         In the absence of -x, a header is written if\n\
+         there is one in the first input file.\n\
+\n\
+     -v  Summarize to stderr.\n"
+
+#include "gtools.h"
+
+/***********************************************************************/
+
+static FILE*
+openfile_head(char *filename, char **header)
+/* Open the file for reading and return a FILE*.  If open fails, or
+   the header is malformed, write a message and return NULL.  Set
+   *header to point to the header string (statically allocated).
+   A filename of NULL or "-" means stdin. */
+{
+    int c,i;
+    char *actname;
+    FILE *f;
+    DYNALLSTAT(char,head,head_sz);
+
+    if (filename == NULL || strcmp(filename,"-") == 0)
+    {
+        f = stdin;
+        actname = "stdin";
+    }
+    else 
+    {
+        f = fopen(filename,"r");
+        actname = filename;
+    }
+
+    if (f == NULL)
+    {
+        fprintf(stderr,">E catg: can't open file %s\n",actname);
+        return NULL;
+    }
+
+    DYNALLOC1(char,head,head_sz,100,"catg");
+
+    c = getc(f);
+    if (c == '>')
+    {
+        i = 0;
+        head[i++] = (char)c;
+
+        c = getc(f);
+        if (c != '>')
+        {
+            fprintf(stderr,">E catg: bad header in %s\n",actname);
+            fclose(f);
+            return NULL;
+        }
+        head[i++] = (char)c;
+
+        do
+        {
+            c = getc(f);
+            if (c == EOF)
+            {
+                fprintf(stderr,">E catg: bad header in %s\n",actname);
+                fclose(f);
+                return NULL;
+            }
+
+            if (i >= head_sz-1)
+                DYNREALLOC(char,head,head_sz,head_sz+100,"catg");
+            head[i++] = (char)c;
+        }
+        while (c != '<' || head[i-2] != '<');
+
+        head[i] = '\0';
+    }
+    else
+    {
+	ungetc(c,f);
+        head[0] = '\0';
+    }
+
+    *header = head;
+
+    return f;
+}
+
+/***********************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    char *infilename,*head;
+    FILE *infile;
+    int nfiles,i,j;
+    char *arg,sw;
+    boolean vswitch,xswitch;
+    boolean badargs;
+    char buff[1024];
+    size_t nr;
+    DYNALLSTAT(char*,filename,filename_sz);
+
+    HELP; PUTVERSION;
+
+    DYNALLOC1(char*,filename,filename_sz,200,"catg");
+
+    xswitch = vswitch = FALSE;
+
+    nfiles = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('v',vswitch)
+                else SWBOOLEAN('x',xswitch)
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            if (nfiles >= filename_sz)
+                DYNREALLOC(char*,filename,filename_sz,
+                                      filename_sz+200,"catg");
+            filename[nfiles++] = arg;
+        }
+    }
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    for (i = 0; i < (nfiles == 0 ? 1 : nfiles); ++i)
+    {
+        infilename = (nfiles == 0 ? NULL : filename[i]);
+        infile = openfile_head(infilename,&head);
+        if (infile == NULL) ABORT("catg");
+
+        if (i == 0 && !xswitch) fprintf(stdout,"%s",head);
+
+        while ((nr = fread(buff,1,1024,infile)) > 0)
+        {
+            fwrite(buff,1,nr,stdout);
+            if (ferror(stdout))
+            {
+                fprintf(stderr,">E catg: error in writing to stdout\n");
+                ABORT("catg");
+            }
+        }
+        if (ferror(infile))
+        {
+            fprintf(stderr,">E catg: error in reading from %s\n",
+                    infilename == NULL ? "stdin" : infilename);
+            ABORT("catg");
+        }
+        fclose(infile);
+    }
+
+    if (vswitch)  { }
+
+    exit(0);
+}
diff --git a/lib/nauty/changes24-26.txt b/lib/nauty/changes24-26.txt
new file mode 100644
index 0000000..acd02f1
--- /dev/null
+++ b/lib/nauty/changes24-26.txt
@@ -0,0 +1,227 @@
+
+Changes from nauty 2.4 to nauty 2.5
+-----------------------------------
+
+* Add Traces.  The main files are traces.h and traces.c, but
+  many changes were made to dreadnaut.c and nausparse.c also.
+
+* Allow thread-safe storage if requested by configure --enable-tls
+  and available.  This allows parallel running of nauty and Traces
+  in separate threads.
+
+* The makefile now creates static libraries like nauty.a in 
+  addition to object files like nauty.o.
+
+* Remove all use of types permutation, nvector, np2vector, shortish.
+  These are now int.
+
+* Add schreier.h, schreier.c and the optional use of the random
+  Schreier method in nauty.  These are also used in Traces, but
+  are not optional there.
+
+* Add large-file support to all programs, assuming it is available.
+  Now there is no longer a 4GB limit on files read or written on
+  32-bit systems.
+
+* Use gcc extensions like __builtin_clz() if available and not
+    disabled by configure --disable-clz.
+  Use FIRSTBITNZ instead of FIRSTBIT if the argument is certain
+    to be nonzero.
+
+* New macros defined in nauty.h:
+   COUNTER_FMT
+   PRINT_COUNTER
+   SETWORDSNEEDED
+   ADDONEARC
+   ADDONEEDGE
+   EMPTYGRAPH
+
+* The options structure has a new boolean field schreier.
+
+* New procedures:
+  densenauty()  in naugraph.c  - simplified dense graph interface
+  sparsenauty() in nausparse.c - simplified sparse graph interface
+  writegroupsize() in nautil.c - write two part group size
+  copy_sg() in nausparse.c     - make a copy of a sparse graph
+
+  densenauty() and sparsenauty() are now the recommended ways to
+  call nauty from a program.  See the sample programs in the package.
+
+* Use quicksort in place of shell sort in many places.  This is 
+  implemented in the file sorttemplates.c that can be used in any
+  applications.
+
+* Apply the const attribute more liberally across the code.
+
+* The sparsegraph fields nde and *v changed type from int to size_t.
+  This is to allow more than 2^31 edges on 64-bit hardware.
+
+* sparsegraph.h and sparsegraph.c:
+    Corrected definition of SG_DECL in sparsegraph.h. (The erroneous
+       definition would have worked but generated warnings.)
+    Added DEFAULTOPTIONS_SPARSEDIGRAPH.
+    Added comparelab_tr(), testcanlab_tr(), updatecan_tr() for Traces.
+
+* gtools.h and gtools.c:
+    Now gtools.h is made from gtools-h.in by configure.
+    Updated G6LEN() to work for larger graphs.
+    Use large-file functions fseeko(), ftello() if possible.
+
+* Most tools now use the random number generator in naurng.c rather
+  than that in rng.c.
+
+* gutils.h, gutil1.c and gutil2.c:
+    New procedures maxcliques(), indpathcount1(), indcyclecount1(),
+      indcyclecount().
+
+* Invariants:
+    Corrected getbigcells(), making a small change to invariants
+       celltrips, cellquins and refinvar.
+
+* dreadnaut:
+    Sparse nauty and Traces now incorported.
+    New commands: A, G, F, FF, sr, O, OO, P, PP, S, V
+    w command is now in units of 2*m.
+    Command-line can run commands using -o.
+    M command is extended; now applies to i as well as x.
+    Implement ANSI controls if requested.
+    File names for > and < can be given in "..." to allow spaces.
+ 
+* Updates to utilities:
+     listg:  add -b (Bliss format), -G (GRAPE format) and
+          -y/-Y (dotty format), -H (HCP format)
+     labelg: add -t (Traces) and -i16 (refinvar)
+     countg/pickg: add -m (vertices of min degree),
+         -M (vertices of max degree), -H (induced cycles),
+         -K (number of maximal independent sets)
+     genrang: add -t (tree)
+     genbg: add -A (antichain)
+        The makefile can also make genbgL which makes larger sizes
+     directg: add PROCESS feature
+     shortg: -S (use sparse nauty), -t (use traces), i16 (refinvar)
+
+* New utilities:
+     ranlabg: randomly relabel graphs
+     linegraphg: compute linegraphs
+     subdivideg: compute subdivision graphs
+     watercluster2: orient edges of graphs (by Gunnar Brinkmann)
+
+* Version 25r2 fixed a rare bug in Traces
+* Version 25r3 fixed some problems in the configure script (thanks to Daniel Grayson)
+
+Changes from nauty 2.5 to nauty 2.6
+-----------------------------------
+
+Changes to dreadnaut:
+* dreadnaut now catches control-C when nauty or Traces is running.
+  This uses the global variable nauty_kill_request.
+* new command "vv" to display sorted degree sequence.
+* new command "r&" to relabel according to the partition.
+* new command "->>" to flush the output.
+* new command "B" to turn on output flushing at the end of every
+  command.  Command "-B" turns it off.  Default off.
+* Command with short arguments now have to be all on one line.
+  Most errors cause the rest of the input line to be skipped.
+* The "R" command now preserves the colouring.
+
+Changes to nauty:
+* nauty has an extra hook usercanonproc().
+* The maximum number of vertices is now 2 billion.
+* Many modern processors have instructions POPCNT and CLZ* that can
+  help nauty.  The configuration script now looks for them and
+  attempts to use them if possible.
+
+New file formats (see formats.txt for definitions):
+* sparse6 format is now extended with "incremental sparse6"
+  format. Graphs in incremental sparse6 format specify only the
+  differences from the previous graph.
+  As yet, incremental sparse6 is only supported by copyg (which
+  has new options -i/-I to write this format), listg, pickg and
+  countg. For listg, pickg and countg, the -p switch might not work
+  if the input is incremental.
+* The new format digraph6 is for directed graphs.  There are
+  procedures for reading and writing it in gtools.c.
+  The following programs can handle digraph6 so far:
+    labelg, shortg, ranlabg, directg, gentourng, amtog, complg,
+    copyg, dretog, catg, listg, showg, converse, converseg, delptg,
+    deledgeg, countg/pickg (partially), genrang (partially), genspecialg
+
+New utilities:
+*  converseg : take converse of a digraph
+*  cubhamg : hamiltonian cycles in subcubic graphs
+*  hamheuristic : heuristic for hamiltonian cycles
+*  twohamg : partition quartic graphs into two hamiltonian cycles
+*  genspecialg : generate special graphs like paths and cycles
+*  gentreeg : generateg trees, based on a program of Li and Ruskey.
+*  genquarticg : generate quartic graphs, written with Narjess Afzaly.
+*  dretodot : reads one graph in dreadnaut format and writes a picture
+     of it in dot format. You can use tools in the graphviz library
+     to deal with it.
+*  vcolg : colours the vertices of graphs in all distinct ways.
+     If you choose the number of colours to be 2, this the same as
+     adding loops in all distinct ways.
+*  delptg : delete vertices.
+As always, run the command with argument "-help" to get instructions.
+
+Extra options in existing utilities:
+* amtog now properly handles loops.  (Recall that loops are ok
+    in sparse6 format but not in graph6 format.)
+  amtog has a switch -o that allows selecting one colour class of
+  a coloured graph, and -w to suppress the warning about loops.
+* copyg has -z for writing digraph6 format. An undirected graph
+  can be written as a digraph, but not vice-versa.
+* directg default output format is directg6.
+  directg has a new option -s for splitting into cases.
+* dretog allows "d" command for digraph input.
+* Option -B added to countg and pickg.
+* complg has new option -R.
+* genrang has new option -d that makes random regular graphs of
+  any degree but does not guarantee uniform distribution.
+  Also option -T for random tournaments.
+  Some options now work for bipartite graphs; specify the number
+  of vertices on each side like n1,n2.
+* labelg has extra options -C and -W. These can help to determine
+    what is different between two different programs that generate
+    almost the same output.
+* linegraphg has -t for making the total graph.
+* Most utilities can take a single argument --version, which will
+  print a message stating which nauty&traces package they belong to.
+
+Other changes:
+* Traces has substantial improvements.
+* Extra argument macros SWDOUBLE, SWREALRANGE, SWSEQUENCE in gtools.h.
+* girth() in gutil1.c got the wrong answer for K2.  Thanks to
+  Sean Irvine for reporting it.
+* gtools.c defines checkgline() to check if a graph input 
+  line looks ok.
+* The procedures in gtnauty.c, used by labelg and other utilities,
+  had an old limit of 2^22 (4 million+) vertices.  This limit is
+  now removed.  Also a new procedure setlabptn() was added to set
+  lab/ptn according to an integer weight.
+* planarg -p had a bug causing wrong output for n >= 65536.  Fixed.
+* The structured type bigint has disappeared in favour of integer type
+  nauty_counter, which is "unsigned long long" if that exists and
+  "unsigned long" is only 32 bits, or "unsigned long" otherwise.
+  This means that some plugins for geng/genbg/gentourng may need
+  to be revised.
+* Problems with input of graphs with 0 vertices were fixed with help
+  from Kevin Ryde.  However, note that many utilities in the package
+  will not work with such graphs.  It is NOT TRUE that graphs of
+  order 0 are now supported.
+* Stronger measures are taken to ensure that the sort order used by
+  shortg is plain byte order. This corresponds to the C collation
+  order, also known as POSIX, but it may be different from the
+  collation order used by default on your command line. This means
+  that utilities like sort, uniq, comm and join might consider the
+  output of shortg to be out of order. To avoid this, define the
+  environment variable LC_ALL to equal the string "C".
+     bash:   export LC_ALL=C
+     tcsh:   setenv LC_ALL C
+  If LC_ALL is undefined, it will also be sufficient to define
+  LC_COLLATE to equal "C".  The POSIX standard says that LC_ALL
+  takes precedence over LC_COLLATE if both are defined, but this
+  might not be true for older systems.  If you really don't want
+  to change environment variables, you can compile shortg with
+  -DKEEP_SORT_LOCALE but beware that some collation orders are
+  are not even deterministic (i.e. different characters might
+  compare equal).
diff --git a/lib/nauty/checks6.c b/lib/nauty/checks6.c
new file mode 100644
index 0000000..06eccc8
--- /dev/null
+++ b/lib/nauty/checks6.c
@@ -0,0 +1,227 @@
+/* checks6.c; May 2005 */
+
+#define USAGE "checks6 [-p#:#w] [infile [outfile]]"
+
+#define HELPTEXT \
+"  Check a file of graphs, optionally write corrected version\n\
+\n\
+     -p# -p#:#  \n\
+         Specify range of input lines (first is 1)\n\
+\n\
+     -w  Write corrected graphs (default is not to write)\n\
+         A header is written if there is one in the input.\n"
+
+/***********************************************************************/
+
+#include "gtools.h"
+
+/***********************************************************************/
+
+static boolean
+seemsbad(char *s)
+/* Check graph string for apparent problem, if so, correct it */
+{
+        int i,j,k,m,n;
+        char *p,x,pq;
+	set *gj;
+	long ii;
+	int r,rr,topbit,nb,lastj;
+	graph g[16];
+
+	if (s[0] != ':') return FALSE;  /* not sparse6 */
+
+	n = graphsize(s);
+	if (n != 2 && n != 4 && n != 8 && n != 16) return FALSE;
+	m = 1;
+
+	stringtograph(s,g,m);
+	if (g[n-1] != bit[n-1]) return FALSE;
+	if (g[n-2] == 0) return FALSE;
+
+	g[n-1] = 0;
+	p = s+2;
+
+	for (i = n-1, nb = 0; i != 0 ; i >>= 1, ++nb) {}
+	topbit = 1 << (nb-1);
+	k = 6;
+	x = 0;
+
+	lastj = 0;
+	for (j = 0; j < n; ++j)
+	{
+	    gj = GRAPHROW(g,j,m);
+	    for (i = 0; i <= j; ++i)
+	    {
+		if (ISELEMENT(gj,i))
+		{
+		    if (j == lastj)
+		    {
+		        x <<= 1;
+		        if (--k == 0)
+		        {
+		            p++;
+		            k = 6;
+		            x = 0;
+		        }
+		    }
+		    else
+		    {
+			x = (x << 1) | 1;
+			if (--k == 0)
+			{
+		            p++;
+			    k = 6;
+			    x = 0;
+			}
+			if (j > lastj+1)
+			{
+			    for (r = 0, rr = j; r < nb; ++r, rr <<= 1)
+			    {
+			        if (rr & topbit) x = (x << 1) | 1;
+			        else             x <<= 1;
+			        if (--k == 0)
+			        {
+				    p++;
+				    k = 6;
+				    x = 0;
+			        }
+			    }
+			    x <<= 1;
+			    if (--k == 0)
+			    {
+				p++;
+				k = 6;
+				x = 0;
+			    }
+			}
+			lastj = j;
+		    }
+		    for (r = 0, rr = i; r < nb; ++r, rr <<= 1)
+		    {
+			if (rr & topbit) x = (x << 1) | 1;
+			else             x <<= 1;
+			if (--k == 0)
+			{
+			    p++;
+			    k = 6;
+			    x = 0;
+			}
+		    }
+		}
+	    }
+	}
+
+        if (k != 6)
+        {
+            if (k >= nb+1 && lastj == n-2 && n == (1<<nb))
+	    {
+                *p++ = BIAS6 + ((x << k) | ((1 << (k-1)) - 1));
+	    	return TRUE;
+	    }
+            else
+                return FALSE;
+        }
+}
+
+/***********************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+	int m,n,codetype;
+	char *infilename,*outfilename;
+	FILE *infile,*outfile;
+	int outcode;
+	long nin,nerr;
+	int argnum,j;
+	char *arg,sw,*s;
+	boolean pswitch;
+	boolean wswitch;
+	boolean badargs;
+	long pval1,pval2,maxin;
+
+	HELP; PUTVERSION;
+
+	wswitch = pswitch = FALSE;
+	infilename = outfilename = NULL;
+
+	argnum = 0;
+	badargs = FALSE;
+	for (j = 1; !badargs && j < argc; ++j)
+	{
+	    arg = argv[j];
+	    if (arg[0] == '-' && arg[1] != '\0')
+	    {
+		++arg;
+		while (*arg != '\0')
+		{
+		    sw = *arg++;
+		         SWBOOLEAN('w',wswitch)
+		    else SWRANGE('p',":-",pswitch,pval1,pval2,"checks6 -p")
+		    else badargs = TRUE;
+		}
+	    }
+	    else
+	    {
+		++argnum;
+		if      (argnum == 1) infilename = arg;
+	        else if (argnum == 2) outfilename = arg;
+		else                  badargs = TRUE;
+	    }
+	}
+
+	if (badargs || argnum > 2)
+	{
+	    fprintf(stderr,">E Usage: %s\n",USAGE);
+	    GETHELP;
+	    exit(1);
+	}
+
+	if (infilename && infilename[0] == '-') infilename = NULL;
+	infile = opengraphfile(infilename,&codetype,FALSE,
+			       pswitch ? pval1 : 1);
+	if (!infile) exit(1);
+	if (!infilename) infilename = "stdin";
+
+	if (!outfilename || outfilename[0] == '-')
+	{
+	    outfilename = "stdout";
+	    outfile = stdout;
+	}
+	else if ((outfile = fopen(outfilename,"w")) == NULL)
+	{
+	    fprintf(stderr,"Can't open output file %s\n",outfilename);
+	    gt_abort(NULL);
+	}
+
+	if (codetype&SPARSE6) outcode = SPARSE6;
+	else                  outcode = GRAPH6;
+
+	if (wswitch && (codetype&HAS_HEADER))
+	{
+	    if (outcode == SPARSE6) writeline(outfile,SPARSE6_HEADER);
+	    else    		    writeline(outfile,GRAPH6_HEADER);
+	}
+
+	nerr = nin = 0;
+	if (!pswitch || pval2 == NOLIMIT)
+	    maxin = NOLIMIT;
+	else if (pval1 < 1) maxin = pval2;
+	else                maxin = pval2 - pval1 + 1;
+	while (nin < maxin || maxin == NOLIMIT)
+	{
+	    if ((s = gtools_getline(infile)) == NULL) break;
+	    ++nin;
+
+	    if (seemsbad(s)) ++nerr;
+	    if (wswitch) writeline(outfile,s);
+	}
+
+	fprintf(stderr,">Z  %ld graphs read",nin);
+	if (nerr > 0) fprintf(stderr,"; %ld probable errors",nerr);
+	else          fprintf(stderr,"; NO PROBLEMS");
+	if (wswitch) fprintf(stderr,"; %ld graphs written",nin);
+	fprintf(stderr,"\n");
+
+	exit(0);
+}
diff --git a/lib/nauty/complg.c b/lib/nauty/complg.c
new file mode 100644
index 0000000..a122a11
--- /dev/null
+++ b/lib/nauty/complg.c
@@ -0,0 +1,267 @@
+/* complg.c  version 2.0; B D McKay, Jun 2015. */
+
+#define USAGE "complg [-lq] [-r|-R] [infile [outfile]]"
+
+#define HELPTEXT \
+" Take the complements of a file of graphs.\n\
+\n\
+    The output file has a header if and only if the input file does.\n\
+    The output format is defined by the header or first graph.\n\
+\n\
+    -r  Only complement if the complement has fewer directed edges.\n\
+    -R  Only complement if the complement has fewer directed edges\n\
+        or has the same number of directed edges and is canonically\n\
+        less than the original.\n\
+    -L  Complement the loops too. By default, preserve them.\n\
+    -l  Canonically label outputs.\n\
+    -q  Suppress auxiliary information.\n"
+
+/*************************************************************************/
+
+#include "gtools.h" 
+
+/**************************************************************************/
+
+static void
+compl(graph *g, int m, int n, graph *h, boolean comploops)
+/* h := complement of g */
+{
+    int i,j;
+    setword *gi,*hi;
+#if MAXN
+    set all[MAXM];
+#else
+    DYNALLSTAT(set,all,all_sz);
+    DYNALLOC1(set,all,all_sz,m,"complg");
+#endif
+
+    EMPTYSET(all,m);
+    for (i = 0; i < n; ++i) ADDELEMENT(all,i);
+
+    gi = (setword*) g;
+    hi = (setword*) h;
+
+    for (i = 0; i < n; ++i)
+    {
+        for (j = 0; j < m; ++j) hi[j] = gi[j] ^ all[j];
+        if (!comploops) FLIPELEMENT(hi,i);
+        gi += m;
+        hi += m;
+    }
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    char *infilename,*outfilename;
+    FILE *infile,*outfile;
+    boolean dolabel,badargs,restricted,Restricted,quiet;
+    boolean digraph,Lswitch;
+    int j,m,n,argnum;
+    int codetype,outcode;
+    graph *g;
+    size_t ii,ned,nedc,nn,loops,loopsc,gwords;
+    nauty_counter nin;
+    char *arg,sw;
+    static graph *gq;
+    double t;
+#if MAXN
+    graph gc[MAXN*MAXM],h[MAXN*MAXM],hc[MAXN*MAXM];
+#else
+    DYNALLSTAT(graph,gc,gc_sz);
+    DYNALLSTAT(graph,h,h_sz);
+    DYNALLSTAT(graph,hc,hc_sz);
+#endif
+
+    HELP; PUTVERSION;
+
+    infilename = outfilename = NULL;
+    dolabel = badargs = FALSE;
+    restricted = Restricted = quiet = Lswitch = FALSE;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('r',restricted)
+                else SWBOOLEAN('R',Restricted)
+                else SWBOOLEAN('l',dolabel)
+                else SWBOOLEAN('L',Lswitch)
+                else SWBOOLEAN('q',quiet)
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if (!quiet)
+    {
+        fprintf(stderr,">A complg");
+        if (restricted || Restricted || dolabel || Lswitch)
+            fprintf(stderr," -");
+        if (restricted && !Restricted) fprintf(stderr,"r");
+        if (Restricted) fprintf(stderr,"R");
+        if (dolabel) fprintf(stderr,"l");
+        if (Lswitch) fprintf(stderr,"L");
+        if (argnum > 0) fprintf(stderr," %s",infilename);
+        if (argnum > 1) fprintf(stderr," %s",outfilename);
+        fprintf(stderr,"\n");
+        fflush(stderr);
+    }
+
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,FALSE,1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    if (!outfilename || outfilename[0] == '-')
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename,"w")) == NULL)
+    {
+        fprintf(stderr,"Can't open output file %s\n",outfilename);
+        gt_abort(NULL);
+    }
+
+    if      (codetype&SPARSE6)  outcode = SPARSE6;
+    else if (codetype&DIGRAPH6) outcode = DIGRAPH6;
+    else                        outcode = GRAPH6;
+
+    if (codetype&HAS_HEADER)
+    {
+        if (outcode == SPARSE6)       writeline(outfile,SPARSE6_HEADER);
+        else if (outcode == DIGRAPH6) writeline(outfile,DIGRAPH6_HEADER);
+        else          	              writeline(outfile,GRAPH6_HEADER);
+    }
+
+    nauty_check(WORDSIZE,1,1,NAUTYVERSIONID);
+
+    nin = 0;
+    t = CPUTIME;
+    while (TRUE)
+    {
+        if ((g = readgg(infile,NULL,0,&m,&n,&digraph)) == NULL) break;
+        ++nin;
+#if !MAXN
+        DYNALLOC2(graph,gc,gc_sz,n,m,"complg");
+#endif
+
+        if (restricted || Restricted)
+        {
+            ned = loops = 0;
+            gwords = m * (size_t)n;
+            nn = n * (size_t)(n-1);
+            for (ii = 0; ii < gwords; ++ii) ned += POPCOUNT(g[ii]);
+            for (ii = 0; ii < n; ++ii) if (ISELEMENT(g+m*ii,ii)) ++loops;
+            if (Lswitch)
+            {
+		loopsc = n - loops;
+                nedc = nn + n - (ned-loops)/2;
+            }
+            else
+            {
+		loopsc = loops;
+                nedc = nn - (ned-3*loops)/2;
+            }
+
+            if (ned > nedc || (ned == nedc && !Restricted))
+            {
+                compl(g,m,n,gc,Lswitch);
+                if (dolabel)
+                {
+#if !MAXN
+                    DYNALLOC2(graph,hc,hc_sz,n,m,"complg");
+#endif
+                    fcanonise(gc,m,n,hc,NULL,digraph||loopsc>0);
+            	    gq = hc;
+                }
+                else
+            	    gq = gc;
+            }
+            else if (ned < nedc)
+            {
+                if (dolabel)
+                {
+#if !MAXN
+                    DYNALLOC2(graph,h,h_sz,n,m,"complg");
+#endif
+                    fcanonise(g,m,n,h,NULL,digraph||loops>0);
+            	    gq = h;
+                }
+                else
+            	    gq = g;
+            }
+            else 
+            {
+                compl(g,m,n,gc,Lswitch);
+#if !MAXN
+                DYNALLOC2(graph,h,h_sz,n,m,"complg");
+                DYNALLOC2(graph,hc,hc_sz,n,m,"complg");
+#endif
+                fcanonise(g,m,n,h,NULL,digraph||loops>0);
+                fcanonise(gc,m,n,hc,NULL,digraph||loopsc>0);
+                for (ii = 0; ii < gwords; ++ii)
+            	if (h[ii] != hc[ii]) break;
+                if (ii == gwords || hc[ii] < h[ii])
+                {
+            	    if (dolabel) gq = hc; else gq = gc;
+                }
+                else
+                {
+            	    if (dolabel) gq = h; else gq = g;
+                }
+            }
+        }
+        else   /* Not restricted */
+        {		
+            compl(g,m,n,gc,Lswitch);
+            if (dolabel)
+            {
+#if !MAXN
+                DYNALLOC2(graph,hc,hc_sz,n,m,"complg");
+#endif
+                fcanonise(gc,m,n,hc,NULL,digraph||loopsc>0);
+                gq = hc;
+            }
+            else
+                gq = gc;
+        }
+
+        if (outcode == SPARSE6)       writes6(outfile,gq,m,n);
+        else if (outcode == DIGRAPH6) writed6(outfile,gq,m,n);
+        else                          writeg6(outfile,gq,m,n);
+        FREES(g);
+    }
+    t = CPUTIME - t;
+
+    if (!quiet)
+        fprintf(stderr,">Z  " COUNTER_FMT 
+                " graphs converted from %s to %s in %3.2f sec.\n",
+                nin,infilename,outfilename,t);
+
+    exit(0);
+}
diff --git a/lib/nauty/config.guess b/lib/nauty/config.guess
new file mode 100644
index 0000000..c4bd827
--- /dev/null
+++ b/lib/nauty/config.guess
@@ -0,0 +1,1456 @@
+#! /bin/sh
+# Attempt to guess a canonical system name.
+#   Copyright 1992-2016 Free Software Foundation, Inc.
+
+timestamp='2016-05-15'
+
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <http://www.gnu.org/licenses/>.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that
+# program.  This Exception is an additional permission under section 7
+# of the GNU General Public License, version 3 ("GPLv3").
+#
+# Originally written by Per Bothner; maintained since 2000 by Ben Elliston.
+#
+# You can get the latest version of this script from:
+# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
+#
+# Please send patches to <config-patches@gnu.org>.
+
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION]
+
+Output the configuration name of the system \`$me' is run on.
+
+Operation modes:
+  -h, --help         print this help, then exit
+  -t, --time-stamp   print date of last modification, then exit
+  -v, --version      print version number, then exit
+
+Report bugs and patches to <config-patches@gnu.org>."
+
+version="\
+GNU config.guess ($timestamp)
+
+Originally written by Per Bothner.
+Copyright 1992-2016 Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+  case $1 in
+    --time-stamp | --time* | -t )
+       echo "$timestamp" ; exit ;;
+    --version | -v )
+       echo "$version" ; exit ;;
+    --help | --h* | -h )
+       echo "$usage"; exit ;;
+    -- )     # Stop option processing
+       shift; break ;;
+    - )	# Use stdin as input.
+       break ;;
+    -* )
+       echo "$me: invalid option $1$help" >&2
+       exit 1 ;;
+    * )
+       break ;;
+  esac
+done
+
+if test $# != 0; then
+  echo "$me: too many arguments$help" >&2
+  exit 1
+fi
+
+trap 'exit 1' 1 2 15
+
+# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
+# compiler to aid in system detection is discouraged as it requires
+# temporary files to be created and, as you can see below, it is a
+# headache to deal with in a portable fashion.
+
+# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
+# use `HOST_CC' if defined, but it is deprecated.
+
+# Portable tmp directory creation inspired by the Autoconf team.
+
+set_cc_for_build='
+trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
+trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
+: ${TMPDIR=/tmp} ;
+ { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
+ { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
+ { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
+ { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
+dummy=$tmp/dummy ;
+tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
+case $CC_FOR_BUILD,$HOST_CC,$CC in
+ ,,)    echo "int x;" > $dummy.c ;
+	for c in cc gcc c89 c99 ; do
+	  if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
+	     CC_FOR_BUILD="$c"; break ;
+	  fi ;
+	done ;
+	if test x"$CC_FOR_BUILD" = x ; then
+	  CC_FOR_BUILD=no_compiler_found ;
+	fi
+	;;
+ ,,*)   CC_FOR_BUILD=$CC ;;
+ ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
+esac ; set_cc_for_build= ;'
+
+# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
+# (ghazi@noc.rutgers.edu 1994-08-24)
+if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
+	PATH=$PATH:/.attbin ; export PATH
+fi
+
+UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
+UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
+UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
+UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
+
+case "${UNAME_SYSTEM}" in
+Linux|GNU|GNU/*)
+	# If the system lacks a compiler, then just pick glibc.
+	# We could probably try harder.
+	LIBC=gnu
+
+	eval $set_cc_for_build
+	cat <<-EOF > $dummy.c
+	#include <features.h>
+	#if defined(__UCLIBC__)
+	LIBC=uclibc
+	#elif defined(__dietlibc__)
+	LIBC=dietlibc
+	#else
+	LIBC=gnu
+	#endif
+	EOF
+	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`
+	;;
+esac
+
+# Note: order is significant - the case branches are not exclusive.
+
+case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
+    *:NetBSD:*:*)
+	# NetBSD (nbsd) targets should (where applicable) match one or
+	# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
+	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
+	# switched to ELF, *-*-netbsd* would select the old
+	# object file format.  This provides both forward
+	# compatibility and a consistent mechanism for selecting the
+	# object file format.
+	#
+	# Note: NetBSD doesn't particularly care about the vendor
+	# portion of the name.  We always set it to "unknown".
+	sysctl="sysctl -n hw.machine_arch"
+	UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \
+	    /sbin/$sysctl 2>/dev/null || \
+	    /usr/sbin/$sysctl 2>/dev/null || \
+	    echo unknown)`
+	case "${UNAME_MACHINE_ARCH}" in
+	    armeb) machine=armeb-unknown ;;
+	    arm*) machine=arm-unknown ;;
+	    sh3el) machine=shl-unknown ;;
+	    sh3eb) machine=sh-unknown ;;
+	    sh5el) machine=sh5le-unknown ;;
+	    earmv*)
+		arch=`echo ${UNAME_MACHINE_ARCH} | sed -e 's,^e\(armv[0-9]\).*$,\1,'`
+		endian=`echo ${UNAME_MACHINE_ARCH} | sed -ne 's,^.*\(eb\)$,\1,p'`
+		machine=${arch}${endian}-unknown
+		;;
+	    *) machine=${UNAME_MACHINE_ARCH}-unknown ;;
+	esac
+	# The Operating System including object format, if it has switched
+	# to ELF recently (or will in the future) and ABI.
+	case "${UNAME_MACHINE_ARCH}" in
+	    earm*)
+		os=netbsdelf
+		;;
+	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
+		eval $set_cc_for_build
+		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
+			| grep -q __ELF__
+		then
+		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
+		    # Return netbsd for either.  FIX?
+		    os=netbsd
+		else
+		    os=netbsdelf
+		fi
+		;;
+	    *)
+		os=netbsd
+		;;
+	esac
+	# Determine ABI tags.
+	case "${UNAME_MACHINE_ARCH}" in
+	    earm*)
+		expr='s/^earmv[0-9]/-eabi/;s/eb$//'
+		abi=`echo ${UNAME_MACHINE_ARCH} | sed -e "$expr"`
+		;;
+	esac
+	# The OS release
+	# Debian GNU/NetBSD machines have a different userland, and
+	# thus, need a distinct triplet. However, they do not need
+	# kernel version information, so it can be replaced with a
+	# suitable tag, in the style of linux-gnu.
+	case "${UNAME_VERSION}" in
+	    Debian*)
+		release='-gnu'
+		;;
+	    *)
+		release=`echo ${UNAME_RELEASE} | sed -e 's/[-_].*//' | cut -d. -f1,2`
+		;;
+	esac
+	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
+	# contains redundant information, the shorter form:
+	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
+	echo "${machine}-${os}${release}${abi}"
+	exit ;;
+    *:Bitrig:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
+	echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE}
+	exit ;;
+    *:OpenBSD:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
+	echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
+	exit ;;
+    *:LibertyBSD:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'`
+	echo ${UNAME_MACHINE_ARCH}-unknown-libertybsd${UNAME_RELEASE}
+	exit ;;
+    *:ekkoBSD:*:*)
+	echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
+	exit ;;
+    *:SolidBSD:*:*)
+	echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}
+	exit ;;
+    macppc:MirBSD:*:*)
+	echo powerpc-unknown-mirbsd${UNAME_RELEASE}
+	exit ;;
+    *:MirBSD:*:*)
+	echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
+	exit ;;
+    *:Sortix:*:*)
+	echo ${UNAME_MACHINE}-unknown-sortix
+	exit ;;
+    alpha:OSF1:*:*)
+	case $UNAME_RELEASE in
+	*4.0)
+		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
+		;;
+	*5.*)
+		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
+		;;
+	esac
+	# According to Compaq, /usr/sbin/psrinfo has been available on
+	# OSF/1 and Tru64 systems produced since 1995.  I hope that
+	# covers most systems running today.  This code pipes the CPU
+	# types through head -n 1, so we only detect the type of CPU 0.
+	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`
+	case "$ALPHA_CPU_TYPE" in
+	    "EV4 (21064)")
+		UNAME_MACHINE=alpha ;;
+	    "EV4.5 (21064)")
+		UNAME_MACHINE=alpha ;;
+	    "LCA4 (21066/21068)")
+		UNAME_MACHINE=alpha ;;
+	    "EV5 (21164)")
+		UNAME_MACHINE=alphaev5 ;;
+	    "EV5.6 (21164A)")
+		UNAME_MACHINE=alphaev56 ;;
+	    "EV5.6 (21164PC)")
+		UNAME_MACHINE=alphapca56 ;;
+	    "EV5.7 (21164PC)")
+		UNAME_MACHINE=alphapca57 ;;
+	    "EV6 (21264)")
+		UNAME_MACHINE=alphaev6 ;;
+	    "EV6.7 (21264A)")
+		UNAME_MACHINE=alphaev67 ;;
+	    "EV6.8CB (21264C)")
+		UNAME_MACHINE=alphaev68 ;;
+	    "EV6.8AL (21264B)")
+		UNAME_MACHINE=alphaev68 ;;
+	    "EV6.8CX (21264D)")
+		UNAME_MACHINE=alphaev68 ;;
+	    "EV6.9A (21264/EV69A)")
+		UNAME_MACHINE=alphaev69 ;;
+	    "EV7 (21364)")
+		UNAME_MACHINE=alphaev7 ;;
+	    "EV7.9 (21364A)")
+		UNAME_MACHINE=alphaev79 ;;
+	esac
+	# A Pn.n version is a patched version.
+	# A Vn.n version is a released version.
+	# A Tn.n version is a released field test version.
+	# A Xn.n version is an unreleased experimental baselevel.
+	# 1.2 uses "1.2" for uname -r.
+	echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
+	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
+	exitcode=$?
+	trap '' 0
+	exit $exitcode ;;
+    Alpha\ *:Windows_NT*:*)
+	# How do we know it's Interix rather than the generic POSIX subsystem?
+	# Should we change UNAME_MACHINE based on the output of uname instead
+	# of the specific Alpha model?
+	echo alpha-pc-interix
+	exit ;;
+    21064:Windows_NT:50:3)
+	echo alpha-dec-winnt3.5
+	exit ;;
+    Amiga*:UNIX_System_V:4.0:*)
+	echo m68k-unknown-sysv4
+	exit ;;
+    *:[Aa]miga[Oo][Ss]:*:*)
+	echo ${UNAME_MACHINE}-unknown-amigaos
+	exit ;;
+    *:[Mm]orph[Oo][Ss]:*:*)
+	echo ${UNAME_MACHINE}-unknown-morphos
+	exit ;;
+    *:OS/390:*:*)
+	echo i370-ibm-openedition
+	exit ;;
+    *:z/VM:*:*)
+	echo s390-ibm-zvmoe
+	exit ;;
+    *:OS400:*:*)
+	echo powerpc-ibm-os400
+	exit ;;
+    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
+	echo arm-acorn-riscix${UNAME_RELEASE}
+	exit ;;
+    arm*:riscos:*:*|arm*:RISCOS:*:*)
+	echo arm-unknown-riscos
+	exit ;;
+    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
+	echo hppa1.1-hitachi-hiuxmpp
+	exit ;;
+    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
+	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
+	if test "`(/bin/universe) 2>/dev/null`" = att ; then
+		echo pyramid-pyramid-sysv3
+	else
+		echo pyramid-pyramid-bsd
+	fi
+	exit ;;
+    NILE*:*:*:dcosx)
+	echo pyramid-pyramid-svr4
+	exit ;;
+    DRS?6000:unix:4.0:6*)
+	echo sparc-icl-nx6
+	exit ;;
+    DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
+	case `/usr/bin/uname -p` in
+	    sparc) echo sparc-icl-nx7; exit ;;
+	esac ;;
+    s390x:SunOS:*:*)
+	echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    sun4H:SunOS:5.*:*)
+	echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
+	echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
+	echo i386-pc-auroraux${UNAME_RELEASE}
+	exit ;;
+    i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
+	eval $set_cc_for_build
+	SUN_ARCH=i386
+	# If there is a compiler, see if it is configured for 64-bit objects.
+	# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
+	# This test works for both compilers.
+	if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
+	    if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
+		(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		grep IS_64BIT_ARCH >/dev/null
+	    then
+		SUN_ARCH=x86_64
+	    fi
+	fi
+	echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    sun4*:SunOS:6*:*)
+	# According to config.sub, this is the proper way to canonicalize
+	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
+	# it's likely to be more like Solaris than SunOS4.
+	echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    sun4*:SunOS:*:*)
+	case "`/usr/bin/arch -k`" in
+	    Series*|S4*)
+		UNAME_RELEASE=`uname -v`
+		;;
+	esac
+	# Japanese Language versions have a version number like `4.1.3-JL'.
+	echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
+	exit ;;
+    sun3*:SunOS:*:*)
+	echo m68k-sun-sunos${UNAME_RELEASE}
+	exit ;;
+    sun*:*:4.2BSD:*)
+	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
+	test "x${UNAME_RELEASE}" = x && UNAME_RELEASE=3
+	case "`/bin/arch`" in
+	    sun3)
+		echo m68k-sun-sunos${UNAME_RELEASE}
+		;;
+	    sun4)
+		echo sparc-sun-sunos${UNAME_RELEASE}
+		;;
+	esac
+	exit ;;
+    aushp:SunOS:*:*)
+	echo sparc-auspex-sunos${UNAME_RELEASE}
+	exit ;;
+    # The situation for MiNT is a little confusing.  The machine name
+    # can be virtually everything (everything which is not
+    # "atarist" or "atariste" at least should have a processor
+    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
+    # to the lowercase version "mint" (or "freemint").  Finally
+    # the system name "TOS" denotes a system which is actually not
+    # MiNT.  But MiNT is downward compatible to TOS, so this should
+    # be no problem.
+    atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
+	echo m68k-atari-mint${UNAME_RELEASE}
+	exit ;;
+    atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
+	echo m68k-atari-mint${UNAME_RELEASE}
+	exit ;;
+    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
+	echo m68k-atari-mint${UNAME_RELEASE}
+	exit ;;
+    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
+	echo m68k-milan-mint${UNAME_RELEASE}
+	exit ;;
+    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
+	echo m68k-hades-mint${UNAME_RELEASE}
+	exit ;;
+    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
+	echo m68k-unknown-mint${UNAME_RELEASE}
+	exit ;;
+    m68k:machten:*:*)
+	echo m68k-apple-machten${UNAME_RELEASE}
+	exit ;;
+    powerpc:machten:*:*)
+	echo powerpc-apple-machten${UNAME_RELEASE}
+	exit ;;
+    RISC*:Mach:*:*)
+	echo mips-dec-mach_bsd4.3
+	exit ;;
+    RISC*:ULTRIX:*:*)
+	echo mips-dec-ultrix${UNAME_RELEASE}
+	exit ;;
+    VAX*:ULTRIX*:*:*)
+	echo vax-dec-ultrix${UNAME_RELEASE}
+	exit ;;
+    2020:CLIX:*:* | 2430:CLIX:*:*)
+	echo clipper-intergraph-clix${UNAME_RELEASE}
+	exit ;;
+    mips:*:*:UMIPS | mips:*:*:RISCos)
+	eval $set_cc_for_build
+	sed 's/^	//' << EOF >$dummy.c
+#ifdef __cplusplus
+#include <stdio.h>  /* for printf() prototype */
+	int main (int argc, char *argv[]) {
+#else
+	int main (argc, argv) int argc; char *argv[]; {
+#endif
+	#if defined (host_mips) && defined (MIPSEB)
+	#if defined (SYSTYPE_SYSV)
+	  printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
+	#endif
+	#if defined (SYSTYPE_SVR4)
+	  printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
+	#endif
+	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
+	  printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
+	#endif
+	#endif
+	  exit (-1);
+	}
+EOF
+	$CC_FOR_BUILD -o $dummy $dummy.c &&
+	  dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` &&
+	  SYSTEM_NAME=`$dummy $dummyarg` &&
+	    { echo "$SYSTEM_NAME"; exit; }
+	echo mips-mips-riscos${UNAME_RELEASE}
+	exit ;;
+    Motorola:PowerMAX_OS:*:*)
+	echo powerpc-motorola-powermax
+	exit ;;
+    Motorola:*:4.3:PL8-*)
+	echo powerpc-harris-powermax
+	exit ;;
+    Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
+	echo powerpc-harris-powermax
+	exit ;;
+    Night_Hawk:Power_UNIX:*:*)
+	echo powerpc-harris-powerunix
+	exit ;;
+    m88k:CX/UX:7*:*)
+	echo m88k-harris-cxux7
+	exit ;;
+    m88k:*:4*:R4*)
+	echo m88k-motorola-sysv4
+	exit ;;
+    m88k:*:3*:R3*)
+	echo m88k-motorola-sysv3
+	exit ;;
+    AViiON:dgux:*:*)
+	# DG/UX returns AViiON for all architectures
+	UNAME_PROCESSOR=`/usr/bin/uname -p`
+	if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
+	then
+	    if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
+	       [ ${TARGET_BINARY_INTERFACE}x = x ]
+	    then
+		echo m88k-dg-dgux${UNAME_RELEASE}
+	    else
+		echo m88k-dg-dguxbcs${UNAME_RELEASE}
+	    fi
+	else
+	    echo i586-dg-dgux${UNAME_RELEASE}
+	fi
+	exit ;;
+    M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
+	echo m88k-dolphin-sysv3
+	exit ;;
+    M88*:*:R3*:*)
+	# Delta 88k system running SVR3
+	echo m88k-motorola-sysv3
+	exit ;;
+    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
+	echo m88k-tektronix-sysv3
+	exit ;;
+    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
+	echo m68k-tektronix-bsd
+	exit ;;
+    *:IRIX*:*:*)
+	echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
+	exit ;;
+    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
+	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
+	exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '
+    i*86:AIX:*:*)
+	echo i386-ibm-aix
+	exit ;;
+    ia64:AIX:*:*)
+	if [ -x /usr/bin/oslevel ] ; then
+		IBM_REV=`/usr/bin/oslevel`
+	else
+		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+	fi
+	echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}
+	exit ;;
+    *:AIX:2:3)
+	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
+		eval $set_cc_for_build
+		sed 's/^		//' << EOF >$dummy.c
+		#include <sys/systemcfg.h>
+
+		main()
+			{
+			if (!__power_pc())
+				exit(1);
+			puts("powerpc-ibm-aix3.2.5");
+			exit(0);
+			}
+EOF
+		if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`
+		then
+			echo "$SYSTEM_NAME"
+		else
+			echo rs6000-ibm-aix3.2.5
+		fi
+	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
+		echo rs6000-ibm-aix3.2.4
+	else
+		echo rs6000-ibm-aix3.2
+	fi
+	exit ;;
+    *:AIX:*:[4567])
+	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
+	if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
+		IBM_ARCH=rs6000
+	else
+		IBM_ARCH=powerpc
+	fi
+	if [ -x /usr/bin/lslpp ] ; then
+		IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc |
+			   awk -F: '{ print $3 }' | sed s/[0-9]*$/0/`
+	else
+		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+	fi
+	echo ${IBM_ARCH}-ibm-aix${IBM_REV}
+	exit ;;
+    *:AIX:*:*)
+	echo rs6000-ibm-aix
+	exit ;;
+    ibmrt:4.4BSD:*|romp-ibm:BSD:*)
+	echo romp-ibm-bsd4.4
+	exit ;;
+    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
+	echo romp-ibm-bsd${UNAME_RELEASE}   # 4.3 with uname added to
+	exit ;;                             # report: romp-ibm BSD 4.3
+    *:BOSX:*:*)
+	echo rs6000-bull-bosx
+	exit ;;
+    DPX/2?00:B.O.S.:*:*)
+	echo m68k-bull-sysv3
+	exit ;;
+    9000/[34]??:4.3bsd:1.*:*)
+	echo m68k-hp-bsd
+	exit ;;
+    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
+	echo m68k-hp-bsd4.4
+	exit ;;
+    9000/[34678]??:HP-UX:*:*)
+	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+	case "${UNAME_MACHINE}" in
+	    9000/31? )            HP_ARCH=m68000 ;;
+	    9000/[34]?? )         HP_ARCH=m68k ;;
+	    9000/[678][0-9][0-9])
+		if [ -x /usr/bin/getconf ]; then
+		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
+		    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
+		    case "${sc_cpu_version}" in
+		      523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0
+		      528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1
+		      532)                      # CPU_PA_RISC2_0
+			case "${sc_kernel_bits}" in
+			  32) HP_ARCH=hppa2.0n ;;
+			  64) HP_ARCH=hppa2.0w ;;
+			  '') HP_ARCH=hppa2.0 ;;   # HP-UX 10.20
+			esac ;;
+		    esac
+		fi
+		if [ "${HP_ARCH}" = "" ]; then
+		    eval $set_cc_for_build
+		    sed 's/^		//' << EOF >$dummy.c
+
+		#define _HPUX_SOURCE
+		#include <stdlib.h>
+		#include <unistd.h>
+
+		int main ()
+		{
+		#if defined(_SC_KERNEL_BITS)
+		    long bits = sysconf(_SC_KERNEL_BITS);
+		#endif
+		    long cpu  = sysconf (_SC_CPU_VERSION);
+
+		    switch (cpu)
+			{
+			case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
+			case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
+			case CPU_PA_RISC2_0:
+		#if defined(_SC_KERNEL_BITS)
+			    switch (bits)
+				{
+				case 64: puts ("hppa2.0w"); break;
+				case 32: puts ("hppa2.0n"); break;
+				default: puts ("hppa2.0"); break;
+				} break;
+		#else  /* !defined(_SC_KERNEL_BITS) */
+			    puts ("hppa2.0"); break;
+		#endif
+			default: puts ("hppa1.0"); break;
+			}
+		    exit (0);
+		}
+EOF
+		    (CCOPTS="" $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
+		    test -z "$HP_ARCH" && HP_ARCH=hppa
+		fi ;;
+	esac
+	if [ ${HP_ARCH} = hppa2.0w ]
+	then
+	    eval $set_cc_for_build
+
+	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
+	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
+	    # generating 64-bit code.  GNU and HP use different nomenclature:
+	    #
+	    # $ CC_FOR_BUILD=cc ./config.guess
+	    # => hppa2.0w-hp-hpux11.23
+	    # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
+	    # => hppa64-hp-hpux11.23
+
+	    if echo __LP64__ | (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) |
+		grep -q __LP64__
+	    then
+		HP_ARCH=hppa2.0w
+	    else
+		HP_ARCH=hppa64
+	    fi
+	fi
+	echo ${HP_ARCH}-hp-hpux${HPUX_REV}
+	exit ;;
+    ia64:HP-UX:*:*)
+	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+	echo ia64-hp-hpux${HPUX_REV}
+	exit ;;
+    3050*:HI-UX:*:*)
+	eval $set_cc_for_build
+	sed 's/^	//' << EOF >$dummy.c
+	#include <unistd.h>
+	int
+	main ()
+	{
+	  long cpu = sysconf (_SC_CPU_VERSION);
+	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns
+	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
+	     results, however.  */
+	  if (CPU_IS_PA_RISC (cpu))
+	    {
+	      switch (cpu)
+		{
+		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
+		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
+		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
+		  default: puts ("hppa-hitachi-hiuxwe2"); break;
+		}
+	    }
+	  else if (CPU_IS_HP_MC68K (cpu))
+	    puts ("m68k-hitachi-hiuxwe2");
+	  else puts ("unknown-hitachi-hiuxwe2");
+	  exit (0);
+	}
+EOF
+	$CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&
+		{ echo "$SYSTEM_NAME"; exit; }
+	echo unknown-hitachi-hiuxwe2
+	exit ;;
+    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
+	echo hppa1.1-hp-bsd
+	exit ;;
+    9000/8??:4.3bsd:*:*)
+	echo hppa1.0-hp-bsd
+	exit ;;
+    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
+	echo hppa1.0-hp-mpeix
+	exit ;;
+    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
+	echo hppa1.1-hp-osf
+	exit ;;
+    hp8??:OSF1:*:*)
+	echo hppa1.0-hp-osf
+	exit ;;
+    i*86:OSF1:*:*)
+	if [ -x /usr/sbin/sysversion ] ; then
+	    echo ${UNAME_MACHINE}-unknown-osf1mk
+	else
+	    echo ${UNAME_MACHINE}-unknown-osf1
+	fi
+	exit ;;
+    parisc*:Lites*:*:*)
+	echo hppa1.1-hp-lites
+	exit ;;
+    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
+	echo c1-convex-bsd
+	exit ;;
+    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
+	if getsysinfo -f scalar_acc
+	then echo c32-convex-bsd
+	else echo c2-convex-bsd
+	fi
+	exit ;;
+    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
+	echo c34-convex-bsd
+	exit ;;
+    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
+	echo c38-convex-bsd
+	exit ;;
+    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
+	echo c4-convex-bsd
+	exit ;;
+    CRAY*Y-MP:*:*:*)
+	echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    CRAY*[A-Z]90:*:*:*)
+	echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
+	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
+	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
+	      -e 's/\.[^.]*$/.X/'
+	exit ;;
+    CRAY*TS:*:*:*)
+	echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    CRAY*T3E:*:*:*)
+	echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    CRAY*SV1:*:*:*)
+	echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    *:UNICOS/mp:*:*)
+	echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit ;;
+    F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
+	FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
+	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
+	FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
+	echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+	exit ;;
+    5000:UNIX_System_V:4.*:*)
+	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
+	FUJITSU_REL=`echo ${UNAME_RELEASE} | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'`
+	echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+	exit ;;
+    i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
+	echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
+	exit ;;
+    sparc*:BSD/OS:*:*)
+	echo sparc-unknown-bsdi${UNAME_RELEASE}
+	exit ;;
+    *:BSD/OS:*:*)
+	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
+	exit ;;
+    *:FreeBSD:*:*)
+	UNAME_PROCESSOR=`/usr/bin/uname -p`
+	case ${UNAME_PROCESSOR} in
+	    amd64)
+		echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+	    *)
+		echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+	esac
+	exit ;;
+    i*:CYGWIN*:*)
+	echo ${UNAME_MACHINE}-pc-cygwin
+	exit ;;
+    *:MINGW64*:*)
+	echo ${UNAME_MACHINE}-pc-mingw64
+	exit ;;
+    *:MINGW*:*)
+	echo ${UNAME_MACHINE}-pc-mingw32
+	exit ;;
+    *:MSYS*:*)
+	echo ${UNAME_MACHINE}-pc-msys
+	exit ;;
+    i*:windows32*:*)
+	# uname -m includes "-pc" on this system.
+	echo ${UNAME_MACHINE}-mingw32
+	exit ;;
+    i*:PW*:*)
+	echo ${UNAME_MACHINE}-pc-pw32
+	exit ;;
+    *:Interix*:*)
+	case ${UNAME_MACHINE} in
+	    x86)
+		echo i586-pc-interix${UNAME_RELEASE}
+		exit ;;
+	    authenticamd | genuineintel | EM64T)
+		echo x86_64-unknown-interix${UNAME_RELEASE}
+		exit ;;
+	    IA64)
+		echo ia64-unknown-interix${UNAME_RELEASE}
+		exit ;;
+	esac ;;
+    [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
+	echo i${UNAME_MACHINE}-pc-mks
+	exit ;;
+    8664:Windows_NT:*)
+	echo x86_64-pc-mks
+	exit ;;
+    i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
+	# How do we know it's Interix rather than the generic POSIX subsystem?
+	# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
+	# UNAME_MACHINE based on the output of uname instead of i386?
+	echo i586-pc-interix
+	exit ;;
+    i*:UWIN*:*)
+	echo ${UNAME_MACHINE}-pc-uwin
+	exit ;;
+    amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
+	echo x86_64-unknown-cygwin
+	exit ;;
+    p*:CYGWIN*:*)
+	echo powerpcle-unknown-cygwin
+	exit ;;
+    prep*:SunOS:5.*:*)
+	echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit ;;
+    *:GNU:*:*)
+	# the GNU system
+	echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-${LIBC}`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
+	exit ;;
+    *:GNU/*:*:*)
+	# other systems with GNU libc and userland
+	echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-${LIBC}
+	exit ;;
+    i*86:Minix:*:*)
+	echo ${UNAME_MACHINE}-pc-minix
+	exit ;;
+    aarch64:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    aarch64_be:Linux:*:*)
+	UNAME_MACHINE=aarch64_be
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    alpha:Linux:*:*)
+	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
+	  EV5)   UNAME_MACHINE=alphaev5 ;;
+	  EV56)  UNAME_MACHINE=alphaev56 ;;
+	  PCA56) UNAME_MACHINE=alphapca56 ;;
+	  PCA57) UNAME_MACHINE=alphapca56 ;;
+	  EV6)   UNAME_MACHINE=alphaev6 ;;
+	  EV67)  UNAME_MACHINE=alphaev67 ;;
+	  EV68*) UNAME_MACHINE=alphaev68 ;;
+	esac
+	objdump --private-headers /bin/sh | grep -q ld.so.1
+	if test "$?" = 0 ; then LIBC=gnulibc1 ; fi
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    arc:Linux:*:* | arceb:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    arm*:Linux:*:*)
+	eval $set_cc_for_build
+	if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
+	    | grep -q __ARM_EABI__
+	then
+	    echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	else
+	    if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
+		| grep -q __ARM_PCS_VFP
+	    then
+		echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabi
+	    else
+		echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabihf
+	    fi
+	fi
+	exit ;;
+    avr32*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    cris:Linux:*:*)
+	echo ${UNAME_MACHINE}-axis-linux-${LIBC}
+	exit ;;
+    crisv32:Linux:*:*)
+	echo ${UNAME_MACHINE}-axis-linux-${LIBC}
+	exit ;;
+    e2k:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    frv:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    hexagon:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    i*86:Linux:*:*)
+	echo ${UNAME_MACHINE}-pc-linux-${LIBC}
+	exit ;;
+    ia64:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    k1om:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    m32r*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    m68*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    mips:Linux:*:* | mips64:Linux:*:*)
+	eval $set_cc_for_build
+	sed 's/^	//' << EOF >$dummy.c
+	#undef CPU
+	#undef ${UNAME_MACHINE}
+	#undef ${UNAME_MACHINE}el
+	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
+	CPU=${UNAME_MACHINE}el
+	#else
+	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
+	CPU=${UNAME_MACHINE}
+	#else
+	CPU=
+	#endif
+	#endif
+EOF
+	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'`
+	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; }
+	;;
+    openrisc*:Linux:*:*)
+	echo or1k-unknown-linux-${LIBC}
+	exit ;;
+    or32:Linux:*:* | or1k*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    padre:Linux:*:*)
+	echo sparc-unknown-linux-${LIBC}
+	exit ;;
+    parisc64:Linux:*:* | hppa64:Linux:*:*)
+	echo hppa64-unknown-linux-${LIBC}
+	exit ;;
+    parisc:Linux:*:* | hppa:Linux:*:*)
+	# Look for CPU level
+	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
+	  PA7*) echo hppa1.1-unknown-linux-${LIBC} ;;
+	  PA8*) echo hppa2.0-unknown-linux-${LIBC} ;;
+	  *)    echo hppa-unknown-linux-${LIBC} ;;
+	esac
+	exit ;;
+    ppc64:Linux:*:*)
+	echo powerpc64-unknown-linux-${LIBC}
+	exit ;;
+    ppc:Linux:*:*)
+	echo powerpc-unknown-linux-${LIBC}
+	exit ;;
+    ppc64le:Linux:*:*)
+	echo powerpc64le-unknown-linux-${LIBC}
+	exit ;;
+    ppcle:Linux:*:*)
+	echo powerpcle-unknown-linux-${LIBC}
+	exit ;;
+    s390:Linux:*:* | s390x:Linux:*:*)
+	echo ${UNAME_MACHINE}-ibm-linux-${LIBC}
+	exit ;;
+    sh64*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    sh*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    sparc:Linux:*:* | sparc64:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    tile*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    vax:Linux:*:*)
+	echo ${UNAME_MACHINE}-dec-linux-${LIBC}
+	exit ;;
+    x86_64:Linux:*:*)
+	echo ${UNAME_MACHINE}-pc-linux-${LIBC}
+	exit ;;
+    xtensa*:Linux:*:*)
+	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	exit ;;
+    i*86:DYNIX/ptx:4*:*)
+	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
+	# earlier versions are messed up and put the nodename in both
+	# sysname and nodename.
+	echo i386-sequent-sysv4
+	exit ;;
+    i*86:UNIX_SV:4.2MP:2.*)
+	# Unixware is an offshoot of SVR4, but it has its own version
+	# number series starting with 2...
+	# I am not positive that other SVR4 systems won't match this,
+	# I just have to hope.  -- rms.
+	# Use sysv4.2uw... so that sysv4* matches it.
+	echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
+	exit ;;
+    i*86:OS/2:*:*)
+	# If we were able to find `uname', then EMX Unix compatibility
+	# is probably installed.
+	echo ${UNAME_MACHINE}-pc-os2-emx
+	exit ;;
+    i*86:XTS-300:*:STOP)
+	echo ${UNAME_MACHINE}-unknown-stop
+	exit ;;
+    i*86:atheos:*:*)
+	echo ${UNAME_MACHINE}-unknown-atheos
+	exit ;;
+    i*86:syllable:*:*)
+	echo ${UNAME_MACHINE}-pc-syllable
+	exit ;;
+    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
+	echo i386-unknown-lynxos${UNAME_RELEASE}
+	exit ;;
+    i*86:*DOS:*:*)
+	echo ${UNAME_MACHINE}-pc-msdosdjgpp
+	exit ;;
+    i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
+	UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
+	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
+		echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
+	else
+		echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
+	fi
+	exit ;;
+    i*86:*:5:[678]*)
+	# UnixWare 7.x, OpenUNIX and OpenServer 6.
+	case `/bin/uname -X | grep "^Machine"` in
+	    *486*)	     UNAME_MACHINE=i486 ;;
+	    *Pentium)	     UNAME_MACHINE=i586 ;;
+	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
+	esac
+	echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
+	exit ;;
+    i*86:*:3.2:*)
+	if test -f /usr/options/cb.name; then
+		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
+		echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
+	elif /bin/uname -X 2>/dev/null >/dev/null ; then
+		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
+		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
+		(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
+			&& UNAME_MACHINE=i586
+		(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
+			&& UNAME_MACHINE=i686
+		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
+			&& UNAME_MACHINE=i686
+		echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
+	else
+		echo ${UNAME_MACHINE}-pc-sysv32
+	fi
+	exit ;;
+    pc:*:*:*)
+	# Left here for compatibility:
+	# uname -m prints for DJGPP always 'pc', but it prints nothing about
+	# the processor, so we play safe by assuming i586.
+	# Note: whatever this is, it MUST be the same as what config.sub
+	# prints for the "djgpp" host, or else GDB configure will decide that
+	# this is a cross-build.
+	echo i586-pc-msdosdjgpp
+	exit ;;
+    Intel:Mach:3*:*)
+	echo i386-pc-mach3
+	exit ;;
+    paragon:*:*:*)
+	echo i860-intel-osf1
+	exit ;;
+    i860:*:4.*:*) # i860-SVR4
+	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
+	  echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
+	else # Add other i860-SVR4 vendors below as they are discovered.
+	  echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4
+	fi
+	exit ;;
+    mini*:CTIX:SYS*5:*)
+	# "miniframe"
+	echo m68010-convergent-sysv
+	exit ;;
+    mc68k:UNIX:SYSTEM5:3.51m)
+	echo m68k-convergent-sysv
+	exit ;;
+    M680?0:D-NIX:5.3:*)
+	echo m68k-diab-dnix
+	exit ;;
+    M68*:*:R3V[5678]*:*)
+	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
+    3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
+	OS_REL=''
+	test -r /etc/.relid \
+	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+	  && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+	  && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+    3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+	  && { echo i486-ncr-sysv4; exit; } ;;
+    NCR*:*:4.2:* | MPRAS*:*:4.2:*)
+	OS_REL='.3'
+	test -r /etc/.relid \
+	    && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+	    && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+	    && { echo i586-ncr-sysv4.3${OS_REL}; exit; }
+	/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
+	    && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
+	echo m68k-unknown-lynxos${UNAME_RELEASE}
+	exit ;;
+    mc68030:UNIX_System_V:4.*:*)
+	echo m68k-atari-sysv4
+	exit ;;
+    TSUNAMI:LynxOS:2.*:*)
+	echo sparc-unknown-lynxos${UNAME_RELEASE}
+	exit ;;
+    rs6000:LynxOS:2.*:*)
+	echo rs6000-unknown-lynxos${UNAME_RELEASE}
+	exit ;;
+    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
+	echo powerpc-unknown-lynxos${UNAME_RELEASE}
+	exit ;;
+    SM[BE]S:UNIX_SV:*:*)
+	echo mips-dde-sysv${UNAME_RELEASE}
+	exit ;;
+    RM*:ReliantUNIX-*:*:*)
+	echo mips-sni-sysv4
+	exit ;;
+    RM*:SINIX-*:*:*)
+	echo mips-sni-sysv4
+	exit ;;
+    *:SINIX-*:*:*)
+	if uname -p 2>/dev/null >/dev/null ; then
+		UNAME_MACHINE=`(uname -p) 2>/dev/null`
+		echo ${UNAME_MACHINE}-sni-sysv4
+	else
+		echo ns32k-sni-sysv
+	fi
+	exit ;;
+    PENTIUM:*:4.0*:*)	# Unisys `ClearPath HMP IX 4000' SVR4/MP effort
+			# says <Richard.M.Bartel@ccMail.Census.GOV>
+	echo i586-unisys-sysv4
+	exit ;;
+    *:UNIX_System_V:4*:FTX*)
+	# From Gerald Hewes <hewes@openmarket.com>.
+	# How about differentiating between stratus architectures? -djm
+	echo hppa1.1-stratus-sysv4
+	exit ;;
+    *:*:*:FTX*)
+	# From seanf@swdc.stratus.com.
+	echo i860-stratus-sysv4
+	exit ;;
+    i*86:VOS:*:*)
+	# From Paul.Green@stratus.com.
+	echo ${UNAME_MACHINE}-stratus-vos
+	exit ;;
+    *:VOS:*:*)
+	# From Paul.Green@stratus.com.
+	echo hppa1.1-stratus-vos
+	exit ;;
+    mc68*:A/UX:*:*)
+	echo m68k-apple-aux${UNAME_RELEASE}
+	exit ;;
+    news*:NEWS-OS:6*:*)
+	echo mips-sony-newsos6
+	exit ;;
+    R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
+	if [ -d /usr/nec ]; then
+		echo mips-nec-sysv${UNAME_RELEASE}
+	else
+		echo mips-unknown-sysv${UNAME_RELEASE}
+	fi
+	exit ;;
+    BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
+	echo powerpc-be-beos
+	exit ;;
+    BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
+	echo powerpc-apple-beos
+	exit ;;
+    BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
+	echo i586-pc-beos
+	exit ;;
+    BePC:Haiku:*:*)	# Haiku running on Intel PC compatible.
+	echo i586-pc-haiku
+	exit ;;
+    x86_64:Haiku:*:*)
+	echo x86_64-unknown-haiku
+	exit ;;
+    SX-4:SUPER-UX:*:*)
+	echo sx4-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-5:SUPER-UX:*:*)
+	echo sx5-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-6:SUPER-UX:*:*)
+	echo sx6-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-7:SUPER-UX:*:*)
+	echo sx7-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-8:SUPER-UX:*:*)
+	echo sx8-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-8R:SUPER-UX:*:*)
+	echo sx8r-nec-superux${UNAME_RELEASE}
+	exit ;;
+    SX-ACE:SUPER-UX:*:*)
+	echo sxace-nec-superux${UNAME_RELEASE}
+	exit ;;
+    Power*:Rhapsody:*:*)
+	echo powerpc-apple-rhapsody${UNAME_RELEASE}
+	exit ;;
+    *:Rhapsody:*:*)
+	echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
+	exit ;;
+    *:Darwin:*:*)
+	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
+	eval $set_cc_for_build
+	if test "$UNAME_PROCESSOR" = unknown ; then
+	    UNAME_PROCESSOR=powerpc
+	fi
+	if test `echo "$UNAME_RELEASE" | sed -e 's/\..*//'` -le 10 ; then
+	    if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
+		if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
+		    (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		    grep IS_64BIT_ARCH >/dev/null
+		then
+		    case $UNAME_PROCESSOR in
+			i386) UNAME_PROCESSOR=x86_64 ;;
+			powerpc) UNAME_PROCESSOR=powerpc64 ;;
+		    esac
+		fi
+	    fi
+	elif test "$UNAME_PROCESSOR" = i386 ; then
+	    # Avoid executing cc on OS X 10.9, as it ships with a stub
+	    # that puts up a graphical alert prompting to install
+	    # developer tools.  Any system running Mac OS X 10.7 or
+	    # later (Darwin 11 and later) is required to have a 64-bit
+	    # processor. This is not true of the ARM version of Darwin
+	    # that Apple uses in portable devices.
+	    UNAME_PROCESSOR=x86_64
+	fi
+	echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
+	exit ;;
+    *:procnto*:*:* | *:QNX:[0123456789]*:*)
+	UNAME_PROCESSOR=`uname -p`
+	if test "$UNAME_PROCESSOR" = x86; then
+		UNAME_PROCESSOR=i386
+		UNAME_MACHINE=pc
+	fi
+	echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}
+	exit ;;
+    *:QNX:*:4*)
+	echo i386-pc-qnx
+	exit ;;
+    NEO-?:NONSTOP_KERNEL:*:*)
+	echo neo-tandem-nsk${UNAME_RELEASE}
+	exit ;;
+    NSE-*:NONSTOP_KERNEL:*:*)
+	echo nse-tandem-nsk${UNAME_RELEASE}
+	exit ;;
+    NSR-?:NONSTOP_KERNEL:*:*)
+	echo nsr-tandem-nsk${UNAME_RELEASE}
+	exit ;;
+    *:NonStop-UX:*:*)
+	echo mips-compaq-nonstopux
+	exit ;;
+    BS2000:POSIX*:*:*)
+	echo bs2000-siemens-sysv
+	exit ;;
+    DS/*:UNIX_System_V:*:*)
+	echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
+	exit ;;
+    *:Plan9:*:*)
+	# "uname -m" is not consistent, so use $cputype instead. 386
+	# is converted to i386 for consistency with other x86
+	# operating systems.
+	if test "$cputype" = 386; then
+	    UNAME_MACHINE=i386
+	else
+	    UNAME_MACHINE="$cputype"
+	fi
+	echo ${UNAME_MACHINE}-unknown-plan9
+	exit ;;
+    *:TOPS-10:*:*)
+	echo pdp10-unknown-tops10
+	exit ;;
+    *:TENEX:*:*)
+	echo pdp10-unknown-tenex
+	exit ;;
+    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
+	echo pdp10-dec-tops20
+	exit ;;
+    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
+	echo pdp10-xkl-tops20
+	exit ;;
+    *:TOPS-20:*:*)
+	echo pdp10-unknown-tops20
+	exit ;;
+    *:ITS:*:*)
+	echo pdp10-unknown-its
+	exit ;;
+    SEI:*:*:SEIUX)
+	echo mips-sei-seiux${UNAME_RELEASE}
+	exit ;;
+    *:DragonFly:*:*)
+	echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
+	exit ;;
+    *:*VMS:*:*)
+	UNAME_MACHINE=`(uname -p) 2>/dev/null`
+	case "${UNAME_MACHINE}" in
+	    A*) echo alpha-dec-vms ; exit ;;
+	    I*) echo ia64-dec-vms ; exit ;;
+	    V*) echo vax-dec-vms ; exit ;;
+	esac ;;
+    *:XENIX:*:SysV)
+	echo i386-pc-xenix
+	exit ;;
+    i*86:skyos:*:*)
+	echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE} | sed -e 's/ .*$//'`
+	exit ;;
+    i*86:rdos:*:*)
+	echo ${UNAME_MACHINE}-pc-rdos
+	exit ;;
+    i*86:AROS:*:*)
+	echo ${UNAME_MACHINE}-pc-aros
+	exit ;;
+    x86_64:VMkernel:*:*)
+	echo ${UNAME_MACHINE}-unknown-esx
+	exit ;;
+    amd64:Isilon\ OneFS:*:*)
+	echo x86_64-unknown-onefs
+	exit ;;
+esac
+
+cat >&2 <<EOF
+$0: unable to guess system type
+
+This script (version $timestamp), has failed to recognize the
+operating system you are using. If your script is old, overwrite
+config.guess and config.sub with the latest versions from:
+
+  http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
+and
+  http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
+
+If $0 has already been updated, send the following data and any
+information you think might be pertinent to config-patches@gnu.org to
+provide the necessary information to handle your system.
+
+config.guess timestamp = $timestamp
+
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null`
+
+hostinfo               = `(hostinfo) 2>/dev/null`
+/bin/universe          = `(/bin/universe) 2>/dev/null`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
+/bin/arch              = `(/bin/arch) 2>/dev/null`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
+
+UNAME_MACHINE = ${UNAME_MACHINE}
+UNAME_RELEASE = ${UNAME_RELEASE}
+UNAME_SYSTEM  = ${UNAME_SYSTEM}
+UNAME_VERSION = ${UNAME_VERSION}
+EOF
+
+exit 1
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:
diff --git a/lib/nauty/config.sub b/lib/nauty/config.sub
new file mode 100644
index 0000000..9feb73b
--- /dev/null
+++ b/lib/nauty/config.sub
@@ -0,0 +1,1823 @@
+#! /bin/sh
+# Configuration validation subroutine script.
+#   Copyright 1992-2016 Free Software Foundation, Inc.
+
+timestamp='2016-06-20'
+
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <http://www.gnu.org/licenses/>.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that
+# program.  This Exception is an additional permission under section 7
+# of the GNU General Public License, version 3 ("GPLv3").
+
+
+# Please send patches to <config-patches@gnu.org>.
+#
+# Configuration subroutine to validate and canonicalize a configuration type.
+# Supply the specified configuration type as an argument.
+# If it is invalid, we print an error message on stderr and exit with code 1.
+# Otherwise, we print the canonical config type on stdout and succeed.
+
+# You can get the latest version of this script from:
+# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
+
+# This file is supposed to be the same for all GNU packages
+# and recognize all the CPU types, system types and aliases
+# that are meaningful with *any* GNU software.
+# Each package is responsible for reporting which valid configurations
+# it does not support.  The user should be able to distinguish
+# a failure to support a valid configuration from a meaningless
+# configuration.
+
+# The goal of this file is to map all the various variations of a given
+# machine specification into a single specification in the form:
+#	CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+# or in some cases, the newer four-part form:
+#	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+# It is wrong to echo any other type of specification.
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION] CPU-MFR-OPSYS or ALIAS
+
+Canonicalize a configuration name.
+
+Operation modes:
+  -h, --help         print this help, then exit
+  -t, --time-stamp   print date of last modification, then exit
+  -v, --version      print version number, then exit
+
+Report bugs and patches to <config-patches@gnu.org>."
+
+version="\
+GNU config.sub ($timestamp)
+
+Copyright 1992-2016 Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+  case $1 in
+    --time-stamp | --time* | -t )
+       echo "$timestamp" ; exit ;;
+    --version | -v )
+       echo "$version" ; exit ;;
+    --help | --h* | -h )
+       echo "$usage"; exit ;;
+    -- )     # Stop option processing
+       shift; break ;;
+    - )	# Use stdin as input.
+       break ;;
+    -* )
+       echo "$me: invalid option $1$help"
+       exit 1 ;;
+
+    *local*)
+       # First pass through any local machine types.
+       echo $1
+       exit ;;
+
+    * )
+       break ;;
+  esac
+done
+
+case $# in
+ 0) echo "$me: missing argument$help" >&2
+    exit 1;;
+ 1) ;;
+ *) echo "$me: too many arguments$help" >&2
+    exit 1;;
+esac
+
+# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
+# Here we must recognize all the valid KERNEL-OS combinations.
+maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
+case $maybe_os in
+  nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
+  linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
+  knetbsd*-gnu* | netbsd*-gnu* | netbsd*-eabi* | \
+  kopensolaris*-gnu* | \
+  storm-chaos* | os2-emx* | rtmk-nova*)
+    os=-$maybe_os
+    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
+    ;;
+  android-linux)
+    os=-linux-android
+    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown
+    ;;
+  *)
+    basic_machine=`echo $1 | sed 's/-[^-]*$//'`
+    if [ $basic_machine != $1 ]
+    then os=`echo $1 | sed 's/.*-/-/'`
+    else os=; fi
+    ;;
+esac
+
+### Let's recognize common machines as not being operating systems so
+### that things like config.sub decstation-3100 work.  We also
+### recognize some manufacturers as not being operating systems, so we
+### can provide default operating systems below.
+case $os in
+	-sun*os*)
+		# Prevent following clause from handling this invalid input.
+		;;
+	-dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
+	-att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
+	-unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
+	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
+	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
+	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
+	-apple | -axis | -knuth | -cray | -microblaze*)
+		os=
+		basic_machine=$1
+		;;
+	-bluegene*)
+		os=-cnk
+		;;
+	-sim | -cisco | -oki | -wec | -winbond)
+		os=
+		basic_machine=$1
+		;;
+	-scout)
+		;;
+	-wrs)
+		os=-vxworks
+		basic_machine=$1
+		;;
+	-chorusos*)
+		os=-chorusos
+		basic_machine=$1
+		;;
+	-chorusrdb)
+		os=-chorusrdb
+		basic_machine=$1
+		;;
+	-hiux*)
+		os=-hiuxwe2
+		;;
+	-sco6)
+		os=-sco5v6
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco5)
+		os=-sco3.2v5
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco4)
+		os=-sco3.2v4
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco3.2.[4-9]*)
+		os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco3.2v[4-9]*)
+		# Don't forget version if it is 3.2v4 or newer.
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco5v6*)
+		# Don't forget version if it is 3.2v4 or newer.
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco*)
+		os=-sco3.2v2
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-udk*)
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-isc)
+		os=-isc2.2
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-clix*)
+		basic_machine=clipper-intergraph
+		;;
+	-isc*)
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-lynx*178)
+		os=-lynxos178
+		;;
+	-lynx*5)
+		os=-lynxos5
+		;;
+	-lynx*)
+		os=-lynxos
+		;;
+	-ptx*)
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`
+		;;
+	-windowsnt*)
+		os=`echo $os | sed -e 's/windowsnt/winnt/'`
+		;;
+	-psos*)
+		os=-psos
+		;;
+	-mint | -mint[0-9]*)
+		basic_machine=m68k-atari
+		os=-mint
+		;;
+esac
+
+# Decode aliases for certain CPU-COMPANY combinations.
+case $basic_machine in
+	# Recognize the basic CPU types without company name.
+	# Some are omitted here because they have special meanings below.
+	1750a | 580 \
+	| a29k \
+	| aarch64 | aarch64_be \
+	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
+	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
+	| am33_2.0 \
+	| arc | arceb \
+	| arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \
+	| avr | avr32 \
+	| ba \
+	| be32 | be64 \
+	| bfin \
+	| c4x | c8051 | clipper \
+	| d10v | d30v | dlx | dsp16xx \
+	| e2k | epiphany \
+	| fido | fr30 | frv | ft32 \
+	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
+	| hexagon \
+	| i370 | i860 | i960 | ia64 \
+	| ip2k | iq2000 \
+	| k1om \
+	| le32 | le64 \
+	| lm32 \
+	| m32c | m32r | m32rle | m68000 | m68k | m88k \
+	| maxq | mb | microblaze | microblazeel | mcore | mep | metag \
+	| mips | mipsbe | mipseb | mipsel | mipsle \
+	| mips16 \
+	| mips64 | mips64el \
+	| mips64octeon | mips64octeonel \
+	| mips64orion | mips64orionel \
+	| mips64r5900 | mips64r5900el \
+	| mips64vr | mips64vrel \
+	| mips64vr4100 | mips64vr4100el \
+	| mips64vr4300 | mips64vr4300el \
+	| mips64vr5000 | mips64vr5000el \
+	| mips64vr5900 | mips64vr5900el \
+	| mipsisa32 | mipsisa32el \
+	| mipsisa32r2 | mipsisa32r2el \
+	| mipsisa32r6 | mipsisa32r6el \
+	| mipsisa64 | mipsisa64el \
+	| mipsisa64r2 | mipsisa64r2el \
+	| mipsisa64r6 | mipsisa64r6el \
+	| mipsisa64sb1 | mipsisa64sb1el \
+	| mipsisa64sr71k | mipsisa64sr71kel \
+	| mipsr5900 | mipsr5900el \
+	| mipstx39 | mipstx39el \
+	| mn10200 | mn10300 \
+	| moxie \
+	| mt \
+	| msp430 \
+	| nds32 | nds32le | nds32be \
+	| nios | nios2 | nios2eb | nios2el \
+	| ns16k | ns32k \
+	| open8 | or1k | or1knd | or32 \
+	| pdp10 | pdp11 | pj | pjl \
+	| powerpc | powerpc64 | powerpc64le | powerpcle \
+	| pyramid \
+	| riscv32 | riscv64 \
+	| rl78 | rx \
+	| score \
+	| sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[234]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
+	| sh64 | sh64le \
+	| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
+	| sparcv8 | sparcv9 | sparcv9b | sparcv9v \
+	| spu \
+	| tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
+	| ubicom32 \
+	| v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
+	| visium \
+	| we32k \
+	| x86 | xc16x | xstormy16 | xtensa \
+	| z8k | z80)
+		basic_machine=$basic_machine-unknown
+		;;
+	c54x)
+		basic_machine=tic54x-unknown
+		;;
+	c55x)
+		basic_machine=tic55x-unknown
+		;;
+	c6x)
+		basic_machine=tic6x-unknown
+		;;
+	leon|leon[3-9])
+		basic_machine=sparc-$basic_machine
+		;;
+	m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip)
+		basic_machine=$basic_machine-unknown
+		os=-none
+		;;
+	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)
+		;;
+	ms1)
+		basic_machine=mt-unknown
+		;;
+
+	strongarm | thumb | xscale)
+		basic_machine=arm-unknown
+		;;
+	xgate)
+		basic_machine=$basic_machine-unknown
+		os=-none
+		;;
+	xscaleeb)
+		basic_machine=armeb-unknown
+		;;
+
+	xscaleel)
+		basic_machine=armel-unknown
+		;;
+
+	# We use `pc' rather than `unknown'
+	# because (1) that's what they normally are, and
+	# (2) the word "unknown" tends to confuse beginning users.
+	i*86 | x86_64)
+	  basic_machine=$basic_machine-pc
+	  ;;
+	# Object if more than one company name word.
+	*-*-*)
+		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+		exit 1
+		;;
+	# Recognize the basic CPU types with company name.
+	580-* \
+	| a29k-* \
+	| aarch64-* | aarch64_be-* \
+	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
+	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
+	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \
+	| arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
+	| avr-* | avr32-* \
+	| ba-* \
+	| be32-* | be64-* \
+	| bfin-* | bs2000-* \
+	| c[123]* | c30-* | [cjt]90-* | c4x-* \
+	| c8051-* | clipper-* | craynv-* | cydra-* \
+	| d10v-* | d30v-* | dlx-* \
+	| e2k-* | elxsi-* \
+	| f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
+	| h8300-* | h8500-* \
+	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
+	| hexagon-* \
+	| i*86-* | i860-* | i960-* | ia64-* \
+	| ip2k-* | iq2000-* \
+	| k1om-* \
+	| le32-* | le64-* \
+	| lm32-* \
+	| m32c-* | m32r-* | m32rle-* \
+	| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
+	| m88110-* | m88k-* | maxq-* | mcore-* | metag-* \
+	| microblaze-* | microblazeel-* \
+	| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
+	| mips16-* \
+	| mips64-* | mips64el-* \
+	| mips64octeon-* | mips64octeonel-* \
+	| mips64orion-* | mips64orionel-* \
+	| mips64r5900-* | mips64r5900el-* \
+	| mips64vr-* | mips64vrel-* \
+	| mips64vr4100-* | mips64vr4100el-* \
+	| mips64vr4300-* | mips64vr4300el-* \
+	| mips64vr5000-* | mips64vr5000el-* \
+	| mips64vr5900-* | mips64vr5900el-* \
+	| mipsisa32-* | mipsisa32el-* \
+	| mipsisa32r2-* | mipsisa32r2el-* \
+	| mipsisa32r6-* | mipsisa32r6el-* \
+	| mipsisa64-* | mipsisa64el-* \
+	| mipsisa64r2-* | mipsisa64r2el-* \
+	| mipsisa64r6-* | mipsisa64r6el-* \
+	| mipsisa64sb1-* | mipsisa64sb1el-* \
+	| mipsisa64sr71k-* | mipsisa64sr71kel-* \
+	| mipsr5900-* | mipsr5900el-* \
+	| mipstx39-* | mipstx39el-* \
+	| mmix-* \
+	| mt-* \
+	| msp430-* \
+	| nds32-* | nds32le-* | nds32be-* \
+	| nios-* | nios2-* | nios2eb-* | nios2el-* \
+	| none-* | np1-* | ns16k-* | ns32k-* \
+	| open8-* \
+	| or1k*-* \
+	| orion-* \
+	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
+	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
+	| pyramid-* \
+	| riscv32-* | riscv64-* \
+	| rl78-* | romp-* | rs6000-* | rx-* \
+	| sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
+	| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
+	| sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
+	| sparclite-* \
+	| sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx*-* \
+	| tahoe-* \
+	| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
+	| tile*-* \
+	| tron-* \
+	| ubicom32-* \
+	| v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
+	| vax-* \
+	| visium-* \
+	| we32k-* \
+	| x86-* | x86_64-* | xc16x-* | xps100-* \
+	| xstormy16-* | xtensa*-* \
+	| ymp-* \
+	| z8k-* | z80-*)
+		;;
+	# Recognize the basic CPU types without company name, with glob match.
+	xtensa*)
+		basic_machine=$basic_machine-unknown
+		;;
+	# Recognize the various machine names and aliases which stand
+	# for a CPU type and a company and sometimes even an OS.
+	386bsd)
+		basic_machine=i386-unknown
+		os=-bsd
+		;;
+	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
+		basic_machine=m68000-att
+		;;
+	3b*)
+		basic_machine=we32k-att
+		;;
+	a29khif)
+		basic_machine=a29k-amd
+		os=-udi
+		;;
+	abacus)
+		basic_machine=abacus-unknown
+		;;
+	adobe68k)
+		basic_machine=m68010-adobe
+		os=-scout
+		;;
+	alliant | fx80)
+		basic_machine=fx80-alliant
+		;;
+	altos | altos3068)
+		basic_machine=m68k-altos
+		;;
+	am29k)
+		basic_machine=a29k-none
+		os=-bsd
+		;;
+	amd64)
+		basic_machine=x86_64-pc
+		;;
+	amd64-*)
+		basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	amdahl)
+		basic_machine=580-amdahl
+		os=-sysv
+		;;
+	amiga | amiga-*)
+		basic_machine=m68k-unknown
+		;;
+	amigaos | amigados)
+		basic_machine=m68k-unknown
+		os=-amigaos
+		;;
+	amigaunix | amix)
+		basic_machine=m68k-unknown
+		os=-sysv4
+		;;
+	apollo68)
+		basic_machine=m68k-apollo
+		os=-sysv
+		;;
+	apollo68bsd)
+		basic_machine=m68k-apollo
+		os=-bsd
+		;;
+	aros)
+		basic_machine=i386-pc
+		os=-aros
+		;;
+	asmjs)
+		basic_machine=asmjs-unknown
+		;;
+	aux)
+		basic_machine=m68k-apple
+		os=-aux
+		;;
+	balance)
+		basic_machine=ns32k-sequent
+		os=-dynix
+		;;
+	blackfin)
+		basic_machine=bfin-unknown
+		os=-linux
+		;;
+	blackfin-*)
+		basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'`
+		os=-linux
+		;;
+	bluegene*)
+		basic_machine=powerpc-ibm
+		os=-cnk
+		;;
+	c54x-*)
+		basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	c55x-*)
+		basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	c6x-*)
+		basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	c90)
+		basic_machine=c90-cray
+		os=-unicos
+		;;
+	cegcc)
+		basic_machine=arm-unknown
+		os=-cegcc
+		;;
+	convex-c1)
+		basic_machine=c1-convex
+		os=-bsd
+		;;
+	convex-c2)
+		basic_machine=c2-convex
+		os=-bsd
+		;;
+	convex-c32)
+		basic_machine=c32-convex
+		os=-bsd
+		;;
+	convex-c34)
+		basic_machine=c34-convex
+		os=-bsd
+		;;
+	convex-c38)
+		basic_machine=c38-convex
+		os=-bsd
+		;;
+	cray | j90)
+		basic_machine=j90-cray
+		os=-unicos
+		;;
+	craynv)
+		basic_machine=craynv-cray
+		os=-unicosmp
+		;;
+	cr16 | cr16-*)
+		basic_machine=cr16-unknown
+		os=-elf
+		;;
+	crds | unos)
+		basic_machine=m68k-crds
+		;;
+	crisv32 | crisv32-* | etraxfs*)
+		basic_machine=crisv32-axis
+		;;
+	cris | cris-* | etrax*)
+		basic_machine=cris-axis
+		;;
+	crx)
+		basic_machine=crx-unknown
+		os=-elf
+		;;
+	da30 | da30-*)
+		basic_machine=m68k-da30
+		;;
+	decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
+		basic_machine=mips-dec
+		;;
+	decsystem10* | dec10*)
+		basic_machine=pdp10-dec
+		os=-tops10
+		;;
+	decsystem20* | dec20*)
+		basic_machine=pdp10-dec
+		os=-tops20
+		;;
+	delta | 3300 | motorola-3300 | motorola-delta \
+	      | 3300-motorola | delta-motorola)
+		basic_machine=m68k-motorola
+		;;
+	delta88)
+		basic_machine=m88k-motorola
+		os=-sysv3
+		;;
+	dicos)
+		basic_machine=i686-pc
+		os=-dicos
+		;;
+	djgpp)
+		basic_machine=i586-pc
+		os=-msdosdjgpp
+		;;
+	dpx20 | dpx20-*)
+		basic_machine=rs6000-bull
+		os=-bosx
+		;;
+	dpx2* | dpx2*-bull)
+		basic_machine=m68k-bull
+		os=-sysv3
+		;;
+	e500v[12])
+		basic_machine=powerpc-unknown
+		os=$os"spe"
+		;;
+	e500v[12]-*)
+		basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+		os=$os"spe"
+		;;
+	ebmon29k)
+		basic_machine=a29k-amd
+		os=-ebmon
+		;;
+	elxsi)
+		basic_machine=elxsi-elxsi
+		os=-bsd
+		;;
+	encore | umax | mmax)
+		basic_machine=ns32k-encore
+		;;
+	es1800 | OSE68k | ose68k | ose | OSE)
+		basic_machine=m68k-ericsson
+		os=-ose
+		;;
+	fx2800)
+		basic_machine=i860-alliant
+		;;
+	genix)
+		basic_machine=ns32k-ns
+		;;
+	gmicro)
+		basic_machine=tron-gmicro
+		os=-sysv
+		;;
+	go32)
+		basic_machine=i386-pc
+		os=-go32
+		;;
+	h3050r* | hiux*)
+		basic_machine=hppa1.1-hitachi
+		os=-hiuxwe2
+		;;
+	h8300hms)
+		basic_machine=h8300-hitachi
+		os=-hms
+		;;
+	h8300xray)
+		basic_machine=h8300-hitachi
+		os=-xray
+		;;
+	h8500hms)
+		basic_machine=h8500-hitachi
+		os=-hms
+		;;
+	harris)
+		basic_machine=m88k-harris
+		os=-sysv3
+		;;
+	hp300-*)
+		basic_machine=m68k-hp
+		;;
+	hp300bsd)
+		basic_machine=m68k-hp
+		os=-bsd
+		;;
+	hp300hpux)
+		basic_machine=m68k-hp
+		os=-hpux
+		;;
+	hp3k9[0-9][0-9] | hp9[0-9][0-9])
+		basic_machine=hppa1.0-hp
+		;;
+	hp9k2[0-9][0-9] | hp9k31[0-9])
+		basic_machine=m68000-hp
+		;;
+	hp9k3[2-9][0-9])
+		basic_machine=m68k-hp
+		;;
+	hp9k6[0-9][0-9] | hp6[0-9][0-9])
+		basic_machine=hppa1.0-hp
+		;;
+	hp9k7[0-79][0-9] | hp7[0-79][0-9])
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k78[0-9] | hp78[0-9])
+		# FIXME: really hppa2.0-hp
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
+		# FIXME: really hppa2.0-hp
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k8[0-9][13679] | hp8[0-9][13679])
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k8[0-9][0-9] | hp8[0-9][0-9])
+		basic_machine=hppa1.0-hp
+		;;
+	hppa-next)
+		os=-nextstep3
+		;;
+	hppaosf)
+		basic_machine=hppa1.1-hp
+		os=-osf
+		;;
+	hppro)
+		basic_machine=hppa1.1-hp
+		os=-proelf
+		;;
+	i370-ibm* | ibm*)
+		basic_machine=i370-ibm
+		;;
+	i*86v32)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-sysv32
+		;;
+	i*86v4*)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-sysv4
+		;;
+	i*86v)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-sysv
+		;;
+	i*86sol2)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-solaris2
+		;;
+	i386mach)
+		basic_machine=i386-mach
+		os=-mach
+		;;
+	i386-vsta | vsta)
+		basic_machine=i386-unknown
+		os=-vsta
+		;;
+	iris | iris4d)
+		basic_machine=mips-sgi
+		case $os in
+		    -irix*)
+			;;
+		    *)
+			os=-irix4
+			;;
+		esac
+		;;
+	isi68 | isi)
+		basic_machine=m68k-isi
+		os=-sysv
+		;;
+	leon-*|leon[3-9]-*)
+		basic_machine=sparc-`echo $basic_machine | sed 's/-.*//'`
+		;;
+	m68knommu)
+		basic_machine=m68k-unknown
+		os=-linux
+		;;
+	m68knommu-*)
+		basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'`
+		os=-linux
+		;;
+	m88k-omron*)
+		basic_machine=m88k-omron
+		;;
+	magnum | m3230)
+		basic_machine=mips-mips
+		os=-sysv
+		;;
+	merlin)
+		basic_machine=ns32k-utek
+		os=-sysv
+		;;
+	microblaze*)
+		basic_machine=microblaze-xilinx
+		;;
+	mingw64)
+		basic_machine=x86_64-pc
+		os=-mingw64
+		;;
+	mingw32)
+		basic_machine=i686-pc
+		os=-mingw32
+		;;
+	mingw32ce)
+		basic_machine=arm-unknown
+		os=-mingw32ce
+		;;
+	miniframe)
+		basic_machine=m68000-convergent
+		;;
+	*mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
+		basic_machine=m68k-atari
+		os=-mint
+		;;
+	mips3*-*)
+		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
+		;;
+	mips3*)
+		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
+		;;
+	monitor)
+		basic_machine=m68k-rom68k
+		os=-coff
+		;;
+	morphos)
+		basic_machine=powerpc-unknown
+		os=-morphos
+		;;
+	moxiebox)
+		basic_machine=moxie-unknown
+		os=-moxiebox
+		;;
+	msdos)
+		basic_machine=i386-pc
+		os=-msdos
+		;;
+	ms1-*)
+		basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'`
+		;;
+	msys)
+		basic_machine=i686-pc
+		os=-msys
+		;;
+	mvs)
+		basic_machine=i370-ibm
+		os=-mvs
+		;;
+	nacl)
+		basic_machine=le32-unknown
+		os=-nacl
+		;;
+	ncr3000)
+		basic_machine=i486-ncr
+		os=-sysv4
+		;;
+	netbsd386)
+		basic_machine=i386-unknown
+		os=-netbsd
+		;;
+	netwinder)
+		basic_machine=armv4l-rebel
+		os=-linux
+		;;
+	news | news700 | news800 | news900)
+		basic_machine=m68k-sony
+		os=-newsos
+		;;
+	news1000)
+		basic_machine=m68030-sony
+		os=-newsos
+		;;
+	news-3600 | risc-news)
+		basic_machine=mips-sony
+		os=-newsos
+		;;
+	necv70)
+		basic_machine=v70-nec
+		os=-sysv
+		;;
+	next | m*-next )
+		basic_machine=m68k-next
+		case $os in
+		    -nextstep* )
+			;;
+		    -ns2*)
+		      os=-nextstep2
+			;;
+		    *)
+		      os=-nextstep3
+			;;
+		esac
+		;;
+	nh3000)
+		basic_machine=m68k-harris
+		os=-cxux
+		;;
+	nh[45]000)
+		basic_machine=m88k-harris
+		os=-cxux
+		;;
+	nindy960)
+		basic_machine=i960-intel
+		os=-nindy
+		;;
+	mon960)
+		basic_machine=i960-intel
+		os=-mon960
+		;;
+	nonstopux)
+		basic_machine=mips-compaq
+		os=-nonstopux
+		;;
+	np1)
+		basic_machine=np1-gould
+		;;
+	neo-tandem)
+		basic_machine=neo-tandem
+		;;
+	nse-tandem)
+		basic_machine=nse-tandem
+		;;
+	nsr-tandem)
+		basic_machine=nsr-tandem
+		;;
+	op50n-* | op60c-*)
+		basic_machine=hppa1.1-oki
+		os=-proelf
+		;;
+	openrisc | openrisc-*)
+		basic_machine=or32-unknown
+		;;
+	os400)
+		basic_machine=powerpc-ibm
+		os=-os400
+		;;
+	OSE68000 | ose68000)
+		basic_machine=m68000-ericsson
+		os=-ose
+		;;
+	os68k)
+		basic_machine=m68k-none
+		os=-os68k
+		;;
+	pa-hitachi)
+		basic_machine=hppa1.1-hitachi
+		os=-hiuxwe2
+		;;
+	paragon)
+		basic_machine=i860-intel
+		os=-osf
+		;;
+	parisc)
+		basic_machine=hppa-unknown
+		os=-linux
+		;;
+	parisc-*)
+		basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'`
+		os=-linux
+		;;
+	pbd)
+		basic_machine=sparc-tti
+		;;
+	pbb)
+		basic_machine=m68k-tti
+		;;
+	pc532 | pc532-*)
+		basic_machine=ns32k-pc532
+		;;
+	pc98)
+		basic_machine=i386-pc
+		;;
+	pc98-*)
+		basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pentium | p5 | k5 | k6 | nexgen | viac3)
+		basic_machine=i586-pc
+		;;
+	pentiumpro | p6 | 6x86 | athlon | athlon_*)
+		basic_machine=i686-pc
+		;;
+	pentiumii | pentium2 | pentiumiii | pentium3)
+		basic_machine=i686-pc
+		;;
+	pentium4)
+		basic_machine=i786-pc
+		;;
+	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
+		basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pentiumpro-* | p6-* | 6x86-* | athlon-*)
+		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
+		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pentium4-*)
+		basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pn)
+		basic_machine=pn-gould
+		;;
+	power)	basic_machine=power-ibm
+		;;
+	ppc | ppcbe)	basic_machine=powerpc-unknown
+		;;
+	ppc-* | ppcbe-*)
+		basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ppcle | powerpclittle | ppc-le | powerpc-little)
+		basic_machine=powerpcle-unknown
+		;;
+	ppcle-* | powerpclittle-*)
+		basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ppc64)	basic_machine=powerpc64-unknown
+		;;
+	ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ppc64le | powerpc64little | ppc64-le | powerpc64-little)
+		basic_machine=powerpc64le-unknown
+		;;
+	ppc64le-* | powerpc64little-*)
+		basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ps2)
+		basic_machine=i386-ibm
+		;;
+	pw32)
+		basic_machine=i586-unknown
+		os=-pw32
+		;;
+	rdos | rdos64)
+		basic_machine=x86_64-pc
+		os=-rdos
+		;;
+	rdos32)
+		basic_machine=i386-pc
+		os=-rdos
+		;;
+	rom68k)
+		basic_machine=m68k-rom68k
+		os=-coff
+		;;
+	rm[46]00)
+		basic_machine=mips-siemens
+		;;
+	rtpc | rtpc-*)
+		basic_machine=romp-ibm
+		;;
+	s390 | s390-*)
+		basic_machine=s390-ibm
+		;;
+	s390x | s390x-*)
+		basic_machine=s390x-ibm
+		;;
+	sa29200)
+		basic_machine=a29k-amd
+		os=-udi
+		;;
+	sb1)
+		basic_machine=mipsisa64sb1-unknown
+		;;
+	sb1el)
+		basic_machine=mipsisa64sb1el-unknown
+		;;
+	sde)
+		basic_machine=mipsisa32-sde
+		os=-elf
+		;;
+	sei)
+		basic_machine=mips-sei
+		os=-seiux
+		;;
+	sequent)
+		basic_machine=i386-sequent
+		;;
+	sh)
+		basic_machine=sh-hitachi
+		os=-hms
+		;;
+	sh5el)
+		basic_machine=sh5le-unknown
+		;;
+	sh64)
+		basic_machine=sh64-unknown
+		;;
+	sparclite-wrs | simso-wrs)
+		basic_machine=sparclite-wrs
+		os=-vxworks
+		;;
+	sps7)
+		basic_machine=m68k-bull
+		os=-sysv2
+		;;
+	spur)
+		basic_machine=spur-unknown
+		;;
+	st2000)
+		basic_machine=m68k-tandem
+		;;
+	stratus)
+		basic_machine=i860-stratus
+		os=-sysv4
+		;;
+	strongarm-* | thumb-*)
+		basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	sun2)
+		basic_machine=m68000-sun
+		;;
+	sun2os3)
+		basic_machine=m68000-sun
+		os=-sunos3
+		;;
+	sun2os4)
+		basic_machine=m68000-sun
+		os=-sunos4
+		;;
+	sun3os3)
+		basic_machine=m68k-sun
+		os=-sunos3
+		;;
+	sun3os4)
+		basic_machine=m68k-sun
+		os=-sunos4
+		;;
+	sun4os3)
+		basic_machine=sparc-sun
+		os=-sunos3
+		;;
+	sun4os4)
+		basic_machine=sparc-sun
+		os=-sunos4
+		;;
+	sun4sol2)
+		basic_machine=sparc-sun
+		os=-solaris2
+		;;
+	sun3 | sun3-*)
+		basic_machine=m68k-sun
+		;;
+	sun4)
+		basic_machine=sparc-sun
+		;;
+	sun386 | sun386i | roadrunner)
+		basic_machine=i386-sun
+		;;
+	sv1)
+		basic_machine=sv1-cray
+		os=-unicos
+		;;
+	symmetry)
+		basic_machine=i386-sequent
+		os=-dynix
+		;;
+	t3e)
+		basic_machine=alphaev5-cray
+		os=-unicos
+		;;
+	t90)
+		basic_machine=t90-cray
+		os=-unicos
+		;;
+	tile*)
+		basic_machine=$basic_machine-unknown
+		os=-linux-gnu
+		;;
+	tx39)
+		basic_machine=mipstx39-unknown
+		;;
+	tx39el)
+		basic_machine=mipstx39el-unknown
+		;;
+	toad1)
+		basic_machine=pdp10-xkl
+		os=-tops20
+		;;
+	tower | tower-32)
+		basic_machine=m68k-ncr
+		;;
+	tpf)
+		basic_machine=s390x-ibm
+		os=-tpf
+		;;
+	udi29k)
+		basic_machine=a29k-amd
+		os=-udi
+		;;
+	ultra3)
+		basic_machine=a29k-nyu
+		os=-sym1
+		;;
+	v810 | necv810)
+		basic_machine=v810-nec
+		os=-none
+		;;
+	vaxv)
+		basic_machine=vax-dec
+		os=-sysv
+		;;
+	vms)
+		basic_machine=vax-dec
+		os=-vms
+		;;
+	vpp*|vx|vx-*)
+		basic_machine=f301-fujitsu
+		;;
+	vxworks960)
+		basic_machine=i960-wrs
+		os=-vxworks
+		;;
+	vxworks68)
+		basic_machine=m68k-wrs
+		os=-vxworks
+		;;
+	vxworks29k)
+		basic_machine=a29k-wrs
+		os=-vxworks
+		;;
+	w65*)
+		basic_machine=w65-wdc
+		os=-none
+		;;
+	w89k-*)
+		basic_machine=hppa1.1-winbond
+		os=-proelf
+		;;
+	xbox)
+		basic_machine=i686-pc
+		os=-mingw32
+		;;
+	xps | xps100)
+		basic_machine=xps100-honeywell
+		;;
+	xscale-* | xscalee[bl]-*)
+		basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'`
+		;;
+	ymp)
+		basic_machine=ymp-cray
+		os=-unicos
+		;;
+	z8k-*-coff)
+		basic_machine=z8k-unknown
+		os=-sim
+		;;
+	z80-*-coff)
+		basic_machine=z80-unknown
+		os=-sim
+		;;
+	none)
+		basic_machine=none-none
+		os=-none
+		;;
+
+# Here we handle the default manufacturer of certain CPU types.  It is in
+# some cases the only manufacturer, in others, it is the most popular.
+	w89k)
+		basic_machine=hppa1.1-winbond
+		;;
+	op50n)
+		basic_machine=hppa1.1-oki
+		;;
+	op60c)
+		basic_machine=hppa1.1-oki
+		;;
+	romp)
+		basic_machine=romp-ibm
+		;;
+	mmix)
+		basic_machine=mmix-knuth
+		;;
+	rs6000)
+		basic_machine=rs6000-ibm
+		;;
+	vax)
+		basic_machine=vax-dec
+		;;
+	pdp10)
+		# there are many clones, so DEC is not a safe bet
+		basic_machine=pdp10-unknown
+		;;
+	pdp11)
+		basic_machine=pdp11-dec
+		;;
+	we32k)
+		basic_machine=we32k-att
+		;;
+	sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele)
+		basic_machine=sh-unknown
+		;;
+	sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v)
+		basic_machine=sparc-sun
+		;;
+	cydra)
+		basic_machine=cydra-cydrome
+		;;
+	orion)
+		basic_machine=orion-highlevel
+		;;
+	orion105)
+		basic_machine=clipper-highlevel
+		;;
+	mac | mpw | mac-mpw)
+		basic_machine=m68k-apple
+		;;
+	pmac | pmac-mpw)
+		basic_machine=powerpc-apple
+		;;
+	*-unknown)
+		# Make sure to match an already-canonicalized machine name.
+		;;
+	*)
+		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+		exit 1
+		;;
+esac
+
+# Here we canonicalize certain aliases for manufacturers.
+case $basic_machine in
+	*-digital*)
+		basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
+		;;
+	*-commodore*)
+		basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
+		;;
+	*)
+		;;
+esac
+
+# Decode manufacturer-specific aliases for certain operating systems.
+
+if [ x"$os" != x"" ]
+then
+case $os in
+	# First match some system type aliases
+	# that might get confused with valid system types.
+	# -solaris* is a basic system type, with this one exception.
+	-auroraux)
+		os=-auroraux
+		;;
+	-solaris1 | -solaris1.*)
+		os=`echo $os | sed -e 's|solaris1|sunos4|'`
+		;;
+	-solaris)
+		os=-solaris2
+		;;
+	-svr4*)
+		os=-sysv4
+		;;
+	-unixware*)
+		os=-sysv4.2uw
+		;;
+	-gnu/linux*)
+		os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
+		;;
+	# First accept the basic system types.
+	# The portable systems comes first.
+	# Each alternative MUST END IN A *, to match a version number.
+	# -sysv* is not here because it comes later, after sysvr4.
+	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
+	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\
+	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \
+	      | -sym* | -kopensolaris* | -plan9* \
+	      | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
+	      | -aos* | -aros* | -cloudabi* | -sortix* \
+	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
+	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
+	      | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \
+	      | -bitrig* | -openbsd* | -solidbsd* | -libertybsd* \
+	      | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
+	      | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
+	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
+	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
+	      | -chorusos* | -chorusrdb* | -cegcc* \
+	      | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
+	      | -midipix* | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
+	      | -linux-newlib* | -linux-musl* | -linux-uclibc* \
+	      | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \
+	      | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
+	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
+	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
+	      | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
+	      | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
+	      | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
+	      | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* \
+	      | -onefs* | -tirtos* | -phoenix*)
+	# Remember, each alternative MUST END IN *, to match a version number.
+		;;
+	-qnx*)
+		case $basic_machine in
+		    x86-* | i*86-*)
+			;;
+		    *)
+			os=-nto$os
+			;;
+		esac
+		;;
+	-nto-qnx*)
+		;;
+	-nto*)
+		os=`echo $os | sed -e 's|nto|nto-qnx|'`
+		;;
+	-sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
+	      | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \
+	      | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
+		;;
+	-mac*)
+		os=`echo $os | sed -e 's|mac|macos|'`
+		;;
+	-linux-dietlibc)
+		os=-linux-dietlibc
+		;;
+	-linux*)
+		os=`echo $os | sed -e 's|linux|linux-gnu|'`
+		;;
+	-sunos5*)
+		os=`echo $os | sed -e 's|sunos5|solaris2|'`
+		;;
+	-sunos6*)
+		os=`echo $os | sed -e 's|sunos6|solaris3|'`
+		;;
+	-opened*)
+		os=-openedition
+		;;
+	-os400*)
+		os=-os400
+		;;
+	-wince*)
+		os=-wince
+		;;
+	-osfrose*)
+		os=-osfrose
+		;;
+	-osf*)
+		os=-osf
+		;;
+	-utek*)
+		os=-bsd
+		;;
+	-dynix*)
+		os=-bsd
+		;;
+	-acis*)
+		os=-aos
+		;;
+	-atheos*)
+		os=-atheos
+		;;
+	-syllable*)
+		os=-syllable
+		;;
+	-386bsd)
+		os=-bsd
+		;;
+	-ctix* | -uts*)
+		os=-sysv
+		;;
+	-nova*)
+		os=-rtmk-nova
+		;;
+	-ns2 )
+		os=-nextstep2
+		;;
+	-nsk*)
+		os=-nsk
+		;;
+	# Preserve the version number of sinix5.
+	-sinix5.*)
+		os=`echo $os | sed -e 's|sinix|sysv|'`
+		;;
+	-sinix*)
+		os=-sysv4
+		;;
+	-tpf*)
+		os=-tpf
+		;;
+	-triton*)
+		os=-sysv3
+		;;
+	-oss*)
+		os=-sysv3
+		;;
+	-svr4)
+		os=-sysv4
+		;;
+	-svr3)
+		os=-sysv3
+		;;
+	-sysvr4)
+		os=-sysv4
+		;;
+	# This must come after -sysvr4.
+	-sysv*)
+		;;
+	-ose*)
+		os=-ose
+		;;
+	-es1800*)
+		os=-ose
+		;;
+	-xenix)
+		os=-xenix
+		;;
+	-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+		os=-mint
+		;;
+	-aros*)
+		os=-aros
+		;;
+	-zvmoe)
+		os=-zvmoe
+		;;
+	-dicos*)
+		os=-dicos
+		;;
+	-nacl*)
+		;;
+	-ios)
+		;;
+	-none)
+		;;
+	*)
+		# Get rid of the `-' at the beginning of $os.
+		os=`echo $os | sed 's/[^-]*-//'`
+		echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
+		exit 1
+		;;
+esac
+else
+
+# Here we handle the default operating systems that come with various machines.
+# The value should be what the vendor currently ships out the door with their
+# machine or put another way, the most popular os provided with the machine.
+
+# Note that if you're going to try to match "-MANUFACTURER" here (say,
+# "-sun"), then you have to tell the case statement up towards the top
+# that MANUFACTURER isn't an operating system.  Otherwise, code above
+# will signal an error saying that MANUFACTURER isn't an operating
+# system, and we'll never get to this point.
+
+case $basic_machine in
+	score-*)
+		os=-elf
+		;;
+	spu-*)
+		os=-elf
+		;;
+	*-acorn)
+		os=-riscix1.2
+		;;
+	arm*-rebel)
+		os=-linux
+		;;
+	arm*-semi)
+		os=-aout
+		;;
+	c4x-* | tic4x-*)
+		os=-coff
+		;;
+	c8051-*)
+		os=-elf
+		;;
+	hexagon-*)
+		os=-elf
+		;;
+	tic54x-*)
+		os=-coff
+		;;
+	tic55x-*)
+		os=-coff
+		;;
+	tic6x-*)
+		os=-coff
+		;;
+	# This must come before the *-dec entry.
+	pdp10-*)
+		os=-tops20
+		;;
+	pdp11-*)
+		os=-none
+		;;
+	*-dec | vax-*)
+		os=-ultrix4.2
+		;;
+	m68*-apollo)
+		os=-domain
+		;;
+	i386-sun)
+		os=-sunos4.0.2
+		;;
+	m68000-sun)
+		os=-sunos3
+		;;
+	m68*-cisco)
+		os=-aout
+		;;
+	mep-*)
+		os=-elf
+		;;
+	mips*-cisco)
+		os=-elf
+		;;
+	mips*-*)
+		os=-elf
+		;;
+	or32-*)
+		os=-coff
+		;;
+	*-tti)	# must be before sparc entry or we get the wrong os.
+		os=-sysv3
+		;;
+	sparc-* | *-sun)
+		os=-sunos4.1.1
+		;;
+	*-be)
+		os=-beos
+		;;
+	*-haiku)
+		os=-haiku
+		;;
+	*-ibm)
+		os=-aix
+		;;
+	*-knuth)
+		os=-mmixware
+		;;
+	*-wec)
+		os=-proelf
+		;;
+	*-winbond)
+		os=-proelf
+		;;
+	*-oki)
+		os=-proelf
+		;;
+	*-hp)
+		os=-hpux
+		;;
+	*-hitachi)
+		os=-hiux
+		;;
+	i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
+		os=-sysv
+		;;
+	*-cbm)
+		os=-amigaos
+		;;
+	*-dg)
+		os=-dgux
+		;;
+	*-dolphin)
+		os=-sysv3
+		;;
+	m68k-ccur)
+		os=-rtu
+		;;
+	m88k-omron*)
+		os=-luna
+		;;
+	*-next )
+		os=-nextstep
+		;;
+	*-sequent)
+		os=-ptx
+		;;
+	*-crds)
+		os=-unos
+		;;
+	*-ns)
+		os=-genix
+		;;
+	i370-*)
+		os=-mvs
+		;;
+	*-next)
+		os=-nextstep3
+		;;
+	*-gould)
+		os=-sysv
+		;;
+	*-highlevel)
+		os=-bsd
+		;;
+	*-encore)
+		os=-bsd
+		;;
+	*-sgi)
+		os=-irix
+		;;
+	*-siemens)
+		os=-sysv4
+		;;
+	*-masscomp)
+		os=-rtu
+		;;
+	f30[01]-fujitsu | f700-fujitsu)
+		os=-uxpv
+		;;
+	*-rom68k)
+		os=-coff
+		;;
+	*-*bug)
+		os=-coff
+		;;
+	*-apple)
+		os=-macos
+		;;
+	*-atari*)
+		os=-mint
+		;;
+	*)
+		os=-none
+		;;
+esac
+fi
+
+# Here we handle the case where we know the os, and the CPU type, but not the
+# manufacturer.  We pick the logical manufacturer.
+vendor=unknown
+case $basic_machine in
+	*-unknown)
+		case $os in
+			-riscix*)
+				vendor=acorn
+				;;
+			-sunos*)
+				vendor=sun
+				;;
+			-cnk*|-aix*)
+				vendor=ibm
+				;;
+			-beos*)
+				vendor=be
+				;;
+			-hpux*)
+				vendor=hp
+				;;
+			-mpeix*)
+				vendor=hp
+				;;
+			-hiux*)
+				vendor=hitachi
+				;;
+			-unos*)
+				vendor=crds
+				;;
+			-dgux*)
+				vendor=dg
+				;;
+			-luna*)
+				vendor=omron
+				;;
+			-genix*)
+				vendor=ns
+				;;
+			-mvs* | -opened*)
+				vendor=ibm
+				;;
+			-os400*)
+				vendor=ibm
+				;;
+			-ptx*)
+				vendor=sequent
+				;;
+			-tpf*)
+				vendor=ibm
+				;;
+			-vxsim* | -vxworks* | -windiss*)
+				vendor=wrs
+				;;
+			-aux*)
+				vendor=apple
+				;;
+			-hms*)
+				vendor=hitachi
+				;;
+			-mpw* | -macos*)
+				vendor=apple
+				;;
+			-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+				vendor=atari
+				;;
+			-vos*)
+				vendor=stratus
+				;;
+		esac
+		basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
+		;;
+esac
+
+echo $basic_machine$os
+exit
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:
diff --git a/lib/nauty/config.txt b/lib/nauty/config.txt
new file mode 100644
index 0000000..98f66f0
--- /dev/null
+++ b/lib/nauty/config.txt
@@ -0,0 +1,21 @@
+========================================================================
+| In order to compile nauty on systems which include a Unix-like shell
+| (which includes MacOSX and Cygwin), you must first run the script
+| "configure".  Usually this can be done with the command
+|  ./configure
+| 
+| The configure script will create custom versions of these files:
+|   gtools.h makefile naututil.h nauty.h
+| Afterwards you can use "make" to compile everything.
+| 
+| In case you can't run shell scripts, or configure doesn't work for 
+| some reason, you need to adjust the configuration by hand:
+| For gtools.h, naututil.h, and nauty.h, make sure definitions near the
+| start of the file (like HAVE_UNISTD_H and SIZEOF_INT) are all correct.
+| For makefile, copy the file makefile.basic to makefile, then check the
+| definitions near the start.
+| 
+| Please notify Brendan McKay <bdm@cs.anu.edu.au> of any problems with
+| the configuration and of any hints you might have for other people with
+| similar setups as you have.
+========================================================================
diff --git a/lib/nauty/configure b/lib/nauty/configure
new file mode 100755
index 0000000..7c48ea0
--- /dev/null
+++ b/lib/nauty/configure
@@ -0,0 +1,6622 @@
+#! /bin/sh
+# Guess values for system-dependent variables and create Makefiles.
+# Generated by GNU Autoconf 2.69.
+#
+#
+# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
+#
+#
+# This configure script is free software; the Free Software Foundation
+# gives unlimited permission to copy, distribute and modify it.
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\\(.*\\)$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+      esac;
+      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+# Use a proper internal environment variable to ensure we don't fall
+  # into an infinite loop, continuously re-executing ourselves.
+  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
+    _as_can_reexec=no; export _as_can_reexec;
+    # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+as_fn_exit 255
+  fi
+  # We don't want this to propagate to other subprocesses.
+          { _as_can_reexec=; unset _as_can_reexec;}
+if test "x$CONFIG_SHELL" = x; then
+  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '\${1+\"\$@\"}'='\"\$@\"'
+  setopt NO_GLOB_SUBST
+else
+  case \`(set -o) 2>/dev/null\` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+"
+  as_required="as_fn_return () { (exit \$1); }
+as_fn_success () { as_fn_return 0; }
+as_fn_failure () { as_fn_return 1; }
+as_fn_ret_success () { return 0; }
+as_fn_ret_failure () { return 1; }
+
+exitcode=0
+as_fn_success || { exitcode=1; echo as_fn_success failed.; }
+as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
+as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
+as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
+if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
+
+else
+  exitcode=1; echo positional parameters were not saved.
+fi
+test x\$exitcode = x0 || exit 1
+test -x / || exit 1"
+  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
+  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
+  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
+  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
+test \$(( 1 + 1 )) = 2 || exit 1"
+  if (eval "$as_required") 2>/dev/null; then :
+  as_have_required=yes
+else
+  as_have_required=no
+fi
+  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
+
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_found=false
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  as_found=:
+  case $as_dir in #(
+	 /*)
+	   for as_base in sh bash ksh sh5; do
+	     # Try only shells that exist, to save several forks.
+	     as_shell=$as_dir/$as_base
+	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
+		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  CONFIG_SHELL=$as_shell as_have_required=yes
+		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  break 2
+fi
+fi
+	   done;;
+       esac
+  as_found=false
+done
+$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
+	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
+  CONFIG_SHELL=$SHELL as_have_required=yes
+fi; }
+IFS=$as_save_IFS
+
+
+      if test "x$CONFIG_SHELL" != x; then :
+  export CONFIG_SHELL
+             # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+exit 255
+fi
+
+    if test x$as_have_required = xno; then :
+  $as_echo "$0: This script requires a shell more modern than all"
+  $as_echo "$0: the shells that I found on your system."
+  if test x${ZSH_VERSION+set} = xset ; then
+    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
+    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
+  else
+    $as_echo "$0: Please tell bug-autoconf@gnu.org about your system,
+$0: including any error possibly output before this
+$0: message. Then install a modern shell, or manually run
+$0: the script under such a shell if you do have one."
+  fi
+  exit 1
+fi
+fi
+fi
+SHELL=${CONFIG_SHELL-/bin/sh}
+export SHELL
+# Unset more variables known to interfere with behavior of common tools.
+CLICOLOR_FORCE= GREP_OPTIONS=
+unset CLICOLOR_FORCE GREP_OPTIONS
+
+## --------------------- ##
+## M4sh Shell Functions. ##
+## --------------------- ##
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  $as_echo "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+
+  as_lineno_1=$LINENO as_lineno_1a=$LINENO
+  as_lineno_2=$LINENO as_lineno_2a=$LINENO
+  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
+  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
+  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
+  sed -n '
+    p
+    /[$]LINENO/=
+  ' <$as_myself |
+    sed '
+      s/[$]LINENO.*/&-/
+      t lineno
+      b
+      :lineno
+      N
+      :loop
+      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+      t loop
+      s/-\n.*//
+    ' >$as_me.lineno &&
+  chmod +x "$as_me.lineno" ||
+    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
+
+  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
+  # already done that, so ensure we don't try to do so again and fall
+  # in an infinite loop.  This has already happened in practice.
+  _as_can_reexec=no; export _as_can_reexec
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensitive to this).
+  . "./$as_me.lineno"
+  # Exit status is that of the last command.
+  exit
+}
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
+  fi
+else
+  as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+test -n "$DJDIR" || exec 7<&0 </dev/null
+exec 6>&1
+
+# Name of the host.
+# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
+# so uname gets run too.
+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+
+#
+# Initializations.
+#
+ac_default_prefix=/usr/local
+ac_clean_files=
+ac_config_libobj_dir=.
+LIBOBJS=
+cross_compiling=no
+subdirs=
+MFLAGS=
+MAKEFLAGS=
+
+# Identity of this package.
+PACKAGE_NAME=
+PACKAGE_TARNAME=
+PACKAGE_VERSION=
+PACKAGE_STRING=
+PACKAGE_BUGREPORT=
+PACKAGE_URL=
+
+ac_unique_file="nauty-h.in"
+# Factoring default headers for most tests.
+ac_includes_default="\
+#include <stdio.h>
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# ifdef HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+#ifdef HAVE_STRING_H
+# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
+#  include <memory.h>
+# endif
+# include <string.h>
+#endif
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+# include <inttypes.h>
+#endif
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif"
+
+ac_subst_vars='LTLIBOBJS
+LIBOBJS
+edit_msg
+sort_newparams_ok
+sort_prog
+allow_interrupt
+have_ansicontrols
+default_wordsize
+have_tls
+ac_cv_tls
+stdio_nolock
+threadlib
+have_pthread
+shortg_or_null
+have_clzll
+have_clzl
+have_clz
+MORECFLAGS
+have_mmpop64
+have_mmpop32
+have_popcntll
+have_popcntl
+have_popcnt
+have_hwpopcnt
+have_sigprocmask
+have_sigaction
+have_fseeko
+have_fork
+have_setenv
+have_putenv
+have_popen
+have_wait
+have_pipe
+have_perror
+have_getrusage
+have_times
+have_gettimeofday
+have_time
+have_isatty
+have_const
+testprogs
+lok
+ac_cv_sizeof___int128_t
+ac_cv_sizeof_long_long
+ac_cv_sizeof_long
+ac_cv_sizeof_int
+has_math_inf
+setenv_dec
+putenv_dec
+popen_dec
+fdopen_dec
+ftell_dec
+malloc_dec
+have_pid_t
+header_signal_h
+header_pthread_h
+header_errno_h
+header_sys_types_h
+header_sys_wait_h
+header_string_h
+header_stdlib_h
+header_unistd_h
+header_stddef_h
+EGREP
+GREP
+CPP
+ac_cv_sys_file_offset_bits
+OBJEXT
+EXEEXT
+ac_ct_CC
+CPPFLAGS
+LDFLAGS
+CFLAGS
+CC
+host_os
+host_vendor
+host_cpu
+host
+build_os
+build_vendor
+build_cpu
+build
+target_alias
+host_alias
+build_alias
+LIBS
+ECHO_T
+ECHO_N
+ECHO_C
+DEFS
+mandir
+localedir
+libdir
+psdir
+pdfdir
+dvidir
+htmldir
+infodir
+docdir
+oldincludedir
+includedir
+localstatedir
+sharedstatedir
+sysconfdir
+datadir
+datarootdir
+libexecdir
+sbindir
+bindir
+program_transform_name
+prefix
+exec_prefix
+PACKAGE_URL
+PACKAGE_BUGREPORT
+PACKAGE_STRING
+PACKAGE_VERSION
+PACKAGE_TARNAME
+PACKAGE_NAME
+PATH_SEPARATOR
+SHELL'
+ac_subst_files=''
+ac_user_opts='
+enable_option_checking
+enable_largefile
+enable_popcnt
+enable_clz
+enable_tls
+enable_wordsize
+enable_ansicontrols
+enable_interrupt
+'
+      ac_precious_vars='build_alias
+host_alias
+target_alias
+CC
+CFLAGS
+LDFLAGS
+LIBS
+CPPFLAGS
+CPP'
+
+
+# Initialize some variables set by options.
+ac_init_help=
+ac_init_version=false
+ac_unrecognized_opts=
+ac_unrecognized_sep=
+# The variables have the same names as the options, with
+# dashes changed to underlines.
+cache_file=/dev/null
+exec_prefix=NONE
+no_create=
+no_recursion=
+prefix=NONE
+program_prefix=NONE
+program_suffix=NONE
+program_transform_name=s,x,x,
+silent=
+site=
+srcdir=
+verbose=
+x_includes=NONE
+x_libraries=NONE
+
+# Installation directory options.
+# These are left unexpanded so users can "make install exec_prefix=/foo"
+# and all the variables that are supposed to be based on exec_prefix
+# by default will actually change.
+# Use braces instead of parens because sh, perl, etc. also accept them.
+# (The list follows the same order as the GNU Coding Standards.)
+bindir='${exec_prefix}/bin'
+sbindir='${exec_prefix}/sbin'
+libexecdir='${exec_prefix}/libexec'
+datarootdir='${prefix}/share'
+datadir='${datarootdir}'
+sysconfdir='${prefix}/etc'
+sharedstatedir='${prefix}/com'
+localstatedir='${prefix}/var'
+includedir='${prefix}/include'
+oldincludedir='/usr/include'
+docdir='${datarootdir}/doc/${PACKAGE}'
+infodir='${datarootdir}/info'
+htmldir='${docdir}'
+dvidir='${docdir}'
+pdfdir='${docdir}'
+psdir='${docdir}'
+libdir='${exec_prefix}/lib'
+localedir='${datarootdir}/locale'
+mandir='${datarootdir}/man'
+
+ac_prev=
+ac_dashdash=
+for ac_option
+do
+  # If the previous option needs an argument, assign it.
+  if test -n "$ac_prev"; then
+    eval $ac_prev=\$ac_option
+    ac_prev=
+    continue
+  fi
+
+  case $ac_option in
+  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
+  *=)   ac_optarg= ;;
+  *)    ac_optarg=yes ;;
+  esac
+
+  # Accept the important Cygnus configure options, so we can diagnose typos.
+
+  case $ac_dashdash$ac_option in
+  --)
+    ac_dashdash=yes ;;
+
+  -bindir | --bindir | --bindi | --bind | --bin | --bi)
+    ac_prev=bindir ;;
+  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
+    bindir=$ac_optarg ;;
+
+  -build | --build | --buil | --bui | --bu)
+    ac_prev=build_alias ;;
+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
+    build_alias=$ac_optarg ;;
+
+  -cache-file | --cache-file | --cache-fil | --cache-fi \
+  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+    ac_prev=cache_file ;;
+  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
+    cache_file=$ac_optarg ;;
+
+  --config-cache | -C)
+    cache_file=config.cache ;;
+
+  -datadir | --datadir | --datadi | --datad)
+    ac_prev=datadir ;;
+  -datadir=* | --datadir=* | --datadi=* | --datad=*)
+    datadir=$ac_optarg ;;
+
+  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
+  | --dataroo | --dataro | --datar)
+    ac_prev=datarootdir ;;
+  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
+  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
+    datarootdir=$ac_optarg ;;
+
+  -disable-* | --disable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=no ;;
+
+  -docdir | --docdir | --docdi | --doc | --do)
+    ac_prev=docdir ;;
+  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
+    docdir=$ac_optarg ;;
+
+  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
+    ac_prev=dvidir ;;
+  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
+    dvidir=$ac_optarg ;;
+
+  -enable-* | --enable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=\$ac_optarg ;;
+
+  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+  | --exec | --exe | --ex)
+    ac_prev=exec_prefix ;;
+  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
+  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
+  | --exec=* | --exe=* | --ex=*)
+    exec_prefix=$ac_optarg ;;
+
+  -gas | --gas | --ga | --g)
+    # Obsolete; use --with-gas.
+    with_gas=yes ;;
+
+  -help | --help | --hel | --he | -h)
+    ac_init_help=long ;;
+  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
+    ac_init_help=recursive ;;
+  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
+    ac_init_help=short ;;
+
+  -host | --host | --hos | --ho)
+    ac_prev=host_alias ;;
+  -host=* | --host=* | --hos=* | --ho=*)
+    host_alias=$ac_optarg ;;
+
+  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
+    ac_prev=htmldir ;;
+  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
+  | --ht=*)
+    htmldir=$ac_optarg ;;
+
+  -includedir | --includedir | --includedi | --included | --include \
+  | --includ | --inclu | --incl | --inc)
+    ac_prev=includedir ;;
+  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
+  | --includ=* | --inclu=* | --incl=* | --inc=*)
+    includedir=$ac_optarg ;;
+
+  -infodir | --infodir | --infodi | --infod | --info | --inf)
+    ac_prev=infodir ;;
+  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
+    infodir=$ac_optarg ;;
+
+  -libdir | --libdir | --libdi | --libd)
+    ac_prev=libdir ;;
+  -libdir=* | --libdir=* | --libdi=* | --libd=*)
+    libdir=$ac_optarg ;;
+
+  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
+  | --libexe | --libex | --libe)
+    ac_prev=libexecdir ;;
+  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
+  | --libexe=* | --libex=* | --libe=*)
+    libexecdir=$ac_optarg ;;
+
+  -localedir | --localedir | --localedi | --localed | --locale)
+    ac_prev=localedir ;;
+  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
+    localedir=$ac_optarg ;;
+
+  -localstatedir | --localstatedir | --localstatedi | --localstated \
+  | --localstate | --localstat | --localsta | --localst | --locals)
+    ac_prev=localstatedir ;;
+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
+    localstatedir=$ac_optarg ;;
+
+  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+    ac_prev=mandir ;;
+  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
+    mandir=$ac_optarg ;;
+
+  -nfp | --nfp | --nf)
+    # Obsolete; use --without-fp.
+    with_fp=no ;;
+
+  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+  | --no-cr | --no-c | -n)
+    no_create=yes ;;
+
+  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
+    no_recursion=yes ;;
+
+  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
+  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
+  | --oldin | --oldi | --old | --ol | --o)
+    ac_prev=oldincludedir ;;
+  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
+  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
+  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
+    oldincludedir=$ac_optarg ;;
+
+  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+    ac_prev=prefix ;;
+  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+    prefix=$ac_optarg ;;
+
+  -program-prefix | --program-prefix | --program-prefi | --program-pref \
+  | --program-pre | --program-pr | --program-p)
+    ac_prev=program_prefix ;;
+  -program-prefix=* | --program-prefix=* | --program-prefi=* \
+  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
+    program_prefix=$ac_optarg ;;
+
+  -program-suffix | --program-suffix | --program-suffi | --program-suff \
+  | --program-suf | --program-su | --program-s)
+    ac_prev=program_suffix ;;
+  -program-suffix=* | --program-suffix=* | --program-suffi=* \
+  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
+    program_suffix=$ac_optarg ;;
+
+  -program-transform-name | --program-transform-name \
+  | --program-transform-nam | --program-transform-na \
+  | --program-transform-n | --program-transform- \
+  | --program-transform | --program-transfor \
+  | --program-transfo | --program-transf \
+  | --program-trans | --program-tran \
+  | --progr-tra | --program-tr | --program-t)
+    ac_prev=program_transform_name ;;
+  -program-transform-name=* | --program-transform-name=* \
+  | --program-transform-nam=* | --program-transform-na=* \
+  | --program-transform-n=* | --program-transform-=* \
+  | --program-transform=* | --program-transfor=* \
+  | --program-transfo=* | --program-transf=* \
+  | --program-trans=* | --program-tran=* \
+  | --progr-tra=* | --program-tr=* | --program-t=*)
+    program_transform_name=$ac_optarg ;;
+
+  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
+    ac_prev=pdfdir ;;
+  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
+    pdfdir=$ac_optarg ;;
+
+  -psdir | --psdir | --psdi | --psd | --ps)
+    ac_prev=psdir ;;
+  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
+    psdir=$ac_optarg ;;
+
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil)
+    silent=yes ;;
+
+  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+    ac_prev=sbindir ;;
+  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+  | --sbi=* | --sb=*)
+    sbindir=$ac_optarg ;;
+
+  -sharedstatedir | --sharedstatedir | --sharedstatedi \
+  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
+  | --sharedst | --shareds | --shared | --share | --shar \
+  | --sha | --sh)
+    ac_prev=sharedstatedir ;;
+  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
+  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
+  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
+  | --sha=* | --sh=*)
+    sharedstatedir=$ac_optarg ;;
+
+  -site | --site | --sit)
+    ac_prev=site ;;
+  -site=* | --site=* | --sit=*)
+    site=$ac_optarg ;;
+
+  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+    ac_prev=srcdir ;;
+  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+    srcdir=$ac_optarg ;;
+
+  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
+  | --syscon | --sysco | --sysc | --sys | --sy)
+    ac_prev=sysconfdir ;;
+  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
+  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
+    sysconfdir=$ac_optarg ;;
+
+  -target | --target | --targe | --targ | --tar | --ta | --t)
+    ac_prev=target_alias ;;
+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
+    target_alias=$ac_optarg ;;
+
+  -v | -verbose | --verbose | --verbos | --verbo | --verb)
+    verbose=yes ;;
+
+  -version | --version | --versio | --versi | --vers | -V)
+    ac_init_version=: ;;
+
+  -with-* | --with-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=\$ac_optarg ;;
+
+  -without-* | --without-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error $? "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=no ;;
+
+  --x)
+    # Obsolete; use --with-x.
+    with_x=yes ;;
+
+  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
+  | --x-incl | --x-inc | --x-in | --x-i)
+    ac_prev=x_includes ;;
+  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
+  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
+    x_includes=$ac_optarg ;;
+
+  -x-libraries | --x-libraries | --x-librarie | --x-librari \
+  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
+    ac_prev=x_libraries ;;
+  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
+  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
+    x_libraries=$ac_optarg ;;
+
+  -*) as_fn_error $? "unrecognized option: \`$ac_option'
+Try \`$0 --help' for more information"
+    ;;
+
+  *=*)
+    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
+    # Reject names that are not valid shell variable names.
+    case $ac_envvar in #(
+      '' | [0-9]* | *[!_$as_cr_alnum]* )
+      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
+    esac
+    eval $ac_envvar=\$ac_optarg
+    export $ac_envvar ;;
+
+  *)
+    # FIXME: should be removed in autoconf 3.0.
+    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
+    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
+    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
+    ;;
+
+  esac
+done
+
+if test -n "$ac_prev"; then
+  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
+  as_fn_error $? "missing argument to $ac_option"
+fi
+
+if test -n "$ac_unrecognized_opts"; then
+  case $enable_option_checking in
+    no) ;;
+    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
+    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
+  esac
+fi
+
+# Check all directory arguments for consistency.
+for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
+		datadir sysconfdir sharedstatedir localstatedir includedir \
+		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
+		libdir localedir mandir
+do
+  eval ac_val=\$$ac_var
+  # Remove trailing slashes.
+  case $ac_val in
+    */ )
+      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
+      eval $ac_var=\$ac_val;;
+  esac
+  # Be sure to have absolute directory names.
+  case $ac_val in
+    [\\/$]* | ?:[\\/]* )  continue;;
+    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+  esac
+  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
+done
+
+# There might be people who depend on the old broken behavior: `$host'
+# used to hold the argument of --host etc.
+# FIXME: To remove some day.
+build=$build_alias
+host=$host_alias
+target=$target_alias
+
+# FIXME: To remove some day.
+if test "x$host_alias" != x; then
+  if test "x$build_alias" = x; then
+    cross_compiling=maybe
+  elif test "x$build_alias" != "x$host_alias"; then
+    cross_compiling=yes
+  fi
+fi
+
+ac_tool_prefix=
+test -n "$host_alias" && ac_tool_prefix=$host_alias-
+
+test "$silent" = yes && exec 6>/dev/null
+
+
+ac_pwd=`pwd` && test -n "$ac_pwd" &&
+ac_ls_di=`ls -di .` &&
+ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
+  as_fn_error $? "working directory cannot be determined"
+test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
+  as_fn_error $? "pwd does not report name of working directory"
+
+
+# Find the source files, if location was not specified.
+if test -z "$srcdir"; then
+  ac_srcdir_defaulted=yes
+  # Try the directory containing this script, then the parent directory.
+  ac_confdir=`$as_dirname -- "$as_myself" ||
+$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_myself" : 'X\(//\)[^/]' \| \
+	 X"$as_myself" : 'X\(//\)$' \| \
+	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_myself" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  srcdir=$ac_confdir
+  if test ! -r "$srcdir/$ac_unique_file"; then
+    srcdir=..
+  fi
+else
+  ac_srcdir_defaulted=no
+fi
+if test ! -r "$srcdir/$ac_unique_file"; then
+  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
+  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
+fi
+ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
+ac_abs_confdir=`(
+	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
+	pwd)`
+# When building in place, set srcdir=.
+if test "$ac_abs_confdir" = "$ac_pwd"; then
+  srcdir=.
+fi
+# Remove unnecessary trailing slashes from srcdir.
+# Double slashes in file names in object file debugging info
+# mess up M-x gdb in Emacs.
+case $srcdir in
+*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
+esac
+for ac_var in $ac_precious_vars; do
+  eval ac_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_env_${ac_var}_value=\$${ac_var}
+  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_cv_env_${ac_var}_value=\$${ac_var}
+done
+
+#
+# Report the --help message.
+#
+if test "$ac_init_help" = "long"; then
+  # Omit some internal or obsolete options to make the list less imposing.
+  # This message is too long to be a string in the A/UX 3.1 sh.
+  cat <<_ACEOF
+\`configure' configures this package to adapt to many kinds of systems.
+
+Usage: $0 [OPTION]... [VAR=VALUE]...
+
+To assign environment variables (e.g., CC, CFLAGS...), specify them as
+VAR=VALUE.  See below for descriptions of some of the useful variables.
+
+Defaults for the options are specified in brackets.
+
+Configuration:
+  -h, --help              display this help and exit
+      --help=short        display options specific to this package
+      --help=recursive    display the short help of all the included packages
+  -V, --version           display version information and exit
+  -q, --quiet, --silent   do not print \`checking ...' messages
+      --cache-file=FILE   cache test results in FILE [disabled]
+  -C, --config-cache      alias for \`--cache-file=config.cache'
+  -n, --no-create         do not create output files
+      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+
+Installation directories:
+  --prefix=PREFIX         install architecture-independent files in PREFIX
+                          [$ac_default_prefix]
+  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
+                          [PREFIX]
+
+By default, \`make install' will install all the files in
+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
+an installation prefix other than \`$ac_default_prefix' using \`--prefix',
+for instance \`--prefix=\$HOME'.
+
+For better control, use the options below.
+
+Fine tuning of the installation directories:
+  --bindir=DIR            user executables [EPREFIX/bin]
+  --sbindir=DIR           system admin executables [EPREFIX/sbin]
+  --libexecdir=DIR        program executables [EPREFIX/libexec]
+  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
+  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
+  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
+  --libdir=DIR            object code libraries [EPREFIX/lib]
+  --includedir=DIR        C header files [PREFIX/include]
+  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
+  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
+  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
+  --infodir=DIR           info documentation [DATAROOTDIR/info]
+  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
+  --mandir=DIR            man documentation [DATAROOTDIR/man]
+  --docdir=DIR            documentation root [DATAROOTDIR/doc/PACKAGE]
+  --htmldir=DIR           html documentation [DOCDIR]
+  --dvidir=DIR            dvi documentation [DOCDIR]
+  --pdfdir=DIR            pdf documentation [DOCDIR]
+  --psdir=DIR             ps documentation [DOCDIR]
+_ACEOF
+
+  cat <<\_ACEOF
+
+System types:
+  --build=BUILD     configure for building on BUILD [guessed]
+  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
+_ACEOF
+fi
+
+if test -n "$ac_init_help"; then
+
+  cat <<\_ACEOF
+
+Optional Features:
+  --disable-option-checking  ignore unrecognized --enable/--with options
+  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
+  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
+  --disable-largefile     omit support for large files
+  --disable-popcnt        Disable popcnt extensions
+  --disable-clz           Disable clz extensions
+  --enable-tls            Enable thread-local variables
+  --enable-wordsize=value Override default WORDSIZE choice
+  --enable-ansicontrols   Enable ANSI terminal control sequences
+  --disable-interrupt     Disable SIGINT catching in dreadnaut
+
+Some influential environment variables:
+  CC          C compiler command
+  CFLAGS      C compiler flags
+  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+              nonstandard directory <lib dir>
+  LIBS        libraries to pass to the linker, e.g. -l<library>
+  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
+              you have headers in a nonstandard directory <include dir>
+  CPP         C preprocessor
+
+Use these variables to override the choices made by `configure' or to help
+it to find libraries and programs with nonstandard names/locations.
+
+Report bugs to the package provider.
+_ACEOF
+ac_status=$?
+fi
+
+if test "$ac_init_help" = "recursive"; then
+  # If there are subdirs, report their specific --help.
+  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+    test -d "$ac_dir" ||
+      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
+      continue
+    ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+    cd "$ac_dir" || { ac_status=$?; continue; }
+    # Check for guested configure.
+    if test -f "$ac_srcdir/configure.gnu"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
+    elif test -f "$ac_srcdir/configure"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure" --help=recursive
+    else
+      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+    fi || ac_status=$?
+    cd "$ac_pwd" || { ac_status=$?; break; }
+  done
+fi
+
+test -n "$ac_init_help" && exit $ac_status
+if $ac_init_version; then
+  cat <<\_ACEOF
+configure
+generated by GNU Autoconf 2.69
+
+Copyright (C) 2012 Free Software Foundation, Inc.
+This configure script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it.
+_ACEOF
+  exit
+fi
+
+## ------------------------ ##
+## Autoconf initialization. ##
+## ------------------------ ##
+
+# ac_fn_c_try_compile LINENO
+# --------------------------
+# Try to compile conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext
+  if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_compile
+
+# ac_fn_c_try_run LINENO
+# ----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
+# that executables *can* be run.
+ac_fn_c_try_run ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: program exited with status $ac_status" >&5
+       $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+       ac_retval=$ac_status
+fi
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_run
+
+# ac_fn_c_try_cpp LINENO
+# ----------------------
+# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_cpp ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } > conftest.i && {
+	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+    ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_cpp
+
+# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists, giving a warning if it cannot be compiled using
+# the include files in INCLUDES and setting the cache variable VAR
+# accordingly.
+ac_fn_c_check_header_mongrel ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if eval \${$3+:} false; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+else
+  # Is the header compilable?
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
+$as_echo_n "checking $2 usability... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_header_compiler=yes
+else
+  ac_header_compiler=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
+$as_echo "$ac_header_compiler" >&6; }
+
+# Is the header present?
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
+$as_echo_n "checking $2 presence... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <$2>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  ac_header_preproc=yes
+else
+  ac_header_preproc=no
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
+$as_echo "$ac_header_preproc" >&6; }
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
+  yes:no: )
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
+$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+    ;;
+  no:yes:* )
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
+$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
+$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
+$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
+$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+    ;;
+esac
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  eval "$3=\$ac_header_compiler"
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_header_mongrel
+
+# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists and can be compiled using the include files in
+# INCLUDES, setting the cache variable VAR accordingly.
+ac_fn_c_check_header_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_header_compile
+
+# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
+# -------------------------------------------
+# Tests whether TYPE exists after having included INCLUDES, setting cache
+# variable VAR accordingly.
+ac_fn_c_check_type ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  eval "$3=no"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+if (sizeof ($2))
+	 return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+if (sizeof (($2)))
+	    return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  eval "$3=yes"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_type
+
+# ac_fn_c_compute_int LINENO EXPR VAR INCLUDES
+# --------------------------------------------
+# Tries to find the compile-time value of EXPR in a program that includes
+# INCLUDES, setting VAR accordingly. Returns whether the value could be
+# computed
+ac_fn_c_compute_int ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if test "$cross_compiling" = yes; then
+    # Depending upon the size, compute the lo and hi bounds.
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+static int test_array [1 - 2 * !(($2) >= 0)];
+test_array [0] = 0;
+return test_array [0];
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_lo=0 ac_mid=0
+  while :; do
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+static int test_array [1 - 2 * !(($2) <= $ac_mid)];
+test_array [0] = 0;
+return test_array [0];
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_hi=$ac_mid; break
+else
+  as_fn_arith $ac_mid + 1 && ac_lo=$as_val
+			if test $ac_lo -le $ac_mid; then
+			  ac_lo= ac_hi=
+			  break
+			fi
+			as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+  done
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+static int test_array [1 - 2 * !(($2) < 0)];
+test_array [0] = 0;
+return test_array [0];
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_hi=-1 ac_mid=-1
+  while :; do
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+static int test_array [1 - 2 * !(($2) >= $ac_mid)];
+test_array [0] = 0;
+return test_array [0];
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_lo=$ac_mid; break
+else
+  as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
+			if test $ac_mid -le $ac_hi; then
+			  ac_lo= ac_hi=
+			  break
+			fi
+			as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+  done
+else
+  ac_lo= ac_hi=
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+# Binary search between lo and hi bounds.
+while test "x$ac_lo" != "x$ac_hi"; do
+  as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+static int test_array [1 - 2 * !(($2) <= $ac_mid)];
+test_array [0] = 0;
+return test_array [0];
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_hi=$ac_mid
+else
+  as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+done
+case $ac_lo in #((
+?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
+'') ac_retval=1 ;;
+esac
+  else
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+static long int longval () { return $2; }
+static unsigned long int ulongval () { return $2; }
+#include <stdio.h>
+#include <stdlib.h>
+int
+main ()
+{
+
+  FILE *f = fopen ("conftest.val", "w");
+  if (! f)
+    return 1;
+  if (($2) < 0)
+    {
+      long int i = longval ();
+      if (i != ($2))
+	return 1;
+      fprintf (f, "%ld", i);
+    }
+  else
+    {
+      unsigned long int i = ulongval ();
+      if (i != ($2))
+	return 1;
+      fprintf (f, "%lu", i);
+    }
+  /* Do not output a trailing newline, as this causes \r\n confusion
+     on some platforms.  */
+  return ferror (f) || fclose (f) != 0;
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+  echo >>conftest.val; read $3 <conftest.val; ac_retval=0
+else
+  ac_retval=1
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+rm -f conftest.val
+
+  fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_compute_int
+
+# ac_fn_c_try_link LINENO
+# -----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_link ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext conftest$ac_exeext
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest$ac_exeext && {
+	 test "$cross_compiling" = yes ||
+	 test -x conftest$ac_exeext
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
+  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
+  # interfere with the next link command; also delete a directory that is
+  # left behind by Apple's compiler.  We do this before executing the actions.
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_link
+
+# ac_fn_c_check_func LINENO FUNC VAR
+# ----------------------------------
+# Tests whether FUNC exists, setting the cache variable VAR accordingly
+ac_fn_c_check_func ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+/* Define $2 to an innocuous variant, in case <limits.h> declares $2.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $2 innocuous_$2
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $2 (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $2
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char $2 ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_$2 || defined __stub___$2
+choke me
+#endif
+
+int
+main ()
+{
+return $2 ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_func
+cat >config.log <<_ACEOF
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+
+It was created by $as_me, which was
+generated by GNU Autoconf 2.69.  Invocation command line was
+
+  $ $0 $@
+
+_ACEOF
+exec 5>>config.log
+{
+cat <<_ASUNAME
+## --------- ##
+## Platform. ##
+## --------- ##
+
+hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
+
+/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
+/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+
+_ASUNAME
+
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    $as_echo "PATH: $as_dir"
+  done
+IFS=$as_save_IFS
+
+} >&5
+
+cat >&5 <<_ACEOF
+
+
+## ----------- ##
+## Core tests. ##
+## ----------- ##
+
+_ACEOF
+
+
+# Keep a trace of the command line.
+# Strip out --no-create and --no-recursion so they do not pile up.
+# Strip out --silent because we don't want to record it for future runs.
+# Also quote any args containing shell meta-characters.
+# Make two passes to allow for proper duplicate-argument suppression.
+ac_configure_args=
+ac_configure_args0=
+ac_configure_args1=
+ac_must_keep_next=false
+for ac_pass in 1 2
+do
+  for ac_arg
+  do
+    case $ac_arg in
+    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
+    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+    | -silent | --silent | --silen | --sile | --sil)
+      continue ;;
+    *\'*)
+      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    case $ac_pass in
+    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
+    2)
+      as_fn_append ac_configure_args1 " '$ac_arg'"
+      if test $ac_must_keep_next = true; then
+	ac_must_keep_next=false # Got value, back to normal.
+      else
+	case $ac_arg in
+	  *=* | --config-cache | -C | -disable-* | --disable-* \
+	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
+	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
+	  | -with-* | --with-* | -without-* | --without-* | --x)
+	    case "$ac_configure_args0 " in
+	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
+	    esac
+	    ;;
+	  -* ) ac_must_keep_next=true ;;
+	esac
+      fi
+      as_fn_append ac_configure_args " '$ac_arg'"
+      ;;
+    esac
+  done
+done
+{ ac_configure_args0=; unset ac_configure_args0;}
+{ ac_configure_args1=; unset ac_configure_args1;}
+
+# When interrupted or exit'd, cleanup temporary files, and complete
+# config.log.  We remove comments because anyway the quotes in there
+# would cause problems or look ugly.
+# WARNING: Use '\'' to represent an apostrophe within the trap.
+# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+trap 'exit_status=$?
+  # Save into config.log some information that might help in debugging.
+  {
+    echo
+
+    $as_echo "## ---------------- ##
+## Cache variables. ##
+## ---------------- ##"
+    echo
+    # The following way of writing the cache mishandles newlines in values,
+(
+  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+  (set) 2>&1 |
+    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      sed -n \
+	"s/'\''/'\''\\\\'\'''\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
+      ;; #(
+    *)
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+)
+    echo
+
+    $as_echo "## ----------------- ##
+## Output variables. ##
+## ----------------- ##"
+    echo
+    for ac_var in $ac_subst_vars
+    do
+      eval ac_val=\$$ac_var
+      case $ac_val in
+      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+      esac
+      $as_echo "$ac_var='\''$ac_val'\''"
+    done | sort
+    echo
+
+    if test -n "$ac_subst_files"; then
+      $as_echo "## ------------------- ##
+## File substitutions. ##
+## ------------------- ##"
+      echo
+      for ac_var in $ac_subst_files
+      do
+	eval ac_val=\$$ac_var
+	case $ac_val in
+	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+	esac
+	$as_echo "$ac_var='\''$ac_val'\''"
+      done | sort
+      echo
+    fi
+
+    if test -s confdefs.h; then
+      $as_echo "## ----------- ##
+## confdefs.h. ##
+## ----------- ##"
+      echo
+      cat confdefs.h
+      echo
+    fi
+    test "$ac_signal" != 0 &&
+      $as_echo "$as_me: caught signal $ac_signal"
+    $as_echo "$as_me: exit $exit_status"
+  } >&5
+  rm -f core *.core core.conftest.* &&
+    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+    exit $exit_status
+' 0
+for ac_signal in 1 2 13 15; do
+  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
+done
+ac_signal=0
+
+# confdefs.h avoids OS command line length limits that DEFS can exceed.
+rm -f -r conftest* confdefs.h
+
+$as_echo "/* confdefs.h */" > confdefs.h
+
+# Predefined preprocessor variables.
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_NAME "$PACKAGE_NAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_VERSION "$PACKAGE_VERSION"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_STRING "$PACKAGE_STRING"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_URL "$PACKAGE_URL"
+_ACEOF
+
+
+# Let the site file select an alternate cache file if it wants to.
+# Prefer an explicitly selected file to automatically selected ones.
+ac_site_file1=NONE
+ac_site_file2=NONE
+if test -n "$CONFIG_SITE"; then
+  # We do not want a PATH search for config.site.
+  case $CONFIG_SITE in #((
+    -*)  ac_site_file1=./$CONFIG_SITE;;
+    */*) ac_site_file1=$CONFIG_SITE;;
+    *)   ac_site_file1=./$CONFIG_SITE;;
+  esac
+elif test "x$prefix" != xNONE; then
+  ac_site_file1=$prefix/share/config.site
+  ac_site_file2=$prefix/etc/config.site
+else
+  ac_site_file1=$ac_default_prefix/share/config.site
+  ac_site_file2=$ac_default_prefix/etc/config.site
+fi
+for ac_site_file in "$ac_site_file1" "$ac_site_file2"
+do
+  test "x$ac_site_file" = xNONE && continue
+  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
+$as_echo "$as_me: loading site script $ac_site_file" >&6;}
+    sed 's/^/| /' "$ac_site_file" >&5
+    . "$ac_site_file" \
+      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "failed to load site script $ac_site_file
+See \`config.log' for more details" "$LINENO" 5; }
+  fi
+done
+
+if test -r "$cache_file"; then
+  # Some versions of bash will fail to source /dev/null (special files
+  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
+  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
+$as_echo "$as_me: loading cache $cache_file" >&6;}
+    case $cache_file in
+      [\\/]* | ?:[\\/]* ) . "$cache_file";;
+      *)                      . "./$cache_file";;
+    esac
+  fi
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
+$as_echo "$as_me: creating cache $cache_file" >&6;}
+  >$cache_file
+fi
+
+# Check that the precious variables saved in the cache have kept the same
+# value.
+ac_cache_corrupted=false
+for ac_var in $ac_precious_vars; do
+  eval ac_old_set=\$ac_cv_env_${ac_var}_set
+  eval ac_new_set=\$ac_env_${ac_var}_set
+  eval ac_old_val=\$ac_cv_env_${ac_var}_value
+  eval ac_new_val=\$ac_env_${ac_var}_value
+  case $ac_old_set,$ac_new_set in
+    set,)
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,set)
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,);;
+    *)
+      if test "x$ac_old_val" != "x$ac_new_val"; then
+	# differences in whitespace do not lead to failure.
+	ac_old_val_w=`echo x $ac_old_val`
+	ac_new_val_w=`echo x $ac_new_val`
+	if test "$ac_old_val_w" != "$ac_new_val_w"; then
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
+$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
+	  ac_cache_corrupted=:
+	else
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
+$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
+	  eval $ac_var=\$ac_old_val
+	fi
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
+$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
+$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
+      fi;;
+  esac
+  # Pass precious variables to config.status.
+  if test "$ac_new_set" = set; then
+    case $ac_new_val in
+    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+    *) ac_arg=$ac_var=$ac_new_val ;;
+    esac
+    case " $ac_configure_args " in
+      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
+      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
+    esac
+  fi
+done
+if $ac_cache_corrupted; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
+$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
+  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
+fi
+## -------------------- ##
+## Main body of script. ##
+## -------------------- ##
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+
+
+
+
+
+
+ac_aux_dir=
+for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
+  if test -f "$ac_dir/install-sh"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install-sh -c"
+    break
+  elif test -f "$ac_dir/install.sh"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install.sh -c"
+    break
+  elif test -f "$ac_dir/shtool"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/shtool install -c"
+    break
+  fi
+done
+if test -z "$ac_aux_dir"; then
+  as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5
+fi
+
+# These three variables are undocumented and unsupported,
+# and are intended to be withdrawn in a future Autoconf release.
+# They can cause serious problems if a builder's source tree is in a directory
+# whose full name contains unusual characters.
+ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
+ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
+ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
+
+
+# Make sure we can run config.sub.
+$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
+  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
+$as_echo_n "checking build system type... " >&6; }
+if ${ac_cv_build+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_build_alias=$build_alias
+test "x$ac_build_alias" = x &&
+  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
+test "x$ac_build_alias" = x &&
+  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
+ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
+  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
+$as_echo "$ac_cv_build" >&6; }
+case $ac_cv_build in
+*-*-*) ;;
+*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
+esac
+build=$ac_cv_build
+ac_save_IFS=$IFS; IFS='-'
+set x $ac_cv_build
+shift
+build_cpu=$1
+build_vendor=$2
+shift; shift
+# Remember, the first character of IFS is used to create $*,
+# except with old shells:
+build_os=$*
+IFS=$ac_save_IFS
+case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
+$as_echo_n "checking host system type... " >&6; }
+if ${ac_cv_host+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test "x$host_alias" = x; then
+  ac_cv_host=$ac_cv_build
+else
+  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
+    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
+$as_echo "$ac_cv_host" >&6; }
+case $ac_cv_host in
+*-*-*) ;;
+*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
+esac
+host=$ac_cv_host
+ac_save_IFS=$IFS; IFS='-'
+set x $ac_cv_host
+shift
+host_cpu=$1
+host_vendor=$2
+shift; shift
+# Remember, the first character of IFS is used to create $*,
+# except with old shells:
+host_os=$*
+IFS=$ac_save_IFS
+case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
+
+
+case "$host" in
+  *powerpc*)
+     is_powerpc=1 ;;
+  *)
+     is_powerpc=0 ;;
+esac
+
+case "$build" in
+  *cygwin*)
+     is_cygwin=1 ;;
+  *)
+     is_cygwin=0 ;;
+esac
+
+case "$CC" in
+  gcc*)
+     gccver=`"$CC" -dumpversion` ;;
+  *)
+     gccver=0.0.0 ;;
+esac
+
+user_cflags="$CFLAGS"
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+  ac_ct_CC=$CC
+  # Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+else
+  CC="$ac_cv_prog_CC"
+fi
+
+if test -z "$CC"; then
+          if test -n "$ac_tool_prefix"; then
+    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  fi
+fi
+if test -z "$CC"; then
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  ac_prog_rejected=no
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+       ac_prog_rejected=yes
+       continue
+     fi
+    ac_cv_prog_CC="cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+if test $ac_prog_rejected = yes; then
+  # We found a bogon in the path, so make sure we never use it.
+  set dummy $ac_cv_prog_CC
+  shift
+  if test $# != 0; then
+    # We chose a different compiler from the bogus one.
+    # However, it has the same basename, so the bogon will be chosen
+    # first if we set CC to just the basename; use the full file name.
+    shift
+    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
+  fi
+fi
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$CC"; then
+  if test -n "$ac_tool_prefix"; then
+  for ac_prog in cl.exe
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$CC" && break
+  done
+fi
+if test -z "$CC"; then
+  ac_ct_CC=$CC
+  for ac_prog in cl.exe
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_CC" && break
+done
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+fi
+
+fi
+
+
+test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "no acceptable C compiler found in \$PATH
+See \`config.log' for more details" "$LINENO" 5; }
+
+# Provide some information about the compiler.
+$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
+set X $ac_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion; do
+  { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    sed '10a\
+... rest of stderr output deleted ...
+         10q' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+  fi
+  rm -f conftest.er1 conftest.err
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+done
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
+# Try to create an executable without -o first, disregard a.out.
+# It will help us diagnose broken compilers, and finding out an intuition
+# of exeext.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
+$as_echo_n "checking whether the C compiler works... " >&6; }
+ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+
+# The possible output files:
+ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
+
+ac_rmfiles=
+for ac_file in $ac_files
+do
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
+  esac
+done
+rm -f $ac_rmfiles
+
+if { { ac_try="$ac_link_default"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link_default") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
+# in a Makefile.  We should not override ac_cv_exeext if it was cached,
+# so that the user can short-circuit this test for compilers unknown to
+# Autoconf.
+for ac_file in $ac_files ''
+do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
+	;;
+    [ab].out )
+	# We found the default executable, but exeext='' is most
+	# certainly right.
+	break;;
+    *.* )
+	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
+	then :; else
+	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	fi
+	# We set ac_cv_exeext here because the later test for it is not
+	# safe: cross compilers may not add the suffix if given an `-o'
+	# argument, so we may need to know it at that point already.
+	# Even if this section looks crufty: it has the advantage of
+	# actually working.
+	break;;
+    * )
+	break;;
+  esac
+done
+test "$ac_cv_exeext" = no && ac_cv_exeext=
+
+else
+  ac_file=''
+fi
+if test -z "$ac_file"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+$as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "C compiler cannot create executables
+See \`config.log' for more details" "$LINENO" 5; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
+$as_echo_n "checking for C compiler default output file name... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
+$as_echo "$ac_file" >&6; }
+ac_exeext=$ac_cv_exeext
+
+rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
+$as_echo_n "checking for suffix of executables... " >&6; }
+if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # If both `conftest.exe' and `conftest' are `present' (well, observable)
+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
+# work properly (i.e., refer to `conftest.exe'), while it won't with
+# `rm'.
+for ac_file in conftest.exe conftest conftest.*; do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	  break;;
+    * ) break;;
+  esac
+done
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest conftest$ac_cv_exeext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
+$as_echo "$ac_cv_exeext" >&6; }
+
+rm -f conftest.$ac_ext
+EXEEXT=$ac_cv_exeext
+ac_exeext=$EXEEXT
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+int
+main ()
+{
+FILE *f = fopen ("conftest.out", "w");
+ return ferror (f) || fclose (f) != 0;
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files="$ac_clean_files conftest.out"
+# Check that the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
+$as_echo_n "checking whether we are cross compiling... " >&6; }
+if test "$cross_compiling" != yes; then
+  { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+  if { ac_try='./conftest$ac_cv_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then
+    cross_compiling=no
+  else
+    if test "$cross_compiling" = maybe; then
+	cross_compiling=yes
+    else
+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details" "$LINENO" 5; }
+    fi
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
+$as_echo "$cross_compiling" >&6; }
+
+rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
+$as_echo_n "checking for suffix of object files... " >&6; }
+if ${ac_cv_objext+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.o conftest.obj
+if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  for ac_file in conftest.o conftest.obj conftest.*; do
+  test -f "$ac_file" || continue;
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
+    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+       break;;
+  esac
+done
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of object files: cannot compile
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest.$ac_cv_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
+$as_echo "$ac_cv_objext" >&6; }
+OBJEXT=$ac_cv_objext
+ac_objext=$OBJEXT
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
+$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
+if ${ac_cv_c_compiler_gnu+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_compiler_gnu=yes
+else
+  ac_compiler_gnu=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_c_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
+$as_echo "$ac_cv_c_compiler_gnu" >&6; }
+if test $ac_compiler_gnu = yes; then
+  GCC=yes
+else
+  GCC=
+fi
+ac_test_CFLAGS=${CFLAGS+set}
+ac_save_CFLAGS=$CFLAGS
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
+$as_echo_n "checking whether $CC accepts -g... " >&6; }
+if ${ac_cv_prog_cc_g+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_c_werror_flag=$ac_c_werror_flag
+   ac_c_werror_flag=yes
+   ac_cv_prog_cc_g=no
+   CFLAGS="-g"
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+else
+  CFLAGS=""
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  ac_c_werror_flag=$ac_save_c_werror_flag
+	 CFLAGS="-g"
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   ac_c_werror_flag=$ac_save_c_werror_flag
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
+$as_echo "$ac_cv_prog_cc_g" >&6; }
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS=$ac_save_CFLAGS
+elif test $ac_cv_prog_cc_g = yes; then
+  if test "$GCC" = yes; then
+    CFLAGS="-g -O2"
+  else
+    CFLAGS="-g"
+  fi
+else
+  if test "$GCC" = yes; then
+    CFLAGS="-O2"
+  else
+    CFLAGS=
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
+$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
+if ${ac_cv_prog_cc_c89+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_cv_prog_cc_c89=no
+ac_save_CC=$CC
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdio.h>
+struct stat;
+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+struct buf { int x; };
+FILE * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+     char **p;
+     int i;
+{
+  return p[i];
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+  char *s;
+  va_list v;
+  va_start (v,p);
+  s = g (p, va_arg (v,int));
+  va_end (v);
+  return s;
+}
+
+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+   function prototypes and stuff, but not '\xHH' hex character constants.
+   These don't provoke an error unfortunately, instead are silently treated
+   as 'x'.  The following induces an error, until -std is added to get
+   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+   array size at least.  It's necessary to write '\x00'==0 to get something
+   that's true only with -std.  */
+int osf4_cc_array ['\x00' == 0 ? 1 : -1];
+
+/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
+   inside strings and character constants.  */
+#define FOO(x) 'x'
+int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
+
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+int argc;
+char **argv;
+int
+main ()
+{
+return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
+  ;
+  return 0;
+}
+_ACEOF
+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
+	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+  CC="$ac_save_CC $ac_arg"
+  if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_c89=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext
+  test "x$ac_cv_prog_cc_c89" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC
+
+fi
+# AC_CACHE_VAL
+case "x$ac_cv_prog_cc_c89" in
+  x)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;;
+  xno)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;;
+  *)
+    CC="$CC $ac_cv_prog_cc_c89"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
+$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
+esac
+if test "x$ac_cv_prog_cc_c89" != xno; then :
+
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+CFLAGS=$user_cflags
+MORECFLAGS=""
+
+# Check whether --enable-largefile was given.
+if test "${enable_largefile+set}" = set; then :
+  enableval=$enable_largefile;
+fi
+
+if test "$enable_largefile" != no; then
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for special C compiler options needed for large files" >&5
+$as_echo_n "checking for special C compiler options needed for large files... " >&6; }
+if ${ac_cv_sys_largefile_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_cv_sys_largefile_CC=no
+     if test "$GCC" != yes; then
+       ac_save_CC=$CC
+       while :; do
+	 # IRIX 6.2 and later do not support large files by default,
+	 # so use the C compiler's -n32 option if that helps.
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <sys/types.h>
+ /* Check that off_t can represent 2**63 - 1 correctly.
+    We can't simply define LARGE_OFF_T to be 9223372036854775807,
+    since some C++ compilers masquerading as C compilers
+    incorrectly reject 9223372036854775807.  */
+#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31))
+  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
+		       && LARGE_OFF_T % 2147483647 == 1)
+		      ? 1 : -1];
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+	 if ac_fn_c_try_compile "$LINENO"; then :
+  break
+fi
+rm -f core conftest.err conftest.$ac_objext
+	 CC="$CC -n32"
+	 if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_sys_largefile_CC=' -n32'; break
+fi
+rm -f core conftest.err conftest.$ac_objext
+	 break
+       done
+       CC=$ac_save_CC
+       rm -f conftest.$ac_ext
+    fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_largefile_CC" >&5
+$as_echo "$ac_cv_sys_largefile_CC" >&6; }
+  if test "$ac_cv_sys_largefile_CC" != no; then
+    CC=$CC$ac_cv_sys_largefile_CC
+  fi
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _FILE_OFFSET_BITS value needed for large files" >&5
+$as_echo_n "checking for _FILE_OFFSET_BITS value needed for large files... " >&6; }
+if ${ac_cv_sys_file_offset_bits+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  while :; do
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <sys/types.h>
+ /* Check that off_t can represent 2**63 - 1 correctly.
+    We can't simply define LARGE_OFF_T to be 9223372036854775807,
+    since some C++ compilers masquerading as C compilers
+    incorrectly reject 9223372036854775807.  */
+#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31))
+  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
+		       && LARGE_OFF_T % 2147483647 == 1)
+		      ? 1 : -1];
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_sys_file_offset_bits=no; break
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#define _FILE_OFFSET_BITS 64
+#include <sys/types.h>
+ /* Check that off_t can represent 2**63 - 1 correctly.
+    We can't simply define LARGE_OFF_T to be 9223372036854775807,
+    since some C++ compilers masquerading as C compilers
+    incorrectly reject 9223372036854775807.  */
+#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31))
+  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
+		       && LARGE_OFF_T % 2147483647 == 1)
+		      ? 1 : -1];
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_sys_file_offset_bits=64; break
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+  ac_cv_sys_file_offset_bits=unknown
+  break
+done
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_file_offset_bits" >&5
+$as_echo "$ac_cv_sys_file_offset_bits" >&6; }
+case $ac_cv_sys_file_offset_bits in #(
+  no | unknown) ;;
+  *)
+cat >>confdefs.h <<_ACEOF
+#define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits
+_ACEOF
+;;
+esac
+rm -rf conftest*
+  if test $ac_cv_sys_file_offset_bits = unknown; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for _LARGE_FILES value needed for large files" >&5
+$as_echo_n "checking for _LARGE_FILES value needed for large files... " >&6; }
+if ${ac_cv_sys_large_files+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  while :; do
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <sys/types.h>
+ /* Check that off_t can represent 2**63 - 1 correctly.
+    We can't simply define LARGE_OFF_T to be 9223372036854775807,
+    since some C++ compilers masquerading as C compilers
+    incorrectly reject 9223372036854775807.  */
+#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31))
+  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
+		       && LARGE_OFF_T % 2147483647 == 1)
+		      ? 1 : -1];
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_sys_large_files=no; break
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#define _LARGE_FILES 1
+#include <sys/types.h>
+ /* Check that off_t can represent 2**63 - 1 correctly.
+    We can't simply define LARGE_OFF_T to be 9223372036854775807,
+    since some C++ compilers masquerading as C compilers
+    incorrectly reject 9223372036854775807.  */
+#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31))
+  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
+		       && LARGE_OFF_T % 2147483647 == 1)
+		      ? 1 : -1];
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_sys_large_files=1; break
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+  ac_cv_sys_large_files=unknown
+  break
+done
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_large_files" >&5
+$as_echo "$ac_cv_sys_large_files" >&6; }
+case $ac_cv_sys_large_files in #(
+  no | unknown) ;;
+  *)
+cat >>confdefs.h <<_ACEOF
+#define _LARGE_FILES $ac_cv_sys_large_files
+_ACEOF
+;;
+esac
+rm -rf conftest*
+  fi
+
+
+fi
+
+if test "x$ac_cv_sys_file_offset_bits" = xno; then :
+  ac_cv_sys_file_offset_bits=0
+fi
+
+
+if test "x$user_cflags" = x || test "x$user_cflags" = x-m32; then :
+
+  if test "$CC" = "icc"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -O3 flags" >&5
+$as_echo_n "checking if $CC supports -O3 flags... " >&6; }
+    SAVE_CFLAGS="$CFLAGS"
+    CFLAGS="-O3"
+    if test "$cross_compiling" = yes; then :
+  ac_cv_try_cflags_ok=no
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+main(){exit(0);}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+  ac_cv_try_cflags_ok=yes
+else
+  ac_cv_try_cflags_ok=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+    CFLAGS="$SAVE_CFLAGS"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_try_cflags_ok" >&5
+$as_echo "$ac_cv_try_cflags_ok" >&6; }
+    if test x"$ac_cv_try_cflags_ok" = x"yes"; then
+        CFLAGS="$CFLAGS -O3"
+    else
+        :
+    fi;
+     if test "x$ac_cv_try_cflags_ok" = xno; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -O2 flags" >&5
+$as_echo_n "checking if $CC supports -O2 flags... " >&6; }
+    SAVE_CFLAGS="$CFLAGS"
+    CFLAGS="-O2"
+    if test "$cross_compiling" = yes; then :
+  ac_cv_try_cflags_ok=no
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+main(){exit(0);}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+  ac_cv_try_cflags_ok=yes
+else
+  ac_cv_try_cflags_ok=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+    CFLAGS="$SAVE_CFLAGS"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_try_cflags_ok" >&5
+$as_echo "$ac_cv_try_cflags_ok" >&6; }
+    if test x"$ac_cv_try_cflags_ok" = x"yes"; then
+        CFLAGS="$CFLAGS -O2"
+    else
+        CFLAGS="$CFLAGS -O"
+    fi
+fi
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -O4 -Werror flags" >&5
+$as_echo_n "checking if $CC supports -O4 -Werror flags... " >&6; }
+    SAVE_CFLAGS="$CFLAGS"
+    CFLAGS="-O4 -Werror"
+    if test "$cross_compiling" = yes; then :
+  ac_cv_try_cflags_ok=no
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+main(){exit(0);}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+  ac_cv_try_cflags_ok=yes
+else
+  ac_cv_try_cflags_ok=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+    CFLAGS="$SAVE_CFLAGS"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_try_cflags_ok" >&5
+$as_echo "$ac_cv_try_cflags_ok" >&6; }
+    if test x"$ac_cv_try_cflags_ok" = x"yes"; then
+        CFLAGS="$CFLAGS -O4"
+    else
+        :
+    fi;
+     if test "x$ac_cv_try_cflags_ok" = xno; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -O3 flags" >&5
+$as_echo_n "checking if $CC supports -O3 flags... " >&6; }
+    SAVE_CFLAGS="$CFLAGS"
+    CFLAGS="-O3"
+    if test "$cross_compiling" = yes; then :
+  ac_cv_try_cflags_ok=no
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+main(){exit(0);}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+  ac_cv_try_cflags_ok=yes
+else
+  ac_cv_try_cflags_ok=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+    CFLAGS="$SAVE_CFLAGS"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_try_cflags_ok" >&5
+$as_echo "$ac_cv_try_cflags_ok" >&6; }
+    if test x"$ac_cv_try_cflags_ok" = x"yes"; then
+        CFLAGS="$CFLAGS -O3"
+    else
+        :
+    fi
+        if test "x$ac_cv_try_cflags_ok" = xno; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -O2 flags" >&5
+$as_echo_n "checking if $CC supports -O2 flags... " >&6; }
+    SAVE_CFLAGS="$CFLAGS"
+    CFLAGS="-O2"
+    if test "$cross_compiling" = yes; then :
+  ac_cv_try_cflags_ok=no
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+main(){exit(0);}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+  ac_cv_try_cflags_ok=yes
+else
+  ac_cv_try_cflags_ok=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+    CFLAGS="$SAVE_CFLAGS"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_try_cflags_ok" >&5
+$as_echo "$ac_cv_try_cflags_ok" >&6; }
+    if test x"$ac_cv_try_cflags_ok" = x"yes"; then
+        CFLAGS="$CFLAGS -O2"
+    else
+        CFLAGS="$CFLAGS -O"
+    fi
+fi
+
+fi
+
+fi
+
+fi
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sys/wait.h that is POSIX.1 compatible" >&5
+$as_echo_n "checking for sys/wait.h that is POSIX.1 compatible... " >&6; }
+if ${ac_cv_header_sys_wait_h+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <sys/types.h>
+#include <sys/wait.h>
+#ifndef WEXITSTATUS
+# define WEXITSTATUS(stat_val) ((unsigned int) (stat_val) >> 8)
+#endif
+#ifndef WIFEXITED
+# define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
+#endif
+
+int
+main ()
+{
+  int s;
+  wait (&s);
+  s = WIFEXITED (s) ? WEXITSTATUS (s) : 1;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_header_sys_wait_h=yes
+else
+  ac_cv_header_sys_wait_h=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_sys_wait_h" >&5
+$as_echo "$ac_cv_header_sys_wait_h" >&6; }
+if test $ac_cv_header_sys_wait_h = yes; then
+
+$as_echo "#define HAVE_SYS_WAIT_H 1" >>confdefs.h
+
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+$as_echo_n "checking how to run the C preprocessor... " >&6; }
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+  CPP=
+fi
+if test -z "$CPP"; then
+  if ${ac_cv_prog_CPP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+      # Double quotes because CPP needs to be expanded
+    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+  break
+fi
+
+    done
+    ac_cv_prog_CPP=$CPP
+
+fi
+  CPP=$ac_cv_prog_CPP
+else
+  ac_cv_prog_CPP=$CPP
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
+$as_echo "$CPP" >&6; }
+ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
+if ${ac_cv_path_GREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$GREP"; then
+  ac_path_GREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in grep ggrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_GREP" || continue
+# Check for GNU ac_path_GREP and select it if it is found.
+  # Check for GNU $ac_path_GREP
+case `"$ac_path_GREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'GREP' >> "conftest.nl"
+    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_GREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_GREP="$ac_path_GREP"
+      ac_path_GREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_GREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_GREP"; then
+    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_GREP=$GREP
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+$as_echo "$ac_cv_path_GREP" >&6; }
+ GREP="$ac_cv_path_GREP"
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
+$as_echo_n "checking for egrep... " >&6; }
+if ${ac_cv_path_EGREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
+   then ac_cv_path_EGREP="$GREP -E"
+   else
+     if test -z "$EGREP"; then
+  ac_path_EGREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in egrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_EGREP" || continue
+# Check for GNU ac_path_EGREP and select it if it is found.
+  # Check for GNU $ac_path_EGREP
+case `"$ac_path_EGREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'EGREP' >> "conftest.nl"
+    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_EGREP="$ac_path_EGREP"
+      ac_path_EGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_EGREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_EGREP"; then
+    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_EGREP=$EGREP
+fi
+
+   fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
+$as_echo "$ac_cv_path_EGREP" >&6; }
+ EGREP="$ac_cv_path_EGREP"
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
+$as_echo_n "checking for ANSI C header files... " >&6; }
+if ${ac_cv_header_stdc+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <float.h>
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_header_stdc=yes
+else
+  ac_cv_header_stdc=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+if test $ac_cv_header_stdc = yes; then
+  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <string.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "memchr" >/dev/null 2>&1; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "free" >/dev/null 2>&1; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
+  if test "$cross_compiling" = yes; then :
+  :
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ctype.h>
+#include <stdlib.h>
+#if ((' ' & 0x0FF) == 0x020)
+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+#else
+# define ISLOWER(c) \
+		   (('a' <= (c) && (c) <= 'i') \
+		     || ('j' <= (c) && (c) <= 'r') \
+		     || ('s' <= (c) && (c) <= 'z'))
+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
+#endif
+
+#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
+int
+main ()
+{
+  int i;
+  for (i = 0; i < 256; i++)
+    if (XOR (islower (i), ISLOWER (i))
+	|| toupper (i) != TOUPPER (i))
+      return 2;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
+$as_echo "$ac_cv_header_stdc" >&6; }
+if test $ac_cv_header_stdc = yes; then
+
+$as_echo "#define STDC_HEADERS 1" >>confdefs.h
+
+fi
+
+# On IRIX 5.3, sys/types and inttypes.h are conflicting.
+for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
+		  inttypes.h stdint.h unistd.h
+do :
+  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
+ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
+"
+if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+
+for ac_header in signal.h stddef.h unistd.h sys/types.h sys/wait.h stdlib.h string.h errno.h pthread.h
+do :
+  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
+ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
+if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+if test x"$ac_cv_header_stddef_h" = x"yes"; then
+header_stddef_h=1
+else
+header_stddef_h=0
+fi
+
+if test x"$ac_cv_header_unistd_h" = x"yes"; then
+header_unistd_h=1
+else
+header_unistd_h=0
+fi
+
+if test x"$ac_cv_header_stdlib_h" = x"yes"; then
+header_stdlib_h=1
+else
+header_stdlib_h=0
+fi
+
+if test x"$ac_cv_header_string_h" = x"yes"; then
+header_string_h=1
+else
+header_string_h=0
+fi
+
+if test x"$ac_cv_header_sys_wait_h" = x"yes"; then
+header_sys_wait_h=1
+else
+header_sys_wait_h=0
+fi
+
+if test x"$ac_cv_header_sys_types_h" = x"yes"; then
+header_sys_types_h=1
+else
+header_sys_types_h=0
+fi
+
+if test x"$ac_cv_header_errno_h" = x"yes"; then
+header_errno_h=1
+else
+header_errno_h=0
+fi
+
+if test x"$ac_cv_header_pthread_h" = x"yes"; then
+header_pthread_h=1
+else
+header_pthread_h=0
+fi
+
+if test x"$ac_cv_header_signal_h" = x"yes"; then
+header_signal_h=1
+else
+header_signal_h=0
+fi
+
+
+ac_fn_c_check_type "$LINENO" "pid_t" "ac_cv_type_pid_t" "$ac_includes_default"
+if test "x$ac_cv_type_pid_t" = xyes; then :
+
+else
+
+cat >>confdefs.h <<_ACEOF
+#define pid_t int
+_ACEOF
+
+fi
+
+if test x"$ac_cv_type_pid_t" = x"yes"; then
+have_pid_t=1
+else
+have_pid_t=0
+fi
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if malloc is declared in stdlib.h or malloc.h" >&5
+$as_echo_n "checking if malloc is declared in stdlib.h or malloc.h... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "(^|[^a-zA-Z_0-9])malloc[^a-zA-Z_0-9]" >/dev/null 2>&1; then :
+  malloc_dec=1
+else
+  malloc_dec=0
+fi
+rm -f conftest*
+
+if test $malloc_dec -eq 0; then
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <malloc.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "(^|[^a-zA-Z_0-9])malloc[^a-zA-Z_0-9]" >/dev/null 2>&1; then :
+  malloc_dec=2
+else
+  malloc_dec=0
+fi
+rm -f conftest*
+
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $malloc_dec" >&5
+$as_echo "$malloc_dec" >&6; }
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if ftell is declared in stdio.h" >&5
+$as_echo_n "checking if ftell is declared in stdio.h... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "(^|[^a-zA-Z_0-9])ftell[^a-zA-Z_0-9]" >/dev/null 2>&1; then :
+  ftell_dec=1
+else
+  ftell_dec=0
+fi
+rm -f conftest*
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ftell_dec" >&5
+$as_echo "$ftell_dec" >&6; }
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if fdopen is declared in stdio.h" >&5
+$as_echo_n "checking if fdopen is declared in stdio.h... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "(^|[^a-zA-Z_0-9])fdopen[^a-zA-Z_0-9]" >/dev/null 2>&1; then :
+  fdopen_dec=1
+else
+  fdopen_dec=0
+fi
+rm -f conftest*
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $fdopen_dec" >&5
+$as_echo "$fdopen_dec" >&6; }
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if popen is declared in stdio.h" >&5
+$as_echo_n "checking if popen is declared in stdio.h... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "(^|[^a-zA-Z_0-9])popen[^a-zA-Z_0-9]" >/dev/null 2>&1; then :
+  popen_dec=1
+else
+  popen_dec=0
+fi
+rm -f conftest*
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $popen_dec" >&5
+$as_echo "$popen_dec" >&6; }
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if putenv is declared in stdlib.h" >&5
+$as_echo_n "checking if putenv is declared in stdlib.h... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "(^|[^a-zA-Z_0-9])putenv[^a-zA-Z_0-9]" >/dev/null 2>&1; then :
+  putenv_dec=1
+else
+  putenv_dec=0
+fi
+rm -f conftest*
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $putenv_dec" >&5
+$as_echo "$putenv_dec" >&6; }
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if setenv is declared in stdlib.h" >&5
+$as_echo_n "checking if setenv is declared in stdlib.h... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "(^|[^a-zA-Z_0-9])setenv[^a-zA-Z_0-9]" >/dev/null 2>&1; then :
+  setenv_dec=1
+else
+  setenv_dec=0
+fi
+rm -f conftest*
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $setenv_dec" >&5
+$as_echo "$setenv_dec" >&6; }
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if INFINITY is declared in math.h" >&5
+$as_echo_n "checking if INFINITY is declared in math.h... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+#include <math.h>
+#ifdef INFINITY
+  yes
+#endif
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "yes" >/dev/null 2>&1; then :
+  has_math_inf=1
+else
+  has_math_inf=0
+fi
+rm -f conftest*
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_math_inf" >&5
+$as_echo "$has_math_inf" >&6; }
+
+# The cast to long int works around a bug in the HP C Compiler
+# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
+# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
+# This bug is HP SR number 8606223364.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int" >&5
+$as_echo_n "checking size of int... " >&6; }
+if ${ac_cv_sizeof_int+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (int))" "ac_cv_sizeof_int"        "$ac_includes_default"; then :
+
+else
+  if test "$ac_cv_type_int" = yes; then
+     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "cannot compute sizeof (int)
+See \`config.log' for more details" "$LINENO" 5; }
+   else
+     ac_cv_sizeof_int=0
+   fi
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int" >&5
+$as_echo "$ac_cv_sizeof_int" >&6; }
+
+
+
+cat >>confdefs.h <<_ACEOF
+#define SIZEOF_INT $ac_cv_sizeof_int
+_ACEOF
+
+
+
+# The cast to long int works around a bug in the HP C Compiler
+# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
+# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
+# This bug is HP SR number 8606223364.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of long" >&5
+$as_echo_n "checking size of long... " >&6; }
+if ${ac_cv_sizeof_long+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (long))" "ac_cv_sizeof_long"        "$ac_includes_default"; then :
+
+else
+  if test "$ac_cv_type_long" = yes; then
+     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "cannot compute sizeof (long)
+See \`config.log' for more details" "$LINENO" 5; }
+   else
+     ac_cv_sizeof_long=0
+   fi
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long" >&5
+$as_echo "$ac_cv_sizeof_long" >&6; }
+
+
+
+cat >>confdefs.h <<_ACEOF
+#define SIZEOF_LONG $ac_cv_sizeof_long
+_ACEOF
+
+
+
+# The cast to long int works around a bug in the HP C Compiler
+# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
+# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
+# This bug is HP SR number 8606223364.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of long long" >&5
+$as_echo_n "checking size of long long... " >&6; }
+if ${ac_cv_sizeof_long_long+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (long long))" "ac_cv_sizeof_long_long"        "$ac_includes_default"; then :
+
+else
+  if test "$ac_cv_type_long_long" = yes; then
+     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "cannot compute sizeof (long long)
+See \`config.log' for more details" "$LINENO" 5; }
+   else
+     ac_cv_sizeof_long_long=0
+   fi
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long_long" >&5
+$as_echo "$ac_cv_sizeof_long_long" >&6; }
+
+
+
+cat >>confdefs.h <<_ACEOF
+#define SIZEOF_LONG_LONG $ac_cv_sizeof_long_long
+_ACEOF
+
+
+
+# The cast to long int works around a bug in the HP C Compiler
+# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
+# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
+# This bug is HP SR number 8606223364.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of __int128_t" >&5
+$as_echo_n "checking size of __int128_t... " >&6; }
+if ${ac_cv_sizeof___int128_t+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (__int128_t))" "ac_cv_sizeof___int128_t"        "$ac_includes_default"; then :
+
+else
+  if test "$ac_cv_type___int128_t" = yes; then
+     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "cannot compute sizeof (__int128_t)
+See \`config.log' for more details" "$LINENO" 5; }
+   else
+     ac_cv_sizeof___int128_t=0
+   fi
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof___int128_t" >&5
+$as_echo "$ac_cv_sizeof___int128_t" >&6; }
+
+
+
+cat >>confdefs.h <<_ACEOF
+#define SIZEOF___INT128_T $ac_cv_sizeof___int128_t
+_ACEOF
+
+
+
+lok=0
+testprogs="dreadtest dreadtestS dreadtestS1 dreadtest4K"
+testprogs="$testprogs dreadtest1 dreadtestW dreadtestW1"
+
+if test $ac_cv_sizeof_long_long -eq 8; then
+   lok=1
+   testprogs="$testprogs dreadtestL1 dreadtestL"
+else
+   if test $ac_cv_sizeof_long -eq 8; then
+      lok=1
+   fi
+fi
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5
+$as_echo_n "checking for an ANSI C-conforming const... " >&6; }
+if ${ac_cv_c_const+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+#ifndef __cplusplus
+  /* Ultrix mips cc rejects this sort of thing.  */
+  typedef int charset[2];
+  const charset cs = { 0, 0 };
+  /* SunOS 4.1.1 cc rejects this.  */
+  char const *const *pcpcc;
+  char **ppc;
+  /* NEC SVR4.0.2 mips cc rejects this.  */
+  struct point {int x, y;};
+  static struct point const zero = {0,0};
+  /* AIX XL C 1.02.0.0 rejects this.
+     It does not let you subtract one const X* pointer from another in
+     an arm of an if-expression whose if-part is not a constant
+     expression */
+  const char *g = "string";
+  pcpcc = &g + (g ? g-g : 0);
+  /* HPUX 7.0 cc rejects these. */
+  ++pcpcc;
+  ppc = (char**) pcpcc;
+  pcpcc = (char const *const *) ppc;
+  { /* SCO 3.2v4 cc rejects this sort of thing.  */
+    char tx;
+    char *t = &tx;
+    char const *s = 0 ? (char *) 0 : (char const *) 0;
+
+    *t++ = 0;
+    if (s) return 0;
+  }
+  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
+    int x[] = {25, 17};
+    const int *foo = &x[0];
+    ++foo;
+  }
+  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
+    typedef const int *iptr;
+    iptr p = 0;
+    ++p;
+  }
+  { /* AIX XL C 1.02.0.0 rejects this sort of thing, saying
+       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
+    struct s { int j; const int *ap[3]; } bx;
+    struct s *b = &bx; b->j = 5;
+  }
+  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
+    const int foo = 10;
+    if (!foo) return 0;
+  }
+  return !cs[0] && !zero.x;
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_c_const=yes
+else
+  ac_cv_c_const=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5
+$as_echo "$ac_cv_c_const" >&6; }
+if test $ac_cv_c_const = no; then
+
+$as_echo "#define const /**/" >>confdefs.h
+
+fi
+
+if test x"$ac_cv_c_const" = x"yes"; then
+have_const=1
+else
+have_const=0
+fi
+
+
+ac_fn_c_check_func "$LINENO" "isatty" "ac_cv_func_isatty"
+if test "x$ac_cv_func_isatty" = xyes; then :
+  have_isatty=1
+else
+  have_isatty=0
+fi
+
+
+ac_fn_c_check_func "$LINENO" "time" "ac_cv_func_time"
+if test "x$ac_cv_func_time" = xyes; then :
+  have_time=1
+else
+  have_time=0
+fi
+
+
+ac_fn_c_check_func "$LINENO" "gettimeofday" "ac_cv_func_gettimeofday"
+if test "x$ac_cv_func_gettimeofday" = xyes; then :
+  have_gettimeofday=1
+else
+  have_gettimeofday=0
+fi
+
+
+ac_fn_c_check_func "$LINENO" "times" "ac_cv_func_times"
+if test "x$ac_cv_func_times" = xyes; then :
+  have_times=1
+else
+  have_times=0
+fi
+
+
+ac_fn_c_check_func "$LINENO" "getrusage" "ac_cv_func_getrusage"
+if test "x$ac_cv_func_getrusage" = xyes; then :
+  have_getrusage=1
+else
+  have_getrusage=0
+fi
+
+
+ac_fn_c_check_func "$LINENO" "perror" "ac_cv_func_perror"
+if test "x$ac_cv_func_perror" = xyes; then :
+  have_perror=1
+else
+  have_perror=0
+fi
+
+
+ac_fn_c_check_func "$LINENO" "pipe" "ac_cv_func_pipe"
+if test "x$ac_cv_func_pipe" = xyes; then :
+  have_pipe=1
+else
+  have_pipe=0
+fi
+
+
+ac_fn_c_check_func "$LINENO" "wait" "ac_cv_func_wait"
+if test "x$ac_cv_func_wait" = xyes; then :
+  have_wait=1
+else
+  have_wait=0
+fi
+
+
+ac_fn_c_check_func "$LINENO" "popen" "ac_cv_func_popen"
+if test "x$ac_cv_func_popen" = xyes; then :
+  have_popen=1
+else
+  have_popen=0
+fi
+
+
+ac_fn_c_check_func "$LINENO" "putenv" "ac_cv_func_putenv"
+if test "x$ac_cv_func_putenv" = xyes; then :
+  have_putenv=1
+else
+  have_putenv=0
+fi
+
+
+ac_fn_c_check_func "$LINENO" "setenv" "ac_cv_func_setenv"
+if test "x$ac_cv_func_setenv" = xyes; then :
+  have_setenv=1
+else
+  have_setenv=0
+fi
+
+
+for ac_header in vfork.h
+do :
+  ac_fn_c_check_header_mongrel "$LINENO" "vfork.h" "ac_cv_header_vfork_h" "$ac_includes_default"
+if test "x$ac_cv_header_vfork_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_VFORK_H 1
+_ACEOF
+
+fi
+
+done
+
+for ac_func in fork vfork
+do :
+  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
+if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+if test "x$ac_cv_func_fork" = xyes; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working fork" >&5
+$as_echo_n "checking for working fork... " >&6; }
+if ${ac_cv_func_fork_works+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test "$cross_compiling" = yes; then :
+  ac_cv_func_fork_works=cross
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$ac_includes_default
+int
+main ()
+{
+
+	  /* By Ruediger Kuhlmann. */
+	  return fork () < 0;
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+  ac_cv_func_fork_works=yes
+else
+  ac_cv_func_fork_works=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_fork_works" >&5
+$as_echo "$ac_cv_func_fork_works" >&6; }
+
+else
+  ac_cv_func_fork_works=$ac_cv_func_fork
+fi
+if test "x$ac_cv_func_fork_works" = xcross; then
+  case $host in
+    *-*-amigaos* | *-*-msdosdjgpp*)
+      # Override, as these systems have only a dummy fork() stub
+      ac_cv_func_fork_works=no
+      ;;
+    *)
+      ac_cv_func_fork_works=yes
+      ;;
+  esac
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: result $ac_cv_func_fork_works guessed because of cross compilation" >&5
+$as_echo "$as_me: WARNING: result $ac_cv_func_fork_works guessed because of cross compilation" >&2;}
+fi
+ac_cv_func_vfork_works=$ac_cv_func_vfork
+if test "x$ac_cv_func_vfork" = xyes; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working vfork" >&5
+$as_echo_n "checking for working vfork... " >&6; }
+if ${ac_cv_func_vfork_works+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test "$cross_compiling" = yes; then :
+  ac_cv_func_vfork_works=cross
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+/* Thanks to Paul Eggert for this test.  */
+$ac_includes_default
+#include <sys/wait.h>
+#ifdef HAVE_VFORK_H
+# include <vfork.h>
+#endif
+/* On some sparc systems, changes by the child to local and incoming
+   argument registers are propagated back to the parent.  The compiler
+   is told about this with #include <vfork.h>, but some compilers
+   (e.g. gcc -O) don't grok <vfork.h>.  Test for this by using a
+   static variable whose address is put into a register that is
+   clobbered by the vfork.  */
+static void
+#ifdef __cplusplus
+sparc_address_test (int arg)
+# else
+sparc_address_test (arg) int arg;
+#endif
+{
+  static pid_t child;
+  if (!child) {
+    child = vfork ();
+    if (child < 0) {
+      perror ("vfork");
+      _exit(2);
+    }
+    if (!child) {
+      arg = getpid();
+      write(-1, "", 0);
+      _exit (arg);
+    }
+  }
+}
+
+int
+main ()
+{
+  pid_t parent = getpid ();
+  pid_t child;
+
+  sparc_address_test (0);
+
+  child = vfork ();
+
+  if (child == 0) {
+    /* Here is another test for sparc vfork register problems.  This
+       test uses lots of local variables, at least as many local
+       variables as main has allocated so far including compiler
+       temporaries.  4 locals are enough for gcc 1.40.3 on a Solaris
+       4.1.3 sparc, but we use 8 to be safe.  A buggy compiler should
+       reuse the register of parent for one of the local variables,
+       since it will think that parent can't possibly be used any more
+       in this routine.  Assigning to the local variable will thus
+       munge parent in the parent process.  */
+    pid_t
+      p = getpid(), p1 = getpid(), p2 = getpid(), p3 = getpid(),
+      p4 = getpid(), p5 = getpid(), p6 = getpid(), p7 = getpid();
+    /* Convince the compiler that p..p7 are live; otherwise, it might
+       use the same hardware register for all 8 local variables.  */
+    if (p != p1 || p != p2 || p != p3 || p != p4
+	|| p != p5 || p != p6 || p != p7)
+      _exit(1);
+
+    /* On some systems (e.g. IRIX 3.3), vfork doesn't separate parent
+       from child file descriptors.  If the child closes a descriptor
+       before it execs or exits, this munges the parent's descriptor
+       as well.  Test for this by closing stdout in the child.  */
+    _exit(close(fileno(stdout)) != 0);
+  } else {
+    int status;
+    struct stat st;
+
+    while (wait(&status) != child)
+      ;
+    return (
+	 /* Was there some problem with vforking?  */
+	 child < 0
+
+	 /* Did the child fail?  (This shouldn't happen.)  */
+	 || status
+
+	 /* Did the vfork/compiler bug occur?  */
+	 || parent != getpid()
+
+	 /* Did the file descriptor bug occur?  */
+	 || fstat(fileno(stdout), &st) != 0
+	 );
+  }
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+  ac_cv_func_vfork_works=yes
+else
+  ac_cv_func_vfork_works=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_vfork_works" >&5
+$as_echo "$ac_cv_func_vfork_works" >&6; }
+
+fi;
+if test "x$ac_cv_func_fork_works" = xcross; then
+  ac_cv_func_vfork_works=$ac_cv_func_vfork
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: result $ac_cv_func_vfork_works guessed because of cross compilation" >&5
+$as_echo "$as_me: WARNING: result $ac_cv_func_vfork_works guessed because of cross compilation" >&2;}
+fi
+
+if test "x$ac_cv_func_vfork_works" = xyes; then
+
+$as_echo "#define HAVE_WORKING_VFORK 1" >>confdefs.h
+
+else
+
+$as_echo "#define vfork fork" >>confdefs.h
+
+fi
+if test "x$ac_cv_func_fork_works" = xyes; then
+
+$as_echo "#define HAVE_WORKING_FORK 1" >>confdefs.h
+
+fi
+
+if test x"$ac_cv_func_fork" = x"yes"; then
+have_fork=1
+else
+have_fork=0
+fi
+
+
+ac_fn_c_check_func "$LINENO" "fseeko" "ac_cv_func_fseeko"
+if test "x$ac_cv_func_fseeko" = xyes; then :
+  have_fseeko=1
+else
+  have_fseeko=0
+fi
+
+
+ac_fn_c_check_func "$LINENO" "sigaction" "ac_cv_func_sigaction"
+if test "x$ac_cv_func_sigaction" = xyes; then :
+  have_sigaction=1
+else
+  have_sigaction=0
+fi
+
+
+ac_fn_c_check_func "$LINENO" "sigprocmask" "ac_cv_func_sigprocmask"
+if test "x$ac_cv_func_sigprocmask" = xyes; then :
+  have_sigprocmask=1
+else
+  have_sigprocmask=0
+fi
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if popcnt instruction is available and requested" >&5
+$as_echo_n "checking if popcnt instruction is available and requested... " >&6; }
+# Check whether --enable-popcnt was given.
+if test "${enable_popcnt+set}" = set; then :
+  enableval=$enable_popcnt; popcntarg=given
+else
+  popcntarg=notgiven
+fi
+
+if test "x$popcntarg" = "xnotgiven" -o "x$enable_popcnt" = "xyes"; then :
+
+have_hwpopcnt=0
+test -e /proc/cpuinfo && grep -i popcnt /proc/cpuinfo >/dev/null && have_hwpopcnt=1
+test $have_hwpopcnt -eq 0 && sysctl machdep.cpu.features 2>/dev/null | grep -i popcnt >/dev/null && have_hwpopcnt=1
+test $have_hwpopcnt -eq 0 && isainfo -x -v 2>/dev/null | grep -i popc >/dev/null && have_hwpopcnt=1
+
+else
+
+have_hwpopcnt=0
+
+fi
+test $is_powerpc -eq 1 && have_hwpopcnt=0
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_hwpopcnt" >&5
+$as_echo "$have_hwpopcnt" >&6; }
+
+
+SAVE_CFLAGS="$CFLAGS"
+have_popcnt=0
+have_popcntl=0
+have_popcntll=0
+have_mmpop32=0
+have_mmpop64=0
+
+if test $have_hwpopcnt -eq 1; then :
+
+if test "$CC" = "icc"; then :
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if _mm_popcnt_u32() is supported" >&5
+$as_echo_n "checking if _mm_popcnt_u32() is supported... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <nmmintrin.h>
+main(){unsigned int x; x = _mm_popcnt_u32(x);}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  have_mmpop32=1
+else
+  have_mmpop32=0
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_mmpop32" >&5
+$as_echo "$have_mmpop32" >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if _mm_popcnt_u64() is supported" >&5
+$as_echo_n "checking if _mm_popcnt_u64() is supported... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <nmmintrin.h>
+main(){unsigned int x; x = _mm_popcnt_u64(x);}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  have_mmpop64=1
+else
+  have_mmpop64=0
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_mmpop64" >&5
+$as_echo "$have_mmpop64" >&6; }
+
+else
+
+CFLAGS="$CFLAGS -mpopcnt"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if __builtin_popcount() is supported" >&5
+$as_echo_n "checking if __builtin_popcount() is supported... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+main(){unsigned int x; x = __builtin_popcount(x);}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  have_popcnt=1
+else
+  have_popcnt=0
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_popcnt" >&5
+$as_echo "$have_popcnt" >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if __builtin_popcountl() is supported" >&5
+$as_echo_n "checking if __builtin_popcountl() is supported... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+main(){unsigned long x; x = __builtin_popcountl(x);}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  have_popcntl=1
+else
+  have_popcntl=0
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_popcntl" >&5
+$as_echo "$have_popcntl" >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if __builtin_popcountll() is supported" >&5
+$as_echo_n "checking if __builtin_popcountll() is supported... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+main(){unsigned long long x; x = __builtin_popcountll(x);}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  have_popcntll=1
+else
+  have_popcntll=0
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_popcntll" >&5
+$as_echo "$have_popcntll" >&6; }
+if test $have_popcnt -eq 1 -o $have_popcntl -eq 1 -o $have_popcntll -eq 1; then :
+  MORECFLAGS="$MORECFLAGS -mpopcnt"
+fi
+
+fi
+fi
+CFLAGS="$SAVE_CFLAGS"
+
+
+
+
+
+
+
+
+# Check whether --enable-clz was given.
+if test "${enable_clz+set}" = set; then :
+  enableval=$enable_clz; clzarg=given
+else
+  clzarg=notgiven
+fi
+
+if test "x$clzarg" = "xnotgiven" -o "x$enable_clz" = "xyes"; then :
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if __builtin_clz() is supported" >&5
+$as_echo_n "checking if __builtin_clz() is supported... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+main(){unsigned int x; x = __builtin_clz(x);}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  have_clz=1
+else
+  have_clz=0
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_clz" >&5
+$as_echo "$have_clz" >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if __builtin_clzl() is supported" >&5
+$as_echo_n "checking if __builtin_clzl() is supported... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+main(){unsigned long x; x = __builtin_clzl(x);}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  have_clzl=1
+else
+  have_clzl=0
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_clzl" >&5
+$as_echo "$have_clzl" >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if __builtin_clzll() is supported" >&5
+$as_echo_n "checking if __builtin_clzll() is supported... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+main(){unsigned long long x; x = __builtin_clzll(x);}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  have_clzll=1
+else
+  have_clzll=0
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_clzll" >&5
+$as_echo "$have_clzll" >&6; }
+
+else
+
+have_clz=0
+have_clzl=0
+have_clzll=0
+
+fi
+
+
+
+
+ac_fn_c_check_func "$LINENO" "pthread_create" "ac_cv_func_pthread_create"
+if test "x$ac_cv_func_pthread_create" = xyes; then :
+  have_pthread=1
+else
+  have_pthread=0
+fi
+
+if test $have_pthread -eq 1; then :
+  threadlib=
+else
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pthread_create in -lpthread" >&5
+$as_echo_n "checking for pthread_create in -lpthread... " >&6; }
+if ${ac_cv_lib_pthread_pthread_create+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lpthread  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char pthread_create ();
+int
+main ()
+{
+return pthread_create ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_pthread_pthread_create=yes
+else
+  ac_cv_lib_pthread_pthread_create=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_create" >&5
+$as_echo "$ac_cv_lib_pthread_pthread_create" >&6; }
+if test "x$ac_cv_lib_pthread_pthread_create" = xyes; then :
+  have_pthread=1
+else
+  have_pthread=0
+fi
+
+    if test $have_pthread -eq 1; then :
+  threadlib=-lpthread
+else
+  threadlib=
+fi
+
+fi
+
+if test $have_pipe -eq 1 -a $have_wait -eq 1 -a $have_fork -eq 1 ; then
+    shortg=1
+    shortg_or_null=shortg
+else
+    shortg=0
+    shortg_or_null=
+fi
+
+
+
+
+
+ac_fn_c_check_func "$LINENO" "getc_unlocked" "ac_cv_func_getc_unlocked"
+if test "x$ac_cv_func_getc_unlocked" = xyes; then :
+  have_getc_unlocked=1
+else
+  have_getc_unlocked=0
+fi
+
+ac_fn_c_check_func "$LINENO" "flockfile" "ac_cv_func_flockfile"
+if test "x$ac_cv_func_flockfile" = xyes; then :
+  have_flockfile=1
+else
+  have_flockfile=0
+fi
+
+if test $have_getc_unlocked -eq 1 -a $have_flockfile -eq 1 ; then
+    stdio_nolock=1
+else
+    stdio_nolock=0
+fi
+
+
+# Check whether --enable-tls was given.
+if test "${enable_tls+set}" = set; then :
+  enableval=$enable_tls;
+fi
+
+if test "x$enable_tls" = "xyes"; then :
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for thread local storage (TLS) class" >&5
+$as_echo_n "checking for thread local storage (TLS) class... " >&6; }
+  if ${ac_cv_tls+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+
+    ax_tls_keywords="__thread __declspec(thread) none"
+    for ax_tls_keyword in $ax_tls_keywords; do
+       case $ax_tls_keyword in #(
+  none) :
+    ac_cv_tls=none ; break ;; #(
+  *) :
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+               static void
+               foo(void) {
+               static  $ax_tls_keyword  int bar;
+               exit(1);
+               }
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_tls=$ax_tls_keyword ; break
+else
+  ac_cv_tls=none
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ;;
+esac
+    done
+
+fi
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_tls" >&5
+$as_echo "$ac_cv_tls" >&6; }
+
+  if test "$ac_cv_tls" != "none"; then :
+
+cat >>confdefs.h <<_ACEOF
+#define TLS $ac_cv_tls
+_ACEOF
+
+      have_tls=1
+else
+  have_tls=0
+
+fi
+
+
+else
+  have_tls=0
+fi
+
+if test "$have_tls" -eq 0 ; then
+    ac_cv_tls=
+fi
+
+
+
+# Check whether --enable-wordsize was given.
+if test "${enable_wordsize+set}" = set; then :
+  enableval=$enable_wordsize;
+fi
+
+if test "x$enable_wordsize" = "x16"; then :
+  default_wordsize=16
+else
+  default_wordsize=0
+fi
+if test "x$enable_wordsize" = "x32"; then :
+  default_wordsize=32
+fi
+if test "x$enable_wordsize" = "x64"; then :
+  default_wordsize=64
+fi
+
+
+# Check whether --enable-ansicontrols was given.
+if test "${enable_ansicontrols+set}" = set; then :
+  enableval=$enable_ansicontrols;
+fi
+
+if test "x$enable_ansicontrols" = "xyes"; then :
+  have_ansicontrols=1
+else
+  have_ansicontrols=0
+fi
+
+
+# Check whether --enable-interrupt was given.
+if test "${enable_interrupt+set}" = set; then :
+  enableval=$enable_interrupt; intarg=given
+else
+  intarg=notgiven
+fi
+
+if test "x$intarg" = "xnotgiven" -o "x$enable_interrupt" = "xyes"; then :
+  allow_interrupt=1
+else
+  allow_interrupt=0
+fi
+
+
+case "$build" in
+   *cygwin*)
+       for ac_prog in gsort sort
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_path_sort_prog+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  case $sort_prog in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_sort_prog="$sort_prog" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in /usr/bin$PATH_SEPARATOR/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_path_sort_prog="$as_dir/$ac_word$ac_exec_ext"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+  ;;
+esac
+fi
+sort_prog=$ac_cv_path_sort_prog
+if test -n "$sort_prog"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $sort_prog" >&5
+$as_echo "$sort_prog" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$sort_prog" && break
+done
+test -n "$sort_prog" || sort_prog="no_sort_found"
+ ;;
+   *)
+       for ac_prog in gsort sort
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_sort_prog+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$sort_prog"; then
+  ac_cv_prog_sort_prog="$sort_prog" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_sort_prog="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+sort_prog=$ac_cv_prog_sort_prog
+if test -n "$sort_prog"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $sort_prog" >&5
+$as_echo "$sort_prog" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$sort_prog" && break
+done
+test -n "$sort_prog" || sort_prog="no_sort_found"
+ ;;
+esac
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if sort supports the -k switch" >&5
+$as_echo_n "checking if sort supports the -k switch... " >&6; }
+if { $sort_prog -k "2,3" </dev/null >/dev/null 2>&1 ; } ; then
+   sort_newparams_ok=1
+else
+   sort_newparams_ok=0
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $sort_newparams_ok" >&5
+$as_echo "$sort_newparams_ok" >&6; }
+
+edit_msg="++++++ This file is automatically generated, don't edit it by hand! ++++++"
+
+
+echo CFLAGS=$CFLAGS
+echo MORECFLAGS=$MORECFLAGS
+
+ac_config_files="$ac_config_files makefile:makefile.in nauty.h:nauty-h.in naututil.h:naututil-h.in gtools.h:gtools-h.in"
+
+cat >confcache <<\_ACEOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs, see configure's option --config-cache.
+# It is not useful on other systems.  If it contains results you don't
+# want to keep, you may remove or edit it.
+#
+# config.status only pays attention to the cache file if you give it
+# the --recheck option to rerun configure.
+#
+# `ac_cv_env_foo' variables (set or unset) will be overridden when
+# loading this file, other *unset* `ac_cv_foo' will be assigned the
+# following values.
+
+_ACEOF
+
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, we kill variables containing newlines.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+(
+  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+
+  (set) 2>&1 |
+    case $as_nl`(ac_space=' '; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      # `set' does not quote correctly, so add quotes: double-quote
+      # substitution turns \\\\ into \\, and sed turns \\ into \.
+      sed -n \
+	"s/'/'\\\\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+      ;; #(
+    *)
+      # `set' quotes correctly as required by POSIX, so do not add quotes.
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+) |
+  sed '
+     /^ac_cv_env_/b end
+     t clear
+     :clear
+     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+     t end
+     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+     :end' >>confcache
+if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
+  if test -w "$cache_file"; then
+    if test "x$cache_file" != "x/dev/null"; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
+$as_echo "$as_me: updating cache $cache_file" >&6;}
+      if test ! -f "$cache_file" || test -h "$cache_file"; then
+	cat confcache >"$cache_file"
+      else
+        case $cache_file in #(
+        */* | ?:*)
+	  mv -f confcache "$cache_file"$$ &&
+	  mv -f "$cache_file"$$ "$cache_file" ;; #(
+        *)
+	  mv -f confcache "$cache_file" ;;
+	esac
+      fi
+    fi
+  else
+    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
+$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+  fi
+fi
+rm -f confcache
+
+test "x$prefix" = xNONE && prefix=$ac_default_prefix
+# Let make expand exec_prefix.
+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+
+# Transform confdefs.h into DEFS.
+# Protect against shell expansion while executing Makefile rules.
+# Protect against Makefile macro expansion.
+#
+# If the first sed substitution is executed (which looks for macros that
+# take arguments), then branch to the quote section.  Otherwise,
+# look for a macro that doesn't take arguments.
+ac_script='
+:mline
+/\\$/{
+ N
+ s,\\\n,,
+ b mline
+}
+t clear
+:clear
+s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 (][^	 (]*([^)]*)\)[	 ]*\(.*\)/-D\1=\2/g
+t quote
+s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 ][^	 ]*\)[	 ]*\(.*\)/-D\1=\2/g
+t quote
+b any
+:quote
+s/[	 `~#$^&*(){}\\|;'\''"<>?]/\\&/g
+s/\[/\\&/g
+s/\]/\\&/g
+s/\$/$$/g
+H
+:any
+${
+	g
+	s/^\n//
+	s/\n/ /g
+	p
+}
+'
+DEFS=`sed -n "$ac_script" confdefs.h`
+
+
+ac_libobjs=
+ac_ltlibobjs=
+U=
+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+  # 1. Remove the extension, and $U if already installed.
+  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
+  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
+  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
+  #    will be set to the directory where LIBOBJS objects are built.
+  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
+  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
+done
+LIBOBJS=$ac_libobjs
+
+LTLIBOBJS=$ac_ltlibobjs
+
+
+
+: "${CONFIG_STATUS=./config.status}"
+ac_write_fail=0
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files $CONFIG_STATUS"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
+$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
+as_write_fail=0
+cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
+#! $SHELL
+# Generated by $as_me.
+# Run this file to recreate the current configuration.
+# Compiler output produced by configure, useful for debugging
+# configure, is in config.log if it exists.
+
+debug=false
+ac_cs_recheck=false
+ac_cs_silent=false
+
+SHELL=\${CONFIG_SHELL-$SHELL}
+export SHELL
+_ASEOF
+cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\\(.*\\)$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+      esac;
+      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  $as_echo "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
+  fi
+else
+  as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+exec 6>&1
+## ----------------------------------- ##
+## Main body of $CONFIG_STATUS script. ##
+## ----------------------------------- ##
+_ASEOF
+test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# Save the log message, to keep $0 and so on meaningful, and to
+# report actual input values of CONFIG_FILES etc. instead of their
+# values after options handling.
+ac_log="
+This file was extended by $as_me, which was
+generated by GNU Autoconf 2.69.  Invocation command line was
+
+  CONFIG_FILES    = $CONFIG_FILES
+  CONFIG_HEADERS  = $CONFIG_HEADERS
+  CONFIG_LINKS    = $CONFIG_LINKS
+  CONFIG_COMMANDS = $CONFIG_COMMANDS
+  $ $0 $@
+
+on `(hostname || uname -n) 2>/dev/null | sed 1q`
+"
+
+_ACEOF
+
+case $ac_config_files in *"
+"*) set x $ac_config_files; shift; ac_config_files=$*;;
+esac
+
+
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+# Files that config.status was made for.
+config_files="$ac_config_files"
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+ac_cs_usage="\
+\`$as_me' instantiates files and other configuration actions
+from templates according to the current configuration.  Unless the files
+and actions are specified as TAGs, all are instantiated by default.
+
+Usage: $0 [OPTION]... [TAG]...
+
+  -h, --help       print this help, then exit
+  -V, --version    print version number and configuration settings, then exit
+      --config     print configuration, then exit
+  -q, --quiet, --silent
+                   do not print progress messages
+  -d, --debug      don't remove temporary files
+      --recheck    update $as_me by reconfiguring in the same conditions
+      --file=FILE[:TEMPLATE]
+                   instantiate the configuration file FILE
+
+Configuration files:
+$config_files
+
+Report bugs to the package provider."
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
+ac_cs_version="\\
+config.status
+configured by $0, generated by GNU Autoconf 2.69,
+  with options \\"\$ac_cs_config\\"
+
+Copyright (C) 2012 Free Software Foundation, Inc.
+This config.status script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it."
+
+ac_pwd='$ac_pwd'
+srcdir='$srcdir'
+test -n "\$AWK" || AWK=awk
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# The default lists apply if the user does not specify any file.
+ac_need_defaults=:
+while test $# != 0
+do
+  case $1 in
+  --*=?*)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
+    ac_shift=:
+    ;;
+  --*=)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=
+    ac_shift=:
+    ;;
+  *)
+    ac_option=$1
+    ac_optarg=$2
+    ac_shift=shift
+    ;;
+  esac
+
+  case $ac_option in
+  # Handling of the options.
+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+    ac_cs_recheck=: ;;
+  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
+    $as_echo "$ac_cs_version"; exit ;;
+  --config | --confi | --conf | --con | --co | --c )
+    $as_echo "$ac_cs_config"; exit ;;
+  --debug | --debu | --deb | --de | --d | -d )
+    debug=: ;;
+  --file | --fil | --fi | --f )
+    $ac_shift
+    case $ac_optarg in
+    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    '') as_fn_error $? "missing file argument" ;;
+    esac
+    as_fn_append CONFIG_FILES " '$ac_optarg'"
+    ac_need_defaults=false;;
+  --he | --h |  --help | --hel | -h )
+    $as_echo "$ac_cs_usage"; exit ;;
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil | --si | --s)
+    ac_cs_silent=: ;;
+
+  # This is an error.
+  -*) as_fn_error $? "unrecognized option: \`$1'
+Try \`$0 --help' for more information." ;;
+
+  *) as_fn_append ac_config_targets " $1"
+     ac_need_defaults=false ;;
+
+  esac
+  shift
+done
+
+ac_configure_extra_args=
+
+if $ac_cs_silent; then
+  exec 6>/dev/null
+  ac_configure_extra_args="$ac_configure_extra_args --silent"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+if \$ac_cs_recheck; then
+  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+  shift
+  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
+  CONFIG_SHELL='$SHELL'
+  export CONFIG_SHELL
+  exec "\$@"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+exec 5>>config.log
+{
+  echo
+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+  $as_echo "$ac_log"
+} >&5
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+
+# Handling of arguments.
+for ac_config_target in $ac_config_targets
+do
+  case $ac_config_target in
+    "makefile") CONFIG_FILES="$CONFIG_FILES makefile:makefile.in" ;;
+    "nauty.h") CONFIG_FILES="$CONFIG_FILES nauty.h:nauty-h.in" ;;
+    "naututil.h") CONFIG_FILES="$CONFIG_FILES naututil.h:naututil-h.in" ;;
+    "gtools.h") CONFIG_FILES="$CONFIG_FILES gtools.h:gtools-h.in" ;;
+
+  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
+  esac
+done
+
+
+# If the user did not use the arguments to specify the items to instantiate,
+# then the envvar interface is used.  Set only those that are not.
+# We use the long form for the default assignment because of an extremely
+# bizarre bug on SunOS 4.1.3.
+if $ac_need_defaults; then
+  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+fi
+
+# Have a temporary directory for convenience.  Make it in the build tree
+# simply because there is no reason against having it here, and in addition,
+# creating and moving files from /tmp can sometimes cause problems.
+# Hook for its removal unless debugging.
+# Note that there is a small window in which the directory will not be cleaned:
+# after its creation but before its name has been assigned to `$tmp'.
+$debug ||
+{
+  tmp= ac_tmp=
+  trap 'exit_status=$?
+  : "${ac_tmp:=$tmp}"
+  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
+' 0
+  trap 'as_fn_exit 1' 1 2 13 15
+}
+# Create a (secure) tmp directory for tmp files.
+
+{
+  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+  test -d "$tmp"
+}  ||
+{
+  tmp=./conf$$-$RANDOM
+  (umask 077 && mkdir "$tmp")
+} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
+ac_tmp=$tmp
+
+# Set up the scripts for CONFIG_FILES section.
+# No need to generate them if there are no CONFIG_FILES.
+# This happens for instance with `./config.status config.h'.
+if test -n "$CONFIG_FILES"; then
+
+
+ac_cr=`echo X | tr X '\015'`
+# On cygwin, bash can eat \r inside `` if the user requested igncr.
+# But we know of no other shell where ac_cr would be empty at this
+# point, so we can use a bashism as a fallback.
+if test "x$ac_cr" = x; then
+  eval ac_cr=\$\'\\r\'
+fi
+ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
+if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
+  ac_cs_awk_cr='\\r'
+else
+  ac_cs_awk_cr=$ac_cr
+fi
+
+echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
+_ACEOF
+
+
+{
+  echo "cat >conf$$subs.awk <<_ACEOF" &&
+  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
+  echo "_ACEOF"
+} >conf$$subs.sh ||
+  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
+ac_delim='%!_!# '
+for ac_last_try in false false false false false :; do
+  . ./conf$$subs.sh ||
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+
+  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
+  if test $ac_delim_n = $ac_delim_num; then
+    break
+  elif $ac_last_try; then
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+rm -f conf$$subs.sh
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
+_ACEOF
+sed -n '
+h
+s/^/S["/; s/!.*/"]=/
+p
+g
+s/^[^!]*!//
+:repl
+t repl
+s/'"$ac_delim"'$//
+t delim
+:nl
+h
+s/\(.\{148\}\)..*/\1/
+t more1
+s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
+p
+n
+b repl
+:more1
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t nl
+:delim
+h
+s/\(.\{148\}\)..*/\1/
+t more2
+s/["\\]/\\&/g; s/^/"/; s/$/"/
+p
+b
+:more2
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t delim
+' <conf$$subs.awk | sed '
+/^[^""]/{
+  N
+  s/\n//
+}
+' >>$CONFIG_STATUS || ac_write_fail=1
+rm -f conf$$subs.awk
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+_ACAWK
+cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
+  for (key in S) S_is_set[key] = 1
+  FS = ""
+
+}
+{
+  line = $ 0
+  nfields = split(line, field, "@")
+  substed = 0
+  len = length(field[1])
+  for (i = 2; i < nfields; i++) {
+    key = field[i]
+    keylen = length(key)
+    if (S_is_set[key]) {
+      value = S[key]
+      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
+      len += length(value) + length(field[++i])
+      substed = 1
+    } else
+      len += 1 + keylen
+  }
+
+  print line
+}
+
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
+  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
+else
+  cat
+fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
+  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
+_ACEOF
+
+# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
+# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
+# trailing colons and then remove the whole line if VPATH becomes empty
+# (actually we leave an empty line to preserve line numbers).
+if test "x$srcdir" = x.; then
+  ac_vpsub='/^[	 ]*VPATH[	 ]*=[	 ]*/{
+h
+s///
+s/^/:/
+s/[	 ]*$/:/
+s/:\$(srcdir):/:/g
+s/:\${srcdir}:/:/g
+s/:@srcdir@:/:/g
+s/^:*//
+s/:*$//
+x
+s/\(=[	 ]*\).*/\1/
+G
+s/\n//
+s/^[^=]*=[	 ]*$//
+}'
+fi
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+fi # test -n "$CONFIG_FILES"
+
+
+eval set X "  :F $CONFIG_FILES      "
+shift
+for ac_tag
+do
+  case $ac_tag in
+  :[FHLC]) ac_mode=$ac_tag; continue;;
+  esac
+  case $ac_mode$ac_tag in
+  :[FHL]*:*);;
+  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
+  :[FH]-) ac_tag=-:-;;
+  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
+  esac
+  ac_save_IFS=$IFS
+  IFS=:
+  set x $ac_tag
+  IFS=$ac_save_IFS
+  shift
+  ac_file=$1
+  shift
+
+  case $ac_mode in
+  :L) ac_source=$1;;
+  :[FH])
+    ac_file_inputs=
+    for ac_f
+    do
+      case $ac_f in
+      -) ac_f="$ac_tmp/stdin";;
+      *) # Look for the file first in the build tree, then in the source tree
+	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
+	 # because $ac_f cannot contain `:'.
+	 test -f "$ac_f" ||
+	   case $ac_f in
+	   [\\/$]*) false;;
+	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
+	   esac ||
+	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
+      esac
+      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
+      as_fn_append ac_file_inputs " '$ac_f'"
+    done
+
+    # Let's still pretend it is `configure' which instantiates (i.e., don't
+    # use $as_me), people would be surprised to read:
+    #    /* config.h.  Generated by config.status.  */
+    configure_input='Generated from '`
+	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
+	`' by configure.'
+    if test x"$ac_file" != x-; then
+      configure_input="$ac_file.  $configure_input"
+      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
+$as_echo "$as_me: creating $ac_file" >&6;}
+    fi
+    # Neutralize special characters interpreted by sed in replacement strings.
+    case $configure_input in #(
+    *\&* | *\|* | *\\* )
+       ac_sed_conf_input=`$as_echo "$configure_input" |
+       sed 's/[\\\\&|]/\\\\&/g'`;; #(
+    *) ac_sed_conf_input=$configure_input;;
+    esac
+
+    case $ac_tag in
+    *:-:* | *:-) cat >"$ac_tmp/stdin" \
+      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
+    esac
+    ;;
+  esac
+
+  ac_dir=`$as_dirname -- "$ac_file" ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$ac_file" : 'X\(//\)[^/]' \| \
+	 X"$ac_file" : 'X\(//\)$' \| \
+	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$ac_file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  as_dir="$ac_dir"; as_fn_mkdir_p
+  ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+
+  case $ac_mode in
+  :F)
+  #
+  # CONFIG_FILE
+  #
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# If the template does not know about datarootdir, expand it.
+# FIXME: This hack should be removed a few years after 2.60.
+ac_datarootdir_hack=; ac_datarootdir_seen=
+ac_sed_dataroot='
+/datarootdir/ {
+  p
+  q
+}
+/@datadir@/p
+/@docdir@/p
+/@infodir@/p
+/@localedir@/p
+/@mandir@/p'
+case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
+*datarootdir*) ac_datarootdir_seen=yes;;
+*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
+$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  ac_datarootdir_hack='
+  s&@datadir@&$datadir&g
+  s&@docdir@&$docdir&g
+  s&@infodir@&$infodir&g
+  s&@localedir@&$localedir&g
+  s&@mandir@&$mandir&g
+  s&\\\${datarootdir}&$datarootdir&g' ;;
+esac
+_ACEOF
+
+# Neutralize VPATH when `$srcdir' = `.'.
+# Shell code in configure.ac might set extrasub.
+# FIXME: do we really want to maintain this feature?
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_sed_extra="$ac_vpsub
+$extrasub
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+:t
+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+s|@configure_input@|$ac_sed_conf_input|;t t
+s&@top_builddir@&$ac_top_builddir_sub&;t t
+s&@top_build_prefix@&$ac_top_build_prefix&;t t
+s&@srcdir@&$ac_srcdir&;t t
+s&@abs_srcdir@&$ac_abs_srcdir&;t t
+s&@top_srcdir@&$ac_top_srcdir&;t t
+s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
+s&@builddir@&$ac_builddir&;t t
+s&@abs_builddir@&$ac_abs_builddir&;t t
+s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
+$ac_datarootdir_hack
+"
+eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
+  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+
+test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
+  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
+  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
+      "$ac_tmp/out"`; test -z "$ac_out"; } &&
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&5
+$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&2;}
+
+  rm -f "$ac_tmp/stdin"
+  case $ac_file in
+  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
+  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
+  esac \
+  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+ ;;
+
+
+
+  esac
+
+done # for ac_tag
+
+
+as_fn_exit 0
+_ACEOF
+ac_clean_files=$ac_clean_files_save
+
+test $ac_write_fail = 0 ||
+  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
+
+
+# configure is writing to config.log, and then calls config.status.
+# config.status does its own redirection, appending to config.log.
+# Unfortunately, on DOS this fails, as config.log is still kept open
+# by configure, so config.status won't be able to write to it; its
+# output is simply discarded.  So we exec the FD to /dev/null,
+# effectively closing config.log, so it can be properly (re)opened and
+# appended to by config.status.  When coming back to configure, we
+# need to make the FD available again.
+if test "$no_create" != yes; then
+  ac_cs_success=:
+  ac_config_status_args=
+  test "$silent" = yes &&
+    ac_config_status_args="$ac_config_status_args --quiet"
+  exec 5>/dev/null
+  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
+  exec 5>>config.log
+  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
+  # would make configure fail if this is the last instruction.
+  $ac_cs_success || as_fn_exit 1
+fi
+if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
+$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
+fi
+
+
diff --git a/lib/nauty/configure.ac b/lib/nauty/configure.ac
new file mode 100644
index 0000000..d2e1209
--- /dev/null
+++ b/lib/nauty/configure.ac
@@ -0,0 +1,405 @@
+dnl Process this file with autoconf to produce a configure script.
+AC_INIT(nauty-h.in)
+
+AC_DEFUN([AX_TLS], [
+  AC_MSG_CHECKING(for thread local storage (TLS) class)
+  AC_CACHE_VAL(ac_cv_tls, [
+    ax_tls_keywords="__thread __declspec(thread) none"
+    for ax_tls_keyword in $ax_tls_keywords; do
+       AS_CASE([$ax_tls_keyword],
+          [none], [ac_cv_tls=none ; break],
+          [AC_TRY_COMPILE(
+              [#include <stdlib.h>
+               static void
+               foo(void) {
+               static ] $ax_tls_keyword [ int bar;
+               exit(1);
+               }],
+               [],
+               [ac_cv_tls=$ax_tls_keyword ; break],
+               ac_cv_tls=none
+           )])
+    done
+  ])
+  AC_MSG_RESULT($ac_cv_tls)
+
+  AS_IF([test "$ac_cv_tls" != "none"],
+    AC_DEFINE_UNQUOTED([TLS], $ac_cv_tls, [If the compiler supports a TLS storage class define it to that here])
+      m4_ifnblank([$1], [$1]),
+    m4_ifnblank([$2], [$2])
+  )
+])
+
+dnl AC_TRY_CFLAGS (CFLAGS, [ACTION-IF-WORKS], [ACTION-IF-FAILS])
+dnl Check if $CC supports a given set of cflags
+AC_DEFUN([AC_TRY_CFLAGS],
+    [AC_MSG_CHECKING([if $CC supports $1 flags])
+    SAVE_CFLAGS="$CFLAGS"
+    CFLAGS="$1"
+    AC_TRY_RUN([main(){exit(0);}],[ac_cv_try_cflags_ok=yes],
+	[ac_cv_try_cflags_ok=no],[ac_cv_try_cflags_ok=no])
+    CFLAGS="$SAVE_CFLAGS"
+    AC_MSG_RESULT([$ac_cv_try_cflags_ok])
+    if test x"$ac_cv_try_cflags_ok" = x"yes"; then
+        ifelse([$2],[],[:],[$2])
+    else
+        ifelse([$3],[],[:],[$3])
+    fi])
+
+dnl CVT_YESNO([YES-NO VARIABLE],[0-1 VARIABLE])
+dnl Make a 0-1 output variable from a yes/no shell variable
+AC_DEFUN(CVT_YESNO,[if test x"$$1" = x"yes"; then
+$2=1
+else
+$2=0
+fi
+AC_SUBST($2)])
+
+dnl Checks for system features
+AC_CANONICAL_HOST
+case "$host" in
+  *powerpc*)
+     is_powerpc=1 ;;
+  *)
+     is_powerpc=0 ;;
+esac
+
+case "$build" in
+  *cygwin*)
+     is_cygwin=1 ;;
+  *)
+     is_cygwin=0 ;;
+esac
+
+case "$CC" in
+  gcc*)
+     gccver=`"$CC" -dumpversion` ;;
+  *)
+     gccver=0.0.0 ;;
+esac
+
+dnl Checks for C compiler and sets CFLAGS if not set by user
+user_cflags="$CFLAGS"
+AC_PROG_CC
+CFLAGS=$user_cflags
+MORECFLAGS=""
+dnl  we need  AC_SYS_LARGEFILE and AC_FUNC_FSEEKO
+AC_SYS_LARGEFILE
+AS_IF([test "x$ac_cv_sys_file_offset_bits" = xno],[ac_cv_sys_file_offset_bits=0])
+AC_SUBST(ac_cv_sys_file_offset_bits)
+
+AS_IF([test "x$user_cflags" = x || test "x$user_cflags" = x-m32],
+[
+  AS_IF([test "$CC" = "icc"],
+    [AC_TRY_CFLAGS([-O3],[CFLAGS="$CFLAGS -O3"]);
+     AS_IF([test "x$ac_cv_try_cflags_ok" = xno],
+        [AC_TRY_CFLAGS([-O2],[CFLAGS="$CFLAGS -O2"],[CFLAGS="$CFLAGS -O"])])],
+    [AC_TRY_CFLAGS([-O4 -Werror],[CFLAGS="$CFLAGS -O4"]);
+     AS_IF([test "x$ac_cv_try_cflags_ok" = xno],
+       [AC_TRY_CFLAGS([-O3],[CFLAGS="$CFLAGS -O3"])
+        AS_IF([test "x$ac_cv_try_cflags_ok" = xno],
+          [AC_TRY_CFLAGS([-O2],[CFLAGS="$CFLAGS -O2"],[CFLAGS="$CFLAGS -O"])])
+       ])
+    ])
+])
+
+dnl Checks relevant to Cygwin and other Windows things
+AC_EXEEXT
+
+dnl Checks for header files.
+dnl AC_HEADER_STDC
+AC_HEADER_SYS_WAIT
+AC_CHECK_HEADERS(signal.h stddef.h unistd.h sys/types.h sys/wait.h stdlib.h string.h errno.h pthread.h)
+CVT_YESNO(ac_cv_header_stddef_h,header_stddef_h)
+CVT_YESNO(ac_cv_header_unistd_h,header_unistd_h)
+CVT_YESNO(ac_cv_header_stdlib_h,header_stdlib_h)
+CVT_YESNO(ac_cv_header_string_h,header_string_h)
+CVT_YESNO(ac_cv_header_sys_wait_h,header_sys_wait_h)
+CVT_YESNO(ac_cv_header_sys_types_h,header_sys_types_h)
+CVT_YESNO(ac_cv_header_errno_h,header_errno_h)
+CVT_YESNO(ac_cv_header_pthread_h,header_pthread_h)
+CVT_YESNO(ac_cv_header_signal_h,header_signal_h)
+
+AC_TYPE_PID_T
+CVT_YESNO(ac_cv_type_pid_t,have_pid_t)
+
+AC_MSG_CHECKING(if malloc is declared in stdlib.h or malloc.h)
+AC_EGREP_HEADER([(^|[^a-zA-Z_0-9])malloc[^a-zA-Z_0-9]],stdlib.h,
+  malloc_dec=1,malloc_dec=0)
+if test $malloc_dec -eq 0; then
+  AC_EGREP_HEADER([(^|[^a-zA-Z_0-9])malloc[^a-zA-Z_0-9]],malloc.h,
+  malloc_dec=2,malloc_dec=0)
+fi
+AC_SUBST(malloc_dec)
+AC_MSG_RESULT($malloc_dec)
+
+AC_MSG_CHECKING(if ftell is declared in stdio.h)
+AC_EGREP_HEADER([(^|[^a-zA-Z_0-9])ftell[^a-zA-Z_0-9]],stdio.h,
+  ftell_dec=1,ftell_dec=0)
+AC_SUBST(ftell_dec)
+AC_MSG_RESULT($ftell_dec)
+
+AC_MSG_CHECKING(if fdopen is declared in stdio.h)
+AC_EGREP_HEADER([(^|[^a-zA-Z_0-9])fdopen[^a-zA-Z_0-9]],stdio.h,
+  fdopen_dec=1,fdopen_dec=0)
+AC_SUBST(fdopen_dec)
+AC_MSG_RESULT($fdopen_dec)
+
+AC_MSG_CHECKING(if popen is declared in stdio.h)
+AC_EGREP_HEADER([(^|[^a-zA-Z_0-9])popen[^a-zA-Z_0-9]],stdio.h,
+  popen_dec=1,popen_dec=0)
+AC_SUBST(popen_dec)
+AC_MSG_RESULT($popen_dec)
+
+AC_MSG_CHECKING(if putenv is declared in stdlib.h)
+AC_EGREP_HEADER([(^|[^a-zA-Z_0-9])putenv[^a-zA-Z_0-9]],stdlib.h,
+  putenv_dec=1,putenv_dec=0)
+AC_SUBST(putenv_dec)
+AC_MSG_RESULT($putenv_dec)
+
+AC_MSG_CHECKING(if setenv is declared in stdlib.h)
+AC_EGREP_HEADER([(^|[^a-zA-Z_0-9])setenv[^a-zA-Z_0-9]],stdlib.h,
+  setenv_dec=1,setenv_dec=0)
+AC_SUBST(setenv_dec)
+AC_MSG_RESULT($setenv_dec)
+
+AC_MSG_CHECKING(if INFINITY is declared in math.h)
+AC_EGREP_CPP(yes,
+[#include <stdio.h>
+#include <math.h>
+#ifdef INFINITY
+  yes
+#endif
+], has_math_inf=1, has_math_inf=0)
+AC_SUBST(has_math_inf)
+AC_MSG_RESULT($has_math_inf)
+
+dnl Checks for sizes of integer types; avoid 64-bit if necessary
+AC_CHECK_SIZEOF([int],4)
+AC_SUBST(ac_cv_sizeof_int)
+AC_CHECK_SIZEOF([long],4)
+AC_SUBST(ac_cv_sizeof_long)
+AC_CHECK_SIZEOF([long long],0)
+AC_SUBST(ac_cv_sizeof_long_long)
+AC_CHECK_SIZEOF([__int128_t],0)
+AC_SUBST(ac_cv_sizeof___int128_t)
+lok=0
+testprogs="dreadtest dreadtestS dreadtestS1 dreadtest4K"
+testprogs="$testprogs dreadtest1 dreadtestW dreadtestW1"
+
+if test $ac_cv_sizeof_long_long -eq 8; then
+   lok=1
+   testprogs="$testprogs dreadtestL1 dreadtestL"
+else
+   if test $ac_cv_sizeof_long -eq 8; then
+      lok=1
+   fi
+fi
+AC_SUBST(lok)
+AC_SUBST(testprogs)
+
+dnl Checks for typedefs, structures, and compiler characteristics.
+AC_C_CONST
+CVT_YESNO(ac_cv_c_const,have_const)
+
+dnl Checks for library functions.
+AC_CHECK_FUNC(isatty,have_isatty=1,have_isatty=0)
+AC_SUBST(have_isatty)
+AC_CHECK_FUNC(time,have_time=1,have_time=0)
+AC_SUBST(have_time)
+AC_CHECK_FUNC(gettimeofday,have_gettimeofday=1,have_gettimeofday=0)
+AC_SUBST(have_gettimeofday)
+AC_CHECK_FUNC(times,have_times=1,have_times=0)
+AC_SUBST(have_times)
+AC_CHECK_FUNC(getrusage,have_getrusage=1,have_getrusage=0)
+AC_SUBST(have_getrusage)
+AC_CHECK_FUNC(perror,have_perror=1,have_perror=0)
+AC_SUBST(have_perror)
+AC_CHECK_FUNC(pipe,have_pipe=1,have_pipe=0)
+AC_SUBST(have_pipe)
+AC_CHECK_FUNC(wait,have_wait=1,have_wait=0)
+AC_SUBST(have_wait)
+AC_CHECK_FUNC(popen,have_popen=1,have_popen=0)
+AC_SUBST(have_popen)
+AC_CHECK_FUNC(putenv,have_putenv=1,have_putenv=0)
+AC_SUBST(have_putenv)
+AC_CHECK_FUNC(setenv,have_setenv=1,have_setenv=0)
+AC_SUBST(have_setenv)
+AC_FUNC_FORK
+CVT_YESNO(ac_cv_func_fork,have_fork)
+AC_SUBST(have_fork)
+AC_CHECK_FUNC(fseeko,have_fseeko=1,have_fseeko=0)
+AC_SUBST(have_fseeko)
+AC_CHECK_FUNC(sigaction,have_sigaction=1,have_sigaction=0)
+AC_SUBST(have_sigaction)
+AC_CHECK_FUNC(sigprocmask,have_sigprocmask=1,have_sigprocmask=0)
+AC_SUBST(have_sigprocmask)
+
+dnl --check if popcnt instruction is available and desired
+dnl --disable-popcnt disables the use of gcc extensions __builtin_popcount*()
+
+AC_MSG_CHECKING(if popcnt instruction is available and requested)
+AC_ARG_ENABLE([popcnt],
+   AS_HELP_STRING([--disable-popcnt], [Disable popcnt extensions]), [popcntarg=given], [popcntarg=notgiven])
+AS_IF([test "x$popcntarg" = "xnotgiven" -o "x$enable_popcnt" = "xyes"], [
+have_hwpopcnt=0
+test -e /proc/cpuinfo && grep -i popcnt /proc/cpuinfo >/dev/null && have_hwpopcnt=1 
+test $have_hwpopcnt -eq 0 && sysctl machdep.cpu.features 2>/dev/null | grep -i popcnt >/dev/null && have_hwpopcnt=1
+test $have_hwpopcnt -eq 0 && isainfo -x -v 2>/dev/null | grep -i popc >/dev/null && have_hwpopcnt=1 
+],[
+have_hwpopcnt=0
+])
+test $is_powerpc -eq 1 && have_hwpopcnt=0
+AC_MSG_RESULT($have_hwpopcnt)
+AC_SUBST(have_hwpopcnt)
+
+SAVE_CFLAGS="$CFLAGS"
+have_popcnt=0
+have_popcntl=0
+have_popcntll=0
+have_mmpop32=0
+have_mmpop64=0
+
+AS_IF([test $have_hwpopcnt -eq 1], [
+AS_IF([test "$CC" = "icc"],[
+AC_MSG_CHECKING(if _mm_popcnt_u32() is supported)
+AC_LINK_IFELSE([AC_LANG_SOURCE([#include <nmmintrin.h>
+main(){unsigned int x; x = _mm_popcnt_u32(x);}])], [have_mmpop32=1], [have_mmpop32=0])
+AC_MSG_RESULT($have_mmpop32)
+AC_MSG_CHECKING(if _mm_popcnt_u64() is supported)
+AC_LINK_IFELSE([AC_LANG_SOURCE([#include <nmmintrin.h>
+main(){unsigned int x; x = _mm_popcnt_u64(x);}])], [have_mmpop64=1], [have_mmpop64=0])
+AC_MSG_RESULT($have_mmpop64)
+], [
+CFLAGS="$CFLAGS -mpopcnt"
+AC_MSG_CHECKING(if __builtin_popcount() is supported)
+AC_LINK_IFELSE([AC_LANG_SOURCE([main(){unsigned int x; x = __builtin_popcount(x);}])], [have_popcnt=1], [have_popcnt=0])
+AC_MSG_RESULT($have_popcnt)
+AC_MSG_CHECKING(if __builtin_popcountl() is supported)
+AC_LINK_IFELSE([AC_LANG_SOURCE([main(){unsigned long x; x = __builtin_popcountl(x);}])], [have_popcntl=1], [have_popcntl=0])
+AC_MSG_RESULT($have_popcntl)
+AC_MSG_CHECKING(if __builtin_popcountll() is supported)
+AC_LINK_IFELSE([AC_LANG_SOURCE([main(){unsigned long long x; x = __builtin_popcountll(x);}])], [have_popcntll=1], [have_popcntll=0])
+AC_MSG_RESULT($have_popcntll)
+AS_IF([test $have_popcnt -eq 1 -o $have_popcntl -eq 1 -o $have_popcntll -eq 1],
+   [MORECFLAGS="$MORECFLAGS -mpopcnt"],[])
+])],[])
+CFLAGS="$SAVE_CFLAGS"
+AC_SUBST(have_popcnt)
+AC_SUBST(have_popcntl)
+AC_SUBST(have_popcntll)
+AC_SUBST(have_mmpop32)
+AC_SUBST(have_mmpop64)
+AC_SUBST(MORECFLAGS)
+
+dnl --disable-clz disables the use of gcc extensions __builtin_clz*()
+
+AC_ARG_ENABLE([clz],
+   AS_HELP_STRING([--disable-clz], [Disable clz extensions]), [clzarg=given], [clzarg=notgiven])
+AS_IF([test "x$clzarg" = "xnotgiven" -o "x$enable_clz" = "xyes"], [
+AC_MSG_CHECKING(if __builtin_clz() is supported)
+AC_LINK_IFELSE([AC_LANG_SOURCE([main(){unsigned int x; x = __builtin_clz(x);}])], [have_clz=1], [have_clz=0])
+AC_MSG_RESULT($have_clz)
+AC_MSG_CHECKING(if __builtin_clzl() is supported)
+AC_LINK_IFELSE([AC_LANG_SOURCE([main(){unsigned long x; x = __builtin_clzl(x);}])], [have_clzl=1], [have_clzl=0])
+AC_MSG_RESULT($have_clzl)
+AC_MSG_CHECKING(if __builtin_clzll() is supported)
+AC_LINK_IFELSE([AC_LANG_SOURCE([main(){unsigned long long x; x = __builtin_clzll(x);}])], [have_clzll=1], [have_clzll=0])
+AC_MSG_RESULT($have_clzll)
+],[
+have_clz=0
+have_clzl=0
+have_clzll=0
+])
+AC_SUBST(have_clz)
+AC_SUBST(have_clzl)
+AC_SUBST(have_clzll)
+
+AC_CHECK_FUNC(pthread_create,have_pthread=1,have_pthread=0)
+AS_IF([test $have_pthread -eq 1],
+[threadlib=],
+[
+    AC_CHECK_LIB(pthread,pthread_create,have_pthread=1,have_pthread=0)
+    AS_IF([test $have_pthread -eq 1],[threadlib=-lpthread],[threadlib=])
+])
+
+if test $have_pipe -eq 1 -a $have_wait -eq 1 -a $have_fork -eq 1 ; then
+    shortg=1
+    shortg_or_null=shortg
+else
+    shortg=0
+    shortg_or_null=
+fi
+AC_SUBST(shortg_or_null)
+
+AC_SUBST(have_pthread)
+AC_SUBST(threadlib)
+
+AC_CHECK_FUNC(getc_unlocked,have_getc_unlocked=1,have_getc_unlocked=0)
+AC_CHECK_FUNC(flockfile,have_flockfile=1,have_flockfile=0)
+if test $have_getc_unlocked -eq 1 -a $have_flockfile -eq 1 ; then
+    stdio_nolock=1
+else
+    stdio_nolock=0
+fi
+AC_SUBST(stdio_nolock)
+
+dnl --enable-tls enables tests for thread-local attributes
+AC_ARG_ENABLE([tls],
+   AS_HELP_STRING([--enable-tls], [Enable thread-local variables]))
+AS_IF([test "x$enable_tls" = "xyes"], [
+AX_TLS([have_tls=1],[have_tls=0])
+],[have_tls=0])
+
+if test "$have_tls" -eq 0 ; then
+    ac_cv_tls=
+fi
+AC_SUBST(ac_cv_tls)
+AC_SUBST(have_tls)
+
+dnl --enable-wordsize=value overrides default rule for choosing WORDSIZE
+AC_ARG_ENABLE([wordsize],
+   AS_HELP_STRING([--enable-wordsize=value], [Override default WORDSIZE choice]))
+AS_IF([test "x$enable_wordsize" = "x16"],[default_wordsize=16],[default_wordsize=0])
+AS_IF([test "x$enable_wordsize" = "x32"],[default_wordsize=32],[])
+AS_IF([test "x$enable_wordsize" = "x64"],[default_wordsize=64],[])
+AC_SUBST(default_wordsize)
+
+dnl --enable-ansicontrols enables ANSI terminal control sequences
+AC_ARG_ENABLE([ansicontrols],
+   AS_HELP_STRING([--enable-ansicontrols], [Enable ANSI terminal control sequences]))
+AS_IF([test "x$enable_ansicontrols" = "xyes"],[have_ansicontrols=1],[have_ansicontrols=0])
+AC_SUBST(have_ansicontrols)
+
+dnl --disable-interrupt disables SIGINT catching in dreadnaut
+AC_ARG_ENABLE([interrupt],
+   AS_HELP_STRING([--disable-interrupt], [Disable SIGINT catching in dreadnaut]),[intarg=given],[intarg=notgiven])
+AS_IF([test "x$intarg" = "xnotgiven" -o "x$enable_interrupt" = "xyes"], [allow_interrupt=1],[allow_interrupt=0])
+AC_SUBST(allow_interrupt)
+
+case "$build" in
+   *cygwin*)
+       AC_PATH_PROGS(sort_prog,[gsort sort],no_sort_found,
+             [/usr/bin$PATH_SEPARATOR/bin$PATH_SEPARATOR$PATH]) ;;
+   *)
+       AC_CHECK_PROGS(sort_prog,[gsort sort],no_sort_found) ;;
+esac
+
+AC_MSG_CHECKING(if sort supports the -k switch)
+if { $sort_prog -k "2,3" </dev/null >/dev/null 2>&1 ; } ; then
+   sort_newparams_ok=1
+else
+   sort_newparams_ok=0
+fi
+AC_SUBST(sort_newparams_ok)
+AC_MSG_RESULT($sort_newparams_ok)
+
+edit_msg="++++++ This file is automatically generated, don't edit it by hand! ++++++"
+AC_SUBST(edit_msg)
+
+echo CFLAGS=$CFLAGS
+echo MORECFLAGS=$MORECFLAGS
+
+AC_OUTPUT(makefile:makefile.in nauty.h:nauty-h.in
+    naututil.h:naututil-h.in gtools.h:gtools-h.in)
+
diff --git a/lib/nauty/converseg.c b/lib/nauty/converseg.c
new file mode 100644
index 0000000..8f572da
--- /dev/null
+++ b/lib/nauty/converseg.c
@@ -0,0 +1,152 @@
+/* converseg.c  version 2.0; B D McKay, Jun 2015. */
+
+#define USAGE "converseg [-q] [infile [outfile]]"
+
+#define HELPTEXT \
+" Take the converse digraphs of a file of graphs.\n\
+\n\
+    The output file has a header if and only if the input file does.\n\
+    Undirected graphs are passed through without change, while\n\
+    directed graphs are written in digraph6 format.\n\
+\n\
+    -q  Suppress auxiliary information.\n"
+
+/*************************************************************************/
+
+#include "gtools.h" 
+
+/**************************************************************************/
+
+static void
+conv(graph *g, int m, int n)
+/* Replace g by its converse */
+{
+    int i,j;
+    graph *gi,*gj;
+
+    for (i = 0, gi = g; i < n; ++i, gi += m)
+        for (j = i+1, gj = gi+m; j < n; ++j, gj += m)
+            if ((ISELEMENT(gi,j)!=0) + (ISELEMENT(gj,i)!=0) == 1)
+            {
+                FLIPELEMENT(gi,j);
+                FLIPELEMENT(gj,i);
+            }
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    char *infilename,*outfilename;
+    FILE *infile,*outfile;
+    boolean badargs,quiet;
+    boolean digraph;
+    int j,m,n,argnum;
+    int codetype,outcode;
+    graph *g;
+    // size_t ii,ned,nedc,nn,loops,loopsc,gwords;
+    nauty_counter nin;
+    char *arg,sw;
+    double t;
+
+    HELP; PUTVERSION;
+
+    infilename = outfilename = NULL;
+    badargs = FALSE;
+    quiet = FALSE;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                SWBOOLEAN('q',quiet)
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if (!quiet)
+    {
+        fprintf(stderr,">A converseg");
+        if (argnum > 0) fprintf(stderr," %s",infilename);
+        if (argnum > 1) fprintf(stderr," %s",outfilename);
+        fprintf(stderr,"\n");
+        fflush(stderr);
+    }
+
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,FALSE,1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    if (!outfilename || outfilename[0] == '-')
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename,"w")) == NULL)
+    {
+        fprintf(stderr,"Can't open output file %s\n",outfilename);
+        gt_abort(NULL);
+    }
+
+    if      (codetype&SPARSE6)  outcode = SPARSE6;
+    else if (codetype&DIGRAPH6) outcode = DIGRAPH6;
+    else                        outcode = GRAPH6;
+
+    if (codetype&HAS_HEADER)
+    {
+        if (outcode == SPARSE6)       writeline(outfile,SPARSE6_HEADER);
+        else if (outcode == DIGRAPH6) writeline(outfile,DIGRAPH6_HEADER);
+        else          	              writeline(outfile,GRAPH6_HEADER);
+    }
+
+    gtools_check(WORDSIZE,1,1,NAUTYVERSIONID);
+
+    nin = 0;
+    t = CPUTIME;
+    while (TRUE)
+    {
+        if ((g = readgg(infile,NULL,0,&m,&n,&digraph)) == NULL) break;
+        ++nin;
+
+        if (!digraph)
+	    writelast(outfile);
+        else
+        {
+	    conv(g,m,n);
+	    writed6(outfile,g,m,n);
+	}
+        FREES(g);
+    }
+    t = CPUTIME - t;
+
+    if (!quiet)
+        fprintf(stderr,">Z  " COUNTER_FMT 
+                " graphs converted from %s to %s in %3.2f sec.\n",
+                nin,infilename,outfilename,t);
+
+    exit(0);
+}
diff --git a/lib/nauty/copyg.c b/lib/nauty/copyg.c
new file mode 100644
index 0000000..ddba730
--- /dev/null
+++ b/lib/nauty/copyg.c
@@ -0,0 +1,202 @@
+/* copyg.c version 2.1; B D McKay, Jun 2015 */
+
+#define USAGE "copyg [-gszfp#:#qhx] [infile [outfile]]"
+
+#define HELPTEXT \
+"  Copy a file of graphs with possible format conversion.\n\
+\n\
+     -g  Use graph6 format for output\n\
+     -s  Use sparse6 format for output\n\
+     -z  Use digraph6 format for output\n\
+     -i  Use incremental sparse6 format for output\n\
+     In the absence of -g, -s, -z or -i, the format\n\
+     depends on the header or, if none, the first input line.\n\
+     As an exception, digraphs are always written in digraph6.\n\
+\n\
+     -p# -p#:#  \n\
+     Specify range of input lines (first is 1)\n\
+     This can fail if the input has incremental lines.\n\
+     -f  With -p, assume input lines of fixed length\n\
+      (ignored if header or first line has sparse6 format).\n\
+     -I# Have at most this number of incremental steps\n\
+      in a row.  Implies -i. \n\
+\n\
+     -h  Write a header.\n\
+     -x  Don't write a header.\n\
+     In the absence of -h and -x, a header is written if\n\
+     there is one in the input.\n\
+\n\
+     -q  Suppress auxiliary output.\n"
+
+/***********************************************************************/
+
+#include "gtools.h"
+
+int
+main(int argc, char *argv[])
+{
+    graph *g,*gprev,*gbase;
+    int m,n,codetype;
+    char *infilename,*outfilename;
+    FILE *infile,*outfile;
+    int outcode;
+    nauty_counter nin;
+    int argnum,j,nprev,mprev;
+    char *arg,sw;
+    boolean sswitch,fswitch,pswitch,qswitch,gswitch;
+    boolean hswitch,xswitch,iswitch,Iswitch,zswitch;
+    boolean badargs,digraph;
+    long pval1,pval2,maxin,refresh,inclines;
+
+    HELP; PUTVERSION;
+
+    iswitch = Iswitch = sswitch = fswitch = pswitch = FALSE;
+    gswitch = qswitch = xswitch = hswitch = zswitch = FALSE;
+    infilename = outfilename = NULL;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('s',sswitch)
+                else SWBOOLEAN('g',gswitch)
+                else SWBOOLEAN('z',zswitch)
+                else SWBOOLEAN('q',qswitch)
+                else SWBOOLEAN('f',fswitch)
+                else SWBOOLEAN('h',hswitch)
+                else SWBOOLEAN('i',iswitch)
+                else SWBOOLEAN('x',xswitch)
+                else SWLONG('I',Iswitch,refresh,"copyg -I")
+                else SWRANGE('p',":-",pswitch,pval1,pval2,"copyg -p")
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if (Iswitch) iswitch = TRUE;
+    if ((sswitch!=0) + (gswitch!=0) + (iswitch!=0) + (zswitch!=0) > 1) 
+        gt_abort(">E copyg: -s, -g, -z and -i/-I are incompatible\n");
+    if (hswitch && xswitch) 
+        gt_abort(">E copyg: -h and -x are incompatible\n");
+
+    if (badargs || argnum > 2)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if (!qswitch)
+    {
+        fprintf(stderr,">A copyg");
+        if (sswitch || gswitch || iswitch || Iswitch || fswitch
+                        || zswitch || pswitch || xswitch || hswitch)
+            fprintf(stderr," -");
+        if (sswitch) fprintf(stderr,"s");
+        if (gswitch) fprintf(stderr,"g");
+        if (zswitch) fprintf(stderr,"z");
+        if (hswitch) fprintf(stderr,"h");
+        if (Iswitch) fprintf(stderr,"I%ld",refresh); 
+        else if (iswitch) fprintf(stderr,"i");
+        if (xswitch) fprintf(stderr,"x");
+        if (fswitch) fprintf(stderr,"f");
+        if (pswitch) writerange(stderr,'p',pval1,pval2);
+        if (argnum > 0) fprintf(stderr," %s",infilename);
+        if (argnum > 1) fprintf(stderr," %s",outfilename);
+        fprintf(stderr,"\n");
+        fflush(stderr);
+    }
+
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,fswitch,
+                                        pswitch ? pval1 : 1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    if (!outfilename || outfilename[0] == '-')
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename,"w")) == NULL)
+    {
+        fprintf(stderr,"Can't open output file %s\n",outfilename);
+        gt_abort(NULL);
+    }
+
+    if (gswitch)                  outcode = GRAPH6;
+    else if (sswitch || iswitch)  outcode = SPARSE6;
+    else if (zswitch)             outcode = DIGRAPH6;
+    else if ((codetype&GRAPH6))   outcode = GRAPH6;
+    else if ((codetype&SPARSE6))  outcode = SPARSE6;
+    else if ((codetype&DIGRAPH6)) outcode = DIGRAPH6;
+    else
+    {
+        outcode = GRAPH6;
+        fprintf(stderr,
+             ">W copyg doesn't handle this graph format, writing graph6.\n");
+    }
+
+    if (hswitch || (!xswitch && (codetype&HAS_HEADER)))
+    {
+        if (outcode == SPARSE6)       writeline(outfile,SPARSE6_HEADER);
+        else if (outcode == DIGRAPH6) writeline(outfile,DIGRAPH6_HEADER);
+        else                          writeline(outfile,GRAPH6_HEADER);
+    }
+
+    nin = 0;
+    if (!pswitch || pval2 == NOLIMIT) maxin = NOLIMIT;
+    else if (pval1 < 1) maxin = pval2;
+    else                maxin = pval2 - pval1 + 1;
+
+    gprev = NULL;
+    nprev = mprev = 1;
+    inclines = 0;
+    while (nin < maxin || maxin == NOLIMIT)
+    {
+        if ((g = readgg_inc(infile,NULL,0,&m,&n,gprev,mprev,nprev,&digraph))
+                                                      == NULL) break;
+        ++nin;
+
+        if (iswitch)  
+        {
+	    if (digraph) gt_abort(
+                ">Z incremental sparse6 is incompatible with digraphs\n");
+            gbase = gprev;
+            if (nprev != n || mprev != m) gbase = NULL;
+            if (Iswitch > 0 && inclines == refresh) gbase = NULL;
+            if (gbase == NULL) inclines = 0; else ++inclines;
+            writeis6(outfile,g,gbase,m,n);
+        }
+        else if (outcode == readg_code)   writelast(outfile);
+	else if (digraph)             writed6(outfile,g,m,n);
+        else if (outcode == SPARSE6)  writes6(outfile,g,m,n);
+        else if (outcode == DIGRAPH6) writed6(outfile,g,m,n);
+        else                          writeg6(outfile,g,m,n);
+
+        if (gprev) FREES(gprev);
+        gprev = g;
+        nprev = n;
+        mprev = m;
+    }
+
+    if (!qswitch) 
+        fprintf(stderr,">Z  " COUNTER_FMT " graphs copied from %s to %s\n",
+                       nin,infilename,outfilename);
+
+    exit(0);
+}
diff --git a/lib/nauty/cubhamg.c b/lib/nauty/cubhamg.c
new file mode 100644
index 0000000..325c24f
--- /dev/null
+++ b/lib/nauty/cubhamg.c
@@ -0,0 +1,1985 @@
+/* cubhamg.c : pick those inputs that are nonhamiltonian and
+                have max degree <= 3.
+
+ Usage:
+cubhamg [-#] [-v|-V] [-n#-#|-y#-#|-i|-I|-o|-x|-e|-E] [-b|-t] [infile [outfile]]
+
+        infile is the name of the input file in graph6/sparse6 format
+        outfile is the name of the output file in the same format
+
+	stdin and stdout are the defaults for infile and outfile
+
+	The output file will have a header >>graph6<< or >>sparse6<<
+        if and only if the input file does.
+
+        Optional switches:
+
+        -#  A parameter useful for tuning (default 100)
+	-v  Report nonhamiltonian graphs and noncubic graphs
+	-V  .. in addition give a cycle for the hamiltonian ones
+	-n#-#  If the two numbers are v and i, then the i-th edge
+	    out of vertex v is required to be not in the cycle.
+	    It must be that i=1..3 and v=0..n-1.
+	-y#-#  If the two numbers are v and i, then the i-th edge
+	    out of vertex v is required to be in the cycle.
+	    It must be that i=1..3 and v=0..n-1.
+            You can use any number of -n/-y switches to force
+            edges.  Out of range first arguments are ignored.
+            If -y and -n give same edge, -y wins.
+        -i  Test + property: for each edge e, there is a hamiltonian
+            cycle using e.
+	-I  Test ++ property: for each pair of edges e,e', there is
+            a hamiltonian cycle which uses both e and e'.
+        -o  Test - property: for each edge e, there is a hamiltonian 
+            cycle avoiding e.
+        -x  Test +- property: for each pair of edges e,e', there is
+            a hamiltonian cycle which uses e but avoids e'.
+        -e  Test 3/4 property: for each edge e, at least 3 of the 4
+            paths of length 3 passing through e lie on hamiltonian cycles.
+        -E  Test 3/4+ property: for each edge e failing the 3/4 property,
+            all three ways of joining e to the rest of the graph are
+            hamiltonian avoiding e.
+        -T# Specify a timeout, being a limit on how many search tree
+            nodes are made.  If the timeout occurs, the graph is 
+            written to the output as if it is nonhamiltonian.
+        -R# Specify the number of repeat attempts for each stage.
+        -F  Analyze covering paths from 2 or 4 vertices of degree 2.
+
+	-b  Require biconnectivity
+        -t  Require triconnectivity  (note: quadratic algorithm)
+
+        -y, -n, -#, -R and -T are ignored for -i, -I, -x, -o, -e, -E, -F
+
+	B. D. McKay, Nov 1995 + Aug 1996 + Feb 2002 + Jul 2008 + Nov 2015
+
+**************************************************************************/
+
+#ifndef MAXN
+#define MAXN 152  /* 2 more than largest graph size! */
+#endif
+
+#if MAXN==0
+#error MAXN cannot be zero for cubhamg
+#endif
+
+#include "gtools.h" 
+#include "naurng.h"
+
+/**************************************************************************/
+
+#define RANPERM TRUE
+
+/* cubham.h */
+
+#define MAXNE ((3 * MAXN) / 2)
+#define FALSE 0
+#define TRUE 1
+#define YES 1
+#define DUNNO 0
+#define NO (-1)
+#define HABORT 5
+
+#define BADLIM 100  /* limit on number of bad things to report per graph */
+#define MAXA  100   /* max number of -y or -n switches */
+
+typedef int cubgraph[MAXN][4];
+typedef int vertvec[MAXN];
+typedef int edgevec[MAXNE+1];
+static long nodecount,maxnodes,totalnodes;
+static long timeout;
+static long repeats;
+static int verbose;
+
+#define NO_LIMIT 0x7FFFFFFFL
+
+static long standard[]
+  = {30,40,50,60,100,200,300,400,500,1000,2000,3000,5000,
+     10000,20000,30000,100000,300000,1000000};
+#define NUMMAXNODES (sizeof(standard)/sizeof(long))
+static nauty_counter numtries[NUMMAXNODES+1];
+
+/* cubham.c */
+
+/***************************************************************************
+
+        *****   Instructions for using cubham.  *****
+
+    cubham can find hamiltonian cycles in graphs of maximum 
+    degree at most 3, with specifed edges either required or forbidden.  
+    To use it:
+
+    (1) Check that MAXN (defined in cubham.h) is at least equal to the
+    number of vertices.
+
+    (2) #include cubham.h.
+
+    (3) The cubic graph must be stored in an object of type cubgraph.  Say
+    you call it g.  The vertices are numbered 0,1,..., and the neighbours of
+    vertex i are g[i][0], g[i][1] and g[i][2].  Entries of the form g[i][3]
+    are unused.  If the degree is less than 3, -1 is used as padding.
+
+    (4) Call   cubinit(g,eno,v1,v2,nv,&ne), where
+        g     = the cubic graph                         (input)
+        eno   = another object of type cubgraph         (output)
+        v1,v2 = objects of type edgevec                 (output)
+        nv    = the number of vertices                  (input)
+	ne    = the number of edges                     (output)
+
+    This numbers the edges 0,1,...ne-1, and defines
+        eno[i][j]      = the number of the edge {i, g[i][j]}
+        {v1[j], v2[j]} = the vertices of the j-th edge.
+
+    (5) Call  cubham(g,eno,initclass,v1,v2,cycle,outclass,nv,ne), where
+        g,eno,v1,v2,nv = as above                       (input)
+        initclass = initial edge classification         (input)
+        outclass = final edge classifiction             (output)
+        cycle = the hamiltonian cycle found, if any     (output)
+
+    The value returned by cubham is either YES (hamiltonian cycle found)
+        or NO (there isn't any).
+
+    The initial edge classification is specified by you in the edgevec
+    initclass[].  For each edge j, (0 <= j < 3*nv/2), set
+    initclass[j] = NO, YES or DUNNO, if edge j must not be in the cycle,
+    must be in the cycle, or don't care, respectively.  Passing NULL as
+    the initclass parameter is equivalent to setting each edge to DUNNO.
+    All initial classifications are legal, even those clearly impossible.
+
+    The final edge classification is set by cubham in the edgevec
+    outclass[], if a hamiltonian cycle is found.  Each entry should be
+    either NO or YES.  No final classification is provided if NULL is passed
+    as the outclass parameter.
+
+    The hamiltonian cycle itself, if any, is returned as cycle[0], cycle[1],
+    ..., cycle[nv-1], cycle[0].  If the cycle is not needed, you can pass
+    NULL for this parameter.
+
+    Step (4) need not be repeated if the same graph is processed again with
+    a different initial classification.
+
+****************************************************************************/
+
+#define POP(x) (onstack[x = *(--stackptr)] = 0)
+#define PUSH(x) if(onstack[x]!=stacklev){onstack[x]=stacklev;*(stackptr++)=x;}
+#define RESETSTACK {stacklev++; stackptr = stack;}
+
+typedef struct
+{
+    edgevec class;
+    vertvec din,dout,farend;
+} nodedata;
+
+static nodedata hcnodat;
+static cubgraph eno;
+static vertvec onstack,stack;       /* stack contains vertex numbers */
+static int *stackptr,stacklev;      /* stackptr points above top */
+static int classstack[4*MAXNE];      /* stack of classifications */
+   /* x >= 0        : edge number
+     (x < 0 above y : farend[-x-1] = y  */
+static int *classstackptr;       /* points above top of classstack */
+static int classout(cubgraph,nodedata*,int,int,int);
+static int classin(cubgraph,cubgraph,nodedata*,int,int,int,int*,int);
+
+#define MAXES 0
+
+#if MAXES
+static int maxlevel,maxclassstack;
+#endif
+
+static void
+dummy(void)
+{
+}
+
+static void
+check_it(int index, cubgraph g, cubgraph eno, edgevec v1, edgevec v2,
+         int *din, int *dout, int *class, int *farend, int nin, int nv,
+         int stable)
+/* Check some things */
+{
+    int xdin[MAXN],xdout[MAXN],xnin,v,i,j,k,l,*gv,xin,xout,has1;
+
+    for (i = 0; i < nv; ++i) xdin[i] = xdout[i] = 0;
+    xnin = has1 = 0;
+
+    for (v = 0; v < nv; ++v)
+    {
+	gv = g[v];
+	xin = xout = 0;
+	for (i = 0; i < 3; ++i)
+	    if (gv[i] >= 0)
+	    {
+		j = eno[v][i];
+		if (class[j] == NO) ++xout;
+		if (class[j] == YES) ++xin;
+	    }
+	if (xout != dout[v] || xin != din[v])
+	{
+	    fprintf(stderr,">E%d degrees of %d: din,dout=%d,%d really %d,%d\n",
+			index,v,din[v],dout[v],xin,xout);
+	    dummy();
+	}
+	if (xin == 1) ++has1;
+	xnin += xin;
+    }
+
+    xnin /= 2;
+    if (xnin != nin)
+    {
+        fprintf(stderr,">E%d nin=%d actually %d\n",index,nin,xnin);
+        dummy();
+    }
+    if (nin != 0 && !has1)
+    {
+        fprintf(stderr,">E%d nin=%d has no in=1\n",index,nin);
+        dummy();
+    }
+
+    for (i = 0; i < nv; ++i)
+	if (din[i] == 0)
+	{
+            if (farend[i] != i)
+    	    {
+        	fprintf(stderr,">E%d farend[isolate %d]=%d\n",
+			index,i,farend[i]);
+        	dummy();
+	    }
+	}
+	else if (din[i] == 1)
+	{
+	    k = -1;
+	    j = i;
+	    do
+	    {
+	        for (l = 0; l < 3; ++l)
+		    if (g[j][l] >= 0 && g[j][l] != k && class[eno[j][l]] == YES)
+			break;
+		k = j;
+		if (l < 3) j = g[j][l];
+	    } while (l < 3);
+            if (farend[i] != j)
+    	    {
+        	fprintf(stderr,">E%d farend[%d]=%d really %d\n",
+			index,i,farend[i],j);
+        	dummy();
+	    }
+        }
+
+    if (stable)
+	for (i = 0; i < nv; ++i)
+	    if ((dout[i] == 1 && din[i] != 2) || (din[i] == 2 && dout[i] != 1)
+		|| dout[i] > 1 || din[i] > 2)
+	    {
+		fprintf(stderr,">E%d din[%d]=%d dout[%d]=%d\n",
+		        index,i,din[i],i,dout[i]);
+		dummy();
+	    }
+}
+
+static void
+cubinit(cubgraph g, cubgraph eno, edgevec v1, edgevec v2, int nv, int ne)
+/* initialise edge numbers, etc. */
+{
+        int *gpx,*gpy,*enop,x,y,i,j,n,en;
+
+        n = nv;
+        en = 0;
+        for (x = 0; x < n; ++x)
+        {
+            gpx = g[x];
+            enop = eno[x];
+            for (i = 0; i < 3; ++i)
+                if ((y = gpx[i]) < 0)
+		    enop[i] = ne;
+		else if (y > x)
+                {
+                    v1[en] = x;
+                    v2[en] = y;
+                    enop[i] = en++;
+                }
+                else
+                {
+                    gpy = g[y];
+                    for (j = 0; gpy[j] != x; j++)
+                        {}
+                    enop[i] = eno[y][j];
+                }
+        }
+
+        if (en != ne)
+            fprintf(stderr,"%% cubinit got en=%d when ne=%d\n",en,ne);
+}
+
+static int
+propagate(cubgraph g, cubgraph eno, nodedata *ndptr, int *nin, int nv)
+/* propagate classifications: */
+/*   ans = YES, NO or DUNNO */
+{
+        int v,w,i,status;
+        nodedata *np;
+        int *gp,*enop,*class,*din,*dout;
+
+        status = DUNNO;
+        np = ndptr;
+        class = np->class;
+        din = np->din;
+        dout = np->dout;
+
+        while (status == DUNNO && stackptr > stack)
+        {
+            POP(v);
+            gp = g[v];
+            enop = eno[v];
+            if (dout[v] == 0)
+            {
+                if (din[v] == 2)
+                {
+                    if (class[enop[0]] == DUNNO)      i = 0;
+                    else if (class[enop[1]] == DUNNO) i = 1;
+                    else                              i = 2;
+                    w = gp[i];
+                    status = classout(g,np,v,w,enop[i]);
+                    PUSH(w);
+                }
+                else if (din[v] == 3)
+                    status = NO;
+            }
+            else if (dout[v] == 1)
+            {
+                for (i = 0; i < 3; ++i)
+                if (class[enop[i]] == DUNNO)
+                {
+                    w = gp[i];
+                    if ((status = classin(g,eno,np,v,w,enop[i],nin,nv))
+                                                                 != DUNNO)
+                        break;
+                    else
+                        PUSH(w);
+                }
+            }
+            else
+                status = NO;
+        }
+
+        if (status != NO && *nin == nv) return YES;
+        else			        return status;
+}
+
+static int
+classout(cubgraph g, nodedata *nodat, int v, int w, int en) 
+/* classify edge en = vw out */
+{
+        nodedata *np;
+
+        np = nodat;
+        ++np->dout[v];
+        ++np->dout[w];
+        np->class[en] = NO;
+	*classstackptr++ = en;
+#if MAXES
+	if (classstackptr-classstack > maxclassstack)
+	    maxclassstack = classstackptr-classstack;
+#endif
+
+        return DUNNO;
+}
+
+static int
+classin(cubgraph g, cubgraph eno, nodedata *nodat,
+                                    int v, int w, int en, int *nin, int nv)
+/* classify edge en = vw in */
+{
+        nodedata *np;
+        int *farend,*gp,fv,fw,i;
+
+        np = nodat;
+        ++np->din[v];
+        ++np->din[w];
+        np->class[en] = YES;
+	*classstackptr++ = en; 
+#if MAXES
+	if (classstackptr-classstack > maxclassstack)
+	    maxclassstack = classstackptr-classstack;
+#endif
+
+        ++*nin;
+        if (*nin == nv)
+	{
+	    return DUNNO;
+	}
+
+        farend = np->farend;
+        fv = farend[v];
+        fw = farend[w];
+	*classstackptr++ = farend[fv];
+	*classstackptr++ = -fv-1;
+	*classstackptr++ = farend[fw];
+	*classstackptr++ = -fw-1;
+#if MAXES
+	if (classstackptr-classstack > maxclassstack)
+	    maxclassstack = classstackptr-classstack;
+#endif
+        farend[fv] = fw;
+        farend[fw] = fv;
+
+        gp = g[fv];
+        if      (gp[0] == fw) i = 0;
+        else if (gp[1] == fw) i = 1;
+        else if (gp[2] == fw) i = 2;
+        else                  return DUNNO;
+
+        i = eno[fv][i];
+        if (np->class[i] == DUNNO)
+        {
+            PUSH(fv);
+            PUSH(fw);
+            if (*nin == nv - 1)
+                return classin(g,eno,np,fv,fw,i,nin,nv);
+            else
+                return classout(g,np,fv,fw,i);
+        }
+
+        return DUNNO;
+}
+
+static int
+hamnode(cubgraph g, cubgraph eno, edgevec v1, edgevec v2,
+	nodedata *nodat, int level, int nin, int nv)
+/* main node for recursion */
+{
+        int i,p,q,status;
+        int v,w,en,*gv,*enov;
+	int *csptr;
+
+#if MAXES
+	if (level > maxlevel) maxlevel = level;
+#endif
+
+        if (++nodecount > maxnodes && maxnodes != NO_LIMIT) return HABORT;
+        status = propagate(g,eno,nodat,&nin,nv);
+
+        if (status != DUNNO) return status;
+
+        for (v = nv; --v >= 0;)
+            if (nodat->din[v] == 1) break;
+
+        if (v < 0) v = 0;
+
+        gv = g[v];
+        enov = eno[v];
+
+        for (i = 0; i < 3; ++i)
+        {
+            en = enov[i];
+            if (nodat->class[en] == DUNNO)
+            {
+                w = gv[i];
+                csptr = classstackptr;
+                status = classout(g,nodat,v,w,en);
+                if (status == YES) break;
+	 	if (status == NO)
+		{
+		    while (classstackptr > csptr)
+		    {
+			p = *--classstackptr;
+			if (p >= 0)
+			{
+			    if (nodat->class[p] == YES)
+			    {
+				--nodat->din[v1[p]];
+				--nodat->din[v2[p]];
+			    }
+			    else
+			    {
+				--nodat->dout[v1[p]];
+				--nodat->dout[v2[p]];
+			    }
+			    nodat->class[p] = DUNNO;
+			}
+			else
+			{
+			    q = *--classstackptr;
+			    nodat->farend[-p-1] = q;
+			}
+		    }
+                    continue;
+		}
+                RESETSTACK;
+                PUSH(v);
+                PUSH(w);
+                status = hamnode(g,eno,v1,v2,nodat,level+1,nin,nv);
+                if (status == YES) break;
+		while (classstackptr > csptr)
+		{
+		    p = *--classstackptr;
+		    if (p >= 0)
+		    {
+		        if (nodat->class[p] == YES)
+		        {
+		    	    --nodat->din[v1[p]];
+		    	    --nodat->din[v2[p]];
+		        }
+		        else
+		        {
+		    	    --nodat->dout[v1[p]];
+		    	    --nodat->dout[v2[p]];
+		        }
+		        nodat->class[p] = DUNNO;
+		    }
+		    else
+		    {
+			q = *--classstackptr;
+			nodat->farend[-p-1] = q;
+		    }
+		}
+                if (status == HABORT) return HABORT;
+            }
+        }
+
+        if (status == DUNNO)
+            fprintf(stderr,"hamnode returning DUNNO, this can't happen\n");
+        return status;
+}
+
+static int
+cubham(cubgraph g, cubgraph eno, edgevec initclass, edgevec v1, edgevec v2,
+       vertvec cycle, edgevec outclass, int nv, int ne) 
+/* external interface */
+{
+        int i,j,status,nin,v,w;
+
+        for (i = ne; --i >= 0;)
+            hcnodat.class[i] = DUNNO;
+	if (3*nv > 2*ne) hcnodat.class[ne] = NO;
+
+        for (i = nv; --i >= 0;)
+        {
+            hcnodat.din[i] = hcnodat.dout[i] = 0;
+            hcnodat.farend[i] = i;
+            onstack[i] = 0;
+        }
+        nin = 0;
+        stacklev = 0;
+        RESETSTACK;
+
+	for (i = nv; --i >= 0;)
+	{
+	    if (g[i][1] < 0) return NO;
+	    if (g[i][2] < 0)
+	    {
+		hcnodat.dout[i] = 1;
+		PUSH(i);
+	    }
+	}
+
+        status = DUNNO;
+	classstackptr = classstack;
+        if (initclass)
+            for (i = 0; i < ne; ++i)
+                if (initclass[i] != DUNNO)
+                {
+                    v = v1[i];
+                    w = v2[i];
+                    if (initclass[i] == NO)
+                    {
+                        if (hcnodat.class[i] == YES)
+                            status = NO;
+                        else if (hcnodat.class[i] == DUNNO)
+                        {
+                            if (hcnodat.dout[v] == 0)
+                            {
+                                status = classout(g,&hcnodat,v,w,i);
+                                PUSH(v);
+                                PUSH(w);
+                            }
+                            else
+                                status = NO;
+			}
+                    }
+                    else if (initclass[i] == YES)
+                    {
+                        if (hcnodat.class[i] == NO)
+                            status = NO;
+                        else if (hcnodat.class[i] == DUNNO)
+			{
+                            if (hcnodat.din[v] < 2)
+                            {
+                                status = classin(g,eno,&hcnodat,v,w,i,&nin,nv);
+                                PUSH(v);
+                                PUSH(w);
+                            }
+                            else
+                                status = NO;
+			}
+                    }
+
+                    if (status != DUNNO) break;
+                }
+
+        if (status == DUNNO)
+            status = hamnode(g,eno,v1,v2,&hcnodat,0,nin,nv);
+
+        if (status == YES && cycle)
+        {
+            w = -1;
+            v = 0;
+            cycle[0] = 0;
+            for (i = 1; i < nv; ++i)
+            {
+                for (j = 0; g[v][j] == w || hcnodat.class[eno[v][j]] != YES; ++j)
+                    {}
+                w = v;
+                v = g[v][j];
+                cycle[i] = v;
+            }
+        }
+        if (status == YES && outclass)
+            for (i = 0; i < ne; ++i)
+                outclass[i] = hcnodat.class[i];
+
+        return status;
+}
+
+/********************************************************************/
+
+static int
+isham(cubgraph cub,
+      int n, int ne, int weight,
+      int *vv, int *vi, int nvv,
+      int *yy, int *yi, int nyy, int *cyc)
+/* test if hamiltonian; optionally return a cycle 
+   Forbid the vi[i]-th nbr of vv[i], for i=0..nvv-1 
+   Force the yi[i]-th nbr of yy[i], for i=0..nyy-1 
+     WARNING: vi[i]/yi[i] is numbered starting at 1  */
+{
+        int i,j,k;
+        int nmax,ch;
+        cubgraph cubcopy;
+        edgevec v1,v2,initclass,outclass;
+        int perm[MAXN],pinv[MAXN];
+	double tmp;
+
+#if !RANPERM
+
+        maxnodes = NO_LIMIT;
+        nodecount = 0;
+        cubinit(cub,eno,v1,v2,n,ne);
+
+        for (i = 0; i < ne; ++i)
+            initclass[i] = DUNNO;
+
+	for (i = 0; i < nvv; ++i)
+	    if (vv[i] < n) initclass[eno[vv[i]][vi[i]-1]] = NO;
+	for (i = 0; i < nyy; ++i)
+	    if (yy[i] < n) initclass[eno[yy[i]][yi[i]-1]] = YES;
+
+        ch = cubham(cub,eno,initclass,v1,v2,cyc,outclass,n,ne);
+
+        totalnodes += nodecount;
+        ++numtries[0];
+       
+#else
+        ch = HABORT;
+	maxnodes = -1;
+        for (nmax = 0; ch == HABORT && maxnodes != timeout; ++nmax)
+        {
+            if (nmax/repeats < NUMMAXNODES)
+            {
+		tmp = (double)standard[nmax/repeats] * (double)weight 
+                                             * (double)n/ 10000.0;
+		if (tmp >= (double)NO_LIMIT) maxnodes = NO_LIMIT;
+		else                        maxnodes = tmp;
+		if (timeout > 0 && timeout < maxnodes) maxnodes = timeout;
+            }
+            else if (timeout > 0)
+		maxnodes = timeout;
+	    else
+                maxnodes = NO_LIMIT;
+
+	    if (nmax != 0)
+	    {
+                for (i = n; --i > 0;)
+                {
+                    k = KRAN(i+1);
+                    j = perm[i];
+                    perm[i] = perm[k];
+                    perm[k] = j;
+                }
+	    }
+	    else
+	    {
+		for (i = 0; i < n; ++i)
+		    perm[i] = i;
+	    }
+
+            for (i = 0; i < n; ++i)
+            {
+                j = perm[i];
+                cubcopy[j][0] = cub[i][0] < 0 ? -1 : perm[cub[i][0]];
+                cubcopy[j][1] = cub[i][1] < 0 ? -1 : perm[cub[i][1]];
+                cubcopy[j][2] = cub[i][2] < 0 ? -1 : perm[cub[i][2]];
+            }
+
+            cubinit(cubcopy,eno,v1,v2,n,ne);
+            nodecount = 0;
+
+            for (i = 0; i < ne; ++i)
+                initclass[i] = DUNNO;
+
+            for (i = 0; i < nvv; ++i)
+                if (vv[i] < n) initclass[eno[perm[vv[i]]][vi[i]-1]] = NO;
+            for (i = 0; i < nyy; ++i)
+                if (yy[i] < n) initclass[eno[perm[yy[i]]][yi[i]-1]] = YES;
+
+            ch = cubham(cubcopy,eno,initclass,v1,v2,cyc,outclass,n,ne);
+            totalnodes += nodecount;
+            ++numtries[nmax/repeats];
+        }
+
+	if (cyc != NULL && ch == YES)
+	{
+	    for (i = 0; i < n; ++i)
+		pinv[perm[i]] = i;
+	    for (i = 0; i < n; ++i)
+		cyc[i] = pinv[cyc[i]];
+	}
+#endif
+
+        return ch;
+}
+
+/**************************************************************************/
+
+static int
+optadd(cubgraph cub, int v1, int v2)
+/* v1 and v2 must have degree 2 and be distinct.
+   Add edge v1-v2 if not already present; return index of edge in cub[v1]. */
+{
+    if (cub[v1][0] == v2) return 0;
+    if (cub[v1][1] == v2) return 1;
+    cub[v1][2] = v2;
+    cub[v2][2] = v1;
+    return 2;
+}
+
+/**************************************************************************/
+
+static void
+dofragment(nauty_counter id, cubgraph cub, int n, int ne, int weight)
+/* Test for coverage by one or two paths between vertices of degree 2 */
+{
+    int i,i1,i2,i3,i4;
+    int v1,v2,v3,v4,j1,j3;
+    int deg2[MAXN],ndeg2;
+    int yy[3],yi[3],newne;
+    int cyc[MAXN];
+    int status;
+
+    ndeg2 = 0;
+    for (i = 0; i < n; ++i)
+    {
+        if (cub[i][0] < 0 || cub[i][1] < 0)
+            gt_abort(">E -F forbids degree 0,1\n");
+
+	if (cub[i][2] < 0) deg2[ndeg2++] = i;
+    }
+
+    printf("Input " COUNTER_FMT ":",id);
+    for (i = 0; i < ndeg2; ++i) printf(" %d",deg2[i]);
+    printf("\n");
+
+    printf(" Pairs: ");
+    for (i1 = 0; i1 < ndeg2; ++i1)
+    for (i2 = i1+1; i2 < ndeg2; ++i2)
+    {
+	v1 = deg2[i1]; v2 = deg2[i2];
+	j1 = optadd(cub,v1,v2);
+	yy[0] = v1; yi[0] = j1+1;
+	newne = ne + (j1==2);
+	status = isham(cub,n,newne,weight,NULL,NULL,0,yy,yi,1,cyc);
+        if (status == HABORT)
+	    printf(" T%d-%d",v1,v2);
+        if (status == NO)
+	    printf(" N%d-%d",v1,v2);
+        else 
+        {
+	    printf(" Y%d-%d",v1,v2);
+            if (verbose > 1)
+	    {
+		printf("[");
+	        for (i = 0; i < n; ++i) printf(" %d",cyc[i]);
+	        printf("]\n");
+	    }
+        }
+	cub[v1][2] = cub[v2][2] = -1;
+    }
+    printf("\n");
+
+    printf(" Quartets: ");
+    for (i1 = 0; i1 < ndeg2; ++i1)
+    for (i2 = i1+1; i2 < ndeg2; ++i2)
+    for (i3 = i1+1; i3 < ndeg2; ++i3)
+    for (i4 = i3+1; i4 < ndeg2; ++i4)
+    {
+        if (i3 == i2 || i4 == i2) continue;
+
+	v1 = deg2[i1]; v2 = deg2[i2];
+	j1 = optadd(cub,v1,v2);
+	v3 = deg2[i3]; v4 = deg2[i4];
+	j3 = optadd(cub,v3,v4);
+	yy[0] = v1; yi[0] = j1+1;
+        yy[1] = v3; yi[1] = j3+1;
+	newne = ne + (j1==2) + (j3==2);
+	status = isham(cub,n,newne,weight,NULL,NULL,0,yy,yi,2,cyc);
+        if (status == HABORT)
+	    printf(" T%d-%d,%d-%d",v1,v2,v3,v4);
+        if (status == NO)
+	    printf(" N%d-%d,%d-%d",v1,v2,v3,v4);
+        else
+        {
+	    printf(" Y%d-%d,%d-%d",v1,v2,v3,v4);
+	    if (verbose > 1)
+	    {
+		printf("[");
+	        for (i = 0; i < n; ++i) printf(" %d",cyc[i]);
+	        printf("]\n");
+	    }
+        }
+	cub[v1][2] = cub[v2][2] = -1;
+	cub[v3][2] = cub[v4][2] = -1;
+    }
+    printf("\n");
+}
+
+/********************************************************************/
+
+static int
+hasinout(cubgraph cub,
+         int n, int ne, int *x0, int *x1, int *y0, int *y1, int limit)
+/* test if cub has in-out (+-) property */
+{
+	edgevec v1,v2,initclass,outclass;
+	set *d0,*di,*dii;
+	int i,ii,j,jj;
+	int me,nbad;
+        DYNALLSTAT(graph,done,done_sz);
+	
+	me = (ne + WORDSIZE - 1) / WORDSIZE;
+
+        DYNALLOC2(graph,done,done_sz,ne,me,"hasinout");
+
+	d0 = (set*)done;
+	EMPTYSET(d0,me);
+	for (j = 0; j < ne; ++j)
+	    ADDELEMENT(d0,j);
+
+	for (i = 1, di = d0 + me; i < ne; ++i, di += me)
+	{
+	    for (j = 0; j < me; ++j)
+		di[j] = d0[j];
+	    DELELEMENT(di,i);
+	}
+	DELELEMENT(d0,0);
+
+	cubinit(cub,eno,v1,v2,n,ne);
+	for (i = 0; i < ne; ++i)
+	    initclass[i] = DUNNO;
+
+	maxnodes = NO_LIMIT;
+	nbad = 0;
+
+	for (i = 0, di = (set*)done; i < ne; ++i, di += me)
+	    for (j = -1; (j = nextelement(di,me,j)) >= 0;)
+	    {
+		initclass[i] = NO;
+		initclass[j] = YES;
+		++numtries[0];
+		if (cubham(cub,eno,initclass,v1,v2,NULL,
+							outclass,n,ne) == NO)
+		{
+		    x0[nbad] = v1[i]; x1[nbad] = v2[i];
+		    y0[nbad] = v1[j]; y1[nbad] = v2[j];
+		    ++nbad;
+		    if (nbad >= limit) return nbad;
+		}
+		else
+		{
+                    for (ii = i, dii = di; ii < ne; ++ii, dii += me)
+                    if (outclass[ii] == NO)
+                        for (jj = 0; jj < ne; ++jj)
+                            if (outclass[jj] == YES)
+                                DELELEMENT(dii,jj);
+		}
+
+		initclass[i] = DUNNO;
+		initclass[j] = DUNNO;
+	    }
+
+	return nbad;
+}
+
+/**************************************************************************/
+
+static int
+hasinin(cubgraph cub,
+        int n, int ne, int *x0, int *x1, int *y0, int *y1, int limit)
+/* test if cub has in-in (++) property */
+{
+        edgevec v1,v2,initclass,outclass;
+	set *d0,*di,*dii;
+	int i,ii,j,jj;
+	int me,nbad;
+        DYNALLSTAT(graph,done,done_sz);
+	
+	me = (ne + WORDSIZE - 1) / WORDSIZE;
+
+        DYNALLOC2(graph,done,done_sz,ne,me,"hasinin");
+
+	d0 = (set*)done;
+	EMPTYSET(d0,me);
+	for (j = 0; j < ne; ++j)
+	    ADDELEMENT(d0,j);
+
+	for (i = 1, di = d0 + me; i < ne; ++i, di += me)
+	{
+	    for (j = 0; j < me; ++j)
+		di[j] = d0[j];
+	    DELELEMENT(di,i);
+	}
+	DELELEMENT(d0,0);
+
+	cubinit(cub,eno,v1,v2,n,ne);
+	for (i = 0; i < ne; ++i)
+	    initclass[i] = DUNNO;
+
+	maxnodes = NO_LIMIT;
+	nbad = 0;
+
+	for (i = 0, di = (set*)done; i < ne; ++i, di += me)
+	    for (j = i; (j = nextelement(di,me,j)) >= 0;)
+	    {
+		initclass[i] = YES;
+		initclass[j] = YES;
+		++numtries[0];
+		if (cubham(cub,eno,initclass,v1,v2,NULL,outclass,n,ne) == NO)
+		{
+                    x0[nbad] = v1[i]; x1[nbad] = v2[i];
+                    y0[nbad] = v1[j]; y1[nbad] = v2[j];
+                    ++nbad;
+                    if (nbad >= limit) return nbad;
+		}
+		else
+	 	{
+                    for (ii = i, dii = di; ii < ne; ++ii, dii += me)
+                    if (outclass[ii] == YES)
+                        for (jj = ii; jj < ne; ++jj)
+                            if (outclass[jj] == YES)
+                                DELELEMENT(dii,jj);
+		}
+
+		initclass[i] = DUNNO;
+		initclass[j] = DUNNO;
+	    }
+	return nbad;
+}
+
+/**************************************************************************/
+
+static int
+hasin(cubgraph cub, int n, int ne, int *x0, int *x1, int limit)
+/* test if cub has "in" property */
+{
+	edgevec v1,v2,initclass,outclass;
+	boolean done[MAXNE];
+	int i,ii;
+	int nbad;
+	
+	cubinit(cub,eno,v1,v2,n,ne);
+	for (i = 0; i < ne; ++i)
+	{
+	    initclass[i] = DUNNO;
+	    done[i] = FALSE;
+	}
+
+	maxnodes = NO_LIMIT;
+	nbad = 0;
+
+	for (i = 0; i < ne; ++i)
+	    if (!done[i])
+	    {
+		initclass[i] = YES;
+		++numtries[0];
+		if (cubham(cub,eno,initclass,v1,v2,NULL,outclass,n,ne) == NO)
+		{
+		    x0[nbad] = v1[i]; x1[nbad] = v2[i];
+		    ++nbad;
+		    if (nbad >= limit) return nbad;
+		}
+		else
+		{
+                    for (ii = i; ii < ne; ++ii)
+                    if (outclass[ii] == YES) done[ii] = TRUE;
+		}
+
+		initclass[i] = DUNNO;
+	    }
+	return nbad;
+}
+
+/**************************************************************************/
+
+static boolean
+eplus(cubgraph acub, int n, int ne, int x, int y, int *pwhy)
+{
+        cubgraph cub;
+        edgevec v1,v2,initclass;
+	int i,a,b,c,d,xy,why;
+
+	if (3*n != 2*ne)
+	{
+	    fprintf(stderr,
+		"cubhamg: eplus() not implemented for noncubic graphs\n");
+	    exit(1);
+	}
+
+        for (i = 0; i < n; ++i)
+        {
+            cub[i][0] = acub[i][0];
+            cub[i][1] = acub[i][1];
+            cub[i][2] = acub[i][2];
+        }
+
+	if      (cub[x][0] == y) 
+	{
+	    xy = 0;
+	    a = cub[x][1];
+	    b = cub[x][2];
+	}
+	else if (cub[x][1] == y)
+        {
+            xy = 1;
+            a = cub[x][0];
+            b = cub[x][2];
+        }
+	else
+        {
+            xy = 2;
+            a = cub[x][0];
+            b = cub[x][1];
+        }
+
+	if      (cub[y][0] == x)
+        {
+            c = cub[y][1];
+            d = cub[y][2];
+        }
+        else if (cub[y][1] == x)
+        {
+            c = cub[y][0];
+            d = cub[y][2];
+        }
+        else
+        {
+            c = cub[y][0];
+            d = cub[y][1];
+        }
+
+	for (i = 0; i < ne; ++i)
+	    initclass[i] = DUNNO;
+
+	why = 0;
+	cubinit(cub,eno,v1,v2,n,ne);
+	initclass[eno[x][xy]] = NO;
+	if (cubham(cub,eno,initclass,v1,v2,NULL,NULL,n,ne) == YES)
+	    why |= 1;
+	initclass[eno[x][xy]] = DUNNO;
+
+#define CHANGE(z,p,q) if (cub[z][0]==p) cub[z][0]=q;\
+     else if (cub[z][1]==p) cub[z][1]=q; else cub[z][2]=q;
+
+	CHANGE(x,b,c);
+	CHANGE(y,c,b);
+	CHANGE(b,x,y);
+	CHANGE(c,y,x);
+
+        cubinit(cub,eno,v1,v2,n,ne);
+        initclass[eno[x][xy]] = NO;
+        if (cubham(cub,eno,initclass,v1,v2,NULL,NULL,n,ne) == YES)
+            why |= 2;
+        initclass[eno[x][xy]] = DUNNO;
+
+	CHANGE(x,c,d);
+	CHANGE(y,d,c);
+	CHANGE(c,x,y);
+	CHANGE(d,y,x);
+
+        cubinit(cub,eno,v1,v2,n,ne);
+        initclass[eno[x][xy]] = NO;
+        if (cubham(cub,eno,initclass,v1,v2,NULL,NULL,n,ne) == YES)
+            why |= 4;
+
+	*pwhy = why;
+	return why == 7;
+}
+
+/**************************************************************************/
+
+static int
+hase34(cubgraph cub,
+       int n, int ne, int *x0, int *x1, int *why, boolean plus, int limit)
+/* test if cub has "e34" property */
+{
+	edgevec v1,v2,initclass,outclass;
+	int ea[4*MAXNE],eb[4*MAXNE],ec[4*MAXNE];
+	boolean done[4*MAXNE];
+	int count[MAXNE];
+	int i,ii;
+	int vi,nbad,pluswhy;
+	static int pop[] = {0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4};
+	
+	if (3*n != 2*ne)
+	{
+	    fprintf(stderr,
+		"cubhamg: hase34() not implemented for noncubic graphs\n");
+	    exit(1);
+	}
+	cubinit(cub,eno,v1,v2,n,ne);
+	for (i = 0; i < ne; ++i)
+	{
+	    initclass[i] = DUNNO;
+	    count[i] = 0;
+	}
+
+	for (i = ii = 0; i < ne; ++i)
+	{
+	    eb[ii] = eb[ii+1] = eb[ii+2] = eb[ii+3] = i;
+	    done[ii] = done[ii+1] = done[ii+2] = done[ii+3] = FALSE;
+	    
+	    vi = v1[i];
+	    if (eno[vi][0] != i) ea[ii++] = eno[vi][0];
+	    if (eno[vi][1] != i) ea[ii++] = eno[vi][1];
+	    if (eno[vi][2] != i) ea[ii++] = eno[vi][2];
+	    ea[ii] = ea[ii-2];
+	    ea[ii+1] = ea[ii-1];
+	
+	    vi = v2[i];
+            if (eno[vi][0] != i) ec[ii++] = eno[vi][0];
+            if (eno[vi][1] != i) ec[ii++] = eno[vi][1];
+            if (eno[vi][2] != i) ec[ii++] = eno[vi][2];
+            ec[ii-4] = ec[ii-3] = ec[ii-2]; 
+            ec[ii-2] = ec[ii-1];
+	}
+
+	maxnodes = NO_LIMIT;
+	nbad = 0;
+
+	for (i = 0; i < 4*ne; ++i)
+	    if (!done[i])
+	    {
+		initclass[ea[i]] = YES;
+		initclass[eb[i]] = YES;
+		initclass[ec[i]] = YES;
+		++numtries[0];
+		if (cubham(cub,eno,initclass,v1,v2,NULL,
+						outclass,n,ne) == YES)
+		    for (ii = i; ii < 4*ne; ++ii)
+			if (!done[ii] && outclass[ea[ii]] == YES &&
+			    outclass[eb[ii]] == YES && outclass[ec[ii]] == YES)
+			{
+			    done[ii] = TRUE;
+			    count[eb[ii]] |= 1 << (ii & 3);
+			}
+		++numtries[0];
+		initclass[ea[i]] = DUNNO;
+                initclass[eb[i]] = DUNNO;
+                initclass[ec[i]] = DUNNO;
+	    }
+
+	pluswhy = 0;
+	for (i = 0; i < ne; ++i)
+	    if (pop[count[i]] < 3 
+                && (!plus || !eplus(cub,n,ne,v1[i],v2[i],&pluswhy)))
+	    {
+                x0[nbad] = v1[i]; x1[nbad] = v2[i];
+		why[nbad] = (pluswhy << 4) | count[i];
+                ++nbad;
+                if (nbad >= limit) return nbad;
+            }
+
+	return nbad;
+}
+
+/**************************************************************************/
+
+#if 0
+static int
+oldhasout(cubgraph cub, int n, int ne, int *x0, int *x1, int limit)
+/* test if cub has "out" property */
+{
+        edgevec v1,v2,initclass,outclass;
+        boolean done[MAXNE];
+        int i,ii;
+        int nbad;
+        
+        cubinit(cub,eno,v1,v2,n,ne);
+        for (i = 0; i < ne; ++i)
+        {
+            initclass[i] = DUNNO;
+            done[i] = FALSE;
+        }
+ 
+        maxnodes = NO_LIMIT;
+	nbad = 0;
+ 
+        for (i = 0; i < ne; ++i)
+            if (!done[i])
+            {
+                initclass[i] = NO;
+                ++numtries[0];
+                if (cubham(cub,eno,initclass,v1,v2,NULL,outclass,n,ne) == NO)
+                {
+                    x0[nbad] = v1[i]; x1[nbad] = v2[i];
+                    ++nbad;
+                    if (nbad >= limit) return nbad;
+                }
+		else
+		{
+		    for (ii = i; ii < ne; ++ii)
+                    if (outclass[ii] == NO) done[ii] = TRUE;
+		}
+ 
+                initclass[i] = DUNNO;
+            }
+        return nbad;
+}
+#endif
+
+/**************************************************************************/
+
+static int
+hasout(cubgraph cub, int n, int ne, int weight, int *x0, int *x1, int limit)
+/* test if cub has "out" property 
+   Returns are -2 for timeout, -1 for nonhamiltonian, otherwise
+   number of edges not present in any cycle */
+{
+	cubgraph done;
+	int cyc[MAXN];
+        int vv[2],vi[2];
+        int nbad,ch;
+	int i,j,ii,jj,x,y,z;
+ 
+	nbad = 0;
+ 
+	for (i = 0; i < n; ++i) done[i][0] = done[i][1] = done[i][2] = 0;
+
+	ch = isham(cub,n,ne,weight,vv,vi,0,NULL,NULL,0,cyc);
+	if (ch == HABORT) return -2;
+	if (ch == NO) return -1;
+
+	for (i = 0; i < n; ++i)
+	{
+	    x = cyc[i];
+            y = cyc[i==n-1?0:i+1];
+	    z = cyc[i==0?n-1:i-1];
+	    for (j = 0; j < 3; ++j)
+		if (cub[x][j] >= 0 &&
+		    cub[x][j] != y && cub[x][j] != z) break;
+	    if (j < 3) done[x][j] = 1;
+	}
+
+	for (ii = 0; ii < n; ++ii)
+	for (jj = 0; jj < 3; ++jj)
+	{
+	    if (cub[ii][jj] > ii && !done[ii][jj])
+	    {
+		vv[0] = ii;
+		vi[0] = jj+1;
+		ch = isham(cub,n,ne,weight,vv,vi,1,NULL,NULL,0,cyc);
+                if (ch == HABORT) return -2;
+		if (ch == NO)
+		{
+		    x0[nbad] = ii;
+		    x1[nbad] = cub[ii][jj];
+		    ++nbad;
+		}
+		else
+		{
+		    for (i = 0; i < n; ++i)
+		    {
+	    	        x = cyc[i];
+            	        y = cyc[i==n-1?0:i+1];
+	    	        z = cyc[i==0?n-1:i-1];
+	    	        for (j = 0; j < 3; ++j)
+			    if (cub[x][j] >= 0 &&
+		    	    cub[x][j] != y && cub[x][j] != z) break;
+	    	        if (j < 3) done[x][j] = 1;
+		    }
+
+		}
+	    }
+	}
+
+        return nbad;
+}
+
+/**************************************************************************/
+
+static boolean
+biconnected_cub(cubgraph cub, int n)
+/* test whether cub is biconnected */
+{
+        int i,sp,v,w,x;
+        set visited[MAXM];
+        int numvis,num[MAXN],lp[MAXN],stack[MAXN];
+	int m,*gv;
+
+        if (n <= 2) return FALSE;
+
+	m = (n + WORDSIZE - 1) / WORDSIZE;
+	EMPTYSET(visited,m);
+	ADDELEMENT(visited,0);
+
+        stack[0] = 0;
+        num[0] = 0;
+        lp[0] = 0;
+        numvis = 1;
+        sp = 0;
+        v = 0;
+	gv = (int*)cub[v];
+
+        for (;;)
+        {
+	    for (i = 0; i < 3; ++i)
+		if (gv[i] >= 0 && !ISELEMENT(visited,gv[i])) break;
+
+            if (i < 3)
+            {
+                w = v;
+                v = gv[i];  /* visit next child */
+                stack[++sp] = v;
+		gv = (int*)cub[v];
+                ADDELEMENT(visited,v);
+                lp[v] = num[v] = numvis++;
+
+                for (i = 0; i < 3; ++i)
+		{
+		    x = gv[i];
+		    if (x >= 0 && x != w && ISELEMENT(visited,x))
+			if (num[x] < lp[v])  lp[v] = num[x];
+		}
+            }
+            else
+            {
+                w = v;                  /* back up to parent */
+                if (sp <= 1)          return numvis == n;
+                v = stack[--sp];
+		gv = (int*)cub[v];
+                if (lp[w] >= num[v])  return FALSE;
+                if (lp[w] < lp[v])    lp[v] = lp[w];
+            }
+        }
+}
+
+/**************************************************************************/
+
+static boolean
+biconnected_cub_v(cubgraph cub, int vv, int n)
+/* test whether cub-vv is biconnected */
+{
+        int i,sp,v,w,x,start;
+        set visited[MAXM];
+        int numvis,num[MAXN],lp[MAXN],stack[MAXN];
+	int m,*gv;
+
+        if (n <= 3) return FALSE;
+	start = (vv == 0 ? 1 : 0);
+
+	m = (n + WORDSIZE - 1) / WORDSIZE;
+	EMPTYSET(visited,m);
+	ADDELEMENT(visited,start);
+	ADDELEMENT(visited,vv);
+
+        stack[0] = start;
+        num[start] = 0;
+        lp[start] = 0;
+        numvis = 1;
+        sp = 0;
+        v = start;
+	gv = (int*)cub[v];
+
+        for (;;)
+        {
+	    for (i = 0; i < 3; ++i)
+		if (gv[i] >= 0 && !ISELEMENT(visited,gv[i])) break;
+
+            if (i < 3)
+            {
+                w = v;
+                v = gv[i];  /* visit next child */
+                stack[++sp] = v;
+		gv = (int*)cub[v];
+                ADDELEMENT(visited,v);
+                lp[v] = num[v] = numvis++;
+
+                for (i = 0; i < 3; ++i)
+		{
+		    x = gv[i];
+		    if (x >= 0 && x != w && x != vv && ISELEMENT(visited,x))
+			if (num[x] < lp[v])  lp[v] = num[x];
+		}
+            }
+            else
+            {
+                w = v;                  /* back up to parent */
+                if (sp <= 1)          return numvis == n-1;
+                v = stack[--sp];
+		gv = (int*)cub[v];
+                if (lp[w] >= num[v])  return FALSE;
+                if (lp[w] < lp[v])    lp[v] = lp[w];
+            }
+        }
+}
+
+/**************************************************************************/
+
+static boolean
+biconnected_v(graph *g, int vv, int m, int n)
+/* test whether g-vv is biconnected */
+/* version for arbitrary sizes */
+{
+        int i,sp,v,w;
+	setword ww;
+        set sw[MAXM],visited[MAXM];
+        int numvis,num[MAXN],lp[MAXN],stack[MAXN];
+	int start;
+	set *gv;
+
+        if (n <= 3) return FALSE;
+
+	start = vv == 0 ? 1 : 0;
+	EMPTYSET(visited,m);
+	ADDELEMENT(visited,start);
+	ADDELEMENT(visited,vv);
+
+        stack[0] = start;
+        num[start] = 0;
+        lp[start] = 0;
+        numvis = 1;
+        sp = 0;
+        v = start;
+	gv = (set*)g + m*v;
+
+        for (;;)
+        {
+	    for (i = 0; i < m; ++i)
+		if ((ww = gv[i] & ~visited[i])) break; /* = */
+
+            if (i < m)
+            {
+                w = v;
+                v = TIMESWORDSIZE(i) + FIRSTBIT(ww);   /* visit next child */
+                stack[++sp] = v;
+		gv = (set*)g + m*v;
+                ADDELEMENT(visited,v);
+                lp[v] = num[v] = numvis++;
+		for (i = 0; i < m; ++i)
+		    sw[i] = gv[i] & visited[i];
+		DELELEMENT(sw,w);
+		DELELEMENT(sw,vv);
+
+                for (i = 0; i < m; ++i)
+		{
+		    ww = sw[i];
+                    while (ww)
+                    {
+			TAKEBIT(w,ww);
+			w += TIMESWORDSIZE(i);
+                        if (num[w] < lp[v])  lp[v] = num[w];
+                    }
+		}
+            }
+            else
+            {
+                w = v;                  /* back up to parent */
+                if (sp <= 1)     return numvis == n-1;
+                v = stack[--sp];
+		gv = (set*)g + m*v;
+                if (lp[w] >= num[v])  return FALSE;
+                if (lp[w] < lp[v])    lp[v] = lp[w];
+            }
+        }
+}
+
+/**************************************************************************/
+
+static boolean
+triconnected_cub(cubgraph cub, int n)
+/* test whether triconnected; awfully inefficient */
+{
+	int vv;
+
+	if (n <= 3) return FALSE;
+
+	for (vv = n-1; --vv >= 0;)
+	    if (!biconnected_cub_v(cub,vv,n)) return FALSE;
+
+	return TRUE;
+}
+
+/**************************************************************************/
+
+static boolean
+gtocub(graph *g, int m, int n, cubgraph cub, int *pne)
+/* Convert nauty-format graph into cubgraph.  Returns FALSE if there
+ * are any vertices of degree 4 or more.
+ */
+{
+	int i,j,nde;
+	set *gi;
+
+	nde = 0;
+	for (i = 0, gi = (set*)g; i < n; ++i, gi += m)
+	{
+	    cub[i][0] = cub[i][1] = cub[i][2] = -1;
+	    j = nextelement(gi,m,-1);
+	    if (j < 0) continue;
+	    cub[i][0] = j;
+	    ++nde;
+	    j = nextelement(gi,m,j);
+            if (j < 0) continue;
+            cub[i][1] = j;
+	    ++nde;
+	    j = nextelement(gi,m,j);
+            if (j < 0) continue;
+            cub[i][2] = j;
+	    ++nde;
+	    if (nextelement(gi,m,j) >= 0) return FALSE;
+	}
+
+	*pne = nde / 2;
+	return TRUE;
+}
+
+/**************************************************************************/
+
+static boolean
+sgtocub(sparsegraph *sg, cubgraph cub, int *pne)
+/* Convert sparse-format graph into cubgraph.  Returns FALSE if there
+ * are any vertices of degree 4 or more.
+ */
+{
+	int *d,*e;
+	size_t *v;
+	int n,i,j,vi;
+	unsigned long int nde;
+
+	nde = 0;
+	n = sg->nv;
+	SG_VDE(sg,v,d,e);
+	for (i = 0; i < n; ++i)
+	{
+	    if (d[i] >= 4) return FALSE;
+	    vi = v[i];
+
+	    cub[i][0] = cub[i][1] = cub[i][2] = -1;
+	    for (j = 0; j < d[i]; ++j)
+	       cub[i][j] = e[vi+j];
+	    nde += d[i];
+	}
+
+	*pne = nde / 2;
+	return TRUE;
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+        char *infilename,*outfilename;
+        FILE *infile,*outfile,*msgfile;
+        boolean badargs,biconn,triconn,fragment;
+	boolean in,out,inin,inout,e34,e34plus,testing;
+        nauty_counter numread,noncub,nonham,nonconn,numto;
+        int ch,weight,m,n,ne,i,namesgot,nl;
+	int nbad,limit,x0[BADLIM],x1[BADLIM],y0[BADLIM],y1[BADLIM];
+	sparsegraph sg;
+	int vv[MAXA],vi[MAXA],nvv,cyc[MAXN];
+        int yy[MAXA],yi[MAXA],nyy;
+	double t0,t1;
+	cubgraph cub;
+        char *arg;
+	int codetype;
+
+        infilename = outfilename = NULL;
+        badargs = FALSE;
+	e34plus = e34 = in = out = inin = inout = FALSE;
+	fragment = biconn = triconn = testing = FALSE;
+	verbose = 0;
+	weight = 100;
+	nvv = nyy = 0;
+	timeout = 0;
+	repeats = 1;
+
+     /* parse argument list */
+
+        namesgot = 0;
+        for (i = 1; i < argc && !badargs; ++i)
+        {
+            arg = argv[i];
+            if (arg[0] == '-' && arg[1] != '\0')
+            {
+                if (arg[1] == 'v')
+                    verbose = (verbose == 0 ? 1 : verbose);
+		else if (arg[1] == 'V')
+		    verbose = 2;
+                else if (arg[1] == 'i')
+                    in = TRUE;
+                else if (arg[1] == 'I')
+                    inin = TRUE;
+                else if (arg[1] == 'o')
+                    out = TRUE;
+		else if (arg[1] == 'x')
+		    inout = TRUE;
+		else if (arg[1] == 'e')
+		    e34 = TRUE;
+		else if (arg[1] == 'E')
+		    e34 = e34plus = TRUE;
+                else if (arg[1] == 'b')
+                    biconn = TRUE;
+                else if (arg[1] == 't')
+                    triconn = TRUE;
+                else if (arg[1] == 'Q')
+                    testing = TRUE;
+                else if (arg[1] == 'F')
+                    fragment = TRUE;
+		else if (arg[1] == 'n')
+		{
+		    if (nvv == MAXA)
+		    {
+			fprintf(stderr,">E cubhamg : too many -n switches\n");
+			exit(1);
+		    }
+		    if (sscanf(arg+2,"%d-%d",&vv[nvv],&vi[nvv]) != 2)
+			badargs = TRUE;
+		    else if (vi[nvv] < 1 || vi[nvv] > 3)
+		    {
+			fprintf(stderr,
+                               ">E cubhamg : second arg of -n must be 1..3\n");
+			exit(1);
+		    }
+		    ++nvv;
+		}
+		else if (arg[1] == 'y')
+		{
+		    if (nyy == MAXA)
+		    {
+			fprintf(stderr,">E cubhamg : too many -y switches\n");
+			exit(1);
+		    }
+		    if (sscanf(arg+2,"%d-%d",&yy[nyy],&yi[nyy]) != 2)
+			badargs = TRUE;
+		    else if (yi[nyy] < 1 || yi[nyy] > 3)
+		    {
+			fprintf(stderr,
+                               ">E cubhamg : second arg of -y must be 1..3\n");
+			exit(1);
+		    }
+		    ++nyy;
+		}
+		else if (arg[1] >= '0' && arg[1] <= '9')
+		    sscanf(arg+1,"%d",&weight);
+		else if (arg[1] == 'T')
+		{
+		    if (sscanf(arg+2,"%ld",&timeout) != 1 || timeout < 0)
+		    {
+			fprintf(stderr,">E cubhamg : bad -T value\n");
+			exit(1);
+		    }
+		    else if (timeout > NO_LIMIT-1)
+			timeout = NO_LIMIT - 1;
+		}
+		else if (arg[1] == 'R')
+		{
+		    if (sscanf(arg+2,"%ld",&repeats) != 1 || repeats < 1)
+		    {
+			fprintf(stderr,">E cubhamg : bad -R value\n");
+			exit(1);
+		    }
+		}
+		else
+		    badargs = TRUE;
+            }
+            else
+            {
+                if (namesgot == 0)
+                {
+                    namesgot = 1;
+                    infilename = arg;
+                }
+                else if (namesgot == 1)
+                {
+                    namesgot = 2;
+                    outfilename = arg;
+                }
+                else
+                    badargs = TRUE;
+            }
+        }
+
+	if (badargs)
+	{
+	    fprintf(stderr,
+         ">E Usage: cubhamg [-#] [-v | -V] [-n#-#] [-y#-#] [infile [outfile]]\n");
+	    exit(1);
+	}
+
+     /* open input file */
+
+        if (infilename && infilename[0] == '-') infilename = NULL;
+        infile = opengraphfile(infilename,&codetype,FALSE,1);
+        if (!infile) exit(1);
+        if (!infilename) infilename = "stdin";
+ 
+        if (infilename == NULL) infilename = "stdin";
+
+        NODIGRAPHSYET(codetype);
+
+     /* open output file */
+
+        if (outfilename == NULL || outfilename[0] == '-')
+        {
+            outfile = stdout;
+            outfilename = "stdout";
+            msgfile = stderr;
+        }
+        else
+        {
+            msgfile = stdout;
+            if ((outfile = fopen(outfilename,"w")) == NULL)
+            {
+                fprintf(stderr,
+                    ">E cubhamg: can't open %s for writing\n",outfilename);
+                ABORT(">E cubhamg");
+            }
+        }
+
+	if (triconn) biconn = FALSE;
+	if (e34) in = out = inin = inout = FALSE;
+	if (inout) in = out = inin = FALSE;
+	if (inin) in = out = FALSE;
+	if (out) in = FALSE;
+	if (testing) out = TRUE;
+
+	if (codetype&HAS_HEADER)
+        {
+            if (codetype&SPARSE6) writeline(outfile,SPARSE6_HEADER);
+            else                  writeline(outfile,GRAPH6_HEADER);
+        }
+
+//if (codetype&SPARSE6) outproc = writes6;
+//else                  outproc = writeg6;
+
+	numread = noncub = nonham = nonconn = 0;
+	numto = 0;
+	INITRANBYTIME;
+	t0 = CPUTIME;
+
+	limit = verbose ? BADLIM : 1;
+
+	SG_INIT(sg);
+	while (read_sg(infile,&sg))
+	{
+	    ++numread;
+	    n = sg.nv;
+
+	    if (n >= MAXN-1)
+	    {
+		fprintf(stderr,
+                    ">E cubhamg: input " COUNTER_FMT " too big\n",numread);
+		exit(1);
+	    }
+#if MAXM==1
+	    if (3*n >= 2*WORDSIZE)
+	    {
+		fprintf(stderr,
+                    ">E cubhamg: must compile with MAXM>1 for ne>WORDSIZE\n");
+		exit(1);
+	    }
+#endif
+
+	    if (!sgtocub(&sg,cub,&ne))
+	    {
+		if (verbose)
+		    fprintf(msgfile,"Input " COUNTER_FMT
+                                    " has maxdeg>3.\n",numread);
+		++noncub;
+	    }
+	    else if (biconn && !biconnected_cub(cub,n))
+		++nonconn;
+	    else if (triconn && !triconnected_cub(cub,n))
+		++nonconn;
+            else if (e34)
+            {
+                if ((nbad = hase34(cub,n,ne,x0,x1,y0,e34plus,limit)) > 0)
+                {
+                    if (verbose)
+		    {
+                        fprintf(msgfile,"Input " COUNTER_FMT
+                                        " fails property e34%s:",
+                                               numread,e34plus ? "+" : "");
+			if (e34plus)
+			    for (i = 0; i < nbad; ++i)
+			        fprintf(msgfile," %d-%d[%02x]",
+						x0[i],x1[i],y0[i]);
+			else
+			    for (i = 0; i < nbad; ++i)
+			        fprintf(msgfile," %d-%d",x0[i],x1[i]);
+			fprintf(msgfile,"\n");
+		    }
+                    ++nonham;
+                    writelast(outfile);
+                }
+            }
+	    else if (inout)
+	    {
+		if ((nbad = hasinout(cub,n,ne,x0,x1,y0,y1,limit)) > 0)
+		{
+		    if (verbose)
+                    { 
+                        fprintf(msgfile,"Input " COUNTER_FMT
+                                        " fails property -+:",numread);
+                        for (i = 0; i < nbad; ++i) 
+                            fprintf(msgfile," %d-%d/%d-%d",
+				    x0[i],x1[i],y0[i],y1[i]); 
+                        fprintf(msgfile,"\n");
+                    }
+		    ++nonham;
+                    writelast(outfile);
+		}
+	    }
+            else if (inin)
+            {
+                if ((nbad = hasinin(cub,n,ne,x0,x1,y0,y1,limit)) > 0)
+                {
+                    if (verbose)
+		    {  
+                        fprintf(msgfile,"Input " COUNTER_FMT
+                                        " fails property ++:",numread); 
+                        for (i = 0; i < nbad; ++i) 
+                            fprintf(msgfile," %d-%d/%d-%d",
+                                    x0[i],x1[i],y0[i],y1[i]);
+                        fprintf(msgfile,"\n"); 
+                    }
+                    ++nonham;
+                    writelast(outfile);
+                }
+            }
+            else if (out)
+            { 
+                if ((nbad = hasout(cub,n,ne,weight,x0,x1,limit)) != 0)
+                { 
+                    if (verbose) 
+		    {
+			if (nbad == -2)
+                            fprintf(msgfile,"Input " COUNTER_FMT
+                                        " timed out\n",numread);
+			else if (nbad == -1)
+                            fprintf(msgfile,"Input " COUNTER_FMT
+                                        " is nonhamiltonian\n",numread);
+			else
+			{
+                            fprintf(msgfile,"Input " COUNTER_FMT
+                                            " fails property -:",numread);
+                            for (i = 0; i < nbad; ++i)
+                                fprintf(msgfile," %d-%d",x0[i],x1[i]);
+                            fprintf(msgfile,"\n");
+		 	}
+                    }
+		    if (nbad != -1)
+		    {
+                        ++nonham; 
+                        writelast(outfile);
+		    }
+                } 
+            }
+            else if (in)
+            {
+                if ((nbad = hasin(cub,n,ne,x0,x1,limit)) > 0)
+                {
+                    if (verbose)
+                    {    
+                        fprintf(msgfile,"Input " COUNTER_FMT
+                                        " fails property +:",numread); 
+                        for (i = 0; i < nbad; ++i) 
+                            fprintf(msgfile," %d-%d",x0[i],x1[i]); 
+                        fprintf(msgfile,"\n"); 
+                    }
+                    ++nonham;
+                    writelast(outfile);
+                }
+            }
+	    else if (fragment)
+            {
+		dofragment(numread,cub,n,ne,weight);
+            }
+	    else if ((ch = isham(cub,n,ne,weight,vv,vi,nvv,yy,yi,nyy,cyc)) == NO)
+	    {
+	   	if (verbose)
+                    fprintf(msgfile,"Input " COUNTER_FMT
+                                    " is not hamiltonian.\n",numread);
+                ++nonham;
+		writelast(outfile);
+	    }
+	    else if (ch == HABORT)
+	    {
+                if (verbose)
+                    fprintf(msgfile,"Input " COUNTER_FMT " timed out.\n",numread);
+                ++numto;
+                 writelast(outfile);
+            }
+	    else if (verbose >= 2)
+	    {
+		fprintf(msgfile,"Cycle in input " COUNTER_FMT ":\n",numread);
+		if (n <= 100) nl = 26;
+		else          nl = 19;
+		for (i = 0; i < n; ++i)
+	 	{
+		    if (i > 0 && i % nl == 0) fprintf(msgfile,"\n ");
+		    fprintf(msgfile," %d",cyc[i]);
+		}
+		fprintf(msgfile,"\n");
+	    }
+	}
+	t1 = CPUTIME;
+
+	fprintf(msgfile,">C " COUNTER_FMT
+                        " graphs read from %s\n",numread,infilename);
+	if (noncub > 0)
+	    fprintf(msgfile,">C " COUNTER_FMT " graphs with maxdeg > 3\n",noncub);
+	if (nonconn > 0)
+	    fprintf(msgfile,">C " COUNTER_FMT " graphs not %sconnected\n",
+			    nonconn,biconn ? "bi" : "tri");
+	if (numto > 0)
+	    fprintf(msgfile,">C " COUNTER_FMT " graphs timed out\n",numto);
+	fprintf(msgfile,
+ 	    ">Z " COUNTER_FMT " %s graphs written to %s; %3.2f sec\n",
+              nonham+numto, e34 ? (e34plus ? "non-e34+" : "non-e34") :
+	            inout ? "non-inout" : 
+                        out ? "non-out" :
+		            in ? "non-in" : "nonhamiltonian",
+                outfilename,t1-t0);
+	if (verbose)
+	{
+	    fprintf(msgfile,"Tries:"); 
+	    for (i = 0; i <= NUMMAXNODES && numtries[i] > 0; ++i)
+		fprintf(msgfile," " COUNTER_FMT,numtries[i]);
+	    fprintf(msgfile,"\n");
+	}
+#if MAXES
+	fprintf(msgfile,"Maximum level = %d; Maximum classstack = %d\n",
+		maxlevel,maxclassstack);
+#endif
+
+	return 0;
+}
diff --git a/lib/nauty/deledgeg.c b/lib/nauty/deledgeg.c
new file mode 100644
index 0000000..4e69863
--- /dev/null
+++ b/lib/nauty/deledgeg.c
@@ -0,0 +1,218 @@
+/* deledgeg.c  version 1.4; B D McKay, Jan 2015. */
+
+#define USAGE "deledgeg [-lq] [-d#] [-z] [infile [outfile]]"
+
+#define HELPTEXT \
+" For each edge e, output G-e\n\
+\n\
+    The output file has a header if and only if the input file does.\n\
+\n\
+    -z  Consider as digraph and delete directed edges\n\
+    -l  Canonically label outputs\n\
+    -d# Specify a lower bound on the minimum out-degree of the output\n\
+    -q  Suppress auxiliary information\n"
+
+/*************************************************************************/
+
+#include "gtools.h" 
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    char *infilename,*outfilename;
+    FILE *infile,*outfile;
+    boolean badargs,dolabel,quiet,dswitch;
+    boolean digraph;
+    int i,j,m,n,v,w,argnum;
+    int codetype,outcode;
+    graph *g,*gq;
+    nauty_counter nin,nout;
+    char *arg,sw;
+    setword *gv,*gw;
+    int mindeg,actmindeg,degv;
+    boolean zswitch;
+    double t;
+#if MAXN
+    graph h[MAXN*MAXM];
+    int deg[MAXN];
+#else
+    DYNALLSTAT(graph,h,h_sz);
+    DYNALLSTAT(int,deg,deg_sz);
+#endif
+
+    HELP; PUTVERSION;
+
+    infilename = outfilename = NULL;
+    badargs = FALSE;
+    zswitch = dswitch = dolabel = quiet = FALSE;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('l',dolabel)
+                else SWBOOLEAN('z',zswitch)
+                else SWBOOLEAN('q',quiet)
+                else SWINT('d',dswitch,mindeg,">E deledgeg -d")
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if (!quiet)
+    {
+        fprintf(stderr,">A deledgeg");
+	if (dolabel || zswitch) fprintf(stderr," -");
+        if (dolabel) fprintf(stderr,"l");
+        if (zswitch) fprintf(stderr,"z");
+        if (dswitch) fprintf(stderr," -d%d",mindeg);
+        if (argnum > 0) fprintf(stderr," %s",infilename);
+        if (argnum > 1) fprintf(stderr," %s",outfilename);
+        fprintf(stderr,"\n");
+        fflush(stderr);
+    }
+
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,FALSE,1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    if (!outfilename || outfilename[0] == '-')
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename,"w")) == NULL)
+    {
+        fprintf(stderr,"Can't open output file %s\n",outfilename);
+        gt_abort(NULL);
+    }
+
+    if      (codetype&SPARSE6)  outcode = SPARSE6;
+    else if (codetype&DIGRAPH6) outcode = DIGRAPH6;
+    else                        outcode = GRAPH6;
+
+    if (codetype&HAS_HEADER)
+    {
+        if (outcode == SPARSE6)       writeline(outfile,SPARSE6_HEADER);
+        else if (outcode == DIGRAPH6) writeline(outfile,DIGRAPH6_HEADER);
+        else                          writeline(outfile,GRAPH6_HEADER);
+    }
+    if (!dswitch) mindeg = 0;
+
+    if (dolabel) nauty_check(WORDSIZE,1,1,NAUTYVERSIONID);
+
+    nin = nout = 0;
+    t = CPUTIME;
+    while (TRUE)
+    {
+        if ((g = readgg(infile,NULL,0,&m,&n,&digraph)) == NULL) break;
+        ++nin;
+
+#if !MAXN
+        DYNALLOC1(int,deg,deg_sz,n,"deledgeg");
+#endif
+
+        actmindeg = n;
+        for (v = 0, gv = g; v < n; ++v, gv += m)
+        {
+            degv = 0;
+            for (i = 0; i < m; ++i)
+                degv += POPCOUNT(gv[i]);
+            if (degv < actmindeg) actmindeg = degv;
+            deg[v] = degv;
+        }
+
+        if (actmindeg < mindeg) continue;
+
+	if (zswitch || digraph)
+	{
+            for (v = 0, gv = g; v < n; ++v, gv += m)
+            {
+                if (deg[v] <= mindeg) continue;
+    
+                for (w = -1; (w = nextelement(gv,m,w)) >= 0; )
+                {
+                    DELELEMENT(gv,w);
+                    gq = g;
+            
+                    if (dolabel)
+                    {
+#if !MAXN
+                        DYNALLOC2(graph,h,h_sz,n,m,"deledgeg");
+#endif
+                        fcanonise(g,m,n,h,NULL,TRUE);
+                        gq = h;
+                    }
+                    writed6(outfile,gq,m,n);
+                    ++nout;
+                    ADDELEMENT(gv,w);
+                }
+            }
+        }
+	else
+	{
+            for (v = 0, gv = g; v < n; ++v, gv += m)
+            {
+                if (deg[v] <= mindeg) continue;
+    
+                for (w = v-1; (w = nextelement(gv,m,w)) >= 0; )
+                {
+                    if (deg[w] <= mindeg || (w == v && deg[w] <= mindeg+1)) continue;
+    
+                    gw = GRAPHROW(g,w,m);
+                    DELELEMENT(gv,w);
+                    DELELEMENT(gw,v);
+                    gq = g;
+            
+                    if (dolabel)
+                    {
+#if !MAXN
+                        DYNALLOC2(graph,h,h_sz,n,m,"deledgeg");
+#endif
+                        fcanonise(g,m,n,h,NULL,FALSE);
+                        gq = h;
+                    }
+                    if (outcode == SPARSE6) writes6(outfile,gq,m,n);
+                    else                    writeg6(outfile,gq,m,n);
+                    ++nout;
+                    ADDELEMENT(gv,w);
+                    ADDELEMENT(gw,v);
+                }
+            }
+        }
+        FREES(g);
+    }
+    t = CPUTIME - t;
+
+    if (!quiet)
+        fprintf(stderr,
+          ">Z  " COUNTER_FMT " graphs read from %s, "
+                      COUNTER_FMT " written to %s; %3.2f sec.\n",
+                nin,infilename,nout,outfilename,t);
+
+    exit(0);
+}
diff --git a/lib/nauty/delptg.c b/lib/nauty/delptg.c
new file mode 100644
index 0000000..8c1c05d
--- /dev/null
+++ b/lib/nauty/delptg.c
@@ -0,0 +1,263 @@
+/* delptg.c  version 2.0; B D McKay, Jul 2015. */
+
+#define USAGE "delptg [-lq] [-d#|d#:#] [-n#] [infile [outfile]]"
+
+#define HELPTEXT \
+" Delete some vertices from a file of graphs.\n\
+\n\
+    The output file has a header if and only if the input file does.\n\
+    No isomorph reduction is done.\n\
+\n\
+    -l  Canonically label outputs\n\
+    -d# -d#:# Only remove vertices with original degree in the given range\n\
+        For digraphs, the out-degree is used.\n\
+    -n# The number of vertices to delete (default 1).\n\
+        Inputs that are too small are ignored; no empty graphs are output.\n\
+    -q  Suppress auxiliary information\n"
+
+/*************************************************************************/
+
+#include "gtools.h" 
+
+static FILE *outfile;
+static nauty_counter nout;
+static int outcode;
+static boolean digraph,dolabel;
+
+/**************************************************************************/
+
+static void
+writeone(graph *g, int m, int n, int *del, int ndel)
+/* Delete the stated vertices and write */
+{
+    int i,j,k,nx,mx;
+    graph *gi,*gxi,*gq;
+#if MAXN
+    graph gx[MAXN*MAXM];
+    graph hx[MAXN*MAXM];
+    int lab[MAXN];
+#else
+    DYNALLSTAT(graph,gx,gx_sz);
+    DYNALLSTAT(graph,hx,hx_sz);
+    DYNALLSTAT(int,lab,lab_sz);
+#endif
+
+    nx = n - ndel;    /* Always positive */
+    mx = SETWORDSNEEDED(nx);
+
+#if !MAXN
+    DYNALLOC2(graph,gx,gx_sz,mx,nx,"delptg");
+    if (dolabel) DYNALLOC2(graph,hx,hx_sz,mx,nx,"delptg");
+    DYNALLOC1(int,lab,lab_sz,nx,"delptg");
+#endif
+
+    j = 0;
+    for (i = 0; i < del[0]; ++i) lab[j++] = i;
+    for (k = 1; k < ndel; ++k)
+	for (i = del[k-1]+1; i < del[k]; ++i) lab[j++] = i;
+    for (i = del[ndel-1]+1; i < n; ++i) lab[j++] = i;
+
+    EMPTYSET(gx,nx*(size_t)mx);
+
+    for (i = 0, gxi = (set*)gx; i < nx; ++i, gxi += mx)
+    {
+	gi = GRAPHROW(g,lab[i],m);
+	for (j = 0; j < nx; ++j)
+	{
+	    k = lab[j];
+            if (ISELEMENT(gi,k)) ADDELEMENT(gxi,j);
+	}
+    }
+
+    if (dolabel)
+    {
+     	fcanonise(gx,mx,nx,hx,NULL,digraph);
+    	gq = hx;
+    }
+    else
+	gq = gx;
+
+    if (outcode == DIGRAPH6 || digraph) writed6(outfile,gq,mx,nx);
+    else if (outcode == SPARSE6)        writes6(outfile,gq,mx,nx);
+    else                                writeg6(outfile,gq,mx,nx);
+    ++nout;
+}
+
+/**************************************************************************/
+
+static void
+search(int level, int ndel, int *del, graph *g, int m, int n, boolean *degok)
+{
+    int i;
+
+    if (level == ndel)
+    {
+	writeone(g,m,n,del,ndel);
+	return;
+    }
+
+    for (i = (level == 0 ? 0 : del[level-1]+1); i <= n-ndel+level; ++i)
+	if (degok[i])
+	{
+	    del[level] = i;
+	    search(level+1,ndel,del,g,m,n,degok);
+        }
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    char *infilename,*outfilename;
+    FILE *infile;
+    boolean badargs,quiet,dswitch,nswitch;
+    int i,j,m,n,v,argnum;
+    int ndel;
+    int codetype;
+    graph *g;
+    nauty_counter nin;
+    char *arg,sw;
+    setword *gv;
+    long mindeg,maxdeg;
+    int degv;
+    double t;
+#if MAXN
+    boolean degok[MAXN];
+    boolean del[MAXN];
+#else
+    DYNALLSTAT(boolean,degok,degok_sz);
+    DYNALLSTAT(boolean,del,del_sz);
+#endif
+
+    HELP; PUTVERSION;
+
+    infilename = outfilename = NULL;
+    badargs = FALSE;
+    dswitch = nswitch = quiet = FALSE;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+    	    ++arg;
+    	    while (*arg != '\0')
+    	    {
+    	        sw = *arg++;
+    	             SWBOOLEAN('l',dolabel)
+    	        else SWBOOLEAN('q',quiet)
+		else SWINT('n',nswitch,ndel,">E delptg -n")
+                else SWRANGE('d',":-",dswitch,mindeg,maxdeg,">E delptg -d")
+    	        else badargs = TRUE;
+    	    }
+        }
+        else
+        {
+    	    ++argnum;
+    	    if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+    	    else                  badargs = TRUE;
+        }
+    }
+
+    if (nswitch && ndel < 1) gt_abort(">E delptg: bad argument for -n\n");
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if (!quiet)
+    {
+        fprintf(stderr,">A delptg");
+        if (dolabel) fprintf(stderr," -l");
+        if (dswitch) fprintf(stderr," -d%ld:%ld",mindeg,maxdeg);
+        if (nswitch) fprintf(stderr," -n%d",ndel);
+        if (argnum > 0) fprintf(stderr," %s",infilename);
+        if (argnum > 1) fprintf(stderr," %s",outfilename);
+        fprintf(stderr,"\n");
+        fflush(stderr);
+    }
+
+    if (!dswitch)
+    {
+	mindeg = 0;
+	maxdeg = NAUTY_INFINITY;
+    }
+
+    if (!nswitch) ndel = 1;
+
+    if (dolabel) nauty_check(WORDSIZE,1,1,NAUTYVERSIONID);
+
+    nin = nout = 0;
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,FALSE,1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    if (!outfilename || outfilename[0] == '-')
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename,"w")) == NULL)
+    {
+        fprintf(stderr,"Can't open output file %s\n",outfilename);
+        gt_abort(NULL);
+    }
+
+    if (codetype&SPARSE6)       outcode = SPARSE6;
+    else if (codetype&DIGRAPH6) outcode = DIGRAPH6;
+    else                        outcode = GRAPH6;
+
+    if (codetype&HAS_HEADER)
+    {
+        if (outcode == SPARSE6)       writeline(outfile,SPARSE6_HEADER);
+        else if (outcode == DIGRAPH6) writeline(outfile,DIGRAPH6_HEADER);
+        else    	              writeline(outfile,GRAPH6_HEADER);
+    }
+
+    t = CPUTIME;
+    while (TRUE)
+    {
+        if ((g = readgg(infile,NULL,0,&m,&n,&digraph)) == NULL) break;
+        ++nin;
+
+        if (n <= ndel)
+        {
+	    FREES(g);
+	    continue;
+        }
+
+#if !MAXN
+        DYNALLOC1(boolean,degok,degok_sz,n,"delptg");
+        DYNALLOC1(int,del,del_sz,n,"delptg");
+#endif
+
+        for (v = 0, gv = g; v < n; ++v, gv += m)
+        {
+    	    degv = 0;
+    	    for (i = 0; i < m; ++i)
+    	        degv += POPCOUNT(gv[i]);
+    	    degok[v] = (degv >= mindeg) && (degv <= maxdeg);
+        }
+
+	search(0,ndel,del,g,m,n,degok);
+
+        FREES(g);
+    }
+    t = CPUTIME - t;
+
+    if (!quiet)
+        fprintf(stderr,
+             ">Z  " COUNTER_FMT " graphs read from %s, "
+                    COUNTER_FMT " written to %s; %3.2f sec.\n",
+             nin,infilename,nout,outfilename,t);
+
+    exit(0);
+}
diff --git a/lib/nauty/directg.c b/lib/nauty/directg.c
new file mode 100644
index 0000000..cb609c3
--- /dev/null
+++ b/lib/nauty/directg.c
@@ -0,0 +1,738 @@
+/* directg.c version 2.0; B D McKay, June 19, 2015 */
+
+#define USAGE \
+  "directg [-q] [-u|-T|-G] [-V] [-o] [-f#] [-e#|-e#:#] [-s#/#] [infile [outfile]]"
+
+#define HELPTEXT \
+" Read undirected graphs and orient their edges in all possible ways.\n\
+  Edges can be oriented in either or both directions (3 possibilities).\n\
+  Isomorphic directed graphs derived from the same input are suppressed.\n\
+  If the input graphs are non-isomorphic then the output graphs are also.\n\
+\n\
+   -e# | -e#:#  specify a value or range of the total number of arcs\n\
+    -o     orient each edge in only one direction, never both\n\
+   -f#  Use only the subgroup that fixes the first # vertices setwise\n\
+\n\
+    -T  use a simple text output format (nv ne edges) instead of digraph6\n\
+    -G  like -T but includes group size as third item (if less than 10^10)\n\
+          The group size does not include exchange of isolated vertices.\n\
+    -V  only output graphs with nontrivial groups (including exchange of\n\
+          isolated vertices).  The -f option is respected.\n\
+    -u  no output, just count them\n\
+    -s#/#  Make only a fraction of the orientations: The first integer is\n\
+            the part number (first is 0) and the second is the number of\n\
+            parts. Splitting is done per input graph independently.\n\
+    -q  suppress auxiliary information\n"
+
+/* NOTE: Do not use nauty1.* for this program! */
+
+/*************************************************************************/
+
+#include "gtools.h"
+#include "naugroup.h"
+
+nauty_counter dg_nin,dg_ngen,dg_nout,dg_skipped; 
+
+FILE *outfile;
+
+#define MAXNV 128 
+#define MAXNE 1024
+static int v0[MAXNE],v1[MAXNE];
+static int edgeno[MAXNV][MAXNV];
+
+#define MAXME ((2*MAXNE+WORDSIZE-1)/WORDSIZE)
+
+static set x[MAXME];
+static int ix[2*MAXNE],nix;
+static boolean first;
+static int me;
+static int lastreject[MAXNV];
+static boolean lastrejok;
+static int rejectlevel;
+static unsigned long groupsize;
+static unsigned long newgroupsize;
+static boolean Gswitch,Vswitch,ntgroup,ntisol,digraph6;
+
+static int splitlevel,splitmod,splitres,splitcount;
+static unsigned long splitcases;
+
+/* DEGPRUNE feature 
+ *
+ * If DEGPRUNE is defined it must have a value equal to the name of a 
+ * procedure to be supplied by the user and linked to this program.
+ * The prototype must be
+ *     int DEGPRUNE(int *indeg, int outdeg*, int v, int n)
+ * Here n is the number of vertices altogether, and v (0..n-1) is the
+ * number of one vertex.  At this point in the program, some directed
+ * edges have been inserted, and the indegrees and outdegrees have the
+ * values given in indeg[] and outdeg[].  Moreover, it is known that
+ * no further edges will be added to or from v, so indeg[v] and outdeg[v]
+ * are final.  If DEGPRUNE returns a non-zero value, this branch of the
+ * search will be abandoned.
+ * Before any graph is output, DEGPRUNE will have been called for every
+ * vertex, but it cannot be assumed that DEGPRUNE will be called in order
+ * of vertex number.
+ */
+
+/* INPUTGRAPH feature
+ *
+ * If INPUTGRAPH is defined, it must expand as the name of a procedure
+ * with prototype like  int INPUTGRAPH(graph *g, int m, int n).
+ * This procedure will be called for each input graph before it is 
+ * processed. The graph will be skipped if the value 0 is returned.
+ */
+
+/* PROCESS feature
+ *
+ * If PROCESS is defined, it must expand as the name of a procedure
+ * with prototype like void PROCESS(FILE *f, graph *g, int n). This
+ * procedure will be called for each output graph before it is output,
+ * with f being the output file (possibly NULL).
+ * It is an error if n > WORDSIZE.
+ */
+
+/* SUMMARY feature
+ *
+ * If SUMMARY is defined, it must expand as the name of a procedure
+ * with prototype  void SUMMARY(void).  It is called at the end before
+ * the normal summary (which can be suppressed with -q).  The numbers of
+ * graphs read and digraphs produced are available in the global variables
+ * dg_nin and dg_nout (type nauty_counter).
+ */
+
+#ifdef DEGPRUNE
+static int lastlev[MAXNV],indeg[MAXNV],outdeg[MAXNV];
+extern int DEGPRUNE(int*,int*,int,int);
+#endif
+
+#ifdef INPUTGRAPH
+extern int INPUTGRAPH(graph*,int,int);
+#endif
+
+#ifdef PROCESS
+extern void PROCESS(FILE*,graph*,int);
+#endif
+
+#ifdef SUMMARY
+extern void SUMMARY(void);
+#endif
+
+/* #define GROUPTEST */
+#ifdef GROUPTEST
+static long long totallab;
+#endif
+
+/**************************************************************************/
+
+void
+writeautom(int *p, int n)
+/* Called by allgroup. */
+{
+    int i;
+
+    for (i = 0; i < n; ++i) printf(" %2d",p[i]);
+    printf("\n");
+}
+
+/**************************************************************************/
+
+static boolean
+ismax(int *p, int n)
+/* test if x^p <= x */
+{
+    int i,j,k;
+    set px[MAXME];
+
+    EMPTYSET(px,me);
+
+    for (j = 0; j < nix; ++j)
+    {
+        i = ix[j];
+        k = i >> 1;
+        if (i & 1) ADDELEMENT(px,edgeno[p[v1[k]]][p[v0[k]]]);
+        else       ADDELEMENT(px,edgeno[p[v0[k]]][p[v1[k]]]);
+
+        if (px[0] > x[0])
+        {
+            rejectlevel = k;
+            return FALSE;
+        }
+    }
+
+    rejectlevel = MAXNE+1;
+
+    if (px[0] < x[0]) return TRUE;
+
+    for (i = 1; i < me; ++i)
+        if      (px[i] > x[i]) return FALSE;
+        else if (px[i] < x[i]) return TRUE;
+
+    ++newgroupsize;
+    ntgroup = TRUE;
+    return TRUE;
+}
+
+/**************************************************************************/
+
+void
+testmax(int *p, int n, int *abort)
+/* Called by allgroup2. */
+{
+    int i;
+
+    if (first)
+    {                       /* only the identity */
+        first = FALSE;
+        return;
+    }
+
+    if (!ismax(p,n))
+    {
+        *abort = 1;
+        for (i = 0; i < n; ++i) lastreject[i] = p[i];
+        lastrejok = TRUE;
+    }
+}
+
+/**************************************************************************/
+
+static int
+trythisone(grouprec *group, int ne, int n)
+{
+    int i,k;
+    boolean accept;
+    graph g[WORDSIZE];
+
+    first = TRUE;
+
+    ++dg_ngen;
+    nix = ne;
+    newgroupsize = 1;
+    ntgroup = FALSE;
+
+    if (!group || groupsize == 1)
+        accept = TRUE;
+    else if (lastrejok && !ismax(lastreject,n))
+        accept = FALSE;
+    else if (lastrejok && groupsize == 2)
+        accept = TRUE;
+    else
+    {
+        newgroupsize = 1;
+        ntgroup = FALSE;
+        if (allgroup2(group,testmax) == 0)
+            accept = TRUE;
+        else
+            accept = FALSE;
+    }
+
+    if (accept)
+    {
+
+#ifdef GROUPTEST
+        if (groupsize % newgroupsize != 0)
+                        gt_abort("group size error\n");
+        totallab += groupsize/newgroupsize;
+#endif
+
+        if (Vswitch && !ntisol && !ntgroup) return MAXNE+1;
+
+        ++dg_nout;
+
+	if (digraph6)
+        {
+	    EMPTYSET(g,n);
+	    for (i = -1; (i = nextelement(x,me,i)) >= 0; )
+            {
+                k = i >> 1;
+                if (i & 1) g[v1[k]] |= bit[v0[k]];
+                else       g[v0[k]] |= bit[v1[k]];
+            }
+	}
+
+#ifdef PROCESS
+	if (!digraph6)
+        {
+	    EMPTYSET(g,n);
+	    for (i = -1; (i = nextelement(x,me,i)) >= 0; )
+            {
+                k = i >> 1;
+                if (i & 1) g[v1[k]] |= bit[v0[k]];
+                else       g[v0[k]] |= bit[v1[k]];
+            }
+	}
+	PROCESS(outfile,g,n);
+#endif
+
+	if (digraph6)
+	    writed6(outfile,g,1,n);
+        else if (outfile)
+        {
+            fprintf(outfile,"%d %d",n,ne);
+            if (Gswitch) fprintf(outfile," %lu",newgroupsize);
+    
+            for (i = -1; (i = nextelement(x,me,i)) >= 0; )
+            {
+                k = i >> 1;
+                if (i & 1) fprintf(outfile," %d %d",v1[k],v0[k]);
+                else       fprintf(outfile," %d %d",v0[k],v1[k]);
+            }
+            fprintf(outfile,"\n");
+        }
+        return MAXNE+1;
+    }
+    else
+        return (rejectlevel < splitlevel ? splitlevel : rejectlevel);
+}
+
+/**************************************************************************/
+
+static int
+scan(int level, int ne, int minarcs, int maxarcs, int sofar,
+    boolean oriented, grouprec *group, int n)
+/* Main recursive scan; returns the level to return to. */
+{
+    int k,retlev;
+#ifdef DEGPRUNE
+    int w0,w1;
+
+    w0 = v0[level];
+    w1 = v1[level];
+#endif
+
+    if (level == splitlevel)
+    {
+#ifdef SPLITTEST
+        ++splitcases;
+        return level-1;
+#endif
+        if (splitcount-- != 0) return level-1;
+        splitcount = splitmod - 1;
+    }
+
+    if (level == ne)
+    {
+        retlev = trythisone(group,sofar,n);
+        return retlev;
+    }
+
+    if (oriented || sofar + 1 + 2*(ne - level - 1) >= minarcs)
+    {
+        k = 2*level;
+        ADDELEMENT(x,k);
+        ix[sofar] = k;
+#ifdef DEGPRUNE
+        ++outdeg[w0]; ++indeg[w1];
+        if (lastlev[w0] == level && DEGPRUNE(indeg,outdeg,w0,n)
+         || lastlev[w1] == level && DEGPRUNE(indeg,outdeg,w1,n))
+            retlev = level;
+        else
+#endif
+        retlev = scan(level+1,ne,minarcs,maxarcs,sofar+1,oriented,group,n);
+        DELELEMENT(x,k);
+#ifdef DEGPRUNE
+        --outdeg[w0]; --indeg[w1];
+#endif
+        if (retlev < level) return retlev;
+        ++k;
+        ADDELEMENT(x,k);
+        ix[sofar] = k;
+#ifdef DEGPRUNE
+        ++outdeg[w1]; ++indeg[w0];
+        if (lastlev[w0] == level && DEGPRUNE(indeg,outdeg,w0,n)
+         || lastlev[w1] == level && DEGPRUNE(indeg,outdeg,w1,n))
+            retlev = level;
+        else
+#endif
+        retlev = scan(level+1,ne,minarcs,maxarcs,sofar+1,oriented,group,n);
+        DELELEMENT(x,k);
+#ifdef DEGPRUNE
+        --outdeg[w1]; --indeg[w0];
+#endif
+        if (retlev < level) return retlev;
+    }
+
+    if (!oriented && sofar + 2 + ne - level - 1 <= maxarcs)
+    {
+        k = 2*level;
+        ADDELEMENT(x,k);
+        ADDELEMENT(x,k+1);
+        ix[sofar] = k;
+        ix[sofar+1] = k+1;
+#ifdef DEGPRUNE
+        ++indeg[w0]; ++indeg[w1];
+        ++outdeg[w0]; ++outdeg[w1];
+        if (lastlev[w0] == level && DEGPRUNE(indeg,outdeg,w0,n)
+         || lastlev[w1] == level && DEGPRUNE(indeg,outdeg,w1,n))
+            retlev = level;
+        else
+#endif
+        retlev = scan(level+1,ne,minarcs,maxarcs,sofar+2,oriented,group,n);
+        DELELEMENT(x,k+1);
+        DELELEMENT(x,k);
+#ifdef DEGPRUNE
+        --indeg[w0]; --indeg[w1];
+        --outdeg[w0]; --outdeg[w1];
+#endif
+        if (retlev < level) return retlev;
+    }
+
+    return level-1;
+}
+
+/**************************************************************************/
+
+static void
+direct(graph *g, int nfixed, long minarcs, long maxarcs,
+       boolean oriented, int m, int n)
+{
+    static DEFAULTOPTIONS_GRAPH(options);
+    statsblk stats;
+    setword workspace[100];
+    grouprec *group;
+    long ne;
+    int i,j,k,j0,j1,deg;
+    int isol0,isol1;  /* isolated vertices before and after nfixed */
+    set *gi;
+    int lab[MAXNV],ptn[MAXNV],orbits[MAXNV];
+    set active[(MAXNV+WORDSIZE-1)/WORDSIZE];
+
+    nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
+
+    j0 = -1;  /* last vertex with degree 0 */
+    j1 = n;   /* first vertex with degree > 0 */
+    isol0 = isol1 = 0;
+ 
+    ne = 0;
+    for (i = 0, gi = g; i < n; ++i, gi += m)
+    {
+        deg = 0;
+        for (j = 0; j < m; ++j) deg += POPCOUNT(gi[j]);
+        if (deg == 0)
+        {
+            lab[++j0] = i;
+            if (i < nfixed) ++isol0; else ++isol1;
+        }
+        else
+            lab[--j1] = i;
+        ne += deg;
+    }
+    ne /= 2;
+    ntisol = (isol0 >= 2 || isol1 >= 2);
+
+    me = (2*ne + WORDSIZE - 1) / WORDSIZE;
+    if (me == 0) me = 1;
+    EMPTYSET(x,me);
+
+    splitcount = splitres;
+    if (splitmod == 1)
+        splitlevel = -1;
+    else
+	splitlevel = (ne <= 34 ? ne/2 : 17);
+
+#ifdef DEGPRUNE
+    for (i = 0; i < n; ++i) indeg[i] = outdeg[i] = 0;
+#endif
+#ifndef SPLITTEST
+    if (ne == 0 && minarcs <= 0 && (!Vswitch || ntisol) && splitres == 0)
+    {
+#ifdef DEGPRUNE
+	for (i = 0; i < n; ++i)
+	    if (DEGPRUNE(indeg,outdeg,i,n)) break;
+	if (i == n)
+#endif
+            trythisone(NULL,0,n);    // only in case 0
+        return;
+    }
+#endif
+
+    if (oriented)
+    {
+        if (maxarcs < ne || minarcs > ne) return;
+    }
+    else
+    {
+        if (maxarcs < ne || minarcs > 2*ne) return;
+    }
+
+    if (n > MAXNV || ne > MAXNE)
+    {
+        fprintf(stderr,">E directg: MAXNV or MAXNE exceeded\n");
+        exit(1);
+    }
+
+    for (i = 0; i < n; ++i) ptn[i] = 1;
+    ptn[n-1] = 0;
+    EMPTYSET(active,m);
+    ADDELEMENT(active,0);
+
+    for (i = 0; i <= j0; ++i)
+    {
+        if (i < n-1) ADDELEMENT(active,i+1);
+        ptn[i] = 0;
+    }
+
+    for (i = j0+1; i < n; ++i)
+    if (lab[i] < nfixed) break;
+
+    if (i != j0+1 && i != n)
+    {
+        ptn[i-1] = 0;
+        ADDELEMENT(active,i);
+    }
+
+    options.defaultptn = FALSE;
+    options.userautomproc = groupautomproc;
+    options.userlevelproc = grouplevelproc;
+
+    nauty(g,lab,ptn,active,orbits,&options,&stats,workspace,100,m,n,NULL);
+
+    if (stats.grpsize2 == 0)
+        groupsize = stats.grpsize1 + 0.1;
+    else
+        groupsize = 0;
+
+    if (Vswitch && groupsize == 1 && !ntisol) return;
+
+    group = groupptr(FALSE);
+    makecosetreps(group);
+
+#ifdef DEGPRUNE
+    for (i = 0; i <= j0; ++i)
+        if (DEGPRUNE(indeg,outdeg,lab[i],n)) return;
+#endif
+
+    k = 0;
+    for (i = 0, gi = g; i < n; ++i, gi += m)
+    {
+        for (j = i; (j = nextelement(gi,m,j)) >= 0; )
+        {
+            v0[k] = i;
+            v1[k] = j;
+#ifdef DEGPRUNE
+            lastlev[i] = lastlev[j] = k;
+#endif
+            edgeno[i][j] = 2*k;
+            edgeno[j][i] = 2*k+1;
+            ++k;
+        }
+    }
+
+    lastrejok = FALSE;
+
+    scan(0,ne,minarcs,maxarcs,0,oriented,group,n);
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    graph *g;
+    int m,n,codetype;
+    int argnum,j,nfixed;
+    char *arg,sw;
+    boolean badargs;
+    boolean Tswitch,uswitch,eswitch,qswitch,oswitch,fswitch,sswitch;
+    long minarcs,maxarcs;
+    double t;
+    char *infilename,*outfilename;
+    FILE *infile;
+    char msg[201];
+    int msglen;
+    long lsplitres,lsplitmod;
+
+    HELP; PUTVERSION;
+
+/* Put 2 in the following to catch incorrect uses of naut*1. */
+    nauty_check(WORDSIZE,2,2*WORDSIZE,NAUTYVERSIONID);
+
+    Tswitch = Gswitch = fswitch = Vswitch = FALSE;
+    uswitch = eswitch = oswitch = qswitch = FALSE;
+    sswitch = digraph6 = FALSE;
+    infilename = outfilename = NULL;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('o',oswitch)
+                else SWBOOLEAN('q',qswitch)
+                else SWBOOLEAN('u',uswitch)
+                else SWBOOLEAN('T',Tswitch)
+                else SWBOOLEAN('G',Gswitch)
+                else SWBOOLEAN('V',Vswitch)
+                else SWINT('f',fswitch,nfixed,"directg -f")
+		else SWRANGE('s',"/",sswitch,lsplitres,lsplitmod,"directg -s")
+                else SWRANGE('e',":-",eswitch,minarcs,maxarcs,"directg -e")
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if (badargs || argnum > 2)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if ((Gswitch!=0) + (Tswitch!=0) + (uswitch!=0) >= 2)
+        gt_abort(">E directg: -G, -T and -u are incompatible\n");
+
+    digraph6 = !(Gswitch || Tswitch || uswitch);
+
+    if (!eswitch)
+    {
+        minarcs = 0;
+        maxarcs = NOLIMIT;
+    }
+    if (sswitch)
+    {
+	splitmod = lsplitmod;
+	splitres = lsplitres;
+    }
+    else
+    {
+	splitmod = 1;
+	splitres = 0;
+    }
+    splitcases = 0;
+    if (sswitch && (splitmod < 1 || splitres < 0 || splitres >= splitmod))
+    {
+        fprintf(stderr,">E -s#/# requires 0 <= res < mod\n");
+        exit(1);
+    }
+
+    if (!fswitch) nfixed = 0;
+
+    if (!qswitch)
+    {
+        msg[0] = '\0';
+        CATMSG0(">A directg");
+        if (sswitch || eswitch || oswitch || uswitch || fswitch) CATMSG0(" -");
+        if (oswitch) CATMSG0("o");
+        if (uswitch) CATMSG0("u");
+        if (Tswitch) CATMSG0("T");
+        if (Gswitch) CATMSG0("G");
+        if (Vswitch) CATMSG0("V");
+        if (fswitch) CATMSG1("f%d",nfixed);
+	if (sswitch) CATMSG2("s%d/%d",splitres,splitmod);
+        if (eswitch) CATMSG2("e%ld:%ld",minarcs,maxarcs);
+        msglen = strlen(msg);
+        if (argnum > 0) msglen += strlen(infilename);
+        if (argnum > 1) msglen += strlen(outfilename);
+        if (msglen >= 196)
+        {
+            fputs(msg,stderr);
+            if (argnum > 0) fprintf(stderr," %s",infilename);
+            if (argnum > 1) fprintf(stderr," %s",outfilename);
+            fprintf(stderr,"\n");
+        }
+        else
+        {
+            if (argnum > 0) CATMSG1(" %s",infilename);
+            if (argnum > 1) CATMSG1(" %s",outfilename);
+            CATMSG0("\n");
+            fputs(msg,stderr);
+        }
+        fflush(stderr);
+    }
+
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,FALSE,1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    if (uswitch)
+        outfile = NULL;
+    else
+    {
+        if (!outfilename || outfilename[0] == '-')
+        {
+            outfilename = "stdout";
+            outfile = stdout;
+        }
+        else if ((outfile = fopen(outfilename,"w")) == NULL)
+        {
+            fprintf(stderr,"Can't open output file %s\n",outfilename);
+            gt_abort(NULL);
+        }
+    }
+
+    dg_nin = 0;
+    dg_ngen = 0;
+    dg_nout = 0;
+    dg_skipped = 0;
+
+    t = CPUTIME;
+    while (TRUE)
+    {
+        if ((g = readg(infile,NULL,0,&m,&n)) == NULL) break;
+        ++dg_nin;
+#ifdef PROCESS
+	if (m > 1)
+	{
+	    fprintf(stderr,">E m=1 is needed if PROCESS is defined\n");
+	    exit(1);
+	}
+#endif
+#ifdef INPUTGRAPH
+	if (!INPUTGRAPH(g,m,n))
+	{
+	   ++dg_skipped;
+	   FREES(g);
+	   continue;
+	}
+#endif
+
+        direct(g,nfixed,minarcs,maxarcs,oswitch,m,n);
+        if (!uswitch && ferror(outfile))
+	    gt_abort(">E directg output error\n");
+        FREES(g);
+    }
+    t = CPUTIME - t;
+
+#ifdef SUMMARY
+    SUMMARY();
+#endif
+
+#ifdef SPLITTEST
+    fprintf(stderr,">S %lu cases at level %d\n",splitcases,splitlevel);
+#else
+    if (!qswitch)
+    {
+        fprintf(stderr,">Z " COUNTER_FMT " graphs read from %s",
+                       dg_nin,infilename); 
+#ifdef INPUTGRAPH
+	fprintf(stderr,"; " COUNTER_FMT " skipped",dg_skipped);
+#endif
+        fprintf(stderr,"; " COUNTER_FMT ,dg_nout);
+        if (!uswitch)
+            fprintf(stderr," digraphs written to %s",outfilename);
+        else
+            fprintf(stderr," digraphs generated");
+        fprintf(stderr,"; %.2f sec\n",t);
+    }
+#endif
+
+#ifdef GROUPTEST
+    fprintf(stderr,"Group test = %lld\n",totallab);
+#endif
+
+    exit(0);
+}
diff --git a/lib/nauty/dreadnaut.c b/lib/nauty/dreadnaut.c
new file mode 100644
index 0000000..99a75dd
--- /dev/null
+++ b/lib/nauty/dreadnaut.c
@@ -0,0 +1,2544 @@
+/*****************************************************************************
+*                                                                            *
+* This is the main file for dreadnaut() version 2.6, which is a test-bed     *
+*   for nauty() version 2.6.                                                 *
+*                                                                            *
+*   Subject to the copyright notice in the file COPYRIGHT.                   *
+*                                                                            *
+*   CHANGE HISTORY                                                           *
+*       10-Nov-87 : final changes for version 1.2                            *
+*        5-Dec-87 - replaced all uses of fscanf() by appropriate uses        *
+*                   of the new procedures readinteger() and readstring()     *
+*                 - changed the '<' command slightly.  If a file of the      *
+*                   given name cannot be openned, an attempt is made to      *
+*                   open a file with the same name extended by DEFEXT.       *
+*                 - improved error processing for 'n' command.               *
+*       28-Sep-88 : changes for version 1.4 :                                *
+*                 - replaced incorrect %d by %ld in fprintf for ? command    *
+*       23-Mar-89 : changes for version 1.5 :                                *
+*                 - added optional startup message                           *
+*                 - enabled use of refine1 in 'i' command                    *
+*                 - implemented $$ command                                   *
+*                 - replaced ALLOCS test by DYNALLOC test                    *
+*                 - modified @ command and added # command                   *
+*                 - declared local procedures static                         *
+*       25-Mar-89 - implemented k command                                    *
+*       27-Mar-89 - implemented * and I commands                             *
+*       29-Mar-89 - implemented K command                                    *
+*        2-Apr-89 - added reporting of vertex-invariant statistics           *
+*        2-Apr-89 - added ## command                                         *
+*        4-Apr-89 - added triples(), quadruples(), adjtriang()               *
+*                 - updated error reporting for nauty()                      *
+*        5-Apr-89 - removed flushline() from g and e commands                *
+*                 - added T command                                          *
+*        6-Apr-89 - added cellquads() and distances()                        *
+*       26-Apr-89 - modified ? command, added & and && commands              *
+*                 - added indsets(), cliques(), cellquins()                  *
+*       18-Aug-89 - made g, lab, canong dynamically allocated always         *
+*        2-Mar-90 - added celltrips(), cellcliq(), cellind()                 *
+*       13-Mar-90 - changed canong and savedg in output to h and h'          *
+*       19-Mar-90 - revised help() a little                                  *
+*       19-Apr-90 : changes for version 1.6                                  *
+*                 - rewrote "*" command to avoid bug in Pyramid C compiler   *
+*       20-Apr-90 - rewrote above rewrite to avoid bug in SUN3 gcc           *
+*       23-Apr-90 - undid above rewrite and fixed *my* bug <blush> by        *
+*                   making NUMINVARS have type int.  Sorry, gcc.             *
+*       10-Nov-90 - added calls to null routines (see comment on code)       *
+*       27-Aug-92 : renamed to version 1.7, no changes to this file          *
+*        5-Jun-93 : renamed to version 1.7+, no changes to this file         *
+*       18-Aug-93 : renamed to version 1.8, no changes to this file          *
+*       17-Sep-93 : changes for version 1.9 :                                *
+*                 - added invariant adjacencies()                            *
+*        7-Jun-96 : changes for version 2.0 :                                *
+*                 - added invariants cellfano() and cellfano2()              *
+*                 - made y=10 the default                                    *
+*       11-Jul-96 - added dynamic allocation                                 *
+*                 - rewrote h command and added H command                    *
+*                 - implemented M and R commands                             *
+*       15-Aug-96 - changed z command to use sethash()                       *
+*       30-Aug-96 - no need to declare seed; already in naututil.h           *
+*       12-Sep-96 - let i and I commands use userrefproc                     *
+*        9-Dec-96 - made y=infinity the default                              *
+*        6-Sep-97 - allocated arrays before accepting commands               *
+*        7-Sep-97 - make g,canong,savedg 1-d arrays even statically          *
+*       22-Sep-97 - undid error introduced on 7-Sep (worksize)               *
+*        9-Jan-00 - used *_check() instead of *_null()                       *
+*       12-Feb-00 - minor code formatting                                    *
+*       17-Aug-00 - now use tc_level from DEFAULTOPTIONS                     *
+*       16-Nov-00 - made changes listed in nauty.h                           *
+*       22-Apr-01 - include nautyinv.h                                       *
+*                 - improve worksize processing for MAXN=0                   *
+*        5-May-01 - k=0 1 automatic for *, also K=3 or K=0                   *
+*        2-Jun-01 - added __ command for digraph converse                    *
+*       18-Oct-01 - moved WORKSIZE to here                                   *
+*       21-Nov-01 - use NAUTYREQUIRED in *_check() calls                     *
+*        1-Sep-02 - Undid the previous change                                *
+*       17-Nov-03 - Changed INFINITY to NAUTY_INFINITY                       *
+*       15-Nov-04 - Completed all prototypes                                 *
+*       23-Nov-06 - no usertcellproc() any more in version 2.4               *
+*       10-Nov-09 - removed types shortish and permutation                   *
+*       17-Nov-09 - added sparsegraphs, schreier, A and G commands           *
+*       19-Nov-09 - added F command, stub for Traces                         *
+*        1-Dec-09 - added traces refinement, M also applies to i             *
+*       16-Dec-09 - added sr# command for random regular graphs              *
+*       19-Dec-09 - added s# command for the sparse case                     *
+*                 - w command is in units of 2*m now                         *
+*       19-May-10 - Incorporate traces canonical labelling                   *
+*        7-Jun-10 - implement %, _ and __ commands for sparse format         *
+*        8-Jun-10 - add O and P commands, and sparse && command              *
+*       11-Jun-10 - revise command-line parameters                           *
+*       14-Jun-10 - digraphs and invariants (top level only) in Traces       *
+*       26-Oct-10 - fix u command for sparse graphs; default G=10            *
+*       14-Mar-11 - store partition with savedg                              *
+*       21-Jul-11 - extend M command                                         *
+*       24-Oct-11 - add S and OO commands                                    *
+*       15-Jan-12 - use putorbitsplus() if USE_ANSICONTROLS                  *
+*       20-Sep-12 - the first argument of ungetc is int, not char            *
+*       18-Jan-13 - add code for ^C catching in nauty                        *
+*                 - add usercanonproc sample                                 *
+*                 - ->> means flush output file                              *
+*       14-Nov-14 - fix numcells calculation in 'OO' command                 *
+*       16-Mar-15 - add B command                                            *
+*       16-Dec-15 - add r& command                                           *
+*       22-Jan-16 - commands with short arguments must be all on one line    *
+*                 - most errors cause rest of input line to be skipped       *
+*       19-Feb-16 - make R command induce a partition if one is defined      *
+*                                                                            *
+*****************************************************************************/
+
+#include "gtools.h"    /* which includes nauty.h, which includes stdio.h */
+#include "nautinv.h"  
+#include "schreier.h"
+#include "traces.h"
+
+#define USAGE "dreadnaut [-o options]"
+
+#define HELPTEXT \
+" Enter nauty+traces test program.\n\
+\n\
+  -o options  - set initial options.  The parameter value is a string of\n\
+                dreadnaut commands from the following set:\n\
+                a,c,d,m,p,l,G,P,w,y,$,A,V,M\n\
+                The effect is the same as if these commands are entered\n\
+                at the beginning of the standard input.\n\
+  For help within dreadnaut, use the h command.\n"
+
+#define PM(x) ((x) ? '+' : '-')
+#define SS(n,sing,plur)  (n),((n)==1?(sing):(plur))
+#define WORKSIZE 60
+#define FLUSHANDPROMPT do { flushline(INFILE); if (prompt) fprintf(PROMPTFILE,"> "); } while (0)
+
+#define SORT_OF_SORT 2
+#define SORT_NAME sort2ints
+#define SORT_TYPE1 int
+#define SORT_TYPE2 int
+#include "sorttemplates.c"   /* define sort2ints(a,b,n) */
+
+#define INFILE fileptr[curfile]
+#define SCHREIER_DEFAULT 10
+
+static long seed;
+
+#if !MAXN
+DYNALLSTAT(graph,g,g_sz);
+DYNALLSTAT(graph,canong,canong_sz);
+DYNALLSTAT(graph,savedg,savedg_sz);
+DYNALLSTAT(setword,workspace,workspace_sz);
+DYNALLSTAT(int,lab,lab_sz);
+DYNALLSTAT(int,ptn,ptn_sz);
+DYNALLSTAT(int,orbits,orbits_sz);
+DYNALLSTAT(int,templab,templab_sz);
+DYNALLSTAT(int,tempptn,tempptn_sz);
+DYNALLSTAT(int,perm,perm_sz);
+DYNALLSTAT(int,savedlab,savedlab_sz);
+DYNALLSTAT(int,savedptn,savedptn_sz);
+DYNALLSTAT(set,tempactive,tempactive_sz);
+DYNALLSTAT(set,active,active_sz);
+#else
+static graph g[MAXM*1L*MAXN];
+static graph canong[MAXM*1L*MAXN];
+static graph savedg[MAXM*1L*MAXN];
+static setword workspace[MAXM*2L*WORKSIZE];
+static int lab[MAXN];
+static int ptn[MAXN];
+static int orbits[MAXN];
+static int savedlab[MAXN],savedptn[MAXN];
+static int perm[MAXN];
+static int templab[MAXN];
+static int tempptn[MAXN];
+static int tempactive[MAXM];
+static set active[MAXM];
+#endif
+
+static sparsegraph g_sg;
+static sparsegraph canong_sg;
+static sparsegraph savedg_sg;
+
+static DEFAULTOPTIONS_GRAPH(options);
+static DEFAULTOPTIONS_SPARSEGRAPH(options_sg);
+static statsblk stats;
+static int curfile;
+static FILE *fileptr[MAXIFILES];
+static FILE *outfile;
+static char def_ext[] = DEFEXT;
+static boolean firstpath;       /* used in usernode() */
+
+DEFAULTOPTIONS_TRACES(traces_opts);
+static TracesStats traces_stats;
+
+#define TMP
+
+#define DENSE_MODE  0
+#define SPARSE_MODE 1
+#define TRACES_MODE 2
+#define SPARSEREP(mode) ((mode)==1||(mode)==2)
+#define NOSPARSEYET(c) else if (SPARSEREP(mode)) { fprintf(ERRFILE,\
+              "command %s is not implemented in the sparse case\n",c); }
+#define NODENSEYET else if (!SPARSEREP(mode)) { fprintf(ERRFILE,\
+              "command %c is not implemented in the dense case\n",c); }
+#define NOTRACESYET if (mode==TRACES_MODE) {  fprintf(ERRFILE,\
+              "command %c is not implemented for Traces\n",c); }
+
+static int mode;
+
+#define U_NODE  1               /* masks for u values */
+#define U_AUTOM 2
+#define U_LEVEL 4
+#define U_TCELL 8     /* At version 2.4, usertcellproc() is gone */
+#define U_REF  16
+#define U_CANON 32
+
+#ifndef  NODEPROC
+#define NODEPROC usernode
+#else
+extern void NODEPROC(graph*,int*,int*,int,int,int,int,int,int);
+#endif
+
+#ifndef  AUTOMPROC
+#define AUTOMPROC userautom
+#else
+extern void AUTOMPROC(int,int*,int*,int,int,int);
+#endif
+
+#ifndef  LEVELPROC
+#define LEVELPROC userlevel
+#else
+extern void LEVELPROC(int*,int*,int,int*,statsblk*,int,int,int,int,int,int);
+#endif
+
+#ifndef  REFPROC
+#define REFPROC NULL
+#else
+extern void REFPROC(graph*,int*,int*,int,int*,int*,set*,int*,int,int);
+#endif
+
+#ifndef  CANONPROC
+#define CANONPROC usercanon
+#else
+extern int CANONPROC(graph*,int*,graph*,int,int,int,int);
+#endif
+
+#ifndef  INVARPROC
+#define INVARPROC NULL
+#define INVARPROCNAME "none"
+#else
+extern void INVARPROC(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+#define INVARPROCNAME "user-defined"
+#endif
+
+#ifndef  INVARPROC_SG
+#define INVARPROC_SG NULL
+#define INVARPROCNAME_SG "none"
+#else
+extern void INVARPROC_SG(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+#define INVARPROCNAME_SG "user-defined"
+#endif
+
+static struct invarrec
+{
+    void (*entrypoint)(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+    char *name;
+    void (*entrypoint_sg)(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+    char *name_sg;
+} invarproc[]
+    = {{INVARPROC, INVARPROCNAME, INVARPROC_SG, INVARPROCNAME_SG},
+       {NULL,        "none",        NULL,           "none"},
+       {twopaths,    "twopaths",    NULL,           "unavailable"},
+       {adjtriang,   "adjtriang",   NULL,           "unavailable"},
+       {triples,     "triples",     NULL,           "unavailable"},
+       {quadruples,  "quadruples",  NULL,           "unavailable"},
+       {celltrips,   "celltrips",   NULL,           "unavailable"},
+       {cellquads,   "cellquads",   NULL,           "unavailable"},
+       {cellquins,   "cellquins",   NULL,           "unavailable"},
+       {distances,   "distances",   distances_sg,   "distances_sg"},
+       {indsets,     "indsets",     NULL,           "unavailable"},
+       {cliques,     "cliques",     NULL,           "unavailable"},
+       {cellcliq,    "cellcliq",    NULL,           "unavailable"},
+       {cellind,     "cellind",     NULL,           "unavailable"},
+       {adjacencies, "adjacencies", adjacencies_sg, "adjacencies_sg"},
+       {cellfano,    "cellfano",    NULL,           "unavailable"},
+       {cellfano2,   "cellfano2",   NULL,           "unavailable"},
+       {refinvar,    "refinvar",    NULL,           "unavailable"}
+      };
+#define NUMINVARS ((int)(sizeof(invarproc)/sizeof(struct invarrec)))
+
+static void help(FILE*, int);
+static void userautom(int,int*,int*,int,int,int);
+static void usernode(graph*,int*,int*,int,int,int,int,int,int);
+static void userlevel(int*,int*,int,int*,statsblk*,int,int,int,int,int,int);
+static int usercanon(graph*,int*,graph*,int,int,int,int);
+
+static boolean options_writeautoms,options_writemarkers,
+            options_digraph,options_getcanon,options_linelength;
+static int options_invarproc,options_mininvarlevel,options_maxinvarlevel,
+	    options_invararg,options_tc_level,options_cartesian;
+static int options_schreier,options_keepgroup,options_verbosity,
+	   options_strategy;
+
+#if USE_ANSICONTROLS && !DREADTEST
+#define PUTORBITS putorbitsplus
+#else
+#define PUTORBITS putorbits
+#endif
+
+#ifdef  EXTRADECLS
+EXTRADECLS
+#endif
+
+#if !HAVE_SIGACTION
+#undef ALLOW_INTERRUPT
+#define ALLOW_INTERRUPT 0
+#endif
+
+#if ALLOW_INTERRUPT
+/*****************************************************************************
+*                                                                            *
+*  Routines for catching SIGINT                                              *
+*                                                                            *
+*****************************************************************************/
+
+void
+sigintcatcher(int sig)
+/* This is the routine called on SIGINT receipt. */
+{
+    struct sigaction ss;
+
+    nauty_kill_request = 1;
+    ss.sa_handler = SIG_DFL;
+    sigemptyset(&ss.sa_mask);
+    ss.sa_flags = 0;
+    sigaction(SIGINT,&ss,0);
+}
+
+static void
+setsigcatcher(void)
+{
+    struct sigaction ss;
+
+    nauty_kill_request = 0;
+    ss.sa_handler = sigintcatcher;
+    sigemptyset(&ss.sa_mask);
+    ss.sa_flags = 0;
+    sigaction(SIGINT,&ss,0);
+}
+
+static void
+unsetsigcatcher(void)
+{
+    struct sigaction ss;
+
+    nauty_kill_request = 0;
+    ss.sa_handler = SIG_DFL;
+    sigemptyset(&ss.sa_mask);
+    ss.sa_flags = 0;
+    sigaction(SIGINT,&ss,0);
+}
+#else
+static void
+setsigcatcher(void)
+{
+}
+
+static void
+unsetsigcatcher(void)
+{
+}
+#endif
+
+/*****************************************************************************
+*                                                                            *
+*  This is a program which illustrates the use of nauty.                     *
+*  Commands are read from stdin, and may be separated by white space,        *
+*  commas or not separated.  Output is written to stdout.                    *
+*  For a short description, see the nauty User's Guide.                      *
+*                                                                            *
+*****************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    int m,n,newm,newn;
+    boolean gvalid,ovalid,cvalid,pvalid,minus,prompt,doquot;
+    boolean gvalid_sg,cvalid_sg;
+    int i,j,k,worksize,numcells,savednc,refcode,umask,qinvar;
+    int oldorg,oldmode;
+    int maxsize,cell1,cell2;
+    boolean ranreg,same;
+    char *s1,*s2;
+    int c,d;
+    unsigned long uli;
+    size_t sli;
+    set *gp;
+    double timebefore,timeafter,mintime;
+    char filename[515];
+    int sgn,sgorg,nperm;
+    int multiplicity,actmult;
+    long zseed;
+    permnode *generators;
+    char *ap,*parameters;
+    boolean flushing;
+
+    HELP; PUTVERSION;
+
+    if (argc == 3 && strcmp(argv[1],"-o") == 0)
+	parameters = argv[2];
+    else if (argc != 1)
+    {
+	fprintf(ERRFILE,USAGE);
+	exit(1);
+    }
+    else
+	parameters = "";
+ 
+    mode = DENSE_MODE;
+    curfile = 0;
+    fileptr[curfile] = stdin;
+#ifdef DREADTEST
+    prompt = FALSE;
+#else
+    prompt = DOPROMPT(INFILE);
+#endif
+    outfile = stdout;
+    options_writeautoms = options_writemarkers = TRUE;
+    options_digraph = FALSE;
+    options_getcanon = options.getcanon;
+    options_mininvarlevel = options.mininvarlevel;
+    options_maxinvarlevel = options.maxinvarlevel;
+    options_invararg = options.invararg;
+    options_invarproc = 1; /* index into invarproc[] */
+    options_tc_level = options.tc_level;
+    options_cartesian = options.cartesian;
+    options_linelength = options.linelength;
+    options_schreier = SCHREIER_DEFAULT;
+    options_keepgroup = FALSE;
+    generators = NULL;
+    options_verbosity = 1;
+    options_strategy = 0;
+
+    n = m = 1;
+    worksize = WORKSIZE;
+
+#if !MAXN
+    n = WORDSIZE;
+    DYNALLOC2(graph,g,g_sz,n,m,"dreadnaut");
+    DYNALLOC1(int,lab,lab_sz,n,"dreadnaut");
+    DYNALLOC1(int,ptn,ptn_sz,n,"dreadnaut");
+    DYNALLOC1(int,orbits,orbits_sz,n,"dreadnaut");
+    DYNALLOC1(int,perm,perm_sz,n,"dreadnaut");
+    DYNALLOC1(set,active,active_sz,m,"dreadnaut");
+    n = 1;
+#endif
+
+#ifdef DREADTEST
+    seed = 1;
+    ran_init(seed);
+#else
+#ifdef  INITSEED
+    INITSEED;
+    ran_init(seed);
+#endif
+#endif
+
+    umask = 0;
+    pvalid = FALSE;
+    ovalid = FALSE;
+    gvalid = gvalid_sg = FALSE;  /* at most one valid */
+    cvalid = cvalid_sg = FALSE;  /* at most one valid */
+    sgorg = labelorg = oldorg = 0;
+    sgn = 0;
+    multiplicity = 1;
+    mintime = 0.0;
+    flushing = FALSE;
+
+#ifdef  INITIALIZE
+    INITIALIZE;
+#endif
+
+    if (prompt)
+    {
+        fprintf(PROMPTFILE,"Dreadnaut version %s.\n",NAUTYVERSION);
+        fprintf(PROMPTFILE,"> ");
+    }
+
+    nauty_check(WORDSIZE,1,1,NAUTYVERSIONID);
+    nautinv_check(WORDSIZE,1,1,NAUTYVERSIONID);
+    nautil_check(WORDSIZE,1,1,NAUTYVERSIONID);
+    naututil_check(WORDSIZE,1,1,NAUTYVERSIONID);
+    nausparse_check(WORDSIZE,1,1,NAUTYVERSIONID);
+
+    SG_INIT(g_sg);
+    SG_INIT(canong_sg);
+    SG_INIT(savedg_sg);
+
+    minus = FALSE;
+    for (ap = parameters; *ap != '\0'; )
+    {
+	c = *ap++;
+
+	switch (c)
+	{
+	case ' ':
+	case '\t':
+	    break;
+
+	case '-':
+	    minus = TRUE;
+	    break;
+
+	case '+':
+	    minus = FALSE;
+	    break;
+
+	case 'a': 
+	    options_writeautoms = !minus;
+            minus = FALSE;
+	    break;
+
+	case 'c': 
+	    options_getcanon = !minus;
+            minus = FALSE;
+	    break;
+
+	case 'm': 
+	    options_writemarkers = !minus;
+            minus = FALSE;
+	    break;
+
+	case 'p': 
+	    options_cartesian = !minus;
+            minus = FALSE;
+	    break;
+
+	case 'B': 
+	    flushing = !minus;
+            minus = FALSE;
+	    break;
+
+	case 'd': 
+	    options_digraph = !minus;
+            minus = FALSE;
+	    break;
+
+	case 'P': 
+	    options_keepgroup = !minus;
+            minus = FALSE;
+	    break;
+
+	case 'w':
+	    while (*ap == '=' || *ap == ' ') ++ap;
+            arg_int(&ap,&worksize,"w");
+#if MAXN
+            if (worksize > 2*MAXM*WORKSIZE)
+            {
+                fprintf(ERRFILE,
+                   "too big - setting worksize = %d\n",WORKSIZE);
+                worksize = WORKSIZE;
+            }
+#endif
+            minus = FALSE;
+            break;
+
+	case 'V':
+	    if (minus)
+            {
+                options_verbosity = 0;
+                minus = FALSE;
+            }
+            else
+            {
+	        while (*ap == '=' || *ap == ' ') ++ap;
+                arg_int(&ap,&i,"V");
+                if (i < 0) fprintf(ERRFILE,"verbosity must be >= 0\n");
+                else       options_verbosity = i;
+            }
+            break;
+
+
+	case 'S':
+	    if (minus)
+            {
+                options_strategy = 0;
+                minus = FALSE;
+            }
+            else
+            {
+	        while (*ap == '=' || *ap == ' ') ++ap;
+                arg_int(&ap,&i,"S");
+/*
+                if (i < 0) fprintf(ERRFILE,"strategy must be >= 0\n");
+                else       options_strategy = i;
+*/
+		if (i != 0) fprintf(ERRFILE,
+                      "Only strategy 0 is supported in this version\n");
+            }
+            break;
+
+        case 'G': 
+            if (minus)
+            {
+                options_schreier = 0;
+                minus = FALSE;
+            }
+            else
+            {
+	        while (*ap == '=' || *ap == ' ') ++ap;
+                arg_int(&ap,&i,"G");
+                if (i < 0)
+		    fprintf(ERRFILE,"schreierfails must be >= 0\n");
+                else
+                {
+                    options_schreier = i;
+                    if (i > 0) schreier_fails(i);
+                }
+            }
+            break;
+
+        case 'y': 
+	    while (*ap == '=' || *ap == ' ') ++ap;
+            arg_int(&ap,&options_tc_level,"y");
+            minus = FALSE;
+            break;
+
+        case '$': 
+	    while (*ap == '=' || *ap == ' ') ++ap;
+            arg_int(&ap,&labelorg,"$");
+            minus = FALSE;
+            break;
+
+        case 'M': 
+	    if (minus)
+	    {
+	        multiplicity = 1;
+		mintime = 0.0;
+                minus = FALSE;
+	    }
+	    else
+	    {
+		actmult = 0;
+	        while (*ap == '=' || *ap == ' ') ++ap;
+                arg_int(&ap,&multiplicity,"M");
+		if (*ap == '/')
+		{
+		    ++ap;
+		    arg_int(&ap,&actmult,"M/");
+		}
+	        if (multiplicity < 0) multiplicity = 0;
+	        if (actmult < 0) actmult = 0;
+		if (multiplicity == 0 && actmult == 0) multiplicity = 1;
+		mintime = (double)actmult;
+            }
+            break;
+
+        case 'l': 
+	    while (*ap == '=' || *ap == ' ') ++ap;
+            arg_int(&ap,&options_linelength,"l");
+            minus = FALSE;
+            break;
+
+        case 'A': 
+	    d = *ap++;
+            if (d == 'n' || d == 'N' || d == 'd' || d == 'D')
+		mode = DENSE_MODE;
+            else if (d == 's' || d == 'S') mode = SPARSE_MODE;
+            else if (d == 't' || d == 'T') mode = TRACES_MODE;
+            else
+            {
+                fprintf(ERRFILE,"Mode %c is unknown\n",(d?d:'0'));
+                break;
+            }
+	    minus = FALSE;
+            break;
+
+	default:
+	    fprintf(ERRFILE,"Illegal initialization command %c\n",c);
+	    exit(1);
+	}
+    }
+
+    minus = FALSE;
+    while (curfile >= 0)
+    {
+        if ((c = getc(INFILE)) == EOF || c == '\004')
+        {
+            fclose(INFILE);
+            --curfile;
+            if (curfile >= 0) prompt = DOPROMPT(INFILE);
+        }
+        else switch (c)
+        {
+        case '\n':  /* possibly issue prompt */
+            if (prompt) fprintf(PROMPTFILE,"> ");
+            minus = FALSE;
+            break;
+
+        case ' ':   /* do nothing */
+        case '\t':
+#ifndef  NLMAP
+        case '\r':
+#endif
+        case '\f':
+            break;
+
+        case '-':   /* remember this for next time */
+            minus = TRUE;
+            break;
+
+        case '+':   /* forget - */
+        case ',':
+        case ';':
+            minus = FALSE;
+            break;
+
+        case '<':   /* new input file */
+            minus = FALSE;
+            if (curfile == MAXIFILES - 1)
+	    {
+                fprintf(ERRFILE,"exceeded maximum input nesting of %d\n",
+                        MAXIFILES);
+		FLUSHANDPROMPT;
+		break;
+	    }
+            if (!readstring(INFILE,filename,513))
+            {
+                fprintf(ERRFILE,
+                        "missing file name on '<' command : ignored\n");
+                break;
+            }
+            if ((fileptr[curfile+1] = fopen(filename,"r")) == NULL)
+            {
+                for (s1 = filename; *s1 != '\0'; ++s1) {}
+                for (s2 = def_ext; (*s1 = *s2) != '\0'; ++s1, ++s2) {}
+                fileptr[curfile+1] = fopen(filename,"r");
+            }
+            if (fileptr[curfile+1] != NULL)
+            {
+                ++curfile;
+                prompt = DOPROMPT(INFILE);
+                if (prompt)
+                    fprintf(PROMPTFILE,"> ");
+            }
+            else
+	    {
+                fprintf(ERRFILE,"can't open input file\n");
+		FLUSHANDPROMPT;
+	    }
+            break;
+
+        case '>':   /* new output file, or flush output file */
+            if ((d = getc(INFILE)) != '>') ungetc(d,INFILE);
+            if (minus)
+            {
+                minus = FALSE;
+		if (d == '>')
+		    fflush(outfile);
+                else if (outfile != stdout)
+                {
+                    fclose(outfile);
+                    outfile = stdout;
+                }
+            }
+            else
+            {
+                if (!readstring(INFILE,filename,513))
+                {
+                    fprintf(ERRFILE,
+                        "improper file name, reverting to stdout\n");
+                    outfile = stdout;
+		    FLUSHANDPROMPT;
+                    break;
+                }
+                OPENOUT(outfile,filename,d=='>');
+                if (outfile == NULL)
+                {
+                    fprintf(ERRFILE,
+                        "can't open output file, reverting to stdout\n");
+                    outfile = stdout;
+		    FLUSHANDPROMPT;
+                }
+            }
+            break;
+
+	case 'B': 
+	    flushing = !minus;
+            minus = FALSE;
+	    break;
+
+        case '!':   /* ignore rest of line */
+            do
+                c = getc(INFILE);
+            while (c != '\n' && c != EOF);
+            if (c == '\n') ungetc('\n',INFILE);
+            break;
+
+        case 'n':   /* read n value */
+            minus = FALSE;
+            i = getint_sl(INFILE);
+            if (i <= 0 || (MAXN && i > MAXN)
+                       || (!MAXN && i > NAUTY_INFINITY-2))
+	    {
+                fprintf(ERRFILE,
+                     " n can't be less than 1 or more than %d\n",
+                       MAXN ? MAXN : NAUTY_INFINITY-2);
+		FLUSHANDPROMPT;
+	    }
+            else
+            {
+                gvalid = FALSE;
+                cvalid = FALSE;
+                gvalid_sg = FALSE;
+                cvalid_sg = FALSE;
+                pvalid = FALSE;
+                ovalid = FALSE;
+                n = i;
+                m = SETWORDSNEEDED(n);
+                freeschreier(NULL,&generators); 
+#if !MAXN
+                DYNALLOC1(int,lab,lab_sz,n,"dreadnaut");
+                DYNALLOC1(int,ptn,ptn_sz,n,"dreadnaut");
+                DYNALLOC1(int,orbits,orbits_sz,n,"dreadnaut");
+                DYNALLOC1(int,perm,perm_sz,n,"dreadnaut");
+                DYNALLOC1(set,active,active_sz,m,"dreadnaut");
+#endif
+            }
+            break;
+
+        case 'g':   /* read graph */
+            minus = FALSE;
+            if (SPARSEREP(mode))
+            {
+                readgraph_sg(INFILE,&g_sg,options_digraph,prompt,
+                             options_linelength,n);
+                gvalid_sg = TRUE;
+                cvalid_sg = FALSE;
+            }
+            else
+            {
+#if !MAXN
+                DYNALLOC2(graph,g,g_sz,n,m,"dreadnaut");
+#endif
+                readgraph(INFILE,g,options_digraph,prompt,FALSE,
+                          options_linelength,m,n);
+                gvalid = TRUE;
+                cvalid = FALSE;
+            }
+            ovalid = FALSE;
+            break;
+
+        case 'e':   /* edit graph */
+            minus = FALSE;
+            if (SPARSEREP(mode))
+            {
+                fprintf(ERRFILE,"e command only works in dense mode\n");
+		FLUSHANDPROMPT;
+            }
+            else
+            {
+                readgraph(INFILE,g,options_digraph,prompt,gvalid,
+                          options_linelength,m,n);
+                gvalid = TRUE;
+                cvalid = FALSE;
+                ovalid = FALSE;
+            }
+            break;
+
+        case 'r':   /* relabel graph and current partition */
+            minus = FALSE;
+	    if ((d = getc(INFILE)) != '&') ungetc(d,INFILE);
+            if (gvalid_sg)
+            {
+                if (d == '&')
+		{
+		    if (pvalid)
+			relabel_sg(&g_sg,lab,lab,&canong_sg);
+		}
+		else
+		{
+                    readvperm(INFILE,perm,prompt,n,&nperm);
+                    relabel_sg(&g_sg,(pvalid ? lab : NULL),perm,&canong_sg);
+		}
+                cvalid_sg = FALSE;
+                ovalid = FALSE;
+            }
+            else if (gvalid)
+            {
+		if (d == '&')
+		{
+		    if (pvalid)
+		    {
+#if !MAXN
+                        DYNALLOC2(graph,canong,canong_sz,n,m,"dreadnaut");
+#endif
+			relabel(g,lab,lab,canong,m,n);
+		    }
+		}
+		else
+		{
+#if !MAXN
+                    DYNALLOC2(graph,canong,canong_sz,n,m,"dreadnaut");
+#endif
+                    readvperm(INFILE,perm,prompt,n,&nperm);
+                    relabel(g,(pvalid ? lab : NULL),perm,canong,m,n);
+		}
+                cvalid = FALSE;
+                ovalid = FALSE;
+            }
+            else
+	    {
+                fprintf(ERRFILE,"g is not defined\n");
+		FLUSHANDPROMPT;
+	    }
+            break;
+
+        case 'R':   /* form subgraph */
+            if (gvalid)
+            {
+#if !MAXN
+                DYNALLOC2(graph,canong,canong_sz,n,m,"dreadnaut");
+#endif
+                readvperm(INFILE,perm,prompt,n,&nperm);
+                if ((minus && nperm == n) || (!minus && nperm == 0))
+		{
+                    fprintf(ERRFILE,"can't form null graph\n");
+		    FLUSHANDPROMPT;
+		}
+                else if (minus)
+                {
+                    sublabel(g,perm+nperm,n-nperm,canong,m,n);
+                    if (pvalid) numcells = subpartition(lab,ptn,n,perm+nperm,n-nperm);
+                    n = n - nperm;
+                }
+                else
+                {
+                    sublabel(g,perm,nperm,canong,m,n);
+                    if (pvalid) numcells = subpartition(lab,ptn,n,perm,nperm);
+                    n = nperm;
+                }
+                cvalid = FALSE;
+                ovalid = FALSE;
+                m = SETWORDSNEEDED(n);
+            }
+            else if (gvalid_sg)
+            {
+                readvperm(INFILE,perm,prompt,n,&nperm);
+                if ((minus && nperm == n) || (!minus && nperm == 0))
+		{
+                    fprintf(ERRFILE,"can't form null graph\n");
+		    FLUSHANDPROMPT;
+		}
+                else if (minus)
+                {
+                    sublabel_sg(&g_sg,perm+nperm,n-nperm,&canong_sg);
+                    if (pvalid) numcells = subpartition(lab,ptn,n,perm+nperm,n-nperm);
+                    n = n - nperm;
+                }
+                else
+                {
+                    sublabel_sg(&g_sg,perm,nperm,&canong_sg);
+                    if (pvalid) numcells = subpartition(lab,ptn,n,perm,nperm);
+                    n = nperm;
+                }
+                cvalid_sg = FALSE;
+                ovalid = FALSE;
+                m = SETWORDSNEEDED(n);
+            }
+            else
+	    {
+                fprintf(ERRFILE,"g is not defined\n");
+		FLUSHANDPROMPT;
+	    }
+            minus = FALSE;
+            break;
+
+        case '_':   /* complement graph or converse digraph */
+            minus = FALSE;
+            if ((d = getc(INFILE)) != '_') ungetc(d,INFILE);
+
+            if (!gvalid && !gvalid_sg)
+	    {
+                fprintf(ERRFILE,"g is not defined\n");
+		FLUSHANDPROMPT;
+	    }
+            else if (gvalid)
+            {
+                if (d == '_') converse(g,m,n);
+                else          complement(g,m,n);
+                cvalid = FALSE;
+            }
+	    else
+	    {
+		if (d == '_')
+		{
+		    copy_sg(&g_sg,&canong_sg);
+		    converse_sg(&canong_sg,&g_sg);
+                    cvalid_sg = FALSE;
+		}
+	        else
+		{
+		    copy_sg(&g_sg,&canong_sg);
+		    complement_sg(&canong_sg,&g_sg);
+                    cvalid_sg = FALSE;
+		}
+	    }
+            break;
+
+        case '@':   /* copy canong into savedg */
+            minus = FALSE;
+            if (cvalid)
+            {
+#if !MAXN
+                DYNALLOC2(graph,savedg,savedg_sz,n,m,"dreadnaut");
+                DYNALLOC1(int,savedlab,savedlab_sz,n,"dreadnaut");
+                DYNALLOC1(int,savedptn,savedptn_sz,n,"dreadnaut");
+#endif
+                sgn = n;
+		memcpy(savedg,canong,m*(size_t)n*sizeof(setword));
+                for (i = n; --i >= 0;)
+		{
+		    savedlab[i] = lab[i];
+		    savedptn[i] = ptn[i];
+		}
+                sgorg = labelorg;
+            }
+            else if (cvalid_sg)
+	    {
+#if !MAXN
+                DYNALLOC1(int,savedlab,savedlab_sz,n,"dreadnaut");
+                DYNALLOC1(int,savedptn,savedptn_sz,n,"dreadnaut");
+#endif
+		sgn = n;
+		copy_sg(&canong_sg,&savedg_sg);
+                for (i = n; --i >= 0;)
+		{
+		    savedlab[i] = lab[i];
+		    savedptn[i] = ptn[i];
+		}
+                sgorg = labelorg;
+	    }
+            else
+	    {
+                fprintf(ERRFILE,"h is not defined\n");
+		FLUSHANDPROMPT;
+	    }
+            break;
+
+        case '#':   /* compare canong to savedg */
+            if ((d = getc(INFILE)) != '#') ungetc(d,INFILE);
+
+            if (cvalid || cvalid_sg)
+            {
+                if (sgn > 0)
+                {
+                    if (sgn != n)
+                        fprintf(outfile,
+                              "h and h' have different sizes.\n");
+                    else
+                    {
+			if (cvalid)
+		 	{
+                            for (sli = 0; sli < m*(size_t)n; ++sli)
+                                if (savedg[sli] != canong[sli]) break;
+			    same = (sli == m*(size_t)n); 
+			}
+			else
+			    same = aresame_sg(&canong_sg,&savedg_sg);
+
+                        if (!same)
+                            fprintf(outfile,"h and h' are different.\n");
+                        else
+                        {
+			    for (i = 0; i < n; ++i)
+				if ((ptn[i] == 0) != (savedptn[i] == 0))
+				    break;
+			    if (i < n)
+                                fprintf(outfile,
+                 "h and h' are identical but have incompatible colourings.\n");
+			    else
+                                fprintf(outfile,
+                                    "h and h' are identical.\n");
+                            if (d == '#')
+                                putmapping(outfile,savedlab,sgorg,
+                                       lab,labelorg,options_linelength,n);
+                        }
+                    }
+                }
+                else
+		{
+                    fprintf(ERRFILE,"h' is not defined\n");
+		    FLUSHANDPROMPT;
+		}
+            }
+            else
+	    {
+                fprintf(ERRFILE,"h is not defined\n");
+		FLUSHANDPROMPT;
+	    }
+            break;
+
+        case 'j':   /* relabel graph randomly */
+            minus = FALSE;
+            if (gvalid)
+            {
+                ranperm(perm,n);
+#if !MAXN
+                DYNALLOC2(graph,canong,canong_sz,n,m,"dreadnaut");
+#endif
+                relabel(g,(pvalid?lab:NULL),perm,canong,m,n);
+                cvalid = FALSE;
+                ovalid = FALSE;
+                freeschreier(NULL,&generators);
+            }
+            else if (gvalid_sg)
+            {
+                ranperm(perm,n);
+                relabel_sg(&g_sg,(pvalid?lab:NULL),perm,&canong_sg);
+                cvalid_sg = FALSE;
+                ovalid = FALSE;
+                freeschreier(NULL,&generators);
+            }
+            else
+	    {
+                fprintf(ERRFILE,"g is not defined\n");
+		FLUSHANDPROMPT;
+	    }
+            break;
+
+        case 'v':   /* write vertex degrees */
+            minus = FALSE;
+            if ((d = getc(INFILE)) != 'v') ungetc(d,INFILE);
+
+            if (gvalid)
+	    {
+                if (d == 'v') putdegseq(outfile,g,options_linelength,m,n);
+                else          putdegs(outfile,g,options_linelength,m,n);
+	    }
+            else if (gvalid_sg)
+	    {
+                if (d == 'v') putdegseq_sg(outfile,&g_sg,options_linelength);
+                else          putdegs_sg(outfile,&g_sg,options_linelength);
+	    }
+            else
+	    {
+                fprintf(ERRFILE,"g is not defined\n");
+		FLUSHANDPROMPT;
+	    }
+            break;
+
+        case '%':   /* do Mathon doubling operation */
+            minus = FALSE;
+            if (gvalid || gvalid_sg)
+            {
+#if !MAXN
+                if (2L * ((long)n + 1L) > NAUTY_INFINITY-2)
+                {
+                    fprintf(ERRFILE,
+                         "n can't be more than %d\n",NAUTY_INFINITY-2);
+                    break;
+                }
+#else
+                if (2L * ((long)n + 1L) > MAXN)
+                {
+                    fprintf(ERRFILE,"n can't be more than %d\n",MAXN);
+		    FLUSHANDPROMPT;
+                    break;
+                }
+#endif
+                newn = 2 * (n + 1);
+                newm = SETWORDSNEEDED(newn);
+#if !MAXN
+                DYNALLOC1(int,lab,lab_sz,newn,"dreadnaut");
+                DYNALLOC1(int,ptn,ptn_sz,newn,"dreadnaut");
+                DYNALLOC1(int,orbits,orbits_sz,newn,"dreadnaut");
+                DYNALLOC1(int,perm,perm_sz,newn,"dreadnaut");
+                DYNALLOC1(set,active,active_sz,newm,"dreadnaut");
+#endif
+                ovalid = FALSE;
+                pvalid = FALSE;
+                freeschreier(NULL,&generators);
+	    }
+            else
+	    {
+                fprintf(ERRFILE,"g is not defined\n");
+		FLUSHANDPROMPT;
+	    }
+
+	    if (gvalid)
+	    {
+#if !MAXN
+                DYNALLOC2(graph,canong,canong_sz,n,m,"dreadnaut");
+#endif
+		memcpy(canong,g,m*(size_t)n*sizeof(setword));
+
+#if !MAXN
+                DYNALLOC2(graph,g,g_sz,newn,newm,"dreadnaut");
+#endif
+                mathon(canong,m,n,g,newm,newn);
+                m = newm;
+                n = newn;
+                cvalid = FALSE;
+            }
+	    else if (gvalid_sg)
+	    {
+		copy_sg(&g_sg,&canong_sg);
+		mathon_sg(&canong_sg,&g_sg);
+                m = newm;
+                n = newn;
+                cvalid_sg = FALSE;
+            }
+            break;
+
+        case 's':   /* generate random graph */
+            minus = FALSE;
+	    d = getc(INFILE);
+	    if (d == 'r')
+		ranreg = TRUE;
+	    else
+	    {
+		ranreg = FALSE;
+		if (d != EOF) ungetc(d,INFILE);
+	    }
+
+            i = getint_sl(INFILE);
+	    if (ranreg)
+	    {
+		if (i < 0) i = 3;
+		if (i > MAXREG)
+		{
+		    fprintf(ERRFILE,"sr is limited to degree %d\n",MAXREG);
+		    FLUSHANDPROMPT;
+		    break;
+		}
+		if (SPARSEREP(mode))
+		{
+		    ranreg_sg(&g_sg,i,n);
+		    gvalid_sg = TRUE;
+		    cvalid = FALSE;
+                    ovalid = FALSE;
+                    freeschreier(NULL,&generators);
+                }
+		NODENSEYET
+	    }
+	    else
+	    {
+                if (i <= 0) i = 2;
+                if (!SPARSEREP(mode))
+                {
+#if !MAXN
+                    DYNALLOC2(graph,g,g_sz,n,m,"dreadnaut");
+#endif
+                    rangraph(g,options_digraph,i,m,n);
+                    gvalid = TRUE;
+                    cvalid = FALSE;
+                    ovalid = FALSE;
+                    freeschreier(NULL,&generators);
+                }
+                else
+		{
+		    rangraph2_sg(&g_sg,options_digraph,1,i,n);
+		    gvalid_sg = TRUE;
+                    cvalid = FALSE;
+                    ovalid = FALSE;
+                    freeschreier(NULL,&generators);
+                }
+	    }
+            break;
+
+        case 'q':   /* quit */
+            EXIT;
+            break;
+
+        case '"':   /* copy comment to output */
+            minus = FALSE;
+            copycomment(INFILE,outfile,'"');
+            break;
+
+        case 'I':   /* do refinement and invariants procedure */
+	    minus = FALSE;
+	    if (!gvalid && !gvalid_sg)
+	    {
+		fprintf(ERRFILE,"g is not valid\n");
+		FLUSHANDPROMPT;
+		break;
+	    }
+            if (!pvalid) unitptn(lab,ptn,&numcells,n);
+            cellstarts(ptn,0,active,m,n);
+#ifdef  CPUTIME
+            timebefore = CPUTIME;
+#endif
+            if (gvalid)
+	    {
+                doref(g,lab,ptn,0,&numcells,&qinvar,perm,active,&refcode,
+                    options.userrefproc ? options.userrefproc : 
+                    (m == 1 ? refine1 : refine),
+                    invarproc[options_invarproc].entrypoint,0,0,
+                    options_invararg,options_digraph,m,n);
+		if (numcells > 1) pvalid = TRUE;
+	    }
+            else if (gvalid_sg)
+	    {
+                doref((graph*)&g_sg,lab,ptn,0,&numcells,&qinvar,perm,
+                    active,&refcode,
+                    options_sg.userrefproc ? options_sg.userrefproc : 
+                    refine_sg,
+                    invarproc[options_invarproc].entrypoint_sg,0,0,
+                    options_invararg,options_digraph,m,n);
+		if (numcells > 1) pvalid = TRUE;
+	    }
+	    else
+	    {
+		fprintf(ERRFILE,"g is not valid\n");
+		FLUSHANDPROMPT;
+		break;
+	    }
+#ifdef  CPUTIME
+            timeafter = CPUTIME;
+#endif
+            fprintf(outfile," %d cell%s; code = %x",
+                    SS(numcells,"","s"),refcode);
+	    if (mode == SPARSE_MODE)
+	    {
+		if (invarproc[options_invarproc].entrypoint_sg)
+		    fprintf(outfile,
+                       " (%s %s)",invarproc[options_invarproc].name_sg,
+                       (qinvar == 2 ? "worked" : "failed"));
+	    }
+	    else if (mode == DENSE_MODE)
+	    {
+		if (invarproc[options_invarproc].entrypoint)
+		    fprintf(outfile,
+                       " (%s %s)",invarproc[options_invarproc].name,
+                       (qinvar == 2 ? "worked" : "failed"));
+	    }
+#ifdef  CPUTIME
+            fprintf(outfile,"; cpu time = %.2f seconds\n",
+                    timeafter-timebefore);
+#else
+            fprintf(outfile,"\n");
+#endif
+            if (numcells > 1) pvalid = TRUE;
+            break;
+
+        case 'i':   /* do refinement */
+	    minus = FALSE;
+	    if (!gvalid && !gvalid_sg)
+	    {
+		fprintf(ERRFILE,"g is not valid\n");
+		FLUSHANDPROMPT;
+		break;
+	    }
+            if (!pvalid) unitptn(lab,ptn,&numcells,n);
+            cellstarts(ptn,0,active,m,n);
+
+            if (multiplicity != 0 || mintime != 0.0)
+	    {
+	        savednc = numcells;
+#if !MAXN
+    		DYNALLOC1(int,tempptn,tempptn_sz,n,"dreadnaut");
+    		DYNALLOC1(int,templab,templab_sz,n,"dreadnaut");
+    		DYNALLOC1(set,tempactive,tempactive_sz,m,"dreadnaut");
+#endif
+		memcpy(templab,lab,n*sizeof(int));
+		memcpy(tempptn,ptn,n*sizeof(int));
+		for (i = 0; i < m; ++i) tempactive[i] = active[i];
+	    }
+
+#ifdef  CPUTIME
+            timebefore = CPUTIME;
+#endif
+	    actmult = 0;
+	    for (;;)
+	    {
+		if (actmult > 0)
+		{
+		    memcpy(lab,templab,n*sizeof(int));
+		    memcpy(ptn,tempptn,n*sizeof(int));
+		    for (i = 0; i < m; ++i) active[i] = tempactive[i];
+		    numcells = savednc;
+		}
+
+                if (options.userrefproc)
+                    (*options.userrefproc)
+                         (g,lab,ptn,0,&numcells,perm,active,&refcode,m,n);
+	        else if (gvalid)
+	        {
+                    if (m == 1)
+                        refine1(g,lab,ptn,0,&numcells,perm,active,&refcode,m,n);
+                    else
+                        refine(g,lab,ptn,0,&numcells,perm,active,&refcode,m,n);
+	        }
+	        else if (mode == SPARSE_MODE)
+		    refine_sg((graph*)&g_sg,lab,ptn,0,&numcells,perm,active,
+							         &refcode,m,n);
+	        else  /* traces mode */
+		    refine_tr(&g_sg,lab,ptn,&numcells,&refcode,&traces_opts);
+
+		++actmult;
+		if (multiplicity > 0 && actmult >= multiplicity) break;
+#ifdef  CPUTIME
+		if (mintime > 0.0 && (actmult < 20 || !(actmult&7)) 
+		     	&& CPUTIME >= timebefore+mintime)
+		    break;
+#endif
+	    }
+#ifdef  CPUTIME
+            timeafter = CPUTIME;
+#endif
+	    if (numcells > 1) pvalid = TRUE;
+            fprintf(outfile," %d cell%s; code = %x",
+                    SS(numcells,"","s"),refcode);
+#ifdef  CPUTIME
+            fprintf(outfile,"; cpu time = %.7f seconds\n",
+			      (timeafter-timebefore)/actmult);
+#else
+	    fprintf(outfile,"\n");
+#endif
+            break;
+
+        case 'x':   /* execute nauty */
+            minus = FALSE;
+            if (mode == TRACES_MODE)
+	    {
+                ovalid = FALSE;
+                cvalid_sg = FALSE;
+                if (!gvalid_sg)
+                {
+                    fprintf(ERRFILE,"g is not defined\n");
+		    FLUSHANDPROMPT;
+                    break;
+                }
+
+	        traces_opts.getcanon = options_getcanon;
+	        traces_opts.writeautoms = options_writeautoms;
+	        traces_opts.cartesian = options_cartesian;
+	        traces_opts.linelength = options_linelength;
+	        traces_opts.digraph = options_digraph;
+	        traces_opts.outfile = outfile;
+		traces_opts.verbosity = options_verbosity;
+		traces_opts.strategy = options_strategy;
+		if (options_keepgroup)
+		    traces_opts.generators = &generators;
+		else
+		    traces_opts.generators = NULL;
+
+#if !MAXN
+		DYNALLOC1(int,tempptn,tempptn_sz,n,"dreadnaut"); 
+#endif
+		if (!pvalid) unitptn(lab,ptn,&numcells,n);
+		memcpy(tempptn,ptn,n*sizeof(int));
+		savednc = numcells;
+		if (options_invarproc != 1 && options_maxinvarlevel > 0)
+                {
+                    if (options_maxinvarlevel > 1) fprintf(ERRFILE,
+		    "Warning: Traces only uses invariants at the top level\n");
+                    if (invarproc[options_invarproc].entrypoint_sg)
+		    {
+#ifdef  CPUTIME
+                        timebefore = CPUTIME;
+#endif
+			cellstarts(tempptn,0,active,m,n);
+			doref((graph*)&g_sg,lab,tempptn,0,&savednc,&qinvar,perm,
+			    active,&refcode,
+                    	    options_sg.userrefproc ? options_sg.userrefproc : 
+                    	    refine_sg,
+                    	    invarproc[options_invarproc].entrypoint_sg,0,0,
+                    	    options_invararg,options_digraph,m,n);
+                        fprintf(outfile,"Invariant %s %s; %d cell%s",
+			    invarproc[options_invarproc].name_sg,
+                            (qinvar == 2 ? "worked" : "failed"),
+			    SS(savednc,"","s"));
+#ifdef  CPUTIME
+                        timeafter = CPUTIME;
+			fprintf(outfile,"; cpu time = %.2f seconds\n",
+                    	    timeafter-timebefore);
+#else
+		 	fprintf(outfile,"\n");
+#endif
+		    }
+                }
+
+#ifdef  CPUTIME
+                timebefore = CPUTIME;
+#endif
+		actmult = 0;
+                setsigcatcher(); 
+                for (;;)
+                {
+                    traces_opts.defaultptn = !pvalid;
+                    Traces(&g_sg,lab,tempptn,orbits,&traces_opts,&traces_stats,
+		       &canong_sg);
+		    if (traces_stats.errstatus) break;
+                    traces_opts.writeautoms = FALSE;
+		    traces_opts.verbosity = 0;
+		    ++actmult;
+		    if (multiplicity > 0 && actmult >= multiplicity) break;
+#ifdef  CPUTIME
+		    if (mintime > 0.0 && (actmult < 20 || !(actmult&7))
+		       	   && CPUTIME >= timebefore+mintime)
+			break;
+#endif
+                }
+                unsetsigcatcher(); 
+#ifdef  CPUTIME
+                timeafter = CPUTIME;
+#endif
+            if (traces_stats.errstatus)
+            {
+                if (traces_stats.errstatus == NAUABORTED)
+                    fprintf(ERRFILE,"Traces aborted\n");
+                else if (traces_stats.errstatus == NAUKILLED)
+                    fprintf(ERRFILE,"Traces interrupted\n");
+                else
+                    fprintf(ERRFILE,
+                      "Traces returned error status %d [this can't happen]\n",
+                      traces_stats.errstatus);
+                cvalid = cvalid_sg = ovalid = FALSE;
+            }
+            else
+            {
+                fprintf(outfile,"%d orbit%s",
+				SS(traces_stats.numorbits,"","s"));
+		fprintf(outfile,"; grpsize=");
+		writegroupsize(outfile,
+			       traces_stats.grpsize1,traces_stats.grpsize2);
+                fprintf(outfile,"; %d gen%s",
+                     SS(traces_stats.numgenerators,"","s"));
+                fprintf(outfile,
+		     "; %lu node%s ", SS(traces_stats.numnodes,"","s"));
+		if (traces_stats.interrupted)
+		    fprintf(outfile,
+			    "(%lu interrupted, ",traces_stats.interrupted);
+		else
+		    fprintf(outfile,"(");
+                fprintf(outfile,"%lu peak); maxlev=%d\n",
+		    traces_stats.peaknodes,traces_stats.treedepth);
+                if (options_getcanon)
+                    fprintf(outfile,
+		            "canupdates=%d; ",traces_stats.canupdates);
+#ifdef  CPUTIME
+                fprintf(outfile,actmult == 1 ?
+                              "cpu time = %.2f seconds\n" :
+                              "cpu time = %.7f seconds\n",
+			      (timeafter-timebefore)/actmult);
+#else
+		fprintf(outfile,"\n");
+#endif
+		if (options_getcanon) cvalid_sg = TRUE;
+		ovalid = TRUE;
+            } 
+	    }
+            else 
+            {
+                ovalid = FALSE;
+                cvalid = cvalid_sg = FALSE;
+                if (!gvalid && !gvalid_sg)
+                {
+                    fprintf(ERRFILE,"g is not defined\n");
+		    FLUSHANDPROMPT;
+                    break;
+                }
+		if (mode == DENSE_MODE)
+		{
+                    if (pvalid)
+                    {
+                        fprintf(outfile,"[fixing partition]\n");
+                        options.defaultptn = FALSE;
+                    }
+                    else
+                        options.defaultptn = TRUE;
+
+                    options.outfile = outfile;
+                    options.digraph = options_digraph;
+                    options.cartesian = options_cartesian;
+                    options.schreier = (options_schreier > 0);
+                    options.getcanon = options_getcanon;
+                    options.tc_level = options_tc_level;
+                    options.linelength = options_linelength;
+		    options.invarproc
+				= invarproc[options_invarproc].entrypoint;
+		    options.mininvarlevel = options_mininvarlevel;
+		    if (options.invarproc)
+		       options.maxinvarlevel = options_maxinvarlevel;
+		    else
+		       options.maxinvarlevel = 0;
+		    options.invararg = options_invararg;
+		    if (options_schreier > 0)
+			schreier_fails(options_schreier);
+
+                    if (umask & U_NODE)  options.usernodeproc = NODEPROC;
+                    else                 options.usernodeproc = NULL;
+                    if (umask & U_AUTOM) options.userautomproc = AUTOMPROC;
+                    else                 options.userautomproc = NULL;
+                    if (umask & U_LEVEL) options.userlevelproc = LEVELPROC;
+                    else                 options.userlevelproc = NULL;
+                    if (umask & U_REF)   options.userrefproc = REFPROC;
+                    else                 options.userrefproc = NULL;
+                    if (umask & U_CANON) options.usercanonproc = CANONPROC;
+                    else                 options.usercanonproc = NULL;
+#if !MAXN
+                    if (options_getcanon)
+                        DYNALLOC2(graph,canong,canong_sz,n,m,"dreadnaut");
+                    DYNALLOC1(setword,workspace,workspace_sz,2*m*worksize,
+								"dreadnaut");
+#endif
+                    firstpath = TRUE;
+                    options.writeautoms = options_writeautoms;
+                    options.writemarkers = options_writemarkers;
+#ifdef  CPUTIME
+                    timebefore = CPUTIME;
+#endif
+		    actmult = 0;
+		    setsigcatcher();
+                    for (;;)
+                    {
+                        nauty(g,lab,ptn,NULL,orbits,&options,&stats,workspace,
+                             2*m*worksize,m,n,canong);
+			if (stats.errstatus) break;
+                        options.writeautoms = FALSE;
+                        options.writemarkers = FALSE;
+			++actmult;
+			if (multiplicity > 0 && actmult >= multiplicity)
+			    break;
+#ifdef  CPUTIME
+			if (mintime > 0.0 && (actmult < 20 || !(actmult&7)) 
+	  		        && CPUTIME >= timebefore+mintime)
+			    break;
+#endif
+                    }
+		    unsetsigcatcher();
+#ifdef  CPUTIME
+                    timeafter = CPUTIME;
+#endif
+		}
+		if (mode == SPARSE_MODE)
+		{
+                    if (pvalid)
+                    {
+                        fprintf(outfile,"[fixing partition]\n");
+                        options_sg.defaultptn = FALSE;
+                    }
+                    else
+                        options_sg.defaultptn = TRUE;
+
+                    options_sg.outfile = outfile;
+                    options_sg.digraph = options_digraph;
+                    options_sg.cartesian = options_cartesian;
+                    options_sg.schreier = (options_schreier > 0);
+                    options_sg.getcanon = options_getcanon;
+                    options_sg.linelength = options_linelength;
+		    options_sg.invarproc
+                         = invarproc[options_invarproc].entrypoint_sg;
+		    options_sg.mininvarlevel = options_mininvarlevel;
+		    if (options_sg.invarproc)
+		       options_sg.maxinvarlevel = options_maxinvarlevel;
+		    else
+		       options_sg.maxinvarlevel = 0;
+		    options_sg.invararg = options_invararg;
+                    options_sg.tc_level = options_tc_level;
+		    if (options_schreier > 0)
+			schreier_fails(options_schreier);
+
+                    if (umask & U_NODE)  options_sg.usernodeproc = NODEPROC;
+                    else                 options_sg.usernodeproc = NULL;
+                    if (umask & U_AUTOM) options_sg.userautomproc = AUTOMPROC;
+                    else                 options_sg.userautomproc = NULL;
+                    if (umask & U_LEVEL) options_sg.userlevelproc = LEVELPROC;
+                    else                 options_sg.userlevelproc = NULL;
+                    if (umask & U_REF)   options_sg.userrefproc = REFPROC;
+                    else                 options_sg.userrefproc = NULL;
+                    if (umask & U_CANON) options_sg.usercanonproc = CANONPROC;
+                    else                 options_sg.usercanonproc = NULL;
+#if !MAXN
+                    DYNALLOC1(setword,workspace,workspace_sz,2*m*worksize,
+								"dreadnaut");
+#endif
+
+                    firstpath = TRUE;
+                    options_sg.writeautoms = options_writeautoms;
+                    options_sg.writemarkers = options_writemarkers;
+#ifdef  CPUTIME
+                    timebefore = CPUTIME;
+#endif
+		    actmult = 0;
+		    setsigcatcher();
+                    for (;;)
+                    {
+                        nauty((graph*)&g_sg,lab,ptn,NULL,orbits,&options_sg,
+                         &stats,workspace,2*m*worksize,m,n,(graph*)&canong_sg);
+			if (stats.errstatus) break;
+                        options_sg.writeautoms = FALSE;
+                        options_sg.writemarkers = FALSE;
+			++actmult;
+			if (multiplicity > 0 && actmult >= multiplicity)
+			    break;
+#ifdef  CPUTIME
+			if (mintime > 0.0 && (actmult < 20 || !(actmult&7)) 
+	  		        && CPUTIME >= timebefore+mintime)
+			    break;
+#endif
+                    }
+		    unsetsigcatcher();
+#ifdef  CPUTIME
+                    timeafter = CPUTIME;
+#endif
+		}
+
+		if (stats.errstatus)
+		{
+		    if (stats.errstatus == NAUABORTED)
+		        fprintf(ERRFILE,"nauty aborted\n");
+		    else if (stats.errstatus == NAUKILLED)
+		        fprintf(ERRFILE,"nauty interrupted\n");
+                    else 
+                        fprintf(ERRFILE,
+                        "nauty returned error status %d [this can't happen]\n",
+                           stats.errstatus);
+		    cvalid = cvalid_sg = ovalid = FALSE;
+		}
+                else
+                {
+                    if (options_getcanon)
+		    {
+			if (mode == DENSE_MODE) cvalid = TRUE;
+			else                    cvalid_sg = TRUE;
+		    }
+                    ovalid = TRUE;
+                    fprintf(outfile,"%d orbit%s",SS(stats.numorbits,"","s"));
+		    fprintf(outfile,"; grpsize=");
+		    writegroupsize(outfile,stats.grpsize1,stats.grpsize2);
+                    fprintf(outfile,"; %d gen%s",
+                            SS(stats.numgenerators,"","s"));
+                    fprintf(outfile,"; %lu node%s",SS(stats.numnodes,"","s"));
+                    if (stats.numbadleaves)
+                        fprintf(outfile," (%lu bad lea%s)",
+                            SS(stats.numbadleaves,"f","ves"));
+                    fprintf(outfile,"; maxlev=%d\n", stats.maxlevel);
+                    /* fprintf(outfile,"tctotal=%lu",stats.tctotal); */
+                    if (options_getcanon)
+                        fprintf(outfile,"canupdates=%lu; ",stats.canupdates);
+#ifdef  CPUTIME
+                    fprintf(outfile,actmult == 1 ?
+                              "cpu time = %.2f seconds\n" :
+                              "cpu time = %.7f seconds\n",
+                            (timeafter-timebefore)/actmult);
+#else
+                    fprintf(outfile,"\n");
+#endif
+		    if (mode == DENSE_MODE && options_maxinvarlevel != 0
+		       && invarproc[options_invarproc].entrypoint)
+                    {
+                        fprintf(outfile,"invarproc \"%s\" succeeded %lu/%lu",
+                            invarproc[options_invarproc].name,
+			    stats.invsuccesses,stats.invapplics);
+                        if (stats.invarsuclevel > 0)
+                            fprintf(outfile," beginning at level %d.\n",
+                                    stats.invarsuclevel);
+                        else
+                            fprintf(outfile,".\n");
+                    }
+		    if (mode == SPARSE_MODE && options_maxinvarlevel != 0
+		       && invarproc[options_invarproc].entrypoint_sg)
+                    {
+                        fprintf(outfile,"invarproc \"%s\" succeeded %lu/%lu",
+                            invarproc[options_invarproc].name_sg,
+			    stats.invsuccesses,stats.invapplics);
+                        if (stats.invarsuclevel > 0)
+                            fprintf(outfile," beginning at level %d.\n",
+                                    stats.invarsuclevel);
+                        else
+                            fprintf(outfile,".\n");
+                    }
+                }
+	    }
+            break;
+
+        case 'A':   /* change mode, with possible conversion */
+	    minus = FALSE;
+	    oldmode = mode;
+	    d = getc(INFILE);
+	    if (d == 'n' || d == 'N' || d == 'd' || d == 'D') mode = DENSE_MODE;
+	    else if (d == 's' || d == 'S') mode = SPARSE_MODE;
+	    else if (d == 't' || d == 'T') mode = TRACES_MODE;
+	    else
+	    {
+		fprintf(ERRFILE,"Mode %c is unknown\n",(d?d:'0'));
+		FLUSHANDPROMPT;
+		break;
+	    }
+	    if ((d = getc(INFILE)) != '+')
+	    {
+		ungetc(d,INFILE);
+		gvalid = gvalid_sg = FALSE;
+		pvalid = ovalid = FALSE;
+	    }
+	    else
+	    {
+		if (SPARSEREP(oldmode) && !SPARSEREP(mode) && gvalid_sg)
+		{
+#if !MAXN
+		    DYNALLOC2(graph,g,g_sz,n,m,"dreadnaut");
+#endif
+		    sg_to_nauty(&g_sg,g,m,&m);
+		    gvalid_sg = FALSE;
+		    gvalid = TRUE;
+		}
+		if (!SPARSEREP(oldmode) && SPARSEREP(mode) && gvalid)
+		{
+		    nauty_to_sg(g,&g_sg,m,n);
+		    gvalid = FALSE;
+		    gvalid_sg = TRUE;
+		}
+	    }
+	    cvalid = cvalid_sg = FALSE;
+	    sgn = 0;    /* invalidate saved graph */
+	    break;
+
+        case 'f':   /* read initial partition */
+
+            if (minus)
+            {
+                pvalid = FALSE;
+                minus = FALSE;
+            }
+            else
+            {
+                readptn(INFILE,lab,ptn,&numcells,prompt,n);
+                pvalid = TRUE;
+	        freeschreier(NULL,&generators);
+            }
+            break;
+
+	case 'F':   /* individualise one more vertex */
+            if ((d = getc(INFILE)) != 'F') ungetc(d,INFILE);
+	    minus = FALSE;
+	    if (d != 'F')
+	    {
+	        i = getint_sl(INFILE);
+	        i -= labelorg;
+	        if (i < 0 || i >= n)
+		{
+		    fprintf(ERRFILE,"F argument must be 0..n-1\n");
+		    FLUSHANDPROMPT;
+		}
+	        else
+	        {
+	            if (!pvalid) unitptn(lab,ptn,&numcells,n);
+		    individualise(lab,ptn,0,i,&d,&numcells,n);
+		    pvalid = TRUE;
+	        }
+	    }
+	    else
+	    {
+		if (!gvalid && !gvalid_sg)
+		{
+		    fprintf(stderr,"g is not defined\n");
+		    FLUSHANDPROMPT;
+		    break;
+		}
+		if (!pvalid) unitptn(lab,ptn,&numcells,n);
+
+		if (!SPARSEREP(mode))
+		    i = targetcell(g,lab,ptn,0,1,options_digraph,-1,m,n);
+		else if (mode == SPARSE_MODE)
+		    i = targetcell_sg((graph*)&g_sg,lab,ptn,0,1,
+						options_digraph,-1,m,n);
+		else /* Traces mode */
+	        {
+		    maxsize = 0;
+		    for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+                    {
+                        for (cell2 = cell1; ptn[cell2] > 0; ++cell2) {}
+			if (cell2-cell1+1 > maxsize)
+			{
+			    i = cell1;
+			    maxsize = cell2 - cell1 + 1;
+			}
+		    }
+		}
+		
+		if (ptn[i] > 0)
+		{
+		    ptn[i] = 0;
+		    ++numcells;
+		}
+		pvalid = TRUE;
+	    }
+	    freeschreier(NULL,&generators);
+	    break;
+
+        case 't':   /* type graph */
+            minus = FALSE;
+            if (gvalid)
+                putgraph(outfile,g,options_linelength,m,n);
+            else if (gvalid_sg)
+                putgraph_sg(outfile,&g_sg,options_linelength);
+            else
+	    {
+                fprintf(ERRFILE,"g is not defined\n");
+		FLUSHANDPROMPT;
+	    }
+            break;
+
+        case 'T':   /* type graph preceded by n, $ and g commands */
+            minus = FALSE;
+            if (gvalid)
+            {
+                fprintf(outfile,"n=%d $=%d g\n",n,labelorg);
+                putgraph(outfile,g,options_linelength,m,n);
+                fprintf(outfile,"$$\n");
+            }
+            else if (gvalid_sg)
+            {
+                fprintf(outfile,"n=%d $=%d g\n",n,labelorg);
+                putgraph_sg(outfile,&g_sg,options_linelength);
+                fprintf(outfile,"$$\n");
+            }
+            else
+	    {
+                fprintf(ERRFILE,"g is not defined\n");
+		FLUSHANDPROMPT;
+	    }
+            break;
+
+        case 'u':   /* call user procs */
+            if (minus)
+            {
+                umask = 0;
+                minus = FALSE;
+            }
+            else
+            {
+                umask = getint_sl(INFILE);
+                if (umask < 0) umask = ~U_TCELL;
+            }
+            if (umask & U_TCELL)
+	    {
+                fprintf(ERRFILE,"usertcellproc() is gone at version 2.4\n");
+		umask &= ~U_TCELL;
+	    }
+            break;
+
+        case 'o':   /* type orbits */
+            minus = FALSE;
+            if (ovalid)
+                PUTORBITS(outfile,orbits,options_linelength,n);
+            else
+	    {
+                fprintf(ERRFILE,"orbits are not defined\n");
+		FLUSHANDPROMPT;
+	    }
+            break;
+
+        case 'O':   /* make orbits into a partition*/
+            minus = FALSE;
+            if ((d = getc(INFILE)) != 'O') ungetc(d,INFILE);
+
+            if (ovalid && d != 'O')
+	    {
+#if !MAXN
+    		DYNALLOC1(int,tempptn,tempptn_sz,n,"dreadnaut");
+#endif
+		for (i = n; --i >= 0;) tempptn[i] = 0;
+                for (i = n; --i >= 0;)
+	            if ((j = orbits[i]) < i)
+	            {
+		        tempptn[i] = tempptn[j];
+			tempptn[j] = i;
+		    }
+
+                k = 0; 
+		numcells = 0;
+		for (i = 0; i < n; ++i)
+		{
+		    if (orbits[i] == i)
+		    {
+			j = i;
+			do
+			{
+			    lab[k] = j;
+			    ptn[k] = 1;
+			    ++k;
+			    j = tempptn[j];
+			} while (j > 0);
+
+			ptn[k-1] = 0;
+			++numcells;
+		    }
+		}
+		pvalid = TRUE;
+	    }
+	    else if (ovalid && d == 'O')
+	    {
+#if !MAXN
+    		DYNALLOC1(int,tempptn,tempptn_sz,n,"dreadnaut");
+    		DYNALLOC1(int,templab,templab_sz,n,"dreadnaut");
+#endif
+		for (i = 0; i < n; ++i) tempptn[i] = 0;
+		for (i = 0; i < n; ++i) ++tempptn[orbits[i]];
+
+		j = 0;
+		for (i = 0; i < n; ++i)
+		    if (tempptn[i] > 0)
+		    {
+			templab[j] = i;
+			tempptn[j] = tempptn[i];
+			++j;
+		    }
+		sort2ints(tempptn,templab,j);
+
+		k = 0;
+		for (i = 0; i < j; ++i)
+		{ 
+		    ptn[templab[i]] = k;
+		    k += tempptn[i];
+		}
+		for (i = 0; i < n; ++i) lab[ptn[orbits[i]]++] = i;
+
+		for (i = 0; i < n; ++i) ptn[i] = 1;
+		k = 0;
+                numcells = 0;
+		for (i = 0; i < j; ++i)
+		{ 
+		    k += tempptn[i];
+		    if (i == j-1 || tempptn[i] != tempptn[i+1])
+		    {
+			ptn[k-1] = 0;
+			++numcells;
+		    }
+		}
+		pvalid = TRUE;
+	    }
+            else
+	    {
+                fprintf(ERRFILE,"orbits are not defined\n");
+		FLUSHANDPROMPT;
+	    }
+            break;
+
+        case 'b':   /* type canonlab and canong */
+            minus = FALSE;
+            if (cvalid)
+                putcanon(outfile,lab,canong,options_linelength,m,n);
+            else if (cvalid_sg)
+	    {
+		sortlists_sg(&canong_sg);
+                putcanon_sg(outfile,lab,&canong_sg,options_linelength);
+	    }
+            else
+	    {
+                fprintf(ERRFILE,"h is not defined\n");
+		FLUSHANDPROMPT;
+	    }
+            break;
+
+        case 'z':   /* type hashcode for canong */
+            minus = FALSE;
+            if (cvalid)
+            {
+                zseed = hashgraph(canong,m,n,2922320L);
+                fprintf(outfile,"[N%07lx",zseed);
+                
+                zseed = hashgraph(canong,m,n,19883109L);
+                fprintf(outfile," %07lx",zseed);
+                
+                zseed = hashgraph(canong,m,n,489317L); 
+                fprintf(outfile," %07lx]\n",zseed);
+            }
+            else if (cvalid_sg)
+            {
+                zseed = hashgraph_sg(&canong_sg,2922320L);
+                fprintf(outfile,"[%c%07lx",
+		        mode==SPARSE_MODE?'S':'T',zseed);
+                
+                zseed = hashgraph_sg(&canong_sg,19883109L);
+                fprintf(outfile," %07lx",zseed);
+                
+                zseed = hashgraph_sg(&canong_sg,489317L); 
+                fprintf(outfile," %07lx]\n",zseed);
+            }
+            else
+	    {
+                fprintf(ERRFILE,"h is not defined\n");
+		FLUSHANDPROMPT;
+	    }
+            break;
+
+        case 'c':   /* set getcanon option */
+            options_getcanon = !minus;
+            minus = FALSE;
+            break;
+
+        case 'w':   /* read size of workspace */
+            minus = FALSE;
+            worksize = getint_sl(INFILE);
+#if MAXN
+            if (worksize > 2*MAXM*WORKSIZE)
+            {
+                fprintf(ERRFILE,
+                   "too big - setting worksize = %d\n",WORKSIZE);
+                worksize = WORKSIZE;
+            }
+#endif
+            break;
+
+        case 'l':   /* read linelength for output */
+            options_linelength = getint_sl(INFILE);
+            minus = FALSE;
+            break;
+
+        case 'y':   /* set tc_level field of options */
+            options_tc_level = getint_sl(INFILE);
+            minus = FALSE;
+            break;
+
+        case 'M':   /* set multiplicity */
+	    if (minus)
+	    {
+	        multiplicity = 1;
+		mintime = 0.0;
+                minus = FALSE;
+	    }
+	    else
+	    {
+                multiplicity = getint_sl(INFILE);
+                if (multiplicity < 0) multiplicity = 0;
+		if ((d = getc(INFILE)) == '/')
+		{
+		    actmult = getint_sl(INFILE);
+		    if (actmult < 0) actmult = 0;
+		}
+		else
+		{
+		    ungetc(d,INFILE);
+		    actmult = 0;
+		}
+		if (multiplicity == 0 && actmult == 0) multiplicity = 1;
+		mintime = (double)actmult;
+	    }
+            break;
+
+        case 'k':   /* set invarlev fields of options */
+            options_mininvarlevel = getint_sl(INFILE);
+            options_maxinvarlevel = getint_sl(INFILE);
+            minus = FALSE;
+            break;
+
+        case 'K':   /* set invararg field of options */
+            options_invararg = getint_sl(INFILE);
+            minus = FALSE;
+            break;
+
+        case '*':   /* set invarproc field of options */
+            minus = FALSE;
+            d = getint_sl(INFILE);
+            if (d >= -1 && d <= NUMINVARS-2)
+            {
+                options_invarproc = d+1;
+                options_mininvarlevel = 0;
+                options_maxinvarlevel = 1;
+                if (options_invarproc >= 10 && options_invarproc <= 13)
+                    options.invararg = 3;
+                else
+                    options.invararg = 0;
+            }
+            else
+	    {
+                fprintf(ERRFILE,"no such vertex-invariant\n");
+		FLUSHANDPROMPT;
+	    }
+            break;
+
+        case 'a':   /* set writeautoms option */
+            options_writeautoms = !minus;
+            minus = FALSE;
+            break;
+
+        case 'm':   /* set writemarkers option */
+            options_writemarkers = !minus;
+            minus = FALSE;
+            break;
+
+        case 'V':   /* set verbosity for Traces */
+	    if (minus)
+	    {
+		options_verbosity = 0;
+		minus = FALSE;
+	    }
+	    else
+	    {
+                i = getint_sl(INFILE);
+                if (i < 0)
+		{
+		    fprintf(ERRFILE,"verbosity must be >= 0\n");
+		    FLUSHANDPROMPT;
+		}
+                else
+                    options_verbosity = i;
+	    }
+            break;
+
+        case 'S':   /* set strategy for Traces */
+	    if (minus)
+	    {
+		options_strategy = 0;
+		minus = FALSE;
+	    }
+	    else
+	    {
+                i = getint_sl(INFILE);
+		if (i != 0) fprintf(ERRFILE,
+                      "Only strategy 0 is supported in this version\n");
+/*
+                if (i < 0)
+		{
+		    fprintf(ERRFILE,"strategy must be >= 0\n");
+		    FLUSHANDPROMPT;
+		}
+                else
+                    options_strategy = i;
+*/
+	    }
+            break;
+
+        case 'G':   /* set schreier option */
+	    if (minus)
+	    {
+		options_schreier = 0;
+		minus = FALSE;
+	    }
+	    else
+	    {
+                i = getint_sl(INFILE);
+                if (i < 0)
+		{
+		    fprintf(ERRFILE,"schreierfails must be >= 0\n");
+		    FLUSHANDPROMPT;
+		}
+                else
+		{
+		    options_schreier = i;
+		    if (i > 0) schreier_fails(i);
+		}
+	    }
+            break;
+
+        case 'p':   /* set cartesian option */
+            options_cartesian = !minus;
+            minus = FALSE;
+            break;
+
+        case 'd':   /* set digraph option */
+            if (options_digraph && minus) gvalid = gvalid_sg = FALSE;
+            options_digraph = !minus;
+            minus = FALSE;
+            break;
+
+        case 'P':   /* set keep-group option */
+            if (minus && options_keepgroup)
+	    {
+		options_keepgroup = FALSE;
+		freeschreier(NULL,&generators);
+	    }
+	    else
+	    {
+		if ((d = getc(INFILE)) != 'P') ungetc(d,INFILE);
+                options_keepgroup = TRUE;
+		if (d == 'P')
+		{
+		    readvperm(INFILE,perm,prompt,n,&nperm);
+		    if (nperm != n)
+		    {
+			fprintf(ERRFILE,"Incomplete permutation\n");
+			FLUSHANDPROMPT;
+		    }
+		    else
+			addpermutation(&generators,perm,n);
+		}
+	    }
+            minus = FALSE;
+            break;
+
+        case '$':   /* set label origin */
+            if ((d = getc(INFILE)) == '$')
+                labelorg = oldorg;
+            else
+            {
+                ungetc(d,INFILE);
+                oldorg = labelorg;
+                i = getint_sl(INFILE);
+                if (i < 0)
+		{
+		    fprintf(ERRFILE,"labelorg must be >= 0\n");
+		    FLUSHANDPROMPT;
+		}
+                else
+                    labelorg = i;
+            }
+            break;
+
+        case '?':   /* type options, etc. */
+            minus = FALSE;
+	    fprintf(outfile,"Mode=%s ",
+		(mode==DENSE_MODE?"dense":
+		 mode==SPARSE_MODE?"sparse":"Traces"));
+            fprintf(outfile,"m=%d n=%d labelorg=%d",m,n,labelorg);
+            if (!gvalid && !gvalid_sg)
+                fprintf(outfile," g=undef");
+            else if (gvalid)
+            {
+                uli = 0;
+                for (i = 0, gp = g; i < n; ++i, gp += m) uli += setsize(gp,m);
+                if (options_digraph) fprintf(outfile," arcs=%lu",uli);
+                else                 fprintf(outfile," edges=%lu",uli/2);
+            }
+            else
+            {
+                uli = g_sg.nde;
+                if (options_digraph) fprintf(outfile," arcs=%lu",uli);
+                else                 fprintf(outfile," edges=%lu",uli/2);
+            }
+            fprintf(outfile," options=(%cc%ca%cm%cp%cd",
+                        PM(options_getcanon),PM(options_writeautoms),
+                        PM(options_writemarkers),PM(options_cartesian),
+                        PM(options_digraph));
+	    if (mode == TRACES_MODE)
+		fprintf(outfile,"%cP",PM(options_keepgroup));
+            if (umask & 31)
+                fprintf(outfile," u=%d",umask&31);
+            if (options_tc_level > 0)
+                fprintf(outfile," y=%d",options_tc_level);
+            if (options_mininvarlevel != 0 || options_maxinvarlevel != 0)
+                fprintf(outfile," k=(%d,%d)",
+                              options_mininvarlevel,options_maxinvarlevel);
+            if (options_invararg > 0)
+                fprintf(outfile," K=%d",options_invararg);
+            if (multiplicity != 1 || mintime != 0.0)
+		fprintf(outfile," M=%d/%.0f",multiplicity,mintime);
+            fprintf(outfile,")\n");
+            fprintf(outfile,"linelen=%d worksize=%d input_depth=%d",
+                            options_linelength,worksize,curfile);
+	    if (options_schreier > 0)
+		fprintf(outfile," G=%d",options_schreier);
+	    if (mode == TRACES_MODE)
+	    {
+		if (options_verbosity != 1)
+		    fprintf(outfile," V=%d",options_verbosity);
+		if (options_strategy != 0)
+		    fprintf(outfile," S=%d",options_strategy);
+	    }
+            if (options_invarproc != 1)
+                fprintf(outfile," invarproc=%s",
+		  (mode == DENSE_MODE ?
+		    invarproc[options_invarproc].name : 
+		    invarproc[options_invarproc].name_sg)); 
+            if (pvalid)
+                fprintf(outfile,"; %d cell%s",SS(numcells,"","s"));
+            else
+                fprintf(outfile,"; 1 cell");
+            fprintf(outfile,"\n");
+            if (outfile != PROMPTFILE)
+	    {
+	        fprintf(outfile,"Mode=%s ",
+		    (mode==DENSE_MODE?"dense":
+		     mode==SPARSE_MODE?"sparse":"Traces"));
+                fprintf(PROMPTFILE,"n=%d depth=%d labelorg=%d\n",
+                     n,curfile,labelorg);
+	    }
+            break;
+
+        case '&':   /* list the partition and possibly the quotient */
+            if ((d = getc(INFILE)) == '&')
+                doquot = TRUE;
+            else
+            {
+                ungetc(d,INFILE);
+                doquot = FALSE;
+            }
+            minus = FALSE;
+            if (pvalid)
+                putptn(outfile,lab,ptn,0,options_linelength,n);
+            else
+                fprintf(outfile,"unit partition\n");
+            if (doquot)
+            {
+                if (!pvalid) unitptn(lab,ptn,&numcells,n);
+		if (SPARSEREP(mode))
+		    putquotient_sg(outfile,&g_sg,lab,ptn,0,options_linelength);
+		else
+                    putquotient(outfile,g,lab,ptn,0,options_linelength,m,n);
+            }
+            break;
+
+        case 'h':   /* type help information */
+        case 'H':
+            minus = FALSE;
+            help(PROMPTFILE,c == 'H');
+            break;
+
+        default:    /* illegal command */
+            fprintf(ERRFILE,"'%c' is illegal - type 'h' for help\n",c);
+	    FLUSHANDPROMPT;
+            break;
+
+        }  /* end of switch */
+
+        if (flushing) fflush(outfile);
+    }
+
+    exit(0);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  help(f,i) writes help information to file f (i = 0,1).                    *
+*                                                                            *
+*****************************************************************************/
+
+static void
+help(FILE *f, int i)
+{
+#define H(ss) fprintf(f," %s\n",ss);
+
+if (i == 0)
+{
+H("Modes: An = dense, As = sparse, At = Traces; extra + to convert graph")
+H("+- a : write automs     v,vv : write degrees    *=# : select invariant:")
+H("   b : write canong      w=# : set worksize (units of 2m)")
+H("+- c : canonise            x : run nauty          -1 = user-defined")
+H("+- d : digraph or loops  y=# : set tc_level        0 = none")
+H("   e : edit graph          z : write hashcode      1 = twopaths")
+H("-f, f=#, f=[...] : set colours                     2 = adjtriang(K=0,1)")
+H("   g : read graph        $=# : set origin          3 = triples")
+H(" h,H : help               $$ : restore origin      4 = quadruples")
+H("   i : refine              ? : type options        5 = celltrips")
+H("   I : refine using invar  _ : compl  __ : conv    6 = cellquads")
+H("   j : relabel randomly    % : Mathon doubling     7 = cellquins")
+H("k=# # : set invar levels   & : type colouring      8 = distances(K)")
+H(" K=# : set invar param    && : + quotient matrix   9 = indsets(K)")
+H(" l=# : set line length   >ff : write to file      10 = cliques(K)")
+H("+- m : write markers    >>ff : append to file     11 = cellcliq(K)")
+H(" n=# : set order      ->/->> : close/flush output 12 = cellind(K)")
+H("   o : write orbits      <ff : read from file     13 = adjacencies")
+H("+- p : set autom format    @ : save canong        14 = cellfano")
+H("   q : quit                # : canong = savedg?   15 = cellfano2")
+H(" r,R : relabel/subgraph   ## : + write mapping    16 = refinvar")
+H(" s=# : random g (p=1/#) sr=# : random reg   \"...\" : copy comment")
+H("-G,G=# : schreier param  F=# : fix extra vertex  FF: fix target vertex")
+H(" t,T : type graph          ! : ignore line        O : orbits->partition")
+H("+- P : keep group         PP : add automorphism    Type H for more..")
+}
+
+if (i == 1)
+{
+H("Commands for g and e : ")
+H("   There is always a \"current vertex\" v, initially first vertex.")
+H("   # : add edge v-#       ; : increment v (exit if over limit)")
+H("  -# : delete edge v-#   #: : set v := #")
+H("   ? : list nbhs of v     . : exit")
+H("Mode change:   An = dense nauty, As = sparse nauty, At = Traces")
+H("Use An+, As+ or At+ to also convert graph between dense and sparse")
+H("Command line argument -o options  allows a,c,d,m,p,l,G,P,w,y,$,A,V,M")
+H("Syntax for f :  f=[2 3|4:9|10]  (rest in extra cell at right)")
+H("               -f same as f=[], f=# same as f=[#]")
+H("Syntax for r :  r 2:4 1 5;    (rest appended in order)")
+H("r& relabels the graph and partition in order of the partition")
+H("Syntax for R :  R 2:4 1 5;   or  -R 0 3 6:10;")
+H("Syntax for PP :  PP 2:4 1 5 0; (must be complete)")
+H("Arguments for u : 1=node,2=autom,4=level,16=ref,32=canon (add them)")
+H("Accurate times: M=#/# set number of runs and minimum total cpu.")
+}
+
+}
+
+/*****************************************************************************
+*                                                                            *
+*  usernode(g,lab,ptn,level,numcells,tc,code,m,n) is a simple version of the *
+*  procedure named by options.usernodeproc.                                  *
+*                                                                            *
+*****************************************************************************/
+
+static void
+usernode(graph *g, int *lab, int *ptn, int level, int numcells,
+     int tc, int code, int m, int n)
+{
+    int i;
+
+    for (i = 0; i < level; ++i) PUTC('.',outfile);
+    if (numcells == n)
+        fprintf(outfile,"(n/%d)\n",code);
+    else if (tc < 0)
+        fprintf(outfile,"(%d/%d)\n",numcells,code);
+    else
+        fprintf(outfile,"(%d/%d/%d)\n",numcells,code,tc);
+    if (firstpath) putptn(outfile,lab,ptn,level,options_linelength,n);
+    if (numcells == n) firstpath = FALSE;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  userautom(count,perm,orbits,numorbits,stabvertex,n) is a simple           *
+*  version of the procedure named by options.userautomproc.                  *
+*                                                                            *
+*****************************************************************************/
+
+static void
+userautom(int count, int *perm, int *orbits,
+      int numorbits, int stabvertex, int n)
+{
+    fprintf(outfile,
+         "**userautomproc:  count=%d stabvertex=%d numorbits=%d\n",
+         count,stabvertex+labelorg,numorbits);
+    PUTORBITS(outfile,orbits,options_linelength,n);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  userlevel(lab,ptn,level,orbits,stats,tv,index,tcellsize,numcells,cc,n)    *
+*  is a simple version of the procedure named by options.userlevelproc.      *
+*                                                                            *
+*****************************************************************************/
+
+static void
+userlevel(int *lab, int *ptn, int level, int *orbits, statsblk *stats,
+      int tv, int index, int tcellsize, int numcells, int cc, int n)
+{
+    fprintf(outfile,
+        "**userlevelproc:  level=%d tv=%d index=%d tcellsize=%d cc=%d\n",
+        level,tv+labelorg,index,tcellsize,cc);
+    fprintf(outfile,"    nodes=%lu cells=%d orbits=%d generators=%d\n",
+        stats->numnodes,numcells,stats->numorbits,stats->numgenerators);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  usercanon(g,lab,canong,count,code,m,n)                                    *
+*  is a simple version of the procedure named by options.userlevelproc.      *
+*                                                                            *
+*****************************************************************************/
+
+static int
+usercanon(graph *g, int *lab, graph *canong, int count, int code,
+            int m, int n)
+{
+    fprintf(outfile,
+	"**usercanonproc: count=%d code=%d\n",count,code);
+    return 0;
+}
diff --git a/lib/nauty/dretodot.c b/lib/nauty/dretodot.c
new file mode 100644
index 0000000..108f3fa
--- /dev/null
+++ b/lib/nauty/dretodot.c
@@ -0,0 +1,753 @@
+/* This is dretodot.c version 1.0 (Feb 2016), which is included in     *
+ * nauty distribution (version 2.6).                                   *
+ * See the file COPYRIGHT for the details of the software license.     *
+ *                                                                     *
+ * gcc -03 -o dretodot dretodot.c nauty.a                              *
+ * nauty.a is produced by: make all                                    */
+
+#define USAGE "dretodot [-S#:#ixF#o#m#n#r#:#[r#]d#g] [infile.dre [outfile.dot [outfile.dre]]]"
+
+#define HELPTEXT \
+" Read graphs and initial coloring in dreadnaut format.\n\
+ Write graphs in dot format to outfile.dot.\n\
+ If outfile.dre is given, write the input graph and the partition,\n\
+ as modified by the -F and -i options, to outfile.dre. outfile.dre\n\
+ is allowed to be the same file as infile.dre.\n\
+    -V    Set max number of vertices (default 1000).\n\
+    -E    Set max number of edges (default 5000).\n\
+    -v    Set verbose mode (default NO).\n\
+   -S#:# Set maximum width and height of the drawing, in inches\n\
+         (default 10 x 6.18).\n\
+   -i    Refine the partition before drawing (default NO).\n\
+   -x    Draw the orbit partition, computed by Traces. (default NO).\n\
+   -F#   Individualize vertex # (and refine the partition).\n\
+   -o#   Label vertices starting at # (default 0). This can be\n\
+         overridden in the input.\n\
+   -m#   Set the drawing model (see http://www.graphviz.org): \n\
+         0 (or any value different from 1,...,5)=dot (default 0),\n\
+         1=neato, 2=fdp, 3=sfdp, 4=twopi, 5=circo.\n\
+   -n#   Scale the size of vertices in the drawing (#=0,1,2; default 1).\n\
+   -r#:# (-r#) Set the vertices to be drawn at the topmost level\n\
+         in a hierarchical (dot model) drawing (default none).\n\
+         Any sequence of -r#:# (r#) options is allowed.\n\
+   -d#   Draw the graph induced by vertices at topmost level\n\
+         and by vertices at distance # from them; example:\n\
+         ./dretodot -n2 -r1 -r12:17 -d2 MyGraph.dre Outfile.dot.\n\
+   -g    Highlight the induced subgraph into the whole graph.\n"
+
+/*************************************************************************/
+
+#include <math.h>
+#include "gtools.h"  /* which includes nauty.h and stdio.h */
+#include "traces.h"
+
+#define SORT_OF_SORT 2
+#define SORT_TYPE1 int
+#define SORT_TYPE2 int
+#define SORT_NAME sort2ints
+#include "sorttemplates.c"
+
+#define WRITEDREFILE if (argnum == 3) { \
+fprintf(drefile, "n=%d $=%d g\n", n, labelorg); \
+putgraph_sg(drefile, &g, 0); \
+if (numcells > 1) { \
+fprintf(drefile, "f = "); \
+putptn(drefile,lab,ptn,0,0,n); }}
+
+
+extern int labelorg;
+
+/**************************************************************************/
+typedef struct NodeShape {
+    char color[6];
+    int labcol;
+} NodeShape;
+
+typedef struct list {
+    int vtx;
+    struct list *next;
+} list;
+
+struct list *NewListelem(int el)
+{
+	struct list *L;
+	
+    L = malloc(sizeof(list));
+    if (L == NULL) {
+        fprintf(ERRFILE, "\nError, memory not allocated.\n");
+        exit(1);
+    }
+	L->vtx = el;
+	L->next = NULL;
+	return L;
+}
+
+#define FONT_NAME "Arial Narrow"
+#if MAXN
+int lab[MAXN];
+int invlab[MAXN];
+int ptn[MAXN];
+NodeShape NShape[MAXN];
+int CurrVertices[MAXN];
+int DistStack[MAXN];
+int Ranks[MAXN];
+int orbits[MAXN];
+#else
+DYNALLSTAT(int, lab, lab_sz);
+DYNALLSTAT(int, invlab, invlab_sz);
+DYNALLSTAT(int, ptn, ptn_sz);
+DYNALLSTAT(NodeShape, NShape, NShape_sz);
+DYNALLSTAT(int, CurrVertices, CurrVertices_sz);
+DYNALLSTAT(int, DistStack, DistStack_sz);
+DYNALLSTAT(int, Ranks, Ranks_sz);
+DYNALLSTAT(int, orbits, orbits_sz);
+#endif
+
+DEFAULTOPTIONS_TRACES(traces_opts);
+TracesStats traces_stats;
+
+void CreateRandColors(int n)
+{
+	int i=0, ind0, ind1, ind2;
+    char aux[6];
+    
+    ran_init(n);
+	for (i = 0; i<n; i++)
+	{
+		strcpy(NShape[i].color, "\0");
+		strcpy(aux, "\0");
+
+        ind1 = KRAN(4096);
+        
+	    NShape[i].labcol=(ind1/128) % 2;
+	    for (ind0 = 0; ind0<3; ind0++)
+		{
+            ind2 = ind1 % 16;
+            ind1 = (ind1-ind2) / 16;
+            switch (ind2)
+            {
+				case 0:
+                    strcpy(aux, NShape[i].color);
+                    strcpy(NShape[i].color, "00");
+                    strcat(NShape[i].color, aux);
+                    break;
+				case 1:
+                    strcpy(aux, NShape[i].color);
+                    strcpy(NShape[i].color, "11");
+                    strcat(NShape[i].color, aux);
+                    break;
+				case 2:
+                    strcpy(aux, NShape[i].color);
+                    strcpy(NShape[i].color, "22");
+                    strcat(NShape[i].color, aux);
+                    break;
+				case 3:
+                    strcpy(aux, NShape[i].color);
+                    strcpy(NShape[i].color, "33");
+                    strcat(NShape[i].color, aux);
+                    break;
+				case 4:
+                    strcpy(aux, NShape[i].color);
+                    strcpy(NShape[i].color, "44");
+                    strcat(NShape[i].color, aux);
+                    break;
+				case 5:
+                    strcpy(aux, NShape[i].color);
+                    strcpy(NShape[i].color, "55");
+                    strcat(NShape[i].color, aux);
+                    break;
+				case 6:
+                    strcpy(aux, NShape[i].color);
+                    strcpy(NShape[i].color, "66");
+                    strcat(NShape[i].color, aux);
+                    break;
+				case 7:
+                    strcpy(aux, NShape[i].color);
+                    strcpy(NShape[i].color, "77");
+                    strcat(NShape[i].color, aux);
+                    break;
+				case 8:
+                    strcpy(aux, NShape[i].color);
+                    strcpy(NShape[i].color, "88");
+                    strcat(NShape[i].color, aux);
+                    break;
+				case 9:
+                    strcpy(aux, NShape[i].color);
+                    strcpy(NShape[i].color, "99");
+                    strcat(NShape[i].color, aux);
+                    break;
+				case 10:
+                    strcpy(aux, NShape[i].color);
+                    strcpy(NShape[i].color, "AA");
+                    strcat(NShape[i].color, aux);
+                    break;
+				case 11:
+                    strcpy(aux, NShape[i].color);
+                    strcpy(NShape[i].color, "BB");
+                    strcat(NShape[i].color, aux);
+                    break;
+				case 12:
+                    strcpy(aux, NShape[i].color);
+                    strcpy(NShape[i].color, "CC");
+                    strcat(NShape[i].color, aux);
+                    break;
+				case 13:
+                    strcpy(aux, NShape[i].color);
+                    strcpy(NShape[i].color, "DD");
+                    strcat(NShape[i].color, aux);
+                    break;
+				case 14:
+                    strcpy(aux, NShape[i].color);
+                    strcpy(NShape[i].color, "EE");
+                    strcat(NShape[i].color, aux);
+                    break;
+				case 15:
+                    strcpy(aux, NShape[i].color);
+                    strcpy(NShape[i].color, "FF");
+                    strcat(NShape[i].color, aux);
+                    break;
+            }
+		}
+	}
+}
+
+double ComputeFontsize(int vtx) {
+    int ndigits;
+    double fsize;
+    
+    if (vtx == 0) {
+        fsize = 13.0;
+    }
+    else {
+        ndigits=log10(vtx)+1;
+        switch (ndigits) {
+            case 1:
+                fsize = 13.0;
+                break;
+            case 2:
+                fsize = 13.0;
+                break;
+            case 3:
+                fsize = 11;
+                break;
+            case 4:
+                fsize = 9.5;
+                break;
+            case 5:
+                fsize = 8;
+                break;
+            case 6:
+                fsize = 6.5;
+                break;
+            default:
+                fsize = 5.0;
+                break;
+        }
+    }
+    return fsize;
+}
+
+int
+main(int argc, char *argv[])
+{
+	int m, n, c, a, i, j, k, end, n_count;
+    size_t j1, e_count;
+	int argnum, initorg, cell, numCol, modcode, vtx, refcode, MaxV, MaxE;
+	char *arg, sw;
+	boolean badargs, make_ranks, too_big;
+	boolean rswitch, dswitch, mswitch, nswitch, oswitch, iswitch, xswitch, Sswitch, gswitch, fswitch, vswitch, rswitch1, Eswitch, Vswitch;
+	char *infilename, *outfilename, *drefilename;
+	FILE *infile, *outfile, *drefile;
+	nauty_counter nin;
+	char s[10];
+	char model[10];
+    int numcells, flind, indivtx;
+    long minil, maxil;
+    double hsize, vsize, fsize;
+    sparsegraph g, g1;
+    list *liststart, *listend;
+    int nodescale, distance, StInd, StIndDist, RnkInd, RnkIndDist;
+    
+	HELP; PUTVERSION;
+    
+    liststart = listend = NULL;
+	rswitch = dswitch = mswitch = nswitch = oswitch = iswitch = xswitch = Sswitch = gswitch = fswitch = vswitch = rswitch1 = Vswitch = Eswitch = FALSE;
+	infilename = outfilename = drefilename = NULL;
+	initorg = minil = maxil = flind = 0;
+    hsize = 10.00;
+    vsize = 6.18;
+    modcode = 0;
+	n = -1;
+    nodescale = 1;
+    distance = 0;
+    
+	argnum = 0;
+	badargs = make_ranks = FALSE;
+    MaxV = 1000;
+    MaxE = 5000;
+    
+	for (j = 1; !badargs && j < argc; ++j)
+	{
+	    arg = argv[j];
+	    if (arg[0] == '-' && arg[1] != '\0')
+	    {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                SWBOOLEAN('i',iswitch)
+                else SWBOOLEAN('x',xswitch)
+                else SWBOOLEAN('g',gswitch)
+                else SWBOOLEAN('v',vswitch)
+                else SWINT('V', Vswitch, MaxV, ">E dretodot -V")
+                else SWINT('E', Eswitch, MaxE, ">E dretodot -E")
+                else SWINT('d', dswitch, distance, ">E dretodot -d")
+                else SWINT('F', fswitch, indivtx, ">E dretodot -F")
+                else SWINT('m', mswitch, modcode, ">E dretodot -m")
+                else SWINT('n', nswitch, nodescale, ">E dretodot -n")
+                else SWINT('o', oswitch, initorg, ">E dretodot -o")
+                else SWRANGE('r',":-",rswitch,minil,maxil,">E dretodot -r")
+                else SWREALRANGE('S',":-",Sswitch,hsize,vsize,">E dretodot -S")
+                else badargs = TRUE;
+            }
+            if (rswitch) {
+                rswitch1 = TRUE;
+                rswitch = FALSE;
+                for (i=minil; i<=maxil; i++) {
+                    if (liststart == NULL) {
+                        liststart = NewListelem(i);
+                        listend = liststart;
+                    } else {
+                        listend->next = NewListelem(i);
+                        listend = listend->next;
+                    }
+                }
+            }
+	    }
+	    else
+	    {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+	        else if (argnum == 2) outfilename = arg;
+	        else if (argnum == 3) drefilename = arg;
+            else                  badargs = TRUE;
+	    }
+	}
+    
+	if (labelorg < 0) gt_abort(">E dretodot: negative origin forbidden\n");
+    
+	if (badargs || argnum > 3)
+	{
+	    fprintf(stderr, ">E Usage: %s\n", USAGE);
+	    GETHELP;
+	    exit(1);
+	}
+    
+	if (!infilename || infilename[0] == '-')
+	{
+	    infilename = "stdin";
+	    infile = stdin;
+	}
+	else if ((infile = fopen(infilename, "r")) == NULL)
+	{
+	    fprintf(stderr, "Can't open input file %s\n", infilename);
+	    gt_abort(NULL);
+	}
+    
+	if (!outfilename || outfilename[0] == '-')
+	{
+	    outfilename = "stdout";
+	    outfile = stdout;
+	}
+	else if ((outfile = fopen(outfilename, "w")) == NULL)
+	{
+	    fprintf(stderr, "Can't open output file %s\n", outfilename);
+	    gt_abort(NULL);
+	}
+
+	labelorg = initorg;
+	nin = 0;
+    
+	while (fscanf(infile, "%1s", s) == 1)
+	{
+	    if (s[0] == 'n')
+	    {
+            if (fscanf(infile, "%1s", s) == 1 && s[0] != '=')
+                ungetc(s[0], infile);
+            if (fscanf(infile, "%d", &n) != 1)
+            {
+                fprintf(stderr, ">E dretodot: invalid n=# command\n");
+                gt_abort(NULL);
+            }
+            if (n <= 0)
+                gt_abort(">E dretodot: n can't be <= 0\n");
+	    }
+	    else if (s[0] == '"')
+	    {
+            while ((c = getc(infile)) != '"' && c != EOF) {}
+	    }
+	    else if (s[0] == '!')
+	    {
+            while ((c = getc(infile)) != '\n' && c != EOF) {}
+	    }
+	    else if (s[0] == '$')
+	    {
+            if ((s[0] = getc(infile)) == '$')
+                labelorg = initorg;
+            else
+            {
+                if (s[0] != '=') ungetc(s[0], infile);
+                if (fscanf(infile, "%d", &labelorg) != 1)
+                    gt_abort(">E dretodot: invalid $=# command\n");
+                if (labelorg < 0)
+                    gt_abort(">E dretodot: must have labelorg >= 0\n");
+            }
+        }
+	    else if (s[0] == 'g' || (s[0] >= '0' && s[0] <= '9')
+                 || s[0] == ';')
+	    {
+            if (n < 0)
+                gt_abort(">E dretodot: g command before n is defined\n");
+            if (s[0] != 'g') ungetc(s[0], infile);
+            m = (n + WORDSIZE - 1) / WORDSIZE;
+#if MAXN
+            if (n > MAXN || m > MAXM)
+                gt_abort(">E n or m too big\n");
+#else
+            DYNALLOC2(int, lab, lab_sz, n, m, "dretodot");
+            DYNALLOC2(int, invlab, invlab_sz, n, m, "dretodot");
+            DYNALLOC2(int, ptn, ptn_sz, n, m, "dretodot");
+            DYNALLOC2(NodeShape, NShape, NShape_sz, n, m, "dretodot");
+            DYNALLOC2(int, orbits, orbits_sz, n, m, "dretodot");
+#endif
+            
+            for (i=0; i<n; i++) {
+                lab[i] = i;
+                ptn[i] = 1;
+            }
+            ptn[n-1] = 0;
+            numcells = 1;
+            ++nin;
+            SG_INIT(g);
+            SG_INIT(g1);
+            readgraph_sg(infile, &g, FALSE, FALSE, 0, n);
+	    }
+        else if (s[0] == 'f') {
+            readptn(infile, lab, ptn, &numcells, FALSE, n);
+            if (numcells > 1) {
+                traces_opts.defaultptn = FALSE;
+            }
+        }
+        else
+	    {
+            fprintf(stderr, ">E dretodot: invalid command \"%c\"\n", s[0]);
+            gt_abort(NULL);
+	    }
+	}
+
+    fclose(infile);
+    
+    if ((nodescale != 0) && (nodescale != 1) && (nodescale != 2)) {
+        nodescale = 1;
+    }
+
+    if (!drefilename || drefilename[0] == '-')
+	{
+	    drefilename = "stdout";
+	    drefile = stdout;
+	}
+	else if ((drefile = fopen(drefilename, "w")) == NULL)
+	{
+	    fprintf(stderr, "Can't open output file %s\n", drefilename);
+	    gt_abort(NULL);
+	}
+    
+    if (!dswitch) distance = n;
+    
+    if (iswitch && !xswitch && !fswitch) {
+        if (vswitch) fprintf(stderr, ">Z  partition refinement...");
+        refine_tr(&g,lab,ptn,&numcells,&refcode,&traces_opts);
+        if (vswitch) fprintf(stderr, "done.\n");
+        WRITEDREFILE
+    }
+    
+    if (fswitch) {
+        indivtx -= labelorg;
+        refine_tr(&g,lab,ptn,&numcells,&refcode,&traces_opts);
+        cell = 0;
+        for (i=0; i<n; i++) {
+            if (lab[i] == indivtx) break;
+            if (!ptn[i]) {
+                cell = i+1;
+            }
+        }
+        lab[i] = lab[cell];
+        lab[cell] = indivtx;
+        ptn[cell] = 0;
+        numcells++;
+        traces_opts.defaultptn = FALSE;
+        refine_tr(&g,lab,ptn,&numcells,&refcode,&traces_opts);
+        if (!xswitch) WRITEDREFILE
+    }
+    
+    if (xswitch) {
+        if (vswitch) fprintf(stderr, ">Z  running Traces...");
+        Traces(&g,lab,ptn,orbits,&traces_opts,&traces_stats,&g1);
+        if (vswitch) fprintf(stderr, "done.\n");
+        WRITEDREFILE
+        for (i=0; i<n; i++) {
+            lab[i] = i;
+        }
+        sort2ints(orbits,lab,n);
+        memcpy(ptn,orbits,n*sizeof(int));
+    }
+    
+    strcpy(model, "\0");
+    switch (modcode) {
+        case 1:
+            strcpy(model, "neato");
+            break;
+        case 2:
+            strcpy(model, "fdp");
+            break;
+        case 3:
+            strcpy(model, "sfdp");
+            break;
+        case 4:
+            strcpy(model, "twopi");
+            break;
+        case 5:
+            strcpy(model, "circo");
+            break;
+        default:
+            strcpy(model, "dot");
+            modcode = 0;
+            break;
+    }
+    fprintf(outfile, "graph G\n{\n");
+    
+    if (vswitch) fprintf(stderr, ">Z  selected drawing model \"%s\".\n",model);
+    
+#if !MAXN
+    DYNALLOC2(int, CurrVertices, CurrVertices_sz, n, m, "dretodot");
+    DYNALLOC2(int, DistStack, DistStack_sz, n, m, "dretodot");
+    DYNALLOC2(int, Ranks, Ranks_sz, n, m, "dretodot");
+#endif
+
+    if (vswitch) fprintf(stderr, ">Z  analyzing graph: step 1");
+
+    if (!liststart) {
+        for (i=0; i<n; i++) {
+            CurrVertices[i] = 1;
+            DistStack[i] = i;
+            StInd = n;
+        }
+    } else {
+        memset(CurrVertices, 0, n*sizeof(int));
+        StInd = 0;
+        listend = liststart;
+        while (listend) {
+            if (listend->vtx-labelorg < 0 || listend->vtx-labelorg >= n) {
+                fprintf(stderr, ">W dretodot: invalid vertex %d\n", listend->vtx);
+            } else {
+                DistStack[StInd++] = listend->vtx-labelorg;
+                CurrVertices[listend->vtx-labelorg] = 1;
+            }
+            listend = listend->next;
+        }
+    }
+    
+    if (vswitch) fprintf(stderr, ", 2");
+
+    cell = 0;
+    for (i=0; i<n; i++) {
+        invlab[lab[i]] = i;
+        if (!xswitch) {
+            if (ptn[i] == 0) {
+                ptn[i] = cell++;
+            } else {
+                ptn[i] = cell;
+            }
+        }
+    }
+
+    if (vswitch) fprintf(stderr, ", 3");
+
+    k = RnkInd = 0;
+    StIndDist = StInd;
+    while (k<StInd) {
+        end = StInd;
+        for (j=k; j<end; j++) {
+            vtx = DistStack[j];
+                for (j1 = g.v[vtx]; j1<g.v[vtx]+g.d[vtx]; j1++) {
+                    if (!CurrVertices[g.e[j1]]) {
+                        if (RnkInd<distance) {
+                            CurrVertices[g.e[j1]] = 1;
+                        } else {
+                            CurrVertices[g.e[j1]] = 2;
+                        }
+                        DistStack[StInd++] = g.e[j1];
+                    }
+                }
+        }
+        if (RnkInd<distance) {
+            StIndDist = StInd;
+            RnkIndDist = RnkInd;
+        }
+        Ranks[RnkInd++] = k;
+        k=end;
+    }
+
+    if (gswitch) {
+        n_count = n;
+        e_count = g.nde;
+    } else {
+        n_count = 0;
+        e_count = 0;
+        for (i=0; i<n; i++) {
+            if (CurrVertices[i] == 1) {
+                n_count++;
+                for (j1 = g.v[i]; j1<g.v[i]+g.d[i]; j1++) {
+                    if ((i < g.e[j1]) && (CurrVertices[g.e[j1]] == 1)) {
+                        e_count++;
+                    }
+                }
+            }
+        }
+    }
+    
+    too_big = FALSE;
+    if (n_count > MaxV) {
+        fprintf(stderr, ">E Too many vertices (%d, max: %d; use -V# (at your own risk))\n", n_count, MaxV);
+        too_big = TRUE;
+    }
+    if (e_count > MaxE) {
+        fprintf(stderr, ">E Too many edges (%lu, max: %d; use -E# (at your own risk))\n", e_count, MaxE);
+        too_big = TRUE;
+    }
+    
+    if (too_big) {
+        exit(1);
+    }
+    if (vswitch) fprintf(stderr, ", 4");
+
+    if (Sswitch) {
+        if (gswitch) {
+            hsize *= log10(n);
+            vsize *= log10(n);
+        } else {
+            if (StIndDist) {
+                hsize *= log10(StIndDist);
+                vsize *= log10(StIndDist);
+            }
+        }
+    }
+
+    if (vswitch) fprintf(stderr, ".\n");
+
+    if (vswitch) fprintf(stderr, ">Z  creating colors...");
+    CreateRandColors(n);
+    if (vswitch) fprintf(stderr, "done\n");
+    
+    if (vswitch) fprintf(stderr, ">Z  drawing size %.2f x %.2f\n", hsize, vsize);
+    
+    /* Preamble */
+	fprintf(outfile, "graph [center=\"true\", size=\"%.2f, %.2f\", ratio=\"fill\", ranksep=\"0.25\", nodesep=\"0.40\",\n", hsize, vsize);
+    fprintf(outfile, "       outputorder=\"edgesfirst\", overlap=\"scale\", layout=\"%s\"];\n",model);
+	fprintf(outfile, "node  [shape=\"circle\", width=\"%.2f\", height=\"%.2f\", fixedsize=\"true\",\n",
+            0.5*nodescale, 0.5*nodescale);
+    fprintf(outfile, "       style=\"filled\", color=\"black\",\n");
+    fprintf(outfile, "       fontsize=\"13\", fontname=\"%s\"];\n", FONT_NAME);
+    
+    /* Nodes */
+    if (vswitch) fprintf(stderr, ">Z  drawing vertices...");
+
+    fprintf(outfile, "node  [color=\"black\", fontcolor=\"black\"]\n");
+
+    a = 1;
+    if (dswitch) end = StIndDist; else end = StInd;
+    make_ranks = ((modcode == 0) || (modcode > 5)) && rswitch1;
+
+    if (make_ranks) fprintf(outfile, "{ rank=\"source\";\n");
+    for (i=0; i<end; i++) {
+        vtx = DistStack[i];
+        fsize = ComputeFontsize(vtx) * (double)nodescale * 1.666;
+        if (make_ranks && (i==Ranks[a])) {
+            fprintf(outfile, "}\n{ rank=\"same\";\n");
+            a++;
+        }
+        numCol = ptn[invlab[vtx]];
+        if (fsize == 13.0) {
+            if (NShape[numCol].labcol == 0)
+                fprintf(outfile, "%6d [fontcolor=\"white\", fillcolor=\"#%s\"]\n", vtx + labelorg,
+                        NShape[numCol].color);
+            else
+                fprintf(outfile, "%6d [fillcolor=\"#%s\"]\n", vtx + labelorg,
+                        NShape[numCol].color);
+        } else {
+            if (NShape[numCol].labcol == 0)
+                fprintf(outfile, "%6d [fontsize=\"%.2f\", fontcolor=\"white\", fillcolor=\"#%s\"]\n", vtx + labelorg,
+                        fsize, NShape[numCol].color);
+            else
+                fprintf(outfile, "%6d [fontsize=\"%.2f\", fillcolor=\"#%s\"]\n", vtx + labelorg,
+                        fsize, NShape[numCol].color);
+        }
+    }
+    if (make_ranks) fprintf(outfile, "}\n");
+    
+    if (gswitch) {
+        fprintf(outfile, "node  [fontsize=\"%.2f\", fontcolor=\"gray\", color=\"gray\", fillcolor=\"gray97\"]\n", fsize);
+        for (i=0; i<n; i++) {
+            if (CurrVertices[i] != 1) {
+                fsize = ComputeFontsize(i) * (double)nodescale * 1.666;
+                fprintf(outfile, "%6d\n", i+labelorg);
+            }
+        }
+    }
+
+    if (vswitch) fprintf(stderr, "done\n");
+
+    /* Edges */
+    if (vswitch) fprintf(stderr, ">Z  drawing edges...");
+
+    if (gswitch) {
+        fprintf(outfile, "edge  [penwidth=\"0.4\", color=\"gray\", weight=\"10\"];\n");
+        for (vtx = 0; vtx < n; vtx++) {
+            for (j1 = g.v[vtx]; j1 < g.v[vtx] + g.d[vtx]; ++j1) {
+                if (CurrVertices[vtx] != 1 || CurrVertices[g.e[j1]] != 1) {
+                    if (g.e[j1] > vtx)
+                        fprintf(outfile, "%d -- %d;\n", vtx + labelorg, g.e[j1] + labelorg);
+                }
+            }
+        }
+    }
+
+    fprintf(outfile, "edge  [penwidth=\"0.8\", color=\"black\", weight=\"10\"];\n");
+	for (i = 0; i < StIndDist; ++i) {
+        vtx = DistStack[i];
+		for (j1 = g.v[vtx]; j1 < g.v[vtx] + g.d[vtx]; ++j1) {
+            if (CurrVertices[g.e[j1]] == 1) {
+                if (g.e[j1] > vtx)
+                    fprintf(outfile, "%d -- %d;\n", vtx + labelorg, g.e[j1] + labelorg);
+            }
+        }
+    }
+    
+    if (gswitch) {
+        RnkIndDist = RnkInd;
+    }
+    if (RnkIndDist>1) {
+        fprintf(outfile, "%d ", DistStack[0] + labelorg);
+        for (i=1; i<RnkIndDist; i++) {
+            fprintf(outfile, "-- %d ", DistStack[Ranks[i]] + labelorg);
+        }
+        fprintf(outfile, "[style=\"invis\"];\n");
+    }
+
+    fprintf(outfile, "}\n");
+
+    if (vswitch) fprintf(stderr, "done\n>Z  " COUNTER_FMT
+            " graph drawn from %s to %s\n",
+            nin, infilename, outfilename);
+	exit(0);
+}
diff --git a/lib/nauty/dretog.c b/lib/nauty/dretog.c
new file mode 100644
index 0000000..7b8d448
--- /dev/null
+++ b/lib/nauty/dretog.c
@@ -0,0 +1,229 @@
+/* dretog.c  version 1.1; B D McKay, Jan 2013. */
+
+#define USAGE "dretog [-n#o#sghq] [infile [outfile]]"
+
+#define HELPTEXT \
+" Read graphs in dreadnaut format.\n\
+\n\
+   -o#   Label vertices starting at # (default 0).  \n\
+         This can be overridden in the input.\n\
+   -n#   Set the initial graph order to # (no default).  \n\
+         This can be overridden in the input.\n\
+   -g    Use graph6 format (default for undirected graphs).\n\
+   -z    Use digraph6 format (default for directed graphs).\n\
+   -s    Use sparse6 format.\n\
+   -h    Write a header (according to -g, -z or -s).\n\
+   -q    Suppress auxiliary output.\n\
+\n\
+  Input consists of a sequence of dreadnaut commands restricted to:\n\
+\n\
+   n=#   set number of vertices (no default)\n\
+         The = is optional.\n\
+   $=#   set label of first vertex (default 0)\n\
+         The = is optional.\n\
+   d     indicate graph will be directed\n\
+   $$    return origin to initial value (see -o#)\n\
+   \"..\" and !..\\n   comments to ignore\n\
+   g     specify graph to follow (as dreadnaut format)\n\
+         Can be omitted if first character of graph is a digit or ';'.\n\
+   q     exit (optional)\n"
+
+/*************************************************************************/
+
+#include "gtools.h"  /* which includes nauty.h and stdio.h */
+
+/**************************************************************************/
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+	int m,n,c;
+	int argnum,j,outcode,initorg;
+	char *arg,sw;
+	boolean badargs,prompt,digraph;
+	boolean zswitch,sswitch,gswitch,oswitch,nswitch,hswitch,qswitch;
+	char *infilename,*outfilename;
+	FILE *infile,*outfile;
+	nauty_counter nin;
+	char s[10];
+#if MAXN
+	graph g[MAXN*MAXM];
+#else
+	DYNALLSTAT(graph,g,g_sz);
+#endif
+
+	HELP; PUTVERSION;
+
+	zswitch = sswitch = gswitch = oswitch = FALSE;
+	qswitch = nswitch = hswitch = FALSE;
+	infilename = outfilename = NULL;
+	initorg = 0;
+	n = -1;
+
+	argnum = 0;
+	badargs = FALSE;
+	for (j = 1; !badargs && j < argc; ++j)
+	{
+	    arg = argv[j];
+	    if (arg[0] == '-' && arg[1] != '\0')
+	    {
+		++arg;
+		while (*arg != '\0')
+		{
+		    sw = *arg++;
+		         SWBOOLEAN('s',sswitch)
+		    else SWBOOLEAN('g',gswitch)
+		    else SWBOOLEAN('z',zswitch)
+		    else SWBOOLEAN('h',hswitch)
+		    else SWBOOLEAN('q',qswitch)
+		    else SWINT('o',oswitch,initorg,">E dretog -o")
+		    else SWINT('n',nswitch,n,">E dretog -n")
+		    else badargs = TRUE;
+		}
+	    }
+	    else
+	    {
+		++argnum;
+		if      (argnum == 1) infilename = arg;
+	        else if (argnum == 2) outfilename = arg;
+		else                  badargs = TRUE;
+	    }
+	}
+
+	if ((sswitch!=0) + (gswitch!=0) + (zswitch!=0) > 1) 
+            gt_abort(">E dretog: -s, -z and -g are incompatible\n");
+
+	if (labelorg < 0) gt_abort(">E dretog: negative origin forbidden\n");
+
+	if (badargs || argnum > 2)
+	{
+	    fprintf(stderr,">E Usage: %s\n",USAGE);
+	    GETHELP;
+	    exit(1);
+	}
+
+	if (!infilename || infilename[0] == '-')
+	{
+	    infilename = "stdin";
+	    infile = stdin;
+	}
+	else if ((infile = fopen(infilename,"r")) == NULL)
+	{
+	    fprintf(stderr,"Can't open input file %s\n",infilename);
+	    gt_abort(NULL);
+	}
+
+	if (!outfilename || outfilename[0] == '-')
+	{
+	    outfilename = "stdout";
+	    outfile = stdout;
+	}
+	else if ((outfile = fopen(outfilename,"w")) == NULL)
+	{
+	    fprintf(stderr,"Can't open output file %s\n",outfilename);
+	    gt_abort(NULL);
+	}
+
+	if (sswitch)      outcode = SPARSE6;
+        else if (zswitch) outcode = DIGRAPH6;
+	else              outcode = GRAPH6;
+
+	if (hswitch)
+	{
+	    if (outcode == SPARSE6)       writeline(outfile,SPARSE6_HEADER);
+	    else if (outcode == DIGRAPH6) writeline(outfile,DIGRAPH6_HEADER);
+	    else    		          writeline(outfile,GRAPH6_HEADER);
+	}
+
+#if HAVE_ISATTY
+        prompt = isatty(fileno(infile)) && isatty(fileno(outfile));
+#else
+	prompt = (infile == stdin);
+#endif
+
+     /* perform scanning required */
+
+	labelorg = initorg;
+	nin = 0;
+        digraph = FALSE;
+
+	while (fscanf(infile,"%1s",s) == 1)
+	{
+	    if (s[0] == 'n')
+	    {
+		if (fscanf(infile,"%1s",s) == 1 && s[0] != '=')
+		    ungetc(s[0],infile);
+		if (fscanf(infile,"%d",&n) != 1)
+		{
+		    fprintf(stderr,">E dretog: invalid n=# command\n");
+		    gt_abort(NULL);
+		}
+		if (n <= 0)
+		    gt_abort(">E dretog: n can't be <= 0\n");
+	    } 
+	    else if (s[0] == 'd')
+		digraph = TRUE;
+	    else if (s[0] == '"')
+	    {
+		while ((c = getc(infile)) != '"' && c != EOF) {}
+	    }
+	    else if (s[0] == '!')
+	    {
+		while ((c = getc(infile)) != '\n' && c != EOF) {}
+	    }
+	    else if (s[0] == '$')
+	    {
+		if ((s[0] = (char)getc(infile)) == '$')
+		    labelorg = initorg;
+		else
+		{
+		    if (s[0] != '=') ungetc(s[0],infile);
+		    if (fscanf(infile,"%d",&labelorg) != 1)
+                        gt_abort(">E dretog: invalid $=# command\n");
+                    if (labelorg < 0)
+                        gt_abort(">E dretog: must have labelorg >= 0\n");
+		}
+            }
+	    else if (s[0] == 'g' || (s[0] >= '0' && s[0] <= '9')
+                                                       || s[0] == ';')
+	    {
+		if (n < 0)
+		    gt_abort(">E dretog: g command before n is defined\n");
+		if (s[0] != 'g') ungetc(s[0],infile);
+		m = (n + WORDSIZE - 1) / WORDSIZE;
+#if MAXN
+		if (n > MAXN || m > MAXM)
+		    gt_abort(">E n or m too big\n");
+#else
+		DYNALLOC2(graph,g,g_sz,n,m,"dretog");
+#endif
+		++nin;
+		readgraph(infile,g,digraph,prompt,FALSE,78,m,n);
+
+		if (outcode == DIGRAPH6)
+                    writed6(outfile,g,m,n);
+                else
+	        {
+		    if (digraph) fprintf(stderr,
+                           ">W writing digraph in undirected format\n");
+		    if (outcode == SPARSE6) writes6(outfile,g,m,n);
+		    else                    writeg6(outfile,g,m,n);
+		}
+	    }
+	    else if (s[0] == 'q')
+		exit(0);
+	    else
+	    {
+	 	fprintf(stderr,">E dretog: invalid command \"%c\"\n",s[0]);
+		gt_abort(NULL);
+	    }
+	}
+
+	if (!qswitch)
+	    fprintf(stderr,">Z  " COUNTER_FMT
+                               " graphs converted from %s to %s\n",
+			    nin,infilename,outfilename);
+
+	exit(0);
+}
diff --git a/lib/nauty/formats.txt b/lib/nauty/formats.txt
new file mode 100644
index 0000000..03c520c
--- /dev/null
+++ b/lib/nauty/formats.txt
@@ -0,0 +1,219 @@
+Description of graph6, sparse6 and digraph6 encodings
+-----------------------------------------------------
+Brendan McKay, bdm@cs.anu.edu.au
+Updated Jun 2015.
+
+General principles:
+
+  All numbers in this description are in decimal unless obviously 
+  in binary.
+
+  Apart from the header, there is one object per line. Apart from
+  the header, end-of-line characters, and the characters ":", ";"
+  and "&" which might start a line, all bytes have a value in the
+  range 63-126 (which are all printable ASCII characters). A file of
+  objects is a text file, so whatever end-of-line convention is
+  locally used is fine; however the C library input routines must
+  show the standard single-LF end of line to programs).
+
+Bit vectors:
+
+  A bit vector x of length k can be represented as follows.  
+      Example:  1000101100011100
+
+  (1) Pad on the right with 0 to make the length a multiple of 6.
+      Example:  100010110001110000
+
+  (2) Split into groups of 6 bits each.
+      Example:  100010 110001 110000
+
+  (3) Add 63 to each group, considering them as bigendian binary numbers.
+      Example:  97 112 111
+
+  These values are then stored one per byte.  
+  So, the number of bytes is ceiling(k/6).
+
+  Let R(x) denote this representation of x as a string of bytes.
+      
+Small nonnegative integers:
+ 
+  Let n be an integer in the range 0-68719476735 (2^36-1).
+
+  If 0 <= n <= 62, define N(n) to be the single byte n+63.
+  If 63 <= n <= 258047, define N(n) to be the four bytes
+      126 R(x), where x is the bigendian 18-bit binary form of n.
+  If 258048 <= n <= 68719476735, define N(n) to be the eight bytes
+      126 126 R(x), where x is the bigendian 36-bit binary form of n.
+
+  Examples:  N(30) = 93
+             N(12345) = N(000011 000000 111001) = 126 66 63 120
+             N(460175067) = N(000000 011011 011011 011011 011011 011011)
+                          = 126 126 63 90 90 90 90 90
+
+
+Description of graph6 format.
+----------------------------
+
+Data type:  
+   simple undirected graphs of order 0 to 68719476735.
+
+Optional Header: 
+   >>graph6<<     (without end of line!)
+
+File name extension:
+   .g6
+
+One graph:
+   Suppose G has n vertices.  Write the upper triangle of the adjacency
+   matrix of G as a bit vector x of length n(n-1)/2, using the ordering
+   (0,1),(0,2),(1,2),(0,3),(1,3),(2,3),...,(n-1,n).
+
+   Then the graph is represented as  N(n) R(x).
+
+Example:
+   Suppose n=5 and G has edges 0-2, 0-4, 1-3 and 3-4.
+
+   x = 0 10 010 1001
+    
+   Then N(n) = 68 and R(x) = R(010010 100100) = 81 99.
+   So, the graph is  68 81 99.
+
+
+Description of sparse6 format.
+------------------------------
+
+Data type:
+   Undirected graphs of order 0 to 68719476735.
+   Loops and multiple edges are permitted.
+
+Optional Header:
+   >>sparse6<<     (without end of line!)
+
+File name extension:
+   .s6
+
+General structure:
+
+  Each graph occupies one text line. Except for the first character
+  and end-of-line characters, each byte has the form 63+x, where 
+  0 <= x <= 63. The byte encodes the six bits of x.
+
+  The encoded graph consists of:
+        (1) The character ':'.   (This is present to distinguish
+                                  the code from graph6 format.)
+        (2) The number of vertices.
+        (3) A list of edges.
+        (4) end-of-line
+
+  Loops and multiple edges are supported, but not directed edges.
+
+Number of vertices n:
+
+  1, 4, or 8 bytes N(n) as above.
+  This is the same as graph6 format.
+
+List of edges:
+
+  Let k be the number of bits needed to represent n-1 in binary.
+  
+  The remaining bytes encode a sequence 
+
+      b[0] x[0] b[1] x[1] b[2] x[2] ... b[m] x[m]
+
+  Each b[i] occupies 1 bit, and each x[i] occupies k bits.
+  Pack them together in bigendian order, and pad up to a
+  multiple of 6 as follows:
+  1. If (n,k) = (2,1), (4,2), (8,3) or (16,4), and vertex
+     n-2 has an edge but n-1 doesn't have an edge, and
+     there are k+1 or more bits to pad, then pad with one
+     0-bit and enough 1-bits to complete the multiple of 6.
+  2. Otherwise, pad with enough 1-bits to complete the
+     multiple of 6.
+  These rules are to match the gtools procedures, and to avoid
+  the padding from looking like an extra loop in unusual cases.
+
+  Then represent this bit-stream 6 bits per byte as indicated above.
+
+  The vertices of the graph are 0..n-1.
+  The edges encoded by this sequence are determined thus:
+
+     v = 0
+     for i from 0 to m do
+        if b[i] = 1 then v = v+1 endif;
+        if x[i] > v then v = x[i] else output {x[i],v} endif
+     endfor
+
+   In decoding, an incomplete (b,x) pair at the end is discarded.
+
+Example:
+
+  :Fa@x^
+
+  ':' indicates sparse6 format.
+  Subtract 63 from the other bytes and write them in binary, 
+  six bits each.
+
+   000111 100010 000001 111001 011111
+
+  The first byte is not 63, so it is n.  n=7
+  n-1 needs 3 bits (k=3).  Write the other bits in groups
+  of 1 and k:
+
+    1 000  1 000  0 001  1 110   0 101  1 111
+  
+    This is the b/x sequence  1,0 1,0 0,1 1,6 0,5 1,7.
+    The 1,7 at the end is just padding.
+    The remaining parts give the edges 0-1 0-2 1-2 5-6.
+
+
+Description of incremental sparse6 format.
+-----------------------------------------
+
+  This is an extension to sparse6 format that is very efficient if most
+  graphs in a file are similar to the previous graph.
+
+  Each graph occupies one text line. Except for the first character
+  and end-of-line characters, each byte has the form 63+x, where 
+  0 <= x <= 63. The byte encodes the six bits of x.
+
+  The encoded graph consists of:
+        (1) The character ';'.
+        (2) A list of edges.
+        (3) end-of-line
+
+  This cannot appear as the first graph in a file.  The number of vertices
+  is taken to be equal to the number of vertices in the previous graph.
+  The list of edges specifies the symmetric difference of this graph and
+  the previous graph.  It is encoded exactly the same as part (3) of
+  sparse6 format.
+
+  Loops are supported, but not multiple edges.
+
+
+Description of digraph6 format.
+------------------------------
+
+Data type:  
+   simple directed graphs (allowing loops) of order 0 to 68719476735.
+
+Optional Header: 
+   >>digraph6<<     (without end of line!)
+
+File name extension:
+   .d6
+
+One graph:
+   Suppose G has n vertices. Write the adjacency matrix of G
+   as a bit vector x of length n^2, row by row.
+
+   Then the graph is represented as '&' N(n) R(x).
+   The character '&' (decimal 38) appears as the first character.
+
+Example:
+   Suppose n=5 and G has edges 0->2, 0->4, 3->1 and 3->4.
+
+   x = 00101 00000 00000 01001 00000
+    
+   Then N(n) = 68 and
+   R(x) = R(00101 00000 00000 01001 00000) = 73  63  65  79  63.
+   So, the graph is  38 68 73  63  65  79  63.
diff --git a/lib/nauty/genbg.c b/lib/nauty/genbg.c
new file mode 100644
index 0000000..c40db7e
--- /dev/null
+++ b/lib/nauty/genbg.c
@@ -0,0 +1,1746 @@
+/* genbg.c : version 2.4; B D McKay, 20 Jan 2016. */
+
+/* TODO: consider colour swaps */
+
+#define USAGE \
+"genbg [-c -ugs -vq -lzF] [-Z#] [-D#] [-A] [-d#|-d#:#] [-D#|-D#:#] n1 n2 \n\
+                [mine[:maxe]] [res/mod] [file]"
+
+#define HELPTEXT \
+" Find all bicoloured graphs of a specified class.\n\
+\n\
+  n1   : the number of vertices in the first class\n\
+  n2   : the number of vertices in the second class\n\
+ mine:maxe : a range for the number of edges\n\
+              #:0 means '# or more' except in the case 0:0\n\
+  res/mod : only generate subset res out of subsets 0..mod-1\n\
+   file : the name of the output file (default stdout)\n\
+  -c    : only write connected graphs\n\
+  -z    : all the vertices in the second class must have\n\
+          different neighbourhoods\n\
+  -F    : the vertices in the second class must have at least two\n\
+          neighbours of degree at least 2\n\
+  -L    : there is no vertex in the first class whose removal leaves\n\
+          the vertices in the second class unreachable from each other\n\
+  -Z#   : two vertices in the second class may have at most # common nbrs\n\
+  -A    : no vertex in the second class has a neighbourhood which is a\n\
+          subset of another vertex in the second class\n\
+  -D#   : specify an upper bound for the maximum degree\n\
+          Example: -D6.  You can also give separate maxima for the\n\
+          two parts, for example: -D5:6\n\
+  -d#   : specify a lower bound for the minimum degree.\n\
+          Again, you can specify it separately for the two parts: -d1:2\n\
+  -g    : use graph6 format for output (default)\n\
+  -s    : use sparse6 format for output\n\
+  -a    : use Greechie diagram format for output\n\
+  -u    : do not output any graphs, just generate and count them\n\
+  -v    : display counts by number of edges to stderr\n\
+  -l    : canonically label output graphs (using the 2-part colouring)\n\
+\n\
+  -q    : suppress auxiliary output\n\
+\n\
+  See program text for much more information.\n"
+
+/*
+Output formats.
+
+  If -n is absent, any output graphs are written in graph6 format.
+
+  If -n is present, any output graphs are written in nauty format.
+
+   For a graph of n vertices, the output consists of n+1 long ints
+   (even if a setword is shorter than a long int). The first contains
+   n, and the others contain the adjacency matrix.  Long int i of
+   the adjacency matrix (0 <= i <= n-1) is the set of neighbours of
+   vertex i, cast from setword to long int.
+
+PRUNE feature.
+
+   By defining the C preprocessor variables PRUNE1 and/or PRUNE2 at
+   compile time, you can filter the output of the program efficiently.
+   The value of the variable is a function name with parameter list
+   (graph *g, int *deg, int n1, int n2, int maxn2)
+
+   The function will be called for each intermediate graph generated
+   by the program, including output graphs.  The parameters are:
+      g   = the graph in nauty format
+      deg = an array giving the degrees of the vertices
+      n1  = the number of vertices in the first colour class
+            (same as the n1 parameter on the command line)
+      n2  = the number of vertices in the second colour class
+	    (this will always be at least 1)
+      maxn2 = the value of n2 on the command line
+   If n2=maxn2, the graph has the output size.
+
+   If the function returns a non-zero value, neither this graph nor
+   any of its descendants will be written to the output.
+
+   PRUNE1 and PRUNE2 are functionally equivalent, but placed at different
+   points in the program.  Essentially, use PRUNE1 for fast tests that
+   eliminate many cases and PRUNE2 for slow tests that eliminate few.
+   If in doubt, try it both ways and choose the fastest.
+   You can use both PRUNE1 and PRUNE2 if you wish, in which case note
+   that the PRUNE1 test has already been passed before PRUNE2 is applied.
+
+   Vertices 0..n1-1 are always present.  The program works by successively
+   adding one more vertex to the second colour class.  Vertex n1+n2-1 is
+   always the last one that has been added, and (except for n2=1) the
+   subgraph formed by deleting n1+n2-1 has previously been passed by the
+   pruning function.
+
+   Note that neither PRUNE1 nor PRUNE2 are called with n2=0, even if that
+   is the output level.
+
+   If -c is specified, the connectivity test has NOT been performed yet
+   at the time the pruning function is called.  However the simplicity
+   test indicated by -z HAS been performed if -z is specified.
+
+OUTPROC feature.
+
+   By defining the C preprocessor variable OUTPROC at compile time
+   (for Unix the syntax is -DOUTPROC=procname on the cc command),
+   genbg can be made to call a procedure of your manufacture with
+   each output graph instead of writing anything. Your procedure
+   needs to have type void and the argument list (FILE *f, graph *g,
+   int n1, int n2). f is a stream open for writing (in fact, in the
+   current version it is always stdout), g is the graph in nauty
+   format, and n1,n2 are the numbers of vertices on each side. Your
+   procedure can be in a separate file so long as it is linked with
+   genbg. The global variables nooutput, nautyformat and canonise
+   (all type boolean) can be used to test for the presence of the
+   flags -u, -n and -l, respectively.
+
+   For backward compatibility, it is possible to instead define OUTPROC1 to
+   be the name of a procedure with argument list  (FILE *f, graph *g, int n).
+
+SUMMARY
+
+   If the C preprocessor variable SUMMARY is defined at compile time, the
+   procedure SUMMARY(nauty_counter nout, double cpu) is called just before
+   the program exits.  The purpose is to allow reporting of statistics
+   collected by PRUNE or OUTPROC.  The values nout and cpu are the output
+   count and cpu time reported on the >Z line.
+   Output should be written to stderr.
+
+INSTRUMENT feature.
+
+   If the C preprocessor variable INSTRUMENT is defined at compile time,
+   extra code is inserted to collect statistics during execution, and
+   more information is written to stderr at termination.
+
+**************************************************************************
+
+    Author:   B. D. McKay, Oct 1994.     bdm@cs.anu.edu.au
+              Copyright  B. McKay (1994-2016).  All rights reserved.
+              This software is subject to the conditions and waivers
+              detailed in the file COPYRIGHT.
+    1 May 2003 : fixed PRUNE feature
+   13 Sep 2003 : added Greechie output, all outprocs have n1,n2
+    9 Oct 2003 : changed -l to respect partition
+   11 Apr 2007 : make >A line more atomic
+   29 Aug 2008 : include PLUGIN insertion
+   29 Nov 2008 : slight improvement of connectivity testing
+   27 Jul 2011 : fixed error in PRUNE1 found by Stephen Hartke
+    8 Jan 2012 : add antichains -A suggested by Andrew Juell
+   23 Jan 2013 : fix splitlevinc initialization
+   16 Feb 2014 : add a missing call to PRUNE2
+   20 Jan 2016 : changed bigint to nauty_counter
+
+**************************************************************************/
+
+#define NAUTY_PGM  2   /* 1 = geng, 2 = genbg, 3 = gentourng */
+#undef MAXN
+#define MAXN WORDSIZE
+
+#ifndef MAXN1
+#define MAXN1 24        /* not more than 30 */
+#endif
+#define ONE_WORD_SETS
+#include "gtools.h"   /* which includes nauty.h and stdio.h */
+
+static void (*outproc)(FILE*,graph*,int,int);
+#ifdef OUTPROC
+extern void OUTPROC(FILE*,graph*,int,int);
+#endif
+
+#ifdef SUMMARY
+extern void SUMMARY(nauty_counter,double);
+#endif
+
+static FILE *outfile;           /* file for output graphs */
+static boolean connec;          /* presence of -c */
+static boolean verbose;         /* presence of -v */
+static boolean simple;          /* presence of -z */
+boolean nautyformat;            /* presence of -n */
+boolean nooutput;               /* presence of -u */
+boolean canonise;               /* presence of -l */
+boolean graph6;                 /* presence of -g */
+boolean sparse6;                /* presence of -s */
+boolean greout;                 /* presence of -a */
+boolean quiet;                  /* presence of -q */
+boolean footfree;               /* presence of -F */
+boolean cutfree;                /* presence of -L */
+boolean antichain;              /* presence of -A */
+int class1size;                 /* same as n1 */
+int maxcommon;                  /* -1 or value of -Z */
+static int maxdeg1,maxdeg2,n1,maxn2,mine,maxe,nprune,mod,res,curres;
+static int mindeg1,mindeg2;
+static graph gcan[MAXN];
+static int xval[MAXN];   /* x-bit version of second class, xval[0..] */
+
+#if MAXN1 <= 16
+static int xbit[] = {0x0001,0x0002,0x0004,0x0008,
+                   0x0010,0x0020,0x0040,0x0080,
+                   0x0100,0x0200,0x0400,0x0800,
+                   0x1000,0x2000,0x4000,0x8000};
+
+#define XNEXTBIT(x) \
+    ((x)&0xFF ? 7-leftbit[(x)&0xFF] : 15-leftbit[((x)>>8)&0xFF])
+#define XPOPCOUNT(x) (bytecount[((x)>>8)&0xFF] + bytecount[(x)&0xFF])
+#elif MAXN1 <= 24
+static int xbit[] = {0x000001,0x000002,0x000004,0x000008,
+                   0x000010,0x000020,0x000040,0x000080,
+                   0x000100,0x000200,0x000400,0x000800,
+                   0x001000,0x002000,0x004000,0x008000,
+                   0x010000,0x020000,0x040000,0x080000,
+                   0x100000,0x200000,0x400000,0x800000};
+
+#define XNEXTBIT(x) \
+    ((x)&0xFF ? 7-leftbit[(x)&0xFF] : \
+      (x)&0xFF00 ? 15-leftbit[((x)>>8)&0xFF] : 23-leftbit[((x)>>16)&0xFF])
+#define XPOPCOUNT(x) (bytecount[((x)>>8)&0xFF] \
+    + bytecount[((x)>>16)&0xFF] + bytecount[(x)&0xFF])
+#else
+static int xbit[] = {0x00000001,0x00000002,0x00000004,0x00000008,
+                   0x00000010,0x00000020,0x00000040,0x00000080,
+                   0x00000100,0x00000200,0x00000400,0x00000800,
+                   0x00001000,0x00002000,0x00004000,0x00008000,
+                   0x00010000,0x00020000,0x00040000,0x00080000,
+                   0x00100000,0x00200000,0x00400000,0x00800000,
+                   0x01000000,0x02000000,0x04000000,0x08000000,
+                   0x10000000,0x20000000,0x40000000,0x80000000};
+
+#define XNEXTBIT(x) \
+    ((x)&0xFF ? 7-leftbit[(x)&0xFF] : \
+      (x)&0xFF00 ? 15-leftbit[((x)>>8)&0xFF] : \
+    (x)&0xFF0000 ? 23-leftbit[((x)>>16)&0xFF] : \
+                      31-leftbit[((x)>>24)&0xFF])
+#define XPOPCOUNT(x) (bytecount[((x)>>8)&0xFF] \
+    + bytecount[((x)>>16)&0xFF] + \
+    + bytecount[((x)>>24)&0xFF] + bytecount[(x)&0xFF])
+#endif
+
+typedef struct
+{
+    int ne,dmax;         /* values used for xlb,xub calculation */
+    int xlb,xub;         /* saved bounds on extension degree */
+    int lo,hi;           /* work purposes for orbit calculation */
+    int *xorb;           /* min orbit representative */
+} leveldata;
+
+#define IFLE1BITS(ww)  if (!((ww)&((ww)-1)))
+
+static leveldata data[MAXN];      /* data[n] is data for n -> n+1 */
+static nauty_counter ecount[1+MAXN*MAXN/4];  /* counts by number of edges */
+static int xstart[MAXN+1];  /* index into xset[] for each cardinality */
+static int *xset;           /* array of all x-sets in card order */
+static int *xcard;          /* cardinalities of all x-sets */
+static int *xinv;           /* map from x-set to index in xset */
+
+#ifdef INSTRUMENT
+static long nodes[MAXN],rigidnodes[MAXN],fertilenodes[MAXN];
+static long a1calls,a1nauty,a1succs;
+static long a2calls,a2nauty,a2uniq,a2succs;
+#endif
+
+#ifdef SPLITTEST
+static unsigned long splitcases = 0;
+#endif
+
+#ifdef PLUGIN
+#include PLUGIN
+#endif
+
+/************************************************************************/
+
+void
+writeny(FILE *f, graph *g, int n1, int n2) 
+/* write graph g (n1+n2 vertices) to file f in y format */
+{
+    static char ybit[] = {32,16,8,4,2,1};
+    char s[(MAXN*(MAXN-1)/2 + 5)/6 + 4];
+    int i,j,k;
+    char y,*sp;
+    int n;
+
+    n = n1 + n2;
+    sp = s;
+    *(sp++) = 0x40 | n;
+    y = 0x40;
+
+    k = -1;
+    for (j = 1; j < n; ++j)
+    for (i = 0; i < j; ++i)
+    {
+        if (++k == 6)
+        {
+            *(sp++) = y;
+            y = 0x40;
+            k = 0;
+        }
+        if (g[i] & bit[j]) y |= ybit[k];
+    }
+    if (n >= 2) *(sp++) = y;
+    *(sp++) = '\n';
+    *sp = '\0';
+
+    if (fputs(s,f) == EOF || ferror(f))
+    {
+        fprintf(stderr,">E writeny : error on writing file\n");
+        exit(2);
+    }
+}
+
+/************************************************************************/
+ 
+void
+writeg6x(FILE *f, graph *g, int n1, int n2)
+/* write graph g (n1+n2 vertices) to file f in graph6 format */
+{
+    writeg6(f,g,1,n1+n2);
+}
+
+/************************************************************************/
+
+void
+writes6x(FILE *f, graph *g, int n1, int n2)
+/* write graph g (n1+n2 vertices) to file f in graph6 format */
+{
+    writes6(f,g,1,n1+n2);
+}
+
+/************************************************************************/
+
+void
+writegre(FILE *f, graph *g, int n1, int n2)
+/* write graph g (n1+n2 vertices) to file f in Greechie diagram format */
+{
+    static char atomname[] = "123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\
+abcdefghijklmnopqrstuvwxyz!\"#$%&'()*-/:;<=>?@[\\]^_`{|}~";
+    char grestr[MAXN*MAXN+MAXN+5];
+    int i,j,k;
+    setword gi;
+
+    k = 0;
+    for (i = n1; i < n1+n2; ++i)
+    {
+        if (i > n1) grestr[k++] = ',';
+        gi = g[i];
+        while (gi)
+        {
+            TAKEBIT(j,gi);
+            grestr[k++] = atomname[j];
+        }
+    }
+    grestr[k++] = '.';
+    grestr[k++] = '\n';
+    grestr[k] = '\0';
+    if (fputs(grestr,f) == EOF || ferror(f))
+    {
+        fprintf(stderr,">E genbg : error on writing file\n");
+        gt_abort(NULL);
+    }
+}
+
+/***********************************************************************/
+
+static void
+nullwrite(FILE *f, graph *g, int n1, int n2)
+/* don't write graph g (n1+n2 vertices) to file f */
+{
+}
+
+/***********************************************************************/
+
+#ifdef OUTPROC1
+
+static void
+write12(FILE *f, graph *g, int n1, int n2)
+/* pass to OUTPROC1 */
+{
+    OUTPROC1(f,g,1,n1+n2);
+}
+
+#endif
+
+/***********************************************************************/
+
+void
+writenauty(FILE *f, graph *g, int n1, int n2)
+/* write graph g (n1+n2 vertices) to file f in nauty format */
+{
+    int nn;
+
+    nn = n1+n2;
+
+    if (fwrite((char *)&nn,sizeof(int),(size_t)1,f) != 1 ||
+          fwrite((char*)g,sizeof(setword),(size_t)nn,f) != nn)
+    {
+        fprintf(stderr,">E writenauty : error on writing file\n");
+        exit(2);
+    }
+}
+
+/*********************************************************************/
+
+static void
+fragments(int *x, int nx, int *frag, int *nfrag)
+/* For each v in union(x[0..nx-1]), find the components of the
+   hypergraph x - v and add them to frag if there are more than one. */
+/* This implementation is shocking.  Improve it! */
+{
+    int allx,i,j,v;
+    int vbit,nw,w[MAXN];
+    boolean done;
+
+    allx = 0;
+    for (i = 0; i < nx; ++i) allx |= x[i];
+
+    *nfrag = 0;
+    
+    while (allx)
+    {
+        v = XNEXTBIT(allx);
+        vbit = xbit[v];
+        allx &= ~vbit;
+
+        for (i = 0; i < nx; ++i) w[i] = x[i] & ~vbit;
+        nw = nx;
+
+        done = FALSE;
+        while (!done && nw > 1)
+        {
+            done = TRUE;
+            for (i = 0; i < nw-1; ++i)
+            for (j = i+1; j < nw; )
+                if ((w[i] & w[j]) != 0)
+                {
+                    w[i] |= w[j];
+                    w[j] = w[nw-1];
+                    --nw;
+                    done = FALSE;
+                }
+                else
+                    ++j;
+        }
+    
+        if (nw > 1)
+            for (i = 0; i < nw; ++i)
+                frag[(*nfrag)++] = w[i];
+    }
+}
+ 
+/*********************************************************************/
+
+static boolean
+isconnected(graph *g, int n)
+/* test if g is connected */
+{
+    setword seen,expanded,toexpand,allbits;
+    int i;
+
+    allbits = ALLMASK(n);
+
+    expanded = bit[n-1];
+    seen = expanded | g[n-1];
+
+    while (seen != allbits && (toexpand = (seen & ~expanded))) /* not == */
+    {   
+        i = FIRSTBITNZ(toexpand);
+        expanded |= bit[i];
+        seen |= g[i];
+    }   
+
+    return  seen == allbits;
+}
+
+/**************************************************************************/
+
+static boolean
+distinvar(graph *g, int *invar, int n1, int n2)
+ /* make distance invariant/
+    exit immediately FALSE if n-1 not maximal else exit TRUE
+    Note: only invar[n1..n1+n2-1] set */
+{
+    int w,n;
+    setword workset,frontier;
+    setword sofar;
+    int inv,d,v;
+
+    n = n1 + n2;
+    for (v = n-1; v >= n1; --v)
+    {
+        inv = 0;
+        sofar = frontier = bit[v];
+        for (d = 1; frontier != 0; ++d)
+        {
+            workset = 0;
+            inv += POPCOUNT(frontier) ^ (0x57 + d);
+            while (frontier)
+            {
+                w = FIRSTBITNZ(frontier);
+                frontier &= ~bit[w];
+                workset |= g[w];
+            }
+            frontier = workset & ~sofar;
+            sofar |= frontier;
+        }
+        invar[v] = inv;
+        if (v < n-1 && inv > invar[n-1]) return FALSE;
+    }
+    return TRUE;
+}
+
+/**************************************************************************/
+
+static void
+makeleveldata(void)
+/* make the level data for each level */
+{
+    int i,j,h;
+    int nn,nxsets,tttn;
+    long ncj;
+    leveldata *d;
+    int xw,cw;
+
+    nn = maxdeg2 <= n1 ? maxdeg2 : n1;
+    ncj = nxsets = 1;
+    for (j = 1; j <= nn; ++j)
+    {
+        ncj = (ncj * (n1 - j + 1)) / j;
+        nxsets += ncj;
+    }
+
+    tttn = 1 << n1;
+    xset = (int*) ALLOCS(nxsets,sizeof(int));
+    xcard = (int*) ALLOCS(nxsets,sizeof(int));
+    xinv = (int*) ALLOCS(tttn,sizeof(int));
+    if (xset==NULL || xcard==NULL || xinv==NULL)
+    {
+        fprintf(stderr,">E genbg: malloc failed in makeleveldata()\n");
+        exit(2);
+    }
+
+    j = 0;
+    for (i = 0; i < tttn; ++i)
+        if ((h = XPOPCOUNT(i)) <= maxdeg2)
+        {
+            xset[j] = i;
+            xcard[j] = h;
+            ++j;
+        }
+
+    if (j != nxsets)
+    {
+        fprintf(stderr,">E genbg: j=%d mxsets=%d\n",j,nxsets);
+        exit(2);
+    }
+
+    /* The following is not SORT_OF_SORT 1, 2 or 3 */
+
+    h = 1;
+    do
+        h = 3 * h + 1;
+    while (h < nxsets);
+
+    do
+    {
+        for (i = h; i < nxsets; ++i)
+        {
+            xw = xset[i];
+            cw = xcard[i];
+            for (j = i; xcard[j-h] > cw ||
+                        (xcard[j-h] == cw && xset[j-h] > xw); )
+            {
+                xset[j] = xset[j-h];
+                xcard[j] = xcard[j-h];
+                if ((j -= h) < h) break;
+            }
+            xset[j] = xw;
+            xcard[j] = cw;
+        }
+        h /= 3;
+    }
+    while (h > 0);
+
+    for (i = 0; i < nxsets; ++i) xinv[xset[i]] = i;
+
+    xstart[0] = 0;
+    for (i = 1; i < nxsets; ++i)
+        if (xcard[i] > xcard[i-1]) xstart[xcard[i]] = i;
+    xstart[xcard[nxsets-1]+1] = nxsets;
+
+    for (i = 0; i < maxn2; ++i)
+    {
+
+        d = &data[i];
+
+        d->xorb = (int*) ALLOCS(nxsets,sizeof(int));
+
+        if (d->xorb==NULL)
+        {
+            fprintf(stderr,">E genbg: malloc failed in makeleveldata()\n");
+            exit(2);
+        }
+
+        d->ne = d->dmax = d->xlb = d->xub = -1;
+    }
+}
+
+/**************************************************************************/
+
+static UPROC
+userautomproc(int count, int *p, int *orbits, int numorbits,
+          int stabvertex, int n)
+/* Automorphism procedure called by nauty
+   Form orbits on powerset of VG
+   Operates on data[n-n1] */
+{
+    int i,j1,j2;
+    int moved,pxi,pi;
+    int w,lo,hi;
+    int *xorb;
+
+    xorb = data[n-n1].xorb;
+    lo = data[n-n1].lo;
+    hi = data[n-n1].hi;
+
+    if (count == 1)                         /* first automorphism */
+        for (i = lo; i < hi; ++i) xorb[i] = i;
+
+    moved = 0;
+    for (i = 0; i < n; ++i)
+        if (p[i] != i) moved |= xbit[i];
+
+    for (i = lo; i < hi; ++i)
+    {
+        if ((w = xset[i] & moved) == 0) continue;
+        pxi = xset[i] & ~moved;
+        while (w)
+        {
+            j1 = XNEXTBIT(w);
+            w &= ~xbit[j1];
+            pxi |= xbit[p[j1]];
+        }
+        pi = xinv[pxi];
+
+        j1 = xorb[i];
+        while (xorb[j1] != j1) j1 = xorb[j1];
+        j2 = xorb[pi];
+        while (xorb[j2] != j2) j2 = xorb[j2];
+
+        if      (j1 < j2) xorb[j2] = xorb[i] = xorb[pi] = j1;
+        else if (j1 > j2) xorb[j1] = xorb[i] = xorb[pi] = j2;
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  refinex(g,lab,ptn,level,numcells,count,active,goodret,code,m,n) is a      *
+*  custom version of refine() which can exit quickly if required.            *
+*                                                                            *
+*  Only use at level==0.                                                     *
+*  goodret : whether to do an early return for code 1                        *
+*  code := -1 for n-1 not max, 0 for maybe, 1 for definite                   *
+*                                                                            *
+*****************************************************************************/
+
+static void
+refinex(graph *g, int *lab, int *ptn, int level, int *numcells,
+    int *count, set *active, boolean goodret,
+    int *code, int m, int n)
+{
+    int i,c1,c2,labc1;
+    setword x;
+    int split1,split2,cell1,cell2;
+    int cnt,bmin,bmax;
+    set *gptr;
+    setword workset;
+    int workperm[MAXN];
+    int bucket[MAXN+2];
+
+    if (n == 1)
+    {
+        *code = 1;
+        return;
+    }
+
+    *code = 0;
+    split1 = -1;
+    while (*numcells < n && ((split1 = nextelement(active,1,split1)) >= 0
+                         || (split1 = nextelement(active,1,-1)) >= 0))
+    {
+        DELELEMENT1(active,split1);
+        for (split2 = split1; ptn[split2] > 0; ++split2)
+        {}
+        if (split1 == split2)       /* trivial splitting cell */
+        {
+            gptr = GRAPHROW(g,lab[split1],1);
+            for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+            {
+                for (cell2 = cell1; ptn[cell2] > 0; ++cell2) {}
+                if (cell1 == cell2) continue;
+                c1 = cell1;
+                c2 = cell2;
+                while (c1 <= c2)
+                {
+                    labc1 = lab[c1];
+                    if (ISELEMENT1(gptr,labc1))
+                        ++c1;
+                    else
+                    {
+                        lab[c1] = lab[c2];
+                        lab[c2] = labc1;
+                        --c2;
+                    }
+                }
+                if (c2 >= cell1 && c1 <= cell2)
+                {
+                    ptn[c2] = 0;
+                    ++*numcells;
+                    ADDELEMENT1(active,c1);
+                }
+            }
+        }
+
+        else        /* nontrivial splitting cell */
+        {
+            workset = 0;
+            for (i = split1; i <= split2; ++i)
+                workset |= bit[lab[i]];
+
+            for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+            {
+                for (cell2 = cell1; ptn[cell2] > 0; ++cell2) {}
+                if (cell1 == cell2) continue;
+                i = cell1;
+                if ((x = workset & g[lab[i]]))     /* not == */
+                    cnt = POPCOUNT(x);
+                else
+                    cnt = 0;
+                count[i] = bmin = bmax = cnt;
+                bucket[cnt] = 1;
+                while (++i <= cell2)
+                {
+                    if ((x = workset & g[lab[i]])) /* not == */
+                        cnt = POPCOUNT(x);
+                    else
+                        cnt = 0;
+                    while (bmin > cnt) bucket[--bmin] = 0;
+                    while (bmax < cnt) bucket[++bmax] = 0;
+                    ++bucket[cnt];
+                    count[i] = cnt;
+                }
+                if (bmin == bmax) continue;
+                c1 = cell1;
+                for (i = bmin; i <= bmax; ++i)
+                    if (bucket[i])
+                    {
+                        c2 = c1 + bucket[i];
+                        bucket[i] = c1;
+                        if (c1 != cell1)
+                        {
+                            ADDELEMENT1(active,c1);
+                            ++*numcells;
+                        }
+                        if (c2 <= cell2) ptn[c2-1] = 0;
+                        c1 = c2;
+                    }
+                for (i = cell1; i <= cell2; ++i)
+                    workperm[bucket[count[i]]++] = lab[i];
+                for (i = cell1; i <= cell2; ++i)
+                    lab[i] = workperm[i];
+            }
+        }
+
+        if (ptn[n-2] == 0)
+        {
+            if (lab[n-1] == n-1)
+            {
+                *code = 1;
+                if (goodret) return;
+            }
+            else
+            {
+                *code = -1;
+                return;
+            }
+        }
+        else
+        {
+            i = n - 1;
+            while (1)
+            {
+                if (lab[i] == n-1) break;
+                --i;
+                if (ptn[i] == 0)
+                {
+                    *code = -1;
+                    return;
+                }
+            }
+        }
+    }
+}
+
+/**************************************************************************/
+
+static void
+makecanon(graph *g, graph *gcan, int n1, int n2)
+/* gcan := canonise(g) */
+{
+    int lab[MAXN],ptn[MAXN],orbits[MAXN];
+    setword active[1];
+    int i;
+    statsblk stats;
+    static DEFAULTOPTIONS_GRAPH(options);
+    setword workspace[50];
+
+    options.writemarkers = FALSE;
+    options.writeautoms = FALSE;
+    options.getcanon = TRUE;
+    options.defaultptn = FALSE;
+
+    for (i = 0; i < n1+n2; ++i)
+    {
+        lab[i] = i;
+        ptn[i] = 1;
+    }
+    ptn[n1-1] = ptn[n1+n2-1] = 0;
+    EMPTYSET(active,1);
+    ADDELEMENT(active,0);
+    ADDELEMENT(active,n1);
+
+    nauty(g,lab,ptn,active,orbits,&options,&stats,
+                                         workspace,50,1,n1+n2,gcan);
+}
+
+/**************************************************************************/
+
+static boolean
+accept1(graph *g, int n2, int x, graph *gx, int *deg, boolean *rigid)
+ /* decide if n2 in theta(g+x) -- version for n2+1 < maxn2 */
+{
+    int i,n;
+    int lab[MAXN],ptn[MAXN],orbits[MAXN];
+    int count[MAXN];
+    graph h[MAXN];
+    int xw;
+    int nx,numcells,code;
+    int i0,i1,degn;
+    set active[MAXM];
+    statsblk stats;
+    static DEFAULTOPTIONS_GRAPH(options);
+    setword workspace[50];
+
+#ifdef INSTRUMENT
+    ++a1calls;
+#endif
+
+    n = n1 + n2;
+    nx = n + 1;
+    for (i = 0; i < n; ++i) gx[i] = g[i];
+    gx[n] = 0;
+    deg[n] = degn = XPOPCOUNT(x);
+
+    xw = x;
+    while (xw)
+    {
+        i = XNEXTBIT(xw);
+        xw &= ~xbit[i];
+        gx[i] |= bit[n];
+        gx[n] |= bit[i];
+        ++deg[i];
+    }
+#ifdef PRUNE1
+    if (PRUNE1(gx,deg,n1,n2+1,maxn2)) return FALSE;
+#endif
+
+    for (i = 0; i < n1; ++i)
+    {
+        lab[i] = i;
+        ptn[i] = 1;
+    }
+    ptn[n1-1] = 0;
+
+    i0 = n1;
+    i1 = n;
+    for (i = n1; i < nx; ++i)
+    {
+        if (deg[i] == degn) lab[i1--] = i;
+        else                lab[i0++] = i;
+        ptn[i] = 1;
+    }
+
+    ptn[n] = 0;
+
+    if (i0 == n1)
+    {
+        numcells = 2;
+        active[0] = bit[0] | bit[n1];
+    }
+    else
+    {
+        numcells = 3;
+        active[0] = bit[0] | bit[n1] | bit[i1+1];
+        ptn[i1] = 0;
+    }
+    refinex(gx,lab,ptn,0,&numcells,count,active,FALSE,&code,1,nx);
+
+    if (code < 0) return FALSE;
+
+    if (numcells == nx)
+    {
+        *rigid = TRUE;
+#ifdef INSTRUMENT
+        ++a1succs;
+#endif
+#ifdef PRUNE2
+        if (PRUNE2(gx,deg,n1,n2+1,maxn2)) return FALSE;
+#endif
+        return TRUE;
+    }
+
+    options.writemarkers = FALSE;
+    options.writeautoms = FALSE;
+    options.getcanon = TRUE;
+    options.defaultptn = FALSE;
+    options.userautomproc = userautomproc;
+
+    active[0] = 0;
+#ifdef INSTRUMENT
+    ++a1nauty;
+#endif
+    nauty(gx,lab,ptn,active,orbits,&options,&stats,workspace,50,1,nx,h);
+
+    if (orbits[lab[n]] == orbits[n])
+    {
+        *rigid = stats.numorbits == nx;
+#ifdef INSTRUMENT
+        ++a1succs;
+#endif
+#ifdef PRUNE2
+        if (PRUNE2(gx,deg,n1,n2+1,maxn2)) return FALSE;
+#endif
+        return TRUE;
+    }
+    else
+        return FALSE;
+}
+
+/**************************************************************************/
+
+static boolean
+accept2(graph *g, int n2, int x, graph *gx, int *deg, boolean nuniq)
+/* decide if n in theta(g+x) -- version for n+1 == maxn */
+{
+    int i,n;
+    int lab[MAXN],ptn[MAXN],orbits[MAXN];
+    int degx[MAXN],invar[MAXN];
+    setword vmax,gv;
+    int qn,qv;
+    int count[MAXN];
+    int xw;
+    int nx,numcells,code;
+    int degn,i0,i1,j,j0,j1;
+    set active[MAXM];
+    statsblk stats;
+    static DEFAULTOPTIONS_GRAPH(options);
+    setword workspace[50];
+
+#ifdef INSTRUMENT
+    ++a2calls;
+    if (nuniq) ++a2uniq;
+#endif
+    n = n1 + n2;
+    nx = n + 1;
+    for (i = 0; i < n; ++i)
+    {
+        gx[i] = g[i];
+        degx[i] = deg[i];
+    }
+    gx[n] = 0;
+    degx[n] = degn = XPOPCOUNT(x);
+
+    xw = x;
+    while (xw)
+    {
+        i = XNEXTBIT(xw);
+        xw &= ~xbit[i];
+        gx[i] |= bit[n];
+        gx[n] |= bit[i];
+        ++degx[i];
+    }
+#ifdef PRUNE1
+    if (PRUNE1(gx,degx,n1,n2+1,maxn2)) return FALSE;
+#endif
+
+    if (nuniq)
+    {
+#ifdef INSTRUMENT
+        ++a2succs;
+#endif
+#ifdef PRUNE2
+        if (PRUNE2(gx,degx,n1,n2+1,maxn2)) return FALSE;
+#endif
+        if (canonise) makecanon(gx,gcan,n1,n2+1);
+        return TRUE;
+    }
+
+    for (i = 0; i < n1; ++i)
+    {
+        lab[i] = i;
+        ptn[i] = 1;
+    }
+    ptn[n1-1] = 0;
+
+    i0 = n1;
+    i1 = n;
+    for (i = n1; i < nx; ++i)
+    {
+        if (degx[i] == degn) lab[i1--] = i;
+        else                 lab[i0++] = i;
+        ptn[i] = 1;
+    }
+
+    ptn[n] = 0;
+
+    if (i0 == n1)
+    {
+        numcells = 2;
+        active[0] = bit[0] | bit[n1];
+
+        if (!distinvar(gx,invar,n1,n2+1)) return FALSE;
+        qn = invar[n];
+        j0 = n1;
+        j1 = n;
+        while (j0 <= j1)
+        {
+            j = lab[j0];
+            qv = invar[j];
+            if (qv < qn)
+                ++j0;
+            else
+            {
+                lab[j0] = lab[j1];
+                lab[j1] = j;
+                --j1;
+            }
+        }
+        if (j0 > n1)
+        {
+            if (j0 == n)
+            {
+#ifdef INSTRUMENT
+                ++a2succs;
+#endif
+#ifdef PRUNE2
+                if (PRUNE2(gx,degx,n1,n2+1,maxn2)) return FALSE;
+#endif
+                if (canonise) makecanon(gx,gcan,n1,n2+1);
+                return TRUE;
+            }
+            ptn[j1] = 0;
+            ++numcells;
+            active[0] |= bit[j0];
+        }
+    }
+    else
+    {
+        numcells = 3;
+        ptn[i1] = 0;
+        active[0] = bit[0] | bit[n1] | bit[i1+1];
+
+        vmax = 0;
+        j = MAXN;
+        for (i = 0; i < n1; ++i)
+            if (degx[i] < j && degx[i] > 0)
+            {
+                j = degx[i];
+                vmax = bit[i];
+            }
+            else if (degx[i] == j)
+                vmax |= bit[i];
+
+        gv = gx[n] & vmax;
+        qn = POPCOUNT(gv);
+
+        j0 = i1+1;
+        j1 = n;
+        while (j0 <= j1)
+        {
+            j = lab[j0];
+            gv = gx[j] & vmax;
+            qv = POPCOUNT(gv);
+            if (qv > qn)
+                return FALSE;
+            else if (qv < qn)
+                ++j0;
+            else
+            {
+                lab[j0] = lab[j1];
+                lab[j1] = j;
+                --j1;
+            }
+        }
+        if (j0 > i1+1)
+        {
+            if (j0 == n)
+            {
+#ifdef INSTRUMENT
+                ++a2succs;
+#endif
+#ifdef PRUNE2
+                if (PRUNE2(gx,degx,n1,n2+1,maxn2)) return FALSE;
+#endif
+                if (canonise) makecanon(gx,gcan,n1,n2+1);
+                return TRUE;
+            }
+            ptn[j1] = 0;
+            ++numcells;
+            active[0] |= bit[j0];
+        }
+    }
+
+    refinex(gx,lab,ptn,0,&numcells,count,active,TRUE,&code,1,nx);
+
+    if (code < 0)
+        return FALSE;
+    else if (code > 0 || numcells >= nx-4)
+    {
+#ifdef INSTRUMENT
+        ++a2succs;
+#endif
+#ifdef PRUNE2
+        if (PRUNE2(gx,degx,n1,n2+1,maxn2)) return FALSE;
+#endif
+        if (canonise) makecanon(gx,gcan,n1,n2+1);
+        return TRUE;
+    }
+
+    options.writemarkers = FALSE;
+    options.writeautoms = FALSE;
+    options.getcanon = TRUE;
+    options.defaultptn = FALSE;
+
+    active[0] = 0;
+#ifdef INSTRUMENT
+    ++a2nauty;
+#endif
+    nauty(gx,lab,ptn,active,orbits,&options,&stats,workspace,50,1,nx,gcan);
+
+    if (orbits[lab[n]] == orbits[n])
+    {
+#ifdef INSTRUMENT
+        ++a2succs;
+#endif
+#ifdef PRUNE2
+    if (PRUNE2(gx,degx,n1,n2+1,maxn2)) return FALSE;
+#endif
+        if (canonise) makecanon(gx,gcan,n1,n2+1);
+        return TRUE;
+    }
+    else
+        return FALSE;
+}
+
+/**************************************************************************/
+
+static void
+xbnds(int n2, int ne, int dmax)
+/* find bounds on degree for vertex n2
+   Store answer in data[*].*  */
+{
+    int xlb,xub,m;
+
+    xlb = n2 == 0 ? (connec ? 1 : 0) : dmax;
+    if (xlb < mindeg2) xlb = mindeg2;
+    m = mine - ne - (maxn2 - n2 -1)*maxdeg2;
+    if (m > xlb) xlb = m;
+
+    xub = maxdeg2;
+    m = (maxe - ne) / (maxn2 - n2);
+    if (m < xub) xub = m;
+
+    data[n2].ne = ne;
+    data[n2].dmax = dmax;
+    data[n2].xlb = xlb;
+    data[n2].xub = xub;
+}
+
+/**************************************************************************/
+
+static void
+genextend(graph *g, int n2, int *deg, int ne, boolean rigid, int xlb, int xub)
+/* extend from n2 to n2+1 */
+{
+    int x,y,d;
+    int *xorb,xc;
+    int nx,i,j,imin,imax,dmax;
+    int xlbx,xubx,n;
+    graph gx[MAXN];
+    int degx[MAXN];
+    boolean rigidx;
+    int dneed,need,nfeet,hideg,deg1,ft[MAXN],nfrag,frag[MAXN];
+
+#ifdef INSTRUMENT
+    boolean haschild;
+
+    haschild = FALSE;
+    ++nodes[n2];
+    if (rigid) ++rigidnodes[n2];
+#endif
+
+    n = n1 + n2;
+    nx = n2 + 1;
+    dmax = deg[n-1];
+
+    d = 0;
+    dneed = mindeg1 - maxn2 + n2;
+    need = 0;
+    hideg = 0;
+    deg1 = 0;
+    for (i = 0; i < n1; ++i)
+    {
+        if (deg[i] == maxdeg1) d |= xbit[i];
+        if (deg[i] <= dneed) need |= xbit[i];
+        if (deg[i] >= 2) hideg |= xbit[i];
+        if (deg[i] == 1) deg1 |= xbit[i];
+    }
+
+    if (xlb < XPOPCOUNT(need)) xlb = XPOPCOUNT(need);
+    if (xlb > xub) return;
+
+    imin = xstart[xlb];
+    imax = xstart[xub+1];
+    xorb = data[n2].xorb;
+
+    if (nx == maxn2)
+    {
+        if (footfree)
+        {
+            nfeet = 0;
+            for (j = 0; j < n2; ++j)
+            {
+                x = xval[j] & hideg;
+                IFLE1BITS(x) ft[nfeet++] = xval[j] & deg1;
+            }
+        }
+        if (cutfree) fragments(xval,n2,frag,&nfrag);
+
+        for (i = imin; i < imax; ++i)
+        {
+            if (!rigid && xorb[i] != i) continue;
+            x = xset[i];
+            xc = xcard[i];
+            if ((x & d) != 0) continue;
+            if ((need & ~x) != 0) continue;
+
+            if (simple)
+            {
+                for (j = n2; --j >= 0;)
+                    if (x == xval[j]) break;
+                if (j >= 0) continue;
+            }
+            if (maxcommon >= 0)
+            {
+                for (j = n2; --j >= 0;)
+                {
+                    y = x & xval[j];
+                    if (XPOPCOUNT(y) > maxcommon) break;
+                }
+                if (j >= 0) continue;
+            }
+	    if (antichain)
+	    {
+		for (j = 0; j < n2; ++j)
+		    if ((xval[j] & ~x) == 0) break;
+		if (j < n2) continue;
+	    }
+            if (footfree)
+            {
+                y = x & (hideg | deg1);
+                IFLE1BITS(y) continue;
+                for (j = 0; j < nfeet; ++j)
+                    if ((x & ft[j]) == 0) break;
+                if (j < nfeet) continue;
+            }
+            if (cutfree)
+            {
+                y = x & (hideg | deg1);
+                IFLE1BITS(y) continue;
+                for (j = 0; j < nfrag; ++j)
+                    if ((x & frag[j]) == 0) break;
+                if (j < nfrag) continue;
+            }
+
+            xval[n2] = x;
+
+            if (nx == nprune)
+            {
+                if (curres == 0) curres = mod;
+#ifdef SPLITTEST
+                --curres;
+                ++splitcases;
+                continue;
+#else
+                if (--curres != 0) continue;
+#endif
+            }
+            if (accept2(g,n2,x,gx,deg,xc > dmax))
+                if (!connec || isconnected(gx,n+1))
+                {
+                    ++ecount[ne+xc];
+#ifdef INSTRUMENT
+                    haschild = TRUE;
+#endif
+                    (*outproc)(outfile,canonise ? gcan : gx,n1,n2+1);
+                }
+        }
+    }
+    else
+    {
+        for (i = imin; i < imax; ++i)
+        {
+            if (!rigid && xorb[i] != i) continue;
+            x = xset[i];
+            xc = xcard[i];
+            if ((x & d) != 0) continue;
+            if ((need & ~x) != 0) continue;
+
+            if (nx == nprune)
+            {
+                if (curres == 0) curres = mod;
+#ifdef SPLITTEST
+                --curres;
+                ++splitcases;
+                continue;
+#else
+                if (--curres != 0) continue;
+#endif
+            }
+
+            if (simple)
+            {
+                for (j = n2; --j >= 0;)
+                    if (x == xval[j]) break;
+                if (j >= 0) continue;
+            }
+            if (maxcommon >= 0)
+            {
+                for (j = n2; --j >= 0;)
+                {
+                    y = x & xval[j];
+                    if (XPOPCOUNT(y) > maxcommon) break;
+                }
+                if (j >= 0) continue;
+            }
+	    if (antichain)
+	    {
+		for (j = 0; j < n2; ++j)
+		    if ((xval[j] & ~x) == 0) break;
+		if (j < n2) continue;
+	    }
+            xval[n2] = x;
+
+            for (j = 0; j < n; ++j) degx[j] = deg[j];
+            if (data[nx].ne != ne+xc || data[nx].dmax != xc)
+                xbnds(nx,ne+xc,xc);
+            xlbx = data[nx].xlb;
+            xubx = data[nx].xub;
+            if (xlbx > xubx) continue;
+
+            data[nx].lo = xstart[xlbx];
+            data[nx].hi = xstart[xubx+1];
+            if (accept1(g,n2,x,gx,degx,&rigidx))
+            {
+#ifdef INSTRUMENT
+                haschild = TRUE;
+#endif
+                genextend(gx,nx,degx,ne+xc,rigidx,xlbx,xubx);
+            }
+        }
+    }
+#ifdef INSTRUMENT
+    if (haschild) ++fertilenodes[n2];
+#endif
+}
+
+/**************************************************************************/
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    char *arg;
+    boolean badargs,gotD,gote,gotf,gotmr,gotZ,gotd,gotX;
+    long Dval1,Dval2;
+    long dval1,dval2;
+    int i,j,imin,imax,argnum,sw;
+    int splitlevinc;
+    graph g[MAXN1];
+    int deg[MAXN1];
+    nauty_counter nout;
+    double t1,t2;
+    char *outfilename;
+    char msg[201];
+
+    HELP; PUTVERSION;
+    nauty_check(WORDSIZE,1,MAXN,NAUTYVERSIONID);
+
+    if (MAXN > WORDSIZE || MAXN1 > 8*sizeof(int)-2)
+    {
+        fprintf(stderr,"genbg: incompatible MAXN, MAXN1 or WORDSIZE\n");
+        fprintf(stderr,"--See notes in program source\n");
+        exit(1);
+    }
+
+    badargs = FALSE;
+    connec = FALSE;
+    verbose = FALSE;
+    nautyformat = FALSE;
+    nooutput = FALSE;
+    canonise = FALSE;
+    greout = FALSE;
+    simple = FALSE;
+    graph6 = FALSE;
+    sparse6 = FALSE;
+    quiet = FALSE;
+    footfree = FALSE;
+    cutfree = FALSE;
+
+    gote = FALSE;
+    gotf = FALSE;
+    gotmr = FALSE;
+    gotD = FALSE;
+    gotd = FALSE;
+    gotZ = FALSE;
+    gotX = FALSE;
+    outfilename = NULL;
+
+    maxdeg1 = maxdeg2 = MAXN;
+    mindeg1 = mindeg2 = 0;
+
+    argnum = 0;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('n',nautyformat)
+                else SWBOOLEAN('u',nooutput)
+                else SWBOOLEAN('q',quiet)
+                else SWBOOLEAN('v',verbose)
+                else SWBOOLEAN('z',simple)
+                else SWBOOLEAN('F',footfree)
+                else SWBOOLEAN('L',cutfree)
+                else SWBOOLEAN('A',antichain)
+                else SWBOOLEAN('l',canonise)
+                else SWBOOLEAN('c',connec)
+                else SWBOOLEAN('a',greout)
+                else SWBOOLEAN('g',graph6)
+                else SWBOOLEAN('s',sparse6)
+                else SWINT('Z',gotZ,maxcommon,"genbg -Z")
+                else SWINT('X',gotX,splitlevinc,"geng -X")
+                else SWRANGE('D',":-",gotD,Dval1,Dval2,"genbg -D")
+                else SWRANGE('d',":-",gotd,dval1,dval2,"genbg -d")
+#ifdef PLUGIN_SWITCHES
+PLUGIN_SWITCHES
+#endif
+                else badargs = TRUE;
+            }
+        }
+        else if (arg[0] == '-' && arg[1] == '\0')
+            gotf = TRUE;
+        else
+        {
+            if (argnum == 0)
+            {
+                if (sscanf(arg,"%d",&n1) != 1) badargs = TRUE;
+                ++argnum;
+            }
+            else if (argnum == 1)
+            {
+                if (sscanf(arg,"%d",&maxn2) != 1) badargs = TRUE;
+                ++argnum;
+            }
+            else if (gotf)
+                badargs = TRUE;
+            else
+            {
+                if (!gotmr)
+                {
+                    if (sscanf(arg,"%d/%d",&res,&mod) == 2)
+                    { 
+                        gotmr = TRUE; 
+                        continue; 
+                    }
+                }
+                if (!gote)
+                {
+                    if (sscanf(arg,"%d:%d",&mine,&maxe) == 2
+                     || sscanf(arg,"%d-%d",&mine,&maxe) == 2)
+                    {
+                        gote = TRUE;
+                        if (maxe == 0 && mine > 0) maxe = MAXN*MAXN/4;
+                        continue;
+                    }
+                    else if (sscanf(arg,"%d",&mine) == 1)
+                    {
+                        gote = TRUE;
+                        maxe = mine;
+                        continue;
+                    }
+                }
+                if (!gotf)
+                {
+                    outfilename = arg;
+                    gotf = TRUE;
+                    continue;
+                }
+            }
+        }
+    }
+
+    if (argnum < 2)
+        badargs = TRUE;
+    else if (n1 < 1 || maxn2 < 0 || n1 > MAXN1 || n1+maxn2 > MAXN)
+    {
+        fprintf(stderr,
+           ">E genbg: must have n1=1..%d, n1+n2=1..%d\n",MAXN1,MAXN);
+        badargs = TRUE;
+    }
+
+    if (!gote)
+    {
+        mine = 0;
+        maxe = n1 * maxn2;
+    }
+
+    if (!gotmr)
+    {
+        mod = 1;
+        res = 0;
+    }
+    else if (argnum == 5 || argnum > 6)
+        badargs = TRUE;
+
+    if (gotd)
+    {
+        mindeg1 = dval1;
+        mindeg2 = dval2;
+    }
+    if (gotD)
+    {
+        maxdeg1 = Dval1;
+        maxdeg2 = Dval2;
+    }
+    if (maxdeg1 > maxn2) maxdeg1 = maxn2;
+    if (maxdeg2 > n1) maxdeg2 = n1;
+    if (connec && mine < n1+maxn2-1) mine = n1 + maxn2 - 1;
+    if (connec && mindeg1 == 0) mindeg1 = 1;
+    if (connec && mindeg2 == 0) mindeg2 = 1;
+    if (maxe > n1*maxdeg1) maxe =  n1*maxdeg1;
+    if (maxe > maxn2*maxdeg2) maxe =  maxn2*maxdeg2;
+    if (mine < n1*mindeg1) mine = n1*mindeg1;
+    if (mine < maxn2*mindeg2) mine = maxn2*mindeg2;
+
+    if (!badargs && (mine > maxe || maxe < 0 || maxdeg1 < 0 || maxdeg2 < 0))
+    {
+        fprintf(stderr,">E genbg: impossible mine,maxe,maxdeg values\n");
+        badargs = TRUE;
+    }
+
+    if (!gotZ) maxcommon = -1;
+
+    if (!badargs && (mine > maxe || maxe < 0 || maxdeg1 < 0 || maxdeg2 < 0))
+    {
+        fprintf(stderr,
+                ">E genbg: impossible mine,maxe,mindeg,maxdeg values\n");
+        badargs = TRUE;
+    }
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if ((nautyformat!=0) + (graph6!=0) + (greout!=0)
+                         + (sparse6!=0) + (nooutput!=0) > 1)
+        gt_abort(">E genbg: -ungsa are incompatible\n");
+
+#ifdef OUTPROC
+    outproc = OUTPROC;
+#else
+#ifdef OUTPROC1
+    outproc = write12;
+#endif
+    if (nautyformat)   outproc = writenauty;
+    else if (nooutput) outproc = nullwrite;
+    else if (sparse6)  outproc = writes6x;
+    else if (greout)   outproc = writegre;
+    else               outproc = writeg6x;
+#endif
+
+#ifdef PLUGIN_INIT
+PLUGIN_INIT
+#endif
+
+    for (i = 0; i <= maxe; ++i) ecount[i] = 0;
+
+    if (nooutput)
+        outfile = stdout;
+    else if (!gotf || outfilename == NULL)
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename,
+                    nautyformat ? "wb" : "w")) == NULL)
+    {
+        fprintf(stderr,
+              ">E genbg: can't open %s for writing\n",outfilename);
+        gt_abort(NULL);
+    }
+
+/*
+    if (!quiet)
+    {
+        fprintf(stderr,">A %s n=%d+%d e=%d:%d d=%d:%d D=%d:%d ",
+                       argv[0],n1,maxn2,mine,maxe,
+                       mindeg1,mindeg2,maxdeg1,maxdeg2);
+        if (simple) fprintf(stderr,"z");
+        if (footfree) fprintf(stderr,"F");
+        if (connec) fprintf(stderr,"c");
+        if (maxcommon >= 0) fprintf(stderr,"Z%d",maxcommon);
+        if (mod > 1) fprintf(stderr," class=%d/%d",res,mod);
+        fprintf(stderr,"\n");
+    }
+*/
+
+    if (!quiet)
+    {
+        msg[0] = '\0';
+        if (strlen(argv[0]) > 75)
+            fprintf(stderr,">A %s",argv[0]);
+        else
+            CATMSG1(">A %s",argv[0]);
+        CATMSG4(" n=%d+%d e=%d:%d",n1,maxn2,mine,maxe);
+        CATMSG4(" d=%d:%d D=%d:%d ",mindeg1,mindeg2,maxdeg1,maxdeg2);
+        if (simple) CATMSG0("z");
+        if (footfree) CATMSG0("F");
+        if (antichain) CATMSG0("A");
+        if (connec) CATMSG0("c");
+        if (maxcommon >= 0) CATMSG1("Z%d",maxcommon);
+        if (cutfree) CATMSG0("L");
+        if (mod > 1) CATMSG2(" class=%d/%d",res,mod);
+        CATMSG0("\n");
+        fputs(msg,stderr);
+        fflush(stderr);
+    }
+
+    class1size = n1;
+
+    for (i = 0; i < n1; ++i)
+    {
+        g[i] = 0;
+        deg[i] = 0;
+    }
+
+    t1 = CPUTIME;
+
+    if (maxn2 == 0)
+    {
+        if (res == 0)
+        {
+            ++ecount[0];
+            (*outproc)(outfile,g,n1,0);
+        }
+    }
+    else
+    {
+        makeleveldata();
+        curres = res;
+        if (mod <= 1)        nprune = 0;
+        else if (maxn2 >= 6) nprune = maxn2 - 2;
+        else if (maxn2 >= 3) nprune = maxn2 - 1;
+        else                 nprune = maxn2;
+
+        if (gotX)
+        {
+            nprune += splitlevinc;
+            if (nprune > maxn2) nprune = maxn2;
+            if (nprune < 0) nprune = 0;
+        }
+
+        xbnds(0,0,0);
+        imin = xstart[data[0].xlb];
+        imax = xstart[data[0].xub+1];
+
+        for (i = imin; i < imax; ++i)
+            data[0].xorb[i] = -1;
+
+        for (i = data[0].xlb; i <= data[0].xub; ++i)
+            data[0].xorb[xstart[i]] = xstart[i];
+
+        genextend(g,0,deg,0,FALSE,data[0].xlb,data[0].xub);
+    }
+    t2 = CPUTIME;
+
+    nout = 0;
+    for (i = 0; i <= maxe; ++i) nout += ecount[i];
+
+    if (verbose)
+        for (i = 0; i <= maxe; ++i)
+            if (ecount[i] != 0)
+            {
+                fprintf(stderr,">C " COUNTER_FMT " graphs with %d edges\n",
+                     ecount[i],i);
+            }
+
+#ifdef INSTRUMENT
+    fprintf(stderr,"\n>N node counts\n");
+    for (i = 0; i < maxn2; ++i)
+        fprintf(stderr," level %2d: %7ld (%ld rigid, %ld fertile)\n",
+                        i,nodes[i],rigidnodes[i],fertilenodes[i]);
+    fprintf(stderr,">A1 %ld calls to accept1, %ld nauty, %ld succeeded\n",
+                    a1calls,a1nauty,a1succs);
+    fprintf(stderr,
+         ">A2 %ld calls to accept2, %ld nuniq, %ld nauty, %ld succeeded\n",
+                    a2calls,a2uniq,a2nauty,a2succs);
+    fprintf(stderr,"\n");
+#endif
+
+#ifdef SPLITTEST
+    fprintf(stderr,">Z %lu splitting cases at level %d; cpu=%3.2f sec\n",
+            splitcases,nprune,t2-t1);
+#else
+#ifdef SUMMARY
+    SUMMARY(&nout,t2-t1);
+#endif
+
+    if (!quiet)
+    {
+        fprintf(stderr,">Z " COUNTER_FMT " graphs generated in %3.2f sec\n",
+                nout,t2-t1);
+    }
+#endif
+
+    exit(0);
+}
diff --git a/lib/nauty/geng.c b/lib/nauty/geng.c
new file mode 100644
index 0000000..2f00a84
--- /dev/null
+++ b/lib/nauty/geng.c
@@ -0,0 +1,2450 @@
+/* TODO:  insert new timings
+ *        add chordal graphs 
+ *        add perfect graphs
+ *        add complements for ordinary graphs */
+
+/* geng.c  version 2.9; B D McKay, Jan 2016. */
+
+#define USAGE \
+"geng [-cCmtfbd#D#] [-uygsnh] [-lvq] \n\
+              [-x#X#] n [mine[:maxe]] [res/mod] [file]"
+
+#define HELPTEXT \
+" Generate all graphs of a specified class.\n\
+\n\
+      n    : the number of vertices\n\
+ mine:maxe : a range for the number of edges\n\
+              #:0 means '# or more' except in the case 0:0\n\
+   res/mod : only generate subset res out of subsets 0..mod-1\n\
+\n\
+     -c    : only write connected graphs\n\
+     -C    : only write biconnected graphs\n\
+     -t    : only generate triangle-free graphs\n\
+     -f    : only generate 4-cycle-free graphs\n\
+     -b    : only generate bipartite graphs\n\
+                (-t, -f and -b can be used in any combination)\n\
+     -m    : save memory at the expense of time (only makes a\n\
+                difference in the absence of -b, -t, -f and n <= 28).\n\
+     -d#   : a lower bound for the minimum degree\n\
+     -D#   : a upper bound for the maximum degree\n\
+     -v    : display counts by number of edges\n\
+     -l    : canonically label output graphs\n\
+\n\
+     -u    : do not output any graphs, just generate and count them\n\
+     -g    : use graph6 output (default)\n\
+     -s    : use sparse6 output\n\
+     -y    : use the obsolete y-format instead of graph6 format\n\
+     -h    : for graph6 or sparse6 format, write a header too\n\
+\n\
+     -q    : suppress auxiliary output (except from -v)\n\
+\n\
+  See program text for much more information.\n"
+
+
+/*  Parameters:
+
+             n    = the number of vertices (1..min(32,WORDSIZE))
+             mine = the minimum number of edges (no bounds if missing)
+             maxe = the maximum number of edges (same as mine if missing)
+                    0 means "infinity" except in the case "0-0"
+             mod, res = a way to restrict the output to a subset.
+                        All the graphs in G(n,mine..maxe) are divided into
+                        disjoint classes C(0,mod),C(1,mod),...,C(mod-1,mod),
+                        of very approximately equal size.
+                        Only the class C(res,mod) is written.
+
+                        If the -x or -X switch is used, they must have the 
+                        same value for different values of res; otherwise 
+                        the partitioning may not be valid.  In this case
+                        (-x,-X with constant value), the usual relationships 
+                        between modulo classes are obeyed; for example 
+                        C(3,4) = C(3,8) union C(7,8).  This is not true
+                        if 3/8 and 7/8 are done with -x or -X values
+                        different from those used for 3/4.
+
+             file = a name for the output file (stdout if missing or "-")
+
+             All switches can be concatenated or separate.  However, the
+             value of -d must be attached to the "d", and similarly for "x".
+
+             -c    : only write connected graphs
+             -C    : only write biconnected graphs
+             -t    : only generate triangle-free graphs
+             -f    : only generate 4-cycle-free graphs
+             -b    : only generate bipartite graphs
+                        (-t, -f and -b can be used in any combination)
+             -m    : save memory at expense of time (only makes a
+                        difference in the absence of -b, -t, -f and n <= 30).
+             -d<int> : specify an upper bound for the maximum degree.
+                     The value of the upper bound must be adjacent to
+                     the "d".  Example: -d6
+             -v    : display counts by number of edges
+             -l    : canonically label output graphs
+
+             -u    : do not output any graphs, just generate and count them
+             -g    : use graph6 output (default)
+             -s    : use sparse6 output
+             -n    : use nauty format instead of graph6 format for output
+             -y    : use the obsolete y-format instead of graph6 format
+             -h    : for graph6 or sparse6 format, write a header too
+
+             -q    : suppress auxiliary output (except from -v)
+
+             -x<int> : specify a parameter that determines how evenly
+                     the res/mod facility splits the graphs into subsets.
+                     High values mean more even splitting at slight cost
+                     to the total time.  The default is 20*mod, and the
+                     the legal minimum is 3*mod.  More information is given 
+                     under "res/mod" above.
+             -X<lev> : move the initial splitting level higher by <lev>,
+                     in order to force more even splitting at the cost
+                     of speed.  Default is -X0.  More information is given
+                     under "res/mod" above.
+
+Output formats.
+
+  The output format is determined by the mutually exclusive switches
+  -u, -n, -y, -g and -s.  The default is -g.
+
+  -u suppresses output of graphs completely.
+
+  -s and -g specify sparse6 and graph6 format, defined elsewhere.
+  In this case a header is also written if -h is present.
+
+  If -y is present, graphs will be written in y-format.
+  y-format is obsolete and only provided for backwards compatibility.
+
+    Each graph occupies one line with a terminating newline.
+    Except for the newline, each byte has the format  01xxxxxx, where
+    each "x" represents one bit of data.
+    First byte:  xxxxxx is the number of vertices n
+    Other ceiling(n(n-1)/12) bytes:  These contain the upper triangle of
+    the adjacency matrix in column major order.  That is, the entries
+    appear in the order (0,1),(0,2),(1,2),(0,3),(1,3),(2,3),(0,4),... .
+    The bits are used in left to right order within each byte.
+    Any unused bits on the end are set to zero.
+
+  If -n is present, any output graphs are written in nauty format.
+
+    For a graph of n vertices, the output consists of one int giving
+    the number of vertices, and n setwords containing the adjacency
+    matrix.  Note that this is system dependent (i.e. don't use it).
+    It will not work properly if the output is to stdout and your
+    system distinguishes binary and text files.
+
+OUTPROC feature.
+
+   By defining the C preprocessor variable OUTPROC at compile time
+   (for Unix the syntax is -DOUTPROC=procname on the cc command),
+   geng can be made to call a procedure of your manufacture with
+   each output graph instead of writing anything. Your procedure
+   needs to have type void and the argument list (FILE *f, graph
+   *g, int n). f is a stream open for writing, g is the graph in
+   nauty format, and n is the number of vertices. Your procedure
+   can be in a separate file so long as it is linked with geng. The
+   global variables sparse6, graph6, quiet, nooutput, nautyformat,
+   yformat and canonise (all type boolean) can be used to test
+   for the presence of the flags -s, -g, -q, -u, -n, -y and -l,
+   respectively. If -l is present, the group size and similar
+   details can be found in the global variable nauty_stats.
+
+PRUNE feature.
+
+   By defining the C preprocessor variable PRUNE at compile time, geng
+   can be made to call
+        int PRUNE(graph *g,int n,int maxn) 
+   for each intermediate (and final) graph, and reject it if 
+   the value returned is nonzero.  The arguments are:
+
+     g      = the graph in nauty format (m=1)
+     n      = the number of vertices in g
+     maxn   = the number of vertices for output 
+              (the value you gave on the command line to geng)
+
+   geng constructs the graph starting with vertex 0, then adding
+   vertices 1,2,3,... in that order.  Each graph in the sequence is
+   an induced subgraph of all later graphs in the sequence.
+
+   A call is made for all orders from 1 to maxn.  In testing for
+   a uniform property (such as a forbidden subgraph or forbidden
+   induced subgraph) it might save time to notice that a call to
+   PRUNE for n implies that the call for n-1 already passed. 
+
+   For very fast tests, it might be worthwhile using PREPRUNE as
+   well.  It has the same meaning but is applied earlier and more
+   often.
+  
+SUMMARY
+
+   If the C preprocessor variable SUMMARY is defined at compile time, the
+   procedure SUMMARY(nauty_counter nout, double cpu) is called just before
+   the program exits.  The purpose is to allow reporting of statistics
+   collected by PRUNE or OUTPROC.  The values nout and cpu are the output
+   count and cpu time reported on the >Z line.
+   Output should be written to stderr.
+
+INSTRUMENT feature.
+
+   If the C preprocessor variable INSTRUMENT is defined at compile time,
+   extra code is inserted to collect statistics during execution, and
+   more information is written to stderr at termination.
+
+CALLING FROM A PROGRAM
+
+   It is possible to call geng from another program instead of using it
+   as a stand-alone program.  The main requirement is to change the name
+   of the main program to be other than "main".  This is done by defining
+   the preprocessor variable GENG_MAIN.  You might also like to define
+   OUTPROC to be the name of a procedure to receive the graphs. To call
+   the program you need to define an argument list argv[] consistent with
+   the usual one; don't forget that argv[0] is the command name and not
+   the first argument.  The value of argc is the number of strings in
+   argv[]; that is, one more than the number of arguments.  See the
+   sample program callgeng.c.
+
+**************************************************************************
+
+Sample performance statistics.
+
+    Here we give some graph counts and execution times on a Linux
+    Pentium III running at 550 MHz.  Times are with the -u option
+    (generate but don't write); add 3-5 microseconds per graph for
+    output to a file.  Add another 0.2-0.3 microseconds per graph 
+    if you specify connectivity (-c), or 0.6-0.7 microseconds per
+    graph if you specific biconnectivity (-C).
+
+
+      General Graphs                     C3-free Graphs (-t)
+
+      1              1                    1              1
+      2              2                    2              2
+      3              4                    3              3
+      4             11                    4              7
+      5             34                    5             14
+      6            156                    6             38
+      7           1044                    7            107
+      8          12346   0.11 sec         8            410
+      9         274668   1.77 sec         9           1897
+     10       12005168   1.22 min        10          12172   0.21 sec
+     11     1018997864   1.72 hr         11         105071   1.49 sec
+     12   165091172592    285 hr         12        1262180   15.9 sec
+     13 50502031367952  ~10 years        13       20797002   4.08 min
+    These can be done in about half      14      467871369   1.50 hr
+    the time by setting the edge limit   15    14232552452   45.6 hr
+    half way then adding complements.    16   581460254001   79 days
+                                         17 31720840164950
+
+
+     C4-free Graphs  (-f)              (C3,C4)-free Graphs (-tf)
+
+      1             1                      1            1
+      2             2                      2            2 
+      3             4                      3            3 
+      4             8                      4            6
+      5            18                      5           11
+      6            44                      6           23
+      7           117                      7           48 
+      8           351                      8          114 
+      9          1230                      9          293
+     10          5069   0.11 sec          10          869
+     11         25181   0.48 sec          11         2963   0.10 sec
+     12        152045   2.67 sec          12        12066   0.36 sec
+     13       1116403   18.0 sec          13        58933   1.50 sec
+     14       9899865   2.50 min          14       347498   7.76 sec
+     15     104980369   25.7 min          15      2455693   50.9 sec
+     16    1318017549   5.33 hr           16     20592932   6.79 min
+     17   19427531763   82.6 hr           17    202724920   1.11 hr
+     18  333964672216   62 days           18   2322206466   12.7 hr
+     19 6660282066936                     19  30743624324   168 hr
+                                          20 468026657815   110 days
+
+                   Old value was wrong:  18   2142368552  (The program was
+                   ok, but somehow we tabulated the answer incorrectly.)
+
+
+     Bipartite Graphs (-b)            C4-free Bipartite Graphs (-bf)
+
+      1              1                      1            1
+      2              2                      2            2
+      3              3                      3            3
+      4              7                      4            6
+      5             13                      5           10
+      6             35                      6           21
+      7             88                      7           39
+      8            303                      8           86
+      9           1119                      9          182
+     10           5479   0.11 sec          10          440
+     11          32303   0.59 sec          11         1074
+     12         251135   3.99 sec          12         2941   0.15 sec
+     13        2527712   35.1 sec          13         8424   0.43 sec
+     14       33985853   7.22 min          14        26720   1.37 sec
+     15      611846940   2.05 hr           15        90883   4.30 sec
+     16    14864650924   48.9 hr           16       340253   14.9 sec
+     17   488222721992   70 days           17      1384567   57.1 sec
+     18 21712049275198                     18      6186907   4.01 min
+                                           19     30219769   18.4 min
+                                           20    161763233   1.57 hr
+                                           21    946742190   8.85 hr
+                                           22   6054606722   56.2 hr
+                                           23  42229136988   16.6 days
+                                           24 320741332093   121 days
+
+If you know any more of these counts, please tell me.
+
+**************************************************************************
+
+Hints:
+
+To make all the graphs of order n, without restriction on type,
+it is fastest to make them up to binomial(n,2)/2 edges and append
+the complement of those with strictly less than binomial(n,2)/2 edges.
+
+If it is necessary to split the computation into pieces, it is more
+efficient to use the res/mod feature than to split by numbers of edges.
+
+The memory requirements are exponential in n if no maxdeg is given.
+For maxdeg=D, the requirements are still exponential (but smaller)
+for general graphs, but O(n^D) for other graphs.  Use -m to reduce
+the memory requirements to O(n^D) for general graphs too, at the
+cost of a small increase in cpu time.
+
+**************************************************************************
+
+    Author:   B. D. McKay, Sep 1991 and many later dates.
+              Copyright  B. McKay (1991-2013).  All rights reserved.
+              This software is subject to the conditions and waivers
+              detailed in the file nauty.h.
+
+    Changes:  Nov 18, 1991 : added -d switch
+                             fixed operation for n=16
+              Nov 26, 1991 : added OUTPROC feature
+              Nov 29, 1991 : -c implies mine >= n-1
+              Jan  8, 1992 : make writeny() not static
+              Jan 10, 1992 : added -n switch
+              Feb  9, 1992 : fixed case of n=1
+              Feb 16, 1992 : changed mine,maxe,maxdeg testing
+              Feb 19, 1992 : added -b, -t and -u options
+                             documented OUTPROC and added external
+                                 declaration for it.
+              Feb 20, 1992 : added -v option
+              Feb 22, 1992 : added INSTRUMENT compile-time option
+              Feb 23, 1992 : added xbnds() for more effective pruning
+              Feb 24, 1992 : added -l option
+              Feb 25, 1992 : changed writenauty() to use fwrite()
+              Mar 11, 1992 : completely revised many parts, incl
+                             new refinement procedure for fast rejection,
+                             distance invariant for regular graphs
+              May 19, 1992 : modified userautomproc slightly.  xorb[]
+                             is no longer idempotent but it doesn't matter.
+                             Speed-up of 2-5% achieved.
+              June 5, 1993 : removed ";" after "CPUDEFS" to avoid illegal
+                             empty declaration.
+              Nov 24, 1994 : tested for 0 <= res < mod
+
+              Apr 13, 1996 : Major overhaul.  Renamed "geng".
+                             Changed argument syntax.
+                             Removed 16-vertex limit.
+                             Added -s, -m, -x.  Allowed combinations.
+                             Replaced code for non-general graphs.
+                             Very many small changes.
+              Jul 12, 1996 : Changed semantics of -x and res/mod.
+                             Changed >A line and added fflush()/
+                             All switches can be concatenated or not.
+              Aug 16, 1996 : Added -X switch and PRUNE() feature.
+                             Fixed case of argument 0-0.
+              Sep 22, 1996 : Improved 1-2% by tweaking refinex().
+              Jan 21, 1997 : Renamed to geng.  
+                             Changed -s to -f, and added -sghq.
+              Sep  7, 1997 : Fixed WORDSIZE=16 problems.
+              Sep 22, 1997 : Use "wb" open for nautyformat.
+              Jan 26, 1998 : Added SUMMARY feature.
+              Mar  4, 1998 : Added -C.
+              Mar 12, 1998 : Moved stats to nauty_stats.
+              Jan  1, 2000 : Changed -d to -D and added -d.
+              Feb 24, 2000 : Raised limit to 32 vertices.
+              Mar  3, 2000 : Made some counts into unsigned long.
+                             (Includes first arg to SUMMARY.)
+              Mar 12, 2000 : Used bigint for counts that may exceed 2^32.
+                             Now all counts from very long runs are ok.
+              Oct 12, 2000 : Changed maxef[32] to 92 after confirmation
+                             from Yang Yuansheng.  The old value of 93 was
+                             valid but 92 is slightly more efficient.
+              Nov 16, 2000 : Used fuction prototypes.
+              Jul 31, 2001 : Added PREPRUNE
+               May 7, 2004 : Complete all function prototypes
+              Nov 24, 2004 : Force -m for very large sizes
+                             Add -bf automatically if generating trees
+              Apr 1, 2007  : Write >A in one fputs() to try to reduce
+                             mixing of outputs in multi-process pipes.
+              Sep 19, 2007 : Force -m for n > 28 regardless of word size.
+              Nov 29, 2008 : Slightly improved connectivity testing.
+              Mar 3,  2015 : Improve maxdeg tweaking.
+              Jan 18, 2016 : Replace bigint by nauty_counter.
+
+**************************************************************************/
+
+#define NAUTY_PGM  1   /* 1 = geng, 2 = genbg, 3 = gentourng */
+
+#ifndef MAXN
+#define MAXN 32         /* not more than max(32,WORDSIZE) */
+#endif
+
+#if MAXN > 32
+ #error "Can't have MAXN greater than 32"
+#endif
+
+#define ONE_WORD_SETS
+#include "gtools.h"   /* which includes nauty.h and stdio.h */
+
+#if MAXN < 32
+typedef int xword;   /* Must be as large as MAXN bits, and
+                    must be unsigned if equal to MAXN bits */
+#else
+typedef unsigned int xword;
+#endif
+
+static void (*outproc)(FILE*,graph*,int);
+
+static FILE *outfile;           /* file for output graphs */
+static int connec;              /* 1 for -c, 2 for -C, 0 for neither */
+static boolean bipartite;       /* presence of -b */
+static boolean trianglefree;    /* presence of -t */
+static boolean squarefree;      /* presence of -f */
+static boolean savemem;         /* presence of -m */
+static boolean verbose;         /* presence of -v */
+boolean nautyformat;            /* presence of -n */
+boolean yformat;                /* presence of -y */
+boolean graph6;                 /* presence of -g */
+boolean sparse6;                /* presence of -s */
+boolean nooutput;               /* presence of -u */
+boolean canonise;               /* presence of -l */
+boolean quiet;                  /* presence of -q */
+boolean header;                 /* presence of -h */
+statsblk nauty_stats;
+static int mindeg,maxdeg,maxn,mine,maxe,mod,res;
+#define PRUNEMULT 20   /* bigger -> more even split at greater cost */
+static int min_splitlevel,odometer,splitlevel,multiplicity;
+static graph gcan[MAXN];
+
+#if MAXN <= 16
+static xword xbit[] = {0x0001,0x0002,0x0004,0x0008,
+                   0x0010,0x0020,0x0040,0x0080,
+                   0x0100,0x0200,0x0400,0x0800,
+                   0x1000,0x2000,0x4000,0x8000};
+
+#define XNEXTBIT(x) \
+    ((x)&0xFF ? 7-leftbit[(x)&0xFF] : 15-leftbit[((x)>>8)&0xFF])
+#define XPOPCOUNT(x) (bytecount[((x)>>8)&0xFF] + bytecount[(x)&0xFF])
+#elif MAXN <= 24
+static xword xbit[] = {0x000001,0x000002,0x000004,0x000008,
+                   0x000010,0x000020,0x000040,0x000080,
+                   0x000100,0x000200,0x000400,0x000800,
+                   0x001000,0x002000,0x004000,0x008000,
+                   0x010000,0x020000,0x040000,0x080000,
+                   0x100000,0x200000,0x400000,0x800000};
+
+#define XNEXTBIT(x) \
+    ((x)&0xFF ? 7-leftbit[(x)&0xFF] : \
+      (x)&0xFF00 ? 15-leftbit[((x)>>8)&0xFF] : 23-leftbit[((x)>>16)&0xFF])
+#define XPOPCOUNT(x) (bytecount[((x)>>8)&0xFF] \
+    + bytecount[((x)>>16)&0xFF] + bytecount[(x)&0xFF])
+#else
+static xword xbit[] = {0x00000001,0x00000002,0x00000004,0x00000008,
+                   0x00000010,0x00000020,0x00000040,0x00000080,
+                   0x00000100,0x00000200,0x00000400,0x00000800,
+                   0x00001000,0x00002000,0x00004000,0x00008000,
+                   0x00010000,0x00020000,0x00040000,0x00080000,
+                   0x00100000,0x00200000,0x00400000,0x00800000,
+                   0x01000000,0x02000000,0x04000000,0x08000000,
+                   0x10000000,0x20000000,0x40000000,0x80000000};
+
+#define XNEXTBIT(x) \
+    ((x)&0xFF ? 7-leftbit[(x)&0xFF] : \
+      (x)&0xFF00 ? 15-leftbit[((x)>>8)&0xFF] : \
+    (x)&0xFF0000 ? 23-leftbit[((x)>>16)&0xFF] : \
+                      31-leftbit[((x)>>24)&0xFF])
+#define XPOPCOUNT(x) (bytecount[((x)>>8)&0xFF] \
+    + bytecount[((x)>>16)&0xFF] + \
+    + bytecount[((x)>>24)&0xFF] + bytecount[(x)&0xFF])
+#endif
+
+typedef struct
+{
+    int ne,dmax;          /* values used for xlb,xub calculation */
+    int xlb,xub;          /* saved bounds on extension degree */
+    xword lo,hi;          /* work purposes for orbit calculation */
+    xword xstart[MAXN+1]; /* index into xset[] for each cardinality */
+    xword *xset;          /* array of all x-sets in card order */
+    xword *xcard;         /* cardinalities of all x-sets */
+    xword *xinv;          /* map from x-set to index in xset */
+    xword *xorb;          /* min orbit representative */
+    xword *xx;            /* (-b, -t, -s, -m) candidate x-sets */
+                      /*   note: can be the same as xcard */
+    xword xlim;           /* number of x-sets in xx[] */
+} leveldata;
+
+static leveldata data[MAXN];      /* data[n] is data for n -> n+1 */
+static nauty_counter ecount[1+MAXN*(MAXN-1)/2];  /* counts by number of edges */
+static nauty_counter nodes[MAXN];     /* nodes at each level */
+
+#ifdef INSTRUMENT
+static unsigned long rigidnodes[MAXN],fertilenodes[MAXN];
+static unsigned long a1calls,a1nauty,a1succs;
+static unsigned long a2calls,a2nauty,a2uniq,a2succs;
+#endif
+
+/* The numbers below are actual maximum edge counts.  The apparently
+   anomolous value of 92 for maxef[32] has been confirmed independently
+   by Yang Yuansheng (as well as all the smaller maxef[] values).
+   geng works correctly with any upper bounds.
+   To extend an upper bound upwards: (n-1, E) -> (n, E + floor(2*E/(n-2))).
+*/
+
+static int maxeb[] =     /* max edges for -b */
+ {0,0,1,2,4, 6,9,12,16,20, 25,30,36,42,49, 56,64,72,81,90,
+  100,110,121,132,144, 156,169,182,196,210, 225,240,256};
+static int maxet[] =     /* max edges for -t */
+ {0,0,1,2,4, 6,9,12,16,20, 25,30,36,42,49, 56,64,72,81,90,
+  100,110,121,132,144, 156,169,182,196,210, 225,240,256};
+static int maxef[] =     /* max edges for -f */
+ {0,0,1,3,4, 6,7,9,11,13,  16,18,21,24,27, 30,33,36,39,42,
+  46,50,52,56,59, 63,67,71,76,80, 85,90,92};
+static int maxeft[] =    /* max edges for -ft */
+ {0,0,1,2,3, 5,6,8,10,12,  15,16,18,21,23, 26,28,31,34,38,
+  41,44,47,50,54, 57,61,65,68,72, 76,80,85};
+static int maxebf[] =    /* max edges for -bf */
+ {0,0,1,2,3, 4,6,7,9,10,   12,14,16,18,21, 22,24,26,29,31,
+  34,36,39,42,45, 48,52,53,56,58, 61,64,67}; 
+
+#ifdef PLUGIN
+#include PLUGIN
+#endif
+
+#ifdef OUTPROC
+extern void OUTPROC(FILE*,graph*,int);
+#endif
+#ifdef PRUNE
+extern int PRUNE(graph*,int,int);
+#endif
+#ifdef PREPRUNE
+extern int PREPRUNE(graph*,int,int);
+#endif
+#ifdef SUMMARY
+extern void SUMMARY(nauty_counter,double);
+#endif
+
+/************************************************************************/
+
+void
+writeny(FILE *f, graph *g, int n)
+/* write graph g (n vertices) to file f in y format */
+{
+    static char ybit[] = {32,16,8,4,2,1};
+    char s[(MAXN*(MAXN-1)/2 + 5)/6 + 4];
+    int i,j,k;
+    char y,*sp;
+
+    sp = s;
+    *(sp++) = 0x40 | n;
+    y = 0x40;
+
+    k = -1;
+    for (j = 1; j < n; ++j)
+    for (i = 0; i < j; ++i)
+    {
+        if (++k == 6)
+        {
+            *(sp++) = y;
+            y = 0x40;
+            k = 0;
+        }
+        if (g[i] & bit[j]) y |= ybit[k];
+    }
+    if (n >= 2) *(sp++) = y;
+    *(sp++) = '\n';
+    *sp = '\0';
+
+    if (fputs(s,f) == EOF || ferror(f))
+    {
+        fprintf(stderr,">E writeny : error on writing file\n");
+        exit(2);
+    }
+}
+
+/************************************************************************/
+
+void
+writeg6x(FILE *f, graph *g, int n)
+/* write graph g (n vertices) to file f in graph6 format */
+{
+    writeg6(f,g,1,n);
+}
+
+/************************************************************************/
+
+void
+writes6x(FILE *f, graph *g, int n)
+/* write graph g (n vertices) to file f in sparse6 format */
+{
+    writes6(f,g,1,n);
+}
+
+/***********************************************************************/
+
+static void
+nullwrite(FILE *f, graph *g, int n)
+/* don't write graph g (n vertices) to file f */
+{
+}
+
+/***********************************************************************/
+
+void
+writenauty(FILE *f, graph *g, int n)
+/* write graph g (n vertices) to file f in nauty format */
+{
+    int nn;
+
+    nn = n;
+
+    if (fwrite((char *)&nn,sizeof(int),(size_t)1,f) != 1 ||
+          fwrite((char*)g,sizeof(setword),(size_t)n,f) != n)
+    {
+        fprintf(stderr,">E writenauty : error on writing file\n");
+        exit(2);
+    }
+}
+
+/*********************************************************************/
+
+static boolean
+isconnected(graph *g, int n)
+/* test if g is connected */
+{
+    setword seen,expanded,toexpand,allbits;
+    int i;
+
+    allbits = ALLMASK(n);
+
+    expanded = bit[n-1];
+    seen = expanded | g[n-1];
+
+    while (seen != allbits && (toexpand = (seen & ~expanded))) /* not == */
+    {
+        i = FIRSTBITNZ(toexpand);
+        expanded |= bit[i];
+        seen |= g[i];
+    }
+
+    return  seen == allbits;
+}
+
+/**********************************************************************/
+ 
+static boolean
+isbiconnected(graph *g, int n)
+/* test if g is biconnected */
+{
+    int sp,v,w;
+    setword sw;
+    setword visited;
+    int numvis,num[MAXN],lp[MAXN],stack[MAXN];
+ 
+    if (n <= 2) return FALSE;
+ 
+    visited = bit[0];
+    stack[0] = 0;
+    num[0] = 0;
+    lp[0] = 0;
+    numvis = 1;
+    sp = 0;
+    v = 0;
+ 
+    for (;;)
+    {
+        if ((sw = g[v] & ~visited))           /* not "==" */
+        {
+            w = v;
+            v = FIRSTBITNZ(sw);       /* visit next child */
+            stack[++sp] = v;
+            visited |= bit[v];
+            lp[v] = num[v] = numvis++;
+            sw = g[v] & visited & ~bit[w];
+            while (sw)
+            {
+                w = FIRSTBITNZ(sw);
+                sw &= ~bit[w];
+                if (num[w] < lp[v])  lp[v] = num[w];
+            }
+        }
+        else
+        {
+            w = v;                  /* back up to parent */
+            if (sp <= 1)          return numvis == n;
+            v = stack[--sp];
+            if (lp[w] >= num[v])  return FALSE;
+            if (lp[w] < lp[v])    lp[v] = lp[w];
+        }
+    }
+}
+
+/**********************************************************************/
+
+static void
+gcomplement(graph *g, graph *gc, int n)
+/* Take the complement of g and put it in gc */
+{
+    int i;
+    setword all;
+
+    all = ~(setword)BITMASK(n-1);
+    for (i = 0; i < n; ++i)
+        gc[i] = g[i] ^ all ^ bit[i];
+}
+
+/**********************************************************************/
+
+static boolean
+distinvar(graph *g, int *invar, int n)
+/* make distance invariant
+   return FALSE if n-1 not maximal else return TRUE */
+{
+    int w;
+    setword workset,frontier;
+    setword sofar;
+    int inv,d,v;
+
+    for (v = n-1; v >= 0; --v)
+    {
+        inv = 0;
+        sofar = frontier = bit[v];
+        for (d = 1; frontier != 0; ++d)
+        {
+            workset = 0;
+            inv += POPCOUNT(frontier) ^ (0x57 + d);
+            while (frontier)
+            {
+                w = FIRSTBITNZ(frontier);
+                frontier ^= bit[w];
+                workset |= g[w];
+            }
+            frontier = workset & ~sofar;
+            sofar |= frontier;
+        }
+        invar[v] = inv;
+        if (v < n-1 && inv > invar[n-1]) return FALSE;
+    }
+    return TRUE;
+}
+
+/**************************************************************************/
+
+static void
+makexgraph(graph *g, xword *h, int n)
+/* make x-format graph from nauty format graph */
+{
+    setword gi;
+    int i,j;
+    xword hi;
+
+    for (i = 0; i < n; ++i)
+    {
+        hi = 0;
+        gi = g[i];
+        while (gi)
+        {
+            j = FIRSTBITNZ(gi);
+            gi ^= bit[j];
+            hi |= xbit[j];
+        }
+        h[i] = hi;
+    }
+}
+
+/**************************************************************************/
+
+static void
+make0graph(graph *g, xword *h, int n)
+/* make x-format graph without edges */
+{
+    int i;
+
+    for (i = 0; i < n; ++i) h[i] = 0;
+}
+
+/**************************************************************************/
+
+static void
+makebgraph(graph *g, xword *h, int n)
+/* make x-format graph of different colour graph */
+{
+    setword seen1,seen2,expanded,w;
+    setword restv;
+    xword xseen1,xseen2;
+    int i;
+
+    restv = 0;
+    for (i = 0; i < n; ++i) restv |= bit[i];
+
+    seen1 = seen2 = 0;
+    expanded = 0;
+
+    while (TRUE)
+    {
+        if ((w = ((seen1 | seen2) & ~expanded)) == 0)
+        {
+            xseen1 = 0;
+            w = seen1;
+            while (w)
+            {
+                i = FIRSTBITNZ(w);
+                w ^= bit[i];
+                xseen1 |= xbit[i];
+            }
+            xseen2 = 0;
+            w = seen2;
+            while (w)
+            {
+                i = FIRSTBITNZ(w);
+                w ^= bit[i];
+                xseen2 |= xbit[i];
+            }
+
+            w = seen1;
+            while (w)
+            {
+                i = FIRSTBITNZ(w);
+                w ^= bit[i];
+                h[i] = xseen2;
+            }
+            w = seen2;
+            while (w)
+            {
+                i = FIRSTBITNZ(w);
+                w ^= bit[i];
+                h[i] = xseen1;
+            }
+
+            restv &= ~(seen1 | seen2);
+            if (restv == 0) return;
+            i = FIRSTBITNZ(restv);
+            seen1 = bit[i];
+            seen2 = 0;
+        }
+        else
+            i = FIRSTBITNZ(w);
+
+        expanded |= bit[i];
+        if (bit[i] & seen1) seen2 |= g[i];
+        else                seen1 |= g[i];
+    }
+}
+
+/**************************************************************************/
+ 
+static void
+makeb6graph(graph *g, xword *h, int n)
+/* make x-format bipartite girth 6 graph */
+{
+    setword w,x;
+    xword hi;
+    int i,j;
+
+    makebgraph(g,h,n);
+
+    for (i = 0; i < n; ++i)
+    {
+        w = g[i];
+        x = 0;
+        while (w)
+        {
+            j = FIRSTBITNZ(w);
+            w ^= bit[j];
+            x |= g[j];
+        }
+        x &= ~bit[i];
+        hi = h[i];
+        while (x)
+        {
+            j = FIRSTBITNZ(x);
+            x ^= bit[j];
+            hi |= xbit[j];
+        }
+        h[i] = hi;
+    }
+}
+
+/**************************************************************************/
+ 
+static void
+makesgraph(graph *g, xword *h, int n)
+/* make x-format square graph */
+{
+    setword w,x;
+    xword hi;
+    int i,j;
+
+    for (i = 0; i < n; ++i)
+    {
+        w = g[i];
+        x = 0;
+        while (w)
+        {
+            j = FIRSTBITNZ(w);
+            w ^= bit[j];
+            x |= g[j];
+        }
+        x &= ~bit[i];
+        hi = 0;
+        while (x)
+        {
+            j = FIRSTBITNZ(x);
+            x ^= bit[j];
+            hi |= xbit[j];
+        }
+        h[i] = hi;
+    }
+}
+
+/**************************************************************************/ 
+ 
+static void 
+makeg5graph(graph *g, xword *h, int n)
+/* make x-format girth-5 graph */
+{
+    setword w,x; 
+    xword hi;
+    int i,j;
+ 
+    for (i = 0; i < n; ++i)
+    { 
+        w = g[i]; 
+        x = g[i];
+        while (w) 
+        {
+            j = FIRSTBITNZ(w);
+            w ^= bit[j];
+            x |= g[j];
+        } 
+        x &= ~bit[i]; 
+        hi = 0; 
+        while (x) 
+        { 
+            j = FIRSTBITNZ(x); 
+            x ^= bit[j]; 
+            hi |= xbit[j]; 
+        } 
+        h[i] = hi; 
+    } 
+} 
+
+/**************************************************************************/  
+
+static void
+makeleveldata(boolean restricted)
+/* make the level data for each level */
+{
+    long h;
+    int n,nn;
+    long ncj;
+    leveldata *d;
+    xword *xcard,*xinv;
+    xword *xset,xw,tttn,nxsets;
+    xword cw;
+    xword i,j;
+
+    for (n = 1; n < maxn; ++n)
+    {
+        nn = maxdeg <= n ? maxdeg : n;
+        ncj = nxsets = 1;
+        for (j = 1; j <= nn; ++j)
+        {
+            ncj = (ncj * (n - j + 1)) / j;
+            nxsets += ncj;
+        }
+        tttn = 1L << n;
+
+        d = &data[n];
+
+        d->ne = d->dmax = d->xlb = d->xub = -1;
+
+        if (restricted)
+        {
+            d->xorb = (xword*) calloc(nxsets,sizeof(xword));
+            d->xx = (xword*) calloc(nxsets,sizeof(xword));
+            if (d->xorb == NULL || d->xx == NULL)
+            {
+                fprintf(stderr,
+                   ">E geng: calloc failed in makeleveldata()\n");
+                exit(2);
+            }
+            continue;   /* <--- NOTE THIS! */
+        }
+
+        d->xset = xset = (xword*) calloc(nxsets,sizeof(xword));
+        d->xcard = xcard = (xword*) calloc(nxsets,sizeof(xword));
+        d->xinv = xinv = (xword*) calloc(tttn,sizeof(xword));
+        d->xorb = (xword*) calloc(nxsets,sizeof(xword));
+        d->xx = d->xcard;
+
+        if (xset==NULL || xcard==NULL || xinv==NULL || d->xorb==NULL)
+        {
+            fprintf(stderr,">E geng: calloc failed in makeleveldata()\n");
+            exit(2);
+        }
+
+        j = 0;
+
+        for (i = 0;; ++i)
+        {
+            if ((h = XPOPCOUNT(i)) <= maxdeg)
+            {
+                xset[j] = i;
+                xcard[j] = h;
+                ++j;
+            }
+            if (i == (xword)((1L<<n)-1)) break;
+        }
+
+        if (j != nxsets)
+        {
+            fprintf(stderr,">E geng: j=%u mxsets=%u\n",
+                    j,(unsigned)nxsets);
+            exit(2);
+        }
+
+        h = 1;
+        do
+            h = 3 * h + 1;
+        while (h < nxsets);
+
+        do
+        {
+            for (i = h; i < nxsets; ++i)
+            {
+                xw = xset[i];
+                cw = xcard[i];
+                for (j = i; xcard[j-h] > cw ||
+                            (xcard[j-h] == cw && xset[j-h] > xw); )
+                {
+                    xset[j] = xset[j-h];
+                    xcard[j] = xcard[j-h];
+                    if ((j -= h) < h) break;
+                }
+                xset[j] = xw;
+                xcard[j] = cw;
+            }
+            h /= 3;
+        }
+        while (h > 0);
+
+        for (i = 0; i < nxsets; ++i) xinv[xset[i]] = i;
+
+        d->xstart[0] = 0;
+        for (i = 1; i < nxsets; ++i)
+            if (xcard[i] > xcard[i-1]) d->xstart[xcard[i]] = i;
+        d->xstart[xcard[nxsets-1]+1] = nxsets;
+    }
+}
+
+/**************************************************************************/
+
+static void
+userautomproc(int count, int *p, int *orbits,
+          int numorbits, int stabvertex, int n)
+/* form orbits on powerset of VG
+   called by nauty;  operates on data[n] */
+{
+    xword i,j1,j2,moved,pi,pxi;
+    xword lo,hi;
+    xword *xorb,*xinv,*xset,w;
+
+    xorb = data[n].xorb;
+    xset = data[n].xset;
+    xinv = data[n].xinv;
+    lo = data[n].lo;
+    hi = data[n].hi;
+
+    if (count == 1)                         /* first automorphism */
+        for (i = lo; i < hi; ++i) xorb[i] = i;
+
+    moved = 0;
+    for (i = 0; i < n; ++i)
+        if (p[i] != i) moved |= xbit[i];
+
+    for (i = lo; i < hi; ++i)
+    {
+        if ((w = xset[i] & moved) == 0) continue;
+        pxi = xset[i] & ~moved;
+        while (w)
+        {
+            j1 = XNEXTBIT(w);
+            w ^= xbit[j1];
+            pxi |= xbit[p[j1]];
+        }
+        pi = xinv[pxi];
+
+        j1 = xorb[i];
+        while (xorb[j1] != j1) j1 = xorb[j1];
+        j2 = xorb[pi];
+        while (xorb[j2] != j2) j2 = xorb[j2];
+
+        if      (j1 < j2) xorb[j2] = xorb[i] = xorb[pi] = j1;
+        else if (j1 > j2) xorb[j1] = xorb[i] = xorb[pi] = j2;
+    }
+}
+
+/**************************************************************************/
+
+static void
+userautomprocb(int count, int *p, int *orbits,
+          int numorbits, int stabvertex, int n)
+/* form orbits on powerset of VG
+   called by nauty;  operates on data[n] */
+{
+    xword j1,j2,moved,pi,pxi,lo,hi,x;
+    xword i,*xorb,*xx,w,xlim,xlb;
+
+    xorb = data[n].xorb;
+    xx = data[n].xx;
+    xlim = data[n].xlim;
+
+    if (count == 1)                         /* first automorphism */
+    {
+        j1 = 0;
+        xlb = data[n].xlb;
+
+        for (i = 0; i < xlim; ++i)
+        {
+            x = xx[i];
+            if (XPOPCOUNT(x) >= xlb)
+            {
+                xx[j1] = x;
+                xorb[j1] = j1;
+                ++j1;
+            }
+        }
+        data[n].xlim = xlim = j1;
+    }
+
+    moved = 0;
+    for (i = 0; i < n; ++i)
+        if (p[i] != i) moved |= xbit[i];
+
+    for (i = 0; i < xlim; ++i)
+    {
+        if ((w = xx[i] & moved) == 0) continue;
+        pxi = xx[i] & ~moved;
+        while (w)
+        {
+            j1 = XNEXTBIT(w);
+            w ^= xbit[j1];
+            pxi |= xbit[p[j1]];
+        }
+        /* pi = position of pxi */
+
+        lo = 0;
+        hi = xlim - 1;
+
+        for (;;)
+        {
+            pi = (lo + hi) >> 1;
+            if (xx[pi] == pxi) break;
+            else if (xx[pi] < pxi) lo = pi + 1;
+            else                   hi = pi - 1;
+        }
+
+        j1 = xorb[i];
+        while (xorb[j1] != j1) j1 = xorb[j1];
+        j2 = xorb[pi];
+        while (xorb[j2] != j2) j2 = xorb[j2];
+
+        if      (j1 < j2) xorb[j2] = xorb[i] = xorb[pi] = j1;
+        else if (j1 > j2) xorb[j1] = xorb[i] = xorb[pi] = j2;
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  refinex(g,lab,ptn,level,numcells,count,active,goodret,code,m,n) is a      *
+*  custom version of refine() which can exit quickly if required.            *
+*                                                                            *
+*  Only use at level==0.                                                     *
+*  goodret : whether to do an early return for code 1                        *
+*  code := -1 for n-1 not max, 0 for maybe, 1 for definite                   *
+*                                                                            *
+*****************************************************************************/
+
+static void
+refinex(graph *g, int *lab, int *ptn, int level, int *numcells,
+     int *count, set *active, boolean goodret, int *code, int m, int n)
+{
+    int i,c1,c2,labc1;
+    setword x,lact;
+    int split1,split2,cell1,cell2;
+    int cnt,bmin,bmax;
+    set *gptr;
+    setword workset;
+    int workperm[MAXN];
+    int bucket[MAXN+2];
+
+    if (n == 1)
+    {
+        *code = 1;
+        return;
+    }
+
+    *code = 0;
+    lact = *active;
+
+    while (*numcells < n && lact)
+    {
+        TAKEBIT(split1,lact);
+        
+        for (split2 = split1; ptn[split2] > 0; ++split2) {}
+        if (split1 == split2)       /* trivial splitting cell */
+        {
+            gptr = GRAPHROW(g,lab[split1],1);
+            for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+            {
+                for (cell2 = cell1; ptn[cell2] > 0; ++cell2) {}
+                if (cell1 == cell2) continue;
+
+                c1 = cell1;
+                c2 = cell2;
+                while (c1 <= c2)
+                {
+                    labc1 = lab[c1];
+                    if (ISELEMENT1(gptr,labc1))
+                        ++c1;
+                    else
+                    {
+                        lab[c1] = lab[c2];
+                        lab[c2] = labc1;
+                        --c2;
+                    }
+                }
+                if (c2 >= cell1 && c1 <= cell2)
+                {
+                    ptn[c2] = 0;
+                    ++*numcells;
+                    lact |= bit[c1];
+                }
+            }
+        }
+
+        else        /* nontrivial splitting cell */
+        {
+            workset = 0;
+            for (i = split1; i <= split2; ++i) workset |= bit[lab[i]];
+
+            for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+            {
+                for (cell2 = cell1; ptn[cell2] > 0; ++cell2) {}
+                if (cell1 == cell2) continue;
+                i = cell1;
+                if ((x = workset & g[lab[i]]) != 0) cnt = POPCOUNT(x);
+                else                                cnt = 0;
+                count[i] = bmin = bmax = cnt;
+                bucket[cnt] = 1;
+                while (++i <= cell2)
+                {
+                    if ((x = workset & g[lab[i]]) != 0)
+                        cnt = POPCOUNT(x);
+                    else
+                        cnt = 0;
+
+                    while (bmin > cnt) bucket[--bmin] = 0;
+                    while (bmax < cnt) bucket[++bmax] = 0;
+                    ++bucket[cnt];
+                    count[i] = cnt;
+                }
+                if (bmin == bmax) continue;
+                c1 = cell1;
+                for (i = bmin; i <= bmax; ++i)
+                    if (bucket[i])
+                    {
+                        c2 = c1 + bucket[i];
+                        bucket[i] = c1;
+                        if (c1 != cell1)
+                        {
+                            lact |= bit[c1];
+                            ++*numcells;
+                        }
+                        if (c2 <= cell2) ptn[c2-1] = 0;
+                        c1 = c2;
+                    }
+                for (i = cell1; i <= cell2; ++i)
+                    workperm[bucket[count[i]]++] = lab[i];
+                for (i = cell1; i <= cell2; ++i) lab[i] = workperm[i];
+            }
+        }
+
+        if (ptn[n-2] == 0)
+        {
+            if (lab[n-1] == n-1)
+            {
+                *code = 1;
+                if (goodret) return;
+            }
+            else
+            {
+                *code = -1;
+                return;
+            }
+        }
+        else
+        {
+            i = n - 1;
+            while (TRUE)
+            {
+                if (lab[i] == n-1) break;
+                --i;
+                if (ptn[i] == 0)
+                {
+                    *code = -1;
+                    return;
+                }
+            }
+        }
+    }
+}
+
+/**************************************************************************/
+
+static void
+makecanon(graph *g, graph *gcan, int n)
+/* gcan := canonise(g) */
+{
+    int lab[MAXN],ptn[MAXN],orbits[MAXN];
+    static DEFAULTOPTIONS_GRAPH(options);
+    setword workspace[50];
+
+    options.getcanon = TRUE;
+
+    nauty(g,lab,ptn,NULL,orbits,&options,&nauty_stats,
+          workspace,50,1,n,gcan);
+}
+
+/**************************************************************************/
+
+static boolean
+accept1(graph *g, int n, xword x, graph *gx, int *deg, boolean *rigid)
+/* decide if n in theta(g+x) -  version for n+1 < maxn */
+{
+    int i;
+    int lab[MAXN],ptn[MAXN],orbits[MAXN];
+    int count[MAXN];
+    graph h[MAXN];
+    xword xw;
+    int nx,numcells,code;
+    int i0,i1,degn;
+    set active[MAXM];
+    statsblk stats;
+    static DEFAULTOPTIONS_GRAPH(options);
+    setword workspace[50];
+
+#ifdef INSTRUMENT
+    ++a1calls;
+#endif
+
+    nx = n + 1;
+    for (i = 0; i < n; ++i) gx[i] = g[i];
+    gx[n] = 0;
+    deg[n] = degn = XPOPCOUNT(x);
+
+    xw = x;
+    while (xw)
+    {
+        i = XNEXTBIT(xw);
+        xw ^= xbit[i];
+        gx[i] |= bit[n];
+        gx[n] |= bit[i];
+        ++deg[i];
+    }
+
+#ifdef PREPRUNE
+    if (PREPRUNE(gx,n+1,maxn)) return FALSE;
+#endif
+
+    i0 = 0;
+    i1 = n;
+    for (i = 0; i < nx; ++i)
+    {
+        if (deg[i] == degn) lab[i1--] = i;
+        else                lab[i0++] = i;
+        ptn[i] = 1;
+    }
+    ptn[n] = 0;
+    if (i0 == 0)
+    {
+        numcells = 1;
+        active[0] = bit[0];
+    }
+    else
+    {
+        numcells = 2;
+        active[0] = bit[0] | bit[i1+1];
+        ptn[i1] = 0;
+    }
+    refinex(gx,lab,ptn,0,&numcells,count,active,FALSE,&code,1,nx);
+
+    if (code < 0) return FALSE;
+
+    if (numcells == nx)
+    {
+        *rigid = TRUE;
+#ifdef INSTRUMENT
+        ++a1succs;
+#endif
+        return TRUE;
+    }
+
+    options.getcanon = TRUE;
+    options.defaultptn = FALSE;
+    options.userautomproc = userautomproc;
+
+    active[0] = 0;
+#ifdef INSTRUMENT
+    ++a1nauty;
+#endif
+    nauty(gx,lab,ptn,active,orbits,&options,&stats,workspace,50,1,nx,h);
+
+    if (orbits[lab[n]] == orbits[n])
+    {
+        *rigid = stats.numorbits == nx;
+#ifdef INSTRUMENT
+        ++a1succs;
+#endif
+        return TRUE;
+    }
+    else
+        return FALSE;
+}
+
+/**************************************************************************/
+
+static boolean
+accept1b(graph *g, int n, xword x, graph *gx, int *deg, boolean *rigid,
+     void (*makeh)(graph*,xword*,int))
+/* decide if n in theta(g+x)  --  version for n+1 < maxn */
+{
+    int i,v;
+    xword z,hv,bitv,ixx;
+    int lab[MAXN],ptn[MAXN],orbits[MAXN];
+    int count[MAXN];
+    graph gc[MAXN];
+    xword h[MAXN],xw,jxx,kxx,*xx;
+    int nx,numcells,code;
+    int i0,i1,degn,xubx;
+    set active[MAXM];
+    statsblk stats;
+    static DEFAULTOPTIONS_GRAPH(options);
+    setword workspace[50];
+
+#ifdef INSTRUMENT
+    ++a1calls;
+#endif
+
+    nx = n + 1;
+    for (i = 0; i < n; ++i) gx[i] = g[i];
+    gx[n] = 0;
+    deg[n] = degn = XPOPCOUNT(x);
+
+    xw = x;
+    while (xw)
+    {
+        i = XNEXTBIT(xw);
+        xw ^= xbit[i];
+        gx[i] |= bit[n];
+        gx[n] |= bit[i];
+        ++deg[i];
+    }
+
+#ifdef PREPRUNE
+    if (PREPRUNE(gx,n+1,maxn)) return FALSE;
+#endif
+
+    i0 = 0;
+    i1 = n;
+    for (i = 0; i < nx; ++i)
+    {
+        if (deg[i] == degn) lab[i1--] = i;
+        else                lab[i0++] = i;
+        ptn[i] = 1;
+    }
+    ptn[n] = 0;
+    if (i0 == 0)
+    {
+        numcells = 1;
+        active[0] = bit[0];
+    }
+    else
+    {
+        numcells = 2;
+        active[0] = bit[0] | bit[i1+1];
+        ptn[i1] = 0;
+    }
+    refinex(gx,lab,ptn,0,&numcells,count,active,FALSE,&code,1,nx);
+
+    if (code < 0) return FALSE;
+
+    (*makeh)(gx,h,nx);
+    xx = data[nx].xx;
+    xubx = data[nx].xub;
+
+    xx[0] = 0;
+    kxx = 1;
+    for (v = 0; v < nx; ++v)
+    {
+        bitv = xbit[v];
+        hv = h[v];
+        jxx = kxx;
+        for (ixx = 0; ixx < jxx; ++ixx)
+        if ((hv & xx[ixx]) == 0)
+        {
+            z = xx[ixx] | bitv;
+            if (XPOPCOUNT(z) <= xubx) xx[kxx++] = z;
+        }
+    }
+    data[nx].xlim = kxx;
+
+    if (numcells == nx)
+    {
+        *rigid = TRUE;
+#ifdef INSTRUMENT
+        ++a1succs;
+#endif
+        return TRUE;
+    }
+
+    options.getcanon = TRUE;
+    options.defaultptn = FALSE;
+    options.userautomproc = userautomprocb;
+
+    active[0] = 0;
+#ifdef INSTRUMENT
+    ++a1nauty;
+#endif
+    nauty(gx,lab,ptn,active,orbits,&options,&stats,workspace,50,1,nx,gc);
+
+    if (orbits[lab[n]] == orbits[n])
+    {
+        *rigid = stats.numorbits == nx;
+#ifdef INSTRUMENT
+        ++a1succs;
+#endif
+        return TRUE;
+    }
+    else
+        return FALSE;
+}
+
+/**************************************************************************/
+
+static boolean
+accept2(graph *g, int n, xword x, graph *gx, int *deg, boolean nuniq)
+/* decide if n in theta(g+x)  --  version for n+1 == maxn */
+{
+    int i;
+    int lab[MAXN],ptn[MAXN],orbits[MAXN];
+    int degx[MAXN],invar[MAXN];
+    setword vmax,gv;
+    int qn,qv;
+    int count[MAXN];
+    xword xw;
+    int nx,numcells,code;
+    int degn,i0,i1,j,j0,j1;
+    set active[MAXM];
+    statsblk stats;
+    static DEFAULTOPTIONS_GRAPH(options);
+    setword workspace[50];
+    boolean cheapacc;
+
+#ifdef INSTRUMENT
+    ++a2calls;
+    if (nuniq) ++a2uniq;
+#endif
+    nx = n + 1;
+    for (i = 0; i < n; ++i)
+    {
+        gx[i] = g[i];
+        degx[i] = deg[i];
+    }
+    gx[n] = 0;
+    degx[n] = degn = XPOPCOUNT(x);
+
+    xw = x;
+    while (xw)
+    {
+        i = XNEXTBIT(xw);
+        xw ^= xbit[i];
+        gx[i] |= bit[n];
+        gx[n] |= bit[i];
+        ++degx[i];
+    }
+
+#ifdef PREPRUNE
+    if (PREPRUNE(gx,n+1,maxn)) return FALSE;
+#endif
+
+    if (nuniq)
+    {
+#ifdef INSTRUMENT
+        ++a2succs;
+#endif
+        if (canonise) makecanon(gx,gcan,nx);
+        return TRUE;
+    }
+
+    i0 = 0;
+    i1 = n;
+    for (i = 0; i < nx; ++i)
+    {
+        if (degx[i] == degn) lab[i1--] = i;
+        else                 lab[i0++] = i;
+        ptn[i] = 1;
+    }
+    ptn[n] = 0;
+    if (i0 == 0)
+    {
+        numcells = 1;
+        active[0] = bit[0];
+
+        if (!distinvar(gx,invar,nx)) return FALSE;
+        qn = invar[n];
+        j0 = 0;
+        j1 = n;
+        while (j0 <= j1)
+        {
+            j = lab[j0];
+            qv = invar[j];
+            if (qv < qn)
+                ++j0;
+            else
+            {
+                lab[j0] = lab[j1];
+                lab[j1] = j;
+                --j1;
+            }
+        }
+        if (j0 > 0)
+        {
+            if (j0 == n)
+            {
+#ifdef INSTRUMENT
+                ++a2succs;
+#endif
+                if (canonise) makecanon(gx,gcan,nx);
+                return TRUE;
+            }
+            ptn[j1] = 0;
+            ++numcells;
+            active[0] |= bit[j0];
+        }
+    }
+    else
+    {
+        numcells = 2;
+        ptn[i1] = 0;
+        active[0] = bit[0] | bit[i1+1];
+
+        vmax = 0;
+        for (i = i1+1; i < nx; ++i) vmax |= bit[lab[i]];
+
+        gv = gx[n] & vmax;
+        qn = POPCOUNT(gv);
+
+        j0 = i1+1;
+        j1 = n;
+        while (j0 <= j1)
+        {
+            j = lab[j0];
+            gv = gx[j] & vmax;
+            qv = POPCOUNT(gv);
+            if (qv > qn)
+                return FALSE;
+            else if (qv < qn)
+                ++j0;
+            else
+            {
+                lab[j0] = lab[j1];
+                lab[j1] = j;
+                --j1;
+            }
+        }
+        if (j0 > i1+1)
+        {
+            if (j0 == n)
+            {
+#ifdef INSTRUMENT
+                ++a2succs;
+#endif
+                if (canonise) makecanon(gx,gcan,nx);
+                return TRUE;
+            }
+            ptn[j1] = 0;
+            ++numcells;
+            active[0] |= bit[j0];
+        }
+    }
+
+    refinex(gx,lab,ptn,0,&numcells,count,active,TRUE,&code,1,nx);
+
+    if (code < 0) return FALSE;
+
+    cheapacc = FALSE;
+    if (code > 0 || numcells >= nx-4)
+        cheapacc = TRUE;
+    else if (numcells == nx-5)
+    {
+        for (j1 = nx-2; j1 >= 0 && ptn[j1] > 0; --j1) {}
+        if (nx - j1 != 5) cheapacc = TRUE;
+    }
+    else
+    {
+        j1 = nx;
+        j0 = 0;
+        for (i1 = 0; i1 < nx; ++i1)
+        {
+            --j1;
+            if (ptn[i1] > 0)
+            {
+                ++j0;
+                while (ptn[++i1] > 0) {}
+            }
+        }
+        if (j1 <= j0 + 1) cheapacc = TRUE;
+    }
+    
+    if (cheapacc)
+    {
+#ifdef INSTRUMENT
+        ++a2succs;
+#endif
+        if (canonise) makecanon(gx,gcan,nx);
+        return TRUE;
+    }
+
+    options.getcanon = TRUE;
+    options.defaultptn = FALSE;
+
+    active[0] = 0;
+#ifdef INSTRUMENT
+    ++a2nauty;
+#endif
+    nauty(gx,lab,ptn,active,orbits,&options,&stats,workspace,50,1,nx,gcan);
+
+    if (orbits[lab[n]] == orbits[n])
+    {
+#ifdef INSTRUMENT
+        ++a2succs;
+#endif
+        if (canonise) makecanon(gx,gcan,nx);
+        return TRUE;
+    }
+    else
+        return FALSE;
+}
+
+/**************************************************************************/
+
+static void
+xbnds(int n, int ne, int dmax)
+/* find bounds on extension degree;  store answer in data[*].*  */
+{
+    int xlb,xub,d,nn,m,xc;
+
+    xlb = n == 1 ? 0 : (dmax > (2*ne + n - 2)/(n - 1) ?
+                        dmax : (2*ne + n - 2)/(n - 1));
+    xub = n < maxdeg ? n : maxdeg;
+
+    for (xc = xub; xc >= xlb; --xc)
+    {
+        d = xc;
+        m = ne + d;
+        for (nn = n+1; nn < maxn; ++nn)
+        {
+            if (d < (2*m + nn - 2)/(nn - 1)) d = (2*m + nn - 2)/(nn - 1);
+            m += d;
+        }
+        if (d > maxdeg || m > maxe) xub = xc - 1;
+        else                        break;
+    }
+
+    if (ne + xlb < mine)
+        for (xc = xlb; xc <= xub; ++xc)
+        {
+            m = ne + xc;
+            for (nn = n + 1; nn < maxn; ++nn)
+                m += maxdeg < nn ? maxdeg : nn;
+            if (m < mine) xlb = xc + 1;
+            else          break;
+        }
+
+    data[n].ne = ne;
+    data[n].dmax = dmax;
+    data[n].xlb = xlb;
+    data[n].xub = xub;
+}
+
+/**************************************************************************/
+
+static void
+spaextend(graph *g, int n, int *deg, int ne, boolean rigid,
+      int xlb, int xub, void (*makeh)(graph*,xword*,int))
+/* extend from n to n+1 -- version for restricted graphs */
+{
+    xword x,d,dlow;
+    xword xlim,*xorb;
+    int xc,nx,i,j,dmax,dcrit,xlbx,xubx;
+    graph gx[MAXN];
+    xword *xx,ixx;
+    int degx[MAXN];
+    boolean rigidx;
+
+#ifdef INSTRUMENT
+    boolean haschild;
+
+    haschild = FALSE;
+    if (rigid) ++rigidnodes[n];
+#endif
+    ++nodes[n];
+
+    nx = n + 1;
+    dmax = deg[n-1];
+    dcrit = mindeg - maxn + n;
+    d = dlow = 0;
+    for (i = 0; i < n; ++i)
+    {
+        if (deg[i] == dmax) d |= xbit[i];
+        if (deg[i] == dcrit) dlow |= xbit[i];
+    }
+
+    if (xlb == dmax && XPOPCOUNT(d) + dmax > n) ++xlb;
+    if (nx == maxn && xlb < mindeg) xlb = mindeg;
+    if (xlb > xub) return;
+
+#ifdef PRUNE
+    if (PRUNE(g,n,maxn)) return;
+#endif
+
+    xorb = data[n].xorb;
+    xx = data[n].xx;
+    xlim = data[n].xlim;
+
+    if (nx == maxn)
+    {
+        for (ixx = 0; ixx < xlim; ++ixx)
+        {
+            x = xx[ixx];
+            xc = XPOPCOUNT(x);
+            if (xc < xlb || xc > xub) continue;
+            if ((rigid || xorb[ixx] == ixx) 
+                && (xc > dmax || (xc == dmax && (x & d) == 0))
+                && (dlow & ~x) == 0)
+            {
+                if (accept2(g,n,x,gx,deg,
+                    xc > dmax+1 || (xc == dmax+1 && (x & d) == 0))
+                    && (!connec ||
+                          (connec==1 && isconnected(gx,nx)) ||
+                          (connec>1 && isbiconnected(gx,nx))))
+                {
+#ifdef PRUNE
+                    if (!PRUNE(gx,nx,maxn))
+#endif
+                    {
+#ifdef INSTRUMENT
+                        haschild = TRUE;
+#endif
+                        ++ecount[ne+xc];
+                        (*outproc)(outfile,canonise ? gcan : gx,nx);
+                    }
+                }
+            }
+        }
+    }
+    else
+    {
+        for (ixx = 0; ixx < xlim; ++ixx)
+        {
+            if (nx == splitlevel)
+            {
+                if (odometer-- != 0) continue;
+                odometer = mod - 1;
+            }
+            x = xx[ixx];
+            xc = XPOPCOUNT(x);
+            if (xc < xlb || xc > xub) continue;
+            if ((rigid || xorb[ixx] == ixx)
+                && (xc > dmax || (xc == dmax && (x & d) == 0))
+                && (dlow & ~x) == 0)
+            {
+                for (j = 0; j < n; ++j) degx[j] = deg[j];
+                if (data[nx].ne != ne+xc || data[nx].dmax != xc)
+                    xbnds(nx,ne+xc,xc);
+
+                xlbx = data[nx].xlb;
+                xubx = data[nx].xub;
+                if (xlbx <= xubx
+                    && accept1b(g,n,x,gx,degx,&rigidx,makeh))
+                {
+#ifdef INSTRUMENT
+                    haschild = TRUE;
+#endif
+                    spaextend(gx,nx,degx,ne+xc,rigidx,xlbx,xubx,makeh);
+                }
+            }
+        }
+        if (n == splitlevel - 1 && n >= min_splitlevel
+                                && nodes[n] >= multiplicity)
+            --splitlevel;
+    }
+#ifdef INSTRUMENT
+    if (haschild) ++fertilenodes[n];
+#endif
+}
+
+/**************************************************************************/
+
+static void
+genextend(graph *g, int n, int *deg, int ne, boolean rigid, int xlb, int xub)
+/* extend from n to n+1 -- version for general graphs */
+{
+    xword x,d,dlow;
+    xword *xset,*xcard,*xorb;
+    xword i,imin,imax;
+    int nx,xc,j,dmax,dcrit;
+    int xlbx,xubx;
+    graph gx[MAXN];
+    int degx[MAXN];
+    boolean rigidx;
+
+#ifdef INSTRUMENT
+    boolean haschild;
+
+    haschild = FALSE;
+    if (rigid) ++rigidnodes[n];
+#endif
+    ++nodes[n];
+
+    nx = n + 1;
+    dmax = deg[n-1];
+    dcrit = mindeg - maxn + n;
+    d = dlow = 0;
+    for (i = 0; i < n; ++i)
+    {
+        if (deg[i] == dmax) d |= xbit[i];
+        if (deg[i] == dcrit) dlow |= xbit[i];
+    }
+
+    if (xlb == dmax && XPOPCOUNT(d) + dmax > n) ++xlb;
+    if (nx == maxn && xlb < mindeg) xlb = mindeg;
+    if (xlb > xub) return;
+
+#ifdef PRUNE 
+    if (PRUNE(g,n,maxn)) return; 
+#endif 
+
+    imin = data[n].xstart[xlb];
+    imax = data[n].xstart[xub+1];
+    xset = data[n].xset;
+    xcard = data[n].xcard;
+    xorb = data[n].xorb;
+
+    if (nx == maxn)
+        for (i = imin; i < imax; ++i)
+        {
+            if (!rigid && xorb[i] != i) continue;
+            x = xset[i];
+            xc = xcard[i];
+            if (xc == dmax && (x & d) != 0) continue;
+            if ((dlow & ~x) != 0) continue;
+
+            if (accept2(g,n,x,gx,deg,
+                        xc > dmax+1 || (xc == dmax+1 && (x & d) == 0)))
+                if (!connec || (connec==1 && isconnected(gx,nx))
+                            || (connec>1 && isbiconnected(gx,nx)))
+                {
+#ifdef PRUNE
+                    if (!PRUNE(gx,nx,maxn))
+#endif
+                    {
+#ifdef INSTRUMENT
+                        haschild = TRUE;
+#endif
+                        ++ecount[ne+xc];
+                        (*outproc)(outfile,canonise ? gcan : gx,nx);
+                    }
+                }
+        }
+    else
+        for (i = imin; i < imax; ++i)
+        {
+            if (!rigid && xorb[i] != i) continue;
+            x = xset[i];
+            xc = xcard[i];
+            if (xc == dmax && (x & d) != 0) continue;
+            if ((dlow & ~x) != 0) continue;
+            if (nx == splitlevel)
+            {
+                if (odometer-- != 0) continue;
+                odometer = mod - 1;
+            }
+
+            for (j = 0; j < n; ++j) degx[j] = deg[j];
+            if (data[nx].ne != ne+xc || data[nx].dmax != xc)
+                xbnds(nx,ne+xc,xc);
+            xlbx = data[nx].xlb;
+            xubx = data[nx].xub;
+            if (xlbx > xubx) continue;
+
+            data[nx].lo = data[nx].xstart[xlbx];
+            data[nx].hi = data[nx].xstart[xubx+1];
+            if (accept1(g,n,x,gx,degx,&rigidx))
+            {
+#ifdef INSTRUMENT
+                haschild = TRUE;
+#endif
+                genextend(gx,nx,degx,ne+xc,rigidx,xlbx,xubx);
+            }
+        }
+
+    if (n == splitlevel-1 && n >= min_splitlevel
+            && nodes[n] >= multiplicity)
+        --splitlevel;
+#ifdef INSTRUMENT
+    if (haschild) ++fertilenodes[n];
+#endif
+}
+
+/**************************************************************************/
+/**************************************************************************/
+
+#ifdef GENG_MAIN
+int
+GENG_MAIN(int argc, char *argv[])
+#else
+int
+main(int argc, char *argv[])
+#endif
+{
+    char *arg;
+    boolean badargs,gote,gotmr,gotf,gotd,gotD,gotx,gotX;
+    boolean secret,connec1,connec2,safe,sparse;
+    char *outfilename,sw;
+    int i,j,argnum;
+    graph g[1];
+    int tmaxe,deg[1];
+    nauty_counter nout;
+    int splitlevinc;
+    xword testxword;
+    double t1,t2;
+    char msg[201];
+
+    HELP; PUTVERSION;
+    nauty_check(WORDSIZE,1,MAXN,NAUTYVERSIONID);
+
+    testxword = (xword)(-1);
+    if (MAXN > 32 || MAXN > WORDSIZE || MAXN > 8*sizeof(xword)
+        || (MAXN == 8*sizeof(xword) && testxword < 1))
+    {
+        fprintf(stderr,"geng: incompatible MAXN, WORDSIZE, or xword\n");
+        fprintf(stderr,"--See notes in program source\n");
+        exit(1);
+    }
+
+    badargs = FALSE;
+    trianglefree = FALSE;
+    bipartite = FALSE;
+    squarefree = FALSE;
+    verbose = FALSE;
+    nautyformat = FALSE;
+    yformat = FALSE;
+    graph6 = FALSE;
+    sparse6 = FALSE;
+    savemem = FALSE;
+    nooutput = FALSE;
+    canonise = FALSE;
+    header = FALSE;
+    outfilename = NULL;
+    secret = FALSE;
+    safe = FALSE;
+    connec1 = connec2 = FALSE;
+
+    maxdeg = MAXN; 
+    mindeg = 0;
+    
+    gotX = gotx = gotd = gotD = gote = gotmr = gotf = FALSE;
+
+    argnum = 0;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('n',nautyformat)
+                else SWBOOLEAN('u',nooutput)
+                else SWBOOLEAN('g',graph6)
+                else SWBOOLEAN('s',sparse6)
+                else SWBOOLEAN('t',trianglefree)
+                else SWBOOLEAN('f',squarefree)
+                else SWBOOLEAN('b',bipartite)
+                else SWBOOLEAN('v',verbose)
+                else SWBOOLEAN('l',canonise)
+                else SWBOOLEAN('y',yformat)
+                else SWBOOLEAN('h',header)
+                else SWBOOLEAN('m',savemem)
+                else SWBOOLEAN('c',connec1)
+                else SWBOOLEAN('C',connec2)
+                else SWBOOLEAN('q',quiet)
+                else SWBOOLEAN('$',secret)
+                else SWBOOLEAN('S',safe)
+                else SWINT('d',gotd,mindeg,"geng -d")
+                else SWINT('D',gotD,maxdeg,"geng -D")
+                else SWINT('x',gotx,multiplicity,"geng -x")
+                else SWINT('X',gotX,splitlevinc,"geng -X")
+#ifdef PLUGIN_SWITCHES
+PLUGIN_SWITCHES
+#endif
+                else badargs = TRUE;
+            }
+        }
+        else if (arg[0] == '-' && arg[1] == '\0')
+            gotf = TRUE;
+        else
+        {
+            if (argnum == 0)
+            {
+                if (sscanf(arg,"%d",&maxn) != 1) badargs = TRUE;
+                ++argnum;
+            }
+            else if (gotf)
+                badargs = TRUE;
+            else
+            {
+                if (!gotmr)
+                {
+                    if (sscanf(arg,"%d/%d",&res,&mod) == 2)
+                    { 
+                        gotmr = TRUE; 
+                        continue; 
+                    }
+                }
+                if (!gote)
+                {
+                    if (sscanf(arg,"%d:%d",&mine,&maxe) == 2
+                     || sscanf(arg,"%d-%d",&mine,&maxe) == 2)
+                    {
+                        gote = TRUE;
+                        if (maxe == 0 && mine > 0) maxe = MAXN*(MAXN-1)/2;
+                        continue;
+                    }
+                    else if (sscanf(arg,"%d",&mine) == 1)
+                    {
+                        gote = TRUE;
+                        maxe = mine;
+                        continue;
+                    }
+                }
+                if (!gotf)
+                {
+                    outfilename = arg;
+                    gotf = TRUE;
+                    continue;
+                }
+            }
+        }
+    }
+
+    if (argnum == 0)
+        badargs = TRUE;
+    else if (maxn < 1 || maxn > MAXN)
+    {
+        fprintf(stderr,">E geng: n must be in the range 1..%d\n",MAXN);
+        badargs = TRUE;
+    }
+
+    if (!gotmr)
+    {
+        mod = 1;
+        res = 0;
+    }
+
+    if (!gote)
+    {
+        mine = 0;
+        maxe = (maxn*maxn - maxn) / 2;
+    }
+
+    if (connec1 && mindeg < 1 && maxn > 1) mindeg = 1;
+    if (connec2 && mindeg < 2 && maxn > 2) mindeg = 2;
+    if (maxdeg >= maxn) maxdeg = maxn - 1;
+    if (maxe > maxn*maxdeg / 2) maxe = maxn*maxdeg / 2;
+    if (maxdeg > maxe) maxdeg = maxe;
+    if (mindeg < 0) mindeg = 0;
+    if (mine < (maxn*mindeg+1) / 2) mine = (maxn*mindeg+1) / 2;
+    if (maxdeg > 2*maxe - mindeg*(maxn-1)) maxdeg = 2*maxe - mindeg*(maxn-1);
+
+    if (!badargs && (mine > maxe || maxe < 0 || maxdeg < 0))
+    {
+        fprintf(stderr,
+                ">E geng: impossible mine,maxe,mindeg,maxdeg values\n");
+        badargs = TRUE;
+    }
+
+    if (!badargs && (res < 0 || res >= mod))
+    {
+        fprintf(stderr,">E geng: must have 0 <= res < mod\n");
+        badargs = TRUE;
+    }
+
+    if      (connec2) connec = 2;
+    else if (connec1) connec = 1;
+    else              connec = 0;
+
+    if (connec && mine < maxn-1) mine = maxn - 2 + connec;
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if ((nautyformat!=0) + (yformat!=0) + (graph6!=0)
+                         + (sparse6!=0) + (nooutput!=0) > 1)
+        gt_abort(">E geng: -uyngs are incompatible\n");
+
+#ifdef OUTPROC
+    outproc = OUTPROC;
+#else
+    if (nautyformat)   outproc = writenauty;
+    else if (yformat)  outproc = writeny;
+    else if (nooutput) outproc = nullwrite;
+    else if (sparse6)  outproc = writes6x;
+    else               outproc = writeg6x;
+#endif
+
+#ifdef PLUGIN_INIT
+PLUGIN_INIT
+#endif
+
+    for (i = 0; i <= maxe; ++i) ecount[i] = 0;
+    for (i = 0; i < maxn; ++i)  nodes[i] = 0;
+
+    if (nooutput)
+        outfile = stdout;
+    else if (!gotf || outfilename == NULL)
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename,
+                    nautyformat ? "wb" : "w")) == NULL)
+    {
+        fprintf(stderr,
+              ">E geng: can't open %s for writing\n",outfilename);
+        gt_abort(NULL);
+    }
+
+    if (bipartite)
+        if (squarefree)  tmaxe = maxebf[maxn];
+        else             tmaxe = maxeb[maxn];
+    else if (trianglefree)
+        if (squarefree)  tmaxe = maxeft[maxn];
+        else             tmaxe = maxet[maxn];
+    else if (squarefree) tmaxe = maxef[maxn];
+    else                 tmaxe = (maxn*maxn - maxn) / 2;
+
+    if (safe) ++tmaxe;
+
+    if (maxe > tmaxe) maxe = tmaxe;
+
+    if (gotx)
+    {
+        if (multiplicity < 3 * mod || multiplicity > 999999999)
+            gt_abort(">E geng: -x value must be in [3*mod,10^9-1]\n");
+    }
+    else
+    {
+        multiplicity = PRUNEMULT * mod;
+	if (multiplicity / PRUNEMULT != mod)
+	    gt_abort(">E geng: mod value is too large\n");
+    }
+
+    if (!gotX) splitlevinc = 0;
+
+    if (!quiet)
+    {
+        msg[0] = '\0';
+        if (strlen(argv[0]) > 75)
+            fprintf(stderr,">A %s",argv[0]);
+        else
+            CATMSG1(">A %s",argv[0]);
+       
+        CATMSG6(" -%s%s%s%s%s%s",
+            connec2      ? "C" : connec1 ? "c" : "",
+            trianglefree ? "t" : "",
+            squarefree   ? "f" : "",
+            bipartite    ? "b" : "",
+            canonise     ? "l" : "",
+            savemem      ? "m" : "");
+        if (mod > 1)
+            CATMSG2("X%dx%d",splitlevinc,multiplicity);
+        CATMSG4("d%dD%d n=%d e=%d",mindeg,maxdeg,maxn,mine);
+        if (maxe > mine) CATMSG1("-%d",maxe);
+        if (mod > 1) CATMSG2(" class=%d/%d",res,mod);
+        CATMSG0("\n");
+        fputs(msg,stderr);
+        fflush(stderr);
+    }
+
+    g[0] = 0;
+    deg[0] = 0;
+
+    sparse = bipartite || squarefree || trianglefree || savemem;
+
+    t1 = CPUTIME;
+
+    if (header)
+    {
+        if (sparse6)
+        {
+            writeline(outfile,SPARSE6_HEADER);
+            fflush(outfile);
+        }
+        else if (!yformat && !nautyformat && !nooutput)
+        {
+            writeline(outfile,GRAPH6_HEADER);
+            fflush(outfile);
+        }
+    }
+
+    if (maxn == 1)
+    {
+        if (res == 0)
+        {
+            ++ecount[0];
+            (*outproc)(outfile,g,1);
+        }
+    }
+    else
+    {
+        if (maxn > 28 || maxn+4 > 8*sizeof(xword))
+            savemem = sparse = TRUE;
+        if (maxn == maxe+1 && connec)
+            bipartite = squarefree = sparse = TRUE;  /* trees */
+
+        makeleveldata(sparse);
+
+        if (maxn >= 14 && mod > 1)     splitlevel = maxn - 4;
+        else if (maxn >= 6 && mod > 1) splitlevel = maxn - 3;
+        else                           splitlevel = -1;
+
+        if (splitlevel > 0) splitlevel += splitlevinc;
+        if (splitlevel > maxn - 1) splitlevel = maxn - 1;
+        if (splitlevel < 3) splitlevel = -1;
+
+        min_splitlevel = 6;
+        odometer = secret ? -1 : res;
+
+        if (maxe >= mine && 
+                (mod <= 1 || (mod > 1 && (splitlevel > 2 || res == 0))))
+        {
+            xbnds(1,0,0);   
+            if (sparse)
+            {
+                data[1].xx[0] = 0;
+                if (maxdeg > 0) data[1].xx[1] = xbit[0];
+                data[1].xlim = data[1].xub + 1;
+            }
+
+            if (bipartite)
+                if (squarefree)
+                    spaextend(g,1,deg,0,TRUE,
+                                    data[1].xlb,data[1].xub,makeb6graph);
+                else
+                    spaextend(g,1,deg,0,TRUE,
+                                    data[1].xlb,data[1].xub,makebgraph);
+            else if (trianglefree)
+                if (squarefree)
+                    spaextend(g,1,deg,0,TRUE,
+                                    data[1].xlb,data[1].xub,makeg5graph);
+                else
+                    spaextend(g,1,deg,0,TRUE,
+                                    data[1].xlb,data[1].xub,makexgraph);
+            else if (squarefree)
+                spaextend(g,1,deg,0,TRUE,
+                                    data[1].xlb,data[1].xub,makesgraph);
+            else if (savemem)
+                spaextend(g,1,deg,0,TRUE,
+                                    data[1].xlb,data[1].xub,make0graph);
+            else
+                genextend(g,1,deg,0,TRUE,data[1].xlb,data[1].xub);
+        }
+    }
+    t2 = CPUTIME;
+
+    nout = 0;
+    for (i = 0; i <= maxe; ++i) nout += ecount[i];
+
+    if (verbose)
+    {
+        for (i = 0; i <= maxe; ++i)
+            if (ecount[i] != 0)
+            {
+		fprintf(stderr,">C " COUNTER_FMT " graphs with %d edges\n",
+                     ecount[i],i);
+            }
+    }
+
+#ifdef INSTRUMENT
+    fprintf(stderr,"\n>N node counts\n");
+    for (i = 1; i < maxn; ++i)
+    {
+        fprintf(stderr," level %2d: \n",i);
+        fprintf(stderr,COUNTER_FMT " (%lu rigid, %lu fertile)\n",
+                       nodes[i],rigidnodes[i],fertilenodes[i]);
+    }
+    fprintf(stderr,">A1 %lu calls to accept1, %lu nauty, %lu succeeded\n",
+                    a1calls,a1nauty,a1succs);
+    fprintf(stderr,
+         ">A2 %lu calls to accept2, %lu nuniq, %lu nauty, %lu succeeded\n",
+                    a2calls,a2uniq,a2nauty,a2succs);
+    fprintf(stderr,"\n");
+#endif
+
+#ifdef SUMMARY
+    SUMMARY(nout,t2-t1);
+#endif
+
+    if (!quiet)
+    {
+        fprintf(stderr,">Z " COUNTER_FMT " graphs generated in %3.2f sec\n",
+                nout,t2-t1);
+    }
+
+#ifdef GENG_MAIN
+    for (i = 1; i < maxn; ++i)
+        if (sparse)
+        {
+            free(data[i].xorb);
+            free(data[i].xx);
+        }
+        else
+        {
+            free(data[i].xorb);
+            free(data[i].xset);
+            free(data[i].xinv);
+            free(data[i].xcard);
+        }
+    return 0;
+#else
+    exit(0);
+#endif
+}
diff --git a/lib/nauty/genquarticg.c b/lib/nauty/genquarticg.c
new file mode 100644
index 0000000..0966327
--- /dev/null
+++ b/lib/nauty/genquarticg.c
@@ -0,0 +1,1620 @@
+/*****************************************************************************
+*                                                                            *
+*   Quarticgen by Brendan D. McKay and S. Narjess Afzaly                     *
+*   This program generates all quartic graphs up to a given order            *
+*                                                                            *
+*   Parameters - <r> means read-only, <w> means write-only, <wr> means both: *
+*          nmax  <r>  # vertices.  This must be at least 5 and               *
+*                  at most MAXN.                                             *
+*                                                                            *
+*   numread     <w> # irreducible graphs with n <= nmax vertices             *
+*   numwritten  <w> # quartic graphs of order nmax                           *
+*   diffnum     <w> # all non-root (not irreducible ones) nodes in the       *
+*   search tree (both accepted and rejected ones)                            *
+*   numaac      <w> # accepted non-root nodes in the search tree             *
+*                                                                            *
+ ****************************************************************************/
+//Just the nodes above or on the SL will be generated. The children of nodes oh the SL won't be investigated or generated.
+#define MAXN 28
+#define LEV1 2         //if (nmax<= threshold) then (SplitLevel = nmax-LEV1 ), otherwise (SplitLevel = LEV2).
+#define LEV2 15
+#define threshold 16
+#define WORDSIZE 64
+#include "gtools.h"
+#include "quarticirred28.h"
+
+
+#define MAXE (2*MAXN)
+#define MAXP ((MAXE*MAXE))
+
+static void (*outproc)(FILE*, graph*, int);
+#ifdef OUTPROC
+extern void OUTPROC(FILE*, graph*, int);
+#endif
+
+static DEFAULTOPTIONS_GRAPH(options);
+static int perm[MAXN];
+static setword workspace[50];
+static statsblk(stats);
+
+
+
+
+
+// badan -c#: (-c1 --> only connected ones ) (-c2 --> only biconnected ones)
+#define USAGE "genquarticg [-ugs -h -c -l] n [res/mod] [file]"
+
+
+#define HELPTEXT \
+"  generate all non-isomorphic quartic graphs of a given order \n\
+\n\
+n     : the number of the vertices\n\
+file  : the name of the output file (default stdout)\n\
+-u    : do not output any graphs, just generate and count them\n\
+-g    : use graph6 format for output (default)\n\
+-s    : use sparse6 format for output\n\
+-h      write a header (only with -g or -s). \n\
+-c    : only write connected graphs\n\
+-C    : only write biconnected graphs\n\
+res/mod : only generate subset res out of subsets 0..mod-1\n\
+-l    : canonically label output graphs.\n" //??????? is it a good feature to add?
+
+
+
+static FILE *outfile, *msgfile;             /* file for output graphs */
+static char *outfilename;
+boolean     nooutput;                       /* presence of -u */
+boolean     graph6;                         /* presence of -g */
+boolean     sparse6;                        /* presence of -s */
+boolean     header;                         /* presence of -h */
+static int  connec;                          /* 1 for -c, 2 for -C, 0 for neither */
+boolean     connec1;                        /* presence of -c */
+boolean     connec2;                        /* presence of -C */
+boolean     canonise;                       /* presence of -l */  //????????
+
+
+typedef struct
+{
+	int first;
+    int sec;
+    setword fn;
+    setword sn;
+    setword end;
+    int intersect;
+    int cond;
+} edgestruct;
+
+typedef struct
+{
+	int first;
+    int sec;
+    int multp;
+} pairstruct;
+
+typedef struct
+{
+	int base;
+	int first1;
+	int sec1;
+	int first2;
+	int sec2;
+} dovistruct;
+
+typedef   enum
+{ accept,reject,undef } CHOISE;
+
+int         *pCNT, *pnumpair, *pdoviorbit, *pepairorbit;
+int         (*pantidovi)[MAXN], (*pantipair)[MAXE], (*pantiedge)[MAXN];
+int         count[MAXN];
+long        numread;
+nauty_counter numwritten;
+pairstruct  *pepair;
+dovistruct  *pdovi;
+edgestruct  *pedge;
+setword     active;
+boolean     goodret;
+static int  nmax, m, code, numcells, mod, res, splitlevel, splitcount;
+//TMP static splitlevel,splitcount,mod,res;    ??????TMP?
+static void    extend(int, graph *, edgestruct *, pairstruct *, int, int * , int *, setword *, int *, boolean );
+static int     init_refinex( int *, int *, int *, set *, int);
+static void     refinex( graph *, int *, int *, int , int *, int *, set *, boolean , int *, int , int );
+static UPROC    userautom1();
+static UPROC 	userautom2();
+static UPROC 	userautom3();
+
+
+/************************************************************************/
+
+static void
+writeg6x(FILE *f, graph *g, int n)
+/* write graph g with n vertices to file f in graph6 format */
+{
+    writeg6(f, g, 1, n);
+}
+
+/************************************************************************/
+
+static void
+writes6x(FILE *f, graph *g, int n)
+/* write graph g with n vertices to file f in graph6 format */
+{
+    writes6(f, g, 1, n);
+}
+
+/***********************************************************************/
+
+static void
+nullwrite(FILE *f, graph *g, int n)
+/* don't write graph g to file f */
+{
+}
+
+/***********************************************************************/
+
+static boolean
+isconnected(graph *g, int n)
+/* test if g is connected with vertices 0,1.., n-1 */
+{
+    setword seen,expanded,toexpand,allbits;
+    int i;
+
+    allbits = ALLMASK(n);
+
+    expanded = bit[n-1];
+    seen = expanded | g[n-1];
+
+    while (seen != allbits && (toexpand = (seen & ~expanded))) /* not == */
+    {
+        i = FIRSTBITNZ(toexpand);
+        expanded |= bit[i];
+        seen |= g[i];
+    }
+
+    return  seen == allbits;
+}
+
+/**********************************************************************/
+
+static boolean
+isbiconnected(graph *g, int n)
+/* test if g is biconnected */
+{
+    int sp,v,w;
+    setword sw;
+    setword visited;
+    int numvis,num[MAXN],lp[MAXN],stack[MAXN];
+
+    if (n <= 2) return FALSE;
+
+    visited = bit[0];
+    stack[0] = 0;
+    num[0] = 0;
+    lp[0] = 0;
+    numvis = 1;
+    sp = 0;
+    v = 0;
+
+    for (;;)
+    {
+        if ((sw = g[v] & ~visited))           /* not "==" */
+        {
+            w = v;
+            v = FIRSTBITNZ(sw);       /* visit next child */
+            stack[++sp] = v;
+            visited |= bit[v];
+            lp[v] = num[v] = numvis++;
+            sw = g[v] & visited & ~bit[w];
+            while (sw)
+            {
+                w = FIRSTBITNZ(sw);
+                sw &= ~bit[w];
+                if (num[w] < lp[v])  lp[v] = num[w];
+            }
+        }
+        else
+        {
+            w = v;                  /* back up to parent */
+            if (sp <= 1)          return numvis == n;
+            v = stack[--sp];
+            if (lp[w] >= num[v])  return FALSE;
+            if (lp[w] < lp[v])    lp[v] = lp[w];
+        }
+    }
+}
+
+
+/****************************************************************************
+ *    extend recursively extends quartic graph until number of vertices      *
+ *    of the graph reaches nmax after which it is written to outputfile      *
+ ****************************************************************************/
+
+static void
+extend(int n, graph *g, edgestruct *edge, pairstruct *epair, int numpair,
+   int *epairorbit, int *multar, setword *zar, int *col00w, boolean connectflag)
+{
+    int   vm1, vm2, vm3, vm4, vt1, vt2, vt3, vt4, c, b, mcol1, mcol,
+          tcol, got_one, i, j, k, numpair1, numdovi, maxdovi, i1, j1, i2, j2,
+          numrival, temp, mult, multm, mult2, rely, numedge, dcol, dcolp, e1, e2;
+    int   firsttime[MAXN], firsttimey[MAXN], mult2i[MAXN], multar1[MAXN],
+          col00[MAXN], col00w1[MAXN], rival[MAXN], tagriv[MAXN], doviorbit[3*MAXN],
+          epairorbit1[MAXP], l[MAXN], lab[MAXN], ptn[MAXN], orbits[MAXN];
+    int 		antipair[MAXE][MAXE], antiedge[MAXN][MAXN], antidovi[MAXN][MAXN];
+    setword     x, y, z, x1, bitj1, bitj2, biti2;
+    setword     yi[MAXN], zar1[MAXN];
+    CHOISE	colours; 
+    pairstruct 	epair1[MAXP];
+    edgestruct 	edge1[MAXE];
+    graph       gi[MAXN];
+    dovistruct 	dovi[3*MAXN];
+    dovistruct  dovimax;
+    register    setword    gi1, gi2, gj1, gj2;
+    boolean     conf;
+
+    /////////////////////////////////////////////////////////////////////////
+    if( n == splitlevel )
+    {
+        if (splitcount-- != 0) return;
+        splitcount = mod - 1;
+    }
+    /////////////////////////////////////////////////////////////////////////
+    for( c = 1; c < numpair; c++)
+    {
+        if( epairorbit[c] == c  )
+        {
+
+            int eqn[MAXN],neqn;
+            setword zval[MAXN],zz,eqcol0;
+            int dcol0,dcol1;
+
+            e1 = epair[c].first;
+            e2 = epair[c].sec;
+
+            vm1 = edge[e1].first;
+            vm2 = edge[e1].sec;
+            vm3 = edge[e2].first;
+            vm4 = edge[e2].sec;
+
+            g[vm1] ^= bit[n] | bit[vm2];
+            g[vm2] ^= bit[n] | bit[vm1];
+            g[vm3] ^= bit[n] | bit[vm4];
+            g[vm4] ^= bit[n] | bit[vm3];
+
+            g[n] = bit[vm1] | bit[vm2] | bit[vm3] | bit[vm4];
+
+            multar1[n] = multm = epair[c].multp;
+
+            got_one = 0;
+            dcol0 = ( (g[vm1]&g[vm2])!= bit[n]) + ((g[vm3]&g[vm4])!=bit[n]);
+
+
+            zar1[n] = z = g[vm1] ^ g[vm2] ^ g[vm3] ^ g[vm4];
+            col00w1[n] = col00[n] = -POPCOUNT(z) + ( (4-multm) << 6 );
+
+            zval[n] = z; eqcol0 = bit[n]; neqn = 0;
+            setword xn;
+            xn = g[n]|bit[n];
+
+
+            b = n-1;		
+            while( (!got_one)  &&   (b >= 0) )
+            {					
+
+
+               if(  !((g[b]|bit[b]) & xn )   &&  (multar[b] < 9 ) )
+                {
+                    mult = multar1[b] = multar[b];
+                    if( mult )
+                    {
+                        z = zar1[b] = zar[b];
+                        col00[b] = col00w1[b] = col00w[b];
+                    }
+
+                }
+                else
+                {
+                    x = g[b];
+                    bitj2 = x&(-x); x ^= bitj2; j2 = FIRSTBITNZ(bitj2);
+                    biti2 = x&(-x); x ^= biti2; i2 = FIRSTBITNZ(biti2);
+                    bitj1 = x&(-x); x ^= bitj1; j1 = FIRSTBITNZ(bitj1);
+                    i1 = FIRSTBITNZ(x);
+                    mult = 0;
+                    if(   (!(g[i1] & bitj1))  &&   (!(g[i2] & bitj2))  )
+                        mult++;
+                    if(   (!(g[i1] & bitj2))  &&   (!(g[i2] & bitj1))  )
+                        mult++;
+                    if(   (!(g[i1] & biti2))  &&   (!(g[j1] & bitj2))  )
+                        mult++;
+                    multar1[b] = mult;
+
+
+                    if( mult )
+                    {
+
+                        z = zar1[b] = g[i1] ^ g[i2] ^ g[j1] ^ g[j2];
+                        col00[b] = col00w1[b] = -POPCOUNT(z) + ( (4-mult) << 6 );
+                    }
+                }
+
+
+                if( mult )
+                {
+                    if( col00[b] > col00[n] )
+                            got_one = 1;
+                    else if ( col00[b] == col00[n] )
+                    {
+                            eqcol0 |= bit[b];
+                            zval[b] = z;
+                            eqn[neqn++] = b;
+                    }
+                }
+                else
+                        col00w1[b] = col00[b] = 0;	
+                b--; 	
+            }
+
+
+
+
+            if (!got_one && neqn > 0)
+            {
+                int col00x,col00y,v;
+                setword yz;
+
+                yz = eqcol0 & zval[n];
+                col00x = MAXN-POPCOUNT(yz);
+                col00[n] += col00x;
+                while (--neqn >= 0)
+                {
+                    v = eqn[neqn];
+                    yz = eqcol0 & zval[v];
+                    col00y = MAXN-POPCOUNT(yz);
+                    if (col00y > col00x)
+                    {
+                        got_one = 1;
+                        break;
+                    }
+                    else col00[v] += col00y;
+                }
+            }
+
+            if (  !got_one	) 	
+            {
+                numcells = init_refinex( col00, lab, ptn, &active, n);		
+
+                refinex(g, lab, ptn, 0, &numcells, count, &active, TRUE, &code, 1, n+1);	
+
+                if( code == -1 )
+                    got_one = 1;
+
+                if (	  !got_one	)
+                    mcol1 =  ((col00[vm1] + col00[vm2] ) * (col00[vm3] + col00[vm4]));
+            }
+
+
+            numdovi = 0;
+            j = n;				
+            while(  (!got_one)       &&       (  (j==n)  || (ptn[j])  )     )
+            {			  			
+                b = lab[j];
+                if( b != n)
+                {				
+                    x = g[b];
+                    TAKEBIT(i1,x);				
+                    TAKEBIT(j1,x);
+                    TAKEBIT(i2,x);
+                    TAKEBIT(j2,x);  			
+                    for(i=0; i < 3 && !got_one; i++)
+                    {
+                        if(i == 0)
+                        {
+                            vt1 = i1;
+                            vt2 = j1;
+                            vt3 = i2;
+                            vt4 = j2;
+                        }
+
+                        if(i == 1)
+                        {
+                            vt1 = i1;
+                            vt2 = i2;
+                            vt3 = j1;
+                            vt4 = j2;
+                        }
+
+                        if(i == 2)
+                        {
+                            vt1 = i1;
+                            vt2 = j2;
+                            vt3 = j1;
+                            vt4 = i2;
+                        }
+
+                        if( vt3 > vt4 )
+                        {
+                            temp = vt3;
+                            vt3 = vt4;
+                            vt4 = temp;
+                        }						
+
+                        if( (!(g[vt1] & bit[vt2]))  &&   (!(g[vt3] & bit[vt4]))   &&  (!got_one) )
+                        {	
+                            tcol =  ((col00[vt1] + col00[vt2] ) * (col00[vt3] + col00[vt4]));
+                            dcol1 = ((g[vt1]&g[vt2])!=bit[b]) + ((g[vt3]&g[vt4])!=bit[b]);
+                            if( dcol1 < dcol0 || (dcol1 == dcol0 && tcol < mcol1 ))
+                                got_one = 1;
+                            else if( dcol1 == dcol0 && tcol == mcol1 )
+                            {
+
+                                    dovi[numdovi].base = b;
+                                    dovi[numdovi].first1 = vt1;
+                                    dovi[numdovi].sec1 = vt2;
+                                    dovi[numdovi].first2 = vt3;
+                                    dovi[numdovi].sec2 = vt4;
+                                    antidovi[b][vt2] =numdovi;
+                                    numdovi++;				
+                            }	
+                        }
+                    }							
+                }
+
+                j--;
+                if(j<0)
+                    break; 	
+            }
+
+
+
+            if( (!(g[vm1] & bit[vm3]))  &&   (!(g[vm2] & bit[vm4]))   &&  (!got_one) )
+            {   	
+                if( vm2 < vm4 )
+                {
+                    tcol =  ((col00[vm1] + col00[vm3] ) * (col00[vm2] + col00[vm4]));
+                    dcol1 = ((g[vm1]&g[vm3])!=bit[n]) + ((g[vm2]&g[vm4])!=bit[n]);
+                    if (dcol1 < dcol0 || (dcol1 == dcol0 &&  tcol < mcol1 ))
+                        got_one = 1;
+                    else if( dcol1 == dcol0 && tcol == mcol1 )
+                    {
+                            dovi[numdovi].base = n;
+                            dovi[numdovi].first1 = vm1;
+                            dovi[numdovi].sec1 = vm3;
+                            dovi[numdovi].first2 = vm2;
+                            dovi[numdovi].sec2 = vm4;
+                            antidovi[n][vm3] =numdovi;
+                            numdovi++;  			
+                    }
+
+                }
+                else
+                {
+                    tcol = ((col00[vm1] + col00[vm3] ) * (col00[vm4] + col00[vm2]));
+
+                    dcol1 = ((g[vm1]&g[vm3])!=bit[n]) + ((g[vm2]&g[vm4])!=bit[n]);
+                    if (dcol1 < dcol0 || (dcol1 == dcol0 &&  tcol < mcol1 ))
+                        got_one = 1; 				
+                    else if( dcol1 == dcol0 && tcol == mcol1 )
+                    {
+                            dovi[numdovi].base = n;
+                            dovi[numdovi].first1 = vm1;
+                            dovi[numdovi].sec1 = vm3;
+                            dovi[numdovi].first2 = vm4;
+                            dovi[numdovi].sec2 = vm2;
+                            antidovi[n][vm3] =numdovi;
+                            numdovi++;								
+                    }
+                }	
+            }
+
+            if( (!(g[vm1] & bit[vm4]))  &&   (!(g[vm2] & bit[vm3]))   &&  (!got_one) )
+            {   	
+                if( vm2 < vm3 )
+                {
+                    tcol = ((col00[vm1] + col00[vm4] ) * (col00[vm2] + col00[vm3]));
+                    dcol1 = ((g[vm1]&g[vm4])!=bit[n]) + ((g[vm2]&g[vm3])!=bit[n]);
+                    if (dcol1 < dcol0 || (dcol1 == dcol0 && tcol < mcol1 ))
+                        got_one = 1;
+                    if( dcol1 == dcol0 && tcol == mcol1 )
+                    {
+                            dovi[numdovi].base = n;
+                            dovi[numdovi].first1 = vm1;
+                            dovi[numdovi].sec1 = vm4;
+                            dovi[numdovi].first2 = vm2;
+                            dovi[numdovi].sec2 = vm3;
+                            antidovi[n][vm4] =numdovi;
+                            numdovi++;		
+                    }
+
+                }
+                else
+                {	
+                    tcol =  ((col00[vm1] + col00[vm4] ) * (col00[vm3] + col00[vm2]));
+                    dcol1 = ((g[vm1]&g[vm4])!=bit[n]) + ((g[vm2]&g[vm3])!=bit[n]);
+                    if (dcol1 < dcol0 || (dcol1 == dcol0 && tcol < mcol1 ))
+                        got_one = 1;
+                    if( dcol1 == dcol0 && tcol == mcol1 )
+                    {
+                            dovi[numdovi].base = n;
+                            dovi[numdovi].first1 = vm1;
+                            dovi[numdovi].sec1 = vm4;
+                            dovi[numdovi].first2 = vm3;
+                            dovi[numdovi].sec2 = vm2;
+                            antidovi[n][vm4] =numdovi;
+                            numdovi++;       	
+                    }
+                }
+            }					
+
+
+            if( got_one == 1 )
+                colours = reject;
+            if(   (!got_one) 	&&	 (!numdovi)   	)
+                colours = accept;
+            if( (!got_one) && (numdovi) )
+            {
+                colours = undef;
+                dovi[numdovi].base = n;
+                dovi[numdovi].first1 = vm1;
+                dovi[numdovi].sec1 = vm2;
+                dovi[numdovi].first2 = vm3;
+                dovi[numdovi].sec2 = vm4;
+                antidovi[n][vm2] =numdovi;
+                numdovi++;	                              	
+            }				
+
+/*****************************************************************************/
+            if( n+1 == nmax )
+            {
+                if( connec1 )
+                {
+                    conf = TRUE;
+                    if( !connectflag )
+                        conf = isconnected(g, n+1);
+                }
+                if(  !connec  ||  (connec1 && conf ) || (connec2  &&  isbiconnected(g, n+1))  )
+                {
+                    if( colours == accept )
+                    {
+                        (*outproc)( outfile, g, n+1);
+                        ++numwritten;
+                    }
+
+                    if (colours == undef)
+                    {  	
+                        for (i = 0; i < numdovi; i++)
+                            doviorbit[i] = i;
+
+                        pdoviorbit = doviorbit;
+                        pdovi = dovi;
+                        pantidovi = antidovi;
+                        pCNT = &numdovi;					
+
+                        options.userautomproc = userautom2;
+                        options.writeautoms = FALSE;
+                        options.writemarkers = FALSE;
+                        options.getcanon = TRUE;
+                        options.defaultptn = FALSE;   ///// 1.badan in FALSE SHAVAD, 2.COULR AVALI TARIF SHAD, 3.lab o ptn initialize shavand
+
+                        nauty( g, lab, ptn, NULL, orbits, &options, &stats, workspace, 50, m, n+1, gi);				
+
+                        for (i = 0; i < n+1; i++)
+                            l[lab[i]] = i;
+
+                        dovimax.base = -1;
+                        dovimax.first1= -1;
+                        dovimax.sec1 = -1;
+                        dovimax.first2 = -1;
+                        dovimax.sec2 = -1;
+
+                        for (i = 0; i < numdovi; i++)
+                        {
+                            b = l[dovi[i].base];
+                            if( b >= dovimax.base )
+                            {
+                                vt1 = l[dovi[i].first1];
+                                vt1 = l[dovi[i].first1];
+                                vt2 = l[dovi[i].sec1];
+                                vt3 = l[dovi[i].first2];
+                                vt4 = l[dovi[i].sec2];
+
+
+                                if( vt1 > vt2 )
+                                {
+                                    temp = vt1;
+                                    vt1 = vt2;
+                                    vt2 = temp;
+                                }
+                                if( vt3 > vt4 )
+                                {
+                                    temp = vt3;
+                                    vt3 = vt4;
+                                    vt4 = temp;
+                                }
+                                if( vt1 > vt3 )
+                                {
+                                    temp = vt1;
+                                    vt1 = vt3;
+                                    vt3 = temp;
+
+                                    temp = vt2;
+                                    vt2 = vt4;
+                                    vt4 = temp;
+                                }
+
+                                if( (b > dovimax.base)  || ( vt1 > dovimax.first1)  ||
+                                   (  vt1 == dovimax.first1  &&  vt2 > dovimax.sec1)  ||
+                                   (   vt1 == dovimax.first1  &&  vt2 == dovimax.sec1  &&   vt3 > dovimax.first2) ||
+                                   ( vt1 == dovimax.first1  &&  vt2 == dovimax.sec1  &&   vt3 == dovimax.first2  &&  vt4 > dovimax.sec2)    )
+                                {
+                                    dovimax.base = b;
+                                    dovimax.first1 = vt1;
+                                    dovimax.sec1 = vt2;
+                                    dovimax.first2 = vt3;
+                                    dovimax.sec2 = vt4;
+
+                                    maxdovi = i;
+                                }
+                            }
+
+                        }
+
+                        if (doviorbit[maxdovi] == doviorbit[numdovi-1])
+                        {
+                            (*outproc)( outfile, g, n+1);
+                            ++numwritten;
+                        }
+
+                    }
+                }
+            }
+/*****************************************************************************/
+
+            else
+            {		        						                   								
+                if( colours != reject)
+                {
+                    epairorbit1[0] = 0;
+                        numpair1 = 1;
+
+                        setword yn;
+                        yn = g[n] | bit[n];
+
+                        numedge = 0;
+                        for (i = 0; i < n+1; i++)
+                        {
+                            x = g[i] & BITMASK(i);
+                            while (x)
+                            {
+                                y = x&(-x);
+                                x ^= y;
+                                j = FIRSTBITNZ(y);
+
+                                edge1[numedge].first = i;
+                                edge1[numedge].sec = j;	
+                                edge1[numedge].fn = (g[i] & (~bit[j]) );
+                                edge1[numedge].sn = (g[j] & (~bit[i]) );
+                                edge1[numedge].intersect = ( (g[i] & g[j]) != 0 ) ;
+                                edge1[numedge].cond = !( (bit[i]&yn) && (bit[j]&yn ) );
+                                antiedge[i][j] = numedge;
+                                numedge++;
+                            }
+                            firsttimey[i] = firsttime[i] = 1;
+                        }
+
+                        for (e1 = 0; e1 < numedge; e1++)
+                        {						
+                            i1 = edge1[e1].first;
+                            j1 = edge1[e1].sec;
+                            gi1 = edge1[e1].fn;
+                            gj1 = edge1[e1].sn;
+                            dcolp = edge1[e1].intersect;
+
+                            for (e2 = e1+1; e2 < numedge; e2++)
+                            {
+                                antipair[e1][e2] = 0;
+                                // while( (i1 == edge1[e2].first)    &&    (e2 < numedge) )
+                                while( e2 < numedge   &&   (i1 == edge1[e2].first) )
+                                {
+                                    e2++;
+                                    antipair[e1][e2] = 0;
+                                }
+
+                                if( e2 < numedge )
+                                    if( ( j1 != edge1[e2].first )    &&    ( j1 != edge1[e2].sec )  )
+                                    {
+                                        i2 = edge1[e2].first;
+                                        j2 = edge1[e2].sec;
+
+                                        gi2 = edge1[e2].fn;
+                                        gj2 = edge1[e2].sn;
+
+                                        dcol = dcolp + edge1[e2].intersect;
+
+
+
+                                        mult = 1;
+                                        if(   (!(g[i1] & bit[j2]))  &&   (!(g[i2] & bit[j1]))  )
+                                        {
+                                            mult++;
+                                            if(  ( ( ( gi1 & gj2 )!=0) + (( gi2 & gj1 )!=0) )  < dcol   )
+                                                continue;
+                                        }
+
+                                        if(   (!(g[i1] & bit[i2]))  &&   (!(g[j1] & bit[j2]))  )
+                                        {
+                                            mult++;
+                                            if(  ( ( ( gi1 & gi2 )!=0) + (( gj1 & gj2 )!=0) )  < dcol   )
+                                                continue;
+                                        }
+
+
+                                        rely = got_one = 0;						
+                                        if( mult > multm  )
+                                        {
+                                            if(  edge1[e1].cond   &&   edge1[e2].cond )
+                                               continue;
+
+                                            else for(i=1; i <= n/3    &&    rely < 1 &&    !got_one ; i++)
+                                            {
+                                                if( firsttimey[i] )
+                                                {
+                                                    yi[i] = (g[n-i]|bit[n-i]);
+                                                    firsttimey[i] = 0;
+                                                }
+                                                if(  !( (bit[i1]&yi[i]) && (bit[j1]&yi[i]) )    &&   !( (bit[i2]&yi[i]) && (bit[j2]&yi[i]) )   )
+                                                {
+                                                    rely++;  							                                  								
+                                                    if(  mult > multar1[n-i]  &&  multar1[n-i] != 0 )	
+                                                        got_one = 1;
+                                                }
+                                            }
+                                        }
+
+
+                                        if( !got_one )
+                                        {
+                                            epair1[numpair1].first = e1;
+                                            epair1[numpair1].sec = e2;
+                                            epair1[numpair1].multp = mult;
+                                            epairorbit1[numpair1] = numpair1;
+                                            antipair[e1][e2] = numpair1;
+                                            numpair1++;
+                                        }
+
+                                    }						
+
+                            }	
+                        }													                    								
+
+                        pepair = epair1;
+                        pedge = edge1;
+
+                        pnumpair = &numpair1;
+                        pantipair = antipair;
+                        pantiedge = antiedge;
+                        pepairorbit = epairorbit1;
+
+
+                    if( colours == accept )
+                    {
+                        options.userautomproc = userautom1;			
+                        options.writeautoms = FALSE;
+                        options.writemarkers = FALSE;
+                        options.getcanon = FALSE;
+                        options.defaultptn = FALSE;
+                        nauty(g, lab, ptn, NILSET, orbits, &options, &stats, workspace, 50, m, n+1, NILGRAPH); 	
+                        if( connec1 )
+                        {
+                            conf = TRUE;
+                            if( !connectflag )
+                                conf = isconnected(g, n+1);
+                        }
+                        extend(n+1, g, edge1, epair1, numpair1, epairorbit1, multar1, zar1, col00w1, conf);
+                    }
+                    else
+                    {												
+                        for (i = 0; i < numdovi; i++)
+                         	doviorbit[i] = i ;
+
+                        pdoviorbit = doviorbit;
+                        pdovi = dovi;
+                        pantidovi = antidovi;
+                        pCNT = &numdovi;
+
+
+                        options.userautomproc = userautom3;
+                        options.writeautoms = FALSE;
+                        options.writemarkers = FALSE;
+                        options.getcanon = TRUE;
+                        options.defaultptn = FALSE;
+                        nauty( g, lab, ptn, 0, orbits, &options, &stats, workspace, 50, m, n+1, gi);  	
+                        for (i = 0; i < n+1; i++)
+                            l[lab[i]]=i;
+
+
+                        dovimax.base = -1;
+                        dovimax.first1= -1;
+                        dovimax.sec1 = -1;
+                        dovimax.first2 = -1;
+                        dovimax.sec2 = -1;
+
+                        for (i = 0; i < numdovi; i++)
+                        {
+                            b   = l[dovi[i].base];
+                            if( b >= dovimax.base )
+                            {
+                                vt1 = l[dovi[i].first1];
+                                vt2 = l[dovi[i].sec1];
+                                vt3 = l[dovi[i].first2];
+                                vt4 = l[dovi[i].sec2];
+
+
+                                if( vt1 > vt2 )
+                                {
+                                    temp = vt1;
+                                    vt1 = vt2;
+                                    vt2 = temp;
+                                }
+                                if( vt3 > vt4 )
+                                {
+                                    temp = vt3;
+                                    vt3 = vt4;
+                                    vt4 = temp;
+                                }
+                                if( vt1 > vt3 )
+                                {
+                                    temp = vt1;
+                                    vt1 = vt3;
+                                    vt3 = temp;
+
+                                    temp = vt2;
+                                    vt2 = vt4;
+                                    vt4 = temp;
+                                }
+
+                                if( (b > dovimax.base)  ||
+                                    (  vt1 > dovimax.first1 )  ||
+                                    ( vt1 == dovimax.first1  &&  vt2 > dovimax.sec1)  ||
+                                    ( vt1 == dovimax.first1  &&  vt2 == dovimax.sec1  &&   vt3 > dovimax.first2) ||
+                                    ( vt1 == dovimax.first1  &&  vt2 == dovimax.sec1  &&   vt3 == dovimax.first2  &&  vt4 > dovimax.sec2)    )
+                                {
+                                    dovimax.base = b;
+                                    dovimax.first1 = vt1;
+                                    dovimax.sec1 = vt2;
+                                    dovimax.first2 = vt3;
+                                    dovimax.sec2 = vt4;
+
+                                    maxdovi = i;
+                                }
+                            }
+
+                        }
+
+                        if (doviorbit[maxdovi] == doviorbit[numdovi-1])
+                        {
+                            if( connec1 )
+                            {
+                                conf = TRUE;
+                                if( !connectflag )
+                                    conf = isconnected(g, n+1);
+                            }
+                            extend(n+1, g, edge1, epair1, numpair1, epairorbit1, multar1, zar1, col00w1, conf);
+                        }
+                    }
+
+
+
+                }  // end if col..= rej..
+
+            }  // end else >>> (if namx ==n+1)
+
+            g[vm1] ^= bit[n] | bit[vm2];
+            g[vm2] ^= bit[n] | bit[vm1];
+            g[vm3] ^= bit[n] | bit[vm4];
+            g[vm4] ^= bit[n] | bit[vm3];
+            g[n] = 0;
+
+        }  // end if c..
+
+    } //end for c..
+
+}
+
+/*****************************************************************************
+ *                                                                            *
+ *  userautom1(count,perm,orbits,numorbits,stabvertex,n) is a simple          *
+ *  version of the procedure named by options.userautomproc.                  *
+ *                                                                            *
+ *****************************************************************************/
+
+static void
+userautom1(int count, int *perm, int *orbits, int numorbits, int stabvertex, int n)
+{
+    int  epairperm[MAXP];
+    int  vn1, vn2, vn3, vn4, etmp, i, e1, e2;
+
+    epairperm[0] = 0;
+    for (i = 1; i < *pnumpair; i++)
+    {
+        e1 = pepair[i].first;
+        e2 = pepair[i].sec;
+
+        vn1 = perm[pedge[e1].first];
+        vn2 = perm[pedge[e1].sec];
+        vn3 = perm[pedge[e2].first];
+        vn4 = perm[pedge[e2].sec];
+
+        if( vn1 > vn2 )
+        {
+            etmp = vn1;
+            vn1 = vn2;
+            vn2 = etmp;
+        }
+        if( vn3 > vn4 )
+        {
+            etmp = vn3;
+            vn3 = vn4;
+            vn4 = etmp;
+        }
+        if( vn1 > vn3 )
+        {
+            etmp = vn1;
+            vn1 = vn3;
+            vn3 = etmp;
+
+            etmp = vn2;
+            vn2 = vn4;
+            vn4 = etmp;
+        }
+
+        e1 = pantiedge[vn1][vn2];
+        e2 = pantiedge[vn3][vn4];
+        epairperm[i] = pantipair[e1][e2];  			
+    }
+    orbjoin(pepairorbit,epairperm,*pnumpair);
+}
+
+/*****************************************************************************
+ *                                                                            *
+ *  userautom2(count,perm,orbits,numorbits,stabvertex,n) is a simple          *
+ *  version of the procedure named by options.userautomproc.                  *
+ *                                                                            *
+ *****************************************************************************/
+static void
+userautom2(int count, int *perm, int *orbits, int numorbits, int stabvertex, int n)
+{
+    int 	doviperm[3*MAXN];
+    int             vn1, vn2, vn3, vn4, vnb, i, etmp;
+
+    for (i = 0; i < *pCNT; i++)
+    {
+        vnb = perm[pdovi[i].base];
+        vn1 = perm[pdovi[i].first1];
+        vn2 = perm[pdovi[i].sec1];
+        vn3 = perm[pdovi[i].first2];
+        vn4 = perm[pdovi[i].sec2];
+
+
+        if( vn1 > vn2 )
+        {
+            etmp = vn1;
+            vn1 = vn2;
+            vn2 = etmp;
+        }
+        if( vn3 > vn4 )
+        {
+            etmp = vn3;
+            vn3 = vn4;
+            vn4 = etmp;
+        }
+        if( vn1 > vn3 )
+        {
+            etmp = vn1;
+            vn1 = vn3;
+            vn3 = etmp;
+
+            etmp = vn2;
+            vn2 = vn4;
+            vn4 = etmp;
+        }			
+
+        doviperm[i] = pantidovi[vnb][vn2]; 	
+    } 						 		
+    orbjoin(pdoviorbit,doviperm,*pCNT); 										
+}
+
+/*****************************************************************************
+ *                                                                            *
+ *  userautom3(count,perm,orbits,numorbits,stabvertex,n) is a simple          *
+ *  version of the procedure named by options.userautomproc.                  *
+ *                                                                            *
+ *****************************************************************************/
+static void
+userautom3( int count, int *perm, int *orbits, int numorbits, int stabvertex, int n)
+{
+
+    int 	doviperm[3*MAXN], epairperm[MAXP];
+    int             vn1, vn2, vn3, vn4, vnb, i, etmp, e1, e2;
+
+    for (i = 0; i < *pCNT; i++)
+    {
+        vnb = perm[pdovi[i].base];
+        vn1 = perm[pdovi[i].first1];
+        vn2 = perm[pdovi[i].sec1];
+        vn3 = perm[pdovi[i].first2];
+        vn4 = perm[pdovi[i].sec2];
+
+        if( vn1 > vn2 )
+        {
+            etmp = vn1;
+            vn1 = vn2;
+            vn2 = etmp;
+        }
+        if( vn3 > vn4 )
+        {
+            etmp = vn3;
+            vn3 = vn4;
+            vn4 = etmp;
+        }
+        if( vn1 > vn3 )
+        {
+            etmp = vn1;
+            vn1 = vn3;
+            vn3 = etmp;
+
+            etmp = vn2;
+            vn2 = vn4;
+            vn4 = etmp;
+        }
+
+        doviperm[i] = pantidovi[vnb][vn2];  	
+
+    }					 		
+    orbjoin(pdoviorbit,doviperm,*pCNT);		
+
+    epairperm[0] = 0;
+    for (i = 1; i < *pnumpair; i++)
+    {
+        e1 = pepair[i].first;
+        e2 = pepair[i].sec;
+
+        vn1 = perm[pedge[e1].first];
+        vn2 = perm[pedge[e1].sec];
+        vn3 = perm[pedge[e2].first];
+        vn4 = perm[pedge[e2].sec];
+
+
+        if( vn1 > vn2 )
+        {
+            etmp = vn1;
+            vn1 = vn2;
+            vn2 = etmp;
+        }
+        if( vn3 > vn4 )
+        {
+            etmp = vn3;
+            vn3 = vn4;
+            vn4 = etmp;
+        }
+        if( vn1 > vn3 )
+        {
+            etmp = vn1;
+            vn1 = vn3;
+            vn3 = etmp;
+
+            etmp = vn2;
+            vn2 = vn4;
+            vn4 = etmp;
+        }
+
+        e1 = pantiedge[vn1][vn2];
+        e2 = pantiedge[vn3][vn4];
+        epairperm [i] = pantipair[e1][e2];
+    }
+    orbjoin(pepairorbit,epairperm,*pnumpair);   		
+}
+
+/*****************************************************************************
+ *                                                                            *
+ *  init_refinex(clr, lb, p, active, n) initializes some parameters           *
+ *  of the the procedure refinex                                              *
+ *                                                                            *
+ *****************************************************************************/
+
+static int
+init_refinex( int *clr, int *lb, int *p, set *active, int n)
+{
+    register int	i, j, ci, ncell;
+	
+	ncell = 1;
+	*active = bit[0];
+    for (i = 0; i < n; i++)
+	{
+        ci = clr[i];
+        for (j = i-1; (j >= 0)  &&    (clr[lb[j]] > ci) ; j--)
+            lb[j+1] = lb[j];
+        lb[j+1] = i;
+    }
+	lb[n] = n;
+    for (i = 0; i < n; i++)
+	{
+        if( clr[lb[i]] != clr[lb[i+1]] )
+		{
+			p[i] = 0;
+			ncell++;
+			*active |= bit[i+1];
+		}
+		else
+			p[i] = 1;
+
+    }
+	p[n] = 0;
+	return ncell;
+}
+
+/*****************************************************************************
+ *                                                                            *
+ *  refinex(g,lab,ptn,level,numcells,count,active,goodret,code,m,n) is a      *
+ *  custom version of refine() which can exit quickly if required.            *
+ *                                                                            *
+ *  Only use at level==0.                                                     *
+ *  goodret : whether to do an early return for code 1                        *
+ *  code := -1 for n-1 not max, 0 for maybe, 1 for definite                   *
+ *                                                                            *
+ *****************************************************************************/
+static void
+refinex(graph *g, int *lab, int *ptn, int level, int *numcells, int *count,
+           set *active, boolean goodret, int *code, int m, int n)
+{
+    int     i, c1, c2, labc1, split1, split2, cell1, cell2, cnt, bmin, bmax;
+    int     workperm[MAXN], bucket[MAXN+2];
+    setword x, lact, workset;
+    set     *gptr;
+
+    if (n == 1)
+    {
+        *code = 1;
+        return;
+    }
+
+    *code = 0;
+    lact = *active;
+
+    split1 = -1;
+    while (*numcells < n && lact)
+    {
+        TAKEBIT(split1,lact);
+
+        for (split2 = split1; ptn[split2] > 0; ++split2) {}
+        if (split1 == split2)       /* trivial splitting cell */
+        {
+            gptr = GRAPHROW(g,lab[split1],1);
+            for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+            {
+                for (cell2 = cell1; ptn[cell2] > 0; ++cell2) {}
+                if (cell1 == cell2) continue;
+
+                c1 = cell1;
+                c2 = cell2;
+                while (c1 <= c2)
+                {
+                    labc1 = lab[c1];
+                    if (ISELEMENT1(gptr,labc1))
+                        ++c1;
+                    else
+                    {
+                        lab[c1] = lab[c2];
+                        lab[c2] = labc1;
+                        --c2;
+                    }
+                }
+                if (c2 >= cell1 && c1 <= cell2)
+                {
+                    ptn[c2] = 0;
+                    ++*numcells;
+                    lact |= bit[c1];
+                }
+            }
+        }
+
+        else        /* nontrivial splitting cell */
+        {
+            workset = 0;
+            for (i = split1; i <= split2; ++i) workset |= bit[lab[i]];
+
+            for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+            {
+                for (cell2 = cell1; ptn[cell2] > 0; ++cell2) {}
+                if (cell1 == cell2) continue;
+                i = cell1;
+                if ((x = workset & g[lab[i]]) != 0) cnt = POPCOUNT(x);
+                else                                cnt = 0;
+                count[i] = bmin = bmax = cnt;
+                bucket[cnt] = 1;
+                while (++i <= cell2)
+                {
+                    if ((x = workset & g[lab[i]]) != 0)
+                        cnt = POPCOUNT(x);
+                    else
+                        cnt = 0;
+
+                    while (bmin > cnt) bucket[--bmin] = 0;
+                    while (bmax < cnt) bucket[++bmax] = 0;
+                    ++bucket[cnt];
+                    count[i] = cnt;
+                }
+                if (bmin == bmax) continue;
+                c1 = cell1;
+                for (i = bmin; i <= bmax; ++i)
+                    if (bucket[i])
+                    {
+                        c2 = c1 + bucket[i];
+                        bucket[i] = c1;
+                        if (c1 != cell1)
+                        {
+                            lact |= bit[c1];
+                            ++*numcells;
+                        }
+                        if (c2 <= cell2) ptn[c2-1] = 0;
+                        c1 = c2;
+                    }
+                for (i = cell1; i <= cell2; ++i)
+                    workperm[bucket[count[i]]++] = lab[i];
+                for (i = cell1; i <= cell2; ++i) lab[i] = workperm[i];
+            }
+        }
+
+        if (ptn[n-2] == 0)
+        {
+            if (lab[n-1] == n-1)
+            {
+                *code = 1;
+                if (goodret) return;
+            }
+            else
+            {
+                *code = -1;
+                return;
+            }
+        }
+        else
+        {
+            i = n - 1;
+            while (TRUE)
+            {
+                if (lab[i] == n-1) break;
+                --i;
+                if (ptn[i] == 0)
+                {
+                    *code = -1;
+                    return;
+                }
+            }
+        }
+    }
+}
+
+
+/*****************************************************************************/
+
+int main(int argc, char *argv[])
+{
+    //argc = #entered arguments by the user + 1;
+    int 	n, cntr, numpair, numedge, i, j, i1, i2, j1, j2, multm, e1, e2, argnum, sw; //char  sw??
+    int         multar[MAXN], col00w[MAXN], epairorbit[MAXP], lab[MAXN], ptn[MAXN], orbits[MAXN];
+    int 	antipair[MAXE][MAXE], antiedge[MAXN][MAXN];
+    setword 	x, y;
+    pairstruct 	epair[MAXP];
+    edgestruct  edge[MAXE];	
+    graph 	g[MAXN];
+    double      timebefore, timeafter;
+    setword     zar[MAXN];
+    boolean     badargs, gotf, gotmr, quiet;
+    char        *arg;
+    char        msg[201];
+
+    HELP; PUTVERSION;
+    nauty_check(WORDSIZE,1,MAXN,NAUTYVERSIONID);   ////?????
+
+    if( MAXN > WORDSIZE )
+    {
+        fprintf(stderr,"quarticgen: incompatible MAXN or WORDSIZE\n");
+        exit(1);
+    }
+
+    badargs = FALSE;
+    connec1 = connec2 = FALSE;
+    nooutput = FALSE;
+    canonise = FALSE;  //?????
+    graph6 = FALSE;
+    sparse6 = FALSE;
+    header = FALSE;
+    quiet = FALSE;
+
+    gotf = FALSE;
+    gotmr = FALSE;
+    outfilename = NULL;
+
+    argnum = 0;
+
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                SWBOOLEAN('u', nooutput)
+                else SWBOOLEAN('l', canonise)
+                    else SWBOOLEAN('c',connec1)
+                        else SWBOOLEAN('C',connec2)
+                            else SWBOOLEAN('g', graph6)
+                                else SWBOOLEAN('s', sparse6)
+                                    else SWBOOLEAN('h', header)
+                                        else SWBOOLEAN('q', quiet)
+#ifdef PLUGIN_SWITCHES
+                                PLUGIN_SWITCHES
+#endif
+                                else badargs = TRUE;
+            }
+        }
+        else if (arg[0] == '-' && arg[1] == '\0')
+            gotf = TRUE;
+        else
+        {
+            if (argnum == 0)
+            {
+                if (sscanf(arg,"%d",&nmax) != 1)
+                    badargs = TRUE;
+                ++argnum;
+            }
+            else if (gotf)
+                badargs = TRUE;
+            else
+            {
+                if (!gotmr)
+                {
+                    if (sscanf(arg,"%d/%d",&res,&mod) == 2)
+                    {
+                        gotmr = TRUE;
+                        continue;
+                    }
+                }
+                if (!gotf)
+                {
+                    outfilename = arg;
+                    gotf = TRUE;
+                    continue;
+                }
+            }
+        }
+    }
+
+
+
+    if( !badargs  &&  gotmr  &&  (res < 0 || res >= mod) )
+    {
+        fprintf(stderr,
+                "E quarticgen: must have 0 <= res < mod\n");
+        badargs = TRUE;
+    }
+
+    if      (connec2) connec = 2;
+    else if (connec1) connec = 1;
+    else              connec = 0;
+
+    if (!argnum )
+        badargs = TRUE;
+    else if (nmax < 1 || nmax > MAXN )
+    {
+        fprintf(stderr,
+                ">E quarticgen: must have n =1..%d \n",MAXN);
+        badargs = TRUE;
+    }
+
+    if (!gotmr)
+    {
+        mod = 1;
+        res = 0;
+    }
+   /* else if (argnum == 5 || argnum > 6)
+        badargs = TRUE;*/ // argnum will never exceeds 1 here andeven in genbg it never exceeds 2!
+
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if ( (graph6!=0) + (sparse6!=0) + (nooutput!=0) > 1)
+        gt_abort(">E quarticgen: -ugs are incompatible\n");
+
+    if ( nooutput && header)
+        gt_abort(">E quarticgen: -u -h are incompatible\n");
+
+
+#ifdef OUTPROC
+    outproc = OUTPROC;
+#else
+    if (nooutput) outproc = nullwrite;
+    else if (sparse6)  outproc = writes6x;
+    else               outproc = writeg6x;
+#endif
+
+
+#ifdef PLUGIN_INIT
+    PLUGIN_INIT
+#endif
+
+    if (nooutput)
+        outfile = stdout;
+    else if (!gotf || outfilename == NULL)
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename, "w")) == NULL)
+    {
+        fprintf(stderr,
+                ">E quarticgen: can't open %s for writing\n",outfilename);
+        gt_abort(NULL);
+    }
+
+    if (!quiet)
+    {
+        msg[0] = '\0';
+        if (strlen(argv[0]) > 75) fprintf(stderr,">A %s",argv[0]);
+        else CATMSG1(">A %s",argv[0]);
+
+        CATMSG1(" n = %d", nmax);
+   // if (connec) CATMSG0(connec2 ? "C" : connec1 ? "c" : "",);
+        if (connec2) CATMSG0(" C"); else if (connec1) CATMSG0(" c");
+        if (mod > 1) CATMSG2(" class= %d/%d", res, mod);
+        CATMSG0("\n");
+        fputs(msg,stderr);
+        fflush(stderr);
+    }
+
+    if (header)
+    {
+	if (SPARSE6)
+            writeline(outfile,SPARSE6_HEADER);        // No enter after the header is ok?
+	else
+            writeline(outfile,GRAPH6_HEADER);
+        fflush(outfile);
+    }
+
+ //   if (mod > 1 && nmax > 10)
+    if( mod > 1 )
+    {
+        if( nmax <= threshold )
+            splitlevel = nmax - LEV1;
+        else
+            splitlevel = LEV2;
+        splitcount = res;
+    }
+    else
+    {
+        splitlevel = -1;
+        mod = 1;
+        res = 0;  // narjess for the sake of n>splitlevel (below)
+    }
+
+    timebefore = CPUTIME;
+    m = 1;
+
+    cntr = numread = numwritten = 0;
+    for(cntr = 0; cntr < NUMIRRED; cntr++)
+    {
+        n = graphsize(irred[cntr]);
+        //////////////////////////////////////////////////////////////////
+        if( n == splitlevel  )
+        {
+            if (splitcount-- != 0) continue;
+            if( n == nmax )
+                splitcount = mod-1;
+            else
+                splitcount = 0;
+        }
+        if( n > splitlevel )
+        {
+            if ( gotmr && res ) continue;
+        }
+        /////////////////////////////////////////////////////////////////////////
+
+
+        if( n < nmax )
+        {
+            numread++;
+            stringtograph(irred[cntr],g,m);
+            epairorbit[0] = 0;
+            numpair = 1;
+            numedge = 0;
+            for (i = 0; i < n; i++)
+            {
+                multar[i] = 10;
+
+                x = g[i] & BITMASK(i);
+                while (x)
+                {
+                    TAKEBIT(j,x);
+                    edge[numedge].first = i;
+                    edge[numedge].sec = j;
+                    antiedge[i][j] = numedge;
+                    numedge++;
+
+                }
+            }
+            for (e1 = 0; e1 < numedge; e1++)
+            {
+                i1 = edge[e1].first;
+                j1 = edge[e1].sec;
+                for (e2 = e1+1; e2 < numedge; e2++)
+                {
+                    i2 = edge[e2].first;
+                    j2 = edge[e2].sec;
+                    if( i1 != i2   &&   j1 != i2   &&  j1 != j2   )
+                    {
+                        epair[numpair].first = e1;
+                        epair[numpair].sec = e2;
+
+                        multm = 1;
+
+                        if(   (!(g[i1] & bit[i2]))  &&   (!(g[j1] & bit[j2]))  )
+                            multm++;
+
+                        if(   (!(g[i1] & bit[j2]))  &&   (!(g[j1] & bit[i2]))  )
+                            multm++;
+                        epair[numpair].multp = multm;
+
+                        epairorbit[numpair] = numpair;
+                        antipair[e1][e2] = numpair;
+                        numpair++;
+                    }
+                }
+            }
+            pepair = epair;
+            pedge = edge;
+            pantipair = antipair;
+            pantiedge = antiedge;
+            pnumpair = &numpair;
+            pepairorbit = epairorbit;
+
+            options.userautomproc = userautom1;
+            options.writeautoms = FALSE;
+            options.writemarkers = FALSE;
+            options.getcanon = FALSE;
+            options.defaultptn = TRUE;
+
+            nauty(g, lab, ptn, NILSET, orbits, &options, &stats, workspace, 50, m, n, NILGRAPH);
+            extend(n, g, edge, epair, numpair, epairorbit, multar, zar, col00w, isconnected(g, n));
+        }
+        if( n == nmax )
+        {
+            numread++;
+            stringtograph(irred[cntr],g,m);
+
+            if( connec2 && !isbiconnected(g, n) )
+                continue;
+            if( connec1 && !isconnected(g, n) )
+                continue;
+            (*outproc)( outfile, g, n);
+            numwritten++;
+        }
+    }
+    timeafter=CPUTIME;
+
+    if (!quiet)
+    {
+	if (nooutput)
+	    fprintf(stderr,">Z " COUNTER_FMT " graphs generated in %3.2f seconds\n",
+		numwritten,timeafter-timebefore);
+	else
+	    fprintf(stderr,">Z " COUNTER_FMT " graphs written to %s in %3.2f seconds\n",
+		numwritten,outfilename,timeafter-timebefore);
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/genrang.c b/lib/nauty/genrang.c
new file mode 100644
index 0000000..33c65a8
--- /dev/null
+++ b/lib/nauty/genrang.c
@@ -0,0 +1,1215 @@
+/* genrang.c  version 2.1; B D McKay, Feb 15, 2016 */
+/* TODO:  Check allocs for no edges */
+
+#define USAGE \
+"genrang [-P#|-P#/#|-e#|-r#|-R#|-d#] [-l#] [-m#] [-t] [-T] [-a] \n" \
+"         [-s|-g|-z] [-S#] [-q] n|n1,n2 num [outfile]"
+
+#define HELPTEXT \
+" Generate random graphs.\n\
+     n  : number of vertices\n\
+     n1,n2 : number of vertices (bipartite graph)\n\
+    num : number of graphs\n\
+\n\
+    A bipartite variant is only available if specified below.\n\
+\n\
+    -s  : Write in sparse6 format (default)\n\
+    -g  : Write in graph6 format\n\
+    -z  : Make random digraphs and write in digraph6 format\n\
+    -P#/# : Give edge probability; -P# means -P1/#.\n\
+          Bipartite version available.\n\
+    -e# : Give the number of edges\n\
+          Bipartite version available.\n\
+    -r# : Make regular of specified degree\n\
+    -d# : Make regular of specified degree (pseudorandom)\n\
+          Bipartite version: this is the degree on the first side\n\
+    -R# : Make regular of specified degree but output\n\
+          as vertex count, edge count, then list of edges\n\
+    -l# : Maximum loop multiplicity (default 0)\n\
+    -m# : Maximum multiplicity of non-loop edge (default and minimum 1)\n\
+    -t  : Make a random tree\n\
+    -T  : Make a random tournament (implies -z)\n\
+    -a  : Make invariant under a random permutation\n\
+    -S# : Specify random generator seed (default nondeterministic)\n\
+    -q  : suppress auxiliary output\n"
+
+#define MAXLREG 88   /* Max value for -r or -R switch (multigraphs) */
+/* This is also the limit for -r if MAXN > 0. */
+/* The limit for simple graphs is in naututil-h.in */
+
+/*************************************************************************
+
+   Oct 27, 2004 : corrected handling of -P values
+**************************************************************************/
+
+#include "gtools.h"
+
+static long seed;
+
+/*************************************************************************/
+
+static void
+perminvar(graph *g, int *perm, int m, int n)
+/* Add to g the least number of edges needed to make perm
+   an automorphism. */
+{
+    int i,j,ii,jj;
+    set *gi,*gpi;
+
+    for (i = 0, gi = (set*)g; i < n; ++i, gi += m)
+    {
+        gpi = g + m * 1L * perm[i];
+        for (j = -1; (j = nextelement(gi,m,j)) >= 0; )
+            if (!ISELEMENT(gpi,perm[j]))
+            {
+                ii = perm[i];
+                jj = perm[j];
+                while (ii != i || jj != j)
+                {
+                    ADDELEMENT(g+m*1L*ii,jj);
+                    ii = perm[ii];
+                    jj = perm[jj];
+                }
+            }
+    }
+}
+
+/**************************************************************************/
+
+static void
+gcomplement(graph *g, boolean loopstoo, int m, int n)
+/* Replace g by its complement */
+{
+    int i,j;
+    graph *gp;
+#if MAXN
+    set mask[MAXM];
+#else
+    DYNALLSTAT(set,mask,mask_sz);
+    DYNALLOC1(set,mask,mask_sz,m,"complement");
+#endif
+
+    EMPTYSET(mask,m);
+    for (i = 0; i < n; ++i) ADDELEMENT(mask,i);
+
+    if (loopstoo)
+    {
+        for (i = 0, gp = g; i < n; ++i, gp += m)
+        {
+            for (j = 0; j < m; ++j) gp[j] ^= mask[j];
+        }
+    }
+    else
+    {
+        for (i = 0, gp = g; i < n; ++i, gp += m)
+        {
+	    DELELEMENT(mask,i);
+            for (j = 0; j < m; ++j) gp[j] ^= mask[j];
+	    ADDELEMENT(mask,i);
+        }
+    }
+}
+
+/**************************************************************************/
+
+static void
+gcomplement_bip(graph *g, int m, int n1, int n2)
+/* Replace g by its bipartite complement */
+{
+    int i,j,n;
+    graph *gp;
+#if MAXN
+    set mask[MAXM];
+#else
+    DYNALLSTAT(set,mask,mask_sz);
+    DYNALLOC1(set,mask,mask_sz,m,"complement");
+#endif
+
+    n = n1 + n2;
+
+    EMPTYSET(mask,m);
+    for (i = n1; i < n; ++i) ADDELEMENT(mask,i);
+
+    for (i = 0, gp = g; i < n1; ++i, gp += m)
+        for (j = 0; j < m; ++j) gp[j] ^= mask[j];
+
+    EMPTYSET(mask,m);
+    for (i = 0; i < n1; ++i) ADDELEMENT(mask,i);
+
+    for (i = n1, gp = GRAPHROW(g,n1,m); i < n; ++i, gp += m)
+        for (j = 0; j < m; ++j) gp[j] ^= mask[j];
+}
+
+/**************************************************************************/
+
+static void
+ranedges(long e, boolean loopsok, graph *g, int m, int n)
+/* Random graph with n vertices and e edges */
+{
+    unsigned long ln,li,nc2,ned,sofar;
+    set *gi,*gj;
+    int i,j;
+
+    ln = n;
+    nc2 = (ln&1) ? ln*((ln-1)/2) : (ln/2)*(ln-1);
+    if (loopsok) nc2 += ln;
+
+    if (e + e > nc2) ned = nc2 - e;
+    else             ned = e;
+    sofar = 0;
+
+    for (li = m*ln; --li != 0;) g[li] = 0; g[0] = 0;
+
+    while (sofar < ned)
+    {
+        i = KRAN(n);
+        if (loopsok) j = KRAN(n);
+        else do { j = KRAN(n); } while (i == j);
+        gi = GRAPHROW(g,i,m);
+        if (!ISELEMENT(gi,j))
+        {
+            ADDELEMENT(gi,j);
+            gj = GRAPHROW(g,j,m);
+            ADDELEMENT(gj,i);
+            ++sofar;
+        }
+    }
+
+    if (ned != e) gcomplement(g,loopsok,m,n);
+}
+
+/**************************************************************************/
+
+static void
+ranedges_bip(long e, graph *g, int m, int n1, int n2)
+/* Random bipartite graph with n1+n2 vertices and e edges */
+{
+    size_t ln,li,nc2,ned,sofar;
+    set *gi,*gj;
+    int i,j,n;
+
+    n = n1 + n2;
+    nc2 = (size_t)n1*n2;
+
+    if (e + e > nc2) ned = nc2 - e;
+    else             ned = e;
+    sofar = 0;
+
+    for (li = m*(size_t)n; --li != 0;) g[li] = 0; g[0] = 0;
+
+    while (sofar < ned)
+    {
+        i = KRAN(n1);
+        j = n1 + KRAN(n2);
+        gi = GRAPHROW(g,i,m);
+        if (!ISELEMENT(gi,j))
+        {
+            ADDELEMENT(gi,j);
+            gj = GRAPHROW(g,j,m);
+            ADDELEMENT(gj,i);
+            ++sofar;
+        }
+    }
+
+    if (ned != e) gcomplement_bip(g,m,n1,n2);
+}
+
+/**************************************************************************/
+
+static void
+grandtourn(graph *g, int m, int n)
+/* Random tournament */
+{
+    int i,j;
+    long li;
+    set *row,*col;
+
+    for (li = (long)m * (long)n; --li >= 0;) g[li] = 0;
+
+    for (i = 0, row = g; i < n; ++i, row += m)
+    {
+        for (j = i+1, col = GRAPHROW(g,i+1,m); j < n; ++j, col += m)
+            if (KRAN(2) < 1) ADDELEMENT(row,j);
+	    else             ADDELEMENT(col,i);
+    }
+}
+
+/**************************************************************************/
+
+static void
+grandtourn_bip(graph *g, int m, int n1, int n2)
+/* Random bipartite tournament */
+{
+    int i,j,n;
+    long li;
+    set *row,*col;
+
+    n = n1 + n2;
+    for (li = (long)m * (long)n; --li >= 0;) g[li] = 0;
+
+    for (i = 0, row = g; i < n1; ++i, row += m)
+    {
+        for (j = n1, col = GRAPHROW(g,n1,m); j < n; ++j, col += m)
+            if (KRAN(2) < 1) ADDELEMENT(row,j);
+	    else             ADDELEMENT(col,i);
+    }
+}
+
+/**************************************************************************/
+
+static void
+grandgraph(graph *g, boolean digraph, boolean loopsok,
+                                         int p1, int p2, int m, int n)
+/* Random graph with probability p1/p2 */
+{
+    int i,j;
+    long li;
+    set *row,*col;
+
+    for (li = (long)m * (long)n; --li >= 0;) g[li] = 0;
+
+    for (i = 0, row = g; i < n; ++i, row += m)
+        if (digraph)
+        {
+            for (j = 0; j < n; ++j)
+                if (KRAN(p2) < p1) ADDELEMENT(row,j);
+	    if (!loopsok) DELELEMENT(row,i);
+        }
+        else
+        {
+            for (j = i + (!loopsok), col = GRAPHROW(g,j,m);
+                                            j < n; ++j, col += m)
+                if (KRAN(p2) < p1)
+                {
+                    ADDELEMENT(row,j);
+                    ADDELEMENT(col,i);
+                }
+        }
+}
+
+/**************************************************************************/
+
+static void
+grandgraph_bip(graph *g, boolean digraph,
+                         int p1, int p2, int m, int n1, int n2)
+/* Random bipartite graph with probability p1/p2 */
+{
+    int i,j,n;
+    long li;
+    set *row,*col;
+
+    n = n1 + n2;
+
+    for (li = (long)m * (long)n; --li >= 0;) g[li] = 0;
+
+    for (i = 0, row = g; i < n1; ++i, row += m)
+        if (digraph)
+        {
+            for (j = n1; j < n; ++j)
+                if (KRAN(p2) < p1) ADDELEMENT(row,j);
+        }
+        else
+        {
+            for (j = n1, col = GRAPHROW(g,j,m);
+                                            j < n; ++j, col += m)
+                if (KRAN(p2) < p1)
+                {
+                    ADDELEMENT(row,j);
+                    ADDELEMENT(col,i);
+                }
+        }
+}
+
+/**************************************************************************/
+
+static void
+ranarcs(long e, boolean loopsok, graph *g, int m, int n)
+/* Random digraph graph with n vertices and e edges */
+{
+    unsigned long ln,li,nn,ned,sofar;
+    set *gi;
+    int i,j;
+
+    ln = n;
+    nn = (loopsok ? n*n : n*(n-1));
+
+    if (e + e > nn) ned = nn - e;
+    else            ned = e;
+    sofar = 0;
+
+    for (li = m*ln; --li != 0;) g[li] = 0;
+    g[0] = 0;
+
+    while (sofar < ned)
+    {
+        i = KRAN(n);
+	if (loopsok) j = KRAN(n);
+        else do { j = KRAN(n); } while (i == j);
+        gi = GRAPHROW(g,i,m);
+        if (!ISELEMENT(gi,j))
+        {
+            ADDELEMENT(gi,j);
+            ++sofar;
+        }
+    }
+
+    if (ned != e) gcomplement(g,loopsok,m,n);
+}
+
+/**************************************************************************/
+
+static void
+makeranreg(int *cub, int degree, int multmax, int loopmax, int n)
+/* Make a random regular graph in cub[].  Each consecutive degree
+   entries of cub[] is set to the neighbours of one vertex.
+   The length of cub had better be at least degree*n  */
+{
+    long i,j,k,v,w,nn,mult;
+    boolean ok;
+#if MAXN
+    int deg[MAXN],p[MAXLREG*MAXN];
+#else
+    DYNALLSTAT(int,deg,deg_sz);
+    DYNALLSTAT(int,p,p_sz);
+    DYNALLSTAT(int,loops,loops_sz);
+
+    DYNALLOC1(int,deg,deg_sz,n,"genrang");
+    DYNALLOC2(int,p,p_sz,degree,n,"genrang");
+    DYNALLOC1(int,loops,loops_sz,n,"genrang");
+#endif
+
+    nn = n;
+
+    for (i = j = 0; i < nn; ++i)
+        for (k = 0; k < degree; ++k)
+           p[j++] = i;
+
+    do
+    {
+        ok = TRUE;
+
+        for (j = degree*nn-1; j >= 1; j -= 2)
+        {
+            i = KRAN(j);
+            k = p[j-1];
+            p[j-1] = p[i];
+            p[i] = k;
+        }
+        for (i = 0; i < nn; ++i) deg[i] = loops[i] = 0;
+
+        for (j = degree*nn-1; j >= 1;)
+        {
+            v = p[j--];
+            w = p[j--];
+            if (v == w && ++loops[v] > loopmax)
+            {
+                ok = FALSE;
+                break;
+            }
+            if (v != w && multmax < degree)
+            {
+                mult = 0;
+                for (i = deg[w]; --i >= 0;)
+                    if (cub[degree*w+i] == v && ++mult >= multmax) break;
+                if (i >= 0)
+                {
+                    ok = FALSE;
+                    break;
+                }
+            }
+            cub[degree*w+deg[w]++] = v;
+            cub[degree*v+deg[v]++] = w;
+        }
+    }
+    while (!ok);
+}
+
+/**************************************************************************/
+
+static void
+rundmodel(int *cub, int degree, int n)
+/* Make a random-ish regular graph in cub[] using the d-model.
+   Each consecutive degree entries of cub[] is set to the neighbours
+   of one vertex.  The length of cub had better be at least degree*n  */
+{
+    long iters,fails;
+    size_t i,j,navail;
+    int *cubi,*cubj,vi,vj,k;
+    boolean ok;
+#if MAXN
+    int deg[MAXN],avail[MAXN*MAXLREG];
+#else
+    DYNALLSTAT(int,deg,deg_sz);
+    DYNALLSTAT(int,avail,avail_sz);
+
+    DYNALLOC1(int,deg,deg_sz,n,"genrang");
+    DYNALLOC2(int,avail,avail_sz,n,degree,"genrang");
+#endif
+
+    iters = 0;
+    do
+    {
+	ok = TRUE;
+	++iters;
+
+	k = 0;
+        for (i = 0; i < n; ++i)
+        {
+	    deg[i] = 0;
+	    for (j = 0; j < degree; ++j) avail[k++] = i;
+        }
+        navail = n*degree;
+
+	while (navail >= 2 && ok)
+	{
+	    for (fails = 100 + navail; --fails >= 0;)
+	    {
+		i = KRAN(navail);
+		do { j = KRAN(navail); } while (j == i);
+		vi = avail[i];
+		vj = avail[j];
+                if (vi == vj) continue;
+		cubi = cub + vi*degree;
+		cubj = cub + vj*degree;
+		for (k = deg[vi]; --k >= 0; ) if (cubi[k] == vj) break;
+		if (k < 0) break;
+	    }
+
+	    if (fails >= 0)
+	    {
+		cubi[deg[vi]++] = vj;
+		cubj[deg[vj]++] = vi;
+
+		avail[i] = avail[navail-1];
+		--navail;
+		if (avail[i] == vj) j = i;
+
+		avail[j] = avail[navail-1];
+		--navail;
+	    }
+	    else
+		ok = FALSE;
+	}
+	if (navail > 0) ok = FALSE;
+    } while (!ok);
+
+    /* fprintf(stderr,">C %ld iters\n",iters); */
+}
+
+/**************************************************************************/
+
+static void
+ranregR(FILE *f, int degree, int multmax, int loopmax, int n)
+/* Make a random regular graph of order n and degree d and write
+   it in f, as number of vertices, number of edges, list of edges */
+{
+    long i,j,k,l;
+    int loops;
+#if MAXN
+    int cub[MAXLREG*MAXN];
+#else
+    DYNALLSTAT(int,cub,cub_sz);
+    DYNALLOC2(int,cub,cub_sz,degree,n,"genrang");
+#endif
+
+    makeranreg(cub,degree,multmax,loopmax,n);
+
+    fprintf(f,"%d %ld\n",n,n*(long)degree/2);
+    l = j = 0;
+    for (i = 0; i < n; ++i)
+    {
+        loops = 0;
+        for (k = 0; k < degree; ++k, ++j)
+            if (i < cub[j] || (i == cub[j] && (++loops & 1) == 0))
+            {
+                if (l > 0 && l % 5 == 0) fprintf(f,"\n");
+                fprintf(f," %ld %d",i,cub[j]);
+                ++l;
+            }
+    }
+    fprintf(f,"\n");
+    if (ferror(f)) gt_abort(">E genrang output error\n");
+}
+ 
+/**************************************************************************/
+
+static void
+ranreg(int degree, graph *g, int m, int n)
+/* Make a random simple regular graph of order n and degree d and return
+   it in g. */
+{
+    int i,j,k;
+    set *gi;
+#if MAXN
+    int cub[MAXLREG*MAXN];
+#else
+    DYNALLSTAT(int,cub,cub_sz);
+    DYNALLOC1(int,cub,cub_sz,degree*n,"genrang");
+#endif
+
+    makeranreg(cub,degree,1,0,n);
+
+    j = 0;
+    for (i = 0, gi = (set*)g; i < n; ++i, gi += m)
+    {
+        EMPTYSET(gi,m);
+        for (k = 0; k < degree; ++k)
+        {
+            ADDELEMENT(gi,cub[j]);
+            j++;
+        }
+    }
+}
+
+/**************************************************************************/
+
+static void
+ranreglm_sg(int degree, sparsegraph *sg, int multmax, int loopmax, int n)
+/* Make a sparse random regular graph of order n and degree d
+ * and return it in sg. */
+{
+    int i,j,k,deg,loops;
+    long nde,k0;
+#if MAXN
+    int cub[MAXLREG*MAXN];
+#else
+    DYNALLSTAT(int,cub,cub_sz);
+    DYNALLOC1(int,cub,cub_sz,degree*n,"genrang");
+#endif
+
+    makeranreg(cub,degree,multmax,loopmax,n);
+
+    SG_ALLOC(*sg,n,degree*n,"genrang");
+
+    sg->nv = n;
+    j = nde = 0;
+    for (i = 0; i < n; ++i)
+    {
+        sg->v[i] = k0 = i*degree;
+        loops = deg = 0;
+        for (k = 0; k < degree; ++k, ++j)
+        {
+            if (cub[j] == i)
+            {
+                /* Loops are in cub twice but sg once */
+                ++loops;
+                if ((loops&1)) sg->e[k0+deg++] = i;
+            }
+            else
+                sg->e[k0+deg++] = cub[j];
+        }
+        sg->d[i] = deg;
+        nde += deg;
+    }
+    sg->nde = nde;
+}
+
+/**************************************************************************/
+
+static void
+dmodel_sg(int degree, sparsegraph *sg, int n)
+/* Make a sparse random-ish regular graph of order n and degree d
+ * and return it in sg. */
+{
+    int i,j,k,deg,comdeg;
+    long k0,nde;
+#if MAXN
+    int cub[MAXLREG*MAXN];
+    boolean adj[MAXN];
+#else
+    DYNALLSTAT(int,cub,cub_sz);
+    DYNALLSTAT(boolean,adj,adj_sz);
+#endif
+
+    SG_ALLOC(*sg,n,degree*n,"dmodel_sg");
+
+    if (degree <= n-degree-1)
+    {
+#if !MAXN
+        DYNALLOC1(int,cub,cub_sz,degree*n,"dmodel_sg");
+#endif
+        rundmodel(cub,degree,n);
+
+        sg->nv = n;
+        j = nde = 0;
+        for (i = 0; i < n; ++i)
+        {
+            sg->v[i] = k0 = i*(long)degree;
+            deg = 0;
+            for (k = 0; k < degree; ++k, ++j)
+                sg->e[k0+deg++] = cub[j];
+            sg->d[i] = deg;
+            nde += deg;
+        }
+        sg->nde = nde;
+    }
+    else
+    {
+	comdeg = n - degree - 1;
+#if !MAXN
+        DYNALLOC1(int,cub,cub_sz,comdeg*n,"dmodel_sg");
+        DYNALLOC1(boolean,adj,adj_sz,n,"dmodel_sg");
+#endif
+        rundmodel(cub,comdeg,n);
+
+        sg->nv = n;
+        j = nde = 0;
+        for (i = 0; i < n; ++i)
+        {
+            sg->v[i] = k0 = i*(long)degree;
+            deg = 0;
+	    for (k = 0; k < n; ++k) adj[k] = TRUE;
+	    adj[i] = FALSE;
+	    for (k = 0; k < comdeg; ++k, ++j) adj[cub[j]] = FALSE;
+            for (k = 0; k < n; ++k)
+		if (adj[k]) sg->e[k0+deg++] = k;
+            sg->d[i] = deg;
+            nde += deg;
+        }
+        sg->nde = nde;
+    }
+}
+
+/**************************************************************************/
+
+static void
+rundmodel_bip(int *cub, int deg1, int deg2, int n1, int n2)
+/* Make a random-ish semiregular bipartite graph in cub[] using the d-model.
+   Each consecutive deg1/deg2 entries of cub[] is set to the neighbours
+   of one vertex.  The length of cub had better be deg1*n1  */
+{
+    long iters,fails;
+    size_t i,j,k,navail,ne;
+    int *cubi,*cubj,vi,vj,n;
+    boolean ok;
+#if MAXN
+    int deg[MAXN],avail[MAXN*MAXLREG];
+#else
+    DYNALLSTAT(int,deg,deg_sz);
+    DYNALLSTAT(int,avail,avail_sz);
+
+    n = n1 + n2;
+    DYNALLOC1(int,deg,deg_sz,n,"genrang");
+    DYNALLOC2(int,avail,avail_sz,n,2*deg1,"genrang");
+#endif
+
+    ne = n1*(size_t)deg1;
+
+    iters = 0;
+    do
+    {
+	ok = TRUE;
+	++iters;
+
+	k = 0;
+        for (i = 0; i < n1; ++i)
+        {
+	    deg[i] = 0;
+	    for (j = 0; j < deg1; ++j) avail[k++] = i;
+        }
+        for (i = n1; i < n; ++i)
+        {
+	    deg[i] = 0;
+	    for (j = 0; j < deg2; ++j) avail[k++] = i;
+        }
+        navail = ne;
+
+	while (navail >= 1 && ok)
+	{
+	    for (fails = 100 + navail; --fails >= 0;)
+	    {
+		i = KRAN(navail);
+		j = ne + KRAN(navail);
+		vi = avail[i];
+		vj = avail[j];
+		cubi = cub + vi*deg1;
+		cubj = cub + ne + (vj-n1)*deg2;
+		for (k = 0; k < deg[vi]; ++k) if (cubi[k] == vj) break;
+		if (k == deg[vi]) break;
+	    }
+
+	    if (fails >= 0)
+	    {
+		cubi[deg[vi]++] = vj;
+		cubj[deg[vj]++] = vi;
+
+		avail[i] = avail[navail-1];
+		avail[j] = avail[ne+navail-1];
+		--navail;
+	    }
+	    else
+		ok = FALSE;
+	}
+	if (navail > 0) ok = FALSE;
+    } while (!ok);
+
+    /* fprintf(stderr,">C %ld iters\n",iters); */
+}
+
+/**************************************************************************/
+
+static void
+dmodel_bip_sg(int deg1, sparsegraph *sg, int n1, int n2)
+/* Make a sparse random-ish semiregular bipartite graph of order n1+n2
+   and degree deg1 on the left and return it in sg. */
+{
+    int i,k,deg,comdeg1,comdeg2,n,deg2;
+    size_t j,k0,nde,ne,comne;
+#if MAXN
+    int cub[MAXLREG*MAXN];
+    boolean adj[MAXN];
+#else
+    DYNALLSTAT(int,cub,cub_sz);
+    DYNALLSTAT(boolean,adj,adj_sz);
+#endif
+
+    n = n1 + n2;
+    ne = n1*(size_t)deg1;
+    deg2 = ne / n2;
+    if (deg2*(size_t)n2 != ne || deg1 > n2 || deg2 > n1)
+	gt_abort(">E genrang: impossible bipartite degrees\n");
+
+    SG_ALLOC(*sg,n,2*ne,"dmodel_bip_sg");
+
+    if (deg1 <= n2-deg1)
+    {
+#if !MAXN
+        DYNALLOC1(int,cub,cub_sz,2*ne,"dmodel_bip_sg");
+#endif
+        rundmodel_bip(cub,deg1,deg2,n1,n2);
+
+        sg->nv = n;
+        j = nde = 0;
+        for (i = 0; i < n1; ++i)
+        {
+            sg->v[i] = k0 = i*(size_t)deg1;
+            deg = 0;
+            for (k = 0; k < deg1; ++k, ++j)
+                sg->e[k0+deg++] = cub[j];
+            sg->d[i] = deg;
+            nde += deg;
+        }
+        for (i = n1; i < n; ++i)
+        {
+            sg->v[i] = k0 = ne + (i-n1)*(size_t)deg2;
+            deg = 0;
+            for (k = 0; k < deg2; ++k, ++j)
+                sg->e[k0+deg++] = cub[j];
+            sg->d[i] = deg;
+            nde += deg;
+        }
+        sg->nde = nde;
+    }
+    else
+    {
+	comdeg1 = n2 - deg1;
+	comdeg2 = n1 - deg2;
+	comne = n1*(size_t)comdeg1;
+#if !MAXN
+        DYNALLOC1(int,cub,cub_sz,2*comne,"dmodel_bip_sg");
+        DYNALLOC1(boolean,adj,adj_sz,n,"dmodel_bip_sg");
+#endif
+        rundmodel_bip(cub,comdeg1,comdeg2,n1,n2);
+
+        sg->nv = n;
+        j = nde = 0;
+        for (i = 0; i < n1; ++i)
+        {
+            sg->v[i] = k0 = i*(long)deg1;
+            deg = 0;
+	    for (k = n1; k < n; ++k) adj[k] = TRUE;
+	    for (k = 0; k < comdeg1; ++k, ++j) adj[cub[j]] = FALSE;
+            for (k = n1; k < n; ++k)
+		if (adj[k]) sg->e[k0+deg++] = k;
+            sg->d[i] = deg;
+            nde += deg;
+        }
+        for (i = n1; i < n; ++i)
+        {
+            sg->v[i] = k0 = ne + (i-n1)*(long)deg2;
+            deg = 0;
+	    for (k = 0; k < n1; ++k) adj[k] = TRUE;
+	    for (k = 0; k < comdeg2; ++k, ++j) adj[cub[j]] = FALSE;
+            for (k = 0; k < n1; ++k)
+		if (adj[k]) sg->e[k0+deg++] = k;
+            sg->d[i] = deg;
+            nde += deg;
+        }
+        sg->nde = nde;
+    }
+}
+
+/**************************************************************************/
+
+static void
+randomtree(sparsegraph *sg, int n)
+/* Make a random tree with n vertices */
+{
+    int i,v0,v1,ne,k;
+#if MAXN
+    int ed[2*MAXN];
+#else
+    DYNALLSTAT(int,ed,ed_sz);
+    DYNALLOC1(int,ed,ed_sz,2*n,"randomtree");
+#endif
+
+    SG_ALLOC(*sg,n,2*(n-1),"randomtree");
+    sg->nv = n;
+    sg->nde = 2*(n-1);
+    sg->w = NULL;
+
+    for (i = 0; i < n; ++i) sg->d[i] = 0;
+
+    v0 = KRAN(n);
+    ne = k = 0;
+    while (ne < n-1)
+    {
+	do { v1 = KRAN(n); } while (v1 == v0);
+	if (sg->d[v1] == 0)
+	{
+	    ed[k++] = v0;
+	    ed[k++] = v1;
+	    ++ne;
+	    ++sg->d[v0];
+	    ++sg->d[v1];
+	}
+	v0 = v1;
+    }
+
+    sg->v[0] = 0;
+    for (i = 1; i < n; ++i) sg->v[i] = sg->v[i-1] + sg->d[i-1];
+
+    for (i = 0; i < n; ++i) sg->d[i] = 0;
+
+    for (k = 0; k < 2*(n-1); )
+    {
+        v0 = ed[k++];
+        v1 = ed[k++];
+	sg->e[sg->v[v0]+(sg->d[v0])++] = v1;
+	sg->e[sg->v[v1]+(sg->d[v1])++] = v0;
+    }
+}
+
+/**************************************************************************/
+/**************************************************************************/
+
+#define NOBIP if (bipartite) { fprintf(stderr, \
+ ">E genrang: This option is not available for bipartite graphs." \
+ " Feel free to request it.\n"); exit(1); }
+
+int
+main(int argc, char *argv[])
+{
+    int m,n,n1,n2,codetype;
+    int argnum,j;
+    char *arg,sw;
+    boolean badargs;
+    boolean gswitch,sswitch,qswitch,Sswitch,Rswitch,lswitch,tswitch;
+    boolean aswitch,P1switch,P2switch,eswitch,rswitch,mswitch,dswitch;
+    boolean Tswitch;
+    long numgraphs,nout,P1value,P2value,evalue,rvalue;
+    nauty_counter ln,nc2;
+    int Svalue,loopmax,multmax;
+    static FILE *outfile;
+    char *outfilename;
+    sparsegraph sg;
+    boolean usesparse,digraph,bipartite;
+
+#if MAXN
+    graph g[MAXM*1L*MAXN];
+    int perm[MAXN];
+#else
+    DYNALLSTAT(graph,g,g_sz);
+    DYNALLSTAT(int,perm,perm_sz);
+#endif
+
+    HELP; PUTVERSION;
+
+    gswitch = sswitch = qswitch = Sswitch = Rswitch = FALSE;
+    aswitch = P1switch = P2switch = eswitch = rswitch = FALSE;
+    digraph = dswitch = tswitch = lswitch = mswitch = FALSE;
+    Tswitch = FALSE;
+    outfilename = NULL;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('g',gswitch)
+                else SWBOOLEAN('s',sswitch)
+                else SWBOOLEAN('z',digraph)
+                else SWBOOLEAN('a',aswitch)
+                else SWBOOLEAN('t',tswitch)
+                else SWBOOLEAN('T',Tswitch)
+                else SWBOOLEAN('q',qswitch)
+                else SWLONG('P',P1switch,P1value,"genrang -P")
+                else SWLONG('/',P2switch,P2value,"genrang -P")
+                else SWLONG('e',eswitch,evalue,"genrang -e")
+                else SWLONG('d',dswitch,rvalue,"genrang -d")
+                else SWLONG('r',rswitch,rvalue,"genrang -r")
+                else SWLONG('R',Rswitch,rvalue,"genrang -R")
+                else SWINT('S',Sswitch,Svalue,"genrang -S")
+                else SWINT('l',lswitch,loopmax,"genrang -l")
+                else SWINT('m',mswitch,multmax,"genrang -m")
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1)
+            {
+		if (sscanf(arg,"%d,%d",&n1,&n2) == 2)
+		{
+		    bipartite = TRUE;
+		    if (n1 < 1 || n2 < 1) badargs = TRUE;
+		    n = n1 + n2;
+		}
+		else if (sscanf(arg,"%d",&n) == 1)
+		{
+		    bipartite = FALSE;
+		    if (n < 1) badargs = TRUE;
+		}
+		else
+		    badargs = TRUE;
+            }
+            else if (argnum == 2)
+            {
+                if (sscanf(arg,"%ld",&numgraphs) != 1 || numgraphs < 1)
+                    badargs = TRUE;
+            }
+            else if (argnum == 3) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if (Tswitch) digraph = TRUE;
+
+    if ((gswitch!=0) + (sswitch!=0) + (digraph!=0) > 1)
+        gt_abort(">E genrang: -gsz are incompatible\n");
+
+    if (gswitch)      codetype = GRAPH6;
+    else if (digraph) codetype = DIGRAPH6;
+    else              codetype = SPARSE6;
+
+    if (P1switch && !P2switch)
+    {
+        P2value = P1value;
+        P1value = 1;
+    }
+    else if (P2switch && !P1switch)
+    {
+        P1value = 1;
+        P1switch = TRUE;
+    }
+
+    if (P1switch && (P1value < 0 || P2value <= 0 || P1value > P2value))
+        gt_abort(">E genrang: bad value for -P switch\n");
+
+    if ((P1switch!=0) + (eswitch!=0) + (rswitch!=0) + (dswitch!=0) 
+           + (Tswitch!=0) + (Rswitch!=0) + (tswitch!=0) > 1)
+        gt_abort(">E genrang: -PerRdtT are incompatible\n");
+
+    if ((sswitch!=0) + (gswitch!=0) + (Rswitch!=0) > 1)  /* REVISE */
+        gt_abort(">E genrang: -sgR are incompatible\n");
+
+    if ((aswitch!=0) + (Rswitch!=0) > 1)
+        gt_abort(">E genrang: -aR are incompatible\n");
+
+    if (!lswitch) loopmax = 0;
+    if (!mswitch) multmax = 1;
+    if (digraph &&
+           (Rswitch || multmax>1 || loopmax>1 || dswitch || tswitch))
+        gt_abort(">E genrang: -z is only compatible with -T, -P, -e and -l1\n");
+
+    if (!digraph && (loopmax>1 || multmax>1)
+                 && !(Rswitch || (rswitch && !gswitch)))
+        gt_abort(">E genrang: -l>1,-m>1 need -R or -r without -g\n");
+
+    if (multmax < 1 || loopmax < 0)
+        gt_abort(">E genrang: bad value for -l or -m\n");
+
+    if (argnum < 2 || argnum > 3) badargs = TRUE;
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if (!Sswitch)
+    {
+#ifdef INITSEED
+        INITSEED;
+        ran_init(seed);
+#endif
+    }
+    else
+        ran_init(Svalue);
+
+    if (!outfilename || outfilename[0] == '-')
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename,"w")) == NULL)
+    {
+        fprintf(stderr,"Can't open output file %s\n",outfilename);
+        gt_abort(NULL);
+    }
+
+    m = (n + WORDSIZE + 1) / WORDSIZE;
+    usesparse = tswitch || dswitch ||
+                 (rswitch && !aswitch && codetype==SPARSE6);
+#if !MAXN
+    if (!Rswitch && !usesparse)
+    {
+        DYNALLOC2(graph,g,g_sz,n,m,"genrang");
+        if (aswitch) DYNALLOC1(int,perm,perm_sz,n,"genrang");
+    }
+#endif
+
+    rswitch = rswitch || Rswitch || dswitch;
+
+#if MAXN
+    if (rswitch && rvalue > MAXLREG)
+    {
+        fprintf(stderr,
+                ">E -r/-R is only implemented for degree <= %d\n",MAXLREG);
+        exit(1);
+    }
+#endif
+
+    ln = n;
+    if (bipartite)
+	nc2 = (unsigned long)n1*n2;
+    else
+        nc2 = ln*loopmax + (1+(digraph!=0))*ln*(ln-1)/2*multmax;
+
+    if (eswitch && evalue > nc2)
+    {   
+        fprintf(stderr,
+             ">E There are no graphs of order %d and %ld edges\n",
+             n,evalue);
+        exit(1);
+    }
+
+    if (rswitch && (((n&1) != 0 && (rvalue&1) != 0)
+        || rvalue > (n-1)*multmax+2*loopmax))
+    {
+        fprintf(stderr,     
+             ">E There are no such graphs of order %d and degree %ld\n",
+             n,rvalue);
+        exit(1);
+    }
+
+    if (!P1switch)
+    {
+        P1value = 1;
+        P2value = 2;
+    }
+
+    SG_INIT(sg);
+
+    for (nout = 1; nout <= numgraphs; ++nout)
+    {
+        if (eswitch)
+        {
+	    if (digraph)
+            {
+		NOBIP;
+		ranarcs(evalue,loopmax>0,g,m,n);
+	    }
+	    else 
+	    { 
+		if (bipartite)
+	            ranedges_bip(evalue,g,m,n1,n2);
+		else
+	            ranedges(evalue,loopmax>0,g,m,n);
+	    }
+	}
+	else if (dswitch)
+        {
+	    if (bipartite)
+		dmodel_bip_sg(rvalue,&sg,n1,n2);
+	    else
+		dmodel_sg(rvalue,&sg,n);
+	}
+        else if (Rswitch)
+	{
+	    NOBIP;
+	    ranregR(outfile,rvalue,multmax,loopmax,n);
+	}
+        else if (rswitch && usesparse)
+	{
+	    NOBIP;
+            ranreglm_sg(rvalue,&sg,multmax,loopmax,n);
+	}
+        else if (rswitch && !usesparse)
+	{
+	    NOBIP;
+	    ranreg(rvalue,g,m,n);
+	}
+	else if (tswitch)
+	{
+	    NOBIP;
+	    randomtree(&sg,n);
+	}
+	else if (Tswitch)
+	{
+	    if (bipartite)
+		grandtourn_bip(g,m,n1,n2);
+	    else
+		grandtourn(g,m,n);
+	}
+        else
+        {
+	    if (bipartite)
+	        grandgraph_bip(g,digraph,P1value,P2value,m,n1,n2);
+	    else
+	        grandgraph(g,digraph,loopmax>0,P1value,P2value,m,n);
+	}
+
+        if (Rswitch) continue;
+
+        if (aswitch && !usesparse)
+        {
+            ranperm(perm,n);
+            perminvar(g,perm,m,n);
+        }
+        if (codetype == SPARSE6)
+	{
+            if (usesparse)
+            {
+                sortlists_sg(&sg);
+                writes6_sg(outfile,&sg);
+            }
+            else
+                writes6(outfile,g,m,n);
+	}
+        else if (codetype == DIGRAPH6)
+	{
+	    if (usesparse)
+		writed6_sg(outfile,&sg);
+            else
+                writed6(outfile,g,m,n);
+	}
+        else 
+	{
+	    if (usesparse)
+		writeg6_sg(outfile,&sg);
+            else
+                writeg6(outfile,g,m,n);
+	}
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/genspecialg.c b/lib/nauty/genspecialg.c
new file mode 100644
index 0000000..ad1e974
--- /dev/null
+++ b/lib/nauty/genspecialg.c
@@ -0,0 +1,1020 @@
+/* genspecialg.c  version 1.1; B D McKay, Feb 12, 2016 */
+
+#define USAGE "genspecialg \n\
+[-s|-g|-z|-d] [-q] \
+[-p#|-c#|-e#|-k#|-b#,#|-Q#|-f#|-J#,#|-P#,#|C#,#...|G#,#...|T#,#...] [outfile]"
+
+#define HELPTEXT \
+" Generate one particular graph.\n\
+     #  : size parameter called n in the descriptions\n\
+\n\
+    -s : Write in sparse6 format (default)\n\
+    -g : Write in graph6 format\n\
+    -z : Make digraph versions and write in digraph6 format\n\
+    -d : Write in dreadnaut format (can be used with -z)\n\
+    -q : Suppress summary\n\
+\n\
+    If defined, the digraph version is shown in parentheses:\n\
+    -p#   : path (directed path) on n vertices.\n\
+    -c#   : cycle (directed cycle) on n vertices.\n\
+    -e#   : empty graph (digraph with loops only) on n vertices.\n\
+    -k#   : complete graph (with loops) on n vertices\n\
+    -b#,# : complete bipartite graph (directed l->r) on n vertices\n\
+    -f#   : flower snark on 4*# vertices\n\
+    -P#,# : generalized Petersen graph; usual one is -P5,2\n\
+    -Q#   : hypercube on 2^n vertices and degree n.\n\
+    -J#,# : Johnson graph J(n,k), args are n and k.\n\
+    -C#,#... : circulant (di)graph.\n\
+    -T#,#... : theta (di)graph Theta(#,#,...), give path lengths.\n\
+    -G#,#... : (directed) grid, use negative values for open directions\n"
+
+/* Ideas: multipartite, knesser, full trees */
+
+#include "gtools.h"
+
+#define MAXARGS 1000  /* Maximum argument list for multi-argument parameters */
+#define SWAP(x,y) {int w = x; x = y; y = w;}
+
+static long args[MAXARGS];
+
+static short vmark_val = 32000;
+DYNALLSTAT(short,vmark,vmark_sz);
+#define MARK(i) vmark[i] = vmark_val
+#define UNMARK(i) vmark[i] = 0
+#define ISMARKED(i) (vmark[i] == vmark_val)
+#define ISNOTMARKED(i) (vmark[i] != vmark_val)
+#define RESETMARKS {if (vmark_val++ >= 32000) \
+    {size_t ij; for (ij=0;ij<vmark_sz;++ij) vmark[ij]=0; vmark_val=1;}}
+
+static void
+preparemarks(size_t nn)
+{
+    size_t oldsize;
+    short *oldpos;
+
+    oldsize = vmark_sz;
+    oldpos = vmark;
+    DYNALLOC1(short,vmark,vmark_sz,nn,"preparemarks");
+    if (vmark_sz != oldsize || vmark != oldpos) vmark_val = 32000;
+}
+
+/**************************************************************************/
+
+static void
+writedread(FILE *f, sparsegraph *sg, boolean digraph)
+/* Write in dreadnaut format */
+{
+    size_t *v;
+    int *d,*e,n,i,j,k;
+
+    SG_VDE(sg,v,d,e);
+    n = sg->nv;
+
+    if (digraph) fprintf(f,"n=%d $=0 dg\n",n);
+    else         fprintf(f,"n=%d $=0 g\n",n);
+
+    for (i = 0; i < n; ++i)
+    {
+	for (j = 0; j < d[i]; ++j)
+        {
+	    k = e[v[i]+j];
+	    if (k >= i || digraph) fprintf(f," %d",k);
+	}
+	if (i == n-1) fprintf(f,".\n$$\n");
+	else          fprintf(f,";\n");
+    }
+} 
+
+/**************************************************************************/
+
+static int binom[32][16];   /* Cached binomial coefficients */
+
+static int
+binomial(int n, int k)
+/* Value of binomial(n,k), error if too big for int */
+{
+    int i,nki,ans;
+    nauty_counter work;
+
+    if (k > n/2) k = n - k;
+    if (k < 0) return 0;
+
+    if (n < 32  && binom[n][k] > 0) return binom[n][k];
+
+    work = 1;
+    for (i = 1; i <= k; ++i)
+    {
+        nki = n-k+i;
+        work = (work/i) * nki + (work%i) * nki / i;
+        if ((int)work != work) { fprintf(stderr,"Overflow\n"); exit(1); }
+    }
+
+    ans = (int)work;
+    if (n < 32) binom[n][k] = ans;
+
+    return ans;
+}
+
+/**************************************************************************/
+
+static void
+unrank(int r, int k, int *a)
+/* r-th k-set in colex order (r=0,1,...) */
+{
+    int i,p;
+
+    for (i = k; i > 0; --i)
+    {
+        p = i - 1;
+        do ++p; while (binomial(p,i) <= r);
+        r -= binomial(p-1,i);
+        a[i-1] = p-1;
+    }
+}
+
+static int
+rank(int k, int *a)
+/* Rank of a[0..k-1] in colex order */
+{
+    int i,r;
+
+    r = 0;
+    for (i = 0; i < k; ++i)
+        r += binomial(a[i],i+1);
+
+    return r;
+}
+
+/**************************************************************************/
+
+static int
+vnumber(long *dimen, int *index, int ndimen)
+{
+    int i,v;
+    
+    v = 0;
+    for (i = 0; i < ndimen; ++i)
+        v = v*dimen[i] + index[i];
+
+    return v;
+}
+
+/**************************************************************************/
+
+static void
+makepath(long n, boolean digraph, sparsegraph *sg)
+{
+    int *d,*e,i;
+    size_t *v,k;
+
+    if (n < 1 || n > NAUTY_INFINITY-2)
+        gt_abort(">E genspecialg: bad argument for -p\n");
+
+    if (digraph) SG_ALLOC(*sg,n,n-1,"genspecialg");
+    else         SG_ALLOC(*sg,n,2UL*n-2,"genspecialg");
+
+    SG_VDE(sg,v,d,e);
+
+    if (digraph || n == 1)
+    {
+	sg->nv = n;
+	sg->nde = n-1;
+
+	for (i = 0; i < n-1; ++i)
+        {
+	    d[i] = 1;
+	    v[i] = i;
+	    e[i] = i+1;
+        }
+	d[n-1] = 0;
+	v[n-1] = 0;
+    }
+    else
+    {
+	sg->nv = n;
+	sg->nde = 2*n-2;
+
+	d[0] = 1;
+	v[0] = 0;
+	e[0] = 1;
+	for (i = 1, k = 1; i < n-1; ++i, k += 2)
+	{
+	    d[i] = 2;
+	    v[i] = k;
+	    e[k] = i-1;
+	    e[k+1] = i+1;
+	}
+	d[n-1] = 1;
+	v[n-1] = k;
+	e[k] = n-2;
+    }
+}
+
+/**************************************************************************/
+
+static void
+makecycle(long n, boolean digraph, sparsegraph *sg)
+{
+    int *d,*e,i;
+    size_t *v,k;
+
+    if (!digraph && (n < 1 || n == 2 || n > NAUTY_INFINITY-2))
+        gt_abort(">E genspecialg: bad argument for -c\n");
+    if (digraph && (n < 1 || n > NAUTY_INFINITY-2))
+        gt_abort(">E genspecialg: bad argument for -zc\n");
+
+    if (digraph) SG_ALLOC(*sg,n,n,"genspecialg");
+    else         SG_ALLOC(*sg,n,2UL*n,"genspecialg");
+
+    SG_VDE(sg,v,d,e);
+
+    if (digraph || n == 1)
+    {
+	sg->nv = n;
+	sg->nde = n;
+
+	for (i = 0; i < n-1; ++i)
+        {
+	    d[i] = 1;
+	    v[i] = i;
+	    e[i] = i+1;
+        }
+	d[n-1] = 1;
+	v[n-1] = n-1;
+	e[n-1] = 0;
+    }
+    else
+    {
+	sg->nv = n;
+	sg->nde = 2UL*n;
+
+	d[0] = 2;
+	v[0] = 0;
+	e[0] = 1;
+	e[1] = n-1;
+
+	for (i = 1; i < n-1; ++i)
+        {
+	    d[i] = 2;
+	    v[i] = 2UL*i;
+	    e[2UL*i] = i-1;
+	    e[2UL*i+1] = i+1;
+        }
+	d[n-1] = 2;
+	v[n-1] = 2UL*n-2;
+	e[2UL*n-2] = 0;
+	e[2UL*n-1] = n-2;
+    }
+}
+
+/**************************************************************************/
+
+static void
+makeflowersnark(long k, boolean digraph, sparsegraph *sg)
+/* Flower snark on 4*k vertices, no digraph variant 
+*
+ * The flower snark Jn can be constructed with the following process :
+ * Build n copies of the star graph on 4 vertices. Denote the
+ * central vertex of each star Ai and the outer vertices Bi, Ci and
+ * Di. This results in a disconnected graph on 4n vertices with 3n
+ * edges (Ai-Bi, Ai-Ci and Ai-Di for 1?i?n). Construct the n-cycle
+ * (B1... Bn). This adds n edges. Finally construct the 2n-cycle
+ * (C1... CnD1... Dn). This adds 2n edges. By construction, the
+ * Flower snark Jn is a cubic graph with 4n vertices and 6n edges.
+*/
+
+#define FSA(i) (4*(i))
+#define FSB(i) (4*(i)+1)
+#define FSC(i) (4*(i)+2)
+#define FSD(i) (4*(i)+3)
+
+{
+    int n,*d,*e,i,j;
+    size_t *v,nde;
+
+    if (k < 3 || k > (NAUTY_INFINITY-2)/4)
+        gt_abort(">E genspecialg: bad argument for -f\n");
+
+    n = 4*k;
+    nde = 12*(size_t)k;
+
+    SG_ALLOC(*sg,n,nde,"genspecialg");
+
+    SG_VDE(sg,v,d,e);
+    sg->nv = n;
+    sg->nde = nde;
+
+    for (i = 0; i < n; ++i)
+    {
+	d[i] = 0;
+        v[i] = 3*(size_t)i;
+    }
+
+    for (i = 0; i < k; ++i)
+    {
+        e[v[FSA(i)]+d[FSA(i)]++] = FSB(i);
+        e[v[FSB(i)]+d[FSB(i)]++] = FSA(i);
+        e[v[FSA(i)]+d[FSA(i)]++] = FSC(i);
+        e[v[FSC(i)]+d[FSC(i)]++] = FSA(i);
+        e[v[FSA(i)]+d[FSA(i)]++] = FSD(i);
+        e[v[FSD(i)]+d[FSD(i)]++] = FSA(i);
+    }
+
+    for (i = 0; i < k; ++i)
+    {
+        j = FSB((i+1)%k);
+	e[v[FSB(i)]+d[FSB(i)]++] = j;
+	e[v[j]+d[j]++] = FSB(i);
+    }
+
+    for (i = 0; i < k-1; ++i)
+    {
+	e[v[FSC(i)]+d[FSC(i)]++] = FSC(i+1);
+	e[v[FSC(i+1)]+d[FSC(i+1)]++] = FSC(i);
+    }
+
+    for (i = 0; i < k-1; ++i)
+    {
+	e[v[FSD(i)]+d[FSD(i)]++] = FSD(i+1);
+	e[v[FSD(i+1)]+d[FSD(i+1)]++] = FSD(i);
+    }
+
+    e[v[FSD(0)]+d[FSD(0)]++] = FSC(k-1);
+    e[v[FSC(k-1)]+d[FSC(k-1)]++] = FSD(0);
+    e[v[FSC(0)]+d[FSC(0)]++] = FSD(k-1);
+    e[v[FSD(k-1)]+d[FSD(k-1)]++] = FSC(0);
+}
+
+/**************************************************************************/
+
+static void
+makeJohnson(long n, long k, boolean digraph, sparsegraph *sg)
+{
+    size_t *v;
+    int *d,*e,*ep,nv,deg,i,j,s,t,u;
+    DYNALLSTAT(int,a,a_sz);
+    DYNALLSTAT(int,b,b_sz);
+
+    if (k > n/2) k = n - k;
+    if (k < 0) gt_abort(">E genspecialg: bad parameters for -J\n");
+
+    nv = binomial(n,k);
+    if (nv > NAUTY_INFINITY-2) gt_abort(">E genspecialg: too big -J\n");
+    deg = k*(n-k);
+
+    SG_ALLOC(*sg,nv,nv*(size_t)deg,"genspecialg");
+    sg->nv = nv;
+    sg->nde = nv*(size_t)deg;
+    SG_VDE(sg,v,d,e);
+
+    DYNALLOC1(int,a,a_sz,k,"genspecialg");
+    DYNALLOC1(int,b,b_sz,k,"genspecialg");
+    preparemarks(n);
+
+    for (i = 0; i < nv; ++i)
+    {
+	v[i] = i*(size_t)deg;
+	d[i] = deg;
+	ep = e + v[i];
+	unrank(i,k,a);
+//{int x;for(x=0;x<k;++x)printf(" %d",a[x]);printf("\n");}
+	RESETMARKS;
+	for (j = 0; j < k; ++j) MARK(a[j]);
+
+	for (j = 0; j < n; ++j)
+	if (ISNOTMARKED(j))
+	{
+	    for (s = 0; s < k; ++s)
+	    {
+		for (t = 0; t < k; ++t) b[t] = a[t];
+		u = s;
+		while (u > 0 && b[u-1] > j)
+		{
+		    b[u] = b[u-1];
+		    --u;
+		}
+		while (u < k-1 && b[u+1] < j)
+		{
+		    b[u] = b[u+1];
+		    ++u;
+		}
+		b[u] = j;
+//{int x;printf("-");for(x=0;x<k;++x)printf(" %d",b[x]);printf(" (%d)\n",rank(k,b));}
+		*(ep++) = rank(k,b);
+	    }
+	}
+    }
+}
+
+/**************************************************************************/
+
+static void
+makecomplete(long n, boolean digraph, sparsegraph *sg)
+{
+    int *d,*e,i,j;
+    size_t *v,k;
+
+    if (n < 1 || n > NAUTY_INFINITY-2)
+        gt_abort(">E genspecialg: bad argument for -k\n");
+
+    if (digraph) SG_ALLOC(*sg,n,n*(size_t)n,"genspecialg");
+    else         SG_ALLOC(*sg,n,n*(size_t)(n-1),"genspecialg");
+
+    SG_VDE(sg,v,d,e);
+
+    if (digraph)
+    {
+        sg->nv = n;
+	sg->nde = n*(size_t)n;
+
+	for (i = 0, k = 0; i < n; ++i, k += n)
+	{
+	    d[i] = n;
+	    v[i] = k;
+	    for (j = 0; j < n; ++j) e[k+j] = j;
+        }
+    }
+    else
+    {
+        sg->nv = n;
+	sg->nde = n*(size_t)(n-1);
+
+	for (i = 0, k = 0; i < n; ++i)
+	{
+	    d[i] = n-1;
+	    v[i] = k;
+	    for (j = 0; j < n; ++j)
+               if (j != i) e[k++] = j;
+        }
+    }
+}
+
+/**************************************************************************/
+
+static void
+makeempty(long n, boolean digraph, sparsegraph *sg)
+{
+    int *d,*e,i;
+    size_t *v;
+
+    if (n < 1 || n > NAUTY_INFINITY-2)
+        gt_abort(">E genspecialg: bad argument for -e\n");
+
+    if (digraph) SG_ALLOC(*sg,n,n,"genspecialg");
+    else         SG_ALLOC(*sg,n,0,"genspecialg");
+
+    SG_VDE(sg,v,d,e);
+
+    if (digraph)
+    {
+        sg->nv = n;
+	sg->nde = n;
+
+	for (i = 0; i < n; ++i)
+	{
+	    d[i] = 1;
+	    v[i] = i;
+	    e[i] = i;
+        }
+    }
+    else
+    {
+        sg->nv = n;
+	sg->nde = 0;
+
+	for (i = 0; i < n; ++i)
+	{
+	    d[i] = 0;
+	    v[i] = 0;
+        }
+    }
+}
+
+/**************************************************************************/
+
+static void
+makehypercube(long deg, boolean digraph, sparsegraph *sg)
+{
+    int *d,*e,i,j;
+    size_t *v,k,nv;
+
+    if (deg < 0 || deg > 30)
+        gt_abort(">E genspecialg: bad argument for -q\n");
+    if (digraph)
+        gt_abort(">E genspecialg: -zq is not implemented\n");
+
+    nv = 1UL << deg;
+    SG_ALLOC(*sg,nv,deg*nv,"genspecialg");
+
+    SG_VDE(sg,v,d,e);
+
+    sg->nv = nv;
+    sg->nde = deg*nv;
+
+    for (i = 0, k = 0; i < nv; ++i, k += deg)
+    {
+	d[i] = deg;
+	v[i] = k;
+	for (j = 0; j < deg; ++j) e[k+j] = i ^ (1<<j);
+    }
+}
+
+/**************************************************************************/
+
+static void
+maketheta(long *len, int npaths, boolean digraph, sparsegraph *sg)
+{
+    int i,j,k,n,ntemp,*d,*e;
+    size_t *v,ne,etemp;
+    boolean hasone;
+
+    hasone = FALSE;
+    n = 2;
+    ne = 0;
+    for (i = 0; i < npaths; ++i)
+    {
+	if (len[i] < 1)
+	    gt_abort(">E genspecialg: -T paths must be at least length 1\n");
+	if (len[i] == 1)
+	{
+	    if (hasone) gt_abort(
+                  ">E genspecialg: -T only one path of length 1 allowed\n");
+	    hasone = TRUE;
+	}
+	ntemp = n;
+	n += len[i]-1;
+	if (n < ntemp)
+	    gt_abort(">E genspecialg: -T too many vertices\n");
+	etemp = ne;
+	ne += len[i];
+	if (ne < etemp) gt_abort(">E genspecialg: -T too many edges\n");
+    }
+
+    if (n > NAUTY_INFINITY-2)
+        gt_abort(">E genspecialg: -T size is too big\n");
+
+    if (!digraph)
+    {
+	etemp = ne;
+	ne *= 2;
+	if (ne < etemp) gt_abort(">E genspecialg: -T too many edges\n");
+    }
+
+    SG_ALLOC(*sg,n,ne,"genspecialg");
+    SG_VDE(sg,v,d,e);
+    sg->nv = n;
+    sg->nde = ne;    
+
+    v[0] = 0;
+    v[1] = npaths;
+    if (digraph)
+    {
+	v[2] = v[1];
+	for (i = 3; i < n; ++i) v[i] = v[i-1] + 1;
+    }
+    else
+    {
+	v[2] = v[1] + npaths;
+	for (i = 3; i < n; ++i) v[i] = v[i-1] + 2;
+    }
+
+    for (i = 0; i < n; ++i) d[i] = 0;
+
+    if (hasone)
+    {
+	e[v[0]+(d[0]++)] = 1;
+	if (!digraph) e[v[1]+(d[1]++)] = 0;
+    }
+
+    k = 2;
+    for (i = 0; i < npaths; ++i)
+    {
+	if (len[i] == 1) continue;
+
+	e[v[0]+(d[0]++)] = k;
+	if (!digraph) e[v[k]+(d[k]++)] = 0;
+	
+	for (j = 0; j < len[i]-2; ++j)
+	{
+	    e[v[k]+(d[k]++)] = k+1;
+	    if (!digraph) e[v[k+1]+(d[k+1]++)] = k;
+	    ++k;
+	}
+	e[v[k]+(d[k]++)] = 1;
+	if (!digraph) e[v[1]+(d[1]++)] = k;
+        ++k;
+    }
+}
+
+/**************************************************************************/
+
+static void
+makegrid(long *dim, int ndim, boolean digraph, sparsegraph *sg)
+{
+    int *d,*e,i,j,deg,n,oldn;
+    size_t *v,k;
+    boolean closed[30];
+    int index[30];
+
+    n = 1;
+    deg = 0;
+    for (i = 0; i < ndim; ++i)
+    {
+        if (dim[i] >= -1 && dim[i] <= 1)
+            gt_abort(">E genspecialg: -G dimensions must be at least 2\n");
+	if (dim[i] == 2 && !digraph)
+            gt_abort(">E genspecialg: -G dimen 2 is only ok for digraphs\n");
+
+	closed[i] = (dim[i] > 0);
+	if (dim[i] < 0) dim[i] = -dim[i];
+
+	oldn = n;
+        n *= dim[i];
+	if (n < 0 || n / dim[i] != oldn)
+	    gt_abort(">E genspecialg: -G size is too big\n");
+
+	if (digraph || dim[i] == 2) ++deg;
+        else                        deg += 2;
+
+        index[i] = 0;
+    }
+
+    if (n > NAUTY_INFINITY-2)
+        gt_abort(">E genspecialg: -G size is too big\n");
+
+    SG_ALLOC(*sg,n,deg*(size_t)n,"genspecialg");
+
+    SG_VDE(sg,v,d,e);
+
+    sg->nv = n;
+    sg->nde = deg*(size_t)n;
+
+    k = 0;
+    for (i = 0; i < n; ++i)
+    {
+	v[i] = k;
+	for (j = 0; j < ndim; ++j)
+	{
+	    if (index[j] < dim[j]-1)
+	    {
+		++index[j];
+		e[k++] = vnumber(dim,index,ndim);
+		--index[j];
+	    }
+	    if (!digraph && index[j] > 0)
+	    {
+		--index[j];
+		e[k++] = vnumber(dim,index,ndim);
+		++index[j];
+	    }
+	    if (closed[j] && index[j] == dim[j]-1)
+	    {
+		index[j] = 0;
+		e[k++] = vnumber(dim,index,ndim);
+		index[j] = dim[j]-1;
+	    }
+	    if (closed[j] && !digraph && index[j] == 0)
+	    {
+		index[j] = dim[j]-1;
+		e[k++] = vnumber(dim,index,ndim);
+		index[j] = 0;
+	    }
+	}
+
+        d[i] = k - v[i];
+
+	for (j = ndim; --j >= 0;)
+	{
+	    if (index[j] != dim[j]-1)
+	    {
+		++index[j];
+		break;
+	    }
+	    else
+		index[j] = 0;
+	}
+    }
+}
+
+/**************************************************************************/
+
+static void
+makecirculant(long n, long *conn, int nconn, boolean digraph, sparsegraph *sg)
+{
+    int *d,*e,i,j,deg;
+    size_t *v,k;
+
+    if (nconn > 0 && conn[0] <= 0)
+        gt_abort(">E genspecialg: -C connections must be nonzero\n");
+
+    for (i = 1; i < nconn; ++i)
+	if (conn[i] <= conn[i-1])
+	    gt_abort(">E genspecialg: -C connections must be increasing\n");
+
+    if (nconn == 0)
+	deg = 0;
+    else
+    {
+        if (digraph)
+	{
+	    if (conn[nconn-1] >= n) gt_abort(
+                 ">E genspecialg: -C connections must be 1..n-1\n");
+	    deg = nconn;
+	}
+	else
+        {
+            if (conn[nconn-1] > n/2) gt_abort(
+                 ">E genspecialg: -C connections must be 1..n/2\n");
+	    deg = 2*nconn - (2*conn[nconn-1]==n);
+	}
+    }
+
+    SG_ALLOC(*sg,n,deg*n,"genspecialg");
+
+    SG_VDE(sg,v,d,e);
+    sg->nv = n;
+    sg->nde = deg*n;
+
+    for (i = 0; i < n; ++i)
+    {
+        d[i] = deg;
+	v[i] = deg*(size_t)i;
+    }
+ 
+    for (i = 0; i < n; ++i)
+    {
+	k = v[i];
+	for (j = 0; j < nconn; ++j)
+	{
+	    e[k++] = (i + conn[j]) % n;
+	    if (!digraph && 2*conn[j] != n)
+		e[k++] = (i - conn[j] + n) % n;
+	}
+    }
+}
+
+/**************************************************************************/
+
+static void
+makegenpetersen(long n1, long n2, boolean digraph, sparsegraph *sg)
+{
+    int *d,*e,i,j,n;
+    size_t *v,k;
+
+    if (digraph) gt_abort(">E no digraph version of -P is implemented\n");
+
+    n = 2*n1;
+    if (n < 1 || n1 > NAUTY_INFINITY/2-1 || n2 < 1 || 2*n2 >= n1)
+	gt_abort(">E -Pm,k needs m>0,0<k<m/2; or m too large\n");
+
+    SG_ALLOC(*sg,n,3UL*n,"genspecialg");
+
+    SG_VDE(sg,v,d,e);
+    sg->nv = n;
+    sg->nde = 3UL*n;
+
+    for (i = 0; i < n; ++i)
+    {
+        d[i] = 3;
+	v[i] = 3UL*i;
+    }
+
+    for (i = 0; i < n1; ++i)
+    {
+	k = v[i];
+	e[k] = (i + 1) % n1;
+	e[k+1] = (i + n1 - 1) % n1;
+	e[k+2] = i + n1;
+    }
+    
+    for (i = 0; i < n1; ++i)
+    {
+	k = v[n1+i];
+	e[k] = n1 + (i + n2) % n1;
+        e[k+1] = n1 + (i - n2 + n1) % n1;
+	e[k+2] = i;
+    }
+} 
+
+/**************************************************************************/
+
+static void
+makecompletebipartite(long n1, long n2, boolean digraph, sparsegraph *sg)
+{
+    int *d,*e,i,j,n;
+    size_t *v,k;
+
+    n = n1 + n2;
+
+    if (n1 < 1 || n2 < 1 || n > NAUTY_INFINITY-2)
+        gt_abort(">E genspecialg: bad argument for -b\n");
+
+    if (digraph) SG_ALLOC(*sg,n,n1*n2,"genspecialg");
+    else         SG_ALLOC(*sg,n,2*n1*n2,"genspecialg");
+
+    SG_VDE(sg,v,d,e);
+
+    if (digraph)
+    {
+	sg->nv = n;
+	sg->nde = n1*n2;
+
+	for (i = 0, k = 0; i < n1; ++i)
+	{
+	    d[i] = n2;
+	    v[i] = k;
+	    for (j = n1; j < n; ++j) e[k++] = j;
+	}
+	for (i = n1; i < n; ++i)
+	{
+	    d[i] = 0;
+	    v[i] = 0;
+        }
+    }
+    else
+    {
+	sg->nv = n;
+	sg->nde = 2*n1*n2;
+
+	for (i = 0, k = 0; i < n1; ++i)
+	{
+	    d[i] = n2;
+	    v[i] = k;
+	    for (j = n1; j < n; ++j) e[k++] = j;
+	}
+	for (i = n1; i < n; ++i)
+	{
+	    d[i] = n1;
+	    v[i] = k;
+	    for (j = 0; j < n1; ++j) e[k++] = j;
+        }
+    }
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    int n,codetype;
+    int argnum,i,j,nreq;
+    char *arg,sw;
+    boolean badargs,quiet;
+    boolean Cswitch,Pswitch,gswitch,sswitch,zswitch,Jswitch,dswitch;
+    boolean pswitch,cswitch,eswitch,kswitch,bswitch,Qswitch,Gswitch;
+    boolean fswitch,Tswitch;
+    long size;
+    static FILE *outfile;
+    char *outfilename;
+    sparsegraph sg;
+    boolean usesparse,digraph;
+    long Pargs[2],bargs[2],Jargs[2];
+    int nPargs,nbargs,nCargs,nGargs,nJargs,nTargs;
+
+    HELP; PUTVERSION;
+
+    gswitch = sswitch = zswitch = Pswitch = FALSE;
+    pswitch = cswitch = eswitch = kswitch = FALSE;
+    Gswitch = Cswitch = bswitch = Qswitch = FALSE;
+    dswitch = Jswitch = fswitch = Tswitch = quiet = FALSE;
+
+    outfilename = NULL;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('g',gswitch)
+                else SWBOOLEAN('s',sswitch)
+                else SWBOOLEAN('z',zswitch)
+                else SWBOOLEAN('d',dswitch)
+                else SWBOOLEAN('q',quiet)
+                else SWLONG('p',pswitch,size,"genspecialg -p")
+                else SWLONG('c',cswitch,size,"genspecialg -c")
+                else SWLONG('e',eswitch,size,"genspecialg -e")
+                else SWLONG('k',kswitch,size,"genspecialg -k")
+                else SWLONG('f',fswitch,size,"genspecialg -f")
+                else SWLONG('Q',Qswitch,size,"genspecialg -Q")
+                else SWSEQUENCE('b',",",bswitch,bargs,2,
+                                nbargs,"genspecialg -b")
+                else SWSEQUENCE('J',",",Jswitch,Jargs,2,
+                                nJargs,"genspecialg -J")
+                else SWSEQUENCE('P',",",Pswitch,Pargs,2,
+                                nPargs,"genspecialg -P")
+                else SWSEQUENCE('C',",",Cswitch,args,MAXARGS,
+                                nCargs,"genspecialg -C")
+                else SWSEQUENCE('G',",",Gswitch,args,30,
+                                nGargs,"genspecialg -G")
+                else SWSEQUENCE('T',",",Tswitch,args,MAXARGS,
+                                nTargs,"genspecialg -T")
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if (argnum == 1) outfilename = arg;
+            else             badargs = TRUE;
+        }
+    }
+
+    if ((gswitch!=0) + (sswitch!=0) + (zswitch!=0) > 1)
+        gt_abort(">E genspecialg: -gsz are incompatible\n");
+
+    if ((gswitch!=0) + (sswitch!=0) + (dswitch!=0) > 1)
+        gt_abort(">E genspecialg: -gsd are incompatible\n");
+
+    nreq = (pswitch!=0) + (cswitch!=0) + (eswitch!=0) + (kswitch!=0)
+           + (bswitch!=0) + (Qswitch!=0) + (Pswitch!=0) + (fswitch!=0)
+           + (Cswitch!= 0) + (Gswitch!=0) + (Jswitch!=0)
+           + (Tswitch!= 0);
+    if (nreq > 1)
+        gt_abort(">E genspecialg: must have exactly one of -bcfkpCGJPQT\n");
+    else if (nreq < 1) 
+	badargs = TRUE;
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if (gswitch)      codetype = GRAPH6;
+    else if (zswitch) codetype = DIGRAPH6;
+    else              codetype = SPARSE6;
+
+    if (!outfilename || outfilename[0] == '-')
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename,"w")) == NULL)
+    {
+        fprintf(stderr,"Can't open output file %s\n",outfilename);
+        gt_abort(NULL);
+    }
+
+    SG_INIT(sg);
+
+    if (pswitch)
+        makepath(size,zswitch,&sg);
+    else if (cswitch)
+        makecycle(size,zswitch,&sg);
+    else if (kswitch)
+        makecomplete(size,zswitch,&sg);
+    else if (eswitch)
+        makeempty(size,zswitch,&sg);
+    else if (Qswitch)
+        makehypercube(size,zswitch,&sg);
+    else if (bswitch)
+    {
+	if (nbargs != 2) gt_abort(">E genspecialg: -b needs two arguments\n");
+        makecompletebipartite(bargs[0],bargs[1],zswitch,&sg);
+    }
+    else if (Jswitch)
+    {
+	if (nJargs != 2) gt_abort(">E genspecialg: -J needs two arguments\n");
+        makeJohnson(Jargs[0],Jargs[1],zswitch,&sg);
+    }
+    else if (Pswitch)
+    {
+	if (nPargs != 2) gt_abort(">E genspecialg: -P needs two arguments\n");
+        makegenpetersen(Pargs[0],Pargs[1],zswitch,&sg);
+    }
+    else if (Cswitch)
+        makecirculant(args[0],args+1,nCargs-1,zswitch,&sg);
+    else if (Gswitch)
+    {
+	if (nGargs < 2)
+            gt_abort(">E genspecialg: -G needs at least two arguments\n");
+        makegrid(args,nGargs,zswitch,&sg);
+    }
+    else if (Tswitch)
+    {
+	if (nTargs < 1)
+            gt_abort(">E genspecialg: -T needs at least one argument\n");
+        maketheta(args,nTargs,zswitch,&sg);
+    }
+    else if (fswitch)
+	makeflowersnark(size,zswitch,&sg);
+
+    sortlists_sg(&sg);
+    if (dswitch)                   writedread(outfile,&sg,zswitch);
+    else if (codetype == GRAPH6)   writeg6_sg(outfile,&sg);
+    else if (codetype == DIGRAPH6) writed6_sg(outfile,&sg);
+    else                           writes6_sg(outfile,&sg);
+
+    if (!quiet)
+        fprintf(stderr,">Z %d vertices %lu edges\n",sg.nv,
+                       (unsigned long)(zswitch ? sg.nde : sg.nde/2));
+
+    exit(0);
+}
diff --git a/lib/nauty/gentourng.c b/lib/nauty/gentourng.c
new file mode 100644
index 0000000..76f6e14
--- /dev/null
+++ b/lib/nauty/gentourng.c
@@ -0,0 +1,1467 @@
+/* gentourng.c  version 1.4; B D McKay, Jan 20, 2016 */
+
+#define USAGE \
+"gentourng [-cd#D#] [-ugsz] [-lq] n [res/mod] [file]"
+
+#define HELPTEXT \
+" Generate all tournaments of a specified class.\n\
+\n\
+      n    : the number of vertices\n\
+   res/mod : only generate subset res out of subsets 0..mod-1\n\
+\n\
+     -c    : only write strongly-connected tournaments\n\
+     -d#   : a lower bound for the minimum out-degree\n\
+     -D#   : a upper bound for the maximum out-degree\n\
+     -l    : canonically label output graphs\n\
+\n\
+     -u    : do not output any graphs, just generate and count them\n\
+     -g    : use graph6 output (lower triangle)\n\
+     -s    : use sparse6 output (lower triangle)\n\
+     -z    : use digraph6 output\n\
+     -h    : write a header (only with -g or -s)\n\
+  Default output is upper triangle row-by-row in ascii\n\
+\n\
+     -q    : suppress auxiliary output\n\
+\n\
+  See program text for much more information.\n"
+
+
+/*  Parameters:
+
+             n    = the number of vertices (1..min(32,WORDSIZE))
+             mod, res = a way to restrict the output to a subset.
+                        All the graphs in G(n,mine..maxe) are divided into
+                        disjoint classes C(0,mod),C(1,mod),...,C(mod-1,mod),
+                        of very approximately equal size.
+                        Only the class C(res,mod) is written.
+
+	     file = a name for the output file (stdout if missing or "-")
+
+	     All switches can be concatenated or separate.  However, the
+             value of -d must be attached to the "d", and similarly for "x".
+
+             -c    : only write connected graphs
+             -d<int> : specify an upper bound for the maximum out-degree.
+                     The value of the upper bound must be adjacent to
+                     the "d".  Example: -d6
+             -l    : canonically label output graphs
+
+             -u    : do not output any graphs, just generate and count them
+             -z    : use digraph6 output
+	     -g    : use graph6 output
+	     -s    : use sparse6 output
+		For -g and -s, the lower triangle of the adjacency matrix
+                is written as if it is an undirected graph.  Nauty tools
+		like labelg do not know this format.  To read it you can
+                read it as an undirected graph then complement the upper
+		triangle.
+	     -h    : for graph6 or sparse6 format, write a header too
+
+	     -q    : suppress auxiliary output (except from -v)
+
+Output formats.
+
+  The output format is determined by the mutually exclusive switches
+  -u, -z, -g and -s.  The default is ascii format.
+
+  -u suppresses output of graphs completely.
+  -z uses digraph6 output.
+
+  -s and -g specify sparse6 and graph6 format, defined elsewhere.
+  In this case a header is also written if -h is present.
+
+OUTPROC feature.
+
+   By defining the C preprocessor variable OUTPROC at compile time
+   (for Unix the syntax is  -DOUTPROC=procname  on the cc command),
+   gentourng can be made to call a procedure of your manufacture with each
+   output graph instead of writing anything. Your procedure needs
+   to have type void and the argument list (FILE *f, graph *g, int n).
+   f is a stream open for writing, g is the graph in nauty format,
+   and n is the number of vertices. Your procedure can be in a
+   separate file so long as it is linked with gentourng. The global
+   variables nooutput, and canonise (all type boolean) can be
+   used to test for the presence of the flags -u and -l,
+   respectively. If -l is present, the group size and similar
+   details can be found in the global variable nauty_stats.
+
+PRUNE feature.
+
+   By defining the C preprocessor variable PRUNE at compile time, gentourng
+   can be made to call
+        int PRUNE(graph *g,int n,int maxn) 
+   for each intermediate (and final) graph, and reject it if 
+   the value returned is nonzero.  The arguments are:
+
+     g      = the graph in nauty format (m=1)
+     n      = the number of vertices in g
+     maxn   = the number of vertices for output 
+	      (the value you gave on the command line to gentourng)
+
+   gentourng constructs the graph starting with vertex 0, then adding
+   vertices 1,2,3,... in that order.  Each graph in the sequence is
+   an induced subgraph of all later graphs in the sequence.
+
+   A call is made for all orders from 1 to maxn.  In testing for
+   a uniform property (such as a forbidden subgraph or forbidden
+   induced subgraph) it might save time to notice that a call to
+   PRUNE for n implies that the call for n-1 already passed. 
+
+   For very fast tests, it might be worthwhile using PREPRUNE as
+   well or instead. It has the same meaning but is applied earlier
+   and more often.
+
+SUMMARY
+
+   If the C preprocessor variable SUMMARY is defined at compile time, the
+   procedure SUMMARY(nauty_counter nout, double cpu) is called just before
+   the program exits.  The purpose is to allow reporting of statistics
+   collected by PRUNE or OUTPROC.  The values nout and cpu are the output
+   count and cpu time reported on the >Z line.
+   Output should be written to stderr.
+
+INSTRUMENT feature.
+
+   If the C preprocessor variable INSTRUMENT is defined at compile time,
+   extra code is inserted to collect statistics during execution, and
+   more information is written to stderr at termination.
+
+CALLING FROM A PROGRAM
+
+   It is possible to call gentourng from another program instead of using it
+   as a stand-alone program.  The main requirement is to change the name
+   of the main program to be other than "main".  This is done by defining
+   the preprocessor variable GENG_MAIN.  You might also like to define
+   OUTPROC to be the name of a procedure to receive the graphs. To call
+   the program you need to define an argument list argv[] consistent with
+   the usual one; don't forget that argv[0] is the command name and not
+   the first argument.  The value of argc is the number of strings in
+   argv[]; that is, one more than the number of arguments.  See the
+   sample program callgeng.c.
+
+
+Counts:
+
+                all                 strong          regular
+   n        tournaments           tournaments     tournaments
+  
+   1                     1                     1             1
+   2                     1                     0             1
+   3                     2                     1             1
+   4                     4                     1             1
+   5                    12                     6             1
+   6                    56                    35             5
+   7                   456                   353             3
+   8                  6880                  6008            85
+   9                191536                178133            15
+  10               9733056               9355949         13333
+  11             903753248             884464590          1223
+  12          154108311168          152310149735      19434757
+  13        48542114686912        48234782263293       1495297
+  14     28401423719122304     28304491788158056
+  15  31021002160355166848  30964247546702883729   18400989629 
+
+**************************************************************************
+
+    Author:   B. D. McKay, Nov 2008.
+              Copyright  B. McKay (2008).  All rights reserved.
+              This software is subject to the conditions and waivers
+              detailed in the file nauty.h.
+
+**************************************************************************/
+
+#define NAUTY_PGM  3   /* 1 = geng, 2 = genbg, 3 = gentourng */
+
+#ifndef MAXN
+#define MAXN 32         /* not more than max(32,WORDSIZE) */
+#endif
+
+#if MAXN > 32
+ #error "Can't have MAXN greater than 32"
+#endif
+
+#define ONE_WORD_SETS
+#include "gtools.h"   /* which includes nauty.h and stdio.h */
+
+typedef unsigned int xword;
+
+static void (*outproc)(FILE*,graph*,int);
+
+static FILE *outfile;           /* file for output graphs */
+static int connec;              /* 1 for -c, 0 for not */
+boolean graph6;                 /* presence of -g */
+boolean digraph6;               /* presence of -z */
+boolean sparse6;                /* presence of -s */
+boolean nooutput;               /* presence of -u */
+boolean canonise;               /* presence of -l */
+boolean quiet;                  /* presence of -q */
+boolean header;                 /* presence of -h */
+statsblk nauty_stats;
+static int mindeg,maxdeg,maxn,mod,res;
+static boolean regular;
+#define PRUNEMULT 20   /* bigger -> more even split at greater cost */
+static int min_splitlevel,odometer,splitlevel,multiplicity;
+static graph gcan[MAXN];
+
+#if MAXN <= 16
+static xword xbit[] = {0x0001,0x0002,0x0004,0x0008,
+                       0x0010,0x0020,0x0040,0x0080,
+                       0x0100,0x0200,0x0400,0x0800,
+                       0x1000,0x2000,0x4000,0x8000};
+
+#define XNEXTBIT(x) \
+    ((x)&0xFF ? 7-leftbit[(x)&0xFF] : 15-leftbit[((x)>>8)&0xFF])
+#define XPOPCOUNT(x) (bytecount[((x)>>8)&0xFF] + bytecount[(x)&0xFF])
+#elif MAXN <= 24
+static xword xbit[] = {0x000001,0x000002,0x000004,0x000008,
+                       0x000010,0x000020,0x000040,0x000080,
+                       0x000100,0x000200,0x000400,0x000800,
+                       0x001000,0x002000,0x004000,0x008000,
+		       0x010000,0x020000,0x040000,0x080000,
+		       0x100000,0x200000,0x400000,0x800000};
+
+#define XNEXTBIT(x) \
+    ((x)&0xFF ? 7-leftbit[(x)&0xFF] : \
+      (x)&0xFF00 ? 15-leftbit[((x)>>8)&0xFF] : 23-leftbit[((x)>>16)&0xFF])
+#define XPOPCOUNT(x) (bytecount[((x)>>8)&0xFF] \
+	+ bytecount[((x)>>16)&0xFF] + bytecount[(x)&0xFF])
+#else
+static xword xbit[] = {0x00000001,0x00000002,0x00000004,0x00000008,
+                       0x00000010,0x00000020,0x00000040,0x00000080,
+                       0x00000100,0x00000200,0x00000400,0x00000800,
+                       0x00001000,0x00002000,0x00004000,0x00008000,
+                       0x00010000,0x00020000,0x00040000,0x00080000,
+                       0x00100000,0x00200000,0x00400000,0x00800000,
+                       0x01000000,0x02000000,0x04000000,0x08000000,
+                       0x10000000,0x20000000,0x40000000,0x80000000};
+
+#define XNEXTBIT(x) \
+    ((x)&0xFF ? 7-leftbit[(x)&0xFF] : \
+      (x)&0xFF00 ? 15-leftbit[((x)>>8)&0xFF] : \
+        (x)&0xFF0000 ? 23-leftbit[((x)>>16)&0xFF] : \
+			  31-leftbit[((x)>>24)&0xFF])
+#define XPOPCOUNT(x) (bytecount[((x)>>8)&0xFF] \
+        + bytecount[((x)>>16)&0xFF] + \
+	+ bytecount[((x)>>24)&0xFF] + bytecount[(x)&0xFF])
+#endif
+
+typedef struct
+{
+    xword lo,hi;          /* work purposes for orbit calculation */
+    xword xstart[MAXN+1]; /* index into xset[] for each cardinality */
+    xword *xset;          /* array of all x-sets in card order */
+    xword *xcard;         /* cardinalities of all x-sets */
+    xword *xinv;          /* map from x-set to index in xset */
+    xword *xorb;          /* min orbit representative */
+} leveldata;
+
+static leveldata data[MAXN];      /* data[n] is data for n -> n+1 */
+static nauty_counter nodes[MAXN];     /* nodes at each level */
+static nauty_counter nout;
+
+#ifdef INSTRUMENT
+static unsigned long rigidnodes[MAXN],fertilenodes[MAXN];
+static unsigned long a1calls,a1nauty,a1succs;
+static unsigned long a2calls,a2nauty,a2uniq,a2succs;
+#endif
+
+#ifdef PLUGIN
+#include PLUGIN
+#endif
+
+#ifdef OUTPROC
+extern void OUTPROC(FILE*,graph*,int);
+#endif
+#ifdef PRUNE
+extern int PRUNE(graph*,int,int);
+#endif
+#ifdef PREPRUNE
+extern int PREPRUNE(graph*,int,int);
+#endif
+#ifdef SUMMARY
+extern void SUMMARY(nauty_counter,double);
+#endif
+
+/************************************************************************/
+
+void
+write_ascii(FILE *f, graph *g, int n)
+/* write tournament g (n vertices) to file f in ascii format */
+{
+	char s[MAXN*(MAXN-1)/2+2];
+	int i,j;
+	size_t k;
+
+	k = 0;
+	for (i = 0; i < n-1; ++i)
+	    for (j = i+1; j < n; ++j)
+		if ((g[i] & bit[j])) s[k++] = '1'; else s[k++] = '0';
+
+	s[k++] = '\n';
+	s[k] = '\0';
+
+        if (fwrite(s,1,k,f) != k || ferror(f))
+            gt_abort(">E write_ascii : error on writing\n");
+}
+
+/************************************************************************/
+
+void
+writeg6x(FILE *f, graph *g, int n)
+/* write graph g (n vertices) to file f in graph6 format */
+{
+	writeg6(f,g,1,n);
+}
+
+/************************************************************************/
+
+void
+writes6x(FILE *f, graph *g, int n)
+/* write graph g (n vertices) to file f in sparse6 format */
+{
+	writes6(f,g,1,n);
+}
+
+/************************************************************************/
+
+void
+writed6x(FILE *f, graph *g, int n)
+/* write graph g (n vertices) to file f in digraph6 format */
+{
+	writed6(f,g,1,n);
+}
+
+/***********************************************************************/
+
+static void
+nullwrite(FILE *f, graph *g, int n)
+/* don't write graph g (n vertices) to file f */
+{
+}
+
+/***********************************************************************/
+
+static boolean
+isstrong(graph *g, int n)
+/* test if tournament g is strongly-connected 
+ * This code is strictly for tournaments only.
+ */
+{
+        setword seen,expanded,toexpand,allbits;
+        int i;
+
+	allbits = ALLMASK(n);
+
+        seen = bit[0] | g[0];
+        expanded = bit[0];
+
+        while (seen != allbits && (toexpand = (seen & ~expanded))) /* not == */
+        {
+            i = FIRSTBITNZ(toexpand);
+            expanded |= bit[i];
+            seen |= g[i];
+        }
+
+	if (seen != allbits) return FALSE;
+ 
+        seen = (allbits ^ g[0]);
+        expanded = bit[0];
+
+        while (seen != allbits && (toexpand = (seen & ~expanded))) /* not == */
+        {
+            i = FIRSTBITNZ(toexpand);
+            expanded |= bit[i];
+            seen |= (g[i] ^ allbits);
+        }
+
+	return seen == allbits;
+}
+
+/**********************************************************************/
+
+static void
+gcomplement(graph *g, graph *gc, int n)
+/* Take the complement of g and put it in gc */
+{
+	int i;
+	setword all;
+
+	all = ~(setword)BITMASK(n-1);
+	for (i = 0; i < n; ++i)
+	    gc[i] = g[i] ^ all ^ bit[i];
+}
+
+/**************************************************************************/
+
+static void
+makeleveldata(void)
+/* make the level data for each level */
+{
+        long h;
+        int n,dmax,dmin;
+        long ncj;
+        leveldata *d;
+	xword *xcard,*xinv;
+	xword *xset,xw,tttn,nxsets;
+	xword cw;
+	xword i,j;
+
+        for (n = 1; n < maxn; ++n)
+        {
+            dmax = n/2; 
+	    if (maxdeg < dmax) dmax = maxdeg;
+            dmin = mindeg - maxn + n + 1;
+	    if (dmin < 0) dmin = 0;
+            ncj = 1;
+	    nxsets = (dmin == 0 ? 1 : 0);
+            for (j = 1; j <= dmax; ++j)
+            {
+                ncj = (ncj * (n-j+1)) / j;
+                if (j >= dmin) nxsets += ncj;
+            }
+            tttn = 1L << n;
+
+            d = &data[n];
+
+            d->xset = xset = (xword*) calloc(nxsets,sizeof(xword));
+            d->xcard = xcard = (xword*) calloc(nxsets,sizeof(xword));
+            d->xinv = xinv = (xword*) calloc(tttn,sizeof(xword));
+            d->xorb = (xword*) calloc(nxsets,sizeof(xword));
+
+            if (xset==NULL || xcard==NULL || xinv==NULL || d->xorb==NULL)
+            {
+                fprintf(stderr,
+			">E gentourng: calloc failed in makeleveldata()\n");
+                exit(2);
+            }
+
+            j = 0;
+
+            for (i = 0;; ++i)
+	    {
+                if ((h = XPOPCOUNT(i)) <= dmax && h >= dmin)
+                {
+                    xset[j] = i;
+                    xcard[j] = h;
+                    ++j;
+                }
+		if (i == (xword)((1L<<n)-1)) break;
+	    }
+
+            if (j != nxsets)
+            {
+                fprintf(stderr,">E gentourng: j=%u mxsets=%u\n",
+                        j,(unsigned)nxsets);
+                exit(2);
+            }
+
+            h = 1;
+            do
+                h = 3 * h + 1;
+            while (h < nxsets);
+
+            do
+            {
+                for (i = h; i < nxsets; ++i)
+                {
+                    xw = xset[i];
+                    cw = xcard[i];
+                    for (j = i; xcard[j-h] > cw ||
+                                (xcard[j-h] == cw && xset[j-h] > xw); )
+                    {
+                        xset[j] = xset[j-h];
+                        xcard[j] = xcard[j-h];
+                        if ((j -= h) < h) break;
+                    }
+                    xset[j] = xw;
+                    xcard[j] = cw;
+                }
+                h /= 3;
+            }
+            while (h > 0);
+
+            for (i = 0; i < nxsets; ++i) xinv[xset[i]] = i;
+
+            d->xstart[0] = 0;
+            for (i = 1; i < nxsets; ++i)
+                if (xcard[i] > xcard[i-1]) d->xstart[xcard[i]] = i;
+            d->xstart[xcard[nxsets-1]+1] = nxsets;
+        }
+}
+
+/**************************************************************************/
+
+static void
+userautomproc(int count, int *p, int *orbits,
+              int numorbits, int stabvertex, int n)
+/* form orbits on powerset of VG
+   called by nauty;  operates on data[n] */
+{
+	xword i,j1,j2,moved,pi,pxi;
+        xword lo,hi;
+        xword *xorb,*xinv,*xset,w;
+
+        xorb = data[n].xorb;
+        xset = data[n].xset;
+        xinv = data[n].xinv;
+        lo = data[n].lo;
+        hi = data[n].hi;
+
+        if (count == 1)                         /* first automorphism */
+            for (i = lo; i < hi; ++i) xorb[i] = i;
+
+        moved = 0;
+        for (i = 0; i < n; ++i)
+            if (p[i] != i) moved |= xbit[i];
+
+        for (i = lo; i < hi; ++i)
+        {
+            if ((w = xset[i] & moved) == 0) continue;
+            pxi = xset[i] & ~moved;
+            while (w)
+            {
+                j1 = XNEXTBIT(w);
+                w ^= xbit[j1];
+                pxi |= xbit[p[j1]];
+            }
+            pi = xinv[pxi];
+
+            j1 = xorb[i];
+            while (xorb[j1] != j1) j1 = xorb[j1];
+            j2 = xorb[pi];
+            while (xorb[j2] != j2) j2 = xorb[j2];
+
+            if      (j1 < j2) xorb[j2] = xorb[i] = xorb[pi] = j1;
+            else if (j1 > j2) xorb[j1] = xorb[i] = xorb[pi] = j2;
+        }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  refinex(g,lab,ptn,level,numcells,count,active,goodret,code,m,n) is a      *
+*  custom version of refine() which can exit quickly if required.            *
+*                                                                            *
+*  Only use at level==0.                                                     *
+*  goodret : whether to do an early return for code 1                        *
+*  code := -1 for n-1 not max, 0 for maybe, 1 for definite                   *
+*                                                                            *
+*****************************************************************************/
+
+static void
+refinex(graph *g, int *lab, int *ptn, int level, int *numcells,
+     int *count, set *active, boolean goodret, int *code, int m, int n)
+{
+        int i,c1,c2,labc1;
+        setword x,lact;
+        int split1,split2,cell1,cell2;
+        int cnt,bmin,bmax;
+        set *gptr;
+        setword workset;
+        int workperm[MAXN];
+        int bucket[MAXN+2];
+
+        if (n == 1)
+        {
+            *code = 1;
+            return;
+        }
+
+        *code = 0;
+	lact = *active;
+
+        split1 = -1;
+        while (*numcells < n && lact)
+        {
+	    TAKEBIT(split1,lact);
+            
+            for (split2 = split1; ptn[split2] > 0; ++split2) {}
+            if (split1 == split2)       /* trivial splitting cell */
+            {
+                gptr = GRAPHROW(g,lab[split1],1);
+                for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+                {
+                    for (cell2 = cell1; ptn[cell2] > 0; ++cell2) {}
+                    if (cell1 == cell2) continue;
+
+                    c1 = cell1;
+                    c2 = cell2;
+                    while (c1 <= c2)
+                    {
+                        labc1 = lab[c1];
+                        if (ISELEMENT1(gptr,labc1))
+                            ++c1;
+                        else
+                        {
+                            lab[c1] = lab[c2];
+                            lab[c2] = labc1;
+                            --c2;
+                        }
+                    }
+                    if (c2 >= cell1 && c1 <= cell2)
+                    {
+                        ptn[c2] = 0;
+                        ++*numcells;
+			lact |= bit[c1];
+                    }
+                }
+            }
+
+            else        /* nontrivial splitting cell */
+            {
+                workset = 0;
+                for (i = split1; i <= split2; ++i) workset |= bit[lab[i]];
+
+                for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+                {
+                    for (cell2 = cell1; ptn[cell2] > 0; ++cell2) {}
+                    if (cell1 == cell2) continue;
+                    i = cell1;
+                    if ((x = workset & g[lab[i]]) != 0) cnt = POPCOUNT(x);
+                    else                                cnt = 0;
+                    count[i] = bmin = bmax = cnt;
+                    bucket[cnt] = 1;
+                    while (++i <= cell2)
+                    {
+                        if ((x = workset & g[lab[i]]) != 0)
+                            cnt = POPCOUNT(x);
+                        else
+                            cnt = 0;
+
+                        while (bmin > cnt) bucket[--bmin] = 0;
+                        while (bmax < cnt) bucket[++bmax] = 0;
+                        ++bucket[cnt];
+                        count[i] = cnt;
+                    }
+                    if (bmin == bmax) continue;
+                    c1 = cell1;
+                    for (i = bmin; i <= bmax; ++i)
+                        if (bucket[i])
+                        {
+                            c2 = c1 + bucket[i];
+                            bucket[i] = c1;
+                            if (c1 != cell1)
+                            {
+                                lact |= bit[c1];
+                                ++*numcells;
+                            }
+                            if (c2 <= cell2) ptn[c2-1] = 0;
+                            c1 = c2;
+                        }
+                    for (i = cell1; i <= cell2; ++i)
+                        workperm[bucket[count[i]]++] = lab[i];
+                    for (i = cell1; i <= cell2; ++i) lab[i] = workperm[i];
+                }
+            }
+
+            if (ptn[n-2] == 0)
+            {
+                if (lab[n-1] == n-1)
+                {
+                    *code = 1;
+                    if (goodret) return;
+                }
+                else
+                {
+                    *code = -1;
+                    return;
+                }
+            }
+            else
+            {
+                i = n - 1;
+                while (TRUE)
+                {
+                    if (lab[i] == n-1) break;
+                    --i;
+                    if (ptn[i] == 0)
+                    {
+                        *code = -1;
+                        return;
+                    }
+                }
+            }
+        }
+}
+
+/**************************************************************************/
+
+static void
+makecanon(graph *g, graph *gcan, int n)
+/* gcan := canonise(g) */
+{
+        int lab[MAXN],ptn[MAXN],orbits[MAXN];
+        static DEFAULTOPTIONS_GRAPH(options);
+        setword workspace[50];
+
+        options.getcanon = TRUE;
+        options.digraph = TRUE;
+
+        nauty(g,lab,ptn,NULL,orbits,&options,&nauty_stats,
+              workspace,50,1,n,gcan);
+}
+
+/**************************************************************************/
+
+static boolean
+accept1(graph *g, int n, xword x, graph *gx, int *deg, boolean *rigid)
+/* decide if n in theta(g+x) -  version for n+1 < maxn */
+{
+        int i;
+        int lab[MAXN],ptn[MAXN],orbits[MAXN];
+        int count[MAXN];
+        graph h[MAXN];
+        int nx,numcells,code;
+        int i0,i1,degn;
+        set active[MAXM];
+        statsblk stats;
+        static DEFAULTOPTIONS_GRAPH(options);
+        setword workspace[50];
+
+#ifdef INSTRUMENT
+        ++a1calls;
+#endif
+
+        nx = n + 1;
+        for (i = 0; i < n; ++i) gx[i] = g[i];
+        gx[n] = 0;
+        deg[n] = degn = XPOPCOUNT(x);
+
+        for (i = 0; i < n; ++i)
+	{
+	    if ((xbit[i] & x))
+		gx[n] |= bit[i];
+	    else
+	    {
+		gx[i] |= bit[n];
+		++deg[i];
+	    }
+	}
+
+#ifdef PREPRUNE
+	if (PREPRUNE(gx,n+1,maxn)) return FALSE;
+#endif
+
+        i0 = 0;
+        i1 = n;
+        for (i = 0; i < nx; ++i)
+        {
+            if (deg[i] == degn) lab[i1--] = i;
+            else                lab[i0++] = i;
+            ptn[i] = 1;
+        }
+        ptn[n] = 0;
+        if (i0 == 0)
+        {
+            numcells = 1;
+            active[0] = bit[0];
+        }
+        else
+        {
+            numcells = 2;
+            active[0] = bit[0] | bit[i1+1];
+            ptn[i1] = 0;
+        }
+        refinex(gx,lab,ptn,0,&numcells,count,active,FALSE,&code,1,nx);
+
+        if (code < 0) return FALSE;
+
+        if (numcells == nx)
+        {
+            *rigid = TRUE;
+#ifdef INSTRUMENT
+            ++a1succs;
+#endif
+            return TRUE;
+        }
+
+        options.getcanon = TRUE;
+        options.digraph = TRUE;
+        options.defaultptn = FALSE;
+	options.userautomproc = userautomproc;
+     /*
+        if (!regular || nx != maxn-1) options.userautomproc = userautomproc;
+	else                          options.userautomproc = NULL;
+     */
+
+        active[0] = 0;
+#ifdef INSTRUMENT
+        ++a1nauty;
+#endif
+        nauty(gx,lab,ptn,active,orbits,&options,&stats,workspace,50,1,nx,h);
+
+        if (orbits[lab[n]] == orbits[n])
+        {
+            *rigid = stats.numorbits == nx;
+#ifdef INSTRUMENT
+            ++a1succs;
+#endif
+            return TRUE;
+        }
+        else
+            return FALSE;
+}
+
+/**************************************************************************/
+
+static boolean
+hitinvar(graph *g, int *invar, int n)
+/* make hitting invariant
+ *    return FALSE if n-1 not maximal else return TRUE */
+{
+        setword x,y,z;
+        int inv,i,v,d;
+
+        for (v = n-1; v >= 0; --v)
+        {
+            inv = 0;
+            x = y = g[v];
+	    while (y)
+	    {
+		TAKEBIT(i,y);
+		z = x & g[i];
+		d = POPCOUNT(z);
+		if (d > inv) inv = d;
+	    }
+
+            invar[v] = inv;
+            if (v < n-1 && inv > invar[n-1]) return FALSE;
+        }
+        return TRUE;
+}
+
+/**************************************************************************/
+
+static boolean
+accept2(graph *g, int n, xword x, graph *gx, int *deg, boolean nuniq)
+/* decide if n in theta(g+x)  --  version for n+1 == maxn */
+{
+        int i;
+        int lab[MAXN],ptn[MAXN],orbits[MAXN];
+        int degx[MAXN],invar[MAXN];
+        setword vmax,gv,gxn;
+        int qn,qv;
+        int count[MAXN];
+        int nx,numcells,code;
+        int degn,i0,i1,j,j0,j1;
+        set active[MAXM];
+        statsblk stats;
+        static DEFAULTOPTIONS_GRAPH(options);
+        setword workspace[50];
+	boolean cheapacc;
+
+#ifdef INSTRUMENT
+        ++a2calls;
+        if (nuniq) ++a2uniq;
+#endif
+        nx = n + 1;
+        gxn = 0;
+
+        for (i = 0; i < n; ++i)
+	{
+	    if ((xbit[i] & x))
+	    {
+		gxn |= bit[i];
+		gx[i] = g[i];
+		degx[i] = deg[i];
+	    }
+	    else
+	    {
+		gx[i] = g[i] | bit[n];
+		degx[i] = deg[i] + 1;
+	    }
+	}
+	gx[n] = gxn;
+        degx[n] = degn = XPOPCOUNT(x);
+	    
+#ifdef PREPRUNE
+        if (PREPRUNE(gx,n+1,maxn)) return FALSE;
+#endif
+
+        if (nuniq)
+        {
+#ifdef INSTRUMENT
+            ++a2succs;
+#endif
+            if (canonise) makecanon(gx,gcan,nx);
+            return TRUE;
+        }
+
+        i0 = 0;
+        i1 = n;
+        for (i = 0; i < nx; ++i)
+        {
+            if (degx[i] == degn) lab[i1--] = i;
+            else                 lab[i0++] = i;
+            ptn[i] = 1;
+        }
+        ptn[n] = 0;
+        if (i0 == 0)
+        {
+            numcells = 1;
+            active[0] = bit[0];
+            if (!hitinvar(gx,invar,nx)) return FALSE;
+            qn = invar[n];
+            j0 = 0;
+            j1 = n;
+            while (j0 <= j1)
+            {
+                j = lab[j0];
+                qv = invar[j];
+                if (qv < qn)
+                    ++j0;
+                else
+                {
+                    lab[j0] = lab[j1];
+                    lab[j1] = j;
+                    --j1;
+                }
+            }
+            if (j0 > 0)
+            {
+                if (j0 == n)
+                {
+#ifdef INSTRUMENT
+                    ++a2succs;
+#endif
+                    if (canonise) makecanon(gx,gcan,nx);
+                    return TRUE;
+                }
+                ptn[j1] = 0;
+                ++numcells;
+                active[0] |= bit[j0];
+            }
+        }
+        else
+        {
+            numcells = 2;
+            ptn[i1] = 0;
+            active[0] = bit[0] | bit[i1+1];
+
+            vmax = 0;
+            for (i = i1+1; i < nx; ++i) vmax |= bit[lab[i]];
+
+            gv = gx[n] & vmax;
+            qn = POPCOUNT(gv);
+
+            j0 = i1+1;
+            j1 = n;
+            while (j0 <= j1)
+            {
+                j = lab[j0];
+                gv = gx[j] & vmax;
+                qv = POPCOUNT(gv);
+                if (qv > qn)
+                    return FALSE;
+                else if (qv < qn)
+                    ++j0;
+                else
+                {
+                    lab[j0] = lab[j1];
+                    lab[j1] = j;
+                    --j1;
+                }
+            }
+            if (j0 > i1+1)
+            {
+                if (j0 == n)
+                {
+#ifdef INSTRUMENT
+                    ++a2succs;
+#endif
+                    if (canonise) makecanon(gx,gcan,nx);
+                    return TRUE;
+                }
+                ptn[j1] = 0;
+                ++numcells;
+                active[0] |= bit[j0];
+            }
+        }
+
+        refinex(gx,lab,ptn,0,&numcells,count,active,TRUE,&code,1,nx);
+
+        if (code < 0) return FALSE;
+
+	cheapacc = FALSE;
+	if (code > 0) cheapacc = TRUE;
+    
+        if (cheapacc)
+        {
+#ifdef INSTRUMENT
+            ++a2succs;
+#endif
+            if (canonise) makecanon(gx,gcan,nx);
+            return TRUE;
+        }
+
+        options.getcanon = TRUE;
+        options.digraph = TRUE;
+        options.defaultptn = FALSE;
+
+        active[0] = 0;
+#ifdef INSTRUMENT
+        ++a2nauty;
+#endif
+        nauty(gx,lab,ptn,active,orbits,&options,&stats,workspace,50,1,nx,gcan);
+
+        if (orbits[lab[n]] == orbits[n])
+        {
+#ifdef INSTRUMENT
+            ++a2succs;
+#endif
+            if (canonise) makecanon(gx,gcan,nx);
+            return TRUE;
+        }
+        else
+            return FALSE;
+}
+
+/**************************************************************************/
+
+static void
+genextend(graph *g, int n, int *deg, boolean rigid)
+/* extend from n to n+1 -- version for general graphs */
+{
+        xword x,dlow,dhigh,dcrit;
+        xword *xset,*xcard,*xorb;
+	xword i,imin,imax;
+        int nx,xc,j,dmax;
+        int xlb,xub,xlbx,xubx;
+        graph gx[MAXN];
+        int degx[MAXN];
+        boolean rigidx;
+	boolean subconnec;
+
+#ifdef INSTRUMENT
+        boolean haschild;
+
+        haschild = FALSE;
+        if (rigid) ++rigidnodes[n];
+#endif
+        nx = n + 1;
+        ++nodes[n];
+
+	if (regular && nx == maxn)
+	{
+	    x = 0;
+	    for (i = 0; i < n; ++i)
+		if (deg[i] == maxdeg) x |= xbit[i];
+
+            if (accept2(g,n,x,gx,deg,FALSE))
+            {
+#ifdef PRUNE
+                if (!PRUNE(gx,nx,maxn))
+#endif
+		{
+#ifdef INSTRUMENT
+                    haschild = TRUE;
+#endif
+		    ++nout;
+                    (*outproc)(outfile,canonise ? gcan : gx,nx);
+		}
+            }
+#ifdef INSTRUMENT
+            if (haschild) ++fertilenodes[n];
+#endif
+	    return;
+	}
+
+        dmax = deg[n-1];
+
+	xlb = mindeg + n + 1 - maxn;
+	if (0 > xlb) xlb = 0;
+	xub = dmax+1;
+	if (n/2 < xub) xub = n/2;
+	if (maxdeg < xub) xub = maxdeg;
+
+	if (xlb > xub) return;
+
+        dlow = dcrit = dhigh = 0;
+        for (i = 0; i < n; ++i)
+	{
+            if (deg[i] == dmax) dlow |= xbit[i];
+	    if (deg[i] == maxdeg) dhigh |= xbit[i];
+	    if (deg[i] == mindeg + n - maxn) dcrit |= xbit[i];
+	}
+
+        if (XPOPCOUNT(dhigh) > xlb) xlb = XPOPCOUNT(dhigh);
+	if (n-XPOPCOUNT(dcrit) < xub) xub = n - XPOPCOUNT(dcrit);
+	if (xub == dmax+1 && XPOPCOUNT(dlow)+dmax >= n) --xub;
+        if (xlb > xub) return;
+
+#ifdef PRUNE 
+        if (PRUNE(g,n,maxn)) return; 
+#endif 
+
+        imin = data[n].xstart[xlb];
+        imax = data[n].xstart[xub+1];
+        xset = data[n].xset;
+        xcard = data[n].xcard;
+        xorb = data[n].xorb;
+
+        if (nx == maxn)
+	{
+	    subconnec = connec && isstrong(g,n);
+            for (i = imin; i < imax; ++i)
+            {
+                if (!rigid && xorb[i] != i) continue;
+                x = xset[i];
+                xc = xcard[i];
+                if (xc == dmax+1 && (x & dlow) != 0) continue;
+ 		if ((dhigh & ~x) != 0) continue;
+		if ((dcrit & x) != 0) continue;
+
+                if (accept2(g,n,x,gx,deg,
+                            xc < dmax || (xc == dmax && (x & dlow) == 0)))
+                    if (!connec || (subconnec && x != 0) || isstrong(gx,nx))
+                    {
+#ifdef PRUNE
+                        if (!PRUNE(gx,nx,maxn))
+#endif
+			{
+#ifdef INSTRUMENT
+                            haschild = TRUE;
+#endif
+			    ++nout;
+                            (*outproc)(outfile,canonise ? gcan : gx,nx);
+			}
+                    }
+            }
+	}
+        else
+	{
+            for (i = imin; i < imax; ++i)
+            {
+                if (!rigid && xorb[i] != i) continue;
+                x = xset[i];
+                xc = xcard[i];
+                if (xc == dmax+1 && (x & dlow) != 0) continue;
+ 		if ((dhigh & ~x) != 0) continue;
+		if ((dcrit & x) != 0) continue;
+                if (nx == splitlevel)
+                {
+                    if (odometer-- != 0) continue;
+                    odometer = mod - 1;
+                }
+
+                for (j = 0; j < n; ++j) degx[j] = deg[j];
+                xlbx = mindeg+nx+1-maxn;
+		if (xlbx < 0) xlbx = 0;
+		xubx = xc + 1;
+		if (maxdeg < xubx) xubx = maxdeg;
+		if (nx/2 < xubx) xubx = nx/2;
+                if (xlbx > xubx) continue;
+
+                data[nx].lo = data[nx].xstart[xlbx];
+                data[nx].hi = data[nx].xstart[xubx+1];
+                if (accept1(g,n,x,gx,degx,&rigidx))
+                {
+#ifdef INSTRUMENT
+                    haschild = TRUE;
+#endif
+                    genextend(gx,nx,degx,rigidx);
+                }
+            }
+	}
+
+        if (n == splitlevel-1 && n >= min_splitlevel
+                && nodes[n] >= multiplicity)
+            --splitlevel;
+#ifdef INSTRUMENT
+        if (haschild) ++fertilenodes[n];
+#endif
+}
+
+/**************************************************************************/
+/**************************************************************************/
+
+int
+#ifdef GENG_MAIN
+GENG_MAIN(int argc, char *argv[])
+#else
+main(int argc, char *argv[])
+#endif
+{
+        char *arg;
+        boolean badargs,gotd,gotD,gotf,gotmr;
+	boolean secret,connec1;
+	char *outfilename,sw;
+        int i,j,argnum;
+        graph g[1];
+        int deg[1];
+	int splitlevinc;
+        double t1,t2;
+	char msg[201];
+
+	HELP; PUTVERSION;
+	nauty_check(WORDSIZE,1,MAXN,NAUTYVERSIONID);
+
+	if (MAXN > 32 || MAXN > WORDSIZE || MAXN > 8*sizeof(xword))
+	{
+	    fprintf(stderr,
+		    "gentourng: incompatible MAXN, WORDSIZE, or xword\n");
+	    fprintf(stderr,"--See notes in program source\n");
+	    exit(1);
+	}
+
+        badargs = FALSE;
+	graph6 = FALSE;
+	digraph6 = FALSE;
+	sparse6 = FALSE;
+        nooutput = FALSE;
+        canonise = FALSE;
+	header = FALSE;
+	outfilename = NULL;
+	secret = FALSE;
+	connec1 = FALSE;
+
+        maxdeg = MAXN; 
+	mindeg = 0;
+	splitlevinc = 0;
+	
+	gotd = gotD = gotf = gotmr = FALSE;
+
+        argnum = 0;
+        for (j = 1; !badargs && j < argc; ++j)
+        {
+            arg = argv[j];
+            if (arg[0] == '-' && arg[1] != '\0')
+            {
+		++arg;
+		while (*arg != '\0')
+		{
+		    sw = *arg++;
+		         SWBOOLEAN('u',nooutput)
+		    else SWBOOLEAN('g',graph6)
+		    else SWBOOLEAN('z',digraph6)
+		    else SWBOOLEAN('s',sparse6)
+		    else SWBOOLEAN('l',canonise)
+		    else SWBOOLEAN('h',header)
+		    else SWBOOLEAN('q',quiet)
+		    else SWBOOLEAN('c',connec1)
+		    else SWBOOLEAN('$',secret)
+		    else SWINT('d',gotd,mindeg,"gentourng -d")
+		    else SWINT('D',gotD,maxdeg,"gentourng -D")
+#ifdef PLUGIN_SWITCHES
+PLUGIN_SWITCHES
+#endif
+                    else badargs = TRUE;
+		}
+            }
+            else if (arg[0] == '-' && arg[1] == '\0')
+		gotf = TRUE;
+	    else
+            {
+                if (argnum == 0)
+                {
+                    if (sscanf(arg,"%d",&maxn) != 1) badargs = TRUE;
+		    ++argnum;
+		}
+		else if (gotf)
+		    badargs = TRUE;
+		else
+		{
+		    if (!gotmr)
+		    {
+			if (sscanf(arg,"%d/%d",&res,&mod) == 2)
+                        { 
+                            gotmr = TRUE; 
+                            continue; 
+                        }
+		    }
+		    if (!gotf)
+		    {
+			outfilename = arg;
+			gotf = TRUE;
+			continue;
+		    }
+                }
+            }
+        }
+
+        if (argnum == 0)
+            badargs = TRUE;
+        else if (maxn < 1 || maxn > MAXN)
+        {
+            fprintf(stderr,">E gentourng: n must be in the range 1..%d\n",MAXN);
+            badargs = TRUE;
+        }
+
+        if (!gotmr)
+        {
+            mod = 1;
+            res = 0;
+        }
+
+	if (connec1) connec = 1;
+	else         connec = 0;
+
+        if (maxdeg >= maxn) maxdeg = maxn - 1;
+	if (mindeg < 0) mindeg = 0;
+
+	if (!badargs &&
+	     (maxdeg < mindeg || 2*maxdeg < maxn-1 || 2*mindeg > maxn-1))
+	{
+            fprintf(stderr,">E gentourng: impossible degree bounds\n");
+            badargs = TRUE;
+        }
+
+	if (connec && mindeg < 1 && maxn > 1) mindeg = 1;
+        if (connec && maxdeg == maxn-1 && maxn > 1) maxdeg = maxn - 2;
+
+        if (!badargs && (res < 0 || res >= mod))
+        {
+            fprintf(stderr,">E gentourng: must have 0 <= res < mod\n");
+            badargs = TRUE;
+        }
+
+        if (badargs)
+        {
+            fprintf(stderr,">E Usage: %s\n",USAGE);
+	    GETHELP;
+            exit(1);
+        }
+
+	if ((graph6!=0) + (sparse6!=0) + (digraph6!=0) + (nooutput!=0) > 1)
+	    gt_abort(">E gentourng: -ungzs are incompatible\n");
+
+#ifdef OUTPROC
+        outproc = OUTPROC;
+#else
+        if      (nooutput) outproc = nullwrite;
+	else if (sparse6)  outproc = writes6x;
+        else if (graph6)   outproc = writeg6x;
+        else if (digraph6) outproc = writed6x;
+	else               outproc = write_ascii;
+#endif
+
+#ifdef PLUGIN_INIT
+PLUGIN_INIT
+#endif
+
+	for (i = 0; i < maxn; ++i)  nodes[i] = 0;
+
+	if (nooutput)
+	    outfile = stdout;
+	else if (!gotf || outfilename == NULL)
+	{
+            outfilename = "stdout";
+            outfile = stdout;
+        }
+        else if ((outfile = fopen(outfilename,"w")) == NULL)
+        {
+            fprintf(stderr,
+                  ">E gentourng: can't open %s for writing\n",outfilename);
+            gt_abort(NULL);
+        }
+
+        multiplicity = PRUNEMULT * mod;
+
+	if (!quiet)
+	{
+	    msg[0] = '\0';
+	    if (strlen(argv[0]) > 75)
+		fprintf(stderr,">A %s",argv[0]);
+	    else
+		CATMSG1(">A %s",argv[0]);
+	   
+	    CATMSG2(" -%s%s",connec1  ? "c" : "",canonise ? "l" : "");
+	 /*
+	    if (mod > 1)
+		CATMSG2("X%dx%d",splitlevinc,multiplicity);
+	 */
+	    CATMSG3("d%dD%d n=%d",mindeg,maxdeg,maxn);
+	    if (mod > 1) CATMSG2(" class=%d/%d",res,mod);
+	    CATMSG0("\n");
+	    fputs(msg,stderr);
+	    fflush(stderr);
+	}
+
+        g[0] = 0;
+        deg[0] = 0;
+
+        t1 = CPUTIME;
+
+	if (header)
+	{
+	    if (sparse6)
+	    {
+                writeline(outfile,SPARSE6_HEADER);
+		fflush(outfile);
+	    }
+	    else if (!nooutput)
+	    {
+		writeline(outfile,GRAPH6_HEADER);
+		fflush(outfile);
+	    }
+	}
+
+        nout = 0;
+
+        if (maxn == 1)
+        {
+            if (res == 0)
+            {
+                ++nout;
+                (*outproc)(outfile,g,1);
+            }
+        }
+        else
+        {
+            makeleveldata();
+
+	    if (maxn >= 14 && mod > 1)     splitlevel = maxn - 4;
+	    else if (maxn >= 6 && mod > 1) splitlevel = maxn - 3;
+	    else                           splitlevel = -1;
+
+	    splitlevel += splitlevinc;
+	    if (splitlevel > maxn - 1) splitlevel = maxn - 1;
+	    if (splitlevel < 3) splitlevel = -1;
+
+	    min_splitlevel = 6;
+	    odometer = secret ? -1 : res;
+	    regular = mindeg == maxdeg;
+	    if (regular) connec = FALSE; /* All reg tourns are strong! */
+
+            genextend(g,1,deg,TRUE);
+	}
+        t2 = CPUTIME;
+
+#ifdef INSTRUMENT
+        fprintf(stderr,"\n>N node counts\n");
+        for (i = 1; i < maxn; ++i)
+	{
+            fprintf(stderr," level %2d: \n",i);
+	    fprintf(stderr,COUNTER_FMT " (%lu rigid, %lu fertile)\n",
+                           nodes[i],rigidnodes[i],fertilenodes[i]);
+	}
+        fprintf(stderr,">A1 %lu calls to accept1, %lu nauty, %lu succeeded\n",
+                        a1calls,a1nauty,a1succs);
+        fprintf(stderr,
+             ">A2 %lu calls to accept2, %lu nuniq, %lu nauty, %lu succeeded\n",
+                        a2calls,a2uniq,a2nauty,a2succs);
+        fprintf(stderr,"\n");
+#endif
+
+#ifdef SUMMARY
+	SUMMARY(nout,t2-t1);
+#endif
+
+	if (!quiet)
+	{
+            fprintf(stderr,">Z " COUNTER_FMT " graphs generated in %3.2f sec\n",
+                    nout,t2-t1);
+	}
+
+#ifdef GENG_MAIN
+	for (i = 1; i < maxn; ++i)
+	{
+	    free(data[i].xorb);
+	    free(data[i].xset);
+	    free(data[i].xinv);
+	    free(data[i].xcard);
+	}
+	return 0;
+#else
+        exit(0);
+#endif
+}
diff --git a/lib/nauty/gentreeg.c b/lib/nauty/gentreeg.c
new file mode 100644
index 0000000..02b7f55
--- /dev/null
+++ b/lib/nauty/gentreeg.c
@@ -0,0 +1,628 @@
+/* gentree version 1.2; Brendan McKay Aug 2017 */
+/* This program is a wrapper for the program FreeTrees.c written
+ * by Gang Li & Frank Ruskey.  See below for their original
+ * comments. */
+
+#define USAGE \
+ "gentreeg [-D#] [-Z#:#] [-ulps] [-q] n [res/mod] [file]"
+
+#define HELPTEXT \
+" Generate (unrooted) trees.\n\
+\n\
+      n    : the number of vertices\n\
+   res/mod : only generate subset res out of subsets 0..mod-1\n\
+\n\
+     -D#   : an upper bound for the maximum degree\n\
+     -Z#:# : bounds for the diameter\n\
+\n\
+     -s    : use sparse6 output (default)\n\
+     -p    : write a parent array\n\
+     -l    : write a level array \n\
+     -u    : do not output any graphs, just generate and count them\n\
+\n\
+     -q    : suppress auxiliary output\n\
+\n\
+  See program text for much more information.\n"
+
+/* Comments on original program by original authors */
+/*==============================================================*/
+/* program: freetree.c                                          */
+/* purpose: generating all free trees                           */
+/* input  : n -- number of nodes                                */
+/*          m -- max degree                                     */
+/*          lb,ub -- lower and upper bound on diameter          */
+/*          res/mod -- splitting into parts                     */
+/* output : listing of free trees in relex order                */ 
+/* date   : September 1995, updated Sept 2000                   */
+/* programmers: Gang Li & Frank Ruskey                          */
+/* algorithm: From the paper: G. Li and F. Ruskey,  "The        */
+/*    Advantages of Forward Thinking in Generating Rooted and   */
+/*    Free Trees",  10th Annual ACM-SIAM Symposium on Discrete  */
+/*    Algorithms (SODA), (1999) S939-940.  See the web page at  */
+/*    http://www.theory.csc.UVic.CA/~fruskey/                   */
+/*      Publications/RootedFreeTree.html                        */
+/* more info: See                                               */
+/*    http://www.theory.csc.UVic.CA/~cos/inf/FreeTrees.html     */
+/*==============================================================*/
+
+#define MAXN  128  /* max size of the tree.
+	              Check MAXOUTLEN if more than 1000 */
+#include "gtools.h"
+
+/*****************************************************************
+
+OUTPROC feature.
+
+   By defining the C preprocessor variable OUTPROC at compile time
+   (for Unix the syntax is  -DOUTPROC=procname  on the cc command),
+   gentreeg can be made to call
+       void OUTPROC(FILE *f, int *par, int n)
+   instead of the usual output routines.
+
+   par[1..n] is the parent array of the tree.
+   The edges in 1..n labelling are {j,par[j]} for j=2..n.
+   WARNING: The vertices are 1..n, not 0..n-1, and also par[]
+   uses elements 1..n, not 0..n-1.
+
+   Your procedure can be in a separate file so long as it is linked
+   with gentreeg. 
+
+PRUNE feature.
+
+   By defining the C preprocessor variable PRUNE at compile time,
+   gentreeg can be made to call
+        int PRUNE(int *par, int n)
+   for each tree.  The meaning of par[] is above and n is the number
+   of vertices.  If a non-zero value is returned, the tree is rejected:
+   it is not included in the count, and output routines including
+   OUTPROC are not called.
+
+SUMMARY
+
+   If the C preprocessor variable SUMMARY is defined at compile
+   time, the procedure/macro SUMMARY(nauty_counter nout, double cpu)
+   is called just before the program exits. The purpose is to allow
+   reporting of statistics collected by PRUNE or OUTPROC. The values
+   nout and cpu are the output count and cpu time as reported on the
+   >Z line. Output should be written to stderr.
+
+CALLING FROM A PROGRAM
+
+   It is possible to call gentreeg from another program instead of
+   using it as a stand-alone program. The main requirement is to
+   change the name of the main program to be other than "main". This
+   is done by defining the preprocessor variable GENTREEG_MAIN. You
+   might also like to define OUTPROC to be the name of a procedure
+   to receive the graphs. To call the program you need to define an
+   argument list argv[] consistent with the usual one; don't forget
+   that argv[0] is the command name and not the first argument. The
+   value of argc is the number of strings in argv[]; that is, one
+   more than the number of arguments.
+*/
+
+static int
+ par[MAXN+1],                 /* parent position of i  */
+ maxchild,                    /* max number of children */
+ chi[MAXN+1],                 /* number of children of a node */
+ nextp[MAXN+1],               /* next good pos to add nodes */
+ rChi[MAXN+1],                /* the right most child of node i */
+ ub;                          /* upper bound on something */
+
+static nauty_counter nout;                 /* number of trees */
+static FILE *outfile;
+
+static int splitlevel,splitcount,mod,res;   /* -s res/mod */
+
+static int nv;  /* number of vertices */
+static int mindiam; 
+static int maxdeg; 
+static int maxdiam;
+
+/* MAXOUTLEN must be at least the longest output line length */
+#define MAXOUTLEN (10 + 4*MAXN)
+static char outstring[MAXOUTLEN];
+
+void (*outproc)(FILE *f, int vpar[], int n);
+#ifdef OUTPROC
+extern void OUTPROC(FILE *f, int vpar[], int n);
+#endif
+#ifdef PRUNE
+extern int PRUNE(int vpar[], int n);
+#endif
+
+void WritePar(FILE *f, int vpar[], int n)
+/* Write parent array */
+{
+   int i,j;
+   char *pout,*p,one[8];
+   size_t len;
+
+   pout = outstring;
+
+   for (i=1;i<=nv;++i) {
+       j = vpar[i];
+       if (j == 0) *(pout++) = '0';
+       else {
+	  for (p = one; j > 0; j /= 10)
+	      *(p++) = '0' + j%10;
+	  while (--p >= one) *(pout++) = *p;
+       }
+       if (i < nv) *(pout++) = ' ';
+       else       *(pout++) = '\n';
+   }
+   len = pout - outstring;
+
+   if (fwrite(outstring,sizeof(char),len,f) != len)
+        gt_abort(">E gentreeg: fwrite() failed\n");
+}
+
+static void
+WriteLev(FILE *f, int vpar[], int n)
+/* Write levels array */
+{
+   int i,j;
+   char *pout,*p,one[8];
+   size_t len;
+   int lev[MAXN+1];
+
+   lev[1]=0;
+   for ( i=2; i<=nv; ++i ) lev[i] = lev[vpar[i]]+1;
+
+   pout = outstring;
+
+   for (i=1;i<=nv;++i) {
+       j = lev[i];
+       if (j == 0) *(pout++) = '0';
+       else {
+	  for (p = one; j > 0; j /= 10)
+	      *(p++) = '0' + j%10;
+	  while (--p >= one) *(pout++) = *p;
+       }
+       if (i < nv) *(pout++) = ' ';
+       else       *(pout++) = '\n';
+   }
+   len = pout - outstring;
+
+   if (fwrite(outstring,sizeof(char),len,f) != len)
+        gt_abort(">E gentreeg: fwrite() failed\n");
+}
+
+static void
+DontWrite(FILE *f, int vpar[], int n)
+/* Null print routine */
+{
+}
+
+static void
+WriteS6(FILE *f, int vpar[], int n)
+/* Write in sparse6 format */
+{
+    char *pout;
+    int nb,i,j,lastj,x,k,r,rr,topbit;
+    size_t len;
+
+    pout = outstring;
+    *pout++ = ':';
+    encodegraphsize(n,&pout);
+
+    for (i = n-1, nb = 0; i != 0 ; i >>= 1, ++nb) {}
+    topbit = 1 << (nb-1);
+    k = 6;
+    x = 0;
+
+    lastj = 0;
+    for (j = 1; j < n; ++j)
+    {
+        i = vpar[j+1] - 1;
+        if (j == lastj)
+        {
+            x <<= 1;
+            if (--k == 0)
+            {
+                *pout++ = 63 + x;
+                k = 6;
+                x = 0;
+            }
+        }
+        else
+        {
+            x = (x << 1) | 1;
+            if (--k == 0)
+            {
+                *pout++ = 63 + x;
+                k = 6;
+                x = 0;
+            }
+            if (j > lastj+1)
+            {
+                for (r = 0, rr = j; r < nb; ++r, rr <<= 1)
+                {
+                    if (rr & topbit) x = (x << 1) | 1;
+                    else             x <<= 1;
+                    if (--k == 0)
+                    {
+                        *pout++ = 63 + x;
+                        k = 6;
+                        x = 0;
+                    }
+                }
+                x <<= 1;
+                if (--k == 0)
+                {
+                    *pout++ = 63 + x;
+                    k = 6;
+                    x = 0;
+                }
+            }
+            lastj = j;
+        }
+        for (r = 0, rr = i; r < nb; ++r, rr <<= 1)
+        {
+            if (rr & topbit) x = (x << 1) | 1;
+            else             x <<= 1;
+            if (--k == 0)
+            {
+                *pout++ = 63 + x;
+                k = 6;
+                x = 0;
+            }
+        }
+    }
+
+    if (k != 6) *pout++ = 63 + ((x << k) | ((1 << k) - 1));
+
+    *pout++ = '\n';
+    len = pout - outstring;
+
+    if (fwrite(outstring,sizeof(char),len,f) != len)
+        gt_abort(">E gentreeg: fwrite() failed\n");
+}
+
+static void
+WriteIt(int level)
+{
+   int i;
+
+   if (level < splitlevel && res != 0) return;
+
+#ifdef PRUNE
+   if (PRUNE(par,nv)) return;
+#endif
+
+   ++nout;
+   (*outproc)(outfile,par,nv);
+}
+
+static boolean
+good( int p, int h, int t ) {
+  if (p==2 && mindiam<=2 && t==0) return TRUE;
+  if (t == 1) {
+     if (2*h>=mindiam+1 && 2*h <= maxdiam+1) {
+        if ((p-1)*2 >= nv) return TRUE;  
+        else if (p - h-1 == 1) {
+          if (par[p]> 2) return TRUE;
+        } else
+          if ((p - h-1 >=2) && ((par[h+2]>2) || (par[h+3]>2))) return TRUE;
+     }
+  } else 
+  if (nv-p >= h && 2*h>=mindiam) { 
+     if (maxdiam==nv-1 && nv%2==0) return 2*h<=maxdiam+1; 
+     else return 2*h <= maxdiam;
+  }
+  return FALSE;
+} /* good */   
+
+
+static void
+Gen( int level, int p, int s, int cL, int h, int l, int n, int f, int g )
+/* The main generation procedure. */
+{
+  int hh,flag,entry,temp;
+
+  if (level == splitlevel)
+  {
+      if (splitcount-- != 0) return;
+      splitcount = mod - 1;
+  }
+
+  if (p > n) 
+     if (f == 0) {
+        if (good(p-1,h,0)) Gen(level+1, p, 2, p-2,h,n,nv,1,0); 
+        if (good(p-1,h,1)) Gen(level+1, p, 2, p-3,h,n,nv,1,1);
+     } else { WriteIt(level);}
+  else {
+     if (cL == 0) {
+        if ( p< ub+2 ) par[p] = p-1;
+        else {
+           Gen(level+1, p, p-1, 1, h, l, n, f, g );
+           return; 
+        }
+     } else  
+        if (par[p-cL] < s) par[p]=par[p-cL];       
+        else {
+           par[p] = cL + par[p-cL];
+           if (g==1) 
+	   {
+               if (((l-1)*2 < n) && (p-cL<=l) && (
+                   ((p-cL+1<l) &&  (par[p-cL+1]==2)  
+                   && (p-cL+2<=l) && (par[p-cL+2]==2))     /*case 1*/
+                   || ((p-cL+1==l) && (par[p-cL+1]==2))    /*case 2*/
+                   || (p-cL+1>l))) {                       /*case 3*/
+                  s= par[p]; cL= p-s;
+                  par[p] = par[par[p]];
+               } else 
+                  if (par[p-cL]==2) par[p]=1;  
+           }
+        }
+        if (s!=0 || p<=ub+1) {
+           chi[par[p]] = chi[par[p]] + 1;
+           temp = rChi[par[p]]; rChi[par[p]] = p;
+           if (chi[par[p]] <= ((par[p]==1)?maxchild:maxchild-1)) {
+              if (chi[par[p]] < (par[p]==1?maxchild:maxchild-1)) nextp[p] = par[p];
+              else nextp[p] = nextp[par[p]];
+              Gen(level+1, p+1, s, cL,h,l,n,f,g ); 
+           }
+           chi[par[p]] = chi[par[p]] - 1;
+           rChi[par[p]] = temp;
+        }
+        if (s==0 && 2*(p-2)<mindiam) return;
+
+        nextp[p] = nextp[par[p]];
+        entry = nextp[p];
+        flag= 0; hh=1;
+        while ((((f==0) && (entry>=2)) ||
+	       ((f==1) && (entry>=1))) && (flag==0)) {
+           if (s==0) h = p-2;
+           if (p<=l+h-g) hh = 0; 
+           if ((f==0) || (hh==1)) {
+              /*s = par[p]; par[p] = par[s];*/
+              par[p] = entry;
+
+              chi[entry] = chi[entry] + 1;
+	      temp = rChi[par[p]];  rChi[par[p]] = p;
+	      if (chi[entry] >= (entry==1?maxchild:maxchild-1)) nextp[p] = nextp[entry];
+              if (f == 0) Gen(level+1,p+1,temp,p-temp,h,0,nv-h+1,f,g);
+              else if (hh == 1) Gen(level+1,p+1,temp,p-temp,h,l,n,f,g);
+	      chi[entry] = chi[entry] - 1;
+	      rChi[par[p]] = temp;
+	      entry = nextp[entry];
+	      nextp[p] = entry;
+           } else flag= 1;
+        }
+        if (f == 0) {
+           if (good(p-1,h,0)) Gen(level+1,p,2,p-2,h,p-1,nv,1,0);
+           if (good(p-1,h,1)) Gen(level+1,p,2,p-3,h,p-1,nv,1,1);
+        }
+  }
+} /* Gen */
+
+/**************************************************************************/
+/**************************************************************************/
+
+#ifdef GENTREEG_MAIN
+int
+GENTREEG_MAIN(int argc, char *argv[])
+#else
+int
+main(int argc, char *argv[])
+#endif
+{
+        char *arg;
+        boolean badargs,uswitch,sswitch,pswitch,lswitch,Zswitch;
+        boolean qswitch,Dswitch,gotmr,gotf;
+        long Z1,Z2;
+	char *outfilename,sw;
+        int i,j,argnum;
+	int splitlevinc;
+        double t1,t2;
+	char msg[201];
+
+	HELP; PUTVERSION;
+
+        badargs = FALSE;
+	uswitch = sswitch = pswitch = lswitch = Zswitch = FALSE;
+        qswitch = Dswitch = gotmr = gotf = FALSE;
+	outfilename = NULL;
+
+	splitlevinc = 0;
+	
+        argnum = 0;
+        for (j = 1; !badargs && j < argc; ++j)
+        {
+            arg = argv[j];
+            if (arg[0] == '-' && arg[1] != '\0')
+            {
+		++arg;
+		while (*arg != '\0')
+		{
+		    sw = *arg++;
+		         SWBOOLEAN('u',uswitch)
+		    else SWBOOLEAN('s',sswitch)
+		    else SWBOOLEAN('p',pswitch)
+		    else SWBOOLEAN('l',lswitch)
+		    else SWRANGE('Z',":-",Zswitch,Z1,Z2,"gentreeg -Z")
+		    else SWBOOLEAN('q',qswitch)
+		    else SWINT('D',Dswitch,maxdeg,"gentreeg -D")
+#ifdef PLUGIN_SWITCHES
+PLUGIN_SWITCHES
+#endif
+                    else badargs = TRUE;
+		}
+            }
+            else if (arg[0] == '-' && arg[1] == '\0')
+		gotf = TRUE;
+	    else
+            {
+                if (argnum == 0)
+                {
+                    if (sscanf(arg,"%d",&nv) != 1) badargs = TRUE;
+		    ++argnum;
+		}
+		else if (gotf)
+		    badargs = TRUE;
+		else
+		{
+		    if (!gotmr)
+		    {
+			if (sscanf(arg,"%d/%d",&res,&mod) == 2)
+                        { 
+                            gotmr = TRUE; 
+                            continue; 
+                        }
+		    }
+		    if (!gotf)
+		    {
+			outfilename = arg;
+			gotf = TRUE;
+			continue;
+		    }
+                }
+            }
+        }
+
+        if (argnum == 0)
+            badargs = TRUE;
+        else if (nv < 1 || nv > MAXN)
+        {
+            fprintf(stderr,">E gentreeg: n must be in the range 1..%d\n",MAXN);
+	    exit(1);
+        }
+
+        if (!gotmr)
+        {
+            mod = 1;
+            res = 0;
+        }
+
+        if (!Dswitch || maxdeg >= nv) maxdeg = nv - 1;
+        if (!Zswitch || Z2 >= nv) Z2 = nv - 1;
+        if (!Zswitch || Z1 <= 1) Z1 = (nv == 1 ? 0 : nv == 2 ? 1 : 2);
+	mindiam = Z1;
+        maxdiam = Z2;
+
+	if (!badargs &&
+	     (maxdiam < mindiam || maxdiam < (nv == 1 ? 0 : nv == 2 ? 1 : 2)))
+            gt_abort(">E gentreeg: impossible diameter bounds\n");
+	if (!badargs && maxdeg < (nv == 1 ? 0 : nv == 2 ? 1 : 2))
+            gt_abort(">E gentreeg: impossible degree bound\n");
+
+        if (!badargs && (res < 0 || res >= mod))
+            gt_abort(">E gentreeg: must have 0 <= res < mod\n");
+
+        if (badargs)
+        {
+            fprintf(stderr,">E Usage: %s\n",USAGE);
+	    GETHELP;
+            exit(1);
+        }
+
+	if ((lswitch!=0) + (pswitch!=0) + (sswitch!=0) + (uswitch!=0) > 1)
+	    gt_abort(">E gentreeg: -uslp are incompatible\n");
+
+#ifdef OUTPROC
+        outproc = OUTPROC;
+#else
+        if      (uswitch)  outproc = DontWrite;
+        else if (lswitch)  outproc = WriteLev;
+        else if (pswitch)  outproc = WritePar;
+	else               outproc = WriteS6;
+#endif
+
+#ifdef PLUGIN_INIT
+PLUGIN_INIT
+#endif
+
+	if (qswitch)
+	    outfile = stdout;
+	else if (!gotf || outfilename == NULL)
+	{
+            outfilename = "stdout";
+            outfile = stdout;
+        }
+        else if ((outfile = fopen(outfilename,"w")) == NULL)
+        {
+            fprintf(stderr,
+                  ">E gentree: can't open %s for writing\n",outfilename);
+            gt_abort(NULL);
+        }
+
+	if (!qswitch)
+	{
+	    msg[0] = '\0';
+	    if (strlen(argv[0]) > 75)
+		fprintf(stderr,">A %s",argv[0]);
+	    else
+		CATMSG1(">A %s",argv[0]);
+	   
+	    CATMSG2(" Z=%d:%d",mindiam,maxdiam);
+	    CATMSG2(" D=%d n=%d",maxdeg,nv);
+	    if (mod > 1) CATMSG2(" class=%d/%d",res,mod);
+	    CATMSG0("\n");
+	    fputs(msg,stderr);
+	    fflush(stderr);
+	}
+
+        t1 = CPUTIME;
+
+        nout = 0;
+
+        if (nv == 1)
+        {
+            if (res == 0)
+            {
+                ++nout;
+		par[1] = 0;
+                WriteIt(0);
+            }
+        }
+        else if (nv == 2)
+        {
+            if (res == 0)
+            {
+                ++nout;
+		par[1] = 0;
+		par[2] = 1;
+                WriteIt(0);
+            }
+        }
+        else
+        {
+            if (mod > 1 && nv > 3)
+            {
+                splitlevel = nv/2;
+                splitcount = res;
+            }
+            else
+            {
+                splitlevel = -1;
+                mod = 1;
+            }
+            if ( maxdeg > 0 ) maxchild = maxdeg; 
+            else maxchild = -1;
+
+            ub = (maxdiam+1)/2;
+            for(i=1;i<=nv;i++) chi[i]=0;
+
+            par[1] = 0; par[2] = 1;
+            nextp[1]=0; nextp[2]=1;chi[1]=1;
+            Gen( 0, 3, 0, 0, ub, 0, nv-ub+1, 0, 0 ); 
+	}
+
+        t2 = CPUTIME;
+
+#ifdef SUMMARY
+	SUMMARY(nout,t2-t1);
+#endif
+
+	if (!qswitch)
+	{
+            fprintf(stderr,">Z " COUNTER_FMT 
+	            " trees generated in %3.2f sec\n",nout,t2-t1);
+	}
+
+#ifdef GENTREEG_MAIN
+	return 0;
+#else
+        exit(0);
+#endif
+}
diff --git a/lib/nauty/gtnauty.c b/lib/nauty/gtnauty.c
new file mode 100644
index 0000000..44390df
--- /dev/null
+++ b/lib/nauty/gtnauty.c
@@ -0,0 +1,761 @@
+/* gtnauty.c :  nauty-related routines for gtools.
+
+   Jan 15, 2001 : Increased graph order limit from 2^16-1 to 2^22-1.
+   Aug  9, 2001 : Added fgroup_inv() and fcanonise_inv()
+   Sep 15, 2004 : Completed prototypes
+   Oct 16, 2004 : DEAFULTOPTIONS_GRAPH
+   Nov 17, 2005 : Added fcanonise_inv_sg()
+   May 11, 2010 : use sorttemplates.c
+   Sep  5, 2013 : Unify format processing and remove 2^22 limit
+
+**************************************************************************/
+
+#include "gtools.h"   /* which includes naututil.h, nausparse.h, stdio.h */
+
+static boolean issymm;
+static set *g0;
+static int gm;
+static int fuzz2[] = {006532,070236,035523,062437};
+#define FUZZ2(x) ((x) ^ fuzz2[(x)&3])
+
+int gt_numorbits;
+
+#ifdef REFINE
+void REFINE(graph*,int*,int*,int,int*,int*,set*,int*,int,int);
+#endif
+
+#define MIN_SCHREIER 33  /* If n is this large, schreier will be
+                            turned on. */
+
+/**************************************************************************/
+
+#define SORT_OF_SORT 3
+#define SORT_NAME sortwt
+#define SORT_TYPE1 int
+#define SORT_TYPE2 int
+#include "sorttemplates.c"
+/* Creates static void sortwt(int *lab, int *wt, int n) */
+
+void
+setlabptn(int *weight, int *lab, int *ptn, int n)
+/* Define (lab,ptn) with cells in increasing order of weight. */
+{
+    int i;
+
+    for (i = 0; i < n; ++i) lab[i] = i;
+
+    if (weight)
+    {
+        sortwt(lab,weight,n);
+        for (i = 0; i < n-1; ++i)
+        {
+            if (weight[lab[i]] != weight[lab[i+1]])
+                ptn[i] = 0;
+            else
+                ptn[i] = 1;
+        }
+        ptn[n-1] = 0;
+    }
+    else
+    {
+	for (i = 0; i < n-1; ++i) ptn[i] = 1;
+	ptn[n-1] = 0;
+    }
+}
+
+static int
+setlabptnfmt(char *fmt, int *lab, int *ptn, set *active, int m, int n)
+/* Define (lab,ptn,active) according to format string.
+   Return number of cells */
+{
+    int i,nc;
+#if MAXN
+    int wt[MAXN];
+#else
+    DYNALLSTAT(int,wt,wt_sz);
+
+    DYNALLOC1(int,wt,wt_sz,n,"setlabptnfmt");
+#endif
+
+    EMPTYSET(active,m);
+    ADDELEMENT(active,0);
+    nc = 1;
+
+    if (fmt != NULL && fmt[0] != '\0')
+    {
+#if !MAXN
+        DYNALLOC1(int,wt,wt_sz,n,"fcanonise");
+#endif
+        for (i = 0; i < n && fmt[i] != '\0'; ++i)
+	    wt[i] = (unsigned char)fmt[i];
+	for ( ; i < n; ++i)
+	    wt[i] = 'z';
+
+	setlabptn(wt,lab,ptn,n);
+	for (i = 0; i < n-1; ++i)
+	    if (ptn[i] == 0)
+	    {
+		++nc;
+		ADDELEMENT(active,i+1);
+	    }
+    }
+    else
+    {
+        for (i = 0; i < n; ++i)
+        {
+            lab[i] = i;
+            ptn[i] = 1;
+        }
+        ptn[n-1] = 0;
+    }
+
+    return nc;
+}
+
+/**************************************************************************/
+
+static boolean
+hasloops(graph *g, int m, int n)
+/* Test for loops */
+{
+    int i,nl;
+    set *gi;
+
+    nl = 0;
+    for (i = 0, gi = g; i < n; ++i, gi += m)
+        if (ISELEMENT(gi,i)) return TRUE;
+
+    return FALSE;
+}
+
+static boolean
+hasloops_sg(sparsegraph *sg)
+{
+    size_t *v,vi,j;
+    int *d,*e,n,i;
+
+    n = sg->nv;
+    SG_VDE(sg,v,d,e);
+    for (i = 0; i < n; ++i)
+    {
+	vi = v[i];
+        for (j = vi; j < vi + d[i]; ++j)
+	    if (e[vi] == i) return TRUE;
+    }
+
+    return FALSE;
+}
+
+void
+fcanonise(graph *g, int m, int n, graph *h, char *fmt, boolean digraph)
+/*  canonise g under format fmt; result in h.
+   fmt is either NULL (for no vertex classification) or is a string
+   with char-valued colours for the vertices.  If it ends early, it
+   is assumed to continue with the colour 'z' indefinitely. */
+{
+#if MAXN
+    int lab[MAXN],ptn[MAXN],orbits[MAXN];
+    int count[MAXN];
+    set active[MAXM];
+    setword workspace[24*MAXM];
+#else
+    DYNALLSTAT(int,lab,lab_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+    DYNALLSTAT(int,count,count_sz);
+    DYNALLSTAT(set,active,active_sz);
+    DYNALLSTAT(setword,workspace,workspace_sz);
+#endif
+    int i;
+    int numcells,code;
+    statsblk stats;
+    static DEFAULTOPTIONS_GRAPH(options);
+
+#if MAXN
+    if (n > MAXN || m > MAXM)
+    {
+        fprintf(stderr,">E fcanonise: m or n too large\n");
+        ABORT(">E fcanonise");
+    }
+#else
+    DYNALLOC1(int,lab,lab_sz,n,"fcanonise");
+    DYNALLOC1(int,ptn,ptn_sz,n,"fcanonise");
+    DYNALLOC1(int,orbits,orbits_sz,n,"fcanonise");
+    DYNALLOC1(int,count,count_sz,n,"fcanonise");
+    DYNALLOC1(set,active,active_sz,m,"fcanonise");
+    DYNALLOC1(setword,workspace,workspace_sz,24*m,"fcanonise");
+#endif
+
+    digraph = digraph || hasloops(g,m,n);
+
+    numcells = setlabptnfmt(fmt,lab,ptn,active,m,n);
+
+    if (m == 1)
+        refine1(g,lab,ptn,0,&numcells,count,active,&code,1,n);
+    else
+        refine(g,lab,ptn,0,&numcells,count,active,&code,m,n);
+
+    if (numcells == n || (numcells == n-1 && !digraph))
+    {
+        for (i = 0; i < n; ++i) count[i] = lab[i];
+        updatecan(g,h,count,0,m,n);
+        gt_numorbits = numcells;
+    }
+    else
+    {
+        options.getcanon = TRUE;
+        options.defaultptn = FALSE;
+        options.digraph = digraph;
+#ifdef REFINE
+        options.userrefproc = REFINE;
+#endif
+	if (n >= MIN_SCHREIER) options.schreier = TRUE;
+
+        EMPTYSET(active,m);
+        nauty(g,lab,ptn,active,orbits,&options,&stats,
+                                              workspace,24*m,m,n,h);
+        gt_numorbits = stats.numorbits;
+    }
+}
+
+/**************************************************************************/
+
+void
+fcanonise_inv(graph *g, int m, int n, graph *h, char *fmt,
+   void (*invarproc)(graph*,int*,int*,int,int,int,int*,int,
+    boolean,int,int), int mininvarlevel, int maxinvarlevel,
+    int invararg, boolean digraph)
+/* Canonise g under format fmt; result in h.
+   fmt is either NULL (for no vertex classification) or is a string
+   with char-valued colours for the vertices.  If it ends early, it
+   is assumed to continue with the colour 'z' indefinitely.
+   This is like fcanonise() except that a invariant and its arguments
+   can be specified. */
+{
+#if MAXN
+    int lab[MAXN],ptn[MAXN],orbits[MAXN];
+    int count[MAXN];
+    set active[MAXM];
+    setword workspace[24*MAXM];
+#else
+    DYNALLSTAT(int,lab,lab_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+    DYNALLSTAT(int,count,count_sz);
+    DYNALLSTAT(set,active,active_sz);
+    DYNALLSTAT(setword,workspace,workspace_sz);
+#endif
+    int i;
+    int numcells,code;
+    statsblk stats;
+    static DEFAULTOPTIONS_GRAPH(options);
+
+#if MAXN
+    if (n > MAXN || m > MAXM)
+    {
+        fprintf(stderr,">E fcanonise: m or n too large\n");
+        ABORT(">E fcanonise");
+    }
+#else
+    DYNALLOC1(int,lab,lab_sz,n,"fcanonise");
+    DYNALLOC1(int,ptn,ptn_sz,n,"fcanonise");
+    DYNALLOC1(int,orbits,orbits_sz,n,"fcanonise");
+    DYNALLOC1(int,count,count_sz,n,"fcanonise");
+    DYNALLOC1(set,active,active_sz,m,"fcanonise");
+    DYNALLOC1(setword,workspace,workspace_sz,24*m,"fcanonise");
+#endif
+
+    numcells = setlabptnfmt(fmt,lab,ptn,active,m,n);
+    digraph = digraph || hasloops(g,m,n);
+
+    if (m == 1)
+        refine1(g,lab,ptn,0,&numcells,count,active,&code,1,n);
+    else
+        refine(g,lab,ptn,0,&numcells,count,active,&code,m,n);
+
+    if (numcells == n || (!digraph && numcells >= n-1))
+    {
+        for (i = 0; i < n; ++i) count[i] = lab[i];
+        updatecan(g,h,count,0,m,n);
+        gt_numorbits = numcells;
+    }
+    else
+    {
+        options.getcanon = TRUE;
+        options.digraph = digraph;
+        options.defaultptn = FALSE;
+        if (invarproc)
+        {
+            options.invarproc = invarproc;
+            options.mininvarlevel = mininvarlevel;
+            options.maxinvarlevel = maxinvarlevel;
+            options.invararg = invararg;
+        }
+#ifdef REFINE
+        options.userrefproc = REFINE;
+#endif
+	if (n >= MIN_SCHREIER) options.schreier = TRUE;
+
+        EMPTYSET(active,m);
+        nauty(g,lab,ptn,active,orbits,&options,&stats,workspace,24*m,m,n,h);
+        gt_numorbits = stats.numorbits;
+    }
+}
+
+/**************************************************************************/
+
+void
+fcanonise_inv_sg(sparsegraph *g, int m, int n, sparsegraph *h, char *fmt,
+   void (*invarproc)(graph*,int*,int*,int,int,int,int*,int,
+    boolean,int,int), int mininvarlevel, int maxinvarlevel,
+    int invararg, boolean digraph)
+/*  canonise g under format fmt; result in h.
+   fmt is either NULL (for no vertex classification) or is a string
+   with char-valued colours for the vertices.  If it ends early, it
+   is assumed to continue with the colour 'z' indefinitely.
+   This is like fcanonise() except that a invariant and its arguments
+   can be specified.  Version for sparse graphs. */
+{
+#if MAXN
+    int lab[MAXN],ptn[MAXN],orbits[MAXN];
+    int count[MAXN];
+    set active[MAXM];
+    setword workspace[24*MAXM];
+#else
+    DYNALLSTAT(int,lab,lab_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+    DYNALLSTAT(int,count,count_sz);
+    DYNALLSTAT(set,active,active_sz);
+    DYNALLSTAT(setword,workspace,workspace_sz);
+#endif
+    int i;
+    int numcells,code;
+    statsblk stats;
+    static DEFAULTOPTIONS_SPARSEGRAPH(options);
+
+#if MAXN
+    if (n > MAXN || m > MAXM)
+    {
+        fprintf(stderr,">E fcanonise: m or n too large\n");
+        ABORT(">E fcanonise");
+    }
+#else
+    DYNALLOC1(int,lab,lab_sz,n,"fcanonise");
+    DYNALLOC1(int,ptn,ptn_sz,n,"fcanonise");
+    DYNALLOC1(int,orbits,orbits_sz,n,"fcanonise");
+    DYNALLOC1(int,count,count_sz,n,"fcanonise");
+    DYNALLOC1(set,active,active_sz,m,"fcanonise");
+    DYNALLOC1(setword,workspace,workspace_sz,24*m,"fcanonise");
+#endif
+
+    numcells = setlabptnfmt(fmt,lab,ptn,active,m,n);
+    digraph = digraph || hasloops_sg(g);
+
+    refine_sg((graph*)g,lab,ptn,0,&numcells,count,active,&code,1,n);
+
+    if (numcells == n || (!digraph && numcells == n-1))
+    {
+        for (i = 0; i < n; ++i) count[i] = lab[i];
+        updatecan_sg((graph*)g,(graph*)h,count,0,m,n);
+        gt_numorbits = numcells;
+    }
+    else
+    {
+        options.getcanon = TRUE;
+        options.digraph = digraph;
+        options.defaultptn = FALSE;
+        if (invarproc)
+        {
+            options.invarproc = invarproc;
+            options.mininvarlevel = mininvarlevel;
+            options.maxinvarlevel = maxinvarlevel;
+            options.invararg = invararg;
+        }
+#ifdef REFINE
+        options.userrefproc = REFINE;
+#endif
+	if (n >= MIN_SCHREIER) options.schreier = TRUE;
+
+        EMPTYSET(active,m);
+        nauty((graph*)g,lab,ptn,active,orbits,&options,&stats,
+                                         workspace,24*m,m,n,(graph*)h);
+        gt_numorbits = stats.numorbits;
+    }
+}
+
+/**************************************************************************/
+
+void
+fgroup(graph *g, int m, int n, char *fmt, int *orbits, int *numorbits)  
+/* Find the orbits of undirected graph g stabilised by format fmt.
+   The orbits are put into orbits[] and the number of them into *numorbits
+   fmt is either NULL (for no vertex classification) or is a string
+   with char-valued colours for the vertices.  If it ends early, it
+   is assumed to continue with the colour 'z' indefinitely. */
+{
+#if MAXN
+    int lab[MAXN],ptn[MAXN];
+    int count[MAXN];
+    set active[MAXM];
+    setword workspace[24*MAXM];
+#else
+    DYNALLSTAT(int,lab,lab_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,count,count_sz);
+    DYNALLSTAT(set,active,active_sz);
+    DYNALLSTAT(setword,workspace,workspace_sz);
+#endif
+    int i,j;
+    int orbrep;
+    int numcells,code;
+    boolean digraph;
+    statsblk stats;
+    static DEFAULTOPTIONS_GRAPH(options);
+
+#if MAXN
+    if (n > MAXN || m > MAXM)
+    {
+        fprintf(stderr,">E fcanonise: m or n too large\n");
+        ABORT(">E fcanonise");
+    }
+#else
+    DYNALLOC1(int,lab,lab_sz,n,"fcanonise");
+    DYNALLOC1(int,ptn,ptn_sz,n,"fcanonise");
+    DYNALLOC1(int,count,count_sz,n,"fcanonise");
+    DYNALLOC1(set,active,active_sz,m,"fcanonise");
+    DYNALLOC1(setword,workspace,workspace_sz,24*m,"fcanonise");
+#endif
+
+    numcells = setlabptnfmt(fmt,lab,ptn,active,m,n);
+    digraph = hasloops(g,m,n);
+
+    if (m == 1)
+        refine1(g,lab,ptn,0,&numcells,count,active,&code,1,n);
+    else
+        refine(g,lab,ptn,0,&numcells,count,active,&code,m,n);
+
+    if (cheapautom(ptn,0,digraph,n))
+    {
+        for (i = 0; i < n; )
+        {
+            if (ptn[i] == 0)
+            {
+                orbits[lab[i]] = lab[i];
+                ++i;
+            }
+            else
+            {
+                orbrep = n;
+                j = i;
+                do
+                {
+                    if (lab[j] < orbrep) orbrep = lab[j];
+                } while (ptn[j++] != 0);
+
+                for (; i < j; ++i) orbits[lab[i]] = orbrep;
+            }
+        }
+        *numorbits = gt_numorbits = numcells;
+    }
+    else
+    {
+        options.getcanon = FALSE;
+        options.defaultptn = FALSE;
+        options.digraph = digraph;
+#ifdef REFINE
+        options.userrefproc = REFINE;
+#endif
+	if (n >= MIN_SCHREIER) options.schreier = TRUE;
+
+        EMPTYSET(active,m);
+        nauty(g,lab,ptn,active,orbits,&options,&stats,workspace,24*m,m,n,NULL);
+        *numorbits = gt_numorbits = stats.numorbits;
+    }
+}
+
+/**************************************************************************/
+
+void
+fgroup_inv(graph *g, int m, int n, char *fmt, int *orbits, int *numorbits,
+      void (*invarproc)(graph*,int*,int*,int,int,int,int*,int,
+       boolean,int,int), int mininvarlevel, int maxinvarlevel, int invararg)  
+/* Find the orbits of undirected graph g stabilised by format fmt.
+   The orbits are put into orbits[] and the number of them into *numorbits
+   fmt is either NULL (for no vertex classification) or is a string
+   with char-valued colours for the vertices.  If it ends early, it
+   is assumed to continue with the colour 'z' indefinitely.
+   This is like fgroup() except that a invariant and its arguments
+   can be specified. */
+{
+#if MAXN
+    int lab[MAXN],ptn[MAXN];
+    int count[MAXN];
+    set active[MAXM];
+    setword workspace[24*MAXM];
+#else
+    DYNALLSTAT(int,lab,lab_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,count,count_sz);
+    DYNALLSTAT(set,active,active_sz);
+    DYNALLSTAT(setword,workspace,workspace_sz);
+#endif
+    int i,j;
+    int orbrep;
+    boolean digraph;
+    int numcells,code;
+    statsblk stats;
+    static DEFAULTOPTIONS_GRAPH(options);
+
+#if MAXN
+    if (n > MAXN || m > MAXM)
+    {
+        fprintf(stderr,">E fcanonise: m or n too large\n");
+        ABORT(">E fcanonise");
+    }
+#else
+    DYNALLOC1(int,lab,lab_sz,n,"fcanonise");
+    DYNALLOC1(int,ptn,ptn_sz,n,"fcanonise");
+    DYNALLOC1(int,count,count_sz,n,"fcanonise");
+    DYNALLOC1(set,active,active_sz,m,"fcanonise");
+    DYNALLOC1(setword,workspace,workspace_sz,24*m,"fcanonise");
+#endif
+
+    numcells = setlabptnfmt(fmt,lab,ptn,active,m,n);
+    digraph = hasloops(g,m,n);
+
+    if (m == 1)
+        refine1(g,lab,ptn,0,&numcells,count,active,&code,1,n);
+    else
+        refine(g,lab,ptn,0,&numcells,count,active,&code,m,n);
+
+    if (cheapautom(ptn,0,digraph,n))
+    {
+        for (i = 0; i < n; )
+        {
+            if (ptn[i] == 0)
+            {
+                orbits[lab[i]] = lab[i];
+                ++i;
+            }
+            else
+            {
+                orbrep = n;
+                j = i;
+                do
+                {
+                    if (lab[j] < orbrep) orbrep = lab[j];
+                } while (ptn[j++] != 0);
+
+                for (; i < j; ++i) orbits[lab[i]] = orbrep;
+            }
+        }
+        *numorbits = gt_numorbits = numcells;
+    }
+    else
+    {
+        options.getcanon = FALSE;
+        options.defaultptn = FALSE;
+        options.digraph = digraph;
+        if (invarproc)
+        {
+            options.invarproc = invarproc;
+            options.mininvarlevel = mininvarlevel;
+            options.maxinvarlevel = maxinvarlevel;
+            options.invararg = invararg;
+        }
+#ifdef REFINE
+        options.userrefproc = REFINE;
+#endif
+	if (n >= MIN_SCHREIER) options.schreier = TRUE;
+
+        EMPTYSET(active,m);
+        nauty(g,lab,ptn,active,orbits,&options,&stats,workspace,24*m,m,n,NULL);
+        *numorbits = gt_numorbits = stats.numorbits;
+    }
+}
+
+/**************************************************************************/
+
+static void
+userlevel(int *lab, int *ptn, int level, int *orbits, statsblk *stats,
+      int tv, int index, int tcellsize, int numcells, int cc, int n)
+{
+    int i0,i;
+
+    if (level != 2) return;
+
+    issymm = TRUE;
+
+    i0 = nextelement(g0,gm,-1);
+    if (i0 >= 0)
+        for (i = i0; (i = nextelement(g0,gm,i)) >= 0;)
+            if (orbits[i] != i0)
+            {
+                issymm = FALSE;
+                return;
+            }
+}
+ 
+/*******************************************************************/
+
+/* istransitive(g,m,n,h)
+
+   g   is an input undirected graph without loops
+   m,n of standard meaning.  
+   h   is a place to put an output graph.
+
+   If g is transitive, return 1 or 2 and put a canonically labelled
+       version of g into h.  The value is 2 for symmetric graphs, 
+       and 1 for other transitive graphs.
+   If g is not transitive, return 0.  In that case h may or 
+       may not have something in it.
+*/
+int
+istransitive(graph *g, int m, int n, graph *h)
+{
+    int i,inv;
+    set *gw;
+    short wt;
+    int d,inv0,v,w;
+    statsblk stats; 
+    static DEFAULTOPTIONS_GRAPH(options);
+#if MAXN
+    int lab[MAXN],ptn[MAXN],orbits[MAXN];
+    long x[MAXN];
+    int count[MAXN];
+    setword workspace[24*MAXM];
+    set workset[MAXM];
+    set sofar[MAXM],frontier[MAXM];
+#else
+    DYNALLSTAT(int,lab,lab_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+    DYNALLSTAT(int,count,count_sz);
+    DYNALLSTAT(setword,workspace,workspace_sz);
+    DYNALLSTAT(set,workset,workset_sz);
+    DYNALLSTAT(set,sofar,sofar_sz);
+    DYNALLSTAT(set,frontier,frontier_sz);
+#endif
+
+#if MAXN
+    if (m > MAXM || n > MAXN)
+    {
+        fprintf(stderr,
+            ">E istransitive: bad input parameters (n=%d m=%d)\n",n,m);
+        exit(1);
+    }
+#else
+    DYNALLOC1(int,lab,lab_sz,n,"istransitive");
+    DYNALLOC1(int,ptn,ptn_sz,n,"istransitive");
+    DYNALLOC1(int,orbits,orbits_sz,n,"istransitive");
+    DYNALLOC1(int,count,count_sz,n,"istransitive");
+    DYNALLOC1(setword,workspace,workspace_sz,24*m,"istransitive");
+    DYNALLOC1(set,workset,workset_sz,m,"istransitive");
+    DYNALLOC1(set,sofar,sofar_sz,m,"istransitive");
+    DYNALLOC1(set,frontier,frontier_sz,m,"istransitive");
+#endif
+
+    for (v = 0; v < n; ++v)
+    {
+        inv = 0;
+        EMPTYSET(sofar,m);
+        ADDELEMENT(sofar,v);
+        EMPTYSET(frontier,m);
+        ADDELEMENT(frontier,v);
+        for (d = 1; d < n; ++d)
+        {
+            EMPTYSET(workset,m);
+            wt = 0;
+            for (w = -1; (w = nextelement(frontier,m,w)) >= 0;)
+            {
+                ++wt;
+                gw = GRAPHROW(g,w,m);
+                for (i = m; --i >= 0;) workset[i] |= gw[i];
+            }
+            if (wt == 0) break;
+            wt += (short)(0x73 ^ d);
+            wt = (short)FUZZ2(wt);
+            inv += wt;
+            for (i = m; --i >= 0;)
+            {
+                frontier[i] = workset[i] & ~sofar[i];
+                sofar[i] |= frontier[i];
+            }
+        }
+        if (v == 0) inv0 = inv;
+        else if (inv != inv0) return 0;
+    }
+
+    options.getcanon = TRUE;
+    options.userlevelproc = userlevel;
+#ifdef REFINE
+    options.userrefproc = REFINE;
+#endif
+    if (n >= MIN_SCHREIER) options.schreier = TRUE;
+ 
+    issymm = TRUE;
+    g0 = (set*) g;
+    gm = m;
+
+    nauty(g,lab,ptn,NULL,orbits,&options,&stats,workspace,24*m,m,n,h);
+
+    if (stats.numorbits != 1) return 0;
+    else if (!issymm)         return 1;
+    else                      return 2;
+}
+
+/**************************************************************************/
+
+void 
+tg_canonise(graph *g, graph *h, int m, int n)
+/* Canonise vertex-transitive graph */
+{
+    int i;
+#if MAXN
+    int lab[MAXN],ptn[MAXN],orbits[MAXN];
+    set active[MAXM];
+    setword workspace[24*MAXM];
+#else
+    DYNALLSTAT(int,lab,lab_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+    DYNALLSTAT(set,active,active_sz);
+    DYNALLSTAT(setword,workspace,workspace_sz);
+#endif
+    statsblk stats;
+    static DEFAULTOPTIONS_GRAPH(options);
+
+#if MAXN
+    if (n > MAXN || m > MAXM)
+    {
+        fprintf(stderr,">E tg_canonise: m or n too large\n");
+        ABORT(">E tg_canonise");
+    }
+#else
+    DYNALLOC1(int,lab,lab_sz,n,"tg_canonise");
+    DYNALLOC1(int,ptn,ptn_sz,n,"tg_canonise");
+    DYNALLOC1(int,orbits,orbits_sz,n,"tg_canonise");
+    DYNALLOC1(set,active,active_sz,m,"tg_canonise");
+    DYNALLOC1(setword,workspace,workspace_sz,24*m,"tg_canonise");
+#endif
+
+    options.getcanon = TRUE;
+    options.defaultptn = FALSE;
+#ifdef REFINE
+    options.userrefproc = REFINE;
+#endif
+
+    for (i = 0; i < n; ++i)
+    {
+        lab[i] = i;
+        ptn[i] = 1;
+    }
+    ptn[0] = ptn[n-1] = 0;
+
+    EMPTYSET(active,m);
+    ADDELEMENT(active,0);
+
+    if (n >= MIN_SCHREIER) options.schreier = TRUE;
+    nauty(g,lab,ptn,active,orbits,&options,&stats,workspace,24*m,m,n,h);
+}
diff --git a/lib/nauty/gtools-h.in b/lib/nauty/gtools-h.in
new file mode 100644
index 0000000..cadb987
--- /dev/null
+++ b/lib/nauty/gtools-h.in
@@ -0,0 +1,297 @@
+/*****************************************************************************
+* This is the main header file for gtools.  nauty version 2.6.               *
+* Subject to the copyright notice in nauty.h.                                *
+* @configure_input@
+*****************************************************************************/
+
+/* The parts between the ==== lines are modified by configure when
+creating gtools.h out of gtools-h.in.  If configure is not being
+used, it is necessary to check they are correct.
+====================================================================*/
+
+#ifndef  _GTOOLS_H_    /* only process this file once */
+#define  _GTOOLS_H_
+
+#define HAVE_ERRNO_H  @header_errno_h@      /* <errno.h> exists */
+#define HAVE_PERROR  @have_perror@          /* perror() exists */
+#define HAVE_PIPE  @have_pipe@          /* pipe() exists */
+#define HAVE_WAIT  @have_wait@          /* wait() exists */
+#define HAVE_WAIT_H  @header_sys_wait_h@     /* <sys/wait.h> exists */
+#define HAVE_POPEN  @have_popen@          /* popen() and pclose() exist */
+#define POPEN_DEC  @popen_dec@         /* popen() is declared in stdio.h */
+#define FTELL_DEC  @ftell_dec@         /* ftell() is declared in stdio.h */
+#define FDOPEN_DEC  @fdopen_dec@        /* fdopen() is declared in stdio.h */
+#define SORTPROG  "@sort_prog@"         /* name of sort program */
+#define SORT_NEWKEY @sort_newparams_ok@  /* if -k is supported */
+#define HAVE_PID_T @have_pid_t@    /* pid_t is defined */
+#define PUTENV_DEC @putenv_dec@   /* putenv() is declared in stdlib.h */
+#define SETENV_DEC @setenv_dec@   /* setenv() is declared in stdlib.h */
+#define HAVE_PUTENV @have_putenv@   /* putenv() exists */
+#define HAVE_SETENV @have_setenv@   /* setenv() exists */
+#define HAVE_FORK @have_fork@   /* fork() exists */
+#define HAVE_PTHREADS @have_pthread@   /* Posix threads exist */
+#define HAVE_PTHREAD_H  @header_pthread_h@      /* <pthread.h> exists */
+#define HAVE_SIGNAL_H  @header_signal_h@      /* <signal.h> exists */
+#define HAVE_FSEEKO @have_fseeko@  /* fseeko() and ftello() exist */
+#define HAVE_SIGACTION @have_sigaction@  /* sigaction() exists */
+#define HAVE_SIGPROCMASK @have_sigprocmask@  /* sigprocmask() exists */
+#define ALLOW_INTERRUPT @allow_interrupt@ /* no --disable-interrupt */
+
+/* @edit_msg@ */
+
+/*==================================================================*/
+
+#ifndef MAXN 
+#define MAXN  0
+#endif
+
+#define SIZELEN(n) ((n)<=SMALLN?1:((n)<=SMALLISHN?4:8))
+	/* length of size code in bytes */
+#define G6BODYLEN(n) \
+   (((size_t)(n)/12)*((size_t)(n)-1) + (((size_t)(n)%12)*((size_t)(n)-1)+11)/12)
+#define G6LEN(n) (SIZELEN(n) + G6BODYLEN(n))
+  /* exact graph6 string length excluding \n\0 
+     This twisted expression works up to n=227023 in 32-bit arithmetic
+     and for larger n if size_t has 64 bits.  */
+#define D6BODYLEN(n) \
+   ((n)*(size_t)((n)/6) + (((n)*(size_t)((n)%6)+5)/6))
+#define D6LEN(n) (1 + SIZELEN(n) + D6BODYLEN(n))
+  /* exact digraph6 string length excluding \n\0 
+     This twisted expression works up to n=160529 in 32-bit arithmetic
+     and for larger n if size_t has 64 bits.  */
+
+#include "naututil.h"      /* which includes stdio.h */
+#include "nausparse.h"
+
+#if HAVE_ERRNO_H
+#include <errno.h>
+#else
+extern int errno;
+#endif
+
+#if HAVE_WAIT_H
+#include <sys/wait.h>
+#endif
+
+#if HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+
+#if HAVE_PERROR
+#define ABORT(msg) do {if (errno != 0) perror(msg); exit(1);} while(0)
+#else
+#define ABORT(msg) do {exit(1);} while(0)
+#endif
+
+/* Here we set environment variables that determine the sorting order
+   for the shortg program.  Older docs for sort say that it uses
+   LC_COLLATE, but the POSIX description of locales says that the
+   LC_ALL variable takes precedence over LC_COLLATE.  To be safe,
+   we will define both.  Also, define this to be nothing if the
+   variable KEEP_SORT_LOCALE is defined. */
+#ifdef KEEP_SORT_LOCALE
+#define SET_C_COLLATION
+#else
+#if PUTENV_DEC && HAVE_PUTENV
+#define SET_C_COLLATION putenv("LC_ALL=C"); putenv("LC_COLLATE=C")
+#elif SETENV_DEC && HAVE_SETENV
+#define SET_C_COLLATION setenv("LC_ALL","C",1); setenv("LC_COLLATE","C",1)
+#elif HAVE_PUTENV
+int putenv(char*);
+#define SET_C_COLLATION putenv("LC_ALL=C"); putenv("LC_COLLATE=C")
+#elif HAVE_SETENV
+int setenv(const char*,const char*,int);
+#define SET_C_COLLATION setenv("LC_ALL","C",1); setenv("LC_COLLATE","C",1)
+#else
+#define SET_C_COLLATION
+#endif
+#endif
+
+#if HAS_STDIO_UNLOCK && !defined(NAUTY_IN_MAGMA) && !defined(IS_JAVA)
+#define FLOCKFILE(f) flockfile(f)
+#define FUNLOCKFILE(f) funlockfile(f)
+#define GETC(f) getc_unlocked(f)
+#undef PUTC
+#define PUTC(c,f) putc_unlocked(c,f)
+#else
+#define FLOCKFILE(f)
+#define FUNLOCKFILE(f)
+#define GETC(f) getc(f)
+#undef PUTC
+#define PUTC(c,f) putc(c,f)
+#endif
+
+#define BIAS6 63
+#define MAXBYTE 126
+#define SMALLN 62
+#define SMALLISHN 258047
+#define TOPBIT6 32
+#define C6MASK 63
+
+#define GRAPH6_HEADER ">>graph6<<"
+#define SPARSE6_HEADER ">>sparse6<<"
+#define DIGRAPH6_HEADER ">>digraph6<<"
+#define PLANARCODE_HEADER ">>planar_code<<"
+#define PLANARCODELE_HEADER ">>planar_code le<<"
+#define PLANARCODEBE_HEADER ">>planar_code be<<"
+#define EDGECODE_HEADER ">>edge_code<<"
+
+#define GRAPH6         1
+#define SPARSE6        2
+#define PLANARCODE     4
+#define PLANARCODELE   8
+#define PLANARCODEBE  16
+#define EDGECODE      32
+#define INCSPARSE6    64
+#define PLANARCODEANY (PLANARCODE|PLANARCODELE|PLANARCODEBE)
+#define DIGRAPH6     128
+#define UNKNOWN_TYPE 256
+#define HAS_HEADER   512
+
+#define NODIGRAPHSYET(code) if (((code)&DIGRAPH6)) \
+  gt_abort(">E Sorry, this program doesn't support digraphs yet.\n")
+
+#define ARG_OK 0
+#define ARG_MISSING 1
+#define ARG_TOOBIG 2
+#define ARG_ILLEGAL 3
+
+#define MAXARG 2000000000L
+#define NOLIMIT (MAXARG+31L)
+
+#define SWBOOLEAN(c,boool) if (sw==c) boool=TRUE;
+#define SWINT(c,boool,val,id) if (sw==c) \
+        {boool=TRUE;arg_int(&arg,&val,id);}
+#define SWLONG(c,boool,val,id) if (sw==c) \
+        {boool=TRUE;arg_long(&arg,&val,id);}
+#define SWRANGE(c,sep,boool,val1,val2,id) if (sw==c) \
+	{boool=TRUE;arg_range(&arg,sep,&val1,&val2,id);}
+#define SWREAL(c,boool,val,id) if (sw==c) \
+        {boool=TRUE;arg_double(&arg,&val,id);}
+#define SWREALRANGE(c,sep,boool,val1,val2,id) if (sw==c) \
+	{boool=TRUE;arg_doublerange(&arg,sep,&val1,&val2,id);}
+#define SWSEQUENCE(c,sep,boool,val,maxval,numvals,id) if (sw==c) \
+        {boool=TRUE;arg_sequence(&arg,sep,val,maxval,&numvals,id);}
+
+#ifdef HELPTEXT2 
+#define PUTHELPTEXT printf("\nUsage: %s\n\n%s",USAGE,HELPTEXT1);\
+		    printf("%s",HELPTEXT2);
+#else
+#define PUTHELPTEXT printf("\nUsage: %s\n\n%s",USAGE,HELPTEXT)
+#endif
+
+#define HELP if (argc > 1 && (strcmp(argv[1],"-help")==0 \
+			   || strcmp(argv[1],"/?")==0 \
+			   || strcmp(argv[1],"--help")==0)) \
+       { PUTHELPTEXT; return 0; }
+
+#define PUTVERSION if (argc > 1 && (strcmp(argv[1],"-version")==0 \
+			   || strcmp(argv[1],"--version")==0)) \
+       { printf("Nauty&Traces version %.4f (%d bits)\n",\
+       NAUTYVERSIONID/10000.0,WORDSIZE); return 0; }
+
+#define GETHELP \
+fprintf(stderr,"   Use %s -help to see more detailed instructions.\n",argv[0])
+
+#define alloc_error gt_abort
+
+#define CATMSG0(fmt) sprintf(msg+strlen(msg),fmt)
+#define CATMSG1(fmt,x1) sprintf(msg+strlen(msg),fmt,x1)
+#define CATMSG2(fmt,x1,x2) sprintf(msg+strlen(msg),fmt,x1,x2)
+#define CATMSG3(fmt,x1,x2,x3) sprintf(msg+strlen(msg),fmt,x1,x2,x3)
+#define CATMSG4(fmt,x1,x2,x3,x4) sprintf(msg+strlen(msg),fmt,x1,x2,x3,x4)
+#define CATMSG5(fmt,x1,x2,x3,x4,x5) sprintf(msg+strlen(msg),fmt,x1,x2,x3,x4,x5)
+#define CATMSG6(fmt,x1,x2,x3,x4,x5,x6) \
+		sprintf(msg+strlen(msg),fmt,x1,x2,x3,x4,x5,x6)
+
+/************************************************************************/
+
+/* @edit_msg@ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+ 
+extern void gtools_check(int,int,int,int);
+extern FILE *opengraphfile(char*,int*,boolean,long);
+extern void writeline(FILE*,char*);
+extern char *gtools_getline(FILE*);     /* formerly getline() */
+extern int graphsize(char*);
+extern void encodegraphsize(int,char**);
+extern void stringcounts(char*,int*,size_t*);
+extern void stringtograph(char*,graph*,int);
+extern void stringtograph_inc(char*,graph*,int,graph*,int);
+extern size_t edgecount(char*);
+extern int checkgline(char*);
+extern graph *readgg(FILE*,graph*,int,int*,int*,boolean*);
+extern graph *readg(FILE*,graph*,int,int*,int*);
+extern graph *readgg_inc(FILE*,graph*,int,int*,int*,graph*,int,int,boolean*);
+extern graph *readg_inc(FILE*,graph*,int,int*,int*,graph*,int,int);
+extern char *ntog6(graph*,int,int);
+extern char *ntos6(graph*,int,int);
+extern char *ntod6(graph*,int,int);
+extern char *sgtos6(sparsegraph*);
+extern char *sgtog6(sparsegraph*);
+extern char *sgtod6(sparsegraph*);
+extern void writeg6(FILE*,graph*,int,int);
+extern void writed6(FILE*,graph*,int,int);
+extern void writes6(FILE*,graph*,int,int);
+extern void writeg6_sg(FILE*,sparsegraph*);
+extern void writes6_sg(FILE*,sparsegraph*);
+extern void writed6_sg(FILE*,sparsegraph*);
+extern char *ntois6(graph*,graph*,int,int);
+extern void writeis6(FILE*,graph*,graph*,int,int);
+extern void writepc_sg(FILE*,sparsegraph*);
+extern void stringtosparsegraph(char*,sparsegraph*,int*);
+extern sparsegraph *read_sg(FILE*,sparsegraph*);
+extern sparsegraph *read_sg_loops(FILE*,sparsegraph*,int*);
+extern sparsegraph *read_sgg_loops(FILE*,sparsegraph*,int*,boolean*);
+extern sparsegraph *readpc_sg(FILE*,sparsegraph*);
+extern sparsegraph *readpcle_sg(FILE*,sparsegraph*);
+extern char *getecline(FILE*);
+extern void writelast(FILE*);
+extern int longval(char**,long*);
+extern void arg_int(char**,int*,char*);
+extern void arg_long(char**,long*,char*);
+extern void arg_range(char**,char*,long*,long*,char*);
+extern int doublevalue(char**,double*);
+extern void arg_double(char**,double*,char*);
+extern void arg_doublerange(char**,char*,double*,double*,char*);
+extern void arg_sequence(char**,char*,long*,int,int*,char*);
+
+extern void writerange(FILE*,int,long,long);
+extern void gt_abort(const char*);
+extern char *stringcopy(char*);
+extern boolean strhaschar(char*,int);
+
+extern void fcanonise(graph*,int,int,graph*,char*,boolean);
+extern void fcanonise_inv
+             (graph*,int,int,graph*,char*,void(*)(graph*,int*,int*,int,
+               int,int,int*,int,boolean,int,int),int,int,int,boolean);
+extern void fcanonise_inv_sg
+           (sparsegraph*,int,int,sparsegraph*,char*,void(*)(graph*,int*,int*,
+             int,int,int,int*,int,boolean,int,int),int,int,int,boolean);
+extern void setlabptn(int*,int*,int*,int);
+extern void fgroup(graph*,int,int,char*,int*,int*);
+extern void fgroup_inv
+	     (graph*,int,int,char*,int*,int*,void(*)(graph*,int*,int*,int,
+                int,int,int*,int,boolean,int,int),int,int,int);
+extern int istransitive(graph*,int,int,graph*);
+extern void tg_canonise(graph*,graph*,int,int);
+
+extern TLS_ATTR int readg_code;
+extern TLS_ATTR char *readg_line;
+extern TLS_ATTR size_t ogf_linelen;
+extern TLS_ATTR boolean is_pipe;
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef CPUDEFS
+CPUDEFS
+#endif
+
+/* @edit_msg@ */
+
+#endif /* _GTOOLS_H_  */
diff --git a/lib/nauty/gtools.c b/lib/nauty/gtools.c
new file mode 100644
index 0000000..9b59416
--- /dev/null
+++ b/lib/nauty/gtools.c
@@ -0,0 +1,2873 @@
+/* gtools.c : Common routines for gtools programs. */
+/* Version 4.2, Oct 2017. */
+
+/* Todo: size check if MAXN>0; option to free memory */
+
+#include "gtools.h"
+
+#ifndef SEEK_SET
+#define SEEK_SET 0
+#define SEEK_CUR 1
+#define SEEK_END 2
+#endif
+
+TLS_ATTR size_t ogf_linelen;
+TLS_ATTR boolean is_pipe;
+
+#if HAVE_FSEEKO
+#define FSEEK_VER fseeko
+#define FTELL_VER ftello
+#define OFF_T_VER off_t
+#else
+#if !FTELL_DEC
+extern long ftell(FILE*);
+extern int fseek(FILE*,long,int);
+#endif
+#define FSEEK_VER fseek
+#define FTELL_VER ftell
+#define OFF_T_VER long
+#endif
+
+#if !POPEN_DEC
+extern FILE *popen(const char*,const char*);
+#endif
+
+/*
+  Version 1.1: Fixed sparse6 input for powers of 2.  May 9, 1998
+  Version 1.2: Added "cmd: ..." option for opengraphfile(). 
+               Fixed readg() bug (could not be invisible).  Oct 5, 1998
+  Version 1.3: Added "is_pipe".  June 20, 2002
+  Version 1.4: Stuff for autoconf.  August 30, 2002
+  Version 1.5: Unlocked stdio for efficiency.  October 31, 2004
+               Also fwrite() in place of fputs() for writeline().
+  Version 1.6: i/o for sparsegraph; use of s6len; improve allocations
+  Version 1.7: Add stringcounts()
+  	       Add very long size code (see formats.txt)
+  Version 1.8: Add gtools_check()
+  Version 1.9: Add writepc_sg(), readpc_sg() and readpcle_sg()
+               Add planar_code options to opengraphfile()
+  Version 2.4: Add writeec_sg(), readec_sg()  (MISSING!)
+               Add edge_code options to opengraphfile()
+  Version 2.5: Remove sortints(), not used
+  Version 2.6: Add sgtog6() and writeg6_sg()
+  Version 2.7: Add lots of explicit casts.
+               Fix planar code output for n > 255.
+  Version 3.0: Procedures for incremental sparse6 format.
+               Add checkgline()
+  Version 4.0: Procedures for digraph6 format.
+  Version 4.1: Made encodegraphsize() external.
+  Version 4.2: Fixes for null graphs; thanks to Kevin Ryde.
+*/
+
+#define B(i) (1 << ((i)-1))
+#define M(i) ((1 << (i))-1)
+
+/*********************************************************************
+opengraphfile(filename,codetype,assumefixed,position) 
+          opens and positions a file for reading graphs.
+
+  filename = the name of the file to open 
+                (NULL means stdin, assumed already open)
+             If filename starts with "cmd:", the remainder is taken
+             to be a command to open a subshell for, using a pipe.
+  codetype   = returns a code for the format.
+                This is a combination of SPARSE6, GRAPH6, PLANARCODE,
+                PLANARCODELE, PLANARCODEBE, EDGECODE, DIGRAPH6,
+                UNKNOWN_TYPE and HAS_HEADER.
+                If a header is present, that overrides the data.
+                If there is no header, the first graph is examined.
+  assumefixed = nonzero if files other than stdin or pipes should be
+                assumed to be seekable and have equal record sizes.
+                Ignored if there is a sparse6 header or the first
+                graph has sparse6 format.
+  position = the number of the record to position to
+                (the first is number 1; 0 and -NOLIMIT also mean
+                to position at start).  planar_code files can only
+                be positioned at the start.
+
+  If the file starts with ">", there must be a header.
+  Otherwise opengraphfile() fails.
+
+  The value returned is a file pointer or NULL.  
+  If assumedfixed is not zero and position > 1, the global variable
+  ogf_linelen is set to the length (including \n) of the length of the 
+  first record.  UPDATE
+
+  The global variable is_pipe is set to whether the input file is a pipe.
+
+**********************************************************************/
+
+FILE*
+opengraphfile(char *filename, int *codetype, int assumefixed, long position)
+{
+    FILE *f;
+    int c,bl,firstc;
+    long i,l;
+    OFF_T_VER pos,pos1,pos2;
+    boolean bad_header;
+
+    is_pipe = FALSE;
+
+    if (filename == NULL)
+    {
+        f = stdin;
+        assumefixed = FALSE;
+    }
+    else
+    {
+        if (filename[0] == 'c' && filename[1] == 'm'
+            && filename[2] == 'd' && filename[3] == ':')
+        {
+#if !HAVE_POPEN
+            gt_abort
+               (">E The \"cmd:\" option is not available in this version.\n");
+#else
+            filename += 4;
+            while (*filename == ' ') ++filename;
+            f = popen(filename,"r");
+#endif
+            assumefixed = FALSE;
+            is_pipe = TRUE;
+        }
+        else
+            f = fopen(filename,"r");
+
+        if (f == NULL)
+        {
+             fprintf(stderr,">E opengraphfile: can't open %s\n",filename);
+            return NULL;
+        }
+    }
+
+    FLOCKFILE(f);
+    firstc = c = GETC(f);
+    if (c == EOF)
+    {
+        *codetype = GRAPH6;
+        FUNLOCKFILE(f);
+        return f;
+    }
+
+    if (c != '>')
+    {
+        *codetype = firstc == ':' ? SPARSE6 : firstc == '&' ? DIGRAPH6 : GRAPH6;
+        ungetc(c,f);
+    }
+    else
+    {
+        bad_header = FALSE;
+        if ((c = GETC(f)) == EOF || c != '>')
+            bad_header = TRUE;
+        if (!bad_header && ((c = GETC(f)) == EOF || 
+	         (c != 'g' && c != 's' && c != 'p')))
+            bad_header = TRUE;        
+        if (!bad_header && c == 'g')
+        {
+            if ((c = GETC(f)) == EOF || c != 'r' ||
+                (c = GETC(f)) == EOF || c != 'a' ||
+                (c = GETC(f)) == EOF || c != 'p' ||
+                (c = GETC(f)) == EOF || c != 'h' ||
+                (c = GETC(f)) == EOF || c != '6' ||
+                (c = GETC(f)) == EOF || c != '<' ||
+                (c = GETC(f)) == EOF || c != '<')
+                    bad_header = TRUE;
+            else
+                *codetype = GRAPH6 | HAS_HEADER;
+        }
+        else if (!bad_header && c == 'd')
+        {
+            if ((c = GETC(f)) == EOF || c != 'i' ||
+                (c = GETC(f)) == EOF || c != 'g' ||
+                (c = GETC(f)) == EOF || c != 'r' ||
+                (c = GETC(f)) == EOF || c != 'a' ||
+                (c = GETC(f)) == EOF || c != 'p' ||
+                (c = GETC(f)) == EOF || c != 'h' ||
+                (c = GETC(f)) == EOF || c != '6' ||
+                (c = GETC(f)) == EOF || c != '<' ||
+                (c = GETC(f)) == EOF || c != '<')
+                    bad_header = TRUE;
+            else
+                *codetype = DIGRAPH6 | HAS_HEADER;
+        }
+        else if (!bad_header && c == 'e')
+        {
+            if ((c = GETC(f)) == EOF || c != 'd' ||
+                (c = GETC(f)) == EOF || c != 'g' ||
+                (c = GETC(f)) == EOF || c != 'e' ||
+                (c = GETC(f)) == EOF || c != '_' ||
+                (c = GETC(f)) == EOF || c != 'c' ||
+                (c = GETC(f)) == EOF || c != 'o' ||
+                (c = GETC(f)) == EOF || c != 'd' ||
+                (c = GETC(f)) == EOF || c != 'e' ||
+                (c = GETC(f)) == EOF || c != '<' ||
+                (c = GETC(f)) == EOF || c != '<')
+                    bad_header = TRUE;
+            else
+                *codetype = EDGECODE | HAS_HEADER;
+        }
+        else if (!bad_header && c == 's')
+        {
+            if ((c = GETC(f)) == EOF || c != 'p' ||
+                (c = GETC(f)) == EOF || c != 'a' ||
+                (c = GETC(f)) == EOF || c != 'r' ||
+                (c = GETC(f)) == EOF || c != 's' ||
+                (c = GETC(f)) == EOF || c != 'e' ||
+                (c = GETC(f)) == EOF || c != '6' ||
+                (c = GETC(f)) == EOF || c != '<' ||
+                (c = GETC(f)) == EOF || c != '<')
+                    bad_header = TRUE;
+            else
+                *codetype = SPARSE6 | HAS_HEADER;
+        }
+        else if (!bad_header && c == 'p')
+        {
+            if ((c = GETC(f)) == EOF || c != 'l' ||
+                (c = GETC(f)) == EOF || c != 'a' ||
+                (c = GETC(f)) == EOF || c != 'n' ||
+                (c = GETC(f)) == EOF || c != 'a' ||
+                (c = GETC(f)) == EOF || c != 'r' ||
+                (c = GETC(f)) == EOF || c != '_' ||
+                (c = GETC(f)) == EOF || c != 'c' ||
+                (c = GETC(f)) == EOF || c != 'o' ||
+                (c = GETC(f)) == EOF || c != 'd' ||
+                (c = GETC(f)) == EOF || c != 'e')
+		    bad_header = TRUE;
+	    else
+	    {
+		if ((c = GETC(f)) == EOF)
+		    bad_header = TRUE;
+		else if (c == ' ')
+		{
+		    if ((bl = GETC(f)) == EOF || (bl != 'l' && bl != 'b') ||
+			(c = GETC(f)) == EOF || c != 'e' ||
+			(c = GETC(f)) == EOF || c != '<' ||
+			(c = GETC(f)) == EOF || c != '<')
+			    bad_header = TRUE;
+		    else if (bl == 'l')
+                	*codetype = PLANARCODELE | HAS_HEADER;
+		    else
+                	*codetype = PLANARCODEBE | HAS_HEADER;
+		}
+		else if (c == '<')
+		{
+		    if ((c = GETC(f)) == EOF || c != '<')
+			    bad_header = TRUE;
+                    else
+                        *codetype = PLANARCODE | HAS_HEADER;
+		}
+		else
+                    bad_header = TRUE;
+	    }
+        }
+
+        if (bad_header)
+        {
+            fprintf(stderr,">E opengraphfile: illegal header in %s\n",
+                    filename == NULL ? "stdin" : filename);
+            *codetype = UNKNOWN_TYPE | HAS_HEADER;
+            FUNLOCKFILE(f);
+            return NULL;
+        }
+    }
+
+    if (position <= 1) return f;
+
+    if (*codetype&PLANARCODEANY)
+    {
+	fprintf(stderr,
+      ">E opengraphfile: planar_code files can only be opened at the start\n");
+	*codetype = UNKNOWN_TYPE | HAS_HEADER;
+            FUNLOCKFILE(f);
+	    fclose(f);
+            return NULL;
+    }
+
+    if (*codetype&EDGECODE)
+    {
+	fprintf(stderr,
+      ">E opengraphfile: edge_code files can only be opened at the start\n");
+	*codetype = UNKNOWN_TYPE | HAS_HEADER;
+            FUNLOCKFILE(f);
+	    fclose(f);
+            return NULL;
+    }
+
+    if (!assumefixed || (*codetype&SPARSE6) || firstc == ':')
+    {
+        l = 1;
+        while ((c = GETC(f)) != EOF)
+        {
+            if (c == '\n')
+            {
+                ++l;
+                if (l == position) break;
+            }
+        }
+        if (l == position) return f;
+
+        fprintf(stderr,
+           ">E opengraphfile: can't find line %ld in %s\n",position,
+            filename == NULL ? "stdin" : filename);
+        return NULL;
+    }
+    else
+    {
+        pos1 = FTELL_VER(f);
+        if (pos1 < 0)
+        {
+            fprintf(stderr,">E opengraphfile: error on first ftell\n");
+            return NULL;
+        }
+
+        for (i = 1; (c = GETC(f)) != EOF && c != '\n'; ++i) {}
+        ogf_linelen = i;
+
+        if (c == EOF)
+        {
+            fprintf(stderr,
+                    ">E opengraphfile: required record no present\n");
+            FUNLOCKFILE(f);
+            return NULL;
+        }
+        
+        pos2 = FTELL_VER(f);
+        if (pos2 < 0)
+        {
+            fprintf(stderr,">E opengraphfile: error on second ftell\n");
+            return NULL;
+        }
+
+        pos = pos1 + (position-1)*(pos2-pos1);
+        if (FSEEK_VER(f,pos,SEEK_SET) < 0)
+        {
+            fprintf(stderr,">E opengraphfile: seek failed\n");
+            return NULL;
+        }
+    }
+
+    FUNLOCKFILE(f);
+    return f;
+}
+
+/*********************************************************************/
+
+void
+writeline(FILE *f, char *s)
+/* write a line with error checking */
+/* \n is not appended automatically */
+{
+    size_t slen;
+
+    slen = strlen(s);
+
+    if (fwrite(s,1,slen,f) != slen || ferror(f))
+        gt_abort(">E writeline : error on writing\n");
+}
+
+/*********************************************************************/
+/* This function used to be called getline(), but this was changed due
+   to too much confusion with the GNU function of that name.
+*/
+
+char*
+gtools_getline(FILE *f)     /* read a line with error checking */
+/* includes \n (if present) and \0.  Immediate EOF causes NULL return. */
+{
+    DYNALLSTAT(char,s,s_sz);
+    int c;
+    long i;
+
+    DYNALLOC1(char,s,s_sz,5000,"gtools_getline");
+
+    FLOCKFILE(f);
+    i = 0;
+    while ((c = GETC(f)) != EOF && c != '\n')
+    {
+        if (i == s_sz-3)
+            DYNREALLOC(char,s,s_sz,3*(s_sz/2)+10000,"gtools_getline");
+        s[i++] = (char)c;
+    }
+    FUNLOCKFILE(f);
+
+    if (i == 0 && c == EOF) return NULL;
+
+    if (c == '\n') s[i++] = '\n';
+    s[i] = '\0';
+    return s;
+}
+
+/****************************************************************************/
+
+char*
+getecline(FILE *f)     /* read an edge_code line */
+/* No trailing \n or \0 is added.  Immediate EOF causes NULL return. */
+{
+    size_t headsize,bodysize;
+    int sizesize,edgesize;
+    int c1,c,i;
+    DYNALLSTAT(unsigned char,s,s_sz);
+
+    FLOCKFILE(f);
+    if ((c1 = GETC(f)) == EOF) return NULL;
+
+    if (c1 > 0)
+    {
+        bodysize = c1;
+        edgesize = 1;
+        headsize = 1;
+    }
+    else
+    {
+        if ((c = GETC(f)) == EOF)
+            gt_abort(">E Incomplete edge_code line\n");
+        else
+        {
+            sizesize = c >> 4;
+            edgesize = c & 0xF;
+            bodysize = 0;
+            for (i = 0; i < sizesize; ++i)
+            {
+                if ((c = GETC(f)) == EOF)
+                    gt_abort(">E Incomplete edge_code line\n");
+                else
+                    bodysize = (bodysize << 8) + c;
+            }
+            headsize = 2 + sizesize;
+        }
+    }
+
+    DYNALLOC1(unsigned char,s,s_sz,headsize+bodysize,"getecline");
+
+    s[0] = (unsigned char)c1;
+    if (c1 == 0)
+    {
+        s[1] = (char)((sizesize << 4) + edgesize);
+        for (i = 0; i < sizesize; ++i)
+            s[headsize-1-i] = (bodysize >> 8*i) & 0xFF;
+    }
+
+    if (bodysize > 0 && fread(s+headsize,bodysize,1,f) != bodysize)
+        gt_abort(">E Incomplete edge_code line\n");
+
+    FUNLOCKFILE(f);
+    return (char*)s;
+}
+
+int
+graphsize(char *s)
+/* Get size of graph out of graph6, digraph6 or sparse6 string. */
+{
+    char *p;
+    int n;
+
+    if (s[0] == ':' || s[0] == '&') p = s+1;
+    else                            p = s;
+    n = *p++ - BIAS6;
+
+    if (n > SMALLN) 
+    {
+        n = *p++ - BIAS6;
+        if (n > SMALLN)
+        {
+            n = *p++ - BIAS6;
+            n = (n << 6) | (*p++ - BIAS6);
+            n = (n << 6) | (*p++ - BIAS6);
+            n = (n << 6) | (*p++ - BIAS6);
+            n = (n << 6) | (*p++ - BIAS6);
+            n = (n << 6) | (*p++ - BIAS6);
+        }
+        else
+        {
+            n = (n << 6) | (*p++ - BIAS6);
+            n = (n << 6) | (*p++ - BIAS6);
+        }
+    }
+    return n;
+}
+
+/****************************************************************************/
+
+void
+encodegraphsize(int n, char **pp)
+/* Encode the size n in a string starting at **p, and reset **p
+   to point to the character after the size */
+{
+    char *p;
+
+    p = *pp;
+    if (n <= SMALLN) 
+        *p++ = (char)(BIAS6 + n);
+    else if (n <= SMALLISHN)
+    {
+        *p++ = MAXBYTE;
+        *p++ = (char)(BIAS6 + (n >> 12));
+        *p++ = (char)(BIAS6 + ((n >> 6) & C6MASK));
+        *p++ = (char)(BIAS6 + (n & C6MASK));
+    }
+    else 
+    {
+        *p++ = MAXBYTE;
+        *p++ = MAXBYTE;
+        *p++ = (char)(BIAS6 + (n >> 30));
+        *p++ = (char)(BIAS6 + ((n >> 24) & C6MASK));
+        *p++ = (char)(BIAS6 + ((n >> 18) & C6MASK));
+        *p++ = (char)(BIAS6 + ((n >> 12) & C6MASK));
+        *p++ = (char)(BIAS6 + ((n >> 6) & C6MASK));
+        *p++ = (char)(BIAS6 + (n & C6MASK));
+    }
+
+    *pp = p;
+}
+
+/****************************************************************************/
+
+void
+stringcounts(char *s, int *pn, size_t *pe)
+/* Determine number of edges of graph6, digraph6 or sparse6 string */
+{
+    char *p;
+    int i,j,k,x,nb,v,n,need;
+    size_t count;
+    boolean done;
+
+    n = graphsize(s);
+    *pn = n;
+
+    p = s + (s[0] == ':' || s[0] == '&') + SIZELEN(n);
+ 
+    if (s[0] == ':')  /* sparse6 */
+    {
+        count = 0;
+
+        for (i = n-1, nb = 0; i > 0 ; i >>= 1, ++nb) {}
+        k = 0;
+        v = 0;
+        done = FALSE;
+        while (!done)
+        {
+            if (k == 0)
+            {
+                x = *(p++);
+                if (x == '\n' || x == '\0')
+                {
+                    done = TRUE; continue;
+                }
+                else
+                {
+                    x -= BIAS6; k = 6;
+                }
+            }
+            if ((x & B(k))) ++v;
+            --k;
+
+            need = nb;
+            j = 0;
+            while (need > 0 && !done)
+            {
+                if (k == 0)
+                {
+                    x = *(p++);
+                    if (x == '\n' || x == '\0')
+                    {
+                        done = TRUE; continue;
+                    }
+                    else
+                    {
+                        x -= BIAS6; k = 6;
+                    }
+                }
+                if (need >= k)
+                {
+                    j = (j << k) | (x & M(k));
+                    need -= k; k = 0;
+                }
+                else
+                {
+                    k -= need;
+                    j = (j << need) | ((x >> k) & M(need));
+                    need = 0;
+                }
+            }
+            if (done) continue;
+
+            if (j > v)
+                v = j;
+            else if (v < n)
+                ++count;
+	}
+    }
+    else  /* graph6 or digraph6 */
+    {
+	count = 0;
+	for (; *p != '\n' && *p != '\0'; ++p)
+	    count += bytecount[*p - BIAS6];
+    }
+
+    *pe = count;
+}
+
+/****************************************************************************/
+
+void
+stringtograph(char *s, graph *g, int m)
+/* Convert string (graph6, digraph6 or sparse6 format) to graph. */
+/* Assumes g is big enough to hold it.   */
+{
+    char *p;
+    int n,i,j,k,v,x,nb,need;
+    size_t ii;
+    set *gi,*gj;
+    boolean done;
+
+    n = graphsize(s);
+    if (n == 0) return;
+
+    p = s + (s[0] == ':' || s[0] == '&') + SIZELEN(n);
+
+    if (TIMESWORDSIZE(m) < n)
+        gt_abort(">E stringtograph: impossible m value\n");
+
+    for (ii = m*(size_t)n; --ii > 0;) g[ii] = 0;
+    g[0] = 0;
+
+    if (s[0] != ':' && s[0] != '&')       /* graph6 format */
+    {
+        k = 1;
+        for (j = 1; j < n; ++j)
+        {
+            gj = GRAPHROW(g,j,m);
+    
+            for (i = 0; i < j; ++i)
+            {
+                if (--k == 0)
+                {
+                    k = 6;
+                    x = *(p++) - BIAS6;
+                }
+        
+                if ((x & TOPBIT6))
+                {
+                    gi = GRAPHROW(g,i,m);
+                    ADDELEMENT(gi,j);
+                    ADDELEMENT(gj,i);
+                }
+                x <<= 1;
+            }
+        }
+    }
+    else if (s[0] == '&')
+    {
+        k = 1;
+        for (i = 0; i < n; ++i)
+        {
+            gi = GRAPHROW(g,i,m);
+    
+            for (j = 0; j < n; ++j)
+            {
+                if (--k == 0)
+                {
+                    k = 6;
+                    x = *(p++) - BIAS6;
+                }
+        
+                if ((x & TOPBIT6))
+                {
+                    ADDELEMENT(gi,j);
+                }
+                x <<= 1;
+            }
+        } 
+    }
+    else    /* sparse6 format */
+    {
+        for (i = n-1, nb = 0; i > 0 ; i >>= 1, ++nb) {}
+
+        k = 0;
+        v = 0;
+	done = FALSE;
+        while (!done)
+        {
+	    if (k == 0)
+	    {
+		x = *(p++);
+		if (x == '\n' || x == '\0')
+		{
+		    done = TRUE; continue;
+		}
+		else
+		{
+		    x -= BIAS6; k = 6;
+		}
+	    }
+	    if ((x & B(k))) ++v;
+	    --k;
+
+	    need = nb;
+	    j = 0;
+	    while (need > 0 && !done)
+	    {
+		if (k == 0)
+		{
+		    x = *(p++);
+		    if (x == '\n' || x == '\0')
+		    {
+		        done = TRUE; continue;
+		    }
+		    else
+		    {
+		       	x -= BIAS6; k = 6;
+		    }
+		}
+		if (need >= k)
+		{
+		    j = (j << k) | (x & M(k));
+		    need -= k; k = 0;
+		}
+		else
+		{
+		    k -= need;
+		    j = (j << need) | ((x >> k) & M(need));
+		    need = 0;
+		}
+	    }
+	    if (done) continue;
+
+	    if (j > v)
+		v = j;
+	    else if (v < n)
+	    {
+		ADDELEMENT(GRAPHROW(g,v,m),j);
+		ADDELEMENT(GRAPHROW(g,j,m),v);
+	    }
+        }
+    }
+}
+
+/****************************************************************************/
+
+void
+stringtograph_inc(char *s, graph *g, int m,
+                  graph *prevg, int prevn)
+/* Convert string (graph6, digraph6 or sparse6 format) to graph,
+   allowing incremental sparse6 format with a prior graph assumed
+   to have matching m,n values. 
+   If prevg != NULL and type is is6, use prevg as prior graph.
+   Assumes g is big enough to hold it. 
+   *digraph is set according to the graph type.
+*/
+{
+    char *p;
+    int n,i,j,k,v,x,nb,need;
+    size_t ii;
+    set *gi,*gj;
+    boolean done;
+
+    if (s[0] == ';' && !prevg)
+        gt_abort(">E stringtograph_inc missing prior graph\n");
+
+    if (s[0] == ';')
+    {
+	n = prevn;
+	if (n == 0) return;
+	p = s + 1;
+        for (ii = m*(size_t)n; --ii > 0;) g[ii] = prevg[ii];
+        g[0] = prevg[0];
+    }
+    else 
+    { 
+        n = graphsize(s);
+        if (n == 0) return;
+        p = s + (s[0] == ':' || s[0] == '&') + SIZELEN(n);
+        for (ii = m*(size_t)n; --ii > 0;) g[ii] = 0;
+        g[0] = 0;
+    }
+
+    if (TIMESWORDSIZE(m) < n)
+        gt_abort(">E stringtograph_inc: impossible m value\n");
+
+    if (s[0] != ':' && s[0] != ';' && s[0] != '&')   /* graph6 format */
+    {
+        k = 1;
+        for (j = 1; j < n; ++j)
+        {
+            gj = GRAPHROW(g,j,m);
+    
+            for (i = 0; i < j; ++i)
+            {
+                if (--k == 0)
+                {
+                    k = 6;
+                    x = *(p++) - BIAS6;
+                }
+        
+                if ((x & TOPBIT6))
+                {
+                    gi = GRAPHROW(g,i,m);
+                    FLIPELEMENT(gi,j);
+                    if (i != j) FLIPELEMENT(gj,i);
+                }
+                x <<= 1;
+            }
+        }
+    }
+    else if (s[0] == '&')       /* digraph6 format */
+    {
+        k = 1;
+        for (j = 0; j < n; ++j)
+        {
+            gj = GRAPHROW(g,j,m);
+    
+            for (i = 0; i < n; ++i)
+            {
+                if (--k == 0)
+                {
+                    k = 6;
+                    x = *(p++) - BIAS6;
+                }
+        
+                if ((x & TOPBIT6))
+                {
+                    FLIPELEMENT(gj,i);
+                }
+                x <<= 1;
+            }
+        }
+    }
+    else    /* sparse6 format */
+    {
+        for (i = n-1, nb = 0; i != 0 ; i >>= 1, ++nb) {}
+
+        k = 0;
+        v = 0;
+	done = FALSE;
+        while (!done)
+        {
+	    if (k == 0)
+	    {
+		x = *(p++);
+		if (x == '\n' || x == '\0')
+		{
+		    done = TRUE; continue;
+		}
+		else
+		{
+		    x -= BIAS6; k = 6;
+		}
+	    }
+	    if ((x & B(k))) ++v;
+	    --k;
+
+	    need = nb;
+	    j = 0;
+	    while (need > 0 && !done)
+	    {
+		if (k == 0)
+		{
+		    x = *(p++);
+		    if (x == '\n' || x == '\0')
+		    {
+		        done = TRUE; continue;
+		    }
+		    else
+		    {
+		       	x -= BIAS6; k = 6;
+		    }
+		}
+		if (need >= k)
+		{
+		    j = (j << k) | (x & M(k));
+		    need -= k; k = 0;
+		}
+		else
+		{
+		    k -= need;
+		    j = (j << need) | ((x >> k) & M(need));
+		    need = 0;
+		}
+	    }
+	    if (done) continue;
+
+	    if (j > v)
+		v = j;
+	    else if (v < n)
+	    {
+		FLIPELEMENT(GRAPHROW(g,v,m),j);
+		if (j != v) FLIPELEMENT(GRAPHROW(g,j,m),v);
+	    }
+        }
+    }
+}
+
+/***********************************************************************/
+
+graph*                 /* read graph into nauty format */
+readgg(FILE *f, graph *g, int reqm, int *pm, int *pn, boolean *digraph) 
+/* graph6, digraph6 and sparse6 formats are supported 
+   f = an open file 
+   g = place to put the answer (NULL for dynamic allocation) 
+   reqm = the requested value of m (0 => compute from n) 
+   *pm = the actual value of m 
+   *pn = the value of n 
+   *digraph = whether the input is a digraph
+*/
+{
+    char *s,*p;
+    int m,n;
+
+    if ((readg_line = gtools_getline(f)) == NULL) return NULL;
+
+    s = readg_line;
+    if (s[0] == ':')
+    {
+        readg_code = SPARSE6;
+        *digraph = FALSE;
+        p = s + 1;
+    }
+    else if (s[0] == '&')
+    {
+	readg_code = DIGRAPH6;
+        *digraph = TRUE;
+	p = s + 1;
+    }
+    else
+    {
+        readg_code = GRAPH6;
+        *digraph = FALSE;
+        p = s;
+    }
+
+    while (*p >= BIAS6 && *p <= MAXBYTE) 
+        ++p;
+    if (*p == '\0')
+        gt_abort(">E readgg: missing newline\n");
+    else if (*p != '\n')
+        gt_abort(">E readgg: illegal character\n");
+
+    n = graphsize(s);
+    if (readg_code == GRAPH6 && p - s != G6LEN(n))
+        gt_abort(">E readgg: truncated graph6 line\n");
+    if (readg_code == DIGRAPH6 && p - s != D6LEN(n))
+        gt_abort(">E readgg: truncated digraph6 line\n");
+
+    if (reqm > 0 && TIMESWORDSIZE(reqm) < n)
+        gt_abort(">E readgg: reqm too small\n");
+    else if (reqm > 0)
+        m = reqm;
+    else
+        m = (n + WORDSIZE - 1) / WORDSIZE;
+
+    if (g == NULL)
+    {
+        if ((g = (graph*)ALLOCS(n,m*sizeof(graph))) == NULL)
+            gt_abort(">E readgg: malloc failed\n");
+    }
+
+    *pn = n;
+    *pm = m;
+
+    stringtograph(s,g,m);
+    return g;
+}
+
+/***********************************************************************/
+
+graph*                 /* read undirected graph into nauty format */
+readg(FILE *f, graph *g, int reqm, int *pm, int *pn) 
+/* graph6 and sparse6 formats are supported 
+   f = an open file 
+   g = place to put the answer (NULL for dynamic allocation) 
+   reqm = the requested value of m (0 => compute from n) 
+   *pm = the actual value of m 
+   *pn = the value of n 
+
+   Only allows undirected graphs.
+*/
+{
+    boolean digraph;
+    graph *gg;
+
+    gg = readgg(f,g,reqm,pm,pn,&digraph);
+
+    if (!gg) return NULL;
+    if (digraph)
+        gt_abort(">E readg() doesn't all digraphs; use readgg()\n");
+    return gg;
+}
+
+/***********************************************************************/
+
+int
+checkgline(char *s)
+/* Check if s[0..] appears to be a graph input line.  A complete check
+   is not performed.  Note that graph input lines must end with \n.
+   The value returned is 0 if no errors are found, otherwise:
+     1 = missing newline
+     2 = illegal character
+     3 = graph6 or digraph6 line with wrong length
+*/
+{
+    char *p;
+    int n,t;
+
+    if (s[0] == ':' || s[0] == ';')
+    {
+	t = SPARSE6;
+	p = s + 1;
+    }
+    else if (s[0] == '&')
+    {
+	t = DIGRAPH6;
+	p = s + 1;
+    }
+    else
+    {
+	t = GRAPH6;
+	p = s;
+    }
+
+    while (*p >= BIAS6 && *p <= MAXBYTE)
+        ++p;
+    if (*p == '\0')
+        return 1;
+    else if (*p != '\n')
+        return 2;
+
+    if (t == GRAPH6)
+    {
+	n = graphsize(s);
+	if (p - s != G6LEN(n)) return 3;
+    }
+
+    if (t == DIGRAPH6)
+    {
+	n = graphsize(s);
+	if (p - s != D6LEN(n)) return 3;
+    }
+
+    return 0;
+}
+
+/***********************************************************************/
+
+graph*                 /* read graph into nauty format */
+readgg_inc(FILE *f, graph *g, int reqm, int *pm, int *pn,
+ 	  graph *prevg, int prevm, int prevn, boolean *digraph) 
+/* graph6, digraph6 and sparse6 formats are supported 
+   f = an open file 
+   g = place to put the answer (NULL for dynamic allocation) 
+   reqm = the requested value of m (0 => compute from n) 
+          This is ignored for an incremental input.
+   *pm = the actual value of m 
+   *pn = the value of n 
+   *digraph = whether the input is a digraph
+   If prevg!=NULL, it is a prior graph for use in case the next
+   input is a sparse6 increment.
+*/
+{
+    char *s,*p;
+    int m,n;
+
+    if ((readg_line = gtools_getline(f)) == NULL) return NULL;
+
+    s = readg_line;
+    if (s[0] == ':')
+    {
+        readg_code = SPARSE6;
+	*digraph = FALSE;
+        p = s + 1;
+    }
+    else if (s[0] == ';')
+    {
+        readg_code = INCSPARSE6;
+	*digraph = FALSE;
+        p = s + 1;
+    }
+    else if (s[0] == '&')
+    {
+	readg_code = DIGRAPH6;
+	*digraph = TRUE;
+	p = s + 1;
+    }
+    else
+    {
+        readg_code = GRAPH6;
+	*digraph = FALSE;
+        p = s;
+    }
+
+    while (*p >= BIAS6 && *p <= MAXBYTE) 
+        ++p;
+    if (*p == '\0')
+        gt_abort(">E readg_inc: missing newline\n");
+    else if (*p != '\n')
+        gt_abort(">E readg_inc: illegal character\n");
+
+    if (readg_code == INCSPARSE6)
+    {
+	if (prevg == NULL) gt_abort(">E readg_inc: missing prior\n");
+	n = prevn;
+	m = prevm;
+    }
+    else
+    {
+        n = graphsize(s);
+        if (readg_code == GRAPH6 && p - s != G6LEN(n))
+            gt_abort(">E readg_inc: truncated graph6 line\n");
+        if (readg_code == DIGRAPH6 && p - s != D6LEN(n))
+            gt_abort(">E readg_inc: truncated digraph6 line\n");
+
+        if (reqm > 0 && TIMESWORDSIZE(reqm) < n)
+            gt_abort(">E readg_inc: reqm too small\n");
+        else if (reqm > 0)
+            m = reqm;
+        else
+            m = SETWORDSNEEDED(n);
+    }
+
+    if (g == NULL)
+    {
+        if ((g = (graph*)ALLOCS(n,m*sizeof(graph))) == NULL)
+            gt_abort(">E readg_inc: malloc failed\n");
+    }
+
+    *pn = n;
+    *pm = m;
+
+    stringtograph_inc(s,g,m,prevg,prevn);
+
+    return g;
+}
+
+/***********************************************************************/
+
+graph*              /* read undirected graph into nauty format */
+readg_inc(FILE *f, graph *g, int reqm, int *pm, int *pn,
+ 	  graph *prevg, int prevm, int prevn) 
+/* graph6 and sparse6 formats are supported 
+   f = an open file 
+   g = place to put the answer (NULL for dynamic allocation) 
+   reqm = the requested value of m (0 => compute from n) 
+          This is ignored for an incremental input.
+   *pm = the actual value of m 
+   *pn = the value of n 
+   *digraph = whether the input is a digraph
+   If prevg!=NULL, it is a prior graph for use in case the next
+   input is a sparse6 increment.
+*/
+{
+    boolean digraph;
+    graph *gg;
+
+    gg = readgg_inc(f,g,reqm,pm,pn,prevg,prevm,prevn,&digraph);
+
+    if (!gg) return NULL;
+    if (digraph)
+        gt_abort(">E readg_inc() doesn't all digraphs; use readgg_inc()\n");
+    return gg;
+}
+
+/****************************************************************************/
+
+void
+stringtosparsegraph(char *s, sparsegraph *sg, int *nloops)
+/* Convert string (graph6, digraph6 or sparse6 format)
+ * to sparse graph.
+ * Assumes sg exists and is initialised               
+ * Also returns the number of loops  */
+{
+    char *p,*q;
+    int n,nde,i,j,k,vv,x,nb,need;
+    int *d,*e;
+    size_t *v;
+    int loops;
+    boolean done;
+
+    n = graphsize(s);
+
+    q = s + (s[0] == ':' || s[0] == '&') + SIZELEN(n);
+
+    sg->nv = n;
+
+    DYNALLOC1(size_t,sg->v,sg->vlen,n,"stringtosparsegraph");
+    DYNALLOC1(int,sg->d,sg->dlen,n,"stringtosparsegraph");
+
+    v = sg->v;
+    d = sg->d;
+    for (i = 0; i < n; ++i) d[i] = 0;
+
+    if (s[0] != ':' && s[0] != '&')       /* graph6 format */
+    {
+        p = q;
+        k = 1;
+        for (j = 1; j < n; ++j)
+        {
+            for (i = 0; i < j; ++i)
+            {
+                if (--k == 0)
+                {
+                    k = 6;
+                    x = *(p++) - BIAS6;
+                }
+        
+                if ((x & TOPBIT6))
+                {
+                    d[i]++;
+                    d[j]++;
+                }
+                x <<= 1;
+            }
+        }
+
+        nde = 0;
+        for (i = 0; i < n; ++i)
+        {
+            v[i] = nde; nde += d[i]; d[i] = 0;
+        }
+        sg->nde = nde;
+        DYNALLOC1(int,sg->e,sg->elen,nde,"stringtosparsegraph");
+        e = sg->e;
+
+        p = q;
+        k = 1;
+
+        for (j = 1; j < n; ++j)
+        {
+            for (i = 0; i < j; ++i)
+            {
+                if (--k == 0)
+                {
+                    k = 6;
+                    x = *(p++) - BIAS6;
+                }
+        
+                if ((x & TOPBIT6))
+                {
+                    e[v[i]+d[i]++] = j;
+                    e[v[j]+d[j]++] = i;
+                }
+                x <<= 1;
+            }
+        }
+
+	*nloops = 0;
+    }
+    else if (s[0] == '&')    /* digraph6 */
+    {
+        p = q;
+        k = 1;
+        for (j = 0; j < n; ++j)
+        {
+            for (i = 0; i < n; ++i)
+            {
+                if (--k == 0)
+                {
+                    k = 6;
+                    x = *(p++) - BIAS6;
+                }
+        
+                if ((x & TOPBIT6))
+                    d[j]++;
+                x <<= 1;
+            }
+        }
+
+        nde = 0;
+        for (i = 0; i < n; ++i)
+        {
+            v[i] = nde; nde += d[i]; d[i] = 0;
+        }
+        sg->nde = nde;
+        DYNALLOC1(int,sg->e,sg->elen,nde,"stringtosparsegraph");
+        e = sg->e;
+
+        p = q;
+        k = 1;
+
+	*nloops = 0;
+        for (j = 0; j < n; ++j)
+        {
+            for (i = 0; i < n; ++i)
+            {
+                if (--k == 0)
+                {
+                    k = 6;
+                    x = *(p++) - BIAS6;
+                }
+        
+                if ((x & TOPBIT6))
+                {
+                    e[v[j]+d[j]++] = i;
+		    if (i == j) ++*nloops;
+                }
+                x <<= 1;
+            }
+        }
+    }
+    else    /* sparse6 format */
+    {
+        for (i = n-1, nb = 0; i > 0 ; i >>= 1, ++nb) {}
+
+        p = q;
+
+        k = 0;
+        vv = 0;
+        done = FALSE;
+	loops = 0;
+        while (!done)
+        {
+            if (k == 0)
+            {
+                x = *(p++);
+                if (x == '\n' || x == '\0')
+                {
+                    done = TRUE; continue;
+                }
+                else
+                {
+                    x -= BIAS6; k = 6;
+                }
+            }
+            if ((x & B(k))) ++vv;
+            --k;
+
+            need = nb;
+            j = 0;
+            while (need > 0 && !done)
+            {
+                if (k == 0)
+                {
+                    x = *(p++);
+                    if (x == '\n' || x == '\0')
+                    {
+                        done = TRUE; continue;
+                    }
+                    else
+                    {
+                        x -= BIAS6; k = 6;
+                    }
+                }
+                if (need >= k)
+                {
+                    j = (j << k) | (x & M(k));
+                    need -= k; k = 0;
+                }
+                else
+                {
+                    k -= need;
+                    j = (j << need) | ((x >> k) & M(need));
+                    need = 0;
+                }
+            }
+            if (done) continue;
+
+            if (j > vv)
+                vv = j;
+            else if (vv < n)
+            {
+                d[vv]++;
+                if (vv != j) d[j]++;
+		else         ++loops;
+            }
+        }
+
+        nde = 0;
+        for (i = 0; i < n; ++i)
+        {
+            v[i] = nde; nde += d[i]; d[i] = 0;
+        }
+        sg->nde = nde;
+        DYNALLOC1(int,sg->e,sg->elen,nde,"stringtosparsegraph");
+        e = sg->e;
+
+	p = q;
+
+        k = 0;
+        vv = 0;
+        done = FALSE;
+        while (!done)
+        {
+            if (k == 0)
+            {
+                x = *(p++);
+                if (x == '\n' || x == '\0')
+                {
+                    done = TRUE; continue;
+                }
+                else
+                {
+                    x -= BIAS6; k = 6;
+                }
+            }
+            if ((x & B(k))) ++vv;
+            --k;
+
+            need = nb;
+            j = 0;
+            while (need > 0 && !done)
+            {
+                if (k == 0)
+                {
+                    x = *(p++);
+                    if (x == '\n' || x == '\0')
+                    {
+                        done = TRUE; continue;
+                    }
+                    else
+                    {
+                        x -= BIAS6; k = 6;
+                    }
+                }
+                if (need >= k)
+                {
+                    j = (j << k) | (x & M(k));
+                    need -= k; k = 0;
+                }
+                else
+                {
+                    k -= need;
+                    j = (j << need) | ((x >> k) & M(need));
+                    need = 0;
+                }
+            }
+            if (done) continue;
+
+            if (j > vv)
+                vv = j;
+            else if (vv < n)
+            {
+                e[v[vv]+d[vv]++] = j;
+                if (vv != j) e[v[j]+d[j]++] = vv;
+            }
+        }
+	*nloops = loops;
+    }
+}
+
+/***********************************************************************/
+
+sparsegraph*               /* read graph into sparsegraph format */
+read_sgg_loops(FILE *f, sparsegraph *sg, int *nloops, boolean *digraph) 
+/* graph6, digraph6 and sparse6 formats are supported
+ * f = an open file
+ * sg = place to put the answer (NULL for dynamic allocation) 
+ *      - must be initialised if not NULL 
+ * nloops := number of loops (each loop in a sparse6 string
+ *        gives one loop in the sparse representation)
+ */
+{
+    char *s,*p;
+    int n,loops;
+
+    if ((readg_line = gtools_getline(f)) == NULL) return NULL;
+
+    s = readg_line;
+    if (s[0] == ':')
+    {
+        readg_code = SPARSE6;
+	*digraph = FALSE;
+        p = s + 1;
+    }
+    else if (s[0] == '&')
+    {
+	readg_code = DIGRAPH6;
+        *digraph = TRUE;
+	p = s + 1;
+    }
+    else
+    {
+        readg_code = GRAPH6;
+        *digraph = FALSE;
+        p = s;
+    }
+
+    while (*p >= BIAS6 && *p <= MAXBYTE) 
+        ++p;
+    if (*p == '\0')
+        gt_abort(">E read_sg: missing newline\n");
+    else if (*p != '\n')
+        gt_abort(">E read_sg: illegal character\n");
+
+    n = graphsize(s);
+    if (readg_code == GRAPH6 && p - s != G6LEN(n))
+        gt_abort(">E read_sg: truncated graph6 line\n");
+    if (readg_code == DIGRAPH6 && p - s != D6LEN(n))
+        gt_abort(">E read_sg: truncated digraph6 line\n");
+
+    if (sg == NULL)
+    {
+        if ((sg = (sparsegraph*)ALLOCS(1,sizeof(sparsegraph))) == NULL)
+            gt_abort(">E read_sg: malloc failed\n");
+        SG_INIT(*sg);
+    }
+
+    stringtosparsegraph(s,sg,&loops);
+    *nloops = loops;
+
+    return sg;
+}
+
+/***********************************************************************/
+
+sparsegraph*          /* read undirected graph into sparsegraph format */
+read_sg_loops(FILE *f, sparsegraph *sg, int *nloops) 
+/* graph6 and sparse6 formats are supported
+ * f = an open file
+ * sg = place to put the answer (NULL for dynamic allocation) 
+ *      - must be initialised if not NULL 
+ * nloops := number of loops (each loop in a sparse6 string
+ *        gives one loop in the sparse representation)
+ * digraph = whether input line was a digraph
+ */
+{
+    sparsegraph *sgg;
+    boolean digraph;
+
+    sgg = read_sgg_loops(f,sg,nloops,&digraph);
+    if (!sgg) return NULL;
+    if (digraph) gt_abort(">E read_sg_loops() can't handle digraphs,"
+                  " use read_sgg_loops()\n");
+    return sgg;
+}
+
+/***********************************************************************/
+
+sparsegraph*                 /* read graph into sparsegraph format */
+read_sg(FILE *f, sparsegraph *sg)
+/* graph6 and sparse6 formats are supported
+ *  *f = an open file
+ *  *sg = place to put the answer (NULL for dynamic allocation) 
+ *      - must be initialised if not NULL 
+ */
+{
+    int loops;
+    sparsegraph *sgg;
+    boolean digraph;
+
+    sgg = read_sgg_loops(f,sg,&loops,&digraph); 
+    if (!sgg) return NULL;
+    if (digraph) gt_abort(">E read_sg() can't handle digraphs,"
+                  " use read_sgg_loops()\n");
+    return sgg;
+}
+
+/****************************************************************************/
+
+DYNALLSTAT(char,gcode,gcode_sz);  /* Used by ntog6, ntos6, ntod6 and sgtos6 */
+TLS_ATTR size_t s6len;
+TLS_ATTR int readg_code;
+TLS_ATTR char *readg_line;
+
+/****************************************************************************/
+
+char*
+ntod6(graph *g, int m, int n)
+/* convert nauty graph to digraph6 string, including \n and \0 */
+{
+    int i,j,k;
+    char *p,x;
+    set *gj;
+    size_t ii;
+
+    ii = D6LEN(n)+3;
+
+    DYNALLOC1(char,gcode,gcode_sz,ii,"ntod6");
+
+    p = gcode;
+    *p++ = '&';
+    encodegraphsize(n,&p);
+
+    k = 6;
+    x = 0;
+
+    for (j = 0; j < n; ++j)
+    {
+        gj = GRAPHROW(g,j,m);
+        for (i = 0; i < n; ++i)
+        {
+            x <<= 1;
+            if (ISELEMENT(gj,i)) x |= 1;
+            if (--k == 0)
+            {
+                *p++ = (char)(BIAS6 + x);
+                k = 6;
+                x = 0;
+            }
+        }
+    }
+
+    if (k != 6) *p++ = (char)(BIAS6 + (x << k));
+
+    *p++ = '\n';
+    *p = '\0';
+
+    return gcode;
+}
+
+/****************************************************************************/
+
+char*
+ntog6(graph *g, int m, int n)
+/* convert nauty graph to graph6 string, including \n and \0 */
+{
+    int i,j,k;
+    char *p,x;
+    set *gj;
+    size_t ii;
+
+    ii = G6LEN(n)+3;
+
+    DYNALLOC1(char,gcode,gcode_sz,ii,"ntog6");
+
+    p = gcode;
+    encodegraphsize(n,&p);
+
+    k = 6;
+    x = 0;
+
+    for (j = 1; j < n; ++j)
+    {
+        gj = GRAPHROW(g,j,m);
+        for (i = 0; i < j; ++i)
+        {
+            x <<= 1;
+            if (ISELEMENT(gj,i)) x |= 1;
+            if (--k == 0)
+            {
+                *p++ = (char)(BIAS6 + x);
+                k = 6;
+                x = 0;
+            }
+        }
+    }
+
+    if (k != 6) *p++ = (char)(BIAS6 + (x << k));
+
+    *p++ = '\n';
+    *p = '\0';
+
+    return gcode;
+}
+
+/****************************************************************************/
+
+char*
+ntos6(graph *g, int m, int n)
+/* convert nauty graph to sparse6 string, including \n and \0 */
+{
+    int i,j,k;
+    char *p,x;
+    set *gj;
+    size_t ii;
+    int r,rr,topbit,nb,lastj;
+    char *plim;
+
+    DYNALLOC1(char,gcode,gcode_sz,5000,"ntos6");
+
+    plim = gcode + gcode_sz - 20;
+
+    gcode[0] = ':';
+    p = gcode+1;
+    encodegraphsize(n,&p);
+
+    for (i = n-1, nb = 0; i > 0 ; i >>= 1, ++nb)
+    {}
+    topbit = 1 << (nb-1);
+    k = 6;
+    x = 0;
+
+    lastj = 0;
+    for (j = 0; j < n; ++j)
+    {
+        gj = GRAPHROW(g,j,m);
+        for (i = 0; i <= j; ++i)
+        {
+            if (ISELEMENT(gj,i))
+            {
+                if (p >= plim)
+                {
+                    ii = p - gcode;
+                    DYNREALLOC(char,gcode,gcode_sz,
+                                       3*(gcode_sz/2)+10000,"ntos6");
+                    p = gcode + ii;
+                    plim = gcode + gcode_sz - 20;
+                }
+                if (j == lastj)
+                {
+                    x <<= 1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                }
+                else
+                {
+                    x = (x << 1) | (char)1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                    if (j > lastj+1)
+                    {
+                        for (r = 0, rr = j; r < nb; ++r, rr <<= 1)
+                        {
+                            if ((rr & topbit)) x = (x << 1) | (char)1;
+                            else               x <<= 1;
+                            if (--k == 0)
+                            {
+                                *p++ = (char)(BIAS6 + x);
+                                k = 6;
+                                x = 0;
+                            }
+                        }
+                        x <<= 1;
+                        if (--k == 0)
+                        {
+                            *p++ = (char)(BIAS6 + x);
+                            k = 6;
+                            x = 0;
+                        }
+                    }
+                    lastj = j;
+                }
+                for (r = 0, rr = i; r < nb; ++r, rr <<= 1)
+                {
+                    if ((rr & topbit)) x = (x << 1) | (char)1;
+                    else               x <<= 1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                }
+            }
+        }
+    }
+
+    if (k != 6)
+    {
+        if (k >= nb+1 && lastj == n-2 && n == (1<<nb))
+	    *p++ = (char)(BIAS6 + ((x << k) | ((1 << (k-1)) - 1)));
+        else
+	    *p++ = (char)(BIAS6 + ((x << k) | ((1 << k) - 1)));
+    }
+
+    *p++ = '\n';
+    *p = '\0';
+    s6len = p - gcode;
+    return gcode;
+}
+
+/****************************************************************************/
+
+char*
+ntois6(graph *g, graph *prevg, int m, int n)
+/* convert nauty graph to incremental sparse6 string, including \n and \0.
+   prevg == NULL implies there is no prior graph */
+{
+    int i,j,k;
+    char *p,x;
+    set *gj,*pgj;
+    setword gdiff;
+    size_t ii;
+    int r,rr,topbit,nb,lastj,iw,nwords;
+    char *plim;
+
+    if (!prevg) return ntos6(g,m,n);
+
+    DYNALLOC1(char,gcode,gcode_sz,5000,"ntois6");
+
+    plim = gcode + gcode_sz - 20;
+
+    gcode[0] = ';';
+    p = gcode+1;
+
+    for (i = n-1, nb = 0; i > 0 ; i >>= 1, ++nb)
+    {}
+    topbit = 1 << (nb-1);
+    k = 6;
+    x = 0;
+
+    lastj = 0;
+    for (j = 0; j < n; ++j)
+    {
+        gj = GRAPHROW(g,j,m);
+        pgj = GRAPHROW(prevg,j,m); 
+        nwords = SETWORDSNEEDED(j+1);
+	for (iw = 0; iw < nwords; ++iw)
+        {
+	    gdiff = gj[iw] ^ pgj[iw];
+            if (TIMESWORDSIZE(iw+1) > j+1) gdiff &= ALLMASK(SETBT(j+1));
+	    while (gdiff)
+	    {
+		TAKEBIT(i,gdiff);
+		i += TIMESWORDSIZE(iw);
+   
+                if (p >= plim)
+                {
+                    ii = p - gcode;
+                    DYNREALLOC(char,gcode,gcode_sz,
+                                       3*(gcode_sz/2)+10000,"ntois6");
+                    p = gcode + ii;
+                    plim = gcode + gcode_sz - 20;
+                }
+                if (j == lastj)
+                {
+                    x <<= 1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                }
+                else
+                {
+                    x = (x << 1) | (char)1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                    if (j > lastj+1)
+                    {
+                        for (r = 0, rr = j; r < nb; ++r, rr <<= 1)
+                        {
+                            if ((rr & topbit)) x = (x << 1) | (char)1;
+                            else               x <<= 1;
+                            if (--k == 0)
+                            {
+                                *p++ = (char)(BIAS6 + x);
+                                k = 6;
+                                x = 0;
+                            }
+                        }
+                        x <<= 1;
+                        if (--k == 0)
+                        {
+                            *p++ = (char)(BIAS6 + x);
+                            k = 6;
+                            x = 0;
+                        }
+                    }
+                    lastj = j;
+                }
+                for (r = 0, rr = i; r < nb; ++r, rr <<= 1)
+                {
+                    if ((rr & topbit)) x = (x << 1) | (char)1;
+                    else               x <<= 1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                }
+            }
+        }
+    }
+
+    if (k != 6)
+    {
+        if (k >= nb+1 && lastj == n-2 && n == (1<<nb))
+	    *p++ = (char)(BIAS6 + ((x << k) | ((1 << (k-1)) - 1)));
+        else
+	    *p++ = (char)(BIAS6 + ((x << k) | ((1 << k) - 1)));
+    }
+
+    *p++ = '\n';
+    *p = '\0';
+    s6len = p - gcode;
+    return gcode;
+}
+
+/*************************************************************************/
+
+char*
+sgtos6(sparsegraph *sg)
+/* Convert undirected sparse graph to sparse6 string including '\n'.
+  It is null-terminated and its address (static memory) is returned.
+  The length, not including the null, is put in s6len. */
+{
+    int *d,*e;
+    int i,j,n;
+    char *p,x,*plim;
+    int nb,topbit;
+    int dj,k,lastj;
+    int r,rr;
+    size_t ii,*v,vj,l;
+
+    SG_VDE(sg,v,d,e);
+    n = sg->nv;
+    for (i = n-1, nb = 0; i > 0 ; i >>= 1, ++nb) {}
+
+    ii = (size_t)(nb+1)*(n/6+sg->nde/3);
+    DYNALLOC1(char,gcode,gcode_sz,ii+1000,"sgtos6");
+    plim = gcode + gcode_sz - 20;
+
+    p = gcode;
+    *p++ = ':';
+    encodegraphsize(n,&p);
+
+    topbit = 1 << (nb-1);
+    k = 6;
+    x = 0;
+
+    lastj = 0;
+    for (j = 0; j < n; ++j)
+    {
+        vj = v[j];
+        dj = d[j];
+        for (l = 0; l < dj; ++l)
+        {
+            i = e[vj+l];
+            if (i <= j)
+            {
+                if (p >= plim)
+                {
+                    ii = p - gcode;
+                    DYNREALLOC(char,
+                               gcode,gcode_sz,5*(gcode_sz/4)+1000,"sgtos6");
+                    p = gcode + ii;
+                    plim = gcode + gcode_sz - 20;
+                }
+                if (j == lastj)
+                {
+                    x <<= 1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                }
+                else
+                {
+                    x = (x << 1) | (char)1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                    if (j > lastj+1)
+                    {
+                        for (r = 0, rr = j; r < nb; ++r, rr <<= 1)
+                        {
+                            if ((rr & topbit)) x = (x << 1) | (char)1;
+                            else               x <<= 1;
+                            if (--k == 0)
+                            {
+                                *p++ = (char)(BIAS6 + x);
+                                k = 6;
+                                x = 0;
+                            }
+                        }
+                            x <<= 1;
+                        if (--k == 0)
+                        {
+                            *p++ = (char)(BIAS6 + x);
+                            k = 6;
+                            x = 0;
+                        }
+                    }
+                    lastj = j;
+                }
+                for (r = 0, rr = i; r < nb; ++r, rr <<= 1)
+                {
+                    if ((rr & topbit)) x = (x << 1) | (char)1;
+                    else               x <<= 1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                }
+            }
+        }
+    }
+
+    if (k != 6)
+    {
+        if (k >= nb+1 && lastj == n-2 && n == (1<<nb))
+	    *p++ = (char)(BIAS6 + ((x << k) | ((1 << (k-1)) - 1)));
+        else
+	    *p++ = (char)(BIAS6 + ((x << k) | ((1 << k) - 1)));
+    }
+
+    *p++ = '\n';
+    *p = '\0';
+    s6len = p - gcode;
+    return gcode;
+}
+
+/*************************************************************************/
+
+char*
+sgtog6(sparsegraph *sg)
+/* Convert undirected sparse graph to graph6 string including '\n','\0'.
+  It is null-terminated and its address (static memory) is returned. */
+{
+    int *d,*e,*ei;
+    int i,j,n;
+    char *p;
+    size_t ii,*v,bodylen,org;
+    static char g6bit[] = {32,16,8,4,2,1};
+
+    SG_VDE(sg,v,d,e);
+    n = sg->nv;
+
+    ii = G6LEN(n)+3;
+
+    DYNALLOC1(char,gcode,gcode_sz,ii,"sgtog6");
+
+    p = gcode;
+    encodegraphsize(n,&p);
+
+    bodylen = G6BODYLEN(n);
+    for (ii = 0; ii < bodylen; ++ii) p[ii] = 0;
+    p[bodylen] = '\n';
+    p[bodylen+1] = '\0';
+
+    for (i = 0, org = 0; i < n;  org += i, ++i)
+    {
+	ei = e + v[i];
+	for (j = 0; j < d[i]; ++j)
+	    if (ei[j] < i)
+	    {
+		ii = ei[j] + org;
+		p[ii/6] |= g6bit[ii%6];
+	    }
+    }
+
+    for (ii = 0; ii < bodylen; ++ii) p[ii] += BIAS6;
+
+    return gcode;
+}
+
+/*************************************************************************/
+
+char*
+sgtod6(sparsegraph *sg)
+/* Convert undirected sparse graph to digraph6 string including '\n','\0'.
+  It is null-terminated and its address (static memory) is returned. */
+{
+    int *d,*e,*ei;
+    int i,j,n;
+    char *p;
+    size_t ii,*v,bodylen,org;
+    static char g6bit[] = {32,16,8,4,2,1};
+
+    SG_VDE(sg,v,d,e);
+    n = sg->nv;
+
+    ii = D6LEN(n)+3;
+
+    DYNALLOC1(char,gcode,gcode_sz,ii,"sgtog6");
+
+    p = gcode;
+    *p++ = '&';
+    encodegraphsize(n,&p);
+
+    bodylen = D6BODYLEN(n);
+    for (ii = 0; ii < bodylen; ++ii) p[ii] = 0;
+    p[bodylen] = '\n';
+    p[bodylen+1] = '\0';
+
+    for (i = 0, org = 0; i < n;  org += n, ++i)
+    {
+	ei = e + v[i];
+	for (j = 0; j < d[i]; ++j)
+	{
+	    ii = ei[j] + org;
+	    p[ii/6] |= g6bit[ii%6];
+	}
+    }
+
+    for (ii = 0; ii < bodylen; ++ii) p[ii] += BIAS6;
+
+    return gcode;
+}
+
+/**************************************************************************/
+
+void
+writeg6(FILE *f, graph *g, int m, int n)
+/* write graph to file in graph6 format */
+{
+    writeline(f,ntog6(g,m,n));
+}
+
+/**************************************************************************/
+
+void
+writed6(FILE *f, graph *g, int m, int n)
+/* write graph to file in digraph6 format */
+{
+    writeline(f,ntod6(g,m,n));
+}
+
+/**************************************************************************/
+
+void
+writes6(FILE *f, graph *g, int m, int n)
+/* write graph to file in sparse6 format */
+{
+    char *s;
+
+    s = ntos6(g,m,n);
+
+    if (fwrite(s,1,s6len,f) != s6len || ferror(f))
+        gt_abort(">E writes6 : error on writing\n");
+}
+
+/**************************************************************************/
+
+void
+writeis6(FILE *f, graph *g, graph *prevg, int m, int n)
+/* write graph to file in incremental sparse6 format
+   prevg can be NULL if there is no previous graph */
+{
+    char *s;
+
+    s = ntois6(g,prevg,m,n);
+
+    if (fwrite(s,1,s6len,f) != s6len || ferror(f))
+        gt_abort(">E writeis6 : error on writing\n");
+}
+
+/**************************************************************************/
+
+void
+writeg6_sg(FILE *f, sparsegraph *g)
+/* write undirected sparse graph to file in sparse6 format */
+{
+    writeline(f,sgtog6(g));
+}
+
+/**************************************************************************/
+
+void
+writed6_sg(FILE *f, sparsegraph *g)
+/* write undirected sparse graph to file in sparse6 format */
+{
+    writeline(f,sgtod6(g));
+}
+
+/**************************************************************************/
+
+void
+writes6_sg(FILE *f, sparsegraph *g)
+/* write undirected sparse graph to file in sparse6 format */
+{
+    char *s;
+
+    s = sgtos6(g);
+
+    if (fwrite(s,1,s6len,f) != s6len || ferror(f))
+        gt_abort(">E writes6 : error on writing\n");
+}
+
+/**************************************************************************/
+
+DYNALLSTAT(unsigned char,buff,buff_sz);
+
+void
+writepc_sg(FILE *f, sparsegraph *sg)
+/* write a sparse graph in planar_code format
+    *f = an open file
+    *sg = the graph to write
+*/
+{
+    int bytes;
+    size_t i,j,len,k,*v,vi;
+    unsigned int w;
+    int n,*d,*e,di;
+
+#define BEPUT1(x) buff[j++]=(unsigned char)(x);
+#define BEPUT2(x) w=(x); buff[j++]=(unsigned char)((w>>8)&0xFF); \
+                buff[j++]=(unsigned char)(w&0xff);
+#define BEPUT4(x) w=(x); buff[j++]=(unsigned char)((w>>24)&0xFF); \
+          buff[j++]=(unsigned char)((w>>16)&0xff); \
+          buff[j++]=(unsigned char)((w>>8)&0xFF); \
+          buff[j++]=(unsigned char)(w&0xff);
+
+    n = sg->nv;
+    SG_VDE(sg,v,d,e);
+
+    if (n <= 255)        bytes = 1;
+    else if (n <= 65535) bytes = 2;
+    else                 bytes = 4;
+
+    len = bytes * (1 + n + (size_t)(sg->nde));
+    if (bytes == 2)      len += 1;
+    else if (bytes == 4) len += 3;
+
+    DYNALLOC1(unsigned char,buff,buff_sz,len,"writepc_sg");
+
+    if (bytes == 1)
+    {
+	j = 0;
+	BEPUT1(n);
+	for (i = 0; i < n; ++i)
+	{
+	    vi = v[i];
+	    di = d[i];
+	    for (k = 0; k < di; ++k) { BEPUT1(e[vi+k]+1); }
+	    BEPUT1(0);
+	}
+    }
+    else if (bytes == 2)
+    {
+	j = 0;
+	BEPUT1(n);
+	BEPUT2(n);
+	for (i = 0; i < n; ++i)
+	{
+	    vi = v[i];
+	    di = d[i];
+	    for (k = 0; k < di; ++k) { BEPUT2(e[vi+k]+1); }
+	    BEPUT2(0);
+	}
+    }
+    else /* bytes==4 */
+    {
+	j = 0;
+	BEPUT1(n);
+	BEPUT2(n);
+	BEPUT4(n);
+	for (i = 0; i < n; ++i)
+	{
+	    vi = v[i];
+	    di = d[i];
+	    for (k = 0; k < di; ++k) { BEPUT4(e[vi+k]+1); }
+	    BEPUT4(0);
+	}
+    }
+
+    if (fwrite((void*)buff,1,j,f) != j)
+        gt_abort(">E writepc_sg : error on writing\n");
+}
+
+/**************************************************************************/
+
+sparsegraph*
+readpc_sg(FILE *f,sparsegraph *sg)
+/* read a planar_code graph into sparse graph format 
+    *f = an open file
+    *sg = place to put the answer (NULL for dynamic allocation) 
+        - must be initialised if not NULL 
+*/
+{
+#define BEGET1(x) { x = GETC(f); } 
+#define BEGET2(x) { w1=GETC(f); w2=GETC(f); if (w2==EOF) x = EOF; else \
+                 x = (w1<<8) | w2; }
+#define BEGET4(x) { w1=GETC(f); w2=GETC(f); w3=GETC(f); w4=GETC(f); \
+                 if (w4==EOF) x = EOF; \
+                 else x = (w1<<24) | (w2<<16) | (w3<<8) | w4; }
+    int w1,w2,w3,w4;
+    int bytes,n;
+    int i,j,*d,*e,di;
+    size_t *v,vi;
+
+    BEGET1(n);
+    if (n == EOF || n < 0) return NULL;
+    else if (n > 0)
+	bytes = 1;
+    else
+    {
+	BEGET2(n);
+	if (n == EOF || n < 0)
+	    gt_abort(">E readpc_sg : error 1 on reading\n");
+	else if (n > 0)
+	    bytes = 2;
+	else
+	{
+	    BEGET4(n);
+	    if (n == EOF || n < 0)
+	        gt_abort(">E readpc_sg : error 2 on reading\n");
+	    else if (n > 0)
+		bytes = 4;
+	    else
+	        gt_abort(">E readpc_sg : error 3 on reading\n");
+	}
+    }
+ 
+    if (sg == NULL)
+    {
+        if ((sg = (sparsegraph*)ALLOCS(1,sizeof(sparsegraph))) == NULL)
+            gt_abort(">E readpc_sg: malloc failed\n");
+        SG_INIT(*sg);
+    }
+
+    SG_ALLOC(*sg,n,2*(size_t)n,"readpc_sg");
+    SG_VDE(sg,v,d,e);
+
+    vi = 0;
+    for (i = 0; i < n; ++i)
+    {
+	v[i] = vi;
+	di = 0;
+	do
+	{
+	    if      (bytes == 1) BEGET1(j)
+            else if (bytes == 2) BEGET2(j)
+            else                 BEGET4(j);
+	    if (j == EOF) gt_abort(">E readpc_sg : error 4 on reading\n");
+
+	    if (j > 0)
+	    {
+		if (vi == sg->elen)
+		{
+		    DYNREALLOC(int,sg->e,sg->elen,2*sg->elen,"readpc_sg");
+		    e = sg->e;
+		}
+	        e[vi++] = j-1;
+		++di;
+	    }
+	    else if (j == 0)
+		d[i] = di;
+	    else
+		gt_abort(">E readpc_sg : error 5 on reading\n");
+	} while (j != 0);
+    }
+
+    sg->nv = n;
+    sg->nde = vi;
+    return sg;
+}
+
+/**************************************************************************/
+
+sparsegraph*
+readpcle_sg(FILE *f,sparsegraph *sg)
+/* read a planar_code graph into sparse graph format 
+    *f = an open file
+    *sg = place to put the answer (NULL for dynamic allocation) 
+        - must be initialised if not NULL 
+*/
+{
+#define LEGET1(x) { x = GETC(f); } 
+#define LEGET2(x) { w2=GETC(f); w1=GETC(f); if (w1==EOF) x = EOF; else \
+                 x = (w1<<8) | w2; }
+#define LEGET4(x) { w4=GETC(f); w3=GETC(f); w2=GETC(f); w1=GETC(f); \
+                 if (w1==EOF) x = EOF; \
+                 else x = (w1<<24) | (w2<<16) | (w3<<8) | w4; }
+    int w1,w2,w3,w4;
+    int bytes,n;
+    int i,j,*d,*e,di;
+    size_t *v,vi;
+
+    LEGET1(n);
+    if (n == EOF || n < 0) return NULL;
+    else if (n > 0)
+	bytes = 1;
+    else
+    {
+	LEGET2(n);
+	if (n == EOF || n < 0)
+	    gt_abort(">E readpcle_sg : error 1 on reading\n");
+	else if (n > 0)
+	    bytes = 2;
+	else
+	{
+	    LEGET4(n);
+	    if (n == EOF || n < 0)
+	        gt_abort(">E readpcle_sg : error 2 on reading\n");
+	    else if (n > 0)
+		bytes = 4;
+	    else
+	        gt_abort(">E readpcle_sg : error 3 on reading\n");
+	}
+    }
+ 
+    if (sg == NULL)
+    {
+        if ((sg = (sparsegraph*)ALLOCS(1,sizeof(sparsegraph))) == NULL)
+            gt_abort(">E readpcle_sg: malloc failed\n");
+        SG_INIT(*sg);
+    }
+
+    SG_ALLOC(*sg,n,2*(size_t)n,"readpcle_sg");
+    SG_VDE(sg,v,d,e);
+
+    vi = 0;
+    for (i = 0; i < n; ++i)
+    {
+	v[i] = vi;
+	di = 0;
+	do
+	{
+	    if (bytes == 1)      LEGET1(j)
+            else if (bytes == 2) LEGET2(j)
+            else                 LEGET4(j);
+	    if (j == EOF) gt_abort(">E readpcle_sg : error 4 on reading\n");
+
+	    if (j > 0)
+	    {
+		if (vi == sg->elen)
+		{
+		    DYNREALLOC(int,sg->e,sg->elen,2*sg->elen,"readpcle_sg");
+		    e = sg->e;
+		}
+	        e[vi++] = j-1;
+		++di;
+	    }
+	    else if (j == 0)
+		d[i] = di;
+	    else
+		gt_abort(">E readpcle_sg : error 5 on reading\n");
+	} while (j != 0);
+    }
+
+    sg->nv = n;
+    sg->nde = vi;
+    return sg;
+}
+
+/**************************************************************************/
+
+void
+writelast(FILE *f)
+/* write last graph read by readg() assuming no intervening gtools_getline() */
+{
+    writeline(f,readg_line);
+}
+
+/**************************************************************************/
+
+int
+longvalue(char **ps, long *l)
+{
+    boolean neg,pos;
+    long sofar,last;
+    char *s;
+
+    s = *ps;
+    pos = neg = FALSE;
+    if (*s == '-')
+    {
+        neg = TRUE;
+        ++s;
+    }
+    else if (*s == '+')
+    {
+        pos = TRUE;
+        ++s;
+    }
+
+    if (*s < '0' || *s > '9') 
+    {
+        *ps = s;
+        return (pos || neg) ? ARG_ILLEGAL : ARG_MISSING;
+    }
+
+    sofar = 0;
+
+    for (; *s >= '0' && *s <= '9'; ++s)
+    {
+        last = sofar;
+        sofar = sofar * 10 + (*s - '0');
+        if (sofar < last || sofar > MAXARG)
+        {
+            *ps = s;
+            return ARG_TOOBIG;
+        }
+    }
+    *ps = s;
+    *l = neg ? -sofar : sofar;
+    return ARG_OK;
+}
+    
+/**************************************************************************/
+
+int
+doublevalue(char **ps, double *l)
+{
+    boolean neg,pos;
+    double sofar,weight;
+    char *s;
+
+    s = *ps;
+    pos = neg = FALSE;
+    if (*s == '-')
+    {
+        neg = TRUE;
+        ++s;
+    }
+    else if (*s == '+')
+    {
+        pos = TRUE;
+        ++s;
+    }
+
+    if ((*s < '0' || *s > '9') && *s != '.') 
+    {
+        *ps = s;
+        return (pos || neg) ? ARG_ILLEGAL : ARG_MISSING;
+    }
+
+    sofar = 0.0;
+
+    for (; *s >= '0' && *s <= '9'; ++s)
+        sofar = sofar * 10 + (*s - '0');
+ 
+    if (*s == '.')
+    {
+	weight = 1.0;
+	for (++s; *s >= '0' && *s <= '9'; ++s)
+	{
+	    weight /= 10.0;
+	    sofar += weight * (*s - '0');
+	}
+    }
+
+    *ps = s;
+    *l = neg ? -sofar : sofar;
+    return ARG_OK;
+}
+
+/*************************************************************************/
+
+void
+arg_long(char **ps, long *val, char *id)
+{
+    int code;
+
+    code = longvalue(ps,val);
+    if (code == ARG_MISSING || code == ARG_ILLEGAL)
+    {
+        fprintf(stderr,">E %s: missing argument value\n",id);
+        gt_abort(NULL);
+    }
+    else if (code == ARG_TOOBIG)
+    {
+        fprintf(stderr,">E %s: argument value too large\n",id);
+        gt_abort(NULL);
+    }
+}
+
+/*************************************************************************/
+
+void
+arg_int(char **ps, int *val, char *id)
+{
+    int code;
+    long longval;
+
+    code = longvalue(ps,&longval);
+    *val = longval;
+    if (code == ARG_MISSING || code == ARG_ILLEGAL)
+    {
+        fprintf(stderr,">E %s: missing argument value\n",id);
+        gt_abort(NULL);
+    }
+    else if (code == ARG_TOOBIG || *val != longval)
+    {
+        fprintf(stderr,">E %s: argument value too large\n",id);
+        gt_abort(NULL);
+    }
+}
+
+/*************************************************************************/
+
+void
+arg_double(char **ps, double *val, char *id)
+{
+    int code;
+
+    code = doublevalue(ps,val);
+    if (code == ARG_MISSING || code == ARG_ILLEGAL)
+    {
+        fprintf(stderr,">E %s: missing argument value\n",id);
+        gt_abort(NULL);
+    }
+}
+
+/************************************************************************/
+
+boolean
+strhaschar(char *s, int c)
+/* Check if s contains c.  Saves the bother of figuring out whether
+  strchr() is available, or index() or whatever.  */
+{
+    int i;
+
+    for (i = 0; s[i] != '\0'; ++i)
+        if (s[i] == c) return TRUE;
+
+    return FALSE;
+}
+
+/************************************************************************/
+
+void
+arg_range(char **ps, char *sep, long *val1, long *val2, char *id)
+{
+    int code;
+    char *s;
+
+    s = *ps;
+    code = longvalue(&s,val1);
+    if (code != ARG_MISSING)
+    {
+        if (code == ARG_ILLEGAL)
+        {
+            fprintf(stderr,">E %s: bad range\n",id);
+            gt_abort(NULL);
+        }
+        else if (code == ARG_TOOBIG)
+        {
+            fprintf(stderr,">E %s: value too big\n",id);
+            gt_abort(NULL);
+        }
+    }
+    else if (*s == '\0' || !strhaschar(sep,*s))
+    {
+        fprintf(stderr,">E %s: missing value\n",id);
+        gt_abort(NULL);
+    }
+    else
+        *val1 = -NOLIMIT;
+
+    if (*s != '\0' && strhaschar(sep,*s))
+    {
+        ++s;
+        code = longvalue(&s,val2);
+        if (code == ARG_MISSING)
+            *val2 = NOLIMIT;
+        else if (code == ARG_TOOBIG)
+        {
+            fprintf(stderr,">E %s: value too big\n",id);
+            gt_abort(NULL);
+        }
+        else if (code == ARG_ILLEGAL)
+        {
+            fprintf(stderr,">E %s: illegal range\n",id);
+            gt_abort(NULL);
+        }
+    }
+    else
+        *val2 = *val1;
+
+    *ps = s;
+}
+
+/************************************************************************/
+
+void
+arg_sequence(char **ps, char *sep,
+             long *val, int maxvals, int *numvals, char *id)
+{
+    int code,ival;
+    char *s;
+
+    s = *ps;
+
+    for (ival = 0; ival < maxvals; ++ival)
+    {
+        code = longvalue(&s,&val[ival]);
+        if (code == ARG_ILLEGAL)
+        {
+            fprintf(stderr,">E %s: illegal value\n",id);
+            gt_abort(NULL);
+        }
+        else if (code == ARG_TOOBIG)
+        {
+            fprintf(stderr,">E %s: value too big\n",id);
+            gt_abort(NULL);
+        }
+	else if (code == ARG_MISSING)
+        {
+            fprintf(stderr,">E %s: value missing\n",id);
+            gt_abort(NULL);
+        }
+
+	if (*s == '\0' || !strhaschar(sep,*s))
+	{
+	    *numvals = ival+1;
+	    *ps = s;
+	    return;
+	}
+	++s;
+    }
+    fprintf(stderr,">E %s: too many values\n",id);
+    gt_abort(NULL);
+}
+
+/************************************************************************/
+
+void
+arg_sequence_min(char **ps, char *sep,
+             long *val, int minvals, int maxvals, int *numvals, char *id)
+{
+    int code,ival;
+    char *s;
+
+    s = *ps;
+
+    for (ival = 0; ival < maxvals; ++ival)
+    {
+        code = longvalue(&s,&val[ival]);
+        if (code == ARG_ILLEGAL)
+        {
+            fprintf(stderr,">E %s: illegal value\n",id);
+            gt_abort(NULL);
+        }
+        else if (code == ARG_TOOBIG)
+        {
+            fprintf(stderr,">E %s: value too big\n",id);
+            gt_abort(NULL);
+        }
+	else if (code == ARG_MISSING)
+        {
+            fprintf(stderr,">E %s: value missing\n",id);
+            gt_abort(NULL);
+        }
+
+	if (*s == '\0' || !strhaschar(sep,*s))
+	{
+	    *numvals = ival+1;
+	    *ps = s;
+	    if (*numvals < minvals)
+	    {
+		fprintf(stderr,">E %s: too few values\n",id);
+		gt_abort(NULL);
+	    }
+	    return;
+	}
+	++s;
+    }
+    fprintf(stderr,">E %s: too many values\n",id);
+    gt_abort(NULL);
+}
+
+/************************************************************************/
+
+void
+arg_doublerange(char **ps, char *sep, double *val1, double *val2, char *id)
+{
+    int code;
+    char *s;
+
+    s = *ps;
+    code = doublevalue(&s,val1);
+    if (code != ARG_MISSING)
+    {
+        if (code == ARG_ILLEGAL)
+        {
+            fprintf(stderr,">E %s: bad range\n",id);
+            gt_abort(NULL);
+        }
+    }
+    else if (*s == '\0' || !strhaschar(sep,*s))
+    {
+        fprintf(stderr,">E %s: missing value\n",id);
+        gt_abort(NULL);
+    }
+    else
+        *val1 = -NOLIMIT;
+
+    if (*s != '\0' && strhaschar(sep,*s))
+    {
+        ++s;
+        code = doublevalue(&s,val2);
+        if (code == ARG_MISSING)
+            *val2 = NOLIMIT;
+        else if (code == ARG_ILLEGAL)
+        {
+            fprintf(stderr,">E %s: illegal range\n",id);
+            gt_abort(NULL);
+        }
+    }
+    else
+        *val2 = *val1;
+
+    *ps = s;
+}
+
+/***********************************************************************/
+
+void
+writerange(FILE *f, int c, long lo, long hi)    /* Write a range. */
+{
+    if (c != '\0') fprintf(f,"%c",c);
+    if (lo != -NOLIMIT) fprintf(f,"%ld",lo);
+    if (lo != hi)
+    {
+        fprintf(stderr,":");
+        if (hi != NOLIMIT) fprintf(f,"%ld",hi);
+    }
+}
+
+/************************************************************************/
+
+void
+gt_abort(const char *msg)     /* Write message and halt. */
+{
+    if (msg) fprintf(stderr,"%s",msg);
+    ABORT(">E gtools");
+}
+
+/************************************************************************/
+
+char*
+stringcopy(char *s)   /* duplicate string */
+{
+    char *scopy;
+    size_t i,len;
+
+    for (len = 0; s[len] != '\0'; ++len)
+    {}
+
+    if ((scopy = (char*)ALLOCS(len+1,1)) == NULL)
+        gt_abort(">E stringcopy: malloc failed\n");
+
+    for (i = 0; i <= len; ++i)
+        scopy[i] = s[i];
+
+    return scopy;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  gtools_check() checks that this file is compiled compatibly with the      *
+*  given parameters.   If not, call exit(1).                                 *
+*                                                                            *
+*****************************************************************************/
+
+void
+gtools_check(int wordsize, int m, int n, int version)
+{
+    if (wordsize != WORDSIZE)
+    {
+        fprintf(ERRFILE,"Error: WORDSIZE mismatch in gtools.c\n");
+        exit(1);
+    }
+
+#if MAXN
+    if (m > MAXM)
+    {
+        fprintf(ERRFILE,"Error: MAXM inadequate in gtools.c\n");
+        exit(1);
+    }
+
+    if (n > MAXN)
+    {
+        fprintf(ERRFILE,"Error: MAXN inadequate in gtools.c\n");
+        exit(1);
+    }
+#endif
+
+    if (version < NAUTYREQUIRED)
+    {
+        fprintf(ERRFILE,"Error: gtools.c version mismatch\n");
+        exit(1);
+    }
+}
diff --git a/lib/nauty/gtools.h b/lib/nauty/gtools.h
new file mode 100644
index 0000000..b992140
--- /dev/null
+++ b/lib/nauty/gtools.h
@@ -0,0 +1,297 @@
+/*****************************************************************************
+* This is the main header file for gtools.  nauty version 2.6.               *
+* Subject to the copyright notice in nauty.h.                                *
+* gtools.h.  Generated from gtools-h.in by configure.
+*****************************************************************************/
+
+/* The parts between the ==== lines are modified by configure when
+creating gtools.h out of gtools-h.in.  If configure is not being
+used, it is necessary to check they are correct.
+====================================================================*/
+
+#ifndef  _GTOOLS_H_    /* only process this file once */
+#define  _GTOOLS_H_
+
+#define HAVE_ERRNO_H  1      /* <errno.h> exists */
+#define HAVE_PERROR  1          /* perror() exists */
+#define HAVE_PIPE  1          /* pipe() exists */
+#define HAVE_WAIT  1          /* wait() exists */
+#define HAVE_WAIT_H  1     /* <sys/wait.h> exists */
+#define HAVE_POPEN  1          /* popen() and pclose() exist */
+#define POPEN_DEC  1         /* popen() is declared in stdio.h */
+#define FTELL_DEC  1         /* ftell() is declared in stdio.h */
+#define FDOPEN_DEC  1        /* fdopen() is declared in stdio.h */
+#define SORTPROG  "sort"         /* name of sort program */
+#define SORT_NEWKEY 1  /* if -k is supported */
+#define HAVE_PID_T 1    /* pid_t is defined */
+#define PUTENV_DEC 1   /* putenv() is declared in stdlib.h */
+#define SETENV_DEC 1   /* setenv() is declared in stdlib.h */
+#define HAVE_PUTENV 1   /* putenv() exists */
+#define HAVE_SETENV 1   /* setenv() exists */
+#define HAVE_FORK 1   /* fork() exists */
+#define HAVE_PTHREADS 1   /* Posix threads exist */
+#define HAVE_PTHREAD_H  1      /* <pthread.h> exists */
+#define HAVE_SIGNAL_H  1      /* <signal.h> exists */
+#define HAVE_FSEEKO 1  /* fseeko() and ftello() exist */
+#define HAVE_SIGACTION 1  /* sigaction() exists */
+#define HAVE_SIGPROCMASK 1  /* sigprocmask() exists */
+#define ALLOW_INTERRUPT 1 /* no --disable-interrupt */
+
+/* ++++++ This file is automatically generated, don't edit it by hand! ++++++ */
+
+/*==================================================================*/
+
+#ifndef MAXN 
+#define MAXN  0
+#endif
+
+#define SIZELEN(n) ((n)<=SMALLN?1:((n)<=SMALLISHN?4:8))
+	/* length of size code in bytes */
+#define G6BODYLEN(n) \
+   (((size_t)(n)/12)*((size_t)(n)-1) + (((size_t)(n)%12)*((size_t)(n)-1)+11)/12)
+#define G6LEN(n) (SIZELEN(n) + G6BODYLEN(n))
+  /* exact graph6 string length excluding \n\0 
+     This twisted expression works up to n=227023 in 32-bit arithmetic
+     and for larger n if size_t has 64 bits.  */
+#define D6BODYLEN(n) \
+   ((n)*(size_t)((n)/6) + (((n)*(size_t)((n)%6)+5)/6))
+#define D6LEN(n) (1 + SIZELEN(n) + D6BODYLEN(n))
+  /* exact digraph6 string length excluding \n\0 
+     This twisted expression works up to n=160529 in 32-bit arithmetic
+     and for larger n if size_t has 64 bits.  */
+
+#include "naututil.h"      /* which includes stdio.h */
+#include "nausparse.h"
+
+#if HAVE_ERRNO_H
+#include <errno.h>
+#else
+extern int errno;
+#endif
+
+#if HAVE_WAIT_H
+#include <sys/wait.h>
+#endif
+
+#if HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+
+#if HAVE_PERROR
+#define ABORT(msg) do {if (errno != 0) perror(msg); exit(1);} while(0)
+#else
+#define ABORT(msg) do {exit(1);} while(0)
+#endif
+
+/* Here we set environment variables that determine the sorting order
+   for the shortg program.  Older docs for sort say that it uses
+   LC_COLLATE, but the POSIX description of locales says that the
+   LC_ALL variable takes precedence over LC_COLLATE.  To be safe,
+   we will define both.  Also, define this to be nothing if the
+   variable KEEP_SORT_LOCALE is defined. */
+#ifdef KEEP_SORT_LOCALE
+#define SET_C_COLLATION
+#else
+#if PUTENV_DEC && HAVE_PUTENV
+#define SET_C_COLLATION putenv("LC_ALL=C"); putenv("LC_COLLATE=C")
+#elif SETENV_DEC && HAVE_SETENV
+#define SET_C_COLLATION setenv("LC_ALL","C",1); setenv("LC_COLLATE","C",1)
+#elif HAVE_PUTENV
+int putenv(char*);
+#define SET_C_COLLATION putenv("LC_ALL=C"); putenv("LC_COLLATE=C")
+#elif HAVE_SETENV
+int setenv(const char*,const char*,int);
+#define SET_C_COLLATION setenv("LC_ALL","C",1); setenv("LC_COLLATE","C",1)
+#else
+#define SET_C_COLLATION
+#endif
+#endif
+
+#if HAS_STDIO_UNLOCK && !defined(NAUTY_IN_MAGMA) && !defined(IS_JAVA)
+#define FLOCKFILE(f) flockfile(f)
+#define FUNLOCKFILE(f) funlockfile(f)
+#define GETC(f) getc_unlocked(f)
+#undef PUTC
+#define PUTC(c,f) putc_unlocked(c,f)
+#else
+#define FLOCKFILE(f)
+#define FUNLOCKFILE(f)
+#define GETC(f) getc(f)
+#undef PUTC
+#define PUTC(c,f) putc(c,f)
+#endif
+
+#define BIAS6 63
+#define MAXBYTE 126
+#define SMALLN 62
+#define SMALLISHN 258047
+#define TOPBIT6 32
+#define C6MASK 63
+
+#define GRAPH6_HEADER ">>graph6<<"
+#define SPARSE6_HEADER ">>sparse6<<"
+#define DIGRAPH6_HEADER ">>digraph6<<"
+#define PLANARCODE_HEADER ">>planar_code<<"
+#define PLANARCODELE_HEADER ">>planar_code le<<"
+#define PLANARCODEBE_HEADER ">>planar_code be<<"
+#define EDGECODE_HEADER ">>edge_code<<"
+
+#define GRAPH6         1
+#define SPARSE6        2
+#define PLANARCODE     4
+#define PLANARCODELE   8
+#define PLANARCODEBE  16
+#define EDGECODE      32
+#define INCSPARSE6    64
+#define PLANARCODEANY (PLANARCODE|PLANARCODELE|PLANARCODEBE)
+#define DIGRAPH6     128
+#define UNKNOWN_TYPE 256
+#define HAS_HEADER   512
+
+#define NODIGRAPHSYET(code) if (((code)&DIGRAPH6)) \
+  gt_abort(">E Sorry, this program doesn't support digraphs yet.\n")
+
+#define ARG_OK 0
+#define ARG_MISSING 1
+#define ARG_TOOBIG 2
+#define ARG_ILLEGAL 3
+
+#define MAXARG 2000000000L
+#define NOLIMIT (MAXARG+31L)
+
+#define SWBOOLEAN(c,boool) if (sw==c) boool=TRUE;
+#define SWINT(c,boool,val,id) if (sw==c) \
+        {boool=TRUE;arg_int(&arg,&val,id);}
+#define SWLONG(c,boool,val,id) if (sw==c) \
+        {boool=TRUE;arg_long(&arg,&val,id);}
+#define SWRANGE(c,sep,boool,val1,val2,id) if (sw==c) \
+	{boool=TRUE;arg_range(&arg,sep,&val1,&val2,id);}
+#define SWREAL(c,boool,val,id) if (sw==c) \
+        {boool=TRUE;arg_double(&arg,&val,id);}
+#define SWREALRANGE(c,sep,boool,val1,val2,id) if (sw==c) \
+	{boool=TRUE;arg_doublerange(&arg,sep,&val1,&val2,id);}
+#define SWSEQUENCE(c,sep,boool,val,maxval,numvals,id) if (sw==c) \
+        {boool=TRUE;arg_sequence(&arg,sep,val,maxval,&numvals,id);}
+
+#ifdef HELPTEXT2 
+#define PUTHELPTEXT printf("\nUsage: %s\n\n%s",USAGE,HELPTEXT1);\
+		    printf("%s",HELPTEXT2);
+#else
+#define PUTHELPTEXT printf("\nUsage: %s\n\n%s",USAGE,HELPTEXT)
+#endif
+
+#define HELP if (argc > 1 && (strcmp(argv[1],"-help")==0 \
+			   || strcmp(argv[1],"/?")==0 \
+			   || strcmp(argv[1],"--help")==0)) \
+       { PUTHELPTEXT; return 0; }
+
+#define PUTVERSION if (argc > 1 && (strcmp(argv[1],"-version")==0 \
+			   || strcmp(argv[1],"--version")==0)) \
+       { printf("Nauty&Traces version %.4f (%d bits)\n",\
+       NAUTYVERSIONID/10000.0,WORDSIZE); return 0; }
+
+#define GETHELP \
+fprintf(stderr,"   Use %s -help to see more detailed instructions.\n",argv[0])
+
+#define alloc_error gt_abort
+
+#define CATMSG0(fmt) sprintf(msg+strlen(msg),fmt)
+#define CATMSG1(fmt,x1) sprintf(msg+strlen(msg),fmt,x1)
+#define CATMSG2(fmt,x1,x2) sprintf(msg+strlen(msg),fmt,x1,x2)
+#define CATMSG3(fmt,x1,x2,x3) sprintf(msg+strlen(msg),fmt,x1,x2,x3)
+#define CATMSG4(fmt,x1,x2,x3,x4) sprintf(msg+strlen(msg),fmt,x1,x2,x3,x4)
+#define CATMSG5(fmt,x1,x2,x3,x4,x5) sprintf(msg+strlen(msg),fmt,x1,x2,x3,x4,x5)
+#define CATMSG6(fmt,x1,x2,x3,x4,x5,x6) \
+		sprintf(msg+strlen(msg),fmt,x1,x2,x3,x4,x5,x6)
+
+/************************************************************************/
+
+/* ++++++ This file is automatically generated, don't edit it by hand! ++++++ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+ 
+extern void gtools_check(int,int,int,int);
+extern FILE *opengraphfile(char*,int*,boolean,long);
+extern void writeline(FILE*,char*);
+extern char *gtools_getline(FILE*);     /* formerly getline() */
+extern int graphsize(char*);
+extern void encodegraphsize(int,char**);
+extern void stringcounts(char*,int*,size_t*);
+extern void stringtograph(char*,graph*,int);
+extern void stringtograph_inc(char*,graph*,int,graph*,int);
+extern size_t edgecount(char*);
+extern int checkgline(char*);
+extern graph *readgg(FILE*,graph*,int,int*,int*,boolean*);
+extern graph *readg(FILE*,graph*,int,int*,int*);
+extern graph *readgg_inc(FILE*,graph*,int,int*,int*,graph*,int,int,boolean*);
+extern graph *readg_inc(FILE*,graph*,int,int*,int*,graph*,int,int);
+extern char *ntog6(graph*,int,int);
+extern char *ntos6(graph*,int,int);
+extern char *ntod6(graph*,int,int);
+extern char *sgtos6(sparsegraph*);
+extern char *sgtog6(sparsegraph*);
+extern char *sgtod6(sparsegraph*);
+extern void writeg6(FILE*,graph*,int,int);
+extern void writed6(FILE*,graph*,int,int);
+extern void writes6(FILE*,graph*,int,int);
+extern void writeg6_sg(FILE*,sparsegraph*);
+extern void writes6_sg(FILE*,sparsegraph*);
+extern void writed6_sg(FILE*,sparsegraph*);
+extern char *ntois6(graph*,graph*,int,int);
+extern void writeis6(FILE*,graph*,graph*,int,int);
+extern void writepc_sg(FILE*,sparsegraph*);
+extern void stringtosparsegraph(char*,sparsegraph*,int*);
+extern sparsegraph *read_sg(FILE*,sparsegraph*);
+extern sparsegraph *read_sg_loops(FILE*,sparsegraph*,int*);
+extern sparsegraph *read_sgg_loops(FILE*,sparsegraph*,int*,boolean*);
+extern sparsegraph *readpc_sg(FILE*,sparsegraph*);
+extern sparsegraph *readpcle_sg(FILE*,sparsegraph*);
+extern char *getecline(FILE*);
+extern void writelast(FILE*);
+extern int longval(char**,long*);
+extern void arg_int(char**,int*,char*);
+extern void arg_long(char**,long*,char*);
+extern void arg_range(char**,char*,long*,long*,char*);
+extern int doublevalue(char**,double*);
+extern void arg_double(char**,double*,char*);
+extern void arg_doublerange(char**,char*,double*,double*,char*);
+extern void arg_sequence(char**,char*,long*,int,int*,char*);
+
+extern void writerange(FILE*,int,long,long);
+extern void gt_abort(const char*);
+extern char *stringcopy(char*);
+extern boolean strhaschar(char*,int);
+
+extern void fcanonise(graph*,int,int,graph*,char*,boolean);
+extern void fcanonise_inv
+             (graph*,int,int,graph*,char*,void(*)(graph*,int*,int*,int,
+               int,int,int*,int,boolean,int,int),int,int,int,boolean);
+extern void fcanonise_inv_sg
+           (sparsegraph*,int,int,sparsegraph*,char*,void(*)(graph*,int*,int*,
+             int,int,int,int*,int,boolean,int,int),int,int,int,boolean);
+extern void setlabptn(int*,int*,int*,int);
+extern void fgroup(graph*,int,int,char*,int*,int*);
+extern void fgroup_inv
+	     (graph*,int,int,char*,int*,int*,void(*)(graph*,int*,int*,int,
+                int,int,int*,int,boolean,int,int),int,int,int);
+extern int istransitive(graph*,int,int,graph*);
+extern void tg_canonise(graph*,graph*,int,int);
+
+extern TLS_ATTR int readg_code;
+extern TLS_ATTR char *readg_line;
+extern TLS_ATTR size_t ogf_linelen;
+extern TLS_ATTR boolean is_pipe;
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef CPUDEFS
+CPUDEFS
+#endif
+
+/* ++++++ This file is automatically generated, don't edit it by hand! ++++++ */
+
+#endif /* _GTOOLS_H_  */
diff --git a/lib/nauty/gutil1.c b/lib/nauty/gutil1.c
new file mode 100644
index 0000000..34b04e5
--- /dev/null
+++ b/lib/nauty/gutil1.c
@@ -0,0 +1,851 @@
+/* gutil1.c: Some graph utilities. */
+
+#include "gtools.h"
+#include "gutils.h"
+
+/**************************************************************************/
+
+void
+degstats(graph *g, int m, int n, unsigned long *edges, int *mindeg,
+     int *mincount, int *maxdeg, int *maxcount, boolean *eulerian)
+/* Compute degree-related graph properties.
+   *edges = number of edges
+   *mindeg, *mincount = minimum degree and how many there are
+   *maxdeg, *maxcount = maximum degree and how many there are
+   *eulerian = whether the graph has only even degrees
+*/
+{
+    setword *pg;
+    int i,j,d,dor;
+    int mind,mindc,maxd,maxdc;
+    unsigned long ned;
+
+    mind = n;
+    mindc = 0;
+    maxd = 0;
+    maxdc = 0;
+    ned = 0;
+    dor = 0;
+
+    pg = (setword*)g;
+    for (i = 0; i < n; ++i)
+    {
+        d = 0;
+        for (j = 0; j < m; ++j, ++pg)
+            if (*pg) d += POPCOUNT(*pg);
+
+        if (d == mind)
+            ++mindc;
+        else if (d < mind)
+        {
+            mind = d;
+            mindc = 1;
+        }
+
+        if (d == maxd)
+            ++maxdc;
+        else if (d > maxd)
+        {
+            maxd = d;
+            maxdc = 1;
+        }
+
+        dor |= d;
+        ned += d;
+    }
+
+    *mindeg = mind;
+    *mincount = mindc;
+    *maxdeg = maxd;
+    *maxcount = maxdc;
+    *edges = ned / 2;
+    *eulerian = (dor & 1) == 0;
+}
+
+/**************************************************************************/
+
+void
+degstats2(graph *g, boolean digraph, int m, int n,
+     unsigned long *edges, int *loops,
+     int *minindeg, int *minincount, int *maxindeg, int *maxincount,
+     int *minoutdeg, int *minoutcount, int *maxoutdeg, int *maxoutcount,
+     boolean *eulerian)
+/* Compute degree-related graph properties.
+   *edges = number of edges (including loops), directed edges for digraphs
+   *loops = number of loops
+   *minindeg, *minincount = minimum in-degree and how many there are
+   *maxindeg, *maxincount = maximum in-degree and how many there are
+   *minoutdeg,*minoutcount,*maxoutdeg,*maxoutcount = similarly for out-degree
+   *eulerian = whether the undirected graph has only even degrees,
+               or the directed graph has indegree=outdegree at each vertex.
+   A loop contributes 2 to the degrees of an undirected graph and
+     1 to each degree for a directed graph.
+*/
+{
+    setword *pg;
+    int i,j,d,dor;
+    int mind,mindc,maxd,maxdc;
+    unsigned long ned;
+    int nloops;
+#if MAXN
+    int indeg[MAXN];
+    int outdeg[MAXN];
+#else
+    DYNALLSTAT(int,indeg,indeg_sz);
+    DYNALLSTAT(int,outdeg,outdeg_sz);
+#endif
+
+#if !MAXN
+    if (digraph)
+    {
+        DYNALLOC1(int,indeg,indeg_sz,n,"degstats2");
+        DYNALLOC1(int,outdeg,outdeg_sz,n,"degstats2");
+    }
+#endif
+
+    if (!digraph)
+    {
+        mind = n+2;
+        mindc = 0;
+        maxd = 0;
+        maxdc = 0;
+        ned = 0;
+        dor = 0;
+        nloops = 0;
+
+        pg = (setword*)g;
+        for (i = 0; i < n; ++i)
+        {
+            d = 0;
+	    if (ISELEMENT(pg,i))
+	    {
+		++d;
+		++nloops;
+	    }
+            for (j = 0; j < m; ++j, ++pg)
+                if (*pg) d += POPCOUNT(*pg);
+
+            if (d == mind)
+                ++mindc;
+            else if (d < mind)
+            {
+                mind = d;
+                mindc = 1;
+            }
+    
+            if (d == maxd)
+                ++maxdc;
+            else if (d > maxd)
+            {
+                maxd = d;
+                maxdc = 1;
+            }
+    
+            dor |= d;
+            ned += d;
+        }
+
+        *minindeg = *minoutdeg = mind;
+        *minincount = *minoutcount = mindc;
+        *maxindeg = *maxoutdeg = maxd;
+        *maxincount = *maxoutcount = maxdc;
+        *edges = ned / 2;
+        *eulerian = (dor & 1) == 0;
+        *loops = nloops;
+    }
+    else
+    {
+	for (i = 0; i < n; ++i) indeg[i] = outdeg[i] = 0;
+
+        nloops = 0;
+	ned = 0;
+	for (i = 0, pg = (setword*)g; i < n; ++i, pg += m)
+	{
+	    if (ISELEMENT(pg,i)) ++nloops;
+	    for (j = -1; (j = nextelement(pg,m,j)) >= 0;)
+	    {
+		++outdeg[i];
+		++indeg[j];
+	    }
+	    ned += outdeg[i];
+	}
+	*edges = ned;
+	*loops = nloops;
+
+        mind = maxd = indeg[0];
+        mindc = maxdc = 1;
+
+	for (i = 1; i < n; ++i)
+	{
+	    d = indeg[i];
+
+            if (d == mind)
+                ++mindc;
+            else if (d < mind)
+            {
+                mind = d;
+                mindc = 1;
+            }
+    
+            if (d == maxd)
+                ++maxdc;
+            else if (d > maxd)
+            {
+                maxd = d;
+                maxdc = 1;
+	    }
+	}
+	*minindeg = mind;
+        *minincount = mindc;
+	*maxindeg = maxd;
+        *maxincount = maxdc;
+
+        mind = maxd = outdeg[0];
+        mindc = maxdc = 1;
+
+	for (i = 1; i < n; ++i)
+	{
+	    d = outdeg[i];
+
+            if (d == mind)
+                ++mindc;
+            else if (d < mind)
+            {
+                mind = d;
+                mindc = 1;
+            }
+    
+            if (d == maxd)
+                ++maxdc;
+            else if (d > maxd)
+            {
+                maxd = d;
+                maxdc = 1;
+	    }
+	}
+	*minoutdeg = mind;
+        *minoutcount = mindc;
+	*maxoutdeg = maxd;
+        *maxoutcount = maxdc;
+
+	for (i = 0; i < n; ++i)
+	    if (indeg[i] != outdeg[i]) break;
+	*eulerian = (i == n);
+    }
+}
+
+/*********************************************************************/
+
+boolean
+isconnected1(graph *g, int n)
+/* test if g is connected (m=1) */
+{
+    setword seen,expanded,toexpand;
+    int i;
+
+    seen = bit[0];
+    expanded = 0;
+
+    while ((toexpand = (seen & ~expanded)) != 0)
+    {
+        i = FIRSTBITNZ(toexpand);
+        expanded |= bit[i];
+        seen |= g[i];
+    }
+
+    return  POPCOUNT(seen) == n;
+}
+
+/**************************************************************************/
+
+boolean
+isconnected(graph *g, int m, int n)
+/* Test if g is connected */
+{
+    int i,head,tail,w;
+    set *gw;
+#if MAXN
+    int queue[MAXN],visited[MAXN];
+#else
+    DYNALLSTAT(int,queue,queue_sz);
+    DYNALLSTAT(int,visited,visited_sz);
+#endif
+
+    if (m == 1) return isconnected1(g,n);
+
+#if !MAXN
+    DYNALLOC1(int,queue,queue_sz,n,"isconnected");
+    DYNALLOC1(int,visited,visited_sz,n,"isconnected");
+#endif
+
+    for (i = 0; i < n; ++i) visited[i] = 0;
+
+    queue[0] = 0;
+    visited[0] = 1;
+
+    head = 0;
+    tail = 1;
+    while (head < tail)
+    {
+        w = queue[head++];
+        gw = GRAPHROW(g,w,m);
+        for (i = -1; (i = nextelement(gw,m,i)) >= 0;)
+        {
+            if (!visited[i])
+            {
+                visited[i] = 1;
+                queue[tail++] = i;
+            }
+        }
+    }
+
+    return tail == n;
+}
+
+/**************************************************************************/
+ 
+boolean
+issubconnected(graph *g, set *sub, int m, int n)
+/* Test if the subset of g induced by sub is connected. Empty is connected. */
+{
+    int i,head,tail,w,subsize;
+    set *gw;
+#if MAXN
+    int queue[MAXN],visited[MAXN];
+    setword subw[MAXM];
+#else
+    DYNALLSTAT(int,queue,queue_sz);
+    DYNALLSTAT(int,visited,visited_sz);
+    DYNALLSTAT(set,subw,subw_sz);
+ 
+    DYNALLOC1(int,queue,queue_sz,n,"issubconnected");
+    DYNALLOC1(int,visited,visited_sz,n,"issubconnected");
+    DYNALLOC1(set,subw,subw_sz,m,"issubconnected");
+#endif
+ 
+    subsize = 0;
+    for (i = 0; i < m; ++i) subsize += (sub[i] ? POPCOUNT(sub[i]) : 0);
+ 
+    if (subsize <= 1) return TRUE;
+ 
+    for (i = 0; i < n; ++i) visited[i] = 0;
+ 
+    i = nextelement(sub,m,-1);
+    queue[0] = i;
+    visited[i] = 1;
+ 
+    head = 0;
+    tail = 1;
+    while (head < tail)
+    {
+        w = queue[head++];
+        gw = GRAPHROW(g,w,m);
+        for (i = 0; i < m; ++i) subw[i] = gw[i] & sub[i];
+ 
+        for (i = -1; (i = nextelement(subw,m,i)) >= 0;)
+        {
+            if (!visited[i])
+            {
+                visited[i] = 1;
+                queue[tail++] = i;
+            }
+        }
+    }
+ 
+    return tail == subsize;
+}
+ 
+/**********************************************************************/
+ 
+boolean
+isbiconnected1(graph *g, int n)
+/* Test if g is biconnected; version for m=1. */
+{
+    int sp,v,w;
+    setword sw;
+    int numvis;
+    setword visited;
+    int num[WORDSIZE],lp[WORDSIZE],stack[WORDSIZE];
+ 
+    if (n <= 2) return FALSE;
+ 
+    visited = bit[0];
+    stack[0] = 0;
+    num[0] = 0;
+    lp[0] = 0;
+    numvis = 1;
+    sp = 0;
+    v = 0;
+ 
+    for (;;)
+    {
+        if ((sw = g[v] & ~visited))           /* not "==" */
+        {
+            w = v;
+            v = FIRSTBITNZ(sw);       /* visit next child */
+            stack[++sp] = v;
+            visited |= bit[v];
+            lp[v] = num[v] = numvis++;
+            sw = g[v] & visited & ~bit[w];
+            while (sw)
+            {
+                w = FIRSTBITNZ(sw);
+                sw &= ~bit[w];
+                if (num[w] < lp[v])  lp[v] = num[w];
+            }
+        }
+        else
+        {
+            w = v;                  /* back up to parent */
+            if (sp <= 1)          return numvis == n;
+            v = stack[--sp];
+            if (lp[w] >= num[v])  return FALSE;
+            if (lp[w] < lp[v])    lp[v] = lp[w];
+        }
+    }
+}
+/**********************************************************************/
+ 
+boolean
+isbiconnected(graph *g, int m, int n)
+/* test if g is biconnected */
+{
+    int sp,v,vc;
+    int numvis;
+    set *gv;
+#if MAXN
+    int num[MAXN],lp[MAXN],stack[MAXN];
+#else
+    DYNALLSTAT(int,num,num_sz);
+    DYNALLSTAT(int,lp,lp_sz);
+    DYNALLSTAT(int,stack,stack_sz);
+#endif
+
+    if (n <= 2) return FALSE;
+    if (m == 1) return isbiconnected1(g,n);
+
+#if !MAXN
+    DYNALLOC1(int,num,num_sz,n,"isbiconnected");
+    DYNALLOC1(int,lp,lp_sz,n,"isbiconnected");
+    DYNALLOC1(int,stack,stack_sz,n,"isbiconnected");
+#endif
+ 
+    num[0] = 0;
+    for (v = 1; v < n; ++v) num[v] = -1;
+    lp[0] = 0;
+    numvis = 1;
+    sp = 0;
+    v = 0;
+    vc = -1;
+    gv = (set*)g;
+ 
+    for (;;)
+    {
+        vc = nextelement(gv,m,vc);
+        if (vc < 0)
+        {
+            if (sp <= 1)  return numvis == n;
+            vc = v;
+            v = stack[--sp];
+            gv = GRAPHROW(g,v,m);
+            if (lp[vc] >= num[v])  return FALSE;
+            if (lp[vc] < lp[v])    lp[v] = lp[vc];
+        }
+        else if (num[vc] < 0)
+        {
+            stack[++sp] = vc;
+            v = vc;
+            gv = GRAPHROW(g,v,m);
+            vc = -1;
+            lp[v] = num[v] = numvis++;
+        }
+        else if (vc != v)
+        {
+            if (num[vc] < lp[v])  lp[v] = num[vc];
+        }
+    }
+}
+
+/**************************************************************************/
+
+boolean
+twocolouring(graph *g, int *colour, int m, int n)
+/* If g is bipartite, set colour[*] to 0 or 1 to indicate an example
+   of 2-colouring and return TRUE.  Otherwise return FALSE.
+   Colour 0 is assigned to the first vertex of each component.  */
+{
+    int i,head,tail,v,w,need;
+    set *gw;
+    setword xg;
+#if MAXN
+    int queue[MAXN];
+#else
+    DYNALLSTAT(int,queue,queue_sz);
+#endif
+
+#if !MAXN
+    DYNALLOC1(int,queue,queue_sz,n,"twocolouring");
+#endif
+
+    for (i = 0; i < n; ++i) colour[i] = -1;
+
+    if (m == 1)
+    {
+        for (v = 0; v < n; ++v)
+            if (colour[v] < 0)
+            {
+                queue[0] = v;
+                colour[v] = 0;
+    
+                head = 0;
+                tail = 1;
+                while (head < tail) 
+                {
+                    w = queue[head++];
+                    need = 1 - colour[w];
+                    xg = g[w];
+		    while (xg)
+                    {
+			TAKEBIT(i,xg);
+                        if (colour[i] < 0)
+                        {
+                            colour[i] = need;
+                            queue[tail++] = i;
+                        }
+                        else if (colour[i] != need)
+                            return FALSE;
+                    }
+                }
+            }
+    }
+    else
+    {
+        for (v = 0; v < n; ++v)
+            if (colour[v] < 0)
+            {
+                queue[0] = v;
+                colour[v] = 0;
+    
+                head = 0;
+                tail = 1;
+                while (head < tail) 
+                {
+                    w = queue[head++];
+                    need = 1 - colour[w];
+                    gw = GRAPHROW(g,w,m);
+                    for (i = -1; (i = nextelement(gw,m,i)) >= 0;)
+                    {
+                        if (colour[i] < 0)
+                        {
+                            colour[i] = need;
+                            queue[tail++] = i;
+                        }
+                        else if (colour[i] != need)
+                            return FALSE;
+                    }
+                }
+            }
+     }
+
+    return TRUE;
+}
+
+/**************************************************************************/
+
+boolean
+isbipartite(graph *g, int m, int n)
+/* Test if g is bipartite */
+{
+#if MAXN
+    int colour[MAXN];
+#else
+    DYNALLSTAT(int,colour,colour_sz);
+
+    DYNALLOC1(int,colour,colour_sz,n,"isbipartite");
+#endif
+
+    return twocolouring(g,colour,m,n);
+}
+
+/**************************************************************************/
+
+int
+bipartiteside(graph *g, int m, int n)
+/* If g is not bipartite, return 0.
+   Otherwise return the size of the smallest of the two parts of
+    some 2-coluring.  Note that this is not isomorphism-invariant
+    if g is disconnected. */
+{
+    boolean isbip;
+    int i,sz;
+#if MAXN
+    int colour[MAXN];
+#else
+    DYNALLSTAT(int,colour,colour_sz);
+#endif
+
+#if !MAXN
+    DYNALLOC1(int,colour,colour_sz,n,"isbipartite");
+#endif
+
+    isbip = twocolouring(g,colour,m,n);
+    if (!isbip) return 0;
+
+    sz = 0;
+    for (i = 0; i < n; ++i) sz += colour[i];
+
+    if (sz+sz <= n) return sz;
+    else            return n - sz;
+}
+
+/**************************************************************************/
+
+int
+girth(graph *g, int m, int n)
+/* Find the girth of graph g.  0 means acyclic. */
+{
+    int i,head,tail,v,w;
+    int best,c,dw1;
+    set *gw;
+#if MAXN
+    int dist[MAXN],queue[MAXN];
+#else   
+    DYNALLSTAT(int,queue,queue_sz);
+    DYNALLSTAT(int,dist,dist_sz);
+    
+    DYNALLOC1(int,queue,queue_sz,n,"girth");
+    DYNALLOC1(int,dist,dist_sz,n,"girth");
+#endif  
+    
+    best = n+3;
+
+    for (v = 0; v < n; ++v)
+    {
+        for (i = 0; i < n; ++i) dist[i] = -1;
+
+        queue[0] = v;
+        dist[v] = 0;
+
+        head = 0;
+        tail = 1;
+        while (head < tail)
+        {
+            w = queue[head++];
+            gw = GRAPHROW(g,w,m);
+            dw1 = dist[w] + 1;
+            for (i = -1; (i = nextelement(gw,m,i)) >= 0;)
+            {
+                if (dist[i] < 0)
+                {
+                    dist[i] = dw1;
+                    queue[tail++] = i;
+                }
+                else if (dist[i] >= dist[w])
+                {
+                    c = dw1 + dist[i];
+                    if (c < best) best = c;
+                    if ((c & 1) != 0 || c > best) break;
+                }
+            }
+            if (i >= 0) break;
+        }
+        if (best == 3) return 3;
+    }
+
+    return (best > n ? 0 : best);
+}
+
+/**************************************************************************/
+
+void
+find_dist(graph *g, int m, int n, int v, int *dist)
+/* Put in dist[0..n-1] the distance of each vertex from v.
+   Vertices in a different component are given the distance n. */
+{
+    int i,head,tail,w;
+    set *gw;
+#if MAXN
+    int queue[MAXN];
+#else   
+    DYNALLSTAT(int,queue,queue_sz);
+#endif  
+    
+#if !MAXN
+    DYNALLOC1(int,queue,queue_sz,n,"isconnected");
+#endif  
+    
+    for (i = 0; i < n; ++i) dist[i] = n;
+
+    queue[0] = v;
+    dist[v] = 0;
+
+    head = 0;
+    tail = 1;
+    while (tail < n && head < tail)
+    {
+        w = queue[head++];
+        gw = GRAPHROW(g,w,m);
+        for (i = -1; (i = nextelement(gw,m,i)) >= 0;)
+        {
+            if (dist[i] == n)
+            {
+                dist[i] = dist[w] + 1;
+                queue[tail++] = i;
+            }
+        }
+    }
+}
+
+/**************************************************************************/
+
+void
+find_dist2(graph *g, int m, int n, int v, int w, int *dist)
+/* Put in dist[0..n-1] the distance of each vertex from {v,w}.
+   Vertices in a different component are given the distance n. */
+{
+    int i,head,tail,x;
+    set *gx;
+#if MAXN
+    int queue[MAXN];
+#else   
+    DYNALLSTAT(int,queue,queue_sz);
+#endif  
+    
+#if !MAXN
+    DYNALLOC1(int,queue,queue_sz,n,"isconnected");
+#endif  
+    
+    for (i = 0; i < n; ++i) dist[i] = n;
+
+    queue[0] = v;
+    queue[1] = w;
+    dist[v] = dist[w] = 0;
+
+    head = 0;
+    tail = 2;
+    while (tail < n && head < tail)
+    {
+        x = queue[head++];
+        gx = GRAPHROW(g,x,m);
+        for (i = -1; (i = nextelement(gx,m,i)) >= 0;)
+        {
+            if (dist[i] == n)
+            {
+                dist[i] = dist[x] + 1;
+                queue[tail++] = i;
+            }
+        }
+    }
+}
+
+/**************************************************************************/
+
+void
+diamstats(graph *g, int m, int n, int *radius, int *diameter)
+/* Find the radius and diameter.  Both -1 if g is disconnected.
+   We use an O(mn) algorithm, which is pretty disgraceful. */
+{
+    int v,i,head,tail,w;
+    int ecc,diam,rad;
+    set *gw;
+#if MAXN
+    int queue[MAXN],dist[MAXN];
+#else
+    DYNALLSTAT(int,queue,queue_sz);
+    DYNALLSTAT(int,dist,dist_sz);
+#endif
+
+    /* if (m == 1) {diamstats1(g,n,radius,diameter); return; } */
+
+#if !MAXN
+    DYNALLOC1(int,queue,queue_sz,n,"isconnected");
+    DYNALLOC1(int,dist,dist_sz,n,"isconnected");
+#endif
+
+    diam = -1;
+    rad = n;
+
+    for (v = 0; v < n; ++v)
+    {
+        for (i = 0; i < n; ++i) dist[i] = -1;
+
+        queue[0] = v;
+        dist[v] = 0;
+
+        head = 0;
+        tail = 1;
+        while (tail < n && head < tail)
+        {
+            w = queue[head++];
+            gw = GRAPHROW(g,w,m);
+            for (i = -1; (i = nextelement(gw,m,i)) >= 0;)
+            {
+                if (dist[i] < 0)
+                {
+                    dist[i] = dist[w] + 1;
+                    queue[tail++] = i;
+                }
+            }
+        }
+
+        if (tail < n)
+        {
+            *diameter = *radius = -1;
+            return;
+        }
+
+        ecc = dist[queue[n-1]];
+
+        if (ecc > diam) diam = ecc;
+        if (ecc < rad)  rad  = ecc;
+    }
+
+    *diameter = diam;
+    *radius = rad;
+}
+
+/**************************************************************************/
+
+static long
+maxclnode1(graph *g, setword cliq, setword cov, int maxv)
+/* Internal search node.  cov has all the vertices outside cliq that
+ * cover all of cliq.  maxv is the last vertex of cliq.
+ */
+{
+    long ans;
+    int i;
+    setword w;
+
+    if (cov == 0) return 1;
+
+    ans = 0;
+    w = cov & BITMASK(maxv);
+    while (w)
+    {
+        TAKEBIT(i,w);
+	ans += maxclnode1(g,cliq|bit[i],cov&g[i]&~bit[i],i);
+    }
+    return ans;
+}
+
+long
+maxcliques(graph *g, int m, int n)
+/* Find the number of maximal cliques */
+{
+    int i;
+    long ans;
+
+    if (m == 1)
+    {
+        ans = 0;
+	for (i = 0; i < n; ++i)
+	    ans += maxclnode1(g,bit[i],g[i],i);
+    }
+    else
+    {
+	fprintf(stderr,">E maxcliques() is only implemented for m=1\n");
+	exit(1);
+    }
+
+    return ans;
+}
diff --git a/lib/nauty/gutil2.c b/lib/nauty/gutil2.c
new file mode 100644
index 0000000..6d64228
--- /dev/null
+++ b/lib/nauty/gutil2.c
@@ -0,0 +1,558 @@
+/* gutil2.c: Some more graph utilities. */
+
+#include "gtools.h"
+#include "gutils.h"
+
+/**************************************************************************/
+
+int
+loopcount(graph *g, int m, int n)
+/* Number of loops */
+{
+    set *gi;
+    int i,nl;
+
+    nl = 0;
+    for (i = 0, gi = g; i < n; ++i, gi += m)
+	if (ISELEMENT(gi,i)) ++nl;
+
+    return nl;
+}
+
+/**************************************************************************/
+
+long
+pathcount1(graph *g, int start, setword body, setword last)
+/* Number of paths in g starting at start, lying within body and
+   ending in last.  {start} and last should be disjoint subsets of body. */
+{
+    long count;
+    setword gs,w;
+    int i;
+
+    gs = g[start];
+    w = gs & last;
+    count = POPCOUNT(w);
+
+    body &= ~bit[start];
+    w = gs & body;
+    while (w)
+    {
+	TAKEBIT(i,w);
+	count += pathcount1(g,i,body,last&~bit[i]);
+    }
+
+    return count;
+}
+
+/**************************************************************************/
+
+long
+cyclecount1(graph *g, int n)
+/* The total number of cycles in g (assumed no loops), m=1 only */
+{
+    setword body,nbhd;
+    long total;
+    int i,j;
+
+    body = ALLMASK(n);
+    total = 0;
+
+    for (i = 0; i < n-2; ++i)
+    {
+	body ^= bit[i];
+	nbhd = g[i] & body;
+	while (nbhd)
+	{
+	    TAKEBIT(j,nbhd);
+	    total += pathcount1(g,j,body,nbhd);
+	}
+    }
+
+    return total;
+}
+
+/**************************************************************************/
+
+long
+cyclecount(graph *g, int m, int n)
+/* The total number of cycles in g (assumed no loops) */
+{
+    if (m == 1) return cyclecount1(g,n);
+
+    gt_abort(">E cycle counting is only implemented for n <= WORDSIZE\n");
+    return 0;
+}
+
+/**************************************************************************/
+
+long
+indpathcount1(graph *g, int start, setword body, setword last)
+/* Number of induced paths in g starting at start, extravertices within
+ * body and ending in last.
+ * {start}, body and last should be disjoint. */
+{
+    long count;
+    setword gs,w;
+    int i;
+
+    gs = g[start];
+    w = gs & last;
+    count = POPCOUNT(w);
+
+    w = gs & body;
+    while (w)
+    {
+	TAKEBIT(i,w);
+	count += indpathcount1(g,i,body&~gs,last&~bit[i]&~gs);
+    }
+
+    return count;
+}
+
+/**************************************************************************/
+
+long
+indcyclecount1(graph *g, int n)
+/* The total number of induced cycles in g (assumed no loops), m=1 only */
+{
+    setword body,last,cni;
+    long total;
+    int i,j;
+
+    body = ALLMASK(n);
+    total = 0;
+
+    for (i = 0; i < n-2; ++i)
+    {
+	body ^= bit[i];
+	last = g[i] & body;
+	cni = g[i] | bit[i];
+	while (last)
+	{
+	    TAKEBIT(j,last);
+	    total += indpathcount1(g,j,body&~cni,last);
+	}
+    }
+
+    return total;
+}
+
+/**************************************************************************/
+
+long
+indcyclecount(graph *g, int m, int n)
+/* The total number of induced cycles in g (assumed no loops) */
+{
+    if (m == 1) return indcyclecount1(g,n);
+
+    gt_abort(
+      ">E induced cycle counting is only implemented for n <= WORDSIZE\n");
+    return 0;
+}
+
+/**************************************************************************/
+
+long
+numtriangles1(graph *g, int n)
+/* The number of triangles in g */
+{
+    int i,j;
+    setword gi,w;
+    long total;
+
+    total = 0;
+    for (i = 0; i < n-2; ++i)
+    {
+	gi = g[i] & BITMASK(i);
+	while (gi)
+	{
+	    TAKEBIT(j,gi);
+	    w = g[j] & gi;
+	    if (w) total += POPCOUNT(w);
+	}
+    }
+
+    return total;
+}
+
+/**************************************************************************/
+
+long
+numtriangles(graph *g, int m, int n)
+/* The number of triangles in g */
+{
+    int i,j,k,kw;
+    setword *gi,*gj,w;
+    long total;
+
+    if (m == 1) return numtriangles1(g,n);
+
+    total = 0;
+    for (i = 0, gi = g; i < n-2; ++i, gi += m)
+        for (j = i; (j = nextelement(gi,m,j)) > 0; )
+	{
+	    gj = GRAPHROW(g,j,m);
+	    kw = SETWD(j);
+	    w = gi[kw] & gj[kw] & BITMASK(SETBT(j));
+	    if (w) total += POPCOUNT(w);
+	    for (k = kw+1; k < m; ++k)
+	    {
+		w = gi[k] & gj[k];
+		if (w) total += POPCOUNT(w);
+	    }
+	}
+
+    return total;
+}    
+
+/**************************************************************************/
+
+long
+numdirtriangles(graph *g, int m, int n)
+/* The number of directed triangles in g */
+{
+    long total;
+    int i,j,k;
+    set *gi,*gj;
+
+    total = 0;
+    for (i = 0, gi = g; i < n-2; ++i, gi += m)
+	for (j = i; (j = nextelement(gi,m,j)) >= 0;)
+	{
+	    gj = GRAPHROW(g,j,m);
+	    for (k = i; (k = nextelement(gj,m,k)) >= 0; )
+		if (k != j && ISELEMENT(GRAPHROW(g,k,m),i)) ++total;
+	}
+
+    return total;
+} 
+
+/**************************************************************************/
+
+void
+commonnbrs(graph *g, int *minadj, int *maxadj, int *minnon, int *maxnon,
+       int m, int n)
+/* Count the common neighbours of pairs of vertices, and give the minimum
+   and maximum for adjacent and non-adjacent vertices.  Undirected only.
+   Null minimums are n+1 and null maximums are -1.
+*/
+{
+    int j,k;
+    int mina,maxa,minn,maxn;
+    int cn;
+    set *gi,*gj;
+    setword w;
+
+    mina = minn = n+1;
+    maxa = maxn = -1;
+
+    for (j = 0, gj = g; j < n; ++j, gj += m)
+    for (gi = g; gi != gj; gi += m)
+    {
+	cn = 0;
+	for (k = 0; k < m; ++k)
+	{
+	    w = gi[k] & gj[k];
+	    if (w) cn += POPCOUNT(w);
+	}
+
+	if (ISELEMENT(gi,j))
+	{
+	    if (cn < mina) mina = cn;
+	    if (cn > maxa) maxa = cn;
+	}
+	else
+	{
+	    if (cn < minn) minn = cn;
+	    if (cn > maxn) maxn = cn;
+	}
+    }
+
+    *minadj = mina;
+    *maxadj = maxa;
+    *minnon = minn;
+    *maxnon = maxn;
+}
+
+/**************************************************************************/
+
+void
+delete1(graph *g, graph *h, int v, int n)
+/* Delete vertex v from g, result in h */
+{
+    setword mask1,mask2,gi;
+    int i;
+
+    mask1 = ALLMASK(v);
+    mask2 = BITMASK(v);
+
+    for (i = 0; i < v; ++i)
+    {
+	gi = g[i];
+	h[i] = (gi & mask1) | ((gi & mask2) << 1);
+    }
+    for (i = v; i < n-1; ++i)
+    {
+	gi = g[i+1];
+	h[i] = (gi & mask1) | ((gi & mask2) << 1);
+    }
+}
+
+/**************************************************************************/
+
+void
+contract1(graph *g, graph *h, int v, int w, int n)  
+/* Contract distinct vertices v and w (not necessarily adjacent)
+   with result in h.  No loops are created. */
+{
+    int x,y;
+    setword bitx,bity,mask1,mask2;
+    int i;
+
+    if (w < v)
+    {
+	x = w; 
+	y = v;
+    }
+    else
+    {
+	x = v; 
+	y = w;
+    }
+
+    bitx = bit[x];
+    bity = bit[y];
+    mask1 = ALLMASK(y);
+    mask2 = BITMASK(y);
+
+    for (i = 0; i < n; ++i)
+        if (g[i] & bity)
+	    h[i] = (g[i] & mask1) | bitx | ((g[i] & mask2) << 1);
+	else
+	    h[i] = (g[i] & mask1) | ((g[i] & mask2) << 1);
+
+    h[x] |= h[y];
+    for (i = y+1; i < n; ++i) h[i-1] = h[i];
+    h[x] &= ~bitx;
+}
+
+/**************************************************************************/
+
+static TLS_ATTR int knm[18][16];  /* knm[n,m] = conncontent(K_n - m*K_2) */
+static TLS_ATTR boolean knm_computed = FALSE;
+
+int
+conncontent(graph *g, int m, int n)
+/* number of connected spanning subgraphs with an even number
+   of edges minus the number with an odd number of edges */
+{
+    graph h[WORDSIZE];
+    setword gj;
+    int i,j,v1,v2,x,y;
+    int minv,mindeg,deg,goodv;
+    long ne;
+    
+    if (m > 1) ABORT("conncontent only implemented for m=1");
+
+ /* First handle tiny graphs */
+
+    if (n <= 3)
+    {
+	if (n == 1) return 1;
+	if (n == 2) return (g[0] ? -1 : 0);
+	if (!g[0] || !g[1] || !g[2]) return 0;    /* disconnected */
+	if (g[0]^g[1]^g[2]) return 1;             /* path */
+	return 2;                                 /* triangle */
+    }
+
+ /* Now compute
+      ne = number of edges
+      mindeg = minimum degree
+      minv = a vertex of minimum degree
+      goodv = a vertex with a clique neighbourhood (-1 if none)
+ */
+
+    mindeg = n;
+    ne = 0;
+    goodv = -1;
+    for (j = 0; j < n; ++j)
+    {
+	gj = g[j];
+	deg = POPCOUNT(gj);
+	ne += deg;
+	if (deg < mindeg)
+	{
+	    mindeg = deg;
+	    minv = j;
+            if (deg == 1) goodv = j;
+	}
+	if (deg >= 3 && deg <= 4 && goodv < 0)
+	{
+	    while (gj)
+	    {
+		TAKEBIT(i,gj);
+		if (gj & ~g[i]) break;
+	    }
+	    if (!gj) goodv = j;
+	}
+    }
+    ne /= 2;
+
+/* Cases of isolated vertex or tree */
+
+    if (mindeg == 0) return 0;
+
+#if 0
+    if (mindeg == 1 && ne == n-1)
+    {
+	if (isconnected1(g,n)) return ((n&1) ? 1 : -1);
+	else		       return 0;
+    }
+#endif
+
+/* Cases of clique and near-clique */
+
+    if (mindeg == n-1)
+    {
+	j = -1;
+	for (i = 2; i < n; ++i) j *= -i;
+        return j;
+    }
+
+    if (mindeg == n-2 && n < 16)
+    {
+	if (!knm_computed)
+	{
+	    knm_computed = TRUE;
+	    knm[1][0] = 1;
+	    for (i = 2; i < 16; ++i)
+	    {
+		knm[i][0] = -knm[i-1][0] * (i-1);
+		for (j = 1; j+j <= i; ++j)
+		    knm[i][j] = knm[i][j-1] + knm[i-1][j-1];
+	    }
+	}
+	return knm[n][(n*n-n)/2-ne];
+    }
+
+/*  Case of vertex with clique neighbourhood */
+
+    if (goodv >= 0)
+    {
+	delete1(g,h,goodv,n);
+	return -POPCOUNT(g[goodv]) * conncontent(h,m,n-1);
+    }
+
+/* Case of minimum degree 2 */
+
+    if (mindeg == 2)
+    {
+	x = FIRSTBITNZ(g[minv]);
+	y = FIRSTBITNZ(g[minv]^bit[x]);
+	if (x > minv) --x;
+	if (y > minv) --y;
+	delete1(g,h,minv,n);
+	v1 = conncontent(h,m,n-1);
+	if (h[x] & bit[y]) return -2*v1;   /* adjacent neighbours */
+
+	h[x] |= bit[y];
+	h[y] |= bit[x];
+	v2 = conncontent(h,m,n-1);
+	return -v1 - v2;
+    }
+
+/* Case of more than 2/3 dense but not complete */
+
+    if (3*ne > n*n-n) 
+    {
+	j = FIRSTBITNZ(g[minv] ^ bit[minv] ^ ALLMASK(n));   /* non-neighbour */
+
+	g[minv] ^= bit[j];
+        g[j] ^= bit[minv];
+        v1 = conncontent(g,m,n);
+        g[minv] ^= bit[j];
+        g[j] ^= bit[minv];
+
+        contract1(g,h,minv,j,n);
+        v2 = conncontent(h,m,n-1);
+    
+        return v1 + v2;
+    }
+ 
+/* All remaining cases */
+
+    j = FIRSTBITNZ(g[minv]);     /* neighbour */
+
+    g[minv] ^= bit[j];
+    g[j] ^= bit[minv];
+    v1 = conncontent(g,m,n);
+    g[minv] ^= bit[j];
+    g[j] ^= bit[minv];
+    
+    contract1(g,h,minv,j,n);
+    v2 = conncontent(h,m,n-1);
+
+    return v1 - v2;
+}
+
+boolean
+stronglyconnected(graph *g, int m, int n)
+/* test if digraph g is strongly connected */
+{
+    int sp,v,vc;
+    int numvis;
+    set *gv;
+#if MAXN
+    int num[MAXN],lowlink[MAXN],stack[MAXN];
+#else
+    DYNALLSTAT(int,num,num_sz);
+    DYNALLSTAT(int,lowlink,lowlink_sz);
+    DYNALLSTAT(int,stack,stack_sz);
+#endif
+
+#if !MAXN
+    DYNALLOC1(int,num,num_sz,n,"stronglyconnected");
+    DYNALLOC1(int,lowlink,lowlink_sz,n,"stronglyconnected");
+    DYNALLOC1(int,stack,stack_sz,n,"stronglyconnected");
+#endif
+
+    num[0] = 0;
+    for (v = 1; v < n; ++v) num[v] = -1;
+    lowlink[0] = 0;
+    numvis = 1;
+    sp = 0;
+    v = 0;
+    vc = -1;
+    gv = (set*)g;
+
+    for (;;)
+    {
+        vc = nextelement(gv,m,vc);
+        if (vc < 0)
+        {
+            if (sp == 0) break;
+            if (lowlink[v] == num[v])  return FALSE;
+            vc = v;
+            v = stack[--sp];
+            gv = GRAPHROW(g,v,m);
+            if (lowlink[vc] < lowlink[v]) lowlink[v] = lowlink[vc];
+        }
+        else if (num[vc] < 0)
+        {
+            stack[++sp] = vc;
+            v = vc;
+            gv = GRAPHROW(g,v,m);
+            vc = -1;
+            lowlink[v] = num[v] = numvis++;
+        }
+        else if (vc != v)
+        {
+            if (num[vc] < lowlink[v])  lowlink[v] = num[vc];
+        }
+    }
+
+    return numvis == n;
+}
+
+/**************************************************************************/
diff --git a/lib/nauty/gutils.h b/lib/nauty/gutils.h
new file mode 100644
index 0000000..823b6d6
--- /dev/null
+++ b/lib/nauty/gutils.h
@@ -0,0 +1,46 @@
+/* gutils.h - procedure declarations for gutil1.c and gutil2.c */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void degstats(graph*,int,int,
+                     unsigned long*,int*,int*,int*,int*,boolean*);
+extern void degstats2(graph*,boolean,int,int,unsigned long*,int*l,
+     int*,int*,int*,int*, int*, int*,int*,int*, boolean*);
+extern void diamstats(graph*,int,int,int*,int*);
+extern void find_dist(graph*,int,int,int,int*);
+extern void find_dist2(graph*,int,int,int,int,int*);
+extern int girth(graph*,int,int);
+extern boolean isbiconnected1(graph*,int);
+extern boolean isbiconnected(graph*,int,int);
+extern boolean isbipartite(graph*,int,int);
+extern int bipartiteside(graph*,int,int);
+extern boolean twocolouring(graph*,int*,int,int);
+extern boolean isconnected1(graph*,int);
+extern boolean isconnected(graph*,int,int);
+extern boolean issubconnected(graph*,set*,int,int); 
+extern long maxcliques(graph*,int,int);
+
+extern int loopcount(graph*,int,int);
+extern long pathcount1(graph*,int,setword,setword);
+extern long cyclecount1(graph*,int);
+extern long cyclecount(graph*,int,int);
+extern long indpathcount1(graph*,int,setword,setword);
+extern long indcyclecount1(graph*,int);
+extern long indcyclecount(graph*,int,int);
+extern void commonnbrs(graph*,int*,int*,int*,int*,int,int);
+extern void contract1(graph*,graph*,int,int,int);
+extern int cstarcontent(graph*,int,int);
+extern long numtriangles1(graph*,int);
+extern long numtriangles(graph*,int,int);
+extern long numdirtriangles(graph*,int,int);
+extern void delete1(graph*,graph*,int,int);
+extern int conncontent(graph*,int,int);
+extern boolean stronglyconnected(graph*,int,int);
+
+/* extern int diameter_sg(sparsegraph*,int*,int*); */
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/nauty/hamheuristic.c b/lib/nauty/hamheuristic.c
new file mode 100644
index 0000000..ddaeaf6
--- /dev/null
+++ b/lib/nauty/hamheuristic.c
@@ -0,0 +1,433 @@
+/* hamheuristic.c  */
+
+#define USAGE "hamheuristic [-sgu] [-vq] [-L#] [-t#] [infile [outfile]]"
+
+#define HELPTEXT \
+" Apply a heuristic for finding hamiltonian cycles.\n\
+  Output those which are unsuccessful.\n\
+\n\
+    -s  force output to sparse6 format\n\
+    -g  force output to graph6 format\n\
+        If neither -s or -g are given, the output format is\n\
+        determined by the header or, if there is none, by the\n\
+        format of the first input graph.\n\
+    -u  Suppress output to outfile, give statistics instead.\n\
+\n\
+    The output file will have a header if and only if the input file does.\n\
+\n\
+    -p  Be content with a hamiltonian path\n\
+    -v  Give a cycle or path if one is found.\n\
+    -L# Limit number of sideways steps (default 1000+5*n)\n\
+    -t# Try # times (default 1)\n\
+\n\
+    -q  suppress auxiliary information\n"
+
+#define DEBUG(X) X
+
+/*************************************************************************/
+
+#include "gtools.h"
+
+#define NO 0
+#define YES 1
+#define TIMEOUT 2
+
+static long seed = 314159265;
+
+/**************************************************************************/
+
+static int
+hamheur(sparsegraph *sg, boolean pathok, unsigned long limit, int *cyc)
+/* Try up to limit, fill cyc if YES and cyc!=NULL */
+/* For payjok = TRUE, return when a hamiltonian path is found */
+{
+    DYNALLSTAT(int,path,path_sz);
+    DYNALLSTAT(int,work,work_sz);
+    DYNALLSTAT(int,pos,pos_sz);  /* position on path or -1 */
+    int end0,end1,v0,v1;
+    size_t *v;
+    int n,*e,*d,len,d0,*e0,d1,*e1,dx,*ex;
+    int i,ix,x,j,w,vext,exts;
+    unsigned long count;
+    boolean left,cycle;
+    long ran;
+ 
+    SG_VDE(sg,v,d,e);
+    n = sg->nv;
+    if (n < 3) return NO;
+
+    DYNALLOC1(int,path,path_sz,2*n+4,"malloc");
+    DYNALLOC1(int,pos,pos_sz,n,"malloc");
+    DYNALLOC1(int,work,work_sz,n,"malloc");
+
+    for (i = 0; i < n; ++i)
+    {
+	if (d[i] < 2) return NO;
+	pos[i] = -1;
+    }
+    count = 0;
+ 
+    v0 = KRAN(n);
+    v1 = e[v[v0]+KRAN(d[v0])];
+    end0 = n+1;
+    end1 = n+2;
+    path[end0] = v0; pos[v0] = end0;
+    path[end1] = v1; pos[v1] = end1;
+    len = 2;
+
+    for (; count < limit;)
+    {
+     /* First look for an extension, but note if cycle */
+
+	if (pathok && len == n)
+	{
+	    if (cyc)
+	    {
+	        j = 0;
+	        for (i = end0; i <= end1; ++i)
+		    cyc[j++] = path[i];
+	    }
+	    return YES;
+	}
+
+	v0 = path[end0];
+	v1 = path[end1];
+
+	exts = 0;
+	d0 = d[v0];
+        e0 = e + v[v0];
+	cycle = FALSE;
+        ran = NEXTRAN;
+	for (i = 0; i < d0; ++i)
+	{
+	    w = e0[i];
+	    if (pos[w] < 0)
+	    {
+		++exts;
+		if (ran%exts == 0) {left = TRUE; vext = w;}
+	    }
+	    else if (w == v1) cycle = TRUE;
+        }
+	d1 = d[v1];
+        e1 = e + v[v1];
+        ran = NEXTRAN;
+	for (i = 0; i < d1; ++i)
+	{
+	    w = e1[i];
+	    if (pos[w] < 0) 
+            {
+                ++exts;
+                if (ran%exts == 0) {left = FALSE; vext = w;}
+            }
+	}
+
+	if (exts > 0)
+	{
+	    if (left)
+	    {
+		--end0;
+		path[end0] = vext;
+		pos[vext] = end0;
+	    }
+	    else
+	    {
+		++end1;
+		path[end1] = vext;
+		pos[vext] = end1;
+	    }
+	    ++len;
+	    continue;
+	}
+
+     /* Can't extend but a cycle was found */
+
+	if (cycle)
+        {
+	    if (len == n)
+	    {
+		if (cyc)
+		{
+		    j = 0;
+		    for (i = pos[0]; i <= end1; ++i) cyc[j++] = path[i];
+		    for (i = end0; i < pos[0]; ++i) cyc[j++] = path[i];
+		}
+		return YES;
+	    }
+
+	    ix = end0 + KRAN(len);
+	    for (i = 0; i < len; ++i)      
+            {
+	        x = path[ix];
+
+	        exts = 0;
+	        dx = d[x];
+	        ex = e + v[x];
+		ran = NEXTRAN;
+	        for (j = 0; j < dx; ++j)
+	        {
+		    w = ex[j];
+		    if (pos[w] < 0) 
+                    {
+                        ++exts;
+                        if (ran%exts == 0) vext = w;
+                    }
+	        }
+		if (exts > 0) break;
+		if (ix == end1) ix = end0; else ++ix;
+            }
+	    if (i == len) return NO;    /* isolated component */
+
+	    work[0] = vext;
+	    j = 1;
+	    for (i = ix; i <= end1; ++i) work[j++] = path[i];
+	    for (i = end0; i < ix; ++i) work[j++] = path[i];
+
+	    for (i = 0; i < j; ++i)
+	    {
+		path[end0+i] = work[i];
+                pos[work[i]] = end0+i;
+	    }
+	    ++end1;
+	    ++len;
+	    continue;
+        }
+
+     /* In the last resort, do a sideways move. */
+    
+	exts = 0;
+	d0 = d[v0];
+        e0 = e + v[v0];
+        ran = NEXTRAN;
+	for (i = 0; i < d0; ++i)
+	{
+	    w = e0[i];
+	    if (pos[w] >= 0 && w != path[end0+1])
+	    {
+		++exts;
+		if (ran%exts == 0) {left = TRUE; vext = w;}
+	    }
+        }
+	d1 = d[v1];
+        e1 = e + v[v1];
+        ran = NEXTRAN;
+	for (i = 0; i < d1; ++i)
+	{
+	    w = e1[i];
+	    if (pos[w] >= 0 && w != path[end1-1]) 
+            {
+                ++exts;
+                if (ran%exts == 0) {left = FALSE; vext = w;}
+            }
+	}
+
+	if (left)
+	{
+	    i = end0;
+            j = pos[vext]-1;
+	}
+	else
+	{
+	    i = pos[vext]+1;
+	    j = end1;
+	}
+	for (; i < j; ++i, --j)
+	{
+	    w = path[i];
+	    path[i] = path[j];
+	    path[j] = w;
+	    pos[path[i]] = i;
+	    pos[path[j]] = j;
+	}
+
+	++count;
+    }
+
+    return TIMEOUT;
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    sparsegraph sg;
+    int n,codetype;
+    int argnum,i,j,outcode,tvalue;
+    char *arg,sw;
+    boolean badargs;
+    boolean pswitch,sswitch,gswitch,qswitch,Lswitch,tswitch,vswitch,uswitch;
+    long Lvalue;
+    double t;
+    char *infilename,*outfilename;
+    FILE *infile,*outfile;
+    nauty_counter nin,nout,nNO,nYES,nTIMEOUT;
+    int status;
+    DYNALLSTAT(int,cyc,cyc_sz);
+
+    HELP; PUTVERSION;
+
+    INITSEED;
+    ran_init(seed);
+
+    uswitch = sswitch = gswitch = Lswitch = qswitch = FALSE;
+    pswitch = vswitch = tswitch = FALSE;
+    infilename = outfilename = NULL;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('s',sswitch)
+                else SWBOOLEAN('g',gswitch)
+                else SWBOOLEAN('u',uswitch)
+                else SWBOOLEAN('p',pswitch)
+                else SWBOOLEAN('q',qswitch)
+                else SWBOOLEAN('v',vswitch)
+		else SWLONG('L',Lswitch,Lvalue,"-L")
+		else SWINT('t',tswitch,tvalue,"-t")
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if ((sswitch != 0) + (gswitch != 0) + (uswitch != 0) > 1)
+        gt_abort(">E hamheuristic: -s, -g and -u are incompatible\n");
+
+    if (!tswitch) tvalue = 1;
+
+    if (badargs || argnum > 2)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if (!qswitch)
+    {
+        fprintf(stderr,">A hamheuristic");
+        if (pswitch || sswitch || gswitch || vswitch || tswitch || Lswitch)
+            fprintf(stderr," -");
+        if (sswitch) fprintf(stderr,"s");
+        if (gswitch) fprintf(stderr,"g");
+        if (uswitch) fprintf(stderr,"u");
+        if (vswitch) fprintf(stderr,"v");
+        if (pswitch) fprintf(stderr,"p");
+	if (Lswitch) fprintf(stderr,"L%ld",Lvalue);
+	if (tswitch) fprintf(stderr,"t%d",tvalue);
+        if (argnum > 0) fprintf(stderr," %s",infilename);
+        if (argnum > 1) fprintf(stderr," %s",outfilename);
+        fprintf(stderr,"\n");
+        fflush(stderr);
+    }
+
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,FALSE,1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    NODIGRAPHSYET(codetype);
+
+    if (!uswitch)
+    {
+        if (!outfilename || outfilename[0] == '-')
+        {
+            outfilename = "stdout";
+            outfile = stdout;
+        }
+        else if ((outfile = fopen(outfilename,"w")) == NULL)
+        {
+            fprintf(stderr,"Can't open output file %s\n",outfilename);
+            gt_abort(NULL);
+        }
+
+        if (sswitch || (!gswitch && (codetype&SPARSE6)))
+            outcode = SPARSE6;
+        else 
+            outcode = GRAPH6;
+
+        if (codetype&HAS_HEADER)
+        {
+            if (outcode == SPARSE6) writeline(outfile,SPARSE6_HEADER);
+            else                    writeline(outfile,GRAPH6_HEADER);
+        }
+    }
+
+    nin = nout = 0;
+    nNO = nYES = nTIMEOUT = 0;
+    t = CPUTIME;
+    SG_INIT(sg);
+
+    while (read_sg(infile,&sg) != NULL)
+    {
+        ++nin;
+
+	n = sg.nv;
+
+        if (vswitch) { DYNALLOC1(int,cyc,cyc_sz,n,"malloc"); }
+	else         cyc = NULL;
+
+	status = TIMEOUT;
+	for (i = 0; i < tvalue; ++i)
+	{
+	    status = hamheur(&sg,pswitch,(Lswitch?Lvalue:1000+5*n),cyc);
+	    if (status != TIMEOUT) break;
+	}
+
+	if (status == NO) ++nNO;
+        else if (status == YES) ++nYES;
+        else ++nTIMEOUT;
+
+        if (status != YES && !uswitch)
+        {
+            if (outcode == SPARSE6) writes6_sg(outfile,&sg);
+            else if (outcode == GRAPH6) writeg6_sg(outfile,&sg);
+	    ++nout;
+	}
+
+	if (vswitch)
+	{
+	    fprintf(stderr,">H " COUNTER_FMT ":",nin);
+	    if (status == TIMEOUT)
+		fprintf(stderr," timed out\n");
+            else if (status == NO)
+                    fprintf(stderr," disconnected or low degree\n");
+	    else
+	    {
+		for (i = 0; i < n; ++i) fprintf(stderr," %d",cyc[i]);
+		fprintf(stderr,"\n");
+	    }
+	}
+    }
+    t = CPUTIME - t;
+
+    if (uswitch)
+    {
+	fprintf(stderr,">Z " COUNTER_FMT " graphs read from %s; "
+           COUNTER_FMT " hamiltonian, " COUNTER_FMT " not, "
+           COUNTER_FMT " timed out; %3.2f sec.\n",
+           nin,infilename,nYES,nNO,nTIMEOUT,t);
+    }
+    else if (!qswitch)
+    {
+        fprintf(stderr,
+                ">Z " COUNTER_FMT " graphs read from %s, "
+                COUNTER_FMT " written to %s; %3.2f sec.\n",
+                nin,infilename,nout,outfilename,t);
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/install-sh b/lib/nauty/install-sh
new file mode 100755
index 0000000..a8fff16
--- /dev/null
+++ b/lib/nauty/install-sh
@@ -0,0 +1,4 @@
+#  This is a dummy file to keep autoconf happy
+#  Since we don't provide an "install" target,
+#  it is an error for autoconf to complain when
+#  this file is absent.
diff --git a/lib/nauty/labelg.c b/lib/nauty/labelg.c
new file mode 100644
index 0000000..80d46ef
--- /dev/null
+++ b/lib/nauty/labelg.c
@@ -0,0 +1,440 @@
+/* labelg.c version 2.0; B D McKay, Jun 2015 */
+
+#define USAGE "labelg [-q] [sg | C#W#] [-fxxx] [-S|-t] [-i# -I#:# -K#] [infile [outfile]]"
+
+#define HELPTEXT \
+" Canonically label a file of graphs or digraphs.\n\
+\n\
+    -s  force output to sparse6 format\n\
+    -g  force output to graph6 format\n\
+    -z  force output to digraph6 format\n\
+        If neither -s, -g or -z are given, the output format is\n\
+        determined by the header or, if there is none, by the\n\
+        format of the first input graph. As an exception, digraphs\n\
+        are always written in digraph6 format.\n\
+    -S  Use sparse representation internally.\n\
+         Note that this changes the canonical labelling.\n\
+         Multiple edges are not supported.  One loop per vertex is ok.\n\
+    -t  Use Traces.\n\
+         Note that this changes the canonical labelling.\n\
+         Multiple edges and loops are not supported, nor invariants.\n\
+\n\
+    -C# Make an invariant in 0..#-1 and output the number of graphs\n\
+	with each value of the invariant.  Don't write graphs unless\n\
+        -W too.\n\
+    -W# (requires -C) Output the graphs with this invariant value,\n\
+        in their original labelling.  Don't write the table.\n\
+\n\
+    The output file will have a header if and only if the input file does.\n\
+\n\
+    -fxxx  Specify a partition of the point set.  xxx is any\n\
+        string of ASCII characters except nul.  This string is\n\
+        considered extended to infinity on the right with the\n\
+        character 'z'.  One character is associated with each point,\n\
+        in the order given.  The labelling used obeys these rules:\n\
+         (1) the new order of the points is such that the associated\n\
+        characters are in ASCII ascending order\n\
+         (2) if two graphs are labelled using the same string xxx,\n\
+        the output graphs are identical iff there is an\n\
+        associated-character-preserving isomorphism between them.\n\
+        No option can be concatenated to the right of -f.\n\
+\n\
+    -i#  select an invariant (1 = twopaths, 2 = adjtriang(K), 3 = triples,\n\
+        4 = quadruples, 5 = celltrips, 6 = cellquads, 7 = cellquins,\n\
+        8 = distances(K), 9 = indsets(K), 10 = cliques(K), 11 = cellcliq(K),\n\
+       12 = cellind(K), 13 = adjacencies, 14 = cellfano, 15 = cellfano2,\n\
+       16 = refinvar(K))\n\
+    -I#:#  select mininvarlevel and maxinvarlevel (default 1:1)\n\
+    -K#   select invararg (default 3)\n\
+\n\
+    -q  suppress auxiliary information\n"
+
+
+/*************************************************************************/
+
+#include "gtools.h"
+#include "nautinv.h"
+#include "gutils.h"
+#include "traces.h"
+
+static struct invarrec
+{
+    void (*entrypoint)(graph*,int*,int*,int,int,int,int*,
+                      int,boolean,int,int);
+    void (*entrypoint_sg)(graph*,int*,int*,int,int,int,int*,
+                      int,boolean,int,int);
+    char *name;
+} invarproc[]
+    = {{NULL, NULL, "none"},
+       {twopaths,   NULL, "twopaths"},
+       {adjtriang,  NULL, "adjtriang"},
+       {triples,    NULL, "triples"},
+       {quadruples, NULL, "quadruples"},
+       {celltrips,  NULL, "celltrips"},
+       {cellquads,  NULL, "cellquads"},
+       {cellquins,  NULL, "cellquins"},
+       {distances, distances_sg, "distances"},
+       {indsets,    NULL, "indsets"},
+       {cliques,    NULL, "cliques"},
+       {cellcliq,   NULL, "cellcliq"},
+       {cellind,    NULL, "cellind"},
+       {adjacencies, adjacencies_sg, "adjacencies"},
+       {cellfano,   NULL, "cellfano"},
+       {cellfano2,  NULL, "cellfano2"},
+       {refinvar,   NULL, "refinvar"}
+      };
+
+#define NUMINVARS ((int)(sizeof(invarproc)/sizeof(struct invarrec)))
+
+static nauty_counter orbtotal;
+static double unorbtotal;
+extern int gt_numorbits;
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+	graph *g;
+	sparsegraph sg,sh;
+	int m,n,codetype;
+	int argnum,j,outcode;
+	char *arg,sw,*fmt;
+	boolean badargs,digraph;
+	boolean sswitch,gswitch,qswitch,fswitch,Oswitch;
+	boolean iswitch,Iswitch,Kswitch,Mswitch,Sswitch;
+	boolean uswitch,tswitch,Cswitch,Wswitch,zswitch;
+	boolean dooutput;
+	int tabsize,outinvar;
+	int inv,mininvarlevel,maxinvarlevel,invararg;
+	long minil,maxil;
+	double t;
+	char *infilename,*outfilename;
+	FILE *infile,*outfile;
+	nauty_counter nin,nout;
+	int ii,secret,loops;
+	DEFAULTOPTIONS_TRACES(traces_opts);
+	TracesStats traces_stats;
+#if MAXN
+	graph h[MAXN*MAXM];
+	int lab[MAXN],ptn[MAXN],orbits[MAXN];
+#else
+	DYNALLSTAT(graph,h,h_sz);
+	DYNALLSTAT(int,lab,lab_sz);
+	DYNALLSTAT(int,ptn,ptn_sz);
+	DYNALLSTAT(int,orbits,orbits_sz);
+#endif
+        DYNALLSTAT(nauty_counter,tab,tab_sz);
+
+	HELP; PUTVERSION;
+
+	nauty_check(WORDSIZE,1,1,NAUTYVERSIONID);
+
+	sswitch = gswitch = qswitch = FALSE;
+	fswitch = Oswitch = Mswitch = FALSE;
+	iswitch = Iswitch = Kswitch = FALSE;
+	uswitch = Sswitch = tswitch = FALSE;
+	zswitch = Cswitch = Wswitch = FALSE;
+	infilename = outfilename = NULL;
+	inv = 0;
+
+	argnum = 0;
+	badargs = FALSE;
+	for (j = 1; !badargs && j < argc; ++j)
+	{
+	    arg = argv[j];
+	    if (arg[0] == '-' && arg[1] != '\0')
+	    {
+		++arg;
+		while (*arg != '\0')
+		{
+		    sw = *arg++;
+		         SWBOOLEAN('s',sswitch)
+		    else SWBOOLEAN('g',gswitch)
+		    else SWBOOLEAN('z',zswitch)
+		    else SWBOOLEAN('u',uswitch)
+		    else SWBOOLEAN('q',qswitch)
+		    else SWBOOLEAN('O',Oswitch)
+		    else SWBOOLEAN('S',Sswitch)
+		    else SWBOOLEAN('t',tswitch)
+		    else SWINT('C',Cswitch,tabsize,"labelg -C")
+		    else SWINT('W',Wswitch,outinvar,"labelg -W")
+		    else SWINT('i',iswitch,inv,"labelg -i")
+		    else SWINT('K',Kswitch,invararg,"labelg -K")
+		    else SWRANGE('k',":-",Iswitch,minil,maxil,"labelg -k")
+		    else SWRANGE('I',":-",Iswitch,minil,maxil,"labelg -I")
+		    else if (sw == 'f')
+		    {
+			fswitch = TRUE;
+			fmt = arg;
+			break;
+		    }
+		    else SWINT('M',Mswitch,secret,"labelg -M")
+		    else badargs = TRUE;
+		}
+	    }
+	    else
+	    {
+		++argnum;
+		if      (argnum == 1) infilename = arg;
+	        else if (argnum == 2) outfilename = arg;
+		else                  badargs = TRUE;
+	    }
+	}
+
+	if ((sswitch!=0) + (zswitch!=0) + (gswitch!=0) + (uswitch!=0) > 1)
+            gt_abort(">E labelg: -szgu are incompatible\n");
+
+	if (tswitch && (fswitch || Sswitch))
+            gt_abort(">E labelg: -t is incompatible with -S and -f \n");
+
+	if (iswitch && inv == 0) iswitch = FALSE;
+
+	if (!Sswitch && iswitch && (inv > NUMINVARS))
+	    gt_abort(">E labelg: -i value must be 0..16\n");
+	if (tswitch && iswitch)
+	    gt_abort(">E labelg: invariants are not available with -t\n");
+	if (Wswitch && (sswitch || gswitch || zswitch || uswitch || !Cswitch))
+            gt_abort(">E labelg: -W forbids -sgzu and requires -C\n");
+	if (Cswitch && tabsize <= 0)
+	    gt_abort(">E labelg: bad value for -C\n");
+	if (Wswitch && (outinvar < 0 || outinvar >= tabsize)) 
+	    gt_abort(">E labelg: value of -W is not valid\n");
+        if (Sswitch && iswitch && invarproc[inv].entrypoint_sg == NULL)
+	    gt_abort(
+                ">E labelg: that invariant is not available in sparse mode\n");
+
+
+	if (iswitch)
+	{
+	    if (Iswitch)
+	    {
+		mininvarlevel = minil;
+		maxinvarlevel = maxil;
+	    }
+	    else
+		mininvarlevel = maxinvarlevel = 1;
+	    if (!Kswitch) invararg = 3;
+	}
+
+	if (!Mswitch) secret = 1;
+
+	if (badargs || argnum > 2)
+	{
+	    fprintf(stderr,">E Usage: %s\n",USAGE);
+	    GETHELP;
+	    exit(1);
+	}
+
+	if (!qswitch)
+	{
+	    fprintf(stderr,">A labelg");
+	    if (sswitch || gswitch || fswitch || iswitch || zswitch
+			|| tswitch || Sswitch || Cswitch || Wswitch)
+		fprintf(stderr," -");
+	    if (sswitch) fprintf(stderr,"s");
+	    if (gswitch) fprintf(stderr,"g");
+	    if (zswitch) fprintf(stderr,"z");
+	    if (Sswitch) fprintf(stderr,"S");
+	    if (tswitch) fprintf(stderr,"t");
+	    if (Cswitch) fprintf(stderr,"C%d",tabsize);
+	    if (Wswitch) fprintf(stderr,"W%d",outinvar);
+	    if (iswitch)
+		fprintf(stderr,"i=%s[%d:%d,%d]",invarproc[inv].name,
+		        mininvarlevel,maxinvarlevel,invararg);
+	    if (fswitch) fprintf(stderr,"f%s",fmt);
+	    if (argnum > 0) fprintf(stderr," %s",infilename);
+	    if (argnum > 1) fprintf(stderr," %s",outfilename);
+	    fprintf(stderr,"\n");
+	    fflush(stderr);
+	}
+
+	if (Cswitch & !Wswitch)
+	{
+	    DYNALLOC1(nauty_counter,tab,tab_sz,tabsize,"table");
+	    for (j = 0; j < tabsize; ++j) tab[j] = 0;
+	}
+
+	if (infilename && infilename[0] == '-') infilename = NULL;
+	infile = opengraphfile(infilename,&codetype,FALSE,1);
+
+	if (!infile) exit(1);
+	if (!infilename) infilename = "stdin";
+
+	if (!outfilename || outfilename[0] == '-')
+	{
+	    outfilename = "stdout";
+	    outfile = stdout;
+	}
+	else if ((outfile = fopen(outfilename,"w")) == NULL)
+	{
+	    fprintf(stderr,"Can't open output file %s\n",outfilename);
+	    gt_abort(NULL);
+	}
+
+	if (uswitch)
+	    outcode = 0;
+	else if (Cswitch && !Wswitch)
+	    outcode = -1;
+	else if (Cswitch && Wswitch)
+	    outcode = -2;
+        else if (gswitch)
+            outcode = GRAPH6;
+        else if (sswitch)
+            outcode = SPARSE6;
+        else if (zswitch)
+            outcode = DIGRAPH6;
+	else if ((codetype&GRAPH6))
+	    outcode = GRAPH6;
+	else if ((codetype&SPARSE6))
+	    outcode = SPARSE6;
+	else if ((codetype&DIGRAPH6))
+	    outcode = DIGRAPH6;
+	else 
+        {
+	    outcode = GRAPH6;
+	    fprintf(stderr,
+                ">W labelg doesn't handle this graph format, writing graph6.\n");
+        }
+
+	dooutput = (outcode == GRAPH6 || outcode == DIGRAPH6 || outcode == SPARSE6);
+
+	if (!fswitch) fmt = NULL;
+
+	if (!uswitch && (codetype&HAS_HEADER))
+	{
+	    if (outcode == SPARSE6) writeline(outfile,SPARSE6_HEADER);
+	    else    		    writeline(outfile,GRAPH6_HEADER);
+	}
+
+	nin = nout = 0;
+	orbtotal = 0;
+	unorbtotal = 0.0;
+	t = CPUTIME;
+	if (Sswitch)
+	{
+	    SG_INIT(sg);
+	    SG_INIT(sh);
+	    while (TRUE)
+	    {
+		if (read_sgg_loops(infile,&sg,&loops,&digraph) == NULL) break;
+		++nin;
+		n = sg.nv;
+		m = (n + WORDSIZE - 1) / WORDSIZE;
+		SG_ALLOC(sh,n,sg.nde,"labelg");
+		for (ii = 0; ii < secret; ++ii)
+		    fcanonise_inv_sg(&sg,m,n,&sh,fmt,invarproc[inv].entrypoint_sg,
+		                 mininvarlevel,maxinvarlevel,invararg,loops>0||digraph);
+		sortlists_sg(&sh);
+	        orbtotal += gt_numorbits;
+	        unorbtotal += 1.0 / gt_numorbits;
+		if (dooutput && (outcode == DIGRAPH6 || digraph)) writed6_sg(outfile,&sh);
+	        else if (outcode == SPARSE6) writes6_sg(outfile,&sh);
+	        else if (outcode == GRAPH6) writeg6_sg(outfile,&sh);
+		else if (outcode == -1)
+		    ++tab[hashgraph_sg(&sh,137)%tabsize];
+		else if (outcode == -2 && (hashgraph_sg(&sh,137)%tabsize) == outinvar)
+		{
+		    writelast(outfile);
+		    ++nout;
+		}
+	    }
+	}
+	else if (tswitch)
+	{
+	    SG_INIT(sg);
+	    SG_INIT(sh);
+	    traces_opts.getcanon = TRUE;
+	    traces_opts.writeautoms = FALSE;
+	    traces_opts.verbosity = 0;
+	    traces_opts.outfile = stdout;
+	    
+	    while (TRUE)
+	    {
+		if (read_sgg_loops(infile,&sg,&loops,&digraph) == NULL) break;
+		if (loops > 0 || digraph) gt_abort(">E Traces does not allow loops or directed edges\n");
+		++nin;
+		n = sg.nv;
+	        DYNALLOC1(int,lab,lab_sz,n,"traces@labelg");
+	        DYNALLOC1(int,ptn,ptn_sz,n,"traces@labelg");
+	        DYNALLOC1(int,orbits,orbits_sz,n,"traces@labelg");
+		SG_ALLOC(sh,n,sg.nde,"labelg");
+		for (ii = 0; ii < n; ++ii) { lab[ii] = ii; ptn[ii] = 1; }
+		ptn[n-1] = 0;
+		for (ii = 0; ii < secret; ++ii)
+		    Traces(&sg,lab,ptn,orbits,&traces_opts,&traces_stats,&sh);
+		sortlists_sg(&sh);
+	        orbtotal += gt_numorbits;
+	        unorbtotal += 1.0 / gt_numorbits;
+	        if (outcode == SPARSE6) writes6_sg(outfile,&sh);
+	        else if (outcode == GRAPH6) writeg6_sg(outfile,&sh);
+		else if (outcode == -1)
+		    ++tab[hashgraph_sg(&sh,137)%tabsize];
+		else if (outcode == -2 && (hashgraph_sg(&sh,137)%tabsize) == outinvar)
+		{
+		    writelast(outfile);
+		    ++nout;
+		}
+		SG_FREE(sh);
+	    }
+	}
+	else
+	{
+	    while (TRUE)
+	    {
+	        if ((g = readgg(infile,NULL,0,&m,&n,&digraph)) == NULL) break;
+	        ++nin;
+#if !MAXN
+	        DYNALLOC2(graph,h,h_sz,n,m,"labelg");
+#endif
+		loops = loopcount(g,m,n);
+	        for (ii = 0; ii < secret; ++ii)
+	            fcanonise_inv(g,m,n,h,fmt,invarproc[inv].entrypoint,
+			        mininvarlevel,maxinvarlevel,invararg,loops>0||digraph);
+	        orbtotal += gt_numorbits;
+	        unorbtotal += 1.0 / gt_numorbits;
+		if (dooutput && (outcode == DIGRAPH6 || digraph)) writed6(outfile,h,m,n);
+	        else if (outcode == SPARSE6) writes6(outfile,h,m,n);
+	        else if (outcode == GRAPH6) writeg6(outfile,h,m,n);
+		else if (outcode == -1)
+		    ++tab[hashgraph(h,m,n,137)%tabsize];
+		else if (outcode == -2 && (hashgraph(h,m,n,137)%tabsize) == outinvar)
+		{
+		    writelast(outfile);
+		    ++nout;
+		}
+	        FREES(g);
+	    }
+	}
+	t = CPUTIME - t;
+
+	if (Oswitch)
+	    fprintf(stderr,">C orbit totals = " COUNTER_FMT " %15.8f\n",
+			   orbtotal,unorbtotal);
+        if (!qswitch)
+	{
+	    if (outcode == -1)
+	    {
+		for (j = 0; j < tabsize; ++j)
+		    fprintf(stderr,">C %5d " COUNTER_FMT "\n",j,tab[j]);
+		fprintf(stderr,">Z " COUNTER_FMT " total from %s in %3.2f sec.\n",
+		    nin,infilename,t);
+	    }
+	    else if (outcode == -2)
+	    {
+                fprintf(stderr,
+                    ">Z " COUNTER_FMT " out of " COUNTER_FMT
+                    " graphs copied from %s to %s in %3.2f sec.\n",
+                    nout,nin,infilename,outfilename,t);
+	    }
+	    else
+	    {
+                fprintf(stderr,
+                        ">Z " COUNTER_FMT
+                        " graphs labelled from %s to %s in %3.2f sec.\n",
+                    nin,infilename,outfilename,t);
+	    }
+	}
+
+	exit(0);
+}
diff --git a/lib/nauty/linegraphg.c b/lib/nauty/linegraphg.c
new file mode 100644
index 0000000..4734a57
--- /dev/null
+++ b/lib/nauty/linegraphg.c
@@ -0,0 +1,328 @@
+/* linegraphg.c  version 1.2; B D McKay, Jan 2016. */
+
+#define USAGE "linegraphg [-t] [-q] [infile [outfile]]"
+
+#define HELPTEXT \
+" Take the linegraphs of a file of graphs.\n\
+  Input graphs with no edges produce only a warning message.\n\
+\n\
+    The output file has a header if and only if the input file does.\n\
+\n\
+    -t  make the total graph\n\
+    -q  Suppress auxiliary information.\n"
+
+/*************************************************************************/
+
+#include "gtools.h" 
+
+/**************************************************************************/
+
+static void
+linegraph(sparsegraph *g, sparsegraph *h)
+/* h := linegraph of g */
+/* Has the side effect of sorting the edge lists of g */
+{
+    DYNALLSTAT(size_t,eno,eno_sz);   /* edge number */
+    int *ge,*gd,*he,*hd;
+    size_t *gv,*hv;
+    int gnv,hnv,jj;
+    size_t i,j,k,gnde,hnde,xhnde,num;
+    size_t hi,lo,mid,v,w;
+
+    sortlists_sg(g);
+    SG_VDE(g,gv,gd,ge);
+    gnv = g->nv;
+    gnde = g->nde;
+    DYNALLOC1(size_t,eno,eno_sz,gnde,"linegraphg");
+
+    hnv = gnde/2;
+    if (hnv != gnde/2) gt_abort(">E linegraphg: too many input edges\n");
+
+    hnde = 0;
+    num = 0;
+    for (i = 0; i < gnv; ++i)
+    {
+        xhnde = hnde;
+        hnde += gd[i]*((size_t)gd[i]-1);
+        if (hnde < xhnde) gt_abort(">E linegraphg: too many output edges\n");
+
+        for (j = gv[i]; j < gv[i]+gd[i]; ++j)
+        {
+            if (ge[j] == i)
+                gt_abort(">E linegraphg can't handle loops\n");
+            else if (ge[j] > i)
+                eno[j] = num++;
+            else
+            {
+                lo = gv[ge[j]];
+                hi = lo + gd[ge[j]] - 1;
+                while (lo <= hi)
+                {
+                    mid = lo + (hi-lo)/2;
+                    if (ge[mid] == i) break;
+                    else if  (ge[mid] < i) lo = mid+1;
+                    else hi = mid-1;
+                }
+		if (lo > hi)
+		    gt_abort(">E linegraphg : binary search failed\n");
+                eno[j] = eno[mid];
+            }
+        }
+    }
+
+    SG_ALLOC(*h,hnv,hnde,"linegraphg");
+    h->nv = hnv;
+    h->nde = hnde;
+    SG_VDE(h,hv,hd,he);
+
+    for (i = 0; i < hnv; ++i) hd[i] = 0;
+    for (i = 0; i < gnv; ++i)
+    {
+        for (j = gv[i]; j < gv[i]+gd[i]; ++j)
+            hd[eno[j]] += gd[i]-1;
+    }
+
+    hv[0] = 0;
+    for (i = 1; i < hnv; ++i) hv[i] = hv[i-1] + hd[i-1];
+    for (i = 0; i < hnv; ++i) hd[i] = 0;
+
+    for (i = 0; i < gnv; ++i)
+    {
+        for (jj = 0; jj < gd[i]-1; ++jj)
+	{
+	    j = gv[i] + jj;
+            for (k = j+1; k < gv[i]+gd[i]; ++k)
+            {
+                v = eno[j]; w = eno[k];
+                he[hv[v]+(hd[v]++)] = w;
+                he[hv[w]+(hd[w]++)] = v;
+            }
+	}
+    }
+}
+
+/**************************************************************************/
+
+static void
+totalgraph(sparsegraph *g, sparsegraph *h)
+/* h := total graph of g */
+/* Has the side effect of sorting the edge lists of g */
+{
+    DYNALLSTAT(size_t,eno,eno_sz);   /* edge number */
+    int *ge,*gd,*he,*hd;
+    size_t *gv,*hv;
+    int gnv,hnv,jj;
+    size_t i,j,k,gnde,hnde,xhnde,num;
+    size_t hi,lo,mid,v,w;
+
+    sortlists_sg(g);
+    SG_VDE(g,gv,gd,ge);
+    gnv = g->nv;
+    gnde = g->nde;
+    DYNALLOC1(size_t,eno,eno_sz,gnde,"linegraphg");
+
+    hnv = gnv + gnde/2;
+    if (hnv - gnv != gnde/2) gt_abort(">E linegraphg: too many input edges\n");
+
+    hnde = 3*gnde;
+    if (hnde/3 != gnde) gt_abort(">E linegraphg: too many output edges\n");
+    num = gnv;
+    for (i = 0; i < gnv; ++i)
+    {
+        xhnde = hnde;
+        hnde += gd[i]*((size_t)gd[i]-1);
+        if (hnde < xhnde) gt_abort(">E linegraphg: too many output edges\n");
+
+        for (j = gv[i]; j < gv[i]+gd[i]; ++j)
+        {
+            if (ge[j] == i)
+                gt_abort(">E linegraphg can't handle loops\n");
+            else if (ge[j] > i)
+                eno[j] = num++;
+            else
+            {
+                lo = gv[ge[j]];
+                hi = lo + gd[ge[j]] - 1;
+                while (lo <= hi)
+                {
+                    mid = lo + (hi-lo)/2;
+                    if (ge[mid] == i) break;
+                    else if  (ge[mid] < i) lo = mid+1;
+                    else hi = mid-1;
+                }
+		if (lo > hi)
+		    gt_abort(">E linegraphg : binary search failed\n");
+                eno[j] = eno[mid];
+            }
+        }
+    }
+
+    SG_ALLOC(*h,hnv,hnde,"linegraphg");
+    h->nv = hnv;
+    h->nde = hnde;
+    SG_VDE(h,hv,hd,he);
+
+    for (i = 0; i < gnv; ++i) hd[i] = 2*gd[i];
+    for (i = gnv; i < hnv; ++i) hd[i] = 2;
+
+    for (i = 0; i < gnv; ++i)
+    {
+        for (j = gv[i]; j < gv[i]+gd[i]; ++j)
+            hd[eno[j]] += gd[i]-1;
+    }
+
+    hv[0] = 0;
+    for (i = 1; i < hnv; ++i) hv[i] = hv[i-1] + hd[i-1];
+    if (hnde - hv[hnv-1] != hd[hnv-1])
+        gt_abort(">E linegraphg: too many output edges\n");
+    for (i = 0; i < hnv; ++i) hd[i] = 0;
+
+    for (i = 0; i < gnv; ++i)
+    {
+        for (j = gv[i]; j < gv[i]+gd[i]; ++j)
+	{
+	    v = eno[j];
+	    he[hv[i]+(hd[i]++)] = ge[j];
+	    he[hv[i]+(hd[i]++)] = v;
+	    he[hv[v]+(hd[v]++)] = i;
+	}
+    }
+
+    for (i = 0; i < gnv; ++i)
+    {
+        for (jj = 0; jj < gd[i]-1; ++jj)
+	{
+	    j = gv[i] + jj;
+            for (k = j+1; k < gv[i]+gd[i]; ++k)
+            {
+                v = eno[j]; w = eno[k];
+                he[hv[v]+(hd[v]++)] = w;
+                he[hv[w]+(hd[w]++)] = v;
+            }
+	}
+    }
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    char *infilename,*outfilename;
+    FILE *infile,*outfile;
+    boolean badargs,quiet,tswitch;
+    int j,argnum;
+    int codetype,outcode;
+    sparsegraph g,h;
+    nauty_counter nin,nullgraphs;
+    char *arg,sw;
+    double t;
+
+    HELP; PUTVERSION;
+
+    SG_INIT(g);
+    SG_INIT(h);
+
+    infilename = outfilename = NULL;
+    quiet = tswitch = FALSE;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+		     SWBOOLEAN('t',tswitch)
+                else SWBOOLEAN('q',quiet)
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if (!quiet)
+    {
+        fprintf(stderr,">A linegraphg");
+        if (argnum > 0) fprintf(stderr," %s",infilename);
+        if (argnum > 1) fprintf(stderr," %s",outfilename);
+        fprintf(stderr,"\n");
+        fflush(stderr);
+    }
+
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,FALSE,1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    NODIGRAPHSYET(codetype);
+
+    if (!outfilename || outfilename[0] == '-')
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename,"w")) == NULL)
+    {
+        fprintf(stderr,"Can't open output file %s\n",outfilename);
+        gt_abort(NULL);
+    }
+
+    if (codetype&SPARSE6) outcode = SPARSE6;
+    else                  outcode = GRAPH6;
+
+    if (codetype&HAS_HEADER)
+    {
+        if (outcode == SPARSE6) writeline(outfile,SPARSE6_HEADER);
+        else                    writeline(outfile,GRAPH6_HEADER);
+    }
+
+    nin = 0;
+    nullgraphs = 0;
+    t = CPUTIME;
+    while (read_sg(infile,&g))
+    {
+        ++nin;
+
+        if (g.nde > 0 || tswitch)
+        {
+            if (tswitch) totalgraph(&g,&h);
+            else         linegraph(&g,&h);
+            if (outcode == SPARSE6) writes6_sg(outfile,&h);
+            else                    writeg6_sg(outfile,&h);
+        }
+        else
+            ++nullgraphs;
+    }
+    t = CPUTIME - t;
+
+    if (!quiet)
+    {
+        if (nullgraphs > 0)
+            fprintf(stderr,">W " COUNTER_FMT " null graphs not written\n",
+                    nullgraphs);
+
+        fprintf(stderr,">Z " COUNTER_FMT
+                " graphs converted from %s to %s in %3.2f sec.\n",
+                nin,infilename,outfilename,t);
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/listg.c b/lib/nauty/listg.c
new file mode 100644
index 0000000..168374e
--- /dev/null
+++ b/lib/nauty/listg.c
@@ -0,0 +1,634 @@
+/* listg.c  version 2.2; B D McKay, Aug 2016 */
+
+#define USAGE \
+ "listg [-fp#:#l#o#Ftq] [-a|-A|-c|-d|-e|-H|-M|-s|-b|-G|-y|-Yxxx]" \
+       " [infile [outfile]]"
+
+#define HELPTEXT \
+" Write graphs in human-readable format.\n\
+\n\
+    -f  : assume inputs have same size (only used from a file\n\
+           and only if -p is given)\n\
+    -p#, -p#:#, -p#-# : only display one graph or a sequence of\n\
+           graphs.  The first graph is number 1.  A second number\n\
+           which is empty or zero means infinity.\n\
+	   This option won't work for incremental input.\n\
+    -a  : write as adjacency matrix, not as list of adjacencies\n\
+    -A  : same as -a with a space between entries\n\
+    -l# : specify screen width limit (default 78, 0 means no limit)\n\
+          This is not currently implemented with -a or -A.\n\
+    -o# : specify number of first vertex (default is 0).\n\
+    -d  : write output to satisfy dreadnaut \n\
+    -c  : write ascii form with minimal line-breaks\n\
+    -e  : write a list of edges, preceded by the order and the\n\
+          number of edges\n\
+    -H  : write in HCP operations research format\n\
+    -M  : write in Magma format\n\
+    -W  : write matrix in Maple format\n\
+    -b  : write in Bliss format\n\
+    -G  : write in GRAPE format\n\
+    -y  : write in dot file format\n\
+    -Yxxx : extra dotty commands for dot files (arg continues to end of param)\n\
+    -t  : write upper triangle only (affects -a, -A, -d and default)\n\
+    -s  : write only the numbers of vertices and edges\n\
+    -F  : write a form-feed after each graph except the last\n\
+    -q  : suppress auxiliary output\n\
+\n\
+    -a, -A, -c, -d, -M, -W, -H and -e are incompatible.\n"
+
+#define MAPLE_MATRIX 1  /* 1 for Matrix(..), 0 for array(..) */
+
+/*************************************************************************
+
+    June 26, 2007 : Fix error in putve() reported by Evan Heidtmann
+    March 3, 2013 : Allow incremental input
+    June 18, 2015 : Add digraph code
+
+*************************************************************************/
+
+#include "gtools.h"
+#define LABELORG 0   /* number of first vertex (any integer >= 0) */
+#define LINELEN CONSOLWIDTH   /* max characters per line (0 = no limit) */
+
+static FILE *infile,*outfile;
+static unsigned long nin;
+extern int labelorg;
+
+/*****************************************************************************
+*  putsetx(f,set1,curlenp,linelength,m,compress,start)   writes the set      *
+*  set1 to file f using at most linelength characters per line (excluding    *
+*  '\n').   Set elements less than or equal to start are ignored.            *
+*  *curlenp is the number of characters on the line so far; it is updated.   *
+*  A range j1,j1+1,...,j2 for j2-j1>=2 is written as "j1:j2" if compress     *
+*  is nonzero (eg. TRUE); otherwise each element is written separately.      *
+*  No final '\n' is written.  labelorg is used.                              *
+*                                                                            *
+*  FUNCTIONS CALLED: nextelement(),itos()                                    *
+*                                                                            *
+*****************************************************************************/
+
+static void
+putsetx(FILE *f, set *set1, int *curlenp, int linelength, int m,
+        boolean compress, int start)
+{
+    int slen,j1,j2;
+    char s[40];
+    boolean first;
+
+    first = TRUE;
+    j1 = start;
+    while ((j1 = nextelement(set1,m,j1)) >= 0)
+    {
+        j2 = j1;
+        if (compress)
+        {
+            while (nextelement(set1,m,j2) == j2 + 1)
+                ++j2;
+            if (j2 == j1+1)
+                j2 = j1;
+        }
+        slen = itos(j1 + labelorg,s);
+        if (j2 >= j1 + 2)
+        {
+            s[slen] = ':';
+            slen += 1 + itos(j2 + labelorg,&s[slen+1]);
+        }
+
+        if (*curlenp + slen + 1 >= linelength && linelength > 0)
+        {
+            fprintf(f,"\n ");
+            *curlenp = 1;
+        }
+        if (first)
+        {
+            fprintf(f,"%s",s);
+            *curlenp += slen;
+            first = FALSE;
+        }
+        else
+        {    
+            fprintf(f," %s",s);
+            *curlenp += slen + 1;
+        }
+        j1 = j2;
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  STOLEN FROM naututil.c                                                    *
+*  putgraphx(f,g,linelength,m,n) writes a list of the edges of g to f        *
+*  using at most linelength characters per line (excluding '\n').            *
+*  If triang, only write the upper triangle.                                 *
+*  labelorg is used.                                                         *
+*                                                                            *
+*****************************************************************************/
+
+static void
+putgraphx(FILE *f, graph *g, int linelength, boolean triang, int m, int n)
+{
+    int i,curlen;
+    set *pg;
+
+    for (i = 0, pg = g; i < n; ++i, pg += m)
+    {
+        fprintf(f,"%3d : ",i + labelorg);
+        curlen = 7;
+        putsetx(f,pg,&curlen,linelength,m,FALSE,triang ? i-1 : -1);
+        fprintf(f,";\n");
+    }
+}
+
+/***************************************************************************/
+
+static void
+putedges(FILE *f, graph *g, boolean ptn, int linelength, 
+         boolean digraph, int m, int n)
+/* Write list of edges, preceded by the numbers of vertices and
+   edges and optionally by "1" if "ptn" is TRUE.  Use labelorg */
+{
+    int i,j,curlen,ne;
+    char s[20];
+    set *pg;
+
+    ne = 0;
+    for (i = 0, pg = g; i < n; ++i, pg += m)
+    {
+        for (j = (digraph?-1:i-1); (j = nextelement(pg,m,j)) >= 0;)
+            ++ne;
+    }
+
+    if (ptn) fprintf(f,"%d %d 1\n",n,ne);
+    else     fprintf(f,"%d %d\n",n,ne);
+
+    curlen = 0;
+    for (i = 0, pg = g; i < n; ++i, pg += m)
+    {
+        for (j = (digraph ? -1 : i-1); (j = nextelement(pg,m,j)) >= 0;)
+        { 
+            if (curlen > 0 && curlen > linelength - 10 && linelength > 0)
+            {
+                fprintf(f,"\n");
+                curlen = 0;
+            }
+            if (curlen > 0)
+            {
+                fprintf(f,"  ");
+                curlen += 2;
+            }
+            curlen += itos(i+labelorg,s);
+            fprintf(f,"%s",s);
+            fprintf(f," ");
+            curlen += 1 + itos(j+labelorg,s);
+            fprintf(f,"%s",s);
+        }
+    }
+    fprintf(f,"\n");
+}
+
+/***************************************************************************/
+
+static void
+putHCP(FILE *f, graph *g, int m, int n)
+/* Write list of edges in HCP format.  labelorg is ignored */
+{
+    int i,j,curlen,ne;
+    char s[20];
+    set *pg;
+
+    fprintf(f,"NAME : G%lu\n",nin);
+    fprintf(f,"TYPE : HCP\n");
+    fprintf(f,"DIMENSION : %d\n",n);
+    fprintf(f,"EDGE_DATA_FORMAT : EDGE_LIST\n");
+    fprintf(f,"EDGE_DATA_SECTION\n");
+
+    for (i = 0, pg = g; i < n; ++i, pg += m)
+    {
+        for (j = -1; (j = nextelement(pg,m,j)) >= 0;)
+            fprintf(f,"%d %d\n",i+1,j+1);
+    }
+    fprintf(f,"-1\nEOF\n");
+}
+
+/***************************************************************************/
+
+static void
+putcgraph(FILE *f, graph *g, int linelength, boolean digraph, int m, int n)
+/* write compressed form, using labelorg */
+{
+    int i,curlen,j0;
+    int semicolons;
+    char s[20];
+    set *pg;
+
+    curlen = itos(n,s)+2;
+    fprintf(f,";n%s%s",s,(digraph?"dg":"g"));
+
+    semicolons = 0;
+    for (i = 0, pg = g; i < n; ++i, pg += m)
+    {
+	j0 = digraph ? -1: i-1;
+        if (nextelement(pg,m,j0) >= 0)
+        {
+            while (semicolons > 0)
+            {
+                if (curlen >= linelength-1 && linelength > 0)
+                {
+                    fprintf(f,"\n ");
+                    curlen = 1;
+                }
+                fprintf(f,";");
+                ++curlen;
+                --semicolons;
+            }
+            putsetx(f,pg,&curlen,linelength,m,FALSE,j0);
+            semicolons = 1;
+        }
+        else
+            ++semicolons;
+    }
+    fprintf(f,".\n");
+}
+
+/**************************************************************************/
+
+static void
+putve(FILE *f, unsigned long id, graph *g, boolean digraph, int m, int n)
+/* Write the numbers of vertices and edges */
+{
+    unsigned long ne;
+    setword x,*pg;
+
+    ne = 0;
+    for (pg = g + m*(size_t)n; --pg >= g;)
+        if ((x = *pg) != 0) ne += POPCOUNT(x);
+
+    fprintf(f,"Graph %lu has %d vertices and %lu edges.\n",id,n,
+            (digraph?ne:ne/2));
+}
+
+/**************************************************************************/
+
+static void
+putGRAPE(FILE *f, graph *g, int m, int n)
+/* Write the graph in GRAPE format */
+{
+    int i,j;
+    setword *pg;
+    boolean first;
+
+    fprintf(f,
+       "rec( isGraph:=true, order:=%d, group:=Group([],()),\n",n);
+    fprintf(f,
+       "  representatives := Immutable([1..%d]),\n",n);
+    fprintf(f,"  adjacencies := [\n");
+    
+    for (i = 0, pg = g; i < n; ++i, pg += m)
+    {
+	first = TRUE;
+	fprintf(f,"   [");
+        for (j = nextelement(pg,m,-1); j >= 0; j = nextelement(pg,m,j))
+	{
+	    if (!first) fprintf(f,",");
+            fprintf(f,"%d",j+1);
+	    first = FALSE;
+	}
+	if (i < n-1) fprintf(f,"],\n");
+	else         fprintf(f,"]],\n");
+    }
+
+    fprintf(f,"  schreierVector := Immutable([-1,-2..-%d]) )",n);
+}
+
+/**************************************************************************/
+
+static void
+putdotty(FILE *f, graph *g, unsigned long id, char *extras, int m, int n)
+/* Write the graph in dotty format */
+{
+    int i,j;
+    setword *pg;
+    boolean first;
+
+    fprintf(f,"graph G%lu {\n",id);
+    if (extras) fprintf(f,"%s\n",extras);
+
+    for (i = 0, pg = g; i < n; ++i, pg += m)
+    {
+        for (j = nextelement(pg,m,i); j >= 0; j = nextelement(pg,m,j))
+	{
+            fprintf(f,"%d--%d;\n",labelorg+i,labelorg+j);
+	}
+    }
+
+    fprintf(f,"}\n");
+}
+
+/**************************************************************************/
+
+static void
+putbliss(FILE *f, unsigned long id, graph *g, int m, int n)
+/* Write the graph in Bliss format, according to
+ *      http://www.tcs.hut.fi/Software/bliss/fileformat.shtml */
+{
+    unsigned long ne;
+    setword x,*pg;
+    int i,j;
+
+    ne = 0;
+    for (pg = g + m*(size_t)n; --pg >= g;)
+        if ((x = *pg) != 0) ne += POPCOUNT(x);
+    ne /= 2;
+
+    fprintf(f,"c Graph %lu\n",id);
+    fprintf(f,"p edge %d %lu\n",n,ne);
+
+    for (i = 0, pg = g; i < n; ++i, pg += m)
+        for (j = nextelement(pg,m,i); j >= 0; j = nextelement(pg,m,j))
+            fprintf(f,"e %d %d\n",i+1,j+1);
+}
+
+/**************************************************************************/
+
+static void
+putam(FILE *f, graph *g, int linelength, boolean space,
+    boolean triang, int m, int n)
+/* write adjacency matrix */
+{
+    set *gi;
+    int i,j;
+    boolean first;
+
+    for (i = 0, gi = (set*)g; i < n - (triang!=0); ++i, gi += m)
+    {
+        first = TRUE;
+        for (j = triang ? i+1 : 0; j < n; ++j)
+        {
+            if (!first && space) putc(' ',f);
+            else                 first = FALSE;
+            if (ISELEMENT(gi,j)) putc('1',f);
+            else                 putc('0',f);
+        }
+        putc('\n',f);
+    }
+}
+
+/**************************************************************************/
+
+static void
+putMagma(FILE *outfile, graph *g, int linelength, boolean digraph,
+         int m, int n, long index)
+{
+    int i,j,j0;
+    set *gi;
+    boolean first;
+
+    fprintf(outfile,"g%ld := %s<%d|[\n",
+                 index,(digraph?"Digraph":"Graph"),n);
+
+    for (i = 0, gi = (set*)g; i < n; ++i, gi += m)
+    {
+        fprintf(outfile,"{");
+        first = TRUE;
+        j0 = digraph ? -1 : i;
+        for (j = j0; (j = nextelement(gi,m,j)) >= 0; )
+        {
+            if (!first) fprintf(outfile,",");
+            first = FALSE;
+            fprintf(outfile,"%d",j+1);
+        }
+        fprintf(outfile,"}");
+        if (i != n-1) fprintf(outfile,",\n");
+    }
+    fprintf(outfile,"]>;\n");
+}
+
+/**************************************************************************/
+
+static void
+putMaple(FILE *outfile, graph *g, int linelength, int m, int n, long index)
+{
+    int i,j;
+    set *gi;
+    boolean first;
+
+#if MAPLE_MATRIX
+    fprintf(outfile,"f%ld := Matrix(%d,%d,[\n",index,n,n);
+#else
+    fprintf(outfile,"f%ld := array(1..%d,1..%d,[\n",index,n,n);
+#endif
+
+    for (i = 0, gi = (set*)g; i < n; ++i, gi += m)
+    {
+        fprintf(outfile,"[");
+        first = TRUE;
+        for (j = 0; j < n; ++j)
+        {
+            if (!first) fprintf(outfile,",");
+            first = FALSE;
+            fprintf(outfile,"%d",(ISELEMENT(gi,j)?1:0));
+        }
+        fprintf(outfile,"]");
+        if (i != n-1) fprintf(outfile,",\n");
+    }
+    fprintf(outfile,"]);\n");
+}
+
+/**************************************************************************/
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    graph *g,*gprev;
+    int m,n,codetype;
+    int argnum,j,nprev,mprev;
+    char *arg,sw;
+    boolean badargs,first,digraph;
+    unsigned long maxin;
+    long pval1,pval2;
+    boolean fswitch,pswitch,cswitch,dswitch;
+    boolean aswitch,lswitch,oswitch,Fswitch;
+    boolean Aswitch,eswitch,tswitch,qswitch;
+    boolean sswitch,Mswitch,Wswitch,Eswitch;
+    boolean bswitch,Gswitch,yswitch,Yswitch,Hswitch;
+    int linelength;
+    char *infilename,*outfilename,*yarg;
+
+    HELP; PUTVERSION;
+
+    fswitch = pswitch = cswitch = dswitch = FALSE;
+    aswitch = lswitch = oswitch = Fswitch = FALSE;
+    Aswitch = eswitch = tswitch = qswitch = FALSE;
+    sswitch = Mswitch = Wswitch = Eswitch = FALSE;
+    bswitch = Gswitch = yswitch = Yswitch = Hswitch = FALSE;
+    infilename = outfilename = NULL;
+    linelength = LINELEN;
+    labelorg = 0;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('a',aswitch)
+                else SWBOOLEAN('A',Aswitch)
+                else SWBOOLEAN('c',cswitch)
+                else SWBOOLEAN('d',dswitch)
+                else SWBOOLEAN('e',eswitch)
+                else SWBOOLEAN('H',Hswitch)
+                else SWBOOLEAN('E',Eswitch)
+                else SWBOOLEAN('f',fswitch)
+                else SWBOOLEAN('F',Fswitch)
+                else SWBOOLEAN('t',tswitch)
+                else SWBOOLEAN('b',bswitch)
+                else SWBOOLEAN('G',Gswitch)
+                else SWBOOLEAN('q',qswitch)
+                else SWBOOLEAN('M',Mswitch)
+                else SWBOOLEAN('W',Wswitch)
+                else SWBOOLEAN('s',sswitch)
+                else SWBOOLEAN('y',yswitch)
+                else SWRANGE('p',":-",pswitch,pval1,pval2,"listg -p")
+                else SWINT('l',lswitch,linelength,"listg -l")
+                else SWINT('o',oswitch,labelorg,"listg -o")
+		else if (sw == 'Y')
+		{
+		    Yswitch = TRUE;
+		    yarg = arg;
+		    break;
+		}
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if (Yswitch) yswitch = TRUE;
+
+    if (labelorg < 0) gt_abort(">E listg: negative origin forbidden.\n");
+
+    if ((aswitch!=0) + (Aswitch!=0) + (eswitch!=0) + (Mswitch!=0) +
+        (Wswitch!=0) + (sswitch!=0) + (dswitch!=0) + (cswitch!=0) +
+        (Eswitch!=0) + (bswitch!=0) + (Gswitch!=0) + (yswitch!=0) +
+        (Hswitch!=0) > 1)
+        gt_abort(">E listg: -aAbMWeEHcdsGy are incompatible\n");
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        fprintf(stderr,"  Try listg -help for more detailed help.\n");
+        exit(1);
+    }
+
+    if (!pswitch || pval1 < 1) pval1 = 1;
+
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,fswitch,
+                           pswitch ? pval1 : 1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    if (!outfilename || outfilename[0] == '-')
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename,"w")) == NULL)
+    {
+        fprintf(stderr,"Can't open output file %s\n",outfilename);
+        gt_abort(NULL);
+    }
+
+    nin = 0;
+    if (!pswitch || pval2 == NOLIMIT)
+        maxin = NOLIMIT;
+    else if (pval1 < 1) maxin = pval2;
+    else                maxin = pval2 - pval1 + 1;
+    first = TRUE;
+    gprev = NULL;
+    nprev = mprev = 1;
+
+    while (nin < maxin || maxin == NOLIMIT)
+    {
+        if ((g = readgg_inc(infile,NULL,0,&m,&n,
+		  gprev,mprev,nprev,&digraph)) == NULL) break;
+        ++nin;
+
+        if (Gswitch)
+        {
+            if (first) fprintf(outfile,"graphs := [\n");
+            else       fprintf(outfile,",\n");
+        }
+
+        first = FALSE;
+
+        if (Fswitch && nin > 1) fprintf(outfile,"\f");
+
+        if (cswitch)
+            putcgraph(outfile,g,linelength,digraph,m,n);
+        else if (dswitch)
+        {
+            if (qswitch)
+                fprintf(outfile,"%d\n",n);
+            else
+            {
+                fprintf(outfile,"\n!Graph %lu.\n",pval1+nin-1);
+                fprintf(outfile,"n=%d $=%d %sg\n",
+                                n,labelorg,(digraph?"d":""));
+            }
+            putgraphx(outfile,g,linelength,tswitch,m,n);
+            if (!qswitch) fprintf(outfile,"$$\n");
+        }
+        else if (Mswitch)
+            putMagma(outfile,g,linelength,digraph,m,n,pval1+nin-1);
+        else if (Wswitch)
+            putMaple(outfile,g,linelength,m,n,pval1+nin-1);
+        else if (sswitch)
+            putve(outfile,pval1+nin-1,g,digraph,m,n);
+        else if (bswitch)
+            putbliss(outfile,pval1+nin-1,g,m,n);
+        else if (Gswitch)
+            putGRAPE(outfile,g,m,n);
+        else if (yswitch)
+            putdotty(outfile,g,pval1+nin-1,(Yswitch?yarg:NULL),m,n);
+	else if (Hswitch)
+	    putHCP(outfile,g,m,n);
+        else
+        {
+            if (qswitch)
+            {
+                if (!eswitch && !Eswitch) fprintf(outfile,"%d\n",n);
+            }
+            else fprintf(outfile,"\nGraph %lu, order %d.\n",
+                                 pval1+nin-1,n);
+            if (aswitch|Aswitch)
+                putam(outfile,g,linelength,Aswitch,tswitch,m,n);
+            else if (eswitch || Eswitch)
+                putedges(outfile,g,Eswitch,linelength,digraph,m,n);
+            else
+                putgraphx(outfile,g,linelength,tswitch,m,n);
+        }
+        if (gprev) FREES(gprev);
+        gprev = g;
+        nprev = n;
+        mprev = m;
+
+        if (ferror(outfile)) gt_abort(">E listg output error\n");
+    }
+
+    if (Gswitch && !first) fprintf(outfile,"\n];\n");
+
+    exit(0);
+}
diff --git a/lib/nauty/makefile b/lib/nauty/makefile
new file mode 100644
index 0000000..77b148d
--- /dev/null
+++ b/lib/nauty/makefile
@@ -0,0 +1,540 @@
+# makefile for nauty 2.6
+# makefile.  Generated from makefile.in by configure.
+
+SHELL=/bin/sh
+CC=gcc
+CFLAGS= -O 
+SAFECFLAGS= -O
+LDFLAGS= 
+THREADLIB=
+LOK=1         # 0 if no 64-bit integers
+TESTPROGS=dreadtest dreadtestS dreadtestS1 dreadtest4K dreadtest1 dreadtestW dreadtestW1 dreadtestL1 dreadtestL
+EXEEXT=
+
+SMALL=-DMAXN=WORDSIZE
+S1=-DMAXN=WORDSIZE -DWORDSIZE=16
+W1=-DMAXN=WORDSIZE -DWORDSIZE=32
+L1=-DMAXN=WORDSIZE -DWORDSIZE=64
+S=-DWORDSIZE=16
+W=-DWORDSIZE=32
+L=-DWORDSIZE=64
+
+CCOBJ=${CC} -c ${CFLAGS} -o $@
+GTOOLSH=gtools.h nauty.h naututil.h nausparse.h naurng.h
+
+# ++++++ This file is automatically generated, don't edit it by hand! ++++++
+
+all : nauty gtools ;
+
+nauty : dreadnaut nauty.a nauty1.a nautyW.a nautyW1.a nautyL.a nautyL1.a;
+
+gtools : copyg listg labelg dretog amtog geng complg showg NRswitchg \
+  biplabg addedgeg deledgeg countg pickg genrang newedgeg catg genbg \
+  directg gentreeg genquarticg \
+  ranlabg multig planarg gentourng linegraphg watercluster2 dretodot \
+  subdivideg vcolg delptg cubhamg twohamg hamheuristic converseg \
+  genspecialg genbgL shortg ;
+
+NAUTYO=nauty.o nautil.o nausparse.o naugraph.o schreier.o naurng.o
+NAUTY1O=nauty1.o nautil1.o nausparse.o naugraph1.o schreier.o naurng.o
+NAUTYSO=nautyS.o nautilS.o nausparseS.o naugraphS.o schreierS.o naurng.o
+NAUTYS1O=nautyS1.o nautilS1.o nausparseS.o naugraphS1.o schreierS.o naurng.o
+NAUTYWO=nautyW.o nautilW.o nausparseW.o naugraphW.o schreierW.o naurng.o
+NAUTYW1O=nautyW1.o nautilW1.o nausparseW.o naugraphW1.o schreierW.o naurng.o
+NAUTYLO=nautyL.o nautilL.o nausparseL.o naugraphL.o schreierL.o naurng.o
+NAUTYL1O=nautyL1.o nautilL1.o nausparseL.o naugraphL1.o schreierL.o naurng.o
+
+nauty.o: nauty.h schreier.h nauty.c
+	${CCOBJ} nauty.c
+nauty1.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${SMALL} nauty.c
+nautyS.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${S} nauty.c
+nautyS1.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${S1} nauty.c
+nautyW.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${W} nauty.c
+nautyW1.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${W1} nauty.c
+nautyL.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${L} nauty.c
+nautyL1.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${L1} nauty.c
+
+nautil.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} nautil.c
+nautil1.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${SMALL} nautil.c
+nautilS.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${S} nautil.c
+nautilS1.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${S1} nautil.c
+nautilW.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${W} nautil.c
+nautilW1.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${W1} nautil.c
+nautilL.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${L} nautil.c
+nautilL1.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${L1} nautil.c
+
+naugraph.o: nauty.h naugraph.c
+	${CCOBJ} naugraph.c
+naugraph1.o: nauty.h naugraph.c
+	${CCOBJ} ${SMALL} naugraph.c
+naugraphS.o: nauty.h naugraph.c
+	${CCOBJ} ${S} naugraph.c
+naugraphS1.o: nauty.h naugraph.c
+	${CCOBJ} ${S1} naugraph.c
+naugraphW.o: nauty.h naugraph.c
+	${CCOBJ} ${W} naugraph.c
+naugraphW1.o: nauty.h naugraph.c
+	${CCOBJ} ${W1} naugraph.c
+naugraphL.o: nauty.h naugraph.c
+	${CCOBJ} ${L} naugraph.c
+naugraphL1.o: nauty.h naugraph.c
+	${CCOBJ} ${L1} naugraph.c
+
+naututil.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} naututil.c
+naututil1.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${SMALL} naututil.c
+naututilS.o: nauty.h naututil.h nausparse.h naututil.c 
+	${CCOBJ} ${S} naututil.c
+naututilS1.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${S1} naututil.c
+naututilW.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${W} naututil.c
+naututilW1.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${W1} naututil.c
+naututilL.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${L} naututil.c
+naututilL1.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${L1} naututil.c
+
+nautinv.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} nautinv.c
+nautinv1.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${SMALL} nautinv.c
+nautinvS.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${S} nautinv.c
+nautinvS1.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${S1} nautinv.c
+nautinvW.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${W} nautinv.c 
+nautinvW1.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${W1} nautinv.c
+nautinvL.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${L} nautinv.c
+nautinvL1.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${L1} nautinv.c
+
+schreier.o : nauty.h naurng.h schreier.h schreier.c
+	${CCOBJ} schreier.c
+schreierS.o : nauty.h naurng.h schreier.h schreier.c
+	${CCOBJ} ${S} schreier.c
+schreierW.o : nauty.h naurng.h schreier.h schreier.c
+	${CCOBJ} ${W} schreier.c
+schreierL.o : nauty.h naurng.h schreier.h schreier.c
+	${CCOBJ} ${L} schreier.c
+
+nausparse.o : nauty.h nausparse.h nausparse.c sorttemplates.c
+	${CCOBJ} nausparse.c
+nausparseS.o: nauty.h nausparse.h nausparse.c sorttemplates.c
+	${CCOBJ} ${S} nausparse.c
+nausparseW.o: nauty.h nausparse.h nausparse.c sorttemplates.c
+	${CCOBJ} ${W} nausparse.c
+nausparseL.o: nauty.h nausparse.h nausparse.c sorttemplates.c
+	${CCOBJ} ${L} nausparse.c
+
+traces.o : nauty.h naurng.h schreier.h traces.h nausparse.h traces.c
+	${CCOBJ} traces.c
+tracesS.o : nauty.h naurng.h schreier.h traces.h nausparse.h traces.c
+	${CCOBJ} ${S} traces.c
+tracesW.o : nauty.h naurng.h schreier.h traces.h nausparse.h traces.c
+	${CCOBJ} ${W} traces.c
+tracesL.o : nauty.h naurng.h schreier.h traces.h nausparse.h traces.c
+	${CCOBJ} ${L} traces.c
+
+gtools.o : ${GTOOLSH} gtools.c
+	${CCOBJ} gtools.c
+gtoolsS.o : ${GTOOLSH} gtools.c
+	${CCOBJ} ${S} gtools.c
+gtoolsW.o : ${GTOOLSH} gtools.c
+	${CCOBJ} ${W} gtools.c
+gtoolsL.o : ${GTOOLSH} gtools.c
+	${CCOBJ} ${L} gtools.c
+
+nautaux.o: nautaux.h nauty.h naututil.h nautaux.c
+	${CCOBJ} nautaux.c
+nautauxS.o: nautaux.h nauty.h naututil.h nautaux.c
+	${CCOBJ} ${S} nautaux.c
+nautauxW.o: nautaux.h nauty.h naututil.h nautaux.c
+	${CCOBJ} ${W} nautaux.c
+nautauxL.o: nautaux.h nauty.h naututil.h nautaux.c
+	${CCOBJ} ${L} nautaux.c
+
+gtnauty.o : ${GTOOLSH} gtnauty.c sorttemplates.c
+	${CCOBJ} gtnauty.c
+gtnautyL1.o : ${GTOOLSH} gtnauty.c sorttemplates.c
+	${CCOBJ} ${L1} gtnauty.c
+gtnautyW1.o : ${GTOOLSH} gtnauty.c sorttemplates.c
+	${CCOBJ} ${W1} gtnauty.c
+gtnautyL.o : ${GTOOLSH} gtnauty.c sorttemplates.c
+	${CCOBJ} ${L} gtnauty.c
+gtnautyW.o : ${GTOOLSH} gtnauty.c sorttemplates.c
+	${CCOBJ} ${W} gtnauty.c
+
+naurng.o: naurng.c nauty.h
+	${CCOBJ} naurng.c
+rng.o: rng.c nauty.h
+	${CCOBJ} rng.c
+
+dreadnaut: dreadnaut.c naututil.o nautinv.o traces.o gtools.o ${NAUTYO}
+	${CC} -o dreadnaut ${SAFECFLAGS} dreadnaut.c naututil.o \
+		nautinv.o gtools.o traces.o ${NAUTYO} ${LDFLAGS} ${THREADLIB}
+dreadnautL: dreadnaut.c naututilL.o nautyL.o nautilL.o nautinvL.o \
+	     nausparseL.o naugraphL.o naurng.o schreierL.o tracesL.o gtoolsL.o
+	${CC} -o dreadnautL ${SAFECFLAGS} ${L} dreadnaut.c naututilL.o \
+	     nautyL.o nautilL.o nautinvL.o naugraphL.o naurng.o gtoolsL.o \
+	     nausparseL.o schreierL.o tracesL.o ${LDFLAGS}
+dreadnaut1: dreadnaut.c naututil1.o nauty1.o nautil1.o nautinv1.o \
+	     nausparse.o naugraph1.o naurng.o schreier.o traces.o gtools.o
+	${CC} -o dreadnaut1 ${SAFECFLAGS} ${SMALL} dreadnaut.c naututil1.o \
+	     nauty1.o nautil1.o nautinv1.o naugraph1.o naurng.o gtools.o \
+	     nausparse.o schreier.o traces.o ${LDFLAGS}
+
+nauty.a: ${NAUTYO} traces.o gtools.o naututil.o nautinv.o \
+			gutil1.o gutil2.o gtnauty.o naugroup.o
+	rm -f nauty.a
+	ar crs nauty.a ${NAUTYO} traces.o gtools.o naututil.o \
+		 nautinv.o gutil1.o gutil2.o gtnauty.o naugroup.o \
+		 naurng.o schreier.o
+
+nauty1.a: ${NAUTY1O} traces.o gtools.o naututil1.o nautinv1.o \
+	   gutil1.o gutil2.o gtnauty.o naugroup.o
+	rm -f nauty1.a
+	ar crs nauty1.a ${NAUTY1O} traces.o gtools.o naututil1.o \
+	   nautinv1.o gutil1.o gutil2.o gtnauty.o naugroup.o 
+
+nautyW.a: ${NAUTYWO} traces.o gtoolsW.o naututilW.o nautinvW.o \
+	   gutil1W.o gutil2W.o gtnautyW.o naugroupW.o 
+	rm -f nautyW.a
+	ar crs nautyW.a ${NAUTYWO} traces.o gtoolsW.o naututilW.o \
+	   nautinvW.o gutil1W.o gutil2W.o gtnautyW.o naugroupW.o
+
+nautyW1.a: ${NAUTYW1O} traces.o gtoolsW.o naututilW1.o nautinvW1.o \
+	   gutil1W1.o gutil2W1.o gtnautyW1.o naugroupW.o 
+	rm -f nautyW1.a
+	ar crs nautyW1.a ${NAUTYW1O} traces.o gtoolsW.o naututilW1.o \
+	   nautinvW1.o gutil1W1.o gutil2W1.o gtnautyW1.o naugroupW.o
+
+nautyL.a: ${NAUTYLO} traces.o gtoolsL.o naututilL.o nautinvL.o \
+	   gutil1L.o gutil2L.o gtnautyL.o naugroupL.o 
+	rm -f nautyL.a
+	ar crs nautyL.a ${NAUTYLO} traces.o gtoolsL.o naututilL.o \
+	   nautinvL.o gutil1L.o gutil2L.o gtnautyL.o naugroupL.o
+
+nautyL1.a: ${NAUTYL1O} traces.o gtoolsL.o naututilL1.o nautinvL1.o \
+	   gutil1L1.o gutil2L1.o gtnautyL1.o naugroupL.o 
+	rm -f nautyL1.a
+	ar crs nautyL1.a ${NAUTYL1O} traces.o gtoolsL.o naututilL1.o \
+	   nautinvL1.o gutil1L1.o gutil2L1.o gtnautyL1.o naugroupL.o
+
+clean:
+	rm -f *.o config.log config.cache config.status nauty*.a
+	rm -f dreadtest${EXEEXT} dreadtestL${EXEEXT} \
+		dreadtestW${EXEEXT} \
+		dreadtestS${EXEEXT} dreadtestS1${EXEEXT} \
+	        dreadtest4K${EXEEXT} dreadtest1${EXEEXT} \
+		dreadtestL1${EXEEXT} dreadtestW1${EXEEXT}
+
+gutil1.o : ${GTOOLSH} gutils.h gutil1.c
+	${CCOBJ} gutil1.c
+gutil2.o : ${GTOOLSH} gutils.h gutil2.c
+	${CCOBJ} gutil2.c
+gutil1W1.o : ${GTOOLSH} gutils.h gutil1.c
+	${CCOBJ} ${W1} gutil1.c
+gutil2W1.o : ${GTOOLSH} gutils.h gutil2.c
+	${CCOBJ} ${W1} gutil2.c
+gutil1L1.o : ${GTOOLSH} gutils.h gutil1.c
+	${CCOBJ} ${L1} gutil1.c
+gutil2L1.o : ${GTOOLSH} gutils.h gutil2.c
+	${CCOBJ} ${L1} gutil2.c
+gutil1W.o : ${GTOOLSH} gutils.h gutil1.c
+	${CCOBJ} ${W} gutil1.c
+gutil2W.o : ${GTOOLSH} gutils.h gutil2.c
+	${CCOBJ} ${W} gutil2.c
+gutil1L.o : ${GTOOLSH} gutils.h gutil1.c
+	${CCOBJ} ${L} gutil1.c
+gutil2L.o : ${GTOOLSH} gutils.h gutil2.c
+	${CCOBJ} ${L} gutil2.c
+
+catg : ${GTOOLSH} catg.c gtools.o
+	${CC} -o catg ${CFLAGS} catg.c gtools.o ${LDFLAGS}
+
+copyg : ${GTOOLSH} copyg.c gtools.o
+	${CC} -o copyg ${CFLAGS} copyg.c gtools.o ${LDFLAGS}
+
+genspecialg : ${GTOOLSH} genspecialg.c ${NAUTYO} gtools.o
+	${CC} -o genspecialg ${CFLAGS} genspecialg.c ${NAUTYO} gtools.o ${LDFLAGS}
+
+listg : ${GTOOLSH} listg.c gtools.o nautil.o
+	${CC} -o listg ${CFLAGS} listg.c gtools.o nautil.o ${LDFLAGS}
+
+labelg : ${GTOOLSH} naututil.h labelg.c gtools.o gtnauty.o ${NAUTYO} \
+            nautinv.o nausparse.h gutils.h gutil2.o traces.h traces.o naututil.o
+	${CC} -o labelg ${SAFECFLAGS} labelg.c gtools.o gtnauty.o naututil.o \
+	    nautinv.o gutil2.o traces.o ${NAUTYO} ${LDFLAGS} ${THREADLIB}
+
+shortg : ${GTOOLSH} shortg.c gtools.o gtnauty.o ${NAUTYO} \
+            nausparse.h gutils.h gutil2.o nautinv.h nautinv.o traces.o
+	${CC} -o shortg ${CFLAGS} shortg.c gtools.o gtnauty.o nautinv.o \
+            ${NAUTYO} gutil2.o traces.o ${LDFLAGS} ${THREADLIB}
+
+dretog : ${GTOOLSH} dretog.c naututil.o gtools.o ${NAUTYO} 
+	${CC} -o dretog ${CFLAGS} dretog.c naututil.o gtools.o \
+	    ${NAUTYO} ${LDFLAGS}
+
+dretodot : ${GTOOLSH} dretodot.c naututil.o gtools.o \
+		traces.o traces.h ${NAUTYO} 
+	${CC} -o dretodot ${CFLAGS} dretodot.c naututil.o gtools.o \
+	    traces.o ${NAUTYO} ${LDFLAGS} -lm
+
+amtog : ${GTOOLSH} amtog.c gtools.o ${NAUTYO}
+	${CC} -o amtog ${CFLAGS} amtog.c gtools.o ${NAUTYO} ${LDFLAGS}
+
+genbg : ${GTOOLSH} genbg.c gtoolsW.o nautyW1.o nautilW1.o naugraphW1.o \
+	    schreierW.o naurng.o
+	${CC} -o genbg ${CFLAGS} ${W1} genbg.c gtoolsW.o schreierW.o \
+		nautyW1.o nautilW1.o naugraphW1.o naurng.o ${LDFLAGS}
+
+genbgL : ${GTOOLSH} genbg.c gtoolsL.o nautyL1.o nautilL1.o naugraphL1.o \
+	    schreierL.o naurng.o
+	${CC} -o genbgL ${CFLAGS} ${L1} -DMAXN1=30 genbg.c gtoolsL.o \
+	    schreierL.o naurng.o nautyL1.o nautilL1.o naugraphL1.o ${LDFLAGS}
+
+geng : ${GTOOLSH} geng.c gtoolsW.o nautyW1.o nautilW1.o naugraphW1.o schreier.o naurng.o
+	${CC} -o geng ${CFLAGS} ${W1} geng.c gtoolsW.o nautyW1.o \
+		nautilW1.o naugraphW1.o schreier.o naurng.o ${LDFLAGS}
+
+geng16 : ${GTOOLSH} geng.c gtoolsW.o nautyW1.o nautilW1.o naugraphW1.o schreier.o naurng.o
+	${CC} -o geng16 ${CFLAGS} -DMAXN=16 $W geng.c gtoolsW.o nautyW1.o \
+		nautilW1.o naugraphW1.o schreier.o naurng.o ${LDFLAGS}
+
+geng24 : ${GTOOLSH} geng.c gtoolsW.o nautyW1.o nautilW1.o naugraphW1.o schreier.o naurng.o
+	${CC} -o geng24 ${CFLAGS} -DMAXN=24 $W geng.c gtoolsW.o nautyW1.o \
+		nautilW1.o naugraphW1.o schreier.o naurng.o ${LDFLAGS}
+
+gentourng : ${GTOOLSH} gentourng.c gtoolsW.o nautyW1.o nautilW1.o \
+	    naugraphW1.o schreier.o naurng.o
+	${CC} -o gentourng ${CFLAGS} -DMAXN=24 $W gentourng.c gtoolsW.o nautyW1.o \
+		nautilW1.o naugraphW1.o schreier.o naurng.o ${LDFLAGS}
+
+genquarticg : ${GTOOLSH} genquarticg.c gtoolsL.o nautyL1.o nautilL1.o \
+	    naugraphL1.o schreierL.o naurng.o quarticirred28.h
+	${CC} -o genquarticg ${CFLAGS} genquarticg.c gtoolsL.o nautyL1.o \
+		nautilL1.o naugraphL1.o schreierL.o naurng.o ${LDFLAGS}
+
+gentreeg : gentreeg.c gtools.o nauty.h gtools.h
+	${CC} -o gentreeg ${CFLAGS} gentreeg.c gtools.o
+
+genrang : ${GTOOLSH} genrang.c gtools.o naututil.o ${NAUTYO}
+	${CC} -o genrang ${CFLAGS} genrang.c \
+		gtools.o naututil.o ${NAUTYO} ${LDFLAGS}
+
+complg : ${GTOOLSH} complg.c gtools.o gtnauty.o ${NAUTYO}
+	${CC} -o complg ${CFLAGS} complg.c gtools.o gtnauty.o \
+		${NAUTYO} ${LDFLAGS}
+
+cubhamg : ${GTOOLSH} cubhamg.c gtools.o ${NAUTYO}
+	${CC} -o cubhamg ${CFLAGS} cubhamg.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+twohamg : ${GTOOLSH} twohamg.c gtools.o ${NAUTYO}
+	${CC} -o twohamg ${CFLAGS} twohamg.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+hamheuristic : ${GTOOLSH} hamheuristic.c gtools.o ${NAUTYO}
+	${CC} -o hamheuristic ${CFLAGS} hamheuristic.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+converseg : ${GTOOLSH} converseg.c gtools.o ${NAUTYO}
+	${CC} -o converseg ${CFLAGS} converseg.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+linegraphg : ${GTOOLSH} linegraphg.c gtools.o ${NAUTYO}
+	${CC} -o linegraphg ${CFLAGS} linegraphg.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+subdivideg : ${GTOOLSH} subdivideg.c gtools.o ${NAUTYO}
+	${CC} -o subdivideg ${CFLAGS} subdivideg.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+vcolg : ${GTOOLSH} vcolg.c gtools.o ${NAUTYO} naugroup.o naugroup.h
+	${CC} -o vcolg ${CFLAGS} vcolg.c gtools.o naugroup.o \
+		${NAUTYO} ${LDFLAGS}
+
+biplabg : ${GTOOLSH} gutils.h biplabg.c gtools.o gutil1.o ${NAUTYO}
+	${CC} -o biplabg ${CFLAGS} biplabg.c \
+		gtools.o gutil1.o ${NAUTYO} ${LDFLAGS}
+
+ranlabg : ${GTOOLSH} ranlabg.c gtools.o ${NAUTYO}
+	${CC} -o ranlabg ${CFLAGS} ranlabg.c gtools.o ${NAUTYO} ${LDFLAGS}
+
+NRswitchg : ${GTOOLSH} NRswitchg.c gtools.o gtnauty.o ${NAUTYO}
+	${CC} -o NRswitchg ${CFLAGS} NRswitchg.c gtools.o gtnauty.o \
+		 ${NAUTYO} ${LDFLAGS}
+
+deledgeg : ${GTOOLSH} deledgeg.c gtools.o gtnauty.o ${NAUTYO}
+	${CC} -o deledgeg ${CFLAGS} deledgeg.c gtools.o gtnauty.o \
+		 ${NAUTYO} ${LDFLAGS}
+
+delptg : ${GTOOLSH} delptg.c gtools.o gtnauty.o ${NAUTYO}
+	${CC} -o delptg ${CFLAGS} delptg.c gtools.o gtnauty.o \
+		 ${NAUTYO} ${LDFLAGS}
+
+addedgeg : ${GTOOLSH} gutils.h addedgeg.c gtools.o gtnauty.o gutil1.o ${NAUTYO}
+	${CC} -o addedgeg ${CFLAGS} addedgeg.c gtools.o gtnauty.o \
+	        gutil1.o ${NAUTYO} ${LDFLAGS}
+
+newedgeg : ${GTOOLSH} gutils.h newedgeg.c gtools.o gtnauty.o ${NAUTYO}
+	${CC} -o newedgeg ${CFLAGS} newedgeg.c gtools.o gtnauty.o \
+		 ${NAUTYO} ${LDFLAGS}
+
+pickg : ${GTOOLSH} gutils.h testg.c splay.c ${NAUTYO} \
+	     gtools.o gtnauty.o gutil1.o gutil2.o nautinv.o 
+	${CC} -o pickg ${SAFECFLAGS} testg.c gtools.o gtnauty.o gutil1.o \
+	        gutil2.o nautinv.o ${NAUTYO} ${LDFLAGS}
+
+countg : ${GTOOLSH} gutils.h testg.c splay.c ${NAUTYO} \
+	     gtools.o gtnauty.o gutil1.o gutil2.o nautinv.o
+	${CC} -o countg ${SAFECFLAGS} testg.c gtools.o gtnauty.o gutil1.o \
+	         gutil2.o nautinv.o ${NAUTYO} ${LDFLAGS} 
+
+directg : ${GTOOLSH} naugroup.h directg.c  gtools.o naugroup.o ${NAUTYO}
+	${CC} -o directg ${CFLAGS} directg.c gtools.o \
+                ${NAUTYO} naugroup.o ${LDFLAGS}
+
+multig : ${GTOOLSH} naugroup.h multig.c gtools.o naugroup.o ${NAUTYO}
+	${CC} -o multig ${CFLAGS} multig.c gtools.o \
+                ${NAUTYO} naugroup.o ${LDFLAGS}
+
+planarg : ${GTOOLSH} planarg.c gtools.o planarity.c
+	${CC} -o planarg ${CFLAGS} \
+		planarg.c planarity.c gtools.o ${LDFLAGS}
+
+watercluster2 : ${GTOOLSH} nauty.h watercluster2.c gtools.o ${NAUTYO}
+	${CC} -o watercluster2 ${CFLAGS} -DMAXN=32 watercluster2.c \
+                 gtools.o ${NAUTYO} ${LDFLAGS}
+
+showg : showg.c
+	${CC} -o showg ${CFLAGS} showg.c ${LDFLAGS}
+
+readg : showg
+	echo "*** readg is now called showg ***"
+
+sumlines : sumlines.c
+	${CC} -o sumlines ${CFLAGS} sumlines.c ${LDFLAGS} -lgmp
+
+blisstog : ${GTOOLSH} blisstog.c gtools.o ${NAUTYO}
+	${CC} -o blisstog ${CFLAGS} blisstog.c gtools.o \
+                ${NAUTYO} ${LDFLAGS}
+
+bliss2dre : ${GTOOLSH} bliss2dre.c gtools.o ${NAUTYO}
+	${CC} -o bliss2dre ${CFLAGS} bliss2dre.c gtools.o \
+                ${NAUTYO} ${LDFLAGS}
+
+testlabelling : testlabelling.c nauty.h nauty.a
+	${CC} -o testlabelling -g testlabelling.c traces.c nauty.a ${LDFLAGS}
+
+naugroup.o : nauty.h naugroup.h naugroup.c
+	${CCOBJ} naugroup.c
+naugroupW.o : nauty.h naugroup.h naugroup.c
+	${CCOBJ} ${W} naugroup.c
+naugroupL.o : nauty.h naugroup.h naugroup.c
+	${CCOBJ} ${L} naugroup.c
+
+nautyex1 : nauty.h nautyex1.c nauty.a
+	${CC} -o nautyex1 ${CFLAGS} nautyex1.c nauty.a ${LDFLAGS}
+nautyex2 : nauty.h nautyex2.c ${NAUTYO}
+	${CC} -o nautyex2 ${CFLAGS} nautyex2.c nauty.a ${LDFLAGS}
+nautyex3 : nauty.h nautyex3.c nauty.a
+	${CC} -o nautyex3 ${CFLAGS} nautyex3.c nauty.a ${LDFLAGS}
+nautyex4 : nauty.h nausparse.h nautyex4.c nauty.a
+	${CC} -o nautyex4 ${CFLAGS} nautyex4.c nauty.a ${LDFLAGS}
+nautyex5 : nauty.h nausparse.h nautyex5.c nauty.a
+	${CC} -o nautyex5 ${CFLAGS} nautyex5.c nauty.a ${LDFLAGS}
+nautyex6 : nauty.h nautyex6.c nauty.a
+	${CC} -o nautyex6 ${CFLAGS} nautyex6.c nauty.a ${LDFLAGS}
+nautyex7 : nauty.h nautyex7.c traces.h nauty.a
+	${CC} -o nautyex7 ${CFLAGS} nautyex7.c nauty.a ${LDFLAGS}
+nautyex8 : nauty.h nausparse.h nautyex8.c nauty.a
+	${CC} -o nautyex8 ${CFLAGS} nautyex8.c nauty.a ${LDFLAGS}
+nautyex9 : nauty.h nautyex9.c nauty.a
+	${CC} -o nautyex9 ${CFLAGS} nautyex9.c nauty.a ${LDFLAGS}
+nautyex10 : nauty.h nautyex10.c nauty.a
+	${CC} -o nautyex10 ${CFLAGS} nautyex10.c nauty.a ${LDFLAGS}
+
+testprogs: ${TESTPROGS} ;
+
+checks: nauty gtools naucompare ${TESTPROGS}
+	./runalltests
+
+naucompare : naucompare.c
+	${CC} -o naucompare ${CFLAGS} naucompare.c ${LDFLAGS}
+
+dreadtest: dreadnaut.c nautinv.o ${NAUTYO} naututil.o traces.o gtools.o 
+	${CC} -o dreadtest ${SAFECFLAGS} -DDREADTEST dreadnaut.c \
+	    nautinv.o naututil.o traces.o gtools.o ${NAUTYO} ${LDFLAGS}
+dreadtest1: dreadnaut.c nautinv1.o ${NAUTY1O} naututil1.o traces.o gtools.o 
+	${CC} -o dreadtest1 ${SAFECFLAGS} ${SMALL} -DDREADTEST dreadnaut.c \
+	    nautinv1.o naututil1.o traces.o gtools.o ${NAUTY1O} ${LDFLAGS}
+dreadtestS: dreadnaut.c nautinvS.o ${NAUTYSO} naututilS.o tracesS.o gtoolsS.o 
+	${CC} -o dreadtestS ${SAFECFLAGS} ${S} -DDREADTEST dreadnaut.c \
+	    nautinvS.o naututilS.o tracesS.o gtoolsS.o ${NAUTYSO} ${LDFLAGS}
+dreadtestS1: dreadnaut.c nautinvS1.o ${NAUTYS1O} naututilS1.o \
+		tracesS.o gtoolsS.o 
+	${CC} -o dreadtestS1 ${SAFECFLAGS} ${S1} -DDREADTEST dreadnaut.c \
+	    nautinvS1.o naututilS1.o tracesS.o gtoolsS.o ${NAUTYS1O} ${LDFLAGS}
+dreadtestW: dreadnaut.c nautinvW.o ${NAUTYWO} naututilW.o tracesW.o gtoolsW.o 
+	${CC} -o dreadtestW ${SAFECFLAGS} ${W} -DDREADTEST dreadnaut.c \
+	    nautinvW.o naututilW.o tracesW.o gtoolsW.o ${NAUTYWO} ${LDFLAGS}
+dreadtestW1: dreadnaut.c nautinvW1.o ${NAUTYW1O} naututilW1.o \
+		tracesW.o gtoolsW.o 
+	${CC} -o dreadtestW1 ${SAFECFLAGS} ${W1} -DDREADTEST dreadnaut.c \
+	    nautinvW1.o naututilW1.o tracesW.o gtoolsW.o ${NAUTYW1O} ${LDFLAGS}
+dreadtestL: dreadnaut.c nautinvL.o ${NAUTYLO} naututilL.o tracesL.o gtoolsL.o 
+	${CC} -o dreadtestL ${SAFECFLAGS} ${L} -DDREADTEST dreadnaut.c \
+	    nautinvL.o naututilL.o tracesL.o gtoolsL.o ${NAUTYLO} ${LDFLAGS}
+dreadtestL1: dreadnaut.c nautinvL1.o ${NAUTYL1O} naututilL1.o \
+		tracesL.o gtoolsL.o 
+	${CC} -o dreadtestL1 ${SAFECFLAGS} ${L1} -DDREADTEST dreadnaut.c \
+	    nautinvL1.o naututilL1.o tracesL.o gtoolsL.o ${NAUTYL1O} ${LDFLAGS}
+dreadtest4K: dreadnaut.c nausparse.c schreier.c naututil.c nauty.c \
+	    nautil.c nautinv.c naugraph.c naurng.o gtools.c traces.c
+	${CC} -o dreadtest4K ${SAFECFLAGS} -DMAXN=4096 -DDREADTEST \
+	    dreadnaut.c naututil.c nauty.c nautil.c nautinv.c \
+	    naugraph.c nausparse.c naurng.o schreier.c gtools.c \
+	    traces.c ${LDFLAGS}
+
+checks6: checks6.c ${GTOOLSH} gtools.o
+	${CC} -o checks6 ${SAFECFLAGS} checks6.c gtools.o
+
+bigs: gtnauty.o gutil2.o nausparse.o nautil.o naututil.o gtools.o \
+	naugraph.o nautaux.o nautinv.o nauty.o schreier.o
+	rm -f gtnautyB.o gutil2B.o nausparseB.o nautilB.o naututilB.o \
+	  gtoolsB.o naugraphB.o nautauxB.o nautinvB.o nautyB.o
+	cp gtnauty.o gtnautyB.o
+	cp gutil2.o gutil2B.o
+	cp nausparse.o nausparseB.o
+	cp nautil.o nautilB.o
+	cp naututil.o naututilB.o
+	cp gtools.o gtoolsB.o
+	cp naugraph.o naugraphB.o
+	cp nautaux.o nautauxB.o
+	cp nautinv.o nautinvB.o
+	cp nauty.o nautyB.o
+	cp schreier.o schreierB.o
+
+# ++++++ This file is automatically generated, don't edit it by hand! ++++++
diff --git a/lib/nauty/makefile.basic b/lib/nauty/makefile.basic
new file mode 100644
index 0000000..613a43d
--- /dev/null
+++ b/lib/nauty/makefile.basic
@@ -0,0 +1,540 @@
+# makefile for nauty 2.6
+# makefile.  Generated from makefile.in by configure.
+
+SHELL=/bin/sh
+CC=gcc
+CFLAGS=-O2
+SAFECFLAGS= -O3
+LDFLAGS= 
+THREADLIB=-lpthread
+LOK=1         # 0 if no 64-bit integers
+TESTPROGS=dreadtest dreadtestS dreadtestS1 dreadtest4K dreadtest1 dreadtestW dreadtestW1 dreadtestL1 dreadtestL
+EXEEXT=
+
+SMALL=-DMAXN=WORDSIZE
+S1=-DMAXN=WORDSIZE -DWORDSIZE=16
+W1=-DMAXN=WORDSIZE -DWORDSIZE=32
+L1=-DMAXN=WORDSIZE -DWORDSIZE=64
+S=-DWORDSIZE=16
+W=-DWORDSIZE=32
+L=-DWORDSIZE=64
+
+CCOBJ=${CC} -c ${CFLAGS} -o $@
+GTOOLSH=gtools.h nauty.h naututil.h nausparse.h naurng.h
+
+# ++++++ This file is automatically generated, don't edit it by hand! ++++++
+
+all : nauty gtools ;
+
+nauty : dreadnaut nauty.a nauty1.a nautyW.a nautyW1.a nautyL.a nautyL1.a;
+
+gtools : copyg listg labelg dretog amtog geng complg showg NRswitchg \
+  biplabg addedgeg deledgeg countg pickg genrang newedgeg catg genbg \
+  directg gentreeg genquarticg \
+  ranlabg multig planarg gentourng linegraphg watercluster2 dretodot \
+  subdivideg vcolg delptg cubhamg twohamg hamheuristic converseg \
+  genspecialg genbgL shortg ;
+
+NAUTYO=nauty.o nautil.o nausparse.o naugraph.o schreier.o naurng.o
+NAUTY1O=nauty1.o nautil1.o nausparse.o naugraph1.o schreier.o naurng.o
+NAUTYSO=nautyS.o nautilS.o nausparseS.o naugraphS.o schreierS.o naurng.o
+NAUTYS1O=nautyS1.o nautilS1.o nausparseS.o naugraphS1.o schreierS.o naurng.o
+NAUTYWO=nautyW.o nautilW.o nausparseW.o naugraphW.o schreierW.o naurng.o
+NAUTYW1O=nautyW1.o nautilW1.o nausparseW.o naugraphW1.o schreierW.o naurng.o
+NAUTYLO=nautyL.o nautilL.o nausparseL.o naugraphL.o schreierL.o naurng.o
+NAUTYL1O=nautyL1.o nautilL1.o nausparseL.o naugraphL1.o schreierL.o naurng.o
+
+nauty.o: nauty.h schreier.h nauty.c
+	${CCOBJ} nauty.c
+nauty1.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${SMALL} nauty.c
+nautyS.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${S} nauty.c
+nautyS1.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${S1} nauty.c
+nautyW.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${W} nauty.c
+nautyW1.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${W1} nauty.c
+nautyL.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${L} nauty.c
+nautyL1.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${L1} nauty.c
+
+nautil.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} nautil.c
+nautil1.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${SMALL} nautil.c
+nautilS.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${S} nautil.c
+nautilS1.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${S1} nautil.c
+nautilW.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${W} nautil.c
+nautilW1.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${W1} nautil.c
+nautilL.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${L} nautil.c
+nautilL1.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${L1} nautil.c
+
+naugraph.o: nauty.h naugraph.c
+	${CCOBJ} naugraph.c
+naugraph1.o: nauty.h naugraph.c
+	${CCOBJ} ${SMALL} naugraph.c
+naugraphS.o: nauty.h naugraph.c
+	${CCOBJ} ${S} naugraph.c
+naugraphS1.o: nauty.h naugraph.c
+	${CCOBJ} ${S1} naugraph.c
+naugraphW.o: nauty.h naugraph.c
+	${CCOBJ} ${W} naugraph.c
+naugraphW1.o: nauty.h naugraph.c
+	${CCOBJ} ${W1} naugraph.c
+naugraphL.o: nauty.h naugraph.c
+	${CCOBJ} ${L} naugraph.c
+naugraphL1.o: nauty.h naugraph.c
+	${CCOBJ} ${L1} naugraph.c
+
+naututil.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} naututil.c
+naututil1.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${SMALL} naututil.c
+naututilS.o: nauty.h naututil.h nausparse.h naututil.c 
+	${CCOBJ} ${S} naututil.c
+naututilS1.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${S1} naututil.c
+naututilW.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${W} naututil.c
+naututilW1.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${W1} naututil.c
+naututilL.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${L} naututil.c
+naututilL1.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${L1} naututil.c
+
+nautinv.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} nautinv.c
+nautinv1.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${SMALL} nautinv.c
+nautinvS.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${S} nautinv.c
+nautinvS1.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${S1} nautinv.c
+nautinvW.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${W} nautinv.c 
+nautinvW1.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${W1} nautinv.c
+nautinvL.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${L} nautinv.c
+nautinvL1.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${L1} nautinv.c
+
+schreier.o : nauty.h naurng.h schreier.h schreier.c
+	${CCOBJ} schreier.c
+schreierS.o : nauty.h naurng.h schreier.h schreier.c
+	${CCOBJ} ${S} schreier.c
+schreierW.o : nauty.h naurng.h schreier.h schreier.c
+	${CCOBJ} ${W} schreier.c
+schreierL.o : nauty.h naurng.h schreier.h schreier.c
+	${CCOBJ} ${L} schreier.c
+
+nausparse.o : nauty.h nausparse.h nausparse.c sorttemplates.c
+	${CCOBJ} nausparse.c
+nausparseS.o: nauty.h nausparse.h nausparse.c sorttemplates.c
+	${CCOBJ} ${S} nausparse.c
+nausparseW.o: nauty.h nausparse.h nausparse.c sorttemplates.c
+	${CCOBJ} ${W} nausparse.c
+nausparseL.o: nauty.h nausparse.h nausparse.c sorttemplates.c
+	${CCOBJ} ${L} nausparse.c
+
+traces.o : nauty.h naurng.h schreier.h traces.h nausparse.h traces.c
+	${CCOBJ} traces.c
+tracesS.o : nauty.h naurng.h schreier.h traces.h nausparse.h traces.c
+	${CCOBJ} ${S} traces.c
+tracesW.o : nauty.h naurng.h schreier.h traces.h nausparse.h traces.c
+	${CCOBJ} ${W} traces.c
+tracesL.o : nauty.h naurng.h schreier.h traces.h nausparse.h traces.c
+	${CCOBJ} ${L} traces.c
+
+gtools.o : ${GTOOLSH} gtools.c
+	${CCOBJ} gtools.c
+gtoolsS.o : ${GTOOLSH} gtools.c
+	${CCOBJ} ${S} gtools.c
+gtoolsW.o : ${GTOOLSH} gtools.c
+	${CCOBJ} ${W} gtools.c
+gtoolsL.o : ${GTOOLSH} gtools.c
+	${CCOBJ} ${L} gtools.c
+
+nautaux.o: nautaux.h nauty.h naututil.h nautaux.c
+	${CCOBJ} nautaux.c
+nautauxS.o: nautaux.h nauty.h naututil.h nautaux.c
+	${CCOBJ} ${S} nautaux.c
+nautauxW.o: nautaux.h nauty.h naututil.h nautaux.c
+	${CCOBJ} ${W} nautaux.c
+nautauxL.o: nautaux.h nauty.h naututil.h nautaux.c
+	${CCOBJ} ${L} nautaux.c
+
+gtnauty.o : ${GTOOLSH} gtnauty.c sorttemplates.c
+	${CCOBJ} gtnauty.c
+gtnautyL1.o : ${GTOOLSH} gtnauty.c sorttemplates.c
+	${CCOBJ} ${L1} gtnauty.c
+gtnautyW1.o : ${GTOOLSH} gtnauty.c sorttemplates.c
+	${CCOBJ} ${W1} gtnauty.c
+gtnautyL.o : ${GTOOLSH} gtnauty.c sorttemplates.c
+	${CCOBJ} ${L} gtnauty.c
+gtnautyW.o : ${GTOOLSH} gtnauty.c sorttemplates.c
+	${CCOBJ} ${W} gtnauty.c
+
+naurng.o: naurng.c nauty.h
+	${CCOBJ} naurng.c
+rng.o: rng.c nauty.h
+	${CCOBJ} rng.c
+
+dreadnaut: dreadnaut.c naututil.o nautinv.o traces.o gtools.o ${NAUTYO}
+	${CC} -o dreadnaut ${SAFECFLAGS} dreadnaut.c naututil.o \
+		nautinv.o gtools.o traces.o ${NAUTYO} ${LDFLAGS} ${THREADLIB}
+dreadnautL: dreadnaut.c naututilL.o nautyL.o nautilL.o nautinvL.o \
+	     nausparseL.o naugraphL.o naurng.o schreierL.o tracesL.o gtoolsL.o
+	${CC} -o dreadnautL ${SAFECFLAGS} ${L} dreadnaut.c naututilL.o \
+	     nautyL.o nautilL.o nautinvL.o naugraphL.o naurng.o gtoolsL.o \
+	     nausparseL.o schreierL.o tracesL.o ${LDFLAGS}
+dreadnaut1: dreadnaut.c naututil1.o nauty1.o nautil1.o nautinv1.o \
+	     nausparse.o naugraph1.o naurng.o schreier.o traces.o gtools.o
+	${CC} -o dreadnaut1 ${SAFECFLAGS} ${SMALL} dreadnaut.c naututil1.o \
+	     nauty1.o nautil1.o nautinv1.o naugraph1.o naurng.o gtools.o \
+	     nausparse.o schreier.o traces.o ${LDFLAGS}
+
+nauty.a: ${NAUTYO} traces.o gtools.o naututil.o nautinv.o \
+			gutil1.o gutil2.o gtnauty.o naugroup.o
+	rm -f nauty.a
+	ar crs nauty.a ${NAUTYO} traces.o gtools.o naututil.o \
+		 nautinv.o gutil1.o gutil2.o gtnauty.o naugroup.o \
+		 naurng.o schreier.o
+
+nauty1.a: ${NAUTY1O} traces.o gtools.o naututil1.o nautinv1.o \
+	   gutil1.o gutil2.o gtnauty.o naugroup.o
+	rm -f nauty1.a
+	ar crs nauty1.a ${NAUTY1O} traces.o gtools.o naututil1.o \
+	   nautinv1.o gutil1.o gutil2.o gtnauty.o naugroup.o 
+
+nautyW.a: ${NAUTYWO} traces.o gtoolsW.o naututilW.o nautinvW.o \
+	   gutil1W.o gutil2W.o gtnautyW.o naugroupW.o 
+	rm -f nautyW.a
+	ar crs nautyW.a ${NAUTYWO} traces.o gtoolsW.o naututilW.o \
+	   nautinvW.o gutil1W.o gutil2W.o gtnautyW.o naugroupW.o
+
+nautyW1.a: ${NAUTYW1O} traces.o gtoolsW.o naututilW1.o nautinvW1.o \
+	   gutil1W1.o gutil2W1.o gtnautyW1.o naugroupW.o 
+	rm -f nautyW1.a
+	ar crs nautyW1.a ${NAUTYW1O} traces.o gtoolsW.o naututilW1.o \
+	   nautinvW1.o gutil1W1.o gutil2W1.o gtnautyW1.o naugroupW.o
+
+nautyL.a: ${NAUTYLO} traces.o gtoolsL.o naututilL.o nautinvL.o \
+	   gutil1L.o gutil2L.o gtnautyL.o naugroupL.o 
+	rm -f nautyL.a
+	ar crs nautyL.a ${NAUTYLO} traces.o gtoolsL.o naututilL.o \
+	   nautinvL.o gutil1L.o gutil2L.o gtnautyL.o naugroupL.o
+
+nautyL1.a: ${NAUTYL1O} traces.o gtoolsL.o naututilL1.o nautinvL1.o \
+	   gutil1L1.o gutil2L1.o gtnautyL1.o naugroupL.o 
+	rm -f nautyL1.a
+	ar crs nautyL1.a ${NAUTYL1O} traces.o gtoolsL.o naututilL1.o \
+	   nautinvL1.o gutil1L1.o gutil2L1.o gtnautyL1.o naugroupL.o
+
+clean:
+	rm -f *.o config.log config.cache config.status nauty*.a
+	rm -f dreadtest${EXEEXT} dreadtestL${EXEEXT} \
+		dreadtestW${EXEEXT} \
+		dreadtestS${EXEEXT} dreadtestS1${EXEEXT} \
+	        dreadtest4K${EXEEXT} dreadtest1${EXEEXT} \
+		dreadtestL1${EXEEXT} dreadtestW1${EXEEXT}
+
+gutil1.o : ${GTOOLSH} gutils.h gutil1.c
+	${CCOBJ} gutil1.c
+gutil2.o : ${GTOOLSH} gutils.h gutil2.c
+	${CCOBJ} gutil2.c
+gutil1W1.o : ${GTOOLSH} gutils.h gutil1.c
+	${CCOBJ} ${W1} gutil1.c
+gutil2W1.o : ${GTOOLSH} gutils.h gutil2.c
+	${CCOBJ} ${W1} gutil2.c
+gutil1L1.o : ${GTOOLSH} gutils.h gutil1.c
+	${CCOBJ} ${L1} gutil1.c
+gutil2L1.o : ${GTOOLSH} gutils.h gutil2.c
+	${CCOBJ} ${L1} gutil2.c
+gutil1W.o : ${GTOOLSH} gutils.h gutil1.c
+	${CCOBJ} ${W} gutil1.c
+gutil2W.o : ${GTOOLSH} gutils.h gutil2.c
+	${CCOBJ} ${W} gutil2.c
+gutil1L.o : ${GTOOLSH} gutils.h gutil1.c
+	${CCOBJ} ${L} gutil1.c
+gutil2L.o : ${GTOOLSH} gutils.h gutil2.c
+	${CCOBJ} ${L} gutil2.c
+
+catg : ${GTOOLSH} catg.c gtools.o
+	${CC} -o catg ${CFLAGS} catg.c gtools.o ${LDFLAGS}
+
+copyg : ${GTOOLSH} copyg.c gtools.o
+	${CC} -o copyg ${CFLAGS} copyg.c gtools.o ${LDFLAGS}
+
+genspecialg : ${GTOOLSH} genspecialg.c ${NAUTYO} gtools.o
+	${CC} -o genspecialg ${CFLAGS} genspecialg.c ${NAUTYO} gtools.o ${LDFLAGS}
+
+listg : ${GTOOLSH} listg.c gtools.o nautil.o
+	${CC} -o listg ${CFLAGS} listg.c gtools.o nautil.o ${LDFLAGS}
+
+labelg : ${GTOOLSH} naututil.h labelg.c gtools.o gtnauty.o ${NAUTYO} \
+            nautinv.o nausparse.h gutils.h gutil2.o traces.h traces.o naututil.o
+	${CC} -o labelg ${SAFECFLAGS} labelg.c gtools.o gtnauty.o naututil.o \
+	    nautinv.o gutil2.o traces.o ${NAUTYO} ${LDFLAGS} ${THREADLIB}
+
+shortg : ${GTOOLSH} shortg.c gtools.o gtnauty.o ${NAUTYO} \
+            nausparse.h gutils.h gutil2.o nautinv.h nautinv.o traces.o
+	${CC} -o shortg ${CFLAGS} shortg.c gtools.o gtnauty.o nautinv.o \
+            ${NAUTYO} gutil2.o traces.o ${LDFLAGS} ${THREADLIB}
+
+dretog : ${GTOOLSH} dretog.c naututil.o gtools.o ${NAUTYO} 
+	${CC} -o dretog ${CFLAGS} dretog.c naututil.o gtools.o \
+	    ${NAUTYO} ${LDFLAGS}
+
+dretodot : ${GTOOLSH} dretodot.c naututil.o gtools.o \
+		traces.o traces.h ${NAUTYO} 
+	${CC} -o dretodot ${CFLAGS} dretodot.c naututil.o gtools.o \
+	    traces.o ${NAUTYO} ${LDFLAGS} -lm
+
+amtog : ${GTOOLSH} amtog.c gtools.o ${NAUTYO}
+	${CC} -o amtog ${CFLAGS} amtog.c gtools.o ${NAUTYO} ${LDFLAGS}
+
+genbg : ${GTOOLSH} genbg.c gtoolsW.o nautyW1.o nautilW1.o naugraphW1.o \
+	    schreierW.o naurng.o
+	${CC} -o genbg ${CFLAGS} ${W1} genbg.c gtoolsW.o schreierW.o \
+		nautyW1.o nautilW1.o naugraphW1.o naurng.o ${LDFLAGS}
+
+genbgL : ${GTOOLSH} genbg.c gtoolsL.o nautyL1.o nautilL1.o naugraphL1.o \
+	    schreierL.o naurng.o
+	${CC} -o genbgL ${CFLAGS} ${L1} -DMAXN1=30 genbg.c gtoolsL.o \
+	    schreierL.o naurng.o nautyL1.o nautilL1.o naugraphL1.o ${LDFLAGS}
+
+geng : ${GTOOLSH} geng.c gtoolsW.o nautyW1.o nautilW1.o naugraphW1.o schreier.o naurng.o
+	${CC} -o geng ${CFLAGS} ${W1} geng.c gtoolsW.o nautyW1.o \
+		nautilW1.o naugraphW1.o schreier.o naurng.o ${LDFLAGS}
+
+geng16 : ${GTOOLSH} geng.c gtoolsW.o nautyW1.o nautilW1.o naugraphW1.o schreier.o naurng.o
+	${CC} -o geng16 ${CFLAGS} -DMAXN=16 $W geng.c gtoolsW.o nautyW1.o \
+		nautilW1.o naugraphW1.o schreier.o naurng.o ${LDFLAGS}
+
+geng24 : ${GTOOLSH} geng.c gtoolsW.o nautyW1.o nautilW1.o naugraphW1.o schreier.o naurng.o
+	${CC} -o geng24 ${CFLAGS} -DMAXN=24 $W geng.c gtoolsW.o nautyW1.o \
+		nautilW1.o naugraphW1.o schreier.o naurng.o ${LDFLAGS}
+
+gentourng : ${GTOOLSH} gentourng.c gtoolsW.o nautyW1.o nautilW1.o \
+	    naugraphW1.o schreier.o naurng.o
+	${CC} -o gentourng ${CFLAGS} -DMAXN=24 $W gentourng.c gtoolsW.o nautyW1.o \
+		nautilW1.o naugraphW1.o schreier.o naurng.o ${LDFLAGS}
+
+genquarticg : ${GTOOLSH} genquarticg.c gtoolsL.o nautyL1.o nautilL1.o \
+	    naugraphL1.o schreierL.o naurng.o quarticirred28.h
+	${CC} -o genquarticg ${CFLAGS} genquarticg.c gtoolsL.o nautyL1.o \
+		nautilL1.o naugraphL1.o schreierL.o naurng.o ${LDFLAGS}
+
+gentreeg : gentreeg.c gtools.o nauty.h gtools.h
+	${CC} -o gentreeg ${CFLAGS} gentreeg.c gtools.o
+
+genrang : ${GTOOLSH} genrang.c gtools.o naututil.o ${NAUTYO}
+	${CC} -o genrang ${CFLAGS} genrang.c \
+		gtools.o naututil.o ${NAUTYO} ${LDFLAGS}
+
+complg : ${GTOOLSH} complg.c gtools.o gtnauty.o ${NAUTYO}
+	${CC} -o complg ${CFLAGS} complg.c gtools.o gtnauty.o \
+		${NAUTYO} ${LDFLAGS}
+
+cubhamg : ${GTOOLSH} cubhamg.c gtools.o ${NAUTYO}
+	${CC} -o cubhamg ${CFLAGS} cubhamg.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+twohamg : ${GTOOLSH} twohamg.c gtools.o ${NAUTYO}
+	${CC} -o twohamg ${CFLAGS} twohamg.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+hamheuristic : ${GTOOLSH} hamheuristic.c gtools.o ${NAUTYO}
+	${CC} -o hamheuristic ${CFLAGS} hamheuristic.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+converseg : ${GTOOLSH} converseg.c gtools.o ${NAUTYO}
+	${CC} -o converseg ${CFLAGS} converseg.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+linegraphg : ${GTOOLSH} linegraphg.c gtools.o ${NAUTYO}
+	${CC} -o linegraphg ${CFLAGS} linegraphg.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+subdivideg : ${GTOOLSH} subdivideg.c gtools.o ${NAUTYO}
+	${CC} -o subdivideg ${CFLAGS} subdivideg.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+vcolg : ${GTOOLSH} vcolg.c gtools.o ${NAUTYO} naugroup.o naugroup.h
+	${CC} -o vcolg ${CFLAGS} vcolg.c gtools.o naugroup.o \
+		${NAUTYO} ${LDFLAGS}
+
+biplabg : ${GTOOLSH} gutils.h biplabg.c gtools.o gutil1.o ${NAUTYO}
+	${CC} -o biplabg ${CFLAGS} biplabg.c \
+		gtools.o gutil1.o ${NAUTYO} ${LDFLAGS}
+
+ranlabg : ${GTOOLSH} ranlabg.c gtools.o ${NAUTYO}
+	${CC} -o ranlabg ${CFLAGS} ranlabg.c gtools.o ${NAUTYO} ${LDFLAGS}
+
+NRswitchg : ${GTOOLSH} NRswitchg.c gtools.o gtnauty.o ${NAUTYO}
+	${CC} -o NRswitchg ${CFLAGS} NRswitchg.c gtools.o gtnauty.o \
+		 ${NAUTYO} ${LDFLAGS}
+
+deledgeg : ${GTOOLSH} deledgeg.c gtools.o gtnauty.o ${NAUTYO}
+	${CC} -o deledgeg ${CFLAGS} deledgeg.c gtools.o gtnauty.o \
+		 ${NAUTYO} ${LDFLAGS}
+
+delptg : ${GTOOLSH} delptg.c gtools.o gtnauty.o ${NAUTYO}
+	${CC} -o delptg ${CFLAGS} delptg.c gtools.o gtnauty.o \
+		 ${NAUTYO} ${LDFLAGS}
+
+addedgeg : ${GTOOLSH} gutils.h addedgeg.c gtools.o gtnauty.o gutil1.o ${NAUTYO}
+	${CC} -o addedgeg ${CFLAGS} addedgeg.c gtools.o gtnauty.o \
+	        gutil1.o ${NAUTYO} ${LDFLAGS}
+
+newedgeg : ${GTOOLSH} gutils.h newedgeg.c gtools.o gtnauty.o ${NAUTYO}
+	${CC} -o newedgeg ${CFLAGS} newedgeg.c gtools.o gtnauty.o \
+		 ${NAUTYO} ${LDFLAGS}
+
+pickg : ${GTOOLSH} gutils.h testg.c splay.c ${NAUTYO} \
+	     gtools.o gtnauty.o gutil1.o gutil2.o nautinv.o 
+	${CC} -o pickg ${SAFECFLAGS} testg.c gtools.o gtnauty.o gutil1.o \
+	        gutil2.o nautinv.o ${NAUTYO} ${LDFLAGS}
+
+countg : ${GTOOLSH} gutils.h testg.c splay.c ${NAUTYO} \
+	     gtools.o gtnauty.o gutil1.o gutil2.o nautinv.o
+	${CC} -o countg ${SAFECFLAGS} testg.c gtools.o gtnauty.o gutil1.o \
+	         gutil2.o nautinv.o ${NAUTYO} ${LDFLAGS} 
+
+directg : ${GTOOLSH} naugroup.h directg.c  gtools.o naugroup.o ${NAUTYO}
+	${CC} -o directg ${CFLAGS} directg.c gtools.o \
+                ${NAUTYO} naugroup.o ${LDFLAGS}
+
+multig : ${GTOOLSH} naugroup.h multig.c gtools.o naugroup.o ${NAUTYO}
+	${CC} -o multig ${CFLAGS} multig.c gtools.o \
+                ${NAUTYO} naugroup.o ${LDFLAGS}
+
+planarg : ${GTOOLSH} planarg.c gtools.o planarity.c
+	${CC} -o planarg ${CFLAGS} \
+		planarg.c planarity.c gtools.o ${LDFLAGS}
+
+watercluster2 : ${GTOOLSH} nauty.h watercluster2.c gtools.o ${NAUTYO}
+	${CC} -o watercluster2 ${CFLAGS} -DMAXN=32 watercluster2.c \
+                 gtools.o ${NAUTYO} ${LDFLAGS}
+
+showg : showg.c
+	${CC} -o showg ${CFLAGS} showg.c ${LDFLAGS}
+
+readg : showg
+	echo "*** readg is now called showg ***"
+
+sumlines : sumlines.c
+	${CC} -o sumlines ${CFLAGS} sumlines.c ${LDFLAGS} -lgmp
+
+blisstog : ${GTOOLSH} blisstog.c gtools.o ${NAUTYO}
+	${CC} -o blisstog ${CFLAGS} blisstog.c gtools.o \
+                ${NAUTYO} ${LDFLAGS}
+
+bliss2dre : ${GTOOLSH} bliss2dre.c gtools.o ${NAUTYO}
+	${CC} -o bliss2dre ${CFLAGS} bliss2dre.c gtools.o \
+                ${NAUTYO} ${LDFLAGS}
+
+testlabelling : testlabelling.c nauty.h nauty.a
+	${CC} -o testlabelling -g testlabelling.c traces.c nauty.a ${LDFLAGS}
+
+naugroup.o : nauty.h naugroup.h naugroup.c
+	${CCOBJ} naugroup.c
+naugroupW.o : nauty.h naugroup.h naugroup.c
+	${CCOBJ} ${W} naugroup.c
+naugroupL.o : nauty.h naugroup.h naugroup.c
+	${CCOBJ} ${L} naugroup.c
+
+nautyex1 : nauty.h nautyex1.c nauty.a
+	${CC} -o nautyex1 ${CFLAGS} nautyex1.c nauty.a ${LDFLAGS}
+nautyex2 : nauty.h nautyex2.c ${NAUTYO}
+	${CC} -o nautyex2 ${CFLAGS} nautyex2.c nauty.a ${LDFLAGS}
+nautyex3 : nauty.h nautyex3.c nauty.a
+	${CC} -o nautyex3 ${CFLAGS} nautyex3.c nauty.a ${LDFLAGS}
+nautyex4 : nauty.h nausparse.h nautyex4.c nauty.a
+	${CC} -o nautyex4 ${CFLAGS} nautyex4.c nauty.a ${LDFLAGS}
+nautyex5 : nauty.h nausparse.h nautyex5.c nauty.a
+	${CC} -o nautyex5 ${CFLAGS} nautyex5.c nauty.a ${LDFLAGS}
+nautyex6 : nauty.h nautyex6.c nauty.a
+	${CC} -o nautyex6 ${CFLAGS} nautyex6.c nauty.a ${LDFLAGS}
+nautyex7 : nauty.h nautyex7.c traces.h nauty.a
+	${CC} -o nautyex7 ${CFLAGS} nautyex7.c nauty.a ${LDFLAGS}
+nautyex8 : nauty.h nausparse.h nautyex8.c nauty.a
+	${CC} -o nautyex8 ${CFLAGS} nautyex8.c nauty.a ${LDFLAGS}
+nautyex9 : nauty.h nautyex9.c nauty.a
+	${CC} -o nautyex9 ${CFLAGS} nautyex9.c nauty.a ${LDFLAGS}
+nautyex10 : nauty.h nautyex10.c nauty.a
+	${CC} -o nautyex10 ${CFLAGS} nautyex10.c nauty.a ${LDFLAGS}
+
+testprogs: ${TESTPROGS} ;
+
+checks: nauty gtools naucompare ${TESTPROGS}
+	./runalltests
+
+naucompare : naucompare.c
+	${CC} -o naucompare ${CFLAGS} naucompare.c ${LDFLAGS}
+
+dreadtest: dreadnaut.c nautinv.o ${NAUTYO} naututil.o traces.o gtools.o 
+	${CC} -o dreadtest ${SAFECFLAGS} -DDREADTEST dreadnaut.c \
+	    nautinv.o naututil.o traces.o gtools.o ${NAUTYO} ${LDFLAGS}
+dreadtest1: dreadnaut.c nautinv1.o ${NAUTY1O} naututil1.o traces.o gtools.o 
+	${CC} -o dreadtest1 ${SAFECFLAGS} ${SMALL} -DDREADTEST dreadnaut.c \
+	    nautinv1.o naututil1.o traces.o gtools.o ${NAUTY1O} ${LDFLAGS}
+dreadtestS: dreadnaut.c nautinvS.o ${NAUTYSO} naututilS.o tracesS.o gtoolsS.o 
+	${CC} -o dreadtestS ${SAFECFLAGS} ${S} -DDREADTEST dreadnaut.c \
+	    nautinvS.o naututilS.o tracesS.o gtoolsS.o ${NAUTYSO} ${LDFLAGS}
+dreadtestS1: dreadnaut.c nautinvS1.o ${NAUTYS1O} naututilS1.o \
+		tracesS.o gtoolsS.o 
+	${CC} -o dreadtestS1 ${SAFECFLAGS} ${S1} -DDREADTEST dreadnaut.c \
+	    nautinvS1.o naututilS1.o tracesS.o gtoolsS.o ${NAUTYS1O} ${LDFLAGS}
+dreadtestW: dreadnaut.c nautinvW.o ${NAUTYWO} naututilW.o tracesW.o gtoolsW.o 
+	${CC} -o dreadtestW ${SAFECFLAGS} ${W} -DDREADTEST dreadnaut.c \
+	    nautinvW.o naututilW.o tracesW.o gtoolsW.o ${NAUTYWO} ${LDFLAGS}
+dreadtestW1: dreadnaut.c nautinvW1.o ${NAUTYW1O} naututilW1.o \
+		tracesW.o gtoolsW.o 
+	${CC} -o dreadtestW1 ${SAFECFLAGS} ${W1} -DDREADTEST dreadnaut.c \
+	    nautinvW1.o naututilW1.o tracesW.o gtoolsW.o ${NAUTYW1O} ${LDFLAGS}
+dreadtestL: dreadnaut.c nautinvL.o ${NAUTYLO} naututilL.o tracesL.o gtoolsL.o 
+	${CC} -o dreadtestL ${SAFECFLAGS} ${L} -DDREADTEST dreadnaut.c \
+	    nautinvL.o naututilL.o tracesL.o gtoolsL.o ${NAUTYLO} ${LDFLAGS}
+dreadtestL1: dreadnaut.c nautinvL1.o ${NAUTYL1O} naututilL1.o \
+		tracesL.o gtoolsL.o 
+	${CC} -o dreadtestL1 ${SAFECFLAGS} ${L1} -DDREADTEST dreadnaut.c \
+	    nautinvL1.o naututilL1.o tracesL.o gtoolsL.o ${NAUTYL1O} ${LDFLAGS}
+dreadtest4K: dreadnaut.c nausparse.c schreier.c naututil.c nauty.c \
+	    nautil.c nautinv.c naugraph.c naurng.o gtools.c traces.c
+	${CC} -o dreadtest4K ${SAFECFLAGS} -DMAXN=4096 -DDREADTEST \
+	    dreadnaut.c naututil.c nauty.c nautil.c nautinv.c \
+	    naugraph.c nausparse.c naurng.o schreier.c gtools.c \
+	    traces.c ${LDFLAGS}
+
+checks6: checks6.c ${GTOOLSH} gtools.o
+	${CC} -o checks6 ${SAFECFLAGS} checks6.c gtools.o
+
+bigs: gtnauty.o gutil2.o nausparse.o nautil.o naututil.o gtools.o \
+	naugraph.o nautaux.o nautinv.o nauty.o schreier.o
+	rm -f gtnautyB.o gutil2B.o nausparseB.o nautilB.o naututilB.o \
+	  gtoolsB.o naugraphB.o nautauxB.o nautinvB.o nautyB.o
+	cp gtnauty.o gtnautyB.o
+	cp gutil2.o gutil2B.o
+	cp nausparse.o nausparseB.o
+	cp nautil.o nautilB.o
+	cp naututil.o naututilB.o
+	cp gtools.o gtoolsB.o
+	cp naugraph.o naugraphB.o
+	cp nautaux.o nautauxB.o
+	cp nautinv.o nautinvB.o
+	cp nauty.o nautyB.o
+	cp schreier.o schreierB.o
+
+# ++++++ This file is automatically generated, don't edit it by hand! ++++++
diff --git a/lib/nauty/makefile.in b/lib/nauty/makefile.in
new file mode 100644
index 0000000..56e63b9
--- /dev/null
+++ b/lib/nauty/makefile.in
@@ -0,0 +1,540 @@
+# makefile for nauty 2.6
+# @configure_input@
+
+SHELL=/bin/sh
+CC=@CC@
+CFLAGS=@CFLAGS@ @MORECFLAGS@
+SAFECFLAGS=@CFLAGS@
+LDFLAGS=@LDFLAGS@ @LIBS@
+THREADLIB=@threadlib@
+LOK=@lok@         # 0 if no 64-bit integers
+TESTPROGS=@testprogs@
+EXEEXT=@EXEEXT@
+
+SMALL=-DMAXN=WORDSIZE
+S1=-DMAXN=WORDSIZE -DWORDSIZE=16
+W1=-DMAXN=WORDSIZE -DWORDSIZE=32
+L1=-DMAXN=WORDSIZE -DWORDSIZE=64
+S=-DWORDSIZE=16
+W=-DWORDSIZE=32
+L=-DWORDSIZE=64
+
+CCOBJ=${CC} -c ${CFLAGS} -o $@
+GTOOLSH=gtools.h nauty.h naututil.h nausparse.h naurng.h
+
+# @edit_msg@
+
+all : nauty gtools ;
+
+nauty : dreadnaut nauty.a nauty1.a nautyW.a nautyW1.a nautyL.a nautyL1.a;
+
+gtools : copyg listg labelg dretog amtog geng complg showg NRswitchg \
+  biplabg addedgeg deledgeg countg pickg genrang newedgeg catg genbg \
+  directg gentreeg genquarticg \
+  ranlabg multig planarg gentourng linegraphg watercluster2 dretodot \
+  subdivideg vcolg delptg cubhamg twohamg hamheuristic converseg \
+  genspecialg genbgL @shortg_or_null@ ;
+
+NAUTYO=nauty.o nautil.o nausparse.o naugraph.o schreier.o naurng.o
+NAUTY1O=nauty1.o nautil1.o nausparse.o naugraph1.o schreier.o naurng.o
+NAUTYSO=nautyS.o nautilS.o nausparseS.o naugraphS.o schreierS.o naurng.o
+NAUTYS1O=nautyS1.o nautilS1.o nausparseS.o naugraphS1.o schreierS.o naurng.o
+NAUTYWO=nautyW.o nautilW.o nausparseW.o naugraphW.o schreierW.o naurng.o
+NAUTYW1O=nautyW1.o nautilW1.o nausparseW.o naugraphW1.o schreierW.o naurng.o
+NAUTYLO=nautyL.o nautilL.o nausparseL.o naugraphL.o schreierL.o naurng.o
+NAUTYL1O=nautyL1.o nautilL1.o nausparseL.o naugraphL1.o schreierL.o naurng.o
+
+nauty.o: nauty.h schreier.h nauty.c
+	${CCOBJ} nauty.c
+nauty1.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${SMALL} nauty.c
+nautyS.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${S} nauty.c
+nautyS1.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${S1} nauty.c
+nautyW.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${W} nauty.c
+nautyW1.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${W1} nauty.c
+nautyL.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${L} nauty.c
+nautyL1.o: nauty.h schreier.h nauty.c
+	${CCOBJ} ${L1} nauty.c
+
+nautil.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} nautil.c
+nautil1.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${SMALL} nautil.c
+nautilS.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${S} nautil.c
+nautilS1.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${S1} nautil.c
+nautilW.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${W} nautil.c
+nautilW1.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${W1} nautil.c
+nautilL.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${L} nautil.c
+nautilL1.o: nauty.h nautil.c sorttemplates.c
+	${CCOBJ} ${L1} nautil.c
+
+naugraph.o: nauty.h naugraph.c
+	${CCOBJ} naugraph.c
+naugraph1.o: nauty.h naugraph.c
+	${CCOBJ} ${SMALL} naugraph.c
+naugraphS.o: nauty.h naugraph.c
+	${CCOBJ} ${S} naugraph.c
+naugraphS1.o: nauty.h naugraph.c
+	${CCOBJ} ${S1} naugraph.c
+naugraphW.o: nauty.h naugraph.c
+	${CCOBJ} ${W} naugraph.c
+naugraphW1.o: nauty.h naugraph.c
+	${CCOBJ} ${W1} naugraph.c
+naugraphL.o: nauty.h naugraph.c
+	${CCOBJ} ${L} naugraph.c
+naugraphL1.o: nauty.h naugraph.c
+	${CCOBJ} ${L1} naugraph.c
+
+naututil.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} naututil.c
+naututil1.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${SMALL} naututil.c
+naututilS.o: nauty.h naututil.h nausparse.h naututil.c 
+	${CCOBJ} ${S} naututil.c
+naututilS1.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${S1} naututil.c
+naututilW.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${W} naututil.c
+naututilW1.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${W1} naututil.c
+naututilL.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${L} naututil.c
+naututilL1.o: nauty.h naututil.h nausparse.h naututil.c
+	${CCOBJ} ${L1} naututil.c
+
+nautinv.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} nautinv.c
+nautinv1.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${SMALL} nautinv.c
+nautinvS.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${S} nautinv.c
+nautinvS1.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${S1} nautinv.c
+nautinvW.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${W} nautinv.c 
+nautinvW1.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${W1} nautinv.c
+nautinvL.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${L} nautinv.c
+nautinvL1.o: nauty.h naututil.h nautinv.c
+	${CCOBJ} ${L1} nautinv.c
+
+schreier.o : nauty.h naurng.h schreier.h schreier.c
+	${CCOBJ} schreier.c
+schreierS.o : nauty.h naurng.h schreier.h schreier.c
+	${CCOBJ} ${S} schreier.c
+schreierW.o : nauty.h naurng.h schreier.h schreier.c
+	${CCOBJ} ${W} schreier.c
+schreierL.o : nauty.h naurng.h schreier.h schreier.c
+	${CCOBJ} ${L} schreier.c
+
+nausparse.o : nauty.h nausparse.h nausparse.c sorttemplates.c
+	${CCOBJ} nausparse.c
+nausparseS.o: nauty.h nausparse.h nausparse.c sorttemplates.c
+	${CCOBJ} ${S} nausparse.c
+nausparseW.o: nauty.h nausparse.h nausparse.c sorttemplates.c
+	${CCOBJ} ${W} nausparse.c
+nausparseL.o: nauty.h nausparse.h nausparse.c sorttemplates.c
+	${CCOBJ} ${L} nausparse.c
+
+traces.o : nauty.h naurng.h schreier.h traces.h nausparse.h traces.c
+	${CCOBJ} traces.c
+tracesS.o : nauty.h naurng.h schreier.h traces.h nausparse.h traces.c
+	${CCOBJ} ${S} traces.c
+tracesW.o : nauty.h naurng.h schreier.h traces.h nausparse.h traces.c
+	${CCOBJ} ${W} traces.c
+tracesL.o : nauty.h naurng.h schreier.h traces.h nausparse.h traces.c
+	${CCOBJ} ${L} traces.c
+
+gtools.o : ${GTOOLSH} gtools.c
+	${CCOBJ} gtools.c
+gtoolsS.o : ${GTOOLSH} gtools.c
+	${CCOBJ} ${S} gtools.c
+gtoolsW.o : ${GTOOLSH} gtools.c
+	${CCOBJ} ${W} gtools.c
+gtoolsL.o : ${GTOOLSH} gtools.c
+	${CCOBJ} ${L} gtools.c
+
+nautaux.o: nautaux.h nauty.h naututil.h nautaux.c
+	${CCOBJ} nautaux.c
+nautauxS.o: nautaux.h nauty.h naututil.h nautaux.c
+	${CCOBJ} ${S} nautaux.c
+nautauxW.o: nautaux.h nauty.h naututil.h nautaux.c
+	${CCOBJ} ${W} nautaux.c
+nautauxL.o: nautaux.h nauty.h naututil.h nautaux.c
+	${CCOBJ} ${L} nautaux.c
+
+gtnauty.o : ${GTOOLSH} gtnauty.c sorttemplates.c
+	${CCOBJ} gtnauty.c
+gtnautyL1.o : ${GTOOLSH} gtnauty.c sorttemplates.c
+	${CCOBJ} ${L1} gtnauty.c
+gtnautyW1.o : ${GTOOLSH} gtnauty.c sorttemplates.c
+	${CCOBJ} ${W1} gtnauty.c
+gtnautyL.o : ${GTOOLSH} gtnauty.c sorttemplates.c
+	${CCOBJ} ${L} gtnauty.c
+gtnautyW.o : ${GTOOLSH} gtnauty.c sorttemplates.c
+	${CCOBJ} ${W} gtnauty.c
+
+naurng.o: naurng.c nauty.h
+	${CCOBJ} naurng.c
+rng.o: rng.c nauty.h
+	${CCOBJ} rng.c
+
+dreadnaut: dreadnaut.c naututil.o nautinv.o traces.o gtools.o ${NAUTYO}
+	${CC} -o dreadnaut ${SAFECFLAGS} dreadnaut.c naututil.o \
+		nautinv.o gtools.o traces.o ${NAUTYO} ${LDFLAGS} ${THREADLIB}
+dreadnautL: dreadnaut.c naututilL.o nautyL.o nautilL.o nautinvL.o \
+	     nausparseL.o naugraphL.o naurng.o schreierL.o tracesL.o gtoolsL.o
+	${CC} -o dreadnautL ${SAFECFLAGS} ${L} dreadnaut.c naututilL.o \
+	     nautyL.o nautilL.o nautinvL.o naugraphL.o naurng.o gtoolsL.o \
+	     nausparseL.o schreierL.o tracesL.o ${LDFLAGS}
+dreadnaut1: dreadnaut.c naututil1.o nauty1.o nautil1.o nautinv1.o \
+	     nausparse.o naugraph1.o naurng.o schreier.o traces.o gtools.o
+	${CC} -o dreadnaut1 ${SAFECFLAGS} ${SMALL} dreadnaut.c naututil1.o \
+	     nauty1.o nautil1.o nautinv1.o naugraph1.o naurng.o gtools.o \
+	     nausparse.o schreier.o traces.o ${LDFLAGS}
+
+nauty.a: ${NAUTYO} traces.o gtools.o naututil.o nautinv.o \
+			gutil1.o gutil2.o gtnauty.o naugroup.o
+	rm -f nauty.a
+	ar crs nauty.a ${NAUTYO} traces.o gtools.o naututil.o \
+		 nautinv.o gutil1.o gutil2.o gtnauty.o naugroup.o \
+		 naurng.o schreier.o
+
+nauty1.a: ${NAUTY1O} traces.o gtools.o naututil1.o nautinv1.o \
+	   gutil1.o gutil2.o gtnauty.o naugroup.o
+	rm -f nauty1.a
+	ar crs nauty1.a ${NAUTY1O} traces.o gtools.o naututil1.o \
+	   nautinv1.o gutil1.o gutil2.o gtnauty.o naugroup.o 
+
+nautyW.a: ${NAUTYWO} traces.o gtoolsW.o naututilW.o nautinvW.o \
+	   gutil1W.o gutil2W.o gtnautyW.o naugroupW.o 
+	rm -f nautyW.a
+	ar crs nautyW.a ${NAUTYWO} traces.o gtoolsW.o naututilW.o \
+	   nautinvW.o gutil1W.o gutil2W.o gtnautyW.o naugroupW.o
+
+nautyW1.a: ${NAUTYW1O} traces.o gtoolsW.o naututilW1.o nautinvW1.o \
+	   gutil1W1.o gutil2W1.o gtnautyW1.o naugroupW.o 
+	rm -f nautyW1.a
+	ar crs nautyW1.a ${NAUTYW1O} traces.o gtoolsW.o naututilW1.o \
+	   nautinvW1.o gutil1W1.o gutil2W1.o gtnautyW1.o naugroupW.o
+
+nautyL.a: ${NAUTYLO} traces.o gtoolsL.o naututilL.o nautinvL.o \
+	   gutil1L.o gutil2L.o gtnautyL.o naugroupL.o 
+	rm -f nautyL.a
+	ar crs nautyL.a ${NAUTYLO} traces.o gtoolsL.o naututilL.o \
+	   nautinvL.o gutil1L.o gutil2L.o gtnautyL.o naugroupL.o
+
+nautyL1.a: ${NAUTYL1O} traces.o gtoolsL.o naututilL1.o nautinvL1.o \
+	   gutil1L1.o gutil2L1.o gtnautyL1.o naugroupL.o 
+	rm -f nautyL1.a
+	ar crs nautyL1.a ${NAUTYL1O} traces.o gtoolsL.o naututilL1.o \
+	   nautinvL1.o gutil1L1.o gutil2L1.o gtnautyL1.o naugroupL.o
+
+clean:
+	rm -f *.o config.log config.cache config.status nauty*.a
+	rm -f dreadtest${EXEEXT} dreadtestL${EXEEXT} \
+		dreadtestW${EXEEXT} \
+		dreadtestS${EXEEXT} dreadtestS1${EXEEXT} \
+	        dreadtest4K${EXEEXT} dreadtest1${EXEEXT} \
+		dreadtestL1${EXEEXT} dreadtestW1${EXEEXT}
+
+gutil1.o : ${GTOOLSH} gutils.h gutil1.c
+	${CCOBJ} gutil1.c
+gutil2.o : ${GTOOLSH} gutils.h gutil2.c
+	${CCOBJ} gutil2.c
+gutil1W1.o : ${GTOOLSH} gutils.h gutil1.c
+	${CCOBJ} ${W1} gutil1.c
+gutil2W1.o : ${GTOOLSH} gutils.h gutil2.c
+	${CCOBJ} ${W1} gutil2.c
+gutil1L1.o : ${GTOOLSH} gutils.h gutil1.c
+	${CCOBJ} ${L1} gutil1.c
+gutil2L1.o : ${GTOOLSH} gutils.h gutil2.c
+	${CCOBJ} ${L1} gutil2.c
+gutil1W.o : ${GTOOLSH} gutils.h gutil1.c
+	${CCOBJ} ${W} gutil1.c
+gutil2W.o : ${GTOOLSH} gutils.h gutil2.c
+	${CCOBJ} ${W} gutil2.c
+gutil1L.o : ${GTOOLSH} gutils.h gutil1.c
+	${CCOBJ} ${L} gutil1.c
+gutil2L.o : ${GTOOLSH} gutils.h gutil2.c
+	${CCOBJ} ${L} gutil2.c
+
+catg : ${GTOOLSH} catg.c gtools.o
+	${CC} -o catg ${CFLAGS} catg.c gtools.o ${LDFLAGS}
+
+copyg : ${GTOOLSH} copyg.c gtools.o
+	${CC} -o copyg ${CFLAGS} copyg.c gtools.o ${LDFLAGS}
+
+genspecialg : ${GTOOLSH} genspecialg.c ${NAUTYO} gtools.o
+	${CC} -o genspecialg ${CFLAGS} genspecialg.c ${NAUTYO} gtools.o ${LDFLAGS}
+
+listg : ${GTOOLSH} listg.c gtools.o nautil.o
+	${CC} -o listg ${CFLAGS} listg.c gtools.o nautil.o ${LDFLAGS}
+
+labelg : ${GTOOLSH} naututil.h labelg.c gtools.o gtnauty.o ${NAUTYO} \
+            nautinv.o nausparse.h gutils.h gutil2.o traces.h traces.o naututil.o
+	${CC} -o labelg ${SAFECFLAGS} labelg.c gtools.o gtnauty.o naututil.o \
+	    nautinv.o gutil2.o traces.o ${NAUTYO} ${LDFLAGS} ${THREADLIB}
+
+shortg : ${GTOOLSH} shortg.c gtools.o gtnauty.o ${NAUTYO} \
+            nausparse.h gutils.h gutil2.o nautinv.h nautinv.o traces.o
+	${CC} -o shortg ${CFLAGS} shortg.c gtools.o gtnauty.o nautinv.o \
+            ${NAUTYO} gutil2.o traces.o ${LDFLAGS} ${THREADLIB}
+
+dretog : ${GTOOLSH} dretog.c naututil.o gtools.o ${NAUTYO} 
+	${CC} -o dretog ${CFLAGS} dretog.c naututil.o gtools.o \
+	    ${NAUTYO} ${LDFLAGS}
+
+dretodot : ${GTOOLSH} dretodot.c naututil.o gtools.o \
+		traces.o traces.h ${NAUTYO} 
+	${CC} -o dretodot ${CFLAGS} dretodot.c naututil.o gtools.o \
+	    traces.o ${NAUTYO} ${LDFLAGS} -lm
+
+amtog : ${GTOOLSH} amtog.c gtools.o ${NAUTYO}
+	${CC} -o amtog ${CFLAGS} amtog.c gtools.o ${NAUTYO} ${LDFLAGS}
+
+genbg : ${GTOOLSH} genbg.c gtoolsW.o nautyW1.o nautilW1.o naugraphW1.o \
+	    schreierW.o naurng.o
+	${CC} -o genbg ${CFLAGS} ${W1} genbg.c gtoolsW.o schreierW.o \
+		nautyW1.o nautilW1.o naugraphW1.o naurng.o ${LDFLAGS}
+
+genbgL : ${GTOOLSH} genbg.c gtoolsL.o nautyL1.o nautilL1.o naugraphL1.o \
+	    schreierL.o naurng.o
+	${CC} -o genbgL ${CFLAGS} ${L1} -DMAXN1=30 genbg.c gtoolsL.o \
+	    schreierL.o naurng.o nautyL1.o nautilL1.o naugraphL1.o ${LDFLAGS}
+
+geng : ${GTOOLSH} geng.c gtoolsW.o nautyW1.o nautilW1.o naugraphW1.o schreier.o naurng.o
+	${CC} -o geng ${CFLAGS} ${W1} geng.c gtoolsW.o nautyW1.o \
+		nautilW1.o naugraphW1.o schreier.o naurng.o ${LDFLAGS}
+
+geng16 : ${GTOOLSH} geng.c gtoolsW.o nautyW1.o nautilW1.o naugraphW1.o schreier.o naurng.o
+	${CC} -o geng16 ${CFLAGS} -DMAXN=16 $W geng.c gtoolsW.o nautyW1.o \
+		nautilW1.o naugraphW1.o schreier.o naurng.o ${LDFLAGS}
+
+geng24 : ${GTOOLSH} geng.c gtoolsW.o nautyW1.o nautilW1.o naugraphW1.o schreier.o naurng.o
+	${CC} -o geng24 ${CFLAGS} -DMAXN=24 $W geng.c gtoolsW.o nautyW1.o \
+		nautilW1.o naugraphW1.o schreier.o naurng.o ${LDFLAGS}
+
+gentourng : ${GTOOLSH} gentourng.c gtoolsW.o nautyW1.o nautilW1.o \
+	    naugraphW1.o schreier.o naurng.o
+	${CC} -o gentourng ${CFLAGS} -DMAXN=24 $W gentourng.c gtoolsW.o nautyW1.o \
+		nautilW1.o naugraphW1.o schreier.o naurng.o ${LDFLAGS}
+
+genquarticg : ${GTOOLSH} genquarticg.c gtoolsL.o nautyL1.o nautilL1.o \
+	    naugraphL1.o schreierL.o naurng.o quarticirred28.h
+	${CC} -o genquarticg ${CFLAGS} genquarticg.c gtoolsL.o nautyL1.o \
+		nautilL1.o naugraphL1.o schreierL.o naurng.o ${LDFLAGS}
+
+gentreeg : gentreeg.c gtools.o nauty.h gtools.h
+	${CC} -o gentreeg ${CFLAGS} gentreeg.c gtools.o
+
+genrang : ${GTOOLSH} genrang.c gtools.o naututil.o ${NAUTYO}
+	${CC} -o genrang ${CFLAGS} genrang.c \
+		gtools.o naututil.o ${NAUTYO} ${LDFLAGS}
+
+complg : ${GTOOLSH} complg.c gtools.o gtnauty.o ${NAUTYO}
+	${CC} -o complg ${CFLAGS} complg.c gtools.o gtnauty.o \
+		${NAUTYO} ${LDFLAGS}
+
+cubhamg : ${GTOOLSH} cubhamg.c gtools.o ${NAUTYO}
+	${CC} -o cubhamg ${CFLAGS} cubhamg.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+twohamg : ${GTOOLSH} twohamg.c gtools.o ${NAUTYO}
+	${CC} -o twohamg ${CFLAGS} twohamg.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+hamheuristic : ${GTOOLSH} hamheuristic.c gtools.o ${NAUTYO}
+	${CC} -o hamheuristic ${CFLAGS} hamheuristic.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+converseg : ${GTOOLSH} converseg.c gtools.o ${NAUTYO}
+	${CC} -o converseg ${CFLAGS} converseg.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+linegraphg : ${GTOOLSH} linegraphg.c gtools.o ${NAUTYO}
+	${CC} -o linegraphg ${CFLAGS} linegraphg.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+subdivideg : ${GTOOLSH} subdivideg.c gtools.o ${NAUTYO}
+	${CC} -o subdivideg ${CFLAGS} subdivideg.c gtools.o \
+		${NAUTYO} ${LDFLAGS}
+
+vcolg : ${GTOOLSH} vcolg.c gtools.o ${NAUTYO} naugroup.o naugroup.h
+	${CC} -o vcolg ${CFLAGS} vcolg.c gtools.o naugroup.o \
+		${NAUTYO} ${LDFLAGS}
+
+biplabg : ${GTOOLSH} gutils.h biplabg.c gtools.o gutil1.o ${NAUTYO}
+	${CC} -o biplabg ${CFLAGS} biplabg.c \
+		gtools.o gutil1.o ${NAUTYO} ${LDFLAGS}
+
+ranlabg : ${GTOOLSH} ranlabg.c gtools.o ${NAUTYO}
+	${CC} -o ranlabg ${CFLAGS} ranlabg.c gtools.o ${NAUTYO} ${LDFLAGS}
+
+NRswitchg : ${GTOOLSH} NRswitchg.c gtools.o gtnauty.o ${NAUTYO}
+	${CC} -o NRswitchg ${CFLAGS} NRswitchg.c gtools.o gtnauty.o \
+		 ${NAUTYO} ${LDFLAGS}
+
+deledgeg : ${GTOOLSH} deledgeg.c gtools.o gtnauty.o ${NAUTYO}
+	${CC} -o deledgeg ${CFLAGS} deledgeg.c gtools.o gtnauty.o \
+		 ${NAUTYO} ${LDFLAGS}
+
+delptg : ${GTOOLSH} delptg.c gtools.o gtnauty.o ${NAUTYO}
+	${CC} -o delptg ${CFLAGS} delptg.c gtools.o gtnauty.o \
+		 ${NAUTYO} ${LDFLAGS}
+
+addedgeg : ${GTOOLSH} gutils.h addedgeg.c gtools.o gtnauty.o gutil1.o ${NAUTYO}
+	${CC} -o addedgeg ${CFLAGS} addedgeg.c gtools.o gtnauty.o \
+	        gutil1.o ${NAUTYO} ${LDFLAGS}
+
+newedgeg : ${GTOOLSH} gutils.h newedgeg.c gtools.o gtnauty.o ${NAUTYO}
+	${CC} -o newedgeg ${CFLAGS} newedgeg.c gtools.o gtnauty.o \
+		 ${NAUTYO} ${LDFLAGS}
+
+pickg : ${GTOOLSH} gutils.h testg.c splay.c ${NAUTYO} \
+	     gtools.o gtnauty.o gutil1.o gutil2.o nautinv.o 
+	${CC} -o pickg ${SAFECFLAGS} testg.c gtools.o gtnauty.o gutil1.o \
+	        gutil2.o nautinv.o ${NAUTYO} ${LDFLAGS}
+
+countg : ${GTOOLSH} gutils.h testg.c splay.c ${NAUTYO} \
+	     gtools.o gtnauty.o gutil1.o gutil2.o nautinv.o
+	${CC} -o countg ${SAFECFLAGS} testg.c gtools.o gtnauty.o gutil1.o \
+	         gutil2.o nautinv.o ${NAUTYO} ${LDFLAGS} 
+
+directg : ${GTOOLSH} naugroup.h directg.c  gtools.o naugroup.o ${NAUTYO}
+	${CC} -o directg ${CFLAGS} directg.c gtools.o \
+                ${NAUTYO} naugroup.o ${LDFLAGS}
+
+multig : ${GTOOLSH} naugroup.h multig.c gtools.o naugroup.o ${NAUTYO}
+	${CC} -o multig ${CFLAGS} multig.c gtools.o \
+                ${NAUTYO} naugroup.o ${LDFLAGS}
+
+planarg : ${GTOOLSH} planarg.c gtools.o planarity.c
+	${CC} -o planarg ${CFLAGS} \
+		planarg.c planarity.c gtools.o ${LDFLAGS}
+
+watercluster2 : ${GTOOLSH} nauty.h watercluster2.c gtools.o ${NAUTYO}
+	${CC} -o watercluster2 ${CFLAGS} -DMAXN=32 watercluster2.c \
+                 gtools.o ${NAUTYO} ${LDFLAGS}
+
+showg : showg.c
+	${CC} -o showg ${CFLAGS} showg.c ${LDFLAGS}
+
+readg : showg
+	echo "*** readg is now called showg ***"
+
+sumlines : sumlines.c
+	${CC} -o sumlines ${CFLAGS} sumlines.c ${LDFLAGS} -lgmp
+
+blisstog : ${GTOOLSH} blisstog.c gtools.o ${NAUTYO}
+	${CC} -o blisstog ${CFLAGS} blisstog.c gtools.o \
+                ${NAUTYO} ${LDFLAGS}
+
+bliss2dre : ${GTOOLSH} bliss2dre.c gtools.o ${NAUTYO}
+	${CC} -o bliss2dre ${CFLAGS} bliss2dre.c gtools.o \
+                ${NAUTYO} ${LDFLAGS}
+
+testlabelling : testlabelling.c nauty.h nauty.a
+	${CC} -o testlabelling -g testlabelling.c traces.c nauty.a ${LDFLAGS}
+
+naugroup.o : nauty.h naugroup.h naugroup.c
+	${CCOBJ} naugroup.c
+naugroupW.o : nauty.h naugroup.h naugroup.c
+	${CCOBJ} ${W} naugroup.c
+naugroupL.o : nauty.h naugroup.h naugroup.c
+	${CCOBJ} ${L} naugroup.c
+
+nautyex1 : nauty.h nautyex1.c nauty.a
+	${CC} -o nautyex1 ${CFLAGS} nautyex1.c nauty.a ${LDFLAGS}
+nautyex2 : nauty.h nautyex2.c ${NAUTYO}
+	${CC} -o nautyex2 ${CFLAGS} nautyex2.c nauty.a ${LDFLAGS}
+nautyex3 : nauty.h nautyex3.c nauty.a
+	${CC} -o nautyex3 ${CFLAGS} nautyex3.c nauty.a ${LDFLAGS}
+nautyex4 : nauty.h nausparse.h nautyex4.c nauty.a
+	${CC} -o nautyex4 ${CFLAGS} nautyex4.c nauty.a ${LDFLAGS}
+nautyex5 : nauty.h nausparse.h nautyex5.c nauty.a
+	${CC} -o nautyex5 ${CFLAGS} nautyex5.c nauty.a ${LDFLAGS}
+nautyex6 : nauty.h nautyex6.c nauty.a
+	${CC} -o nautyex6 ${CFLAGS} nautyex6.c nauty.a ${LDFLAGS}
+nautyex7 : nauty.h nautyex7.c traces.h nauty.a
+	${CC} -o nautyex7 ${CFLAGS} nautyex7.c nauty.a ${LDFLAGS}
+nautyex8 : nauty.h nausparse.h nautyex8.c nauty.a
+	${CC} -o nautyex8 ${CFLAGS} nautyex8.c nauty.a ${LDFLAGS}
+nautyex9 : nauty.h nautyex9.c nauty.a
+	${CC} -o nautyex9 ${CFLAGS} nautyex9.c nauty.a ${LDFLAGS}
+nautyex10 : nauty.h nautyex10.c nauty.a
+	${CC} -o nautyex10 ${CFLAGS} nautyex10.c nauty.a ${LDFLAGS}
+
+testprogs: ${TESTPROGS} ;
+
+checks: nauty gtools naucompare ${TESTPROGS}
+	./runalltests
+
+naucompare : naucompare.c
+	${CC} -o naucompare ${CFLAGS} naucompare.c ${LDFLAGS}
+
+dreadtest: dreadnaut.c nautinv.o ${NAUTYO} naututil.o traces.o gtools.o 
+	${CC} -o dreadtest ${SAFECFLAGS} -DDREADTEST dreadnaut.c \
+	    nautinv.o naututil.o traces.o gtools.o ${NAUTYO} ${LDFLAGS}
+dreadtest1: dreadnaut.c nautinv1.o ${NAUTY1O} naututil1.o traces.o gtools.o 
+	${CC} -o dreadtest1 ${SAFECFLAGS} ${SMALL} -DDREADTEST dreadnaut.c \
+	    nautinv1.o naututil1.o traces.o gtools.o ${NAUTY1O} ${LDFLAGS}
+dreadtestS: dreadnaut.c nautinvS.o ${NAUTYSO} naututilS.o tracesS.o gtoolsS.o 
+	${CC} -o dreadtestS ${SAFECFLAGS} ${S} -DDREADTEST dreadnaut.c \
+	    nautinvS.o naututilS.o tracesS.o gtoolsS.o ${NAUTYSO} ${LDFLAGS}
+dreadtestS1: dreadnaut.c nautinvS1.o ${NAUTYS1O} naututilS1.o \
+		tracesS.o gtoolsS.o 
+	${CC} -o dreadtestS1 ${SAFECFLAGS} ${S1} -DDREADTEST dreadnaut.c \
+	    nautinvS1.o naututilS1.o tracesS.o gtoolsS.o ${NAUTYS1O} ${LDFLAGS}
+dreadtestW: dreadnaut.c nautinvW.o ${NAUTYWO} naututilW.o tracesW.o gtoolsW.o 
+	${CC} -o dreadtestW ${SAFECFLAGS} ${W} -DDREADTEST dreadnaut.c \
+	    nautinvW.o naututilW.o tracesW.o gtoolsW.o ${NAUTYWO} ${LDFLAGS}
+dreadtestW1: dreadnaut.c nautinvW1.o ${NAUTYW1O} naututilW1.o \
+		tracesW.o gtoolsW.o 
+	${CC} -o dreadtestW1 ${SAFECFLAGS} ${W1} -DDREADTEST dreadnaut.c \
+	    nautinvW1.o naututilW1.o tracesW.o gtoolsW.o ${NAUTYW1O} ${LDFLAGS}
+dreadtestL: dreadnaut.c nautinvL.o ${NAUTYLO} naututilL.o tracesL.o gtoolsL.o 
+	${CC} -o dreadtestL ${SAFECFLAGS} ${L} -DDREADTEST dreadnaut.c \
+	    nautinvL.o naututilL.o tracesL.o gtoolsL.o ${NAUTYLO} ${LDFLAGS}
+dreadtestL1: dreadnaut.c nautinvL1.o ${NAUTYL1O} naututilL1.o \
+		tracesL.o gtoolsL.o 
+	${CC} -o dreadtestL1 ${SAFECFLAGS} ${L1} -DDREADTEST dreadnaut.c \
+	    nautinvL1.o naututilL1.o tracesL.o gtoolsL.o ${NAUTYL1O} ${LDFLAGS}
+dreadtest4K: dreadnaut.c nausparse.c schreier.c naututil.c nauty.c \
+	    nautil.c nautinv.c naugraph.c naurng.o gtools.c traces.c
+	${CC} -o dreadtest4K ${SAFECFLAGS} -DMAXN=4096 -DDREADTEST \
+	    dreadnaut.c naututil.c nauty.c nautil.c nautinv.c \
+	    naugraph.c nausparse.c naurng.o schreier.c gtools.c \
+	    traces.c ${LDFLAGS}
+
+checks6: checks6.c ${GTOOLSH} gtools.o
+	${CC} -o checks6 ${SAFECFLAGS} checks6.c gtools.o
+
+bigs: gtnauty.o gutil2.o nausparse.o nautil.o naututil.o gtools.o \
+	naugraph.o nautaux.o nautinv.o nauty.o schreier.o
+	rm -f gtnautyB.o gutil2B.o nausparseB.o nautilB.o naututilB.o \
+	  gtoolsB.o naugraphB.o nautauxB.o nautinvB.o nautyB.o
+	cp gtnauty.o gtnautyB.o
+	cp gutil2.o gutil2B.o
+	cp nausparse.o nausparseB.o
+	cp nautil.o nautilB.o
+	cp naututil.o naututilB.o
+	cp gtools.o gtoolsB.o
+	cp naugraph.o naugraphB.o
+	cp nautaux.o nautauxB.o
+	cp nautinv.o nautinvB.o
+	cp nauty.o nautyB.o
+	cp schreier.o schreierB.o
+
+# @edit_msg@
diff --git a/lib/nauty/multig.c b/lib/nauty/multig.c
new file mode 100644
index 0000000..3f8db95
--- /dev/null
+++ b/lib/nauty/multig.c
@@ -0,0 +1,857 @@
+/* multig.c version 1.7; B D McKay, May 17, 2014 */
+
+#define USAGE \
+"multig [-q] [-u|-T|-G|-A|-B] [-e#|-e#:#] \n" \
+"       [-m#] [-f#] [-D#|-r#|-l#] [infile [outfile]]"
+
+#define HELPTEXT \
+" Read undirected loop-free graphs and replace their edges with multiple\n\
+  edges in all possible ways (multiplicity at least 1).\n\
+  Isomorphic multigraphs derived from the same input are suppressed.\n\
+  If the input graphs are non-isomorphic then the output graphs are also.\n\
+\n\
+    -e# | -e#:#  specify a value or range of the total number of edges\n\
+                 counting multiplicities\n\
+    -m# maximum edge multiplicity (minimum is 1)\n\
+    -D# upper bound on maximum degree\n\
+    -r# make regular of specified degree (incompatible with -l, -D, -e)\n\
+    -l# make regular multigraphs with multiloops, degree #\n\
+                 (incompatible with -r, -D, -e)\n\
+    Either -l, -r, -D, -e or -m with a finite maximum must be given\n\
+    -f# Use the group that fixes the first # vertices setwise\n\
+    -T  use a simple text output format (nv ne {v1 v2 mult})\n\
+    -G  like -T but includes group size as third item (if less than 10^10)\n\
+          The group size does not include exchange of isolated vertices.\n\
+    -A  write as the upper triangle of an adjacency matrix, row by row,\n\
+        including the diagonal, and preceded by the number of vertices\n\
+    -B  write as an integer matrix preceded by the number of rows and\n\
+        number of columns, where -f determines the number of rows\n\
+    -u  no output, just count them\n\
+    -q  suppress auxiliary information\n"
+
+/*************************************************************************/
+
+#include "gtools.h"
+#include "naugroup.h"
+
+nauty_counter mg_nin,mg_nout,mg_skipped;
+FILE *outfile;
+
+#define MAXNV 128 
+#define MAXNE 1024
+static int v0[MAXNE+MAXNV],v1[MAXNE+MAXNV];
+static int edgeno[MAXNV][MAXNV];
+static int lastlev[MAXNE];
+
+static int ix[MAXNE+MAXNV],nix;
+static boolean first;
+static int lastreject[MAXNV];
+static boolean lastrejok;
+static unsigned long groupsize;
+static unsigned long newgroupsize;
+static boolean Gswitch,Tswitch,Aswitch,Bswitch;
+static int Brows;
+
+#define GROUPTEST_NOT 
+#ifdef GROUPTEST
+static long long totallab;
+#endif
+
+#define PATHCOUNTS_NOT
+#ifdef PATHCOUNTS
+static long long count0,count1,count2,count3,count4,count5;
+static nauty_counter oldlo;
+#endif
+
+/* INPUTGRAPH feature
+ *
+ * If INPUTGRAPH is defined, it must expand as the name of a procedure
+ * with prototype like  int INPUTGRAPH(graph *g, int m, int n).
+ * This procedure will be called for each input graph before it is
+ * processed. The graph will be skipped if the value 0 is returned.
+ */
+
+/* If OUTPROC is defined at compile time, and -u is not used, the
+ * procedure OUTPROC is called for each graph.  This must be linked
+ * by the compiler.  The arguments are
+ * f = open output file
+ * n = number of vertices
+ * ne = number of edges
+ * gp = group size ignoring isolated vertices (note: may have overflowed)
+ * v0[*], v1[*], ix[*] = integer arrays.  The edges are
+ * v0[i]-v1[i] with multiplicity ix[i] for i=0..ne-1.   ix[i]>0 always.
+ */
+
+/* SUMMARY feature
+ *
+ * If SUMMARY is defined, it must expand as the name of a procedure
+ * with prototype  void SUMMARY(void).  It is called at the end before
+ * the normal summary (which can be suppressed with -q).  The numbers of
+ * graphs read and multigraphs produced are available in the global variables
+ * mg_nin and mg_nout (type nauty_counter).
+ */
+
+#ifdef INPUTGRAPH
+extern int INPUTGRAPH(graph*,int,int);
+#endif
+
+#ifdef OUTPROC
+extern void OUTPROC(FILE*,int,int,unsigned long,int*,int*,int*);
+#endif
+
+#ifdef SUMMARY
+extern void SUMMARY(void);
+#endif
+
+/**************************************************************************/
+
+static void
+writeautom(int *p, int n)
+/* Called by allgroup. */
+{
+    int i;
+
+    for (i = 0; i < n; ++i) printf(" %2d",p[i]);
+    printf("\n");
+}
+
+/**************************************************************************/
+
+static boolean
+ismax(int *p, int n)
+/* test if x^p <= x */
+{
+    int i,k;
+
+    for (i = 0; i < nix; ++i)
+    {
+        k = edgeno[p[v1[i]]][p[v0[i]]];
+
+        if (ix[k] > ix[i]) return FALSE;
+        else if (ix[k] < ix[i]) return TRUE;
+    }
+
+    ++newgroupsize;
+    return TRUE;
+}
+
+/**************************************************************************/
+
+static void
+testmax(int *p, int n, int *abort)
+/* Called by allgroup2. */
+{
+    int i;
+
+    if (first)
+    {                       /* only the identity */
+        first = FALSE;
+        return;
+    }
+
+    if (!ismax(p,n))
+    {
+        *abort = 1;
+        for (i = 0; i < n; ++i) lastreject[i] = p[i];
+        lastrejok = TRUE;
+    }
+}
+
+/**************************************************************************/
+
+static void
+printam(FILE *f, int n, int ne, int *ix)
+/* Write adjacency matrix formats */
+{
+    int i,j;
+
+    if (Aswitch)
+    {
+        fprintf(f,"%d ",n);
+        for (i = 0; i < n; ++i)
+            for (j = i; j < n; ++j)
+                fprintf(f," %d",(edgeno[i][j]>=0 ? ix[edgeno[i][j]]: 0));
+        fprintf(f,"\n");
+    }
+    else
+    {
+        if (Brows <= 0 || Brows > n)
+        {
+            fprintf(stderr,">E multig: impossible matrix size for output\n");
+            exit(1);
+        }
+        fprintf(f,"%d %d",Brows,n-Brows);
+
+        for (i = 0; i < Brows; ++i)
+        {
+            fprintf(f," ");
+            for (j = Brows; j < n; ++j)
+                fprintf(f," %d",(edgeno[i][j]>=0 ? ix[edgeno[i][j]]: 0));
+        }
+        fprintf(f,"\n");
+    }
+}
+
+/**************************************************************************/
+
+static void
+trythisone(grouprec *group,
+       boolean lswitch, int *deg, int maxdeg, int ne, int n)
+/* Try one solution, accept if minimal. */
+{
+    int i,ne2;
+    boolean accept;
+
+    nix = ne;
+    newgroupsize = 1;
+
+    if (!group || groupsize == 1)
+        accept = TRUE;
+    else if (lastrejok && !ismax(lastreject,n))
+        accept = FALSE;
+    else if (lastrejok && groupsize == 2)
+        accept = TRUE;
+    else
+    {
+        newgroupsize = 1;
+        first = TRUE;
+
+        if (allgroup2(group,testmax) == 0)
+            accept = TRUE;
+        else
+            accept = FALSE;
+    }
+
+    if (accept)
+    {
+#ifdef GROUPTEST
+        if (groupsize % newgroupsize != 0)
+                    gt_abort("group size error\n");
+        totallab += groupsize/newgroupsize;
+#endif
+
+        ++mg_nout;
+
+        if (outfile)
+        {
+            ne2 = ne;
+            if (lswitch)
+                for (i = 0; i < n; ++i)
+                    if (deg[i] < maxdeg)
+                    {
+                        v0[ne2] = v1[ne2] = i;
+                        ix[ne2] = (maxdeg-deg[i])/2;
+                        ++ne2;
+                    }
+#ifdef OUTPROC
+            OUTPROC(outfile,n,ne2,newgroupsize,v0,v1,ix);
+#else
+            if (Aswitch || Bswitch)
+                printam(outfile,n,ne2,ix);
+            else
+            {
+                fprintf(outfile,"%d %d",n,ne2);
+                if (Gswitch) fprintf(outfile," %lu",newgroupsize);
+    
+                for (i = 0; i < ne2; ++i)
+                    fprintf(outfile," %d %d %d",v0[i],v1[i],ix[i]);
+                fprintf(outfile,"\n");
+            }
+#endif
+        }
+        return;
+    }
+    else
+        return;
+}
+
+/**************************************************************************/
+
+static void
+scan(int level, int ne, long minedges, long maxedges, long sofar,
+    long maxmult, grouprec *group, int n)
+/* Recursive scan for default case */
+{
+    int left;
+    long min,max,k;
+
+    if (level == ne)
+    {
+        trythisone(group,FALSE,NULL,0,ne,n);
+        return;
+    }
+
+    left = ne - level - 1;
+    min = minedges - sofar - maxmult*left;
+    if (min < 1) min = 1;
+        max = maxedges - sofar - left;
+    if (max > maxmult) max = maxmult;
+
+    for (k = min; k <= max; ++k)
+    {
+        ix[level] = k;
+        scan(level+1,ne,minedges,maxedges,sofar+k,maxmult,group,n);
+    }
+
+    return;
+}
+
+/**************************************************************************/
+
+static void
+scan_md(int level, int ne, long minedges, long maxedges, long sofar,
+    long maxmult, grouprec *group, int n, int *deg, int maxdeg)
+/* Recursive scan, maxdeg version */
+{
+    int left;
+    int min,max,k;
+    int x1,x2;
+
+    if (level == ne)
+    {
+        trythisone(group,FALSE,deg,maxdeg,ne,n);
+        return;
+    }
+
+    x1 = v0[level];
+    x2 = v1[level];
+    left = ne - level - 1;
+    min = minedges - sofar - maxmult*left;
+    if (min < 1) min = 1;
+    max = maxedges - sofar - left;
+    if (max > maxmult) max = maxmult;
+    if (deg[x1] + max - 1 > maxdeg) max = maxdeg - deg[x1] + 1;
+    if (deg[x2] + max - 1 > maxdeg) max = maxdeg - deg[x2] + 1;
+
+    for (k = min; k <= max; ++k)
+    {
+        ix[level] = k;
+        deg[x1] += k-1; deg[x2] += k-1;
+        scan_md(level+1,ne,minedges,maxedges,sofar+k,maxmult,group,
+                n,deg,maxdeg);
+        deg[x1] -= k-1; deg[x2] -= k-1;
+    }
+
+    return;
+}
+
+/**************************************************************************/
+
+static void
+scan_lp(int level, int ne, long minedges, long maxedges, long sofar,
+    long maxmult, grouprec *group, int n, int *deg, int maxdeg)
+/* Recursive scan, regular-with-loops version. */
+{
+    int left;
+    long min,max,k;
+    int x1,x2;
+    boolean odd,even;
+
+    if (level == ne)
+    {
+        trythisone(group,TRUE,deg,maxdeg,ne,n);
+        return;
+    }
+
+    x1 = v0[level];
+    x2 = v1[level];
+    left = ne - level - 1;
+    min = minedges - sofar - maxmult*left;
+    if (min < 1) min = 1;
+    max = maxedges - sofar - left;
+    if (max > maxmult) max = maxmult;
+    if (deg[x1] + max - 1 > maxdeg) max = maxdeg - deg[x1] + 1;
+    if (deg[x2] + max - 1 > maxdeg) max = maxdeg - deg[x2] + 1;
+
+    odd = even = FALSE;
+    if (lastlev[x1] == level)
+    {
+        if (((maxdeg-deg[x1])&1) == 1) even = TRUE; else odd = TRUE;
+    }
+    if (lastlev[x2] == level)
+    {
+        if (((maxdeg-deg[x2])&1) == 1) even = TRUE; else odd = TRUE;
+    }
+    if (even && odd) return;
+
+    for (k = min; k <= max; ++k)
+    {
+        if (even && (k&1) == 1) continue;
+        if (odd && (k&1) == 0) continue;
+
+        ix[level] = k;
+        deg[x1] += k-1; deg[x2] += k-1;
+        scan_lp(level+1,ne,minedges,maxedges,sofar+k,maxmult,group,
+                n,deg,maxdeg);
+        deg[x1] -= k-1; deg[x2] -= k-1;
+    }
+
+    return;
+}
+
+/**************************************************************************/
+
+static void
+scan_reg(int level, int ne, long minedges, long maxedges, long sofar,
+    long maxmult, grouprec *group, int n, int *delta, int *def, int maxdeg)
+/* Recursive scan, regular version. */
+{
+    int left;
+    long min,max,k;
+    int x1,x2;
+
+    if (level == ne)
+    {
+        trythisone(group,FALSE,NULL,maxdeg,ne,n);
+        return;
+    }
+
+    x1 = v0[level];
+    x2 = v1[level];
+    left = ne - level - 1;
+    min = minedges - sofar - maxmult*left;
+    if (min < 1) min = 1;
+    max = maxedges - sofar - left;
+    if (max > maxmult) max = maxmult;
+    if (max > def[x1] + 1) max = def[x1] + 1;
+    if (max > def[x2] + 1) max = def[x2] + 1;
+
+    if (min < def[x2] + 1 - delta[x1]) min = def[x2] + 1 - delta[x1];
+    if (min < def[x1] + 1 - delta[x2]) min = def[x1] + 1 - delta[x2];
+
+    if (lastlev[x1] == level && min < def[x1] + 1) min = def[x1] + 1;
+    if (lastlev[x2] == level && min < def[x2] + 1) min = def[x2] + 1;
+
+    for (k = min; k <= max; ++k)
+    {
+        ix[level] = k;
+        delta[x1] += k-1 - def[x2];
+        delta[x2] += k-1 - def[x1];
+        def[x1] -= k-1;
+        def[x2] -= k-1;
+        scan_reg(level+1,ne,minedges,maxedges,sofar+k,maxmult,group,
+                n,delta,def,maxdeg);
+        def[x1] += k-1;
+        def[x2] += k-1;
+        delta[x1] -= k-1 - def[x2];
+        delta[x2] -= k-1 - def[x1];
+    }
+
+    return;
+}
+
+/**************************************************************************/
+
+static void
+multi(graph *g, int nfixed, long minedges, long maxedges, long maxmult,
+      int maxdeg, boolean lswitch, int m, int n)
+{
+    static DEFAULTOPTIONS_GRAPH(options);
+    statsblk stats;
+    setword workspace[100];
+    grouprec *group;
+    int ne;
+    int i,j,k,j0,j1,thisdeg,maxd,x0,x1;
+    set *gi;
+    int lab[MAXNV],ptn[MAXNV],orbits[MAXNV],deg[MAXNV];
+    int delta[MAXNV],def[MAXNV];
+    set active[(MAXNV+WORDSIZE-1)/WORDSIZE];
+    boolean isreg;
+
+#ifdef PATHCOUNTS
+    ++count0;
+#endif
+
+    j0 = -1;  /* last vertex with degree 0 */
+    j1 = n;   /* first vertex with degree > 0 */
+ 
+    ne = 0;
+    maxd = 0;
+    for (i = 0, gi = g; i < n; ++i, gi += m)
+    {
+        thisdeg = 0;
+        for (j = 0; j < m; ++j) thisdeg += POPCOUNT(gi[j]);
+        deg[i] = thisdeg;
+        if (thisdeg > maxd) maxd = thisdeg;
+        if (thisdeg == 0) lab[++j0] = i;
+        else              lab[--j1] = i;
+        ne += thisdeg;
+    }
+    ne /= 2;
+
+    if (maxdeg >= 0 && maxd > maxdeg) return;
+
+#ifdef PATHCOUNTS
+    ++count1;
+#endif
+
+    if (Aswitch || Bswitch)
+        for (i = 0; i < n; ++i)
+        for (j = 0; j < n; ++j)
+            edgeno[i][j] = -1;
+
+    if (ne == 0 && minedges <= 0
+                && (!lswitch || (lswitch && (maxdeg&1) == 0)))
+    {
+        trythisone(NULL,lswitch,deg,maxdeg,0,n);
+        return;
+    }
+
+#ifdef PATHCOUNTS
+    ++count2;
+#endif
+
+    k = 0;
+    for (i = 0, gi = g; i < n; ++i, gi += m)
+    {
+        for (j = i; (j = nextelement(gi,m,j)) >= 0; )
+        {
+            v0[k] = i;
+            v1[k] = j;
+            edgeno[i][j] = edgeno[j][i] = k;
+            lastlev[i] = lastlev[j] = k;
+            ++k;
+        }
+    }
+
+    isreg = !lswitch && (maxdeg >= 0 && 2*minedges == n*(long)maxdeg);
+        /* Case of regular multigraphs */
+
+    if (isreg)  /* regular case */
+    /* Condition: def(v) <= total def of neighbours */
+    {
+        for (i = 0; i < n; ++i)
+        {
+            def[i] = maxdeg - deg[i];
+            delta[i] = -def[i];
+        }
+
+        for (i = 0; i < k; ++i)
+        {
+            x0 = v0[i]; x1 = v1[i];
+            delta[x0] += def[x1];
+            delta[x1] += def[x0];
+        }
+
+        for (i = 0; i < n; ++i) if (delta[i] < 0) return;
+    }
+
+    if ((isreg || lswitch) && (maxdeg & n & 1) == 1) return;
+    if (isreg && j0 >= 0 && maxdeg > 0) return;
+    if (lswitch && j0 >= 0 && (maxdeg&1) == 1) return;
+
+#ifdef PATHCOUNTS
+    ++count3;
+#endif
+
+    if (maxedges == NOLIMIT)
+    {
+	if (maxmult == NOLIMIT) maxedges = maxdeg*n/2;
+	else                    maxedges = ne*maxmult;
+    }
+    if (maxmult == NOLIMIT) maxmult = maxedges - ne + 1;
+    if (maxdeg >= 0 && maxmult > maxdeg) maxmult = maxdeg;
+    if (maxedges < ne || ne*maxmult < minedges) return;
+
+#ifdef PATHCOUNTS
+    ++count4;
+#endif
+
+    if (n > MAXNV || ne > MAXNE)
+    {
+        fprintf(stderr,">E multig: MAXNV or MAXNE exceeded\n");
+        exit(1);
+    }
+
+    nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
+
+    for (i = 0; i < n; ++i) ptn[i] = 1;
+    ptn[n-1] = 0;
+    EMPTYSET(active,m);
+    if (j0 != n-1) ADDELEMENT(active,j0+1);
+
+    for (i = 0; i <= j0; ++i) ptn[i] = 0;
+
+    for (i = j0+1; i < n; ++i)
+    if (lab[i] < nfixed) break;
+
+    if (i != j0+1 && i != n)
+    {
+        ptn[i-1] = 0;
+        ADDELEMENT(active,i);
+    }
+
+    options.defaultptn = FALSE;
+    options.userautomproc = groupautomproc;
+    options.userlevelproc = grouplevelproc;
+
+    nauty(g,lab,ptn,active,orbits,&options,&stats,workspace,100,m,n,NULL);
+
+    if (stats.grpsize2 == 0)
+        groupsize = stats.grpsize1 + 0.1;
+    else
+        groupsize = 0;
+
+    group = groupptr(FALSE);
+    makecosetreps(group);
+
+    lastrejok = FALSE;
+
+    if (isreg)
+        scan_reg(0,ne,minedges,maxedges,0,maxmult,group,n,delta,def,maxdeg);
+    else if (lswitch)
+        scan_lp(0,ne,minedges,maxedges,0,maxmult,group,n,deg,maxdeg);
+    else if (maxdeg >= 0)
+        scan_md(0,ne,minedges,maxedges,0,maxmult,group,n,deg,maxdeg);
+    else
+        scan(0,ne,minedges,maxedges,0,maxmult,group,n);
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    graph *g;
+    int m,n,codetype;
+    int argnum,j,nfixed,maxdeg,regdeg,ldeg;
+    char *arg,sw;
+    boolean badargs;
+    boolean fswitch,uswitch,eswitch,qswitch,mswitch,Dswitch;
+    boolean lswitch,rswitch;
+    long minedges,maxedges,maxmult;
+    double t;
+    char *infilename,*outfilename;
+    FILE *infile;
+    char msg[201];
+    int msglen;
+
+    HELP; PUTVERSION;
+
+    nauty_check(WORDSIZE,1,1,NAUTYVERSIONID);
+
+    rswitch = fswitch = Tswitch = Gswitch = FALSE;
+    uswitch = eswitch = mswitch = qswitch = FALSE;
+    lswitch = Aswitch = Bswitch = Dswitch = FALSE;
+    infilename = outfilename = NULL;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWLONG('m',mswitch,maxmult,"multig -m")
+                else SWBOOLEAN('q',qswitch)
+                else SWBOOLEAN('u',uswitch)
+                else SWBOOLEAN('T',Tswitch)
+                else SWBOOLEAN('G',Gswitch)
+                else SWBOOLEAN('A',Aswitch)
+                else SWBOOLEAN('B',Bswitch)
+                else SWINT('f',fswitch,nfixed,"multig -f")
+                else SWINT('D',Dswitch,maxdeg,"multig -D")
+                else SWINT('r',rswitch,regdeg,"multig -r")
+                else SWINT('l',lswitch,ldeg,"multig -l")
+                else SWRANGE('e',":-",eswitch,minedges,maxedges,"multig -e")
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if (badargs || argnum > 2)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if ((Gswitch!=0) + (Tswitch!=0) + (uswitch!=0)
+          + (Aswitch!=0) + (Bswitch!=0) >= 2)
+        gt_abort(">E multig: -G, -T, -A, -B and -u are incompatible\n");
+
+#ifndef OUTPROC
+    if (!Tswitch && !Gswitch && !Aswitch && !Bswitch && !uswitch)
+        gt_abort(">E multig: must use -A, -B, -T, -G or -u\n");
+#endif
+
+    if (rswitch && (Dswitch || eswitch))
+        gt_abort(">E multig: -r is incompatible with -D and -e\n");
+
+    if (lswitch && (rswitch || Dswitch || eswitch))
+        gt_abort(">E multig: -l is incompatible with -r, -D and -e\n");
+
+    if (!eswitch)
+    {
+        minedges = 0;
+        maxedges = NOLIMIT;
+    }
+    if (!mswitch) maxmult = NOLIMIT;
+    if (!fswitch) nfixed = 0;
+
+    if (Bswitch && nfixed == 0)
+        gt_abort(">E multig: -B requires -f# with #>0\n");
+    if (fswitch) Brows = nfixed;
+
+    if (maxedges >= NOLIMIT && maxmult >= NOLIMIT
+                  && !Dswitch && !rswitch && !lswitch)
+        gt_abort(
+      ">E multig: either -D or -e or -m or -r must impose a real limit\n");
+
+    if (!qswitch)
+    {
+        msg[0] = '\0';
+        CATMSG0(">A multig");
+        if (eswitch || mswitch || uswitch || (fswitch && nfixed > 0)
+              || lswitch || rswitch || Dswitch || Tswitch
+              || Gswitch || Aswitch || Bswitch)
+            CATMSG0(" -");
+        if (mswitch) CATMSG1("m%ld",maxmult);
+        if (uswitch) CATMSG0("u");
+        if (Tswitch) CATMSG0("T");
+        if (Gswitch) CATMSG0("G");
+        if (Aswitch) CATMSG0("A");
+        if (Bswitch) CATMSG0("B");
+        if (fswitch) CATMSG1("f%d",nfixed);
+        if (eswitch) CATMSG2("e%ld:%ld",minedges,maxedges);
+        if (Dswitch) CATMSG1("D%d",maxdeg);
+        if (rswitch) CATMSG1("r%d",regdeg);
+        if (lswitch) CATMSG1("l%d",ldeg);
+        msglen = strlen(msg);
+        if (argnum > 0) msglen += strlen(infilename);
+        if (argnum > 1) msglen += strlen(outfilename);
+        if (msglen >= 196)
+        {
+            fputs(msg,stderr);
+            if (argnum > 0) fprintf(stderr," %s",infilename);
+            if (argnum > 1) fprintf(stderr," %s",outfilename);
+            fprintf(stderr,"\n");
+        }
+        else
+        {
+            if (argnum > 0) CATMSG1(" %s",infilename);
+            if (argnum > 1) CATMSG1(" %s",outfilename);
+            CATMSG0("\n");
+            fputs(msg,stderr);
+        }
+        fflush(stderr);
+    }
+
+    if (rswitch)
+    {
+        eswitch = Dswitch = TRUE;
+        maxdeg = regdeg;
+    }
+
+    if (lswitch)
+    {
+        eswitch = Dswitch = TRUE;
+        maxdeg = ldeg;
+    }
+
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,FALSE,1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    NODIGRAPHSYET(codetype);
+
+    if (uswitch)
+        outfile = NULL;
+    else
+    {
+        if (!outfilename || outfilename[0] == '-')
+        {
+            outfilename = "stdout";
+            outfile = stdout;
+        }
+        else if ((outfile = fopen(outfilename,"w")) == NULL)
+        {
+            fprintf(stderr,"Can't open output file %s\n",outfilename);
+            gt_abort(NULL);
+        }
+    }
+
+    mg_nin = mg_nout = mg_skipped = 0;
+
+    t = CPUTIME;
+    while (TRUE)
+    {
+        if ((g = readg(infile,NULL,0,&m,&n)) == NULL) break;
+        ++mg_nin;
+#ifdef PATHCOUNTS
+        oldlo = mg_nout;
+#endif
+#ifdef INPUTGRAPH
+        if (!INPUTGRAPH(g,m,n))
+        {
+           ++mg_skipped;
+           FREES(g);
+           continue;
+        }
+#endif
+ 
+        if (rswitch)
+        {
+            minedges = ((long)n * (long)regdeg + 1) / 2;
+            maxedges = ((long)n * (long)regdeg) / 2;
+        }
+        if (lswitch)
+        {
+            maxedges = ((long)n * (long)ldeg) / 2;
+            if ((ldeg & 1) == 1) minedges = (n + 1) / 2;
+            else                 minedges = 0;
+        }
+
+        multi(g,nfixed,minedges,maxedges,maxmult,
+              (Dswitch?maxdeg:-1),lswitch,m,n);
+#ifdef PATHCOUNTS
+        if (mg_nout != oldlo) ++count5;
+#endif
+	if (!uswitch && ferror(outfile))
+	    gt_abort(">E multig output error\n");
+        FREES(g);
+    }
+    t = CPUTIME - t;
+
+#ifdef SUMMARY
+    SUMMARY();
+#endif
+
+    if (!qswitch)
+    {
+        fprintf(stderr,">Z " COUNTER_FMT " graphs read from %s; ",
+	 	       mg_nin,infilename);
+#ifdef INPUTGRAPH
+        fprintf(stderr,COUNTER_FMT " skipped; ",mg_skipped);
+#endif
+        PRINT_COUNTER(stderr,mg_nout);
+        if (!uswitch)
+            fprintf(stderr," multigraphs written to %s",outfilename);
+        else
+            fprintf(stderr," multigraphs generated");
+        fprintf(stderr,"; %.2f sec\n",t);
+    }
+
+#ifdef GROUPTEST
+    fprintf(stderr,"Group test = %lld\n",totallab);
+#endif
+
+#ifdef PATHCOUNTS
+    fprintf(stderr,"Counts: %lld %lld %lld %lld %lld %lld\n",
+            count0,count1,count2,count3,count4,count5);
+#endif
+
+    exit(0);
+}
diff --git a/lib/nauty/naucompare.c b/lib/nauty/naucompare.c
new file mode 100644
index 0000000..56333ed
--- /dev/null
+++ b/lib/nauty/naucompare.c
@@ -0,0 +1,270 @@
+/* naucompare - quick and dirty text file comparitor to compare
+ * two program outputs.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#define MAXLINELEN 100000
+#define MAXDIFFS 5
+
+static char line1[MAXLINELEN+1];
+static char line2[MAXLINELEN+1];
+static char line1mod[MAXLINELEN+100];
+static char line2mod[MAXLINELEN+100];
+
+/* special[] contains formats for lines that might not compare exactly.
+ * See scanline() for the meaning of the format characters.
+ * These strings should have \n at the end.
+ */
+
+static char* special[] =   /* Make sure to use \n */
+{
+    "Dreadnaut version %*f (%*d bits).\n",
+    "cpu time = %*f seconds\n",
+    "canupdates=%d; cpu time = %*f seconds\n",
+    "Mode=%s m=%*d n=%d labelorg=%d edges=%d options=(%s))\n",
+    "group time: %*f, %*f, %*f, group order time: %*f;%\n",
+    ">Z %d graphs generated in %*f sec\n",
+    ">Z %d graphs labelled from %s to %s in %*f sec.\n",
+    "%d graphs altogether; cpu=%*f sec\n",
+    "group time: %*f,%*f,%*f, order:%*f total:%*f "
+       "(Schreier fails: %d); exp_paths time:%*f; aut_check time:%*f\n",
+    "%d cell; code = %d; cpu time = %*f seconds\n",
+    "%d cells; code = %d; cpu time = %*f seconds\n",
+    ">Z %d graphs read from stdin; %d coloured graphs written to stdout; %*f sec\n",
+    ">Z %d graphs read from stdin; %d written to stdout; %*f sec\n",
+    "%d graphs altogether from %d read; cpu=%*f sec\n",
+    ">A %*s %s\n"
+};
+#define NUMSPECIALS (sizeof(special)/sizeof(*special))
+
+/***********************************************************************/
+
+static int
+scanline(char *in, char *fmt, char *out)
+/* Compare input string against format and return 1 if it matches or
+ * 0 if it doesn't match.  In the case of matching, construct an output
+ * string with volatile fields replaced by "*" and some standardisation
+ * of the non-volatile fields.  Format specifiers are:
+ 
+   %d  - matches an integer (maybe with sign)
+   %f  - matches a real number of the form ddd.ddd (maybe with sign)
+   %sx - matches a string, where 'x' is any character. 
+         If 'x' is not a space, match zero or more characters from the
+             current position up but not including the first 'x'.
+         If 'x' is a space, match one or more characters from the current
+             position up to and including the first non-space character
+             which is followed by a space.
+   %c  - matches a non-white character
+   %%  - matches the character '%'
+   %   - (with a space following the '%') matches zero or more spaces or
+            tabs, as many as appear in the input.  In the output, this
+            sequence appears as one space.
+   %   - (appearing exactly at the end of the format) matches zero or
+         more spaces at the end of the line.  In the output, nothing.
+   %*d, %*f, %*sx, %*c - these are similar to the versions
+         without the '*' except that the fields are volatile.
+ * The entire line must match.  */
+{
+    int doass,dots;
+    char ends,*outf,*s,*f;
+
+    outf = out;
+    s = in;
+    f = fmt;
+
+    while (*f != '\0')
+    {
+        if (*f == '%')
+        {
+            ++f;
+            if (*f == '*')
+            {
+                doass = 0;
+                ++f;
+            }
+            else
+                doass = 1;
+
+            if (*f == '%')
+            {
+                if (*s++ != '%') return 0;
+                ++f;
+                *outf++ = '%';
+            }
+            else if (*f == '\n')
+            {
+                while (*s != '\0')
+                {
+                    if (*s != ' ' && *s != '\n') return 0;
+                    ++s;
+                }
+                --s;
+            }
+            else if (*f == 'c')
+            {
+                if (*s == ' ' || *s == '\t' || *s == '\n') return 0;
+                if (doass) *outf++ = *s;
+                else       *outf++ = '*';
+                ++f;
+                ++s;
+            }
+            else if (*f == 's')
+            {
+                ends = *(f+1);
+                if (ends == ' ')
+                {
+		    dots = 0;
+                    while (*s == ' ' || *s == '\t')
+		    {
+			if (doass && dots == 0) *outf++ = ' ';
+                        ++s;
+			++dots;
+                    }
+                }
+                while (*s != '\n' && *s != ends)
+                {
+                    if (doass) *outf++ = *s;
+                    ++s;
+                }
+                if (!doass) *outf++ = '*';
+                ++f;
+            }
+            else if (*f == 'd')
+            {
+                while (*s == ' ' || *s == '\t') ++s;
+                if (!isdigit(*s) && *s != '-' && *s != '+') return 0;
+                if (*s == '-' || *s == '+')
+		{
+		    if (doass) *outf++ = *s;
+		    ++s;
+		}
+                while (isdigit(*s))
+                {
+                    if (doass) *outf++ = *s;
+		    ++s;
+                }
+                if (!doass) *outf++ = '*';
+                ++f;
+            }
+            else if (*f == 'f')
+            {
+                while (*s == ' ' || *s == '\t') ++s;
+                if (!isdigit(*s) && *s != '.' && *s != '-' && *s != '+')
+                    return 0;
+                if (*s == '-' || *s == '+')
+		{
+		    if (doass) *outf++ = *s;
+		    ++s;
+		}
+		dots = 0;
+                while (isdigit(*s) || (dots == 0 && *s == '.'))
+                {
+		    if (*s == '.') ++dots;
+                    if (doass) *outf++ = *s;
+		    ++s;
+                }
+                if (!doass) *outf++ = '*';
+                ++f;
+            }
+            else if (*f == ' ')
+            {
+                while (*s == ' ' || *s == '\t') ++s;
+                *outf++ = ' ';
+                ++f;
+            }
+            else
+            {
+                fprintf(stderr,"Bad format item %%%c\n",*f);
+                exit(1);
+            }
+        }
+        else
+        {
+            if (*s != *f) return 0;
+            *outf++ = *f;
+            ++s;
+            ++f;
+        }
+    }
+
+    if (*s != '\0') return 0;
+
+    *outf = '\0';
+
+    return 1;
+}
+
+/***********************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    int i,diffs,lineno;
+    char *l1,*l2;
+    FILE *f1,*f2;
+
+    if (argc != 3)
+    {
+	fprintf(stderr,"Usage: naucompare file1 file2\n");
+	exit(0);
+    }
+
+    if (strcmp(argv[1],"-") == 0)
+	f1 = stdin;
+    else if ((f1 = fopen(argv[1],"r")) == NULL)
+    {
+	fprintf(stderr,">E naucompare can't open file 1\n");
+	exit(1);
+    }
+
+    if (strcmp(argv[2],"-") == 0)
+	f2 = stdin;
+    else if ((f2 = fopen(argv[2],"r")) == NULL)
+    {
+	fprintf(stderr,">E naucompare can't open file 2\n");
+	exit(1);
+    }
+
+    diffs = lineno = 0;
+
+    for (;;)
+    {
+	l1 = fgets(line1,MAXLINELEN,f1);
+	l2 = fgets(line2,MAXLINELEN,f2);
+
+	if (l1 == NULL || l2 == NULL) break;
+
+	++lineno;
+	if (strcmp(l1,l2) != 0)
+	{
+	    for (i = 0; i < NUMSPECIALS; ++i)
+		if (scanline(l1,special[i],line1mod)
+		              && scanline(l2,special[i],line2mod)
+                              && strcmp(line1mod,line2mod) == 0)
+		    break;
+	    if (i == NUMSPECIALS)
+	    {
+	        if (diffs >= MAXDIFFS)
+		{
+		    printf("----And more differences not reported.\n");
+		    break;
+		}
+		printf("----Difference on line %d:\n",lineno);
+	        printf("%s%s",l1,l2);
+	        ++diffs;
+	    }
+	}
+    }
+
+    if (l1 != NULL || l2 != NULL) ++diffs;
+    if (l1 != NULL && l2 == NULL) printf("File 1 is longer\n");
+    if (l1 == NULL && l2 != NULL) printf("File 2 is longer\n");
+
+    if (diffs == 0) printf("OK\n");
+
+    exit(diffs != 0);
+}
diff --git a/lib/nauty/naugraph.c b/lib/nauty/naugraph.c
new file mode 100644
index 0000000..8f81e7c
--- /dev/null
+++ b/lib/nauty/naugraph.c
@@ -0,0 +1,712 @@
+/*****************************************************************************
+*                                                                            *
+*  Graph-specific auxiliary source file for version 2.6 of nauty.            *
+*                                                                            *
+*   Copyright (1984-2016) Brendan McKay.  All rights reserved.               *
+*   Subject to waivers and disclaimers in nauty.h.                           *
+*                                                                            *
+*   CHANGE HISTORY                                                           *
+*       16-Nov-00 : initial creation out of nautil.c                         *
+*       22-Apr-01 : added aproto line for Magma                              *
+*                   EXTDEFS is no longer required                            *
+*                   removed dynamic allocation from refine1()                *
+*       21-Nov-01 : use NAUTYREQUIRED in naugraph_check()                    *
+*       23-Nov-06 : add targetcell(); make bestcell() local                  *
+*       10-Dec-06 : remove BIGNAUTY                                          *
+*       10-Nov-09 : remove shortish and permutation types                    *
+*       23-May-10 : add densenauty()                                         *
+*       15-Jan-12 : add TLS_ATTR attributes                                  *
+*       23-Jan-13 : add some parens to make icc happy                        *
+*                                                                            *
+*****************************************************************************/
+
+#define ONE_WORD_SETS
+#include "nauty.h"
+
+    /* macros for hash-codes: */
+#define MASH(l,i) ((((l) ^ 065435) + (i)) & 077777)
+    /* : expression whose long value depends only on long l and int/long i.
+     Anything goes, preferably non-commutative. */
+
+#define CLEANUP(l) ((int)((l) % 077777))
+    /* : expression whose value depends on long l and is less than 077777
+     when converted to int then short.  Anything goes. */
+
+#if  MAXM==1
+#define M 1
+#else
+#define M m
+#endif
+
+/* aproto: header new_nauty_protos.h */
+
+dispatchvec dispatch_graph =
+  {isautom,testcanlab,updatecan,refine,refine1,cheapautom,targetcell,
+   naugraph_freedyn,naugraph_check,NULL,NULL};
+
+#if !MAXN
+DYNALLSTAT(set,workset,workset_sz);
+DYNALLSTAT(int,workperm,workperm_sz);
+DYNALLSTAT(int,bucket,bucket_sz);
+DYNALLSTAT(set,dnwork,dnwork_sz);
+#else
+static TLS_ATTR set workset[MAXM];   /* used for scratch work */
+static TLS_ATTR int workperm[MAXN];
+static TLS_ATTR int bucket[MAXN+2];
+static TLS_ATTR set dnwork[40*MAXM];
+#endif
+
+/*****************************************************************************
+*                                                                            *
+*  isautom(g,perm,digraph,m,n) = TRUE iff perm is an automorphism of g       *
+*  (i.e., g^perm = g).  Symmetry is assumed unless digraph = TRUE.           *
+*                                                                            *
+*****************************************************************************/
+
+boolean
+isautom(graph *g, int *perm, boolean digraph, int m, int n)
+{
+    set *pg;
+    int pos;
+    set *pgp;
+    int posp,i;
+
+    for (pg = g, i = 0; i < n; pg += M, ++i)
+    {
+        pgp = GRAPHROW(g,perm[i],M);
+        pos = (digraph ? -1 : i);
+
+        while ((pos = nextelement(pg,M,pos)) >= 0)
+        {
+            posp = perm[pos];
+            if (!ISELEMENT(pgp,posp)) return FALSE;
+        }
+    }
+    return TRUE;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  testcanlab(g,canong,lab,samerows,m,n) compares g^lab to canong,           *
+*  using an ordering which is immaterial since it's only used here.  The     *
+*  value returned is -1,0,1 if g^lab <,=,> canong.  *samerows is set to      *
+*  the number of rows (0..n) of canong which are the same as those of g^lab. *
+*                                                                            *
+*  GLOBALS ACCESSED: workset<rw>,permset(),workperm<rw>                      *
+*                                                                            *
+*****************************************************************************/
+
+int
+testcanlab(graph *g, graph *canong, int *lab, int *samerows, int m, int n)
+{
+    int i,j;
+    set *ph;
+
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n,"testcanlab");
+    DYNALLOC1(set,workset,workset_sz,m,"testcanlab");
+#endif
+
+    for (i = 0; i < n; ++i) workperm[lab[i]] = i;
+
+    for (i = 0, ph = canong; i < n; ++i, ph += M)
+    {
+        permset(GRAPHROW(g,lab[i],M),workset,M,workperm);
+        for (j = 0; j < M; ++j)
+            if (workset[j] < ph[j])
+            {
+                *samerows = i;
+                return -1;
+            }
+            else if (workset[j] > ph[j])
+            {
+                *samerows = i;
+                return 1;
+            }
+    }
+
+    *samerows = n;
+    return 0;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  updatecan(g,canong,lab,samerows,m,n) sets canong = g^lab, assuming        *
+*  the first samerows of canong are ok already.                              *
+*                                                                            *
+*  GLOBALS ACCESSED: permset(),workperm<rw>                                  *
+*                                                                            *
+*****************************************************************************/
+
+void
+updatecan(graph *g, graph *canong, int *lab, int samerows, int m, int n)
+{
+    int i;
+    set *ph;
+
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n,"updatecan");
+#endif
+
+    for (i = 0; i < n; ++i) workperm[lab[i]] = i;
+
+    for (i = samerows, ph = GRAPHROW(canong,samerows,M);
+                                               i < n; ++i, ph += M)
+        permset(GRAPHROW(g,lab[i],M),ph,M,workperm);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  refine(g,lab,ptn,level,numcells,count,active,code,m,n) performs a         *
+*  refinement operation on the partition at the specified level of the       *
+*  partition nest (lab,ptn).  *numcells is assumed to contain the number of  *
+*  cells on input, and is updated.  The initial set of active cells (alpha   *
+*  in the paper) is specified in the set active.  Precisely, x is in active  *
+*  iff the cell starting at index x in lab is active.                        *
+*  The resulting partition is equitable if active is correct (see the paper  *
+*  and the Guide).                                                           *
+*  *code is set to a value which depends on the fine detail of the           *
+*  algorithm, but which is independent of the labelling of the graph.        *
+*  count is used for work space.                                             *
+*                                                                            *
+*  GLOBALS ACCESSED:  workset<w>,bit<r>,nextelement(),bucket<w>,workperm<w>  *
+*                                                                            *
+*****************************************************************************/
+
+void
+refine(graph *g, int *lab, int *ptn, int level, int *numcells,
+       int *count, set *active, int *code, int m, int n)
+{
+
+#if MAXM==1
+    refine1(g,lab,ptn,level,numcells,count,active,code,m,n);
+}
+#else
+
+    int i,c1,c2,labc1;
+    setword x;
+    set *set1,*set2;
+    int split1,split2,cell1,cell2;
+    int cnt,bmin,bmax;
+    long longcode;
+    set *gptr;
+    int maxcell,maxpos,hint;
+
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n,"refine");
+    DYNALLOC1(set,workset,workset_sz,m,"refine");
+    DYNALLOC1(int,bucket,bucket_sz,n+2,"refine");
+#endif
+
+    longcode = *numcells;
+    split1 = -1;
+    hint = 0;
+    while (*numcells < n && ((split1 = hint, ISELEMENT(active,split1))
+                         || (split1 = nextelement(active,M,split1)) >= 0
+                         || (split1 = nextelement(active,M,-1)) >= 0))
+    {
+        DELELEMENT(active,split1);
+        for (split2 = split1; ptn[split2] > level; ++split2) {}
+        longcode = MASH(longcode,split1+split2);
+        if (split1 == split2)       /* trivial splitting cell */
+        {
+            gptr = GRAPHROW(g,lab[split1],M);
+            for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+            {
+                for (cell2 = cell1; ptn[cell2] > level; ++cell2) {}
+                if (cell1 == cell2) continue;
+                c1 = cell1;
+                c2 = cell2;
+                while (c1 <= c2)
+                {
+                    labc1 = lab[c1];
+                    if (ISELEMENT(gptr,labc1))
+                        ++c1;
+                    else
+                    {
+                        lab[c1] = lab[c2];
+                        lab[c2] = labc1;
+                        --c2;
+                    }
+                }
+                if (c2 >= cell1 && c1 <= cell2)
+                {
+                    ptn[c2] = level;
+                    longcode = MASH(longcode,c2);
+                    ++*numcells;
+                    if (ISELEMENT(active,cell1) || c2-cell1 >= cell2-c1)
+                    {
+                        ADDELEMENT(active,c1);
+                        if (c1 == cell2) hint = c1;
+                    }
+                    else
+                    {
+                        ADDELEMENT(active,cell1);
+                        if (c2 == cell1) hint = cell1;
+                    }
+                }
+            }
+        }
+
+        else        /* nontrivial splitting cell */
+        {
+            EMPTYSET(workset,m);
+            for (i = split1; i <= split2; ++i)
+                ADDELEMENT(workset,lab[i]);
+            longcode = MASH(longcode,split2-split1+1);
+
+            for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+            {
+                for (cell2 = cell1; ptn[cell2] > level; ++cell2) {}
+                if (cell1 == cell2) continue;
+                i = cell1;
+                set1 = workset;
+                set2 = GRAPHROW(g,lab[i],m);
+                cnt = 0;
+                for (c1 = m; --c1 >= 0;)
+                    if ((x = ((*set1++) & (*set2++))) != 0)
+                        cnt += POPCOUNT(x);
+
+                count[i] = bmin = bmax = cnt;
+                bucket[cnt] = 1;
+                while (++i <= cell2)
+                {
+                    set1 = workset;
+                    set2 = GRAPHROW(g,lab[i],m);
+                    cnt = 0;
+                    for (c1 = m; --c1 >= 0;)
+                        if ((x = ((*set1++) & (*set2++))) != 0)
+                            cnt += POPCOUNT(x);
+
+                    while (bmin > cnt) bucket[--bmin] = 0;
+                    while (bmax < cnt) bucket[++bmax] = 0;
+                    ++bucket[cnt];
+                    count[i] = cnt;
+                }
+                if (bmin == bmax)
+                {
+                    longcode = MASH(longcode,bmin+cell1);
+                    continue;
+                }
+                c1 = cell1;
+                maxcell = -1;
+                for (i = bmin; i <= bmax; ++i)
+                    if (bucket[i])
+                    {
+                        c2 = c1 + bucket[i];
+                        bucket[i] = c1;
+                        longcode = MASH(longcode,i+c1);
+                        if (c2-c1 > maxcell)
+                        {
+                            maxcell = c2-c1;
+                            maxpos = c1;
+                        }
+                        if (c1 != cell1)
+                        {
+                            ADDELEMENT(active,c1);
+                            if (c2-c1 == 1) hint = c1;
+                            ++*numcells;
+                        }
+                        if (c2 <= cell2) ptn[c2-1] = level;
+                        c1 = c2;
+                    }
+                for (i = cell1; i <= cell2; ++i)
+                    workperm[bucket[count[i]]++] = lab[i];
+                for (i = cell1; i <= cell2; ++i) lab[i] = workperm[i];
+                if (!ISELEMENT(active,cell1))
+                {
+                    ADDELEMENT(active,cell1);
+                    DELELEMENT(active,maxpos);
+                }
+            }
+        }
+    }
+
+    longcode = MASH(longcode,*numcells);
+    *code = CLEANUP(longcode);
+}
+#endif /* else case of MAXM==1 */
+
+/*****************************************************************************
+*                                                                            *
+*  refine1(g,lab,ptn,level,numcells,count,active,code,m,n) is the same as    *
+*  refine(g,lab,ptn,level,numcells,count,active,code,m,n), except that       *
+*  m==1 is assumed for greater efficiency.  The results are identical in all *
+*  respects.  See refine (above) for the specs.                              *
+*                                                                            *
+*****************************************************************************/
+
+void
+refine1(graph *g, int *lab, int *ptn, int level, int *numcells,
+       int *count, set *active, int *code, int m, int n)
+{
+    int i,c1,c2,labc1;
+    setword x;
+    int split1,split2,cell1,cell2;
+    int cnt,bmin,bmax;
+    long longcode;
+    set *gptr,workset0;
+    int maxcell,maxpos,hint;
+
+#if !MAXN 
+    DYNALLOC1(int,workperm,workperm_sz,n,"refine1"); 
+    DYNALLOC1(int,bucket,bucket_sz,n+2,"refine1"); 
+#endif
+
+    longcode = *numcells;
+    split1 = -1;
+
+    hint = 0;
+    while (*numcells < n && ((split1 = hint, ISELEMENT1(active,split1))
+                         || (split1 = nextelement(active,1,split1)) >= 0
+                         || (split1 = nextelement(active,1,-1)) >= 0))
+    {
+        DELELEMENT1(active,split1);
+        for (split2 = split1; ptn[split2] > level; ++split2) {}
+        longcode = MASH(longcode,split1+split2);
+        if (split1 == split2)       /* trivial splitting cell */
+        {
+            gptr = GRAPHROW(g,lab[split1],1);
+            for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+            {
+                for (cell2 = cell1; ptn[cell2] > level; ++cell2) {}
+                if (cell1 == cell2) continue;
+                c1 = cell1;
+                c2 = cell2;
+                while (c1 <= c2)
+                {
+                    labc1 = lab[c1];
+                    if (ISELEMENT1(gptr,labc1))
+                        ++c1;
+                    else
+                    {
+                        lab[c1] = lab[c2];
+                        lab[c2] = labc1;
+                        --c2;
+                    }
+                }
+                if (c2 >= cell1 && c1 <= cell2)
+                {
+                    ptn[c2] = level;
+                    longcode = MASH(longcode,c2);
+                    ++*numcells;
+                    if (ISELEMENT1(active,cell1) || c2-cell1 >= cell2-c1)
+                    {
+                        ADDELEMENT1(active,c1);
+                        if (c1 == cell2) hint = c1;
+                    }
+                    else
+                    {
+                        ADDELEMENT1(active,cell1);
+                        if (c2 == cell1) hint = cell1;
+                    }
+                }
+            }
+        }
+
+        else        /* nontrivial splitting cell */
+        {
+            workset0 = 0;
+            for (i = split1; i <= split2; ++i)
+                ADDELEMENT1(&workset0,lab[i]);
+            longcode = MASH(longcode,split2-split1+1);
+
+            for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+            {
+                for (cell2 = cell1; ptn[cell2] > level; ++cell2) {}
+                if (cell1 == cell2) continue;
+                i = cell1;
+                if ((x = workset0 & g[lab[i]]) != 0)
+                    cnt = POPCOUNT(x);
+                else
+                    cnt = 0;
+                count[i] = bmin = bmax = cnt;
+                bucket[cnt] = 1;
+                while (++i <= cell2)
+                {
+                    if ((x = workset0 & g[lab[i]]) != 0)
+                        cnt = POPCOUNT(x);
+                    else
+                        cnt = 0;
+                    while (bmin > cnt) bucket[--bmin] = 0;
+                    while (bmax < cnt) bucket[++bmax] = 0;
+                    ++bucket[cnt];
+                    count[i] = cnt;
+                }
+                if (bmin == bmax)
+                {
+                    longcode = MASH(longcode,bmin+cell1);
+                    continue;
+                }
+                c1 = cell1;
+                maxcell = -1;
+                for (i = bmin; i <= bmax; ++i)
+                    if (bucket[i])
+                    {
+                        c2 = c1 + bucket[i];
+                        bucket[i] = c1;
+                        longcode = MASH(longcode,i+c1);
+                        if (c2-c1 > maxcell)
+                        {
+                            maxcell = c2-c1;
+                            maxpos = c1;
+                        }
+                        if (c1 != cell1)
+                        {
+                            ADDELEMENT1(active,c1);
+                            if (c2-c1 == 1) hint = c1;
+                            ++*numcells;
+                        }
+                        if (c2 <= cell2) ptn[c2-1] = level;
+                        c1 = c2;
+                    }
+                for (i = cell1; i <= cell2; ++i)
+                    workperm[bucket[count[i]]++] = lab[i];
+                for (i = cell1; i <= cell2; ++i) lab[i] = workperm[i];
+                if (!ISELEMENT1(active,cell1))
+                {
+                    ADDELEMENT1(active,cell1);
+                    DELELEMENT1(active,maxpos);
+                }
+            }
+        }
+    }
+
+    longcode = MASH(longcode,*numcells);
+    *code = CLEANUP(longcode);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  cheapautom(ptn,level,digraph,n) returns TRUE if the partition at the      *
+*  specified level in the partition nest (lab,ptn) {lab is not needed here}  *
+*  satisfies a simple sufficient condition for its cells to be the orbits of *
+*  some subgroup of the automorphism group.  Otherwise it returns FALSE.     *
+*  It always returns FALSE if digraph!=FALSE.                                *
+*                                                                            *
+*  nauty assumes that this function will always return TRUE for any          *
+*  partition finer than one for which it returns TRUE.                       *
+*                                                                            *
+*****************************************************************************/
+
+boolean
+cheapautom(int *ptn, int level, boolean digraph, int n)
+{
+    int i,k,nnt;
+
+    if (digraph) return FALSE;
+
+    k = n;
+    nnt = 0;
+    for (i = 0; i < n; ++i)
+    {
+        --k;
+        if (ptn[i] > level)
+        {
+            ++nnt;
+            while (ptn[++i] > level) {}
+        }
+    }
+
+    return (k <= nnt + 1 || k <= 4);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  bestcell(g,lab,ptn,level,tc_level,m,n) returns the index in lab of the    *
+*  start of the "best non-singleton cell" for fixing.  If there is no        *
+*  non-singleton cell it returns n.                                          *
+*  This implementation finds the first cell which is non-trivially joined    *
+*  to the greatest number of other cells.                                    *
+*                                                                            *
+*  GLOBALS ACCESSED: bit<r>,workperm<rw>,workset<rw>,bucket<rw>              *
+*                                                                            *
+*****************************************************************************/
+
+static int
+bestcell(graph *g, int *lab, int *ptn, int level, int tc_level, int m, int n)
+{
+    int i;
+    set *gp;
+    setword setword1,setword2;
+    int v1,v2,nnt;
+
+#if !MAXN 
+    DYNALLOC1(int,workperm,workperm_sz,n,"bestcell"); 
+    DYNALLOC1(set,workset,workset_sz,m,"bestcell"); 
+    DYNALLOC1(int,bucket,bucket_sz,n+2,"bestcell"); 
+#endif
+
+   /* find non-singleton cells: put starts in workperm[0..nnt-1] */
+
+    i = nnt = 0;
+
+    while (i < n)
+    {
+        if (ptn[i] > level)
+        {
+            workperm[nnt++] = i;
+            while (ptn[i] > level) ++i;
+        }
+        ++i;
+    }
+
+    if (nnt == 0) return n;
+
+    /* set bucket[i] to # non-trivial neighbours of n.s. cell i */
+
+    for (i = nnt; --i >= 0;) bucket[i] = 0;
+
+    for (v2 = 1; v2 < nnt; ++v2)
+    {
+        EMPTYSET(workset,m);
+        i = workperm[v2] - 1;
+        do
+        {
+            ++i;
+            ADDELEMENT(workset,lab[i]);
+        }
+        while (ptn[i] > level);
+        for (v1 = 0; v1 < v2; ++v1)
+        {
+            gp = GRAPHROW(g,lab[workperm[v1]],m);
+#if  MAXM==1
+            setword1 = *workset & *gp;
+            setword2 = *workset & ~*gp;
+#else
+            setword1 = setword2 = 0;
+            for (i = m; --i >= 0;)
+            {
+                setword1 |= workset[i] & gp[i];
+                setword2 |= workset[i] & ~gp[i];
+            }
+#endif
+            if (setword1 != 0 && setword2 != 0)
+            {
+                ++bucket[v1];
+                ++bucket[v2];
+            }
+        }
+    }
+
+    /* find first greatest bucket value */
+
+    v1 = 0;
+    v2 = bucket[0];
+    for (i = 1; i < nnt; ++i)
+        if (bucket[i] > v2)
+        {
+            v1 = i;
+            v2 = bucket[i];
+        }
+
+    return (int)workperm[v1];
+}
+
+/*****************************************************************************
+*                                                                            *
+*  targetcell(g,lab,ptn,level,tc_level,digraph,hint,m,n) returns the index   *
+*  in lab of the next cell to split.                                         *
+*  hint is a suggestion for the answer, which is obeyed if it is valid.      *
+*  Otherwise we use bestcell() up to tc_level and the first non-trivial      *
+*  cell after that.                                                          *
+*                                                                            *
+*****************************************************************************/
+
+int
+targetcell(graph *g, int *lab, int *ptn, int level, int tc_level,
+       boolean digraph, int hint, int m, int n)
+{
+    int i;
+
+    if (hint >= 0 && ptn[hint] > level &&
+                     (hint == 0 || ptn[hint-1] <= level))
+        return hint;
+    else if (level <= tc_level)
+        return bestcell(g,lab,ptn,level,tc_level,m,n);
+    else
+    {
+        for (i = 0; i < n && ptn[i] <= level; ++i) {}
+        return (i == n ? 0 : i);
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  densenauty(g,lab,ptn,orbits,&options,&stats,m,n,h)                        *
+*  is a slightly simplified interface to nauty().  It allocates enough       *
+*  workspace for 20 automorphisms and checks that the densegraph dispatch     *
+*  vector is in use.                                                         *
+*                                                                            *
+*****************************************************************************/
+
+void
+densenauty(graph *g, int *lab, int *ptn, int *orbits,
+           optionblk *options, statsblk *stats, int m, int n, graph *h)
+{
+    if (options->dispatch != &dispatch_graph)
+    {
+	fprintf(ERRFILE,"Error: densenauty() needs standard options block\n");
+	exit(1);
+    }
+
+#if !MAXN
+    DYNALLOC1(set,dnwork,dnwork_sz,2*60*m,"densenauty malloc");
+#endif
+
+    nauty(g,lab,ptn,NULL,orbits,options,stats,dnwork,2*60*m,m,n,h);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  naugraph_check() checks that this file is compiled compatibly with the    *
+*  given parameters.   If not, call exit(1).                                 *
+*                                                                            *
+*****************************************************************************/
+
+void
+naugraph_check(int wordsize, int m, int n, int version)
+{
+    if (wordsize != WORDSIZE)
+    {
+        fprintf(ERRFILE,"Error: WORDSIZE mismatch in naugraph.c\n");
+        exit(1);
+    }
+
+#if MAXN
+    if (m > MAXM)
+    {
+        fprintf(ERRFILE,"Error: MAXM inadequate in naugraph.c\n");
+        exit(1);
+    }
+
+    if (n > MAXN)
+    {
+        fprintf(ERRFILE,"Error: MAXN inadequate in naugraph.c\n");
+        exit(1);
+    }
+#endif
+
+    if (version < NAUTYREQUIRED)
+    {
+        fprintf(ERRFILE,"Error: naugraph.c version mismatch\n");
+        exit(1);
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  naugraph_freedyn() - free the dynamic memory in this module               *
+*                                                                            *
+*****************************************************************************/
+
+void
+naugraph_freedyn(void)
+{
+#if !MAXN
+    DYNFREE(workset,workset_sz);
+    DYNFREE(workperm,workperm_sz);
+    DYNFREE(bucket,bucket_sz);
+    DYNFREE(dnwork,dnwork_sz);
+#endif
+}
diff --git a/lib/nauty/naugroup.c b/lib/nauty/naugroup.c
new file mode 100644
index 0000000..59a1a7b
--- /dev/null
+++ b/lib/nauty/naugroup.c
@@ -0,0 +1,528 @@
+/* naugroup.c
+
+Procedures for handling groups found by nauty.
+*/
+
+#include "naugroup.h"
+
+static permrec *freelist = NULL;
+static int freelist_n = 0;
+
+static grouprec *group = NULL;
+static int group_depth = 0;
+DYNALLSTAT(cosetrec,coset,coset_sz);
+static permrec *gens;
+DYNALLSTAT(set,workset,workset_sz);
+DYNALLSTAT(int,allp,allp_sz);
+DYNALLSTAT(int,id,id_sz);
+
+/**************************************************************************/
+
+permrec
+*newpermrec(int n)
+/* Get a permrec of order n.  This procedure and the next one are
+designed to be efficient if lots of group ops are done with the
+same value of n. */
+{
+    permrec *p;
+
+    if (freelist_n != n)
+    {
+	while (freelist != NULL)
+	{
+	    p = freelist;
+	    freelist = freelist->ptr;
+	    free(p);
+	}
+	freelist_n = n;
+    }
+
+    if (freelist != NULL)
+    {
+	p = freelist;
+	freelist = freelist->ptr;
+	return p;
+    }
+
+    p = (permrec*) malloc(sizeof(permrec)+(freelist_n-2)*sizeof(int)); 
+
+    if (p == NULL)
+    {
+	fprintf(ERRFILE,">E malloc failed in newpermrec()\n");
+	exit(1);
+    }
+
+    return p;
+}
+
+/**************************************************************************/
+
+void
+freepermrec(permrec *p, int n)
+/* Free a permrec of given size. */
+{
+    permrec *q;
+
+    if (p == NULL) return;
+
+    if (freelist_n != n)
+    {
+	while (freelist)
+	{
+	    q = freelist;
+	    freelist = freelist->ptr;
+	    free(q);
+	}
+	freelist_n = n;
+    }
+
+    p->ptr = freelist;
+    freelist = p;
+}
+
+/**************************************************************************/
+
+grouprec *
+groupptr(boolean cutloose)
+/* Give the address of the group structure, cutting it loose
+   if requested. */
+{
+    grouprec *p;
+
+    p = group;
+
+    if (cutloose)
+    {
+	group = NULL;
+	group_depth = 0;
+	coset = NULL;
+	coset_sz = 0;
+    }
+
+    return p;
+}
+
+/**************************************************************************/
+
+void
+freegroup(grouprec *grp)
+/* Free (or pretend to free) group structure. */
+{
+    int i,j;
+    cosetrec *p;
+    permrec *q,*qq;
+
+    for (i = 0; i < grp->depth; ++i)
+    {
+	p = grp->levelinfo[i].replist;
+	if (p != NULL)
+	    for (j = grp->levelinfo[i].orbitsize; --j >= 0; )
+	    {
+		freepermrec(p[j].rep,grp->n);
+		p[j].rep = NULL;
+	    }
+    }
+
+    if (grp->depth > 0)
+    {
+        p = grp->levelinfo[0].replist;
+        if (p != NULL && p != coset)
+	{
+	    free(p);
+	    grp->levelinfo[0].replist = NULL;
+	}
+
+        q = grp->levelinfo[0].gens;
+        while (q != NULL)
+        {
+	    qq = q;
+	    q = q->ptr;
+	    freepermrec(qq,grp->n);
+        }
+	grp->levelinfo[0].gens = NULL;
+    }
+}
+
+/**************************************************************************/
+
+void
+groupautomproc(int count, int *perm, int *orbits,
+                                        int numorbits, int stabvertex, int n)
+{
+    permrec *p;
+    int i;
+
+    p = newpermrec(n);
+    for (i = 0; i < n; ++i) p->p[i] = perm[i];
+    p->ptr = gens;
+    gens = p;
+}
+
+/**************************************************************************/
+
+void
+grouplevelproc(int *lab, int *ptn, int level, int *orbits, statsblk *stats,
+               int tv, int index, int tcellsize, int numcells, int cc, int n)
+{
+    int depth;
+    size_t sz;
+
+    if (numcells == n)   /* first call */
+    {
+	depth = level - 1;
+
+	if (group) freegroup(group);
+
+	if (depth > group_depth || !group)
+	{
+	    if (depth <= 1) sz = sizeof(grouprec);
+	    else            sz = sizeof(grouprec) + (depth-1)*sizeof(levelrec);
+	    if (group) group = (grouprec*)realloc((void*)group,sz);
+	    else       group = (grouprec*)malloc(sz);
+	    if (group == NULL)
+	    {
+		fprintf(ERRFILE,">E malloc failed in grouplevelproc\n");
+		exit(1);
+	    }
+	    group_depth = depth;
+	}
+
+	group->n = n;
+	group->depth = depth;
+	gens = NULL;
+	return;
+    }
+
+    group->levelinfo[level-1].fixedpt = tv;
+    group->levelinfo[level-1].orbitsize = index;
+    group->levelinfo[level-1].gens = gens;
+    group->levelinfo[level-1].replist = NULL;
+
+    if (level == 1) group->numorbits = stats->numorbits;
+}
+
+/**************************************************************************/
+
+void
+makecosetreps(grouprec *grp)
+/* Make all coset representatives for this group */
+{
+    int i,j,k,n,depth;
+    int l,index;
+    int *p,*q;
+    permrec *gen,*g;
+    cosetrec *cr;
+    int head,tail;
+    DYNALLSTAT(int,queue,queue_sz);
+    DYNALLSTAT(int,lab,lab_sz);
+
+    n = grp->n;
+    depth = grp->depth;
+
+    DYNALLOC1(int,queue,queue_sz,n,"malloc");
+    DYNALLOC1(int,lab,lab_sz,n,"malloc");
+
+    j = 0;
+    for (i = 0; i < depth; ++i)
+	j += grp->levelinfo[i].orbitsize;
+
+    if (j > 0) DYNALLOC1(cosetrec,coset,coset_sz,j,"malloc");
+
+    cr = coset;
+    for (i = 0; i < depth; ++i)
+    {
+	grp->levelinfo[i].replist = cr;
+	cr += grp->levelinfo[i].orbitsize;
+    }
+
+    for (i = 0; i < depth; ++i)
+    {
+	cr = grp->levelinfo[i].replist;
+	gen = grp->levelinfo[i].gens;
+	for (j = 0; j < n; ++j) lab[j] = -1;
+	queue[0] = grp->levelinfo[i].fixedpt;
+	lab[queue[0]] = 0;
+	cr[0].image = queue[0];
+	cr[0].rep = NULL;
+	head = 0;
+	tail = 1;
+	index = 0;
+	while (head < tail)
+	{
+	    j = queue[head++];
+	    p = (cr[lab[j]].rep ? cr[lab[j]].rep->p : NULL);
+	    for (g = gen; g != NULL; g = g->ptr)
+	    {
+		k = g->p[j];
+		if (lab[k] < 0)
+		{
+		    ++index;
+		    lab[k] = index;
+		    queue[tail++] = k;
+		    cr[index].image = k;
+		    cr[index].rep = newpermrec(n);
+		    q = cr[index].rep->p;
+		    if (p == NULL)
+			for (l = 0; l < n; ++l) q[l] = g->p[l];
+		    else
+			for (l = 0; l < n; ++l) q[l] = g->p[p[l]];
+		}
+	    }
+	}
+    }
+}
+
+/**************************************************************************/
+
+int
+permcycles(int *p, int n, int *len, boolean sort)
+/* Puts in len[0..] the cycle lengths of p.  If sort, sort them. 
+   Return the number of cycles. */
+{
+    int m,i,j,k,h,nc,leni;
+
+    m = (n + WORDSIZE - 1) / WORDSIZE;
+    DYNALLOC1(set,workset,workset_sz,m,"malloc");
+
+    EMPTYSET(workset,m);
+
+    nc = 0;
+    for (i = 0; i < n; ++i)
+        if (!ISELEMENT(workset,i))
+	{
+	    k = 1;
+	    for (j = p[i]; j != i; j = p[j]) 
+	    {
+		ADDELEMENT(workset,j);
+		++k;
+	    }
+	    len[nc++] = k;
+	}
+
+    if (sort && nc > 1)
+    {
+	j = nc / 3;
+        h = 1;
+        do
+            h = 3 * h + 1;
+        while (h < j);
+
+	do
+        {
+            for (i = h; i < nc; ++i)
+            {
+                leni = len[i];
+                for (j = i; len[j-h] > leni; )
+                {
+                    len[j] = len[j-h];
+                    if ((j -= h) < h) break;
+                }
+                len[j] = leni;
+            }
+            h /= 3;
+        }
+        while (h > 0);
+    }
+
+    return nc;
+}
+
+/**************************************************************************/
+
+static void
+groupelts(levelrec *lr, int n, int level, void (*action)(int*,int),
+          int *before, int *after, int *id)
+/* Recursive routine used by allgroup. */
+{
+    int i,j,orbsize;
+    int *p,*cr;
+    cosetrec *coset;
+    
+    coset = lr[level].replist;
+    orbsize = lr[level].orbitsize;
+
+    for (j = 0; j < orbsize; ++j)
+    {
+	cr = (coset[j].rep == NULL ? NULL : coset[j].rep->p);
+	if (before == NULL)
+	    p = cr;
+	else if (cr == NULL)
+	    p = before;
+	else
+	{
+	    p = after;
+	    for (i = 0; i < n; ++i) p[i] = cr[before[i]];
+	}
+
+	if (level == 0) 
+	    (*action)((p == NULL ? id : p),n);
+	else
+	    groupelts(lr,n,level-1,action,p,after+n,id);
+    }
+}
+
+/**************************************************************************/
+
+void
+allgroup(grouprec *grp, void (*action)(int*,int))
+/* Call action(p,n) for every element of the group, including the identity. 
+   The identity is always the first call. */
+{
+    int i,depth,n;
+
+    depth = grp->depth;
+    n = grp->n;
+
+    DYNALLOC1(int,id,id_sz,n,"malloc");
+    for (i = 0; i < n; ++i) id[i] = i;
+
+    if (depth == 0)
+    {
+	(*action)(id,n);
+	return;
+    }
+
+    DYNALLOC1(int,allp,allp_sz,n*depth,"malloc");
+
+    groupelts(grp->levelinfo,n,depth-1,action,NULL,allp,id);
+}
+
+/**************************************************************************/
+
+static void
+groupelts2(levelrec *lr, int n, int level,
+    void (*action)(int*,int,int*), int *before,
+    int *after, int *id, int *abort)
+/* Recursive routine used by allgroup2. */
+{
+    int i,j,orbsize;
+    int *p,*cr;
+    cosetrec *coset;
+    
+    coset = lr[level].replist;
+    orbsize = lr[level].orbitsize;
+
+    for (j = 0; j < orbsize; ++j)
+    {
+	cr = (coset[j].rep == NULL ? NULL : coset[j].rep->p);
+	if (before == NULL)
+	    p = cr;
+	else if (cr == NULL)
+	    p = before;
+	else
+	{
+	    p = after;
+	    for (i = 0; i < n; ++i) p[i] = cr[before[i]];
+	}
+
+	if (level == 0) 
+	    (*action)((p == NULL ? id : p),n,abort);
+	else
+	    groupelts2(lr,n,level-1,action,p,after+n,id,abort);
+	if (*abort) return;
+    }
+}
+
+/**************************************************************************/
+
+int
+allgroup2(grouprec *grp, void (*action)(int*,int,int*))
+/* Call action(p,n,&abort) for every element of the group, including
+   the identity.  The identity is always the first call.
+   If action() stores a non-zero value in abort, group generation is
+   aborted and the abort value is returned by this procedure.  If no
+   non-zero value is ever returned in abort by action(), this
+   procedure returns 0. */
+{
+    int i,depth,n,abort;
+
+    depth = grp->depth;
+    n = grp->n;
+
+    DYNALLOC1(int,id,id_sz,n,"malloc");
+    for (i = 0; i < n; ++i) id[i] = i;
+
+    abort = 0;
+    if (depth == 0)
+    {
+	(*action)(id,n,&abort);
+	return abort;
+    }
+
+    DYNALLOC1(int,allp,allp_sz,n*depth,"malloc");
+
+    groupelts2(grp->levelinfo,n,depth-1,action,NULL,allp,id,&abort);
+
+    return abort;
+}
+
+/**************************************************************************/
+
+static void
+groupelts3(levelrec *lr, int n, int level,
+    void (*action)(int*,int,int*,void*), int *before,
+    int *after, int *id, int *abort, void *userptr)
+/* Recursive routine used by allgroup3. */
+{
+    int i,j,orbsize;
+    int *p,*cr;
+    cosetrec *coset;
+    
+    coset = lr[level].replist;
+    orbsize = lr[level].orbitsize;
+
+    for (j = 0; j < orbsize; ++j)
+    {
+	cr = (coset[j].rep == NULL ? NULL : coset[j].rep->p);
+	if (before == NULL)
+	    p = cr;
+	else if (cr == NULL)
+	    p = before;
+	else
+	{
+	    p = after;
+	    for (i = 0; i < n; ++i) p[i] = cr[before[i]];
+	}
+
+	if (level == 0) 
+	    (*action)((p == NULL ? id : p),n,abort,userptr);
+	else
+	    groupelts3(lr,n,level-1,action,p,after+n,id,abort,userptr);
+	if (*abort) return;
+    }
+}
+
+/**************************************************************************/
+
+int
+allgroup3(grouprec *grp, void (*action)(int*,int,int*,void*), void *userptr)
+/* Call action(p,n,&abort,userptr) for every element of the group,
+   including the identity.  The identity is always the first call.
+   If action() stores a non-zero value in abort, group generation is
+   aborted and the abort value is returned by this procedure.  If no
+   non-zero value is ever returned in abort by action(), this
+   procedure returns 0. The pointer userptr is not interpretted and
+   is passed to action() to use as it likes. */
+{
+    int i,depth,n,abort;
+
+    depth = grp->depth;
+    n = grp->n;
+
+    DYNALLOC1(int,id,id_sz,n,"malloc");
+    for (i = 0; i < n; ++i) id[i] = i;
+
+    abort = 0;
+    if (depth == 0)
+    {
+	(*action)(id,n,&abort,userptr);
+	return abort;
+    }
+
+    DYNALLOC1(int,allp,allp_sz,n*depth,"malloc");
+
+    groupelts3(grp->levelinfo,n,depth-1,action,NULL,allp,id,&abort,userptr);
+
+    return abort;
+}
+
diff --git a/lib/nauty/naugroup.h b/lib/nauty/naugroup.h
new file mode 100644
index 0000000..a43c262
--- /dev/null
+++ b/lib/nauty/naugroup.h
@@ -0,0 +1,55 @@
+/* naugroup.h
+
+Procedures for handling groups found by nauty.
+*/
+
+#include "nauty.h"
+
+typedef struct perm_struct
+{
+    struct perm_struct *ptr;   /* general-purpose pointer */
+    int p[2];          /* extendable section */
+} permrec;
+
+typedef struct coset_struct
+{
+    int image;       /* image of fixed point */
+    permrec *rep;    /* pointer to a representative */
+} cosetrec;
+
+typedef struct level_struct
+{
+    int fixedpt;       /* point that is fixed in this level */
+    int orbitsize;     /* the size of the orbit containing fixedpt */
+    permrec *gens;     /* pointer to list of generators */
+    cosetrec *replist; /* array of orbitsize representatives */
+} levelrec;
+
+typedef struct group_struct
+{
+    int n;                   /* number of points */
+    int numorbits;           /* number of orbits */
+    int depth;               /* number of points in base */
+    levelrec levelinfo[1];   /* extendable section */
+} grouprec;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void freepermrec(permrec*, int);
+extern grouprec *groupptr(boolean);
+extern permrec *newpermrec(int);
+extern void groupautomproc(int,int*,int*,int,int,int);
+extern void
+   grouplevelproc(int*,int*,int,int*,statsblk*,int,int,int,int,int,int);
+extern void makecosetreps(grouprec*);
+extern int permcycles(int*,int,int*,boolean);
+extern void allgroup(grouprec*,void(*)(int*,int));
+extern int allgroup2(grouprec*,void(*)(int*,int,int*));
+extern int allgroup3(grouprec*,void(*)(int*,int,int*,void*),void*);
+extern void freegroup(grouprec*);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/nauty/naugstrings.c b/lib/nauty/naugstrings.c
new file mode 100644
index 0000000..86fd741
--- /dev/null
+++ b/lib/nauty/naugstrings.c
@@ -0,0 +1,523 @@
+/* naugstrings.c : Write graph6 or sparse6 strings into array. */
+/* Version 1.1, Jun 2015. */
+
+#include "naugstrings.h"
+
+/****************************************************************************/
+
+void
+encodegraphsize(int n, char **pp)
+/* Encode the size n in a string starting at **p, and reset **p
+   to point to the character after the size */
+{
+    char *p;
+
+    p = *pp;
+    if (n <= SMALLN) 
+        *p++ = (char)(BIAS6 + n);
+    else if (n <= SMALLISHN)
+    {
+        *p++ = MAXBYTE;
+        *p++ = (char)(BIAS6 + (n >> 12));
+        *p++ = (char)(BIAS6 + ((n >> 6) & C6MASK));
+        *p++ = (char)(BIAS6 + (n & C6MASK));
+    }
+    else 
+    {
+        *p++ = MAXBYTE;
+        *p++ = MAXBYTE;
+        *p++ = (char)(BIAS6 + (n >> 30));
+        *p++ = (char)(BIAS6 + ((n >> 24) & C6MASK));
+        *p++ = (char)(BIAS6 + ((n >> 18) & C6MASK));
+        *p++ = (char)(BIAS6 + ((n >> 12) & C6MASK));
+        *p++ = (char)(BIAS6 + ((n >> 6) & C6MASK));
+        *p++ = (char)(BIAS6 + (n & C6MASK));
+    }
+
+    *pp = p;
+}
+
+/****************************************************************************/
+
+void
+gtog6string(graph *g, char **pp, int m, int n)
+/* convert dense graph to graph6 string, including \n but not \0
+   Start at *pp and set *pp to point one char after the \n */
+{
+    int i,j,k;
+    char *p,x;
+    set *gj;
+    size_t ii;
+
+    ii = G6LEN(n)+3;
+
+    p = *pp;
+    encodegraphsize(n,&p);
+
+    k = 6;
+    x = 0;
+
+    for (j = 1; j < n; ++j)
+    {
+        gj = GRAPHROW(g,j,m);
+        for (i = 0; i < j; ++i)
+        {
+            x <<= 1;
+            if (ISELEMENT(gj,i)) x |= 1;
+            if (--k == 0)
+            {
+                *p++ = (char)(BIAS6 + x);
+                k = 6;
+                x = 0;
+            }
+        }
+    }
+
+    if (k != 6) *p++ = (char)(BIAS6 + (x << k));
+
+    *p++ = '\n';
+    *pp = p;
+}
+
+/****************************************************************************/
+
+void
+gtod6string(graph *g, char **pp, int m, int n)
+/* convert dense graph to digraph6 string, including \n but not \0
+   Start at *pp and set *pp to point one char after the \n */
+{
+    int i,j,k;
+    char *p,x;
+    set *gj;
+    size_t ii;
+
+    ii = D6LEN(n)+3;
+
+    p = *pp;
+    encodegraphsize(n,&p);
+
+    k = 6;
+    x = 0;
+
+    for (j = 0; j < n; ++j)
+    {
+        gj = GRAPHROW(g,j,m);
+        for (i = 0; i < n; ++i)
+        {
+            x <<= 1;
+            if (ISELEMENT(gj,i)) x |= 1;
+            if (--k == 0)
+            {
+                *p++ = (char)(BIAS6 + x);
+                k = 6;
+                x = 0;
+            }
+        }
+    }
+
+    if (k != 6) *p++ = (char)(BIAS6 + (x << k));
+
+    *p++ = '\n';
+    *pp = p;
+}
+
+/****************************************************************************/
+
+void
+gtois6string(graph *g, graph *prevg, char **pp, int m, int n)
+/* convert dense graph to incremental spargse6 string, including \n
+   but not \0.
+   Start at *pp and set *pp to point one char after the \n */
+{
+    int i,j,k;
+    char *p,x;
+    set *gj,*pgj;
+    setword gdiff;
+    int r,rr,topbit,nb,lastj,iw,nwords;
+
+    if (!prevg) 
+    {
+	gtos6string(g,pp,m,n);
+	return;
+    }
+
+    **pp = ';';
+    p = *pp+1;
+
+    for (i = n-1, nb = 0; i != 0 ; i >>= 1, ++nb)
+    {}
+    topbit = 1 << (nb-1);
+    k = 6;
+    x = 0;
+
+    lastj = 0;
+    for (j = 0; j < n; ++j)
+    {
+        gj = GRAPHROW(g,j,m);
+        pgj = GRAPHROW(prevg,j,m); 
+        nwords = SETWORDSNEEDED(j+1);
+        for (iw = 0; iw < nwords; ++iw)
+        {
+            gdiff = gj[iw] ^ pgj[iw];
+            if (TIMESWORDSIZE(iw+1) > j+1) gdiff &= ALLMASK(SETBT(j+1));
+            while (gdiff)
+            {
+                TAKEBIT(i,gdiff);
+                i += TIMESWORDSIZE(iw);
+   
+                if (j == lastj)
+                {
+                    x <<= 1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                }
+                else
+                {
+                    x = (x << 1) | (char)1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                    if (j > lastj+1)
+                    {
+                        for (r = 0, rr = j; r < nb; ++r, rr <<= 1)
+                        {
+                            if (rr & topbit) x = (x << 1) | (char)1;
+                            else             x <<= 1;
+                            if (--k == 0)
+                            {
+                                *p++ = (char)(BIAS6 + x);
+                                k = 6;
+                                x = 0;
+                            }
+                        }
+                        x <<= 1;
+                        if (--k == 0)
+                        {
+                            *p++ = (char)(BIAS6 + x);
+                            k = 6;
+                            x = 0;
+                        }
+                    }
+                    lastj = j;
+                }
+                for (r = 0, rr = i; r < nb; ++r, rr <<= 1)
+                {
+                    if (rr & topbit) x = (x << 1) | (char)1;
+                    else             x <<= 1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                }
+            }
+        }
+    }
+
+    if (k != 6)
+    {
+        if (k >= nb+1 && lastj == n-2 && n == (1<<nb))
+            *p++ = (char)(BIAS6 + ((x << k) | ((1 << (k-1)) - 1)));
+        else
+            *p++ = (char)(BIAS6 + ((x << k) | ((1 << k) - 1)));
+    }
+
+    *p++ = '\n';
+    *pp = p;
+}
+
+/****************************************************************************/
+
+void
+gtos6string(graph *g, char **pp, int m, int n)
+/* convert dense graph to sparse6 string, including \n but not \0
+   Start at *pp and set *pp to point one char after the \n */
+{
+    int i,j,k;
+    char *p,x;
+    set *gj;
+    int r,rr,topbit,nb,lastj;
+
+    **pp = ':';
+    p = *pp+1;
+    encodegraphsize(n,&p);
+
+    for (i = n-1, nb = 0; i != 0 ; i >>= 1, ++nb)
+    {}
+    topbit = 1 << (nb-1);
+    k = 6;
+    x = 0;
+
+    lastj = 0;
+    for (j = 0; j < n; ++j)
+    {
+        gj = GRAPHROW(g,j,m);
+        for (i = 0; i <= j; ++i)
+        {
+            if (ISELEMENT(gj,i))
+            {
+                if (j == lastj)
+                {
+                    x <<= 1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                }
+                else
+                {
+                    x = (x << 1) | (char)1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                    if (j > lastj+1)
+                    {
+                        for (r = 0, rr = j; r < nb; ++r, rr <<= 1)
+                        {
+                            if (rr & topbit) x = (x << 1) | (char)1;
+                            else             x <<= 1;
+                            if (--k == 0)
+                            {
+                                *p++ = (char)(BIAS6 + x);
+                                k = 6;
+                                x = 0;
+                            }
+                        }
+                        x <<= 1;
+                        if (--k == 0)
+                        {
+                            *p++ = (char)(BIAS6 + x);
+                            k = 6;
+                            x = 0;
+                        }
+                    }
+                    lastj = j;
+                }
+                for (r = 0, rr = i; r < nb; ++r, rr <<= 1)
+                {
+                    if (rr & topbit) x = (x << 1) | (char)1;
+                    else             x <<= 1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                }
+            }
+        }
+    }
+
+    if (k != 6)
+    {
+        if (k >= nb+1 && lastj == n-2 && n == (1<<nb))
+	    *p++ = (char)(BIAS6 + ((x << k) | ((1 << (k-1)) - 1)));
+        else
+	    *p++ = (char)(BIAS6 + ((x << k) | ((1 << k) - 1)));
+    }
+
+    *p++ = '\n';
+    *pp = p;
+}
+
+/*************************************************************************/
+
+void
+sgtos6string(sparsegraph *sg, char **pp)
+/* convert sparse graph to graph6 string, including \n but not \0
+   Start at *pp and set *pp to point one char after the \n */
+{
+    int *d,*e;
+    int i,j,n;
+    char *p,x;
+    int nb,topbit;
+    int dj,k,lastj;
+    int r,rr;
+    size_t ii,*v,vj,l;
+
+    SG_VDE(sg,v,d,e);
+    n = sg->nv;
+    for (i = n-1, nb = 0; i != 0 ; i >>= 1, ++nb) {}
+
+    ii = (size_t)(nb+1)*(n/6+sg->nde/3);
+
+    p = *pp;
+    *p++ = ':';
+    encodegraphsize(n,&p);
+
+    topbit = 1 << (nb-1);
+    k = 6;
+    x = 0;
+
+    lastj = 0;
+    for (j = 0; j < n; ++j)
+    {
+        vj = v[j];
+        dj = d[j];
+        for (l = 0; l < dj; ++l)
+        {
+            i = e[vj+l];
+            if (i <= j)
+            {
+                if (j == lastj)
+                {
+                    x <<= 1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                }
+                else
+                {
+                    x = (x << 1) | (char)1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                    if (j > lastj+1)
+                    {
+                        for (r = 0, rr = j; r < nb; ++r, rr <<= 1)
+                        {
+                            if (rr & topbit) x = (x << 1) | (char)1;
+                            else             x <<= 1;
+                            if (--k == 0)
+                            {
+                                *p++ = (char)(BIAS6 + x);
+                                k = 6;
+                                x = 0;
+                            }
+                        }
+                            x <<= 1;
+                        if (--k == 0)
+                        {
+                            *p++ = (char)(BIAS6 + x);
+                            k = 6;
+                            x = 0;
+                        }
+                    }
+                    lastj = j;
+                }
+                for (r = 0, rr = i; r < nb; ++r, rr <<= 1)
+                {
+                    if (rr & topbit) x = (x << 1) | (char)1;
+                    else             x <<= 1;
+                    if (--k == 0)
+                    {
+                        *p++ = (char)(BIAS6 + x);
+                        k = 6;
+                        x = 0;
+                    }
+                }
+            }
+        }
+    }
+
+    if (k != 6)
+    {
+        if (k >= nb+1 && lastj == n-2 && n == (1<<nb))
+	    *p++ = (char)(BIAS6 + ((x << k) | ((1 << (k-1)) - 1)));
+        else
+	    *p++ = (char)(BIAS6 + ((x << k) | ((1 << k) - 1)));
+    }
+
+    *p++ = '\n';
+    *pp = p;
+}
+
+/*************************************************************************/
+
+void
+sgtog6string(sparsegraph *sg, char **pp)
+/* convert dense graph to graph6 string, including \n but not \0
+   Start at *pp and set *pp to point one char after the \n */
+{
+    int *d,*e,*ei;
+    int i,j,n;
+    char *p;
+    size_t ii,*v,bodylen,org;
+    static char g6bit[] = {32,16,8,4,2,1};
+
+    SG_VDE(sg,v,d,e);
+    n = sg->nv;
+
+    ii = G6LEN(n)+3;
+
+    p = *pp;
+    encodegraphsize(n,&p);
+
+    bodylen = G6BODYLEN(n);
+    for (ii = 0; ii < bodylen; ++ii) p[ii] = 0;
+    p[bodylen] = '\n';
+
+    for (i = 0, org = 0; i < n;  org += i, ++i)
+    {
+	ei = e + v[i];
+	for (j = 0; j < d[i]; ++j)
+	    if (ei[j] < i)
+	    {
+		ii = ei[j] + org;
+		p[ii/6] |= g6bit[ii%6];
+	    }
+    }
+
+    for (ii = 0; ii < bodylen; ++ii) p[ii] += BIAS6;
+
+    *pp = p + bodylen + 1;
+}
+
+/*************************************************************************/
+
+void
+sgtod6string(sparsegraph *sg, char **pp)
+/* convert dense graph to digraph6 string, including \n but not \0
+   Start at *pp and set *pp to point one char after the \n */
+{
+    int *d,*e,*ei;
+    int i,j,n;
+    char *p;
+    size_t ii,*v,bodylen,org;
+    static char g6bit[] = {32,16,8,4,2,1};
+
+    SG_VDE(sg,v,d,e);
+    n = sg->nv;
+
+    ii = G6LEN(n)+3;
+
+    p = *pp;
+    encodegraphsize(n,&p);
+
+    bodylen = D6BODYLEN(n);
+    for (ii = 0; ii < bodylen; ++ii) p[ii] = 0;
+    p[bodylen] = '\n';
+
+    for (i = 0, org = 0; i < n;  org += i, ++i)
+    {
+	ei = e + v[i];
+	for (j = 0; j < d[i]; ++j)
+	{
+	    ii = ei[j] + org;
+	    p[ii/6] |= g6bit[ii%6];
+	}
+    }
+
+    for (ii = 0; ii < bodylen; ++ii) p[ii] += BIAS6;
+
+    *pp = p + bodylen + 1;
+}
diff --git a/lib/nauty/naugstrings.h b/lib/nauty/naugstrings.h
new file mode 100644
index 0000000..f59c1d5
--- /dev/null
+++ b/lib/nauty/naugstrings.h
@@ -0,0 +1,20 @@
+/* naugstrings.h : Write graph6 or sparse6 strings into array. */
+/* Version 1.1, Jun 2015. */
+
+#include "gtools.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void gtog6string(graph*,char**,int,int);
+extern void gtos6string(graph*,char**,int,int);
+extern void gtod6string(graph*,char**,int,int);
+extern void sgtos6string(sparsegraph*,char**);
+extern void sgtog6string(sparsegraph*,char**);
+extern void sgtod6string(sparsegraph*,char**);
+extern void gtois6string(graph*,graph*,char**,int,int);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/nauty/naurng.c b/lib/nauty/naurng.c
new file mode 100644
index 0000000..5853de2
--- /dev/null
+++ b/lib/nauty/naurng.c
@@ -0,0 +1,133 @@
+/* naurng.c
+ * This is thread-safe version of rng.c if thread-local support
+ * is available.
+ *
+   This file contains the code for a high-quality random number
+   generator written by Don Knuth.  The auxilliary routine
+   ran_arr_cycle() has been modified slightly, and ran_init() is new.
+
+   To use it:
+
+      0.  #include "naurng.h" (or "naututil.h" if you are using nauty)
+
+      1.  Call ran_init(seed), where seed is any long integer.
+          This step is optional, but if you don't use it you
+          will always get the same sequence of random numbers.
+
+      2.  For each random number, use the NEXTRAN macro.  It will
+          give a random value in the range 0..2^30-1.  Alternatively,
+          KRAN(k) will have a random value in the range 0..k-1.
+          KRAN(k) actually gives you NEXTRAN mod k, so it is not
+          totally uniform if k is very large.  In that case, you
+          can use the slightly slower GETKRAN(k,var) to set the
+          variable var to a better random number from 0..k-1.
+
+    Brendan McKay, July 2002.  Fixed Nov 2002 on advice of DEK.
+
+*/
+
+/*    This program by D E Knuth is in the public domain and freely copyable
+ *    AS LONG AS YOU MAKE ABSOLUTELY NO CHANGES!
+ *    It is explained in Seminumerical Algorithms, 3rd edition, Section 3.6
+ *    (or in the errata to the 2nd edition --- see
+ *        http://www-cs-faculty.stanford.edu/~knuth/taocp.html
+ *    in the changes to Volume 2 on pages 171 and following).              */
+
+/*    N.B. The MODIFICATIONS introduced in the 9th printing (2002) are
+      included here; there's no backwards compatibility with the original. */
+
+/*    If you find any bugs, please report them immediately to
+ *                 taocp@cs.stanford.edu
+ *    (and you will be rewarded if the bug is genuine). Thanks!            */
+
+/************ see the book for explanations and caveats! *******************/
+/************ in particular, you need two's complement arithmetic **********/
+
+#include "naurng.h"
+
+#define KK 100                     /* the long lag */
+#define LL  37                     /* the short lag */
+#define MM (1L<<30)                 /* the modulus */
+#define mod_diff(x,y) (((x)-(y))&(MM-1)) /* subtraction mod MM */
+
+static TLS_ATTR long ran_x[KK];                    /* the generator state */
+
+static void
+ran_array(long aa[],int n)
+{
+  int i,j;
+  for (j=0;j<KK;j++) aa[j]=ran_x[j];
+  for (;j<n;j++) aa[j]=mod_diff(aa[j-KK],aa[j-LL]);
+  for (i=0;i<LL;i++,j++) ran_x[i]=mod_diff(aa[j-KK],aa[j-LL]);
+  for (;i<KK;i++,j++) ran_x[i]=mod_diff(aa[j-KK],ran_x[i-LL]);
+}
+
+/* the following routines are from exercise 3.6--15 */
+/* after calling ran_start, get new randoms by, e.g., "x=ran_arr_next()" */
+
+#define RNG_QUALITY 1009 /* recommended quality level for high-res use */
+static TLS_ATTR long ran_arr_buf[RNG_QUALITY];
+static long ran_arr_dummy=-1;
+static long ran_arr_started=-1;
+static TLS_ATTR long *ran_arr_ptr = &ran_arr_dummy;
+
+#define TT  70   /* guaranteed separation between streams */
+#define is_odd(x)  ((x)&1)          /* units bit of x */
+
+static void
+ran_start(long seed)
+{
+  int t,j;
+  long x[KK+KK-1];              /* the preparation buffer */
+  long ss=(seed+2)&(MM-2);
+
+  for (j=0;j<KK;j++) {
+    x[j]=ss;                      /* bootstrap the buffer */
+    ss<<=1; if (ss>=MM) ss-=MM-2; /* cyclic shift 29 bits */
+  }
+  x[1]++;              /* make x[1] (and only x[1]) odd */
+  for (ss=seed&(MM-1),t=TT-1; t; ) {       
+    for (j=KK-1;j>0;j--) x[j+j]=x[j], x[j+j-1]=0; /* "square" */
+    for (j=KK+KK-2;j>=KK;j--)
+      x[j-(KK-LL)]=mod_diff(x[j-(KK-LL)],x[j]),
+      x[j-KK]=mod_diff(x[j-KK],x[j]);
+    if (is_odd(ss)) {              /* "multiply by z" */
+      for (j=KK;j>0;j--)  x[j]=x[j-1];
+      x[0]=x[KK];            /* shift the buffer cyclically */
+      x[LL]=mod_diff(x[LL],x[KK]);
+    }
+    if (ss) ss>>=1; else t--;
+  }
+  for (j=0;j<LL;j++) ran_x[j+KK-LL]=x[j];
+  for (;j<KK;j++) ran_x[j-LL]=x[j];
+  for (j=0;j<10;j++) ran_array(x,KK+KK-1); /* warm things up */
+  ran_arr_ptr=&ran_arr_started;
+}
+
+void
+ran_init(long seed)    /* Added by BDM: use instead of ran_start. */
+                       /*  But this is less important with this version */
+{
+    ran_start((unsigned long)seed % (MM-2));
+}
+
+static long
+ran_arr_cycle(void)
+/* Modified by BDM to automatically initialise 
+   if no explicit initialisation has been done */
+{
+   if (ran_arr_ptr==&ran_arr_dummy)
+       ran_start(314159L); /* the user forgot to initialize */
+
+  ran_array(ran_arr_buf,RNG_QUALITY);
+
+  ran_arr_buf[KK]=-1;
+  ran_arr_ptr=ran_arr_buf+1;
+  return ran_arr_buf[0];
+}
+
+long
+ran_nextran(void)
+{
+    return (*ran_arr_ptr>=0 ? *ran_arr_ptr++ : ran_arr_cycle()); 
+}
diff --git a/lib/nauty/naurng.h b/lib/nauty/naurng.h
new file mode 100644
index 0000000..fa4b17e
--- /dev/null
+++ b/lib/nauty/naurng.h
@@ -0,0 +1,40 @@
+/* naurng.h : definitions for using Don Knuth's random number generator.
+   This version uses the attribute TLS_ATTR from nauty.h.
+
+   To use it:
+     1.  Call ran_init(seed) with any long seed.  (Optional,
+	   but you will always get the same sequence otherwise.)
+     2.  Use NEXTRAN to get the next number (0..2^30-1).
+         Alternatively, use KRAN(k) to get a random number 0..k-1.
+	 For large k, KRAN(k) is not quite uniform.  In that case
+         use GETKRAN(k,var) to set the variable var to a better
+         random number 0..k-1.
+*/
+
+#ifndef NAURNG_H
+#include "nauty.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void ran_init(long seed);
+long ran_nextran(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#define MAXRAN (0x3fffffffL)    /* Values are 0..MAXRAN */
+#define NEXTRAN (ran_nextran())
+#define KRAN(k) (NEXTRAN%(k))
+#define RANREAL ((NEXTRAN+0.5)/(MAXRAN+1.0))  /* Uniform (0,1) */
+
+#define MAXSAFE(k) (((MAXRAN+1)/(k))*(k))
+#define GETKRAN(k,var) {long __getkran; \
+    do {__getkran = NEXTRAN;} while (__getkran >= MAXSAFE(k)); \
+    var = __getkran % (k);}
+#define INITRANBYTIME ran_init((long)time(NULL))
+
+#define NAURNG_H
+#endif
diff --git a/lib/nauty/nausparse.c b/lib/nauty/nausparse.c
new file mode 100644
index 0000000..57fe10a
--- /dev/null
+++ b/lib/nauty/nausparse.c
@@ -0,0 +1,1741 @@
+/*****************************************************************************
+*                                                                            *
+*  Sparse-graph-specific auxiliary source file for version 2.6 of nauty.     *
+*                                                                            *
+*   Copyright (2004-2016) Brendan McKay.  All rights reserved.               *
+*   Subject to waivers and disclaimers in nauty.h.                           *
+*                                                                            *
+*   CHANGE HISTORY                                                           *
+*       26-Oct-04 : initial creation                                         *
+*       23-Nov-06 : dispatch uses targetcell_sg, not bestcell_sg             *
+*        8-Dec-06 : add adjacencies_sg()                                     *
+*       10-Nov-09 : remove types shortish and permutation                    *
+*       14-Nov-09 : added copy_sg()                                          *
+*       11-May-10 : use sorttemplates.c for sorting procedures               *
+*       19-May-10 : add two *_tr procedures for traces.                      *
+*       21-May-10 : fixes for nde,v fields becoming size_t                   *
+*       23-May-10 : add sparsenauty()                                        *
+*       15-Jan-12 : add TLS_ATTR attributes                                  *
+*       17-Dec-15 : extend sortlists_sg() to sort weights                    *
+*                 : add weights to copy_sg() and updatecan_sg()              *
+*       11-Mar-16 : add cleanup_sg().  This can be used in the cleanup       *
+*                   field of the dispatch vector to sort the lists of the    *
+*                   canonical graph, but isn't there by default.             *
+*                                                                            *
+*****************************************************************************/
+
+#define TMP
+
+/*   #define ONE_WORD_SETS  not sure about this!  See notes.txt.  */
+#include "nausparse.h"
+
+    /* macros for hash-codes: */
+#define MASH(l,i) ((((l) ^ 065435) + (i)) & 077777)
+    /* : expression whose long value depends only on long l and int/long i.
+         Anything goes, preferably non-commutative. */
+
+#define CLEANUP(l) ((int)((l) % 077777))
+    /* : expression whose value depends on long l and is less than 077777
+         when converted to int then short.  Anything goes. */
+
+#if  MAXM==1
+#define M 1
+#else
+#define M m
+#endif
+
+#define ACCUM(x,y)   x = (((x) + (y)) & 077777)
+
+static const int fuzz1[] = {037541,061532,005257,026416};
+static const int fuzz2[] = {006532,070236,035523,062437};
+
+#define FUZZ1(x) ((x) ^ fuzz1[(x)&3])
+#define FUZZ2(x) ((x) ^ fuzz2[(x)&3])
+
+/* aproto: header new_nauty_protos.h */
+
+dispatchvec dispatch_sparse =
+  {isautom_sg,testcanlab_sg,updatecan_sg,refine_sg,refine_sg,cheapautom_sg,
+   targetcell_sg,nausparse_freedyn,nausparse_check,init_sg,NULL};
+
+#if !MAXN
+DYNALLSTAT(short,vmark1,vmark1_sz);
+DYNALLSTAT(short,vmark2,vmark2_sz);
+DYNALLSTAT(int,work1,work1_sz);
+DYNALLSTAT(int,work2,work2_sz);
+DYNALLSTAT(int,work3,work3_sz);
+DYNALLSTAT(int,work4,work4_sz);
+DYNALLSTAT(set,snwork,snwork_sz);
+#else
+static TLS_ATTR short vmark1[MAXN];
+static TLS_ATTR short vmark2[MAXN];
+static TLS_ATTR int work1[MAXN];
+static TLS_ATTR int work2[MAXN];
+static TLS_ATTR int work3[MAXN];
+static TLS_ATTR int work4[MAXN];
+static TLS_ATTR set snwork[40*MAXM];
+#endif
+
+static TLS_ATTR short vmark1_val = 32000;
+#define MARK1(i) vmark1[i] = vmark1_val
+#define UNMARK1(i) vmark1[i] = 0
+#define ISMARKED1(i) (vmark1[i] == vmark1_val)
+#define ISNOTMARKED1(i) (vmark1[i] != vmark1_val)
+
+static TLS_ATTR short vmark2_val = 32000;
+#define MARK2(i) vmark2[i] = vmark2_val
+#define UNMARK2(i) vmark2[i] = 0
+#define ISMARKED2(i) (vmark2[i] == vmark2_val)
+#define ISNOTMARKED2(i) (vmark2[i] != vmark2_val)
+
+#if !MAXN
+#define RESETMARKS1 {if (vmark1_val++ >= 32000) \
+    {size_t ij; for (ij=0;ij<vmark1_sz;++ij) vmark1[ij]=0; vmark1_val=1;}}
+#define PREPAREMARKS1(nn) preparemarks1(nn)
+#define RESETMARKS2 {if (vmark2_val++ >= 32000) \
+    {size_t ij; for (ij=0;ij<vmark2_sz;++ij) vmark2[ij]=0; vmark2_val=1;}}
+#define PREPAREMARKS2(nn) preparemarks2(nn)
+#else
+#define RESETMARKS1 {if (vmark1_val++ >= 32000) \
+    {size_t ij; for (ij=0;ij<MAXN;++ij) vmark1[ij]=0; vmark1_val=1;}}
+#define PREPAREMARKS1(nn)
+#define RESETMARKS2 {if (vmark2_val++ >= 32000) \
+    {size_t ij; for (ij=0;ij<MAXN;++ij) vmark2[ij]=0; vmark2_val=1;}}
+#define PREPAREMARKS2(nn)
+#endif
+
+/*****************************************************************************
+*                                                                            *
+*  preparemarks1(N) and preparemarks2(N)                                     *
+*  make vmarks array large enough to mark 0..N-1 and such that               *
+*  the next RESETMARKS command will work correctly                           *
+*                                                                            *
+*****************************************************************************/
+
+#if !MAXN
+static void
+preparemarks1(size_t nn)
+{
+    size_t oldsize;
+    short *oldpos;
+
+    oldsize = vmark1_sz;
+    oldpos = vmark1;
+    DYNALLOC1(short,vmark1,vmark1_sz,nn,"preparemarks");
+    if (vmark1_sz != oldsize || vmark1 != oldpos) vmark1_val = 32000;
+}
+#endif
+
+#if !MAXN
+static void
+preparemarks2(size_t nn)
+{
+    size_t oldsize;
+    short *oldpos;
+
+    oldsize = vmark2_sz;
+    oldpos = vmark2;
+    DYNALLOC1(short,vmark2,vmark2_sz,nn,"preparemarks");
+    if (vmark2_sz != oldsize || vmark2 != oldpos) vmark2_val = 32000;
+}
+#endif
+
+/*****************************************************************************
+*                                                                            *
+*  isautom_sg(g,perm,digraph,m,n) = TRUE iff perm is an automorphism of g    *
+*  (i.e., g^perm = g).  Symmetry is assumed unless digraph = TRUE.           *
+*                                                                            *
+*****************************************************************************/
+
+boolean
+isautom_sg(graph *g, int *p, boolean digraph, int m, int n)
+{
+    int *d,*e;
+    size_t *v;
+    int i,pi,di;
+    size_t vi,vpi,j;
+
+    SG_VDE(g,v,d,e);
+
+    PREPAREMARKS1(n);
+
+    for (i = 0; i < n; ++i)
+    if (p[i] != i || digraph)
+    {
+        pi = p[i];
+        di = d[i];
+        if (d[pi] != di) return FALSE;
+
+        vi = v[i];
+        vpi = v[pi];
+        RESETMARKS1;
+        for (j = 0; j < di; ++j) MARK1(p[e[vi+j]]);
+        for (j = 0; j < di; ++j) if (ISNOTMARKED1(e[vpi+j])) return FALSE;
+    }
+
+    return TRUE;
+}
+
+/*****************************************************************************
+*                                                                            *
+* aresame_sg(g1,g2) = TRUE iff g1 and g2 are identical as labelled digraphs  *
+*                                                                            *
+*****************************************************************************/
+
+boolean
+aresame_sg(sparsegraph *g1, sparsegraph *g2)
+{
+    int *d1,*e1;
+    int *d2,*e2;
+    int n,i,di;
+    size_t vi,*v1,*v2,j;
+
+    n = g1->nv;
+    if (g2->nv != n || g2->nde != g1->nde) return FALSE;
+
+    SG_VDE(g1,v1,d1,e1);
+    SG_VDE(g2,v2,d2,e2);
+
+    PREPAREMARKS1(n);
+
+    for (i = 0; i < n; ++i)
+    {
+        di = d1[i];
+        if (d2[i] != di) return FALSE;
+
+        vi = v1[i];
+        RESETMARKS1;
+        for (j = 0; j < di; ++j) MARK1(e1[vi+j]);
+        vi = v2[i];
+        for (j = 0; j < di; ++j) if (ISNOTMARKED1(e2[vi+j])) return FALSE;
+    }
+
+    return TRUE;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  testcanlab_sg(g,canong,lab,samerows,m,n) compares g^lab to canong,        *
+*  using an ordering which is immaterial since it's only used here.  The     *
+*  value returned is -1,0,1 if g^lab <,=,> canong.  *samerows is set to      *
+*  the number of rows (0..n) of canong which are the same as those of g^lab. *
+*                                                                            *
+*****************************************************************************/
+
+int
+testcanlab_sg(graph *g, graph *canong, int *lab, int *samerows, int m, int n)
+{
+    int *d,*e;
+    int *cd,*ce;
+    int i,k,di,dli;
+    size_t j,vi,vli,*v,*cv;
+    int mina;
+
+    SG_VDE(g,v,d,e);
+    SG_VDE(canong,cv,cd,ce);
+
+#if !MAXN
+    DYNALLOC1(int,work1,work1_sz,n,"testcanlab_sg");
+#endif
+#define INVLAB work1
+
+    PREPAREMARKS1(n);
+
+    for (i = 0; i < n; ++i) INVLAB[lab[i]] = i;
+
+    for (i = 0; i < n; ++i)
+    {
+     /* compare g[lab[i]]^INVLAB to canong[i] */
+        vi = cv[i];
+        di = cd[i];
+        vli = v[lab[i]];
+        dli = d[lab[i]];
+
+        if (di != dli)
+        {
+            *samerows = i;
+            if (di < dli) return -1;
+            return 1;
+        }
+
+        RESETMARKS1;
+        mina = n;
+        for (j = 0; j < di; ++j) MARK1(ce[vi+j]);
+        for (j = 0; j < di; ++j)
+        {
+            k = INVLAB[e[vli+j]];
+            if (ISMARKED1(k))  UNMARK1(k);
+            else if (k < mina) mina = k;
+        }
+        if (mina != n)
+        {
+            *samerows = i;
+            for (j = 0; j < di; ++j)
+            {
+                k = ce[vi+j];
+                if (ISMARKED1(k) && k < mina) return -1;
+            }
+            return 1;
+        }
+    }
+
+    *samerows = n;
+    return 0;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  updatecan_sg(g,canong,lab,samerows,m,n) sets canong = g^lab, assuming     *
+*  the first samerows vertices of canong are ok already.  Also assumes       *
+*  contiguity and ample space in canong.                                     *
+*                                                                            *
+*****************************************************************************/
+
+void
+updatecan_sg(graph *g, graph *canong, int *lab, int samerows, int m, int n)
+{
+    int *d,*e;
+    int *cd,*ce;
+    int i,dli;
+    size_t *v,*cv,vli,j,k;
+    sg_weight *wt,*cwt;
+
+    SWG_VDE(g,v,d,e,wt);
+    SWG_VDE(canong,cv,cd,ce,cwt);
+
+#if !MAXN
+    DYNALLOC1(int,work1,work1_sz,n,"testcanlab_sg");
+#endif
+#define INVLAB work1
+
+    ((sparsegraph*)canong)->nv = n;
+    ((sparsegraph*)canong)->nde = ((sparsegraph*)g)->nde;
+
+    for (i = 0; i < n; ++i) INVLAB[lab[i]] = i;
+
+    if (samerows == 0) k = 0;
+    else               k = cv[samerows-1]+cd[samerows-1];
+
+    for (i = samerows; i < n; ++i)
+    {
+        cv[i] = k;
+        cd[i] = dli = d[lab[i]];
+        vli = v[lab[i]];
+	if (wt)
+	{
+            for (j = 0; j < dli; ++j)
+            {
+		ce[k] = INVLAB[e[vli+j]];
+		cwt[k] = wt[vli+j];
+	        ++k;
+            }
+	}
+	else
+            for (j = 0; j < dli; ++j) ce[k++] = INVLAB[e[vli+j]];
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  comparelab_tr(g,lab1,invlab1,lab2,invlab2,cls,col) compares               *
+*  g^lab1 to g^lab2 and returns -1,0,1 according to the comparison.          *
+*  invlab1[] and invlab2[] are assumed to hold inverses of lab1,lab2.        *
+*                                                                            *
+*****************************************************************************/
+
+int
+comparelab_tr(sparsegraph *g,
+       int *lab1, int *invlab1, int *lab2, int *invlab2, int *cls, int *col)
+{
+    int d1,*e1,d2,*e2;
+    int i,j,k,n,c,end;
+    int mina;
+    
+    n = g->nv;
+    PREPAREMARKS1(n);
+    
+    for (c=0; c<n; c+=cls[c])
+    {
+        if (cls[c] == 1)
+        {
+            end = c+cls[c];
+            for (i = c; i < end; ++i)
+            {
+                e1 = g->e + g->v[lab1[i]];
+                d1 = g->d[lab1[i]];
+                e2 = g->e + g->v[lab2[i]];
+                d2 = g->d[lab2[i]];
+                if (d1 < d2) return -1;
+                else if (d1 > d2) return 1;
+                
+                RESETMARKS1;
+                mina = n;
+                for (j = 0; j < d1; ++j) MARK1(col[invlab1[e1[j]]]);
+                
+                for (j = 0; j < d1; ++j)
+                {
+                    k = col[invlab2[e2[j]]];
+                    if (ISMARKED1(k))  UNMARK1(k);
+                    else if (k < mina) mina = k;
+                }
+                if (mina != n)
+                {
+                    for (j = 0; j < d1; ++j)
+                    {
+                        k = col[invlab1[e1[j]]];
+                        if (ISMARKED1(k) && k < mina) return -1;
+                    }
+                    return 1;
+                }
+            }
+        }
+    }
+    
+    return 0;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  testcanlab_tr(g,canong,lab,invlab,samerows) compares g^lab to canong,     *
+*  using an ordering which is immaterial since it's only used here.  The     *
+*  value returned is -1,0,1 if g^lab <,=,> canong.  *samerows is set to      *
+*  the number of rows (0..n) of canong which are the same as those of g^lab. *
+*  invlab[] is assumed to hold the inverse of lab[]                          *
+*                                                                            *
+*****************************************************************************/
+
+int
+testcanlab_tr(sparsegraph *g, sparsegraph *canong,
+                                  int *lab, int *invlab, int *samerows)
+{
+    int *d,*e;
+    int *cd,*ce;
+    int i,di,dli;
+    int k,n;
+    size_t *v,*cv,vi,vli,j;
+    int mina;
+    
+    SG_VDE(g,v,d,e);
+    SG_VDE(canong,cv,cd,ce);
+    n = g->nv;
+    
+    PREPAREMARKS1(n);
+    
+    for (i = 0; i < n; ++i)
+    {
+            /* compare g[lab[i]]^invlab to canong[i] */
+        vi = cv[i];
+        di = cd[i];
+        vli = v[lab[i]];
+        dli = d[lab[i]];
+            
+        if (di != dli)
+        {
+            *samerows = i;
+            if (di < dli) return -1;
+            return 1;
+        }
+ 
+        RESETMARKS1;
+        mina = n;
+        for (j = 0; j < di; ++j) MARK1(ce[vi+j]);
+
+        for (j = 0; j < di; ++j)
+        {
+             k = invlab[e[vli+j]];
+             if (ISMARKED1(k))  UNMARK1(k);
+             else if (k < mina) mina = k;
+        }
+        if (mina != n)
+        {
+            *samerows = i;
+            for (j = 0; j < di; ++j)
+            {
+                k = ce[vi+j];
+                if (ISMARKED1(k) && k < mina) return -1;
+            }
+            return 1;
+        }
+    }
+ 
+    *samerows = n;
+    return 0;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  updatecan_tr(g,canong,lab,invlab,samerows) sets canong = g^lab,           *
+*  assuming the first samerows vertices of canong are ok already.            *
+*  Also assumes contiguity and ample space in canong.                        *
+*  Assumes invlab[] holds the inverse of lab[]                               *
+*                                                                            *
+*****************************************************************************/
+
+void
+updatecan_tr(sparsegraph *g, sparsegraph *canong,
+                    int *lab, int *invlab, int samerows)
+{
+    int *d,*e;
+    int *cd,*ce;
+    int i,dli,n;
+    size_t *v,*cv,vli,j,k;
+    
+    SG_VDE(g,v,d,e);
+    SG_VDE(canong,cv,cd,ce);
+    n = g->nv;
+    
+    PREPAREMARKS1(n);
+    
+    canong->nv = n;
+    canong->nde = g->nde;
+    
+    if (samerows == 0) k = 0;
+    else               k = cv[samerows-1]+cd[samerows-1];
+    
+    for (i = samerows; i < n; ++i)
+    {
+        cv[i] = k;
+        cd[i] = dli = d[lab[i]];
+        vli = v[lab[i]];
+        for (j = 0; j < dli; ++j) ce[k++] = invlab[e[vli+j]];
+    }
+}
+
+#define SORT_OF_SORT 3
+#define SORT_NAME sortindirect
+#define SORT_TYPE1 int
+#define SORT_TYPE2 int
+#include "sorttemplates.c"
+
+#define SORT_OF_SORT 1
+#define SORT_NAME sortints
+#define SORT_TYPE1 int
+#include "sorttemplates.c"
+
+#define SORT_OF_SORT 2
+#define SORT_NAME sortweights
+#define SORT_TYPE1 int
+#define SORT_TYPE2 sg_weight
+#include "sorttemplates.c"
+
+/*****************************************************************************
+*                                                                            *
+*  init_sg(graph *gin, graph **gout, graph *hin, graph **hout,               *
+*          int *lab, int *ptn, set *active, optionblk *options,              *
+*          int *status, int m, int n)                                        *
+*  Initialise routine for dispatch vector.  This one just makes sure         *
+*  that *hin has enough space.                                               *
+*                                                                            *
+*****************************************************************************/
+
+void
+init_sg(graph *gin, graph **gout, graph *hin, graph **hout, int *lab,
+    int *ptn, set *active, struct optionstruct *options, int *status,
+    int m, int n)
+{
+    sparsegraph *sg,*sh;
+
+    if (options->getcanon)
+    {
+        sg = (sparsegraph*)gin;
+        sh = (sparsegraph*)hin;
+        SG_ALLOC(*sh,sg->nv,sg->nde,"init_sg");
+    }
+    *status = 0;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  cleanup_sg(graph *gin, graph **gout, graph *hin, graph **hout,            *
+*          int *lab, int *ptn, optionblk *options,                           *
+*          statsblk *stats, int m, int n)                                    *
+*  Cleanup routine for dispatch vector.  This one sorts the adjacency        *
+*  lists for the canonical labelling.                                        *
+*                                                                            *
+*****************************************************************************/
+
+void
+cleanup_sg(graph *gin, graph **gout, graph *hin, graph **hout, int *lab,
+           int *ptn, optionblk *options, statsblk *stats, int m, int n)
+{
+    sparsegraph *sg,*sh;
+
+    if (options->getcanon
+        && (stats->errstatus == 0 || stats->errstatus == NAUABORTED))
+    {
+        sh = (sparsegraph*)hin;
+        sortlists_sg(sh);
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  distvals(sparsegraph *sg, int v0, int *dist, int n) sets dist[i]          *
+*  to the distance from v0 to i, for each i, or to n if there is no such     *
+*  distance.  work4[] is used as a queue.                                    *
+*                                                                            *
+*****************************************************************************/
+
+void
+distvals(sparsegraph *g, int v0, int *dist, int n)
+{
+    int *d,*e;
+    int i,head,tail;
+    int di,k;
+    size_t *v,vi,j;
+
+    SG_VDE(g,v,d,e);
+#if !MAXN
+    DYNALLOC1(int,work4,work4_sz,n,"distvals");
+#endif
+#define QUEUE work4
+
+    for (i = 0; i < n; ++i) dist[i] = n;
+
+    QUEUE[0] = v0;
+    dist[v0] = 0;
+
+    head = 0;
+    tail = 1;
+    while (tail < n && head < tail)
+    {
+        i = QUEUE[head++];
+        vi = v[i];
+        di = d[i];
+        for (j = 0; j < di; ++j)
+        {
+            k = e[vi+j];
+            if (dist[k] == n)
+            {
+                dist[k] = dist[i] + 1;
+                QUEUE[tail++] = k;
+            }
+        }
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  refine_sg(g,lab,ptn,level,numcells,count,active,code,m,n) performs a      *
+*  refinement operation on the partition at the specified level of the       *
+*  partition nest (lab,ptn).  *numcells is assumed to contain the number of  *
+*  cells on input, and is updated.  The initial set of active cells (alpha   *
+*  in the paper) is specified in the set active.  Precisely, x is in active  *
+*  iff the cell starting at index x in lab is active.                        *
+*  The resulting partition is equitable if active is correct (see the paper  *
+*  and the Guide).                                                           *
+*  *code is set to a value which depends on the fine detail of the           *
+*  algorithm, but which is independent of the labelling of the graph.        *
+*  count is used for work space.                                             *
+*                                                                            *
+*****************************************************************************/
+
+void
+refine_sg(graph *g, int *lab, int *ptn, int level, int *numcells,
+       int *count, set *active, int *code, int m, int n)
+{
+    int i,j,k,l,v1,v2,v3,isplit;
+    int w1,w2,w3;
+    long longcode;
+    int *d,*e;
+    int size,bigsize,bigpos;
+    int nactive,hitcells;
+    int lj,di,splitv;
+    boolean trivsplit;
+    size_t *v,vi,ii;
+
+    SG_VDE(g,v,d,e);
+
+#if !MAXN
+    DYNALLOC1(int,work1,work1_sz,n,"refine_sg");
+    DYNALLOC1(int,work2,work2_sz,n,"refine_sg");
+    DYNALLOC1(int,work3,work3_sz,n,"refine_sg");
+    DYNALLOC1(int,work4,work4_sz,n,"refine_sg");
+#endif
+#define CELLSTART work1
+#define ACTIVE    work2
+#define HITS      work3
+#define HITCELL   work4
+
+    PREPAREMARKS1(n);
+    PREPAREMARKS2(n);
+
+    longcode = *numcells;
+
+     /* Set ACTIVE[0..nactive-1] = queue of active cell starts */
+
+    nactive = 0;
+    for (i = -1; (i = nextelement(active,m,i)) >= 0;)
+        ACTIVE[nactive++] = i;
+
+    if (nactive == 0)
+    {
+        *code = CLEANUP(longcode);
+        return;
+    }
+
+     /* Set CELLSTART[i] = starting point in lab[] of nontrivial cell
+    containing i, or n if i is a singleton */
+
+    for (i = 0; i < n; )
+    {
+     /* Just here, i is a cell starting position */
+        if (ptn[i] <= level)
+        {
+            CELLSTART[lab[i]] = n;
+            ++i;
+        }
+        else
+        {
+            j = i;
+            do
+            {
+                CELLSTART[lab[i]] = j;
+            } while (ptn[i++] > level);
+        }
+    }
+
+    if (level <= 2 && nactive == 1 && ptn[ACTIVE[0]] <= level
+                   && *numcells <= n/8)
+    {
+        isplit = ACTIVE[--nactive];
+        DELELEMENT(active,isplit);
+    
+        distvals((sparsegraph*)g,lab[isplit],HITS,n);
+
+        for (v1 = 0; v1 < n; )
+        {
+            if (ptn[v1] <= level)
+            {
+                ++v1;
+                continue;
+            }
+
+            longcode = MASH(longcode,v1);
+            w1 = HITS[lab[v1]];
+
+            v2 = v1+1;
+            while (ptn[v2-1] > level && HITS[lab[v2]] == w1) ++v2;
+
+            if (ptn[v2-1] <= level)
+            {
+                v1 = v2;
+                continue;
+            }
+
+            w2 = NAUTY_INFINITY;
+            v3 = j = v2;
+
+            do
+            {
+                lj = lab[j];
+                w3 = HITS[lj];
+                if (w3 == w1)
+                {
+                    lab[j] = lab[v3];
+                    lab[v3] = lab[v2];
+                    lab[v2] = lj;
+                    ++v2;
+                    ++v3;
+                }
+                else if (w3 == w2)
+                {
+                    lab[j] = lab[v3];
+                    lab[v3] = lj;
+                    ++v3;
+                }
+                else if (w3 < w1)
+                {
+                    lab[j] = lab[v2];
+                    lab[v2] = lab[v1];
+                    lab[v1] = lj;
+                    v3 = v2 + 1;
+                    v2 = v1 + 1;
+                    w2 = w1;
+                    w1 = w3;
+                }
+                else if (w3 < w2)
+                {
+                    lab[j] = lab[v2];
+                    lab[v2] = lj;
+                    v3 = v2 + 1;
+                    w2 = w3;
+                }
+            } while (ptn[j++] > level);
+    
+            longcode = MASH(longcode,w2);
+            longcode = MASH(longcode,v2);
+            if (j != v2)   /* At least two fragments
+                                * v1..v2-1 = w1; v2..v3-1 = w2  */
+            {
+                if (v2 == v1+1)
+                    CELLSTART[lab[v1]] = n;
+    
+                if (v3 == v2+1)
+                    CELLSTART[lab[v2]] = n;
+                else
+                    for (k = v2; k < v3; ++k)
+                        CELLSTART[lab[k]] = v2;
+                ++*numcells;
+                ptn[v2-1] = level;
+    
+                if (j == v3)
+                {
+                 /* Two fragments only */
+                    if (v2-v1 <= v3-v2 && !ISELEMENT(active,v1))
+                    {
+                        ADDELEMENT(active,v1);
+                        ACTIVE[nactive++] = v1;
+                    }
+                    else
+                    {
+                        ADDELEMENT(active,v2);
+                        ACTIVE[nactive++] = v2;
+                    }
+                }
+                else 
+                {
+                 /* Extra fragments: v3..j-1 > w2 */
+                    sortindirect(lab+v3,HITS,j-v3);
+                    ACTIVE[nactive++] = v2;
+                    ADDELEMENT(active,v2);
+                    if (v2-v1 >= v3-v2)
+                    {
+                        bigpos = -1;
+                        bigsize = v2-v1;
+                    }
+                    else
+                    {
+                        bigpos = nactive-1;
+                        bigsize = v3-v2;
+                    }
+                    for (k = v3-1; k < j-1;)
+                    {
+                        ptn[k] = level;
+                        longcode = MASH(longcode,k);
+                        ++*numcells;
+                        l = k+1;
+                        ADDELEMENT(active,l);
+                        ACTIVE[nactive++] = l;
+                        w3 = HITS[lab[l]];
+                        for (k = l; k < j-1
+                                    && HITS[lab[k+1]] == w3; ++k)
+                            CELLSTART[lab[k+1]] = l;
+                        size = k-l+1;
+                        if (size == 1)
+                            CELLSTART[lab[l]] = n;
+                        else
+                        {
+                            CELLSTART[lab[l]] = l;
+                            if (size > bigsize)
+                            {
+                                bigsize = size;
+                                bigpos = nactive-1;
+                            }
+                        }
+                    }
+    
+                    if (bigpos >= 0 && !ISELEMENT(active,v1))
+                    {
+                        longcode = MASH(longcode,bigpos);
+                        DELELEMENT(active,ACTIVE[bigpos]);
+                        ADDELEMENT(active,v1);
+                        ACTIVE[bigpos] = v1;
+                    }
+                }
+            }
+            v1 = j;
+        }
+    }
+
+     /* Iterate until complete */
+    while (nactive > 0 && *numcells < n)
+    {
+        for (i = 0; i < nactive && i < 10; ++i)
+            if (ptn[ACTIVE[i]] <= level) break;
+
+        if (i < nactive && i < 10)
+        {
+            trivsplit = TRUE;
+            isplit = ACTIVE[i];
+            ACTIVE[i] = ACTIVE[--nactive];
+        }
+        else
+        {
+            isplit = ACTIVE[--nactive];
+            trivsplit = ptn[isplit] <= level;
+        }
+
+        DELELEMENT(active,isplit);
+        longcode = MASH(longcode,isplit);
+    
+        if (trivsplit)
+        {
+            RESETMARKS1;
+            RESETMARKS2;
+            hitcells = 0;
+            splitv = lab[isplit];
+            vi = v[splitv];
+            di = d[splitv];
+            for (ii = 0; ii < di; ++ii)
+            {
+                j = e[vi+ii];
+                MARK2(j);
+                k = CELLSTART[j];
+                if (k != n && ISNOTMARKED1(k))
+                {
+                    MARK1(k);
+                    HITCELL[hitcells++] = k;
+                }
+            }
+
+            if (hitcells > 1) sortints(HITCELL,hitcells);
+	    longcode = MASH(longcode,hitcells);
+
+         /* divide cells according to which vertices are hit */
+
+            for (i = 0; i < hitcells; ++i)
+            {
+                j = v1 = v2 = HITCELL[i];
+                longcode = MASH(longcode,v2);
+                k = 0;
+                do
+                {
+                    lj = lab[j];
+                    if (ISMARKED2(lj))
+                        HITS[k++] = lj;
+                    else
+                        lab[v2++] = lj;
+                } while (ptn[j++] > level);
+
+                longcode = MASH(longcode,k);
+                v3 = v2;
+                while (--k >= 0)
+                {
+                    j = HITS[k];
+                    CELLSTART[j] = v2;
+                    lab[v3++] = j;
+                }
+
+                if (v2 != v3 && v2 != v1)
+                {
+                    ++*numcells;
+                    if (v2 == v1+1) CELLSTART[lab[v1]] = n;
+                    if (v3 == v2+1) CELLSTART[lab[v2]] = n;
+                    ptn[v2-1] = level;
+                    longcode = MASH(longcode,v2);
+                    if (v2-v1 <= v3-v2 && !ISELEMENT(active,v1))
+                    {
+                        ADDELEMENT(active,v1);
+                        ACTIVE[nactive++] = v1;
+                    }
+                    else
+                    {
+                        ADDELEMENT(active,v2);
+                        ACTIVE[nactive++] = v2;
+                    }
+                }
+            }
+        }
+        else  /* non-trivial splitting */
+        {
+         /* isplit is the start of the splitting cell.
+            Set HITS[i] = hits of i for i in non-trivial cells,
+            HITCELL[0..hitcells-1] = starts of hit non-trivial cells */
+
+            RESETMARKS1;
+            hitcells = 0;
+            do
+            {
+                vi = v[lab[isplit]];
+                di = d[lab[isplit]];
+                for (ii = 0; ii < di; ++ii)
+                {
+                    j = e[vi+ii];
+                    k = CELLSTART[j];
+                    if (k != n)
+                    {
+                        if (ISNOTMARKED1(k))
+                        {
+                            MARK1(k);
+                            HITCELL[hitcells++] = k;
+                            do
+                            {
+                                HITS[lab[k]] = 0;
+                            } while (ptn[k++] > level);
+                        }
+                        ++HITS[j];
+                    }
+                }
+            } while (ptn[isplit++] > level);
+    
+            if (hitcells > 1) sortints(HITCELL,hitcells);
+    
+         /* divide cells according to hit counts */
+    
+            longcode = MASH(longcode,hitcells);
+            for (i = 0; i < hitcells; ++i)
+            {
+                v1 = HITCELL[i];
+                w1 = HITS[lab[v1]];
+		longcode = MASH(longcode,v1);
+
+                v2 = v1+1;
+                while (ptn[v2-1] > level && HITS[lab[v2]] == w1) ++v2;
+
+                if (ptn[v2-1] <= level) continue;
+                w2 = NAUTY_INFINITY;
+                v3 = j = v2;
+    
+                do
+                {
+                    lj = lab[j];
+                    w3 = HITS[lj];
+                    if (w3 == w1)
+                    {
+                        lab[j] = lab[v3];
+                        lab[v3] = lab[v2];
+                        lab[v2] = lj;
+                        ++v2;
+                        ++v3;
+                    }
+                    else if (w3 == w2)
+                    {
+                        lab[j] = lab[v3];
+                        lab[v3] = lj;
+                        ++v3;
+                    }
+                    else if (w3 < w1)
+                    {
+                        lab[j] = lab[v2];
+                        lab[v2] = lab[v1];
+                        lab[v1] = lj;
+                        v3 = v2 + 1;
+                        v2 = v1 + 1;
+                        w2 = w1;
+                        w1 = w3;
+                    }
+                    else if (w3 < w2)
+                    {
+                        lab[j] = lab[v2];
+                        lab[v2] = lj;
+                        v3 = v2 + 1;
+                        w2 = w3;
+                    }
+                } while (ptn[j++] > level);
+    
+                longcode = MASH(longcode,w1);
+                longcode = MASH(longcode,v2);
+                if (j != v2)   /* At least two fragments
+                                * v1..v2-1 = w1; v2..v3-1 = w2  */
+                {
+                    if (v2 == v1+1)
+                        CELLSTART[lab[v1]] = n;
+    
+                    if (v3 == v2+1)
+                        CELLSTART[lab[v2]] = n;
+                    else
+                        for (k = v2; k < v3; ++k)
+                            CELLSTART[lab[k]] = v2;
+                    ++*numcells;
+                    ptn[v2-1] = level;
+    
+                    if (j == v3)
+                    {
+                     /* Two fragments only */
+                        if (v2-v1 <= v3-v2 && !ISELEMENT(active,v1))
+                        {
+                            ADDELEMENT(active,v1);
+                            ACTIVE[nactive++] = v1;
+                        }
+                        else
+                        {
+                            ADDELEMENT(active,v2);
+                            ACTIVE[nactive++] = v2;
+                        }
+                    }
+                    else 
+                    {
+                     /* Extra fragments: v3..j-1 > w2 */
+                        longcode = MASH(longcode,v3);
+                        sortindirect(lab+v3,HITS,j-v3);
+                        ACTIVE[nactive++] = v2;
+                        ADDELEMENT(active,v2);
+                        if (v2-v1 >= v3-v2)
+                        {
+                            bigpos = -1;
+                            bigsize = v2-v1;
+                        }
+                        else
+                        {
+                            bigpos = nactive-1;
+                            bigsize = v3-v2;
+                            longcode = MASH(longcode,bigsize);
+                        }
+                        for (k = v3-1; k < j-1;)
+                        {
+                            ptn[k] = level;
+                            ++*numcells;
+                            l = k+1;
+                            ADDELEMENT(active,l);
+                            ACTIVE[nactive++] = l;
+                            w3 = HITS[lab[l]];
+                            longcode = MASH(longcode,w3);
+                            for (k = l; k < j-1
+                                        && HITS[lab[k+1]] == w3; ++k)
+                                CELLSTART[lab[k+1]] = l;
+                            size = k-l+1;
+                            if (size == 1)
+                                CELLSTART[lab[l]] = n;
+                            else
+                            {
+                                CELLSTART[lab[l]] = l;
+                                if (size > bigsize)
+                                {
+                                    bigsize = size;
+                                    bigpos = nactive-1;
+                                }
+                            }
+                        }
+    
+                        if (bigpos >= 0 && !ISELEMENT(active,v1))
+                        {
+                            DELELEMENT(active,ACTIVE[bigpos]);
+                            ADDELEMENT(active,v1);
+                            ACTIVE[bigpos] = v1;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    longcode = MASH(longcode,*numcells);
+    *code = CLEANUP(longcode);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  cheapautom_sg(ptn,level,digraph,n) returns TRUE if the partition at the   *
+*  specified level in the partition nest (lab,ptn) {lab is not needed here}  *
+*  satisfies a simple sufficient condition for its cells to be the orbits of *
+*  some subgroup of the automorphism group.  Otherwise it returns FALSE.     *
+*  It always returns FALSE if digraph!=FALSE.                                *
+*                                                                            *
+*  nauty assumes that this function will always return TRUE for any          *
+*  partition finer than one for which it returns TRUE.                       *
+*                                                                            *
+*****************************************************************************/
+
+boolean
+cheapautom_sg(int *ptn, int level, boolean digraph, int n)
+{
+    int i,k,nnt;
+
+    if (digraph) return FALSE;
+
+    k = n;
+    nnt = 0;
+    for (i = 0; i < n; ++i)
+    {
+        --k;
+        if (ptn[i] > level)
+        {
+            ++nnt;
+            while (ptn[++i] > level) {}
+        }
+    }
+
+    return (k <= nnt + 1 || k <= 4); 
+}
+
+/*****************************************************************************
+*                                                                            *
+*  bestcell_sg(g,lab,ptn,level,tc_level,m,n) returns the index in lab of     *
+*  the start of the "best non-singleton cell" for fixing.  If there is no    *
+*  non-singleton cell it returns n.                                          *
+*  This implementation finds the first cell which is non-trivially joined    *
+*  to the greatest number of other cells, assuming equitability.             *
+*  This is not good for digraphs!                                            *
+*                                                                            *
+*****************************************************************************/
+
+static int
+bestcell_sg(graph *g, int *lab, int *ptn, int level,
+                                          int tc_level, int m, int n)
+{
+    int nnt;
+    int *d,*e;
+    int i,k,di;
+    int *work1b;
+    int maxcnt;
+    size_t *v,vi,j;
+
+    SG_VDE(g,v,d,e);
+
+#if !MAXN 
+    DYNALLOC1(int,work1,work1_sz,n,"bestcell_sg"); 
+    DYNALLOC1(int,work2,work2_sz,n,"bestcell_sg"); 
+    DYNALLOC1(int,work3,work3_sz,n,"bestcell_sg"); 
+    DYNALLOC1(int,work4,work4_sz,n,"bestcell_sg"); 
+#endif
+    work1b = work1 + (n/2);
+#define START    work1
+#define SIZE     work1b
+#define NNTCELL  work2
+#define HITS     work3
+#define COUNT    work4
+
+   /* find non-singleton cells: put starts in START[0..nnt-1],
+      sizes in SIZE[0..nnt-1].
+      Also NNTCELL[i] = n if {i} is a singelton, else index of
+      nontriv cell containing i. */
+
+    i = nnt = 0;
+
+    while (i < n)
+    {
+        if (ptn[i] > level)
+        {
+            START[nnt] = i;
+            j = i;
+            do
+                NNTCELL[lab[j]] = nnt;
+            while (ptn[j++] > level);
+            SIZE[nnt] = j-i;
+            ++nnt;
+            i = j;
+        }
+        else
+        {
+            NNTCELL[lab[i]] = n;
+            ++i;
+        }
+    }
+
+    if (nnt == 0) return n;
+
+     /* set COUNT[i] to # non-trivial neighbours of n.s. cell i */
+
+    for (i = 0; i < nnt; ++i) HITS[i] = COUNT[i] = 0;
+
+    for (i = 0; i < nnt; ++i)
+    {
+        vi = v[lab[START[i]]];
+        di = d[lab[START[i]]];
+
+        for (j = 0; j < di; ++j)
+        {
+            k = NNTCELL[e[vi+j]];
+            if (k != n) ++HITS[k];
+        }
+        for (j = 0; j < di; ++j)
+        {
+            k = NNTCELL[e[vi+j]];
+            if (k != n)
+            {
+                if (HITS[k] > 0 && HITS[k] < SIZE[k]) ++COUNT[i];
+                HITS[k] = 0;
+            }
+        }
+    }
+
+     /* find first greatest bucket value */
+
+    j = 0;
+    maxcnt = COUNT[0];
+    for (i = 1; i < nnt; ++i)
+        if (COUNT[i] > maxcnt)
+        {
+            j = i;
+            maxcnt = COUNT[i];
+        }
+
+    return (int)START[j];
+}
+/*****************************************************************************
+*                                                                            *
+*  targetcell_sg(g,lab,ptn,level,tc_level,digraph,hint,m,n) returns the      *
+*  index in lab of the next cell to split.                                   *
+*  hint is a suggestion for the answer, which is obeyed if it is valid.      *
+*  Otherwise we use bestcell() up to tc_level and the first non-trivial      *
+*  cell after that.                                                          *
+*                                                                            *
+*****************************************************************************/
+
+int
+targetcell_sg(graph *g, int *lab, int *ptn, int level, int tc_level,
+       boolean digraph, int hint, int m, int n)
+{
+    int i;
+
+    if (hint >= 0 && ptn[hint] > level &&
+                     (hint == 0 || ptn[hint-1] <= level))
+        return hint;
+    else if (level <= tc_level)
+        return bestcell_sg(g,lab,ptn,level,tc_level,m,n);
+    else
+    {
+        for (i = 0; i < n && ptn[i] <= level; ++i) {}
+        return (i == n ? 0 : i);
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  sortlists_sg(g) sorts the adjacency lists into numerical order            *
+*                                                                            *
+*****************************************************************************/
+
+void
+sortlists_sg(sparsegraph *g)
+{
+    int *d,*e;
+    int n,i;
+    size_t *v;
+    sg_weight *wt;
+
+    SWG_VDE(g,v,d,e,wt);
+    n = g->nv;
+
+    if (wt)
+    {
+        for (i = 0; i < n; ++i)
+            if (d[i] > 1) sortweights(e+v[i],wt+v[i],d[i]);
+    }
+    else
+    {
+        for (i = 0; i < n; ++i)
+            if (d[i] > 1) sortints(e+v[i],d[i]);
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  put_sg(f,sg,digraph,linelength) writes the sparse graph to file f using   *
+*  at most linelength characters per line.  If digraph then all directed     *
+*  edges are written; else one v-w for w>=v is written.                      *
+*                                                                            *
+*****************************************************************************/
+
+void
+put_sg(FILE *f, sparsegraph *sg, boolean digraph, int linelength)
+{
+    int *d,*e;
+    int n,di;
+    int i,curlen,slen;
+    size_t *v,vi,j;
+    char s[12];
+
+    SG_VDE(sg,v,d,e);
+    n = sg->nv;
+
+    for (i = 0; i < n; ++i)
+    {
+        vi = v[i];
+        di = d[i];
+        if (di == 0) continue;
+        slen = itos(i+labelorg,s);
+        putstring(f,s);
+        putstring(f," :");
+        curlen = slen + 2;
+
+        for (j = 0; j < di; ++j)
+        {
+            if (!digraph && e[vi+j] < i) continue;
+            slen = itos(e[vi+j]+labelorg,s);
+            if (linelength && curlen + slen + 1 >= linelength)
+            {
+                putstring(f,"\n ");
+                curlen = 2;
+            }
+            PUTC(' ',f);
+            putstring(f,s);
+            curlen += slen + 1;
+        }
+        PUTC('\n',f);
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  sg_to_nauty(sg,g,reqm,&m) creates a nauty-format graph from a sparse      *
+*  graph.  reqm is the required m value (computed from n if reqm=0), and     *
+*  m is the actual value used.  g is dynamically generated if NULL is given. *
+*  A pointer to g is returned.                                               *
+*                                                                            *
+*****************************************************************************/
+
+graph*
+sg_to_nauty(sparsegraph *sg, graph *g, int reqm, int *pm)
+{
+    int *d,*e;
+    int m,n,i,di;
+    size_t *v,vi,j;
+    set *gi;
+
+    SG_VDE(sg,v,d,e);
+    n = sg->nv;
+    if (reqm != 0 && reqm*WORDSIZE < n)
+    {
+        fprintf(ERRFILE,"sg_to_nauty: reqm is impossible\n");
+        exit(1);
+    }
+
+    if (reqm != 0) m = reqm;
+    else           m = (n+WORDSIZE-1)/WORDSIZE;
+
+    *pm = m;
+
+    if (g == NULL)
+    {
+        if ((g = (graph*)ALLOCS(n,m*sizeof(graph))) == NULL)
+        {
+            fprintf(ERRFILE,"sg_to_nauty: malloc failed\n");
+            exit(1);
+        }
+    }
+
+    for (i = 0, gi = g; i < n; ++i, gi += m)
+    {
+        vi = v[i];
+        di = d[i];
+        EMPTYSET(gi,m);
+        for (j = 0; j < di; ++j) ADDELEMENT(gi,e[vi+j]);
+    }
+
+    return g;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  copy_sg(sg1,sg2) makes a copy of sg1 into sg2.                            *
+*  If sg2 is not NULL, it is assumed that the vlen,dlen,elen fields are      *
+*  correct and v,d,e are dynamically allocated (or NULL); they are           *
+*  reallocated if necessary.  If sg2==NULL, a new structure is allocated.    *
+*  A pointer to the copy is returned.                                        *
+*  The new graph e component is the same, no compression is done.            *
+*                                                                            *
+*****************************************************************************/
+
+sparsegraph*
+copy_sg(sparsegraph *sg1, sparsegraph *sg2)
+{
+    int *d1,*e1,*d2,*e2;
+    int i,n;
+    size_t *v1,*v2,k;
+    sg_weight *wt1,*wt2;
+
+    if (!sg2)
+    {
+        if ((sg2 = (sparsegraph*)ALLOCS(1,sizeof(sparsegraph))) == NULL)
+        {
+            fprintf(ERRFILE,"copy_sg: malloc failed\n");
+            exit(1);
+        }
+        SG_INIT(*sg2);
+    }
+
+    SWG_VDE(sg1,v1,d1,e1,wt1);
+
+    n = sg1->nv; 
+
+    k = 0;
+    for (i = 0; i < n; ++i)
+       if (v1[i]+d1[i]>k) k = v1[i] + d1[i];
+
+    if (wt1)
+        SWG_ALLOC(*sg2,n,k,"copy_sg malloc");
+    else
+    {
+        SG_ALLOC(*sg2,n,k,"copy_sg malloc");
+	DYNFREE(sg2->w,sg2->wlen);
+    }
+    SWG_VDE(sg2,v2,d2,e2,wt2);
+
+    sg2->nv = n;
+    sg2->nde = sg1->nde;
+    memcpy(v2,v1,n*sizeof(size_t));
+    memcpy(d2,d1,n*sizeof(int));
+    memcpy(e2,e1,k*sizeof(int));
+    if (wt1) memcpy(wt2,wt1,k*sizeof(sg_weight));
+
+    return sg2;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  nauty_to_sg(g,sg,m,n) creates a sparse graph from a nauty format graph    *
+*  If sg is not NULL, it is assumed that the vlen,dlen,elen fields are       *
+*  correct and v,d,e are dynamically allocated (or NULL); they are           *
+*  reallocated if necessary.  If sg==NULL, a new structure is allocated.     *
+*  A pointer to the sparse graph is returned.                                *
+*                                                                            *
+*****************************************************************************/
+
+sparsegraph*
+nauty_to_sg(graph *g, sparsegraph *sg, int m, int n)
+{
+    int *d,*e;
+    int i,k;
+    set *gi;
+    size_t j,*v,nde;
+
+    if (!sg)
+    {
+        if ((sg = (sparsegraph*)ALLOCS(1,sizeof(sparsegraph))) == NULL)
+        {
+            fprintf(ERRFILE,"nauty_to_sg: malloc failed\n");
+            exit(1);
+        }
+        SG_INIT(*sg);
+    }
+
+    nde = 0;
+    for (gi = g + (size_t)m*(size_t)n; --gi >= g; )
+        if (*gi != 0) nde += POPCOUNT(*gi);
+
+    sg->nv = n;
+    sg->nde = nde;
+
+    SG_ALLOC(*sg,n,nde,"nauty_to_sg");
+
+    SG_VDE(sg,v,d,e);
+
+    j = 0;
+    for (i = 0, gi = g; i < n; ++i, gi += m)
+    {
+        v[i] = j;
+        for (k = -1; (k = nextelement(gi,m,k)) >= 0; )
+            e[j++] = k;
+        d[i] = j - v[i];
+    }
+
+    return sg;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  distances_sg() assigns to each vertex v a value depending on the number   *
+*  of vertices at each distance from v, and what cells they lie in.          *
+*  If we find any cell which is split in this manner, we don't try any       *
+*  further cells.                                                            *
+*                                                                            *
+*****************************************************************************/
+
+void
+distances_sg(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+         int *invar, int invararg, boolean digraph, int m, int n)
+{
+    int *d,*e;
+    int i,k,dlim,wt;
+    int di;
+    int cell1,cell2,iv,liv,kcode;
+    int head,tail;
+    long longcode;
+    size_t *v,vi,j;
+    boolean success;
+
+    SG_VDE(g,v,d,e);
+
+#if !MAXN
+    DYNALLOC1(int,work1,work1_sz,n,"distances_sg");
+    DYNALLOC1(int,work4,work4_sz,n,"distances_sg");
+    DYNALLOC1(int,work3,work3_sz,n,"distances_sg");
+#endif
+#define CELLCODE work1
+#define QUEUE work4
+#define DIST work3
+
+    for (i = n; --i >= 0;) invar[i] = 0;
+
+    wt = 1;
+    for (i = 0; i < n; ++i)
+    {
+        CELLCODE[lab[i]] = FUZZ1(wt);
+        if (ptn[i] <= level) ++wt;
+    }
+
+    if (invararg > n || invararg == 0) dlim = n;
+    else                               dlim = invararg+1;
+
+    success = FALSE;
+    for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+    {
+        for (cell2 = cell1; ptn[cell2] > level; ++cell2) {}
+        if (cell2 == cell1) continue;
+
+        for (iv = cell1; iv <= cell2; ++iv)
+        {
+            liv = lab[iv];
+            QUEUE[0] = liv;
+            DIST[liv] = 0;
+            RESETMARKS1;
+            MARK1(liv);
+            longcode = 0;
+            head = 0;
+            tail = 1;
+            
+            while (tail < n && head < tail)
+            {
+                i = QUEUE[head++];
+                if (DIST[i] >= dlim) break;
+                vi = v[i];
+                di = d[i];
+
+                for (j = 0; j < di; ++j)
+                {
+                    k = e[vi+j];
+                    if (ISNOTMARKED1(k))
+                    {
+                        MARK1(k);
+                        DIST[k] = DIST[i] + 1;
+                        kcode = DIST[k]+CELLCODE[k];
+                        ACCUM(longcode,FUZZ1(kcode));
+                        QUEUE[tail++] = k;
+                    }
+                }
+            }
+            invar[liv] = CLEANUP(longcode);
+            if (invar[liv] != invar[lab[cell1]]) success = TRUE;
+        }
+        if (success) break;
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  adjacencies_sg() assigns to each vertex v a code depending on which cells *
+*  it is joined to and from, and how many times.  It is intended to provide  *
+*  better partitioning that the normal refinement routine for digraphs.      *
+*  It will not help with undirected graphs in nauty at all.                  *
+*                                                                            *
+*****************************************************************************/
+
+void
+adjacencies_sg(graph *g, int *lab, int *ptn, int level, int numcells,
+               int tvpos, int *invar, int invararg, boolean digraph,
+               int m, int n)
+{
+    int *d,*e;
+    int vwt,wwt;
+    int *ei,di,i;
+    size_t *v,j;
+
+    SG_VDE(g,v,d,e);
+
+#if !MAXN
+    DYNALLOC1(int,work2,work2_sz,n,"adjacencies_sg");
+#endif
+
+    vwt = 1;
+    for (i = 0; i < n; ++i)
+    {
+        work2[lab[i]] = vwt;
+        if (ptn[i] <= level) ++vwt;
+        invar[i] = 0;
+    }
+
+    for (i = 0; i < n; ++i)
+    {
+        vwt = FUZZ1(work2[i]);
+        wwt = 0;
+        di = d[i];
+        ei = e + v[i];
+        for (j = 0; j < di; ++j)
+        {
+            ACCUM(wwt,FUZZ2(work2[ei[j]]));
+            ACCUM(invar[ei[j]],vwt);
+        }
+        ACCUM(invar[i],wwt);
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  sparsenauty(g,lab,ptn,orbits,&options,&stats,h)                           *
+*  is a slightly simplified interface to nauty().  It allocates enough       *
+*  workspace for 20 automorphisms and checks that the sparsegraph dispatch    *
+*  vector is in use.                                                         *
+*                                                                            *
+*****************************************************************************/
+
+void
+sparsenauty(sparsegraph *g, int *lab, int *ptn, int *orbits,
+            optionblk *options, statsblk *stats, sparsegraph *h)
+{
+    int m,n;
+
+    if (options->dispatch != &dispatch_sparse)
+    {
+        fprintf(ERRFILE,"Error: sparsenauty() needs standard options block\n");
+        exit(1);
+    }
+
+    n = g->nv;
+    m = SETWORDSNEEDED(n);
+
+#if !MAXN
+    DYNALLOC1(set,snwork,snwork_sz,2*60*m,"densenauty malloc");
+#endif
+
+    nauty((graph*)g,lab,ptn,NULL,orbits,options,stats,
+          snwork,2*60*m,m,n,(graph*)h);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  nausparse_check() checks that this file is compiled compatibly with the   *
+*  given parameters.   If not, call exit(1).                                 *
+*                                                                            *
+*****************************************************************************/
+
+void
+nausparse_check(int wordsize, int m, int n, int version)
+{
+    if (wordsize != WORDSIZE)
+    {
+        fprintf(ERRFILE,"Error: WORDSIZE mismatch in nausparse.c\n");
+        exit(1);
+    }
+
+#if MAXN
+    if (m > MAXM)
+    {
+        fprintf(ERRFILE,"Error: MAXM inadequate in nausparse.c\n");
+        exit(1);
+    }
+
+    if (n > MAXN)
+    {
+        fprintf(ERRFILE,"Error: MAXN inadequate in nausparse.c\n");
+        exit(1);
+    }
+#endif
+
+    if (version < NAUTYREQUIRED)
+    {
+        fprintf(ERRFILE,"Error: nausparse.c version mismatch\n");
+        exit(1);
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  nausparse_freedyn() - free the dynamic memory in this module              *
+*                                                                            *
+*****************************************************************************/
+
+void
+nausparse_freedyn(void)
+{
+#if !MAXN
+    DYNFREE(vmark1,vmark1_sz);
+    DYNFREE(vmark2,vmark2_sz);
+    DYNFREE(work1,work1_sz);
+    DYNFREE(work2,work2_sz);
+    DYNFREE(work3,work3_sz);
+    DYNFREE(work4,work4_sz);
+    DYNFREE(snwork,snwork_sz);
+#endif
+}
diff --git a/lib/nauty/nausparse.h b/lib/nauty/nausparse.h
new file mode 100644
index 0000000..b432ca8
--- /dev/null
+++ b/lib/nauty/nausparse.h
@@ -0,0 +1,128 @@
+/* nausparse.h : header file for sparse digraphs, nauty 2.6 */
+/* This version allows only simple graphs with loops but
+ * contains the data structures for weights on the edges
+ * even though they aren't implemented yet. */
+
+/*****************************************************************************
+*                                                                            *
+*   Copyright (1984-2016) Brendan McKay.  All rights reserved.               *
+*   Subject to the waivers and disclaimers in nauty.h.                       *
+*                                                                            *
+*   CHANGE HISTORY                                                           *
+*       10-Nov-09 : removed types shortish and permutation                   *
+*       20-May-10 : make some fields type size_t                             *
+*       23-May-10 : add sparsenauty()                                        *
+*        3-Jun-10 : add *_tr procedures used by Traces                       *
+*       30-Jun-10 : add DEFAULTOPTIONS_SPARSEDIGRAPH()                       *
+*       18-Aug-12 : fix SG_DECL initialization order                         *
+*       18-Jan-13 : add usercanonproc to default options                     *
+*       17-Dec-15 : add macros for weighted graphs                           *
+*                                                                            *
+*****************************************************************************/
+
+#ifndef  _NAUSPARSE_H_    /* only process this file once */
+#define  _NAUSPARSE_H_
+
+#include "nauty.h"
+
+#ifndef SG_WEIGHT
+#define SG_WEIGHT int
+#define SG_WEIGHT_FMT "%d"
+#define SG_MINWEIGHT (-NAUTY_INFINITY)
+#endif
+typedef SG_WEIGHT sg_weight;
+
+#define CHECK_SWG(sg,id) do { if ((sg)->w) { fprintf(stderr, \
+ ">E procedure %s does not accept weighted graphs\n",id); exit(1); } } while (0)
+
+typedef struct
+{
+    size_t nde;  /* Number of directed edges (loops contribute only 1) */
+    size_t *v;   /* Array of indexes into e[*] */
+    int nv;      /* Number of vertices */
+    int *d;      /* Array with out-degree of each vertex */
+    int *e;      /* Array to hold lists of neighbours */
+    sg_weight *w;      /* Not implemented, should be NULL. */
+    size_t vlen,dlen,elen,wlen;  /* Sizes of arrays in units of type */
+} sparsegraph;
+
+
+#define SG_VDE(sgp,vv,dd,ee) do { vv = ((sparsegraph*)(sgp))->v; \
+  dd = ((sparsegraph*)(sgp))->d; ee = ((sparsegraph*)(sgp))->e; } while(0)
+#define SWG_VDE(sgp,vv,dd,ee,ww) do { vv = ((sparsegraph*)(sgp))->v; \
+  dd = ((sparsegraph*)(sgp))->d; ee = ((sparsegraph*)(sgp))->e; \
+  ww = ((sparsegraph*)(sgp))->w; } while(0)
+#define SG_INIT(sg) do { (sg).v = NULL; (sg).d = (sg).e = (sg).w = NULL; \
+   (sg).vlen = (sg).dlen = (sg).elen = (sg).wlen = 0; } while(0)
+#define SWG_INIT SG_INIT
+#define SG_ALLOC(sg,nlen,ndelen,msg) do { \
+   DYNALLOC1(size_t,(sg).v,(sg).vlen,nlen,msg); \
+   DYNALLOC1(int,(sg).d,(sg).dlen,nlen,msg); \
+   DYNALLOC1(int,(sg).e,(sg).elen,ndelen,msg); \
+} while (0)
+#define SWG_ALLOC(sg,nlen,ndelen,msg) do { \
+   DYNALLOC1(size_t,(sg).v,(sg).vlen,nlen,msg); \
+   DYNALLOC1(int,(sg).d,(sg).dlen,nlen,msg); \
+   DYNALLOC1(int,(sg).e,(sg).elen,ndelen,msg); \
+   DYNALLOC1(sg_weight,(sg).w,(sg).wlen,ndelen,msg); \
+} while (0)
+#define SG_FREE(sg) do { \
+   DYNFREE((sg).v,(sg).vlen); \
+   DYNFREE((sg).d,(sg).dlen); \
+   DYNFREE((sg).e,(sg).elen); \
+   if ((sg).w) DYNFREE((sg).w,(sg).wlen); } while (0)
+#define SWG_FREE SG_FREE
+
+#define SG_DECL(sg) sparsegraph sg = {0,NULL,0,NULL,NULL,NULL,0,0,0,0}
+#define SWG_DECL SG_DECL
+
+#define DEFAULTOPTIONS_SPARSEGRAPH(options) optionblk options = \
+ {0,FALSE,FALSE,FALSE,TRUE,FALSE,CONSOLWIDTH, \
+  NULL,NULL,NULL,NULL,NULL,NULL,NULL,100,0,1,0,&dispatch_sparse,FALSE,NULL}
+#define DEFAULTOPTIONS_SPARSEDIGRAPH(options) optionblk options = \
+ {0,TRUE,FALSE,FALSE,TRUE,FALSE,CONSOLWIDTH, \
+  NULL,NULL,NULL,NULL,NULL,NULL,adjacencies_sg,100,0,999,0,&dispatch_sparse,FALSE,NULL}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern dispatchvec dispatch_sparse;
+
+extern int targetcell_sg(graph*,int*,int*,int,int,boolean,int,int,int);
+extern boolean cheapautom_sg(int*,int,boolean,int);
+extern boolean isautom_sg(graph*,int*,boolean,int,int);
+extern void refine_sg(graph*,int*,int*,int,int*,int*,set*,int*,int,int);
+extern int testcanlab_sg(graph*,graph*,int*,int*,int,int);
+extern void updatecan_sg(graph*,graph*,int*,int,int,int);
+extern int testcanlab_tr(sparsegraph*,sparsegraph*,int*,int*,int*);
+extern int comparelab_tr(sparsegraph*,int*,int*,int*,int*,int*,int*);
+extern void updatecan_tr(sparsegraph*,sparsegraph*,int*,int*,int);
+extern void init_sg(graph*,graph**,graph*,graph**,int*,int*,set*,
+	                   struct optionstruct*,int*,int,int);
+extern void cleanup_sg(graph*,graph**,graph*,graph**,int*,
+           int*,optionblk*,statsblk*stats,int,int);
+extern void nausparse_freedyn(void);
+extern void nausparse_check(int,int,int,int);
+
+extern sparsegraph *nauty_to_sg(graph*,sparsegraph*,int,int);
+extern graph* sg_to_nauty(sparsegraph*,graph*,int,int*);
+extern void sortlists_sg(sparsegraph*);
+extern boolean aresame_sg(sparsegraph*,sparsegraph*);
+extern void put_sg(FILE*,sparsegraph*,boolean,int);
+extern sparsegraph *copy_sg(sparsegraph*,sparsegraph*);
+extern void distvals(sparsegraph*,int,int*,int);
+
+extern void sparsenauty(sparsegraph*g,int*,int*,int*,
+                        optionblk*,statsblk*,sparsegraph*);
+
+extern void
+   adjacencies_sg(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+extern void
+   distances_sg(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/nauty/nautaux.c b/lib/nauty/nautaux.c
new file mode 100644
index 0000000..f8792c0
--- /dev/null
+++ b/lib/nauty/nautaux.c
@@ -0,0 +1,252 @@
+/*****************************************************************************
+*                                                                            *
+* Auxiliary procedures for use with nauty 2.5.                               *
+* None of these procedures are needed by nauty or by dreadnaut.              *
+*                                                                            *
+*   Copyright (1984-2013) Brendan McKay.  All rights reserved.               *
+*   Subject to waivers and disclaimers in nauty.h.                           *
+*                                                                            *
+*   CHANGE HISTORY                                                           *
+*       26-Apr-89 : initial creation for Version 1.5.                        *
+*       14-Oct-90 : renamed to version 1.6 (no changes to this file)         *
+*        5-Jun-93 : renamed to version 1.7+ (no changes to this file)        *
+*       18-Aug-93 : renamed to version 1.8 (no changes to this file)         *
+*       17-Sep-93 : renamed to version 1.9 (no changes to this file)         *
+*       24-Jan-00 : renamed to version 2.0 (no changes to this file)         *
+*       16-Nov-00 : made changes listed in nauty.h                           *
+*        8-Aug-02 : updated for version 2.2 (dynamic storage)                *
+*        3-Nov-04 : fixed names of nautaux_freedyn() and nautaux_check()     *
+*       10-Dec-06 : removed BIGNAUTY                                         *
+*       10-Nov-09 : removed types permutation and shortish                   *
+*       15-Jan-12 : add TLS_ATTR attributes                                  *
+*                                                                            *
+*****************************************************************************/
+
+#define ONE_WORD_SETS
+#include "naututil.h"          /* which includes "nauty.h" and <stdio.h> */
+#include "nautaux.h"
+
+#if  MAXM==1
+#define M 1
+#else
+#define M m
+#endif
+
+#if !MAXN
+DYNALLSTAT(set,workset,workset_sz);
+DYNALLSTAT(int,workperm,workperm_sz);
+#else
+static TLS_ATTR set workset[MAXM];   /* used for scratch work */
+static TLS_ATTR int workperm[MAXN+2];
+#endif
+
+/*****************************************************************************
+*                                                                            *
+*  ptncode(g,lab,ptn,level,m,n) returns a long integer invariant which       *
+*  depends on the (assumed equitable) partition at the stated level, and     *
+*  the number of edges betwen the various cells.                             *
+*  Neither nauty nor dreadnaut use this.                                     *
+*                                                                            *
+*  GLOBALS ACCESSED: bit<r>,setinter()                                       *
+*                                                                            *
+*****************************************************************************/
+
+long
+ptncode(graph *g, int *lab, int *ptn, int level, int m, int n)
+{
+    int i;
+    long code;
+    int v1,v2,nc,inter,cellend;
+
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n+2,"testcanlab");
+    DYNALLOC1(set,workset,workset_sz,m,"testcanlab");
+#endif
+
+    /* find all cells: put starts in workperm[0..n] */
+
+    i = nc = 0;
+    code = 0;
+
+    while (i < n)
+    {
+        workperm[nc++] = i;
+        code = ((code << 13) ^ (code >> 19)) + i;
+        while (ptn[i] > level) ++i;
+        ++i;
+    }
+    workperm[nc] = n;
+
+    for (v2 = 0; v2 < nc; ++v2)
+    {
+        EMPTYSET(workset,m);
+        for (i = workperm[v2], cellend = workperm[v2+1] - 1;
+                                                      i <= cellend; ++i)
+            ADDELEMENT(workset,lab[i]);
+        for (v1 = 0; v1 < nc; ++v1)
+        {
+            i = workperm[v1];
+            cellend = workperm[v1+1] - 1;
+            inter = setinter(workset,GRAPHROW(g,lab[i],M),M);
+            code = ((code << 13) ^ (code >> 19)) + inter;
+        }
+    }
+
+    return code;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  equitable(g,lab,ptn,level,m,n) checks that the partition at the given     *
+*  level is equitable.  Neither nauty nor dreadnaut use this.                *
+*                                                                            *
+*  GLOBALS ACCESSED: bit<r>,setinter()                                       *
+*                                                                            *
+*****************************************************************************/
+
+boolean
+equitable(graph *g, int *lab, int *ptn, int level, int m, int n)
+{
+    int i;
+    int v1,v2,nc,inter,cellend;
+    boolean ok;
+
+    /* find all cells: put starts in workperm[0..n] */
+
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n+2,"testcanlab");
+    DYNALLOC1(set,workset,workset_sz,m,"testcanlab");
+#endif
+
+    i = nc = 0;
+
+    while (i < n)
+    {
+        workperm[nc++] = i;
+        while (ptn[i] > level)
+            ++i;
+        ++i;
+    }
+    workperm[nc] = n;
+
+    ok = TRUE;
+    for (v2 = 0; v2 < nc && ok; ++v2)
+    {
+        EMPTYSET(workset,m);
+        for (i = workperm[v2], cellend = workperm[v2+1] - 1;
+                                                      i <= cellend; ++i)
+            ADDELEMENT(workset,lab[i]);
+        for (v1 = 0; v1 < nc; ++v1)
+        {
+            i = workperm[v1];
+            cellend = workperm[v1+1] - 1;
+            if (i == cellend)
+                continue;
+            inter = setinter(workset,GRAPHROW(g,lab[i],M),M);
+            while (++i <= cellend)
+                 if (setinter(workset,GRAPHROW(g,lab[i],M),M) != inter)
+                     ok = FALSE;
+        }
+    }
+
+    return ok;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  component(g,v,c,m,n) determines the set of all vertices that can be       *
+*  reached along directed paths starting at vertex v, including v itself.    *
+*  This set is returned as c, unless c is null.  The size of the set is      *
+*  returned as the function value.                                           *
+*                                                                            *
+*  GLOBALS ACCESSED: bit<r>,setinter(),nextelement()                         *
+*                                                                            *
+*****************************************************************************/
+
+int
+component(graph *g, int v, set *cmpt, int m, int n)
+{
+    int i,z;
+    set newverts[MAXM],*gx;
+    int head,tail,x;
+
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n+2,"testcanlab");
+#endif
+
+    EMPTYSET(workset,m);
+    ADDELEMENT(workset,v);
+    head = 0;
+    tail = 1;
+    workperm[head] = v;
+
+    while (head < tail && tail < n)
+    {
+        x = workperm[head++];
+        gx = GRAPHROW(g,x,m);
+        for (i = m; --i >= 0;)
+        {
+            newverts[i] = gx[i] & ~workset[i];
+            workset[i] |= gx[i];
+        }
+        for (z = -1; (z = nextelement(newverts,m,z)) >= 0; )
+            workperm[tail++] = z;
+    }
+
+    if (cmpt != NULL)
+        for (i = m; --i >= 0;) cmpt[i] = workset[i];
+
+    return tail;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  nautaux_check() checks that this file is compiled compatibly with the    *
+*  given parameters.   If not, call exit(1).                                 *
+*                                                                            *
+*****************************************************************************/
+
+void
+nautaux_check(int wordsize, int m, int n, int version)
+{
+    if (wordsize != WORDSIZE)
+    {
+        fprintf(ERRFILE,"Error: WORDSIZE mismatch in nautaux.c\n");
+        exit(1);
+    }
+
+#if MAXN
+    if (m > MAXM)
+    {
+        fprintf(ERRFILE,"Error: MAXM inadequate in nautaux.c\n");
+        exit(1);
+    }
+
+    if (n > MAXN)
+    {
+        fprintf(ERRFILE,"Error: MAXN inadequate in nautaux.c\n");
+        exit(1);
+    }
+#endif
+
+    if (version < NAUTYREQUIRED)
+    {
+        fprintf(ERRFILE,"Error: nautaux.c version mismatch\n");
+        exit(1);
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  nautaux_freedyn() - free the dynamic memory in this module               *
+*                                                                            *
+*****************************************************************************/
+
+void
+nautaux_freedyn(void)
+{
+#if !MAXN
+    DYNFREE(workset,workset_sz);
+    DYNFREE(workperm,workperm_sz);
+#endif
+}
diff --git a/lib/nauty/nautaux.h b/lib/nauty/nautaux.h
new file mode 100644
index 0000000..b98af32
--- /dev/null
+++ b/lib/nauty/nautaux.h
@@ -0,0 +1,34 @@
+/*****************************************************************************
+*                                                                            *
+* This is the header file for version 2.5 of nautaux.c.                      *
+*                                                                            *
+*   Copyright (1984-2013) Brendan McKay.  All rights reserved.               *
+*   Subject to the waivers and disclaimers in nauty.h.                       *
+*                                                                            *
+*   CHANGE HISTORY                                                           *
+*       26-Apr-89 : initial creation for version 1.5.                        *
+*       14-Oct-90 : renamed as version 1.6 (no changes to this file)         *
+*        5-Jun-93 : renamed as version 1.7+ (no changes to this file)        *
+*       18-Aug-93 : renamed as version 1.8 (no changes to this file)         *
+*       17-Sep-93 : renamed as version 1.9 (no changes to this file)         *
+*       19-Apr-95 : added prototype wrapper for C++                          *
+*       16-Nov-00 : made changes listed in nauty.h.                          *
+*        3-Nov-04 : declared nautaux_freedyn and nautaux_check               *
+*       21-Aug-12 : remove nvector                                           *
+*                                                                            *
+*****************************************************************************/
+
+#include "nauty.h"           /* which includes stdio.h */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int component(graph*,int,set*,int,int);
+extern boolean equitable(graph*,int*,int*,int,int,int);
+extern long ptncode(graph*,int*,int*,int,int,int);
+extern void nautaux_freedyn(void);
+extern void nautaux_check(int,int,int,int);
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/nauty/nautest.c b/lib/nauty/nautest.c
new file mode 100644
index 0000000..32cbdcc
--- /dev/null
+++ b/lib/nauty/nautest.c
@@ -0,0 +1,163 @@
+/* Test for basic nauty functions (but not nauty itself) */
+
+#include "naututil.h"
+
+long seed;
+
+int
+main(int argc, char *argv[])
+{
+	int i,j,bad;
+	setword w,ww;
+        int curfile;
+        FILE *f;
+#ifdef CPUDEFS
+        CPUDEFS
+#endif
+
+	printf("NAUTYVERSION=%s  NAUTYVERSIONID=%d  HAVE_TLS=%d\n",
+		NAUTYVERSION,NAUTYVERSIONID,HAVE_TLS);
+	printf("MAXN=%d  MAXM=%d  WORDSIZE=%d  NAUTY_INFINITY=%d\n",
+		MAXN,MAXM,WORDSIZE,NAUTY_INFINITY);
+	printf("sizes: short=%d int=%d long=%d double=%d boolean=%d setword=%d\n",
+		(int)sizeof(short),(int)sizeof(int),(int)sizeof(long),
+		(int)sizeof(double),(int)sizeof(boolean),(int)sizeof(setword));
+        printf("CLZ=%d,%d,%d  POPCNT=%d,%d,%d;%d,%d\n",
+                HAVE_CLZ,HAVE_CLZL,HAVE_CLZLL,
+                HAVE_POPCNT,HAVE_POPCNTL,HAVE_POPCNTLL,HAVE_MMPOP32,HAVE_MMPOP64);
+        printf("LONG_LONG_COUNTERS=%d  COUNTER_FMT=%s\n",
+                LONG_LONG_COUNTERS,COUNTER_FMT);
+
+#if SIZEOF_LONGLONG > 0
+	printf("sizeof(long long)=%d\n",sizeof(long long));
+#endif
+
+	printf("defined:");
+#ifdef __STDC__
+	printf(" __STDC__");
+#endif
+#ifdef BIGNAUTY
+	printf(" BIGNAUTY(obsolete!)");
+#endif
+#ifdef SYS_UNIX
+	printf(" SYS_UNIX");
+#endif
+#ifdef SYS_CRAY
+        printf(" SYS_CRAY");
+#endif
+#ifdef SETWORD_SHORT
+	printf(" SETWORD_SHORT");
+#endif
+#ifdef SETWORD_INT
+	printf(" SETWORD_INT");
+#endif
+#ifdef SETWORD_LONG
+	printf(" SETWORD_LONG");
+#endif
+#ifdef SETWORD_LONGLONG
+	printf(" SETWORD_LONGLONG");
+#endif
+	printf("\n");
+
+	bad = 0;
+
+	if (8*sizeof(setword) != WORDSIZE)
+	{
+	    printf("\n ***** NOTE:  WORDSIZE mismatch *****\n\n");
+	    ++bad;
+	}
+
+	for (i = 0; i < WORDSIZE; ++i)
+	{
+	    w = ALLMASK(i);
+	    if (POPCOUNT(w) != i)
+	    {
+		printf("\n ***** POPCOUNT(ALLMASK) error %d *****\n\n",i);
+		++bad;
+	    }
+	}
+
+	for (i = 0; i < WORDSIZE; ++i)
+        {
+            w = BITMASK(i);
+            if (POPCOUNT(w) != WORDSIZE-i-1)
+            {
+                printf("\n ***** POPCOUNT(BITMASK) error %d *****\n\n",i);
+                ++bad;
+            }
+        }
+
+	for (i = 0; i < WORDSIZE; ++i)
+	    if (POPCOUNT(ALLMASK(i)) != i)
+	    {
+		printf("\n ***** POPCOUNT(ALLMASK) error %d *****\n\n",i);
+		++bad;
+	    }
+
+	for (i = 0; i < WORDSIZE; ++i)
+            if (FIRSTBIT(BITT[i]) != i)
+	    {
+		printf("\n ***** FIRSTBIT(BITT) error %d *****\n\n",i);
+		++bad;
+	    }
+
+	if (FIRSTBIT((setword)0) != WORDSIZE)
+	{
+	    printf("\n ***** FIRSTBIT(0) error *****\n\n");
+	    ++bad;
+	}
+	
+	for (i = 0; i < WORDSIZE; ++i)
+            if (POPCOUNT(BITT[i]) != 1)
+	    {
+                printf("\n ***** POPCOUNT(BITT) error %d *****\n\n",i);
+		++bad;
+	    }
+
+	for (i = 0; i < WORDSIZE; ++i)
+	{
+	    w = 0;
+	    for (j = 1; j <= WORDSIZE; ++j)
+	    {
+		w |= BITT[(j*97+i)%WORDSIZE];
+		if (POPCOUNT(w) != j)
+		{
+		    printf("\n ***** POPCOUNT(w) error %d %d *****\n\n",i,j);
+		    ++bad;
+		}
+	    }
+	}
+
+#ifdef DOPROMPT
+	curfile = 0;
+	printf("DOPROMPT(stdin)=%d DOPROMPT(stdout)=%d\n",
+		DOPROMPT(stdin),DOPROMPT(stdout));
+#else
+	printf("DOPROMPT is not defined\n");
+#endif
+
+#ifdef CPUTIME
+        printf("CPUTIME = %f\n",CPUTIME);
+#else
+        printf("CPUTIME is not defined\n");
+#endif
+
+#ifdef INITSEED
+	INITSEED;
+        printf("INITSEED: seed=%ld\n",seed);
+#else
+        printf("INITSEED is not defined\n");
+#endif
+
+#ifdef OPENOUT
+        OPENOUT(f,"nautest.txt",0);
+	fprintf(f,"test\n");
+#else
+        printf("OPENOUT is not defined\n");
+#endif
+
+	if (!bad) printf("\nNo errors found\n");
+	else      printf("\nXXXXXXX %d errors found XXXXXXX\n",bad);
+
+	exit(0);
+} 
diff --git a/lib/nauty/nautest1.dre b/lib/nauty/nautest1.dre
new file mode 100644
index 0000000..07d5917
--- /dev/null
+++ b/lib/nauty/nautest1.dre
@@ -0,0 +1,58 @@
+!Hoffman-Singleton graph
+n=50 $=0 g
+  0 : 2 3 5 15 25 35 45;
+  1 : 3 4 6 16 26 36 46;
+  2 : 0 4 7 17 27 37 47;
+  3 : 0 1 8 18 28 38 48;
+  4 : 1 2 9 19 29 39 49;
+  5 : 0 6 9 10 20 30 40;
+  6 : 1 5 7 11 21 31 41;
+  7 : 2 6 8 12 22 32 42;
+  8 : 3 7 9 13 23 33 43;
+  9 : 4 5 8 14 24 34 44;
+ 10 : 5 12 13 16 27 38 49;
+ 11 : 6 13 14 17 28 39 45;
+ 12 : 7 10 14 18 29 35 46;
+ 13 : 8 10 11 19 25 36 47;
+ 14 : 9 11 12 15 26 37 48;
+ 15 : 0 14 16 19 23 32 41;
+ 16 : 1 10 15 17 24 33 42;
+ 17 : 2 11 16 18 20 34 43;
+ 18 : 3 12 17 19 21 30 44;
+ 19 : 4 13 15 18 22 31 40;
+ 20 : 5 17 22 23 29 36 48;
+ 21 : 6 18 23 24 25 37 49;
+ 22 : 7 19 20 24 26 38 45;
+ 23 : 8 15 20 21 27 39 46;
+ 24 : 9 16 21 22 28 35 47;
+ 25 : 0 13 21 26 29 34 42;
+ 26 : 1 14 22 25 27 30 43;
+ 27 : 2 10 23 26 28 31 44;
+ 28 : 3 11 24 27 29 32 40;
+ 29 : 4 12 20 25 28 33 41;
+ 30 : 5 18 26 32 33 39 47;
+ 31 : 6 19 27 33 34 35 48;
+ 32 : 7 15 28 30 34 36 49;
+ 33 : 8 16 29 30 31 37 45;
+ 34 : 9 17 25 31 32 38 46;
+ 35 : 0 12 24 31 36 39 43;
+ 36 : 1 13 20 32 35 37 44;
+ 37 : 2 14 21 33 36 38 40;
+ 38 : 3 10 22 34 37 39 41;
+ 39 : 4 11 23 30 35 38 42;
+ 40 : 5 19 28 37 42 43 46;
+ 41 : 6 15 29 38 43 44 47;
+ 42 : 7 16 25 39 40 44 48;
+ 43 : 8 17 26 35 40 41 49;
+ 44 : 9 18 27 36 41 42 45;
+ 45 : 0 11 22 33 44 46 49;
+ 46 : 1 12 23 34 40 45 47;
+ 47 : 2 13 24 30 41 46 48;
+ 48 : 3 14 20 31 42 47 49;
+ 49 : 4 10 21 32 43 45 48;
+$$
+t ? x o
+c -ax z jxz b
+_ x o
+f=3 x o
+q
diff --git a/lib/nauty/nautest1a.ans b/lib/nauty/nautest1a.ans
new file mode 100644
index 0000000..5cd01ab
--- /dev/null
+++ b/lib/nauty/nautest1a.ans
@@ -0,0 +1,149 @@
+  0 :  2 3 5 15 25 35 45;
+  1 :  3 4 6 16 26 36 46;
+  2 :  0 4 7 17 27 37 47;
+  3 :  0 1 8 18 28 38 48;
+  4 :  1 2 9 19 29 39 49;
+  5 :  0 6 9 10 20 30 40;
+  6 :  1 5 7 11 21 31 41;
+  7 :  2 6 8 12 22 32 42;
+  8 :  3 7 9 13 23 33 43;
+  9 :  4 5 8 14 24 34 44;
+ 10 :  5 12 13 16 27 38 49;
+ 11 :  6 13 14 17 28 39 45;
+ 12 :  7 10 14 18 29 35 46;
+ 13 :  8 10 11 19 25 36 47;
+ 14 :  9 11 12 15 26 37 48;
+ 15 :  0 14 16 19 23 32 41;
+ 16 :  1 10 15 17 24 33 42;
+ 17 :  2 11 16 18 20 34 43;
+ 18 :  3 12 17 19 21 30 44;
+ 19 :  4 13 15 18 22 31 40;
+ 20 :  5 17 22 23 29 36 48;
+ 21 :  6 18 23 24 25 37 49;
+ 22 :  7 19 20 24 26 38 45;
+ 23 :  8 15 20 21 27 39 46;
+ 24 :  9 16 21 22 28 35 47;
+ 25 :  0 13 21 26 29 34 42;
+ 26 :  1 14 22 25 27 30 43;
+ 27 :  2 10 23 26 28 31 44;
+ 28 :  3 11 24 27 29 32 40;
+ 29 :  4 12 20 25 28 33 41;
+ 30 :  5 18 26 32 33 39 47;
+ 31 :  6 19 27 33 34 35 48;
+ 32 :  7 15 28 30 34 36 49;
+ 33 :  8 16 29 30 31 37 45;
+ 34 :  9 17 25 31 32 38 46;
+ 35 :  0 12 24 31 36 39 43;
+ 36 :  1 13 20 32 35 37 44;
+ 37 :  2 14 21 33 36 38 40;
+ 38 :  3 10 22 34 37 39 41;
+ 39 :  4 11 23 30 35 38 42;
+ 40 :  5 19 28 37 42 43 46;
+ 41 :  6 15 29 38 43 44 47;
+ 42 :  7 16 25 39 40 44 48;
+ 43 :  8 17 26 35 40 41 49;
+ 44 :  9 18 27 36 41 42 45;
+ 45 :  0 11 22 33 44 46 49;
+ 46 :  1 12 23 34 40 45 47;
+ 47 :  2 13 24 30 41 46 48;
+ 48 :  3 14 20 31 42 47 49;
+ 49 :  4 10 21 32 43 45 48;
+Mode=dense m=2 n=50 labelorg=0 edges=175 options=(-c+a+m-p-d y=100 k=(0,1))
+linelen=78 worksize=60 input_depth=0 G=10; 1 cell
+(5 45 35 25 15)(6 46 36 26 16)(7 47 37 27 17)(8 48 38 28 18)(9 49 39 29 19)
+   (10 11 12 13 14)(20 22 24 21 23)(30 33 31 34 32)(40 44 43 42 41)
+(10 20 40 30)(11 21 41 31)(12 22 42 32)(13 23 43 33)(14 24 44 34)(15 35 45 25)
+   (16 36 46 26)(17 37 47 27)(18 38 48 28)(19 39 49 29)
+level 4:  11 orbits; 10 fixed; index 20
+(1 6 21 23 46)(3 5 25 15 45)(4 7 37 27 47)(8 40 26 41 49)(9 42 14 44 48)
+   (10 13 19 22 38)(11 18 20 34 16)(12 36 31 24 39)(28 30 29 32 33)
+level 3:  5 orbits; 1 fixed; index 36
+(1 4)(2 3)(6 9)(7 8)(11 14)(12 13)(15 45)(16 49)(17 48)(18 47)(19 46)(21 24)
+   (22 23)(25 35)(26 39)(27 38)(28 37)(29 36)(31 34)(32 33)(41 44)(42 43)
+level 2:  3 orbits; 2 fixed; index 7
+(0 1 2 3 4)(5 16 27 38 49)(6 17 28 39 45)(7 18 29 35 46)(8 19 25 36 47)(9 15
+    26 37 48)(20 24 23 22 21)(30 33 31 34 32)(40 42 44 41 43)
+level 1:  1 orbit; 0 fixed; index 50
+1 orbit; grpsize=252000; 5 gens; 16 nodes; maxlev=5
+cpu time = 0.00 seconds
+ 0:49 (50);
+level 4:  11 orbits; 10 fixed; index 20
+level 3:  5 orbits; 1 fixed; index 36
+level 2:  3 orbits; 2 fixed; index 7
+level 1:  1 orbit; 0 fixed; index 50
+1 orbit; grpsize=252000; 5 gens; 16 nodes; maxlev=5
+canupdates=1; cpu time = 0.00 seconds
+[N4fa37bd7 27e16be2 7d20780d]
+level 4:  11 orbits; 2 fixed; index 20
+level 3:  5 orbits; 1 fixed; index 36
+level 2:  3 orbits; 6 fixed; index 7
+level 1:  1 orbit; 0 fixed; index 50
+1 orbit; grpsize=252000; 5 gens; 16 nodes; maxlev=5
+canupdates=1; cpu time = 0.00 seconds
+[N4fa37bd7 27e16be2 7d20780d]
+ 0 6 46 29 8 35 17 30 42 43 34 19 10 22 1 14 11 27 31 24 45 44 21 7 40 25 37 4
+    5 38 2 49 33 20 47 23 16 28 3 41 13 18 15 26 32 12 36 39 9 48
+  0 :  1 2 3 4 5 6 7;
+  1 :  0 8 9 10 11 12 13;
+  2 :  0 14 25 26 27 28 29;
+  3 :  0 17 23 30 38 46 47;
+  4 :  0 16 21 31 40 41 42;
+  5 :  0 19 24 32 34 39 44;
+  6 :  0 18 20 33 36 43 48;
+  7 :  0 15 22 35 37 45 49;
+  8 :  1 14 20 21 22 23 24;
+  9 :  1 19 27 30 37 41 48;
+ 10 :  1 16 25 43 44 45 47;
+ 11 :  1 18 29 32 35 38 42;
+ 12 :  1 17 26 31 33 39 49;
+ 13 :  1 15 28 34 36 40 46;
+ 14 :  2 8 15 16 17 18 19;
+ 15 :  7 13 14 30 39 42 43;
+ 16 :  4 10 14 32 46 48 49;
+ 17 :  3 12 14 35 36 41 44;
+ 18 :  6 11 14 31 34 37 47;
+ 19 :  5 9 14 33 38 40 45;
+ 20 :  6 8 29 30 40 44 49;
+ 21 :  4 8 25 36 37 38 39;
+ 22 :  7 8 28 32 33 41 47;
+ 23 :  3 8 26 34 42 45 48;
+ 24 :  5 8 27 31 35 43 46;
+ 25 :  2 10 21 30 33 34 35;
+ 26 :  2 12 23 32 37 40 43;
+ 27 :  2 9 24 36 42 47 49;
+ 28 :  2 13 22 31 38 44 48;
+ 29 :  2 11 20 39 41 45 46;
+ 30 :  3 9 15 20 25 31 32;
+ 31 :  4 12 18 24 28 30 45;
+ 32 :  5 11 16 22 26 30 36;
+ 33 :  6 12 19 22 25 42 46;
+ 34 :  5 13 18 23 25 41 49;
+ 35 :  7 11 17 24 25 40 48;
+ 36 :  6 13 17 21 27 32 45;
+ 37 :  7 9 18 21 26 44 46;
+ 38 :  3 11 19 21 28 43 49;
+ 39 :  5 12 15 21 29 47 48;
+ 40 :  4 13 19 20 26 35 47;
+ 41 :  4 9 17 22 29 34 43;
+ 42 :  4 11 15 23 27 33 44;
+ 43 :  6 10 15 24 26 38 41;
+ 44 :  5 10 17 20 28 37 42;
+ 45 :  7 10 19 23 29 31 36;
+ 46 :  3 13 16 24 29 33 37;
+ 47 :  3 10 18 22 27 39 40;
+ 48 :  6 9 16 23 28 35 39;
+ 49 :  7 12 16 20 27 34 38;
+level 4:  20 orbits; 20 fixed; index 4
+level 3:  7 orbits; 2 fixed; index 30
+level 2:  3 orbits; 1 fixed; index 42
+level 1:  1 orbit; 0 fixed; index 50
+1 orbit; grpsize=252000; 5 gens; 17 nodes; maxlev=5
+canupdates=1; cpu time = 0.00 seconds
+ 0:49 (50);
+[fixing partition]
+level 3:  20 orbits; 10 fixed; index 4
+level 2:  7 orbits; 1 fixed; index 30
+level 1:  3 orbits; 0 fixed; index 42
+3 orbits; grpsize=5040; 4 gens; 12 nodes; maxlev=4
+canupdates=1; cpu time = 0.00 seconds
+ 0:2 4 6:18 20:23 25 27 28 30:43 45:47 49 (42); 3; 5 19 24 26 29 44 48 (7);
diff --git a/lib/nauty/nautest1a.dre b/lib/nauty/nautest1a.dre
new file mode 100644
index 0000000..b848622
--- /dev/null
+++ b/lib/nauty/nautest1a.dre
@@ -0,0 +1,149 @@
+  0 :  2 3 5 15 25 35 45;
+  1 :  3 4 6 16 26 36 46;
+  2 :  0 4 7 17 27 37 47;
+  3 :  0 1 8 18 28 38 48;
+  4 :  1 2 9 19 29 39 49;
+  5 :  0 6 9 10 20 30 40;
+  6 :  1 5 7 11 21 31 41;
+  7 :  2 6 8 12 22 32 42;
+  8 :  3 7 9 13 23 33 43;
+  9 :  4 5 8 14 24 34 44;
+ 10 :  5 12 13 16 27 38 49;
+ 11 :  6 13 14 17 28 39 45;
+ 12 :  7 10 14 18 29 35 46;
+ 13 :  8 10 11 19 25 36 47;
+ 14 :  9 11 12 15 26 37 48;
+ 15 :  0 14 16 19 23 32 41;
+ 16 :  1 10 15 17 24 33 42;
+ 17 :  2 11 16 18 20 34 43;
+ 18 :  3 12 17 19 21 30 44;
+ 19 :  4 13 15 18 22 31 40;
+ 20 :  5 17 22 23 29 36 48;
+ 21 :  6 18 23 24 25 37 49;
+ 22 :  7 19 20 24 26 38 45;
+ 23 :  8 15 20 21 27 39 46;
+ 24 :  9 16 21 22 28 35 47;
+ 25 :  0 13 21 26 29 34 42;
+ 26 :  1 14 22 25 27 30 43;
+ 27 :  2 10 23 26 28 31 44;
+ 28 :  3 11 24 27 29 32 40;
+ 29 :  4 12 20 25 28 33 41;
+ 30 :  5 18 26 32 33 39 47;
+ 31 :  6 19 27 33 34 35 48;
+ 32 :  7 15 28 30 34 36 49;
+ 33 :  8 16 29 30 31 37 45;
+ 34 :  9 17 25 31 32 38 46;
+ 35 :  0 12 24 31 36 39 43;
+ 36 :  1 13 20 32 35 37 44;
+ 37 :  2 14 21 33 36 38 40;
+ 38 :  3 10 22 34 37 39 41;
+ 39 :  4 11 23 30 35 38 42;
+ 40 :  5 19 28 37 42 43 46;
+ 41 :  6 15 29 38 43 44 47;
+ 42 :  7 16 25 39 40 44 48;
+ 43 :  8 17 26 35 40 41 49;
+ 44 :  9 18 27 36 41 42 45;
+ 45 :  0 11 22 33 44 46 49;
+ 46 :  1 12 23 34 40 45 47;
+ 47 :  2 13 24 30 41 46 48;
+ 48 :  3 14 20 31 42 47 49;
+ 49 :  4 10 21 32 43 45 48;
+Mode=dense m=2 n=50 labelorg=0 edges=175 options=(-c+a+m-p-d y=100 k=(0,1))
+linelen=78 worksize=60 input_depth=0 G=10; 1 cell
+(5 45 35 25 15)(6 46 36 26 16)(7 47 37 27 17)(8 48 38 28 18)(9 49 39 29 19)
+   (10 11 12 13 14)(20 22 24 21 23)(30 33 31 34 32)(40 44 43 42 41)
+(10 20 40 30)(11 21 41 31)(12 22 42 32)(13 23 43 33)(14 24 44 34)(15 35 45 25)
+   (16 36 46 26)(17 37 47 27)(18 38 48 28)(19 39 49 29)
+level 4:  11 orbits; 10 fixed; index 20
+(1 6 21 23 46)(3 5 25 15 45)(4 7 37 27 47)(8 40 26 41 49)(9 42 14 44 48)
+   (10 13 19 22 38)(11 18 20 34 16)(12 36 31 24 39)(28 30 29 32 33)
+level 3:  5 orbits; 1 fixed; index 36
+(1 4)(2 3)(6 9)(7 8)(11 14)(12 13)(15 45)(16 49)(17 48)(18 47)(19 46)(21 24)
+   (22 23)(25 35)(26 39)(27 38)(28 37)(29 36)(31 34)(32 33)(41 44)(42 43)
+level 2:  3 orbits; 2 fixed; index 7
+(0 1 2 3 4)(5 16 27 38 49)(6 17 28 39 45)(7 18 29 35 46)(8 19 25 36 47)(9 15
+    26 37 48)(20 24 23 22 21)(30 33 31 34 32)(40 42 44 41 43)
+level 1:  1 orbit; 0 fixed; index 50
+1 orbit; grpsize=252000; 5 gens; 16 nodes; maxlev=5
+cpu time = 0.00 seconds
+ 0:49;
+level 4:  11 orbits; 10 fixed; index 20
+level 3:  5 orbits; 1 fixed; index 36
+level 2:  3 orbits; 2 fixed; index 7
+level 1:  1 orbit; 0 fixed; index 50
+1 orbit; grpsize=252000; 5 gens; 16 nodes; maxlev=5
+canupdates=1; cpu time = 0.00 seconds
+[N4fa37bd7 27e16be2 7d20780d]
+level 4:  11 orbits; 4 fixed; index 20
+level 3:  5 orbits; 3 fixed; index 36
+level 2:  3 orbits; 1 fixed; index 7
+level 1:  1 orbit; 0 fixed; index 50
+1 orbit; grpsize=252000; 5 gens; 16 nodes; maxlev=5
+canupdates=1; cpu time = 0.00 seconds
+[N4fa37bd7 27e16be2 7d20780d]
+ 0 1 2 25 47 21 17 12 30 44 33 6 11 27 3 40 18 29 24 36 42 14 19 23 28 49 16
+    48 7 10 4 22 43 8 32 13 39 38 34 46 5 45 35 41 15 37 31 9 26 20
+  0 :  1 2 3 4 5 6 7;
+  1 :  0 8 9 10 11 12 13;
+  2 :  0 14 25 26 27 28 29;
+  3 :  0 17 23 30 38 46 47;
+  4 :  0 16 21 31 40 41 42;
+  5 :  0 19 24 32 34 39 44;
+  6 :  0 18 20 33 36 43 48;
+  7 :  0 15 22 35 37 45 49;
+  8 :  1 14 20 21 22 23 24;
+  9 :  1 19 27 30 37 41 48;
+ 10 :  1 16 25 43 44 45 47;
+ 11 :  1 18 29 32 35 38 42;
+ 12 :  1 17 26 31 33 39 49;
+ 13 :  1 15 28 34 36 40 46;
+ 14 :  2 8 15 16 17 18 19;
+ 15 :  7 13 14 30 39 42 43;
+ 16 :  4 10 14 32 46 48 49;
+ 17 :  3 12 14 35 36 41 44;
+ 18 :  6 11 14 31 34 37 47;
+ 19 :  5 9 14 33 38 40 45;
+ 20 :  6 8 29 30 40 44 49;
+ 21 :  4 8 25 36 37 38 39;
+ 22 :  7 8 28 32 33 41 47;
+ 23 :  3 8 26 34 42 45 48;
+ 24 :  5 8 27 31 35 43 46;
+ 25 :  2 10 21 30 33 34 35;
+ 26 :  2 12 23 32 37 40 43;
+ 27 :  2 9 24 36 42 47 49;
+ 28 :  2 13 22 31 38 44 48;
+ 29 :  2 11 20 39 41 45 46;
+ 30 :  3 9 15 20 25 31 32;
+ 31 :  4 12 18 24 28 30 45;
+ 32 :  5 11 16 22 26 30 36;
+ 33 :  6 12 19 22 25 42 46;
+ 34 :  5 13 18 23 25 41 49;
+ 35 :  7 11 17 24 25 40 48;
+ 36 :  6 13 17 21 27 32 45;
+ 37 :  7 9 18 21 26 44 46;
+ 38 :  3 11 19 21 28 43 49;
+ 39 :  5 12 15 21 29 47 48;
+ 40 :  4 13 19 20 26 35 47;
+ 41 :  4 9 17 22 29 34 43;
+ 42 :  4 11 15 23 27 33 44;
+ 43 :  6 10 15 24 26 38 41;
+ 44 :  5 10 17 20 28 37 42;
+ 45 :  7 10 19 23 29 31 36;
+ 46 :  3 13 16 24 29 33 37;
+ 47 :  3 10 18 22 27 39 40;
+ 48 :  6 9 16 23 28 35 39;
+ 49 :  7 12 16 20 27 34 38;
+level 4:  20 orbits; 8 fixed; index 4
+level 3:  7 orbits; 4 fixed; index 30
+level 2:  3 orbits; 3 fixed; index 42
+level 1:  1 orbit; 0 fixed; index 50
+1 orbit; grpsize=252000; 4 gens; 15 nodes; maxlev=5
+canupdates=1; cpu time = 0.00 seconds
+ 0:49;
+[fixing partition]
+level 3:  20 orbits; 8 fixed; index 4
+level 2:  7 orbits; 4 fixed; index 30
+level 1:  3 orbits; 0 fixed; index 42
+3 orbits; grpsize=5040; 3 gens; 10 nodes; maxlev=4
+canupdates=1; cpu time = 0.00 seconds
+ 0 1 4:17 19:23 25:28 31:35 37:39 41:49; 2 18 24 29 30 36 40; 3;
diff --git a/lib/nauty/nautest1b.ans b/lib/nauty/nautest1b.ans
new file mode 100644
index 0000000..45aa8cb
--- /dev/null
+++ b/lib/nauty/nautest1b.ans
@@ -0,0 +1,150 @@
+  0 :  2 3 5 15 25 35 45;
+  1 :  3 4 6 16 26 36 46;
+  2 :  0 4 7 17 27 37 47;
+  3 :  0 1 8 18 28 38 48;
+  4 :  1 2 9 19 29 39 49;
+  5 :  0 6 9 10 20 30 40;
+  6 :  1 5 7 11 21 31 41;
+  7 :  2 6 8 12 22 32 42;
+  8 :  3 7 9 13 23 33 43;
+  9 :  4 5 8 14 24 34 44;
+ 10 :  5 12 13 16 27 38 49;
+ 11 :  6 13 14 17 28 39 45;
+ 12 :  7 10 14 18 29 35 46;
+ 13 :  8 10 11 19 25 36 47;
+ 14 :  9 11 12 15 26 37 48;
+ 15 :  0 14 16 19 23 32 41;
+ 16 :  1 10 15 17 24 33 42;
+ 17 :  2 11 16 18 20 34 43;
+ 18 :  3 12 17 19 21 30 44;
+ 19 :  4 13 15 18 22 31 40;
+ 20 :  5 17 22 23 29 36 48;
+ 21 :  6 18 23 24 25 37 49;
+ 22 :  7 19 20 24 26 38 45;
+ 23 :  8 15 20 21 27 39 46;
+ 24 :  9 16 21 22 28 35 47;
+ 25 :  0 13 21 26 29 34 42;
+ 26 :  1 14 22 25 27 30 43;
+ 27 :  2 10 23 26 28 31 44;
+ 28 :  3 11 24 27 29 32 40;
+ 29 :  4 12 20 25 28 33 41;
+ 30 :  5 18 26 32 33 39 47;
+ 31 :  6 19 27 33 34 35 48;
+ 32 :  7 15 28 30 34 36 49;
+ 33 :  8 16 29 30 31 37 45;
+ 34 :  9 17 25 31 32 38 46;
+ 35 :  0 12 24 31 36 39 43;
+ 36 :  1 13 20 32 35 37 44;
+ 37 :  2 14 21 33 36 38 40;
+ 38 :  3 10 22 34 37 39 41;
+ 39 :  4 11 23 30 35 38 42;
+ 40 :  5 19 28 37 42 43 46;
+ 41 :  6 15 29 38 43 44 47;
+ 42 :  7 16 25 39 40 44 48;
+ 43 :  8 17 26 35 40 41 49;
+ 44 :  9 18 27 36 41 42 45;
+ 45 :  0 11 22 33 44 46 49;
+ 46 :  1 12 23 34 40 45 47;
+ 47 :  2 13 24 30 41 46 48;
+ 48 :  3 14 20 31 42 47 49;
+ 49 :  4 10 21 32 43 45 48;
+Mode=sparse m=2 n=50 labelorg=0 edges=175 options=(-c+a+m-p-d y=100 k=(0,1))
+linelen=78 worksize=60 input_depth=0 G=10; 1 cell
+(10 30 40 20)(11 31 41 21)(12 32 42 22)(13 33 43 23)(14 34 44 24)(15 25 45 35)
+   (16 26 46 36)(17 27 47 37)(18 28 48 38)(19 29 49 39)
+level 4:  20 orbits; 15 fixed; index 4
+(2 5)(4 6)(7 9)(10 17)(11 49)(12 34)(13 43)(14 32)(18 38)(19 41)(20 27)
+   (21 39)(22 44)(24 42)(25 35)(26 36)(28 48)(29 31)(30 37)(40 47)
+(2 5 15)(4 6 16)(7 10 19)(8 38 18)(9 41 17)(11 24 29)(12 13 22)(14 47 20)
+   (21 33 39)(23 37 30)(25 45 35)(26 46 36)(27 40 32)(31 42 49)(34 44 43)
+level 3:  7 orbits; 7 fixed; index 30
+(1 4 9 8 7 6)(2 5 3)(10 18 37 20 28 47)(11 46 49 44 33 22)(12 21 36 29 24 13)
+   (14 23 32 41 16 19)(17 40 48 27 30 38)(25 35)(26 39 34 43 42 31)
+level 2:  3 orbits; 1 fixed; index 42
+(0 1)(2 6)(4 5)(10 19)(11 47)(12 22)(14 24)(15 16)(17 41)(18 38)(20 29)
+   (21 37)(23 33)(25 36)(26 35)(27 31)(28 48)(30 39)(32 42)(34 44)(40 49)
+   (45 46)
+level 1:  1 orbit; 0 fixed; index 50
+1 orbit; grpsize=252000; 5 gens; 17 nodes; maxlev=5
+cpu time = 0.00 seconds
+ 0:49 (50);
+level 4:  20 orbits; 15 fixed; index 4
+level 3:  7 orbits; 7 fixed; index 30
+level 2:  3 orbits; 1 fixed; index 42
+level 1:  1 orbit; 0 fixed; index 50
+1 orbit; grpsize=252000; 5 gens; 17 nodes; maxlev=5
+canupdates=1; cpu time = 0.00 seconds
+[S7c9fbc52 9edc578 5ff84822]
+level 4:  20 orbits; 6 fixed; index 4
+level 3:  7 orbits; 2 fixed; index 30
+level 2:  3 orbits; 1 fixed; index 42
+level 1:  1 orbit; 0 fixed; index 50
+1 orbit; grpsize=252000; 6 gens; 18 nodes; maxlev=5
+canupdates=1; cpu time = 0.00 seconds
+[S7c9fbc52 9edc578 5ff84822]
+ 0 6 35 8 17 30 29 46 1 2 13 9 40 19 48 12 28 21 20 47 44 34 18 16 32 10 23 26
+    41 15 22 36 39 7 3 49 45 33 43 4 37 5 38 25 24 11 31 42 27 14
+  0 :  1 2 3 4 5 6 7;
+  1 :  0 13 21 25 30 38 47;
+  2 :  0 12 19 24 28 37 44;
+  3 :  0 10 20 22 29 35 45;
+  4 :  0 11 18 23 27 36 46;
+  5 :  0 14 15 16 17 26 49;
+  6 :  0 9 31 32 33 34 48;
+  7 :  0 8 39 40 41 42 43;
+  8 :  7 44 45 46 47 48 49;
+  9 :  6 35 36 37 38 43 49;
+ 10 :  3 26 30 32 36 40 44;
+ 11 :  4 26 28 33 38 41 45;
+ 12 :  2 26 27 31 35 39 47;
+ 13 :  1 26 29 34 37 42 46;
+ 14 :  5 19 25 34 36 39 45;
+ 15 :  5 21 23 33 35 42 44;
+ 16 :  5 20 24 31 38 40 46;
+ 17 :  5 18 22 32 37 41 47;
+ 18 :  4 17 25 29 31 43 44;
+ 19 :  2 14 22 30 33 43 46;
+ 20 :  3 16 23 28 34 43 47;
+ 21 :  1 15 24 27 32 43 45;
+ 22 :  3 17 19 27 38 42 48;
+ 23 :  4 15 20 30 37 39 48;
+ 24 :  2 16 21 29 36 41 48;
+ 25 :  1 14 18 28 35 40 48;
+ 26 :  5 10 11 12 13 43 48;
+ 27 :  4 12 21 22 34 40 49;
+ 28 :  2 11 20 25 32 42 49;
+ 29 :  3 13 18 24 33 39 49;
+ 30 :  1 10 19 23 31 41 49;
+ 31 :  6 12 16 18 30 42 45;
+ 32 :  6 10 17 21 28 39 46;
+ 33 :  6 11 15 19 29 40 47;
+ 34 :  6 13 14 20 27 41 44;
+ 35 :  3 9 12 15 25 41 46;
+ 36 :  4 9 10 14 24 42 47;
+ 37 :  2 9 13 17 23 40 45;
+ 38 :  1 9 11 16 22 39 44;
+ 39 :  7 12 14 23 29 32 38;
+ 40 :  7 10 16 25 27 33 37;
+ 41 :  7 11 17 24 30 34 35;
+ 42 :  7 13 15 22 28 31 36;
+ 43 :  7 9 18 19 20 21 26;
+ 44 :  2 8 10 15 18 34 38;
+ 45 :  3 8 11 14 21 31 37;
+ 46 :  4 8 13 16 19 32 35;
+ 47 :  1 8 12 17 20 33 36;
+ 48 :  6 8 22 23 24 25 26;
+ 49 :  5 8 9 27 28 29 30;
+level 4:  20 orbits; 11 fixed; index 4
+level 3:  7 orbits; 2 fixed; index 30
+level 2:  3 orbits; 1 fixed; index 42
+level 1:  1 orbit; 0 fixed; index 50
+1 orbit; grpsize=252000; 5 gens; 17 nodes; maxlev=5
+canupdates=1; cpu time = 0.00 seconds
+ 0:49 (50);
+[fixing partition]
+level 3:  11 orbits; 10 fixed; index 20
+level 2:  5 orbits; 0 fixed; index 36
+level 1:  3 orbits; 5 fixed; index 7
+3 orbits; grpsize=5040; 5 gens; 13 nodes; maxlev=4
+canupdates=1; cpu time = 0.00 seconds
+ 0:2 4 6:18 20:23 25 27 28 30:43 45:47 49 (42); 3; 5 19 24 26 29 44 48 (7);
diff --git a/lib/nauty/nautest1b.dre b/lib/nauty/nautest1b.dre
new file mode 100644
index 0000000..66216d1
--- /dev/null
+++ b/lib/nauty/nautest1b.dre
@@ -0,0 +1,150 @@
+  0 :  2 3 5 15 25 35 45;
+  1 :  3 4 6 16 26 36 46;
+  2 :  0 4 7 17 27 37 47;
+  3 :  0 1 8 18 28 38 48;
+  4 :  1 2 9 19 29 39 49;
+  5 :  0 6 9 10 20 30 40;
+  6 :  1 5 7 11 21 31 41;
+  7 :  2 6 8 12 22 32 42;
+  8 :  3 7 9 13 23 33 43;
+  9 :  4 5 8 14 24 34 44;
+ 10 :  5 12 13 16 27 38 49;
+ 11 :  6 13 14 17 28 39 45;
+ 12 :  7 10 14 18 29 35 46;
+ 13 :  8 10 11 19 25 36 47;
+ 14 :  9 11 12 15 26 37 48;
+ 15 :  0 14 16 19 23 32 41;
+ 16 :  1 10 15 17 24 33 42;
+ 17 :  2 11 16 18 20 34 43;
+ 18 :  3 12 17 19 21 30 44;
+ 19 :  4 13 15 18 22 31 40;
+ 20 :  5 17 22 23 29 36 48;
+ 21 :  6 18 23 24 25 37 49;
+ 22 :  7 19 20 24 26 38 45;
+ 23 :  8 15 20 21 27 39 46;
+ 24 :  9 16 21 22 28 35 47;
+ 25 :  0 13 21 26 29 34 42;
+ 26 :  1 14 22 25 27 30 43;
+ 27 :  2 10 23 26 28 31 44;
+ 28 :  3 11 24 27 29 32 40;
+ 29 :  4 12 20 25 28 33 41;
+ 30 :  5 18 26 32 33 39 47;
+ 31 :  6 19 27 33 34 35 48;
+ 32 :  7 15 28 30 34 36 49;
+ 33 :  8 16 29 30 31 37 45;
+ 34 :  9 17 25 31 32 38 46;
+ 35 :  0 12 24 31 36 39 43;
+ 36 :  1 13 20 32 35 37 44;
+ 37 :  2 14 21 33 36 38 40;
+ 38 :  3 10 22 34 37 39 41;
+ 39 :  4 11 23 30 35 38 42;
+ 40 :  5 19 28 37 42 43 46;
+ 41 :  6 15 29 38 43 44 47;
+ 42 :  7 16 25 39 40 44 48;
+ 43 :  8 17 26 35 40 41 49;
+ 44 :  9 18 27 36 41 42 45;
+ 45 :  0 11 22 33 44 46 49;
+ 46 :  1 12 23 34 40 45 47;
+ 47 :  2 13 24 30 41 46 48;
+ 48 :  3 14 20 31 42 47 49;
+ 49 :  4 10 21 32 43 45 48;
+Mode=sparse m=2 n=50 labelorg=0 edges=175 options=(-c+a+m-p-d y=100 k=(0,1))
+linelen=78 worksize=60 input_depth=0 G=10; 1 cell
+(10 30 40 20)(11 31 41 21)(12 32 42 22)(13 33 43 23)(14 34 44 24)(15 25 45 35)
+   (16 26 46 36)(17 27 47 37)(18 28 48 38)(19 29 49 39)
+level 4:  20 orbits; 15 fixed; index 4
+(2 5)(4 6)(7 9)(10 17)(11 49)(12 34)(13 43)(14 32)(18 38)(19 41)(20 27)
+   (21 39)(22 44)(24 42)(25 35)(26 36)(28 48)(29 31)(30 37)(40 47)
+(2 5 15)(4 6 16)(7 10 19)(8 38 18)(9 41 17)(11 24 29)(12 13 22)(14 47 20)
+   (21 33 39)(23 37 30)(25 45 35)(26 46 36)(27 40 32)(31 42 49)(34 44 43)
+level 3:  7 orbits; 7 fixed; index 30
+(1 4 9 8 7 6)(2 5 3)(10 18 37 20 28 47)(11 46 49 44 33 22)(12 21 36 29 24 13)
+   (14 23 32 41 16 19)(17 40 48 27 30 38)(25 35)(26 39 34 43 42 31)
+level 2:  3 orbits; 1 fixed; index 42
+(0 1)(2 6)(4 5)(10 19)(11 47)(12 22)(14 24)(15 16)(17 41)(18 38)(20 29)
+   (21 37)(23 33)(25 36)(26 35)(27 31)(28 48)(30 39)(32 42)(34 44)(40 49)
+   (45 46)
+level 1:  1 orbit; 0 fixed; index 50
+1 orbit; grpsize=252000; 5 gens; 17 nodes; maxlev=5
+cpu time = 0.00 seconds
+ 0:49;
+level 4:  20 orbits; 15 fixed; index 4
+level 3:  7 orbits; 7 fixed; index 30
+level 2:  3 orbits; 1 fixed; index 42
+level 1:  1 orbit; 0 fixed; index 50
+1 orbit; grpsize=252000; 5 gens; 17 nodes; maxlev=5
+canupdates=1; cpu time = 0.00 seconds
+[S7c9fbc52 9edc578 5ff84822]
+level 4:  20 orbits; 1 fixed; index 4
+level 3:  7 orbits; 4 fixed; index 30
+level 2:  3 orbits; 3 fixed; index 42
+level 1:  1 orbit; 0 fixed; index 50
+1 orbit; grpsize=252000; 4 gens; 15 nodes; maxlev=5
+canupdates=1; cpu time = 0.00 seconds
+[S7c9fbc52 9edc578 5ff84822]
+ 0 1 21 47 17 12 25 2 3 4 5 26 28 6 20 37 38 19 8 32 14 33 45 39 15 11 13 41
+    46 35 27 31 9 23 34 22 42 43 44 48 16 7 10 49 36 18 24 30 29 40
+  0 :  1 2 3 4 5 6 7;
+  1 :  0 13 21 25 30 38 47;
+  2 :  0 12 19 24 28 37 44;
+  3 :  0 10 20 22 29 35 45;
+  4 :  0 11 18 23 27 36 46;
+  5 :  0 14 15 16 17 26 49;
+  6 :  0 9 31 32 33 34 48;
+  7 :  0 8 39 40 41 42 43;
+  8 :  7 44 45 46 47 48 49;
+  9 :  6 35 36 37 38 43 49;
+ 10 :  3 26 30 32 36 40 44;
+ 11 :  4 26 28 33 38 41 45;
+ 12 :  2 26 27 31 35 39 47;
+ 13 :  1 26 29 34 37 42 46;
+ 14 :  5 19 25 34 36 39 45;
+ 15 :  5 21 23 33 35 42 44;
+ 16 :  5 20 24 31 38 40 46;
+ 17 :  5 18 22 32 37 41 47;
+ 18 :  4 17 25 29 31 43 44;
+ 19 :  2 14 22 30 33 43 46;
+ 20 :  3 16 23 28 34 43 47;
+ 21 :  1 15 24 27 32 43 45;
+ 22 :  3 17 19 27 38 42 48;
+ 23 :  4 15 20 30 37 39 48;
+ 24 :  2 16 21 29 36 41 48;
+ 25 :  1 14 18 28 35 40 48;
+ 26 :  5 10 11 12 13 43 48;
+ 27 :  4 12 21 22 34 40 49;
+ 28 :  2 11 20 25 32 42 49;
+ 29 :  3 13 18 24 33 39 49;
+ 30 :  1 10 19 23 31 41 49;
+ 31 :  6 12 16 18 30 42 45;
+ 32 :  6 10 17 21 28 39 46;
+ 33 :  6 11 15 19 29 40 47;
+ 34 :  6 13 14 20 27 41 44;
+ 35 :  3 9 12 15 25 41 46;
+ 36 :  4 9 10 14 24 42 47;
+ 37 :  2 9 13 17 23 40 45;
+ 38 :  1 9 11 16 22 39 44;
+ 39 :  7 12 14 23 29 32 38;
+ 40 :  7 10 16 25 27 33 37;
+ 41 :  7 11 17 24 30 34 35;
+ 42 :  7 13 15 22 28 31 36;
+ 43 :  7 9 18 19 20 21 26;
+ 44 :  2 8 10 15 18 34 38;
+ 45 :  3 8 11 14 21 31 37;
+ 46 :  4 8 13 16 19 32 35;
+ 47 :  1 8 12 17 20 33 36;
+ 48 :  6 8 22 23 24 25 26;
+ 49 :  5 8 9 27 28 29 30;
+level 4:  20 orbits; 18 fixed; index 4
+level 3:  7 orbits; 4 fixed; index 30
+level 2:  3 orbits; 3 fixed; index 42
+level 1:  1 orbit; 0 fixed; index 50
+1 orbit; grpsize=252000; 4 gens; 15 nodes; maxlev=5
+canupdates=1; cpu time = 0.00 seconds
+ 0:49;
+[fixing partition]
+level 3:  11 orbits; 4 fixed; index 20
+level 2:  5 orbits; 1 fixed; index 36
+level 1:  3 orbits; 2 fixed; index 7
+3 orbits; grpsize=5040; 4 gens; 11 nodes; maxlev=4
+canupdates=1; cpu time = 0.00 seconds
+ 0 1 4:17 19:23 25:28 31:35 37:39 41:49; 2 18 24 29 30 36 40; 3;
diff --git a/lib/nauty/nautest1c.ans b/lib/nauty/nautest1c.ans
new file mode 100644
index 0000000..5b8ebd6
--- /dev/null
+++ b/lib/nauty/nautest1c.ans
@@ -0,0 +1,142 @@
+  0 :  2 3 5 15 25 35 45;
+  1 :  3 4 6 16 26 36 46;
+  2 :  0 4 7 17 27 37 47;
+  3 :  0 1 8 18 28 38 48;
+  4 :  1 2 9 19 29 39 49;
+  5 :  0 6 9 10 20 30 40;
+  6 :  1 5 7 11 21 31 41;
+  7 :  2 6 8 12 22 32 42;
+  8 :  3 7 9 13 23 33 43;
+  9 :  4 5 8 14 24 34 44;
+ 10 :  5 12 13 16 27 38 49;
+ 11 :  6 13 14 17 28 39 45;
+ 12 :  7 10 14 18 29 35 46;
+ 13 :  8 10 11 19 25 36 47;
+ 14 :  9 11 12 15 26 37 48;
+ 15 :  0 14 16 19 23 32 41;
+ 16 :  1 10 15 17 24 33 42;
+ 17 :  2 11 16 18 20 34 43;
+ 18 :  3 12 17 19 21 30 44;
+ 19 :  4 13 15 18 22 31 40;
+ 20 :  5 17 22 23 29 36 48;
+ 21 :  6 18 23 24 25 37 49;
+ 22 :  7 19 20 24 26 38 45;
+ 23 :  8 15 20 21 27 39 46;
+ 24 :  9 16 21 22 28 35 47;
+ 25 :  0 13 21 26 29 34 42;
+ 26 :  1 14 22 25 27 30 43;
+ 27 :  2 10 23 26 28 31 44;
+ 28 :  3 11 24 27 29 32 40;
+ 29 :  4 12 20 25 28 33 41;
+ 30 :  5 18 26 32 33 39 47;
+ 31 :  6 19 27 33 34 35 48;
+ 32 :  7 15 28 30 34 36 49;
+ 33 :  8 16 29 30 31 37 45;
+ 34 :  9 17 25 31 32 38 46;
+ 35 :  0 12 24 31 36 39 43;
+ 36 :  1 13 20 32 35 37 44;
+ 37 :  2 14 21 33 36 38 40;
+ 38 :  3 10 22 34 37 39 41;
+ 39 :  4 11 23 30 35 38 42;
+ 40 :  5 19 28 37 42 43 46;
+ 41 :  6 15 29 38 43 44 47;
+ 42 :  7 16 25 39 40 44 48;
+ 43 :  8 17 26 35 40 41 49;
+ 44 :  9 18 27 36 41 42 45;
+ 45 :  0 11 22 33 44 46 49;
+ 46 :  1 12 23 34 40 45 47;
+ 47 :  2 13 24 30 41 46 48;
+ 48 :  3 14 20 31 42 47 49;
+ 49 :  4 10 21 32 43 45 48;
+Mode=Traces m=2 n=50 labelorg=0 edges=175 options=(-c+a+m-p-d-P y=100 k=(0,1))
+linelen=78 worksize=60 input_depth=0 G=10; 1 cell
+Gen(A) #1: (0 11 32 10 26 35 6 15 13 30 12 1)(2 17 34 38 22 24 21 23 8 33 29 4)(3 45 28
+    49 27 43 31 41 19 47 18 46)(5 14 36)(7 16 25 39)(9 37 20)(40 48 44)
+Gen(A) #2: (0 35 12 7 2)(3 36 46 6 4)(5 39 18 32 47)(8 37 45 31 29)(9 38 44 34 41)
+   (10 42 17 15 24)(11 19 28 13 40)(14 22 27 25 43)(20 23 21 49 48)
+ Level 1:  3 cells; 1 singleton; target cell: 50; 1 orbit; 3 nodes (1 kept); 1 update; group_level: 4
+ Level 2:  7 cells; 3 singletons; target cell: 42; 1 orbit; 1 node (1 kept); 1 update; group_level: 4
+ Level 3:  20 cells; 10 singletons; target cell: 30; 1 orbit; 1 node (1 kept); 1 update; group_level: 4
+ Level 4:  50 cells; 50 singletons; target cell: 4; 1 orbit; 1 node (1 kept); 1 update; group_level: 4
+1 orbit; grpsize=252000; 2 gens; 16 nodes (2 peak); maxlev=4
+cpu time = 0.00 seconds
+ 0:49 (50);
+ Level 1:  3 cells; 1 singleton; target cell: 50; 1 orbit; 3 nodes (1 kept); 1 update; group_level: 4
+ Level 2:  7 cells; 3 singletons; target cell: 42; 1 orbit; 1 node (1 kept); 1 update; group_level: 4
+ Level 3:  20 cells; 10 singletons; target cell: 30; 1 orbit; 1 node (1 kept); 1 update; group_level: 4
+ Level 4:  50 cells; 50 singletons; target cell: 4; 1 orbit; 1 node (1 kept); 1 update; group_level: 4
+1 orbit; grpsize=252000; 2 gens; 16 nodes (2 peak); maxlev=4
+canupdates=1; cpu time = 0.00 seconds
+[T59831010 1d19a3af 43c72725]
+ Level 1:  3 cells; 1 singleton; target cell: 50; 1 orbit; 3 nodes (1 kept); 1 update; group_level: 4
+ Level 2:  7 cells; 3 singletons; target cell: 42; 1 orbit; 1 node (1 kept); 1 update; group_level: 4
+ Level 3:  20 cells; 10 singletons; target cell: 30; 1 orbit; 1 node (1 kept); 1 update; group_level: 4
+ Level 4:  50 cells; 50 singletons; target cell: 4; 1 orbit; 1 node (1 kept); 1 update; group_level: 4
+1 orbit; grpsize=252000; 2 gens; 16 nodes (2 peak); maxlev=4
+canupdates=1; cpu time = 0.00 seconds
+[T59831010 1d19a3af 43c72725]
+ 13 16 47 5 39 28 20 22 29 42 11 33 14 7 30 41 32 19 21 4 45 40 17 3 27 49 25
+    26 18 2 24 34 31 10 8 46 23 38 12 43 44 1 36 48 15 37 35 6 9 0
+  0 :  9 14 16 23 34 36 43;
+  1 :  10 13 18 21 34 35 44;
+  2 :  8 12 17 22 34 37 42;
+  3 :  11 15 19 24 34 38 45;
+  4 :  12 20 23 28 31 38 44;
+  5 :  14 20 24 27 32 35 42;
+  6 :  15 20 21 26 30 37 43;
+  7 :  13 20 22 25 33 36 45;
+  8 :  2 19 21 28 32 36 46;
+  9 :  0 18 22 27 30 38 46;
+ 10 :  1 16 24 25 31 37 46;
+ 11 :  3 17 23 26 33 35 46;
+ 12 :  2 4 18 24 33 40 43;
+ 13 :  1 7 19 23 30 40 42;
+ 14 :  0 5 17 21 31 40 45;
+ 15 :  3 6 16 22 32 40 44;
+ 16 :  0 10 15 28 33 39 42;
+ 17 :  2 11 14 25 30 39 44;
+ 18 :  1 9 12 26 32 39 45;
+ 19 :  3 8 13 27 31 39 43;
+ 20 :  4 5 6 7 34 39 46;
+ 21 :  1 6 8 14 33 38 47;
+ 22 :  2 7 9 15 31 35 47;
+ 23 :  0 4 11 13 32 37 47;
+ 24 :  3 5 10 12 30 36 47;
+ 25 :  7 10 17 29 32 38 43;
+ 26 :  6 11 18 29 31 36 42;
+ 27 :  5 9 19 29 33 37 44;
+ 28 :  4 8 16 29 30 35 45;
+ 29 :  25 26 27 28 34 40 47;
+ 30 :  6 9 13 17 24 28 48;
+ 31 :  4 10 14 19 22 26 48;
+ 32 :  5 8 15 18 23 25 48;
+ 33 :  7 11 12 16 21 27 48;
+ 34 :  0 1 2 3 20 29 48;
+ 35 :  1 5 11 22 28 41 43;
+ 36 :  0 7 8 24 26 41 44;
+ 37 :  2 6 10 23 27 41 45;
+ 38 :  3 4 9 21 25 41 42;
+ 39 :  16 17 18 19 20 41 47;
+ 40 :  12 13 14 15 29 41 46;
+ 41 :  35 36 37 38 39 40 48;
+ 42 :  2 5 13 16 26 38 49;
+ 43 :  0 6 12 19 25 35 49;
+ 44 :  1 4 15 17 27 36 49;
+ 45 :  3 7 14 18 28 37 49;
+ 46 :  8 9 10 11 20 40 49;
+ 47 :  21 22 23 24 29 39 49;
+ 48 :  30 31 32 33 34 41 49;
+ 49 :  42 43 44 45 46 47 48;
+ Level 1:  3 cells; 1 singleton; target cell: 50; 1 orbit; 3 nodes (1 kept); 1 update; group_level: 4
+ Level 2:  7 cells; 3 singletons; target cell: 42; 1 orbit; 1 node (1 kept); 1 update; group_level: 4
+ Level 3:  20 cells; 10 singletons; target cell: 30; 1 orbit; 1 node (1 kept); 1 update; group_level: 4
+ Level 4:  50 cells; 50 singletons; target cell: 4; 1 orbit; 1 node (1 kept); 1 update; group_level: 4
+1 orbit; grpsize=252000; 2 gens; 16 nodes (2 peak); maxlev=4
+canupdates=1; cpu time = 0.00 seconds
+ 0:49 (50);
+ Level 1:  7 cells; 2 singletons; target cell: 42; 3 orbits; 4 nodes (1 kept); 1 update; group_level: 2
+ Level 2:  20 cells; 9 singletons; target cell: 30; 3 orbits; 1 node (1 kept); 1 update; group_level: 2
+ Level 3:  50 cells; 50 singletons; target cell: 4; 3 orbits; 2 nodes (1 kept); 1 update;
+3 orbits; grpsize=5040; 4 gens; 16 nodes (2 peak); maxlev=3
+canupdates=1; cpu time = 0.00 seconds
+ 0:2 4 5 8:12 14:30 32 34:37 40:49 (42); 3; 6 7 13 31 33 38 39 (7);
diff --git a/lib/nauty/nautest1c.dre b/lib/nauty/nautest1c.dre
new file mode 100644
index 0000000..9e86919
--- /dev/null
+++ b/lib/nauty/nautest1c.dre
@@ -0,0 +1,143 @@
+  0 :  2 3 5 15 25 35 45;
+  1 :  3 4 6 16 26 36 46;
+  2 :  0 4 7 17 27 37 47;
+  3 :  0 1 8 18 28 38 48;
+  4 :  1 2 9 19 29 39 49;
+  5 :  0 6 9 10 20 30 40;
+  6 :  1 5 7 11 21 31 41;
+  7 :  2 6 8 12 22 32 42;
+  8 :  3 7 9 13 23 33 43;
+  9 :  4 5 8 14 24 34 44;
+ 10 :  5 12 13 16 27 38 49;
+ 11 :  6 13 14 17 28 39 45;
+ 12 :  7 10 14 18 29 35 46;
+ 13 :  8 10 11 19 25 36 47;
+ 14 :  9 11 12 15 26 37 48;
+ 15 :  0 14 16 19 23 32 41;
+ 16 :  1 10 15 17 24 33 42;
+ 17 :  2 11 16 18 20 34 43;
+ 18 :  3 12 17 19 21 30 44;
+ 19 :  4 13 15 18 22 31 40;
+ 20 :  5 17 22 23 29 36 48;
+ 21 :  6 18 23 24 25 37 49;
+ 22 :  7 19 20 24 26 38 45;
+ 23 :  8 15 20 21 27 39 46;
+ 24 :  9 16 21 22 28 35 47;
+ 25 :  0 13 21 26 29 34 42;
+ 26 :  1 14 22 25 27 30 43;
+ 27 :  2 10 23 26 28 31 44;
+ 28 :  3 11 24 27 29 32 40;
+ 29 :  4 12 20 25 28 33 41;
+ 30 :  5 18 26 32 33 39 47;
+ 31 :  6 19 27 33 34 35 48;
+ 32 :  7 15 28 30 34 36 49;
+ 33 :  8 16 29 30 31 37 45;
+ 34 :  9 17 25 31 32 38 46;
+ 35 :  0 12 24 31 36 39 43;
+ 36 :  1 13 20 32 35 37 44;
+ 37 :  2 14 21 33 36 38 40;
+ 38 :  3 10 22 34 37 39 41;
+ 39 :  4 11 23 30 35 38 42;
+ 40 :  5 19 28 37 42 43 46;
+ 41 :  6 15 29 38 43 44 47;
+ 42 :  7 16 25 39 40 44 48;
+ 43 :  8 17 26 35 40 41 49;
+ 44 :  9 18 27 36 41 42 45;
+ 45 :  0 11 22 33 44 46 49;
+ 46 :  1 12 23 34 40 45 47;
+ 47 :  2 13 24 30 41 46 48;
+ 48 :  3 14 20 31 42 47 49;
+ 49 :  4 10 21 32 43 45 48;
+Mode=Traces m=2 n=50 labelorg=0 edges=175 options=(-c+a+m-p-d-P y=100 k=(0,1))
+linelen=78 worksize=60 input_depth=0 G=10; 1 cell
+(0 16 5 24 20 47 29 46 25 1)(2 33 40 21 36)(3 15 10 9 22 48 41 12 34 26)(4 45
+    42 6 35 17 30 28 23 13)(7 31 43 18 32 27 8 19 49 44)(11 39)(14 38)
+(0 45 22 19 18 30 47 2)(1 8 16 9)(3 33 24 4)(5 46 7 15 44 26 13 17)(6 23 42
+    14 36 43 10 34)(11 20 40 12 32 41 27 25)(21 39 48 37 35 49 38 31)(28 29)
+group time: 0.0000, 0.0000, 0.0000, group order time: 0.0000; 
+0 refinements interrupted by trace comparison
+------
+CandList length: 1; GarbList length: 1
+1 orbit; grpsize=252000; 2 gens; 16 nodes; maxlev=4; canlist=1
+cpu time = 0.00 seconds
+ 0:49;
+group time: 0.0000, 0.0000, 0.0000, group order time: 0.0000; 
+0 refinements interrupted by trace comparison
+------
+CandList length: 1; GarbList length: 1
+1 orbit; grpsize=252000; 2 gens; 16 nodes; maxlev=4; canlist=1
+canupdates=1; cpu time = 0.00 seconds
+[T2248f06c 652ffd7d 4b56e2d9]
+group time: 0.0000, 0.0000, 0.0000, group order time: 0.0000; 
+0 refinements interrupted by trace comparison
+------
+CandList length: 1; GarbList length: 1
+1 orbit; grpsize=252000; 3 gens; 17 nodes; maxlev=4; canlist=1
+canupdates=1; cpu time = 0.00 seconds
+[T2248f06c 652ffd7d 4b56e2d9]
+ 0 1 2 22 43 26 46 29 47 32 17 15 37 14 13 4 20 21 41 6 12 3 36 40 45 10 8 38
+    34 49 27 28 35 19 39 9 25 30 5 24 16 11 18 23 48 42 33 7 44 31
+  0 :  43 44 45 46 47 48 49;
+  1 :  37 38 39 40 41 42 49;
+  2 :  28 29 30 31 36 42 48;
+  3 :  14 18 22 27 36 40 46;
+  4 :  12 17 19 26 36 38 44;
+  5 :  13 16 21 24 36 37 45;
+  6 :  11 15 20 25 36 39 43;
+  7 :  15 23 26 31 33 40 45;
+  8 :  17 23 27 30 34 37 43;
+  9 :  18 23 24 29 32 39 44;
+ 10 :  16 23 25 28 35 38 46;
+ 11 :  6 22 24 31 34 38 47;
+ 12 :  4 21 25 30 32 40 47;
+ 13 :  5 19 27 28 33 39 47;
+ 14 :  3 20 26 29 35 37 47;
+ 15 :  6 7 21 27 35 42 44;
+ 16 :  5 10 22 26 32 42 43;
+ 17 :  4 8 20 24 33 42 46;
+ 18 :  3 9 19 25 34 42 45;
+ 19 :  4 13 18 31 35 41 43;
+ 20 :  6 14 17 28 32 41 45;
+ 21 :  5 12 15 29 34 41 46;
+ 22 :  3 11 16 30 33 41 44;
+ 23 :  7 8 9 10 36 41 47;
+ 24 :  5 9 11 17 35 40 48;
+ 25 :  6 10 12 18 33 37 48;
+ 26 :  4 7 14 16 34 39 48;
+ 27 :  3 8 13 15 32 38 48;
+ 28 :  2 10 13 20 34 40 44;
+ 29 :  2 9 14 21 33 38 43;
+ 30 :  2 8 12 22 35 39 45;
+ 31 :  2 7 11 19 32 37 46;
+ 32 :  9 12 16 20 27 31 49;
+ 33 :  7 13 17 22 25 29 49;
+ 34 :  8 11 18 21 26 28 49;
+ 35 :  10 14 15 19 24 30 49;
+ 36 :  2 3 4 5 6 23 49;
+ 37 :  1 5 8 14 25 31 44;
+ 38 :  1 4 10 11 27 29 45;
+ 39 :  1 6 9 13 26 30 46;
+ 40 :  1 3 7 12 24 28 43;
+ 41 :  1 19 20 21 22 23 48;
+ 42 :  1 2 15 16 17 18 47;
+ 43 :  0 6 8 16 19 29 40;
+ 44 :  0 4 9 15 22 28 37;
+ 45 :  0 5 7 18 20 30 38;
+ 46 :  0 3 10 17 21 31 39;
+ 47 :  0 11 12 13 14 23 42;
+ 48 :  0 2 24 25 26 27 41;
+ 49 :  0 1 32 33 34 35 36;
+group time: 0.0000, 0.0000, 0.0000, group order time: 0.0000; 
+0 refinements interrupted by trace comparison
+------
+CandList length: 1; GarbList length: 1
+1 orbit; grpsize=252000; 2 gens; 16 nodes; maxlev=4; canlist=1
+canupdates=1; cpu time = 0.00 seconds
+ 0:49;
+group time: 0.0000, 0.0000, 0.0000, group order time: 0.0000; 
+0 refinements interrupted by trace comparison
+------
+CandList length: 1; GarbList length: 1
+3 orbits; grpsize=5040; 2 gens; 12 nodes; maxlev=3; canlist=1
+canupdates=1; cpu time = 0.00 seconds
+ 0:2 5:10 12:25 27:32 34:36 38 40:48; 3; 4 11 26 33 37 39 49;
diff --git a/lib/nauty/nautest2.dre b/lib/nauty/nautest2.dre
new file mode 100644
index 0000000..f708f5c
--- /dev/null
+++ b/lib/nauty/nautest2.dre
@@ -0,0 +1,7 @@
+n=12 $=1 g
+2;3;4;5;6;7;8;9;10;11;12;1.
+v
+i & 
+x
+c xz jxz
+q
diff --git a/lib/nauty/nautest2a.ans b/lib/nauty/nautest2a.ans
new file mode 100644
index 0000000..caff68d
--- /dev/null
+++ b/lib/nauty/nautest2a.ans
@@ -0,0 +1,24 @@
+1-12:2 
+ 1 cell; code = 41; cpu time = 0.0000000 seconds
+unit partition
+(2 12)(3 11)(4 10)(5 9)(6 8)
+level 2:  7 orbits; 5 fixed; index 2
+(1 2 3 4 5 6 7 8 9 10 11 12)
+level 1:  1 orbit; 1 fixed; index 12
+1 orbit; grpsize=24; 2 gens; 6 nodes; maxlev=3
+cpu time = 0.00 seconds
+(2 12)(3 11)(4 10)(5 9)(6 8)
+level 2:  7 orbits; 5 fixed; index 2
+(1 2 3 4 5 6 7 8 9 10 11 12)
+level 1:  1 orbit; 1 fixed; index 12
+1 orbit; grpsize=24; 2 gens; 6 nodes; maxlev=3
+canupdates=1; cpu time = 0.00 seconds
+[N2552efde 394889fc 3c67aaf3]
+(2 8)(3 9)(4 5)(6 7)(10 11)
+level 2:  7 orbits; 2 fixed; index 2
+(1 2)(3 6)(4 12)(7 11)(9 10)
+(1 3)(2 7)(4 6)(5 9)(8 10)(11 12)
+level 1:  1 orbit; 1 fixed; index 12
+1 orbit; grpsize=24; 3 gens; 8 nodes; maxlev=3
+canupdates=1; cpu time = 0.00 seconds
+[N2552efde 394889fc 3c67aaf3]
diff --git a/lib/nauty/nautest2b.ans b/lib/nauty/nautest2b.ans
new file mode 100644
index 0000000..609c372
--- /dev/null
+++ b/lib/nauty/nautest2b.ans
@@ -0,0 +1,24 @@
+1-12:2 
+ 1 cell; code = 3; cpu time = 0.0000000 seconds
+unit partition
+(2 12)(3 11)(4 10)(5 9)(6 8)
+level 2:  7 orbits; 5 fixed; index 2
+(1 2 3 4 5 6 7 8 9 10 11 12)
+level 1:  1 orbit; 1 fixed; index 12
+1 orbit; grpsize=24; 2 gens; 6 nodes; maxlev=3
+cpu time = 0.00 seconds
+(2 12)(3 11)(4 10)(5 9)(6 8)
+level 2:  7 orbits; 5 fixed; index 2
+(1 2 3 4 5 6 7 8 9 10 11 12)
+level 1:  1 orbit; 1 fixed; index 12
+1 orbit; grpsize=24; 2 gens; 6 nodes; maxlev=3
+canupdates=1; cpu time = 0.00 seconds
+[S694e3b60 2ef1aacb 10268774]
+(2 8)(3 9)(4 5)(6 7)(10 11)
+level 2:  7 orbits; 2 fixed; index 2
+(1 2)(3 6)(4 12)(7 11)(9 10)
+(1 3)(2 7)(4 6)(5 9)(8 10)(11 12)
+level 1:  1 orbit; 1 fixed; index 12
+1 orbit; grpsize=24; 3 gens; 8 nodes; maxlev=3
+canupdates=1; cpu time = 0.00 seconds
+[S694e3b60 2ef1aacb 10268774]
diff --git a/lib/nauty/nautest2c.ans b/lib/nauty/nautest2c.ans
new file mode 100644
index 0000000..efcaf03
--- /dev/null
+++ b/lib/nauty/nautest2c.ans
@@ -0,0 +1,17 @@
+1-12:2 
+ 1 cell; code = 1; cpu time = 0.0000000 seconds
+unit partition
+Gen #1: (1 12 11 10 9 8 7 6 5 4 3 2)
+Gen #2: (1 2)(3 12)(4 11)(5 10)(6 9)(7 8)
+1 orbit; grpsize=24; 2 gens; 1 node (1 peak); maxlev=0
+cpu time = 0.00 seconds
+Gen #1: (1 12 11 10 9 8 7 6 5 4 3 2)
+Gen #2: (1 2)(3 12)(4 11)(5 10)(6 9)(7 8)
+1 orbit; grpsize=24; 2 gens; 1 node (1 peak); maxlev=0
+canupdates=0; cpu time = 0.00 seconds
+[T40ae9d28 336706d1 2832ac44]
+Gen #1: (1 11 5 7 2 9 12 3 8 6 4 10)
+Gen #2: (1 10)(2 3)(4 11)(5 6)(7 8)(9 12)
+1 orbit; grpsize=24; 2 gens; 1 node (1 peak); maxlev=0
+canupdates=0; cpu time = 0.00 seconds
+[T40ae9d28 336706d1 2832ac44]
diff --git a/lib/nauty/nautesta.ans b/lib/nauty/nautesta.ans
new file mode 100644
index 0000000..3d08949
--- /dev/null
+++ b/lib/nauty/nautesta.ans
@@ -0,0 +1,2 @@
+>A ./geng -td1D7 n=11 e=6-30
+>Z 92779 graphs generated in 0.14 sec
diff --git a/lib/nauty/nautestb.ans b/lib/nauty/nautestb.ans
new file mode 100644
index 0000000..0685980
--- /dev/null
+++ b/lib/nauty/nautestb.ans
@@ -0,0 +1,3391 @@
+I??????~w
+I?????@~g
+I?????@~w
+I?????B~O
+I?????B~G
+I?????B~W
+I?????F}O
+I?????F}G
+I?????F}W
+I?????N{O
+I????AF]G
+I?????N{W
+I????GA}W
+I???G?@}w
+I???G?@~w
+I????GB}G
+I????GB}_
+I????GB}g
+I????GB~_
+I????GB}W
+I????GI{o
+I????CK|o
+I????OE{W
+I????OE{w
+I????CK{w
+I????CK|w
+I????CL{O
+I????OF{_
+I????CL{_
+I????CL{o
+I????GJ|_
+I????OF{G
+I????OF{W
+I????OF{g
+I????_Mwo
+I????C[xo
+I????_MwW
+I????_Mww
+I????C[ww
+I????C[xw
+I???C@FMO
+I????FaFO
+I????C\wo
+I????GZx_
+I???C@FMW
+I???G?xoo
+I????C{po
+I???G?xow
+I????C{ow
+I????C{pw
+I????CB~G
+I????CF}O
+I????CF~?
+I????CF}G
+I????CF~G
+I????CN{O
+I????CN|?
+I????CN|G
+I???OGB{G
+I???OGB|?
+I????SE~?
+I????SE{G
+I???GCH{W
+I???OCD|G
+I???GCH|G
+I????SE~G
+I????gIx_
+I????cKwg
+I????gIxg
+I????cKwW
+I????KWww
+I????gIxw
+I???GCXwO
+I???GCXx?
+I????cMx?
+I????SUz?
+I????KYwO
+I????KYwo
+I????KYxO
+I????SUxO
+I????KYzO
+I???_CLwW
+I???GCXxG
+I????cMxG
+I????SUzG
+I???@GYp_
+I????Wqoo
+I????Sspo
+I????Kwog
+I???@GYpg
+I???@C[ow
+I???@_Mow
+I???@GYpw
+I????NKM_
+I????SurO
+I????NKMg
+I???CGN[_
+I???CGN[g
+I????SF{_
+I????SF|?
+I????SF~?
+I????SF{G
+I????SF|G
+I????KXw_
+I????gJx_
+I???E?FMG
+I????oFwg
+I????cLwW
+I???GCxoo
+I????KZx?
+I????SVz?
+I????KZxO
+I???CGZX_
+I???@SUr?
+I????]QWg
+I???CLcEg
+I???@SUrG
+I???BGY`_
+I???EGMKg
+I????KZwO
+I???BGY`w
+I???EWiDg
+I???_OCww
+I???G_Gxw
+I?C?G?@zw
+I?C?G?@~w
+I???G_Hwg
+I???OGPx_
+I??G?_Bxg
+I?C??GBz_
+I???G_Hxg
+I???G_Hz_
+I???G_Hzg
+I?C??GB~_
+I???_ODww
+I???G_Hxw
+I???OGRwO
+I???_OFx?
+I???G_Jx?
+I???OGRxO
+I???GORxO
+I???_OFz?
+I???OGRz?
+I???OGRzO
+I???OGR~?
+I???_OFwW
+I???_OFxG
+I???_Ocpo
+I??O?Cgro
+I??G?Covo
+I???OGoow
+I???_Ocpw
+I??G?Copw
+I???H?Wrw
+I??G?Corw
+I??G?Covw
+I???OGpoo
+I??G@?Rp_
+I??@?GXp_
+I??G?Cppo
+I???_Odr_
+I???GOppo
+I???H?Xr_
+I???GOpr_
+I???GOpro
+I???G_hv_
+I???OGqoW
+I??@?_Low
+I??G@?Rpg
+I???H?Xpg
+I???H?Xpw
+I???H?Xrg
+I??C?GZXO
+I???K@dEo
+I???OJKKo
+I???OGrrO
+I???OGrv?
+I???_Pc`o
+I?C??Dcbo
+I??G?Dofo
+I???OHo_w
+I???_Pc`w
+I??G?Do`w
+I?C??Dcbw
+I??G?Dobw
+I??G?Dofw
+I??C?GN[O
+I??O?Dhb_
+I???K?xPo
+I??O?Dkao
+I???GPpb_
+I???GPpbo
+I???G`hf_
+I???K?xPw
+I??O?Dkaw
+I?C??FcBo
+I??G?FoFo
+I?C??FcBw
+I??G?FoBw
+I??G?FoFw
+I??G?CB|G
+I??G?CB~G
+I??G?CF{O
+I???GOF{O
+I??G?CF}?
+I??G?CF}O
+I???GOF}O
+I??G?CF{G
+I???GOF{W
+I??G?CRxO
+I?C??CFz?
+I??G?CRzO
+I??G?CR~?
+I??O?CJxG
+I?C??CFzG
+I??G?CRzG
+I??G?CR~G
+I??G?CVyO
+I???GOVyO
+I???G_N}?
+I??G?CrrO
+I??G?Crv?
+I??G?FKKw
+I??G?CrvG
+I???GON{O
+I???GgIwG
+I???W_DwG
+I??GGCPy?
+I??GGCPyG
+I??OGCHyG
+I??OOCDyG
+I???GgI}?
+I???GgI}G
+I???WGPwW
+I??OOGBwW
+I???W_DyW
+I???GgIwW
+I???GcKyW
+I???GgI}W
+I???h?HpG
+I???Gcgr?
+I???`OErG
+I??@_ODv?
+I??@G_HpW
+I??@?KWoW
+I???HCWpG
+I??@?SSpW
+I???PCSrG
+I??@?KWpW
+I???OKorG
+I??@?KWrW
+I???OKovG
+I??@_ODow
+I??@G_Hpw
+I???GckqO
+I???OKwp?
+I???GSsqO
+I??GGCpqO
+I???Ggiu?
+I???GSsuO
+I???OKsoo
+I??G?Kqoo
+I???_KkqO
+I???_Kkqo
+I??CGHHKW
+I???HGYqW
+I???OKwpG
+I???GWqqW
+I??GGCpqW
+I???GgiuG
+I???GgiuW
+I???_Lgb?
+I???_LgbO
+I???OLof?
+I???_Tc`o
+I??OCGJWg
+I???_LgbG
+I???_KLwG
+I???OLobG
+I??A?SsbW
+I???OLofG
+I???OLo_w
+I???_Tc`w
+I??G?pbd_
+I??A?SubO
+I??G?orp_
+I??G?orpg
+I???OKK{G
+I???WOD{W
+I???OK[wO
+I??GGCXwO
+I???OK[{?
+I???OK[{O
+I??G?KYwo
+I???OK[wo
+I???OK[{o
+I???WOTwW
+I???OK[{G
+I??G?Krq_
+I???ONILO
+I???OKtu_
+I???OK{so
+I???GcJx?
+I???_SFz?
+I???_SFxG
+I???_SF~?
+I??@?SVr?
+I???OKrr?
+I???OKrv?
+I??__OBpG
+I??O?Sar?
+I@??OGBv?
+I??H?_BrG
+I??H?CPv?
+I@??OGB~?
+I??_OCPpG
+I??H?CPpW
+I??O@CIrG
+I??_OCPrG
+I@??GCHvG
+I??G@CQrG
+I??H?CPrW
+I??H?CPvG
+I?C?GC`vG
+I?C?GC`~G
+I???W_dqO
+I??_?SUu?
+I???gOdqO
+I??G_CdqO
+I???W_du?
+I???gOduO
+I??_G_Ju?
+I??OOCd}?
+I??GB?R`_
+I???Ogeoo
+I??G?ceoo
+I??O?SeqO
+I???_Weqo
+I??@?gMqO
+I??@?WUuO
+I??G?ceqO
+I???Ogeqo
+I??G?ceqo
+I??G?ceuO
+I???Ogeuo
+I??G@CUuO
+I??G?ce}O
+I??GH?RqW
+I??_?SUuG
+I??A@OSb_
+I?C?AGaf_
+I??@AGW`g
+I??OAOabg
+I???IOobg
+I???I_gfg
+I??A@GW_w
+I???P`C`w
+I?C?AGabw
+I???IOo`w
+I???H`Gbw
+I?C?AGafw
+I???gP`b?
+I???oH`bO
+I???Q_ef?
+I??E@_EAW
+I???Oha`o
+I??@?hIbO
+I???M?JL?
+I???Gpa`o
+I???OhabO
+I???Gpabo
+I???H`IbO
+I???PHQfO
+I???[?pPW
+I??@I?X`w
+I??A@OUbW
+I?C??Lab?
+I??O@DKa_
+I?@?OCpf?
+I??G_D`bO
+I?C?GD`f?
+I??GACqf?
+I?C?GD`n?
+I??G?da`O
+I??G?da`o
+I?C??LabO
+I??_?dIbO
+I??_?TQfO
+I??G?dabO
+I??G?dabo
+I??G?dafO
+I??G@DQfO
+I??G?danO
+I??S?GJWW
+I?C??LabG
+I??O@DKag
+I?@?OCpfG
+I??G_D`bG
+I??I?CpbW
+I?C?GD`fG
+I??GACqfG
+I?C?GD`nG
+I??GG_rqO
+I@G?GATQo
+I???gPdao
+I???W`deo
+I??G@DUmO
+I?C?@FCB_
+I???K`gF_
+I??GE?q@o
+I??@?jGBo
+I???HbGBo
+I???HROFo
+I?C?@FCBg
+I???Gr_Bg
+I???K`gFg
+I???SGF[G
+I???U?FLG
+I?C?CHaBw
+I???M?FMG
+I???KPoBw
+I???M?wBw
+I???K`gFw
+I???gR`Bo
+I???S_VZ?
+I???HO]{?
+I??@?oNt?
+I??G_F`Bo
+I???GoN{?
+I???K_N]?
+I??G@FQNO
+I???HO]{G
+I???oGLwO
+I??G_CLwO
+I?CG?CF{?
+I???oGL{O
+I???GoMwO
+I???GoMwo
+I??G?cMwo
+I???GoM{O
+I???GoM{o
+I?C?GOFwW
+I?CG?CF{G
+I???oGdqO
+I??o?CJu?
+I???Goeoo
+I???Goeqo
+I???H_MqO
+I???HOUuO
+I??o?CJuG
+I???HOUqW
+I???H_MqW
+I???H_MuW
+I???gOlso
+I???HO]{O
+I???OKTw_
+I??G?KRw_
+I??O?SFy?
+I???_KLy_
+I??G?cFy?
+I???OKTy_
+I??G?KRy_
+I??G?cF}?
+I???_KL}_
+I??O?KJyG
+I??G?KRyG
+I??G?KR}G
+I???OgFwg
+I???_Wbp_
+I??@?KXr?
+I???GSpp_
+I???Ocdr?
+I???Gchr_
+I???OKpr?
+I???_Khv?
+I???KGXWg
+I???PCTrG
+I???Gpa_w
+I??_?cJp_
+I?G??KRr?
+I@???SFv?
+I??G@CRr_
+I?C??Kbv?
+I@???SF~?
+I???cGLWg
+I?C?@CFrG
+I??G@CRrG
+I??G@CRvG
+I??@?WVq_
+I???Gpeao
+I??G?deao
+I???Gojt?
+I???Ogfu_
+I??G@CV}?
+I??G?cfuO
+I?C?AGbb_
+I???H`Hb_
+I?C?AGbf_
+I??GE?RHg
+I???M?XHg
+I???J?Xbg
+I??CACdEW
+I???IOp`w
+I???IOrb_
+I???S_fV?
+I??_?pJd_
+I??GACrb_
+I???Gphd_
+I???K_xR_
+I??G@DRn?
+I??G?dbfO
+I???K_xRg
+I???K`hF_
+I???GKXw_
+I???GoFy?
+I???GKXy_
+I???GKXyG
+I???GKXwW
+I???GoN{_
+I???GoN{O
+I??APGRf?
+I??A@SUbG
+I???PK[s_
+I??G@SU{?
+I???HWYp_
+I???Gwisg
+I???PWU{G
+I???IWqag
+I??OCoiPg
+I???GpbbO
+I???IgieW
+I???aSff?
+I?C?Agi`_
+I???`LKe_
+I???Owes?
+I??GAcem?
+IC???xIHg
+I??GAKqag
+I???aKkeg
+I???_weqG
+I??G@LQmG
+I??ACWiDg
+I??E?SsBW
+I??OCoMWg
+I??C?KZXO
+I?C?EGi@w
+I??C?tSJ?
+I???G[ws?
+I@??CTEN?
+I?@?CoiDg
+I??GECqBg
+I???M_wBg
+I???KoM[G
+I??GDDQNG
+I???_libO
+I??G@pRh_
+I???PgMs_
+I???G[qqG
+I??G?]QWg
+I?C??weog
+I???G[wsg
+I???Glgag
+I???Gph`o
+I???N?XBg
+I???G\oeW
+I???`LYbO
+I@??@yIPg
+I??W?CByG
+I???GKWwW
+I???GoEyW
+I???GKwqO
+I???GKXwG
+I???GKwqW
+I???GNIMO
+I???G[qu?
+I???Gser?
+I???Olcag
+I???HcMuG
+I???WKpuG
+I???gWWwG
+I?COOGBwW
+I?C?GcKwW
+I?CGGC`s?
+I?CGH?BsG
+I??GPGQ{?
+I??g_OBoW
+I?CG@CEsG
+I?CH?CDsW
+I??@OgK{G
+I??GoG`oW
+I??G_KgoW
+I??GHCWsG
+I??_OcKsW
+I?CGGC`sG
+I?CGGC`sW
+I??GHOQ{G
+I???XOSoW
+I??GGcgow
+I??GGcgsW
+I??H?gIsw
+I??GPGQ{W
+I??OOKwwO
+I??OGSwoo
+I??W?Sqoo
+I??GGoqoo
+I??GGcwwO
+I??OGSwwo
+I??OOoewW
+I???XHOe?
+I?@_?cIm?
+I???pHG`G
+I??Y?C`aW
+I??@I_KeG
+I??GI_aeG
+I?@_OCPmG
+I??OPB@@o
+I??OGT_aG
+I???gX_eG
+I??_aOEaW
+I???iGgeG
+I??OOL_mG
+I???W```O
+I?@?GSo_w
+I??OGT_aW
+I??GGd_aW
+I??GGd_eW
+I??@GpCaW
+I?@?Goaaw
+I??@GXOeW
+I???X`CeW
+I???iOcmW
+I@GOO@D_o
+I??W?Taco
+I??_GTWco
+I???gXgkO
+I??GGpaco
+I??GHDWco
+I??GGdgkO
+I?CGG_boW
+I@GOO@D_w
+I??GgP`_w
+I???gohpG
+I??GgP`cw
+I??I?Sscw
+I??GHPQkW
+I???gWww?
+I??GGobs?
+I??GGf_MO
+I???gWwwG
+I??GGoRwG
+I??@_oLpG
+I???k_LYG
+I??GHFOMW
+I??GOctw_
+I??GGcXw_
+I??W?cJw_
+I??OGoJwg
+I???ogLw_
+I???gWXx_
+I???ogLx_
+I??GHCXs_
+I??GPGR{?
+I??GGobp_
+I???XGXs_
+I??GGobt_
+I???XOT{_
+I???Wgxx_
+I?C?GTsgo
+I???Whde_
+I?@?Gcjf?
+I??_GdMeO
+I??_GdJn?
+I???WpedO
+I???gYqYO
+I???gYqYW
+I???Wpdd_
+I???WiqYO
+I???golw_
+I?GP?`H`_
+I??@OhK{?
+I??C_WsQO
+I??_GpIco
+I?COAKaaG
+I??W@DIco
+I??@OhKkO
+I??C_xGHG
+I??AOgkkO
+I???qGkkO
+I??@OhK{O
+I??A@SUb?
+I???pHK`o
+I??@GpKco
+I??@GpKdo
+I??@OhKko
+I??APG[co
+I???iOkko
+I??@OhK{o
+IC?GO`DGw
+I?GP?`H`g
+I??@OhK{G
+I??CaOcF?
+I??@Oj?BG
+I??APIOFG
+I???[`_@W
+I??COh_BW
+I??CaOcFW
+I??E@GW?w
+I??CIOo@w
+I??E@OSBw
+I??CaOcFw
+I??@QG[k?
+I??@OgLs?
+I??C_odR?
+I??A_YcMO
+I?CG?Kbs?
+I??GGoqoO
+I???iQcMO
+I?@_s?D?w
+I??@_NGBO
+I??BGiGAW
+I???pJCBo
+I??@OjCEo
+I??B?KXb?
+I???ZASEo
+I??@QISEo
+I???YacMo
+I??@QG[kG
+I??OKPaAw
+I??GK_RYG
+I??GM?RMG
+I??@S_TRG
+I??GL@QMW
+I??GJ?ru?
+I??@GoNt?
+I??@OgN{?
+I??@OjK[o
+I?G?OKTs_
+I??W@CJs_
+I???gWh{?
+I??@OWT{G
+I???oWdp_
+I??@OgLs_
+I???gWhp_
+I??_GSXt_
+I???pGLs_
+I??W?Sbt_
+I??@OgL{_
+I??@GWXsg
+I???gWhsg
+I???gWh{g
+I?@_?cJm?
+I?@G@CRb_
+I??A_Wde_
+I??B?gLe_
+I??B?gLm_
+I??@OhI`W
+I??@aGLeg
+I???iOdm?
+I???s_dRG
+I??CQKSIG
+I??@GpDb_
+I???XHPe_
+I??@GXPe_
+I???gX`e_
+I???gX`m_
+I??@GhIaW
+I??AGWqaW
+I???iGheg
+I???]?hDW
+I??_GpJd_
+I???hQqRO
+I??@IO\{_
+I??@OhLko
+I??B?iIBO
+I??E@OTB_
+I??CaOdF_
+I??E@OUBW
+I??CGLHKW
+I??@QG\k_
+I??@QG]kO
+I??@OgN{O
+I??@I_Nm?
+I???iWwh_
+I???qgkw_
+I@??xAHPW
+I??_KdIN?
+I?C?aKkgg
+I??@Olce?
+I?C?_LbbO
+I??GPadSo
+I??GHpRh_
+I??GHyaSg
+I??BCtSJG
+I?COF@IH_
+I???g\oi?
+I??@ogLw?
+I???XhWg_
+I??@ShK[_
+I?OGBaQHg
+I??CWpcDW
+I??@goLwG
+I??@QYS[g
+I?COF@IHg
+I??BAuKLG
+I???g]qYO
+I???g[wx?
+I???g[wxG
+I?@_GcJm?
+I??_IcMeG
+I???g\ceG
+I??_GlIeG
+I???g\cmG
+I???ZOUkG
+I???WtcdG
+I???g\oiG
+I???o[dsG
+I???scdRG
+I???YgikW
+I???g[wwG
+I??C_tcBW
+I??@OlK{?
+I??@YOTkG
+I???{`HHW
+I?A?GxQIg
+I??@OlceG
+I??@OlK{G
+I??@QK[kG
+I??CaSsBW
+I??EdPKL?
+I??AhZGkG
+I??EdPMLO
+I??__OFqO
+I??H?_FqO
+I??__OFu?
+I??__OFuO
+I??OP?FuO
+I??__OF}?
+I??OP?F}O
+I?@@?_G`w
+I??I@?Obw
+I?C?I?_fw
+IGC?G?@nw
+IGC?G?@~w
+I??OQ?``g
+I??__P@b_
+I??_a?Hbg
+I?@@?_Hf_
+I?C?I?`bg
+I??H?`@f_
+I@??I?Hfg
+IGC??GBn_
+I?C?I?`fg
+I?C?I?`n_
+I?C?I?`ng
+IGC??GB~_
+I??OQ?``w
+I?C?I?`bw
+I?C?I?`fw
+I?C_?EIPO
+I?C@?HBbO
+I?C?H@BbO
+I??_a?Jf?
+I?@?_Obf?
+I@??OHBfO
+IG??OGRn?
+I??H?`BbO
+I??I@?Rf?
+I??Ga?bf?
+I??H?`BfO
+I??G`@BfO
+I??I@?Rn?
+I@??OHBn?
+I??H?`BnO
+I@??OHB~?
+I??OS?dOw
+I?GO?DK_w
+I??I@?RbW
+I??I@?RfG
+I?@?O_rbO
+I??OS@XHo
+I??__QwPo
+I??OP@FmO
+I??__PF}?
+I?@@?aGBo
+I??I@AOFo
+IA?G?E_No
+I@?G?F?^o
+I??__R?@w
+I?@@?aGBw
+I?GO?F?Bw
+I??I@AOFw
+I?C?K@_Fw
+I?C?K@_Nw
+I@?G?F?Nw
+I@?G?F?^w
+I??_aAHB_
+I?GO?F@B_
+I??__R@Bo
+I?@@?aHF_
+I??H?b@Bo
+I?G?K@PF_
+I?G?Gb@F_
+I@??GR@Fo
+I?O?HAPN_
+I?C?HB@Fo
+I?C?K@`N_
+I?C?HB@N_
+I?C?HB@No
+I?C?IA`^_
+I??OS@`@w
+I??_aAHBg
+I?C_?FCAw
+I?C?K@`Bw
+I?G?K@PFg
+I?C?K@`Fg
+I?C?K@`Fw
+I?C?K@`Ng
+I??H?_VqO
+I??OQ?fm?
+I?G?G_VqO
+I?C?K?N[O
+I??HA?]kO
+I??H?_N{?
+I??H?bBNO
+I@??OJB^?
+I?GO?CBrG
+I@?G?CBvG
+I@?G?CB~G
+I?C@?GFqO
+I?G?G_FqO
+I@?G?CFu?
+I@?G?CFuO
+I@??GOFuO
+I?C_?CFuO
+I?C?H?FuO
+I@?G?CF}?
+I@?G?CF}O
+I?C?H?F}O
+I?G?G_FqW
+I?C_?CFuG
+I?C?H?FuW
+I??__ON{O
+I??H?_N{O
+I?GO?DBbO
+I?O_?CRf?
+I@?G?DBfO
+IG?G?CRn?
+I@?G?DBnO
+I@?G?DB~?
+I?O_?CRfG
+I?D??CbfG
+IG?G?CRnG
+I@?G?DBnG
+I@?G?DB~G
+I??I?_rbO
+I?C?K@XHo
+I@?G?EwPo
+I@?G?DFmO
+I?C?H@FmO
+I@?G?DF}?
+I?C?K@XHw
+I??K?`pBo
+I?C?I?fm?
+I@?G?FBNO
+I@?G?FB^?
+I?C?I?fmG
+I@?G?CN{G
+I@?G?FB^G
+I@??GON{O
+I??OS?dOo
+I??OPHAe?
+I??P?TCaW
+I??OY?`eG
+I??PI?HeG
+I?@@G_Hm?
+I?@@?WQeW
+I?@?_ScmG
+I?@@G_H}?
+I?@@G_H_w
+I??IH?PaW
+I?@?X?Paw
+I??OY?`eW
+I?@@G_H`w
+I??P?XBe_
+I?@@?STm?
+I??OPHBe_
+I??GaCdm?
+I?@?_Wbe_
+I??__XBm_
+I??OPHB}?
+I?AAHGICW
+I??I?cdb_
+I??I@GRag
+I??OPHBf_
+I?GO?LAaG
+I?G?GdCe?
+I?OOGC`eG
+I?G?IGQeG
+I?GOI?BeG
+IG??GgIm?
+IG??OKSmG
+I?C?IGaeG
+I?C@I?DeG
+I?D?GC`m?
+I@??OLCmG
+I?D?GC`mG
+I@@?OCDmG
+IG?OOGB}?
+I@??OLC}G
+I?O?h?DaW
+I?O__GBaW
+I?G?gH@eW
+I?C@GH@eW
+I?D@?GBeW
+I?C@I?DmW
+I?O?HGQaW
+I?G?GdCeW
+IG??GgImW
+I?C?IGaeW
+I?C?ICcmW
+IG??GgI}W
+I??G`EIPO
+I??H?hIco
+I?@?OckkO
+I??OSocOg
+I??G`HIco
+I??OQCkkO
+I@?G`AIPO
+I??_OdKkO
+I??HG`HkO
+I??G`HIko
+I?GOGDHkO
+I??Gh@H{?
+I??_OdK{O
+I?CA@CFb?
+I?CACCdB_
+I??OPDK`o
+I??a?S[co
+I??P?TKco
+I??__XIco
+I??P?TKdo
+I?C_?LIco
+I??Q?SkkO
+I?C?ICkko
+I?COS?dOw
+I??Gq?dcw
+I?O?HGYkW
+I?C_AECAg
+I?A?`DGF?
+I?A@Q?PFG
+I?@?_U_N?
+I?C@IA@FG
+I??HAEON?
+I?CAK?`NG
+I@?E?OD^?
+I?@CP?PBW
+I??Ka?`FW
+I??Ge?BHG
+I?C@?N?BG
+I??c?dGBW
+I?@?cCgFG
+I?CC?L_BW
+I?A?_T_FG
+I??c?TOFW
+I?A?_T_NG
+I??K?d_BW
+I??GcD_FG
+I??K@DOFW
+I??HCDONG
+I??K?d_FW
+I@??ON?NG
+I??K?d_NW
+I@??ON?^G
+I?AB?_H@w
+I??Q@EGBw
+I??M@?PBw
+I??I@EOFw
+I?C@ECEBG
+I??OY?wgO
+I?CB?GFaO
+I??S?WbU?
+I??HAOUk?
+I??_OjAEo
+I@??OK[w?
+I??OXB@MO
+I??I?ecMO
+I??__VC]?
+I?B@G_H?w
+I??H?fCAo
+I??H?fCBo
+I??I@ESEo
+I??S?XaAw
+I?COS?FWW
+I??OY?wgW
+I??__VC@w
+I@??gOloo
+I??_bAJV?
+I?A?W`dEo
+I?C?ICmkO
+I??K?cdU?
+I?C@?KLs?
+I??HQ?Tk?
+I?O?GecMO
+I?C?GKhs?
+I??HAC[k?
+I?C?IEcMO
+I@CG?CFw?
+I?C?HFCMO
+I@?GGF@MO
+I@??ONC]?
+I?C?HFC]O
+I?C@?NCAo
+I?@@?WRe?
+I?O@?MSEo
+I??H?cLs?
+I?C@?NCEo
+I?C_?NAEo
+I?CA?McMO
+I?C?IEcMo
+I??PC_JRG
+I??H?oRpG
+I?CK?_FWW
+I??HQ?TkG
+I?_?HHQMW
+I?C?K_FYG
+I?c?G_FWW
+I??HAC[kG
+I?C?KHaMW
+I@CG?CFwG
+I?C?HJAMW
+I@?GGF@MW
+I@??ONC]G
+I?C?IIa]W
+I?G?GoVw_
+I??_b@Jf?
+I?A?gON[O
+I?C@?KLs_
+I?GO?KJs_
+I?G?_KLs_
+I??__WJ{?
+I?C@?KL{_
+I?GO?SF{_
+I??__WJp_
+I??__SLt_
+I??P?WJsg
+I??__WJ|_
+I@??OKKsG
+I@?GOGBsW
+I@??OKK{G
+I@?GOGB{W
+I??H?gYoo
+I@?G?KYoo
+I??__S[wO
+I??OX?XwO
+I??H?gYwo
+I@?GGCXwO
+I@?G?KYwo
+I@??OK[oo
+I??__S[po
+I@??OK[wo
+I??__S[xo
+I??_gPhco
+I@?GGDXgo
+I?A?_TUJO
+I?A?gOlSo
+I@??OMiTO
+I??P?XJl_
+I?@@?S\{_
+IA??OKkkO
+I@?G?LIco
+I@??OLKkO
+I@?GGDHkO
+I@??OLK{?
+I@??OLK{O
+I@?G?LIko
+I@??OLKco
+IA??OKkko
+I@??OLKko
+I@??OLK{o
+I?CK?_bPW
+I@?H?`K_w
+I@?GGPBkW
+I@??OLK{G
+I??__T[ho
+I?@?_S{wo
+I??IBApF_
+I?C_GCxoo
+I?@?_Slk_
+I??H?c\w_
+I??HAC\k_
+I?C@?ND]_
+I??IBApFg
+I@??J?Nu?
+I@?G?cNw_
+I??H?cN{?
+I@??ONK[o
+I??OPGJs_
+I?G?GKXs_
+I??G_Wb{?
+I?C?GKh{_
+I??G_Wbp_
+I??G`CLs_
+I??G_Wbt_
+I??OPGYoo
+I??G`C[wO
+I??_gOXwO
+I??OPGYwo
+I?C_GCXwO
+I??H?c[oo
+I??_OgYoo
+I??OPC[po
+I?C_?KYoo
+I?C?H_MwW
+I@C?GOFwW
+I?CA?Kda_
+I??_OhIco
+I??_gPHkO
+I??I?ckkO
+I??H?dK{?
+I??H?dK`o
+I??I@C[co
+I?O?HOUkW
+I??H?dK{G
+I??I@C[cw
+I??__Xico
+I??_OgZx_
+I??__S{po
+I??OOKbr?
+I?C@?SFpG
+I??_GcJu?
+I??_GcJv?
+I??H?KRqG
+I??GHCRr?
+I??OGSbu?
+I??OHCJv?
+I??OHCJuG
+I??_GcJ}?
+I??_GcJ~?
+I@?A?SFf?
+I?CA@CFbG
+IG??_SFn?
+I??H?dBbG
+I??I@CRf?
+I@?A?SFn?
+I??I@CRfG
+IG??_SF~?
+I?@?_Sff?
+I?@?_Sfm?
+I?@?Ogfe_
+I??_aCNm?
+I@??OL[go
+I??__TFn?
+I?@?_Sf}?
+I?@?_S{go
+I??GaC{go
+I@??OK{oo
+I@??ONB^?
+I??H?cN|?
+I??IGchl?
+I??I@SU{?
+I??GaSef?
+I?@?Owecg
+I?C?Hgip_
+I??_`S[p_
+I??OPp``g
+I??OQoewW
+I?@@O_LkO
+I??PQ?LkO
+I??aO_LkO
+I?GQ?CLkO
+I?@H?_J{?
+I??aO_L{O
+I?@@?oMcO
+I?@@?oMco
+I??S?scQG
+I??_aOMco
+I??PAOMco
+I?GOACMco
+I?O?`GMkO
+I?@?`OMko
+I??Q@OMko
+I??_aOMkO
+I??_aOMko
+I?GOACMko
+I??_aOM{O
+I??_aOM{o
+I??_aOMk?
+I??R?QDMO
+I?B?_Ob]?
+I??GbAEAo
+I??K?oeSO
+I??_QaEEo
+I??HAaEEo
+I??P?WYoO
+I??IC_eMO
+I??OOoeoO
+I??ORAEEo
+I??ORAEMO
+I??ORAEMo
+I??OU?eMO
+I??OT@E]O
+I?__a?H@g
+I?O_?eAF?
+I?`@?_BN?
+I?EA@?BFG
+I?D?@EAN?
+I`??OGB^?
+I@?KA?BNG
+I@?K?D@^?
+I`??OGB~?
+I?O__E@BG
+I?GS?D@BW
+I?O_CCQFG
+I?O__E@FG
+I?`?_C`NG
+I?D?CCaFG
+I@?K?D@FW
+I?D?CCaNG
+I@A?OD@NG
+I_C?GC`^G
+I@?GCDANG
+I@?K?D@NW
+I@?K?D@^G
+IGC?GE@^G
+IGC?GE@~G
+I@GCA?MDO
+I??XA?Jk?
+I?O@GaDMO
+I?GACG[K_
+I_?OOCd]?
+I@C?I?MgO
+I?C@IADMO
+I?CACGwH_
+I@A?ODD]?
+I??HA_Mk?
+I?CAHADMO
+I?Ca?EDMO
+IG?G?eE]?
+I?CAHAD]O
+I?E?I?b]?
+IG?G?eE}?
+I?CA@IEAo
+I??a?SXd?
+I?O@?iEEo
+I??a?S[cO
+I?`??ceMO
+I?CC?cdR?
+I@??QIEEo
+I@?GAEEEo
+IG?G?eEMO
+I?O?`IEMo
+IA?GCCeMO
+IC?G@DE]O
+I??K?WqSO
+I?C@AIEEo
+I?C_AEEEo
+I?D?@EEMO
+I?CA@IEMo
+I?D?CCeMO
+I?CC@HE]O
+I@?GAEEMO
+I?C@AIEMo
+I?C_AEEMo
+I@?GAEE]O
+I?C@AIE]o
+I@?GCDE]O
+I@?GAEE}O
+I?OOc?bBW
+I@GCA?MDW
+IA?Gc?bBW
+IC?I?_bBW
+I@C?I?MgW
+I@?GK@BMW
+I?CACGwHg
+I@A?ODD]G
+I??XA@JkO
+Io?OO@XHo
+I?C?J?Nk_
+I??PAQM[o
+I??_cPM{O
+I?CB?GLkO
+I??J?_LkO
+I?G?I_Mco
+I??HA_Mco
+I??G_waoG
+I?C?J?Mco
+I??Gb?Mco
+I??HA_MkO
+I?C?J?Mko
+I??Gb?Mko
+I??Ha?Lcw
+IA?@OGLkO
+I@?AOGLkO
+I@?I?CLkO
+I@??IOM{?
+I@?AOGL{O
+I??K?waSG
+I@??IOMco
+I@?GACMco
+IG??GoMkO
+IA??HOMko
+I@??IOMkO
+I@??IOMko
+I@?GACMko
+I@??IOM{O
+I@??IOM{o
+I@O?GOFkW
+I@??IOM{G
+I??_Q_]wo
+I?C@I?\wo
+I?CB?IDMO
+I?F??Cb]?
+I?CB?IDAo
+I?G?IaEEo
+I??H?c[oO
+I?O?K_eMO
+I?C?JAEEo
+I?C?JAEMo
+I?C?M?eMO
+I?C?L@E]O
+I@??IOMkG
+I?F??Cb]G
+I?_?J?UMW
+I?C?L@EMW
+I?C?M?eMW
+I?C?M?e]W
+I@?GIBBMO
+IoC?G@XHo
+I??HA_Nk_
+IG??gQL[o
+I@??KPM{O
+IoC?G@XHw
+I?@?OKpe_
+I??P?LHe_
+I??OOL`e_
+I??OR?Fm?
+I??_OLPm_
+I?O?_od`g
+I??OOp``g
+I??OOL`mG
+I?GA?KTe_
+I?G?_LDe_
+I?GO?LBe_
+IG?G?cFm?
+I?O@?KTm_
+I?CA?Kde_
+I?D??Kbe_
+I@@??SFm?
+I?CA?Kdm_
+I@?GACFm?
+I?C@?LDm_
+I?C_?LBm_
+I@?GACF}?
+I?CA?Kd}_
+I?GA?oT`g
+I??Q?oh`g
+IG?G?KRmG
+I?O?Gop`g
+I?D??KbmG
+I@?G?LBmG
+I@?G?LB}G
+I??PCOJPg
+I??HC_RRG
+I?C@AGFeg
+I?@?`ONk_
+I?C@I?NkO
+I?C@AGNk_
+I?GOACNk_
+I??OR?fu?
+I??_aON{_
+I??_aON{O
+I??_QEPF_
+I?@@?UPN?
+I??I@EPF_
+I??K?d`N?
+I??G`F@F_
+I??HAEPN?
+I??HAEPN_
+I??H?f@N?
+I??I?e`^?
+I?CAC_dBg
+IA??K_hBg
+I?C?K``Bg
+I??HCDPNG
+I??Ge?bBg
+I??HE?RFG
+I?C?M?h@w
+I@??QG]go
+I??OU?f]?
+IQ???SFN?
+I@?GCDBF_
+IOC??LBN?
+I`???SF^?
+I@?GCDBN_
+IGC??MB^?
+I`???SF~?
+I?@@C_XBg
+I??IC_pBg
+IG?GCCRNG
+I@?GCDBNG
+I@?GCDB^G
+I?@@O_\go
+I?A?b?jV?
+I??Ha?\go
+I??KB?rV?
+I??Gb?]go
+I@?GAC]go
+I??GbAbV?
+I?C@AIF]_
+I??HE@RN?
+I@?GCDF}?
+I@?GAEF]O
+I?G?GLPe_
+I?C?GL`e_
+I?C?J?Fm?
+I?C?GL`m_
+I?CA?od`g
+I?C?Gp``g
+I?C?GL`mG
+I?C?M?FMG
+I?C?GL`eW
+I?@?P_Zh_
+I@??QGNk_
+I@?GACNk_
+I?C?J?fu?
+I@??ION{_
+I@??ION{O
+I??HA_]go
+I?C?M?f]?
+I??cGTPN?
+I?@@GUP]?
+I??aGiIEW
+I??OqCkgW
+I_?GB_iD_
+I??_aYIL_
+I??PF?MU?
+I?C@CLK[_
+I??_aYI{?
+I??Pq?LgW
+I??_WTPl?
+I?C?G\al?
+I??_WTPlG
+I?A?`TKDg
+I??_aS[h_
+I??P?\Ww_
+I?G?Ic[h_
+I??__\Ww_
+I@??wH`aW
+I??__xIhg
+I?GO?\acg
+I??Q?skwg
+I??OSXaDg
+I?C?ISekG
+I??_`oMog
+I?H?BaEEg
+I??S?SfUO
+I?CA@GNkO
+I??G`Xbd_
+I??HF?[S_
+I@??SLK[_
+I_??HWY{?
+I@??KXIL_
+I?@?PoUgg
+I?`?B_UIg
+I??Gb_Mgg
+I@?GAcMgg
+IA?GF?qBg
+I??IBaQJG
+I@??QYE[g
+I@??KXI{G
+I??OOlbj?
+I??QAUeMO
+I??a?]R]?
+IQ??EWeEg
+I??GWd`l?
+I?A?WSsSW
+I??HAc[h_
+I??_OtSw_
+I??K?dbFO
+I??I@_\go
+I??G_weog
+I?C?G\ogg
+I@?G@pB`g
+I??OO|cgg
+I??G`xa`g
+I??QCTeMO
+I??OV@WH_
+I?CADGM[_
+I?@?PKYkG
+I??HQCTkG
+I??HOcTwG
+I?GO@cMog
+I?O_BaQBg
+I??__^G[g
+I??K?cN[O
+I?C?N@WH_
+I@??UGM[_
+I?@?oSdkG
+I??H_cLwG
+I@?G@cMog
+IG?GBaQBg
+I@??G^G[g
+I@?GECqBg
+I?C?N@WHg
+I??I?likO
+I??IAcmkO
+I??G_WaoW
+I?Cg?CBsG
+I??H?cKsW
+I??H?cK{G
+I??GX?Pow
+I?G?I_EeG
+I?D_?CBmG
+I?O?H_EaW
+I?G?GLOeW
+I?C?GL_eW
+I?C?J?EmW
+I??K?d`B_
+I??G_Xaco
+I?C?GLgkO
+I??H?WRog
+I??G_Xbd_
+I@??GMiUO
+I?C?GN_MO
+I?C@?oFpG
+I?C?GoFwG
+I?C?GN_MW
+I??G_clw_
+I?C?GoEwW
+I??G_cLw_
+I??OOgJx_
+I?C?GoFwW
+I??G_Wqoo
+I?C?GKwwO
+I?C?GoewW
+I??OWSpx?
+I?C?G[qx?
+I??HOcTr?
+I?C@OKTr?
+I??HOcTxG
+I?C?G[qwG
+I??aGSXl?
+I?C?HLI{?
+I?C?HLIf?
+I?C?IKil?
+I?A?gXQIW
+I??OQKilG
+I??__\gcg
+I?C?ISe{G
+I?@?OsedG
+I?C?HNA]?
+I?C?IMaN?
+I?@?dCkEg
+I?C@ECeFG
+I??HAc[gg
+I?C?MCe]G
+I?@?Ossgg
+I??K_d`BW
+I??G`ckog
+I??Gackgg
+I@??WN@]G
+I??OPgjp_
+I??OgShx?
+I??POSTr?
+I??OWT`dG
+I??G_[qwG
+I??OgShxG
+I??_`WYp_
+I?C?Hp``g
+I?C?IoewW
+I??[?c`QG
+I@GOOH@_g
+IA?GHCWgW
+I?COPHAw?
+I?CGI_awG
+I?C@IOSwG
+I?D@?WQ_W
+I@?I?KW_w
+I@CGGD@gW
+I@CI?CDgW
+I??K_o`PG
+I@?G_LG_w
+I@C?GTCgW
+I@CAGODgW
+I?@G`CWgW
+I?D@_GHgw
+I?C@GXOwW
+I??qO_HwW
+I?COPHA_W
+I??Y?So_w
+I?CGHDOgW
+I?CH_H@gw
+I?COPHAwW
+I?COPHA`w
+I??OpHHw_
+I?CGICph_
+I??GiOph_
+I??OX`Hx_
+I@CGACEgG
+I@CACGKGg
+I?o?HGQ[?
+I?o?Gcc[G
+I??qO_H_W
+I??i_Q@KW
+I??K_`HHO
+I??J?iGKW
+I?o?HGQ[W
+I?CGG_boO
+I?CC_GdQO
+I??aO_LcO
+I?CGI_agG
+I??GqI_KW
+I??PGOXoO
+I?CH?GRoO
+I??HOgooG
+I??HOj?KW
+I??IOi_KW
+I?CI?M_KW
+I??HOj?[G
+I??HK`G[W
+I??W@FAAo
+I?GU?CH@W
+I?CGHF?Cw
+I??ka?HCw
+I?Oc_ODCw
+I?CGIE_Kw
+I??G@eIP_
+I??GjAGCw
+I??KaOcCw
+I??HIaGKw
+I??HOj?Kw
+I??M@OS[w
+I?COGSbp?
+I?C?G[qp?
+I?G?GtSg_
+I?C@_KLw?
+I?CP?SFw?
+I?C?XbCHo
+I?COV?cOg
+I??GhROWo
+I??g_VOWo
+I?CGH_bog
+I??QJ?heG
+I?GAJ?TeG
+I?E?gOFWW
+I??GiahX_
+I@G?GgIoW
+I@GOOGBoW
+I?GP_ODow
+I?C@_Wdp_
+I?C?XGpp_
+I?COPGbp_
+I??_hOXp_
+I??_hOXr_
+I?COPDc`o
+I??X?Tooo
+I?GOOLooo
+I??HOho_o
+I?C?X`c`o
+I??HOhooo
+I?GOOLoow
+I@??WjHX_
+I??_hOZr?
+I?COHCJx?
+I?CH?cFr?
+I??X?cJx?
+I??W_SbxG
+I?CG`CFz?
+I??GpIiTO
+I??W`DJj?
+I?CGICrz?
+I??WQCrj?
+I??gQER\?
+I?OOOMb\?
+I??GqGrj?
+I??HOgrr?
+I?GOONB^?
+I??_ojHX_
+IK`@??LCo
+I??I`IWwO
+I?_GGcsOo
+I@C?GTc_o
+I?@__Sw_o
+I??oSDWWo
+I?C?KLSI_
+I@??G\Wg_
+I@??wH`aO
+Ih???wI@g
+I??SHPWWo
+I?C?G\og_
+I?COOLagO
+I?CAHQSHo
+I??HV?SSG
+I??PIQWWo
+I?GGIaQWo
+I??HU?T[?
+I??PKPWWo
+I??QHQWwO
+I??PIQWwo
+I???hLKe?
+I?_GGLQKO
+I?_WGCpOo
+I?@H?eWBo
+I?@?Osek?
+I?@?XaWHo
+I?O?XaSHo
+I?@?PoUg_
+I??IK_wHo
+I?A?X`WWo
+I??k?dWXo
+I?H?GoRgg
+I?O?j?deG
+IH?GI?RaW
+IK`@??LCw
+I??KaOswW
+I?D_?Sqoo
+I?OH?cs`o
+I?@__Swoo
+I?G?XhO_g
+I?CAHOs`o
+I??O]@`M?
+I??_Y_woo
+I?CGJ?qoo
+I?C?Z?s`o
+I?G?Y_spo
+I?@__Sw`o
+I?@H?cwbo
+I?@__Swpo
+I?@GPCRk?
+I?A__TWWo
+I??__\gc_
+I??P?[wo_
+I??O\@WWo
+I?C?ZASHo
+I???g[wp?
+I?@__UWHo
+I??O]?wHo
+I?A__TWXo
+Io??OLYLO
+I@?AOiLX_
+I?@COgxx_
+I??O\@wpo
+I?OGHCRl?
+I?CGICbkG
+I??Y@CJ{?
+I??g_TBf?
+I?@?WoecW
+I??gaCJl?
+I?@GPCRl?
+I?OGHCRn?
+I??WQCblG
+I?@GPCR|?
+I?B@?cJ]?
+I?Aa?cJN?
+I?@@K_MEW
+I?B@?cJN?
+I?B@?cJ^?
+IH??OM[oo
+I?AAHO][O
+I??_iOxb_
+I?@H?eJ\?
+I?B?_S{Wo
+I?AH?dJ|?
+I?C@QGTh_
+I??HOhPw_
+I??gOdPw_
+I??PGpHb_
+I?@?hOXh_
+IA?OGShh_
+I@?@OhI`W
+I??QGohwg
+I??IGophg
+I@C?QGFgg
+I??HK`H[_
+I??O[KoQG
+I??W_Sbp?
+I??IGq`L_
+I??OqGigW
+I?A?XOUSW
+I??HU?TKg
+I??OoSdoW
+I?_APGT[_
+I??_kPH{?
+I??KQScDG
+I??GqGdc_
+I?AAHOXL_
+I?@?l?hEg
+I??O]@`MG
+I?O@GrSgo
+I?AAHO\[_
+I?A@OhXw_
+I?C?Z?Th_
+I??OZ?Xh_
+I?C?gXagW
+I??OWp``g
+I??OWp`hg
+I?D_OEpPo
+I?G?qGVj?
+I??aOiXX_
+I?@?hOZxO
+I??OZ?xpo
+I?B?_Sl[_
+I??_iONm?
+I?@__UwPo
+I??_iON{O
+I?B?_Sf]?
+I?CI_M`Z?
+I?C?iWeiG
+I??HGlge?
+I?B__SbU?
+I??OZagp_
+I?C?]GtY_
+I??OZahp_
+I??wPCRq?
+I?C?Xj_Pg
+I??x?cJqG
+I??OXr_Pg
+IB?GOGBgW
+I??OWo`oG
+I??OZ?WgW
+I??Z?_H_w
+I?CR?ODgw
+I?COOKbwG
+I??GoiiXO
+I??OXp``g
+I??OXL`eG
+I??HGlgeG
+I??OXLWwW
+I??HGkwqG
+I??aGoNkO
+I??HGnG[G
+IG??gWWwG
+IGCOOGBgW
+IGC?GcKgW
+IGCOOGBwW
+IGC?GcKwW
+I?GP_XA_W
+I?GQ?Wqoo
+I@G?gXA_W
+I?D?PCs`o
+IG?GM?RM?
+I??Y@Oqoo
+I?O_Gcwoo
+I?H?Ocspo
+IA?g?Sqoo
+IA?GHOqoo
+I??gq?o_W
+I?`G@CQ[?
+I?Oc?_RBO
+I?_@GhG[G
+I?G[A?o?w
+I?_IH?P[?
+I?AIP?P{?
+I?C_AEEAo
+I?@@_OX`O
+I?CK?GbSO
+I??i?qAKW
+I??QKOoIG
+I@C?IGIgG
+I?`G?ca[G
+I??a_OLcO
+I?H?k?HCw
+I?@K?oaKW
+I??i?eGKW
+I?_@GpC[W
+I??OZ?WgG
+I?GY?E@KW
+I?_H?dC[G
+I?@H?eG[G
+I?@H?eG{G
+I?GOCDBB_
+I?CK_H@GW
+I??gs@@KW
+I??WACba_
+I?_IH?P@w
+I?GGk@@Cw
+I?CKI?`Cw
+I?CHK@@Kw
+I@GOOH@__
+I@GQC?H@g
+I_?GPGQ[?
+I@_GGD@[?
+I@_?ICK[G
+I@?GSHA{?
+I?d@?_D?w
+IA?k?CHKW
+I_?@OgK[G
+I@@K?OBKW
+I@_GACE[G
+I@_AGOD[W
+I_?@OgK{G
+I?CaO_D_W
+I?Ca?CLcO
+I?CQCGgGg
+IA?K?KgKW
+I@CGI?BgG
+IAGGGE@KW
+I_?GHOQ[G
+I@C?IOEgG
+I@?IOI@KW
+I@?I?MGKW
+I@_GGD@[G
+I@_?GTC[W
+I@?GIQA[G
+I@?IK?H[W
+IGC?GUC{G
+I?CS?DHHO
+IC?I?KgCw
+IA?GHEGKW
+IA?GHQAKw
+I_??XOS[W
+I@?GSHAKW
+I@?GIEGKw
+I@?GKDG[W
+I@?K?LG[w
+I_??XOS{W
+I@@?OSTg_
+IWEA??LCo
+I?_GgK`SG
+I?G_GtO_g
+I_?GR_cCg
+I?@G`ORg_
+I?O__USHo
+I?CHF?ESG
+I?@H?qQWo
+I@@G?UQWo
+Ig??P_FF?
+I?I?GdWWo
+I?GAGiWwO
+I?C?XHEcO
+I@C?G\__g
+I@G?GMQQO
+I?GOOLo_o
+I?Ca?USHo
+I?GOGUaSO
+I??aV?WDG
+I??XAQQWo
+I@?GIQQWo
+I?@PE?JM?
+I?GOKDWWo
+I?O?hIWwO
+I@C?Y?FgW
+I?D@F?W@g
+IWEA??X@o
+IG?OOMWwO
+I?H?OcFk?
+I?D?`OFg_
+I_?GJ?RM?
+IO?OGTWWo
+I??Hf?KSG
+IG?OGUWWo
+IG?W?UQWo
+IG?GGqQWo
+IG?GGeWwO
+IG?OGUWwo
+IAG?J?FeG
+IHC?IAH@w
+IWEA??X@w
+IG?OOqEwW
+I?O__cLw_
+IA?H?WRh_
+I?H?_cLh_
+I?D@?KXw_
+I?H?_cLx_
+I?H?_Wq_o
+I?@G`Oq_o
+I?O__Ss`o
+I?@G`Oqoo
+I@@G?Sqoo
+I?C_QCs`o
+I??gaOqoo
+I@?GIOqoo
+I@?I`?Low
+I?_GGceSO
+I?@P?SXg_
+I@?OOL`a_
+I??gaQQWo
+I?D?M?bM?
+I?CAHIWwO
+I??Ka_kwW
+IA?_OiJX_
+I?D?GSbl?
+I?O_GcJl?
+I?C_ICJl?
+I?GQ?SF{?
+I?O_OKR|?
+I?H?OKRkG
+I?GOOLo_w
+I?GOOLB{G
+I?O__SFf?
+I?C_OLBf?
+I?O_GcJn?
+I?Ca?SFdG
+I?GQ?SFn?
+I?GOOLB~?
+IA?__SLh_
+I?@P?SXw_
+I?L??cFw_
+I??i?oRb_
+I?@@_oLh_
+IA?g?SRh_
+I?@H?cXh_
+I@@?GSXh_
+I?OH?cTj_
+I@@G?SRh_
+I?@@_WXw_
+I?@@_WXx_
+I?GA_WTx_
+I?@@OoThg
+I?C_QCTh_
+I?CH?LPw_
+I?C_OLPw_
+I@?GgP`_w
+I??X?dHb_
+I?@?pOTh_
+IA?GHORh_
+I??_qOTh_
+I@?GICXh_
+I?CH?dDj_
+I??_oXPw_
+I?@?pOTx_
+I@??YOTh_
+I?G?gXPx_
+IGC?_KLw_
+IGCO?SFw_
+I?H?P_R`g
+I?CAJ?deG
+IG?OGoJwg
+I?@@`OX`_
+IG??gWXh_
+IG??ogLh_
+IG??ogLw_
+IG??gWXx_
+IG??ogLx_
+I??Y@Orr_
+I??gcDH[_
+I?C@IQD{?
+IG?GM?RMG
+I??I@SUb?
+I??GpHBd?
+I??Gx@DcO
+I??Y@QBL_
+I?_@GhH[_
+I??GYCpd?
+I??SPHHF_
+I@??WhHg_
+I?@H?qBL_
+I@??WlGgG
+I??XAQBL_
+I??_sHH[_
+I?@H?qB\_
+I?C?gXagO
+I?GAGqDL_
+I?CCHHH[_
+I?C@KHH[_
+I?CAHIH{_
+I?AAOoeDW
+I?OOPEF\?
+IA?_GUwoo
+I??XQ?rbO
+I_?_GdJN?
+I??XAOrb_
+I??PQOubO
+I?O_GeJ\?
+I?C_QEF^?
+I@A?GT[Wo
+I?Q?HC][O
+I?`?HCZ|?
+I?GOQCVj?
+I??aOqTX_
+I?GA_iLX_
+I_??gYqYO
+I@?GKDH[_
+I_??XOT{?
+I@?HA_M_w
+I?D?M?bMG
+I?@?pOTg_
+IG?GGqBL_
+I_??XOT[_
+I@?@_]GPG
+I@?GIQBL_
+I@??[HH[_
+I@?GIQB\_
+I_??XOT{_
+I@?GPaDOw
+I?C@IG]iO
+I??XAaJX_
+I?G?iaLX_
+I_??WiqYO
+IG?OON`e_
+IG??WiXX_
+IG??oiLX_
+IG??WqTX_
+I_??Wj`M_
+IG??WiXx_
+I??oOTPw_
+I??POhHb_
+I?@G_chh_
+I??PQOTh_
+I??H_XPw_
+I??PQOTx_
+I@@?OekPo
+I?D?HCZz?
+I??HaaLX_
+I?CI`EDZ?
+I??[Acix?
+I??gapab_
+I??JAosb_
+I?Ca_MHZ?
+I?E?Icix?
+I@?GcTEN?
+I@?IOeDXG
+I?O_Guoog
+I??GhXWg_
+I_?BSgcEG
+IG?Q?UFMO
+IoC?Agi@w
+I?GOKTXX_
+I??XCdJx?
+I@`CA?XH_
+I?@PS?XwO
+I@G?W`D_o
+I_??j_KIG
+I??kA_YWo
+Ig?G@oQ@g
+I?AHA_YWo
+I?I?I_YWo
+I??XE?J[?
+I?@HC_YWo
+I?OoCCYWo
+I??caO[wO
+I?@HC_Ywo
+I???sLSJ?
+I?@?`WYg_
+I?AAP_[Ho
+I?_AH_[Ho
+IC?APG[Wo
+I?AA`O[Xo
+I@??xAHPO
+I??caO[Ho
+I?GAK_[Ho
+I??cQ_[Wo
+I??cQ_[Xo
+I?GCI_[Xo
+I@?CQG[wo
+I?AA`O[xo
+IAH@C?RBW
+I?@GP_Rg_
+Ig??H_XB_
+I?A_Q_YWo
+I??p?SXo_
+I@?GM@BM?
+I??oU?YWo
+I???Wssp?
+I??H@c[o_
+I??PU?[Ho
+I@?@gPDaO
+I??QT?[Ho
+I?CAL?[Ho
+I??LA_[Wo
+I??LA_[Xo
+I?D?L?bEg
+I@?GM@BMG
+Ig??gOlco
+I?B?`ON[_
+I@A?ION[_
+I_?@OjKKo
+I??caO{po
+I?cA?Kd[_
+I??cb@HFG
+I??OOsep?
+I??OSLSI_
+I?@c?SXL_
+I?C@`GLo_
+I?B@?SXL_
+I@?@OhI`O
+I?AP?THL_
+I?GA_YDL_
+I?CE@GL[_
+I??TAOL\_
+I?C@aGLgg
+I??c_XH[g
+I?AA`OUBW
+I?@HC_J[_
+I??abAHFG
+I??GcLSI_
+I??Y?U`L_
+I@?@OhEaO
+I?@G_U`L_
+I?H?GUPL_
+I??X?V@L_
+I?CAL?L[_
+I??g_V@\_
+I?@?Wopgg
+I??OqOdgg
+I??Gh_hog
+I?C@GZ@[g
+I@_?OLD[_
+I@@GCCJ[_
+IG??kOL{?
+I?AAb?hFG
+I??MB?pFG
+I??IbA`FG
+IG?OGUH{G
+I?@?hOXg_
+IO@?GSXL_
+I?@@_WXg_
+IG?W?UBL_
+I_?@OgL[_
+I@?@_XDa_
+I@@G?UBL_
+I@?CQGL[_
+I@A?GTHL_
+I@?CIOL\_
+I@?ASGL[_
+I@@G?UB\_
+I@?CQGL{_
+I?@@d?LEg
+I?@@OoTgg
+IC?@GXH[g
+I??Ha_Lgg
+I@?CGXH[g
+I@?AGYH[g
+I@?AGYH{g
+I?AA`PMLO
+I@A?IO]Wo
+I_??hQqRO
+I??iC_Zx_
+I@?CQG\wo
+I??OWSpp?
+I??OgShp?
+I??I_Y`L_
+I?C?qGdgg
+I?B?p@LKo
+I?B@O_\Wo
+I@?CQGN{O
+I?K?gN@Z?
+I??gpGRoW
+I??GphKg_
+I?B@GcXY?
+I_?BdOSBG
+I??GXqcS_
+I?B_oc`QG
+I??JCgwR_
+I?B@GdHM?
+I??aOyop_
+Io??wHPIW
+I?@?k\gKg
+I_?DbOUBW
+I??Gx`Di?
+I?A@iGXY?
+I?B__dIIO
+I?O?lGwR_
+I_?@YoSgG
+I??i?uop_
+I?OOHUop_
+I?C_oN@Z?
+I??gWcpq?
+IG?I?cNkO
+I??GhdKi?
+I?B__TQIO
+I_?@v?SBG
+I??J?yop_
+I?F?J?bEg
+I_??hZGKg
+I?G?mHYJO
+I??gePRh_
+IG?GKorp_
+I?GOMDXJ_
+I??_u`Lh_
+I??j?cXr?
+I@?QHOJf?
+I??r?SXr?
+I?D?PiaPg
+I@?GWf@XG
+I?AOPTQx?
+I?KA_MDZ?
+IG?__^Gcg
+I?@OPeIXG
+I?AOQcixG
+IB??G]gog
+I?@AlGhEg
+I?OGGma]?
+I@B?HCJUG
+I??GyGpiG
+I??GxGpqG
+I??GiWqiG
+I?OGgM`[G
+I?OGGma]G
+I??hGcXqG
+I??i?cNkO
+I??pOgJu?
+I??_WvOXG
+I??OXT`dG
+I??OYgiwW
+I?CGHLQy?
+I?DOHCJm?
+I?C@iGLiG
+I@??WnGXG
+I??OpTKhG
+I??I`qcPg
+I?CBAeDJG
+I?GBAcTbG
+I??HOgrpO
+I??gqIB{?
+I?AAHS[[G
+I?@?XeWx?
+I?O?XjOgg
+I@?AOmKXG
+I?A?YcwxG
+I??WXDPy?
+I??_iWYiG
+I?@?XeWXG
+I??J?kwr?
+I??XOf@XG
+I?B?hChUG
+I??QHO\go
+I?A@OlWwG
+I??PQeKXG
+I??M@TSKW
+I?GBCcTRG
+I??GpHbdO
+I?O@Gkwr?
+I?CB@iKPg
+I?QGHCR]?
+I?`GHCR{?
+I??a[OXLG
+I?Q?HSU[G
+I??gy?paW
+I_??g\cMG
+I?B?j?hEg
+I?O@GzOgg
+I??q?S\go
+I?_BAcTJG
+IG??g]Wx?
+IG??g]WXG
+IG??WuSXG
+I_??g^_MG
+IG??g]WxG
+I?CWICby?
+I?CWICbiG
+I??oOvAXG
+I??JAePJG
+I??MBCpFG
+I?AA`S[x?
+I?B?aSkKg
+I?AA`TKLG
+I??GYgqy?
+I??_xIPQW
+I??GXadSo
+I??OiUgXG
+I?hO?]QWg
+I??MPucTG
+I?D@?oE_W
+I?CAHGWwG
+I??K_WoOW
+I@?I?cK_w
+I?D?HCWgW
+I@C?IOEgW
+I??H_XOwW
+I@?CQGoBG
+I?C@GGXoO
+I??I_Y_KW
+I??GCdaB_
+I??Kb?KCw
+I??G\@OKw
+I?C?Gsep?
+I??H_cLw?
+I?C?Gtcg_
+I??H_ZOWo
+IG?GJ?ReG
+I?C?qGdw_
+I??QOihX_
+I?SoON__w
+I?S@G]opG
+IgC?H?RBO
+I??gu@@KG
+I@GO?SFo_
+I@?G@KYo_
+I@GU?ODOw
+I@?M@GWOw
+IAH@C?RBO
+IGD@C?LCo
+II?HG_H_w
+IGD?gO``w
+IoCOOGaOO
+IK_PA?H@g
+I@Q?_CdAo
+I`?GJ?BEG
+IgCOP?D?w
+I`GOQ?D?w
+IoCQ@?EAW
+I@@K`?HoW
+I?L??ce_o
+Ih?G?oB@g
+I_?_j?HEG
+IGCGM?BKG
+IIGOS?B@W
+IqGOO?B@W
+I@?IOi_oW
+I@@G?SRg_
+I?HO?Sq_o
+I@D??SFg_
+I@O__UC@w
+Ig??p_DBG
+I@AJ?_HOw
+I@EB?GHOw
+I?WOM?BKG
+IH?G_MGOw
+IH?GoI@Ow
+I@CAGY_oW
+I@@GOe_ow
+I?GO?\ac_
+I?K_GDP_o
+I?K_aIA@w
+I?OHM?PKG
+I@?J?iGOw
+I@CJ?I@Ow
+I@GOQIAoW
+I?GPaQCow
+IAJ@GCHCW
+IGF?GCJKO
+I?N@GD@CW
+IK?@Wj?AW
+I?F__ChOo
+I?N?GCRWO
+I@?gaFGBo
+Io??yOcCW
+I?D?Xb_`o
+I@@GaChb_
+I?AAhXGKG
+I?@H_p`b_
+I?@PQOpf_
+I@OP?UFV?
+I@E?GTbv?
+I@?Y?Sbr?
+I@GQ?SFr?
+I?GY@CRr?
+I?GW`DK_w
+I?GX?dBrG
+I@@?iOhb_
+I@?XAPBb_
+IAC_GVBj?
+I?CQPJEiO
+I@?GjAHp_
+IAC_ONDi_
+I?CQPIipO
+I@D?GUbV?
+I?KAIadF_
+ICCGICrZ?
+I?S__NabO
+I?L?_Mbr?
+I`@@WGHCW
+IAI?GLaEO
+IQ?@gZ?AW
+I?J?GSR[?
+I?F?GSqWO
+IIA?GKiEO
+I@AGaDgBo
+Io?@WhGCW
+I?OGl@o`o
+I?SD?hc`o
+I?CLA`c`o
+I?BAHcgEG
+I?o_GcpR_
+I?oo@CRR_
+Io??ohIHO
+I?SD?gdp_
+I_@@OoeDW
+Io??gXQIW
+I?B@HdGEG
+I?hO?cbR_
+I?@SP_hF_
+I?_J@_TR_
+I?@SP_hp_
+I?@c`OXr_
+Io??gpIHO
+I?S@Gi`p_
+I@?HOhK_o
+I@?QOY`p_
+I?GI`aDPg
+I?B@GtGKG
+I?gOI_bR_
+I?KAHIPF_
+I?_Ha_dR_
+I?B@gOXWO
+I?WOKCpR_
+I??qOq`p_
+I??ZC_hR_
+I??i_q`r_
+ICD?HCZZ?
+I?gQ?LqbO
+I?hO?dbb_
+I?hO_Ddao
+I?GGhb@Pg
+Io??okgPG
+I?SOHE`p_
+I@?HOhI`O
+I?CQPI`p_
+Ic??WgiWW
+I?P@OiacW
+I?F@O`DGw
+I?_IH_VyO
+I@C_G^AUG
+I??KYosw?
+I?@PUQoF_
+I??MTHSM?
+I?@PO~GkG
+I?Q`_cLu?
+ICCQHHIIW
+I?o__]cSg
+IOGOG^AUG
+I@E_ICJu?
+ICCPPHIPW
+IA?geQBHg
+I?hO@eIPg
+I??guAdSo
+I?ASZ@TIo
+I?KR?NG`W
+I??XUAdSo
+I@?I@SUr?
+I?GQ@KYr?
+I?GSA?MKO
+I?Oc?_FMO
+I?__a?FMO
+I_?__OF]?
+I_?OP?F]O
+I@?KA?[Go
+I?EA@?FMO
+I?CcA?FMO
+IGA?_OF]?
+I?EA@?F]O
+IG?OS?F]O
+I_?__OF}?
+IG?OS?F}O
+I?D@C?X@w
+IO?OQ@FMO
+IG?OS@FMO
+I_?__QF]?
+I?O_c?N{O
+ICO_?CBFG
+I@`??CBNG
+I`?G?CB^G
+I`?G?CB~G
+ICO_?CFMO
+ICO?H?FMO
+I@OC?GFMO
+I@_?I?FMO
+I`?G?CF]?
+I`?G?CF]O
+I_C?H?F]O
+IGE??CF]O
+IGC?K?F]O
+I`?G?CF}?
+I`?G?CF}O
+IGC?K?F}O
+I@?KA?MKW
+I@_?I?FMW
+IGE??CF]G
+IGC?K?F]W
+I?E@A@FMO
+IOC?I@FMO
+IGC?K@FMO
+I`?G?EF]?
+I_?__ON{O
+IGC?K?N{O
+I`??GON{O
+I`?G?FBNG
+I?`@?gJ[_
+I?CcAGJ[_
+I?H?cGJ[_
+I?OcB?RFG
+I?`?_Kh[_
+I?GQCCL{?
+I?Cc?LH{_
+I?COPHB`_
+I?_P?TDL_
+I?GQ?UDL_
+I?GPa?L_w
+I?H?_UDL_
+I?GQCCL[_
+I?OP?UD\_
+I@?GgP`_o
+I_?_b_KAg
+I?_PAGYWo
+I@?KAGYWo
+IG?OU?FM?
+I?OPCGYWo
+I_GSA?MKO
+I?O_cC[wO
+I?OSH?XwO
+I@?ICGYwo
+IAGCGGXwO
+I?_W_CdOo
+I?H?Ocs_o
+I?`?_chH_
+I?O_cC[Ho
+I?D?P_e_o
+I?IA?c[Ho
+I_?OR?FM?
+I?Oc?c[Wo
+I?Q@?gYWo
+I?Oc?c[Xo
+IAI??KYWo
+I?D@c?LGw
+I_C@?KL[_
+I_GO?SF[_
+IGCC?KL[_
+I@`??KJ[_
+I@_A?KL[_
+I_?__WJ{?
+IGCC?KL{_
+I_GO?SF{_
+I?_G_dEHO
+IA?c?SLL_
+I_?__WJ\_
+I@AA?WJL_
+IG?S?SL\_
+I@@C?WJ[g
+I_?__WJ|_
+I_?P?XJL_
+IGA?_TUJO
+IQ??ONILO
+I?Oc?gZx_
+IQ?GOGBKW
+I`??OKK[G
+I`??WOD[W
+I`??OKK{G
+I`??WOD{W
+I?D?HOq_o
+I_?_b?JF?
+IO?I?gYWo
+I`?G?KYWo
+I_?Gb_KGg
+IG?K?gYWo
+IK?G?KYWo
+IGA?_S[wO
+IG?O[?XwO
+IG?K?gYwo
+IG_?gGXwO
+I`?G?KYwo
+I?Q@?csAo
+IGA?_S[Ho
+I`??OK[Wo
+I_?__S[Xo
+IK??OK[Wo
+IGA?_S[Xo
+I`??OK[wo
+IGA?_S[xo
+I_G?W`dco
+ICO_GCxoo
+I_?__T[Ho
+IGA?_S{Po
+IQ??OK{oo
+I?O_k?xpo
+I_C?GKh[_
+I@@?SGJ[_
+IG?KB?RFG
+I@_?GLH[_
+IGC?KOF{?
+IGC?GMH{_
+I?_GgccOW
+IG?G_YBL_
+I@?Ha?L_w
+I@?I?YBL_
+I@?ICCL[_
+I@?I?YB\_
+I@?I@_L_w
+I?Q@?ciDO
+I@@@?SX`_
+I@A?QGYWo
+I?E@AGYWo
+I`?KA?[Go
+I?`@G_XwO
+I?D@K?XwO
+I?_WgD@GW
+I?C?sLCHG
+I@?GxA@OW
+I?GSAC[Ho
+I?CcAC[Ho
+I?D@K?bEW
+IGD@C?X@w
+I?EA@CFFG
+I@AAGO\Wo
+I?EAH?\Wo
+I@@?GSXg_
+I_?Gb?bF?
+IO?OQGYWo
+IGC?M?FM?
+IG?OSGYWo
+I`?KA?MKO
+IG?GcC[wO
+IG?KG_XwO
+IG?OSGYwo
+IGCCGGXwO
+I?D?HCw_o
+I?Q?`ccAg
+IG?OSC[Ho
+I_C?J?FM?
+IG?K?c[Wo
+IGA?OgYWo
+IG?K?c[Xo
+IGE??KYWo
+I@?KB@BFG
+IH?KA?RBW
+IGC?M?FMG
+IWC?I?X@w
+I`?KA?MKW
+IGC?K_MwW
+IG?K__LwW
+I_G?Gpeco
+IGA?Wb`Eo
+I?Q@G_N[O
+I@AAGON[O
+I`??ONILO
+IGA?OgZx_
+I`??gOloo
+I_C_GCxoo
+I_?__TFN?
+I`??OK{oo
+I_?__S{po
+IGA?GcJN?
+I?O_GeBN?
+I?H?SCRLG
+IO@?GcJ]?
+I_?_GcJ^?
+I?E?ICbN?
+I?D?KCbMG
+IGA?GcJ]?
+IGA?GcJ^?
+I@?HAC[_w
+I?C_KDBN?
+I@@?GUB]?
+I?DC?Kb^?
+I?D?KCb]G
+IGA?GcJ}?
+IGA?GcJ~?
+I?`@?cN|?
+I_?H?cN|?
+I?Gg_dH`_
+I?O__mIZ?
+I@@?O]Qx?
+IA?_oUDZ?
+I@O?KSUx?
+I?Ggi?RaW
+I?GQ[?hDW
+I?GX?dH`_
+I?GgohA_W
+I?D?hEHZ?
+I?E@?\Qx?
+IA?GpEDZ?
+I@?KASUx?
+I?GPIC[aW
+I?E?iCkWW
+IGA?yGHKG
+I?OS@ckp_
+I@AA?wip_
+ICO?Hckp_
+I_?__xIHg
+I?Q@?tSHg
+IGC?gMHZ?
+IGC?G]Qx?
+IG?G_mIZ?
+IG?OWUPx?
+I@?JAEPBW
+IG?OOuEXG
+I@O?G]oog
+IG?OScMxG
+I?F@Gd@IG
+I?D@@iIPg
+I?GSACN[O
+I?H?cWVY_
+I_?G`Xbd_
+I_@@GghE_
+I`??HWYp_
+I_?OPckp_
+IG?OTFKDo
+I?GXOhA_W
+I?D?pEDZ?
+I@?I?]Qx?
+I_@_gcHIG
+IGA@iGHEG
+I?Oc?ssp_
+IGA?_\gcg
+I_GO?^AKg
+IAB@GcHIG
+I?F@I?bEW
+IK??wIHWW
+I?D@?CX`O
+I?CaCGWGg
+IA?K@CKKW
+I_?H?cK[G
+I@?I?YAKW
+I@`G?CB[G
+I@_?IOE[W
+I_?H?cK{G
+IC?I@CKCw
+I@?G[@@Kw
+I?D@@CX`_
+I?C_Gt__g
+IA?H?YQWo
+IAG?GMWwO
+I?GQ?iJX_
+IQ??GNIMO
+IGC?GoEgW
+IGC?GoEwW
+IG?OOgJh_
+IG?G_cLw_
+IG?OOgJx_
+IGC?GoFwW
+I?D@?oe_o
+I@?H_XA_W
+IG?G_Wqoo
+I@?I?Wqoo
+I?D@?KXg_
+IG?G_YQWo
+IGC?GMWwO
+IGC?J?FeG
+IGC?GqEwW
+IG?OOiJX_
+I`??GNIMO
+I?O_gchr?
+I@O?Gkir?
+IG?G_kir?
+IGC?gKhr?
+I?O_`SUrG
+I?GQEWiDg
+I?O`GcXr?
+IGC?oKdr?
+I?GQ@SUr?
+I@@?SSUx?
+IAG?oMDZ?
+I_@?gWqIW
+I@@?OmIXG
+I?O__^_cg
+I@@?OmIxG
+IG?OgUHx?
+IGC?oMDZ?
+I_?_WTPLG
+IG?OgUHXG
+IG?G_^_cg
+IG?OgUHxG
+I@?MACpBW
+I@BAHCHEG
+I?FAHC`EG
+I@?KACN[O
+I_?OPgjp_
+I_@@GgiEO
+I_?OPgip_
+I`??G[wog
+I`?G?^AKg
+IK?CQKWHG
+I@OOHEHp_
+I?R@gO`CW
+I?O_haHp_
+IAAAXG`EG
+I@?GhXG_g
+I@?YCChR_
+I??gx`@aG
+I?K_i?FaW
+I?O_kOpR_
+I`?BGiGAW
+IK_AHGICW
+I@OCOhc`o
+IGB?GcJM?
+Ig?_wGPAW
+Ik??wODGW
+I?QH?do`o
+ICCI@Dc`o
+IAA@GKXY?
+IGQ?gKHKG
+I`@?GKiEO
+I_D_GCJKO
+I@?[ADgBo
+I_@_GcJM?
+I?`H?doBo
+IC?Y@DgBo
+IGQ?gQ`Cw
+I?_aOiXX_
+I_?_iOxb_
+ICO?hQdR_
+I?__iPpb_
+I_OH?esBo
+I?`H?foBo
+I?E?iOeWW
+I?EI@CRx?
+I@CGKDBx?
+I?GW`DK_o
+I?GcQGYDW
+I?EGaCbZ?
+ICCGICbZ?
+I?_Y@ERZ?
+I?CpQIBu?
+ICKR?GFQO
+IC?I`Lgf?
+I?EA`LgbG
+ICO?hUcRG
+ICSr?CH@W
+I_?WRIQGw
+I?Cq?U`p_
+I@?GxAHPO
+I@O?kGhR_
+IAIAHGPAg
+I??OpTKh?
+I?E@IHQIO
+I_@_x?PAW
+I?_PGp`R_
+I?J@gP@CW
+I?O_k_hR_
+IK?CQKSIG
+ICO?gY`Wg
+I@?Y?U`p_
+I?OPGq`p_
+I?Ci?e`r_
+I@OOGU`p_
+IOGI?cTR_
+I?SS@Cdp_
+I??PPhIb?
+I?EAHHQIO
+IAGH?cFb?
+IGAAGkgEG
+I?_Y@CpR_
+IK?CQSSHG
+I?`@OhacW
+I?DCP_dp_
+IG_W?cbR_
+I@OD?gLp_
+I?CqCOJHg
+IGAA`OUBW
+IGAAGghE_
+IQ?E@GXB_
+I?Os?chp_
+IA__HORp_
+IAG@GKXb?
+IG_?godR_
+IOCI?cdR_
+I@Oc?cLp_
+IA?k@CXr_
+I??_hpKa_
+I?`@_odR_
+I@IA?WRp_
+I?MA?gbr_
+I`G?I?TAo
+I`G?GgIoW
+I`GOOGBoW
+I_GP_ODOw
+I_GP_ODow
+IK?B?iIBO
+I`??pGLp_
+I_C?X_dp_
+I_COPGbp_
+I_@@GkgEG
+I_?_hOXR_
+I_?OX_hp_
+I_?_hOXr_
+Iq?@OoD@g
+IoCA`OE@W
+IcG@IGHCg
+I_GTA_EAW
+IGQ@gGHCW
+IAIBGGPAW
+I_D_gC`AW
+IoCAWG`CW
+I?MA?dc`o
+ICOf?_H@W
+IAI?_Tc`o
+I_CH?dc`o
+I?EBGHPIO
+I`?AXOS_W
+I?EA`Pc`o
+I_C@Ohc`o
+IAI?_Tc@w
+ICOP?MiRO
+I?`P?dkao
+I_?_gphb_
+I_@_gSHKG
+IAG@OKTb?
+IGI?iGHCg
+I??OxPHh?
+IAB@HCHEG
+I?R@GcPIG
+I?EAHL_EG
+I?_X@DPR_
+I@?I_Y`p_
+I?J@GcPQG
+I?OT?ghp_
+IA?H@KYb?
+I`@@GgIAW
+IA_H@CTR_
+I??OxHHi?
+I?gQ?gbR_
+IBAAHGIAW
+I?_a_odR_
+I@@CP_Lp_
+I?Sc?cdp_
+I?DD?odr_
+I`??WgioW
+Ik?@OgI@W
+IcG?X_EOW
+IIA@GKHEG
+I`@@GKHEG
+I@QAGKHKG
+I?R?GciKO
+Ig?_gKHEG
+I`?@iIGAW
+Ik??WoEGW
+I?CcQ`c`o
+IoC?wH@GW
+ICC_QDc`o
+IGCCOhc`o
+IGa?gP`Cw
+IGE?gOFWW
+I?QP?dkao
+I_GQ?KybO
+I?HS?dhb_
+I_G?grDJ_
+ICD?HCJZ?
+IGC_GVO_w
+I?M?ICRx?
+I?COQgi`_
+I?U@?cFN?
+I_@?XOUKW
+I?M?_LBZ?
+I@@GOeBN?
+I@@GOeBXG
+I?S_cCFZ?
+I?F?QCsGw
+I?c__LBZ?
+IA_G_KbZ?
+ICD?HCJ^?
+I@AI?SRx?
+I@@GOeBxG
+I?S__MBz?
+IA___KJZ?
+ICO__SFZ?
+IAI?GcJx?
+ICO__SFz?
+I?CWCdIH_
+I@`?_SFN?
+ICO__SF^?
+ICO__SF~?
+IGCOON__w
+IGCGKCRx?
+I_?OWp`Hg
+I_CG`CFZ?
+IG?W_UBXG
+IGCGcCFZ?
+IG?[?cJx?
+IG?W_UBxG
+IGCG_MBz?
+IC?IPGyTO
+I_C_OMiTO
+I@EA?Sfv?
+ICC_Y?xPo
+ICCI@GrR_
+I_GOONBN?
+I@`?OKrv?
+IECHY?`@W
+IKCOOLIHO
+I?HL?dPf?
+IGGOOnCag
+ICSq?CFIO
+I?`HOhQgO
+ICKQBGEAg
+IECgQGBGg
+IKCOOTEHO
+IH?KQGRN?
+I?HT?dHf?
+I?S`aEDFG
+IGCOPNCag
+I@?G]QcS_
+I??X[PPw?
+I@?KIMWY?
+I?D@MQoF_
+IOCa_NGBW
+I?GQQMYhO
+I@Gg_dH`_
+IAI_GSR]?
+I@Q_GcJu?
+I@O_G]QUG
+IOC_G^AUG
+IECGX@BHO
+IGDOHCJm?
+I?C[ASe{?
+I@H??cJ`_
+Ih?GO_D?w
+I_?OZ?`EG
+I`__a?H@g
+IOCR?ODOw
+I@IAG_HoW
+I@GO?]AOg
+I?K_k@@@w
+I?OoPCRr?
+IAGG_Kbf?
+IGCH?fC@w
+I@O_GcJr?
+IGCG`CFr?
+I@D@?KJv?
+I@D@?UFV?
+I_COOMiXO
+I@@?qGhb_
+I?D@Gp`b_
+I?NAGC`CW
+I?aIPGqSO
+ICKQ@GFQ_
+IECHQGDGg
+I?Ot?dHf?
+I??YPUSw?
+I@?KINGM?
+I_?_hrGBg
+I?DH@eMsO
+I@?G]AdSo
+I?DQPGbm?
+I?C[ASew?
+I?OgpGR{?
+ICCY@CFY?
+IGGOQMSag
+I?GY@fAbG
+I?CoQN_ag
+I?_IJOUKW
+I?@QPegFG
+I?__iON[O
+I?C_]?tQo
+I?O_WmoUG
+I?_IHXQKW
+I?O_g]oqG
+I?OGl@p`o
+I?C_lPHPg
+I?__iOxPo
+I_?_g^GMG
+I@?KqgkwG
+I?OkSHPK_
+I?Sc@dEf?
+I?DcAcif?
+I@`KACXH_
+ICCQPKgPG
+IK?GaSef?
+ICO_aKif?
+I@?IKXWg_
+I??XUQcS_
+ICCYACiHO
+I?`HKOqSO
+I?`HOhacO
+IE?H@LIf?
+IEG@GLHf?
+ICD@@WYPg
+I?Sc@eERG
+I?GUAMYJO
+I`H?gWQAW
+IC@I`Chf?
+IC@a_Shf?
+I`C@GLHf?
+I_O_cKkEg
+ICCY@DIHO
+I?aIPHQKO
+IEG@OLDf?
+I_?gu?dCw
+I@aIACXH_
+ICCQQKcIG
+ICO_aSef?
+I??guQcS_
+I@?IKZAM?
+I?d@Agrb_
+I?D`SCTu?
+I?CQPNCiG
+I?C_mDHJG
+I?OpSCTu?
+I?`@OmWXG
+I?O_onGhG
+I?`?hOZXO
+I@OgGeBu?
+IOCoICJu?
+I_?pOgJu?
+I_GOG^AMG
+I?C_qMcqG
+I@OoGUBu?
+I_G?gvCJG
+I_?WPjAGw
+IAA`_SLu?
+I?GQ]?hDW
+I@KGKdEwG
+I@OGM?BKG
+Ih??GoH@g
+I_C_J?BEG
+IqGO?CK?w
+I@?I_Y_oW
+I@@G?Sq_o
+I@`@_CH@W
+IH?GcCKOw
+I@?G?]aS_
+I@?JC_KOw
+I@?HcPCow
+IGD@C?X@o
+II?GX?P_w
+I?CY@FIhO
+I`?@Wj?AW
+I@R?GCJKO
+I?F_oD@GW
+I?D@Gr_`o
+I?C[ACbx?
+I?D@Gr`b_
+Ig?_gWQAW
+I??gpGRq?
+I?o_`GRR_
+I`_?X_EOW
+I?F?HCYWO
+IGE?GLaEO
+I`?@gZ?AW
+I?DD?pc`o
+I?J?_dhb_
+I?E@IH`E_
+I?CY@E`p_
+I?E?pH`og
+I?F@HD@EG
+IgC?H?X@o
+I@?G@cMo_
+I@?M@_KOw
+I@?JIqobG
+IQ`@_GH?w
+I`Q@G_H?w
+I`?L?hG?w
+IoD@?WQ@w
+I@A@WpHp?
+IB?KSHIHO
+IK?KQSSHG
+I@?IGzAi?
+IGIOaEKAw
+IG?qSaHF_
+I@?IWj@i?
+IB?KASeb?
+I@?IOzCg_
+I@AAGwiq?
+I`?I@SUb?
+IGAPSPPF_
+I??g}P_cG
+I@@?yQHh?
+I?HK`b@F_
+IKCY?CdAo
+IGCQPII`W
+IGLC?cFf?
+IKOG_Kbf?
+IKO__SFf?
+ICCQPScPG
+I@`ICC[Go
+ICOgaCbf?
+ICOhAC[Cw
+I?DH[APWO
+IEGH?LBf?
+IPOG_LBN?
+I@GSIQiTO
+I?DKb?xh_
+I?HcQ_Zl?
+I@GQSGN{?
+I@GQQIhd_
+Ii?HOsSHG
+I?Ka_mDqG
+I?CpShIoW
+I@GO[hIw?
+I?EJQ_phG
+I@KaKIQQO
+IG`HOgR{?
+I@C[QIaWW
+I?dS@pEGw
+I@GG[hQw?
+I`Gg_dH`_
+I@KGIeEw?
+I?GTbPSb?
+I@GTQhG`G
+IgEP?KJ]?
+I?`ad_kEg
+I?GTbHWb?
+IAISQCd]?
+I@GTcXGPG
+I@GTShGPG
+I``@_OD?w
+I`?LA_K?w
+I@@AWqHh?
+IB?K@MIR?
+I@?[IDHi?
+IpD?GUbV?
+IsP@OkWHG
+I`?M@_K?w
+I@AISHBM?
+I_OgpGR{?
+I?dPcPDGw
+I@KcIIQQO
+It?IQGiDO
+IsPH@CYDO
+IqKaK?X@w
+>A ./geng -cfd1D9 n=10 e=9-16
+>Z 3389 graphs generated in 0.01 sec
diff --git a/lib/nauty/nautestc.ans b/lib/nauty/nautestc.ans
new file mode 100644
index 0000000..a70123e
--- /dev/null
+++ b/lib/nauty/nautestc.ans
@@ -0,0 +1,2 @@
+      100 graphs : n=114; e=171; mindeg=3; maxdeg=3; regular
+ 100 graphs altogether; cpu=0.000 sec
diff --git a/lib/nauty/nautestd.ans b/lib/nauty/nautestd.ans
new file mode 100644
index 0000000..a7eea5c
--- /dev/null
+++ b/lib/nauty/nautestd.ans
@@ -0,0 +1,16 @@
+&G^r{\Bo[BGO?
+&G^r{^BO[ACOO
+&G^r{^BO[BC?G
+&G^rk^Bo\B?O?
+&G\r{^Bw[B?O?
+&G^r[^Bs[A?OO
+&G^r{TBq[BGO?
+&GZr{^bo[A?OO
+&GZr{^boSBAO?
+&G^q{^RoOBAO_
+&G^qk^Ro\B?O?
+&GVr}^BO[BCO?
+&GVr}^BoOBAO_
+&GTr}^Bw[B?O?
+>A ./pickg -T3
+>Z 6880 graphs read from stdin; 14 written to stdout; 0.000 sec
diff --git a/lib/nauty/nauteste.ans b/lib/nauty/nauteste.ans
new file mode 100644
index 0000000..9edb99e
--- /dev/null
+++ b/lib/nauty/nauteste.ans
@@ -0,0 +1,15 @@
+        2 graphs : orbits=6
+       16 graphs : orbits=7
+       29 graphs : orbits=8
+       32 graphs : orbits=9
+       21 graphs : orbits=10
+       14 graphs : orbits=11
+       23 graphs : orbits=12
+      218 graphs : orbits=13
+     1071 graphs : orbits=14
+     2658 graphs : orbits=15
+     4002 graphs : orbits=16
+     3375 graphs : orbits=17
+     1408 graphs : orbits=18
+ 12869 graphs altogether from 123867 read; cpu=0.730 sec
+>A ./countg --o -z6
diff --git a/lib/nauty/nautestf.ans b/lib/nauty/nautestf.ans
new file mode 100644
index 0000000..f661dca
--- /dev/null
+++ b/lib/nauty/nautestf.ans
@@ -0,0 +1,11934 @@
+&G????????_Nw
+&G????????_^o
+&G??????A??^o
+&G???????@_^_
+&G?????G?@?^_
+&G??????C@_^?
+&G????_?C@?^?
+&G?????OC@_]?
+&G??A??OC@?]?
+&G???@?OC@_[?
+&G?G?@?OC@?[?
+&G?G@?OC@?OK?
+&G???????A?^o
+&G???????@@^_
+&G??????O@?^_
+&G??????C@A^?
+&G????A?C@?^?
+&G?????OC@C]?
+&G???O?OC@?]?
+&G???@?OC@G[?
+&G?A?@?OC@?[?
+&G?G@?OC@?OE?
+&GOAA?_GA?_G?
+&G?GA?_GA?_K?
+&G????????oNo
+&G???????@oN_
+&G??????C@oN?
+&G?????OC@oM?
+&G???A?_GAoK?
+&G???????@`N_
+&G??????C@aN?
+&G?????OC@cM?
+&G???@?OC@gK?
+&G?AA?GA?_GK?
+&G???????A_No
+&G??????Q??^_
+&G????AG?@?^?
+&G???O_?C@?]?
+&G?AA??OC@?[?
+&G??????A?@^_
+&G?????G?@A^?
+&G????_?C@C]?
+&G???@?OE?@[?
+&G?GA?OC@?OE?
+&G??????C@BN?
+&G?????OC@EM?
+&G???@?OC@KK?
+&G?@?O_@?OCE?
+&G?GA?_GA?_E?
+&G??????OA?^_
+&G????A?O@?^?
+&G???OA?C@?]?
+&G?A?O?OC@?[?
+&GOA?O_GA?_G?
+&G??????CG@^?
+&G?????OCO@]?
+&G???O?OC@G[?
+&G?G?OOC@?OE?
+&G?AA?_GA?_K?
+&G???????GANW
+&G?????@?O?]o
+&G????GA?@?\_
+&G??@?O?C@?Z?
+&G?GA??OC@?U?
+&G???????GA^O
+&G?????@?@C]_
+&G????G?C@G\?
+&G???A?_I?PGG
+&G?AA?OC@?OK?
+&G???????HA^?
+&G??????CPC]?
+&G????@?R?HAO
+&G???C@?Q?PCO
+&G??A?_GA?oK?
+&G????????`Ng
+&G????????`^_
+&G???????@aNG
+&G???????@a^?
+&G??????C@cMG
+&G??????GAkKG
+&G?????OC@gKG
+&G?????_GAgKG
+&G???A?_GA_[?
+&G??A?GA?_GM?
+&G??????A?@No
+&G???????A_^_
+&G?????G?G?^_
+&G??????G@_^?
+&G????_@?@?^?
+&G?????_C@_]?
+&G??A?G?C@?]?
+&G???A?OC@_[?
+&G?G@??OC@?[?
+&G?G@?OC@??[?
+&G???????@BNG
+&G???????@B^?
+&G??????C@EMG
+&G??????GA[Gg
+&G?????OC@KKG
+&G?????_GAWHG
+&G???@?OC@WGG
+&G??@?GA?_GJ?
+&G?A?@GA?_GK?
+&G??A?_GA?_M?
+&G??????O@AN_
+&G??????CAA^?
+&G????A?CO?^?
+&G?????OG@C]?
+&G???O?Q?@?]?
+&G???@?_C@G[?
+&G?A?@O?C@?[?
+&G?G@??S@?OE?
+&GOAA?_GA?_C?
+&G?GA?_GA??[?
+&G???????G@NW
+&G???????AA^O
+&G?????@?G?]o
+&G??????G@C]_
+&G????G@?@?\_
+&G?????_C@G\?
+&G??@?G?C@?Z?
+&G???A?_G@PGG
+&G?G@??OC@?U?
+&G?A?@OC@?OK?
+&G??????A?_No
+&G??????O@@N_
+&G?????GA??^_
+&G????A?CG?^?
+&G????_G?@?^?
+&G???O?P?@?]?
+&G??A?_?C@?]?
+&G?A?@G?C@?[?
+&G?GA??OC@?[?
+&GOAA?_GA?_A?
+&G???????G@^O
+&G???????H@^?
+&G?????@?@A]_
+&G??????CP@]?
+&G????G?C@C\?
+&G????@?P_`?W
+&G???@?OD?@WO
+&G???C@?P?@WO
+&G?G@?GA?_GE?
+&G??A?_GA?_[?
+&G??????A?_^_
+&G??????CGA^?
+&G?????G?@_^?
+&G?????OCOC]?
+&G????_?C@_]?
+&G???@G?C@G[?
+&G???@?OE?_[?
+&G?G@?OC@?GE?
+&G?GA?OC@?OK?
+&G?GA?_GA?OK?
+&G????????pN_
+&G???????@qN?
+&G??????GAwL?
+&G?????_GAoM?
+&G???????AoN_
+&G??????G@oN?
+&G?????_C@oM?
+&G???A?_G@oK?
+&G???????@bN?
+&G??????GAkK_
+&G?????_GAgL?
+&G???O_@?OCM?
+&G??????CAaN?
+&G?????OG@cM?
+&G???@?_C@gK?
+&G?AA?GA?_?[?
+&G???????AaNO
+&G??????G@cM_
+&G?????_C@gL?
+&G???@?_GAgK?
+&G??????Q?@N_
+&G????AG?G?^?
+&G???O_@?@?]?
+&G?AA?G?C@?[?
+&G??????AG@^?
+&G??????EO@]?
+&G????@?R?g?W
+&G???C@?Q?@[?
+&G?????G?GA^?
+&G????_?COC]?
+&G???C?OE?@[?
+&G?GA?OC@?GE?
+&G??????GA[Go
+&G?????_GAWH_
+&G???GAC?GAJ?
+&G??@?OC@?OJ?
+&G?????OCAEM?
+&G???@?OG@KK?
+&G?@?O_@?O?U?
+&G?GA?_GA??U?
+&G??????G@DM_
+&G?????_C@IL?
+&G???A?_G@`D?
+&G?A?O?Q?_GK?
+&G????A?O@AN?
+&G???OA?CO?]?
+&G?A?O?Q?@?[?
+&GOA?O_GA?_A?
+&G??????CW@]?
+&G????@?P_@X?
+&G???C@?P?@Y?
+&G??A?_GA?WGG
+&G?????P?GA]?
+&G???O?Q?@G[?
+&G?G?OOC@?GE?
+&G?AA?_GA?OK?
+&G??????GACMo
+&G????@?O_?\_
+&G???GAC?@?Z?
+&G?@?O_?C@?U?
+&G?????@?OCMo
+&G????GA?_?\_
+&G??@?OC?@?Z?
+&G?GA?_?C@?U?
+&G??????OO@]_
+&G????AA?@A\?
+&G???C?OD?@Y?
+&G?G?OOA?_GE?
+&G?????@?OC]_
+&G????GA?@G\?
+&G???@?S@?OW_
+&G?AA?_C@?OK?
+&G?????@?HA]?
+&G????G?R?D@O
+&G???GAG@?B?o
+&G??A?_G@?`GO
+&G?????@?PC]?
+&G????G?R?HAO
+&G???GAG@?QC_
+&G??A?_G@?oK?
+&G????????bNG
+&G????????fMG
+&G???????@eMG
+&G???????AeMG
+&G??????C@kKG
+&G??????GAcMG
+&G?????_GA_]?
+&G????_@?OCN?
+&G???????AaNG
+&G???????Aa^?
+&G??????G@cMG
+&G??????G@kKG
+&G?????_C@gKG
+&G?????_G@gKG
+&G???A?_G@_[?
+&G??A?GA?_?]?
+&G?????G?GAN_
+&G??????GA_^?
+&G????_@?O?^?
+&G?????_G@_]?
+&G??A?GA?@?]?
+&G???A?_C@_[?
+&G?G@?O?C@?[?
+&G?G@?OC?@?[?
+&G???????@FMG
+&G???????AMKW
+&G??????GAK[_
+&G??????GAKKg
+&G?????_GAG\?
+&G????G@?OCL_
+&G???O?P?OCM?
+&G????_GA?_N?
+&G??????CAEMG
+&G??????G@[Gg
+&G?????OG@KKG
+&G?????_G@WHG
+&G???A?OC@SGG
+&G??@?G?C_GJ?
+&G?A?@GA?_?[?
+&G??A?_GA??]?
+&G????A?COCN?
+&G?????OGAC]?
+&G???O?Q?_?]?
+&G???@?_G@G[?
+&G?A?@OC?@?[?
+&G?G@??OD?OE?
+&GOAA?_GA?OC?
+&G?GA?_G?@?[?
+&G???????AEMW
+&G???????AE]O
+&G??????G@KKg
+&G??????G@K[_
+&G?????_C@WHG
+&G?????OGAKKG
+&G???@?_GAG[?
+&G???O?Q?_GM?
+&G?????@?GAMo
+&G??????GAC]_
+&G????G@?O?\_
+&G?????_G@G\?
+&G??@?G?C@GJ?
+&G???A?_C@QGG
+&G?G@??OC@OE?
+&G?A?@OC@??[?
+&G?????GA?_N_
+&G????A?CGAN?
+&G????_GA??^?
+&G???O?P?O?]?
+&G??A?_G?@?]?
+&G?A?@GA?@?[?
+&G?GA?_?C@?[?
+&GOAA?_GA?GA?
+&G???????W@]O
+&G???????BMKG
+&G??????Co@[O
+&G??????Oo@[O
+&G?????_H_`?W
+&G????G@?OC\?
+&G???@GA?_G[?
+&G????_GA?_]?
+&G?????@?GA]_
+&G??????OP@]?
+&G????G@?@C\?
+&G????@?H_`?W
+&G???C?OD?@WO
+&G???C@?D?@WO
+&G?G@?OA?_GE?
+&G???@_GA?_[?
+&G?????GA?_^?
+&G?????P?OC]?
+&G????_G?@_]?
+&G???@GA?@G[?
+&G???@?WA?_[?
+&G?G@?OC?_GE?
+&G?GA?_C@?OK?
+&G?GA?_G@?OK?
+&G????????{Ko
+&G???????AqN?
+&G??????GAoN?
+&G??????G@wL?
+&G?????_G@oM?
+&G???A?_C@oK?
+&G???????AeMO
+&G??????GAcM_
+&G????AG?GAN?
+&G??????G@kK_
+&G?????_G@gL?
+&G???O_@?O?]?
+&G?????OGAcM?
+&G???@?_G@gK?
+&G?AA?GA?@?[?
+&G???????BwH_
+&G??????QO@]?
+&G????_@?OC]?
+&G????@?J?g?W
+&G???C@?E?@[?
+&G?GA?OC?_GE?
+&G??????GAKKo
+&G????@?O_@L_
+&G????GA?_GL_
+&G?????_G@WH_
+&G???GAC?G?Z?
+&G??@?OC@??Z?
+&G???@?OGAKK?
+&G?@?O_@?@?U?
+&G?GA?_G?@?U?
+&G??????G@pB_
+&G?????_CAIL?
+&G???OA?COCM?
+&G???A?_C@aD?
+&G?A?O?Q?_?[?
+&GOA?O_GA?GA?
+&G??????GBKK_
+&G????AA?GA\?
+&G????GA?_G\?
+&G????@?D_@X?
+&G???C@?D?@Y?
+&G???A_GA?SGG
+&G???O?Q?_G[?
+&G?G?OOC?_GE?
+&G?AA?_G@?OK?
+&G?????K?oB?o
+&G????G@B?D@O
+&G????GAB?HAO
+&G???G@G@?B?o
+&G???O_C@?SD?
+&G??A?_C@?oK?
+&G??????@?_No
+&G??????A?O^_
+&G?????G@??^_
+&G?????C?@_^?
+&G????_?C@ON?
+&G????O?C@_]?
+&G??A?O?C@?]?
+&G???@?OE?O[?
+&G?????G?@@N_
+&G??????CG_^?
+&G????_?O@?^?
+&G?????OCO_]?
+&G??A?A?C@?]?
+&G???O?OC@_[?
+&G?G?O?OC@?[?
+&G?G?OOC@?OK?
+&G??????A?ANW
+&G???????G_^O
+&G?????G?O?]o
+&G?????@?@_]_
+&G????GG?@?\_
+&G????G?C@_\?
+&G??A?O?C@?Z?
+&G???A?_I?PCG
+&G??????A?A^O
+&G??????A@A^?
+&G?????G?@C]_
+&G??????E@C]?
+&G????_?C@G\?
+&G????@?R?`AO
+&G???A?_I?`CG
+&G???C@?Q?`CO
+&G??????O@_N_
+&G??????E?A^?
+&G????A?C@_N?
+&G?????W?@C]?
+&G???O?OC@_M?
+&G???@?OE?G[?
+&G?A?@_?C@?[?
+&G?G@?_C@?OE?
+&G????A?CA?^?
+&G?????OCOA]?
+&G???O?OO@?]?
+&G???@A?C@G[?
+&G?A?@A?C@?[?
+&G?G@?AC@?OE?
+&GOAA?AGA?_G?
+&G?G?O_GA?_K?
+&G?????@?A?]o
+&G?????@?@@]_
+&G????G?O@?\_
+&G????G?C@A\?
+&G???GO?C@?Z?
+&G???@?OD?GWO
+&G?G?O?OC@?U?
+&G?@@?_C@?OE?
+&G??????O@C]_
+&G??????CPA]?
+&G????A?C@G\?
+&G????@?P_`@O
+&G???O?_GAWGG
+&G???C@?P?HGO
+&G?A?OOC@?OK?
+&G??A?_GA?gK?
+&G??????A?oN_
+&G?????G?@oN?
+&G????_?C@oM?
+&G???A?_I?oK?
+&G??????E?aN?
+&G?????W?@cM?
+&G???@?OE?gK?
+&G?AA?_A?_GK?
+&G??????Q?_N_
+&G????AGA??^?
+&G???O_G?@?]?
+&G?AA?_?C@?[?
+&G?????GA?A^?
+&G????_G?@C]?
+&G???@?WA?A[?
+&G?GA?_C@?OE?
+&G??????CGaN?
+&G?????OCOcM?
+&G???@G?C@gK?
+&G?AA?OA?_GK?
+&G?????OCOEM?
+&G???@?Q?@KK?
+&G?@?O_@?OOE?
+&G?GA?_GA?OE?
+&G????A?O@@N?
+&G???OA?CG?]?
+&G?A?O?P?@?[?
+&GOA?O_GA?_@?
+&G?????P?OA]?
+&G???O?P?@G[?
+&G?G?GAC@?OE?
+&G?AA?_GA?GK?
+&G??????Q?AN_
+&G????AG?O?^?
+&G???O_A?@?]?
+&G?AA?O?C@?[?
+&G????A?O@CN?
+&G???OA?C_?]?
+&G?A?O?S?@?[?
+&GOA?O_GA?_C?
+&G?????@?OAMo
+&G????GA?O?\_
+&G??@?O?C@GJ?
+&G?GA??OC@OE?
+&G?????@?GC]_
+&G????G@?@G\?
+&G???C?_I?PGG
+&G?AA?OC@?GK?
+&G?????G?AA^?
+&G????_?G@C]?
+&G???A?OE?@[?
+&G?GA??S@?OE?
+&G?????OGO@]?
+&G???O?OG@G[?
+&G??a??Q?_GE?
+&G?AA?_GA??[?
+&G?????@?AC]_
+&G????G?G@G\?
+&G???A?_E?PGG
+&G?AA?OC@??[?
+&G??????OPC]?
+&G?????_R?HAO
+&G???C@?I?PCO
+&G???A_GA?oK?
+&G???????G`NO
+&G?????@?@aM_
+&G????G?C@cL?
+&G???A?_I?PCO
+&G?????@?@BM_
+&G????G?C@EL?
+&G???@?OD?HGO
+&G?G?A?_GAOE?
+&G?????@?AAMo
+&G????G?OO?\_
+&G??@??_C@GJ?
+&G?G?A?OC@OE?
+&G?????@?G@]_
+&G????G@?@A\?
+&G???C?OD?GWO
+&G?@?O_C@?OE?
+&G???????H`N?
+&G??????CP`M?
+&G????@?R?_QO
+&G???C@?Q?PGG
+&G??????CPBM?
+&G?????_Gao@O
+&G???C@?P?GWO
+&G??A?_GA?G[?
+&G??????OAC]_
+&G????A?G@G\?
+&G???O?OGAWGG
+&G?A?O?S@?OK?
+&G??????OPA]?
+&G?????_P_`@O
+&G???@@?P?HGO
+&G???@_GA?gK?
+&G??????A?BNG
+&G?????G?@EMG
+&G????_?C@KKG
+&G???@?OE?PGG
+&G??????CGDMG
+&G?????OCOHKG
+&G???O?OC@WGG
+&G?A?O?P?OCK?
+&G???????OEMW
+&G?????A?@KKg
+&G????O?C@WHG
+&G???A?_I?@[?
+&G???????WC]O
+&G??????CoG[O
+&G?????_J?HGG
+&G???@GA?_gK?
+&G??????A?B^?
+&G?????C?A[Gg
+&G????O?GAWHG
+&G??@?OA?_GJ?
+&G??????GG[GW
+&G????A?GAWHG
+&G???GO@?OCJ?
+&G???O_GA?_M?
+&G???????OE]O
+&G?????A?@K[_
+&G????_?GAKKG
+&G???O_A?_GM?
+&G??????AAMKG
+&G??????Oo`KO
+&G????G@?OcL?
+&G????_GA?oM?
+&G??????A?aNO
+&G??????AG_^?
+&G?????G?@cM_
+&G??????EO_]?
+&G????_?C@gL?
+&G????@?Q_oGO
+&G???A?_I?`K?
+&G???C@?Q?`K?
+&G?????GA?@N_
+&G?????G?G_^?
+&G????_?Q??^?
+&G????_?CO_]?
+&G??A?AG?@?]?
+&G???C?OE?_[?
+&G?G?O_?C@?[?
+&G?G?O_C@?OK?
+&G??????O@DM_
+&G??????CWA]?
+&G????A?C@IL?
+&G????@?R?K@O
+&G???O?_GAWH?
+&G???C@?P?HI?
+&G?A?OOA?_GK?
+&G??A?_GA?gE?
+&G????A?CG@N?
+&G?????P?GC]?
+&G???O?OOO?]?
+&G???@AA?@G[?
+&G?A?@AA?@?[?
+&G?G@?AA@?OE?
+&GOAA?AG@?OC?
+&G?G?OOGA?_K?
+&G??????GGCMo
+&G??????OOA]_
+&G????A?O_?\_
+&G????AA?@C\?
+&G???GGC?@?Z?
+&G???C?OD?GY?
+&G?@@?_?C@?U?
+&G?@@?_A?_GE?
+&G?????@?GCMo
+&G?????@?OA]_
+&G????G@?_?\_
+&G????GA?@C\?
+&G??@?GC?@?Z?
+&G???@?S@?AW_
+&G?G@?_?C@?U?
+&G?G@?_A?_GE?
+&G??????GO@]_
+&G?????@?H@]?
+&G?????a?@A\?
+&G????G?R?@PO
+&G???A?OD?@Y?
+&G???GACA?AOo
+&G?G?O?Q?_GE?
+&G??A?_G@?`GG
+&G??????GOC]_
+&G?????@?P@]?
+&G?????a?@G\?
+&G????_?P_`?W
+&G???A?_E?QGG
+&G???GACA?AW_
+&G?A?@_C@?OK?
+&G??A?_G@?_[?
+&G??????A?BNO
+&G??????O@EM_
+&G?????G?@EM_
+&G????A?C@KL?
+&G????_?C@KL?
+&G???O?_GAWI?
+&G???A?_I?`CO
+&G?A?OO@?OCK?
+&G?????G?G@N_
+&G????A?CO@N?
+&G????_?OO?^?
+&G???O?OO_?]?
+&G??A?AA?@?]?
+&G?A?@AC?@?[?
+&G?G?OO?C@?[?
+&GOAA?AG?_GA?
+&G??????A@BN?
+&G??????CHDM?
+&G??????E@DM?
+&G????@?P__PO
+&G????@?R?`AG
+&G???C@?P?HGG
+&G???C@?Q?`CG
+&G??@?OC@?WGG
+&G??????GG_^?
+&G?????_COA]?
+&G?????_CO_]?
+&G???@A?G@G[?
+&G???O?_C@_[?
+&G?G@?A?D?OE?
+&G?G?O?S@?OK?
+&G?G?O?WA?_K?
+&G???????G`NG
+&G?????@?@BMG
+&G?????@?@aMG
+&G????G?C@EKG
+&G????G?C@cKG
+&G???@?OD?HGG
+&G???@?OE?PCG
+&G?G?GA?CGAE?
+&G???????GaNG
+&G??????COEMG
+&G?????@?@cMG
+&G?????Q?@KKG
+&G????G?C@gKG
+&G???@?OE?gCG
+&G???A?_I?O[?
+&G?A?@_A?_GK?
+&G???????G`^?
+&G?????@?Aw?w
+&G?????@?AwGg
+&G????G?GAo@g
+&G????O?GAgHG
+&G???OOG?OCB_
+&G??A?OA?_GJ?
+&G??A?OGA?_J?
+&G???????Ga^?
+&G??????I?[Gg
+&G?????G?A[KG
+&G?????g?AWHG
+&G????O?GAgKG
+&G??@?GG?_GJ?
+&G??A?OA?_GM?
+&G??A?_GA?OM?
+&G???????GaNO
+&G??????AGA^?
+&G?????@?@cM_
+&G??????EOC]?
+&G????G?C@gL?
+&G????@?P_oGO
+&G???A?_I?PK?
+&G???C@?Q?PK?
+&G?????@?@DM_
+&G??????CWC]?
+&G????G?C@IL?
+&G????@?P_`H?
+&G???A?_I?PH?
+&G???C@?Q?WCO
+&G?A?O_A?_GK?
+&G??@?OC@?gK?
+&G?????@?ACMo
+&G??????OOC]_
+&G????G?O_?\_
+&G????AA?@G\?
+&G???GOC?@?Z?
+&G???C?_I?WGG
+&G?G?O_?C@?U?
+&G?A?O_C@?OK?
+&G?????@?O@]_
+&G?????@?PA]?
+&G????GA?@A\?
+&G????_?P_`@O
+&G???@?S@?@W_
+&G???GACA?BG_
+&G?G?O_A?_GE?
+&G??@?_GA?gK?
+&G??????OA_N_
+&G?????G?G@^?
+&G????A?Q??^?
+&G????_?CO@]?
+&G???OAG?@?]?
+&G???C?OE?G[?
+&G?A?O_?C@?[?
+&G?G?O_C@?OE?
+&G????A?OA?^?
+&G?????OOOA]?
+&G???OA?O@?]?
+&G???OA?C@G[?
+&G?A?OA?C@?[?
+&G?G?OAC@?OE?
+&GOA?OA?P?OC?
+&G?A?O_GA?_K?
+&G??????A?PN_
+&G??????CG`N?
+&G?????C?@aN?
+&G?????OCO`M?
+&G????O?C@cM?
+&G???O?OC@gK?
+&G???@?OE?PK?
+&G?A?O_@?OCK?
+&G?????G?@BN?
+&G?????OCOBM?
+&G????_?C@EM?
+&G???@A?C@KK?
+&G???@?OE?HK?
+&G?@?GAG?GAE?
+&G?G?GAG?GAE?
+&G?G?O_GA?_E?
+&G??????A?aNG
+&G??????A?a^?
+&G?????G?@cMG
+&G?????G?AkKG
+&G????_?C@gKG
+&G????_?GAgKG
+&G???A?_I?_[?
+&G??A?_A?_GM?
+&G?????GA?AN_
+&G?????G?A_^?
+&G????_G?O?^?
+&G????_?G@_]?
+&G??A?_A?@?]?
+&G???A?OE?_[?
+&G?GA?O?C@?[?
+&G?GA?OC@??[?
+&G??????CGEMG
+&G??????GG[Gg
+&G?????OCOKKG
+&G?????`?AWHG
+&G???O?OC@SGG
+&G??@?GA?_CJ?
+&G?A?@OA?_GK?
+&G??A?_GA?GM?
+&G????A?COAN?
+&G?????OGOC]?
+&G???O?Q?O?]?
+&G???@G?G@G[?
+&G?A?@OA?@?[?
+&G?G@??S@?GE?
+&GOAA?_GA?OA?
+&G?GA?_G@??[?
+&G??????OOAMo
+&G??????GGC]_
+&G????G@?G?\_
+&G?????`?@G\?
+&G??@?G?C@CJ?
+&G???O?OGASGG
+&G?G@??OC@GE?
+&G?A?@OC@?GK?
+&G?????@?AA]_
+&G??????OBC]?
+&G????G?G@C\?
+&G????@?D_`?W
+&G???A?OD?@WO
+&G???C@?H?@WO
+&G?G@??Q?_GE?
+&G???A_GA?_[?
+&G???????OBMW
+&G???????OB]O
+&G?????@?@IKg
+&G?????C?AMGg
+&G????O?C@KHG
+&G????O?GAKHG
+&G???A?_H?@WO
+&G??@?G@?OCJ?
+&G???????IC]O
+&G??????AAMCW
+&G??????CQG[O
+&G??????OoPGW
+&G????@?QAOQO
+&G????O@?OKHG
+&G???C@?O@PGG
+&G????_GA?gKG
+&G??????A?WN_
+&G??????C_oN?
+&G????G?C@oM?
+&G??????D?aN?
+&G?????S?@cM?
+&G???@?OE?WK?
+&G??????P?_N_
+&G????AG?@ON?
+&G???O_C?@?]?
+&G?????CA?A^?
+&G????_C?@C]?
+&G???@?SA?A[?
+&G?????OE?EM?
+&G???@?OE?KK?
+&G?@?O_G?OCE?
+&G????A?O@_N?
+&G???OA?C@_M?
+&G?A?O?W?@?[?
+&G?????W?O@]?
+&G???O?OE?G[?
+&G??a?_A?_GE?
+&G?????@?O_Mo
+&G????GA?@_L_
+&G??@?OG?@?Z?
+&G?????@A?C]_
+&G????GG?@G\?
+&G???@?SA?OW_
+&G?????G?PC]?
+&G????_?R?HAO
+&G???GAGA?QC_
+&G??????CGoN?
+&G?????OCOoM?
+&G???O?_GAoK?
+&G?????OCOaM?
+&G???@A?C@gK?
+&G?AA?AA?_GK?
+&G????AG?A?^?
+&G???O_?O@?]?
+&G?AA?A?C@?[?
+&G?????W?OA]?
+&G???O?OE?@[?
+&G?GA?AC@?OE?
+&G???@?OCGKK?
+&G?@?O_?OOCE?
+&G?GA?AGA?_E?
+&G???OA?CA?]?
+&G?A?O?OO@?[?
+&GOA?O_?Q?_G?
+&G???O?OO@G[?
+&G?G?CAC@?OE?
+&G?AA?AGA?_K?
+&G????GA?@@L_
+&G??@?O?O@?Z?
+&G?GA?A?C@?U?
+&G????G?CGG\?
+&G???O?_I?PGG
+&G?AA?AC@?OK?
+&G????@@B?HAO
+&G???O@?Q?PCO
+&G???O_GA?oK?
+&G???????GoNO
+&G?????@?@oM_
+&G????G?C@oL?
+&G?????@?@`M_
+&G????G?C@aL?
+&G???A?_I?PD?
+&G?????@?A_Mo
+&G????G?Q??\_
+&G???GOG?@?Z?
+&G?????@A?@]_
+&G????GG?@A\?
+&G???@?SA?@W_
+&G????G?C@BL?
+&G???@?OD?KGO
+&G?@?OAG?OCE?
+&G????G?G@@L_
+&G???GO?O@?Z?
+&G?@A?A?C@?U?
+&G????G?CG@\?
+&G???O?OD?GWO
+&G??_O_A?_GE?
+&G?????A?_CKw
+&G????OC?_?Xo
+&G??A?_C?@?R_
+&G?????A?OG[o
+&G????OA?@OX_
+&G???A?g@?BGG
+&G?????A?PC[_
+&G????O?C`GX?
+&G???O@@A?SD?
+&G??????B?A^?
+&G??????F?C]?
+&G????@?P_WGO
+&G??????EGC]?
+&G????@?Q_PH?
+&G???C@?Q?gCO
+&G??????Q?C]_
+&G????AG?@G\?
+&G???C?_I?gCG
+&G?????G?PA]?
+&G????O?P_`@O
+&G???GAC@?BG_
+&G????@?P_`@_
+&G???C@?P?KGO
+&G??A?_GA?KK?
+&G????A?O@G\?
+&G???OA?GAWGG
+&G?A?OAC@?OK?
+&G????@@@_`?o
+&G???O@?P?HGO
+&G???O_GA?gK?
+&G?????@?OG[o
+&G????GA?@OX_
+&G???A?c@?BGG
+&G?????A?`C[_
+&G????O?D@GX?
+&G???O@@A?cD?
+&G?????K?gI@_
+&G????_@@OSB?
+&G????_GB?oI?
+&G??????A?QNO
+&G??????AGO^?
+&G?????C?@cM_
+&G??????EOO]?
+&G????_?C@WL?
+&G????@?R?WGO
+&G?????G@?@N_
+&G?????C?G_^?
+&G????_?G@ON?
+&G????O?CO_]?
+&G??A?AC?@?]?
+&G???C?OE?O[?
+&G?????G?@DM_
+&G??????E@EM?
+&G????_?C@IL?
+&G????@?P_PH?
+&G???A?_I?`D?
+&G???C@?Q?`E?
+&G????_?OA?^?
+&G?????P?G_]?
+&G??A?A?O@?]?
+&G???OA?C@_[?
+&G?G?OA?C@?[?
+&G?G?OAC@?OK?
+&G?????G?ACMo
+&G??????OO_]_
+&G????_?O_?\_
+&G????AA?@_\?
+&G???G_C?@?Z?
+&G???C?_I?WCG
+&G?????G?OCMo
+&G?????@?O_]_
+&G????GG?_?\_
+&G????GA?@_\?
+&G??A?OC?@?Z?
+&G???@?S@?_W_
+&G?????G?O@]_
+&G?????@A@A]?
+&G????_A?@A\?
+&G????G?R?`@O
+&G???@?W@?@W_
+&G???GAG@?BG_
+&G?????G?OC]_
+&G?????@A@C]?
+&G????_A?@G\?
+&G????G?R?`AO
+&G???@?W@?OW_
+&G???GAG@?aC_
+&G??????O@cM_
+&G??????EOA]?
+&G????A?C@gL?
+&G????@?Q_o@O
+&G???O?_GAgK?
+&G???C@?Q?HK?
+&G????A?CA_N?
+&G????_?COA]?
+&G???O?OG@_M?
+&G???@@?E?G[?
+&G?A?@AG?@?[?
+&G?G@?_@@?OE?
+&G????A?C@HL?
+&G????@?R?K?o
+&G???O?_GAWG_
+&G???C@?P?DI?
+&G?A?OAA?_GK?
+&G??A?_GA?gD?
+&G???O?OOA?]?
+&G???@A?O@G[?
+&G?A?@A?O@?[?
+&G?G@?A?P?OE?
+&GOAA?A?Q?_G?
+&G?G?OAGA?_K?
+&G????@?G_?\_
+&G????AA?@@\?
+&G???G@C?@?Z?
+&G???C?OD?CY?
+&G?@?G_?C@?U?
+&G?@@?AG@?OE?
+&G????G?O@GL_
+&G????G?C_A\?
+&G???GO?D??Z?
+&G???@?S@?GW_
+&G?G?O?W?@?U?
+&G?@@?_G@?OE?
+&G????A?C_@\?
+&G????G?R?D?o
+&G???O?OD?@Y?
+&G???GACA?I?o
+&G?@A?AC@?OE?
+&G??A?_G@?gGO
+&G????A?C_G\?
+&G????@G@_`@O
+&G???O?_I?WGG
+&G???GACA?IG_
+&G?A?OOG@?OK?
+&G??A?_G@?gK?
+&G??????A?QNG
+&G??????A?Q^?
+&G?????C?@cMG
+&G?????A?AkKG
+&G????O?C@gKG
+&G????G?GAgKG
+&G?????G@?AN_
+&G?????C?A_^?
+&G????_@?@ON?
+&G????O?G@_]?
+&G??A?OA?@?]?
+&G???A?OE?O[?
+&G??????E?EMG
+&G??????H?[Gg
+&G?????W?@KKG
+&G?????c?AWHG
+&G???@?OE?WGG
+&G??@?GC?_GJ?
+&G????A?CO_N?
+&G?????W?AC]?
+&G???O?Q?@_M?
+&G???@?_E?G[?
+&G?A?@_C?@?[?
+&G?G@?_?D?OE?
+&G?????@?G_Mo
+&G??????I?C]_
+&G????G@?@_L_
+&G?????g?@G\?
+&G??@?GG?@?Z?
+&G???A?_E?aCG
+&G?????GA?ON_
+&G????A?CG_N?
+&G????_G?@ON?
+&G???O?P?@_M?
+&G??A?_C?@?]?
+&G?A?@_A?@?[?
+&G?????@A?A]_
+&G?????G?P@]?
+&G????GG?@C\?
+&G????O?P_`?W
+&G???@?SA?AW_
+&G???GAC@?AW_
+&G?????G@?_^?
+&G?????W?OC]?
+&G????_C?@_]?
+&G???@G?E?G[?
+&G???@?W@?_[?
+&G?G@?_C@?GE?
+&G??????CGcMG
+&G??????GGkKG
+&G?????OCOgKG
+&G?????_GOgKG
+&G???O?_GA_[?
+&G??A?AA?_GM?
+&G????_?O@CN?
+&G?????OGO_]?
+&G??A?A?C_?]?
+&G???O?OG@_[?
+&G?G?O?S?@?[?
+&G?G?OOC@??[?
+&G?????OCOIKG
+&G?????_GGWHG
+&G???O?OC@QGG
+&G??@?G?O_GJ?
+&G?A?@AA?_GK?
+&G??A?AGA?_M?
+&G???O?OO@GM?
+&G???@A?CAG[?
+&G?A?@A?D??[?
+&G?G@??OP?OE?
+&GOAA?AGA?_C?
+&G?G?O_GA??[?
+&G????G@?@@L_
+&G?????_CGG\?
+&G??@?G?O@?Z?
+&G???O?_G@PGG
+&G?G@?A?C@?U?
+&G?A?@AC@?OK?
+&G????_?O@_N?
+&G???O?OO@CM?
+&G??A?A?E??]?
+&G?A?@A?C_?[?
+&G?G?O?W?@?[?
+&GOAA?AGA?_A?
+&G????G?CGC\?
+&G????@@@_`?W
+&G???O?OD?@WO
+&G???O@?P?@WO
+&G?G@?AA?_GE?
+&G???O_GA?_[?
+&G?????W?O_]?
+&G???@A?C_G[?
+&G???O?OE?_[?
+&G?G@?AC@?GE?
+&G?G?OOG@?OK?
+&G?G?O_GA?OK?
+&G???????OaMW
+&G???????Oa]O
+&G?????@?@gKg
+&G?????@?@g[_
+&G????O?C@gHG
+&G????G?GAcKG
+&G?????G?OAMo
+&G?????@?A_]_
+&G????GG?G?\_
+&G????G?G@_\?
+&G??A?O?C@GJ?
+&G???A?_E?PCG
+&G?????@?@HKg
+&G?????C?AMGW
+&G????O?C@IHG
+&G?????a?AQHG
+&G???A?_H?@Y?
+&G???GGC?_GJ?
+&G????G?O@AL_
+&G????G?CAA\?
+&G???GO?C@GJ?
+&G???@?_D?GWO
+&G?@A??OC@OE?
+&G?@@?_?D?OE?
+&G??????OOGKw
+&G??????G_C[o
+&G????AA@??Xo
+&G????G?G@OX_
+&G???OOG?@?R_
+&G???@?_H?HGG
+&G?????G?O_Mo
+&G????G?O@@L_
+&G????GG?@_L_
+&G???GO?CG?Z?
+&G??A?OG?@?Z?
+&G?G?GA?C@?U?
+&G?????@?_A[o
+&G?????@?BG[_
+&G????GC?@CX_
+&G????O?C`@X?
+&G???@?SA?AOo
+&G???CGA@?GY?
+&G?????@A?_]_
+&G????G?CGA\?
+&G????GG?@_\?
+&G???@G?D?GWO
+&G???@?SA?_W_
+&G?@@?_C@?GE?
+&G??????AGC]O
+&G??????AAUEG
+&G??????EOG[O
+&G??????QOHKO
+&G?????_J?`AG
+&G????_@?OKL?
+&G?????G?GC]_
+&G??????Q@C]?
+&G????_@?@G\?
+&G?????_R?`AO
+&G???C?_I?`CG
+&G???C@?I?`CO
+&G??????CWG[O
+&G??????OoPGo
+&G????@?O`PH?
+&G????G@?OSH_
+&G???C@?OAWGO
+&G????_GA?gL?
+&G????A?COG\?
+&G????@?D_`@O
+&G???OA?GASGG
+&G???C@?H?HGO
+&G?A?OOC@?GK?
+&G???A_GA?cK?
+&G??????O_C[o
+&G??????OPG[_
+&G????G@?@OX_
+&G????@?D@GX?
+&G???C?_H?HGG
+&G???CGA?AWI?
+&G?????GA?C]_
+&G????A?CGG\?
+&G????_G?@G\?
+&G???GA?GAWGG
+&G???@?WA?OW_
+&G?A?OOC@?CK?
+&G?????@?HG[_
+&G?????E?Wa?o
+&G????G?IAS@G
+&G????O@?oc@O
+&G???CGA@?HI?
+&G????_GA_oGO
+&G?????GA@C]?
+&G????@@@_`@O
+&G????_?R?`AO
+&G???CG?P?HGO
+&G???GAGA?aC_
+&G???O_GA?cK?
+&G??????A?EMW
+&G??????A?E]O
+&G???????W_]O
+&G??????AAeEG
+&G?????G?@KKg
+&G?????G?@K[_
+&G??????Co_[O
+&G??????OoHKO
+&G????_?C@WHG
+&G????G?GAKKG
+&G?????_J?HAG
+&G????G@?OKL?
+&G?????@A?AMo
+&G?????G?AC]_
+&G?????@?G_]_
+&G??????OP_]?
+&G????GG?O?\_
+&G????_?G@G\?
+&G????G@?@_\?
+&G?????_R?HGO
+&G??@?_?C@GJ?
+&G???A?_E?`CG
+&G???C?_I?PCG
+&G???C@?I?PGO
+&G?????G@?ON_
+&G????_?O@@N?
+&G?????C@?_^?
+&G?????P?O_]?
+&G????_?D?ON?
+&G??A?A?CG?]?
+&G????OC?@_]?
+&G???O?P?@_[?
+&G??A?OC?@?]?
+&G?G?O?P?@?[?
+&G???@?S@?_[?
+&G?G?OOC@?CK?
+&G??????O@KKg
+&G??????CGK[O
+&G??????CoA[O
+&G??????OoBKO
+&G????A?C@WHG
+&G?????_GOHKG
+&G????@?Oao@O
+&G????G@?OEL?
+&G???O?_GAG[?
+&G???OAA?_GM?
+&G???O?P?OKK?
+&G????_GA?cM?
+&G????G?O@CL_
+&G????A?CAG\?
+&G????G?COA\?
+&G????@?H_`@O
+&G??@?A?C@GJ?
+&G???O?_G@WGG
+&G???@@?D?GWO
+&G???C@?D?HGO
+&G?G?O?OC@OE?
+&G?A?OOC@??[?
+&G?@@?_@@?OE?
+&G???@_GA?cK?
+&G????A?E?_N?
+&G???O?OO@@M?
+&G?????WA?C]?
+&G???@A?CGG[?
+&G???O?OE?_M?
+&G?A?@A?CG?[?
+&G???@?WA?G[?
+&G?G@?@?P?OE?
+&G?A?@_G?@?[?
+&GOAA?AGA?_?_
+&G?G@?_G@?OE?
+&G?G?O_GA?CK?
+&G??????A?`N_
+&G?????G?@aN?
+&G????_?C@cM?
+&G???@?OE?`K?
+&G?G?O_@?OCK?
+&G??????CGBN?
+&G?????OCODM?
+&G???O?OC@KK?
+&G??`?AG?GAE?
+&G?G@?_GA?_E?
+&G??????OAAN_
+&G???????GBNO
+&G????A?OO?^?
+&G?????@?@EM_
+&G???OAA?@?]?
+&G????G?C@KL?
+&G?A?OO?C@?[?
+&G???A?_I?PGO
+&GOAA?AG?GA?_
+&G?G?OO@?OCK?
+&G??????GG@^?
+&G???????HBN?
+&G?????_CO@]?
+&G??????CPDM?
+&G???O?_C@G[?
+&G????@?R?HAG
+&G?G?O?S@?OE?
+&G???C@?Q?PCG
+&G?A?@_GA?_K?
+&G??@?OC@?_[?
+&G???????GBNG
+&G?????@?@EMG
+&G????G?C@KKG
+&G???@?OE?`CG
+&G?G?O?P?OCK?
+&G???????GB^?
+&G?????G?A[Gg
+&G????_?GAWHG
+&G??A?O@?OCJ?
+&G??A?OC@?OM?
+&G??????A?qN?
+&G?????G?AsM?
+&G????_?GAoM?
+&G?????G?AoN?
+&G????_?G@oM?
+&G???A?_E?oK?
+&G??????I?kK_
+&G?????g?AgL?
+&G???O_G?OCM?
+&G?????W?AcM?
+&G???@?_E?gK?
+&G?AA?_A?_?[?
+&G??????I?cM_
+&G?????g?@gL?
+&G???@?_I?gK?
+&G????AGA?AN?
+&G???O_G?O?]?
+&G?AA?_A?@?[?
+&G?????GAO@]?
+&G????_?Q_o?W
+&G???GAGA?A[?
+&G????_G?OC]?
+&G???@AGA?A[?
+&G?GA?_C@?GE?
+&G??????GGkK_
+&G?????`?AgL?
+&G???O_A?OCM?
+&G?????OGOcM?
+&G???@G?G@gK?
+&G?AA?OA?_?[?
+&G?????_GOWH_
+&G???GAC?GGJ?
+&G??@?OC@?GJ?
+&G???@?Q?AKK?
+&G?@?O_@?@OE?
+&G?GA?_G?@OE?
+&G?????_CGIL?
+&G???O?_G@PH?
+&G?A?O?S?_GK?
+&G???OA?COAM?
+&G?A?O?Q?O?[?
+&GOA?O_GA?G@?
+&G????@@@_@X?
+&G???CG?P?@Y?
+&G???O_GA?SGG
+&G???O?Q?OG[?
+&G?G?GAC@?GE?
+&G?AA?_G@?GK?
+&G??????GGcM_
+&G?????`?@gL?
+&G???@G?GAgK?
+&G????AG?OAN?
+&G???O_A?O?]?
+&G?AA?OA?@?[?
+&G?????_COIL?
+&G???O?_C@QH?
+&G?A?O?Q?_CK?
+&G???OA?C_CM?
+&G?A?O?S?_?[?
+&GOA?O_GA?OA?
+&G????@?O_CL_
+&G???GAC?@GJ?
+&G?@?O_?C@OE?
+&G????GA?_CL_
+&G??@?OC?@GJ?
+&G?GA?_?C@OE?
+&G????AA?OA\?
+&G???CG?D?@Y?
+&G?G?GAC?_GE?
+&G????GA?OG\?
+&G???@AC@?OW_
+&G?AA?_C@?GK?
+&G??????OBcM?
+&G????@?F?g?W
+&G???C@?I?@[?
+&G????_?GOC]?
+&G???C?_E?@[?
+&G?GA??S@?GE?
+&G?????_OBWH?
+&G???C@?H?@Y?
+&G???AOC@?OX?
+&G???O?Q?AG[?
+&G??a??Q@?GE?
+&G?AA?_G@??[?
+&G????AA?AA\?
+&G???C?_D?@Y?
+&G??a??Q@?OE?
+&G????GA?AG\?
+&G???A?S@?OW_
+&G?AA?_C@??[?
+&G????G?J?D@O
+&G???AACA?B?o
+&G???AOGA?cH?
+&G????_?H_`GO
+&G???AACA?aG_
+&G???A_G@?oK?
+&G???????ObMO
+&G?????A?AeK_
+&G????G?GAcL?
+&G?????@?AaM_
+&G????G?G@cL?
+&G???A?_E?PCO
+&G?????@?AYGo
+&G????G?GASH_
+&G??@??_GAGJ?
+&G????G?CAEL?
+&G???@?_D?HGO
+&G?G?A?_G@OE?
+&G??????G_DKo
+&G????G?G@SH_
+&G???@?_H?HGO
+&G????G?OO@L_
+&G??@??_G@GJ?
+&G?G?A?_C@OE?
+&G?????@?BIK_
+&G????O?GBKH?
+&G???CGA@?GWO
+&G????G@?GA\?
+&G???CG?D?GWO
+&G?@?O_C@?GE?
+&G??????AAUEO
+&G??????GQgKO
+&G????_@?OKKG
+&G??????QAC]?
+&G?????_R?_QO
+&G???C@?E?PGG
+&G??????GQWGo
+&G????AA?GQHG
+&G????OC@?WHG
+&G?????_Cao@O
+&G???C@?H?GWO
+&G???A_GA?C[?
+&G??????OQG[_
+&G?????_C`PH?
+&G???O@@?@SGG
+&G????A?GGG\?
+&G???GA?CAWGG
+&G?A?O?S@?CK?
+&G?????E?Qa?o
+&G????G@AAS@O
+&G????_GB?_QO
+&G?????`@_`@O
+&G???@G?P?HGO
+&G???@GGA?gK?
+&G???????IcMO
+&G??????CQgKO
+&G?????_J?_QO
+&G?????G?GEMG
+&G????_?COKKG
+&G???C?OE?PGG
+&G??????CQIKO
+&G????@?OaOX?
+&G???C@?O@WGG
+&G?????P?GIKG
+&G???OA?C@SGG
+&G?A?O?S?OCK?
+&G??????O_DKg
+&G????AA?@QHG
+&G???C?_H?GWO
+&G?????A?_KKg
+&G????OC?@WHG
+&G???A?gA?A[?
+&G?????A?WA[O
+&G????G?QAS@O
+&G???@GA@?HGO
+&G?????A?oG[O
+&G????_?J?HGG
+&G???@GAA?gK?
+&G??????B?eAW
+&G??????POWGW
+&G????O@?OWHG
+&G?????C?G[Gg
+&G????O@?AWHG
+&G??@?OA?_CJ?
+&G??????OoQGW
+&G????O@?OIHG
+&G????_GA?KKG
+&G????A?GOWHG
+&G???GO@?_CJ?
+&G???O_GA?GM?
+&G?????C?GLGg
+&G????O@?AIHG
+&G???GO@?_GJ?
+&G?????A?_K[_
+&G????_G?AKKG
+&G???O_G?_GM?
+&G?????C?oBGo
+&G????GC?OEH_
+&G????GGA?cL?
+&G?????G?o`KO
+&G????GG?OcL?
+&G????_G@?oM?
+&G???????GqN?
+&G?????G?A[M?
+&G????G?GAoM?
+&G??????I?[K_
+&G?????c?AgL?
+&G???O_C?OCM?
+&G??????GOcM_
+&G?????a?@gL?
+&G???@?_I?WK?
+&G?????@AO@]?
+&G????_?P_o?W
+&G???GACA?A[?
+&G?????_I?WH_
+&G???GACA?AJ?
+&G??@?OG@?OJ?
+&G?????_C_IL?
+&G???A?_E?QH?
+&G?A?O?W?_GK?
+&G????@G@_@X?
+&G???GACA?AY?
+&G??A?_G@?WGG
+&G????@?O_GL_
+&G???GAC@??Z?
+&G?@?O_G?@?U?
+&G????AA?_A\?
+&G???G?S@?AY?
+&G??a?_A@?OE?
+&G????GAB?D@O
+&G???O_C@?E@_
+&G??A?_C@?aG_
+&G??????GGoN?
+&G?????_COoM?
+&G???O?_C@oK?
+&G?????_COaM?
+&G???@A?G@gK?
+&G?AA?A?C_GK?
+&G????AG?G@N?
+&G???O_?OO?]?
+&G?AA?AA?@?[?
+&G????_@?GC]?
+&G???O@?E?@[?
+&G?GA?AC?_GE?
+&G???@?OGGKK?
+&G?@?O_?O@CE?
+&G?GA?A?E?_E?
+&G???OA?CO@M?
+&G?A?O?OO_?[?
+&GOA?O_?Q?GA?
+&G???O?Q?GG[?
+&G??Q?AC?_GE?
+&G?AA?ACA?_K?
+&G????GA?_@L_
+&G??@?O?P??Z?
+&G?GA?AG?@?U?
+&G????GA?GG\?
+&G???@@C@?OW_
+&G?AA?AG@?OK?
+&G????G@B?HAO
+&G???G@G@?`GO
+&G???O_C@?oK?
+&G???????GpN?
+&G?????@?AwK_
+&G????G?GAoL?
+&G?????@?AwGo
+&G????G?GAoH_
+&G???GOG?GAJ?
+&G??????GO`M_
+&G?????a?@aL?
+&G???A?_E?QCO
+&G?????@AG@]?
+&G????G?R?@X?
+&G???C@CA?@W_
+&G????G?GAo@o
+&G???A?c?A_B_
+&G??A?_CA?_B_
+&G?????a?@BL?
+&G???A?OD?DI?
+&G?@A?A?COCE?
+&G????_?P_@P_
+&G???GACA?H?g
+&G??A?OGA?KGG
+&G?????_G_@L_
+&G???GA?P??Z?
+&G?@?OAG?@?U?
+&G????A?O_A\?
+&G???O@?D?CY?
+&G??_O_A@?OE?
+&G????G@B?B?o
+&G???G@G@?HAO
+&G???O_C@?WE?
+&G??????B?BN?
+&G??????F?DM?
+&G?????_H_WGO
+&G??????EGDM?
+&G????@?Q_OX?
+&G???C@?Q?gCG
+&G??????Q?DM_
+&G????AG?@IL?
+&G???C?_I?gCO
+&G?????G?WA]?
+&G????_?R?K@O
+&G???C@C@?BG_
+&G????@?R?GP_
+&G???C@?P?KGG
+&G??@?OC@?KGG
+&G????A?O@IL?
+&G???OA?GAWH?
+&G?A?OAC?OCK?
+&G????@@B?I?o
+&G???O@?P?HI?
+&G???O_GA?gE?
+&G?????A?_KKo
+&G????OC?@WH_
+&G???A?gA?BK?
+&G?????A?`KK_
+&G????O?D_OX?
+&G???CGAA?gK?
+&G?????K?o`GO
+&G????G@B?cH?
+&G????_GB?oE?
+&G??????A?eMO
+&G??????AAeM?
+&G?????G?@kK_
+&G??????QO`M?
+&G????_?GAcM?
+&G????_@?OcM?
+&G?????G?AcM_
+&G??????QO_]?
+&G????_?G@gL?
+&G????@?I_oGO
+&G???A?_E?`K?
+&G???C@?E?`K?
+&G????_?Q?@N?
+&G????_@?O_]?
+&G??A?AG?G?]?
+&G???C@?E?_[?
+&G?G?O_@?@?[?
+&G?G?O_C@?CK?
+&G??????GGpB_
+&G??????GIKK_
+&G?????`?AIL?
+&G????AA?GEL?
+&G???OAA?OCM?
+&G????GA?_KL?
+&G????A?CAIL?
+&G????@?J?K@O
+&G???O?_G@WH?
+&G???C@?D?HI?
+&G?A?OOA?_?[?
+&G???A_GA?SH?
+&G???O?OOO@M?
+&G???@AA?GG[?
+&G?A?@AA?G?[?
+&G?G@?@?O_OE?
+&GOAA?AG@?O?_
+&G?G?OOGA?CK?
+&G??????GGKKo
+&G??????GHKK_
+&G?????`?@WH_
+&G????@?J?K@G
+&G???O?OGAKK?
+&G???O?Q?_KK?
+&G????A?O_@L_
+&G????AA?GC\?
+&G???CG?P??Z?
+&G???C@?D?GY?
+&G??`?AG?@?U?
+&G?@@?_@?_GE?
+&G????G@?_GL_
+&G????GA?_C\?
+&G??@?GC@??Z?
+&G???@OC@?CX?
+&G?G@?_G?@?U?
+&G?G@?_G?_GE?
+&G??????OBKK_
+&G?????BB?B?g
+&G?????_D_@X?
+&G????G@B?D@G
+&G???O?a?_G[?
+&G????GAB?HAG
+&G?????a?GA\?
+&G????G@B?@PO
+&G???A@?D?@Y?
+&G???G@CA?AOo
+&G?G?O?S?_GE?
+&G???O_C@?SCG
+&G?????a?_G\?
+&G????_G@_`?W
+&G???A?WA?SGG
+&G???OOGA?CX?
+&G?A?@_G@?OK?
+&G??A?_C@?_[?
+&G??????A?FMO
+&G??????GGpBO
+&G?????A?AMK_
+&G????A?GAKL?
+&G????G?GAKL?
+&G???OAA?GAM?
+&G?????G?AEM_
+&G????A?CAKL?
+&G????_?G@KL?
+&G???O?_G@WI?
+&G???A?_E?`CO
+&G?A?OO@?O?[?
+&G????_?OO@N?
+&G???O?OO_@M?
+&G??A?AA?G?]?
+&G?A?@AC?G?[?
+&G?G?OO@?@?[?
+&GOAA?AG?_G?_
+&G??????AAeEO
+&G??????GIKKO
+&G??????GaKKO
+&G????G@?OEKG
+&G????G@?OKKG
+&G????GA?_KKG
+&G??????OQ_]?
+&G????@?H__PO
+&G?????_R?GWO
+&G???C@?D?HGG
+&G???C@?E?`CG
+&G???A_GA?OX?
+&G?????`?O_]?
+&G???@A?GGG[?
+&G???O?`?@_[?
+&G?G@?A?CGOE?
+&G?G?O?S@?CK?
+&G?G?O?WA?CK?
+&G??????AAEMO
+&G??????CIKKO
+&G??????EAKKO
+&G?????_H__PO
+&G?????_J?GQO
+&G???O?`?OG[?
+&G?????@?GaMG
+&G????G?COEKG
+&G????G?COcKG
+&G???@@?D?HGG
+&G???C?OE?PCG
+&G?G?O?P?OOE?
+&G?????@?OcMG
+&G?????Q?_KKG
+&G????GA?@gKG
+&G???@?S@?WGG
+&G???A?c@?_[?
+&G?A?@_G?_GK?
+&G??????B?MAW
+&G??????Ooo?w
+&G??????QOWGW
+&G????G@?Oo@g
+&G????_@?OWHG
+&G????_GA?WHG
+&G?????@?GwGg
+&G????G?GOo@g
+&G????O@?AgHG
+&G???OOG?OAB_
+&G??A?OA?_CJ?
+&G??@?_GA?GJ?
+&G?????GA?[KG
+&G?????gA?WHG
+&G????OC?AgKG
+&G??@?GGA?GJ?
+&G??A?OC?_GM?
+&G??A?_G@?OM?
+&G???????OeMO
+&G??????AAUM?
+&G?????A?@kK_
+&G??????PO`M?
+&G????O?GAcM?
+&G????_@?OSM?
+&G?????@?AcM_
+&G??????QOC]?
+&G????G?G@gL?
+&G????@?H_oGO
+&G???A?_E?PK?
+&G???C@?E?PK?
+&G?????G?AMKO
+&G??????IAKK_
+&G?????g?AIL?
+&G????AA?GaL?
+&G???OAG?OCM?
+&G????GA?_gL?
+&G????G?CAIL?
+&G????@?D_`H?
+&G???A?_E?PH?
+&G???C@?I?WCO
+&G?A?O_A?_?[?
+&G???AOC@?cK?
+&G??????G_KKo
+&G??????G`KK_
+&G????O?G@WH_
+&G????@?D_OX?
+&G???@?_I?HK?
+&G???O?Q?_gK?
+&G????G?O_@L_
+&G????AA?GG\?
+&G???GOC?G?Z?
+&G???C@?I?WGG
+&G?G?GAG?@?U?
+&G?A?O_C@?CK?
+&G?????A?BKK_
+&G?????BB?a?o
+&G????O?D_@X?
+&G????G@B?c@O
+&G???CGAA?G[?
+&G????_G@_oGO
+&G????GA?GA\?
+&G????_@@_`@O
+&G???C?S@?@W_
+&G???G@CA?BG_
+&G?G?O_C?_GE?
+&G???O_C@?SK?
+&G??????OAcM_
+&G??????QOA]?
+&G????A?G@gL?
+&G?????_Q_o@O
+&G???O?OGAgK?
+&G???@@?Q?HK?
+&G????A?Q?@N?
+&G????_@?OA]?
+&G???OAG?G?]?
+&G???C@?E?G[?
+&G?A?O_@?@?[?
+&G?@A?_@?_GE?
+&G????A?G@HL?
+&G????@?J?K?o
+&G???O?_C@QI?
+&G???C?OP?DI?
+&G?A?OA?C_GK?
+&G???A_GA?SI?
+&G???OA?O@AM?
+&G???OA?COG[?
+&G?A?OA?CO?[?
+&G?G?GA?P?OE?
+&GOA?OA?P?O?_
+&G?A?O_GA?GK?
+&G????@?G_@L_
+&G????AA?G@\?
+&G???G@?P??Z?
+&G???C@?D?CY?
+&G?@?GAG?@?U?
+&G?@?G_@?_GE?
+&G????G?O_GL_
+&G????GA?_A\?
+&G???GOC@??Z?
+&G???@OC@?AX?
+&G?G?O_G?@?U?
+&G?@A?_G@?OE?
+&G????A?O_@\?
+&G????G@B?D?o
+&G???O@?D?@Y?
+&G???CACA?I?o
+&G?G?OAC?_GE?
+&G???O_C@?WD?
+&G????AA?_G\?
+&G????_G@_`@O
+&G???AAGA?SGG
+&G???OOGA?EH?
+&G?A?O_G@?OK?
+&G??@?_G@?gK?
+&G??????A?RN?
+&G??????GGkKO
+&G?????A?AkK_
+&G????A?GAgL?
+&G????G?GAgL?
+&G???OAG?GAM?
+&G?????C?AaN?
+&G?????OGO`M?
+&G????O?G@cM?
+&G???O?OG@gK?
+&G???A?OE?PK?
+&G?A?O_@?O?[?
+&G?????C?A[Go
+&G????@?GAWH_
+&G????O?GAWH_
+&G???G@?P?@J?
+&G???GOC?GAJ?
+&G???GOC@?OJ?
+&G????_?CAEM?
+&G???@A?CAKK?
+&G???@?_E?HK?
+&G?@?GAG?G?U?
+&G?G?GAG?G?U?
+&G?G?O_GA??U?
+&G??????I?DM_
+&G?????_CGHL?
+&G?????g?@IL?
+&G???O?_G@PI?
+&G???A?_E?aCO
+&G?A?OA?COCK?
+&G????A?Q?AN?
+&G???OA?O@CM?
+&G???OAG?O?]?
+&G?A?OA?C_?[?
+&G?A?O_A?@?[?
+&GOA?OA?P?O@?
+&G?????G?W@]?
+&G????@@@_@W_
+&G????O?P_@X?
+&G???O@?P?@Y?
+&G???C@C@?@W_
+&G???O_GA?WGG
+&G????_@?GA]?
+&G???OA?C_G[?
+&G???CG?E?G[?
+&G?G?OAC@?GE?
+&G?G?O_C@?GE?
+&G?A?O_GA?OK?
+&G??????@G`N?
+&G??????EOBM?
+&G??????DO`M?
+&G?????_I_o@O
+&G?????_H_oGO
+&G???C@?Q?G[?
+&G?????C?GaN?
+&G????_?COEM?
+&G????O?COcM?
+&G???@@?E?HK?
+&G???C?OE?PK?
+&G?G?O_@?OOE?
+&G??????CW`M?
+&G????@?R?I@G
+&G????@?P_OX?
+&G???C@?P?CY?
+&G???C@?Q?WGG
+&G??@?OC@?CY?
+&G?????P?GaM?
+&G???@A?COKK?
+&G???O?Q?@gK?
+&G??_O_@?OOE?
+&G?A?O_C?OCK?
+&G?@A?_GA?OE?
+&G??????OO`M_
+&G????AA?@BL?
+&G????AA?@aL?
+&G???C?OD?DI?
+&G???C?_I?WCO
+&G?G?O?`?OOE?
+&G?????@?OcM_
+&G????G?C_IL?
+&G????GA?@gL?
+&G???@?S@?WG_
+&G???A?c@?aK?
+&G?A?O_G?_GK?
+&G?????@AGA]?
+&G????G?R?D@_
+&G????G?R?c@O
+&G???C@CA?I?o
+&G???C@CA?BG_
+&G??@?_GA?KI?
+&G?????@AOC]?
+&G????@G@_`H?
+&G????_?P_oGO
+&G???GACA?gG_
+&G???GACA?aK?
+&G??@?_C@?gK?
+&G??????A?eMG
+&G?????G?@kKG
+&G?????G?AcMG
+&G????_?GA_]?
+&G????_G?OCN?
+&G????_?G@gKG
+&G???A?_E?_[?
+&G??A?_A?_?]?
+&G?GA?OC?@?[?
+&G??????GGK[_
+&G??????GGKKg
+&G?????`?AG\?
+&G????G@?OAL_
+&G???O?Q?OCM?
+&G????_GA?CN?
+&G?????OGOKKG
+&G?????`?@WHG
+&G???O?OG@SGG
+&G??@?G?C_CJ?
+&G?A?@OA?_?[?
+&G??A?_G?_?]?
+&G???O?Q?_CM?
+&G???@G?GAG[?
+&G?A?@OC?_?[?
+&G?G@??OD?GE?
+&GOAA?_G@?OA?
+&G?GA?_C?@?[?
+&G??????Go@[O
+&G?????_D_`?W
+&G????G@?AC\?
+&G???@GA?AG[?
+&G????_G?A_]?
+&G???C?_D?@WO
+&G?G@??S?_GE?
+&G???A?WA?_[?
+&G?GA?_C@??[?
+&G???????_FKW
+&G?????C?@MGg
+&G?????@?AIKg
+&G????G?GAC\?
+&G????G@?GAL_
+&G????O?G@KHG
+&G???A?_D?@WO
+&G??@?G?COCJ?
+&G?G@??OC_GE?
+&G??????AAEUO
+&G???????WHKW
+&G??????GQG[O
+&G?????@?GIKg
+&G?????P?OKKG
+&G?????GA?cMG
+&G??????OQG[O
+&G??????CoPGW
+&G????@?IAOQO
+&G????O@?@KHG
+&G???GA?C@QGG
+&G????_G?@gKG
+&G?????`?OG\?
+&G?????OD_`?W
+&G???GA?CAQGG
+&G???C?_H?@WO
+&G?A?@OC?_GK?
+&G???A?gA?_[?
+&G??????B?FAW
+&G??????OQWGW
+&G?????C?GMGg
+&G?????`?OWHG
+&G?????GA?kKG
+&G????O@?AKHG
+&G??@?GA?OCJ?
+&G????_G?AgKG
+&G??A?_G?_GM?
+&G???????_MKW
+&G??????A?FMG
+&G??????AAE]?
+&G???????W`MO
+&G?????C?@[Gg
+&G?????G?AEMG
+&G??????OP`M?
+&G?????@?GaM_
+&G????_?GAC]?
+&G????AG?OCN?
+&G?????P?OcM?
+&G?????GA?oN?
+&G?????A?AKKg
+&G?????A?AK[_
+&G??????OoG[O
+&G??????Co`KO
+&G????O?G@WHG
+&G????_?G@KKG
+&G?????_R?HGG
+&G????G@?@cL?
+&G???A?_E?@[?
+&G???O_A?_?]?
+&G???@GA?@gK?
+&G????_G?@oM?
+&G????GA?OCL_
+&G????G?GAG\?
+&G????G@?OG\?
+&G?????_J?HAO
+&G??@?O?C_GJ?
+&G???A?OE?PGG
+&G???C@?I?PGG
+&G???C?_I?PCO
+&G?GA??OD?OE?
+&G?AA?OC?@?[?
+&G?AA?OC?_GK?
+&G???A?gA?oK?
+&G??????OAKKg
+&G??????GGK[O
+&G??????OoA[O
+&G??????CoBKO
+&G????A?G@WHG
+&G?????OGOHKG
+&G?????_Oao@O
+&G????G?COEL?
+&G???O?OGAG[?
+&G???OA?C_GM?
+&G???@?Q?_KK?
+&G?????WA?cM?
+&G????G?OOCL_
+&G????A?GAG\?
+&G????G@?OA\?
+&G?????_H_`@O
+&G???CO?COCJ?
+&G???O?OG@WGG
+&G???C@?D?GWO
+&G???@@?D?HGO
+&G?G?C?OD?OE?
+&G?A?O?S@??[?
+&G?@?O_@@?OE?
+&G???@?WA?gK?
+&G????AGA?_N?
+&G???OA?CGAM?
+&G????_GA?C]?
+&G???O?P?OG[?
+&G???O_GA??]?
+&G?A?O?P?O?[?
+&G???@_GA?C[?
+&G?G?C@?P?OE?
+&G?AA?_G?@?[?
+&GOA?O_GA?OC?
+&G?GA?_G@?OE?
+&G?AA?_G?_GK?
+&G??????A?YN?
+&G?????@?AsM?
+&G??????G_oN?
+&G????G?G@oM?
+&G??????G_kK_
+&G?????a?AgL?
+&G?????S?AcM?
+&G???@?_E?WK?
+&G??????I?SM_
+&G?????c?@gL?
+&G????AG?GON?
+&G???O_C?O?]?
+&G?????G@O@]?
+&G????G?Q_o?W
+&G????OG?OC]?
+&G???@ACA?A[?
+&G?????_H?WH_
+&G???GAC@?AJ?
+&G???@?OI?KK?
+&G?@?O_G?O?U?
+&G?????_E?IL?
+&G???A?_E?aD?
+&G???OA?CO_M?
+&G?A?O?W?_?[?
+&G????@C@_@X?
+&G???GAC@?AY?
+&G???O?QA?G[?
+&G??a?_A@?GE?
+&G????@?O__L_
+&G???GACA??Z?
+&G????GA?__L_
+&G??@?OG@??Z?
+&G????AAA?A\?
+&G???G?SA?AY?
+&G????GG?_G\?
+&G???A_G@?SGG
+&G????_AB?B?o
+&G???O_G@?D@O
+&G????_AB?HAO
+&G???O_G@?SD?
+&G??????GGwL?
+&G?????_GOoM?
+&G?????OGOoM?
+&G???O?_G@oK?
+&G?????_GGgL?
+&G???O_?OOCM?
+&G???@A?CAgK?
+&G?AA?AA?_?[?
+&G?????_CGgL?
+&G???@A?GAgK?
+&G???O_?O@CM?
+&G?AA?A?C_?[?
+&G????@@B?g?W
+&G???O@?Q?@[?
+&G???O?OQ?@[?
+&G?GA?AC@?GE?
+&G???GAC?G@J?
+&G??@?O?P?OJ?
+&G?@?O_?OO?U?
+&G?GA?AGA??U?
+&G???O?_G@PG_
+&G?A?O?OO_GK?
+&G?A?O?OO@GK?
+&GOA?O_?Q?_A?
+&G???CA?P?@Y?
+&G???O_GA?QGG
+&G?G?CAC@?GE?
+&G?AA?AGA?OK?
+&G???GAC?A?Z?
+&G?@?O_?O@?U?
+&G??@?O?O@OJ?
+&G?GA?A?E??U?
+&G???CA?D?@Y?
+&G??Q?AC?_OE?
+&G???O?S@?OW_
+&G?AA?ACA?OK?
+&G???OACA?B?o
+&G???O_G@?`GO
+&G???OACA?aG_
+&G???O_G@?oK?
+&G???????OqMO
+&G?????@?@wK_
+&G?????@?AoM_
+&G????G?G@oL?
+&G?????A?AeKO
+&G?????a?AaL?
+&G????G?CAaL?
+&G???A?_E?PD?
+&G??????G_cKo
+&G????G?G@oH_
+&G????G?Q?@L_
+&G???GOG?G?Z?
+&G?????@?BgK_
+&G????O?E_@X?
+&G????GG?GA\?
+&G???C?SA?@W_
+&G?????_H?HH_
+&G???GA?P?AJ?
+&G???@?OH?KGO
+&G?@?OAG?O?U?
+&G????G?G@PH_
+&G???A?OH?DI?
+&G???GO?O@AJ?
+&G?@A?A?CO?U?
+&G????O?GBKG_
+&G???O@@@?CY?
+&G???O?Q@?GWO
+&G??_O_A@?GE?
+&G????G?GAOHo
+&G???A?c?@_B_
+&G????OC?_OHo
+&G??A?_C?@_B_
+&G????G?P?@X_
+&G???AACA?D?g
+&G????OA@?OX_
+&G???A_CA?EGG
+&G????GCAOB?o
+&G???OACA?D@O
+&G????GC@@OX?
+&G???OACA?cH?
+&G??????AAYF?
+&G??????R?DM?
+&G??????R?C]?
+&G????@?H_WGO
+&G??????QOHK_
+&G????AG?GIL?
+&G????@?E_PH?
+&G???C@?I?gCO
+&G??????QOG[_
+&G????@?F?GX?
+&G????AG?GG\?
+&G???C@?I?gCG
+&G?????D@_a?o
+&G????_@B?K@O
+&G????O@@_`@O
+&G???G@C@?BG_
+&G????@?P?HH_
+&G????OC@?WH_
+&G???C@?H?KGO
+&G???A_GA?EK?
+&G?????_EAID?
+&G???CGA?ASI?
+&G???O@@?AWGG
+&G?A?OAC@?CK?
+&G????O@?gc@O
+&G????OC@_OX?
+&G???O@A@?HGO
+&G???OAGA?cK?
+&G????@?P?GX_
+&G???C@?H?KGG
+&G????OC@?GX_
+&G???AOC@?EGG
+&G????G@AAQ@G
+&G???O@A@?HI?
+&G????OC@@GX?
+&G???OAGA?cD?
+&G????GCAOE@_
+&G????_AB?aG_
+&G????_CAGaA_
+&G????_CB?oI?
+&G??????A?UMO
+&G??????AAqF?
+&G?????C?@kK_
+&G??????QODM?
+&G?????C?AcM_
+&G??????PO_]?
+&G????_?G@WL?
+&G????@?J?WGO
+&G????_?GAON?
+&G????_@?OO]?
+&G??A?AC?G?]?
+&G???C@?E?O[?
+&G?????A?AMKO
+&G??????GaKK_
+&G?????a?AIL?
+&G????AA?GIL?
+&G????_?CAIL?
+&G????@?D_PH?
+&G???A?_E?`D?
+&G???C@?I?WGO
+&G??A?A?O@AM?
+&G???OA?CO_[?
+&G?G?OA?CO?[?
+&G?G?OAC@?CK?
+&G?????G?AKKo
+&G??????I@KK_
+&G????_?G@WH_
+&G????@?D__X?
+&G????_?O_@L_
+&G????AA?G_\?
+&G???G_C?G?Z?
+&G???C@?I?WCG
+&G????GG?_GL_
+&G????GA?__\?
+&G??A?OC@??Z?
+&G???AOC@?cGG
+&G?????G?BKK_
+&G?????H@_a?o
+&G????_?D_@X?
+&G????G@B?K@O
+&G????_A?GA\?
+&G????G@B?`@O
+&G???C?W@?@W_
+&G???G@G@?BG_
+&G????_A?_G\?
+&G????GAB?`AO
+&G???AOGA?SGG
+&G???O_C@?cD?
+&G??????CGkKO
+&G??????QOBM?
+&G?????_GO`M?
+&G????_@?OEM?
+&G????A?CAgL?
+&G????@?I_o@O
+&G???O?_G@gK?
+&G???C@?E?HK?
+&G???O?OGA_M?
+&G???@@?Q?G[?
+&G?A?@AG?G?[?
+&G?G@?AG?GOE?
+&G?????_GGHL?
+&G????AA?GBL?
+&G???OA?OOCM?
+&G????GA?_IL?
+&G???O?_G@WG_
+&G???C@?D?DI?
+&G?A?OAA?_?[?
+&G???A_GA?QH?
+&G?A?@A?O@AK?
+&G?G@?A?GGOE?
+&GOAA?A?Q?_?_
+&G?G?OAGA?CK?
+&G????@?G@WH_
+&G????@?J?K?g
+&G???@A?GAKK?
+&G???OA?COKK?
+&G???G@C?@AJ?
+&G???C?OP?CY?
+&G?@?C?OQ??U?
+&G?@@?AG?GOE?
+&G???GO?D?OJ?
+&G???@OC@?GX?
+&G?G?O?WA??U?
+&G?@@?_GA?OE?
+&G?????P@_@W_
+&G????G@B?D@_
+&G???OAA?_G[?
+&G????_G@_`H?
+&G???O?OP?@Y?
+&G???G@CA?I?o
+&G?@A?AC@?GE?
+&G???O_C@?SC_
+&G???O?gA?WGG
+&G???OOGA?KH?
+&G?A?OOGA?OK?
+&G??A?_C@?gK?
+&G??????A?UMG
+&G???????OeMG
+&G?????G?@[KG
+&G?????@?AcMG
+&G?????C?AcMG
+&G?????A?@kKG
+&G????O?G@gKG
+&G????G?G@gKG
+&G????_@?OON?
+&G????O?GA_]?
+&G??A?OA?_?]?
+&G???A?_E?O[?
+&G??????G_K[_
+&G??????G_KKg
+&G?????a?AG\?
+&G????G@?_CL_
+&G?????W?AKKG
+&G?????c?@WHG
+&G???A?OE?SGG
+&G??@?GC?@GJ?
+&G???O?Q?__M?
+&G???@?_I?G[?
+&G?A?@_C@??[?
+&G?G@?_?C@OE?
+&G??????I?KKg
+&G??????I?K[_
+&G?????g?@WHG
+&G?????Q?AKKG
+&G????G@?O_L_
+&G?????g?AG\?
+&G??@?GG?@GJ?
+&G???A?OE?cCG
+&G????_GA?ON?
+&G???O?P?O_M?
+&G??A?_G@??]?
+&G?A?@_A?_?[?
+&G?????G?o@[O
+&G?????A?o@[O
+&G????_?H_`?W
+&G????GA?OC\?
+&G????GG?OC\?
+&G????O?H_`?W
+&G???G?SA?AW_
+&G???G?S@?AW_
+&G????_G@?_]?
+&G???@GAA?G[?
+&G???@_G@?_[?
+&G?G@?_C?_GE?
+&G??????CGkKG
+&G??????GGcMG
+&G?????_GO_]?
+&G????_?OOCN?
+&G?????OGOgKG
+&G?????_COgKG
+&G???O?_G@_[?
+&G??A?AA?_?]?
+&G??A?A?C_GM?
+&G???O?OGA_[?
+&G?G?O?S@??[?
+&G?G?OOC?@?[?
+&G?????_GGG\?
+&G????G@?O@L_
+&G???O?OOOCM?
+&G????_?Q?_N?
+&G???O?OG@PGG
+&G??@?G?G@GJ?
+&G?A?@AA?_?[?
+&G??A?AGA??]?
+&G?A?@A?D?OK?
+&G?G@??_C@OE?
+&GOAA?AGA?OC?
+&G?G?O_G?@?[?
+&G?????_CGWHG
+&G?????_COIKG
+&G???@A?GAG[?
+&G???O?OO_GM?
+&G??@?G?O@GJ?
+&G???O?_C@QGG
+&G?G@?A?C@OE?
+&G?A?@AC@??[?
+&G??A?A?E?_M?
+&G?A?@A?C_GK?
+&G?G?O?WA??[?
+&GOAA?AGA?GA?
+&G?????`@_`?W
+&G????G@?GC\?
+&G???@AA?_G[?
+&G????_G?O_]?
+&G???O?OP?@WO
+&G???O@?D?@WO
+&G?G@?AA@?GE?
+&G???@AGA?_[?
+&G???O?WA?_[?
+&G?G@?AC?_GE?
+&G?G?OOGA?OK?
+&G?G?O_G@?OK?
+&G???????_eKW
+&G???????ObMG
+&G?????@?@wGg
+&G?????@?AaMG
+&G?????@?AgKg
+&G?????@?Ag[_
+&G????O?G@gHG
+&G????G?G@cKG
+&G????GG?GAL_
+&G????G?GA_\?
+&G??A?O?C_GJ?
+&G???A?OE?PCG
+&G?????C?@LGg
+&G??????G_DKg
+&G?????a?AA\?
+&G????A?O_AL_
+&G????O?CAIHG
+&G?????a?@QHG
+&G???A?_D?@Y?
+&G???GGC?@GJ?
+&G??@?A?COCJ?
+&G???@?_H?GWO
+&G?@A??OD?OE?
+&G?@@?_?C@OE?
+&G?????@?AWGw
+&G?????@?AWWo
+&G????G?G@o@g
+&G????G?CAEKG
+&G????OA?OCHo
+&G????G?GAOX_
+&G???OOG?O?R_
+&G???@?_D?HGG
+&G????GGA?_L_
+&G???GO?CGAJ?
+&G??A?OGA??Z?
+&G?G?GA?CG?U?
+&G?????C?o@Wo
+&G?????A?W@[O
+&G????G?F?@PO
+&G????AA?OC\?
+&G????GC?OCX_
+&G????G?P@@X?
+&G???@ACA?AOo
+&G???CG?D?GY?
+&G????GGA?_\?
+&G???@GA@?GWO
+&G???AOGA?cGG
+&G?@@?_C?_GE?
+&G??????AAQV?
+&G??????AGDMO
+&G??????Q@DM?
+&G?????G?GEM_
+&G??????QOG[O
+&G??????EOHKO
+&G?????_R?`AG
+&G????_@?@KL?
+&G????_@?OG\?
+&G?????_J?`AO
+&G???C@?I?`CG
+&G???C?_I?`CO
+&G??????OPHK_
+&G??????O_DKo
+&G????A?CGIL?
+&G?????GA?cM_
+&G????@?C`PH?
+&G????G@?@SH_
+&G???GA?GAWG_
+&G????_G?@gL?
+&G???O@@?ASGG
+&G???C?_H?HGO
+&G?A?OOC?_GK?
+&G???A?gA?aK?
+&G??????OoOWo
+&G??????CWHKO
+&G????@?D__PO
+&G????A?COKL?
+&G????G@?OOX_
+&G????@?O`OX?
+&G???C@?H?HGG
+&G???OA?GASH?
+&G????_GA?G\?
+&G???C@?OAWGG
+&G???AOC@?SGG
+&G?A?OOC?OCK?
+&G?????E?W`?o
+&G?????@?HIK_
+&G????@@B?K@O
+&G?????GAO_]?
+&G????G@AAS@G
+&G????O?Ooc@O
+&G???CG?P?HI?
+&G????_?Q_oGO
+&G????_GB?`AO
+&G???CGA@?HGO
+&G???O_GA?cD?
+&G???GAGA?aK?
+&G??????A?MKW
+&G???????OFMG
+&G??????AAaV?
+&G???????WDMO
+&G?????G?@[Gg
+&G?????@?AEMG
+&G??????OPDM?
+&G?????@?GEM_
+&G?????G?AKKg
+&G?????G?AK[_
+&G??????Oo_[O
+&G??????CoHKO
+&G????_?G@WHG
+&G????G?G@KKG
+&G?????_R?HAG
+&G????G@?@KL?
+&G????GG?OCL_
+&G????_?GAG\?
+&G????G@?O_\?
+&G?????_J?HGO
+&G??A?O?COCJ?
+&G???A?OE?`CG
+&G???C@?I?PCG
+&G???C?_I?PGO
+&G????_C@?ON?
+&G??A?A?CGAM?
+&G????OC@?_]?
+&G???O?P?O_[?
+&G??A?OC@??]?
+&G?G?O?P?O?[?
+&G???@OC@?_[?
+&G?G?OOC?OCK?
+&G??????CG[GW
+&G??????GGDMG
+&G??????OPBM?
+&G?????@?GBM_
+&G?????_GO@]?
+&G????A?OOCN?
+&G?????P?OEM?
+&G?????GA?aN?
+&G????A?CAWHG
+&G?????_COHKG
+&G????@?Gao@O
+&G????G@?@EL?
+&G???O?_G@G[?
+&G???OAA?_?]?
+&G???O?P?@KK?
+&G????_G?@cM?
+&G??@?A?C_GJ?
+&G???O?_C@WGG
+&G???@@?P?GWO
+&G???C?OD?HGO
+&G?@A??OC_GE?
+&G?A?OOC?@?[?
+&G??`?AG?GOE?
+&G???@?WA?aK?
+&G???O?WA?_M?
+&G?A?@A?CGAK?
+&G???@_GA?G[?
+&G?G@??_GAOE?
+&G?A?@_GA??[?
+&GOAA?AGA?A?_
+&G?G@?_GA?OE?
+&G?G?O_G?OCK?
+&G??????A?bN?
+&G??????AG`N?
+&G?????G?AkK_
+&G??????EO`M?
+&G????_?GAgL?
+&G?????_I_oGO
+&G??A?AG?GAM?
+&G???C@?Q?_[?
+&G?????G?AaN?
+&G?????G?GaN?
+&G????_?G@cM?
+&G????_?COcM?
+&G???A?OE?`K?
+&G???C?OE?`K?
+&G?G?O_@?O?[?
+&G?G?O_C?OCK?
+&G??????GG[Go
+&G??????CWBM?
+&G?????`?AWH_
+&G????@?R?K@G
+&G???CG?P?@J?
+&G???C@?P?GY?
+&G??@?GC@?OJ?
+&G??@?OC@?GY?
+&G?????OGODM?
+&G?????P?GEM?
+&G???O?OG@KK?
+&G???O?Q?@KK?
+&G??`?AG?G?U?
+&G??`?AG?GGE?
+&G?G@?_GA??U?
+&G?G@?_GA?GE?
+&G??????GGDM_
+&G??????OOBM_
+&G?????`?@IL?
+&G????AA?@EL?
+&G???O?_C@WH?
+&G???C?OD?HI?
+&G?A?@AA?GAK?
+&G?G@??_GAGE?
+&G????A?OOAN?
+&G?????@?OEM_
+&G???OAA?O?]?
+&G????GA?@KL?
+&G?A?OOA?@?[?
+&G???A?gA?QG_
+&GOAA?AG@?A?_
+&G?G?OOG?OCK?
+&G??????OBEM?
+&G?????@?HBM?
+&G?????_P_@X?
+&G????G?R?D@G
+&G???A@?P?@Y?
+&G???C@CA?AOo
+&G???AOC@?OY?
+&G??@?_GA?GY?
+&G?????`?GA]?
+&G?????@?PDM?
+&G???O?a?@G[?
+&G????G?R?HAG
+&G?G?O?S@?GE?
+&G???GACA?_W_
+&G?A?@_GA?OK?
+&G??A?OC@?_[?
+&G???????OFMO
+&G??????OAEM_
+&G?????G?AMK_
+&G????A?G@KL?
+&G????_?GAKL?
+&G???O?_C@WI?
+&G??A?AA?GAM?
+&G?A?@AC?GAK?
+&G?????@?AEM_
+&G????A?OO@N?
+&G????G?G@KL?
+&G???OAA?G?]?
+&G???A?_E?PGO
+&G?A?OO@?@?[?
+&G?G?OO@?O?[?
+&GOAA?AG?_A?_
+&G??????AAMKO
+&G??????OQA]?
+&G??????IAKKO
+&G?????_P__PO
+&G????G@?OcKG
+&G???@@?P?HGG
+&G????GA?_gKG
+&G???A_GA?OY?
+&G??????OQC]?
+&G?????`?OA]?
+&G?????_R?GQO
+&G???O?`?@G[?
+&G???C@?E?PCG
+&G?@A??P?_GE?
+&G???AOC@?_[?
+&G?A?@_GA?GK?
+&G???????QEMO
+&G?????@?GBMG
+&G??????CaKKO
+&G????G?CODKG
+&G?????_J?GWO
+&G???C?OD?HGG
+&G???O?`?O_[?
+&G?G@?A?CGAE?
+&G?????@?GEMG
+&G?????@?OEMG
+&G????G?COKKG
+&G????GA?@KKG
+&G???C?OE?`CG
+&G???A?gA?OW_
+&G?G?O?S?OCK?
+&G?G?O?W?OCK?
+&G??????B?MGW
+&G?????@?Gw?w
+&G??????OooGW
+&G????G@?Ao@g
+&G????O@?OgHG
+&G???OOG?GAB_
+&G????OC@?gKG
+&G??@?GGA?_J?
+&G?????G?G[Gg
+&G?????GA?[Gg
+&G????_@?AWHG
+&G????_G?AWHG
+&G??A?OA?OCJ?
+&G??A?OG?OCJ?
+&G??A?OC@?GM?
+&G??A?_C@?OM?
+&G???????GbN?
+&G??????AGBN?
+&G?????C?AkK_
+&G??????EODM?
+&G????_?GAWL?
+&G?????_J?WGO
+&G??A?AC?GAM?
+&G???C@?Q?O[?
+&G?????G?A[Go
+&G??????CWDM?
+&G????_?GAWH_
+&G????@?P__X?
+&G???G_C?GAJ?
+&G???C@?Q?WCG
+&G??A?OC@?OJ?
+&G??@?OC@?gGG
+&G??????GODM_
+&G??????OODM_
+&G?????a?@IL?
+&G????AA?@IL?
+&G???A?_E?QGO
+&G???C?_I?WGO
+&G?G?OA?COCK?
+&G?G?OAC?OCK?
+&G?????@?W@]?
+&G?????@?WA]?
+&G????_?P_@X?
+&G????G?R?K@O
+&G???C@G@?@W_
+&G???C@G@?BG_
+&G??A?_G@?PGG
+&G??A?_G@?`CO
+&G??????GG`N?
+&G?????G?GBN?
+&G?????_CO`M?
+&G????_?CODM?
+&G???O?_C@gK?
+&G???C?OE?HK?
+&G?A?@AG?GAK?
+&G?G@?AG?GAE?
+&G?????_COBM?
+&G?????P?GBM?
+&G???@A?G@KK?
+&G???OA?C@KK?
+&G?@?C?OQ?@E?
+&G?@@?AG?GAE?
+&G?G?O?WA?_E?
+&G?@@?_GA?_E?
+&G????A?OAAN?
+&G?????@?ODM_
+&G???OA?OO?]?
+&G????GA?@IL?
+&G?A?OAA?@?[?
+&G???A?gA?PG_
+&GOAA?A?Q?A?_
+&G?G?OAG?OCK?
+&G????A?OOC]?
+&G?????@?WC]?
+&G???OAA?@G[?
+&G????_?P_`H?
+&G?@A?AC?_GE?
+&G???GAG@?QCO
+&G?A?OOGA?_K?
+&G??A?OC@?gK?
+&G??????AGaN?
+&G??????EOcM?
+&G????@?R?gI?
+&G???C@?Q?oK?
+&G?????G?G`N?
+&G????_?CO`M?
+&G???C?OE?gK?
+&G?AA?AG?GAK?
+&G?????GA?BN?
+&G????_G?@EM?
+&G???@?WA?BK?
+&G?GA?AG?GAE?
+&G??????CWEM?
+&G????@?R?KB?
+&G???C@?Q?WE?
+&G??A?_GA?WE?
+&G?????OOOEM?
+&G???@AA?@KK?
+&G??_AAG?GOE?
+&G?G?A_GA?OE?
+&G?????P?OBM?
+&G???GA?C@KK?
+&G?@?OAG?GAE?
+&G?@?O_GA?_E?
+&G??????OOEM_
+&G????AA?@KL?
+&G???C?_I?WI?
+&G?AA?AC?GAK?
+&G?????@?OBM_
+&G????GA?@EL?
+&G???@?S@?BG_
+&G?GA??_GAOE?
+&G????A?OACN?
+&G???OA?O_?]?
+&G?A?OAC?@?[?
+&GOA?O_?Q?@?O
+&G?????@?GDM_
+&G????G@?@IL?
+&G???C?_I?PI?
+&G?AA?AA?GAK?
+&G?????@?HDM?
+&G????_?P__PO
+&G???GACA?BGG
+&G??A?OC@?WGG
+&G?????@?PBM?
+&G????G?Gao@O
+&G???GACA?@W_
+&G??A?OC@?G[?
+&G?????_OOA]?
+&G???OA?G@G[?
+&G?@A?A?C_GE?
+&G?A?O?WA?_K?
+&G??????OPEM?
+&G?????_P_`H?
+&G???C@?I?PC_
+&G???@OC@?gK?
+&G?????@?OBMG
+&G????GA?@EKG
+&G???@?S@?BGG
+&G?GA?A?CGAE?
+&G?????@?GDMG
+&G????G?COHKG
+&G???C?OE?gCG
+&G?AA?A?CGAK?
+&G???????WEMO
+&G??????CoKKO
+&G?????OD_WGO
+&G???C@?OAoK?
+&G?????@?Ow?w
+&G????GA?Ao@g
+&G??A?_C?GAB_
+&G??@?OGA?_J?
+&G?????G?G[GW
+&G????AG?AWHG
+&G??@?AG?_GJ?
+&G???O_C@?OM?
+&G??????B?MKG
+&G??????OooKO
+&G????G@?OoL?
+&G????GA?_oM?
+&G??????B?aN?
+&G??????F?cM?
+&G????@?R?oI?
+&G?????G?GoN?
+&G????_?COoM?
+&G???C?_I?oK?
+&G??????EOaM?
+&G????@?Q_oH?
+&G???C@?Q?gK?
+&G????_?COaM?
+&G???@@?E?gK?
+&G?AA?AG?_GK?
+&G??????Q?cM_
+&G????AG?@gL?
+&G???C?_I?gK?
+&G????AGA?@N?
+&G???O_?Q??]?
+&G?AA?AG?@?[?
+&G?????GAOA]?
+&G????_?Q_o@O
+&G???GAGA?BK?
+&G????_G?OA]?
+&G???@AGA?@[?
+&G?GA?_@@?OE?
+&G??????EGEM?
+&G????@?R?cB?
+&G???C@?Q?gE?
+&G?????P?GcM?
+&G???@AA?@gK?
+&G?AA?AC?_GK?
+&G????@?R?K@_
+&G???C@?P?KI?
+&G??@?OC@?KI?
+&G???@?Q?GKK?
+&G?@?O_@?AOE?
+&G?GA?_G?AOE?
+&G????A?O@HL?
+&G???OA?GAWG_
+&G?A?OAC?_GK?
+&G???OA?CG@M?
+&G?A?O?OOO?[?
+&GOA?O_?Q?OC?
+&G????@@B?K?o
+&G???CG?P?DI?
+&G???O_GA?gD?
+&G???O?P?GG[?
+&G?G?CA?P?OE?
+&G?AA?AAA?_K?
+&G??????OOaM_
+&G????AA?@cL?
+&G???C?_I?WE?
+&G?????@?OaM_
+&G????GA?@cL?
+&G???A?gA?QC_
+&G????AA?@DL?
+&G???C?OD?KI?
+&G?@?A_?GAOE?
+&G????G?C_EL?
+&G???@?S@?IG_
+&G?G?A_?GAOE?
+&G????@?G_CL_
+&G???G?c?@GJ?
+&G?@?A_?C@OE?
+&G????G?OOGL_
+&G??@??c?@GJ?
+&G?G?A_?C@OE?
+&G????AA?O@\?
+&G???CG?D?CY?
+&G?@?OAG@?OE?
+&G????G@?_A\?
+&G???G?S@?GW_
+&G?@?O_G@?OE?
+&G?????@?H`M?
+&G????G?R?_PO
+&G???GAG@?BGG
+&G?????@?P`M?
+&G????G?R?_QO
+&G???GACA?OW_
+&G????@AB?B@G
+&G???GACA?GOo
+&G??@?_GA?CY?
+&G?????a?ao@O
+&G???GACA?GW_
+&G??A?_G@?G[?
+&G????A?G_@\?
+&G???O?_D?@Y?
+&G?@A?A?D?OE?
+&G????A?G_G\?
+&G???O?OI?WGG
+&G?A?O?W@?OK?
+&G????G?J?D?o
+&G???@ACA?I?o
+&G???AOGA?cI?
+&G?????g@_`@O
+&G???@ACA?IG_
+&G???@_G@?gK?
+&G??????Q?EM_
+&G????AG?@KL?
+&G???C?_I?gE?
+&G????AG?O@N?
+&G???O_?O_?]?
+&G?AA?AC?@?[?
+&G????A?O@KL?
+&G???OA?GAWI?
+&G?A?OAC?GAK?
+&G???OA?C_@M?
+&G?A?O?OP??[?
+&GOA?O_?Q?C@?
+&G?????@?OIKo
+&G????GA?@SH_
+&G???A?c@?BG_
+&G????GA?O@L_
+&G??@?O?G@GJ?
+&G?GA??_C@OE?
+&G?????A?`EK_
+&G????_?IAKD?
+&G???O@@A?cCO
+&G????G@?GG\?
+&G???O@?I?PGG
+&G?AA?AA@?OK?
+&G?????G?HDM?
+&G????O?P__PO
+&G???GAC@?BGG
+&G?????g?OA]?
+&G???O?_E?@[?
+&G?GA?A?D?OE?
+&G????@@@__Oo
+&G???O@?P?HGG
+&G???O_GA?gCG
+&G???O?OOAG[?
+&G?G?CA?D?OE?
+&G?AA?A?E?_K?
+&G?????A?`DK_
+&G????G?C`PH?
+&G???O@@A?cCG
+&G????G?GGG\?
+&G???O?OI?PGG
+&G?AA?A?D?OK?
+&G?????K?aE@_
+&G????G@AASD?
+&G????OC@_WGO
+&G?????`B?HAO
+&G???G@?I?PCO
+&G???O?gA?oK?
+&G?????G?OBMG
+&G????_A?@EKG
+&G???@?W@?BGG
+&G?????G?OEMG
+&G????_A?@KKG
+&G???A?cA?OW_
+&G?????Q?OBKG
+&G???O?OD?HGG
+&G?@A?A?CGAE?
+&G?????Q?OHKG
+&G???O?OE?gCG
+&G?A?O?W?OCK?
+&G?????@?_DKg
+&G????OA?@QHG
+&G???A?cA?@W_
+&G?????@?_KKg
+&G????OA?@WHG
+&G???A?cA?A[?
+&G?????@?gG[O
+&G????G?P@`H?
+&G???GA?I?PC_
+&G?????@?oG[O
+&G????O?J?HGG
+&G???@GAA?WK?
+&G?????G?Ow?w
+&G????_A?Ao@g
+&G??A?_C?_GB_
+&G?????CA?[Gg
+&G????OG?AWHG
+&G??@?OG?_GJ?
+&G????G?OAo@g
+&G???COG?OCB_
+&G???GOGA?_J?
+&G????A?I?WHG
+&G???COG?OCJ?
+&G???O_GA?OM?
+&G?????CA?LGg
+&G????OG?AIHG
+&G??@?AG?OCJ?
+&G?????@?_K[_
+&G????_C?AKKG
+&G???O_C?_GM?
+&G?????C?o`Go
+&G????GC?OcH_
+&G????GGA?oL?
+&G?????C?o`KO
+&G????GC?OcL?
+&G????_G?_oM?
+&G??????AGQN?
+&G??????EOSM?
+&G????@?R?gE?
+&G??????EOEM?
+&G????@?P_oH?
+&G???C@?Q?WK?
+&G??????OOcM_
+&G????AA?@gL?
+&G???C?_I?WK?
+&G?????@AOA]?
+&G????O?Q_o@O
+&G???GAG@?BK?
+&G????@?R?KA_
+&G???C@?Q?WD?
+&G??A?_GA?WD?
+&G????AA?@HL?
+&G???C?_I?WH?
+&G?A?OAG?_GK?
+&G????G?R?I@O
+&G???GACA?BI?
+&G??A?_G@?`E?
+&G????@?G_GL_
+&G???G@C@??Z?
+&G?@?G_G?@?U?
+&G????AA?_@\?
+&G???C?S@?AY?
+&G?@A?AG@?OE?
+&G????GAB?D?o
+&G???O_C@?E@O
+&G??A?_C@?aGO
+&G?????C?G`N?
+&G????O?CO`M?
+&G???C?OE?WK?
+&G?????OOOaM?
+&G???OA?C@gK?
+&G?A?OAG?GAK?
+&G?????@?O`M_
+&G????GA?@aL?
+&G???A?gA?PC_
+&G?????@AGC]?
+&G????O?Q_PH?
+&G???GAG@?`C_
+&G????_?COBM?
+&G???C?OE?KK?
+&G?@?C_?Q?@E?
+&G???@@?CGKK?
+&G?@?CA?Q?@E?
+&G?@A?AGA?_E?
+&G????GA?@BL?
+&G???@?S@?HG_
+&G?@A?AG?OCE?
+&G????_?P_`@_
+&G???GACA?HG_
+&G??A?OGA?KK?
+&G????A?OA_N?
+&G???OA?Q??]?
+&G?A?OAG?@?[?
+&G???OA?OA?]?
+&G?A?OA?O@?[?
+&GOA?OA?OAOC?
+&G????G?G_@L_
+&G???GO?P??Z?
+&G?@A?AG?@?U?
+&G????A?O_G\?
+&G???O@?I?WGG
+&G?A?OAG@?OK?
+&G????_?OOA]?
+&G???O@?E?G[?
+&G?@A?AG?_GE?
+&G???OA?O@G[?
+&G?G?OA?P?OE?
+&G?A?OAGA?_K?
+&G????GA?G@\?
+&G???C?S@?GW_
+&G?@?G_G@?OE?
+&G????_@@_`?o
+&G???CACA?IG_
+&G???O_C@?WK?
+&G?????G@?BN?
+&G????_C?@EM?
+&G???@?W@?BK?
+&G?????W?OBM?
+&G???O?OE?HK?
+&G?@A?AG?GAE?
+&G?????@A?DM_
+&G????GG?@IL?
+&G???A?g@?`C_
+&G?????G?WC]?
+&G????O?P_`H?
+&G???GAGA?QCO
+&G???G@?C@KK?
+&G?@?CAG?GAE?
+&G?@?G_GA?_E?
+&G????G?CGHL?
+&G???O?_I?PI?
+&G?A?OAG?OCK?
+&G????@@@_`G_
+&G???O@?Q?WCO
+&G???O_GA?WK?
+&G?????A?OKKo
+&G????OA?@WH_
+&G???A?g@?BK?
+&G?????A?PKK_
+&G????O?D_GX?
+&G???CGAA?WK?
+&G?????K?o`CO
+&G????G@B?cD?
+&G????_GB?gE?
+&G??????AGcMO
+&G??????B?eIG
+&G??????EOgKO
+&G??????QOgKO
+&G?????OE_oGO
+&G????_@?OgL?
+&G?????G?GcMG
+&G?????G?GkKG
+&G????_?COgKG
+&G????_?GOgKG
+&G???C?_I?_[?
+&G??A?AG?_GM?
+&G?????G?GcM_
+&G??????Q@cM?
+&G????_@?@gL?
+&G????@?E_oGO
+&G???C?_I?`K?
+&G???C@?I?`K?
+&G????_?Q?CN?
+&G????_?GO_]?
+&G??A?AG?_?]?
+&G???C?_E?_[?
+&G?G?O_C?@?[?
+&G?G?O_C@??[?
+&G??????CWIKO
+&G??????OoQGo
+&G????@?QAKD?
+&G????G@?OQH_
+&G???C@?OAWI?
+&G????_GA?KL?
+&G?????P?GKKG
+&G?????`?GWHG
+&G???OA?C@QGG
+&G??@?G?OOGJ?
+&G?A?@AC?_GK?
+&G??A?AAA?_M?
+&G????A?COIL?
+&G????@?J?DB?
+&G???OA?GASG_
+&G???C@?H?HI?
+&G?A?OOA?_CK?
+&G???AOC@?SH?
+&G???O?OOOGM?
+&G???@AA?AG[?
+&G?A?@AA@??[?
+&G?G@??OO_OE?
+&GOAA?AG@?OA?
+&G?G?OOGA??[?
+&G??????O_EKg
+&G?????C?GLGW
+&G????AA?@SHG
+&G????AA?ASHG
+&G???C?_H?GY?
+&G???GGC?OCJ?
+&G?????A?_EKg
+&G?????C@?MGg
+&G????OC?@KHG
+&G????OC?AKHG
+&G???A?c@?AW_
+&G??@?GC?OCJ?
+&G????A?O_CL_
+&G????AA?AC\?
+&G???GGC?@CJ?
+&G???C?_D?GY?
+&G?@@?_?C@GE?
+&G?@@?_?C_GE?
+&G????G@?_AL_
+&G????GA?AC\?
+&G??@?GC?@CJ?
+&G???A?S@?AW_
+&G?G@?_?C@GE?
+&G?G@?_?C_GE?
+&G?????A?QA[O
+&G?????C?oBGW
+&G????G?PA_PO
+&G????OA?OEHG
+&G???@GA@?HGG
+&G????GGA?cKG
+&G?????A?QG[O
+&G?????C?oPGW
+&G????O?QAGSO
+&G????OA?OKHG
+&G???GA?E?aCG
+&G????_G?_gKG
+&G?????a?OA\?
+&G????G?J?@PO
+&G???AG?D?@Y?
+&G???AACA?AOo
+&G?@A??P@?OE?
+&G???AOGA?_X?
+&G?????a?OG\?
+&G????_?D_`?W
+&G???O?OI?SGG
+&G???G?cA?AW_
+&G?A?@_C@?GK?
+&G???A_G@?_[?
+&G??????O_EKo
+&G??????OPIK_
+&G????AA?@SH_
+&G????@?IAKD?
+&G???C?_H?HI?
+&G???O@@?ASGO
+&G????G@?G@L_
+&G?????`?GG\?
+&G??@?G?G@CJ?
+&G???OA?CAQGG
+&G?G@??_C@GE?
+&G?A?@AA@?OK?
+&G?????GA?EM_
+&G????A?CGKL?
+&G????_G?@KL?
+&G???GA?GAgE?
+&G???A?gA?aC_
+&G?A?OOA?OCK?
+&G????_?OO_N?
+&G???O?OO_CM?
+&G??A?AAA??]?
+&G?A?@AC?_?[?
+&G?G?OOG?@?[?
+&GOAA?AG@?GA?
+&G?????@?HHK_
+&G?????E?W_Oo
+&G????G?EACT?
+&G????G@AACT?
+&G???CGA@?HGG
+&G????_GB?`AG
+&G????G?GGC\?
+&G?????P@_`?W
+&G???O?_D?@WO
+&G???O?_P?@WO
+&G?G@?A?C_GE?
+&G???O?gA?_[?
+&G?????GA@DM?
+&G????@@@__PO
+&G????_?R?`AG
+&G???CG?P?HGG
+&G???GAGA?OW_
+&G???O_GA?cCG
+&G?????g?O_]?
+&G???@A?G_G[?
+&G???O?_E?_[?
+&G?G@?A?D?GE?
+&G?G?O?W@?OK?
+&G?G?O?WA?OK?
+&G?????@?_BKg
+&G?????@?IG[O
+&G????OA?@EHG
+&G????G?HA_PO
+&G???A?cA?AOo
+&G???AGA@?@Y?
+&G?????@?_IKg
+&G?????@?QG[O
+&G????OA?@KHG
+&G????G?QAGSO
+&G???A?cA?AW_
+&G???GA?E?QGG
+&G?????@A?aMG
+&G?????Q?OEKG
+&G????GG?@cKG
+&G???@G?D?HGG
+&G???A?cA?_W_
+&G??a?A?CGOE?
+&G?????G?OcMG
+&G?????Q?OKKG
+&G????_A?@gKG
+&G???O?OE?cCG
+&G???A?g@?_[?
+&G?A?@_C?_GK?
+&G?????@?_q?w
+&G?????G?oP?w
+&G????GC?Ac@g
+&G????OG?OK@g
+&G???OOG?_GB_
+&G????OGA?gHG
+&G?????CA?MGg
+&G?????G?oPGW
+&G????OG?AKHG
+&G????OG?OKHG
+&G??@?GG?OCJ?
+&G????_G@?gKG
+&G?????@A?wGg
+&G?????g?OW@g
+&G????OG?AgHG
+&G???OOG?_CB_
+&G??A?OG?_GJ?
+&G??A?OGA?GJ?
+&G?????G@?kKG
+&G?????g?OWHG
+&G????_C?AgKG
+&G??@?GG?_CJ?
+&G??A?_C?_GM?
+&G??A?_G@?GM?
+&G??????AOEMO
+&G??????B?MIG
+&G??????E_KKO
+&G??????POgKO
+&G?????OF?WGO
+&G????_@?OWL?
+&G?????@?GcMG
+&G?????G?G[KG
+&G????G?COgKG
+&G????O?GOgKG
+&G???C?_I?O[?
+&G??A?AC?_GM?
+&G??????CgKKO
+&G??????OooGo
+&G????@?O`oH?
+&G????G@?OoH_
+&G???O?`?OgK?
+&G????_GA?WL?
+&G????G?COIKG
+&G?????g?GWHG
+&G???C?OE?cCG
+&G??@?GG?GGJ?
+&G?A?@AG?_GK?
+&G??A?ACA?_M?
+&G??????O_KKo
+&G??????O`KK_
+&G????O@?@WH_
+&G????@?D@WH?
+&G???C?_I?HK?
+&G???O?a?_gK?
+&G????G@?_@L_
+&G?????a?GG\?
+&G??@?G?P??Z?
+&G???C?_E?QGG
+&G?G@?AG?@?U?
+&G?A?@AG@?OK?
+&G?????A?HKK_
+&G?????BB?a?g
+&G????_?J?K@G
+&G????G@B?c@G
+&G???CGAA?HK?
+&G????_GB?WGO
+&G????GA?GC\?
+&G????_@@_`?W
+&G???C?S@?AW_
+&G???G@CA?AW_
+&G?G@?_@?_GE?
+&G???O_C@?O[?
+&G?????@?G`MG
+&G?????@?GwGW
+&G????G?CO`KG
+&G????AA?AoHG
+&G???C?OE?WCG
+&G??A?AC?_GJ?
+&G?????@?OaMG
+&G?????C@?kGg
+&G????GA?@cKG
+&G????OC?AgHG
+&G???A?c@?_W_
+&G??A?OC?_GJ?
+&G????G?COBKG
+&G????@?I?W@g
+&G???C?OD?KGG
+&G???G?c?G_B_
+&G?@?C_?O@@E?
+&G???G_CA?_J?
+&G????G?C_EKG
+&G????_?I?W@g
+&G???@?S@?IGG
+&G???OOG?O_B_
+&G?G?GA?E?AE?
+&G??A?OGA?OJ?
+&G????A?G_@L_
+&G?????a?G@\?
+&G???GG?P??Z?
+&G???A@?D?CY?
+&G?@@?AG?@?U?
+&G?@?G_?C_GE?
+&G????A?O_GL_
+&G?????a?_A\?
+&G???GGC@??Z?
+&G???A?S@?AY?
+&G?@@?_G?@?U?
+&G?@A??W@?OE?
+&G????A?O_C\?
+&G????G@B?@Oo
+&G???O@?D?GY?
+&G???G@CA?E?g
+&G?@@?AG?_GE?
+&G???O_C@?WCG
+&G????AA?_C\?
+&G????_G@_@PO
+&G???G?S@?GY?
+&G???O_C@?E@G
+&G?@@?_G?_GE?
+&G??A?_C@?aGG
+&G?????G?GDM_
+&G??????Q@EM?
+&G????_@?@IL?
+&G?????_P_PH?
+&G???C?_I?`E?
+&G???C@?I?`C_
+&G????_?OOAN?
+&G?????`?G_]?
+&G??A?A?O_?]?
+&G???OA?G@_[?
+&G?G?OAC?@?[?
+&G?G?OA?D?OK?
+&G????A?COHL?
+&G????@?J?DA_
+&G???OA?GASI?
+&G???A@?P?DI?
+&G?A?OAA?GAK?
+&G???AOC@?SI?
+&G???O?OO_AM?
+&G???@A?OAG[?
+&G?A?@A?P??[?
+&G?G@?A?O@OE?
+&GOAA?A?Q?GA?
+&G?G?OA?E?_K?
+&G?????GA?DM_
+&G????A?CGHL?
+&G????_G?@IL?
+&G???GA?GAgD?
+&G???A?gA?`C_
+&G?A?OAA?OCK?
+&G????_?Q?AN?
+&G???O?OOOAM?
+&G??A?A?Q??]?
+&G?A?@A?O_?[?
+&G?G?OAG?@?[?
+&GOAA?A?Q?OC?
+&G?????GA@EM?
+&G????@@B?I@O
+&G????O?P_PH?
+&G???O@?P?DI?
+&G???GAGA?aCO
+&G???O_GA?cE?
+&G????_@?G_]?
+&G???@AA?OG[?
+&G???O@?E?_[?
+&G?G@?A?O_OE?
+&G?G?OAG@?OK?
+&G?G?OACA?_K?
+&G?????G?OBM_
+&G?????@A@BM?
+&G????_A?@EL?
+&G????G?IAo@O
+&G???@?W@?BG_
+&G???GAG@?@W_
+&G?????G?OEM_
+&G?????@A@DM?
+&G????_A?@KL?
+&G????G?R?`AG
+&G???A?g@?aC_
+&G???GAG@?OW_
+&G????A?C_DL?
+&G????G?R?B@G
+&G???O?OD?HI?
+&G???C@CA?H?g
+&G?@A??_GAOE?
+&G??A?OGA?CY?
+&G????A?C_KL?
+&G????@G@__PO
+&G???O?_I?WI?
+&G???GACA?IGG
+&G?A?OOG?OCK?
+&G??A?OC@?SGG
+&G?????G?O`M_
+&G????A?C_BL?
+&G????_A?@aL?
+&G???O?OD?DI?
+&G???A?g@?PC_
+&G??a?A?GGOE?
+&G?????G?OcM_
+&G????A?C_IL?
+&G????_A?@gL?
+&G???O?_I?WH?
+&G???A?g@?aK?
+&G?A?OOG?_GK?
+&G?????@AG_]?
+&G????@AB?D@_
+&G????G?R?`H?
+&G???GAG@?IAO
+&G???GAG@?aGO
+&G??A?OGA?KI?
+&G?????@AO_]?
+&G????G?R?I?o
+&G????O?Q_oGO
+&G???GACA?II?
+&G???GAG@?aK?
+&G??A?_G@?gE?
+&G???????WcMO
+&G??????B?UIG
+&G??????CogKO
+&G??????OogKO
+&G?????OD_oGO
+&G????G@?OgL?
+&G??????CoIKO
+&G??????OoaKO
+&G????@?OaoH?
+&G????G@?OaL?
+&G???O?P?OgK?
+&G????OC@?cM?
+&G??????O_KKg
+&G?????A?GK[O
+&G????AC?@WHG
+&G????_?GOHKG
+&G???C?_I?G[?
+&G???OAG?_GM?
+&G?????A?oA[O
+&G?????G?oBKO
+&G????_?Oao@O
+&G????GG?OEL?
+&G???@GAA?HK?
+&G????OGA?cM?
+&G?????@?GcM_
+&G??????OPcM?
+&G????G@?@gL?
+&G????@?D_oGO
+&G???C?_I?PK?
+&G???C@?I?PK?
+&G????G?COIL?
+&G?????_QAWH?
+&G???C?_I?PH?
+&G???C@?I?PE?
+&G?A?O_A?_CK?
+&G???@OC@?cK?
+&G????G?O_CL_
+&G????AA?AG\?
+&G??@?AC?@GJ?
+&G???C?_E?WGG
+&G?G?O_?C@OE?
+&G?A?O_C@??[?
+&G????GA?OA\?
+&G????_?H_`@O
+&G???G?S@?@W_
+&G???G?SA?BG_
+&G?@A?_@@?OE?
+&G???@OGA?cK?
+&G?????G?GDMG
+&G?????C?G[GW
+&G????_?COHKG
+&G????AC?AWHG
+&G???C?OE?WGG
+&G??@?AC?_GJ?
+&G?????OOOIKG
+&G????A?OAWHG
+&G???OA?C@WGG
+&G??@?A?O_GJ?
+&G?A?OA?CGAK?
+&G???OAGA?_M?
+&G?????A?_DKg
+&G?????C@?LGg
+&G????OC?@IHG
+&G????OC?AIHG
+&G???A?c@?@W_
+&G??@?AC?OCJ?
+&G?????A?WG[O
+&G?????C?oPGo
+&G????O?O`PH?
+&G????GC?OSH_
+&G???GA?I?PG_
+&G????GGA?gL?
+&G????A?Q?CN?
+&G????_?GO@]?
+&G???OAG?_?]?
+&G???C?_E?G[?
+&G?A?O_C?@?[?
+&G?@A?_?C_GE?
+&G???OA?O@GM?
+&G???OA?CAG[?
+&G?A?OA?D??[?
+&G?G?G?OP?OE?
+&GOA?OA?P?OA?
+&G?A?O_GA??[?
+&G????G?O_AL_
+&G????GA?AA\?
+&G???GOC?@GJ?
+&G???A?S@?@W_
+&G?@A?_?C@OE?
+&G?@A?_?D?OE?
+&G????AA?OG\?
+&G????_?D_`@O
+&G???O@?I?SGG
+&G???G?cA?BG_
+&G?A?O_C@?GK?
+&G???AOGA?cK?
+&G?????@?G`M_
+&G??????OPaM?
+&G????G@?@aL?
+&G?????_Q_PH?
+&G???C?_I?PE?
+&G???C@?I?PG_
+&G????G@?@BL?
+&G????@?H_`@_
+&G???C?OD?KGO
+&G???C?OP?KGO
+&G?@?GAG?OCE?
+&G???@_GA?KK?
+&G????G?GO@L_
+&G????A?OAG\?
+&G??@?A?G@GJ?
+&G???OA?CAWGG
+&G?G?O?_C@OE?
+&G?A?OA?D?OK?
+&G????G@?G@\?
+&G?????`@_`?o
+&G???O@?D?GWO
+&G???O?OP?HGO
+&G?@?G_@@?OE?
+&G???O?WA?gK?
+&G?????C@?aN?
+&G?????P?OaM?
+&G????OC?@cM?
+&G???O?P?@gK?
+&G???@?S@?aK?
+&G?A?O_A?OCK?
+&G????_?E?EM?
+&G???@A?CGKK?
+&G???@?WA?IK?
+&G?@?GAG?OAE?
+&G?G?GAGA?AE?
+&G?G?GAGA?_E?
+&G????A?Q?_N?
+&G???OA?O@@M?
+&G???OAGA??]?
+&G?A?OA?CG?[?
+&G?A?O_G?@?[?
+&GOA?OA?P?O?O
+&G????_G?O@]?
+&G???OA?CGG[?
+&G???@AGA?C[?
+&G?@A?@?O_GE?
+&G?@A?_G?_GE?
+&G?A?O_GA?CK?
+&G?????@A?BM_
+&G?????G?PBM?
+&G????GG?@EL?
+&G????_?Gao@O
+&G???@?SA?BG_
+&G???GAC@?@W_
+&G????G?CGDL?
+&G?????`?ao?o
+&G???O?OD?HGO
+&G???O@?P?GWO
+&G?G?O?_GAOE?
+&G???O_GA?G[?
+&G?????@?_IKo
+&G?????A?PHK_
+&G????GC?@SH_
+&G????O?C`PH?
+&G???A?cA?BG_
+&G???O@@A?SGG
+&G?????A?WC[_
+&G?????K?aEA_
+&G????G?IASH?
+&G????G@AASH?
+&G???O@@A?SCO
+&G????OC@_oGO
+&G?????CA?aN?
+&G?????W?OEM?
+&G????OG?@cM?
+&G???@G?E?HK?
+&G???@?SA?aK?
+&G??a?AG?GOE?
+&G?????W?O`M?
+&G???@A?C_KK?
+&G???O?OE?gK?
+&G??_OAG?GOE?
+&G?A?O_G?OCK?
+&G?G?O_GA?OE?
+&G?????@A?cM_
+&G????G?CGIL?
+&G????GG?@gL?
+&G???O?_I?PH?
+&G???A?cA?aK?
+&G?A?O_C?_GK?
+&G?????GAOC]?
+&G????@@@_`H?
+&G????O?P_oGO
+&G???O@?Q?SCO
+&G???GAC@?aK?
+&G???O_GA?SK?
+&G???????oIKW
+&G??????B?FIG
+&G??????B?LAo
+&G??????D_SGW
+&G??????OQgKO
+&G?????G?GYD_
+&G?????OF?g?W
+&G?????`?OgL?
+&G?????GA?wL?
+&G?????A?GKKg
+&G??????GoG[O
+&G?????A?GK[_
+&G??????Go`KO
+&G????O@?@WHG
+&G?????_F?_QO
+&G????_?GOKKG
+&G????G@?AcL?
+&G???C?_I?@[?
+&G???@GA?AgK?
+&G???O_A?_CM?
+&G????_G?AoM?
+&G????GA?OAL_
+&G????G@?AG\?
+&G?????_F?HAO
+&G??@?O?C_CJ?
+&G???C?_E?PGG
+&G???C?_E?PCO
+&G?GA??OD?GE?
+&G?AA?OC?_?[?
+&G???A?WA?oK?
+&G?????@?GHKg
+&G??????GWG[O
+&G?????C?GMGW
+&G??????GoPGo
+&G????O@?@IHG
+&G?????_O`PH?
+&G????AA?AQHG
+&G????G?GOSH_
+&G???C?_H?@Y?
+&G???GA?CAaCO
+&G???GAC?_GJ?
+&G?????gA?gL?
+&G?????GA?EMG
+&G?????P?OIKG
+&G?????C@?[Gg
+&G????A?GGWHG
+&G????_G?@KKG
+&G???GA?C@WGG
+&G????OC?AWHG
+&G??@?@?O_GJ?
+&G???A?c@?OW_
+&G?A?O?Q?OCK?
+&G??@?OC?_GJ?
+&G???O_GA?CM?
+&G????G?OOAL_
+&G????A?GOG\?
+&G????G@?AA\?
+&G?????_D_`@O
+&G???CO?COGJ?
+&G???OA?CASGG
+&G???C?_D?GWO
+&G???@@?H?HGO
+&G?G?C?OD?GE?
+&G?A?O?S@?GK?
+&G?@?O_?D?OE?
+&G???@?gA?gK?
+&G????AGA?CN?
+&G???OA?C_AM?
+&G????_G?AC]?
+&G???O?P?AG[?
+&G???O_G?_?]?
+&G?A?O?S?O?[?
+&G???A?WA?A[?
+&G?G?C?OP?OE?
+&G?AA?_C?@?[?
+&GOA?O_GA?O@?
+&G?GA?_?D?OE?
+&G?AA?_G?_?[?
+&G?????A?OBKo
+&G?????@?IG[_
+&G?????K?gE?W
+&G????OA?@EH_
+&G????G?IAS@O
+&G????_@?BSB?
+&G???A?g@?B?o
+&G???CGA@?@Y?
+&G????_GB?g?W
+&G?????@A?aM_
+&G????G?CGEL?
+&G?????G?P`M?
+&G?????`?ao@O
+&G????GG?@cL?
+&G???@G?D?HGO
+&G????_?R?_QO
+&G???CG?P?GWO
+&G???A?g@?QC_
+&G?G?C@?P?GE?
+&G???GAC@?OW_
+&G???O_GA?C[?
+&G?????G@?oN?
+&G?????W?OcM?
+&G???@?Q?OKK?
+&G????_C?@oM?
+&G???@G?E?gK?
+&G?@?O_@@?GE?
+&G???A?g@?oK?
+&G?AA?_C?_GK?
+&G?GA?_G@?GE?
+&G??????B?IN?
+&G??????F?KM?
+&G?????A?GoN?
+&G????G?COoM?
+&G??????F?EM?
+&G????@?P_WH?
+&G?????P?GoM?
+&G???OA?GAoK?
+&G??????OOoM_
+&G????AA?@oL?
+&G?????@?OoM_
+&G????GA?@oL?
+&G?????@B?A]?
+&G????G?R?o@O
+&G?????@B?C]?
+&G????_?P_WGO
+&G??????EOQM?
+&G????@?R?WH?
+&G????O?COaM?
+&G???@@?E?WK?
+&G????@?R?cA_
+&G???C@?Q?gD?
+&G???@A?O@gK?
+&G?AA?A?O_GK?
+&G????AA?@`L?
+&G???C?_I?WD?
+&G????G?C_aL?
+&G???@?S@?gG_
+&G????G?R?a@O
+&G???GAG@?BI?
+&G????@CA_PH?
+&G???GACA?WG_
+&G??????Q?SM_
+&G????AC?@gL?
+&G????AG?AON?
+&G???O_?P??]?
+&G????AG?@HL?
+&G???C?_I?gD?
+&G???O_?OA?]?
+&G?AA?A?O@?[?
+&G????@?G__L_
+&G???G@G@??Z?
+&G????G?Q?GL_
+&G???GOG@??Z?
+&G????AG?_@\?
+&G???C?SA?AY?
+&G????AG?_G\?
+&G???AACA?SGG
+&G?????G@OA]?
+&G????G?Q_o@O
+&G????OG?OA]?
+&G???@ACA?@[?
+&G????_?R?I@O
+&G???GAC@?BI?
+&G???OA?E?@[?
+&G?GA?A?P?OE?
+&G????AAA?@\?
+&G???C?W@?AY?
+&G????GG?_A\?
+&G???@OG@?AX?
+&G????_AB?D?o
+&G???O_G@?E@O
+&G????OG@_`@O
+&G???OOCA?EH?
+&G????@?R?g@_
+&G???C@?Q?KK?
+&G???@?OQ?KK?
+&G?@?O_?Q?CE?
+&G???C@?P?EI?
+&G??@?OC@?EI?
+&G?@?O_?OOAE?
+&G?GA?A?Q?_E?
+&G???C?OD?EI?
+&G?@?OA?Q?CE?
+&G???@?S@?KG_
+&G?@?OAGA?CE?
+&G???GAG@?K?o
+&G??@?_GA?EI?
+&G???GACA?KG_
+&G??A?_G@?KK?
+&G????A?O@gL?
+&G???OA?GAgK?
+&G???OA?CA_M?
+&G?A?O?OQ??[?
+&G???O@?GAWG_
+&G?A?OA?O_GK?
+&G?A?O?OOA?[?
+&GOA?OA?OAC@?
+&G???G?_O@OJ?
+&G?@?CA?E??U?
+&G???GO?O@OJ?
+&G?@A?A?E??U?
+&G???OA?D?@Y?
+&G?@A?A?P?OE?
+&G???OA?I?WGG
+&G?A?OACA?OK?
+&G????@@A_o?o
+&G???O@?Q?HK?
+&G???O?OQ?G[?
+&G?G?C_@@?OE?
+&G???CA?P?DI?
+&G???O_GA?gC_
+&G?G?AA?P?OE?
+&G?AA?A?Q?_K?
+&G???CA?D?CY?
+&G?@?CAG@?OE?
+&G???O?S@?GW_
+&G?@?C_G@?OE?
+&G???OACA?I?o
+&G???O_G@?gGO
+&G???OACA?IG_
+&G???O_G@?gK?
+&G?????@?OgKo
+&G????GA?@oH_
+&G????GAA?@L_
+&G??@?O?Q??Z?
+&G????GA?@PH_
+&G???A?c@?BI?
+&G??@?O?OA?Z?
+&G?GA?A?O@?U?
+&G????GA?AOHo
+&G???AOC?@_B_
+&G????OA?_OHo
+&G??A?OC?@_B_
+&G????GA@?@X_
+&G???A_C@?B@G
+&G????GA@?OX_
+&G???AOCA?EGG
+&G?????AAOG[_
+&G????O?E_OX?
+&G????GG?GG\?
+&G???@@CA?OW_
+&G?????gAAID?
+&G???O@@A?cE?
+&G???OA?I?PGG
+&G?AA?A?P?OK?
+&G????G?P?GX_
+&G???AACA?DGG
+&G????OA@?GX_
+&G???A_C@?EGG
+&G????GGAAQ@G
+&G???CGCA?II?
+&G????GC@@GX?
+&G???OACA?cD?
+&G?????KA_E@_
+&G????_@B?KB?
+&G????_@B?HAO
+&G???G@GA?QC_
+&G????_@@OSA_
+&G????OC@_WH?
+&G???OA?Q?PCO
+&G???OAGA?oK?
+&G????O@?`GW_
+&G???OA?Q?SD?
+&G????OC?`GX?
+&G???OAGA?SD?
+&G????_C?oK@_
+&G????OGA_gH?
+&G????_CAGIA_
+&G????_CB?gI?
+&G??????@GcMO
+&G??????B?iBG
+&G??????DOgKO
+&G??????Q_KKO
+&G?????C?GcMG
+&G?????A?GkKG
+&G????O?COgKG
+&G????G?GOgKG
+&G??????EOIKO
+&G??????QOIKO
+&G????@?PAWH?
+&G????_@?OIL?
+&G?????P?GgKG
+&G?????`?GgKG
+&G???OA?GA_[?
+&G??A?A?O_GM?
+&G??????O_cKg
+&G?????@?Gg[O
+&G????AA?@oHG
+&G????G?GO`KG
+&G?????A?_cKg
+&G?????A?_c[_
+&G????OC?@gHG
+&G????GA?AcKG
+&G?????AAOA[O
+&G?????AAOBKO
+&G????G?QAo@O
+&G????_A?OEL?
+&G?????AAOG[O
+&G?????AAOHKO
+&G????_?H_PGG
+&G????_A?OKL?
+&G?????C?GcM_
+&G??????P@cM?
+&G????_@?@WL?
+&G????@?F?WGO
+&G????_@?AON?
+&G????O?GO_]?
+&G??A?AC?_?]?
+&G???C?_E?O[?
+&G????_?COIL?
+&G?????_PAWH?
+&G???C?_I?`D?
+&G???C@?I?`E?
+&G??A?A?O@GM?
+&G???OA?CA_[?
+&G?G?OA?D??[?
+&G?G?OAC@??[?
+&G????_?O_CL_
+&G????AA?A_\?
+&G??A?AC?@GJ?
+&G???C?_E?WCG
+&G????GG?_AL_
+&G????GA?A_\?
+&G??A?OC?@GJ?
+&G???A?S@?_W_
+&G????_A?OA\?
+&G????G?J?`@O
+&G???G?W@?@W_
+&G???G?W@?BG_
+&G????_A?OG\?
+&G????_?H_PGO
+&G???@AG@?OW_
+&G???AACA?QG_
+&G??????CWgKO
+&G??????POWGo
+&G????@?P@WH?
+&G????O@?OWH_
+&G????_?COIKG
+&G?????c?GWHG
+&G???C?OE?SGG
+&G??@?GC?GGJ?
+&G????@?QAID?
+&G????G@?OPH_
+&G???C@?OASI?
+&G????_GA?IL?
+&G???OA?C@PGG
+&G??@?G?OAGJ?
+&G?A?@A?O_GK?
+&G??A?A?Q?_M?
+&G????AA?@PHG
+&G?????a?GPHG
+&G???A@?H?CY?
+&G???GG?P?GJ?
+&G????O?D?IHG
+&G?????a?_QHG
+&G???A?c@?AY?
+&G???GGC@?GJ?
+&G????G?QAQ@O
+&G????G@@?DH_
+&G???O?P@?DI?
+&G????_AA?aL?
+&G????@C?`PH?
+&G????G@@?SH_
+&G???GA?I?WG_
+&G????_G?_gL?
+&G????A?COgL?
+&G????@?E_o@O
+&G???O?a?AgK?
+&G???C@?I?HK?
+&G???O?Q?A_M?
+&G???@@?I?G[?
+&G?A?@AG@??[?
+&G?G@?AG?@OE?
+&G???O@?GASG_
+&G???C@?H?DI?
+&G?A?OAA?_CK?
+&G???AOC@?QH?
+&G?A?@A?O@OK?
+&G?G@?A?G@OE?
+&GOAA?A?Q?_C?
+&G?G?OAGA??[?
+&G???CAC?@GJ?
+&G???C?OH?CY?
+&G??_O_?C@OE?
+&G?@@?AG?@OE?
+&G???GO?D?GJ?
+&G???@?c@?GW_
+&G?@A??W?@OE?
+&G?@@?_G?@OE?
+&G???O?Q@?@Y?
+&G???AACA?E?o
+&G??a?A?P?OE?
+&G???AOGA?aH?
+&G???OA?I?SGG
+&G???G?cA?IG_
+&G?A?OOG@?GK?
+&G???A_G@?cK?
+&G??????O_cKo
+&G??????OPgK_
+&G????G@?@oH_
+&G????@?D@gH?
+&G????G@A?@L_
+&G?????g?GG\?
+&G??@?G?Q??Z?
+&G???C?_E?aCG
+&G????G@?@PH_
+&G?????_QAID?
+&G???A@?H?DI?
+&G???O@@?ASI?
+&G??@?G?OA?Z?
+&G???OA?G@PGG
+&G?G@?A?O@?U?
+&G?A?@A?P?OK?
+&G????AA?AOHo
+&G????@?H?GX_
+&G???G?c?@_B_
+&G???C?OH?KGG
+&G????AA@?OHo
+&G????O?H?GX_
+&G???OOG?@_B_
+&G???@?c@?IGG
+&G????G@@?@X_
+&G????G?QAQ@G
+&G???AACA?E?W
+&G???O?Q@?HI?
+&G????G@@?OX_
+&G????@C?`OX?
+&G???AACA?EGG
+&G???GG?I?WI?
+&G?????GA?SM_
+&G????A?CGgL?
+&G????_G?@WL?
+&G???O?`?AgK?
+&G????_G?AON?
+&G???O?P?A_M?
+&G??A?ACA??]?
+&G?A?@AG?_?[?
+&G????_?E?IL?
+&G???C@?GAWG_
+&G???@?WA?WG_
+&G?A?OAA?_AK?
+&G??A?A?O@_M?
+&G?A?@A?O@GK?
+&G?G?OA?E??[?
+&GOAA?A?Q?_A?
+&G????_?O__L_
+&G???G@C?@@J?
+&G???G_CA??Z?
+&G?@?C_?O@?U?
+&G????GG?__L_
+&G???GO?D?AJ?
+&G??A?OG@??Z?
+&G?G?GA?E??U?
+&G????_AA?A\?
+&G???O?P@?@Y?
+&G???@_CA?AX?
+&G?@A?@?P?OE?
+&G????_G?_G\?
+&G???GA?I?WGG
+&G???AOG@?SGG
+&G?A?OOG@?CK?
+&G?????@?HgK_
+&G?????HB?I?g
+&G????G?J?c@G
+&G????_@B?K@G
+&G????GG?GC\?
+&G????O@@_`?W
+&G???C?SA?AW_
+&G???G@C@?AW_
+&G????O?Ooa@O
+&G????O@?oa@O
+&G???O@@@?DI?
+&G????OC@_PH?
+&G???OA?D?@WO
+&G???OA?P?@WO
+&G?G@?A?O_GE?
+&G???OAGA?_[?
+&G????G?P?CX_
+&G????O@?`@W_
+&G???AACA?D?W
+&G???O@A@?GY?
+&G????GC@?CX_
+&G????OC?`@X?
+&G???A_C@?E@G
+&G???GGC@?GY?
+&G????GCAOD?o
+&G????OG?oD@_
+&G???OACA?E@O
+&G????OGA_`H?
+&G????GGAAS@G
+&G????OG?oc@O
+&G???GGCA?II?
+&G????_CA_oGO
+&G?????GA@SM?
+&G????@@A_o@O
+&G????_?R?WGO
+&G???CG?Q?HK?
+&G????OG?O_]?
+&G???@G?Q?G[?
+&G???@ACA?_[?
+&G?G@?_@@?GE?
+&G????@C@_PH?
+&G???C@@@?DI?
+&G???GAGA?WG_
+&G???O_GA?cC_
+&G???OA?E?_[?
+&G?G@?A?P?GE?
+&G?G?OACA?OK?
+&G?G?OAGA?OK?
+&G????AAA?_\?
+&G???C?P@?CY?
+&G???AACA?cGG
+&G?@@?AG@?GE?
+&G????GG?__\?
+&G???@GC@?GW_
+&G???AOG@?cGG
+&G?@@?_G@?GE?
+&G????GGB?`@O
+&G???OACA?E?o
+&G???O_CA?EH?
+&G???O_G@?cGO
+&G????_AB?`AO
+&G???GGCA?IG_
+&G???O_G@?cD?
+&G???O_G@?cK?
+&G???????WoMO
+&G??????B?qBG
+&G??????CooKO
+&G??????OoKKO
+&G??????CoaKO
+&G??????OoIKO
+&G????@?QAWH?
+&G????G@?OIL?
+&G??????Q?KKg
+&G?????G?GK[O
+&G????AG?@WHG
+&G????G?GOHKG
+&G?????G?oA[O
+&G?????A?oBKO
+&G????G?Oao@O
+&G????GA?OEL?
+&G?????_H_`@_
+&G????G@?OBL?
+&G???GA?CGKK?
+&G????_GA?EM?
+&G????A?O@WHG
+&G?????_OOIKG
+&G???OA?GAG[?
+&G???OA?O_GM?
+&G????@@?ao?o
+&G????G@?GDL?
+&G???@AA?_KK?
+&G????_G?O`M?
+&G?????@?OWGw
+&G?????@?OWWo
+&G????GA?@o@g
+&G????GA?AEKG
+&G?????C?oOWo
+&G?????A?WHKO
+&G????_?D__PO
+&G????AA?OKL?
+&G?????K?aEAG
+&G?????A?WEK_
+&G????@@B?KB?
+&G?????GAOcM?
+&G?????@?GoM_
+&G??????OPoM?
+&G????G@?@oL?
+&G????@?D_WGO
+&G????G?COaL?
+&G?????_OaoH?
+&G???C?_I?PD?
+&G???C@?I?PI?
+&G????G?Q?CL_
+&G????AG?AG\?
+&G??@?AG?@GJ?
+&G???C?_E?gCG
+&G????GG?OA\?
+&G????O?H_`@O
+&G???G?SA?@W_
+&G???G?S@?BG_
+&G???@?OP?KGO
+&G???C@?D?KGO
+&G?@?OAG?OAE?
+&G???@_GA?EK?
+&G??@?A?O@GJ?
+&G???OA?G@WGG
+&G?G?OA?C@OE?
+&G?A?OAC@??[?
+&G???O?OP?GWO
+&G???O@?D?HGO
+&G?@?C_@@?OE?
+&G???@AGA?cK?
+&G????OA?_CHo
+&G????GA?AOX_
+&G??A?_C?G?R_
+&G???A?S@?BGG
+&G????GC?OOX_
+&G????O?O`OX?
+&G???AACA?BGG
+&G???CG?I?WI?
+&G????O@?`GX?
+&G????O?QOKB?
+&G???O@?Q?SD?
+&G????_?R?gI?
+&G?????A?_oN?
+&G?????P?OoM?
+&G????GA?@oM?
+&G???GA?GAoK?
+&G?????S@?cM?
+&G???@A?CGgK?
+&G???@?S@?gK?
+&G?AA?AA?_AK?
+&G????AG@?ON?
+&G???O_?O@@M?
+&G???O_C@??]?
+&G?AA?A?CG?[?
+&G????_C@?C]?
+&G???O?PA?@[?
+&G???@_C@?C[?
+&G?GA?@?P?OE?
+&G???@?WA?KK?
+&G?@?O_?OO@E?
+&G?@?O_GA?CE?
+&G?GA?AGA?AE?
+&G???OA?E?_M?
+&G?A?O?OO@@K?
+&G?A?O?WA??[?
+&GOA?O_?Q?_?O
+&G???O?WA?G[?
+&G?G?C?_H?OE?
+&G?G?C_G@?OE?
+&G?AA?AGA?AK?
+&G????GAA?_L_
+&G??@?O?O@@J?
+&G??@?OGA??Z?
+&G?GA?A?CG?U?
+&G????GGA?G\?
+&G???GA?I?PGG
+&G???A_C@?SGG
+&G?AA?AC@?AK?
+&G????_GB?HAO
+&G???O@@A?PCO
+&G???O_GA?SD?
+&G???GAGA?oK?
+&G???????WgKW
+&G??????B?bBG
+&G??????B?JBG
+&G??????B?FIO
+&G??????F?KGW
+&G??????OaKKO
+&G??????QAKKO
+&G?????G?GqB_
+&G?????@?GgKg
+&G??????IOG[O
+&G?????@?Gg[_
+&G??????IOHKO
+&G????O@?@gHG
+&G?????_F?`AG
+&G????G?GOcKG
+&G????_@?AKL?
+&G?????C@?cMG
+&G?????P?OgKG
+&G?????A?_kKG
+&G?????`?OgKG
+&G????OC?@gKG
+&G???O?`?A_[?
+&G????GA?AgKG
+&G??A?AA?_AM?
+&G?????G?GKKg
+&G?????G?GK[_
+&G??????Go_[O
+&G??????GoHKO
+&G????_@?@WHG
+&G????G?GOKKG
+&G?????_F?HAG
+&G????G@?AKL?
+&G????GG?OAL_
+&G????_@?AG\?
+&G????G@?A_\?
+&G?????_F?`AO
+&G??A?O?C_CJ?
+&G???C?_E?`CG
+&G???C?_E?PCG
+&G???C?_E?`CO
+&G????_@@?ON?
+&G??A?A?C_AM?
+&G????OC?A_]?
+&G???O?P?A_[?
+&G??A?OC?_?]?
+&G?G?O?S?O?[?
+&G???A?S@?_[?
+&G?G?OOC?O?[?
+&G??????D_EGW
+&G??????OQIKO
+&G??????OQWGo
+&G?????@?GYGo
+&G????@?OBWH?
+&G?????`?OIL?
+&G?????`?OWH_
+&G?????GA?kK_
+&G????O?COIHG
+&G?????_OaOX?
+&G?????a?GQHG
+&G????G@?ASH_
+&G???A@?H?@Y?
+&G???GA?G@WG_
+&G???GGC?GGJ?
+&G????_G?AgL?
+&G?????WA?KKG
+&G???GA?C@PGG
+&G?????c@?WHG
+&G??@?G?GAGJ?
+&G???@?WA?WGG
+&G?A?@AA?_AK?
+&G??@?GC@?GJ?
+&G??A?AGA?AM?
+&G????A?COWHG
+&G?????`?GIKG
+&G????@?Cao@O
+&G????G@?AEL?
+&G???O?a?AG[?
+&G???OAA?_CM?
+&G???O?P?AKK?
+&G????_G?AcM?
+&G??@?A?C_CJ?
+&G???OA?G@SGG
+&G???@@?H?GWO
+&G???C?_D?HGO
+&G?@A??OD?GE?
+&G?A?OOC?_?[?
+&G??`?AG?@OE?
+&G???A?WA?aK?
+&G???O?QA?_M?
+&G?A?@A?D?AK?
+&G???@?gA?G[?
+&G?G@??_G@OE?
+&G?A?@_G@??[?
+&GOAA?AGA?O?_
+&G?G@?_G?@OE?
+&G?G?O_G?O?[?
+&G?????@?GWGw
+&G?????@?GWWo
+&G??????GoOWo
+&G??????GWHKO
+&G????G@?@o@g
+&G????G?GODKG
+&G?????_D__PO
+&G????A?GOKL?
+&G????OA?GCHo
+&G????G@?AOX_
+&G????G?GOOX_
+&G?????_O`OX?
+&G???OOG?G?R_
+&G???C?_D?HGG
+&G???@@?H?HGG
+&G???OA?CASH?
+&G????G@A?_L_
+&G??@?G?O@@J?
+&G?????gA?G\?
+&G???GA?G@PGG
+&G??@?GGA??Z?
+&G?G@?A?CG?U?
+&G???A?S@?SGG
+&G?A?@AC@?AK?
+&G?????GA?KKg
+&G?????GA?K[_
+&G????A?CGWHG
+&G?????`?OIKG
+&G????_G?@WHG
+&G????GA?AKKG
+&G???O?`?AG[?
+&G???OAA?_AM?
+&G????GG?O_L_
+&G????_G?AG\?
+&G??@?A?CGGJ?
+&G???GA?G@WGG
+&G??@?_G?@GJ?
+&G???A?WA?OW_
+&G?G?O?P?@OE?
+&G?A?OOC?O?[?
+&G????_G@?ON?
+&G??A?A?E?AM?
+&G???O?PA?_M?
+&G?A?@A?C_AK?
+&G??A?_C@??]?
+&G?G?O?W?O?[?
+&G?A?@_G?_?[?
+&GOAA?AGA?G?_
+&G?????C?oAWo
+&G?????A?WBKO
+&G?????K?gD?W
+&G?????@?IIK_
+&G????G?J?D@G
+&G????AA?OEL?
+&G????@@B?K@G
+&G?????GAO`M?
+&G????GC?OAX_
+&G????G?QAS@G
+&G????O@?`@X?
+&G????O?Goc@O
+&G???@ACA?@Oo
+&G???CG?D?HI?
+&G???CG?P?GY?
+&G????_?I_oGO
+&G????GGA?C\?
+&G???O?P@?@WO
+&G????OC@_`?W
+&G???O@@@?@WO
+&G???@OGA?CX?
+&G?G@?@?O_GE?
+&G???OOC@?CX?
+&G???GAGA?_[?
+&G?????G?o_[O
+&G?????A?oHKO
+&G????@@?ao@O
+&G????G@?GEL?
+&G????_?H_`GG
+&G????GA?OKL?
+&G???O?Q?OKK?
+&G????_G?OcM?
+&G????GG?O_\?
+&G????_?J?HGO
+&G???@G?P?GWO
+&G???CG?D?HGO
+&G???@ACA?_W_
+&G???AAGA?QG_
+&G?@@?_@@?GE?
+&G???@AGA?aK?
+&G????_C@?_]?
+&G???O?PA?_[?
+&G???@GGA?G[?
+&G?G@?@?P?GE?
+&G???@_C@?_[?
+&G?G?OOG@?CK?
+&G?G@?_G@?GE?
+&G?G?O_G@?CK?
+&G??????B?FM?
+&G??????B?MBO
+&G??????OQoM?
+&G?????@?GwK_
+&G?????`?OoM?
+&G?????GA?wF?
+&G??????GoKKO
+&G??????GooKO
+&G?????_D_WGO
+&G????G@?AoL?
+&G???GA?CAoK?
+&G????GA?AoM?
+&G??????GgKKO
+&G??????GooGo
+&G?????_O`oH?
+&G????G?GOoH_
+&G???@A?GGgK?
+&G?????c@?gL?
+&G????G@?OIKG
+&G????AG?GWHG
+&G???C@?E?gCG
+&G??@?AG?GGJ?
+&G?AA?A?C_AK?
+&G???O_C@?CM?
+&G?????G?GpB_
+&G??????QAKK_
+&G????AG?AIL?
+&G?????a?GaL?
+&G???O_?OO@M?
+&G?????a?_gL?
+&G????G@?AIL?
+&G?????_D_`H?
+&G???C?_E?gCO
+&G???C?_E?QCO
+&G?AA?AA?G?[?
+&G???@?c@?gK?
+&G?????A?IKK_
+&G?????BB?H?g
+&G????_?J?K@O
+&G????O@A_@X?
+&G???O@@A?@[?
+&G????_GB?W?W
+&G????GA?GEL?
+&G????G@?ao@O
+&G???C?S@?BG_
+&G???G@CA?@W_
+&G?GA?@?P?GE?
+&G???O_C@?C[?
+&G????G@?OBKG
+&G????@?Q?W@g
+&G???C@?D?KGG
+&G???A?c?G_B_
+&G?@?O_?O@@E?
+&G???GACA?_J?
+&G????GA?_EKG
+&G????_GA?W@g
+&G???@OC@?EGG
+&G??@?_G?__B_
+&G?GA?A?E?AE?
+&G??@?OGA?OJ?
+&G????A?GOHL?
+&G?????_F?I@O
+&G???OA?CASI?
+&G???A?OP?DI?
+&G?A?O?OO_@K?
+&G???A?WA?cE?
+&G???OA?O_AM?
+&G???OA?GOG[?
+&G?A?OAC?O?[?
+&G?G?OA?COOE?
+&GOA?O_?Q?G?O
+&G?A?O?WA?GK?
+&G????A?O_DL?
+&G????G@B?B@G
+&G???O@?D?HI?
+&G???G@CA?H?g
+&G?G?C?_H?GE?
+&G???OOGA?CY?
+&G????AA?_KL?
+&G????_G@__PO
+&G???AAGA?SH?
+&G???OOGA?EGG
+&G?AA?ACA?AK?
+&G??A?_C@?WGG
+&G?????C@?[Go
+&G????@?OAWH_
+&G????OC?AWH_
+&G???GA?P?@J?
+&G??@?O?P?@J?
+&G???GAC@?OJ?
+&G????_G?AEM?
+&G???GA?CAKK?
+&G???A?WA?BK?
+&G?@?OAG?G?U?
+&G?GA?AG?G?U?
+&G?@?O_GA??U?
+&G?????G?W`M?
+&G????@@B?I@G
+&G????O?P_OX?
+&G???O@?P?CY?
+&G???C@C@?OW_
+&G???OOC@?CY?
+&G????_@?GaM?
+&G???@AA?OKK?
+&G???CG?E?gK?
+&G?@?C_@@?GE?
+&G?AA?AG@?AK?
+&G?G?C_G@?GE?
+&G?????@AGaM?
+&G????G?R?E@_
+&G????G?R?cH?
+&G???GAG@?HAO
+&G???GAG@?`GO
+&G??A?_G@?HAO
+&G?????@AOcM?
+&G????G?R?IA_
+&G????G?R?gI?
+&G???GAG@?WE?
+&G???GAG@?oK?
+&G??A?_G@?WE?
+&G??????B?kE_
+&G??????POcM?
+&G????@?J?gE?
+&G??????I_KK_
+&G????AA?GgL?
+&G????@?D_oH?
+&G???C@?I?WK?
+&G?????I@Oo?o
+&G????O@A_o@O
+&G???G@G@?BK?
+&G??????POaM?
+&G????_@?OQM?
+&G?????_R?WH?
+&G???C@?E?WK?
+&G????AA?G`L?
+&G????GA?_aL?
+&G???C@?I?SE?
+&G???AOC@?aH?
+&G????@?J?KG_
+&G???OA?COgK?
+&G???C@?I?WG_
+&G?A?OAG?_AK?
+&G????G@B?a@O
+&G????OCA_PH?
+&G???CAG@?BI?
+&G???O_C@?aD?
+&G?????A?GkKO
+&G????O?GO`M?
+&G????AA?AgL?
+&G???C?_E?WK?
+&G?????g?GHL?
+&G???OA?Q?CM?
+&G???C?_E?aE?
+&G?A?OAG?_?[?
+&G????@?H?WH_
+&G???C?OI?KK?
+&G???G@C@?AJ?
+&G?@?C_?Q??U?
+&G????O@@_@W_
+&G???O@AA?G[?
+&G???CAC@?AY?
+&G?@A?AG@?GE?
+&G?????G@OBM?
+&G????OG?OEM?
+&G????O?I_o@O
+&G???@ACA?BK?
+&G????AAA?BL?
+&G????GG?_IL?
+&G???G?SA?BI?
+&G???AOGA?QH?
+&G????_?R?I@G
+&G???O?QA?HK?
+&G???GAC@?@Y?
+&G?@A?AG?GOE?
+&G????GGB?D@_
+&G????OG@_`H?
+&G???O_G@?D?o
+&G???O_G@?SC_
+&G????@?J?g@_
+&G???C?OQ?KK?
+&G?@?C_?Q?CE?
+&G???C@?D?EI?
+&G???@OC@?IH?
+&G?@?CA?Q?CE?
+&G?@A?AGA?CE?
+&G???G@G@?K?o
+&G???OOGA?IH?
+&G??A?OG@?KK?
+&G????A?OAgL?
+&G???OA?CAgK?
+&G???OA?Q?@M?
+&G?A?OAG?G?[?
+&G???O@?G@WG_
+&G?A?OA?O@GK?
+&G?A?OA?O@AK?
+&GOA?OA?OAO@?
+&G???G?_OAOJ?
+&G?@?CA?Q??U?
+&G???GO?P?OJ?
+&G?@A?AGA??U?
+&G???OA?P?@Y?
+&G?@A?A?O_OE?
+&G???OAGA?WGG
+&G?A?OAGA?OK?
+&G?????`A_o?o
+&G???O?OQ?HK?
+&G???O@?Q?G[?
+&G?G?OAG?GOE?
+&G???CA?D?DI?
+&G???O?S@?WG_
+&G?G?OA?GGOE?
+&G?A?OAGA?CK?
+&G???CA?P?CY?
+&G??OOAG?GOE?
+&G???GOC@?GX?
+&G??_O_GA?OE?
+&G???OACA?H?o
+&G???OACA?gG_
+&G???GOGA?KH?
+&G???O_G@?WK?
+&G?????GA?YDO
+&G????GA?AaL?
+&G???A?WA?PC_
+&G????O?H?HH_
+&G???GO?P?AJ?
+&G???@?c@?HG_
+&G?@A?AG?O?U?
+&G????_G?BSA_
+&G???CGC@?GW_
+&G?@?G_G@?GE?
+&G?????AAOHK_
+&G????GG?GIL?
+&G????O?E_PH?
+&G???AACA?PG_
+&G????G?P?HH_
+&G????OA@?WH_
+&G???G?cA?HG_
+&G???A_CA?EK?
+&G????_?EAID?
+&G???GG?I?PI?
+&G???O@@A?WGG
+&G?A?OAG@?CK?
+&G????OG?gc@O
+&G????GC@_OX?
+&G???CGCA?IG_
+&G???OACA?cK?
+&G?????KA_E@O
+&G????O@@_`H?
+&G???G@GA?QCO
+&G????G@AAQH?
+&G????OC@_GX?
+&G???OA?Q?SCO
+&G???OAGA?SK?
+&G????_C?oI@_
+&G????_AB?aC_
+&G????_CB?gE?
+&G??????B?kCo
+&G??????B?MIO
+&G??????OQcM?
+&G?????C?GkK_
+&G??????I_KKO
+&G??????HOgKO
+&G?????_F?WGO
+&G????_@?AWL?
+&G????G@?OgKG
+&G????_@?OWKG
+&G???C@?I?O[?
+&G??A?AC?_AM?
+&G??????OQaM?
+&G?????@?GwGo
+&G?????`?OaM?
+&G?????GA?[K_
+&G?????_Q_OX?
+&G????G@?AoH_
+&G???O?`?@gK?
+&G????_G?AWL?
+&G???C@?E?aCG
+&G??@?G?Q?@J?
+&G?A?@AG?_AK?
+&G??A?ACA?AM?
+&G?????C?G[Go
+&G??????QAEM?
+&G????_?GODM?
+&G?????`?GaM?
+&G????O@?AWH_
+&G?????_P_OX?
+&G???C?_E?HK?
+&G???O?a?@gK?
+&G??@?G?P?@J?
+&G???C@?E?QGG
+&G?G@?AG?G?U?
+&G?A?@AG@?AK?
+&G?????G?WBM?
+&G?????@AGBM?
+&G????_@?GEM?
+&G?????@AODM?
+&G????_?R?K@G
+&G????G?R?c@G
+&G???CG?E?HK?
+&G????_?J?WGO
+&G???C@C@?AW_
+&G???C@CA?AW_
+&G?G@?AG?GGE?
+&G???GACA?_[?
+&G??????IGKKO
+&G??????IOWGo
+&G?????_Q@WH?
+&G????_?GOWH_
+&G????G@?OaKG
+&G????AA?GoHG
+&G???C@?E?WCG
+&G??A?AC?GGJ?
+&G????GA?_cKG
+&G????OC@?gHG
+&G???AOC@?_X?
+&G??A?OC@?GJ?
+&G????@?J?GP_
+&G????G?GOo@o
+&G???@A?GGKK?
+&G????_?I?WH_
+&G???C?OP?KGG
+&G???G?c?A_B_
+&G?@?C_?O@CE?
+&G???G_CA?AJ?
+&G???@OC@?KGG
+&G???OOGA?_B_
+&G?G?GA?E?_E?
+&G??A?OG@?OJ?
+&G????@@?AWH_
+&G????@?F?I@G
+&G???OA?CAKK?
+&G???@A?GOKK?
+&G???GG?P?@J?
+&G???A@?P?CY?
+&G?@@?AG?G?U?
+&G??_O_?COOE?
+&G???GGC@?OJ?
+&G???AOC@?CY?
+&G?@@?_GA??U?
+&G?@A??WA?OE?
+&G????@@B?I?g
+&G????G?R?CP_
+&G???OA?C_KK?
+&G????@G@__X?
+&G???O@?P?GY?
+&G???C@CA?I?g
+&G?@@?AG?GGE?
+&G???GACA?gGG
+&G???OOC@?GY?
+&G??A?OC@?KAG
+&G?@@?_GA?GE?
+&G??A?OC@?cGG
+&G?????G?GqBO
+&G??????OaKK_
+&G????AA?AIL?
+&G?????a?GIL?
+&G????_@?AIL?
+&G?????_D_PH?
+&G???C?_E?`E?
+&G???C?_E?`D?
+&G??A?A?O_AM?
+&G???OA?GO_[?
+&G?G?OAC?O?[?
+&G?G?OA?D?CK?
+&G????A?OAIL?
+&G?????a?GBL?
+&G???OA?OO@M?
+&G?????a?_IL?
+&G???OA?CAWH?
+&G???A@?D?DI?
+&G?A?OAA?G?[?
+&G???@?gA?WG_
+&G?A?@A?P?AK?
+&G?G@?A?O@AE?
+&GOAA?A?Q?G?_
+&G?G?OA?E?CK?
+&G?????GA?qBO
+&G????A?GGHL?
+&G????GA?AIL?
+&G???OA?OOAM?
+&G????_G?AIL?
+&G???GA?CAgD?
+&G???A?WA?`C_
+&G?A?OAA?O?[?
+&G??A?A?Q?AM?
+&G?A?@A?O_AK?
+&G?G?OAG?O?[?
+&GOAA?A?Q?O?_
+&G?????A?aKK_
+&G????A?O_BL?
+&G????GA?GIL?
+&G????AA?_IL?
+&G????O?D_PH?
+&G???O@?D?DI?
+&G???AAGA?PG_
+&G???AAGA?SG_
+&G???O@@A?_[?
+&G?G@?A?GGGE?
+&G?G?OAG@?CK?
+&G?G?OACA?CK?
+&G?????G?IKK_
+&G?????BB?`?g
+&G????G?J?K@O
+&G????_@@_@X?
+&G????_A?GEL?
+&G????G@AAo@O
+&G???C?W@?BG_
+&G???G@G@?@W_
+&G????_A?_KL?
+&G????GAB?`AG
+&G???AOGA?SH?
+&G???O_C@?cCG
+&G?????`B?I?o
+&G????_@@_@P_
+&G???OAA?GG[?
+&G????_G@_@X?
+&G???O?OP?HI?
+&G???G@CA?D?g
+&G?@A?@?P?GE?
+&G???G_CA?AX?
+&G???O?gA?WI?
+&G???OOGA?KGG
+&G?A?OOGA?CK?
+&G??A?_C@?QGG
+&G?????GAAKK_
+&G?????`B?I@O
+&G????_?D_`H?
+&G???OAA?OG[?
+&G????_A?GaL?
+&G???O?OP?DI?
+&G???AACA?`G_
+&G?G?GA?O_OE?
+&G????_A?_gL?
+&G???O?gA?WH?
+&G???A_C@?cK?
+&G?A?OOGA?GK?
+&G?????K?oaGO
+&G????G@B?B@_
+&G????_@@_`H?
+&G????GAB?K@O
+&G????O@A_`H?
+&G???G@G@?IAO
+&G???G@G@?aGO
+&G???G_CA?EH?
+&G????OCA_oGO
+&G???OOGA?KI?
+&G???O_C@?cK?
+&G??A?_C@?gE?
+&G??????B?JJ?
+&G??????PAcM?
+&G?????A?GkK_
+&G??????GogKO
+&G?????_D_oGO
+&G????G@?AgL?
+&G??????OQgK_
+&G?????G?GYDO
+&G????A?GGgL?
+&G?????A?_kK_
+&G?????_E_PH?
+&G????G@?AaL?
+&G???O?P?AgK?
+&G????OC?AcM?
+&G??????HOWGo
+&G??????GWgKO
+&G?????_E_o@O
+&G????A?GOgL?
+&G????AC?GWHG
+&G????_@?OIKG
+&G???C@?I?G[?
+&G???OAG?_AM?
+&G?????HB?H?g
+&G?????@?IgK_
+&G?????`A_o@O
+&G?????G@O`M?
+&G????_@?ao@O
+&G????GG?GEL?
+&G???@G?Q?HK?
+&G????OG?OcM?
+&G????O?GOcM?
+&G???C?_E?PK?
+&G?????g?GIL?
+&G????AA?AaL?
+&G???OAG?OAM?
+&G????GA?AgL?
+&G???C?_E?aCO
+&G???C?_E?WCO
+&G?A?O_A?O?[?
+&G???A?S@?aK?
+&G????O?GOWH_
+&G?????_P@WH?
+&G???@@?I?HK?
+&G???O?Q?AgK?
+&G??@?AC?GGJ?
+&G???C@?E?WGG
+&G?G?O_@?@OE?
+&G?A?O_C?O?[?
+&G????O@@_@X?
+&G????G?J?c@O
+&G???CG?Q?G[?
+&G????_?H_oGO
+&G???G@C@?@W_
+&G???C?SA?BG_
+&G?@A?_@@?GE?
+&G???@ACA?aK?
+&G????@?EAID?
+&G????G?GOPH_
+&G???C@?G@WG_
+&G?????gA?IL?
+&G???O@@?@WGG
+&G??@?A?GGGJ?
+&G?A?OA?C_AK?
+&G???OAGA?CM?
+&G????AA?GPHG
+&G???C@?H?CY?
+&G???CAC?GGJ?
+&G????OC@?IHG
+&G???AOC@?AX?
+&G???GOC@?GJ?
+&G????G@AAQ@O
+&G????G?P?DH_
+&G???C?P@?DI?
+&G????AAA?aL?
+&G????OC?`PH?
+&G????GC@?SH_
+&G???@GC@?WG_
+&G????GG?_gL?
+&G???O@?G@SG_
+&G???C?OH?DI?
+&G?A?OA?C_CK?
+&G???@?c@?WG_
+&G?A?OA?D?CK?
+&G?G?O?`?@OE?
+&GOA?OA?P?G?_
+&G?A?O_G?_?[?
+&G??_O_@?@OE?
+&G?@A?_G?@OE?
+&G???O@A@?@Y?
+&G???AACA?D?o
+&G??a?A?O_OE?
+&G???AACA?cG_
+&G???OAGA?SGG
+&G???AOGA?EH?
+&G?A?O_G@?GK?
+&G???AOG@?cK?
+&G????@?H?HH_
+&G???G@?P?AJ?
+&G????O?H?WH_
+&G???C?OH?KGO
+&G?@?GAG?O?U?
+&G???@?gA?IK?
+&G????_@?BSA_
+&G????O?Ggc@O
+&G???C@@@?CY?
+&G????@C@_OX?
+&G???O@A@?GWO
+&G???O?Q@?HGO
+&G?@?G_@@?GE?
+&G???O?QA?gK?
+&G???GOC@?AJ?
+&G?G?GAGA??U?
+&G????OC@_@X?
+&G???O@@@?@Y?
+&G???GOC@?AX?
+&G???GAGA?WGG
+&G???OAGA?C[?
+&G?@A?@?O_OE?
+&G?@A?_G@?GE?
+&G?A?O_G@?CK?
+&G????OG?gD@_
+&G???OACA?D?o
+&G????_AB?a?o
+&G????GGAASH?
+&G???OACA?cG_
+&G????_C@_oGO
+&G???GOGA?EH?
+&G???O_G@?SK?
+&G??????B?MM?
+&G??????OooM?
+&G????_@?OWM?
+&G??????OoKK_
+&G????@?D_WH?
+&G???O@@?AoK?
+&G??????J?KK_
+&G????AA?GoL?
+&G????GA?_oL?
+&G?????K?oo?o
+&G????G@B?o@O
+&G????_G@_WGO
+&G??????QOEM?
+&G?????_P_oH?
+&G???@@?Q?WK?
+&G????AA?GHL?
+&G???C@?I?SI?
+&G?AA?A?O_AK?
+&G????@?J?KA_
+&G???C@?I?WC_
+&G???AOC@?cI?
+&G????G@B?I@O
+&G???CACA?BI?
+&G???O_C@?gD?
+&G?????C?GkKO
+&G????AC?AgL?
+&G???O_?P?@M?
+&G?????a?GHL?
+&G???C?_E?gD?
+&G?AA?A?O@AK?
+&G????@?I?WH_
+&G???G@G@?@J?
+&G???GOG@?OJ?
+&G????_@@_@W_
+&G???CACA?AY?
+&G???O_C@?gCG
+&G?????@AOBM?
+&G????G?I_o@O
+&G???C@CA?A[?
+&G????AA?_BL?
+&G???G?S@?BI?
+&G?GA?A?GGOE?
+&G????G?R?I@G
+&G???GACA?@Y?
+&G??@?_C@?CY?
+&G????GAB?D@_
+&G???O_C@?E?o
+&G??@?OGA?KI?
+&G????_@?OBM?
+&G???C@?E?KK?
+&G?@?O_?Q?@E?
+&G????GA?_BL?
+&G???@OC@?BH?
+&G?GA?A?Q?AE?
+&G???C@?CGKK?
+&G?@?OA?Q?@E?
+&G?@?OAGA?_E?
+&G????_G@_`@_
+&G???OOGA?BH?
+&G??A?_C@?KK?
+&G?????_OOaM?
+&G???OA?G@gK?
+&G?A?O?OQ?@K?
+&G???OA?OACM?
+&G?A?OA?O_?[?
+&GOA?OA?OACC?
+&G???@@?GGKK?
+&G?@?CA?E?@E?
+&G?@A?A?E?_E?
+&G???OA?O_G[?
+&G?G?OA?O_OE?
+&G?A?OACA?_K?
+&G????_?OOEM?
+&G???O@?E?HK?
+&G?G?AAG?GOE?
+&G????GA?GHL?
+&G???@@C@?SG_
+&G?AA?A?Q?AK?
+&G???G@@?@KK?
+&G?@?AAG?GOE?
+&G?@?A_GA?OE?
+&G????_@@_`G_
+&G???CACA?gG_
+&G???O_C@?gK?
+&G?????@?OwGo
+&G????GA?AoH_
+&G??@?O?Q?@J?
+&G?????a?_BL?
+&G???A?S@?BI?
+&G?GA?A?O@AE?
+&G????GA?Ao@o
+&G???AOC?A_B_
+&G??A?_C@?OB_
+&G????_G@_@P_
+&G???O_C@?B@G
+&G??@?OGA?KGG
+&G?????@AGDM?
+&G????O?Q_OX?
+&G???C@CA?OW_
+&G????A?O_IL?
+&G???CG?I?SI?
+&G?AA?A?P?AK?
+&G????_?P__P_
+&G???C@G@?IGG
+&G??A?OC@?KGG
+&G????G@B?I?o
+&G???CACA?II?
+&G???O_C@?gE?
+&G?????G?WEM?
+&G????_?R?KB?
+&G???GAGA?PCO
+&G?????A?oKK_
+&G????O?D_WH?
+&G???O@@A?oK?
+&G????@@B?IA_
+&G???O@?Q?WE?
+&G???O_GA?WE?
+&G?????EAOcG_
+&G????O@A_gH?
+&G????_GB?WE?
+&G??????B?MJ?
+&G??????P_cM?
+&G??????Q_KK_
+&G????@?F?WH?
+&G??????POgK_
+&G????AC?GgL?
+&G?????I?oo?o
+&G????G@A_o@O
+&G????@?P?WH_
+&G???C@?I?KK?
+&G?????_F?aB?
+&G???OA?GOgK?
+&G????_@B?I@G
+&G???O@AA?HK?
+&G????@?P?gH_
+&G????OC@?gH_
+&G????G@B?a@G
+&G????OCA_OX?
+&G????_AB?E@_
+&G????_AB?KB?
+&G?????G?GwF?
+&G????G?GOoM?
+&G?????a?GgL?
+&G???@@?I?WK?
+&G?????c?GgL?
+&G???O_?P?CM?
+&G????_@B?W?W
+&G???G@CA?A[?
+&G???GAC@?@J?
+&G?@?O_?Q??U?
+&G???C?_E?aD?
+&G?A?O?OQ?GK?
+&G???CAC@?@Y?
+&G?G?C_@@?GE?
+&G???GACA?@J?
+&G??@?O?Q?OJ?
+&G???CAG@?@Y?
+&G???O_C@?aCG
+&G???O_G@?B?o
+&G???O_G@?QC_
+&G??????R?EM?
+&G?????_P_WH?
+&G????AG?GHL?
+&G???C@?I?cE?
+&G????@?J?cA_
+&G???C@?I?gC_
+&G????_@B?I@O
+&G???CAC@?BI?
+&G????OC@?HH_
+&G???AOC@?BH?
+&G???O@@?AQI?
+&G?A?OA?O_AK?
+&G????_GAAID?
+&G???O@C@?SG_
+&G???A@?P?EI?
+&G???AOC@?EI?
+&G???OA?P?DI?
+&G???OAGA?cE?
+&G????_CAGaB?
+&G????GC@_WH?
+&G?????`?GoM?
+&G???OA?CAoK?
+&G???O_?OOAM?
+&G?AA?A?O_?[?
+&G???@A?OAgK?
+&G?AA?A?O@GK?
+&G???OA?Q?@[?
+&G?GA?A?O_OE?
+&G??@?O?P?AJ?
+&G?GA?A?Q??U?
+&G?A?O?OO_AK?
+&GOA?OA?OAC?O
+&G???O@C@?OW_
+&G?AA?A?Q?OK?
+&G?@?O_?OA?U?
+&G?GA?A?O@_E?
+&G?G?AA?O_OE?
+&G?AA?A?P?_K?
+&G???OACA?PCO
+&G???OACA?oK?
+&G?????@?GwKO
+&G????AA?AoL?
+&G?????a?G`L?
+&G???C?_E?WD?
+&G????@?H?gH_
+&G???G@G@?AJ?
+&G????O@A_@W_
+&G???CAG@?AY?
+&G???GA?OAOJ?
+&G?@?OA?Q??U?
+&G???A@?D?EI?
+&G?@?CA?E?CE?
+&G???OA?P?CY?
+&G?@?CAG@?GE?
+&G???C@?I?OB_
+&G???C_G@?_B_
+&G???G@CA?K?g
+&G???OOGA?IGG
+&G???OACA?HAO
+&G???OACA?gI?
+&G?????A?_sK_
+&G????GA?AoL?
+&G?????a?_aL?
+&G???@?c@?gG_
+&G????O?H?gH_
+&G???GOG@?AJ?
+&G????OCA_@X?
+&G???GOG@?AX?
+&G???GA?P?OJ?
+&G?@?OAGA??U?
+&G???A?S@?EI?
+&G?@A?A?E?CE?
+&G???OAC@?CY?
+&G?@?C_G@?GE?
+&G???C@G@?_B_
+&G??A?_CA?OB_
+&G???O_C@?I@G
+&G??A?OG@?KGG
+&G???O_G@?HAO
+&G???O_G@?WE?
+&G?????@B?BM?
+&G????G?J?o@O
+&G????AG?_BL?
+&G???G?W@?BI?
+&G????G?R?a@G
+&G???GAG@?@Y?
+&G????_AB?D@_
+&G???O_G@?E?o
+&G????GA@?HH_
+&G???AOGA?BH?
+&G???OA?D?DI?
+&G?@A?A?GGOE?
+&G????GGAAQH?
+&G???O@CA?cG_
+&G???C@CA?K?g
+&G??A?OC@?EAG
+&G???OACA?IAO
+&G???O_CA?II?
+&G????_C?oKA_
+&G????GCB?oH?
+&G?????@B?DM?
+&G????_?H_WGO
+&G????AG?_IL?
+&G???AACA?SG_
+&G????@CA_OX?
+&G???GACA?WGG
+&G????_AB?K@O
+&G???GOCA?EH?
+&G????GA@?WH_
+&G???AOCA?EK?
+&G???GG?I?SI?
+&G?A?OACA?CK?
+&G????GC@_GX?
+&G???OACA?SK?
+&G???GACA?KGG
+&G??@?OG@?KGG
+&G???OACA?II?
+&G???O_G@?gE?
+&G????_AB?QC_
+&G????_CA_gE?
+&G?????G@?GN_
+&G?????C?__^?
+&G????_?D?GN?
+&G????OA?@_]?
+&G????_?O@ON?
+&G?????W?OO]?
+&G??A?A?D??]?
+&G???O?OE?O[?
+&G?????C?O_Mo
+&G?????@A?O]_
+&G????GC?@_L_
+&G????GC?@_\?
+&G?????CA?C]_
+&G?????G@@C]?
+&G????_C?@G\?
+&G????_?R?PAO
+&G??A?A?CA?]?
+&G???O?OO@_[?
+&G?G?O?OO@?[?
+&G?G?OO?P?OK?
+&G????GG?@@L_
+&G????G?CG_\?
+&G??A?O?O@?Z?
+&G???O?_I?PCG
+&G????_?CGG\?
+&G????@@B?`AO
+&G???O?_I?`CG
+&G???O@?Q?`CO
+&G?????G?_CKw
+&G?????A?O_[o
+&G????_C?_?Xo
+&G????OA?@_X_
+&G?????G?_C[o
+&G?????@A@G[_
+&G????_A?@OX_
+&G????O?E@GX?
+&G?????G?`C[_
+&G?????KAGI@_
+&G????_?D@GX?
+&G????_@AOSB?
+&G????A?E?ON?
+&G?????W@?C]?
+&G???O?OE?OM?
+&G???@?W@?G[?
+&G???O?OO@_M?
+&G???@A?E?G[?
+&G?A?@A?E??[?
+&G?G@?_?P?OE?
+&G????G?O@_L_
+&G????G?E?A\?
+&G???GO?E??Z?
+&G???@?SA?GW_
+&G????A?E?G\?
+&G????@C@_`@O
+&G???O?_I?gCG
+&G???GAC@?IG_
+&G?A?@A?CA?[?
+&G?G@?@?H?OE?
+&GOAA?AG?A_G?
+&G?G?O_?Q?_K?
+&G???GO?CA?Z?
+&G???@A?D?GWO
+&G?G?CA?C@?U?
+&G?@@?_?P?OE?
+&G???G@?GAWGG
+&G???CA?P?HGO
+&G?A?OO?P?OK?
+&G???O_GA?aK?
+&G?????c?_?Xo
+&G????OA?@@X_
+&G???C_C?@?R_
+&G???@?W@?GOo
+&G????G?O@OX_
+&G?????cAAI@G
+&G???O?_H?HGG
+&G???CGA@?KI?
+&G?????P@@GW_
+&G????_@@OK@_
+&G???OAA?_gE?
+&G????_GB?gH?
+&G?????G?_oN?
+&G????_A?@oM?
+&G?????W@?cM?
+&G???@?W@?gK?
+&G????AGA?ON?
+&G???O_G@??]?
+&G????_G@?C]?
+&G???@_G@?C[?
+&G?????W?OoM?
+&G???O?_I?oK?
+&G???@A?E?gK?
+&G?AA?AAA?GK?
+&G???O_?O@_M?
+&G?AA?A?E??[?
+&G???O?WA?A[?
+&G?GA?_?P?OE?
+&G?????@A?oM_
+&G????GG?@oL?
+&G????G?E?aL?
+&G???@?SA?gG_
+&G????G?Q?_L_
+&G???GOGA??Z?
+&G????GGA?A\?
+&G???@OGA?AX?
+&G?????GB?C]?
+&G????O?P_WGO
+&G????@GA_PH?
+&G???GAC@?WG_
+&G????AGA?G\?
+&G???AAGA?cCG
+&G????OC@_`@O
+&G???OOC@?EH?
+&G?????W?OSM?
+&G???@G?E?WK?
+&G???@?QA?KK?
+&G?@?O_G?OOE?
+&G???OA?CG_M?
+&G?A?O?W?O?[?
+&G???O?PA?G[?
+&G?G?C_?P?OE?
+&G???@A?C_gK?
+&G?AA?AA@?GK?
+&G?@?O_@?GOE?
+&G?GA?AGA?OE?
+&G?A?O?OO@CK?
+&GOA?O_?Q?_@?
+&G?G?C@?H?OE?
+&G?AA?AGA?GK?
+&G????G?CGaL?
+&G???O?_I?PD?
+&G???@?Q@?KGO
+&G?@?OAG?OOE?
+&G???GO?O@@J?
+&G?@A?A?CG?U?
+&G???O?P@?GWO
+&G?@?C_?P?OE?
+&G????@@A_PH?
+&G???O@?Q?cCO
+&G???C@A@?KGO
+&G???O_GA?EK?
+&G???O@?OAWGG
+&G?A?OAC@?AK?
+&G???O@@@?HGO
+&G???GAGA?gK?
+&G????AG?OON?
+&G???O_C?_?]?
+&G???OA?C__M?
+&G?A?O?W@??[?
+&G????GA?O_L_
+&G??@?OG?@GJ?
+&G????GG?OG\?
+&G???@ACA?OW_
+&G???O_?O@GM?
+&G?AA?A?D??[?
+&G?A?O?OO@OK?
+&GOA?O_?Q?_C?
+&G??@?O?O@GJ?
+&G?GA?A?C@OE?
+&G???G@?I?PGG
+&G?AA?AC@?GK?
+&G????G?Q?AL_
+&G???GOG?@GJ?
+&G???GO?O@GJ?
+&G?@A?A?C@OE?
+&G????OC?_CHo
+&G??A?_C?_?R_
+&G????GC?OGX_
+&G???AAG@?BGG
+&G????AG?OG\?
+&G???O@?I?cCG
+&G???OA?OASGG
+&G?A?OAC@?GK?
+&G????OC?OGX_
+&G???AAC@?BGG
+&G????O@@@GX?
+&G???O@?Q?cD?
+&G????_C?AC]?
+&G???A?SA?A[?
+&G???O?OI?G[?
+&G?G?C_?D?OE?
+&G????GG?AG\?
+&G???A?SA?OW_
+&G????O?H_`GO
+&G???AAGA?QC_
+&G???O?OI?@[?
+&G?GA??OP?OE?
+&G?G?A?OP?OE?
+&G?AA?AGA??[?
+&G???O?_E?PGG
+&G?AA?AC@??[?
+&G???O@?I?PCO
+&G???AAGA?oK?
+&G????GG?AA\?
+&G???A?SA?@W_
+&G???O?OH?GWO
+&G?@?C_?D?OE?
+&G????OA?AOX_
+&G???A?W@?BGG
+&G????G?P@OX?
+&G???CG?I?WE?
+&G????O?D_`@O
+&G???G?c@?BG_
+&G???O@?H?HGO
+&G???AAGA?cK?
+&G????G?O`OX?
+&G???CG?I?gE?
+&G????O?QOcB?
+&G????_?R?oI?
+&G?????@A?QM_
+&G????GC?@cL?
+&G????G?E?EL?
+&G???@?SA?IG_
+&G????G?OO_L_
+&G??@??g?@GJ?
+&G????G@A?A\?
+&G???G?SA?GW_
+&G????G?CGcL?
+&G???O?_I?PCO
+&G???@A?D?HGO
+&G?G?AA?GAOE?
+&G??@??_O@GJ?
+&G?G?AA?C@OE?
+&G???CA?D?GWO
+&G?@?O_?P?OE?
+&G?????@?_aKo
+&G????GC?@cH_
+&G????GC?@DH_
+&G???@?SA?I?o
+&G????OA?ACHo
+&G???COG?O?R_
+&G????GC?O@X_
+&G???@ACA?COo
+&G?????@AGG[_
+&G????G?IASD?
+&G????G?IAS@_
+&G???CGA@?DI?
+&G????G?OOOX_
+&G???O@?H?HGG
+&G????G@AAS?g
+&G???C@A@?KI?
+&G?????G?PPM?
+&G????_?R?OQO
+&G?????g?ao@O
+&G???GAC@?GW_
+&G????A?I?G\?
+&G???O?OI?gCG
+&G?????c@_`@O
+&G???@AC@?IG_
+&G????@@B?_QO
+&G???O@?Q?PGG
+&G???CA?P?GWO
+&G???O_GA?A[?
+&G???G@?G@SGG
+&G?A?O?OP?OK?
+&G???@A?P?HGO
+&G???@AGA?gK?
+&G?????@AAG[_
+&G????O?C``H?
+&G?????cAAI@O
+&G???CGA@?CY?
+&G????G?OAOX_
+&G???O?OH?HGG
+&G????@CAAI@G
+&G???C?Q@?KI?
+&G?????KAAEA_
+&G????_@AAKD?
+&G????O@?oc?o
+&G????_GA_o@O
+&G????@@@@GW_
+&G???O@A?AWI?
+&G????O?Ooc@_
+&G????@GB?gH?
+&G?????CA?EMG
+&G????_C?@KKG
+&G?????W?OHKG
+&G???O?OE?WGG
+&G?????AA?KKg
+&G????OG?@WHG
+&G?????G?oG[O
+&G????G?J?HGG
+&G?????W?OIKG
+&G???O?OE?PGG
+&G???G@?C@WGG
+&G?A?O?OOOCK?
+&G????O?CGWHG
+&G???O?_I?@[?
+&G?????`B?HGG
+&G???@AA?_gK?
+&G?????AA?DKg
+&G????OG?@IHG
+&G????O?CGHHG
+&G???O?_H?@Y?
+&G?????C?OWGw
+&G????_A?@o@g
+&G?????A@OOWo
+&G????G?F?_PO
+&G?????G?WG[O
+&G????G?O`PH?
+&G????@@?`PG_
+&G???O@?OAWGO
+&G?????A?oOWo
+&G????O?D__PO
+&G?????KAAEAG
+&G????@@B?cB?
+&G?????A@?[Gg
+&G????OA?AWHG
+&G????A?H?WHG
+&G???COC?OCJ?
+&G?????AA?K[_
+&G????_A?AKKG
+&G?????A?o`KO
+&G????GA?OcL?
+&G????O?GGWHG
+&G??@?O?O_GJ?
+&G??@??_O_GJ?
+&G???O_?Q?_M?
+&G?????g?OIKG
+&G???O_?O_GM?
+&G????G@?GcL?
+&G????_G?OoM?
+&G?????A@?LGg
+&G????OA?AQHG
+&G????A?H?HHG
+&G???CAC?OCJ?
+&G?????C?OWWo
+&G????_A?AEKG
+&G?????A?W`KO
+&G????AA?OcL?
+&G?????A?oPGo
+&G????OC?OKH_
+&G????G?OOSH_
+&G????AGA?gL?
+&G?????G?WHKO
+&G????AG?OKL?
+&G?????@AGIK_
+&G?????GB?cM?
+&G?????CA?SM_
+&G?????G@OO]?
+&G????_C?@gL?
+&G????G?Q_oGO
+&G????_G?GON?
+&G????OG?OO]?
+&G??A?AG@??]?
+&G???@ACA?O[?
+&G????_?CGgL?
+&G????@@A_oGO
+&G???O?_I?`K?
+&G???O@?Q?`K?
+&G??A?AG?A?]?
+&G???O?OQ?_[?
+&G?G?O_?O@?[?
+&G?G?O_?P?OK?
+&G?????G?_cKo
+&G?????@A@gK_
+&G????_A?@oH_
+&G????O?E__X?
+&G????GGA?@L_
+&G????GG?G_\?
+&G??A?O?Q??Z?
+&G???@@CA?_W_
+&G?????GA_C[_
+&G?????KA_a@_
+&G????_?F?GX?
+&G????_@B?cB?
+&G????_G?GG\?
+&G????_@B?`AO
+&G???@@GA?OW_
+&G???G@GA?aC_
+&G????A?E?IL?
+&G????_?R?I?o
+&G???O?_I?gD?
+&G???GAC@?II?
+&G???O?P?G_M?
+&G???@G@A?G[?
+&G?A?@AAA??[?
+&G?G@?_?O_OE?
+&G???G@?GAWG_
+&G???CA?P?HI?
+&G?A?OO?O_GK?
+&G???O_GA?aC_
+&G?A?@AA?A?[?
+&G?G@?@?H?GE?
+&GOAA?AG?AOC?
+&G?G?O_?P?_K?
+&G????G?O@PH_
+&G????O?Ooa?o
+&G???AG?H?DI?
+&G???O@@@?KI?
+&G???GO?CG@J?
+&G???@G@@?GWO
+&G?G?CA?O@?U?
+&G?@@?_?O_OE?
+&G?????`AAID?
+&G????_@@OI@_
+&G???OAA?_gC_
+&G????_GB?cB?
+&G???O@?OAQGG
+&G???CG@@?HGO
+&G?A?OO?OOOK?
+&G???OAGA?aK?
+&G????A?O__L_
+&G????AAA?C\?
+&G???GGCA??Z?
+&G???G?SA?GY?
+&G????G@?__L_
+&G????GG?_C\?
+&G??@?GG@??Z?
+&G???@OG@?CX?
+&G???AG?O@OJ?
+&G???CA?D?GY?
+&G??P?A?E??U?
+&G?@@?_?O_GE?
+&G??@?G?O@OJ?
+&G???O?S@?AW_
+&G?G@?A?E??U?
+&G?G@?_?O_GE?
+&G????A?G_OHo
+&G????@A@?CX_
+&G???O?c?@_B_
+&G???@@CA?CP_
+&G????AC?_OHo
+&G????OA@?CX_
+&G???O_C?@_B_
+&G???A_CA?E@G
+&G????@@@?GX_
+&G????G@AAQ?g
+&G???O@?H?KGG
+&G???O@A@?KI?
+&G????O@@?GX_
+&G????OCAAK@G
+&G???AAC@?EGG
+&G???GGC@?II?
+&G?????aA?A\?
+&G????GGB?@PO
+&G???A?SA?AY?
+&G???O_G@?D@G
+&G?????g?_G\?
+&G????_C@_`?W
+&G???A?W@?SGG
+&G???OOG@?CX?
+&G???AA?D?@Y?
+&G???OACA?AOo
+&G?@A??OP?OE?
+&G???O_G@?`GG
+&G???O?_E?QGG
+&G???OACA?AW_
+&G?A?@ACA?OK?
+&G???O_G@?_[?
+&G????G?H?@X_
+&G????OG?BI@G
+&G???A?SA?D?g
+&G???O@CA?CP_
+&G????G?H?OX_
+&G????GC@@@X?
+&G???@?cA?IGG
+&G???GGCA?GY?
+&G????G?EAQ@G
+&G????_C?oCP_
+&G???O?a@?HI?
+&G????OGA__X?
+&G????@C@@GX?
+&G????GC@Oc@O
+&G???GG?I?gE?
+&G????_AA_oGO
+&G?????CA?EM_
+&G????A?E?KL?
+&G????_C?@KL?
+&G???O?_I?gE?
+&G????_@?GON?
+&G???O?Q?G_M?
+&G??A?AA@??]?
+&G?A?@ACA??[?
+&G????_?CGKL?
+&G???G@?GAgE?
+&G???O?_I?`CO
+&G?A?OO?OOCK?
+&G??A?AA?A?]?
+&G?A?@AC?A?[?
+&G?G?OO?O@?[?
+&GOAA?AG?AOG?
+&G?????G?_EKo
+&G????@A?@SH_
+&G????_A?@SH_
+&G???O?_H?HI?
+&G????GG?G@L_
+&G???GO?CAGJ?
+&G??A?O?G@GJ?
+&G?@A??OG@OE?
+&G?????G?gC[_
+&G?????`AAIC_
+&G????G?IAKD?
+&G???OAA?_gD?
+&G????_@?GG\?
+&G???OA?OAQGG
+&G???O@?I?`CG
+&G?A?OO?O_OK?
+&G?????G@@DM?
+&G????@C@__PO
+&G????_?R?PAG
+&G???GAC@?IGG
+&G?????g?OO]?
+&G???@A?I?G[?
+&G???O?_E?O[?
+&G?G@?A?E?OE?
+&G????@@B?`AG
+&G???CA?P?HGG
+&G???O@?Q?`CG
+&G???O_GA?aCG
+&G???O?_O@_[?
+&G?G@?A?CAOE?
+&G?G?OO?O@OK?
+&G?G?O_?O@_K?
+&G?????@A@HK_
+&G????G?EAAT?
+&G????G?E@PH?
+&G???CGA@?KGG
+&G????G?GG_\?
+&G???@A?H?GWO
+&G???O?OI?PCG
+&G??P?A?E?OE?
+&G?????KAGI@O
+&G????G@A@S@_
+&G????G@AAKD?
+&G????_GB?GX?
+&G?????`B?`AO
+&G???CA?H?HGO
+&G???G@?I?`CO
+&G???O?gA?aK?
+&G?????@@?aMG
+&G????G?E?EKG
+&G????GC?@cKG
+&G???@?SA?IGG
+&G?????C?OcMG
+&G?????W?_KKG
+&G????OA?@gKG
+&G???@?W@?WGG
+&G?????Q?OaKG
+&G???@A?D?HGG
+&G???O?OE?PCG
+&G?G?CA?O@@E?
+&G?????Q?OgKG
+&G???O?OE?aCG
+&G???O?_I?O[?
+&G?A?@AAA?GK?
+&G?????@?_`Kg
+&G????OA?@BHG
+&G????OA?@aHG
+&G???@?SA?H?g
+&G?????@?_gKg
+&G????O?C_IHG
+&G????OA?@gHG
+&G???A?cA?AY?
+&G?????@AGG[O
+&G????O?O``@_
+&G????G?Q@PH?
+&G???AGA@?DI?
+&G?????@AOG[O
+&G????@G?`PH?
+&G????O?H_HGG
+&G???GA?I?gC_
+&G?????@@?wGg
+&G????G?I?o@g
+&G????OA?AgHG
+&G???O_C?O_B_
+&G?????G?_[KG
+&G?????g@?WHG
+&G????OA?AgKG
+&G??@?GG@?GJ?
+&G????O?GGgHG
+&G???OOG?O@B_
+&G??A?O?O_GJ?
+&G??A?O?Q?_J?
+&G?????g?OWKG
+&G??@?GG?AGJ?
+&G??A?AA@?GM?
+&G??A?AGA?OM?
+&G?????A@?dGg
+&G????G?I?P@g
+&G????OA?AaHG
+&G???AGC?__B_
+&G?????@?_g[_
+&G?????aA?QHG
+&G????GC?AcKG
+&G???GGCA?GJ?
+&G?????AAOPGo
+&G????GG?OS@o
+&G????_C?OKH_
+&G????_AA?oH_
+&G?????G@OHKO
+&G????G@A?SH_
+&G????_C?OKL?
+&G????_G@?gL?
+&G?????@A?SM_
+&G?????G@OC]?
+&G????GC?@gL?
+&G????G?P_oGO
+&G????G?E?IL?
+&G????@C@_`H?
+&G???@?SA?WG_
+&G???GAC@?gG_
+&G????G?O__L_
+&G????AAA?G\?
+&G???GOCA??Z?
+&G???AACA?cCG
+&G????GAA?A\?
+&G????_C@_`@O
+&G???@OCA?AX?
+&G???OOG@?EH?
+&G????G?CGgL?
+&G????@@@_oGO
+&G???O?_I?PK?
+&G???O@?Q?PK?
+&G???O?_I?PG_
+&G???O@?Q?QCO
+&G?A?O_?O_GK?
+&G???O_GA?QK?
+&G???GOC?A?Z?
+&G???G@?I?SGG
+&G?G?CA?E??U?
+&G?A?O_?P?OK?
+&G???O?S@?@W_
+&G???OACA?BG_
+&G?@A?_?P?OE?
+&G???O_CA?aK?
+&G?????A?OgKo
+&G?????AAOC[_
+&G????OA?@oH_
+&G????O?E_GX?
+&G????OA?@PH_
+&G?????cAAIH?
+&G???A?g@?BI?
+&G???O@@A?WD?
+&G????OA?AOHo
+&G????G?P?OX_
+&G???A_C?@_B_
+&G???AAG@?DGG
+&G????OA@?@X_
+&G????_CAAI@G
+&G???A_G@?B@G
+&G???CGG@?II?
+&G?????AA_C[_
+&G?????KA_P@O
+&G????O?F?GX?
+&G????_@B?SB?
+&G?????cAAID?
+&G????_@@OQB?
+&G???O@@A?gD?
+&G????OCB?WH?
+&G????O?P?GX_
+&G????O@@@GW_
+&G???AAC@?DGG
+&G???OA?Q?cD?
+&G????OCAAI@G
+&G????_CAGI@_
+&G???CGC@?II?
+&G????OGB?gH?
+&G????A?P?_N?
+&G????OG?O@]?
+&G???OAG@??]?
+&G???@ACA?C[?
+&G???OA?O@_M?
+&G???OA?E?G[?
+&G?A?OA?E??[?
+&G?G?G_?P?OE?
+&G???OAG?A?]?
+&G???CA?E?G[?
+&G?A?O_?O@?[?
+&G?G?O_?P?OE?
+&G?A?OA?CA?[?
+&G?@A??_O_GE?
+&GOA?OA?OAGA?
+&G?A?O_?Q?_K?
+&G????G?I?@L_
+&G????GG?G@\?
+&G???GO?Q??Z?
+&G???C?SA?GW_
+&G???GO?OA?Z?
+&G???OA?D?GWO
+&G?@A?A?O@?U?
+&G?@?G_?P?OE?
+&G????A?Q?G\?
+&G????O@@_`?o
+&G???O@?I?gCG
+&G???CAC@?IG_
+&G???OA?OAWGG
+&G???OA?P?HGO
+&G?A?OA?P?OK?
+&G???OAGA?gK?
+&G?????A@?aN?
+&G?????W?OPM?
+&G????OA?@cM?
+&G???O?OE?WK?
+&G????O?E?EM?
+&G???G?OE?KK?
+&G???@?SA?IK?
+&G?@?GAGA?AE?
+&G?????W?OQM?
+&G???O?OO@gK?
+&G???O?OE?PK?
+&G?A?O_?OOCK?
+&G???@A?E?HK?
+&G?@?GAG?G@E?
+&G?G?CA?Q?@E?
+&G?G?CAGA?_E?
+&G?????@A?PM_
+&G????G?CG`L?
+&G????GC?@aL?
+&G???O?_I?PE?
+&G????GG?@BL?
+&G???G?OD?KGO
+&G???@?SA?HG_
+&G?@?GA?Q?AE?
+&G?????G@GC]?
+&G????@@A_PG_
+&G????G?Q_PH?
+&G???O@?Q?gCO
+&G????O?P_`@_
+&G???G@?P?KGO
+&G???GAC@?HG_
+&G???O_GA?IK?
+&G?????CA?cM_
+&G?????GAOO]?
+&G????_C?@WL?
+&G????O?R?WGO
+&G????_?P?ON?
+&G????_G?OO]?
+&G??A?AC@??]?
+&G???@AGA?O[?
+&G????A?E?gL?
+&G????@GA_o@O
+&G???O?_I?gK?
+&G???GAGA?IK?
+&G???O?OQ?_M?
+&G???@AGA?G[?
+&G?A?@AGA??[?
+&G?G@?AGA?OE?
+&G????_?CGIL?
+&G????@@@_PH?
+&G???O?_I?`D?
+&G???O@?Q?`D?
+&G??A?A?O@@M?
+&G???OA?CG_[?
+&G?G?OA?CG?[?
+&G?G?OAC@?AK?
+&G???G@?GASG_
+&G???C@A@?DI?
+&G?A?OAA@?GK?
+&G???O_GA?aD?
+&G?A?@A?O@@K?
+&G?G@?A?GAOE?
+&GOAA?A?Q?_?O
+&G?G?OAGA?AK?
+&G????_?O_AL_
+&G????AA?O_\?
+&G???G_C?@GJ?
+&G???O@?I?SCG
+&G????GG?_CL_
+&G????GA?O_\?
+&G??@?_C?@GJ?
+&G???@AC@?_W_
+&G???CA?D?GJ?
+&G???C?Q@?CY?
+&G??_O?W?@OE?
+&G?@@?AG?OOE?
+&G??@?A?D?GJ?
+&G???@AC@?GW_
+&G?G?O?W?@OE?
+&G??`?AGA?OE?
+&G????_A?AA\?
+&G????G?F?`@O
+&G???A?W@?@W_
+&G???G?g@?BG_
+&G????_A?AG\?
+&G????G?J?HGO
+&G???A?W@?OW_
+&G???AACA?aC_
+&G???O?OH?@Y?
+&G???@ACA?E?o
+&G??a??OP?OE?
+&G???A_CA?aH?
+&G???O?_E?WGG
+&G???G?SA?IG_
+&G?A?OOG@??[?
+&G???@_G@?cK?
+&G?????G?_DKo
+&G?????@A@IK_
+&G????GG?@SH_
+&G????G?IAcD?
+&G????GG?O@L_
+&G????G@?G_\?
+&G??@?_?G@GJ?
+&G???O@?I?PCG
+&G????G?O@SH_
+&G????O?Ooc?o
+&G???O?_H?HGO
+&G???CGA@?KGO
+&G??@?A?CAGJ?
+&G???@A?P?GWO
+&G?G?O?OG@OE?
+&G??`?AG?OOE?
+&G?????G?PHK_
+&G?????KAGI@G
+&G????_?C`PH?
+&G????O@AAKD?
+&G????_?GGG\?
+&G?????`B?HGO
+&G???O?OI?`CG
+&G???G@?I?PGO
+&G?????P?`PG_
+&G????G@AAS@_
+&G???OAA?_WGG
+&G????_GA_PH?
+&G???G@?G@WGG
+&G???CA?D?HGO
+&G?A?OO?O@OK?
+&G???O?WA?aK?
+&G?????G?_DKg
+&G?????A?W_[O
+&G????_A?@QHG
+&G????G?P@PH?
+&G?????G?_KKg
+&G?????A?o_[O
+&G????_C?@WHG
+&G????O?H_`GG
+&G????A?D?HHG
+&G????@CAAI@O
+&G???O?_H?GWO
+&G???@GA@?KGO
+&G????A?D?WHG
+&G????@G?ao@O
+&G???O?_I?G[?
+&G???@GAA?KK?
+&G?????A@?TGg
+&G?????A@OPGo
+&G????OA?AIHG
+&G????GC?OKH_
+&G?????G?_K[_
+&G?????G?oHKO
+&G????GG?AKKG
+&G????GG?OKL?
+&G????O?GGHHG
+&G????GC?ODH_
+&G???GO?O_GJ?
+&G????GGA?aL?
+&G?????g?OHKG
+&G????G@A?EL?
+&G???OAA?__M?
+&G????_G@?cM?
+&G?????C?OcM_
+&G?????@AOO]?
+&G????_A?@WL?
+&G????O?Q_WGO
+&G????_?C_IL?
+&G????@G@_PH?
+&G???@?W@?WG_
+&G???GAG@?WG_
+&G????_?O_GL_
+&G????AA?__\?
+&G???G_C@??Z?
+&G???AAGA?SCG
+&G????_A?_A\?
+&G????OCA_`@O
+&G???@_C@?AX?
+&G???O_C@?EH?
+&G????A?C_gL?
+&G????@G@_o@O
+&G???O?_I?WK?
+&G???GACA?IK?
+&G???O?_I?WG_
+&G???GACA?EI?
+&G?A?OAAA?GK?
+&G??A?_G@?gD?
+&G???G@C?@OJ?
+&G???G?S@?CY?
+&G?@?G_?E??U?
+&G?@@?AGA?OE?
+&G???O?S@?AY?
+&G???O_C@?K@_
+&G??a?_?P?OE?
+&G??A?_C@?gG_
+&G????_?OAON?
+&G????_@?GO]?
+&G??A?A?P??]?
+&G???O@?E?O[?
+&G??A?A?OA?]?
+&G???OA?O@_[?
+&G?G?OA?O@?[?
+&G?G?OA?P?OK?
+&G????GG?_@L_
+&G????GA?G_\?
+&G??A?O?P??Z?
+&G???@@C@?_W_
+&G????_A?GG\?
+&G????G@B?`AO
+&G???@@G@?OW_
+&G???G@G@?aC_
+&G???O?OOA_M?
+&G???@A?Q?G[?
+&G?A?@A?Q??[?
+&G?G@?AG?OOE?
+&G?A?@A?OA?[?
+&G?G@?A?OAOE?
+&GOA?OA?OAA?_
+&G?G?OA?Q?_K?
+&G???GO?D?@J?
+&G???@@C@?GW_
+&G?G?CAG?@?U?
+&G??P?AGA?OE?
+&G???G@?I?WGG
+&G???G@CA?IG_
+&G?A?OO?Q?OK?
+&G???O_C@?QK?
+&G?????C?O`M_
+&G?????@AGO]?
+&G????_A?@QL?
+&G????G?R?PH?
+&G????_A?@BL?
+&G????O?Q_`@_
+&G???@?W@?HG_
+&G???GAG@?HG_
+&G????_?G_@L_
+&G????A?O__\?
+&G???G_?P??Z?
+&G???O@?I?WCG
+&G????_A?G@\?
+&G????G@B?`?o
+&G???C?W@?GW_
+&G???CAG@?IG_
+&G????A?C_`L?
+&G????G?R?c?o
+&G???O?_I?WCO
+&G???C@CA?HG_
+&G???O?OD?BI?
+&G???GAG@?I@O
+&G?@A?A?OOCE?
+&G??A?_CA?EI?
+&G???G?_P??Z?
+&G???O@?D?AY?
+&G?@?CAG?@?U?
+&G?@@?A?Q?OE?
+&G???O?OP?AY?
+&G???G@G@?I@_
+&G??_O_?P?OE?
+&G???O_C@?WC_
+&G?????CA?DM_
+&G?????G@@EM?
+&G????_C?@IL?
+&G????G?P_PH?
+&G????_?CGHL?
+&G????@@@_PG_
+&G???O?_I?`E?
+&G???O@?Q?`E?
+&G?????G?_KKo
+&G?????AA@KK_
+&G????_C?@WH_
+&G????O?E@WH?
+&G?????G?`KK_
+&G?????K?oaA_
+&G????_?D_OX?
+&G????G@B?cB?
+&G????A?E?HL?
+&G????_?R?K?o
+&G???O?_I?gCO
+&G???C@C@?HG_
+&G???G@?GAgD?
+&G???O@?P?BI?
+&G?A?OA?OOCK?
+&G???O_GA?aE?
+&G????O?O@WH_
+&G????_?J?K?g
+&G???O?_I?HK?
+&G???CGAA?KK?
+&G?????P@_OW_
+&G????G@B?c@_
+&G???OAA?_gK?
+&G????_GB?WH?
+&G?????G@?cMG
+&G?????G?_kKG
+&G????_C?@gKG
+&G????_A?AgKG
+&G????_G?OON?
+&G????_C?A_]?
+&G??A?_C?_?]?
+&G???A?W@?_[?
+&G?????W?OgKG
+&G?????g?OgKG
+&G???O?_I?_[?
+&G??A?AAA?GM?
+&G??A?A?E?GM?
+&G???O?OI?_[?
+&G?G?O?W@??[?
+&G?G?OOG@??[?
+&G?????AA?cKg
+&G?????@A?g[_
+&G????OG?@gHG
+&G????GG?AcKG
+&G????GG?G_L_
+&G????GG?A_\?
+&G??A?OG?@GJ?
+&G???A?SA?_W_
+&G?????GAOG[O
+&G?????GAOHKO
+&G????O?H_PGG
+&G????_G?OKL?
+&G????_G?OG\?
+&G????O?H_PGO
+&G???@AGA?OW_
+&G???AAGA?aC_
+&G?????W?OKKG
+&G?????c?OWHG
+&G???O?OE?SGG
+&G??@?GC?_CJ?
+&G???O?Q?O_M?
+&G???@G?I?G[?
+&G?A?@_C?_?[?
+&G?G@?_?D?GE?
+&G???G@?C@QGG
+&G??@?G?O_CJ?
+&G?A?@AA@?GK?
+&G??A?AGA?GM?
+&G?A?@A?D?GK?
+&G?G@??OP?GE?
+&GOAA?AGA?OA?
+&G?G?O_G@??[?
+&G????O?CGIHG
+&G?????a?OQHG
+&G???AG?H?@Y?
+&G???GGC?_CJ?
+&G???GO?CGGJ?
+&G???@G?H?GWO
+&G??a?A?C@OE?
+&G?@@?_?D?GE?
+&G????@@?`PH?
+&G????AC?OIH_
+&G???O@?OASGO
+&G????_G?OgL?
+&G???O@?OASGG
+&G???CG?H?HGO
+&G?A?OOC?_CK?
+&G???AAGA?aK?
+&G????G@?G_L_
+&G?????g?OG\?
+&G??@?GG?@CJ?
+&G???O?OI?cCG
+&G??@?G?O@CJ?
+&G???G@?G@PGG
+&G?G@?A?C@GE?
+&G?A?@AC@?GK?
+&G????AA@?CHo
+&G?????c?OGX_
+&G???OOG?_?R_
+&G???@G?H?HGG
+&G????AC?OGX_
+&G????@@@@GX?
+&G???CG?H?HGG
+&G???CG?OAWI?
+&G????GG?AC\?
+&G????O?D_`?W
+&G???A?SA?AW_
+&G???G?c@?AW_
+&G???O?OH?@WO
+&G???O@?H?@WO
+&G?G@??OO_GE?
+&G???AAGA?_[?
+&G????GC?ACX_
+&G????G?OBOX?
+&G???A?SA?AOo
+&G???CG?H?GY?
+&G????G?EAS@G
+&G????O?Coc@O
+&G???CG?H?HI?
+&G????_?E_oGO
+&G?????AA?EKg
+&G?????A@?UGg
+&G????OG?@KHG
+&G????OA?AKHG
+&G????O?CGKHG
+&G????O?GGKHG
+&G???O?_H?@WO
+&G??@?G?OOCJ?
+&G?????@?_QGw
+&G?????@?_QWo
+&G????GC?@c@g
+&G????OA?AEHG
+&G?????A?WOWo
+&G?????A?WPGo
+&G????G?IACT?
+&G????AC?OKH_
+&G?????G?QG[O
+&G?????C@OHGW
+&G????_?QAGSO
+&G????OC?OKHG
+&G????@@AAOQO
+&G????O@?GKHG
+&G???O@?O@PGG
+&G????_G?OgKG
+&G?????A?QOWo
+&G?????C?WHGW
+&G????G?DA_PO
+&G????AA?OSHG
+&G?????GPAI@_
+&G?????A?WQGo
+&G????@@AAKD?
+&G?????GAOgKO
+&G?????A?OoN?
+&G?????S?_cM?
+&G????AG@?GN?
+&G????_C?_C]?
+&G???@?W@?KK?
+&G???OA?E?OM?
+&G???O?W@?G[?
+&G????GAA?OL_
+&G????GG@?G\?
+&G????_CB?HAO
+&G?????W?OWM?
+&G???@A?E?WK?
+&G???O_?O@OM?
+&G???O?SA?A[?
+&G?@?O_?OO_E?
+&G?A?O?OO@_K?
+&G?G?A_?P?OE?
+&G??@?O?O@_J?
+&G???O?SA?OW_
+&G???OAGA?QC_
+&G?????@A?WM_
+&G????G?D?aL?
+&G????G?P?_L_
+&G????GCA?A\?
+&G???@?SA?KG_
+&G???GO?O@_J?
+&G???O?SA?GW_
+&G????OC?__Ho
+&G????OAA?OX_
+&G????OG?`GX?
+&G?????G@_C]?
+&G????@CB?HH?
+&G????ACA?G\?
+&G????GC@_`@O
+&G???GAC@?KG_
+&G???OA?I?gCG
+&G???OAC@?IG_
+&G????GAA?OX_
+&G????OG@@GX?
+&G????_G@OSB?
+&G???G@?GAoK?
+&G?AA?AA?_@K?
+&G?AA?A?CA?[?
+&G?GA?@?H?OE?
+&G?GA?AGA?@E?
+&GOA?O_?Q?_?G
+&G?AA?AGA?@K?
+&G?GA?A?CA?U?
+&G?AA?AC@?@K?
+&G???G@GA?oK?
+&G????G?CGoL?
+&G???O?_I?PC_
+&G???GOG?A?Z?
+&G???O?SA?@W_
+&G?@?OAG?O@E?
+&G?@A?A?CA?U?
+&G?@?A_?P?OE?
+&G??A?_C?@@B_
+&G???O?g@?BGG
+&G???OA?Q?QC_
+&G????@@@_WGO
+&G???O@?Q?aCO
+&G???G@?I?cCG
+&G???OAC@?BG_
+&G???O_GA?BK?
+&G?A?OAC@?@K?
+&G???CAGA?gK?
+&G???O?c@?BGG
+&G???OA?Q?aC_
+&G????_@B?oI?
+&G?????A?OoKo
+&G????OA?@`H_
+&G?????c?__Ho
+&G????OAA?@X_
+&G???@?W@?K?o
+&G???C_C?A?R_
+&G???O?W@?GOo
+&G????_G@?G@w
+&G????_C?__Po
+&G????_C?`GP_
+&G?????@B?G[_
+&G?????aAAQD?
+&G????G?Q?OX_
+&G????GCAAI@G
+&G???CGA@?EI?
+&G???OA?H?HGG
+&G???CAA@?KI?
+&G????OC?__Po
+&G????_CA@GP_
+&G????_@@GQA_
+&G?????KB?I@_
+&G????_@AGSB?
+&G????_@@@GW_
+&G????_G@OK@_
+&G????_GB?g@_
+&G???OA?O_gE?
+&G????_@B?gG_
+&G????_G@@GP_
+&G????_@AGQA_
+&G?????KB?gH?
+&G?????CA?KM_
+&G?????G@OG]?
+&G????_?O_ON?
+&G????GG?OO]?
+&G????_?D?IL?
+&G????@C@_HH?
+&G??A?A?O@OM?
+&G???OA?E?O[?
+&G????O?O__L_
+&G????AAA?O\?
+&G????GC?__L_
+&G????GC?__\?
+&G????_A@?A\?
+&G????GCB?`@O
+&G????_C?_G\?
+&G????_AB?PAO
+&G????_?CGWL?
+&G????@@B?WGO
+&G??A?AC?A?]?
+&G???O?OQ?O[?
+&G???O?_I?`C_
+&G???O@?Q?`C_
+&G?G?OA?CA?[?
+&G?G?OAC@?@K?
+&G???G_C?A?Z?
+&G???G@?I?SCG
+&G??A?O?O@OJ?
+&G???O?S@?_W_
+&G???O?W@?@W_
+&G???OAG@?BG_
+&G???O?W@?OW_
+&G???OACA?aC_
+&G?????G?_SKo
+&G?????@@@gK_
+&G????GG@?@L_
+&G????GC?G_\?
+&G????_A?@PH_
+&G?????aAAaD?
+&G??A?O?OA?Z?
+&G???OA?I?PCG
+&G????_A?AOHo
+&G????G?P?_X_
+&G????_C?_OHo
+&G????OA@?_X_
+&G????_A@?@X_
+&G????GCAAa@G
+&G????_A@?OX_
+&G????GCA@OX?
+&G?????G@_C[_
+&G?????KA_Q@_
+&G????_C?GG\?
+&G????_@B?PAO
+&G?????aAAID?
+&G????_@AOSA_
+&G???OA?I?`CG
+&G???OA?Q?`CO
+&G????_?P?GX_
+&G????O@A@GW_
+&G????_C@?GX_
+&G????OCA@GX?
+&G????GCAAQ@G
+&G????_CAOK@_
+&G????_C@@GX?
+&G????_CAOSB?
+&G????A?E?WL?
+&G????@AA_o@O
+&G???O?OP?_M?
+&G???@ACA?G[?
+&G???O?_I?gC_
+&G???GAC@?EI?
+&G?A?@A?O@_K?
+&G?G@?A?I?OE?
+&G???G@C?@_J?
+&G???G?SA?CY?
+&G???GO?E?OJ?
+&G???@OG@?GX?
+&G???O?SA?AY?
+&G???O_G@?K@O
+&G???O?g@?WGG
+&G???OOG@?KH?
+&G???O?_OAgK?
+&G???CA?Q?HK?
+&G?A?@AG?A?[?
+&G?G@?AG?AOE?
+&G?A?OAA?_@K?
+&G???O_GA?aCO
+&GOAA?A?Q?_?G
+&G?G?OAGA?@K?
+&G?@?A_?O@?U?
+&G?@@?AG?AOE?
+&G?G?CA?C@_E?
+&G?@@?_G?AOE?
+&G?@A??_P?OE?
+&G???O_G@?aGO
+&G?A?OO?P?_K?
+&G???O_G@?aK?
+&G????G?O@oH_
+&G????G?J?c?g
+&G???GO?E?@J?
+&G???@@CA?GW_
+&G???AA?H?DI?
+&G???O@@@?EI?
+&G?G?AA?O@?U?
+&G??P?A?I?OE?
+&G???C?c?@_B_
+&G???@@CA?GP_
+&G???C_C?@_B_
+&G???A_CA?EAG
+&G???O?cA?H?g
+&G???O@CA?K@_
+&G???O?cA?IGG
+&G???GGCA?KI?
+&G?????PB?GW_
+&G????_@B?K@_
+&G???G@?I?gCG
+&G???G@C@?IG_
+&G???OAA?_gCO
+&G????_GB?cA_
+&G?A?OO?P?AK?
+&G???OAGA?`K?
+&G???G@?H?KGG
+&G???O@A@?II?
+&G???O?c@?IGG
+&G???GGC@?KI?
+&G???OAA@?HI?
+&G????_AB?cG_
+&G???OAAA?gE?
+&G????_CB?gH?
+&G?????C?_cMG
+&G?????A?OkKG
+&G????_@@?GN?
+&G????OA?A_]?
+&G?????W@?KKG
+&G?????c?_WHG
+&G???O?QA?OM?
+&G???@?g@?G[?
+&G????G@A?OL_
+&G?????g@?G\?
+&G????_G@?GN?
+&G???O?PA?OM?
+&G????GG@?C\?
+&G????OA@_`?W
+&G????_C?__]?
+&G???@GG@?G[?
+&G?????W?OWKG
+&G?????a?OgKG
+&G??A?A?D?GM?
+&G???O?OI?O[?
+&G???O?OE?QGG
+&G??@?GC?AGJ?
+&G?A?@A?E?OK?
+&G?G@?_?G@OE?
+&G??@?G?O@_J?
+&G???O?_E?aCG
+&G??A?A?E?OM?
+&G?A?@A?E?GK?
+&G???O?SA?AW_
+&G???OAC@?AW_
+&G???O?W@?_[?
+&G?G@?_?P?GE?
+&G?????AA?SKg
+&G?????@A?W[_
+&G????GC?G_L_
+&G????GC?A_\?
+&G????O?E?IHG
+&G?????a@?QHG
+&G???GO?E?GJ?
+&G???@?cA?GW_
+&G????AA@?_Ho
+&G????G?I?OX_
+&G????GGA?OL_
+&G???GO?E?AJ?
+&G????GCA?CX_
+&G????OG?`@X?
+&G????GG@?_\?
+&G???@GCA?GW_
+&G?????G@OG[O
+&G?????@AOHKO
+&G????_C?OG\?
+&G????O?H_HGO
+&G????@C@@HH?
+&G????O@@?KH_
+&G???OA?I?cCG
+&G???G?c@?IG_
+&G????G@A?OX_
+&G????@G@@GX?
+&G????_G@?G\?
+&G???GA?I?gCG
+&G????GCAAS@G
+&G????OC?oc@O
+&G????_CB?`AO
+&G???GGC@?IG_
+&G???O?_OA_[?
+&G??A?AA?_@M?
+&G?G?O?OO@OK?
+&G?G?OO?P??[?
+&G?A?@AA?_@K?
+&G??A?AGA?@M?
+&GOAA?AG?A_C?
+&G?G?O_?Q??[?
+&G?G@?A?CA?U?
+&G?A?@AC@?@K?
+&G?G?O?OO@_K?
+&GOAA?AG?A_A?
+&G?G@?@?G_GE?
+&G???G@GA?_[?
+&G?G?OO?P?_K?
+&G?G?O_?Q?OK?
+&G????O?CGgHG
+&G?????a?OaKG
+&G??A?O?O@GJ?
+&G???O?_E?PCG
+&G???AA?H?@Y?
+&G???GGC?AGJ?
+&G??Q?A?C@OE?
+&G?@@?_?G@OE?
+&G???OOG?@@B_
+&G???@A?H?HGG
+&G??A?O?O@_J?
+&G?G?GA?CA?U?
+&G???O?SA?AOo
+&G???CG@@?GY?
+&G???O?SA?_W_
+&G?@@?_?P?GE?
+&G?????`B?`AG
+&G????_@?GKL?
+&G???G@?I?`CG
+&G???O@?I?`CO
+&G???O@?OAQGO
+&G????_G?GgL?
+&G?A?OO?P?GK?
+&G???AAGA?`K?
+&G???CA?H?HGG
+&G???CG@?AWI?
+&G???O?WA?OW_
+&G?A?OO?P?CK?
+&G???CG@@?HI?
+&G????_@A_oGO
+&G???OAGA?aC_
+&G???G@GA?aK?
+&G?????A?OoGw
+&G?????A?OoWo
+&G????_C?_CHo
+&G????OA?A_X_
+&G????OA?@`@g
+&G?????c?_BHG
+&G???C_C?@GB_
+&G???@?g@?GOo
+&G????AG@?G@w
+&G????OA?A_Po
+&G????_C?__Ho
+&G???C_C?@@B_
+&G????_C?_CPo
+&G????_C?`@P_
+&G????OAA?_X_
+&G???@GG@?GOo
+&G?????AAOOWo
+&G?????@AGHKO
+&G????_C?OGX_
+&G????G?Q@OX?
+&G?????aAAAT?
+&G????@@@?KH_
+&G???O?a@?HGG
+&G???CG?H?KI?
+&G????GG?OOPo
+&G????O?O`_P_
+&G????_AA?OX_
+&G???O?`@?HGG
+&G????GCA@CP_
+&G????O@?ga?o
+&G????OGA@GX?
+&G???CG@@?KI?
+&G?????KAGH@O
+&G?????G?gEK_
+&G????_@@@GX?
+&G????_?QOSB?
+&G????@@AGSB?
+&G?????GA_cK_
+&G???OAA?_aC_
+&G????_?F?gH?
+&G????_@@@GP_
+&G????@@AGQA_
+&G????_G@@GX?
+&G???OAA?_cD?
+&G????_@@GI@_
+&G?????KA_cG_
+&G????_GAOSB?
+&G????_@B?gH?
+&G?????CA?KKg
+&G?????CA?K[_
+&G?????C?o_[O
+&G?????@?oHKO
+&G????GC?O_L_
+&G????_C?AG\?
+&G????GC?O_\?
+&G????O?J?HGO
+&G????_C@?GN?
+&G??A?A?D?AM?
+&G????OC?__]?
+&G???O?PA?O[?
+&G????_?CGWHG
+&G?????a?OIKG
+&G?????`B?HAG
+&G????G@?GKL?
+&G??@?_?O@GJ?
+&G???O?_E?`CG
+&G???G@?I?PCG
+&G???O@?I?PGO
+&G??A?A?D?OM?
+&G?G?O?OO@CK?
+&G???O?S@?_[?
+&G?G?OO?P?CK?
+&G?????G?OWGw
+&G?????G?OWWo
+&G?????C?o_Wo
+&G?????@?gHKO
+&G????OG?_CHo
+&G????_A?AOX_
+&G????GC?O_X_
+&G????G?P@_X?
+&G????GG@?OL_
+&G??A?O?O@@J?
+&G????GC@?_\?
+&G???GA?I?PCG
+&G?????G?oOWo
+&G?????@?WHKO
+&G?????K?aI@G
+&G?????A?gEK_
+&G????GG?OOX_
+&G????_?O`OX?
+&G????O@A@GX?
+&G????O?QOSB?
+&G????_C@?G\?
+&G???GA?I?`CG
+&G????_GB?PAO
+&G???O@@A?`CO
+&G????A?E?WHG
+&G?????a?OHKG
+&G????@A?ao@O
+&G????G@?_EL?
+&G??@?A?E?GJ?
+&G???O?_E?gCG
+&G???@ACA?GW_
+&G???G?S@?IG_
+&G???O?WA?OM?
+&G?A?@A?E?AK?
+&G???@_G@?G[?
+&G?G@?_?GAOE?
+&G???O?_OAG[?
+&G???OAA?_@M?
+&G???O?P?GKK?
+&G????_G?OaM?
+&G?G?O?OO@OE?
+&G?A?OO?P??[?
+&G??`?AG?AOE?
+&G???@AGA?`K?
+&G?A?@A?E?_K?
+&GOAA?AG?A_?_
+&G?G@?_G?AOE?
+&G?G?O_?Q?CK?
+&G????G?O@o@g
+&G?????a?OBKG
+&G????G?J?D?g
+&G????AA?ODL?
+&G???COG?@CB_
+&G???O?_D?HGG
+&G???@ACA?GOo
+&G???CG?D?KI?
+&G???GO?E?_J?
+&G?G?CA?C@AE?
+&G???@OGA?GX?
+&G?@@?_?GAOE?
+&G?????P@__Oo
+&G????A?OOKL?
+&G????@@B?K@_
+&G?????GAOaM?
+&G???O?_P?HGG
+&G???OAA?AWI?
+&G???CG?P?KI?
+&G????_?Q_oH?
+&G???O?c@?WGG
+&G?A?OO?P?@K?
+&G???OOC@?KH?
+&G???C@GA?aK?
+&G?????G@?aN?
+&G????_C?@cM?
+&G???@?W@?aK?
+&G?????W?OaM?
+&G???O?OE?`K?
+&G?G?OAG?GAK?
+&G?????@A?`M_
+&G????GG?@aL?
+&G???A?g@?`G_
+&G?????GAGC]?
+&G????_?Q_PH?
+&G???GAGA?`C_
+&G?????W?ODM?
+&G???O?OE?KK?
+&G??`?AGA?AE?
+&G???O?OCGKK?
+&G??P?A?Q?@E?
+&G?G@?AGA?_E?
+&G????G?CGBL?
+&G???O?OD?KGO
+&G??`?A?Q?AE?
+&G????@@@_`@_
+&G???O@?P?KGO
+&G???O_GA?KK?
+&G????A?OO_N?
+&G?????@A?EM_
+&G???OAA?@_M?
+&G????GG?@KL?
+&G?A?OOG?@?[?
+&G???A?g@?QG_
+&G???OAA?A?]?
+&G????G?CGKL?
+&G?A?OO?O@?[?
+&G???O?_I?PGO
+&GOAA?A?Q?@?O
+&G?G?OAC?GAK?
+&G????G?GG@L_
+&G?????A?OIKo
+&G???GO?G@GJ?
+&G????OA?@SH_
+&G?@A??_C@OE?
+&G???A?g@?BG_
+&G????A?OOG\?
+&G?????A?gC[_
+&G???OAA?AWGG
+&G????O?IAKD?
+&G?A?OAA@?OK?
+&G???O@@A?`D?
+&G?????g?O@]?
+&G?????G?PDM?
+&G???O?_E?G[?
+&G????_?R?HAG
+&G?@A??W?_GE?
+&G???GAC@?_W_
+&G???O?_O@G[?
+&G????@@B?HAG
+&G?G?O?OP?OE?
+&G???O@?Q?PCG
+&G?A?@AGA?_K?
+&G???O_GA?O[?
+&G????G?GG@\?
+&G?????A?PDK_
+&G???O?_D?GWO
+&G????G?D@PH?
+&G?@?G_?D?OE?
+&G???O@@A?SCG
+&G?????P@_`?o
+&G?????K?aI@_
+&G???O?_P?HGO
+&G????G@AAcD?
+&G???O?gA?gK?
+&G????OCB?WGO
+&G?????@A?EMG
+&G????GG?@KKG
+&G???A?g@?OW_
+&G?????Q?OIKG
+&G???O?OE?`CG
+&G?G?OA?CGAK?
+&G?????@?_HKg
+&G????OA?@IHG
+&G???A?g@?@W_
+&G?????@?WG[O
+&G????_?O`PH?
+&G???GA?I?`C_
+&G?????G@?[Gg
+&G????_C?AWHG
+&G??A?OC?OCJ?
+&G????_?GGWHG
+&G??@?_?O_GJ?
+&G??A?AC@?OM?
+&G?????G@?LGg
+&G????_A?AQHG
+&G??A?AC?OCJ?
+&G?????G?oPGo
+&G????GG?OSH_
+&G????_C@?WL?
+&G?????G@?wL?
+&G????_C?AoM?
+&G???A?W@?oK?
+&G?????g?OgL?
+&G???O_G?_CM?
+&G???@G?I?gK?
+&G?AA?_C?_?[?
+&G????_?F?g?W
+&G???AAGA?A[?
+&G?GA?_?D?GE?
+&G?????G@?hHO
+&G????GG?AcL?
+&G???A?W@?QC_
+&G?????G?QgKO
+&G????_G?OKKG
+&G????O?H_OWO
+&G???AAC@?OW_
+&G?????C@_SGW
+&G????OC?OWHG
+&G??@?OC?_CJ?
+&G???GAC?_CJ?
+&G?@?O_?D?GE?
+&G???G@?CAaCO
+&G?A?O?S?_CK?
+&GOA?O_G@?G@?
+&G???CG?H?@Y?
+&G?G?C?OP?GE?
+&G?????c?OIH_
+&G???CO?OOGJ?
+&G???@G?H?HGO
+&G????AA?OQHG
+&G???CG?H?GWO
+&G?????`?`PH?
+&G???O@?O@SGG
+&G????O@?GIHG
+&G???A?W@?B?o
+&G????_?OBSB?
+&G????G?EAS@O
+&G????OA?AEH_
+&G?????G@?J@o
+&G?????A?QQGo
+&G?????C?gEGW
+&G?????GPAGP_
+&G?????C?_[Go
+&G?????G?WPM?
+&G?????@AGQM?
+&G????_C?AEM?
+&G????_@?GQM?
+&G?????@AOSM?
+&G????OA?AWH_
+&G????G?P_OX?
+&G????G?R?cD?
+&G???A?W@?BK?
+&G???CG?E?WK?
+&G????G?R?gE?
+&G????O?OAWH_
+&G????@GB?I@G
+&G????@@@_OW_
+&G????G?R?c@_
+&G???O?OI?HK?
+&G???C?QA?KK?
+&G???OA?C_gK?
+&G????@G@_oH?
+&G???GO?P?@J?
+&G???C@C@?GW_
+&G???O@?Q?WGG
+&G???C@CA?IG_
+&G?@A?AG?G?U?
+&G??_O_G?OOE?
+&G?A?OAG@?AK?
+&G???GACA?gK?
+&G?????G@?hD_
+&G????A?I?HL?
+&G?????AAAKK_
+&G????A?O_`L?
+&G????GG?AIL?
+&G???OA?Q?AM?
+&G????GA?GaL?
+&G????AA?_gL?
+&G???O?OI?gCO
+&G????O?D_`H?
+&G???O@?I?WCO
+&G???A?W@?`C_
+&G?A?OAG?O?[?
+&G???AAGA?PC_
+&G???AAGA?SK?
+&G????_?J?K?o
+&G?????K?o`A_
+&G????G@B?c?o
+&G???O@@A?G[?
+&G????O@A_PH?
+&G????_G@_o@O
+&G???@@C@?HG_
+&G???G@CA?HG_
+&G?G?OAG?OOE?
+&G???G@G@?`C_
+&G???O_C@?EK?
+&G???G?_P?@J?
+&G???O@?P?AY?
+&G???GAG@?H@O
+&G?@?CAG?G?U?
+&G??_O_?OOOE?
+&G???GAG@?WD?
+&G???G@C@?OJ?
+&G???OOC@?AY?
+&G??A?_G@?H@O
+&G?@?G_GA??U?
+&G?@A?AGA?OE?
+&G??A?_G@?WD?
+&G???G@?CAgD?
+&G???O@?D?BI?
+&G?A?OA?O@CK?
+&G???AAGA?SI?
+&G?G?OA?GOOE?
+&GOA?OA?OAO?_
+&G?A?OAGA?GK?
+&G???G@G@?H@_
+&G???OOGA?EI?
+&G??A?_C@?aE?
+&G?????G@?kF?
+&G?????c?_gL?
+&G????_CA_W?W
+&G???GACA?OJ?
+&G???A?W@?cE?
+&G???OOG@?CY?
+&G??A?_C@?IA_
+&G?????g?OWM?
+&G???O_?OOOM?
+&G???@A?I?WK?
+&G???OACA?A[?
+&G??@?O?P?_J?
+&G?A?O?OO__K?
+&G???O_G@?QGG
+&G?@?O_?O@_E?
+&G?G?A_?O_OE?
+&G???O_C@?aG_
+&G?????@?_wK_
+&G?????a@?aL?
+&G????G?H?oH_
+&G????GCB?@X?
+&G???GA?P?_J?
+&G???A?SA?EI?
+&G???OACA?CY?
+&G???C@G@?OB_
+&G???O_G@?H@G
+&G???O_C@?IA_
+&G?????G@_DM?
+&G????ACA?IL?
+&G????@CB?GX?
+&G????_CB?K@O
+&G????OCA?WH_
+&G???GG?I?cE?
+&G????OG@_OX?
+&G???GAC@?KGG
+&G???OAC@?II?
+&G????GAB?cH?
+&G???G@?CAoK?
+&G?AA?AA?A?[?
+&G?GA?@?H?GE?
+&G?GA?AG?A?U?
+&GOA?O_?Q?G?G
+&G?AA?AG@?@K?
+&G???G@G@?oK?
+&G????G?GGoL?
+&G???O?OI?PC_
+&G???GOG?G@J?
+&G???O@CA?@W_
+&G?@?OAG?A?U?
+&G?@A?A?CO@E?
+&G?@?A_?O_OE?
+&G??A?_C?A_B_
+&G???O_G@?BGG
+&G???G@G@?cH?
+&G?????`@_WGO
+&G???G@?I?cCO
+&G???O@?Q?aCG
+&G???O@C@?BG_
+&G???O?gA?BK?
+&G?A?OAC?O@K?
+&G???CG@A?gK?
+&G???OOC@?BGG
+&G???G@GA?gE?
+&G????_@B?oE?
+&G?????G@?MBO
+&G????G?H?`H_
+&G????_C?BKA_
+&G???C@C?A_B_
+&G???A?W@?DA_
+&G???O@CA?CQ_
+&G???G@G@?KB?
+&G?????@B?HK_
+&G????G?Q?PH_
+&G????G?EAQD?
+&G????GC?gc@O
+&G????_G?_o@o
+&G???O?a@?BI?
+&G????_CA__P_
+&G???GA?P?KGG
+&G???OA?P?II?
+&G????G@B?aG_
+&G?????KB?I@O
+&G????G@AAID?
+&G????_G@OI@_
+&G????_GB?GP_
+&G???OA?O_gC_
+&G????_@B?aA_
+&G?????KB?gD?
+&G?????AA?[K_
+&G?????@@O`M?
+&G????GC?AgL?
+&G????G?H_oGO
+&G?????g?_IL?
+&G????AA?_aL?
+&G???@?cA?WG_
+&G???AAC@?cG_
+&G????O?I?WH_
+&G????@G@_OX?
+&G???GOCA?AJ?
+&G???GAG@?WGG
+&G????OG@_@X?
+&G????GAB?c@O
+&G???GOCA?AX?
+&G???GOG@?EH?
+&G?????g?OQM?
+&G????_@?GSM?
+&G???O?_E?PK?
+&G???O@?E?PK?
+&G???OAG?O@M?
+&G????GA?GgL?
+&G?A?O_?O_?[?
+&G???AAGA?PK?
+&G???@A?I?HK?
+&G???O?Q?GgK?
+&G?G?GAG?A?U?
+&G?A?O_?P?CK?
+&G???CG@A?G[?
+&G????_@@_oGO
+&G?G?O_?O_OE?
+&G???G@CA?aK?
+&G?????C?OwGo
+&G?????@@G`M?
+&G????OA?AoH_
+&G????G?R?OX?
+&G?????g?_BL?
+&G????A?O_aL?
+&G???A?W@?BI?
+&G???CG?I?SE?
+&G????_A?Ao@o
+&G????O?Q__P_
+&G???A_C?A_B_
+&G???C@CA?IGG
+&G????_CA_@P_
+&G????G@B?a?o
+&G???O_G@?B@G
+&G???CAG@?II?
+&G?????G@GDM?
+&G?????G@GEM?
+&G????G?Q_OX?
+&G????_?R?SB?
+&G????A?Q?IL?
+&G?????AA_KK_
+&G???CG?I?cE?
+&G????O?F?WH?
+&G????O?P__P_
+&G????@@B?aA_
+&G???C@C@?IGG
+&G???O@?Q?gE?
+&G????_@B?I?o
+&G?????EB?cG_
+&G???CAC@?II?
+&G????O@B?gH?
+&G????A?I?WL?
+&G?????aA_o@O
+&G???OAG@?AM?
+&G???GACA?G[?
+&G???O?OI?gC_
+&G???G?S@?EI?
+&G?A?OA?E?CK?
+&G?G?O?g?OOE?
+&G???G@?P?_J?
+&G???GACA?CY?
+&G???GOCA?OJ?
+&G??@?OG@?CY?
+&G???OACA?AY?
+&G???O_C@?I@_
+&G???O_G@?WGG
+&G??@?_G@?KI?
+&G???O?OOAgK?
+&G???@A?Q?HK?
+&G?A?O_?O@CK?
+&G?G?O_@?AOE?
+&G?A?OA?C_@K?
+&G???@@C@?WG_
+&GOA?OA?OAG?O
+&G?A?O_?Q?GK?
+&G?@?GAG?A?U?
+&G??_O_@?AOE?
+&G?G?CA?E?_E?
+&G?@A?_G?AOE?
+&G?@A??_P?GE?
+&G???G@CA?gG_
+&G?A?O_?P?_K?
+&G???O_C@?aK?
+&G????G?OAoH_
+&G????@AB?a@G
+&G???GO?Q?@J?
+&G???C@CA?GW_
+&G???AA?D?DI?
+&G???O@?D?EI?
+&G?@A?A?O@AE?
+&G??_O?g?OOE?
+&G???C?c?A_B_
+&G???C@CA?CQ_
+&G???C_CA?_B_
+&G??A?_G@?DAG
+&G???OACA?H?g
+&G???CACA?KA_
+&G???O_CA?IGG
+&G???OOGA?II?
+&G????@@B?GW_
+&G????_?R?K@_
+&G???O@?Q?gCG
+&G???C@C@?IG_
+&G???O@A?AQI?
+&G????_?J?KG_
+&G?A?OA?P?AK?
+&G???O@@A?gK?
+&G???G@?P?KGG
+&G???O@?P?II?
+&G???OOC@?IGG
+&G???OOC@?II?
+&G???OA?P?HI?
+&G????G@B?cG_
+&G???OAGA?gE?
+&G????OCB?gH?
+&G?????@?_kK_
+&G????A?G_gL?
+&G????OA?AcM?
+&G???O?OI?WK?
+&G????G?H?WH_
+&G???G@?P?OJ?
+&G???@?cA?IK?
+&G?@?GAGA??U?
+&G?????cA?IL?
+&G???O?OI?WG_
+&G???OAG@?CM?
+&G?A?OA?E?GK?
+&G????GC@_@X?
+&G???OAC@?AY?
+&G???OACA?C[?
+&G??a?_?O_OE?
+&G????G?GGgL?
+&G???OAG?G@M?
+&G???O?OI?PK?
+&G?A?O_?OO?[?
+&G???GOC?G@J?
+&G???GOC@?@J?
+&G?G?CA?Q??U?
+&G?G?CAGA??U?
+&G???O?OI?PG_
+&G?A?OA?CO@K?
+&G?A?O_?O@GK?
+&GOA?OA?OAG?_
+&G???O@C@?@W_
+&G???G@GA?WGG
+&G?@A?_?O_OE?
+&G?A?O_?Q?OK?
+&G?????G@?hB_
+&G????A?G_`L?
+&G????GC?AaL?
+&G???O?OI?WCO
+&G????G?H?HH_
+&G???G@?OAOJ?
+&G???@?cA?HG_
+&G?@?GA?Q??U?
+&G????G?I?PH_
+&G???O?_D?BI?
+&G???GO?Q?AJ?
+&G?@A?A?O@CE?
+&G????_C?BaB?
+&G???OA?P?AY?
+&G???CGCA?GW_
+&G??_O_?O_OE?
+&G?????AA_DK_
+&G????A?Q?HL?
+&G????G?E_PH?
+&G???O@?I?gCO
+&G????O?P?HH_
+&G????O?P?WH_
+&G???G?c@?HG_
+&G???AAGA?DK?
+&G????G?EAID?
+&G???CG@?AQI?
+&G???O@@A?gCG
+&G?A?OA?P?CK?
+&G????OC?gc@O
+&G????O@@_OW_
+&G???CGC@?IG_
+&G???O@AA?gK?
+&G?????G?oPM?
+&G?????g@_o@O
+&G????GG?OSM?
+&G???@ACA?IK?
+&G????@C@_GX?
+&G???GAC@?CY?
+&G???O?QA?WK?
+&G??_O_@A?OE?
+&G????AAA?QL?
+&G???G?SA?EI?
+&G????GC?_gL?
+&G???A_G@?SI?
+&G????_AB?Q?o
+&G???O_G@?H@O
+&G????_A@_oGO
+&G???O_G@?WD?
+&G?????`@_oGO
+&G???CA?Q?G[?
+&G???O?OQ?PK?
+&G?G?O_@?GOE?
+&G???O@?Q?QGG
+&G???COC@?AX?
+&G?A?O_?OOOK?
+&G??Q?AGA?OE?
+&G???G@?I?SCO
+&G?G?O?`?GOE?
+&G???O?c@?aK?
+&G?A?O_?O__K?
+&G???O@CA?BG_
+&G???COGA?EH?
+&G???OACA?aK?
+&G???O_G@?QK?
+&G?????@@AgK_
+&G????G?J?c?o
+&G????GC?GaL?
+&G???@@CA?HG_
+&G????G?EAQH?
+&G???O@@@?AY?
+&G???GG?I?PE?
+&G??OOAG?OOE?
+&G????G?P?`H_
+&G???AACA?DA_
+&G????OA@?oH_
+&G???A_CA?EI?
+&G????GCAGc@O
+&G???OACA?H@O
+&G????GCB?OX?
+&G???OACA?gH?
+&G?????KA_P@_
+&G????_@B?K?o
+&G????G@A_PH?
+&G???G@C@?HG_
+&G????_@AAID?
+&G????_GB?I@G
+&G???OA?Q?cCO
+&G???OAGA?DK?
+&G????G@AAQD?
+&G???O@A@?BI?
+&G????OCB?GX?
+&G???OAGA?gD?
+&G????_CAGK@_
+&G????GGB?c@_
+&G????_CB?aA_
+&G????OGB?WH?
+&G?????C?_kK_
+&G?????G@ODM?
+&G????_A?AWL?
+&G????O?I_WGO
+&G?????aA?IL?
+&G????AAA?IL?
+&G???@?g@?WG_
+&G???AAG@?SG_
+&G????_?H?WH_
+&G????@C@__X?
+&G???G_C@?AJ?
+&G???GAC@?gGG
+&G????_C@_@X?
+&G????_AB?I?o
+&G???G_C@?AX?
+&G???G_C@?EH?
+&G?????g?OPM?
+&G????OG?ODM?
+&G???O?_E?WK?
+&G???@ACA?EK?
+&G???OA?OO_M?
+&G????GAA?IL?
+&G?A?OAAA??[?
+&G???A_G@?QH?
+&G???G?OI?KK?
+&G???OA?E?KK?
+&G?@?C?OQ?_E?
+&G?@@?AGA?AE?
+&G???OAAA?G[?
+&G????_C@_`H?
+&G?G?G_?O_OE?
+&G???O_G@?SCO
+&G????_?GGWL?
+&G?????`B?WGO
+&G??A?A?P?@M?
+&G???O@?Q?O[?
+&G???O?OI?`C_
+&G???G@?I?SGO
+&G?G?OA?O@AK?
+&G?G?OA?P?AK?
+&G???G_C?G@J?
+&G???O@?Q?QCG
+&G??A?O?P?OJ?
+&G???O_GA?QCG
+&G???O@G@?@W_
+&G???O@G@?BG_
+&G???O_G@?PGG
+&G???O_G@?`CO
+&G???O?_O@gK?
+&G???CA?E?HK?
+&G?A?@A?Q?@K?
+&G?G@?A?Q?@E?
+&G?A?OAA?A?[?
+&G???O?gA?PG_
+&GOA?OA?OAAA?
+&G?G?OA?Q?AK?
+&G?@?C?OQ?AE?
+&G??H?A?Q?@E?
+&G?G?CAG?@_E?
+&G??P?AGA?_E?
+&G?@A??_O_OE?
+&G???OACA?aGO
+&G?A?OO?Q?_K?
+&G???O_CA?QK?
+&G?????G@?iBO
+&G?????AAODK_
+&G????_A?AQL?
+&G????G?F?PH?
+&G????G?H?PH_
+&G????G?P?PH_
+&G???@?g@?HG_
+&G???G?g@?HG_
+&G????_?H?HH_
+&G????G?EAaD?
+&G???G_?P?AJ?
+&G???O@@A?WCG
+&G????_C?BcA_
+&G????_C?gc@O
+&G???CGG@?GW_
+&G???CGG@?IG_
+&G????G?GG`L?
+&G????GG?GBL?
+&G???O?OI?PE?
+&G???C?SA?HG_
+&G???GO?OAAJ?
+&G????OA@?PH_
+&G?@A?A?OO?U?
+&G???A_G@?BH?
+&G???G?OH?KGO
+&G???OA?D?KGO
+&G?@?CAG?@CE?
+&G?@@?A?Q?AE?
+&G???OAA@?GWO
+&G????_CAAIH?
+&G?@?G_?O_OE?
+&G???O@G@?cG_
+&G?????G@OHK_
+&G?????KA_Q@O
+&G????_C?GIL?
+&G????G@@_PH?
+&G????O?EAID?
+&G????O@AAID?
+&G???GG?I?`E?
+&G???OA?Q?`D?
+&G????_?P?HH_
+&G????G@AAaD?
+&G????_C@?WH_
+&G????OCA@WH?
+&G????GC@Gc@O
+&G????_CAOI@_
+&G????_C@_OX?
+&G????_AB?aA_
+&G?????PA_PG_
+&G????O@@_`@_
+&G???G@?I?gCO
+&G???CAC@?HG_
+&G???OAA?_PGG
+&G????OCAAID?
+&G?A?OA?OOOK?
+&G???O@GA?SG_
+&G???G@?H?KGO
+&G???OA?P?KGO
+&G???O?gA?IK?
+&G???OAGA?KK?
+&G???OAA@?HGO
+&G????_CAOaA_
+&G???OAAA?gK?
+&G????_CB?WH?
+&G?????G@?[Go
+&G?????G?WDM?
+&G?????@?W`M?
+&G?????@AGEM?
+&G????_C?AWH_
+&G????O?P__X?
+&G????_?P_OX?
+&G????G?R?cB?
+&G??A?O?P?@J?
+&G???C@C@?_W_
+&G???C@G@?OW_
+&G???GAG@?`CO
+&G?????g?OBM?
+&G????_@?GBM?
+&G????A?OOcM?
+&G?????@AOEM?
+&G???O?_E?HK?
+&G???O@?E?KK?
+&G???OAA?@gK?
+&G????_?P_oH?
+&G?G?CAG?@AE?
+&G??P?AGA?AE?
+&G?A?OO?Q?@K?
+&G???C@G@?aK?
+&G????_?OAWH_
+&G????@@@__W_
+&G????@AB?I@G
+&G????G?R?K@_
+&G???G_?P?@J?
+&G???O@?Q?WCG
+&G???C@G@?GW_
+&G???C@G@?IG_
+&G???G_C@?OJ?
+&G???O_GA?WCG
+&G??A?OC@?CY?
+&G??A?OC@?KI?
+&G???G@?G@KK?
+&G???O@?CGKK?
+&G???@@@?GKK?
+&G????G?R?KA_
+&G?@?CAG?@AE?
+&G?@@?A?Q?@E?
+&G??_O_?GOOE?
+&G???C@G@?gG_
+&G?@?G_?E?_E?
+&G?@@?AGA?_E?
+&G?@A??gA?OE?
+&G??A?_G@?WCO
+&G?????G@?qBO
+&G?????A?QKK_
+&G????A?G_HL?
+&G????A?O_HL?
+&G????_C?AIL?
+&G????G?D_PH?
+&G???O?OI?WGO
+&G???O@?I?WGO
+&G??A?A?P?AM?
+&G???O@@A?O[?
+&G?G?OA?O@CK?
+&G?G?OA?P?CK?
+&G????G?GGHL?
+&G????GA?GBL?
+&G???OA?OAAM?
+&G????AA?_HL?
+&G???O?OI?PI?
+&G???C?S@?HG_
+&G?A?OA?OO?[?
+&G???A@GA?SG_
+&G?A?@A?Q?AK?
+&G?G@?A?Q?AE?
+&GOA?OA?OAAC?
+&G?G?OA?Q?CK?
+&G?????G@AKK_
+&G?????K?oaCO
+&G????G?J?K?o
+&G????G@B?K?o
+&G????_A?GQL?
+&G????G@B?PH?
+&G???@@G@?HG_
+&G???G@G@?HG_
+&G????_A?_WL?
+&G????OCA_WGO
+&G???AOGA?SI?
+&G???O_C@?cE?
+&G?????P@_`G_
+&G????_@@_`@_
+&G???OA?OOG[?
+&G????GAB?K?o
+&G???G@?I?WCO
+&G???CACA?HG_
+&G?G?OA?OOOE?
+&G???G_CA?BH?
+&G???O?c@?gK?
+&G???O_C@?KK?
+&G?A?OAAA?_K?
+&G??A?_C@?gD?
+&G?????GB?SM?
+&G????_?R?oE?
+&G????OG?OoM?
+&G???AACA?oK?
+&G????_?R?aA_
+&G???GAGA?gE?
+&G???@G@A?gK?
+&G?AA?ACA?GK?
+&G????AAA?cL?
+&G???AACA?cH?
+&G????GG?_cL?
+&G???AOG@?cH?
+&G????GGB?_PO
+&G???O_CA?EGG
+&G????_AB?_QO
+&G???O_G@?SGG
+&G????AGA?KL?
+&G???AAGA?cD?
+&G???O_?O__M?
+&G?AA?ACA??[?
+&G????OC@__PO
+&G???OOC@?EGG
+&G???O?gA?A[?
+&G?GA?A?E?OE?
+&G????_AA?EKG
+&G???@_CA?EGG
+&G????_G?_KKG
+&G???AOG@?OX?
+&G????_AA?o@g
+&G??A?_C?__B_
+&G????OG@?WHG
+&G??@?OG@?GJ?
+&G????@@B?gH?
+&G???CG?Q?gK?
+&G???@G?Q?gK?
+&G?AA?AG@?GK?
+&G???C@@@?KI?
+&G???GOC@?EH?
+&G?@?O_?O_OE?
+&G?GA?_?O_OE?
+&G???C?P@?KI?
+&G?@?C_?P?GE?
+&G???@GC@?IG_
+&G?G?C_?P?GE?
+&G???OACA?COo
+&G???GOGA?AX?
+&G???GGCA?GW_
+&G???O_G@?C[?
+&G???O@?OAWI?
+&G?A?OAC?OAK?
+&G?A?O?OP?CK?
+&GOA?O_?Q?G@?
+&G???O@@@?HGG
+&G???GAC@?WGG
+&G?G?AA?CAOE?
+&G?AA?A?E?GK?
+&G???O?P@?HGG
+&G?@A?A?COAE?
+&G???GA?E?gCG
+&G?A?O?W?_CK?
+&G???COG?O@B_
+&G???GOGA?AJ?
+&G??@??g?AGJ?
+&G???O_G@?CM?
+&G????AG?OgL?
+&G???CG?I?gK?
+&G???O_?Q?GM?
+&G?AA?AG@??[?
+&G???OA?OASGO
+&G?A?OAC?_CK?
+&G?A?O?OOOOK?
+&GOA?O_?Q?OA?
+&G???CAC?OGJ?
+&G?@?C_?D?GE?
+&G???COC?OGJ?
+&G?G?C_?D?GE?
+&G???O?a@?@Y?
+&G?@A?A?COOE?
+&G???OA?E?SGG
+&G?A?O?W@?GK?
+&G????OC?OIH_
+&G???C?c@?BG_
+&G??@?O?OOGJ?
+&G?GA??OO_OE?
+&G????G@?`PH?
+&G???O@?Q?cCG
+&G???G@?E?PGG
+&G?AA?A?D?GK?
+&G????OA?OQHG
+&G???C?cA?@W_
+&G????OA?OWHG
+&G???AACA?A[?
+&G????OG?GIHG
+&G???GOG?GGJ?
+&G????OG?OKKG
+&G???O_C?_CM?
+&G????_?E_o@O
+&G???AAGA?BK?
+&G???AAGA?@[?
+&G?GA?AG?@OE?
+&G???CG?H?DI?
+&G???AAC@?SG_
+&G?G?AA?G@OE?
+&G?AA?AAA??[?
+&G???CG?H?CY?
+&G?@?OAG?@OE?
+&G???G?c@?GW_
+&G?@?O_G?@OE?
+&G???@?cA?I?o
+&G???@?cA?gG_
+&G???@?cA?IG_
+&G???@?g@?gK?
+&G????_?QAKD?
+&G???O@?I?cCO
+&G???O@?E?PGG
+&G?AA?AA@??[?
+&G????G?EASD?
+&G????O?H_WGO
+&G???O?OI?PCO
+&G???O?OI?oK?
+&G????G?QAOX?
+&G???O?OI?SCO
+&G????O?H_GWO
+&G???@G?I?WK?
+&G????GC?AcH_
+&G????GG?AoL?
+&G????GC?AcL?
+&G????_A?AoM?
+&G?????@AGgK_
+&G????G?J?cH?
+&G????GG?GcL?
+&G???AACA?PCO
+&G????O?Ooa@_
+&G???O@@@?HI?
+&G???@G@@?HGO
+&G?G?C@?H?GE?
+&G????G?P?EH_
+&G???AACA?D@O
+&G????OA@?EH_
+&G???A_CA?E@_
+&G????GCAOCOo
+&G???OACA?D?g
+&G????GGAAS@O
+&G???GGCA?AY?
+&G????G?OOQH_
+&G???O@?H?HI?
+&G??@??_OOGJ?
+&G?G?A?OO_OE?
+&G????G@AAAT?
+&G???C@A@?KGG
+&G???CA?H?GWO
+&G?@?O_?O@OE?
+&G????OA?OBHG
+&G???@ACA?D?g
+&G????O@?_IHG
+&G???G?cA?AY?
+&G????G?Q?P@g
+&G???A?c?__B_
+&G????AAA?QHG
+&G???GACA?GJ?
+&G?????KA_EGG
+&G????O@@_OX?
+&G????_@B?_QO
+&G???G@C@?OW_
+&G????O@?oa?o
+&G????_GB?K@O
+&G???CG@@?GWO
+&G???OAGA?A[?
+&G????G@AAQ?o
+&G???O@A@?CY?
+&G????OCAAK@O
+&G???GGC@?AY?
+&G????GC?Bc@_
+&G????OGA_@X?
+&G????_C?BaA_
+&G????_CB?g?W
+&G????@@AAIC_
+&G???CG@?ASI?
+&G???OA?O@QGG
+&G?A?O?OO_OK?
+&G????G?I@S@_
+&G????@GB?GX?
+&G???@A?H?HGO
+&G???@A?I?gK?
+&G????O?G``@_
+&G???A?Q@?DI?
+&G?????g?`PH?
+&G???O?OI?SG_
+&G????OA?Ac@o
+&G????G?I?oH_
+&G????G?I?SH_
+&G?????g@?gL?
+&G?????G?WgKO
+&G????O?P@WH?
+&G????_G?OIKG
+&G???A@C@?OW_
+&G????@@AAID?
+&G???CG?OASI?
+&G???O@?O@QGG
+&G?A?O?OO_CK?
+&G????AA?OPHG
+&G???O@?H?CY?
+&G????O@@?IHG
+&G???G?c@?AY?
+&G????G?EAQ@O
+&G???A?P@?DI?
+&G?????c?`PH?
+&G???O?OI?cC_
+&G?????A?oQGo
+&G????_?J?DB?
+&G????O@?GWHG
+&G???O@?I?@[?
+&G?????KAAEAO
+&G????@@B?GX?
+&G?????`B?_QO
+&G???@A?G_gK?
+&G?????C?oIGW
+&G????G?OBoH?
+&G?????C@_KGW
+&G????_?F?W?W
+&G?????A?QoGo
+&G?????c?OgH_
+&G?????C?QgKO
+&G?????c?OgL?
+&G?????C@OWGo
+&G????OC?OWH_
+&G????OC?GWHG
+&G??@?OC?GGJ?
+&G????G?OOPH_
+&G????AGA?IL?
+&G??@??_OAGJ?
+&G???O_?OO_M?
+&G????A?P?IHG
+&G???GA?P?GJ?
+&G????AC@?IHG
+&G???GAC@?GJ?
+&G????G?H?DH_
+&G?????aA?aL?
+&G????G?H?SH_
+&G?????g?_gL?
+&G?????G?WIKO
+&G????AG?OIL?
+&G????_@?GKKG
+&G???O_?OOGM?
+&G?????@AGHK_
+&G?????GB?DM?
+&G????G?GGcL?
+&G?????g?OoM?
+&G?????A?QaKO
+&G?????a?OaL?
+&G?????A?QgKO
+&G?????a?OgL?
+&G?????@?_qGo
+&G?????@A?wK_
+&G?????G@?hBO
+&G?????G@?wJ?
+&G?????GAOSM?
+&G????_?R?gE?
+&G????@C@_oH?
+&G???GAC@?gK?
+&G????AAA?gL?
+&G???AACA?cK?
+&G????OGA_o@O
+&G???O_CA?EK?
+&G????OG?O`M?
+&G???@ACA?cK?
+&G???OA?E?gK?
+&G?A?OAGA?AK?
+&G????GAA?aL?
+&G???AOCA?aH?
+&G????OGA_PH?
+&G???O_G@?`D?
+&G????_G?OPM?
+&G???@AGA?SK?
+&G???@AGA?KK?
+&G?@?C_?Q?_E?
+&G???OA?Q?_M?
+&G?A?OAGA??[?
+&G???OAGA?G[?
+&G?G?OAGA?OE?
+&G????_CA?EM?
+&G???@_CA?EK?
+&G???O?WA?IK?
+&G?@A?AGA?AE?
+&G????GGA?IL?
+&G???AOG@?QH?
+&G????OC@_`H?
+&G???O_GA?SC_
+&G????@@@_oH?
+&G???CG?Q?WK?
+&G???O@?Q?SC_
+&G???G@?I?SG_
+&G?A?OAG@?GK?
+&G???GGCA?BI?
+&G???@@AA?KK?
+&G??_O_G?GOE?
+&G??OOA?Q?OE?
+&G???@GC@?HG_
+&G?@A?AG?OOE?
+&G???GGCA?HG_
+&G???OA?CGgK?
+&G?A?OAG?OAK?
+&G?@?CA?Q?AE?
+&G?A?OA?O@@K?
+&GOA?OA?OAOA?
+&G?G?OA?GAOE?
+&G???O?PA?HK?
+&G?@A?AG?OAE?
+&G?@?CAG?GCE?
+&G???GA?I?PI?
+&G?A?OAG?_CK?
+&G???O@@A?WCO
+&G????AA?OgL?
+&G???CG?I?WK?
+&G???O@?I?SG_
+&G???CAC@?GJ?
+&G??_O_G?@OE?
+&G???CGC@?AY?
+&G???OA?Q?GM?
+&G?A?OAG@??[?
+&G?A?OA?O@OK?
+&G???GO?P?GJ?
+&G?@A?AG?@OE?
+&G???OA?Q?SGG
+&G????GA?OaL?
+&G???AAGA?QCO
+&G???@AC@?HG_
+&G??@?A?P?GJ?
+&G?G?OAG?@OE?
+&G???CAC@?GW_
+&G????GG?OIL?
+&G???AACA?aCO
+&G???G@?I?PI?
+&G????GC?OWH_
+&G???AACA?BK?
+&G????O@@_GX?
+&G????O?E_o@O
+&G???G?cA?BI?
+&G???C?c@?AY?
+&G???AOGA?D@_
+&G???O@?I?G[?
+&G?G?OA?G@OE?
+&G???C?c@?GW_
+&G???C?cA?IG_
+&G????G?OaoH?
+&G???G?SA?HG_
+&G???O@?E?WGG
+&G???C?SA?IG_
+&G????O?QAWH?
+&G???O@?I?PE?
+&G????G?P@WH?
+&G????G?J?SH?
+&G?????AAOEK_
+&G????O?QOKA_
+&G????G?P?SH_
+&G????_C?ga@O
+&G????GG?GDL?
+&G???OA?D?HGO
+&G????GC@?DH_
+&G????GGAAS@_
+&G????G@?G`L?
+&G???G?OP?KGO
+&G??@?A?OAGJ?
+&G???OA?P?GWO
+&G????GG?OBL?
+&G???G@?D?KGO
+&G????GC?OPH_
+&G????G@AASG_
+&G?????K@_DGG
+&G????O@?`PG_
+&G????_@?ao?o
+&G????OCAAI@O
+&G?????`A_PG_
+&G???OA?O@WGG
+&G????O?H_`@_
+&G????@CAAID?
+&G?????A?WgKO
+&G????AC@?HHG
+&G????_?OOIKG
+&G????OC?GHHG
+&G?????A?oaKO
+&G????A?P?WHG
+&G?????G?oIKO
+&G?????C?oWGo
+&G?????AAOKK_
+&G?????EAOSG_
+&G????O?E_WH?
+&G????O@A_WH?
+&G????O?J?KG_
+&G????G@B?cC_
+&G???O@@A?WK?
+&G????OCA_WH?
+&G????G?P?WH_
+&G????O@@_GW_
+&G???AACA?DK?
+&G???O@AA?WK?
+&G????OGB?I@G
+&G????GCB?c@_
+&G???OACA?DK?
+&G????OGA_WH?
+&G????GG?GHL?
+&G????O@@_`G_
+&G???@@CA?SG_
+&G???CAC@?gG_
+&G???OA?I?PI?
+&G???OA?Q?WCO
+&G?A?OA?Q?AK?
+&G???OAGA?WK?
+&G????OA@?HH_
+&G????OCAAIH?
+&G???AOG@?BH?
+&G???O@C@?cG_
+&G????_CAAID?
+&G????_CAGKA_
+&G???O@CA?SG_
+&G????GCB?WH?
+&G????GA?G`L?
+&G????O@A_PG_
+&G???@@C@?cG_
+&G???CACA?WG_
+&G???C?S@?KG_
+&G???G@CA?KG_
+&G?@?CAGA?CE?
+&G???O_C@?IK?
+&G???GO?OAOJ?
+&G???OA?Q?WGG
+&G?@A?A?Q??U?
+&G?A?OA?Q?OK?
+&G???O@C@?GW_
+&G???O@CA?IG_
+&G??OOAGA?OE?
+&G???OACA?gK?
+&G????GG?_BL?
+&G????_C@_`@_
+&G???@OG@?BH?
+&G???OOG@?BH?
+&G???O?S@?HG_
+&G???OACA?HG_
+&G?@A?A?Q?AE?
+&G???O_CA?IK?
+&G????A?O_gL?
+&G????O@A_o?o
+&G???O@?I?WK?
+&G???CACA?IK?
+&G???O@?I?WG_
+&G???CAG@?DI?
+&G?A?OA?Q?GK?
+&G???O_C@?aE?
+&G???G?_P?OJ?
+&G???CAC@?CY?
+&G?@?CAGA??U?
+&G??_O_?Q?OE?
+&G???OAC@?@Y?
+&G???O_G@?H?o
+&G?@A?A?Q?OE?
+&G???O_G@?WC_
+&G???OA?OA_M?
+&G???OA?Q?G[?
+&G?A?OA?Q??[?
+&G?G?OA?Q?OE?
+&G?A?OA?OA?[?
+&G?G?OA?OAOE?
+&GOA?OA?OA_G?
+&G?A?OA?Q?_K?
+&G????AA?_`L?
+&G????GAB?c?o
+&G???A@C@?cG_
+&G???GOG@?BH?
+&G???C?S@?EI?
+&G???O_C@?I@O
+&G?@A?A?Q?CE?
+&G??@?_CA?EI?
+&G????AAA?HL?
+&G????_AB?K?o
+&G???A@CA?SG_
+&G???GOCA?BH?
+&G???G@?I?SI?
+&G???OACA?BI?
+&G?A?OA?Q?CK?
+&G???O_G@?`E?
+&G?????G@OEM?
+&G????@@@_oG_
+&G????G?P_oH?
+&G???O@?Q?WK?
+&G????_?R?KA_
+&G???O@?Q?WC_
+&G???C@C@?gG_
+&G???O_GA?WC_
+&G????OG?OBM?
+&G???G@?E?KK?
+&G???@ACA?DK?
+&G?@?CAGA?AE?
+&G???OA?E?HK?
+&G?@?AA?Q?@E?
+&G?@A?A?Q?@E?
+&G?@?CAGA?_E?
+&G????_?OOQM?
+&G???OA?O@gK?
+&G???O@?E?WK?
+&G?A?OA?Q?@K?
+&G???G?OQ?KK?
+&G?@?AA?OA_E?
+&G?@?CAGA?@E?
+&G?@A?A?Q?_E?
+&G?????@AOQM?
+&G????_?P_o@_
+&G????G?R?WH?
+&G???C@CA?IK?
+&G????G?R?cA_
+&G???GACA?DI?
+&G???C@CA?WG_
+&G??@?_C@?EI?
+&G?????G?ogKO
+&G?????A?ogKO
+&G????_?D_oGO
+&G????GA?OgL?
+&G????GG?OgL?
+&G????O?D_oGO
+&G???AACA?aK?
+&G???AAGA?QK?
+&G????G@A?aL?
+&G?????gA_PH?
+&G???@ACA?cG_
+&G???@AC@?WG_
+&G????OG@?cM?
+&G???O?PA?gK?
+&G???@OG@?cK?
+&G?A?O_G?_CK?
+&G????_G?OHKG
+&G????AC@?WHG
+&G???@AGA?SGG
+&G??@?AC@?GJ?
+&G???OAGA?GM?
+&G???AAGA?C[?
+&G?A?O_G@??[?
+&G?G?O_G?@OE?
+&G????GGA?EL?
+&G????_G?ao@O
+&G???@OGA?EH?
+&G???OOC@?AX?
+&G???@GGA?IK?
+&G??a?AGA?OE?
+&G?????`A_PH?
+&G????G@?GaL?
+&G???O?Q?OgK?
+&G????_G?OSM?
+&G???G@?I?PG_
+&G???CG?I?PE?
+&G?A?O_C?_CK?
+&G???@AGA?QK?
+&G???@@A@?KGO
+&G???C?Q@?KGO
+&G??_O_@?GOE?
+&G???@AGA?IK?
+&G??_OAG?OOE?
+&G?G?O_G?OOE?
+&G???O@?O@WGG
+&G??@?A?GAGJ?
+&G?A?OA?COAK?
+&G???OAGA?AM?
+&G?A?OA?D?AK?
+&G?G?O?_G@OE?
+&GOA?OA?P?G@?
+&G?A?O_G?O?[?
+&G???O?P@?HGO
+&G???O@@@?GWO
+&G?G?O?`?AOE?
+&G???GAGA?G[?
+&G????AC?OWHG
+&G????_@?GIKG
+&G???CG?I?G[?
+&G???OAG?_CM?
+&G??@?AC?_CJ?
+&G???O@?E?SGG
+&G?@A?_?D?GE?
+&G?A?O_C?_?[?
+&G???GO?OOGJ?
+&G???OA?O@SGG
+&G??a??OO_OE?
+&G?A?OA?D?GK?
+&G????OC?OIHG
+&G????OC?GIHG
+&G???C?c@?@W_
+&G???GOC?GGJ?
+&G???G?c@?@W_
+&G??a?AG?@OE?
+&G????GC?OIH_
+&G????O@?`PH?
+&G???C?cA?BG_
+&G???O@?Q?SGG
+&G????_?Cao@O
+&G????GG?AEL?
+&G???@G?I?HK?
+&G????OG?AcM?
+&G???A?SA?BG_
+&G???A?SA?aK?
+&G???O@?H?GWO
+&G???O?OH?HGO
+&G??_OAG?@OE?
+&G???O?OI?gK?
+&G????G?OaOX?
+&G????GC?ASH_
+&G???O?OI?cCO
+&G????GG?AgL?
+&G????G?QASH?
+&G????G?EASH?
+&G???O@?I?SCO
+&G????O?H_oGO
+&G?????A@OQGo
+&G?????A?WaKO
+&G????G?J?DH?
+&G????AA?OaL?
+&G????GC?OBH_
+&G????G?QAS@_
+&G???@ACA?D?o
+&G???C?Q@?DI?
+&G????O@?GHHG
+&G????A?P?HHG
+&G???O@?H?@Y?
+&G???CA?P?GJ?
+&G????G@AAS?o
+&G???C@A@?CY?
+&G?????KAACQ_
+&G?????@AAIK_
+&G????@@@_OX?
+&G?????GAOPM?
+&G????O?Goc?o
+&G?????gA_o@O
+&G?????`?`PG_
+&G????G?OASH_
+&G???G@?G@SG_
+&G????A?I?gL?
+&G?????C@_EGW
+&G?????G?QIKO
+&G????O?OBWH?
+&G?????g?OIL?
+&G?????C?QWGo
+&G?????c?OWH_
+&G?????@@?YGo
+&G?????AA?kK_
+&G?????GB?KM?
+&G????GG?OoM?
+&G????@C@_WH?
+&G???OA?I?oK?
+&G????AAA?oL?
+&G????GG?_oL?
+&G????GGB?o@O
+&G????_C@_WGO
+&G????@GB?WH?
+&G???@ACA?gK?
+&G???GAGA?gD?
+&G?AA?A?O__K?
+&G???AACA?cI?
+&G???AOG@?cI?
+&G???O_CA?EI?
+&G???O_G@?gD?
+&G????AGA?WL?
+&G???O_?P?_M?
+&G???AAGA?cE?
+&G?AA?A?O@_K?
+&G???G@G@?_J?
+&G???GOGA?OJ?
+&G???O_CA?AY?
+&G???O_G@?gCG
+&G????GAA_o@O
+&G???O_C@?A[?
+&G???OOC@?EI?
+&G?GA?A?I?OE?
+&G???OOGA?AY?
+&G??@?_G@?CY?
+&G??A?_G@?KAO
+&G??@?OG@?KI?
+&G????@@B?WH?
+&G???@G?Q?WK?
+&G???O@?Q?cC_
+&G?AA?A?O_OK?
+&G???G@?I?SC_
+&G???@GC@?gG_
+&G???GGG@?BI?
+&G???OACA?SG_
+&G???C@AA?KK?
+&G?@?O_G?GOE?
+&G???GOC@?BH?
+&G?GA?AG?OOE?
+&G?@?OA?Q?OE?
+&G?@?OAGA?OE?
+&G???GOGA?BH?
+&G???O_G@?EK?
+&G???OA?GGgK?
+&G?A?O?OQ?CK?
+&G?A?OA?O_@K?
+&GOA?OA?OAC?G
+&G?@?CA?E?AE?
+&G?@A?A?E?AE?
+&G?@A?A?GAOE?
+&G?A?OACA?AK?
+&G???O@@A?HK?
+&G?G?AAG?AOE?
+&G???C@C@?WG_
+&G?AA?A?Q?GK?
+&G?@?AAG?AOE?
+&G?@?A_G?AOE?
+&G???C@CA?gG_
+&G???GAG@?gK?
+&G????AC?OgL?
+&G???O_?P?GM?
+&G???O@?I?cC_
+&G?AA?A?O@OK?
+&G???CACA?GJ?
+&G???GOG@?GJ?
+&G???CGCA?AY?
+&G???OACA?SGG
+&G???OA?G_gK?
+&G?A?O?OQ?OK?
+&G?A?OA?O_CK?
+&GOA?OA?OAC?_
+&G??_O_?O@OE?
+&G?@A?A?E?OE?
+&G?@A?A?GOOE?
+&G?A?OACA?GK?
+&G????OC?OgH_
+&G??@?OG?GGJ?
+&G???AAC@?BI?
+&G?GA?A?O@OE?
+&G???AOC?O_B_
+&G??@?_C?__B_
+&G???O_CA?D?g
+&G???OOCA?EGG
+&G????O@A_OX?
+&G???G@CA?OW_
+&G???O@?Q?cE?
+&G?AA?A?P?GK?
+&G???CAG@?IGG
+&G???O_C@?EGG
+&G???GAG@?HI?
+&G???GAG@?gE?
+&G????G?E_o@O
+&G???AACA?@[?
+&G???G?c@?BI?
+&G?GA?A?G@OE?
+&G???C?g@?AY?
+&G???AOG@?AX?
+&G???A_CA?D@_
+&G???AOCA?EH?
+&G???O@?I?HK?
+&G?G?AAG?@OE?
+&G???A@C@?SG_
+&G?AA?A?Q??[?
+&G?@?AAG?@OE?
+&G?@?A_G?@OE?
+&G???A@CA?cG_
+&G???AACA?SK?
+&G????G?O`oH?
+&G???A@CA?OW_
+&G???O@?I?cE?
+&G?AA?A?P??[?
+&G???@ACA?DGG
+&G???@_C@?EGG
+&G???C?SA?II?
+&G???AACA?SH?
+&G????_?J?KB?
+&G???AAGA?PCO
+&G????O?P_WH?
+&G???O@?I?oK?
+&G???O@?I?WE?
+&G???AAGA?SD?
+&G????G?R?oH?
+&G????G?R?oI?
+&G?????@@GgK_
+&G????GC?GcL?
+&G????O?QOcA_
+&G???OA?I?PCO
+&G????G?P?cH_
+&G????GC@?cH_
+&G????GCAGa@O
+&G????GGAASD?
+&G????G?J?c@_
+&G???@@CA?IG_
+&G???O@@@?BI?
+&G?G?AA?OAOE?
+&G???AACA?DAO
+&G???A_C@?EB?
+&G???OACA?I@O
+&G???GGCA?EI?
+&G????G?OOoH_
+&G??@??g?GGJ?
+&G???AA?P?DI?
+&G?G?AA?O@OE?
+&G???C?c?G_B_
+&G???COG?O_B_
+&G???OACA?I?W
+&G???OACA?IGG
+&G????G@B?c?g
+&G???G@CA?GW_
+&G???O@?P?EI?
+&G?@?O_?OAOE?
+&G???CACA?CQ_
+&G???O_C@?EAG
+&G???C@CA?KA_
+&G???GACA?KI?
+&G?????K@_EGG
+&G????_@B?OQO
+&G????_@AAKC_
+&G???OA?Q?PGG
+&G????O@?``G_
+&G????OC?``H?
+&G????_AAAS@_
+&G????_CAAKD?
+&G????_@B?K?g
+&G???G@C@?GW_
+&G????_GB?K?o
+&G???OAGA?@[?
+&G???O@A@?AY?
+&G???GGC@?CY?
+&G????_AB?a@O
+&G????OG@_o@O
+&G????@@@@gG_
+&G???G@?E?gCG
+&G???OA?OASI?
+&G?A?O?OP?AK?
+&G???G@?D?KGG
+&G???O?S@?IGG
+&G???OA?D?HI?
+&G???OA?I?WI?
+&G????_?J?K@_
+&G???@@C@?IG_
+&G????_?R?aB?
+&G???@A?Q?gK?
+&G???O@?D?II?
+&G???G?S@?KI?
+&G????G?R?cG_
+&G????@CA_oH?
+&G?????C?WgKO
+&G????OG?OIKG
+&G????@GAAID?
+&G???OA?E?PGG
+&G????AAA?PHG
+&G????OG@?IHG
+&G????GGAAQ@O
+&G????GC?`PH?
+&G????@@@@WG_
+&G???G@?E?WGG
+&G???CA?OASI?
+&G?A?O?OOOAK?
+&G???O?_P?AY?
+&G???O?c@?AY?
+&G???OA?D?BI?
+&G???OA?I?WG_
+&G?????A?ooGo
+&G????OG?GWHG
+&G????_?J?DA_
+&G???OA?I?@[?
+&G????O?Q?W@g
+&G????_CA?W@g
+&G????GGB?B@G
+&G????OG@__PO
+&G?????K?oIGG
+&G????G@B?_QO
+&G????@@B?cA_
+&G???@AA?OgK?
+&G????G@B?_Oo
+&G????OCA__PO
+&G????@AB?c@_
+&G????G?R?aA_
+&G?????@@OWGo
+&G????OA?GWHG
+&G????OC?OHH_
+&G??@?O?OAGJ?
+&G????OA?GPHG
+&G????OA?_QHG
+&G????GA@?DH_
+&G????GA@?SH_
+&G????O?OOWH_
+&G??@??c?GGJ?
+&G????AGA?HL?
+&G???O_?Q?AM?
+&G???G?_P?GJ?
+&G???G?c@?GJ?
+&G????AG?_`L?
+&G????AG?_gL?
+&G?????G?gKKO
+&G????GG?OIKG
+&G????AG?OHL?
+&G???O_?O_AM?
+&G????GG?OBKG
+&G????_A?_EKG
+&G????AG?_DL?
+&G????AG?_KL?
+&G?????AAGKK_
+&G????GA?GcL?
+&G?????GB?EM?
+&G????_@?GoM?
+&G????A?O_cL?
+&G????AA?_cL?
+&G?????@B?aM?
+&G?????@B?cM?
+&G?????GAOWM?
+&G????@CB?WH?
+&G????ACA?gL?
+&G????GGA_o@O
+&G???GAGA?KK?
+&G???OA?I?gK?
+&G???OAGA?IK?
+&G????GAA?oH_
+&G????OGA_OX?
+&G????_GB?KB?
+&G????_G?OWM?
+&G???@AGA?WK?
+&G???O_?P?OM?
+&G???O_CA?A[?
+&G?@?O_?Q?_E?
+&G?A?O?OQ?_K?
+&G?G?AAGA?OE?
+&G??@?O?Q?_J?
+&G???O_G@?`CG
+&G???O_GA?QC_
+&G????@@@_WH?
+&G???O@?Q?aD?
+&G???G@?I?cC_
+&G???GGC@?BI?
+&G???OOC@?BH?
+&G?A?OA?O_OK?
+&G???CAC@?WG_
+&G???AGC@?BI?
+&G???OA?Q?aD?
+&G????O@@_WH?
+&G???O@?OAoK?
+&G?AA?A?O_@K?
+&G?AA?A?O@@K?
+&G?GA?A?GAOE?
+&G?GA?A?Q?@E?
+&GOA?OA?OACA?
+&G?AA?A?Q?@K?
+&G?GA?A?O@@E?
+&G?AA?A?P?@K?
+&G???O@?Q?oK?
+&G????AA?OoL?
+&G???O@?I?SC_
+&G???CAG@?GJ?
+&G???CGG@?AY?
+&G?@?OA?Q?AE?
+&G??OOA?E?OE?
+&G?@?AAG?OOE?
+&G???AOC?__B_
+&G???OACA?DGG
+&G???O@@A?WE?
+&G????GA?OoL?
+&G???@AC@?gG_
+&G??@?AG@?GJ?
+&G???OOG@?AX?
+&G?@?OAGA?AE?
+&G?G?OA?E?OE?
+&G??_AAGA?OE?
+&G??A?OC?__B_
+&G???OOG@?EGG
+&G???GAGA?WE?
+&G????G?F?o@O
+&G???G?g@?BI?
+&G???C?cA?AY?
+&G???AOCA?D@_
+&G???@OGA?BH?
+&G?@A?A?G@OE?
+&G???@@CA?cG_
+&G???AOCA?@P_
+&G???C?cA?II?
+&G????O?E_gH?
+&G????_?D_WGO
+&G???@ACA?SG_
+&G???@ACA?SGG
+&G???@OCA?EH?
+&G???@OCA?EK?
+&G?A?OACA??[?
+&G???@ACA?SK?
+&G???@OCA?EGG
+&G???AACA?cD?
+&G????_?R?WE?
+&G?????@B?IK_
+&G????O?QOaB?
+&G????G?Q?SH_
+&G????GC?ga@O
+&G???GA?P?KGO
+&G???OA?H?HGO
+&G???CAA@?KGO
+&G????OA?_c@o
+&G????GGA@S@_
+&G????_@@OIA_
+&G????G@?GoL?
+&G???O@?I?PC_
+&G??@?AG?AGJ?
+&G???OACA?@W_
+&G?@?OAG?G@E?
+&G?G?OA?CAOE?
+&G??_AAG?OOE?
+&G??A?_C?G@B_
+&G???OACA?BGG
+&G???O@?Q?QC_
+&G?????E@_EGG
+&G????O@AAKC_
+&G????_@?`PG_
+&G????GAAAS@_
+&G????OC@_`@_
+&G???OA?O_WGG
+&G????_@A_PG_
+&G????OC?``@_
+&G????O@AAIC_
+&G?????E@OSG_
+&G?????P@_WGO
+&G???CA?I?PI?
+&G???G@?E?cCG
+&G???O?S@?BG_
+&G???O?WA?BK?
+&G?A?OAC?A?[?
+&G???CA?E?gK?
+&G???O?S@?BGG
+&G???CA?I?WI?
+&G????@@B?gI?
+&G?????A?WoKO
+&G????@CAAIH?
+&G????AG@?HHG
+&G????_CAAI@O
+&G???GA?D?KGO
+&G???OA?H?GWO
+&G???@AA@?KGO
+&G????GAA?P@g
+&G????GGAAAT?
+&G????O?QOIA_
+&G?????A?ooKO
+&G?????c@_`H?
+&G????AG@?WHG
+&G????GG?ao@O
+&G???GA?E?KK?
+&G???OA?I?G[?
+&G???@AAA?KK?
+&G????GAA?o@g
+&G????_C@__PO
+&G????_?R?IA_
+&G?????@@_WGo
+&G????GC?OHH_
+&G????OA?GHHG
+&G????OA@?DH_
+&G????GGA?BL?
+&G???GO?OAGJ?
+&G????GG?G`L?
+&G????OA?_BHG
+&G????@A@?SH_
+&G?????AAOcK_
+&G?????G?oKKO
+&G????G@A?IL?
+&G????GG?OHKG
+&G????GAA?EL?
+&G????OCA?EM?
+&G???OA?O__M?
+&G????OG?OPM?
+&G????GAA?EKG
+&G????AAA?KL?
+&G?????G@OSM?
+&G?????@B?KM?
+&G????@CA_WH?
+&G????AC?_gL?
+&G????GG@_o@O
+&G???GAG@?KK?
+&G???OA?I?WK?
+&G???OACA?IK?
+&G????GA@?oH_
+&G????GCB?GX?
+&G????_CB?KB?
+&G????@G@_WH?
+&G???GAG@?gD?
+&G???AACA?SI?
+&G???OOCA?EI?
+&G??@?OCA?EI?
+&G?A?OA?O__K?
+&G???O_G@?gC_
+&G???AOCA?EI?
+&G???OACA?gD?
+&G????OG@_WH?
+&G????AA?_oL?
+&G???AAGA?SE?
+&G???G@G@?OJ?
+&G???OOG@?AY?
+&G?@?OA?Q?_E?
+&G?@?CA?E?_E?
+&G?@?AAGA?OE?
+&G???COCA?_B_
+&G???OOG@?IGG
+&G???OAGA?WE?
+&G????GAB?o@O
+&G???O_C@?EI?
+&G???O_C@?AY?
+&G??A?_C@?KA_
+&G??@?_G@?EI?
+&G?@A?A?I?OE?
+&G???O_C@?gG_
+&G??A?_C@?BAG
+&G???O_C@?II?
+&G????OCA_gH?
+&G????_@?GWM?
+&G???@A?Q?WK?
+&G???O_?P?AM?
+&G???OACA?@[?
+&G?@?O_?Q?AE?
+&G?A?O?OQ?AK?
+&G?G?AAG?OOE?
+&G??@?O?Q?AJ?
+&G???O@CA?OW_
+&G???OAGA?PCO
+&G???OA?OAoK?
+&G?AA?A?O_CK?
+&G?AA?A?OA?[?
+&G?GA?A?OAOE?
+&G?GA?A?Q?CE?
+&GOA?OA?OACG?
+&G?AA?A?Q?CK?
+&G?GA?A?OA?U?
+&G?AA?A?P?CK?
+&G???OA?Q?oK?
+&G????GA?GoL?
+&G???@@C@?gG_
+&G???GOG@?@J?
+&G???COG@?AX?
+&G?@?OAGA?@E?
+&G?@A?A?E?@E?
+&G??OAAGA?OE?
+&G??A?OC?A_B_
+&G???OOG@?BGG
+&G???G@GA?WE?
+&G????_@@_WGO
+&G???G@CA?WG_
+&G???G@G@?SGG
+&G???COCA?EH?
+&G???O_C@?BK?
+&G?A?OACA?@K?
+&G???CACA?gK?
+&G???O_C@?BGG
+&G???G@G@?gE?
+&G????_@B?WE?
+&G?????@B?IM?
+&G????G?R?cC_
+&G????AC?_`L?
+&G????_AB?Q@O
+&G???C@CA?KG_
+&G???OA?I?WCO
+&G???O@CA?HG_
+&G????GA@?`H_
+&G????GGAAQD?
+&G????_CAGKB?
+&G????G?R?o@_
+&G???GAG@?DI?
+&G???C?SA?EI?
+&G???O_G@?H@_
+&G??A?_G@?K?o
+&G?@A?A?OACE?
+&G???O_G@?BI?
+&G???A_C@?BB?
+&G???CGCA?EI?
+&G????_CA_g@_
+&G????A?O_oL?
+&G???O@?I?WC_
+&G???G?_P?_J?
+&G???OACA?@Y?
+&G?@?OA?OA_E?
+&G?@?CAG?A?U?
+&G?@?AA?Q?OE?
+&G???COC?A_B_
+&G???OACA?HGG
+&G???OA?Q?WE?
+&G????G@B?o?o
+&G???CACA?DI?
+&G???CACA?CY?
+&G???O_C@?I?o
+&G???OOGA?BI?
+&G??_O_?OAOE?
+&G???G@G@?gH?
+&G???O_C@?BAG
+&G???CACA?KI?
+&G????O@A_gG_
+&G?????G@_EM?
+&G????_?R?QB?
+&G????ACA?HL?
+&G????_CB?K?o
+&G???C@C@?KG_
+&G???OA?I?gCO
+&G???O@C@?HG_
+&G????GAA?PH_
+&G????GGAAID?
+&G????_G@OSA_
+&G????@@@_WG_
+&G???O@?Q?aE?
+&G???G@?I?cE?
+&G???OAC@?BI?
+&G???OOC@?BI?
+&G?A?OA?OACK?
+&G???G@GA?gD?
+&G???O?c@?BI?
+&G???OA?Q?aE?
+&G????O@@_WG_
+&G?????AB?KK_
+&G????_?J?KA_
+&G????O?Q?WH_
+&G????GGB?I@G
+&G???GA?Q?KK?
+&G???OA?I?HK?
+&G???CAAA?KK?
+&G????_A?_o@o
+&G????_CA_OP_
+&G????_@B?IA_
+&G?????EAOWG_
+&G????G@B?cA_
+&G????_@@_OW_
+&G????GAB?c@_
+&G????_GB?W@_
+&G???OA?O_gK?
+&G????_@B?WG_
+&G????_G@_OP_
+&G????G@B?aA_
+&G?????KB?gB?
+&G?????AA_SK_
+&G?????EB?KG_
+&G????GC?GgL?
+&G????G@@_oGO
+&G????_?J?SA_
+&G????_@B?SA_
+&G???OA?I?PK?
+&G???OA?Q?PK?
+&G????G?P?gH_
+&G????O@A_GW_
+&G????OA@?gH_
+&G????OCA_GX?
+&G????GGB?Q@G
+&G????OAB?c@_
+&G????GCA_OX?
+&G????_AB?SB?
+&G????G?J?cA_
+&G????_@B?KA_
+&G???@@CA?WG_
+&G???G@C@?gG_
+&G???O@@A?gC_
+&G????_GB?SA_
+&G?A?O_?O_AK?
+&G???OAGA?PK?
+&G???AACA?DI?
+&G???OA?Q?WD?
+&G???A_C@?EI?
+&G???OAGA?WD?
+&G???OAG@?DI?
+&G????_AB?aD?
+&G???OACA?cE?
+&G????GCA_WH?
+&G????O?P?gH_
+&G????O@A_OW_
+&G???GOCA?@J?
+&G???G@G@?WGG
+&G???AAC@?DI?
+&G???OA?Q?cE?
+&G?G?AA?O@_E?
+&G?A?O_?P?AK?
+&G???C?gA?OB_
+&G???G@G@?KGG
+&G???C_C@?_B_
+&G???O_C@?IGG
+&G???O_CA?H?g
+&G???OAG@?HI?
+&G???OOCA?IGG
+&G???OACA?gE?
+&G????GAB?a@G
+&G????_AB?K@_
+&G???COCA?AX?
+&G???COG@?EH?
+&G???OAC@?DI?
+&G????_CB?aB?
+&G??Q?A?I?OE?
+&G???OACA?PK?
+&G???O_C@?H?g
+&G???OACA?HI?
+&G??A?_C@?EAG
+&G???OOG@?II?
+&G???O_G@?IAO
+&G????_AB?SC_
+&G???OOCA?II?
+&G????GCB?gH?
+&G????A?Q?WL?
+&G????G@A_o?o
+&G???OAG@?@M?
+&G???CACA?G[?
+&G???O@?I?gC_
+&G???CAC@?DI?
+&G?A?O_?OA?[?
+&G?G?O_?OAOE?
+&G???G?_Q?OJ?
+&G???CAG@?CY?
+&G???GO?Q?OJ?
+&G???GOG@?GX?
+&G???OAG@?@Y?
+&G???O_G@?I?o
+&G???OACA?WGG
+&G???GOCA?KH?
+&G???OA?OAgK?
+&G???OA?Q?HK?
+&G?A?OA?E?@K?
+&G?G?O?g?GOE?
+&G?A?OA?OAGK?
+&G???O@C@?WG_
+&GOA?OA?OAGG?
+&G?A?O_?Q?AK?
+&G?@?AA?O@_E?
+&G??_O?_Q?OE?
+&G?@A?A?O@_E?
+&G??_O?gA?OE?
+&G?@A?A?OAOE?
+&G???O@CA?gG_
+&G?A?OA?P?_K?
+&G???OACA?WK?
+&G?????G@OIM?
+&G????@@B?WG_
+&G????GG?OQM?
+&G???O?OQ?WK?
+&G????_?R?SA_
+&G???O@?Q?gC_
+&G???OA?E?PK?
+&G?A?O_?OOAK?
+&G????AAA?PL?
+&G???G@?I?SE?
+&G????GC?_aL?
+&G???O?S@?gG_
+&G????_AB?S?o
+&G???OAG@?BI?
+&G????GCA_PH?
+&G???OACA?WG_
+&G????G?Q_o@_
+&G???G@?Q?KK?
+&G???@ACA?HK?
+&G?@?GAGA?@E?
+&G???GAC@?DI?
+&G???COC@?IH?
+&G?G?CA?Q?CE?
+&G?G?AA?Q?_E?
+&G???C?W@?EI?
+&G?@?GA?OA_E?
+&G???@OG@?IH?
+&G?@?GA?Q?_E?
+&G???O_G@?I@O
+&G???COGA?IH?
+&G???OOCA?IH?
+&G???O_G@?IK?
+&G?????C@OgKO
+&G?????GA_KKO
+&G????OG?OgKG
+&G????GG?OgKG
+&G?????c@_PH?
+&G????_@A?IL?
+&G???OA?I?_[?
+&G??A?A?O__M?
+&G????AAA?oHG
+&G????GG?O`KG
+&G????OG@?gHG
+&G????GG?_cKG
+&G????GGAAo@O
+&G????_AA?EL?
+&G????_AB?`AG
+&G????_G?_KL?
+&G????_G?OWL?
+&G????_?F?WGO
+&G??A?ACA?GM?
+&G???AACA?_[?
+&G???@AGA?WG_
+&G???@AGA?SG_
+&G?G?OA?E?OK?
+&G?G?OACA??[?
+&G??A?ACA?GJ?
+&G???@ACA?cGG
+&G??A?OG@?GJ?
+&G???AOG@?_X?
+&G???O_CA?AX?
+&G???@_CA?EH?
+&G???O_G@?cCG
+&G???AOG@?SH?
+&G????@@@@WH?
+&G????AC?OWH_
+&G???G@?E?QGG
+&G??@?GC?GCJ?
+&G???CA?OAQI?
+&G????_G?OIL?
+&G?A?@A?O_OK?
+&G??A?A?Q?GM?
+&G???A@A@?CY?
+&G???GG?P?CJ?
+&G???AGC@?AY?
+&G???GGC@?CJ?
+&G???O?Q@?DI?
+&G????_A?OaL?
+&G???OA?I?SG_
+&G????_A?OgL?
+&G???O?a?OgK?
+&G???CG?I?HK?
+&G?A?@AG@?GK?
+&G?G@?AG?@GE?
+&G?A?OAA?OAK?
+&G???AAGA?aCO
+&GOAA?A?Q?OA?
+&G?G?OAG@??[?
+&G??_O_?CGOE?
+&G?@@?AG?@GE?
+&G??a?A?E?OE?
+&G?@@?_G?@GE?
+&G??a?A?GAOE?
+&G???AACA?QCO
+&G?A?OOG?_CK?
+&G???AACA?QK?
+&G????AC?OgH_
+&G????@@@@gH?
+&G??@?GG?GCJ?
+&G???G@?E?aCG
+&G???A@@@?DI?
+&G???O@?OASI?
+&G?G@?A?O@GE?
+&G?A?@A?P?GK?
+&G???G?c?__B_
+&G???@@A@?KGG
+&G???OOG?__B_
+&G???@GC@?IGG
+&G???OACA?E?W
+&G???O?P@?HI?
+&G???OACA?EGG
+&G???GA?I?WI?
+&G????G?F?c@G
+&G????_?F?K@G
+&G???C?cA?AW_
+&G???C?c@?AW_
+&G???O@?H?DI?
+&G????O?PAWH?
+&G?G@?A?G@GE?
+&G???O@?I?_[?
+&G???@ACA?D?W
+&G???O@?H?GY?
+&G???AOGA?CP_
+&G???G?c@?GY?
+&G???AACA?E@O
+&G????G?QAoH?
+&G???G?cA?II?
+&G????O?E_oGO
+&G?????A?WoGo
+&G?????@@GWGo
+&G????OG?GKHG
+&G????OA?GKHG
+&G????O?Coa@O
+&G????AC?OHH_
+&G???OA?H?@WO
+&G??@?G?OACJ?
+&G????G?Q?S@g
+&G????OA?GDHG
+&G????GGA?S@g
+&G????OA?_EHG
+&G????GCAOD?g
+&G????G@@?BH_
+&G????GGAACT?
+&G????G@@?QH_
+&G?????KAACQO
+&G?????C?WWGo
+&G????_@AAOQO
+&G????OC?GKHG
+&G????@@AAKC_
+&G?????GAOIKO
+&G???OA?O@PGG
+&G????_@?GgKG
+&G????G@@A_Oo
+&G????A?P?KHG
+&G????OC?a_PO
+&G????AC@?KHG
+&G????@AAAS@_
+&G?????AAOaKO
+&G????@CAAKD?
+&G?????AAOgKO
+&G?????G?ooKO
+&G?????A?oKKO
+&G????GG?OoL?
+&G????O?D_WGO
+&G????_A?_oM?
+&G???GA?I?oK?
+&G?????g@_`H?
+&G????G@?_IL?
+&G???@ACA?gG_
+&G???@AC@?SG_
+&G???@_C@?gK?
+&G?AA?AAA?AK?
+&G????AGA?WHG
+&G????GA?OHKG
+&G??@?AGA?GJ?
+&G???@AGA?cCG
+&G???O_G@?OM?
+&G?AA?A?E?AK?
+&G????GA?ao@O
+&G????GA?_EL?
+&G???OOGA?AX?
+&G???@OC@?EH?
+&G??A?_C@?G[?
+&G?GA?_?GAOE?
+&G?????`@_`H?
+&G????G@?GIL?
+&G???G@?I?PC_
+&G???CG?I?PI?
+&G???@GC@?gK?
+&G?AA?AA@?AK?
+&G???GA?C_KK?
+&G????_G?OEM?
+&G?@?OAG?GOE?
+&G???@AGA?BK?
+&G?@?O_GA?OE?
+&G?GA?AG?GOE?
+&G???OA?GGG[?
+&G???OA?O_@M?
+&G?G?OA?CGOE?
+&G?A?OAC?G?[?
+&G?A?O?WA?CK?
+&GOA?O_?Q?C?O
+&G???@AA?GKK?
+&G????_@?OaM?
+&G??_AAG?AOE?
+&G???C@?E?gK?
+&G?G?A_G?AOE?
+&G?AA?AG?_AK?
+&G????AG?OWHG
+&G????G@?GIKG
+&G??@?AG?_CJ?
+&G???O@?E?cCG
+&G???O_C@?GM?
+&G?AA?A?D?AK?
+&G???OA?G_G[?
+&G???OA?O_CM?
+&G?@A?A?D?GE?
+&G?A?OAC?_?[?
+&G?A?O?WA?OK?
+&GOA?O_?Q?O?O
+&G????_G?OW@g
+&G????GA?OEKG
+&G??A?_C?_AB_
+&G???@AC@?BGG
+&G??@?OGA?GJ?
+&G?GA?A?CGOE?
+&G????_@@__PO
+&G????AA?GKL?
+&G???G@G@?BGG
+&G???C@?I?WI?
+&G???O_C@?SGG
+&G?AA?AC?_AK?
+&G????G?Cao@O
+&G????GA?AEL?
+&G???G?cA?@W_
+&G???A?S@?BG_
+&G???A_C@?C[?
+&G?GA??_G@OE?
+&G???@AA?AKK?
+&G????_?GO`M?
+&G??_AAG?@OE?
+&G???C?_E?gK?
+&G?G?A_G?@OE?
+&G?AA?AG?G?[?
+&G????_?H__PO
+&G????AA?AKL?
+&G???@ACA?BGG
+&G???C?_E?gE?
+&G???AOGA?OX?
+&G?AA?AC?G?[?
+&G????@?J?KB?
+&G??????QOcM?
+&G???C@?I?WE?
+&G????@?J?gK?
+&G???AOC@?cH?
+&G???C@?I?oK?
+&G?????C?oaGo
+&G?????@?gIKO
+&G????GC?OaH_
+&G????G?QASD?
+&G????GC@?cL?
+&G???GA?I?PCO
+&G????G?J?D@_
+&G????AA?OBL?
+&G???@ACA?H?o
+&G???CG?D?DI?
+&G???@OGA?KH?
+&G?G?AA?GGOE?
+&G????G?OOo@g
+&G????G?OOEKG
+&G???COG?GCB_
+&G???O@?D?HGG
+&G??@??gA?GJ?
+&G?G?AA?CGOE?
+&G????G@B?D?g
+&G????AA?GDL?
+&G???CACA?GOo
+&G???C@?D?KI?
+&G???OOGA?GX?
+&G?@?O_?GAOE?
+&G?????K?aE@O
+&G?????A?WHK_
+&G????O@?``H?
+&G????_?EAKD?
+&G????_GB?OQO
+&G???O@@A?PGG
+&G????@@B?K?g
+&G?????GAOBM?
+&G???CG?P?CY?
+&G????_?I_o@O
+&G???OOC@?GX?
+&G???C@GA?A[?
+&G?????`@__Oo
+&G????A?OAKL?
+&G???O?OP?HGG
+&G???OA?CAWI?
+&G???O?S@?WGG
+&G?A?O?OP?@K?
+&G????@?J?K@_
+&G??????QOaM?
+&G???C?OP?KI?
+&G?????_Q_oH?
+&G???@OC@?KH?
+&G???@@?Q?gK?
+&G?????G@_EGW
+&G?????@?QIKO
+&G????OG?OIHG
+&G????O?OaOX?
+&G????_C@?KKG
+&G???GA?E?PGG
+&G?????`@_@W_
+&G?????`?GHL?
+&G???O?_P?@Y?
+&G???OA?G@WG_
+&G???O?WA?WGG
+&G?A?O?OOO@K?
+&G?????GB?K?w
+&G?????A?IKKO
+&G????OG?Og@g
+&G????O?H__PO
+&G????OGA?WHG
+&G???O?`A?@[?
+&G?????K?o_Oo
+&G??????GgKK_
+&G????G@B?_PO
+&G????@?J?KH?
+&G????GAB?_QO
+&G???@AA?GgK?
+&G?????@?QWGo
+&G?????@?OYGo
+&G????OA?GQHG
+&G????GA?ASH_
+&G????OA?_WHG
+&G??@?O?GAGJ?
+&G?????_OOWH_
+&G?????G?GkKO
+&G???G?c?GGJ?
+&G????AG?AgL?
+&G??@??c@?GJ?
+&G???O_?Q?@M?
+&G?????G?IKKO
+&G?????G?GpBO
+&G????GG?OEKG
+&G????AG?AKL?
+&G????_A?_KKG
+&G???O_?O_@M?
+&G??????IGKK_
+&G??????B?eM?
+&G????AA?GcL?
+&G??????QOoM?
+&G????GA?_cL?
+&G????_@?OoM?
+&G?????G@OgKO
+&G?????AA_KKO
+&G????_C?OWL?
+&G????O?F?WGO
+&G????@C@@WH?
+&G????O@@?WH_
+&G???O?aA?gK?
+&G???AAGA?EK?
+&G????G@A?oH_
+&G????@G@@gH?
+&G????_G@?WL?
+&G???O?`A?gK?
+&G????GGB?c@G
+&G????_GB?K@G
+&G????_CB?WGO
+&G???OAGA?EK?
+&G????_G?OWKG
+&G????GA?OgKG
+&G??A?AC@?GM?
+&G???AAGA?O[?
+&G???@AGA?WGG
+&G??@?G?P?OJ?
+&G?A?@AGA?OK?
+&G?G@?AGA??U?
+&G??@?G?Q?_J?
+&G???@AGA?gCG
+&G??A?ACA?OM?
+&G?A?@AGA?GK?
+&G???GOGA?CX?
+&G???GOC@?CX?
+&G???O_G@?O[?
+&G?G@?AGA?GE?
+&G?????`@_PH?
+&G????_@?GIL?
+&G???G@?I?`C_
+&G???CG?I?`E?
+&G???CG?OAQI?
+&G????_G?GIL?
+&G?A?OAA@?CK?
+&G???AAGA?`C_
+&G???A@A@?DI?
+&G???O@A?ASI?
+&G???@GGA?WG_
+&G?A?OAA@?AK?
+&G???O@A@?DI?
+&G????O@@_PH?
+&G???OAGA?SG_
+&G???G@GA?aCO
+&G???OA?GG_[?
+&G??A?A?O_@M?
+&G?G?OA?D?AK?
+&G?G?OAC?G?[?
+&G?A?@A?O_@K?
+&G??A?A?Q?@M?
+&GOAA?A?Q?O?O
+&G?G?OAG?G?[?
+&G?G@?A?O@@E?
+&G?A?@A?P?@K?
+&G?G?OA?E?AK?
+&GOAA?A?Q?G?O
+&G?G@?A?GAGE?
+&G???O@?Q?_[?
+&G?G?OACA?AK?
+&G?G?OAG@?AK?
+&G????AA?OoHG
+&G????G@?GaKG
+&G??A?AC?_CJ?
+&G???O@?E?SCG
+&G???A@@@?CY?
+&G???GG?P?AJ?
+&G?@?G_?D?GE?
+&G??`?A?Q??U?
+&G???AAC?__B_
+&G???C?Q@?KGG
+&G???G_CA?GJ?
+&G??_O?W?OOE?
+&G???OACA?D?W
+&G???O@@@?GY?
+&G???OACA?cGG
+&G?@@?AG?OGE?
+&G????OC?OgHG
+&G????GA?OcKG
+&G??A?OC?_CJ?
+&G???AAC@?_W_
+&G???AAC@?AY?
+&G???CG?P?OJ?
+&G?@A??W@?GE?
+&G??`?AGA??U?
+&G???OOG?G_B_
+&G???@AC@?IGG
+&G??@?_G@?GJ?
+&G?G?O?W?OOE?
+&G???O_CA?E?g
+&G???GAC@?GY?
+&G???O_G@?SCG
+&G??`?AGA?GE?
+&G????G?EAo@O
+&G????_A?AEL?
+&G???G?g@?@W_
+&G???A?W@?BG_
+&G???O?OH?DI?
+&G????_A?AaL?
+&G??a?A?G@OE?
+&G???A?W@?`G_
+&G???@ACA?E?W
+&G???O?OH?HI?
+&G???A_CA?AX?
+&G?@A??_G@OE?
+&G???AACA?D@_
+&G????O?E_`H?
+&G???A_CA?EH?
+&G???AACA?PC_
+&G????G?J?GWO
+&G????_A?AKL?
+&G???AAG@?OW_
+&G???A?W@?aC_
+&G???O?OI?cE?
+&G????_A?AgL?
+&G?A?OOG?_?[?
+&G???A?W@?aK?
+&G???@ACA?EGG
+&G???O?OI?gE?
+&G???A_G@?OX?
+&G?A?OOG?O?[?
+&G???G?SA?II?
+&G????O?I_oGO
+&G???A_G@?SH?
+&G???@ACA?QK?
+&G?????AAOQGo
+&G?????@AGIKO
+&G????_C?OIH_
+&G????G?QAcD?
+&G????O?Cgc@O
+&G????@@@?HH_
+&G???O?a@?HGO
+&G???O@?H?KGO
+&G????GG?OQ@o
+&G????G?Q@S@_
+&G????GGA?SH_
+&G???O?`@?HGO
+&G????_C?oAP_
+&G????O@?gc?o
+&G????GGAAcD?
+&G???O@A@?KGO
+&G????O@?GgHG
+&G????G@?GcKG
+&G??A?O?OOGJ?
+&G???O@?E?PCG
+&G???AA?P?@Y?
+&G???CG?P?AJ?
+&G?@A??OO_OE?
+&G??P?A?Q??U?
+&G???OOG?G@B_
+&G???@A?P?HGG
+&G??@?_G?AGJ?
+&G?G?O?P?AOE?
+&G???OACA?@Oo
+&G???CA?P?GY?
+&G???OACA?_W_
+&G??`?AG?OGE?
+&G?????KAGH@G
+&G?????G?WHK_
+&G????_@?`PH?
+&G????O?EAKD?
+&G?????PAAKC_
+&G?????GAOHK_
+&G???OAA?_QGG
+&G????_?E_PH?
+&G????O@?``@_
+&G?????PAAIC_
+&G????_G?`PH?
+&G???OAA?_SGG
+&G????G@AAQ@_
+&G?????KA_a@O
+&G????OCAAKD?
+&G????_@A_PH?
+&G?????`B?GWO
+&G????_?GGKL?
+&G???G@?E?`CG
+&G???O?OI?`CO
+&G???G@?G@WG_
+&G????_?GGgL?
+&G?A?OO?O@GK?
+&G???O?OI?`K?
+&G???CA?D?HGG
+&G???G@?CAgE?
+&G???O?gA?OW_
+&G?A?OO?O@CK?
+&G???CA?D?HI?
+&G?????`A_oGO
+&G???O?gA?QG_
+&G???O?OQ?`K?
+&G?????CA_EGW
+&G?????@AAIKO
+&G????_A?OQHG
+&G????G?PAOX?
+&G????_?OBSA_
+&G?????`@?HH_
+&G???O?a@?GWO
+&G???O?OH?KGO
+&G????G@A?P@g
+&G????G?QAAT?
+&G????_AA?QHG
+&G???O?`@?GWO
+&G????GCAOB?g
+&G????O?Ggc?o
+&G????GC@@PH?
+&G???O?Q@?KGO
+&G?????CA_SGW
+&G?????AAAKKO
+&G????_C?OWHG
+&G????O?H__WO
+&G?????c@_@X?
+&G?????`@?WH_
+&G???O?aA?G[?
+&G???O?OI?KK?
+&G????G@A?o@g
+&G?????c@__PO
+&G????_G@?WHG
+&G???O?`A?G[?
+&G????GGB?D@G
+&G????@GB?K@G
+&G????_AB?HAG
+&G???O?QA?KK?
+&G?????@@AWGo
+&G?????C?OYGo
+&G????OA?GIHG
+&G????OA?ASH_
+&G?????c?OHH_
+&G?????G@?iHO
+&G???GO?GGGJ?
+&G????GG?AaL?
+&G????OA?GBHG
+&G????@A?ASH_
+&G????OA?_IHG
+&G???GO?GAGJ?
+&G????@A@?DH_
+&G?????@AAgK_
+&G????OA@?SH_
+&G????GG?GaL?
+&G?????G?aKKO
+&G?????G@?iD_
+&G????GG?OKKG
+&G????GG?AKL?
+&G?????`A?IL?
+&G?????G?_kK_
+&G???OAA?O_M?
+&G????_C?AcM?
+&G????GG?ODKG
+&G????A?I?KL?
+&G????GG?_KKG
+&G???OAA?G_M?
+&G????AAA?EL?
+&G?????G@OPM?
+&G????GG?_KL?
+&G????OG?OSM?
+&G?????A@OgKO
+&G?????AAOKKO
+&G????_A?OWL?
+&G????O?E_WGO
+&G????@C?`WH?
+&G????G@@?WH_
+&G???O?aA?WK?
+&G???AACA?EK?
+&G????G@@?oH_
+&G????@C?`oH?
+&G????_G?_WL?
+&G???O?`A?WK?
+&G????GGB?S@G
+&G????OGB?K@G
+&G????_CA_WGO
+&G???OACA?EK?
+&G?????g@_PH?
+&G????_@?_IL?
+&G???@AG@?WG_
+&G???@AG@?SG_
+&G???GA?I?SI?
+&G????_G?_IL?
+&G?A?OAAA?CK?
+&G???AOCA?QH?
+&G???AACA?EI?
+&G???OA?I?SI?
+&G???AOG@?SI?
+&G?A?OAAA?AK?
+&G???OACA?EI?
+&G????OG@_PH?
+&G???O_G@?cE?
+&G???O_G@?cC_
+&G????AC@?gHG
+&G????GA?O`KG
+&G??A?AC@?GJ?
+&G???@AGA?SCG
+&G???AAC@?CY?
+&G???GG?P?OJ?
+&G??_O_?E?OE?
+&G?@@?AGA??U?
+&G???G@G@?OB_
+&G???@AC@?KGG
+&G???G_CA?OJ?
+&G?@?C_?O@_E?
+&G???O_CA?I?g
+&G???OAC@?GY?
+&G???O_G@?WCG
+&G?@@?AGA?GE?
+&G????GAAAo@O
+&G????_A?_EL?
+&G???O_C@?AX?
+&G???@_C@?EH?
+&G???O?S@?EI?
+&G????_A?_aL?
+&G??a?A?I?OE?
+&G???AOG@?aH?
+&G???O_C@?K?g
+&G???O?S@?II?
+&G??A?OG@?CY?
+&G?@A??g?AOE?
+&G???O_C@?KA_
+&G????OCA_`H?
+&G??A?OG@?KI?
+&G???O_C@?cG_
+&G????_@?GWKG
+&G????G@?GgKG
+&G??A?A?P?GM?
+&G???O@?I?O[?
+&G???O@?E?QGG
+&G??@?G?P?AJ?
+&G?A?@A?Q?OK?
+&G?G@?A?Q??U?
+&G??@?G?Q?AJ?
+&G???O@?E?aCG
+&G??A?A?P?_M?
+&G?A?@A?Q?GK?
+&G???O@CA?AW_
+&G???O@C@?AW_
+&G???OACA?_[?
+&G?G@?AG?OGE?
+&G???OA?OA_[?
+&G??A?A?O_CM?
+&G?G?OA?O@OK?
+&G?G?OA?P??[?
+&G?A?@A?O_CK?
+&G??A?A?Q?CM?
+&GOA?OA?OAA?O
+&G?G?OA?Q??[?
+&G?G@?A?OA?U?
+&G?A?@A?P?CK?
+&G?G?OA?O@_K?
+&GOA?OA?OAA?G
+&G?G@?A?OAGE?
+&G???OA?Q?_[?
+&G?G?OA?P?_K?
+&G?G?OA?Q?OK?
+&G????OC?GgHG
+&G????GA?OaKG
+&G??A?OC?GGJ?
+&G???A@C@?_W_
+&G???AAC@?@Y?
+&G???AG?P?OJ?
+&G??Q?AG?@OE?
+&G??P?AGA??U?
+&G???OOG?A_B_
+&G???@AC@?HGG
+&G??A?O?P?_J?
+&G?G?GA?E?@E?
+&G???O_CA?B?g
+&G???CAC@?GY?
+&G???O_G@?QCG
+&G??P?AGA?GE?
+&G????G@B?`AG
+&G????_A?GKL?
+&G???G@G@?OW_
+&G???AACA?`CO
+&G???G@?I?WG_
+&G????_A?GgL?
+&G?A?OO?Q?GK?
+&G???AACA?`K?
+&G???G@CA?IGG
+&G???G@?I?WI?
+&G???O_C@?QGG
+&G?A?OO?Q?CK?
+&G???CAG@?HI?
+&G????O@A_oGO
+&G???O_C@?aC_
+&G???G@G@?aK?
+&G?????A@OaKO
+&G?????@A_IKO
+&G????_A?OQL?
+&G????G?PAoH?
+&G????G?QAQH?
+&G????G@@?HH_
+&G???OA?I?SCO
+&G???C?cA?HG_
+&G????G@@?`H_
+&G????G?QAQD?
+&G????_AA?QL?
+&G???GA?I?WCO
+&G????GCAOa@O
+&G????_C?oa@O
+&G????GCB?PH?
+&G???CGCA?HG_
+&G????O?I_`@_
+&G????_A?OBL?
+&G???@AG@?HG_
+&G???G?W@?HG_
+&G???O?P@?BI?
+&G????_G?_BL?
+&G?@A?A?OOAE?
+&G???@_G@?BH?
+&G???AACA?EAO
+&G???O?Q@?BI?
+&G???@_CA?IH?
+&G?@A?A?OO@E?
+&G???OACA?H@_
+&G????_CA_`@_
+&G???O_CA?IH?
+&G???O_G@?BH?
+&G????A?P?gHG
+&G????G?OOaKG
+&G??A?A?P?GJ?
+&G???O@?E?WCG
+&G???AA?P?CY?
+&G???GG?OAOJ?
+&G??OOAG?@OE?
+&G?@@?A?Q??U?
+&G???G@C?A_B_
+&G???G?OP?KGG
+&G???G_?P?_J?
+&G?@?CAG?@@E?
+&G???OACA?H?W
+&G???OA?P?GY?
+&G???OACA?gGG
+&G?@@?A?Q?GE?
+&G????G@AAo?o
+&G????_A?GDL?
+&G???CAG@?GW_
+&G???C?W@?IG_
+&G???O?OP?EI?
+&G????_A?G`L?
+&G??_O_?GGOE?
+&G???@@G@?cG_
+&G???G@CA?CQ_
+&G???O?OP?II?
+&G???G_CA?GX?
+&G??_O_?GAOE?
+&G???G@CA?KA_
+&G????O@A_`G_
+&G???G_CA?KH?
+&G???CAG@?gG_
+&G?????G@OIKO
+&G?????@AOIKO
+&G????_C?OIL?
+&G????G?PAWH?
+&G????_?QAID?
+&G????O@@?HH_
+&G???OA?I?cCO
+&G???C?c@?HG_
+&G????G@A?PH_
+&G????G?QAID?
+&G????_CA?IL?
+&G???GA?I?gCO
+&G????GC@Oa@O
+&G????OC?oa@O
+&G????GC@_PH?
+&G???CGC@?HG_
+&G?????`@_PG_
+&G????_@?GHL?
+&G???G@?I?`E?
+&G???O@?I?`E?
+&G???O@?OAQI?
+&G????_G?GHL?
+&G?A?OA?OOAK?
+&G???@@GA?SG_
+&G???O?_P?BI?
+&G???OA?OAQI?
+&G???O?WA?WG_
+&G?A?OA?OO@K?
+&G???OA?P?BI?
+&G????O@@_PG_
+&G???OAGA?WG_
+&G???CAGA?WG_
+&G?????CAOWGo
+&G?????AAGKKO
+&G????_C?OWH_
+&G????O?Q@WH?
+&G????_?F?I@G
+&G????@@@?WH_
+&G???O?aA?HK?
+&G???O@?I?KK?
+&G????GG?Oo@o
+&G????_?O`o@_
+&G????_CA?WH_
+&G???O?`A?HK?
+&G????GGB?CP_
+&G????_@B?I?g
+&G????OGA@WH?
+&G???O@AA?KK?
+&G?????K?oHGG
+&G?????G?gKK_
+&G????_@@_OX?
+&G????G?J?KH?
+&G?????`B?IH?
+&G?????GA_KK_
+&G???OAA?OgK?
+&G????_?F?WH?
+&G????_@@_OP_
+&G?????`B?IG_
+&G????_G@_OX?
+&G???OAA?GgK?
+&G????G@B?a@_
+&G?????KA_KG_
+&G????GAB?cB?
+&G????_@B?WH?
+&G?????G?ooGo
+&G?????A?gKKO
+&G?????K?o`GG
+&G?????A?gKK_
+&G????GG?OoH_
+&G????_?O`oH?
+&G????O@A__X?
+&G????_?J?KH?
+&G????_C@?gL?
+&G???O?`A?`K?
+&G????GAA_oGO
+&G???O@@A?`K?
+&G????_G?GWHG
+&G????GA?OIKG
+&G????G@B?HAG
+&G????GA?GKL?
+&G??@?_G?GGJ?
+&G???A@GA?OW_
+&G???G@CA?_W_
+&G???AAGA?PGO
+&G??A?AG@?OM?
+&G?G?O_?O@@K?
+&G???O_C@?_[?
+&G?G?O_?P?@K?
+&G?????`B?BB?
+&G????A?OOHL?
+&G????@@B?I@_
+&G?????GAGEM?
+&G???AG?P?DI?
+&G???OAA?ASI?
+&G???O@?P?KI?
+&G????_?R?cB?
+&G???O?c@?WH?
+&G?A?OO?O_@K?
+&G???OOC@?KI?
+&G???GAGA?`CO
+&G???O?`?GG[?
+&G???OAA?G@M?
+&G???O?Q?GKK?
+&G????_@?GcM?
+&G?G?O?P?GOE?
+&G?A?OO?OO?[?
+&G??`?AG?AGE?
+&G???O@?E?`K?
+&G?A?@AAA?_K?
+&GOAA?AG?AO?G
+&G?G@?_G?AGE?
+&G?G?O_?P?CK?
+&G????@@A?W@g
+&G????G@?GBKG
+&G????G@B?B?g
+&G????A?O_EL?
+&G???O?c?G_B_
+&G???O@?D?KGG
+&G???CACA?GQ_
+&G???O@?D?KI?
+&G???GGCA?_J?
+&G??P?A?E?AE?
+&G???OOGA?GY?
+&G?@@?_?GAGE?
+&G????_@A?W@g
+&G????GA?ODKG
+&G????GAB?D@G
+&G????AA?_EL?
+&G???O_C?G_B_
+&G???@AC@?EGG
+&G???O_C@?E?g
+&G???G?S@?II?
+&G??@?GGA?OJ?
+&G?G@?A?E?AE?
+&G??@?_G@?GY?
+&G?G@?_?GAGE?
+&G????G?F?B@G
+&G????A?G_DL?
+&G????@AB?CP_
+&G?????@AG`M?
+&G???@ACA?I?W
+&G???O?_D?HI?
+&G???C@CA?GQ_
+&G????G?R?_X?
+&G???AOGA?CY?
+&G?@A??OGAOE?
+&G??A?_G@?HAG
+&G???C@CA?_W_
+&G?????g@__PO
+&G????A?G_KL?
+&G????@AB?K@G
+&G?????@AO`M?
+&G???@ACA?IGG
+&G???O?OI?WI?
+&G???GACA?GY?
+&G????G?I_oGO
+&G???A_G@?OY?
+&G?A?@ACA?AK?
+&G??@?_C@?GY?
+&G???GAG@?_[?
+&G?????G?oQGo
+&G?????@?WIKO
+&G?????`B?BA_
+&G????A?OOIL?
+&G????GG?OQH_
+&G????G?QAKD?
+&G???O?_P?HI?
+&G???OAA?AQI?
+&G????_C@?KL?
+&G???GA?I?`CO
+&G???O?c@?WI?
+&G?A?OO?OO@K?
+&G????_@?GWHG
+&G????G@?GKKG
+&G???O?a?GG[?
+&G???OAA?O@M?
+&G??@?_?OOGJ?
+&G???O@?E?`CG
+&G?G?O?OO_OE?
+&G?A?OO?O_?[?
+&G??A?AA@?OM?
+&G?G?OO?O@@K?
+&G?A?@ACA?_K?
+&GOAA?AG?AO?_
+&G?????K?aI@O
+&G?????A?gDK_
+&G????@@B?GP_
+&G?????GAGDM?
+&G????G@A@PH?
+&G????G?EAKD?
+&G???O@?P?KGG
+&G????_?Q_OX?
+&G????_GB?PAG
+&G???O@@A?`CG
+&G???OOC@?KGG
+&G???C@GA?OW_
+&G?????`B?GQO
+&G????G?GGKL?
+&G???O?OGGKK?
+&G?????g?OaM?
+&G???G@?E?PCG
+&G???O?OI?PGO
+&G??`?AG?A?U?
+&G???O?_E?`K?
+&G???O?c@?_[?
+&G?G?OO?O@CK?
+&G?G@?A?E?_E?
+&G?G?O_?O@CK?
+&G?????CAGKGW
+&G?????@?aIKO
+&G????_?H_@P_
+&G?????a?OBL?
+&G????OA?OaHG
+&G????G?PA_X?
+&G???@ACA?H?g
+&G???AG?D?DI?
+&G????GC@?cKG
+&G???GA?E?PCG
+&G???@OGA?KGG
+&G?G?CA?O@AE?
+&G?????CB?KGW
+&G?????A?QKKO
+&G?????g@_@X?
+&G?????`?_IL?
+&G????OA?OgHG
+&G????O?J?GWO
+&G???AACA?AY?
+&G???O?OI?SI?
+&G????OC?_gKG
+&G???O?`A?O[?
+&G???A_C@?OY?
+&G?A?@AAA?AK?
+&G?????@AAWGo
+&G?????G?OYGo
+&G?????g?OW@o
+&G?????G?OwGo
+&G????OA?GaHG
+&G????_A?ASH_
+&G???O?c?A_B_
+&G????_A?AoH_
+&G????OA?_gHG
+&G??A?O?GAGJ?
+&G???OOG@?OB_
+&G??A?O?Q?@J?
+&G?????G@AKKO
+&G?????G@?qB_
+&G?????`A?WH_
+&G?????CA?[K_
+&G????GG?OSKG
+&G????_C?AKL?
+&G???CG?P?_J?
+&G????_C?AgL?
+&G????OA?_gKG
+&G??A?AA@?AM?
+&G??@?GG@?OJ?
+&G??A?AG@?AM?
+&G?????C?ooGo
+&G?????A?WKKO
+&G?????K?oPGG
+&G?????A?WKK_
+&G????GC?OoH_
+&G????O?O`oH?
+&G????O@A_GX?
+&G????O?J?KH?
+&G????GC@?gL?
+&G???O?`A?PK?
+&G????GA@_oGO
+&G???O@@A?PK?
+&G????G?J?DA_
+&G????AA?OHL?
+&G????@@B?KA_
+&G?????GAOEM?
+&G???AACA?BI?
+&G???O@?I?SI?
+&G???O@?Q?WD?
+&G????O?P_oH?
+&G???A_C@?SI?
+&G?A?O_?O_@K?
+&G???O_GA?WD?
+&G???C@C@?aK?
+&G????_?Q?W@g
+&G????GA?OBKG
+&G????_@@__Oo
+&G????A?O_KL?
+&G???AOG?O_B_
+&G???@AC@?DGG
+&G???CACA?IGG
+&G???O@?I?WI?
+&G???GOCA?_J?
+&G?G?CA?E?AE?
+&G???O_C@?WGG
+&G?A?O_?P?@K?
+&G????GAB?B@G
+&G????AA?_DL?
+&G????@AB?K@_
+&G?????@AOaM?
+&G???O_C@?D?g
+&G???C?S@?II?
+&G???GACA?HI?
+&G????O?Q_oH?
+&G??@?OGA?CY?
+&G?@A?_?GAOE?
+&G??@?_C@?KI?
+&G???C@CA?aK?
+&G????A?Q?WHG
+&G????G?OOIKG
+&G????G@?ao?o
+&G????GA?GDL?
+&G??@?A?Q?GJ?
+&G???O@?E?gCG
+&G???CACA?GW_
+&G???C?S@?IG_
+&G???OAG@?OM?
+&G?A?O_?O@@K?
+&G???O_C@?G[?
+&G?G?O_?GAOE?
+&G???OA?OAG[?
+&G???OA?OAGM?
+&G???@@A?GKK?
+&G????_?OOaM?
+&G?G?OA?O@OE?
+&G?A?OA?P??[?
+&G??_O?g?GOE?
+&G???O@?E?gK?
+&G?A?OA?E?_K?
+&GOA?OA?OAGC?
+&G?G?O?gA?OE?
+&G?A?O_?Q?@K?
+&G?????C?oaKO
+&G?????@?oIKO
+&G?????`@_`G_
+&G????G@?GHL?
+&G????GC?OaL?
+&G????O?OaoH?
+&G???G@?I?PE?
+&G???O@?I?PI?
+&G????OA?_cM?
+&G???O?PA?PK?
+&G???O?S@?gK?
+&G?A?O_?OO@K?
+&G????_?H_`@_
+&G????GA?OBL?
+&G???G@?CGKK?
+&G????_G?OBM?
+&G???@ACA?HG_
+&G???G?S@?HG_
+&G?@?GA?Q?@E?
+&G???@AGA?DK?
+&G???@_C@?KK?
+&G?G?CA?Q?AE?
+&G?@?GAGA?_E?
+&G?G?CAGA?AE?
+&G?????GB?KGW
+&G?????A?aKKO
+&G?????GAAKKO
+&G?????GA?qB_
+&G????OG?OgHG
+&G????_?J?GWO
+&G????GG?OcKG
+&G????_G?AKL?
+&G????_C@?gKG
+&G???O?`A?_[?
+&G????_A?_gKG
+&G??A?AAA?AM?
+&G????_G?OWHG
+&G????GA?OKKG
+&G????_?H__WO
+&G????GA?AKL?
+&G??A?OG?_CJ?
+&G???AAGA?OW_
+&G???AACA?_W_
+&G???A?WA?aC_
+&G??A?_C@?GM?
+&G?G?O?W@?CK?
+&G???A_C@?_[?
+&G?G?OOG?O?[?
+&G?????`@_@X?
+&G?????`?GIL?
+&G????A?GOWH_
+&G?????G?GkK_
+&G???AG?P?@Y?
+&G???OA?G@SG_
+&G???GGC?GCJ?
+&G????_@?AgL?
+&G???O?WA?SGG
+&G?A?@AA@?AK?
+&G??@?GC@?CJ?
+&G??A?AG?_AM?
+&G???O?a?OG[?
+&G???OAA?OAM?
+&G???O?Q?AKK?
+&G????_?GOcM?
+&G?@A??P@?GE?
+&G?A?OOA?O?[?
+&G??`?AG?@GE?
+&G???C?_E?`K?
+&G?A?@_G@?GK?
+&GOAA?AG@?G?_
+&G?G@?_G?@GE?
+&G?G?O_C?O?[?
+&G????AG?OW@g
+&G????G@?GEKG
+&G?????`@__PO
+&G????A?GGKL?
+&G???OOG?_AB_
+&G???CG?D?HGG
+&G???@G?P?HGG
+&G???GA?CAgE?
+&G??@?GGA?CJ?
+&G?G@?A?CGGE?
+&G???O?S@?SGG
+&G?A?@AC?_AK?
+&G????G?F?D@G
+&G????AA?AEL?
+&G????@?F?K@G
+&G??????QAcM?
+&G???AACA?@Oo
+&G???C?_D?HI?
+&G???C@?H?GY?
+&G?????_E_oGO
+&G???AOGA?CX?
+&G?G@??_G@GE?
+&G???AOC@?CX?
+&G???C@?I?_[?
+&G?????G@_E?w
+&G?????@?IIKO
+&G?????@?IWGo
+&G?????@?GXGo
+&G????OG?OI@g
+&G????G?QACT?
+&G????OA?GEHG
+&G????AA?ASH_
+&G????OGA?KHG
+&G???O?`@?@WO
+&G????OA?_KHG
+&G??@?G?GACJ?
+&G?????E?Q_Oo
+&G??????OQIK_
+&G??????GWWGo
+&G??????B?kGo
+&G????G@@A_PO
+&G????@?EAKD?
+&G????AA?GSHG
+&G??????IOgKO
+&G????_GAAOQO
+&G???O@@?@PGG
+&G????OC@?KHG
+&G????_@?OgKG
+&G?????G@_SM?
+&G????OG?OWM?
+&G????@CB?gH?
+&G???@ACA?WK?
+&G????ACA?WL?
+&G???O_?Q?OM?
+&G????_AA_o@O
+&G???O_G@?A[?
+&G????_?R?QA_
+&G???@G@A?WK?
+&G???GAC@?KI?
+&G?@?O_G?AOE?
+&G???OA?I?gC_
+&G?A?O?OOO_K?
+&G???GGC@?EI?
+&G?G?AA?I?OE?
+&G????AAA?SL?
+&G????GC?_cL?
+&G???G?SA?KI?
+&G???@OG@?KH?
+&G???G?cA?GJ?
+&G??@??g@?GJ?
+&G???GGCA?CY?
+&G???OOG@?GX?
+&G????GCB?_PO
+&G????_AB?OQO
+&G???O_G@?DAG
+&G???O?cA?AY?
+&G???O?W@?WGG
+&G???A_CA?EB?
+&G????ACA?KL?
+&G???O_?O_OM?
+&G???OA?I?gE?
+&G?A?O?OP?_K?
+&G????GAA?SH_
+&G??@?OG?AGJ?
+&G????_AAAKD?
+&G???OACA?OW_
+&G????GC@__PO
+&G???O?cA?A[?
+&G???OAC@?IGG
+&G?G?AA?E?OE?
+&G????GG?`PH?
+&G???O?cA?OW_
+&G????GAAASD?
+&G???O?c@?aG_
+&G????OAA?EKG
+&G????_C?_KKG
+&G???O?SA?IGG
+&G????OAA?QHG
+&G????OG?_WHG
+&G????GC@@`H?
+&G????OAA?o@g
+&G???C_C?O_B_
+&G????OG?_IHG
+&G????OA@?cH_
+&G????@@B?oI?
+&G???G@?I?oK?
+&G???CA?Q?gK?
+&G?AA?AG?_@K?
+&G???CA?I?gK?
+&G?AA?AG?A?[?
+&G???OAGA?BK?
+&G?GA?AG?AOE?
+&G???O@?Q?aC_
+&G?AA?AC?_@K?
+&G???COC@?EH?
+&G?A?OAC?_@K?
+&GOA?O_?Q?O?G
+&G???G@C@?WG_
+&G???CA?I?WE?
+&G??OAA?I?OE?
+&G??OAA?E?OE?
+&G?@?OAG?AOE?
+&G???OAG@?BGG
+&G???COGA?AX?
+&G?@A?A?CAOE?
+&G???@@CA?gG_
+&G???CA?I?gE?
+&G?AA?AC?A?[?
+&G?A?OAC?G@K?
+&G???O?c@?BG_
+&G?GA?A?CAOE?
+&G???OA?Q?aCO
+&G???OAC@?BGG
+&G???G@C@?WGG
+&G???OA?Q?aCG
+&G????O@@_WGO
+&G???O?W@?BGG
+&G?@A?A?CG@E?
+&G???O?cA?@W_
+&G???OA?I?PC_
+&G??A?_C?_@B_
+&G???GOGA?@J?
+&G???GOG?AGJ?
+&G????GG?GoL?
+&G?????@B?gK_
+&G????G?J?cG_
+&G????G?Q?oH_
+&G????_AB?a@G
+&G????O?QOaA_
+&G???O@@@?II?
+&G???AAA@?DI?
+&G???O@A@?EI?
+&G????@A@?cH_
+&G???@@CA?K@_
+&G???A@C?__B_
+&G???O@CA?GP_
+&G????GCAAAX?
+&G???O?SA?H?g
+&G????@AA?SH_
+&G???OA?H?HI?
+&G????OC?_c@o
+&G????_AA@S@_
+&G????GCAAAT?
+&G???CAA@?KGG
+&G????OA@@`@_
+&G????G@AAQC_
+&G????OG?_BHG
+&G????OAA?P@g
+&G?????E@_SG_
+&G????_@B?aB?
+&G????_@B?GW_
+&G????_GB?K@_
+&G????_@AGSA_
+&G???OA?O_gD?
+&G????G@AAIC_
+&G????GAA@S@_
+&G?????G@OKM?
+&G????@C@_gH?
+&G????AAA?WL?
+&G????OAA_o@O
+&G???GAGA?WD?
+&G???AACA?cE?
+&G???OOG@?EI?
+&G???G@C@?_J?
+&G???OOCA?AY?
+&G??A?_C@?IAO
+&G????GG?OPM?
+&G???OA?E?WK?
+&G????GA@?aL?
+&G????GCB?HH?
+&G???@ACA?KK?
+&G?@?CA?Q?_E?
+&G???@OCA?IH?
+&G???OOG@?IH?
+&G???OA?P?_M?
+&G?A?OA?O@_K?
+&G???GO?P?_J?
+&G???OACA?gCG
+&G???OACA?G[?
+&G?G?OA?I?OE?
+&G???GOCA?GX?
+&G???GOG@?KH?
+&G????OAA?EM?
+&G???O?SA?IK?
+&G????GCA?IL?
+&G????GC@_`H?
+&G?@?CAG?G_E?
+&G???O?SA?WG_
+&G???OAC@?gG_
+&G????OAA?WH_
+&G????OG@_GX?
+&G????GAB?cD?
+&G????@@B?gE?
+&G???CA?Q?WK?
+&G???CA?I?WK?
+&G???OACA?BK?
+&G???O_GA?QCO
+&G?A?OAG?_@K?
+&G???O_G@?`C_
+&G?@?A_?O@_E?
+&G?@A?AG?AOE?
+&G???O_C@?aGO
+&G???CA?E?WK?
+&G?A?OAG?G@K?
+&G???O?c@?`G_
+&G???OACA?aCO
+&G?@?C_?Q?AE?
+&G?@A?AGA?@E?
+&G?@A?AG?O@E?
+&G???O_G@?BK?
+&G?A?OAG?A?[?
+&GOA?OA?OAOG?
+&G?@A?AG?A?U?
+&G?A?OAG@?@K?
+&G?G?OAG?AOE?
+&G?A?OAGA?@K?
+&G??_O_G?AOE?
+&G???CAG@?gK?
+&G???O?W@?BK?
+&G?@A?AG?G@E?
+&G???O?cA?PG_
+&G???OAGA?QCO
+&G?@?A_?Q?_E?
+&G?A?OAG?O@K?
+&G???CAC@?gK?
+&G???O?g@?BK?
+&G???CG@A?WK?
+&G????_@B?gE?
+&G?????AAOSK_
+&G????G?J?SG_
+&G????G?P?oH_
+&G????_AB?Q@G
+&G???O@@A?WC_
+&G???AAG@?DI?
+&G???OACA?DI?
+&G???C?g@?OB_
+&G???O_G@?H?g
+&G???O_C@?IAO
+&G????GC?G`L?
+&G???OA?I?PE?
+&G????OA@?`H_
+&G????_AAAQD?
+&G???C?SA?KG_
+&G?@?CA?OA_E?
+&G???A_G@?BB?
+&G???CGG@?EI?
+&G???GO?OA_J?
+&G?@A?A?OA?U?
+&G???C_C?A_B_
+&G???OAG@?HGG
+&G???O@CA?GW_
+&G??OOA?I?OE?
+&G???O_G@?BAG
+&G???CAG@?KI?
+&G????GG@?BL?
+&G???O?SA?HG_
+&G????OAA?PH_
+&G????GCAAIH?
+&G?@?AA?Q?AE?
+&G???O?g@?BI?
+&G???OA?Q?WC_
+&G????_C?_o@o
+&G????_CA_GP_
+&G????G@B?aC_
+&G?????E@OKG_
+&G????_@B?QB?
+&G????O@B?GW_
+&G????OGB?K@_
+&G????_GB?KA_
+&G???OA?Q?gD?
+&G????_AB?aB?
+&G???G@C@?KGG
+&G???OAC@?HI?
+&G????GAB?cG_
+&G????G@A_PG_
+&G???OA?Q?gCO
+&G????GAAAQD?
+&G????_CAGSB?
+&G???G@C@?KG_
+&G???OAGA?HK?
+&G???CGC@?EI?
+&G????_CB?g@_
+&G???OA?Q?gCG
+&G?A?OA?OAOK?
+&G???OAC@?HGG
+&G???OA?Q?gE?
+&G???O@C@?IG_
+&G???OA?Q?gK?
+&G???CAC@?KI?
+&G????O@B?gG_
+&G????OA@_`@_
+&G???OAC@?HG_
+&G????GCAAID?
+&G????_G@OQB?
+&G???G@GA?KK?
+&G???OA?Q?gC_
+&G????O@B?WG_
+&G????_CB?GP_
+&G????_@B?QA_
+&G?????KA_cE?
+&G?????G@_SK_
+&G?????K@_SG_
+&G????_C?GWL?
+&G????O@B?WGO
+&G??A?AC@?@M?
+&G???G@C@?_[?
+&G????_?QOQA_
+&G????_@AOQA_
+&G???OA?I?`C_
+&G???OA?Q?`C_
+&G?G?OA?CG@K?
+&G?G?OAC?G@K?
+&G????@G@?KH_
+&G????G@AAaC_
+&G????OG@?KH_
+&G????GAAAcD?
+&G???G_C?AGJ?
+&G???OA?Q?QCG
+&G??@?_C?AGJ?
+&G???OAC@?_W_
+&G????OAAAAT?
+&G????OAA@S@_
+&G????_C@@HH?
+&G????OAAAKD?
+&G???O?g@?@W_
+&G???O?g@?BG_
+&G???O?g@?OW_
+&G???O?g@?QG_
+&G????_C?_BHG
+&G????OAA@`@_
+&G????_A@?QHG
+&G????GG@@PH?
+&G????_C?_WHG
+&G????_CB?HAG
+&G????OAA?`@g
+&G????_C?_c@o
+&G????OAA?IHG
+&G????OAA?SH_
+&G????GG@?KKG
+&G????GG@?KL?
+&G?????PB?gG_
+&G????_@B?g@_
+&G???O?_Q?gK?
+&G???G@GA?IK?
+&G?A?@AGA?@K?
+&G?G@?AGA?@E?
+&G???OAA?_`CO
+&G????_GAOQA_
+&G?A?OAA@?@K?
+&G???OAGA?`C_
+&GOAA?A?Q?@?G
+&G?G?OAG?G@K?
+&G???CA?H?KI?
+&G???CG@@?EI?
+&G???O?c@?IG_
+&G???OAC@?KG_
+&G??_O?W?AOE?
+&G??`?A?Q?CE?
+&G?G?O?W?AOE?
+&G??P?A?Q?_E?
+&G???OAA@?HGG
+&G????OAAAQD?
+&G???OAAA?gCG
+&G????_CB?HH?
+&G??Q?A?CAOE?
+&G???O?g@?`G_
+&G?A?OO?O@_K?
+&G???O?W@?aK?
+&G???O?g@?GOo
+&G???O?W@?K?o
+&G???O?cA?GW_
+&G???O?SA?KG_
+&G???O?g@?G[?
+&G???O?W@?KK?
+&G???C_C?AGB_
+&G????OAA?`H_
+&G???GO?I?GJ?
+&G????GG@?aL?
+&G???OAAA?OM?
+&G????_C?_cM?
+&G?????G@_KK_
+&G?????K@_KG_
+&G????_A?GWL?
+&G????O@A_WGO
+&G????G?J?KG_
+&G????G@B?aB?
+&G???@@G@?WG_
+&G???G@G@?WG_
+&G????_?P?WH_
+&G????O@A@WG_
+&G???G_C@?@J?
+&G???G@C@?gGG
+&G????_AB?I@G
+&G????GGB?K@_
+&G???C_C@?AX?
+&G???C_C@?EH?
+&G????_A?GPL?
+&G????G@B?PG_
+&G????_A?_QL?
+&G????OCA_HH?
+&G???C?W@?KG_
+&G???G@G@?KG_
+&G???@_C@?IH?
+&G???O_C@?IH?
+&G???G_?OAOJ?
+&G???OA?Q?WCG
+&G???G_?P?OJ?
+&G???OAGA?WCG
+&G???O@G@?GW_
+&G???O@G@?IG_
+&G???G_C@?GX?
+&G???G_C@?KH?
+&G????_C?GHL?
+&G????G@@_PG_
+&G??A?A?P?CM?
+&G???OA?Q?O[?
+&G???OA?I?`E?
+&G???OA?Q?`E?
+&G?G?OA?OA?[?
+&G?G?OA?P?GK?
+&G????_C@?HH_
+&G????GAAAaD?
+&G??A?O?P?AJ?
+&G???O@C@?_W_
+&G????_AAAID?
+&G????_CAOSA_
+&G???O@G@?OW_
+&G???OACA?`CO
+&G????_C?_BL?
+&G????OAB?`@_
+&G????_C?_IL?
+&G????GG@_PH?
+&G???O?W@?HG_
+&G???OAG@?HG_
+&G???O?W@?WG_
+&G???OAG@?WG_
+&G????_A@?HH_
+&G????GCAAaD?
+&G????_A@?WH_
+&G????GCA@WH?
+&G????GCAAQH?
+&G????_CAOKA_
+&G????_C@_GX?
+&G????_AB?QA_
+&G?????PB?WG_
+&G????_@B?W@_
+&G???O?_Q?WK?
+&G???G@CA?IK?
+&G???OA?OOgK?
+&G????GAB?cA_
+&G?A?OAAA?@K?
+&G???O_C@?aCO
+&G???G@?I?KK?
+&G???OA?Q?KK?
+&G?@?A_?Q??U?
+&G?@@?AGA?@E?
+&G???OAAA?HK?
+&G????_AB?KA_
+&G??Q?AG?AOE?
+&G???O_G@?QCO
+&G???CA?I?SE?
+&G???CAG@?EI?
+&G???O?c@?gG_
+&G???GOG@?IH?
+&G?@?AA?OO_E?
+&G???C_G@?IH?
+&G?@A?A?OO_E?
+&G??A?_C@?EI?
+&G?@?AA?Q??U?
+&G?@@?A?OA_E?
+&G?@?CAG?@_E?
+&G?@@?A?Q?_E?
+&G??OOAG?AOE?
+&G???O@G@?gG_
+&G??_O_?I?OE?
+&G???O_G@?WCO
+&G???CA?I?cE?
+&G???CAC@?EI?
+&G?A?@A?Q?CK?
+&G?G@?A?Q?CE?
+&G?A?OA?OAAK?
+&G???O@GA?WG_
+&GOA?OA?OAAG?
+&G?G?OA?Q?GK?
+&G???O?c@?HG_
+&G???O@C@?KG_
+&G?G?AA?Q??U?
+&G??H?A?Q?_E?
+&G???OAAA?gCO
+&G????_CB?cA_
+&G?A?OO?Q?AK?
+&G???OACA?`K?
+&G???O?W@?BI?
+&G???O_G@?K?o
+&G???O?cA?WG_
+&G???GOCA?IH?
+&G?@A?A?OAAE?
+&G???C_CA?IH?
+&G?A?OA?OO_K?
+&G???O_G@?aE?
+&G???O?cA?HG_
+&G???O@CA?KG_
+&G???O?cA?IK?
+&G???OACA?KK?
+&G???OAAA?WCO
+&G????_AB?cC_
+&G???OAAA?WK?
+&G????_CA_WH?
+&G?????CAOgKO
+&G?????@AOgKO
+&G????OG?OWKG
+&G????_A?OgKG
+&G????_C?OgL?
+&G????G?E_oGO
+&G??A?AG@?GM?
+&G???AACA?O[?
+&G????@GAAKD?
+&G????O@@?IH_
+&G???OA?E?QGG
+&G??@?GC?ACJ?
+&G???OA?I?cC_
+&G???G?c@?II?
+&G?A?@AAA?OK?
+&G?G@?_?G@GE?
+&G????AAA?SHG
+&G????AA@?SHG
+&G????OG@?KHG
+&G????OC?_KHG
+&G???GGCA?CJ?
+&G???G?cA?GY?
+&G??@?GG@?CJ?
+&G???AOG@?CX?
+&G????GC@A_PO
+&G????OA@?EHG
+&G????_CAAOQO
+&G???AGCA?AY?
+&G???A_CA?CP_
+&G???O?W@?SGG
+&G????AAA?SH_
+&G????@AAAKD?
+&G??@?GG?ACJ?
+&G???OA?E?aCG
+&G????_G@?KL?
+&G???GA?I?gE?
+&G??A?AAA?OM?
+&G?A?@ACA?GK?
+&G????GCAACT?
+&G????GAAACT?
+&G???O?cA?AW_
+&G???O?c@?AW_
+&G????_CB?`AG
+&G???OAC@?EGG
+&G???O?g@?_[?
+&G?G@?A?E?GE?
+&G????OAA?EHG
+&G????GG@A_PO
+&G????OG?_KHG
+&G????GG@?cKG
+&G???@GCA?IGG
+&G????_C?_gKG
+&G????GCA?c@g
+&G????_AA?S@g
+&G????OG?_gHG
+&G???O_C?__B_
+&G?????PA_oGO
+&G????_@?GgL?
+&G???O?_Q?_[?
+&G??A?AG?_@M?
+&G???O?_Q?`K?
+&G???O@?I?`K?
+&G?G?O_?O@OK?
+&G?G?O_?P??[?
+&G???CA?OAWI?
+&G????_G?GKL?
+&G?A?@AC?_@K?
+&G?A?OO?O_CK?
+&G???AAGA?`CO
+&GOAA?AG?AOA?
+&G???CA?H?GY?
+&G???GGC?ACJ?
+&G??P?A?E?GE?
+&G?@@?_?G@GE?
+&G???@G@@?HGG
+&G????_A?OaKG
+&G??a?A?CAOE?
+&G???A@CA?_W_
+&G???CA?H?HI?
+&G???OA?OAQGO
+&G?G@?A?CAGE?
+&G???O?c@?QG_
+&G?A?OO?OOGK?
+&G?G?OO?O@_K?
+&G???CG@@?HGG
+&G????_@B?`AG
+&G???OAGA?OW_
+&G???G@GA?OW_
+&G???O?cA?AOo
+&G???AG@@?@Y?
+&G???O?cA?_W_
+&G??a?A?COOE?
+&G???OOG?_@B_
+&G????OG?GgHG
+&G??A?OG?AGJ?
+&G??A?OG?GGJ?
+&G?????AAOoGo
+&G?????@AGgKO
+&G????_C?OgH_
+&G????G?Q@oH?
+&G????O?Cga@O
+&G????@@@?IH_
+&G???AG@@?DI?
+&G???O@?H?KI?
+&G????@AA?S@g
+&G????AA@?DHG
+&G???O?c?__B_
+&G???A@CA?CP_
+&G????GCAAAPO
+&G???O?SA?D?g
+&G????GG?OP@o
+&G????@AA@S@_
+&G????_AA?SH_
+&G???O?`@?HI?
+&G????GCAACP_
+&G????G@AAAS_
+&G????GGA@PH?
+&G???O@A@?KGG
+&G????GCA?D@g
+&G????OAA?aHG
+&G?????E@OQGG
+&G?????GA_EK_
+&G????_@B?GX?
+&G????_?J?cB?
+&G????@@AGSA_
+&G???OAA?_cC_
+&G????G@A@Q@_
+&G????GAAAKD?
+&G?????G@_KKO
+&G?????@@OgKO
+&G????GG?OWKG
+&G????OA?OgKG
+&G????@C@@gH?
+&G????O@@?gH_
+&G???@ACA?WGG
+&G??@?G?Q?OJ?
+&G????O@A?WH_
+&G????@G@@WH?
+&G??@?G?P?_J?
+&G???@ACA?gCG
+&G????_AB?K@G
+&G????GAB?c@G
+&G???GOCA?CX?
+&G???GOG@?CX?
+&G????GG?OPKG
+&G????AA@?oHG
+&G????GC?_cKG
+&G????OC?_gHG
+&G???@ACA?KGG
+&G???G@G@?_B_
+&G???@OG@?KGG
+&G???OOGA?OB_
+&G???GG?P?_J?
+&G???AACA?CY?
+&G???GGCA?OJ?
+&G???AOG@?CY?
+&G???OACA?GY?
+&G???O_C@?I?g
+&G???OOG@?GY?
+&G??A?_C@?IAG
+&G????_@@?IL?
+&G?????c@_HH?
+&G??A?A?O_OM?
+&G???OA?I?O[?
+&G???OA?I?cE?
+&G???AAC@?EI?
+&G?A?@A?P?_K?
+&G?G@?A?O@_E?
+&G????_G@?IL?
+&G???GA?I?cE?
+&G??A?A?Q?OM?
+&G?A?@A?O__K?
+&G????GC@_HH?
+&G???OAC@?EI?
+&G???OACA?O[?
+&G?G@?A?I?GE?
+&G????_A@?EL?
+&G????GG@Ao@O
+&G????_C?_KL?
+&G????_AB?PAG
+&G???O?SA?II?
+&G???O_CA?K?g
+&G???O?g@?WI?
+&G???OOG@?KGG
+&G????_A@?aL?
+&G???O?SA?EI?
+&G????_C?_gL?
+&G???O?g@?WH?
+&G????GCB?`H?
+&G???O_G@?KAO
+&G????OAA_oGO
+&G???OOG@?KI?
+&G?????PB?WGO
+&G????_@?GWL?
+&G???O?_Q?O[?
+&G??A?AC?_@M?
+&G???O?`?GgK?
+&G????_G?GWL?
+&G?A?@AG?_@K?
+&G??A?AG@?@M?
+&G???CA?I?HK?
+&G???O?a?GgK?
+&G?G@?AG?A?U?
+&G?A?@AG@?@K?
+&G???CG@A?HK?
+&G????_@B?WGO
+&G?G@?AG?AGE?
+&G???G@G@?_[?
+&G???G@?E?SCG
+&G??A?AC?AGJ?
+&G???O?c@?_W_
+&G??A?OC?AGJ?
+&G?@?C_?O@AE?
+&G???G_CA?@J?
+&G?G?CA?O@_E?
+&G??A?O?Q?OJ?
+&G?@@?AG?A?U?
+&G??_O_?CAOE?
+&G??P?A?E?_E?
+&G?@A??W?AOE?
+&G?@@?AG?AGE?
+&G???G@G@?cGG
+&G?@@?_G?AGE?
+&G???O_C@?aGG
+&G???CA?I?`E?
+&G???O@?I?`C_
+&G?G?OAC?A?[?
+&G?G?OA?D?@K?
+&G?A?OAA?G@K?
+&G???@@GA?WG_
+&GOAA?A?Q?G?G
+&G?G?OA?E?@K?
+&G???O?c@?PG_
+&G?A?OAA?O@K?
+&G?G?OAG?A?[?
+&GOAA?A?Q?O?G
+&G???OAGA?aCO
+&G???G@GA?WG_
+&G?G?OAG@?@K?
+&G?G?OACA?@K?
+&G???O?W@?BG_
+&G???OAG@?@W_
+&G???O?cA?QG_
+&G???OAG@?OW_
+&G??Q?A?GAOE?
+&G???C_CA?AX?
+&G?A?OO?OO_K?
+&G???O_G@?aCG
+&G???O?cA?`G_
+&G??a?A?GOOE?
+&G???O?g@?aK?
+&G?A?OO?O__K?
+&G???OACA?QCO
+&G???C_CA?EH?
+&G???OACA?QK?
+&G???O_G@?aC_
+&G?????@B?WGo
+&G?????@@GgKO
+&G????OA?GgHG
+&G????OA?OaKG
+&G????G?F?a@G
+&G????@@@?gH_
+&G???AAG@?@Y?
+&G???AG?Q?OJ?
+&G????OG?OW@o
+&G????G?Q@o@_
+&G???O_C?A_B_
+&G???@AG@?HGG
+&G????_AB?CP_
+&G????G@B?a?g
+&G???O_G@?B?g
+&G???CAG@?GY?
+&G????OA?G`HG
+&G????AA@?`HG
+&G????OA?_aHG
+&G????OA@?aHG
+&G???@@CA?K?g
+&G???O?_P?_B_
+&G???A_CA?AR?
+&G???O@G@?_B_
+&G???O@C?A_B_
+&G???A@CA?CQ_
+&G???O@G@?OB_
+&G???A_C@?AR?
+&G???O@CA?GQ_
+&G???CACA?KAG
+&G???O_G@?HAG
+&G???O_C@?IAG
+&G????_C?OHH_
+&G????@AAAaD?
+&G??A?O?OAGJ?
+&G???OA?E?PCG
+&G???OA?H?DI?
+&G???AA?P?EI?
+&G??Q?A?G@OE?
+&G??H?A?O@_E?
+&G????_AA?PH_
+&G???O?`@?BI?
+&G??A?O?Q?AJ?
+&G?G?CA?O@CE?
+&G????_AAAaD?
+&G???OA?P?EI?
+&G???O@CA?_W_
+&G??P?A?I?GE?
+&G????_A@?DH_
+&G????GCAAa@O
+&G????_A@?SH_
+&G????GCA@PH?
+&G???O?cA?HA_
+&G???O@CA?K?g
+&G???O?cA?II?
+&G???OACA?KGG
+&G????_A@?`H_
+&G???O?cA?H@_
+&G????_A@?oH_
+&G???AGCA?EI?
+&G????GCAAaH?
+&G???O@CA?KA_
+&G????GCB?_X?
+&G???OACA?KI?
+&G?????E@OIGG
+&G?????G@_EK_
+&G????_@B?PAG
+&G????_C?GKL?
+&G?????`B?aB?
+&G?????GA_SK_
+&G???G@?I?gC_
+&G????_C?GgL?
+&G????_@B?GP_
+&G?????`B?aA_
+&G???G@C@?IGG
+&G???G@?I?gE?
+&G????_@B?I@_
+&G?????KA_SG_
+&G???CAC@?HI?
+&G????G@A_oGO
+&G????G@A@PG_
+&G????_?P?KH_
+&G????OCA@HH?
+&G????_C@?KH_
+&G???AG?P?EI?
+&G????_?P?gH_
+&G???AGC@?EI?
+&G????_C@?gH_
+&G???OA?P?KGG
+&G???O?_P?II?
+&G???OAC@?KGG
+&G???O?c@?II?
+&G???OA?P?KI?
+&G????O@A__W_
+&G???OAC@?KI?
+&G????OCA__X?
+&G????G@AAKC_
+&G????_?QOSA_
+&G???OA?Q?`CG
+&G???OA?I?`CO
+&G???OAA?_aCO
+&G????_?J?cA_
+&G?A?OO?O_AK?
+&G???OA?I?`K?
+&G????GAAAID?
+&G???OAA?_cCO
+&G???O@GA?OW_
+&G?A?OO?OOAK?
+&G????_GAOSA_
+&G????_@B?cA_
+&G???OAGA?`CO
+&G???OA?Q?`K?
+&G????OAAAS@_
+&G????GC@Ga@O
+&G????GCAAKD?
+&G????GGAAKD?
+&G???OAA@?DI?
+&G????GGB?a@G
+&G???OAAA?gC_
+&G????_CA_OX?
+&G????GCAAQD?
+&G???OAA@?BI?
+&G????_CB?GX?
+&G???OAAA?gD?
+&G????_CAOaB?
+&G????_AB?c@_
+&G????_CB?cB?
+&G????_AB?cB?
+&G?????C?ogKO
+&G?????@?ogKO
+&G?????cA_PH?
+&G????G@?_aL?
+&G????ACA?WHG
+&G????_A?OHKG
+&G????_A?ao@O
+&G????GG?_EL?
+&G????GC?OgL?
+&G????G?D_oGO
+&G???@ACA?WG_
+&G???@AC@?cG_
+&G??@?ACA?GJ?
+&G???@ACA?cCG
+&G???OOCA?AX?
+&G???@OG@?EH?
+&G????OG?OHKG
+&G????AA@?WHG
+&G???OA?E?WGG
+&G??@?A?H?GJ?
+&G????OCA?IHG
+&G????OC?_IHG
+&G????GC@@HH?
+&G????OA@?KH_
+&G???OAG@?GM?
+&G???AACA?C[?
+&G?A?OA?E?OK?
+&G?G?O?g?@OE?
+&G???GOCA?GJ?
+&G???AOCA?AX?
+&G???OACA?cCG
+&G???AOG@?EH?
+&G????G@@?aL?
+&G?????cB?HH?
+&G???G?SA?KG_
+&G???G?S@?KG_
+&G??@?A?I?GJ?
+&G???OA?E?gCG
+&G???OACA?GW_
+&G???O?S@?IG_
+&G????OC?_cM?
+&G???O?PA?WK?
+&G???@_G@?KK?
+&G?@?GAGA?CE?
+&G???OAGA?OM?
+&G?A?OA?E?AK?
+&G???O_G@?G[?
+&G?G?O?g?AOE?
+&G????GCA?EL?
+&G????OG?ao@O
+&G???O?SA?IG_
+&G???OAC@?GW_
+&G????GCA?SH_
+&G????OG?`PH?
+&G????GCAASH?
+&G????OCAAKH?
+&G????OG?_cM?
+&G???@GCA?IK?
+&G???O?W@?gK?
+&G??_OAGA?OE?
+&G????GG@?gL?
+&G???@GCA?WG_
+&G????OA@_oGO
+&G???OAC@?cG_
+&G?????P@_oGO
+&G????G@?GgL?
+&G???O?P?GgK?
+&G????_G?OQM?
+&G???CA?I?G[?
+&G???OAG?_@M?
+&G???@G@A?HK?
+&G????OG?OQM?
+&G???O?_Q?PK?
+&G???O@?I?PK?
+&G?A?O_?O_CK?
+&G???@AGA?PK?
+&G?G?O_?O@OE?
+&G?A?O_?P??[?
+&G??a?AG?AOE?
+&G???@ACA?PK?
+&G???G@?E?SGG
+&G??@?AC?AGJ?
+&G?A?OA?CG@K?
+&G???OAGA?@M?
+&G???O?c@?@W_
+&G???GOC?AGJ?
+&G???OA?I?PG_
+&G????GG?GgL?
+&G?A?O_?O@OK?
+&G?G?O_?G@OE?
+&GOA?OA?OAG@?
+&G?A?O_?Q??[?
+&G??Q?A?E?OE?
+&G?@A?_?G@OE?
+&G?A?O_?P?GK?
+&G???AACA?PK?
+&G???CA?I?PE?
+&G???O@?I?PG_
+&G?@?GAG?O@E?
+&G???@AGA?HK?
+&G?G?O?_O@OE?
+&G?A?OA?D?@K?
+&G??_OAG?AOE?
+&G???O?OQ?gK?
+&G???O?S@?aK?
+&G?A?O_?OOGK?
+&G?G?CA?Q?_E?
+&G?G?GAGA?@E?
+&G?A?O_?O@_K?
+&GOA?OA?OAG?G
+&G?G?O_G?AOE?
+&G?A?O_?Q?CK?
+&G???O?SA?BG_
+&G???OAC@?@W_
+&G?G?O?_OAOE?
+&G???CAGA?G[?
+&G???O?cA?BG_
+&G???OA?Q?QGG
+&G???OA?Q?QCO
+&G????O@@_oGO
+&G???O?SA?aK?
+&G??a?AG?OOE?
+&G?A?O_?OO_K?
+&G?G?O_G?GOE?
+&G???O?cA?aK?
+&G?A?O_?O_OK?
+&G???OAGA?QK?
+&G???G@C@?aK?
+&G?????A@OoGo
+&G?????@?ggKO
+&G????G?J?DG_
+&G????AA?O`L?
+&G????G?Q?o@g
+&G????_A?OBKG
+&G????_AB?B@G
+&G????AAA?DL?
+&G????GC?OgH_
+&G????G?P@oH?
+&G???AAG@?BI?
+&G???O@?I?SE?
+&G???A_C?O_B_
+&G???@AG@?DGG
+&G???O_G@?D?g
+&G???C?W@?II?
+&G????OG?GHHG
+&G????AA@?HHG
+&G???OA?H?@Y?
+&G???CA?H?GJ?
+&G????_AA?P@g
+&G????OC?_BHG
+&G????_AAAAT?
+&G????@A@?KH_
+&G???GO?Q?GJ?
+&G???C?cA?GW_
+&G?@A?A?O@OE?
+&G??_O?g?@OE?
+&G???A_C?__B_
+&G???A_CA?@P_
+&G???OAG@?DGG
+&G???C?g@?II?
+&G????GC?O`H_
+&G????@AAAQD?
+&G???@ACA?K?o
+&G???CG?D?EI?
+&G???COG?ACB_
+&G???OA?D?HGG
+&G???OACA?GOo
+&G???CA?D?KI?
+&G????GC@?aL?
+&G???GA?I?PE?
+&G???@OGA?IH?
+&G?@?GA?Q?CE?
+&G???GO?Q?_J?
+&G?@A?A?O@@E?
+&G???GOGA?GX?
+&G??_O?g?AOE?
+&G????GCA?DH_
+&G????GCAAI@O
+&G???O?SA?I?o
+&G???CAA@?CY?
+&G????OG?_c@o
+&G????_C?``@_
+&G????GCA@c@_
+&G????G@AAQG_
+&G????GCA?aL?
+&G???@GCA?HG_
+&G???O?SA?gG_
+&G??_OA?Q?OE?
+&G????OAA?oH_
+&G???AGG@?BI?
+&G????OGA_GX?
+&G???OA?Q?SC_
+&G?????E@OHGG
+&G?????AA_EK_
+&G????@@B?aB?
+&G?????GAOQM?
+&G????O@@__Oo
+&G????A?Q?KL?
+&G????@GB?K@_
+&G?????G@OQM?
+&G????O@B?GX?
+&G????_?J?SB?
+&G???O@?Q?gD?
+&G????O?R?WH?
+&G???CAC@?IGG
+&G???O@?I?gE?
+&G???GAC@?HI?
+&G????G?Q_oH?
+&G????G@?`PG_
+&G????O?P?KH_
+&G???OA?OAWGO
+&G????A?Q?gL?
+&G????GAAAAT?
+&G????@C@?KH_
+&G????O?QOQA_
+&G?????AA_cK_
+&G???OA?Q?cCG
+&G???C?c@?IG_
+&G?A?OA?P?GK?
+&G???O@?I?gK?
+&G???OAC@?DGG
+&G???C?c@?II?
+&G???O@@A?gE?
+&G????O?F?gH?
+&G????G@AASC_
+&G????O?QOQB?
+&G???CG?P?EI?
+&G????_?Q_o@_
+&G???OA?P?HGG
+&G???OA?OAWI?
+&G???CA?P?KI?
+&G????@@B?gG_
+&G????OCB?HH?
+&G???O@@A?gCO
+&G???OOC@?IH?
+&G???C@GA?IK?
+&G???OAGA?gCG
+&G?A?OA?P?@K?
+&G???GOC@?KH?
+&G???O@?Q?gK?
+&G????GCAAS@_
+&G????OC?ga@O
+&G???CAA@?DI?
+&G????_@A_o?o
+&G????GCA@S@_
+&G????_@AAIC_
+&G????_@@OQA_
+&G?????EB?SG_
+&G????GGA_PH?
+&G???GGC@?HG_
+&G???OAC@?WG_
+&G???CAGA?IK?
+&G????OGB?GX?
+&G???OA?Q?cC_
+&G????_GB?SB?
+&G????O@B?WH?
+&G?????G@OWGo
+&G?????@?WgKO
+&G?????E@OaGG
+&G?????AAOIK_
+&G????_C?GWHG
+&G????_A?OIKG
+&G????_@B?HAG
+&G????GG?GKL?
+&G????OG?OWH_
+&G????_?P@WH?
+&G????O@A@WH?
+&G????G?J?cB?
+&G??@?_C?GGJ?
+&G???A@G@?OW_
+&G???G@C@?_W_
+&G???AACA?PGO
+&G????_A?GPHG
+&G????AA@?PHG
+&G????G@@@PG_
+&G????G?P?KH_
+&G????_A?_QHG
+&G????OA@?IHG
+&G????OC?`HH?
+&G????GC@?KH_
+&G???G_?P?GJ?
+&G???C?g@?GW_
+&G???OA?Q?SCG
+&G???C?g@?IG_
+&G???G_C@?GJ?
+&G???A_C@?AX?
+&G???OAGA?SCG
+&G???A_C@?EH?
+&G????GG?OPH_
+&G????@AAAID?
+&G????G@AAcC_
+&G????O?QOSA_
+&G??@?_?OAGJ?
+&G???OA?E?`CG
+&G???OA?Q?PCG
+&G???OA?I?PGO
+&G????_C@?IL?
+&G???GA?I?`E?
+&G????OC@_HH?
+&G???O@@A?`E?
+&G??A?A?P?OM?
+&G?G?OA?O@@K?
+&G???OAGA?O[?
+&G?G?OA?P?@K?
+&G????GG@?DH_
+&G????GCAAQ@O
+&G????GCAAc@_
+&G????OG?ga@O
+&G????GG@?SH_
+&G????_C?`PH?
+&G????GCAAcD?
+&G????OGAAKD?
+&G????_A@?QL?
+&G???@GG@?HG_
+&G????GGB?PH?
+&G???GGG@?HG_
+&G????_C?_WL?
+&G???@GG@?WG_
+&G????OAB?WGO
+&G???OAG@?SG_
+&G?????PA_o?o
+&G????A?OOgL?
+&G????@@B?g@_
+&G?????GAGSM?
+&G???O?_Q?G[?
+&G???OAA?A_M?
+&G???O?OQ?KK?
+&G????OG?OaM?
+&G???O?_Q?HK?
+&G???OAA?AgK?
+&G???O@?Q?KK?
+&G????_?R?WH?
+&G?G?O?W?GOE?
+&G?A?OO?Q??[?
+&G??`?AGA?@E?
+&G???@ACA?`K?
+&G???CA?H?CY?
+&G???CAC?AGJ?
+&G???CA?D?EI?
+&G????AAA?`L?
+&G???O?c@?GW_
+&G???GO?H?GJ?
+&G???O?S@?KG_
+&G????GG?_aL?
+&G??_O?OQ?OE?
+&G??_O_?G@OE?
+&G?@@?A?Q?CE?
+&G???A@G@?cG_
+&G??_O?WA?OE?
+&G?@A??g?@OE?
+&G??`?A?Q?_E?
+&G???A_C@?aH?
+&G???CA?H?DI?
+&G???OAA?AWGO
+&G???CA?P?EI?
+&G????_?R?cA_
+&G?G?O?OOAOE?
+&G?A?OO?OA?[?
+&G??P?A?Q?CE?
+&G???OA?E?`K?
+&G???O?c@?WG_
+&G?A?OA?OOGK?
+&G???GOC@?IH?
+&G???C@GA?WG_
+&G?A?@A?Q?_K?
+&GOA?OA?OAA@?
+&G?G@?A?Q?_E?
+&G?G?OA?Q?@K?
+&G???O?cA?I?o
+&G???OAA@?@Y?
+&G???OACA?K?o
+&G????_AB?c?o
+&G???O?cA?IG_
+&G???OAAA?WGG
+&G???OACA?KG_
+&G????_CA_PH?
+&G???O?cA?gG_
+&G?@A?A?OOOE?
+&G???GOGA?IH?
+&G???G_G@?BH?
+&G???O?g@?gK?
+&G?A?OAAA?OK?
+&G???O_G@?KK?
+&G???O_G@?aD?
+&G?????G@_SGW
+&G?????@?QgKO
+&G?????GA?YD_
+&G????OG?OWHG
+&G????_?H_OWO
+&G????_A?OKKG
+&G????GA?AcL?
+&G??@?OG?_CJ?
+&G???AACA?OW_
+&G???A?WA?QC_
+&G????O@A?IHG
+&G?????c@@HH?
+&G????AA@?QHG
+&G????O?H?KH_
+&G????_G@?KKG
+&G???GA?E?WGG
+&G????OC?_WHG
+&G??@??c?AGJ?
+&G???COG?OGJ?
+&G???OA?E?cCG
+&G???G?cA?GW_
+&G???@?c@?IG_
+&G???O_G@?GM?
+&G?A?O?W@?CK?
+&G???A_G@?C[?
+&G?G?A_?G@OE?
+&G????OAA?EH_
+&G????GCAAS@O
+&G????_G?BSB?
+&G????GG@?cL?
+&G???@GCA?IG_
+&G????_CB?_QO
+&G???GGC@?GW_
+&G????_C?_oM?
+&G???@GG@?gK?
+&G?@?O_G@?GE?
+&G?????PB?g?W
+&G?????`?GgL?
+&G?????G?GwL?
+&G???O?_Q?@[?
+&G???@AA?AgK?
+&G???O_?O_CM?
+&G????_?GOoM?
+&G?GA?A?D?GE?
+&G?AA?AC?_?[?
+&G???C?_E?oK?
+&G???CA?H?@Y?
+&G???OA?CAQGO
+&G???GAC?AGJ?
+&G?????g?GgL?
+&G???O?c@?OW_
+&G?A?O?OOOGK?
+&G??@?OC?AGJ?
+&G???O_?Q?CM?
+&G?G?CA?D?GE?
+&G?A?O?OP?GK?
+&G?@?O_?G@OE?
+&G???@@?I?gK?
+&G?AA?A?E?OK?
+&GOA?O_?Q?O@?
+&G?GA?_?G@OE?
+&G?AA?AG?_?[?
+&G???O?g@?B?o
+&G???CG@@?@Y?
+&G????_@B?g?W
+&G???O?cA?aG_
+&G?G?CA?P?GE?
+&G???OAC@?OW_
+&G???G@GA?A[?
+&G???O?g@?oK?
+&G?AA?AAA?OK?
+&G?GA?_@@?GE?
+&G?????G@_S?w
+&G?????@?IgKO
+&G?????G?GXDO
+&G????OG?OW@g
+&G????G?J?_PO
+&G????_A?OEKG
+&G????AA?AcL?
+&G??A?_C?_CB_
+&G???@AG@?BGG
+&G???C?_E?WE?
+&G????OG?OH@g
+&G????@AAAAT?
+&G????AA@?BHG
+&G????@?H?KH_
+&G????OGA?IHG
+&G???O?`@?@Y?
+&G????OA@?QHG
+&G???G?c?AGJ?
+&G???COG?OGB_
+&G???O?Q@?HGG
+&G???AACA?COo
+&G???C?OH?KI?
+&G???GOGA?GJ?
+&G?@A?A?CGOE?
+&G???AOGA?AX?
+&G?@?A_?G@OE?
+&G????OAA?E@o
+&G????GCA@D@_
+&G????_@?BQA_
+&G????GCA?cH_
+&G???@GCA?I?o
+&G????OG?``H?
+&G???CG@@?CY?
+&G????GG@?oL?
+&G???@GCA?gG_
+&G?@?OAG@?GE?
+&G?????E@O_Oo
+&G??????QOIK_
+&G??????B?kI_
+&G????O@@__PO
+&G????@?J?cB?
+&G????AG?GKL?
+&G??????R?cM?
+&G???G@C@?BGG
+&G???C@?I?gE?
+&G????@?J?oI?
+&G????G@AACS_
+&G????@?IGSB?
+&G????@?P?KH_
+&G??????QOgK_
+&G????OC@@HH?
+&G???O@@?AWGO
+&G????OC@?KH_
+&G????AG?GgL?
+&G???O@A@?HGG
+&G???O@@?AWI?
+&G???C@?H?KI?
+&G????@?F?gH?
+&G???OAGA?cCG
+&G?A?OAC?_AK?
+&G???AOC@?EH?
+&G???C@?I?gK?
+&G????OAAAE@_
+&G????O@?ga@O
+&G?????IAOo?o
+&G????GCAASD?
+&G???CG@@?DI?
+&G????_GAAKD?
+&G????_@A_o@O
+&G????OA@_WGO
+&G???OAC@?SG_
+&G???G@GA?BK?
+&G?????G?oaKO
+&G?????A?oIKO
+&G????_?QAWH?
+&G????GA?OIL?
+&G????GG?OaL?
+&G????_?OaoH?
+&G???AACA?aGO
+&G???AAGA?QGO
+&G????_C@?cM?
+&G???O?PA?`K?
+&G???@_C@?cK?
+&G?G?OAG?OAK?
+&G?????`@_`@_
+&G????G@?GBL?
+&G???OA?CGKK?
+&G????_G?ODM?
+&G???O?OP?KGO
+&G???O@?D?KGO
+&G??`?A?Q?@E?
+&G???@AGA?EK?
+&G???O?WA?KK?
+&G??P?A?Q?AE?
+&G??`?AGA?_E?
+&G?G@?AGA?AE?
+&G????A?OOWHG
+&G????A?OOKKG
+&G?????C?oQGo
+&G?????A?WIKO
+&G???OAA?AG[?
+&G???OA?OOGM?
+&G????G?J?DB?
+&G????AA?OIL?
+&G??@?A?OOGJ?
+&G???OAA?@WGG
+&G????GC?OQH_
+&G????O?QAKD?
+&G?G?G?OO_OE?
+&G?A?OAA@??[?
+&G???C?g@?BG_
+&G???O@?I?SGO
+&G???OAAA?_M?
+&G?A?OO?O@@K?
+&G????GGA?KL?
+&G???GA?I?PGO
+&G?A?OOGA??[?
+&GOAA?A?Q?A?O
+&G???A_C@?SH?
+&G?G?OAC?OAK?
+&G?????P?ao?o
+&G????G?GGDL?
+&G?????K?aGP_
+&G?????A?WDK_
+&G???@A?G_KK?
+&G?????g?O`M?
+&G????@@@__X?
+&G?????GAODM?
+&G???O?_P?GWO
+&G???O?_D?HGO
+&G????G@@@PH?
+&G????G?EAcD?
+&G??_O?W?GOE?
+&G???O?_E?gK?
+&G???O@?Q?SCG
+&G????O?J?WGO
+&G???O?gA?G[?
+&G?G?O?OGAOE?
+&G????_GB?HAG
+&G???O@@A?PCG
+&G?G?O?WA?OE?
+&G?A?@AGA?AK?
+&G???O_GA?SCG
+&G???GAC@?_[?
+&G?????C@GKGW
+&G?????A?QIKO
+&G????_?OBWH?
+&G?????a?OIL?
+&G????OA?OIHG
+&G????_?OaOX?
+&G???C?g@?@W_
+&G???O?OI?SGO
+&G????GGA?KKG
+&G???GA?E?`CG
+&G???A_C@?OX?
+&G?G?OA?COAK?
+&G?????G?QWGo
+&G?????@A?YGo
+&G?????g?OWH_
+&G?????CA?kK_
+&G????_A?GQHG
+&G????GG?ASH_
+&G???G_C?GGJ?
+&G????_C?AWL?
+&G????_C@?WHG
+&G??@?_?GAGJ?
+&G??@?_C@?GJ?
+&G??A?AC@?AM?
+&G?????KA_SB?
+&G????O@A_WG_
+&G????_CA_W@_
+&G????GAB?cC_
+&G???OA?Q?WK?
+&G????_AB?QB?
+&G???G@G@?KK?
+&G???OACA?HK?
+&G????_CB?KA_
+&G???G@GA?WD?
+&G???O@C@?gG_
+&G???G@G@?cE?
+&G?A?OA?OA_K?
+&G???COCA?IH?
+&G???O@CA?WG_
+&G???OOG@?BI?
+&G???COG@?IH?
+&G?@?AA?Q?_E?
+&G?@?CAG?A_E?
+&G?@A?A?OA_E?
+&G??A?_C@?I@O
+&GOA?OA?OA?W?
diff --git a/lib/nauty/nautestg.ans b/lib/nauty/nautestg.ans
new file mode 100644
index 0000000..44bc730
--- /dev/null
+++ b/lib/nauty/nautestg.ans
@@ -0,0 +1,181820 @@
+7 10 0 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 0 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 1 1 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 0 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 1 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 2 2 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 0 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 1 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 2 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 3 3 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 0 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 1 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 2 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 3 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 4 4 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 0 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 1 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 2 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 3 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 4 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 5 5 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 5 2 6 3 5 3 6
+7 10 0 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 0 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 1 1 1 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 0 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 1 1 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 1 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 2 2 2 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 0 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 1 1 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 1 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 2 2 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 1 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 2 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 3 3 3 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 0 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 1 1 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 1 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 2 2 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 1 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 2 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 3 3 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 1 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 2 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 3 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 4 4 4 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 0 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 1 1 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 1 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 2 2 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 1 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 2 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 3 3 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 1 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 2 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 3 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 4 4 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 0 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 1 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 2 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 3 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 4 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 5 5 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 5 2 6 3 6
+7 10 0 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 0 0 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 0 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 1 1 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 0 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 1 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 2 2 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 0 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 1 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 2 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 3 3 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 0 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 1 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 2 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 3 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 4 4 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 0 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 1 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 2 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 3 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 4 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 0 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 1 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 2 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 3 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 4 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 0 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 1 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 2 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 3 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 0 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 1 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 2 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 3 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 4 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 4 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 0 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 0 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 0 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 0 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 0 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 0 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 1 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 1 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 1 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 1 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 1 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 1 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 1 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 1 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 1 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 1 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 1 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 1 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 2 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 3 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 4 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 0 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 0 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 0 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 0 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 0 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 0 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 1 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 1 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 1 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 1 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 1 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 1 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 2 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 2 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 2 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 2 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 2 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 2 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 3 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 3 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 3 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 3 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 3 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 3 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 4 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 4 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 4 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 4 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 4 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 4 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 5 0  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 5 1  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 5 2  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 5 3  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 5 4  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+7 10 5 5 5 5 5 5 5  0 4 0 5 0 6 1 4 1 5 1 6 2 4 2 6 3 5 3 6
+>A vcolg -m6T
+>Z 3 graphs read from stdin; 181818 coloured graphs written to stdout; 0.47 sec
diff --git a/lib/nauty/nauthread1.c b/lib/nauty/nauthread1.c
new file mode 100644
index 0000000..c15d2e7
--- /dev/null
+++ b/lib/nauty/nauthread1.c
@@ -0,0 +1,134 @@
+/* nauthread1.c
+
+   This program tests dense nauty running in multiple threads.
+   It must be linked with nauty as configured with 
+   --enable-tls and will only run on systems which support
+   thread-local storage.
+*/
+
+#include <pthread.h>
+#include "nauty.h"   
+/* MAXN=0 is defined by nauty.h, which implies dynamic allocation */
+
+#define THREADS 1000    /* Total number of threads to run */
+#define ATONCE 20       /* Number of threads to run at once */
+#define GRAPHSIZE 200   /* Least graph size to use */
+
+typedef struct
+{
+    int n;
+    boolean writeautoms;
+} params;   /* Used to pass parameters to the thread */
+
+static void*
+runit(void * threadarg)          /* Main routine for one thread */
+{
+    DYNALLSTAT(graph,g,g_sz);
+    DYNALLSTAT(int,lab,lab_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+    DEFAULTOPTIONS_GRAPH(options);
+    statsblk stats;
+    set *gv;
+
+    int n,m,v;
+
+    n = ((params*)threadarg)->n;
+
+ /* Default options are set by the DEFAULTOPTIONS_GRAPH macro above.
+    Here we change those options that we want to be different from the
+    defaults.  writeautoms=TRUE causes automorphisms to be written.     */
+
+    options.writeautoms = ((params*)threadarg)->writeautoms;
+
+    m = SETWORDSNEEDED(n);
+
+ /* The following optional call verifies that we are linking
+    to compatible versions of the nauty routines.            */
+
+    nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
+
+    DYNALLOC2(graph,g,g_sz,m,n,"malloc");
+    DYNALLOC1(int,lab,lab_sz,n,"malloc");
+    DYNALLOC1(int,ptn,ptn_sz,n,"malloc");
+    DYNALLOC1(int,orbits,orbits_sz,n,"malloc");
+
+ /* Now we will make a polygon of n vertices */
+
+    EMPTYGRAPH(g,m,n);
+    for (v = 0; v < n; ++v) ADDONEEDGE(g,v,(v+1)%n,m);
+
+    if (options.writeautoms)
+         printf("Generators for Aut(C[%d]):\n",n);
+    densenauty(g,lab,ptn,orbits,&options,&stats,m,n,NULL);
+
+    if (options.writeautoms)
+    {
+        printf("order = ");
+        writegroupsize(stdout,stats.grpsize1,stats.grpsize2);
+        printf("\n");
+    }
+    if (stats.numorbits != 1 || stats.grpsize1 != 2*n)
+        fprintf(stderr,">E group error\n");
+
+ /* If we are using multiple threads, we need to free all the dynamic
+    memory we have allocated.  We don't have to do this after each 
+    call to nauty, just once before the thread finishes. */
+
+    DYNFREE(g,g_sz);
+    DYNFREE(lab,lab_sz);
+    DYNFREE(ptn,ptn_sz);
+    DYNFREE(orbits,orbits_sz);
+    nauty_freedyn();
+    nautil_freedyn();
+    naugraph_freedyn();  /* Use nausparse_freedyn() instead if
+                            sparse format is being used. */
+
+    return NULL;
+}
+
+
+int
+main(int argc, char *argv[])
+{
+    int n,ret;
+    pthread_t thread[THREADS];
+    params par[THREADS];
+    int started,finished;
+
+#if !HAVE_TLS
+    fprintf(stderr,">E This program needs to be linked with a version\n");
+    fprintf(stderr,"  of nauty successfully configured with --enable-tls.\n");
+    exit(1);
+#endif
+
+    for (started = finished = 0; finished < THREADS; )
+    {
+	if (started == THREADS || started-finished == ATONCE)
+	{
+	    if ((ret = pthread_join(thread[finished],NULL)) != 0)
+	    {
+                fprintf(stderr,">E Thread joining failed, code=%d\n",ret);    
+                exit(1);
+            }
+	    ++finished;
+	}
+	else
+	{
+		/* We vary the graph size a bit as it tests the
+                   thread independence better. */
+	    par[started].n = GRAPHSIZE + (started % 17);
+	    par[started].writeautoms = FALSE;
+
+            if ((ret = pthread_create(&thread[started],NULL,
+					runit,&par[started])) != 0)
+            {
+                fprintf(stderr,">E Thread creation failed, code=%d\n",ret);       
+                exit(1);
+            }
+	    ++started;
+	}
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/nauthread2.c b/lib/nauty/nauthread2.c
new file mode 100644
index 0000000..89b74b3
--- /dev/null
+++ b/lib/nauty/nauthread2.c
@@ -0,0 +1,140 @@
+/* nauthread2.c
+
+   This program tests sparse nauty running in multiple threads.
+   It must be linked with nauty as configured with 
+   --enable-tls and will only run on systems which support
+   thread-local storage.
+*/
+
+#include <pthread.h>
+#include "nauty.h"   
+#include "nausparse.h"
+/* MAXN=0 is defined by nauty.h, which implies dynamic allocation */
+
+#define THREADS 1000    /* Total number of threads to run */
+#define ATONCE 20       /* Number of threads to run at once */
+#define GRAPHSIZE 500   /* Least graph size to use */
+
+typedef struct
+{
+    int n;
+    boolean writeautoms;
+} params;   /* Used to pass parameters to the thread */
+
+static void*
+runit(void * threadarg)          /* Main routine for one thread */
+{
+    DYNALLSTAT(int,lab,lab_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+    DEFAULTOPTIONS_SPARSEGRAPH(options);
+    statsblk stats;
+    sparsegraph sg;   /* Declare sparse graph structure */
+
+    int n,m,i;
+
+    n = ((params*)threadarg)->n;
+    options.writeautoms = ((params*)threadarg)->writeautoms;
+
+ /* Initialise sparse graph structure. */
+
+    SG_INIT(sg);
+
+    m = SETWORDSNEEDED(n);
+    nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
+
+    DYNALLOC1(int,lab,lab_sz,n,"malloc");
+    DYNALLOC1(int,ptn,ptn_sz,n,"malloc");
+    DYNALLOC1(int,orbits,orbits_sz,n,"malloc");
+
+ /* SG_ALLOC makes sure that the v,d,e fields of a sparse graph
+    structure point to arrays that are large enough.  This only
+    works if the structure has been initialised. */
+
+    SG_ALLOC(sg,n,2*n,"malloc");
+
+    sg.nv = n;              /* Number of vertices */
+    sg.nde = 2*n;           /* Number of directed edges */
+
+    for (i = 0; i < n; ++i)
+    {
+        sg.v[i] = 2*i;
+        sg.d[i] = 2;
+        sg.e[2*i] = (i+n-1)%n;      /* edge i->i-1 */
+        sg.e[2*i+1] = (i+n+1)%n;    /* edge i->i+1 */
+    }
+
+    if (options.writeautoms)
+        printf("Generators for Aut(C[%d]):\n",n);
+    sparsenauty(&sg,lab,ptn,orbits,&options,&stats,NULL);
+
+    if (options.writeautoms)
+    {
+        printf("Automorphism group size = ");
+        writegroupsize(stdout,stats.grpsize1,stats.grpsize2);
+        printf("\n");
+    }
+    if (stats.numorbits != 1 || stats.grpsize1 != 2*n)
+        fprintf(stderr,">E group error\n");
+
+ /* If we are using multiple threads, we need to free all the dynamic
+    memory we have allocated.  We don't have to do this after each 
+    call to nauty, just once before the thread finishes. */
+
+    SG_FREE(sg);
+    DYNFREE(lab,lab_sz);
+    DYNFREE(ptn,ptn_sz);
+    DYNFREE(orbits,orbits_sz);
+    nauty_freedyn();
+    nautil_freedyn();
+    nausparse_freedyn();  /* Use naugraph_freedyn() instead if
+                            dense format is being used. */
+
+    return NULL;
+}
+
+
+int
+main(int argc, char *argv[])
+{
+    int n,ret;
+    pthread_t thread[THREADS];
+    params par[THREADS];
+    int started,finished;
+
+#if !HAVE_TLS
+    fprintf(stderr,">E This program needs to be linked with a version\n");
+    fprintf(stderr,"  of nauty successfully configured using --enable-tls.\n");
+    exit(1);
+#endif
+
+    for (started = finished = 0; finished < THREADS; )
+    {
+	if (started == THREADS || started-finished == ATONCE)
+	{
+	    if ((ret = pthread_join(thread[finished],NULL)) != 0)
+	    {
+                fprintf(stderr,">E Thread joining failed, code=%d\n",ret);    
+                exit(1);
+            }
+	    ++finished;
+	}
+	else
+	{
+		/* We vary the graph size a bit as it tests the
+                   thread independence better. */
+	    par[started].n = GRAPHSIZE + (started % 17);
+	    par[started].writeautoms = FALSE;
+
+            if ((ret = pthread_create(&thread[started],NULL,
+					runit,&par[started])) != 0)
+            {
+                fprintf(stderr,">E Thread creation failed, code=%d\n",ret);       
+                exit(1);
+            }
+	    ++started;
+	}
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/nautil.c b/lib/nauty/nautil.c
new file mode 100644
index 0000000..eb10cf4
--- /dev/null
+++ b/lib/nauty/nautil.c
@@ -0,0 +1,747 @@
+/*****************************************************************************
+*                                                                            *
+*  Auxiliary source file for version 2.6 of nauty.                           *
+*                                                                            *
+*   Copyright (1984-2013) Brendan McKay.  All rights reserved.               *
+*   Subject to waivers and disclaimers in nauty.h.                           *
+*                                                                            *
+*   CHANGE HISTORY                                                           *
+*       10-Nov-87 : final changes for version 1.2                            *
+*        5-Dec-87 : renamed to version 1.3 (no changes to this file)         *
+*       28-Sep-88 : renamed to version 1.4 (no changes to this file)         *
+*       23-Mar-89 : changes for version 1.5 :                                *
+*                   - added procedure refine1()                              *
+*                   - changed type of ptn from int* to nvector* in fmptn()   *
+*                   - declared level in breakout()                           *
+*                   - changed char[] to char* in a few places                *
+*                   - minor rearrangement in bestcell()                      *
+*       31-Mar-89 : - added procedure doref()                                *
+*        5-Apr-89 : - changed MAKEEMPTY uses to EMPTYSET                     *
+*       12-Apr-89 : - changed writeperm() and fmperm() to not use MARKing    *
+*        5-May-89 : - redefined MASH to gain about 8% efficiency             *
+*       18-Oct-90 : changes for version 1.6 :                                *
+*                   - improved line breaking in writeperm()                  *
+*       10-Nov-90 : - added dummy routine nautil_null()                      *
+*       27-Aug-92 : changes for version 1.7 :                                *
+*                   - made linelength <= 0 mean no line breaks               *
+*        5-Jun-93 : renamed to version 1.7+ (no changes to this file)        *
+*       18-Aug-93 : renamed to version 1.8 (no changes to this file)         *
+*       17-Sep-93 : renamed to version 1.9 (no changes to this file)         *
+*       29-Jun-95 : changes for version 1.10 :                               *
+*                   - replaced loop in nextelement() to save reference past  *
+*                     end of array (thanks to Kevin Maylsiak)                *
+*       11-Jul-96 : changes for version 2.0 :                                *
+*                   - added alloc_error()                                    *
+*                   - added dynamic allocation                               *
+*       21-Oct-98 : use 077777 in place of INFINITY for CLEANUP()            *
+*        9-Jan-00 : added nautil_check()                                     *
+*       12-Feb-00 : did a little formating of the code                       *
+*       28-May-00 : added nautil_freedyn()                                   *
+*       16-Aug-00 : added OLDNAUTY behaviour                                 *
+*       16-Nov-00 : moved graph-specific things to naugraph.c                *
+*                   use function prototypes, remove UPROC, nvector           *
+*       22-Apr-01 : added code for compilation into Magma                    *
+*                   removed nautil_null()                                    *
+*                   removed EXTDEFS and included labelorg                    *
+*       21-Nov-01 : use NAUTYREQUIRED in nautil_check()                      *
+*       26-Jun-02 : revised permset() to avoid fetch past the end of         *
+*                     the array (thanks to Jan Kieffer)                      *
+*       17-Nov-03 : changed INFINITY to NAUTY_INFINITY                       *
+*       14-Sep-04 : extended prototypes to recursive functions               *
+*       23-Nov-06 : replave targetcell() by maketargetcell()                 *
+*       10-Dec-06 : remove BIGNAUTY                                          *
+*       10-Dec-10 : remove shortish and permutation types                    *
+*       11-May-10 : use sorttemplates.c                                      *
+*       27-Mar-11 : add writegroupsize()                                     *
+*       15-Jan-12 : add TLS_ATTR attributes                                  *
+*       16-Sep-12 : small change to objoin(), more efficient for sparse case *
+*       22-Sep-12 : change documentation of orbjoin()                        *
+*       18-Jan-12 : changes for version 2.6 :                                *
+*                 - declare nauty_kill_request                               *
+*                                                                            *
+*****************************************************************************/
+
+#define ONE_WORD_SETS
+#include "nauty.h"
+#ifdef NAUTY_IN_MAGMA
+#include "io.e"
+#endif
+
+    /* macros for hash-codes: */
+    /* Don't use NAUTY_INFINITY here as that would make the canonical
+     * labelling depend on whether BIGNAUTY is in operation */
+#define MASH(l,i) ((((l) ^ 065435) + (i)) & 077777)
+    /* : expression whose long value depends only on long l and int/long i.
+         Anything goes, preferably non-commutative. */
+
+#define CLEANUP(l) ((int)((l) % 077777))
+    /* : expression whose value depends on long l and is less than 077777
+         when converted to int then short.  Anything goes. */
+
+#if  MAXM==1
+#define M 1
+#else
+#define M m
+#endif
+
+#if !MAXN
+DYNALLSTAT(int,workperm,workperm_sz);
+#else
+static TLS_ATTR int workperm[MAXN];
+#endif
+
+int labelorg = 0;   /* no TLS_ATTR on purpose */
+volatile int nauty_kill_request = 0;   /* no TLS_ATTR on purpose */
+
+/* aproto: header new_nauty_protos.h */
+
+/*****************************************************************************
+*                                                                            *
+*  nextelement(set1,m,pos) = the position of the first element in set set1   *
+*  which occupies a position greater than pos.  If no such element exists,   *
+*  the value is -1.  pos can have any value less than n, including negative  *
+*  values.                                                                   *
+*                                                                            *
+*  GLOBALS ACCESSED: none                                                    *
+*                                                                            *
+*****************************************************************************/
+
+int
+nextelement(set *set1, int m, int pos)
+{
+    setword setwd;
+
+#if  MAXM==1
+    if (pos < 0) setwd = set1[0];
+    else         setwd = set1[0] & BITMASK(pos);
+
+    if (setwd == 0) return -1;
+    else            return FIRSTBITNZ(setwd);
+#else
+    int w;
+
+    if (pos < 0)
+    {
+        w = 0;
+        setwd = set1[0];
+    }
+    else
+    {
+        w = SETWD(pos);
+        setwd = set1[w] & BITMASK(SETBT(pos));
+    }
+
+    for (;;)
+    {
+        if (setwd != 0) return  TIMESWORDSIZE(w) + FIRSTBITNZ(setwd);
+        if (++w == m) return -1;
+        setwd = set1[w];
+    }
+
+#endif
+}
+
+/*****************************************************************************
+*                                                                            *
+*  permset(set1,set2,m,perm)  defines set2 to be the set                     *
+*  {perm[i] | i in set1}.                                                    *
+*                                                                            *
+*  GLOBALS ACCESSED: bit<r>,leftbit<r>                                       *
+*                                                                            *
+*****************************************************************************/
+
+void
+permset(set *set1, set *set2, int m, int *perm)
+{
+    setword setw;
+    int pos,w,b;
+
+    EMPTYSET(set2,m);
+
+#if  MAXM==1
+    setw = set1[0];
+    while (setw  != 0)
+    {
+        TAKEBIT(b,setw);
+        pos = perm[b];
+        ADDELEMENT(set2,pos);
+    }
+#else
+    for (w = 0; w < m; ++w)
+    {
+        setw = set1[w];
+        while (setw != 0)
+        {
+            TAKEBIT(b,setw);
+            pos = perm[TIMESWORDSIZE(w)+b];
+            ADDELEMENT(set2,pos);
+        }
+    }
+#endif
+}
+
+/*****************************************************************************
+*                                                                            *
+*  putstring(f,s) writes the nul-terminated string s to file f.              *
+*                                                                            *
+*****************************************************************************/
+
+void
+putstring(FILE *f, char *s)
+{
+    while (*s != '\0')
+    {
+        PUTC(*s,f);
+        ++s;
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  itos(i,s) converts the int i to a nul-terminated decimal character        *
+*  string s.  The value returned is the number of characters excluding       *
+*  the nul.                                                                  *
+*                                                                            *
+*  GLOBALS ACCESSED: NONE                                                    *
+*                                                                            *
+*****************************************************************************/
+
+int
+itos(int i, char *s)
+{
+    int digit,j,k;
+    char c;
+    int ans;
+
+    if (i < 0)
+    {
+        k = 0;
+        i = -i;
+        j = 1;
+        s[0] = '-';
+    }
+    else
+    {
+        k = -1;
+        j = 0;
+    }
+
+    do
+    {
+        digit = i % 10;
+        i = i / 10;
+        s[++k] = (char)(digit + '0');
+    }
+    while (i);
+
+    s[k+1] = '\0';
+    ans = k + 1;
+
+    for (; j < k; ++j, --k)
+    {
+        c = s[j];
+        s[j] = s[k];
+        s[k] = c;
+    }
+
+    return ans;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  orbits represents a partition of {0,1,...,n-1}, by orbits[i] = the        *
+*  smallest element in the same cell as i.  map[] is any array with values   *
+*  in {0,1,...,n-1}.  orbjoin(orbits,map,n) joins the cells of orbits[]      *
+*  together to the minimum extent such that for each i, i and map[i] are in  *
+*  the same cell.  The function value returned is the new number of cells.   *
+*                                                                            *
+*  GLOBALS ACCESSED: NONE                                                    *
+*                                                                            *
+*****************************************************************************/
+
+int
+orbjoin(int *orbits, int *map, int n)
+{
+    int i,j1,j2;
+
+    for (i = 0; i < n; ++i)
+    if (map[i] != i)
+    {
+        j1 = orbits[i];
+        while (orbits[j1] != j1) j1 = orbits[j1];
+        j2 = orbits[map[i]];
+        while (orbits[j2] != j2) j2 = orbits[j2];
+
+        if (j1 < j2)      orbits[j2] = j1;
+        else if (j1 > j2) orbits[j1] = j2;
+    }
+
+    j1 = 0;
+    for (i = 0; i < n; ++i)
+        if ((orbits[i] = orbits[orbits[i]]) == i) ++j1;
+
+    return j1;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  writeperm(f,perm,cartesian,linelength,n) writes the permutation perm to   *
+*  the file f.  The cartesian representation (i.e. perm itself) is used if   *
+*  cartesian != FALSE; otherwise the cyclic representation is used.  No      *
+*  more than linelength characters (not counting '\n') are written on each   *
+*  line, unless linelength is ridiculously small.  linelength<=0 causes no   *
+*  line breaks at all to be made.  The global int labelorg is added to each  *
+*  vertex number.                                                            *
+*                                                                            *
+*  GLOBALS ACCESSED: itos(),putstring()                                      *
+*                                                                            *
+*****************************************************************************/
+
+void
+writeperm(FILE *f, int *perm, boolean cartesian, int linelength, int n)
+{
+    int i,k,l,curlen,intlen;
+    char s[30];
+
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n,"writeperm");
+#endif
+
+    /* CONDNL(x) writes end-of-line and 3 spaces if x characters
+       won't fit on the current line. */
+#define CONDNL(x) if (linelength>0 && curlen+(x)>linelength)\
+              {putstring(f,"\n   ");curlen=3;}
+
+    curlen = 0;
+    if (cartesian)
+    {
+        for (i = 0; i < n; ++i)
+        {
+            intlen = itos(perm[i]+labelorg,s);
+            CONDNL(intlen+1);
+            PUTC(' ',f);
+            putstring(f,s);
+            curlen += intlen + 1;
+        }
+        PUTC('\n',f);
+    }
+    else
+    {
+        for (i = n; --i >= 0;) workperm[i] = 0;
+
+        for (i = 0; i < n; ++i)
+        {
+            if (workperm[i] == 0 && perm[i] != i)
+            {
+                l = i;
+                intlen = itos(l+labelorg,s);
+                if (curlen > 3) CONDNL(2*intlen+4);
+                PUTC('(',f);
+                do
+                {
+                    putstring(f,s);
+                    curlen += intlen + 1;
+                    k = l;
+                    l = perm[l];
+                    workperm[k] = 1;
+                    if (l != i)
+                    {
+                        intlen = itos(l+labelorg,s);
+                        CONDNL(intlen+2);
+                        PUTC(' ',f);
+                    }
+                }
+                while (l != i);
+                PUTC(')',f);
+                ++curlen;
+            }
+        }
+
+        if (curlen == 0) putstring(f,"(1)\n");
+        else             PUTC('\n',f);
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  fmperm(perm,fix,mcr,m,n) uses perm to construct fix and mcr.  fix         *
+*  contains those points are fixed by perm, while mcr contains the set of    *
+*  those points which are least in their orbits.                             *
+*                                                                            *
+*  GLOBALS ACCESSED: bit<r>                                                  *
+*                                                                            *
+*****************************************************************************/
+
+void
+fmperm(int *perm, set *fix, set *mcr, int m, int n)
+{
+    int i,k,l;
+
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n,"writeperm");
+#endif
+
+    EMPTYSET(fix,m);
+    EMPTYSET(mcr,m);
+
+    for (i = n; --i >= 0;) workperm[i] = 0;
+
+    for (i = 0; i < n; ++i)
+        if (perm[i] == i)
+        {
+            ADDELEMENT(fix,i);
+            ADDELEMENT(mcr,i);
+        }
+        else if (workperm[i] == 0)
+        {
+            l = i;
+            do
+            {
+                k = l;
+                l = perm[l];
+                workperm[k] = 1;
+            }
+            while (l != i);
+
+            ADDELEMENT(mcr,i);
+        }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  fmptn(lab,ptn,level,fix,mcr,m,n) uses the partition at the specified      *
+*  level in the partition nest (lab,ptn) to make sets fix and mcr.  fix      *
+*  represents the points in trivial cells of the partition, while mcr        *
+*  represents those points which are least in their cells.                   *
+*                                                                            *
+*  GLOBALS ACCESSED: bit<r>                                                  *
+*                                                                            *
+*****************************************************************************/
+
+void
+fmptn(int *lab, int *ptn, int level, set *fix, set *mcr, int m, int n)
+{
+    int i,lmin;
+
+    EMPTYSET(fix,m);
+    EMPTYSET(mcr,m);
+
+    for (i = 0; i < n; ++i)
+        if (ptn[i] <= level)
+        {
+            ADDELEMENT(fix,lab[i]);
+            ADDELEMENT(mcr,lab[i]);
+        }
+        else
+        {
+            lmin = lab[i];
+            do
+                if (lab[++i] < lmin) lmin = lab[i];
+            while (ptn[i] > level);
+            ADDELEMENT(mcr,lmin);
+        }
+}
+
+#define SORT_TYPE1 int
+#define SORT_TYPE2 int
+#define SORT_OF_SORT 2
+#define SORT_NAME sortparallel
+#include "sorttemplates.c"
+
+/*****************************************************************************
+*                                                                            *
+*  doref(g,lab,ptn,level,numcells,qinvar,invar,active,code,refproc,          *
+*        invarproc,mininvarlev,maxinvarlev,invararg,digraph,m,n)             *
+*  is used to perform a refinement on the partition at the given level in    *
+*  (lab,ptn).  The number of cells is *numcells both for input and output.   *
+*  The input active is the active set for input to the refinement procedure  *
+*  (*refproc)(), which must have the argument list of refine().              *
+*  active may be arbitrarily changed.  invar is used for working storage.    *
+*  First, (*refproc)() is called.  Then, if invarproc!=NULL and              *
+*  |mininvarlev| <= level <= |maxinvarlev|, the routine (*invarproc)() is    *
+*  used to compute a vertex-invariant which may refine the partition         *
+*  further.  If it does, (*refproc)() is called again, using an active set   *
+*  containing all but the first fragment of each old cell.  Unless g is a    *
+*  digraph, this guarantees that the final partition is equitable.  The      *
+*  arguments invararg and digraph are passed to (*invarproc)()               *
+*  uninterpretted.  The output argument code is a composite of the codes     *
+*  from all the calls to (*refproc)().  The output argument qinvar is set    *
+*  to 0 if (*invarproc)() is not applied, 1 if it is applied but fails to    *
+*  refine the partition, and 2 if it succeeds.                               *
+*  See the file nautinv.c for a further discussion of vertex-invariants.     *
+*  Note that the dreadnaut I command generates a call to  this procedure     *
+*  with level = mininvarlevel = maxinvarlevel = 0.                           *
+*                                                                            *
+*****************************************************************************/
+
+void
+doref(graph *g, int *lab, int *ptn, int level, int *numcells,
+     int *qinvar, int *invar, set *active, int *code,
+     void (*refproc)(graph*,int*,int*,int,int*,int*,set*,int*,int,int),
+     void (*invarproc)(graph*,int*,int*,int,int,int,int*,
+                                                 int,boolean,int,int),
+     int mininvarlev, int maxinvarlev, int invararg,
+     boolean digraph, int m, int n)
+{
+    int pw;
+    int i,cell1,cell2,nc,tvpos,minlev,maxlev;
+    long longcode;
+    boolean same;
+
+#if !MAXN 
+    DYNALLOC1(int,workperm,workperm_sz,n,"doref"); 
+#endif
+
+    if ((tvpos = nextelement(active,M,-1)) < 0) tvpos = 0;
+
+    (*refproc)(g,lab,ptn,level,numcells,invar,active,code,M,n);
+
+    minlev = (mininvarlev < 0 ? -mininvarlev : mininvarlev);
+    maxlev = (maxinvarlev < 0 ? -maxinvarlev : maxinvarlev);
+    if (invarproc != NULL && *numcells < n
+                        && level >= minlev && level <= maxlev)
+    {
+        (*invarproc)(g,lab,ptn,level,*numcells,tvpos,invar,invararg,
+                                                             digraph,M,n);
+        EMPTYSET(active,m);
+        for (i = n; --i >= 0;) workperm[i] = invar[lab[i]];
+        nc = *numcells;
+        for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+        {
+            pw = workperm[cell1];
+            same = TRUE;
+            for (cell2 = cell1; ptn[cell2] > level; ++cell2)
+                if (workperm[cell2+1] != pw) same = FALSE;
+
+            if (same) continue;
+
+            sortparallel(workperm+cell1, lab+cell1, cell2-cell1+1);
+
+            for (i = cell1 + 1; i <= cell2; ++i)
+                if (workperm[i] != workperm[i-1])
+                {
+                    ptn[i-1] = level;
+                    ++*numcells;
+                    ADDELEMENT(active,i);
+                }
+        }
+
+        if (*numcells > nc)
+        {
+            *qinvar = 2;
+            longcode = *code;
+            (*refproc)(g,lab,ptn,level,numcells,invar,active,code,M,n);
+            longcode = MASH(longcode,*code);
+            *code = CLEANUP(longcode);
+        }
+        else
+            *qinvar = 1;
+    }
+    else
+        *qinvar = 0;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  maketargetcell(g,lab,ptn,level,tcell,tcellsize,&cellpos,                  *
+*                 tc_level,digraph,hint,targetcell,m,n)                      *
+*  calls targetcell() to determine the target cell at the specified level    *
+*  in the partition nest (lab,ptn).  It must be a nontrivial cell (if not,   *
+*  the first cell.  The intention of hint is that, if hint >= 0 and there    *
+*  is a suitable non-trivial cell starting at position hint in lab,          *
+*  that cell is chosen.                                                      *
+*  tc_level and digraph are input options.                                   *
+*  When a cell is chosen, tcell is set to its contents, *tcellsize to its    *
+*  size, and cellpos to its starting position in lab.                        *
+*                                                                            *
+*  GLOBALS ACCESSED: bit<r>                                                  *
+*                                                                            *
+*****************************************************************************/
+
+void
+maketargetcell(graph *g, int *lab, int *ptn, int level, set *tcell,
+       int *tcellsize, int *cellpos, int tc_level, boolean digraph,
+       int hint,
+       int (*targetcell)(graph*,int*,int*,int,int,boolean,int,int,int),
+       int m, int n)
+{
+    int i,j,k;
+
+    i = (*targetcell)(g,lab,ptn,level,tc_level,digraph,hint,m,n);
+    for (j = i + 1; ptn[j] > level; ++j) {}
+
+    *tcellsize = j - i + 1;
+
+    EMPTYSET(tcell,m);
+    for (k = i; k <= j; ++k) ADDELEMENT(tcell,lab[k]);
+
+    *cellpos = i;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  shortprune(set1,set2,m) ANDs the contents of set set2 into set set1.      *
+*                                                                            *
+*  GLOBALS ACCESSED: NONE                                                    *
+*                                                                            *
+*****************************************************************************/
+
+void
+shortprune(set *set1, set *set2, int m)
+{
+    int i;
+
+    for (i = 0; i < M; ++i) INTERSECT(set1[i],set2[i]);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  breakout(lab,ptn,level,tc,tv,active,m) operates on the partition at       *
+*  the specified level in the partition nest (lab,ptn).  It finds the        *
+*  element tv, which is in the cell C starting at index tc in lab (it had    *
+*  better be) and splits C in the two cells {tv} and C\{tv}, in that order.  *
+*  It also sets the set active to contain just the element tc.               *
+*                                                                            *
+*  GLOBALS ACCESSED: bit<r>                                                  *
+*                                                                            *
+*****************************************************************************/
+
+void
+breakout(int *lab, int *ptn, int level, int tc, int tv,
+     set *active, int m)
+{
+    int i,prev,next;
+
+    EMPTYSET(active,m);
+    ADDELEMENT(active,tc);
+
+    i = tc;
+    prev = tv;
+
+    do
+    {
+        next = lab[i];
+        lab[i++] = prev;
+        prev = next;
+    }
+    while (prev != tv);
+
+    ptn[tc] = level;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  longprune(tcell,fix,bottom,top,m) removes zero or elements of the set     *
+*  tcell.  It is assumed that addresses bottom through top-1 contain         *
+*  contiguous pairs of sets (f1,m1),(f2,m2), ... .  tcell is intersected     *
+*  with each mi such that fi is a subset of fix.                             *
+*                                                                            *
+*  GLOBALS ACCESSED: NONE                                                    *
+*                                                                            *
+*****************************************************************************/
+
+void
+longprune(set *tcell, set *fix, set *bottom, set *top, int m)
+{
+    int i;
+
+    while (bottom < top)
+    {
+        for (i = 0; i < M; ++i)
+            if (NOTSUBSET(fix[i],bottom[i])) break;
+        bottom += M;
+
+        if (i == M)
+            for (i = 0; i < M; ++i) INTERSECT(tcell[i],bottom[i]);
+        bottom += M;
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  writegroupsize(f,gpsize1,gpsize2) writes a real number gpsize1*10^gpsize2 *
+*  It is assumed that gpsize1 >= 1 and that gpsize1 equals an integer in the *
+*  case that gpsize2==0.  These assumptions are true for group sizes         *
+*  computed by nauty.                                                        *
+*                                                                            *
+*****************************************************************************/
+
+void
+writegroupsize(FILE *f, double gpsize1, int gpsize2)
+{
+    if (gpsize2 == 0)
+        fprintf(f,"%.0f",gpsize1+0.1);
+    else
+    {   
+        while (gpsize1 >= 10.0)
+        {   
+            gpsize1 /= 10.0;
+            ++gpsize2;
+        }
+        fprintf(f,"%14.12fe%d",gpsize1,gpsize2);
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  nautil_check() checks that this file is compiled compatibly with the      *
+*  given parameters.   If not, call exit(1).                                 *
+*                                                                            *
+*****************************************************************************/
+
+void
+nautil_check(int wordsize, int m, int n, int version)
+{
+    if (wordsize != WORDSIZE)
+    {
+        fprintf(ERRFILE,"Error: WORDSIZE mismatch in nautil.c\n");
+        exit(1);
+    }
+
+#if MAXN
+    if (m > MAXM)
+    {
+        fprintf(ERRFILE,"Error: MAXM inadequate in nautil.c\n");
+        exit(1);
+    }
+
+    if (n > MAXN)
+    {
+        fprintf(ERRFILE,"Error: MAXN inadequate in nautil.c\n");
+        exit(1);
+    }
+#endif
+
+    if (version < NAUTYREQUIRED)
+    {
+        fprintf(ERRFILE,"Error: nautil.c version mismatch\n");
+        exit(1);
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  alloc_error() writes a message and exits.  Used by DYNALLOC? macros.      *
+*                                                                            *
+*****************************************************************************/
+
+void
+alloc_error(const char *s)
+{
+    fprintf(ERRFILE,"Dynamic allocation failed: %s\n",s);
+    exit(2);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  nautil_freedyn() - free the dynamic memory in this module                 *
+*                                                                            *
+*****************************************************************************/
+
+void
+nautil_freedyn(void)
+{
+#if !MAXN
+    DYNFREE(workperm,workperm_sz);
+#endif
+}
diff --git a/lib/nauty/nautinv.c b/lib/nauty/nautinv.c
new file mode 100644
index 0000000..fa7d21d
--- /dev/null
+++ b/lib/nauty/nautinv.c
@@ -0,0 +1,1752 @@
+/*****************************************************************************
+*                                                                            *
+*  Vertex-invariants source file for nauty 2.6.                              *
+*                                                                            *
+*   Copyright (1989-2013) Brendan McKay.  All rights reserved.               *
+*   Subject to waivers and disclaimers in nauty.h.                           *
+*                                                                            *
+*   CHANGE HISTORY                                                           *
+*       13-Mar-90 : initial release for version 1.5                          *
+*       10-Nov-90 : changes for version 1.6 :                                *
+*                 - added dummy routine nautinv_null()                       *
+*       27-Aug-92 : renamed to version 1.7, no changes to this file          *
+*        5-Jun-93 : renamed to version 1.7+, no changes to this file         *
+*       18-Aug-93 : renamed to version 1.8, no changes to this file          *
+*       17-Sep-93 : changes for version 1.9 :                                *
+*                 - added invariant routine adjacencies()                    *
+*       20-Jun-96 : changes for version 2.0 :                                *
+*                 - added invariants cellfano() and cellfano2()              *
+*       11-Jul-96 - added dynamic allocation                                 *
+*       21-Oct-98 - use shortish in place of short for BIGNAUTY              *
+*        9-Jan-00 - added nautinv_check()                                    *
+*       12-Feb-00 - minor code formatting                                    *
+*       16-Nov-00 - made changes listed in nauty.h                           *
+*       22-Apr-01 : changes for version 2.1 :                                *
+*                 - made all large dynamic memory external to routines       *
+*                 - added nautinv_freedyn() to free all such memory          *
+*                 - include nautinv.h rather than naututil.h                 *
+*                 - removed nautinv_null()                                   *
+*                 - added code to facilitate compilation into Magma          *
+*                 - removed EXTDEFS                                          *
+*       12-Jul-01 - use invararg in distances()                              *
+*                 - fixed comments in ind and cliq routines                  *
+*       21-Nov-01 : use NAUTYREQUIRED in nautinv_check()                     *
+*       10-Dec-06 : remove BIGNAUTY                                          *
+*       10-Nov-09 : remove types shortish and permutation                    *
+*       23-Nov-09 : add refinvar()                                           *
+*       12-Jun-10 : fixed identical errors in cellcliq() and cellind()       *
+*       15-Jan-12 : add TLS_ATTR attributes                                  *
+*       23-Aug-12 : fix getbigcells(), thanks to Fatih Demirkale             *
+*       23-Jan-13 : add some parens to satisfy icc                           *
+*                                                                            *
+*****************************************************************************/
+
+#define ONE_WORD_SETS
+#include "nautinv.h"
+
+#if  MAXM==1
+#define M 1
+#else
+#define M m
+#endif
+
+#define MASH(l,i) ((((l) ^ 056345) + (i)) & 077777)
+    /* : expression whose long value depends only on long l and int/long i.
+	 Anything goes, preferably non-commutative. */
+
+#define CLEANUP(l) ((int)((l) % 077777))
+    /* : expression whose value depends on long l and is less than 077777
+	 when converted to int then short.  Anything goes. */
+
+#define ACCUM(x,y)   x = (((x) + (y)) & 077777)
+    /* : must be commutative. */
+
+static const int fuzz1[] = {037541,061532,005257,026416};
+static const int fuzz2[] = {006532,070236,035523,062437};
+
+#define FUZZ1(x) ((x) ^ fuzz1[(x)&3])
+#define FUZZ2(x) ((x) ^ fuzz2[(x)&3])
+
+#define MAXCLIQUE 10    /* max clique size for cliques() and maxindset() */
+
+#if MAXN
+static TLS_ATTR int workshort[MAXN+2];
+static TLS_ATTR int vv[MAXN],ww[MAXN];
+static TLS_ATTR int workperm[MAXN];
+static TLS_ATTR int bucket[MAXN+2];
+static TLS_ATTR int count[MAXN];
+static TLS_ATTR set workset[MAXM];
+static TLS_ATTR set w01[MAXM],w02[MAXM],w03[MAXM],w12[MAXM],w13[MAXM],w23[MAXM];
+static TLS_ATTR set pt0[MAXM],pt1[MAXM],pt2[MAXM];
+static TLS_ATTR set wss[MAXCLIQUE-1][MAXM];
+static TLS_ATTR set ws1[MAXM],ws2[MAXM];
+#else
+DYNALLSTAT(int,workshort,workshort_sz);
+DYNALLSTAT(int,vv,vv_sz);
+DYNALLSTAT(int,ww,ww_sz);
+DYNALLSTAT(int,workperm,workperm_sz);
+DYNALLSTAT(int,bucket,bucket_sz);
+DYNALLSTAT(int,count,count_sz);
+DYNALLSTAT(set,ws1,ws1_sz);
+DYNALLSTAT(set,ws2,ws2_sz);
+DYNALLSTAT(set,workset,workset_sz);
+DYNALLSTAT(set,w01,w01_sz);
+DYNALLSTAT(set,w02,w02_sz);
+DYNALLSTAT(set,w03,w03_sz);
+DYNALLSTAT(set,w12,w12_sz);
+DYNALLSTAT(set,w13,w13_sz);
+DYNALLSTAT(set,w23,w23_sz);
+DYNALLSTAT(set,pt0,pt0_sz);
+DYNALLSTAT(set,pt1,pt1_sz);
+DYNALLSTAT(set,pt2,pt2_sz);
+DYNALLSTAT(set,wss,wss_sz);
+#endif
+
+/* aproto: header new_nauty_protos.h */
+
+/*****************************************************************************
+*                                                                            *
+*  This file contains a number of procedures which compute vertex-invariants *
+*  for stronger partition refinement.   Since entirely different             *
+*  vertex-invariants seem to work better for different types of graph, we    *
+*  cannot do more than give a small collection of representative examples.   *
+*  Any serious computations with difficult graphs may well need to use       *
+*  specially-written vertex-invariants.  The use of vertex-invariants        *
+*  procedures is supported by nauty from version 1.5 onwards, via the        *
+*  options userinvarproc, mininvarlevel, maxinvarlevel and invararg.         *
+*  The meaning of these fields in detail are as follows:                     *
+*     userinvarproc  is the address of the vertex-invariant procedure.  If   *
+*                    no vertex-invariants is required, this field should     *
+*                    have the value NULL.                                    *
+*     maxinvarlevel  The absolute value of this is the maximum level in the  *
+*                    search tree at which the vertex-invariant will be       *
+*                    computed.  The root of the tree is at level 1, so the   *
+*                    vertex-invariant will not be invoked at all if          *
+*                    maxinvarlevel==0.  Negative values of maxinvarlevel     *
+*                    request nauty to not compute the vertex-invariant at    *
+*                    a level greater than that of the earliest node (if any) *
+*                    on the path to the first leaf of the search tree at     *
+*                    which the vertex-invariant refines the partition.       *
+*     mininvarlevel  The absolute value of this is the minimum level in the  *
+*                    search tree at which the vertex-invariant will be       *
+*                    computed.  The root of the tree is at level 1, so there *
+*                    is no effective limit if mininvarlevel is -1, 0 or 1.   *
+*                    Negative values of mininvarlevel request nauty to not   *
+*                    compute the vertex-invariant at a level less than       *
+*                    that of the earliest node (if any) on the path to the   *
+*                    first leaf of the search tree at which the              *
+*                    vertex-invariant refines the partition.                 *
+*     invararg       is passed to the vertex-invariant procedure via the     *
+*                    argument of the same name.  It can be used by the       *
+*                    procedure for any purpose.                              *
+*  Note that negative values of maxinvarlevel and mininvarlevel make the     *
+*  canonical labelling invalid, but can speed automorphism group finding.    *
+*  Nauty already knows this and takes their absolute values.                 *
+*                                                                            *
+*  A vertex-invariant must be declared thus:                                 *
+*  void invarproc(g,lab,ptn,level,numcells,tvpos,invar,invararg,digraph,m,n) *
+*  All of these arguments must be treated as read-only except for invar.     *
+*  g        : the graph, exactly as passed to nauty()                        *
+*  lab,ptn  : the current partition nest (see nauty.h for the format)        *
+*  level    : the level of this node in the search tree.                     *
+*  numcells : the number of cells in the partition at this node.             *
+*  tvpos    : the index in (lab,ptn) of one cell in the partition.           *
+*             If level <= 1, the cell will be the first fragment of the      *
+*             first active cell (as provided by the initial call to nauty),  *
+*             or the first cell, if there were no active cells.              *
+*             If level > 1, the cell will be the singleton cell which was    *
+*             created to make this node of the search tree from its parent.  *
+*  invararg : a copy of options.invararg                                     *
+*  digraph  : a copy of options.digraph                                      *
+*  m,n      : size parameters as passed to nauty()                           *
+*  invar    : an array to return the answer in.   The procedure must put in  *
+*             each invar[i]  (0 <= i < n)  an invariant of the 6-tuple       *
+*             (<vertex i>,g,<the partition nest to this level>,level,        *
+*               invararg,digraph)                                            *
+*             Note that invar[] is declared as an int array.  Since the      *
+*             absolute value of the invariant is irrelevant, only the        *
+*             comparative values, any short, int or long value can be        *
+*             assigned to the entries of invar[] without fear.  However,     *  
+*             you should assign a value less than 077777 to ensure machine-  *
+*             independence of the canonical labelling.                       *
+*                                                                            *
+*  The refinement procedure has already been called before the invariant     *
+*  procedure is called.  That means that the partition is equitable if       *
+*  digraph==FALSE.                                                           *
+*                                                                            *
+*****************************************************************************/
+
+/*****************************************************************************
+*                                                                            *
+*  twopaths() assigns to each vertex v the sum of the weights of each vertex *
+*  which can be reached from v along a walk of length two (including itself  *
+*  usually).  The weight of each vertex w is defined as the ordinal number   *
+*  of the cell containing w, starting at 1 for the first cell.               *
+*                                                                            *
+*****************************************************************************/
+
+void
+twopaths(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+         int *invar, int invararg, boolean digraph, int m, int n)
+{
+        int i,v,w;
+        int wt;
+        set *gv,*gw;
+
+#if !MAXN
+	DYNALLOC1(set,workset,workset_sz,m,"twopaths");
+	DYNALLOC1(int,workshort,workshort_sz,n+2,"twopaths");
+#endif
+
+        wt = 1;
+        for (i = 0; i < n; ++i)
+        {
+            workshort[lab[i]] = wt;
+            if (ptn[i] <= level) ++wt;
+        }
+
+        for (v = 0, gv = (set*)g; v < n; ++v, gv += M)
+        {
+            EMPTYSET(workset,m);
+            w = -1;
+            while ((w = nextelement(gv,M,w)) >= 0)
+            {
+                gw = GRAPHROW(g,w,m);
+                for (i = M; --i >= 0;) UNION(workset[i],gw[i]);
+            }
+            wt = 0;
+            w = -1;
+            while ((w = nextelement(workset,M,w)) >= 0) ACCUM(wt,workshort[w]);
+            invar[v] = wt;
+        }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  quadruples() assigns to each vertex v a value depending on the set of     *
+*  weights w(v,v1,v2,v3), where w(v,v1,v2,v3) depends on the number of       *
+*  vertices adjacent to an odd number of {v,v1,v2,v3}, and to the cells      *
+*  that v,v1,v2,v3 belong to.  {v,v1,v2,v3} are permitted to range over all  *
+*  distinct 4-tuples which contain at least one member in the cell tvpos.    *
+*                                                                            *
+*****************************************************************************/
+
+void
+quadruples(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+           int *invar, int invararg, boolean digraph, int m, int n)
+{
+        int i,pc;
+        setword sw;
+        set *gw;
+        int wt;
+        int v,iv,v1,v2,v3;
+        set *gv;
+        long wv,wv1,wv2,wv3;
+
+#if !MAXN
+        DYNALLOC1(int,workshort,workshort_sz,n+2,"quadruples");
+	DYNALLOC1(set,ws1,ws1_sz,m,"quadruples");
+	DYNALLOC1(set,workset,workset_sz,m,"quadruples");
+#endif
+
+        for (i = n; --i >= 0;) invar[i] = 0;
+
+        wt = 1;
+        for (i = 0; i < n; ++i)
+        {
+            workshort[lab[i]] = FUZZ2(wt);
+            if (ptn[i] <= level) ++wt;
+        }
+
+        iv = tvpos - 1;
+        do
+        {
+             v = lab[++iv];
+             gv = GRAPHROW(g,v,m);
+             wv = workshort[v];
+             for (v1 = 0; v1 < n-2; ++v1)
+             {
+                wv1 = workshort[v1];
+                if (wv1 == wv && v1 <= v) continue;
+                wv1 += wv;
+                gw = GRAPHROW(g,v1,m);
+                for (i = M; --i >= 0;) workset[i] = gv[i] ^ gw[i];
+                for (v2 = v1+1; v2 < n-1; ++v2)
+                {
+                    wv2 = workshort[v2];
+                    if (wv2 == wv && v2 <= v) continue;
+                    wv2 += wv1;
+                    gw = GRAPHROW(g,v2,m);
+                    for (i = M; --i >= 0;) ws1[i] = workset[i] ^ gw[i];
+                    for (v3 = v2+1; v3 < n; ++v3)
+                    {
+                        wv3 = workshort[v3];
+                        if (wv3 == wv && v3 <= v) continue;
+                        wv3 += wv2;
+                        gw = GRAPHROW(g,v3,m);
+                        pc = 0;
+                        for (i = M; --i >= 0;)
+                            if ((sw = ws1[i] ^ gw[i]) != 0) pc += POPCOUNT(sw);
+                        wt = (FUZZ1(pc)+wv3) & 077777;
+                        wt = FUZZ2(wt);
+                        ACCUM(invar[v],wt);
+                        ACCUM(invar[v1],wt);
+                        ACCUM(invar[v2],wt);
+                        ACCUM(invar[v3],wt);
+                    }
+                }
+            }
+        }
+        while (ptn[iv] > level);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  triples() assigns to each vertex v a value depending on the set of        *
+*  weights w(v,v1,v2), where w(v,v1,v2) depends on the number of vertices    *
+*  adjacent to an odd number of {v,v1,v2}, and to the cells that             *
+*  v,v1,v2 belong to.  {v,v1,v2} are permitted to range over all distinct    *
+*  triples which contain at least one member in the cell tvpos.              *
+*                                                                            *
+*****************************************************************************/
+
+void
+triples(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+        int *invar, int invararg, boolean digraph, int m, int n)
+{
+        int i,pc;
+        setword sw;
+        set *gw;
+        int wt;
+        int v,iv,v1,v2;
+        set *gv;
+        long wv,wv1,wv2;
+
+#if !MAXN
+        DYNALLOC1(set,workset,workset_sz,m,"triples");
+        DYNALLOC1(int,workshort,workshort_sz,n+2,"triples");
+#endif
+
+        for (i = n; --i >= 0;) invar[i] = 0;
+
+        wt = 1;
+        for (i = 0; i < n; ++i)
+        {
+            workshort[lab[i]] = FUZZ1(wt);
+            if (ptn[i] <= level) ++wt;
+        }
+
+        iv = tvpos - 1;
+        do
+        {
+             v = lab[++iv];
+             gv = GRAPHROW(g,v,m);
+             wv = workshort[v];
+             for (v1 = 0; v1 < n-1; ++v1)
+             {
+                wv1 = workshort[v1];
+                if (wv1 == wv && v1 <= v) continue;
+                wv1 += wv;
+                gw = GRAPHROW(g,v1,m);
+                for (i = M; --i >= 0;) workset[i] = gv[i] ^ gw[i];
+                for (v2 = v1+1; v2 < n; ++v2)
+                {
+                    wv2 = workshort[v2];
+                    if (wv2 == wv && v2 <= v) continue;
+                    wv2 += wv1;
+                    gw = GRAPHROW(g,v2,m);
+                    pc = 0;
+                    for (i = M; --i >= 0;)
+                        if ((sw = workset[i] ^ gw[i]) != 0) pc += POPCOUNT(sw);
+                    wt = (FUZZ1(pc)+wv2) & 077777;
+                    wt = FUZZ2(wt);
+                    ACCUM(invar[v],wt);
+                    ACCUM(invar[v1],wt);
+                    ACCUM(invar[v2],wt);
+                }
+            }
+        }
+        while (ptn[iv] > level);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  adjtriang() assigns to each vertex v a value depending on the numbers     *
+*  of common neighbours between each pair {v1,v2} of neighbours of v, and    *
+*  which cells v1 and v2 lie in.  The vertices v1 and v2 must be adjacent    *
+*  if invararg == 0 and not adjacent if invararg == 1.                       *
+*                                                                            *
+*****************************************************************************/
+
+void
+adjtriang(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+          int *invar, int invararg, boolean digraph, int m, int n)
+{
+        int j,pc;
+        setword sw;
+        set *gi;
+        int wt;
+        int i,v1,v2;
+        boolean v1v2;
+        set *gv1,*gv2;
+
+#if !MAXN
+        DYNALLOC1(set,workset,workset_sz,m,"adjtriang");
+        DYNALLOC1(int,workshort,workshort_sz,n+2,"adjtriang");
+#endif
+
+        for (i = n; --i >= 0;) invar[i] = 0;
+
+        wt = 1;
+        for (i = 0; i < n; ++i)
+        {
+            workshort[lab[i]] = FUZZ1(wt);
+            if (ptn[i] <= level) ++wt;
+        }
+
+        for (v1 = 0, gv1 = g; v1 < n; ++v1, gv1 += M)
+        {
+            for (v2 = (digraph ? 0 : v1+1); v2 < n; ++v2)
+            {
+                if (v2 == v1) continue;
+                v1v2 = (ISELEMENT(gv1,v2) != 0);
+                if ((invararg == 0 && !v1v2)
+			 || (invararg == 1 && v1v2)) continue;
+                wt = workshort[v1];
+                ACCUM(wt,workshort[v2]);
+                ACCUM(wt,v1v2);
+
+                gv2 = GRAPHROW(g,v2,m);
+                for (i = M; --i >= 0;) workset[i] = gv1[i] & gv2[i];
+                i = -1;
+                while ((i = nextelement(workset,M,i)) >= 0)
+                {
+                    pc = 0;
+                    gi = GRAPHROW(g,i,m);
+                    for (j = M; --j >= 0;)
+                        if ((sw = workset[j] & gi[j]) != 0) pc += POPCOUNT(sw);
+                    pc = (pc + wt) & 077777;
+                    ACCUM(invar[i],pc);
+                }
+            }
+        }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  getbigcells(ptn,level,minsize,bigcells,cellstart,cellsize,n) is an        *
+*  auxiliary procedure to make a list of all the large cells in the current  *
+*  partition.  On entry, ptn, level and n have their usual meanings,         *
+*  while minsize is the smallest size of an interesting cell.  On return,    *
+*  bigcells is the number of cells of size at least minsize, cellstart[0...] *
+*  contains their starting positions in ptn, and cellsize[0...] contain      *
+*  their sizes.  These two arrays are in increasing order of cell size,      *
+*  then position.                                                            *
+*                                                                            *
+*****************************************************************************/
+
+void
+getbigcells(int *ptn, int level, int minsize, int *bigcells,
+            int *cellstart, int *cellsize, int n)
+{
+        int cell1,cell2,j;
+        int si,st;
+        int bc,i,h;
+
+        bc = 0;
+        for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+        {
+            for (cell2 = cell1; ptn[cell2] > level; ++cell2) {}
+
+            if (cell2 >= cell1 + minsize - 1)
+            {
+                cellstart[bc] = cell1;
+                cellsize[bc] = cell2 - cell1 + 1;
+                ++bc;
+            }
+        }
+        *bigcells = bc;
+
+        j = bc / 3;
+        h = 1;
+        do
+            h = 3 * h + 1;
+        while (h < j);
+
+        do                      /* shell sort */
+        {
+            for (i = h; i < bc; ++i)
+            {
+                st = cellstart[i];
+                si = cellsize[i];
+                for (j = i; cellsize[j-h] > si ||
+                            (cellsize[j-h] == si && cellstart[j-h] > st); )
+                {
+                    cellsize[j] = cellsize[j-h];
+                    cellstart[j] = cellstart[j-h];
+                    if ((j -= h) < h) break;
+                }
+                cellsize[j] = si;
+                cellstart[j] = st;
+            }
+            h /= 3;
+        }
+        while (h > 0);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  celltrips() assigns to each vertex v a value depending on the set of      *
+*  weights w(v,v1,v2), where w(v,v1,v2) depends on the number of vertices    *
+*  adjacent to an odd number of {v,v1,v2}.  {v,v1,v2} are  constrained to    *
+*  belong to the same cell.  We try the cells in increasing order of size,   *
+*  and stop as soon as any cell splits.                                      *
+*                                                                            *
+*****************************************************************************/
+
+void
+celltrips(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+          int *invar, int invararg, boolean digraph, int m, int n)
+{
+        int i,pc;
+        setword sw;
+        set *gw;
+        int wt;
+        int v,iv,v1,iv1,v2,iv2;
+        int icell,bigcells,cell1,cell2;
+        int *cellstart,*cellsize;
+        set *gv;
+
+#if !MAXN
+        DYNALLOC1(set,workset,workset_sz,m,"celltrips");
+        DYNALLOC1(int,workshort,workshort_sz,n+2,"celltrips");
+#endif
+
+        for (i = n; --i >= 0;) invar[i] = 0;
+
+        cellstart = workshort;
+        cellsize = workshort + (n/2);
+        getbigcells(ptn,level,3,&bigcells,cellstart,cellsize,n);
+
+        for (icell = 0; icell < bigcells; ++icell)
+        {
+            cell1 = cellstart[icell];
+            cell2 = cell1 + cellsize[icell] - 1;
+            for (iv = cell1; iv <= cell2 - 2; ++iv)
+            {
+                v = lab[iv];
+                gv = GRAPHROW(g,v,m);
+                for (iv1 = iv + 1; iv1 <= cell2 - 1; ++iv1)
+                {
+                    v1 = lab[iv1];
+                    gw = GRAPHROW(g,v1,m);
+                    for (i = M; --i >= 0;) workset[i] = gv[i] ^ gw[i];
+                    for (iv2 = iv1 + 1; iv2 <= cell2; ++iv2)
+                    {
+                        v2 = lab[iv2];
+                        gw = GRAPHROW(g,v2,m);
+                        pc = 0;
+                        for (i = M; --i >= 0;)
+                            if ((sw = workset[i] ^ gw[i]) != 0)
+                                pc += POPCOUNT(sw);
+                        wt = FUZZ1(pc);
+                        ACCUM(invar[v],wt);
+                        ACCUM(invar[v1],wt);
+                        ACCUM(invar[v2],wt);
+                    }
+                }
+            }
+            wt = invar[lab[cell1]];
+            for (i = cell1 + 1; i <= cell2; ++i)
+                if (invar[lab[i]] != wt) return;
+        }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  cellquads() assigns to each vertex v a value depending on the set of      *
+*  weights w(v,v1,v2,v3), where w(v,v1,v2,v3) depends on the number of       *
+*  vertices adjacent to an odd number of {v,v1,v2,v3}.  {v,v1,v2,v3} are     *
+*  constrained to belong to the same cell.  We try the cells in increasing   *
+*  order of size, and stop as soon as any cell splits.                       *
+*                                                                            *
+*****************************************************************************/
+
+void
+cellquads(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+          int *invar, int invararg, boolean digraph, int m, int n)
+{
+        int i,pc;
+        setword sw;
+        set *gw;
+        int wt;
+        int v,iv,v1,iv1,v2,iv2,v3,iv3;
+        int icell,bigcells,cell1,cell2;
+        int *cellstart,*cellsize;
+        set *gv;
+
+#if !MAXN
+        DYNALLOC1(set,workset,workset_sz,m,"cellquads");
+        DYNALLOC1(int,workshort,workshort_sz,n+2,"cellquads");
+	DYNALLOC1(set,ws1,ws1_sz,m,"cellquads");
+#endif
+
+        for (i = n; --i >= 0;) invar[i] = 0;
+
+        cellstart = workshort;
+        cellsize = workshort + (n/2);
+        getbigcells(ptn,level,4,&bigcells,cellstart,cellsize,n);
+
+        for (icell = 0; icell < bigcells; ++icell)
+        {
+            cell1 = cellstart[icell];
+            cell2 = cell1 + cellsize[icell] - 1;
+            for (iv = cell1; iv <= cell2 - 3; ++iv)
+            {
+                v = lab[iv];
+                gv = GRAPHROW(g,v,m);
+                for (iv1 = iv + 1; iv1 <= cell2 - 2; ++iv1)
+                {
+                    v1 = lab[iv1];
+                    gw = GRAPHROW(g,v1,m);
+                    for (i = M; --i >= 0;) workset[i] = gv[i] ^ gw[i];
+                    for (iv2 = iv1 + 1; iv2 <= cell2 - 1; ++iv2)
+                    {
+                        v2 = lab[iv2];
+                        gw = GRAPHROW(g,v2,m);
+                        for (i = M; --i >= 0;) ws1[i] = workset[i] ^ gw[i];
+                        for (iv3 = iv2 + 1; iv3 <= cell2; ++iv3)
+                        {
+                            v3 = lab[iv3];
+                            gw = GRAPHROW(g,v3,m);
+                            pc = 0;
+                            for (i = M; --i >= 0;)
+                                if ((sw = ws1[i] ^ gw[i]) != 0)
+                                    pc += POPCOUNT(sw);
+                            wt = FUZZ1(pc);
+                            ACCUM(invar[v],wt);
+                            ACCUM(invar[v1],wt);
+                            ACCUM(invar[v2],wt);
+                            ACCUM(invar[v3],wt);
+                        }
+                    }
+                }
+            }
+            wt = invar[lab[cell1]];
+            for (i = cell1 + 1; i <= cell2; ++i)
+                if (invar[lab[i]] != wt) return;
+        }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  cellquins() assigns to each vertex v a value depending on the set of      *
+*  weights w(v,v1,v2,v3,v4), where w(v,v1,v2,v3,v4) depends on the number    *
+*  of vertices adjacent to an odd number of {v,v1,v2,v3,v4}.                 *
+*  {v,v1,v2,v3,v4} are constrained to belong to the same cell.  We try the   *
+*  cells in increasing order of size, and stop as soon as any cell splits.   *
+*                                                                            *
+*****************************************************************************/
+
+void
+cellquins(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+          int *invar, int invararg, boolean digraph, int m, int n)
+{
+        int i,pc;
+        setword sw;
+        set *gw;
+        int wt;
+        int v,iv,v1,iv1,v2,iv2,v3,iv3,v4,iv4;
+        int icell,bigcells,cell1,cell2;
+        int *cellstart,*cellsize;
+        set *gv;
+
+#if !MAXN
+        DYNALLOC1(set,workset,workset_sz,m,"cellquins");
+        DYNALLOC1(int,workshort,workshort_sz,n+2,"cellquins");
+	DYNALLOC1(set,ws1,ws1_sz,m,"cellquins");
+	DYNALLOC1(set,ws2,ws2_sz,m,"cellquins");
+#endif
+
+        for (i = n; --i >= 0;) invar[i] = 0;
+
+        cellstart = workshort;
+        cellsize = workshort + (n/2);
+        getbigcells(ptn,level,5,&bigcells,cellstart,cellsize,n);
+
+        for (icell = 0; icell < bigcells; ++icell)
+        {
+            cell1 = cellstart[icell];
+            cell2 = cell1 + cellsize[icell] - 1;
+            for (iv = cell1; iv <= cell2 - 4; ++iv)
+            {
+                v = lab[iv];
+                gv = GRAPHROW(g,v,m);
+                for (iv1 = iv + 1; iv1 <= cell2 - 3; ++iv1)
+                {
+                    v1 = lab[iv1];
+                    gw = GRAPHROW(g,v1,m);
+                    for (i = M; --i >= 0;) workset[i] = gv[i] ^ gw[i];
+                    for (iv2 = iv1 + 1; iv2 <= cell2 - 2; ++iv2)
+                    {
+                        v2 = lab[iv2];
+                        gw = GRAPHROW(g,v2,m);
+                        for (i = M; --i >= 0;) ws1[i] = workset[i] ^ gw[i];
+                        for (iv3 = iv2 + 1; iv3 <= cell2 - 1; ++iv3)
+                        {
+                            v3 = lab[iv3];
+                            gw = GRAPHROW(g,v3,m);
+                            for (i = M; --i >= 0;) ws2[i] = ws1[i] ^ gw[i];
+                            for (iv4 = iv3 + 1; iv4 <= cell2; ++iv4)
+                            {
+                                v4 = lab[iv4];
+                                gw = GRAPHROW(g,v4,m);
+                                pc = 0;
+                                for (i = M; --i >= 0;)
+                                    if ((sw = ws2[i] ^ gw[i]) != 0)
+                                        pc += POPCOUNT(sw);
+                                wt = FUZZ1(pc);
+                                ACCUM(invar[v],wt);
+                                ACCUM(invar[v1],wt);
+                                ACCUM(invar[v2],wt);
+                                ACCUM(invar[v3],wt);
+                                ACCUM(invar[v4],wt);
+                            }
+                        }
+                    }
+                }
+            }
+            wt = invar[lab[cell1]];
+            for (i = cell1 + 1; i <= cell2; ++i)
+                if (invar[lab[i]] != wt) return;
+        }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  uniqinter(s1,s2,m) returns the number in both sets if it is unique,       *
+*  or -1 if there is none or it is not unique.                               *
+*****************************************************************************/
+
+static int
+uniqinter(set *s1, set *s2, int m)
+{
+	int i,j;
+	setword w;
+
+	for (i = 0; i < M; ++i)
+	{
+	    if ((w = s1[i] & s2[i]) != 0)
+	    {
+		j = FIRSTBITNZ(w);
+		if (w != BITT[j]) return -1;
+		j += TIMESWORDSIZE(i);
+		for (++i; i < M; ++i)
+		    if (s1[i] & s2[i]) return -1;
+		return j;
+	    }
+	}
+	return -1;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  cellfano2() assigns to each vertex v a value depending on the set of      *
+*  weights w(v,v1,v2,v3), where w(v,v1,v2,v3) depends on the number of       *
+*  fano-plane analogues containing {v,v1,v2,v3}.  {v,v1,v2,v3} are           *
+*  constrained to belong to the same cell and being independent and          *
+*  non-collinear.  We try the cells in increasing order of size, and stop    *
+*  as soon as any cell splits.                                               *
+*                                                                            *
+*****************************************************************************/
+
+void 
+cellfano2(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+          int *invar, int invararg, boolean digraph, int m, int n)
+{
+        int i,pc;
+        setword sw;
+        int wt;
+        int v0,v1,v2,v3,iv0,iv1,iv2,iv3;
+        int icell,bigcells,cell1,cell2;
+        int *cellstart,*cellsize;
+	int nw,x01,x02,x03,x12,x13,x23;
+	int pnt0,pnt1,pnt2;
+	set *gv0,*gv1,*gv2,*gv3;
+	set *gp0,*gp1,*gp2;
+
+#if !MAXN
+        DYNALLOC1(int,workshort,workshort_sz,n+2,"cellfano2");
+	DYNALLOC1(int,vv,vv_sz,n,"cellfano2");
+	DYNALLOC1(int,ww,ww_sz,n,"cellfano2");
+#endif
+
+        for (i = n; --i >= 0;) invar[i] = 0;
+
+        cellstart = workshort;
+        cellsize = workshort + (n/2);
+        getbigcells(ptn,level,4,&bigcells,cellstart,cellsize,n);
+
+        for (icell = 0; icell < bigcells; ++icell)
+        {
+            cell1 = cellstart[icell];
+            cell2 = cell1 + cellsize[icell] - 1;
+            for (iv0 = cell1; iv0 <= cell2 - 3; ++iv0)
+            {
+                v0 = lab[iv0];
+                gv0 = GRAPHROW(g,v0,m);
+		nw = 0;
+		for (iv1 = iv0 + 1; iv1 <= cell2; ++iv1)
+		{
+		    v1 = lab[iv1];
+                    if (ISELEMENT(gv0,v1)) continue;
+                    if ((x01 = uniqinter(gv0,GRAPHROW(g,v1,m),m)) < 0) continue;
+		    vv[nw] = v1;
+		    ww[nw] = x01;
+		    ++nw;
+		}	
+
+                for (iv1 = 0; iv1 < nw-2; ++iv1)
+                {
+                    v1 = vv[iv1];
+                    gv1 = GRAPHROW(g,v1,m);
+		    x01 = ww[iv1];
+
+                    for (iv2 = iv1 + 1; iv2 < nw-1; ++iv2)
+                    {
+			x02 = ww[iv2];
+			if (x02 == x01) continue;
+                        v2 = vv[iv2];
+			if (ISELEMENT(gv1,v2)) continue;
+                        gv2 = GRAPHROW(g,v2,m);
+			if ((x12 = uniqinter(gv1,gv2,m)) < 0) continue;
+
+                        for (iv3 = iv2 + 1; iv3 < nw; ++iv3)
+                        {
+			    x03 = ww[iv3];
+			    if (x03 == x01 || x03 == x02) continue;
+                            v3 = vv[iv3];
+			    if (ISELEMENT(gv1,v3) || ISELEMENT(gv2,v3))
+				continue;
+                            gv3 = GRAPHROW(g,v3,m);
+			    if ((x13 = uniqinter(gv1,gv3,m)) < 0) continue;
+			    if ((x23 = uniqinter(gv2,gv3,m)) < 0
+                                                   || x23 == x13) continue;
+
+			    if ((pnt0 = uniqinter(GRAPHROW(g,x01,m),
+						 GRAPHROW(g,x23,m),m)) < 0)
+				continue;
+			    if ((pnt1 = uniqinter(GRAPHROW(g,x02,m),
+                                                 GRAPHROW(g,x13,m),m)) < 0)
+                                continue;
+                            if ((pnt2 = uniqinter(GRAPHROW(g,x03,m),
+                                                 GRAPHROW(g,x12,m),m)) < 0)
+                                continue;
+
+			    gp0 = GRAPHROW(g,pnt0,m);
+			    gp1 = GRAPHROW(g,pnt1,m);
+			    gp2 = GRAPHROW(g,pnt2,m);
+
+			    pc = 0;
+			    for (i = M; --i >= 0;)
+			    {
+				sw = gp0[i] & gp1[i] & gp2[i];
+				if (sw) pc += POPCOUNT(sw);
+			    }
+			    wt = FUZZ1(pc);
+			    ACCUM(invar[v0],wt);
+			    ACCUM(invar[v1],wt);
+                            ACCUM(invar[v2],wt);
+                            ACCUM(invar[v3],wt);
+                        }
+                    }
+                }
+            }
+            wt = invar[lab[cell1]];
+            for (i = cell1 + 1; i <= cell2; ++i)
+                if (invar[lab[i]] != wt) return;
+        }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  setnbhd(g,m,n,w,wn) is an auxiliary routine that sets wn to the union     *
+*  of the neighbours of the vertices in w.                                   *
+*                                                                            *
+*****************************************************************************/
+
+void
+setnbhd(graph *g, int m, int n, set *w, set *wn)
+{
+	int i,j;
+	set *gi;
+
+	i = nextelement(w,M,-1);
+	if (i < 0)
+	{
+	    EMPTYSET(wn,M);
+	    return;
+	}
+
+	gi = GRAPHROW(g,i,M);
+	for (j = M; --j >= 0;) wn[j] = gi[j];
+
+	while ((i = nextelement(w,M,i)) >= 0)
+	{
+	    gi = GRAPHROW(g,i,M);
+            for (j = M; --j >= 0;) wn[j] |= gi[j];
+	}
+}    
+
+/*****************************************************************************
+*                                                                            *
+*  cellfano() assigns to each vertex v a value depending on the set of       *
+*  weights w(v,v1,v2,v3), where w(v,v1,v2,v3) depends on the number of       *
+*  fano-plane analogues containing {v,v1,v2,v3}.  {v,v1,v2,v3} are           *
+*  constrained to belong to the same cell and being independent.  We try     *
+*  the cells in increasing order of size, and stop as soon as any cell       *
+*  splits.                                                                   *
+*                                                                            *
+*****************************************************************************/
+
+void 
+cellfano(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+         int *invar, int invararg, boolean digraph, int m, int n)
+{
+        int i,pc;
+        setword sw;
+        int wt;
+        int v0,v1,v2,v3,iv0,iv1,iv2,iv3;
+        int icell,bigcells,cell1,cell2;
+        int *cellstart,*cellsize;
+	set *gv0,*gv1,*gv2,*gv3;
+
+#if !MAXN
+        DYNALLOC1(int,workshort,workshort_sz,n+2,"cellfano");
+	DYNALLOC1(set,w01,w01_sz,m,"cellfano");
+	DYNALLOC1(set,w02,w02_sz,m,"cellfano");
+	DYNALLOC1(set,w03,w03_sz,m,"cellfano");
+	DYNALLOC1(set,w12,w12_sz,m,"cellfano");
+	DYNALLOC1(set,w13,w13_sz,m,"cellfano");
+	DYNALLOC1(set,w23,w23_sz,m,"cellfano");
+	DYNALLOC1(set,pt0,pt0_sz,m,"cellfano");
+	DYNALLOC1(set,pt1,pt1_sz,m,"cellfano");
+	DYNALLOC1(set,pt2,pt2_sz,m,"cellfano");
+	DYNALLOC1(set,workset,workset_sz,m,"cellfano");
+#else
+#endif
+
+        for (i = n; --i >= 0;) invar[i] = 0;
+
+        cellstart = workshort;
+        cellsize = workshort + (n/2);
+        getbigcells(ptn,level,4,&bigcells,cellstart,cellsize,n);
+
+        for (icell = 0; icell < bigcells; ++icell)
+        {
+            cell1 = cellstart[icell];
+            cell2 = cell1 + cellsize[icell] - 1;
+            for (iv0 = cell1; iv0 <= cell2 - 3; ++iv0)
+            {
+                v0 = lab[iv0];
+                gv0 = GRAPHROW(g,v0,m);
+                for (iv1 = iv0 + 1; iv1 <= cell2 - 2; ++iv1)
+                {
+                    v1 = lab[iv1];
+		    if (ISELEMENT(gv0,v1)) continue;
+                    gv1 = GRAPHROW(g,v1,m);
+                    for (i = M; --i >= 0;) workset[i] = gv0[i] & gv1[i];
+		    setnbhd(g,m,n,workset,w01);
+
+                    for (iv2 = iv1 + 1; iv2 <= cell2 - 1; ++iv2)
+                    {
+                        v2 = lab[iv2];
+			if (ISELEMENT(gv0,v2) || ISELEMENT(gv1,v2))
+			    continue;
+                        gv2 = GRAPHROW(g,v2,m);
+			for (i = M; --i >= 0;) workset[i] = gv0[i] & gv2[i];
+                        setnbhd(g,m,n,workset,w02);
+                        for (i = M; --i >= 0;) workset[i] = gv1[i] & gv2[i];
+                        setnbhd(g,m,n,workset,w12);
+
+                        for (iv3 = iv2 + 1; iv3 <= cell2; ++iv3)
+                        {
+                            v3 = lab[iv3];
+			    if (ISELEMENT(gv0,v3) || ISELEMENT(gv1,v3) ||
+					ISELEMENT(gv2,v3))
+				continue;
+                            gv3 = GRAPHROW(g,v3,m);
+                            for (i = M; --i >= 0;) workset[i] = gv0[i] & gv3[i];
+                            setnbhd(g,m,n,workset,w03);
+                            for (i = M; --i >= 0;) workset[i] = gv1[i] & gv3[i];
+                            setnbhd(g,m,n,workset,w13);
+                            for (i = M; --i >= 0;) workset[i] = gv2[i] & gv3[i];
+                            setnbhd(g,m,n,workset,w23);
+			
+			    for (i = M; --i >= 0;) workset[i] = w01[i] & w23[i];
+			    setnbhd(g,m,n,workset,pt0);
+                            for (i = M; --i >= 0;) workset[i] = w03[i] & w12[i];
+                            setnbhd(g,m,n,workset,pt1);
+                            for (i = M; --i >= 0;) workset[i] = w02[i] & w13[i];
+                            setnbhd(g,m,n,workset,pt2);
+			    pc = 0;
+			    for (i = M; --i >= 0;)
+			    {
+				sw = pt0[i] & pt1[i] & pt2[i];
+				if (sw) pc += POPCOUNT(sw);
+			    }
+			    wt = FUZZ1(pc);
+			    ACCUM(invar[v0],wt);
+			    ACCUM(invar[v1],wt);
+                            ACCUM(invar[v2],wt);
+                            ACCUM(invar[v3],wt);
+                        }
+                    }
+                }
+            }
+            wt = invar[lab[cell1]];
+            for (i = cell1 + 1; i <= cell2; ++i)
+                if (invar[lab[i]] != wt) return;
+        }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  distances() assigns to each vertex v a value depending on the number of   *
+*  vertices at each distance from v, and what cells they lie in.             *
+*  If we find any cell which is split in this manner, we don't try any       *
+*  further cells.                                                            *
+*                                                                            *
+*****************************************************************************/
+
+void
+distances(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+          int *invar, int invararg, boolean digraph, int m, int n)
+{
+        int i;
+        set *gw;
+        int wt;
+        int d,dlim,cell1,cell2,iv,v,w;
+        boolean success;
+
+#if !MAXN
+        DYNALLOC1(set,workset,workset_sz,m,"distances");
+        DYNALLOC1(int,workshort,workshort_sz,n+2,"distances");
+	DYNALLOC1(set,ws1,ws1_sz,m,"distances");
+	DYNALLOC1(set,ws2,ws2_sz,m,"distances"); 
+#endif
+
+        for (i = n; --i >= 0;) invar[i] = 0;
+
+        wt = 1;
+        for (i = 0; i < n; ++i)
+        {
+            workshort[lab[i]] = FUZZ1(wt);
+            if (ptn[i] <= level) ++wt;
+        }
+
+	if (invararg > n || invararg == 0) dlim = n;
+	else                               dlim = invararg+1;
+
+        success = FALSE;
+        for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+        {
+            for (cell2 = cell1; ptn[cell2] > level; ++cell2) {}
+            if (cell2 == cell1) continue;
+
+            for (iv = cell1; iv <= cell2; ++iv)
+            {
+                v = lab[iv];
+                EMPTYSET(ws1,m);
+                ADDELEMENT(ws1,v);
+                EMPTYSET(ws2,m);
+                ADDELEMENT(ws2,v);
+                for (d = 1; d < dlim; ++d)
+                {
+                    EMPTYSET(workset,m);
+                    wt = 0;
+                    w = -1;
+                    while ((w = nextelement(ws2,M,w)) >= 0)
+                    {
+                        gw = GRAPHROW(g,w,m);
+                        ACCUM(wt,workshort[w]);
+                        for (i = M; --i >= 0;) workset[i] |= gw[i];
+                    }
+                    if (wt == 0) break;
+                    ACCUM(wt,d);
+                    wt = FUZZ2(wt);
+                    ACCUM(invar[v],wt);
+                    for (i = M; --i >= 0;)
+                    {
+                        ws2[i] = workset[i] & ~ws1[i];
+                        ws1[i] |= ws2[i];
+                    }
+                }
+                if (invar[v] != invar[lab[cell1]]) success = TRUE;
+            }
+            if (success) break;
+        }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  indsets() assigns to each vertex v a value depending on which cells the   *
+*  vertices which join v in an independent set lie in.  The size of the      *
+*  independent sets which are used is the smallest of invararg and MAXCLIQUE.*
+*                                                                            *
+*****************************************************************************/
+
+void
+indsets(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+        int *invar, int invararg, boolean digraph, int m, int n)
+{
+        int i;
+        int wt;
+        set *gv;
+        int ss,setsize;
+        int v[MAXCLIQUE];
+        long wv[MAXCLIQUE];
+        set *s0,*s1;
+
+#if !MAXN
+        DYNALLOC1(int,workshort,workshort_sz,n+2,"indsets");
+	DYNALLOC2(set,wss,wss_sz,m,MAXCLIQUE-1,"indsets");
+#endif
+
+        for (i = n; --i >= 0;) invar[i] = 0;
+
+        if (invararg <= 1 || digraph) return;
+
+        if (invararg > MAXCLIQUE) setsize = MAXCLIQUE;
+        else                      setsize = invararg;
+
+        wt = 1;
+        for (i = 0; i < n; ++i)
+        {
+            workshort[lab[i]] = FUZZ2(wt);
+            if (ptn[i] <= level) ++wt;
+        }
+
+        for (v[0] = 0; v[0] < n; ++v[0])
+        {
+            wv[0] = workshort[v[0]];
+            s0 = (set*)wss;
+            EMPTYSET(s0,m);
+            for (i = v[0]+1; i < n; ++i) ADDELEMENT(s0,i);
+            gv = GRAPHROW(g,v[0],m);
+            for (i = M; --i >= 0;) s0[i] &= ~gv[i];
+            ss = 1;
+            v[1] = v[0];
+            while (ss > 0)
+            {
+                if (ss == setsize)
+                {
+                    wt = FUZZ1(wv[ss-1]);
+                    for (i = ss; --i >= 0;) ACCUM(invar[v[i]],wt);
+                    --ss;
+                }
+                else if ((v[ss] = nextelement((set*)wss+M*(ss-1),M,v[ss])) < 0)
+                    --ss;
+                else
+                {
+                    wv[ss] = wv[ss-1] + workshort[v[ss]];
+                    ++ss;
+                    if (ss < setsize)
+                    {
+                        gv = GRAPHROW(g,v[ss-1],m);
+			s1 = (set*)wss + M*(ss-2);
+                        for (i = M; --i >= 0;) s1[i+M] = s1[i] & ~gv[i];
+                        v[ss] = v[ss-1];
+                    }
+                }
+            }
+        }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  cliques() assigns to each vertex v a value depending on which cells the   *
+*  vertices which join v in a clique lie in.  The size of the cliques used   *
+*  is the smallest of invararg and MAXCLIQUE.                                *
+*                                                                            *
+*****************************************************************************/
+
+void
+cliques(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+        int *invar, int invararg, boolean digraph, int m, int n)
+{
+        int i;
+        int wt;
+        set *gv;
+        int ss,setsize;
+        int v[MAXCLIQUE];
+        long wv[MAXCLIQUE];
+	set *ns;
+
+#if !MAXN
+        DYNALLOC1(int,workshort,workshort_sz,n+2,"cliques");
+	DYNALLOC2(set,wss,wss_sz,m,MAXCLIQUE-1,"cliques");
+#else
+	set wss[MAXCLIQUE-1][MAXM];
+#endif
+
+        for (i = n; --i >= 0;) invar[i] = 0;
+
+        if (invararg <= 1 || digraph) return;
+
+        if (invararg > MAXCLIQUE) setsize = MAXCLIQUE;
+        else                      setsize = invararg;
+
+        wt = 1;
+        for (i = 0; i < n; ++i)
+        {
+            workshort[lab[i]] = FUZZ2(wt);
+            if (ptn[i] <= level) ++wt;
+        }
+
+        for (v[0] = 0; v[0] < n; ++v[0])
+        {
+            wv[0] = workshort[v[0]];
+            gv = GRAPHROW(g,v[0],m);
+	    ns = (set*)wss;
+            for (i = M; --i >= 0;) ns[i] = gv[i];
+            ss = 1;
+            v[1] = v[0];
+            while (ss > 0)
+            {
+                if (ss == setsize)
+                {
+                    wt = FUZZ1(wv[ss-1]);
+                    for (i = ss; --i >= 0;) ACCUM(invar[v[i]],wt);
+                    --ss;
+                }
+                else if ((v[ss] = nextelement((set*)wss+M*(ss-1),M,v[ss])) < 0)
+                    --ss;
+                else
+                {
+                    wv[ss] = wv[ss-1] + workshort[v[ss]];
+                    ++ss;
+                    if (ss < setsize)
+                    {
+                        gv = GRAPHROW(g,v[ss-1],m);
+			ns = (set*)wss + M*(ss-2);
+                        for (i = M; --i >= 0;) ns[i+M] = ns[i] & gv[i];
+                        v[ss] = v[ss-1];
+                    }
+                }
+            }
+        }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  cellcliq() assigns to each vertex v a value depending on the number of    *
+*  cliques which v lies in and which lie in the same cell as v.  The size    *
+*  of clique counted is the smallest of invararg and MAXCLIQUE.  We try the  *
+*  cells in increasing order of size and stop as soon as any cell splits.    *
+*                                                                            *
+*****************************************************************************/
+
+void
+cellcliq(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+         int *invar, int invararg, boolean digraph, int m, int n)
+{
+        int i;
+        int wt;
+        set *gv;
+        int ss,setsize;
+        int v[MAXCLIQUE];
+        set *ns;
+        int *cellstart,*cellsize;
+        int iv,icell,bigcells,cell1,cell2;
+        int pc;
+        setword sw;
+
+#if !MAXN
+        DYNALLOC1(set,workset,workset_sz,m,"cellcliq");
+        DYNALLOC1(int,workshort,workshort_sz,n+2,"cellcliq");
+	DYNALLOC2(set,wss,wss_sz,m,MAXCLIQUE-1,"cellcliq");
+#endif
+
+        for (i = n; --i >= 0;) invar[i] = 0;
+
+        if (invararg <= 1 || digraph) return;
+
+        if (invararg > MAXCLIQUE) setsize = MAXCLIQUE;
+        else                      setsize = invararg;
+
+        cellstart = workshort;
+        cellsize = workshort + (n/2);
+        getbigcells(ptn,level,setsize > 6 ? setsize : 6,&bigcells,
+                    cellstart,cellsize,n);
+
+        for (icell = 0; icell < bigcells; ++icell)
+        {
+            cell1 = cellstart[icell];
+            cell2 = cell1 + cellsize[icell] - 1;
+
+            EMPTYSET(workset,m);
+            for (iv = cell1; iv <= cell2; ++iv) ADDELEMENT(workset,lab[iv]);
+
+            for (iv = cell1; iv <= cell2; ++iv)
+            {
+                v[0] = lab[iv];
+                gv = GRAPHROW(g,v[0],m);
+		ns = (set*)wss;
+                pc = 0;
+
+                for (i = M; --i >= 0;)
+                {
+                    ns[i] = gv[i] & workset[i];
+                    if ((sw = ns[i]) != 0) pc += POPCOUNT(sw);
+                }
+                if (pc <= 1 || pc >= cellsize[icell] - 2) continue;
+
+                ss = 1;
+                v[1] = v[0];
+                while (ss > 0)
+                {
+                    if (ss == setsize)
+                    {
+                        for (i = ss; --i >= 0;) ++invar[v[i]];
+                        --ss;
+                    }
+                    else if ((v[ss] 
+				= nextelement((set*)wss+M*(ss-1),M,v[ss])) < 0)
+                        --ss;
+                    else
+                    {
+                        ++ss;
+                        if (ss < setsize)
+                        {
+                            gv = GRAPHROW(g,v[ss-1],m);
+			    ns = (set*)wss + M*(ss-2);
+                            for (i = M; --i >= 0;) ns[i+M] = ns[i] & gv[i];
+                            v[ss] = v[ss-1];
+                        }
+                    }
+                }
+            }
+            wt = invar[lab[cell1]];
+            for (iv = cell1 + 1; iv <= cell2; ++iv)
+                if (invar[lab[iv]] != wt) return;
+        }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  cellind() assigns to each vertex v a value depending on the number of     *
+*  independent sets which v lies in and which lie in the same cell as v.     *
+*  The size of clique counted is the smallest of invararg and MAXCLIQUE.     *
+*  We try the cells in increasing order of size and stop as soon as any      *
+*  cell splits.                                                              *
+*                                                                            *
+*****************************************************************************/
+
+void
+cellind(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+        int *invar, int invararg, boolean digraph, int m, int n)
+{
+        int i;
+        int wt;
+        set *gv;
+        int ss,setsize;
+        int v[MAXCLIQUE];
+        set *ns;
+        int *cellstart,*cellsize;
+        int iv,icell,bigcells,cell1,cell2;
+        int pc;
+        setword sw;
+
+#if !MAXN
+        DYNALLOC1(set,workset,workset_sz,m,"cellind");
+        DYNALLOC1(int,workshort,workshort_sz,n+2,"cellind");
+	DYNALLOC2(set,wss,wss_sz,m,MAXCLIQUE-1,"cellind");
+#endif
+
+        for (i = n; --i >= 0;) invar[i] = 0;
+
+        if (invararg <= 1 || digraph) return;
+
+        if (invararg > MAXCLIQUE) setsize = MAXCLIQUE;
+        else                      setsize = invararg;
+
+        cellstart = workshort;
+        cellsize = workshort + (n/2);
+        getbigcells(ptn,level,setsize > 6 ? setsize : 6,&bigcells,
+                    cellstart,cellsize,n);
+
+        for (icell = 0; icell < bigcells; ++icell)
+        {
+            cell1 = cellstart[icell];
+            cell2 = cell1 + cellsize[icell] - 1;
+
+            EMPTYSET(workset,m);
+            for (iv = cell1; iv <= cell2; ++iv) ADDELEMENT(workset,lab[iv]);
+
+            for (iv = cell1; iv <= cell2; ++iv)
+            {
+                v[0] = lab[iv];
+                gv = GRAPHROW(g,v[0],m);
+	 	ns = (set*)wss;
+                pc = 0;
+
+                for (i = M; --i >= 0;)
+                {
+                    ns[i] = ~gv[i] & workset[i];
+                    if ((sw = ns[i]) != 0) pc += POPCOUNT(sw);
+                }
+                if (pc <= 1 || pc >= cellsize[icell] - 2) continue;
+
+                ss = 1;
+                v[1] = v[0];
+                while (ss > 0)
+                {
+                    if (ss == setsize)
+                    {
+                        for (i = ss; --i >= 0;) ++invar[v[i]];
+                        --ss;
+                    }
+                    else if ((v[ss] 
+			   = nextelement((set*)wss+M*(ss-1),M,v[ss])) < 0)
+                        --ss;
+                    else
+                    {
+                        ++ss;
+                        if (ss < setsize)
+                        {
+                            gv = GRAPHROW(g,v[ss-1],m);
+			    ns = (set*)wss + M*(ss-2);
+                            for (i = M; --i >= 0;) ns[i+M] = ns[i] & ~gv[i];
+                            v[ss] = v[ss-1];
+                        }
+                    }
+                }
+            }
+            wt = invar[lab[cell1]];
+            for (iv = cell1 + 1; iv <= cell2; ++iv)
+                if (invar[lab[iv]] != wt) return;
+        }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  adjacencies() assigns to each vertex v a code depending on which cells    *
+*  it is joined to and from, and how many times.  It is intended to provide  *
+*  better partitioning that the normal refinement routine for digraphs.      *
+*  It will not help with undirected graphs in nauty at all.                  *
+*                                                                            *
+*****************************************************************************/
+
+void
+adjacencies(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+            int *invar, int invararg, boolean digraph, int m, int n)
+{
+        int i,v,w;
+        int vwt,wwt;
+        set *gv;
+
+#if !MAXN
+        DYNALLOC1(int,workshort,workshort_sz,n+2,"adjacencies");
+#endif
+
+        vwt = 1;
+        for (i = 0; i < n; ++i)
+        {
+            workshort[lab[i]] = vwt;
+            if (ptn[i] <= level) ++vwt;
+            invar[i] = 0;
+        }
+
+        for (v = 0, gv = (set*)g; v < n; ++v, gv += M)
+        {
+            vwt = FUZZ1(workshort[v]);
+            wwt = 0;
+            w = -1;
+            while ((w = nextelement(gv,M,w)) >= 0)
+            {
+                ACCUM(wwt,FUZZ2(workshort[w]));
+                ACCUM(invar[w],vwt);
+            }
+            ACCUM(invar[v],wwt);
+        }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  nautinv_check() checks that this file is compiled compatibly with the     *
+*  given parameters.   If not, call exit(1).                                 *
+*                                                                            *
+*****************************************************************************/
+
+void
+nautinv_check(int wordsize, int m, int n, int version)
+{
+        if (wordsize != WORDSIZE)
+        {
+            fprintf(ERRFILE,"Error: WORDSIZE mismatch in nautinv.c\n");
+            exit(1);
+        }
+
+#if MAXN
+        if (m > MAXM)
+        {
+            fprintf(ERRFILE,"Error: MAXM inadequate in nautinv.c\n");
+            exit(1);
+        }
+
+        if (n > MAXN)
+        {
+            fprintf(ERRFILE,"Error: MAXN inadequate in nautinv.c\n");
+            exit(1);
+        }
+#endif
+
+        if (version < NAUTYREQUIRED)
+        {
+            fprintf(ERRFILE,"Error: nautinv.c version mismatch\n");
+            exit(1);
+        }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  nautinv_freedyn() - free the dynamic memory in this module                *
+*                                                                            *
+*****************************************************************************/
+ 
+void
+nautinv_freedyn(void)
+{
+#if !MAXN
+	DYNFREE(workset,workset_sz);
+	DYNFREE(workshort,workshort_sz);
+	DYNFREE(ws1,ws1_sz);
+	DYNFREE(ws2,ws2_sz);
+	DYNFREE(vv,vv_sz);
+	DYNFREE(ww,ww_sz);
+	DYNFREE(w01,w01_sz);
+	DYNFREE(w02,w02_sz);
+	DYNFREE(w03,w03_sz);
+	DYNFREE(w12,w12_sz);
+	DYNFREE(w13,w13_sz);
+	DYNFREE(w23,w23_sz);
+	DYNFREE(pt0,pt0_sz);
+	DYNFREE(pt1,pt1_sz);
+	DYNFREE(pt2,pt2_sz);
+	DYNFREE(wss,wss_sz);
+#endif
+}
+
+/*===================================================================*/
+
+
+/*****************************************************************************
+*                                                                            *
+*  semirefine(g,lab,ptn,level,numcells,strength,active,m,n) performs a       *
+*  refinement operation on the partition at the specified level of the       *
+*  partition nest (lab,ptn).  *numcells is assumed to contain the number of  *
+*  cells on input, and is updated.  The initial set of active cells (alpha   *
+*  in the paper) is specified in the set active.  Precisely, x is in active  *
+*  iff the cell starting at index x in lab is active.                        *
+*  *code is set to a value which depends on the fine detail of the           *
+*  algorithm, but which is independent of the labelling of the graph.        *
+*                                                                            *
+*****************************************************************************/
+
+static int
+semirefine(graph *g, int *lab, int *ptn, int level, int *numcells,
+           int strength, set *active, int m, int n)
+{
+	int i,c1,c2,labc1;
+	setword x;
+	set *set1,*set2;
+	int split1,split2,cell1,cell2;
+	int cnt,bmin,bmax;
+	long longcode;
+	set *gptr;
+	int maxcell,maxpos,hint;
+
+#if !MAXN
+	DYNALLOC1(int,workperm,workperm_sz,n,"refine");
+	DYNALLOC1(set,workset,workset_sz,m,"refine");
+	DYNALLOC1(int,bucket,bucket_sz,n+2,"refine");
+	DYNALLOC1(int,count,count_sz,n,"refine");
+#endif
+
+	longcode = *numcells;
+	split1 = -1;
+	hint = 0;
+	while (*numcells < n && ((split1 = hint, ISELEMENT(active,split1))
+                             || (split1 = nextelement(active,M,split1)) >= 0
+	                     || (split1 = nextelement(active,M,-1)) >= 0))
+	{
+	    DELELEMENT(active,split1);
+	    for (split2 = split1; ptn[split2] > level; ++split2) {}
+	    longcode = MASH(longcode,split1+split2);
+	    if (split1 == split2)       /* trivial splitting cell */
+	    {
+	        gptr = GRAPHROW(g,lab[split1],M);
+	        for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+	        {
+	            for (cell2 = cell1; ptn[cell2] > level; ++cell2) {}
+	            if (cell1 == cell2) continue;
+	            c1 = cell1;
+	            c2 = cell2;
+	            while (c1 <= c2)
+	            {
+	                labc1 = lab[c1];
+	                if (ISELEMENT(gptr,labc1))
+	                    ++c1;
+	                else
+	                {
+	                    lab[c1] = lab[c2];
+	                    lab[c2] = labc1;
+	                    --c2;
+	                }
+	            }
+	            if (c2 >= cell1 && c1 <= cell2)
+	            {
+	                ptn[c2] = level;
+	                longcode = MASH(longcode,FUZZ1(c2));
+	                ++*numcells;
+			if (ISELEMENT(active,cell1) || c2-cell1 >= cell2-c1)
+			{
+     			    ADDELEMENT(active,c1);
+			    if (c1 == cell2) hint = c1;
+			}
+			else
+			{
+     			    ADDELEMENT(active,cell1);
+			    if (c2 == cell1) hint = cell1;
+			}
+	            }
+	        }
+	    }
+	    else        /* nontrivial splitting cell */
+	    {
+	        EMPTYSET(workset,m);
+	        for (i = split1; i <= split2; ++i)
+	            ADDELEMENT(workset,lab[i]);
+	        longcode = MASH(longcode,FUZZ2(split2-split1+1));
+
+	        for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+	        {
+	            for (cell2 = cell1; ptn[cell2] > level; ++cell2) {}
+	            if (cell1 == cell2) continue;
+	            i = cell1;
+	            set1 = workset;
+	            set2 = GRAPHROW(g,lab[i],m);
+	            cnt = 0;
+	            for (c1 = m; --c1 >= 0;)
+	                if ((x = ((*set1++) & (*set2++))) != 0)
+	                    cnt += POPCOUNT(x);
+
+	            count[i] = bmin = bmax = cnt;
+	            bucket[cnt] = 1;
+	            while (++i <= cell2)
+	            {
+	                set1 = workset;
+	                set2 = GRAPHROW(g,lab[i],m);
+	                cnt = 0;
+	                for (c1 = m; --c1 >= 0;)
+	                    if ((x = ((*set1++) & (*set2++))) != 0)
+	                        cnt += POPCOUNT(x);
+
+	                while (bmin > cnt) bucket[--bmin] = 0;
+	                while (bmax < cnt) bucket[++bmax] = 0;
+	                ++bucket[cnt];
+	                count[i] = cnt;
+	            }
+	            if (bmin == bmax)
+	            {
+	                longcode = MASH(longcode,FUZZ1(bmin+cell1));
+	                continue;
+	            }
+	            c1 = cell1;
+		    maxcell = -1;
+	            for (i = bmin; i <= bmax; ++i)
+	                if (bucket[i])
+	                {
+	                    c2 = c1 + bucket[i];
+	                    bucket[i] = c1;
+	                    longcode = MASH(longcode,i+c1);
+			    if (c2-c1 > maxcell)
+			    {
+				maxcell = c2-c1;
+				maxpos = c1;
+			    }
+	                    if (c1 != cell1)
+	                    {
+	                        ADDELEMENT(active,c1);
+			        if (c2-c1 == 1) hint = c1;
+	                        ++*numcells;
+	                    }
+	                    if (c2 <= cell2) ptn[c2-1] = level;
+	                    c1 = c2;
+	                }
+	            for (i = cell1; i <= cell2; ++i)
+	                workperm[bucket[count[i]]++] = lab[i];
+	            for (i = cell1; i <= cell2; ++i) lab[i] = workperm[i];
+		    if (!ISELEMENT(active,cell1))
+		    {
+     			ADDELEMENT(active,cell1);
+     			DELELEMENT(active,maxpos);     /* check maxpos is alwas defined */
+		    }
+	        }
+	    }
+	    if (--strength == 0) break;   /* negative is fine! */
+	}
+
+	longcode = MASH(longcode,FUZZ2(*numcells));
+	return CLEANUP(longcode);
+}
+
+void 
+refinvar(graph *g, int *lab, int *ptn, int level, int numcells, int tvpos,
+          int *invar, int invararg, boolean digraph, int m, int n)
+{
+        int i,j;
+        int wt;
+        int icell,bigcells,cell1,cell2;
+        int *cellstart,*cellsize;
+	int newnumcells;
+
+#if !MAXN
+        DYNALLOC1(int,workshort,workshort_sz,n+2,"refinvar");
+        DYNALLOC1(int,vv,vv_sz,n,"refinvar");
+        DYNALLOC1(int,ww,ww_sz,n,"refinvar");
+        DYNALLOC1(set,ws1,ws1_sz,n,"refinvar");
+#endif
+
+        for (i = n; --i >= 0;) invar[i] = 0;
+
+        cellstart = workshort;
+        cellsize = workshort + (n/2);
+        getbigcells(ptn,level,2,&bigcells,cellstart,cellsize,n);
+
+        for (icell = 0; icell < bigcells; ++icell)
+        {
+            cell1 = cellstart[icell];
+            cell2 = cell1 + cellsize[icell] - 1;
+            for (i = cell1; i <= cell2; ++i)
+            {
+		for (j = 0; j < n; ++j)
+		{
+		    vv[j] = lab[j];
+		    ww[j] = ptn[j];
+		}
+		newnumcells = numcells + 1;
+		ww[cell1] = level;
+		EMPTYSET(ws1,m);
+		ADDELEMENT(ws1,cell1);
+		vv[i] = lab[cell1];
+		vv[cell1] = lab[i];
+		invar[lab[i]] = semirefine(g,vv,ww,level,&newnumcells,
+						invararg,ws1,m,n);
+            }
+            wt = invar[lab[cell1]];
+            for (i = cell1 + 1; i <= cell2; ++i)
+                if (invar[lab[i]] != wt) return;
+        }
+}
diff --git a/lib/nauty/nautinv.h b/lib/nauty/nautinv.h
new file mode 100644
index 0000000..738d8c2
--- /dev/null
+++ b/lib/nauty/nautinv.h
@@ -0,0 +1,42 @@
+/*****************************************************************************
+* This is the header file for versions 2.5 of nautinv.c.                     *
+*                                                                            *
+*   Copyright (1984-2013) Brendan McKay.  All rights reserved.               *
+*   Subject to the waivers and disclaimers in nauty.h.                       *
+*                                                                            *
+*   CHANGE HISTORY                                                           *
+*       20-Apr-01 : initial creation out of naututil.h                       *
+*       10-Nov-10 : remove types shortish and permutation                    *
+*                                                                            *
+*****************************************************************************/
+
+#include "nauty.h"              /* which includes stdio.h */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void adjacencies(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+extern void adjtriang(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+extern void cellcliq(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+extern void cellfano(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+extern void cellfano2(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+extern void cellind(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+extern void cellquads(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+extern void cellquins(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+extern void celltrips(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+extern void cellstarts(int*,int,set*,int,int);
+extern void cliques(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+extern void distances(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+extern void getbigcells(int*,int,int,int*,int*,int*,int);
+extern void indsets(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+extern void nautinv_check(int,int,int,int);
+extern void nautinv_freedyn(void);
+extern void quadruples(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+extern void refinvar(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+extern void setnbhd(graph*,int,int,set*,set*);
+extern void triples(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+extern void twopaths(graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/nauty/naututil-h.in b/lib/nauty/naututil-h.in
new file mode 100644
index 0000000..1879604
--- /dev/null
+++ b/lib/nauty/naututil-h.in
@@ -0,0 +1,289 @@
+/*****************************************************************************
+* This is the header file for versions 2.6 of naututil.c and dreadnaut.c.    *
+* @configure_input@
+*****************************************************************************/
+
+/* The parts between the ==== lines are modified by configure when
+creating naututil.h out of naututil-h.in.  If configure is not being
+used, it is necessary to check they are correct.
+====================================================================*/
+
+/* Check whether various headers are available */
+
+#define HAVE_ISATTY  @have_isatty@     /* if isatty() is available */
+#define HAVE_TIMES  @have_times@      /* if times() is available */
+#define HAVE_TIME  @have_time@      /* if time() is available */
+#define HAVE_GETRUSAGE @have_getrusage@  /* if getrusage() is available */
+#define HAVE_GETTIMEOFDAY  @have_gettimeofday@  /* if gettimeofday() */
+
+/*==================================================================*/
+
+/*****************************************************************************
+*                                                                            *
+*   Copyright (1984-2016) Brendan McKay.  All rights reserved.               *
+*   Subject to the waivers and disclaimers in nauty.h.                       *
+*                                                                            *
+*   CHANGE HISTORY                                                           *
+*       10-Nov-87 : final changes for version 1.2                            *
+*        5-Dec-87 : changes for version 1.3 :                                *
+*                   - added declarations of readinteger() and readstring()   *
+*                   - added definition of DEFEXT : default file-name         *
+*                     extension for dreadnaut input files                    *
+*       28-Sep-88 : changes for version 1.4 :                                *
+*                   - added support for PC Turbo C                           *
+*       29-Nov-88 : - added getc macro for AZTEC C on MAC                    *
+*       23-Mar-89 : changes for version 1.5 :                                *
+*                   - added DREADVERSION macro                               *
+*                   - added optional ANSI function prototypes                *
+*                   - changed file name to naututil.h                        *
+*                   - moved ALLOCS to nauty.h and defined DYNALLOC           *
+*       25-Mar-89 : - added declaration of twopaths()                        *
+*       29-Mar-89 : - added declaration of putmapping()                      *
+*        4-Apr-89 : - added declarations of triples, quadruples, adjtriang   *
+*                   - only define ERRFILE if not in nauty.h                  *
+*       25-Apr-89 : - added declarations of cellquads,distances,getbigcells  *
+*       26-Apr-89 : - added declarations of indsets,cliques,cellquins        *
+*                   - removed declarations of ptncode and equitable          *
+*       27-Apr-89 : - added declaration of putquotient                       *
+*       18-Aug-89 : - added new arg to putset, and changed mathon            *
+*        2-Mar-90 : - added declarations of celltrips, cellcliq, cellind     *
+*                   - changed declarations to use EXTPROC                    *
+*       12-Mar-90 : - added changes for Cray version                         *
+*       20-Mar-90 : - added changes for THINK version                        *
+*       27-Mar-90 : - split SYS_MSDOS into SYS_PCMS4 and SYS_PCMS5           *
+*       13-Oct-90 : changes for version 1.6 :                                *
+*                   - changed CPUTIME to use HZ on Unix for times()          *
+*       14-Oct-90 : - added SYS_APOLLO variant                               *
+*       19-Oct-90 : - changed CPUTIME defs for BSDUNIX to avoid conficting   *
+*                     declarations of size_t and ptrdiff_t in gcc            *
+*       27-Aug-92 : changes for version 1.7 :                                *
+*                   - added SYS_IBMC variant                                 *
+*                   - removed workaround for bad gcc installation            *
+*        5-Jun-93 : changes for version 1.8 :                                *
+*                   - changed CRAY version of CPUTIME to use CLK_TCK         *
+*                     if HZ could not be found (making 1.7+)                 *
+*       30-Jul-93 : - added SYS_ALPHA variant                                *
+*       17-Sep-93 : changes for version 1.9 :                                *
+*                   - declared adjacencies()                                 *
+*       24-Feb-94 : changes for version 1.10 :                               *
+*                   - added version SYS_AMIGAAZT (making 1.9+)               *
+*       19-Apr-95 : - added C++ prototype wrapper                            *
+*        6-Mar-96 : - added SYS_ALPHA32 code                                 *
+*       23-Jul-96 : changes for version 2.0 :                                *
+*                   - changed readstring() declaration                       *
+*                   - removed DYNALLOC definition                            *
+*                   - added sublabel() definition                            *
+*       15-Aug-96 : - added sethash() definition                             *
+*       30-Aug-96 : - added KRAN and D. Knuth routines                       *
+*       16-Sep-96 : - fixed the above!                                       *
+*        7-Feb-96 : - declared nautinv_null() and setnbhd()                  *
+*        4-Sep-97 : - arg of time() is type time_t*, was long*               *
+*       22-Sep-97 : - defined fileno() and time_t for SYS_PCTURBO            *
+*       10-Dec-97 : - revised KRAN for new rng.c from Knuth                  *
+*       18-Feb-98 : - changed time() to time_t for Unix                      *
+*       21-Oct-98 : - changed short to shortish as needed                    *
+*        9-Jan-00 : - declared nautinv_check() and naututil_check()          *
+*       16-Nov-00 : - applied changes logged in nauty.h                      *
+*       22-Apr-01 : changes for version 2.1 :                                *
+*                   - prototypes for nautinv.c are now in nautinv.h          *
+*                   - CPUTIME for UNIX uses CLK_TCK (needs revision!)        *
+*        2-Jun-01 : - prototype for converse()                               *
+*       18-Oct-01 : - complete revision; sysdeps in separate files           *
+*       28-Aug-02 : changes for version 2.2 :                                *
+*                   - revised for autoconf                                   *
+*       17-Nov-02 : added explicit "extern" where it was implicit before     *
+*       11-Apr-02 : added rangraph2()                                        *
+*       10-Sep-07 : Define CPUTIME=0.0 for hosts that don't provide it       *
+*        4-Nov-09 : added readgraph_sg(), putgraph_sg(), putcanon_sg()       *
+*       10-Nov-09 : removed types shortish and permutation                   *
+*       14-Nov-09 : added relabel_sg(), copy_sg(), putdegs_sg(),             *
+*                    sublabel_sg()                                           *
+*       19-Nov-09 : added individualise()                                    *
+*       20-Nov-09 : added hashgraph_sg(), listhash(), hashgraph()            *
+*       19-Dec-09 : added ranreg(), rangraph2_sg()                           *
+*        5-Jun-10 : added mathon_sg() and converse_sg()                      *
+*       10-Jun-10 : added putquotient_sg() and complement_sg()               *
+*       15-Jan-12 : added TLS_ATTR to static declarations                    *
+*        3-Mar-12 : added putorbitsplus() and putset_firstbold()             *
+*       17-Mar-12 : include naurng.h and remove redundant lines              *
+*        1-Nov-15 : changes for version 2.6 :                                *
+*                 - prototypes for putdegseq(), putdegseq_sg()               *
+*       17-Dec-15 : prototype for readgraph_swg()                            *
+*        6-Apr-16 : prototype for countcells()                               *
+*                                                                            *
+* @edit_msg@
+*                                                                            *
+*****************************************************************************/
+
+#include "nauty.h"              /* which includes stdio.h */
+#include "nausparse.h"
+#include "naurng.h"
+/* At this point we can assume that <sys/types.h>, <unistd.h>, <stddef.h>,
+   <stdlib.h>, <string.h> or <strings.h> and <malloc.h> if necessary have
+   been included if they exist. */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void complement(graph*,int,int);
+extern void converse(graph*,int,int);
+extern void converse_sg(sparsegraph*, sparsegraph*);
+extern void copycomment(FILE*,FILE*,int);
+extern void complement_sg(sparsegraph*, sparsegraph*);
+extern int countcells(int*,int,int);
+extern void flushline(FILE*);
+extern void fixit(int*,int*,int*,int,int);
+extern int getint(FILE*);
+extern int getint_sl(FILE*);
+extern long hash(set*,long,int);
+extern long hashgraph(graph*,int,int,long);
+extern long hashgraph_sg(sparsegraph*,long);
+extern void individualise(int*,int*,int,int,int*,int*,int);
+extern long listhash(int*,int,long);
+extern void mathon(graph*,int,int,graph*,int,int);
+extern void mathon_sg(sparsegraph*,sparsegraph*);
+extern void naututil_check(int,int,int,int);
+extern void naututil_freedyn(void);
+extern void putcanon(FILE*,int*,graph*,int,int,int);
+extern void putcanon_sg(FILE*,int*,sparsegraph*,int);
+extern void putdegs(FILE*,graph*,int,int,int);
+extern void putdegs_sg(FILE*,sparsegraph*,int);
+extern void putdegseq(FILE*,graph*,int,int,int);
+extern void putdegseq_sg(FILE*,sparsegraph*,int);
+extern void putgraph(FILE*,graph*,int,int,int);
+extern void putgraph_sg(FILE*,sparsegraph*,int);
+extern void putmapping(FILE*,int*,int,int*,int,int,int);
+extern void putorbits(FILE*,int*,int,int);
+extern void putorbitsplus(FILE*,int*,int,int);
+extern void putptn(FILE*,int*,int*,int,int,int);
+extern void putquotient(FILE*,graph*,int*,int*,int,int,int,int);
+extern void putquotient_sg(FILE*,sparsegraph*,int*,int*,int,int);
+extern void putset(FILE*,set*,int*,int,int,boolean);
+extern void putset_firstbold(FILE*,set*,int*,int,int,boolean);
+extern void rangraph(graph*,boolean,int,int,int);
+extern void rangraph2(graph*,boolean,int,int,int,int);
+extern void rangraph2_sg(sparsegraph*,boolean,int,int,int);
+extern void ranreg_sg(sparsegraph *sg, int degree, int n);
+extern void ranperm(int*,int);
+extern void readgraph(FILE*,graph*,boolean,boolean,boolean,int,int,int);
+extern void readgraph_sg(FILE*,sparsegraph*,boolean,boolean,int,int);
+extern void readgraph_swg(FILE*,sparsegraph*,boolean,boolean,int,int);
+extern boolean readinteger(FILE*,int*);
+extern boolean readinteger_sl(FILE*,int*);
+extern void readperm(FILE*,int*,boolean,int);
+extern void readptn(FILE*,int*,int*,int*,boolean,int);
+extern void readvperm(FILE*,int*,boolean,int,int*);
+extern boolean readstring(FILE*,char*,int);
+extern void relabel(graph*,int*,int*,graph*,int,int);
+extern void relabel_sg(sparsegraph*,int*,int*,sparsegraph*);
+extern long sethash(set*,int,long,int);
+extern int setinter(set*,set*,int);
+extern int setsize(set*,int);
+extern void sublabel(graph*,int*,int,graph*,int,int);
+extern void sublabel_sg(sparsegraph*,int*,int,sparsegraph*);
+extern int subpartition(int*,int*,int,int*,int);
+extern void unitptn(int*,int*,int*,int);
+
+#ifdef __cplusplus
+}
+#endif
+
+#define MAXREG 8    /* Used to limit ranreg_sg() degree */
+
+#define PROMPTFILE stdout    /* where to write prompts */
+#ifndef ERRFILE
+#define ERRFILE stderr       /* where to write error messages */
+#endif
+#define MAXIFILES 10         /* how many input files can be open at once */
+#define EXIT exit(0)         /* how to stop normally */
+#define DEFEXT ".dre"        /* extension for dreadnaut files */
+
+/*************************************************************************
+ The following macros may represent differences between system.  This
+ file contains the UNIX/POSIX editions.  For other systems, a separate
+ file of definitions is read in first.  That file should define the
+ variables NAUTY_*_DEFINED for sections that are to replace the UNIX
+ versions.  See the provided examples for more details.
+
+ If your system does not have a predefined macro you can use to cause
+ a definitions file to be read, you have to make up one and arrange for
+ it to be defined when this file is read.
+
+ The system-dependent files can also redefine the macros just ahead of
+ this comment.
+**************************************************************************/
+
+#ifdef __weirdmachine__
+#include "weird.h"  /* Some weird machine (ILLUSTRATION ONLY) */
+#endif
+
+/*************************************************************************/
+
+#ifndef NAUTY_PROMPT_DEFINED
+#if HAVE_ISATTY
+#define DOPROMPT(fp) (isatty(fileno(fp)) && isatty(fileno(PROMPTFILE)))
+#else
+#define DOPROMPT(fp) (curfile==0)
+#endif
+#endif /*NAUTY_PROMPT_DEFINED*/
+
+/*************************************************************************/
+
+#ifndef NAUTY_OPEN_DEFINED
+#define OPENOUT(fp,name,append) fp = fopen(name,(append)?"a":"w")
+#endif /*NAUTY_OPEN_DEFINED*/
+
+/*************************************************************************/
+
+#ifndef NAUTY_CPU_DEFINED
+#if HAVE_TIMES
+#include <sys/times.h>
+#define CPUDEFS static TLS_ATTR struct tms timebuffer;
+#ifndef CLK_TCK
+#include <time.h>
+#endif
+#if !defined(CLK_TCK) && defined(_SC_CLK_TCK)
+#define CLK_TCK sysconf(_SC_CLK_TCK)
+#endif
+#ifndef CLK_TCK
+#define CLK_TCK 60
+#endif
+#define CPUTIME (times(&timebuffer),\
+              (double)(timebuffer.tms_utime + timebuffer.tms_stime) / CLK_TCK)
+#else
+#if HAVE_GETRUSAGE
+#include <sys/time.h>
+#include <sys/resource.h>
+#define CPUDEFS struct rusage ruse;
+#define CPUTIME (getrusage(RUSAGE_SELF,&ruse),\
+  ruse.ru_utime.tv_sec + ruse.ru_stime.tv_sec + \
+  1e-6 * (ruse.ru_utime.tv_usec + ruse.ru_stime.tv_usec))
+#endif
+#endif
+
+#ifndef CPUTIME
+#define CPUTIME 0.0
+#endif
+
+#endif /*NAUTY_CPU_DEFINED*/
+
+/*************************************************************************/
+
+#ifndef NAUTY_SEED_DEFINED
+#if HAVE_GETTIMEOFDAY
+#include <sys/time.h>
+#define INITSEED \
+{struct timeval nauty_tv; \
+ struct timezone nauty_tz; \
+ gettimeofday(&nauty_tv,&nauty_tz); \
+ seed = ((nauty_tv.tv_sec<<10) + (nauty_tv.tv_usec>>10)) & 0x7FFFFFFFL;}
+#else
+#if HAVE_TIME
+#include <time.h>
+#define INITSEED  seed = ((time((time_t*)NULL)<<1) | 1) & 0x7FFFFFFFL
+#endif
+#endif
+#endif /*NAUTY_SEED_DEFINED*/
+
+/* @edit_msg@ */
diff --git a/lib/nauty/naututil.c b/lib/nauty/naututil.c
new file mode 100644
index 0000000..6cee404
--- /dev/null
+++ b/lib/nauty/naututil.c
@@ -0,0 +1,3192 @@
+/*****************************************************************************
+*                                                                            *
+* miscellaneous utilities for use with nauty 2.6.                            *
+* None of these procedures are needed by nauty, but all are by dreadnaut.    *
+*                                                                            *
+*   Copyright (1984-2016) Brendan McKay.  All rights reserved.               *
+*   Subject to waivers and disclaimers in nauty.h.                           *
+*                                                                            *
+*   CHANGE HISTORY                                                           *
+*       10-Nov-87 : final changes for version 1.2                            *
+*        5-Dec-87 : changes made for version 1.3 :                           *
+*                   - added procedures readinteger() and readstring()        *
+*                   - replaced all uses of fscanf() by appropriate uses      *
+*                     of readinteger() or readstring()                       *
+*                   - "N:" is now illegal in readgraph() if N is too large   *
+*                     or too small                                           *
+*       28-Sep-88 : renamed to version 1.4 (no changes to this file)         *
+*       23-Mar-89 : changes for version 1.5 :                                *
+*                   - declared key in hash()                                 *
+*                   - changed file name to naututil.c                        *
+*       29-Mar-89 : - declared workperm[] and workset[], and modified        *
+*                     many routines to use them.                             *
+*                   - added putmapping()                                     *
+*                   - reworked some code in mathon() and rangraph()          *
+*        3-Apr-89 : - changed putorbits() to use O(n) algorithm              *
+*        5-Apr-89 : - modifed readgraph() to not require fresh line          *
+*                   - changed MAKEEMPTY uses to EMPTYSET uses                *
+*       26-Apr-89 : - moved ptncode() and equitable() to nautaux.c           *
+*                   - added putquotient()                                    *
+*       18-Aug-89 : - modified putset() to use "i:j" syntax optionally       *
+*                   - modified putorbits() to use putset()                   *
+*                   - modified calling sequence for mathon()                 *
+*       19-Aug-90 : - changed delimeter arg of copycomment to int            *
+*       14-Oct-90 : renamed to version 1.6 (no changes to this file)         *
+*       23-Jan-91 : changes for version 1.7 :                                *
+*                   - fixed bug in complement()                              *
+*       27-Aug-92 : - made linelength <= 0 mean no line breaks               *
+*        5-Jun-93 : renamed to version 1.7+ (no changes to this file)        *
+*       18-Aug-93 : renamed to version 1.8 (no changes to this file)         *
+*       17-Sep-93 : renamed to version 1.9 (no changes to this file)         *
+*       13-Jul-96 : changes for version 2.0 :                                *
+*                   - added dynamic allocation                               *
+*                   - added limit parameter to readstring                    *
+*                   - added readvperm() and sublabel()                       *
+*       31-Aug-96 : - converted from RAN to KRAN                             *
+*        6-Feb-97 : - corrected DYNALLOC1 call in putmapping                 *
+*       10-Dec-97 : - KRAN now initialises automatically                     *
+*        9-Jan-00 : - added naututil_check()                                 *
+*       12-Feb-00 : - some minor code formatting                             *
+*       16-Nov-00 : - changes as listed in nauty.h                           *
+*       23-Apr-01 : changes for version 2.1 :                                *
+*                   - removed EXTDEFS                                        *
+*        2-Jun-01 : - added converse()                                       *
+*       21-Nov-01 : use NAUTYREQUIRED in naututil_check()                    *
+*       11-Apr-03 : changes for version 2.2 :                                *
+*                   - added rangraph2()                                      *
+*       17-Nov-03 : changed INFINITY to NAUTY_INFINITY                       *
+*       10-Dec-06 : removed BIGNAUTY                                         *
+*        4-Nov-09 : added readgraph_sg, putgraph_sg, putcanon_sg             *
+*       10-Nov-09 : removed shortish and permutation types                   *
+*       14-Nov-09 : added relabel_sg(), putdegs_sg(), sublabel_sg()          *
+*       19-Nov-09 : added individualise()                                    *
+*       20-Nov-09 : added hashgraph_sg(), listhash(), hashgraph()            *
+*       19-Dec-09 : added ranreg_sg(), rangraph2_sg()                        *
+*       21-May-10 : conform to type changes in sparsegraph                   *
+*        5-Jun-10 : add mathon_sg()                                          *
+*       10-Jun-10 : add putquotient_sg() and complement_sg()                 *
+*       26-Jan-11 : fix nde error in sublabel_sg()                           *
+*       15-Jan-12 : add TLS_ATTR attributes                                  *
+*        3-Mar-12 : add putorbitsplus() and putset_firstbold()               *
+*                 : write orbit sizes if not trivial                         *
+*       17-Mar-12 : move seed definition to naututil.h                       *
+*       20-Sep-12 : allow quoted strings in readstring()                     *
+*       20-Sep-12 : the first argument of ungetc is int, not char            *
+*        4-Mar-13 : remove a side-effect issue in setinter()                 *
+*       17-Dec-15 : add readgraph_swg() and update putgraph_sg()             *
+*       22-Jan-16 : add readintger_sl() and getint_sl()                      *
+*       29-Feb-16 : add subpartition()                                       *
+*        6-Apr-16 : add countcells(), make subpartition return a count       *
+*                                                                            *
+*****************************************************************************/
+
+#define ONE_WORD_SETS
+#include "naututil.h"    /* which includes nauty.h, nautinv.h and stdio.h */
+#include "nausparse.h"
+
+#if  MAXM==1
+#define M 1
+#else
+#define M m
+#endif
+
+#if !MAXN
+DYNALLSTAT(int,workperm,workperm_sz);
+DYNALLSTAT(set,workset,workset_sz);
+#else
+static TLS_ATTR int workperm[MAXN+2];   /* used for scratch purposes */
+static TLS_ATTR set workset[MAXM];      /* used for scratch purposes */
+#endif
+
+#define ECHUNKSIZE 1000  /* should be a multiple of 2 */
+typedef struct echunk {struct echunk *next; int edge[ECHUNKSIZE];} echunk;
+static TLS_ATTR echunk first_echunk = {NULL,{0}};
+typedef struct echunkw {struct echunkw *next; \
+ struct {int v1,v2; sg_weight wt;} edge[ECHUNKSIZE];} echunkw;
+static TLS_ATTR echunkw first_echunkw = {NULL,{0,0,0}};
+
+#ifdef  NLMAP
+#define GETNW(c,f) do c = getc(f); while (c==' '||c=='\t')
+#define GETNWC(c,f) do c = getc(f); while (c==' '||c==','||c=='\t')
+#define GETNWL(c,f) do c = getc(f); while (c==' '||c=='\n'||c=='\t')
+#else
+#define GETNW(c,f) do c = getc(f); while (c==' '||c=='\t'||c=='\r')
+#define GETNWC(c,f) do c = getc(f); while (c==' '||c==','||c=='\t'||c=='\r')
+#define GETNWL(c,f) do c = getc(f); while (c==' '||c=='\n'||c=='\t'||c=='\r')
+#endif
+
+#define ISDIGIT(c) ((c) >= '0' && (c) <= '9')
+
+static const long fuzz1[] = {1984625421L, 971524688L,1175081625L, 377165387L};
+static const long fuzz2[] = {2001381726L,1615243355L, 191176436L,1212176501L};
+#define FUZZ1(x) ((x) ^ fuzz1[(x)&3L])
+#define FUZZ2(x) ((x) ^ fuzz2[(x)&3L])
+
+#define SORT_OF_SORT 1
+#define SORT_NAME sort1int
+#define SORT_TYPE1 int
+#include "sorttemplates.c"   /* define sort1int(a,n) */
+
+/*****************************************************************************
+*                                                                            *
+*  setinter(set1,set2,m) = the number of elements in the intersection of     *
+*  the sets set1 and set2.                                                   *
+*                                                                            *
+*****************************************************************************/
+
+int
+setinter(set *set1, set *set2, int m)
+{
+    setword x;
+
+#if  MAXM==1
+    if ((x = *set1 & *set2) != 0) return POPCOUNT(x);
+    else                          return 0;
+#else
+    int count,i;
+
+    count = 0;
+    for (i = m; --i >= 0;)
+    {
+        if ((x = (*set1 & *set2)) != 0) count += POPCOUNT(x);
+        ++set1;
+	++set2;
+    }
+
+    return count;
+#endif
+}
+
+/*****************************************************************************
+*                                                                            *
+*  setsize(set1,m) = the number of elements in the set set1.                 *
+*                                                                            *
+*****************************************************************************/
+
+int
+setsize(set *set1, int m)
+{
+
+#if  MAXM==1
+    if (set1 != 0) return POPCOUNT(*set1);
+    else           return 0;
+#else
+    int count,i;
+    setword x;
+
+    count = 0;
+    for (i = m; --i >= 0;)
+        if ((x = *set1++) != 0) count += POPCOUNT(x);
+
+    return count;
+#endif
+}
+
+/*****************************************************************************
+*                                                                            *
+*  flushline(f) reads from f until '\n' or EOF.                              *
+*  If non-trivial characters are skipped, the user is informed.              *
+*                                                                            *
+*****************************************************************************/
+
+void
+flushline(FILE *f)
+{
+    boolean msg;
+    int c;
+
+    msg = FALSE;
+
+    while ((c = getc(f)) != EOF && c != '\n')
+        if (msg)
+            PUTC((char)c,ERRFILE);
+        else if (c != ' ' && c != '\t' && c != '\f' &&
+                                  c != '\r' && c != ',')
+        {
+            msg = TRUE;
+            fprintf(ERRFILE,"input skipped : '%c",(char)c);
+        }
+    if (msg) fprintf(ERRFILE,"'\n\n");
+}
+
+/*****************************************************************************
+*                                                                            *
+*  readinteger(f,&i) reads an optionally-signed integer from f, preceded by  *
+*  any amount of white space.  The function value returned is TRUE if an     *
+*  integer was found, FALSE otherwise.                                       *
+*                                                                            *
+*****************************************************************************/
+
+boolean
+readinteger(FILE *f, int *p)
+{
+    int c,ans,minus;
+
+    GETNWL(c,f);
+    if (!ISDIGIT(c) && c != '-' && c != '+')
+    {
+        if (c != EOF) ungetc(c,f);
+        return FALSE;
+    }
+
+    minus = c == '-';
+    ans = (c == '-' || c == '+' ? 0 : c - '0');
+
+    c = getc(f);
+    while (ISDIGIT(c))
+    {
+        ans *= 10;
+        ans += c - '0';
+        c = getc(f);
+    }
+
+    if (c != EOF) ungetc(c,f);
+
+    *p = (minus ? -ans : ans);
+    return TRUE;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  readinteger_sl(f,&i) reads an optionally-signed integer from f, preceded  *
+*  by any amount of white space except newlines.  The function value         *
+*  returned is TRUE if an integer was found, FALSE otherwise.                *
+*                                                                            *
+*****************************************************************************/
+
+boolean
+readinteger_sl(FILE *f, int *p)
+{
+    int c,ans,minus;
+
+    GETNW(c,f);
+    if (!ISDIGIT(c) && c != '-' && c != '+')
+    {
+        if (c != EOF) ungetc(c,f);
+        return FALSE;
+    }
+
+    minus = c == '-';
+    ans = (c == '-' || c == '+' ? 0 : c - '0');
+
+    c = getc(f);
+    while (ISDIGIT(c))
+    {
+        ans *= 10;
+        ans += c - '0';
+        c = getc(f);
+    }
+
+    if (c != EOF) ungetc(c,f);
+
+    *p = (minus ? -ans : ans);
+    return TRUE;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  readstring(f,s,slen) reads a string from f. First any amount of white     *
+*  space is skipped (including newlines).  If the next character is a        *
+*  double-quote, everything after that before the next double-quote or       *
+*  newline is put into s.  If the next character is not a double-quote,      *
+*  everything before the next white space is put into s.  A nul is added,    *
+*  but no more than slen characters are ever put into s.  The function       *
+*  value is TRUE if a string was found and FALSE otherwise.                  *
+*                                                                            *
+*****************************************************************************/
+
+boolean
+readstring(FILE *f, char *s, int slen)
+{
+    int c;
+    char *slim;
+
+    slim = s + slen - 1;
+    GETNWL(c,f);
+    if (c == EOF)
+    {
+        *s = '\0';
+        return FALSE;
+    }
+
+    if (c == '"')
+    {
+	c = getc(f);
+	while (c != '"' && c != '\n' && c != '\r' && c != EOF)
+	{
+	    if (s <= slim) *s++ = (char)c;
+            c = getc(f);
+        }
+	if (c != '"' && c != EOF) ungetc(c,f);
+    }
+    else
+    {
+        if (s <= slim) *s++ = (char)c;
+        c = getc(f);
+        while (c != ' ' && c != '\n' && c != '\t' && c != '\r' && c != EOF)
+        {
+            if (s <= slim) *s++ = (char)c;
+            c = getc(f);
+        }
+        if (c != EOF) ungetc(c,f);
+    }
+    if (s <= slim) *s = '\0';
+    else           *slim = '\0';
+
+    return TRUE;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  getint(f) reads an integer from f, optionally preceded by '='             *
+*  and white space.  -1 is returned if the attempt was unsuccessful.         *
+*                                                                            *
+*****************************************************************************/
+
+int
+getint(FILE *f)
+{
+    int i,c;
+
+    GETNWL(c,f);
+    if (c != '=') ungetc(c,f);
+
+    if (readinteger(f,&i)) return i;
+    else                   return -1;
+}
+
+/*****************************************************************************
+*                                                                            *
+* getint_sl(f) reads an integer from f, optionally preceded by '=' and       *
+* white space other than newlines.  -1 is returned if the attempt was        *
+* unsuccessful.                                                              *
+*****************************************************************************/
+
+int
+getint_sl(FILE *f)
+{
+    int i,c;
+
+    GETNW(c,f);
+    if (c != '=') ungetc(c,f);
+
+    if (readinteger_sl(f,&i)) return i;
+    else                      return -1;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  putset(f,set1,curlenp,linelength,m,compress)   writes the set set1 to     *
+*  file f using at most linelength characters per line (excluding '\n').     *
+*  A value of linelength <= 0 dictates no line breaks at all.                *
+*  *curlenp is the number of characters on the line so far; it is updated.   *
+*  A range j1,j1+1,...,j2 for j2-j1>=2 is written as "j1:j2" if compress     *
+*  is nonzero (eg. TRUE); otherwise each element is written separately.      *
+*  No final '\n' is written.  labelorg is used.                              *
+*                                                                            *
+*  FUNCTIONS CALLED: nextelement(),itos()                                    *
+*                                                                            *
+*****************************************************************************/
+
+void
+putset(FILE *f, set *set1, int *curlenp, int linelength,
+       int m, boolean compress)
+{
+    int slen,j1,j2;
+    char s[40];
+
+    j1 = -1;
+    while ((j1 = nextelement(set1,m,j1)) >= 0)
+    {
+        j2 = j1;
+        if (compress)
+        {
+            while (nextelement(set1,m,j2) == j2 + 1) ++j2;
+            if (j2 == j1+1) j2 = j1;
+        }
+        slen = itos(j1+labelorg,s);
+        if (j2 >= j1 + 2)
+        {
+            s[slen] = ':';
+            slen += 1 + itos(j2+labelorg,&s[slen+1]);
+        }
+
+        if (linelength > 0 && *curlenp + slen + 1 >= linelength)
+        {
+            fprintf(f,"\n   ");
+            *curlenp = 3;
+        }
+        fprintf(f," %s",s);
+        *curlenp += slen + 1;
+        j1 = j2;
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  putset_firstbold(f,set1,curlenp,linelength,m,compress) is the same as     *
+*  putset(f,set1,curlenp,linelength,m,compress) except that the first        *
+*  element of the set is written bold.  This is only useful when output is   *
+*  to a device that interprets ANSI control sequences.                       *
+*                                                                            *
+*  FUNCTIONS CALLED: nextelement(),itos()                                    *
+*                                                                            *
+*****************************************************************************/
+
+void
+putset_firstbold(FILE *f, set *set1, int *curlenp, int linelength,
+       int m, boolean compress)
+{
+    int slen,slen1,j1,j2;
+    char s[50],c;
+    boolean bold;
+
+    bold = TRUE;
+    j1 = -1;
+    while ((j1 = nextelement(set1,m,j1)) >= 0)
+    {
+        j2 = j1;
+        if (compress)
+        {
+            while (nextelement(set1,m,j2) == j2 + 1) ++j2;
+            if (j2 == j1+1) j2 = j1;
+        }
+        slen1 = slen = itos(j1+labelorg,s);
+        if (j2 >= j1 + 2)
+        {
+            s[slen] = ':';
+            slen += 1 + itos(j2+labelorg,&s[slen+1]);
+        }
+	c = s[slen1];
+
+        if (linelength > 0 && *curlenp + slen + 1 >= linelength)
+        {
+            fprintf(f,"\n   ");
+            *curlenp = 3;
+        }
+        if (bold)
+        {
+	    s[slen1] = '\0';
+            fprintf(f," \033[1m%s\033[0m",s);
+            s[slen1] = c;
+            fprintf(f,"%s",&s[slen1]);
+            bold = FALSE;
+        }
+        else
+            fprintf(f," %s",s);
+
+        *curlenp += slen + 1;
+        j1 = j2;
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  readgraph(f,g,digraph,prompt,edit,linelength,m,n) reads a graph g from f. *
+*  Commands: (There is always a "current vertex" v, initially labelorg;      *
+*             n is an unsigned integer.)                                     *
+*  n  : add edge (v,n)                                                       *
+*  -n : delete edge (v,n)                                                    *
+*  n: : set v := n, and exit if v >= n.                                      *
+*  ?  : type neighbours of vertex v                                          *
+*  ;  : increment v, and exit if v >= n.                                     *
+*  .  : exit                                                                 *
+*  !  : skip rest of input line                                              *
+*                                                                            *
+* If digraph==FALSE, loops are illegal and (x,y) => (y,x)                    *
+* If edit==FALSE, the graph is initialized to empty.                         *
+* If prompt==TRUE, prompts are written to PROMPTFILE.                        *
+* linelength is a limit on the number of characters per line caused by '?'   *
+* A value of linelength <= 0 dictates no line breaks at all.                *
+* labelorg is used.                                                          *
+*                                                                            *
+* FUNCTIONS CALLED : putset()                                                *
+*                                                                            *
+*****************************************************************************/
+
+void
+readgraph(FILE *f, graph *g, boolean digraph, boolean prompt,
+      boolean edit, int linelength, int m, int n)
+{
+    int v,c;
+    int curlen,w;
+    graph *gv;
+    boolean neg;
+
+    if (!edit)
+        for (v = 0, gv = g; v < n; ++v, gv += M) EMPTYSET(gv,m);
+
+    v = 0;
+    gv = g;
+    neg = FALSE;
+
+    while (TRUE)
+    {
+        GETNWC(c,f);
+        if (ISDIGIT(c))
+        {
+            ungetc(c,f);
+            readinteger(f,&w);
+            w -= labelorg;
+            if (neg)
+            {
+                neg = FALSE;
+                if (w < 0 || w >= n || (!digraph && w == v))
+                    fprintf(ERRFILE,"illegal edge (%d,%d) ignored\n\n",
+                            v+labelorg,w+labelorg);
+                else
+                {
+                    DELELEMENT(gv,w);
+                    if (!digraph) DELELEMENT(GRAPHROW(g,w,M),v);
+                }
+            }
+            else
+            {
+                GETNWC(c,f);
+                if (c == ':')
+                    if (w < 0 || w >= n)
+                        fprintf(ERRFILE,
+                                "illegal vertex number %d ignored\n\n",
+                                w+labelorg);
+                    else
+                    {
+                        v = w;
+                        gv = GRAPHROW(g,v,M);
+                    }
+                else
+                {
+                    ungetc(c,f);
+                    if (w < 0 || w >= n || (!digraph && w == v))
+                        fprintf(ERRFILE,"illegal edge (%d,%d) ignored\n\n",
+                                v+labelorg,w+labelorg);
+                    else
+                    {
+                        ADDELEMENT(gv,w);
+                        if (!digraph) ADDELEMENT(GRAPHROW(g,w,M),v);
+                    }
+                }
+            }
+        }
+        else switch(c)
+        {
+            case ';':
+                neg = FALSE;
+                ++v;
+                if (v >= n) return;
+                gv = GRAPHROW(g,v,M);
+                break;
+            case '?':
+                neg = FALSE;
+                fprintf(PROMPTFILE,"%2d : ",v+labelorg);
+                curlen = 5;
+                putset(PROMPTFILE,gv,&curlen,linelength,M,FALSE);
+                fprintf(PROMPTFILE,";\n");
+                break;
+            case '\n':
+                neg = FALSE;
+                if (prompt) fprintf(PROMPTFILE,"%2d : ",v+labelorg);
+                break;
+            case EOF:
+            case '.':
+                return;
+            case '-':
+                neg = TRUE;
+                break;
+            case '!':
+                do
+                    c = getc(f);
+                while (c != '\n' && c != EOF);
+                if (c == '\n') ungetc(c,f);
+                break;
+            default :
+                fprintf(ERRFILE,"illegal char '%c' - use '.' to exit\n\n",
+                        (char)c);
+        }
+    }
+}
+
+/**************************************************************************/
+
+void
+ranreg_sg(sparsegraph *sg, int degree, int n)
+/* Make a random regular simple undirected graph.
+ * For MAXN!=0, the maximum degree is MAXREG.
+ * sg must be initialised
+ */
+{
+    long i,k,v,w;
+    boolean ok;
+    int *dd,*ee;
+    size_t *vv,nde,j;
+ 
+#if MAXN
+    int p[MAXREG*MAXN];
+#else
+    DYNALLSTAT(int,p,p_sz);
+
+    DYNALLOC2(int,p,p_sz,degree,n,"genrang");
+#endif
+
+    nde = (size_t)n * (size_t)degree;
+
+    SG_ALLOC(*sg,n,nde,"ranreg_sg");
+    SG_VDE(sg,vv,dd,ee);
+    DYNFREE(sg->w,sg->wlen);
+
+    sg->nv = n;
+    sg->nde = nde;
+
+    for (i = j = 0; i < n; ++i)
+        for (k = 0; k < degree; ++k) p[j++] = i;
+
+    for (i = 0; i < n; ++i) vv[i] = i*(size_t)degree;
+
+    do
+    {   
+        ok = TRUE;
+
+        for (j = nde; j > 0; j -= 2)
+        {   
+            i = KRAN(j-1);
+	    k = p[i];
+	    if (k == p[j-1]) break;
+	    p[i] = p[j-2]; p[j-2] = k;
+        }
+	if (j > 0) { ok = FALSE; continue; }
+
+        for (i = 0; i < n; ++i) dd[i] = 0;
+
+        for (j = nde; j > 0; )
+        {   
+            v = p[--j];
+            w = p[--j];
+            if (v != w)
+	    {
+                for (i = dd[w]; --i >= 0;) if (ee[vv[w]+i] == v) break;
+                if (i >= 0) { ok = FALSE; break; }
+            }
+            ee[vv[w]+(dd[w]++)] = v;
+            ee[vv[v]+(dd[v]++)] = w;
+        }
+    }
+    while (!ok);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  readgraph_sg(f,sg,digraph,prompt,linelength,n) reads a graph g from f.    *
+*  Commands: (There is always a "current vertex" v, initially labelorg;      *
+*             n is an unsigned integer.)                                     *
+*  n  : add edge (v,n)                                                       *
+*  -n : delete edge (v,n)                                                    *
+*  n: : set v := n, and exit if v >= n.                                      *
+*  ?  : type neighbours of vertex v     ** NOT IMPLEMENTED **                *
+*  ;  : increment v, and exit if v >= n.                                     *
+*  .  : exit                                                                 *
+*  !  : skip rest of input line                                              *
+*  sg must be initialised                                                    *
+*                                                                            *
+* If digraph==FALSE, loops are illegal and (x,y) => (y,x)                    *
+* If prompt==TRUE, prompts are written to PROMPTFILE.                        *
+* linelength is a limit on the number of characters per line caused by '?'   *
+* A value of linelength <= 0 dictates no line breaks at all.                 *
+* labelorg is used.                                                          *
+*                                                                            *
+*****************************************************************************/
+
+void
+readgraph_sg(FILE *f, sparsegraph *sg, boolean digraph, boolean prompt,
+             int linelength, int n)
+{
+    int i,j,k,vv,ww,c;
+    boolean neg,done;
+    int *d,*e,*evi;
+    echunk *ec,*ecnext,*ec_end;
+    size_t ned,*v,iec,iec_end;
+
+    sg->nv = n;
+    DYNALLOC1(size_t,sg->v,sg->vlen,n,"malloc");
+    DYNALLOC1(int,sg->d,sg->dlen,n,"malloc");
+    DYNFREE(sg->w,sg->wlen);
+    v = sg->v;
+    d = sg->d;
+
+    for (i = 0; i < n; ++i) d[i] = 0;
+
+    ec = &first_echunk;
+    iec = 0;
+    vv = 0;
+    neg = done = FALSE;
+
+    while (!done)
+    {
+        GETNWC(c,f);
+        if (ISDIGIT(c))
+        {
+            ungetc(c,f);
+            readinteger(f,&ww);
+            ww -= labelorg;
+            if (neg)
+            {
+                neg = FALSE;
+                if (ww < 0 || ww >= n || (!digraph && ww == vv))
+                    fprintf(ERRFILE,"illegal edge (%d,%d) ignored\n\n",
+                            vv+labelorg,ww+labelorg);
+                else
+                {
+                    if (iec == ECHUNKSIZE)
+                    {
+                        if (!ec->next)
+                        {
+                            ecnext = (echunk*)ALLOCS(1,sizeof(echunk));
+                            if (!ecnext) alloc_error("malloc");
+                            ecnext->next = NULL;
+                            ec->next = ecnext;
+                        }
+                        ec = ec->next;
+                        iec = 0;
+                    }
+                    ec->edge[iec++] = vv;
+                    ec->edge[iec++] = -1 - ww;
+                    ++d[vv];
+                    if (!digraph && ww != vv) ++d[ww];
+                }
+            }
+            else
+            {
+                GETNWC(c,f);
+                if (c == ':')
+                {
+                    if (ww < 0 || ww >= n)
+                        fprintf(ERRFILE,
+                                "illegal vertex number %d ignored\n\n",
+                                ww+labelorg);
+                    else
+                        vv = ww;
+                }
+                else
+                {
+                    ungetc(c,f);
+                    if (ww < 0 || ww >= n || (!digraph && ww == vv))
+                        fprintf(ERRFILE,"illegal edge (%d,%d) ignored\n\n",
+                                vv+labelorg,ww+labelorg);
+                    else
+                    {
+                        if (iec == ECHUNKSIZE)
+                        {
+                            if (!ec->next)
+                            {
+                                ecnext = (echunk*)ALLOCS(1,sizeof(echunk));
+                                if (!ecnext) alloc_error("malloc");
+                                ecnext->next = NULL;
+                                ec->next = ecnext;
+                            }
+                            ec = ec->next;
+                            iec = 0;
+                        }
+                        ec->edge[iec++] = vv;
+                        ec->edge[iec++] = ww;
+                        ++d[vv];
+                        if (!digraph && ww != vv) ++d[ww];
+                    }
+                }
+            }
+        }
+        else switch(c)
+        {
+            case ';':
+                neg = FALSE;
+                ++vv;
+                if (vv >= n) done = TRUE;
+                break;
+            case '?':
+                neg = FALSE;
+                fprintf(ERRFILE,"Command \'?\' not implemented.\n\n");
+                break;
+            case '\n':
+                neg = FALSE;
+                if (prompt) fprintf(PROMPTFILE,"%2d : ",vv+labelorg);
+                break;
+            case EOF:
+            case '.':
+                done = TRUE;
+                break;
+            case '-':
+                neg = TRUE;
+                break;
+            case '!':
+                do
+                    c = getc(f);
+                while (c != '\n' && c != EOF);
+                if (c == '\n') ungetc(c,f);
+                break;
+            default :
+                fprintf(ERRFILE,"illegal char '%c' - use '.' to exit\n\n",
+                        (char)c);
+        }
+    }
+
+    ned = 0;
+    for (i = 0; i < n; ++i) ned += d[i];
+    DYNALLOC1(int,sg->e,sg->elen,ned,"malloc");
+    e = sg->e;
+
+    v[0] = 0;
+    for (i = 1; i < n; ++i) v[i] = v[i-1] + d[i-1];
+    for (i = 0; i < n; ++i) d[i] = 0;
+
+    iec_end = iec;
+    ec_end = ec;
+
+    iec = 0;
+    ec = &first_echunk;
+
+    if (ned != 0) while (TRUE)
+    {
+        vv = ec->edge[iec++];
+        ww = ec->edge[iec++];
+
+        if (ww >= 0)
+        {
+            e[v[vv]+(d[vv]++)] = ww;
+            if (!digraph && ww != vv) e[v[ww] +(d[ww]++)] = vv;
+        }
+        else
+        {
+            ww = -1 - ww;
+            for (i = 0; i < d[vv]; ++i)
+                if (e[v[vv]+i] == ww) break;
+            if (i < d[vv])
+            {
+                e[v[vv]+i] = e[v[vv]+d[vv]-1];
+                --d[vv];
+            }
+            if (!digraph && ww != vv)
+            {
+                for (i = 0; i < d[ww]; ++i)
+                    if (e[v[ww]+i] == vv) break;
+                if (i < d[ww])
+                {
+                    e[v[ww]+i] = e[v[ww]+d[ww]-1];
+                    --d[ww];
+                }
+            }
+        }
+        if (iec == iec_end && ec == ec_end) break;
+        if (iec == ECHUNKSIZE) { iec = 0; ec = ec->next; }
+    }
+
+    sortlists_sg(sg);
+
+    ned = 0;
+    for (i = 0; i < n; ++i)
+    {
+        if (d[i] > 1)
+        {
+            evi = e + v[i];
+            j = 1;
+            for (k = 1; k < d[i]; ++k)
+                if (evi[k] != evi[j-1]) evi[j++] = evi[k];
+            d[i] = j;
+        }
+        ned += d[i];
+    }
+    sg->nde = ned; 
+}
+
+/*****************************************************************************
+*                                                                            *
+*  readgraph_swg(f,sg,digraph,prompt,linelength,n) reads a sparse weighted   *
+*  graph g from f.                                                           *
+*  Commands: (There is always a "current vertex" v, initially labelorg;      *
+*             n is an unsigned integer, w is a weight.)                      *
+*  n  : add edge (v,n)                                                       *
+*  -n : delete edge (v,n)                                                    *
+*  n: : set v := n, and exit if v >= n.                                      *
+*  ?  : type neighbours of vertex v     ** NOT IMPLEMENTED **                *
+*  ;  : increment v, and exit if v >= n.                                     *
+*  .  : exit                                                                 *
+*  !  : skip rest of input line                                              *
+*  w# : set the weight for the next edge only                                *
+*  W# : set the weight from now on                                           *
+*  sg must be initialised                                                    *
+*                                                                            *
+* If digraph==FALSE, loops are illegal and (x,y) => (y,x)                    *
+* For digraphs, an unspecified opposite edge has weight SG_MINWEIGHT         *
+* If edges are inserted more than once, the largest weight counts.           *
+* If prompt==TRUE, prompts are written to PROMPTFILE.                        *
+* linelength is a limit on the number of characters per line caused by '?'   *
+* A value of linelength <= 0 dictates no line breaks at all.                 *
+* labelorg is used.                                                          *
+*                                                                            *
+*****************************************************************************/
+
+void
+readgraph_swg(FILE *f, sparsegraph *sg, boolean digraph, boolean prompt,
+             int linelength, int n)
+{
+    int i,j,k,vv,ww,c;
+    boolean neg,done;
+    int *d,*e,*evi;
+    echunkw *ec,*ecnext,*ec_end;
+    size_t ned,*v,iec,iec_end;
+    sg_weight *wt,currwt,defwt,*wvi;
+
+    sg->nv = n;
+    DYNALLOC1(size_t,sg->v,sg->vlen,n,"malloc");
+    DYNALLOC1(int,sg->d,sg->dlen,n,"malloc");
+    v = sg->v;
+    d = sg->d;
+    wt = sg->w;
+
+    for (i = 0; i < n; ++i) d[i] = 0;
+
+    defwt = currwt = 1; 
+    ec = &first_echunkw;
+    iec = 0;
+    vv = 0;
+    neg = done = FALSE;
+
+    while (!done)
+    {
+        GETNWC(c,f);
+        if (ISDIGIT(c))
+        {
+            ungetc(c,f);
+            readinteger(f,&ww);
+            ww -= labelorg;
+            if (neg)
+            {
+                neg = FALSE;
+                if (ww < 0 || ww >= n || (!digraph && ww == vv))
+                    fprintf(ERRFILE,"illegal edge (%d,%d) ignored\n\n",
+                            vv+labelorg,ww+labelorg);
+                else
+                {
+                    if (iec == ECHUNKSIZE)
+                    {
+                        if (!ec->next)
+                        {
+                            ecnext = (echunkw*)ALLOCS(1,sizeof(echunkw));
+                            if (!ecnext) alloc_error("malloc");
+                            ecnext->next = NULL;
+                            ec->next = ecnext;
+                        }
+                        ec = ec->next;
+                        iec = 0;
+                    }
+                    ec->edge[iec].v1 = vv;
+                    ec->edge[iec].v2 = -1 - ww;
+                    ec->edge[iec].wt = currwt;
+		    ++iec;
+                    currwt = defwt;
+                    ++d[vv];
+                    if (ww != vv) ++d[ww];
+                }
+            }
+            else
+            {
+                GETNWC(c,f);
+                if (c == ':')
+                {
+                    if (ww < 0 || ww >= n)
+                        fprintf(ERRFILE,
+                                "illegal vertex number %d ignored\n\n",
+                                ww+labelorg);
+                    else
+                        vv = ww;
+                }
+                else
+                {
+                    ungetc(c,f);
+                    if (ww < 0 || ww >= n || (!digraph && ww == vv))
+                        fprintf(ERRFILE,"illegal edge (%d,%d) ignored\n\n",
+                                vv+labelorg,ww+labelorg);
+                    else
+                    {
+                        if (iec == ECHUNKSIZE)
+                        {
+                            if (!ec->next)
+                            {
+                                ecnext = (echunkw*)ALLOCS(1,sizeof(echunkw));
+                                if (!ecnext) alloc_error("malloc");
+                                ecnext->next = NULL;
+                                ec->next = ecnext;
+                            }
+                            ec = ec->next;
+                            iec = 0;
+                        }
+                        ec->edge[iec].v1 = vv;
+                        ec->edge[iec].v2 = ww;
+                        ec->edge[iec].wt = currwt;
+			++iec;
+                        currwt = defwt;
+                        ++d[vv];
+                        if (ww != vv) ++d[ww];
+                    }
+                }
+            }
+        }
+        else switch(c)
+        {
+            case ';':
+                neg = FALSE;
+                ++vv;
+                if (vv >= n) done = TRUE;
+                break;
+            case '?':
+                neg = FALSE;
+                fprintf(ERRFILE,"Command \'?\' not implemented.\n\n");
+                break;
+            case '\n':
+                neg = FALSE;
+                if (prompt) fprintf(PROMPTFILE,"%2d : ",vv+labelorg);
+                break;
+            case EOF:
+            case '.':
+                done = TRUE;
+                break;
+            case '-':
+                neg = TRUE;
+                break;
+            case 'w':
+                readinteger(f,&currwt);
+		if (currwt <= SG_MINWEIGHT)
+		{
+		    fprintf(ERRFILE,"Weight too small\n\n");
+		    currwt = 1;
+		}
+		break;
+            case 'W':
+                readinteger(f,&currwt);
+		if (currwt <= SG_MINWEIGHT)
+		{
+		    fprintf(ERRFILE,"Weight too small\n\n");
+		    currwt = 1;
+		}
+		defwt = currwt;
+		break;
+            case '!':
+                do
+                    c = getc(f);
+                while (c != '\n' && c != EOF);
+                if (c == '\n') ungetc(c,f);
+                break;
+            default :
+                fprintf(ERRFILE,"illegal char '%c' - use '.' to exit\n\n",
+                        (char)c);
+        }
+    }
+
+    ned = 0;
+    for (i = 0; i < n; ++i) ned += d[i];
+    DYNALLOC1(int,sg->e,sg->elen,ned,"malloc");
+    DYNALLOC1(sg_weight,sg->w,sg->wlen,ned,"malloc");
+    e = sg->e;
+    wt = sg->w;
+
+    v[0] = 0;
+    for (i = 1; i < n; ++i) v[i] = v[i-1] + d[i-1];
+    for (i = 0; i < n; ++i) d[i] = 0;
+
+    iec_end = iec;
+    ec_end = ec;
+
+    iec = 0;
+    ec = &first_echunkw;
+
+    if (ned != 0) while (TRUE)
+    {
+        vv = ec->edge[iec].v1;
+        ww = ec->edge[iec].v2;
+        currwt = ec->edge[iec].wt;
+        ++iec;
+
+        if (ww >= 0)
+        {
+            e[v[vv]+d[vv]] = ww;
+            wt[v[vv]+d[vv]] = currwt;
+	    ++d[vv];
+            if (ww != vv)
+            {
+		e[v[ww]+d[ww]] = vv;
+		wt[v[ww]+d[ww]] = (digraph ? SG_MINWEIGHT : currwt);
+		++d[ww];
+	    }
+        }
+        else
+        {
+            ww = -1 - ww;
+            for (i = 0; i < d[vv]; ++i)
+                if (e[v[vv]+i] == ww) break;
+            if (i < d[vv])
+            {
+                e[v[vv]+i] = e[v[vv]+d[vv]-1];
+                wt[v[vv]+i] = wt[v[vv]+d[vv]-1];
+                --d[vv];
+            }
+            if (ww != vv)
+            {
+                for (i = 0; i < d[ww]; ++i)
+                    if (e[v[ww]+i] == vv) break;
+                if (i < d[ww])
+                {
+                    e[v[ww]+i] = e[v[ww]+d[ww]-1];
+                    wt[v[ww]+i] = wt[v[ww]+d[ww]-1];
+                    --d[ww];
+                }
+            }
+        }
+        if (iec == iec_end && ec == ec_end) break;
+        if (iec == ECHUNKSIZE) { iec = 0; ec = ec->next; }
+    }
+
+    sortlists_sg(sg);
+
+    ned = 0;
+    for (i = 0; i < n; ++i)
+    {
+        if (d[i] > 1)
+        {
+            evi = e + v[i];
+	    wvi = wt + v[i];
+            j = 1;
+            for (k = 1; k < d[i]; ++k)
+            {
+                if (evi[k] != evi[j-1])
+                {
+		    evi[j] = evi[k];
+		    wvi[j] = wvi[k];
+		    ++j;
+		}
+		else if (wvi[k] > wvi[j-1])
+		    wvi[j-1] = wvi[k];
+            }
+            d[i] = j;
+        }
+        ned += d[i];
+    }
+    sg->nde = ned; 
+}
+
+/*****************************************************************************
+*                                                                            *
+*  putgraph(f,g,linelength,m,n) writes a list of the edges of g to f         *
+*  using at most linelength characters per line (excluding '\n').            *
+*  A value of linelength <= 0 dictates no line breaks at all within the      *
+*    list for each vertex.                                                   *
+*  labelorg is used.                                                         *
+*                                                                            *
+*  FUNCTIONS CALLED: putset()                                                *
+*                                                                            *
+*****************************************************************************/
+
+void
+putgraph(FILE *f, graph *g, int linelength, int m, int n)
+{
+    int i,curlen;
+    set *pg;
+
+    for (i = 0, pg = g; i < n; ++i, pg += M)
+    {
+        fprintf(f,"%3d : ",i+labelorg);
+        curlen = 7;
+        putset(f,pg,&curlen,linelength,M,FALSE);
+        fprintf(f,";\n");
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  putgraph_sg(f,sg,linelength) writes a list of the edges of g to f         *
+*  using at most linelength characters per line (excluding '\n').            *
+*  A value of linelength <= 0 dictates no line breaks at all within the      *
+*    list for each vertex.                                                   *
+*  labelorg is used.                                                         *
+*                                                                            *
+*****************************************************************************/
+
+void
+putgraph_sg(FILE *f, sparsegraph *sg, int linelength)
+{
+    int i,n,curlen,slen;
+    int *d,*e;
+    size_t *v,j;
+    sg_weight *wt;
+    char s[60];
+
+    n = sg->nv;
+    SWG_VDE(sg,v,d,e,wt);
+
+    for (i = 0; i < n; ++i)
+    {
+        fprintf(f,"%3d : ",i+labelorg);
+        curlen = 7;
+
+        for (j = v[i]; j < v[i]+d[i]; ++j)
+        {
+	    if (wt && wt[j] != 1)
+	    {
+		s[0] = 'w';
+		if (wt[j] == SG_MINWEIGHT)
+		{
+		    s[1] = 'X';
+		    s[2] = ' ';
+		    slen = 3;
+		}
+		else
+		{
+		    slen = 2 + itos(wt[j],s+1);
+		    s[slen-1] = ' ';
+		}
+                slen += itos(e[j]+labelorg,s+slen);
+            }
+            else
+                slen = itos(e[j]+labelorg,s);
+
+            if (linelength > 0 && curlen + slen + 1 > linelength)
+            {
+                putstring(f,"\n  ");
+                curlen = 2;
+            }
+            PUTC(' ',f);
+            putstring(f,s);
+            curlen += slen + 1;
+        }
+        putstring(f,";\n");
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  putmapping(f,lab1,org1,lab2,org2,linelength,n) writes n pairs             *
+*  (lab1[i]+org1)-(lab2[i]+org2) to file f in increasing order of lab1[i].   *
+*  lab1 and lab2 are assumed to be permutations.  At most linelength         *
+*  characters (excluding '\n') are written per line.                         *
+*  A value of linelength <= 0 dictates no line breaks at all.                *
+*                                                                            *
+*  FUNCTIONS CALLED: itos(),putstring()                                      *
+*                                                                            *
+*****************************************************************************/
+
+void
+putmapping(FILE *f, int *lab1, int org1,int *lab2, int org2,
+       int linelength, int n)
+{
+    int i,curlen,slen;
+    char s[60];
+
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n+2,"putmapping");
+#endif
+
+    for (i = 0; i < n; ++i) workperm[lab1[i]] = lab2[i];
+
+    curlen = 0;
+    for (i = 0; i < n; ++i)
+    {
+        slen = itos(i+org1,s);
+        s[slen++] = '-';
+        slen += itos(workperm[i]+org2,&s[slen]);
+        if (linelength > 0 && curlen + slen + 1 > linelength)
+        {
+            putstring(f,"\n  ");
+            curlen = 2;
+        }
+        PUTC(' ',f);
+        putstring(f,s);
+        curlen += slen + 1;
+    }
+    PUTC('\n',f);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  putorbits(f,orbits,linelength,n) writes the orbits to f as lists          *
+*  of integers separated by semicolons.  No more than linelength characters  *
+*  (excluding '\n') are written per line.                                    *
+*  A value of linelength <= 0 dictates no line breaks at all.                *
+*  labelorg is used.                                                         *
+*                                                                            *
+*  FUNCTIONS CALLED: itos(),putset()                                         *
+*                                                                            *
+*****************************************************************************/
+
+void
+putorbits(FILE *f, int *orbits, int linelength, int n)
+{
+    int i,j;
+    int m,curlen,sz,slen;
+    char s[20];
+
+    m = SETWORDSNEEDED(n);
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n+2,"putorbits");
+    DYNALLOC1(set,workset,workset_sz,m,"putorbits");
+#endif
+
+    for (i = n; --i >= 0;) workperm[i] = 0;
+    for (i = n; --i >= 0;)
+        if ((j = orbits[i]) < i)
+        {
+            workperm[i] = workperm[j];
+            workperm[j] = i;
+        }
+
+    curlen = 0;
+    for (i = 0; i < n; ++i)
+        if (orbits[i] == i)
+        {
+	    sz = 0;
+            EMPTYSET(workset,m);
+            j = i;
+            do
+            {
+                ADDELEMENT(workset,j);
+                j = workperm[j];
+		++sz;
+            }
+            while (j > 0);
+            putset(f,workset,&curlen,linelength-1,m,TRUE);
+	    if (sz > 1)
+	    {
+	        s[0] = ' ';
+		s[1] = '(';
+		slen = 2 + itos(sz,s+2);
+		s[slen++] = ')';
+		s[slen] = '\0';
+		if (linelength > 0 && curlen + slen + 1 >= linelength)
+        	{
+            	    fprintf(f,"\n   ");
+                    curlen = 3;
+        	}
+		fprintf(f,"%s",s);
+		curlen += slen;
+	    }
+
+            PUTC(';',f);
+            ++curlen;
+        }
+    PUTC('\n',f);
+}
+
+
+/*****************************************************************************
+*                                                                            *
+*  putorbitsplus(f,orbits,linelength,n) is the same as                       *
+*  putorbits(f,orbits,linelength,n) except that the first element of each    *
+*  orbit is written bold.  This only works if output is to a device that     *
+*  interprets ANSI controls.                                                 *
+*                                                                            *
+*  FUNCTIONS CALLED: itos(),putset()                                         *
+*                                                                            *
+*****************************************************************************/
+
+void
+putorbitsplus(FILE *f, int *orbits, int linelength, int n)
+{
+    int i,j;
+    int m,curlen,sz,slen;
+    char s[20];
+
+    m = SETWORDSNEEDED(n);
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n+2,"putorbits");
+    DYNALLOC1(set,workset,workset_sz,m,"putorbits");
+#endif
+
+    for (i = n; --i >= 0;) workperm[i] = 0;
+    for (i = n; --i >= 0;)
+        if ((j = orbits[i]) < i)
+        {
+            workperm[i] = workperm[j];
+            workperm[j] = i;
+        }
+
+    curlen = 0;
+    for (i = 0; i < n; ++i)
+        if (orbits[i] == i)
+        {
+	    sz = 0;
+            EMPTYSET(workset,m);
+            j = i;
+            do
+            {
+                ADDELEMENT(workset,j);
+                j = workperm[j];
+		++sz;
+            }
+            while (j > 0);
+            putset_firstbold(f,workset,&curlen,linelength-1,m,TRUE);
+	    if (sz > 1)
+	    {
+	        s[0] = ' ';
+		s[1] = '(';
+		slen = 2 + itos(sz,s+2);
+		s[slen++] = ')';
+		s[slen] = '\0';
+		if (linelength > 0 && curlen + slen + 1 >= linelength)
+        	{
+            	    fprintf(f,"\n   ");
+                    curlen = 3;
+        	}
+		fprintf(f,"%s",s);
+		curlen += slen;
+	    }
+
+            PUTC(';',f);
+            ++curlen;
+        }
+    PUTC('\n',f);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  putquotient(f,g,lab,ptn,level,linelength,m,n) writes the quotient matrix  *
+*  of g defined by the partition at the given level.  Precisely, for each    *
+*  cell W, it writes the number w of the least vertex in W, then the size    *
+*  of W, then the number of times w is joined FROM each cell.  A complete    *
+*  join is written as "*", while an empty join is written as "-".  No more   *
+*  than linelength  characters (excluding '\n') are written per line unless  *
+*  linelength is very small.  A value of linelength <= 0 dictates no line    *
+*  breaks at all.   labelorg is used.                                        *
+*                                                                            *
+*  FUNCTIONS CALLED: itos()                                                  *
+*                                                                            *
+*****************************************************************************/
+
+void
+putquotient(FILE *f, graph *g, int *lab, int *ptn, int level,
+        int linelength, int m, int n)
+{
+    int i;
+    char s[50];
+    int ic,curlen,v,w,cell1,cell2,numcells,jc,csize,k;
+    set *gw;
+
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n+2,"putquotient");
+    DYNALLOC1(set,workset,workset_sz,m,"putquotient");
+#endif
+
+    numcells = 0;
+    for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+    {
+        for (cell2 = cell1; ptn[cell2] > level; ++cell2) {}
+        w = lab[cell1];
+        for (i = cell1 + 1; i <= cell2; ++i)
+            if (lab[i] < w) w = lab[i];
+        workperm[numcells++] = w;
+    }
+
+    for (ic = cell1 = 0; ic < numcells; ++ic, cell1 = cell2 + 1)
+    {
+        for (cell2 = cell1; ptn[cell2] > level; ++cell2) {}
+        EMPTYSET(workset,M);
+        for (i = cell1; i <= cell2; ++i) ADDELEMENT(workset,lab[i]);
+        v = workperm[ic];
+        csize = cell2 - cell1 + 1;
+        if (v + labelorg < 10)
+        {
+            s[0] = ' ';
+            curlen = 1;
+        }
+        else
+            curlen = 0;
+        curlen += itos(v+labelorg,&s[curlen]);
+        s[curlen++] = '[';
+        curlen += itos(csize,&s[curlen]);
+        fprintf(f,"%s",s);
+        if (csize < 10)
+        {
+            fprintf(f,"]  :");
+            curlen += 4;
+        }
+        else
+        {
+            fprintf(f,"] :");
+            curlen += 3;
+        }
+
+        for (jc = 0; jc < numcells; ++jc)
+        {
+            w = workperm[jc];
+            gw = GRAPHROW(g,w,m);
+            k = setinter(gw,workset,M);
+            if (k == 0 || k == csize)
+            {
+                if (linelength > 0 && curlen + 2 > linelength)
+                {
+                    fprintf(f,"\n    ");
+                    curlen = 4;
+                }
+                if (k == 0) fprintf(f," -");
+                else        fprintf(f," *");
+                curlen += 2;
+            }
+            else
+            {
+                i = itos(k,s);
+                if (linelength > 0 && curlen + i + 1 > linelength)
+                {
+                    fprintf(f,"\n    ");
+                    curlen = 4;
+                }
+                fprintf(f," %s",s);
+                curlen += i + 1;
+            }
+        }
+        fprintf(f,"\n");
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  putquotient_sg(f,g,lab,ptn,level,linelength) writes the quotient matrix   *
+*  of g defined by the partition at the given level.  Precisely, for each    *
+*  cell W, it writes the number w of the least vertex in W, then the size    *
+*  of W, then the number of times w is joined FROM each cell.  A complete    *
+*  join is written as "*", while an empty join is written as "-".  No more   *
+*  than linelength  characters (excluding '\n') are written per line unless  *
+*  linelength is very small.  A value of linelength <= 0 dictates no line    *
+*  breaks at all.   labelorg is used.                                        *
+*                                                                            *
+*  Weughts are ignored.                                                      *
+*                                                                            *
+*****************************************************************************/
+
+void
+putquotient_sg(FILE *f, sparsegraph *g, int *lab, int *ptn,
+						int level, int linelength)
+{
+    int i,m,n;
+    char s[50];
+    int ic,curlen,v,w,cell1,cell2,numcells,jc,csize,k;
+    int *dd,*ee;
+    size_t *vv,j;
+
+    n = g->nv;
+    m = SETWORDSNEEDED(n);
+    SG_VDE(g,vv,dd,ee);
+
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n+2,"putquotient");
+    DYNALLOC1(set,workset,workset_sz,m,"putquotient");
+#endif
+
+    numcells = 0;
+    for (cell1 = 0; cell1 < n; cell1 = cell2 + 1)
+    {
+        for (cell2 = cell1; ptn[cell2] > level; ++cell2) {}
+        w = lab[cell1];
+        for (i = cell1 + 1; i <= cell2; ++i)
+            if (lab[i] < w) w = lab[i];
+        workperm[numcells++] = w;
+    }
+
+    for (ic = cell1 = 0; ic < numcells; ++ic, cell1 = cell2 + 1)
+    {
+        for (cell2 = cell1; ptn[cell2] > level; ++cell2) {}
+        EMPTYSET(workset,M);
+        for (i = cell1; i <= cell2; ++i) ADDELEMENT(workset,lab[i]);
+        v = workperm[ic];
+        csize = cell2 - cell1 + 1;
+        if (v + labelorg < 10)
+        {
+            s[0] = ' ';
+            curlen = 1;
+        }
+        else
+            curlen = 0;
+        curlen += itos(v+labelorg,&s[curlen]);
+        s[curlen++] = '[';
+        curlen += itos(csize,&s[curlen]);
+        fprintf(f,"%s",s);
+        if (csize < 10)
+        {
+            fprintf(f,"]  :");
+            curlen += 4;
+        }
+        else
+        {
+            fprintf(f,"] :");
+            curlen += 3;
+        }
+
+        for (jc = 0; jc < numcells; ++jc)
+        {
+            w = workperm[jc];
+            k = 0;
+	    for (j = vv[w]; j < vv[w]+dd[w]; ++j)
+		if (ISELEMENT(workset,ee[j])) ++k;
+
+            if (k == 0 || k == csize)
+            {
+                if (linelength > 0 && curlen + 2 > linelength)
+                {
+                    fprintf(f,"\n    ");
+                    curlen = 4;
+                }
+                if (k == 0) fprintf(f," -");
+                else        fprintf(f," *");
+                curlen += 2;
+            }
+            else
+            {
+                i = itos(k,s);
+                if (linelength > 0 && curlen + i + 1 > linelength)
+                {
+                    fprintf(f,"\n    ");
+                    curlen = 4;
+                }
+                fprintf(f," %s",s);
+                curlen += i + 1;
+            }
+        }
+        fprintf(f,"\n");
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  putptn(f,lab,ptn,level,linelength,n) writes the partition at the given    *
+*  level as sorted lists of integers separated by semicolons.  No more than  *
+*  linelength characters (excluding '\n') are written per line.              *
+*  A value of linelength <= 0 dictates no line breaks at all.                *
+*  labelorg is used.                                                         *
+*                                                                            *
+*****************************************************************************/
+
+void
+putptn(FILE *f, int *lab, int *ptn, int level, int linelength, int n)
+{
+    int i;
+    int curlen,m;
+
+    m = SETWORDSNEEDED(n);
+#if !MAXN
+    DYNALLOC1(set,workset,workset_sz,m,"putptn");
+#endif
+
+    PUTC('[',f);
+    curlen = 1;
+    i = 0;
+    while (i < n)
+    {
+        EMPTYSET(workset,m);
+        while (TRUE)
+        {
+            ADDELEMENT(workset,lab[i]);
+            if (ptn[i] > level) ++i;
+            else                break;
+        }
+        putset(f,workset,&curlen,linelength-2,m,TRUE);
+        if (i < n-1)
+        {
+            fprintf(f," |");
+            curlen += 2;
+        }
+        ++i;
+    }
+    fprintf(f," ]\n");
+}
+
+/*****************************************************************************
+*                                                                            *
+*  putcanon(f,canonlab,canong,linelength,m,n) writes the label canonlab      *
+*  and the graph canong to f, using at most linelength characters            *
+*  (excluding '\n') per line.   labelorg is used.                            *
+*  A value of linelength <= 0 dictates no line breaks at all.                *
+*                                                                            *
+*****************************************************************************/
+
+void
+putcanon(FILE *f, int *canonlab, graph *canong, int linelength, int m, int n)
+{
+    int i;
+
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n+2,"putcanon");
+#endif
+
+    for (i = 0; i < n; ++i) workperm[i] = canonlab[i];
+    writeperm(f,workperm,TRUE,linelength,n);
+    putgraph(f,canong,linelength,m,n);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  putcanon_sg(f,canonlab,canong,linelength) writes the label canonlab       *
+*  and the graph canong to f, using at most linelength characters            *
+*  (excluding '\n') per line.   labelorg is used.                            *
+*  A value of linelength <= 0 dictates no line breaks at all.                *
+*                                                                            *
+*****************************************************************************/
+
+void
+putcanon_sg(FILE *f, int *canonlab, sparsegraph *canong, int linelength)
+{
+    int i,n;
+
+    n = canong->nv;
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n+2,"putcanon");
+#endif
+
+    for (i = 0; i < n; ++i) workperm[i] = canonlab[i];
+    writeperm(f,workperm,TRUE,linelength,n);
+    putgraph_sg(f,canong,linelength);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  readptn(f,lab,ptn,&numcells,prompt,n) reads a partition from f            *
+*  and establishes it in (lab,ptn).                                          *
+*  The format can be just a number, which is fixed alone, or an arbitrary    *
+*  partition [...|...|...].  Ranges x:y can be used.                         *
+*  labelorg is used.                                                         *
+*                                                                            *
+*****************************************************************************/
+
+void
+readptn(FILE *f, int *lab, int *ptn, int *numcells, boolean prompt, int n)
+{
+    int i,j;
+    int c,v1,v2,m;
+
+    m = SETWORDSNEEDED(n);
+#if !MAXN
+    DYNALLOC1(set,workset,workset_sz,m,"readptn");
+#endif
+
+    GETNW(c,f);
+    if (c == '=') GETNW(c,f);
+    if (ISDIGIT(c))
+    {
+        ungetc(c,f);
+        readinteger(f,&v1);
+        v1 -= labelorg;
+        if (v1 >= 0 && v1 < n)
+            fixit(lab,ptn,numcells,v1,n);
+        else
+        {
+            fprintf(ERRFILE,"vertex out of range (%d), fixing nothing\n\n",
+                    v1+labelorg);
+            unitptn(lab,ptn,numcells,n);
+        }
+        return;
+    }
+    if (c != '[')
+    {
+        ungetc(c,f);
+        fprintf(ERRFILE,"illegal partition, fixing nothing\n\n");
+        unitptn(lab,ptn,numcells,n);
+        return;
+    }
+    EMPTYSET(workset,m);
+    *numcells = 0;
+    for (i = 0; i < n; ++i) ptn[i] = NAUTY_INFINITY;
+    i = 0;
+    j = -1;
+    while (TRUE)
+    {
+        GETNWC(c,f);
+        if (ISDIGIT(c))
+        {
+            ungetc(c,f);
+            readinteger(f,&v1);
+            v1 -= labelorg;
+            GETNWC(c,f);
+            if (c == ':')
+                if (!readinteger(f,&v2))
+                {
+                    fprintf(ERRFILE,"unfinished range\n\n");
+                    v2 = v1;
+                }
+                else
+                    v2 -= labelorg;
+            else
+            {
+                ungetc(c,f);
+                v2 = v1;
+            }
+            while (v1 <= v2)
+            {
+                if (v1 < 0 || v1 >= n || ISELEMENT(workset,v1))
+                    fprintf(ERRFILE,"illegal or repeated number : %d\n\n",
+                            v1+labelorg);
+                else
+                {
+                    ADDELEMENT(workset,v1);
+                    lab[++j] = v1;
+                }
+                ++v1;
+            }
+        }
+        else if (c == '|' || c == ']' || c == EOF)
+        {
+            if (j >= i)
+            {
+                ++*numcells;
+                ptn[j] = 0;
+            }
+            if (c == '|')
+                i = j + 1;
+            else if (j == n - 1)
+                return;
+            else
+            {
+                i = j + 1;
+                ++*numcells;
+                for (j = 0; j < n; ++j)
+                    if (!ISELEMENT(workset,j)) lab[i++] = j;
+                ptn[n-1] = 0;
+                return;
+            }
+        }
+        else if (c == '\n')
+        {
+            if (prompt) fprintf(PROMPTFILE,"] ");
+        }
+        else
+            fprintf(ERRFILE,"illegal character '%c' in partition\n\n",c);
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  unitptn(lab,ptn,&numcells,n) establishes the partition with one cell.     *
+*                                                                            *
+*****************************************************************************/
+
+void
+unitptn(int *lab,int *ptn, int *numcells, int n)
+{
+    int i;
+
+    for (i = 0; i < n; ++i)
+    {
+        lab[i] = i;
+        ptn[i] = NAUTY_INFINITY;
+    }
+    ptn[n-1] = 0;
+    *numcells = 1;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  individualise(lab,ptn,level,v,&pos,&numcells,n) individualises vertex v.  *
+*  numcells is updated and the position of the possibly-new singleton is     *
+*  returned in pos.                                                          *
+*                                                                            *
+*****************************************************************************/
+
+void
+individualise(int *lab,int *ptn, int level,
+				int v, int *pos, int *numcells, int n)
+{
+    int i,j;
+
+    for (i = 0; i < n; ++i) if (lab[i] == v) break;
+
+    for (j = i; j > 0 && ptn[j-1] > level; --j) {};
+
+    *pos = j;
+    if (ptn[j] <= level) return;   /* individual already */
+
+    lab[i] = lab[j];
+    lab[j] = v;
+    ptn[j] = level;
+    ++*numcells;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  cellstarts(ptn,level,cell,m,n) sets the set cell to contain the indices   *
+*  of the starts in ptn of the partition at level level.                     *
+*                                                                            *
+*****************************************************************************/
+
+void
+cellstarts(int *ptn, int level, set *cell, int m, int n)
+{
+    int i;
+
+    EMPTYSET(cell,m);
+    i = 0;
+    while (i < n)
+    {
+        ADDELEMENT(cell,i);
+        while (ptn[i] > level) ++i;
+        ++i;
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  fixit(lab,ptn,&numcells,fixedvertex,n) establishes the partition          *
+*  with one cell {fixedvertex} and all the other vertices (if any) in        *
+*  another cell.                                                             *
+*                                                                            *
+*****************************************************************************/
+
+void
+fixit(int *lab, int *ptn, int *numcells, int fixedvertex, int n)
+{
+    int i;
+
+    for (i = 1; i < n; ++i)
+    {
+        lab[i] = i;
+        ptn[i] = 1;
+    }
+
+    lab[0] = fixedvertex;
+    lab[fixedvertex] = 0;
+    ptn[0] = 0;
+    ptn[n-1] = 0;
+    if (n == 1) *numcells = 1;
+    else        *numcells = 2;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  sethash(s,n,seed,key) is a function whose value depends only on the       *
+*  set s, a long seed, and an integer key.  It is intended to be independent *
+*  of the word size provided long ints have at least 32 bits, and also       *
+*  independent of m.  n is the underlying universal set size.                *
+*  31 bits of seed and 15 bits of key are significant.                       *
+*  The result is in 0..2^31-1.                                               *
+*                                                                            *
+*****************************************************************************/
+
+long
+sethash(set *s, int n, long seed, int key)
+{
+    int i,j,lsh,rsh;
+    unsigned long l,res,lshmask,salt;
+    setword si;
+
+    lsh = key & 0xF;
+    rsh = 28 - lsh;
+    salt = (key >> 4) & 0x7FFL;
+    res = seed & 0x7FFFFFFFUL;
+    lshmask = (1UL << lsh) - 1;
+
+    j = 0;
+    for (i = 0; ; ++i)
+    {
+        si = s[i];
+        l = SWCHUNK0(si);
+        res = (((res << lsh) ^ ((res >> rsh) & lshmask) ^ l) + salt) 
+                                                            & 0x7FFFFFFFUL;
+	res = FUZZ1(res);
+        if ((j += 16) >= n) break;
+#if WORDSIZE > 16
+        l = SWCHUNK1(si);
+        res = (((res << lsh) ^ ((res >> rsh) & lshmask) ^ l) + salt) 
+                                                           & 0x7FFFFFFFUL;
+	res = FUZZ1(res);
+        if ((j += 16) >= n) break;
+#if WORDSIZE == 64    
+        l = SWCHUNK2(si);
+        res = (((res << lsh) ^ ((res >> rsh) & lshmask) ^ l) + salt) 
+                                                            & 0x7FFFFFFFUL;
+	res = FUZZ1(res);
+        if ((j += 16) >= n) break;
+        l = SWCHUNK3(si);
+        res = (((res << lsh) ^ ((res >> rsh) & lshmask) ^ l) + salt) 
+                                                            & 0x7FFFFFFFUL;
+	res = FUZZ1(res);
+        if ((j += 16) >= n) break;
+#endif
+#endif
+    }
+
+    return res;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  listhash(x,nx,key) is a function whose value depends on the SET of values *
+*  in the first 'nx' entries of the array 'x', and the value of key.         *
+*  Machine-independent if long ints have at least 32 bits, otherwise not.    *
+*  The result is in 0..2^31-1.                                               *
+*                                                                            *
+*****************************************************************************/
+
+long
+listhash(int *x, int nx, long key)
+{
+    unsigned long lkey,val,accum;
+    int i;
+
+    lkey = (unsigned long)key & 0x7FFFFFFFUL;
+    accum = nx;
+    
+    for (i = 0; i < nx; ++i)
+    {
+	val = (unsigned long)x[i] & 0x7FFFFFFFUL;
+	val = (val + lkey) & 0x7FFFFFFFUL;
+	accum += FUZZ1(val);
+    }
+
+    return  accum & 0x7FFFFFFFUL;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  hashgraph_sg(sg,key) is a function whose value depends on the sparse      *
+*  graph or digraph sg.                                                      *
+*  Machine-independent if long ints have at least 32 bits, otherwise not.    *
+*  The result is in 0..2^31-1.                                               *
+*                                                                            *
+*****************************************************************************/
+
+long
+hashgraph_sg(sparsegraph *sg, long key)
+{
+    int n,i;
+    int *d,*e;
+    size_t *v;
+    unsigned long val,accum;
+
+    CHECK_SWG(sg,"hashgraph_sg");
+    accum = n = sg->nv;
+
+    SG_VDE(sg,v,d,e);
+
+    for (i = 0; i < n; ++i)
+        if (d[i] == 0)
+	    accum += FUZZ1(i);
+        else
+        {
+	    accum = (accum>>7) | ((accum<<24)&0x7FFFFFFFUL);
+	    val = listhash(e+v[i],d[i],key);
+	    val = (val + i) & 0x7FFFFFFFUL;
+	    accum += FUZZ2(val);
+	}
+
+   return (long)(accum & 0x7FFFFFFFUL);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  hashgraph(g,m,n,key) is a function whose value depends on the             *
+*  graph or digraph sg.                                                      *
+*  Machine-independent if long ints have at least 32 bits, otherwise not.    *
+*  The result is in 0..2^31-1.                                               *
+*                                                                            *
+*****************************************************************************/
+
+long
+hashgraph(graph *g, int m, int n, long key)
+{
+    int i;
+    set *gi;
+    unsigned long val,accum;
+
+    accum = n;
+    for (i = 0, gi = g; i < n; ++i, gi += m)
+    {
+	accum = (accum>>12) | ((accum<<19)&0x7FFFFFFFUL);
+	val = sethash(gi,n,key,(key&0xFL)+i);
+	val = (val + i) & 0x7FFFFFFFUL;
+        accum += FUZZ2(val);
+    }
+
+    return (long)(accum & 0x7FFFFFFFUL);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  hash(setarray,length,key) is a function whose value depends only on the   *
+*  first 'length' entries of the array 'setarray', and the value of key.     *
+*  key should be in the range 1..31 and preferably odd.                      *
+*  This works best if long ints have at least 32 bits, but it's valid anyway.*
+*  Not machine-indpendent!  Use sethash() in preference.                     *
+*                                                                            *
+*****************************************************************************/
+
+long
+hash(set *setarray, long length, int key)
+{
+    long code;
+    set *sptr;
+
+    code = length;
+    sptr = setarray + length;
+
+    while (--sptr >= setarray)
+        code = (code<<key) ^ ((code>>(32-key)) + *sptr);
+
+    return code;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  readperm is like readvperm without the last argument.  It is provided     *
+*  only for backward compatibility.                                          *
+*                                                                            *
+*****************************************************************************/
+
+void
+readperm(FILE *f, int *perm, boolean prompt, int n)
+{
+    int nv;
+
+    readvperm(f,perm,prompt,n,&nv);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  readvperm(f,perm,prompt,n,nv) reads a permutation of order n from         *
+*  f, terminated by a semicolon.  Any repeated or illegal numbers or         *
+*  characters are reported then ignored.    Missing numbers are filled in    *
+*  in numerical order.  A prompt is issued for each line if prompt!=FALSE.   *
+*  labelorg is used.  *nv is set equal to the number of numbers actually     *
+*  given.  Ranges like v1:v2 are allowed.                                    *
+*                                                                            *
+*****************************************************************************/
+
+void
+readvperm(FILE *f, int *perm, boolean prompt, int n, int *nv)
+{
+    int i;
+    int m,c,v1,v2;
+
+    m = SETWORDSNEEDED(n);
+#if !MAXN
+    DYNALLOC1(set,workset,workset_sz,m,"readperm");
+#endif
+
+    EMPTYSET(workset,m);
+
+    i = 0;
+
+    while (TRUE)
+    {
+        GETNWC(c,f);
+        if (c == ';' || c == EOF) break;
+        if (ISDIGIT(c))
+        {
+            ungetc(c,f);
+            readinteger(f,&v1);
+            v1 -= labelorg;
+            GETNWC(c,f);
+            if (c == ':')
+                if (!readinteger(f,&v2))
+                {
+                    fprintf(ERRFILE,"unfinished range\n\n");
+                    v2 = v1;
+                }
+                else
+                    v2 -= labelorg;
+            else
+            {
+                ungetc(c,f);
+                v2 = v1;
+            }
+
+            if (v1 < 0 || v1 >= n || v2 >= n || v1 > v2)
+            {
+                if (v1 < v2)
+                    fprintf(ERRFILE,
+                      "illegal range in permutation : %d:%d\n\n",
+                      v1+labelorg,v2+labelorg);
+                else
+                    fprintf(ERRFILE,
+                      "illegal number in permutation : %d\n\n",
+                      v1+labelorg);
+            }
+            else
+            for (; v1 <= v2; ++v1)
+            {
+                if (!ISELEMENT(workset,v1))
+                {
+                    perm[i++] = v1;
+                    ADDELEMENT(workset,v1);
+                }
+                else
+                    fprintf(ERRFILE,
+                      "repeated number in permutation : %d\n\n",
+                      v1+labelorg);
+            }
+        }
+        else
+        {
+            if (c == '\n' && prompt)
+                fprintf(PROMPTFILE,"+ ");
+            if (c != '\n')
+                fprintf(ERRFILE,"bad character '%c' in permutation\n\n",
+                       (char)c);
+        }
+    }
+
+    *nv = i;
+
+    for (v1 = 0; v1 < n; ++v1)
+        if (!ISELEMENT(workset,v1)) perm[i++] = v1;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  ranperm(perm,n) creates a random permutation in perm.                     *
+*                                                                            *
+*****************************************************************************/
+
+void
+ranperm(int *perm, int n)
+{
+    int i,j,t;
+
+    for (i = n; --i >= 0; ) perm[i] = i;
+
+    for (i = n; --i > 0; )
+    {
+        j = KRAN(i+1);
+        t = perm[i];
+        perm[i] = perm[j];
+        perm[j] = t;
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  relabel(g,perm,lab,workg,m,n) replaces g by g^perm, using workg as        *
+*  scratch space.  If lab!=NULL, it is taken as a labelling vector and       *
+*  also permuted.                                                            *
+*                                                                            *
+*****************************************************************************/
+
+void
+relabel(graph *g, int *lab, int *perm, graph *workg, int m, int n)
+{
+    long li;
+    int i;
+
+    for (li = (long)M * (long)n; --li >= 0;) workg[li] = g[li];
+
+    updatecan(workg,g,perm,0,M,n);
+    if (lab != NULL)
+    {
+#if !MAXN
+        DYNALLOC1(int,workperm,workperm_sz,n+2,"relabel");
+#endif
+        for (i = 0; i < n; ++i) workperm[perm[i]] = i;
+        for (i = 0; i < n; ++i) lab[i] = workperm[lab[i]];
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  relabel_sg(g,perm,lab,workg,m,n) replaces g by g^perm, using workg as     *
+*  scratch space.  If lab!=NULL, it is taken as a labelling vector and       *
+*  also permuted.                                                            *
+*                                                                            *
+*****************************************************************************/
+
+void
+relabel_sg(sparsegraph *sg, int *lab, int *perm, sparsegraph *workg)
+{
+    int i,n;
+    sparsegraph *tempsg;
+    sparsegraph tmp;
+
+    n = sg->nv;
+
+    if (workg)
+    {
+        tempsg = copy_sg(sg,workg);
+        updatecan_sg((graph*)tempsg,(graph*)sg,perm,0,SETWORDSNEEDED(n),n);
+    }
+    else
+    {
+        SG_INIT(tmp);
+        tempsg = copy_sg(sg,&tmp);
+        updatecan_sg((graph*)tempsg,(graph*)sg,perm,0,SETWORDSNEEDED(n),n);
+        SG_FREE(tmp);
+    }
+
+    if (lab != NULL)
+    {
+#if !MAXN
+        DYNALLOC1(int,workperm,workperm_sz,n+2,"relabel_sg");
+#endif
+        for (i = 0; i < n; ++i) workperm[perm[i]] = i;
+        for (i = 0; i < n; ++i) lab[i] = workperm[lab[i]];
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  sublabel(g,perm,nperm,workg,m,n) replaces g by g^perm, using workg as     *
+*  scratch space.  perm is a partial vector, of length nperm, where it is    *
+*  known that the elements of perm are distinct.                             *
+*                                                                            *
+*****************************************************************************/
+
+void
+sublabel(graph *g, int *perm, int nperm, graph *workg, int m, int n)
+{
+    long li;
+    int i,j,k;
+    int newm;
+    set *gi,*wgi;
+
+    for (li = (long)m * (long)n; --li >= 0;) workg[li] = g[li];
+
+    newm = SETWORDSNEEDED(nperm);
+
+    for (li = (long)newm * (long)nperm; --li >= 0;) g[li] = 0;
+
+    for (i = 0, gi = (set*)g; i < nperm; ++i, gi += newm)
+    {
+        wgi = GRAPHROW(workg,perm[i],m);
+        for (j = 0; j < nperm; ++j)
+        {
+            k = perm[j];
+            if (ISELEMENT(wgi,k)) ADDELEMENT(gi,j);
+        }
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  countcells(ptn,level,n) finds the number of elements of ptn[0..n-1]       *
+*  that are <= level.                                                        *
+*                                                                            *
+*****************************************************************************/
+
+int
+countcells(int *ptn, int level, int n)
+{
+    int i,cnt;
+
+    cnt = 0;
+    for (i = 0; i < n; ++i) if (ptn[i] <= level) ++cnt;
+
+    return cnt;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  subpartion(lab,ptn,n,perm,nperm) replaces the partition (lab,ptn) of      *
+*  0..n-1 by the induced partition of 0..nperm-1, using the partial          *
+*  ordering of 0..n-1 given in perm[0..nperm-1].                             *
+*  Return the new number of cells.                                           *
+*                                                                            *
+*****************************************************************************/
+
+#define DEB(str,x) fprintf(stderr,"%s=%d\n",str,x);
+
+int
+subpartition(int *lab, int *ptn, int n, int *perm, int nperm)
+{
+    int i,j;
+
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n+2,"subpartition");
+#endif
+    for (i = 0; i < n; ++i) workperm[i] = -1;
+    for (i = 0; i < nperm; ++i) workperm[perm[i]] = i;
+
+    j = -1;
+    for (i = 0; i < n; ++i)
+    {
+	if (workperm[lab[i]] >= 0)
+	{      
+	    ++j;     
+	    lab[j] = workperm[lab[i]];
+	    ptn[j] = ptn[i];
+	}
+	else if (j >= 0 && ptn[i] < ptn[j])
+	    ptn[j] = ptn[i];
+    }
+
+    return countcells(ptn,0,nperm);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  sublabel_sg(sg,perm,nperm,workg) replaces g by g^perm, using workg as     *
+*  scratch space.  perm is a partial vector, of length nperm, where it is    *
+*  known that the elements of perm are distinct.                             *
+*                                                                            *
+*****************************************************************************/
+
+void
+sublabel_sg(sparsegraph *sg, int *perm, int nperm, sparsegraph *workg)
+{
+    int i,j,k,n;
+    size_t newnde,kk;
+    sparsegraph *tempsg;
+    sparsegraph tmp;
+    int *d,*e;
+    int *dd,*ee;
+    size_t *v,*vv;
+
+    CHECK_SWG(sg,"sublabel_sg");
+    n = sg->nv;
+ 
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n+2,"relabel_sg");
+#endif
+    for (i = 0; i < n; ++i) workperm[i] = -1;
+    for (i = 0; i < nperm; ++i) workperm[perm[i]] = i;
+
+    newnde = 0;
+    SG_VDE(sg,v,d,e);
+
+    for (i = 0; i < nperm; ++i)
+    {
+        j = perm[i];
+        for (k = 0; k < d[j]; ++k)
+            if (workperm[e[v[j]+k]] >= 0) ++newnde;
+    }
+ 
+    if (workg)
+        tempsg = workg;
+    else
+    {
+        SG_INIT(tmp);
+        tempsg = &tmp;
+    }
+ 
+    SG_ALLOC(*tempsg,nperm,newnde,"sublabel_sg");
+    SG_VDE(tempsg,vv,dd,ee);
+
+    kk = 0;
+    for (i = 0; i < nperm; ++i)
+    {
+        j = perm[i];
+        vv[i] = kk;
+        dd[i] = 0;
+        for (k = 0; k < d[j]; ++k)
+            if (workperm[e[v[j]+k]] >= 0)
+            {
+                ee[vv[i]+dd[i]] = workperm[e[v[j]+k]];
+                ++dd[i];
+            }
+	kk += dd[i];
+    }
+    tempsg->nv = nperm;
+    tempsg->nde = newnde;
+
+    copy_sg(tempsg,sg);
+
+    if (!workg) SG_FREE(tmp);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  copycomment(fin,fout,delimiter) copies fin to fout until either EOF or    *
+*  the character 'delimiter' is read.  The delimiter itself isn't written.   *
+*  Escape sequences \n,\t,\b,\r,\f,\\,\',\",\\n are recognised.  Otherwise,  *
+*  '\' is ignored.                                                           *
+*                                                                            *
+*****************************************************************************/
+
+void
+copycomment(FILE *fin, FILE *fout, int delimiter)
+{
+    int c,backslash;
+
+    backslash = FALSE;
+
+    while ((c = getc(fin)) != EOF && (c != delimiter || backslash))
+        if (backslash)
+        {
+            switch (c)
+            {
+            case '\n':
+                break;
+            case 'n':
+                PUTC('\n',fout);
+                break;
+            case 't':
+                PUTC('\t',fout);
+                break;
+            case 'b':
+                PUTC('\b',fout);
+                break;
+            case 'r':
+                PUTC('\r',fout);
+                break;
+            case 'f':
+                PUTC('\f',fout);
+                break;
+            case '\\':
+                PUTC('\\',fout);
+                break;
+            case '\'':
+                PUTC('\'',fout);
+                break;
+            case '"':
+                PUTC('"',fout);
+                break;
+            default:
+                PUTC(c,fout);
+            }
+            backslash = FALSE;
+        }
+        else if (c == '\\')
+            backslash = TRUE;
+        else
+            PUTC(c,fout);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  converse_sg(g1,g2) performs a digraph converse operation on g1,           *
+*  leaving the result in g2. g2 must exist and be initialised.               *
+*  If g1 is an undirected graph, g2 will be the same.                        *
+*                                                                            *
+*****************************************************************************/
+
+void
+converse_sg(sparsegraph *g1, sparsegraph *g2)
+{
+    int *e1,*d1,*e2,*d2;
+    size_t *v1,*v2,j;
+    int i,k,n;
+
+    CHECK_SWG(g1,"converse_sg");
+    n = g1->nv;
+
+    SG_ALLOC(*g2,n,g1->nde,"converse_sg");
+    g2->nv = n;
+    g2->nde = g1->nde;
+    DYNFREE(g2->w,g2->wlen);
+
+    SG_VDE(g1,v1,d1,e1);
+    SG_VDE(g2,v2,d2,e2);
+
+    for (i = 0; i < n; ++i) d2[i] = 0;
+    for (i = 0; i < n; ++i)
+        for (j = v1[i]; j < v1[i]+d1[i]; ++j) ++d2[e1[j]];
+
+    v2[0] = 0;
+    for (i = 1; i < n; ++i) v2[i] = v2[i-1] + d2[i-1];
+    for (i = 0; i < n; ++i) d2[i] = 0;
+
+    for (i = 0; i < n; ++i)
+        for (j = v1[i]; j < v1[i]+d1[i]; ++j)
+	{
+	    k = e1[j];
+	    e2[v2[k] + (d2[k]++)] = i;
+	}
+}
+
+/*****************************************************************************
+*                                                                            *
+*  complement_sg(g1,g2) sets g2 to the complement of g1.                     *
+*  If g1 has loops then the loop set is also complemented; otherwise         *
+*  no loops are created.  g2 must exist and be initialised.                  *
+*                                                                            *
+*****************************************************************************/
+
+void
+complement_sg(sparsegraph *g1, sparsegraph *g2)
+{
+    int *e1,*d1,*e2,*d2;
+    size_t *v1,*v2,j,ndec;
+    int i,l,m,n;
+    int loops;
+
+    CHECK_SWG(g1,"complement_sg");
+    n = g1->nv;
+    SG_VDE(g1,v1,d1,e1);
+
+    loops = 0;
+    for (i = 0; i < n; ++i)
+	for (j = v1[i]; j < v1[i] + d1[i]; ++j)
+	    if (e1[j] == i) ++loops;
+
+    if (loops > 1) ndec = n*(size_t)n - g1->nde;
+    else           ndec = n*(size_t)n - n - g1->nde; 
+    SG_ALLOC(*g2,n,ndec,"converse_sg");
+    g2->nv = n;
+    SG_VDE(g2,v2,d2,e2);
+
+    m = SETWORDSNEEDED(n);
+#if !MAXN
+    DYNALLOC1(set,workset,workset_sz,m,"putorbits");
+#endif
+
+    DYNFREE(g2->w,g2->wlen);
+
+    ndec = 0;
+
+    for (i = 0; i < n; ++i)
+    {
+	EMPTYSET(workset,m);
+	for (j = v1[i]; j < v1[i]+d1[i]; ++j) ADDELEMENT(workset,e1[j]);
+	if (loops == 0) ADDELEMENT(workset,i);
+
+	v2[i] = ndec;
+	for (l = 0; l < n; ++l)
+	    if (!ISELEMENT(workset,l)) e2[ndec++] = l;
+	d2[i] = ndec - v2[i];
+    }
+    g2->nde = ndec;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  mathon_sg(g1,g2) performs a Mathon doubling operation on g1,              *
+*  leaving the result in g2. g2 must exist and be initialised.               *
+*                                                                            *
+*****************************************************************************/
+
+void
+mathon_sg(sparsegraph *g1, sparsegraph *g2)
+{
+    int *e1,*d1,*e2,*d2;
+    size_t *v1,*v2,j;
+    int i,k,m,n1,n2;
+
+    CHECK_SWG(g1,"mathon_sg");
+
+    n1 = g1->nv;
+    n2 = 2*n1 + 2;
+    SG_ALLOC(*g2,n2,n2*(size_t)n1,"mathon_sg");
+    g2->nv = n2;
+    g2->nde = n2*(size_t)n1;
+    DYNFREE(g2->w,g2->wlen);
+
+    SG_VDE(g1,v1,d1,e1);
+    SG_VDE(g2,v2,d2,e2);
+
+    m = SETWORDSNEEDED(n1);
+#if !MAXN
+    DYNALLOC1(set,workset,workset_sz,m,"mathon_sg");
+#endif
+
+    for (i = 0; i < n2; ++i)
+    {
+	v2[i] = i*(size_t)n1;
+	d2[i] = 0;
+    }
+
+    for (i = 0; i < n1; ++i)
+    {
+        e2[v2[0]+(d2[0]++)] = i+1;
+        e2[v2[i+1]+(d2[i+1]++)] = 0;
+	e2[v2[n1+1]+(d2[n1+1]++)] = i+n1+2;
+	e2[v2[i+n1+2]+(d2[i+n1+2]++)] = n1+1;
+    }
+
+    for (i = 0; i < n1; ++i)
+    {
+	EMPTYSET(workset,m);
+	for (j = v1[i]; j < v1[i]+d1[i]; ++j)
+	{
+	    k = e1[j];
+	    if (k == i) continue;   /* ignore loops */
+	    ADDELEMENT(workset,k);
+	    e2[v2[i+1]+(d2[i+1]++)] = k+1;
+	    e2[v2[i+n1+2]+(d2[i+n1+2]++)] = k+n1+2;
+	}
+	for (k = 0; k < n1; ++k)
+	    if (k != i && !ISELEMENT(workset,k))
+	    {
+		e2[v2[i+1]+(d2[i+1]++)] = k+n1+2;
+                e2[v2[k+n1+2]+(d2[k+n1+2]++)] = i+1;
+	    }
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  mathon(g1,m1,n1,g2,m2,n2) performs a Mathon doubling operation on g1,     *
+*  leaving the result in g2.                                                 *
+*  m1,n1 and m2,n2 are the values of m,n before and after the operation.     *
+*                                                                            *
+*****************************************************************************/
+
+void
+mathon(graph *g1, int m1, int n1, graph *g2, int m2, int n2)
+{
+    int i,j,ii,jj;
+    long li;
+    set *rowptr,*gp;
+
+    for (li = (long)m2 * (long)n2; --li >= 0;) g2[li] = 0;
+
+    for (i = 1; i <= n1; ++i)
+    {
+        ii = i + n1 + 1;
+        gp = GRAPHROW(g2,0,m2);        /* unnecessarily convoluted code */
+        ADDELEMENT(gp,i);             /* needed to avoid compiler bug  */
+        gp = GRAPHROW(g2,i,m2);        /* in MSDOS version */
+        ADDELEMENT(gp,0);
+        gp = GRAPHROW(g2,n1+1,m2);
+        ADDELEMENT(gp,ii);
+        gp = GRAPHROW(g2,ii,m2);
+        ADDELEMENT(gp,n1+1);
+    }
+
+    for (i = 0, rowptr = g1; i < n1; ++i, rowptr += m1)
+        for (j = 0; j < n1; ++j)
+            if (j != i)
+            {
+                ii = i + n1 + 2;
+                jj = j + n1 + 2;
+                if (ISELEMENT(rowptr,j))
+                {
+                    gp = GRAPHROW(g2,i+1,m2);
+                    ADDELEMENT(gp,j+1);
+                    gp = GRAPHROW(g2,ii,m2);
+                    ADDELEMENT(gp,jj);
+                }
+                else
+                {
+                    gp = GRAPHROW(g2,i+1,m2);
+                    ADDELEMENT(gp,jj);
+                    gp = GRAPHROW(g2,ii,m2);
+                    ADDELEMENT(gp,j+1);
+                }
+            }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  rangraph(g,digraph,invprob,m,n) makes a random graph (or digraph if       *
+*  digraph!=FALSE) with edge probability 1/invprob.                          *
+*                                                                            *
+*****************************************************************************/
+
+void
+rangraph(graph *g, boolean digraph, int invprob, int m, int n)
+{
+    int i,j;
+    long li;
+    set *row,*col;
+
+    for (li = (long)m * (long)n; --li >= 0;) g[li] = 0;
+
+    for (i = 0, row = g; i < n; ++i, row += m)
+        if (digraph)
+        {
+            for (j = 0; j < n; ++j)
+                if (KRAN(invprob) == 0) ADDELEMENT(row,j);
+        }
+        else
+        {
+            for (j = i + 1, col = GRAPHROW(g,j,m); j < n; ++j, col += m)
+                if (KRAN(invprob) == 0)
+                {
+                    ADDELEMENT(row,j);
+                    ADDELEMENT(col,i);
+                }
+        }
+}
+
+
+/*****************************************************************************
+*                                                                            *
+*  rangraph2(g,digraph,p1,p2,m,n) makes a random graph (or digraph if        *
+*  digraph!=FALSE) with edge probability p1/p2.                              *
+*                                                                            *
+*****************************************************************************/
+
+void
+rangraph2(graph *g, boolean digraph, int p1, int p2, int m, int n)
+{
+    int i,j;
+    long li;
+    set *row,*col;
+
+    for (li = (long)m * (long)n; --li >= 0;) g[li] = 0;
+
+    for (i = 0, row = g; i < n; ++i, row += m)
+        if (digraph)
+        {
+            for (j = 0; j < n; ++j)
+                if (KRAN(p2) < p1) ADDELEMENT(row,j);
+        }
+        else
+            for (j = i + 1, col = GRAPHROW(g,j,m); j < n; ++j, col += m)
+                if (KRAN(p2) < p1)
+                {
+                    ADDELEMENT(row,j);
+                    ADDELEMENT(col,i);
+                }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  rangraph2_sg(sg,digraph,p1,p2,n) makes a random graph (or digraph if    *
+*  digraph!=FALSE) with edge probability p1/p2. sg must be initialised.      *
+*                                                                            *
+*****************************************************************************/
+
+void
+rangraph2_sg(sparsegraph *sg, boolean digraph, int p1, int p2, int n)
+{
+    int i,j,k;
+    int *dd,*ee;
+    double rn,expec,var,sd;
+    int ldeg;
+    size_t *vv,inc,nde;
+ 
+    sg->nv = n;
+
+    rn = n;
+    expec = (rn*rn-rn)*(double)p1/(double)p2;
+    var = expec*(double)(p2-p1)/(double)p2;
+    if (!digraph) var *= 2.0;
+    sd = 1.0;
+    if (var > 1.0)
+        for (i = 0; i < 19; ++i) sd = (sd + var/sd) / 2.0;
+    inc = sd + 20;
+ 
+    SG_ALLOC(*sg,n,(size_t)expec+4*inc,"rangraph2_sg");
+    SG_VDE(sg,vv,dd,ee);
+    DYNFREE(sg->w,sg->wlen);
+
+    for (i = 0; i < n; ++i) dd[i] = 0;
+    vv[0] = 0;
+    nde = 0;
+
+    if (!digraph)
+    {
+	for (i = 0; i < n; ++i)
+	{
+	    ldeg = 0;
+	    for (j = i+1; j < n; ++j)
+	    if (KRAN(p2) < p1)
+	    {
+		nde += 2;
+		if (nde > sg->elen)
+		{
+		    DYNREALLOC(int,sg->e,sg->elen,sg->elen+inc,
+						"rangraph2_sg realloc");
+		    ee = sg->e;
+		}
+		ee[vv[i]+ldeg++] = j;
+		++dd[j];
+	    }
+	    if (i < n-1) vv[i+1] = vv[i] + dd[i] + ldeg;
+	    dd[i] = ldeg;
+	}
+        for (i = 0; i < n; ++i)
+	    for (k = 0; k < dd[i]; ++k)
+	    {
+		j = ee[vv[i]+k];
+		if (j > i) ee[vv[j]+dd[j]++] = i;
+	    }
+	sg->nde = nde;	
+    }
+    else
+    {
+	for (i = 0; i < n; ++i)
+        {
+            ldeg = 0;
+            for (j = 0; j < n; ++j)
+            if (j != i && KRAN(p2) < p1)
+            {
+                ++nde;
+                if (nde > sg->elen)
+                {
+                    DYNREALLOC(int,sg->e,sg->elen,sg->elen+inc,
+                                             "rangraph2_sg realloc");
+                    ee = sg->e;
+                }
+                ee[vv[i]+ldeg++] = j;
+            }
+	    if (i < n-1) vv[i+1] = vv[i] + ldeg;
+            dd[i] = ldeg;
+        }
+	sg->nde = nde;	
+    }
+}
+
+/****************************************************************************/
+
+static void
+putsequence(FILE *f, int *x, int linelength, int n)
+/* Write n integers to f with equal values collapsed.
+ * labelorg is used. */
+{
+    char s[60];
+    int j,v1,v2,xval,curlen;
+
+    curlen = 0;
+    v1 = 0;
+    while (v1 < n)
+    {
+        xval = x[v1];
+
+        for (v2 = v1; v2 < n - 1 && x[v2+1] == xval; ++v2) {}
+        j = itos(v1+labelorg,s);
+        if (v2 > v1)
+        {
+            s[j++] = '-';
+            j += itos(v2+labelorg,&s[j]);
+        }
+        s[j++] = ':';
+        j += itos(xval,&s[j]);
+        s[j] = ' ';
+        s[j+1] = '\0';
+        if (linelength > 0 && curlen + j >= linelength)
+        {
+            PUTC('\n',f);
+            curlen = 0;
+        }
+        curlen += j + 1;
+        putstring(f,s);
+        v1 = v2 + 1;
+    }
+    PUTC('\n',f);
+}
+
+/****************************************************************************/
+
+static void
+putnumbers(FILE *f, int *x, int linelength, int n)
+/* Write n integers to f with equal values combined as multiplicities.
+ * labelorg is NOT used. */
+{
+    char s[60];
+    int j,v1,v2,xval,curlen;
+
+    curlen = 0;
+    v1 = 0;
+    while (v1 < n)
+    {
+        xval = x[v1];
+
+        for (v2 = v1; v2 < n - 1 && x[v2+1] == xval; ++v2) {}
+	if (v2 > v1)
+	{
+	    j = itos(v2-v1+1,s);
+	    s[j++] = '*';
+	}
+	else
+	    j = 0;
+
+        j += itos(xval,&s[j]);
+        s[j] = ' ';
+        s[j+1] = '\0';
+        if (linelength > 0 && curlen + j >= linelength)
+        {
+            PUTC('\n',f);
+            curlen = 0;
+        }
+        curlen += j + 1;
+        putstring(f,s);
+        v1 = v2 + 1;
+    }
+    PUTC('\n',f);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  putdegs(f,g,linelength,m,n)  writes the degree of each vertex of g to     *
+*  file f, using at most linelength characters per line (excluding '\n').    *
+*  A value of linelength <= 0 dictates no line breaks at all.                *
+*  labelorg is used.                                                         *
+*                                                                            *
+*  FUNCTIONS CALLED : itos(),putstring(),setsize()                           *
+*                                                                            *
+*****************************************************************************/
+
+void
+putdegs(FILE *f, graph *g, int linelength, int m, int n)
+{
+    int i;
+    graph *gp;
+
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n+2,"putdegs");
+#endif
+
+    for (i = 0, gp = g; i < n; ++i, gp += M)
+        workperm[i] = setsize(gp,m);
+
+    putsequence(f,workperm,linelength,n);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  putdegseq(f,g,linelength,m,n)  writes the sorted degree sequence of g     *
+*  file f, using at most linelength characters per line (excluding '\n').    *
+*  A value of linelength <= 0 dictates no line breaks at all.                *
+*                                                                            *
+*****************************************************************************/
+
+void
+putdegseq(FILE *f, graph *g, int linelength, int m, int n)
+{
+    int i;
+    graph *gp;
+
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n,"putdegs");
+#endif
+
+    for (i = 0, gp = g; i < n; ++i, gp += M)
+        workperm[i] = setsize(gp,m);
+
+    sort1int(workperm,n);
+    putnumbers(f,workperm,linelength,n);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  putdegs_sg(f,sg,linelength)  writes the degree of each vertex of sg to    *
+*  file f, using at most linelength characters per line (excluding '\n').    *
+*  A value of linelength <= 0 dictates no line breaks at all.                *
+*  labelorg is used.                                                         *
+*                                                                            *
+*  FUNCTIONS CALLED : itos(),putstring(),                                    *
+*                                                                            *
+*****************************************************************************/
+
+void
+putdegs_sg(FILE *f, sparsegraph *sg, int linelength)
+{
+    putsequence(f,sg->d,linelength,sg->nv);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  putdegseq_sg(f,sg,linelength) writes the sorted degree sequence of sg to  *
+*  file f, using at most linelength characters per line (excluding '\n').    *
+*  A value of linelength <= 0 dictates no line breaks at all.                *
+*                                                                            *
+*****************************************************************************/
+
+void
+putdegseq_sg(FILE *f, sparsegraph *sg, int linelength)
+{
+    int i;
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,sg->nv,"putdegs");
+#endif
+
+    for (i = 0; i < sg->nv; ++i)
+        workperm[i] = sg->d[i];
+
+    sort1int(workperm,sg->nv);
+    putnumbers(f,workperm,linelength,sg->nv);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  complement(g,m,n) replaces the graph g by its complement                  *
+*  No loops are created unless there are loops present, in which case the    *
+*  loops are also complemented.                                              *
+*                                                                            *
+*****************************************************************************/
+
+void
+complement(graph *g, int m, int n)
+{
+    boolean loops;
+    int i,j;
+    graph *gp;
+
+#if !MAXN
+    DYNALLOC1(set,workset,workset_sz,m,"complement");
+#endif
+
+    loops = FALSE;
+    for (i = 0, gp = g; i < n && !loops; ++i, gp += M)
+        if (ISELEMENT(gp,i)) loops = TRUE;
+
+    EMPTYSET(workset,m);
+    for (i = 0; i < n; ++ i) ADDELEMENT(workset,i);
+
+    for (i = 0, gp = g; i < n; ++i, gp += M)
+    {
+        for (j = 0; j < M; ++j) gp[j] = workset[j] & ~gp[j];
+        if (!loops) DELELEMENT(gp,i);
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  converse(g,m,n) replaces the digraph g by its converse.                   *
+*  There is no effect on an undirected graph.                                *
+*                                                                            *
+*****************************************************************************/
+
+void
+converse(graph *g, int m, int n)
+{
+    int i,j;
+    graph *gi,*gj;
+
+    for (i = 0, gi = g; i < n; ++i, gi += M)
+        for (j = i+1, gj = gi+M; j < n; ++j, gj += M)
+            if ((ISELEMENT(gi,j)!=0) + (ISELEMENT(gj,i)!=0) == 1)
+            {
+                FLIPELEMENT(gi,j);
+                FLIPELEMENT(gj,i);
+            }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  naututil_check() checks that this file is compiled compatibly with the    *
+*  given parameters.   If not, call exit(1).                                 *
+*                                                                            *
+*****************************************************************************/
+
+void
+naututil_check(int wordsize, int m, int n, int version)
+{
+    if (wordsize != WORDSIZE)
+    {
+        fprintf(ERRFILE,"Error: WORDSIZE mismatch in naututil.c\n");
+        exit(1);
+    }
+
+#if MAXN
+    if (m > MAXM)
+    {
+        fprintf(ERRFILE,"Error: MAXM inadequate in naututil.c\n");
+        exit(1);
+    }
+
+    if (n > MAXN)
+    {
+        fprintf(ERRFILE,"Error: MAXN inadequate in naututil.c\n");
+        exit(1);
+    }
+#endif
+
+    if (version < NAUTYREQUIRED)
+    {
+        fprintf(ERRFILE,"Error: naututil.c version mismatch\n");
+        exit(1);
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  naututil_freedyn() - free the dynamic memory in this module               *
+*                                                                            *
+*****************************************************************************/
+
+void
+naututil_freedyn(void)
+{
+    echunk *ec1,*ec2;
+
+#if !MAXN
+    DYNFREE(workperm,workperm_sz);
+    DYNFREE(workset,workset_sz);
+#endif
+    ec1 = first_echunk.next;
+
+    while (ec1)
+    {
+        ec2 = ec1->next;
+        FREES(ec1);
+        ec1 = ec2;
+    }
+}
diff --git a/lib/nauty/naututil.h b/lib/nauty/naututil.h
new file mode 100644
index 0000000..c9f6bee
--- /dev/null
+++ b/lib/nauty/naututil.h
@@ -0,0 +1,289 @@
+/*****************************************************************************
+* This is the header file for versions 2.6 of naututil.c and dreadnaut.c.    *
+* naututil.h.  Generated from naututil-h.in by configure.
+*****************************************************************************/
+
+/* The parts between the ==== lines are modified by configure when
+creating naututil.h out of naututil-h.in.  If configure is not being
+used, it is necessary to check they are correct.
+====================================================================*/
+
+/* Check whether various headers are available */
+
+#define HAVE_ISATTY  1     /* if isatty() is available */
+#define HAVE_TIMES  1      /* if times() is available */
+#define HAVE_TIME  1      /* if time() is available */
+#define HAVE_GETRUSAGE 1  /* if getrusage() is available */
+#define HAVE_GETTIMEOFDAY  1  /* if gettimeofday() */
+
+/*==================================================================*/
+
+/*****************************************************************************
+*                                                                            *
+*   Copyright (1984-2016) Brendan McKay.  All rights reserved.               *
+*   Subject to the waivers and disclaimers in nauty.h.                       *
+*                                                                            *
+*   CHANGE HISTORY                                                           *
+*       10-Nov-87 : final changes for version 1.2                            *
+*        5-Dec-87 : changes for version 1.3 :                                *
+*                   - added declarations of readinteger() and readstring()   *
+*                   - added definition of DEFEXT : default file-name         *
+*                     extension for dreadnaut input files                    *
+*       28-Sep-88 : changes for version 1.4 :                                *
+*                   - added support for PC Turbo C                           *
+*       29-Nov-88 : - added getc macro for AZTEC C on MAC                    *
+*       23-Mar-89 : changes for version 1.5 :                                *
+*                   - added DREADVERSION macro                               *
+*                   - added optional ANSI function prototypes                *
+*                   - changed file name to naututil.h                        *
+*                   - moved ALLOCS to nauty.h and defined DYNALLOC           *
+*       25-Mar-89 : - added declaration of twopaths()                        *
+*       29-Mar-89 : - added declaration of putmapping()                      *
+*        4-Apr-89 : - added declarations of triples, quadruples, adjtriang   *
+*                   - only define ERRFILE if not in nauty.h                  *
+*       25-Apr-89 : - added declarations of cellquads,distances,getbigcells  *
+*       26-Apr-89 : - added declarations of indsets,cliques,cellquins        *
+*                   - removed declarations of ptncode and equitable          *
+*       27-Apr-89 : - added declaration of putquotient                       *
+*       18-Aug-89 : - added new arg to putset, and changed mathon            *
+*        2-Mar-90 : - added declarations of celltrips, cellcliq, cellind     *
+*                   - changed declarations to use EXTPROC                    *
+*       12-Mar-90 : - added changes for Cray version                         *
+*       20-Mar-90 : - added changes for THINK version                        *
+*       27-Mar-90 : - split SYS_MSDOS into SYS_PCMS4 and SYS_PCMS5           *
+*       13-Oct-90 : changes for version 1.6 :                                *
+*                   - changed CPUTIME to use HZ on Unix for times()          *
+*       14-Oct-90 : - added SYS_APOLLO variant                               *
+*       19-Oct-90 : - changed CPUTIME defs for BSDUNIX to avoid conficting   *
+*                     declarations of size_t and ptrdiff_t in gcc            *
+*       27-Aug-92 : changes for version 1.7 :                                *
+*                   - added SYS_IBMC variant                                 *
+*                   - removed workaround for bad gcc installation            *
+*        5-Jun-93 : changes for version 1.8 :                                *
+*                   - changed CRAY version of CPUTIME to use CLK_TCK         *
+*                     if HZ could not be found (making 1.7+)                 *
+*       30-Jul-93 : - added SYS_ALPHA variant                                *
+*       17-Sep-93 : changes for version 1.9 :                                *
+*                   - declared adjacencies()                                 *
+*       24-Feb-94 : changes for version 1.10 :                               *
+*                   - added version SYS_AMIGAAZT (making 1.9+)               *
+*       19-Apr-95 : - added C++ prototype wrapper                            *
+*        6-Mar-96 : - added SYS_ALPHA32 code                                 *
+*       23-Jul-96 : changes for version 2.0 :                                *
+*                   - changed readstring() declaration                       *
+*                   - removed DYNALLOC definition                            *
+*                   - added sublabel() definition                            *
+*       15-Aug-96 : - added sethash() definition                             *
+*       30-Aug-96 : - added KRAN and D. Knuth routines                       *
+*       16-Sep-96 : - fixed the above!                                       *
+*        7-Feb-96 : - declared nautinv_null() and setnbhd()                  *
+*        4-Sep-97 : - arg of time() is type time_t*, was long*               *
+*       22-Sep-97 : - defined fileno() and time_t for SYS_PCTURBO            *
+*       10-Dec-97 : - revised KRAN for new rng.c from Knuth                  *
+*       18-Feb-98 : - changed time() to time_t for Unix                      *
+*       21-Oct-98 : - changed short to shortish as needed                    *
+*        9-Jan-00 : - declared nautinv_check() and naututil_check()          *
+*       16-Nov-00 : - applied changes logged in nauty.h                      *
+*       22-Apr-01 : changes for version 2.1 :                                *
+*                   - prototypes for nautinv.c are now in nautinv.h          *
+*                   - CPUTIME for UNIX uses CLK_TCK (needs revision!)        *
+*        2-Jun-01 : - prototype for converse()                               *
+*       18-Oct-01 : - complete revision; sysdeps in separate files           *
+*       28-Aug-02 : changes for version 2.2 :                                *
+*                   - revised for autoconf                                   *
+*       17-Nov-02 : added explicit "extern" where it was implicit before     *
+*       11-Apr-02 : added rangraph2()                                        *
+*       10-Sep-07 : Define CPUTIME=0.0 for hosts that don't provide it       *
+*        4-Nov-09 : added readgraph_sg(), putgraph_sg(), putcanon_sg()       *
+*       10-Nov-09 : removed types shortish and permutation                   *
+*       14-Nov-09 : added relabel_sg(), copy_sg(), putdegs_sg(),             *
+*                    sublabel_sg()                                           *
+*       19-Nov-09 : added individualise()                                    *
+*       20-Nov-09 : added hashgraph_sg(), listhash(), hashgraph()            *
+*       19-Dec-09 : added ranreg(), rangraph2_sg()                           *
+*        5-Jun-10 : added mathon_sg() and converse_sg()                      *
+*       10-Jun-10 : added putquotient_sg() and complement_sg()               *
+*       15-Jan-12 : added TLS_ATTR to static declarations                    *
+*        3-Mar-12 : added putorbitsplus() and putset_firstbold()             *
+*       17-Mar-12 : include naurng.h and remove redundant lines              *
+*        1-Nov-15 : changes for version 2.6 :                                *
+*                 - prototypes for putdegseq(), putdegseq_sg()               *
+*       17-Dec-15 : prototype for readgraph_swg()                            *
+*        6-Apr-16 : prototype for countcells()                               *
+*                                                                            *
+* ++++++ This file is automatically generated, don't edit it by hand! ++++++
+*                                                                            *
+*****************************************************************************/
+
+#include "nauty.h"              /* which includes stdio.h */
+#include "nausparse.h"
+#include "naurng.h"
+/* At this point we can assume that <sys/types.h>, <unistd.h>, <stddef.h>,
+   <stdlib.h>, <string.h> or <strings.h> and <malloc.h> if necessary have
+   been included if they exist. */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void complement(graph*,int,int);
+extern void converse(graph*,int,int);
+extern void converse_sg(sparsegraph*, sparsegraph*);
+extern void copycomment(FILE*,FILE*,int);
+extern void complement_sg(sparsegraph*, sparsegraph*);
+extern int countcells(int*,int,int);
+extern void flushline(FILE*);
+extern void fixit(int*,int*,int*,int,int);
+extern int getint(FILE*);
+extern int getint_sl(FILE*);
+extern long hash(set*,long,int);
+extern long hashgraph(graph*,int,int,long);
+extern long hashgraph_sg(sparsegraph*,long);
+extern void individualise(int*,int*,int,int,int*,int*,int);
+extern long listhash(int*,int,long);
+extern void mathon(graph*,int,int,graph*,int,int);
+extern void mathon_sg(sparsegraph*,sparsegraph*);
+extern void naututil_check(int,int,int,int);
+extern void naututil_freedyn(void);
+extern void putcanon(FILE*,int*,graph*,int,int,int);
+extern void putcanon_sg(FILE*,int*,sparsegraph*,int);
+extern void putdegs(FILE*,graph*,int,int,int);
+extern void putdegs_sg(FILE*,sparsegraph*,int);
+extern void putdegseq(FILE*,graph*,int,int,int);
+extern void putdegseq_sg(FILE*,sparsegraph*,int);
+extern void putgraph(FILE*,graph*,int,int,int);
+extern void putgraph_sg(FILE*,sparsegraph*,int);
+extern void putmapping(FILE*,int*,int,int*,int,int,int);
+extern void putorbits(FILE*,int*,int,int);
+extern void putorbitsplus(FILE*,int*,int,int);
+extern void putptn(FILE*,int*,int*,int,int,int);
+extern void putquotient(FILE*,graph*,int*,int*,int,int,int,int);
+extern void putquotient_sg(FILE*,sparsegraph*,int*,int*,int,int);
+extern void putset(FILE*,set*,int*,int,int,boolean);
+extern void putset_firstbold(FILE*,set*,int*,int,int,boolean);
+extern void rangraph(graph*,boolean,int,int,int);
+extern void rangraph2(graph*,boolean,int,int,int,int);
+extern void rangraph2_sg(sparsegraph*,boolean,int,int,int);
+extern void ranreg_sg(sparsegraph *sg, int degree, int n);
+extern void ranperm(int*,int);
+extern void readgraph(FILE*,graph*,boolean,boolean,boolean,int,int,int);
+extern void readgraph_sg(FILE*,sparsegraph*,boolean,boolean,int,int);
+extern void readgraph_swg(FILE*,sparsegraph*,boolean,boolean,int,int);
+extern boolean readinteger(FILE*,int*);
+extern boolean readinteger_sl(FILE*,int*);
+extern void readperm(FILE*,int*,boolean,int);
+extern void readptn(FILE*,int*,int*,int*,boolean,int);
+extern void readvperm(FILE*,int*,boolean,int,int*);
+extern boolean readstring(FILE*,char*,int);
+extern void relabel(graph*,int*,int*,graph*,int,int);
+extern void relabel_sg(sparsegraph*,int*,int*,sparsegraph*);
+extern long sethash(set*,int,long,int);
+extern int setinter(set*,set*,int);
+extern int setsize(set*,int);
+extern void sublabel(graph*,int*,int,graph*,int,int);
+extern void sublabel_sg(sparsegraph*,int*,int,sparsegraph*);
+extern int subpartition(int*,int*,int,int*,int);
+extern void unitptn(int*,int*,int*,int);
+
+#ifdef __cplusplus
+}
+#endif
+
+#define MAXREG 8    /* Used to limit ranreg_sg() degree */
+
+#define PROMPTFILE stdout    /* where to write prompts */
+#ifndef ERRFILE
+#define ERRFILE stderr       /* where to write error messages */
+#endif
+#define MAXIFILES 10         /* how many input files can be open at once */
+#define EXIT exit(0)         /* how to stop normally */
+#define DEFEXT ".dre"        /* extension for dreadnaut files */
+
+/*************************************************************************
+ The following macros may represent differences between system.  This
+ file contains the UNIX/POSIX editions.  For other systems, a separate
+ file of definitions is read in first.  That file should define the
+ variables NAUTY_*_DEFINED for sections that are to replace the UNIX
+ versions.  See the provided examples for more details.
+
+ If your system does not have a predefined macro you can use to cause
+ a definitions file to be read, you have to make up one and arrange for
+ it to be defined when this file is read.
+
+ The system-dependent files can also redefine the macros just ahead of
+ this comment.
+**************************************************************************/
+
+#ifdef __weirdmachine__
+#include "weird.h"  /* Some weird machine (ILLUSTRATION ONLY) */
+#endif
+
+/*************************************************************************/
+
+#ifndef NAUTY_PROMPT_DEFINED
+#if HAVE_ISATTY
+#define DOPROMPT(fp) (isatty(fileno(fp)) && isatty(fileno(PROMPTFILE)))
+#else
+#define DOPROMPT(fp) (curfile==0)
+#endif
+#endif /*NAUTY_PROMPT_DEFINED*/
+
+/*************************************************************************/
+
+#ifndef NAUTY_OPEN_DEFINED
+#define OPENOUT(fp,name,append) fp = fopen(name,(append)?"a":"w")
+#endif /*NAUTY_OPEN_DEFINED*/
+
+/*************************************************************************/
+
+#ifndef NAUTY_CPU_DEFINED
+#if HAVE_TIMES
+#include <sys/times.h>
+#define CPUDEFS static TLS_ATTR struct tms timebuffer;
+#ifndef CLK_TCK
+#include <time.h>
+#endif
+#if !defined(CLK_TCK) && defined(_SC_CLK_TCK)
+#define CLK_TCK sysconf(_SC_CLK_TCK)
+#endif
+#ifndef CLK_TCK
+#define CLK_TCK 60
+#endif
+#define CPUTIME (times(&timebuffer),\
+              (double)(timebuffer.tms_utime + timebuffer.tms_stime) / CLK_TCK)
+#else
+#if HAVE_GETRUSAGE
+#include <sys/time.h>
+#include <sys/resource.h>
+#define CPUDEFS struct rusage ruse;
+#define CPUTIME (getrusage(RUSAGE_SELF,&ruse),\
+  ruse.ru_utime.tv_sec + ruse.ru_stime.tv_sec + \
+  1e-6 * (ruse.ru_utime.tv_usec + ruse.ru_stime.tv_usec))
+#endif
+#endif
+
+#ifndef CPUTIME
+#define CPUTIME 0.0
+#endif
+
+#endif /*NAUTY_CPU_DEFINED*/
+
+/*************************************************************************/
+
+#ifndef NAUTY_SEED_DEFINED
+#if HAVE_GETTIMEOFDAY
+#include <sys/time.h>
+#define INITSEED \
+{struct timeval nauty_tv; \
+ struct timezone nauty_tz; \
+ gettimeofday(&nauty_tv,&nauty_tz); \
+ seed = ((nauty_tv.tv_sec<<10) + (nauty_tv.tv_usec>>10)) & 0x7FFFFFFFL;}
+#else
+#if HAVE_TIME
+#include <time.h>
+#define INITSEED  seed = ((time((time_t*)NULL)<<1) | 1) & 0x7FFFFFFFL
+#endif
+#endif
+#endif /*NAUTY_SEED_DEFINED*/
+
+/* ++++++ This file is automatically generated, don't edit it by hand! ++++++ */
diff --git a/lib/nauty/nauty-h.in b/lib/nauty/nauty-h.in
new file mode 100644
index 0000000..fe1defa
--- /dev/null
+++ b/lib/nauty/nauty-h.in
@@ -0,0 +1,1225 @@
+/**************************************************************************
+*    This is the header file for Version 2.6 of nauty().                  *
+*    @configure_input@
+**************************************************************************/
+
+#ifndef  _NAUTY_H_    /* only process this file once */
+#define  _NAUTY_H_
+
+/* The parts between the ==== lines are modified by configure when
+creating nauty.h out of nauty-h.in.  If configure is not being used,
+it is necessary to check they are correct.
+====================================================================*/
+
+/* Check whether various headers or options are available */
+#define HAVE_UNISTD_H  @header_unistd_h@    /* <unistd.h> */
+#define HAVE_SYSTYPES_H  @header_sys_types_h@    /* <sys/types.h> */
+#define HAVE_STDDEF_H  @header_stddef_h@     /* <stddef.h> */
+#define HAVE_STDLIB_H  @header_stdlib_h@    /* <stdlib.h> */
+#define HAVE_STRING_H  @header_string_h@    /* <string.h> */
+#define MALLOC_DEC @malloc_dec@  /* 1 = malloc() is declared in stdlib.h, */
+				 /* 2 = in malloc.h, 0 = in neither place */
+#define HAS_MATH_INF @has_math_inf@ /* INFINITY is defined in math.h or */
+				 /* some system header likely to be used */
+#define HAS_STDIO_UNLOCK @stdio_nolock@  /* Whether there are getc_unlocked, */
+		               /* putc_unlocked,flockfile and funlockfile*/
+
+#define DEFAULT_WORDSIZE @default_wordsize@
+#define SIZEOF_INT @ac_cv_sizeof_int@
+#define SIZEOF_LONG @ac_cv_sizeof_long@
+#define SIZEOF_LONG_LONG @ac_cv_sizeof_long_long@   /* 0 if nonexistent */
+#define SIZEOF_INT128 @ac_cv_sizeof___int128_t@   /* 0 if nonexistent */
+
+#define HAVE_CONST @have_const@    /* compiler properly supports const */
+
+/* Note that the following is only for running nauty in multiple threads
+   and will slow it down a little otherwise. */
+#define HAVE_TLS @have_tls@   /* have storage attribute for thread-local */
+#define TLS_ATTR @ac_cv_tls@  /* if so, what it is.  if not, empty */
+
+#define USE_ANSICONTROLS @have_ansicontrols@ 
+                          /* whether --enable-ansicontrols is used */
+
+#define _FILE_OFFSET_BITS @ac_cv_sys_file_offset_bits@
+#if _FILE_OFFSET_BITS == 64
+#define _LARGEFILE_SOURCE
+#else
+#undef _FILE_OFFSET_BITS
+#endif
+
+/* Support of gcc extensions __builtin_clz, __builtin_clzl, __builtin_clzll */
+#define HAVE_CLZ @have_clz@
+#define HAVE_CLZL @have_clzl@
+#define HAVE_CLZLL @have_clzll@
+
+/* Support of gcc extensions
+      __builtin_popcount, __builtin_popcountl, __builtin_popcountll
+   Note that these may only be fast if the compiler switch -mpopcnt is used.
+
+   Also the intrinsics
+      _mm_popcnt_u32, _mm_popcnt_u64
+   for the Intel compiler icc.  These need no compiler switch.
+*/
+#define HAVE_HWPOPCNT @have_hwpopcnt@
+#define HAVE_POPCNT @have_popcnt@
+#define HAVE_POPCNTL @have_popcntl@
+#define HAVE_POPCNTLL @have_popcntll@
+#define HAVE_MMPOP32 @have_mmpop32@
+#define HAVE_MMPOP64 @have_mmpop64@
+
+/*==================================================================*/
+
+/* The following line must be uncommented for compiling into Magma. */
+/* #define NAUTY_IN_MAGMA  */
+
+#ifdef NAUTY_IN_MAGMA
+#include "defs.h"
+#include "system.h"
+#include "bs.h"
+#define OLDEXTDEFS
+#else
+#include <stdio.h>
+#define P_(x) x
+#endif
+
+#if defined(__unix) || defined(__unix__) || defined(unix)
+#define SYS_UNIX
+#endif
+
+#if !HAVE_CONST
+#define const
+#endif
+
+/*****************************************************************************
+*                                                                            *
+*    AUTHOR: Brendan D. McKay                                                *
+*            Research School of Computer Science                             *
+*            Australian National University                                  *
+*            Canberra, ACT 2601, Australia                                   *
+*            phone:  +61 2 6125 3845                                         *
+*            email:  Brendan.McKay@anu.edu.au                                *
+*                                                                            *
+*  This software is subject to copyright as detailed in the file COPYRIGHT.  *
+*                                                                            *
+*   Reference manual:                                                        *
+*     B. D. McKay and A. Piperno, nauty User's Guide (Version 2.5),          *
+*         http://pallini.di.uniroma1.it                                      *
+*         http://cs.anu.edu.au/~bdm/nauty/                                   *
+*                                                                            *
+*   CHANGE HISTORY                                                           *
+*       10-Nov-87 : final changes for version 1.2                            *
+*        5-Dec-87 : renamed to version 1.3 (no changes to this file)         *
+*       28-Sep-88 : added PC Turbo C support, making version 1.4             *
+*       23-Mar-89 : changes for version 1.5 :                                *
+*                   - reworked M==1 code                                     *
+*                   - defined NAUTYVERSION string                            *
+*                   - made NAUTYH_READ to allow this file to be read twice   *
+*                   - added optional ANSI function prototypes                *
+*                   - added validity check for WORDSIZE                      *
+*                   - added new fields to optionblk structure                *
+*                   - updated DEFAULTOPTIONS to add invariants fields        *
+*                   - added (set*) cast to definition of GRAPHROW            *
+*                   - added definition of ALLOCS and FREES                   *
+*       25-Mar-89 : - added declaration of new function doref()              *
+*                   - added UNION macro                                      *
+*       29-Mar-89 : - reduced the default MAXN for small machines            *
+*                   - removed OUTOFSPACE (no longer used)                    *
+*                   - added SETDIFF and XOR macros                           *
+*        2-Apr-89 : - extended statsblk structure                            *
+*        4-Apr-89 : - added IS_* macros                                      *
+*                   - added ERRFILE definition                               *
+*                   - replaced statsblk.outofspace by statsblk.errstatus     *
+*        5-Apr-89 : - deleted definition of np2vector (no longer used)       *
+*                   - introduced EMPTYSET macro                              *
+*       12-Apr-89 : - eliminated MARK, UNMARK and ISMARKED (no longer used)  *
+*       18-Apr-89 : - added MTOOBIG and CANONGNIL                            *
+*       12-May-89 : - made ISELEM1 and ISELEMENT return 0 or 1               *
+*        2-Mar-90 : - added EXTPROC macro and used it                        *
+*       12-Mar-90 : - added SYS_CRAY, with help from N. Sloane and A. Grosky *
+*                   - added dummy groupopts field to optionblk               *
+*                   - select some ANSI things if __STDC__ exists             *
+*       20-Mar-90 : - changed default MAXN for Macintosh versions            *
+*                   - created SYS_MACTHINK for Macintosh THINK compiler      *
+*       27-Mar-90 : - split SYS_MSDOS into SYS_PCMS4 and SYS_PCMS5           *
+*       13-Oct-90 : changes for version 1.6:                                 *
+*                   - fix definition of setword for WORDSIZE==64             *
+*       14-Oct-90 : - added SYS_APOLLO version to avoid compiler bug         *
+*       15-Oct-90 : - improve detection of ANSI conformance                  *
+*       17-Oct-90 : - changed temp name in EMPTYSET to avoid A/UX bug        *
+*       16-Apr-91 : changes for version 1.7:                                 *
+*                   - made version SYS_PCTURBO use free(), not cfree()       *
+*        2-Sep-91 : - noted that SYS_PCMS5 also works for Quick C            *
+*                   - moved MULTIPLY to here from nauty.c                    *
+*       12-Jun-92 : - changed the top part of this comment                   *
+*       27-Aug-92 : - added version SYS_IBMC, thanks to Ivo Duentsch         *
+*        5-Jun-93 : - renamed to version 1.7+, only change in naututil.h     *
+*       29-Jul-93 : changes for version 1.8:                                 *
+*                   - fixed error in default 64-bit version of FIRSTBIT      *
+*                     (not used in any version before ALPHA)                 *
+*                   - installed ALPHA version (thanks to Gordon Royle)       *
+*                   - defined ALLOCS,FREES for SYS_IBMC                      *
+*        3-Sep-93 : - make calloc void* in ALPHA version                     *
+*       17-Sep-93 : - renamed to version 1.9,                                *
+*                        changed only dreadnaut.c and nautinv.c              *
+*       24-Feb-94 : changes for version 1.10:                                *
+*                   - added version SYS_AMIGAAZT, thanks to Carsten Saager   *
+*                     (making 1.9+)                                          *
+*       19-Apr-95 : - added prototype wrapper for C++,                       *
+*                     thanks to Daniel Huson                                 *
+*        5-Mar-96 : - added SYS_ALPHA32 version (32-bit setwords on Alpha)   *
+*       13-Jul-96 : changes for version 2.0:                                 *
+*                   - added dynamic allocation                               *
+*                   - ERRFILE must be defined                                *
+*                   - added FLIPELEM1 and FLIPELEMENT macros                 *
+*       13-Aug-96 : - added SWCHUNK? macros                                  *
+*                   - added TAKEBIT macro                                    *
+*       28-Nov-96 : - include sys/types.h if not ANSI (tentative!)           *
+*       24-Jan-97 : - and stdlib.h if ANSI                                   *
+*                   - removed use of cfree() from UNIX variants              *
+*       25-Jan-97 : - changed options.getcanon from boolean to int           *
+*                     Backwards compatibility is ok, as boolean and int      *
+*                     are the same.  Now getcanon=2 means to get the label   *
+*                     and not care about the group.  Sometimes faster.       *
+*        6-Feb-97 : - Put in #undef for FALSE and TRUE to cope with          *
+*                     compilers that illegally predefine them.               *
+*                   - declared nauty_null and nautil_null                    *
+*        2-Jul-98 : - declared ALLBITS                                       *
+*       21-Oct-98 : - allow WORDSIZE==64 using unsigned long long            *
+*                   - added BIGNAUTY option for really big graphs            *
+*       11-Dec-99 : - made bit, leftbit and bytecount static in each file    *
+*        9-Jan-00 : - declared nauty_check() and nautil_check()              *
+*       12-Feb-00 : - Used #error for compile-time checks                    *
+*                   - Added DYNREALLOC                                       *
+*        4-Mar-00 : - declared ALLMASK(n)                                    *
+*       27-May-00 : - declared CONDYNFREE                                    *
+*       28-May-00 : - declared nautil_freedyn()                              *
+*       16-Aug-00 : - added OLDNAUTY and changed canonical labelling         *
+*       16-Nov-00 : - function prototypes are now default and unavoidable    *
+*                   - removed UPROC, now assume all compilers know void      *
+*                   - removed nvector, now just int (as it always was)       *
+*                   - added extra parameter to targetcell()                  *
+*                   - removed old versions which were only to skip around    *
+*                     bugs that should have been long fixed:                 *
+*                     SYS_APOLLO and SYS_VAXBSD.                             *
+*                   - DEFAULTOPIONS now specifies no output                  *
+*                   - Removed obsolete SYS_MACLSC version                    *
+*       21-Apr-01 : - Added code to satisfy compilation into Magma.  This    *
+*                       is activated by defining NAUTY_IN_MAGMA above.       *
+*                   - The *_null routines no longer exist                    *
+*                   - Default maxinvarlevel is now 1.  (This has no effect   *
+*                        unless an invariant is specified.)                  *
+*                   - Now labelorg has a concrete declaration in nautil.c    *
+*                        and EXTDEFS is not needed                           *
+*        5-May-01 : - NILFUNCTION, NILSET, NILGRAPH now obsolete.  Use NULL. *
+*       11-Sep-01 : - setword is unsigned int in the event that UINT_MAX     *
+*                     is defined and indicates it is big enough              *
+*       17-Oct-01 : - major rewrite for 2.1.  SYS_* variables gone!          *
+*                     Some modernity assumed, eg size_t                      *
+*        8-Aug-02 : - removed MAKEEMPTY  (use EMPTYSET instead)              *
+*                   - deleted OLDNAUTY everywhere                            *
+*       27-Aug-02 : - converted to use autoconf.  Now the original of this   *
+*                     file is nauty-h.in. Run configure to make nauty.h.     *
+*       20-Dec-02 : - increased INFINITY                                     *
+*                     some reorganization to please Magma                    *
+*                   - declared nauty_freedyn()                               *
+*       17-Nov-03 : - renamed INFINITY to NAUTY_INFINITY                     *
+*       29-May-04 : - added definition of SETWORD_FORMAT                     *
+*       14-Sep-04 : - extended prototypes even to recursive functions        *
+*       16-Oct-04 : - added DEFAULTOPTIONS_GRAPH                             *
+*       24-Oct-04 : Starting 2.3                                             *
+*                   - remove register declarations as modern compilers       *
+*                     tend to find them a nuisance                           *
+*                   - Don't define the obsolete symbol INFINITY if it is     *
+*                     defined already                                        *
+*       17-Nov-04 : - make 6 counters in statsblk unsigned long              *
+*       17-Jan-04 : - add init() and cleanup() to dispatchvec                *
+*       12-Nov-05 : - Changed NAUTY_INFINITY to 2^30+2 in BIGNAUTY case      *
+*       22-Nov-06 : Starting 2.4                                             *
+*                   - removed usertcellproc from options                     *
+*                     changed bestcell to targetcell in dispatch vector      *
+*                     declare targetcell and maketargetcell                  *
+*       29-Nov-06 : - add extraoptions to optionblk                          *
+*                   - add declarations of extra_autom and extra_level        *
+*       10-Dec-06 : - BIGNAUTY is gone!  Now permutation=shortish=int.       *
+*                     NAUTY_INFINITY only depends on whether sizeof(int)=2.  *
+*       27-Jun-08 : - define nauty_counter and LONG_LONG_COUNTERS            *
+*       30-Jun-08 : - declare version 2.4                                    *
+*        8-Nov-09 : - final release of version 2.4;                          *
+*       10-Nov-10 : Starting 2.5                                             *
+*                   - declare shortish and permutation obsolete, now int     *
+*       14-Nov-10 : - SETWORDSNEEDED(n)                                      *
+*       23-May-10 : - declare densenauty()                                   *
+*       29-Jun-10 : - add PRINT_COUNTER(f,x)                                 *
+*                   - add DEFAULTOPTIONS_DIGRAPH()                           *
+*       27-Mar-11 : - declare writegroupsize()                               *
+*       14-Jan-12 : - add HAVE_TLS and TLS_ATTR                              *
+*       21-Feb-12 : - add ENABLE_ANSI                                        *
+*       18-Mar-12 : - add COUNTER_FMT                                        *
+*       18-Aug-12 : - add ADDONEARC, ADDONEEDGE, EMPTYGRAPH                  *
+*       29-Aug-12 : - add CLZ macros and FIRSTBITNZ                          *
+*       19-Oct-12 : - add DEFAULT_WORDSIZE                                   *
+*        3-Jan-12 : Released 2.5rc1                                          *
+*       18-Jan-12 : Froze 2.5                                                *
+*       18-Jan-12 : - add NAUABORTED and NAUKILLED                           *
+*                   - add nauty_kill_request                                 *
+*                   - add usercanonproc                                      *
+*        1-Oct-15 : - add COUNTER_FMT_RAW                                    *
+*       10-Jan-16 : - defined POPCOUNTMAC, optionally use popcnt             *
+*                   - remove SYS_CRAY, let's hope it is long obsolete        *
+*                   - add Intel popcount intrinsics for icc                  *
+*       12-Jan-16 : - DYNFREE and CONDYNFREE now set the pointer to NULL     *
+*       16-Jan-16 : - Change NAUTY_INFINITY to 2 billion + 2                 *
+*                 : Froze 2.6                                                *
+*       12-Mar-16 : - Add const to alloc_error()                             *
+*                                                                            *
+* @edit_msg@
+*                                                                            *
+*****************************************************************************/
+
+/*****************************************************************************
+*                                                                            *
+*   16-bit, 32-bit and 64-bit versions can be selected by defining WORDSIZE. *
+*   The largest graph that can be handled has MAXN vertices.                 *
+*   Both WORDSIZE and MAXN can be defined on the command line.               *
+*   WORDSIZE must be 16, 32 or 64; MAXN must be <= NAUTY_INFINITY-2;         *
+*                                                                            *
+*   With a very slight loss of efficiency (depending on platform), nauty     *
+*   can be compiled to dynamically allocate arrays.  Predefine MAXN=0 to     *
+*   achieve this effect, which is default behaviour from version 2.0.        *
+*   In that case, graphs of size up to NAUTY_INFINITY-2 can be handled       *
+*   if the the memory is available.                                          *
+*                                                                            *
+*   If only very small graphs need to be processed, use MAXN<=WORDSIZE       *
+*   since this causes substantial code optimizations.                        *
+*                                                                            *
+*   Conventions and Assumptions:                                             *
+*                                                                            *
+*    A 'setword' is the chunk of memory that is occupied by one part of      *
+*    a set.  This is assumed to be >= WORDSIZE bits in size.                 *
+*                                                                            *
+*    The rightmost (loworder) WORDSIZE bits of setwords are numbered         *
+*    0..WORDSIZE-1, left to right.  It is necessary that the 2^WORDSIZE      *
+*    setwords with the other bits zero are totally ordered under <,=,>.      *
+*    This needs care on a 1's-complement machine.                            *
+*                                                                            *
+*    The int variables m and n have consistent meanings throughout.          *
+*    Graphs have n vertices always, and sets have m setwords always.         *
+*                                                                            *
+*    A 'set' consists of m contiguous setwords, whose bits are numbered      *
+*    0,1,2,... from left (high-order) to right (low-order), using only       *
+*    the rightmost WORDSIZE bits of each setword.  It is used to             *
+*    represent a subset of {0,1,...,n-1} in the usual way - bit number x     *
+*    is 1 iff x is in the subset.  Bits numbered n or greater, and           *
+*    unnumbered bits, are assumed permanently zero.                          *
+*                                                                            *
+*    A 'graph' consists of n contiguous sets.  The i-th set represents       *
+*    the vertices adjacent to vertex i, for i = 0,1,...,n-1.                 *
+*                                                                            *
+*    A 'permutation' is an array of n ints repesenting a permutation of      *
+*    the set {0,1,...,n-1}.  The value of the i-th entry is the number to    *
+*    which i is mapped.                                                      *
+*                                                                            *
+*    If g is a graph and p is a permutation, then g^p is the graph in        *
+*    which vertex i is adjacent to vertex j iff vertex p[i] is adjacent      *
+*    to vertex p[j] in g.                                                    *
+*                                                                            *
+*    A partition nest is represented by a pair (lab,ptn), where lab and ptn  *
+*    are int arrays.  The "partition at level x" is the partition whose      *
+*    cells are {lab[i],lab[i+1],...,lab[j]}, where [i,j] is a maximal        *
+*    subinterval of [0,n-1] such that ptn[k] > x for i <= k < j and          *
+*    ptn[j] <= x.  The partition at level 0 is given to nauty by the user.   *
+*    This is  refined for the root of the tree, which has level 1.           *
+*                                                                            *
+*****************************************************************************/
+
+#ifndef NAUTY_IN_MAGMA
+#if HAVE_SYSTYPES_H
+#include <sys/types.h>
+#endif
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#if HAVE_STDDEF_H
+#include <stddef.h>
+#endif
+#if HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#if HAVE_STRING_H
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+#endif
+
+/* WORDSIZE is the number of set elements per setword (16, 32 or 64).
+   WORDSIZE and setword are defined as follows:
+
+   DEFAULT_WORDSIZE is usually 0 but is set by the configure script
+   to NN if --enable-wordsize=NN is used, where NN is 16, 32 or 64.
+
+   If WORDSIZE is not defined, but DEFAULT_WORDSIZE > 0, then set
+      WORDSIZE to the same value as DEFAULT_WORDSIZE.
+   If WORDSIZE is so far undefined, use 32 unless longs have more 
+      than 32 bits, in which case use 64.
+   Define setword thus:
+      WORDSIZE==16 : unsigned short
+      WORDSIZE==32 : unsigned int unless it is too small,
+			in which case unsigned long
+      WORDSIZE==64 : the first of unsigned int, unsigned long,
+                      unsigned long long, which is large enough.
+*/
+
+#ifdef NAUTY_IN_MAGMA
+#undef WORDSIZE
+#define WORDSIZE WORDBITS
+#endif
+
+#ifndef WORDSIZE
+#if DEFAULT_WORDSIZE > 0
+#define WORDSIZE DEFAULT_WORDSIZE
+#endif
+#endif
+
+#ifdef WORDSIZE
+
+#if  (WORDSIZE != 16) && (WORDSIZE != 32) && (WORDSIZE != 64)
+ #error "WORDSIZE must be 16, 32 or 64"
+#endif
+
+#else  /* WORDSIZE undefined */
+
+#if SIZEOF_LONG>4
+#define WORDSIZE 64
+#else
+#define WORDSIZE 32
+#endif
+
+#endif  /* WORDSIZE */
+
+#ifdef NAUTY_IN_MAGMA
+typedef t_uint setword;
+#define SETWORD_INT  /* Don't assume this is correct in Magma. */
+
+#else /* NAUTY_IN_MAGMA */
+
+#if WORDSIZE==16
+typedef unsigned short setword;
+#define SETWORD_SHORT
+#endif
+
+#if WORDSIZE==32
+#if SIZEOF_INT>=4
+typedef unsigned int setword;
+#define SETWORD_INT
+#else
+typedef unsigned long setword;
+#define SETWORD_LONG
+#endif
+#endif
+
+#if WORDSIZE==64
+#if SIZEOF_INT>=8
+typedef unsigned int setword;
+#define SETWORD_INT
+#else
+#if SIZEOF_LONG>=8
+typedef unsigned long setword;
+#define SETWORD_LONG
+#else
+typedef unsigned long long setword;
+#define SETWORD_LONGLONG
+#endif
+#endif
+#endif
+
+#endif /* NAUTY_IN_MAGMA else */
+
+#if SIZEOF_LONG_LONG>=8 && SIZEOF_LONG==4
+typedef unsigned long long nauty_counter;
+#define LONG_LONG_COUNTERS 1
+#define COUNTER_FMT "%llu"
+#define COUNTER_FMT_RAW "llu"
+#else
+typedef unsigned long nauty_counter;
+#define LONG_LONG_COUNTERS 0
+#define COUNTER_FMT "%lu"
+#define COUNTER_FMT_RAW "lu"
+#endif
+#define PRINT_COUNTER(f,x) fprintf(f,COUNTER_FMT,x)
+
+#define NAUTYVERSIONID (26040+HAVE_TLS)  /* 10000*version + HAVE_TLS */
+#define NAUTYREQUIRED NAUTYVERSIONID  /* Minimum compatible version */
+
+#if WORDSIZE==16
+#define NAUTYVERSION "2.6 (16 bits)"
+#endif
+#if WORDSIZE==32
+#define NAUTYVERSION "2.6 (32 bits)"
+#endif
+#if WORDSIZE==64
+#define NAUTYVERSION "2.6 (64 bits)"
+#endif
+
+#ifndef  MAXN  /* maximum allowed n value; use 0 for dynamic sizing. */
+#define MAXN 0
+#define MAXM 0
+#else
+#define MAXM ((MAXN+WORDSIZE-1)/WORDSIZE)  /* max setwords in a set */
+#endif  /* MAXN */
+
+/* Starting at version 2.2, set operations work for all set sizes unless
+   ONE_WORD_SETS is defined.  In the latter case, if MAXM=1, set ops
+   work only for single-setword sets.  In any case, macro versions
+   ending with 1 work for single-setword sets and versions ending with
+   0 work for all set sizes.
+*/
+
+#if  WORDSIZE==16
+#define SETWD(pos) ((pos)>>4)  /* number of setword containing bit pos */
+#define SETBT(pos) ((pos)&0xF) /* position within setword of bit pos */
+#define TIMESWORDSIZE(w) ((w)<<4)
+#define SETWORDSNEEDED(n) ((((n)-1)>>4)+1)  /* setwords needed for n bits */
+#endif
+
+#if  WORDSIZE==32
+#define SETWD(pos) ((pos)>>5)
+#define SETBT(pos) ((pos)&0x1F)
+#define TIMESWORDSIZE(w) ((w)<<5)
+#define SETWORDSNEEDED(n) ((((n)-1)>>5)+1)
+#endif
+
+#if  WORDSIZE==64
+#define SETWD(pos) ((pos)>>6)
+#define SETBT(pos) ((pos)&0x3F)
+#define TIMESWORDSIZE(w) ((w)<<6)    /* w*WORDSIZE */
+#define SETWORDSNEEDED(n) ((((n)-1)>>6)+1)
+#endif
+
+#ifdef NAUTY_IN_MAGMA
+#define BITT bs_bit
+#else
+#define BITT bit
+#endif
+
+#define ADDELEMENT1(setadd,pos)  (*(setadd) |= BITT[pos])
+#define DELELEMENT1(setadd,pos)  (*(setadd) &= ~BITT[pos])
+#define FLIPELEMENT1(setadd,pos) (*(setadd) ^= BITT[pos])
+#define ISELEMENT1(setadd,pos)   ((*(setadd) & BITT[pos]) != 0)
+#define EMPTYSET1(setadd,m)   *(setadd) = 0;
+#define GRAPHROW1(g,v,m) ((set*)(g)+(v))
+#define ADDONEARC1(g,v,w,m) (g)[v] |= BITT[w]
+#define ADDONEEDGE1(g,v,w,m) { ADDONEARC1(g,v,w,m); ADDONEARC1(g,w,v,m); }
+#define EMPTYGRAPH1(g,m,n) EMPTYSET0(g,n)  /* really EMPTYSET0 */
+
+#define ADDELEMENT0(setadd,pos)  ((setadd)[SETWD(pos)] |= BITT[SETBT(pos)])
+#define DELELEMENT0(setadd,pos)  ((setadd)[SETWD(pos)] &= ~BITT[SETBT(pos)])
+#define FLIPELEMENT0(setadd,pos) ((setadd)[SETWD(pos)] ^= BITT[SETBT(pos)])
+#define ISELEMENT0(setadd,pos) (((setadd)[SETWD(pos)] & BITT[SETBT(pos)]) != 0)
+#define EMPTYSET0(setadd,m) \
+    {setword *es; \
+    for (es = (setword*)(setadd)+(m); --es >= (setword*)(setadd);) *es=0;}
+#define GRAPHROW0(g,v,m) ((set*)(g) + (m)*(size_t)(v))
+#define ADDONEARC0(g,v,w,m) ADDELEMENT0(GRAPHROW0(g,v,m),w)
+#define ADDONEEDGE0(g,v,w,m) { ADDONEARC0(g,v,w,m); ADDONEARC0(g,w,v,m); }
+#define EMPTYGRAPH0(g,m,n) EMPTYSET0(g,(m)*(size_t)(n))
+
+#if  (MAXM==1) && defined(ONE_WORD_SETS)
+#define ADDELEMENT ADDELEMENT1
+#define DELELEMENT DELELEMENT1
+#define FLIPELEMENT FLIPELEMENT1
+#define ISELEMENT ISELEMENT1
+#define EMPTYSET EMPTYSET1
+#define GRAPHROW GRAPHROW1
+#define ADDONEARC ADDONEARC1
+#define ADDONEEDGE ADDONEEDGE1
+#define EMPTYGRAPH EMPTYGRAPH1
+#else
+#define ADDELEMENT ADDELEMENT0
+#define DELELEMENT DELELEMENT0
+#define FLIPELEMENT FLIPELEMENT0
+#define ISELEMENT ISELEMENT0
+#define EMPTYSET EMPTYSET0
+#define GRAPHROW GRAPHROW0
+#define ADDONEARC ADDONEARC0
+#define ADDONEEDGE ADDONEEDGE0
+#define EMPTYGRAPH EMPTYGRAPH0
+#endif
+
+
+#ifdef NAUTY_IN_MAGMA
+#undef EMPTYSET
+#define EMPTYSET(setadd,m) {t_int _i; bsp_makeempty(setadd,m,_i);}
+#endif
+
+#define NOTSUBSET(word1,word2) ((word1) & ~(word2))  /* test if the 1-bits
+                    in setword word1 do not form a subset of those in word2  */
+#define INTERSECT(word1,word2) ((word1) &= (word2))  /* AND word2 into word1 */
+#define UNION(word1,word2)     ((word1) |= (word2))  /* OR word2 into word1 */
+#define SETDIFF(word1,word2)   ((word1) &= ~(word2)) /* - word2 into word1 */
+#define XOR(word1,word2)       ((word1) ^= (word2))  /* XOR word2 into word1 */
+#define ZAPBIT(word,x) ((word) &= ~BITT[x])  /* delete bit x in setword */
+#define TAKEBIT(iw,w) {(iw) = FIRSTBITNZ(w); (w) ^= BITT[iw];}
+
+#ifdef SETWORD_LONGLONG
+#define MSK3232 0xFFFFFFFF00000000ULL
+#define MSK1648 0xFFFF000000000000ULL
+#define MSK0856 0xFF00000000000000ULL
+#define MSK1632 0x0000FFFF00000000ULL
+#define MSK0840     0xFF0000000000ULL
+#define MSK1616         0xFFFF0000ULL 
+#define MSK0824         0xFF000000ULL 
+#define MSK0808             0xFF00ULL 
+#define MSK63C  0x7FFFFFFFFFFFFFFFULL
+#define MSK31C          0x7FFFFFFFULL
+#define MSK15C              0x7FFFULL
+#define MSK64   0xFFFFFFFFFFFFFFFFULL
+#define MSK32           0xFFFFFFFFULL
+#define MSK16               0xFFFFULL
+#define MSK8                  0xFFULL
+#endif
+
+#ifdef SETWORD_LONG
+#define MSK3232 0xFFFFFFFF00000000UL
+#define MSK1648 0xFFFF000000000000UL
+#define MSK0856 0xFF00000000000000UL
+#define MSK1632 0x0000FFFF00000000UL
+#define MSK0840     0xFF0000000000UL
+#define MSK1616         0xFFFF0000UL 
+#define MSK0824         0xFF000000UL 
+#define MSK0808             0xFF00UL 
+#define MSK63C  0x7FFFFFFFFFFFFFFFUL
+#define MSK31C          0x7FFFFFFFUL
+#define MSK15C              0x7FFFUL
+#define MSK64   0xFFFFFFFFFFFFFFFFUL
+#define MSK32           0xFFFFFFFFUL
+#define MSK16               0xFFFFUL
+#define MSK8                  0xFFUL
+#endif
+
+#if defined(SETWORD_INT) || defined(SETWORD_SHORT)
+#define MSK3232 0xFFFFFFFF00000000U
+#define MSK1648 0xFFFF000000000000U
+#define MSK0856 0xFF00000000000000U
+#define MSK1632 0x0000FFFF00000000U
+#define MSK0840     0xFF0000000000U
+#define MSK1616         0xFFFF0000U 
+#define MSK0824         0xFF000000U
+#define MSK0808             0xFF00U 
+#define MSK63C  0x7FFFFFFFFFFFFFFFU
+#define MSK31C          0x7FFFFFFFU
+#define MSK15C              0x7FFFU
+#define MSK64   0xFFFFFFFFFFFFFFFFU
+#define MSK32           0xFFFFFFFFU
+#define MSK16               0xFFFFU
+#define MSK8                  0xFFU
+#endif
+
+#if defined(SETWORD_LONGLONG)
+#if WORDSIZE==16
+#define SETWORD_FORMAT "%04llx"
+#endif
+#if WORDSIZE==32
+#define SETWORD_FORMAT "%08llx"
+#endif
+#if WORDSIZE==64
+#define SETWORD_FORMAT "%16llx"
+#endif
+#endif
+
+#if defined(SETWORD_LONG)
+#if WORDSIZE==16
+#define SETWORD_FORMAT "%04lx"
+#endif
+#if WORDSIZE==32
+#define SETWORD_FORMAT "%08lx"
+#endif
+#if WORDSIZE==64
+#define SETWORD_FORMAT "%16lx"
+#endif
+#endif
+
+#if defined(SETWORD_INT)
+#if WORDSIZE==16
+#define SETWORD_FORMAT "%04x"
+#endif
+#if WORDSIZE==32
+#define SETWORD_FORMAT "%08x"
+#endif
+#if WORDSIZE==64
+#define SETWORD_FORMAT "%16x"
+#endif
+#endif
+
+#if defined(SETWORD_SHORT)
+#if WORDSIZE==16
+#define SETWORD_FORMAT "%04hx"
+#endif
+#if WORDSIZE==32
+#define SETWORD_FORMAT "%08hx"
+#endif
+#if WORDSIZE==64
+#define SETWORD_FORMAT "%16hx"
+#endif
+#endif
+
+/* POPCOUNT(x) = number of 1-bits in a setword x
+   POPCOUNTMAC(x) = Macro version of POPCOUNT
+   FIRSTBIT(x) = number of first 1-bit in non-zero setword (0..WORDSIZE-1)
+                   or WORDSIZE if x == 0
+   FIRSTBITNZ(x) = as FIRSTBIT(x) but assumes x is not zero
+   BITMASK(x)  = setword whose rightmost WORDSIZE-x-1 (numbered) bits
+                 are 1 and the rest 0 (0 <= x < WORDSIZE)
+                 (I.e., bits 0..x are unselected and the rest selected.)
+   ALLBITS     = all (numbered) bits in a setword  */
+
+#if  WORDSIZE==64
+#define POPCOUNTMAC(x) (bytecount[(x)>>56 & 0xFF] + bytecount[(x)>>48 & 0xFF] \
+                   + bytecount[(x)>>40 & 0xFF] + bytecount[(x)>>32 & 0xFF] \
+                   + bytecount[(x)>>24 & 0xFF] + bytecount[(x)>>16 & 0xFF] \
+                   + bytecount[(x)>>8 & 0xFF]  + bytecount[(x) & 0xFF])
+#define FIRSTBIT(x) ((x) & MSK3232 ? \
+                       (x) &   MSK1648 ? \
+                         (x) & MSK0856 ? \
+                         0+leftbit[((x)>>56) & MSK8] : \
+                         8+leftbit[(x)>>48] \
+                       : (x) & MSK0840 ? \
+                         16+leftbit[(x)>>40] : \
+                         24+leftbit[(x)>>32] \
+                     : (x) & MSK1616 ? \
+                         (x) & MSK0824 ? \
+                         32+leftbit[(x)>>24] : \
+                         40+leftbit[(x)>>16] \
+                       : (x) & MSK0808 ? \
+                         48+leftbit[(x)>>8] : \
+                         56+leftbit[x])
+#define BITMASK(x)  (MSK63C >> (x))
+#define ALLBITS  MSK64
+#define SWCHUNK0(w) ((long)((w)>>48)&0xFFFFL)
+#define SWCHUNK1(w) ((long)((w)>>32)&0xFFFFL)
+#define SWCHUNK2(w) ((long)((w)>>16)&0xFFFFL)
+#define SWCHUNK3(w) ((long)(w)&0xFFFFL)
+#endif
+
+#if  WORDSIZE==32
+#define POPCOUNTMAC(x) (bytecount[(x)>>24 & 0xFF] + bytecount[(x)>>16 & 0xFF] \
+                        + bytecount[(x)>>8 & 0xFF] + bytecount[(x) & 0xFF])
+#define FIRSTBIT(x) ((x) & MSK1616 ? ((x) & MSK0824 ? \
+                     leftbit[((x)>>24) & MSK8] : 8+leftbit[(x)>>16]) \
+                    : ((x) & MSK0808 ? 16+leftbit[(x)>>8] : 24+leftbit[x]))
+#define BITMASK(x)  (MSK31C >> (x))
+#define ALLBITS  MSK32
+#define SWCHUNK0(w) ((long)((w)>>16)&0xFFFFL)
+#define SWCHUNK1(w) ((long)(w)&0xFFFFL)
+#endif
+
+#if  WORDSIZE==16
+#define POPCOUNTMAC(x) (bytecount[(x)>>8 & 0xFF] + bytecount[(x) & 0xFF])
+#define FIRSTBIT(x) ((x) & MSK0808 ? leftbit[((x)>>8) & MSK8] : 8+leftbit[x])
+#define BITMASK(x)  (MSK15C >> (x))
+#define ALLBITS  MSK16
+#define SWCHUNK0(w) ((long)(w)&0xFFFFL)
+#endif
+
+#if defined(SETWORD_LONGLONG) && HAVE_CLZLL
+#undef FIRSTBIT
+#undef FIRSTBITNZ
+#define FIRSTBITNZ(x) __builtin_clzll(x)
+#define FIRSTBIT(x) ((x) ? FIRSTBITNZ(x) : WORDSIZE)
+#endif
+#if defined(SETWORD_LONG) && HAVE_CLZL
+#undef FIRSTBIT
+#undef FIRSTBITNZ
+#define FIRSTBITNZ(x) __builtin_clzl(x)
+#define FIRSTBIT(x) ((x) ? FIRSTBITNZ(x) : WORDSIZE)
+#endif
+#if defined(SETWORD_INT) && HAVE_CLZ
+#undef FIRSTBIT
+#undef FIRSTBITNZ
+#define FIRSTBITNZ(x) __builtin_clz(x)
+#define FIRSTBIT(x) ((x) ? FIRSTBITNZ(x) : WORDSIZE)
+#endif
+
+#ifndef FIRSTBITNZ
+#define FIRSTBITNZ FIRSTBIT
+#endif
+
+/* Use popcount instructions if available */
+#define POPCOUNT POPCOUNTMAC
+
+#ifdef __INTEL_COMPILER
+#include <nmmintrin.h>
+#if WORDSIZE==64 && HAVE_MMPOP64
+#undef POPCOUNT
+#define POPCOUNT(x) _mm_popcnt_u64(x)
+#endif
+#if WORDSIZE==32 && HAVE_MMPOP32
+#undef POPCOUNT
+#define POPCOUNT(x) _mm_popcnt_u32(x)
+#endif
+
+#else
+
+/* Note that, unlike icc, gcc will not use the POPCNT instruction without
+   permission, in which case it defines __POPCNT__ .
+*/
+#ifdef __POPCNT__
+#if defined(SETWORD_LONGLONG) && HAVE_POPCNTLL
+#undef POPCOUNT
+#define POPCOUNT(x) __builtin_popcountll(x)
+#endif
+#if defined(SETWORD_LONG) && HAVE_POPCNTL
+#undef POPCOUNT
+#define POPCOUNT(x) __builtin_popcountl(x)
+#endif
+#if defined(SETWORD_INT) && HAVE_POPCNT
+#undef POPCOUNT
+#define POPCOUNT(x) __builtin_popcount(x)
+#endif
+#endif
+#endif
+
+#ifdef NAUTY_IN_MAGMA
+#undef POPCOUNT
+#undef FIRSTBIT
+#undef BITMASK
+#define POPCOUNT(x) bs_popcount(x)
+#define FIRSTBIT(x) bs_firstbit(x)
+#define BITMASK(x)  bs_bitmask(x)
+#endif
+
+#define ALLMASK(n) ((n)?~BITMASK((n)-1):(setword)0)  /* First n bits */
+
+    /* various constants: */
+#undef FALSE
+#undef TRUE
+#define FALSE    0
+#define TRUE     1
+
+#if SIZEOF_INT>=4
+#define NAUTY_INFINITY 2000000002  /* Max graph size is 2 billion */
+#else
+#define NAUTY_INFINITY 0x7FFF
+#endif
+
+/* The following four types are obsolete, use int in new code. */
+typedef int shortish;
+typedef shortish permutation;
+typedef int nvector,np2vector; 
+
+/* For backward compatibility: */
+#if !HAS_MATH_INF && !defined(INFINITY)
+#define INFINITY NAUTY_INFINITY
+#endif
+
+#if MAXN > NAUTY_INFINITY-2
+ #error MAXN must be at most NAUTY_INFINITY-2
+#endif
+
+    /* typedefs for sets, graphs, permutations, etc.: */
+
+typedef int boolean;    /* boolean MUST be the same as int */
+
+#define UPROC void      /* obsolete */
+
+typedef setword set,graph;
+#ifdef NAUTY_IN_MAGMA
+typedef graph nauty_graph;
+typedef set nauty_set;
+#endif
+
+typedef struct
+{
+    double grpsize1;        /* size of group is */
+    int grpsize2;           /*    grpsize1 * 10^grpsize2 */
+#define groupsize1 grpsize1     /* for backwards compatibility */
+#define groupsize2 grpsize2
+    int numorbits;          /* number of orbits in group */
+    int numgenerators;      /* number of generators found */
+    int errstatus;          /* if non-zero : an error code */
+#define outofspace errstatus;   /* for backwards compatibility */
+    unsigned long numnodes;      /* total number of nodes */
+    unsigned long numbadleaves;  /* number of leaves of no use */
+    int maxlevel;                /* maximum depth of search */
+    unsigned long tctotal;       /* total size of all target cells */
+    unsigned long canupdates;    /* number of updates of best label */
+    unsigned long invapplics;    /* number of applications of invarproc */
+    unsigned long invsuccesses;  /* number of successful uses of invarproc() */
+    int invarsuclevel;      /* least level where invarproc worked */
+} statsblk;
+
+/* codes for errstatus field (see nauty.c for more accurate descriptions): */
+/* 0 is normal - no error */
+#define NTOOBIG      1      /* n > MAXN or n > WORDSIZE*m */
+#define MTOOBIG      2      /* m > MAXM */
+#define CANONGNIL    3      /* canong = NULL, but getcanon = TRUE */
+#define NAUABORTED   4      /* nauty is terminated early under program control */
+#define NAUKILLED    5      /* nauty is terminated early by caught signal */
+
+/* manipulation of real approximation to group size */
+#define MULTIPLY(s1,s2,i) if ((s1 *= i) >= 1e10) {s1 /= 1e10; s2 += 10;}
+
+struct optionstruct;  /* incomplete definition */
+
+typedef struct
+{
+    boolean (*isautom)        /* test for automorphism */
+            (graph*,int*,boolean,int,int);
+    int     (*testcanlab)     /* test for better labelling */
+            (graph*,graph*,int*,int*,int,int);
+    void    (*updatecan)      /* update canonical object */
+            (graph*,graph*,int*,int,int,int);
+    void    (*refine)         /* refine partition */
+            (graph*,int*,int*,int,int*,int*,set*,int*,int,int);
+    void    (*refine1)        /* refine partition, MAXM==1 */
+            (graph*,int*,int*,int,int*,int*,set*,int*,int,int);
+    boolean (*cheapautom)     /* test for easy automorphism */
+            (int*,int,boolean,int);
+    int     (*targetcell)     /* decide which cell to split */
+            (graph*,int*,int*,int,int,boolean,int,int,int);
+    void    (*freedyn)(void); /* free dynamic memory */
+    void    (*check)          /* check compilation parameters */
+            (int,int,int,int);
+    void    (*init)(graph*,graph**,graph*,graph**,int*,int*,set*,
+                   struct optionstruct*,int*,int,int);
+    void    (*cleanup)(graph*,graph**,graph*,graph**,int*,int*,
+                      struct optionstruct*,statsblk*,int,int);
+} dispatchvec;
+
+typedef struct optionstruct
+{
+    int getcanon;             /* make canong and canonlab? */
+#define LABELONLY 2   /* new value UNIMPLEMENTED */
+    boolean digraph;          /* multiple edges or loops? */
+    boolean writeautoms;      /* write automorphisms? */
+    boolean writemarkers;     /* write stats on pts fixed, etc.? */
+    boolean defaultptn;       /* set lab,ptn,active for single cell? */
+    boolean cartesian;        /* use cartesian rep for writing automs? */
+    int linelength;           /* max chars/line (excl. '\n') for output */
+    FILE *outfile;            /* file for output, if any */
+    void (*userrefproc)       /* replacement for usual refine procedure */
+         (graph*,int*,int*,int,int*,int*,set*,int*,int,int);
+    void (*userautomproc)     /* procedure called for each automorphism */
+         (int,int*,int*,int,int,int);
+    void (*userlevelproc)     /* procedure called for each level */
+         (int*,int*,int,int*,statsblk*,int,int,int,int,int,int);
+    void (*usernodeproc)      /* procedure called for each node */
+         (graph*,int*,int*,int,int,int,int,int,int);
+    int  (*usercanonproc)     /* procedure called for better labellings */
+         (graph*,int*,graph*,int,int,int,int);
+    void (*invarproc)         /* procedure to compute vertex-invariant */
+         (graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+    int tc_level;             /* max level for smart target cell choosing */
+    int mininvarlevel;        /* min level for invariant computation */
+    int maxinvarlevel;        /* max level for invariant computation */
+    int invararg;             /* value passed to (*invarproc)() */
+    dispatchvec *dispatch;    /* vector of object-specific routines */
+    boolean schreier;         /* use random schreier method */
+    void *extra_options;      /* arbitrary extra options */
+#ifdef NAUTY_IN_MAGMA
+    boolean print_stats;      /* CAYLEY specfic - GYM Sep 1990 */
+    char *invarprocname;      /* Magma - no longer global sjc 1994 */
+    int lab_h;                /* Magma - no longer global sjc 1994 */
+    int ptn_h;                /* Magma - no longer global sjc 1994 */
+    int orbitset_h;           /* Magma - no longer global sjc 1994 */
+#endif
+} optionblk;
+
+#ifndef CONSOLWIDTH
+#define CONSOLWIDTH 78
+#endif
+
+/* The following are obsolete.  Just use NULL. */
+#define NILFUNCTION ((void(*)())NULL)      /* nil pointer to user-function */
+#define NILSET      ((set*)NULL)           /* nil pointer to set */
+#define NILGRAPH    ((graph*)NULL)         /* nil pointer to graph */
+
+#define DEFAULTOPTIONS_GRAPH(options) optionblk options = \
+ {0,FALSE,FALSE,FALSE,TRUE,FALSE,CONSOLWIDTH, \
+  NULL,NULL,NULL,NULL,NULL,NULL,NULL,100,0,1,0,&dispatch_graph,FALSE,NULL}
+#define DEFAULTOPTIONS_DIGRAPH(options) optionblk options = \
+ {0,TRUE,FALSE,FALSE,TRUE,FALSE,CONSOLWIDTH, \
+  NULL,NULL,NULL,NULL,NULL,NULL,adjacencies,100,0,999,0,&dispatch_graph,FALSE,NULL}
+
+#ifndef DEFAULTOPTIONS
+#define DEFAULTOPTIONS DEFAULTOPTIONS_GRAPH
+#endif
+#ifndef DEFAULTOPTIONS_DENSEGRAPH
+#define DEFAULTOPTIONS_DENSEGRAPH DEFAULTOPTIONS_GRAPH
+#endif
+
+#ifdef NAUTY_IN_MAGMA
+#define PUTC(c,f) io_putchar(c)
+#else
+#ifdef IS_JAVA
+extern void javastream(FILE* f,char c);
+#define PUTC(c,f) javastream(f,c)
+#else
+#define PUTC(c,f) putc(c,f)
+#endif
+#endif
+
+/* We hope that malloc, free, realloc are declared either in <stdlib.h>
+   or <malloc.h>.  Otherwise we will define them.  We also assume that
+   size_t has been defined by the time we get to define malloc(). */
+#ifndef NAUTY_IN_MAGMA
+#if MALLOC_DEC==2
+#include <malloc.h>
+#endif
+#if MALLOC_DEC==0
+extern void *malloc(size_t);
+extern void *realloc(void*,size_t);
+extern void free(void*);
+#endif
+#endif
+
+/* ALLOCS(x,y) should return a pointer (any pointer type) to x*y units of new
+   storage, not necessarily initialised.  A "unit" of storage is defined by
+   the sizeof operator.   x and y are integer values of type int or larger, 
+   but x*y may well be too large for an int.  The macro should cast to the
+   correct type for the call.  On failure, ALLOCS(x,y) should return a NULL 
+   pointer.  FREES(p) should free storage previously allocated by ALLOCS, 
+   where p is the value that ALLOCS returned. */
+
+#ifdef NAUTY_IN_MAGMA
+#define ALLOCS(x,y) mem_malloc((size_t)(x)*(size_t)(y))
+#define REALLOCS(p,x) mem_realloc(p,(size_t)(x))
+#define FREES(p) mem_free(p)
+#else
+#define ALLOCS(x,y) malloc((size_t)(x)*(size_t)(y))
+#define REALLOCS(p,x) realloc(p,(size_t)(x)) 
+#define FREES(p) free(p)
+#endif
+
+/* The following macros are used by nauty if MAXN=0.  They dynamically
+   allocate arrays of size dependent on m or n.  For each array there
+   should be two static variables:
+     type *name;
+     size_t name_sz;
+   "name" will hold a pointer to an allocated array.  "name_sz" will hold
+   the size of the allocated array in units of sizeof(type).  DYNALLSTAT
+   declares both variables and initialises name_sz=0.  DYNALLOC1 and
+   DYNALLOC2 test if there is enough space allocated, and if not free
+   the existing space and allocate a bigger space.  The allocated space
+   is not initialised.
+   
+   In the case of DYNALLOC1, the space is allocated using
+       ALLOCS(sz,sizeof(type)).
+   In the case of DYNALLOC2, the space is allocated using
+       ALLOCS(sz1,sz2*sizeof(type)).
+
+   DYNREALLOC is like DYNALLOC1 except that the old contents are copied
+   into the new space. Availability of realloc() is assumed.
+
+   DYNFREE frees any allocated array and sets name_sz back to 0.
+   CONDYNFREE does the same, but only if name_sz exceeds some limit.
+*/
+
+#define DYNALLSTAT(type,name,name_sz) \
+	static TLS_ATTR type *name; static TLS_ATTR size_t name_sz=0
+#define DYNALLOC1(type,name,name_sz,sz,msg) \
+ if ((size_t)(sz) > name_sz) \
+ { if (name_sz) FREES(name); name_sz = (sz); \
+ if ((name=(type*)ALLOCS(sz,sizeof(type))) == NULL) {alloc_error(msg);}}
+#define DYNALLOC2(type,name,name_sz,sz1,sz2,msg) \
+ if ((size_t)(sz1)*(size_t)(sz2) > name_sz) \
+ { if (name_sz) FREES(name); name_sz = (size_t)(sz1)*(size_t)(sz2); \
+ if ((name=(type*)ALLOCS((sz1),(sz2)*sizeof(type))) == NULL) \
+ {alloc_error(msg);}}
+#define DYNREALLOC(type,name,name_sz,sz,msg) \
+ {if ((size_t)(sz) > name_sz) \
+ { if ((name = (type*)REALLOCS(name,(sz)*sizeof(type))) == NULL) \
+      {alloc_error(msg);} else name_sz = (sz);}}
+#define DYNFREE(name,name_sz) \
+  { if (name) FREES(name); name = NULL; name_sz = 0;}
+#define CONDYNFREE(name,name_sz,minsz) \
+ if (name_sz > (size_t)(minsz)) {DYNFREE(name,name_sz);}
+
+/* File to write error messages to (used as first argument to fprintf()). */
+#define ERRFILE stderr
+
+/* Don't use OLDEXTDEFS, it is only still here for Magma. */
+#ifdef OLDEXTDEFS   
+#define EXTDEF_CLASS
+#ifdef EXTDEFS
+#define EXTDEF_TYPE 1
+#else
+#define EXTDEF_TYPE 2
+#endif
+#else
+#define EXTDEF_CLASS static
+#define EXTDEF_TYPE 2
+#endif
+
+extern int labelorg;   /* Declared in nautil.c */
+extern volatile int nauty_kill_request;  /* Also declared in nautil.c */
+
+#ifndef NAUTY_IN_MAGMA
+  /* Things equivalent to bit, bytecount, leftbit are defined
+     in bs.h for Magma. */
+#if  EXTDEF_TYPE==1
+extern setword bit[];
+extern int bytecount[];
+extern int leftbit[];
+
+#else
+    /* array giving setwords with single 1-bit */
+#if  WORDSIZE==64
+#ifdef SETWORD_LONGLONG
+EXTDEF_CLASS const
+setword bit[] = {01000000000000000000000LL,0400000000000000000000LL,
+                 0200000000000000000000LL,0100000000000000000000LL,
+                 040000000000000000000LL,020000000000000000000LL,
+                 010000000000000000000LL,04000000000000000000LL,
+                 02000000000000000000LL,01000000000000000000LL,
+                 0400000000000000000LL,0200000000000000000LL,
+                 0100000000000000000LL,040000000000000000LL,
+                 020000000000000000LL,010000000000000000LL,
+                 04000000000000000LL,02000000000000000LL,
+                 01000000000000000LL,0400000000000000LL,0200000000000000LL,
+                 0100000000000000LL,040000000000000LL,020000000000000LL,
+                 010000000000000LL,04000000000000LL,02000000000000LL,
+                 01000000000000LL,0400000000000LL,0200000000000LL,
+		 0100000000000LL,040000000000LL,020000000000LL,010000000000LL,
+		 04000000000LL,02000000000LL,01000000000LL,0400000000LL,
+		 0200000000LL,0100000000LL,040000000LL,020000000LL,
+		 010000000LL,04000000LL,02000000LL,01000000LL,0400000LL,
+		 0200000LL,0100000LL,040000LL,020000LL,010000LL,04000LL,
+                 02000LL,01000LL,0400LL,0200LL,0100LL,040LL,020LL,010LL,
+		 04LL,02LL,01LL};
+#else
+EXTDEF_CLASS const
+setword bit[] = {01000000000000000000000,0400000000000000000000,
+                 0200000000000000000000,0100000000000000000000,
+                 040000000000000000000,020000000000000000000,
+                 010000000000000000000,04000000000000000000,
+                 02000000000000000000,01000000000000000000,
+                 0400000000000000000,0200000000000000000,
+                 0100000000000000000,040000000000000000,020000000000000000,
+                 010000000000000000,04000000000000000,02000000000000000,
+                 01000000000000000,0400000000000000,0200000000000000,
+                 0100000000000000,040000000000000,020000000000000,
+                 010000000000000,04000000000000,02000000000000,
+                 01000000000000,0400000000000,0200000000000,0100000000000,
+                 040000000000,020000000000,010000000000,04000000000,
+                 02000000000,01000000000,0400000000,0200000000,0100000000,
+                 040000000,020000000,010000000,04000000,02000000,01000000,
+                 0400000,0200000,0100000,040000,020000,010000,04000,
+                 02000,01000,0400,0200,0100,040,020,010,04,02,01};
+#endif
+#endif
+
+#if  WORDSIZE==32
+EXTDEF_CLASS const
+setword bit[] = {020000000000,010000000000,04000000000,02000000000,
+                 01000000000,0400000000,0200000000,0100000000,040000000,
+                 020000000,010000000,04000000,02000000,01000000,0400000,
+                 0200000,0100000,040000,020000,010000,04000,02000,01000,
+                 0400,0200,0100,040,020,010,04,02,01};
+#endif
+
+#if WORDSIZE==16
+EXTDEF_CLASS const
+setword bit[] = {0100000,040000,020000,010000,04000,02000,01000,0400,0200,
+                 0100,040,020,010,04,02,01};
+#endif
+
+    /*  array giving number of 1-bits in bytes valued 0..255: */
+EXTDEF_CLASS const
+int bytecount[] = {0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,
+                   1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+                   1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+                   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+                   1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+                   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+                   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+                   3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+                   1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+                   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+                   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+                   3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+                   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+                   3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+                   3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+                   4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8};
+
+    /* array giving position (1..7) of high-order 1-bit in byte: */
+EXTDEF_CLASS const
+int leftbit[] =   {8,7,6,6,5,5,5,5,4,4,4,4,4,4,4,4,
+                   3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
+                   2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+                   2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+                   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+                   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+                   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+                   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+#endif  /* EXTDEFS */
+
+#endif /* not NAUTY_IN_MAGMA */
+
+#define ANSIPROT 1
+#define EXTPROC(func,args) extern func args;     /* obsolete */
+
+/* The following is for C++ programs that read nauty.h.  Compile nauty
+   itself using C, not C++.  */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void alloc_error(const char*);
+extern void breakout(int*,int*,int,int,int,set*,int);
+extern boolean cheapautom(int*,int,boolean,int);
+extern void doref(graph*,int*,int*,int,int*,int*,int*,set*,int*,
+  void(*)(graph*,int*,int*,int,int*,int*,set*,int*,int,int),
+  void(*)(graph*,int*,int*,int,int,int,int*,int,boolean,int,int),
+  int,int,int,boolean,int,int);
+extern void extra_autom(int*,int);
+extern void extra_level(int,int*,int*,int,int,int,int,int,int);
+extern boolean isautom(graph*,int*,boolean,int,int);
+extern dispatchvec dispatch_graph;
+extern int itos(int,char*);
+extern void fmperm(int*,set*,set*,int,int);
+extern void fmptn(int*,int*,int,set*,set*,int,int);
+extern void longprune(set*,set*,set*,set*,int);
+extern void nauty(graph*,int*,int*,set*,int*,optionblk*,
+                  statsblk*,set*,int,int,int,graph*);
+extern void maketargetcell(graph*,int*,int*,int,set*,int*,int*,int,boolean,
+           int,int (*)(graph*,int*,int*,int,int,boolean,int,int,int),int,int);
+extern int nextelement(set*,int,int);
+extern int orbjoin(int*,int*,int);
+extern void permset(set*,set*,int,int*);
+extern void putstring(FILE*,char*);
+extern void refine(graph*,int*,int*,int,int*,int*,set*,int*,int,int);
+extern void refine1(graph*,int*,int*,int,int*,int*,set*,int*,int,int);
+extern void shortprune(set*,set*,int);
+extern int targetcell(graph*,int*,int*,int,int,boolean,int,int,int);
+extern int testcanlab(graph*,graph*,int*,int*,int,int);
+extern void updatecan(graph*,graph*,int*,int,int,int);
+extern void writeperm(FILE*,int*,boolean,int,int);
+extern void nauty_freedyn(void);
+extern void nauty_check(int,int,int,int);
+extern void naugraph_check(int,int,int,int);
+extern void nautil_check(int,int,int,int);
+extern void nautil_freedyn(void);
+extern void naugraph_freedyn(void);
+extern void densenauty(graph*,int*,int*,int*,
+			optionblk*,statsblk*,int,int,graph*);
+extern void writegroupsize(FILE*,double,int);
+
+#ifdef __cplusplus
+}
+#endif
+
+/* @edit_msg@ */
+
+
+#endif  /* _NAUTY_H_ */
diff --git a/lib/nauty/nauty.c b/lib/nauty/nauty.c
new file mode 100644
index 0000000..ef665e2
--- /dev/null
+++ b/lib/nauty/nauty.c
@@ -0,0 +1,1229 @@
+/*****************************************************************************
+*                                                                            *
+*  Main source file for version 2.6 of nauty.                                *
+*                                                                            *
+*   Copyright (1984-2016) Brendan McKay.  All rights reserved.  Permission   *
+*   Subject to the waivers and disclaimers in nauty.h.                       *
+*                                                                            *
+*   CHANGE HISTORY                                                           *
+*       10-Nov-87 : final changes for version 1.2                            *
+*        5-Dec-87 : renamed to version 1.3 (no changes to this file)         *
+*       28-Sep-88 : renamed to version 1.4 (no changes to this file)         *
+*       23-Mar-89 : changes for version 1.5 :                                *
+*                   - add use of refine1 instead of refine for m==1          *
+*                   - changes for new optionblk syntax                       *
+*                   - disable tc_level use for digraphs                      *
+*                   - interposed doref() interface to refine() so that       *
+*                        options.invarproc can be supported                  *
+*                   - declared local routines static                         *
+*       28-Mar-89 : - implemented mininvarlevel/maxinvarlevel < 0 options    *
+*        2-Apr-89 : - added invarproc fields in stats                        *
+*        5-Apr-89 : - modified error returns from nauty()                    *
+*                   - added error message to ERRFILE                         *
+*                   - changed MAKEEMPTY uses to EMPTYSET                     *
+*       18-Apr-89 : - added MTOOBIG and CANONGNIL                            *
+*        8-May-89 : - changed firstcode[] and canoncode[] to short           *
+*       10-Nov-90 : changes for version 1.6 :                                *
+*                   - added dummy routine nauty_null (see dreadnaut.c)       *
+*        2-Sep-91 : changes for version 1.7 :                                *
+*                   - moved MULTIPLY into nauty.h                            *
+*       27-Mar-92 : - changed 'n' into 'm' in error message in nauty()       *
+*        5-Jun-93 : renamed to version 1.7+ (no changes to this file)        *
+*       18-Aug-93 : renamed to version 1.8 (no changes to this file)         *
+*       17-Sep-93 : renamed to version 1.9 (no changes to this file)         *
+*       13-Jul-96 : changes for version 2.0 :                                *
+*                   - added dynamic allocation                               *
+*       21-Oct-98 : - made short into shortish for BIGNAUTY as needed        *
+*        7-Jan-00 : - allowed n=0                                            *
+*                   - added nauty_check() and a call to it                   *
+*       12-Feb-00 : - used better method for target cell memory allocation   *
+*                   - did a little formating of the code                     *
+*       27-May-00 : - fixed error introduced on Feb 12.                      *
+*                   - dynamic allocations in nauty() are now deallocated     *
+*                     before return if n >= 320.                             *
+*       16-Nov-00 : - use function prototypes, change UPROC to void.         *
+*                   - added argument to tcellproc(), removed nvector         *
+*                   - now use options.dispatch, options.groupopts is gone.   *
+*       22-Apr-01 : - Added code for compilation into Magma                  *
+*                   - Removed nauty_null() and EXTDEFS                       *
+*        2-Oct-01 : - Improved error message for bad dispatch vector         *
+*       21-Nov-01 : - use NAUTYREQUIRED in nauty_check()                     *
+*       20-Dec-02 : changes for version 2.2:                                 *
+*                   - made tcnode0 global                                    *
+*                   - added nauty_freedyn()                                  *
+*       17-Nov-03 : changed INFINITY to NAUTY_INFINITY                       *
+*       14-Sep-04 : extended prototypes even to recursive functions          *
+*       16-Oct-04 : disallow NULL dispatch vector                            *
+*       11-Nov-05 : changes for version 2.3:                                 *
+*                   - init() and cleanup() optional calls                    *
+*       23-Nov-06 : changes for version 2.4:                                 *
+*                   - use maketargetcell() instead of tcellproc()            *
+*       29-Nov-06 : add extra_autom, extra_level, extra_options              *
+*       10-Dec-06 : remove BIGNAUTY                                          *
+*       10-Nov-09 : remove shortish and permutation types                    *
+*       16-Nov-11 : added Shreier option                                     *
+*       15-Jan-12 : added TLS_ATTR to static declarations                    *
+*       18-Jan-13 : added signal aborting                                    *
+*       19-Jan-13 : added usercanonproc()                                    *
+*                                                                            *
+*****************************************************************************/
+
+#define ONE_WORD_SETS
+#include "nauty.h"
+#include "schreier.h"
+
+#ifdef NAUTY_IN_MAGMA
+#include "cleanup.e"
+#endif
+
+#define NAUTY_ABORTED (-11)
+#define NAUTY_KILLED (-12)
+
+typedef struct tcnode_struct
+{
+    struct tcnode_struct *next;
+    set *tcellptr;
+} tcnode;
+
+/* aproto: header new_nauty_protos.h */
+
+#ifndef NAUTY_IN_MAGMA
+#if !MAXN
+static int firstpathnode0(int*, int*, int, int, tcnode*);
+static int othernode0(int*, int*, int, int, tcnode*);
+#else
+static int firstpathnode(int*, int*, int, int);
+static int othernode(int*, int*, int, int);
+#endif
+static void firstterminal(int*, int);
+static int processnode(int*, int*, int, int);
+static void recover(int*, int);
+static void writemarker(int, int, int, int, int, int);
+#endif
+
+#if  MAXM==1
+#define M 1
+#else
+#define M m
+#endif
+
+#define OPTCALL(proc) if (proc != NULL) (*proc)
+
+ /* copies of some of the options: */
+static TLS_ATTR
+   boolean getcanon,digraph,writeautoms,domarkers,cartesian,doschreier;
+static TLS_ATTR int linelength,tc_level,mininvarlevel,maxinvarlevel,invararg;
+static TLS_ATTR void (*usernodeproc)(graph*,int*,int*,int,int,int,int,int,int);
+static TLS_ATTR void (*userautomproc)(int,int*,int*,int,int,int);
+static TLS_ATTR void (*userlevelproc)
+          (int*,int*,int,int*,statsblk*,int,int,int,int,int,int);
+static TLS_ATTR int (*usercanonproc)
+          (graph*,int*,graph*,int,int,int,int);
+static TLS_ATTR void (*invarproc)
+          (graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+static TLS_ATTR FILE *outfile;
+static TLS_ATTR dispatchvec dispatch;
+
+ /* local versions of some of the arguments: */
+static TLS_ATTR int m,n;
+static TLS_ATTR graph *g,*canong;
+static TLS_ATTR int *orbits;
+static TLS_ATTR statsblk *stats;
+ /* temporary versions of some stats: */
+static TLS_ATTR unsigned long invapplics,invsuccesses;
+static TLS_ATTR int invarsuclevel;
+
+ /* working variables: <the "bsf leaf" is the leaf which is best guess so
+                            far at the canonical leaf>  */
+static TLS_ATTR int gca_first, /* level of greatest common ancestor of
+				  current node and first leaf */
+    gca_canon,     /* ditto for current node and bsf leaf */
+    noncheaplevel, /* level of greatest ancestor for which cheapautom==FALSE */
+    allsamelevel,  /* level of least ancestor of first leaf for
+                      which all descendant leaves are known to be
+                      equivalent */
+    eqlev_first,   /* level to which codes for this node match those
+                      for first leaf */
+    eqlev_canon,   /* level to which codes for this node match those
+                      for the bsf leaf. */
+    comp_canon,    /* -1,0,1 according as code at eqlev_canon+1 is
+                       <,==,> that for bsf leaf.  Also used for
+                       similar purpose during leaf processing */
+    samerows,      /* number of rows of canong which are correct for
+                      the bsf leaf  BDM:correct description? */
+    canonlevel,    /* level of bsf leaf */
+    stabvertex,    /* point fixed in ancestor of first leaf at level
+                      gca_canon */
+    cosetindex;    /* the point being fixed at level gca_first */
+
+static TLS_ATTR boolean needshortprune;  /* used to flag calls to shortprune */
+
+#if !MAXN
+DYNALLSTAT(set,defltwork,defltwork_sz);
+DYNALLSTAT(int,workperm,workperm_sz);
+DYNALLSTAT(set,fixedpts,fixedpts_sz);
+DYNALLSTAT(int,firstlab,firstlab_sz);
+DYNALLSTAT(int,canonlab,canonlab_sz);
+DYNALLSTAT(short,firstcode,firstcode_sz);
+DYNALLSTAT(short,canoncode,canoncode_sz);
+DYNALLSTAT(int,firsttc,firsttc_sz);
+DYNALLSTAT(set,active,active_sz);
+
+/* In the dynamically allocated case (MAXN=0), each level of recursion
+   needs one set (tcell) to represent the target cell.  This is 
+   implemented by using a linked list of tcnode anchored at the root
+   of the search tree.  Each node points to its child (if any) and to
+   the dynamically allocated tcell.  Apart from the the first node of
+   the list, each node always has a tcell good for m up to alloc_m.
+   tcnodes and tcells are kept between calls to nauty, except that
+   they are freed and reallocated if m gets bigger than alloc_m.  */
+
+static TLS_ATTR tcnode tcnode0 = {NULL,NULL};
+static TLS_ATTR int alloc_m = 0;
+
+#else
+static TLS_ATTR set defltwork[2*MAXM];   /* workspace in case none provided */
+static TLS_ATTR int workperm[MAXN];   /* various scratch uses */
+static TLS_ATTR set fixedpts[MAXM];      /* points which were explicitly
+                                    fixed to get current node */
+static TLS_ATTR int firstlab[MAXN],   /* label from first leaf */
+               canonlab[MAXN];   /* label from bsf leaf */
+static TLS_ATTR short firstcode[MAXN+2],      /* codes for first leaf */
+         canoncode[MAXN+2];      /* codes for bsf leaf */
+static TLS_ATTR int firsttc[MAXN+2];  /* index of target cell for left path */
+static TLS_ATTR set active[MAXM];     /* used to contain index to cells now
+                                    active for refinement purposes */
+#endif
+
+static TLS_ATTR set *workspace,*worktop;  /* first and just-after-last
+		     addresses of work area to hold automorphism data */
+static TLS_ATTR set *fmptr;                   /* pointer into workspace */
+
+static TLS_ATTR schreier *gp;       /* These two for Schreier computations */
+static TLS_ATTR permnode *gens;
+
+/*****************************************************************************
+*                                                                            *
+*  This procedure finds generators for the automorphism group of a           *
+*  vertex-coloured graph and optionally finds a canonically labelled         *
+*  isomorph.  A description of the data structures can be found in           *
+*  nauty.h and in the "nauty User's Guide".  The Guide also gives            *
+*  many more details about its use, and implementation notes.                *
+*                                                                            *
+*  Parameters - <r> means read-only, <w> means write-only, <wr> means both:  *
+*           g <r>  - the graph                                               *
+*     lab,ptn <rw> - used for the partition nest which defines the colouring *
+*                  of g.  The initial colouring will be set by the program,  *
+*                  using the same colour for every vertex, if                *
+*                  options->defaultptn!=FALSE.  Otherwise, you must set it   *
+*                  yourself (see the Guide). If options->getcanon!=FALSE,    *
+*                  the contents of lab on return give the labelling of g     *
+*                  corresponding to canong.  This does not change the        *
+*                  initial colouring of g as defined by (lab,ptn), since     *
+*                  the labelling is consistent with the colouring.           *
+*     active  <r>  - If this is not NULL and options->defaultptn==FALSE,     *
+*                  it is a set indicating the initial set of active colours. *
+*                  See the Guide for details.                                *
+*     orbits  <w>  - On return, orbits[i] contains the number of the         *
+*                  least-numbered vertex in the same orbit as i, for         *
+*                  i=0,1,...,n-1.                                            *
+*    options  <r>  - A list of options.  See nauty.h and/or the Guide        *
+*                  for details.                                              *
+*      stats  <w>  - A list of statistics produced by the procedure.  See    *
+*                  nauty.h and/or the Guide for details.                     *
+*  workspace  <w>  - A chunk of memory for working storage.                  *
+*  worksize   <r>  - The number of setwords in workspace.  See the Guide     *
+*                  for guidance.                                             *
+*          m  <r>  - The number of setwords in sets.  This must be at        *
+*                  least ceil(n / WORDSIZE) and at most MAXM.                *
+*          n  <r>  - The number of vertices.  This must be at least 1 and    *
+*                  at most MAXN.                                             *
+*     canong  <w>  - The canononically labelled isomorph of g.  This is      *
+*                  only produced if options->getcanon!=FALSE, and can be     *
+*                  given as NULL otherwise.                                  *
+*                                                                            *
+*  FUNCTIONS CALLED: firstpathnode(),updatecan()                             *
+*                                                                            *
+*****************************************************************************/
+
+void
+nauty(graph *g_arg, int *lab, int *ptn, set *active_arg,
+      int *orbits_arg, optionblk *options, statsblk *stats_arg,
+      set *ws_arg, int worksize, int m_arg, int n_arg, graph *canong_arg)
+{
+    int i;
+    int numcells;
+    int retval;
+    int initstatus;
+#if !MAXN
+    tcnode *tcp,*tcq;
+#endif
+
+    /* determine dispatch vector */
+
+    if (options->dispatch == NULL)
+    {
+        fprintf(ERRFILE,">E nauty: null dispatch vector\n");
+        fprintf(ERRFILE,"Maybe you need to recompile\n");
+        exit(1);
+    }
+    else
+        dispatch = *(options->dispatch);
+
+    if (options->userrefproc) 
+        dispatch.refine = options->userrefproc;
+    else if (dispatch.refine1 && m_arg == 1)
+        dispatch.refine = dispatch.refine1;
+
+    if (dispatch.refine == NULL || dispatch.updatecan == NULL
+            || dispatch.targetcell == NULL || dispatch.cheapautom == NULL)
+    {
+        fprintf(ERRFILE,">E bad dispatch vector\n");
+        exit(1);
+    }
+
+    /* check for excessive sizes: */
+
+#if !MAXN
+    if (m_arg > NAUTY_INFINITY/WORDSIZE+1)
+    {
+        stats_arg->errstatus = MTOOBIG;
+        fprintf(ERRFILE,"nauty: need m <= %d, but m=%d\n\n",
+                NAUTY_INFINITY/WORDSIZE+1,m_arg);
+        return;
+    }
+    if (n_arg > NAUTY_INFINITY-2 || n_arg > WORDSIZE * m_arg)
+    {
+        stats_arg->errstatus = NTOOBIG;
+        fprintf(ERRFILE,"nauty: need n <= min(%d,%d*m), but n=%d\n\n",
+                NAUTY_INFINITY-2,WORDSIZE,n_arg);
+        return;
+    }
+#else
+    if (m_arg > MAXM)
+    {
+        stats_arg->errstatus = MTOOBIG;
+        fprintf(ERRFILE,"nauty: need m <= %d\n\n",MAXM);
+        return;
+    }
+    if (n_arg > MAXN || n_arg > WORDSIZE * m_arg)
+    {
+        stats_arg->errstatus = NTOOBIG;
+        fprintf(ERRFILE,
+                "nauty: need n <= min(%d,%d*m)\n\n",MAXM,WORDSIZE);
+        return;
+    }
+#endif
+    if (n_arg == 0)   /* Special code for zero-sized graph */
+    {
+        stats_arg->grpsize1 = 1.0;
+        stats_arg->grpsize2 = 0;
+        stats_arg->numorbits = 0;
+        stats_arg->numgenerators = 0;
+        stats_arg->errstatus = 0;
+        stats_arg->numnodes = 1;
+        stats_arg->numbadleaves = 0;
+        stats_arg->maxlevel = 1;
+        stats_arg->tctotal = 0;
+        stats_arg->canupdates = (options->getcanon != 0);
+        stats_arg->invapplics = 0;
+        stats_arg->invsuccesses = 0;
+        stats_arg->invarsuclevel = 0;
+        return;
+    }
+
+    /* take copies of some args, and options: */
+    m = m_arg;
+    n = n_arg;
+
+    nautil_check(WORDSIZE,m,n,NAUTYVERSIONID);
+    OPTCALL(dispatch.check)(WORDSIZE,m,n,NAUTYVERSIONID);
+
+#if !MAXN
+    DYNALLOC1(set,defltwork,defltwork_sz,2*m,"nauty");
+    DYNALLOC1(set,fixedpts,fixedpts_sz,m,"nauty");
+    DYNALLOC1(set,active,active_sz,m,"nauty");
+    DYNALLOC1(int,workperm,workperm_sz,n,"nauty");
+    DYNALLOC1(int,firstlab,firstlab_sz,n,"nauty");
+    DYNALLOC1(int,canonlab,canonlab_sz,n,"nauty");
+    DYNALLOC1(short,firstcode,firstcode_sz,n+2,"nauty");
+    DYNALLOC1(short,canoncode,canoncode_sz,n+2,"nauty");
+    DYNALLOC1(int,firsttc,firsttc_sz,n+2,"nauty");
+    if (m > alloc_m)
+    {
+        tcp = tcnode0.next;
+        while (tcp != NULL)
+        {
+            tcq = tcp->next;
+            FREES(tcp->tcellptr);
+            FREES(tcp);
+            tcp = tcq;
+        }
+        alloc_m = m;
+        tcnode0.next = NULL;
+    }
+#endif
+
+       /* OLD g = g_arg; */
+    orbits = orbits_arg;
+    stats = stats_arg;
+
+    getcanon = options->getcanon;
+    digraph = options->digraph;
+    writeautoms = options->writeautoms;
+    domarkers = options->writemarkers;
+    cartesian = options->cartesian;
+    doschreier = options->schreier;
+    if (doschreier) schreier_check(WORDSIZE,m,n,NAUTYVERSIONID);
+    linelength = options->linelength;
+    if (digraph) tc_level = 0;
+    else         tc_level = options->tc_level;
+    outfile = (options->outfile == NULL ? stdout : options->outfile);
+    usernodeproc = options->usernodeproc;
+    userautomproc = options->userautomproc;
+    userlevelproc = options->userlevelproc;
+    usercanonproc = options->usercanonproc;
+
+    invarproc = options->invarproc;
+    if (options->mininvarlevel < 0 && options->getcanon)
+        mininvarlevel = -options->mininvarlevel;
+    else
+        mininvarlevel = options->mininvarlevel;
+    if (options->maxinvarlevel < 0 && options->getcanon)
+        maxinvarlevel = -options->maxinvarlevel;
+    else
+        maxinvarlevel = options->maxinvarlevel;
+    invararg = options->invararg;
+
+    if (getcanon)
+        if (canong_arg == NULL)
+        {
+            stats_arg->errstatus = CANONGNIL;
+            fprintf(ERRFILE,
+                  "nauty: canong=NULL but options.getcanon=TRUE\n\n");
+            return;
+        }
+
+    /* initialize everything: */
+
+    if (options->defaultptn)
+    {
+        for (i = 0; i < n; ++i)   /* give all verts same colour */
+        {
+            lab[i] = i;
+            ptn[i] = NAUTY_INFINITY;
+        }
+        ptn[n-1] = 0;
+        EMPTYSET(active,m);
+        ADDELEMENT(active,0);
+        numcells = 1;
+    }
+    else
+    {
+        ptn[n-1] = 0;
+        numcells = 0;
+        for (i = 0; i < n; ++i)
+            if (ptn[i] != 0) ptn[i] = NAUTY_INFINITY;
+            else             ++numcells;
+        if (active_arg == NULL)
+        {
+            EMPTYSET(active,m);
+            for (i = 0; i < n; ++i)
+            {
+                ADDELEMENT(active,i);
+                while (ptn[i]) ++i;
+            }
+        }
+        else
+            for (i = 0; i < M; ++i) active[i] = active_arg[i];
+    }
+
+    g = canong = NULL;
+    initstatus = 0;
+    OPTCALL(dispatch.init)(g_arg,&g,canong_arg,&canong,
+            lab,ptn,active,options,&initstatus,m,n);
+    if (initstatus)
+    {
+        stats->errstatus = initstatus;
+        return;
+    }
+
+    if (g == NULL) g = g_arg;
+    if (canong == NULL) canong = canong_arg;
+
+    if (doschreier) newgroup(&gp,&gens,n);
+
+    for (i = 0; i < n; ++i) orbits[i] = i;
+    stats->grpsize1 = 1.0;
+    stats->grpsize2 = 0;
+    stats->numgenerators = 0;
+    stats->numnodes = 0;
+    stats->numbadleaves = 0;
+    stats->tctotal = 0;
+    stats->canupdates = 0;
+    stats->numorbits = n;
+    EMPTYSET(fixedpts,m);
+    noncheaplevel = 1;
+    eqlev_canon = -1;       /* needed even if !getcanon */
+
+    if (worksize >= 2 * m)
+        workspace = ws_arg;
+    else
+    {
+        workspace = defltwork;
+        worksize = 2 * m;
+    }
+    worktop = workspace + (worksize - worksize % (2 * m));
+    fmptr = workspace;
+
+    /* here goes: */
+    stats->errstatus = 0;
+    needshortprune = FALSE;
+    invarsuclevel = NAUTY_INFINITY;
+    invapplics = invsuccesses = 0;
+
+#if !MAXN
+    retval = firstpathnode0(lab,ptn,1,numcells,&tcnode0);
+#else   
+    retval = firstpathnode(lab,ptn,1,numcells);
+#endif  
+
+    if (retval == NAUTY_ABORTED)
+	stats->errstatus = NAUABORTED;
+    else if (retval == NAUTY_KILLED)
+	stats->errstatus = NAUKILLED;
+    else
+    {
+        if (getcanon)
+        {
+            (*dispatch.updatecan)(g,canong,canonlab,samerows,M,n);
+            for (i = 0; i < n; ++i) lab[i] = canonlab[i];
+        }
+        stats->invarsuclevel =
+             (invarsuclevel == NAUTY_INFINITY ? 0 : invarsuclevel);
+        stats->invapplics = invapplics;
+        stats->invsuccesses = invsuccesses;
+    }
+
+#if !MAXN
+#ifndef NAUTY_IN_MAGMA
+    if (n >= 320)
+#endif
+    {   
+        nautil_freedyn();
+        OPTCALL(dispatch.freedyn)();
+        nauty_freedyn();
+    }
+#endif  
+    OPTCALL(dispatch.cleanup)(g_arg,&g,canong_arg,&canong,
+                                           lab,ptn,options,stats,m,n);
+
+    if (doschreier)
+    {
+	freeschreier(&gp,&gens);
+	if (n >= 320) schreier_freedyn();
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  firstpathnode(lab,ptn,level,numcells) produces a node on the leftmost     *
+*  path down the tree.  The parameters describe the level and the current    *
+*  colour partition.  The set of active cells is taken from the global set   *
+*  'active'.  If the refined partition is not discrete, the leftmost child   *
+*  is produced by calling firstpathnode, and the other children by calling   *
+*  othernode.                                                                *
+*  For MAXN=0 there is an extra parameter: the address of the parent tcell   *
+*  structure.                                                                *
+*  The value returned is the level to return to.                             *
+*                                                                            *
+*  FUNCTIONS CALLED: (*usernodeproc)(),doref(),cheapautom(),                 *
+*                    firstterminal(),nextelement(),breakout(),               *
+*                    firstpathnode(),othernode(),recover(),writestats(),     *
+*                    (*userlevelproc)(),(*tcellproc)(),shortprune()          *
+*                                                                            *
+*****************************************************************************/
+
+static int
+#if !MAXN
+firstpathnode0(int *lab, int *ptn, int level, int numcells,
+          tcnode *tcnode_parent)
+#else
+firstpathnode(int *lab, int *ptn, int level, int numcells)
+#endif
+{
+    int tv;
+    int tv1,index,rtnlevel,tcellsize,tc,childcount,qinvar,refcode;
+#if !MAXN
+    set *tcell;
+    tcnode *tcnode_this;
+
+    tcnode_this = tcnode_parent->next;
+    if (tcnode_this == NULL)
+    {
+        if ((tcnode_this = (tcnode*)ALLOCS(1,sizeof(tcnode))) == NULL ||
+            (tcnode_this->tcellptr
+                         = (set*)ALLOCS(alloc_m,sizeof(set))) == NULL)
+            alloc_error("tcell");
+        tcnode_parent->next = tcnode_this;
+        tcnode_this->next = NULL;
+    }
+    tcell = tcnode_this->tcellptr;
+#else
+    set tcell[MAXM];
+#endif
+
+    ++stats->numnodes;
+
+    /* refine partition : */
+    doref(g,lab,ptn,level,&numcells,&qinvar,workperm,
+          active,&refcode,dispatch.refine,invarproc,
+          mininvarlevel,maxinvarlevel,invararg,digraph,M,n);
+    firstcode[level] = (short)refcode;
+    if (qinvar > 0)
+    {
+        ++invapplics;
+        if (qinvar == 2)
+        {
+            ++invsuccesses;
+            if (mininvarlevel < 0) mininvarlevel = level;
+            if (maxinvarlevel < 0) maxinvarlevel = level;
+            if (level < invarsuclevel) invarsuclevel = level;
+        }
+    }
+
+    tc = -1;
+    if (numcells != n)
+    {
+     /* locate new target cell, setting tc to its position in lab, tcell
+                      to its contents, and tcellsize to its size: */
+        maketargetcell(g,lab,ptn,level,tcell,&tcellsize,
+                        &tc,tc_level,digraph,-1,dispatch.targetcell,M,n);
+        stats->tctotal += tcellsize;
+    }
+    firsttc[level] = tc;
+
+    /* optionally call user-defined node examination procedure: */
+    OPTCALL(usernodeproc)
+                   (g,lab,ptn,level,numcells,tc,(int)firstcode[level],M,n);
+
+    if (numcells == n)      /* found first leaf? */
+    {
+        firstterminal(lab,level);
+        OPTCALL(userlevelproc)(lab,ptn,level,orbits,stats,0,1,1,n,0,n);
+	if (getcanon && usercanonproc != NULL)
+	{
+            (*dispatch.updatecan)(g,canong,canonlab,samerows,M,n);
+            samerows = n;
+	    if ((*usercanonproc)(g,canonlab,canong,stats->canupdates,
+                                (int)canoncode[level],M,n))
+	        return NAUTY_ABORTED;
+	}
+        return level-1;
+    }
+
+    if (noncheaplevel >= level
+                         && !(*dispatch.cheapautom)(ptn,level,digraph,n))
+        noncheaplevel = level + 1;
+
+    /* use the elements of the target cell to produce the children: */
+    index = 0;
+    for (tv1 = tv = nextelement(tcell,M,-1); tv >= 0;
+                                    tv = nextelement(tcell,M,tv))
+    {
+        if (orbits[tv] == tv)   /* ie, not equiv to previous child */
+        {
+            breakout(lab,ptn,level+1,tc,tv,active,M);
+            ADDELEMENT(fixedpts,tv);
+            cosetindex = tv;
+            if (tv == tv1)
+            {
+#if !MAXN
+                rtnlevel = firstpathnode0(lab,ptn,level+1,numcells+1,
+                                         tcnode_this);
+#else
+                rtnlevel = firstpathnode(lab,ptn,level+1,numcells+1);
+#endif
+                childcount = 1;
+                gca_first = level;
+                stabvertex = tv1;
+            }
+            else
+            {
+#if !MAXN
+                rtnlevel = othernode0(lab,ptn,level+1,numcells+1,
+                                     tcnode_this);
+#else
+                rtnlevel = othernode(lab,ptn,level+1,numcells+1);
+#endif
+                ++childcount;
+            }
+            DELELEMENT(fixedpts,tv);
+            if (rtnlevel < level)
+                return rtnlevel;
+            if (needshortprune)
+            {
+                needshortprune = FALSE;
+                shortprune(tcell,fmptr-M,M);
+            }
+            recover(ptn,level);
+        }
+        if (orbits[tv] == tv1)  /* ie, in same orbit as tv1 */
+            ++index;
+    }
+    MULTIPLY(stats->grpsize1,stats->grpsize2,index);
+
+    if (tcellsize == index && allsamelevel == level + 1)
+        --allsamelevel;
+
+    if (domarkers)
+        writemarker(level,tv1,index,tcellsize,stats->numorbits,numcells);
+    OPTCALL(userlevelproc)(lab,ptn,level,orbits,stats,tv1,index,tcellsize,
+                                                    numcells,childcount,n);
+    return level-1;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  othernode(lab,ptn,level,numcells) produces a node other than an ancestor  *
+*  of the first leaf.  The parameters describe the level and the colour      *
+*  partition.  The list of active cells is found in the global set 'active'. *
+*  The value returned is the level to return to.                             *
+*                                                                            *
+*  FUNCTIONS CALLED: (*usernodeproc)(),doref(),refine(),recover(),           *
+*                    processnode(),cheapautom(),(*tcellproc)(),shortprune(), *
+*                    nextelement(),breakout(),othernode(),longprune()        *
+*                                                                            *
+*****************************************************************************/
+
+static int
+#if !MAXN
+othernode0(int *lab, int *ptn, int level, int numcells,
+      tcnode *tcnode_parent)
+#else
+othernode(int *lab, int *ptn, int level, int numcells)
+#endif
+{
+    int tv;
+    int tv1,refcode,rtnlevel,tcellsize,tc,qinvar;
+    short code;
+#if !MAXN
+    set *tcell;
+    tcnode *tcnode_this;
+
+    tcnode_this = tcnode_parent->next;
+    if (tcnode_this == NULL)
+    {
+        if ((tcnode_this = (tcnode*)ALLOCS(1,sizeof(tcnode))) == NULL ||
+            (tcnode_this->tcellptr
+                     = (set*)ALLOCS(alloc_m,sizeof(set))) == NULL)
+            alloc_error("tcell");
+        tcnode_parent->next = tcnode_this;
+        tcnode_this->next = NULL;
+    }
+    tcell = tcnode_this->tcellptr;
+#else
+    set tcell[MAXM];
+#endif
+
+#ifdef NAUTY_IN_MAGMA
+    if (main_seen_interrupt) return NAUTY_KILLED;
+#else
+    if (nauty_kill_request) return NAUTY_KILLED;
+#endif
+
+    ++stats->numnodes;
+
+    /* refine partition : */
+    doref(g,lab,ptn,level,&numcells,&qinvar,workperm,active,
+          &refcode,dispatch.refine,invarproc,mininvarlevel,maxinvarlevel,
+          invararg,digraph,M,n);
+    code = (short)refcode;
+    if (qinvar > 0)
+    {
+        ++invapplics;
+        if (qinvar == 2)
+        {
+            ++invsuccesses;
+            if (level < invarsuclevel) invarsuclevel = level;
+        }
+    }
+
+    if (eqlev_first == level - 1 && code == firstcode[level])
+        eqlev_first = level;
+    if (getcanon)
+    {
+        if (eqlev_canon == level - 1)
+        {
+            if (code < canoncode[level])
+                comp_canon = -1;
+            else if (code > canoncode[level])
+                comp_canon = 1;
+            else
+            {
+                comp_canon = 0;
+                eqlev_canon = level;
+            }
+        }
+        if (comp_canon > 0) canoncode[level] = code;
+    }
+
+    tc = -1;
+   /* If children will be required, find new target cell and set tc to its
+      position in lab, tcell to its contents, and tcellsize to its size: */
+
+    if (numcells < n && (eqlev_first == level ||
+                         (getcanon && comp_canon >= 0)))
+    {
+        if (!getcanon || comp_canon < 0)
+        {
+            maketargetcell(g,lab,ptn,level,tcell,&tcellsize,&tc,
+                  tc_level,digraph,firsttc[level],dispatch.targetcell,M,n);
+            if (tc != firsttc[level]) eqlev_first = level - 1;
+        }
+        else
+            maketargetcell(g,lab,ptn,level,tcell,&tcellsize,&tc,
+                  tc_level,digraph,-1,dispatch.targetcell,M,n);
+        stats->tctotal += tcellsize;
+    }
+
+    /* optionally call user-defined node examination procedure: */
+    OPTCALL(usernodeproc)(g,lab,ptn,level,numcells,tc,(int)code,M,n);
+
+    /* call processnode to classify the type of this node: */
+
+    rtnlevel = processnode(lab,ptn,level,numcells);
+    if (rtnlevel < level)   /* keep returning if necessary */
+        return rtnlevel;
+    if (needshortprune)
+    {
+        needshortprune = FALSE;
+        shortprune(tcell,fmptr-M,M);
+    }
+
+    if (!(*dispatch.cheapautom)(ptn,level,digraph,n))
+        noncheaplevel = level + 1;
+
+    /* use the elements of the target cell to produce the children: */
+    for (tv1 = tv = nextelement(tcell,M,-1); tv >= 0;
+                                    tv = nextelement(tcell,M,tv))
+    {
+        breakout(lab,ptn,level+1,tc,tv,active,M);
+        ADDELEMENT(fixedpts,tv);
+#if !MAXN   
+        rtnlevel = othernode0(lab,ptn,level+1,numcells+1,tcnode_this);
+#else
+        rtnlevel = othernode(lab,ptn,level+1,numcells+1);
+#endif
+        DELELEMENT(fixedpts,tv);
+
+        if (rtnlevel < level) return rtnlevel;
+    /* use stored automorphism data to prune target cell: */
+        if (needshortprune)
+        {
+            needshortprune = FALSE;
+            shortprune(tcell,fmptr-M,M);
+        }
+        if (tv == tv1)
+        {
+	    longprune(tcell,fixedpts,workspace,fmptr,M);
+	    if (doschreier) pruneset(fixedpts,gp,&gens,tcell,M,n);
+	}
+
+        recover(ptn,level);
+    }
+
+    return level-1;
+}
+
+/*****************************************************************************
+*                                                                            *
+*  Process the first leaf of the tree.                                       *
+*                                                                            *
+*  FUNCTIONS CALLED: NONE                                                    *
+*                                                                            *
+*****************************************************************************/
+
+static void
+firstterminal(int *lab, int level)
+{
+    int i;
+
+    stats->maxlevel = level;
+    gca_first = allsamelevel = eqlev_first = level;
+    firstcode[level+1] = 077777;
+    firsttc[level+1] = -1;
+
+    for (i = 0; i < n; ++i) firstlab[i] = lab[i];
+
+    if (getcanon)
+    {
+        canonlevel = eqlev_canon = gca_canon = level;
+        comp_canon = 0;
+        samerows = 0;
+        for (i = 0; i < n; ++i) canonlab[i] = lab[i];
+        for (i = 0; i <= level; ++i) canoncode[i] = firstcode[i];
+        canoncode[level+1] = 077777;
+        stats->canupdates = 1;
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  Process a node other than the first leaf or its ancestors.  It is first   *
+*  classified into one of five types and then action is taken appropriate    *
+*  to that type.  The types are                                              *
+*                                                                            *
+*  0:   Nothing unusual.  This is just a node internal to the tree whose     *
+*         children need to be generated sometime.                            *
+*  1:   This is a leaf equivalent to the first leaf.  The mapping from       *
+*         firstlab to lab is thus an automorphism.  After processing the     *
+*         automorphism, we can return all the way to the closest invocation  *
+*         of firstpathnode.                                                  *
+*  2:   This is a leaf equivalent to the bsf leaf.  Again, we have found an  *
+*         automorphism, but it may or may not be as useful as one from a     *
+*         type-1 node.  Return as far up the tree as possible.               *
+*  3:   This is a new bsf node, provably better than the previous bsf node.  *
+*         After updating canonlab etc., treat it the same as type 4.         *
+*  4:   This is a leaf for which we can prove that no descendant is          *
+*         equivalent to the first or bsf leaf or better than the bsf leaf.   *
+*         Return up the tree as far as possible, but this may only be by     *
+*         one level.                                                         *
+*                                                                            *
+*  Types 2 and 3 can't occur if getcanon==FALSE.                             *
+*  The value returned is the level in the tree to return to, which can be    *
+*  anywhere up to the closest invocation of firstpathnode.                   *
+*                                                                            *
+*  FUNCTIONS CALLED:    isautom(),updatecan(),testcanlab(),fmperm(),         *
+*                       writeperm(),(*userautomproc)(),orbjoin(),            *
+*                       shortprune(),fmptn()                                 *
+*                                                                            *
+*****************************************************************************/
+
+static int
+processnode(int *lab, int *ptn, int level, int numcells)
+{
+    int i,code,save,newlevel;
+    boolean ispruneok;
+    int sr;
+
+    code = 0;
+    if (eqlev_first != level && (!getcanon || comp_canon < 0))
+        code = 4;
+    else if (numcells == n)
+    {
+        if (eqlev_first == level)
+        {
+            for (i = 0; i < n; ++i) workperm[firstlab[i]] = lab[i];
+
+            if (gca_first >= noncheaplevel ||
+                               (*dispatch.isautom)(g,workperm,digraph,M,n))
+                code = 1;
+        }
+        if (code == 0)
+        {
+            if (getcanon)
+            {
+                sr = 0;
+                if (comp_canon == 0)
+                {
+                    if (level < canonlevel)
+                        comp_canon = 1;
+                    else
+                    {
+                        (*dispatch.updatecan)
+                                          (g,canong,canonlab,samerows,M,n);
+                        samerows = n;
+                        comp_canon
+                            = (*dispatch.testcanlab)(g,canong,lab,&sr,M,n);
+                    }
+                }
+                if (comp_canon == 0)
+                {
+                    for (i = 0; i < n; ++i) workperm[canonlab[i]] = lab[i];
+                    code = 2;
+                }
+                else if (comp_canon > 0)
+                    code = 3;
+                else
+                    code = 4;
+            }
+            else
+                code = 4;
+        }
+    }
+
+    if (code != 0 && level > stats->maxlevel) stats->maxlevel = level;
+
+    switch (code)
+    {
+    case 0:                 /* nothing unusual noticed */
+        return level;
+
+    case 1:                 /* lab is equivalent to firstlab */
+        if (fmptr == worktop) fmptr -= 2 * M;
+        fmperm(workperm,fmptr,fmptr+M,M,n);
+        fmptr += 2 * M;
+        if (writeautoms)
+            writeperm(outfile,workperm,cartesian,linelength,n);
+        stats->numorbits = orbjoin(orbits,workperm,n);
+        ++stats->numgenerators;
+        OPTCALL(userautomproc)(stats->numgenerators,workperm,orbits,
+                                    stats->numorbits,stabvertex,n);
+        if (doschreier) addgenerator(&gp,&gens,workperm,n);
+        return gca_first;
+
+    case 2:                 /* lab is equivalent to canonlab */
+        if (fmptr == worktop) fmptr -= 2 * M;
+        fmperm(workperm,fmptr,fmptr+M,M,n);
+        fmptr += 2 * M;
+        save = stats->numorbits;
+        stats->numorbits = orbjoin(orbits,workperm,n);
+        if (stats->numorbits == save)
+        {
+            if (gca_canon != gca_first) needshortprune = TRUE;
+            return gca_canon;
+        }
+        if (writeautoms)
+            writeperm(outfile,workperm,cartesian,linelength,n);
+        ++stats->numgenerators;
+        OPTCALL(userautomproc)(stats->numgenerators,workperm,orbits,
+                                    stats->numorbits,stabvertex,n);
+        if (doschreier) addgenerator(&gp,&gens,workperm,n);
+        if (orbits[cosetindex] < cosetindex)
+            return gca_first;
+        if (gca_canon != gca_first)
+            needshortprune = TRUE;
+        return gca_canon;
+
+    case 3:                 /* lab is better than canonlab */
+        ++stats->canupdates;
+        for (i = 0; i < n; ++i) canonlab[i] = lab[i];
+        canonlevel = eqlev_canon = gca_canon = level;
+        comp_canon = 0;
+        canoncode[level+1] = 077777;
+        samerows = sr;
+	if (getcanon && usercanonproc != NULL)
+	{
+            (*dispatch.updatecan)(g,canong,canonlab,samerows,M,n);
+            samerows = n;
+	    if ((*usercanonproc)(g,canonlab,canong,stats->canupdates,
+                                (int)canoncode[level],M,n))
+	        return NAUTY_ABORTED;
+	}
+        break;
+
+    case 4:                /* non-automorphism terminal node */
+        ++stats->numbadleaves;
+        break;
+    }  /* end of switch statement */
+
+    /* only cases 3 and 4 get this far: */
+    if (level != noncheaplevel)
+    {
+        ispruneok = TRUE;
+        if (fmptr == worktop) fmptr -= 2 * M;
+        fmptn(lab,ptn,noncheaplevel,fmptr,fmptr+M,M,n);
+        fmptr += 2 * M;
+    }
+    else
+        ispruneok = FALSE;
+
+    save = (allsamelevel > eqlev_canon ? allsamelevel-1 : eqlev_canon);
+    newlevel = (noncheaplevel <= save ? noncheaplevel-1 : save);
+
+    if (ispruneok && newlevel != gca_first) needshortprune = TRUE;
+    return newlevel;
+ }
+
+/*****************************************************************************
+*                                                                            *
+*  Recover the partition nest at level 'level' and update various other      *
+*  parameters.                                                               *
+*                                                                            *
+*  FUNCTIONS CALLED: NONE                                                    *
+*                                                                            *
+*****************************************************************************/
+
+static void
+recover(int *ptn, int level)
+{
+    int i;
+
+    for (i = 0; i < n; ++i)
+        if (ptn[i] > level) ptn[i] = NAUTY_INFINITY;
+
+    if (level < noncheaplevel) noncheaplevel = level + 1;
+    if (level < eqlev_first) eqlev_first = level;
+    if (getcanon)
+    {
+        if (level < gca_canon) gca_canon = level;
+        if (level <= eqlev_canon)
+        {
+            eqlev_canon = level;
+            comp_canon = 0;
+        }
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  Write statistics concerning an ancestor of the first leaf.                *
+*                                                                            *
+*  level = its level                                                         *
+*  tv = the vertex fixed to get the first child = the smallest-numbered      *
+*               vertex in the target cell                                    *
+*  cellsize = the size of the target cell                                    *
+*  index = the number of vertices in the target cell which were equivalent   *
+*               to tv = the index of the stabiliser of tv in the group       *
+*               fixing the colour partition at this level                    *
+*                                                                            *
+*  numorbits = the number of orbits of the group generated by all the        *
+*               automorphisms so far discovered                              *
+*                                                                            *
+*  numcells = the total number of cells in the equitable partition at this   *
+*               level                                                        *
+*                                                                            *
+*  FUNCTIONS CALLED: itos(),putstring()                                      *
+*                                                                            *
+*****************************************************************************/
+
+static void
+writemarker(int level, int tv, int index, int tcellsize,
+        int numorbits, int numcells)
+{
+    char s[30];
+
+#define PUTINT(i) itos(i,s); putstring(outfile,s)
+#define PUTSTR(x) putstring(outfile,x)
+
+    PUTSTR("level ");
+    PUTINT(level);
+    PUTSTR(":  ");
+    if (numcells != numorbits)
+    {
+        PUTINT(numcells);
+        PUTSTR(" cell");
+        if (numcells == 1) PUTSTR("; ");
+        else               PUTSTR("s; ");
+    }
+    PUTINT(numorbits);
+    PUTSTR(" orbit");
+    if (numorbits == 1) PUTSTR("; ");
+    else                PUTSTR("s; ");
+    PUTINT(tv+labelorg);
+    PUTSTR(" fixed; index ");
+    PUTINT(index);
+    if (tcellsize != index)
+    {
+        PUTSTR("/");
+        PUTINT(tcellsize);
+    }
+    PUTSTR("\n");
+}
+
+/*****************************************************************************
+*                                                                            *
+*  nauty_check() checks that this file is compiled compatibly with the       *
+*  given parameters.   If not, call exit(1).                                 *
+*                                                                            *
+*****************************************************************************/
+
+void
+nauty_check(int wordsize, int m, int n, int version)
+{
+    if (wordsize != WORDSIZE)
+    {
+        fprintf(ERRFILE,"Error: WORDSIZE mismatch in nauty.c\n");
+        exit(1);
+    }
+
+#if MAXN
+    if (m > MAXM)
+    {
+        fprintf(ERRFILE,"Error: MAXM inadequate in nauty.c\n");
+        exit(1);
+    }
+
+    if (n > MAXN)
+    {
+        fprintf(ERRFILE,"Error: MAXN inadequate in nauty.c\n");
+        exit(1);
+    }
+#endif
+
+    if (version < NAUTYREQUIRED)
+    {
+        fprintf(ERRFILE,"Error: nauty.c version mismatch\n");
+        exit(1);
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  extra_autom(p,n)  - add an extra automophism, hard to do correctly        *
+*                                                                            *
+*****************************************************************************/
+
+void
+extra_autom(int *p, int n)
+{
+    if (writeautoms)
+        writeperm(outfile,p,cartesian,linelength,n);
+    stats->numorbits = orbjoin(orbits,p,n);
+    ++stats->numgenerators;
+    OPTCALL(userautomproc)(stats->numgenerators,p,orbits,
+                                    stats->numorbits,stabvertex,n);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  extra_level(level,lab,ptn,numcells,tv1,index,tcellsize,childcount)        *
+*     creates an artificial level in the search.  This is dangerous.         *
+*                                                                            *
+*****************************************************************************/
+
+void
+extra_level(int level, int *lab, int *ptn, int numcells, int tv1, int index,
+        int tcellsize, int childcount, int n)
+{
+    MULTIPLY(stats->grpsize1,stats->grpsize2,index);
+    if (domarkers)
+        writemarker(level,tv1,index,tcellsize,stats->numorbits,numcells);
+    OPTCALL(userlevelproc)(lab,ptn,level,orbits,stats,tv1,index,tcellsize,
+                                                    numcells,childcount,n);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  nauty_freedyn() frees all the dynamic memory used in this module.         *
+*                                                                            *
+*****************************************************************************/
+
+void
+nauty_freedyn(void)
+{
+#if !MAXN
+    tcnode *tcp,*tcq;
+
+    tcp = tcnode0.next;
+    while (tcp != NULL)
+    {   
+        tcq = tcp->next;
+        FREES(tcp->tcellptr);
+        FREES(tcp);
+        tcp = tcq;
+    }
+    alloc_m = 0;
+    tcnode0.next = NULL;
+    DYNFREE(firsttc,firsttc_sz);
+    DYNFREE(canoncode,canoncode_sz);
+    DYNFREE(firstcode,firstcode_sz);
+    DYNFREE(workperm,workperm_sz);
+    DYNFREE(canonlab,canonlab_sz);
+    DYNFREE(firstlab,firstlab_sz);
+    DYNFREE(defltwork,defltwork_sz);
+    DYNFREE(fixedpts,fixedpts_sz);
+    DYNFREE(active,active_sz);
+#endif  
+}
diff --git a/lib/nauty/nauty.h b/lib/nauty/nauty.h
new file mode 100644
index 0000000..2215c2f
--- /dev/null
+++ b/lib/nauty/nauty.h
@@ -0,0 +1,1225 @@
+/**************************************************************************
+*    This is the header file for Version 2.6 of nauty().                  *
+*    nauty.h.  Generated from nauty-h.in by configure.
+**************************************************************************/
+
+#ifndef  _NAUTY_H_    /* only process this file once */
+#define  _NAUTY_H_
+
+/* The parts between the ==== lines are modified by configure when
+creating nauty.h out of nauty-h.in.  If configure is not being used,
+it is necessary to check they are correct.
+====================================================================*/
+
+/* Check whether various headers or options are available */
+#define HAVE_UNISTD_H  1    /* <unistd.h> */
+#define HAVE_SYSTYPES_H  1    /* <sys/types.h> */
+#define HAVE_STDDEF_H  1     /* <stddef.h> */
+#define HAVE_STDLIB_H  1    /* <stdlib.h> */
+#define HAVE_STRING_H  1    /* <string.h> */
+#define MALLOC_DEC 1  /* 1 = malloc() is declared in stdlib.h, */
+				 /* 2 = in malloc.h, 0 = in neither place */
+#define HAS_MATH_INF 1 /* INFINITY is defined in math.h or */
+				 /* some system header likely to be used */
+#define HAS_STDIO_UNLOCK 1  /* Whether there are getc_unlocked, */
+		               /* putc_unlocked,flockfile and funlockfile*/
+
+#define DEFAULT_WORDSIZE 0
+#define SIZEOF_INT 4
+#define SIZEOF_LONG 8
+#define SIZEOF_LONG_LONG 8   /* 0 if nonexistent */
+#define SIZEOF_INT128 16   /* 0 if nonexistent */
+
+#define HAVE_CONST 1    /* compiler properly supports const */
+
+/* Note that the following is only for running nauty in multiple threads
+   and will slow it down a little otherwise. */
+#define HAVE_TLS 0   /* have storage attribute for thread-local */
+#define TLS_ATTR   /* if so, what it is.  if not, empty */
+
+#define USE_ANSICONTROLS 0 
+                          /* whether --enable-ansicontrols is used */
+
+#define _FILE_OFFSET_BITS 0
+#if _FILE_OFFSET_BITS == 64
+#define _LARGEFILE_SOURCE
+#else
+#undef _FILE_OFFSET_BITS
+#endif
+
+/* Support of gcc extensions __builtin_clz, __builtin_clzl, __builtin_clzll */
+#define HAVE_CLZ 1
+#define HAVE_CLZL 1
+#define HAVE_CLZLL 1
+
+/* Support of gcc extensions
+      __builtin_popcount, __builtin_popcountl, __builtin_popcountll
+   Note that these may only be fast if the compiler switch -mpopcnt is used.
+
+   Also the intrinsics
+      _mm_popcnt_u32, _mm_popcnt_u64
+   for the Intel compiler icc.  These need no compiler switch.
+*/
+#define HAVE_HWPOPCNT 0
+#define HAVE_POPCNT 0
+#define HAVE_POPCNTL 0
+#define HAVE_POPCNTLL 0
+#define HAVE_MMPOP32 0
+#define HAVE_MMPOP64 0
+
+/*==================================================================*/
+
+/* The following line must be uncommented for compiling into Magma. */
+/* #define NAUTY_IN_MAGMA  */
+
+#ifdef NAUTY_IN_MAGMA
+#include "defs.h"
+#include "system.h"
+#include "bs.h"
+#define OLDEXTDEFS
+#else
+#include <stdio.h>
+#define P_(x) x
+#endif
+
+#if defined(__unix) || defined(__unix__) || defined(unix)
+#define SYS_UNIX
+#endif
+
+#if !HAVE_CONST
+#define const
+#endif
+
+/*****************************************************************************
+*                                                                            *
+*    AUTHOR: Brendan D. McKay                                                *
+*            Research School of Computer Science                             *
+*            Australian National University                                  *
+*            Canberra, ACT 2601, Australia                                   *
+*            phone:  +61 2 6125 3845                                         *
+*            email:  Brendan.McKay@anu.edu.au                                *
+*                                                                            *
+*  This software is subject to copyright as detailed in the file COPYRIGHT.  *
+*                                                                            *
+*   Reference manual:                                                        *
+*     B. D. McKay and A. Piperno, nauty User's Guide (Version 2.5),          *
+*         http://pallini.di.uniroma1.it                                      *
+*         http://cs.anu.edu.au/~bdm/nauty/                                   *
+*                                                                            *
+*   CHANGE HISTORY                                                           *
+*       10-Nov-87 : final changes for version 1.2                            *
+*        5-Dec-87 : renamed to version 1.3 (no changes to this file)         *
+*       28-Sep-88 : added PC Turbo C support, making version 1.4             *
+*       23-Mar-89 : changes for version 1.5 :                                *
+*                   - reworked M==1 code                                     *
+*                   - defined NAUTYVERSION string                            *
+*                   - made NAUTYH_READ to allow this file to be read twice   *
+*                   - added optional ANSI function prototypes                *
+*                   - added validity check for WORDSIZE                      *
+*                   - added new fields to optionblk structure                *
+*                   - updated DEFAULTOPTIONS to add invariants fields        *
+*                   - added (set*) cast to definition of GRAPHROW            *
+*                   - added definition of ALLOCS and FREES                   *
+*       25-Mar-89 : - added declaration of new function doref()              *
+*                   - added UNION macro                                      *
+*       29-Mar-89 : - reduced the default MAXN for small machines            *
+*                   - removed OUTOFSPACE (no longer used)                    *
+*                   - added SETDIFF and XOR macros                           *
+*        2-Apr-89 : - extended statsblk structure                            *
+*        4-Apr-89 : - added IS_* macros                                      *
+*                   - added ERRFILE definition                               *
+*                   - replaced statsblk.outofspace by statsblk.errstatus     *
+*        5-Apr-89 : - deleted definition of np2vector (no longer used)       *
+*                   - introduced EMPTYSET macro                              *
+*       12-Apr-89 : - eliminated MARK, UNMARK and ISMARKED (no longer used)  *
+*       18-Apr-89 : - added MTOOBIG and CANONGNIL                            *
+*       12-May-89 : - made ISELEM1 and ISELEMENT return 0 or 1               *
+*        2-Mar-90 : - added EXTPROC macro and used it                        *
+*       12-Mar-90 : - added SYS_CRAY, with help from N. Sloane and A. Grosky *
+*                   - added dummy groupopts field to optionblk               *
+*                   - select some ANSI things if __STDC__ exists             *
+*       20-Mar-90 : - changed default MAXN for Macintosh versions            *
+*                   - created SYS_MACTHINK for Macintosh THINK compiler      *
+*       27-Mar-90 : - split SYS_MSDOS into SYS_PCMS4 and SYS_PCMS5           *
+*       13-Oct-90 : changes for version 1.6:                                 *
+*                   - fix definition of setword for WORDSIZE==64             *
+*       14-Oct-90 : - added SYS_APOLLO version to avoid compiler bug         *
+*       15-Oct-90 : - improve detection of ANSI conformance                  *
+*       17-Oct-90 : - changed temp name in EMPTYSET to avoid A/UX bug        *
+*       16-Apr-91 : changes for version 1.7:                                 *
+*                   - made version SYS_PCTURBO use free(), not cfree()       *
+*        2-Sep-91 : - noted that SYS_PCMS5 also works for Quick C            *
+*                   - moved MULTIPLY to here from nauty.c                    *
+*       12-Jun-92 : - changed the top part of this comment                   *
+*       27-Aug-92 : - added version SYS_IBMC, thanks to Ivo Duentsch         *
+*        5-Jun-93 : - renamed to version 1.7+, only change in naututil.h     *
+*       29-Jul-93 : changes for version 1.8:                                 *
+*                   - fixed error in default 64-bit version of FIRSTBIT      *
+*                     (not used in any version before ALPHA)                 *
+*                   - installed ALPHA version (thanks to Gordon Royle)       *
+*                   - defined ALLOCS,FREES for SYS_IBMC                      *
+*        3-Sep-93 : - make calloc void* in ALPHA version                     *
+*       17-Sep-93 : - renamed to version 1.9,                                *
+*                        changed only dreadnaut.c and nautinv.c              *
+*       24-Feb-94 : changes for version 1.10:                                *
+*                   - added version SYS_AMIGAAZT, thanks to Carsten Saager   *
+*                     (making 1.9+)                                          *
+*       19-Apr-95 : - added prototype wrapper for C++,                       *
+*                     thanks to Daniel Huson                                 *
+*        5-Mar-96 : - added SYS_ALPHA32 version (32-bit setwords on Alpha)   *
+*       13-Jul-96 : changes for version 2.0:                                 *
+*                   - added dynamic allocation                               *
+*                   - ERRFILE must be defined                                *
+*                   - added FLIPELEM1 and FLIPELEMENT macros                 *
+*       13-Aug-96 : - added SWCHUNK? macros                                  *
+*                   - added TAKEBIT macro                                    *
+*       28-Nov-96 : - include sys/types.h if not ANSI (tentative!)           *
+*       24-Jan-97 : - and stdlib.h if ANSI                                   *
+*                   - removed use of cfree() from UNIX variants              *
+*       25-Jan-97 : - changed options.getcanon from boolean to int           *
+*                     Backwards compatibility is ok, as boolean and int      *
+*                     are the same.  Now getcanon=2 means to get the label   *
+*                     and not care about the group.  Sometimes faster.       *
+*        6-Feb-97 : - Put in #undef for FALSE and TRUE to cope with          *
+*                     compilers that illegally predefine them.               *
+*                   - declared nauty_null and nautil_null                    *
+*        2-Jul-98 : - declared ALLBITS                                       *
+*       21-Oct-98 : - allow WORDSIZE==64 using unsigned long long            *
+*                   - added BIGNAUTY option for really big graphs            *
+*       11-Dec-99 : - made bit, leftbit and bytecount static in each file    *
+*        9-Jan-00 : - declared nauty_check() and nautil_check()              *
+*       12-Feb-00 : - Used #error for compile-time checks                    *
+*                   - Added DYNREALLOC                                       *
+*        4-Mar-00 : - declared ALLMASK(n)                                    *
+*       27-May-00 : - declared CONDYNFREE                                    *
+*       28-May-00 : - declared nautil_freedyn()                              *
+*       16-Aug-00 : - added OLDNAUTY and changed canonical labelling         *
+*       16-Nov-00 : - function prototypes are now default and unavoidable    *
+*                   - removed UPROC, now assume all compilers know void      *
+*                   - removed nvector, now just int (as it always was)       *
+*                   - added extra parameter to targetcell()                  *
+*                   - removed old versions which were only to skip around    *
+*                     bugs that should have been long fixed:                 *
+*                     SYS_APOLLO and SYS_VAXBSD.                             *
+*                   - DEFAULTOPIONS now specifies no output                  *
+*                   - Removed obsolete SYS_MACLSC version                    *
+*       21-Apr-01 : - Added code to satisfy compilation into Magma.  This    *
+*                       is activated by defining NAUTY_IN_MAGMA above.       *
+*                   - The *_null routines no longer exist                    *
+*                   - Default maxinvarlevel is now 1.  (This has no effect   *
+*                        unless an invariant is specified.)                  *
+*                   - Now labelorg has a concrete declaration in nautil.c    *
+*                        and EXTDEFS is not needed                           *
+*        5-May-01 : - NILFUNCTION, NILSET, NILGRAPH now obsolete.  Use NULL. *
+*       11-Sep-01 : - setword is unsigned int in the event that UINT_MAX     *
+*                     is defined and indicates it is big enough              *
+*       17-Oct-01 : - major rewrite for 2.1.  SYS_* variables gone!          *
+*                     Some modernity assumed, eg size_t                      *
+*        8-Aug-02 : - removed MAKEEMPTY  (use EMPTYSET instead)              *
+*                   - deleted OLDNAUTY everywhere                            *
+*       27-Aug-02 : - converted to use autoconf.  Now the original of this   *
+*                     file is nauty-h.in. Run configure to make nauty.h.     *
+*       20-Dec-02 : - increased INFINITY                                     *
+*                     some reorganization to please Magma                    *
+*                   - declared nauty_freedyn()                               *
+*       17-Nov-03 : - renamed INFINITY to NAUTY_INFINITY                     *
+*       29-May-04 : - added definition of SETWORD_FORMAT                     *
+*       14-Sep-04 : - extended prototypes even to recursive functions        *
+*       16-Oct-04 : - added DEFAULTOPTIONS_GRAPH                             *
+*       24-Oct-04 : Starting 2.3                                             *
+*                   - remove register declarations as modern compilers       *
+*                     tend to find them a nuisance                           *
+*                   - Don't define the obsolete symbol INFINITY if it is     *
+*                     defined already                                        *
+*       17-Nov-04 : - make 6 counters in statsblk unsigned long              *
+*       17-Jan-04 : - add init() and cleanup() to dispatchvec                *
+*       12-Nov-05 : - Changed NAUTY_INFINITY to 2^30+2 in BIGNAUTY case      *
+*       22-Nov-06 : Starting 2.4                                             *
+*                   - removed usertcellproc from options                     *
+*                     changed bestcell to targetcell in dispatch vector      *
+*                     declare targetcell and maketargetcell                  *
+*       29-Nov-06 : - add extraoptions to optionblk                          *
+*                   - add declarations of extra_autom and extra_level        *
+*       10-Dec-06 : - BIGNAUTY is gone!  Now permutation=shortish=int.       *
+*                     NAUTY_INFINITY only depends on whether sizeof(int)=2.  *
+*       27-Jun-08 : - define nauty_counter and LONG_LONG_COUNTERS            *
+*       30-Jun-08 : - declare version 2.4                                    *
+*        8-Nov-09 : - final release of version 2.4;                          *
+*       10-Nov-10 : Starting 2.5                                             *
+*                   - declare shortish and permutation obsolete, now int     *
+*       14-Nov-10 : - SETWORDSNEEDED(n)                                      *
+*       23-May-10 : - declare densenauty()                                   *
+*       29-Jun-10 : - add PRINT_COUNTER(f,x)                                 *
+*                   - add DEFAULTOPTIONS_DIGRAPH()                           *
+*       27-Mar-11 : - declare writegroupsize()                               *
+*       14-Jan-12 : - add HAVE_TLS and TLS_ATTR                              *
+*       21-Feb-12 : - add ENABLE_ANSI                                        *
+*       18-Mar-12 : - add COUNTER_FMT                                        *
+*       18-Aug-12 : - add ADDONEARC, ADDONEEDGE, EMPTYGRAPH                  *
+*       29-Aug-12 : - add CLZ macros and FIRSTBITNZ                          *
+*       19-Oct-12 : - add DEFAULT_WORDSIZE                                   *
+*        3-Jan-12 : Released 2.5rc1                                          *
+*       18-Jan-12 : Froze 2.5                                                *
+*       18-Jan-12 : - add NAUABORTED and NAUKILLED                           *
+*                   - add nauty_kill_request                                 *
+*                   - add usercanonproc                                      *
+*        1-Oct-15 : - add COUNTER_FMT_RAW                                    *
+*       10-Jan-16 : - defined POPCOUNTMAC, optionally use popcnt             *
+*                   - remove SYS_CRAY, let's hope it is long obsolete        *
+*                   - add Intel popcount intrinsics for icc                  *
+*       12-Jan-16 : - DYNFREE and CONDYNFREE now set the pointer to NULL     *
+*       16-Jan-16 : - Change NAUTY_INFINITY to 2 billion + 2                 *
+*                 : Froze 2.6                                                *
+*       12-Mar-16 : - Add const to alloc_error()                             *
+*                                                                            *
+* ++++++ This file is automatically generated, don't edit it by hand! ++++++
+*                                                                            *
+*****************************************************************************/
+
+/*****************************************************************************
+*                                                                            *
+*   16-bit, 32-bit and 64-bit versions can be selected by defining WORDSIZE. *
+*   The largest graph that can be handled has MAXN vertices.                 *
+*   Both WORDSIZE and MAXN can be defined on the command line.               *
+*   WORDSIZE must be 16, 32 or 64; MAXN must be <= NAUTY_INFINITY-2;         *
+*                                                                            *
+*   With a very slight loss of efficiency (depending on platform), nauty     *
+*   can be compiled to dynamically allocate arrays.  Predefine MAXN=0 to     *
+*   achieve this effect, which is default behaviour from version 2.0.        *
+*   In that case, graphs of size up to NAUTY_INFINITY-2 can be handled       *
+*   if the the memory is available.                                          *
+*                                                                            *
+*   If only very small graphs need to be processed, use MAXN<=WORDSIZE       *
+*   since this causes substantial code optimizations.                        *
+*                                                                            *
+*   Conventions and Assumptions:                                             *
+*                                                                            *
+*    A 'setword' is the chunk of memory that is occupied by one part of      *
+*    a set.  This is assumed to be >= WORDSIZE bits in size.                 *
+*                                                                            *
+*    The rightmost (loworder) WORDSIZE bits of setwords are numbered         *
+*    0..WORDSIZE-1, left to right.  It is necessary that the 2^WORDSIZE      *
+*    setwords with the other bits zero are totally ordered under <,=,>.      *
+*    This needs care on a 1's-complement machine.                            *
+*                                                                            *
+*    The int variables m and n have consistent meanings throughout.          *
+*    Graphs have n vertices always, and sets have m setwords always.         *
+*                                                                            *
+*    A 'set' consists of m contiguous setwords, whose bits are numbered      *
+*    0,1,2,... from left (high-order) to right (low-order), using only       *
+*    the rightmost WORDSIZE bits of each setword.  It is used to             *
+*    represent a subset of {0,1,...,n-1} in the usual way - bit number x     *
+*    is 1 iff x is in the subset.  Bits numbered n or greater, and           *
+*    unnumbered bits, are assumed permanently zero.                          *
+*                                                                            *
+*    A 'graph' consists of n contiguous sets.  The i-th set represents       *
+*    the vertices adjacent to vertex i, for i = 0,1,...,n-1.                 *
+*                                                                            *
+*    A 'permutation' is an array of n ints repesenting a permutation of      *
+*    the set {0,1,...,n-1}.  The value of the i-th entry is the number to    *
+*    which i is mapped.                                                      *
+*                                                                            *
+*    If g is a graph and p is a permutation, then g^p is the graph in        *
+*    which vertex i is adjacent to vertex j iff vertex p[i] is adjacent      *
+*    to vertex p[j] in g.                                                    *
+*                                                                            *
+*    A partition nest is represented by a pair (lab,ptn), where lab and ptn  *
+*    are int arrays.  The "partition at level x" is the partition whose      *
+*    cells are {lab[i],lab[i+1],...,lab[j]}, where [i,j] is a maximal        *
+*    subinterval of [0,n-1] such that ptn[k] > x for i <= k < j and          *
+*    ptn[j] <= x.  The partition at level 0 is given to nauty by the user.   *
+*    This is  refined for the root of the tree, which has level 1.           *
+*                                                                            *
+*****************************************************************************/
+
+#ifndef NAUTY_IN_MAGMA
+#if HAVE_SYSTYPES_H
+#include <sys/types.h>
+#endif
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#if HAVE_STDDEF_H
+#include <stddef.h>
+#endif
+#if HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#if HAVE_STRING_H
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+#endif
+
+/* WORDSIZE is the number of set elements per setword (16, 32 or 64).
+   WORDSIZE and setword are defined as follows:
+
+   DEFAULT_WORDSIZE is usually 0 but is set by the configure script
+   to NN if --enable-wordsize=NN is used, where NN is 16, 32 or 64.
+
+   If WORDSIZE is not defined, but DEFAULT_WORDSIZE > 0, then set
+      WORDSIZE to the same value as DEFAULT_WORDSIZE.
+   If WORDSIZE is so far undefined, use 32 unless longs have more 
+      than 32 bits, in which case use 64.
+   Define setword thus:
+      WORDSIZE==16 : unsigned short
+      WORDSIZE==32 : unsigned int unless it is too small,
+			in which case unsigned long
+      WORDSIZE==64 : the first of unsigned int, unsigned long,
+                      unsigned long long, which is large enough.
+*/
+
+#ifdef NAUTY_IN_MAGMA
+#undef WORDSIZE
+#define WORDSIZE WORDBITS
+#endif
+
+#ifndef WORDSIZE
+#if DEFAULT_WORDSIZE > 0
+#define WORDSIZE DEFAULT_WORDSIZE
+#endif
+#endif
+
+#ifdef WORDSIZE
+
+#if  (WORDSIZE != 16) && (WORDSIZE != 32) && (WORDSIZE != 64)
+ #error "WORDSIZE must be 16, 32 or 64"
+#endif
+
+#else  /* WORDSIZE undefined */
+
+#if SIZEOF_LONG>4
+#define WORDSIZE 64
+#else
+#define WORDSIZE 32
+#endif
+
+#endif  /* WORDSIZE */
+
+#ifdef NAUTY_IN_MAGMA
+typedef t_uint setword;
+#define SETWORD_INT  /* Don't assume this is correct in Magma. */
+
+#else /* NAUTY_IN_MAGMA */
+
+#if WORDSIZE==16
+typedef unsigned short setword;
+#define SETWORD_SHORT
+#endif
+
+#if WORDSIZE==32
+#if SIZEOF_INT>=4
+typedef unsigned int setword;
+#define SETWORD_INT
+#else
+typedef unsigned long setword;
+#define SETWORD_LONG
+#endif
+#endif
+
+#if WORDSIZE==64
+#if SIZEOF_INT>=8
+typedef unsigned int setword;
+#define SETWORD_INT
+#else
+#if SIZEOF_LONG>=8
+typedef unsigned long setword;
+#define SETWORD_LONG
+#else
+typedef unsigned long long setword;
+#define SETWORD_LONGLONG
+#endif
+#endif
+#endif
+
+#endif /* NAUTY_IN_MAGMA else */
+
+#if SIZEOF_LONG_LONG>=8 && SIZEOF_LONG==4
+typedef unsigned long long nauty_counter;
+#define LONG_LONG_COUNTERS 1
+#define COUNTER_FMT "%llu"
+#define COUNTER_FMT_RAW "llu"
+#else
+typedef unsigned long nauty_counter;
+#define LONG_LONG_COUNTERS 0
+#define COUNTER_FMT "%lu"
+#define COUNTER_FMT_RAW "lu"
+#endif
+#define PRINT_COUNTER(f,x) fprintf(f,COUNTER_FMT,x)
+
+#define NAUTYVERSIONID (26040+HAVE_TLS)  /* 10000*version + HAVE_TLS */
+#define NAUTYREQUIRED NAUTYVERSIONID  /* Minimum compatible version */
+
+#if WORDSIZE==16
+#define NAUTYVERSION "2.6 (16 bits)"
+#endif
+#if WORDSIZE==32
+#define NAUTYVERSION "2.6 (32 bits)"
+#endif
+#if WORDSIZE==64
+#define NAUTYVERSION "2.6 (64 bits)"
+#endif
+
+#ifndef  MAXN  /* maximum allowed n value; use 0 for dynamic sizing. */
+#define MAXN 0
+#define MAXM 0
+#else
+#define MAXM ((MAXN+WORDSIZE-1)/WORDSIZE)  /* max setwords in a set */
+#endif  /* MAXN */
+
+/* Starting at version 2.2, set operations work for all set sizes unless
+   ONE_WORD_SETS is defined.  In the latter case, if MAXM=1, set ops
+   work only for single-setword sets.  In any case, macro versions
+   ending with 1 work for single-setword sets and versions ending with
+   0 work for all set sizes.
+*/
+
+#if  WORDSIZE==16
+#define SETWD(pos) ((pos)>>4)  /* number of setword containing bit pos */
+#define SETBT(pos) ((pos)&0xF) /* position within setword of bit pos */
+#define TIMESWORDSIZE(w) ((w)<<4)
+#define SETWORDSNEEDED(n) ((((n)-1)>>4)+1)  /* setwords needed for n bits */
+#endif
+
+#if  WORDSIZE==32
+#define SETWD(pos) ((pos)>>5)
+#define SETBT(pos) ((pos)&0x1F)
+#define TIMESWORDSIZE(w) ((w)<<5)
+#define SETWORDSNEEDED(n) ((((n)-1)>>5)+1)
+#endif
+
+#if  WORDSIZE==64
+#define SETWD(pos) ((pos)>>6)
+#define SETBT(pos) ((pos)&0x3F)
+#define TIMESWORDSIZE(w) ((w)<<6)    /* w*WORDSIZE */
+#define SETWORDSNEEDED(n) ((((n)-1)>>6)+1)
+#endif
+
+#ifdef NAUTY_IN_MAGMA
+#define BITT bs_bit
+#else
+#define BITT bit
+#endif
+
+#define ADDELEMENT1(setadd,pos)  (*(setadd) |= BITT[pos])
+#define DELELEMENT1(setadd,pos)  (*(setadd) &= ~BITT[pos])
+#define FLIPELEMENT1(setadd,pos) (*(setadd) ^= BITT[pos])
+#define ISELEMENT1(setadd,pos)   ((*(setadd) & BITT[pos]) != 0)
+#define EMPTYSET1(setadd,m)   *(setadd) = 0;
+#define GRAPHROW1(g,v,m) ((set*)(g)+(v))
+#define ADDONEARC1(g,v,w,m) (g)[v] |= BITT[w]
+#define ADDONEEDGE1(g,v,w,m) { ADDONEARC1(g,v,w,m); ADDONEARC1(g,w,v,m); }
+#define EMPTYGRAPH1(g,m,n) EMPTYSET0(g,n)  /* really EMPTYSET0 */
+
+#define ADDELEMENT0(setadd,pos)  ((setadd)[SETWD(pos)] |= BITT[SETBT(pos)])
+#define DELELEMENT0(setadd,pos)  ((setadd)[SETWD(pos)] &= ~BITT[SETBT(pos)])
+#define FLIPELEMENT0(setadd,pos) ((setadd)[SETWD(pos)] ^= BITT[SETBT(pos)])
+#define ISELEMENT0(setadd,pos) (((setadd)[SETWD(pos)] & BITT[SETBT(pos)]) != 0)
+#define EMPTYSET0(setadd,m) \
+    {setword *es; \
+    for (es = (setword*)(setadd)+(m); --es >= (setword*)(setadd);) *es=0;}
+#define GRAPHROW0(g,v,m) ((set*)(g) + (m)*(size_t)(v))
+#define ADDONEARC0(g,v,w,m) ADDELEMENT0(GRAPHROW0(g,v,m),w)
+#define ADDONEEDGE0(g,v,w,m) { ADDONEARC0(g,v,w,m); ADDONEARC0(g,w,v,m); }
+#define EMPTYGRAPH0(g,m,n) EMPTYSET0(g,(m)*(size_t)(n))
+
+#if  (MAXM==1) && defined(ONE_WORD_SETS)
+#define ADDELEMENT ADDELEMENT1
+#define DELELEMENT DELELEMENT1
+#define FLIPELEMENT FLIPELEMENT1
+#define ISELEMENT ISELEMENT1
+#define EMPTYSET EMPTYSET1
+#define GRAPHROW GRAPHROW1
+#define ADDONEARC ADDONEARC1
+#define ADDONEEDGE ADDONEEDGE1
+#define EMPTYGRAPH EMPTYGRAPH1
+#else
+#define ADDELEMENT ADDELEMENT0
+#define DELELEMENT DELELEMENT0
+#define FLIPELEMENT FLIPELEMENT0
+#define ISELEMENT ISELEMENT0
+#define EMPTYSET EMPTYSET0
+#define GRAPHROW GRAPHROW0
+#define ADDONEARC ADDONEARC0
+#define ADDONEEDGE ADDONEEDGE0
+#define EMPTYGRAPH EMPTYGRAPH0
+#endif
+
+
+#ifdef NAUTY_IN_MAGMA
+#undef EMPTYSET
+#define EMPTYSET(setadd,m) {t_int _i; bsp_makeempty(setadd,m,_i);}
+#endif
+
+#define NOTSUBSET(word1,word2) ((word1) & ~(word2))  /* test if the 1-bits
+                    in setword word1 do not form a subset of those in word2  */
+#define INTERSECT(word1,word2) ((word1) &= (word2))  /* AND word2 into word1 */
+#define UNION(word1,word2)     ((word1) |= (word2))  /* OR word2 into word1 */
+#define SETDIFF(word1,word2)   ((word1) &= ~(word2)) /* - word2 into word1 */
+#define XOR(word1,word2)       ((word1) ^= (word2))  /* XOR word2 into word1 */
+#define ZAPBIT(word,x) ((word) &= ~BITT[x])  /* delete bit x in setword */
+#define TAKEBIT(iw,w) {(iw) = FIRSTBITNZ(w); (w) ^= BITT[iw];}
+
+#ifdef SETWORD_LONGLONG
+#define MSK3232 0xFFFFFFFF00000000ULL
+#define MSK1648 0xFFFF000000000000ULL
+#define MSK0856 0xFF00000000000000ULL
+#define MSK1632 0x0000FFFF00000000ULL
+#define MSK0840     0xFF0000000000ULL
+#define MSK1616         0xFFFF0000ULL 
+#define MSK0824         0xFF000000ULL 
+#define MSK0808             0xFF00ULL 
+#define MSK63C  0x7FFFFFFFFFFFFFFFULL
+#define MSK31C          0x7FFFFFFFULL
+#define MSK15C              0x7FFFULL
+#define MSK64   0xFFFFFFFFFFFFFFFFULL
+#define MSK32           0xFFFFFFFFULL
+#define MSK16               0xFFFFULL
+#define MSK8                  0xFFULL
+#endif
+
+#ifdef SETWORD_LONG
+#define MSK3232 0xFFFFFFFF00000000UL
+#define MSK1648 0xFFFF000000000000UL
+#define MSK0856 0xFF00000000000000UL
+#define MSK1632 0x0000FFFF00000000UL
+#define MSK0840     0xFF0000000000UL
+#define MSK1616         0xFFFF0000UL 
+#define MSK0824         0xFF000000UL 
+#define MSK0808             0xFF00UL 
+#define MSK63C  0x7FFFFFFFFFFFFFFFUL
+#define MSK31C          0x7FFFFFFFUL
+#define MSK15C              0x7FFFUL
+#define MSK64   0xFFFFFFFFFFFFFFFFUL
+#define MSK32           0xFFFFFFFFUL
+#define MSK16               0xFFFFUL
+#define MSK8                  0xFFUL
+#endif
+
+#if defined(SETWORD_INT) || defined(SETWORD_SHORT)
+#define MSK3232 0xFFFFFFFF00000000U
+#define MSK1648 0xFFFF000000000000U
+#define MSK0856 0xFF00000000000000U
+#define MSK1632 0x0000FFFF00000000U
+#define MSK0840     0xFF0000000000U
+#define MSK1616         0xFFFF0000U 
+#define MSK0824         0xFF000000U
+#define MSK0808             0xFF00U 
+#define MSK63C  0x7FFFFFFFFFFFFFFFU
+#define MSK31C          0x7FFFFFFFU
+#define MSK15C              0x7FFFU
+#define MSK64   0xFFFFFFFFFFFFFFFFU
+#define MSK32           0xFFFFFFFFU
+#define MSK16               0xFFFFU
+#define MSK8                  0xFFU
+#endif
+
+#if defined(SETWORD_LONGLONG)
+#if WORDSIZE==16
+#define SETWORD_FORMAT "%04llx"
+#endif
+#if WORDSIZE==32
+#define SETWORD_FORMAT "%08llx"
+#endif
+#if WORDSIZE==64
+#define SETWORD_FORMAT "%16llx"
+#endif
+#endif
+
+#if defined(SETWORD_LONG)
+#if WORDSIZE==16
+#define SETWORD_FORMAT "%04lx"
+#endif
+#if WORDSIZE==32
+#define SETWORD_FORMAT "%08lx"
+#endif
+#if WORDSIZE==64
+#define SETWORD_FORMAT "%16lx"
+#endif
+#endif
+
+#if defined(SETWORD_INT)
+#if WORDSIZE==16
+#define SETWORD_FORMAT "%04x"
+#endif
+#if WORDSIZE==32
+#define SETWORD_FORMAT "%08x"
+#endif
+#if WORDSIZE==64
+#define SETWORD_FORMAT "%16x"
+#endif
+#endif
+
+#if defined(SETWORD_SHORT)
+#if WORDSIZE==16
+#define SETWORD_FORMAT "%04hx"
+#endif
+#if WORDSIZE==32
+#define SETWORD_FORMAT "%08hx"
+#endif
+#if WORDSIZE==64
+#define SETWORD_FORMAT "%16hx"
+#endif
+#endif
+
+/* POPCOUNT(x) = number of 1-bits in a setword x
+   POPCOUNTMAC(x) = Macro version of POPCOUNT
+   FIRSTBIT(x) = number of first 1-bit in non-zero setword (0..WORDSIZE-1)
+                   or WORDSIZE if x == 0
+   FIRSTBITNZ(x) = as FIRSTBIT(x) but assumes x is not zero
+   BITMASK(x)  = setword whose rightmost WORDSIZE-x-1 (numbered) bits
+                 are 1 and the rest 0 (0 <= x < WORDSIZE)
+                 (I.e., bits 0..x are unselected and the rest selected.)
+   ALLBITS     = all (numbered) bits in a setword  */
+
+#if  WORDSIZE==64
+#define POPCOUNTMAC(x) (bytecount[(x)>>56 & 0xFF] + bytecount[(x)>>48 & 0xFF] \
+                   + bytecount[(x)>>40 & 0xFF] + bytecount[(x)>>32 & 0xFF] \
+                   + bytecount[(x)>>24 & 0xFF] + bytecount[(x)>>16 & 0xFF] \
+                   + bytecount[(x)>>8 & 0xFF]  + bytecount[(x) & 0xFF])
+#define FIRSTBIT(x) ((x) & MSK3232 ? \
+                       (x) &   MSK1648 ? \
+                         (x) & MSK0856 ? \
+                         0+leftbit[((x)>>56) & MSK8] : \
+                         8+leftbit[(x)>>48] \
+                       : (x) & MSK0840 ? \
+                         16+leftbit[(x)>>40] : \
+                         24+leftbit[(x)>>32] \
+                     : (x) & MSK1616 ? \
+                         (x) & MSK0824 ? \
+                         32+leftbit[(x)>>24] : \
+                         40+leftbit[(x)>>16] \
+                       : (x) & MSK0808 ? \
+                         48+leftbit[(x)>>8] : \
+                         56+leftbit[x])
+#define BITMASK(x)  (MSK63C >> (x))
+#define ALLBITS  MSK64
+#define SWCHUNK0(w) ((long)((w)>>48)&0xFFFFL)
+#define SWCHUNK1(w) ((long)((w)>>32)&0xFFFFL)
+#define SWCHUNK2(w) ((long)((w)>>16)&0xFFFFL)
+#define SWCHUNK3(w) ((long)(w)&0xFFFFL)
+#endif
+
+#if  WORDSIZE==32
+#define POPCOUNTMAC(x) (bytecount[(x)>>24 & 0xFF] + bytecount[(x)>>16 & 0xFF] \
+                        + bytecount[(x)>>8 & 0xFF] + bytecount[(x) & 0xFF])
+#define FIRSTBIT(x) ((x) & MSK1616 ? ((x) & MSK0824 ? \
+                     leftbit[((x)>>24) & MSK8] : 8+leftbit[(x)>>16]) \
+                    : ((x) & MSK0808 ? 16+leftbit[(x)>>8] : 24+leftbit[x]))
+#define BITMASK(x)  (MSK31C >> (x))
+#define ALLBITS  MSK32
+#define SWCHUNK0(w) ((long)((w)>>16)&0xFFFFL)
+#define SWCHUNK1(w) ((long)(w)&0xFFFFL)
+#endif
+
+#if  WORDSIZE==16
+#define POPCOUNTMAC(x) (bytecount[(x)>>8 & 0xFF] + bytecount[(x) & 0xFF])
+#define FIRSTBIT(x) ((x) & MSK0808 ? leftbit[((x)>>8) & MSK8] : 8+leftbit[x])
+#define BITMASK(x)  (MSK15C >> (x))
+#define ALLBITS  MSK16
+#define SWCHUNK0(w) ((long)(w)&0xFFFFL)
+#endif
+
+#if defined(SETWORD_LONGLONG) && HAVE_CLZLL
+#undef FIRSTBIT
+#undef FIRSTBITNZ
+#define FIRSTBITNZ(x) __builtin_clzll(x)
+#define FIRSTBIT(x) ((x) ? FIRSTBITNZ(x) : WORDSIZE)
+#endif
+#if defined(SETWORD_LONG) && HAVE_CLZL
+#undef FIRSTBIT
+#undef FIRSTBITNZ
+#define FIRSTBITNZ(x) __builtin_clzl(x)
+#define FIRSTBIT(x) ((x) ? FIRSTBITNZ(x) : WORDSIZE)
+#endif
+#if defined(SETWORD_INT) && HAVE_CLZ
+#undef FIRSTBIT
+#undef FIRSTBITNZ
+#define FIRSTBITNZ(x) __builtin_clz(x)
+#define FIRSTBIT(x) ((x) ? FIRSTBITNZ(x) : WORDSIZE)
+#endif
+
+#ifndef FIRSTBITNZ
+#define FIRSTBITNZ FIRSTBIT
+#endif
+
+/* Use popcount instructions if available */
+#define POPCOUNT POPCOUNTMAC
+
+#ifdef __INTEL_COMPILER
+#include <nmmintrin.h>
+#if WORDSIZE==64 && HAVE_MMPOP64
+#undef POPCOUNT
+#define POPCOUNT(x) _mm_popcnt_u64(x)
+#endif
+#if WORDSIZE==32 && HAVE_MMPOP32
+#undef POPCOUNT
+#define POPCOUNT(x) _mm_popcnt_u32(x)
+#endif
+
+#else
+
+/* Note that, unlike icc, gcc will not use the POPCNT instruction without
+   permission, in which case it defines __POPCNT__ .
+*/
+#ifdef __POPCNT__
+#if defined(SETWORD_LONGLONG) && HAVE_POPCNTLL
+#undef POPCOUNT
+#define POPCOUNT(x) __builtin_popcountll(x)
+#endif
+#if defined(SETWORD_LONG) && HAVE_POPCNTL
+#undef POPCOUNT
+#define POPCOUNT(x) __builtin_popcountl(x)
+#endif
+#if defined(SETWORD_INT) && HAVE_POPCNT
+#undef POPCOUNT
+#define POPCOUNT(x) __builtin_popcount(x)
+#endif
+#endif
+#endif
+
+#ifdef NAUTY_IN_MAGMA
+#undef POPCOUNT
+#undef FIRSTBIT
+#undef BITMASK
+#define POPCOUNT(x) bs_popcount(x)
+#define FIRSTBIT(x) bs_firstbit(x)
+#define BITMASK(x)  bs_bitmask(x)
+#endif
+
+#define ALLMASK(n) ((n)?~BITMASK((n)-1):(setword)0)  /* First n bits */
+
+    /* various constants: */
+#undef FALSE
+#undef TRUE
+#define FALSE    0
+#define TRUE     1
+
+#if SIZEOF_INT>=4
+#define NAUTY_INFINITY 2000000002  /* Max graph size is 2 billion */
+#else
+#define NAUTY_INFINITY 0x7FFF
+#endif
+
+/* The following four types are obsolete, use int in new code. */
+typedef int shortish;
+typedef shortish permutation;
+typedef int nvector,np2vector; 
+
+/* For backward compatibility: */
+#if !HAS_MATH_INF && !defined(INFINITY)
+#define INFINITY NAUTY_INFINITY
+#endif
+
+#if MAXN > NAUTY_INFINITY-2
+ #error MAXN must be at most NAUTY_INFINITY-2
+#endif
+
+    /* typedefs for sets, graphs, permutations, etc.: */
+
+typedef int boolean;    /* boolean MUST be the same as int */
+
+#define UPROC void      /* obsolete */
+
+typedef setword set,graph;
+#ifdef NAUTY_IN_MAGMA
+typedef graph nauty_graph;
+typedef set nauty_set;
+#endif
+
+typedef struct
+{
+    double grpsize1;        /* size of group is */
+    int grpsize2;           /*    grpsize1 * 10^grpsize2 */
+#define groupsize1 grpsize1     /* for backwards compatibility */
+#define groupsize2 grpsize2
+    int numorbits;          /* number of orbits in group */
+    int numgenerators;      /* number of generators found */
+    int errstatus;          /* if non-zero : an error code */
+#define outofspace errstatus;   /* for backwards compatibility */
+    unsigned long numnodes;      /* total number of nodes */
+    unsigned long numbadleaves;  /* number of leaves of no use */
+    int maxlevel;                /* maximum depth of search */
+    unsigned long tctotal;       /* total size of all target cells */
+    unsigned long canupdates;    /* number of updates of best label */
+    unsigned long invapplics;    /* number of applications of invarproc */
+    unsigned long invsuccesses;  /* number of successful uses of invarproc() */
+    int invarsuclevel;      /* least level where invarproc worked */
+} statsblk;
+
+/* codes for errstatus field (see nauty.c for more accurate descriptions): */
+/* 0 is normal - no error */
+#define NTOOBIG      1      /* n > MAXN or n > WORDSIZE*m */
+#define MTOOBIG      2      /* m > MAXM */
+#define CANONGNIL    3      /* canong = NULL, but getcanon = TRUE */
+#define NAUABORTED   4      /* nauty is terminated early under program control */
+#define NAUKILLED    5      /* nauty is terminated early by caught signal */
+
+/* manipulation of real approximation to group size */
+#define MULTIPLY(s1,s2,i) if ((s1 *= i) >= 1e10) {s1 /= 1e10; s2 += 10;}
+
+struct optionstruct;  /* incomplete definition */
+
+typedef struct
+{
+    boolean (*isautom)        /* test for automorphism */
+            (graph*,int*,boolean,int,int);
+    int     (*testcanlab)     /* test for better labelling */
+            (graph*,graph*,int*,int*,int,int);
+    void    (*updatecan)      /* update canonical object */
+            (graph*,graph*,int*,int,int,int);
+    void    (*refine)         /* refine partition */
+            (graph*,int*,int*,int,int*,int*,set*,int*,int,int);
+    void    (*refine1)        /* refine partition, MAXM==1 */
+            (graph*,int*,int*,int,int*,int*,set*,int*,int,int);
+    boolean (*cheapautom)     /* test for easy automorphism */
+            (int*,int,boolean,int);
+    int     (*targetcell)     /* decide which cell to split */
+            (graph*,int*,int*,int,int,boolean,int,int,int);
+    void    (*freedyn)(void); /* free dynamic memory */
+    void    (*check)          /* check compilation parameters */
+            (int,int,int,int);
+    void    (*init)(graph*,graph**,graph*,graph**,int*,int*,set*,
+                   struct optionstruct*,int*,int,int);
+    void    (*cleanup)(graph*,graph**,graph*,graph**,int*,int*,
+                      struct optionstruct*,statsblk*,int,int);
+} dispatchvec;
+
+typedef struct optionstruct
+{
+    int getcanon;             /* make canong and canonlab? */
+#define LABELONLY 2   /* new value UNIMPLEMENTED */
+    boolean digraph;          /* multiple edges or loops? */
+    boolean writeautoms;      /* write automorphisms? */
+    boolean writemarkers;     /* write stats on pts fixed, etc.? */
+    boolean defaultptn;       /* set lab,ptn,active for single cell? */
+    boolean cartesian;        /* use cartesian rep for writing automs? */
+    int linelength;           /* max chars/line (excl. '\n') for output */
+    FILE *outfile;            /* file for output, if any */
+    void (*userrefproc)       /* replacement for usual refine procedure */
+         (graph*,int*,int*,int,int*,int*,set*,int*,int,int);
+    void (*userautomproc)     /* procedure called for each automorphism */
+         (int,int*,int*,int,int,int);
+    void (*userlevelproc)     /* procedure called for each level */
+         (int*,int*,int,int*,statsblk*,int,int,int,int,int,int);
+    void (*usernodeproc)      /* procedure called for each node */
+         (graph*,int*,int*,int,int,int,int,int,int);
+    int  (*usercanonproc)     /* procedure called for better labellings */
+         (graph*,int*,graph*,int,int,int,int);
+    void (*invarproc)         /* procedure to compute vertex-invariant */
+         (graph*,int*,int*,int,int,int,int*,int,boolean,int,int);
+    int tc_level;             /* max level for smart target cell choosing */
+    int mininvarlevel;        /* min level for invariant computation */
+    int maxinvarlevel;        /* max level for invariant computation */
+    int invararg;             /* value passed to (*invarproc)() */
+    dispatchvec *dispatch;    /* vector of object-specific routines */
+    boolean schreier;         /* use random schreier method */
+    void *extra_options;      /* arbitrary extra options */
+#ifdef NAUTY_IN_MAGMA
+    boolean print_stats;      /* CAYLEY specfic - GYM Sep 1990 */
+    char *invarprocname;      /* Magma - no longer global sjc 1994 */
+    int lab_h;                /* Magma - no longer global sjc 1994 */
+    int ptn_h;                /* Magma - no longer global sjc 1994 */
+    int orbitset_h;           /* Magma - no longer global sjc 1994 */
+#endif
+} optionblk;
+
+#ifndef CONSOLWIDTH
+#define CONSOLWIDTH 78
+#endif
+
+/* The following are obsolete.  Just use NULL. */
+#define NILFUNCTION ((void(*)())NULL)      /* nil pointer to user-function */
+#define NILSET      ((set*)NULL)           /* nil pointer to set */
+#define NILGRAPH    ((graph*)NULL)         /* nil pointer to graph */
+
+#define DEFAULTOPTIONS_GRAPH(options) optionblk options = \
+ {0,FALSE,FALSE,FALSE,TRUE,FALSE,CONSOLWIDTH, \
+  NULL,NULL,NULL,NULL,NULL,NULL,NULL,100,0,1,0,&dispatch_graph,FALSE,NULL}
+#define DEFAULTOPTIONS_DIGRAPH(options) optionblk options = \
+ {0,TRUE,FALSE,FALSE,TRUE,FALSE,CONSOLWIDTH, \
+  NULL,NULL,NULL,NULL,NULL,NULL,adjacencies,100,0,999,0,&dispatch_graph,FALSE,NULL}
+
+#ifndef DEFAULTOPTIONS
+#define DEFAULTOPTIONS DEFAULTOPTIONS_GRAPH
+#endif
+#ifndef DEFAULTOPTIONS_DENSEGRAPH
+#define DEFAULTOPTIONS_DENSEGRAPH DEFAULTOPTIONS_GRAPH
+#endif
+
+#ifdef NAUTY_IN_MAGMA
+#define PUTC(c,f) io_putchar(c)
+#else
+#ifdef IS_JAVA
+extern void javastream(FILE* f,char c);
+#define PUTC(c,f) javastream(f,c)
+#else
+#define PUTC(c,f) putc(c,f)
+#endif
+#endif
+
+/* We hope that malloc, free, realloc are declared either in <stdlib.h>
+   or <malloc.h>.  Otherwise we will define them.  We also assume that
+   size_t has been defined by the time we get to define malloc(). */
+#ifndef NAUTY_IN_MAGMA
+#if MALLOC_DEC==2
+#include <malloc.h>
+#endif
+#if MALLOC_DEC==0
+extern void *malloc(size_t);
+extern void *realloc(void*,size_t);
+extern void free(void*);
+#endif
+#endif
+
+/* ALLOCS(x,y) should return a pointer (any pointer type) to x*y units of new
+   storage, not necessarily initialised.  A "unit" of storage is defined by
+   the sizeof operator.   x and y are integer values of type int or larger, 
+   but x*y may well be too large for an int.  The macro should cast to the
+   correct type for the call.  On failure, ALLOCS(x,y) should return a NULL 
+   pointer.  FREES(p) should free storage previously allocated by ALLOCS, 
+   where p is the value that ALLOCS returned. */
+
+#ifdef NAUTY_IN_MAGMA
+#define ALLOCS(x,y) mem_malloc((size_t)(x)*(size_t)(y))
+#define REALLOCS(p,x) mem_realloc(p,(size_t)(x))
+#define FREES(p) mem_free(p)
+#else
+#define ALLOCS(x,y) malloc((size_t)(x)*(size_t)(y))
+#define REALLOCS(p,x) realloc(p,(size_t)(x)) 
+#define FREES(p) free(p)
+#endif
+
+/* The following macros are used by nauty if MAXN=0.  They dynamically
+   allocate arrays of size dependent on m or n.  For each array there
+   should be two static variables:
+     type *name;
+     size_t name_sz;
+   "name" will hold a pointer to an allocated array.  "name_sz" will hold
+   the size of the allocated array in units of sizeof(type).  DYNALLSTAT
+   declares both variables and initialises name_sz=0.  DYNALLOC1 and
+   DYNALLOC2 test if there is enough space allocated, and if not free
+   the existing space and allocate a bigger space.  The allocated space
+   is not initialised.
+   
+   In the case of DYNALLOC1, the space is allocated using
+       ALLOCS(sz,sizeof(type)).
+   In the case of DYNALLOC2, the space is allocated using
+       ALLOCS(sz1,sz2*sizeof(type)).
+
+   DYNREALLOC is like DYNALLOC1 except that the old contents are copied
+   into the new space. Availability of realloc() is assumed.
+
+   DYNFREE frees any allocated array and sets name_sz back to 0.
+   CONDYNFREE does the same, but only if name_sz exceeds some limit.
+*/
+
+#define DYNALLSTAT(type,name,name_sz) \
+	static TLS_ATTR type *name; static TLS_ATTR size_t name_sz=0
+#define DYNALLOC1(type,name,name_sz,sz,msg) \
+ if ((size_t)(sz) > name_sz) \
+ { if (name_sz) FREES(name); name_sz = (sz); \
+ if ((name=(type*)ALLOCS(sz,sizeof(type))) == NULL) {alloc_error(msg);}}
+#define DYNALLOC2(type,name,name_sz,sz1,sz2,msg) \
+ if ((size_t)(sz1)*(size_t)(sz2) > name_sz) \
+ { if (name_sz) FREES(name); name_sz = (size_t)(sz1)*(size_t)(sz2); \
+ if ((name=(type*)ALLOCS((sz1),(sz2)*sizeof(type))) == NULL) \
+ {alloc_error(msg);}}
+#define DYNREALLOC(type,name,name_sz,sz,msg) \
+ {if ((size_t)(sz) > name_sz) \
+ { if ((name = (type*)REALLOCS(name,(sz)*sizeof(type))) == NULL) \
+      {alloc_error(msg);} else name_sz = (sz);}}
+#define DYNFREE(name,name_sz) \
+  { if (name) FREES(name); name = NULL; name_sz = 0;}
+#define CONDYNFREE(name,name_sz,minsz) \
+ if (name_sz > (size_t)(minsz)) {DYNFREE(name,name_sz);}
+
+/* File to write error messages to (used as first argument to fprintf()). */
+#define ERRFILE stderr
+
+/* Don't use OLDEXTDEFS, it is only still here for Magma. */
+#ifdef OLDEXTDEFS   
+#define EXTDEF_CLASS
+#ifdef EXTDEFS
+#define EXTDEF_TYPE 1
+#else
+#define EXTDEF_TYPE 2
+#endif
+#else
+#define EXTDEF_CLASS static
+#define EXTDEF_TYPE 2
+#endif
+
+extern int labelorg;   /* Declared in nautil.c */
+extern volatile int nauty_kill_request;  /* Also declared in nautil.c */
+
+#ifndef NAUTY_IN_MAGMA
+  /* Things equivalent to bit, bytecount, leftbit are defined
+     in bs.h for Magma. */
+#if  EXTDEF_TYPE==1
+extern setword bit[];
+extern int bytecount[];
+extern int leftbit[];
+
+#else
+    /* array giving setwords with single 1-bit */
+#if  WORDSIZE==64
+#ifdef SETWORD_LONGLONG
+EXTDEF_CLASS const
+setword bit[] = {01000000000000000000000LL,0400000000000000000000LL,
+                 0200000000000000000000LL,0100000000000000000000LL,
+                 040000000000000000000LL,020000000000000000000LL,
+                 010000000000000000000LL,04000000000000000000LL,
+                 02000000000000000000LL,01000000000000000000LL,
+                 0400000000000000000LL,0200000000000000000LL,
+                 0100000000000000000LL,040000000000000000LL,
+                 020000000000000000LL,010000000000000000LL,
+                 04000000000000000LL,02000000000000000LL,
+                 01000000000000000LL,0400000000000000LL,0200000000000000LL,
+                 0100000000000000LL,040000000000000LL,020000000000000LL,
+                 010000000000000LL,04000000000000LL,02000000000000LL,
+                 01000000000000LL,0400000000000LL,0200000000000LL,
+		 0100000000000LL,040000000000LL,020000000000LL,010000000000LL,
+		 04000000000LL,02000000000LL,01000000000LL,0400000000LL,
+		 0200000000LL,0100000000LL,040000000LL,020000000LL,
+		 010000000LL,04000000LL,02000000LL,01000000LL,0400000LL,
+		 0200000LL,0100000LL,040000LL,020000LL,010000LL,04000LL,
+                 02000LL,01000LL,0400LL,0200LL,0100LL,040LL,020LL,010LL,
+		 04LL,02LL,01LL};
+#else
+EXTDEF_CLASS const
+setword bit[] = {01000000000000000000000,0400000000000000000000,
+                 0200000000000000000000,0100000000000000000000,
+                 040000000000000000000,020000000000000000000,
+                 010000000000000000000,04000000000000000000,
+                 02000000000000000000,01000000000000000000,
+                 0400000000000000000,0200000000000000000,
+                 0100000000000000000,040000000000000000,020000000000000000,
+                 010000000000000000,04000000000000000,02000000000000000,
+                 01000000000000000,0400000000000000,0200000000000000,
+                 0100000000000000,040000000000000,020000000000000,
+                 010000000000000,04000000000000,02000000000000,
+                 01000000000000,0400000000000,0200000000000,0100000000000,
+                 040000000000,020000000000,010000000000,04000000000,
+                 02000000000,01000000000,0400000000,0200000000,0100000000,
+                 040000000,020000000,010000000,04000000,02000000,01000000,
+                 0400000,0200000,0100000,040000,020000,010000,04000,
+                 02000,01000,0400,0200,0100,040,020,010,04,02,01};
+#endif
+#endif
+
+#if  WORDSIZE==32
+EXTDEF_CLASS const
+setword bit[] = {020000000000,010000000000,04000000000,02000000000,
+                 01000000000,0400000000,0200000000,0100000000,040000000,
+                 020000000,010000000,04000000,02000000,01000000,0400000,
+                 0200000,0100000,040000,020000,010000,04000,02000,01000,
+                 0400,0200,0100,040,020,010,04,02,01};
+#endif
+
+#if WORDSIZE==16
+EXTDEF_CLASS const
+setword bit[] = {0100000,040000,020000,010000,04000,02000,01000,0400,0200,
+                 0100,040,020,010,04,02,01};
+#endif
+
+    /*  array giving number of 1-bits in bytes valued 0..255: */
+EXTDEF_CLASS const
+int bytecount[] = {0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,
+                   1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+                   1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+                   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+                   1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+                   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+                   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+                   3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+                   1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+                   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+                   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+                   3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+                   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+                   3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+                   3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+                   4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8};
+
+    /* array giving position (1..7) of high-order 1-bit in byte: */
+EXTDEF_CLASS const
+int leftbit[] =   {8,7,6,6,5,5,5,5,4,4,4,4,4,4,4,4,
+                   3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
+                   2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+                   2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+                   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+                   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+                   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+                   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+                   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+#endif  /* EXTDEFS */
+
+#endif /* not NAUTY_IN_MAGMA */
+
+#define ANSIPROT 1
+#define EXTPROC(func,args) extern func args;     /* obsolete */
+
+/* The following is for C++ programs that read nauty.h.  Compile nauty
+   itself using C, not C++.  */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void alloc_error(const char*);
+extern void breakout(int*,int*,int,int,int,set*,int);
+extern boolean cheapautom(int*,int,boolean,int);
+extern void doref(graph*,int*,int*,int,int*,int*,int*,set*,int*,
+  void(*)(graph*,int*,int*,int,int*,int*,set*,int*,int,int),
+  void(*)(graph*,int*,int*,int,int,int,int*,int,boolean,int,int),
+  int,int,int,boolean,int,int);
+extern void extra_autom(int*,int);
+extern void extra_level(int,int*,int*,int,int,int,int,int,int);
+extern boolean isautom(graph*,int*,boolean,int,int);
+extern dispatchvec dispatch_graph;
+extern int itos(int,char*);
+extern void fmperm(int*,set*,set*,int,int);
+extern void fmptn(int*,int*,int,set*,set*,int,int);
+extern void longprune(set*,set*,set*,set*,int);
+extern void nauty(graph*,int*,int*,set*,int*,optionblk*,
+                  statsblk*,set*,int,int,int,graph*);
+extern void maketargetcell(graph*,int*,int*,int,set*,int*,int*,int,boolean,
+           int,int (*)(graph*,int*,int*,int,int,boolean,int,int,int),int,int);
+extern int nextelement(set*,int,int);
+extern int orbjoin(int*,int*,int);
+extern void permset(set*,set*,int,int*);
+extern void putstring(FILE*,char*);
+extern void refine(graph*,int*,int*,int,int*,int*,set*,int*,int,int);
+extern void refine1(graph*,int*,int*,int,int*,int*,set*,int*,int,int);
+extern void shortprune(set*,set*,int);
+extern int targetcell(graph*,int*,int*,int,int,boolean,int,int,int);
+extern int testcanlab(graph*,graph*,int*,int*,int,int);
+extern void updatecan(graph*,graph*,int*,int,int,int);
+extern void writeperm(FILE*,int*,boolean,int,int);
+extern void nauty_freedyn(void);
+extern void nauty_check(int,int,int,int);
+extern void naugraph_check(int,int,int,int);
+extern void nautil_check(int,int,int,int);
+extern void nautil_freedyn(void);
+extern void naugraph_freedyn(void);
+extern void densenauty(graph*,int*,int*,int*,
+			optionblk*,statsblk*,int,int,graph*);
+extern void writegroupsize(FILE*,double,int);
+
+#ifdef __cplusplus
+}
+#endif
+
+/* ++++++ This file is automatically generated, don't edit it by hand! ++++++ */
+
+
+#endif  /* _NAUTY_H_ */
diff --git a/lib/nauty/nautyex1.c b/lib/nauty/nautyex1.c
new file mode 100644
index 0000000..89b9f6c
--- /dev/null
+++ b/lib/nauty/nautyex1.c
@@ -0,0 +1,73 @@
+/* This program prints generators for the automorphism group of an
+   n-vertex polygon, where n is a number supplied by the user.
+
+   This version uses a fixed limit for MAXN.
+*/
+
+#define MAXN 1000    /* Define this before including nauty.h */
+#include "nauty.h"   /* which includes <stdio.h> and other system files */
+
+int
+main(int argc, char *argv[])
+{
+    graph g[MAXN*MAXM];
+    int lab[MAXN],ptn[MAXN],orbits[MAXN];
+    static DEFAULTOPTIONS_GRAPH(options);
+    statsblk stats;
+
+    int n,m,v;
+
+ /* Default options are set by the DEFAULTOPTIONS_GRAPH macro above.
+    Here we change those options that we want to be different from the
+    defaults.  writeautoms=TRUE causes automorphisms to be written.     */
+
+    options.writeautoms = TRUE;
+
+    while (1)
+    {
+        printf("\nenter n : ");
+        if (scanf("%d",&n) != 1 || n <= 0)    /* Exit if EOF or bad number */
+            break;
+
+        if (n > MAXN)
+        {
+            printf("n must be in the range 1..%d\n",MAXN);
+            exit(1);
+        }
+
+     /* The nauty parameter m is a value such that an array of
+        m setwords is sufficient to hold n bits.  The type setword
+        is defined in nauty.h.  The number of bits in a setword is
+        WORDSIZE, which is 16, 32 or 64.  Here we calculate
+        m = ceiling(n/WORDSIZE).                                  */
+
+        m = SETWORDSNEEDED(n);
+
+     /* The following optional call verifies that we are linking
+        to compatible versions of the nauty routines.            */
+
+        nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
+
+     /* Now we create the cycle.  First we zero the graph, than for
+        each v, we add the edge (v,v+1), where values are mod n. */
+
+        EMPTYGRAPH(g,m,n);
+        for (v = 0; v < n; ++v)  ADDONEEDGE(g,v,(v+1)%n,m);
+
+        printf("Generators for Aut(C[%d]):\n",n);
+
+     /* Since we are not requiring a canonical labelling, the last
+        parameter to densenauty() is not required and can be NULL. */
+
+        densenauty(g,lab,ptn,orbits,&options,&stats,m,n,NULL);
+
+     /* The size of the group is returned in stats.grpsize1 and
+        stats.grpsize2. */
+
+        printf("Automorphism group size = ");
+        writegroupsize(stdout,stats.grpsize1,stats.grpsize2);
+        printf("\n");
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/nautyex10.c b/lib/nauty/nautyex10.c
new file mode 100644
index 0000000..997db7a
--- /dev/null
+++ b/lib/nauty/nautyex10.c
@@ -0,0 +1,151 @@
+/* This program demonstrates how an isomorphism is found between
+   two graphs, using the Moebius graph as an example.
+   This version uses Traces and demonstrates how to compute the
+   automorphism group separately before computing the canonical
+   labelling.  Although this is slower for easy graphs like
+   those here, it can be faster for some very difficult graphs.
+*/
+
+#include "traces.h"
+
+int
+main(int argc, char *argv[])
+{
+    DYNALLSTAT(int,lab1,lab1_sz);
+    DYNALLSTAT(int,lab2,lab2_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+    DYNALLSTAT(int,map,map_sz);
+    static DEFAULTOPTIONS_TRACES(options);
+    TracesStats stats;
+    permnode *generators;
+ /* Declare and initialize sparse graph structures */
+    SG_DECL(sg1); SG_DECL(sg2);
+    SG_DECL(cg1); SG_DECL(cg2);
+
+    int n,m,i;
+
+ /* Read a number of vertices and process */
+
+    while (1)
+    {
+        printf("\nenter n : ");
+        if (scanf("%d",&n) == 1 && n > 0)
+        {
+            if (n%2 != 0)
+            {
+                fprintf(stderr,"Sorry, n must be even\n");
+                continue;
+            }
+
+            m = SETWORDSNEEDED(n);
+            nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
+
+            DYNALLOC1(int,lab1,lab1_sz,n,"malloc");
+            DYNALLOC1(int,lab2,lab2_sz,n,"malloc");
+            DYNALLOC1(int,ptn,ptn_sz,n,"malloc");
+            DYNALLOC1(int,orbits,orbits_sz,n,"malloc");
+            DYNALLOC1(int,map,map_sz,n,"malloc");
+
+         /* Now make the first graph */
+
+            SG_ALLOC(sg1,n,3*n,"malloc");
+            sg1.nv = n;              /* Number of vertices */
+            sg1.nde = 3*n;           /* Number of directed edges */
+
+            for (i = 0; i < n; ++i)
+            {
+                sg1.v[i] = 3*i;     /* Position of vertex i in v array */
+                sg1.d[i] = 3;       /* Degree of vertex i */
+            }
+             
+            for (i = 0; i < n; i += 2)   /* Spokes */
+            {
+                sg1.e[sg1.v[i]] = i+1;
+                sg1.e[sg1.v[i+1]] = i;
+            }
+
+            for (i = 0; i < n-2; ++i)  /* Clockwise edges */
+                sg1.e[sg1.v[i]+1] = i+2;
+            sg1.e[sg1.v[n-2]+1] = 1;
+            sg1.e[sg1.v[n-1]+1] = 0;
+
+            for (i = 2; i < n; ++i)  /* Anticlockwise edges */
+                sg1.e[sg1.v[i]+2] = i-2;
+            sg1.e[sg1.v[1]+2] = n-2;
+            sg1.e[sg1.v[0]+2] = n-1;
+                
+         /* Now make the second graph */
+
+            SG_ALLOC(sg2,n,3*n,"malloc");
+            sg2.nv = n;              /* Number of vertices */
+            sg2.nde = 3*n;           /* Number of directed edges */
+
+            for (i = 0; i < n; ++i)
+            {
+                sg2.v[i] = 3*i;
+                sg2.d[i] = 3;
+            }
+
+            for (i = 0; i < n; ++i)
+            {
+                sg2.v[i] = 3*i;
+                sg2.d[i] = 3;
+                sg2.e[sg2.v[i]] = (i+1) % n;      /* Clockwise */
+                sg2.e[sg2.v[i]+1] = (i+n-1) % n;  /* Anti-clockwise */
+                sg2.e[sg2.v[i]+2] = (i+n/2) % n;  /* Diagonals */
+            }
+
+         /* Now we make the canonically labelled graphs by a two-step
+            process.  The first call to Traces computes the
+            automorphism group.  The second call computes the
+            canonical labelling, using the automorphism group from
+            the first call.
+
+            We have declared a variable "generators" that will be
+            used to hold the group generators between the two calls.
+            It has to be initialised to NULL and its address has to 
+            be given to Traces using options.generators.  After the
+            second call, we need to discard the generators with a
+            call to freeschreier(), which also initializes it again. */
+            
+            generators = NULL;
+            options.generators = &generators;
+
+            options.getcanon = FALSE;
+            Traces(&sg1,lab1,ptn,orbits,&options,&stats,NULL);
+            options.getcanon = TRUE;
+            Traces(&sg1,lab1,ptn,orbits,&options,&stats,&cg1);
+            freeschreier(NULL,&generators);
+
+            options.getcanon = FALSE;
+            Traces(&sg2,lab1,ptn,orbits,&options,&stats,NULL);
+            options.getcanon = TRUE;
+            Traces(&sg2,lab1,ptn,orbits,&options,&stats,&cg2);
+            freeschreier(NULL,&generators);
+
+         /* Compare canonically labelled graphs */
+
+            if (aresame_sg(&cg1,&cg2))
+            {
+                printf("Isomorphic.\n");
+                if (n <= 1000)
+                {
+                 /* Write the isomorphism.  For each i, vertex lab1[i]
+                    of sg1 maps onto vertex lab2[i] of sg2.  We compute
+                    the map in order of labelling because it looks better. */
+
+                    for (i = 0; i < n; ++i) map[lab1[i]] = lab2[i];
+                    for (i = 0; i < n; ++i) printf(" %d-%d",i,map[i]);
+                    printf("\n");
+                }
+            }
+            else
+                printf("Not isomorphic.\n");
+        }
+        else
+            break;
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/nautyex2.c b/lib/nauty/nautyex2.c
new file mode 100644
index 0000000..81d9f84
--- /dev/null
+++ b/lib/nauty/nautyex2.c
@@ -0,0 +1,75 @@
+/* This program prints generators for the automorphism group of an
+   n-vertex polygon, where n is a number supplied by the user.
+
+   This version uses dynamic allocation.
+*/
+
+#include "nauty.h"   
+/* MAXN=0 is defined by nauty.h, which implies dynamic allocation */
+
+int
+main(int argc, char *argv[])
+{
+  /* DYNALLSTAT declares a pointer variable (to hold an array when it
+     is allocated) and a size variable to remember how big the array is.
+     Nothing is allocated yet.  */
+ 
+    DYNALLSTAT(graph,g,g_sz);
+    DYNALLSTAT(int,lab,lab_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+    static DEFAULTOPTIONS_GRAPH(options);
+    statsblk stats;
+
+    int n,m,v;
+    set *gv;
+
+/* Default options are set by the DEFAULTOPTIONS_GRAPH macro above.
+   Here we change those options that we want to be different from the
+   defaults.  writeautoms=TRUE causes automorphisms to be written. */
+
+    options.writeautoms = TRUE;
+
+    while (1)
+    {
+        printf("\nenter n : ");
+        if (scanf("%d",&n) == 1 && n > 0)
+        {
+
+     /* The nauty parameter m is a value such that an array of
+        m setwords is sufficient to hold n bits.  The type setword
+        is defined in nauty.h.  The number of bits in a setword is
+        WORDSIZE, which is 16, 32 or 64.  Here we calculate
+        m = ceiling(n/WORDSIZE). */
+
+            m = SETWORDSNEEDED(n);
+
+         /* The following optional call verifies that we are linking
+            to compatible versions of the nauty routines. */
+
+            nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
+
+         /* Now that we know how big the graph will be, we allocate
+          * space for the graph and the other arrays we need. */
+
+            DYNALLOC2(graph,g,g_sz,m,n,"malloc");
+            DYNALLOC1(int,lab,lab_sz,n,"malloc");
+            DYNALLOC1(int,ptn,ptn_sz,n,"malloc");
+            DYNALLOC1(int,orbits,orbits_sz,n,"malloc");
+
+            EMPTYGRAPH(g,m,n);
+            for (v = 0; v < n; ++v) ADDONEEDGE(g,v,(v+1)%n,m);
+
+            printf("Generators for Aut(C[%d]):\n",n);
+            densenauty(g,lab,ptn,orbits,&options,&stats,m,n,NULL);
+
+            printf("order = ");
+            writegroupsize(stdout,stats.grpsize1,stats.grpsize2);
+            printf("\n");
+        }
+        else
+            break;
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/nautyex3.c b/lib/nauty/nautyex3.c
new file mode 100644
index 0000000..b71fe8c
--- /dev/null
+++ b/lib/nauty/nautyex3.c
@@ -0,0 +1,82 @@
+/* This program prints the entire automorphism group of an n-vertex
+   polygon, where n is a number supplied by the user. 
+*/
+
+#include "nauty.h"    /* which includes <stdio.h> */
+#include "naugroup.h"
+
+/**************************************************************************/
+
+void
+writeautom(int *p, int n)
+/* Called by allgroup.  Just writes the permutation p. */
+{
+    int i;
+
+    for (i = 0; i < n; ++i) printf(" %2d",p[i]); printf("\n");
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    DYNALLSTAT(graph,g,g_sz);
+    DYNALLSTAT(int,lab,lab_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+    static DEFAULTOPTIONS_GRAPH(options);
+    statsblk stats;
+
+    int n,m,v;
+    grouprec *group;
+
+ /* The following cause nauty to call two procedures which
+        store the group information as nauty runs. */
+        
+    options.userautomproc = groupautomproc;
+    options.userlevelproc = grouplevelproc;
+
+    while (1)
+    {
+        printf("\nenter n : ");
+        if (scanf("%d",&n) == 1 && n > 0)
+        {
+            m = SETWORDSNEEDED(n);
+            nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
+
+            DYNALLOC2(graph,g,g_sz,m,n,"malloc");
+            DYNALLOC1(int,lab,lab_sz,n,"malloc");
+            DYNALLOC1(int,ptn,ptn_sz,n,"malloc");
+            DYNALLOC1(int,orbits,orbits_sz,n,"malloc");
+
+            EMPTYGRAPH(g,m,n);
+            for (v = 0; v < n; ++v) ADDONEEDGE(g,v,(v+1)%n,m);
+
+            printf("Automorphisms of C[%d]:\n",n);
+            densenauty(g,lab,ptn,orbits,&options,&stats,m,n,NULL);
+
+         /* Get a pointer to the structure in which the group information
+            has been stored.  If you use TRUE as an argument, the
+            structure will be "cut loose" so that it won't be used
+            again the next time nauty() is called.  Otherwise, as
+            here, the same structure is used repeatedly. */
+                
+            group = groupptr(FALSE);
+
+         /* Expand the group structure to include a full set of coset
+            representatives at every level.  This step is necessary
+            if allgroup() is to be called. */
+                
+            makecosetreps(group);
+
+         /* Call the procedure writeautom() for every element of the group.
+            The first call is always for the identity. */
+                
+            allgroup(group,writeautom);
+        }
+        else
+            break;
+    }
+    exit(0);
+}
diff --git a/lib/nauty/nautyex4.c b/lib/nauty/nautyex4.c
new file mode 100644
index 0000000..4ad30f8
--- /dev/null
+++ b/lib/nauty/nautyex4.c
@@ -0,0 +1,67 @@
+/* This program prints generators for the automorphism group of an
+   n-vertex polygon, where n is a number supplied by the user.
+   This version uses sparse form with dynamic allocation.
+*/
+
+#include "nausparse.h"    /* which includes nauty.h */
+
+int
+main(int argc, char *argv[])
+{
+    DYNALLSTAT(int,lab,lab_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+    static DEFAULTOPTIONS_SPARSEGRAPH(options);
+    statsblk stats;
+    sparsegraph sg;   /* Declare sparse graph structure */
+
+    int n,m,i;
+
+    options.writeautoms = TRUE;
+
+ /* Initialise sparse graph structure. */
+
+    SG_INIT(sg);
+
+    while (1)
+    {
+        printf("\nenter n : ");
+        if (scanf("%d",&n) == 1 && n > 0)
+        {
+            m = SETWORDSNEEDED(n);
+            nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
+
+            DYNALLOC1(int,lab,lab_sz,n,"malloc");
+            DYNALLOC1(int,ptn,ptn_sz,n,"malloc");
+            DYNALLOC1(int,orbits,orbits_sz,n,"malloc");
+
+         /* SG_ALLOC makes sure that the v,d,e fields of a sparse graph
+            structure point to arrays that are large enough.  This only
+            works if the structure has been initialised. */
+
+            SG_ALLOC(sg,n,2*n,"malloc");
+
+            sg.nv = n;              /* Number of vertices */
+            sg.nde = 2*n;           /* Number of directed edges */
+
+            for (i = 0; i < n; ++i)
+            {
+                sg.v[i] = 2*i;
+                sg.d[i] = 2;
+                sg.e[2*i] = (i+n-1)%n;      /* edge i->i-1 */
+                sg.e[2*i+1] = (i+n+1)%n;    /* edge i->i+1 */
+            }
+
+            printf("Generators for Aut(C[%d]):\n",n);
+            sparsenauty(&sg,lab,ptn,orbits,&options,&stats,NULL);
+
+            printf("Automorphism group size = ");
+            writegroupsize(stdout,stats.grpsize1,stats.grpsize2);
+            printf("\n");
+        }
+        else
+            break;
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/nautyex5.c b/lib/nauty/nautyex5.c
new file mode 100644
index 0000000..7de33c3
--- /dev/null
+++ b/lib/nauty/nautyex5.c
@@ -0,0 +1,130 @@
+/* This program demonstrates how an isomorphism is found between
+   two graphs, using the Moebius graph as an example.
+   This version uses sparse form with dynamic allocation.
+*/
+
+#include "nausparse.h"    /* which includes nauty.h */
+
+int
+main(int argc, char *argv[])
+{
+    DYNALLSTAT(int,lab1,lab1_sz);
+    DYNALLSTAT(int,lab2,lab2_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+    DYNALLSTAT(int,map,map_sz);
+    static DEFAULTOPTIONS_SPARSEGRAPH(options);
+    statsblk stats;
+ /* Declare and initialize sparse graph structures */
+    SG_DECL(sg1); SG_DECL(sg2);
+    SG_DECL(cg1); SG_DECL(cg2);
+
+    int n,m,i;
+
+ /* Select option for canonical labelling */
+
+    options.getcanon = TRUE;
+ 
+ /* Read the number of vertices and process it */
+
+    while (1)
+    {
+        printf("\nenter n : ");
+        if (scanf("%d",&n) == 1 && n > 0)
+        {
+            if (n%2 != 0)
+            {
+                fprintf(stderr,"Sorry, n must be even\n");
+                continue;
+            }
+
+            m = SETWORDSNEEDED(n);
+            nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
+
+            DYNALLOC1(int,lab1,lab1_sz,n,"malloc");
+            DYNALLOC1(int,lab2,lab2_sz,n,"malloc");
+            DYNALLOC1(int,ptn,ptn_sz,n,"malloc");
+            DYNALLOC1(int,orbits,orbits_sz,n,"malloc");
+            DYNALLOC1(int,map,map_sz,n,"malloc");
+
+         /* Now make the first graph */
+
+            SG_ALLOC(sg1,n,3*n,"malloc");
+            sg1.nv = n;              /* Number of vertices */
+            sg1.nde = 3*n;           /* Number of directed edges */
+
+            for (i = 0; i < n; ++i)
+            {
+                sg1.v[i] = 3*i;     /* Position of vertex i in v array */
+                sg1.d[i] = 3;       /* Degree of vertex i */
+            }
+             
+            for (i = 0; i < n; i += 2)   /* Spokes */
+            {
+                sg1.e[sg1.v[i]] = i+1;
+                sg1.e[sg1.v[i+1]] = i;
+            }
+
+            for (i = 0; i < n-2; ++i)  /* Clockwise edges */
+                sg1.e[sg1.v[i]+1] = i+2;
+            sg1.e[sg1.v[n-2]+1] = 1;
+            sg1.e[sg1.v[n-1]+1] = 0;
+
+            for (i = 2; i < n; ++i)  /* Anticlockwise edges */
+                sg1.e[sg1.v[i]+2] = i-2;
+            sg1.e[sg1.v[1]+2] = n-2;
+            sg1.e[sg1.v[0]+2] = n-1;
+                
+         /* Now make the second graph */
+
+            SG_ALLOC(sg2,n,3*n,"malloc");
+            sg2.nv = n;              /* Number of vertices */
+            sg2.nde = 3*n;           /* Number of directed edges */
+
+            for (i = 0; i < n; ++i)
+            {
+                sg2.v[i] = 3*i;
+                sg2.d[i] = 3;
+            }
+
+            for (i = 0; i < n; ++i)
+            {
+                sg2.v[i] = 3*i;
+                sg2.d[i] = 3;
+                sg2.e[sg2.v[i]] = (i+1) % n;      /* Clockwise */
+                sg2.e[sg2.v[i]+1] = (i+n-1) % n;  /* Anti-clockwise */
+                sg2.e[sg2.v[i]+2] = (i+n/2) % n;  /* Diagonals */
+            }
+
+         /* Label sg1, result in cg1 and labelling in lab1; similarly sg2.
+            It is not necessary to pre-allocate space in cg1 and cg2, but
+            they have to be initialised as we did above.  */
+            
+            sparsenauty(&sg1,lab1,ptn,orbits,&options,&stats,&cg1);
+            sparsenauty(&sg2,lab2,ptn,orbits,&options,&stats,&cg2);
+
+         /* Compare canonically labelled graphs */
+
+            if (aresame_sg(&cg1,&cg2))
+            {
+                printf("Isomorphic.\n");
+                if (n <= 1000)
+                {
+                 /* Write the isomorphism.  For each i, vertex lab1[i]
+                    of sg1 maps onto vertex lab2[i] of sg2.  We compute
+                    the map in order of labelling because it looks better. */
+
+                    for (i = 0; i < n; ++i) map[lab1[i]] = lab2[i];
+                    for (i = 0; i < n; ++i) printf(" %d-%d",i,map[i]);
+                    printf("\n");
+                }
+            }
+            else
+                printf("Not isomorphic.\n");
+        }
+        else
+            break;
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/nautyex6.c b/lib/nauty/nautyex6.c
new file mode 100644
index 0000000..c406f63
--- /dev/null
+++ b/lib/nauty/nautyex6.c
@@ -0,0 +1,103 @@
+/* This program demonstrates how an isomorphism is found between
+   graphs of the form in the figure above, for general size.
+
+   This version uses dense form with dynamic allocation.
+*/
+
+#include "nauty.h"
+
+int
+main(int argc, char *argv[])
+{
+    DYNALLSTAT(int,lab1,lab1_sz);
+    DYNALLSTAT(int,lab2,lab2_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+    DYNALLSTAT(int,map,map_sz);
+    DYNALLSTAT(graph,g1,g1_sz);
+    DYNALLSTAT(graph,g2,g2_sz);
+    DYNALLSTAT(graph,cg1,cg1_sz);
+    DYNALLSTAT(graph,cg2,cg2_sz);
+    static DEFAULTOPTIONS_GRAPH(options);
+    statsblk stats;
+
+    int n,m,i;
+
+ /* Select option for canonical labelling */
+
+    options.getcanon = TRUE;
+ 
+    while (1)
+    {
+        printf("\nenter n : ");
+        if (scanf("%d",&n) == 1 && n > 0)
+        {
+            if (n%2 != 0)
+            {
+                fprintf(stderr,"Sorry, n must be even\n");
+                continue;
+            }
+
+            m = SETWORDSNEEDED(n);
+            nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
+
+            DYNALLOC1(int,lab1,lab1_sz,n,"malloc");
+            DYNALLOC1(int,lab2,lab2_sz,n,"malloc");
+            DYNALLOC1(int,ptn,ptn_sz,n,"malloc");
+            DYNALLOC1(int,orbits,orbits_sz,n,"malloc");
+            DYNALLOC1(int,map,map_sz,n,"malloc");
+            DYNALLOC2(graph,g1,g1_sz,n,m,"malloc");
+            DYNALLOC2(graph,g2,g2_sz,n,m,"malloc");
+            DYNALLOC2(graph,cg1,cg1_sz,n,m,"malloc");
+            DYNALLOC2(graph,cg2,cg2_sz,n,m,"malloc");
+
+         /* Now make the first graph */
+         /* ADDEDGE() is defined above */
+
+            EMPTYGRAPH(g1,m,n);  /* start with no edges */
+
+            for (i = 0; i < n-2; ++i) ADDONEEDGE(g1,i,i+2,m);
+            ADDONEEDGE(g1,n-2,1,m);
+            ADDONEEDGE(g1,n-1,0,m);
+            for (i = 0; i < n; i += 2) ADDONEEDGE(g1,i,i+1,m);
+
+         /* Now make the second graph */
+
+            EMPTYGRAPH(g2,m,n);  /* start with no edges */
+
+            for (i = 0; i < n-1; ++i) ADDONEEDGE(g2,i,i+1,m);
+            ADDONEEDGE(g2,n-1,0,m);
+            for (i = 0; i < n/2; ++i) ADDONEEDGE(g2,i,i+n/2,m);
+
+         /* Label g1, result in cg1 and labelling in lab1; similarly g2.
+            It is not necessary to pre-allocate space in cg1 and cg2, but
+            they have to be initialised as we did above.  */
+            
+            densenauty(g1,lab1,ptn,orbits,&options,&stats,m,n,cg1);
+            densenauty(g2,lab2,ptn,orbits,&options,&stats,m,n,cg2);
+
+         /* Compare canonically labelled graphs */
+
+            if (memcmp(cg1,cg2,m*sizeof(graph)*n) == 0)
+            {
+                printf("Isomorphic.\n");
+                if (n <= 1000)
+                {
+                 /* Write the isomorphism.  For each i, vertex lab1[i]
+                    of sg1 maps onto vertex lab2[i] of sg2.  We compute
+                    the map in order of labelling because it looks better. */
+
+                    for (i = 0; i < n; ++i) map[lab1[i]] = lab2[i];
+                    for (i = 0; i < n; ++i) printf(" %d-%d",i,map[i]);
+                    printf("\n");
+                }
+            }
+            else
+                printf("Not isomorphic.\n");
+        }
+        else
+            break;
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/nautyex7.c b/lib/nauty/nautyex7.c
new file mode 100644
index 0000000..6cb878b
--- /dev/null
+++ b/lib/nauty/nautyex7.c
@@ -0,0 +1,130 @@
+/* This program demonstrates how an isomorphism is found between
+   two graphs, using the Moebius graph as an example.
+   This version uses Traces.
+*/
+
+#include "traces.h"
+
+int
+main(int argc, char *argv[])
+{
+    DYNALLSTAT(int,lab1,lab1_sz);
+    DYNALLSTAT(int,lab2,lab2_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+    DYNALLSTAT(int,map,map_sz);
+    static DEFAULTOPTIONS_TRACES(options);
+    TracesStats stats;
+ /* Declare and initialize sparse graph structures */
+    SG_DECL(sg1); SG_DECL(sg2);
+    SG_DECL(cg1); SG_DECL(cg2);
+
+    int n,m,i;
+
+ /* Select option for canonical labelling */
+
+    options.getcanon = TRUE;
+ 
+ /* Read a number of vertices and process */
+
+    while (1)
+    {
+        printf("\nenter n : ");
+        if (scanf("%d",&n) == 1 && n > 0)
+        {
+            if (n%2 != 0)
+            {
+                fprintf(stderr,"Sorry, n must be even\n");
+                continue;
+            }
+
+            m = SETWORDSNEEDED(n);
+            nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
+
+            DYNALLOC1(int,lab1,lab1_sz,n,"malloc");
+            DYNALLOC1(int,lab2,lab2_sz,n,"malloc");
+            DYNALLOC1(int,ptn,ptn_sz,n,"malloc");
+            DYNALLOC1(int,orbits,orbits_sz,n,"malloc");
+            DYNALLOC1(int,map,map_sz,n,"malloc");
+
+         /* Now make the first graph */
+
+            SG_ALLOC(sg1,n,3*n,"malloc");
+            sg1.nv = n;              /* Number of vertices */
+            sg1.nde = 3*n;           /* Number of directed edges */
+
+            for (i = 0; i < n; ++i)
+            {
+                sg1.v[i] = 3*i;     /* Position of vertex i in v array */
+                sg1.d[i] = 3;       /* Degree of vertex i */
+            }
+             
+            for (i = 0; i < n; i += 2)   /* Spokes */
+            {
+                sg1.e[sg1.v[i]] = i+1;
+                sg1.e[sg1.v[i+1]] = i;
+            }
+
+            for (i = 0; i < n-2; ++i)  /* Clockwise edges */
+                sg1.e[sg1.v[i]+1] = i+2;
+            sg1.e[sg1.v[n-2]+1] = 1;
+            sg1.e[sg1.v[n-1]+1] = 0;
+
+            for (i = 2; i < n; ++i)  /* Anticlockwise edges */
+                sg1.e[sg1.v[i]+2] = i-2;
+            sg1.e[sg1.v[1]+2] = n-2;
+            sg1.e[sg1.v[0]+2] = n-1;
+                
+         /* Now make the second graph */
+
+            SG_ALLOC(sg2,n,3*n,"malloc");
+            sg2.nv = n;              /* Number of vertices */
+            sg2.nde = 3*n;           /* Number of directed edges */
+
+            for (i = 0; i < n; ++i)
+            {
+                sg2.v[i] = 3*i;
+                sg2.d[i] = 3;
+            }
+
+            for (i = 0; i < n; ++i)
+            {
+                sg2.v[i] = 3*i;
+                sg2.d[i] = 3;
+                sg2.e[sg2.v[i]] = (i+1) % n;      /* Clockwise */
+                sg2.e[sg2.v[i]+1] = (i+n-1) % n;  /* Anti-clockwise */
+                sg2.e[sg2.v[i]+2] = (i+n/2) % n;  /* Diagonals */
+            }
+
+         /* Label sg1, result in cg1 and labelling in lab1; similarly sg2.
+            It is not necessary to pre-allocate space in cg1 and cg2, but
+            they have to be initialised as we did above.  */
+            
+            Traces(&sg1,lab1,ptn,orbits,&options,&stats,&cg1);
+            Traces(&sg2,lab2,ptn,orbits,&options,&stats,&cg2);
+
+         /* Compare canonically labelled graphs */
+
+            if (aresame_sg(&cg1,&cg2))
+            {
+                printf("Isomorphic.\n");
+                if (n <= 1000)
+                {
+                 /* Write the isomorphism.  For each i, vertex lab1[i]
+                    of sg1 maps onto vertex lab2[i] of sg2.  We compute
+                    the map in order of labelling because it looks better. */
+
+                    for (i = 0; i < n; ++i) map[lab1[i]] = lab2[i];
+                    for (i = 0; i < n; ++i) printf(" %d-%d",i,map[i]);
+                    printf("\n");
+                }
+            }
+            else
+                printf("Not isomorphic.\n");
+        }
+        else
+            break;
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/nautyex8.c b/lib/nauty/nautyex8.c
new file mode 100644
index 0000000..33220f5
--- /dev/null
+++ b/lib/nauty/nautyex8.c
@@ -0,0 +1,109 @@
+/* This program demonstrates how an isomorphism is found between
+   two graphs, using the Moebius graphs as an example.
+   This version uses dense form with dynamic allocation.
+*/
+
+#include "nauty.h" 
+
+int
+main(int argc, char *argv[])
+{
+    DYNALLSTAT(int,lab1,lab1_sz);
+    DYNALLSTAT(int,lab2,lab2_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+    DYNALLSTAT(int,map,map_sz);
+    DYNALLSTAT(graph,g1,g1_sz);
+    DYNALLSTAT(graph,g2,g2_sz);
+    DYNALLSTAT(graph,cg1,cg1_sz);
+    DYNALLSTAT(graph,cg2,cg2_sz);
+    static DEFAULTOPTIONS_GRAPH(options);
+    statsblk stats;
+
+    int n,m,i;
+    size_t k;
+
+ /* Select option for canonical labelling */
+
+    options.getcanon = TRUE;
+ 
+    while (1)
+    {
+        printf("\nenter n : ");
+        if (scanf("%d",&n) == 1 && n > 0)
+        {
+            if (n%2 != 0)
+            {
+                fprintf(stderr,"Sorry, n must be even\n");
+                continue;
+            }
+
+            m = SETWORDSNEEDED(n);
+            nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
+
+            DYNALLOC1(int,lab1,lab1_sz,n,"malloc");
+            DYNALLOC1(int,lab2,lab2_sz,n,"malloc");
+            DYNALLOC1(int,ptn,ptn_sz,n,"malloc");
+            DYNALLOC1(int,orbits,orbits_sz,n,"malloc");
+            DYNALLOC1(int,map,map_sz,n,"malloc");
+
+         /* Now make the first graph */
+
+            DYNALLOC2(graph,g1,g1_sz,n,m,"malloc");
+            EMPTYGRAPH(g1,m,n);
+
+            for (i = 0; i < n; i += 2)   /* Spokes */
+                ADDONEEDGE(g1,i,i+1,m);
+
+            for (i = 0; i < n-2; ++i)  /* Cycle */
+                ADDONEEDGE(g1,i,i+2,m);
+            ADDONEEDGE(g1,1,n-2,m);
+            ADDONEEDGE(g1,0,n-1,m);
+
+         /* Now make the second graph */
+
+            DYNALLOC2(graph,g2,g2_sz,n,m,"malloc");
+            EMPTYGRAPH(g2,m,n);
+
+            for (i = 0; i < n; ++i)
+            {
+                ADDONEEDGE(g2,i,(i+1)%n,m);   /* Rim */
+                ADDONEEDGE(g2,i,(i+n/2)%n,m); /* Diagonals */
+            }
+
+         /* Create canonical graphs */
+
+            DYNALLOC2(graph,cg1,cg1_sz,n,m,"malloc");
+            DYNALLOC2(graph,cg2,cg2_sz,n,m,"malloc");
+
+            densenauty(g1,lab1,ptn,orbits,&options,&stats,m,n,cg1);
+            densenauty(g2,lab2,ptn,orbits,&options,&stats,m,n,cg2);
+
+         /* Compare canonically labelled graphs */
+
+            for (k = 0; k < m*(size_t)n; ++k)
+                if (cg1[k] != cg2[k]) break;
+
+            if (k == m*(size_t)n)
+            {
+                printf("Isomorphic.\n");
+                if (n <= 1000)
+                {
+                 /* Write the isomorphism.  For each i, vertex lab1[i]
+                    of sg1 maps onto vertex lab2[i] of sg2.  We compute
+                    the map in order of labelling because it looks better. */
+
+                    for (i = 0; i < n; ++i) map[lab1[i]] = lab2[i];
+                    for (i = 0; i < n; ++i) printf(" %d-%d",i,map[i]);
+                    printf("\n");
+                }
+            }
+            else
+                printf("Not isomorphic.\n");
+        }
+        else
+            break;
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/nautyex9.c b/lib/nauty/nautyex9.c
new file mode 100644
index 0000000..68cc138
--- /dev/null
+++ b/lib/nauty/nautyex9.c
@@ -0,0 +1,118 @@
+/* This program demonstrates how known automorphisms can be given
+   to Traces.  We compute the automorphism group of the circulant
+   graph of order n with i is adjacent to j iff j-i is a square
+   mod n.  We need that -1 is a square so that the graph is
+   undirected, which means that the prime factors of n must be 
+   congruent to 1 mod 4.  (This is the Paley graph in the event
+   that p is a prime.)
+*/
+
+#include "traces.h"
+
+int
+main(int argc, char *argv[])
+{
+    DYNALLSTAT(int,p,p_sz);
+    DYNALLSTAT(boolean,issquare,issquare_sz);
+    DYNALLSTAT(int,lab,lab_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+    static DEFAULTOPTIONS_TRACES(options);
+    TracesStats stats;
+ /* Declare and initialize sparse graph structures */
+    SG_DECL(sg);
+
+    int deg,n,m,i,j;
+    size_t k;
+    permnode *gens;
+
+ /* Select option for passing generators to Traces */
+
+    options.generators = &gens;
+ 
+ /* Read a number of vertices and process it */
+
+    while (1)
+    {
+        printf("\nenter n : ");
+        if (scanf("%d",&n) == 1 && n > 2)
+        {
+            m = SETWORDSNEEDED(n);
+            nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
+
+            DYNALLOC1(int,lab,lab_sz,n,"malloc");
+            DYNALLOC1(int,ptn,ptn_sz,n,"malloc");
+            DYNALLOC1(int,orbits,orbits_sz,n,"malloc");
+            DYNALLOC1(int,p,p_sz,n,"malloc");
+            DYNALLOC1(boolean,issquare,issquare_sz,n,"malloc");
+
+         /* Initialise list of automorphisms */
+
+            gens = NULL;
+
+         /* Find the squares and the degree */
+
+            for (i = 0; i < n; ++i) issquare[i] = FALSE;
+            for (i = 0; i < n; ++i) issquare[(i*i)%n] = TRUE;
+            if (!issquare[n-1])
+            {
+                printf("-1 must be a square mod n; try again\n");
+                continue;
+            }
+
+            deg = 0;
+            for (i = 1; i < n; ++i) if (issquare[i]) ++deg;
+
+         /* Now make the graph */
+
+            SG_ALLOC(sg,n,n*deg,"malloc");
+            sg.nv = n;              /* Number of vertices */
+            sg.nde = n*deg;           /* Number of directed edges */
+
+            for (i = 0; i < n; ++i)
+            {
+                sg.v[i] = i*deg;     /* Position of vertex i in v array */
+                sg.d[i] = deg;       /* Degree of vertex i */
+            }
+             
+            for (i = 0; i < n; ++i)   /* Edges */
+            {
+                k = sg.v[i];
+                for (j = 1; j < n; ++j)
+                    if (issquare[j]) sg.e[k++] = (i + j) % n;
+            }
+
+         /* Add known automorphisms */
+
+            /* We wouldn't need freeschreier() if we were only
+               processing one graph, but it doesn't hurt.  This
+               is how to properly dispose of previous generators. */
+
+            freeschreier(NULL,&gens);
+
+            /* Cyclic rotation */
+            for (i = 0; i < n; ++i) p[i] = (i + 1) % n;
+            addpermutation(&gens,p,n);
+
+            /* Reflection about 0 */
+            for (i = 0; i < n; ++i) p[i] = (n - i) % n;
+            addpermutation(&gens,p,n);
+
+         /* Call Traces */
+            
+            Traces(&sg,lab,ptn,orbits,&options,&stats,NULL);
+
+            printf("Automorphism group size = ");
+            writegroupsize(stdout,stats.grpsize1,stats.grpsize2);
+            printf("\n");
+
+        /* Traces left the automorphims we gave it, augmented by
+           any extra automorphims it found, in a circular list
+           pointed to by gens.  See schreier.txt for documentation. */
+        }
+        else
+            break;
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/newedgeg.c b/lib/nauty/newedgeg.c
new file mode 100644
index 0000000..c33ecf6
--- /dev/null
+++ b/lib/nauty/newedgeg.c
@@ -0,0 +1,242 @@
+/* newedgeg.c  version 1.1; B D McKay, Dec 2005. */
+
+#define USAGE "newedgeg [-lq] [infile [outfile]]"
+
+#define HELPTEXT \
+" For each pair of non-adjacent edges, output the graph obtained\n\
+  by subdividing the edges and joining the new vertices.\n\
+\n\
+    The output file has a header if and only if the input file does.\n\
+\n\
+    -l  Canonically label outputs\n\
+    -q  Suppress auxiliary information\n"
+
+/*************************************************************************/
+
+#include "gtools.h" 
+#include "gutils.h"
+
+static FILE *outfile;
+static nauty_counter nout;
+static int outcode;
+
+/*************************************************************************/
+
+static void
+newedge(graph *g1, int m1, int n1,
+        int v1, int v2, int w1, int w2,
+        graph *g2, int m2) 
+/* Make g2 by subdividing edges v1-v2 and w1-w2 in g1
+   and adding an edge between them.  Must have m2 >= m1.  */
+{
+	int i,j;
+	setword *s1,*s2;
+
+	s1 = g1;
+	s2 = g2;
+	for (i = 0; i < n1; ++i)
+	{
+	    for (j = 0; j < m1; ++j) *(s2++) = *(s1++);
+	    for (; j < m2; ++j) *(s2++) = 0;
+	}
+
+	s2 = GRAPHROW(g2,v1,m2);
+	DELELEMENT(s2,v2);
+	ADDELEMENT(s2,n1);
+
+	s2 = GRAPHROW(g2,v2,m2);
+        DELELEMENT(s2,v1);
+        ADDELEMENT(s2,n1);
+
+	s2 = GRAPHROW(g2,w1,m2);
+        DELELEMENT(s2,w2);
+        ADDELEMENT(s2,n1+1);
+
+	s2 = GRAPHROW(g2,w2,m2);
+        DELELEMENT(s2,w1);
+        ADDELEMENT(s2,n1+1);
+
+	s2 = GRAPHROW(g2,n1,m2);
+	EMPTYSET(s2,m2);
+	ADDELEMENT(s2,v1);
+	ADDELEMENT(s2,v2);
+	ADDELEMENT(s2,n1+1);
+
+	s2 = GRAPHROW(g2,n1+1,m2);
+	EMPTYSET(s2,m2);
+	ADDELEMENT(s2,w1);
+	ADDELEMENT(s2,w2);
+	ADDELEMENT(s2,n1);
+}
+
+/*************************************************************************/
+
+static void
+na_newedge(graph *g1, int m1, int n1, boolean dolabel)
+/* Make all graphs by non-adjacent edge addition. */
+{
+	int n2,m2;
+	int v1,v2,w1,w2;
+	set *sv1,*sw1;
+	graph *gq;
+#if MAXN
+	graph h[MAXN*MAXM];
+	grapg g2[MAXN*MAXM];
+#else
+	DYNALLSTAT(graph,h,h_sz);
+	DYNALLSTAT(graph,g2,g2_sz);
+#endif
+
+	n2 = n1 + 2;
+	m2 = (n2 + WORDSIZE - 1) / WORDSIZE;
+	if (m2 < m1) m2 = m1;
+
+#if !MAXN
+	DYNALLOC2(graph,g2,g2_sz,m2,n2,"newedgeg");
+	if (dolabel) DYNALLOC2(graph,h,h_sz,m2,n2,"newedgeg");
+#endif
+
+	for (v1 = 0, sv1 = g1; v1 < n1-3; ++v1, sv1 += m1)
+	for (w1 = v1+1, sw1 = sv1 + m1; w1 < n1-1; ++w1, sw1 += m1)
+	{
+	    for (v2 = v1; (v2 = nextelement(sv1,m1,v2)) >= 0; )
+	    for (w2 = w1; (w2 = nextelement(sw1,m1,w2)) >= 0; )
+	    {
+		if (v2 == w1 || v2 == w2) continue;
+
+		newedge(g1,m1,n1,v1,v2,w1,w2,g2,m2);
+
+                gq = g2;
+
+                if (dolabel)
+                {
+                    fcanonise(g2,m2,n2,h,NULL,FALSE);  /* FIXME (loops) */
+                    gq = h;
+                }
+                if (outcode == SPARSE6) writes6(outfile,gq,m2,n2);
+                else                    writeg6(outfile,gq,m2,n2);
+                ++nout;
+	    }
+	}
+}
+
+/*************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+        char *infilename,*outfilename;
+        FILE *infile;
+        boolean badargs,dolabel,quiet;
+	int j,m,n,argnum;
+	int codetype;
+	graph *g;
+	nauty_counter nin;
+        char *arg,sw;
+	double t;
+
+	HELP; PUTVERSION;
+
+        infilename = outfilename = NULL;
+	dolabel = quiet = FALSE;
+
+	argnum = 0;
+	badargs = FALSE;
+	for (j = 1; !badargs && j < argc; ++j)
+	{
+	    arg = argv[j];
+	    if (arg[0] == '-' && arg[1] != '\0')
+	    {
+		++arg;
+		while (*arg != '\0')
+		{
+		    sw = *arg++;
+		         SWBOOLEAN('l',dolabel)
+		    else SWBOOLEAN('q',quiet)
+		    else badargs = TRUE;
+		}
+	    }
+	    else
+	    {
+		++argnum;
+		if      (argnum == 1) infilename = arg;
+	        else if (argnum == 2) outfilename = arg;
+		else                  badargs = TRUE;
+	    }
+	}
+
+	if (badargs)
+	{
+	    fprintf(stderr,">E Usage: %s\n",USAGE);
+	    GETHELP;
+	    exit(1);
+	}
+
+	if (!quiet)
+	{
+	    fprintf(stderr,">A newedgeg");
+	    if (dolabel) fprintf(stderr," -l");
+	    if (argnum > 0) fprintf(stderr," %s",infilename);
+	    if (argnum > 1) fprintf(stderr," %s",outfilename);
+	    fprintf(stderr,"\n");
+	    fflush(stderr);
+	}
+
+	if (infilename && infilename[0] == '-') infilename = NULL;
+	infile = opengraphfile(infilename,&codetype,FALSE,1);
+	if (!infile) exit(1);
+	if (!infilename) infilename = "stdin";
+
+        NODIGRAPHSYET(codetype);
+
+	if (!outfilename || outfilename[0] == '-')
+	{
+	    outfilename = "stdout";
+	    outfile = stdout;
+	}
+	else if ((outfile = fopen(outfilename,"w")) == NULL)
+	{
+	    fprintf(stderr,"Can't open output file %s\n",outfilename);
+	    gt_abort(NULL);
+	}
+
+	if (codetype&SPARSE6) outcode = SPARSE6;
+	else                  outcode = GRAPH6;
+
+	if (codetype&HAS_HEADER)
+	{
+	    if (outcode == SPARSE6) writeline(outfile,SPARSE6_HEADER);
+	    else    		    writeline(outfile,GRAPH6_HEADER);
+	}
+
+	if (dolabel) nauty_check(WORDSIZE,1,1,NAUTYVERSIONID);
+
+	nin = nout = 0;
+	t = CPUTIME;
+	while (TRUE)
+	{
+	    if ((g = readg(infile,NULL,0,&m,&n)) == NULL) break;
+#if MAXN
+	    if (n > MAXN-2)
+	    {
+		fprintf(stderr,">E newedgeg: input too large\n");
+		exit(1);
+	    }
+#endif
+
+	    ++nin;
+
+	    na_newedge(g,m,n,dolabel);
+
+	    FREES(g);
+	}
+	t = CPUTIME - t;
+
+        if (!quiet)
+            fprintf(stderr,
+                ">Z  " COUNTER_FMT " graphs read from %s, "
+                       COUNTER_FMT " written to %s; %3.2f sec.\n",
+                    nin,infilename,nout,outfilename,t);
+
+	exit(0);
+}
diff --git a/lib/nauty/nug26.pdf b/lib/nauty/nug26.pdf
new file mode 100644
index 0000000..21d49dc
Binary files /dev/null and b/lib/nauty/nug26.pdf differ
diff --git a/lib/nauty/planarg.c b/lib/nauty/planarg.c
new file mode 100644
index 0000000..185901c
--- /dev/null
+++ b/lib/nauty/planarg.c
@@ -0,0 +1,393 @@
+/* planarg : test for planarity and find embedding or obstruction */
+
+#define USAGE "planarg [-v] [-nVq] [-p|-u] [infile [outfile]]"
+
+#define HELPTEXT \
+" For each input, write to output if planar.\n\
+\n\
+    The output file has a header if and only if the input file does.\n\
+\n\
+    -v  Write non-planar graphs instead of planar graphs\n\
+    -V  Write report on every input\n\
+    -u  Don't write anything, just count\n\
+    -p  Write in planar_code if planar (without -p, same format as input)\n\
+    -k  Follow each non-planar output with an obstruction in sparse6\n\
+        format (implies -v, incompatible with -p)\n\
+    -n  Suppress checking of the result\n\
+    -q  Suppress auxiliary information\n\
+\n\
+    This program permits multiple edges and loops\n"
+
+/*************************************************************************/
+
+#include "gtools.h" 
+#include "planarity.h"
+
+/*************************************************************************/
+
+static void
+write_planarcode(FILE *f, t_ver_sparse_rep *VR, t_adjl_sparse_rep *A,
+                 t_embed_sparse_rep *ER, int n, int ne)
+/* Write the embedding to f in planar_code */
+{
+    int bytes;
+    size_t i,j,len,k,k0;
+    unsigned int w;
+    DYNALLSTAT(unsigned char,buff,buff_sz);
+#define PUT1(x) buff[j++]=(x);
+#define PUT2(x) w=(x); buff[j++]=(w>>8)&0xFF; buff[j++]=w&0xff;
+#define PUT4(x) w=(x); buff[j++]=(w>>24)&0xFF; buff[j++]=(w>>16)&0xff; \
+             buff[j++]=(w>>8)&0xFF; buff[j++]=w&0xff;
+
+    if (n <= 255)        bytes = 1;
+    else if (n <= 65535) bytes = 2;
+    else                 bytes = 4;
+
+    len = bytes * (1 + n + 2*(size_t)ne);
+    if (bytes == 2)      len += 1;
+    else if (bytes == 4) len += 3;
+
+    DYNALLOC1(unsigned char,buff,buff_sz,len,"planarg");
+
+    if (bytes == 1)
+    {
+        j = 0;
+        PUT1(n);
+        for (i = 0; i < n; ++i)
+        {
+            k = k0 = VR[i].first_edge;
+            if (k != NIL)
+                do
+                {
+                    PUT1(A[ER[k].in_adjl].end_vertex+1);
+                    k = ER[k].next;
+                } while (k != k0);
+            PUT1(0);
+        }
+    }
+    else if (bytes == 2)
+    {
+        j = 0;
+        PUT1(0);
+        PUT2(n);
+        for (i = 0; i < n; ++i)
+        {
+            k = k0 = VR[i].first_edge;
+            if (k != NIL)
+                do
+                {
+                    PUT2(A[ER[k].in_adjl].end_vertex+1);
+                    k = ER[k].next;
+                } while (k != k0);
+            PUT2(0);
+        }
+    }
+    else
+    {
+        j = 0;
+        PUT1(0);
+        PUT2(0);
+        PUT4(n);
+        for (i = 0; i < n; ++i)
+        {
+            k = k0 = VR[i].first_edge;
+            if (k != NIL)
+                do
+                {
+                    PUT4(A[ER[k].in_adjl].end_vertex+1);
+                    k = ER[k].next;
+                } while (k != k0);
+            PUT4(0);
+        }
+    }
+
+    if (fwrite((void*)buff,1,len,f) != len)
+    {
+        fprintf(stderr,">E write_planarcode : error on writing\n");
+        ABORT(">E write_planarcode");
+    }
+}
+
+/*************************************************************************/
+
+static boolean
+isplanar(t_ver_sparse_rep *V, int n, t_adjl_sparse_rep *A, int e,
+         int *c, t_ver_sparse_rep **VR, t_adjl_sparse_rep **AR,
+         t_embed_sparse_rep  **ER, int *nbr_e_obs,
+         boolean planarcheck, boolean nonplanarcheck)
+/*
+  The input graph is given as an adjacency list:
+      V: array of vertices 
+      n: size of graph
+      A: adjacency list
+      e: number of edges
+      
+  If the graph is planar the embedding is stored  in VR and ER;
+  the embedding contains e edges (nbr_e_obs not used)
+      
+  If the graph is non planar the obstruction is returned in
+  VR and AR together with the number of edges in nbr_e_obs.
+
+  In all cases the number of components is return in c.
+
+  planarcheck and nonplanarcheck determine if checking is done.
+  The embedding and obstruction outputs are only made if the
+  appropriate checking is done.
+*/
+{
+    t_dlcl           **dfs_tree, **back_edges, **mult_edges;
+    int              edge_pos, v, w;
+    boolean          ans;
+    t_ver_edge       *embed_graph;
+ 
+    ans = sparseg_adjl_is_planar(V, n, A, c,
+                                 &dfs_tree, &back_edges, &mult_edges,
+                                 &embed_graph, &edge_pos, &v, &w);
+    
+    if (!ans && nonplanarcheck)
+    {
+        embedg_obstruction(V, A, dfs_tree, back_edges,
+                           embed_graph, n, &edge_pos,
+                           v, w, VR, AR, nbr_e_obs);
+    }
+    else if (planarcheck)
+    {
+        embedg_embedding(V, A, embed_graph, n, e, *c, edge_pos, mult_edges,
+                         VR, ER);
+    }
+    
+    sparseg_dlcl_delete(dfs_tree, n);
+    sparseg_dlcl_delete(back_edges, n);
+    sparseg_dlcl_delete(mult_edges, n);
+    embedg_VES_delete(embed_graph, n);
+ 
+    return ans;
+}
+
+/*************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    char *infilename,*outfilename;
+    FILE *infile,*outfile;
+    sparsegraph sg;
+    boolean badargs;
+    boolean verbose,nonplanar,quiet;
+    boolean planarcode,nowrite,nocheck;
+    int i,j,k,n,argnum,ne,loops;
+    int codetype,outcode;
+    t_ver_sparse_rep *VR;
+    t_adjl_sparse_rep *AR;
+    t_embed_sparse_rep *ER;
+    int nbr_c,nbr_e_obs;
+    nauty_counter nin,nout,nplan;
+    char *arg,sw;
+    double t0,tp,tnp,netotalp,netotalnp;
+    DYNALLSTAT(t_ver_sparse_rep,V,V_sz);
+    DYNALLSTAT(t_adjl_sparse_rep,A,A_sz);
+
+    HELP; PUTVERSION;
+
+    infilename = outfilename = NULL;
+    quiet = nowrite = planarcode = FALSE;
+    verbose = nonplanar = nocheck = FALSE;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('v',nonplanar)
+                else SWBOOLEAN('q',quiet)
+                else SWBOOLEAN('V',verbose)
+                else SWBOOLEAN('p',planarcode)
+                else SWBOOLEAN('u',nowrite)
+                else SWBOOLEAN('n',nocheck)
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        exit(1);
+    }
+
+    if (planarcode && nonplanar)
+    {
+        fprintf(stderr,">E planarg: -p and -v are incompatible\n");
+        exit(1);
+    }
+
+    if (!quiet)
+    {
+        fprintf(stderr,">A planarg");
+        if (nonplanar||planarcode||nowrite||nocheck)
+            fprintf(stderr," -");
+        if (nonplanar) fprintf(stderr,"v");
+        if (nowrite) fprintf(stderr,"u");
+        if (planarcode) fprintf(stderr,"p");
+        if (nocheck) fprintf(stderr,"n");
+        if (argnum > 0) fprintf(stderr," %s",infilename);
+        if (argnum > 1) fprintf(stderr," %s",outfilename);
+        fprintf(stderr,"\n");
+        fflush(stderr);
+    }
+
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,FALSE,1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    NODIGRAPHSYET(codetype);
+
+    if (!nowrite)
+    {
+        if (!outfilename || outfilename[0] == '-')
+        {
+            outfilename = "stdout";
+            outfile = stdout;
+        }
+        else if ((outfile = fopen(outfilename,"w")) == NULL)
+        {
+            fprintf(stderr,"Can't open output file %s\n",outfilename);
+            gt_abort(NULL);
+        }
+
+        if (planarcode)            outcode = PLANARCODE;
+        else if (codetype&SPARSE6) outcode = SPARSE6;
+        else                       outcode = GRAPH6;
+
+        if (outcode == PLANARCODE)
+            writeline(outfile,PLANARCODE_HEADER);
+        else if (codetype&HAS_HEADER)
+        {
+            if (outcode == SPARSE6) writeline(outfile,SPARSE6_HEADER);
+            else                    writeline(outfile,GRAPH6_HEADER);
+        }
+    }
+
+    nin = nout = nplan = 0;
+    netotalp = netotalnp = 0.0;
+    SG_INIT(sg);
+
+    tp = tnp = 0.0;
+    while (TRUE)
+    {
+        if (read_sg_loops(infile,&sg,&loops) == NULL) break;
+        n = sg.nv;
+        ne = (sg.nde+loops)/2;
+        ++nin;
+
+        DYNALLOC1(t_ver_sparse_rep,V,V_sz,n,"planarg");
+        DYNALLOC1(t_adjl_sparse_rep,A,A_sz,2*ne+1,"planarg");
+        k = 0;
+        for (i = 0; i < n; ++i)
+            if (sg.d[i] == 0)
+                V[i].first_edge = NIL;
+            else
+            {
+                V[i].first_edge = k;
+                for (j = sg.v[i]; j < sg.v[i]+sg.d[i]; ++j)
+                {
+                    A[k].end_vertex = sg.e[j];
+                    A[k].next = k+1;
+                    ++k;
+                    if (A[k-1].end_vertex == i)  /* loops go in twice */
+                    {
+                        A[k].end_vertex = i;
+                        A[k].next = k+1;
+                        k++;
+                    }
+                }
+                A[k-1].next = NIL;
+            }
+
+        if (k != 2*ne)
+        {
+            fprintf(stderr,
+               ">E planarg: decoding error; nin=" COUNTER_FMT "\n",nin);
+            fprintf(stderr,"n=%d nde=%lu ne=%d loops=%d\n",
+                    n,(unsigned long)sg.nde,ne,loops);
+            exit(1);
+        }
+
+        VR = NULL;
+        AR = NULL;
+        ER = NULL;
+        t0 = CPUTIME;
+        if (isplanar(V,n,A,ne,&nbr_c,&VR,&AR,&ER,&nbr_e_obs,
+                     !nocheck||planarcode,!nocheck))
+        {
+            ++nplan;
+            tp += CPUTIME - t0;
+            netotalp += ne;
+            if (!nowrite && !nonplanar)
+            {
+                if (planarcode)
+                    write_planarcode(outfile,VR,A,ER,n,ne);
+                else
+                    writelast(outfile);
+                ++nout;
+            }
+            if (verbose)
+                fprintf(stderr,"graph " COUNTER_FMT ": n=%d ne=%d planar\n",
+                        nin,n,ne);
+        }
+        else
+        {
+            tnp += CPUTIME - t0;
+            netotalnp += ne;
+            if (!nowrite && nonplanar)
+            {
+                writelast(outfile);
+                ++nout;
+            }
+            if (verbose)
+                fprintf(stderr,"graph " COUNTER_FMT ": n=%d ne=%d non-planar\n",
+                        nin,n,ne);
+        }
+        FREES(VR);
+        FREES(AR);
+        FREES(ER);
+    }
+
+
+    if (!nowrite)
+    {
+        if (!quiet)
+            fprintf(stderr,
+            ">Z  " COUNTER_FMT " graphs read from %s, "
+                  COUNTER_FMT " written to %s; %3.2f sec.\n",
+                nin,infilename,nout,outfilename,tp+tnp);
+    }
+    else
+    {
+        fprintf(stderr,
+                " " COUNTER_FMT " graphs input\n "
+                    COUNTER_FMT " graphs planar\n",nin,nplan);
+        fprintf(stderr," cpu = %3.2f sec. ",tp+tnp);
+        if (netotalp)
+            fprintf(stderr," planar:%.3f",1e5*tp/netotalp);
+        if (netotalnp)
+            fprintf(stderr," nonplanar:%.3f",1e5*tnp/netotalnp);
+        fprintf(stderr,"\n");
+    }
+
+    return 0;
+}
diff --git a/lib/nauty/planarity.c b/lib/nauty/planarity.c
new file mode 100644
index 0000000..39b27bc
--- /dev/null
+++ b/lib/nauty/planarity.c
@@ -0,0 +1,10386 @@
+/* planarity.c - code for planarity testing of undirected graphs.
+ * Method of Boyer and Myrvold, programmed by Paulette Lieby.
+ * The copyright of this program is owned by the Magma project.
+ * Distributed with nauty by permission.
+ ***************************************************************/
+ 
+/*
+ *  sparseg_adjl.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  Some high-level functions on the sparse graph as
+  an adjacency list.
+  In particular, testing if it is planar.
+  
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+#include "planarity.h"
+
+#define IF_DEB(x)    {}
+#define IF_VERB(x)   {}
+
+
+
+/* aproto: header embed_graph_protos.h */
+
+
+#ifndef PLANAR_IN_MAGMA
+#endif
+
+
+boolean 
+sparseg_adjl_plan_and_iso (t_ver_sparse_rep *V, int n, t_adjl_sparse_rep *A,
+	int e, int *c, t_ver_sparse_rep **VR, t_adjl_sparse_rep **AR,
+	t_embed_sparse_rep **ER, int *nbr_e_obs)
+    /*
+      the input graph is given as an adjacency list:
+      V: array of vertices 
+      n: size of graph
+      A: adjacency list
+      e: number of edges
+      
+      if the graph is planar the embedding is stored  in VR and ER;
+      the embedding contains e edges
+      (nbr_e_obs not used)
+      
+      if the graph is non planar the obstruction is returned in
+      VR and AR together with the number of edges in nbr_e_obs
+
+      in all cases is also returned the number of components (in c)
+    */
+{
+    t_dlcl           **dfs_tree, **back_edges, **mult_edges;
+    int              edge_pos, v, w;
+    boolean          ans;
+    t_ver_edge       *embed_graph;
+ 
+    ans = sparseg_adjl_is_planar(V, n, A, c,
+                                 &dfs_tree, &back_edges, &mult_edges,
+                                 &embed_graph, &edge_pos, &v, &w);
+    
+    if (!ans)
+    {
+        embedg_obstruction(V, A, dfs_tree, back_edges,
+                           embed_graph, n, &edge_pos,
+                           v, w, VR, AR, nbr_e_obs);
+    }
+    else
+    {
+        embedg_embedding(V, A, embed_graph, n, e, *c, edge_pos, mult_edges,
+                         VR, ER);
+    }
+    
+    sparseg_dlcl_delete(dfs_tree, n);
+    sparseg_dlcl_delete(back_edges, n);
+    sparseg_dlcl_delete(mult_edges, n);
+    embedg_VES_delete(embed_graph, n);
+ 
+    return ans;
+}
+
+
+
+int *
+sparseg_adjl_footprint (t_ver_sparse_rep *V, int n,
+	t_adjl_sparse_rep *A, int v)
+    /*
+      return v's footprint:
+      an array fp of size n where fp[i] = index of (directed)
+      edge [v, i] in A
+    */
+{
+    /*
+      note that we won't initialise the array:
+      its subsequent usage doesn't require it
+    */
+    int        *fp, e;
+
+    fp = (int *) mem_malloc(sizeof(int) * n);
+
+    if (V[v].first_edge == NIL)
+        /*
+          do nothing
+        */
+        return fp;
+
+    e = V[v].first_edge;
+    while (e != NIL)
+    {
+        fp[A[e].end_vertex] = e;
+        e = A[e].next;
+    }
+
+    return fp;
+}
+
+
+void 
+sparseg_adjl_print (t_ver_sparse_rep *V, int n,
+	t_adjl_sparse_rep *A, boolean user_level)
+{
+    int        v;
+
+    for (v = 0; v < n; v++)
+    {
+        int     next;
+
+        if (user_level)
+            fprintf(stdout, "%d:\t", v + 1);
+        else
+            fprintf(stdout, "%d:\t", v);
+        
+        next = V[v].first_edge;
+        while (next != NIL)
+        {
+            if (user_level)
+                fprintf(stdout, "%d ", A[next].end_vertex + 1);
+            else
+                fprintf(stdout, "%d ", A[next].end_vertex);
+            
+            next = A[next].next;
+        }
+        fprintf(stdout, "\n");
+    }
+}
+
+
+
+
+void 
+sparseg_adjl_embed_print (t_ver_sparse_rep *V_e, int n,
+	t_adjl_sparse_rep *A, t_embed_sparse_rep *E, boolean user_level)
+    /*
+      print the embedding given by E,
+      edges are referred to by their index in A
+
+      and V_e[v].first_edge is the index in E of the first edge
+      (in the embedding's order) incident from v
+
+      note that E is NOT indexed by the same vertices' array
+      that indexes A (at the creation of the sparse graph)
+    */
+{
+    int        v;
+
+    for (v = 0; v < n; v++)
+    {
+        int      start, next;
+
+        if (user_level)
+            fprintf(stdout, "%d:\t", v + 1);
+        else
+            fprintf(stdout, "%d:\t", v);
+
+        if (V_e[v].first_edge == NIL)
+        {
+            fprintf(stdout, "\n");
+            continue;
+        }
+        start = next = V_e[v].first_edge;
+
+        if (user_level)
+            fprintf(stdout, "%d ", A[ E[next].in_adjl ].end_vertex + 1);
+        else
+            fprintf(stdout, "%d ", A[ E[next].in_adjl ].end_vertex);
+
+        next = E[next].next;
+        
+        while (next != start)
+            /*
+              recall that in E edges are linked into a circular list
+            */
+        {
+            if (user_level)
+                fprintf(stdout, "%d ", A[ E[next].in_adjl ].end_vertex + 1);
+            else
+                fprintf(stdout, "%d ", A[ E[next].in_adjl ].end_vertex);
+
+            next = E[next].next;
+        }
+        fprintf(stdout, "\n");
+    }
+}
+
+graph *
+sparseg_adjl_to_nauty_graph (t_ver_sparse_rep *V, int n, t_adjl_sparse_rep *A)
+    /*
+      write the sparse graph as a nauty graph
+    */
+{
+    int          m, v, e, i;
+    graph        *g;
+ 
+    m = (n + WORDSIZE - 1) / WORDSIZE;
+    g = (graph *) mem_malloc(n * m * sizeof(graph));
+    for (i = (long) m * n; --i >= 0;)
+        g[i] = 0;
+ 
+    /*
+      we first copy V and A's information into g
+    */
+    for (v = 0; v < n; v++)
+    {
+        e = V[v].first_edge;
+        while (e != NIL)
+            /*
+              A[e].end_vertex is the next neighbour in the list,
+              A[e].next points to the next edge in the list
+            */
+        {
+            if (A[e].end_vertex != v)  /* no loops */
+            {
+                ADDELEMENT(GRAPHROW(g, v, m), A[e].end_vertex);
+            }
+            e = A[e].next;
+        }
+    }
+
+    return g;
+}
+
+
+
+#if 0
+t_edge_sparse_rep *
+sparseg_adjl_edges (t_ver_sparse_rep *V, int n,
+	t_adjl_sparse_rep *A, int e, boolean digraph)
+    /*
+      e is the number of edges
+    */
+{
+    t_edge_sparse_rep *edges;
+    int               m, u, v, pos_e;
+    graph             *g;
+
+    edges = (t_edge_sparse_rep *) mem_malloc(sizeof(t_edge_sparse_rep) * e);
+
+    m = (n + WORDSIZE - 1) / WORDSIZE;
+    g = sparseg_adjl_to_nauty_graph(V, n, A);
+
+    pos_e = 0;
+    for (u = 0; u < n; u++)
+    {
+        v = digraph == TRUE ? 0 : u + 1;
+        for (; v < n; v++)
+        {
+            if (ISELEMENT(GRAPHROW(g, u, m), v))
+            {
+                t_edge_sparse_rep edge;
+
+                edge.ends[0] = u;
+                edge.ends[1] = v;
+                edges[pos_e++] = edge;
+            }
+        }
+    }
+    ASSERT(pos_e == e);
+    mem_free(g);
+    
+    return edges;
+}
+#endif
+
+
+
+t_edge_sparse_rep *
+sparseg_adjl_edges (t_ver_sparse_rep *V, int n, t_adjl_sparse_rep *A,
+	int e, boolean digraph)
+    /*
+      e is the number of edges
+    */
+{
+#if 0
+    t_edge_sparse_rep   *edges;
+    int                 u, v, pos_e, *loops, *foot_print;
+    graph               *g;
+ 
+    loops = (int *) mem_malloc(sizeof(int) * n);
+    for (v = 0; v < n; v++)
+    {
+        loops[v] = 0;
+    }
+ 
+    edges = (t_edge_sparse_rep *) mem_malloc(sizeof(t_edge_sparse_rep) * e);
+    pos_e = 0;
+
+    foot_print = (int *) mem_malloc(sizeof(int) * n);
+    for (u = 0; u < n; u++)
+        foot_print[u] = NIL;
+    
+    for (v = 0; v < n; v++)
+    {
+        int               ne;
+        t_edge_sparse_rep edge;
+
+        ne = V[v].first_edge;
+        while (ne != NIL)
+        {
+            u = A[ne].end_vertex;
+            if (digraph
+                || (!digraph && u > v))
+            {
+                foot_print[u] = v;
+            }
+            else if (!digraph && u == v)
+            {
+                if (loops[v] == 0)
+                {
+                    foot_print[u] = v;
+                }
+ 
+                loops[v] ^= 1;
+            }
+
+            ne = A[ne].next;
+        }
+
+        for (u = 0; u < n; u++)
+            if (foot_print[u] == v)
+            {
+                edge.ends[0] = v;
+                edge.ends[1] = u;
+                edges[pos_e++] = edge;
+            }
+    }
+    ASSERT(pos_e == e);
+    mem_free(loops);
+    mem_free(foot_print);
+    
+    return edges;
+    
+#endif   
+    /*
+      there must be a simpler way
+    */
+#if 0
+    typedef struct edge_list {
+        int               size;
+        t_edge_sparse_rep *edges;
+    } t_edge_list;
+ 
+    t_edge_list         *edge_table;        
+    t_edge_sparse_rep   *edges;
+    int                 u, v, nbr_e, pos_e, *loops;
+    graph               *g;
+
+    loops = (int *) mem_malloc(sizeof(int) * n);
+    for (v = 0; v < n; v++)
+    {
+        loops[v] = 0;
+    }
+
+    /*
+      now create an edge table as follows:
+      - there are n lists in total
+      - their respective size is given by size
+      - their contents by *edges:
+
+      edge_table[i] will contain all the edges whose end-point is i:
+      these edges, by construction, will be sorted according to their
+      starting point
+
+      what for? to finish off each start-vertex processing
+      with a bucket sort so that
+      the edges are sorted wrt start- & end-point
+
+      bucket sort is linear, hence why...
+    */
+    edge_table = (t_edge_list *) mem_malloc(sizeof(t_edge_list) * n);
+    for (v = 0; v < n; v++)
+    {
+        edge_table[v].size = 0;
+        edge_table[v].edges = NP;
+    }
+
+    edges = (t_edge_sparse_rep *) mem_malloc(sizeof(t_edge_sparse_rep) * e);
+    
+    nbr_e = 0;
+    pos_e = 0;
+    for (v = 0; v < n; v++)
+    {
+        int    ne, w, u;
+
+        ne = V[v].first_edge;
+        while (ne != NIL)
+        {
+            u = A[ne].end_vertex;
+            if (digraph
+                || (!digraph && u > v))
+            {
+                t_edge_sparse_rep edge;
+ 
+                edge.ends[0] = v;
+                edge.ends[1] = u;
+
+                /*
+                  now stick this edge into the table: one may ponder
+                  as to the cost of constantly reallocating memory...
+                  some cursory tests in another context tell me that
+                  this is pretty much ok
+                  (and certainly better than allocating n^2 storage space)
+                */
+                if (edge_table[u].size == 0)
+                {
+                    edge_table[u].edges = (t_edge_sparse_rep *)
+                        mem_malloc(sizeof(t_edge_sparse_rep));
+                }
+                else
+                {
+                    edge_table[u].edges = (t_edge_sparse_rep *)
+                         mem_realloc(edge_table[u].edges,
+                                     sizeof(t_edge_sparse_rep)
+                                     * (edge_table[u].size + 1));
+                }
+
+                (edge_table[u].edges)[edge_table[u].size] = edge;
+                edge_table[u].size += 1;
+                nbr_e++;
+            }
+            else if (!digraph && u == v)
+            {
+                if (loops[v] == 0)
+                {
+                    t_edge_sparse_rep edge;
+ 
+                    edge.ends[0] = v;
+                    edge.ends[1] = u;
+
+                    if (edge_table[u].size == 0)
+                    {
+                        edge_table[u].edges = (t_edge_sparse_rep *)
+                            mem_malloc(sizeof(t_edge_sparse_rep));
+                    }
+                    else
+                    {
+                        edge_table[u].edges = (t_edge_sparse_rep *)
+                            mem_realloc(edge_table[u].edges,
+                                        sizeof(t_edge_sparse_rep)
+                                        * (edge_table[u].size + 1));
+                    }
+                    
+                    (edge_table[u].edges)[edge_table[u].size] = edge;
+                    edge_table[u].size += 1;
+                    nbr_e++;
+                }
+                
+                loops[v] ^= 1;
+            }
+            
+            ne = A[ne].next;
+        }
+
+        /*
+          bucket sort must take place here:
+          of course the whole lot is not exactly linear!
+          since we perform the sort n times; but we can hope for
+          a "good"  ?? average behaviour:
+
+          in any case this must be better that checking adjacencies
+          n^2 times in a sparse rep. (see edge_set_iset_assure)
+        */
+        for (w = 0; w < n; w++)
+        {
+            if (edge_table[w].size > 0)
+            {
+                for (u = 0; u < edge_table[w].size; u++)
+                {
+                    ASSERT((edge_table[w].edges)[u].ends[0] == v);
+                    edges[pos_e++] = (edge_table[w].edges)[u];
+                }
+                mem_free(edge_table[w].edges);
+                edge_table[w].size = 0;
+                edge_table[w].edges = NP;
+            }
+        }
+    }
+    ASSERT(nbr_e == e);
+    ASSERT(pos_e == e);
+    mem_free(loops);
+    mem_free(edge_table);
+    
+    return edges;
+#endif
+
+    t_edge_sparse_rep *edges;
+    int               v, pos_e, *loops;
+
+    edges = (t_edge_sparse_rep *) mem_malloc(sizeof(t_edge_sparse_rep) * e);
+    loops = (int *) mem_malloc(sizeof(int) * n);
+    for (v = 0; v < n; v++)
+    {
+        loops[v] = 0;
+    }
+    
+    pos_e = 0;
+    for (v = 0; v < n; v++)
+    {
+        int    ne;
+
+        ne = V[v].first_edge;
+        while (ne != NIL)
+        {
+            int      u;
+
+            u = A[ne].end_vertex;
+            if (digraph
+                || (!digraph && u > v))
+            {
+                t_edge_sparse_rep edge;
+ 
+                edge.ends[0] = v;
+                edge.ends[1] = u;
+                edges[pos_e++] = edge;
+            }
+            else if (!digraph && u == v)
+            {
+                if (loops[v] == 0)
+                {
+                    t_edge_sparse_rep edge;
+ 
+                    edge.ends[0] = v;
+                    edge.ends[1] = u;
+                    edges[pos_e++] = edge;
+                }
+
+                loops[v] ^= 1;
+            }
+            ne = A[ne].next;
+        }
+    }
+    ASSERT(pos_e == e);
+    mem_free(loops);
+    
+    return edges;
+
+}
+
+/*
+ *  sparseg_adjl_modify.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+ 
+  Some high-level functions on the sparse graph as
+  an adjacency list.
+  In particular, adding/removing vertices/edges.
+
+
+  NOTE: Most of the functions implicitely assume that the
+  graph is undirected;
+  this must be slightly rewritten for the general case
+  -- just haven't got the time right now...
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+#include "planarity.h"
+
+#define IF_DEB(x)    {}
+#define IF_VERB(x)   {}
+
+
+/* aproto: header embed_graph_protos.h */
+
+
+
+#ifndef PLANAR_IN_MAGMA
+#endif
+
+
+
+boolean 
+sparseg_adjl_add_edge (t_ver_sparse_rep *V, int n, t_adjl_sparse_rep **A,
+	int *size_A, int *pos, int u, int v, boolean CHECK)
+    /*
+      add the UNDIRECTED edge to the sparse graph (V, n, A)
+      - pos records where to add the next edge in A
+      - if pos + 1 == size_A, we must extend A
+
+      we check if the edge is already in the graph iff CHECK true
+
+      also we assume that the graph (V, n, A) is undirected
+    */
+{
+    boolean             edge_exists;
+
+    edge_exists = FALSE;
+    if (CHECK)
+    {
+        edge_exists = sparseg_adjl_dir_edge_exists(V, n, *A, u, v);
+
+        if (edge_exists)
+            return FALSE;
+    }
+    
+    if (*pos == *size_A)
+    {
+        IF_DEB(
+               fprintf(stdout, "realloc \n");
+               )
+
+        *size_A += 2;    /* add two directed edges */
+        *A = (t_adjl_sparse_rep *)
+            mem_realloc(*A, sizeof(t_adjl_sparse_rep) * *size_A);
+    }
+    else if (*pos + 1 == *size_A)
+    {
+        IF_DEB(
+               fprintf(stdout, "realloc \n");
+               )
+
+        *size_A += 1;    /* add two directed edges */
+        *A = (t_adjl_sparse_rep *)
+            mem_realloc(*A, sizeof(t_adjl_sparse_rep) * *size_A);
+    }
+    ASSERT(*pos + 1 < *size_A);
+    
+    sparseg_adjl_add_dir_edge(V, n, A, size_A, pos, u, v, FALSE);
+    sparseg_adjl_add_dir_edge(V, n, A, size_A, pos, v, u, FALSE);
+
+    return TRUE;
+}
+ 
+boolean 
+sparseg_adjl_add_edge_no_extend (t_ver_sparse_rep *V, int n,
+    t_adjl_sparse_rep *A, int size_A, int *pos, int u, int v, boolean CHECK)
+    /*
+      like sparseg_adjl_add_edge but here we are guaranteed
+      that pos + 1 < size_A
+      (unless that for some reason we attempt to add
+      an edge which is already there)
+      
+      this feature is required when A is part of a Magma block:
+      we do not want to reallocate A here
+      (would be done at a higher level)
+ 
+      we check if the edge is already in the graph iff CHECK true
+
+      also, we assume that we use this procedur only when dealing
+      with an undirected graph
+    */
+{
+    boolean   edge_added;
+   
+    edge_added =
+        sparseg_adjl_add_dir_edge_no_extend(V, n, A, size_A, pos, u, v,
+                                            CHECK);
+
+    if (edge_added)
+        sparseg_adjl_add_dir_edge_no_extend(V, n, A, size_A, pos, v, u,
+                                            FALSE);
+
+    return edge_added;
+}
+
+
+boolean 
+sparseg_adjl_add_dir_edge (t_ver_sparse_rep *V, int n,
+	t_adjl_sparse_rep **A, int *size_A, int *pos, int u, int v,
+	boolean CHECK)
+    /*
+      add the DIRECTED edge to the sparse graph (V, n, A)
+      - pos records where to add the next edge in A
+      - if pos >= size_A, we must extend A
+ 
+      we check if the edge is already in the graph iff CHECK true
+    */
+{
+    boolean             edge_exists;
+
+    edge_exists = FALSE;
+    if (CHECK)
+    {
+        edge_exists = sparseg_adjl_dir_edge_exists(V, n, *A, u, v);
+ 
+        if (edge_exists)
+            return FALSE;
+    }
+
+    if (*pos == *size_A)
+    {
+        *size_A += 1;    /* add one directed edge */
+        *A = (t_adjl_sparse_rep *)
+            mem_realloc(*A, sizeof(t_adjl_sparse_rep) * *size_A);
+    }
+    ASSERT(*pos < *size_A);
+
+    sparseg_adjl_add_dir_edge_no_extend(V, n, *A, *size_A, pos, u, v,
+                                        FALSE);
+
+    return TRUE;
+}
+ 
+boolean 
+sparseg_adjl_add_dir_edge_no_extend (t_ver_sparse_rep *V, int n,
+     t_adjl_sparse_rep *A, int size_A, int *pos, int u, int v, boolean CHECK)
+    /*
+      add an edge where A is guaranteed to be be big enough
+      (unless that for some reason we attempt to add
+      an edge which is already there)
+
+      this feature is required when A is part of a Magma block:
+      we do not want to reallocate A here
+      (would be done at a higher level)
+ 
+      we check if the edge is already in the graph iff CHECK true
+    */
+{
+    /*
+      given the way V and A represent the graph, it is simplest
+      to add the new edge at the beginning of i's adj. list
+    */
+    int                  i_v;
+    t_adjl_sparse_rep    a;
+
+    if (CHECK && sparseg_adjl_dir_edge_exists(V, n, A, u, v))
+        return FALSE;
+    
+    if (*pos >= size_A)
+        DIE();
+
+    /*
+      otherwise always add the edge
+    */
+    i_v = *pos;
+    a.end_vertex = v;
+    a.next = V[u].first_edge;
+    A[(*pos)++] = a;
+    V[u].first_edge = i_v;
+
+    return TRUE;
+}
+ 
+
+
+boolean 
+sparseg_adjl_remove_edge_no_red (t_ver_sparse_rep *V, t_adjl_sparse_rep *A,
+	int u, int v)
+    /*
+      remove the UNDIRECTED edge from sparse graph (V, A)
+      if (u, v) is not an edge then nothing changes (and return FALSE)
+
+      A will be left with "holes"
+    */
+{
+    sparseg_adjl_remove_dir_edge_no_red(V, A, u, v);
+    return sparseg_adjl_remove_dir_edge_no_red(V, A, v, u);
+}
+ 
+
+boolean 
+sparseg_adjl_remove_dir_edge_no_red (t_ver_sparse_rep *V,
+	t_adjl_sparse_rep *A, int u, int v)
+    /*
+      remove the DIRECTED edge from the sparse graph (V, n, A)
+      if (u, v) is not an edge then nothing changes  (and return FALSE)
+
+      A will be left with "holes"
+    */
+{
+    int         cur_e, prev_e;
+
+    cur_e = V[u].first_edge;
+    if (cur_e == NIL)
+        /*
+          (u, v) is not an edge
+        */
+        return FALSE;
+
+    if (A[cur_e].end_vertex == v)
+    {
+        V[u].first_edge = A[cur_e].next;
+        return TRUE;   /* done */
+    }
+
+    while (A[cur_e].end_vertex != v)
+        /*
+          if (u, v) is an edge then this loop will terminate
+        */
+    {
+        prev_e = cur_e;
+        cur_e = A[cur_e].next;
+        if (cur_e == NIL)
+            /*
+              (u, v) is not an edge
+            */
+            return FALSE;
+    }
+    ASSERT(A[cur_e].end_vertex == v);
+
+    A[prev_e].next = A[cur_e].next;
+    return TRUE;
+}
+ 
+int 
+sparseg_adjl_remove_all_dir_edge_no_red (t_ver_sparse_rep *V,
+	t_adjl_sparse_rep *A, int u, int v)
+    /*
+      remove all DIRECTED edges [u, v] from the non-simple
+      sparse graph (V, n, A)
+      if (u, v) is not an edge then nothing changes;
+      we return the number of edges removed
+
+      A will be left with "holes"
+    */
+{
+    int         cur_e, prev_e, e_removed;
+
+    if (V[u].first_edge == NIL)
+        /*
+          (u, v) is not an edge
+        */
+        return 0;
+
+    e_removed = 0;
+    while (A[V[u].first_edge].end_vertex == v)
+    {
+        V[u].first_edge = A[V[u].first_edge].next;
+        e_removed++;
+
+        if (V[u].first_edge == NIL)
+            return e_removed;
+    }
+    ASSERT(A[V[u].first_edge].end_vertex != v);
+    
+    prev_e = V[u].first_edge;
+    cur_e = A[prev_e].next;
+    while (cur_e != NIL)
+    {
+        if (A[cur_e].end_vertex == v)
+        {
+            A[prev_e].next = A[cur_e].next;
+            e_removed++;
+            cur_e = A[cur_e].next;
+        }
+        else
+        {
+            prev_e = cur_e;
+            cur_e = A[cur_e].next;
+        }
+    }
+
+    return e_removed;
+}
+ 
+
+
+void 
+sparseg_adjl_add_vertices (t_ver_sparse_rep **V, int n, int nmore)
+    /*
+      add nmore vertices
+      V is assumed to have length n 
+    */
+{
+    *V = (t_ver_sparse_rep *)
+        mem_realloc(*V, sizeof(t_ver_sparse_rep) * (n + nmore));
+
+    sparseg_adjl_add_vertices_no_extend(*V, n, nmore);
+}
+ 
+void 
+sparseg_adjl_add_vertices_no_extend (t_ver_sparse_rep *V, int n, int nmore)
+    /*
+      add nmore vertices,
+      here V is assumed to have length n + nmore (ie V has already
+      been made bigger)
+    */
+{
+    int                  v;
+
+    for (v = n; v < n + nmore; v++)
+    {
+        V[v].first_edge = NIL;
+    }
+}
+ 
+void 
+sparseg_adjl_remove_vertex (t_ver_sparse_rep **V, int n,
+	t_adjl_sparse_rep *A, int pos_A, int w, int *e)
+    /*
+      V is assumed to have length n: we will reallocate
+      V so that V will have length n-1
+
+      A is occupied from [0..pos-1], A will be left with holes
+
+      we also assume that the graph can have loops and multiple edges;
+      further, we the edge counting implicitely assumes that graph
+      is undirected!!!
+
+      this must be eventually fixed
+    */
+{
+    int                  v, nv, edge, loops;
+    t_ver_sparse_rep     *new_V;
+
+    /*
+      we first count the loops if any 
+    */
+    loops = 0;
+    edge = (*V)[w].first_edge;
+    while (edge != NIL)
+    {
+        loops = A[edge].end_vertex == w ? loops + 1 : loops;
+        edge = A[edge].next;
+    }
+    ASSERT(loops % 2 == 0);
+    loops /= 2;
+
+    /*
+      we recreate the vertices array
+    */
+    new_V = (t_ver_sparse_rep *)
+        mem_malloc(sizeof(t_ver_sparse_rep) * (n - 1));
+
+    for (v = 0, nv = 0; v < n; v++, nv++)
+    {
+        if (v == w)
+        {
+            nv--;
+        }
+        else
+        {
+            new_V[nv].first_edge = (*V)[v].first_edge;
+        }
+    }
+    mem_free(*V);
+    *V = new_V;
+
+    *e -= loops;
+    sparseg_adjl_remove_vertex_no_red(*V, n, A, w, e);
+    
+    /*
+      oops! not relabelling vertices can wreck havock!
+    */
+    sparseg_adjl_relabel_vertex(A, pos_A, w);
+}
+ 
+void 
+sparseg_adjl_remove_vertex_no_red (t_ver_sparse_rep *V, int n,
+	t_adjl_sparse_rep *A, int w, int *e)
+    /*
+      here V has already size n - 1 and has been initialised,
+      all what remains to do is to remove the edges incident
+      from w in A
+
+      A will be left with holes
+    */
+{
+    int                  v, nbr_e_removed;
+
+    nbr_e_removed = 0;
+    for (v = 0; v < n - 1; v++)
+    {
+        nbr_e_removed += sparseg_adjl_remove_all_dir_edge_no_red(V, A, v, w);
+    }
+
+    *e= *e - nbr_e_removed;
+}
+ 
+void 
+sparseg_adjl_relabel_vertex (t_adjl_sparse_rep *A, int pos, int u)
+    /*
+      relabel all vertices v > u as v-1
+      (required when removing a vertex)
+    */
+{
+    int                  i;
+
+    for (i = 0; i < pos; i++)
+    {
+        A[i].end_vertex = A[i].end_vertex > u ?
+            A[i].end_vertex - 1 : A[i].end_vertex;
+    }
+}
+ 
+/*
+ *  sparseg_adjl_pred.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+ 
+  Some high-level functions on the sparse graph as
+  an adjacency list: predicates.
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+#include "planarity.h"
+
+#define IF_DEB(x)    {}
+#define IF_VERB(x)   {}
+
+
+
+/* aproto: header embed_graph_protos.h */
+
+
+#ifndef PLANAR_IN_MAGMA
+#endif
+
+boolean 
+sparseg_adjl_dir_edge_exists (t_ver_sparse_rep *V, int n,
+	t_adjl_sparse_rep *A, int u, int v)
+    /*
+      does the directed edge [u, v] already exist in the graph
+    */
+{
+    int         cur_e, prev_e;
+
+    cur_e = V[u].first_edge;
+    if (cur_e == NIL)
+        return FALSE;
+
+    if (A[cur_e].end_vertex == v)
+    {
+        return TRUE; 
+    }
+
+    while (A[cur_e].end_vertex != v)
+    {
+        prev_e = cur_e;
+        cur_e = A[cur_e].next;
+        if (cur_e == NIL)
+            /*
+              (u, v) is not an edge
+            */
+            return FALSE;
+    }
+    ASSERT(A[cur_e].end_vertex == v);
+    return TRUE;
+}
+
+
+
+boolean 
+sparseg_adjl_u_adj_v (t_ver_sparse_rep *V, int n, t_adjl_sparse_rep *A,
+	int u, int v)
+    /*
+      is u adj. to v 
+    */
+{
+    return sparseg_adjl_dir_edge_exists(V, n, A, u, v);
+}
+
+
+boolean 
+sparseg_adjl_sub (t_ver_sparse_rep *V1, int n1, t_adjl_sparse_rep *A1,
+	t_ver_sparse_rep *V2, int n2, t_adjl_sparse_rep *A2)
+    /*
+      test if the (V1, n1, A1) sparse graph is a subgraph of
+      the (V2, n2, A2) graph
+    */
+{
+    int             v, *fp, n, bign, i;
+
+    n = n1 > n2 ? n2 : n1;
+    bign = n1 > n2 ? n1 : 0;
+    fp = (int *) mem_malloc(sizeof(int) * n);
+    for (i = 0; i < n; i++)
+        fp[i] = NIL;
+
+    for (v = 0; v < n; v++)
+    {
+        int      ne1, ne2;
+
+        ne1 = V1[v].first_edge;
+        ne2 = V2[v].first_edge;
+        if (ne1 == NIL)
+        {
+            continue;
+        }
+        else if (ne2 == NIL)
+        {
+            mem_free(fp);
+            return FALSE;
+        }
+        
+        while (ne2 != NIL)
+        {
+            int u2;
+
+            u2 = A2[ne2].end_vertex;
+            fp[u2] = v;
+            ne2 = A2[ne2].next;
+        }
+
+        while (ne1 != NIL)
+        {
+            int u1;
+
+            u1 = A1[ne1].end_vertex;
+            if (fp[u1] != v)
+            {
+                mem_free(fp);
+                return FALSE;
+            }
+            ne1 = A1[ne1].next;
+        }
+    }
+    mem_free(fp);
+
+    for (v = n; v < bign; v++)
+        /*
+          those vertices must not be end points of edges:
+          this chcek is only necessary in the digraph case
+        */
+    {
+        if (V1[v].first_edge != NIL)
+            return FALSE;
+    }
+    
+    return TRUE;
+}
+
+
+
+boolean 
+sparseg_adjl_eq (t_ver_sparse_rep *V1, int n1, t_adjl_sparse_rep *A1,
+	t_ver_sparse_rep *V2, int n2, t_adjl_sparse_rep *A2)
+    /*
+      compare the two sparse graphs (V1, n1, A1) & (V2, n2, A2)
+      we don't know their number of edges
+    */
+{
+    if (n1 != n2)
+        return FALSE;
+
+    return sparseg_adjl_sub(V1, n1, A1, V2, n2, A2)
+        && sparseg_adjl_sub(V2, n2, A2, V1, n1, A1);
+}
+
+
+
+/*
+ *  sparseg_dlcl_misc.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+ 
+  Housekeeping for an internal sparse graph representation
+  internal to the planarity tester and obstruction isolator.
+
+  This sparse graph consists of an array of doubly linked circular lists
+  (the neighbour lists for each vertex).
+ 
+ 
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+ 
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+ 
+  Started October 2001
+*/
+
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_VERB(x)   {}
+ 
+ 
+/* aproto: header embed_graph_protos.h */
+
+/* aproto: beginstatic -- don't touch this!! */
+static boolean sparseg_dlcl_is_present (t_dlcl *, int, t_dlcl **);
+/* aproto: endstatic -- don't touch this!! */
+ 
+ 
+#ifndef PLANAR_IN_MAGMA
+#endif
+ 
+
+void 
+sparseg_dlcl_delete (t_dlcl **g, int n)
+{
+    int      i;
+
+    for (i = 0; i < n; i++)
+    {
+       embedg_dlcl_delete(g[i]);
+    }
+    mem_free(g);
+}
+
+void 
+sparseg_dlcl_print (t_dlcl **g, int n)
+{
+    int      i;
+
+    for (i = 0; i < n; i++)
+    {
+        fprintf(stdout,"%d:\t", i);
+        embedg_dlcl_print(g[i]);
+    }
+}
+
+
+static boolean 
+sparseg_dlcl_is_present (t_dlcl *l, int label, t_dlcl **p)
+{
+    *p = embedg_dlcl_find(l, label);
+    return *p == NP ? FALSE : TRUE;
+}
+
+
+boolean 
+sparseg_dlcl_is_adjacent (t_dlcl **g, int n, int v, int u, t_dlcl **p)
+    /*
+      is u adjacent to v
+    */
+{
+    ASSERT(v >= 0 && v < n && u >= 0 && u < n);
+    return sparseg_dlcl_is_present(g[v], u, p);
+}
+
+void 
+sparseg_dlcl_append_to_neigh_list (t_dlcl **g, int n, int v, int u, int in_adjl)
+    /*
+      append u to the neighbour list of v
+    */
+{
+    t_dlcl   *u_rec;
+ 
+    u_rec = embedg_dlcl_rec_new(u);
+    u_rec->in_adjl = in_adjl;
+    g[v] = embedg_dlcl_rec_append(g[v], u_rec);
+}
+
+
+
+
+void 
+sparseg_dlcl_to_sparseg (t_dlcl **g, int n, int e,
+	t_ver_sparse_rep **V, t_adjl_sparse_rep **A)
+    /*
+      e is the number of undirected edges of g
+
+      convert a dlcl into the standard sparseg rep. as an
+      adjacency list
+    */
+{
+    int                 i_e, v;
+
+    *V = (t_ver_sparse_rep *) mem_malloc(sizeof(t_ver_sparse_rep) * n);
+    *A = (t_adjl_sparse_rep *) mem_malloc(sizeof(t_adjl_sparse_rep) * 2 * e);
+ 
+    for (v = 0; v < n; v++)
+        (*V)[v].first_edge = NIL;
+    
+    i_e = 0;
+    for (v = 0; v < n; v++)
+    {
+        t_dlcl     *l, *p;
+
+        l = p = g[v];
+        if (!embedg_dlcl_is_empty(p))
+        {
+            t_adjl_sparse_rep   a;
+            
+            ASSERT((*V)[v].first_edge == NIL);
+            (*V)[v].first_edge = i_e;
+            a.end_vertex = p->info;
+            a.next = i_e + 1;
+            (*A)[i_e++] = a;
+            
+            p = embedg_dlcl_list_next(p);
+            while (p != l)
+            {
+                a.end_vertex = p->info;
+                a.next = i_e + 1;
+                (*A)[i_e++] = a;
+
+                p = embedg_dlcl_list_next(p);
+            }
+
+            /*
+              end of list for v
+            */
+            (*A)[i_e - 1].next = NIL;
+        }
+    }
+    ASSERT(i_e == 2 * e);
+}
+
+boolean 
+sparseg_dlcl_sub (t_dlcl **g1, int n1, t_dlcl **g2, int n2)
+    /*
+      is g2 a subgraph of g1
+
+      I request that both graphs have same order
+
+      This is not used anywhere... do we need it???
+    */
+{
+    int           n, v, *fp;
+
+    if (n1 != n2)
+        return FALSE;
+
+    n = n1;
+    fp = (int *) mem_malloc(sizeof(int) * n);
+    for (v = 0; v < n; v++)
+        fp[v] = NIL;
+
+    for (v = 0; v < n; v++)
+    {
+         t_dlcl     *l1, *p1, *l2, *p2;
+ 
+        l1 = p1 = g1[v];
+        l2 = p2 = g2[v];
+        if (embedg_dlcl_is_empty(p1) && !embedg_dlcl_is_empty(p2))
+        {
+            mem_free(fp);
+            return FALSE;
+        }
+        if (embedg_dlcl_is_empty(p2))
+        {
+            continue;
+        }
+        
+        fp[p1->info] = v;
+        p1 = embedg_dlcl_list_next(p1);
+        while (p1 != l1)
+        {
+            fp[p1->info] = v;
+            p1 = embedg_dlcl_list_next(p1);
+        }
+
+        if (fp[p2->info] != v)
+        {
+            mem_free(fp);
+            return FALSE;
+        }
+        p2 = embedg_dlcl_list_next(p2);
+        while (p2 != l2)
+        {
+            if (fp[p2->info] != v)
+            {
+                mem_free(fp);
+                return FALSE;
+            }
+        }
+    }
+    mem_free(fp);
+    
+    return TRUE;
+}
+/*
+ *  VES_misc.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  All low-level routines for the VES structure:
+
+  - the VES structure is solely used within the planarity tester
+    and obstruction isolator
+
+  - it stores vertices, virtual vertices and edges
+       --more on this later--
+
+  - it allows for circular doubly linked lists, hence
+    enabling us -among other things- to store the
+    graph embedding if the tester is successful
+
+  - basic features:
+    + the VES has exactly size 2n + 2(3n-5) :
+      we add at most one more edge than the max for a planar graph
+      (need to x by 2: we store directed edges)
+    + a vertex and the edges incident FROM it are linked in a doubly
+      linked circular list
+    + where a vertex is inserted between two of its outcoming edges
+      determines an external face walk for a bicomponent
+    + the twin edge is more commonly known as the inverse edge
+    + we have tree and back edges (from the DFS), and short-cut edges
+      which are added by the tester
+      -but short-cut edges are added in such a way as to maintain
+       planarity (in a local sense)
+    + vertices and edges can be marked (visited for example)
+    + they have an orientation which must be eventuall recovered
+      and which is set in the merge_bicomp routine
+    + vertices are essentially known via their DFI or DFS index
+      (though their label is stored too)
+
+     blah, blah.... later then.
+     Have a look at embedg_planar_alg_init which initialises the VES
+     structure
+
+     
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+ 
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_DEB_SCE(x)    {}
+#define IF_DEB_PROPER_FACE(x) {}
+#define IF_VERB(x)   {}
+ 
+ 
+/* aproto: header embed_graph_protos.h */
+
+boolean 
+embedg_VES_is_vertex (int n, int i)
+    /*
+      is this a vertex
+      (relative to the "big" array of size 2n + 2(3n-5))
+    */
+{
+    return i < n ? TRUE : FALSE;
+}
+
+boolean 
+embedg_VES_is_virtual_vertex (int n, int i)
+    /*
+      is this a virtual vertex
+      (relative to the "big" array of size 2n + 2(3n-5))
+
+      a virtual vertex is a vertex v^c which denotes the
+      DFS parent of the child c
+
+      see embedg_planar_alg_init for more
+    */
+{
+    return i >= n && i < 2*n ? TRUE : FALSE;
+}
+
+boolean 
+embedg_VES_is_edge (int n, int i)
+    /*
+      is this an edge
+      (relative to the "big" array of size 2n + 2(3n-5))
+    */
+{
+    return i >= 2*n ? TRUE : FALSE;
+}
+
+boolean 
+embedg_VES_is_tree_edge (t_ver_edge *embed_graph, int n, int i)
+    /*
+      is this s tree edge
+    */
+{
+    return embedg_VES_is_edge(n, i)
+        && embed_graph[i].type == TE;
+}
+
+boolean 
+embedg_VES_is_back_edge (t_ver_edge *embed_graph, int n, int i)
+    /*
+      is this a back edge
+    */
+{
+    return embedg_VES_is_edge(n, i)
+        && embed_graph[i].type == BE;
+}
+
+boolean 
+embedg_VES_is_short_cut_edge (t_ver_edge *embed_graph, int n, int i)
+    /*
+      as the name indicates...
+    */
+{
+    return embedg_VES_is_edge(n, i)
+        && embed_graph[i].type == SCE;
+}
+
+void 
+embedg_VES_print_vertex (int n, int v)
+{
+    ASSERT(embedg_VES_is_vertex(n, v));
+    fprintf(stdout, "%d  ", v);
+}
+
+void 
+embedg_VES_print_virtual_vertex (t_ver_edge *embed_graph, int n, int v)
+{
+    int          c;
+    
+    ASSERT(embedg_VES_is_virtual_vertex(n, v));
+    c = v - n;
+    fprintf(stdout, "%d^%d  ", embed_graph[c].DFS_parent, c);
+}
+
+void 
+embedg_VES_print_any_vertex (t_ver_edge *embed_graph, int n, int v)
+{
+    if (embedg_VES_is_vertex(n, v))
+    {
+        embedg_VES_print_vertex(n, v);
+    }
+    else
+    {
+        embedg_VES_print_virtual_vertex(embed_graph, n, v);
+    }
+}
+
+void 
+embedg_VES_print_any_rec (t_ver_edge *embed_graph, int n, int r)
+{
+    if (embedg_VES_is_edge(n, r))
+    {
+        embedg_VES_print_edge(embed_graph, n, r);
+    }
+    else
+    {
+        embedg_VES_print_any_vertex(embed_graph, n, r);
+    }
+}
+
+void 
+embedg_VES_print_edge (t_ver_edge *embed_graph, int n, int e)
+{
+    int          v, prev, cur;
+    
+    ASSERT(embedg_VES_is_edge(n, e));
+
+    /*
+      must find the vertex in the doubly linked circular list
+      of vertices/edges
+    */
+
+    prev = e;
+    cur = v = embed_graph[e].link[0];
+    if (embedg_VES_is_vertex(n, v)
+        || embedg_VES_is_virtual_vertex(n, v))
+    {
+        embedg_VES_print_any_vertex(embed_graph, n, v);
+        fprintf(stdout, ", ");
+        embedg_VES_print_any_vertex(embed_graph, n,
+                                         embed_graph[e].neighbour);
+        fprintf(stdout, "):0\n");
+    }
+    else while (!embedg_VES_is_vertex(n, v)
+                && !embedg_VES_is_virtual_vertex(n, v))
+    {
+        v = embedg_VES_get_next_in_dlcl(embed_graph, n,
+                                                   cur, prev);
+
+        if (embedg_VES_is_vertex(n, v)
+            || embedg_VES_is_virtual_vertex(n, v))
+        {
+            embedg_VES_print_any_vertex(embed_graph, n, v);
+            fprintf(stdout, ", ");
+            embedg_VES_print_any_vertex(embed_graph, n,
+                                             embed_graph[e].neighbour);
+            fprintf(stdout, "):0\n");
+        }
+        else
+        {
+            prev = cur;
+            cur = v;
+        }
+    }
+}
+
+void 
+embedg_VES_print_flipped_edges (t_ver_edge *embed_graph, int n, int edge_pos)
+    /*
+      print those edges in the structure whose sign is CLOCKW,
+      ie which have been flipped at some stage
+    */
+{
+    int          e;
+    
+    for (e = 2*n; e <= edge_pos; e++)
+    {
+        if (!embedg_VES_is_short_cut_edge(embed_graph, n, e))
+            /*
+              we don't care about the short-cut edges
+            */
+        {
+            if (embed_graph[e].sign != CCLOCKW)
+            {
+                embedg_VES_print_edge(embed_graph, n, e);
+            }
+        }
+    }
+}
+
+#if 0
+int 
+embedg_VES_get_edge_from_ver (t_ver_edge *embed_graph, int n, int v)
+    /*
+      not used anywhere; why is this here???
+    */
+{
+    int          in, e;
+
+    ASSERT(embedg_VES_is_vertex(n, v)
+           || embedg_VES_is_virtual_vertex(n, v));
+    
+    in = embedg_VES_is_edge(n, embed_graph[v].link[0]) ? 0 : 1;
+    e = embed_graph[v].link[in];
+    ASSERT(embedg_VES_is_edge(n, e));
+
+    return e;
+}
+
+int 
+embedg_VES_get_ver_from_edge (t_ver_edge *embed_graph, int n, int e)
+{
+    int          in, v;
+
+    ASSERT(embedg_VES_is_edge(n, e));
+
+    in = embedg_VES_is_vertex(n, embed_graph[e].link[0])    
+        || embedg_VES_is_virtual_vertex(n, embed_graph[e].link[0])
+        ?
+        0 : 1;
+
+    v = embed_graph[e].link[in];
+    ASSERT(embedg_VES_is_vertex(n, v)
+           || embedg_VES_is_virtual_vertex(n, v));
+
+    return v;
+}
+#endif
+
+int 
+embedg_VES_get_twin_edge (t_ver_edge *embed_graph, int n, int e)
+    /*
+      the twin edge is understood as being the inverse edge
+    */
+{
+    int          twin;
+
+    ASSERT(embedg_VES_is_edge(n, e));
+
+    twin = e % 2 == 0 ? e + 1 : e - 1;
+    ASSERT(embedg_VES_is_edge(n, twin));
+
+    return twin;
+}
+
+int 
+embedg_VES_get_ver_from_virtual (t_ver_edge *embed_graph, int n, int vv)
+    /*
+      get v from the virtual vertex v^c
+    */
+{
+    int          v;
+
+    ASSERT(embedg_VES_is_virtual_vertex(n, vv));
+    v = embed_graph[vv - n].DFS_parent;
+
+    return v;
+}
+
+int 
+embedg_VES_get_ver (t_ver_edge *embed_graph, int n, int v)
+{
+    if (embedg_VES_is_virtual_vertex(n, v))
+        return embedg_VES_get_ver_from_virtual(embed_graph, n, v);
+
+    return v;
+}
+    
+
+int 
+embedg_VES_get_next_in_dlcl (t_ver_edge *embed_graph, int n, int r, int prev)
+    /*
+      r is a (virtual) vertex or edge record in embed_graph:
+      get the next in the list (formed by the .link[] fields)
+      in the doubly linked circular list
+
+      so that prev != next
+      -- NOTE: a priori these lists always contain 2 elts at least
+      so that there shouldn't be any problem...
+      --> huh? is that true?
+    */
+{
+    return embed_graph[r].link[0] == prev ?
+        embed_graph[r].link[1] : embed_graph[r].link[0];
+}
+
+
+void 
+embedg_VES_walk_bicomp (t_ver_edge *embed_graph, int n, int v, int vin)
+    /*
+      walk the external face of the bicomp starting
+      at VIRTUAL vertex v entered via vin
+
+      this of course assumes that the "thing" rooted at
+      v is a bicomponent -- depending where we are at in the
+      tester this is not necessarily the case
+      -- I comment upon this in merge_bicomps.c:
+               embedg_VES_merge_pertinent_bicomps
+    */
+{
+    int        start, startin, s, sin;
+
+    ASSERT(embedg_VES_is_virtual_vertex(n, v));
+
+    embedg_VES_print_virtual_vertex(embed_graph, n, v);
+
+    s = NIL;
+    start = v;
+    startin = vin;
+    while (s != v)
+    {
+        embedg_VES_get_succ_on_ext_face(embed_graph, n, start, startin,
+                                             FALSE, 0, &s, &sin);
+        if (embedg_VES_is_virtual_vertex(n, s))
+        {
+            embedg_VES_print_virtual_vertex(embed_graph, n, s);
+        }
+        else
+        {
+            embedg_VES_print_vertex(n, s);
+        }
+        start = s;
+        startin = sin;
+    }
+    fprintf(stdout, "\n");
+}
+
+void 
+embedg_VES_print_adj_list (t_ver_edge *embed_graph, int n, int r,
+	boolean consistent)
+    /*
+      print r's adjacency list - r can be a vertex or edge
+
+      the boolean <consistent> if true assumes that
+      the list is consistent (will determine the way we traverse the list)
+
+      a priori we should get the same result either way
+    */
+{
+    if (consistent)
+    {
+        int        next;
+
+        embedg_VES_print_any_rec(embed_graph, n, r);
+        
+        next = embed_graph[r].link[0];
+        while (next != r)
+        {
+            embedg_VES_print_any_rec(embed_graph, n, next);
+            next = embed_graph[next].link[0];
+        }
+    }
+    else
+    {
+        int          prev, cur, next;
+        
+        embedg_VES_print_any_rec(embed_graph, n, r);
+        
+        prev = r;
+        cur = embed_graph[r].link[0];
+        
+        while (cur != r)
+        {
+            embedg_VES_print_any_rec(embed_graph, n, cur);
+            next = embedg_VES_get_next_in_dlcl(embed_graph, n,
+                                                          cur, prev);
+            prev = cur;
+            cur = next;
+        }
+    }
+}
+
+boolean 
+embedg_VES_is_adj_list_consistent (t_ver_edge *embed_graph, int n, int r)
+    /*
+      checks that r's adjacency list is consistent:
+      ie, that either traversing it using link[0] always
+      or traversing it using embedg_VES_get_next_in_dlcl
+      gives the SAME result
+    */
+{
+    int          *list_link, *list_n_dldl, il, id, i;
+
+    list_link = (int *) mem_malloc(sizeof(int) * 2 * n);
+    list_n_dldl = (int *) mem_malloc(sizeof(int) * 2 * n);
+    /*
+      must allocate 2*n space: I could have TE and SCE with same neighbour
+      (or BE and SCE as well)
+    */
+    il = id = -1;
+
+    /*
+      traversing the list via link[0]
+    */
+    {
+        int        next;
+
+        list_link[++il] = r;
+        
+        next = embed_graph[r].link[0];
+        while (next != r)
+        {
+            list_link[++il] = next;
+            next = embed_graph[next].link[0];
+        }
+    }
+
+    /*
+       traversing the list using embedg_VES_get_next_in_dlcl
+    */
+    {
+        int          prev, cur, next;
+        
+        list_n_dldl[++id] = r;
+        prev = r;
+        cur = embed_graph[r].link[0];
+        
+        while (cur != r)
+        {
+            list_n_dldl[++id] = cur;
+            next = embedg_VES_get_next_in_dlcl(embed_graph, n,
+                                                          cur, prev);
+            prev = cur;
+            cur = next;
+        }
+    }
+
+    if (il != id)
+    {
+        mem_free(list_link);
+        mem_free(list_n_dldl);
+        return FALSE;
+    }
+
+    for (i = 0; i <= il; i++)
+    {
+        if (list_link[i] != list_n_dldl[i])
+        {
+            mem_free(list_link);
+            mem_free(list_n_dldl);
+            return FALSE;
+        }
+    }
+
+    mem_free(list_link);
+    mem_free(list_n_dldl);
+    return TRUE;
+}
+
+
+boolean 
+embedg_VES_are_adj_lists_consistent (t_ver_edge *embed_graph, int n)
+    /*
+      checks that the adjacency list of each vertex is consistent
+      in the manner of embedg_VES_is_adj_list_consistent
+    */
+{
+    int          i;
+
+    /*
+      it is enough to visit the vertices and virtual vertices only
+      (I don't think it is enough to do the vertices only --??)
+    */
+    for (i = 0; i < 2*n; i++)
+        if (!embedg_VES_is_adj_list_consistent(embed_graph, n, i))
+            return FALSE;
+
+    return TRUE;
+}
+
+
+
+void 
+embedg_VES_remove_edge (t_ver_edge *embed_graph, int n, int e)
+    /*
+      remove edge e from the embedding
+    */
+{
+    int          r1, r2, r1out, r2in, twin;
+
+    ASSERT(embedg_VES_is_edge(n, e));
+
+    IF_DEB_SCE(
+               fprintf(stdout, "removing an SCE, enter\n");
+               embedg_VES_print_edge(embed_graph, n, e);
+               )
+    
+    r1 = embed_graph[e].link[0];
+    r2 = embed_graph[e].link[1];
+
+    /*
+      disable e and link r1 and r2 together:
+      we had r1 -> e -> r2
+    */
+    embed_graph[e].link[0] = embed_graph[e].link[1] = e;
+    
+    r1out = embed_graph[r1].link[0] == e ? 0 : 1;
+    r2in = embed_graph[r2].link[0] == e ? 0 : 1;
+
+    if (r1 == r2)
+        /*
+          this I think should never happen, but one never knows...
+        */
+    {
+        embed_graph[r1].link[0] = embed_graph[r1].link[1] = r1;
+    }
+    else
+    {
+        embed_graph[r1].link[r1out] = r2;
+        embed_graph[r2].link[r2in] = r1;
+    }
+
+    ASSERT(embedg_VES_is_adj_list_consistent(embed_graph, n, r1));
+
+    /*
+      now we must do a similar thing for the twin
+      (which must get reomved as well)
+    */
+    twin = embedg_VES_get_twin_edge(embed_graph, n, e);
+
+    IF_DEB_SCE(
+               fprintf(stdout, "removing an SCE, the twin\n");
+               embedg_VES_print_edge(embed_graph, n, twin);
+               )
+    
+    r1 = embed_graph[twin].link[0];
+    r2 = embed_graph[twin].link[1];
+
+    embed_graph[twin].link[0] = embed_graph[twin].link[1] = twin;
+
+    r1out = embed_graph[r1].link[0] == twin ? 0 : 1;
+    r2in = embed_graph[r2].link[0] == twin ? 0 : 1;
+
+    if (r1 == r2)
+    {
+        embed_graph[r1].link[0] = embed_graph[r1].link[1] = r1;
+    }
+    else
+    {
+        embed_graph[r1].link[r1out] = r2;
+        embed_graph[r2].link[r2in] = r1;
+    }
+
+    ASSERT(embedg_VES_is_adj_list_consistent(embed_graph, n, r1));
+}
+
+
+void 
+embedg_VES_set_orientation (t_ver_edge *embed_graph, int n, int *ver_orient)
+    /*
+      using the vertices' orientation as given in ver_orient
+      we set the orientation for each edge in the adjacency list
+      for each vertex
+
+      to do this we use the field sign which is NOT needed
+      anymore by the tester since by the time we call this
+      function we would have finished with that bit (the tester)
+
+      sign is only set when merging bicomps
+      - even though we'll perform another walkdown when
+      recovering an obstruction (if any) no bicomp merging will occur,
+      so we are safe
+    */
+{
+    int          v;
+
+    for (v = 0; v < n; v++)
+    {
+        int      o, e;
+
+        o = ver_orient[v];
+        embed_graph[v].sign = o;
+
+        e = embed_graph[v].link[0];
+
+        while (e != v)
+            /*
+              just as a note: note the way I get the next in the list
+              here (as opposed to using
+              embedg_VES_get_next_in_dlcl):
+              this is because I implicitely assume that
+              the adjacency lists are consistent
+              
+              Also note that edges can be SCE, it doesn't really matter
+              anyway (they may not have been removed yet
+              -- see the way we recover the obstruction:
+              embedg_mark_obstruction)
+            */
+        {
+            embed_graph[e].sign = o;
+            e = embed_graph[e].link[0];
+        }       
+    }
+}
+
+
+/*
+ *  dlcl_misc.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  Housekeeping for a simple doubly linked circular list:
+  this is a data structure ONLY used WITHIN
+  the planarity tester and obstruction isolator and is not to be
+  confused with the VES structure mentionned elsewhere.
+
+  The VES structure is an array, while the dlcl one is a list of
+  pointers.
+
+  The  dlcl is especially useful as it allows for the storage
+  of an ordered list.
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+
+#include "planarity.h"
+
+#define IF_DEB(x)    {}
+#define IF_VERB(x)   {}
+
+
+/* aproto: header embed_graph_protos.h */
+
+/* aproto: beginstatic -- don't touch this!! */
+static void embedg_dlcl_rec_free (t_dlcl *);
+static void embedg_dlcl_rec_insert_right (t_dlcl *, t_dlcl *);
+static void embedg_dlcl_rec_insert_left (t_dlcl *, t_dlcl *);
+static void embedg_dlcl_rec_retrieve (t_dlcl *);
+static void embedg_dlcl_rec_delete (t_dlcl *);
+static boolean embedg_dlcl_is_singleton (t_dlcl *);
+/* aproto: endstatic -- don't touch this!! */
+
+
+#ifndef PLANAR_IN_MAGMA
+#endif
+
+
+t_dlcl *
+embedg_dlcl_rec_new (int info)
+    /*
+      create a new record with info <info> in the global array
+      to insert in the list
+    */
+{
+    t_dlcl    *r;
+ 
+    r = (t_dlcl *) mem_malloc(sizeof(t_dlcl));
+    r->info = info;
+    r->in_adjl = r->twin_in_adjl = NIL;
+    r->mult = 1;
+    r->right = r;
+    r->left = r;
+    return r;
+}
+
+static void 
+embedg_dlcl_rec_free (t_dlcl *r)
+    /*
+      free
+    */
+{
+    mem_free(r);
+}
+
+void 
+embedg_dlcl_rec_print (t_dlcl *r)
+{
+    fprintf(stdout,"%d ", r->info);
+}
+
+void 
+embedg_dlcl_print (t_dlcl *l)
+{
+    t_dlcl    *p = l;
+    
+    if (!embedg_dlcl_is_empty(p))
+    {
+        embedg_dlcl_rec_print(p);
+        p = embedg_dlcl_list_next(p);
+        while (p != l)
+        {
+            embedg_dlcl_rec_print(p);
+            p = embedg_dlcl_list_next(p);
+        }
+    }
+    fprintf(stdout,"\n");
+}
+
+
+static void 
+embedg_dlcl_rec_insert_right (t_dlcl *l, t_dlcl *r)
+{
+    t_dlcl    *tmp_r, *tmp_l;
+
+    tmp_r = l->right;
+    tmp_l = tmp_r->left;
+
+    l->right = r;
+    r->right = tmp_r;
+
+    r->left = tmp_l;
+    tmp_r->left = r;
+}
+
+
+static void 
+embedg_dlcl_rec_insert_left (t_dlcl *l, t_dlcl *r)
+{
+    t_dlcl    *tmp_r, *tmp_l;
+
+    tmp_l = l->left;
+    tmp_r = tmp_l->right;
+
+    l->left = r;
+    r->left = tmp_l;
+
+    r->right = tmp_r;
+    tmp_l->right = r;
+}
+
+t_dlcl *
+embedg_dlcl_rec_append (t_dlcl *l, t_dlcl *r)
+{
+    if (embedg_dlcl_is_empty(l))
+        return r;
+    
+    embedg_dlcl_rec_insert_left(l, r);
+    return l;
+}
+
+t_dlcl *
+embedg_dlcl_rec_prepend (t_dlcl *l, t_dlcl *r)
+{
+    if (embedg_dlcl_is_empty(l))
+        return r;
+
+    embedg_dlcl_rec_insert_left(l, r);
+    return r;
+}
+
+t_dlcl *
+embedg_dlcl_cat (t_dlcl *l, t_dlcl *m)
+    /*
+      concatenate m to the RIGHT of the end of l
+      WITHOUT copying m 
+    */
+{
+    t_dlcl    *h1, *h2, *e1, *e2;
+
+    if (embedg_dlcl_is_empty(l))
+        return m;
+    if (embedg_dlcl_is_empty(m))
+        return l;
+    
+    h1 = l;
+    e1 = l->left;
+    h2 = m;
+    e2 = m->left;
+
+    e1->right = h2;
+    h2->left = e1;
+    e2->right = h1;
+    h1->left = e2;
+
+    return l;
+}
+
+t_dlcl *
+embedg_dlcl_find (t_dlcl *l, int info)
+{
+    t_dlcl    *p = l;
+    
+    if (!embedg_dlcl_is_empty(p))
+    {
+        if (p->info == info)
+        {
+            return p;
+        }
+        p = embedg_dlcl_list_next(p);
+        while (p != l)
+        {
+            if (p->info == info)
+            {
+                return p;
+            }
+            p = embedg_dlcl_list_next(p);
+        }
+    }
+    return NP;
+}
+
+t_dlcl *
+embedg_dlcl_find_with_NIL_twin_in_adjl (t_dlcl *l, int info)
+{
+    t_dlcl    *p = l;
+    
+    if (!embedg_dlcl_is_empty(p))
+    {
+        if (p->info == info && p->twin_in_adjl == NIL)
+        {
+            return p;
+        }
+        p = embedg_dlcl_list_next(p);
+        while (p != l)
+        {
+            if (p->info == info && p->twin_in_adjl == NIL)
+            {
+                return p;
+            }
+            p = embedg_dlcl_list_next(p);
+        }
+    }
+    return NP;
+}
+
+
+
+static void 
+embedg_dlcl_rec_retrieve (t_dlcl *r)
+{
+    t_dlcl    *right, *left;
+ 
+    right = r->right;
+    left = r->left;
+ 
+    left->right = right;
+    right->left = left;
+ 
+    r->right = r;
+    r->left = r;
+}
+
+static void 
+embedg_dlcl_rec_delete (t_dlcl *r)
+{
+    embedg_dlcl_rec_retrieve(r);
+    embedg_dlcl_rec_free(r);
+}
+
+
+t_dlcl *
+embedg_dlcl_delete_first (t_dlcl *l)
+    /*
+      prune the list from the head:
+      - set new head to right of old head
+      - delete old head
+    */
+{
+    t_dlcl    *new_head;
+
+    ASSERT(!embedg_dlcl_is_empty(l));
+    if (embedg_dlcl_is_singleton(l))
+    {
+        new_head = NP;
+    }
+    else
+    {
+        new_head = l->right;
+    }
+    embedg_dlcl_rec_delete(l);
+    return new_head;
+}
+
+
+t_dlcl *
+embedg_dlcl_delete_rec (t_dlcl *l, t_dlcl *r)
+    /*
+      delete r from l;
+      if r == l, set new head to right of old head
+    */
+{
+    if (r == l)
+    {
+        return embedg_dlcl_delete_first(l);
+    }
+    embedg_dlcl_rec_delete(r);
+    return l;
+}
+
+
+boolean 
+embedg_dlcl_is_empty (t_dlcl *l)
+{
+    return (l == NP) ? TRUE : FALSE;
+}
+
+
+static boolean 
+embedg_dlcl_is_singleton (t_dlcl *l)
+{
+    return (l->right == l) ? TRUE : FALSE;
+    /*
+      same as l->left == l
+    */
+}
+
+t_dlcl *
+embedg_dlcl_list_next (t_dlcl *l)
+    /*
+      this assumes no choice in the direction of the walking
+      (always to the right)
+      -- good enough when deleting for example or when
+      the direction of the walking does not matter
+    */
+{
+    return l->right;
+}
+ 
+
+t_dlcl *
+embedg_dlcl_list_prev (t_dlcl *l)
+    /*
+      this assumes no choice in the direction of the walking
+      (always to the right)
+    */
+{
+    return l->left;
+}
+ 
+t_dlcl *
+embedg_dlcl_list_last (t_dlcl *l)
+{
+    return embedg_dlcl_list_prev(l);
+}
+ 
+
+
+void 
+embedg_dlcl_delete (t_dlcl *l)
+{
+    if (!embedg_dlcl_is_empty(l))
+    {
+        while (!embedg_dlcl_is_singleton(l))
+        {
+            t_dlcl    *next;
+ 
+            next = embedg_dlcl_list_next(l);
+            embedg_dlcl_rec_delete(next);
+        }
+        embedg_dlcl_rec_delete(l);
+    }
+}
+
+t_dlcl *
+embedg_dlcl_copy (t_dlcl *l)
+{
+    t_dlcl    *p, *c;
+    
+    if (embedg_dlcl_is_empty(l))
+        return NP;
+
+    c = embedg_dlcl_rec_new(l->info);
+    
+    p = embedg_dlcl_list_next(l);
+    while (p != l)
+    {
+        t_dlcl     *temp;
+
+        temp = embedg_dlcl_rec_new(p->info);
+        temp->in_adjl = p->in_adjl;
+        temp->twin_in_adjl = p->twin_in_adjl;
+        temp->mult = p->mult;
+        c = embedg_dlcl_rec_append(c, temp);
+        p = embedg_dlcl_list_next(p);
+    }
+    return c;
+}
+
+
+int 
+embedg_dlcl_length (t_dlcl *l)
+{
+    t_dlcl    *p;
+    int       n;
+    
+    if (embedg_dlcl_is_empty(l))
+        return 0;
+
+    p = embedg_dlcl_list_next(l);
+    n = 1;
+    while (p != l)
+    {
+        n++;
+        p = embedg_dlcl_list_next(p);
+    }
+    return n;
+}
+/*
+ *  planar_by_edge_addition.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  The top level for the planarity tester.
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+ 
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_VERB(x)   {}
+#define IF_DEB_TREE(x)    {}
+#define IF_DEB_EDGES(x) {}
+#define IF_CPU(x) {}
+ 
+ 
+/* aproto: header embed_graph_protos.h */
+
+
+#ifndef PLANAR_IN_MAGMA
+#endif
+ 
+
+boolean 
+sparseg_adjl_is_planar (
+    t_ver_sparse_rep *V,
+    int n,
+    t_adjl_sparse_rep *A,        /* input sparse graph */
+    int *nbr_c,        /* size of the graph, #components
+                                    */
+    t_dlcl ***dfs_tree,      /* a sparse graph rep. for the dfs tree
+                                      -- vertices are as DFIs
+                                      -- and children are ordered wrt
+                                         lowpoint value
+                                   */
+    t_dlcl ***back_edges,    /* for each vertex v, a dlcl
+                                      of the back edges [v, x] incident to v
+                                      where x is a DESCENDANT of v
+                                      (vertices are given as DFIs)
+                                   */
+    t_dlcl ***mult_edges,    /* for each vertex v, a dlcl
+                                      of the back edges [v, x] incident to v
+                                      where x is a DESCENDANT of v
+                                      (vertices are given as DFIs)
+                                   */
+    t_ver_edge **embed_graph,    /* output graph embedding -- more on that
+                                      later
+                                   */
+    int *edge_pos,        /* pos. in embed_graph for addition
+                                      of the next edge */
+    int *vr,
+    int *wr         /* if graph is non planar, return
+                                      the unembedded edge
+                                      (where wr descendant of vr)
+                                   */
+)
+    /*
+      as the name indicates: is the graph planar?
+    */
+{
+    int          v;
+
+    IF_CPU(
+    float      sttime; float time_to_now;
+    )
+
+
+    *embed_graph =
+        embedg_planar_alg_init(V, n, A, nbr_c,
+                               edge_pos, dfs_tree, back_edges, mult_edges);
+    IF_CPU(
+    sttime = time_current_user();
+          )
+
+    for (v = n - 1; v >= 0; v--)
+        /*
+          visit all vertices in descending DFI order
+        */
+    {
+        t_dlcl     *be_l, *te_l, *p;
+
+        IF_DEB(
+               fprintf(stdout, "top level, vertex   %d\n", v);
+               )
+            
+        /*
+          find all the back edges [w, v] where w is a descendant of v
+          and perform a walkup from w to v
+          (ie determine which bicomps are pertinent)
+        */
+        be_l = (*back_edges)[v];
+        p = be_l;
+
+        if (!embedg_dlcl_is_empty(p))
+        {
+            int       w;
+            
+            w = p->info;
+            IF_DEB(
+                   fprintf(stdout, "top level, before walkup for w %d\n", w);
+                   )
+            embedg_walkup(*embed_graph, n, v, p);
+
+            p = embedg_dlcl_list_next(p);
+            while (p != be_l)
+            {
+                w = p->info;
+                IF_DEB(
+                       fprintf(stdout, "top level, before walkup for w %d\n", w);
+                       )
+                embedg_walkup(*embed_graph, n, v, p);
+                
+                p = embedg_dlcl_list_next(p);
+            }
+        }
+
+        /*
+          perform a walkdown for each tree edge [v, c], c a descendant of v
+          (ie attempt to embed all back edges on the pertinent bicomps)
+        */
+        te_l = (*dfs_tree)[v];
+        p = te_l;
+
+        if (!embedg_dlcl_is_empty(p))
+        {
+            int             c, vv;
+            t_merge_queue   q;
+
+            c = p->info;
+            vv = c + n;
+            IF_DEB(
+                   fprintf(stdout, "top level, before walkdown for c %d\n", c);
+                   )
+            q = embedg_walkdown(*embed_graph, n, edge_pos, vv);
+
+            IF_DEB(
+                   fprintf(stdout, "top level, after walkdown for c %d, state of edges'sign\n", c);
+                   embedg_VES_print_flipped_edges(*embed_graph,
+                                                       n, *edge_pos);
+                   )
+ 
+            /*
+              temp only
+            */
+            embedg_merge_queue_delete(q);
+            p = embedg_dlcl_list_next(p);
+            while (p != te_l)
+            {
+                c = p->info;
+                vv = c + n;
+                IF_DEB(
+                       fprintf(stdout, "top level, before walkdown for c %d\n", c);
+                       )
+                q = embedg_walkdown(*embed_graph, n, edge_pos, vv);
+
+                IF_DEB(
+                       fprintf(stdout, "top level, after walkdown for c %d, state of edges'sign\n", c);
+                       embedg_VES_print_flipped_edges(*embed_graph,
+                                                           n, *edge_pos);
+                       )
+ 
+                /*
+                  temp only
+                */
+                embedg_merge_queue_delete(q);
+                
+                p = embedg_dlcl_list_next(p);
+            }
+        }
+
+
+        /*
+          check that each back edge [w, v], w a descendant of v,
+          has been embedded
+        */
+        be_l = (*back_edges)[v];
+        p = be_l;
+
+        if (!embedg_dlcl_is_empty(p))
+        {
+            int       w;
+            
+            w = p->info;
+            IF_DEB(
+                   fprintf(stdout, "top level, before checking embedding for w %d\n",
+                           w);
+                   )
+            if ((*embed_graph)[w].adjacent_to == v)
+                /*
+                  this edge hasn't been embedded:
+                  the graph is non-planar
+                */
+            {
+                /*
+                  before returning we really want to ensure that
+                  the vertices' adjacency lists are consistent
+                */
+                ASSERT(embedg_VES_are_adj_lists_consistent(
+                                                       *embed_graph, n));
+
+                IF_CPU(
+                       fprintf(stdout, "CPU for tester only %f\n",
+                               (time_current_user() - sttime));
+                       )
+
+                *vr = v;
+                *wr = w;
+                return FALSE;
+            }
+
+            p = embedg_dlcl_list_next(p);
+            while (p != be_l)
+            {
+                w = p->info;
+                IF_DEB(
+                       fprintf(stdout, "top level, before checking embedding for w %d\n",
+                               w);
+                       )
+                if ((*embed_graph)[w].adjacent_to == v)
+                {
+                    /*
+                      before returning we really want to ensure that
+                      the vertices' adjacency lists are consistent
+                    */
+                    ASSERT(embedg_VES_are_adj_lists_consistent(
+                                                       *embed_graph, n));
+
+                    IF_CPU(
+                           fprintf(stdout, "CPU for tester only %f\n",
+                                   (time_current_user() - sttime));
+                           )
+
+                    *vr = v;
+                    *wr = w;
+                    return FALSE;
+                }
+                
+                p = embedg_dlcl_list_next(p);
+            }
+        }
+    }
+    IF_DEB_EDGES(
+                 fprintf(stdout, "top level, total number of edges in embedding %d\n",
+                         *edge_pos - 2 * n + 1);
+                 )
+
+
+    /*
+      before returning we really want to ensure that
+      the vertices' adjacency lists are consistent
+    */
+    ASSERT(embedg_VES_are_adj_lists_consistent(*embed_graph, n));
+
+    IF_CPU(
+           fprintf(stdout, "CPU for tester only %f\n",
+                   (time_current_user() - sttime));
+           )
+
+    return TRUE;    
+}
+
+
+
+/*
+ *  walkup.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+ 
+  The walkup routine within the VES structure:
+
+  Walking up from w where [w, v^c] is a (directed)
+  back edge to be embeeding later.
+  Along the way collect all the pertinent bicomps that
+  will need to be merged before embedding the back edges
+  to v^c.
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_VERB(x)   {}
+ 
+ 
+ 
+/* aproto: header embed_graph_protos.h */
+ 
+ 
+#ifndef PLANAR_IN_MAGMA
+#endif
+
+
+void 
+embedg_walkup (t_ver_edge *embed_graph, int n, int v, t_dlcl *p)
+    /*
+      walkup from w = p->info to v: [w, v] is a back edge where w is a DFS
+      descendant of v
+    */
+{
+    int          w, x, xin, y, yin;
+
+    w = p->info;
+    
+    IF_DEB(
+           fprintf(stdout, "walkup from %d to %d, enter\n", w, v);
+           )
+        
+    embed_graph[w].adjacent_to = v;
+    /*
+      dirty trick to record some information about the BE [w, v]
+      which will be useful at the time of creation and insertion of
+      this BE: this happens in the walkdown procedure
+
+      note that what I am doing here is safe: [w].in_adjl,
+      [w].twin_in_adjl, [w].mult had no use so far since w is a vertex
+      (and not an edge...)
+    */
+    embed_graph[w].in_adjl = p->in_adjl;
+    embed_graph[w].twin_in_adjl = p->twin_in_adjl;
+    embed_graph[w].mult = p->mult;
+    
+    /*
+      set up the traversal contexts for w: one in each direction
+    */
+    x = w;
+    xin = 1;
+    y = w;
+    yin = 0;
+
+    while (x != v)
+    {
+        int          vz, z, c;
+
+        IF_DEB(
+               fprintf(stdout, "walkup, x %d and y %d\n", x, y);
+               )
+            
+        if (embed_graph[x].visited == v
+            || embed_graph[y].visited == v)
+        {
+            IF_DEB(
+                   if (embed_graph[x].visited == v)
+                       fprintf(stdout, "walkup, x visited\n");
+                   else
+                       fprintf(stdout, "walkup, y visited\n");
+                   )
+            break;
+        }
+
+        /*
+          set x and y as visited!
+        */
+        embed_graph[x].visited = embed_graph[y].visited = v;
+        
+        vz = embedg_VES_is_virtual_vertex(n, x) ? x : NIL;
+        vz = embedg_VES_is_virtual_vertex(n, y) ? y : vz;
+
+        if (vz != NIL)
+            /*
+              that is, x (or y) is a virtual vertex
+              -- in other words, we are set to find the root of the bicomp
+              containing w, or of the bicomp r^c such that w is in the tree
+              rooted by c
+
+              consequently, by definition, vz is PERTINENT
+            */
+        {
+            c = vz - n;
+            z = embed_graph[c].DFS_parent;
+
+            IF_DEB(
+                   fprintf(stdout, "walkup, vz is virtual, %d^%d\n",
+                           z, c);
+                   )
+
+            if (z != v)
+                /*
+                  determine if vz externally or internally active
+                */
+            {
+                if (embed_graph[c].lowpoint < v)
+                    /*
+                      vz is externally active: APPEND to the list
+                      of pertinent bicomps
+                    */
+                {
+                    IF_DEB(
+                           fprintf(stdout, "walkup, vz is ext. active\n");
+                           )
+
+                    embed_graph[z].pertinent_bicomp_list =
+                        embedg_dlcl_rec_append(
+                                embed_graph[z].pertinent_bicomp_list,
+                                embedg_dlcl_rec_new(vz));
+                }
+                else
+                    /*
+                      vz is internally active: PREPEND to the list
+                      of pertinent bicomps
+                    */
+                {
+                    IF_DEB(
+                           fprintf(stdout, "walkup, vz is pertinent\n");
+                           )
+
+                    embed_graph[z].pertinent_bicomp_list =
+                        embedg_dlcl_rec_prepend(
+                                embed_graph[z].pertinent_bicomp_list,
+                                embedg_dlcl_rec_new(vz));
+                }
+            }
+            
+            /*
+              continue the walkup, look if there are any other
+              pertinent bicomps
+              -- here "jump" to the next bicomp "up"
+            */
+            x = z;
+            xin = 1;
+            y = z;
+            yin = 0;
+        }
+        else
+            /*
+              continue the traversal of the bicomp until one finds
+              its (virtual) root
+            */
+        {
+            embedg_VES_get_succ_on_ext_face(embed_graph, n,
+                                                 x, xin, FALSE, 0, &x, &xin);
+            embedg_VES_get_succ_on_ext_face(embed_graph, n,
+                                                 y, yin, FALSE, 0, &y, &yin);
+        }
+    }
+}
+
+/*
+ *  walkdown.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  The walkdown routine within the VES structure:
+
+  walking down a bicomp rooted by a virtual vertex v^c
+  and attempting to embed the back edges.
+  This cannot be done if the walk has to stop due to the
+  presence of externally active vertices on both
+  the clockwise and the anticlockwise side of the bicomp.
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+ 
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_DEB_EMBED(x)    {}
+#define IF_DEB_BE(x) {}
+#define IF_DEB_SCE(x) {}
+#define IF_VERB(x)   {}
+ 
+ 
+ 
+/* aproto: header embed_graph_protos.h */
+ 
+ 
+#ifndef PLANAR_IN_MAGMA
+#endif
+ 
+
+
+t_merge_queue 
+embedg_walkdown (t_ver_edge *embed_graph, int n, int *edge_pos, int vv)
+    /*
+      walkdown from the virtual vertex:
+      embed any back edges incident to vv if any
+      and merge the encountered bicomps while walking down
+      (very informative isn't it? :))
+
+      ... and return the merge queue: will be useful when
+      isolating the Kuratowski subgraphs
+    */
+{
+    t_merge_queue    q;
+    int              v, c, vvout;
+    
+    ASSERT(embedg_VES_is_virtual_vertex(n, vv));
+
+    /*
+      find v and c such that v^c = vv
+    */
+    c = vv - n;
+    v = embed_graph[c].DFS_parent;
+
+    IF_DEB(
+           fprintf(stdout, "walkdown from %d^%d, enter\n", v, c);
+           )
+
+    IF_DEB_EMBED(
+                 fprintf(stdout, "walkdown, embedding at start\n");
+                 embedg_VES_print_bigcomps(embed_graph, n);
+                 )
+        
+    /*
+      create an empty merge queue
+    */
+    q = embedg_merge_queue_new(n);
+
+    for (vvout = 0; vvout <= 1; vvout++)
+        /*
+          chose a direction for the walk, but walk in both
+          directions unless a stopping vertex is encountered
+          and other conditions are satisfied (see below)
+        */
+    {
+        int    w, win;
+
+        embedg_VES_get_succ_on_ext_face(embed_graph, n, vv, vvout ^ 1,
+                                             FALSE, 0, &w, &win);
+
+        IF_DEB(
+               fprintf(stdout, "walkdown, successor (outside while loop) from %d^%d:%d is %d:%d\n",
+                       embed_graph[vv-n].DFS_parent, vv-n, vvout ^ 1,
+                       w, win);
+               )
+
+        while (w != vv)
+            /*
+              is there no danger we walk the whole way back to vv
+              and that all the vertices along the walk are inactive?
+
+              answer: no, because of the short-cut edges.
+
+              Short-cut edges are precisely inserted to remove the inactive
+              vertices from the external face (ie they are "pushed"
+              to the internal face of the bicomp)
+            */
+        {
+            if (embed_graph[w].adjacent_to == v)
+                /*
+                  ie there is a (directed) back edge [w, v]
+                  (would have been set in the previous walkup routine):
+                  embed this edge, but before that, merge all the bicomps
+                  previouslsy collected 
+                */
+            {
+                IF_DEB(
+                       fprintf(stdout, "walkdown, embed BE (%d^%d:%d, %d:%d)\n",
+                               embed_graph[vv-n].DFS_parent, vv - n, vvout,
+                               w, win);
+                       fprintf(stdout, "walkdown, queue before pulling elts\n");
+                       embedg_merge_queue_print(q);
+                       )
+            
+                while (!embedg_merge_queue_empty(q))
+                {
+                    int     u, uin, vu, vuout;
+
+                    embedg_merge_queue_get(&q, &u, &uin, &vu, &vuout);
+
+                    IF_DEB(
+                           fprintf(stdout, "walkdown, pull from queue (%d:%d, %d^%d:%d)\n",
+                                   u, uin,
+                                   embed_graph[vu-n].DFS_parent, vu-n,
+                                   vuout);
+                       )
+
+                    embedg_VES_merge_pertinent_bicomps(
+                                                        embed_graph, n,
+                                                        vu, vuout, u, uin);
+                }
+                IF_DEB_BE(
+                          fprintf(stdout, "walkdown, before embed BE [%d^%d:%d, %d:%d]\n",
+                                  embed_graph[vv-n].DFS_parent, vv - n,
+                                  vvout, w, win);
+                          embedg_VES_print_adj_list(
+                                                    embed_graph, n, vv,
+                                                    TRUE);
+                          fprintf(stdout, "\n");
+                          embedg_VES_print_adj_list(
+                                                    embed_graph, n, vv,
+                                                    FALSE);
+                          )
+                    
+                embedg_VES_embed_edge(embed_graph, n, edge_pos,
+                                                 BE, vv, vvout, w, win);
+
+                IF_DEB_BE(
+                          fprintf(stdout, "walkdown, after embed BE [%d^%d:%d, %d:%d]\n",
+                                  embed_graph[vv-n].DFS_parent, vv - n,
+                                  vvout, w, win);
+                          embedg_VES_print_adj_list(
+                                                    embed_graph, n, vv,
+                                                    TRUE);
+                          fprintf(stdout, "\n");
+                          embedg_VES_print_adj_list(
+                                                    embed_graph, n, vv,
+                                                    FALSE);
+                          )
+                IF_DEB_EMBED(
+                       fprintf(stdout, "walkdown, embedding after bicomp merge & back edge embedding\n");
+                       embedg_VES_print_bigcomps(embed_graph, n);
+                       )
+                        
+                /*
+                  clear the adjacent_to flag
+                */
+                embed_graph[w].adjacent_to = n;  /* "invalid" value */
+            }
+
+            if (!embedg_dlcl_is_empty(embed_graph[w].pertinent_bicomp_list))
+                /*
+                  each pertinent child bicomp of w
+                  (pertinent: contains active (ie more back edges to embed)
+                  elts)
+                  must be traversed
+                  and pushed onto the queue for later bicomp merging
+                */
+            {
+                int           vw, vwout, x, xin, y, yin, s, sin;
+
+                IF_DEB(
+                       fprintf(stdout, "walkdown, pertinent list for %d\n",
+                               w);
+                       embedg_dlcl_print(embed_graph[w].pertinent_bicomp_list);
+                       )
+                
+                /*
+                  get the first child in the pertinent list
+                  (see how the list is built in embedg_walkup)
+
+                  the child will eventually be removed from that list
+                  when merging the bicomps, and surely
+                  this bicomp (rooted at vw) will be merged (later)
+                  because it is active and hence pushed on
+                  the merge queue
+                */
+
+                /*
+                  we can start by pushing the vertex (w, win) on
+                  the merge queue
+                */
+                embedg_merge_queue_append_vertex(&q, embed_graph, n, w, win);
+
+                IF_DEB(
+                       fprintf(stdout, "walkdown, push 1rst 2-tuple on queue\n");
+                       embedg_merge_queue_print(q);
+                       )
+                    
+                /*
+                  get the first child in the pertinent list
+                */
+                vw = (embed_graph[w].pertinent_bicomp_list)->info;
+
+                IF_DEB(
+                       fprintf(stdout, "walkdown, get pertinent %d^%d\n",
+                               embed_graph[vw - n].DFS_parent, vw - n);
+                       )
+                    
+                /*
+                  start two walks starting at vw
+                */
+                embedg_VES_get_succ_active_on_ext_face(embed_graph, n,
+                                                     v , vw, 1,
+                                                     FALSE, 0, &x, &xin);
+                embedg_VES_get_succ_active_on_ext_face(embed_graph, n,
+                                                     v, vw, 0,
+                                                     FALSE, 0, &y, &yin);
+
+                /*
+                  because of the trick of inserting short-cut edges
+                  at previous stages, neighbours of vw are guaranteed
+                  to be active
+                  
+                  (however I'll use the more general 
+                  embedg_VES_get_succ_active_on_ext_face
+                  instead of the restrictive 
+                  embedg_VES_get_succ_on_ext_face
+                  because  the walkdown may be used later to isolate
+                  Kuratowski minors, in a situation where SCEs could have
+                  been removed and thus where the successor on the
+                  external face will no longer be guaranteed to be active)
+                  (* actually I have decided to remove the SCE at the
+                  very last moment hence the above pb
+                  does not occur in the present implementation)
+
+                  
+                  it only remains to chose the next vertex where from
+                  to continue the walk; the choice is made in that order:
+                  - an internally active vertex
+                    (incident to v via a backedge but whose lowpoint 
+                    is NO less than v)
+                  - a (externally active) pertinent vertex
+                    (incident to v via a backedge but whose lowpoint
+                    is less than v: ie which is also externally active)
+                  - as a last resort, a non-pertinent externally vertex,
+                    which is then a stopping vertex
+                */
+                IF_DEB(
+                       fprintf(stdout, "walkdown, x and y: %d, %d\n", x, y);
+                       )
+                
+                if (embedg_VES_is_ver_int_active(embed_graph, n,
+                                                            v, x))
+                    /*
+                      x is internally active
+                    */
+                {
+                    IF_DEB(
+                           fprintf(stdout, "walkdown, x is int. active\n");
+                           )
+                        
+                    s = x;
+                    sin = xin;
+                }
+                else if (embedg_VES_is_ver_int_active(
+                                                            embed_graph, n,
+                                                            v, y))
+                    /*
+                      y is internally active
+                    */
+                {
+                    IF_DEB(
+                           fprintf(stdout, "walkdown, y is int. active\n");
+                           )
+                        
+                    s = y;
+                    sin = yin;
+                }
+                else if (embedg_VES_is_ver_pertinent(
+                                                            embed_graph, n,
+                                                            v, x))
+                    /*
+                      x is pertinent
+                    */
+                {
+                    IF_DEB(
+                           fprintf(stdout, "walkdown, x is pertinent\n");
+                           )
+                        
+                    s = x;
+                    sin = xin;
+                }
+                else
+                    /*
+                      tough luck: y may be externally active
+                    */
+                {
+                    IF_DEB(
+                           fprintf(stdout, "walkdown, tough luck\n");
+                           )
+                        
+                    s = y;
+                    sin = yin;
+                }
+
+                IF_DEB(
+                       fprintf(stdout, "walkdown, succ. on pertinent bicomp is %d:%d\n", s, sin);
+                       )
+                        
+                /*
+                  set vwout to respect consistency of traversal
+                */
+                vwout = s == x ? 0 : 1;
+
+                /*
+                  now that we know vwout we can push (vw, vwout)
+                  on the merge queue, thus completing the 4-tuple
+                  (w, win, vw, vwout) describing a bicomp merge
+                  to occur at a later stage
+                */
+                embedg_merge_queue_append_virtual_vertex(&q, embed_graph, n,
+                                                         vw, vwout);
+
+                IF_DEB(
+                       fprintf(stdout, "walkdown, push on queue (%d:%d, %d^%d:%d)\n",
+                               w, win, embed_graph[vw-n].DFS_parent, vw - n,
+                               vwout);
+                       embedg_merge_queue_print(q);
+                       )
+                    
+                /*
+                  we continue the walk
+                */
+                w = s;
+                win = sin;
+            }
+            /*
+              at this point, w is either inactive or externally active
+              (w can't be pertinent: its pertinent bicomp list is empty,
+              and the back edge [w, v], if any, has already been embedded)
+            */
+            else if (embedg_VES_is_ver_inactive(embed_graph, n,
+                                                           v, w))
+                /*
+                  w is inactive: continue with the walk on the external face
+                  and, insert a short cut edge so that w is removed
+                  from the external face
+                */
+            {
+                int   s, sin;
+
+                IF_DEB(
+                       fprintf(stdout, "walkdown, %d has no pertinent bicomps and is inactive\n", w);
+                       )
+                    
+                embedg_VES_get_succ_on_ext_face(embed_graph, n,
+                                                     w, win,
+                                                     FALSE, 0, &s, &sin);
+
+                IF_DEB(
+                       fprintf(stdout, "walkdown, successor from %d:%d is %d:%d\n",
+                               w, win, s, sin);
+                       )
+
+                /*
+                  s is the successor of w: we embed a short circuit edge
+                  [vv, s] if
+                  - the bicomp is externally active (to ensure that
+                    at a later stage this new face gets bisected:
+                    so that we don't end up with a face of degree 2
+                    (parallel edges))
+                  - if [s, vv] is not a back edge
+
+                  CONSEQUENTLY, adding SCE edges
+                  + does not destroy the planarity of the graph
+                  + ensures that each face has degree > 2 so that
+                    |E| <= 3 * |V| - 6 remains valid at all times
+                  + that the space allocated to the edges in embed_graph
+                    (via MAXDE(n)) is sufficient
+
+                  NOTE:
+                  the above still allows to embed a short-cut edge
+                  as an edge parallel to a tree edge OR a back edge
+                  (which then has been embedded previously
+                  so that [w].adjacent has been cleared)
+                  
+                  but again, since the degree of the face will be
+                  > 2, that's ok 
+
+                  recall that c = vv - n
+                */
+                if (embed_graph[c].lowpoint < v
+                    /*
+                      bicomp rooted at vv is externally active
+                    */
+                    && embed_graph[s].adjacent_to != v)
+                    /*
+                      [s, vv] is not a back edge
+                    */
+                {
+                    IF_DEB_SCE(
+                           fprintf(stdout, "walkdown, before embed SCE [%d^%d:%d, %d:%d]\n",
+                                   embed_graph[vv-n].DFS_parent, vv - n,
+                                   vvout, s, sin);
+                           embedg_VES_print_adj_list(
+                                                    embed_graph, n, vv,
+                                                    TRUE);
+                           fprintf(stdout, "\n");
+                           embedg_VES_print_adj_list(
+                                                    embed_graph, n, vv,
+                                                    FALSE);
+                           
+                           )
+
+                    embedg_VES_embed_edge(embed_graph,
+                                                     n, edge_pos,
+                                                     SCE, vv, vvout, s, sin);
+                    /*
+                      note also that the addition of short cut edges
+                      does not change the fact that the graph is planar
+                      (when it is, so we never run into the problem
+                      of creating/adding too many edges to embed-graph)
+                    */
+                    IF_DEB_SCE(
+                           fprintf(stdout, "walkdown, after embed SCE [%d^%d:%d, %d:%d]\n",
+                                   embed_graph[vv-n].DFS_parent, vv - n,
+                                   vvout, s, sin);
+                           embedg_VES_print_adj_list(
+                                                    embed_graph, n, vv,
+                                                    TRUE);
+                           fprintf(stdout, "\n");
+                           embedg_VES_print_adj_list(
+                                                    embed_graph, n, vv,
+                                                    FALSE);
+                           
+                           )
+                    IF_DEB(
+                           fprintf(stdout, "walkdown, embed SCE [%d^%d:%d, %d:%d]\n",
+                                   embed_graph[vv-n].DFS_parent, vv - n,
+                                   vvout, s, sin);
+                           )
+
+                }
+                /*
+                  continue the walk
+                */
+                w = s;
+                win = sin;
+            }
+            else
+                /*
+                  w is non-pertinent and externally active:
+                  it is a stopping vertex:
+                  we stop here and see if we can walk in the other direction
+                */
+            {
+                IF_DEB(
+                       fprintf(stdout, "walkdown, %d is externally active\n", w);
+                       )
+                break;
+            }
+        }
+        if (!embedg_merge_queue_empty(q))
+            /*
+              mumm.... don't understand this one... let's see:
+              the queue constains pertinent bicomps collected during one of
+              the traversal of the external face, so that once
+              a stopping vertex has been encountered and the queue
+              is not empty, this means that we will be unable
+              to embed any remaining back edges:
+
+              it is important to remember that when w is a stopping vertex
+              there is no choice left, since we walk the pertinent
+              bicomp in both directions at once, and always choose
+              the "best" possible vertex
+              (see the choice strategy: (a) internally active, (b) pertinent,
+              (c) the rest)
+            */
+        {
+            IF_DEB(
+                   fprintf(stdout, "walkdown, merge queue is not empty\n");
+                   )
+            break;
+        }
+    }
+
+    /*
+      and return the merge queue
+    */
+    return q;
+}
+
+
+
+
+/*
+ *  merge_queue_misc.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  The merge queue stores the pertinent bicomps waiting to
+  be merged before a subsequent back edge embedding.
+  See walkdown.c
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+ 
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_VERB(x)   {}
+ 
+ 
+ 
+/* aproto: header embed_graph_protos.h */
+
+ 
+#ifndef PLANAR_IN_MAGMA
+#endif
+
+t_merge_queue 
+embedg_merge_queue_new (int n)
+    /*
+      create a merge queue of 4 * (n-1) elts:
+      we can only have at most n-1 virtual vertices,
+      and for each of those we need to store 4 bits of info
+    */
+{
+    t_merge_queue   q;
+
+    q.start = q.end = 0;
+    q.b = (int *) mem_malloc(sizeof(int) * 4 * (n - 1));
+
+    return q;
+}
+
+void 
+embedg_merge_queue_delete (t_merge_queue q)
+{
+    mem_free(q.b);
+}
+
+
+boolean 
+embedg_merge_queue_empty (t_merge_queue q)
+{
+    return q.start == q.end ? TRUE : FALSE;
+}
+
+void 
+embedg_merge_queue_print (t_merge_queue q)
+{
+    int        i;
+
+    for (i = q.start; i < q.end; i++)
+    {
+        fprintf(stdout, "%d:%d ", q.b[i], q.b[i+1]);
+	++i;
+    }
+    fprintf(stdout, "\n");
+}
+
+void 
+embedg_merge_queue_append (t_merge_queue *q, t_ver_edge *embed_graph,
+	int n, int v, int vin, int vv, int vvout)
+    /*
+      append the 4-tuple (v, vin, vv, vvout)
+      where v is a vertex and vv is its virtual counterpart
+
+      we don't do much here, most of the work is done
+      when pulling a bicomp/4-tuple from the queue
+    */
+{
+    /*
+      is this really necessary? - YES!!!
+    */
+    ASSERT((*q).end < 4 * (n - 2));
+    ASSERT(embedg_VES_is_vertex(n, v));
+    ASSERT(embedg_VES_is_virtual_vertex(n, vv));
+    ASSERT(embed_graph[vv - n].DFS_parent == v);
+
+    (*q).b[(*q).end++] = v;
+    (*q).b[(*q).end++] = vin;
+    (*q).b[(*q).end++] = vv;
+    (*q).b[(*q).end++] = vvout;
+}
+
+void 
+embedg_merge_queue_append_vertex (t_merge_queue *q, t_ver_edge *embed_graph,
+	int n, int v, int vin)
+    /*
+      same as above but were we only append the 2-tuple (v, vin),
+      appending the 2-tuple (vv, vvout) at a later stage
+      (see embedg_merge_queue_append_virtual_vertex)
+    */
+{
+    ASSERT((*q).end < 4 * (n - 2));
+    ASSERT(embedg_VES_is_vertex(n, v));
+
+    (*q).b[(*q).end++] = v;
+    (*q).b[(*q).end++] = vin;
+
+    IF_DEB(
+           fprintf(stdout, "merge_queue_append_vertex, after, end is %d\n",
+                   (*q).end);
+           )
+}
+
+void 
+embedg_merge_queue_append_virtual_vertex (t_merge_queue *q,
+	t_ver_edge *embed_graph, int n, int vv, int vvout)
+    /*
+      counterpart to embedg_merge_queue_append_vertex:
+      here we append the 2-tuple (vv, vvout), vv = v^c,
+      where the 2-tuple (v, vin) is already in the queue
+      (see embedg_merge_queue_append_vertex)
+    */
+{
+    ASSERT(!embedg_merge_queue_empty(*q));
+    ASSERT(embedg_VES_is_virtual_vertex(n, vv));
+    ASSERT(embed_graph[vv - n].DFS_parent == (*q).b[(*q).end - 2]);
+    
+    (*q).b[(*q).end++] = vv;
+    (*q).b[(*q).end++] = vvout;
+
+    IF_DEB(
+           fprintf(stdout, "merge_queue_append_virtual_vertex, after, end is %d\n",
+                   (*q).end);
+           )
+}
+
+void 
+embedg_merge_queue_get (t_merge_queue *q, int *v, int *vin, int *vv, int *vvout)
+    /*
+      pulling out a 4-tuple from the beginning of the FIFO queue
+    */
+{
+    ASSERT(!embedg_merge_queue_empty((*q)));
+
+    *v = (*q).b[(*q).start++];
+    *vin = (*q).b[(*q).start++];
+    *vv = (*q).b[(*q).start++];
+    *vvout = (*q).b[(*q).start++];
+}
+
+void 
+embedg_merge_queue_prune (t_merge_queue *q, int *v,
+			  int *vin, int *vv, int *vvout)
+    /*
+      pulling out a 4-tuple from the end of the FIFO queue
+    */
+{
+    ASSERT(!embedg_merge_queue_empty((*q)));
+
+    *vvout = (*q).b[--((*q).end)];
+    *vv = (*q).b[--((*q).end)];
+    *vin = (*q).b[--((*q).end)];
+    *v = (*q).b[--((*q).end)];
+}
+
+/*
+ *  vertex_activity.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  Determining a vertex's activity. This takes place within
+  the VES structure.
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+ 
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_VERB(x)   {}
+ 
+ 
+ 
+/* aproto: header embed_graph_protos.h */
+ 
+ 
+#ifndef PLANAR_IN_MAGMA
+#endif
+ 
+ 
+
+
+boolean 
+embedg_VES_is_ver_pertinent (t_ver_edge *embed_graph, int n, int v, int w)
+    /*
+      is w pertinent (wrt v)
+      - the field adjacent_to = v: means there is a back edge [w, v]
+      - or w has a non empty pertinent_bicomp_list
+    */
+{
+    boolean       ans;
+    
+    ans = embed_graph[w].adjacent_to == v ? TRUE : FALSE;
+
+    if (ans)
+        return TRUE;
+    else
+        return embedg_dlcl_is_empty(embed_graph[w].pertinent_bicomp_list) ?
+            FALSE : TRUE;
+}
+
+boolean 
+embedg_VES_is_ver_ext_active (t_ver_edge *embed_graph, int n, int v, int w)
+    /*
+      is w externally active (wrt v)
+      this is the case when either w's least_ancestor < v
+      or the first member of w's separated_DFS_child_list has lowpoint < v
+      (the vertices in separated_DFS_child_list are ordered by lowpoint)
+
+      why? because w's separated_DFS_child_list may be empty
+      (due to prior bicomp merging say) and so its children are in effect
+      inactive
+    */
+{
+    boolean       ans;
+
+    ans = embed_graph[w].least_ancestor < v ? TRUE : FALSE;
+
+    if (ans)
+        return TRUE;
+    else
+    {
+        if (embedg_dlcl_is_empty(embed_graph[w].separated_DFS_child_list))
+        {
+            return FALSE;
+        }
+        else
+        {
+            int      c;
+            
+            c = (embed_graph[w].separated_DFS_child_list)->info;
+            return embed_graph[c].lowpoint < v ? TRUE : FALSE;
+        }
+    }
+}
+
+
+boolean 
+embedg_VES_is_ver_int_active (t_ver_edge *embed_graph, int n, int v, int w)
+    /*
+      is w internally active (wrt v):
+      this happens when w is pertinent but NOT externally active
+    */
+{
+    return embedg_VES_is_ver_pertinent(embed_graph, n, v, w)
+        && !embedg_VES_is_ver_ext_active(embed_graph, n, v, w);
+}
+
+boolean 
+embedg_VES_is_ver_inactive (t_ver_edge *embed_graph, int n, int v, int w)
+    /*
+      is w inactive (wrt v), that is w nor pertinent nor externally activ
+    */
+{
+    return !embedg_VES_is_ver_pertinent(embed_graph, n, v, w)
+        && !embedg_VES_is_ver_ext_active(embed_graph, n, v, w);
+}
+
+/*
+ *  merge_bicomps.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  In the VES structure, merging two bicomponents.
+  That is, merging the virtual vertex v^c with the
+  actual vertex v while merging their respective
+  adjacency lists.
+  This must be done in a very specific manner so as to able to
+  determine the subsequent internal/external faces.
+  Also, great care must be taken so that the resulting
+  adj. list for v is consistent (wrt to the direction
+  of traversal).
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_DEB_ADJL(x)    {}
+#define IF_VERB(x)   {}
+
+ 
+ 
+/* aproto: header embed_graph_protos.h */
+
+
+void 
+embedg_VES_merge_simple_bicomps (t_ver_edge *embed_graph, int n, int vv,
+	int vvout, int v, int vin)
+    /*
+      merge the bicomp rooted at vv (vv a virtual vertex) with
+      its counterpart v so that the resulting adjacency list for v
+      is consistent and is the union of the adjacency lists for vv and v
+
+      we treat the case that the bicomp may be flipped (vvout == vin)
+      here
+    */
+{
+    int       c, edge, twin, root_edge, cur, prev;
+    int       vout, vvin, e1, e2, e3, e4, e1out, e3out, e4in;
+
+    /*
+      find c such that [v^c, c] is the root edge of the bicomp
+      rooted at vv = v^c
+    */
+    c = vv - n;
+    ASSERT(embed_graph[c].DFS_parent == v);
+
+    IF_DEB(
+           fprintf(stdout, "merge_simple_bicomp, start: merge\n");
+           embedg_VES_print_virtual_vertex(embed_graph, n, vv);
+           fprintf(stdout, ":%d & ", vvout);
+           embedg_VES_print_vertex(n, v);
+           fprintf(stdout, ":%d\n", vin);
+           )
+
+    IF_DEB_ADJL(
+           fprintf(stdout, "merge_simple_bicomp, adj. list for %d (before)\n", vv);
+           embedg_VES_print_adj_list(embed_graph, n, vv,
+                                                TRUE);
+           fprintf(stdout, "\n");
+           embedg_VES_print_adj_list(embed_graph, n, vv,
+                                                FALSE);
+           fprintf(stdout, "\n");
+
+           fprintf(stdout, "merge_simple_bicomp, adj. list for %d (before)\n", v);
+           embedg_VES_print_adj_list(embed_graph, n, v,
+                                                TRUE);
+           fprintf(stdout, "\n");
+           embedg_VES_print_adj_list(embed_graph, n, v,
+                                                FALSE);
+           )
+    /*
+      find all edges incident to vv and (re)set all references
+      to incidence to vv to incidence to v
+
+      by the same token, find the root_edge [v^c, c]
+
+      MOREVOVER, when vin == vvout, the bicomp (rooted by v^v = vv)
+      will be flipped:
+      we must invert the links of all the edges incident
+      to vv so that their further union with v's adjacency list
+      results in a consistent adjacency list for v!
+
+      we do everything in one go
+    */
+
+    /*
+      very careful here: a root edge must ALSO be a TE
+      (because the same edge could have been added as a SCE)
+    */
+        
+    root_edge = NIL;
+    edge = embed_graph[vv].link[vvout];
+    ASSERT(embedg_VES_is_edge(n, edge));
+    if (embed_graph[edge].neighbour == c
+        && embedg_VES_is_tree_edge(embed_graph, n, edge))
+    {
+        root_edge = edge;
+    }
+
+    if (vin == vvout)
+        /*
+          invert the links
+        */
+    {
+        int  in, out;
+
+        in = embed_graph[edge].link[0];
+        out = embed_graph[edge].link[1];
+        embed_graph[edge].link[0] = out;
+        embed_graph[edge].link[1] = in;
+    }
+    /*
+      get the twin and set the neighbour there to v (was vv originally)
+    */
+    twin =  embedg_VES_get_twin_edge(embed_graph, n, edge);
+    ASSERT(embed_graph[twin].neighbour == vv);
+    embed_graph[twin].neighbour = v;
+
+    prev = vv;
+    cur = edge;
+    while (edge != vv)
+    {
+        edge =
+            embedg_VES_get_next_in_dlcl(embed_graph, n,
+                                                   cur, prev);
+
+        if (embedg_VES_is_edge(n, edge))
+            /*
+              get the twin again (and invert the links if need be)
+            */
+        {
+            if (embed_graph[edge].neighbour == c
+                && embedg_VES_is_tree_edge(embed_graph, n, edge))
+            {
+                root_edge = edge;
+            }
+
+            if (vin == vvout)
+            {
+                int  in, out;
+                
+                in = embed_graph[edge].link[0];
+                out = embed_graph[edge].link[1];
+                embed_graph[edge].link[0] = out;
+                embed_graph[edge].link[1] = in;
+            }
+            
+            twin =
+                embedg_VES_get_twin_edge(embed_graph, n, edge);
+            ASSERT(embed_graph[twin].neighbour == vv);
+            embed_graph[twin].neighbour = v;
+
+            prev = cur;
+            cur = edge;
+        }
+        else
+        {
+            ASSERT(edge == vv);
+            /*
+              only one vertex in the whole circular list
+            */
+        }
+    }
+    ASSERT(root_edge != NIL);
+
+    /*
+      and now union the adjacency lists of v and vv:
+
+      let e1 be the edge record used to enter v
+          e2                            exit  v
+          e3                            enter vv 
+          e4                            exit  vv :
+
+          e1 -> v  -> e2
+          e3 -> vv -> e4
+
+      the union of the list is done in such a way that
+      - e1 and e4 are consecutive in v's adjacency list:
+        they are now in the internal face
+      - e3 is now the edge record used to enter v:
+        it is on the external face (along with e2) :
+
+          e1 -> e4
+          e3 -> v -> e2
+
+      (note that this does not assume that e1 & e2 are distinct
+      or that e3 & e4 are distinct)
+    */
+    /*
+      I must not forget the case where v is a lone vertex:
+      this is the case where v has no DFS ancestor, ie when
+      v is the root of a tree in the DFS forest
+    */
+
+    e1 = embed_graph[v].link[vin];
+    vout = 1 ^ vin;
+    e2 = embed_graph[v].link[vout];
+
+    if (e1 != v)
+    {
+        ASSERT(e2 != v);
+        ASSERT(embedg_VES_is_edge(n, e1));
+        ASSERT(embedg_VES_is_edge(n, e2));
+    }
+    
+    e4 = embed_graph[vv].link[vvout];
+    ASSERT(embedg_VES_is_edge(n, e4));
+
+    vvin = 1 ^ vvout;
+    e3 = embed_graph[vv].link[vvin];
+    ASSERT(embedg_VES_is_edge(n, e3));
+    
+    /*
+      must take care of the adjacency list's consistency of traversal
+      (will be important only when recovering the embedding)
+    */
+    if (e1 == e2)
+    {
+        ASSERT(embed_graph[e1].link[0] == embed_graph[e1].link[1]);
+        if (vin == vvout)
+            /*
+              the bicomp will be flipped:
+              must take 1 ^ vvout - difficult to explain -- later...
+            */
+        {
+            e1out = 1 ^ vvout;
+        }
+        else
+        {
+            e1out = vvout;
+        }
+    }
+    else
+    {
+        e1out = embed_graph[e1].link[0] == v ? 0 : 1;
+    }
+    if (e3 == e4)
+    {
+        ASSERT(embed_graph[e3].link[0] == embed_graph[e3].link[1]);
+        e3out = 1 ^ vin;
+        e4in = vin;
+    }
+    else
+    {
+        e4in = embed_graph[e4].link[0] == vv ? 0 : 1;
+        e3out = embed_graph[e3].link[0] == vv ? 0 : 1;
+    }
+
+    IF_DEB(
+           fprintf(stdout, "merge_simple_bicomp, before union of lists, e1\n");
+           embedg_VES_print_edge(embed_graph, n, e1);
+           fprintf(stdout, "merge_simple_bicomp, e3\n");
+           embedg_VES_print_edge(embed_graph, n, e3);
+           fprintf(stdout, "merge_simple_bicomp, e4\n");
+           embedg_VES_print_edge(embed_graph, n, e4);
+           )
+
+    /*
+      make e1 and e4 consecutive in the adjacency list
+    */
+    embed_graph[e1].link[e1out] = e4;
+    embed_graph[e4].link[e4in] = e1;
+    embed_graph[e3].link[e3out] = v;
+    embed_graph[v].link[vin] = e3;
+
+    IF_DEB(
+           fprintf(stdout, "merge_simple_bicomp, after union of lists, e1\n");
+           embedg_VES_print_edge(embed_graph, n, e1);
+           fprintf(stdout, "merge_simple_bicomp, e3\n");
+           embedg_VES_print_edge(embed_graph, n, e3);
+           fprintf(stdout, "merge_simple_bicomp, e4\n");
+           embedg_VES_print_edge(embed_graph, n, e4);
+           )
+
+    /*
+      also, want to "disable" vv links, meaning then that
+      vv is no longer a root of a bicomp
+    */
+    embed_graph[vv].link[0] = embed_graph[vv].link[1] = vv;
+
+    IF_DEB_ADJL(
+           fprintf(stdout, "merge_simple_bicomp, adj. list for %d (after)\n", vv);
+           embedg_VES_print_adj_list(embed_graph, n, vv,
+                                                TRUE);
+           fprintf(stdout, "\n");
+           embedg_VES_print_adj_list(embed_graph, n, vv,
+                                                FALSE);
+           fprintf(stdout, "\n");
+
+           fprintf(stdout, "merge_simple_bicomp, adj. list for %d (after)\n", v);
+           embedg_VES_print_adj_list(embed_graph, n, v,
+                                                TRUE);
+           fprintf(stdout, "\n");
+           embedg_VES_print_adj_list(embed_graph, n, v,
+                                                FALSE);
+           )
+
+    ASSERT(embedg_VES_is_adj_list_consistent(embed_graph, n, v));
+
+    /*
+      finally, give an orientation to the (formerly) root edge [vv, c]
+      to keep traversal consistent (when recovering embedding)
+    */
+    if (vin == vvout)
+        /*
+          flip: set the sign of the root edge to clockwise
+
+          note: a bicomp is merged only once, so there is no need to
+          "flip" the root_edge's sign: it is set once at initialisation
+          and then changed here if need be.
+        */
+    {
+        embed_graph[root_edge].sign = CLOCKW;
+
+        IF_VERB(
+            fprintf(stdout, "merge_simple_bicomp, flip for %d, sign is now %d for %d of type %d\n",
+                    c, embed_graph[root_edge].sign, root_edge, embed_graph[root_edge].type);
+            embedg_VES_print_edge(embed_graph, n, root_edge);
+            )
+    }
+}
+
+
+
+void 
+embedg_VES_merge_pertinent_bicomps (t_ver_edge *embed_graph, int n,
+	int vv, int vvout, int v, int vin)
+    /*
+      the bicomps to be merged are pertinent: on top (and before)
+      performing a simple merge, there are several things to do
+      related to the merging to pertinent bicomps
+    */
+{
+    /*
+      a note of caution:
+      it is (very) likely that after a bicomp merge the resulting
+      bicomp is not biconnected (and hence traversal of the external face
+      of the bicomp via embedg_VES_get_succ_on_ext_face is non-sensical)
+
+      remembering that a PERTINENT bicomp merge is ALWAYS followed
+      by a back edge embedding we see that the end result is then a bicomp
+      where again traversal of the external face
+      via embedg_VES_get_succ_on_ext_face will make sense
+    */
+    t_dlcl    *pertinent_list, *head, *rep_in_parent_list, *parent_list;
+    int       c;
+
+    /*
+      find c such that [v^c, c] is the root edge of the bicomp
+      rooted at vv = v^c
+    */
+    c = vv - n;
+    ASSERT(embed_graph[c].DFS_parent == v);
+
+    /*
+      two things to do first:
+      - remove vv from head of pertinent_bicomp_list of v
+      - remove c from separated_DFS_child_list of v
+
+      one may ask the point of this since the separated_DFS_child_list
+      seems to mirror pertinent_bicomp_list: but this is not exactly so:
+      + pertinent_bicomp_list is ordered according to the activity
+        of the (virtual) vertices
+      + separated_DFS_child_list is ordered according to the vertices'
+        lowpoint values
+      in effect, it could (almost?*) be said that these two lists
+      are in reverse order (the *almost bit would warrant some thinking here)
+    */
+    
+    /*
+      remove vv from head of pertinent_bicomp_list of v
+    */
+    pertinent_list = head = embed_graph[v].pertinent_bicomp_list;
+    ASSERT(!embedg_dlcl_is_empty(pertinent_list));
+    ASSERT(head->info == vv);
+
+    IF_DEB(
+           fprintf(stdout, "merge_pertinent_bicomp, start: merge\n");
+           embedg_VES_print_virtual_vertex(embed_graph, n, vv);
+           fprintf(stdout, ":%d & ", vvout);
+           embedg_VES_print_vertex(n, v);
+           fprintf(stdout, ":%d\n", vin);
+           )
+
+    IF_DEB(
+           fprintf(stdout, "merge_pertinent_bicomp, pertinent bicomp_list of %d (before)\n", v);
+           embedg_dlcl_print(embed_graph[v].pertinent_bicomp_list);
+           )
+
+    
+    embed_graph[v].pertinent_bicomp_list =
+        embedg_dlcl_delete_first(pertinent_list);
+
+    IF_DEB(
+           fprintf(stdout, "merge_pertinent_bicomp, pertinent bicomp_list of %d (after)\n", v);
+           embedg_dlcl_print(embed_graph[v].pertinent_bicomp_list);
+           )
+
+    /*
+      vv = v^c: remove c from separated_DFS_child_list of v
+    */
+    rep_in_parent_list = embed_graph[c].rep_in_parent_list;
+    ASSERT(!embedg_dlcl_is_empty(rep_in_parent_list));
+
+    parent_list = embed_graph[v].separated_DFS_child_list;
+    ASSERT(!embedg_dlcl_is_empty(parent_list));
+    embed_graph[v].separated_DFS_child_list = 
+        embedg_dlcl_delete_rec(parent_list, rep_in_parent_list);
+
+    /*
+      that's it, it remains to merge, ie. union the adjacency list,
+      and flipping the bicomp if necessary
+    */
+    embedg_VES_merge_simple_bicomps(embed_graph, n,
+                                               vv, vvout, v, vin);
+}
+
+
+
+
+    
+    
+/*
+ *  embed_edge.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  Embedding an edge so that it lies on the external face of a bicomp.
+  We work here with the VES structure.
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+ 
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_DEB_EMBED(x)    {}
+#define IF_VERB(x)   {}
+ 
+ 
+/* aproto: header embed_graph_protos.h */
+ 
+
+void 
+embedg_VES_embed_edge (t_ver_edge *embed_graph, int n, int *edge_pos,
+	int edge_type, int vv, int vvout, int w, int win)
+    /*
+      embed the edge (vv, w) (vv a virtual vertex, w a vertex) between
+      vv and the edge vvout
+      and the edge win and w
+
+      so that after the embedding, one exits vv via (vv, w) and
+      enters w via the twin (w, vv)
+    */
+{
+    int       temp, tempin, tempout;
+
+    ASSERT(edge_type == BE || edge_type == SCE);
+    ASSERT(embedg_VES_is_virtual_vertex(n, vv));
+    ASSERT(embedg_VES_is_vertex(n, w));
+
+    IF_DEB(
+           fprintf(stdout, "embed_edge, (%d:%d)\n", vv, w);
+           )
+    
+    /*
+      first, set the edge [vv, w] with the appropriate info
+
+      when [vv, w] is a back edge there is some more work to do
+      (see the walkup procedure for the extra information we need
+      to copy here
+    */
+    (*edge_pos)++;
+    ASSERT(*edge_pos < 2*n + 2 * MAXE(n));
+    embed_graph[*edge_pos].neighbour = w;
+    embed_graph[*edge_pos].type = edge_type;
+    embed_graph[*edge_pos].sign = CCLOCKW;
+    if (edge_type == BE)
+    {
+        ASSERT(embed_graph[w].adjacent_to ==
+               embed_graph[vv - n].DFS_parent);
+
+        /*
+          PLUS: originally when the back edge [w, vv] was
+          created (in the dfs preprocessing stage), it carried in
+          .in_adjl the index of this directed edge in the
+          adjacency list
+
+          but now, note that we are actually inserting the
+          directed edge [vv, w] in vv's adjacency list,
+          meaning that in_adjl and twin_in_adjl
+          must be exchanged!
+        */
+        embed_graph[*edge_pos].in_adjl = embed_graph[w].twin_in_adjl;
+        embed_graph[*edge_pos].twin_in_adjl = embed_graph[w].in_adjl;
+
+        ASSERT(embed_graph[w].mult % 2 == 0);
+        /*
+          the original graph is always undirected:
+          we store its number of undirected edges
+        */
+        embed_graph[*edge_pos].mult = embed_graph[w].mult / 2;
+    }
+        
+    /*
+      insert this edge between vertex record for vv
+      and edge record vv.link[vvout]
+    */
+    temp = embed_graph[vv].link[vvout];
+    
+    if (embed_graph[temp].link[0] == embed_graph[temp].link[1])
+        /*
+          this needs special treatment to ensure consistency of
+          orientation
+        */
+    {
+        ASSERT(embed_graph[temp].link[0] == vv);
+        tempin = 1 ^ vvout;
+    }
+    else
+    {
+        tempin = embed_graph[temp].link[0] == vv ? 0 : 1;
+    }
+
+    IF_DEB(
+           fprintf(stdout, "embed_edge, edge out of vv\n");
+           embedg_VES_print_edge(embed_graph, n, temp);
+           )
+    
+    embed_graph[vv].link[vvout] = *edge_pos;
+    embed_graph[temp].link[tempin] = *edge_pos;
+    /*
+      the links for *edge_pos must also be "consistent"
+    */
+    embed_graph[*edge_pos].link[vvout] = temp;
+    embed_graph[*edge_pos].link[vvout ^ 1] = vv;
+
+    /*
+      now create/set the twin edge, the directed edge [w, vv]
+    */
+    (*edge_pos)++;
+    ASSERT(*edge_pos < 2*n + 2 * MAXE(n));
+    embed_graph[*edge_pos].neighbour = vv;
+    embed_graph[*edge_pos].type = edge_type;
+    embed_graph[*edge_pos].sign = CCLOCKW;
+    if (edge_type == BE)
+    {
+        embed_graph[*edge_pos].in_adjl = embed_graph[w].in_adjl;
+        embed_graph[*edge_pos].twin_in_adjl = embed_graph[w].twin_in_adjl;
+        embed_graph[*edge_pos].mult = embed_graph[w].mult / 2;
+    }
+ 
+    /*
+      and insert the twin edge between edge record w.link[win]
+      and vertex record for w
+    */
+    temp = embed_graph[w].link[win];
+
+    if (embed_graph[temp].link[0] == embed_graph[temp].link[1])
+        /*
+          again, special treatment to ensure consistency of orientation
+        */
+    {
+        ASSERT(embed_graph[temp].link[0] == w);
+        tempout = 1 ^ win;
+    }
+    else
+    {
+        tempout = embed_graph[temp].link[0] == w ? 0 : 1;
+    }
+    
+    IF_DEB(
+           fprintf(stdout, "embed_edge, edge in of w\n");
+           embedg_VES_print_edge(embed_graph, n, temp);
+           )
+    
+    embed_graph[w].link[win] = *edge_pos;
+    embed_graph[temp].link[tempout] = *edge_pos;
+    /*
+      and consistent orientation
+    */
+    embed_graph[*edge_pos].link[win] = temp;
+    embed_graph[*edge_pos].link[win ^ 1] = w;
+}
+
+
+
+void 
+embedg_VES_add_edge (t_ver_edge *embed_graph, int n, int *edge_pos,
+	int v, int w, boolean MARK, int mark)
+    /*
+      add the edge (v, w): this is DIFFERENT from
+      embedg_VES_embed_edge in the sense
+      that the present function will only be used
+      when building the Kuratowski homeomorphs:
+
+      that is, we are in a situation where the graph is NON planar
+
+      consequently it doesn't matter much where in the adjacency
+      lists of v & w the edge is added:
+      let's say that we always add it at the beginning
+
+      for our sanity's sake, we'll ensure that the resulting
+      adjacency lists remain consistent!
+      
+      and we add the edge as a BE!
+      PLUS we mark it with mark in MARK true
+    */
+{
+    int       temp;
+
+    ASSERT(embedg_VES_is_vertex(n, v) ||
+           embedg_VES_is_virtual_vertex(n, v));
+    ASSERT(embedg_VES_is_vertex(n, w) ||
+           embedg_VES_is_virtual_vertex(n, w));
+
+    IF_DEB(
+           fprintf(stdout, "add_edge, (%d:%d)\n", v, w);
+           )
+
+    /*
+      not sure this is the best place to do this: mark the endpoints
+    */
+    if (MARK)
+    {
+        embed_graph[v].visited = mark;
+        embed_graph[w].visited = mark;
+    }
+        
+    /*
+      first, set the edge [v, w] with the appropriate info
+    */
+    (*edge_pos)++;
+    ASSERT(*edge_pos < 2*n + 2 * MAXE(n));
+    embed_graph[*edge_pos].neighbour = w;
+    embed_graph[*edge_pos].type = BE;
+    /*
+      the edge's orientation will be the same as the vertex
+    */
+    embed_graph[*edge_pos].sign = embed_graph[v].sign;
+    /*
+      and mark the edge
+    */
+    if (MARK)
+    {
+        embed_graph[*edge_pos].visited = mark;
+    }
+        
+    /*
+      insert this edge between vertex record for v 
+      and edge record v.link[1]
+    */
+    temp = embed_graph[v].link[1];
+
+    IF_DEB(
+           fprintf(stdout, "add_edge, edge out of v\n");
+           embedg_VES_print_edge(embed_graph, n, temp);
+           )
+    
+    embed_graph[v].link[1] = *edge_pos;
+    embed_graph[temp].link[0] = *edge_pos;
+    /*
+      the links for *edge_pos must also be "consistent"
+    */
+    embed_graph[*edge_pos].link[1] = temp;
+    embed_graph[*edge_pos].link[0] = v;
+
+    /*
+      now create/set the twin edge, the directed edge [w, v]
+    */
+    (*edge_pos)++;
+    ASSERT(*edge_pos < 2*n + 2 * MAXE(n));
+    embed_graph[*edge_pos].neighbour = v;
+    embed_graph[*edge_pos].type = BE;
+    embed_graph[*edge_pos].sign = embed_graph[w].sign;
+    if (MARK)
+    {
+        embed_graph[*edge_pos].visited = mark;
+    }
+ 
+    /*
+      insert this edge between vertex record for w
+      and edge record w.link[1]
+    */
+    temp = embed_graph[w].link[1];
+    
+    IF_DEB(
+           fprintf(stdout, "add_edge, edge out of w\n");
+           embedg_VES_print_edge(embed_graph, n, temp);
+           )
+    
+    embed_graph[w].link[1] = *edge_pos;
+    embed_graph[temp].link[0] = *edge_pos;
+    /*
+      and consistent orientation
+    */
+    embed_graph[*edge_pos].link[1] = temp;
+    embed_graph[*edge_pos].link[0] = w;
+}
+
+
+/*
+ *  recover.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  From the VES data structure recover either the embedding ot
+  the obstruction into the
+
+  t_sparseg_ver_struct,
+  t_sparseg_adjl_struct,
+  t_sparseg_embed_struct
+  
+  data types.
+
+
+  (This is no even quite true: for some obscure reason
+  I recover the obstruction as a dlcl[] structure to be
+  converted later.
+  The obvious reason being that it is easier to check as such.
+  Maybe I leave it as it is...)
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+ 
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_DEB_EMBED_MULT(x) {}
+#define IF_DEB_EMBED_LOOPS(x) {}
+#define IF_DEB_EMBED(x)    {}
+#define IF_DEB_CHECK_EMBED(x)    {}
+#define IF_DEB_FACES(x) {}
+#define IF_VERB(x)   {}
+#define IF_DEB_SCE(x) {}
+#define IF_DEB_OBS(x) {}
+#define IF_DEB_CHECK_OBS(x) {}
+#define IF_CPU(x) {}
+ 
+
+
+/* aproto: header embed_graph_protos.h */
+
+/* aproto: beginstatic -- don't touch this!! */
+static void embedg_recover_embedding_embed_mult
+ (t_dlcl **, t_embed_sparse_rep *, int, int, int, int, int *, boolean *, int *);
+static void embedg_recover_embedding_embed_loops
+ (t_dlcl **, t_embed_sparse_rep *, int, int, int *, boolean *);
+static t_dlcl **embedg_get_reduced_obs (t_dlcl **, int);
+static boolean embedg_is_red_obs_K33 (t_dlcl **, int);
+static boolean embedg_is_red_obs_K5 (t_dlcl **, int);
+/* aproto: endstatic -- don't touch this!! */
+ 
+ 
+#ifndef PLANAR_IN_MAGMA
+#endif
+
+void 
+embedg_recover_embedding (
+    t_ver_sparse_rep *V,
+    t_adjl_sparse_rep *A,             /* input (original sparse graph) */
+    t_ver_edge *embed_graph,
+    int n,
+    int nbr_e,
+    t_dlcl **mult_edges,
+    t_ver_sparse_rep **vertices,
+    t_embed_sparse_rep **embedding
+)
+    /*
+      recover the embedding
+      to prepare for the final Magma type for sparse & embedded graph
+
+      we assume that all vertices/edges have been given their
+      orientation
+ 
+      at this stage we also embed the multiple edges and loops
+      which were set aside in mult_edges by
+      sparseg_adjl_dfs_preprocessing:
+
+      as it turns out the last bit is pretty hairy!
+    */
+{
+    /*
+      the idea is to return an array of vertices and an array
+      representing the embedding
+      (careful: need to weedout the SCE)
+
+      vertices: (*vertices)[i].first_edge contains index
+                to first edge in embedding
+
+      embedding: a doubly linked circular list of edges,
+                 for each record/edge e = (*embedding)[i]:
+                 e.in_adjl: index in A of e
+                 e.next:    next edge in CLOCKW
+                            (as an index in the embedding)
+                 e.prev:    previous edge in CLOCKW
+                            (as an index in embedding)
+                 e.inv:     inverse edge (as an index in embedding)
+                 e.mark:    a mark for this edge
+
+      let's say that this new array is a slimmed down version of embed_graph
+
+      one issue to address:
+      - for edge e, find its index in A: this should be found
+        in either the embed_graph[v] record of the mult_edges[v] record
+    */
+    int          index_embed, v, mult, w, v_w_in_embed, new_first_edge;
+    boolean      set_next;
+
+    IF_DEB(
+           fprintf(stdout, "in recover emb.\n");
+           sparseg_dlcl_print(mult_edges, n);
+           );
+    
+    *vertices = (t_ver_sparse_rep *)
+        mem_malloc(sizeof(t_ver_sparse_rep) * n);
+    *embedding = (t_embed_sparse_rep *)
+        mem_malloc(sizeof(t_embed_sparse_rep) * 2 * nbr_e);
+
+    index_embed = 0;
+    set_next = TRUE;
+    for (v = 0; v < n; v++)
+    {
+        int       v_l, orient, in, out, e, cur_e, next_e;
+
+        /*
+          we take v's label
+        */
+        v_l = embed_graph[v].label;
+
+        /*
+          first let's deal with the isolated vertex case: those
+          that refer to self
+        */
+        if (embed_graph[v].link[0] == v)
+        {
+            int       temp_index_embed;
+            
+            ASSERT(embed_graph[v].link[1] == v);
+
+            /*
+              there may be [v, v] loops for this vertex, must check this
+            */
+            temp_index_embed = index_embed - 1;
+            /*
+              temp_index_embed is pre-increased below
+            */
+            embedg_recover_embedding_embed_loops(mult_edges, *embedding,
+                                                 nbr_e, v,
+                                                 &temp_index_embed,
+                                                 &set_next);
+            
+            if (temp_index_embed > index_embed - 1)
+                /*
+                  must fix beginning and end of adjacency list:
+                */
+            {
+                (*vertices)[v_l].first_edge = index_embed;
+                (*embedding)[temp_index_embed].next =
+                    (*vertices)[v_l].first_edge;
+                (*embedding)[(*vertices)[v_l].first_edge].prev =
+                    temp_index_embed;
+
+                index_embed = temp_index_embed;
+                index_embed += 1;
+            }
+            else
+            {
+                (*vertices)[v_l].first_edge = NIL;
+            }
+            continue;
+        }
+        
+        /*
+          get v's orientation, and from this decide the way in which
+          v's adjacency list will be traversed
+          (recall that the list is supposed to be consistent, so no bad
+          surprises)
+        */
+        orient = embed_graph[v].sign;
+        in = orient == CCLOCKW ? 0 : 1;
+        out = 1 ^ in;
+
+        e = embed_graph[v].link[out];
+        while (embedg_VES_is_short_cut_edge(embed_graph, n, e))
+        {
+            e = embed_graph[e].link[out];
+        }
+        ASSERT(embedg_VES_is_edge(n, e)
+               && !embedg_VES_is_short_cut_edge(embed_graph, n, e));
+        /*
+          strictly speaking there should be no SCEs left at this stage...
+          
+          if there are SCEs in v's list, it must be the case that
+          the list also contains tree or back edges...
+        */
+        
+        (*vertices)[v_l].first_edge = index_embed;
+
+        IF_DEB_EMBED(
+                     fprintf(stdout, "recov. embed. DFI %d vertex %d at %d (edges) and %d (embedding)\n",
+                             v, v_l, index_e, (*vertices)[v_l].first_edge);
+                     )
+
+        cur_e = e;
+        while (TRUE)
+        {
+            next_e = embed_graph[cur_e].link[out];
+            while (embedg_VES_is_short_cut_edge(embed_graph, n, next_e))
+            {
+                next_e = embed_graph[next_e].link[out];
+            }
+            ASSERT(!embedg_VES_is_short_cut_edge(embed_graph, n, next_e));
+
+            if (next_e == v)
+                /*
+                  end of adjacency list
+                */
+            {
+                break;
+            }
+            
+            ASSERT(embedg_VES_is_edge(n, next_e));
+
+            (*embedding)[index_embed].in_adjl = embed_graph[cur_e].in_adjl; 
+            (*embedding)[index_embed].next = index_embed + 1; /* next in adj.
+                                                                list */
+            (*embedding)[index_embed].mark = NIL;  /* mark */
+            
+            /*
+              cur_e's twin is trickier:
+              we'll use twin's label field to store cur_e's index in
+              the embedding
+
+              if cur_e's label != NIL this means that cur_e's twin
+              is already stored in edges/embedding  and consequently
+              that cur_e.label = index of its twin (in the embedding)
+
+              note that it is safe to do so since an edge's label
+              has no meaning
+            */
+            if (embed_graph[cur_e].label != NIL)
+            {
+                (*embedding)[index_embed].inv = embed_graph[cur_e].label;
+
+                /*
+                  but fix the twin by the same token
+                */
+                (*embedding)[embed_graph[cur_e].label].inv = index_embed;
+                ASSERT((*embedding)[embed_graph[cur_e].label].in_adjl ==
+                       embed_graph[cur_e].twin_in_adjl);
+            }
+            else
+                /*
+                  we store cur_e's index in the embedding in twin's label
+                */
+            {
+                int      twin;
+                
+                twin = embedg_VES_get_twin_edge(embed_graph, n, cur_e);
+                embed_graph[twin].label = index_embed;
+            }
+
+            /*
+              so the only thing we couldn't update yet is
+              (*embedding)[index_embed].prev, cur_e previous edge in the list
+
+              but we can do this for next_e
+            */
+            (*embedding)[index_embed + 1].prev = index_embed;
+
+            /*
+              we check if there are any multiple edges or loops
+              to embed
+            */
+            w = embed_graph[cur_e].neighbour;
+            mult = embed_graph[cur_e].mult - 1;
+            /*
+              one was for the TE or BE edge
+            */
+
+            if (index_embed == (*vertices)[v_l].first_edge)
+                /*
+                  when looking for multiple edges/loops
+                  we must temporarily "close" this ordered
+                  list of vertices when in presence of the first
+                  edge in the list:
+
+                  not doing this would mean that
+                  (*embedding)[(*vertices)[v_l].first_edge].prev
+                  contains some irrelevant value which may cause
+                  (major) trouble when embedding inverses of
+                  multiple edges...
+                */
+            {
+                (*embedding)[(*vertices)[v_l].first_edge].prev = index_embed;
+            }
+            
+            embedg_recover_embedding_embed_mult(mult_edges, *embedding,
+                                                nbr_e, v, w, mult,
+                                                &index_embed, &set_next,
+                                                &new_first_edge);
+            embedg_recover_embedding_embed_loops(mult_edges, *embedding,
+                                                 nbr_e, v, &index_embed,
+                                                 &set_next);
+            set_next = TRUE;
+
+            /*
+              yes, it may be the case that (*vertices)[v_l].first_edge
+              change while in embedg_recover_embedding_embed_mult
+              -- see that function for more
+            */
+            (*vertices)[v_l].first_edge = new_first_edge == NIL ?
+                (*vertices)[v_l].first_edge : new_first_edge;
+            
+            /*
+              that's all, we proceed to read a new edge in the list
+            */
+            index_embed += 1;
+            cur_e = next_e;
+        }
+
+        /*
+          now next_e = v so that cur_e is the last edge in v's adjacency list
+          we must deal with this case separately
+        */
+
+        /*
+          fix cur_e in embedding (and its twin)
+        */
+        (*embedding)[index_embed].in_adjl = embed_graph[cur_e].in_adjl;
+
+        /*
+          we temporarily set next of cur_e in to index_embed + 1
+        */
+        (*embedding)[index_embed].next = index_embed + 1;
+        (*embedding)[index_embed].mark = NIL;  /* mark */
+
+        /*
+          fix cur_e's twin
+        */
+        if (embed_graph[cur_e].label != NIL)
+        {
+            (*embedding)[index_embed].inv = embed_graph[cur_e].label;
+            (*embedding)[embed_graph[cur_e].label].inv = index_embed;
+            ASSERT((*embedding)[embed_graph[cur_e].label].in_adjl ==
+                   embed_graph[cur_e].twin_in_adjl);
+        }
+        else
+        {
+            int      twin;
+            
+            twin = embedg_VES_get_twin_edge(embed_graph, n, cur_e);
+            embed_graph[twin].label = index_embed;
+        }
+
+        /*
+          we temporarily set the next record's prev field:
+          but we can do that only if we haven't processed
+          all the edges yet
+        */
+        if (index_embed < 2 * nbr_e - 1)
+        {
+            (*embedding)[index_embed + 1].prev = index_embed;
+
+            /*
+              again, check if there are any multiple edges/loops
+              to embed
+            */
+            w = embed_graph[cur_e].neighbour;
+            mult = embed_graph[cur_e].mult - 1;
+            /*
+              one was for the TE or BE edge
+            */
+            v_w_in_embed = index_embed;
+
+            if (index_embed == (*vertices)[v_l].first_edge)
+                /*
+                  same comment as above
+                */
+            {
+                (*embedding)[(*vertices)[v_l].first_edge].prev = index_embed;
+            }
+            
+            embedg_recover_embedding_embed_mult(mult_edges, *embedding,
+                                                nbr_e, v, w, mult,
+                                                &index_embed, &set_next,
+                                                &new_first_edge);
+            embedg_recover_embedding_embed_loops(mult_edges, *embedding,
+                                                 nbr_e, v, &index_embed,
+                                                 &set_next);
+
+            /*
+              same comment as above
+            */
+             (*vertices)[v_l].first_edge = new_first_edge == NIL ?
+                (*vertices)[v_l].first_edge : new_first_edge;
+         }
+
+        /*
+          to finish off, we must set:
+          
+          cur_e's next field:
+          next of cur_e in the list is ... vertices[v_l].first_edge
+          
+          cur_e's next's previous field...
+        */
+        if (set_next)
+            /*
+              set_next (poorly named) is used to indicate which
+              edges must be updated to "close off" the list:
+
+              if set_next is TRUE, we are in the standard case
+              where the last edge in the ordered adj. list
+              is at index_embed
+
+              if set_next is FALSE, the last edge in the ordered adj. list
+              is at v_w_in_embed: because it could have happened
+              (in embedg_recover_embedding_embed_mult only)
+              that the edges have been "wedged" between
+              v_w_in_embed.prev and v_w_in_embed,
+              leaving v_w_in_embed the last in the list
+            */
+        {
+            (*embedding)[index_embed].next = (*vertices)[v_l].first_edge;
+            (*embedding)[(*vertices)[v_l].first_edge].prev = index_embed;
+        }
+        else
+        {
+            (*embedding)[v_w_in_embed].next = (*vertices)[v_l].first_edge;
+            (*embedding)[(*vertices)[v_l].first_edge].prev = v_w_in_embed;
+        }
+        set_next = TRUE;
+            
+        /*
+          a simple check
+        */
+        ASSERT(embedg_dlcl_is_empty(mult_edges[v]));
+        
+        /*
+          we can process another vertex
+        */
+        index_embed += 1;
+    }
+    /*
+      when this is done there are a few things that must hold
+    */
+    ASSERT(index_embed == 2 * nbr_e);
+}
+
+
+static void 
+embedg_recover_embedding_embed_mult (t_dlcl **mult_edges,
+	t_embed_sparse_rep *embedding, int nbr_e, int v, int w,
+	int mult, int *index_embed, boolean *set_next, int *first_edge)
+    /*
+      see if the directed edge [v, w] is multiple: if so embed it
+      in embedding
+
+      moreover if there are any [v, v] loops do that too
+    */
+{
+    /*
+      we take care of multiple edges: for tree edges and back
+      edges their multiplicity is indicated by the
+      embed_graph[cur_e].mult field (which records the number
+      of undirected edges)
+      
+      for loops hovewer this information is stored in the mult
+      field of the FIRST encountered neighbour v in v's neighbour
+      list
+    */
+    t_dlcl      *p;
+    int         v_w_in_embed, v_w_prev;
+    boolean     do_twins, start, do_first_edge;
+
+    IF_DEB_EMBED_MULT(
+           fprintf(stdout, "in recover emb. mult, v %d w %d mult %d\n",
+                   v, w, mult);
+           )
+
+    /*
+      the current index_embed value is the edge [v, w]:
+      I must record this value as it will be needed
+      later
+    */
+    v_w_in_embed = *index_embed;
+    start = TRUE;
+    *set_next = TRUE;
+    do_twins = FALSE;
+    *first_edge = NIL;
+    do_first_edge = FALSE;
+    v_w_prev = NIL;
+    while (mult > 0)
+    {
+        ASSERT(!embedg_dlcl_is_empty(mult_edges[v]));
+        p = embedg_dlcl_find(mult_edges[v], w);
+        /*
+          note that using embedg_dlcl_find to always find
+          the first in the list with p->info == w
+          is ok here since any previous such records would
+          have been deleted/removed from the list
+        */
+        ASSERT(p != NP);
+        /*
+          otherwise we couldn't have mult > 0 !
+        */
+        
+        *index_embed += 1;
+        
+        /*
+          once again I must use a similar sort of trick as in the
+          main function to deal with the inverse edge:
+          
+          the inverse edge is to be found in mult_edges[w]:
+          if p->twin_in_adjl (which was initialised to NIL
+          and has NOT been set in the DFS preprocessing),
+          if p->twin_in_adjl != NIL, then
+          a. its inverse in mult_edges[w] has already been embedded
+          in *embedding
+          b. its index there is stored in p->twin_in_adjl
+          precisely
+         */
+        if (p->twin_in_adjl != NIL)
+        {
+            if (! start)
+                /*
+                  if the first the multiple edges' inverse is already
+                  stored, then this is true for ALL of them
+                */
+            {
+                ASSERT(do_twins == TRUE);
+            }
+            do_twins = TRUE;
+        }
+        else
+            /*
+              similarly, if the first the multiple edges' inverse is
+              not already stored, then this is true for ALL of them
+            */
+        {
+            ASSERT(do_twins == FALSE);
+        }
+
+        embedding[*index_embed].in_adjl = p->in_adjl;
+        embedding[*index_embed].mark = NIL;  
+
+        /*
+          as we will see do_twins has to be treated differently
+        */
+        if (!do_twins)
+            /*
+              this is pretty standard as works as the
+              main recover function
+            */
+        {
+            t_dlcl      *i_m_l, *i_p;
+            
+            embedding[*index_embed].next = *index_embed + 1;
+            
+            /*
+              we store the current index in the embedding in
+              the twin/inverse's twin_in_adjl field
+            */
+            i_p = i_m_l = mult_edges[w];
+            ASSERT(!embedg_dlcl_is_empty(i_m_l));
+            i_p = embedg_dlcl_find_with_NIL_twin_in_adjl(i_m_l, v);
+            ASSERT(i_p != NP);
+            ASSERT(i_p->twin_in_adjl == NIL);
+            
+            i_p->twin_in_adjl = *index_embed;
+            
+             /*
+              to finish off this bit we set embedding[*index_embed + 1].prev
+              
+              but I can only set this prev field if I haven't reached
+              the end of the embedding[] array: this is why we needed
+              nbr_e (total number of edges to embed) as input
+             */
+            
+            if (*index_embed < 2 * nbr_e - 1)
+            {
+                embedding[*index_embed + 1].prev = *index_embed;
+            }
+        }
+        else
+            /*
+              how to insert the inverses of multiple edges already
+              in the embedding:
+
+              if one studies how the twin_in_adjl field has been
+              set while dealing with the inverses of the
+              present multiple edges one sees that
+              the latter must be inserted in counter clockwise
+              order (assuming that the inverses were inserted
+              in clockwise order)
+
+              this is necessariy to ensure a correct matching between
+              the edge and its inverse
+            */
+        {
+            
+            embedding[*index_embed].inv = p->twin_in_adjl;
+            
+            /*
+              fix the twin by the same token
+            */
+            embedding[p->twin_in_adjl].inv = *index_embed;
+
+            /*
+              general (reverse) insertion for these edges
+            */
+            embedding[*index_embed].prev = *index_embed + 1;
+            embedding[*index_embed].next = *index_embed - 1;
+ 
+            /*
+              ok, that was the easy bit, things are a bit more complicated
+              below...
+            */
+            if (start)
+                /*
+                  the edges are "wedged" between
+                  embedding[v_w_in_embed].prev and v_w_in_embed,
+
+                  hence the following
+                */
+            {
+                v_w_prev = embedding[v_w_in_embed].prev;
+                if (v_w_prev == v_w_in_embed)
+                    /*
+                      in this case the first edge in the adj. list
+                      of the vertex whose first_edges is v_w_in_embed
+                      will be changed
+                      (because we insert in reverse order)
+                    */
+                {
+                    do_first_edge = TRUE;
+                }
+
+                embedding[*index_embed].next = v_w_in_embed;
+                embedding[v_w_in_embed].prev = *index_embed;
+                
+                ASSERT(embedding[embedding[*index_embed].inv].prev ==
+                       embedding[v_w_in_embed].inv);
+                ASSERT(embedding[embedding[v_w_in_embed].inv].next ==
+                       embedding[*index_embed].inv);
+            }
+ 
+            if (mult == 1)
+                /*
+                  last inv. edge in this list to add
+                */
+            {
+                ASSERT(v_w_prev != NIL);
+
+                /*
+                  must fix embedding[v_w_prev].next appropriately
+                  (and embedding[*index_embed].prev)
+
+                  this may be overwritten later on, but not necessarily so
+
+                  the next_set flag will enable us to decide
+                  which edge ends this adjacency list: see above
+                */
+                
+                embedding[*index_embed].prev = v_w_prev;
+                embedding[v_w_prev].next = *index_embed;
+                *set_next = FALSE;
+
+                ASSERT(embedding[embedding[*index_embed].inv].prev ==
+                       embedding[*index_embed - 1].inv);
+                ASSERT(embedding[embedding[*index_embed - 1].inv].next ==
+                       embedding[*index_embed].inv);
+
+                if (do_first_edge)
+                    /*
+                      the first edge is the last one added
+                    */
+                {
+                    *first_edge = *index_embed;
+                }
+
+                embedding[v_w_in_embed].next = *index_embed + 1;
+                if (*index_embed < 2 * nbr_e - 1)
+                {
+                   embedding[*index_embed + 1].prev = v_w_in_embed;
+                }
+            }
+
+            ASSERT(embedding[embedding[*index_embed].inv].prev ==
+                   embedding[embedding[*index_embed].next].inv);
+        }
+        
+        /*
+          to finish off this bit we delete the p record from m_l
+          and set embedding[*index_embed + 1].prev
+        */
+        mult_edges[v] = embedg_dlcl_delete_rec(mult_edges[v], p);
+
+        mult--;
+        start = FALSE;
+    }
+    /*
+      conclusion: sevral days to get this working! *sigh*
+    */
+}
+
+
+
+
+static void 
+embedg_recover_embedding_embed_loops (t_dlcl **mult_edges,
+	t_embed_sparse_rep *embedding, int nbr_e, int v,
+	int *index_embed, boolean *set_next)
+    /*
+      embed the [v, v] loops 
+    */
+{
+    /*
+      the loops' multiplicity is stored in the mult
+      field of the FIRST encountered neighbour v in v's neighbour
+      list
+    */
+    t_dlcl      *p;
+    int         nbr_loops;
+    
+    /*
+      have a look if there are any [v. v] loops
+    */
+    p = embedg_dlcl_find(mult_edges[v], v);
+    if (p == NP)
+    {
+        return;
+    }
+
+    /*
+      when there are loops to add to the adjaceny list,
+      edge insertion resume in the "normal" clockwaise saya, way:
+      so we reset set_next to true
+    */
+    *set_next = TRUE;
+    
+    nbr_loops = p->mult;
+    ASSERT(nbr_loops % 2 == 0);
+    /*
+      we counted directed edges
+    */
+    nbr_loops /= 2;
+
+    IF_DEB_EMBED_LOOPS(
+           fprintf(stdout, "in recover emb. loops, nbr_loops [v, v] %d\n",
+                   nbr_loops);
+           )
+        
+    while (nbr_loops > 0)
+        /*
+          a loop requires to embed two directed edges
+        */
+    {
+        p = embedg_dlcl_find(mult_edges[v], v);
+        ASSERT(p != NP);
+
+        *index_embed += 1;
+        
+        embedding[*index_embed].in_adjl = p->in_adjl;
+        embedding[*index_embed].next = *index_embed + 1; 
+        embedding[*index_embed].mark = NIL; 
+        embedding[*index_embed].inv = *index_embed + 1;
+        embedding[*index_embed + 1].prev = *index_embed;
+        
+        mult_edges[v] = embedg_dlcl_delete_rec(mult_edges[v], p);
+        
+        IF_DEB_EMBED_LOOPS(
+           fprintf(stdout, "in recover emb. loops, mid\n");
+           embedg_dlcl_print(mult_edges[v]);
+           );
+
+        /*
+          now do the "inverse" loop
+        */
+        p = embedg_dlcl_find(mult_edges[v], v);
+        ASSERT(p != NP);
+        
+        *index_embed += 1;
+        
+        embedding[*index_embed].in_adjl = p->in_adjl;
+        embedding[*index_embed].next = *index_embed + 1; 
+        embedding[*index_embed].mark = NIL;
+        embedding[*index_embed].inv = *index_embed - 1;
+
+        if (*index_embed < 2 * nbr_e - 1)
+        {
+            embedding[*index_embed + 1].prev = *index_embed;
+        }
+        mult_edges[v] = embedg_dlcl_delete_rec(mult_edges[v], p);
+        
+        nbr_loops--;
+
+        IF_DEB_EMBED_LOOPS(
+           fprintf(stdout, "in recover emb. loops, end\n");
+           embedg_dlcl_print(mult_edges[v]);
+           );
+    }
+}
+
+
+
+
+void 
+embedg_recov_embed_walk_proper_face (int n, int e, t_adjl_sparse_rep *A,
+	t_embed_sparse_rep *embedding, boolean MARK, int mark)
+    /*
+      do a proper face walk in the recovered embedding starting
+      at index e in the embedding
+    */
+{
+    int          cur, next;
+    
+    IF_DEB_FACES(
+                 fprintf(stdout, "recov. emb. proper face walk\n");
+                 fprintf(stdout, "[-, %d] ",
+                         A[embedding[e].in_adjl].end_vertex);
+                 )
+        
+    cur = e;
+    next = NIL;
+    while (next != e)
+        /*
+          to get the next in a proper face traversal:
+          get the previous of the cur's inverse
+        */
+    {
+        int     inv;
+
+        inv = embedding[cur].inv;
+        next = embedding[inv].prev;
+
+        ASSERT(embedding[next].mark != mark);
+        
+        if (MARK)
+        {
+            embedding[next].mark = mark;
+        }
+        
+        cur = next;
+        IF_DEB_FACES(
+                     fprintf(stdout, "[-, %d] ",
+                             A[embedding[cur].in_adjl].end_vertex);
+                     )
+    }
+    IF_DEB_FACES(
+                 fprintf(stdout, "\n");
+                 )
+}
+      
+
+
+boolean 
+embedg_check_recov_embedding (int n, int nbr_e, int nbr_comp,
+	t_ver_sparse_rep *vertices, t_adjl_sparse_rep *A,
+	t_embed_sparse_rep *embedding)
+    /*
+      check if the recovered embedding is a valid embedding
+      SHOULD ONLY be use after creation, that is, after having
+      recovered the embedding from the VES structure
+      (because of the mark MIN_EMBED_MARK we use)
+    */
+{
+    int          v, e, f;
+
+    f = 0;
+    /*
+      do all the edges in embedding:
+      careful: we have 2 * nbr_e to visit (the edge and its inverse!)
+    */
+    for (e = 0; e < 2 * nbr_e; e++)
+    {
+        /*
+          we check if the current edge is marked: if not, we
+          traverse a proper face bordered by this edge
+        */
+        if (embedding[e].mark != MIN_EMBED_MARK)
+            /*
+              we --hopefully-- perform this check only after creation
+              where mark == NIL
+            */
+        {
+            embedg_recov_embed_walk_proper_face(n, e, A, embedding,
+                                                TRUE, MIN_EMBED_MARK);
+            f++;
+        }
+    }
+
+    /*
+      must also count a face for each isolated vertex
+    */
+    for (v = 0; v < n; v++)
+    {
+        if (vertices[v].first_edge == NIL)
+            f++;
+    }
+    
+    IF_DEB_CHECK_EMBED(
+                       fprintf(stdout, "recovered embedding, n: %d\t e: %d\t C: %d\t f: %d\n",
+                               n, nbr_e, nbr_comp, f);
+                       )
+        
+    return f == 2 * nbr_comp + nbr_e - n ? TRUE : FALSE;
+}
+
+
+t_dlcl **
+embedg_recover_obstruction (t_ver_edge *embed_graph, int n, minor m, int *nbr_e)
+    /*
+      recover the obstruction as a t_dlcl * structure:
+      and return the number of edges: lets say we agree on returning
+      the number of undirected edges
+      -- I don't know yet which way to do, directed or undirected???
+
+      so far in the algorithm we only dealt with DFIs,
+      but now, we retrieve the obstruction not wrt DFIs but
+      wrt the vertices' labels
+    */
+{
+    /*
+      so I am looking, in embed_graph, for the vertices and edges
+      marked MARK_MINORS(n)
+    */
+
+    int          v;
+    t_dlcl       **obs;
+
+    obs = (t_dlcl **) mem_malloc(sizeof(t_dlcl *) * n);
+    for (v = 0; v < n; v++)
+        obs[v] = NP;
+
+    *nbr_e = 0;
+    for (v = 0; v < 2*n; v++)
+        /*
+          must check real vertices as well as virtual vertices
+        */
+    {
+        int      e;
+
+        if (embed_graph[v].link[0] == v)
+            /*
+              isolated vertex case
+            */
+        {
+            ASSERT(embed_graph[v].link[1] == v);
+            continue;
+        }
+
+        e = embed_graph[v].link[0];
+        while (e != v)
+        {
+            ASSERT(embedg_VES_is_edge(n, e));
+            if (embed_graph[e].visited == MARK_MINORS(n))
+            {
+                int        cur_v, neigh;
+
+                /*
+                  virtual vertices may still hang around
+                */
+                /*
+                  let's get the "actual" v:
+                  note that the statement below is safe since if v were
+                  not a valid virtual vertex (ie [v - n].DFS_parent = n)
+                  it would have an empty
+                  adjacency list and we wouldn't be there anyway
+                */
+                cur_v = embedg_VES_get_ver(embed_graph, n, v);
+        
+                neigh = embedg_VES_get_ver(embed_graph, n,
+                                           embed_graph[e].neighbour);
+
+                /*
+                  again, cur_v and neigh are DFIs,
+                  we want vertex labels at this stage
+                */
+                cur_v = embed_graph[cur_v].label;
+                neigh = embed_graph[neigh].label;
+                sparseg_dlcl_append_to_neigh_list(obs, n, cur_v, neigh,
+                                                  embed_graph[e].in_adjl);
+                (*nbr_e)++;
+            }
+            e = embed_graph[e].link[0];
+        }
+    }
+    
+    IF_DEB_OBS(
+               fprintf(stdout, "recovering the obstruction\n");
+               sparseg_dlcl_print(obs, n);
+    );
+
+    ASSERT(*nbr_e % 2 == 0);
+    *nbr_e /= 2;
+    
+    return obs;
+}
+
+
+static t_dlcl **
+embedg_get_reduced_obs (t_dlcl **obs, int n)
+    /*
+      reduce the obstruction by removing all degree 2 vertices
+      (so that they become isolated vertices)
+    */
+{
+    t_dlcl       **reduced;
+    int          v;
+
+    reduced =  (t_dlcl **) mem_malloc(sizeof(t_dlcl *) * n);
+    for (v = 0; v < n; v++)
+    {
+        reduced[v] = embedg_dlcl_copy(obs[v]);
+    }
+        
+    for (v = 0; v < n; v++)
+    {
+        t_dlcl   *n_l, *n_l_b, *p, *new_n_v, *n_l_x, *b_in_n_x;
+        int      a, b, n_x;
+
+        n_l = reduced[v];
+        while (!embedg_dlcl_is_empty(n_l)
+                && embedg_dlcl_list_last(n_l) == embedg_dlcl_list_next(n_l))
+            /*
+              pick out which  vertices have deg 2
+            */
+        {
+            a = n_l->info;
+            b = embedg_dlcl_list_next(n_l)->info;
+            /*
+              we remove the edge (v, b), or rather, we identify v and b:
+              b will then be an isolated vertex
+              
+              fix v's neighbour list: all of b's neighbours
+              are now v's neighbours
+            */
+            reduced[v] = n_l =
+                embedg_dlcl_delete_rec(n_l, embedg_dlcl_list_last(n_l));
+            
+            p = n_l_b = reduced[b];
+            ASSERT(!embedg_dlcl_is_empty(n_l_b));
+            n_x = p->info;
+            if (n_x != v)
+            {
+                new_n_v = embedg_dlcl_rec_new(n_x);
+                reduced[v] = n_l = embedg_dlcl_cat(n_l, new_n_v);
+                
+                /*
+                  and in n_x neighbour list, we must replace b by v
+                */
+                n_l_x = reduced[n_x];
+                b_in_n_x = embedg_dlcl_find(n_l_x, b);
+                b_in_n_x->info = v;
+            }
+            /*
+              and do this for all of b's neighbours
+            */
+            p = embedg_dlcl_list_next(p);
+            while (p != n_l_b)
+            {
+                n_x = p->info;
+                if (n_x != v)
+                {
+                    new_n_v = embedg_dlcl_rec_new(n_x);
+                    reduced[v] = n_l = embedg_dlcl_cat(n_l, new_n_v);
+                    n_l_x = reduced[n_x];
+                    b_in_n_x = embedg_dlcl_find(n_l_x, b);
+                    b_in_n_x->info = v;
+                }
+                p = embedg_dlcl_list_next(p);
+            }
+            embedg_dlcl_delete(reduced[b]);
+            reduced[b] = NP;
+        }
+    }
+
+    IF_DEB_CHECK_OBS(
+                     fprintf(stdout, "reducing the obstruction\n");
+                     sparseg_dlcl_print(reduced, n);
+                     )
+
+    /*
+      now check no degree 2 vertices are left
+    */
+    for (v = 0; v < n; v++)
+    {
+        t_dlcl   *n_l;
+        
+        n_l = reduced[v];
+        if (!embedg_dlcl_is_empty(n_l))
+        {
+            ASSERT(embedg_dlcl_list_last(n_l) != embedg_dlcl_list_next(n_l));
+        }
+    }
+
+    return reduced;
+}
+
+static boolean 
+embedg_is_red_obs_K33 (t_dlcl **reduced, int n)
+    /*
+      check if the (reduced) obstruction is indeed K33 
+    */
+{
+    int          v, order, vs[6], i, b1[3];
+    
+    /*
+      check that order == 6 and that the obstruction is cubic
+    */
+    order = 0;
+    for (v = 0; v < n; v++)
+    {
+        if (!embedg_dlcl_is_empty(reduced[v]))
+        {
+            if (order == 6)
+            {
+                return FALSE;
+            }
+            order++;
+            vs[order - 1] = v;
+            
+            if (embedg_dlcl_length(reduced[v]) != 3)
+            {
+                return FALSE;
+            }
+        }
+    }
+    if (order != 6)
+    {
+        return FALSE;
+    }
+    
+    /*
+      check if bipartite
+    */
+    v = vs[0];
+    ASSERT(!embedg_dlcl_is_empty(reduced[v]));
+    b1[0] = reduced[v]->info;
+    b1[1] = embedg_dlcl_list_next(reduced[v])->info;
+    b1[2] = embedg_dlcl_list_prev(reduced[v])->info;
+    
+    for (i = 1; i < 6; i++)
+    {
+        t_dlcl      *n_v;
+
+        v = vs[i];
+        n_v = reduced[v];
+        ASSERT(!embedg_dlcl_is_empty(n_v));
+        if (n_v->info == b1[0]
+            || embedg_dlcl_list_next(n_v)->info == b1[0]
+            || embedg_dlcl_list_prev(n_v)->info == b1[0])
+        {
+            if ((n_v->info != b1[1]
+                 && embedg_dlcl_list_next(n_v)->info != b1[1]
+                 && embedg_dlcl_list_prev(n_v)->info != b1[1])
+                &&
+                (n_v->info != b1[2]
+                 && embedg_dlcl_list_next(n_v)->info != b1[2]
+                 && embedg_dlcl_list_prev(n_v)->info != b1[2]))
+            {
+                return FALSE;
+            }
+        }
+        else
+        {
+            if ((n_v->info == b1[1]
+                 || embedg_dlcl_list_next(n_v)->info == b1[1]
+                 || embedg_dlcl_list_prev(n_v)->info == b1[1])
+                ||
+                (n_v->info == b1[2]
+                 || embedg_dlcl_list_next(n_v)->info == b1[2]
+                 || embedg_dlcl_list_prev(n_v)->info == b1[2]))
+            {
+                return FALSE;
+            }
+        }
+    }
+
+    return TRUE;
+}
+
+
+static boolean 
+embedg_is_red_obs_K5 (t_dlcl **reduced, int n)
+    /*
+      check if the (reduced) obstruction is indeed K5
+    */
+{
+    int          v, order;
+    
+    /*
+      check that order == 5 and that the obstruction is quadric
+    */
+    order = 0;
+    for (v = 0; v < n; v++)
+    {
+        if (!embedg_dlcl_is_empty(reduced[v]))
+        {
+            if (order == 5)
+            {
+                return FALSE;
+            }
+            order++;
+            
+            if (embedg_dlcl_length(reduced[v]) != 4)
+            {
+                return FALSE;
+            }
+        }
+    }
+
+    return TRUE;
+}
+
+
+boolean 
+embedg_check_recov_obs (t_dlcl **obs, int n, minor m)
+    /*
+      check if the recovered obstruction is one of K33 or K5
+    */
+{
+    t_dlcl      **reduced;
+    boolean     ans;
+
+    reduced = embedg_get_reduced_obs(obs, n);
+    if (m != MINOR_E5)
+    {
+        ans = embedg_is_red_obs_K33(reduced, n);
+    }
+    else
+    {
+        ans = embedg_is_red_obs_K5(reduced, n);
+    }
+
+    sparseg_dlcl_delete(reduced, n);
+    return ans;
+}
+/*
+ *  obstruction.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  The graph is not planar: we recover the obstruction from the VES structure
+  and check it as well.
+  (Some of these checks will disappear later)
+  
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+ 
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_VERB(x)   {}
+#define IF_DEB_OBS(x) {}
+#define IF_DEB_CHECK_OBS(x) {}
+#define IF_CPU(x) {}
+#define IF_DEB_MINOR(x) {}
+ 
+ 
+/* aproto: header embed_graph_protos.h */
+
+void 
+embedg_obstruction (
+    t_ver_sparse_rep *V,
+    t_adjl_sparse_rep *A,       /* the input graph as a sparse graph */
+    t_dlcl **dfs_tree,      /* a sparse graph rep. for the dfs tree
+                                      -- vertices are as DFIs
+                                      -- and children are ordered wrt
+                                      lowpoint value
+                                  */
+    t_dlcl **back_edges,    /* for each vertex v, a dlcl
+                                      of the back edges [v, x] incident to v
+                                      where x is a DESCENDANT of v
+                                      (vertices are given as DFIs)
+                                  */
+    t_ver_edge *embed_graph,    /* output of tester */
+    int n,               /* size of the graph */
+    int *edge_pos,       /* pos. in embed_graph for addition
+                                     of the next edge */
+    int v,
+    int w_in,         /* the unembedded directed back edge
+                                     [w_in, v]
+                                   */
+    t_ver_sparse_rep **OV,      /* the obstruction as an adjacency list */
+    t_adjl_sparse_rep **OA,
+    int *nbr_e_obs      /* obstruction's #edges */
+)
+                                    
+    /*
+      the graph is non planar: we must mark & recover the K33 or K5
+      homeomorph
+    */
+{
+    int          *ver_orient;
+    minor        m;
+    t_dlcl       **obs;
+    
+    /*
+      this is magma code - must be removed
+    */
+    float      sttime, time_to_now;
+ 
+ IF_CPU(
+    sttime = time_current_user();
+       )
+
+    /*
+      we will NOT remove the short-cut edges at this stage:
+      we'll have to perform another walkdown in embedg_iso_is_minor_A
+      so
+      1. saves time when looking for ext. active vertices
+      2. more importantly this enables us to ascertain that the number of
+         edges in embed_graph (even after completing whichever obstruction
+         applying in this case) will NEVER be > 3*n - 5!!!
+      3. SCEs are then removed in embedg_iso_is_minor_A
+         (obligatory path for every possible case)
+    */
+
+    /*
+      we must compute each vertex's orientation (wrt flipped bicomps)
+      and set the edges' orientation:
+      
+      the other day I was wondering why this was necessary in this
+      instance (because after all we won't get an embedding):
+      orientation is required bacause later in the piece we
+      do a proper face traversal (I guess for Minor C testing)
+    */
+    ver_orient = embedg_vertices_orientation(embed_graph, n);
+    embedg_VES_set_orientation(embed_graph, n, ver_orient);
+    mem_free(ver_orient);
+
+    m = embedg_mark_obstruction(dfs_tree, back_edges,
+                                embed_graph, n, edge_pos, v, w_in);
+
+    /*
+      get the obstruction
+    */
+    obs = embedg_recover_obstruction(embed_graph, n, m, nbr_e_obs);
+
+    /*
+      and check it
+    */
+    if (!embedg_check_recov_obs(obs, n, m))
+    {
+        sparseg_dlcl_delete(obs, n);
+        DIE();
+    }
+    
+    sparseg_dlcl_to_sparseg(obs, n, *nbr_e_obs, OV, OA);
+    sparseg_dlcl_delete(obs, n);
+
+    /*
+      just for the sake of it, chcek if the obstruction is
+      a subgraph of the input graph
+    */
+    if (!sparseg_adjl_sub(*OV, n, *OA, V, n, A))
+    {
+        DIE();
+    }
+    
+    IF_DEB_OBS(
+               sparseg_adjl_print(*V, n, *A, FALSE);
+               )
+    
+    IF_CPU(
+           fprintf(stdout, "CPU for obstruction recovering %f\n",
+                   (time_current_user() - sttime));
+           )
+}
+
+
+
+
+
+
+
+minor 
+embedg_mark_obstruction (
+    t_dlcl **dfs_tree,      /* a sparse graph rep. for the dfs tree
+                                      -- vertices are as DFIs
+                                      -- and children are ordered wrt
+                                      lowpoint value
+                                  */
+    t_dlcl **back_edges,    /* for each vertex v, a dlcl
+                                      of the back edges [v, x] incident to v
+                                      where x is a DESCENDANT of v
+                                      (vertices are given as DFIs)
+                                  */
+    t_ver_edge *embed_graph,    /* output of tester */
+    int n,               /* size of the graph */
+    int *edge_pos,       /* pos. in embed_graph for addition
+                                     of the next edge */
+    int v,
+    int w_in         /* the unembedded directed back edge
+                                     [w_in, v]
+                                   */
+)
+    /*
+      the graph is non planar: we must mark & recover the K33 or K5
+      homeomorph
+    */
+{
+    int          c, vr, x, y, w;
+    int          *path_v, *path_e, nbr_v, entry_in_path_e;
+    boolean      px_attached_high, py_attached_high, is_minor_D;
+    minor        m;
+    
+ 
+  IF_CPU(
+    float      sttime; float time_to_now;
+
+    sttime = time_current_user();
+        )
+    
+
+    /*
+      find c such that v^c is the root of the biconnected
+      component on which the walkdown failed
+    */
+    c = embedg_iso_get_c_of_v(embed_graph, n, v, w_in);
+
+    /*
+      now: decide which minor we are dealing with and mark the
+      appropriate one (vertices/edges marked as MARK_MINOR(n)
+      in embed_graph)
+    */
+    if (embedg_iso_is_minor_A(embed_graph, n, edge_pos, v, c, &vr))
+    {
+        embedg_mark_minor_A(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos, v, c, vr);
+        
+        IF_DEB_MINOR(
+                     fprintf(stdout, "Minor A\n");
+                     )
+
+        return MINOR_A;
+    }
+
+    /*
+      get the externally active vertices x & y and the pertinent w
+      on the external face of the bicomp rooted by v^c
+
+      and determine if minor B
+    */
+    if (embedg_iso_is_minor_B(embed_graph, n, edge_pos, v, c,
+                                   &x, &y, &w))
+    {
+        embedg_mark_minor_B(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos, v, c,
+                            x, y, w);
+        IF_DEB_MINOR(
+                     fprintf(stdout, "Minor B\n");
+                     )
+
+        IF_CPU(
+               fprintf(stdout, "CPU for obstruction isolation %f\n",
+                       time_current_user() - sttime);
+               )
+            
+        return MINOR_B;
+    }
+
+    /*
+      the remaining cases: must get the highest x-y path
+
+      it will be containing in path_v (vertices), path_e (edges)
+    */
+    embedg_iso_get_highest_x_y_path(embed_graph, n, MARK_EXT_FACE(n),
+                                    MARK_EXT_FACE_L(n),
+                                    MARK_EXT_FACE_R(n),
+                                    v, c, x, y, w,
+                                    &path_v, &path_e,
+                                    &nbr_v, &entry_in_path_e,
+                                    &px_attached_high,
+                                    &py_attached_high,
+                                    &is_minor_D);
+
+    /*
+      we are in the minor C case if either one of p_x or p_y
+      is attached high
+    */
+    if (px_attached_high || py_attached_high)
+    {
+        embedg_mark_minor_C(dfs_tree, back_edges, embed_graph, n, edge_pos,
+                            v, c, x, y, w,
+                            path_v, path_e, nbr_v,
+                            px_attached_high, py_attached_high);
+        IF_DEB_MINOR(
+                     fprintf(stdout, "Minor C\n");
+                     )
+
+        mem_free(path_v);
+        mem_free(path_e);
+        
+        IF_CPU(
+               fprintf(stdout, "CPU for obstruction isolation %f\n",
+                       time_current_user() - sttime);
+               )
+            
+        return MINOR_C;
+    }
+
+    if (is_minor_D)
+    {
+        embedg_mark_minor_D(dfs_tree, back_edges, embed_graph, n, edge_pos,
+                            v, c, x, y, w,
+                            path_v, path_e, nbr_v, entry_in_path_e);
+        IF_DEB_MINOR(
+                     fprintf(stdout, "Minor D\n");
+                     )
+
+        mem_free(path_v);
+        mem_free(path_e);
+        
+        IF_CPU(
+               fprintf(stdout, "CPU for obstruction isolation %f\n",
+                       time_current_user() - sttime);
+               )
+            
+        return MINOR_D;
+    }
+
+    /*
+      finally, the minor E case
+    */
+    m = embedg_mark_minor_E(dfs_tree, back_edges, embed_graph, n, edge_pos,
+                            v, c, x, y, w,
+                            path_v, path_e, nbr_v);
+    switch (m)
+    {
+    case MINOR_E1:
+        IF_DEB_MINOR(
+                     fprintf(stdout, "Minor E1\n");
+                     )
+        break;
+    case MINOR_E2:
+        IF_DEB_MINOR(
+                     fprintf(stdout, "Minor E2\n");
+                     )
+        break;
+    case MINOR_E3:
+        IF_DEB_MINOR(
+                     fprintf(stdout, "Minor E3\n");
+                     )
+        break;
+    case MINOR_E4:
+        IF_DEB_MINOR(
+                     fprintf(stdout, "Minor E4\n");
+                     )
+        break;
+    case MINOR_E5:
+        IF_DEB_MINOR(
+                     fprintf(stdout, "Minor E5\n");
+                     )
+        break;
+    case MINOR_A: 
+    case MINOR_B: 
+    case MINOR_C: 
+    case MINOR_D:
+    case MINOR_E:
+    case NBR_MINORS:
+        break;
+    }
+
+    mem_free(path_v);
+    mem_free(path_e);
+    
+    IF_CPU(
+           fprintf(stdout, "CPU (scaled) for obstruction isolation %f\n",
+                   (time_current_user() - sttime) / e);
+           )
+        
+    return m;
+}
+/*
+ *  isolator.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  The graph is non planar: we isolate the obstruction.
+  
+ 
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+ 
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+ 
+ 
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+ 
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+ 
+  Started October 2001
+*/
+ 
+ 
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_VERB(x)   {}
+#define IF_DEB_TREE(x)    {}
+#define IF_DEB_EDGES(x) {}
+#define IF_CPU(x) {}
+/* #define IF_DEB_MINOR(x) {x}  -- Not Used  */
+ 
+ 
+/* aproto: header embed_graph_protos.h */
+ 
+#ifndef PLANAR_IN_MAGMA
+#endif
+ 
+
+
+
+int 
+embedg_iso_get_c_of_v (t_ver_edge *embed_graph, int n, int v, int w)
+    /*
+      the edge [v, w] (w a descendant of v) remains unembedded
+      after the walkdown returns
+
+      find c such that v^c is the root of the biconnected
+      component on which the walkdown failed
+    */
+{
+    /*
+      how to do this??? easy! follow the DFS tree path as given
+      by the field DFS_parent
+    */
+
+    int           u;
+
+    u = embed_graph[w].DFS_parent;
+    while (embed_graph[u].DFS_parent != v)
+    {
+        u = embed_graph[u].DFS_parent;
+    }
+    /*
+      this is guaranteed to succeed given the structure of the DFS tree
+      and the fact that there exists a  back edge [w, v]
+    */
+    
+    return u;
+}
+
+
+boolean 
+embedg_iso_is_minor_A (t_ver_edge *embed_graph, int n,
+	int *edge_pos, int v, int c, int *vr)
+    /*
+      determines if the obstruction is a minor A
+    */
+{
+    /*
+      to do this we again call the walkdown routine with v^c as input,
+      the walkdown routine will fail (since there will be an
+      un-embedded back edge incident to v and to a vertex
+      in the subtree rooted by v^c)
+
+      the obstruction is a minor A if the merge queue returned by the
+      walkdown is non-empty, if this is the case we return
+      the bicomp last appended to the queue
+    */
+    int             vv;
+    t_merge_queue   q;
+
+    vv = c + n;
+    
+    q = embedg_walkdown(embed_graph, n, edge_pos, vv);
+    /*
+      we MUST remove the SCEs here: this is the only place where it
+      will be done when looking for and recovering an obstruction
+
+      this is safe since this very function applies to ALL cases!
+    */
+    embedg_remove_SCE(embed_graph, n, *edge_pos);
+
+    if (!embedg_merge_queue_empty(q))
+        /*
+          the bicomp of interest is the last in the queue
+        */
+    {
+        int         r, rin, vrout;
+        
+        embedg_merge_queue_prune(&q, &r, &rin, vr, &vrout);
+        embedg_merge_queue_delete(q);
+        return TRUE;
+    }
+    else
+    {
+        embedg_merge_queue_delete(q);
+        return FALSE;
+    }
+}
+
+
+void 
+embedg_iso_get_x_y_w (t_ver_edge *embed_graph, int n, int v, int r,
+	int c, int mark, int mark_l, int mark_r, int *x, int *y, int *w)
+    /*
+      the obstruction is one of minor B, C, D, E.
+      
+      get the externally active vertices x & y along the
+      external face  paths starting at r^c
+
+      get a pertinent vertex w along the lower external
+      face path between x and y
+
+      external activity and pertinence are wrt v
+      
+      all the vertices on the external face r^c...x...w
+      and r^c...y...w will be marked (the visited field)
+    */
+{
+    int          vr, vrin, x_y[4];
+    int          s, sin, cur, curin;
+
+    vr = c + n;
+
+    /*
+      find x and y first:
+
+      note that we mark the vertices on the external face r^c...x
+      and r^c...y
+
+      more on that below
+    */
+    embed_graph[vr].visited = mark;
+    for (vrin = 0; vrin <= 1; vrin++)
+    {
+        int      m;
+
+        m = vrin == 0 ? mark_l : mark_r;
+        embedg_VES_get_succ_ext_active_on_ext_face(embed_graph, n, v,
+                                                        vr, vrin,
+                                                        TRUE, m,
+                                                        &s, &sin);
+        x_y[vrin] = s;
+        x_y[vrin + 2] = sin;
+        /*
+          note the bizarre way I store the active vertex
+          and the direction out of which to continue a walk
+          on the lower external face as described above
+        */
+    }
+    *x = x_y[0];
+    *y = x_y[1];
+    
+    /*
+      next get the pertinent w on the lower external face from x to y
+    */
+    cur = x_y[0];
+    curin = x_y[2];
+    embedg_VES_get_succ_pertinent_on_ext_face(embed_graph, n, v,
+                                                   cur, curin,
+                                                   TRUE, mark_l, w, &sin);
+
+    /*
+      now all the vertices  r^c...x...w and r^c...y have been marked,
+      it remains to mark the vertices on the y...w external face path
+
+      (will need to be able to distinguish the external face  later on)
+
+      Note the way the external face is marked (needed when recovering
+      the highest x-y path):
+      mark_l for the path v^c...x...w
+      mark_r for the path v^c...y
+      mark for the lower external face y...w
+    */
+    cur = x_y[1];
+    curin = x_y[3];
+    s = n;
+    while (s != *w)
+    {
+        embedg_VES_get_succ_pertinent_on_ext_face(embed_graph, n, v,
+                                                       cur, curin,
+                                                       TRUE, mark, &s, &sin);
+        cur = s;
+        curin = sin;
+    }
+
+    IF_DEB(
+           fprintf(stdout, "get x, y & w: the external face\n");
+           fprintf(stdout, "%d\t", vr);
+           cur = vr;
+           curin = 0;
+           while (s != vr)
+           {
+               embedg_VES_get_succ_on_ext_face(embed_graph, n,
+                                                    cur, curin,
+                                                    FALSE, 0, &s, &sin);
+               cur = s;
+               curin = sin;
+               fprintf(stdout, "%d\t", s);
+           }
+           fprintf(stdout, "\n");
+           )
+}
+
+
+
+
+boolean 
+embedg_iso_is_minor_B (t_ver_edge *embed_graph, int n, int *edge_pos,
+	int v, int c, int *x, int *y, int *w)
+    /*
+      determines if the obstruction is a minor B and return x, y
+      (ext. active) and w (pertinent)
+    */
+{
+    /*
+      get x & y the ext. active vertices on the (external face)
+      path out of v^c,
+      and w the pertinent vertex on the lower external face x-y
+
+      PLUS mark the whole external face with MARK_EXT_FACE(n)
+    */
+    embedg_iso_get_x_y_w(embed_graph, n, v, v, c,
+                              MARK_EXT_FACE(n),
+                              MARK_EXT_FACE_L(n), MARK_EXT_FACE_R(n),
+                              x, y, w);
+
+    if (embedg_dlcl_is_empty(embed_graph[*w].pertinent_bicomp_list))
+        /*
+          w has no pertinent child bicomp: not a minor B
+        */
+        return FALSE;
+    else
+    {
+        t_dlcl      *pert_l;
+        int         l;
+
+        pert_l = embed_graph[*w].pertinent_bicomp_list;
+        l = embedg_dlcl_list_last(pert_l)->info;
+        /*
+          if w has an ext. active pertinent child bicomp then minor B
+
+          note that we need to know if w has an ext. active AND pertinent
+          bicomp child: so it is NOT good enough to test
+          w's separated_DFS_child_list as is done in
+          embedg_VES_is_ver_ext_active!!!!!!!!!
+
+          PLUS: l is actually a VIRTUAL vertex: to check its lowpoint
+          I must take its DFS child l - n !!!!!!!!
+        */
+        ASSERT(embedg_VES_is_virtual_vertex(n, l));
+        l = l - n;
+        return embed_graph[l].lowpoint < v ? TRUE : FALSE;
+    }
+}
+
+void 
+embedg_iso_get_highest_x_y_path (
+    t_ver_edge *embed_graph,
+    int n,
+    int mark,
+    int mark_l,
+    int mark_r,
+    int v,
+    int c,
+    int x,
+    int y,
+    int w,
+    int **path_v,     /* stack of vertices in x-y path */
+    int **path_e,     /* stack of egdes in x-y path */
+    int *nbr_v,         /* number of vertices in path_v */
+    int *entry_in_path_e, /* the in direction for the FIRST edge in
+                                      path_e: needed later on *sigh*
+                                   */
+    boolean *px_attached_high,
+    boolean *py_attached_high,
+    boolean *is_minor_D
+)
+    /*
+      the obstruction is one of minor C, D, E.
+
+      we want to recover the highest x-y path:
+      the obstructing path attached to the external faces v^c - x - w
+      and v^c - y - w
+
+      while doing all this we also determine if the case is a minor C
+      or a minor D
+    */
+{
+    /*
+      the path is obtained by walking the proper face starting at v
+      where ALL the edges incident to v^c BUT the ones bordering
+      the external face have been removed
+
+      I won't I don't think remove these edges, but instead I'll be
+      implementing an "avoidance" walk
+    */
+
+    int          vv, s, sin, p_x, p_y, cur_v, cur_vin;
+    int          e, ein, s_e, s_ein;
+    boolean      avoid_vv;
+    
+    /*
+      must start the walk at edge embed_graph[v^c].link[1 ^ 0],
+      (vvin = 0 is in direction of x, see embedg_iso_get_x_y_w)
+    */
+    vv = c + n;
+    e = embed_graph[vv].link[1];
+    ein = 0;     /* because of adjacency list consistency */
+
+    *path_v = (int *) mem_malloc(sizeof(int) * n);
+    *path_e = (int *) mem_malloc(sizeof(int) * n);
+    (*nbr_v) = -1;
+    
+    /*
+      recall that in embedg_iso_get_x_y_w we did mark
+      (with mark, mark_l, mark_r)
+      ALL the vertices lying on the external face walk starting
+      & ending at v^c: we will use this fact to enable us
+      to decide if a vertex is on the external face
+      (as opposed to being on the internal face)
+    */
+
+    s = embed_graph[e].neighbour;
+    ASSERT(embed_graph[s].visited == mark_l);
+    /*
+       this must be the case since s lies on the external face
+       starting at v^c in x's direction
+      -- we push s onto the stack
+    */
+    (*path_v)[++(*nbr_v)] = s;
+
+    /*
+      start the proper face walk which "avoids" v^c since the
+      internal edges incident to v^c are supposed to have
+      been removed
+
+      please read on
+    */
+    avoid_vv = FALSE;
+    while (TRUE)
+    {
+        boolean      av;
+        
+        av = 
+            embedg_VES_get_succ_on_proper_face_with_avoidance(
+                                                          embed_graph, n,
+                                                          e, ein, vv,
+                                                          FALSE, 0,
+                                                          &s, &s_e, &s_ein);
+        avoid_vv = av == TRUE ? av : avoid_vv;
+        if (embed_graph[s].visited == mark_l)
+            /*
+              means that s is still on the external face:
+              empty the path's stack and push s
+            */
+        {
+            (*nbr_v) = -1;
+            (*path_v)[++(*nbr_v)] = s;
+            e = s_e;
+            ein = s_ein;
+        }
+        else if (*nbr_v == 0)
+            /*
+              s is the first encountered vertex after
+              path_v[0] which does not
+              lie on the external face v^c...c...w
+
+              given the way we pushed things on the vertex stack, path_v[0]
+              will be the point of attachement of the x-y path
+              on the v^c...x...w external face
+
+              path_e[0] will contain nothing: a dummy
+              
+              path_e[1] will be the first edge in the x-y path
+              (and entry_in_path will give the in-direction to this edge)
+              
+              oh yes!, we break the loop at this point if
+              the vertex s lies on the v^c...y...w external face
+            */
+        {
+            ASSERT(embed_graph[(*path_v)[0]].visited == mark_l);
+            /*
+              the first vertex on the path must be on the
+              v^c...x...w external face
+            */
+            (*path_v)[++(*nbr_v)] = s;
+            /*
+              and now we also push the edge on the edge stack
+
+              I'll need this later to initiate a proper face walk
+              starting at the first vertex/edge in the x-y path,
+              which is the same as starting from s_e
+            */
+            (*path_e)[*nbr_v] = s_e;
+            *entry_in_path_e = s_ein;
+            e = s_e;
+            ein = s_ein;
+
+            /*
+              since we are at the start of the path, we must not
+              forget to reset avoid_vv
+            */
+            avoid_vv = FALSE;
+            
+            if (embed_graph[s].visited == mark_r
+                || embed_graph[s].visited == mark)
+                /*
+                  we have reached the v^c...y...w external face:
+                  we can stop here
+                */
+            {
+                break;
+            }
+
+            /*
+              if not finished yet,
+              we also mark s (and path_v[0]) as visited:
+              later on we'll need to recognise which of the vertices
+              in path have already been encountered
+              (in case of encountering a cut-vertex due to the
+              "removal" of the "internal" edges incidnet ot v^c)
+
+              note that we mark s as visited iff s if not already
+              on the v^c..y..w external face
+            */
+
+            ASSERT(embedg_VES_is_vertex(n, (*path_v)[0]));
+            ASSERT(embedg_VES_is_vertex(n, s));
+
+            embed_graph[s].visited = MARK_X_Y_PATH(n);
+        }
+        else  if (embed_graph[s].visited == MARK_X_Y_PATH(n))
+            /*
+              this means that s is a cut vertex on the internal
+              face walk: pop all the vertices from path
+              until s's last occurrence in path
+            */
+        {
+            ASSERT((*nbr_v) >= 0);
+            while ((*path_v)[(*nbr_v)] != s)
+            {
+                (*nbr_v)--;
+                ASSERT((*nbr_v) >= 0);
+                /*
+                  note that s should be somewhere in path!
+                */
+            }
+            /*
+              note also that popping from path_v also implies
+              popping from path_e
+            */
+            e = s_e;
+            ein = s_ein;
+        }
+        else
+            /*
+              we push s and s_e on their respective stacks
+            */
+        {
+            (*path_v)[++(*nbr_v)] = s;
+            (*path_e)[*nbr_v] = s_e;
+            e = s_e;
+            ein = s_ein;
+            
+            if (embed_graph[s].visited == mark_r
+                || embed_graph[s].visited == mark)
+                /*
+                  again, s lies on the v^c...y...w external face:
+                  we end the walk: path_v now contains the highest x-y path
+
+                  note that there can be no conflict between
+                  mark_r or mark and MARK_X_Y_PATH(n) since
+                  we mark with MARK_X_Y_PATH iff the vertex
+                  is NOT marked with mark_r/mark!
+                */
+            {
+                break;
+            }
+            else
+                /*
+                  we must mark this vertex as MARK_X_Y_PATH since we aren't
+                  finished yet
+                */
+            {
+                embed_graph[s].visited = MARK_X_Y_PATH(n);
+            }
+        }
+    }
+
+    /*
+      there is only one thing remaining to do: see if p_x or
+      p_y are attached high
+      (ie closer to v^c than x or y resp.)
+
+      we walk the external face starting at v^c in y's direction
+      (again see embedg_iso_get_x_y_w)
+    */
+    *px_attached_high = TRUE;
+    p_x = (*path_v)[0];
+    /*
+      p_y denotes the attachement point of the x-y path
+      on the v^c...y...w external face
+    */
+
+    s = n;
+    cur_v = vv;
+    cur_vin = 0;
+    while (s != p_x)
+    {
+        embedg_VES_get_succ_on_ext_face(embed_graph, n,
+                                             cur_v, cur_vin,
+                                             FALSE, 0, &s, &sin);
+        if (s == x)
+        {
+            *px_attached_high = FALSE;
+            break;
+        }
+        cur_v = s;
+        cur_vin = sin;
+    }
+
+    *py_attached_high = TRUE;
+    p_y = (*path_v)[*nbr_v];
+    /*
+      p_y denotes the attachement point of the x-y path
+      on the v^c...y...w external face
+    */
+
+    s = n;
+    cur_v = vv;
+    cur_vin = 1;
+    while (s != p_y)
+    {
+        embedg_VES_get_succ_on_ext_face(embed_graph, n,
+                                             cur_v, cur_vin,
+                                             FALSE, 0, &s, &sin);
+        if (s == y)
+        {
+            *py_attached_high = FALSE;
+            break;
+        }
+        cur_v = s;
+        cur_vin = sin;
+    }
+
+    /*
+      now we are in the minor C case if either p_x or p_y are
+      attached high
+
+      the minor D case:
+      this happens when there is a path v^c - z where z lies
+      on the x-y path
+
+      that is, when
+      
+      either v^c has been effectively "avoided" within the
+      embedg_VES_get_succ_on_proper_face_with_avoidance function
+      BUT ONLY if this "avoidance" happened AFTER having
+      encountered the very first vertex on the x-y path!
+
+      or when a cut vertex has been encountered on the x-y path:
+      separable components on this walk can only occur
+      if one walks the face while skipping the edges incident to v^c
+
+      in any case this means that checking the return from 
+      the embedg_VES_get_succ_on_proper_face_with_avoidance function
+      is enough: this is the purpose of avoid_vv.
+    */
+
+    *is_minor_D = !(*px_attached_high || *py_attached_high) && avoid_vv;
+
+
+    IF_DEB(
+           int    i;
+           
+           fprintf(stdout, "x-y path\t");
+           for (i = 0; i <= *nbr_v; i++)
+               fprintf(stdout, "%d\t", (*path_v)[i]);
+           fprintf(stdout, "\n");
+           )
+}
+
+
+/*
+ *  embedg_misc.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  Some high level routinse for the VES structure.
+  See VES_misc.c.
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+ 
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_VERB(x)   {}
+#define IF_DEB_TREE(x)    {}
+ 
+ 
+ 
+/* aproto: header embed_graph_protos.h */
+ 
+#ifndef PLANAR_IN_MAGMA
+#endif
+ 
+
+
+
+void 
+embedg_VES_delete (t_ver_edge *embed_graph, int n)
+{
+    int          i;
+
+    for (i = 0; i < n; i++)
+    {
+        embedg_dlcl_delete(embed_graph[i].separated_DFS_child_list);
+        /*
+          embedg_dlcl_delete(embed_graph[i].rep_in_parent_list);
+
+          NO!!! this points to something in separated_DFS_child_list
+        */
+        embedg_dlcl_delete(embed_graph[i].pertinent_bicomp_list);
+    }
+    mem_free(embed_graph);
+}    
+
+
+
+void 
+embedg_VES_print (t_ver_edge *embed_graph, int n)
+{
+    int          i;
+
+    fprintf(stdout, "vertices\n");
+    for (i = 0; i < n; i++)
+    {
+        t_ver_edge   rec;
+
+        rec = embed_graph[i];
+
+        fprintf(stdout, "\nDFI\t%d\tlabel\t%d\n", i, rec.label);
+        fprintf(stdout, "DFS parent\t%d\tleast_a\t%d\tlowpoint\t%d\n",
+                rec.DFS_parent, rec.least_ancestor, rec.lowpoint);
+        fprintf(stdout, "separated_DFS_child_list\n");
+        embedg_dlcl_print(rec.separated_DFS_child_list);
+    }
+
+    fprintf(stdout, "\nvirtual vertices\n");
+    for (i = n; i < 2*n; i++)
+    {
+        int          c;
+        
+        c = i - n;
+        fprintf(stdout, "%d^%d\t", embed_graph[c].DFS_parent, c);
+    }
+    fprintf(stdout, "\n");
+    
+    embedg_VES_print_bigcomps(embed_graph, n);
+}
+
+
+void 
+embedg_VES_print_bigcomps (t_ver_edge *embed_graph, int n)
+    /*
+      walking the external faces of all the bicomp; for testing only
+    */
+{
+    int          i;
+ 
+    fprintf(stdout, "bicomponents\n");
+    /*
+      to get to the bicomps, it makes sense to start at the
+      virtual vertices????
+    */
+    for (i = n + 1; i < 2*n; i++)
+        /*
+          a note of caution: there is no virtual vertex at
+          embed_graph[n] since that would mean a virtual vertex x^0
+          which makes no sense (0 is the root of the dfs_tree)
+        */
+    {
+        embedg_VES_walk_bicomp(embed_graph, n, i, 0);
+    }
+    fprintf(stdout, "\n");
+}
+/*
+ *  planar_alg_init.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  Initialising the embed_graph aka VES data structure from the information
+  collected from the DFS.
+
+  The embed_graph/VES data structure is an array consisting of vertices,
+  virtual vertices and edges;
+  vertices, virtual vertices and edges share a common record structure;
+  one of the particular features is that any vertex is linked
+  together with its incident edges into a doubly circular linked list.
+
+  See also VES_misc.c.
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+ 
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_DEB_DFS(x) {}
+#define IF_VERB(x)   {}
+#define IF_DEB_TREE(x)    {}
+#define IF_CPU(x) {}
+ 
+ 
+/* aproto: header embed_graph_protos.h */
+
+/* aproto: beginstatic -- don't touch this!! */
+static void embedg_init_insert_TE (t_ver_edge *, int, int *, t_dlcl *);
+/* aproto: endstatic -- don't touch this!! */
+ 
+#ifndef PLANAR_IN_MAGMA
+#endif
+
+
+t_ver_edge *
+embedg_planar_alg_init (
+    t_ver_sparse_rep *V,
+    int n,
+    t_adjl_sparse_rep *A,        /* input sparse graph */
+    int *nbr_c,        /* size of the graph, #components*/
+    int *edge_pos,        /* pos in the struct where the last edge
+                                      has been inserted
+                                   */
+    t_dlcl ***dfs_tree,      /* a sparse graph rep. for the dfs tree
+                                      -- vertices are as DFIs
+                                   */
+    t_dlcl ***back_edges,    /* for each vertex v, a dlcl
+                                      of the back edges [v, x] incident to v
+                                      where x is a DESCENDANT of v
+                                      -- vertices are as DFIs
+                                   */
+    t_dlcl ***mult_edges    /* for each vertex v, a dlcl
+                                      of the back edges [v, x] incident to v
+                                      where x is a DESCENDANT of v
+                                      -- vertices are as DFIs
+                                   */
+)
+    /*
+      initialising embed_graph, the fundamental data structure
+      underpinning the tester and obstruction isolator
+
+      from there on, a vertex is exclusively referred to by its DFI!!
+      -- so forget about labels
+    */
+{
+    int          *dfs_nbr;        /* dfs numbering for each vertex */
+    int          *dfs_order;      /* vertices in dfs order */
+    int          *lowpoint;       /* lowpoint value for each DFI */
+    int          *dfs_parent;     /* for each DFI, its DFS ancestor 
+                                     as a DFI (DFS index)
+                                  */
+    int          *least_a;        /* for each DFI, its least ancestor's DFI
+                                     (via a back edge exclusively)
+                                  */
+
+    t_ver_edge   *embed_graph;
+    int          i;
+
+
+  IF_CPU(
+    float      sttime;  float time_to_now;
+ 
+    sttime = time_current_user();
+       )
+
+    ASSERT(n >= 1);
+
+    /*
+      DFS and lowpoint calculations + ordering 
+    */
+    sparseg_adjl_dfs_preprocessing(V, n, A, nbr_c,
+                                   &dfs_nbr, &dfs_order, &lowpoint,
+                                   dfs_tree, back_edges,
+                                   &dfs_parent, &least_a, mult_edges);
+
+    IF_CPU(
+           fprintf(stdout, "CPU for DFS only %f\n",
+                   (time_current_user() - sttime));
+    sttime = time_current_user();
+           )
+ 
+    IF_DEB_DFS(     
+            fprintf(stdout, "DFS indices\n");
+            for (i = 0; i < n; i++)
+            fprintf(stdout, "%d ", dfs_nbr[i]);
+            fprintf(stdout, "\n");
+            
+            fprintf(stdout, "DFS order\n");
+            for (i = 0; i < n; i++)
+            fprintf(stdout, "%d ", dfs_order[i]);
+            fprintf(stdout, "\n");
+            
+            fprintf(stdout, "lowpoint values\n");
+            for (i = 0; i < n; i++)
+            fprintf(stdout, "%d ", lowpoint[i]);
+            fprintf(stdout, "\n");
+            );
+    
+    IF_VERB(
+            fprintf(stdout, "DFS parent\n");
+            for (i = 0; i < n; i++)
+                fprintf(stdout, "%d ", dfs_parent[i]);
+            fprintf(stdout, "\n");
+            );
+
+    IF_VERB(
+            fprintf(stdout, "least ancestors\n");
+            for (i = 0; i < n; i++)
+                fprintf(stdout, "%d ", least_a[i]);
+            fprintf(stdout, "\n");
+            );
+    
+    IF_VERB(
+            for (i = 0; i < n; i++)
+            {
+                fprintf(stdout, "the list of children ordered by lowpoint for %d\n",
+                        i);
+                embedg_dlcl_print((*dfs_tree)[i]);
+            }
+            );
+
+    IF_DEB_DFS(
+            fprintf(stdout, "the tree edges\n");
+            sparseg_dlcl_print(*dfs_tree, n);
+            
+            fprintf(stdout, "the back edges\n");
+            sparseg_dlcl_print(*back_edges, n);
+ 
+            fprintf(stdout, "multiple edges\n");
+            sparseg_dlcl_print(*mult_edges, n);
+            );
+    
+    /*
+      create the data structure for the embedded graph:
+      it will have (max) size 2*n + 2 * MAXE(n)
+
+      we will see that that number of edges is sufficient
+      even when later adding short-cut edges (see embedg_walkdown)
+    */
+    embed_graph = (t_ver_edge *) mem_malloc(sizeof(t_ver_edge)
+                                            * (2*n + 2 * MAXE(n)));
+    /*
+      initialisation
+    */
+    for (i = 0; i < 2*n + 2 * MAXE(n); i++)
+        /*
+          some fields are initialised to n as n is actually
+          an "invalid" value 
+        */
+    {
+        t_ver_edge   rec;
+  
+        rec.label = NIL;
+        rec.DFS_parent = n;
+        rec.least_ancestor = n;
+        rec.lowpoint = n;
+        rec.separated_DFS_child_list = NP;
+        rec.rep_in_parent_list = NP;
+        rec.pertinent_bicomp_list = NP;
+        rec.adjacent_to = n;
+        rec.visited = n;
+        rec.neighbour = n;
+        rec.in_adjl = NIL;
+        rec.twin_in_adjl = NIL;
+        rec.mult = 0;
+        rec.type = NIL;
+        rec.sign = NILSIGN;
+        /*
+          make the links refer back to self
+        */
+        rec.link[0] = rec.link[1] = i;
+ 
+        embed_graph[i] = rec;
+    }
+    
+    /*
+      embed_graph[0..n-1]: the n vertices
+      ATTENTION: the vertices are stored according to their DFS numbering
+    */
+    for (i = 0; i < n; i++)
+    {
+        t_ver_edge   rec;
+
+        rec = embed_graph[i];
+
+        rec.label = dfs_order[i];
+        rec.DFS_parent = dfs_parent[i];
+        rec.least_ancestor = least_a[i];  
+        rec.lowpoint = lowpoint[i];
+        rec.separated_DFS_child_list = embedg_dlcl_copy((*dfs_tree)[i]);
+
+        IF_VERB(
+                fprintf(stdout, "the list of children ordered by lowpoint for DFI %d\n",
+                        i);
+                embedg_dlcl_print(rec.separated_DFS_child_list);
+        );
+
+        embed_graph[i] = rec;
+    }
+    
+    /*
+      one more thing to do for these vertices:
+      fix the rep_in_parent_list field
+    */
+    for (i = 1; i < n; i++)
+    {
+        t_dlcl       *parent_list, *rep;
+        int          parent;
+
+        parent = embed_graph[i].DFS_parent; /* careful: this is a DFI  */
+        /*
+          recall that the vertices in embed_graph are accessed via their DFI
+        */
+
+        if (parent != n)
+            /*
+              when parent == n this means that i the root of a DFS tree
+              in the disconnected graph
+            */
+        {
+            parent_list = embed_graph[parent].separated_DFS_child_list;
+            rep = embedg_dlcl_find(parent_list, i);
+            ASSERT(rep != NP);
+            embed_graph[i].rep_in_parent_list = rep;
+        }
+    }
+
+    /*
+      embed_graph[n..2*n-1]: the n virtual vertices
+      do I need to do anything here?????
+
+      no - I don't think so
+
+      let's try to explain what virtual vertices are:
+      let v^c be a virtual vertex:
+      - it is at position  c + n in the array,
+      - c is the DFS child of v,
+      - v can be retrieved by taking embed_graph[c].DFS_parent,
+      - v^c is said virtual as long as the bicomp rooted by v^c is not
+        merged with the vertex v
+      - once v is merged (identified?) with v^c, then v^c
+        is of no relevance anymore
+
+      below we will see that we embed all the tree edges as singleton
+      bicomps (bicomponent): (0^1, 1), (1^2, 2) etc...:
+      this is what virtual vertices are there for:
+      to distinguish them from their "real" counterpart with
+      which they will be ultimately merged
+
+      the primary reason for this is:
+      while testing for planarity virtual vertices are the roots of bicomps
+    */
+
+    /*
+      now the edges:
+      we actually embed the tree edges so that each tree edge
+      forms a (singleton) biconnected component
+
+      embedding an edge in effect means creating the
+      doubly linked circular list of [virtual] vertices & the edges incident
+      to it
+
+      this list is built using the links 0 & 1 in embed_graph[i]
+    */
+
+    /*
+      for each tree edge (v,u) we embed (v^u, u) (v^u is the virtual vertex)
+
+      CAREFUL: when talking about vertex v say, 
+      we mean the vertex with DFI v, and NOT the vertex with label v
+      **************************************************************
+    */
+    *edge_pos = 2*n - 1;
+    /*
+      edge_pos will tell us where to insert the next edge in embed_graph[]
+    */
+    for (i = 0; i < n; i++)
+    {
+        t_dlcl     *te_l, *p;
+
+        te_l = (*dfs_tree)[i];
+        p = te_l;
+ 
+        if (!embedg_dlcl_is_empty(p))
+        {
+            /*
+              the test below is a bit stupid... well...
+            */
+            ASSERT(embed_graph[p->info].DFS_parent == i);
+
+            embedg_init_insert_TE(embed_graph, n, edge_pos, p);
+            p = embedg_dlcl_list_next(p);
+            while (p != te_l)
+            {
+                ASSERT(embed_graph[p->info].DFS_parent == i);
+                embedg_init_insert_TE(embed_graph, n, edge_pos, p);
+
+                p = embedg_dlcl_list_next(p);
+            }
+        }
+    }
+    
+    mem_free(dfs_nbr);
+    mem_free(dfs_order);
+    mem_free(lowpoint);
+
+    mem_free(dfs_parent);
+    mem_free(least_a);
+    
+    IF_CPU(
+           fprintf(stdout, "CPU for remainder of initialisation %f\n",
+                   (time_current_user() - sttime));
+           )
+
+    return embed_graph;
+}
+
+
+static void
+embedg_init_insert_TE (t_ver_edge *embed_graph, int n, int *edge_pos, t_dlcl *p)
+    /*
+      init and insert a tree edge in embed graph:
+      
+      the tree edge will form a singleton bicomponent (v^c, c)
+      where c is p->info and v is c.DFS_parent
+    */
+{
+    int             c, v;
+
+    c = p->info;
+    v = embed_graph[c].DFS_parent;
+    ASSERT(v >= 0 && v < n);
+    
+    /*
+      now (v, c) is a tree edge; embed the directed edge [v^c, c]
+      
+      -- and recall that v^c is a virtual vertex, at position  c + n
+      in embed_graph, and that vertex c is at position c
+    */
+    
+    /*
+      first, set this edge with the appropriate info
+    */
+    (*edge_pos)++;
+    ASSERT(*edge_pos < 2*n + 2 * MAXE(n));
+    embed_graph[*edge_pos].neighbour = c;
+    embed_graph[*edge_pos].in_adjl = p->in_adjl;
+    embed_graph[*edge_pos].twin_in_adjl = p->twin_in_adjl;
+
+    ASSERT(p->mult % 2 == 0);
+    /*
+      we want the number of undirected edges
+    */
+    embed_graph[*edge_pos].mult = p->mult / 2;
+    embed_graph[*edge_pos].type = TE;
+    embed_graph[*edge_pos].sign = CCLOCKW;
+        
+    /*
+      link this with vertex v^c in a doubly linked circular list
+    */
+    embed_graph[c + n].link[0] =
+        embed_graph[c + n].link[1] = *edge_pos;
+    embed_graph[*edge_pos].link[0] =
+        embed_graph[*edge_pos].link[1] = c + n;
+        
+    /*
+      now create/set the twin edge, the directed edge [c, v^c] 
+    */
+    (*edge_pos)++;
+    ASSERT(*edge_pos < 2*n + 2 * MAXE(n));
+    embed_graph[*edge_pos].neighbour = c + n;
+    embed_graph[*edge_pos].in_adjl = p->twin_in_adjl;
+    embed_graph[*edge_pos].twin_in_adjl = p->in_adjl;
+    embed_graph[*edge_pos].mult = p->mult / 2;
+    embed_graph[*edge_pos].type = TE;
+    embed_graph[*edge_pos].sign = CCLOCKW;
+    
+    /*
+      and link it with vertex c in a doubly linked circular list
+    */
+    embed_graph[c].link[0] = embed_graph[c].link[1] = *edge_pos;
+    embed_graph[*edge_pos].link[0] =
+        embed_graph[*edge_pos].link[1] = c;
+}
+/*
+ *  dfs_preprocessing.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  A DFS as an initialisation step for the planarity tester.
+  This is an especially beefed up DFS that collects lots of
+  marginal information:
+
+  - a DFS tree as a list of DFS children for each vertex
+  - the DFS children are sorted according to their lowpoint value
+  - a back_edge structure as a list of descendants v for each
+    vertex u such that [v, u] is a back edge
+  - a multiple edges structure which stores multiple (directed) edges
+    NOT in the DFS tree nor in the back_edge struc, and loops
+    
+  - the vertices in DFS order
+  - the DFS index (DFI) for each vertex
+  - the lowpoint value for each vertex
+  - the number of components of the (possibly disconnected) graph
+  - for each vertex, its DFS parent
+  - for each vertex v, its least ancestor u such that [v, u]
+    is a back edge
+
+  ALL info above (except the vertices in DFS order) is given
+  in terms of the vertices' DFIs and NOT their labels.
+  
+
+    
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+ 
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+ 
+ 
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+ 
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+ 
+  Started October 2001
+*/
+
+
+/*
+  There are some dodgy things which need some thought; it would be nice
+  to fix them so that the code get's cleaner:
+
+  - we do store in_adj (and twin_in_adjl) for each directed edge:
+  
+    + this is ONLY needed at the time of recovering the embedding
+      (see embedg_recover_embedding) and its sole use is to establish
+      a link between an edge in the embedding structure
+      t_embed_sparse_rep  *E and the corresponding edge
+      in the t_adjl_sparse_rep   *A struc.
+
+    + well, I cannot recall why I thought this correspondence
+      was needed in the first place and it might well be the case
+      that there is no use for it; in which case recovering the
+      embedding is simplified
+      (we would store the end-vertex in the embedding's edges instead
+      of their index in the adjacency list)
+
+  - there are some non-linear bits in the DFS below: when searching
+    for an already existing tree/back/multiple edge.
+    I couldn't fix this in less then one hour so I leave it as it is...
+    for now.
+
+    This shouldn't be a major issue, overall timings of the planarity
+    tester do not show this non-linear "bump"...
+
+  - also, this algorithm has been growing incrementally and I now
+    realise that I am using some redundant data structures:
+    for example visited[] and the vertex and could be dispensed with...
+    ...more things to clean up...
+
+    Paulette  07/02/02
+*/
+ 
+
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_VERB(x)   {}
+#define IF_DEB_TREE(x)    {}
+ 
+ 
+/* aproto: header embed_graph_protos.h */
+ 
+#ifndef PLANAR_IN_MAGMA
+#endif
+ 
+
+void 
+sparseg_adjl_dfs_preprocessing (
+    t_ver_sparse_rep *V,
+    int n,                /* size of the graph */
+    t_adjl_sparse_rep *A,        /* input sparse graph */
+    int *c,               /* nbr of components */
+    int **dfs_nbr,        /* dfs numbering for each vertex */
+    int **dfs_order,      /* vertices in dfs order */
+    int **lowpoint,       /* lowpoint value for each DFI */
+    t_dlcl ***dfs_tree,      /* a sparse graph rep. for the dfs tree:
+                                      for each DFI, a list of its children's
+                                      DFI ordered wrt their lowpoint values
+                                   */
+    t_dlcl ***back_edges,    /* for each DFI  v, a dlcl
+                                      of the back edges [v, x] incident to v
+                                      where x is a DESCENDANT of v */
+    int **dfs_parent,     /* for each DFI its DFS ancestor */
+    int **least_a,        /* for each DFI, its least ancestor's DFI
+                                      via a back edge exclusively */
+    t_dlcl ***mult_edges    /*  for each DFI  v, a dlcl
+                                       of the multiple directed
+                                       edges NOT included
+                                       in either dfs_tree or back_edges
+                                   */
+)
+
+    /*
+      in ALL the returned info above BUT dfs_order[] we store
+      the vertices' DFIs (DFS indices) and NOT their labels!
+
+      -- shuffling between labels and vertices can then be done
+         via dfs_nbr[] and dfs_order[]
+    */
+{
+    int            pos_v_stack, pos_e_stack, dfs_n;
+    int            *visited, *vertex_stack, *edge_stack, *lowpoint_order;
+    int            *TE_in_adjl, *TE_twin_in_adjl, *TE_mult;
+    int            v, lp, cur, cur_e, next;
+    t_dlcl         **temp, *lowpoint_list, **new_dfs_tree;
+    
+    /*
+      create the dfs tree as a sparse graph
+    */
+    *dfs_tree = (t_dlcl **) mem_malloc(sizeof(t_dlcl *) * n);
+    /*
+      the DFS numbering for the vertices
+    */
+    *dfs_nbr = (int *) mem_malloc(sizeof(int) * n);
+    /*
+      the vertices as ordered by their DFS index
+    */
+    *dfs_order = (int *) mem_malloc(sizeof(int) * n);
+    /*
+      the lowpoint value for each DFI
+    */
+    *lowpoint = (int *) mem_malloc(sizeof(int) * n);
+
+    /*
+      the (directed) back edges
+    */
+    *back_edges = (t_dlcl **) mem_malloc(sizeof(t_dlcl *) * n);
+
+
+    /*
+      the DFS parent for each DFI
+    */
+    *dfs_parent = (int *) mem_malloc(sizeof(int) * n);
+    /*
+      the least ancestor (via a back edge exlusively) for each DFI
+    */
+    *least_a = (int *) mem_malloc(sizeof(int) * n);
+    
+    /*
+      the (directed) multiple edges
+    */
+    *mult_edges = (t_dlcl **) mem_malloc(sizeof(t_dlcl *) * n);
+
+    /*
+      the vertices visited while DFS
+    */
+    visited = (int *) mem_malloc(sizeof(int) * n);
+    /*
+      stack of vertices: last current vertex
+    */
+    vertex_stack = (int *) mem_malloc(sizeof(int) * n);
+    /*
+      stack of (tree) edges: last added tree edge
+    */
+    edge_stack = (int *) mem_malloc(sizeof(int) * n);
+    
+    /*
+      the following will be used in order to recreate the dfs_tree
+      so that the DFS children of each DFI are ordered
+      according to their lowpoint value
+    */
+    lowpoint_order = (int *) mem_malloc(sizeof(int) * n);
+    temp = (t_dlcl **) mem_malloc(sizeof(t_dlcl *) * n);
+    new_dfs_tree = (t_dlcl **) mem_malloc(sizeof(t_dlcl *) * n);
+
+    /*
+      finally, three more holding arrays: a trick to remember which
+      tree edges we are talking about:
+
+      when constructing dfs_tree, back_edges, mult_edges
+      - we NEED to record the index in A (the adjacency list)
+        of some of the edges and their twins/inverses
+        we are currently storing in either of these structures
+      - we also need to record the number of multiple (directed)
+        edges we encounter  when the graph is not simple
+      
+      this is easy to do when storing back edges and multiple edges,
+      and tree edges also: but this lattest set of neighbour lists (dfs_tree)
+      is subsequently reordered so that DFS children are ordered
+      wrt lowpoint values;
+      - consequently the info about position in adjacency list
+      and edge multiplicity are lost in the ordering process
+
+      the two following arrays will remember the info we'll need later
+      - more about this below
+    */
+    TE_in_adjl = (int *) mem_malloc(sizeof(int) * n);
+    TE_twin_in_adjl = (int *) mem_malloc(sizeof(int) * n);
+    TE_mult = (int *) mem_malloc(sizeof(int) * n);
+    
+    
+    /*
+      initialization of the data structures
+    */
+    for (v = 0; v < n; v++)
+    {
+        (*dfs_tree)[v] = (*back_edges)[v] = (*mult_edges)[v] = NP;
+        visited[v] = TE_mult[v] = 0;
+        (*dfs_parent)[v] = (*least_a)[v] = n;
+        temp[v] = new_dfs_tree[v] = NP;
+        TE_in_adjl[v] = TE_twin_in_adjl[v] = NIL;
+        /*
+          note that in the 3rd last statement n is considered
+          as an "invalid" value;
+          will be if importance in the overall algorithm
+        */
+    }
+    
+    /*
+      the DFS tree is rooted at vertex 0
+    */
+    dfs_n = -1;
+    pos_v_stack = -1;
+    pos_e_stack = -1;
+    *c = 0;
+    for (v = 0; v < n; v++)
+    {
+        if (visited[v])
+            /*
+              we come only at this level when looking for
+              a new subtree (when graph is disconnected)
+            */
+        {
+            continue;
+        }
+        else
+        {
+            (*c)++;
+        }
+        
+        cur = v;
+        visited[cur] = 1;
+        (*dfs_nbr)[cur] = ++dfs_n;
+        (*lowpoint)[(*dfs_nbr)[cur]] = dfs_n;
+        (*dfs_order)[dfs_n] = cur;
+
+        cur_e = V[cur].first_edge == NIL ? NIL : V[cur].first_edge;
+        while (TRUE)
+        {
+            if (cur_e != NIL)
+            {
+                t_dlcl        *existing_e;
+                
+                next = A[cur_e].end_vertex;
+                if (!visited[next])
+                    /*
+                      adding tree edges (careful: directed edges)
+                      
+                      AND tree edges are stored as 
+                      [dfs_nbr[u], dfs_nbr[cv]]
+                      instead of [u, cv]: that is we store the edges
+                      according to the vertices' DFIs
+                    */
+                {
+                    IF_DEB_TREE(
+                                io_printf("add tree edge %d\t%d\n",
+                                          cur+1, next+1);
+                                );
+                    
+                    (*dfs_nbr)[next] = ++dfs_n;
+                    (*lowpoint)[(*dfs_nbr)[next]] = dfs_n;
+                    (*dfs_order)[dfs_n] = next;
+                    
+                    sparseg_dlcl_append_to_neigh_list(*dfs_tree, n,
+                                                      (*dfs_nbr)[cur],
+                                                      (*dfs_nbr)[next],
+                                                      NIL);
+                    TE_in_adjl[(*dfs_nbr)[next]] = cur_e;
+                    TE_mult[(*dfs_nbr)[next]]++;
+                    
+                    /*
+                      we push cur and the edge (cur, cur_e) on their
+                      respective stacks
+                    */
+                    vertex_stack[++pos_v_stack] = cur;
+                    edge_stack[++pos_e_stack] = cur_e;
+                    
+                    /*
+                      and mark next as visited
+                    */
+                    visited[next] = 1;
+
+                    /*
+                      update dfs_parent (always deal with DFIs rembember!)
+                    */
+                    (*dfs_parent)[(*dfs_nbr)[next]] = (*dfs_nbr)[cur];
+                    
+                    /*
+                      the DFS goes one level deeper
+                    */
+                    cur = next;
+                    cur_e = V[cur].first_edge == NIL ?
+                        NIL : V[cur].first_edge;
+                }
+                /*
+                  the next three tests deal with multiple edges
+                  and loops: apart from storing these (DIRECTED) edges
+                  in mult_edges, we also need to update
+                  the multipliciaty information about these edges
+                */
+                else if (sparseg_dlcl_is_adjacent(*dfs_tree, n,
+                                                  (*dfs_nbr)[cur],
+                                                  (*dfs_nbr)[next],
+                                                  &existing_e))
+                    /*
+                      [cur, next] is a tree edge
+                    */
+                {
+                    sparseg_dlcl_append_to_neigh_list(*mult_edges, n,
+                                                      (*dfs_nbr)[cur],
+                                                      (*dfs_nbr)[next],
+                                                      cur_e);
+                    TE_mult[(*dfs_nbr)[next]]++;
+                    
+                    cur_e = A[cur_e].next; /* next in cur's adjacency list */
+                }
+                else if (sparseg_dlcl_is_adjacent(*back_edges, n,
+                                                  (*dfs_nbr)[next],
+                                                  (*dfs_nbr)[cur],
+                                                  &existing_e))
+                    /*
+                      [cur, next] is a back edge
+                    */
+                {
+                    sparseg_dlcl_append_to_neigh_list(*mult_edges, n,
+                                                      (*dfs_nbr)[cur],
+                                                      (*dfs_nbr)[next],
+                                                      cur_e);
+                    (existing_e->mult)++;
+                    
+                    cur_e = A[cur_e].next; /* next in cur's adjacency list */
+                }
+                else if (next == cur)
+                    /*
+                      the case of a loop
+                    */
+                {
+                    if (sparseg_dlcl_is_adjacent(*mult_edges, n,
+                                                  (*dfs_nbr)[next],
+                                                  (*dfs_nbr)[cur],
+                                                  &existing_e))
+                        /*
+                          in this case we must update the multiplicity
+                          of this edge: note that the elt. in cur's
+                          neighbours list that gets updated is the first
+                          in the list
+
+                          dodgy??? certainly, but can't think
+                          of a better way to do this
+
+                          eventually it will happen that even myself
+                          won't understand what I am doing..........
+                        */
+                    {
+                        (existing_e->mult)++;
+                    }
+                    sparseg_dlcl_append_to_neigh_list(*mult_edges, n,
+                                                      (*dfs_nbr)[cur],
+                                                      (*dfs_nbr)[next],
+                                                      cur_e);
+                    
+                    cur_e = A[cur_e].next; /* next in cur's adjacency list */
+                }
+                else if (sparseg_dlcl_is_adjacent(*dfs_tree, n,
+                                                  (*dfs_nbr)[next],
+                                                  (*dfs_nbr)[cur],
+                                                  &existing_e))
+                    /*
+                      [next, cur] is a tree edge:
+                      that is, [cur, next] is [next, cur]'s twin/inverse:
+
+                      1. if it is the first time one encounters
+                         [cur, next] (as it would always be the case
+                         for a simple graph) then all I need to do
+                         is to update the tree edge's multiplicity,
+                         and the twin info in TE_[]
+
+                      2. if [cur, next] is actually a multiple edge,
+                         then I'll need to store it in mult_edges;
+                         and I update the tree edge's multiplicity too.
+                         No twin info will be required here.
+                         Why? see how recover.c embeds the multiple
+                         edges in the planar embedding.
+
+                      3. how do I know it is the first time I encounter
+                         [cur, next]?:
+                         when TE_twin_in_adjl = NIL
+
+                      4. finally, note that the present counting scheme
+                         implies that the mult field always holds
+                         the number of directed edges:
+                         ie, if [a, b] is a tree edge, [a, b].mult = 2
+                         because we would have counted [a, b] and [b, a]
+
+                         this applies to tree edges, back edges, and loops
+                    */
+                {
+                    ASSERT(TE_in_adjl[(*dfs_nbr)[cur]] != NIL);
+                    if (TE_twin_in_adjl[(*dfs_nbr)[cur]] == NIL)
+                    {
+                        TE_twin_in_adjl[(*dfs_nbr)[cur]] = cur_e;
+                    }
+                    else
+                    {
+                        sparseg_dlcl_append_to_neigh_list(*mult_edges, n,
+                                                          (*dfs_nbr)[cur],
+                                                          (*dfs_nbr)[next],
+                                                          cur_e);
+                    }
+                     
+                    TE_mult[(*dfs_nbr)[cur]]++;
+
+                    cur_e = A[cur_e].next; /* next in cur's adjacency list */
+                }
+                else if (sparseg_dlcl_is_adjacent(*back_edges, n,
+                                                  (*dfs_nbr)[cur],
+                                                  (*dfs_nbr)[next],
+                                                  &existing_e))
+                    /*
+                      [next, cur] is a back edge: [cur, next] is its inverse:
+                      we proceed as for the tree edge case above
+                    */
+                {
+                    ASSERT(existing_e->in_adjl != NIL);
+                    if (existing_e->twin_in_adjl == NIL)
+                    {
+                        existing_e->twin_in_adjl = cur_e;
+                    }
+                    else
+                    {
+                        sparseg_dlcl_append_to_neigh_list(*mult_edges, n,
+                                                          (*dfs_nbr)[cur],
+                                                          (*dfs_nbr)[next],
+                                                          cur_e);
+                    }
+                    
+                    (existing_e->mult)++;
+                    
+                    cur_e = A[cur_e].next; /* next in cur's adjacency list */
+                }
+                /*
+                  the next bit concludes the DFS: it deals with the case
+                  where a back edge needs to be added 
+                */
+                else 
+                    /*
+                      that is, next is visited and neither
+                      the tree edge [next, cur] nor
+                      the back edge [next, cur] exist:
+                      
+                      this implies that [cur, next] is a back edge
+                      that must be added to the back_edges structure
+                      (with dfs_nbr(next) < dfs_nbr(cur))
+                    */
+                {
+                    IF_DEB_TREE(
+                                io_printf("add back edge %d\t%d\n",
+                                          cur+1, next+1);
+                                );
+                    
+                    ASSERT(visited[next]);
+                    ASSERT((*dfs_nbr)[cur] > (*dfs_nbr)[next]);
+                    
+                    sparseg_dlcl_append_to_neigh_list(*back_edges, n,
+                                                      (*dfs_nbr)[next],
+                                                      (*dfs_nbr)[cur],
+                                                      cur_e);
+
+                    /*
+                      update cur's lowpoint
+                    */
+                    (*lowpoint)[(*dfs_nbr)[cur]] =
+                        (*dfs_nbr)[next] < (*lowpoint)[(*dfs_nbr)[cur]] ?
+                        (*dfs_nbr)[next] : (*lowpoint)[(*dfs_nbr)[cur]];
+                    
+                    /*
+                      update least_a (of cur)
+                      (always deal with DFIs remember!)
+                    */
+                    (*least_a)[(*dfs_nbr)[cur]] =
+                        (*dfs_nbr)[next] < (*least_a)[(*dfs_nbr)[cur]] ?
+                            (*dfs_nbr)[next] : (*least_a)[(*dfs_nbr)[cur]];
+
+                    /*
+                      get the next edge in cur's adjacency list
+                    */
+                    cur_e = A[cur_e].next;
+                }
+            }
+            
+            if (cur_e == NIL)
+                /*
+                  we are either at a leaf or have finished scanning
+                  cur's adjacency list: backtrack
+                */
+            {
+                if (pos_v_stack == -1)      /* no previous vertex */
+                {
+                    /*
+                      no edge left on the stack: DFS ends for
+                      this subtree:
+                      we visit the next vertex
+                    */
+                    ASSERT(pos_e_stack == -1);
+                    break;
+                }
+                else
+                {
+                    int      prev_e;
+                    /*
+                      Otherwise backtrack and pop cur from the stack
+                      as well as the last tree edge  added to the tree.
+                      We use next to get a new lowpoint value for cur:
+                      This value will be min(lowpoint(cur), lowpoint(next)).
+                    */
+                    cur = vertex_stack[pos_v_stack--];
+                    prev_e = edge_stack[pos_e_stack--];
+                    next = A[prev_e].end_vertex;
+                    (*lowpoint)[(*dfs_nbr)[cur]] =
+                        (*lowpoint)[(*dfs_nbr)[cur]]
+                        < (*lowpoint)[(*dfs_nbr)[next]] ?
+                        (*lowpoint)[(*dfs_nbr)[cur]]
+                        : (*lowpoint)[(*dfs_nbr)[next]];
+
+                    cur_e = A[prev_e].next;
+                }
+                /*
+                  we proceed with DFS
+                */
+            }
+        }
+    }
+    mem_free(vertex_stack);
+    mem_free(edge_stack);
+
+    /*
+      just for the sake of it, check that all vertices have
+      been visited
+    */
+#ifdef ASSERTIONS
+    for (v = 0; v < n; v++)
+    {
+        ASSERT(visited[v]);
+    }
+#endif
+    mem_free(visited);
+
+    /*
+      we now order the DFIs wrt lowpoint values:
+      use bucket sort (linear time)
+    */
+    /*
+      for each lowpoint value, collect the DFIs (in a t_dlcl)
+      with that lowpoint value
+      (IMPORTANT: we want the DFIs since the aim is to rewrite dfs_tree
+      which stores DFIs and not labels!)
+    */
+    for (v = 0; v < n; v++)
+        /*
+          v  is taken as a DFI here
+        */
+    {
+        t_dlcl    *r;
+ 
+        r = embedg_dlcl_rec_new(v);
+        temp[(*lowpoint)[v]] = 
+            embedg_dlcl_rec_append(temp[(*lowpoint)[v]], r);
+    }
+ 
+    /*
+      concatenate these lists now
+    */
+    lowpoint_list = temp[0];
+    for (lp = 1; lp < n; lp++)
+    {
+        lowpoint_list = embedg_dlcl_cat(lowpoint_list, temp[lp]);
+    }
+    ASSERT(embedg_dlcl_length(lowpoint_list) == n);
+        
+    lowpoint_order[0] = lowpoint_list->info;
+    for (lp = 1; lp < n; lp++)
+    {
+        lowpoint_list = embedg_dlcl_list_next(lowpoint_list);
+        lowpoint_order[lp] = lowpoint_list->info;
+    }
+    embedg_dlcl_delete(lowpoint_list);
+    mem_free(temp);
+
+    IF_DEB(
+           fprintf(stdout, "dfs_preprocessing, lowpoint_order\n");
+           for (lp = 0; lp < n; lp++)
+           fprintf(stdout, "%d ", lowpoint_order[lp]);
+           fprintf(stdout, "\n");
+           fprintf(stdout, "dfs_preprocessing, lowpoint\n");
+           for (lp = 0; lp < n; lp++)
+           fprintf(stdout, "%d ", (*lowpoint)[lp]);
+           fprintf(stdout, "\n");
+           )
+    
+    /*
+      we now use this order to rewrite dfs_tree such that
+      the DFS children of each vertex are ordered wrt lowpoint values
+    */
+    for (lp = 0; lp < n; lp ++)
+        /*
+          for each DFI in lowpoint_order[] I know its DFS_parent
+          from dfs_parent[] -- the rest is then trivial
+        */
+    {
+        int       parent;
+        
+        v = lowpoint_order[lp];
+        /*
+          lowpoint_order stores DFIs as does dfs_parent, so the lot
+          makes sense
+        */
+        parent = (*dfs_parent)[v];
+        if (parent != n)
+            /*
+              v may be the root of a DFS tree
+            */
+        {
+            t_dlcl   *temp;
+
+            temp = embedg_dlcl_rec_new(v);
+
+            /*
+              this is where the TE_ holding arrays are useful *sigh*
+            */
+            ASSERT(TE_in_adjl[v] != NIL);
+            temp->in_adjl = TE_in_adjl[v];
+
+            ASSERT(TE_twin_in_adjl[v] != NIL);
+            temp->twin_in_adjl = TE_twin_in_adjl[v];
+
+            ASSERT(TE_mult[v] != 0 && TE_mult[v] % 2 == 0);
+            temp->mult = TE_mult[v];
+            
+            new_dfs_tree[parent] =
+                embedg_dlcl_rec_append(new_dfs_tree[parent], temp);
+        }
+    }
+    mem_free(lowpoint_order);
+    mem_free(TE_in_adjl);
+    mem_free(TE_twin_in_adjl);
+    mem_free(TE_mult);
+
+    /*
+      some checks are in order here
+    */
+#ifdef ASSERTIONS
+    for (v = 0; v < n; v++)
+    {
+        ASSERT(embedg_dlcl_length((*dfs_tree)[v])
+               == embedg_dlcl_length(new_dfs_tree[v]));
+
+        IF_DEB(
+               fprintf(stdout, "dfs_preprocessing    dfs_tree for %d\n", v);
+               embedg_dlcl_print((*dfs_tree)[v]);
+               fprintf(stdout, "dfs_preprocessing    new_dfs_tree for %d\n", v);
+               embedg_dlcl_print(new_dfs_tree[v]);
+    );
+    }
+#endif
+    
+    sparseg_dlcl_delete(*dfs_tree, n);
+    *dfs_tree = new_dfs_tree;
+}
+
+/*
+ *  embedding.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  The graph is planar: we recover the embedding from the VES structure
+  and check it as well.
+  (Some of these checks will disappear later)
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+ 
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_DEB_EMBED(x)    {}
+#define IF_DEB_CHECK_EMBED(x)    {}
+#define IF_DEB_FACES(x) {}
+#define IF_VERB(x)   {}
+#define IF_DEB_SCE(x) {}
+#define IF_CPU(x) {}
+ 
+
+/* aproto: header embed_graph_protos.h */
+ 
+ 
+#ifndef PLANAR_IN_MAGMA
+#endif
+ 
+void 
+embedg_embedding (t_ver_sparse_rep *V, t_adjl_sparse_rep *A,
+	t_ver_edge *embed_graph, int n, int e, int nbr_c,
+	int edge_pos, t_dlcl **mult_edges, t_ver_sparse_rep **vertices,
+	t_embed_sparse_rep **embedding)
+    /*
+      recovering the embedding for the (planar) graph
+
+      - the embedding is returned in vertices and embedding, vertices
+      indexes embedding, the ordered list of edges
+      - edges in the embedding are given as their index in A, the graph's
+      adajacency list
+      - the nbr of edges in the embedding is given as nbr_e_embed:
+      this may be different form the original number of edges when the graph
+      iss not simple
+    */
+{
+    int          *ver_orient, nbr_comp, nbr_e_embed;
+    
+    IF_CPU(
+    float      sttime; float time_to_now;
+ 
+    sttime = time_current_user();
+    )
+
+    IF_DEB(
+           fprintf(stdout, "embedding, begin, which edges have been flipped\n");
+           embedg_VES_print_flipped_edges(embed_graph, n, edge_pos);
+           )
+
+    IF_DEB(
+           fprintf(stdout, "embedding, before removing SCE\n");
+           embedg_VES_print_bigcomps(embed_graph, n);
+           )
+
+    /*
+      several things to do:
+      1. removing the short-cut edges
+    */
+    embedg_remove_SCE(embed_graph, n, edge_pos);
+
+    IF_DEB(
+           fprintf(stdout, "embedding, after removing SCE\n");
+           embedg_VES_print_bigcomps(embed_graph, n);
+           )
+        
+    /*
+      2. computing each vertex's orientation (wrt flipped bicomps)
+    */
+    ver_orient = embedg_vertices_orientation(embed_graph, n);
+    
+
+    /*
+      3. merging the remaining virtual vertices with their
+         non-virtual counterpart
+    */
+    nbr_comp = embedg_merge_remaining_virtual(embed_graph, n);
+    /*
+      actually there is no need to return the nbr of components
+      from the above function
+      but let's do it for the sake of it and for possible checking
+    */
+    ASSERT(nbr_c == nbr_comp);
+
+    IF_DEB(
+           fprintf(stdout, "embedding, after merging of remaining vertices\n");
+           )
+
+    /*
+      4. to be on the safe side: check that the embedding is a valid one
+
+      for now, we DIE if not
+    */
+
+    if (!embedg_is_embed_valid(embed_graph, n, nbr_comp, edge_pos,
+                               ver_orient, &nbr_e_embed))
+    {
+        mem_free(ver_orient);
+        DIE();
+    }
+    mem_free(ver_orient);
+
+    ASSERT(nbr_e_embed <= e);
+    /*
+      when the graph is not simple, multiple edges and loops are
+      not in embed_graph[]: they will be added to the final
+      embedding in embedg_recover_embedding below
+    */
+    
+    /*
+      5. recover the embedding in preparation for the Magma type,
+      and check it as well
+    */
+    embedg_recover_embedding(V, A, embed_graph, n, e,
+                             mult_edges, vertices, embedding);
+    if (!embedg_check_recov_embedding(n, e, nbr_comp,
+                                      *vertices, A, *embedding))
+    {
+        mem_free(*vertices);
+        mem_free(*embedding);
+        
+        IF_CPU(
+               fprintf(stdout, "CPU for embedding recovering %f\n",
+                       time_current_user() - sttime);
+               )
+ 
+        DIE();
+    }
+
+    IF_DEB_EMBED(
+                 fprintf(stdout, "embedding, original graph and embedding\n");
+                 sparseg_adjl_print(V, n, A, FALSE);
+                 fprintf(stdout, "\n");
+                 sparseg_adjl_embed_print(*vertices, n, A, *embedding,
+                                          FALSE);
+                 )
+    
+    IF_CPU(
+           fprintf(stdout, "CPU for embedding recovering %f\n",
+                   time_current_user() - sttime);
+           )
+}
+
+
+void 
+embedg_remove_SCE (t_ver_edge *embed_graph, int n, int edge_pos)
+    /*
+      remove all the short-cut edges from the embedding
+    */
+{
+    int          i, c;
+
+    c = 0;
+    for (i = 2*n; i <= edge_pos; i += 2)
+        /*
+          and edge and its twin occupy consecutive positions in embed_graph:
+          need only to examine one out of two
+          (removing an edge also entails removing its twin of course
+        */
+    {
+        if (embedg_VES_is_short_cut_edge(embed_graph, n, i))
+        {
+            IF_DEB_SCE(
+                       fprintf(stdout, "remove SCE\n");
+                       embedg_VES_print_edge(embed_graph, n, i);
+                       )
+
+            embedg_VES_remove_edge(embed_graph, n, i);
+            c++;
+        }
+    }
+
+    IF_DEB_SCE(
+               fprintf(stdout, "nbr of SCE edges removed %d\n", c);
+               )
+}
+
+
+int *
+embedg_vertices_orientation (t_ver_edge *embed_graph, int n)
+    /*
+      for each vertex return its orientation from the
+      bicomps in embed_graph:
+      perform a DFS of each bicomp
+    */
+{
+    int          i, vv, prod_sign;
+    int          *stack, *ver_orient, to_prev;
+
+    /*
+      the whole lot makes sense iff the adjacency lists are consistent:
+      this is a very important issue and it might be the case
+      that the ASSERT warrants replacement by a DIE
+      (the check is linear - I think)
+    */
+    ASSERT(embedg_VES_are_adj_lists_consistent(embed_graph, n));
+
+    ver_orient = (int *) mem_malloc(sizeof(int) * n);
+    for (i = 0; i < n; i++)
+    {
+        ver_orient[i] = CCLOCKW;
+    }
+
+    /*
+      create the stack for the DFS
+    */
+    stack = (int *) mem_malloc(sizeof(int) * 3*n);
+    to_prev = -1;
+    
+    IF_DEB(
+           fprintf(stdout, "vertex orientation, one line (of vert.) for each bicomp\n");
+           )
+                
+    /*
+      now visit all the bicomps, ie, all the virtual vertices
+      in embed_graph
+    */
+    for (vv = n; vv < 2*n; vv++)
+    {
+        int      c, cur, cur_e;
+        boolean  NEW_BICOMP;
+
+        if (embed_graph[vv].link[0] == vv)
+            /*
+              means that vv is disabled and is not the root of a bicomp
+            */
+        {
+            continue;
+        }
+
+        c = vv - n;
+        IF_DEB(
+               fprintf(stdout, "%d ", c);
+               )
+        /*
+          orientation for c (vv is as yet unembedded) is CCLOCKW
+
+          now find the orientation of all its DFS descendants
+        */
+
+        if (embed_graph[c].DFS_parent == n)
+            /*
+              this means that actually c is an isolated vertex:
+              we initialise the sign to CCLOCKW
+            */
+        {
+            prod_sign = CCLOCKW;
+        }
+        else
+            /*
+              we initialise the sign to CCLOCKW to the sign of c's parent
+            */
+        {
+            prod_sign = ver_orient[embed_graph[c].DFS_parent];
+        }
+
+        /*
+          we must not forget to set c's sign!!
+          (won't be done below)
+        */
+        ver_orient[c] = prod_sign;
+        
+        NEW_BICOMP = FALSE;
+        cur = c;
+        cur_e = embed_graph[cur].link[0];
+        ASSERT(embedg_VES_is_edge(n, cur_e));
+
+        ASSERT(to_prev == -1);
+        while (TRUE)
+        {
+            while (!embedg_VES_is_tree_edge(embed_graph, n, cur_e)
+                   || !embedg_VES_is_vertex(n,
+                                             embed_graph[cur_e].neighbour)
+                   || embed_graph[cur_e].neighbour <= cur)
+                /*
+                  want to find a tree edge [cur, u]
+                  where u is a descendant of cur
+                */
+            {
+                cur_e = embed_graph[cur_e].link[0];
+                
+                while (cur_e == cur)
+                    /*
+                      back to the vertex where we started from:
+                      no edge has been found:
+                      cur is a leaf, backtrack
+                    */
+                {
+                    if (to_prev == -1)
+                    {
+                        NEW_BICOMP = TRUE;
+                        break;
+                    }
+                    prod_sign = stack[to_prev--];
+                    cur_e = stack[to_prev--];
+                    /*
+                      must advance one more edge
+                    */
+                    cur_e = embed_graph[cur_e].link[0];
+                    cur = stack[to_prev--];
+                }
+                if (NEW_BICOMP)
+                {
+                    break;
+                }
+            }
+
+            if (NEW_BICOMP)
+            {
+                break;
+            }
+            else
+                /*
+                  now cur_e is the edge we were looking for, get its sign
+                */
+            {
+                /*
+                  push on stack the current vertex, the edge where we
+                  stopped the DFS, AND the sign carried by that vertex
+                  
+                  and go down one level in the DFS
+                */
+                stack[++to_prev] = cur;
+                stack[++to_prev] = cur_e;
+                stack[++to_prev] = prod_sign;
+                
+                cur = embed_graph[cur_e].neighbour;
+                prod_sign *= embed_graph[cur_e].sign;
+                ver_orient[cur] = prod_sign;
+                
+                cur_e = embed_graph[cur].link[0];
+                ASSERT(embedg_VES_is_edge(n, cur_e));
+                
+                IF_DEB(
+                       fprintf(stdout, "%d with sign %d\n", cur, prod_sign);
+                       )
+            }
+        }
+
+        IF_DEB(
+               fprintf(stdout, "\n");
+               )
+    }
+
+    IF_DEB(
+           fprintf(stdout, "vertex orientation\n");
+           for (i = 0; i < n; i++)
+           {
+               fprintf(stdout, "%d ", ver_orient[i]);
+           }
+           fprintf(stdout, "\n");
+           )
+
+   mem_free(stack);
+   return ver_orient;
+}
+    
+
+int 
+embedg_merge_remaining_virtual (t_ver_edge *embed_graph, int n)
+    /*
+      after the short-cut edges have been removed and the vertices'
+      orientation computed, one finishes by merging all
+      remaining virtual vertices with their virtual counterpart
+      (without flip of course)
+
+      and use this routine to return  the number of disconnected
+      components of the graph
+    */
+{
+    /*
+      at this stage it is easy to see that all remaining
+      virtual vertices are DFS roots (if the graph is not connected)
+      or cut vertices
+    */
+
+    int          vv, nbr_comp;
+
+    nbr_comp = 0;
+    for (vv = n; vv < 2*n; vv++)
+    {
+        int      v, c;
+
+
+        c = vv - n;
+        v = embed_graph[c].DFS_parent;
+        
+        /*
+          must fish out which virtual vertices are actual roots
+          of DFS trees (esp. for the disconnected graph case):
+          roots of DFS trees are those virtual vertices for which
+          v = embed_graph[c].DFS_parent = n
+        */
+        if (v == n)
+        {
+            nbr_comp++;
+            continue;
+        }
+        
+        if (embed_graph[vv].link[0] == vv)
+            /*
+              means that vv is disabled and is not the root of a bicomp
+            */
+        {
+            continue;
+        }
+
+        embedg_VES_merge_simple_bicomps(embed_graph, n,
+                                                   vv, 1, v, 0);
+        /*
+          note:
+          since v is a cut vertex in this intance the bicomp
+          rooted by vv will be merged without flip;
+          therefore we could have done
+          embedg_VES_merge_simple_bicomps(embed_graph, n,
+          vv, 0, v, 1)
+          as well, the important thing being that vin != vvout
+          (see embedg_VES_merge_simple_bicomps)
+        */
+    }
+
+    return nbr_comp;
+}
+
+
+int 
+embedg_nbr_faces (t_ver_edge *embed_graph, int n, int edge_pos,
+	int *ver_orient, int *nbr_e_embed)
+    /*
+      count the number of faces and the number of edges of the embedding
+    */
+{
+    int          v, e, f, total_e;
+
+    IF_DEB_FACES(
+                 int    v;
+                 
+                 fprintf(stdout, "nbr of faces, the vertices' adj. lists\n");
+                 for (v = 0; v < n; v++)
+                     embedg_VES_print_adj_list(embed_graph, n,
+                                                          v, TRUE);
+                 )
+        
+    /*
+      the following is no more than a quick check -- certainly
+      not very useful -- or could be done elsewhere
+    */
+    total_e = 0;
+    for (e = 2*n; e <= edge_pos; e++)
+    {
+        if (!embedg_VES_is_short_cut_edge(embed_graph, n, e))
+        {
+            total_e++;
+        }
+    }
+    ASSERT(total_e % 2 == 0);
+    *nbr_e_embed = total_e / 2;
+
+    /*
+      I now set each edge's orientation
+
+      QUESTION: do I really need to do this???
+      so far, when doing a proper face traversal, the way in which
+      the adjacency list of an edge must be traversed is given
+      by the vertex's (in that list) orientation...
+      So this seems sensible to me huh?
+    */
+    embedg_VES_set_orientation(embed_graph, n, ver_orient);
+
+    /*
+      I will be using the visited field to enable me to check
+      if all edges have been traversed
+
+      let's be smart (?!): so far the visited field has been used
+      and set in the following circumstances:
+      + initialisation: set to n
+      + walkup: set to whatever DFI of interest
+
+      so here we set it to MARK_EMBED(n)
+    */
+    f = 0;
+    for (e = 2*n; e <= edge_pos; e++)
+    {
+        if (!embedg_VES_is_short_cut_edge(embed_graph, n, e)
+            /*
+              arrghh!!! I must also skip the SCE!!!
+            */
+            && embed_graph[e].visited != MARK_EMBED(n))
+        {
+            int          ein;
+            
+            IF_DEB_FACES(
+                         fprintf(stdout, "nbr of faces, edges not visited\n");
+                         embedg_VES_print_edge(embed_graph, n, e);
+                         )
+
+            ein = embed_graph[e].sign == CCLOCKW ? 0 : 1;
+            /*
+              the way I enter e in dependent on its sign:
+              all the proper face traversal must obviously be done
+              with the same orientation!
+            */
+            embedg_VES_walk_proper_face(embed_graph, n, e,
+                                                       ein,
+                                                       TRUE,
+                                                       MARK_EMBED(n));
+            f++;
+        }
+    }
+
+    /*
+      counting the faces by traversing all the edges does not
+      account of the face defined by isolated vertices
+      -- we do that now
+
+      we only need to check which vertices refer to self, ie with
+      no incident edges
+    */
+    for (v = 0; v < n; v++)
+    {
+        if (embed_graph[v].link[0] == v)
+        {
+            ASSERT(embed_graph[v].link[1] == v);
+            f++;
+        }
+    }
+    
+    return f;
+}
+
+
+boolean 
+embedg_is_embed_valid (t_ver_edge *embed_graph, int n, int nbr_comp,
+	int edge_pos, int *ver_orient, int *nbr_e_embed)
+    /*
+      use Euler's formula to assertain that the embedding is a valid
+      embedding:
+
+      f = 2 * nbr_comp + nbr_e_embed - n
+
+    */
+{
+    int         v, f;
+
+    f = embedg_nbr_faces(embed_graph, n, edge_pos, ver_orient, nbr_e_embed);
+
+    IF_DEB_CHECK_EMBED(
+                       fprintf(stdout, "embedding, n: %d\t e: %d\t C: %d\t f: %d\n",
+                               n, nbr_e, nbr_comp, f);
+                       )
+        
+    return f == 2 * nbr_comp + *nbr_e_embed - n ? TRUE : FALSE;
+}
+/*
+ *  ext_face_walk.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing the external face walk of a bicomponent.
+  The concept of an external face --in the context of the VES
+  data structure-- makes only sense when talking
+  about a bicomp.
+
+  Recall that a vertex is linked together with the edges
+  incident from it in a circular (doubly) linked list
+  (this is the VES structure).
+
+  One particular feature is that if a vertex v is on
+  the external face of a component and if in the list
+  we have edges e1, e2 such as e1  -> v -> e2
+  then e1 and e2 border the external face.
+
+  In other words, in the circular list of vertex v and edges,
+  v is ALWAYS between the two edges bordering the external face
+
+  Of course, when v is (maybe) pushed into the internal face
+  (by embedding of some edge) then we don't care about this any more
+  (for v that is).
+  
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+ 
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_VERB(x)   {}
+ 
+ 
+/* aproto: header embed_graph_protos.h */
+ 
+
+void 
+embedg_VES_get_succ_on_ext_face (t_ver_edge *embed_graph, int n, int v,
+	int vin, boolean MARK, int mark, int *s, int *sin)
+    /*
+      find the successor s of v (entered via vin) on the external face
+      -- also return the direction in which s has been entered
+
+      if MARK true mark the succ. vertex and the edges traversed
+      with mark (the visited field)
+    */
+{
+    int        e, twin;
+    int        vout, ein, eout, tout;
+
+    ASSERT(embedg_VES_is_vertex(n, v)
+           || embedg_VES_is_virtual_vertex(n, v));
+
+    IF_DEB(
+           fprintf(stdout, "get_succ_on_ext_face, of %d:%d\n", v, vin);
+           )
+        
+    /*
+      find the direction out of the vertex, and get the edge
+    */
+    vout = vin == 0 ? 1 : 0;
+    e = embed_graph[v].link[vout];
+    if (embedg_VES_is_virtual_vertex(n, v) && e == v)
+        /*
+          this can happen if a virtual vertex has been "disabled"
+
+          -- this should not never happen since we can only walk
+          on the external face of a bicomp!
+        */
+    {
+        *s = v;
+        *sin = vin;
+        return;
+    }
+
+    /*
+      otherwise we must have an edge:
+      note that it is entirely irrelevant if I walk SCEs:
+      those are precisely there to "jump" over inactive vertices
+    */
+    ASSERT(embedg_VES_is_edge(n, e));
+
+    /*
+      get the twin edge
+    */
+    twin = embedg_VES_get_twin_edge(embed_graph, n, e);
+
+    IF_DEB(
+           fprintf(stdout, "get_succ_on_ext_face, edge [%d, %d]\n",
+                   v, embed_graph[e].neighbour);
+           fprintf(stdout, "get_succ_on_ext_face, twin edge [%d, %d]\n",
+                   embed_graph[e].neighbour, embed_graph[twin].neighbour);
+           )
+    /*
+      find which of twin's link links a vertex
+    */
+    tout = embedg_VES_is_vertex(n, embed_graph[twin].link[0])
+        || embedg_VES_is_virtual_vertex(n,
+                                                   embed_graph[twin].link[0])
+        ?
+        0 : 1;
+
+    /*
+      get this vertex: this is v's successor on the external face
+    */
+    *s = embed_graph[twin].link[tout];
+
+    /*
+      one more thing to do: find the direction in which s was entered
+    */
+    *sin = embed_graph[*s].link[0] == twin ? 0 : 1;
+
+    IF_DEB(
+           fprintf(stdout, "get_succ_on_ext_face, succ is %d:%d\n",
+                   *s, *sin);
+           )
+    /*
+      a special case: when the bicomp is a singleton bicomp
+      (ie a single edge)
+    */
+    if (embed_graph[*s].link[0] == (embed_graph[*s].link[1]))
+    {
+        ASSERT(embed_graph[*s].link[0] = twin);
+        *sin = vin;
+    }
+
+    /*
+      finally, mark the vertex and edges if so requested
+    */
+    if (MARK)
+    {
+        embed_graph[*s].visited = mark;
+        embed_graph[e].visited = mark;
+        embed_graph[twin].visited = mark;
+    }
+}
+
+void 
+embedg_VES_get_succ_active_on_ext_face (t_ver_edge *embed_graph, int n,
+	int v, int w, int win, boolean MARK, int mark, int *s, int *sin)
+    /*
+      find the ACTIVE (wrt v) successor s of w (entered via win)
+      on the external face
+      -- also return the direction in which s has been entered
+ 
+      if MARK true mark the succ. vertex (and the edge)
+      with mark (the visited field)
+    */
+{
+    /*
+      simply repeatedly calls embedg_VES_get_succ_on_ext_face
+      until an active vertex is found
+    */
+    ASSERT(embedg_VES_is_vertex(n, w)
+           || embedg_VES_is_virtual_vertex(n, w));
+
+    embedg_VES_get_succ_on_ext_face(embed_graph, n,
+                                         w, win, MARK, mark, s, sin);
+    while (embedg_VES_is_ver_inactive(embed_graph, n, v, *s))
+    {
+        embedg_VES_get_succ_on_ext_face(embed_graph, n,
+                                             *s, *sin, MARK, mark, s, sin);
+    }
+    ASSERT(!embedg_VES_is_ver_inactive(embed_graph, n, v, *s));
+}
+
+void 
+embedg_VES_get_succ_ext_active_on_ext_face (t_ver_edge *embed_graph, int n,
+	int v, int w, int win, boolean MARK, int mark, int *s, int *sin)
+    /*
+      find the externally active (wrt v) successor s of w (entered via win)
+      on the external face
+      -- also return the direction in which s has been entered
+ 
+      if MARK true mark the succ. vertex (and the edge)
+      with mark (the visited field)
+    */
+{
+    ASSERT(embedg_VES_is_vertex(n, w)
+           || embedg_VES_is_virtual_vertex(n, w));
+
+    embedg_VES_get_succ_on_ext_face(embed_graph, n,
+                                         w, win, MARK, mark, s, sin);
+    while (!embedg_VES_is_ver_ext_active(embed_graph, n, v, *s))
+    {
+        embedg_VES_get_succ_on_ext_face(embed_graph, n,
+                                             *s, *sin, MARK, mark, s, sin);
+    }
+    ASSERT(embedg_VES_is_ver_ext_active(embed_graph, n, v, *s));
+}
+
+void 
+embedg_VES_get_succ_pertinent_on_ext_face (t_ver_edge *embed_graph, int n,
+	int v, int w, int win, boolean MARK, int mark, int *s, int *sin)
+    /*
+      find the pertinent (wrt v) successor s of w (entered via win)
+      on the external face
+      -- also return the direction in which s has been entered
+ 
+      if MARK true mark the succ. vertex (and the edge)
+      with mark (the visited field)
+    */
+{
+    ASSERT(embedg_VES_is_vertex(n, w)
+           || embedg_VES_is_virtual_vertex(n, w));
+
+    embedg_VES_get_succ_on_ext_face(embed_graph, n,
+                                         w, win, MARK, mark, s, sin);
+    while (!embedg_VES_is_ver_pertinent(embed_graph, n, v, *s))
+    {
+        embedg_VES_get_succ_on_ext_face(embed_graph, n,
+                                             *s, *sin, MARK, mark, s, sin);
+    }
+    ASSERT(embedg_VES_is_ver_pertinent(embed_graph, n, v, *s));
+}
+
+/*
+ *  mark_kur.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing:
+
+  Marking the Kuratowski obstruction (in the VES structure):
+  this we do once we know which minor we are talking about
+  (see isolator.c).
+ 
+ 
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+ 
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+ 
+ 
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+ 
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+ 
+  Started October 2001
+*/
+ 
+ 
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_VERB(x)   {}
+#define IF_DEB_TREE(x)    {}
+#define IF_DEB_EDGES(x) {}
+#define IF_CPU(x) {}
+ 
+
+
+/* aproto: header embed_graph_protos.h */
+
+/* aproto: beginstatic -- don't touch this!! */
+static void embedg_VES_walk_mark_part_ext_face (t_ver_edge *, int, int, int, int, int, int);
+static void embedg_VES_walk_mark_ext_face (t_ver_edge *, int, int, int);
+static void embedg_VES_walk_mark_part_proper_face (t_ver_edge *, int, int, int, int, int);
+static boolean embedg_VES_is_part_ext_face_marked (t_ver_edge *, int, int, int, int, int, int);
+static void embedg_get_u_x (t_ver_edge *, int, int, int, int *);
+static int embedg_get_least_neigh (t_dlcl **, t_dlcl **, int, int, int);
+static void embedg_add_mark_u_x (t_dlcl **, t_dlcl **, t_ver_edge *, int, int *, int, int, int *, int);
+static void embedg_mark_tree_path (t_ver_edge *, int, int, int, int);
+static void embedg_add_mark_v_w (t_dlcl **, t_dlcl **, t_ver_edge *, int, int *, int, int, int);
+static void embedg_add_mark_v_w_for_B (t_dlcl **, t_dlcl **, t_ver_edge *, int, int *, int, int, int *, int);
+static void embedg_mark_x_y_path (t_ver_edge *, int, int *, int *, int, int);
+/* aproto: endstatic -- don't touch this!! */
+ 
+#ifndef PLANAR_IN_MAGMA
+#endif
+
+
+
+static void 
+embedg_VES_walk_mark_part_ext_face (t_ver_edge *embed_graph, int n,
+	int v, int vin, int from, int to, int mark)
+    /*
+      walk & mark the external face:
+      walk in the direction vin -> v -> vout and mark <from> <to>
+    */
+{
+    int          cur, curin, next, nextin;
+
+    embed_graph[from].visited = mark;
+    embed_graph[to].visited = mark;
+
+    IF_DEB(
+           fprintf(stdout, "part. ext face marked\t");
+           fprintf(stdout, "%d\t", from);
+           )
+
+    next = cur = v;
+    curin = vin;
+    while (next != from)
+    {
+        embedg_VES_get_succ_on_ext_face(embed_graph, n, cur, curin,
+                                             FALSE, 0, &next, &nextin);
+        cur = next;
+        curin = nextin;
+    }
+    next = n;
+    while (next != to)
+    {
+        embedg_VES_get_succ_on_ext_face(embed_graph, n, cur, curin,
+                                             TRUE, mark, &next, &nextin);
+        cur = next;
+        curin = nextin;
+
+        IF_DEB(
+               fprintf(stdout, "%d\t", next);
+               )
+    }
+    IF_DEB(
+           fprintf(stdout, "\n");
+           )
+}
+   
+static void 
+embedg_VES_walk_mark_ext_face (t_ver_edge *embed_graph, int n, int v, int mark)
+    /*
+      walk & mark the external face, starting & ending at vertex v
+    */
+{
+    embedg_VES_walk_mark_part_ext_face(embed_graph, n, v, 0, v, v,
+                                            mark);
+}
+   
+
+
+static void 
+embedg_VES_walk_mark_part_proper_face (t_ver_edge *embed_graph, int n,
+	int from_e, int from_ein, int to, int mark)
+    /*
+      walk & mark a proper face starting at EDGE from_e and ending
+      at VERTEX to
+
+      walk in the direction from_ein -> from_e -> to and mark
+      everything in between
+    */
+{
+    int     s, cur_e, cur_ein, next_e, next_ein;
+ 
+    next_e = s = n; /* this is an invalid value for an edge/vertex */
+  
+    cur_e = from_e;
+    cur_ein = from_ein;
+    while (s != to)
+    {
+        ASSERT(embedg_VES_is_edge(n, cur_e));
+        ASSERT(!embedg_VES_is_short_cut_edge(embed_graph,
+                                                        n, cur_e));
+ 
+        embedg_VES_get_succ_on_proper_face(embed_graph, n,
+                                                cur_e, cur_ein,
+                                                TRUE, mark,
+                                                &s, &next_e, &next_ein);
+        cur_e = next_e;
+        cur_ein = next_ein;
+    }
+}
+
+
+
+static boolean 
+embedg_VES_is_part_ext_face_marked (t_ver_edge *embed_graph, int n, int v,
+	int vin, int from, int to, int mark)
+    /*
+      simple check to see if all the vertices on the external
+      face walk starting at vin -> v -> vout <from> <to> are marked
+      (with mark)
+    */
+{
+    int          cur, curin, next, nextin;
+
+    if (embed_graph[from].visited != mark || embed_graph[to].visited != mark)
+        return FALSE;
+
+    cur = v;
+    curin = vin;
+    next = n;
+    while (next != from)
+    {
+        embedg_VES_get_succ_on_ext_face(embed_graph, n, cur, curin,
+                                             FALSE, 0, &next, &nextin);
+        cur = next;
+        curin = nextin;
+    }
+    while (next != to)
+    {
+        embedg_VES_get_succ_on_ext_face(embed_graph, n, cur, curin,
+                                             FALSE, 0, &next, &nextin);
+        if (embed_graph[next].visited != mark)
+            return FALSE;
+
+        cur = next;
+        curin = nextin;
+    }
+    
+    return TRUE;
+}
+
+
+boolean 
+embedg_VES_is_ext_face_marked (t_ver_edge *embed_graph, int n, int v, int mark)
+    /*
+      simple check to see if all the vertices on the external
+      face walk starting/ending at v are marked (with mark)
+    */
+{
+    return embedg_VES_is_part_ext_face_marked(embed_graph, n, v, 0,
+                                                   v, v, mark);
+}
+
+
+static void 
+embedg_get_u_x (t_ver_edge *embed_graph, int n, int v, int x, int *u_x)
+    /*
+      x is an externally active vertex (wrt v):
+      we want u_x, the lowest point of "attachement" for
+      the unembedded directed edge [x, u_x]
+    */
+{
+    int          c;
+    t_dlcl       *child_list;
+
+    ASSERT(embedg_VES_is_ver_ext_active(embed_graph, n, v, x));
+    if (embed_graph[x].least_ancestor < v)
+        /*
+          then there is a single unembedded back edge (u_x, x),
+          u_x an ancestor of v
+        */
+    {
+        *u_x = embed_graph[x].least_ancestor;
+        return;
+    }
+
+    /*
+      else there is a tree path x to d_x and an
+      unembedded back edge (u_x, d_x)
+
+      get the lowpoint of the first elt. in separated_DFS_child_list of x
+    */
+    child_list = embed_graph[x].separated_DFS_child_list;
+    ASSERT(!embedg_dlcl_is_empty(child_list));
+    c = child_list->info;
+    *u_x = embed_graph[c].lowpoint;
+}
+
+static int 
+embedg_get_least_neigh (t_dlcl **dfs_tree, t_dlcl **back_edges,
+	int n, int v, int c)
+    /*
+      get the least neighbour of v >= c, ie a vertex in the sub tree
+      rooted by c
+
+      somehow this must always succeed
+    */
+{
+    int          least_n;
+    t_dlcl       *tree_l, *back_l, *p;
+
+    /*
+      neighbours are found in either dfs_tree[v] or back_edges[v]
+    */
+
+    tree_l = dfs_tree[v];
+    back_l = back_edges[v];
+    ASSERT(!embedg_dlcl_is_empty(tree_l) || !embedg_dlcl_is_empty(back_l));
+
+    least_n = n;  /* ok, invalid value for any neighbour */
+    p = tree_l;
+    if (!embedg_dlcl_is_empty(p))
+    {
+        if (p->info >= c)
+        {
+            least_n = p->info < least_n ? p->info : least_n;
+        }
+        p = embedg_dlcl_list_next(p);
+        while (p != tree_l)
+        {
+            if (p->info >= c)
+            {
+                least_n = p->info < least_n ? p->info : least_n;
+            }
+            p = embedg_dlcl_list_next(p);
+        }
+    }
+    p = back_l;
+    if (!embedg_dlcl_is_empty(p))
+    {
+        if (p->info >= c)
+        {
+            least_n = p->info < least_n ? p->info : least_n;
+        }
+        p = embedg_dlcl_list_next(p);
+        while (p != back_l)
+        {
+            if (p->info >= c)
+            {
+                least_n = p->info < least_n ? p->info : least_n;
+            }
+            p = embedg_dlcl_list_next(p);
+        }
+    }
+
+    ASSERT(least_n >= c);
+    /*
+      this is so because of the context where this function is called from
+    */
+    return least_n;
+}
+  
+static void 
+embedg_add_mark_u_x (t_dlcl **dfs_tree, t_dlcl **back_edges,
+	t_ver_edge *embed_graph, int n, int *edge_pos, int v,
+	int x, int *u_x, int mark)
+    /*
+      marking a Kuratowski homeomorph:
+      
+      marking and adding the unembedded dotted edge (u, x),
+      x an ext. active vertex wrt v
+    */
+{
+    int          c, d_x;
+    t_dlcl       *child_list;
+
+    ASSERT(embedg_VES_is_ver_ext_active(embed_graph, n, v, x));
+    if (embed_graph[x].least_ancestor < v)
+        /*
+          then there is a single unembedded back edge (u_x, x),
+          u_x an ancestor of v
+        */
+    {
+        *u_x = embed_graph[x].least_ancestor;
+        embed_graph[x].visited = mark;
+        embed_graph[*u_x].visited = mark;
+        embedg_VES_add_edge(embed_graph, n, edge_pos, *u_x, x,
+                                       TRUE, mark);
+        return;
+    }
+
+    /*
+      else there is a tree path x to d_x and an
+      unembedded back edge (u_x, d_x)
+
+      get the lowpoint of the first elt. in separated_DFS_child_list of x
+    */
+    child_list = embed_graph[x].separated_DFS_child_list;
+    ASSERT(!embedg_dlcl_is_empty(child_list));
+    c = child_list->info;
+    *u_x = embed_graph[c].lowpoint;
+
+    /*
+      search for the least neighbour of *u_x  >= c,
+      that is in the subtree rooted by c
+    */
+    d_x = embedg_get_least_neigh(dfs_tree, back_edges, n, *u_x, c);
+    ASSERT(d_x >= c);
+    /*
+      this must be true  since u_x is incident to a descendant of x
+      (remember: x is externally active)
+    */
+
+    /*
+      mark the DFS tree path from d_x to x
+    */
+    embedg_mark_tree_path(embed_graph, n, d_x, x, mark);
+    /*
+      add the unembedded (u_x, d_x) edge
+    */
+    embedg_VES_add_edge(embed_graph, n, edge_pos, *u_x, d_x,
+                                   TRUE, mark);
+}
+  
+static void 
+embedg_mark_tree_path (t_ver_edge *embed_graph, int n, int d_x, int x, int mark)
+    /*
+      marking the DFS tree path d_x...x where x is an ancestor of d_x
+    */
+{
+    int          cur_v, te, twe;
+
+    ASSERT(d_x >= x);
+    
+    cur_v = d_x;
+
+    while (cur_v != x)
+    {
+        embed_graph[cur_v].visited = mark;
+        te = embed_graph[cur_v].link[0];
+        ASSERT(embedg_VES_is_edge(n, te));
+        while (!embedg_VES_is_tree_edge(embed_graph, n, te)
+               || (embed_graph[te].neighbour > cur_v
+                   && embed_graph[te].neighbour != cur_v + n))
+            /*
+              want to find a tree edge incident to an ancestor of d_x:
+              given that d_x..x is a tree path, we MUST find such an edge!
+
+              note also that I must take account of the fact that
+              [te].neighbour could be a virtual vertex, in which case
+              it can only be cur_v + n!
+            */
+        {
+            te = embed_graph[te].link[0];
+        }
+        ASSERT(embedg_VES_is_tree_edge(embed_graph, n, te));
+        ASSERT(embed_graph[te].neighbour == embed_graph[cur_v].DFS_parent
+               || embed_graph[te].neighbour == cur_v + n);
+        
+        embed_graph[te].visited = mark;
+        twe =  embedg_VES_get_twin_edge(embed_graph, n, te);
+        embed_graph[twe].visited = mark;
+
+        /*
+          want only to deal with real vertices instead of virtual vertices
+        */
+        cur_v = embed_graph[te].neighbour < cur_v ?
+            embed_graph[te].neighbour : embed_graph[cur_v].DFS_parent;
+    }
+    embed_graph[x].visited = MARK_MINORS(n);
+}
+  
+
+static void 
+embedg_add_mark_v_w (t_dlcl **dfs_tree, t_dlcl **back_edges,
+	t_ver_edge *embed_graph, int n, int *edge_pos, int v, int w, int mark)
+    /*
+      marking a Kuratowski homeomorph:
+      
+      marking and adding the unembedded dotted edge (v, w),
+      w is pertinent wrt v
+    */
+{
+    int          vw, c, d_w;
+    t_dlcl       *bicomp_list;
+    
+    if (embed_graph[w].adjacent_to == v)
+        /*
+          then there is a single unembedded back edge (v, w)
+          w an ancestor of w
+        */
+    {
+        embed_graph[v].visited = mark;
+        embed_graph[w].visited = mark;
+        embedg_VES_add_edge(embed_graph, n, edge_pos, v, w,
+                                       TRUE, mark);
+        return;
+    }
+
+    /*
+      else there is a tree path w to d_w and an
+      unembedded back edge (v, d_w)
+
+      get the last elt in w's bicomp list
+    */
+    bicomp_list = embed_graph[w].pertinent_bicomp_list;
+    ASSERT(!embedg_dlcl_is_empty(bicomp_list));
+    vw = (embedg_dlcl_list_last(bicomp_list))->info;
+    c = vw - n;
+
+    /*
+      search for the least neighbour of v >= c,
+      that is in the subtree rooted by c
+    */
+    d_w = embedg_get_least_neigh(dfs_tree, back_edges, n, v, c);
+    ASSERT(d_w >= c);
+    /*
+      this must be true since v is incident to a descendant of w
+      (remember: w is pertinent)
+    */
+
+    /*
+      mark the DFS tree path from d_w to w
+    */
+    embedg_mark_tree_path(embed_graph, n, d_w, w, mark);
+    /*
+      add the unembedded (d_w, v) edge
+    */
+    embedg_VES_add_edge(embed_graph, n, edge_pos, d_w, v,
+                                   TRUE, mark);
+}
+
+
+static void 
+embedg_add_mark_v_w_for_B (t_dlcl **dfs_tree, t_dlcl **back_edges,
+	t_ver_edge *embed_graph, int n, int *edge_pos, int v, int w,
+	int *u_z, int mark)
+    /*
+      marking a Kuratowski homeomorph:
+      
+      marking and adding the unembedded dotted edge (v, w) for minor B:
+      w is pertinent wrt v
+    */
+{
+    int          vz, z, d_z, d_w;
+    t_dlcl       *bicomp_list;
+    
+    /*
+      get the last elt in w's bicomp list
+    */
+    bicomp_list = embed_graph[w].pertinent_bicomp_list;
+    ASSERT(!embedg_dlcl_is_empty(bicomp_list));
+    vz = (embedg_dlcl_list_last(bicomp_list))->info;
+    z = vz - n;
+
+    /*
+      get the lowpoint of z
+    */
+    *u_z = embed_graph[z].lowpoint;
+ 
+    /*
+      search for the least neighbour of *u_z  >= z,
+      that is in the subtree rooted by c
+    */
+    d_z = embedg_get_least_neigh(dfs_tree, back_edges, n, *u_z, z);
+    ASSERT(d_z >= z);
+    /*
+      this must be true since u_z is incident to z or a descendant of z
+    */
+
+    /*
+      now do the same for neighbours of v
+    */
+    d_w = embedg_get_least_neigh(dfs_tree, back_edges, n, v, z);
+    ASSERT(d_w >= z);
+    /*
+      this must be true since v is incident to a descendant of w
+      (remember: w is pertinent)
+    */
+  
+    /*
+      mark the DFS tree path from d_w to w
+    */
+    embedg_mark_tree_path(embed_graph, n, d_w, w, mark);
+    /*
+      mark the DFS tree path from d_z to z
+    */
+    embedg_mark_tree_path(embed_graph, n, d_z, z, mark);
+    /*
+      add & mark the edges (u_z, d_z), (v, d_w)
+    */
+    embedg_VES_add_edge(embed_graph, n, edge_pos, *u_z, d_z,
+                                   TRUE, mark);
+    embedg_VES_add_edge(embed_graph, n, edge_pos, v, d_w,
+                                   TRUE, mark);
+}
+
+static void 
+embedg_mark_x_y_path (t_ver_edge *embed_graph, int n, int *path_v,
+	int *path_e, int nbr_v, int mark)
+{
+    int          i;
+
+    /*      
+      have a look at embedg_iso_get_highest_x_y_path
+      to see that path_e[0] is a dummy
+
+      (note: path_v and path_e contain nbr_v + 1 elts!)
+    */
+    embed_graph[path_v[0]].visited = mark;
+    for (i = 1; i <= nbr_v; i++)
+    {
+        int        e, twin;
+        
+        embed_graph[path_v[i]].visited = mark;
+        e = path_e[i];
+        twin = embedg_VES_get_twin_edge(embed_graph, n, e);
+        embed_graph[e].visited =
+            embed_graph[twin].visited = mark;
+    }
+}
+
+void 
+embedg_mark_minor_A (t_dlcl **dfs_tree, t_dlcl **back_edges,
+	t_ver_edge *embed_graph, int n, int *edge_pos, int v, int c, int vr)
+{
+    int          r, r_c, x, y, w, u_x, u_y, u;
+
+    ASSERT(embedg_VES_is_virtual_vertex(n, vr));
+    r_c = vr - n;
+    r = embed_graph[r_c].DFS_parent;
+
+    /*
+      find the ext. active x & y, and the pertinent w,
+      and mark the external face of the bicomp rooted at vr
+    */
+    embedg_iso_get_x_y_w(embed_graph, n, v, r, r_c,
+                              MARK_MINORS(n),
+                              MARK_MINORS(n), MARK_MINORS(n), &x, &y, &w);
+
+    /*
+      mark the edges (u, x), (u, y), (v, w)
+    */
+    embedg_add_mark_u_x(dfs_tree, back_edges,
+                        embed_graph, n, edge_pos, v, x, &u_x,
+                        MARK_MINORS(n));
+    embedg_add_mark_u_x(dfs_tree, back_edges,
+                        embed_graph, n, edge_pos, v, y, &u_y,
+                        MARK_MINORS(n));
+    embedg_add_mark_v_w(dfs_tree, back_edges,
+                        embed_graph, n, edge_pos, v, w,
+                        MARK_MINORS(n));
+
+    /*
+      mark the tree path from r to min(u_x, u_y)
+    */
+    u = u_x <= u_y ? u_x : u_y;
+    embedg_mark_tree_path(embed_graph, n, r, u, MARK_MINORS(n));
+
+    IF_DEB(
+           fprintf(stdout, "mark minor A\n");
+           fprintf(stdout, "v %d\t c %d\t r %d\t r_c %d\t x %d\t y %d\t w %d\t u_x %d\t u_y %d\n",
+                   v, c, r, r_c, x, y, w, u_x, u_y);
+           )
+}
+
+void 
+embedg_mark_minor_B (t_dlcl **dfs_tree, t_dlcl **back_edges,
+	t_ver_edge *embed_graph, int n, int *edge_pos, int v,
+	int c, int x, int y, int w)
+{
+    int          vv, u_x, u_y, vz, u_z, u_max, u_min;
+
+    vv = c + n;
+
+    /*
+      mark the external face of the bicomp rooted by v^c
+    */
+    embedg_VES_walk_mark_ext_face(embed_graph, n, vv, MARK_MINORS(n));
+    ASSERT(embedg_VES_is_ext_face_marked(embed_graph, n, vv,
+                                              MARK_MINORS(n)));
+
+    /*
+      mark the edges (u, x), (u, y)
+    */
+    embedg_add_mark_u_x(dfs_tree, back_edges,
+                        embed_graph, n, edge_pos, v, x, &u_x,
+                        MARK_MINORS(n));
+    embedg_add_mark_u_x(dfs_tree, back_edges,
+                        embed_graph, n, edge_pos, v, y, &u_y,
+                        MARK_MINORS(n));
+
+    /*
+      mark the dotted edges (v, w), (v, u)
+    */
+    embedg_add_mark_v_w_for_B(dfs_tree, back_edges,
+                              embed_graph, n, edge_pos, v, w,
+                              &u_z, MARK_MINORS(n));
+
+    /*
+      mark the tree path from max(u_x, u_y, u_z) to min(u_x, u_y, u_z)
+    */
+    u_max = u_x > u_y ? u_x : u_y;
+    u_max = u_max > u_z ? u_max : u_z;
+    u_min = u_x < u_y ? u_x : u_y;
+    u_min = u_min < u_z ? u_min : u_z;
+    embedg_mark_tree_path(embed_graph, n, u_max, u_min, MARK_MINORS(n));
+
+    IF_DEB(
+           fprintf(stdout, "mark minor B\n");
+           fprintf(stdout, "v %d\t c %d\t x %d\t y %d\t w %d\t u_x %d\t u_y %d\t u_z %d\n",
+                   v, c, x, y, w, u_x, u_y, u_z);
+           )
+}
+
+void 
+embedg_mark_minor_C (t_dlcl **dfs_tree, t_dlcl **back_edges,
+	t_ver_edge *embed_graph, int n, int *edge_pos, int v,
+	int c, int x, int y, int w, int *path_v, int *path_e,
+	int nbr_v, boolean px_attached_high, boolean py_attached_high)
+{
+    int          vv, p_x, p_y, u_x, u_y, u;
+
+    vv = c + n;
+    p_x = path_v[0];
+    p_y = path_v[nbr_v];
+    /*
+      see embedg_iso_get_highest_x_y_path for the above
+    */
+    
+    if (px_attached_high)
+        /*
+          mark the external face:
+          - from v^c to p_y if py_attached_high
+          - from v^c to y if !py_attached_high
+
+          not too sure about that one....
+
+          from v^c to p_y: so vvin = 0,
+          in x's direction
+        */
+    {
+        if (py_attached_high)
+            embedg_VES_walk_mark_part_ext_face(embed_graph, n, vv, 0,
+                                                    vv, p_y, MARK_MINORS(n));
+        else
+            embedg_VES_walk_mark_part_ext_face(embed_graph, n, vv, 0,
+                                                    vv, y, MARK_MINORS(n));
+    }
+    else
+        /*
+          symmetric case:
+          mark the external face from v^c to p_x: so vvin = 1,
+          in y's direction
+        */
+    {
+        if (px_attached_high)
+            embedg_VES_walk_mark_part_ext_face(embed_graph, n, vv, 1,
+                                                    vv, p_x, MARK_MINORS(n));
+        else
+            embedg_VES_walk_mark_part_ext_face(embed_graph, n, vv, 1,
+                                                    vv, x, MARK_MINORS(n));
+    }
+
+    /*
+      mark the edges (u, x), (u, y), (v, w)
+    */
+    embedg_add_mark_u_x(dfs_tree, back_edges,
+                        embed_graph, n, edge_pos, v, x, &u_x,
+                        MARK_MINORS(n));
+    embedg_add_mark_u_x(dfs_tree, back_edges,
+                        embed_graph, n, edge_pos, v, y, &u_y,
+                        MARK_MINORS(n));
+    embedg_add_mark_v_w(dfs_tree, back_edges,
+                        embed_graph, n, edge_pos, v, w,
+                        MARK_MINORS(n));
+ 
+    /*
+      mark the tree path from v to min(u_x, u_y)
+    */
+    u = u_x <= u_y ? u_x : u_y;
+    embedg_mark_tree_path(embed_graph, n, v, u, MARK_MINORS(n));
+
+    /*
+      finally, mark the x-y path, ie the vertices in path_v
+      and the edges in path_e
+    */
+    embedg_mark_x_y_path(embed_graph, n, path_v, path_e, nbr_v,
+                         MARK_MINORS(n));
+
+    IF_DEB(
+           fprintf(stdout, "mark minor C      p_x high %d\t p_y high %d\n",
+                   px_attached_high, py_attached_high);
+           fprintf(stdout, "v %d\t c %d\t x %d\t y %d\t w %d\t p_x %d\t p_y %d\t u_x %d\t u_y %d\n",
+                   v, c, x, y, w, p_x, p_y, u_x, u_y);
+           )
+}
+
+void 
+embedg_mark_minor_D (t_dlcl **dfs_tree, t_dlcl **back_edges,
+	t_ver_edge *embed_graph, int n, int *edge_pos, int v,
+	int c, int x, int y, int w, int *path_v, int *path_e,
+	int nbr_v, int entry_in_path_e)
+{
+    int          i, vv, p_x, p_y, u_x, u_y, u;
+
+    vv = c + n;
+    p_x = path_v[0];
+    p_y = path_v[nbr_v];
+    /*
+      see embedg_iso_get_highest_x_y_path for the above
+    */
+    
+    /*
+      mark the lower external face from x to y: we can walk in
+      either direction
+    */
+    embedg_VES_walk_mark_part_ext_face(embed_graph, n, vv, 0,
+                                            x, y, MARK_MINORS(n));
+
+    /*
+      mark the internal path which goes from the x-y path to v
+      - since I haven't stored those vertices/edges I assume
+      that a proper face walk should suffice
+
+      BUT a walk that say starts at p_x and ends at vv,
+      that is, a walk starting at path_e[1] entered from entry_in_path_e
+      (recall that path_e[0] is a dummy)
+    */
+    embedg_VES_walk_mark_part_proper_face(embed_graph, n,
+                                               path_e[1], entry_in_path_e,
+                                               vv, MARK_MINORS(n));
+
+    /*
+      a note of caution here:
+      ALWAYS mark external/internal faces before adding any other edges:
+      since adding edges destroys the faces' consistency
+      (adding edges makes no sense of face since we are in a non-planar
+      situation)
+    */
+    /*
+      mark the edges (u, x), (u, y), (v, w)
+    */
+    embedg_add_mark_u_x(dfs_tree, back_edges,
+                        embed_graph, n, edge_pos, v, x, &u_x,
+                        MARK_MINORS(n));
+    embedg_add_mark_u_x(dfs_tree, back_edges,
+                        embed_graph, n, edge_pos, v, y, &u_y,
+                        MARK_MINORS(n));
+    embedg_add_mark_v_w(dfs_tree, back_edges,
+                        embed_graph, n, edge_pos, v, w,
+                        MARK_MINORS(n));
+ 
+    /*
+      mark the tree path from v to min(u_x, u_y)
+    */
+    u = u_x <= u_y ? u_x : u_y;
+    embedg_mark_tree_path(embed_graph, n, v, u, MARK_MINORS(n));
+
+    /*
+      mark the x-y path, ie the vertices in path_v
+      and the edges in path_e
+    */
+    embedg_mark_x_y_path(embed_graph, n, path_v, path_e, nbr_v,
+                         MARK_MINORS(n));
+
+    IF_DEB(
+           fprintf(stdout, "mark minor D\n");
+           fprintf(stdout, "v %d\t c %d\t x %d\t y %d\t w %d\t p_x %d\t p_y %d\t u_x %d\t u_y %d\n",
+                   v, c, x, y, w, p_x, p_y, u_x, u_y);
+           )
+}
+
+
+
+
+minor 
+embedg_mark_minor_E (t_dlcl **dfs_tree, t_dlcl **back_edges,
+	t_ver_edge *embed_graph, int n, int *edge_pos, int v,
+	int c, int x, int y, int w, int *path_v, int *path_e, int nbr_v)
+    /*
+      while marking minor E return which of the minors we are dealing with
+    */
+{
+    int          vv, p_x, p_y, u_x, u_y, u_w, u, u_max, u_min;
+
+    vv = c + n;
+    p_x = path_v[0];
+    p_y = path_v[nbr_v];
+    /*
+      see embedg_iso_get_highest_x_y_path for the above
+    */
+
+    if (!embedg_VES_is_ver_ext_active(embed_graph, n, v, w))
+        /*
+          minor E1 case: we must find an ext. active z, distinct from w,
+          on the external face p_x..w..p_y
+        */
+    {
+        int       s, sin, cur, curin, z, u_z, u_xy;
+        
+        s = n;
+        /*
+          start searching at vv entered from 0 (in x's direction)
+          -- we MUST reach p_x - hopefully! :)
+        */
+        cur = vv;
+        curin = 0;
+        while (s != p_x)
+            /*
+              first advance to p_x: we are sure of reaching it
+            */
+        {
+            embedg_VES_get_succ_on_ext_face(embed_graph, n,
+                                                 cur, curin,
+                                                 FALSE, 0, &s, &sin);
+            cur = s;
+            curin = sin;
+        }
+
+        /*
+          continue the walk on the external face:
+          stop if either s is ext. active OR s == w
+
+          we'll mark the lot later on
+        */
+        while (
+               !(embedg_VES_is_ver_ext_active(embed_graph, n, v,
+                                                         s)
+                 && s != p_x)
+               && s != w)
+        {
+            embedg_VES_get_succ_on_ext_face(embed_graph, n, cur, curin,
+                                                 FALSE, 0, &s, &sin);
+            cur = s;
+            curin = sin;
+        }
+        /*
+          now we must decide which symmetry we are in
+        */
+        if (embedg_VES_is_ver_ext_active(embed_graph, n, v, s))
+            /*
+              z is between x and w (recall that w is NOT ext. active)
+            */
+        {
+            z = s;
+            ASSERT(z != w);
+
+            /*
+              mark the external face from v^c to y in x's direction
+            */
+            embedg_VES_walk_mark_part_ext_face(embed_graph, n, vv, 0,
+                                                    vv, y, MARK_MINORS(n));
+            /*
+              add/mark dotted edge (u, y)
+            */
+            embedg_add_mark_u_x(dfs_tree, back_edges,
+                                embed_graph, n, edge_pos,
+                                v, y, &u_xy, MARK_MINORS(n));
+        }
+        else
+            /*
+              this is the symmetric case: must find z between w and p_y
+            */
+        {
+            ASSERT(s == w);
+            embedg_VES_get_succ_ext_active_on_ext_face(embed_graph, n, 
+                                                            v, cur, curin,
+                                                            FALSE, 0,
+                                                            &s, &sin);
+            /*
+              and z is distinct from p_y!
+            */
+            z = s;
+            ASSERT(z != p_y);
+
+            /*
+              mark the external face from v^c to x in y's direction
+            */
+            embedg_VES_walk_mark_part_ext_face(embed_graph, n, vv, 1,
+                                                    vv, x, MARK_MINORS(n));
+            /*
+              add/mark dotted edge (u, x)
+            */
+            embedg_add_mark_u_x(dfs_tree, back_edges,
+                                embed_graph, n, edge_pos,
+                                v, x, &u_xy, MARK_MINORS(n));
+        }
+        /*
+          now the marked bits which are common to both cases:
+          dotted edges (u, z), (v, w), the x-y path,
+          the tree path (v, min(u_xy, u_z))
+        */
+        embedg_add_mark_u_x(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos,
+                            v, z, &u_z, MARK_MINORS(n));
+        embedg_add_mark_v_w(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos, v, w,
+                            MARK_MINORS(n));
+
+        embedg_mark_x_y_path(embed_graph, n, path_v, path_e, nbr_v,
+                             MARK_MINORS(n));
+        
+        u = u_z <= u_xy ? u_z : u_xy;
+        embedg_mark_tree_path(embed_graph, n, v, u, MARK_MINORS(n));
+
+        IF_DEB(
+               fprintf(stdout, "mark minor E1\n");
+               fprintf(stdout, "v %d\t c %d\t x %d\t y %d\t z %d\t w %d\t p_x %d\t p_y %d\t u_xy %d\t u_z %d\n",
+                       v, c, x, y, z, w, p_x, p_y, u_xy, u_z);
+           )
+
+        return MINOR_E1;
+    }
+    
+    /*
+      in all other cases we get u_x, u_y, u_w back
+      from the ext. active vertices x, y, w resp.
+
+      again, I CANNOT embed these edges now since that would destroy
+      my external/internal faces
+    */
+    
+    embedg_get_u_x(embed_graph, n, v, x, &u_x);
+    embedg_get_u_x(embed_graph, n, v, y, &u_y);
+    embedg_get_u_x(embed_graph, n, v, w, &u_w);
+
+    if (u_w > u_x && u_w > u_y)
+        /*
+          minor E2 case:
+          we mark the whole external face rooted by v^c
+          and the tree path (v, min(u_x, u_y))
+        */
+    {
+        embedg_VES_walk_mark_ext_face(embed_graph, n, vv,
+                                           MARK_MINORS(n));
+        u = u_x <= u_y ? u_x : u_y;
+        embedg_mark_tree_path(embed_graph, n, v, u, MARK_MINORS(n));
+
+        /*
+          embed dotted edges (u, x), (u, y) & (u, w)
+        */
+        embedg_add_mark_u_x(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos,
+                            v, x, &u_x, MARK_MINORS(n));
+        embedg_add_mark_u_x(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos,
+                            v, y, &u_y, MARK_MINORS(n));
+        embedg_add_mark_u_x(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos,
+                            v, w, &u_w, MARK_MINORS(n));
+        
+        IF_DEB(
+               fprintf(stdout, "mark minor E2\n");
+               fprintf(stdout, "v %d\t c %d\t x %d\t y %d\t w %d\t p_x %d\t p_y %d\t u_x %d\t u_y %d\t u_w %d\n",
+                       v, c, x, y, w, p_x, p_y, u_x, u_y, u_w);
+           )
+            
+        return MINOR_E2;
+    }
+
+    /*
+      two more things common to all remaining cases:
+
+      mark the dotted edge (v, w) (but we MUST do that later)
+      
+      mark the x-y path
+    */
+    embedg_mark_x_y_path(embed_graph, n, path_v, path_e, nbr_v,
+                         MARK_MINORS(n));
+     
+    if (u_x < u_y && u_w < u_y)
+        /*
+          minor E3 case: one of the symmetric cases:
+          the external face rooted at v_c from vv to x (in x's direction)
+          the external face rooted at v_c from y to w (in y's direction)
+          the (v, min(u_w, u_x)) tree path
+        */
+    {
+        embedg_VES_walk_mark_part_ext_face(embed_graph, n, vv, 0,
+                                                vv, p_x, MARK_MINORS(n));
+        embedg_VES_walk_mark_part_ext_face(embed_graph, n, vv, 1,
+                                                y, w, MARK_MINORS(n));
+        
+        u = u_x <= u_w ? u_x : u_w;
+        embedg_mark_tree_path(embed_graph, n, v, u, MARK_MINORS(n));
+
+        /*
+          embed dotted edges (u, x), (u, y), (u, w), (v, w)
+        */
+        embedg_add_mark_u_x(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos,
+                            v, x, &u_x, MARK_MINORS(n));
+        embedg_add_mark_u_x(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos,
+                            v, y, &u_y, MARK_MINORS(n));
+        embedg_add_mark_u_x(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos,
+                            v, w, &u_w, MARK_MINORS(n));
+        embedg_add_mark_v_w(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos, v, w,
+                            MARK_MINORS(n));
+
+        IF_DEB(
+               fprintf(stdout, "mark minor E3/a\n");
+               fprintf(stdout, "v %d\t c %d\t x %d\t y %d\t w %d\t p_x %d\t p_y %d\t u_x %d\t u_y %d\t u_w %d\n",
+                       v, c, x, y, w, p_x, p_y, u_x, u_y, u_w);
+           )
+            
+        return MINOR_E3;
+    }
+    if (u_y < u_x && u_w < u_x)
+        /*
+          minor E3 case: the other symmetric case:
+          the external face rooted at v_c from vv to y (in y's direction)
+          the external face rooted at v_c from x to w (in x's direction)
+          the (v, min(u_w, u_y)) tree path
+        */
+    {
+        embedg_VES_walk_mark_part_ext_face(embed_graph, n, vv, 1,
+                                                vv, p_y, MARK_MINORS(n));
+        embedg_VES_walk_mark_part_ext_face(embed_graph, n, vv, 0,
+                                                x, w, MARK_MINORS(n));
+
+        u = u_y <= u_w ? u_y : u_w;
+        embedg_mark_tree_path(embed_graph, n, v, u, MARK_MINORS(n));
+
+        /*
+          embed dotted edges (u, x), (u, y), (u, w), (v, w)
+        */
+        embedg_add_mark_u_x(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos,
+                            v, x, &u_x, MARK_MINORS(n));
+        embedg_add_mark_u_x(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos,
+                            v, y, &u_y, MARK_MINORS(n));
+        embedg_add_mark_u_x(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos,
+                            v, w, &u_w, MARK_MINORS(n));
+        embedg_add_mark_v_w(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos, v, w,
+                            MARK_MINORS(n));
+
+        IF_DEB(
+               fprintf(stdout, "mark minor E3/b\n");
+               fprintf(stdout, "v %d\t c %d\t x %d\t y %d\t w %d\t p_x %d\t p_y %d\t u_x %d\t u_y %d\t u_w %d\n",
+                       v, c, x, y, w, p_x, p_y, u_x, u_y, u_w);
+           )
+            
+        return MINOR_E3;
+    }
+    
+    if (p_x != x)
+        /*
+          minor E4 case: one of the symmetric cases:
+          the external face rooted at v_c from vv to w (in x's direction)
+          the external face rooted at v_c from vv to p_y (in y's direction)
+          the tree path from max(u_x, u_y, u_w) to min(u_x, u_y, u_w)
+        */
+    {
+        embedg_VES_walk_mark_part_ext_face(embed_graph, n, vv, 0,
+                                                vv, w, MARK_MINORS(n));
+        embedg_VES_walk_mark_part_ext_face(embed_graph, n, vv, 1,
+                                                vv, p_y, MARK_MINORS(n));
+        
+        u_max = u_x > u_y ? u_x : u_y;
+        u_max = u_max > u_w ? u_max : u_w;
+        u_min = u_x < u_y ? u_x : u_y;
+        u_min = u_min < u_w ? u_min : u_w;
+        embedg_mark_tree_path(embed_graph, n, u_max, u_min, MARK_MINORS(n));
+
+        /*
+          embed dotted edges (u, x), (u, y), (u, w), (v, w)
+        */
+        embedg_add_mark_u_x(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos,
+                            v, x, &u_x, MARK_MINORS(n));
+        embedg_add_mark_u_x(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos,
+                            v, y, &u_y, MARK_MINORS(n));
+        embedg_add_mark_u_x(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos,
+                            v, w, &u_w, MARK_MINORS(n));
+        embedg_add_mark_v_w(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos, v, w,
+                            MARK_MINORS(n));
+
+        IF_DEB(
+               fprintf(stdout, "mark minor E4/a\n");
+               fprintf(stdout, "v %d\t c %d\t x %d\t y %d\t w %d\t p_x %d\t p_y %d\t u_x %d\t u_y %d\t u_w %d\n",
+                       v, c, x, y, w, p_x, p_y, u_x, u_y, u_w);
+           )
+            
+        return MINOR_E4;
+    }
+    if (p_y != y)
+        /*
+          minor E4 case: the other symmetric case:
+          the external face rooted at v_c from vv to w (in y's direction)
+          the external face rooted at v_c from vv to x (in x's direction)
+          (here p_x = x!)
+          the tree path from max(u_x, u_y, u_w) to min(u_x, u_y, u_w)
+        */
+    {
+        embedg_VES_walk_mark_part_ext_face(embed_graph, n, vv, 1,
+                                                vv, w, MARK_MINORS(n));
+        embedg_VES_walk_mark_part_ext_face(embed_graph, n, vv, 0,
+                                                vv, x, MARK_MINORS(n));
+        
+        u_max = u_x > u_y ? u_x : u_y;
+        u_max = u_max > u_w ? u_max : u_w;
+        u_min = u_x < u_y ? u_x : u_y;
+        u_min = u_min < u_w ? u_min : u_w;
+        embedg_mark_tree_path(embed_graph, n, u_max, u_min, MARK_MINORS(n));
+
+        /*
+          embed dotted edges (u, x), (u, y), (u, w), (v, w)
+        */
+        embedg_add_mark_u_x(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos,
+                            v, x, &u_x, MARK_MINORS(n));
+        embedg_add_mark_u_x(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos,
+                            v, y, &u_y, MARK_MINORS(n));
+        embedg_add_mark_u_x(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos,
+                            v, w, &u_w, MARK_MINORS(n));
+        embedg_add_mark_v_w(dfs_tree, back_edges,
+                            embed_graph, n, edge_pos, v, w,
+                            MARK_MINORS(n));
+
+        IF_DEB(
+               fprintf(stdout, "mark minor E$/b\n");
+               fprintf(stdout, "v %d\t c %d\t x %d\t y %d\t w %d\t p_x %d\t p_y %d\t u_x %d\t u_y %d\t u_w %d\n",
+                       v, c, x, y, w, p_x, p_y, u_x, u_y, u_w);
+           )
+            
+        return MINOR_E4;
+    }
+
+    /*
+      this is the last case for minor E: when the homeomorph is K5
+      
+      mark the whole external face rooted at v^c
+      mark the tree path from v to min(u_x, u_y, u_w)
+    */
+
+    embedg_VES_walk_mark_ext_face(embed_graph, n, vv, MARK_MINORS(n));
+    
+    u = u_x < u_y ? u_x : u_y;
+    u = u < u_w ? u : u_w;
+    embedg_mark_tree_path(embed_graph, n, v, u, MARK_MINORS(n));
+
+    /*
+      embed dotted edges (u, x), (u, y), (u, w), (v, w)
+    */
+    embedg_add_mark_u_x(dfs_tree, back_edges,
+                        embed_graph, n, edge_pos,
+                        v, x, &u_x, MARK_MINORS(n));
+    embedg_add_mark_u_x(dfs_tree, back_edges,
+                        embed_graph, n, edge_pos,
+                        v, y, &u_y, MARK_MINORS(n));
+    embedg_add_mark_u_x(dfs_tree, back_edges,
+                        embed_graph, n, edge_pos,
+                        v, w, &u_w, MARK_MINORS(n));
+    embedg_add_mark_v_w(dfs_tree, back_edges,
+                        embed_graph, n, edge_pos, v, w,
+                        MARK_MINORS(n));
+    
+    IF_DEB(
+           fprintf(stdout, "mark minor E5\n");
+           fprintf(stdout, "v %d\t c %d\t x %d\t y %d\t w %d\t p_x %d\t p_y %d\t u_x %d\t u_y %d\t u_w %d\n",
+                   v, c, x, y, w, p_x, p_y, u_x, u_y, u_w);
+           )
+            
+    return MINOR_E5;
+}
+/*
+ *  proper_face_walk.c
+ */
+ 
+/*
+  What:
+  *****
+  
+  Implementing a proper face walk within the VES structure.
+  This is obviously not the same as an external face walk,
+  but is simply the standard face walk in a planar embedding.
+
+  Not much to say, if only to emphasize that for our
+  purposes here we assume:
+
+  1. the short-cut edges have been removed from the VES structure
+  2. each vertex/edge has been given its orientation
+  2. the adjacency lists (vertex + plus its incident edges)
+     are consistent:  (and this is IMPORTANT)
+     that is, the way to traverse an adj. list (ie what
+     constitute previous and next in the list which actually
+     is a planar embedding at this stage) is indicated
+     by the vertex/edge's orientation
+
+
+     try to explain this better another time.... sorry...
+  
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  from 
+
+  Simplified O(n) Planarity Algorithms  (draft)
+  ************************************
+  
+  John Boyer      JBoyer@PureEdge.com, jboyer@acm.org
+  Wendy Myrvold   wendym@csr.uvic.ca
+
+
+  ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  authors:
+  ********
+
+  Paulette Lieby (Magma), Brendan McKay (ANU)
+
+  Started October 2001
+*/
+
+ 
+#include "planarity.h"
+ 
+#define IF_DEB(x)    {}
+#define IF_DEB_PROPER_FACE(x)    {}
+#define IF_VERB(x)   {}
+
+ 
+ 
+/* aproto: header embed_graph_protos.h */
+
+
+
+
+boolean 
+embedg_VES_get_succ_on_proper_face_with_avoidance (t_ver_edge *embed_graph,
+	int n, int e, int ein, int a, boolean MARK, int mark, int *s,
+	int *next_e, int *next_ein)
+    /*
+      find the successor s of embed_graph[e].neighbour
+      (entered via ein) on a proper face traversal
+      which avoids (the vertex) a if a != n 
+
+      also returns the edge next_e such that
+      embed_graph[next_e].neighbour = s (to allow for continuation
+      of the walk)
+
+      assumes that short-cut edges have been removed and that each
+      edge/vertex has been given its orientation
+
+      and (more importantly) assumes that adjacency lists are consistent
+
+      this function has been written especially to retrieve the highest
+      x-y path for the isolator;
+      (see embedg_iso_get_highest_x_y_path)
+      but as I discovered later (when marking an internal face
+      as for minor D) this function is general purpose
+
+      PLUS: return true if the proper face walk has to skip an edge
+      incident to a (ie had to "avoid" a)
+
+      PLUS: mark s & next_e if so requested
+    */
+{
+    int            eout;
+    int            twin, twinout;
+    boolean        avoid_a;
+
+    ASSERT(embedg_VES_is_edge(n, e));
+    ASSERT(!embedg_VES_is_short_cut_edge(embed_graph, n, e));
+
+    IF_DEB(
+           fprintf(stdout, "get_succ_on_proper_face, \n");
+           )
+
+    avoid_a = FALSE;
+    /*
+      find the direction out of the edge
+    */
+    eout = 1 ^ ein;
+
+    /*
+      get the twin edge
+    */
+    twin = embedg_VES_get_twin_edge(embed_graph, n, e);
+ 
+    /*
+      for each edge we must set the way to get to the next
+      in the adjacency list:
+      adjacency lists are traversed according to the vertex/edges
+      orientation (one unique orientation per list of course)
+    */
+    if (embed_graph[e].sign != embed_graph[twin].sign)
+        /*
+          invert traversal
+        */
+    {
+        twinout = 1 ^ eout;
+    }
+    else
+        /*
+          traversal is identical
+        */
+    {
+        twinout = eout;
+    }
+ 
+    /*
+      now, we want the edge previous to twin in twin's adjacency list,
+      ie link[1 ^ twinout]
+    */
+    *next_e = embed_graph[twin].link[1 ^ twinout];
+    /*
+      next_e could be a vertex, I need an edge
+    */
+    if (embedg_VES_is_vertex(n, *next_e)
+        || embedg_VES_is_virtual_vertex(n, *next_e))
+        /*
+          at this stage all virtual vertices should have
+          been disabled BUT the vertices rooting the bicomps!!!
+        */
+    {
+        *next_e = embed_graph[*next_e].link[1 ^ twinout];
+    }
+    ASSERT(embedg_VES_is_edge(n, *next_e));
+    ASSERT(!embedg_VES_is_short_cut_edge(embed_graph, n, e));
+    *s = embed_graph[*next_e].neighbour;
+
+    if (*s == a)
+        /*
+          want to avoid this vertex, so must get yet previous
+          edge in adjacency list
+        */
+    {
+        avoid_a = TRUE;
+        
+        *next_e = embed_graph[*next_e].link[1 ^ twinout];
+        if (embedg_VES_is_vertex(n, *next_e)
+            || embedg_VES_is_virtual_vertex(n, *next_e))
+        {
+            *next_e = embed_graph[*next_e].link[1 ^ twinout];
+        }
+        ASSERT(embedg_VES_is_edge(n, *next_e));
+        ASSERT(!embedg_VES_is_short_cut_edge(embed_graph, n, e));
+    }
+    *s = embed_graph[*next_e].neighbour;
+    ASSERT(*s != a);
+
+    /*
+      finally (again, because lists  are consistent)
+    */
+    *next_ein = 1 ^ twinout;
+
+    /*
+      now mark s and next_e if required
+    */
+    if (MARK)
+    {
+        embed_graph[*s].visited = 
+            embed_graph[*next_e].visited = mark;
+        /*
+          ouuh... must mark the twin as well....
+          but ONLY when we mark the minors....
+          that is poor design, can we do better????
+          -- don't think so...
+
+          (when we mark when counting the faces, we MUST only
+          mark the edge and NOT its twin)
+        */
+        if (mark == MARK_MINORS(n))
+        {
+            twin =
+                embedg_VES_get_twin_edge(embed_graph, n, *next_e);
+            embed_graph[twin].visited = mark;
+        }
+    }
+
+    return avoid_a;
+}
+
+
+
+void 
+embedg_VES_get_succ_on_proper_face (t_ver_edge *embed_graph, int n, int e,
+	int ein, int MARK, int mark, int *s, int *next_e, int *next_ein)
+    /*
+      same as above but without avoidance
+    */
+{
+    boolean  avoid;
+    
+    avoid =
+        embedg_VES_get_succ_on_proper_face_with_avoidance(
+                                                       embed_graph, n,
+                                                       e, ein, n,
+                                                       MARK, mark,
+                                                       s, next_e, next_ein);
+    ASSERT(avoid == FALSE);
+}
+
+
+void 
+embedg_VES_walk_proper_face (t_ver_edge *embed_graph, int n, int e,
+	int ein, boolean MARK, int mark)
+    /*
+      traversing a proper face starting at edge e which has been entered
+      via ein
+
+      -- we mark the visited edges with mark if so requested
+
+      assumes that short-cut edges have been removed and that each
+      edge/vertex has been given its orientation
+    */
+{
+    int     s, cur_e, cur_ein, next_e, next_ein;
+
+    next_e = n; /* this is an invalid value for an edge */
+
+    IF_DEB_PROPER_FACE(
+                       fprintf(stdout, "proper face traversal\n");
+                       )
+
+    cur_e = e;
+    cur_ein = ein;
+    while (next_e != e)
+    {
+        ASSERT(embedg_VES_is_edge(n, cur_e));
+        ASSERT(!embedg_VES_is_short_cut_edge(embed_graph,
+                                                        n, cur_e));
+        IF_DEB_PROPER_FACE(
+                           embedg_VES_print_edge(embed_graph, n, cur_e);
+                           )
+
+        embedg_VES_get_succ_on_proper_face(embed_graph, n,
+                                                cur_e, cur_ein,
+                                                MARK, mark,
+                                                &s, &next_e, &next_ein);
+        cur_e = next_e;
+        cur_ein = next_ein;
+    }
+
+    /*
+      note that by doing so we would have marked e and the first of e's
+      endpoints since by exiting the loop e = next_e and s is the
+      actual starting vertex of the walk
+    */
+}
+
+
+
+
+
diff --git a/lib/nauty/planarity.h b/lib/nauty/planarity.h
new file mode 100644
index 0000000..1943437
--- /dev/null
+++ b/lib/nauty/planarity.h
@@ -0,0 +1,457 @@
+/*
+  data structures and stuff for the planarity algorithm
+
+  Paulette Lieby, Brendan McKay
+  October 2001
+*/
+
+#ifndef _PLANARITY_H_
+#define _PLANARITY_H_
+
+
+
+/* The following line must be uncommented for compiling into Magma. */
+/* #define PLANAR_IN_MAGMA  */
+
+
+#ifdef PLANAR_IN_MAGMA
+#include "defs.h"
+#include "system.h"   /* includes <stdio.h> <signal.h> "system_math.h"
+                         <setjmp.h> <ctype.h> and more
+                      */
+#else
+/* not PLANAR_IN_MAGMA */
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <time.h>
+
+#undef FALSE
+#undef TRUE
+#define FALSE 0
+#define TRUE  1
+
+#define NP NULL
+
+#define ASSERT(x) assert(x)
+#define DIE() exit(0)
+
+#define mem_malloc malloc
+#define mem_realloc realloc
+#define mem_free free
+
+#include "naututil.h"
+#ifdef CPUDEFS
+CPUDEFS
+#endif
+#define time_current_user() CPUTIME
+
+#endif  /* not  PLANAR_IN_MAGMA */
+
+#include "nauty.h" 
+
+
+
+
+
+/*
+  max number of edges (and directed edges) for the embed_graph
+  data structure:
+  1 more than for a (possibly) planar graph to allow search for obstructions
+
+  1. if the graph is planar the embedding cannot possibly contain
+  more than 3*n - 6 edges (including the short cut edges)
+  2. if the graph is non planar, when retrieving and marking the
+  obstruction, we introduce EXACTLY one edge crossing
+*/
+#define MAXE(n) ((n) > 1 ? 3*(n) - 5 : 0)
+#define MAXDE(n) (6*(n) - 10)
+
+#define NIL -1
+#define CUTV -2     /* obviously used in diff. circ. than NILSIGN */
+#define NILSIGN -2
+#define CCLOCKW 1
+#define CLOCKW -1
+#define TE 1
+#define BE 2
+#define SCE 3
+
+/*
+  various "marks" for various purposes, ONLY for the t_ver_edge str
+
+  note: do NOT use a mark in {0,..,n} since those values are
+  used either while initialising or in the walkup procedure
+*/
+#define MARK_EMBED(n) ((n)+1)
+#define MARK_EXT_FACE(n) ((n)+2)
+#define MARK_EXT_FACE_L(n) ((n)+3)
+#define MARK_EXT_FACE_R(n) ((n)+4)
+#define MARK_X_Y_PATH(n) ((n)+5)
+#define MARK_MINORS(n) ((n)+6)
+#define MIN_EMBED_MARK    0   /* ONLY for the t_embed_sparse_rep str */
+                        
+
+typedef enum
+{
+    MINOR_A,
+    MINOR_B,
+    MINOR_C,
+    MINOR_D,
+    MINOR_E,
+    MINOR_E1,
+    MINOR_E2,
+    MINOR_E3,
+    MINOR_E4,
+    MINOR_E5,
+    NBR_MINORS
+} minor;
+
+
+/*
+  a basic doubly linked circular list storing
+  vertices/edges from the "big" 2*n + 2(3*n-5) array of vertices/edges
+
+  only used internally in the planarity tester: especially
+  where ordering of the vertices is important
+*/
+typedef struct dlcl {
+    int            info;
+    /*
+      info is:
+      - position in "big" array
+    */
+    int            in_adjl;      /* if relevant, the pos in the adjl. list
+                                    of this edge
+                                 */
+    int            twin_in_adjl; /* if relevant, the pos in the adjl. list
+                                    of the twin of this edge
+                                 */
+    int            mult;         /* if relevant, #occurences if this edge
+                                    (when graph is not simple
+                                 */
+    struct dlcl    * right;
+    struct dlcl    * left;
+} t_dlcl;
+
+
+/*
+  a common structure for both (virtual) vertex & edge
+*/
+typedef struct ver_edge {
+    /* vertex data */
+    int          label;
+    int          DFS_parent;
+    int          least_ancestor;
+    int          lowpoint;
+    t_dlcl       * separated_DFS_child_list;
+    t_dlcl       * rep_in_parent_list;
+    t_dlcl       * pertinent_bicomp_list;
+    int          adjacent_to;
+    int          visited;
+    /* edge data */
+    int          neighbour;
+    int          in_adjl;
+    int          twin_in_adjl; 
+    int          mult;
+    int          type;
+    int          sign;
+    /* link the lot in a doubly linked circular list           */
+    /* links indicate positions in the array of vertices/edges */
+    int          link[2];
+} t_ver_edge;
+
+
+/*
+  data structure for the merge queue
+*/
+typedef struct merge_queue {
+    int          start, end;
+    int          *b;
+} t_merge_queue;
+
+
+
+/*
+  data structure for the sparse graph representation:
+  the array of vertices
+*/
+typedef struct ver_sparse_rep {
+    int          first_edge; /* can be index into an adj. list
+                                or an embedding */
+} t_ver_sparse_rep;
+
+/*
+  data structure for the sparse graph representation:
+  a record in the adjacency list
+*/
+typedef struct adjl_sparse_rep {
+    int          end_vertex; 
+    int          next;   /* next in list as an index in the adj. list */
+} t_adjl_sparse_rep;
+
+/*
+  data structure for the sparse graph representation:
+  a record in the embedding
+*/
+typedef struct embed_sparse_rep {
+    int          in_adjl;/* index of edge in adj. list */
+    int          next;   /* next edge in embedding  */
+    int          prev;   /* previous edge in embedding  */
+    int          inv;    /* inverse edge */
+    int          mark;   /* a spot for marking */
+} t_embed_sparse_rep;
+
+/*
+  data structure for the sparse graph representation:
+  a record an individual edge
+*/
+typedef struct edge_sparse_rep {
+    int          ends[2];
+} t_edge_sparse_rep;
+
+/*
+  data structure for the sparse graph representation:
+  a record for a component
+*/
+typedef struct comp_sparse_rep {
+    int          nbr_v;   /* nbr of vertices */
+    int          *v;      /* the actual vertices */
+} t_comp_sparse_rep;
+
+typedef struct graph_sparse_rep {
+        t_ver_sparse_rep    *V;
+	int                 n;
+	t_adjl_sparse_rep   *A;
+	int                 size_A;
+	int                 pos_A;
+	int                 nbr_e;   /* ALWAYS # directed edges */
+} t_graph_sparse_rep;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * embed_graph_protos.h
+ */
+
+/* aproto: file embed_graph/sparseg_adjl_pred.c */
+extern boolean sparseg_adjl_dir_edge_exists (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int, int);
+extern boolean sparseg_adjl_u_adj_v (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int, int);
+extern boolean sparseg_adjl_sub (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, t_ver_sparse_rep *, int, t_adjl_sparse_rep *);
+extern boolean sparseg_adjl_eq (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, t_ver_sparse_rep *, int, t_adjl_sparse_rep *);
+/* aproto: endfile */
+/* aproto: file embed_graph/VES_misc.c */
+extern boolean embedg_VES_is_vertex (int, int);
+extern boolean embedg_VES_is_virtual_vertex (int, int);
+extern boolean embedg_VES_is_edge (int, int);
+extern boolean embedg_VES_is_tree_edge (t_ver_edge *, int, int);
+extern boolean embedg_VES_is_back_edge (t_ver_edge *, int, int);
+extern boolean embedg_VES_is_short_cut_edge (t_ver_edge *, int, int);
+extern void embedg_VES_print_vertex (int, int);
+extern void embedg_VES_print_virtual_vertex (t_ver_edge *, int, int);
+extern void embedg_VES_print_any_vertex (t_ver_edge *, int, int);
+extern void embedg_VES_print_any_rec (t_ver_edge *, int, int);
+extern void embedg_VES_print_edge (t_ver_edge *, int, int);
+extern void embedg_VES_print_flipped_edges (t_ver_edge *, int, int);
+extern int embedg_VES_get_edge_from_ver (t_ver_edge *, int, int);
+extern int embedg_VES_get_ver_from_edge (t_ver_edge *, int, int);
+extern int embedg_VES_get_twin_edge (t_ver_edge *, int, int);
+extern int embedg_VES_get_ver_from_virtual (t_ver_edge *, int, int);
+extern int embedg_VES_get_ver (t_ver_edge *, int, int);
+extern int embedg_VES_get_next_in_dlcl (t_ver_edge *, int, int, int);
+extern void embedg_VES_walk_bicomp (t_ver_edge *, int, int, int);
+extern void embedg_VES_print_adj_list (t_ver_edge *, int, int, boolean);
+extern boolean embedg_VES_is_adj_list_consistent (t_ver_edge *, int, int);
+extern boolean embedg_VES_are_adj_lists_consistent (t_ver_edge *, int);
+extern void embedg_VES_remove_edge (t_ver_edge *, int, int);
+extern void embedg_VES_set_orientation (t_ver_edge *, int, int *);
+/* aproto: endfile */
+/* aproto: file embed_graph/embed_edge.c */
+extern void embedg_VES_embed_edge (t_ver_edge *, int, int *, int, int, int, int, int);
+extern void embedg_VES_add_edge (t_ver_edge *, int, int *, int, int, boolean, int);
+/* aproto: endfile */
+/* aproto: file embed_graph/embedg_misc.c */
+extern void embedg_VES_delete (t_ver_edge *, int);
+extern void embedg_VES_print (t_ver_edge *, int);
+extern void embedg_VES_print_bigcomps (t_ver_edge *, int);
+/* aproto: endfile */
+/* aproto: file embed_graph/ext_face_walk.c */
+extern void embedg_VES_get_succ_on_ext_face (t_ver_edge *, int, int, int, boolean, int, int *, int *);
+extern void embedg_VES_get_succ_active_on_ext_face (t_ver_edge *, int, int, int, int, boolean, int, int *, int *);
+extern void embedg_VES_get_succ_ext_active_on_ext_face (t_ver_edge *, int, int, int, int, boolean, int, int *, int *);
+extern void embedg_VES_get_succ_pertinent_on_ext_face (t_ver_edge *, int, int, int, int, boolean, int, int *, int *);
+/* aproto: endfile */
+/* aproto: file embed_graph/isolator.c */
+extern int embedg_iso_get_c_of_v (t_ver_edge *, int, int, int);
+extern boolean embedg_iso_is_minor_A (t_ver_edge *, int, int *, int, int, int *);
+extern void embedg_iso_get_x_y_w (t_ver_edge *, int, int, int, int, int, int, int, int *, int *, int *);
+extern boolean embedg_iso_is_minor_B (t_ver_edge *, int, int *, int, int, int *, int *, int *);
+extern void embedg_iso_get_highest_x_y_path (t_ver_edge *, int, int, int, int, int, int, int, int, int, int **, int **, int *, int *, boolean *, boolean *, boolean *);
+/* aproto: endfile */
+/* aproto: file embed_graph/mark_kur.c */
+extern boolean embedg_VES_is_ext_face_marked (t_ver_edge *, int, int, int);
+extern void embedg_mark_minor_A (t_dlcl **, t_dlcl **, t_ver_edge *, int, int *, int, int, int);
+extern void embedg_mark_minor_B (t_dlcl **, t_dlcl **, t_ver_edge *, int, int *, int, int, int, int, int);
+extern void embedg_mark_minor_C (t_dlcl **, t_dlcl **, t_ver_edge *, int, int *, int, int, int, int, int, int *, int *, int, boolean, boolean);
+extern void embedg_mark_minor_D (t_dlcl **, t_dlcl **, t_ver_edge *, int, int *, int, int, int, int, int, int *, int *, int, int);
+extern minor embedg_mark_minor_E (t_dlcl **, t_dlcl **, t_ver_edge *, int, int *, int, int, int, int, int, int *, int *, int);
+/* aproto: endfile */
+/* aproto: file embed_graph/merge_bicomps.c */
+extern void embedg_VES_merge_simple_bicomps (t_ver_edge *, int, int, int, int, int);
+extern void embedg_VES_merge_pertinent_bicomps (t_ver_edge *, int, int, int, int, int);
+/* aproto: endfile */
+/* aproto: file embed_graph/merge_queue_misc.c */
+extern t_merge_queue embedg_merge_queue_new (int);
+extern void embedg_merge_queue_delete (t_merge_queue);
+extern boolean embedg_merge_queue_empty (t_merge_queue);
+extern void embedg_merge_queue_print (t_merge_queue);
+extern void embedg_merge_queue_append (t_merge_queue *, t_ver_edge *, int, int, int, int, int);
+extern void embedg_merge_queue_append_vertex (t_merge_queue *, t_ver_edge *, int, int, int);
+extern void embedg_merge_queue_append_virtual_vertex (t_merge_queue *, t_ver_edge *, int, int, int);
+extern void embedg_merge_queue_get (t_merge_queue *, int *, int *, int *, int *);
+extern void embedg_merge_queue_prune (t_merge_queue *, int *, int *, int *, int *);
+/* aproto: endfile */
+/* aproto: file embed_graph/obstruction.c */
+extern void embedg_obstruction (t_ver_sparse_rep *, t_adjl_sparse_rep *, t_dlcl **, t_dlcl **, t_ver_edge *, int, int *, int, int, t_ver_sparse_rep **, t_adjl_sparse_rep **, int *);
+extern minor embedg_mark_obstruction (t_dlcl **, t_dlcl **, t_ver_edge *, int, int *, int, int);
+/* aproto: endfile */
+/* aproto: file embed_graph/post_dfs_preproc.c */
+extern t_dlcl *sparseg_order_wrt_lowpoint (int, int *, int *, t_dlcl *);
+extern int *sparseg_find_least_ancestor (int, t_dlcl **);
+extern int *sparseg_find_dfs_parent (int, t_dlcl **);
+/* aproto: endfile */
+/* aproto: file embed_graph/proper_face_walk.c */
+extern boolean embedg_VES_get_succ_on_proper_face_with_avoidance (t_ver_edge *, int, int, int, int, boolean, int, int *, int *, int *);
+extern void embedg_VES_get_succ_on_proper_face (t_ver_edge *, int, int, int, int, int, int *, int *, int *);
+extern void embedg_VES_walk_proper_face (t_ver_edge *, int, int, int, boolean, int);
+/* aproto: endfile */
+/* aproto: file embed_graph/vertex_activity.c */
+extern boolean embedg_VES_is_ver_pertinent (t_ver_edge *, int, int, int);
+extern boolean embedg_VES_is_ver_ext_active (t_ver_edge *, int, int, int);
+extern boolean embedg_VES_is_ver_int_active (t_ver_edge *, int, int, int);
+extern boolean embedg_VES_is_ver_inactive (t_ver_edge *, int, int, int);
+/* aproto: endfile */
+/* aproto: file embed_graph/walkdown.c */
+extern t_merge_queue embedg_walkdown (t_ver_edge *, int, int *, int);
+/* aproto: endfile */
+/* aproto: file embed_graph/sparseg_dlcl_misc.c */
+extern void sparseg_dlcl_delete (t_dlcl **, int);
+extern void sparseg_dlcl_print (t_dlcl **, int);
+extern boolean sparseg_dlcl_is_adjacent (t_dlcl **, int, int, int, t_dlcl **);
+extern void sparseg_dlcl_append_to_neigh_list (t_dlcl **, int, int, int, int);
+extern void sparseg_dlcl_to_sparseg (t_dlcl **, int, int, t_ver_sparse_rep **, t_adjl_sparse_rep **);
+extern boolean sparseg_dlcl_sub (t_dlcl **, int, t_dlcl **, int);
+/* aproto: endfile */
+/* aproto: file embed_graph/walkup.c */
+extern void embedg_walkup (t_ver_edge *, int, int, t_dlcl *);
+/* aproto: endfile */
+/* aproto: file embed_graph/dfs_preprocessing.c */
+extern void sparseg_adjl_dfs_preprocessing (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int *, int **, int **, int **, t_dlcl ***, t_dlcl ***, int **, int **, t_dlcl ***);
+/* aproto: endfile */
+/* aproto: file embed_graph/planar_by_edge_addition.c */
+extern boolean sparseg_adjl_is_planar (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int *, t_dlcl ***, t_dlcl ***, t_dlcl ***, t_ver_edge **, int *, int *, int *);
+/* aproto: endfile */
+/* aproto: file embed_graph/recover.c */
+extern void embedg_recover_embedding (t_ver_sparse_rep *, t_adjl_sparse_rep *, t_ver_edge *, int, int, t_dlcl **, t_ver_sparse_rep **, t_embed_sparse_rep **);
+extern void embedg_recov_embed_walk_proper_face (int, int, t_adjl_sparse_rep *, t_embed_sparse_rep *, boolean, int);
+extern boolean embedg_check_recov_embedding (int, int, int, t_ver_sparse_rep *, t_adjl_sparse_rep *, t_embed_sparse_rep *);
+extern t_dlcl **embedg_recover_obstruction (t_ver_edge *, int, minor, int *);
+extern boolean embedg_check_recov_obs (t_dlcl **, int, minor);
+/* aproto: endfile */
+/* aproto: file embed_graph/planar_alg_init.c */
+extern t_ver_edge *embedg_planar_alg_init (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int *, int *, t_dlcl ***, t_dlcl ***, t_dlcl ***);
+/* aproto: endfile */
+/* aproto: file embed_graph/dlcl_misc.c */
+extern t_dlcl *embedg_dlcl_rec_new (int);
+extern void embedg_dlcl_rec_print (t_dlcl *);
+extern void embedg_dlcl_print (t_dlcl *);
+extern t_dlcl *embedg_dlcl_rec_append (t_dlcl *, t_dlcl *);
+extern t_dlcl *embedg_dlcl_rec_prepend (t_dlcl *, t_dlcl *);
+extern t_dlcl *embedg_dlcl_cat (t_dlcl *, t_dlcl *);
+extern t_dlcl *embedg_dlcl_find (t_dlcl *, int);
+extern t_dlcl *embedg_dlcl_find_with_NIL_twin_in_adjl (t_dlcl *, int);
+extern t_dlcl *embedg_dlcl_delete_first (t_dlcl *);
+extern t_dlcl *embedg_dlcl_delete_rec (t_dlcl *, t_dlcl *);
+extern boolean embedg_dlcl_is_empty (t_dlcl *);
+extern t_dlcl *embedg_dlcl_list_next (t_dlcl *);
+extern t_dlcl *embedg_dlcl_list_prev (t_dlcl *);
+extern t_dlcl *embedg_dlcl_list_last (t_dlcl *);
+extern void embedg_dlcl_delete (t_dlcl *);
+extern t_dlcl *embedg_dlcl_copy (t_dlcl *);
+extern int embedg_dlcl_length (t_dlcl *);
+/* aproto: endfile */
+/* aproto: file embed_graph/sparseg_adjl.c */
+extern boolean sparseg_adjl_plan_and_iso (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int, int *, t_ver_sparse_rep **, t_adjl_sparse_rep **, t_embed_sparse_rep **, int *);
+extern int *sparseg_adjl_footprint (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int);
+extern void sparseg_adjl_print (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, boolean);
+extern void sparseg_adjl_embed_print (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, t_embed_sparse_rep *, boolean);
+extern graph *sparseg_adjl_to_nauty_graph (t_ver_sparse_rep *, int, t_adjl_sparse_rep *);
+extern t_edge_sparse_rep *sparseg_adjl_edges (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int, boolean);
+/* aproto: endfile */
+/* aproto: file embed_graph/embedding.c */
+extern void embedg_embedding (t_ver_sparse_rep *, t_adjl_sparse_rep *, t_ver_edge *, int, int, int, int, t_dlcl **, t_ver_sparse_rep **, t_embed_sparse_rep **);
+extern void embedg_remove_SCE (t_ver_edge *, int, int);
+extern int *embedg_vertices_orientation (t_ver_edge *, int);
+extern int embedg_merge_remaining_virtual (t_ver_edge *, int);
+extern int embedg_nbr_faces (t_ver_edge *, int, int, int *, int *);
+extern boolean embedg_is_embed_valid (t_ver_edge *, int, int, int, int *, int *);
+/* aproto: endfile */
+/* aproto: file embed_graph/sparseg_adjl_modify.c */
+extern boolean sparseg_adjl_add_edge (t_ver_sparse_rep *, int, t_adjl_sparse_rep **, int *, int *, int, int, boolean);
+extern boolean sparseg_adjl_add_edge_no_extend (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int, int *, int, int, boolean);
+extern boolean sparseg_adjl_add_dir_edge (t_ver_sparse_rep *, int, t_adjl_sparse_rep **, int *, int *, int, int, boolean);
+extern boolean sparseg_adjl_add_dir_edge_no_extend (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int, int *, int, int, boolean);
+extern boolean sparseg_adjl_remove_edge_no_red (t_ver_sparse_rep *, t_adjl_sparse_rep *, int, int);
+extern boolean sparseg_adjl_remove_dir_edge_no_red (t_ver_sparse_rep *, t_adjl_sparse_rep *, int, int);
+extern int sparseg_adjl_remove_all_dir_edge_no_red (t_ver_sparse_rep *, t_adjl_sparse_rep *, int, int);
+extern void sparseg_adjl_add_vertices (t_ver_sparse_rep **, int, int);
+extern void sparseg_adjl_add_vertices_no_extend (t_ver_sparse_rep *, int, int);
+extern void sparseg_adjl_remove_vertex (t_ver_sparse_rep **, int, t_adjl_sparse_rep *, int, int, int *);
+extern void sparseg_adjl_remove_vertex_no_red (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int, int *);
+extern void sparseg_adjl_relabel_vertex (t_adjl_sparse_rep *, int, int);
+/* aproto: endfile */
+/* aproto: file embed_graph/sparseg_adjl_misc.c */
+extern void sparseg_adjl_assign_V (t_ver_sparse_rep *, t_ver_sparse_rep *, int);
+extern t_ver_sparse_rep *sparseg_adjl_dup_V (t_ver_sparse_rep *, int);
+extern void sparseg_adjl_assign_A (t_adjl_sparse_rep *, t_adjl_sparse_rep *, int);
+extern t_adjl_sparse_rep *sparseg_adjl_dup_A (t_adjl_sparse_rep *, int);
+extern void sparseg_embed_assign_E (t_embed_sparse_rep *, t_embed_sparse_rep *, int);
+extern t_embed_sparse_rep *sparseg_embed_dup_E (t_embed_sparse_rep *, int);
+extern void sparseg_adjl_underlying_undir (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int, t_ver_sparse_rep **, t_adjl_sparse_rep **, int *, int *);
+extern void sparseg_adjl_edge_union (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int, t_ver_sparse_rep *, t_adjl_sparse_rep *, boolean, t_ver_sparse_rep **, t_adjl_sparse_rep **, int *, int *);
+extern void sparseg_adjl_add_edges (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int, int *, t_ver_sparse_rep *, t_adjl_sparse_rep *, boolean, int *);
+/* aproto: endfile */
+/* aproto: file embed_graph/degree.c */
+extern int *sparseg_adjl_degree_seq (t_ver_sparse_rep *, int, t_adjl_sparse_rep *);
+/* aproto: endfile */
+/* aproto: file embed_graph/neighbours.c */
+extern void sparseg_adjl_vertex_out_neighbours (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int, int **, int *);
+extern void sparseg_adjl_vertex_in_neighbours (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int, int **, int *);
+/* aproto: endfile */
+/* aproto: file embed_graph/misc.c */
+extern void sparseg_comp_delete (t_comp_sparse_rep *, int);
+extern void sparseg_comp_print (t_comp_sparse_rep *, int);
+/* aproto: endfile */
+/* aproto: file embed_graph/dfs_things.c */
+extern void sparseg_adjl_dfs_things (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int, boolean, int *, t_ver_sparse_rep **, t_adjl_sparse_rep **, int *, int **, int **, int **, int **, int **, int *, int **, int *, t_comp_sparse_rep **);
+extern void sparseg_adjl_dfs_add_vertex_to_comp (t_comp_sparse_rep **, int *, int);
+extern void sparseg_adjl_dfs_create_new_comp (t_comp_sparse_rep **, int *);
+extern void sparseg_adjl_from_comps_to_sparseg_adjl (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, t_comp_sparse_rep *, int, t_graph_sparse_rep **);
+extern void sparseg_adjl_from_start_comp_to_sparseg_adjl (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int *, t_graph_sparse_rep **);
+/* aproto: endfile */
+/* aproto: file embed_graph/dfs_for_digraph.c */
+extern void sparseg_adjl_dfs_digraph (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, int, int, t_ver_sparse_rep **, t_adjl_sparse_rep **, int *, int **, int **, int **, int **, int **, int *, t_comp_sparse_rep **);
+/* aproto: endfile */
+/* aproto: file embed_graph/bfs.c */
+extern void sparseg_adjl_bfs (t_ver_sparse_rep *, int, t_adjl_sparse_rep *, boolean, int, t_ver_sparse_rep **, t_adjl_sparse_rep **, int *);
+/* aproto: endfile */
+/* aproto: file embed_graph/faces.c */
+extern void sparseg_adjl_walk_proper_face (int, t_adjl_sparse_rep *, t_embed_sparse_rep *, int, boolean, int, int *, t_edge_sparse_rep *);
+extern void sparseg_adjl_get_face_edges (int, t_adjl_sparse_rep *, int, t_embed_sparse_rep *, int, t_edge_sparse_rep **, int *, boolean, int);
+/* aproto: endfile */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* _PLANARITY_H_ */
diff --git a/lib/nauty/poptest.c b/lib/nauty/poptest.c
new file mode 100644
index 0000000..8862164
--- /dev/null
+++ b/lib/nauty/poptest.c
@@ -0,0 +1,264 @@
+/* Compare times for popcount instructions */
+/* Usage:  poptest K N
+   - measures the time for 1000*N popcount operations on words
+     with K one bits, comparing with the macro POPCOUNTMAC.
+     Compile with values for WORDSIZE and POPC with POPC values:
+     0 = loop, 1 = popcount, 2 = popcountl, 3 = popcountll,
+                    4 = _mm_popcnt_u32, 5 = _mm_popcnt_u32 */
+
+#define MAXN WORDSIZE
+
+#ifndef WORDSIZE 
+#define WORDSIZE 32
+#endif
+
+#ifndef POPC
+#error  Need a value for POPC
+#endif
+
+#include "gtools.h"
+#ifdef __INTEL_COMPILER
+#include <nmmintrin.h>
+#endif
+
+#ifndef POPCOUNTMAC
+#define POPCOUNTMAC POPCOUNT
+#endif
+
+#if POPC==0
+#define NEWPOPC(x,c) {c = 0; while(x){++c; x &= x-1;}}
+#endif
+#if POPC==1
+#define NEWPOPC(x,c) {c = __builtin_popcount(x);}
+#endif
+#if POPC==2
+#define NEWPOPC(x,c) {c = __builtin_popcountl(x);}
+#endif
+#if POPC==3
+#define NEWPOPC(x,c) {c = __builtin_popcountll(x);}
+#endif
+#if POPC==4
+#define NEWPOPC(x,c) {c = _mm_popcnt_u32(x);}
+#endif
+#if POPC==5
+#define NEWPOPC(x,c) {c = _mm_popcnt_u64(x);}
+#endif
+
+static setword
+ransetword(int k)     /* setword with k random bits */
+{
+	register setword w,rb;
+	register int j;
+
+	j = 0;
+	w = 0;
+	for (;;)
+	{
+	    if (j == k) return w;
+
+	    rb = bit[random() % WORDSIZE];
+	    if ((rb & w) == 0)
+	    {
+		w |= rb;
+		++j;
+	    }
+	}
+}
+
+static double
+timemac(setword *x, int n, int iters, int *sump)
+{
+	register int c,i,j,sum;
+	register setword w;
+	int it;
+	double t;
+
+	sum = 0;
+	for (i = 0; i < n; ++i)
+	{
+	    w = x[i];
+	    sum += POPCOUNTMAC(w);
+	}
+
+	t = CPUTIME;
+
+	for (it = 0; it < iters; ++it)
+	{
+	    for (i = 0; i < n; ++i)
+            {
+                w = x[i];
+                sum += POPCOUNTMAC(w);
+            }
+	    sum ^= it;
+	}	
+	    
+	t = CPUTIME - t;
+	*sump = sum;
+
+	return t;
+}
+
+static double
+timeold(setword *x, int n, int iters, int *sump)
+{
+	register int c,i,j,sum;
+	register setword w;
+	int it;
+	double t;
+
+	sum = 0;
+	for (i = 0; i < n; ++i)
+	{
+	    w = x[i];
+	    sum += POPCOUNT(w);
+	}
+
+	t = CPUTIME;
+
+	for (it = 0; it < iters; ++it)
+	{
+	    for (i = 0; i < n; ++i)
+            {
+                w = x[i];
+                sum += POPCOUNT(w);
+            }
+	    sum ^= it;
+	}	
+	    
+	t = CPUTIME - t;
+	*sump = sum;
+
+	return t;
+}
+
+static double
+timenew(setword *x, int n, int iters, int *sump)
+{
+	register int c,i,j,sum;
+	register setword w;
+	int it;
+	double t;
+
+	sum = 0;
+	for (i = 0; i < n; ++i)
+	{
+	    w = x[i];
+	    NEWPOPC(w,c);
+	    sum += c;
+	}
+
+	t = CPUTIME;
+
+	for (it = 0; it < iters; ++it)
+	{
+	    for (i = 0; i < n; ++i)
+            {
+                w = x[i];
+		NEWPOPC(w,c);
+                sum += c;
+            }
+	    sum ^= it;
+	}	
+	    
+	t = CPUTIME - t;
+	*sump = sum;
+
+	return t;
+}
+
+static double
+timenull(setword *x, int n, int iters, int *sump)
+{
+	register int c,i,j,sum;
+	register setword w;
+	int it;
+	double t;
+
+	sum = 0;
+	for (i = 0; i < n; ++i)
+	{
+	    w = x[i];
+	    NEWPOPC(w,c);
+	    sum += c;
+	}
+
+	t = CPUTIME;
+
+	for (it = 0; it < iters; ++it)
+	{
+	    for (i = 0; i < n; ++i)
+            {
+                w = x[i];
+		c = w;
+                sum += c;
+            }
+	    sum ^= it;
+	}	
+	    
+	t = CPUTIME - t;
+	*sump = sum;
+
+	return t;
+}
+
+int
+main(int argc, char *argv[])
+{
+	int i,k,iters;
+	setword x[1000];
+	double tnull,told,tnew,tmac;
+	int summac,sumold,sumnew,sumnull;
+
+	printf("WORDSIZE=%d POPC=%s  ",WORDSIZE,
+          POPC==0 ? "loop" :
+          POPC==1 ? "popcount" : 
+          POPC==2 ? "popcountl" : 
+          POPC==3 ? "popcountll" : 
+          POPC==4 ? "popcnt_u32" : 
+          POPC==5 ? "popcnt_u64" : "undefined");
+#ifdef SETWORD_INT
+        printf(" setword=unsigned int ");
+#endif
+#ifdef SETWORD_LONG
+        printf(" setword=unsigned long ");
+#endif
+#ifdef SETWORD_LONGLONG
+        printf(" setword=unsigned long long ");
+#endif
+#ifdef __SSE4_2__
+	printf("__SSE4_2__ ");
+#endif
+#ifdef __POPCNT__
+	printf("__POPCNT__ ");
+#endif
+#ifdef __INTEL_COMPILER
+	printf("__INTEL_COMPILER ");
+#endif
+printf("\n");
+
+	if (argc != 3)
+        {
+	    fprintf(stderr,"Usage: poptest num1bits numiters\n");
+	    exit(1);
+        }
+
+	k = atoi(argv[1]);
+	if (k > WORDSIZE) k = WORDSIZE;
+	iters = atoi(argv[2]);
+
+	for (i = 0; i < 1000; ++i)
+	    x[i] = ransetword(k);
+
+	tnull = timenull(x,1000,iters,&sumnull);
+	tmac = timemac(x,1000,iters,&summac);
+	told = timeold(x,1000,iters,&sumold);
+	tnew = timenew(x,1000,iters,&sumnew);
+
+	if (summac != sumold) printf("*** sum mismatch (mac/old)\n");
+	if (sumold != sumnew) printf("*** sum mismatch (old/new)\n");
+
+	printf("macro=%3.2f compiled=%3.2f new=%3.2f\n",
+		tmac-tnull,told-tnull,tnew-tnull);
+
+	return 0;
+}
diff --git a/lib/nauty/quarticirred28.h b/lib/nauty/quarticirred28.h
new file mode 100644
index 0000000..14ca82e
--- /dev/null
+++ b/lib/nauty/quarticirred28.h
@@ -0,0 +1,316 @@
+static char *irred[] = {
+"D~{\n",
+"I~{?GKF@w\n",
+"I^}A?KF@w\n",
+"G~`HW{\n",
+"N~{?GKF@w??@?B?B_@w\n",
+"N^{?GKF@{?G??B?B_@w\n",
+"L~?GW[N_A?cBCF\n",
+"M^{??KF@{?G@@B?b_\n",
+"N^}??KF@y??O?B?B_@w\n",
+"K~`GW[_CGD_N\n",
+"L~`HW[O?O@_F?N\n",
+"S~{?GKF@w??@?B?B_@w????C??W??w??{\n",
+"S^{?GKF@w??@?B?B_@{??O????W??w??{\n",
+"Q~?GW[N???_B?F?Fo?A?@G?KO?w\n",
+"R^{??KF@w??@?B?B_@{??O?CC?WC?w\n",
+"S^{??KF@{?G??B?B_@wG??_???W??w??{\n",
+"Q~??W[N_A?cBCFA??_??B??[?@w\n",
+"O~?GW]?OH@aFA?@?_OWAF\n",
+"Q~??W[N_A??B?F?Fc??_@A?KC?w\n",
+"S^{?GKF@{????B?B_@y???@???W??w??{\n",
+"P~?GW[N_A?_B?FG?A?G?J??{\n",
+"Q~?GW[N_A?cB?FC???O?B??[?@w\n",
+"R^{??KF@{????B?B_@y??@?CA?W?Gw\n",
+"P~??W[N_A?cB?FC?@?GGB??{\n",
+"S^{??KF@{??_?B?B_@y???_???W??w??{\n",
+"O~?GW]?OGP_fG?C?_OWAF\n",
+"Q~??W[N_A?cBAFC??_??B??[?@w\n",
+"O~?GW]?OH@`FC?@?_OWAF\n",
+"Q^{??KF@{??`?B?Bg??C@??k?@w\n",
+"P~??W[N_A?`B?FG?A?GGB??{\n",
+"O~`GW[_?g@_FC??O_@W?N\n",
+"X~{?GKF@w??@?B?B_@w????C??W??w??{??????G??@_??F???N\n",
+"X^{?GKF@w??@?B?B_@w????C??W??w??}???O?????@_??F???N\n",
+"V~?GW[N???_B?F?F_???@??K??w?@{??@??@G??W_?B_\n",
+"W^{??KF@w??@?B?B_@w????C??W??w??}???O??GG?@_O?F\n",
+"X^{??KF@w??@?B?B_@{??O????W??w??{C???_????@_??F???N\n",
+"V~??W[N???_B?F?Fo?A?@G?KO?wO??G????B???w??F_\n",
+"T~?GW[??G@_F?N_?G?H?BC?[G??G?GC?K@?F\n",
+"V~??W[N???_B?F?Fo?A????K??w?@x???O?@A??WG?B_\n",
+"W^{??KF@w????B?B_@{??O????W??w??{C???_?G?O@_?_F\n",
+"U~??W[N????B?F?Fo?A?@G?KO?wO??G?C?OB?A?w\n",
+"X^{?GKF@w??@?B?B_@{???????W??w??|?????A???@_??F???N\n",
+"U~?GW[N???_B?F?Fo?A?@??K??x???_?C??J??@w\n",
+"V~?GW[N???_B?F?Fo?A?@G?K??w_????G??B???w??F_\n",
+"W^{??KF@w??@?B?B_@{???????W??w??|???@??GC?@_?@F\n",
+"U~??W[N???_B?F?Fo?A?@G?K??w_??O?CC?B??@w\n",
+"X^{??KF@w??@?B?B_@{??@????W??w??|????_????@_??F???N\n",
+"T~?GW[??G@_F?N_?G?GOB@?[_??_?GC?K@?F\n",
+"V~??W[N???_B?F?Fo?A?@G?KG?w_??G????B???w??F_\n",
+"T~?GW[??G@_F?N_?G?H?BA?[O??G?GC?K@?F\n",
+"W^{??KF@w????B?B_@{??@????W??w??|????_?G?O@_?_F\n",
+"U~??W[N????B?F?Fo?A?@G?KG?w_??G?C?OB?A?w\n",
+"V^{??KF@w??@?B?B_@{??@?C??W??y???A?@??@W??F_\n",
+"U~??W[N???_B?F?Fo?A?@A?K??x???_?CC?B??@w\n",
+"V^{??KF@w????B?B_@{??@?CA?W??y????G@?@?W??F_\n",
+"U~??W[N????B?F?Fo?A?@A?K?Ox???_?CC?B?A?w\n",
+"V^{??KF@w????B?B_@{??@?C?GW??y???A?@?@?W??F_\n",
+"U~?GW]?O?@_F?NA??_??B??[?@x???_?CA?B?O?w\n",
+"X^{??KF@{????B?B_@wG??_???W??w??|????@????@_??F???N\n",
+"V^{?GKF_???B?F?F__?C@?OK?_y????O???B???w??F_\n",
+"U~??W[N_A?_B?FA??_??B??[?@x???_?C?CB??_w\n",
+"S~?GW]?OG@_FA?@?_OWAFG??O?G?OW?G[\n",
+"V~??W[N_A?cB?FA??_??B??[?@w_???C???B???w??F_\n",
+"T~?GW]?OH@_FA?@?_OWAFC???C???W??[??N\n",
+"V^{?GKF_???B?F?F__?C???K??w?@y???@?@?G?W?OB_\n",
+"T~?GW]?OH@_FA?@???W?F??{O??C?GA?K?CF\n",
+"W^{??KF@{????B?B_@wG??????W??w??|????_?G?G@_?@F\n",
+"U~??W[N_A?cB?FA?????B??[?@w_??G?C?AB??Gw\n",
+"S~?GW]?OH@_FA?@?_OW?FC??@?G?GW??{\n",
+"X^{??KF@{????B?B_@y??@????W??w??{A???@????@_??F???N\n",
+"S~?GW]?OG@_FG?C?`?WGF?_?@?G?OW?G[\n",
+"V~??W[N_A?cB?FC?@???B??[?@wG???C???B???w??F_\n",
+"T~?GW]?OH@_FC?A?__WCF?O??C???W??[??N\n",
+"V~??W[N_???B?F?Fg??O???K??w?@x???O?@@??W?OB_\n",
+"T~?GW]???@_F?NO?@?GGB?_[_??_?GA?K?OF\n",
+"T~?GW]???@_F?NO?C?GOB@?[O??C?GA?K?OF\n",
+"U~??W[N_A?_B?FG?@???B??[?@w_??G?C?CB??_w\n",
+"S~?GW]?OG@_FG?A?__WCFC??@?G?OW?G[\n",
+"U~??W[N_???B?F?Fg?@?@A?K??w_??G?C?GB??@w\n",
+"T~??W[N_??_B?FO?C?G?R?@[O??O?GG?K?AF\n",
+"U~??W[N_A?_B?FG???_?B??[?@w_??O?CC?B??_w\n",
+"T~?GW[N_A?_B?FG???g?B??[O???CG??k??N\n",
+"T~??W[N_A?_B?FG?@?G?J??[O??G?G?CK??N\n",
+"S~?GW]?AG@_FO?G?__WCFC??@?G?OW?G[\n",
+"T~?GW]?OGP_FG?@???W?F??{O??C?GA?K?CF\n",
+"S~?GW]?OGP_FG?@?_OW?FC??@?G?GW??{\n",
+"S~_GW\\?@G@_FG??__@W?FC??@?G?GW??{\n",
+"[~?GW[N???_B?F?F_???@??K??w?@w?????@???W??B_??N_???O???c???W_??F\n",
+"[~??W[N???_B?F?F_???@??K??w?@{??@??@G??W_?B`???@??????@_???w???N\n",
+"Y~?GW[??G@_F?N????G?B??[?@{??A??C_?BC??wO???_?@?_?B?O?B_\n",
+"[~??W[N???_B?F?F_???@??K??w?@{??@??????W??B_??NG???C???`???WG??F\n",
+"Z~??W[N????B?F?F_???@??K??w?@{??@??@G??W_?B`???@??@?C?@_@??w\n",
+"Z~?GW[N???_B?F?F_???@??K??w?@{??@??@???W??Bc???C??@???D_??@w\n",
+"[~?GW[N???_B?F?F_???@??K??w?@{??@??@G??W??Ba??????A???@_???w???N\n",
+"Z~??W[N???_B?F?F_???@??K??w?@{??@??@G??W??Ba???A??@@??@_??@w\n",
+"Y~?GW[??G@_F?N????G?B??[?@{??A??CG?B@??x???A??@?_?B?O?B_\n",
+"[~??W[N???_B?F?F_???@??K??w?@{??@??@G??WO?Ba???@??????@_???w???N\n",
+"Y~?GW[??G@_F?N????G?B??[?@{??A??C_?BA??w_???_?@?_?B?O?B_\n",
+"[^{??KF@w????B?B_@w???????W??w??}???O??GG?@_O?F?A???@??_?A?W??OF\n",
+"Z~??W[N????B?F?F_???@??K??w?@{??@??@G??WO?Ba???@??@?C?@_@??w\n",
+"[^{??KF@w??@?B?B_@w????C??W??w??}???@??G??@_??FO????_??_??@W???N\n",
+"Z~??W[N???_B?F?F_???@??K??w?@{??@??@A??W??Bc???C??@@??@_??@w\n",
+"[^{??KF@w????B?B_@w????C??W??w??}???@??GC?@_??FO????A??_?_?W???N\n",
+"Z~??W[N????B?F?F_???@??K??w?@{??@??@A??W?_Bc???C??@@??@_@??w\n",
+"[^{??KF@w????B?B_@w???????W??w??}???@??G?O@_?_FO????_??_?A?W??OF\n",
+"[^{??KF@w????B?B_@w????C??W??w??}???@??G?O@_??FO????_??_?_?W???N\n",
+"[^{??KF@w????B?B_@w???????W??w??}???@??G?O@_?AFO????_??_?_?W??OF\n",
+"[~??W[N????B?F?Fo?A?@G?KO?wO??G????B???w??F_A???A?????@_???w???N\n",
+"Y~?GW[???@_F?N_?G?H?BC?[G??G?GC?K@?F?G???_????B???F???F_\n",
+"W~?GW[??G@_F_?O?c?W_FA??C?GC?WA?[?_??C?G?O@_?_F\n",
+"Z~?GW[??G@_F?N_?G???B??[?@wO??G????B???w??Fc???C??@?_?@_G??w\n",
+"[~??W[N????B?F?Fo?A????K??w?@wO??C?????W??B_??NG???C???_A??W?O?F\n",
+"Y~?GW[???@_F?N_?G???B??[?@wO??G?CA?B?O?x???A??@?G?B?C?B_\n",
+"[^{?GKF???_B?F?Fo??????K??w?@wG??A?@?O?W@?Bg?????C????@_???w???N\n",
+"Z~??W[N???_B?F?Fo?A?@??K??wO??G????B???w??Fc???C??@??A@_??_w\n",
+"X~?GW[??G@_F?N_?G?G?B??[G??G?GC?K@?FG???_??_?AB??AF\n",
+"[~??W[N???_B?F?Fo?A?@G?K??wO??G????B???w??Fa?????@????@_???w???N\n",
+"Y~?GW[??G@_F?N_?G?H?B??[G??G?GC?K@?FC?????O???B???F???F_\n",
+"[^{?GKF???_B?F?Fo??????K??w?@wG??A?????W??B_??NO????O??_C??W??_F\n",
+"Y~?GW[??G@_F?N_?G?H?B??[G??G????K??F??@w_???O?@?O?B??AB_\n",
+"Z^{?GKF????B?F?Fo??????K??w?@wG??A?@?O?W@?Bg????C?@?A?@_?A?w\n",
+"Z~??W[N????B?F?Fo?A?@G?K??wO??G????B???w??Fa????C?@?A?@_??_w\n",
+"X~?GW[???@_F?N_?G?H?B??[G??G?GC?K@?FC???@??_A?B??AF\n",
+"Z~??W[N???_B?F?Fo?A?@G?K??wO???????B???w??Fa???@??@??@@_??Gw\n",
+"X~?GW[??G@_F?N_?G?H?B??[G??G?GC?K??FC???A??_?@B???N\n",
+"X~?GW[??G@_F?N_?G?G?B??[_??_?GO?KC?F?_??A??_?AB??AF\n",
+"[~??W[N???_B?F?Fo?A?@G?K??w_??O????B???w??F__????@????@_???w???N\n",
+"Y~?GW[??G@_F?N_?G?H?B??[O??O?GG?KA?F?O????O???B???F???F_\n",
+"[~??W[N????B?F?Fo?A????K??w?@x???G?????W??B_??NC???@???_A??W?O?F\n",
+"Y~?GW[???@_F?N_?G???B??[?@x???O?CC?B?_?w_???G?@?G?B?C?B_\n",
+"[~??W[N???_B?F?Fo??????K??w?@y???G?????W??B_??NG???C???__??W??_F\n",
+"Y~?GW[??G@_F?N_?????B??[?@y???O?CC?B?_?x???A??@?O?B??GB_\n",
+"Y~?GW[??G@_F?N_?????B??[?@y??@??CG?B@??w_???O?@?O?B??GB_\n",
+"Z~??W[N???_B?F?Fo?A?@??K??x???O????B???w??Fa???@??@??A@_??_w\n",
+"X~?GW[??G@_F?N_?G?G?B??[_??O?GG?KA?FC???A??_?AB??AF\n",
+"Z~??W[N????B?F?Fo??????K??w?@y???_?@C??WO?B__???C?@?A?@_?A?w\n",
+"Z~??W[N????B?F?Fo?A?@G?K??w_??O????B???w??F__???C?@?A?@_??_w\n",
+"X~?GW[???@_F?N_?G?H?B??[O??O?GG?KA?F?O??@??_A?B??AF\n",
+"Z~??W[N???_B?F?Fo?A????K??w?@x???G?@???W??Ba???@??@???D_??@w\n",
+"Y~?GW[??G@_F?N_?G???B??[?@x???O?CC?B???w_???O?@?O?B???F_\n",
+"Z~??W[N????B?F?Fo?A????K??w?@x???G?@@??W??Ba????C?@?A?@_??@w\n",
+"Z~??W[N???_B?F?Fo??????K??w?@y???_?@A??W??Ba???@??@??C@_??@w\n",
+"Y~?GW[???@_F?N_?G???B??[?@wO??G?C?_B?C?x???A??@?_?B?O?B_\n",
+"Y^{?GKF???_B?F_?G???B??[?@wG??C?C?OB?A?wA???C?@?@?B??_B_\n",
+"[^{?GKF????B?F?Fo?A????K??w?@wG??A?@?O?W?_B_C???A?????@_???w???N\n",
+"Y^{?GKF???_B?F_?G???B??[?@wG??C?C@?B?C?w@???@?@?@?B??_B_\n",
+"[~??W[N????B?F?Fo?A?@G?KO?wO???_???B???w??F__???A?????@_???w???N\n",
+"W~?GW[??G@_F_?O?c?W_FA??C?G@?W?_[A???O?G?O@_?_F\n",
+"Y~?GW[???@_F?N_?G?H?BC?[G??G?GC?K?_F?O???_????B???F???F_\n",
+"W~?GW[??G@_F_?O?c?W_FA??C?GC?W@?[@???C?G?O@_?_F\n",
+"Y~??W[N????B?F?Fo?A?@??K??wO??G?C?OB?A?x???A??@??AB??@B_\n",
+"Z~??W[N????B?F?Fo?A?@G?K??wO??G?C?OB?A?w_?????_???B???B_??@w\n",
+"[~??W[N????B?F?Fo?A????K??w?@wO???O????W??B_??NG???C???__??W?O?F\n",
+"Y~?GW[???@_F?N_?G???B??[?@wO??G?CA?B?G?x???A??@?O?B?C?B_\n",
+"Z^{?GKF????B?F?Fo??????K??w?@wG??A?@?C?W?OBg????O?@?G?@_?A?w\n",
+"X~?GW[???@_F?N_?G?H?B??[G??G?G@?K?OFC???C??_G?B??AF\n",
+"Z~??W[N????B?F?Fo?A????K??w?@wO???O@?A?W??Bc???C??@@??@_??@w\n",
+"[^{??KF@w????B?B_@{??O????W??w??{C???A?G??@_??F?_???@??_??@W???N\n",
+"Z^{?GKF????B?F?Fo?A????K??w?@wG??A?@?C?W??B_G???G?@?A?@_??@w\n",
+"Y~??W[N????B?F?Fo?A?@G?KO?wO???_C??B???wG???@?@???J???F_\n",
+"X~?GW[???@_F?N_?G?H?BC?[G??G?G@?K??F?_??A??_A?B???N\n",
+"Z^{?GKF????B?F?Fo??????K??w?@wG??A?@?O?W?_Bg????G?@?A?@_?A?w\n",
+"Z~??W[N????B?F?Fo?A?@G?K??wO???_???B???w??Fa???@??@?A?@_??_w\n",
+"X~?GW[???@_F?N_?G?H?B??[G??G?GC?K?_FC???A??_A?B??AF\n",
+"[^{??KF@w????B?B_@{???????W??w??{C???A?G?G@_??FO????_??_?@?W???N\n",
+"Y~??W[N????B?F?Fo?A?@G?K??wO???_C?GB???w_???_?@??@B???F_\n",
+"Y~?GW[N???_B?F?Fo?A?@??K??x?????S??B???w_?????`???J???F_\n",
+"Z^{?GKF????B?F?Fo??????K??w?@y???C?@?_?W?_B_G???G?@?A?@_?A?w\n",
+"Y~??W[N????B?F?Fo?A?@??K??x???_?CG?B?C?wG???@?@??AB??@B_\n",
+"X~?GW[???@_F?N_?G?H?B??[O??O?GG?K?_F?_??A??_A?B??AF\n",
+"Z~??W[N????B?F?Fo??????K??w?@y???_?@A??W?_Ba???@??@?A?@_?A?w\n",
+"Z~??W[N????B?F?Fo?A????K??w?@x???G?@?C?W??Ba???@??@?A?@_??@w\n",
+"[^{??KF@w????B?B_@{???????W??w??|???@??G?O@_??F?_???@??_?@?W???N\n",
+"Y~??W[N????B?F?Fo?A?@G?K??w_??O?C?OB???wG???@?@??@B???F_\n",
+"Y~??W[N???_B?F?Fo?A?@??K??x???O?C??J???w_???_?@??@B???F_\n",
+"Y~??W[N????B?F?Fo?A?@??K??x???O?C?OB??Aw_???_?@?A?B??@B_\n",
+"Y~?GW[???@_F?N_?G?GOB@?[_??C????K??F??@w_???G?@?G?B?C?B_\n",
+"X~?GW[??G@_F?N_?@?G?B??\\??@??GG?KA?FC???A??_?AB??AF\n",
+"Y~?GW[??G@_F?N_?G?GOB??[_??G????K??F??@w_???O?@?O?B??AB_\n",
+"X~?GW[??G@_F?N_?G?GOB??[_??G?GC?K??FC???A??_?@B???N\n",
+"W~?GW[??G@_F_?O?`?WGFG??O?G@?W?_[A???O?G?O@_?_F\n",
+"[~??W[N????B?F?Fo?A?@G?KG?w_???_???B???w??F__???A?????@_???w???N\n",
+"Y~??W[N???_B?F_?G?H?BA?[O???_???K??F??@wG???@?@?@?B??_B_\n",
+"Y~?GW[???@_F?N_?G?H?BA?[O??@????K??F??@wG???O?@?O?B?C?B_\n",
+"W~?GW[??G@_F_?O?c?WOFC???_G?_W?O[C???_?GA?@_?_F\n",
+"[~??W[N????B?F?Fo??O???K??w?@y????O????W??B_??NG???C???__??W?O?F\n",
+"Y~?GW[???@_F?N_?@?GGB?_\\???@????K??F??@x???A??@?O?B?C?B_\n",
+"W~?GW[??G@_F_?A?__WCFO???_G?_W?O[_??C??GA?@_?_F\n",
+"Y~?GW[???@_F?N_?G?GOB@?[_??@????K??F??@w_???O?@?O?B?C?B_\n",
+"W~?GW[??G@_F_?O?`?WGFG???_G?_W?O[O???_?GA?@_?_F\n",
+"Z~??W[N????B?F?Fo??O@@?K??y????_???B???w??Fc???C??@?A?@_??_w\n",
+"X~??W[N???_B?F_?@?GGB??\\????_G?OK?CFG???_??_?OB??AF\n",
+"X~??W[N???_B?F_?@?GGB??\\??@??G?_K?GFC????G?_?OB??AF\n",
+"[^{??KF@w????B?B_@{??@?C??W??y????G????W??B_??N?_???@??_??_W??CF\n",
+"Z^{?GKF????B?F?Fo??G@?_K??y????_???B???w??F_G???G?@?A?@_??_w\n",
+"Y~??W[N????B?F?Fo??O@??K??y??@??CO?B?C?wG???@?@??AB??@B_\n",
+"X~?GW[???@_F?N_?@?GGB??\\??@??G_?K?_F?_??A??_A?B??AF\n",
+"X~??W[N???_B?F_?G?GOB??[_??_?G?_K?GF@????G?_?OB??AF\n",
+"Y~??W[N????B?F?Fo??O@@?K??y????_C?GB???x???A??@??@B???F_\n",
+"Z^{??KF@w????B?B_@{??@?C??W??y????G@?@?W??B_O????@@???`_??@w\n",
+"Y^{?GKF????B?F?Fo??G@?_K??y????_C?GB???wA???C?@??@B???F_\n",
+"Z~??W[N????B?F?Fo?A?@A?K??x????_???B???w??Fa???@??@?A?@_??_w\n",
+"X~??W[N???_B?F_?G?GOB??[_???_G?OK?CFC???G??_?OB??AF\n",
+"Y~??W[N????B?F?Fo?A?@A?K??x????_C?GB???w_???_?@??@B???F_\n",
+"Y~??W[N????B?F?Fo?A?@A?K??x???_?C?OB???wG???@?@??@B???F_\n",
+"Y~?GW[???@_F?N_?@???B??[?@y??@??CC?B?G?w_???O?@?O?B?C?B_\n",
+"W~?GW[??G@_F_?O?`?WGFG??A?G@?W?_[O???O?G?O@_?_F\n",
+"X~?GW[???@_F?N_?G?GOB??[_??G?G@?K?OFC???C??_G?B??AF\n",
+"X~?GW[???@_F?N_?G?GOB??[_??G?GC?K?_FC???A??_A?B??AF\n",
+"X~?GW[???@_F?N_?G?GOB@?[_??C?G@?K??FC???A??_A?B???N\n",
+"Y~??W[N????B?F?Fo??O@??K??y??@??C?OB??Aw_???_?@?A?B??@B_\n",
+"Z^{??KF@w????B?B_@{??@?C??W??y????G@??@W??B_O???@?@???`_??@w\n",
+"W~?GW[??G@_F_?O?`?W@FG??C?GC?W?_[O???O?G?O@_?_F\n",
+"Z~??W[N_A?_B?FA?????B??[?@x???_?C?CB??_wG????C????B???B_??@w\n",
+"W~?GW]?OG@_FA?@?_?W?FG??O?G?OW?G[A???O?G?@@_?AF\n",
+"[~??W[N_A?cB?FA?????B??[?@w_???C???B???w??F__????G????@_???w???N\n",
+"X~?GW]?OH@_FA?@?_?W?FC???C???W??[??N?_??A??_?CB??CF\n",
+"Y~?GW]?OH@_FA?@?_OW?FC???C???W??[??N?O????_???B???F???F_\n",
+"X~?GW]??G@_FA?@???W?F??|??@??G?_K?GFC???C??_G?B?@?F\n",
+"Y~?GW]?OG@_FA?@???W?F??{_???O???K??F??@w_???O?@?O?B?@?B_\n",
+"[~??W[N_???B?F?F`??????K??w?@y????G????W??B_??NG???C???__??W??_F\n",
+"Y~?GW]???@_F?NA??_GCB??\\????_???K??F??@x???A??@?O?B??AB_\n",
+"W~?GW]??G@_FA?@?_OW?FO???OG?OW?G[_??C??GA?@_?AF\n",
+"Y~??W[N_A?_B?FA??_??B??[?@x????GC??B???w_????O@???J???F_\n",
+"W~?GW]?OG@_FA?@?_OWAFG???GG??W??[O???@?G??D_??N\n",
+"Y~??W[N_??_B?FA?????B??[?@y??@??C?GB?@?w_???_?@??_B??GB_\n",
+"W~?GW]??G@_FA?@?_OW?FO??_?G?_W?O[O???O?G?G@_?AF\n",
+"Z~??W[N_A?_B?FA?????B??[?@x????G???B???w??Fa???@??@??_@_?C?w\n",
+"X~?GW]?OG@_FA?@?_OW?FG???G???W??[??NC???A??_?_B??CF\n",
+"Y~?GW]???@_F?NA?????B??[?@y???G?CA?B?C?x???A??@?O?B??GB_\n",
+"Y~?GW]???@_F?NA?????B??[?@y??@??CC?B?C?w_???O?@?O?B??GB_\n",
+"X~?GW]?OG@_FA?????W?F??{_??G?G?OK?CFC???C??_G?B??OF\n",
+"W~?GW]?OG@_FA?@?_?W?FG??A?G?OW?G[O???O?G?@@_?AF\n",
+"X~?GW]?OG@_FA?????W?F??{_??G?GC?K?GFC???A??_?_B??OF\n",
+"X~?GW]?OG@_FA?@???W?F??{_??C?G?OK??FC???A??_?_B???N\n",
+"Y~??W[N_A?_B?FA?????B??[?@x???G?C?CB???w_????O@??GB???F_\n",
+"W~?GW]?OG@_FA?@?_OW?FG??@?G?OW??[O???@?G??`_??N\n",
+"W~?GW]?OG@_FA?@?_?W?FG??A?G?OW?@[O???O?G?G@_?AF\n",
+"X~?GW]??G@_FO?G?`?WGF?_??O???W??[??NC???A??_@?B?@?F\n",
+"Y~?GW]?OG@_FG?A???W?F??{C???O???K??F??@w_???O?@?O?B?@?B_\n",
+"Y~?GW]???@_F?NO?C?GOB??[C???_???K??F??@w_???O?@?O?B??AB_\n",
+"W~?GW]??G@_FO?G?`?W?F@???OG?OW?G[O???_?GA?@_?AF\n",
+"W~?GW]?OG@_FG?A?_?W?F@??A?G?OW?G[O???O?G?@@_?AF\n",
+"W~?GW]??G@_FO?G?`?W?F@??A?G?_W?O[O???O?G?G@_?AF\n",
+"X~?GW]?OG@_FG?A?__W?F?_??G???W??[??NC???A??_?_B??CF\n",
+"W~?GW]??G@_FO?G?`?W?FC??C?GC?W?_[@???A?G?G@_?AF\n",
+"W~?GW]?OG@_FG?A?_?W?FC??C?GC?W?O[@???@?G?@@_?AF\n",
+"W~?GW]??G@_FO?A?__W?FG??A?G?_W?O[O???O?G?G@_?AF\n",
+"X~?GW]???@_F?NO?@?GGB??[_??C?G?_K??FC???A??_?@B???N\n",
+"Y~??W[N_??_B?FO??@??B??[?@x???O?C?CB???w_???_?@??_B???F_\n",
+"X~?GW[N_??_B?FO??@G?B??[_???GG??k??FC????C?_?@B???N\n",
+"X~?GW]?AG@_FO?@???W?F??{_??C?G?OK??FC???A??_?_B???N\n",
+"W~?GW]?AG@_FO?@?_OW?FG??@?G?OW??[O???@?G??`_??N\n",
+"W~?GW]?AG@_FO?@?_?W?FG??A?G?OW?@[O???O?G?G@_?AF\n",
+"[~?GW[??G@_F_?O?_?W?FA??C?GC?WA?[?_??C?G?O@_?_FG???C???_?C?W??_F\n",
+"[~?GW[??G@_F_?O?c?W?FA??C?GC?W??[?_??C?G?O@_?_FC????O??_?A?W??AF\n",
+"[~?GW[??G@_F_?O?_?W?FA??C?GC?WA?[_??C??G@?@_A?F?A???@??_?C?W??_F\n",
+"[~?GW[??G@_F_?O?_?W?FA??C?GC?WA?[_???G?G?_@_@?FC????@??_?C?W??_F\n",
+"[~?GW[??G@_F_?O?c?W?FA??C?GC?W??[O???G?G?_@_@?F?O???@??_?A?W??AF\n",
+"[~?GW[??G@_F_?O?c?W?FA??C?GC?W??[O???O?G@?@_A?F?A???@??_?A?W??AF\n",
+"[~?GW[??G@_F_?O?c?W?FA??C?GC?W??[O???G?G?_@_?AF?O???A??_?_?W??AF\n",
+"[~?GW[??G@_F_?O?_?W?FG??O?GO?WG?[A???O?G@?@_A?F?A???@??_?C?W??_F\n",
+"[~?GW[??G@_F_?O?_?W?FG??G?GG?WC?[@???G?G?_@_@?FC????@??_?C?W??_F\n",
+"[~?GW[??G@_F_?O?_?W?FG??O?GO?WG?[A???G?G?_@_@?F?O???@??_?C?W??_F\n",
+"[~?GW[??G@_F_?O?c?W?FC??G?GG?W??[A???G?G?_@_@?F?O???@??_?A?W??AF\n",
+"[~?GW[??G@_F_?O?c?W_FA???_G??W??[C???_?G?_@_@?F?O???@??_??OW??AF\n",
+"[~?GW[??G@_F_?O?c?W?FA???_G?_W??[C???_?G?O@_?_FC????O??_?A?W??AF\n",
+"[~?GW[??G@_F_?O?c?W?FA??C?G@?W??[A???C?G?O@_?_FC????O??_?A?W??AF\n",
+"[~?GW[??G@_F_?O?c?W_FA??C?G@?W??[A???C?G?O@_??F?O???@??_??GW???N\n",
+"[~?GW[??G@_F_?O?_?W?FA??C?G@?W?_[_??C??GC?@_@?F?O???@??_?C?W??_F\n",
+"[~?GW[??G@_F_?O?c?W?FA??C?G@?W??[O???_?G?_@_@?F?O???@??_?A?W??AF\n",
+"[~?GW[??G@_F_?O?c?W?FA??C?G@?W?_[O???_?G?O@_??F?O???@??_?A?W???N\n",
+"[~?GW[??G@_F_?O?_?W?FA???_G?_W?O[_??@??G?@@_?AFC????_??_G??W?G?F\n",
+"[~?GW[??G@_F_?O?_?W?FA??C?G@?W?_[_???_?G?@@_?AFC????O??_@??W?G?F\n",
+"[~?GW[??G@_F_?O?_?W?FA???_G?_W?O[_??@??GC?@_?CFC????O??_?_?W??_F\n",
+"[~?GW[??G@_F_?O?c?W?FA??C?G@?W??[A???C?G?O@_??NC????O??_?_?W??_F\n",
+"[~?GW[??G@_F_?O?_?W?FA??C?G@?W?_[_???_?G?O@_?CFC????O??_?_?W??_F\n",
+"[~?GW[??G@_F_?O?_?W?FG??O?G?@W??{G??@??G@?@_A?F?_???O??_@??W?G?F\n",
+"[~?GW[??G@_F_?O?_?W?FG??O?G?@W??{G??@??GC?@_C?F?O???C??_@??W?G?F\n",
+"[~?GW[??G@_F_?O?_?W?FG??G?GG?W@?[A???C?G?@@_?AFC????O??_@??W?G?F\n",
+"[~?GW[??G@_F_?O?_?W?FG??G?GG?W@?[A???C?G?O@_?CFC????O??_?_?W??_F\n",
+"[~?GW[??G@_F_?A?_?W?FO??_?G@?W?_[C???_?G?O@_?_FC????O??_?C?W??_F\n",
+"[~?GW[??G@_F_?A?_?W?FO??_?G@?W?_[C???_?GA?@_@?FC????@??_?C?W??_F\n",
+"[~?GW[??G@_F_?A?__W?FO??_?G@?W??[A???C?G?O@_?_FC????O??_?A?W??AF\n",
+"[~?GW[??G@_F_?O?`?W?FG???_G?_W??[C???_?G?O@_?_FC????O??_?A?W??AF\n",
+"[~?GW[??G@_F_?O?`?W?FG??O?G@?W??[C???_?G?_@_@?F?O???@??_?A?W??AF\n",
+"[~?GW[??G@_F_?A?__W?FO???_G?_W??[_???_?G?O@_?_FC????O??_?A?W??AF\n",
+"[~?GW[??G@_F_?A?__W?FO???_G?_W??[_??C??GC?@_@?F?O???@??_?A?W??AF\n",
+"[~?GW[??G@_F_?O?`?W?FG???_G?_W??[O??@??GC?@_@?F?O???@??_?A?W??AF\n",
+"[~?GW[??G@_F_?A?__W?FO???_G?_W?O[_???_?G?G@_??FC????O??_?A?W???N\n",
+"[~?GW[??G@_F_?A?_?W?FO??_?G@?W?_[C???A?G?@@_?AFC????_??_G??W?G?F\n",
+"[~?GW[??G@_F_?A?__W?FO???_G?_W??[A???A?G?G@_?AFG???C???_G??W??AF\n",
+"[~?GW[??G@_F_?O?`?W?FG???_G?_W??[C???A?G?G@_?AFC????_??_G??W??AF\n",
+"[~?GW[??G@_F_?O?`?W?FG???_G?_W??[C???_?G?O@_?AFC????O??_?_?W??AF\n",
+"[~?GW[??G@_F_?A?_?W?FO???_G?_W?@[_??@??GC?@_@?FC????O??_?_?W??_F\n",
+"[~?GW[??G@_F_?A?_CW?FO??C?G?_W??[_???_?G?O@_?_FC????O??_?A?W??AF\n",
+"[~?GW[??G@_F_?A?_CW?FO??C?G?_W??[_???_?G?O@_?AFC????O??_?_?W??AF\n",
+"[~?GW]??G@_FA???_?W?FO??_?G?_W?O[C????OG?@@_?AFC????_??_G??W?G?F\n",
+"[~?GW]?OG@_FA?@?_?W?FG???GG??W??[A???O?G?@@_?AFC????@??_??OW??AF\n",
+"[~?GW]??G@_FA???_?W?FO??_?G?_W?O[C???_?G?A@_?CFC????O??_?_?W??_F\n",
+"[~?GW]??G@_FA???_?W?FO??_?G?_W?O[O??@??GC?@_?GF?O???@??_?C?W??_F\n",
+"[~?GW]??G@_FA?@?_?W?FO???OG?OW??[_???_?G?@@_?AFC????O??_?_?W??AF\n",
+"[~?GW]??G@_FA?@?_?W?FO???OG?OW??[_??C??GC?@_?CF?O???@??_?A?W??AF\n",
+"[~?GW]??G@_FA?@?_?W?FO???OG?OW?G[_???_?G?@@_??FC????O??_?A?W???N\n",
+"[~?GW]??G@_FA?@?_OWAFO???OG??W??[_???A?G??D_??FC????@??_??GW???N\n",
+"[~?GW]??G@_FA???_?W?FO??C?G?_W?O[_???_?G?A@_?CFC????O??_?_?W??_F\n",
+"[~?GW]??G@_FA???_?W?FO??C?GC?W?_[_???A?G?A@_?CFC????O??_?_?W??_F\n",
+"[~?GW]??G@_FA?@?_?W?FO??A?G?_W??[_???A?G?@@_?AFC????O??_?_?W??AF\n",
+"[~?GW]??G@_FA?@?_?W?FO??A?G?_W??[_???A?G?G@_?CFC????O??_?A?W??AF\n",
+"[~?GW]??G@_FA?@?_OW?FO??@?G?_W??[_???A?G??`_??FC????@??_??GW???N\n",
+"[~?GW]?OG@_FA?@?_?W?FG??A?G?OW??[O???@?G?@@_??F?O????C?_??GW???N\n",
+"[~?GW]??G@_FO?A?_?W?FG??C?G?_W??[A???A?G?@@_?AFC????O??_?_?W??AF\n",
+"[~?GW]??G@_FO?A?_?W?FG??C?G?_W??[A???A?G?G@_?CFC????O??_?A?W??AF\n",
+"[~?GW]??G@_FO?A?_?W?FG??C?G?_W??[O???_?G?O@_?CF?O???@??_?A?W??AF\n"};
+#define NUMIRRED (sizeof(irred)/sizeof(char*))
diff --git a/lib/nauty/ranlabg.c b/lib/nauty/ranlabg.c
new file mode 100644
index 0000000..04338c5
--- /dev/null
+++ b/lib/nauty/ranlabg.c
@@ -0,0 +1,192 @@
+/* ranlabg.c  version 1.2; B D McKay, Jun 20, 2015. */
+
+#define USAGE "ranlabg [-q] [-f#] [-S#] [infile [outfile]]"
+
+#define HELPTEXT \
+" Randomly relabel graphs.\n\
+\n\
+    The output file has a header if and only if the input file does.\n\
+    Each graph is written in the same format as it is read.\n\
+\n\
+    -f# Don't relabel the first # vertices.\n\
+    -m# Output # randomly labelled copies of each input (default 1).\n\
+    -S# Set random number seed (taken from clock otherwise).\n\
+\n\
+    -q  Suppress auxiliary information.\n"
+
+/*************************************************************************/
+
+#include "gtools.h" 
+
+/**************************************************************************/
+
+static void
+ranrelabel(graph *g, int fixed, int m, int n, graph *h)
+/* h := random labelling of g, fixing some initial vertices */
+{
+    int i,j,w,imin;
+#if MAXN
+    int perm[MAXN];
+#else
+    DYNALLSTAT(int,perm,perm_sz);
+    DYNALLOC1(int,perm,perm_sz,n,"ranlabg");
+#endif
+
+    for (i = 0 ; i < n; ++i) perm[i] = i;
+
+    if (fixed >= 0 && fixed < n) imin = fixed;
+    else                         imin = 0;
+
+    for (i = imin; i < n-1; ++i)
+    {
+        j = i + KRAN(n-i);
+        w = perm[i];
+        perm[i] = perm[j];
+        perm[j] = w;
+    }
+
+    updatecan(g,h,perm,0,m,n);
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    char *infilename,*outfilename;
+    FILE *infile,*outfile;
+    boolean badargs,quiet,Sswitch,fswitch,mswitch;
+    int j,m,n,argnum,fixed;
+    int codetype,outcode;
+    graph *g;
+    nauty_counter nin;
+    int mult;
+    boolean digraph;
+    char *arg,sw;
+    double t;
+    long seed;
+#if MAXN
+    graph h[MAXN*MAXM];
+#else
+    DYNALLSTAT(graph,h,h_sz);
+#endif
+
+    HELP; PUTVERSION;
+
+    infilename = outfilename = NULL;
+    mswitch = quiet = fswitch = Sswitch = FALSE;
+
+    argnum = 0;
+    badargs = FALSE;
+       
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('q',quiet)
+                else SWINT('f',fswitch,fixed,"ranlabg -f") 
+                else SWINT('m',mswitch,mult,"ranlabg -m") 
+                else SWLONG('S',Sswitch,seed,"ranlabg -S") 
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if (!Sswitch) INITSEED;
+    if (!mswitch) mult = 1;
+    if (!fswitch) fixed = 0;
+
+    if (!quiet)
+    {
+        fprintf(stderr,">A ranlabg");
+        fprintf(stderr," -S%ld",seed);
+        if (fswitch) fprintf(stderr,"f%d",fixed);
+        if (mswitch) fprintf(stderr,"m%d",mult);
+        if (argnum > 0) fprintf(stderr," %s",infilename);
+        if (argnum > 1) fprintf(stderr," %s",outfilename);
+        fprintf(stderr,"\n");
+        fflush(stderr);
+    }
+
+    ran_init(seed);
+
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,FALSE,1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    if (!outfilename || outfilename[0] == '-')
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename,"w")) == NULL)
+    {
+        fprintf(stderr,"Can't open output file %s\n",outfilename);
+        gt_abort(NULL);
+    }
+
+    if (codetype&SPARSE6)       outcode = SPARSE6;
+    else if (codetype&DIGRAPH6) outcode = DIGRAPH6;
+    else                        outcode = GRAPH6;
+
+    if (codetype&HAS_HEADER)
+    {
+        if (outcode == SPARSE6)       writeline(outfile,SPARSE6_HEADER);
+        else if (outcode == DIGRAPH6) writeline(outfile,DIGRAPH6_HEADER);
+        else                          writeline(outfile,GRAPH6_HEADER);
+    }
+
+    nautil_check(WORDSIZE,1,1,NAUTYVERSIONID);
+
+    nin = 0;
+    t = CPUTIME;
+    while (TRUE)
+    {
+        if ((g = readgg(infile,NULL,0,&m,&n,&digraph)) == NULL) break;
+        ++nin;
+
+#if !MAXN
+        DYNALLOC2(graph,h,h_sz,n,m,"ranlabg");
+#endif
+        for (j = 0; j < mult; ++j)
+        {
+            ranrelabel(g,fixed,m,n,h);
+            if (readg_code == SPARSE6 || readg_code == INCSPARSE6)
+                writes6(outfile,h,m,n);
+            else if (readg_code == GRAPH6)
+                writeg6(outfile,h,m,n);
+            else
+                writed6(outfile,h,m,n);
+        }
+        FREES(g);
+    }
+    t = CPUTIME - t;
+
+    if (!quiet)
+        fprintf(stderr,
+            ">Z  " COUNTER_FMT
+                 " graphs relabeled from %s to %s; %3.2f sec.\n",
+                nin,infilename,outfilename,t);
+
+    exit(0);
+}
diff --git a/lib/nauty/rng.c b/lib/nauty/rng.c
new file mode 100644
index 0000000..691ea61
--- /dev/null
+++ b/lib/nauty/rng.c
@@ -0,0 +1,131 @@
+/* rng.c
+   This file contains the code for a high-quality random number
+   generator written by Don Knuth.  The auxilliary routine
+   ran_arr_cycle() has been modified slightly, and ran_init() is new.
+
+   To use it:
+
+      0.  #include "rng.h" (or "naututil.h" if you are using nauty)
+
+      1.  Call ran_init(seed), where seed is any long integer.
+          This step is optional, but if you don't use it you
+          will always get the same sequence of random numbers.
+
+      2.  For each random number, use the NEXTRAN macro.  It will
+          give a random value in the range 0..2^30-1.  Alternatively,
+          KRAN(k) will have a random value in the range 0..k-1.
+          KRAN(k) actually gives you NEXTRAN mod k, so it is not
+          totally uniform if k is very large.  In that case, you
+          can use the slightly slower GETKRAN(k,var) to set the
+          variable var to a better random number from 0..k-1.
+
+    Brendan McKay, July 2002.  Fixed Nov 2002 on advice of DEK.
+
+*/
+
+/*    This program by D E Knuth is in the public domain and freely copyable
+ *    AS LONG AS YOU MAKE ABSOLUTELY NO CHANGES!
+ *    It is explained in Seminumerical Algorithms, 3rd edition, Section 3.6
+ *    (or in the errata to the 2nd edition --- see
+ *        http://www-cs-faculty.stanford.edu/~knuth/taocp.html
+ *    in the changes to Volume 2 on pages 171 and following).              */
+
+/*    N.B. The MODIFICATIONS introduced in the 9th printing (2002) are
+      included here; there's no backwards compatibility with the original. */
+
+/*    If you find any bugs, please report them immediately to
+ *                 taocp@cs.stanford.edu
+ *    (and you will be rewarded if the bug is genuine). Thanks!            */
+
+/************ see the book for explanations and caveats! *******************/
+/************ in particular, you need two's complement arithmetic **********/
+
+#define KK 100                     /* the long lag */
+#define LL  37                     /* the short lag */
+#define MM (1L<<30)                 /* the modulus */
+#define mod_diff(x,y) (((x)-(y))&(MM-1)) /* subtraction mod MM */
+
+long ran_x[KK];                    /* the generator state */
+
+#ifdef __STDC__
+void ran_array(long aa[],int n)
+#else
+void ran_array(aa,n)    /* put n new random numbers in aa */
+  long *aa;   /* destination */
+  int n;      /* array length (must be at least KK) */
+#endif
+{
+  int i,j;
+  for (j=0;j<KK;j++) aa[j]=ran_x[j];
+  for (;j<n;j++) aa[j]=mod_diff(aa[j-KK],aa[j-LL]);
+  for (i=0;i<LL;i++,j++) ran_x[i]=mod_diff(aa[j-KK],aa[j-LL]);
+  for (;i<KK;i++,j++) ran_x[i]=mod_diff(aa[j-KK],ran_x[i-LL]);
+}
+
+/* the following routines are from exercise 3.6--15 */
+/* after calling ran_start, get new randoms by, e.g., "x=ran_arr_next()" */
+
+#define QUALITY 1009 /* recommended quality level for high-res use */
+static long ran_arr_buf[QUALITY];
+static long ran_arr_dummy=-1, ran_arr_started=-1;
+long *ran_arr_ptr=&ran_arr_dummy; /* the next random number, or -1 */
+
+#define TT  70   /* guaranteed separation between streams */
+#define is_odd(x)  ((x)&1)          /* units bit of x */
+
+#ifdef __STDC__
+void ran_start(long seed)
+#else
+void ran_start(seed)    /* do this before using ran_array */
+  long seed;            /* selector for different streams */
+#endif
+{
+  int t,j;
+  long x[KK+KK-1];              /* the preparation buffer */
+  long ss=(seed+2)&(MM-2);
+  for (j=0;j<KK;j++) {
+    x[j]=ss;                      /* bootstrap the buffer */
+    ss<<=1; if (ss>=MM) ss-=MM-2; /* cyclic shift 29 bits */
+  }
+  x[1]++;              /* make x[1] (and only x[1]) odd */
+  for (ss=seed&(MM-1),t=TT-1; t; ) {       
+    for (j=KK-1;j>0;j--) x[j+j]=x[j], x[j+j-1]=0; /* "square" */
+    for (j=KK+KK-2;j>=KK;j--)
+      x[j-(KK-LL)]=mod_diff(x[j-(KK-LL)],x[j]),
+      x[j-KK]=mod_diff(x[j-KK],x[j]);
+    if (is_odd(ss)) {              /* "multiply by z" */
+      for (j=KK;j>0;j--)  x[j]=x[j-1];
+      x[0]=x[KK];            /* shift the buffer cyclically */
+      x[LL]=mod_diff(x[LL],x[KK]);
+    }
+    if (ss) ss>>=1; else t--;
+  }
+  for (j=0;j<LL;j++) ran_x[j+KK-LL]=x[j];
+  for (;j<KK;j++) ran_x[j-LL]=x[j];
+  for (j=0;j<10;j++) ran_array(x,KK+KK-1); /* warm things up */
+  ran_arr_ptr=&ran_arr_started;
+}
+
+void
+ran_init(long seed)    /* Added by BDM: use instead of ran_start. */
+                       /*  But this is less important with this version */
+{
+    ran_start((unsigned long)seed % (MM-2));
+}
+
+#define ran_arr_next() (*ran_arr_ptr>=0? *ran_arr_ptr++: ran_arr_cycle())
+
+long
+ran_arr_cycle(void)
+/* Modified by BDM to automatically initialise 
+   if no explicit initialisation has been done */
+{
+   if (ran_arr_ptr==&ran_arr_dummy)
+       ran_start(314159L); /* the user forgot to initialize */
+
+  ran_array(ran_arr_buf,QUALITY);
+
+  ran_arr_buf[KK]=-1;
+  ran_arr_ptr=ran_arr_buf+1;
+  return ran_arr_buf[0];
+}
diff --git a/lib/nauty/rng.h b/lib/nauty/rng.h
new file mode 100644
index 0000000..7160486
--- /dev/null
+++ b/lib/nauty/rng.h
@@ -0,0 +1,37 @@
+/* rng.h : definitions for using Don Knuth's random number generator.
+
+   To use it:
+     1.  Call ran_init(seed) with any long seed.  (Optional,
+	   but you will always get the same sequence otherwise.)
+     2.  Use NEXTRAN to get the next number (0..2^30-1).
+         Alternatively, use KRAN(k) to get a random number 0..k-1.
+	 For large k, KRAN(k) is not quite uniform.  In that case
+         use GETKRAN(k,var) to set the variable var to a better
+         random number 0..k-1.
+
+   Some of these definitions are also in naututil.h.
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long *ran_arr_ptr;
+long ran_arr_cycle(void);
+void ran_init(long seed);
+void ran_array(long *aa, int n);
+
+#ifdef __cplusplus
+}
+#endif
+
+#define MAXRAN (0x3fffffffL)    /* Values are 0..MAXRAN */
+#define NEXTRAN (*ran_arr_ptr>=0 ? *ran_arr_ptr++ : ran_arr_cycle())
+#define KRAN(k) (NEXTRAN%(k))
+#define RANREAL ((NEXTRAN+0.5)/(MAXRAN+1.0))  /* Uniform (0,1) */
+
+#define MAXSAFE(k) (((MAXRAN+1)/(k))*(k))
+#define GETKRAN(k,var) {long __getkran; \
+    do {__getkran = NEXTRAN;} while (__getkran >= MAXSAFE(k)); \
+    var = __getkran % (k);}
+#define INITRANBYTIME ran_init((long)time(NULL))
diff --git a/lib/nauty/runalltests b/lib/nauty/runalltests
new file mode 100755
index 0000000..903b3bb
--- /dev/null
+++ b/lib/nauty/runalltests
@@ -0,0 +1,91 @@
+#!/bin/sh
+# Run all nauty checks
+
+runonetest() {
+cmd="$1"
+in="$2"
+ok="$3"
+printf "%s %s %s  " "$cmd" "$in" "$ok"
+ 
+if [ "X$in" = "X" ] ; then
+   in=/dev/null
+elif [ ! -r "$in" ] ; then
+   echo "File $in not found or not readable."
+   exit 1
+fi
+
+if [ ! -r "$ok" ] ; then
+   echo "File $ok not found or not readable."
+   exit 1
+fi
+
+out1=`mktemp runtest.XXXXXX`
+out2=`mktemp runtest.XXXXXX`
+
+eval $cmd <"$in" 2>$out2 >$out1
+LC_COLLATE=C sort $out2 >>$out1
+if ./naucompare "$out1" "$ok" ; then
+   rm $out1 $out2
+else
+   echo "Output file is $out1"
+   rm $out2
+   fails=`expr $fails + 1`
+fi
+}
+
+fails=0
+
+runonetest ./dreadtest nautest1.dre nautest1a.ans
+runonetest "./dreadtest -o As" nautest1.dre nautest1b.ans
+runonetest "./dreadtest -o At" nautest1.dre nautest1c.ans
+runonetest ./dreadtestS nautest1.dre nautest1a.ans
+runonetest "./dreadtestS -o As" nautest1.dre nautest1b.ans
+runonetest ./dreadtestW nautest1.dre nautest1a.ans
+runonetest "./dreadtestW -o As" nautest1.dre nautest1b.ans
+runonetest ./dreadtestL nautest1.dre nautest1a.ans
+runonetest "./dreadtestL -o As" nautest1.dre nautest1b.ans
+runonetest ./dreadtestL1 nautest1.dre nautest1a.ans
+runonetest "./dreadtestL1 -o As" nautest1.dre nautest1b.ans
+runonetest ./dreadtest4K nautest1.dre nautest1a.ans
+runonetest "./dreadtest4K -o As" nautest1.dre nautest1b.ans
+runonetest "./dreadtest4K -o At" nautest1.dre nautest1c.ans
+
+runonetest ./dreadtest nautest2.dre nautest2a.ans
+runonetest "./dreadtest -o As" nautest2.dre nautest2b.ans
+runonetest "./dreadtest -o At" nautest2.dre nautest2c.ans
+runonetest ./dreadtestS nautest2.dre nautest2a.ans
+runonetest "./dreadtestS -o As" nautest2.dre nautest2b.ans
+runonetest ./dreadtestW nautest2.dre nautest2a.ans
+runonetest "./dreadtestW -o As" nautest2.dre nautest2b.ans
+runonetest "./dreadtestW -o At" nautest2.dre nautest2c.ans
+runonetest ./dreadtestL nautest2.dre nautest2a.ans
+runonetest "./dreadtestL -o As" nautest2.dre nautest2b.ans
+runonetest "./dreadtestL -o At" nautest2.dre nautest2c.ans
+runonetest ./dreadtest1 nautest2.dre nautest2a.ans
+runonetest "./dreadtest1 -o As" nautest2.dre nautest2b.ans
+runonetest ./dreadtestS1 nautest2.dre nautest2a.ans
+runonetest "./dreadtestS1 -o As" nautest2.dre nautest2b.ans
+runonetest ./dreadtestW1 nautest2.dre nautest2a.ans
+runonetest "./dreadtestW1 -o As" nautest2.dre nautest2b.ans
+runonetest ./dreadtestL1 nautest2.dre nautest2a.ans
+runonetest "./dreadtestL1 -o As" nautest2.dre nautest2b.ans
+runonetest ./dreadtest4K nautest2.dre nautest2a.ans
+runonetest "./dreadtest4K -o As" nautest2.dre nautest2b.ans
+
+runonetest "./geng -ud1D7t 11" "" nautesta.ans
+runonetest "./geng -cd1f 10 | ./labelg -q" "" nautestb.ans
+runonetest "./genrang -r3 114 100 | ./countg --nedDr -q" "" nautestc.ans
+runonetest "./gentourng -q -z 8 | ./pickg -T3" "" nautestd.ans
+runonetest "./gentreeg -q -s 18 | ./countg -z6 --o" "" nauteste.ans
+runonetest "./geng -c -q 8 8 | ./directg -q -o | ./converseg -q | ./labelg -q" "" nautestf.ans
+runonetest "./genbg -q 4 3 10 | ./vcolg -m6 -T" "" nautestg.ans
+
+echo " "
+
+if [ $fails -eq 0 ] ; then
+   echo "PASSED ALL TESTS"
+   exit 0
+else
+   echo "$fails TESTS FAILED"
+   exit 1
+fi
diff --git a/lib/nauty/schreier.c b/lib/nauty/schreier.c
new file mode 100644
index 0000000..db00491
--- /dev/null
+++ b/lib/nauty/schreier.c
@@ -0,0 +1,1124 @@
+/* schreier.c - procedures for manipulating a permutation group using
+ * the random schreier algorithm.  There is a separate file schreier.txt
+ * which describes the usage.
+ *
+ * Written for nauty and traces, Brendan McKay 2010-2013.
+ */
+
+#include "schreier.h" 
+
+TLS_ATTR long long multcount = 0;
+TLS_ATTR long long filtercount = 0;
+
+static permnode id_permnode; 
+  /* represents identity, no actual content, doesn't need TLS_ATTR */
+#define ID_PERMNODE (&id_permnode)
+
+#if !MAXN
+DYNALLSTAT(int,workperm,workperm_sz);
+DYNALLSTAT(int,workperm2,workperm2_sz);
+DYNALLSTAT(int,workpermA,workpermA_sz);
+DYNALLSTAT(int,workpermB,workpermB_sz);
+DYNALLSTAT(set,workset,workset_sz);
+DYNALLSTAT(set,workset2,workset2_sz);
+#else
+static TLS_ATTR int workperm[MAXN];
+static TLS_ATTR int workperm2[MAXN];
+static TLS_ATTR int workpermA[MAXN];
+static TLS_ATTR int workpermB[MAXN];
+static TLS_ATTR set workset[MAXM];
+static TLS_ATTR set workset2[MAXM];
+#endif
+
+static TLS_ATTR schreier *schreier_freelist = NULL;
+	/* Freelist of scheier structures connected by next field.
+         * vec, pwr and orbits fields are assumed allocated. */
+static TLS_ATTR permnode *permnode_freelist = NULL;
+	/* Freelist of permnode structures connected by next field.
+         * p[] is assumed extended. */
+
+static TLS_ATTR int schreierfails = SCHREIERFAILS;
+
+#define TMP
+
+static boolean filterschreier(schreier*,int*,permnode**,boolean,int,int);
+#define PNCODE(x) ((int)(((size_t)(x)>>3)&0xFFFUL))
+
+/* #define TESTP(id,p,n) testispermutation(id,p,n) */
+#define TESTP(id,p,n)
+
+/************************************************************************/
+
+static void
+testispermutation(int id, int *p, int n)
+/* For debugging purposes, crash with a message if p[0..n-1] is
+   not a permutation. */
+{
+    int i,m;
+    DYNALLSTAT(set,seen,seen_sz);
+
+    for (i = 0; i < n; ++i)
+        if (p[i] < 0 || p[i] > n) break;
+
+    if (i < n)
+    {
+	fprintf(stderr,">E Bad permutation (id=%d): n=%d p[%d]=%d\n",
+		id,n,i,p[i]);
+	exit(1);
+    }
+
+    m = SETWORDSNEEDED(n);
+    DYNALLOC1(set,seen,seen_sz,m,"malloc seen");
+    EMPTYSET(seen,m);
+
+    for (i = 0; i < n; ++i)
+    {
+	if (ISELEMENT(seen,p[i]))
+	{
+	    fprintf(stderr,
+		">E Bad permutation (id=%d): n=%d p[%d]=%d is a repeat\n",
+		id,n,i,p[i]);
+	    exit(1);
+	}
+        ADDELEMENT(seen,p[i]);
+    }
+}
+    
+/************************************************************************/
+
+int
+schreier_fails(int nfails)
+/* Set the number of consecutive failures for filtering;
+ * A value of <= 0 defaults to SCHREIERFAILS.
+ * The function value is the previous setting. */
+{
+    int prev;
+
+    prev = schreierfails;
+
+    if (nfails <= 0) schreierfails = SCHREIERFAILS;
+    else             schreierfails = nfails;
+
+    return prev;
+}
+
+/************************************************************************/
+
+static void
+clearfreelists(void)
+/* Clear the schreier and permnode freelists */
+{
+    schreier *sh,*nextsh;
+    permnode *p,*nextp;
+
+    nextsh = schreier_freelist;
+    while (nextsh)
+    {
+	sh = nextsh;
+	nextsh = sh->next;
+	free(sh->vec);
+	free(sh->pwr);
+	free(sh->orbits);
+	free(sh);
+    }
+    schreier_freelist = NULL;
+
+    nextp = permnode_freelist;
+    while (nextp)
+    {
+	p = nextp;
+	nextp = p->next;
+	free(p);
+    }
+    permnode_freelist = NULL;
+}
+
+/************************************************************************/
+
+static permnode
+*newpermnode(int n)
+/* Allocate a new permode structure, with initialized next/prev fields */
+{
+    permnode *p;
+
+    while (permnode_freelist)
+    {
+	p = permnode_freelist;
+	permnode_freelist = p->next;
+	if (p->nalloc >= n && p->nalloc <= n+100)
+	{
+	    p->next = p->prev = NULL;
+	    p->mark = 0;
+            return p;
+	}
+	else
+	    free(p);
+    }
+
+    p = (permnode*) malloc(sizeof(permnode)+(n-2)*sizeof(int)); 
+
+    if (p == NULL)
+    {
+        fprintf(ERRFILE,">E malloc failed in newpermnode()\n");
+        exit(1);
+    }
+
+    p->next = p->prev = NULL;
+    p->nalloc = n;
+
+    return p;
+}
+
+/************************************************************************/
+
+static schreier
+*newschreier(int n)
+/* Allocate a new schreier structure, with initialised next field */
+{
+    schreier *sh;
+
+    while (schreier_freelist)
+    {
+	sh = schreier_freelist;
+	schreier_freelist = sh->next;
+	if (sh->nalloc >= n && sh->nalloc <= n+100)
+	{
+	    sh->next = NULL;
+	    return sh;
+	}
+	else
+	{
+	    free(sh->vec);
+	    free(sh->pwr);
+	    free(sh->orbits);
+	    free(sh);
+	}
+    }
+
+    sh = (schreier*) malloc(sizeof(schreier));
+
+    if (sh == NULL)
+    {
+        fprintf(ERRFILE,">E malloc failed in newschreier()\n");
+        exit(1);
+    }
+
+    sh->vec = (permnode**) malloc(sizeof(permnode*)*n);
+    sh->pwr = (int*) malloc(sizeof(int)*n);
+    sh->orbits = (int*) malloc(sizeof(int)*n);
+
+    if (sh->vec == NULL || sh->pwr == NULL || sh->orbits == NULL)
+    {
+        fprintf(ERRFILE,">E malloc failed in newschreier()\n");
+        exit(1);
+    }
+
+    sh->next = NULL;
+    sh->nalloc = n;
+
+    return sh;
+}
+
+/************************************************************************/
+
+void
+freeschreier(schreier **gp, permnode **gens)
+/* Free schreier structure and permutation ring.  Assume this is everything. */
+/* Use NULL for arguments which don't need freeing. */
+{
+    schreier *sh,*nextsh;
+    permnode *p,*nextp;
+
+    if (gp && *gp)
+    {
+        nextsh = *gp;
+        while (nextsh)
+        {
+	    sh = nextsh;
+	    nextsh = sh->next;
+	    sh->next = schreier_freelist;
+	    schreier_freelist = sh;
+        }
+        *gp = NULL;
+    }
+
+    if (gens && *gens)
+    {
+        p = *gens;
+        do
+        {
+            nextp = p->next;
+	    p->next = permnode_freelist;
+	    permnode_freelist = p;
+	    p = nextp;
+        } while (p != *gens);
+        *gens = NULL;
+    }
+}
+
+/************************************************************************/
+
+permnode*
+findpermutation(permnode *pn, int *p, int n)
+/* Return a pointer to permutation p in the circular list,
+ * or NULL if it isn't present. */
+{
+    permnode *rn;
+    int i;
+
+    if (!pn) return NULL;
+
+    rn = pn;
+    do
+    {
+	for (i = 0; i < n; ++i) 
+	    if (rn->p[i] != p[i]) break;
+	if (i == n) return rn;
+	rn = rn->next;
+    } while (rn != pn);
+
+    return NULL;
+}
+
+/************************************************************************/
+
+void
+addpermutation(permnode **ring, int *p, int n)
+/* Add new permutation to circular list, marked.
+ * and return pointer to it in *ring. */
+{
+    permnode *pn,*rn;
+
+    pn = newpermnode(n);
+    rn = *ring;
+
+    memcpy(pn->p,p,n*sizeof(int));
+	
+    if (!rn)
+	pn->next = pn->prev = pn;
+    else
+    {
+	pn->next = rn->next;
+	pn->prev = rn;
+	rn->next = pn->next->prev = pn;
+    }
+
+    pn->refcount = 0;
+    pn->mark = 1;
+    *ring = pn;
+}
+
+/************************************************************************/
+
+static void
+addpermutationunmarked(permnode **ring, int *p, int n)
+/* Add new permutation to circular list, not marked.
+ * and return pointer to it in *ring. */
+{
+    TESTP(3,p,n);
+    addpermutation(ring,p,n);
+    (*ring)->mark = 0;
+}
+
+/************************************************************************/
+
+boolean
+addgenerator(schreier **gp, permnode **ring, int *p, int n)
+/* Add new permutation to group, unless it is discovered to be
+ * already in the group.  It is is possible to be in the group
+ * and yet this fact is not discovered.
+ * Return TRUE if the generator (or an equivalent) is added or the
+ * group knowledge with the current partial base is improved. */
+{
+    TESTP(2,p,n);
+    return filterschreier(*gp,p,ring,FALSE,-1,n);
+}
+
+/************************************************************************/
+
+boolean
+condaddgenerator(schreier **gp, permnode **ring, int *p, int n)
+/* Add new permutation to group, unless it is discovered to be
+ * already in the group.  It is is possible to be in the group
+ * and yet this fact is not discovered, but this version will 
+ * always notice if this permutation precisely is present.
+ * Return TRUE if the generator (or an equivalent) is added or the
+ * group knowledge with the current partial base is improved. */
+{
+    TESTP(4,p,n);
+    if (findpermutation(*ring,p,n)) 
+	return FALSE;
+    else
+        return filterschreier(*gp,p,ring,FALSE,-1,n);
+}
+
+/************************************************************************/
+
+static void
+delpermnode(permnode **ring)
+/* Delete permnode at head of circular list, making the next node head. */
+{
+    permnode *newring;
+
+    if (!*ring) return;
+
+    if ((*ring)->next == *ring)
+	newring = NULL;
+    else
+    {
+	newring = (*ring)->next;
+	newring->prev = (*ring)->prev;
+        (*ring)->prev->next = newring;
+    }
+
+    (*ring)->next = permnode_freelist;
+    permnode_freelist = *ring;
+
+    *ring = newring;
+}
+
+/************************************************************************/
+
+void
+deleteunmarked(permnode **ring)
+/* Delete all permutations in the ring that are not marked */
+{
+    permnode *pn,*firstmarked;
+
+    pn = *ring;
+    firstmarked = NULL;
+
+    while (pn != NULL && pn != firstmarked)
+    {
+	if (pn->mark)
+	{
+	    if (!firstmarked) firstmarked = pn;
+	    pn = pn->next;
+	}
+	else
+	    delpermnode(&pn);
+    }
+
+    *ring = pn;
+}
+
+/************************************************************************/
+
+static void
+clearvector(permnode **vec, permnode **ring, int n)
+/* clear vec[0..n-1], freeing permnodes that have no other references
+ * and are not marked */
+{
+    int i;
+
+    for (i = 0; i < n; ++i)
+        if (vec[i])
+        {
+            if (vec[i] != ID_PERMNODE)
+	    {
+		--(vec[i]->refcount);
+		if (vec[i]->refcount == 0 && !vec[i]->mark)
+		{
+		    *ring = vec[i];
+		    delpermnode(ring);
+		}
+	    }
+            vec[i] = NULL;
+        }
+}
+
+/************************************************************************/
+
+static void
+initschreier(schreier *sh, int n)
+/* Initialise schreier structure to trivial orbits and empty vector */
+{
+    int i;
+
+    sh->fixed = -1;
+    for (i = 0; i < n; ++i)
+    {
+	sh->vec[i] = NULL; 
+	sh->orbits[i] = i;
+    }
+}
+
+/************************************************************************/
+
+void
+newgroup(schreier **sh, permnode **ring, int n)
+/* Make the trivial group, allow for ring to be set elsewhere */
+{
+    *sh = newschreier(n);
+    initschreier(*sh,n);
+    if (ring) *ring = NULL;
+}
+
+/************************************************************************/
+
+static void
+applyperm(int *wp, int *p, int k, int n)
+/* Apply the permutation p, k times to each element of wp */
+{
+    int i,j,cyclen,kk,m;
+
+    TESTP(1,p,n);
+
+    if (k <= 5)
+    {
+        if (k == 0)
+            return;
+        else if (k == 1)
+            for (i = 0; i < n; ++i) wp[i] = p[wp[i]];
+        else if (k == 2)
+            for (i = 0; i < n; ++i) wp[i] = p[p[wp[i]]];
+        else if (k == 3)
+            for (i = 0; i < n; ++i) wp[i] = p[p[p[wp[i]]]];
+        else if (k == 4)
+            for (i = 0; i < n; ++i) wp[i] = p[p[p[p[wp[i]]]]];
+        else if (k == 5)
+            for (i = 0; i < n; ++i) wp[i] = p[p[p[p[p[wp[i]]]]]];
+    }
+    else if (k <= 19)
+    {
+#if !MAXN
+        DYNALLOC1(int,workpermA,workpermA_sz,n,"applyperm");
+#endif
+        for (i = 0; i < n; ++i) workpermA[i] = p[p[p[i]]];
+        for (; k >= 6; k -= 6)
+            for (i = 0; i < n; ++i) wp[i] = workpermA[workpermA[wp[i]]];
+        if (k == 1)
+            for (i = 0; i < n; ++i) wp[i] = p[wp[i]];
+        else if (k == 2)
+            for (i = 0; i < n; ++i) wp[i] = p[p[wp[i]]];
+        else if (k == 3)
+            for (i = 0; i < n; ++i) wp[i] = workpermA[wp[i]];
+        else if (k == 4)
+            for (i = 0; i < n; ++i) wp[i] = p[workpermA[wp[i]]];
+        else if (k == 5)
+            for (i = 0; i < n; ++i) wp[i] = p[p[workpermA[wp[i]]]];
+    }
+    else
+    {
+        m = SETWORDSNEEDED(n);
+#if !MAXN
+        DYNALLOC1(int,workpermA,workpermA_sz,n,"applyperm");
+        DYNALLOC1(int,workpermB,workpermB_sz,n,"applyperm");
+        DYNALLOC1(set,workset2,workset2_sz,m,"applyperm");
+#endif
+
+        EMPTYSET(workset2,m);
+
+      /* We will construct p^k in workpermB one cycle at a time. */
+
+        for (i = 0; i < n; ++i)
+        {
+            if (ISELEMENT(workset2,i)) continue;
+            if (p[i] == i)
+                workpermB[i] = i;
+            else
+            {
+                cyclen = 1;
+                workpermA[0] = i;
+                for (j = p[i]; j != i; j = p[j])
+                {
+                    workpermA[cyclen++] = j;
+                    ADDELEMENT(workset2,j);
+                }
+                kk = k % cyclen;
+                for (j = 0; j < cyclen; ++j)
+                {
+                    workpermB[workpermA[j]] = workpermA[kk];
+                    if (++kk == cyclen) kk = 0;
+                }
+            }
+        }
+        for (i = 0; i < n; ++i) wp[i] = workpermB[wp[i]];
+    }
+}
+
+/************************************************************************/
+
+static boolean
+filterschreier(schreier *gp, int *p, permnode **ring,
+               boolean ingroup, int maxlevel, int n)
+/* Filter permutation p up to level maxlevel of gp.
+ * Use ingroup=TRUE if p is known to be in the group, otherwise
+ * at least one equivalent generator is added unless it is proved
+ * (nondeterministically) that it is in the group already. 
+ * maxlevel < 0 means no limit, maxlevel=0 means top level only, etc.
+ * Return TRUE iff some change is made. */
+{
+    int i,j,j1,j2,lev;
+    int ipwr;
+    schreier *sh;
+    int *orbits,*pwr;
+    permnode **vec,*curr;
+    boolean changed,lchanged,ident;
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n,"filterschreier");
+#endif
+
+++filtercount;
+
+    memcpy(workperm,p,n*sizeof(int));
+
+    if (*ring && p == (*ring)->p)
+    {
+	ingroup = TRUE;
+	curr = *ring;
+    }
+    else
+	curr = NULL;
+
+ /* curr is the location of workperm in ring, if anywhere */
+
+    sh = gp;
+    changed = FALSE;
+    if (maxlevel < 0) maxlevel = n+1;
+ 
+    for (lev = 0; lev <= maxlevel; ++lev)
+    {
+	for (i = 0; i < n; ++i) if (workperm[i] != i) break;
+	ident = (i == n);
+	if (ident) break;
+
+	lchanged = FALSE;
+	orbits = sh->orbits;
+	vec = sh->vec;
+        pwr = sh->pwr;
+	for (i = 0; i < n; ++i)
+	{
+	    j1 = orbits[i];
+            while (orbits[j1] != j1) j1 = orbits[j1];
+	    j2 = orbits[workperm[i]];
+            while (orbits[j2] != j2) j2 = orbits[j2];
+
+	    if (j1 != j2)
+	    {
+		lchanged = TRUE;
+		if (j1 < j2) orbits[j2] = j1;
+		else         orbits[j1] = j2;
+	    }
+	}
+	if (lchanged)
+	    for (i = 0; i < n; ++i) orbits[i] = orbits[orbits[i]];
+
+	if (lchanged) changed = TRUE;
+	
+	if (sh->fixed >= 0)
+	{
+	    for (i = 0; i < n; ++i)
+	        if (vec[i] && !vec[workperm[i]])
+	        {
+		    changed = TRUE;
+		    ipwr = 0;
+		    for (j = workperm[i]; !vec[j] ; j = workperm[j]) ++ipwr;
+
+		    for (j = workperm[i]; !vec[j] ; j = workperm[j])
+		    {
+			if (!curr)
+			{
+			    if (!ingroup) addpermutation(ring,workperm,n);
+			    else  addpermutationunmarked(ring,workperm,n);
+			    ingroup = TRUE;
+			    curr = *ring;
+			}
+			vec[j] = curr;
+			pwr[j] = ipwr--;
+			++curr->refcount;
+		    }
+	        }
+
+	    j = workperm[sh->fixed];
+
+	    while (j != sh->fixed)
+	    {
+		applyperm(workperm,vec[j]->p,pwr[j],n);
+		++multcount;
+		curr = NULL;
+		j = workperm[sh->fixed];
+	    }
+	    sh = sh->next;
+	}
+	else
+	    break;
+    }
+
+    if (!ident && !ingroup)
+    {
+	changed = TRUE;
+	addpermutation(ring,p,n);
+    }
+
+    return changed;
+}
+
+/************************************************************************/
+
+boolean
+expandschreier(schreier *gp, permnode **ring, int n)
+/* filter random elements until schreierfails failures.
+ * Return true if it ever expanded. */
+{
+    int i,j,nfails,wordlen,skips;
+    boolean changed;
+    permnode *pn;
+#if !MAXN
+    DYNALLOC1(int,workperm2,workperm2_sz,n,"expandschreier");
+#endif
+
+    pn = *ring;
+    if (pn == NULL) return FALSE;
+
+    nfails = 0;
+    changed = FALSE;
+
+    for (skips = KRAN(17); --skips >= 0; ) pn = pn->next;
+ 
+    memcpy(workperm2,pn->p,n*sizeof(int));
+
+    while (nfails < schreierfails)
+    {
+	wordlen = 1 + KRAN(3);
+	for (j = 0; j < wordlen; ++j)
+	{
+	    for (skips = KRAN(17); --skips >= 0; ) pn = pn->next;
+	    for (i = 0; i < n; ++i) workperm2[i] = pn->p[workperm2[i]];
+	}
+	if (filterschreier(gp,workperm2,ring,TRUE,-1,n))
+	{
+	    changed = TRUE;
+	    nfails = 0;
+	}
+	else
+	    ++nfails;
+    }
+
+    return changed;
+}
+
+/************************************************************************/
+
+int*
+getorbits(int *fix, int nfix, schreier *gp, permnode **ring, int n)
+/* Get a pointer to the orbits for this partial base. The pointer
+ * remains valid until pruneset(), getorbits(), getorbitsmin()
+ * or grouporder() is called with an incompatible base (neither a
+ * prefix nor an extension). The contents of the array pointed to
+ * MUST NOT BE MODIFIED by the calling program.
+ */
+{
+    int k;
+    schreier *sh,*sha;
+
+    sh = gp;
+    for (k = 0; k < nfix; ++k)
+    {
+	if (sh->fixed != fix[k]) break;
+	sh = sh->next;
+    }
+
+    if (k == nfix) return sh->orbits;
+ 
+    sh->fixed = fix[k];
+    clearvector(sh->vec,ring,n);
+    sh->vec[fix[k]] = ID_PERMNODE;  
+
+    for (sha = sh->next; sha ; sha = sha->next) clearvector(sha->vec,ring,n);
+    
+    for (++k; k <= nfix; ++k)
+    {
+	if (!sh->next) sh->next = newschreier(n);
+	sh = sh->next;
+	initschreier(sh,n);
+	if (k < nfix)
+	{
+	    sh->fixed = fix[k];
+	    sh->vec[fix[k]] = ID_PERMNODE;
+	}
+	else
+	    sh->fixed = -1;
+    }
+
+    if (*ring) expandschreier(gp,ring,n);
+    return sh->orbits;
+}
+
+/************************************************************************/
+
+int
+getorbitsmin(int *fix, int nfix, schreier *gp, permnode **ring,
+         int **orbits, int *cell, int ncell, int n, boolean changed)
+/* If the basis elements fix[0..nfix-1] are minimal in their orbits,
+ * as far as we know, return value nfix and set *orbits to point
+ * to orbits fixing fix[0..nfix-1]. If fix[i] is seen to be not
+ * minimal for some i <= nfix-1, return i and set *orbits to point
+ * to orbits fixing fix[0..i-1]. If the partial base is already
+ * known, or fix[0..nfix-1] can already be seen to be non-minimal,
+ * do this work without more filtering. This shortcut is turned
+ * off if changed==TRUE. Otherwise, filter until schreierfails
+ * failures.
+ * The pointer returned remains valid until pruneset(), getorbits(),
+ * getorbitsmin() or grouporder() is called with an incompatible base
+ * (neither a prefix nor an extension). The contents of the array
+ * pointed to MUST NOT BE MODIFIED by the calling program.
+ * If cell != NULL, return early if possible when cell[0..ncell-1]
+ * are all in the same orbit fixing fix[0..nfix-1]. Otherwise
+ * cell,ncell play no part in the computation.
+ */
+{
+    schreier *sh,*sha;
+    int *fixorbs;
+    int i,j,k,icell,nfails,wordlen,skips;
+    permnode *pn;
+#if !MAXN
+    DYNALLOC1(int,workperm2,workperm2_sz,n,"expandschreier");
+#endif
+
+    sh = gp;
+    k = 0;
+    if (!changed)
+        for (k = 0; k < nfix; ++k)
+        {
+	    if (sh->orbits[fix[k]] != fix[k])
+	    {
+	        *orbits = sh->orbits;
+	        return k;
+	    }
+	    if (sh->fixed != fix[k]) break;
+	    sh = sh->next;
+        }
+
+    if (k == nfix)
+    {
+	*orbits = sh->orbits;
+	return nfix;
+    }
+ 
+    sh->fixed = fix[k];
+    clearvector(sh->vec,ring,n);
+    sh->vec[fix[k]] = ID_PERMNODE;  
+
+    for (sha = sh->next; sha ; sha = sha->next) clearvector(sha->vec,ring,n);
+    
+    for (++k; k <= nfix; ++k)
+    {
+	if (!sh->next) sh->next = newschreier(n);
+	sh = sh->next;
+	initschreier(sh,n);
+	if (k < nfix)
+	{
+	    sh->fixed = fix[k];
+	    sh->vec[fix[k]] = ID_PERMNODE;
+	}
+	else
+	    sh->fixed = -1;
+    }
+    *orbits = fixorbs = sh->orbits;
+
+    if (cell)
+    {
+	for (icell = 1; icell < ncell; ++icell)
+	    if (fixorbs[cell[icell]] != fixorbs[cell[0]]) break;
+
+	if (icell >= ncell) return nfix;
+    }
+
+    if (*ring)
+    {
+        pn = *ring;
+
+        nfails = 0;
+
+        for (skips = KRAN(17); --skips >= 0; ) pn = pn->next;
+
+        memcpy(workperm2,pn->p,n*sizeof(int));
+
+        while (nfails < schreierfails)
+        {
+            wordlen = 1 + KRAN(3);
+            for (j = 0; j < wordlen; ++j)
+            {
+                for (skips = KRAN(17); --skips >= 0; ) pn = pn->next;
+                for (i = 0; i < n; ++i) workperm2[i] = pn->p[workperm2[i]];
+            }
+            if (filterschreier(gp,workperm2,ring,TRUE,-1,n))
+            {
+                nfails = 0;
+                sh = gp;
+                for (k = 0; k < nfix; ++k)
+                {
+	            if (sh->orbits[fix[k]] != fix[k])
+	            {
+	                *orbits = sh->orbits;
+	                return k;
+	            }
+	            sh = sh->next;
+		}
+		if (cell)
+		{
+		    for ( ; icell < ncell; ++icell)
+	    	 	if (fixorbs[cell[icell]] != fixorbs[cell[0]]) break;
+
+		    if (icell >= ncell) return nfix;
+		}
+	    }
+            else
+                ++nfails;
+        }
+    }
+
+    return nfix;
+}
+
+/************************************************************************/
+
+void
+pruneset(set *fixset, schreier *gp, permnode **ring, set *x, int m, int n)
+/* Remove from x any point not minimal for the orbits for this base.
+ * If the base is already known, just provide the orbits without
+ * more filtering. Otherwise, filter until schreierfails failures.
+ */ 
+{
+    int i,k;
+    schreier *sh,*sha;
+    int *orbits;
+
+#if !MAXN
+    DYNALLOC1(set,workset,workset_sz,m,"pruneset");
+#endif
+    for (i = 0; i < m; ++i) workset[i] = fixset[i];
+	
+    sh = gp;
+    while (sh->fixed >= 0 && ISELEMENT(workset,sh->fixed))
+    {
+	DELELEMENT(workset,sh->fixed);
+	sh = sh->next;
+    }
+
+    k = nextelement(workset,m,-1);
+    if (k < 0)
+	orbits = sh->orbits;
+    else
+    {
+        sh->fixed = k;
+        clearvector(sh->vec,ring,n);
+        sh->vec[k] = ID_PERMNODE;  
+
+        for (sha = sh->next; sha ; sha = sha->next)
+	    clearvector(sha->vec,ring,n);
+    
+	while ((k = nextelement(workset,m,k)) >= 0)
+        {
+	    if (!sh->next) sh->next = newschreier(n);
+	    sh = sh->next;
+	    initschreier(sh,n);
+	    sh->fixed = k;
+	    sh->vec[k] = ID_PERMNODE;
+        }
+	if (!sh->next) sh->next = newschreier(n);
+	sh = sh->next;
+        initschreier(sh,n);
+	sh->fixed = -1;
+
+        if (*ring) expandschreier(gp,ring,n);
+        orbits = sh->orbits;
+    }
+
+    for (k = -1; (k = nextelement(x,m,k)) >= 0; )
+	if (orbits[k] != k) DELELEMENT(x,k);
+}
+
+/************************************************************************/
+
+int
+schreier_gens(permnode *ring)
+/* Returns the number of generators in the ring */
+{
+    int j;
+    permnode *pn;
+
+    if (!ring) j = 0;
+    else for (j = 1, pn = ring->next; pn != ring; pn = pn->next) ++j;
+ 
+    return j;
+}
+
+/************************************************************************/
+
+void
+dumpschreier(FILE *f, schreier *gp, permnode *ring, int n)
+/* Dump the whole schreier structure to file f. */
+{
+    schreier *sh;
+    permnode *pn;
+    int i,j,jj,k;
+
+
+    fprintf(f,"Schreier structure n=%d; ",n);
+
+    jj = -1;
+    for (j = 0, sh = gp; sh; sh = sh->next)
+    {
+	++j;
+	if (sh->fixed < 0 && jj < 0) jj = j;
+    }
+    fprintf(f," levels=%d (%d used); ",j,jj);
+
+    if (!ring) j = 0;
+    else for (j = 1, pn = ring->next; pn != ring; pn = pn->next) ++j;
+    fprintf(f,"gens=%d; ",j);
+
+    for (j = 0, sh = schreier_freelist; sh; sh = sh->next) ++j;
+    for (k = 0, pn = permnode_freelist; pn; pn = pn->next) ++k;
+    fprintf(f,"freelists: %d,%d\n",j,k);
+
+    if (ring)
+    {
+	fprintf(f,"Generators:\n");
+        pn = ring;
+	do
+	{
+	    fprintf(f,"  %03x ref=%lu mk=%d alloc=%d p=",PNCODE(pn),
+			pn->refcount,pn->mark,pn->nalloc);
+	    for (i = 0; i < n; ++i) fprintf(f," %d",pn->p[i]);
+	    fprintf(f,"\n");
+	    pn = pn->next;
+	} while (pn != ring);
+    }
+
+    if (gp)
+    {
+	fprintf(f,"Levels:\n");
+	for (sh = gp; sh; sh = sh->next)
+	{
+	    fprintf(f,"fixed=%2d alloc=%d vec=",sh->fixed,sh->nalloc);
+	    for (i = 0; i < n; ++i)
+	    {
+		if (sh->vec[i] == ID_PERMNODE) fprintf(f," %d=e",i);
+		else if (sh->vec[i])
+		{
+		    k = sh->pwr[i];
+		    j = (sh->vec[i])->p[i];
+		    fprintf(f," %03x",PNCODE(sh->vec[i]));
+		    if (k == 1)
+			fprintf(f,"(%d,%d)",i,j);
+		    else
+		    {
+			fprintf(f,"^%d",k);
+			while (--k >= 1) j = (sh->vec[i])->p[j];
+			fprintf(f,"(%d,%d)",i,j);
+		    }
+		}
+	    }
+	    fprintf(f,"\n  Orb=");
+	    j = 0;
+	    for (i = 0; i < n; ++i)
+	    {
+		fprintf(f," %d",sh->orbits[i]);
+		if (sh->orbits[i] == i) ++j;
+	    }
+	    fprintf(f," [%d]\n",j);
+	    if (sh->fixed < 0) break;
+	}
+    }
+}
+
+/************************************************************************/
+
+void
+grouporder(int *fix, int nfix, schreier *gp, permnode **ring, 
+                           double *grpsize1, int *grpsize2, int n)
+/* process the base like in getorbits(), then return the product of the
+ * orbits along the base, using the largest orbit at the end if the
+ * base is not complete.
+*/
+{
+    schreier *sh;
+    int i,j,k,fx;
+    int *orb;
+
+#if !MAXN
+    DYNALLOC1(int,workperm,workperm_sz,n,"grouporder");
+#endif
+
+    getorbits(fix,nfix,gp,ring,n);
+    expandschreier(gp,ring,n);
+    expandschreier(gp,ring,n);
+    *grpsize1 = 1.0; *grpsize2 = 0;
+
+    for (i = 0, sh = gp; i < nfix; ++i, sh = sh->next)
+    {
+	orb = sh->orbits;
+	fx = orb[sh->fixed];
+	k = 0;
+	for (j = fx; j < n; ++j) if (orb[j] == fx) ++k;
+	MULTIPLY(*grpsize1,*grpsize2,k);
+    }
+
+    orb = sh->orbits;
+    k = 1;
+    for (i = 0; i < n; ++i)
+	if (orb[i] == i)
+	    workperm[i] = 1;
+	else
+	{
+	    ++workperm[orb[i]];
+	    if (workperm[orb[i]] > k) k = workperm[orb[i]];
+	}
+    MULTIPLY(*grpsize1,*grpsize2,k);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  schreier_check() checks that this file is compiled compatibly with the    *
+*  given parameters.   If not, call exit(1).                                 *
+*                                                                            *
+*****************************************************************************/
+
+void
+schreier_check(int wordsize, int m, int n, int version)
+{
+        if (wordsize != WORDSIZE)
+        {
+            fprintf(ERRFILE,"Error: WORDSIZE mismatch in schreier.c\n");
+            exit(1);
+        }
+
+#if MAXN
+        if (m > MAXM)
+        {
+            fprintf(ERRFILE,"Error: MAXM inadequate in schreier.c\n");
+            exit(1);
+        }
+
+        if (n > MAXN)
+        {
+            fprintf(ERRFILE,"Error: MAXN inadequate in schreier.c\n");
+            exit(1);
+        }
+#endif
+
+        if (version < NAUTYREQUIRED)
+        {
+            fprintf(ERRFILE,"Error: schreier.c version mismatch\n");
+            exit(1);
+        }
+}
+
+/************************************************************************/
+
+void
+schreier_freedyn(void)
+{
+#if !MAXN
+    DYNFREE(workperm,workperm_sz);
+    DYNFREE(workperm2,workperm2_sz);
+    DYNFREE(workpermA,workpermA_sz);
+    DYNFREE(workpermB,workpermB_sz);
+    DYNFREE(workset,workset_sz);
+    DYNFREE(workset2,workset2_sz);
+#endif
+    clearfreelists();
+}
diff --git a/lib/nauty/schreier.h b/lib/nauty/schreier.h
new file mode 100644
index 0000000..b53b758
--- /dev/null
+++ b/lib/nauty/schreier.h
@@ -0,0 +1,68 @@
+/* schreier.h - Version 1.2 (January 2013) */
+
+#ifndef  _SCHREIER_H_    /* only process this file once */
+#define  _SCHREIER_H_
+
+#include "nauty.h"
+#include "naurng.h"
+
+typedef struct permnodestruct
+{
+    struct permnodestruct *prev,*next;   /* prev&next in circular list */
+    unsigned long refcount;              /* number of references */
+    int nalloc;                          /* size of p[] in ints,
+                                            <= 0 for a perm marker */
+    int mark;                            /* a mark, 0 unless changed */
+    int p[2];                            /* actual vector, extended to
+                                            nalloc enties */
+} permnode;
+
+typedef struct schreierlevel
+{
+    struct schreierlevel *next;    /* down one level, if any */
+    int fixed;                     /* fixed at next level, -1 if none */
+                	/* Invariant: next=NULL => fixed = -1 */
+    int nalloc;                    /* size of vec[] and orbits[] */
+    permnode **vec;                /* vec[i]^pwr[i] is edge label, */
+    int *pwr;                      /*  transitive closure maps i->fixed */
+    int *orbits;                   /* vector of orbits */
+    permnode *marker;              /* points to marker for this level */
+} schreier;
+
+#define SCHREIERFAILS 10 
+  /* Default number of Schreier failures before giving up. */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* See separate file schreier.txt for a description of usage. */
+
+extern void freeschreier(schreier **gp, permnode **gens);
+extern void addpermutation(permnode **ring, int *p, int n); 
+extern permnode *findpermutation(permnode *gens, int *p, int n);
+extern boolean addgenerator(schreier **gp, permnode **gens, int *p, int n);
+extern boolean
+	condaddgenerator(schreier **gp, permnode **gens, int *p, int n);
+extern boolean expandschreier(schreier *gp, permnode **gens, int n);
+extern int *getorbits(int *fix, int nfix,
+		 schreier *gp, permnode **gens, int n);
+extern int getorbitsmin(int *fix, int nfix, schreier *gp, permnode **gens,
+		 int **orbits, int *cell, int ncell, int n, boolean changed);
+extern void pruneset(set *fixset, schreier *gp, permnode **gens,
+		      set *x, int m, int n);
+extern void newgroup(schreier **gp, permnode **gens, int n);
+extern void schreier_freedyn(void);
+extern int schreier_fails(int nfails);
+extern void dumpschreier(FILE *f, schreier *gp, permnode *gens, int n);
+extern int schreier_gens(permnode *gens);
+extern void deleteunmarked(permnode **gens);
+extern void grouporder(int *fix, int nfix,  schreier *gp, permnode **gens,
+		double *grpsize1, int *grpsize2, int n);
+extern void schreier_check(int wordsize, int m, int n, int version);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* _SCHREIER_H_ */
diff --git a/lib/nauty/schreier.txt b/lib/nauty/schreier.txt
new file mode 100644
index 0000000..fee021f
--- /dev/null
+++ b/lib/nauty/schreier.txt
@@ -0,0 +1,132 @@
+
+Instructions for using schreier.c - May 12, 2010.
+-------------------------------------------------
+
+Declarations:
+    #include "schreier.h"
+
+    schreier  *gp;    /* This will point to the Schreier structure */
+    permnode  *gens;  /* This will point to the stored generators */
+
+Initialising group:
+
+    newgroup(&gp, &gens, n);
+       - This creates the two structures needed for a trivial group
+         of degree n.  In the case that &gens == NULL, it creates the
+         scheier structure only.  This enables a previous set of 
+         generators to be used to initialise a new group;
+
+Adding a generator p[0..n-1] :
+
+  There are three options:
+
+    addpermutation(&gens, p, n);
+       - This just adds p to the stored generators without updating
+         the Schreier structure.
+
+    addgenerator(&gp, &gens, p, n);
+       - This filters p through the Schreier structure once, adding 
+         either p or an equivalent generator if it is not found to
+         be in the group already. It is possible that the generator
+         can be added even though it is not needed, even if it is
+         identical to a previous generator. It returns a boolean
+         value which is FALSE if p was found to be in the group and
+         useless, otherwise it returns TRUE.
+
+    condaddgenerator(&gp, &gens, p, n);
+       - This is the same as addgenerator() except that it guarantees
+         to never add a generator which is identical to a previous
+         generator.  However, it still might not notice if it is in
+         the group generated by the previous generators.
+
+Updating the Schreier structure:
+
+  At any moment, a partial base is known (initially empty) and some
+  partial Schreier vectors and orbits relative to that partial base.  
+  To make the Schreier vectors and orbits more likely to be complete,
+  you can filter random group elements through it:
+
+    expandschreier(gp, &gens, n);
+        - Filter random elements until schreierfails consecutive
+          failures occur.  Uses the existing partial base and does
+          not attempt to extend it.
+
+    schreier_fails(fails);
+        - Change the value of schreierfails (default 10).  The previous
+          is returned as the function value.
+
+Orbits of stabiliser of partial base fix[0..nfix-1]:
+
+    getorbits(fix, nfix, gp, &gens, n);
+        - If fix[0..nfix-1] is a prefix of the partial base held
+          internally, the existing orbits are returned immediately
+          without changing the Schreier structure.  (Call
+          expandschreier() first if this is not good enough.)
+        - Otherwise, the Schreier structure is modified to use the
+          partial base fix[0..nfix-1], keeping as much information
+          as possible. Then expandschreier() is called and the
+          orbits are returned.
+  The function value points to an int array containing the orbits.
+  The orbits are in nauty format (orbits[i] is the least vertex in
+  the same orbit as vertex i). Since a randomised algorithm is used,
+  correctness is not guaranteed. However, the partition returned is
+  guaranteed to be finer than the true orbits partition.
+
+    getorbitsmin(fix, nfix, gp, &gens, &orbits, cell, ncell, n);
+        - If the basis elements fix[0..nfix-1] are minimal in their
+          orbits, as far as we know, return value nfix and set *orbits
+          to point to orbits fixing fix[0..nfix-1].  If fix[i] is seen
+          to be not minimal for some i <= nfix-1, return i and set
+          *orbits to point to orbits fixing fix[0..i-1]. If the partial
+          base is already known, or fix[0..nfix-1] can already be seen
+          to be non-minimal, do this work without more filtering.
+        - Otherwise, filter until schreierfails failures, or until
+          cell[0..ncell-1] is a subset of an orbit.  This last test
+          is omitted if cell=NULL. 
+          The pointer &orbits remains valid until getorbits() or
+          getorbitsmin() is called with an incompatible base (neither
+          a prefix nor an extension).
+
+  For both getorbits() and getorbitsmin(), the orbits vector whose
+  address is returned MUST NOT BE MODIFIED by the calling program.
+  The pointer will remain valid until getorbits(), getorbitsmin(),
+  pruneset() or grouporder() is called for a base that is neither a
+  prefix nor an extension of this base.  During that time it will
+  contain the orbits of some group (not necessarily the full group)
+  fixing this base.
+
+Finishing:
+
+   deleteunmarked(&gens);
+	- Delete some redundant generators.  Those left are guaranteed
+          to generate the group. This invalidates the Schreier
+          structure, so call freeschreier(&gp, NULL) afterwards.
+
+   freeschreier(&gp, &gens);
+        - Free these two structures.  Do this before using (gp,gens)
+          for another group.
+
+   schreier_freedyn();
+        - Frees all the dynamic memory allocated by the Schreier code.
+          This is optional since the same dynamic memory will be reused
+          if you have a new group. 
+
+Getting information:
+
+    schreier_gens(gens)
+        - Return the number of stored generators.
+
+    grouporder(fix, nfix, gp, &gens, &grpsize1, &grpsize2, n);
+	- Make an estimate of the group size using the base or
+          base-less-one fix[0..nfix-1].  grpsize1 is double and
+          grpsize2 is int, as in nauty.h.  The value returned is
+          the product of the orbit sizes at each level times the
+          largest orbit size at the end.  Correct with some
+          probability.
+
+    dumpschreier(FILE* f, gp, gens, n);
+        - Write to file f a complete description of the structures.
+
+    permnode *findpermutation(permnode *gens, int *p, int n)
+        - return a pointer to the permnode in the circular list which
+          is identical to p, if it exists.  Otherwise return NULL.
diff --git a/lib/nauty/shortg.c b/lib/nauty/shortg.c
new file mode 100644
index 0000000..9a62cb5
--- /dev/null
+++ b/lib/nauty/shortg.c
@@ -0,0 +1,749 @@
+/* shortg.c  version 3.1; B D McKay, July 15 2016. */
+
+#define USAGE \
+  "shortg [-qvkdu] [-i# -I#:# -K#] [-fxxx] [-S|-t] [-Tdir] [infile [outfile]]"
+
+#define HELPTEXT \
+"  Remove isomorphs from a file of graphs.\n\
+\n\
+    If outfile is omitted, it is taken to be the same as infile\n\
+    If both infile and outfile are omitted, input will be taken\n\
+            from stdin and written to stdout\n\
+\n\
+    The output file has a header if and only if the input file does.\n\
+\n\
+    -s  force output to sparse6 format\n\
+    -g  force output to graph6 format\n\
+    -z  force output to digraph6 format\n\
+        If none of -s, -z, -g are given, the output format is determined\n\
+        by the header or, if there is none, by the format of the first\n\
+        input graph. The output format determines the sorting order too.\n\
+        As an exception, digraphs are always written in digraph6 format.\n\
+    -S  Use sparse representation internally. Note that this changes the\n\
+        canonical labelling. \n\
+        Multiple edges are not supported.  One loop per vertex is ok.\n\
+    -t  Use Traces.\n\
+        Note that this changes the canonical labelling.\n\
+        Multiple edges,loops, directed edges are not supported,\n\
+        nor invariants.\n\
+\n\
+    -k  output graphs have the same labelling and format as the inputs.\n\
+        Without -k, output graphs have canonical labelling.\n\
+        -s, -g, -z are ineffective if -k is given.\n\
+\n\
+    -v  write to stderr a list of which input graphs correspond to which\n\
+        output graphs. The input and output graphs are both numbered\n\
+        beginning at 1.  A line like\n\
+           23 : 30 154 78\n\
+        means that inputs 30, 154 and 78 were isomorphic, and produced\n\
+        output 23.\n\
+\n\
+    -d  include in the output only those inputs which are isomorphic\n\
+        to another input.  If -k is specified, all such inputs are\n\
+        included in their original labelling.  Without -k, only one\n\
+        member of each nontrivial isomorphism class is written,\n\
+        with canonical labelling.\n\
+\n\
+    -fxxx  Specify a partition of the point set.  xxx is any\n\
+        string of ASCII characters except nul.  This string is\n\
+        considered extended to infinity on the right with the\n\
+        character 'z'.  One character is associated with each point,\n\
+        in the order given.  The labelling used obeys these rules:\n\
+         (1) the new order of the points is such that the associated\n\
+        characters are in ASCII ascending order\n\
+         (2) if two graphs are labelled using the same string xxx,\n\
+        the output graphs are identical iff there is an\n\
+        associated-character-preserving isomorphism between them.\n\
+    -i#  select an invariant (1 = twopaths, 2 = adjtriang(K), 3 = triples,\n\
+        4 = quadruples, 5 = celltrips, 6 = cellquads, 7 = cellquins,\n\
+        8 = distances(K), 9 = indsets(K), 10 = cliques(K), 11 = cellcliq(K),\n\
+       12 = cellind(K), 13 = adjacencies, 14 = cellfano, 15 = cellfano2,\n\
+       16 = refinvar(K))\n\
+    -I#:#  select mininvarlevel and maxinvarlevel (default 1:1)\n\
+    -K#   select invararg (default 3)\n\
+\n\
+    -u  Write no output, just report how many graphs it would have output.\n\
+        In this case, outfile is not permitted.\n\
+    -Tdir  Specify that directory \"dir\" will be used for temporary disk\n\
+        space by the sort subprocess.  The default is usually /tmp.\n\
+    -q  Suppress auxiliary output\n"
+
+
+/*************************************************************************/
+
+#include "gtools.h" 
+#include "nautinv.h"
+#include "gutils.h"
+#include "traces.h"
+
+#if (HAVE_PIPE==0) || (HAVE_WAIT==0) || (HAVE_FORK==0)
+ #error Forget it, either pipe(), wait() or fork() are not available
+#endif
+
+#if !HAVE_PID_T
+typedef int pid_t;
+#endif
+
+#if !FDOPEN_DEC
+FILE *fdopen(int, const char*);
+#endif
+
+#if SORT_NEWKEY == 0
+#define SORTCOMMAND  SORTPROG,SORTPROG,"-u","+0","-1"
+#define VSORTCOMMAND1  SORTPROG,SORTPROG
+#define VSORTCOMMAND2  SORTPROG,SORTPROG,"+0","-1","+2"
+
+#define SORTCOMMANDT  SORTPROG,SORTPROG,"-T",tempdir,"-u","+0","-1"
+#define VSORTCOMMANDT1  SORTPROG,SORTPROG,"-T",tempdir
+#define VSORTCOMMANDT2  SORTPROG,SORTPROG,"-T",tempdir,"+0","-1","+2"
+#else
+#define SORTCOMMAND  SORTPROG,SORTPROG,"-u","-k","1,1"
+#define VSORTCOMMAND1  SORTPROG,SORTPROG
+#define VSORTCOMMAND2  SORTPROG,SORTPROG,"-k","1,1","-k","3"
+
+#define SORTCOMMANDT  SORTPROG,SORTPROG,"-T",tempdir,"-u","-k","1,1"
+#define VSORTCOMMANDT1  SORTPROG,SORTPROG,"-T",tempdir
+#define VSORTCOMMANDT2  SORTPROG,SORTPROG,"-T",tempdir,"-k","1,1","-k","3"
+#endif
+
+static struct invarrec
+{
+    void (*entrypoint)(graph*,int*,int*,int,int,int,int*,
+                      int,boolean,int,int);
+    void (*entrypoint_sg)(graph*,int*,int*,int,int,int,int*,
+                      int,boolean,int,int);
+    char *name;
+} invarproc[]
+    = {{NULL, NULL, "none"},
+       {twopaths,   NULL, "twopaths"},
+       {adjtriang,  NULL, "adjtriang"},
+       {triples,    NULL, "triples"},
+       {quadruples, NULL, "quadruples"},
+       {celltrips,  NULL, "celltrips"},
+       {cellquads,  NULL, "cellquads"},
+       {cellquins,  NULL, "cellquins"},
+       {distances, distances_sg, "distances"},
+       {indsets,    NULL, "indsets"},
+       {cliques,    NULL, "cliques"},
+       {cellcliq,   NULL, "cellcliq"},
+       {cellind,    NULL, "cellind"},
+       {adjacencies, adjacencies_sg, "adjacencies"},
+       {cellfano,   NULL, "cellfano"},
+       {cellfano2,  NULL, "cellfano2"},
+       {refinvar,   NULL, "refinvar"}
+      };
+
+#define NUMINVARS ((int)(sizeof(invarproc)/sizeof(struct invarrec)))
+
+/**************************************************************************/
+
+static pid_t
+beginsort(FILE **sortin, FILE **sortout, char *tempdir,
+          boolean vdswitch, boolean keep)
+/* begin sort process, open streams for i/o to it, and return its pid */
+{
+    int pid;
+    int inpipe[2],outpipe[2];
+
+    if (pipe(inpipe) < 0 || pipe(outpipe) < 0)
+        gt_abort(">E shortg: can't create pipes to sort process\n");
+
+    if ((pid = fork()) < 0) gt_abort(">E shortg: can't fork\n");
+
+    if (pid > 0)            /* parent */
+    {
+        close(inpipe[0]);
+        close(outpipe[1]);
+        if ((*sortin = fdopen(inpipe[1],"w")) == NULL)
+            gt_abort(">E shortg: can't open stream to sort process\n");
+        if ((*sortout = fdopen(outpipe[0],"r")) == NULL)
+            gt_abort(">E shortg: can't open stream from sort process\n");
+    }
+    else                   /* child */
+    {
+        SET_C_COLLATION;
+
+        close(inpipe[1]);
+        close(outpipe[0]);
+        if (dup2(inpipe[0],0) < 0 || dup2(outpipe[1],1) < 0)
+            gt_abort(">E shortg: dup2 failed\n");
+
+        if (tempdir == NULL)
+        {
+            if (vdswitch)
+                if (keep) execlp(VSORTCOMMAND2,NULL);
+                else      execlp(VSORTCOMMAND1,NULL);
+            else
+                execlp(SORTCOMMAND,NULL);
+        }
+        else
+        {
+            if (vdswitch)
+                if (keep) execlp(VSORTCOMMANDT2,NULL);
+                else      execlp(VSORTCOMMANDT1,NULL);
+            else
+                execlp(SORTCOMMANDT,NULL);
+        }
+        gt_abort(">E shortg: can't start sort process\n");
+    }
+
+    return pid;
+}
+
+/**************************************************************************/
+
+static void
+tosort(FILE *f, char *cdstr, char *dstr, nauty_counter index)
+/* write one graph to sort process 
+   cdstr = canonical string 
+   dstr = optional original string
+   index = optional index number */
+{
+    int i;
+    char buff[30];
+
+    for (i = 0; cdstr[i] != '\n'; ++i) {}
+    cdstr[i] = '\0';
+    writeline(f,cdstr);
+
+    if (dstr != NULL)
+    {
+        writeline(f," ");
+        for (i = 0; dstr[i] != '\n'; ++i) {}
+        dstr[i] = '\0';
+        writeline(f,dstr);
+    }
+
+    if (index > 0)
+    {
+#if LONG_LONG_COUNTERS
+        sprintf(buff,"\t%11llu\n",index);
+#else
+        sprintf(buff,"\t%10lu\n",index);
+#endif
+        writeline(f,buff);
+    }
+    else
+        writeline(f,"\n");
+}
+
+/**************************************************************************/
+
+static boolean
+fromsort(FILE *f, char **cdstr, char **dstr, nauty_counter *index)
+/* read one graph from sort process */
+{
+    int j;
+    char *s;
+
+    if ((s = gtools_getline(f)) == NULL) return FALSE;
+
+    *cdstr = s;
+    for (j = 0; s[j] != ' ' && s[j] != '\t' && s[j] != '\n'; ++j) {}
+
+    if (s[j] == ' ')
+    {
+        s[j] = '\0';
+        *dstr = &s[j+1];
+        for (++j; s[j] != '\t' && s[j] != '\n'; ++j) {}
+    }
+    else
+        *dstr = NULL;
+
+    if (s[j] == '\t')
+    {
+#if LONG_LONG_COUNTERS
+        if (sscanf(&s[j+1],"%llu",index) != 1)
+#else
+        if (sscanf(&s[j+1],"%lu",index) != 1)
+#endif
+            gt_abort(">E shortg: index field corrupted\n");
+    }
+    else
+        *index = 0;
+    s[j] = '\0';
+
+    return TRUE;
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    char *infilename,*outfilename;
+    FILE *infile,*outfile;
+    FILE *sortin,*sortout;
+    int status,loops;
+    char *dstr,*cdstr,*prevdstr,*prevcdstr;
+    char sw,*fmt;
+    boolean badargs,quiet,vswitch,dswitch,kswitch,format,uswitch;
+    boolean iswitch,Iswitch,Kswitch,Tswitch;
+    boolean zswitch,sswitch,gswitch,Sswitch,tswitch;
+    boolean digraph;
+    nauty_counter numread,prevnumread,numwritten,classsize;
+    int m,n,i,ii,argnum,line;
+    int outcode,codetype;
+    int inv,mininvarlevel,maxinvarlevel,invararg;
+    long minil,maxil;
+    pid_t sortpid;
+    graph *g;
+    char *arg,*tempdir;
+    sparsegraph sg,sh;
+    DEFAULTOPTIONS_TRACES(traces_opts);
+    TracesStats traces_stats;
+#if MAXN
+    graph h[MAXN*MAXM];
+    int lab[MAXN],ptn[MAXN],orbits[MAXN];
+#else
+    DYNALLSTAT(graph,h,h_sz);
+    DYNALLSTAT(int,lab,lab_sz);
+    DYNALLSTAT(int,ptn,ptn_sz);
+    DYNALLSTAT(int,orbits,orbits_sz);
+#endif
+
+    HELP; PUTVERSION;
+
+    nauty_check(WORDSIZE,1,1,NAUTYVERSIONID);
+
+    infilename = outfilename = NULL;
+    dswitch = format = quiet = vswitch = kswitch = uswitch = FALSE;
+    zswitch = sswitch = gswitch = Sswitch = Tswitch = FALSE;
+    tswitch = iswitch = Iswitch = Kswitch = FALSE;
+    tempdir = NULL;
+    inv = 0;
+
+     /* parse argument list */
+
+    argnum = 0;
+    badargs = FALSE;
+
+    for (i = 1; !badargs && i < argc; ++i)
+    {
+        arg = argv[i];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('q',quiet)
+                else SWBOOLEAN('v',vswitch)
+                else SWBOOLEAN('k',kswitch)
+                else SWBOOLEAN('d',dswitch)
+                else SWBOOLEAN('u',uswitch)
+                else SWBOOLEAN('s',sswitch)
+                else SWBOOLEAN('g',gswitch)
+                else SWBOOLEAN('z',zswitch)
+                else SWBOOLEAN('S',Sswitch)
+                else SWBOOLEAN('t',tswitch)
+                else SWINT('i',iswitch,inv,"shortg -i")
+                else SWINT('K',Kswitch,invararg,"shortg -K")
+                else SWRANGE('I',":-",Iswitch,minil,maxil,"shortg -I")
+                else if (sw == 'f')
+                {
+                    format = TRUE;
+                    fmt = arg;
+                    break;
+                }
+                else if (sw == 'T')
+                {
+                    Tswitch = TRUE;
+                    tempdir = arg;
+                    break;
+                }
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if (iswitch && inv == 0) iswitch = FALSE;
+
+    if (strcmp(SORTPROG,"no_sort_found") == 0)
+        gt_abort(">E shortg: no sort program known\n");
+    if (uswitch && outfilename != NULL)
+        gt_abort(">E shortg: -u and outfile are incompatible\n");
+    if ((sswitch!=0) + (gswitch!=0) + (zswitch!=0) + (kswitch!=0) > 1)
+        gt_abort(">E shortg: -sgzk are incompatible\n");
+    if (Tswitch && *tempdir == '\0')
+        gt_abort(">E shortg: -T needs a non-empty argument\n");
+    if (tswitch && (format || Sswitch))
+        gt_abort(">E shortg: -t is incompatible with -S and -f \n");
+    if (iswitch && (inv > 16))
+        gt_abort(">E shortg: -i value must be 0..16\n");
+    if (Sswitch && iswitch && invarproc[inv].entrypoint_sg == NULL)
+        gt_abort(
+          ">E shortg: that invariant is not available in sparse mode\n");
+
+    if (argnum == 1 && !uswitch) outfilename = infilename;
+
+    if (iswitch)
+    {
+        if (Iswitch)
+        {
+            mininvarlevel = minil;
+            maxinvarlevel = maxil;
+        }
+        else
+            mininvarlevel = maxinvarlevel = 1;
+        if (!Kswitch) invararg = 3;
+    }
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if (!quiet)
+    {
+        fprintf(stderr,">A shortg");
+        if (uswitch || kswitch || vswitch || format || Tswitch || zswitch
+                  || tswitch  || sswitch || gswitch || Sswitch || iswitch)
+        fprintf(stderr," -");
+        if (sswitch) fprintf(stderr,"s");
+        if (gswitch) fprintf(stderr,"g");
+        if (zswitch) fprintf(stderr,"z");
+        if (Sswitch) fprintf(stderr,"S");
+        if (tswitch) fprintf(stderr,"t");
+        if (kswitch) fprintf(stderr,"k");
+        if (vswitch) fprintf(stderr,"v");
+        if (dswitch) fprintf(stderr,"d");
+        if (uswitch) fprintf(stderr,"u");
+        if (iswitch)
+            fprintf(stderr,"i=%s[%d:%d,%d]",invarproc[inv].name,
+                    mininvarlevel,maxinvarlevel,invararg);
+        if (format) fprintf(stderr,"f%s",fmt);
+        if (format && Tswitch) fprintf(stderr," -");
+        if (Tswitch) fprintf(stderr,"T%s",tempdir);
+        if (argnum > 0) fprintf(stderr," %s",infilename);
+        if (argnum > 1) fprintf(stderr," %s",outfilename);
+        fprintf(stderr,"\n");
+    }
+
+     /* open input file */
+
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,FALSE,1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    if (gswitch)      outcode = GRAPH6;
+    else if (sswitch) outcode = SPARSE6;
+    else if (zswitch) outcode = DIGRAPH6;
+    else if ((codetype&GRAPH6))   outcode = GRAPH6;
+    else if ((codetype&SPARSE6))  outcode = SPARSE6;
+    else if ((codetype&DIGRAPH6)) outcode = DIGRAPH6;
+    else
+    {
+        outcode = GRAPH6;
+        fprintf(stderr,
+             ">W shortg doesn't handle this graph format, writing graph6.\n");
+    }
+
+    if (sswitch || (!gswitch && (codetype&SPARSE6))) outcode = SPARSE6;
+    else                                             outcode = GRAPH6;
+
+#if defined(SIG_IGN) && defined(SIGPIPE)
+    signal(SIGPIPE,SIG_IGN);        /* process pipe errors ourselves */
+#endif
+
+     /* begin sort in a subprocess */
+
+    sortpid = beginsort(&sortin,&sortout,(Tswitch?tempdir:NULL),
+                                            dswitch||vswitch,kswitch);
+
+  /* feed input graphs, possibly relabelled, to sort process */
+
+    numread = 0;
+
+    if (Sswitch)
+    {
+	SG_INIT(sg);
+	SG_INIT(sh);
+        while (TRUE)
+        {
+	    if (read_sgg_loops(infile,&sg,&loops,&digraph) == NULL) break;
+            dstr = readg_line;
+            ++numread;
+	    n = sg.nv;
+#if MAXN
+	    if (n > MAXN) gt_abort(">E shortg: graph larger than MAXN read\n");
+#endif
+            m = SETWORDSNEEDED(n);
+            SG_ALLOC(sh,n,sg.nde,"shortg");
+            fcanonise_inv_sg(&sg,m,n,&sh,format?fmt:NULL,
+		invarproc[inv].entrypoint_sg,
+                mininvarlevel,maxinvarlevel,invararg,loops>0||digraph);
+            sortlists_sg(&sh);
+	    if (outcode == DIGRAPH6 || digraph) cdstr = sgtod6(&sh);
+            else if (outcode == SPARSE6)        cdstr = sgtos6(&sh);
+            else                                cdstr = sgtog6(&sh);
+
+            tosort(sortin,cdstr,kswitch ? dstr : NULL,vswitch ? numread : 0);
+        }
+    }
+    else if (tswitch)
+    {   
+        SG_INIT(sg);
+        SG_INIT(sh);
+        traces_opts.getcanon = TRUE;
+        traces_opts.writeautoms = FALSE;
+        traces_opts.verbosity = 0;
+        traces_opts.outfile = stdout;
+
+        while (TRUE)
+        {   
+            if (read_sgg_loops(infile,&sg,&loops,&digraph) == NULL) break;
+            if (loops > 0) gt_abort(
+               ">E shortg: Traces does not allow loops or directed edges\n");
+            ++numread;
+            n = sg.nv;
+#if MAXN
+	    if (n > MAXN) gt_abort(">E shortg: graph larger than MAXN read\n");
+#endif
+            DYNALLOC1(int,lab,lab_sz,n,"traces@shortg");
+            DYNALLOC1(int,ptn,ptn_sz,n,"traces@shortg");
+            DYNALLOC1(int,orbits,orbits_sz,n,"traces@shortg");
+            SG_ALLOC(sh,n,sg.nde,"labelg");
+            for (ii = 0; ii < n; ++ii) { lab[ii] = ii; ptn[ii] = 1; }
+            ptn[n-1] = 0;
+            Traces(&sg,lab,ptn,orbits,&traces_opts,&traces_stats,&sh);
+            sortlists_sg(&sh);
+	    if (outcode == DIGRAPH6 || digraph) cdstr = sgtod6(&sh);
+            else if (outcode == SPARSE6)        cdstr = sgtos6(&sh);
+            else                                cdstr = sgtog6(&sh);
+	    tosort(sortin,cdstr,kswitch ? dstr : NULL,vswitch ? numread : 0);
+        }
+    }
+    else
+    {
+        while (TRUE)
+        {
+            if ((g = readgg(infile,NULL,0,&m,&n,&digraph)) == NULL) break;
+            dstr = readg_line;
+            ++numread;
+            loops = loopcount(g,m,n);
+#if !MAXN
+            DYNALLOC2(graph,h,h_sz,n,m,"shortg");
+#endif
+            fcanonise_inv(g,m,n,h,format?fmt:NULL,
+                invarproc[inv].entrypoint,mininvarlevel,maxinvarlevel,
+                invararg, loops>0||digraph);
+	    if (outcode == DIGRAPH6 || digraph) cdstr = ntod6(h,m,n);
+            else if (outcode == SPARSE6)        cdstr = ntos6(h,m,n);
+            else                                cdstr = ntog6(h,m,n);
+
+            tosort(sortin,cdstr,kswitch ? dstr : NULL,vswitch ? numread : 0);
+            FREES(g);
+        }
+    }
+    fclose(sortin);
+    fclose(infile);
+
+     /* open output file */
+
+    if (uswitch)
+        outfilename = "<none>";
+    else if (outfilename == NULL || outfilename[0] == '-' || is_pipe)
+    {
+        outfile = stdout;
+        outfilename = "stdout";
+    }
+    else
+    {
+        if ((outfile = fopen(outfilename,"w")) == NULL)
+        {
+            fprintf(stderr,
+                ">E shortg: can't open %s for writing\n",outfilename);
+            gt_abort(NULL);
+        }
+    }
+
+    if (!uswitch && (codetype&HAS_HEADER))
+    {
+        if (outcode == SPARSE6) writeline(outfile,SPARSE6_HEADER);
+        else                    writeline(outfile,GRAPH6_HEADER);
+    }
+
+    if (!quiet)
+        fprintf(stderr,">Z " COUNTER_FMT " graphs read from %s\n",
+                numread,infilename);
+
+     /* collect output from sort process and write to output file */
+
+    prevcdstr = prevdstr = NULL;
+    numwritten = 0;
+    if (dswitch)
+    {
+        classsize = 0;
+        while (fromsort(sortout,&cdstr,&dstr,&numread))
+        {
+            if (classsize == 0 || strcmp(cdstr,prevcdstr) != 0)
+                classsize = 1;
+            else
+            {
+                ++classsize;
+                if (classsize == 2)
+                {
+                    ++numwritten;
+                    if (!uswitch)
+                    {
+                        writeline(outfile,kswitch ? prevdstr : prevcdstr);
+                        writeline(outfile,"\n");
+                    }
+                    if (kswitch)
+                    {
+                        ++numwritten;
+                        if (!uswitch)
+                        {
+                            writeline(outfile,kswitch ? dstr : cdstr);
+                            writeline(outfile,"\n");
+                        }
+                    }
+                    if (vswitch)
+                    {
+                        fprintf(stderr,"\n");
+#if LONG_LONG_COUNTERS
+                        fprintf(stderr,"%3llu : %3llu %3llu",
+                            numwritten,prevnumread,numread);
+#else
+                        fprintf(stderr,"%3lu : %3lu %3lu",
+                            numwritten,prevnumread,numread);
+#endif
+                        line = 1;
+                    }
+                }
+                else
+                {
+                    if (kswitch)
+                    {
+                        ++numwritten;
+                        if (!uswitch)
+                        {
+                            writeline(outfile,kswitch ? dstr : cdstr);
+                            writeline(outfile,"\n");
+                        }
+                    }
+                    if (vswitch)
+                    {
+                        if (line == 15)
+                        {
+                            line = 0;
+                            fprintf(stderr,"\n     ");
+                        }
+#if LONG_LONG_COUNTERS
+                        fprintf(stderr," %3llu",numread);
+#else
+                        fprintf(stderr," %3lu",numread);
+#endif
+                        ++line;
+                    }
+                }
+            }
+            if (prevcdstr) FREES(prevcdstr);
+            prevcdstr = stringcopy(cdstr);
+            if (prevdstr) FREES(prevdstr);
+            if (kswitch) prevdstr = stringcopy(dstr);
+            prevnumread = numread;
+        }
+        if (vswitch) fprintf(stderr,"\n\n");
+    }
+    else if (vswitch)
+    {
+        while (fromsort(sortout,&cdstr,&dstr,&numread))
+        {
+            if (numwritten == 0 || strcmp(cdstr,prevcdstr) != 0)
+            {
+                ++numwritten;
+                if (!uswitch)
+                {
+                    writeline(outfile,kswitch ? dstr : cdstr);
+                    writeline(outfile,"\n");
+                }
+                fprintf(stderr,"\n");
+#if LONG_LONG_COUNTERS
+                fprintf(stderr,"%3llu : %3llu",numwritten,numread);
+#else
+                fprintf(stderr,"%3lu : %3lu",numwritten,numread);
+#endif
+                line = 1;
+            }
+            else
+            {
+                if (line == 15)
+                {
+                    line = 0;
+                    fprintf(stderr,"\n     ");
+                }
+#if LONG_LONG_COUNTERS
+                fprintf(stderr," %3llu",numread);
+#else
+                fprintf(stderr," %3lu",numread);
+#endif
+                ++line;
+            }
+            if (prevcdstr) FREES(prevcdstr);
+            prevcdstr = stringcopy(cdstr);
+        }
+        fprintf(stderr,"\n\n");
+    }
+    else
+    {
+        while (fromsort(sortout,&cdstr,&dstr,&numread))
+        {
+            ++numwritten;
+            if (!uswitch)
+            {
+                writeline(outfile,kswitch ? dstr : cdstr);
+                writeline(outfile,"\n");
+            }
+        }
+    }
+
+    fclose(sortout);
+    if (!uswitch) fclose(outfile);
+
+    if (!quiet)
+    {
+        if (uswitch)
+            fprintf(stderr,">Z " COUNTER_FMT " graphs produced\n",numwritten);
+        else
+            fprintf(stderr,
+                  ">Z " COUNTER_FMT " graphs written to %s\n",numwritten,outfilename);
+    }
+
+     /* check that the subprocess exitted properly */
+
+    while (wait(&status) != sortpid) {}
+
+#if (defined(WIFSIGNALED) || defined(WTERMSIG)) && defined(WEXITSTATUS)
+#ifdef WIFSIGNALED
+    if (WIFSIGNALED(status) && WTERMSIG(status) != 0)
+#else
+    if (WTERMSIG(status) != 0)
+#endif
+    {
+        fprintf(stderr,">E shortg: sort process killed (signal %d)\n",
+                      WTERMSIG(status)); 
+        gt_abort(NULL);
+    }   
+    else if (WEXITSTATUS(status) != 0)
+    {
+        fprintf(stderr,
+                ">E shortg: sort process exited abnormally (code %d)\n",
+                WEXITSTATUS(status));
+        gt_abort(NULL);
+    }
+#endif
+
+    exit(0);
+}
diff --git a/lib/nauty/showg.c b/lib/nauty/showg.c
new file mode 100644
index 0000000..a924a9d
--- /dev/null
+++ b/lib/nauty/showg.c
@@ -0,0 +1,1238 @@
+/* showg.c  version 2.1; B D McKay, August 2017.
+   Formerly called readg.c.
+ 
+   This is a stand-alone edition of listg.c that does not
+   need nauty or any other files.  Use listg in preference
+   if you have installed it.  */
+
+#define USAGE "showg [-p#:#l#o#Ftq] [-a|-A|-c|-d|-e] [infile [outfile]]"
+
+#define HELPTEXT \
+" Write graphs in human-readable format.\n\
+\n\
+   infile is the input file in graph6, sparse6 or digraph6 format\n\
+     This program does not support incremental sparse6 files; use listg.\n\
+   outfile is the output file\n\
+   Defaults are standard input and standard output.\n\
+\n\
+    -p#, -p#:#, -p#-# : only display one graph or a sequence of\n\
+          graphs.  The first graph is number 1.  A second number\n\
+          which is empty or zero means infinity.\n\
+\n\
+    -a  : write the adjacency matrix\n\
+    -A  : same as -a with a space between entries\n\
+    -d  : write output to satisfy dreadnaut\n\
+    -c  : write compact dreadnaut form with minimal line-breaks\n\
+    -e  : write a list of edges, preceded by the order and the\n\
+          number of edges\n\
+\n\
+    -o# : specify number of first vertex (default is 0)\n\
+    -t  : write upper triangle only (affects -a, -A, -d and default)\n\
+    -F  : write a form-feed after each graph except the last\n\
+    -l# : specify screen width limit (default 78, 0 means no limit)\n\
+          This is not currently implemented with -a or -A.\n\
+    -q  : suppress auxiliary output\n\
+\n\
+    -a, -A, -c, -d and -e are incompatible.\n"
+
+/*
+ Version 1.1: Fixed sparse6 input for powers of 2.  May 9, 1998.
+ Version 1.3: Declared errno according to ISO C.  August 22, 1998.
+ Version 1.4: Change name of getline() so that broken compilers
+                which define the GNU function without being asked
+                don't cause a conflict.   June 16, 2006.
+ Version 1.5: Use function prototypes.  Avoid errno.  Sep 19, 2007.
+ Version 1.6: Very minor tweaks.  Hope you all have string.h. Sep 6, 2009.
+ Version 1.7: Make it work for n=0. Sep 18, 2013.
+ Version 2.0: Support digraph6 format.
+ Version 2.1: Fix digraph6 format and remove limit of 200K or so vertices.
+*/
+
+/*************************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+
+/* gtools.h : General header for gtools programs. */
+
+#ifndef MAXN 
+#define MAXN  0
+#endif
+
+#define BIAS6 63
+#define MAXBYTE 126
+#define SMALLN 62
+#define SMALLISHN 258047
+#define TOPBIT6 32
+#define C6MASK 63
+
+#define SIZELEN(n) ((n)<=SMALLN?1:((n)<=SMALLISHN?4:8))
+        /* length of size code in bytes */
+#define G6BODYLEN(n) \
+   (((size_t)(n)/12)*((size_t)(n)-1) + (((size_t)(n)%12)*((size_t)(n)-1)+11)/12)
+#define G6LEN(n) (SIZELEN(n) + G6BODYLEN(n))
+  /* exact graph6 string length excluding \n\0
+     This twisted expression works up to n=227023 in 32-bit arithmetic
+     and for larger n if size_t has 64 bits.  */
+#define D6BODYLEN(n) \
+   ((n)*(size_t)((n)/6) + (((n)*(size_t)((n)%6)+5)/6))
+#define D6LEN(n) (1 + SIZELEN(n) + D6BODYLEN(n))
+  /* exact digraph6 string length excluding \n\0
+     This twisted expression works up to n=160529 in 32-bit arithmetic
+     and for larger n if size_t has 64 bits.  */
+
+#define B(i) (1 << ((i)-1))
+#define M(i) ((1 << (i))-1)
+
+/* Remove errno: too hard to get portable without configuration
+ * #if defined(__unix) || defined(__unix__) || defined(unix) || \
+    defined(__ppc__)
+#include <errno.h>
+#else
+int errno = 0;
+#endif
+#define ABORT(msg) {if (errno != 0) perror(msg); exit(1);}
+*/
+
+/* extern long ftell(FILE*);   Should be in stdio.h  */
+
+#define GRAPH6_HEADER ">>graph6<<"
+#define SPARSE6_HEADER ">>sparse6<<"
+#define DIGRAPH6_HEADER ">>sparse6<<"
+
+#define GRAPH6         1
+#define SPARSE6        2
+#define DIGRAPH6       4
+#define UNKNOWN_TYPE 256
+#define HAS_HEADER   512
+
+#define ARG_OK 0
+#define ARG_MISSING 1
+#define ARG_TOOBIG 2
+#define ARG_ILLEGAL 3
+
+#define MAXARG 2000000000L
+#define NOLIMIT (MAXARG+1L)
+
+#define SWBOOLEAN(c,boool) if (sw==c) boool=TRUE;
+#define SWINT(c,boool,val,id) if (sw==c) \
+    {boool=TRUE;arg_int(&arg,&val,id);}
+#define SWRANGE(c,boool,val1,val2,id) if (sw==c) \
+    {boool=TRUE;arg_range(&arg,&val1,&val2,id);}
+
+#define FREES free
+#define ALLOCS calloc
+
+#define DYNALLSTAT(type,name,name_sz) static type *name; static size_t name_sz=0
+#define DYNALLOC1(type,name,name_sz,sz,msg) \
+ if ((size_t)(sz) > name_sz) \
+ { if (name_sz) FREES(name); name_sz = (sz); \
+ if ((name=(type*)ALLOCS(sz,sizeof(type))) == NULL) alloc_error(msg);}
+#define DYNALLOC2(type,name,name_sz,sz1,sz2,msg) \
+ if ((size_t)(sz1)*(size_t)(sz2) > name_sz) \
+ { if (name_sz) FREES(name); name_sz = (size_t)(sz1)*(size_t)(sz2); \
+ if ((name=(type*)ALLOCS((sz1),(sz2)*sizeof(type))) == NULL) alloc_error(msg);}
+#define DYNFREE(name,name_sz) if (name_sz) {FREES(name); name_sz = 0;}
+#define DYNREALLOC(type,name,name_sz,sz,msg) \
+ {if ((size_t)(sz) > name_sz) \
+ { if ((name = (type*)realloc(name,(sz)*sizeof(type))) == NULL) \
+      alloc_error(msg); else name_sz = (sz);}}
+
+#define alloc_error gt_abort
+
+#ifdef __STDC__
+#include <stddef.h>
+#include <stdlib.h>
+#else
+#include <sys/types.h>
+extern char *calloc();
+extern char *malloc();
+extern char *realloc();
+#endif
+
+#ifdef __alpha
+typedef unsigned int setword;
+#else
+typedef unsigned long setword;
+#endif
+typedef setword set;
+typedef setword graph;
+typedef int boolean;
+
+static setword bit[32]=
+  {020000000000,010000000000,04000000000,02000000000,
+   01000000000,0400000000,0200000000,0100000000,040000000,
+   020000000,010000000,04000000,02000000,01000000,0400000,
+   0200000,0100000,040000,020000,010000,04000,02000,01000,
+   0400,0200,0100,040,020,010,04,02,01};
+static int leftbit[] =
+  {8,7,6,6,5,5,5,5,4,4,4,4,4,4,4,4,
+   3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
+   2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+   2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static int labelorg = 0;
+
+#define WORDSIZE 32
+#define FIRSTBIT(x) ((x) & 037777600000 ? ((x) & 037700000000 ? \
+                 leftbit[((x)>>24) & 0377] : 8+leftbit[(x)>>16]) \
+                : ((x) & 0177400 ? 16+leftbit[(x)>>8] : 24+leftbit[x]))
+#define BITMASK(x)  (017777777777 >> (x)) /* setword whose rightmost
+  WORDSIZE-x-1 (numbered) bits are 1 and the rest 0 (0 <= x < WORDSIZE) */
+#define TIMESWORDSIZE(w) ((w)<<5)
+#define SETWD(pos) ((pos)>>5)
+#define SETBT(pos) ((pos)&037)
+#define ISELEMENT(setadd,pos)  (((setadd)[SETWD(pos)] & bit[SETBT(pos)]) != 0)
+#define ADDELEMENT(setadd,pos)  ((setadd)[SETWD(pos)] |= bit[SETBT(pos)])
+#define GRAPHROW(g,v,m) ((set*)(g) + (long)(v) * (long)(m))
+
+#define FALSE 0
+#define TRUE  1
+
+/************************************************************************/
+
+#ifndef SEEK_SET
+#define SEEK_SET 0
+#define SEEK_CUR 1
+#define SEEK_END 2
+#endif
+
+#ifndef SEEK_CUR
+#define SEEK_CUR SEEK_CURRENT
+#endif
+
+static long ogf_linelen;
+
+/************************************************************************/
+
+static void
+gt_abort(char *msg)     /* Write message and halt. */
+{
+    if (msg) fprintf(stderr,"%s",msg);
+    exit(1);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  itos(i,s) converts the int i to a nul-terminated decimal character        *
+*  string s.  The value returned is the number of characters excluding       *
+*  the nul.                                                                  *
+*                                                                            *
+*  GLOBALS ACCESSED: NONE                                                    *
+*                                                                            *
+*****************************************************************************/
+
+static int
+itos(int i, char *s)
+{
+    int digit,j,k;
+    char c;
+    int ans;
+
+    if (i < 0)
+    {
+        k = 0;
+        i = -i;
+        j = 1;
+        s[0] = '-';
+    }
+    else
+    {
+        k = -1;
+        j = 0;
+    }
+
+    do
+    {
+        digit = i % 10;
+        i = i / 10;
+        s[++k] = digit + '0';
+    }
+    while (i);
+
+    s[k+1] = '\0';
+    ans = k + 1;
+
+    for (;j < k; ++j, --k)
+    {
+        c = s[j];
+        s[j] = s[k];
+        s[k] = c;
+    }
+
+    return(ans);
+}
+
+/*****************************************************************************
+*                                                                            *
+*  nextelement(set1,m,pos) = the position of the first element in set set1   *
+*  which occupies a position greater than pos.  If no such element exists,   *
+*  the value is -1.  pos can have any value less than n, including negative  *
+*  values.                                                                   *
+*                                                                            *
+*  GLOBALS ACCESSED: none                                                    *
+*                                                                            *
+*****************************************************************************/
+
+static int
+nextelement(set *set1, int m, int pos)
+{
+    setword setwd;
+    int w;
+
+    if (pos < 0)
+    {
+        w = 0;
+        setwd = set1[0];
+    }
+    else
+    {
+        w = SETWD(pos);
+        setwd = set1[w] & BITMASK(SETBT(pos));
+    }
+
+    for (;;)
+    {
+        if (setwd != 0)
+            return(TIMESWORDSIZE(w) + FIRSTBIT(setwd));
+        if (++w == m) return -1;
+        setwd = set1[w];
+    }
+}
+
+/*********************************************************************
+opengraphfile(filename,codetype,assumefixed,position) 
+      opens and positions a file for reading graphs.
+
+  filename = the name of the file to open 
+            (NULL means stdin, assumed already open)
+  codetype   = returns a code for the format.
+            This is a combination of SPARSE6, GRAPH6,
+            UNKNOWN_TYPE and HAS_HEADER.  If a header is
+            present, that overrides the data.  If there is
+            no header, the first graph is examined.
+  assumefixed = nonzero if files other than stdin should be assumed to
+            be seekable and have equal record sizes.
+            Ignored if there is a sparse6 header or the first
+            graph has sparse6 format.
+  position = the number of the record to position to
+            (the first is number 1; 0 and -NOLIMIT also mean
+             to position at start)
+
+  If the file starts with ">", there must be a header, either
+  GRAPH6_HEADER, SPARSE6_HEADER or DIGRAPH6_HEADER.  Otherwise
+  opengraphfile() fails.
+
+  The value returned is a file pointer or NULL.  
+  If assumedfixed is not zero and position > 1, the global variable
+  ogf_linelen is set to the length (including \n) of the length of the 
+  first record.
+
+**********************************************************************/
+
+static FILE*
+opengraphfile(char *filename, int *codetype, int assumefixed, long position)
+{
+    FILE *f;
+    int c,firstc;
+    long i,l,pos,pos1,pos2;
+    boolean bad_header;
+
+    if (filename == NULL)
+        f = stdin;
+    else
+    {
+        f = fopen(filename,"r");
+        if (f == NULL)
+        {
+            fprintf(stderr,">E opengraphfile: can't open %s\n",filename);
+            return NULL;
+        }
+    }
+
+    firstc = c = getc(f);
+    if (c == EOF)
+    {
+        *codetype = GRAPH6;
+        return f;
+    }
+
+    if (c != '>')
+    {
+        *codetype = firstc == ':' ? SPARSE6 : firstc == '&' ? DIGRAPH6 : GRAPH6;
+        ungetc(c,f);
+    }
+    else
+    {
+        bad_header = FALSE;
+        if ((c = getc(f)) == EOF || c != '>')
+            bad_header = TRUE;
+        if (!bad_header &&
+                ((c = getc(f)) == EOF || (c != 'g' && c != 's')))
+            bad_header = TRUE;      
+        if (!bad_header && c == 'g')
+        {
+            if ((c = getc(f)) == EOF || c != 'r' ||
+                (c = getc(f)) == EOF || c != 'a' ||
+                (c = getc(f)) == EOF || c != 'p' ||
+                (c = getc(f)) == EOF || c != 'h' ||
+                (c = getc(f)) == EOF || c != '6' ||
+                (c = getc(f)) == EOF || c != '<' ||
+                (c = getc(f)) == EOF || c != '<')
+                    bad_header = TRUE;
+            else
+                *codetype = GRAPH6 | HAS_HEADER;
+        }
+        else if (!bad_header && c == 'd')
+        {
+            if ((c = getc(f)) == EOF || c != 'i' ||
+                (c = getc(f)) == EOF || c != 'g' ||
+                (c = getc(f)) == EOF || c != 'r' ||
+                (c = getc(f)) == EOF || c != 'a' ||
+                (c = getc(f)) == EOF || c != 'p' ||
+                (c = getc(f)) == EOF || c != 'h' ||
+                (c = getc(f)) == EOF || c != '6' ||
+                (c = getc(f)) == EOF || c != '<' ||
+                (c = getc(f)) == EOF || c != '<')
+                    bad_header = TRUE;
+            else
+                *codetype = DIGRAPH6 | HAS_HEADER;
+        }
+        else if (!bad_header && c == 's')
+        {
+            if ((c = getc(f)) == EOF || c != 'p' ||
+                (c = getc(f)) == EOF || c != 'a' ||
+                (c = getc(f)) == EOF || c != 'r' ||
+                (c = getc(f)) == EOF || c != 's' ||
+                (c = getc(f)) == EOF || c != 'e' ||
+                (c = getc(f)) == EOF || c != '6' ||
+                (c = getc(f)) == EOF || c != '<' ||
+                (c = getc(f)) == EOF || c != '<')
+                    bad_header = TRUE;
+            else
+                *codetype = SPARSE6 | HAS_HEADER;
+        }
+        if (bad_header)
+        {
+            fprintf(stderr,">E opengraphfile: illegal header in %s\n",
+                    filename == NULL ? "stdin" : filename);
+            *codetype = UNKNOWN_TYPE | HAS_HEADER;
+            return NULL;
+        }
+    }
+
+    if (position <= 1) return f;
+
+    if (filename == NULL || !assumefixed || (*codetype&SPARSE6)
+                         || firstc == ':')
+    {
+        l = 1;
+        while ((c = getc(f)) != EOF)
+        {
+            if (c == '\n')
+            {
+                ++l;
+                if (l == position) break;
+            }
+        }
+        if (l == position) return f;
+
+        fprintf(stderr,
+           ">E opengraphfile: can't find line %ld in %s\n",position,
+            filename == NULL ? "stdin" : filename);
+        return NULL;
+    }
+    else
+    {
+        pos1 = ftell(f);
+        if (pos1 < 0)
+        {
+            fprintf(stderr,">E opengraphfile: error on first ftell\n");
+            return NULL;
+        }
+
+        for (i = 1; (c = getc(f)) != EOF && c != '\n'; ++i) {}
+        ogf_linelen = i;
+
+        if (c == EOF)
+        {
+            fprintf(stderr,
+                    ">E opengraphfile: required record no present\n");
+            return NULL;
+        }
+        
+        pos2 = ftell(f);
+        if (pos2 < 0)
+        {
+            fprintf(stderr,">E opengraphfile: error on second ftell\n");
+            return NULL;
+        }
+
+        pos = pos1 + (position-1)*(pos2-pos1);
+        if (fseek(f,pos,SEEK_SET) < 0)
+        {
+            fprintf(stderr,">E opengraphfile: seek failed\n");
+            return NULL;
+        }
+    }
+
+    return f;
+}
+
+/*********************************************************************/
+
+static char*
+showg_getline(FILE *f)     /* read a line with error checking */
+       /* includes \n (if present) and \0.
+    Immediate EOF causes NULL return. */
+{
+    DYNALLSTAT(char,s,s_sz);
+    int c;
+    long i;
+
+    DYNALLOC1(char,s,s_sz,500,"showg_getline");
+
+    i = 0;
+    while ((c = getc(f)) != EOF && c != '\n')
+    {
+        if (i == s_sz-2) DYNREALLOC(char,s,s_sz,s_sz+1000,"showg_getline");
+        s[i++] = c;
+    }
+
+    if (i == 0 && c == EOF) return NULL;
+
+    if (c == '\n') s[i++] = '\n';
+    s[i] = '\0';
+    return s;
+}
+
+/****************************************************************************/
+
+int
+graphsize(char *s)
+/* Get size of graph out of graph6, digraph6 or sparse6 string. */
+{
+    char *p;
+    int n;
+
+    if (s[0] == ':' || s[0] == '&') p = s+1;
+    else                            p = s;
+    n = *p++ - BIAS6;
+
+    if (n > SMALLN)
+    {
+        n = *p++ - BIAS6;
+        if (n > SMALLN)
+        {
+            n = *p++ - BIAS6;
+            n = (n << 6) | (*p++ - BIAS6);
+            n = (n << 6) | (*p++ - BIAS6);
+            n = (n << 6) | (*p++ - BIAS6);
+            n = (n << 6) | (*p++ - BIAS6);
+            n = (n << 6) | (*p++ - BIAS6);
+        }
+        else
+        {
+            n = (n << 6) | (*p++ - BIAS6);
+            n = (n << 6) | (*p++ - BIAS6);
+        }
+    }
+    return n;
+}
+
+/****************************************************************************/
+
+static void
+stringtograph(char *s, graph *g, int m)
+/* Convert string (graph6, digraph6 or sparse6 format) to graph. */
+/* Assumes g is big enough to hold it.   */
+{
+    char *p;
+    int n,i,j,k,v,x,nb,need;
+    size_t ii;
+    set *gi,*gj;
+    boolean done;
+
+    n = graphsize(s);
+    if (n == 0) return;
+
+    p = s + (s[0] == ':' || s[0] == '&') + SIZELEN(n);
+
+    if (TIMESWORDSIZE(m) < n)
+        gt_abort(">E stringtograph: impossible m value\n");
+
+    for (ii = m*(size_t)n; --ii > 0;) g[ii] = 0;
+    g[0] = 0;
+
+    if (s[0] != ':' && s[0] != '&')       /* graph6 format */
+    {
+        k = 1;
+        for (j = 1; j < n; ++j)
+        {
+            gj = GRAPHROW(g,j,m);
+    
+            for (i = 0; i < j; ++i)
+            {
+                if (--k == 0)
+                {
+                    k = 6;
+                    x = *(p++) - BIAS6;
+                }
+        
+                if ((x & TOPBIT6))
+                {
+                    gi = GRAPHROW(g,i,m);
+                    ADDELEMENT(gi,j);
+                    ADDELEMENT(gj,i);
+                }
+                x <<= 1;
+            }
+        }
+    }
+    else if (s[0] == '&')
+    {
+        k = 1;
+        for (i = 0; i < n; ++i)
+        {
+            gi = GRAPHROW(g,i,m);
+    
+            for (j = 0; j < n; ++j)
+            {
+                if (--k == 0)
+                {
+                    k = 6;
+                    x = *(p++) - BIAS6;
+                }
+        
+                if ((x & TOPBIT6))
+                {
+                    ADDELEMENT(gi,j);
+                }
+                x <<= 1;
+            }
+        } 
+    }
+    else    /* sparse6 format */
+    {
+        for (i = n-1, nb = 0; i != 0 ; i >>= 1, ++nb) {}
+
+        k = 0;
+        v = 0;
+	done = FALSE;
+        while (!done)
+        {
+	    if (k == 0)
+	    {
+		x = *(p++);
+		if (x == '\n' || x == '\0')
+		{
+		    done = TRUE; continue;
+		}
+		else
+		{
+		    x -= BIAS6; k = 6;
+		}
+	    }
+	    if ((x & B(k))) ++v;
+	    --k;
+
+	    need = nb;
+	    j = 0;
+	    while (need > 0 && !done)
+	    {
+		if (k == 0)
+		{
+		    x = *(p++);
+		    if (x == '\n' || x == '\0')
+		    {
+		        done = TRUE; continue;
+		    }
+		    else
+		    {
+		       	x -= BIAS6; k = 6;
+		    }
+		}
+		if (need >= k)
+		{
+		    j = (j << k) | (x & M(k));
+		    need -= k; k = 0;
+		}
+		else
+		{
+		    k -= need;
+		    j = (j << need) | ((x >> k) & M(need));
+		    need = 0;
+		}
+	    }
+	    if (done) continue;
+
+	    if (j > v)
+		v = j;
+	    else if (v < n)
+	    {
+		ADDELEMENT(GRAPHROW(g,v,m),j);
+		ADDELEMENT(GRAPHROW(g,j,m),v);
+	    }
+        }
+    }
+}
+
+/***********************************************************************/
+
+graph*                 /* read graph into nauty format */
+readgg(FILE *f, graph *g, int reqm, int *pm, int *pn, boolean *digraph) 
+/* graph6, digraph6 and sparse6 formats are supported 
+   f = an open file 
+   g = place to put the answer (NULL for dynamic allocation) 
+   reqm = the requested value of m (0 => compute from n) 
+   *pm = the actual value of m 
+   *pn = the value of n 
+   *digraph = whether the input is a digraph
+*/
+{
+    char *s,*p;
+    int m,n;
+    int readg_code;
+
+    if ((s = showg_getline(f)) == NULL) return NULL;
+
+    if (s[0] == ':')
+    {
+        *digraph = FALSE;
+        p = s + 1;
+    }
+    else if (s[0] == '&')
+    {
+	readg_code = DIGRAPH6;
+        *digraph = TRUE;
+	p = s + 1;
+    }
+    else
+    {
+        readg_code = GRAPH6;
+        *digraph = FALSE;
+        p = s;
+    }
+
+    while (*p >= BIAS6 && *p <= MAXBYTE) 
+        ++p;
+    if (*p == '\0')
+        gt_abort(">E readgg: missing newline\n");
+    else if (*p != '\n')
+        gt_abort(">E readgg: illegal character\n");
+
+    n = graphsize(s);
+    if (readg_code == GRAPH6 && p - s != G6LEN(n))
+        gt_abort(">E readgg: truncated graph6 line\n");
+    if (readg_code == DIGRAPH6 && p - s != D6LEN(n))
+        gt_abort(">E readgg: truncated digraph6 line\n");
+
+    if (reqm > 0 && TIMESWORDSIZE(reqm) < n)
+        gt_abort(">E readgg: reqm too small\n");
+    else if (reqm > 0)
+        m = reqm;
+    else
+        m = (n + WORDSIZE - 1) / WORDSIZE;
+
+    if (g == NULL)
+    {
+        if ((g = (graph*)ALLOCS(n,m*sizeof(graph))) == NULL)
+            gt_abort(">E readgg: malloc failed\n");
+    }
+
+    *pn = n;
+    *pm = m;
+
+    stringtograph(s,g,m);
+    return g;
+}
+
+
+/**************************************************************************/
+
+static int
+longvalue(char **ps, long *l)
+{
+    boolean neg,pos;
+    long sofar,last;
+    char *s;
+
+    s = *ps;
+    pos = neg = FALSE;
+    if (*s == '-')
+    {
+        neg = TRUE;
+        ++s;
+    }
+    else if (*s == '+')
+    {
+        pos = TRUE;
+        ++s;
+    }
+
+    if (*s < '0' || *s > '9') 
+    {
+        *ps = s;
+        return (pos || neg) ? ARG_ILLEGAL : ARG_MISSING;
+    }
+
+    sofar = 0;
+
+    for (; *s >= '0' && *s <= '9'; ++s)
+    {
+        last = sofar;
+        sofar = sofar * 10 + (*s - '0');
+        if (sofar < last || sofar > MAXARG)
+        {
+            *ps = s;
+            return ARG_TOOBIG;
+        }
+    }
+    *ps = s;
+    *l = neg ? -sofar : sofar;
+    return ARG_OK;
+}
+    
+/*************************************************************************/
+
+static void
+arg_int(char **ps, int *val, char *id)
+{
+    int code;
+    long longval;
+
+    code = longvalue(ps,&longval);
+    *val = longval;
+    if (code == ARG_MISSING || code == ARG_ILLEGAL)
+    {
+        fprintf(stderr,">E %s: missing argument value\n",id);
+        gt_abort(NULL);
+    }
+    else if (code == ARG_TOOBIG || *val != longval)
+    {
+        fprintf(stderr,">E %s: argument value too large\n",id);
+        gt_abort(NULL);
+    }
+}
+
+/************************************************************************/
+
+static void
+arg_range(char **ps, long *val1, long *val2, char *id)
+{
+    int code;
+    char *s;
+
+    s = *ps;
+    code = longvalue(&s,val1);
+    if (code != ARG_MISSING)
+    {
+        if (code == ARG_ILLEGAL)
+        {
+            fprintf(stderr,">E %s: bad range\n",id);
+            gt_abort(NULL);
+        }
+        else if (code == ARG_TOOBIG)
+        {
+            fprintf(stderr,">E %s: value too big\n",id);
+            gt_abort(NULL);
+        }
+    }
+    else if (*s != ':' && *s != '-')
+    {
+        fprintf(stderr,">E %s: missing value\n",id);
+        gt_abort(NULL);
+    }
+    else
+        *val1 = -NOLIMIT;
+
+    if (*s == ':' || *s == '-')
+    {
+        ++s;
+        code = longvalue(&s,val2);
+        if (code == ARG_MISSING)
+            *val2 = NOLIMIT;
+        else if (code == ARG_TOOBIG)
+        {
+            fprintf(stderr,">E %s: value too big\n",id);
+            gt_abort(NULL);
+        }
+        else if (code == ARG_ILLEGAL)
+        {
+            fprintf(stderr,">E %s: illegal range\n",id);
+            gt_abort(NULL);
+        }
+    }
+    else
+        *val2 = *val1;
+
+    *ps = s;
+}
+
+/************************************************************************/
+
+#define LABELORG 0   /* number of first vertex (any integer >= 0) */
+#define LINELEN 78   /* max characters per line (0 = no limit) */
+
+static FILE *infile,*outfile;
+static long nin;
+
+/*****************************************************************************
+*                                                                            *
+*  putsetx(f,set1,curlenp,linelength,m,compress,start)   writes the set      *
+*  set1 to file f using at most linelength characters per line (excluding    *
+*  '\n').   Set elements less than or equal to start are ignored.            *
+*  *curlenp is the number of characters on the line so far; it is updated.   *
+*  A range j1,j1+1,...,j2 for j2-j1>=2 is written as "j1:j2" if compress     *
+*  is nonzero (eg. TRUE); otherwise each element is written separately.      *
+*  No final '\n' is written.  labelorg is used.                              *
+*                                                                            *
+*  FUNCTIONS CALLED: nextelement(),itos()                                    *
+*                                                                            *
+*****************************************************************************/
+
+static void
+putsetx(FILE *f, set *set1, int *curlenp, int linelength, int m,
+    boolean compress, int start)
+{
+    int slen,j1,j2;
+    char s[40];
+    boolean first;
+
+    first = TRUE;
+    j1 = start;
+    while ((j1 = nextelement(set1,m,j1)) >= 0)
+    {
+        j2 = j1;
+        if (compress)
+        {
+            while (nextelement(set1,m,j2) == j2 + 1)
+                ++j2;
+            if (j2 == j1+1)
+                j2 = j1;
+        }
+        slen = itos(j1 + labelorg,s);
+        if (j2 >= j1 + 2)
+        {
+            s[slen] = ':';
+            slen += 1 + itos(j2 + labelorg,&s[slen+1]);
+        }
+
+        if (*curlenp + slen + 1 >= linelength && linelength > 0)
+        {
+            fprintf(f,"\n ");
+            *curlenp = 1;
+        }
+        if (first)
+        {
+            fprintf(f,"%s",s);
+            *curlenp += slen;
+            first = FALSE;
+        }
+        else
+        {    
+            fprintf(f," %s",s);
+            *curlenp += slen + 1;
+        }
+        j1 = j2;
+    }
+}
+
+/*****************************************************************************
+*                                                                            *
+*  STOLEN FROM naututil.c                                                    *
+*  putgraphx(f,g,linelength,m,n) writes a list of the edges of g to f        *
+*  using at most linelength characters per line (excluding '\n').            *
+*  If triang, only write the upper triangle.                                 *
+*  labelorg is used.                                                         *
+*                                                                            *
+*****************************************************************************/
+
+static void
+putgraphx(FILE *f, graph *g, int linelength, boolean triang, int m, int n)
+{
+    int i,curlen;
+    set *pg;
+
+    for (i = 0, pg = g; i < n; ++i, pg += m)
+    {
+        fprintf(f,"%3d : ",i + labelorg);
+        curlen = 7;
+        putsetx(f,pg,&curlen,linelength,m,FALSE,triang ? i-1 : -1);
+        fprintf(f,";\n");
+    }
+}
+
+/***************************************************************************/
+
+static void
+putedges(FILE *f, graph *g, int linelength, 
+         boolean digraph, int m, int n)
+/* Write list of edges, preceded by the numbers of vertices and
+   edges.  Use labelorg */
+{
+    int i,j,curlen,ne;
+    char s[20];
+    set *pg;
+
+    ne = 0;
+    for (i = 0, pg = g; i < n; ++i, pg += m)
+    {
+        for (j = (digraph?-1:i-1); (j = nextelement(pg,m,j)) >= 0;)
+            ++ne;
+    }
+
+    fprintf(f,"%d %d\n",n,ne);
+
+    curlen = 0;
+    for (i = 0, pg = g; i < n; ++i, pg += m)
+    {
+        for (j = (digraph ? -1 : i-1); (j = nextelement(pg,m,j)) >= 0;)
+        { 
+            if (curlen > 0 && curlen > linelength - 10 && linelength > 0)
+            {
+                fprintf(f,"\n");
+                curlen = 0;
+            }
+            if (curlen > 0)
+            {
+                fprintf(f,"  ");
+                curlen += 2;
+            }
+            curlen += itos(i+labelorg,s);
+            fprintf(f,"%s",s);
+            fprintf(f," ");
+            curlen += 1 + itos(j+labelorg,s);
+            fprintf(f,"%s",s);
+        }
+    }
+    fprintf(f,"\n");
+}
+
+/***************************************************************************/
+
+static void
+putcgraph(FILE *f, graph *g, int linelength, boolean digraph, int m, int n)
+/* write compressed form, using labelorg */
+{
+    int i,curlen,j0;
+    int semicolons;
+    char s[20];
+    set *pg;
+
+    curlen = itos(n,s)+2;
+    fprintf(f,";n%s%s",s,(digraph?"dg":"g"));
+
+    semicolons = 0;
+    for (i = 0, pg = g; i < n; ++i, pg += m)
+    {
+	j0 = digraph ? -1: i-1;
+        if (nextelement(pg,m,j0) >= 0)
+        {
+            while (semicolons > 0)
+            {
+                if (curlen >= linelength-1 && linelength > 0)
+                {
+                    fprintf(f,"\n ");
+                    curlen = 1;
+                }
+                fprintf(f,";");
+                ++curlen;
+                --semicolons;
+            }
+            putsetx(f,pg,&curlen,linelength,m,FALSE,j0);
+            semicolons = 1;
+        }
+        else
+            ++semicolons;
+    }
+    fprintf(f,".\n");
+}
+
+/**************************************************************************/
+
+static void
+putam(FILE *f, graph *g, int linelength, boolean space, boolean triang,
+      int m, int n)   /* write adjacency matrix */
+{
+    set *gi;
+    int i,j;
+    boolean first;
+
+    for (i = 0, gi = (set*)g; i < n - (triang!=0); ++i, gi += m)
+    {
+        first = TRUE;
+        for (j = triang ? i+1 : 0; j < n; ++j)
+        {
+            if (!first && space) putc(' ',f);
+            else                 first = FALSE;
+            if (ISELEMENT(gi,j)) putc('1',f);
+            else                 putc('0',f);
+        }
+        putc('\n',f);
+    }
+}
+
+/**************************************************************************/
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    graph *g;
+    int m,n,codetype;
+    int argnum,j;
+    char *arg,sw;
+    boolean badargs,digraph;
+    long maxin,pval1,pval2;
+    boolean fswitch,pswitch,cswitch,dswitch;
+    boolean aswitch,lswitch,oswitch,Fswitch;
+    boolean Aswitch,eswitch,tswitch,qswitch;
+    int linelength;
+    char *infilename,*outfilename;
+
+    if (argc > 1 && (strcmp(argv[1],"-help") == 0
+                   || (strcmp(argv[1],"--help") == 0)))
+    {
+        printf("Usage: %s\n\n%s",USAGE,HELPTEXT);
+        exit(0);
+    }
+
+    if (sizeof(setword) < 4)
+    {
+        fprintf(stderr,">E showg: setword too small\n");
+        fprintf(stderr,"   Please report this to bdm@cs.anu.edu.au\n");
+        exit(1);
+    }
+
+    fswitch = pswitch = cswitch = dswitch = FALSE;
+    aswitch = lswitch = oswitch = Fswitch = FALSE;
+    Aswitch = eswitch = tswitch = qswitch = FALSE;
+    infilename = outfilename = NULL;
+    linelength = LINELEN;
+    labelorg = 0;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('a',aswitch)
+                else SWBOOLEAN('A',Aswitch)
+                else SWBOOLEAN('c',cswitch)
+                else SWBOOLEAN('d',dswitch)
+                else SWBOOLEAN('e',eswitch)
+                else SWBOOLEAN('f',fswitch)
+                else SWBOOLEAN('F',Fswitch)
+                else SWBOOLEAN('t',tswitch)
+                else SWBOOLEAN('q',qswitch)
+                else SWRANGE('p',pswitch,pval1,pval2,"showg -p")
+                else SWINT('l',lswitch,linelength,"showg -l")
+                else SWINT('o',oswitch,labelorg,"listo -o")
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if (labelorg < 0) gt_abort(">E showg: negative origin forbidden.\n");
+
+    if ((aswitch!=0) + (Aswitch!=0) + (eswitch!=0) 
+                     + (dswitch!=0) + (cswitch!=0) > 1)
+        gt_abort(">E showg: -aAecd are incompatible\n");
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        fprintf(stderr,"Use showg -help to see a list of the options.\n");
+        exit(1);
+    }
+
+    if (!pswitch || pval1 < 1) pval1 = 1;
+
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,fswitch,
+                           pswitch ? pval1 : 1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    if (!outfilename || outfilename[0] == '-')
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename,"w")) == NULL)
+    {
+        fprintf(stderr,"Can't open output file %s\n",outfilename);
+        gt_abort(NULL);
+    }
+
+    nin = 0;
+    if (!pswitch || pval2 == NOLIMIT)
+        maxin = NOLIMIT;
+    else if (pval1 < 1) maxin = pval2;
+    else                maxin = pval2 - pval1 + 1;
+    while (nin < maxin || maxin == NOLIMIT)
+    {
+        if ((g = readgg(infile,NULL,0,&m,&n,&digraph)) == NULL) break;
+        ++nin;
+
+        if (Fswitch && nin > 1) fprintf(outfile,"\f");
+
+        if (cswitch)
+            putcgraph(outfile,g,linelength,digraph,m,n);
+        else if (dswitch)
+        {
+            if (qswitch)
+                fprintf(outfile,"%d\n",n);
+            else
+            {
+                fprintf(outfile,"\n!Graph %ld.\n",pval1+nin-1);
+                fprintf(outfile,"n=%d $=%d g\n",n,labelorg);
+            }
+            putgraphx(outfile,g,linelength,tswitch,m,n);
+            if (!qswitch) fprintf(outfile,"$$\n");
+        }
+        else
+        {
+            if (qswitch)
+            {
+                if (!eswitch) fprintf(outfile,"%d\n",n);
+            }
+            else fprintf(outfile,"\nGraph %ld, order %d.\n",
+                                 pval1+nin-1,n);
+            if (aswitch|Aswitch)
+                putam(outfile,g,linelength,Aswitch,tswitch,m,n);
+            else if (eswitch)
+                putedges(outfile,g,linelength,digraph,m,n);
+            else
+                putgraphx(outfile,g,linelength,tswitch,m,n);
+        }
+        FREES(g);
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/sorttemplates.c b/lib/nauty/sorttemplates.c
new file mode 100644
index 0000000..8764fb3
--- /dev/null
+++ b/lib/nauty/sorttemplates.c
@@ -0,0 +1,445 @@
+/* sorttemplates.c version 1.1, Oct 9, 2013.
+ * Author: Brendan McKay; bdm@cs.anu.edu.au
+ *
+ * This file contains templates for creating in-place sorting procedures
+ * for different data types.  It cannot be compiled separately but
+ * should be #included after defining a few preprocessor variables.
+ *   SORT_OF_SORT, SORT_NAME and SORT_TYPE1 are required, and
+ *   SORT_TYPE2 is needed for SORT_OF_SORT > 1.
+ * 
+ *   SORT_OF_SORT = 1: Creates a procedure
+ *         static void SORT_NAME(SORT_TYPE1 *x, int n)
+ *     which permutes x[0..n-1] so that x[0] <= ... <= x[n-1].
+ *   SORT_OF_SORT = 2: Creates a procedure
+ *         static void SORT_NAME(SORT_TYPE1 *x, SORT_TYPE2 *y, int n)
+ *     which permutes x[0..n-1] so that x[0] <= ... <= x[n-1]
+ *     and also permutes y[0..n-1] by the same permutation.
+ *   SORT_OF_SORT = 3: Creates a procedure
+ *         static void SORT_NAME(SORT_TYPE1 *x, SORT_TYPE2 *y, int n)
+ *     which permutes x[0..n-1] so that y[x[0]] <= ... <= y[x[n-1]].
+ *     The array y[] is not changed.
+ * 
+ *   SORT_NAME = the name of the procedure to be created
+ *
+ *   SORT_TYPE1 = type of the first or only array (no default)
+ *   	 This can be any numeric type for SORT_OF_SORT=1,2, but
+ *   	 should be an integer type for SORT_OF_SORT=3.
+ *   SORT_TYPE2 = type of the second array if needed (no default)
+ *       This can be any assignable type (including a structure) for
+ *       SORT_OF_SORT=2, but must be a numeric type for SORT_OF_SORT=3.
+ *
+ *   SORT_MINPARTITION = least number of elements for using quicksort
+ *           partitioning, otherwise insertion sort is used (default "11") 
+ *   SORT_MINMEDIAN9 = least number of elements for using the median of 3
+ *           medians of 3 for partitioning (default "320")
+ *   SORT_FUNCTYPE = type of sort function (default "static void")
+ *
+ *   This file can be included any number of times provided the value
+ *   of SORT_NAME is different each time.
+ */
+ 
+#define SORT_MEDIAN_OF_3(a,b,c) \
+ ((a) <= (b) ? ((b) <= (c) ? (b) : (c) <= (a) ? (a) : (c)) \
+             : ((a) <= (c) ? (a) : (c) <= (b) ? (b) : (c)))
+
+#if !defined(SORT_OF_SORT) || !defined(SORT_NAME)
+ #error Either SORT_OF_SORT or SORT_NAME is undefined
+#endif
+
+#if (SORT_OF_SORT < 1) || (SORT_OF_SORT > 3)
+ #error Unknown value of SORT_OF_SORT
+#endif
+
+#ifndef SORT_TYPE1
+ #error "SORT_TYPE1 must be defined before including sorttemplates.c"
+#endif
+
+#ifndef SORT_MINPARTITION
+#define SORT_MINPARTITION 11
+#endif
+
+#ifndef SORT_MINMEDIAN9
+#define SORT_MINMEDIAN9 320
+#endif
+
+#ifndef SORT_FUNCTYPE
+#define SORT_FUNCTYPE static void
+#endif
+
+#define SORT_SWAP1(x,y) tmp1 = x; x = y; y = tmp1;
+#define SORT_SWAP2(x,y) tmp2 = x; x = y; y = tmp2;
+
+/*******************************************************************/
+
+#if SORT_OF_SORT == 1
+SORT_FUNCTYPE
+SORT_NAME(SORT_TYPE1 *x, int n)
+{
+    int i,j;
+    int a,d,ba,dc,s,nn;
+    SORT_TYPE1 tmp1,v,v1,v2,v3;
+    SORT_TYPE1 *x0,*xa,*xb,*xc,*xd,*xh,*xl;
+    struct {SORT_TYPE1 *addr; int len;} stack[40];
+    int top;
+
+    top = 0;
+    if (n > 1)
+    {
+        stack[top].addr = x;
+        stack[top].len = n;
+        ++top;
+    }
+
+    while (top > 0)
+    {
+	--top;
+	x0 = stack[top].addr;
+	nn = stack[top].len;
+
+        if (nn < SORT_MINPARTITION)
+        {
+            for (i = 1; i < nn; ++i)
+            {
+                tmp1 = x0[i];
+                for (j = i; x0[j-1] > tmp1; )
+                {
+                    x0[j] = x0[j-1];
+                    if (--j == 0) break;
+                }
+                x0[j] = tmp1;
+            }
+	    continue;
+        }
+
+        if (nn < SORT_MINMEDIAN9)
+            v = SORT_MEDIAN_OF_3(x0[0],x0[nn/2],x0[nn-1]);
+        else
+        {
+	    v1 = SORT_MEDIAN_OF_3(x0[0],x0[1],x0[2]);
+	    v2 = SORT_MEDIAN_OF_3(x0[nn/2-1],x0[nn/2],x0[nn/2+1]);
+	    v3 = SORT_MEDIAN_OF_3(x0[nn-3],x0[nn-2],x0[nn-1]);
+	    v = SORT_MEDIAN_OF_3(v1,v2,v3);
+        }
+
+        xa = xb = x0;  xc = xd = x0+(nn-1);
+        for (;;)
+        {
+	    while (xb <= xc && *xb <= v)
+	    {
+	        if (*xb == v)
+	        {
+		    *xb = *xa; *xa = v; ++xa;
+	        }
+	        ++xb;
+	    }
+	    while (xc >= xb && *xc >= v)
+	    {
+	        if (*xc == v)
+	        {
+		    *xc = *xd; *xd = v; --xd;
+	        }
+	        --xc;
+	    }
+	    if (xb > xc) break;
+            SORT_SWAP1(*xb,*xc);
+	    ++xb;
+	    --xc;
+        }
+    
+        a = xa - x0;
+        ba = xb - xa;
+        if (ba > a) s = a; else s = ba;
+        for (xl = x0, xh = xb-s; s > 0; --s)
+        {
+	    *xl = *xh; *xh = v; ++xl; ++xh;
+        }
+        d = xd - x0;
+        dc = xd - xc;
+        if (dc > nn-1-d) s = nn-1-d; else s = dc;
+        for (xl = xb, xh = x0 + (nn-s); s > 0; --s)
+        {
+	    *xh = *xl; *xl = v; ++xl; ++xh;
+        }
+
+	if (ba > dc)
+	{
+	    if (ba > 1)
+	    {
+	        stack[top].addr = x0; stack[top].len = ba; ++top;
+	    }
+	    if (dc > 1)
+	    {
+	        stack[top].addr = x0+(nn-dc); stack[top].len = dc; ++top;
+	    }
+	}
+	else
+	{
+	    if (dc > 1)
+	    {
+	        stack[top].addr = x0+(nn-dc); stack[top].len = dc; ++top;
+	    }
+	    if (ba > 1)
+	    {
+	        stack[top].addr = x0; stack[top].len = ba; ++top;
+	    }
+	}
+    }
+}
+#endif
+
+#if SORT_OF_SORT == 2
+#ifndef SORT_TYPE2
+ #error "SORT_TYPE2 must be defined before including sorttemplates.c"
+#endif
+
+SORT_FUNCTYPE
+SORT_NAME(SORT_TYPE1 *x, SORT_TYPE2 *y, int n)
+{
+    int i,j;
+    int a,d,ba,dc,s,nn;
+    SORT_TYPE2 tmp2,*y0,*ya,*yb,*yc,*yd,*yl,*yh;
+    SORT_TYPE1 tmp1,v,v1,v2,v3;
+    SORT_TYPE1 *x0,*xa,*xb,*xc,*xd,*xh,*xl;
+    struct {SORT_TYPE1 *addr; int len;} stack[40];
+    int top;
+
+    top = 0;
+    if (n > 1)
+    {
+        stack[top].addr = x;
+        stack[top].len = n;
+        ++top;
+    }
+
+    while (top > 0)
+    {
+	--top;
+	x0 = stack[top].addr;
+	y0 = y + (x0-x);
+	nn = stack[top].len;
+
+        if (nn < SORT_MINPARTITION)
+        {
+            for (i = 1; i < nn; ++i)
+            {
+                tmp1 = x0[i];
+                tmp2 = y0[i];
+                for (j = i; x0[j-1] > tmp1; )
+                {
+                    x0[j] = x0[j-1];
+                    y0[j] = y0[j-1];
+                    if (--j == 0) break;
+                }
+                x0[j] = tmp1;
+                y0[j] = tmp2;
+            }
+	    continue;
+        }
+
+        if (nn < SORT_MINMEDIAN9)
+            v = SORT_MEDIAN_OF_3(x0[0],x0[nn/2],x0[nn-1]);
+        else
+        {
+	    v1 = SORT_MEDIAN_OF_3(x0[0],x0[1],x0[2]);
+	    v2 = SORT_MEDIAN_OF_3(x0[nn/2-1],x0[nn/2],x0[nn/2+1]);
+	    v3 = SORT_MEDIAN_OF_3(x0[nn-3],x0[nn-2],x0[nn-1]);
+	    v = SORT_MEDIAN_OF_3(v1,v2,v3);
+        }
+
+        xa = xb = x0;  xc = xd = x0+(nn-1);
+        ya = yb = y0;  yc = yd = y0+(nn-1);
+        for (;;)
+        {
+	    while (xb <= xc && *xb <= v)
+	    {
+	        if (*xb == v)
+	        {
+		    *xb = *xa; *xa = v; ++xa;
+		    SORT_SWAP2(*ya,*yb); ++ya;
+	        }
+	        ++xb; ++yb;
+	    }
+	    while (xc >= xb && *xc >= v)
+	    {
+	        if (*xc == v)
+	        {
+		    *xc = *xd; *xd = v; --xd;
+		    SORT_SWAP2(*yc,*yd); --yd;
+	        }
+	        --xc; --yc;
+	    }
+	    if (xb > xc) break;
+            SORT_SWAP1(*xb,*xc);
+            SORT_SWAP2(*yb,*yc);
+	    ++xb; ++yb;
+	    --xc; --yc;
+        }
+    
+        a = xa - x0;
+        ba = xb - xa;
+        if (ba > a) s = a; else s = ba;
+        for (xl = x0, xh = xb-s, yl = y0, yh = yb-s; s > 0; --s)
+        {
+	    *xl = *xh; *xh = v; ++xl; ++xh;
+	    SORT_SWAP2(*yl,*yh); ++yl; ++yh;
+        }
+        d = xd - x0;
+        dc = xd - xc;
+        if (dc > nn-1-d) s = nn-1-d; else s = dc;
+        for (xl = xb, xh = x0+(nn-s), yl = yb, yh = y0+(nn-s); s > 0; --s)
+        {
+	    *xh = *xl; *xl = v; ++xl; ++xh;
+	    SORT_SWAP2(*yl,*yh); ++yl; ++yh;
+        }
+
+	if (ba > dc)
+	{
+	    if (ba > 1)
+	    {
+	        stack[top].addr = x0; stack[top].len = ba; ++top;
+	    }
+	    if (dc > 1)
+	    {
+	        stack[top].addr = x0+(nn-dc); stack[top].len = dc; ++top;
+	    }
+	}
+	else
+	{
+	    if (dc > 1)
+	    {
+	        stack[top].addr = x0+(nn-dc); stack[top].len = dc; ++top;
+	    }
+	    if (ba > 1)
+	    {
+	        stack[top].addr = x0; stack[top].len = ba; ++top;
+	    }
+	}
+    }
+}
+#endif
+
+#if SORT_OF_SORT == 3
+#ifndef SORT_TYPE2
+ #error "SORT_TYPE2 must be defined before including sorttemplates.c"
+#endif
+
+SORT_FUNCTYPE
+SORT_NAME(SORT_TYPE1 *x, SORT_TYPE2 *y, int n)
+{
+    int i,j;
+    int a,d,ba,dc,s,nn;
+    SORT_TYPE2 tmp2,v,v1,v2,v3;
+    SORT_TYPE1 tmp1,*x0,*xa,*xb,*xc,*xd,*xh,*xl;
+    struct {SORT_TYPE1 *addr; int len;} stack[40];
+    int top;
+
+    top = 0;
+    if (n > 1)
+    {
+        stack[top].addr = x;
+        stack[top].len = n;
+        ++top;
+    }
+
+    while (top > 0)
+    {
+	--top;
+	x0 = stack[top].addr;
+	nn = stack[top].len;
+
+        if (nn < SORT_MINPARTITION)
+        {
+            for (i = 1; i < nn; ++i)
+            {
+                tmp1 = x0[i];
+		tmp2 = y[tmp1];
+                for (j = i; y[x0[j-1]] > tmp2; )
+                {
+                    x0[j] = x0[j-1];
+                    if (--j == 0) break;
+                }
+                x0[j] = tmp1;
+            }
+	    continue;
+        }
+
+        if (nn < SORT_MINMEDIAN9)
+            v = SORT_MEDIAN_OF_3(y[x0[0]],y[x0[nn/2]],y[x0[nn-1]]);
+        else
+        {
+	    v1 = SORT_MEDIAN_OF_3(y[x0[0]],y[x0[1]],y[x0[2]]);
+	    v2 = SORT_MEDIAN_OF_3(y[x0[nn/2-1]],y[x0[nn/2]],y[x0[nn/2+1]]);
+	    v3 = SORT_MEDIAN_OF_3(y[x0[nn-3]],y[x0[nn-2]],y[x0[nn-1]]);
+	    v = SORT_MEDIAN_OF_3(v1,v2,v3);
+        }
+
+        xa = xb = x0;  xc = xd = x0+(nn-1);
+        for (;;)
+        {
+	    while (xb <= xc && y[*xb] <= v)
+	    {
+	        if (y[*xb] == v)
+	        {
+		    SORT_SWAP1(*xa,*xb); ++xa;
+	        }
+	        ++xb;
+	    }
+	    while (xc >= xb && y[*xc] >= v)
+	    {
+	        if (y[*xc] == v)
+	        {
+		    SORT_SWAP1(*xc,*xd); --xd;
+	        }
+	        --xc;
+	    }
+	    if (xb > xc) break;
+            SORT_SWAP1(*xb,*xc);
+	    ++xb;
+	    --xc;
+        }
+    
+        a = xa - x0;
+        ba = xb - xa;
+        if (ba > a) s = a; else s = ba;
+        for (xl = x0, xh = xb-s; s > 0; --s)
+        {
+	    SORT_SWAP1(*xl,*xh); ++xl; ++xh;
+        }
+        d = xd - x0;
+        dc = xd - xc;
+        if (dc > nn-1-d) s = nn-1-d; else s = dc;
+        for (xl = xb, xh = x0 + (nn-s); s > 0; --s)
+        {
+	    SORT_SWAP1(*xl,*xh); ++xl; ++xh;
+        }
+
+	if (ba > dc)
+	{
+	    if (ba > 1)
+	    {
+	        stack[top].addr = x0; stack[top].len = ba; ++top;
+	    }
+	    if (dc > 1)
+	    {
+	        stack[top].addr = x0+(nn-dc); stack[top].len = dc; ++top;
+	    }
+	}
+	else
+	{
+	    if (dc > 1)
+	    {
+	        stack[top].addr = x0+(nn-dc); stack[top].len = dc; ++top;
+	    }
+	    if (ba > 1)
+	    {
+	        stack[top].addr = x0; stack[top].len = ba; ++top;
+	    }
+	}
+    }
+}
+#endif
+
+#undef SORT_NAME
+#undef SORT_OF_SORT
+#undef SORT_TYPE1
+#undef SORT_TYPE2
diff --git a/lib/nauty/splay.c b/lib/nauty/splay.c
new file mode 100644
index 0000000..84b3009
--- /dev/null
+++ b/lib/nauty/splay.c
@@ -0,0 +1,413 @@
+/* splay.c  - code for splay trees    Version of August 18, 2001.
+ * Author: Brendan McKay  bdm@cs.anu.edu.au
+
+   This file is not meant to be compiled separately, but to be
+   #included into other programs.  Use it like this:
+
+   1. Define a node type SPLAYNODE.  It must be a structure that
+   contains at least the pointer fields left, right and parent of
+   type SPLAYNODE*.
+   Also define a macro SPLAYNODESIZE giving the size of an object
+   of type SPLAYNODE, unless  sizeof(SPLAYNODE) is adequate.
+
+   2. Declare a variable of type SPLAYNODE* to point to the root
+   of the tree, and initialise it to NULL.
+
+   3. Declare SCAN_ARGS to be the additional arguments needed for
+   splay_scan(), including a leading comma.
+
+   4. Declare ACTION(p) for what splay_scan() should do for node p.
+
+   5. Declare INSERT_ARGS to be the additional arguments needed 
+   for splay_insert(), including a leading comma.
+
+   6. Declare COMPARE(p) to compare INSERT_ARGS or LOOKUP_ARGS to the
+   contents of node p.  <0, 0, >0 if INSERT_ARGS is greater, equal,
+   less, than p.  This has to be an expression with a value, so you will
+   need to make it a procedure call if the comparison is complicated.
+
+   If you are using something like strcmp, the correct order is
+   strcmp( INSERT_ARGS, p ).
+
+   7. Declare PRESENT(p) for what to do if INSERT_ARGS is already
+   present, in node p.  There is a spare int variable i available.
+   Typically, this might update some data in the node p.
+
+   8. Declare NOT_PRESENT(p) for what to do if INSERT_ARGS is not
+   in the tree and p is a fresh node to hold it.  No need to set
+   the left, right, and parent fields.  Use i here too if you like.
+   Typically, this might initialise the data in node p.
+
+	PRESENT(p) and NOT_PRESENT(p) should not manipulate the
+        tree pointers.  However, each of them can include a
+        return if you don't want to change the tree.  In the
+        case of NOT_PRESENT(p), do free(p) before returning.
+
+        In the case of PRESENT(p), it is also legal to delete the
+        node from the tree using SCAN_DELETE(to_root,p).  In that
+        case you MUST return immediately afterwards.
+
+   9. Declare LOOKUP_ARGS to be the additional arguments needed
+   for splay_lookup(), including a leading comma.  The default
+   for LOOKUP_ARGS is to be the same as INSERT_ARGS.
+
+  10. #include "splay.c"
+
+
+  Calls:
+
+    Suppose "root" is name of the variable described in step 2.
+
+    There is no need to initialise the tree.  Step 2 did that already.
+
+    To insert something in the tree:
+        splay_insert(&root, ...stuff...)
+    where "stuff" is the stuff you want to insert, declared as INSERT_ARGS.
+    If the key (some part of the stuff decided by you) is present in an
+    existing tree node p, PRESENT(p) is executed.  Otherwise, a new tree
+    node p is created and NOT_PRESENT(p) is executed.
+
+    To look up something in the tree:
+        splay_lookup(&root, ...stuff...)
+    where "stuff" is the stuff you want to find, declared as LOOKUP_ARGS.
+    It will return a pointer to the tree node with the right key, or NULL
+    if there is no such tree node.
+
+    To do something for each node of the tree:
+        splay_scan(root, ...stuff...)
+    where "stuff" is anything you like (including nothing).  This will
+    execute ACTION(p) for each node p in inorder.
+
+    To delete the node p (which MUST be in the tree:
+        splay_delete(&root, p)
+    Nothing happens if p is NULL, so you can use
+        splay_delete(&root, splay_lookup(&root, ...stuff...))
+    to delete a node, if any, containing stuff.
+
+  It is possible to have splay trees of several types in the same
+  program.  Just include "splay.c" several times, with the procedure
+  names SPLAY, SPLAY_SCAN, SPLAY_LOOKUP, SPLAY_INSERT, SPLAY_DELETE
+  defined to distinct names.  You have to redefine them all even if
+  you aren't using them all.
+*/
+
+#define S_A 0
+#define S_L 1
+#define S_R 2
+#define S_LL 3
+#define S_LR 4
+#define S_RL 5
+#define S_RR 6
+
+#ifndef SPLAYNODESIZE
+#define SPLAYNODESIZE sizeof(SPLAYNODE)
+#endif
+
+#ifndef LOOKUP_ARGS
+#define LOOKUP_ARGS INSERT_ARGS
+#endif
+
+#ifndef SPLAY
+#define SPLAY splay
+#define SPLAY_SCAN splay_scan
+#define SPLAY_LOOKUP splay_lookup
+#define SPLAY_INSERT splay_insert
+#define SPLAY_DELETE splay_delete
+#endif
+
+/*********************************************************************/
+
+void
+SPLAY_SCAN(SPLAYNODE *root SCAN_ARGS)
+/* Do ACTION(p) for each node of the tree, in inorder.  Nonrecursive! */
+{
+    int code;
+    SPLAYNODE *p;
+
+    p = root;
+    code = S_A;
+
+    while (p)
+    {
+	switch (code)    /* deliberate flow-ons */
+	{
+	 case S_A:
+	    if (p->left)
+	    {
+		p = p->left;
+		break;
+	    }
+	 case S_L:
+	    ACTION(p);
+	    if (p->right)
+	    {
+		p = p->right;
+		code = S_A;
+		break;
+	    }
+	 case S_R:
+	    if (p->parent && p->parent->left == p) code = S_L;
+	    else                                   code = S_R;
+	    p = p->parent;
+	    break;
+	}
+    }
+}
+
+/*********************************************************************/
+
+static void
+SPLAY(SPLAYNODE *p)
+/* Splay the node p.  It becomes the new root. */
+{
+    SPLAYNODE *q,*r,*s;
+    SPLAYNODE *a,*b,*c;
+    int code;
+
+#define LCHILD(x,y) {(x)->left = y; if (y) (y)->parent = x;}
+#define RCHILD(x,y) {(x)->right = y; if (y) (y)->parent = x;}
+
+    while (p->parent)
+    {
+	a = p->left;
+	b = p->right;
+	q = p->parent;
+	if (q->left == p)
+	{
+	    code = S_L;
+	    c = q->right;
+	}
+	else
+	{
+	    code = S_R;
+	    c = q->left;
+	}
+	r = q->parent;
+	if (r)
+	{
+	    if (r->left == q) code = (code == S_L ? S_LL : S_LR);
+	    else              code = (code == S_L ? S_RL : S_RR);
+	    s = r->parent;
+	    p->parent = s;
+	    if (s)
+	    {
+		if (s->left == r) s->left = p;
+		else              s->right = p;
+	    }
+	}
+	else
+	{
+	    p->parent = NULL;
+	}
+	
+	switch (code)
+	{
+	 case S_L:
+	    RCHILD(p,q);
+	    LCHILD(q,b);
+	    break;
+	 case S_R:
+	    LCHILD(p,q);
+	    RCHILD(q,a);
+	    break;
+	 case S_LL:
+	    RCHILD(p,q);
+	    RCHILD(q,r);
+	    LCHILD(q,b);
+	    LCHILD(r,c);
+	    break;
+	 case S_RR:
+	    LCHILD(p,q);
+	    LCHILD(q,r);
+	    RCHILD(r,c);
+	    RCHILD(q,a);
+	    break;
+	 case S_LR:
+	    LCHILD(p,q);
+	    RCHILD(p,r);
+	    RCHILD(q,a);
+	    LCHILD(r,b);
+	    break;
+	 case S_RL:
+	    LCHILD(p,r);
+	    RCHILD(p,q);
+	    RCHILD(r,a);
+	    LCHILD(q,b);
+	    break;
+	}
+    }
+}
+
+/*********************************************************************/
+
+void
+SPLAY_INSERT(SPLAYNODE **to_root  INSERT_ARGS)
+/* Do insertion operation.  On return, the object being inserted
+   is at the root of the tree regardless of whether a new node
+   needed to be created for it. */
+{
+    int i,cmp;
+    SPLAYNODE *p,*ppar,*new_node;
+
+    p = *to_root;
+    cmp = 0;
+
+    while (p != NULL)
+    {
+        cmp = COMPARE(p);
+        if (cmp == 0)
+        {
+	    PRESENT(p);
+	    SPLAY(p);
+	    *to_root = p;
+            return;
+        }
+        else if (cmp < 0)
+        {
+            ppar = p;
+            p = p->left;
+        }
+        else
+        {
+            ppar = p;
+            p = p->right;
+        }
+    }
+
+    if ((new_node = (SPLAYNODE*)malloc(SPLAYNODESIZE)) == NULL)
+    {
+        fprintf(stderr,">E malloc failed in splay_insert()\n");
+        exit(1);
+    }
+
+    NOT_PRESENT(new_node);
+
+    new_node->left = new_node->right = NULL;
+
+    if (cmp == 0)
+    {
+        *to_root = new_node;
+	new_node->parent = NULL;
+    }
+    else if (cmp < 0)
+    {
+        ppar->left = new_node;
+	new_node->parent = ppar;
+    }
+    else
+    {
+        ppar->right = new_node;
+	new_node->parent = ppar;
+    }
+
+    SPLAY(new_node);
+    *to_root = new_node;
+}
+
+/*********************************************************************/
+
+SPLAYNODE*
+SPLAY_LOOKUP(SPLAYNODE **to_root  LOOKUP_ARGS)
+/* Do a look-up operation.  If found, return a pointer to the
+   node containing it.  If not, return NULL. */
+{
+    int i,cmp;   /* i is available for COMPARE */
+    SPLAYNODE *p;
+
+    p = *to_root;
+    cmp = 0;
+
+    while (p != NULL)
+    {
+        cmp = COMPARE(p);
+        if (cmp == 0)
+        {
+	    SPLAY(p);
+	    *to_root = p;
+            return p;
+        }
+        else if (cmp < 0)
+            p = p->left;
+        else
+            p = p->right;
+    }
+
+    return NULL;
+}
+
+/*********************************************************************/
+
+void
+SPLAY_DELETE(SPLAYNODE **to_root, SPLAYNODE *p)
+/* Remove node p from the tree and free it. */
+{
+    SPLAYNODE *q;
+
+    if (p == NULL) return;
+
+    SPLAY(p);
+    *to_root = p;
+
+    /* Now we have to delete the root. */
+
+    /* No right child (includes no children). */
+
+    if (!p->right)
+    {
+	*to_root = p->left;
+        if (p->left) p->left->parent = NULL;
+	free(p);
+	return;
+    }
+
+    /* right child but no left child */
+
+    if (!p->left)
+    {
+        *to_root = p->right;
+        p->right->parent = NULL;
+        free(p);
+        return;
+    }  
+
+    /* both children exist */
+
+     for (q = p->left; q->right; q = q->right) {}
+
+     if (q->left) q->left->parent = q->parent;
+     if (q->parent == p) q->parent->left = q->left;
+     else                q->parent->right = q->left;
+
+     q->left = p->left;
+     q->right = p->right;
+     q->parent = NULL;
+     if (p->left) p->left->parent = q;
+     if (p->right) p->right->parent = q;
+     *to_root = q;
+     free(p);
+}
+
+/*********************************************************************/
+
+/* The following shows the tree structure for debugging purposes.
+   If you define SPLAY_DUMP you must also define DUMP_ARGS,
+   DUMP_LEFT, DUMP_RIGHT and DUMP_ACTION(p). */
+
+#ifdef SPLAY_DUMP
+void
+SPLAY_DUMP(SPLAYNODE *p DUMP_ARGS)
+{
+    int i;
+    
+    if (p == NULL) return;
+
+    if (p->right && p->right->parent != p)
+	fprintf(stderr,"parent misaligned at %p-%p ************\n",p,p->right);
+    if (p->left && p->left->parent != p)
+	fprintf(stderr,"parent misaligned at %p-%p ************\n",p,p->left);
+
+    SPLAY_DUMP(p->right  DUMP_RIGHT);
+    DUMP_ACTION(p);
+    SPLAY_DUMP(p->left  DUMP_LEFT);
+}
+#endif
diff --git a/lib/nauty/subdivideg.c b/lib/nauty/subdivideg.c
new file mode 100644
index 0000000..ee5249f
--- /dev/null
+++ b/lib/nauty/subdivideg.c
@@ -0,0 +1,226 @@
+/* subdivideg.c  version 1.0; B D McKay, May 2011. */
+
+#define USAGE "subdivideg [-k#] [-q] [infile [outfile]]"
+
+#define HELPTEXT \
+" Make the subdivision graphs of a file of graphs.\n\
+    -k#  Subdivide each edge by # new vertices (default 1)\n\
+\n\
+    The output file has a header if and only if the input file does.\n\
+\n\
+    -q  Suppress auxiliary information.\n"
+
+/*************************************************************************/
+
+#include "gtools.h" 
+
+/**************************************************************************/
+
+static void
+subdivisiongraph(sparsegraph *g, int k, sparsegraph *h)
+/* h := subdivision graph of g, k new vertices per edge */
+{
+    DYNALLSTAT(size_t,eno,eno_sz);   /* edge number */
+    int *ge,*gd,*he,*hd;
+    size_t *gv,*hv;
+    int gnv,hnv;
+    size_t i,j,l,gnde,hnde,num;
+    size_t hi,lo,mid,w;
+
+    if (k == 0)
+    {
+	copy_sg(g,h);
+	return;
+    }
+
+    sortlists_sg(g);
+    SG_VDE(g,gv,gd,ge);
+    gnv = g->nv;
+    gnde = g->nde;
+    DYNALLOC1(size_t,eno,eno_sz,gnde,"subdivideg");
+
+    hnv = gnv + k*(gnde/2);
+    if (hnv <= 0 || (gnde > 0 && ((size_t)(hnv-gnv))/(gnde/2) != k))
+        gt_abort(">E subdivideg: output graph too large\n");
+    hnde = gnde * (k+1);
+    if (hnde/(k+1) != gnde)
+        gt_abort(">E subdivideg: output graph too large\n");
+
+    num = 0;
+    for (i = 0; i < gnv; ++i)
+    {
+        for (j = gv[i]; j < gv[i]+gd[i]; ++j)
+        {
+            if (ge[j] == i)
+                gt_abort(">E subdivideg can't handle undirected loops\n");
+            else if (ge[j] > i)
+                eno[j] = num++;
+            else
+            {
+                lo = gv[ge[j]];
+                hi = lo + gd[ge[j]] - 1;
+                while (lo <= hi)
+                {
+                    mid = lo + (hi-lo)/2;
+                    if (ge[mid] == i) break;
+                    else if  (ge[mid] < i) lo = mid+1;
+                    else hi = mid-1;
+                }
+		if (lo > hi)
+		    gt_abort(">E subdivideg : binary search failed\n");
+                eno[j] = eno[mid];
+            }
+        }
+    }
+
+    SG_ALLOC(*h,hnv,hnde,"subdivideg");
+    h->nv = hnv;
+    h->nde = hnde;
+    SG_VDE(h,hv,hd,he);
+
+    for (i = 0; i < gnv; ++i)
+    {
+        hd[i] = gd[i];
+        hv[i] = gv[i];
+    }
+    for (i = gnv; i < hnv; ++i)
+    {
+	hd[i] = 2;
+        hv[i] = gnde + 2*(i-gnv);
+    }
+
+    for (i = 0; i < gnv; ++i)
+    {
+        for (j = gv[i]; j < gv[i]+gd[i]; ++j)
+            if (ge[j] > i)
+	    {
+		w = gnv + k*eno[j];
+		he[j] = w;
+		he[hv[w]] = i;
+		for (l = 1; l < k; ++l)
+		{
+		    he[hv[w]+1] = w+1;
+		    he[hv[w+1]] = w;
+		    ++w;
+		}
+	    }
+	    else
+	    {
+		w = gnv + k*eno[j] + k - 1;
+		he[j] = w;
+		he[hv[w]+1] = i;
+	    }
+    }
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    char *infilename,*outfilename;
+    FILE *infile,*outfile;
+    boolean badargs,quiet,kswitch;
+    int j,argnum,kvalue;
+    int codetype,outcode;
+    SG_DECL(g); SG_DECL(h);
+    nauty_counter nin;
+    char *arg,sw;
+    double t;
+
+    HELP; PUTVERSION;
+
+    infilename = outfilename = NULL;
+    quiet = kswitch = FALSE;
+    kvalue = 1;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                SWBOOLEAN('q',quiet)
+                else SWINT('k',kswitch,kvalue,"subdivideg -k")
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if (badargs)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if (!quiet)
+    {
+        fprintf(stderr,">A subdivideg");
+	if (kswitch) fprintf(stderr," -k%d",kvalue);
+        if (argnum > 0) fprintf(stderr," %s",infilename);
+        if (argnum > 1) fprintf(stderr," %s",outfilename);
+        fprintf(stderr,"\n");
+        fflush(stderr);
+    }
+
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,FALSE,1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    NODIGRAPHSYET(codetype);
+
+    if (!outfilename || outfilename[0] == '-')
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename,"w")) == NULL)
+    {
+        fprintf(stderr,"Can't open output file %s\n",outfilename);
+        gt_abort(NULL);
+    }
+
+    if (codetype&SPARSE6) outcode = SPARSE6;
+    else                  outcode = GRAPH6;
+
+    if (codetype&HAS_HEADER)
+    {
+        if (outcode == SPARSE6) writeline(outfile,SPARSE6_HEADER);
+        else                    writeline(outfile,GRAPH6_HEADER);
+    }
+
+    nin = 0;
+    t = CPUTIME;
+    while (read_sg(infile,&g))
+    {
+        ++nin;
+
+        subdivisiongraph(&g,kvalue,&h);
+        if (outcode == SPARSE6) writes6_sg(outfile,&h);
+        else                    writeg6_sg(outfile,&h);
+    }
+    t = CPUTIME - t;
+
+    if (!quiet)
+    {
+        fprintf(stderr,">Z " COUNTER_FMT
+                       " graphs converted from %s to %s in %3.2f sec.\n",
+                nin,infilename,outfilename,t);
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/sumlines.c b/lib/nauty/sumlines.c
new file mode 100644
index 0000000..28e4c76
--- /dev/null
+++ b/lib/nauty/sumlines.c
@@ -0,0 +1,1663 @@
+/* sumlines.c - total the numbers appearing in various input lines. */
+/* B. D. McKay.  Version of June 18, 2016. */
+
+#ifndef GMP
+#define GMP 1  /* Non-zero if gmp multi-precise integers are allowed.
+                  In this case you need the GNU multi-precision library,
+                  available with -lgmp if it is installed. */
+#endif
+
+#define USAGE \
+"sumlines [-w|-W] [-v] [-d] [-n] [-f fmtfile]...  file file file ..."
+
+#define HELPTEXT \
+"   Sum lines matching specified formats.\n\
+\n\
+   Any number of input files can be given.  \"-\" means stdin.\n\
+   If there are no files given, just stdin is assumed.\n\
+   File names can contain wildcards, in which case all matching files\n\
+      are used in numerically sorted order.\n\
+\n\
+   Formats are read from four sources in this order:\n\
+   (1) Any files mentioned with -f on the command line (any number).\n\
+   (2) The file named in the environment variable SUMLINES.FMT (if any)\n\
+   (3) The file sumlines.fmt in the current directory (if it exists)\n\
+   (4) The file sumlines.fmt in the home directory (if it exists)\n\
+   All these are read if they exist and the results concatenated.\n\
+   Formats exactly matching earlier formats (except perhaps for flags)\n\
+        are not used.\n\
+\n\
+   Each format occupies exactly two lines.  The first line gives a\n\
+   list of flags (DEFAULT FINAL ERROR UNIQUE COUNT CONTINUE NUMERIC\n\
+   SILENT ENDFILE P=# separated by spaces, commas or |s).\n\
+   The second line gives the format itself.\n\
+\n\
+   Example.  This totals the summary lines of autoson runs:\n\
+     DEFAULT  # comment \n\
+     cpu=%fu,%fs,%fx  pf=%d\n\
+   There can also be blank lines and lines with only comments, but\n\
+   not between the flags line and the format itself.\n\
+\n\
+   -d don't read sumlines.fmt or ~/sumlines.fmt or $SUMLINES.FMT \n\
+   -w suppresses warning messages about no matching lines or no\n\
+      matching final lines.\n\
+   -W in addition, suppresses woarning about missing cases.\n\
+   -n don't write the number of matching lines for each format.\n\
+   -v produces a list of all the formats.\n"
+
+#define DEFAULT   0  /* No special flags */
+#define FINAL     1  /* At least one of these must be in each input file */
+#define ERROR     2  /* Must be none of these */
+#define UNIQUE    4  /* The %s and %c parts must be unique over all inputs */
+#define COUNT     8  /* The output only states how many lines matched */
+#define CONTINUE 16  /* Try to match later formats too */
+#define NUMERIC  32  /* Use numerical comparison (see numstrcmp() below) */
+#define SILENT   64  /* Don't report, just check */
+#define ENDFILE 128  /* Usually appears at end of output */
+
+/* The formats are tried against each input line one at a time, and the
+   first one that matches is accepted.  The entire line must match.
+   If the CONTINUE flag is present, the input line is also matched
+   against further formats.
+
+   Except in the case of formats with the COUNT flag, each format that
+   matches any lines produces output giving the total value of each of the
+   integers %d or real numbers %f in the lines which match.  If there are
+   any %s or %c controls in the format, the output is given separately for
+   each value of the matching strings which appear in the input lines.
+   %m is like %d but allows arbitrarily large integers.
+   %x is like %d but the maximum rather than the sum is accumulated.
+   %p is like %d but the value is accumulated modulo some base.
+   %h is like %d:%d:%f taken as h:m:s with a single floating value.
+
+   In the case of the COUNT flag, the program only reports the number of
+   input lines which matched the format.
+
+   If a format has the UNIQUE flag, no two input lines may match with the
+   same values of the %s and %c controls present.  Otherwise a warning
+   message is written for each duplicate match.
+
+   The sequence P=# where # is an integer value defines the base for the
+   %p directive.  There can be no spaces in the sequence "P=#".  The
+   default base is 2.
+
+   %d  - matches an integer (small enough for 64 bits)
+   %x  - same as %d but accumulates maximum rather than the sum
+   %p  - same as %d but accumulates the value modulo a base
+   %m  - matches a integer of unbounded size (if GMP!=0)
+   %f  - matches a real number of the form ddddd.ddd or -ddddd.ddd
+   %v  - same as %f but reports the average rather than the sum
+   %h  - similar to %d:%d:%f taken as h:m:s with a single floating value
+   %sx - matches a string, where 'x' is any character. 
+         If 'x' is not a space, match zero or more characters from the
+             current position up but not including the first 'x'.
+         If 'x' is a space, match one or more characters from the current
+             position up to and including the first non-space character
+             which is followed by a space.
+   %c  - matches a non-white character
+   %%  - matches the character '%'
+   %   - (with a space following the '%') matches zero or more spaces or
+            tabs, as many as appear in the input.  In the output, this
+            sequence appears as one space.
+   %   - (appearing exactly at the end of the format) matches zero or
+         more spaces at the end of the line.  In the output, nothing.
+   %*d, %*m, %*x, %*p, %*f, %*sx, %*c - these are similar to the versions
+         without the '*' except that the value is ignored (not used for
+         summing, and not used to divide the output).  In the output,
+         this field appears as a single character '*'.
+   %#  - matches an unsigned integer.  For each format containing this
+         control, a report is made of any breaks or duplicates in the
+         sequence of matching numbers.  (So this is useful for checking a
+         sequence of case numbers.)  At most one %# may appear in each format.
+   %l  - matches a list of arbitrarily many (%d sized) integers
+
+  At least one FINAL format must match in each file or a warning is given
+  (unless -w is used, in which case no warning is given).
+
+  A format marked ENDFILE will cause sumlines to act as if it started
+  reading from a new input file.  This can have some effects on the
+  order of output lines.
+*/
+
+#define HAS(i,flgs)  ((format[i].flags&(flgs)) != 0)
+
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <pwd.h>
+#include <stdlib.h>
+#include <glob.h>
+#include <limits.h>
+#include <unistd.h>
+
+#if GMP
+#include <gmp.h>
+#endif
+
+#if defined(__alpha)
+typedef long integer;
+#define DOUT "%ld"       /* Formats used to output %d/%x/%p,%f,%v quantities */
+#define FOUT "%.2f"
+#define VOUT "%.4f"
+#define HMSOUT1 "%ld:%ld:%ld"
+#define HMSOUT2 "%ld:%ld:%.2f"
+#elif defined(__sun) || defined(__GNUC__) || (__STDC_VERSION__ > 199900L)
+typedef long long integer;
+#define DOUT "%lld"   
+#define FOUT "%.2f"
+#define VOUT "%.4f"
+#define HMSOUT1 "%lld:%lld:%lld"
+#define HMSOUT2 "%lld:%lld:%.2f"
+#else
+typedef long long integer;
+#define DOUT "%Ld"   
+#define FOUT "%.2f"
+#define VOUT "%.4f"
+#define HMSOUT1 "%Ld:%Ld:%Ld"
+#define HMSOUT2 "%Ld:%Ld:%.2f"
+#endif
+
+static char *dout,*fout,*vout,*hmsout1,*hmsout2;
+static integer maxint;   /* set by find_maxint() */
+
+
+#define INCR(x,inc) \
+     {if (((x) > 0 && maxint-(x) < (inc)) || ((x) < 0 && (maxint)+(x) < -(inc))) \
+           {fprintf(stderr,">E overflow with %%d or %%p format\n"); exit(1);} \
+      x += (inc);}    /*  x += inc   with safety check */
+
+typedef int boolean;
+#define FALSE 0
+#define TRUE  1
+
+typedef struct
+{
+    int nvals;
+    integer *val;
+} integerlist;
+
+typedef union
+{
+    double f;
+    integer d;
+    integerlist *l;
+#if GMP
+    mpz_t *m;
+#endif
+} number;
+
+#define D 0    /* Code for "integer" */
+#define F 1    /* Code for "real" */
+#define M 2    /* Code for "multiprecision integer" */
+#define X 3    /* Code for "integer, take maximum" */
+#define V 4    /* Code for "real, take average" */
+#define P 5    /* Code for "integer, modulo some base" */
+#define LD 6   /* Code for "list of integer" */
+#define H 8    /* Code for "h:m:s" */
+
+#define MAXLINELEN 100000   /* Maximum input line size
+                              (longer lines are broken in bits) */
+#define MAXVALUES 32  /* Maximum  total number of 
+                             %d,%x,%p,%m,%v,%f,%h or %l items in a format */
+
+#define MAXFORMATS 1000
+
+static struct fmt_st
+{
+   integer pmod;
+   int flags;
+   char *fmt;
+} format[MAXFORMATS];
+
+typedef struct countrec
+{
+    struct countrec *left,*right,*parent;
+    char *fmt;
+    unsigned long count;
+    number total[MAXVALUES];
+} countnode;
+
+static countnode *count_root[MAXFORMATS];
+static unsigned long matching_lines[MAXFORMATS];
+static integer total_position[MAXFORMATS];
+static integer lastseq[MAXFORMATS];
+
+#if GMP
+static mpz_t mp_value[MAXVALUES];
+#endif
+
+static integerlist il[MAXVALUES];
+
+#define A 0
+#define L 1
+#define R 2
+#define LL 3
+#define LR 4
+#define RL 5
+#define RR 6
+
+#ifndef GLOB_BRACE       /* Allow {} processing -- Linux extension */
+#define GLOB_BRACE 0
+#endif
+
+#ifndef GLOB_TILDE      /* Allow ~  processing -- Linux extension */
+#define GLOB_TILDE 0
+#endif
+
+#ifndef GLOB_NOMATCH
+#define GLOB_NOMATCH 0 /* Some versions don't have a special return for this */
+#endif
+
+#define GLOB_FLAGS (GLOB_ERR|GLOB_NOSORT|GLOB_BRACE|GLOB_TILDE)
+
+#define HELP if (argc > 1 && (strcmp(argv[1],"-help")==0 \
+                           || strcmp(argv[1],"--help")==0)) \
+       { printf("\nUsage: %s\n\n%s",USAGE,HELPTEXT); return 0;}
+
+/****************************************************************************/
+
+static int
+numstrcmp(char *s1, char *s2)
+/* Same behaviour as strcmp(), except that when an unsigned integer is
+   found in each string, the numerical values are compared instead of
+   the ascii values.   Overflow is impossible.  Leading spaces before
+   numbers are considered part of the numbers.  A number in one string
+   is considered less than a non-number in the other string. */
+{
+    char *a1,*a2;
+
+    while (1)
+    {
+        for (a1 = s1; *a1 == ' '; ++a1) {}
+        if (isdigit(*a1))
+        {
+            for (s1 = a1+1; isdigit(*s1); ++s1) {}
+        }
+        else 
+        {
+            a1 = s1;
+            ++s1;
+        }
+
+        for (a2 = s2; *a2 == ' '; ++a2) {}
+        if (isdigit(*a2))
+        {   
+            for (s2 = a2+1; isdigit(*s2); ++s2) {}
+        }  
+        else
+        {
+            a2 = s2;
+            ++s2;
+        }
+
+        if (!isdigit(*a1))
+        {
+            if (!isdigit(*a2))
+            {
+                if (*a1 < *a2) return -1;
+                if (*a1 > *a2) return 1;
+                if (*a1 == '\0') return 0;
+            }
+            else
+                return 1;
+        }
+        else
+        {
+            if (!isdigit(*a2))
+                return -1;
+            else
+            {
+                for (; *a1 == '0'; ++a1) {}
+                for (; *a2 == '0'; ++a2) {}
+
+                if (s1-a1 < s2-a2) return -1;
+                if (s1-a1 > s2-a2) return 1;
+                for (; a1 < s1 && *a1 == *a2; ++a1, ++a2) {}
+                if (a1 < s1)
+                {
+                    if (*a1 < *a2) return -1;
+                    else           return 1;
+                }
+            }
+        }
+    }
+}
+
+/****************************************************************************/
+
+static void
+writeline(char *outf, number *val, unsigned long count)
+/* Write an output line with the given format and values */
+{
+    int i,n;
+    integer mins,nsecs;
+    double secs,hms;
+    boolean neg;
+
+    n = 0;
+
+    for (; *outf != '\0'; ++outf)
+    {
+        if (*outf == '%')
+        {
+            ++outf;
+            if (*outf == '%' || *outf == '#')
+                putchar(*outf);
+            else if (*outf == 'd' || *outf == 'x' || *outf == 'p')
+                printf(dout,val[n++].d);
+            else if (*outf == 'f')
+                printf(fout,val[n++].f);
+            else if (*outf == 'v')
+                printf(vout,val[n++].f/count);
+	    else if (*outf == 'h')
+	    {
+		if (val[n].f < 0)
+		{
+		    neg = TRUE;
+		    hms = -val[n].f;
+		}
+		else
+		{
+		    neg = FALSE;
+		    hms = val[n].f;
+		}
+		mins = hms/60.0;
+		secs = hms - 60*mins;
+		nsecs = secs;
+		++n;
+		if (neg) printf("-");
+		if (secs == nsecs)
+		    printf(hmsout1,mins/60,mins%60,nsecs);
+		else
+		    printf(hmsout2,mins/60,mins%60,secs);
+	    }
+            else if (*outf == 'l')
+            {
+                for (i = 0; i < val[n].l->nvals; ++i)
+                {
+                    if (i > 0) printf(" ");
+                    printf(dout,val[n].l->val[i]);
+                }
+                ++n;
+            }
+#if GMP
+            else if (*outf == 'm')
+                mpz_out_str(NULL,10,*(val[n++].m));
+#endif
+            else
+            {
+                fprintf(stderr,">E unknown output format %%%c\n",*outf);
+                exit(1);
+            }
+        }
+        else
+            putchar(*outf);
+    }
+}
+
+/*********************************************************************/
+
+static void
+print_counts(countnode *root, boolean printcounts)
+/* Use a non-recursive inorder traversal to print the tree */
+{
+    int code;
+    countnode *p;
+
+    p = root;
+    code = A;
+
+    while (p)
+    {
+        switch (code)    /* deliberate flow-ons */
+        {
+         case A:
+            if (p->left)
+            {
+                p = p->left;
+                break;
+            }
+         case L:
+            if (printcounts) printf("%5lu: ",p->count);
+            writeline(p->fmt,p->total,p->count);
+            if (p->right)
+            {
+                p = p->right;
+                code = A;
+                break;
+            }
+         case R:
+            if (p->parent && p->parent->left == p) code = L;
+            else                                   code = R;
+            p = p->parent;
+            break;
+        }
+    }
+}
+
+/*********************************************************************/
+
+static void
+print_common(countnode *root)
+/* Print the common ends of the formats in the tree */
+{
+    int code;
+    countnode *p;
+    char *s0,*s1,*t0,*t1;
+    int i,comm0,comm1,minlen,maxlen;
+
+    if (root == NULL) return;
+
+    p = root;
+    code = A;
+
+    s0 = s1 = p->fmt;
+    while (*s1 != '\0') ++s1;
+    comm0 = comm1 = minlen = maxlen = s1-s0;
+
+    while (p)
+    {   
+        switch (code)    /* deliberate flow-ons */
+        {
+         case A:
+            if (p->left)
+            {   
+                p = p->left;
+                break;
+            }
+         case L:
+            t0 = t1 = p->fmt;
+            for (i = 0; i < comm0; ++i)
+                if (s0[i] != t0[i]) break;
+            comm0 = i;
+
+            while (*t1 != '\0') ++t1;
+            for (i = 1; i <= comm1; ++i)
+                if (s1[-i] != t1[-i]) break;
+            comm1 = i-1;
+            if (t1-t0 < minlen) minlen = t1-t0;
+            if (t1-t0 > maxlen) maxlen = t1-t0;
+
+            if (p->right)
+            {
+                p = p->right;
+                code = A;
+                break;
+            }
+         case R:
+            if (p->parent && p->parent->left == p) code = L;
+            else                                   code = R;
+            p = p->parent;
+            break;
+        }
+    }
+
+    if (comm0 + comm1 > minlen) comm1 = minlen - comm0;
+
+    for (i = 0; i < comm0; ++i)
+        printf("%c",s0[i]);
+    if (comm0 + comm1 < maxlen) printf("*");
+    for (i = comm1; i > 0; --i)
+        printf("%c",s1[-i]);
+}
+
+/*********************************************************************/
+
+static void
+splay(countnode *p)
+/* Splay the node p.  It becomes the new root. */
+{
+    countnode *q,*r,*s;
+    countnode *a,*b,*c;
+    int code;
+
+#define LCHILD(x,y) {(x)->left = y; if (y) (y)->parent = x;}
+#define RCHILD(x,y) {(x)->right = y; if (y) (y)->parent = x;}
+
+    while (p->parent)
+    {
+        a = p->left;
+        b = p->right;
+        q = p->parent;
+        if (q->left == p)
+        {
+            code = L;
+            c = q->right;
+        }
+        else
+        {
+            code = R;
+            c = q->left;
+        }
+        r = q->parent;
+        if (r)
+        {
+            if (r->left == q) code = (code == L ? LL : LR);
+            else              code = (code == L ? RL : RR);
+            s = r->parent;
+            p->parent = s;
+            if (s)
+            {
+                if (s->left == r) s->left = p;
+                else              s->right = p;
+            }
+        }
+        else
+        {
+            p->parent = NULL;
+        }
+        
+        switch (code)
+        {
+         case L:
+            RCHILD(p,q); LCHILD(q,b); break;
+         case R:
+            LCHILD(p,q); RCHILD(q,a); break;
+         case LL:
+            RCHILD(p,q); RCHILD(q,r); LCHILD(q,b); LCHILD(r,c); break;
+         case RR:
+            LCHILD(p,q); LCHILD(q,r); RCHILD(r,c); RCHILD(q,a); break;
+         case LR:
+            LCHILD(p,q); RCHILD(p,r); RCHILD(q,a); LCHILD(r,b); break;
+         case RL:
+            LCHILD(p,r); RCHILD(p,q); RCHILD(r,a); LCHILD(q,b); break;
+        }
+    }
+}
+
+/*********************************************************************/
+
+static void
+add_one(countnode **to_root, char *fmt, integer pmod, int nval,
+        number *val, int *valtype, int which, boolean numcompare)
+/* Add one match to the node with the given format, creating it if it is new.
+   The tree is then splayed to ensure good efficiency. */
+{
+    int i,j,cmp;
+    countnode *p,*ppar,*new_node;
+    integer w;
+
+    p = *to_root;
+    cmp = 0;
+
+    while (p != NULL)
+    {
+        cmp = (numcompare ? numstrcmp(fmt,p->fmt) : strcmp(fmt,p->fmt));
+        if (cmp == 0)
+        {
+            if (HAS(which,UNIQUE) && p->count == 1)
+                printf("ERROR: Multiple matches for %s",fmt);
+            for (i = 0; i < nval; ++i)
+                if (valtype[i] == D)
+                    {INCR(p->total[i].d,val[i].d);}
+                else if (valtype[i] == X)
+                    {if (val[i].d > p->total[i].d) p->total[i].d = val[i].d;}
+                else if (valtype[i] == P)
+                    {w = val[i].d % pmod; INCR(p->total[i].d,w);
+                      p->total[i].d %= pmod;}
+                else if (valtype[i] == LD)
+                {
+                    if (p->total[i].l->nvals < val[i].l->nvals)
+                    {
+                        if ((p->total[i].l->val
+                           = (integer*)realloc(p->total[i].l->val,
+                                          sizeof(integer)*val[i].l->nvals))
+                                == NULL)
+                        {
+                            fprintf(stderr,"Malloc failed\n");
+                            exit(1);
+                        }
+                    }
+                    for (j = 0; j < p->total[i].l->nvals &&
+                                j < val[i].l->nvals; ++j)
+                        INCR(p->total[i].l->val[j],val[i].l->val[j]);
+                    if (p->total[i].l->nvals < val[i].l->nvals)
+                    {
+                        for (j = p->total[i].l->nvals;
+                                   j < val[i].l->nvals; ++j)
+                            p->total[i].l->val[j] = val[i].l->val[j];
+                        p->total[i].l->nvals = val[i].l->nvals;
+                    }
+                }
+#if GMP
+                else if (valtype[i] == M) 
+                    mpz_add(*(p->total[i].m),*(p->total[i].m),*(val[i].m));
+#endif
+                else  
+                    p->total[i].f += val[i].f;   /* F, V and H */
+            ++p->count;
+            splay(p);
+            *to_root = p;
+            return;
+        }
+        else if (cmp < 0)
+        {
+            ppar = p;
+            p = p->left;
+        }
+        else
+        {
+            ppar = p;
+            p = p->right;
+        }
+    }
+
+    if ((new_node = (countnode*)malloc(sizeof(countnode))) == NULL)
+    {
+        fprintf(stderr,">E malloc failed in add_one()\n");
+        exit(1);
+    }
+
+    if ((new_node->fmt = (char*)malloc(strlen(fmt)+1)) == NULL)
+    {
+        fprintf(stderr,">E malloc failed in add_one()\n");
+        exit(1);
+    }
+
+    new_node->count = 1;
+    strcpy(new_node->fmt,fmt);
+    for (i = 0; i < nval; ++i)
+    {
+#if GMP
+        if (valtype[i] == M)
+        {
+            if ((new_node->total[i].m
+                                = (mpz_t*)malloc(sizeof(mpz_t))) == NULL)
+            {
+                fprintf(stderr,"Malloc failed\n");
+                exit(1);
+            }
+            mpz_init_set(*(new_node->total[i].m),*(val[i].m));
+        }
+        else
+#endif
+        if (valtype[i] == LD)
+        {
+            if ((new_node->total[i].l
+                        = (integerlist*)malloc(sizeof(integerlist))) == NULL)
+            {  
+                fprintf(stderr,"Malloc failed\n");
+                exit(1);
+            }
+            if ((new_node->total[i].l->val
+                 = (integer*)malloc(sizeof(integer)*val[i].l->nvals)) == NULL)
+            {  
+                fprintf(stderr,"Malloc failed\n");
+                exit(1);
+            }
+            new_node->total[i].l->nvals = val[i].l->nvals;
+            for (j = 0; j < val[i].l->nvals; ++j)
+                new_node->total[i].l->val[j] = val[i].l->val[j];
+        }
+        else
+            new_node->total[i] = val[i];
+    }
+
+    new_node->left = new_node->right = NULL;
+
+    if (cmp == 0)
+    {
+        *to_root = new_node;
+        new_node->parent = NULL;
+    }
+    else if (cmp < 0)
+    {
+        ppar->left = new_node;
+        new_node->parent = ppar;
+    }
+    else
+    {
+        ppar->right = new_node;
+        new_node->parent = ppar;
+    }
+
+    splay(new_node);
+    *to_root = new_node;
+}
+
+/****************************************************************************/
+
+static int
+scanline(char *s, char *f, number *val, int *valtype,
+         integer *seqno, char *outf)
+/* Perform sscanf-like scan of line.
+   The whole format must match.  outf is set to be an output format
+   with unassigned values replaced by '*' and %s replaced by what
+   it matches.  Assigned values except %s are put into val[] with
+   their types in valtype[].  The number of values (not counting %#)
+   is returned. 
+   Integers matching %# are put into *seqno, with an error if there
+   are more than one, and -1 if there are none.
+   If the format doesn't match, -1 is returned.
+   WARNING: the gmp and ilist values are pointers to static data,
+   so they need to be copied if the values array is copied.
+   See the comments at the start of the program for more information.
+*/
+{
+    int n;                   /* Number of values assigned */
+    int digit;
+    boolean doass,neg,oflow,badgmp;
+    integer ival;
+    double dval,digval,comval;
+    char ends,*saves;
+    static boolean gmp_warning = FALSE;
+    integer *ilist;
+    size_t ilist_sz;
+    int nilist;
+#if GMP
+    char mp_line[MAXLINELEN+1],*mp;
+#endif
+        
+    n = 0;
+    *seqno = -1;
+    badgmp = oflow = FALSE;
+
+    while (*f != '\0')
+    {
+        if (*f == '%')
+        {
+            ++f;
+            if (*f == '*')
+            {
+                doass = FALSE;
+                ++f;
+            }
+            else
+                doass = TRUE;
+
+            if (*f == '%')
+            {
+                if (!doass)
+                {
+                    fprintf(stderr,"Bad format item %%*\n");
+                    exit(1);
+                }
+                if (*s++ != '%') return -1;
+                ++f;
+                *outf++ = '%';
+                *outf++ = '%';
+            }
+            else if (*f == '\n')
+            {
+                if (!doass)
+                {
+                    fprintf(stderr,"Bad format item %%*\n");
+                    exit(1);
+                }
+                while (*s != '\0')
+                {
+                    if (*s != ' ' && *s != '\n') return -1;
+                    ++s;
+                }
+                --s;
+            }
+            else if (*f == 'c')
+            {   
+                if (*s == ' ' || *s == '\t' || *s == '\n') return -1;
+                if (doass) *outf++ = *s;
+                else       *outf++ = '*';
+                ++f;
+                ++s;
+            }
+            else if (*f == 's')
+            {
+                ends = *(f+1);
+                if (ends == ' ')
+                {
+                    while (*s == ' ' || *s == '\t')
+                    {
+                        if (doass) *outf++ = *s;
+                        ++s;
+                    }
+                }
+                while (*s != '\n' && *s != ends)
+                {
+                    if (doass) *outf++ = *s;
+                    ++s;
+                }
+                if (!doass) *outf++ = '*';
+                ++f;
+            }
+#if GMP         
+            else if (*f == 'd' || *f == 'x' || *f == 'p')
+            {
+#else
+            else if (*f == 'd' || *f == 'x' || *f == 'p' || *f == 'm')
+            {
+                if (*f == 'm' && !gmp_warning)
+                {
+                    fprintf(stderr,
+                     ">W not compiled with GMP, treating %%m like %%d\n");
+                    gmp_warning = TRUE;
+                }
+#endif
+                while (*s == ' ' || *s == '\t') ++s;
+                if (!isdigit(*s) && *s != '-' && *s != '+') return -1;
+                neg = (*s == '-');
+                if (*s == '-' || *s == '+') ++s;
+                ival = 0;
+                while (isdigit(*s))
+                {
+                    digit =  *s++ - '0';
+                    if (ival > (maxint-digit)/10)
+                        oflow = TRUE;
+                    else
+                        ival = ival*10 + digit;
+                }
+                if (doass)
+                {
+                    *outf++ = '%';
+                    if (*f == 'd' || *f == 'm')
+                    {
+                        *outf++ = 'd';
+                        valtype[n] = D;
+                    }
+                    else if (*f == 'x')
+                    {
+                        *outf++ = 'x';
+                        valtype[n] = X;
+                    }
+                    else
+                    {
+                        *outf++ = 'p';
+                        valtype[n] = P;
+                    }
+                    val[n++].d = (neg ? -ival : ival);
+                }
+                else
+                    *outf++ = '*';
+                ++f;
+            }
+            else if (*f == 'l')
+            {
+                nilist = 0;
+                if ((ilist = (integer*)malloc(200*sizeof(integer)))
+                            == NULL)
+                {
+                    fprintf(stderr,"Malloc failed\n");
+                    exit(1);
+                }
+                ilist_sz = 200;
+                for (;;)
+                {
+                    saves = s;
+                    while (*s == ' ' || *s == '\t') ++s;
+                    if (!isdigit(*s) && *s != '-' && *s != '+')
+                    {
+                        s = saves;
+                        break;
+                    }
+                    neg = (*s == '-');
+                    if (*s == '-' || *s == '+') ++s;
+                    ival = 0;
+                    while (isdigit(*s))
+                    {
+                        digit =  *s++ - '0';
+                        if (ival > (maxint-digit)/10)
+                            oflow = TRUE;
+                        else
+                            ival = ival*10 + digit;
+                    }
+                    if (neg) ival = -ival;
+                    if (nilist == ilist_sz)
+                    {
+                        if ((ilist
+                            = (integer*)realloc((void*)ilist,
+                                       (ilist_sz+500)*sizeof(integer)))
+                                == NULL)
+                        {
+                            fprintf(stderr,"Malloc failed\n");
+                            exit(1);
+                        }
+                        ilist_sz += 500;
+                    }
+                    ilist[nilist++] = ival;
+                }
+                if (doass)
+                {
+                    valtype[n] = LD;
+                    val[n].l = &il[n];
+                    val[n].l->nvals = nilist;
+                    if (val[n].l->val) free(val[n].l->val);
+                    val[n].l->val = ilist;
+                    ++n;
+                    *outf++ = '%';
+                    *outf++ = 'l';
+                }
+                else
+                {
+                    free(ilist);
+                    *outf++ = '*';
+                }
+                ++f;
+            }
+#if GMP
+            else if (*f == 'm')
+            {
+                while (*s == ' ' || *s == '\t') ++s;        
+                if (!isdigit(*s) && *s != '-' && *s != '+') return -1;
+                mp = mp_line;
+                if      (*s == '-') *mp++ = *s++;
+                else if (*s == '+') s++;
+                while (isdigit(*s)) *mp++ = *s++;
+                *mp = '\0'; 
+                if (doass)
+                {
+                    valtype[n] = M;
+                    val[n].m = &mp_value[n];
+                    if (mpz_set_str(mp_value[n],mp_line,10) < 0)
+                        badgmp = TRUE;
+                    ++n;
+                    *outf++ = '%';
+                    *outf++ = 'm';
+                }
+                else
+                    *outf++ = '*';
+                ++f;
+            }
+#endif
+            else if (*f == '#')
+            {
+                while (*s == ' ' || *s == '\t') ++s;
+                if (!isdigit(*s)) return -1;
+                ival = 0;
+                while (isdigit(*s))
+                {
+                    digit =  *s++ - '0';
+                    if (ival > (maxint-digit)/10)
+                        oflow = TRUE;
+                    else
+                        ival = ival*10 + digit;
+                }
+                if (*seqno >= 0)
+                {
+                    fprintf(stderr, 
+                            ">E %%# can only be used once per format\n");
+                    exit(1);
+                }
+                *seqno = ival;
+                *outf++ = '#';
+                ++f;
+            }
+            else if (*f == 'f' || *f == 'v')
+            {
+                while (*s == ' ' || *s == '\t') ++s;
+
+                if (!isdigit(*s) && *s != '.' && *s != '-' && *s != '+')
+                    return -1;
+                neg = (*s == '-');
+                if (*s == '-' || *s == '+') ++s;
+                dval = 0.0;
+                while (isdigit(*s)) dval = dval*10.0 + (*s++ - '0');
+                if (*s == '.')
+                {
+                    digval = 1.0;
+                    ++s;
+                    while (isdigit(*s))
+                    {
+                        digval /= 10.0;
+                        dval += (*s++ - '0') * digval;
+                    }
+                }
+                if (doass)
+                {
+                    valtype[n] = (*f == 'f' ? F : V);
+                    val[n++].f = (neg ? -dval : dval);
+                    *outf++ = '%';
+                    *outf++ = *f;
+                }
+                else
+                    *outf++ = '*';
+                ++f;
+            }
+            else if (*f == 'h')
+            {
+                while (*s == ' ' || *s == '\t') ++s;
+
+                if (!isdigit(*s) && *s != '.' && *s != '-' && *s != '+' && *s != ':')
+                    return -1;
+                neg = (*s == '-');
+                if (*s == '-' || *s == '+') ++s;
+                dval = 0.0;
+		comval = 0.0;
+                while (isdigit(*s) || *s == ':')
+		{
+		    if (*s == ':')
+		    {
+			dval = dval*60.0 + comval;
+			comval = 0.0;
+			++s;
+		    }
+		    else
+		        comval = comval*10.0 + (*s++ - '0');
+		}
+                if (*s == '.')
+                {
+                    digval = 1.0;
+                    ++s;
+                    while (isdigit(*s))
+                    {
+                        digval /= 10.0;
+                        comval += (*s++ - '0') * digval;
+                    }
+                }
+		dval = dval*60.0 + comval;
+                if (doass)
+                {
+                    valtype[n] = H;
+                    val[n++].f = (neg ? -dval : dval);
+                    *outf++ = '%';
+                    *outf++ = *f;
+                }
+                else
+                    *outf++ = '*';
+                ++f;
+            }
+            else if (*f == ' ')
+            {
+                while (*s == ' ' || *s == '\t') ++s;
+                *outf++ = ' ';
+                ++f;
+            }
+            else
+            {
+                fprintf(stderr,"Bad format item %%%c\n",*f);
+                exit(1);
+            }
+        }
+        else
+        {
+            if (*s != *f) return -1;
+            *outf++ = *f;
+            ++s;
+            ++f;
+        }
+    }
+
+    if (*s != '\0') return -1;
+
+    *outf = '\0';
+
+    if (oflow)
+    {
+        fprintf(stderr,"Integer too large\n");
+        exit(1);
+    }
+    if (badgmp)
+    {
+        fprintf(stderr,"Illegal multiprecision integer\n");
+        exit(1);
+    }
+
+    return n;
+}
+
+/****************************************************************************/
+
+void
+find_maxint(void)
+{
+/* Put the maximum possible integer value into maxint. */
+/* New version with no integer overflow. */
+    integer x,y;
+
+    x = ((integer)1) << (8*sizeof(integer) - 2);
+    y = x - 1;
+    x += y;
+
+    if (x <= 0)
+    {
+        fprintf(stderr,">E find_maxint() failed\n");
+        exit(1);
+    }
+
+    maxint = x;
+}
+
+/****************************************************************************/
+
+static void
+sort_formats(int *order, int numformats)
+/* Make order[0..numformats-1] a permutation of 0..numformats-1 being
+   a good order to display the results. */
+{
+    double score[MAXFORMATS];
+    int h,i,j,iw;
+
+    for (i = 0; i < numformats; ++i)
+    {
+        if (matching_lines[i] == 0)
+            score[i] = -1.0;
+        else
+            score[i] = i +
+               ((100.0*total_position[i]) / matching_lines[i]) * numformats;
+        order[i] = i;
+    }
+
+    j = numformats / 3;
+    h = 1;
+    do
+        h = 3 * h + 1;
+    while (h < j);
+
+    do
+    {
+        for (i = h; i < numformats; ++i)
+        {
+            iw = order[i];
+            for (j = i; score[order[j-h]] > score[iw]; )
+            {
+                order[j] = order[j-h];
+                if ((j -= h) < h) break;
+            }
+            order[j] = iw;
+        }
+        h /= 3;
+    }
+    while (h > 0);
+}
+
+/****************************************************************************/
+
+static void
+read_formats(char *filename, int *numformatsp, boolean mustexist)
+/* Read formats from the given file. */
+{
+    FILE *f;
+    int i,c,flags,ignore;  
+    char flagname[52];
+    char line[MAXLINELEN+3];
+    integer pmod;
+    char *s;
+    boolean oflow,badpmod;
+    int digit;
+
+    if (strcmp(filename,"-") == 0)
+        f = stdin;
+    else if ((f = fopen(filename,"r")) == NULL)
+    {
+        if (mustexist)
+        {
+            fprintf(stderr,">E Can't open %s for reading.\n",filename);
+            exit(1);
+        }
+        return;
+    }
+
+    line[MAXLINELEN+2] = '\0';
+
+    for (;;)
+    {
+        if ((c = getc(f)) == EOF) break;
+
+        while (c == ' ' || c == '\t') c = getc(f);
+        if (c == '\n') continue;
+        if (c == EOF) break;
+        
+        if (c == '#')
+        {
+            while (c != '\n' && c != EOF) c = getc(f);
+            continue;
+        }
+
+        ungetc(c,f);
+
+        flags = 0;
+        pmod = 2;
+        for (;;)
+        {
+            while ((c = getc(f)) == ' '
+                                || c == '|' || c == ',' || c == '\t') {}
+            if (c == '#')
+                while (c != '\n' && c != EOF) c = getc(f);
+            if (c == '\n' || c == EOF) break;
+
+            ungetc(c,f);
+
+         /* There appear to be some issues with the [ flag in fscanf,
+          * as to whether a null is appended.  We'll take no chances. */
+            for (i = 0; i < 52; ++i) flagname[i] = '\0';
+            ignore = fscanf(f,"%50[A-Za-z0-9=]",flagname);
+
+            if      (strcmp(flagname,"DEFAULT") == 0)  {}
+            else if (strcmp(flagname,"FINAL") == 0)    flags |= FINAL;
+            else if (strcmp(flagname,"ERROR") == 0)    flags |= ERROR;
+            else if (strcmp(flagname,"UNIQUE") == 0)   flags |= UNIQUE;
+            else if (strcmp(flagname,"COUNT") == 0)    flags |= COUNT;
+            else if (strcmp(flagname,"CONTINUE") == 0) flags |= CONTINUE;
+            else if (strcmp(flagname,"NUMERIC") == 0)  flags |= NUMERIC;
+            else if (strcmp(flagname,"SILENT") == 0)   flags |= SILENT;
+            else if (strcmp(flagname,"ENDFILE") == 0)  flags |= ENDFILE;
+            else if (flagname[0] == 'P' && flagname[1] == '=')
+            {
+                pmod = 0;
+                oflow = FALSE;
+                badpmod = (flagname[2] == '\0');
+                for (s = flagname+2; *s != '\0'; ++s)
+                {
+                    if (isdigit(*s))
+                    {
+                        digit =  *s - '0';
+                        if (pmod > (maxint-digit)/10)
+                            oflow = TRUE;
+                        else
+                            pmod = pmod*10 + digit;
+                    }
+                    else
+                        badpmod = TRUE;
+                }
+                if (badpmod)
+                {
+                    fprintf(stderr,">E Bad value for P= directive: %s\n",
+                            flagname+2);
+                    exit(1);
+                }
+                else if (oflow)
+                {
+                    fprintf(stderr,">E Value for P= is too large\n");
+                    exit(1);
+                }
+    
+            }
+            else
+            {
+                fprintf(stderr,">E Unknown flag \"%s\" in %s\n",
+                               flagname,filename);
+                exit(1);
+            }
+        }
+
+        if (fgets(line,MAXLINELEN,f) == NULL)
+        {
+            fprintf(stderr,">E Missing format in %s\n",filename);
+            exit(1);
+        }
+
+        for (i = 0; i < *numformatsp; ++i)
+            if (strcmp(line,format[i].fmt) == 0) break;
+        if (i < *numformatsp) continue;
+
+        if (*numformatsp == MAXFORMATS)
+        {
+            fprintf(stderr,">E Increase MAXFORMATS\n");
+            exit(1);
+        }
+
+        format[*numformatsp].flags = flags;
+        format[*numformatsp].pmod = pmod;
+        if ((format[*numformatsp].fmt
+                            = (char*)malloc(strlen(line)+1)) == NULL)
+        {
+            fprintf(stderr,">E malloc() failed in read_formats()\n");
+            exit(1);
+        }
+        strcpy(format[*numformatsp].fmt,line);
+        ++*numformatsp;
+    }
+
+    if (f != stdin) fclose(f);
+}
+
+/****************************************************************************/
+
+static void
+read_local_formats(int *numformatsp)
+/* Read formats from sumlines.fmt in current directory */
+{
+        read_formats("sumlines.fmt",numformatsp,FALSE);
+}
+
+/****************************************************************************/
+
+static void
+read_global_formats(int *numformatsp)
+/* Read formats from sumlines.fmt in home directory */
+{
+    struct passwd *pwd;
+    char *homedir;
+    char filename[4097];
+
+    homedir = getenv("HOME");
+    if (homedir == NULL && (pwd = getpwuid(getuid())) != NULL)
+        homedir = pwd->pw_dir;
+
+    if (homedir == NULL)
+    {
+        fprintf(stderr,">W Can't find home directory\n");
+        return;
+    }
+
+    sprintf(filename,"%s/sumlines.fmt",homedir);
+    read_formats(filename,numformatsp,FALSE);
+}
+
+/****************************************************************************/
+
+static void
+read_env_formats(int *numformatsp)
+/* Read formats from $SUMLINES.FMT if it exists */
+{
+    char *filename;
+
+    if ((filename = getenv("SUMLINES.FMT")) != 0)
+        read_formats(filename,numformatsp,FALSE);
+}
+
+/****************************************************************************/
+
+static boolean
+readoneline(FILE *f, char *line, int size, int *nulls)
+/* Get a line.  Read at most size-1 chars until EOF or \n.
+   If \n is read, it is stored.  Then \0 is appended.
+   *nulls is set to the number of NUL chars (which are also stored). */
+{
+    int i,c;
+
+    *nulls = 0;
+    for (i = 0; i < size-1; ++i)
+    {
+        c = getc(f);
+        if (c == EOF) break;
+        line[i] = c;
+        if (c == '\0') ++*nulls;
+        if (c == '\n') {++i; break;}
+    }
+    line[i] = '\0';
+
+    return i > 0;
+}
+
+/****************************************************************************/
+
+static int
+pnumstrcmp(const void *a, const void *b)
+/* numstrcmp on strings pointed at by a and b */
+{
+    return numstrcmp(*(char**)a,*(char**)b);
+}
+
+/****************************************************************************/
+
+static void
+doglob(char *patt, glob_t *globlk)
+/* Find all files matching the given pattern, numeric sorting.
+   Give a warning message if there are none. */
+{
+    int ret;
+
+    ret = glob(patt,GLOB_FLAGS,NULL,globlk);
+
+    if (ret != 0) globlk->gl_pathc = 0;
+
+    if (ret == GLOB_NOSPACE)
+    {
+        fprintf(stderr,"ERROR: ran out of space during glob()\n");
+        exit(1);
+    }
+    if (ret == GLOB_ERR)
+    {
+        fprintf(stderr,"ERROR: during glob(%s)\n",patt);
+        exit(1);
+    }
+    if (ret != 0 && ret != GLOB_NOMATCH)
+    {
+        fprintf(stderr,"ERROR: value %d from glob(%s)\n",ret,patt);
+        exit(1);
+    }
+
+
+    if (globlk->gl_pathc == 0) printf("WARNING: no files match %s\n",patt);
+    
+    if (globlk->gl_pathc >= 2)
+        qsort(globlk->gl_pathv,globlk->gl_pathc,sizeof(char*),pnumstrcmp);
+}
+
+/****************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    int i,j,nvals,argnum;
+    number val[MAXVALUES];
+    int valtype[MAXVALUES];
+    char line[MAXLINELEN+2];
+    char outf[MAXLINELEN+MAXVALUES+6];
+    unsigned long matched,unmatched,finalmatched;
+    unsigned long errorlines,totalerrorlines;
+    unsigned long line_number,nullcount,numfiles,ifile;
+    char *filename;
+    FILE *infile;
+    int numformats,firstarg,nulls;
+    boolean havefinal,nowarn,noWarn,listformats,readfiles;
+    integer seq;
+    int order[MAXFORMATS];
+    glob_t globlk,globlk_stdin,*pglob;
+    char *glob_stdin_v[2];
+    boolean printcounts;
+
+    HELP;
+
+    find_maxint();
+
+    firstarg = 1;
+    numformats = 0;
+    nowarn = noWarn = FALSE;
+    listformats = FALSE;
+    readfiles = TRUE;
+    printcounts = TRUE;
+
+    globlk_stdin.gl_pathc = 1;
+    globlk_stdin.gl_pathv = glob_stdin_v;
+    glob_stdin_v[0] = "-";
+    glob_stdin_v[1] = NULL;
+
+    dout = DOUT;
+    fout = FOUT;
+    vout = VOUT;
+    hmsout1 = HMSOUT1;
+    hmsout2 = HMSOUT2;
+
+    for (; firstarg < argc; ++firstarg)
+    {
+        if (argv[firstarg][0] == '-' && argv[firstarg][1] == 'f')
+        {
+            if (argv[firstarg][2] != '\0')
+                read_formats(&argv[firstarg][2],&numformats,TRUE);
+            else if (firstarg == argc - 1)
+            {
+                fprintf(stderr,">E No argument for -f\n");
+                exit(1);
+            }
+            else
+            {
+                ++firstarg;
+                read_formats(argv[firstarg],&numformats,TRUE);
+            }
+        }
+        else if (strcmp(argv[firstarg],"-W") == 0)
+            noWarn = TRUE;
+        else if (strcmp(argv[firstarg],"-w") == 0)
+            nowarn = TRUE;
+        else if (strcmp(argv[firstarg],"-v") == 0)
+            listformats = TRUE;
+        else if (strcmp(argv[firstarg],"-d") == 0)
+            readfiles = FALSE;
+        else if (strcmp(argv[firstarg],"-n") == 0)
+            printcounts = FALSE;
+        else if (strcmp(argv[firstarg],"-V") == 0)
+            vout = argv[++firstarg];
+        else if (strcmp(argv[firstarg],"-F") == 0)
+            fout = argv[++firstarg];
+        else if (strcmp(argv[firstarg],"-D") == 0)
+            dout = argv[++firstarg];
+        else
+            break;
+    }
+
+#if GMP
+    for (i = 0; i < MAXVALUES; ++i) mpz_init(mp_value[i]);
+#endif
+    for (i = 0; i < MAXVALUES; ++i) 
+    {
+        il[i].nvals = 0;
+        il[i].val = NULL;
+    }
+
+    if (noWarn) nowarn = TRUE;
+
+    if (readfiles) read_local_formats(&numformats);
+    if (readfiles) read_env_formats(&numformats);
+    if (readfiles) read_global_formats(&numformats);
+
+    if (listformats)
+    {
+        printf("%d formats:\n",numformats);
+        for (i = 0; i < numformats; ++i)
+            printf("%03x %s",format[i].flags,format[i].fmt);
+    }
+
+    if (numformats == 0)
+    {
+        fprintf(stderr,">E No formats\n");
+        exit(1);
+    }
+
+    havefinal = FALSE;
+    for (i = 0; i < numformats; ++i)
+    {
+        count_root[i] = NULL;
+        matching_lines[i] = 0;
+        total_position[i] = 0;
+        if (HAS(i,FINAL)) havefinal = TRUE;
+    }
+
+    unmatched = totalerrorlines = 0;
+    numfiles = 0;
+
+    for (argnum = firstarg;
+         argnum < (argc == firstarg ? argc+1 : argc); ++argnum)
+    {
+        if (argnum >= argc || strcmp(argv[argnum],"-") == 0)
+            pglob = &globlk_stdin;
+        else
+        {
+            pglob = &globlk;
+            doglob(argv[argnum],pglob);
+        }
+
+        for (ifile = 0; ifile < pglob->gl_pathc; ++ifile)
+        {
+            matched = finalmatched = errorlines = 0;
+            ++numfiles;
+
+            if (strcmp(pglob->gl_pathv[ifile],"-") == 0)
+            {
+                filename = "stdin";
+                infile = stdin;
+            }
+            else
+            {
+                filename = pglob->gl_pathv[ifile];
+                if ((infile = fopen(filename,"r")) == NULL)
+                {
+                    fprintf(stderr,">E Can't open %s\n",filename);
+                    exit(1);
+                }
+            }
+
+            line_number = 0;
+            nullcount = 0;
+            while (readoneline(infile,line,MAXLINELEN,&nulls))
+            {
+                nullcount += nulls;
+                line[MAXLINELEN] = '\n';
+                line[MAXLINELEN+1] = '\0';
+                if (line[0] == '\n') continue;
+                ++line_number;
+    
+                for (i = 0; i < numformats; ++i)
+                {
+                    nvals
+                      = scanline(line,format[i].fmt,val,valtype,&seq,outf);
+                    if (nvals >= 0)
+                    {
+                        if (HAS(i,ENDFILE)) line_number = 0;
+                        ++matched;
+                        if (HAS(i,FINAL)) ++finalmatched;
+                        if (HAS(i,ERROR)) ++errorlines;
+                        ++matching_lines[i];
+                        total_position[i] += line_number;
+                        add_one(&count_root[i],outf,format[i].pmod,nvals,
+                             val,valtype,i,HAS(i,NUMERIC));
+                        if (!noWarn && matching_lines[i] > 1 && seq >= 0 
+                                               && seq != lastseq[i]+1)
+                        {
+                            printf("WARNING: Sequence number");
+                            if (seq == lastseq[i])
+                            {   
+                                printf(" ");
+                                printf(dout,seq);
+                                printf(" is repeated.\n");
+                            }
+                            else if (seq != lastseq[i]+2)
+                            {
+                                printf("s ");
+                                printf(dout,lastseq[i]+1);
+                                printf("-");
+                                printf(dout,seq-1);
+                                printf(" are missing.\n");
+                            }
+                            else
+                            {
+                                printf("  ");
+                                printf(dout,seq-1);
+                                printf(" is missing.\n");
+                            }
+                        }
+                        lastseq[i] = seq;
+                        if (!HAS(i,CONTINUE)) break;
+                    }
+                }
+    
+                if (i == numformats) ++unmatched;
+            }
+            if (errorlines != 0)
+                printf("ERRORS: Error lines in file %s\n",filename);
+            else if (matched == 0 && !nowarn)
+                printf("WARNING: No matching lines in file %s\n",filename);
+            else if (finalmatched == 0 && havefinal && !nowarn)
+                printf("WARNING: No final lines in file %s\n",filename);
+            if (nullcount > 0)
+                printf("WARNING: %ld NULs found in file %s\n",
+                                                        nullcount,filename);
+            if (infile != stdin) fclose(infile);
+
+            totalerrorlines += errorlines;
+        }
+        if (pglob == &globlk) globfree(pglob);
+    }
+
+    sort_formats(order,numformats);
+
+    for (j = 0; j < numformats; ++j)
+    {
+        i = order[j];
+        if (HAS(i,SILENT)) continue;
+
+        if (HAS(i,COUNT))
+        {
+            if (matching_lines[i] > 0)
+                printf("%5lu lines matched ",matching_lines[i]);
+            print_common(count_root[i]);
+        }
+        else
+            print_counts(count_root[i],printcounts);
+    }
+
+    if (unmatched > 0)
+        printf("%5lu non-empty lines not matched\n",unmatched);
+    if (argc > firstarg) printf("%5lu files read altogether\n",numfiles);
+    if (totalerrorlines > 0) printf("%5lu errors found\n",totalerrorlines);
+
+    exit(0);
+}
diff --git a/lib/nauty/testg.c b/lib/nauty/testg.c
new file mode 100644
index 0000000..4202948
--- /dev/null
+++ b/lib/nauty/testg.c
@@ -0,0 +1,1095 @@
+/* testg.c : Find properties of graphs.  This is the source file for
+   both pickg (select by property) and countg (count by property).
+   Version 1.5 of October 1, 2015. */
+/* TODO - write a header if input has one */
+
+#define USAGE \
+  "[pickg|countg] [-fp#:#q -V] [--keys] [-constraints -v] [ifile [ofile]]"
+
+#define HELPTEXT \
+" countg : Count graphs according to their properties.\n\
+  pickg : Select graphs according to their properties.\n\
+\n\
+  ifile, ofile : Input and output files.\n\
+        '-' and missing names imply stdin and stdout.\n\
+\n\
+  Miscellaneous switches:\n\
+     -p# -p#:#   Specify range of input lines (first is 1)\n\
+		 May fail if input is incremental.\n\
+     -f          With -p, assume input lines of fixed length\n\
+                        (only used with a file in graph6/digraph6 format)\n\
+     -v          Negate all constraints\n\
+     -V          List properties of every input matching constraints.\n\
+     -l          Put a blank line whenever the first parameter changes,\n\
+                    if there are at least two parameters.\n\
+     -q          Suppress informative output.\n\
+\n\
+  Constraints:\n\
+     Numerical constraints (shown here with following #) can take\n\
+     a single integer value, or a range like #:#, #:, or :#.  Each\n\
+     can also be preceded by '~', which negates it.   (For example,\n\
+     -~D2:4 will match any maximum degree which is _not_ 2, 3, or 4.)\n\
+     Constraints are applied to all input graphs, and only those\n\
+     which match all constraints are counted or selected.\n\
+\n\
+     -n#  number of vertices           -e#  number of edges\n\
+     -L#  number of loops              -C   strongly connected\n\
+     -d#  minimum (out-)degree         -D#  maximum (out-)degree\n\
+     -m#  vertices of min (out-)degree -M#  vertices of max (out-)degree\n\
+     -u#  minimum (in-)degree          -U#  maximum (in-)degree\n\
+     -s#  vertices of min (out-)degree -S#  vertices of max (out-)degree\n\
+     -r   regular                      -b   bipartite\n\
+     -z#  radius                       -Z#  diameter\n\
+     -g#  girth (0=acyclic)            -Y#  total number of cycles\n\
+     -T#  number of triangles          -K#  number of maximal cliques\n\
+     -B#  smallest side of some bipartition (0 if none)\n\
+     -H#  number of induced cycles\n\
+     -E   Eulerian (all degrees are even, connectivity not required)\n\
+     -a#  group size  -o# orbits  -F# fixed points  -t vertex-transitive\n\
+     -c#  connectivity (only implemented for 0,1,2).\n\
+     -i#  min common nbrs of adjacent vertices;     -I# maximum\n\
+     -j#  min common nbrs of non-adjacent vertices; -J# maximum\n\
+\n\
+  Sort keys:\n\
+     Counts are made for all graphs passing the constraints.  Counts\n\
+     are given separately for each combination of values occurring for\n\
+     the properties listed as sort keys.  A sort key is introduced by\n\
+     '--' and uses one of the letters known as constraints.  These can\n\
+     be combined:  --n --e  --r  is the same as --ne --r and --ner.\n\
+     The order of sort keys is significant.\n\
+  The output format matches the input, except that sparse6 is used\n\
+  to output an incremental graph whose predecessor is not output.\n"
+
+
+#include "gtools.h"
+#include "gutils.h"
+#include "nautinv.h"
+
+/*
+Available letters: hkwxy AGNOPWX
+
+How to add a new property:
+
+ 1. Add entries to constraint[], following the examples there.
+    If several things are computed at the same time, link them
+    together such as for z and Z.  It doesn't matter which is
+    first, provided the prereq field points to the first one.
+   
+ 2. Add code to compute() to compute the value(s) of the parameter.
+    Probably this means calling an external procedure then setting
+    some VAL() and COMPUTED() values.
+
+ 3. Update HELPTEXT.
+
+External user-defined parameters:
+  A general integer-valued parameter can be compiled into this program
+  if USERDEF is defined as the function name at compile time.  In this
+  case the parameter is selected using the letter 'Q'.  The name of the
+  parameter is "userdef" unless USERDEFNAME is defined.  The function
+  is called with the parameters (graph *g, int m, int n) and must return
+  an int value.  If it works also for digraphs, also define
+  USERDEFDIGRAPH (with any value).
+
+  Alternatively, use LUSERDEF for a function returning a long int.
+  You can't use both USERDEF and LUSERDEF; choose one.
+
+How the program tells if it is a picker or counter or both:
+  > If either DOPICK or DOCOUNT is defined (or both), that determines
+    the nature of the program regardless of its name.
+  > If neither DOPICK nor DOCOUNT are defined, the nature is determined
+    by which of the strings "pick" and "count" occur in the last part of
+    the program name (the part after the final "/" if any).
+  > It is an error if none of these rules provide a nature.
+*/
+
+#if defined(USERDEF) && defined(LUSERDEF)
+#error It is not allowed to define both USERDEF and LUSERDEF.
+#endif 
+
+#ifdef USERDEF
+int USERDEF(graph*,int,int);
+#endif
+
+#ifdef LUSERDEF
+long LUSERDEF(graph*,int,int);
+#endif
+
+#ifndef USERDEFNAME
+#define USERDEFNAME "userdef"
+#endif
+
+#if defined(USERDEFDIGRAPH) || defined(LUSERDEFDIGRAPH)
+#define QDIGRAPH TRUE
+#else
+#define QDIGRAPH FALSE
+#endif
+
+/**********************************************************************/
+
+#define BOOLTYPE 0
+#define INTTYPE 1
+#define GROUPSIZE 2
+#define INTVECTOR 3  /* Don't use (yet). */
+
+#undef CMASK
+#define CMASK(i) (1UL << (i))
+
+static struct constraint_st    /* Table of Constraints */
+{
+    char symbol;
+    boolean digraphok;   /* Can be computed for digraphs */
+    int needed;     /* 1 = sortkey, 2 = constraint; 3 = both */
+    boolean computed;
+    boolean inverse;
+    unsigned long prereq;    /* Must be earlier, must be <= bits in long */
+    long lo,hi;
+    char *id;
+    int valtype;
+    long val;
+} constraint[] = {
+#define I_n 0
+   {'n',TRUE,0,FALSE,FALSE,0,-NOLIMIT,NOLIMIT,"n",INTTYPE,0}, /* always known */
+#define I_e 1
+   {'e',TRUE,0,FALSE,FALSE,0,-NOLIMIT,NOLIMIT,"e",INTTYPE,0},
+#define I_L 2
+   {'L',TRUE,0,FALSE,FALSE,CMASK(I_e),-NOLIMIT,NOLIMIT,"loops",INTTYPE,0},
+#define I_d 3
+   {'d',TRUE,0,FALSE,FALSE,CMASK(I_e),-NOLIMIT,NOLIMIT,"mindeg",INTTYPE,0},
+#define I_D 4
+   {'D',TRUE,0,FALSE,FALSE,CMASK(I_e),-NOLIMIT,NOLIMIT,"maxdeg",INTTYPE,0},
+#define I_u 5
+   {'u',TRUE,0,FALSE,FALSE,CMASK(I_e),-NOLIMIT,NOLIMIT,"minindeg",INTTYPE,0},
+#define I_U 6
+   {'U',TRUE,0,FALSE,FALSE,CMASK(I_e),-NOLIMIT,NOLIMIT,"maxindeg",INTTYPE,0},
+#define I_m 7
+   {'m',TRUE,0,FALSE,FALSE,CMASK(I_e),-NOLIMIT,NOLIMIT,"minverts",INTTYPE,0},
+#define I_M 8
+   {'M',TRUE,0,FALSE,FALSE,CMASK(I_e),-NOLIMIT,NOLIMIT,"maxverts",INTTYPE,0},
+#define I_s 9
+   {'s',TRUE,0,FALSE,FALSE,CMASK(I_e),-NOLIMIT,NOLIMIT,"mininverts",INTTYPE,0},
+#define I_S 10
+   {'S',TRUE,0,FALSE,FALSE,CMASK(I_e),-NOLIMIT,NOLIMIT,"maxinverts",INTTYPE,0},
+#define I_E 11
+   {'E',TRUE,0,FALSE,FALSE,CMASK(I_e),-NOLIMIT,NOLIMIT,"eulerian",BOOLTYPE,0},
+#define I_r 12
+   {'r',TRUE,0,FALSE,FALSE,CMASK(I_e),-NOLIMIT,NOLIMIT,"regular",BOOLTYPE,0},
+#define I_B 13
+   {'B',FALSE,0,FALSE,FALSE,CMASK(I_e),-NOLIMIT,NOLIMIT,"bipside",INTTYPE,0},
+#define I_z 14
+   {'z',TRUE,0,FALSE,FALSE,0,-NOLIMIT,NOLIMIT,"radius",INTTYPE,0},
+#define I_Z 15
+   {'Z',TRUE,0,FALSE,FALSE,CMASK(I_z),-NOLIMIT,NOLIMIT,"diameter",INTTYPE,0},
+#define I_a 16
+   {'a',TRUE,0,FALSE,FALSE,0,-NOLIMIT,NOLIMIT,"groupsize",GROUPSIZE,0},
+#define I_o 17
+   {'o',TRUE,0,FALSE,FALSE,CMASK(I_a),-NOLIMIT,NOLIMIT,"orbits",INTTYPE,0},
+#define I_t 18
+   {'t',TRUE,0,FALSE,FALSE,CMASK(I_o),-NOLIMIT,NOLIMIT,"transitive",BOOLTYPE,0},
+#define I_c 19
+   {'c',FALSE,0,FALSE,FALSE,0,-NOLIMIT,NOLIMIT,"connectivity",INTTYPE,0},
+#define I_F 20
+   {'F',TRUE,0,FALSE,FALSE,CMASK(I_a),-NOLIMIT,NOLIMIT,"fixedpts",INTTYPE,0},
+#define I_g 21
+   {'g',FALSE,0,FALSE,FALSE,0,-NOLIMIT,NOLIMIT,"girth",INTTYPE,0},
+#define I_Y 22
+   {'Y',FALSE,0,FALSE,FALSE,0,-NOLIMIT,NOLIMIT,"cycles",INTTYPE,0},
+#define I_i 23
+   {'i',FALSE,0,FALSE,FALSE,0,-NOLIMIT,NOLIMIT,"minadjcn",INTTYPE,0},
+#define I_I 24
+   {'I',FALSE,0,FALSE,FALSE,CMASK(I_i),-NOLIMIT,NOLIMIT,"maxadjcn",INTTYPE,0},
+#define I_j 25
+   {'j',FALSE,0,FALSE,FALSE,CMASK(I_i),-NOLIMIT,NOLIMIT,"minnoncn",INTTYPE,0},
+#define I_J 26
+   {'J',FALSE,0,FALSE,FALSE,CMASK(I_i),-NOLIMIT,NOLIMIT,"maxnoncn",INTTYPE,0},
+#define I_T 27
+   {'T',TRUE,0,FALSE,FALSE,0,-NOLIMIT,NOLIMIT,"triang",INTTYPE,0},
+#define I_K 28
+   {'K',FALSE,0,FALSE,FALSE,0,-NOLIMIT,NOLIMIT,"maxlcliq",INTTYPE,0},
+#define I_H 29
+   {'H',FALSE,0,FALSE,FALSE,0,-NOLIMIT,NOLIMIT,"induced cycles",INTTYPE,0},
+#define I_b 30
+   {'b',FALSE,0,FALSE,FALSE,0,-NOLIMIT,NOLIMIT,"bipartite",BOOLTYPE,0},
+#define I_C 31
+   {'C',TRUE,0,FALSE,FALSE,0,-NOLIMIT,NOLIMIT,"strong",BOOLTYPE,0},
+#define I_Q 32
+#if defined(USERDEF) || defined(LUSERDEF)
+   {'Q',QDIGRAPH,0,FALSE,FALSE,0,-NOLIMIT,NOLIMIT,USERDEFNAME,INTTYPE,0}
+#else
+   {' ',FALSE,0,FALSE,FALSE,0,-NOLIMIT,NOLIMIT,USERDEFNAME,INTTYPE,0}
+#endif
+};
+
+#define NUMCONSTRAINTS (sizeof(constraint)/sizeof(struct constraint_st))
+#define SYMBOL(i) (constraint[i].symbol)
+#define ISNEEDED(i) (constraint[i].needed > 0)
+#define NEEDED(i) (constraint[i].needed)
+#define ISKEY(i) ((constraint[i].needed & 1) != 0)
+#define ISCONSTRAINT(i) (constraint[i].needed > 1)
+#define INVERSE(i) (constraint[i].inverse)
+#define COMPUTED(i) (constraint[i].computed)
+#define PREREQ(i) (constraint[i].prereq)
+#define LO(i) (constraint[i].lo)
+#define HI(i) (constraint[i].hi)
+#define VAL(i) (constraint[i].val)
+#define VALTYPE(i) (constraint[i].valtype)
+#define ID(i) (constraint[i].id)
+#define ISDIGOK(i) (constraint[i].digraphok)
+
+#define INBOUNDS0(i) ((LO(i) == -NOLIMIT || VAL(i) >= LO(i)) \
+		  && (HI(i) == NOLIMIT || VAL(i) <= HI(i)))
+#define INBOUNDS(i) (VALTYPE(i) == GROUPSIZE \
+	      ? group_in_range((group_node*)VAL(i),LO(i),HI(i)) \
+              : INBOUNDS0(i))
+
+static boolean docount,dofilter;
+
+#define MAXKEYS NUMCONSTRAINTS /* Maximum number of keys to sort by */
+
+/* splay_st is the generic structure of a splay tree node.  The
+   data[] field has varying lengths according to need.  This program
+   uses two splay trees: one for counts and one for large data items.
+*/
+
+typedef struct splay_st
+{
+    struct splay_st *left,*right,*parent;
+    long data[1];
+} splay_node;
+
+typedef struct node_st     /* variant for count tree */
+{
+    struct splay_st *left,*right,*parent;
+    nauty_counter count;
+    long val[MAXKEYS];
+} count_node;
+
+typedef struct value_st    /* variant for value tree */
+{
+    struct splay_st *left,*right,*parent;
+    size_t size;
+    long data[1];
+} value_node;
+
+#define SPLAYNODE splay_node
+#define TOSPLAY(p) ((SPLAYNODE*)(p))
+#define TOVALUE(p) ((value_node*)(p))
+#define TOCOUNT(p) ((count_node*)(p))
+#define SPLAYNODESIZE new_val_sz
+#define SCAN_ARGS , FILE *f
+#define ACTION(p) {possibleblankline(f,TOCOUNT(p)->val); \
+                   fprintf(f,"%9" COUNTER_FMT_RAW \
+                         " graphs : ",TOCOUNT(p)->count); \
+                   printkeyvals(f,TOCOUNT(p)->val); fprintf(f,"\n");}
+#define INSERT_ARGS , boolean isvalue, SPLAYNODE *new_val, size_t new_val_sz
+#define COMPARE(p) (isvalue ? \
+              compare_value_node(TOVALUE(new_val),TOVALUE(p)) \
+            : compare_count_node(TOCOUNT(new_val),TOCOUNT(p)))
+#define PRESENT(p) {if (!isvalue) ++TOCOUNT(p)->count;}
+#define NOT_PRESENT(p) {memcpy((void*)p,(void*)new_val,SPLAYNODESIZE); \
+                    if (!isvalue) TOCOUNT(p)->count = 1;}
+
+static void printkeyvals(FILE*,long*);
+static void possibleblankline(FILE*,long*);
+static int compare_count_node(count_node*,count_node*);
+static int compare_value_node(value_node*,value_node*);
+
+static splay_node *count_root = NULL;
+static splay_node *value_root = NULL;
+static int key[MAXKEYS];
+static int numkeys;
+
+#include "splay.c"     /* Procedures for splay tree management */
+
+typedef struct grpsize_st
+{
+    struct splay_st *left,*right,*parent;
+    size_t size;
+    double groupsize1;
+    long groupsize2;
+} group_node;
+
+static boolean lswitch;
+
+/**********************************************************************/
+
+static int
+compare_count_node(count_node *a, count_node *b)
+/* Usual type of comparison */
+{
+	int i;
+	group_node *sza,*szb;
+
+	for (i = 0; i < numkeys; ++i)
+	{
+	    if (VALTYPE(key[i]) == GROUPSIZE)
+	    {
+		sza = (group_node*)a->val[i];
+		szb = (group_node*)b->val[i];
+		if      (sza->groupsize2 < szb->groupsize2) return -1;
+		else if (sza->groupsize2 > szb->groupsize2) return 1;
+		else if (sza->groupsize1 < szb->groupsize1) return -1;
+		else if (sza->groupsize1 > szb->groupsize1) return 1;
+	    }
+	    else if (a->val[i] < b->val[i]) return -1;
+	    else if (a->val[i] > b->val[i]) return 1;
+	}
+
+	return 0;
+}
+
+/**********************************************************************/
+
+static int
+compare_value_node(value_node *a, value_node *b)
+/* Usual type of comparison */
+{
+	size_t minsize;
+	int cmp;
+
+	if (a->size < b->size) minsize = a->size;
+	else                   minsize = b->size;
+	cmp = memcmp(a->data,b->data,minsize);
+	if (cmp != 0) return cmp;
+
+	if      (a->size < minsize) return -1;
+	else if (a->size > minsize) return 1;
+	else                        return 0;
+}
+
+/**********************************************************************/
+
+static void
+write_group_size(FILE *f, group_node *sz)
+{
+	double sz1;
+	int sz2;
+
+	sz1 = sz->groupsize1;
+	sz2 = sz->groupsize2;
+
+        if (sz2 == 0)
+            fprintf(f,"%.0f",sz1+0.1);
+        else
+        {
+            while (sz1 >= 10.0)
+            {
+                sz1 /= 10.0;
+                ++sz2;
+            }
+            fprintf(f,"%12.10fe%d",sz1,sz2);
+        }
+}
+
+/**********************************************************************/
+
+static void
+add_one(void)
+/* Add current graph to count. */
+{
+	int i;
+	count_node new_val;
+
+	for (i = 0; i < numkeys; ++i)
+	    new_val.val[i] = VAL(key[i]);
+
+        splay_insert(&count_root,FALSE,TOSPLAY(&new_val),
+	    //	     sizeof(count_node)+(numkeys-MAXKEYS)*sizeof(long));
+            offsetof(count_node,val) + numkeys*sizeof(long));
+}
+
+/**********************************************************************/
+
+static void
+printthesevals(FILE *f)
+{       
+        int i,ki;
+        
+        for (i = 0; i < numkeys; ++i)
+        {   
+            ki = key[i];
+            if (i > 0) fprintf(f,"; ");
+            
+            if (VALTYPE(ki) == BOOLTYPE)
+	    {
+                if (!VAL(ki)) fprintf(f,"not %s",ID(ki));
+                else          fprintf(f,"%s",ID(ki));
+	    }
+	    else if (VALTYPE(ki) == GROUPSIZE)
+	    {
+		fprintf(f,"%s=",ID(ki));
+		write_group_size(f,(group_node*)VAL(ki));
+	    }
+            else
+                fprintf(f,"%s=%ld",ID(ki),VAL(ki));
+        }
+}
+
+/**********************************************************************/
+
+static void
+possibleblankline(FILE *f, long *val)
+{
+	static long lastval0 = 0x162a54c7L;
+
+	if (lswitch && numkeys > 1 && val[0] != lastval0 && lastval0 != 0x162a54c7L)
+	    fprintf(f,"\n");
+	lastval0 = val[0];
+}
+
+/**********************************************************************/
+
+static void
+printkeyvals(FILE *f, long *val)
+{
+	int i,ki;
+
+	for (i = 0; i < numkeys; ++i)
+	{
+	    ki = key[i];
+	    if (i > 0) fprintf(f,"; ");
+
+	    if (VALTYPE(ki) == BOOLTYPE)
+	    {
+		if (!val[i]) fprintf(f,"not %s",ID(ki));
+		else         fprintf(f,"%s",ID(ki));
+	    }
+	    else if (VALTYPE(ki) == GROUPSIZE)
+	    {
+		fprintf(f,"%s=",ID(ki));
+		write_group_size(f,(group_node*)val[i]);
+	    }
+	    else
+		fprintf(f,"%s=%ld",ID(ki),val[i]);
+	}
+}
+
+/**********************************************************************/
+
+static void
+groupstats(graph *g, boolean digraph, int m, int n, group_node *sz,
+           int *numorbits, int *fixedpts)  
+/* Find the automorphism group of the undirected graph g.
+   Return the group size and number of orbits and fixed points. */
+{
+#if MAXN
+        int lab[MAXN],ptn[MAXN],orbits[MAXN];
+        int count[MAXN];
+        set active[MAXM];
+        setword workspace[24*MAXM];
+#else
+	DYNALLSTAT(int,lab,lab_sz);
+	DYNALLSTAT(int,ptn,ptn_sz);
+	DYNALLSTAT(int,orbits,orbits_sz);
+	DYNALLSTAT(int,count,count_sz);
+	DYNALLSTAT(set,active,active_sz);
+	DYNALLSTAT(setword,workspace,workspace_sz);
+#endif
+        int i;
+	int fixed;
+        int numcells,code;
+        statsblk stats;
+        static DEFAULTOPTIONS_GRAPH(options);
+
+#if !MAXN
+	DYNALLOC1(int,lab,lab_sz,n,"groupstats");
+	DYNALLOC1(int,ptn,ptn_sz,n,"groupstats");
+	DYNALLOC1(int,orbits,orbits_sz,n,"groupstats");
+	DYNALLOC1(int,count,count_sz,n,"groupstats");
+	DYNALLOC1(set,active,active_sz,m,"groupstats");
+	DYNALLOC1(setword,workspace,workspace_sz,24*m,"groupstats");
+#endif
+
+        EMPTYSET(active,m);
+        ADDELEMENT(active,0);
+        numcells = 1;
+
+	for (i = 0; i < n; ++i)
+	{
+	    lab[i] = i;
+	    ptn[i] = 1;
+	}
+	ptn[n-1] = 0;
+
+	if (m == 1)
+            refine1(g,lab,ptn,0,&numcells,count,active,&code,1,n);
+	else
+            refine(g,lab,ptn,0,&numcells,count,active,&code,m,n);
+
+        if ((!digraph && numcells >= n-1) || (digraph && numcells == n))
+        {
+	    *numorbits = numcells;
+	    *fixedpts = (numcells == n ? n : n-2);
+	    sz->groupsize1 = n + 1.0 - numcells; 
+	    sz->groupsize2 = 0;
+        }
+        else
+        {
+            options.getcanon = FALSE;
+            options.defaultptn = FALSE;
+            options.digraph = digraph;
+	    if (n >= 33) options.schreier = TRUE;
+
+	    if (digraph)
+	    {
+		options.invarproc = adjacencies;
+		options.maxinvarlevel = 99;
+		options.mininvarlevel = 0;
+	    }
+
+            EMPTYSET(active,m);
+            nauty(g,lab,ptn,active,orbits,&options,&stats,
+                                             workspace,24*m,m,n,NULL);
+	    *numorbits = stats.numorbits;
+	    sz->groupsize1 = stats.grpsize1;
+	    sz->groupsize2 = stats.grpsize2;
+	    for (i = 0; i < n; ++i) count[i] = 0;
+	    fixed = stats.numorbits;
+	    for (i = 0; i < n; ++i)
+		if (++count[orbits[i]] == 2) --fixed;
+	    *fixedpts = fixed;
+        }
+}
+
+/**********************************************************************/
+
+static void
+compute(graph *g, int m, int n, int code, boolean digraph)
+/* Compute property i assuming the prerequisites are known. */
+{
+	int mind,maxd,mincount,maxcount;
+	int minind,maxind,minincount,maxincount;
+	int rad,diam,loops;
+	unsigned long ned;
+	boolean eul;
+	group_node sz;
+	int norbs,fixedpts;
+	int minadj,maxadj,minnon,maxnon;
+
+	switch (code)
+	{
+	    case I_e:
+		degstats2(g,digraph,m,n,&ned,&loops,&minind,&minincount,
+                    &maxind,&maxincount,&mind,&mincount,&maxd,&maxcount,&eul);
+		VAL(I_e) = ned;
+		VAL(I_L) = loops;
+		VAL(I_d) = mind;
+		VAL(I_D) = maxd;
+		VAL(I_u) = minind;
+                VAL(I_U) = maxind;
+		VAL(I_E) = eul;
+		VAL(I_r) = (mind == maxd) && (minind == maxind)
+                                          && (mind == minind);
+		VAL(I_m) = mincount;
+		VAL(I_M) = maxcount;
+		VAL(I_s) = minincount;
+		VAL(I_S) = maxincount;
+		COMPUTED(I_e) = COMPUTED(I_d) = COMPUTED(I_D) = TRUE;
+		COMPUTED(I_L) = COMPUTED(I_s) = COMPUTED(I_S) = TRUE;
+	        COMPUTED(I_E) = COMPUTED(I_r) = TRUE;
+	        COMPUTED(I_m) = COMPUTED(I_M) = TRUE;
+	        COMPUTED(I_u) = COMPUTED(I_U) = TRUE;
+		break;
+
+	    case I_b:
+		VAL(I_b) = isbipartite(g,m,n);
+		COMPUTED(I_b) = TRUE;
+		break;
+
+	    case I_B:
+		VAL(I_B) = bipartiteside(g,m,n);
+		VAL(I_b) = (VAL(I_e) == 0 || VAL(I_B) > 0);
+		COMPUTED(I_B) = COMPUTED(I_b) = TRUE;
+		break;
+
+	    case I_C:
+		VAL(I_C) = stronglyconnected(g,m,n);
+		COMPUTED(I_C) = TRUE;
+		break;
+
+	    case I_g:
+		VAL(I_g) = girth(g,m,n);
+		COMPUTED(I_g) = TRUE;
+		break;
+
+	    case I_K:
+		VAL(I_K) = maxcliques(g,m,n);
+		COMPUTED(I_K) = TRUE;
+		break;
+
+	    case I_z:
+	    case I_Z:
+		diamstats(g,m,n,&rad,&diam);
+		VAL(I_z) = rad;
+		VAL(I_Z) = diam;
+		COMPUTED(I_z) = COMPUTED(I_Z) = TRUE;
+		break;		
+
+	    case I_a:
+		if (!COMPUTED(I_L))
+		{
+		    VAL(I_L) = loopcount(g,m,n);
+		    COMPUTED(I_L) = TRUE;
+		}
+		groupstats(g,digraph||VAL(I_L)>0,m,n,&sz,&norbs,&fixedpts);
+		sz.size = sizeof(long) + sizeof(double);
+		splay_insert(&value_root,TRUE,TOSPLAY(&sz),sizeof(group_node));
+		VAL(I_a) = (long)value_root;
+		VAL(I_o) = norbs;
+		VAL(I_t) = norbs == 1;
+		VAL(I_F) = fixedpts;
+		COMPUTED(I_a) = COMPUTED(I_o) = TRUE;
+		COMPUTED(I_F) = COMPUTED(I_t) = TRUE;
+	        break;
+
+	    case I_c:
+		if (isbiconnected(g,m,n)) VAL(I_c) = 2;
+		else if (isconnected(g,m,n)) VAL(I_c) = 1;
+		else VAL(I_c) = 0;
+		COMPUTED(I_c) = TRUE;
+		break;
+
+	    case I_n:
+	    case I_d:
+	    case I_D:
+	    case I_E:
+	    case I_r:
+	    case I_o:
+	    case I_t:
+	    case I_m:
+	    case I_M:
+		fprintf(stderr,">E Property %d should be known already\n",code);
+		exit(1);
+
+	    case I_Y:
+		VAL(I_Y) = cyclecount(g,m,n);
+		COMPUTED(I_Y) = TRUE;
+		break;
+
+	    case I_H:
+		VAL(I_H) = indcyclecount(g,m,n);
+		COMPUTED(I_H) = TRUE;
+		break;
+
+	    case I_T:
+		if (digraph) VAL(I_T) = numdirtriangles(g,m,n);
+                else         VAL(I_T) = numtriangles(g,m,n);
+		COMPUTED(I_T) = TRUE;
+		break;
+
+	    case I_i:
+	    case I_I:
+	    case I_j:
+	    case I_J:
+		commonnbrs(g,&minadj,&maxadj,&minnon,&maxnon,m,n);
+		VAL(I_i) = minadj;
+		VAL(I_I) = maxadj;
+		VAL(I_j) = minnon;
+		VAL(I_J) = maxnon;
+		COMPUTED(I_i) = COMPUTED(I_I) = TRUE;
+                COMPUTED(I_j) = COMPUTED(I_J) = TRUE;
+                break;
+
+#ifdef USERDEF
+	    case I_Q:
+		VAL(I_Q) = USERDEF(g,m,n);
+		COMPUTED(I_Q) = TRUE;
+		break;
+#endif
+#ifdef LUSERDEF
+	    case I_Q:
+		VAL(I_Q) = LUSERDEF(g,m,n);
+		COMPUTED(I_Q) = TRUE;
+		break;
+#endif
+
+	    default:
+		fprintf(stderr,">E Property %d is uncomputable\n",code);
+		exit(1);
+	}
+}
+
+/**********************************************************************/
+
+static boolean
+group_in_range(group_node *sz, long lo, long hi)
+/* Test if the group size is in the given range */
+{
+	double sz1;
+	int sz2;
+
+	if (lo != -NOLIMIT)
+	{
+	    sz1 = sz->groupsize1;
+	    sz2 = sz->groupsize2;
+
+            while (sz2 >= 0 && sz1 < lo)
+	    {
+		--sz2;
+		sz1 *= 10.0;
+	    }
+	    if (sz2 < 0) return FALSE;
+	}
+
+	if (hi != NOLIMIT)
+	{
+	    sz1 = sz->groupsize1;
+	    sz2 = sz->groupsize2;
+	   
+	    while (sz2 >= 0 && sz1 <= hi)
+	    {
+		--sz2;
+		sz1 *= 10.0;
+	    }
+	    if (sz2 >= 0) return FALSE;
+	}
+
+	return TRUE;
+}
+
+/**********************************************************************/
+
+static boolean
+selected(graph *g, int m, int n, boolean digraph)
+/* See if g is selected by the constraints */
+{
+	int i;
+
+	VAL(I_n) = n;
+	COMPUTED(I_n) = TRUE;
+
+	for (i = 0; i < NUMCONSTRAINTS; ++i)
+	if (ISNEEDED(i))
+	{
+	    if (!COMPUTED(i)) compute(g,m,n,i,digraph);
+
+	    if (ISCONSTRAINT(i))
+	    {
+	        if (INBOUNDS(i))
+	        {
+		    if (INVERSE(i)) return FALSE;
+	        }
+	        else
+	        {
+		    if (!INVERSE(i)) return FALSE;
+	        }
+	    }
+	}
+
+	return TRUE;
+}
+
+/**********************************************************************/
+
+static void
+decodekeys(char *s)
+/* Extract key symbols from -- string */
+{
+	int i,j,k;
+
+	for (i = 0; s[i] != '\0'; ++i)
+	{
+	    for (j = 0; j < NUMCONSTRAINTS; ++j)
+		if (s[i] == SYMBOL(j)) break;
+	    if (j == NUMCONSTRAINTS)
+	    {
+		fprintf(stderr,">E unknown sort key %c\n",s[i]);
+		exit(1);
+	    }
+
+	    for (k = 0; k < numkeys; ++k) if (key[k] == j) break;
+
+	    if (k == numkeys)
+	    {
+		if (numkeys == MAXKEYS)
+		{
+		    fprintf(stderr,
+			    ">E too many sort keys, increase MAXKEYS\n");
+		    exit(1);
+		}
+		key[numkeys++] = j;
+		NEEDED(j) |= 1;
+	    }
+	}
+}
+
+/**********************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+	graph *g,*gprev;
+	int m,n,codetype;
+	char *infilename,*outfilename;
+	FILE *infile,*outfile,*countfile;
+	nauty_counter nin,nout;
+	int argnum,i,j,nprev,mprev,digbad;
+	char *arg,sw,*baseptr,*bp;
+	boolean badargs,lastwritten,digraph;
+	long pval1,pval2,maxin;
+	boolean fswitch,pswitch,Vswitch,vswitch,qswitch;
+	unsigned long cmask;
+	boolean havecon,neg,doflush;
+	double t;
+
+	HELP; PUTVERSION;
+
+	if (sizeof(void*) > sizeof(long))
+	{
+	    fprintf(stderr,">E %s cannot run on this machine.\n",argv[0]);
+	    exit(1);
+	}
+	lswitch = vswitch = qswitch = fswitch = pswitch = FALSE;
+	doflush = Vswitch = FALSE;
+	infilename = outfilename = NULL;
+	numkeys = 0;
+	havecon = FALSE;
+
+	baseptr = argv[0];
+	for (bp = baseptr; *bp != '\0'; ++bp)
+	    if (*bp == '/' || *bp == '\\') baseptr = bp+1;
+
+#ifdef DOCOUNT
+#ifdef DOPICK
+        docount = dofilter = TRUE;
+#else
+        docount = TRUE;
+        dofilter = TRUE;
+#endif
+#else
+#ifdef DOPICK
+        docount = FALSE;
+        dofilter = TRUE;
+#else
+        docount = strstr(baseptr,"count") != NULL;
+        dofilter = strstr(baseptr,"pick") != NULL;
+#endif
+#endif
+
+        if (!docount && !dofilter)
+        {
+            fprintf(stderr,
+             ">E %s: can\'t tell if this is a picker or a counter\n",argv[0]);
+            gt_abort(NULL);
+        }
+
+	argnum = 0;
+	badargs = FALSE;
+	for (j = 1; !badargs && j < argc; ++j)
+	{
+	    arg = argv[j];
+	    if (arg[0] == '-' && arg[1] != '\0')
+	    {
+		++arg;
+		while (*arg != '\0')
+		{
+		    sw = *arg++;
+		         SWBOOLEAN('q',qswitch)
+		    else SWBOOLEAN('f',fswitch)
+		    else SWBOOLEAN('v',vswitch)
+		    else SWBOOLEAN('V',Vswitch)
+		    else SWBOOLEAN('9',doflush)
+		    else SWBOOLEAN('l',lswitch)
+		    else SWRANGE('p',":-",pswitch,pval1,pval2,"-p")
+		    else if (sw == '-')
+		    {
+			docount = TRUE;
+			decodekeys(arg);
+			while (*arg != '\0') ++arg;
+		    }
+		    else
+		    {
+			if (sw == '~')
+			{
+			    neg = TRUE;
+			    sw = *arg++;
+			}
+			    else neg = FALSE;
+
+			for (i = 0; i < NUMCONSTRAINTS; ++i)
+			    if (sw == SYMBOL(i))
+			    {
+				NEEDED(i) |= 2;
+				if (VALTYPE(i) == INTTYPE
+				 || VALTYPE(i) == GROUPSIZE)
+				    arg_range(&arg,":-",&LO(i),&HI(i),ID(i));
+				else
+				    LO(i) = HI(i) = 1;
+				if (neg) INVERSE(i) = TRUE;
+				havecon = TRUE;
+			        break;
+			    }
+			if (i == NUMCONSTRAINTS) badargs = TRUE;
+		    }
+		}
+	    }
+	    else
+	    {
+		++argnum;
+		if      (argnum == 1) infilename = arg;
+	        else if (argnum == 2) outfilename = arg;
+		else                  badargs = TRUE;
+	    }
+	}
+
+	if (badargs || argnum > 2)
+	{
+	    fprintf(stderr,">E Usage: %s\n",USAGE);
+	    GETHELP;
+	    exit(1);
+	}
+
+	if (vswitch && !havecon)
+	{
+	    fprintf(stderr,">E -v is illegal with no constraints\n");
+	    exit(1);
+	}
+
+	for (j = NUMCONSTRAINTS; --j >= 0;)
+	if (ISNEEDED(j))
+	{
+	     cmask = PREREQ(j);
+	     for (i = 0; cmask != 0; ++i, cmask >>= 1)
+		 if (cmask & 1) NEEDED(i) |= 1;
+	}
+
+	digbad = -1;
+	for (j = 0; j < NUMCONSTRAINTS; ++j)
+	    if (ISNEEDED(j) && !ISDIGOK(j))
+	    {
+		digbad = j;
+		break;
+	    }
+	
+	if (vswitch)
+	{
+	    for (j = 0; j < NUMCONSTRAINTS; ++j)
+		if (ISCONSTRAINT(j)) INVERSE(j) = !INVERSE(j);
+	}
+
+	if (!qswitch)
+	{
+	    fprintf(stderr,">A %s",argv[0]);
+	    if (fswitch || pswitch)
+		fprintf(stderr," -");
+	    if (fswitch) fprintf(stderr,"f");
+	    if (pswitch) writerange(stderr,'p',pval1,pval2);
+
+	    if (numkeys > 0)
+	    {
+		fprintf(stderr," --");
+		for (j = 0; j < numkeys; ++j)
+		    fprintf(stderr,"%c",SYMBOL(key[j]));
+	    }
+
+	    if (havecon) fprintf(stderr," -");
+	    for (j = 0; j < NUMCONSTRAINTS; ++j)
+	    if (ISCONSTRAINT(j))
+	    {
+		if (INVERSE(j)) fprintf(stderr,"~");
+		if (VALTYPE(j) == BOOLTYPE)
+		    fprintf(stderr,"%c",SYMBOL(j));
+		else
+		    writerange(stderr,(int)SYMBOL(j),LO(j),HI(j));
+	    }
+
+	    if (argnum > 0) fprintf(stderr," %s",infilename);
+	    if (argnum > 1) fprintf(stderr," %s",outfilename);
+	    fprintf(stderr,"\n");
+	    fflush(stderr);
+	}
+
+	if (infilename && infilename[0] == '-') infilename = NULL;
+	infile = opengraphfile(infilename,&codetype,fswitch,
+			       pswitch ? pval1 : 1);
+	if (!infile) exit(1);
+	if (!infilename) infilename = "stdin";
+
+	if (!outfilename || outfilename[0] == '-')
+	{
+	    outfilename = "stdout";
+	    outfile = stdout;
+	}
+	else if ((outfile = fopen(outfilename,"w")) == NULL)
+	{
+	    fprintf(stderr,"Can't open output file %s\n",outfilename);
+	    gt_abort(NULL);
+	}
+
+	if (dofilter) countfile = stderr;
+	else          countfile = outfile;
+
+	nin = nout = 0;
+	if (!pswitch || pval2 == NOLIMIT) maxin = NOLIMIT;
+	else if (pval1 < 1)               maxin = pval2;
+	else                              maxin = pval2 - pval1 + 1;
+	t = CPUTIME;
+
+	gprev = NULL;
+	nprev = mprev = 1;
+	lastwritten = FALSE;
+	while (nin < maxin || maxin == NOLIMIT)
+	{
+	    if ((g = readgg_inc(infile,NULL,0,&m,&n,
+				gprev,mprev,nprev,&digraph)) == NULL) break;
+	    ++nin;
+	    if (digraph && digbad >= 0)
+	    {
+		fprintf(stderr,
+                        ">E %s: option %c is not implemented for digraphs\n",
+			argv[0],SYMBOL(digbad));
+		gt_abort(NULL);
+	    }
+
+	    for (j = 0; j < NUMCONSTRAINTS; ++j) COMPUTED(j) = FALSE;
+
+	    if (selected(g,m,n,digraph))
+	    {
+	        if (dofilter)
+		{
+		    if (readg_code == INCSPARSE6 && !lastwritten)
+			writes6(outfile,g,m,n);
+		    else
+		        writelast(outfile);
+		    if (doflush) fflush(outfile);
+		}
+		if (Vswitch)
+		{
+		    fprintf(countfile,"Graph " COUNTER_FMT " : ",nin);
+		    printthesevals(countfile);
+		    fprintf(countfile,"\n");
+	        }
+		else if (docount)
+		    add_one();
+
+	        ++nout;
+		lastwritten = TRUE;
+	    }
+	    else
+		lastwritten = FALSE;
+
+            if (gprev) FREES(gprev);
+            gprev = g;
+            nprev = n;
+            mprev = m;
+	}
+	t = CPUTIME - t;
+
+	if (docount && !Vswitch)
+	{
+	    splay_scan(count_root,countfile);
+	    if (qswitch || !dofilter)
+	    {
+		fprintf(countfile," " COUNTER_FMT " graphs altogether",nout);
+		if (nin != nout) fprintf(countfile," from " COUNTER_FMT " read",nin);
+		fprintf(countfile,"; cpu=%.3f sec\n",t);
+	    }
+	}
+
+	if (!qswitch && dofilter) 
+	    fprintf(stderr,
+		">Z " COUNTER_FMT " graphs read from %s; "
+                          COUNTER_FMT " written to %s; %.3f sec\n",
+	        nin,infilename,nout,outfilename,t);
+
+	exit(0);
+}
diff --git a/lib/nauty/traces.c b/lib/nauty/traces.c
new file mode 100644
index 0000000..04425bd
--- /dev/null
+++ b/lib/nauty/traces.c
@@ -0,0 +1,10608 @@
+/******************************************************************************
+ *                                                                            *
+ * This is the main file for traces() version 2.1, which is included into     *
+ *   nauty() version 2.6.                                                     *
+ *                                                                            *
+ *   nauty is Copyright (1984-2016) Brendan McKay.  All rights reserved.      *
+ *   Traces is Copyright Adolfo Piperno, 2008-2016.  All rights reserved.     *
+ *   See the file COPYRIGHT for the details of the software license.          *
+ *                                                                            *
+ *   CHANGE HISTORY                                                           *
+ *       28-Dec-12 : final changes for version 2.0                            *
+ *       20-Jan-13 : add code for ^C catching in Traces                       *
+ *       29-Mar-13 : bug correction in automorphism mode                      *
+ *       02-Apr-13 : add preprocessing                                        *
+ *       21-May-13 : bug correction (coloured lists)                          *
+ *       29-Jun-13 : bug correction (coloured lists and cycles)               *
+ *       07-Dec-13 : bug correction in automorphism mode (wrong group size    *
+ *                   due to randomness in Schreier-Sims orbit computation)    *
+ *                   bug correction (discrete initial partition)              *
+ *       15-Feb-14 : CPUDEFS removed (already declared in gtools.h)           *
+ *       01-Sep-15 : add weighted edges (not active)                          *
+ *       28-Jan-16 : version ready for nauty and Traces v.2.6 distribution    *
+ *       12-Jul-16 : bug correction (reaching degree 2 vertices)              *
+ *****************************************************************************/
+
+#include "traces.h"
+
+#ifdef NAUTY_IN_MAGMA
+#include "cleanup.e"
+#endif
+
+#define SORT_OF_SORT 2
+#define SORT_NAME sort2ints
+#define SORT_TYPE1 int
+#define SORT_TYPE2 int
+#include "sorttemplates.c"
+
+typedef struct weightwhere {
+    int weight;
+    int *ref;
+} weightwhere;
+
+#define SORT_OF_SORT 2
+#define SORT_NAME sortweights
+#undef SORT_TYPE2
+#define SORT_TYPE1 int
+#define SORT_TYPE2 weightwhere
+#include "sorttemplates.c"
+
+#define NAUTY_ABORTED (-11)
+#define NAUTY_KILLED (-12)
+
+typedef struct Candidate {
+    boolean sortedlab;
+    int *invlab;
+    int *lab;
+    int code;
+    int do_it;
+    int indnum;
+    int name;
+    int vertex;
+    struct Candidate *next;
+    struct searchtrie *stnode;
+    unsigned int firstsingcode;
+    unsigned int pathsingcode;
+    unsigned int singcode;
+} Candidate;
+
+typedef struct Partition {
+    int *cls;
+    int *inv;
+    int active;
+    int cells;
+    int code;
+} Partition;
+
+typedef struct trielist {
+    struct searchtrie *triearray;
+    struct trielist *prev;
+    struct trielist *next;
+} trielist;
+
+typedef struct TracesVars {
+    char digstring[25];
+    double autchk;
+    double expaths;
+    double schreier1;
+    double schreier2;
+    double schreier3;
+    int augmented_cells;
+    int build_autom;
+    int *currorbit;
+    int *orbits;
+    int answ;
+    int brkstpcount;
+    int compstage;
+    int cand_level;
+    int canlist;
+    int digits;
+    int expathlength;
+    int firstpathlength;
+    int fromlevel;
+    int group_level;
+    int indivend;
+    int indivstart;
+    int indiv_vtx;
+    int lastcell;
+    int lastlev;
+    int lev_of_lastauto;
+    int levelfromCS0;
+    int linelgth;
+    int mark;
+    int treemark;
+    int autmark;
+    int markcell1;
+    int markcell2;
+    int maxdeg;
+    int maxtreelevel;
+    int maxspineorblevel;
+    int mindeg;
+    int name;
+    struct searchtrie *gotonode;
+    struct searchtrie *newgotonode;
+    struct searchtrie *newst_stage1;
+    int newindex;
+    int nextlevel;
+    int nfix;
+    int finalnumcells;
+    int permInd;
+    int preprocessed;
+    int samepref;
+    int specialgens;
+    int stackmark;
+    int steps;
+    int strategy;
+    trielist *strielist;
+    int strienext;
+    int tcell_sz;
+    int tcell;
+    int tcellevel;
+    int tcellexpath_sz;
+    int tcellexpath;
+    int tolevel_tl;
+    int tolevel;
+    int treedepth;
+    int trienext;
+    int triepos;
+    TracesOptions *options;
+    TracesStats *stats;
+    unsigned int singlongcode;
+    sparsegraph *graph;
+    sparsegraph *cangraph;
+    sparsegraph *input_graph;
+    int conta0;
+    int conta1;
+    int conta2;
+    int conta3;
+    int conta4;
+    int conta5;
+    int conta6;
+    int conta7;
+    int contatc;
+} TracesVars;
+
+typedef struct TracesInfo {
+    boolean autofound;
+    boolean deg_one;
+    boolean first_matching;
+    boolean regular;
+    boolean exitfromref;
+    boolean identitygroup;
+    boolean minimalinorbits;
+    boolean thegraphisparse;
+    boolean thegrouphaschanged;
+    boolean thereisnextlevel;
+    boolean useTempOrbits1;
+    boolean useTempOrbits2;
+} TracesInfo;
+
+typedef struct TracesSpine {
+    boolean thetracexists;
+    Candidate *listend;
+    Candidate *liststart;
+    int ccend;
+    int ccstart;
+    int listcounter;
+    int stpend;
+    int stpstart;
+    int tgtcell;
+    int tgtend;
+    int tgtfrom;
+    int tgtpos;
+    int tgtsize;
+    int trcend;
+    int trcstart;
+    int singend;
+    int singstart;
+    int updates;
+    unsigned long keptcounter;
+    unsigned long levelcounter;
+    Partition *part;
+    unsigned int singcode;
+} TracesSpine;
+
+typedef struct trie {
+    int value;
+    struct trie *first_child;
+    struct trie *next_sibling;
+} trie;
+
+typedef struct searchtrie {
+    int index;
+    int name;
+    int vtx;
+    int level;
+    struct searchtrie *father;
+    struct searchtrie *first_child;
+    struct searchtrie *last_child;
+    struct searchtrie *next_sibling;
+    struct searchtrie *goes_to;
+} searchtrie;
+
+typedef struct pair {
+    int arg;
+    int val;
+} pair;
+
+typedef struct grph_strct {
+    int *e;
+    int *w;
+    int d;
+    boolean one;
+} grph_strct;
+
+typedef struct ExpPathInfo {
+    int code;
+    int cell;
+    int info;
+} ExpPathInfo;
+
+static boolean traces_degree_refine(sparsegraph*, Candidate*, int, Partition*,
+                                    struct TracesVars*, struct TracesInfo*, int, int*);
+static int  traces_vertexclass_refine (int, int*, int*, Candidate*, Partition*, int*);
+static int  traces_refine(Candidate*, int, Partition*,
+                          struct TracesVars*, struct TracesInfo*, int, boolean);
+static void traces_refine_notrace(Candidate*, int, Partition*,
+                                  struct TracesVars*, struct TracesInfo*);
+static void traces_refine_maketrie(Candidate*, int, Partition*,
+                                   struct TracesVars*, struct TracesInfo*);
+static int  traces_refine_comptrie(Candidate*, int, Partition*,
+                                   struct TracesVars*, struct TracesInfo*);
+static int  traces_refine_sametrace(Candidate*, int, Partition*,
+                                    struct TracesVars*, struct TracesInfo*);
+static int  traces_refine_refine(sparsegraph*, Candidate*, int, Partition*,
+                                 struct TracesVars*, struct TracesInfo*);
+static int  refine_tr_refine(Candidate*, int, Partition*,
+                             struct TracesVars*, struct TracesInfo*);
+static int given_gens(sparsegraph*, permnode*, int*, boolean);
+static void quickSort(int*, int);
+static struct Partition* NewPartition(int);
+static struct Candidate* NewCandidate(int, Candidate**, int);
+static void NewPartSpine(int, int);
+static int FreeList(Candidate*, int);
+static int FixBase(int*, struct TracesVars*, Candidate*, int, int);
+static boolean FixedBase(int*, struct TracesVars*, Candidate*, int, int);
+static void factorial(double*, int*, int);
+static void factorial2(double*, int*, int);
+static int CheckForAutomorphisms(Candidate*, Candidate*, struct TracesVars*, struct TracesInfo*, int, int, Partition*);
+static int CheckForSingAutomorphisms(Candidate*, Partition*, Candidate*, struct TracesVars*, struct TracesInfo*, int, int);
+static int CheckForMatching(Candidate*, Candidate*, Partition*, struct TracesVars*, struct TracesInfo*, int, int);
+static void Individualize(Partition*, Candidate*, int, int, int, int);
+static boolean TreeFyTwo(int, Candidate*, Candidate*, Partition*, int, struct TracesVars*, struct TracesInfo*);
+static void ExperimentalStep(Partition*, Candidate*, struct TracesVars*, struct TracesInfo*, int, int);
+static boolean TargetCell(Candidate*, Partition*, int, struct TracesVars*, int);
+static boolean TargetCellFirstPath(Candidate*, Partition*, struct TracesVars*);
+static int TargetCellExpPath(Candidate*, Partition*, struct TracesVars*);
+static boolean TargetCellSmall(Candidate*, Partition*, int, struct TracesVars*, int);
+static boolean TargetCellFirstPathSmall(Candidate*, Partition*, struct TracesVars*);
+static int TargetCellExpPathSmall(Candidate*, Partition*, struct TracesVars*);
+static boolean SelectNextLevel(int, struct TracesVars*, struct TracesInfo*);
+static void CopyCand(Candidate*, Candidate*, int, int*, int*);
+static struct trie* trie_new(int, struct TracesVars*);
+static struct trie* trie_make(trie*, int, int, struct TracesVars*);
+static struct trie* trie_comp(trie*, int);
+static void trie_dump(trie*);
+static void trie_class(trie*, int*);
+static void RemoveFromLevel(int, int, int, boolean);
+static int CompStage0(Partition*, Partition*, Candidate*, Candidate*, int, int, struct TracesVars*, struct TracesInfo*);
+static int CompStage1(Partition*, Partition*, Candidate*, Candidate*, int, int, struct TracesVars*, struct TracesInfo*);
+static int CompStage2(Partition*, Partition*, Candidate*, Candidate*, int, int, struct TracesVars*, struct TracesInfo*);
+static void grouporderplus(sparsegraph*, Candidate*, Partition*, permnode**, double*, int*, int, struct TracesVars*, struct TracesInfo*);
+static boolean Prefix(Candidate*, Candidate*, int);
+static boolean findperm(permnode*, int*, int);
+static int spinelementorbsize(int*, int*, int, int);
+static trielist* searchtrie_new(int, struct TracesVars*);
+static searchtrie* searchtrie_make(Candidate*, Candidate*, int, struct TracesVars*);
+static boolean lookup(searchtrie*);
+static int* findcurrorbits(schreier*, int);
+static int Preprocess(sparsegraph*, permnode**, Candidate*, int, Partition*, struct TracesVars*);
+static int Preprocess_refine(sparsegraph*, permnode**, Candidate*, int, Partition*, struct TracesVars*);
+static void MakeTree(int, int, sparsegraph*, int, struct TracesVars*, boolean);
+static void MakeCanTree(int, sparsegraph*, int, Candidate*, Partition*, struct TracesVars*);
+static int max(int, int);
+static int min(int, int);
+static void orbjoin_sp_perm(int*, int*, int*, int, int*);
+static void orbjoin_sp_pair(int*, int*, int, int, int, int*);
+static boolean isautom_sg_pair(graph*, int*, boolean, int, int, struct TracesVars*);
+static void SetAutom(int, int, struct TracesVars*);
+static void ResetAutom(int, int, struct TracesVars*);
+static void PrintVect(int*, int, int, int);
+static void putgraphplus_sg(FILE*, sparsegraph*, int);
+static boolean VerifyId(int *p, int n);
+static void PrintPartition(int*, int*, int, int, int);
+static void Place(int, Candidate*, Partition*);
+static int NonSingDeg(int, Candidate*, Partition*);
+static int NonSingDegPlus1(Candidate*, Partition*, int, TracesVars*);
+static void NonSingDegPlus2(Candidate*, Partition*, int, TracesVars*);
+static void Edge_Delete(int, int, Candidate*, TracesVars*);
+static boolean VerifyPart(Partition*, int, int);
+static int VerifyPerm(int*, int,int);
+static boolean VerifyCand(Candidate*, int, int);
+static int FirstNeighbour(int, Candidate*, Partition*, int*, int, int*, int);
+static int NextNeighbour(int, Candidate*, Partition*, int*, int, int*, int);
+static sparsegraph* copy_sg_structure(sparsegraph*, sparsegraph*);
+static void WeightCodes (int);
+static void PrintWeightedGraph1(sparsegraph*, int, char[30]);
+static void PrintWeightedGraph2(int n, char msg[30]);
+static void MakeDiscrete(Partition*, int);
+static void Complete(sparsegraph*, Candidate*, Partition*, int, TracesVars*, double*, int*,permnode**, int);
+static void Allocate_Traces_Structures(int);
+static void Allocate_refine_Structures(int);
+static void Initialize_Traces_Variables(TracesVars*, TracesOptions*, TracesStats*, int*, sparsegraph*, sparsegraph*, int);
+static void Initialize_Traces_Statistics (TracesStats*, int);
+static void Initialize_Traces_Time_Variables (TracesVars*);
+static int trie_classify(int, TracesVars*);
+static int Check_degree_one(sparsegraph*, Candidate*, Partition*, int);
+static void sort_Split_Array(int*, int);
+static const unsigned int fuzz1[] = {037541, 061532, 005257, 026416};
+static const unsigned int fuzz2[] = {006532, 070236, 035523, 062437};
+static int Select_from_CStack(int*, int);
+static void PrintBlissGraph(int);
+static void CodeClassify(int, int, int);
+
+#define FUZZ1(x) ((x) ^ fuzz1[(x)&3])
+#define FUZZ2(x) ((x) ^ fuzz2[(x)&3])
+
+#define MASHCOMM(l, i) ((l) + FUZZ1(i))
+#define MASHNONCOMM(l, i) (FUZZ2(l) + (i))
+#define MASH(l, i) ((((l) ^ 065435) + (i)) & 077777)
+#define MASH1(l, i) ((l + (i*i)) & 077777)
+#define CLEANUP(l) ((int)((l) % 0x7FFF))
+#define SS(n, sing, plur)  (n), ((n) == 1?(sing):(plur))
+
+#define SETMARK(Arr, Mrk) if (Mrk > (NAUTY_INFINITY-2)) { memset(Arr, 0, n*sizeof(int)); Mrk = 0; } Mrk++;
+
+#define COPYNODE(W, V) { \
+memcpy(W->lab, V->lab, n*sizeof(int)); \
+memcpy(W->invlab, V->invlab, n*sizeof(int)); \
+W->code = V->code; \
+W->singcode = V->singcode; \
+W->do_it = V->do_it; }
+
+#define NEXTLINE fprintf(outfile, "\n");
+
+#define PRINTCHAR(c) fprintf(outfile, "%s", c);
+
+#define PRINTCAND(V, Lev) PRINTCHAR(" ") for (tmp=1; tmp<=Lev; tmp++) {fprintf(outfile, tv->digstring, V->lab[Spine[tmp].tgtpos]+labelorg);}
+
+#define PRINTCANDF(V, Lev) { NEXTLINE for (tmp=1; tmp<=Lev; tmp++) {fprintf(outfile, "F%di", V->lab[Spine[tmp].tgtpos]+labelorg);} NEXTLINE }
+
+#define PRINTCANDBIG(V, Lev) { PRINTCHAR(" ") \
+for (tmp=1; tmp<=5; tmp++) {fprintf(outfile, tv->digstring, V->lab[Spine[tmp].tgtpos]+labelorg);} \
+fprintf(outfile, "... "); \
+for (tmp=Lev-4; tmp<=Lev; tmp++) {fprintf(outfile, tv->digstring, V->lab[Spine[tmp].tgtpos]+labelorg);} }
+
+#define LINE(K, c) { PRINTCHAR(c) for (tmp=1; tmp<=K; tmp++) {fprintf(outfile, c);} }
+
+#define TRACE_CHECK(Tr, Ind, Arg, End) { TracePos = Tr+Ind; \
+if (newtrace) { \
+*TracePos = Arg; \
+} \
+else { \
+if (Ind < *End) { \
+if (*TracePos != Arg) { \
+if (*TracePos > Arg) { \
+return FALSE; \
+} \
+else { \
+*TracePos = Arg; \
+newtrace = TRUE; \
+} \
+} \
+} \
+else { \
+*TracePos = Arg; \
+newtrace = TRUE; \
+} \
+} \
+Ind++; }
+
+#define SAMETRACE_CHECK(Tr, Ind, Arg, End) { TracePos = Tr+Ind; \
+if (Ind < *End) { \
+if (*TracePos != Arg) { \
+return FALSE; \
+} \
+} \
+else { \
+return FALSE; \
+} \
+Ind++; }
+
+#define NEWPARTSPINE(Lev) { if (Lev > 3) { \
+Spine[Lev].part = malloc(sizeof(*(Spine[Lev].part))); \
+if (Spine[Lev].part == NULL) { \
+fprintf(ERRFILE, "\nError, memory not allocated.\n"); \
+exit(1); \
+} \
+Spine[Lev].part->cls = Spine[Lev-3].part->cls; \
+Spine[Lev].part->inv = Spine[Lev-3].part->inv; \
+Spine[Lev-3].part->cls = Spine[Lev-3].part->inv = NULL; \
+Spine[Lev].part->code = -1; \
+Spine[Lev].part->cells = 0; \
+} \
+else { \
+Spine[Lev].part = NewPartition(n); \
+} }
+
+#define FIND_SPLIT_CELLS SplInd = 0; \
+for (j = 0; j < HitClsInd; j++) { \
+ind1 = HitCls[j]; \
+ElmHitCll[ind1] -= ind1; \
+if ((ElmHitCll[ind1] > 0) && (ElmHitCll[ind1] < cls[ind1])) { \
+SplCls[SplInd++] = ind1; \
+} \
+}
+
+#define FREEPART(Part) { if (Part) { \
+if (Part->cls) free(Part->cls); \
+if (Part->inv) free(Part->inv); \
+free(Part); } \
+}
+
+#define FREECAND(Cand) { if (Cand) { \
+if (Cand->lab) free(Cand->lab); \
+if (Cand->invlab) free(Cand->invlab); \
+free(Cand); \
+} }
+
+#define COPYPART(P, Q) { memcpy(P->cls, Q->cls, n*sizeof(int)); \
+memcpy(P->inv, Q->inv, n*sizeof(int)); \
+P->cells = Q->cells; \
+P->code = Q->code; } \
+
+#define ADDTONEXTLEVEL { if (SpineTL->listend) { \
+(SpineTL->listend)->next = NewCandidate(n, &GarbList, TRUE); \
+if ((tv->compstage < 2) && (SpineTL->listcounter <= (NAUTY_INFINITY-2))) SpineTL->listcounter++; \
+SpineTL->listend = (SpineTL->listend)->next; \
+CopyCand(SpineTL->listend, NextCand, n, NULL, NULL); \
+} \
+else { \
+SpineTL->liststart = NewCandidate(n, &GarbList, TRUE); \
+if (tv->compstage < 2) SpineTL->listcounter = 1; \
+SpineTL->listend = SpineTL->liststart; \
+CopyCand(SpineTL->liststart, NextCand, n, NULL, NULL); \
+} }
+
+#define ORBITSIZES { memset(OrbSize, 0, n*sizeof(int)); \
+for (i=0; i<n; i++) { \
+OrbSize[tv->orbits[i]]++; \
+} }
+
+#define CURRORBITSIZES { memset(CurrOrbSize, 0, n*sizeof(int)); \
+for (i=SpineTL->tgtcell; i<SpineTL->tgtend; i++) { \
+CurrOrbSize[tv->currorbit[CurrCand->lab[i]]]++; \
+} }
+
+#define EXITFROMSTAGE0REFINE { PRINT_LINE_PLUS(tv->tolevel) \
+if (tv->options->verbosity >= 2) fprintf(outfile, "-=="); \
+CurrCand->indnum--; \
+RemoveFromLevel(tv->tolevel, tv->treedepth, tv->strategy, FALSE); \
+tv->compstage = 1; \
+TempOrbits = NULL; \
+trieroot = trie_new(n, tv); \
+trieref = trieroot; \
+tv->nextlevel = tv->maxtreelevel = tv->fromlevel; \
+ti->thereisnextlevel = TRUE; \
+ti->exitfromref = TRUE; \
+return 0; }
+
+#define EXITFROMSTAGE0EXPATH2 { PRINT_LINE_PLUS(tv->tolevel) \
+if (tv->options->verbosity >= 2) fprintf(outfile, "=-="); \
+tv->compstage = 1; \
+TempOrbits = NULL; \
+trieroot = trie_new(n, tv); \
+trieref = trieroot; \
+tv->nextlevel = tv->maxtreelevel = tv->tolevel; \
+ti->thereisnextlevel = TRUE; \
+ti->exitfromref = FALSE; \
+return 0; }
+
+#define EXITFROMSTAGE0EXPATH1 { PRINT_RETURN PRINT_LINE_PLUS(tv->tolevel) \
+if (tv->options->verbosity >= 2) fprintf(outfile, "==-"); \
+if (SpineTL->liststart) { \
+AuxCand = SpineTL->liststart; \
+SpineTL->liststart = NewCandidate(n, &GarbList, TRUE); \
+CopyCand(SpineTL->liststart, NextCand, n, NULL, NULL); \
+SpineTL->liststart->next = AuxCand; \
+} \
+else { \
+SpineTL->liststart = NewCandidate(n, &GarbList, TRUE); \
+SpineTL->listend = SpineTL->liststart; \
+SpineTL->liststart->next = NULL; \
+CopyCand(SpineTL->liststart, NextCand, n, NULL, NULL); \
+} \
+tv->compstage = 1; \
+TempOrbits = NULL; \
+trieroot = trie_new(n, tv); \
+trieref = trieroot; \
+tv->nextlevel = tv->maxtreelevel = tv->tolevel; \
+ti->thereisnextlevel = TRUE; \
+ti->exitfromref = FALSE; \
+return 0; }
+
+#define UPDATE_LINELGTH { if (tv->options->verbosity >= 2) { \
+if (tv->tolevel < 12) { \
+tv->linelgth = (tv->digits+1)*tv->tolevel+16; \
+} \
+else { \
+tv->linelgth = (tv->digits+1)*10+20; \
+} \
+} }
+
+#define PRINT_LINE { if ((tv->options->verbosity >= 1) && (tv->strategy == 0)) { \
+if (tv->options->verbosity >= 2) { LINE(tv->linelgth, "-"); \
+NEXTLINE} \
+} \
+}
+
+#define PRINT_LINE_PLUS(Lev) { if ((tv->options->verbosity >= 1) && (tv->strategy == 0)) { \
+if (tv->options->verbosity >= 2) { LINE(16+tv->digits+1, "-");} \
+fprintf(outfile, " Level %d:  %d cell%s; %d singleton%s; target cell: %d; %d orbit%s; %lu node%s (%lu kept); %d update%s;", \
+Lev, SS(Spine[Lev].part->cells, "", "s"), SS((Spine[Lev].part->cells == n) ? n : Spine[Lev].singend, "", "s"), Spine[Lev].tgtsize, SS(tv->stats->numorbits, "", "s"), \
+SS(Spine[Lev].levelcounter, "", "s"), Spine[Lev].keptcounter, SS(Spine[Lev].updates, "", "s")); \
+if (Lev <= tv->group_level) fprintf(outfile, " group_level: %d", tv->group_level); \
+NEXTLINE \
+} \
+}
+
+#define PRINT_CANDIDATE(Cand, Lev) { \
+for (tmp = Cand->name, cu = 0; tmp > 0; tmp /= 10, ++cu) {} \
+for (tmp = Lev, cu1 = 0; tmp > 0; tmp /= 10, ++cu1) {} \
+cu = 14-cu-cu1; \
+LINE(cu, "-") \
+fprintf(outfile, " %d, %d) ", Lev % 10000, Cand->name % 10000000); \
+if (Lev < 12) { \
+PRINTCAND(Cand, Lev) \
+} \
+else { \
+PRINTCANDBIG(Cand, Lev) \
+} \
+PRINTCHAR("| ")	\
+fprintf(outfile, "{%x, %x} ", Cand->code, Cand->singcode); \
+}
+
+#define PRINT_CANDIDATEPLUS(PrevCand, Cand, Lev) { \
+for (tmp = Cand->name, cu = 0; tmp > 0; tmp /= 10, ++cu) {} \
+for (tmp = Lev, cu1 = 0; tmp > 0; tmp /= 10, ++cu1) {} \
+cu = 14-cu-cu1; \
+LINE(cu, "-") \
+fprintf(outfile, " %d, %d, %d) ", Lev % 10000, Cand->name % 10000000, PrevCand->name); \
+if (Lev < 12) { \
+PRINTCAND(Cand, Lev) \
+} \
+else { \
+PRINTCANDBIG(Cand, Lev) \
+} \
+PRINTCHAR("| ")	\
+fprintf(outfile, "{%x, %x} ", Cand->code, Cand->singcode); \
+}
+
+#define PRINT_EXPPATHSTEP(Cand, Boo) { \
+if (tv->options->verbosity >= 2) { \
+if ((tv->tolevel_tl-tv->tolevel < 6) || !has_nexttcell) { \
+fprintf(outfile, "%d ", tv->indiv_vtx+labelorg); \
+if (Boo) { \
+if (tv->options->verbosity >= 2) fprintf(outfile, "{%d:%x} ", tv->tcellexpath, Cand->code); \
+} \
+else fprintf(outfile, "{interr.(%d)} ", NextPart->cells); \
+if ((!has_nexttcell) && (tv->compstage == 0)) { \
+fprintf(outfile, "(%d) ", tv->tolevel_tl); \
+} \
+} \
+else { \
+if (tv->tolevel_tl-tv->tolevel == 6) { \
+fprintf(outfile, "... "); \
+} \
+} \
+} \
+}
+
+#define PRINT_RETURN { if (tv->options->verbosity >= 2) { \
+fprintf(outfile, "\n"); \
+} }
+
+#define PRINT_FROM_VERB(Verb,Lev) { if (tv->options->verbosity >= Verb) { \
+fprintf(outfile, "FROM: "); \
+if (Lev < 12) { \
+PRINTCAND(CurrCand, tv->fromlevel) \
+} \
+else { \
+PRINTCANDBIG(CurrCand, tv->fromlevel) \
+} \
+fprintf(outfile, " do_it: %d, indnum: %d, stnode->index: %d ", CurrCand->do_it, CurrCand->indnum, CurrCand->stnode->index); \
+PRINT_RETURN \
+} }
+
+#define PRINT_NOTMIN_VERB(Verb) { if (tv->options->verbosity >= Verb) { \
+fprintf(outfile, " is NOT minimal in orbits (1, %d) [%d]; ", gom_level, CurrCand->lab[Spine[gom_level+1].tgtpos]+labelorg); \
+fprintf(outfile, "at lev %d, orb[%d] = %d.\n", gom_level+1, CurrCand->lab[Spine[gom_level+1].tgtpos]+labelorg, tv->currorbit[CurrCand->lab[Spine[gom_level+1].tgtpos]]+labelorg); } }
+
+#define PRINT_SKIPPED_VERB(Verb) { if (tv->options->verbosity >= Verb) \
+fprintf(outfile, " skipped (0) (orbit[%d] = %d)\n", \
+NextCand->vertex+labelorg, tv->currorbit[NextCand->vertex]+labelorg); }
+
+#define PRINT_REFINE_VERB(Verb,where) { if (tv->options->verbosity >= Verb) \
+fprintf(outfile, " REFINE(%c) (orbit[%d] = %d)\n",where, NextCand->vertex+labelorg, tv->currorbit[NextCand->vertex]+labelorg); }
+
+#define PRINT_INDIV_VERB(Verb,Lev) { if (tv->options->verbosity >= Verb) { \
+if (Lev < 12) { \
+PRINTCAND(CurrCand, tv->fromlevel) \
+} \
+else { \
+PRINTCANDBIG(CurrCand, tv->fromlevel) \
+} \
+fprintf(outfile, "| "); \
+fprintf(outfile, tv->digstring, NextCand->vertex+labelorg); \
+} }
+
+#define PRINT_INDEX(V,Verb,where) if (tv->options->verbosity >= Verb) \
+fprintf(outfile,"Set index @ %d: Name %d, index %d\n",where,V->name,V->index);
+
+#define SPECIALGENERATORS { if (tv->options->generators) addpermutation(ring, AUTPERM, n); \
+tv->stats->numgenerators++; \
+tv->specialgens++; \
+if (tv->options->writeautoms) { \
+fprintf(outfile, "Gen #%d: ", tv->stats->numgenerators); \
+writeperm(outfile, AUTPERM, tv->options->cartesian, tv->options->linelength, n); \
+} \
+if (tv->options->userautomproc) { \
+(*tv->options->userautomproc)(tv->stats->numgenerators, AUTPERM, n); \
+} }
+
+#define UPDATEMIN(A, B) if (B < A) A = B;
+
+#define PAIRORBJOIN(A, V) { if (A != V) { \
+PrmPairs[tv->permInd].arg = A; \
+PrmPairs[tv->permInd].val = V; \
+tv->permInd++; \
+orbjoin_sp_pair(tv->orbits, OrbList, n, A, V, &tv->stats->numorbits); \
+MakeTree(A, V, sg, n, tv, FALSE); \
+} }
+
+#define SETPAIRS(A, V) { if (A != V) { \
+PrmPairs[tv->permInd].arg = A; \
+PrmPairs[tv->permInd].val = V; \
+tv->permInd++; \
+} }
+
+#define SETPAIRSAUT(A, V) { if ((A != V) && (AUTPERM[A] != V)) { \
+AUTPERM[A] = V; \
+PrmPairs[tv->permInd].arg = A; \
+PrmPairs[tv->permInd].val = V; \
+tv->permInd++; \
+} }
+
+#define SETPAIRSAUTANDTREE(arg, val) { if (tv->build_autom) { SETPAIRSAUT(arg, val) } \
+if (arg != val) orbjoin_sp_pair(tv->orbits, OrbList, n, arg, val, &tv->stats->numorbits); \
+MakeTree(arg, val, sg_orig, n, tv, FALSE); }
+
+#define PRINTF2(A, B) if (tv->options->verbosity > 3) printf(A, B)
+#define PRINTF2_2(A, B, C) if (tv->options->verbosity > 3) printf(A, B, C)
+#define PRINTF2_3(A, B, C, D) if (tv->options->verbosity > 3) printf(A, B, C, D)
+#define PRINTF2_4(A, B, C, D, E) if (tv->options->verbosity > 3) printf(A, B, C, D, E)
+
+/* data decls. for CPUTIME */
+#ifdef  CPUDEFS
+CPUDEFS
+#endif
+
+#if !MAXN
+DYNALLSTAT(int, AUTPERM, AUTPERM_sz);
+DYNALLSTAT(int, BreakSteps, BreakSteps_sz);
+DYNALLSTAT(int, CStack, CStack_sz);
+DYNALLSTAT(int, CurrOrbSize, CurrOrbSize_sz);
+DYNALLSTAT(int, CurrRefCells, CurrRefCells_sz);
+DYNALLSTAT(boolean, Diff, Diff_sz);
+DYNALLSTAT(boolean, Factorials, Factorials_sz);
+DYNALLSTAT(int, fix, fix_sz);
+DYNALLSTAT(int, IDENTITY_PERM, IDENTITY_PERM_sz);
+DYNALLSTAT(int, Markers, Markers_sz);
+DYNALLSTAT(int, TreeMarkers, TreeMarkers_sz);
+DYNALLSTAT(int, AutMarkers, AutMarkers_sz);
+DYNALLSTAT(int, MarkHitVtx, MarkHitVtx_sz);
+DYNALLSTAT(int, MultRefCells, MultRefCells_sz);
+DYNALLSTAT(int, NghCounts, NghCounts_sz);
+DYNALLSTAT(int, OrbSize, OrbSize_sz);
+DYNALLSTAT(int, OrbList, OrbList_sz);
+DYNALLSTAT(pair, PrmPairs, PrmPairs_sz);
+DYNALLSTAT(int, TempOrbList, TempOrbList_sz);
+DYNALLSTAT(int, RefCells, RefCells_sz);
+DYNALLSTAT(searchtrie*, RefPath, RefPath_sz);
+DYNALLSTAT(int, Singletons, Singletons_sz);
+DYNALLSTAT(int, SplCls, SplCls_sz);
+DYNALLSTAT(int, SplCnt, SplCnt_sz);
+DYNALLSTAT(int, SplPos, SplPos_sz);
+DYNALLSTAT(int, StackMarkers, StackMarkers_sz);
+DYNALLSTAT(int, TheTrace, TheTrace_sz);
+DYNALLSTAT(int, TheTraceCC, TheTraceCC_sz);
+DYNALLSTAT(int, TheTraceSplNum, TheTraceSplNum_sz);
+DYNALLSTAT(int, TheTraceSteps, TheTraceSteps_sz);
+DYNALLSTAT(int, TEMPLAB, TEMPLAB_sz);
+DYNALLSTAT(int, TEMPINVLAB, TEMPINVLAB_sz);
+DYNALLSTAT(int, WeightsSeq, WeightsSeq_sz);
+DYNALLSTAT(int, WorkArray, WorkArray_sz);
+DYNALLSTAT(int, WorkArray0, WorkArray0_sz);
+DYNALLSTAT(int, WorkArray1, WorkArray1_sz);
+DYNALLSTAT(int, WorkArray2, WorkArray2_sz);
+DYNALLSTAT(int, WorkArray3, WorkArray3_sz);
+DYNALLSTAT(int, WorkArray4, WorkArray4_sz);
+DYNALLSTAT(int, WorkArray5, WorkArray5_sz);
+DYNALLSTAT(int, WorkArray6, WorkArray6_sz);
+DYNALLSTAT(int, WorkArray7, WorkArray7_sz);
+DYNALLSTAT(int, Neighbs1, Neighbs1_sz);
+DYNALLSTAT(int, Neighbs2, Neighbs2_sz);
+DYNALLSTAT(int, TreeStack, TreeStack_sz);
+DYNALLSTAT(TracesSpine, Spine, Spine_sz);
+DYNALLSTAT(trie*, TrieArray, TrieArray_sz);
+DYNALLSTAT(grph_strct, TheGraph, TheGraph_sz);
+DYNALLSTAT(ExpPathInfo, EPCodes, EPCodes_sz);
+#else
+static TLS_ATTR int CStack[MAXN];
+static TLS_ATTR int AUTPERM[MAXN];
+static TLS_ATTR int BreakSteps[MAXN];
+static TLS_ATTR int CurrOrbSize[MAXN];
+static TLS_ATTR int CurrRefCells[MAXN];
+static TLS_ATTR boolean Diff[MAXN];
+static TLS_ATTR boolean Factorials[MAXN];
+static TLS_ATTR int fix[MAXN];
+static TLS_ATTR int IDENTITY_PERM[MAXN];
+static TLS_ATTR int Markers[MAXN];
+static TLS_ATTR int TreeMarkers[MAXN];
+static TLS_ATTR int AutMarkers[MAXN];
+static TLS_ATTR int MarkHitVtx[MAXN];
+static TLS_ATTR int MultRefCells[MAXN];
+static TLS_ATTR int NghCounts[MAXN];
+static TLS_ATTR int OrbSize[MAXN];
+static TLS_ATTR int OrbList[MAXN];
+static TLS_ATTR pair PrmPairs[MAXN];
+static TLS_ATTR int TempOrbList[MAXN];
+static TLS_ATTR int RefCells[MAXN];
+static TLS_ATTR searchtrie* RefPath[MAXN];
+static TLS_ATTR int Singletons[MAXN];
+static TLS_ATTR int SplCls[MAXN];
+static TLS_ATTR int SplCnt[MAXN];
+static TLS_ATTR int SplPos[MAXN];
+static TLS_ATTR int StackMarkers[MAXN];
+static TLS_ATTR int TheTrace[MAXN];
+static TLS_ATTR int TheTraceCC[MAXN];
+static TLS_ATTR int TheTraceSplNum[MAXN];
+static TLS_ATTR int TheTraceSteps[MAXN];
+static TLS_ATTR int TEMPLAB[MAXN];
+static TLS_ATTR int TEMPINVLAB[MAXN];
+static TLS_ATTR int WeightsSeq[MAXN];
+static TLS_ATTR int WorkArray[MAXN];
+static TLS_ATTR int WorkArray0[MAXN];
+static TLS_ATTR int WorkArray1[MAXN];
+static TLS_ATTR int WorkArray2[MAXN];
+static TLS_ATTR int WorkArray3[MAXN];
+static TLS_ATTR int WorkArray4[MAXN];
+static TLS_ATTR int WorkArray5[MAXN];
+static TLS_ATTR int WorkArray6[MAXN];
+static TLS_ATTR int WorkArray7[MAXN];
+static TLS_ATTR int TreeStack[MAXN];
+static TLS_ATTR TracesSpine Spine[MAXN];
+static TLS_ATTR trie* TrieArray[MAXN];
+static TLS_ATTR grph_strct TheGraph[MAXN];
+static TLS_ATTR int Neighbs1[MAXN];
+static TLS_ATTR int Neighbs2[MAXN];
+static TLS_ATTR ExpPathInfo EPCodes[MAXN];
+#endif
+
+#define PERMSTACK WorkArray1
+#define CYCLES WorkArray1
+#define HitCls WorkArray2
+#define CYCOLR WorkArray2
+#define HitVtx WorkArray3
+#define CYLGTH WorkArray3
+#define CYMULT WorkArray4
+#define HitCount WorkArray5
+#define ElmHitCll WorkArray5
+#define CYCPOS WorkArray5
+#define CYCHIT TempOrbList
+#define LGHATTR RefCells
+#define CYCREP MultRefCells
+#define TempOrbSize TEMPLAB
+#define AutomCount TEMPINVLAB
+#define CanonIndices MarkHitVtx
+#define NSFCells NghCounts
+#define TreeNodes AutMarkers
+#define CellMarkers1 WorkArray6
+#define CellMarkers2 WorkArray7
+#define SingNonSing Singletons
+
+static TLS_ATTR FILE *outfile;
+
+/* Brendan's SCHREIER */
+static TLS_ATTR schreier  *gpB;				/* This will point to the Schreier structure */
+static TLS_ATTR permnode  *gensB;			/* This will point to the stored generators */
+
+static TLS_ATTR Candidate *GarbList, *SpOrd, *SpCyc, *SpSwp;
+static TLS_ATTR Partition *SpPart1, *SpPart2;
+static TLS_ATTR TracesSpine *SpineTL, *SpineFL, *SpineTL_tl;
+static TLS_ATTR trie *trieroot, *trieref;
+static TLS_ATTR int *TempOrbits = NULL;
+static TLS_ATTR sparsegraph redgraph;
+
+
+void
+Traces(sparsegraph *g_arg, int *lab, int *ptn,
+       int *orbits_arg, TracesOptions *options_arg, TracesStats *stats_arg,
+       sparsegraph *canong_arg) {
+    int i, j;
+    int tmp;
+    int deg, vtx1, vtx2, *ngh1, *ngh2, *wgh1, *wgh2, ord;
+    size_t j1;
+    
+    trielist *STStart, *STAux;
+    searchtrie *TrieNode;
+    int retval;
+    Partition *CurrPart, *NextPart;
+    Candidate *CurrCand, *NextCand, *BestCand, *AuxCand;
+    
+    const int n = g_arg->nv;
+    const int m = SETWORDSNEEDED(n);
+    
+    if (g_arg->nv > (NAUTY_INFINITY-2))
+    {
+        fprintf(ERRFILE, "Traces: need n <= %d, but n=%d\n\n",
+                NAUTY_INFINITY-2, g_arg->nv);
+        return;
+    }
+    
+    Allocate_Traces_Structures(n);
+    
+    struct TracesVars *tv = malloc(sizeof(struct TracesVars));
+    if (tv == NULL) {
+        fprintf(ERRFILE, "\nError, memory not allocated.\n");
+        exit(1);
+    }
+    struct TracesInfo *ti = malloc(sizeof(struct TracesInfo));
+    if (ti == NULL) {
+        fprintf(ERRFILE, "\nError, memory not allocated.\n");
+        exit(1);
+    }
+    
+    trieroot = NULL;
+    NextCand = GarbList = NULL;
+    DYNFREE(g_arg->w,g_arg->wlen);   /* to be removed in presence of weightd edges */
+    
+    Initialize_Traces_Variables(tv, options_arg, stats_arg, orbits_arg, g_arg, canong_arg, n);
+    
+    outfile = (tv->options->outfile == NULL ? stdout : tv->options->outfile);
+    
+    SpOrd = SpCyc = SpSwp = NULL;
+    SpPart1 = SpPart2 = NULL;
+    
+    if (tv->options->verbosity >= 2) {
+        for (i = n, tv->digits = 0; i > 0; i /= 10, ++tv->digits) {}
+        sprintf(tv->digstring, "%s%dd ", "%", tv->digits);
+    }
+    
+    /* Initialize group and statistics */
+    Initialize_Traces_Statistics(stats_arg,n);
+    
+    if (tv->options->verbosity >= 2) {
+        Initialize_Traces_Time_Variables(tv);
+    }
+    
+    /* Initialize lab and ptn when in the unit partition case */
+    if (tv->options->defaultptn) {
+        for (i = 0; i < n; i++) {
+            IDENTITY_PERM[i] = i;
+            ptn[i] = NAUTY_INFINITY;
+        }
+        ptn[n-1] = 0;
+        memcpy(lab, IDENTITY_PERM, n*sizeof(int));
+    } else {
+        for (i = 0; i < n; i++) {
+            IDENTITY_PERM[i] = i;
+        }
+    }
+    
+    memcpy(orbits_arg, IDENTITY_PERM, n*sizeof(int));
+    
+    if (tv->options->generators) {
+        tv->stats->numorbits = given_gens(g_arg, *tv->options->generators,
+                                          orbits_arg, tv->options->digraph);
+        newgroup(&gpB, NULL, n);
+        gensB = *tv->options->generators;
+        expandschreier(gpB, &gensB, n);
+        ti->thegrouphaschanged = TRUE;
+        ti->identitygroup = FALSE;
+        memcpy(OrbList, gpB->orbits, n*sizeof(int));
+    }
+    else {
+        newgroup(&gpB, &gensB, n);
+        memcpy(OrbList, IDENTITY_PERM, n*sizeof(int));
+        tv->stats->numorbits = n;
+        ti->thegrouphaschanged = FALSE;
+        ti->identitygroup = TRUE;
+    }
+    
+    copy_sg_structure(&redgraph, g_arg);
+    
+    tv->graph = &redgraph;
+    if (g_arg->w) memcpy(tv->graph->w, g_arg->w, tv->graph->wlen*sizeof(int));
+    memcpy(tv->graph->e, g_arg->e, tv->graph->elen*sizeof(int));
+    
+    for (i=0; i<n; i++) {
+        EPCodes[i].info = 0;
+        TheGraph[i].d = g_arg->d[i];
+        if (TheGraph[i].d > tv->maxdeg) {
+            tv->maxdeg = TheGraph[i].d;
+        }
+        if (TheGraph[i].d < tv->mindeg) {
+            tv->mindeg = TheGraph[i].d;
+        }
+        TheGraph[i].e = tv->graph->e + g_arg->v[i];
+        if (g_arg->w)
+            TheGraph[i].w = tv->graph->w + g_arg->v[i];
+        else
+            TheGraph[i].w = NULL;
+        TheGraph[i].one = FALSE;
+    }
+    
+    ord = 0;
+    
+    /*----------- WEIGHTS --------------*/
+    if (tv->options->weighted) {
+        WeightCodes(n);
+        ord = trie_classify(n,tv);
+    }
+    /*----------------------------------*/
+    
+    if ((tv->maxdeg == tv->mindeg) && (ord == 0)) ti->regular = TRUE; else ti->regular = FALSE;
+    
+    tv->currorbit = gpB->orbits;
+    
+    memcpy(AUTPERM, IDENTITY_PERM, n*sizeof(int));
+    tv->permInd = 0;
+    
+    memset(fix, 0, n*sizeof(int));
+    memset(TheTraceCC, 0, n*sizeof(int));
+    memset(Factorials, 0, n*sizeof(int));
+    /* ran_init(1234);  any long int as an argument */
+    
+    /* The graph is sparse? */
+    if (g_arg->nde < n || g_arg->nde / n < n / (g_arg->nde / n)) {
+        ti->thegraphisparse = TRUE;
+    }
+    else {
+        ti->thegraphisparse = FALSE;
+    }
+    
+    tv->preprocessed = 0;
+    ti->deg_one = FALSE;
+    ti->first_matching = FALSE;
+    retval = 0;
+    
+    /* Initialize candidate, partition, cells, orbits */
+    Spine[0].part = NewPartition(n);
+    CurrPart = Spine[0].part;
+    memset(CurrPart->inv, 0, n*sizeof(int));
+    
+    NextPart = NewPartition(n);
+    CurrCand = NewCandidate(n, &GarbList, TRUE);
+    
+    CurrCand->singcode = 0;
+    TempOrbits = NULL;
+    STStart = NULL;
+    
+    if (ti->regular) {
+        if (tv->options->defaultptn) {
+            memcpy(CurrCand->lab, IDENTITY_PERM, n*sizeof(int));
+            memcpy(CurrCand->invlab, IDENTITY_PERM, n*sizeof(int));
+            CurrPart->cells = 1;
+            CurrPart->cls[0] = n;
+            TheTrace[0] = 0;
+        }
+        else {
+            memcpy(CurrCand->lab, lab, n*sizeof(int));
+            CurrPart->cells = 0;
+            j = 0;
+            for (i = 0; i < n; i++) {
+                if (j) CurrPart->inv[i] = j;
+                CurrCand->invlab[CurrCand->lab[i]] = i;
+                if (!ptn[i]) {
+                    CurrPart->cls[j] = i-j+1;
+                    if (CurrPart->cls[j] == 1) {
+                        CurrCand->singcode = MASHCOMM(CurrCand->singcode, CurrCand->lab[j]);
+                    }
+                    TheTrace[CurrPart->cells++] = j;
+                    j = i+1;
+                }
+            }
+        }
+    } else {
+        if (tv->options->weighted) {
+            CurrPart->cells = traces_vertexclass_refine(n, lab, ptn,
+                                                        CurrCand, CurrPart, WeightsSeq);
+        }
+        else {
+            CurrPart->cells = traces_vertexclass_refine (n, lab, ptn,
+                                                         CurrCand, CurrPart, g_arg->d);
+        }
+    }
+    
+    memset(NghCounts,0,n*sizeof(int));
+    if (tv->options->verbosity == 7) PrintPartition(CurrCand->lab,CurrPart->cls,n,labelorg,1323);
+    
+    /* Check for deg 1 vertices */
+    ti->deg_one = Check_degree_one(g_arg, CurrCand, CurrPart, n);
+    
+#if !MAXN
+    DYNALLOC1(int, Neighbs1, Neighbs1_sz, tv->maxdeg, "Traces");
+    DYNALLOC1(int, Neighbs2, Neighbs2_sz, tv->maxdeg, "Traces");
+#endif
+    
+    if (ti->deg_one) {
+        tv->preprocessed = Preprocess(g_arg, &gensB, CurrCand, n, CurrPart, tv);
+    }
+    
+    if (tv->preprocessed) {
+        memset(Diff,0,n*sizeof(boolean));
+        for (i=0; i<n; i++) {
+            if ((TheGraph[i].d > 1) && (tv->input_graph->d[i] != TheGraph[i].d))
+                Diff[i] = TRUE;
+        }
+    }
+    
+    /* Initialization of Spine structure */
+    SpineFL = Spine;
+    SpineFL->tgtcell = SpineFL->tgtpos = 0;
+    SpineFL->tgtend = n;
+    SpineFL->tgtfrom = -1;
+    SpineFL->trcstart = 0;
+    SpineFL->trcend = CurrPart->active = CurrPart->cells;
+    SpineFL->ccstart = SpineFL->ccend = 0;
+    SpineFL->stpstart = SpineFL->stpend = 0;
+    SpineFL->singstart = SpineFL->singend = 0;
+    SpineFL->thetracexists = FALSE;
+    SpineFL->liststart = SpineFL->listend = CurrCand;
+    SpineFL->levelcounter = 1;
+    SpineFL->keptcounter = 1;
+    SpineFL->updates = 1;
+    
+    /* Further initializations */
+    tv->maxtreelevel = 0;
+    tv->tolevel = 0;
+    tv->tcell = 0;
+    UPDATE_LINELGTH
+    
+    /* First refinement */
+    if (tv->preprocessed < 2)
+        traces_refine(CurrCand, n, CurrPart, tv, ti, 0, FALSE);
+    
+    CurrCand->name = 0;
+    
+    if (CurrPart->cells == n) {
+        tv->stats->canupdates++;
+        
+        /* CANONICAL FORM ? */
+        if (tv->options->getcanon) {
+            memcpy(lab, CurrCand->lab, n*sizeof(int));
+            if (canong_arg) memcpy(CurrPart->inv, CurrCand->invlab, n*sizeof(int));
+            if (tv->options->usercanonproc != NULL)
+            {
+                (*tv->options->usercanonproc)((graph*)g_arg, lab, (graph*)canong_arg, tv->stats->canupdates, CurrCand->code, m, n);
+            }
+        }
+    }
+    else {
+        STStart = searchtrie_new(n, tv);
+        CurrCand->stnode = tv->strielist->triearray;
+        NextCand = NewCandidate(n, &GarbList, TRUE);
+        SpineFL->listcounter = 1;
+        tv->tcellevel = 0;
+        ti->exitfromref = FALSE;
+        Spine[1].levelcounter = 0;
+        Spine[1].updates = 0;
+        Spine[1].tgtfrom = 0;
+        
+        memset(WorkArray, 0, n*sizeof(int));
+        
+        do {
+            tv->fromlevel = tv->tolevel;
+            SpineFL = Spine+tv->fromlevel;
+            
+            if (CurrCand) {
+                switch (tv->compstage) {
+                    case 0: retval = CompStage0(CurrPart, NextPart, CurrCand, NextCand, m, n, tv, ti);
+                        break;
+                    case 1:
+                        if (!TempOrbits) {
+                            memcpy(WorkArray1, tv->currorbit, n*sizeof(int));
+                            TempOrbits = WorkArray1;
+                        }
+                        memset(TempOrbSize, 0, n*sizeof(int));
+                        for (i=SpineTL->tgtcell; i<SpineTL->tgtend; i++) {
+                            TempOrbSize[TempOrbits[CurrCand->lab[i]]]++;
+                        }
+                        retval = CompStage1(CurrPart, NextPart, CurrCand, NextCand, m, n, tv, ti);
+                        break;
+                    case 2:
+                        retval = CompStage2(CurrPart, NextPart, CurrCand, NextCand, m, n, tv, ti);
+                        break;
+                    default:
+                        break;
+                }
+                if (retval == NAUTY_ABORTED)
+                    tv->stats->errstatus = NAUABORTED;
+                else if (retval == NAUTY_KILLED) {
+                    tv->stats->errstatus = NAUKILLED;
+                    return;
+                }
+            }
+            
+            /* NEXT CANDIDATE */
+            if (ti->thereisnextlevel) {
+                if (tv->nextlevel != tv->fromlevel) {
+                    UPDATE_LINELGTH
+                }
+                tv->tolevel = tv->nextlevel;
+                CurrCand = Spine[tv->nextlevel].liststart;
+                CurrPart = Spine[tv->nextlevel].part;
+            }
+        }
+        while (ti->thereisnextlevel);
+        
+        if (!retval) {
+            if (tv->compstage) {
+                memset(CurrOrbSize, 0, n*sizeof(int));
+                for (i=0; i<n; i++) {
+                    CurrOrbSize[TempOrbits[i]]++;
+                }
+            }
+            
+            if (!tv->options->getcanon) {
+                if (tv->compstage) {
+                    tv->maxtreelevel++;
+                    TrieNode = Spine[tv->maxtreelevel].liststart->stnode;
+                    if (TrieNode->father) {
+                        TrieNode = TrieNode->father;
+                    }
+                    if (!ti->exitfromref) {
+                        TrieNode->index = 0;
+                        for (i=1; i<AutomCount[0]; i++) {
+                            TrieNode->index += CurrOrbSize[AutomCount[i]];
+                            PRINT_INDEX(TrieNode,4,30)
+                        }
+                    }
+                }
+            }
+            
+            if (tv->maxtreelevel) PRINT_LINE_PLUS(tv->maxtreelevel);
+            
+            AuxCand = Spine[tv->maxtreelevel].liststart;
+            while (!AuxCand->do_it) {
+                AuxCand = AuxCand->next;
+            }
+            
+            /* CANONICAL FORM ? */
+            if (tv->options->getcanon) {
+                BestCand = AuxCand;
+                AuxCand = AuxCand->next;
+                while (AuxCand) {
+                    if (AuxCand->do_it) {
+                        if (comparelab_tr(g_arg, BestCand->lab, BestCand->invlab, AuxCand->lab, AuxCand->invlab, Spine[tv->maxtreelevel].part->cls, Spine[tv->maxtreelevel].part->inv) == 1) {
+                            BestCand = AuxCand;
+                            tv->stats->canupdates++;
+                            if (tv->options->usercanonproc != NULL)
+                            {
+                                (*tv->options->usercanonproc)((graph*)g_arg, lab, (graph*)canong_arg, tv->stats->canupdates, CurrCand->code, m, n);
+                            }
+                        }
+                    }
+                    AuxCand = AuxCand->next;
+                }
+                
+                grouporderplus(g_arg, BestCand, Spine[tv->maxtreelevel].part, &gensB, &(tv->stats->grpsize1), &(tv->stats->grpsize2), n, tv, ti);
+                
+                if (tv->options->verbosity >= 2) {
+                    LINE(32, "—")
+                    NEXTLINE
+                    fprintf(outfile, "Canonical:");
+                    PRINTCAND(BestCand, tv->maxtreelevel)
+                    PRINT_RETURN
+                }
+                memcpy(lab, BestCand->lab, n*sizeof(int));
+                if (canong_arg) memcpy(CurrPart->inv, BestCand->invlab, n*sizeof(int));
+            }
+            else {
+                grouporderplus(g_arg, AuxCand, Spine[tv->maxtreelevel].part, &gensB, &(tv->stats->grpsize1), &(tv->stats->grpsize2), n, tv, ti);
+            }
+            
+            if (tv->options->verbosity >= 2) {
+                if (tv->linelgth < 40) {
+                    tv->linelgth = 40;
+                }
+                LINE(32, "—")
+                NEXTLINE
+            }
+            
+        }
+    }
+    tv->stats->treedepth = tv->treedepth;
+    if (Spine[tv->treedepth].part->code == -1) {
+        tv->stats->treedepth--;
+    }
+    
+    if (tv->options->verbosity >= 2) {
+        fprintf(outfile, "group time: %.2f, %.2f, %.2f; total: %.2f; exp_paths time: %.2f; aut_check time: %.2f\n%lu refinement%s interrupted by trace comparison (%s); special cells: %d\n------", tv->schreier1, tv->schreier2, tv->schreier3, tv->schreier1+tv->schreier2+tv->schreier3,
+                tv->expaths, tv->autchk, SS(tv->stats->interrupted, "", "s"), (tv->options->strategy == 0 ? "breadth-first" : "depth-first"), tv->specialgens);
+        PRINT_RETURN
+    }
+    if (tv->options->verbosity >= 3) fprintf(outfile, "CPYCAND(0): %d, ID<-TMPORB(1): %d, LAB(2): %d, PART(3): %d, TEMP(4)->: %d, TEMP(5)<-: %d, CHKFORAUT(6): %d, ISAUT(7): %d, ContaTC: %d\n", tv->conta0, tv->conta1, tv->conta2, tv->conta3, tv->conta4, tv->conta5, tv->conta6, tv->conta7, tv->contatc);
+    
+    if (tv->options->getcanon && canong_arg) {
+        canong_arg->nv  = g_arg->nv;
+        canong_arg->nde  = g_arg->nde;
+        SG_ALLOC(*canong_arg, g_arg->nv, g_arg->nde, "traces canong");
+        updatecan_tr(g_arg, canong_arg, lab, CurrPart->inv, 0);
+    }
+    
+    if (tv->options->generators) {
+        deleteunmarked(&gensB);
+        *tv->options->generators = gensB;
+        freeschreier(&gpB, NULL);
+    }
+    else {
+        freeschreier(&gpB, &gensB);
+        schreier_freedyn();
+    }
+    
+    while (STStart) {
+        STAux = STStart;
+        free(STAux->triearray);
+        STStart = STStart->next;
+        free(STAux);
+    }
+    
+    tv->canlist = 0;
+    for (i=0; i<=tv->treedepth; i++) {
+        if (Spine[i].liststart) {
+            tv->canlist += FreeList(Spine[i].liststart, TRUE);
+            Spine[i].liststart = Spine[i].listend = NULL;
+        }
+    }
+    
+    if (GarbList) {
+        tv->stats->peaknodes = FreeList(GarbList, FALSE);
+    }
+    
+    FREECAND(NextCand)
+    FREECAND(SpOrd)
+    FREECAND(SpCyc)
+    FREECAND(SpSwp)
+    FREEPART(NextPart)
+    FREEPART(SpPart1)
+    FREEPART(SpPart2)
+    
+    if (!tv->options->getcanon && trieroot) {
+        for (i=0; i<=tv->triepos; i++) {
+            free(TrieArray[i]);
+        }
+    }
+    
+    for (i=0; i <= tv->treedepth; i++) {
+        FREEPART(Spine[i].part)
+    }
+    
+    CurrCand = GarbList = NULL;
+    tv->stats->peaknodes += tv->canlist;
+    
+    if (tv->graph != g_arg) {
+        SG_FREE(redgraph);
+    }
+    free(tv);
+    free(ti);
+    traces_freedyn();
+    
+    return;
+}
+
+int traces_vertexclass_refine (int n, int *lab, int *ptn, Candidate *Cand, Partition *Part, int *RefArray) {
+    
+    int i, j, k, aux, cells, end;
+    
+    memcpy(Cand->lab, lab, n*sizeof(int));
+    
+    cells = 0;
+    j = 0;
+    
+    for (i = 0; i < n; i++) {
+        WorkArray1[i] = RefArray[Cand->lab[i]];
+        if (!ptn[i]) {
+            TheTrace[cells++] = j;
+            
+            sort2ints(WorkArray1+j,Cand->lab+j,i-j+1);
+            
+            aux = WorkArray1[j];
+            Part->cls[j] = 1;
+            Part->inv[j] = j;
+            Cand->invlab[Cand->lab[j]] = j;
+            
+            if (i == j) {
+                Cand->singcode = MASHCOMM(Cand->singcode, Cand->lab[j]);
+                j++;
+            } else {
+                end = i+1;
+                for (k=j+1; k<end; k++) {
+                    if (WorkArray1[k] == aux) {
+                        (Part->cls[j])++;
+                        Part->inv[k] = j;
+                        Cand->invlab[Cand->lab[k]] = k;
+                    } else {
+                        if (Part->cls[j] == 1) {
+                            Cand->singcode = MASHCOMM(Cand->singcode, Cand->lab[j]);
+                        }
+                        
+                        TheTrace[cells++] = k;
+                        j = k;
+                        aux = WorkArray1[j];
+                        Part->cls[j] = 1;
+                        Part->inv[j] = j;
+                        Cand->invlab[Cand->lab[j]] = j;
+                    }
+                }
+                j = end;
+            }
+        }
+    }
+    return cells;
+}
+
+int traces_refine(Candidate *Cand,
+                  int n,
+                  Partition *Part,
+                  struct TracesVars* tv,
+                  struct TracesInfo *ti,
+                  int num_indv,
+                  boolean make_code) {
+    
+    int i, j, k, jk, sc, ind0, ind1, ind2, ind3, ind4, tlp1, labi;
+    int value, iend, newcell;
+    int HitClsInd, SplInd, SplCntInd, CStackInd, TraceInd, TraceCCInd, TraceStepsInd, SingInd;
+    int j1int, iend1int;
+    unsigned int longcode;
+    int newtrace = FALSE;
+    int Sparse = TRUE;
+    int *lab, *cls, *InvLab, *TracePos, *SplitCell, *LabCell, *TraceEnd, Traceccend, *Tracestpend;
+    int BigCell, BigCellPos, BigCellSize;
+    boolean TraceCell = FALSE;
+    int *nghb;
+    int conta;
+    const int variation = 0;
+    int currentweight, weightstart, weightend, currentcell, currentsize;
+    
+    HitClsInd = 0;
+    if (tv->stackmark > (NAUTY_INFINITY-2)) {
+        memset(StackMarkers, 0, n*sizeof(int));
+        tv->stackmark = 0;
+    }
+    tv->stackmark++;
+    tv->augmented_cells = Part->cells;
+    
+    SpineTL = Spine+tv->tolevel;
+    TraceEnd = &(SpineTL->trcend);
+    Traceccend = SpineTL->ccend;
+    Tracestpend = &(SpineTL->stpend);
+    TraceCCInd = SpineTL->ccstart;
+    TraceStepsInd = SpineTL->stpstart;
+    
+    SingInd = SpineTL->singstart + num_indv;
+    
+    lab = Cand->lab;
+    InvLab = Cand->invlab;
+    cls = Part->cls;
+    
+    UPDATEMIN(Part->active, n-1);
+    memcpy(CStack+1, TheTrace+SpineTL->trcstart, (Part->active)*sizeof(int));
+    CStackInd = Part->active;
+    for (i = 1; i <= CStackInd; i++) {
+        StackMarkers[CStack[i]] = tv->stackmark;
+    }
+    
+    longcode = Part->cells;
+    TraceInd = SpineTL->trcstart+Part->active;
+    if (!SpineTL->thetracexists) {
+        newtrace = TRUE;
+    }
+    conta=0;
+    
+    while (CStackInd > 0) {
+        
+        weightend = 0;
+        
+        if (tv->mark > (NAUTY_INFINITY-2)) {
+            memset(Markers, 0, n*sizeof(int));
+            memset(MarkHitVtx, 0, n*sizeof(int));
+            tv->mark = 0;
+        }
+        tv->mark++;
+        
+        if (Part->cells == n) break;
+        
+        k = Select_from_CStack(cls, CStackInd);
+        
+        currentcell = CStack[k];
+        currentsize = currentcell+cls[currentcell];
+        CStack[k] = CStack[CStackInd--];
+        StackMarkers[currentcell] = 0;
+        
+        labi = lab[currentcell];
+        iend1int = TheGraph[labi].d;
+        nghb =  TheGraph[labi].e;
+        
+        do {
+            ind0 = currentcell;
+            ind2 = currentsize;
+            weightstart = weightend;
+            
+            if (tv->options->weighted) {
+                currentweight = (TheGraph[labi].w)[weightstart];
+                while ((iend1int > weightend) && ((TheGraph[labi].w)[weightend] == currentweight)) {
+                    weightend++;
+                }
+            } else {
+                weightend = TheGraph[labi].d;
+            }
+            
+            if (!newtrace) {
+                TraceCell = ((ind0 == TheTraceCC[TraceCCInd]) && (TraceCCInd < Traceccend));
+            }
+            
+            /* Analysis of occurrences of neighbors of the current cell */
+            /* The list of cells with neighbors in the current cell is  built */
+            if (cls[ind0] == 1) {			/* SINGLETON CURRENT CELL CASE */
+                
+                /* NEIGHCOUNT_SING_MULT */
+                HitClsInd = 0;
+                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                    k = nghb[j1int];
+                    value = Part->inv[InvLab[k]];
+                    if (cls[value] > 1) {
+                        if (Markers[value] != tv->mark) {
+                            HitCls[HitClsInd++] = value;
+                            Markers[value] = tv->mark;
+                            ElmHitCll[value] = value;
+                        }
+                        HitVtx[ElmHitCll[value]++] = k;
+                    } else {
+                        switch (variation) {
+                            case 1:
+                                longcode = MASHCOMM(longcode, value);
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                }
+                /* end NEIGHCOUNT_SING_MULT */
+                
+                tv->mark++;
+                FIND_SPLIT_CELLS;
+                
+                /* SINGLETON CC CASE */
+                if (SplInd) {
+                    if (newtrace) {
+                        TheTraceCC[TraceCCInd] = ind0;
+                    }
+                    if (!TraceCell) {
+                        TheTraceCC[TraceCCInd] = ind0;
+                        newtrace = TRUE;
+                    }
+                    
+                    TRACE_CHECK(TheTraceSplNum, TraceCCInd, SplInd, &Traceccend)
+                    
+                    /* Sorting the cells to be split */
+                    sort_Split_Array(SplCls, SplInd);
+                    
+                    for (j = 0; j < SplInd; j++) {
+                        ind1 = SplCls[j];
+                        i = ind1+cls[ind1]-ElmHitCll[ind1];
+                        TRACE_CHECK(TheTrace, TraceInd, i, TraceEnd)
+                    }
+                    
+                    for (j = 0; j < SplInd; j++) {
+                        /* REARRANGE_CELLS */
+                        ind1 = SplCls[j];
+                        cls[ind1] = cls[ind1]-ElmHitCll[ind1];
+                        newcell = ind1+cls[ind1];
+                        cls[newcell] = ElmHitCll[ind1];
+                        Part->cells++;
+                        if (StackMarkers[ind1] != tv->stackmark) {
+                            if (cls[newcell] < cls[ind1]) {
+                                CStack[++CStackInd] = newcell;
+                                StackMarkers[newcell] = tv->stackmark;
+                            }
+                            else {
+                                CStack[++CStackInd] = ind1;
+                                StackMarkers[ind1] = tv->stackmark;
+                            }
+                        }
+                        else {
+                            CStack[++CStackInd] = newcell;
+                            StackMarkers[newcell] = tv->stackmark;
+                        }
+                        SplitCell = HitVtx+ind1;
+                        ind3 = cls[newcell];
+                        LabCell = lab+newcell;
+                        for (jk = 0; jk < ind3; jk++) {
+                            k = SplitCell[jk];
+                            i = LabCell[jk];
+                            Part->inv[newcell+jk] = newcell;
+                            lab[InvLab[k]] = i;
+                            InvLab[i] = InvLab[k];
+                            LabCell[jk] = k;
+                            InvLab[k] = newcell+jk;
+                        }
+                        /* END REARRANGE_CELLS */
+                        
+                        if (cls[ind1] == 1) {
+                            Cand->singcode = MASHCOMM(Cand->singcode, Cand->lab[ind1]);
+                            if (newtrace) Singletons[SingInd] = ind1;
+                            SingInd++;
+                        }
+                        if (cls[newcell] == 1) {
+                            Cand->singcode = MASHCOMM(Cand->singcode, Cand->lab[newcell]);
+                            if (newtrace) Singletons[SingInd] = newcell;
+                            SingInd++;
+                        }
+                    }
+                }
+                else {
+                    if ((!newtrace) && TraceCell) {
+                        if (!tv->options->weighted) return 0;
+                    }
+                }
+            }
+            else {
+                if (ti->thegraphisparse) {
+                    
+                    /* NEIGHCOUNT_SPARSE_MULT */
+                    if (cls[ind0] != n) {
+                        HitClsInd = 0;
+                        for (i = ind0; i < ind2; i++) {
+                            labi = lab[i];
+                            nghb = TheGraph[labi].e;
+                            for (j = weightstart; j < weightend; j++) {
+                                k = nghb[j];
+                                if (MarkHitVtx[k] == tv->mark) {
+                                    NghCounts[k]++;
+                                }
+                                else {
+                                    value = Part->inv[InvLab[k]];
+                                    if (cls[value] > 1) {
+                                        MarkHitVtx[k] = tv->mark;
+                                        NghCounts[k] = 1;
+                                        if (Markers[value] != tv->mark) {
+                                            HitCls[HitClsInd++] = value;
+                                            Markers[value] = tv->mark;
+                                            HitVtx[value] = k;
+                                            ElmHitCll[value] = 1;
+                                        }
+                                        else {
+                                            HitVtx[value+ElmHitCll[value]++] = k;
+                                        }
+                                    }
+                                    else {
+                                        switch (variation) {
+                                            case 1:
+                                                longcode = MASHCOMM(longcode, value);
+                                                break;
+                                            default:
+                                                break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    /* End NEIGHCOUNT_SPARSE_MULT */
+                    
+                    tv->mark++;
+                    
+                    SplInd = 0;
+                    SplCls[0] = n;
+                    for (j = 0; j < HitClsInd; j++) {
+                        ind1 = HitCls[j];
+                        if ((ElmHitCll[ind1] > 0) && (ElmHitCll[ind1] < cls[ind1])) {
+                            SplCls[SplInd++] = ind1;
+                        }
+                        else {
+                            ind2 = ind1+cls[ind1];
+                            value = NghCounts[lab[ind1++]];
+                            for (i = ind1; i < ind2; i++)
+                            {
+                                if (NghCounts[lab[i]] != value)
+                                {
+                                    SplCls[SplInd++] = HitCls[j];
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    
+                    /* SPARSE CASE */
+                    if (SplInd) {
+                        if (newtrace) {
+                            TheTraceCC[TraceCCInd] = ind0;
+                        }
+                        if (!TraceCell) {
+                            TheTraceCC[TraceCCInd] = ind0;
+                            newtrace = TRUE;
+                        }
+                        TRACE_CHECK(TheTraceSplNum, TraceCCInd, SplInd+n, &Traceccend)
+                        
+                        /* Sorting the cells to be split */
+                        sort_Split_Array(SplCls, SplInd);
+                        
+                        for (sc = 0; sc < SplInd; sc++) {	/* For each cell C to be split */
+                            ind0 = SplCls[sc];
+                            ind1 = ind0 + cls[ind0];
+                            SplCntInd = 0;
+                            if (ElmHitCll[ind0] < cls[ind0]) {
+                                SplCnt[SplCntInd++] = 0;
+                                SplPos[0] = cls[ind0] - ElmHitCll[ind0];
+                            }
+                            
+                            /* According to the numbers of neighbors of C into the current cell */
+                            /* compute how many vertices in C will be placed into the same new cell */
+                            iend = ind0 + ElmHitCll[ind0];
+                            for (i = ind0; i < iend; i++) {
+                                value = NghCounts[HitVtx[i]];
+                                if (Markers[value] != tv->mark) {
+                                    Markers[value] = tv->mark;
+                                    SplCnt[SplCntInd++] = value;
+                                    SplPos[value] = 1;
+                                }
+                                else {
+                                    SplPos[value]++;
+                                }
+                            }
+                            tv->mark++;
+                            
+                            if (SplCntInd) {
+                                TRACE_CHECK(TheTraceSteps, TraceStepsInd, SplCntInd+n, Tracestpend)
+                            }
+                            
+                            /* Sort the values deriving from the previous step */
+                            sort_Split_Array(SplCnt,SplCntInd);
+                            Part->cells += SplCntInd-1;
+                            
+                            /* Split the cell C and update the information for sizes of new cells */
+                            /* Put the new cells into the stack */
+                            i = ind0;
+                            if (StackMarkers[i] != tv->stackmark) {
+                                BigCellSize = 0;
+                            }
+                            for (k = 0; k < SplCntInd; k++) {
+                                value = SplPos[SplCnt[k]];
+                                cls[i] = value;
+                                if ((StackMarkers[ind0] != tv->stackmark) && (value > BigCellSize)) {
+                                    BigCell = i;
+                                    BigCellPos = CStackInd;
+                                    BigCellSize = cls[i];
+                                }
+                                SplPos[SplCnt[k]] = i;
+                                i += value;
+                                if (i < ind1) {
+                                    CStack[++CStackInd] = i;
+                                    StackMarkers[i] = tv->stackmark;
+                                    TRACE_CHECK(TheTrace, TraceInd, i, TraceEnd)
+                                }
+                            }
+                            
+                            if ((StackMarkers[ind0] != tv->stackmark) && (BigCell != ind0)) {
+                                CStack[BigCellPos] = ind0;
+                                StackMarkers[BigCell] = 0;
+                                StackMarkers[ind0] = tv->stackmark;
+                            }
+                            /* Permute elements of the cell C */
+                            iend = ind0 + ElmHitCll[ind0];
+                            for (i = ind0; i < iend; i++) {
+                                value = HitVtx[i];
+                                j = SplPos[NghCounts[value]]++; /* where HitVtx[i] goes */
+                                k = InvLab[value];				/* where HitVtx[i] is in lab */
+                                lab[k] = lab[j];
+                                lab[j] = value;
+                                InvLab[value] = j;
+                                InvLab[lab[k]] = k;
+                                NghCounts[value] = 0;
+                            }
+                            
+                            /* Reconstruct the cell C and update the inverse partition */
+                            newcell = ind1 - ElmHitCll[ind0];
+                            i = newcell;
+                            ind2 = newcell+cls[newcell]-1;
+                            do {
+                                Part->inv[i] = newcell;
+                                if (i == ind2) {
+                                    newcell = i+1;
+                                    if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                                }
+                            }
+                            while (++i < ind1);
+                            
+                            for (i = ind0, k = 0; k < SplCntInd; i+=cls[i], k++) {
+                                if (cls[i] == 1) {
+                                    Cand->singcode = MASHCOMM(Cand->singcode, Cand->lab[i]);
+                                    if (newtrace) Singletons[SingInd] = i;
+                                    SingInd++;
+                                }
+                            }
+                            
+                        }
+                    }
+                    else {
+                        if ((!newtrace) && TraceCell) {
+                            return 0;
+                        }
+                    }
+                    
+                }
+                else {
+                    if (TheGraph[lab[ind0]].d > n/cls[ind0]) {
+                        Sparse = FALSE;
+                    }
+                    else {
+                        Sparse = TRUE;
+                    }
+                    if (Sparse) {
+                        /* Counting occurrences of neighbors of the current cell */
+                        /* The list of cells with neighbors in the current cell is also built */
+                        if (cls[ind0] == n) {
+                            for (i = 0; i < n; i++) {
+                                NghCounts[i] = TheGraph[i].d;
+                            }
+                            HitCls[0] = 0;
+                            HitClsInd = 1;
+                        }
+                        else {
+                            memset(NghCounts, 0, n*sizeof(int));
+                            
+                            /* NEIGHCOUNT_DENSE_SPARSE_MULT */
+                            HitClsInd = 0;
+                            for (i = ind0; i < ind2; i++) {
+                                labi = lab[i];
+                                nghb =  TheGraph[labi].e;
+                                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                                    k = nghb[j1int];
+                                    (NghCounts[k])++;
+                                    value = Part->inv[InvLab[k]];
+                                    if (Markers[value] != tv->mark) {
+                                        if (cls[value] > 1) HitCls[HitClsInd++] = value;
+                                        Markers[value] = tv->mark;
+                                    }
+                                }
+                            }
+                            /* End NEIGHCOUNT_DENSE_SPARSE_MULT */
+                            
+                        }
+                        
+                        tv->mark++;
+                        
+                        
+                        SplInd = 0;
+                        for (j = 0; j < HitClsInd; j++) {
+                            ind1 = HitCls[j];
+                            ind2 = ind1+cls[ind1];
+                            value = NghCounts[lab[ind1++]];
+                            for (i = ind1; i < ind2; i++)
+                            {
+                                if (NghCounts[lab[i]] != value)
+                                {
+                                    SplCls[SplInd++] = HitCls[j];
+                                    break;
+                                }
+                            }
+                        }
+                        
+                        /* DENSE-SPARSE CASE */
+                        if (SplInd) {
+                            if (newtrace) {
+                                TheTraceCC[TraceCCInd] = ind0;
+                            }
+                            if (!TraceCell) {
+                                TheTraceCC[TraceCCInd] = ind0;
+                                newtrace = TRUE;
+                            }
+                            TRACE_CHECK(TheTraceSplNum, TraceCCInd, SplInd+2*n, &Traceccend)
+                            
+                            /* Sorting the cells to be split */
+                            sort_Split_Array(SplCls, SplInd);
+                            
+                            for (j = 0; j < SplInd; j++) {	/* For each cell C to be split */
+                                ind0 = SplCls[j];
+                                ind1 = ind0+cls[ind0];
+                                SplCntInd = 0;
+                                
+                                /* According to the numbers of neighbors of C into the current cell */
+                                /* compute how many vertices in C will be placed into the same new cell */
+                                for (i = ind0; i < ind1; i++) {
+                                    value = NghCounts[lab[i]];
+                                    if (Markers[value] != tv->mark) {
+                                        Markers[value] = tv->mark;
+                                        SplCnt[SplCntInd++] = value;
+                                        SplPos[value] = 1;
+                                    }
+                                    else {
+                                        SplPos[value]++;
+                                    }
+                                }
+                                tv->mark++;
+                                
+                                if (SplCntInd) {
+                                    TRACE_CHECK(TheTraceSteps, TraceStepsInd, SplCntInd+2*n, Tracestpend)
+                                }
+                                
+                                /* Sort the values deriving from the previous step */
+                                sort_Split_Array(SplCnt, SplCntInd);
+                                
+                                Part->cells += SplCntInd-1;
+                                
+                                /* Split the cell C and update the information for sizes of new cells */
+                                /* Put the new cells into the stack */
+                                i = ind0;
+                                if (StackMarkers[i] != tv->stackmark) {
+                                    BigCellSize = 0;
+                                }
+                                for (k = 0; k < SplCntInd; k++) {
+                                    value = SplPos[SplCnt[k]];
+                                    cls[i] = value;
+                                    
+                                    if ((StackMarkers[ind0] != tv->stackmark) && (value > BigCellSize)) {
+                                        BigCell = i;
+                                        BigCellPos = CStackInd;
+                                        BigCellSize = cls[i];
+                                    }
+                                    SplPos[SplCnt[k]] = i;
+                                    i += value;
+                                    if (i < ind1) {
+                                        CStack[++CStackInd] = i;
+                                        StackMarkers[i] = tv->stackmark;
+                                        TRACE_CHECK(TheTrace, TraceInd, i, TraceEnd)
+                                    }
+                                }
+                                
+                                if ((StackMarkers[ind0] != tv->stackmark) && (BigCell != ind0)) {
+                                    CStack[BigCellPos] = ind0;
+                                    StackMarkers[BigCell] = 0;
+                                    StackMarkers[ind0] = tv->stackmark;
+                                }
+                                
+                                /* Permute elements of the cell C */
+                                i = ind0;
+                                do {
+                                    SplCnt[SplPos[NghCounts[lab[i]]]++] = lab[i];
+                                }
+                                while(++i < ind1);
+                                
+                                /* Reconstruct the cell C and update the inverse partition */
+                                newcell = ind0;
+                                i = ind0;
+                                ind2 = newcell+cls[newcell]-1;
+                                do {
+                                    lab[i] = SplCnt[i];
+                                    InvLab[lab[i]] = i;
+                                    
+                                    Part->inv[i] = newcell;
+                                    if (i == ind2) {
+                                        newcell = i+1;
+                                        if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                                    }
+                                }
+                                while (++i < ind1);
+                                
+                                for (i = ind0, k = 0; k < SplCntInd; i+=cls[i], k++) {
+                                    if (cls[i] == 1) {
+                                        Cand->singcode = MASHCOMM(Cand->singcode, Cand->lab[i]);
+                                        if (newtrace) Singletons[SingInd] = i;
+                                        SingInd++;
+                                    }
+                                }
+                                
+                            }
+                        }
+                        else {
+                            if ((!newtrace) && TraceCell) {
+                                return 0;
+                            }
+                        }
+                        
+                    }
+                    else {
+                        if (cls[ind0] == n) {
+                            for (i = 0; i < n; i++) {
+                                NghCounts[i] = TheGraph[i].d;
+                            }
+                        }
+                        else {
+                            memset(NghCounts, 0, n*sizeof(int));
+                            
+                            /* NEIGHCOUNT_DENSE_DENSE_MULT */
+                            for (i = ind0; i < ind2; i++) {
+                                labi = lab[i];
+                                nghb = TheGraph[labi].e;
+                                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                                    k = nghb[j1int];
+                                    (NghCounts[k])++;
+                                }
+                            }
+                            /* End NEIGHCOUNT_DENSE_DENSE_MULT */
+                            
+                        }
+                        SplInd = 0;
+                        ind4 = 0;
+                        while (ind4 < n) {	/* For each cell C with size(C) > 1 */
+                            ind1 = ind4+cls[ind4];
+                            if (cls[ind4] > 1) {
+                                
+                                
+                                /* Determine whether C must be split */
+                                SplCntInd = 0;
+                                value = NghCounts[lab[ind4]];
+                                for (i = ind4+1; i < ind1; i++) {
+                                    if (NghCounts[lab[i]] != value)
+                                    {
+                                        SplInd++;
+                                        Markers[value] = tv->mark;
+                                        SplCnt[SplCntInd++] = value;
+                                        SplPos[value] = i-ind4;
+                                        do {
+                                            value = NghCounts[lab[i++]];
+                                            if (Markers[value] != tv->mark) {
+                                                Markers[value] = tv->mark;
+                                                SplCnt[SplCntInd++] = value;
+                                                SplPos[value] = 1;
+                                            }
+                                            else {
+                                                SplPos[value]++;
+                                            }
+                                        }
+                                        while(i != ind1);
+                                        break;
+                                    }
+                                }
+                                tv->mark++;
+                                
+                                if (SplInd && !TraceCell) newtrace = TRUE;
+                                
+                                if (SplCntInd) {
+                                    TRACE_CHECK(TheTraceSteps, TraceStepsInd, SplCntInd+3*n, Tracestpend)
+                                    
+                                    /* Sort the values deriving from the previous step */
+                                    sort_Split_Array(SplCnt, SplCntInd);
+                                    
+                                    Part->cells += SplCntInd-1;
+                                    
+                                    /* Split the cell C and update the information for sizes of new cells */
+                                    /* Put the new cells into the stack */
+                                    i = ind4;
+                                    if (StackMarkers[i] != tv->stackmark) {
+                                        BigCellSize = 0;
+                                    }
+                                    for (k = 0; k < SplCntInd; k++) {
+                                        value = SplPos[SplCnt[k]];
+                                        cls[i] = value;
+                                        
+                                        if ((StackMarkers[ind4] != tv->stackmark) && (value > BigCellSize)) {
+                                            BigCell = i;
+                                            BigCellPos = CStackInd;
+                                            BigCellSize = cls[i];
+                                        }
+                                        SplPos[SplCnt[k]] = i;
+                                        i += value;
+                                        if (i < ind1) {
+                                            CStack[++CStackInd] = i;
+                                            StackMarkers[i] = tv->stackmark;
+                                            TRACE_CHECK(TheTrace, TraceInd, i, TraceEnd)
+                                        }
+                                    }
+                                    if ((StackMarkers[ind4] != tv->stackmark) && (BigCell != ind4)) {
+                                        CStack[BigCellPos] = ind4;
+                                        StackMarkers[BigCell] = 0;
+                                        StackMarkers[ind4] = tv->stackmark;
+                                    }
+                                    
+                                    /* Permute elements of the cell C */
+                                    i = ind4;
+                                    do {
+                                        SplCnt[SplPos[NghCounts[lab[i]]]++] = lab[i];
+                                    }
+                                    while(++i < ind1);
+                                    
+                                    /* Reconstruct the cell C and update the inverse partition */
+                                    newcell = ind4;
+                                    i = ind4;
+                                    ind2 = newcell+cls[newcell]-1;
+                                    do {
+                                        lab[i] = SplCnt[i];
+                                        InvLab[lab[i]] = i;
+                                        Part->inv[i] = newcell;
+                                        if (i == ind2) {
+                                            newcell = i+1;
+                                            if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                                        }
+                                    }
+                                    while (++i < ind1);
+                                    
+                                    for (i = ind4; i < ind1; i+=cls[i]) {
+                                        if (cls[i] == 1) {
+                                            Cand->singcode = MASHCOMM(Cand->singcode, Cand->lab[i]);
+                                            if (newtrace) Singletons[SingInd] = i;
+                                            SingInd++;
+                                        }
+                                    }
+                                }
+                            }
+                            ind4 = ind1;
+                        }
+                        
+                        /* DENSE-DENSE CASE */
+                        if (SplInd) {
+                            if (!TraceCell) {
+                                newtrace = TRUE;
+                            }
+                            TRACE_CHECK(TheTraceSplNum, TraceCCInd, SplInd+3*n, &Traceccend)
+                            if (newtrace) {
+                                TheTraceCC[TraceCCInd-1] = ind0;
+                            }
+                        }
+                        else {
+                            if ((!newtrace) && TraceCell) {
+                                return 0;
+                            }
+                        }
+                        
+                    }
+                }
+            }
+        }
+        while (weightend < iend1int);
+    }  /* end while (CStackInd > 0) */
+    
+    tv->augmented_cells = Part->cells - tv->augmented_cells;
+    
+    if (make_code) {
+        for (i=SpineTL->trcstart; i < TraceInd; i++) {
+            ind0 = TheTrace[i];
+            longcode = MASHNONCOMM(longcode, Part->inv[ind0]);
+            labi = lab[ind0];
+            iend1int = TheGraph[labi].d;
+            nghb = TheGraph[labi].e;
+            for (j1int = 0; j1int < iend1int; ++j1int) {
+                k = nghb[j1int];
+                value = Part->inv[InvLab[k]];
+                longcode = MASHCOMM(longcode, value);
+            }
+        }
+    }
+    Part->code = Cand->code = CLEANUP(longcode);
+    tlp1 = tv->tolevel+1;
+    if (newtrace) {
+        if ((tlp1 < n) && (tlp1 > tv->treedepth)) {
+            tv->treedepth = tlp1;
+            if (tv->strategy) {
+                Spine[tlp1].part = NewPartition(n);
+            }
+            else {
+                NewPartSpine(tlp1,n);
+            }
+            Spine[tlp1].liststart = Spine[tlp1].listend = NULL;
+            Spine[tlp1].listcounter = 0;
+        }
+        *TraceEnd = TraceInd;
+        SpineTL->ccend = TraceCCInd;
+        SpineTL->singend = SingInd;
+        *Tracestpend = TraceStepsInd;
+        
+        SpineTL->thetracexists = TRUE;
+        if (tlp1 < n) {
+            Spine[tlp1].ccstart = TraceCCInd;
+            Spine[tlp1].singstart = Spine[tlp1].singend = SingInd;
+            Spine[tlp1].stpstart = TraceStepsInd;
+            Spine[tlp1].thetracexists = FALSE;
+            Spine[tlp1].part->code = -1;
+        }
+        return 2;
+    }
+    else {
+        if (TraceInd < *TraceEnd) {
+            return 0;
+        }
+        if (Cand->code > SpineTL->part->code) {
+            return 2;
+        }
+        else {
+            if (Cand->code < SpineTL->part->code) {
+                return 0;
+            }
+        }
+        return 1;
+    }
+}
+
+void traces_refine_notrace(Candidate *Cand,
+                           int n,
+                           Partition *Part,
+                           struct TracesVars* tv,
+                           struct TracesInfo *ti) {
+    int i, j, k, jk, sc, ind0, ind1, ind2, ind3, labi, auxcells;
+    int value, iend, newcell;
+    int HitClsInd, SplInd, SplCntInd, CStackInd;
+    int iend1int, j1int;
+    unsigned int longcode;
+    int Split = 0;
+    int Sparse = TRUE;
+    int *lab, *cls, *InvLab, *SplitCell, *LabCell;
+    int BigCell, BigCellPos, BigCellSize;
+    int *nghb;
+    const int variation = 1;
+    int currentweight, weightstart, weightend, currentcell, currentsize;
+    
+    if (tv->stackmark > (NAUTY_INFINITY-2)) {
+        memset(StackMarkers, 0, n*sizeof(int));
+        tv->stackmark = 0;
+    }
+    tv->stackmark++;
+    
+    tv->augmented_cells = Part->cells;
+    
+    lab = Cand->lab;
+    InvLab = Cand->invlab;
+    cls = Part->cls;
+    
+    CStackInd = 1;
+    CStack[1] = tv->tcellexpath+cls[tv->tcellexpath];
+    
+    for (i = 1; i <= CStackInd; i++) {
+        StackMarkers[CStack[i]] = tv->stackmark;
+    }
+    
+    longcode = Part->cells;
+    
+    while (CStackInd > 0) {
+        
+        weightend = 0;
+        
+        if (tv->mark > (NAUTY_INFINITY-2)) {
+            memset(Markers, 0, n*sizeof(int));
+            memset(MarkHitVtx, 0, n*sizeof(int));
+            tv->mark = 0;
+        }
+        tv->mark++;
+        
+        k = Select_from_CStack(cls, CStackInd);
+        
+        currentcell = CStack[k];
+        currentsize = currentcell+cls[currentcell];
+        CStack[k] = CStack[CStackInd--];		/* Current Cell */
+        longcode = MASHNONCOMM(longcode, currentcell);
+        StackMarkers[currentcell] = 0;
+        
+        labi = lab[currentcell];
+        iend1int = TheGraph[labi].d;
+        nghb =  TheGraph[labi].e;
+        
+        do {
+            ind0 = currentcell;
+            ind2 = currentsize;
+            weightstart = weightend;
+            
+            if (tv->options->weighted) {
+                currentweight = (TheGraph[labi].w)[weightstart];
+                while ((iend1int > weightend) && ((TheGraph[labi].w)[weightend] == currentweight)) {
+                    weightend++;
+                }
+            } else {
+                weightend = TheGraph[labi].d;
+            }
+            
+            /* Analysis of occurrences of neighbors of the current cell */
+            /* The list of cells with neighbors in the current cell is  built */
+            
+            if (cls[ind0] == 1) {   /* SINGLETON CURRENT CELL CASE */
+                
+                /* NEIGHCOUNT_SING_MULT */
+                HitClsInd = 0;
+                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                    k = nghb[j1int];
+                    value = Part->inv[InvLab[k]];
+                    if (cls[value] > 1) {
+                        if (Markers[value] != tv->mark) {
+                            HitCls[HitClsInd++] = value;
+                            Markers[value] = tv->mark;
+                            ElmHitCll[value] = value;
+                        }
+                        HitVtx[ElmHitCll[value]++] = k;
+                    } else {
+                        switch (variation) {
+                            case 1:
+                                longcode = MASHCOMM(longcode, value);
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                }
+                /* end NEIGHCOUNT_SING_MULT */
+                
+                tv->mark++;
+                FIND_SPLIT_CELLS;
+                
+                /* Sorting the cells to be split */
+                sort_Split_Array(SplCls, SplInd);
+                
+                /* REARRANGE THE CELLS */
+                for (j = 0; j < SplInd; j++) {
+                    /* REARRANGE_CELLS */
+                    ind1 = SplCls[j];
+                    cls[ind1] = cls[ind1]-ElmHitCll[ind1];
+                    newcell = ind1+cls[ind1];
+                    cls[newcell] = ElmHitCll[ind1];
+                    Part->cells++;
+                    if (StackMarkers[ind1] != tv->stackmark) {
+                        if (cls[newcell] < cls[ind1]) {
+                            CStack[++CStackInd] = newcell;
+                            StackMarkers[newcell] = tv->stackmark;
+                        }
+                        else {
+                            CStack[++CStackInd] = ind1;
+                            StackMarkers[ind1] = tv->stackmark;
+                        }
+                    }
+                    else {
+                        CStack[++CStackInd] = newcell;
+                        StackMarkers[newcell] = tv->stackmark;
+                    }
+                    SplitCell = HitVtx+ind1;
+                    ind3 = cls[newcell];
+                    LabCell = lab+newcell;
+                    for (jk = 0; jk < ind3; jk++) {
+                        k = SplitCell[jk];
+                        i = LabCell[jk];
+                        Part->inv[newcell+jk] = newcell;
+                        lab[InvLab[k]] = i;
+                        InvLab[i] = InvLab[k];
+                        LabCell[jk] = k;
+                        InvLab[k] = newcell+jk;
+                    }
+                    /* END REARRANGE_CELLS */
+                    
+                    if (cls[ind1] == 1) {
+                        Cand->pathsingcode = MASHCOMM(Cand->pathsingcode, lab[ind1]);
+                    }
+                    if (cls[newcell] == 1) {
+                        Cand->pathsingcode = MASHCOMM(Cand->pathsingcode, lab[newcell]);
+                    }
+                }
+            }
+            else {
+                if (ti->thegraphisparse) {
+                    
+                    /* NEIGHCOUNT_SPARSE_MULT */
+                    if (cls[ind0] != n) {
+                        HitClsInd = 0;
+                        for (i = ind0; i < ind2; i++) {
+                            labi = lab[i];
+                            nghb = TheGraph[labi].e;
+                            for (j = weightstart; j < weightend; j++) {
+                                k = nghb[j];
+                                if (MarkHitVtx[k] == tv->mark) {
+                                    NghCounts[k]++;
+                                }
+                                else {
+                                    value = Part->inv[InvLab[k]];
+                                    if (cls[value] > 1) {
+                                        MarkHitVtx[k] = tv->mark;
+                                        NghCounts[k] = 1;
+                                        if (Markers[value] != tv->mark) {
+                                            HitCls[HitClsInd++] = value;
+                                            Markers[value] = tv->mark;
+                                            HitVtx[value] = k;
+                                            ElmHitCll[value] = 1;
+                                        }
+                                        else {
+                                            HitVtx[value+ElmHitCll[value]++] = k;
+                                        }
+                                    }
+                                    else {
+                                        switch (variation) {
+                                            case 1:
+                                                longcode = MASHCOMM(longcode, value);
+                                                break;
+                                            default:
+                                                break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    /* End NEIGHCOUNT_SPARSE_MULT */
+                    
+                    tv->mark++;
+                    
+                    SplInd = 0;
+                    SplCls[0] = n;
+                    for (j = 0; j < HitClsInd; j++) {
+                        ind1 = HitCls[j];
+                        if ((ElmHitCll[ind1] > 0) && (ElmHitCll[ind1] < cls[ind1])) {
+                            SplCls[SplInd++] = ind1;
+                        }
+                        else {
+                            ind2 = ind1+cls[ind1];
+                            Split = FALSE;
+                            value = NghCounts[lab[ind1++]];
+                            for (i = ind1; i < ind2; i++)
+                            {
+                                if (NghCounts[lab[i]] != value)
+                                {
+                                    SplCls[SplInd++] = HitCls[j];
+                                    Split = TRUE;
+                                    break;
+                                }
+                            }
+                            if (!Split) {
+                                longcode = MASHCOMM(longcode, ind1);
+                            }
+                        }
+                    }
+                    
+                    /* Sorting the cells to be split */
+                    sort_Split_Array(SplCls, SplInd);
+                    
+                    for (sc = 0; sc < SplInd; sc++) {	/* For each cell C to be split */
+                        ind0 = SplCls[sc];
+                        ind1 = ind0 + cls[ind0];
+                        SplCntInd = 0;
+                        if (ElmHitCll[ind0] < cls[ind0]) {
+                            SplCnt[SplCntInd++] = 0;
+                            SplPos[0] = cls[ind0] - ElmHitCll[ind0];
+                        }
+                        
+                        /* According to the numbers of neighbors of C into the current cell */
+                        /* compute how many vertices in C will be placed into the same new cell */
+                        iend = ind0 + ElmHitCll[ind0];
+                        for (i = ind0; i < iend; i++) {
+                            value = NghCounts[HitVtx[i]];
+                            if (Markers[value] != tv->mark) {
+                                Markers[value] = tv->mark;
+                                SplCnt[SplCntInd++] = value;
+                                SplPos[value] = 1;
+                            }
+                            else {
+                                SplPos[value]++;
+                            }
+                        }
+                        tv->mark++;
+                        
+                        /* Sort the values deriving from the previous step */
+                        sort_Split_Array(SplCnt, SplCntInd);
+                        Part->cells += SplCntInd-1;
+                        
+                        /* Split the cell C and update the information for sizes of new cells */
+                        /* Put the new cells into the stack */
+                        i = ind0;
+                        if (StackMarkers[i] != tv->stackmark) {
+                            BigCellSize = 0;
+                        }
+                        for (k = 0; k < SplCntInd; k++) {
+                            value = SplPos[SplCnt[k]];
+                            cls[i] = value;
+                            if ((StackMarkers[ind0] != tv->stackmark) && (value > BigCellSize)) {
+                                BigCell = i;
+                                BigCellPos = CStackInd;
+                                BigCellSize = cls[i];
+                            }
+                            SplPos[SplCnt[k]] = i;
+                            i += value;
+                            if (i < ind1) {
+                                CStack[++CStackInd] = i;
+                                StackMarkers[i] = tv->stackmark;
+                            }
+                        }
+                        
+                        if ((StackMarkers[ind0] != tv->stackmark) && (BigCell != ind0)) {
+                            CStack[BigCellPos] = ind0;
+                            StackMarkers[BigCell] = 0;
+                            StackMarkers[ind0] = tv->stackmark;
+                        }
+                        
+                        /* Permute elements of the cell C */
+                        iend = ind0 + ElmHitCll[ind0];
+                        for (i = ind0; i < iend; i++) {
+                            value = HitVtx[i];
+                            j = SplPos[NghCounts[value]]++; /* where HitVtx[i] goes */
+                            k = InvLab[value];				/* where HitVtx[i] is in lab */
+                            lab[k] = lab[j];
+                            lab[j] = value;
+                            InvLab[value] = j;
+                            InvLab[lab[k]] = k;
+                            NghCounts[value] = 0;
+                        }
+                        
+                        /* Reconstruct the cell C and update the inverse partition */
+                        newcell = ind1 - ElmHitCll[ind0];
+                        i = newcell;
+                        ind2 = newcell+cls[newcell]-1;
+                        do {
+                            Part->inv[i] = newcell;
+                            if (i == ind2) {
+                                newcell = i+1;
+                                if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                            }
+                        }
+                        while (++i < ind1);
+                        
+                        for (i = ind0, k = 0; k < SplCntInd; i+=cls[i], k++) {
+                            if (cls[i] == 1) {
+                                Cand->pathsingcode = MASHCOMM(Cand->pathsingcode, lab[i]);
+                            }
+                        }
+                        
+                    }
+                }
+                else {
+                    if (TheGraph[lab[ind0]].d > n/cls[ind0]) {
+                        Sparse = FALSE;
+                    }
+                    else {
+                        Sparse = TRUE;
+                    }
+                    if (Sparse) {
+                        /* Counting occurrences of neighbors of the current cell */
+                        /* The list of cells with neighbors in the current cell is also built */
+                        if (cls[ind0] == n) {
+                            for (i = 0; i < n; i++) {
+                                NghCounts[i] = TheGraph[i].d;
+                            }
+                            HitCls[0] = 0;
+                            HitClsInd = 1;
+                        }
+                        else {
+                            memset(NghCounts, 0, n*sizeof(int));
+                            
+                            /* NEIGHCOUNT_DENSE_SPARSE_MULT */
+                            HitClsInd = 0;
+                            for (i = ind0; i < ind2; i++) {
+                                labi = lab[i];
+                                nghb =  TheGraph[labi].e;
+                                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                                    k = nghb[j1int];
+                                    (NghCounts[k])++;
+                                    value = Part->inv[InvLab[k]];
+                                    if (Markers[value] != tv->mark) {
+                                        if (cls[value] > 1) HitCls[HitClsInd++] = value;
+                                        Markers[value] = tv->mark;
+                                    }
+                                }
+                            }
+                            /* End NEIGHCOUNT_DENSE_SPARSE_MULT */
+                            
+                        }
+                        
+                        tv->mark++;
+                        
+                        SplInd = 0;
+                        for (j = 0; j < HitClsInd; j++) {
+                            ind1 = HitCls[j];
+                            ind2 = ind1+cls[ind1];
+                            value = NghCounts[lab[ind1++]];
+                            for (i = ind1; i < ind2; i++)
+                            {
+                                if (NghCounts[lab[i]] != value)
+                                {
+                                    SplCls[SplInd++] = HitCls[j];
+                                    break;
+                                }
+                            }
+                        }
+                        
+                        /* Sorting the cells to be split */
+                        sort_Split_Array(SplCls, SplInd);
+                        
+                        for (j = 0; j < SplInd; j++) {	/* For each cell C to be split */
+                            ind0 = SplCls[j];
+                            ind1 = ind0+cls[ind0];
+                            SplCntInd = 0;
+                            
+                            /* According to the numbers of neighbors of C into the current cell */
+                            /* compute how many vertices in C will be placed into the same new cell */
+                            for (i = ind0; i < ind1; i++) {
+                                value = NghCounts[lab[i]];
+                                if (Markers[value] != tv->mark) {
+                                    Markers[value] = tv->mark;
+                                    SplCnt[SplCntInd++] = value;
+                                    SplPos[value] = 1;
+                                }
+                                else {
+                                    SplPos[value]++;
+                                }
+                            }
+                            
+                            tv->mark++;
+                            
+                            /* Sort the values deriving from the previous step */
+                            sort_Split_Array(SplCnt, SplCntInd);
+                            
+                            Part->cells += SplCntInd-1;
+                            
+                            /* Split the cell C and update the information for sizes of new cells */
+                            /* Put the new cells into the stack */
+                            i = ind0;
+                            if (StackMarkers[i] != tv->stackmark) {
+                                BigCellSize = 0;
+                            }
+                            for (k = 0; k < SplCntInd; k++) {
+                                value = SplPos[SplCnt[k]];
+                                cls[i] = value;
+                                if ((StackMarkers[ind0] != tv->stackmark) && (value > BigCellSize)) {
+                                    BigCell = i;
+                                    BigCellPos = CStackInd;
+                                    BigCellSize = cls[i];
+                                }
+                                SplPos[SplCnt[k]] = i;
+                                i += value;
+                                if (i < ind1) {
+                                    CStack[++CStackInd] = i;
+                                    StackMarkers[i] = tv->stackmark;
+                                }
+                            }
+                            if ((StackMarkers[ind0] != tv->stackmark) && (BigCell != ind0)) {
+                                CStack[BigCellPos] = ind0;
+                                StackMarkers[BigCell] = 0;
+                                StackMarkers[ind0] = tv->stackmark;
+                            }
+                            
+                            /* Permute elements of the cell C */
+                            i = ind0;
+                            do {
+                                SplCnt[SplPos[NghCounts[lab[i]]]++] = lab[i];
+                            }
+                            while(++i < ind1);
+                            
+                            /* Reconstruct the cell C and update the inverse partition */
+                            newcell = ind0;
+                            i = ind0;
+                            ind2 = newcell+cls[newcell]-1;
+                            do {
+                                lab[i] = SplCnt[i];
+                                InvLab[lab[i]] = i;
+                                Part->inv[i] = newcell;
+                                
+                                if (i == ind2) {
+                                    newcell = i+1;
+                                    if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                                }
+                            }
+                            while (++i < ind1);
+                            
+                            for (i = ind0, k = 0; k < SplCntInd; i+=cls[i], k++) {
+                                if (cls[i] == 1) {
+                                    Cand->pathsingcode = MASHCOMM(Cand->pathsingcode, lab[i]);
+                                }
+                            }
+                            
+                        }
+                    }
+                    else {
+                        if (cls[ind0] == n) {
+                            for (i = 0; i < n; i++) {
+                                NghCounts[i] = TheGraph[i].d;
+                            }
+                        }
+                        else {
+                            memset(NghCounts, 0, n*sizeof(int));
+                            
+                            /* NEIGHCOUNT_DENSE_DENSE_MULT */
+                            for (i = ind0; i < ind2; i++) {
+                                labi = lab[i];
+                                nghb = TheGraph[labi].e;
+                                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                                    k = nghb[j1int];
+                                    (NghCounts[k])++;
+                                }
+                            }
+                            /* End NEIGHCOUNT_DENSE_DENSE_MULT */
+                            
+                        }
+                        
+                        ind0 = 0;
+                        while (ind0 < n) {	/* For each cell C with size(C) > 1 */
+                            ind1 = ind0+cls[ind0];
+                            if (cls[ind0] > 1) {
+                                
+                                /* Determine whether C must be split */
+                                SplCntInd = 0;
+                                value = NghCounts[lab[ind0]];
+                                for (i = ind0+1; i < ind1; i++)
+                                {
+                                    if (NghCounts[lab[i]] != value)
+                                    {
+                                        Markers[value] = tv->mark;
+                                        SplCnt[SplCntInd++] = value;
+                                        SplPos[value] = i-ind0;
+                                        do {
+                                            value = NghCounts[lab[i++]];
+                                            if (Markers[value] != tv->mark) {
+                                                Markers[value] = tv->mark;
+                                                SplCnt[SplCntInd++] = value;
+                                                SplPos[value] = 1;
+                                            }
+                                            else {
+                                                SplPos[value]++;
+                                            }
+                                        }
+                                        while(i != ind1);
+                                        break;
+                                    }
+                                }
+                                
+                                if (SplCntInd) {
+                                    tv->mark++;
+                                    
+                                    /* Sort the values deriving from the previous step */
+                                    sort_Split_Array(SplCnt, SplCntInd);
+                                    Part->cells += SplCntInd-1;
+                                    
+                                    /* Split the cell C and update the information for sizes of new cells */
+                                    /* Put the new cells into the stack */
+                                    i = ind0;
+                                    if (StackMarkers[i] != tv->stackmark) {
+                                        BigCellSize = 0;
+                                    }
+                                    for (k = 0; k < SplCntInd; k++) {
+                                        value = SplPos[SplCnt[k]];
+                                        cls[i] = value;
+                                        if ((StackMarkers[ind0] != tv->stackmark) && (value > BigCellSize)) {
+                                            BigCell = i;
+                                            BigCellPos = CStackInd;
+                                            BigCellSize = cls[i];
+                                        }
+                                        SplPos[SplCnt[k]] = i;
+                                        i += value;
+                                        if (i < ind1) {
+                                            CStack[++CStackInd] = i;
+                                            StackMarkers[i] = tv->stackmark;
+                                        }
+                                    }
+                                    if ((StackMarkers[ind0] != tv->stackmark) && (BigCell != ind0)) {
+                                        CStack[BigCellPos] = ind0;
+                                        StackMarkers[BigCell] = 0;
+                                        StackMarkers[ind0] = tv->stackmark;
+                                    }
+                                    
+                                    /* Permute elements of the cell C */
+                                    i = ind0;
+                                    do {
+                                        SplCnt[SplPos[NghCounts[lab[i]]]++] = lab[i];
+                                    }
+                                    while(++i < ind1);
+                                    
+                                    /* Reconstruct the cell C and update the inverse partition */
+                                    newcell = ind0;
+                                    i = ind0;
+                                    ind2 = newcell+cls[newcell]-1;
+                                    do {
+                                        lab[i] = SplCnt[i];
+                                        InvLab[lab[i]] = i;
+                                        Part->inv[i] = newcell;
+                                        if (i == ind2) {
+                                            newcell = i+1;
+                                            if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                                        }
+                                    }
+                                    while (++i < ind1);
+                                    
+                                    for (i = ind0; i < ind1; i+=cls[i]) {
+                                        if (cls[i] == 1) {
+                                            Cand->pathsingcode = MASHCOMM(Cand->pathsingcode, lab[i]);
+                                        }
+                                    }
+                                    
+                                }
+                            }
+                            ind0 = ind1;
+                        }
+                    }
+                }
+            }
+        }
+        while (weightend < iend1int);
+    }  /* end while (CStackInd > 0) */
+    
+    tv->augmented_cells = Part->cells - tv->augmented_cells;
+    Cand->code = CLEANUP(longcode);
+    return;
+}
+
+void traces_refine_maketrie(Candidate *Cand,
+                            int n,
+                            Partition *Part,
+                            struct TracesVars* tv,
+                            struct TracesInfo *ti) {
+    int i, j, k, jk, sc, ind0, ind1, ind2, ind3, labi;
+    int value, iend, newcell;
+    int HitClsInd, SplInd, SplCntInd, CStackInd;
+    int j1int, iend1int;
+    unsigned int longcode;
+    int Split = 0;
+    int Sparse = TRUE;
+    int *lab, *cls, *InvLab, *SplitCell, *LabCell;
+    int BigCell, BigCellPos, BigCellSize;
+    int *nghb;
+    const int variation = 1;
+    int currentweight, weightstart, weightend, currentcell, currentsize;
+    
+    if (tv->stackmark > (NAUTY_INFINITY-2)) {
+        memset(StackMarkers, 0, n*sizeof(int));
+        tv->stackmark = 0;
+    }
+    tv->stackmark++;
+    
+    tv->augmented_cells = Part->cells;
+    
+    lab = Cand->lab;
+    InvLab = Cand->invlab;
+    cls = Part->cls;
+    
+    CStack[1] = Spine[tv->tolevel_tl].tgtpos;
+    CStackInd = 1;
+    for (i = 1; i <= CStackInd; i++) {
+        StackMarkers[CStack[i]] = tv->stackmark;
+    }
+    
+    longcode = Part->cells;
+    
+    while (CStackInd > 0)
+    {
+        weightend = 0;
+        
+        if (tv->mark > (NAUTY_INFINITY-2)) {
+            memset(Markers, 0, n*sizeof(int));
+            memset(MarkHitVtx, 0, n*sizeof(int));
+            tv->mark = 0;
+        }
+        tv->mark++;
+        
+        if (Part->cells == n) break;
+        
+        k = Select_from_CStack(cls, CStackInd);
+        
+        currentcell = CStack[k];
+        currentsize = currentcell+cls[currentcell];
+        CStack[k] = CStack[CStackInd--];
+        longcode = MASHNONCOMM(longcode, currentcell);
+        StackMarkers[currentcell] = 0;
+        
+        labi = lab[currentcell];
+        iend1int = TheGraph[labi].d;
+        nghb =  TheGraph[labi].e;
+        
+        do {
+            ind0 = currentcell;
+            ind2 = currentsize;
+            weightstart = weightend;
+            
+            if (tv->options->weighted) {
+                currentweight = (TheGraph[labi].w)[weightstart];
+                while ((iend1int > weightend) && ((TheGraph[labi].w)[weightend] == currentweight)) {
+                    weightend++;
+                }
+            } else {
+                weightend = TheGraph[labi].d;
+            }
+            
+            /* Analysis of occurrences of neighbors of the current cell */
+            /* The list of cells with neighbors in the current cell is  built */
+            if (cls[ind0] == 1) {  /* SINGLETON CURRENT CELL CASE */
+                
+                /* NEIGHCOUNT_SING_MULT */
+                HitClsInd = 0;
+                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                    k = nghb[j1int];
+                    value = Part->inv[InvLab[k]];
+                    if (cls[value] > 1) {
+                        if (Markers[value] != tv->mark) {
+                            HitCls[HitClsInd++] = value;
+                            Markers[value] = tv->mark;
+                            ElmHitCll[value] = value;
+                        }
+                        HitVtx[ElmHitCll[value]++] = k;
+                    } else {
+                        switch (variation) {
+                            case 1:
+                                longcode = MASHCOMM(longcode, value);
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                }
+                /* end NEIGHCOUNT_SING_MULT */
+                
+                tv->mark++;
+                FIND_SPLIT_CELLS;
+                
+                /* Sorting the cells to be split */
+                sort_Split_Array(SplCls, SplInd);
+                
+                for (j = 0; j < SplInd; j++) {
+                    ind1 = SplCls[j];
+                    i = ind1+cls[ind1]-ElmHitCll[ind1];
+                    trieref = trie_make(trieref, i, n, tv);
+                }
+                
+                /* REARRANGE THE CELLS */
+                for (j = 0; j < SplInd; j++) {
+                    /* REARRANGE_CELLS */
+                    ind1 = SplCls[j];
+                    cls[ind1] = cls[ind1]-ElmHitCll[ind1];
+                    newcell = ind1+cls[ind1];
+                    cls[newcell] = ElmHitCll[ind1];
+                    Part->cells++;
+                    if (StackMarkers[ind1] != tv->stackmark) {
+                        if (cls[newcell] < cls[ind1]) {
+                            CStack[++CStackInd] = newcell;
+                            StackMarkers[newcell] = tv->stackmark;
+                        }
+                        else {
+                            CStack[++CStackInd] = ind1;
+                            StackMarkers[ind1] = tv->stackmark;
+                        }
+                    }
+                    else {
+                        CStack[++CStackInd] = newcell;
+                        StackMarkers[newcell] = tv->stackmark;
+                    }
+                    SplitCell = HitVtx+ind1;
+                    ind3 = cls[newcell];
+                    LabCell = lab+newcell;
+                    for (jk = 0; jk < ind3; jk++) {
+                        k = SplitCell[jk];
+                        i = LabCell[jk];
+                        Part->inv[newcell+jk] = newcell;
+                        lab[InvLab[k]] = i;
+                        InvLab[i] = InvLab[k];
+                        LabCell[jk] = k;
+                        InvLab[k] = newcell+jk;
+                    }
+                    /* END REARRANGE_CELLS */
+                }
+            }
+            else {
+                if (ti->thegraphisparse) {
+                    
+                    /* NEIGHCOUNT_SPARSE_MULT */
+                    if (cls[ind0] != n) {
+                        HitClsInd = 0;
+                        for (i = ind0; i < ind2; i++) {
+                            labi = lab[i];
+                            nghb = TheGraph[labi].e;
+                            for (j = weightstart; j < weightend; j++) {
+                                k = nghb[j];
+                                if (MarkHitVtx[k] == tv->mark) {
+                                    NghCounts[k]++;
+                                }
+                                else {
+                                    value = Part->inv[InvLab[k]];
+                                    if (cls[value] > 1) {
+                                        MarkHitVtx[k] = tv->mark;
+                                        NghCounts[k] = 1;
+                                        if (Markers[value] != tv->mark) {
+                                            HitCls[HitClsInd++] = value;
+                                            Markers[value] = tv->mark;
+                                            HitVtx[value] = k;
+                                            ElmHitCll[value] = 1;
+                                        }
+                                        else {
+                                            HitVtx[value+ElmHitCll[value]++] = k;
+                                        }
+                                    }
+                                    else {
+                                        switch (variation) {
+                                            case 1:
+                                                longcode = MASHCOMM(longcode, value);
+                                                break;
+                                            default:
+                                                break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    /* End NEIGHCOUNT_SPARSE_MULT */
+                    
+                    tv->mark++;
+                    
+                    SplInd = 0;
+                    SplCls[0] = n;
+                    for (j = 0; j < HitClsInd; j++) {
+                        ind1 = HitCls[j];
+                        if ((ElmHitCll[ind1] > 0) && (ElmHitCll[ind1] < cls[ind1])) {
+                            SplCls[SplInd++] = ind1;
+                        }
+                        else {
+                            ind2 = ind1+cls[ind1];
+                            Split = FALSE;
+                            value = NghCounts[lab[ind1++]];
+                            for (i = ind1; i < ind2; i++)
+                            {
+                                if (NghCounts[lab[i]] != value)
+                                {
+                                    SplCls[SplInd++] = HitCls[j];
+                                    Split = TRUE;
+                                    break;
+                                }
+                            }
+                            if (!Split) {
+                                longcode = MASHCOMM(longcode, ind1);
+                            }
+                        }
+                    }
+                    
+                    /* Sorting the cells to be split */
+                    sort_Split_Array(SplCls, SplInd);
+                    
+                    for (sc = 0; sc < SplInd; sc++) {	/* For each cell C to be split */
+                        ind0 = SplCls[sc];
+                        ind1 = ind0 + cls[ind0];
+                        SplCntInd = 0;
+                        if (ElmHitCll[ind0] < cls[ind0]) {
+                            SplCnt[SplCntInd++] = 0;
+                            SplPos[0] = cls[ind0] - ElmHitCll[ind0];
+                        }
+                        
+                        /* According to the numbers of neighbors of C into the current cell */
+                        /* compute how many vertices in C will be placed into the same new cell */
+                        iend = ind0 + ElmHitCll[ind0];
+                        for (i = ind0; i < iend; i++) {
+                            value = NghCounts[HitVtx[i]];
+                            if (Markers[value] != tv->mark) {
+                                Markers[value] = tv->mark;
+                                SplCnt[SplCntInd++] = value;
+                                SplPos[value] = 1;
+                            }
+                            else {
+                                SplPos[value]++;
+                            }
+                        }
+                        
+                        tv->mark++;
+                        
+                        /* Sort the values deriving from the previous step */
+                        sort_Split_Array(SplCnt, SplCntInd);
+                        Part->cells += SplCntInd-1;
+                        
+                        /* Split the cell C and update the information for sizes of new cells */
+                        /* Put the new cells into the stack */
+                        i = ind0;
+                        if (StackMarkers[i] != tv->stackmark) {
+                            BigCellSize = 0;
+                        }
+                        for (k = 0; k < SplCntInd; k++) {
+                            value = SplPos[SplCnt[k]];
+                            cls[i] = value;
+                            if ((StackMarkers[ind0] != tv->stackmark) && (value > BigCellSize)) {
+                                BigCell = i;
+                                BigCellPos = CStackInd;
+                                BigCellSize = cls[i];
+                            }
+                            SplPos[SplCnt[k]] = i;
+                            i += value;
+                            if (i < ind1) {
+                                CStack[++CStackInd] = i;
+                                StackMarkers[i] = tv->stackmark;
+                                trieref = trie_make(trieref, i, n, tv);
+                            }
+                        }
+                        
+                        if ((StackMarkers[ind0] != tv->stackmark) && (BigCell != ind0)) {
+                            CStack[BigCellPos] = ind0;
+                            StackMarkers[BigCell] = 0;
+                            StackMarkers[ind0] = tv->stackmark;
+                        }
+                        /* Permute elements of the cell C */
+                        iend = ind0 + ElmHitCll[ind0];
+                        for (i = ind0; i < iend; i++) {
+                            value = HitVtx[i];
+                            j = SplPos[NghCounts[value]]++; /* where HitVtx[i] goes */
+                            k = InvLab[value];				/* where HitVtx[i] is in lab */
+                            lab[k] = lab[j];
+                            lab[j] = value;
+                            InvLab[value] = j;
+                            InvLab[lab[k]] = k;
+                            NghCounts[value] = 0;
+                        }
+                        
+                        /* Reconstruct the cell C and update the inverse partition */
+                        newcell = ind1 - ElmHitCll[ind0];
+                        i = newcell;
+                        ind2 = newcell+cls[newcell]-1;
+                        do {
+                            Part->inv[i] = newcell;
+                            if (i == ind2) {
+                                newcell = i+1;
+                                if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                            }
+                        }
+                        while (++i < ind1);
+                    }
+                }
+                else {
+                    if (TheGraph[lab[ind0]].d > n/cls[ind0]) {
+                        Sparse = FALSE;
+                    }
+                    else {
+                        Sparse = TRUE;
+                    }
+                    if (Sparse) {
+                        /* Counting occurrences of neighbors of the current cell */
+                        /* The list of cells with neighbors in the current cell is also built */
+                        if (cls[ind0] == n) {
+                            for (i = 0; i < n; i++) {
+                                NghCounts[i] = TheGraph[i].d;
+                            }
+                            HitCls[0] = 0;
+                            HitClsInd = 1;
+                        }
+                        else {
+                            memset(NghCounts, 0, n*sizeof(int));
+                            
+                            /* NEIGHCOUNT_DENSE_SPARSE_MULT */
+                            HitClsInd = 0;
+                            for (i = ind0; i < ind2; i++) {
+                                labi = lab[i];
+                                nghb =  TheGraph[labi].e;
+                                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                                    k = nghb[j1int];
+                                    (NghCounts[k])++;
+                                    value = Part->inv[InvLab[k]];
+                                    if (Markers[value] != tv->mark) {
+                                        if (cls[value] > 1) HitCls[HitClsInd++] = value;
+                                        Markers[value] = tv->mark;
+                                    }
+                                }
+                            }
+                            /* End NEIGHCOUNT_DENSE_SPARSE_MULT */
+                            
+                        }
+                        
+                        tv->mark++;
+                        
+                        SplInd = 0;
+                        for (j = 0; j < HitClsInd; j++) {
+                            ind1 = HitCls[j];
+                            ind2 = ind1+cls[ind1];
+                            value = NghCounts[lab[ind1++]];
+                            for (i = ind1; i < ind2; i++)
+                            {
+                                if (NghCounts[lab[i]] != value)
+                                {
+                                    SplCls[SplInd++] = HitCls[j];
+                                    break;
+                                }
+                            }
+                        }
+                        
+                        /* Sorting the cells to be split */
+                        sort_Split_Array(SplCls, SplInd);
+                        
+                        for (j = 0; j < SplInd; j++) {	/* For each cell C to be split */
+                            ind0 = SplCls[j];
+                            ind1 = ind0+cls[ind0];
+                            SplCntInd = 0;
+                            
+                            /* According to the numbers of neighbors of C into the current cell */
+                            /* compute how many vertices in C will be placed into the same new cell */
+                            for (i = ind0; i < ind1; i++) {
+                                value = NghCounts[lab[i]];
+                                if (Markers[value] != tv->mark) {
+                                    Markers[value] = tv->mark;
+                                    SplCnt[SplCntInd++] = value;
+                                    SplPos[value] = 1;
+                                }
+                                else {
+                                    SplPos[value]++;
+                                }
+                            }
+                            
+                            tv->mark++;
+                            
+                            /* Sort the values deriving from the previous step */
+                            sort_Split_Array(SplCnt, SplCntInd);
+                            Part->cells += SplCntInd-1;
+                            
+                            /* Split the cell C and update the information for sizes of new cells */
+                            /* Put the new cells into the stack */
+                            i = ind0;
+                            if (StackMarkers[i] != tv->stackmark) {
+                                BigCellSize = 0;
+                            }
+                            for (k = 0; k < SplCntInd; k++) {
+                                value = SplPos[SplCnt[k]];
+                                cls[i] = value;
+                                if ((StackMarkers[ind0] != tv->stackmark) && (value > BigCellSize)) {
+                                    BigCell = i;
+                                    BigCellPos = CStackInd;
+                                    BigCellSize = cls[i];
+                                }
+                                SplPos[SplCnt[k]] = i;
+                                i += value;
+                                if (i < ind1) {
+                                    CStack[++CStackInd] = i;
+                                    StackMarkers[i] = tv->stackmark;
+                                    trieref = trie_make(trieref, i, n, tv);
+                                }
+                            }
+                            if ((StackMarkers[ind0] != tv->stackmark) && (BigCell != ind0)) {
+                                CStack[BigCellPos] = ind0;
+                                StackMarkers[BigCell] = 0;
+                                StackMarkers[ind0] = tv->stackmark;
+                            }
+                            
+                            /* Permute elements of the cell C */
+                            i = ind0;
+                            do {
+                                SplCnt[SplPos[NghCounts[lab[i]]]++] = lab[i];
+                            }
+                            while(++i < ind1);
+                            
+                            /* Reconstruct the cell C and update the inverse partition */
+                            newcell = ind0;
+                            i = ind0;
+                            ind2 = newcell+cls[newcell]-1;
+                            do {
+                                lab[i] = SplCnt[i];
+                                InvLab[lab[i]] = i;
+                                Part->inv[i] = newcell;
+                                if (i == ind2) {
+                                    newcell = i+1;
+                                    if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                                }
+                            }
+                            while (++i < ind1);
+                        }
+                    }
+                    else {
+                        if (cls[ind0] == n) {
+                            for (i = 0; i < n; i++) {
+                                NghCounts[i] = TheGraph[i].d;
+                            }
+                        }
+                        else {
+                            memset(NghCounts, 0, n*sizeof(int));
+                            
+                            /* NEIGHCOUNT_DENSE_DENSE_MULT */
+                            for (i = ind0; i < ind2; i++) {
+                                labi = lab[i];
+                                nghb = TheGraph[labi].e;
+                                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                                    k = nghb[j1int];
+                                    (NghCounts[k])++;
+                                }
+                            }
+                            /* End NEIGHCOUNT_DENSE_DENSE_MULT */
+                            
+                        }
+                        
+                        ind0 = 0;
+                        while (ind0 < n) {	/* For each cell C with size(C) > 1 */
+                            ind1 = ind0+cls[ind0];
+                            if (cls[ind0] > 1) {
+                                
+                                /* Determine whether C must be split */
+                                SplCntInd = 0;
+                                value = NghCounts[lab[ind0]];
+                                for (i = ind0+1; i < ind1; i++)
+                                {
+                                    if (NghCounts[lab[i]] != value)
+                                    {
+                                        Markers[value] = tv->mark;
+                                        SplCnt[SplCntInd++] = value;
+                                        SplPos[value] = i-ind0;
+                                        do {
+                                            value = NghCounts[lab[i++]];
+                                            if (Markers[value] != tv->mark) {
+                                                Markers[value] = tv->mark;
+                                                SplCnt[SplCntInd++] = value;
+                                                SplPos[value] = 1;
+                                            }
+                                            else {
+                                                SplPos[value]++;
+                                            }
+                                        }
+                                        while(i != ind1);
+                                        break;
+                                    }
+                                }
+                                
+                                if (SplCntInd) {
+                                    tv->mark++;
+                                    
+                                    /* Sort the values deriving from the previous step */
+                                    sort_Split_Array(SplCnt, SplCntInd);
+                                    
+                                    Part->cells += SplCntInd-1;
+                                    
+                                    /* Split the cell C and update the information for sizes of new cells */
+                                    /* Put the new cells into the stack */
+                                    i = ind0;
+                                    if (StackMarkers[i] != tv->stackmark) {
+                                        BigCellSize = 0;
+                                    }
+                                    for (k = 0; k < SplCntInd; k++) {
+                                        value = SplPos[SplCnt[k]];
+                                        cls[i] = value;
+                                        if ((StackMarkers[ind0] != tv->stackmark) && (value > BigCellSize)) {
+                                            BigCell = i;
+                                            BigCellPos = CStackInd;
+                                            BigCellSize = cls[i];
+                                        }
+                                        SplPos[SplCnt[k]] = i;
+                                        i += value;
+                                        if (i < ind1) {
+                                            CStack[++CStackInd] = i;
+                                            StackMarkers[i] = tv->stackmark;
+                                        }
+                                    }
+                                    if ((StackMarkers[ind0] != tv->stackmark) && (BigCell != ind0)) {
+                                        CStack[BigCellPos] = ind0;
+                                        StackMarkers[BigCell] = 0;
+                                        StackMarkers[ind0] = tv->stackmark;
+                                        trieref = trie_make(trieref, i, n, tv);
+                                    }
+                                    
+                                    /* Permute elements of the cell C */
+                                    i = ind0;
+                                    do {
+                                        SplCnt[SplPos[NghCounts[lab[i]]]++] = lab[i];
+                                    }
+                                    while(++i < ind1);
+                                    
+                                    /* Reconstruct the cell C and update the inverse partition */
+                                    newcell = ind0;
+                                    i = ind0;
+                                    ind2 = newcell+cls[newcell]-1;
+                                    do {
+                                        lab[i] = SplCnt[i];
+                                        InvLab[lab[i]] = i;
+                                        Part->inv[i] = newcell;
+                                        if (i == ind2) {
+                                            newcell = i+1;
+                                            if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                                        }
+                                    }
+                                    while (++i < ind1);
+                                }
+                            }
+                            ind0 = ind1;
+                        }
+                    }
+                }
+            }
+        }
+        while (weightend < iend1int);
+    } /* end while (CStackInd > 0) */
+    
+    tv->augmented_cells = Part->cells - tv->augmented_cells;
+    
+    Cand->code = CLEANUP(longcode);
+    return;
+}
+
+int traces_refine_comptrie(Candidate *Cand,
+                           int n,
+                           Partition *Part,
+                           struct TracesVars* tv,
+                           struct TracesInfo *ti) {
+    int i, j, k, jk, sc, ind0, ind1, ind2, ind3, labi;
+    int value, iend, newcell;
+    int HitClsInd, SplInd, SplCntInd, CStackInd;
+    int j1int, iend1int;
+    unsigned int longcode;
+    int Split = 0;
+    int Sparse = TRUE;
+    int *lab, *cls, *InvLab, *SplitCell, *LabCell;
+    int BigCell, BigCellPos, BigCellSize;
+    int *nghb;
+    const int variation = 1;
+    int currentweight, weightstart, weightend, currentcell, currentsize;
+    
+    if (tv->stackmark > (NAUTY_INFINITY-2)) {
+        memset(StackMarkers, 0, n*sizeof(int));
+        tv->stackmark = 0;
+    }
+    tv->stackmark++;
+    
+    tv->augmented_cells = Part->cells;
+    
+    lab = Cand->lab;
+    InvLab = Cand->invlab;
+    cls = Part->cls;
+    
+    CStack[1] = Spine[tv->tolevel_tl].tgtpos;
+    CStackInd = 1;
+    for (i = 1; i <= CStackInd; i++) {
+        StackMarkers[CStack[i]] = tv->stackmark;
+    }
+    
+    longcode = Part->cells;
+    while (CStackInd > 0)
+    {
+        
+        weightend = 0;
+        
+        if (tv->mark > (NAUTY_INFINITY-2)) {
+            memset(Markers, 0, n*sizeof(int));
+            memset(MarkHitVtx, 0, n*sizeof(int));
+            tv->mark = 0;
+        }
+        tv->mark++;
+        
+        if (Part->cells == n) break;
+        
+        k = Select_from_CStack(cls, CStackInd);
+        
+        currentcell = CStack[k];
+        currentsize = currentcell+cls[currentcell];
+        CStack[k] = CStack[CStackInd--];		/* Current Cell */
+        longcode = MASHNONCOMM(longcode, currentcell);
+        StackMarkers[currentcell] = 0;
+        
+        labi = lab[currentcell];
+        iend1int = TheGraph[labi].d;
+        nghb =  TheGraph[labi].e;
+        
+        do {
+            ind0 = currentcell;
+            ind2 = currentsize;
+            weightstart = weightend;
+            
+            if (tv->options->weighted) {
+                currentweight = (TheGraph[labi].w)[weightstart];
+                while ((iend1int > weightend) && ((TheGraph[labi].w)[weightend] == currentweight)) {
+                    weightend++;
+                }
+            } else {
+                weightend = TheGraph[labi].d;
+            }
+            
+            /* Analysis of occurrences of neighbors of the current cell */
+            /* The list of cells with neighbors in the current cell is  built */
+            if (cls[ind0] == 1) {  /* SINGLETON CURRENT CELL CASE */
+                
+                /* NEIGHCOUNT_SING_MULT */
+                HitClsInd = 0;
+                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                    k = nghb[j1int];
+                    value = Part->inv[InvLab[k]];
+                    if (cls[value] > 1) {
+                        if (Markers[value] != tv->mark) {
+                            HitCls[HitClsInd++] = value;
+                            Markers[value] = tv->mark;
+                            ElmHitCll[value] = value;
+                        }
+                        HitVtx[ElmHitCll[value]++] = k;
+                    } else {
+                        switch (variation) {
+                            case 1:
+                                longcode = MASHCOMM(longcode, value);
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                }
+                /* end NEIGHCOUNT_SING_MULT */
+                
+                tv->mark++;
+                FIND_SPLIT_CELLS;
+                
+                /* Sorting the cells to be split */
+                sort_Split_Array(SplCls, SplInd);
+                
+                for (j = 0; j < SplInd; j++) {
+                    ind1 = SplCls[j];
+                    i = ind1+cls[ind1]-ElmHitCll[ind1];
+                    trieref = trie_comp(trieref, i);
+                    if (trieref == NULL) return 0;
+                }
+                
+                /* REARRANGE THE CELLS */
+                for (j = 0; j < SplInd; j++) {
+                    /* REARRANGE_CELLS */
+                    ind1 = SplCls[j];
+                    cls[ind1] = cls[ind1]-ElmHitCll[ind1];
+                    newcell = ind1+cls[ind1];
+                    cls[newcell] = ElmHitCll[ind1];
+                    Part->cells++;
+                    if (StackMarkers[ind1] != tv->stackmark) {
+                        if (cls[newcell] < cls[ind1]) {
+                            CStack[++CStackInd] = newcell;
+                            StackMarkers[newcell] = tv->stackmark;
+                        }
+                        else {
+                            CStack[++CStackInd] = ind1;
+                            StackMarkers[ind1] = tv->stackmark;
+                        }
+                    }
+                    else {
+                        CStack[++CStackInd] = newcell;
+                        StackMarkers[newcell] = tv->stackmark;
+                    }
+                    SplitCell = HitVtx+ind1;
+                    ind3 = cls[newcell];
+                    LabCell = lab+newcell;
+                    for (jk = 0; jk < ind3; jk++) {
+                        k = SplitCell[jk];
+                        i = LabCell[jk];
+                        Part->inv[newcell+jk] = newcell;
+                        lab[InvLab[k]] = i;
+                        InvLab[i] = InvLab[k];
+                        LabCell[jk] = k;
+                        InvLab[k] = newcell+jk;
+                    }
+                    /* END REARRANGE_CELLS */
+                }
+            }
+            else {
+                if (ti->thegraphisparse) {
+                    
+                    /* NEIGHCOUNT_SPARSE_MULT */
+                    if (cls[ind0] != n) {
+                        HitClsInd = 0;
+                        for (i = ind0; i < ind2; i++) {
+                            labi = lab[i];
+                            nghb = TheGraph[labi].e;
+                            for (j = weightstart; j < weightend; j++) {
+                                k = nghb[j];
+                                if (MarkHitVtx[k] == tv->mark) {
+                                    NghCounts[k]++;
+                                }
+                                else {
+                                    value = Part->inv[InvLab[k]];
+                                    if (cls[value] > 1) {
+                                        MarkHitVtx[k] = tv->mark;
+                                        NghCounts[k] = 1;
+                                        if (Markers[value] != tv->mark) {
+                                            HitCls[HitClsInd++] = value;
+                                            Markers[value] = tv->mark;
+                                            HitVtx[value] = k;
+                                            ElmHitCll[value] = 1;
+                                        }
+                                        else {
+                                            HitVtx[value+ElmHitCll[value]++] = k;
+                                        }
+                                    }
+                                    else {
+                                        switch (variation) {
+                                            case 1:
+                                                longcode = MASHCOMM(longcode, value);
+                                                break;
+                                            default:
+                                                break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    /* End NEIGHCOUNT_SPARSE_MULT */
+                    
+                    tv->mark++;
+                    
+                    SplInd = 0;
+                    SplCls[0] = n;
+                    for (j = 0; j < HitClsInd; j++) {
+                        ind1 = HitCls[j];
+                        if ((ElmHitCll[ind1] > 0) && (ElmHitCll[ind1] < cls[ind1])) {
+                            SplCls[SplInd++] = ind1;
+                        }
+                        else {
+                            ind2 = ind1+cls[ind1];
+                            Split = FALSE;
+                            value = NghCounts[lab[ind1++]];
+                            for (i = ind1; i < ind2; i++)
+                            {
+                                if (NghCounts[lab[i]] != value)
+                                {
+                                    SplCls[SplInd++] = HitCls[j];
+                                    Split = TRUE;
+                                    break;
+                                }
+                            }
+                            if (!Split) {
+                                longcode = MASHCOMM(longcode, ind1);
+                            }
+                        }
+                    }
+                    
+                    /* Sorting the cells to be split */
+                    sort_Split_Array(SplCls, SplInd);
+                    
+                    for (sc = 0; sc < SplInd; sc++) {	/* For each cell C to be split */
+                        ind0 = SplCls[sc];
+                        ind1 = ind0 + cls[ind0];
+                        SplCntInd = 0;
+                        if (ElmHitCll[ind0] < cls[ind0]) {
+                            SplCnt[SplCntInd++] = 0;
+                            SplPos[0] = cls[ind0] - ElmHitCll[ind0];
+                        }
+                        
+                        /* According to the numbers of neighbors of C into the current cell */
+                        /* compute how many vertices in C will be placed into the same new cell */
+                        iend = ind0 + ElmHitCll[ind0];
+                        for (i = ind0; i < iend; i++) {
+                            value = NghCounts[HitVtx[i]];
+                            if (Markers[value] != tv->mark) {
+                                Markers[value] = tv->mark;
+                                SplCnt[SplCntInd++] = value;
+                                SplPos[value] = 1;
+                            }
+                            else {
+                                SplPos[value]++;
+                            }
+                        }
+                        
+                        tv->mark++;
+                        
+                        /* Sort the values deriving from the previous step */
+                        sort_Split_Array(SplCnt, SplCntInd);
+                        Part->cells += SplCntInd-1;
+                        
+                        /* Split the cell C and update the information for sizes of new cells */
+                        /* Put the new cells into the stack */
+                        i = ind0;
+                        if (StackMarkers[i] != tv->stackmark) {
+                            BigCellSize = 0;
+                        }
+                        for (k = 0; k < SplCntInd; k++) {
+                            value = SplPos[SplCnt[k]];
+                            cls[i] = value;
+                            if ((StackMarkers[ind0] != tv->stackmark) && (value > BigCellSize)) {
+                                BigCell = i;
+                                BigCellPos = CStackInd;
+                                BigCellSize = cls[i];
+                            }
+                            SplPos[SplCnt[k]] = i;
+                            i += value;
+                            if (i < ind1) {
+                                CStack[++CStackInd] = i;
+                                StackMarkers[i] = tv->stackmark;
+                                trieref = trie_comp(trieref, i);
+                                if (trieref == NULL) return 0;
+                            }
+                        }
+                        
+                        if ((StackMarkers[ind0] != tv->stackmark) && (BigCell != ind0)) {
+                            CStack[BigCellPos] = ind0;
+                            StackMarkers[BigCell] = 0;
+                            StackMarkers[ind0] = tv->stackmark;
+                        }
+                        /* Permute elements of the cell C */
+                        iend = ind0 + ElmHitCll[ind0];
+                        for (i = ind0; i < iend; i++) {
+                            value = HitVtx[i];
+                            j = SplPos[NghCounts[value]]++; /* where HitVtx[i] goes */
+                            k = InvLab[value];				/* where HitVtx[i] is in lab */
+                            lab[k] = lab[j];
+                            lab[j] = value;
+                            InvLab[value] = j;
+                            InvLab[lab[k]] = k;
+                            NghCounts[value] = 0;
+                        }
+                        
+                        /* Reconstruct the cell C and update the inverse partition */
+                        newcell = ind1 - ElmHitCll[ind0];
+                        i = newcell;
+                        ind2 = newcell+cls[newcell]-1;
+                        do {
+                            Part->inv[i] = newcell;
+                            if (i == ind2) {
+                                newcell = i+1;
+                                if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                            }
+                        }
+                        while (++i < ind1);
+                    }
+                }
+                else {
+                    if (TheGraph[lab[ind0]].d > n/cls[ind0]) {
+                        Sparse = FALSE;
+                    }
+                    else {
+                        Sparse = TRUE;
+                    }
+                    if (Sparse) {
+                        /* Counting occurrences of neighbors of the current cell */
+                        /* The list of cells with neighbors in the current cell is also built */
+                        if (cls[ind0] == n) {
+                            for (i = 0; i < n; i++) {
+                                NghCounts[i] = TheGraph[i].d;
+                            }
+                            HitCls[0] = 0;
+                            HitClsInd = 1;
+                        }
+                        else {
+                            memset(NghCounts, 0, n*sizeof(int));
+                            
+                            /* NEIGHCOUNT_DENSE_SPARSE_MULT */
+                            HitClsInd = 0;
+                            for (i = ind0; i < ind2; i++) {
+                                labi = lab[i];
+                                nghb =  TheGraph[labi].e;
+                                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                                    k = nghb[j1int];
+                                    (NghCounts[k])++;
+                                    value = Part->inv[InvLab[k]];
+                                    if (Markers[value] != tv->mark) {
+                                        if (cls[value] > 1) HitCls[HitClsInd++] = value;
+                                        Markers[value] = tv->mark;
+                                    }
+                                }
+                            }
+                            /* End NEIGHCOUNT_DENSE_SPARSE_MULT */
+                            ;
+                        }
+                        
+                        tv->mark++;
+                        
+                        SplInd = 0;
+                        for (j = 0; j < HitClsInd; j++) {
+                            ind1 = HitCls[j];
+                            ind2 = ind1+cls[ind1];
+                            value = NghCounts[lab[ind1++]];
+                            for (i = ind1; i < ind2; i++)
+                            {
+                                if (NghCounts[lab[i]] != value)
+                                {
+                                    SplCls[SplInd++] = HitCls[j];
+                                    break;
+                                }
+                            }
+                        }
+                        
+                        /* Sorting the cells to be split */
+                        sort_Split_Array(SplCls, SplInd);
+                        
+                        for (j = 0; j < SplInd; j++) {	/* For each cell C to be split */
+                            ind0 = SplCls[j];
+                            ind1 = ind0+cls[ind0];
+                            SplCntInd = 0;
+                            
+                            /* According to the numbers of neighbors of C into the current cell */
+                            /* compute how many vertices in C will be placed into the same new cell */
+                            for (i = ind0; i < ind1; i++) {
+                                value = NghCounts[lab[i]];
+                                if (Markers[value] != tv->mark) {
+                                    Markers[value] = tv->mark;
+                                    SplCnt[SplCntInd++] = value;
+                                    SplPos[value] = 1;
+                                }
+                                else {
+                                    SplPos[value]++;
+                                }
+                            }
+                            
+                            tv->mark++;
+                            
+                            /* Sort the values deriving from the previous step */
+                            sort_Split_Array(SplCnt, SplCntInd);
+                            
+                            Part->cells += SplCntInd-1;
+                            
+                            /* Split the cell C and update the information for sizes of new cells */
+                            /* Put the new cells into the stack */
+                            i = ind0;
+                            if (StackMarkers[i] != tv->stackmark) {
+                                BigCellSize = 0;
+                            }
+                            for (k = 0; k < SplCntInd; k++) {
+                                value = SplPos[SplCnt[k]];
+                                cls[i] = value;
+                                if ((StackMarkers[ind0] != tv->stackmark) && (value > BigCellSize)) {
+                                    BigCell = i;
+                                    BigCellPos = CStackInd;
+                                    BigCellSize = cls[i];
+                                }
+                                SplPos[SplCnt[k]] = i;
+                                i += value;
+                                if (i < ind1) {
+                                    CStack[++CStackInd] = i;
+                                    StackMarkers[i] = tv->stackmark;
+                                    trieref = trie_comp(trieref, i);
+                                    if (trieref == NULL) return 0;
+                                }
+                            }
+                            if ((StackMarkers[ind0] != tv->stackmark) && (BigCell != ind0)) {
+                                CStack[BigCellPos] = ind0;
+                                StackMarkers[BigCell] = 0;
+                                StackMarkers[ind0] = tv->stackmark;
+                            }
+                            
+                            /* Permute elements of the cell C */
+                            i = ind0;
+                            do {
+                                SplCnt[SplPos[NghCounts[lab[i]]]++] = lab[i];
+                            }
+                            while(++i < ind1);
+                            
+                            /* Reconstruct the cell C and update the inverse partition */
+                            newcell = ind0;
+                            i = ind0;
+                            ind2 = newcell+cls[newcell]-1;
+                            do {
+                                lab[i] = SplCnt[i];
+                                InvLab[lab[i]] = i;
+                                Part->inv[i] = newcell;
+                                
+                                if (i == ind2) {
+                                    newcell = i+1;
+                                    if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                                }
+                            }
+                            while (++i < ind1);
+                        }
+                    }
+                    else {
+                        if (cls[ind0] == n) {
+                            for (i = 0; i < n; i++) {
+                                NghCounts[i] = TheGraph[i].d;
+                            }
+                        }
+                        else {
+                            memset(NghCounts, 0, n*sizeof(int));
+                            
+                            /* NEIGHCOUNT_DENSE_DENSE_MULT */
+                            for (i = ind0; i < ind2; i++) {
+                                labi = lab[i];
+                                nghb = TheGraph[labi].e;
+                                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                                    k = nghb[j1int];
+                                    (NghCounts[k])++;
+                                }
+                            }
+                            /* End NEIGHCOUNT_DENSE_DENSE_MULT */
+                            
+                        }
+                        
+                        ind0 = 0;
+                        while (ind0 < n) {	/* For each cell C with size(C) > 1 */
+                            ind1 = ind0+cls[ind0];
+                            if (cls[ind0] > 1) {
+                                
+                                /* Determine whether C must be split */
+                                SplCntInd = 0;
+                                value = NghCounts[lab[ind0]];
+                                for (i = ind0+1; i < ind1; i++)
+                                {
+                                    if (NghCounts[lab[i]] != value)
+                                    {
+                                        Markers[value] = tv->mark;
+                                        SplCnt[SplCntInd++] = value;
+                                        SplPos[value] = i-ind0;
+                                        do {
+                                            value = NghCounts[lab[i++]];
+                                            if (Markers[value] != tv->mark) {
+                                                Markers[value] = tv->mark;
+                                                SplCnt[SplCntInd++] = value;
+                                                SplPos[value] = 1;
+                                            }
+                                            else {
+                                                SplPos[value]++;
+                                            }
+                                        }
+                                        while(i != ind1);
+                                        break;
+                                    }
+                                }
+                                
+                                if (SplCntInd) {
+                                    tv->mark++;
+                                    
+                                    /* Sort the values deriving from the previous step */
+                                    sort_Split_Array(SplCnt, SplCntInd);
+                                    
+                                    Part->cells += SplCntInd-1;
+                                    
+                                    /* Split the cell C and update the information for sizes of new cells */
+                                    /* Put the new cells into the stack */
+                                    i = ind0;
+                                    if (StackMarkers[i] != tv->stackmark) {
+                                        BigCellSize = 0;
+                                    }
+                                    for (k = 0; k < SplCntInd; k++) {
+                                        value = SplPos[SplCnt[k]];
+                                        cls[i] = value;
+                                        if ((StackMarkers[ind0] != tv->stackmark) && (value > BigCellSize)) {
+                                            BigCell = i;
+                                            BigCellPos = CStackInd;
+                                            BigCellSize = cls[i];
+                                        }
+                                        SplPos[SplCnt[k]] = i;
+                                        i += value;
+                                        if (i < ind1) {
+                                            CStack[++CStackInd] = i;
+                                            StackMarkers[i] = tv->stackmark;
+                                        }
+                                    }
+                                    if ((StackMarkers[ind0] != tv->stackmark) && (BigCell != ind0)) {
+                                        CStack[BigCellPos] = ind0;
+                                        StackMarkers[BigCell] = 0;
+                                        StackMarkers[ind0] = tv->stackmark;
+                                        trieref = trie_comp(trieref, i);
+                                        if (trieref == NULL) return 0;
+                                    }
+                                    
+                                    /* Permute elements of the cell C */
+                                    i = ind0;
+                                    do {
+                                        SplCnt[SplPos[NghCounts[lab[i]]]++] = lab[i];
+                                    }
+                                    while(++i < ind1);
+                                    
+                                    /* Reconstruct the cell C and update the inverse partition */
+                                    newcell = ind0;
+                                    i = ind0;
+                                    ind2 = newcell+cls[newcell]-1;
+                                    do {
+                                        lab[i] = SplCnt[i];
+                                        InvLab[lab[i]] = i;
+                                        Part->inv[i] = newcell;
+                                        if (i == ind2) {
+                                            newcell = i+1;
+                                            if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                                        }
+                                    }
+                                    while (++i < ind1);
+                                }
+                            }
+                            ind0 = ind1;
+                        }
+                    }
+                }
+            }
+        }
+        while (weightend < iend1int);
+    }  /* end while (CStackInd > 0) */
+    
+    tv->augmented_cells = Part->cells - tv->augmented_cells;
+    
+    Cand->code = CLEANUP(longcode);
+    return 1;
+}
+
+int traces_refine_sametrace(Candidate *Cand,
+                            int n,
+                            Partition *Part,
+                            struct TracesVars* tv,
+                            struct TracesInfo *ti) {
+    int i, j, k, jk, sc, ind0, ind1, ind2, ind3, ind4, labi;
+    int value, iend, newcell;
+    int HitClsInd, SplInd, SplCntInd, CStackInd, TraceInd, TraceCCInd, TraceStepsInd;
+    int j1int, iend1int;
+    unsigned int longcode;
+    int Sparse = TRUE;
+    int *lab, *cls, *InvLab, *TracePos, *SplitCell, *LabCell, *TraceEnd, Traceccend, *Tracestpend;
+    int BigCell, BigCellPos, BigCellSize;
+    boolean TraceCell = FALSE;
+    int *nghb;
+    const int variation = 0;
+    int currentweight, weightstart, weightend, currentcell, currentsize;
+    
+    if (tv->stackmark > (NAUTY_INFINITY-2)) {
+        memset(StackMarkers, 0, n*sizeof(int));
+        tv->stackmark = 0;
+    }
+    tv->stackmark++;
+    
+    tv->augmented_cells = Part->cells;
+    
+    SpineTL = Spine+tv->tolevel;
+    TraceEnd = &(SpineTL->trcend);
+    Traceccend = SpineTL->ccend;
+    Tracestpend = &(SpineTL->stpend);
+    TraceCCInd = SpineTL->ccstart;
+    TraceStepsInd = SpineTL->stpstart;
+    
+    lab = Cand->lab;
+    InvLab = Cand->invlab;
+    cls = Part->cls;
+    
+    UPDATEMIN(Part->active, n-1);
+    memcpy(CStack+1, TheTrace+SpineTL->trcstart, (Part->active)*sizeof(int));
+    CStackInd = Part->active;
+    for (i = 1; i <= CStackInd; i++) {
+        StackMarkers[CStack[i]] = tv->stackmark;
+    }
+    
+    longcode = Part->cells;
+    TraceInd = SpineTL->trcstart+Part->active;
+    
+    while (CStackInd > 0)
+    {
+        
+        weightend = 0;
+        
+        if (tv->mark > (NAUTY_INFINITY-2)) {
+            memset(Markers, 0, n*sizeof(int));
+            memset(MarkHitVtx, 0, n*sizeof(int));
+            tv->mark = 0;
+        }
+        tv->mark++;
+        
+        if (Part->cells == n) break;
+        
+        k = Select_from_CStack(cls, CStackInd);
+        
+        currentcell = CStack[k];
+        currentsize = currentcell+cls[currentcell];
+        CStack[k] = CStack[CStackInd--];		/* Current Cell */
+        StackMarkers[currentcell] = 0;
+        
+        labi = lab[currentcell];
+        iend1int = TheGraph[labi].d;
+        nghb =  TheGraph[labi].e;
+        
+        do {
+            ind0 = currentcell;
+            ind2 = currentsize;
+            weightstart = weightend;
+            
+            if (tv->options->weighted) {
+                currentweight = (TheGraph[labi].w)[weightstart];
+                while ((iend1int > weightend) && ((TheGraph[labi].w)[weightend] == currentweight)) {
+                    weightend++;
+                }
+            } else {
+                weightend = TheGraph[labi].d;
+            }
+            
+            TraceCell = ((ind0 == TheTraceCC[TraceCCInd]) && (TraceCCInd < Traceccend));
+            
+            /* Analysis of occurrences of neighbors of the current cell */
+            /* The list of cells with neighbors in the current cell is  built */
+            if (cls[ind0] == 1) {  /* SINGLETON CURRENT CELL CASE */
+                
+                /* NEIGHCOUNT_SING_MULT */
+                HitClsInd = 0;
+                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                    k = nghb[j1int];
+                    value = Part->inv[InvLab[k]];
+                    if (cls[value] > 1) {
+                        if (Markers[value] != tv->mark) {
+                            HitCls[HitClsInd++] = value;
+                            Markers[value] = tv->mark;
+                            ElmHitCll[value] = value;
+                        }
+                        HitVtx[ElmHitCll[value]++] = k;
+                    } else {
+                        switch (variation) {
+                            case 1:
+                                longcode = MASHCOMM(longcode, value);
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                }
+                /* end NEIGHCOUNT_SING_MULT */
+                
+                tv->mark++;
+                FIND_SPLIT_CELLS;
+                
+                /* SINGLETON CC CASE */
+                if (SplInd) {
+                    SAMETRACE_CHECK(TheTraceSplNum, TraceCCInd, SplInd, &Traceccend)
+                    
+                    /* Sorting the cells to be split */
+                    sort_Split_Array(SplCls, SplInd);
+                    
+                    for (j = 0; j < SplInd; j++) {
+                        ind1 = SplCls[j];
+                        i = ind1+cls[ind1]-ElmHitCll[ind1];
+                        SAMETRACE_CHECK(TheTrace, TraceInd, i, TraceEnd)
+                    }
+                    
+                    /* REARRANGE THE CELLS */
+                    for (j = 0; j < SplInd; j++) {
+                        /* REARRANGE_CELLS */
+                        ind1 = SplCls[j];
+                        cls[ind1] = cls[ind1]-ElmHitCll[ind1];
+                        newcell = ind1+cls[ind1];
+                        cls[newcell] = ElmHitCll[ind1];
+                        Part->cells++;
+                        if (StackMarkers[ind1] != tv->stackmark) {
+                            if (cls[newcell] < cls[ind1]) {
+                                CStack[++CStackInd] = newcell;
+                                StackMarkers[newcell] = tv->stackmark;
+                            }
+                            else {
+                                CStack[++CStackInd] = ind1;
+                                StackMarkers[ind1] = tv->stackmark;
+                            }
+                        }
+                        else {
+                            CStack[++CStackInd] = newcell;
+                            StackMarkers[newcell] = tv->stackmark;
+                        }
+                        SplitCell = HitVtx+ind1;
+                        ind3 = cls[newcell];
+                        LabCell = lab+newcell;
+                        for (jk = 0; jk < ind3; jk++) {
+                            k = SplitCell[jk];
+                            i = LabCell[jk];
+                            Part->inv[newcell+jk] = newcell;
+                            lab[InvLab[k]] = i;
+                            InvLab[i] = InvLab[k];
+                            LabCell[jk] = k;
+                            InvLab[k] = newcell+jk;
+                        }
+                        /* END REARRANGE_CELLS */
+                        
+                        if (cls[ind1] == 1) {
+                            Cand->singcode = MASHCOMM(Cand->singcode, Cand->lab[ind1]);
+                        }
+                        if (cls[newcell] == 1) {
+                            Cand->singcode = MASHCOMM(Cand->singcode, Cand->lab[newcell]);
+                        }
+                    }
+                }
+                else {
+                    if (TraceCell) {
+                        return 0;
+                    }
+                }
+                
+            }
+            else {
+                if (ti->thegraphisparse) {
+                    
+                    /* NEIGHCOUNT_SPARSE_MULT */
+                    if (cls[ind0] != n) {
+                        HitClsInd = 0;
+                        for (i = ind0; i < ind2; i++) {
+                            labi = lab[i];
+                            nghb = TheGraph[labi].e;
+                            for (j = weightstart; j < weightend; j++) {
+                                k = nghb[j];
+                                if (MarkHitVtx[k] == tv->mark) {
+                                    NghCounts[k]++;
+                                }
+                                else {
+                                    value = Part->inv[InvLab[k]];
+                                    if (cls[value] > 1) {
+                                        MarkHitVtx[k] = tv->mark;
+                                        NghCounts[k] = 1;
+                                        if (Markers[value] != tv->mark) {
+                                            HitCls[HitClsInd++] = value;
+                                            Markers[value] = tv->mark;
+                                            HitVtx[value] = k;
+                                            ElmHitCll[value] = 1;
+                                        }
+                                        else {
+                                            HitVtx[value+ElmHitCll[value]++] = k;
+                                        }
+                                    }
+                                    else {
+                                        switch (variation) {
+                                            case 1:
+                                                longcode = MASHCOMM(longcode, value);
+                                                break;
+                                            default:
+                                                break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    /* End NEIGHCOUNT_SPARSE_MULT */
+                    
+                    tv->mark++;
+                    
+                    SplInd = 0;
+                    SplCls[0] = n;
+                    for (j = 0; j < HitClsInd; j++) {
+                        ind1 = HitCls[j];
+                        if ((ElmHitCll[ind1] > 0) && (ElmHitCll[ind1] < cls[ind1])) {
+                            SplCls[SplInd++] = ind1;
+                        }
+                        else {
+                            ind2 = ind1+cls[ind1];
+                            value = NghCounts[lab[ind1++]];
+                            for (i = ind1; i < ind2; i++)
+                            {
+                                if (NghCounts[lab[i]] != value)
+                                {
+                                    SplCls[SplInd++] = HitCls[j];
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    
+                    /* SPARSE CASE */
+                    if (SplInd) {
+                        SAMETRACE_CHECK(TheTraceSplNum, TraceCCInd, SplInd+n, &Traceccend)
+                        
+                        /* Sorting the cells to be split */
+                        sort_Split_Array(SplCls, SplInd);
+                        
+                        for (sc = 0; sc < SplInd; sc++) {	/* For each cell C to be split */
+                            ind0 = SplCls[sc];
+                            ind1 = ind0 + cls[ind0];
+                            SplCntInd = 0;
+                            if (ElmHitCll[ind0] < cls[ind0]) {
+                                SplCnt[SplCntInd++] = 0;
+                                SplPos[0] = cls[ind0] - ElmHitCll[ind0];
+                            }
+                            
+                            /* According to the numbers of neighbors of C into the current cell */
+                            /* compute how many vertices in C will be placed into the same new cell */
+                            iend = ind0 + ElmHitCll[ind0];
+                            for (i = ind0; i < iend; i++) {
+                                value = NghCounts[HitVtx[i]];
+                                if (Markers[value] != tv->mark) {
+                                    Markers[value] = tv->mark;
+                                    SplCnt[SplCntInd++] = value;
+                                    SplPos[value] = 1;
+                                }
+                                else {
+                                    SplPos[value]++;
+                                }
+                            }
+                            tv->mark++;
+                            
+                            if (SplCntInd) {
+                                SAMETRACE_CHECK(TheTraceSteps, TraceStepsInd, SplCntInd+n, Tracestpend)
+                            }
+                            
+                            /* Sort the values deriving from the previous step */
+                            sort_Split_Array(SplCnt, SplCntInd);
+                            
+                            Part->cells += SplCntInd-1;
+                            
+                            /* Split the cell C and update the information for sizes of new cells */
+                            /* Put the new cells into the stack */
+                            i = ind0;
+                            if (StackMarkers[i] != tv->stackmark) {
+                                BigCellSize = 0;
+                            }
+                            for (k = 0; k < SplCntInd; k++) {
+                                value = SplPos[SplCnt[k]];
+                                cls[i] = value;
+                                if ((StackMarkers[ind0] != tv->stackmark) && (value > BigCellSize)) {
+                                    BigCell = i;
+                                    BigCellPos = CStackInd;
+                                    BigCellSize = cls[i];
+                                }
+                                SplPos[SplCnt[k]] = i;
+                                i += value;
+                                if (i < ind1) {
+                                    CStack[++CStackInd] = i;
+                                    StackMarkers[i] = tv->stackmark;
+                                    SAMETRACE_CHECK(TheTrace, TraceInd, i, TraceEnd)
+                                }
+                            }
+                            
+                            if ((StackMarkers[ind0] != tv->stackmark) && (BigCell != ind0)) {
+                                CStack[BigCellPos] = ind0;
+                                StackMarkers[BigCell] = 0;
+                                StackMarkers[ind0] = tv->stackmark;
+                            }
+                            /* Permute elements of the cell C */
+                            iend = ind0 + ElmHitCll[ind0];
+                            for (i = ind0; i < iend; i++) {
+                                value = HitVtx[i];
+                                j = SplPos[NghCounts[value]]++; /* where HitVtx[i] goes */
+                                k = InvLab[value];				/* where HitVtx[i] is in lab */
+                                lab[k] = lab[j];
+                                lab[j] = value;
+                                InvLab[value] = j;
+                                InvLab[lab[k]] = k;
+                                NghCounts[value] = 0;
+                            }
+                            
+                            /* Reconstruct the cell C and update the inverse partition */
+                            newcell = ind1 - ElmHitCll[ind0];
+                            i = newcell;
+                            ind2 = newcell+cls[newcell]-1;
+                            do {
+                                Part->inv[i] = newcell;
+                                if (i == ind2) {
+                                    newcell = i+1;
+                                    if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                                }
+                            }
+                            while (++i < ind1);
+                            
+                            for (i = ind0, k = 0; k < SplCntInd; i+=cls[i], k++) {
+                                if (cls[i] == 1) {
+                                    Cand->singcode = MASHCOMM(Cand->singcode, Cand->lab[i]);
+                                }
+                            }
+                            
+                        }
+                    }
+                    else {
+                        if (TraceCell) {
+                            return 0;
+                        }
+                    }
+                    
+                }
+                else {
+                    if (TheGraph[lab[ind0]].d > n/cls[ind0]) {
+                        Sparse = FALSE;
+                    }
+                    else {
+                        Sparse = TRUE;
+                    }
+                    if (Sparse) {
+                        /* Counting occurrences of neighbors of the current cell */
+                        /* The list of cells with neighbors in the current cell is also built */
+                        if (cls[ind0] == n) {
+                            for (i = 0; i < n; i++) {
+                                NghCounts[i] = TheGraph[i].d;
+                            }
+                            HitCls[0] = 0;
+                            HitClsInd = 1;
+                        }
+                        else {
+                            memset(NghCounts, 0, n*sizeof(int));
+                            
+                            /* NEIGHCOUNT_DENSE_SPARSE_MULT */
+                            HitClsInd = 0;
+                            for (i = ind0; i < ind2; i++) {
+                                labi = lab[i];
+                                nghb =  TheGraph[labi].e;
+                                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                                    k = nghb[j1int];
+                                    (NghCounts[k])++;
+                                    value = Part->inv[InvLab[k]];
+                                    if (Markers[value] != tv->mark) {
+                                        if (cls[value] > 1) HitCls[HitClsInd++] = value;
+                                        Markers[value] = tv->mark;
+                                    }
+                                }
+                            }
+                            /* End NEIGHCOUNT_DENSE_SPARSE_MULT */
+                            
+                        }
+                        
+                        tv->mark++;
+                        
+                        SplInd = 0;
+                        for (j = 0; j < HitClsInd; j++) {
+                            ind1 = HitCls[j];
+                            ind2 = ind1+cls[ind1];
+                            value = NghCounts[lab[ind1++]];
+                            for (i = ind1; i < ind2; i++)
+                            {
+                                if (NghCounts[lab[i]] != value)
+                                {
+                                    SplCls[SplInd++] = HitCls[j];
+                                    break;
+                                }
+                            }
+                        }
+                        
+                        /* DENSE-SPARSE CASE */
+                        if (SplInd) {
+                            SAMETRACE_CHECK(TheTraceSplNum, TraceCCInd, SplInd+2*n, &Traceccend)
+                            
+                            /* Sorting the cells to be split */
+                            sort_Split_Array(SplCls, SplInd);
+                            
+                            for (j = 0; j < SplInd; j++) {	/* For each cell C to be split */
+                                ind0 = SplCls[j];
+                                ind1 = ind0+cls[ind0];
+                                SplCntInd = 0;
+                                
+                                /* According to the numbers of neighbors of C into the current cell */
+                                /* compute how many vertices in C will be placed into the same new cell */
+                                for (i = ind0; i < ind1; i++) {
+                                    value = NghCounts[lab[i]];
+                                    if (Markers[value] != tv->mark) {
+                                        Markers[value] = tv->mark;
+                                        SplCnt[SplCntInd++] = value;
+                                        SplPos[value] = 1;
+                                    }
+                                    else {
+                                        SplPos[value]++;
+                                    }
+                                }
+                                tv->mark++;
+                                
+                                if (SplCntInd) {
+                                    SAMETRACE_CHECK(TheTraceSteps, TraceStepsInd, SplCntInd+2*n, Tracestpend)
+                                }
+                                
+                                /* Sort the values deriving from the previous step */
+                                sort_Split_Array(SplCnt, SplCntInd);
+                                Part->cells += SplCntInd-1;
+                                
+                                /* Split the cell C and update the information for sizes of new cells */
+                                /* Put the new cells into the stack */
+                                i = ind0;
+                                if (StackMarkers[i] != tv->stackmark) {
+                                    BigCellSize = 0;
+                                }
+                                for (k = 0; k < SplCntInd; k++) {
+                                    value = SplPos[SplCnt[k]];
+                                    cls[i] = value;
+                                    if ((StackMarkers[ind0] != tv->stackmark) && (value > BigCellSize)) {
+                                        BigCell = i;
+                                        BigCellPos = CStackInd;
+                                        BigCellSize = cls[i];
+                                    }
+                                    SplPos[SplCnt[k]] = i;
+                                    i += value;
+                                    if (i < ind1) {
+                                        CStack[++CStackInd] = i;
+                                        StackMarkers[i] = tv->stackmark;
+                                        SAMETRACE_CHECK(TheTrace, TraceInd, i, TraceEnd)
+                                    }
+                                }
+                                
+                                if ((StackMarkers[ind0] != tv->stackmark) && (BigCell != ind0)) {
+                                    CStack[BigCellPos] = ind0;
+                                    StackMarkers[BigCell] = 0;
+                                    StackMarkers[ind0] = tv->stackmark;
+                                }
+                                
+                                /* Permute elements of the cell C */
+                                i = ind0;
+                                do {
+                                    SplCnt[SplPos[NghCounts[lab[i]]]++] = lab[i];
+                                }
+                                while(++i < ind1);
+                                
+                                /* Reconstruct the cell C and update the inverse partition */
+                                newcell = ind0;
+                                i = ind0;
+                                ind2 = newcell+cls[newcell]-1;
+                                do {
+                                    lab[i] = SplCnt[i];
+                                    InvLab[lab[i]] = i;
+                                    Part->inv[i] = newcell;
+                                    if (i == ind2) {
+                                        newcell = i+1;
+                                        if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                                    }
+                                }
+                                while (++i < ind1);
+                                
+                                for (i = ind0, k = 0; k < SplCntInd; i+=cls[i], k++) {
+                                    if (cls[i] == 1) {
+                                        Cand->singcode = MASHCOMM(Cand->singcode, Cand->lab[i]);
+                                    }
+                                }
+                                
+                            }
+                        }
+                        else {
+                            if (TraceCell) {
+                                return 0;
+                            }
+                        }
+                        
+                    }
+                    else {
+                        if (cls[ind0] == n) {
+                            for (i = 0; i < n; i++) {
+                                NghCounts[i] = TheGraph[i].d;
+                            }
+                        }
+                        else {
+                            memset(NghCounts, 0, n*sizeof(int));
+                            
+                            /* NEIGHCOUNT_DENSE_DENSE_MULT */
+                            for (i = ind0; i < ind2; i++) {
+                                labi = lab[i];
+                                nghb = TheGraph[labi].e;
+                                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                                    k = nghb[j1int];
+                                    (NghCounts[k])++;
+                                }
+                            }
+                            /* End NEIGHCOUNT_DENSE_DENSE_MULT */
+                            
+                        }
+                        SplInd = 0;
+                        ind4 = 0;
+                        while (ind4 < n) {	/* For each cell C with size(C) > 1 */
+                            ind1 = ind4+cls[ind4];
+                            if (cls[ind4] > 1) {
+                                
+                                /* Determine whether C must be split */
+                                SplCntInd = 0;
+                                value = NghCounts[lab[ind4]];
+                                for (i = ind4+1; i < ind1; i++) {
+                                    if (NghCounts[lab[i]] != value)
+                                    {
+                                        SplInd++;
+                                        Markers[value] = tv->mark;
+                                        SplCnt[SplCntInd++] = value;
+                                        SplPos[value] = i-ind4;
+                                        do {
+                                            value = NghCounts[lab[i++]];
+                                            if (Markers[value] != tv->mark) {
+                                                Markers[value] = tv->mark;
+                                                SplCnt[SplCntInd++] = value;
+                                                SplPos[value] = 1;
+                                            }
+                                            else {
+                                                SplPos[value]++;
+                                            }
+                                        }
+                                        while(i != ind1);
+                                        break;
+                                    }
+                                }
+                                tv->mark++;
+                                
+                                if (SplCntInd) {
+                                    SAMETRACE_CHECK(TheTraceSteps, TraceStepsInd, SplCntInd+3*n, Tracestpend)
+                                    
+                                    /* Sort the values deriving from the previous step */
+                                    sort_Split_Array(SplCnt, SplCntInd);
+                                    
+                                    Part->cells += SplCntInd-1;
+                                    
+                                    /* Split the cell C and update the information for sizes of new cells */
+                                    /* Put the new cells into the stack */
+                                    i = ind4;
+                                    if (StackMarkers[i] != tv->stackmark) {
+                                        BigCellSize = 0;
+                                    }
+                                    for (k = 0; k < SplCntInd; k++) {
+                                        value = SplPos[SplCnt[k]];
+                                        cls[i] = value;
+                                        if ((StackMarkers[ind4] != tv->stackmark) && (value > BigCellSize)) {
+                                            BigCell = i;
+                                            BigCellPos = CStackInd;
+                                            BigCellSize = cls[i];
+                                        }
+                                        SplPos[SplCnt[k]] = i;
+                                        i += value;
+                                        if (i < ind1) {
+                                            CStack[++CStackInd] = i;
+                                            StackMarkers[i] = tv->stackmark;
+                                            SAMETRACE_CHECK(TheTrace, TraceInd, i, TraceEnd)
+                                        }
+                                    }
+                                    if ((StackMarkers[ind4] != tv->stackmark) && (BigCell != ind4)) {
+                                        CStack[BigCellPos] = ind4;
+                                        StackMarkers[BigCell] = 0;
+                                        StackMarkers[ind4] = tv->stackmark;
+                                    }
+                                    
+                                    /* Permute elements of the cell C */
+                                    i = ind4;
+                                    do {
+                                        SplCnt[SplPos[NghCounts[lab[i]]]++] = lab[i];
+                                    }
+                                    while(++i < ind1);
+                                    
+                                    /* Reconstruct the cell C and update the inverse partition */
+                                    newcell = ind4;
+                                    i = ind4;
+                                    ind2 = newcell+cls[newcell]-1;
+                                    do {
+                                        lab[i] = SplCnt[i];
+                                        InvLab[lab[i]] = i;
+                                        Part->inv[i] = newcell;
+                                        if (i == ind2) {
+                                            newcell = i+1;
+                                            if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                                        }
+                                    }
+                                    while (++i < ind1);
+                                    
+                                    for (i = ind4, k = 0; k < SplCntInd; i+=cls[i], k++) {
+                                        if (cls[i] == 1) {
+                                            Cand->singcode = MASHCOMM(Cand->singcode, Cand->lab[i]);
+                                        }
+                                    }
+                                    
+                                }
+                            }
+                            ind4 = ind1;
+                        }
+                        
+                        /* DENSE-DENSE CASE */
+                        if (SplInd) {
+                            SAMETRACE_CHECK(TheTraceSplNum, TraceCCInd, SplInd+3*n, &Traceccend)
+                        }
+                        else {
+                            if (TraceCell) {
+                                return 0;
+                            }
+                        }
+                        
+                    }
+                }
+            }
+        }
+        while (weightend < iend1int);
+    }  /* end while (CStackInd > 0) */
+    
+    for (i=SpineTL->trcstart; i < TraceInd; i++) {
+        ind0 = TheTrace[i];
+        longcode = MASHNONCOMM(longcode, Part->inv[ind0]);
+        labi = lab[ind0];
+        iend1int = TheGraph[labi].d;
+        nghb = TheGraph[labi].e;
+        for (j1int = 0; j1int < iend1int; ++j1int) {
+            k = nghb[j1int];
+            value = Part->inv[InvLab[k]];
+            longcode = MASHCOMM(longcode, value);
+        }
+    }
+    
+    tv->augmented_cells = Part->cells - tv->augmented_cells;
+    
+    Part->code = Cand->code = CLEANUP(longcode);
+    if ((Cand->code != SpineTL->part->code) || (TraceInd != *TraceEnd)) return FALSE;
+    return TRUE;
+}
+
+void refine_tr(sparsegraph *sg, int *lab, int *ptn, int *numcells, int *code, TracesOptions *options_arg) {
+    
+    const int n = sg->nv;
+    const int m = SETWORDSNEEDED(n);
+    
+    int i, j, ord;
+    Partition *CurrPart;
+    Candidate *CurrCand;
+    struct TracesVars tvar, *tv;
+    struct TracesInfo tinf, *ti;
+    
+    if (n > (NAUTY_INFINITY-2))
+    {
+        fprintf(ERRFILE, "Traces: need n <= %d, but n=%d\n\n",
+                NAUTY_INFINITY-2, n);
+        return;
+    }
+    
+    Allocate_refine_Structures(n);
+    
+    tv = &tvar;
+    ti = &tinf;
+    
+    tv->options = options_arg;
+    tv->mark = tv->stackmark = NAUTY_INFINITY-1;
+    tv->maxdeg = 0;
+    tv->mindeg = n;
+    
+    outfile = (tv->options->outfile == NULL ? stdout : tv->options->outfile);
+    
+    for (i = 0; i < n; i++) {
+        IDENTITY_PERM[i] = i;
+    }
+    
+    copy_sg_structure(&redgraph, sg);
+    
+    tv->graph = &redgraph;
+    if (tv->options->weighted) {
+        tv->graph->w = malloc(tv->graph->wlen*sizeof(int));
+        if (tv->graph->w == NULL) {
+            fprintf(ERRFILE, "\nError, memory not allocated.\n");
+            exit(1);
+        }
+        memcpy(tv->graph->w, sg->w, tv->graph->wlen*sizeof(int));
+    }
+    memcpy(tv->graph->e, sg->e, tv->graph->elen*sizeof(int));
+    
+    for (i=0; i<n; i++) {
+        TheGraph[i].d = sg->d[i];
+        if (TheGraph[i].d > tv->maxdeg) {
+            tv->maxdeg = TheGraph[i].d;
+        }
+        if (TheGraph[i].d < tv->mindeg) {
+            tv->mindeg = TheGraph[i].d;
+        }
+        TheGraph[i].e = tv->graph->e + sg->v[i];
+        if (sg->w)
+            TheGraph[i].w = tv->graph->w + sg->v[i];
+        else
+            TheGraph[i].w = NULL;
+        TheGraph[i].one = FALSE;
+    }
+    
+    ord = 0;
+    
+    /*----------- WEIGHTS --------------*/
+    if (tv->options->weighted) {
+        WeightCodes(n);
+        ord = trie_classify(n,tv);
+    }
+    /*----------------------------------*/
+    
+    if ((tv->maxdeg == tv->mindeg) && (ord == 0)) ti->regular = TRUE; else ti->regular = FALSE;
+    
+    /* The graph is sparse? */
+    if (sg->nde < n || sg->nde / n < n / (sg->nde / n)) {
+        ti->thegraphisparse = TRUE;
+    }
+    else {
+        ti->thegraphisparse = FALSE;
+    }
+    
+    /* Initialize candidate, partition, cells, orbits */
+    CurrCand = NewCandidate(n, &GarbList, TRUE);
+    CurrPart = NewPartition(n);
+    memset(CurrPart->inv, 0, n*sizeof(int));
+    
+    CurrCand->singcode = 0;
+    
+    if (ti->regular) {
+        memcpy(CurrCand->lab, lab, n*sizeof(int));
+        CurrPart->cells = 0;
+        j = 0;
+        for (i = 0; i < n; i++) {
+            if (j) CurrPart->inv[i] = j;
+            CurrCand->invlab[CurrCand->lab[i]] = i;
+            if (!ptn[i]) {
+                CurrPart->cls[j] = i-j+1;
+                if (CurrPart->cls[j] == 1) {
+                    CurrCand->singcode = MASHCOMM(CurrCand->singcode, CurrCand->lab[j]);
+                }
+                TheTrace[CurrPart->cells++] = j;
+                j = i+1;
+            }
+        }
+    } else {
+        if (tv->options->weighted) {
+            CurrPart->cells = traces_vertexclass_refine (n, lab, ptn, CurrCand, CurrPart, WeightsSeq);
+        }
+        else {
+            CurrPart->cells = traces_vertexclass_refine (n, lab, ptn, CurrCand, CurrPart, sg->d);
+        }
+    }
+    
+    /* First refinement */
+    refine_tr_refine(CurrCand, n, CurrPart, tv, ti);
+    
+    for (i = CurrPart->cls[0]; i < n; i+=CurrPart->cls[i]) {
+        ptn[i-1] = 0;
+    }
+    ptn[n-1] = 0;
+    
+    memcpy(lab, CurrCand->lab, n*sizeof(int));
+    *code = CurrCand->code;
+    *numcells = CurrPart->cells;
+    
+    FREECAND(CurrCand)
+    FREEPART(CurrPart)
+    
+    if (tv->graph != sg) {
+        SG_FREE(redgraph);
+    }
+    
+#if !MAXN
+    DYNFREE(CStack, CStack_sz);
+    DYNFREE(IDENTITY_PERM, IDENTITY_PERM_sz);
+    DYNFREE(Markers, Markers_sz);
+    DYNFREE(MarkHitVtx, MarkHitVtx_sz);
+    DYNFREE(TreeMarkers, TreeMarkers_sz);
+    DYNFREE(NghCounts, NghCounts_sz);
+    DYNFREE(Singletons, Singletons_sz);
+    DYNFREE(SplPos, SplPos_sz);
+    DYNFREE(SplCls, SplCls_sz);
+    DYNFREE(SplCnt, SplCnt_sz);
+    DYNFREE(StackMarkers, StackMarkers_sz);
+    DYNFREE(TheTrace, TheTrace_sz);
+    DYNFREE(TheTraceSteps, TheTraceSteps_sz);
+    DYNFREE(TheTraceCC, TheTraceCC_sz);
+    DYNFREE(TheTraceSplNum, TheTraceSplNum_sz);
+    DYNFREE(WeightsSeq, WeightsSeq_sz);
+    DYNFREE(WorkArray1, WorkArray1_sz);
+    DYNFREE(WorkArray2, WorkArray2_sz);
+    DYNFREE(WorkArray3, WorkArray3_sz);
+    DYNFREE(WorkArray4, WorkArray4_sz);
+    DYNFREE(WorkArray5, WorkArray5_sz);
+    DYNFREE(TreeStack, TreeStack_sz);
+    DYNFREE(Spine, Spine_sz);
+    DYNFREE(TrieArray, TrieArray_sz);
+    DYNFREE(TheGraph, TheGraph_sz);
+#endif
+}
+
+int refine_tr_refine(Candidate *Cand,
+                     int n,
+                     Partition *Part,
+                     struct TracesVars* tv,
+                     struct TracesInfo *ti) {
+    
+    int i, j, k, jk, sc, ind0, ind1, ind2, ind3, ind4, labi;
+    int value, iend, newcell;
+    int HitClsInd, SplInd, SplCntInd, CStackInd, TraceInd, TraceCCInd, TraceStepsInd, SingInd;
+    int j1int, iend1int;
+    unsigned int longcode;
+    int newtrace = FALSE;
+    int Sparse = TRUE;
+    int *lab, *cls, *InvLab, *TracePos, *SplitCell, *LabCell, TraceEnd, Traceccend, Tracestpend;
+    int BigCell, BigCellPos, BigCellSize;
+    boolean TraceCell = FALSE;
+    int *nghb;
+    const int variation = 0;
+    int currentweight, weightstart, weightend, currentcell, currentsize;
+    
+    HitClsInd = 0;
+    if (tv->stackmark > (NAUTY_INFINITY-2)) {
+        memset(StackMarkers, 0, n*sizeof(int));
+        tv->stackmark = 0;
+    }
+    tv->stackmark++;
+    
+    lab = Cand->lab;
+    InvLab = Cand->invlab;
+    cls = Part->cls;
+    
+    UPDATEMIN(Part->active, n-1);
+    memcpy(CStack+1, TheTrace, (Part->cells)*sizeof(int));
+    CStackInd = Part->cells;
+    
+    for (i = 1; i <= CStackInd; i++) {
+        StackMarkers[CStack[i]] = tv->stackmark;
+    }
+    
+    longcode = Part->cells;
+    newtrace = TRUE;
+    while (CStackInd > 0) {
+        
+        weightend = 0;
+        
+        if (tv->mark > (NAUTY_INFINITY-2)) {
+            memset(Markers, 0, n*sizeof(int));
+            memset(MarkHitVtx, 0, n*sizeof(int));
+            tv->mark = 0;
+        }
+        tv->mark++;
+        
+        if (Part->cells == n) break;
+        
+        k = Select_from_CStack(cls, CStackInd);
+        
+        currentcell = CStack[k];
+        currentsize = currentcell+cls[currentcell];
+        CStack[k] = CStack[CStackInd--];
+        StackMarkers[currentcell] = 0;
+        
+        labi = lab[currentcell];
+        iend1int = TheGraph[labi].d;
+        nghb =  TheGraph[labi].e;
+        
+        do {
+            
+            ind0 = currentcell;
+            ind2 = currentsize;
+            weightstart = weightend;
+            
+            if (tv->options->weighted) {
+                currentweight = (TheGraph[labi].w)[weightstart];
+                while ((iend1int > weightend) && ((TheGraph[labi].w)[weightend] == currentweight)) {
+                    weightend++;
+                }
+            } else {
+                weightend = TheGraph[labi].d;
+            }
+            
+            /* Analysis of occurrences of neighbors of the current cell */
+            /* The list of cells with neighbors in the current cell is  built */
+            if (cls[ind0] == 1) {			/* SINGLETON CURRENT CELL CASE */
+                
+                /* NEIGHCOUNT_SING_MULT */
+                HitClsInd = 0;
+                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                    k = nghb[j1int];
+                    value = Part->inv[InvLab[k]];
+                    if (cls[value] > 1) {
+                        if (Markers[value] != tv->mark) {
+                            HitCls[HitClsInd++] = value;
+                            Markers[value] = tv->mark;
+                            ElmHitCll[value] = value;
+                        }
+                        HitVtx[ElmHitCll[value]++] = k;
+                    } else {
+                        switch (variation) {
+                            case 1:
+                                longcode = MASHCOMM(longcode, value);
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                }
+                /* end NEIGHCOUNT_SING_MULT */
+                
+                tv->mark++;
+                FIND_SPLIT_CELLS;
+                
+                /* SINGLETON CC CASE */
+                if (SplInd) {
+                    
+                    /* Sorting the cells to be split */
+                    sort_Split_Array(SplCls, SplInd);
+                    
+                    for (j = 0; j < SplInd; j++) {
+                        ind1 = SplCls[j];
+                        i = ind1+cls[ind1]-ElmHitCll[ind1];
+                    }
+                    
+                    /* REARRANGE THE CELLS */
+                    for (j = 0; j < SplInd; j++) {
+                        /* REARRANGE_CELLS */
+                        ind1 = SplCls[j];
+                        cls[ind1] = cls[ind1]-ElmHitCll[ind1];
+                        newcell = ind1+cls[ind1];
+                        cls[newcell] = ElmHitCll[ind1];
+                        Part->cells++;
+                        if (StackMarkers[ind1] != tv->stackmark) {
+                            if (cls[newcell] < cls[ind1]) {
+                                CStack[++CStackInd] = newcell;
+                                StackMarkers[newcell] = tv->stackmark;
+                            }
+                            else {
+                                CStack[++CStackInd] = ind1;
+                                StackMarkers[ind1] = tv->stackmark;
+                            }
+                        }
+                        else {
+                            CStack[++CStackInd] = newcell;
+                            StackMarkers[newcell] = tv->stackmark;
+                        }
+                        SplitCell = HitVtx+ind1;
+                        ind3 = cls[newcell];
+                        LabCell = lab+newcell;
+                        for (jk = 0; jk < ind3; jk++) {
+                            k = SplitCell[jk];
+                            i = LabCell[jk];
+                            Part->inv[newcell+jk] = newcell;
+                            lab[InvLab[k]] = i;
+                            InvLab[i] = InvLab[k];
+                            LabCell[jk] = k;
+                            InvLab[k] = newcell+jk;
+                        }
+                        /* END REARRANGE_CELLS */
+                        
+                    }
+                }
+                else {
+                }
+            }
+            else {
+                if (ti->thegraphisparse) {
+                    
+                    /* NEIGHCOUNT_SPARSE_MULT */
+                    if (cls[ind0] != n) {
+                        HitClsInd = 0;
+                        for (i = ind0; i < ind2; i++) {
+                            labi = lab[i];
+                            nghb = TheGraph[labi].e;
+                            for (j = weightstart; j < weightend; j++) {
+                                k = nghb[j];
+                                if (MarkHitVtx[k] == tv->mark) {
+                                    NghCounts[k]++;
+                                }
+                                else {
+                                    value = Part->inv[InvLab[k]];
+                                    if (cls[value] > 1) {
+                                        MarkHitVtx[k] = tv->mark;
+                                        NghCounts[k] = 1;
+                                        if (Markers[value] != tv->mark) {
+                                            HitCls[HitClsInd++] = value;
+                                            Markers[value] = tv->mark;
+                                            HitVtx[value] = k;
+                                            ElmHitCll[value] = 1;
+                                        }
+                                        else {
+                                            HitVtx[value+ElmHitCll[value]++] = k;
+                                        }
+                                    }
+                                    else {
+                                        switch (variation) {
+                                            case 1:
+                                                longcode = MASHCOMM(longcode, value);
+                                                break;
+                                            default:
+                                                break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    /* End NEIGHCOUNT_SPARSE_MULT */
+                    
+                    tv->mark++;
+                    
+                    SplInd = 0;
+                    SplCls[0] = n;
+                    for (j = 0; j < HitClsInd; j++) {
+                        ind1 = HitCls[j];
+                        if ((ElmHitCll[ind1] > 0) && (ElmHitCll[ind1] < cls[ind1])) {
+                            SplCls[SplInd++] = ind1;
+                        }
+                        else {
+                            ind2 = ind1+cls[ind1];
+                            value = NghCounts[lab[ind1++]];
+                            for (i = ind1; i < ind2; i++)
+                            {
+                                if (NghCounts[lab[i]] != value)
+                                {
+                                    SplCls[SplInd++] = HitCls[j];
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    
+                    /* SPARSE CASE */
+                    if (SplInd) {
+                        
+                        /* Sorting the cells to be split */
+                        sort_Split_Array(SplCls, SplInd);
+                        
+                        for (sc = 0; sc < SplInd; sc++) {	/* For each cell C to be split */
+                            ind0 = SplCls[sc];
+                            ind1 = ind0 + cls[ind0];
+                            SplCntInd = 0;
+                            if (ElmHitCll[ind0] < cls[ind0]) {
+                                SplCnt[SplCntInd++] = 0;
+                                SplPos[0] = cls[ind0] - ElmHitCll[ind0];
+                            }
+                            
+                            /* According to the numbers of neighbors of C into the current cell */
+                            /* compute how many vertices in C will be placed into the same new cell */
+                            iend = ind0 + ElmHitCll[ind0];
+                            for (i = ind0; i < iend; i++) {
+                                value = NghCounts[HitVtx[i]];
+                                if (Markers[value] != tv->mark) {
+                                    Markers[value] = tv->mark;
+                                    SplCnt[SplCntInd++] = value;
+                                    SplPos[value] = 1;
+                                }
+                                else {
+                                    SplPos[value]++;
+                                }
+                            }
+                            tv->mark++;
+                            
+                            sort_Split_Array(SplCnt,SplCntInd);
+                            Part->cells += SplCntInd-1;
+                            
+                            /* Split the cell C and update the information for sizes of new cells */
+                            /* Put the new cells into the stack */
+                            i = ind0;
+                            if (StackMarkers[i] != tv->stackmark) {
+                                BigCellSize = 0;
+                            }
+                            for (k = 0; k < SplCntInd; k++) {
+                                value = SplPos[SplCnt[k]];
+                                cls[i] = value;
+                                if ((StackMarkers[ind0] != tv->stackmark) && (value > BigCellSize)) {
+                                    BigCell = i;
+                                    BigCellPos = CStackInd;
+                                    BigCellSize = cls[i];
+                                }
+                                SplPos[SplCnt[k]] = i;
+                                i += value;
+                                if (i < ind1) {
+                                    CStack[++CStackInd] = i;
+                                    StackMarkers[i] = tv->stackmark;
+                                }
+                            }
+                            
+                            if ((StackMarkers[ind0] != tv->stackmark) && (BigCell != ind0)) {
+                                CStack[BigCellPos] = ind0;
+                                StackMarkers[BigCell] = 0;
+                                StackMarkers[ind0] = tv->stackmark;
+                            }
+                            /* Permute elements of the cell C */
+                            iend = ind0 + ElmHitCll[ind0];
+                            for (i = ind0; i < iend; i++) {
+                                value = HitVtx[i];
+                                j = SplPos[NghCounts[value]]++; /* where HitVtx[i] goes */
+                                k = InvLab[value];				/* where HitVtx[i] is in lab */
+                                lab[k] = lab[j];
+                                lab[j] = value;
+                                InvLab[value] = j;
+                                InvLab[lab[k]] = k;
+                                NghCounts[value] = 0;
+                            }
+                            
+                            /* Reconstruct the cell C and update the inverse partition */
+                            newcell = ind1 - ElmHitCll[ind0];
+                            i = newcell;
+                            ind2 = newcell+cls[newcell]-1;
+                            do {
+                                Part->inv[i] = newcell;
+                                if (i == ind2) {
+                                    newcell = i+1;
+                                    if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                                }
+                            }
+                            while (++i < ind1);
+                        }
+                    }
+                }
+                else {
+                    if (TheGraph[lab[ind0]].d > n/cls[ind0]) {
+                        Sparse = FALSE;
+                    }
+                    else {
+                        Sparse = TRUE;
+                    }
+                    if (Sparse) {
+                        /* Counting occurrences of neighbors of the current cell */
+                        /* The list of cells with neighbors in the current cell is also built */
+                        if (cls[ind0] == n) {
+                            for (i = 0; i < n; i++) {
+                                NghCounts[i] = TheGraph[i].d;
+                            }
+                            HitCls[0] = 0;
+                            HitClsInd = 1;
+                        }
+                        else {
+                            memset(NghCounts, 0, n*sizeof(int));
+                            
+                            /* NEIGHCOUNT_DENSE_SPARSE_MULT */
+                            HitClsInd = 0;
+                            for (i = ind0; i < ind2; i++) {
+                                labi = lab[i];
+                                nghb =  TheGraph[labi].e;
+                                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                                    k = nghb[j1int];
+                                    (NghCounts[k])++;
+                                    value = Part->inv[InvLab[k]];
+                                    if (Markers[value] != tv->mark) {
+                                        if (cls[value] > 1) HitCls[HitClsInd++] = value;
+                                        Markers[value] = tv->mark;
+                                    }
+                                }
+                            }
+                            /* End NEIGHCOUNT_DENSE_SPARSE_MULT */
+                            
+                        }
+                        
+                        tv->mark++;
+                        
+                        
+                        SplInd = 0;
+                        for (j = 0; j < HitClsInd; j++) {
+                            ind1 = HitCls[j];
+                            ind2 = ind1+cls[ind1];
+                            value = NghCounts[lab[ind1++]];
+                            for (i = ind1; i < ind2; i++)
+                            {
+                                if (NghCounts[lab[i]] != value)
+                                {
+                                    SplCls[SplInd++] = HitCls[j];
+                                    break;
+                                }
+                            }
+                        }
+                        
+                        /* DENSE-SPARSE CASE */
+                        if (SplInd) {
+                            
+                            /* Sorting the cells to be split */
+                            sort_Split_Array(SplCls, SplInd);
+                            
+                            for (j = 0; j < SplInd; j++) {	/* For each cell C to be split */
+                                ind0 = SplCls[j];
+                                ind1 = ind0+cls[ind0];
+                                SplCntInd = 0;
+                                
+                                /* According to the numbers of neighbors of C into the current cell */
+                                /* compute how many vertices in C will be placed into the same new cell */
+                                for (i = ind0; i < ind1; i++) {
+                                    value = NghCounts[lab[i]];
+                                    if (Markers[value] != tv->mark) {
+                                        Markers[value] = tv->mark;
+                                        SplCnt[SplCntInd++] = value;
+                                        SplPos[value] = 1;
+                                    }
+                                    else {
+                                        SplPos[value]++;
+                                    }
+                                }
+                                tv->mark++;
+                                
+                                /* Sort the values deriving from the previous step */
+                                sort_Split_Array(SplCnt, SplCntInd);
+                                Part->cells += SplCntInd-1;
+                                
+                                /* Split the cell C and update the information for sizes of new cells */
+                                /* Put the new cells into the stack */
+                                i = ind0;
+                                if (StackMarkers[i] != tv->stackmark) {
+                                    BigCellSize = 0;
+                                }
+                                for (k = 0; k < SplCntInd; k++) {
+                                    value = SplPos[SplCnt[k]];
+                                    cls[i] = value;
+                                    
+                                    if ((StackMarkers[ind0] != tv->stackmark) && (value > BigCellSize)) {
+                                        BigCell = i;
+                                        BigCellPos = CStackInd;
+                                        BigCellSize = cls[i];
+                                    }
+                                    SplPos[SplCnt[k]] = i;
+                                    i += value;
+                                    if (i < ind1) {
+                                        CStack[++CStackInd] = i;
+                                        StackMarkers[i] = tv->stackmark;
+                                    }
+                                }
+                                
+                                if ((StackMarkers[ind0] != tv->stackmark) && (BigCell != ind0)) {
+                                    CStack[BigCellPos] = ind0;
+                                    StackMarkers[BigCell] = 0;
+                                    StackMarkers[ind0] = tv->stackmark;
+                                }
+                                
+                                /* Permute elements of the cell C */
+                                i = ind0;
+                                do {
+                                    SplCnt[SplPos[NghCounts[lab[i]]]++] = lab[i];
+                                }
+                                while(++i < ind1);
+                                
+                                /* Reconstruct the cell C and update the inverse partition */
+                                newcell = ind0;
+                                i = ind0;
+                                ind2 = newcell+cls[newcell]-1;
+                                do {
+                                    lab[i] = SplCnt[i];
+                                    InvLab[lab[i]] = i;
+                                    
+                                    Part->inv[i] = newcell;
+                                    if (i == ind2) {
+                                        newcell = i+1;
+                                        if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                                    }
+                                }
+                                while (++i < ind1);
+                            }
+                        }
+                    }
+                    else {
+                        if (cls[ind0] == n) {
+                            for (i = 0; i < n; i++) {
+                                NghCounts[i] = TheGraph[i].d;
+                            }
+                        }
+                        else {
+                            memset(NghCounts, 0, n*sizeof(int));
+                            
+                            /* NEIGHCOUNT_DENSE_DENSE_MULT */
+                            for (i = ind0; i < ind2; i++) {
+                                labi = lab[i];
+                                nghb = TheGraph[labi].e;
+                                for (j1int = weightstart; j1int < weightend; ++j1int) {
+                                    k = nghb[j1int];
+                                    (NghCounts[k])++;
+                                }
+                            }
+                            /* End NEIGHCOUNT_DENSE_DENSE_MULT */
+                            
+                        }
+                        SplInd = 0;
+                        ind4 = 0;
+                        while (ind4 < n) {	/* For each cell C with size(C) > 1 */
+                            ind1 = ind4+cls[ind4];
+                            if (cls[ind4] > 1) {
+                                
+                                
+                                /* Determine whether C must be split */
+                                SplCntInd = 0;
+                                value = NghCounts[lab[ind4]];
+                                for (i = ind4+1; i < ind1; i++) {
+                                    if (NghCounts[lab[i]] != value)
+                                    {
+                                        SplInd++;
+                                        Markers[value] = tv->mark;
+                                        SplCnt[SplCntInd++] = value;
+                                        SplPos[value] = i-ind4;
+                                        do {
+                                            value = NghCounts[lab[i++]];
+                                            if (Markers[value] != tv->mark) {
+                                                Markers[value] = tv->mark;
+                                                SplCnt[SplCntInd++] = value;
+                                                SplPos[value] = 1;
+                                            }
+                                            else {
+                                                SplPos[value]++;
+                                            }
+                                        }
+                                        while(i != ind1);
+                                        break;
+                                    }
+                                }
+                                tv->mark++;
+                                
+                                if (SplCntInd) {
+                                    
+                                    /* Sort the values deriving from the previous step */
+                                    sort_Split_Array(SplCnt, SplCntInd);
+                                    Part->cells += SplCntInd-1;
+                                    
+                                    /* Split the cell C and update the information for sizes of new cells */
+                                    /* Put the new cells into the stack */
+                                    i = ind4;
+                                    if (StackMarkers[i] != tv->stackmark) {
+                                        BigCellSize = 0;
+                                    }
+                                    for (k = 0; k < SplCntInd; k++) {
+                                        value = SplPos[SplCnt[k]];
+                                        cls[i] = value;
+                                        
+                                        if ((StackMarkers[ind4] != tv->stackmark) && (value > BigCellSize)) {
+                                            BigCell = i;
+                                            BigCellPos = CStackInd;
+                                            BigCellSize = cls[i];
+                                        }
+                                        SplPos[SplCnt[k]] = i;
+                                        i += value;
+                                        if (i < ind1) {
+                                            CStack[++CStackInd] = i;
+                                            StackMarkers[i] = tv->stackmark;
+                                        }
+                                    }
+                                    if ((StackMarkers[ind4] != tv->stackmark) && (BigCell != ind4)) {
+                                        CStack[BigCellPos] = ind4;
+                                        StackMarkers[BigCell] = 0;
+                                        StackMarkers[ind4] = tv->stackmark;
+                                    }
+                                    
+                                    /* Permute elements of the cell C */
+                                    i = ind4;
+                                    do {
+                                        SplCnt[SplPos[NghCounts[lab[i]]]++] = lab[i];
+                                    }
+                                    while(++i < ind1);
+                                    
+                                    /* Reconstruct the cell C and update the inverse partition */
+                                    newcell = ind4;
+                                    i = ind4;
+                                    ind2 = newcell+cls[newcell]-1;
+                                    do {
+                                        lab[i] = SplCnt[i];
+                                        InvLab[lab[i]] = i;
+                                        Part->inv[i] = newcell;
+                                        if (i == ind2) {
+                                            newcell = i+1;
+                                            if (newcell < n) ind2 = newcell+cls[newcell]-1;
+                                        }
+                                    }
+                                    while (++i < ind1);
+                                }
+                            }
+                            ind4 = ind1;
+                        }
+                        
+                        /* DENSE-DENSE CASE */
+                    }
+                }
+            }
+        }
+        while (weightend < iend1int);
+    }  /* end while (CStackInd > 0) */
+    
+    Cand->code = CLEANUP(longcode);
+    for (ind0=Part->cls[0]; ind0 < n; ind0+=Part->cls[ind0]) {
+        longcode = MASHNONCOMM(longcode, Part->inv[ind0]);
+        labi = lab[ind0];
+        iend1int = TheGraph[labi].d;
+        nghb = TheGraph[labi].e;
+        for (j1int = 0; j1int < iend1int; ++j1int) {
+            k = nghb[j1int];
+            value = Part->inv[InvLab[k]];
+            longcode = MASHCOMM(longcode, value);
+        }
+    }
+    Part->code = Cand->code = CLEANUP(longcode);
+    return TraceInd;
+}
+
+void Allocate_Traces_Structures(int n) {
+#if !MAXN
+    DYNALLOC1(int, AUTPERM, AUTPERM_sz, n, "Traces");
+    DYNALLOC1(int, BreakSteps, BreakSteps_sz, n, "Traces");
+    DYNALLOC1(int, CurrOrbSize, CurrOrbSize_sz, n, "Traces");
+    DYNALLOC1(int, CurrRefCells, CurrRefCells_sz, n, "Traces");
+    DYNALLOC1(boolean, Diff, Diff_sz, n, "Traces");
+    DYNALLOC1(int, CStack, CStack_sz, n, "Traces");
+    DYNALLOC1(boolean, Factorials, Factorials_sz, n, "Traces");
+    DYNALLOC1(int, fix, fix_sz, n, "Traces");
+    DYNALLOC1(int, IDENTITY_PERM, IDENTITY_PERM_sz, n, "Traces");
+    DYNALLOC1(int, Markers, Markers_sz, n, "Traces");
+    DYNALLOC1(int, TreeMarkers, TreeMarkers_sz, n, "Traces");
+    DYNALLOC1(int, AutMarkers, AutMarkers_sz, n, "Traces");
+    DYNALLOC1(int, MarkHitVtx, MarkHitVtx_sz, n, "Traces");
+    DYNALLOC1(int, MultRefCells, MultRefCells_sz, n, "Traces");
+    DYNALLOC1(int, NghCounts, NghCounts_sz, n, "Traces");
+    DYNALLOC1(int, OrbSize, OrbSize_sz, n, "Traces");
+    DYNALLOC1(int, OrbList, OrbList_sz, n, "Traces");
+    DYNALLOC1(pair, PrmPairs, PrmPairs_sz, n, "Traces");
+    DYNALLOC1(int, TempOrbList, TempOrbList_sz, n, "Traces");
+    DYNALLOC1(int, RefCells, RefCells_sz, n, "Traces");
+    DYNALLOC1(int, Singletons, Singletons_sz, n, "Traces");
+    DYNALLOC1(int, SplCls, SplCls_sz, n, "Traces");
+    DYNALLOC1(int, SplCnt, SplCnt_sz, n, "Traces");
+    DYNALLOC1(int, SplPos, SplPos_sz, n, "Traces");
+    DYNALLOC1(int, StackMarkers, StackMarkers_sz, n, "Traces");
+    DYNALLOC1(int, TheTrace, TheTrace_sz, n+10, "Traces");
+    DYNALLOC1(int, TheTraceCC, TheTraceCC_sz, n, "Traces");
+    DYNALLOC1(int, TheTraceSplNum, TheTraceSplNum_sz, n, "Traces");
+    DYNALLOC1(int, TheTraceSteps, TheTraceSteps_sz, n+10, "Traces");
+    DYNALLOC1(int, TEMPLAB, TEMPLAB_sz, n, "Traces");
+    DYNALLOC1(int, TEMPINVLAB, TEMPINVLAB_sz, n, "Traces");
+    DYNALLOC1(int, WeightsSeq, WeightsSeq_sz, n, "Traces");
+    DYNALLOC1(int, WorkArray, WorkArray_sz, n, "Traces");
+    DYNALLOC1(int, WorkArray0, WorkArray0_sz, n, "Traces");
+    DYNALLOC1(int, WorkArray1, WorkArray1_sz, n, "Traces");
+    DYNALLOC1(int, WorkArray2, WorkArray2_sz, n, "Traces");
+    DYNALLOC1(int, WorkArray3, WorkArray3_sz, n, "Traces");
+    DYNALLOC1(int, WorkArray4, WorkArray4_sz, n, "Traces");
+    DYNALLOC1(int, WorkArray5, WorkArray5_sz, n, "Traces");
+    DYNALLOC1(int, WorkArray6, WorkArray6_sz, n, "Traces");
+    DYNALLOC1(int, WorkArray7, WorkArray7_sz, n, "Traces");
+    DYNALLOC1(int, TreeStack, TreeStack_sz, n, "Traces");
+    DYNALLOC1(TracesSpine, Spine, Spine_sz, n, "Traces");
+    DYNALLOC1(trie*, TrieArray, TrieArray_sz, n, "Traces");
+    DYNALLOC1(grph_strct, TheGraph, TheGraph_sz, n, "Traces");
+    DYNALLOC1(ExpPathInfo, EPCodes, EPCodes_sz, n, "Traces");
+#endif
+    return;
+}
+
+void Allocate_refine_Structures(int n) {
+#if !MAXN
+    DYNALLOC1(int, CStack, CStack_sz, n, "refine_tr");
+    DYNALLOC1(int, IDENTITY_PERM, IDENTITY_PERM_sz, n, "refine_tr");
+    DYNALLOC1(int, Markers, Markers_sz, n, "refine_tr");
+    DYNALLOC1(int, MarkHitVtx, MarkHitVtx_sz, n, "refine_tr");
+    DYNALLOC1(int, TreeMarkers, TreeMarkers_sz, n, "refine_tr");
+    DYNALLOC1(int, NghCounts, NghCounts_sz, n, "refine_tr");
+    DYNALLOC1(int, Singletons, Singletons_sz, n, "refine_tr");
+    DYNALLOC1(int, SplPos, SplPos_sz, n, "refine_tr");
+    DYNALLOC1(int, SplCls, SplCls_sz, n, "refine_tr");
+    DYNALLOC1(int, SplCnt, SplCnt_sz, n, "refine_tr");
+    DYNALLOC1(int, StackMarkers, StackMarkers_sz, n, "refine_tr");
+    DYNALLOC1(int, TheTrace, TheTrace_sz, n+10, "refine_tr");
+    DYNALLOC1(int, TheTraceSteps, TheTraceSteps_sz, n+10, "refine_tr");
+    DYNALLOC1(int, TheTraceCC, TheTraceCC_sz, n, "refine_tr");
+    DYNALLOC1(int, TheTraceSplNum, TheTraceSplNum_sz, n, "refine_tr");
+    DYNALLOC1(int, WeightsSeq, WeightsSeq_sz, n, "refine_tr");
+    DYNALLOC1(int, WorkArray1, WorkArray1_sz, n, "refine_tr");
+    DYNALLOC1(int, WorkArray2, WorkArray2_sz, n, "refine_tr");
+    DYNALLOC1(int, WorkArray3, WorkArray3_sz, n, "refine_tr");
+    DYNALLOC1(int, WorkArray4, WorkArray4_sz, n, "refine_tr");
+    DYNALLOC1(int, WorkArray5, WorkArray5_sz, n, "refine_tr");
+    DYNALLOC1(int, TreeStack, TreeStack_sz, n, "refine_tr");
+    DYNALLOC1(TracesSpine, Spine, Spine_sz, n, "refine_tr");
+    DYNALLOC1(trie*, TrieArray, TrieArray_sz, n, "refine_tr");
+    DYNALLOC1(grph_strct, TheGraph, TheGraph_sz, n, "refine_tr");
+#endif
+    
+#define HitCls WorkArray2
+#define HitVtx WorkArray3
+#define ElmHitCll WorkArray5
+    return;
+}
+
+struct Candidate *NewCandidate(int n, Candidate **GarbList, int Mrk) {
+    struct Candidate *Cand;
+    
+    if (*GarbList) {
+        Cand = *GarbList;
+        *GarbList = (*GarbList)->next;
+    }
+    else {
+        Cand = malloc(sizeof(*Cand));
+        if (Cand == NULL) {
+            fprintf(ERRFILE, "\nError, memory not allocated.\n");
+            exit(1);
+        }
+        Cand->lab = malloc(n*sizeof(*Cand->lab));
+        if (Cand->lab == NULL) {
+            fprintf(ERRFILE, "\nError, memory not allocated.\n");
+            exit(1);
+        }
+        Cand->invlab = malloc(n*sizeof(*Cand->invlab));
+        if (Cand->invlab == NULL) {
+            fprintf(ERRFILE, "\nError, memory not allocated.\n");
+            exit(1);
+        }
+    }
+    Cand->do_it = Mrk;
+    Cand->indnum = 0;
+    Cand->code = 0;
+    Cand->next = NULL;
+    Cand->stnode = NULL;
+    Cand->sortedlab = FALSE;
+    return Cand;
+}
+
+int Check_degree_one(sparsegraph *sg, Candidate *Cand, Partition *Part, int n) {
+    
+    int i;
+    
+    for (i=0; i<n; i += Part->cls[i]) {
+        if (sg->d[Cand->lab[i]] == 1) {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+int CheckForAutomorphisms(Candidate *CurrCand, Candidate *NextCand,
+                          struct TracesVars* tv, struct TracesInfo* ti,
+                          int m, int n, Partition* Part) {
+    Candidate *CheckAutList;
+    int i, j, k, tgt_level, numtemporbits;
+    int CheckLevel, CheckLevelEnd;
+    int temp, tmp, tmp1, arg, arg1, val, val1;
+    searchtrie *TrieCandFrom, *TrieCheckFrom;
+    
+    CheckLevel = 0;
+    CheckLevelEnd = 0;
+    temp = 0;
+    tv->gotonode = NULL;
+    tv->conta6++;
+    
+    switch (tv->compstage) {
+        case 0:
+            if (tv->strategy) {
+                CheckLevel = CheckLevelEnd = tv->maxtreelevel;
+            }
+            else {
+                if ((Spine[tv->tolevel].part)->cells == tv->finalnumcells) {
+                    CheckLevel = CheckLevelEnd = tv->maxtreelevel;
+                }
+                else {
+                    CheckLevel = 1;
+                    if ((Spine[tv->maxtreelevel].part)->cells == tv->finalnumcells) {
+                        CheckLevelEnd = tv->maxtreelevel - 1;
+                    }
+                    else {
+                        CheckLevelEnd = tv->maxtreelevel;
+                    }
+                }
+            }
+            break;
+        case 1:
+            CheckLevel = CheckLevelEnd = tv->tolevel;
+            break;
+        case 2:
+            if (m || (tv->tolevel == tv->maxtreelevel+1)) {
+                CheckLevel = CheckLevelEnd = tv->maxtreelevel+1;
+            }
+            else {
+                CheckLevel = 1;
+                if ((Spine[tv->maxtreelevel].part)->cells == tv->finalnumcells) {
+                    CheckLevelEnd = tv->maxtreelevel - 1;
+                }
+                else {
+                    CheckLevelEnd = tv->maxtreelevel;
+                }
+            }
+            break;
+        default:
+            break;
+    }
+    
+    while (CheckLevel <= CheckLevelEnd) {
+        CheckAutList = Spine[CheckLevel].liststart;
+        while (CheckAutList) {
+            if (CheckAutList->do_it && lookup(CheckAutList->stnode) && (CheckAutList != NextCand) && (CheckAutList != CurrCand)) {
+                if (CheckAutList->code == NextCand->code) {
+                    SETMARK(Markers, tv->mark)
+                    if (Part->cells == n) {
+                        if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                        for (i = 0; i < n; i++) {
+                            arg = NextCand->lab[i];
+                            val = CheckAutList->lab[i];
+                            SETPAIRSAUT(arg, val)
+                        }
+                    }
+                    else {
+                        if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                        SETMARK(CellMarkers1, tv->markcell1)
+                        SETMARK(CellMarkers2, tv->markcell2)
+                        for (i=0; i<n; i+=Part->cls[i]) {
+                            if (Part->cls[i] == 1) {
+                                arg = NextCand->lab[i];
+                                val = CheckAutList->lab[i];
+                                SETPAIRSAUT(arg, val)
+                                if (tv->preprocessed && Diff[arg])
+                                    MakeTree(arg, val, tv->input_graph, n, tv, TRUE);
+                            }
+                            else {
+                                k = i;
+                                for (j=i; j<i+Part->cls[i]; j++) {
+                                    arg = arg1 = NextCand->lab[j];
+                                    if (CellMarkers1[arg] != tv->markcell1) {
+                                        CellMarkers1[arg] = tv->markcell1;
+                                        while ((CellMarkers2[CheckAutList->lab[k]] == tv->markcell2) && (k < i+Part->cls[i])) {
+                                            k++;
+                                        }
+                                        if (k < i+Part->cls[i]) {
+                                            val = val1 = CheckAutList->lab[k];
+                                            CellMarkers2[val] = tv->markcell2;
+                                            SETPAIRSAUT(arg, val)
+                                            if (tv->preprocessed && Diff[arg])
+                                                MakeTree(arg, val, tv->input_graph, n, tv, TRUE);
+                                            tmp = FirstNeighbour(arg, NextCand, Part, CellMarkers1, tv->markcell1, &arg, n);
+                                            if (tmp) {
+                                                CellMarkers1[arg] = tv->markcell1;
+                                                tmp = FirstNeighbour(val, CheckAutList, Part, CellMarkers2, tv->markcell2, &val, n);
+                                                CellMarkers2[val] = tv->markcell2;
+                                                SETPAIRSAUT(arg, val)
+                                                if (tv->preprocessed && Diff[arg])
+                                                    MakeTree(arg, val, tv->input_graph, n, tv, TRUE);
+                                                while (tmp) {
+                                                    tmp = NextNeighbour(arg, NextCand, Part, CellMarkers1, tv->markcell1, &arg, n);
+                                                    if (tmp) {
+                                                        CellMarkers1[arg] = tv->markcell1;
+                                                        tmp = NextNeighbour(val, CheckAutList, Part, CellMarkers2, tv->markcell2, &val, n);
+                                                        if (tmp) {
+                                                            CellMarkers2[val] = tv->markcell2;
+                                                            SETPAIRSAUT(arg, val)
+                                                            if (tv->preprocessed && Diff[arg])
+                                                                MakeTree(arg, val, tv->input_graph, n, tv, TRUE);
+                                                        }
+                                                    }
+                                                }
+                                                arg = arg1;
+                                                val = val1;
+                                                do {
+                                                    tmp = NextNeighbour(arg, NextCand, Part, CellMarkers1, tv->markcell1, &arg, n);
+                                                    if (tmp) {
+                                                        CellMarkers1[arg] = tv->markcell1;
+                                                        tmp = NextNeighbour(val, CheckAutList, Part, CellMarkers2, tv->markcell2, &val, n);
+                                                        if (tmp) {
+                                                            CellMarkers2[val] = tv->markcell2;
+                                                            SETPAIRSAUT(arg, val)
+                                                            if (tv->preprocessed && Diff[arg])
+                                                                MakeTree(arg, val, tv->input_graph, n, tv, TRUE);
+                                                        }
+                                                    }
+                                                } while (tmp);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    
+                    if (isautom_sg_pair((graph*)tv->input_graph, AUTPERM, tv->options->digraph, m, n, tv)) {
+                        if (!findperm(gensB, AUTPERM, n)) {
+                            if (tv->options->verbosity >= 2) tv->schreier3 -= CPUTIME;
+                            addgenerator(&gpB, &gensB, AUTPERM, n);
+                            if (tv->options->verbosity >= 2) tv->schreier3 += CPUTIME;
+                            if (tv->options->verbosity >= 2) {
+                                fprintf(outfile, "[A(%d,%d)] ", CheckLevel, CheckAutList->name);
+                            }
+                            tv->lev_of_lastauto = tv->tolevel;
+                            tv->stats->numgenerators++;
+                            orbjoin_sp_perm(tv->orbits, AUTPERM, OrbList, n, &tv->stats->numorbits);
+                            ti->thegrouphaschanged = TRUE;
+                            ti->identitygroup = FALSE;
+                            if (tv->options->verbosity >= 2 && tv->options->writeautoms) {
+                                PRINT_RETURN
+                            }
+                            if (tv->options->writeautoms) {
+                                fprintf(outfile, "Gen(A) #%d: ", tv->stats->numgenerators);
+                                writeperm(outfile, AUTPERM, tv->options->cartesian, tv->options->linelength, n);
+                            }
+                            if (tv->options->userautomproc) {
+                                (*tv->options->userautomproc)(tv->stats->numgenerators, AUTPERM, n);
+                            }
+                        }
+                        else {
+                            if (tv->options->verbosity >= 2) {
+                                fprintf(outfile, "[A*(%d,%d)] ", CheckLevel, CheckAutList->name);
+                            }
+                        }
+                        TrieCandFrom = NULL;
+                        TrieCheckFrom = CheckAutList->stnode;
+                        if (CurrCand->stnode->level <= 1) {
+                            tgt_level = CurrCand->stnode->level + 1;
+                            while (TrieCheckFrom->level > tgt_level) {
+                                TrieCheckFrom = TrieCheckFrom->father;
+                            }
+                        }
+                        else {
+                            if (tv->tolevel <= TrieCheckFrom->level) {
+                                tgt_level = tv->tolevel;
+                                while (TrieCheckFrom->level != tgt_level) {
+                                    TrieCheckFrom = TrieCheckFrom->father;
+                                }
+                            }
+                            else {
+                                TrieCandFrom = CurrCand->stnode;
+                                tgt_level = TrieCheckFrom->level;
+                                while (TrieCandFrom->level != tgt_level) {
+                                    TrieCandFrom = TrieCandFrom->father;
+                                }
+                            }
+                        }
+                        if (TrieCandFrom) {
+                            while (TrieCandFrom->father != TrieCheckFrom->father) {
+                                TrieCandFrom = TrieCandFrom->father;
+                                TrieCheckFrom = TrieCheckFrom->father;
+                            }
+                        }
+                        else {
+                            if ((TrieCheckFrom->level > 1) && (TrieCheckFrom->father != CurrCand->stnode)) {
+                                TrieCandFrom = CurrCand->stnode;
+                                TrieCheckFrom = TrieCheckFrom->father;
+                                while (TrieCandFrom->father != TrieCheckFrom->father) {
+                                    TrieCandFrom = TrieCandFrom->father;
+                                    TrieCheckFrom = TrieCheckFrom->father;
+                                }
+                            }
+                        }
+                        
+                        while (TrieCheckFrom->goes_to) {
+                            TrieCheckFrom = TrieCheckFrom->goes_to;
+                        }
+                        
+                        for (temp=1; temp<=tv->tolevel; temp++) {
+                            if (CheckAutList->lab[Spine[temp].tgtpos] != NextCand->lab[Spine[temp].tgtpos]) {
+                                break;
+                            }
+                        }
+                        
+                        if (temp == tv->tolevel) {
+                            if (TempOrbits) {
+                                if (tv->compstage == 0) {
+                                    for (j=0; j<tv->permInd; j++) {
+                                        orbjoin_sp_pair(TempOrbits, TempOrbList, n,
+                                                        PrmPairs[j].arg, PrmPairs[j].val, &numtemporbits);
+                                    }
+                                }
+                                else {
+                                    orbjoin(TempOrbits, AUTPERM, n);
+                                }
+                            } else {
+                                orbjoin(tv->currorbit, AUTPERM, n);
+                            }
+                        }
+                        
+                        switch (tv->compstage) {
+                            case 0:
+                                if (tv->strategy && (tv->steps == 1)) {
+                                    RemoveFromLevel(temp, tv->maxtreelevel-1, tv->strategy, FALSE);
+                                    if (TrieCandFrom) {
+                                        TrieCheckFrom->index += TrieCandFrom->index;
+                                        TrieCandFrom->goes_to = TrieCheckFrom;
+                                        PRINT_INDEX(TrieCheckFrom,4,1)
+                                    }
+                                    else {
+                                        TrieCheckFrom->index++;
+                                        PRINT_INDEX(TrieCheckFrom,4,2)
+                                    }
+                                    NextCand->do_it = FALSE;
+                                }
+                                else {
+                                    if (CheckAutList->lab[Spine[temp].tgtpos] >= NextCand->lab[Spine[temp].tgtpos]) {
+                                        CheckAutList->do_it = FALSE;
+                                        if (TrieCandFrom) {
+                                            TrieCandFrom->index += TrieCheckFrom->index;
+                                            tv->newindex = 0;
+                                            TrieCheckFrom->goes_to = TrieCandFrom;
+                                            PRINT_INDEX(TrieCandFrom,4,3)
+                                        }
+                                        else {
+                                            if (CurrCand->stnode->level > 1) {
+                                                tv->newgotonode = TrieCheckFrom;
+                                                tv->newindex = TrieCheckFrom->index;
+                                            }
+                                            else {
+                                                tv->newgotonode = NULL;
+                                                tv->newindex = 0;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        if (TrieCandFrom) {
+                                            TrieCheckFrom->index += TrieCandFrom->index;
+                                            TrieCandFrom->goes_to = TrieCheckFrom;
+                                            PRINT_INDEX(TrieCheckFrom,4,4)
+                                        }
+                                        else {
+                                            TrieCheckFrom->index++;
+                                            PRINT_INDEX(TrieCheckFrom,4,5)
+                                        }
+                                        NextCand->do_it = FALSE;
+                                    }
+                                }
+                                break;
+                            case 1:
+                                TrieCheckFrom->index ++;
+                                PRINT_INDEX(TrieCheckFrom,4,6)
+                                tv->gotonode = TrieCheckFrom;
+                                break;
+                            case 2:
+                                if (TrieCandFrom) {
+                                    TrieCheckFrom->index += TrieCandFrom->index;
+                                    TrieCandFrom->goes_to = TrieCheckFrom;
+                                    PRINT_INDEX(TrieCheckFrom,4,7)
+                                }
+                                else {
+                                    TrieCheckFrom->index++;
+                                    PRINT_INDEX(TrieCheckFrom,4,8)
+                                }
+                                if (temp == tv->maxtreelevel) {
+                                    tmp1 = TempOrbits[NextCand->lab[Spine[temp].tgtpos]];
+                                    for (i=1; i<AutomCount[0]; i++) if (AutomCount[i] == tmp1) break;
+                                    if (i == AutomCount[0]) AutomCount[AutomCount[0]++] = TempOrbits[NextCand->lab[Spine[temp].tgtpos]];
+                                }
+                                break;
+                            default:
+                                break;
+                        }
+                        return temp;
+                    }
+                }
+            }
+            CheckAutList = CheckAutList->next;
+        }
+        CheckLevel++;
+    }
+    return FALSE;
+}
+
+
+int CheckForSingAutomorphisms(Candidate *CurrCand, Partition *NextPart, Candidate *NextCand,
+                              struct TracesVars* tv, struct TracesInfo* ti,
+                              int m, int n) {
+    int i, j, temp, tmp, tmp1, result, tgt_level, numtemporbits;
+    TracesSpine *SpineTL;
+    Candidate *CheckAutList;
+    searchtrie *TrieCandFrom, *TrieCheckFrom;
+    
+    SpineTL = Spine+tv->tolevel;
+    CheckAutList = SpineTL->liststart;
+    tv->gotonode = NULL;
+    
+    result = 0;
+    while (CheckAutList != NULL) {
+        if (CheckAutList->do_it && (CheckAutList->stnode->father == CurrCand->stnode)) {
+            if (CheckAutList->firstsingcode == NextCand->firstsingcode) {
+                if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                if ((tv->tolevel == 1) && (Spine[0].part->cells == 1)) tmp = 2; else tmp = tv->tolevel;
+                if (TreeFyTwo(tmp, CheckAutList, NextCand, NextPart, n, tv, ti)) {
+                    if (isautom_sg((graph*)tv->input_graph, AUTPERM, tv->options->digraph, m, n)) {
+                        if (!findperm(gensB, AUTPERM, n)) {
+                            if (tv->options->verbosity >= 2) tv->schreier3 -= CPUTIME;
+                            addgenerator(&gpB, &gensB, AUTPERM, n);
+                            if (tv->options->verbosity >= 2) tv->schreier3 += CPUTIME;
+                            result = CheckAutList->name;
+                            if (TempOrbits) {
+                                if (tv->compstage == 0) {
+                                    for (j=0; j<tv->permInd; j++) {
+                                        orbjoin_sp_pair(TempOrbits, TempOrbList, n,
+                                                        PrmPairs[j].arg, PrmPairs[j].val, &numtemporbits);
+                                    }
+                                }
+                                else {
+                                    orbjoin(TempOrbits, AUTPERM, n);
+                                }
+                            }
+                            tv->stats->numgenerators++;
+                            orbjoin_sp_perm(tv->orbits, AUTPERM, OrbList, n, &tv->stats->numorbits);
+                            
+                            ti->thegrouphaschanged = TRUE;
+                            ti->identitygroup = FALSE;
+                            tv->lev_of_lastauto = tv->tolevel;
+                            if (tv->options->verbosity >= 2) fprintf(outfile, "[a(%d)] ", CheckAutList->name);
+                            if (tv->options->verbosity >= 2 && tv->options->writeautoms) {
+                                PRINT_RETURN
+                            }
+                            if (tv->options->writeautoms) {
+                                fprintf(outfile, "Gen(a) #%d: ", tv->stats->numgenerators);
+                                writeperm(outfile, AUTPERM, tv->options->cartesian, tv->options->linelength, n);
+                            }
+                            if (tv->options->userautomproc) {
+                                (*tv->options->userautomproc)(tv->stats->numgenerators, AUTPERM, n);
+                            }
+                        }
+                        else {
+                            if (tv->options->verbosity >= 2) {
+                                fprintf(outfile, "[a*]");
+                            }
+                            if (TempOrbits) {
+                                if (tv->compstage == 0) {
+                                    for (j=0; j<tv->permInd; j++) {
+                                        orbjoin_sp_pair(TempOrbits, TempOrbList, n,
+                                                        PrmPairs[j].arg, PrmPairs[j].val, &numtemporbits);
+                                    }
+                                }
+                                else {
+                                    orbjoin(TempOrbits, AUTPERM, n);
+                                }
+                            }
+                            else {
+                                orbjoin(tv->currorbit, AUTPERM, n);
+                            }
+                            result = -CheckAutList->name;
+                        }
+                        
+                        TrieCandFrom = NULL;
+                        TrieCheckFrom = CheckAutList->stnode;
+                        if (CurrCand->stnode->level <= 1) {
+                            tgt_level = CurrCand->stnode->level + 1;
+                            while (TrieCheckFrom->level > tgt_level) {
+                                TrieCheckFrom = TrieCheckFrom->father;
+                            }
+                        }
+                        else {
+                            if (tv->tolevel <= TrieCheckFrom->level) {
+                                tgt_level = tv->tolevel;
+                                while (TrieCheckFrom->level != tgt_level) {
+                                    TrieCheckFrom = TrieCheckFrom->father;
+                                }
+                            }
+                            else {
+                                TrieCandFrom = CurrCand->stnode;
+                                tgt_level = TrieCheckFrom->level;
+                                while (TrieCandFrom->level != tgt_level) {
+                                    TrieCandFrom = TrieCandFrom->father;
+                                }
+                            }
+                        }
+                        if (TrieCandFrom) {
+                            while (TrieCandFrom->father != TrieCheckFrom->father) {
+                                TrieCandFrom = TrieCandFrom->father;
+                                TrieCheckFrom = TrieCheckFrom->father;
+                            }
+                        }
+                        else {
+                            if ((TrieCheckFrom->level > 1) && (TrieCheckFrom->father != CurrCand->stnode)) {
+                                TrieCandFrom = CurrCand->stnode;
+                                TrieCheckFrom = TrieCheckFrom->father;
+                                while (TrieCandFrom->father != TrieCheckFrom->father) {
+                                    TrieCandFrom = TrieCandFrom->father;
+                                    TrieCheckFrom = TrieCheckFrom->father;
+                                }
+                            }
+                        }
+                        
+                        while (TrieCheckFrom->goes_to) {
+                            TrieCheckFrom = TrieCheckFrom->goes_to;
+                        }
+                        
+                        for (temp=1; temp<=tv->tolevel; temp++) {
+                            if (CheckAutList->lab[Spine[temp].tgtpos] != NextCand->lab[Spine[temp].tgtpos]) {
+                                break;
+                            }
+                        }
+                        
+                        switch (tv->compstage) {
+                            case 0:
+                                if (tv->strategy && (tv->steps == 1)) {
+                                    RemoveFromLevel(temp, tv->maxtreelevel-1, tv->strategy, FALSE);
+                                    if (TrieCandFrom) {
+                                        TrieCheckFrom->index += TrieCandFrom->index;
+                                        TrieCandFrom->goes_to = TrieCheckFrom;
+                                        PRINT_INDEX(TrieCheckFrom,4,9)
+                                    }
+                                    else {
+                                        TrieCheckFrom->index++;
+                                        PRINT_INDEX(TrieCheckFrom,4,10)
+                                    }
+                                    NextCand->do_it = FALSE;
+                                }
+                                else {
+                                    if (CheckAutList->lab[Spine[temp].tgtpos] >= NextCand->lab[Spine[temp].tgtpos]) {
+                                        CheckAutList->do_it = FALSE;
+                                        if (TrieCandFrom) {
+                                            TrieCandFrom->index += TrieCheckFrom->index;
+                                            tv->newindex = 0;
+                                            TrieCheckFrom->goes_to = TrieCandFrom;
+                                            PRINT_INDEX(TrieCandFrom,4,11)
+                                        }
+                                        else {
+                                            if (CurrCand->stnode->level > 1) {
+                                                tv->newgotonode = TrieCheckFrom;
+                                                tv->newindex = TrieCheckFrom->index;
+                                            }
+                                            else {
+                                                tv->newgotonode = NULL;
+                                                tv->newindex = 0;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        if (TrieCandFrom) {
+                                            TrieCheckFrom->index += TrieCandFrom->index;
+                                            TrieCandFrom->goes_to = TrieCheckFrom;
+                                            PRINT_INDEX(TrieCheckFrom,4,12)
+                                        }
+                                        else {
+                                            TrieCheckFrom->index++;
+                                            PRINT_INDEX(TrieCheckFrom,4,13)
+                                        }
+                                        NextCand->do_it = FALSE;
+                                    }
+                                }
+                                break;
+                            case 1:
+                                TrieCheckFrom->index++;
+                                PRINT_INDEX(TrieCheckFrom,4,14)
+                                tv->gotonode = TrieCheckFrom;
+                                break;
+                            case 2:
+                                if (TrieCandFrom) {
+                                    TrieCheckFrom->index += TrieCandFrom->index;
+                                    TrieCandFrom->goes_to = TrieCheckFrom;
+                                    PRINT_INDEX(TrieCheckFrom,4,15)
+                                }
+                                else {
+                                    TrieCheckFrom->index++;
+                                    PRINT_INDEX(TrieCheckFrom,4,16)
+                                }
+                                if (temp == tv->maxtreelevel) {
+                                    tmp1 = TempOrbits[NextCand->lab[Spine[temp].tgtpos]];
+                                    for (i=1; i<AutomCount[0]; i++) if (AutomCount[i] == tmp1) break;
+                                    if (i == AutomCount[0]) AutomCount[AutomCount[0]++] = TempOrbits[NextCand->lab[Spine[temp].tgtpos]];
+                                }
+                                break;
+                            default:
+                                break;
+                        }
+                        return result;
+                    }
+                }
+            }
+        }
+        CheckAutList = CheckAutList->next;
+    }
+    return result;
+}
+
+int CheckForMatching(Candidate *CurrCand, Candidate *NextCand, Partition *Part, struct TracesVars* tv, struct TracesInfo* ti, int m, int n) {
+    int i, j, vtx, vtx1, temp, tmp1, tgt_level, numtemporbits, pos;
+    TracesSpine *SpineTL;
+    Candidate *CheckAutList;
+    int *cls;
+    searchtrie *TrieCandFrom, *TrieCheckFrom;
+    boolean CodeVerify;
+    
+    SpineTL = Spine+tv->tolevel;
+    CheckAutList = SpineTL->liststart;
+    cls = Part->cls;
+    numtemporbits = 0;
+    tv->gotonode = NULL;
+    
+    while (CheckAutList != NULL) {
+        if (CheckAutList->do_it && (CheckAutList->singcode == NextCand->singcode)) {
+            TrieCheckFrom = CheckAutList->stnode->father;
+            TrieCandFrom = CurrCand->stnode;
+            while (TrieCandFrom != TrieCheckFrom) {
+                TrieCandFrom = TrieCandFrom->father;
+                TrieCheckFrom = TrieCheckFrom->father;
+            }
+            
+            if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+            
+            CodeVerify = TRUE;
+            for (i=Spine[TrieCheckFrom->level+1].singstart; i<SpineTL->singend; i++) {
+                Markers[NextCand->lab[Singletons[i]]] = tv->mark;
+            }
+            for (i=Spine[TrieCheckFrom->level+1].singstart; i<SpineTL->singend; i++) {
+                pos = Singletons[i];
+                vtx1 = CheckAutList->lab[pos];
+                if (Markers[vtx1] != tv->mark) {
+                    CodeVerify = FALSE;
+                    break;
+                }
+                vtx = NextCand->lab[pos];
+                SETPAIRSAUT(vtx, vtx1)
+                
+                if (tv->preprocessed && Diff[vtx1]) {
+                    MakeTree(vtx, vtx1, tv->input_graph, n, tv, TRUE);
+                }
+            }
+            tv->conta7++;
+            
+            if (CodeVerify) {
+                if (isautom_sg_pair((graph*)tv->input_graph, AUTPERM, tv->options->digraph, m, n, tv)) {
+                    
+                    if (!findperm(gensB, AUTPERM, n)) {
+                        if (tv->options->verbosity >= 2) tv->schreier3 -= CPUTIME;
+                        if (tv->options->generators) addpermutation(&gensB, AUTPERM, n);
+                        
+                        if (tv->options->verbosity >= 2) tv->schreier3 += CPUTIME;
+                        
+                        if (CheckAutList->stnode->father == CurrCand->stnode) {
+                            if (TempOrbits) {
+                                if (tv->compstage == 0) {
+                                    for (j=0; j<tv->permInd; j++) {
+                                        orbjoin_sp_pair(TempOrbits, TempOrbList, n, PrmPairs[j].arg, PrmPairs[j].val, &numtemporbits);
+                                    }
+                                }
+                                else {
+                                    orbjoin(TempOrbits, AUTPERM, n);
+                                }
+                            } else {
+                                orbjoin(tv->currorbit, AUTPERM, n);
+                            }
+                        }
+                        
+                        tv->stats->numgenerators++;
+                        
+                        for (j=0; j<tv->permInd; j++) {
+                            orbjoin_sp_pair(tv->orbits, OrbList, n, PrmPairs[j].arg, PrmPairs[j].val, &tv->stats->numorbits);
+                        }
+                        
+                        ti->thegrouphaschanged = TRUE;
+                        ti->first_matching = TRUE;
+                        tv->lev_of_lastauto = tv->tolevel;
+                        if (tv->options->verbosity >= 2) fprintf(outfile, "[M(%d)] ", CheckAutList->name);
+                        if (tv->options->verbosity >= 2 && tv->options->writeautoms) {
+                            PRINT_RETURN
+                        }
+                        if (tv->options->writeautoms) {
+                            fprintf(outfile, "Gen(M) #%d: ", tv->stats->numgenerators);
+                            writeperm(outfile, AUTPERM, tv->options->cartesian, tv->options->linelength, n);
+                        }
+                        if (tv->options->userautomproc) {
+                            (*tv->options->userautomproc)(tv->stats->numgenerators, AUTPERM, n);
+                        }
+                        
+                    }
+                    else {
+                        if (tv->options->verbosity >= 2) {
+                            fprintf(outfile, "[M*]");
+                        }
+                        if (TempOrbits) {
+                            if (tv->compstage == 0) {
+                                for (j=0; j<tv->permInd; j++) {
+                                    orbjoin_sp_pair(TempOrbits, TempOrbList, n,
+                                                    PrmPairs[j].arg, PrmPairs[j].val, &numtemporbits);
+                                }
+                            }
+                            else {
+                                orbjoin(TempOrbits, AUTPERM, n);
+                            }
+                        }
+                    }
+                    
+                    TrieCandFrom = NULL;
+                    TrieCheckFrom = CheckAutList->stnode;
+                    if (CurrCand->stnode->level <= 1) {
+                        tgt_level = CurrCand->stnode->level + 1;
+                        while (TrieCheckFrom->level > tgt_level) {
+                            TrieCheckFrom = TrieCheckFrom->father;
+                        }
+                    }
+                    else {
+                        if (tv->tolevel <= TrieCheckFrom->level) {
+                            tgt_level = tv->tolevel;
+                            while (TrieCheckFrom->level != tgt_level) {
+                                TrieCheckFrom = TrieCheckFrom->father;
+                            }
+                        }
+                        else {
+                            TrieCandFrom = CurrCand->stnode;
+                            tgt_level = TrieCheckFrom->level;
+                            while (TrieCandFrom->level != tgt_level) {
+                                TrieCandFrom = TrieCandFrom->father;
+                            }
+                        }
+                    }
+                    if (TrieCandFrom) {
+                        while (TrieCandFrom->father != TrieCheckFrom->father) {
+                            TrieCandFrom = TrieCandFrom->father;
+                            TrieCheckFrom = TrieCheckFrom->father;
+                        }
+                    }
+                    else {
+                        if ((TrieCheckFrom->level > 1) && (TrieCheckFrom->father != CurrCand->stnode)) {
+                            TrieCandFrom = CurrCand->stnode;
+                            TrieCheckFrom = TrieCheckFrom->father;
+                            while (TrieCandFrom->father != TrieCheckFrom->father) {
+                                TrieCandFrom = TrieCandFrom->father;
+                                TrieCheckFrom = TrieCheckFrom->father;
+                            }
+                        }
+                    }
+                    
+                    while (TrieCheckFrom->goes_to) {
+                        TrieCheckFrom = TrieCheckFrom->goes_to;
+                    }
+                    
+                    for (temp=1; temp<=tv->tolevel; temp++) {
+                        if (CheckAutList->lab[Spine[temp].tgtpos] != NextCand->lab[Spine[temp].tgtpos]) {
+                            break;
+                        }
+                    }
+                    switch (tv->compstage) {
+                        case 0:
+                            if (tv->strategy && (tv->steps == 1)) {
+                                RemoveFromLevel(temp, tv->maxtreelevel-1, tv->strategy, FALSE);
+                                if (TrieCandFrom) {
+                                    TrieCheckFrom->index += TrieCandFrom->index;
+                                    TrieCandFrom->goes_to = TrieCheckFrom;
+                                    PRINT_INDEX(TrieCheckFrom,4,17)
+                                }
+                                else {
+                                    TrieCheckFrom->index++;
+                                    PRINT_INDEX(TrieCheckFrom,4,18)
+                                }
+                                NextCand->do_it = FALSE;
+                            }
+                            else {
+                                if (CheckAutList->lab[Spine[temp].tgtpos] >= NextCand->lab[Spine[temp].tgtpos]) {
+                                    CheckAutList->do_it = FALSE;
+                                    if (TrieCandFrom) {
+                                        TrieCandFrom->index += TrieCheckFrom->index;
+                                        tv->newindex = 0;
+                                        TrieCheckFrom->goes_to = TrieCandFrom;
+                                        PRINT_INDEX(TrieCandFrom,4,19)
+                                    }
+                                    else {
+                                        if (CurrCand->stnode->level > 1) {
+                                            tv->newgotonode = TrieCheckFrom;
+                                            tv->newindex = TrieCheckFrom->index;
+                                        }
+                                        else {
+                                            tv->newgotonode = NULL;
+                                            tv->newindex = 0;
+                                        }
+                                    }
+                                }
+                                else {
+                                    if (TrieCandFrom) {
+                                        TrieCheckFrom->index += TrieCandFrom->index;
+                                        TrieCandFrom->goes_to = TrieCheckFrom;
+                                        PRINT_INDEX(TrieCheckFrom,4,20)
+                                    }
+                                    else {
+                                        TrieCheckFrom->index++;
+                                        PRINT_INDEX(TrieCheckFrom,4,21)
+                                    }
+                                    NextCand->do_it = FALSE;
+                                }
+                            }
+                            break;
+                        case 1:
+                            TrieCheckFrom->index ++;
+                            tv->gotonode = TrieCheckFrom;
+                            PRINT_INDEX(TrieCheckFrom,4,22)
+                            break;
+                        case 2:
+                            if (TrieCandFrom) {
+                                TrieCheckFrom->index += TrieCandFrom->index;
+                                TrieCandFrom->goes_to = TrieCheckFrom;
+                                PRINT_INDEX(TrieCheckFrom,4,23)
+                            }
+                            else {
+                                TrieCheckFrom->index++;
+                                PRINT_INDEX(TrieCheckFrom,4,24)
+                            }
+                            if (temp == tv->maxtreelevel) {
+                                tmp1 = TempOrbits[NextCand->lab[Spine[temp].tgtpos]];
+                                for (i=1; i<AutomCount[0]; i++) if (AutomCount[i] == tmp1) break;
+                                if (i == AutomCount[0]) AutomCount[AutomCount[0]++] = TempOrbits[NextCand->lab[Spine[temp].tgtpos]];
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+                    return temp;
+                }
+            }
+        }
+        CheckAutList = CheckAutList->next;
+    }
+    return FALSE;
+}
+
+void CodeClassify(int Level, int code, int cell) {
+    switch (EPCodes[Level].info) {
+        case 0:
+            EPCodes[Level].code = code;
+            EPCodes[Level].cell = cell;
+            EPCodes[Level].info = 1;
+            break;
+        case 1:
+            if (EPCodes[Level].cell != cell) {
+                EPCodes[Level].info = 3;
+            } else {
+                if (EPCodes[Level].code != code) {
+                    EPCodes[Level].info = 2;
+                }
+            }
+            break;
+        case 2:
+            if (EPCodes[Level].cell != cell) {
+                EPCodes[Level].info = 3;
+            }
+            break;
+        default:
+            break;
+    }
+}
+
+void Complete(sparsegraph *sg_orig, Candidate *Cand, Partition *Part, int cell, TracesVars *tv,
+              double *grpsize1, int *grpsize2, permnode **ring, int n) {
+    int i, j, k;
+    int arg, val;
+    int numtemporbits;
+    k = cell + Part->cls[cell];
+    
+    if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+    for (i = cell; i < k; i++) {
+        tv->currorbit[Cand->lab[i]] = Cand->lab[k];
+        arg = Cand->lab[i];
+        val = Cand->lab[i+1];
+        SETPAIRSAUTANDTREE(arg, val)
+    }
+    arg = Cand->lab[i];
+    val = Cand->lab[cell];
+    SETPAIRSAUTANDTREE(arg, val)
+    SPECIALGENERATORS
+    
+    if (Part->cls[cell] > 1) {
+        if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+        arg = Cand->lab[cell];
+        val = Cand->lab[cell+1];
+        SETPAIRSAUTANDTREE(arg, val)
+        arg = Cand->lab[cell+1];
+        val = Cand->lab[cell];
+        SETPAIRSAUTANDTREE(arg, val)
+        SPECIALGENERATORS
+    }
+}
+
+int CompStage0(Partition *CurrPart, Partition *NextPart, Candidate *CurrCand, Candidate *NextCand,
+               int m, int n, struct TracesVars* tv, struct TracesInfo *ti) {
+    int i, j, i1, j2, k, cu, cu1, num_indv;
+    int temp, tmp, auxcode, search_vtx, gom_level;
+    boolean closeloop, firstsing, has_nexttcell;
+    Candidate *SpTLliststart, *AuxCand;
+    searchtrie *TreeNode, *TreeNode1, *TreeNode2;
+    
+#ifdef NAUTY_IN_MAGMA
+    if (main_seen_interrupt) return NAUTY_KILLED;
+#else
+    if (nauty_kill_request) return NAUTY_KILLED;
+#endif
+    
+    PRINT_FROM_VERB(4,tv->tolevel)
+    if (TargetCell(CurrCand, CurrPart, n, tv, tv->tolevel)) {
+        ++tv->tolevel;
+        SpineTL = Spine+tv->tolevel;
+        SpineTL->tgtcell = tv->tcell;
+        SpineTL->tgtsize = CurrPart->cls[tv->tcell];
+        SpineTL->tgtend = tv->tcell+SpineTL->tgtsize;
+        SpineTL->tgtpos = SpineTL->tgtend - 1;
+    }
+    else {
+        tv->finalnumcells = min(CurrPart->cells,tv->finalnumcells);    /* 160712 */
+        ti->thereisnextlevel = SelectNextLevel(n, tv, ti);
+        return 0;
+    }
+    
+    tv->newgotonode = NULL;
+    
+    /*  CANDIDATE */
+    temp = CurrCand->lab[Spine[1].tgtpos];
+    k = SpineTL->tgtend;
+    
+    TreeNode = CurrCand->stnode;
+    while (TreeNode) {
+        if (TreeNode->goes_to) {
+            CurrCand->do_it = FALSE;
+            break;
+        }
+        TreeNode = TreeNode->father;
+    }
+    
+    if (CurrCand->do_it) {
+        if ((tv->orbits[temp] == temp) || tv->tolevel == 1) {
+            ti->minimalinorbits = TRUE;
+            
+            if ((tv->group_level >= tv->tolevel) && (FixedBase(fix, tv, CurrCand, 0, tv->fromlevel))) {
+                tv->nfix = tv->fromlevel;
+                tv->currorbit = findcurrorbits(gpB, tv->nfix);
+            } else {
+                if ((!ti->identitygroup) &&
+                    (((Spine[tv->fromlevel].liststart != Spine[tv->fromlevel].listend)
+                      && (CurrPart->cls[tv->tcell] > 10))
+                     || tv->strategy
+                     || (tv->expathlength <=10)
+                     )) {
+                        
+                        TempOrbits = NULL;
+                        tv->samepref = FixBase(fix, tv, CurrCand, 0, tv->fromlevel);
+                        if ((tv->samepref != tv->nfix) || ti->thegrouphaschanged) {
+                            if (tv->options->verbosity >= 2) tv->schreier1 -= CPUTIME;
+                            gom_level = getorbitsmin(fix, tv->nfix, gpB, &gensB, &tv->currorbit, CurrCand->lab+tv->tcell, CurrPart->cls[tv->tcell], n, TRUE);
+                            if (tv->options->verbosity >= 2) tv->schreier1 += CPUTIME;
+                            ti->thegrouphaschanged = FALSE;
+                            
+                            if (gom_level < tv->nfix) {
+                                PRINT_NOTMIN_VERB(4)
+                                
+                                TreeNode = CurrCand->stnode;
+                                j2 = CurrCand->lab[Spine[gom_level+1].tgtpos];
+                                i1 = tv->currorbit[j2];
+                                for (j=0; j < tv->nfix - gom_level; j++) {
+                                    TreeNode = TreeNode->father;
+                                }
+                                TreeNode1 = TreeNode->first_child;
+                                while (TreeNode1) {
+                                    if (TreeNode1->vtx == i1) {
+                                        break;
+                                    }
+                                    TreeNode1 = TreeNode1->next_sibling;
+                                }
+                                if (TreeNode1) {
+                                    while (TreeNode1->goes_to) {
+                                        TreeNode1 = TreeNode1->goes_to;
+                                    }
+                                    TreeNode2 = TreeNode1->next_sibling;
+                                    while (TreeNode2->vtx != j2) {
+                                        TreeNode2 = TreeNode2->next_sibling;
+                                    }
+                                    TreeNode1->index += TreeNode2->index;
+                                    TreeNode2->goes_to = TreeNode1;
+                                    PRINT_INDEX(TreeNode1,4,25)
+                                    
+                                    ti->minimalinorbits = FALSE;
+                                }
+                                else {
+                                    tv->currorbit = getorbits(fix, tv->nfix, gpB, &gensB, n);
+                                }
+                            }
+                        }
+                        else {
+                            tv->currorbit = findcurrorbits(gpB, tv->nfix);
+                        }
+                    }
+                else {
+                    TempOrbits = WorkArray1;
+                    memcpy(TempOrbits, IDENTITY_PERM, n*sizeof(int));
+                    memcpy(TempOrbList, IDENTITY_PERM, n*sizeof(int));
+                    
+                    tv->conta1++;
+                    tv->currorbit = TempOrbits;
+                }
+            }
+            if (ti->minimalinorbits) {
+                memcpy(NextCand->lab, CurrCand->lab, n*sizeof(int));
+                memcpy(NextCand->invlab, CurrCand->invlab, n*sizeof(int));
+                tv->conta2++;
+                auxcode = CurrCand->code;
+                SpineTL->trcstart = CurrPart->cells;
+                TheTrace[SpineTL->trcstart] = SpineTL->tgtpos;
+                if (!CurrCand->sortedlab) {
+                    quickSort(CurrCand->lab+tv->tcell, CurrPart->cls[tv->tcell]);
+                    for (i=tv->tcell; i<tv->tcell+CurrPart->cls[tv->tcell]; i++) {
+                        CurrCand->invlab[CurrCand->lab[i]] = i;
+                    }
+                    CurrCand->sortedlab = TRUE;
+                }
+                
+                tv->indivstart = tv->tcell+CurrCand->indnum;
+                tv->indivend = tv->indivstart+tv->steps;
+                if (tv->indivend > SpineTL->tgtend) {
+                    tv->indivend = SpineTL->tgtend;
+                }
+                
+                temp = CurrCand->lab[tv->indivstart];
+                for (k = tv->indivstart; k < tv->indivend; k++) {
+                    CurrCand->indnum++;
+                    NextCand->singcode = CurrCand->singcode;
+                    NextCand->vertex = CurrCand->lab[k];
+                    NextCand->name = ++tv->name;
+                    if (NextCand->name == (NAUTY_INFINITY-2)) {
+                        NextCand->name = tv->name = 1;
+                    }
+                    
+                    PRINT_INDIV_VERB(4,tv->tolevel)
+                    if (tv->currorbit[NextCand->vertex] != NextCand->vertex) {
+                        PRINT_SKIPPED_VERB(4)
+                        
+                        search_vtx = tv->currorbit[NextCand->vertex];
+                        TreeNode = CurrCand->stnode;
+                        if (TreeNode->first_child) {
+                            TreeNode = TreeNode->first_child;
+                            while (TreeNode) {
+                                if (TreeNode->vtx == search_vtx) {
+                                    break;
+                                }
+                                TreeNode = TreeNode->next_sibling;
+                            }
+                            if (TreeNode) {
+                                while (TreeNode->goes_to) {
+                                    TreeNode = TreeNode->goes_to;
+                                }
+                                TreeNode->index++;
+                                PRINT_INDEX(TreeNode,4,26)
+                                continue;
+                            }
+                        }
+                    }
+                    else {
+                        PRINT_REFINE_VERB(4,'a')
+                        
+                        memcpy(NextPart->cls, CurrPart->cls, n*sizeof(int));
+                        memcpy(NextPart->inv, CurrPart->inv, n*sizeof(int));
+                        
+                        tv->conta3++;
+                        
+                        if (NextPart->cls[tv->tcell] == 2) {
+                            num_indv = 2;
+                            NextCand->singcode = MASHCOMM(NextCand->singcode, CurrCand->lab[tv->tcell]);
+                            NextCand->singcode = MASHCOMM(NextCand->singcode, CurrCand->lab[tv->tcell+1]);
+                            if (SpineTL->singstart == SpineTL->singend) {
+                                Singletons[SpineTL->singend++] = tv->tcell;
+                                Singletons[SpineTL->singend++] = tv->tcell+1;
+                            }
+                        }
+                        else {
+                            num_indv = 1;
+                            NextCand->singcode = MASHCOMM(NextCand->singcode, NextCand->vertex);
+                            if (SpineTL->singstart == SpineTL->singend) {
+                                Singletons[SpineTL->singend++] = tv->tcell + NextPart->cls[tv->tcell] - 1;
+                            }
+                        }
+                        
+                        Individualize(NextPart, NextCand, NextCand->vertex, tv->tcell, CurrPart->cells, SpineTL->tgtpos);
+                        tv->stats->numnodes++;
+                        tv->answ = traces_refine(NextCand,
+                                                 n,
+                                                 NextPart, tv, ti, num_indv, TRUE);
+                        
+                        switch (tv->answ) {
+                            case 0:				/* Interrupted refinement: do not add to the list */
+                                tv->stats->interrupted++;
+                                SpineTL->levelcounter++;
+                                break;
+                            case 1 :			/* The same trace has been found once more : add to the list */
+                                SpineTL->levelcounter++;
+                                
+                                NextCand->do_it = TRUE;
+                                if (tv->options->verbosity >= 2) PRINT_CANDIDATE(NextCand, tv->tolevel);
+                                
+                                tv->tolevel_tl = tv->tolevel;
+                                NextCand->pathsingcode = NextCand->singcode;
+                                NextCand->firstsingcode = 0;
+                                
+                                if (tv->steps > 1) {
+                                    if (tv->fromlevel <= tv->lev_of_lastauto) {
+                                        
+                                        closeloop = CheckForMatching(CurrCand, NextCand, NextPart, tv, ti, m, n);
+                                    }
+                                    if (NextCand->do_it) {
+                                        firstsing = TRUE;
+                                        
+                                        /* EXPERIMENTAL PATH */
+                                        if (NextPart->cells != tv->finalnumcells) {    /* 160712 */
+                                            if (tv->options->verbosity >= 2) tv->expaths -= CPUTIME;
+                                            while (NextPart->cells < n) {
+                                                if (firstsing && BreakSteps[tv->tolevel]) {
+                                                    firstsing = FALSE;
+                                                    NextCand->firstsingcode = NextCand->pathsingcode;
+                                                    if (CheckForSingAutomorphisms(CurrCand, NextPart, NextCand, tv, ti, m, n))
+                                                        if (!NextCand->do_it) {
+                                                            break;
+                                                        }
+                                                }
+                                                
+                                                has_nexttcell = TargetCellExpPath(NextCand, NextPart, tv);
+                                                
+                                                if (!has_nexttcell) {
+                                                    NextCand->firstsingcode = NextCand->pathsingcode;
+                                                    if (tv->options->verbosity >= 2) {
+                                                        if (tv->tolevel_tl-tv->tolevel >= 6) {
+                                                            PRINT_EXPPATHSTEP(NextCand, TRUE)
+                                                        }
+                                                        else {
+                                                            fprintf(outfile, "(%d) ", tv->tolevel_tl);
+                                                        }
+                                                    }
+                                                    break;
+                                                }
+                                                ExperimentalStep(NextPart, NextCand, tv, ti, m, n);
+                                                if (NextPart->cells == n) {
+                                                    has_nexttcell = FALSE;
+                                                }
+                                                PRINT_EXPPATHSTEP(NextCand, TRUE)
+                                            }
+                                            if (tv->options->verbosity >= 2) tv->expaths += CPUTIME;
+                                        }
+                                    }
+                                    else {
+                                        if (closeloop < tv->tolevel) k = SpineTL->tgtend;
+                                        PRINT_RETURN
+                                        break;
+                                    }
+                                    
+                                    if (!tv->strategy && !tv->options->getcanon && (tv->tolevel_tl == tv->tolevel + 1) && ((NextPart->cells != tv->finalnumcells) || (NextPart->cells == n))) {    /* 160717 */
+                                        tv->levelfromCS0 = tv->tolevel;
+                                        tv->maxtreelevel = tv->tolevel_tl;
+                                        if (tv->tolevel == 1) {
+                                            tv->newst_stage1 = searchtrie_make(CurrCand, NextCand, n, tv);
+                                            EXITFROMSTAGE0EXPATH1
+                                        }
+                                        else {
+                                            temp = 0;
+                                            for (i=0; i<tv->tolevel; i++) {
+                                                temp += Spine[i].listcounter;
+                                            }
+                                            if (temp > 5) {
+                                                tv->newst_stage1 = searchtrie_make(CurrCand, NextCand, n, tv);
+                                                EXITFROMSTAGE0EXPATH1
+                                            }
+                                        }
+                                    }
+                                    
+                                    /* ANY AUTOMORPHISM? */
+                                    if (tv->options->verbosity >= 2) tv->autchk -= CPUTIME;
+                                    tv->newindex = 0;
+                                    if (NextCand->do_it) {
+                                        closeloop = CheckForAutomorphisms(CurrCand, NextCand, tv, ti, m, n, NextPart);
+                                        if (!NextCand->do_it && closeloop < tv->tolevel) k = SpineTL->tgtend;
+                                    }
+                                    if (tv->options->verbosity >= 2) tv->autchk += CPUTIME;
+                                    
+                                    if (NextCand->do_it) {
+                                        ADDTONEXTLEVEL;
+                                        SpineTL->keptcounter++;
+                                        searchtrie_make(CurrCand, SpineTL->listend, n, tv);
+                                    }
+                                }
+                                else {
+                                    if (BreakSteps[tv->tolevel]) {
+                                        NextCand->firstsingcode = NextCand->pathsingcode;
+                                        if (CheckForSingAutomorphisms(CurrCand, NextPart, NextCand, tv, ti, m, n))
+                                            if (!NextCand->do_it) {
+                                                PRINT_RETURN
+                                                break;
+                                            }
+                                    }
+                                    
+                                    /* ANY AUTOMORPHISM? */
+                                    if (tv->options->verbosity >= 2) tv->autchk -= CPUTIME;
+                                    tv->newindex = 0;
+                                    if (NextCand->do_it) {
+                                        closeloop = CheckForAutomorphisms(CurrCand, NextCand, tv, ti, m, n, NextPart);
+                                        if (!NextCand->do_it && closeloop < tv->tolevel) k = SpineTL->tgtend;
+                                    }
+                                    if (tv->options->verbosity >= 2) tv->autchk += CPUTIME;
+                                    
+                                    if (NextCand->do_it) {
+                                        ADDTONEXTLEVEL;
+                                        SpineTL->keptcounter++;
+                                        searchtrie_make(CurrCand, SpineTL->listend, n, tv);
+                                    }
+                                }
+                                PRINT_RETURN
+                                break;
+                            case 2 :	/* Delete the old list and start a new one: a better trace has been found */
+                                
+                                tv->tolevel_tl = tv->tolevel;
+                                has_nexttcell = FALSE;
+                                if (NextPart->cells == n) {
+                                    tv->stats->canupdates++;
+                                    if (tv->options->usercanonproc != NULL)
+                                    {
+                                        (*tv->options->usercanonproc)((graph*)tv->input_graph, NextCand->lab, (graph*)tv->cangraph, tv->stats->canupdates, NextCand->code, m, n);
+                                    }
+                                }
+                                
+                                if (tv->tolevel > tv->treedepth) {
+                                    tv->treedepth = tv->tolevel;
+                                    if (tv->strategy) {
+                                        SpineTL->part = NewPartition(n);
+                                    }
+                                    else {
+                                        NewPartSpine(tv->tolevel,n);
+                                    }
+                                }
+                                
+                                if (!tv->strategy && (tv->tolevel > 1) && !SpineTL->liststart) {
+                                    /* First Candidate at current level */
+                                    tv->maxtreelevel = tv->tolevel;
+                                    
+                                    SpineTL->liststart = NewCandidate(n, &GarbList, TRUE);
+                                    SpineTL->listend = SpineTL->liststart;
+                                    
+                                    tv->conta0++;
+                                    CopyCand(SpineTL->liststart, NextCand, n, TEMPLAB, TEMPINVLAB);
+                                    if (NextPart->cells < tv->finalnumcells) SpineTL->liststart->code = auxcode;
+                                    COPYPART(SpineTL->part, NextPart);
+                                    tv->newindex = 0;
+                                    tv->newst_stage1 = searchtrie_make(CurrCand, SpineTL->listend, n, tv);
+                                    
+                                    SpineTL->listcounter = 1;
+                                    SpTLliststart = SpineTL->liststart;
+                                    
+                                    i = tv->tolevel;
+                                    if (tv->brkstpcount) {
+                                        while ((i<n) && !BreakSteps[i]) {
+                                            i++;
+                                        }
+                                        if (i<n) SpineTL->liststart->firstsingcode = Spine[i].singcode;
+                                    }
+                                    
+                                    SpineTL->updates = 1;
+                                    SpineTL->levelcounter = 1;
+                                    SpineTL->keptcounter = 1;
+                                    
+                                    PRINT_LINE_PLUS(tv->fromlevel)
+                                    
+                                    if (tv->options->verbosity >= 2) PRINT_CANDIDATE(SpineTL->liststart, tv->tolevel);
+                                    PRINT_RETURN;
+                                    
+                                    if (!tv->strategy && !tv->options->getcanon && (tv->tolevel+1 == tv->firstpathlength) && ((NextPart->cells != tv->finalnumcells) || (NextPart->cells == n))) {
+                                        if ((tv->tolevel == 1) && (CurrPart->cls[tv->tcell] > 5)) {
+                                            EXITFROMSTAGE0EXPATH2;
+                                        }
+                                        else {
+                                            temp = 0;
+                                            for (i=0; i<tv->tolevel; i++) {
+                                                temp += Spine[i].listcounter;
+                                            }
+                                            if (temp > 5) {
+                                                EXITFROMSTAGE0EXPATH2;
+                                            }
+                                        }
+                                    }
+                                }
+                                else {
+                                    memset(WorkArray, 0, n*sizeof(int));
+                                    
+                                    tv->lastcell = tv->lastlev = -1;
+                                    has_nexttcell = TargetCellFirstPath(NextCand, NextPart, tv);
+                                    
+                                    if (!has_nexttcell) {
+                                        tv->stats->canupdates++;
+                                        if (tv->options->usercanonproc != NULL) {
+                                            (*tv->options->usercanonproc)((graph*)tv->input_graph, NextCand->lab, (graph*)tv->cangraph, tv->stats->canupdates, NextCand->code, m, n);
+                                        }
+                                    }
+                                    
+                                    tv->tcellevel = tv->maxtreelevel = tv->tolevel;
+                                    SpineTL->levelcounter++;
+                                    SpineTL->updates++;
+                                    SpineTL->keptcounter = 1;
+                                    
+                                    RemoveFromLevel(tv->tolevel, tv->treedepth, tv->strategy, TRUE);
+                                    SpineTL->liststart = NewCandidate(n, &GarbList, TRUE);
+                                    SpineTL->listend = SpineTL->liststart;
+                                    
+                                    tv->conta0++;
+                                    CopyCand(SpineTL->liststart, NextCand, n, NULL, NULL);
+                                    COPYPART(SpineTL->part, NextPart);
+                                    
+                                    tv->newindex = 0;
+                                    
+                                    tv->newst_stage1 = searchtrie_make(CurrCand, SpineTL->listend, n, tv);
+                                    
+                                    SpineTL->listcounter = 1;
+                                    SpTLliststart = SpineTL->liststart;
+                                    
+                                    SpTLliststart->pathsingcode = SpineTL->singcode = SpTLliststart->singcode;
+                                    SpTLliststart->firstsingcode = 0;
+                                    
+                                    PRINT_LINE
+                                    if (tv->options->verbosity >= 2) PRINT_CANDIDATE(SpTLliststart, tv->tolevel);
+                                    
+                                    memset(BreakSteps, 0, n*sizeof(int));
+                                    tv->brkstpcount = 0;
+                                    
+                                    if (tv->steps > 1) {
+                                        
+                                        /* EXPERIMENTAL PATH */
+                                        if (tv->options->verbosity >= 2) tv->expaths -= CPUTIME;
+                                        PRINTF2("CStage0 2: %d\n", tv->finalnumcells);
+                                        tv->finalnumcells = n;
+                                        
+                                        while (has_nexttcell) {
+                                            ExperimentalStep(NextPart, SpTLliststart, tv, ti, m, n);
+                                            
+                                            Spine[tv->tolevel_tl].singcode = SpTLliststart->pathsingcode;
+                                            has_nexttcell = TargetCellFirstPath(SpTLliststart, NextPart, tv);
+                                            PRINT_EXPPATHSTEP(SpTLliststart, TRUE)
+                                        }
+                                        if (NextPart->cells < n) {
+                                            PRINTF2("CStage0 3: %d\n", tv->finalnumcells);
+                                            tv->finalnumcells = min(NextPart->cells,tv->finalnumcells);    /* 160712 */
+                                            PRINTF2("CStage0 3<: %d\n", tv->finalnumcells);
+                                        }
+                                        
+                                        PRINTF2("CS0 2?: finalnumcells: %d\n", tv->finalnumcells);
+                                        if (NextPart->cells == tv->finalnumcells) {
+                                            UPDATEMIN(tv->expathlength, tv->tolevel_tl);
+                                        }
+                                        
+                                        if (tv->options->verbosity >= 2) tv->expaths += CPUTIME;
+                                        
+                                        tv->firstpathlength = tv->tolevel_tl;
+                                        PRINT_RETURN
+                                        if (!tv->strategy && !tv->options->getcanon && (NextPart->cells == tv->finalnumcells) && (tv->tolevel_tl == tv->tolevel + 1) && ((NextPart->cells != tv->finalnumcells) || (NextPart->cells == n))) {
+                                            tv->maxtreelevel = tv->tolevel_tl;
+                                            if ((tv->tolevel == 1) && (CurrPart->cls[tv->tcell] > 5)) {
+                                                EXITFROMSTAGE0EXPATH2
+                                            }
+                                            else {
+                                                temp = 0;
+                                                for (i=0; i<tv->tolevel; i++) {
+                                                    temp += Spine[i].listcounter;
+                                                }
+                                                if (temp > 5) {
+                                                    EXITFROMSTAGE0EXPATH2
+                                                }
+                                            }
+                                        }
+                                        memcpy(TEMPLAB, SpTLliststart->lab, n*sizeof(int));
+                                        memcpy(TEMPINVLAB, SpTLliststart->invlab, n*sizeof(int));
+                                        tv->conta5++;
+                                    }
+                                    else {
+                                        PRINT_RETURN
+                                    }
+                                }
+                                
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                } /* end for */
+            }
+        }
+    }
+    
+    /* REMOVE CURRENT CANDIDATE */
+    if (SpineFL->liststart && (k >= SpineTL->tgtend)) {
+        SpineFL->liststart = CurrCand->next;
+        if (CurrCand->next == NULL) {
+            SpineFL->listend = NULL;
+        }
+        SpineFL->listcounter--;
+        CurrCand->next = GarbList;
+        GarbList = CurrCand;
+    }
+    ti->thereisnextlevel = SelectNextLevel(n, tv, ti);
+    return 0;
+}
+
+int CompStage1(Partition *CurrPart, Partition *NextPart, Candidate *CurrCand, Candidate *NextCand,
+               int m, int n,
+               struct TracesVars* tv, struct TracesInfo *ti) {
+    int i, k, cu, cu1, tmp, gom_level, search_vtx, temp;
+    searchtrie *TreeNode, *TrieNode;
+    
+#ifdef NAUTY_IN_MAGMA
+    if (main_seen_interrupt) return NAUTY_KILLED;
+#else
+    if (nauty_kill_request) return NAUTY_KILLED;
+#endif
+    
+    CurrCand->stnode = tv->newst_stage1;
+    
+    tv->tolevel++;
+    SpineTL = Spine+tv->tolevel;
+    tv->tcell = SpineTL->tgtcell;
+    SpineTL->levelcounter = 0;
+    SpineTL->keptcounter = 0;
+    SpineTL->updates = 1;
+    
+    
+    if (tv->options->verbosity >= 2) {
+        LINE(32, "=")
+        NEXTLINE
+    }
+    
+    memset(RefCells, 0, n*sizeof(int));
+    memset(MultRefCells, 0, n*sizeof(int));
+    ti->thegrouphaschanged = TRUE;
+    
+    /*  CANDIDATE */
+    memcpy(NextCand->lab, CurrCand->lab, n*sizeof(int));
+    memcpy(NextCand->invlab, CurrCand->invlab, n*sizeof(int));
+    NextCand->do_it = TRUE;
+    SpineTL->trcstart = CurrPart->cells;
+    
+    tv->indivstart = tv->tcell;
+    tv->indivend = SpineTL->tgtend;
+    if (TheGraph[CurrCand->lab[tv->indivstart]].d == 1) {
+        tv->indivstart = SpineTL->tgtend-1;
+    }
+    
+    FixBase(fix, tv, NextCand, 0, tv->fromlevel);
+    
+    if (!ti->identitygroup) {
+        if (tv->options->verbosity >= 2) tv->schreier2 -= CPUTIME;
+        tv->currorbit = getorbits(fix, tv->nfix, gpB, &gensB, n);
+        if (tv->options->verbosity >= 2) tv->schreier2 += CPUTIME;
+    }
+    else {
+        if (n / CurrPart->cls[tv->tcell] < 256) {
+            memcpy(tv->currorbit, IDENTITY_PERM, n*sizeof(int));
+        }
+        else {
+            for (k = tv->indivstart; k < tv->indivend; k++) {
+                tv->currorbit[CurrCand->lab[k]] = CurrCand->lab[k];
+            }
+        }
+    }
+    
+    if (!CurrCand->sortedlab) {
+        quickSort(CurrCand->lab+tv->tcell, CurrPart->cls[tv->tcell]);
+        for (i=tv->tcell; i<tv->tcell+CurrPart->cls[tv->tcell]; i++) {
+            CurrCand->invlab[CurrCand->lab[i]] = i;
+        }
+        CurrCand->sortedlab = TRUE;
+    }
+    for (k = tv->indivstart; k < tv->indivend; k++) {
+        NextCand->vertex = CurrCand->lab[k];
+        NextCand->name = ++tv->name;
+        if (NextCand->name == (NAUTY_INFINITY-2)) {
+            NextCand->name = tv->name = 1;
+        }
+        if (tv->currorbit[CurrCand->lab[k]] != CurrCand->lab[k]) {
+            search_vtx = tv->currorbit[NextCand->vertex];
+            TreeNode = CurrCand->stnode;
+            if (TreeNode->first_child) {
+                TreeNode = TreeNode->first_child;
+                while (TreeNode) {
+                    if (TreeNode->vtx == search_vtx) {
+                        break;
+                    }
+                    TreeNode = TreeNode->next_sibling;
+                }
+                if (TreeNode) {
+                    while (TreeNode->goes_to) {
+                        TreeNode = TreeNode->goes_to;
+                    }
+                    TreeNode->index++;
+                    PRINT_INDEX(TreeNode,4,27)
+                }
+            }
+            continue;
+        }
+        PRINT_REFINE_VERB(4,'b')
+        memcpy(NextPart->cls, CurrPart->cls, n*sizeof(int));
+        memcpy(NextPart->inv, CurrPart->inv, n*sizeof(int));
+        
+        Individualize(NextPart, NextCand, CurrCand->lab[k], tv->tcell, CurrPart->cells, SpineTL->tgtpos);
+        
+        tv->stats->numnodes++;
+        SpineTL->levelcounter++;
+        tv->tolevel_tl = tv->tolevel;
+        trieref = trieroot;
+        SpineTL->levelcounter++;
+        
+        traces_refine_maketrie(NextCand,
+                               n,
+                               NextPart, tv, ti);
+        
+        RefCells[CurrCand->lab[k]] = NextPart->cells;
+        PRINTF2("CS1 1?: finalnumcells: %d\n", tv->finalnumcells);
+        if ((NextPart->cells == tv->finalnumcells) || (NextPart->cells == n)) {
+            if (tv->options->verbosity >= 2) PRINT_CANDIDATE(NextCand, tv->tolevel);
+            
+            /* ANY AUTOMORPHISM? */
+            if (tv->options->verbosity >= 2) tv->autchk -= CPUTIME;
+            
+            PRINTF2("CS1 2?: finalnumcells: %d\n", tv->finalnumcells);
+            CheckForAutomorphisms(CurrCand, NextCand, tv, ti, m, n, NextPart);
+            if (tv->options->verbosity >= 2) tv->autchk += CPUTIME;
+            
+            PRINT_RETURN
+            
+            /* ADD TO NEXT LEVEL */
+            SpineTL->keptcounter++;
+            if (!Spine[tv->tolevel].listend) COPYPART(Spine[tv->tolevel].part, NextPart);
+            ADDTONEXTLEVEL;
+            searchtrie_make(CurrCand, SpineTL->listend, n, tv);
+        }
+    } /* end for */
+    PRINTF2("CS1 3: finalnumcells: %d\n", tv->finalnumcells);
+    for (k = tv->indivstart; k < tv->indivend; k++) {
+        MultRefCells[RefCells[tv->currorbit[CurrCand->lab[k]]] % n]++;
+    }
+    
+    if (tv->options->verbosity >= 2) {
+        if (MultRefCells[0]) {
+            fprintf(outfile, tv->digstring, n);
+            fprintf(outfile, "cells: %d; ", MultRefCells[0]);
+        }
+        for (k=1; k<n; k++) {
+            if (MultRefCells[k]) {
+                fprintf(outfile, tv->digstring, k);
+                fprintf(outfile, "cells: %d; ", MultRefCells[k]);
+            }
+        }
+        NEXTLINE
+        
+    }
+    
+#if !MAXN
+    DYNALLOC1(searchtrie*, RefPath, RefPath_sz, tv->tolevel, "Traces-CS1");
+#endif
+    
+    TreeNode = CurrCand->stnode;
+    while (TreeNode) {
+        RefPath[TreeNode->level] = TreeNode;
+        TreeNode = TreeNode->father;
+    }
+    
+    /* REMOVE CURRENT CANDIDATE */
+    SpineFL->liststart = CurrCand->next;
+    if (CurrCand->next == NULL) {
+        SpineFL->listend = NULL;
+        SpineFL->listcounter = 1;
+    }
+    SpineFL->listcounter--;
+    CurrCand->next = GarbList;
+    GarbList = CurrCand;
+    
+    if (tv->options->verbosity >= 2) {
+        LINE(32, "=")
+        NEXTLINE
+    }
+    tv->compstage = 2;
+    tv->steps = n;
+    
+    if (tv->options->verbosity >= 2) tv->schreier1 -= CPUTIME;
+    
+    gom_level = getorbitsmin(fix, tv->nfix, gpB, &gensB, &tv->currorbit,
+                             CurrCand->lab+tv->tcell, CurrPart->cls[tv->tcell], n, TRUE);
+    if (tv->options->verbosity >= 2) tv->schreier1 += CPUTIME;
+    ORBITSIZES
+    ti->thereisnextlevel = SelectNextLevel(n, tv, ti);
+    PRINTF2("CS1 4: finalnumcells: %d\n", tv->finalnumcells);
+    SpineTL->part->cells = tv->finalnumcells;
+    
+    AutomCount[0] = 2;
+    AutomCount[1] = CurrCand->vertex;
+    
+    return 0;
+}
+
+int CompStage2(Partition *CurrPart, Partition *NextPart, Candidate *CurrCand, Candidate *NextCand,
+               int m, int n,
+               struct TracesVars* tv, struct TracesInfo *ti) {
+    int i, j, i1, j2, k, cu, cu1, vertex, gom_level;
+    int temp, tmp, autom;
+    Candidate *AuxCand;
+    searchtrie *TreeNode, *TreeNode1, *TreeNode2;
+    int *CuOrb,*AuxOrb;
+    boolean has_nexttcell = FALSE;
+    searchtrie *TrieNode;
+    boolean schreierwrong;
+    
+#ifdef NAUTY_IN_MAGMA
+    if (main_seen_interrupt) return NAUTY_KILLED;
+#else
+    if (nauty_kill_request) return NAUTY_KILLED;
+#endif
+    
+    autom = 0;
+    schreierwrong = FALSE;
+    
+    TreeNode = CurrCand->stnode;
+    tv->cand_level = 0;
+    
+    while (TreeNode) {
+        if (TreeNode->goes_to) {
+            CurrCand->do_it = FALSE;
+        }
+        if (!tv->cand_level && TreeNode == RefPath[TreeNode->level]) {
+            tv->cand_level = TreeNode->level;
+        }
+        TreeNode = TreeNode->father;
+    }
+    if (tv->cand_level+1 == tv->maxtreelevel) {
+        ti->useTempOrbits1 = TRUE;
+    }
+    else {
+        ti->useTempOrbits1 = FALSE;
+    }
+    if (tv->cand_level == tv->fromlevel) {
+        ti->useTempOrbits2 = TRUE;
+    }
+    else {
+        ti->useTempOrbits2 = FALSE;
+    }
+    
+    PRINT_FROM_VERB(4,tv->tolevel)
+    
+    if (CurrCand->do_it) {
+        if (tv->tolevel == 0) {
+            tv->fromlevel = tv->tolevel;
+            SpineFL = Spine+tv->fromlevel;
+            vertex = Spine[tv->maxtreelevel+1].liststart->lab[Spine[1].tgtpos];
+            k = n;
+            
+            if (TargetCell(CurrCand, CurrPart, n, tv, tv->tolevel)) {
+                ++tv->tolevel;
+                SpineTL = Spine+tv->tolevel;
+                SpineTL->tgtcell = tv->tcell;
+                SpineTL->tgtsize = CurrPart->cls[tv->tcell];
+                SpineTL->tgtend = tv->tcell+SpineTL->tgtsize;
+                SpineTL->tgtpos = SpineTL->tgtend - 1;
+            }
+            else {
+                PRINTF2("CStage2 1: %d\n", tv->finalnumcells);
+                tv->finalnumcells = min(CurrPart->cells,tv->finalnumcells);    /* 160712 */
+                return 0;
+            }
+            
+            memcpy(NextCand->lab, CurrCand->lab, n*sizeof(int));
+            memcpy(NextCand->invlab, CurrCand->invlab, n*sizeof(int));
+            SpineTL->trcstart = CurrPart->cells;
+            TheTrace[SpineTL->trcstart] = SpineTL->tgtpos;
+            
+            tv->indivstart = tv->tcell+CurrCand->indnum;
+            tv->indivend = tv->indivstart+tv->steps;
+            if (tv->indivend > SpineTL->tgtend) {
+                tv->indivend = SpineTL->tgtend;
+            }
+            memset(CurrRefCells, 0, n*sizeof(int));
+            ti->thegrouphaschanged = TRUE;
+            
+            if (!CurrCand->sortedlab) {
+                quickSort(CurrCand->lab+tv->tcell, CurrPart->cls[tv->tcell]);
+                for (i=tv->tcell; i<tv->tcell+CurrPart->cls[tv->tcell]; i++) {
+                    CurrCand->invlab[CurrCand->lab[i]] = i;
+                }
+                CurrCand->sortedlab = TRUE;
+            }
+            
+            for (k = tv->indivstart; k < tv->indivend; k++) {
+                if ((tv->orbits[CurrCand->lab[k]] == CurrCand->lab[k]) && ((tv->finalnumcells < n) || (OrbSize[tv->orbits[CurrCand->lab[k]]] >= OrbSize[tv->orbits[vertex]]))) {
+                    
+                    CurrCand->indnum++;
+                    NextCand->singcode = CurrCand->singcode;
+                    NextCand->vertex = CurrCand->lab[k];
+                    NextCand->name = ++tv->name;
+                    if (NextCand->name == (NAUTY_INFINITY-2)) {
+                        NextCand->name = tv->name = 1;
+                    }
+                    
+                    if (ti->thegrouphaschanged) {
+                        if (tv->fromlevel == tv->maxtreelevel) {
+                            CURRORBITSIZES
+                        }
+                        ti->thegrouphaschanged = FALSE;
+                    }
+                    
+                    if (tv->currorbit[CurrCand->lab[k]] != CurrCand->lab[k]) {
+                        continue;
+                    }
+                    
+                    memcpy(NextPart->cls, CurrPart->cls, n*sizeof(int));
+                    memcpy(NextPart->inv, CurrPart->inv, n*sizeof(int));
+                    if (NextPart->cls[tv->tcell] == 2) {
+                        NextCand->singcode = MASHCOMM(NextCand->singcode, CurrCand->lab[tv->tcell]);
+                        NextCand->singcode = MASHCOMM(NextCand->singcode, CurrCand->lab[tv->tcell+1]);
+                    }
+                    else {
+                        NextCand->singcode = MASHCOMM(NextCand->singcode, CurrCand->lab[k]+labelorg);
+                    }
+                    
+                    Individualize(NextPart, NextCand, CurrCand->lab[k], tv->tcell, CurrPart->cells, SpineTL->tgtpos);
+                    
+                    tv->stats->numnodes++;
+                    Spine[tv->tolevel+1].levelcounter++;
+                    if (tv->fromlevel == tv->maxtreelevel) {
+                        tv->tolevel_tl = tv->tolevel;
+                        trieref = trieroot;
+                        
+                        tv->answ = traces_refine_comptrie(NextCand,
+                                                          n,
+                                                          NextPart, tv, ti);
+                        if (tv->answ) {
+                            if (NextPart->cells != tv->finalnumcells) {
+                                CurrRefCells[NextPart->cells % n] += CurrOrbSize[CurrCand->lab[k]];
+                                if (CurrRefCells[NextPart->cells % n] > MultRefCells[NextPart->cells % n]) {
+                                    k = n;
+                                    break;
+                                }
+                                continue;
+                            }
+                            if (tv->options->verbosity >= 2) PRINT_CANDIDATE(NextCand, tv->tolevel)
+                                }
+                    }
+                    else {
+                        tv->answ = traces_refine_sametrace(NextCand,
+                                                           n,
+                                                           NextPart, tv, ti);
+                        
+                        if (tv->answ) {
+                            if (tv->options->verbosity >= 2) PRINT_CANDIDATE(NextCand, tv->tolevel)
+                                if (tv->tolevel == tv->maxtreelevel) {
+                                    tv->tolevel_tl = tv->tolevel;
+                                    if (tv->options->verbosity >= 2) tv->expaths -= CPUTIME;
+                                    TargetCellExpPath(NextCand, NextPart, tv);
+                                    ExperimentalStep(NextPart, NextCand, tv, ti, m, n);
+                                    PRINT_EXPPATHSTEP(NextCand, tv->answ)
+                                    PRINTF2("CS2 1?: finalnumcells: %d\n", tv->finalnumcells);
+                                    if ((NextPart->cells == tv->finalnumcells) || (NextPart->cells == n)) {
+                                        UPDATEMIN(tv->expathlength, tv->tolevel_tl);
+                                    }
+                                    
+                                    if (tv->options->verbosity >= 2) tv->expaths += CPUTIME;
+                                    if (!tv->answ) {
+                                        PRINT_RETURN
+                                    }
+                                }
+                        }
+                    }
+                    if (tv->answ) {
+                        PRINTF2("CS2 2?: finalnumcells: %d\n", tv->finalnumcells);
+                        if ((NextPart->cells == tv->finalnumcells) || (NextPart->cells == n)) {
+                            if (tv->options->verbosity >= 2) tv->autchk -= CPUTIME;
+                            temp = (tv->tolevel_tl == tv->tolevel+1);
+                            autom = CheckForAutomorphisms(CurrCand, NextCand,
+                                                          tv, ti, temp, n, NextPart);
+                            if (tv->options->verbosity >= 2) tv->autchk += CPUTIME;
+                            
+                            if (ti->thegrouphaschanged) {
+                                ORBITSIZES
+                            }
+                        }
+                        PRINT_RETURN
+                        
+                        /* ADD TO NEXT LEVEL */
+                        PRINTF2_2("CS2 3?: cells: %d, finalnumcells: %d\n", NextPart->cells, tv->finalnumcells);
+                        if ((NextPart->cells != tv->finalnumcells) || (tv->tolevel != tv->maxtreelevel) || (tv->tolevel_tl != tv->tolevel+1)) {
+                            ADDTONEXTLEVEL;
+                            searchtrie_make(CurrCand, SpineTL->listend, n, tv);
+                        }
+                    }
+                    else {
+                        tv->stats->interrupted++;
+                    }
+                    if (tv->fromlevel == tv->maxtreelevel) {
+                        k = n;
+                        break;
+                    }
+                }
+            } /* end for */
+        }
+        else {
+            
+            temp = CurrCand->lab[Spine[1].tgtpos];
+            vertex = Spine[tv->maxtreelevel+1].liststart->lab[Spine[1].tgtpos];
+            k = n;
+            
+            if (tv->cand_level ||
+                ((tv->orbits[temp] == temp) && ((tv->finalnumcells < n) || (OrbSize[tv->orbits[temp]] >= OrbSize[tv->orbits[vertex]])))) {
+                tv->fromlevel = tv->tolevel;
+                SpineFL = Spine+tv->fromlevel;
+                
+                if (TargetCell(CurrCand, CurrPart, n, tv, tv->tolevel)) {
+                    tv->tcellevel = ++tv->tolevel;
+                    SpineTL = Spine+tv->tolevel;
+                    SpineTL->tgtcell = tv->tcell;
+                    SpineTL->tgtsize = CurrPart->cls[tv->tcell];
+                    SpineTL->tgtend = tv->tcell+SpineTL->tgtsize;
+                    SpineTL->tgtpos = SpineTL->tgtend - 1;
+                }
+                else {
+                    PRINTF2("CStage2 2: %d\n", tv->finalnumcells);
+                    tv->finalnumcells = min(CurrPart->cells,tv->finalnumcells);    /* 160712 */
+                    PRINTF2("CStage2 2<: %d\n", tv->finalnumcells);
+                    return 0;
+                }
+                ti->minimalinorbits = TRUE;
+                
+                if (!ti->identitygroup) {
+                    
+                    if (ti->useTempOrbits1 && ti->useTempOrbits2) {
+                        CuOrb = TempOrbits;
+                    }
+                    else {
+                        FixBase(fix, tv, CurrCand, 0, tv->fromlevel);
+                        if (ti->useTempOrbits1 && tv->fromlevel == tv->maxtreelevel) {
+                            tv->currorbit = getorbits(fix, tv->nfix, gpB, &gensB, n);
+                            CuOrb = tv->currorbit;
+                        }
+                        else {
+                            if (tv->options->verbosity >= 2) tv->schreier1 -= CPUTIME;
+                            
+                            gom_level = getorbitsmin(fix, tv->nfix, gpB, &gensB, &tv->currorbit,
+                                                     CurrCand->lab+tv->tcell, CurrPart->cls[tv->tcell], n, TRUE);
+                            if (tv->options->verbosity >= 2) tv->schreier1 += CPUTIME;
+                            
+                            CuOrb = tv->currorbit;
+                            if (gom_level < tv->nfix) {
+                                PRINT_NOTMIN_VERB(4)
+                                if (ti->useTempOrbits1) {
+                                    for (i=1; i<AutomCount[0]; i++) if (AutomCount[i] == CuOrb[tv->currorbit[CurrCand->vertex]]) break;
+                                    if (i < AutomCount[0]) {
+                                        AutomCount[AutomCount[0]++] = CurrCand->vertex;
+                                    }
+                                    ti->minimalinorbits = FALSE;
+                                }
+                                else {
+                                    TreeNode = CurrCand->stnode;
+                                    j2 = CurrCand->lab[Spine[gom_level+1].tgtpos];
+                                    i1 = tv->currorbit[j2];
+                                    for (j=0; j < tv->nfix - gom_level; j++) {
+                                        TreeNode = TreeNode->father;
+                                    }
+                                    TreeNode1 = TreeNode->first_child;
+                                    while (TreeNode1) {
+                                        if (TreeNode1->vtx == i1) {
+                                            break;
+                                        }
+                                        TreeNode1 = TreeNode1->next_sibling;
+                                    }
+                                    schreierwrong = FALSE;
+                                    if (TreeNode1) {
+                                        while (TreeNode1->goes_to) {
+                                            TreeNode1 = TreeNode1->goes_to;
+                                        }
+                                        TreeNode2 = TreeNode->first_child;
+                                        while (TreeNode2->vtx != j2) {
+                                            TreeNode2 = TreeNode2->next_sibling;
+                                        }
+                                        
+                                        TreeNode1->index += TreeNode2->index;
+                                        TreeNode2->goes_to = TreeNode1;
+                                        PRINT_INDEX(TreeNode1,4,28)
+                                        PRINT_INDEX(TreeNode2,4,29)
+                                        ti->minimalinorbits = FALSE;
+                                    }
+                                    else {
+                                        tv->currorbit = getorbits(fix, tv->nfix, gpB, &gensB, n);
+                                        schreierwrong = TRUE;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    ti->thegrouphaschanged = FALSE;
+                }
+                else {
+                    CuOrb = IDENTITY_PERM;
+                }
+                
+                if (ti->minimalinorbits) {
+                    memcpy(NextCand->lab, CurrCand->lab, n*sizeof(int));
+                    memcpy(NextCand->invlab, CurrCand->invlab, n*sizeof(int));
+                    SpineTL->trcstart = CurrPart->cells;
+                    TheTrace[SpineTL->trcstart] = SpineTL->tgtpos;
+                    
+                    tv->indivstart = tv->tcell+CurrCand->indnum;
+                    tv->indivend = tv->indivstart+tv->steps;
+                    if (tv->indivend > SpineTL->tgtend) {
+                        tv->indivend = SpineTL->tgtend;
+                    }
+                    memset(CurrRefCells, 0, n*sizeof(int));
+                    ti->thegrouphaschanged = TRUE;
+                    
+                    if (!CurrCand->sortedlab) {
+                        quickSort(CurrCand->lab+tv->tcell, CurrPart->cls[tv->tcell]);
+                        for (i=tv->tcell; i<tv->tcell+CurrPart->cls[tv->tcell]; i++) {
+                            CurrCand->invlab[CurrCand->lab[i]] = i;
+                        }
+                        CurrCand->sortedlab = TRUE;
+                    }
+                    
+                    for (k = tv->indivstart; k < tv->indivend; k++) {
+                        CurrCand->indnum++;
+                        NextCand->singcode = CurrCand->singcode;
+                        NextCand->vertex = CurrCand->lab[k];
+                        NextCand->name = ++tv->name;
+                        if (NextCand->name == (NAUTY_INFINITY-2)) {
+                            NextCand->name = tv->name = 1;
+                        }
+                        
+                        if (ti->thegrouphaschanged) {
+                            if (tv->fromlevel == tv->maxtreelevel) {
+                                CURRORBITSIZES
+                            }
+                            ti->thegrouphaschanged = FALSE;
+                        }
+                        
+                        if (!schreierwrong) {
+                            if (CuOrb[CurrCand->lab[k]] != CurrCand->lab[k]) {
+                                continue;
+                            }
+                        }
+                        
+                        memcpy(NextPart->cls, CurrPart->cls, n*sizeof(int));
+                        memcpy(NextPart->inv, CurrPart->inv, n*sizeof(int));
+                        if (NextPart->cls[tv->tcell] == 2) {
+                            NextCand->singcode = MASHCOMM(NextCand->singcode, CurrCand->lab[tv->tcell]);
+                            NextCand->singcode = MASHCOMM(NextCand->singcode, CurrCand->lab[tv->tcell+1]);
+                        }
+                        else {
+                            NextCand->singcode = MASHCOMM(NextCand->singcode, CurrCand->lab[k]);
+                        }
+                        
+                        Individualize(NextPart, NextCand, CurrCand->lab[k], tv->tcell, CurrPart->cells, SpineTL->tgtpos);
+                        
+                        tv->stats->numnodes++;
+                        Spine[tv->tolevel+1].levelcounter++;
+                        if (tv->fromlevel == tv->maxtreelevel) {
+                            tv->tolevel_tl = tv->tolevel;
+                            trieref = trieroot;
+                            
+                            tv->answ = traces_refine_comptrie(NextCand,
+                                                              n,
+                                                              NextPart, tv, ti);
+                            
+                            if (tv->answ) {
+                                PRINTF2("CS2 4?: finalnumcells: %d\n", tv->finalnumcells);
+                                if (NextPart->cells != tv->finalnumcells) {
+                                    CurrRefCells[NextPart->cells % n] += CurrOrbSize[CurrCand->lab[k]];
+                                    if (CurrRefCells[NextPart->cells % n] > MultRefCells[NextPart->cells % n]) {
+                                        k = n;
+                                        break;
+                                    }
+                                    continue;
+                                }
+                                if (tv->options->verbosity >= 2) PRINT_CANDIDATE(NextCand, tv->tolevel);
+                            }
+                        }
+                        else
+                        {
+                            tv->answ = traces_refine_sametrace(NextCand,
+                                                               n,
+                                                               NextPart, tv, ti);
+                            
+                            if (tv->answ) {
+                                if (tv->options->verbosity >= 2) PRINT_CANDIDATE(NextCand, tv->tolevel)
+                                    if (tv->tolevel == tv->maxtreelevel) {
+                                        tv->tolevel_tl = tv->tolevel;
+                                        if (tv->options->verbosity >= 2) tv->expaths -= CPUTIME;
+                                        if (TargetCellExpPath(NextCand, NextPart, tv)) {
+                                            ExperimentalStep(NextPart, NextCand, tv, ti, m, n);
+                                            PRINT_EXPPATHSTEP(NextCand, tv->answ)
+                                            PRINTF2("CS2 5?: finalnumcells: %d\n", tv->finalnumcells);
+                                            if ((NextPart->cells == tv->finalnumcells) || (NextPart->cells == n)) {
+                                                UPDATEMIN(tv->expathlength, tv->tolevel_tl);
+                                            }
+                                            
+                                        }
+                                        if (tv->options->verbosity >= 2) tv->expaths += CPUTIME;
+                                        if (!tv->answ) {
+                                            PRINT_RETURN
+                                        }
+                                    }
+                            }
+                        }
+                        if (tv->answ) {
+                            PRINTF2("CS2 6?: finalnumcells: %d\n", tv->finalnumcells);
+                            if ((NextPart->cells == tv->finalnumcells) || (NextPart->cells == n)) {
+                                if (tv->options->verbosity >= 2) tv->autchk -= CPUTIME;
+                                temp = (tv->tolevel_tl == tv->tolevel+1);
+                                autom = CheckForAutomorphisms(CurrCand, NextCand,
+                                                              tv, ti, temp, n, NextPart);
+                                if (tv->options->verbosity >= 2) tv->autchk += CPUTIME;
+                                if (autom) {
+                                    for (i=autom; i<=tv->maxtreelevel; i++) {
+                                        AuxCand = Spine[i].liststart;
+                                        while (AuxCand && Prefix(AuxCand, NextCand, autom)) {
+                                            AuxCand->do_it = FALSE;
+                                            AuxCand = AuxCand->next;
+                                        }
+                                    }
+                                    if (autom == tv->tolevel) {
+                                        autom = 0;
+                                    }
+                                }
+                                
+                                if (ti->thegrouphaschanged) {
+                                    ORBITSIZES
+                                }
+                            }
+                            PRINT_RETURN
+                            
+                            /* ADD TO NEXT LEVEL */
+                            PRINTF2("CS2 7?: finalnumcells: %d\n", tv->finalnumcells);
+                            if ((NextPart->cells != tv->finalnumcells) || (tv->tolevel != tv->maxtreelevel) || (tv->tolevel_tl != tv->tolevel+1)) {
+                                ADDTONEXTLEVEL;
+                                searchtrie_make(CurrCand, SpineTL->listend, n, tv);
+                            }
+                        }
+                        else {
+                            tv->stats->interrupted++;
+                        }
+                        if (autom) {
+                            k = n;
+                            autom = 0;
+                            break;
+                        }
+                        if (tv->fromlevel == tv->maxtreelevel) {
+                            k = n;
+                            break;
+                        }
+                    } /* end for */
+                    TreeNode = RefPath[tv->maxtreelevel];
+                }
+            }
+            else SpineTL = &Spine[tv->tolevel+1];
+        }
+        
+    }
+    
+    /* REMOVE CURRENT CANDIDATE */
+    if (!CurrCand->do_it || k >= SpineTL->tgtend) {
+        SpineFL->liststart = CurrCand->next;
+        if (CurrCand->next == NULL) {
+            SpineFL->listend = NULL;
+        }
+        CurrCand->next = GarbList;
+        GarbList = CurrCand;
+    }
+    ti->thereisnextlevel = SelectNextLevel(n, tv, ti);
+    return 0;
+}
+
+void CopyCand(Candidate *W, Candidate *V,int n, int *lab, int *invlab) {
+    
+    if (lab) {
+        memcpy(W->lab, lab, n*sizeof(int));
+        memcpy(W->invlab, invlab, n*sizeof(int));
+    }
+    else {
+        memcpy(W->lab, V->lab, n*sizeof(int));
+        memcpy(W->invlab, V->invlab, n*sizeof(int));
+    }
+    W->name = V->name;
+    W->vertex = V->vertex;
+    W->code = V->code;
+    W->singcode = V->singcode;
+    W->firstsingcode = V->firstsingcode;
+    W->do_it = V->do_it;
+    W->sortedlab = FALSE;
+}
+
+sparsegraph* copy_sg_structure(sparsegraph *sg2, sparsegraph *sg1) {
+    int *d1, *e1, *d2, *e2;
+    int i, n;
+    size_t *v1, *v2, k;
+    
+    if (!sg2)
+    {
+        if ((sg2 = (sparsegraph*)ALLOCS(1, sizeof(sparsegraph))) == NULL)
+        {
+            fprintf(ERRFILE, "copy_sg: malloc failed\n");
+            exit(1);
+        }
+        SG_INIT(*sg2);
+    }
+    
+    SG_VDE(sg1, v1, d1, e1);
+    
+    n = sg1->nv;
+    
+    k = 0;
+    for (i = 0; i < n; ++i)
+        if (v1[i]+d1[i]>k) k = v1[i] + d1[i];
+    SG_ALLOC(*sg2, n, k, "copy_sg malloc");
+    
+    sg2->nv = n;
+    sg2->nde = sg1->nde;
+    sg2->elen = k;
+    /* sg2->wlen = k; */
+    return sg2;
+}
+
+void Edge_Delete(int vertex, int sons, Candidate *Cand, TracesVars *tv) {
+    int d_vtx, j1, temp;
+    int *sge, *sgw;
+    
+    if (TheGraph[vertex].d <= 1) {
+        return;
+    }
+    
+    d_vtx = TheGraph[vertex].d = TheGraph[vertex].d - sons;
+    sge = TheGraph[vertex].e;
+    sgw = TheGraph[vertex].w;
+    
+    for (j1=0; j1<d_vtx; j1++) {
+        if (TheGraph[sge[j1]].one) {
+            while (TheGraph[sge[TheGraph[vertex].d]].d == -1) {
+                (TheGraph[vertex].d)++;
+            }
+            temp = sge[j1];
+            sge[j1] = sge[TheGraph[vertex].d];
+            sge[TheGraph[vertex].d] = temp;
+            if (sgw) {
+                temp = sgw[j1];
+                sgw[j1] = sgw[TheGraph[vertex].d];
+                sgw[TheGraph[vertex].d] = temp;
+            }
+        }
+    }
+    TheGraph[vertex].d = d_vtx;
+}
+
+void ExperimentalStep(Partition *NextPart, Candidate *NextCand,
+                      TracesVars *tv, TracesInfo *ti, int m, int n) {
+    int i, iend, min, tmp;
+    
+    SpineTL_tl = Spine+tv->tolevel_tl;
+    NextPart->active = 1;
+    
+    /* EXPERIMENTAL PATH INDIVIDUALIZATION AND REFINEMENT */
+    if (tv->answ == 2) {
+        min = NextCand->lab[tv->tcellexpath];
+        tmp = tv->tcellexpath;
+        iend = tv->tcellexpath + NextPart->cls[tv->tcellexpath];
+        for (i=tv->tcellexpath + 1; i<iend ; i++) {
+            if (NextCand->lab[i] < min) {
+                min = NextCand->lab[i];
+                tmp = i;
+            }
+        }
+    }
+    else {
+        tmp = tv->tcellexpath+KRAN(NextPart->cls[tv->tcellexpath]);
+    }
+    if (NextPart->cls[tv->tcellexpath] == 2) {
+        NextCand->pathsingcode = MASHCOMM(NextCand->pathsingcode, NextCand->lab[tv->tcellexpath]);
+        NextCand->pathsingcode = MASHCOMM(NextCand->pathsingcode, NextCand->lab[tv->tcellexpath+1]);
+    }
+    else {
+        NextCand->pathsingcode = MASHCOMM(NextCand->pathsingcode, NextCand->lab[tmp]);
+    }
+    
+    tv->indiv_vtx = NextCand->lab[tmp];
+    Individualize(NextPart, NextCand, NextCand->lab[tmp], tv->tcellexpath, NextPart->cells, tv->tcellexpath + NextPart->cls[tv->tcellexpath]-1);
+    
+    tv->stats->numnodes++;
+    if (tv->compstage == 0) {
+        traces_refine_notrace(NextCand,
+                              n,
+                              NextPart, tv, ti);
+    }
+    else {
+        if (tv->tolevel_tl == tv->maxtreelevel+1) {
+            trieref = trieroot;
+            tv->answ = traces_refine_comptrie(NextCand,
+                                              n,
+                                              NextPart, tv, ti);
+            if (tv->answ == 0 ) {
+                tv->stats->interrupted++;
+            }
+        }
+        else {
+            traces_refine_notrace(NextCand,
+                                  n,
+                                  NextPart, tv, ti);
+        }
+    }
+    
+    CodeClassify(tv->tolevel_tl, NextCand->code, tv->tcellexpath);
+    
+}
+
+void factorial(double *size1, int *size2, int k) {
+    int i;
+    
+    for(i = k; i; i--) {
+        MULTIPLY(*size1, *size2, i);
+    }
+}
+
+void factorial2(double *size1, int *size2, int k) {
+    int i;
+    
+    for(i = k; i > 0; i -= 2) {
+        MULTIPLY(*size1, *size2, i);
+    }
+}
+
+boolean findperm(permnode *pn, int *p, int n) {
+    permnode *rn;
+    
+    if (!pn) {
+        return FALSE;
+    }
+    rn = pn;
+    do {
+        if (!memcmp(rn->p, p, n*sizeof(int))) {
+            return TRUE;
+        }
+        rn = rn->next;
+    } while (rn != pn);
+    return FALSE;
+}
+
+int *findcurrorbits(schreier *gp, int k) {
+    int i;
+    schreier *sh;
+    
+    sh = gp;
+    for (i = 0; i < k; i++) {
+        sh = sh->next;
+    }
+    return sh->orbits;
+}
+
+int FirstNeighbour(int vtx, Candidate *Cand, Partition *Part, int* Markers, int mark, int *ngh, int n) {
+    int *e_vtx;
+    int i, k, deg;
+    int ngh1, ngh2, cell1, cell2;
+    
+    k = 0;
+    
+    deg = TheGraph[vtx].d;
+    e_vtx = TheGraph[vtx].e;
+    
+    if (deg == n-1) {
+        return 0;
+    }
+    
+    for (i=0; i<deg; i++) {
+        if (Markers[e_vtx[i]] != mark) {
+            cell1 = Part->inv[Cand->invlab[e_vtx[i]]];
+            if (Part->cls[cell1] > 1) {
+                ngh1 = e_vtx[i++];
+                k++;
+                break;
+            }
+        }
+    }
+    for (; i<deg; i++) {
+        if (Markers[e_vtx[i]] != mark) {
+            cell2 = Part->inv[Cand->invlab[e_vtx[i]]];
+            if (Part->cls[cell2] > 1) {
+                ngh2 = e_vtx[i];
+                k++;
+                break;
+            }
+        }
+    }
+    switch (k) {
+        case 0:
+            break;
+            
+        case 1:
+            *ngh = ngh1;
+            break;
+            
+        case 2:
+            if (cell1 < cell2) {
+                *ngh = ngh1;
+            }
+            else {
+                *ngh = ngh2;
+            }
+            break;
+            
+        default:
+            break;
+    }
+    return k;
+}
+
+int FixBase(int *fix, struct TracesVars *tv, Candidate *Cand, int from, int to) {
+    int i, j, k, go, nfix;
+    
+    nfix = j = 0;
+    go = TRUE;
+    for (i = from; i < to; i++) {
+        k = Cand->lab[Spine[i+1].tgtpos];
+        if (go && (nfix < tv->nfix) && (fix[nfix] == k)) {
+            j++;
+        }
+        else {
+            fix[nfix] = k;
+            if (go) go = FALSE;
+        }
+        nfix++;
+    }
+    tv->nfix = nfix;
+    return j;
+}
+
+boolean FixedBase(int *fix, struct TracesVars *tv, Candidate *Cand, int from, int to) {
+    int i, k, nfix;
+    
+    nfix = 0;
+    for (i = from; i < to; i++) {
+        k = Cand->lab[Spine[i+1].tgtpos];
+        if (fix[nfix] != k) {
+            return FALSE;
+        }
+        nfix++;
+    }
+    return TRUE;
+}
+
+int FreeList(Candidate *List, int cond) {
+    Candidate *Temp;
+    int conta = 0;
+    int conta1 = 0;
+    
+    while (List) {
+        if (List->do_it == cond) {
+            conta1++;
+        }
+        conta++;
+        Temp = List;
+        if (List->lab) free(List->lab);
+        if (List->invlab) free(List->invlab);
+        List = List->next;
+        free(Temp);
+    }
+    
+    if (cond) {
+        return conta1;
+    }
+    else {
+        return conta;
+    }
+}
+
+/* Check if the permutations in the list gens are automorphisms,
+ * also set mark and refcount fields and initialise orbits. */
+int given_gens(sparsegraph *g, permnode *gens, int *orbits, boolean digraph) {
+    int i, m, n, norbs;
+    permnode *pn;
+    
+    n = g->nv;
+    for (i = 0; i < n; ++i) orbits[i] = i;
+    memcpy(IDENTITY_PERM, orbits, n*sizeof(int));
+    norbs = n;
+    
+    if (!gens) return norbs;
+    
+    m = SETWORDSNEEDED(n);
+    pn = gens;
+    do {
+        if (!isautom_sg((graph*)g, pn->p, digraph, m, n)) {
+            fprintf(ERRFILE, "Input permutation is not an automorphism\n");
+            exit(1);
+        }
+        norbs = orbjoin(orbits, pn->p, n);
+        pn->mark = 1;
+        pn->refcount = 0;
+        pn = pn->next;
+    } while (pn != gens);
+    
+    return norbs;
+}
+
+void grouporderplus(sparsegraph *sg_orig, Candidate *Cand, Partition *Part, permnode **ring,
+                    double *grpsize1, int *grpsize2, int n, TracesVars *tv, TracesInfo *ti) {
+    
+    int i, i1, j, j0, j2, k, k1, k2, w, w1, w2, c, c1, c2, n1, n2;
+    int prev, step, start, counts, StInd, CyInd, cycnum;
+    int tmp, temp, halfsize, nghcell, numvertices;
+    int arg, val;
+    
+    searchtrie *TrieNode;
+    int NSFCInd, ind;
+    boolean do_ngh = FALSE;
+    
+    numvertices = n;
+    memcpy(CanonIndices, IDENTITY_PERM, n*sizeof(int));
+    memset(TreeNodes, 0, n*sizeof(int));
+    
+    TrieNode = Spine[tv->maxtreelevel].liststart->stnode;
+    if (TrieNode->father) {
+        if (tv->options->verbosity >= 2) {
+            LINE(32, "—")
+            NEXTLINE
+            fprintf(outfile, "group structure: ");
+            while (TrieNode->father) {
+                if (Factorials[TrieNode->level]) {
+                    fprintf(outfile, "%d (%d!), ", TrieNode->name, TrieNode->index);
+                    factorial(grpsize1, grpsize2, TrieNode->index);
+                } else {
+                    if (TrieNode->father->name) {
+                        fprintf(outfile, "%d (%d), ", TrieNode->name, TrieNode->index);
+                        MULTIPLY(tv->stats->grpsize1, tv->stats->grpsize2, TrieNode->index);
+                    }
+                    else {
+                        temp = spinelementorbsize(tv->orbits, Spine[tv->maxtreelevel].liststart->lab+Spine[1].tgtcell, Spine[1].tgtsize, TrieNode->vtx);
+                        MULTIPLY(*grpsize1, *grpsize2, temp);
+                        fprintf(outfile, "%d (%d)\n",
+                                TrieNode->name, temp);
+                    }
+                }
+                TrieNode = TrieNode->father;
+            }
+        }
+        else {
+            while (TrieNode->father) {
+                if (Factorials[TrieNode->level]) {
+                    factorial(grpsize1, grpsize2, TrieNode->index);
+                } else {
+                    if (TrieNode->father->name) {
+                        MULTIPLY(tv->stats->grpsize1, tv->stats->grpsize2, TrieNode->index);
+                    }
+                    else {
+                        temp = spinelementorbsize(tv->orbits, Spine[tv->maxtreelevel].liststart->lab+Spine[1].tgtcell, Spine[1].tgtsize, TrieNode->vtx);
+                        MULTIPLY(*grpsize1, *grpsize2, temp);
+                    }
+                }
+                TrieNode = TrieNode->father;
+            }
+        }
+    }
+    
+    if (Part->cells < n) {
+        
+        if (!ti->deg_one) {
+            memcpy(tv->graph->e, sg_orig->e, tv->graph->elen*sizeof(int));
+            for (i=0; i<n; i++) {
+                TheGraph[i].e = tv->graph->e + sg_orig->v[i];
+            }
+        }
+        NSFCInd = 0;
+        
+        /* Trees */
+        if (tv->options->getcanon && tv->preprocessed) {
+            for (i = 0; i < n; i += Part->cls[i]) {
+                if (Part->cls[i] == 1) {
+                    tmp = Cand->lab[i];
+                    if ((TheGraph[tmp].d >= 0) && (TheGraph[tmp].d < sg_orig->d[tmp])) {
+                        for (j=i; j<i+Part->cls[i]; j++) {
+                            MakeCanTree(Cand->lab[j], sg_orig, n, Cand, Part, tv);
+                        }
+                    }
+                }
+            }
+        }
+        
+        memset(SingNonSing, 0, n*sizeof(int));
+        
+        for (i = 0; i < n; i += Part->cls[i]) {
+            if (Part->cls[i] > 1) {
+                if (TheGraph[Cand->lab[i]].d > 2) {
+                    for (j=i; j<i+Part->cls[i]; j++) {
+                        SingNonSing[Cand->lab[j]] = 2;
+                    }
+                }
+            }
+            else {
+                SingNonSing[Cand->lab[i]] = 1;
+            }
+        }
+        
+        for (i = 0; i < n; i += Part->cls[i]) {
+            if (Part->cls[i] > 1) {
+                if (TheGraph[Cand->lab[i]].d > 2) NonSingDegPlus1(Cand, Part, i, tv);
+                NSFCells[NSFCInd++] = i;
+            }
+            else {
+                NonSingDegPlus2(Cand, Part, i, tv);
+                numvertices--;
+            }
+        }
+        
+        /* Degree 2 and at least one nghb with deg > 2 */
+        SETMARK(StackMarkers, tv->stackmark)
+        for (ind = 0; ind < NSFCInd; ind++) {
+            i = NSFCells[ind];
+            SETMARK(Markers, tv->mark)
+            if (Part->cls[i] > 1) {
+                tmp = Cand->lab[i];
+                if ((TheGraph[tmp].d == 2) && ((TheGraph[TheGraph[tmp].e[0]].d > 2) || ((TheGraph[TheGraph[tmp].e[1]].d > 2)))) {
+                    n1 = TheGraph[tmp].e[0];
+                    n2 = TheGraph[tmp].e[1];
+                    if (TheGraph[n1].d > 2) {
+                        if (TheGraph[n2].d > 2) {
+                            if (Cand->invlab[n1] < Cand->invlab[n2]) {
+                                start = n1;
+                            }
+                            else {
+                                start = n2;
+                            }
+                        }
+                        else {
+                            start = n1;
+                        }
+                    }
+                    else {
+                        start = n2;
+                    }
+                    counts = 0;
+                    StInd = 0;
+                    for (j=i; j<i+Part->cls[i]; j++) {
+                        step = Cand->lab[j];
+                        if (Markers[step] != tv->mark) {
+                            prev = start;
+                            counts++;
+                            do {
+                                Markers[step] = tv->mark;
+                                PERMSTACK[StInd++] = step;
+                                if (TheGraph[step].e[0] != prev) {
+                                    prev = step;
+                                    step = TheGraph[step].e[0];
+                                }
+                                else {
+                                    prev = step;
+                                    step = TheGraph[step].e[1];
+                                }
+                            } while (TheGraph[step].d == 2);
+                            
+                            if (TheGraph[step].d == 1) {
+                                PERMSTACK[StInd++] = step;
+                            }
+                        }
+                    }
+                    
+                    if (counts == Part->cls[i]) {
+                        factorial(grpsize1, grpsize2, Part->cls[i]);
+                        if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                        for (k=0; k<StInd/counts; k++) {
+                            i1 = PERMSTACK[k];
+                            for (j0=0; j0<counts-1; j0++) {
+                                SETPAIRSAUTANDTREE(PERMSTACK[j0*(StInd/counts)+k], PERMSTACK[(j0+1)*(StInd/counts)+k])
+                            }
+                            SETPAIRSAUTANDTREE(PERMSTACK[j0*(StInd/counts)+k], i1)
+                        }
+                        SPECIALGENERATORS
+                        if (counts > 2) {
+                            if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                            for (k=0; k<StInd/counts; k++) {
+                                i1 = PERMSTACK[k];
+                                for (j0=0; j0<1; j0++) {
+                                    SETPAIRSAUTANDTREE(PERMSTACK[j0*(StInd/counts)+k], PERMSTACK[(j0+1)*(StInd/counts)+k])
+                                }
+                                SETPAIRSAUTANDTREE(PERMSTACK[j0*(StInd/counts)+k], i1)
+                            }
+                            SPECIALGENERATORS
+                        }
+                    }
+                    else {
+                        factorial2(grpsize1, grpsize2, Part->cls[i]);
+                        for (j=0; j<counts; j++) {
+                            j0 = j*(StInd/counts);
+                            k1 = (j+1)*(StInd/counts);
+                            if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                            for (k=j0, i1=k1-1; k<k1; k++, i1--) {
+                                SETPAIRSAUTANDTREE(PERMSTACK[k], PERMSTACK[i1])
+                            }
+                            SPECIALGENERATORS
+                        }
+                        if (counts > 1) {
+                            if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                            for (k=0; k<StInd/counts; k++) {
+                                i1 = PERMSTACK[k];
+                                for (j0=0; j0<counts-1; j0++) {
+                                    SETPAIRSAUTANDTREE(PERMSTACK[j0*(StInd/counts)+k], PERMSTACK[(j0+1)*(StInd/counts)+k])
+                                }
+                                SETPAIRSAUTANDTREE(PERMSTACK[j0*(StInd/counts)+k], i1)
+                            }
+                            SPECIALGENERATORS
+                        }
+                        if (counts > 2) {
+                            if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                            for (k=0; k<StInd/counts; k++) {
+                                i1 = PERMSTACK[k];
+                                for (j0=0; j0<1; j0++) {
+                                    SETPAIRSAUTANDTREE(PERMSTACK[j0*(StInd/counts)+k], PERMSTACK[(j0+1)*(StInd/counts)+k])
+                                }
+                                SETPAIRSAUTANDTREE(PERMSTACK[j0*(StInd/counts)+k], i1)
+                            }
+                            SPECIALGENERATORS
+                        }
+                    }
+                    for (j=0; j<StInd; j++) {
+                        Place(PERMSTACK[j], Cand, Part);
+                        if ((TheGraph[PERMSTACK[j]].d >= 0) && (TheGraph[PERMSTACK[j]].d < sg_orig->d[PERMSTACK[j]])) {
+                            MakeCanTree(PERMSTACK[j], sg_orig, n, Cand, Part, tv);
+                        }
+                    }
+                }
+            }
+        }
+        
+        /* Degree 2 and at least one nghb with == 1 */
+        for (ind = 0; ind < NSFCInd; ind++) {
+            SETMARK(Markers, tv->mark)
+            i = NSFCells[ind];
+            if (Part->cls[i] > 1) {
+                tmp = Cand->lab[i];
+                if ((TheGraph[tmp].d == 2) && ((TheGraph[TheGraph[tmp].e[0]].d == 1) || ((TheGraph[TheGraph[tmp].e[1]].d == 1)))) {
+                    counts = 0;
+                    StInd = 0;
+                    for (j=i; j<i+Part->cls[i]; j++) {
+                        step = Cand->lab[j];
+                        if (Markers[step] != tv->mark) {
+                            n1 = TheGraph[step].e[0];
+                            n2 = TheGraph[step].e[1];
+                            if (TheGraph[n1].d == 1) {
+                                if (TheGraph[n2].d == 1) {
+                                    if (Cand->invlab[n1] < Cand->invlab[n2]) {
+                                        start = n1;
+                                    }
+                                    else {
+                                        start = n2;
+                                    }
+                                }
+                                else {
+                                    start = n1;
+                                }
+                            }
+                            else {
+                                start = n2;
+                            }
+                            PERMSTACK[StInd++] = start;
+                            prev = start;
+                            counts++;
+                            
+                            do {
+                                Markers[step] = tv->mark;
+                                PERMSTACK[StInd++] = step;
+                                if (TheGraph[step].e[0] != prev) {
+                                    prev = step;
+                                    step = TheGraph[step].e[0];
+                                } else {
+                                    prev = step;
+                                    step = TheGraph[step].e[1];
+                                }
+                            } while (TheGraph[step].d == 2);
+                            PERMSTACK[StInd++] = step;
+                        }
+                    }
+                    
+                    if (counts == Part->cls[i]) {
+                        if (Part->inv[Cand->invlab[PERMSTACK[0]]] != Part->inv[Cand->invlab[PERMSTACK[StInd/counts-1]]]) {
+                            factorial(grpsize1, grpsize2, Part->cls[i]);
+                        }
+                        else {
+                            factorial2(grpsize1, grpsize2, 2*Part->cls[i]);
+                            for (j=0; j<counts; j++) {
+                                j0 = j*(StInd/counts);
+                                k1 = (j+1)*(StInd/counts);
+                                if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                                for (k=j0, i1=k1-1; k<k1; k++, i1--) {
+                                    SETPAIRSAUTANDTREE(PERMSTACK[k], PERMSTACK[i1])
+                                }
+                                SPECIALGENERATORS
+                            }
+                        }
+                        if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                        for (k=0; k<StInd/counts; k++) {
+                            i1 = PERMSTACK[k];
+                            for (j0=0; j0<counts-1; j0++) {
+                                SETPAIRSAUTANDTREE(PERMSTACK[j0*(StInd/counts)+k], PERMSTACK[(j0+1)*(StInd/counts)+k])
+                            }
+                            SETPAIRSAUTANDTREE(PERMSTACK[j0*(StInd/counts)+k], i1)
+                        }
+                        SPECIALGENERATORS
+                        if (counts > 2) {
+                            for (k=0; k<StInd/counts; k++) {
+                                i1 = PERMSTACK[k];
+                                for (j0=0; j0<1; j0++) {
+                                    SETPAIRSAUTANDTREE(PERMSTACK[j0*(StInd/counts)+k], PERMSTACK[(j0+1)*(StInd/counts)+k])
+                                }
+                                SETPAIRSAUTANDTREE(PERMSTACK[j0*(StInd/counts)+k], i1)
+                            }
+                            SPECIALGENERATORS
+                        }
+                    }
+                    else {
+                        factorial2(grpsize1, grpsize2, Part->cls[i]);
+                        for (j=0; j<counts; j++) {
+                            j0 = j*(StInd/counts);
+                            k1 = (j+1)*(StInd/counts);
+                            if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                            for (k=j0, i1=k1-1; k<k1; k++, i1--) {
+                                SETPAIRSAUTANDTREE(PERMSTACK[k], PERMSTACK[i1])
+                            }
+                            SPECIALGENERATORS
+                        }
+                        if (counts > 1) {
+                            if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                            for (k=0; k<StInd/counts; k++) {
+                                i1 = PERMSTACK[k];
+                                for (j0=0; j0<counts-1; j0++) {
+                                    SETPAIRSAUTANDTREE(PERMSTACK[j0*(StInd/counts)+k], PERMSTACK[(j0+1)*(StInd/counts)+k])
+                                }
+                                SETPAIRSAUTANDTREE(PERMSTACK[j0*(StInd/counts)+k], i1)
+                            }
+                            SPECIALGENERATORS
+                        }
+                        if (counts > 2) {
+                            if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                            for (k=0; k<StInd/counts; k++) {
+                                i1 = PERMSTACK[k];
+                                for (j0=0; j0<1; j0++) {
+                                    SETPAIRSAUTANDTREE(PERMSTACK[j0*(StInd/counts)+k], PERMSTACK[(j0+1)*(StInd/counts)+k])
+                                }
+                                SETPAIRSAUTANDTREE(PERMSTACK[j0*(StInd/counts)+k], i1)
+                            }
+                            SPECIALGENERATORS
+                        }
+                    }
+                    for (j=0; j<StInd; j++) {
+                        Place(PERMSTACK[j], Cand, Part);
+                        if ((TheGraph[PERMSTACK[j]].d >= 0) && (TheGraph[PERMSTACK[j]].d < sg_orig->d[PERMSTACK[j]])) {
+                            MakeCanTree(PERMSTACK[j], sg_orig, n, Cand, Part, tv);
+                        }
+                    }
+                }
+            }
+        }
+        
+        /* Cycles */
+        for (ind = 0; ind < NSFCInd; ind++) {
+            i = NSFCells[ind];
+            SETMARK(Markers, tv->mark)
+            if (Part->cls[i] > 1) {
+                tmp = Cand->lab[i];
+                if (TheGraph[tmp].d == 2) {
+                    CyInd = StInd = cycnum = 0;
+                    for (j=i; j<i+Part->cls[i]; j++) {
+                        start = Cand->lab[j];
+                        if (Markers[start] != tv->mark) {
+                            counts = 1;
+                            CYCLES[StInd] = start;
+                            CYCOLR[StInd++] = Part->inv[Cand->invlab[start]];
+                            Markers[start] = tv->mark;
+                            k = Cand->invlab[TheGraph[start].e[0]];
+                            k1 = Cand->invlab[TheGraph[start].e[1]];
+                            if (Part->inv[k] < Part->inv[k1]) {
+                                step = TheGraph[start].e[0];
+                            }
+                            else {
+                                step = TheGraph[start].e[1];
+                            }
+                            prev = start;
+                            do {
+                                counts++;
+                                Markers[step] = tv->mark;
+                                CYCLES[StInd] = step;
+                                CYCOLR[StInd++] = Part->inv[Cand->invlab[step]];
+                                
+                                if (TheGraph[step].e[0] != prev) {
+                                    prev = step;
+                                    step = TheGraph[step].e[0];
+                                }
+                                else {
+                                    prev = step;
+                                    step = TheGraph[step].e[1];
+                                }
+                            } while (step != start);
+                            CYLGTH[CyInd++] = counts;
+                            cycnum++;
+                        }
+                    }
+                    
+                    CYCPOS[0] = 0;
+                    for (j=1; j<CyInd; j++) {
+                        CYCPOS[j] = CYCPOS[j-1]+CYLGTH[j-1];
+                    }
+                    memcpy(WorkArray, CYLGTH, CyInd*sizeof(int));
+                    sort2ints(WorkArray, CYCPOS, CyInd);
+                    
+                    k = 0;
+                    for (i1=0; i1<CyInd; i1++) {
+                        k1 = CYCOLR[k];
+                        k2 = CYCOLR[k+1];
+                        for (j=1; j<=CYLGTH[i1]/2; j++) {
+                            w1 = CYCOLR[j+k];
+                            w2 = CYCOLR[j+1+k];
+                            if ((w1 == k1) && (w2 == k2)) {
+                                if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                                for (w=0; w<CYLGTH[i1]; w++) {
+                                    if (CYCOLR[w+k] == CYCOLR[((w+j) % CYLGTH[i1]) + k]) {
+                                        SETPAIRSAUTANDTREE(CYCLES[w+k], CYCLES[((w+j) % CYLGTH[i1]) + k])
+                                    }
+                                    else {
+                                        break;
+                                    }
+                                }
+                                if (w == CYLGTH[i1]) { SPECIALGENERATORS }
+                                if (w == CYLGTH[i1]) {
+                                    MULTIPLY(*grpsize1, *grpsize2, CYLGTH[i1]/j);
+                                    break;
+                                }
+                            }
+                        }
+                        
+                        if (Part->cls[k1] >= Part->cls[k2]) {
+                            for (j=CYLGTH[i1]-1; j>0; j--) {
+                                w1 = CYCOLR[j % CYLGTH[i1] + k];
+                                w2 = CYCOLR[(j-1) % CYLGTH[i1] + k];
+                                if ((w1 == k1) && (w2 == k2)) {
+                                    if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                                    for (w=0; w<CYLGTH[i1]; w++) {
+                                        SETPAIRSAUTANDTREE(CYCLES[w+k], CYCLES[((j-w+(w>j)*CYLGTH[i1]) % CYLGTH[i1]) + k])
+                                    }
+                                    SPECIALGENERATORS
+                                    MULTIPLY(*grpsize1, *grpsize2, 2);
+                                    break;
+                                }
+                            }
+                        }
+                        else {
+                            j=CYLGTH[i1]-1;
+                            w2 = CYCOLR[j % CYLGTH[i1] + k];
+                            if (w2 == k2) {
+                                if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                                for (w=1; w<CYLGTH[i1]; w++) {
+                                    SETPAIRSAUTANDTREE(CYCLES[w+k], CYCLES[CYLGTH[i1]-w+k])
+                                }
+                                SPECIALGENERATORS
+                                MULTIPLY(*grpsize1, *grpsize2, 2);
+                            }
+                        }
+                        k += CYLGTH[i1];
+                    }
+                    k = 0;
+                    for (i1=0; i1<CyInd; i1++) {
+                        if (CYLGTH[i1] > 0) {
+                            CYMULT[0] = k;
+                            k1 = k;
+                            counts = 1;
+                            for (j0=i1+1; j0<CyInd; j0++) {
+                                k1 += abs(CYLGTH[j0]);
+                                if (CYLGTH[j0] == CYLGTH[i1]) {
+                                    CYMULT[counts++] = k1;
+                                    CYLGTH[j0] = -CYLGTH[j0];
+                                }
+                            }
+                            if (counts > 1) {
+                                if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                                for (j0=0; j0<CYLGTH[i1]; j0++) {
+                                    for (j2 = 0; j2<counts-1; j2++) {
+                                        SETPAIRSAUTANDTREE(CYCLES[CYMULT[j2]+j0], CYCLES[CYMULT[j2+1]+j0])
+                                    }
+                                    SETPAIRSAUTANDTREE(CYCLES[CYMULT[j2]+j0], CYCLES[CYMULT[0]+j0])
+                                }
+                                SPECIALGENERATORS
+                                if (counts > 2) {
+                                    if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                                    for (j0=0; j0<CYLGTH[i1]; j0++) {
+                                        SETPAIRSAUTANDTREE(CYCLES[CYMULT[1]+j0], CYCLES[CYMULT[0]+j0])
+                                        if (tv->build_autom) {
+                                            SETPAIRSAUT(CYCLES[CYMULT[0]+j0], CYCLES[CYMULT[1]+j0])
+                                        }
+                                        MakeTree(CYCLES[CYMULT[0]+j0], CYCLES[CYMULT[1]+j0], sg_orig, n, tv, FALSE);
+                                    }
+                                    SPECIALGENERATORS
+                                }
+                                factorial(grpsize1, grpsize2, counts);
+                            }
+                        }
+                        k += abs(CYLGTH[i1]);
+                        CYLGTH[i1] = -CYLGTH[i1];
+                    }
+                    
+                    for (c1=0; c1<CyInd; c1++) {
+                        c = CYCPOS[c1]+WorkArray[c1];
+                        for (c2=CYCPOS[c1]; c2<c; c2++) {
+                            Place(CYCLES[c2], Cand, Part);
+                            if ((TheGraph[CYCLES[c2]].d >= 0) && (TheGraph[CYCLES[c2]].d < sg_orig->d[CYCLES[c2]])) {
+                                MakeCanTree(CYCLES[c2], sg_orig, n, Cand, Part, tv);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        
+        /* Degree 1, and nghb too */
+        SETMARK(Markers, tv->mark)
+        for (ind = 0; ind < NSFCInd; ind++) {
+            i = NSFCells[ind];
+            if (Part->cls[i] > 1) {
+                tmp = Cand->lab[i];
+                if ((TheGraph[tmp].d == 1) && (TheGraph[TheGraph[tmp].e[0]].d == 1) && (i == Part->inv[Cand->invlab[TheGraph[tmp].e[0]]])) {
+                    factorial2(grpsize1, grpsize2, Part->cls[i]);
+                    /* the cell has size two */
+                    if (Part->cls[i] == 2) {
+                        val = Cand->lab[i+1];
+                        if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                        arg = tmp;
+                        SETPAIRSAUTANDTREE(arg, val)
+                        SETPAIRSAUTANDTREE(val, arg)
+                        SPECIALGENERATORS
+                    }
+                    else {
+                        /* the cell has size greater than two */
+                        if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                        SETMARK(Markers, tv->mark)
+                        halfsize = Part->cls[i]/2;
+                        i1 = 0;
+                        for (j=i; j<i+Part->cls[i]; j++) {
+                            if (Markers[Cand->lab[j]] != tv->mark) {
+                                Markers[TheGraph[Cand->lab[j]].e[0]] = tv->mark;
+                                PERMSTACK[i1] = Cand->lab[j];
+                                PERMSTACK[i1+halfsize] = TheGraph[Cand->lab[j]].e[0];
+                                i1++;
+                            }
+                        }
+                        temp = PERMSTACK[0];
+                        for (j=0; j<Part->cls[i]-1; j++) {
+                            SETPAIRSAUTANDTREE(PERMSTACK[j], PERMSTACK[j+1])
+                        }
+                        SETPAIRSAUTANDTREE(PERMSTACK[j], temp)
+                        SPECIALGENERATORS
+                        if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                        memmove(PERMSTACK+halfsize, PERMSTACK+halfsize+1, (halfsize-1)*sizeof(int));
+                        temp = PERMSTACK[1];
+                        for (j=1; j<Part->cls[i]-2; j++) {
+                            SETPAIRSAUTANDTREE(PERMSTACK[j], PERMSTACK[j+1])
+                        }
+                        SETPAIRSAUTANDTREE(PERMSTACK[j], temp)
+                        SPECIALGENERATORS
+                    }
+                    
+                    SETMARK(Markers, tv->mark)
+                    for (j=i; j<i+Part->cls[i]; j++) {
+                        temp = Cand->lab[j];
+                        if (Markers[temp] != tv->mark) {
+                            if ((TheGraph[temp].d >= 0) && (TheGraph[temp].d < sg_orig->d[temp])) {
+                                MakeCanTree(temp, sg_orig, n, Cand, Part, tv);
+                            }
+                            tmp = Cand->lab[j+1];
+                            Markers[TheGraph[temp].e[0]] = tv->mark;
+                            i1 = Cand->invlab[TheGraph[temp].e[0]];
+                            Cand->lab[j+1] = TheGraph[temp].e[0];
+                            
+                            if ((TheGraph[TheGraph[temp].e[0]].d >= 0) && (TheGraph[TheGraph[temp].e[0]].d < sg_orig->d[TheGraph[temp].e[0]])) {
+                                MakeCanTree(TheGraph[temp].e[0], sg_orig, n, Cand, Part, tv);
+                            }
+                            Cand->invlab[TheGraph[temp].e[0]] = j+1;
+                            Cand->lab[i1] = tmp;
+                            Cand->invlab[tmp] = i1;
+                        }
+                    }
+                }
+            }
+        }
+        
+        /* Degree 0 */
+        for (ind = 0; ind < NSFCInd; ind++) {
+            i = NSFCells[ind];
+            if (Part->cls[i] > 1) {
+                tmp = Cand->lab[i];
+                if ((TheGraph[0].e != NULL) && (TheGraph[tmp].d != 0) && (TheGraph[tmp].d != numvertices-1))
+                    nghcell = Part->inv[Cand->invlab[TheGraph[tmp].e[0]]]; else nghcell = i;
+                if ((TheGraph[tmp].d == 0) ||
+                    ((TheGraph[tmp].d == numvertices-1) && (TheGraph[tmp].d > 2)) ||
+                    ((TheGraph[tmp].d == 1) && (TheGraph[TheGraph[tmp].e[0]].d == 1) && (i < nghcell))) {
+                    do_ngh = FALSE;
+                    if ((TheGraph[tmp].d == 1) && (TheGraph[TheGraph[tmp].e[0]].d == 1) && (i != nghcell)) {
+                        do_ngh = TRUE;
+                    }
+                    if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                    for (j=i; j<i+Part->cls[i]-1; j++) {
+                        arg = Cand->lab[j];
+                        val = Cand->lab[j+1];
+                        SETPAIRSAUTANDTREE(arg, val)
+                        if (do_ngh) {
+                            SETPAIRSAUTANDTREE(TheGraph[arg].e[0], TheGraph[val].e[0])
+                            
+                        }
+                    }
+                    arg = Cand->lab[j];
+                    val = tmp;
+                    SETPAIRSAUTANDTREE(arg, val)
+                    if (do_ngh) {
+                        SETPAIRSAUTANDTREE(TheGraph[arg].e[0], TheGraph[val].e[0])
+                    }
+                    SPECIALGENERATORS
+                    if (Part->cls[i] > 2) {
+                        if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                        arg = tmp;
+                        val = Cand->lab[i+1];
+                        SETPAIRSAUTANDTREE(arg, val)
+                        if (do_ngh) {
+                            SETPAIRSAUTANDTREE(TheGraph[arg].e[0], TheGraph[val].e[0])
+                        }
+                        arg = Cand->lab[i+1];
+                        val = tmp;
+                        SETPAIRSAUTANDTREE(arg, val)
+                        if (do_ngh) {
+                            SETPAIRSAUTANDTREE(TheGraph[arg].e[0], TheGraph[val].e[0])
+                        }
+                        SPECIALGENERATORS
+                    }
+                    factorial(grpsize1, grpsize2, Part->cls[i]);
+                    if (do_ngh) {
+                        for (j=i; j<i+Part->cls[i]; j++) {
+                            temp = TheGraph[Cand->lab[j]].e[0];
+                            Cand->lab[nghcell] = temp;
+                            Cand->invlab[temp] = nghcell;
+                            nghcell++;
+                        }
+                    }
+                    
+                    k = i+Part->cls[i];
+                    for (j=i; j<k; j++) {
+                        Place(Cand->lab[j], Cand, Part);
+                        if ((TheGraph[Cand->lab[j]].d >= 0) && (TheGraph[Cand->lab[j]].d < sg_orig->d[Cand->lab[j]])) {
+                            MakeCanTree(Cand->lab[j], sg_orig, n, Cand, Part, tv);
+                            if (do_ngh) {
+                                MakeCanTree(TheGraph[Cand->lab[j]].e[0], sg_orig, n, Cand, Part, tv);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        
+    }
+    
+    /* Orbit Count */
+    SETMARK(Markers, tv->mark)
+    i1=0;
+    for (c1=0; c1<n; c1++) {
+        if (Markers[tv->orbits[c1]] != tv->mark) {
+            i1++;
+            Markers[tv->orbits[c1]] = tv->mark;
+        }
+    }
+    tv->stats->numorbits = i1;
+    return;
+}
+
+void Individualize(Partition *NextPart, Candidate *NextCand, int K, int Tc, int Cl, int Pos) {
+    int i, j;
+    
+    NextCand->do_it = TRUE;
+    if (NextPart->cls[Tc] > 1) {
+        NextPart->cells = Cl+1;
+        NextPart->active = 1;
+        NextPart->cls[Tc]--;
+        NextPart->cls[Pos] = 1;
+    }
+    NextPart->inv[Pos] = Pos;
+    
+    j = NextCand->lab[Pos];
+    i = NextCand->invlab[K];
+    NextCand->lab[Pos] = K;
+    NextCand->invlab[K] = Pos;
+    NextCand->lab[i] = j;
+    NextCand->invlab[j] = i;
+    return;
+}
+
+void Initialize_Traces_Variables(TracesVars *tv, TracesOptions *options_arg,
+                                 TracesStats *stats_arg, int *orbits_arg,
+                                 sparsegraph *g_arg, sparsegraph *canong_arg,
+                                 int n) {
+    tv->augmented_cells = n;
+    tv->canlist = 0;
+    tv->compstage = 0;
+    tv->expathlength = n;
+    tv->finalnumcells = n;
+    tv->firstpathlength = 0;
+    tv->group_level = 0;
+    tv->lev_of_lastauto = 0;
+    tv->linelgth = 0;
+    tv->name = 0;
+    tv->maxspineorblevel = 0;
+    tv->nfix = 0;
+    tv->options = options_arg;
+    tv->orbits = orbits_arg;
+    tv->permInd = 0;
+    tv->maxdeg = 0;
+    tv->mindeg = n;
+    
+    if (tv->options->generators || tv->options->writeautoms || tv->options->userautomproc)
+        tv->build_autom = TRUE;
+    else
+        tv->build_autom = FALSE;
+    
+    tv->specialgens = 0;
+    tv->stats = stats_arg;
+    tv->treedepth = 0;
+    tv->gotonode = NULL;
+    tv->input_graph = tv->graph = g_arg;
+    tv->cangraph = canong_arg;
+    tv->mark = tv->stackmark = tv->treemark = tv->autmark = tv->markcell1 = tv->markcell2 = NAUTY_INFINITY-1;
+    tv->conta0 = tv->conta1 = tv->conta2 = tv->conta3 = tv->conta4 = tv->conta5 = tv->conta6 = tv->conta7 = tv->contatc = 0;
+    
+    if (tv->options->strategy == 0) {
+        tv->steps = n;
+        tv->strategy = 0;
+    }
+    else {
+        tv->strategy = 1;
+        tv->steps = tv->options->strategy;
+        if (tv->steps > n) {
+            tv->steps = n;
+        }
+    }
+}
+
+void Initialize_Traces_Statistics (TracesStats *stats_arg, int n) {
+    stats_arg->grpsize1 = 1;
+    stats_arg->grpsize2 = 0;
+    stats_arg->numorbits = n;
+    stats_arg->treedepth= 0;
+    stats_arg->numgenerators = 0;
+    stats_arg->numnodes = 1;
+    stats_arg->errstatus = 0;
+    stats_arg->interrupted = 0;
+    stats_arg->canupdates = 0;
+    stats_arg->peaknodes = 0;
+}
+
+void Initialize_Traces_Time_Variables (TracesVars *tv) {
+    tv->autchk = 0;
+    tv->expaths = 0;
+    tv->schreier1 = 0;
+    tv->schreier2 = 0;
+    tv->schreier3 = 0;
+}
+
+boolean isautom_sg_pair(graph *g, int *p, boolean digraph, int m, int n, struct TracesVars *tv) {
+    int *d, *e;
+    size_t *v;
+    int i, k, pi, di;
+    size_t vi, vpi, j;
+    
+    SG_VDE(g, v, d, e);
+    
+    for (k = 0; k < tv->permInd; ++k)
+    {
+        i = PrmPairs[k].arg;
+        pi = p[i];
+        di = d[i];
+        if (d[pi] != di) return FALSE;
+        
+        vi = v[i];
+        vpi = v[pi];
+        SETMARK(AutMarkers, tv->autmark)
+        for (j = 0; j < di; ++j) AutMarkers[p[e[vi+j]]] = tv->autmark;
+        for (j = 0; j < di; ++j) if (AutMarkers[e[vpi+j]] != tv->autmark) {
+            return FALSE;
+        }
+    }
+    
+    return TRUE;
+}
+
+boolean lookup(searchtrie *t) {
+    searchtrie *TreeNode;
+    
+    TreeNode = t;
+    while (TreeNode->level >= 1) {
+        if (TreeNode->goes_to) {
+            return FALSE;
+        }
+        TreeNode = TreeNode->father;
+    }
+    return TRUE;
+}
+
+void MakeCanTree(int v1, sparsegraph *sg_orig, int n, Candidate *Cand, Partition *Part, struct TracesVars* tv) {
+    int ind, vtx, ngh, trind, deg0, deg1;
+    size_t j1;
+    int *sge1;
+    
+    trind = 1;
+    ind = 0;
+    TreeStack[0] = v1;
+    SETMARK(TreeMarkers, tv->treemark);
+    
+    while (ind < trind) {
+        vtx = TreeStack[ind++];
+        if (TreeNodes[vtx]) {
+            return;
+        }
+        
+        if (TheGraph[vtx].d == -1) {
+            Place(vtx, Cand, Part);
+            TreeNodes[vtx] = TRUE;
+        }
+        
+        TreeMarkers[vtx] = tv->treemark;
+        deg0 = max(TheGraph[vtx].d, 0);
+        deg1 = sg_orig->d[vtx];
+        sge1 = TheGraph[vtx].e;
+        
+        for (j1 = deg0; j1 < deg1; j1++) {
+            ngh = sge1[j1];
+            if ((TheGraph[ngh].d == -1) && (TreeMarkers[ngh] != tv->treemark)) {
+                TreeStack[trind++] = ngh;
+            }
+        }
+    }
+    return;
+}
+
+void MakeDiscrete(Partition *Part, int cell) {
+    int i, k;
+    
+    Part->cells += (Part->cls[cell] - 1);
+    k = cell + Part->cls[cell];
+    
+    for (i = cell; i < k; i++) {
+        Part->cls[i] = 1;
+        Part->inv[i] = i;
+    }
+}
+
+void MakeTree(int v1, int v2, sparsegraph *sg, int n, struct TracesVars* tv, boolean forceautom) {
+    int ind, vtx1, vtx2, ngh1, ngh2, trind, deg0, deg1;
+    size_t j1;
+    int *sge1, *sge2;
+    boolean build_autom;
+    
+    if (v1 == v2) return;
+    build_autom = tv->build_autom || forceautom;
+    trind = 2;
+    ind = 0;
+    TreeStack[0] = v1;
+    TreeStack[1] = v2;
+    SETMARK(TreeMarkers, tv->treemark);
+    
+    while (ind < trind) {
+        vtx1 = TreeStack[ind++];
+        vtx2 = TreeStack[ind++];
+        
+        TreeMarkers[vtx1] = tv->treemark;
+        TreeMarkers[vtx2] = tv->treemark;
+        
+        deg0 = max(TheGraph[vtx1].d, 0);
+        deg1 = sg->d[vtx1];
+        sge1 = TheGraph[vtx1].e;
+        sge2 = TheGraph[vtx2].e;
+        for (j1 = deg0; j1 < deg1; j1++) {
+            ngh1 = sge1[j1];
+            ngh2 = sge2[j1];
+            if ((TreeMarkers[ngh1] != tv->treemark) && (ngh1 != ngh2)) {
+                TreeStack[trind++] = ngh1;
+                TreeStack[trind++] = ngh2;
+                if (ngh1 != ngh2) {
+                    if (build_autom) {
+                        AUTPERM[ngh1] = ngh2;
+                        PrmPairs[tv->permInd].arg = ngh1;
+                        PrmPairs[tv->permInd].val = ngh2;
+                        tv->permInd++;
+                    }
+                    orbjoin_sp_pair(tv->orbits, OrbList, n,
+                                    ngh1, ngh2, &tv->stats->numorbits);
+                }
+            }
+        }
+    }
+    return;
+}
+
+int max(int u, int v) {
+    if (u > v) {
+        return u;
+    }
+    else {
+        return v;
+    }
+}
+
+int min(int u, int v) {
+    if (u < v) {
+        return u;
+    }
+    else {
+        return v;
+    }
+}
+
+int NextNeighbour(int vtx, Candidate *Cand, Partition *Part, int* Markers, int mark, int *ngh, int n) {
+    int *e_vtx;
+    int i, deg;
+    int cell1;
+    
+    deg = TheGraph[vtx].d;
+    e_vtx = TheGraph[vtx].e;
+    
+    if (deg == n-1) {
+        return 0;
+    }
+    
+    for (i=0; i<deg; i++) {
+        if (Markers[e_vtx[i]] != mark) {
+            cell1 = Part->inv[Cand->invlab[e_vtx[i]]];
+            if (Part->cls[cell1] > 1) {
+                *ngh = e_vtx[i];
+                break;
+            }
+        }
+    }
+    if (i<deg) return 1; else return 0;
+}
+
+int NonSingDeg(int vtx, Candidate *Cand, Partition *Part) {
+    int *e_vtx;
+    int i, deg, retdeg;
+    
+    retdeg = TheGraph[vtx].d;
+    deg = retdeg;
+    e_vtx = TheGraph[vtx].e;
+    for (i=0; i<deg; i++) {
+        if (Part->cls[Part->inv[Cand->invlab[e_vtx[i]]]] == 1) {
+            retdeg--;
+        }
+    }
+    return retdeg;
+}
+
+int NonSingDegPlus1(Candidate *Cand, Partition *Part, int cell, TracesVars *tv) {
+    
+    int *e_vtx;
+    int vtx, sing;
+    int i, j, deg, retdeg, n, singcount;
+    
+    n = tv->input_graph->nv;
+    singcount = 0;
+    
+    SETMARK(StackMarkers, tv->stackmark)
+    
+    for (j=cell; j<cell+Part->cls[cell]; j++) {
+        vtx = Cand->lab[j];
+        deg = TheGraph[vtx].d;
+        retdeg = 0;
+        e_vtx = TheGraph[vtx].e;
+        
+        for (i=0; i<deg; i++) {
+            if (SingNonSing[e_vtx[i]] != 1) {
+                e_vtx[retdeg++] = e_vtx[i];
+            }
+            else {
+                if (StackMarkers[e_vtx[i]] != tv->stackmark) {
+                    sing = e_vtx[i];
+                    WorkArray2[singcount] = Part->inv[Cand->invlab[sing]];
+                    WorkArray[singcount++] = sing;
+                    
+                    StackMarkers[e_vtx[i]] = tv->stackmark;
+                }
+            }
+        }
+        if (j == cell) {
+            sort2ints(WorkArray2, WorkArray, singcount);
+        }
+        if (deg != retdeg) {
+            memcpy(e_vtx+retdeg, WorkArray, singcount*sizeof(int));
+            TheGraph[vtx].d = retdeg;
+        }
+    }
+    return retdeg;
+}
+
+void NonSingDegPlus2(Candidate *Cand, Partition *Part, int cell, TracesVars *tv) {
+    
+    int *e_sing;
+    int sing;
+    int k, deg1, singdeg, singcount;
+    
+    singcount = 0;
+    
+    sing = Cand->lab[cell];
+    singdeg = 0;
+    deg1 = TheGraph[sing].d;
+    e_sing = TheGraph[sing].e;
+    
+    for (k=0; k<deg1; k++) {
+        if (SingNonSing[e_sing[k]] != 2) {
+            e_sing[singdeg++] = e_sing[k];
+        }
+    }
+    TheGraph[sing].d = singdeg;
+}
+
+void orbjoin_sp_pair(int *orbits, int *list, int n, int u, int v, int *numorbs) {
+    int j1, j2, k1, k2;
+    
+    j1 = orbits[u];
+    while (orbits[j1] != j1) j1 = orbits[j1];
+    j2 = orbits[v];
+    while (orbits[j2] != j2) j2 = orbits[j2];
+    
+    if (j1 != j2) {
+        k1 = j1;
+        k2 = j2;
+        if (k1 < k2) {
+            (*numorbs)--;
+            while (list[j2] != k2) {
+                orbits[j2] = k1;
+                j2 = list[j2];
+            }
+            orbits[j2] = k1;
+            k1 = list[k1];
+            list[j2] = k1;
+            list[j1] = k2;
+        }
+        else if (k1 > k2) {
+            (*numorbs)--;
+            while (list[j1] != k1) {
+                orbits[j1] = k2;
+                j1 = list[j1];
+            }
+            orbits[j1] = k2;
+            k2 = list[k2];
+            list[j1] = k2;
+            list[j2] = k1;
+        }
+    }
+    return;
+}
+
+void orbjoin_sp_perm(int *orbits, int *map, int *list, int n, int *numorbs) {
+    int i, j1, j2, k1, k2;
+    
+    for (i = 0; i < n; ++i)
+        if (map[i] != i)
+        {
+            j1 = orbits[i];
+            while (orbits[j1] != j1) j1 = orbits[j1];
+            j2 = orbits[map[i]];
+            while (orbits[j2] != j2) j2 = orbits[j2];
+            k1 = j1;
+            k2 = j2;
+            if (k1 < k2) {
+                (*numorbs)--;
+                while (OrbList[j2] != k2) {
+                    orbits[j2] = k1;
+                    j2 = OrbList[j2];
+                }
+                orbits[j2] = k1;
+                k1 = OrbList[k1];
+                OrbList[j2] = k1;
+                OrbList[j1] = k2;
+            }
+            else if (k1 > k2) {
+                (*numorbs)--;
+                while (OrbList[j1] != k1) {
+                    orbits[j1] = k2;
+                    j1 = OrbList[j1];
+                }
+                orbits[j1] = k2;
+                k2 = OrbList[k2];
+                OrbList[j1] = k2;
+                OrbList[j2] = k1;
+            }
+        }
+}
+
+struct Partition *NewPartition(int n) {
+    struct Partition *P;
+    
+    P = malloc(sizeof(*(P)));
+    if (P == NULL) {
+        fprintf(ERRFILE, "\nError, memory not allocated.\n");
+        exit(1);
+    }
+    P->cls = malloc(n*sizeof(int));
+    if (P->cls == NULL) {
+        fprintf(ERRFILE, "\nError, memory not allocated.\n");
+        exit(1);
+    }
+    P->inv = malloc(n*sizeof(int));
+    if (P->inv == NULL) {
+        fprintf(ERRFILE, "\nError, memory not allocated.\n");
+        exit(1);
+    }
+    P->code = -1;
+    P->cells = 0;
+    return P;
+}
+
+void NewPartSpine(int Lev, int n) {
+    
+    if (Lev > 3) {
+        Spine[Lev].part = malloc(sizeof(*(Spine[Lev].part)));
+        if (Spine[Lev].part == NULL) {
+            fprintf(ERRFILE, "\nError, memory not allocated.\n");
+            exit(1);
+        }
+        Spine[Lev].part->cls = Spine[Lev-3].part->cls;
+        Spine[Lev].part->inv = Spine[Lev-3].part->inv;
+        Spine[Lev-3].part->cls = Spine[Lev-3].part->inv = NULL;
+        Spine[Lev].part->code = -1;
+        Spine[Lev].part->cells = 0;
+    }
+    else {
+        Spine[Lev].part = NewPartition(n);
+    }
+}
+
+void Place(int vtx, Candidate *Cand, Partition *Part) {
+    int vtxto, vtxpos;
+    
+    vtxpos = Cand->invlab[vtx];
+    vtxto = CanonIndices[Part->inv[vtxpos]]++;
+    if (Cand->lab[vtxpos] != Cand->lab[vtxto]) {
+        Cand->lab[vtxpos] = Cand->lab[vtxto];
+        Cand->lab[vtxto] = vtx;
+        Cand->invlab[Cand->lab[vtxpos]] = vtxpos;
+        Cand->invlab[Cand->lab[vtxto]] = vtxto;
+    }
+    if (Part->cls[vtxto] > 1) {
+        Part->cls[vtxto+1] = Part->cls[vtxto]-1;
+        Part->cls[vtxto] = 1;
+    }
+}
+
+boolean Prefix(Candidate *Cand1, Candidate *Cand2, int k) {
+    int i;
+    
+    for (i=1; i<=k; i++) {
+        if (Cand1->lab[Spine[k].tgtpos] != Cand2->lab[Spine[k].tgtpos]) {
+            break;
+        }
+    }
+    return (i>k);
+}
+
+int Preprocess(sparsegraph *sg,
+               permnode **ring,
+               Candidate *Cand,
+               int n,
+               Partition *Part,
+               struct TracesVars* tv) {
+    
+    int i, j, j0, k, curr_cell, ind, ind0, ind1, ind2;
+    int *sge;
+    int HitClsInd, labi, nghb, value, SplInd, SplCntInd, sc, iend, CStackInd, SingInd, newcell, TraceInd;
+    
+#define SETPAIRSAUTANDTREE_PREPROC(arg, val) \
+if (tv->build_autom) SETPAIRSAUT(arg, val) \
+if (arg != val) \
+orbjoin_sp_pair(tv->orbits, OrbList, n, arg, val, &tv->stats->numorbits); \
+MakeTree(arg, val, sg, n, tv, FALSE);
+    
+    CStackInd = 0;
+    for (i = 0; i < n; i += Part->cls[i]) {
+        if (TheGraph[Cand->lab[i]].d == 1) {
+            CStack[CStackInd++] = i;
+        }
+    }
+    
+    TraceInd = Part->cells;
+    
+    if (CStackInd > 0) {
+        ind = 0;
+        while (ind < CStackInd) {
+            
+            if (tv->mark > (NAUTY_INFINITY-2)) {
+                memset(Markers, 0, n*sizeof(int));
+                memset(MarkHitVtx, 0, n*sizeof(int));
+                tv->mark = 0;
+            }
+            tv->mark++;
+            
+            curr_cell = CStack[ind++];
+            ind2 = curr_cell+Part->cls[curr_cell];
+            HitClsInd = 0;
+            for (i = curr_cell; i < ind2; i++) {
+                labi = Cand->lab[i];
+                nghb = *(TheGraph[labi].e);
+                
+                if (TheGraph[nghb].d != 1) {
+                    TheGraph[labi].d = -1;
+                    TheGraph[labi].one = TRUE;
+                }
+                
+                if (MarkHitVtx[nghb] == tv->mark) {
+                    NghCounts[nghb]++;
+                }
+                else {
+                    value = Part->inv[Cand->invlab[nghb]];
+                    MarkHitVtx[nghb] = tv->mark;
+                    NghCounts[nghb] = 1;
+                    if (Markers[value] != tv->mark) {
+                        HitCls[HitClsInd++] = value;
+                        Markers[value] = tv->mark;
+                        HitVtx[value] = nghb;
+                        ElmHitCll[value] = 1;
+                    }
+                    else {
+                        HitVtx[value+ElmHitCll[value]++] = nghb;
+                    }
+                }
+            }
+            tv->mark++;
+            
+            sort_Split_Array(HitCls,HitClsInd);
+            SplInd = 0;
+            SplCls[0] = n;
+            for (j = 0; j < HitClsInd; j++) {
+                ind1 = HitCls[j];
+                if ((ElmHitCll[ind1] > 0) && (ElmHitCll[ind1] < Part->cls[ind1])) {
+                    SplCls[SplInd++] = ind1;
+                }
+                else {
+                    ind2 = ind1+Part->cls[ind1];
+                    value = NghCounts[Cand->lab[ind1++]];
+                    for (i = ind1; i < ind2; i++) {
+                        if (NghCounts[Cand->lab[i]] != value) {
+                            SplCls[SplInd++] = HitCls[j];
+                            break;
+                        }
+                    }
+                    if (i == ind2) {
+                        ind1 = HitCls[j];
+                        if (TheGraph[Cand->lab[ind1]].d != 1) {
+                            for (i = ind1; i < ind2; i++) {
+                                value = Cand->lab[i];
+                                Edge_Delete(value, NghCounts[value], Cand, tv);
+                                sge = TheGraph[value].e+TheGraph[value].d;
+                                if (NghCounts[value]>1) {
+                                    factorial(&(tv->stats->grpsize1), &(tv->stats->grpsize2), NghCounts[value]);
+                                    if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                                    for (j0=0; j0<NghCounts[value]-1; j0++) {
+                                        SETPAIRSAUTANDTREE_PREPROC(sge[j0], sge[j0+1])
+                                    }
+                                    SETPAIRSAUTANDTREE_PREPROC(sge[j0], sge[0])
+                                    SPECIALGENERATORS
+                                    if (NghCounts[value] > 2) {
+                                        if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                                        SETPAIRSAUTANDTREE_PREPROC(sge[0], sge[1])
+                                        if (tv->build_autom) {
+                                            SETPAIRSAUT(sge[1], sge[0])
+                                        }
+                                        MakeTree(sge[1], sge[0], sg, n, tv, FALSE);
+                                        SPECIALGENERATORS
+                                    }
+                                }
+                            }
+                            if (TheGraph[Cand->lab[ind1]].d == 1) {
+                                CStack[CStackInd++] = ind1;
+                            }
+                        }
+                    }
+                }
+            }
+            
+            if (SplInd) {
+                
+                for (sc = 0; sc < SplInd; sc++) {	/* For each cell C to be split */
+                    ind0 = SplCls[sc];
+                    ind1 = ind0 + Part->cls[ind0];
+                    SplCntInd = 0;
+                    if (ElmHitCll[ind0] < Part->cls[ind0]) {
+                        SplCnt[SplCntInd++] = 0;
+                        SplPos[0] = Part->cls[ind0] - ElmHitCll[ind0];
+                    }
+                    
+                    /* According to the numbers of neighbors of C into the current cell */
+                    /* compute how many vertices in C will be placed into the same new cell */
+                    iend = ind0 + ElmHitCll[ind0];
+                    for (i = ind0; i < iend; i++) {
+                        value = NghCounts[HitVtx[i]];
+                        if (Markers[value] != tv->mark) {
+                            Markers[value] = tv->mark;
+                            SplCnt[SplCntInd++] = value;
+                            SplPos[value] = 1;
+                        }
+                        else {
+                            SplPos[value]++;
+                        }
+                    }
+                    tv->mark++;
+                    
+                    /* Sort the values deriving from the previous step */
+                    sort_Split_Array(SplCnt, SplCntInd);
+                    
+                    Part->cells += SplCntInd-1;
+                    
+                    /* Split the cell C and update the information for sizes of new cells */
+                    /* Put the new cells into the stack */
+                    i = ind0;
+                    for (k = 0; k < SplCntInd; k++) {
+                        value = SplPos[SplCnt[k]];
+                        Part->cls[i] = value;
+                        SplPos[SplCnt[k]] = i;
+                        i += value;
+                        if (i < ind1) {
+                            TheTrace[TraceInd++] = i;
+                        }
+                    }
+                    
+                    /* Permute elements of the cell C */
+                    iend = ind0 + ElmHitCll[ind0];
+                    
+                    for (i = ind0; i < iend; i++) {
+                        value = HitVtx[i];
+                        Edge_Delete(value, NghCounts[value], Cand, tv);
+                        sge = TheGraph[value].e+TheGraph[value].d;
+                        if (NghCounts[value] > 1) {
+                            factorial(&(tv->stats->grpsize1), &(tv->stats->grpsize2), NghCounts[value]);
+                            
+                            if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                            for (j0=0; j0<NghCounts[value]-1; j0++) {
+                                SETPAIRSAUTANDTREE_PREPROC(sge[j0], sge[j0+1])
+                            }
+                            SETPAIRSAUTANDTREE_PREPROC(sge[j0], sge[0])
+                            SPECIALGENERATORS
+                            if (NghCounts[value] > 2) {
+                                if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                                SETPAIRSAUTANDTREE_PREPROC(sge[0], sge[1])
+                                if (tv->build_autom) {
+                                    SETPAIRSAUT(sge[1], sge[0])
+                                }
+                                MakeTree(sge[1], sge[0], sg, n, tv, FALSE);
+                                SPECIALGENERATORS
+                            }
+                        }
+                        
+                        j = SplPos[NghCounts[value]]++;         /* where HitVtx[i] goes */
+                        k = Cand->invlab[value];				/* where HitVtx[i] is in lab */
+                        Cand->lab[k] = Cand->lab[j];
+                        Cand->lab[j] = value;
+                        Cand->invlab[value] = j;
+                        Cand->invlab[Cand->lab[k]] = k;
+                        NghCounts[value] = 0;
+                    }
+                    
+                    /* Reconstruct the cell C and update the inverse partition */
+                    newcell = ind1 - ElmHitCll[ind0];
+                    i = newcell;
+                    ind2 = newcell+Part->cls[newcell]-1;
+                    do {
+                        Part->inv[i] = newcell;
+                        if (i == ind2) {
+                            newcell = i+1;
+                            if (newcell < n) ind2 = newcell+Part->cls[newcell]-1;
+                        }
+                    }
+                    while (++i < ind1);
+                    
+                    for (i = ind0, k = 0; k < SplCntInd; i+=Part->cls[i], k++) {
+                        if ((k > 0) || (SplCnt[0] > 0)) {
+                            if (TheGraph[Cand->lab[i]].d == 1) {
+                                CStack[CStackInd++] = i;
+                            }
+                        }
+                        if (Part->cls[i] == 1) {
+                            Cand->singcode = MASHCOMM(Cand->singcode, Cand->lab[i]);
+                            SingInd++;
+                        }
+                    }
+                    
+                }
+            }
+        }
+        return 1;
+    }
+    else {
+        return 0;
+    }
+}
+
+int Preprocess_refine(sparsegraph *sg,
+                      permnode **ring,
+                      Candidate *Cand,
+                      int n,
+                      Partition *Part,
+                      struct TracesVars* tv) {
+    
+    int i, j, j0, k, curr_cell, ind, ind0, ind1, ind2;
+    int *sge;
+    int HitClsInd, labi, nghb, value, SplInd, SplCntInd, sc, iend, CStackInd, SingInd, newcell, TraceInd;
+    
+#define SETPAIRSAUTANDTREE_PREPROC_REFINE(arg, val) \
+MakeTree(arg, val, sg, n, tv, FALSE);
+    
+    CStackInd = 0;
+    for (i = 0; i < n; i += Part->cls[i]) {
+        if (TheGraph[Cand->lab[i]].d == 1) {
+            CStack[CStackInd++] = i;
+        }
+    }
+    
+    TraceInd = Part->cells;
+    
+    if (CStackInd > 0) {
+        ind = 0;
+        while (ind < CStackInd) {
+            
+            if (tv->mark > (NAUTY_INFINITY-2)) {
+                memset(Markers, 0, n*sizeof(int));
+                memset(MarkHitVtx, 0, n*sizeof(int));
+                tv->mark = 0;
+            }
+            tv->mark++;
+            
+            curr_cell = CStack[ind++];
+            ind2 = curr_cell+Part->cls[curr_cell];
+            HitClsInd = 0;
+            for (i = curr_cell; i < ind2; i++) {
+                labi = Cand->lab[i];
+                nghb = *(TheGraph[labi].e);
+                
+                if (TheGraph[nghb].d != 1) {
+                    TheGraph[labi].d = -1;
+                    TheGraph[labi].one = TRUE;
+                }
+                
+                if (MarkHitVtx[nghb] == tv->mark) {
+                    NghCounts[nghb]++;
+                }
+                else {
+                    value = Part->inv[Cand->invlab[nghb]];
+                    MarkHitVtx[nghb] = tv->mark;
+                    NghCounts[nghb] = 1;
+                    if (Markers[value] != tv->mark) {
+                        HitCls[HitClsInd++] = value;
+                        Markers[value] = tv->mark;
+                        HitVtx[value] = nghb;
+                        ElmHitCll[value] = 1;
+                    }
+                    else {
+                        HitVtx[value+ElmHitCll[value]++] = nghb;
+                    }
+                }
+            }
+            
+            tv->mark++;
+            
+            sort_Split_Array(HitCls,HitClsInd);
+            
+            SplInd = 0;
+            SplCls[0] = n;
+            for (j = 0; j < HitClsInd; j++) {
+                ind1 = HitCls[j];
+                if ((ElmHitCll[ind1] > 0) && (ElmHitCll[ind1] < Part->cls[ind1])) {
+                    SplCls[SplInd++] = ind1;
+                }
+                else {
+                    ind2 = ind1+Part->cls[ind1];
+                    value = NghCounts[Cand->lab[ind1++]];
+                    for (i = ind1; i < ind2; i++) {
+                        if (NghCounts[Cand->lab[i]] != value) {
+                            SplCls[SplInd++] = HitCls[j];
+                            break;
+                        }
+                    }
+                    if (i == ind2) {
+                        ind1 = HitCls[j];
+                        if (TheGraph[Cand->lab[ind1]].d != 1) {
+                            for (i = ind1; i < ind2; i++) {
+                                value = Cand->lab[i];
+                                Edge_Delete(value, NghCounts[value], Cand, tv);
+                                sge = TheGraph[value].e+TheGraph[value].d;
+                                if (NghCounts[value]>1) {
+                                    if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                                    for (j0=0; j0<NghCounts[value]-1; j0++) {
+                                        SETPAIRSAUTANDTREE_PREPROC_REFINE(sge[j0], sge[j0+1])
+                                    }
+                                    SETPAIRSAUTANDTREE_PREPROC_REFINE(sge[j0], sge[0])
+                                    if (NghCounts[value] > 2) {
+                                        if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                                        SETPAIRSAUTANDTREE_PREPROC_REFINE(sge[0], sge[1])
+                                        MakeTree(sge[1], sge[0], sg, n, tv, FALSE);
+                                    }
+                                }
+                            }
+                            if (TheGraph[Cand->lab[ind1]].d == 1) {
+                                CStack[CStackInd++] = ind1;
+                            }
+                        }
+                    }
+                }
+            }
+            
+            if (SplInd) {
+                
+                for (sc = 0; sc < SplInd; sc++) {	/* For each cell C to be split */
+                    ind0 = SplCls[sc];
+                    ind1 = ind0 + Part->cls[ind0];
+                    SplCntInd = 0;
+                    if (ElmHitCll[ind0] < Part->cls[ind0]) {
+                        SplCnt[SplCntInd++] = 0;
+                        SplPos[0] = Part->cls[ind0] - ElmHitCll[ind0];
+                    }
+                    
+                    /* According to the numbers of neighbors of C into the current cell */
+                    /* compute how many vertices in C will be placed into the same new cell */
+                    iend = ind0 + ElmHitCll[ind0];
+                    for (i = ind0; i < iend; i++) {
+                        value = NghCounts[HitVtx[i]];
+                        if (Markers[value] != tv->mark) {
+                            Markers[value] = tv->mark;
+                            SplCnt[SplCntInd++] = value;
+                            SplPos[value] = 1;
+                        }
+                        else {
+                            SplPos[value]++;
+                        }
+                    }
+                    tv->mark++;
+                    
+                    /* Sort the values deriving from the previous step */
+                    sort_Split_Array(SplCnt, SplCntInd);
+                    
+                    Part->cells += SplCntInd-1;
+                    
+                    /* Split the cell C and update the information for sizes of new cells */
+                    /* Put the new cells into the stack */
+                    i = ind0;
+                    for (k = 0; k < SplCntInd; k++) {
+                        value = SplPos[SplCnt[k]];
+                        Part->cls[i] = value;
+                        SplPos[SplCnt[k]] = i;
+                        i += value;
+                        if (i < ind1) {
+                            TheTrace[TraceInd++] = i;
+                        }
+                    }
+                    
+                    /* Permute elements of the cell C */
+                    iend = ind0 + ElmHitCll[ind0];
+                    
+                    for (i = ind0; i < iend; i++) {
+                        value = HitVtx[i];
+                        Edge_Delete(value, NghCounts[value], Cand, tv);
+                        sge = TheGraph[value].e+TheGraph[value].d;
+                        if (NghCounts[value] > 1) {
+                            
+                            if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                            for (j0=0; j0<NghCounts[value]-1; j0++) {
+                                SETPAIRSAUTANDTREE_PREPROC_REFINE(sge[j0], sge[j0+1])
+                            }
+                            SETPAIRSAUTANDTREE_PREPROC_REFINE(sge[j0], sge[0])
+                            if (NghCounts[value] > 2) {
+                                if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+                                SETPAIRSAUTANDTREE_PREPROC_REFINE(sge[0], sge[1])
+                                MakeTree(sge[1], sge[0], sg, n, tv, FALSE);
+                            }
+                        }
+                        
+                        j = SplPos[NghCounts[value]]++;         /* where HitVtx[i] goes */
+                        k = Cand->invlab[value];				/* where HitVtx[i] is in lab */
+                        Cand->lab[k] = Cand->lab[j];
+                        Cand->lab[j] = value;
+                        Cand->invlab[value] = j;
+                        Cand->invlab[Cand->lab[k]] = k;
+                        NghCounts[value] = 0;
+                    }
+                    
+                    /* Reconstruct the cell C and update the inverse partition */
+                    newcell = ind1 - ElmHitCll[ind0];
+                    i = newcell;
+                    ind2 = newcell+Part->cls[newcell]-1;
+                    do {
+                        Part->inv[i] = newcell;
+                        if (i == ind2) {
+                            newcell = i+1;
+                            if (newcell < n) ind2 = newcell+Part->cls[newcell]-1;
+                        }
+                    }
+                    while (++i < ind1);
+                    
+                    for (i = ind0, k = 0; k < SplCntInd; i+=Part->cls[i], k++) {
+                        if ((k > 0) || (SplCnt[0] > 0)) {
+                            if (TheGraph[Cand->lab[i]].d == 1) {
+                                CStack[CStackInd++] = i;
+                            }
+                        }
+                        if (Part->cls[i] == 1) {
+                            Cand->singcode = MASHCOMM(Cand->singcode, Cand->lab[i]);
+                            SingInd++;
+                        }
+                    }
+                }
+            }
+        }
+        return 1;
+    }
+    else {
+        return 0;
+    }
+}
+
+void PrintPartition(int *v, int *cls, int n, int l, int line) {
+    int i, j, k;
+    
+    k=0;
+    fprintf(outfile, "[ ");
+    for (i=0; i<n; i+=cls[i]) {
+        if ((cls[i]<=0) || i>=n) {
+            printf("WRONG");
+            break;
+        }
+        for (j=i; j<i+cls[i]; j++) {
+            fprintf(outfile, "%d ", v[j]+l);
+            if (k++ > 50) {
+                fprintf(outfile,"\n");
+                k=0;
+            }
+        }
+        if ((i+cls[i])<n) fprintf(outfile, "| ");
+    }
+    fprintf(outfile, "] at line %d\n", line);
+    return;
+}
+
+void PrintVect(int *v, int z, int n, int l) {
+    int i;
+    printf("[");
+    for (i = z; i<n; i++)
+        printf(" %2d", v[i]+l);
+    printf(" ]\n");
+    return;
+}
+
+void PrintWeightedGraph1(sparsegraph *g_arg, int n, char msg[30]) {
+    int i, j;
+    int *ngh1, *wgh1;
+    
+    printf("%s\n",msg);
+    for (i=0; i<n; i++) {
+        ngh1 = g_arg->e+g_arg->v[i];
+        wgh1 = g_arg->w+g_arg->v[i];
+        printf("%2d: ",i+labelorg);
+        for (j=0; j<g_arg->d[i]; j++) {
+            printf("%2d ",ngh1[j]);
+            printf("(%d) ",wgh1[j]);
+        }
+        printf("\n");
+    }
+    printf("\n");
+}
+
+void PrintWeightedGraph2(int n, char msg[30]) {
+    int i, j;
+    int *ngh1, *wgh1;
+    
+    printf("%s\n",msg);
+    for (i=0; i<n; i++) {
+        ngh1 = TheGraph[i].e;
+        printf("%2d: ",i+labelorg);
+        for (j=0; j<TheGraph[i].d; j++) {
+            printf("%2d ",ngh1[j]+labelorg);
+        }
+        printf(";\n");
+    }
+    printf("\n");
+}
+
+void PrintBlissGraph(int n) {
+    int i, j;
+    int *ngh1, *wgh1;
+    
+    fprintf(outfile,"p edge %d\n",n);
+    for (i=0; i<n; i++) {
+        ngh1 = TheGraph[i].e;
+        for (j=0; j<TheGraph[i].d; j++) {
+            if (i < ngh1[j]) {
+                fprintf(outfile, "e %d %d\n",i+labelorg,ngh1[j]+labelorg);
+            }
+        }
+    }
+    printf("\n");
+}
+
+void putgraphplus_sg(FILE *f, sparsegraph *sg, int linelength)
+{
+    int i,n,curlen,slen;
+    int *d,*e;
+    size_t *v,j;
+    char s[60];
+    
+    n = sg->nv;
+    SG_VDE(sg,v,d,e);
+    
+    for (i = 0; i < n; ++i)
+    {
+        fprintf(f,"%3d : ",i+labelorg);
+        curlen = 7;
+        
+        for (j = v[i]; j < v[i]+d[i]; ++j)
+        {
+            if (sg->w) {
+                if (sg->w[j] != 1) {
+                    slen = itos(sg->w[j],s);
+                    if (linelength > 0 && curlen + slen + 1 > linelength)
+                    {
+                        putstring(f,"\n  ");
+                        curlen = 2;
+                    }
+                    PUTC(' ',f);
+                    PUTC('w',f);
+                    putstring(f,s);
+                    curlen += slen + 3;
+                }
+            }
+            
+            slen = itos(e[j]+labelorg,s);
+            if (linelength > 0 && curlen + slen + 1 > linelength)
+            {
+                putstring(f,"\n  ");
+                curlen = 2;
+            }
+            PUTC(' ',f);
+            putstring(f,s);
+            curlen += slen + 1;
+        }
+        putstring(f,";\n");
+    }
+}
+
+void quickSort(int *arr, int elements) {
+    
+#define MAX_LEVELS 300
+    
+    int piv, beg[MAX_LEVELS], end[MAX_LEVELS], i = 0, L, R, swap;
+    int k, value;
+    
+    beg[0] = 0;
+    end[0] = elements;
+    while (i>= 0) {
+        L = beg[i];
+        R = end[i]-1;
+        if (L<R-8) {
+            piv = arr[(L+R)/2];
+            arr[(L+R)/2] = arr[L];
+            arr[L] = piv;
+            while (L<R) {
+                while (arr[R]>= piv && L<R) R--;
+                if (L<R) arr[L++] = arr[R];
+                while (arr[L]<= piv && L<R) L++;
+                if (L<R) arr[R--] = arr[L];
+            }
+            arr[L] = piv;
+            beg[i+1] = L+1;
+            end[i+1] = end[i]; end[i++] = L;
+            if (end[i]-beg[i]>end[i-1]-beg[i-1]) {
+                swap = beg[i];
+                beg[i] = beg[i-1];
+                beg[i-1] = swap;
+                swap = end[i];
+                end[i] = end[i-1];
+                end[i-1] = swap;
+            }
+        }
+        else {
+            i--;
+        }
+    }
+    for (k = 1; k < elements; ++k) {
+        value = arr[k];
+        i = k - 1;
+        while ((i >= 0) && (value < arr[i])) {
+            arr[i + 1] = arr[i];
+            --i;
+        }
+        arr[i + 1] = value;
+    }
+}
+
+void RemoveFromLevel(int from, int to, int strategy, boolean reinit) {
+    int i;
+    
+    for (i=from; i<=to; i++) {
+        if (Spine[i].listend) {
+            (Spine[i].listend)->next = GarbList;
+            GarbList = Spine[i].liststart;
+            Spine[i].liststart = Spine[i].listend = NULL;
+        }
+        if (strategy == 0 || reinit) {
+            Spine[i].listcounter = 0;
+            if (i>from) {
+                Spine[i].thetracexists = FALSE;
+                Spine[i].part->code = -1;
+            }
+        }
+    }
+}
+
+searchtrie *searchtrie_make(Candidate *CurrCand, Candidate *NextCand, int n, struct TracesVars *tv) {
+    
+    searchtrie *st;
+    if (tv->strienext == n) {
+        tv->strienext = 0;
+        tv->strielist->next = malloc(sizeof(struct trielist));
+        if (tv->strielist->next == NULL) {
+            fprintf(ERRFILE, "\nError, memory not allocated.\n");
+            exit(1);
+        }
+        tv->strielist->next->prev = tv->strielist;
+        tv->strielist = tv->strielist->next;
+        tv->strielist->next = NULL;
+        tv->strielist->triearray = malloc(n*sizeof(searchtrie));
+        if (tv->strielist->triearray == NULL) {
+            fprintf(ERRFILE, "\nError, memory not allocated.\n");
+            exit(1);
+        }
+    }
+    st = &(tv->strielist->triearray[tv->strienext]);
+    st->father = CurrCand->stnode;
+    st->name = NextCand->name;
+    st->index = tv->newindex+1;
+    st->vtx = NextCand->vertex;
+    st->level = tv->tolevel;
+    st->first_child = st->next_sibling = st->last_child = st->goes_to = NULL;
+    if (st->father) {
+        if (st->father->first_child) {
+            st->father->last_child->next_sibling = st;
+            st->father->last_child = st;
+        }
+        else {
+            st->father->first_child = st->father->last_child = st;
+        }
+    }
+    NextCand->stnode = st;
+    if (tv->newgotonode) {
+        tv->newgotonode->goes_to = st;
+    }
+    if (tv->gotonode) {
+        st->goes_to = tv->gotonode;
+        tv->gotonode = NULL;
+    }
+    tv->strienext++;
+    return st;
+}
+
+trielist *searchtrie_new(int n, struct TracesVars *tv) {
+    
+    tv->strielist = malloc(sizeof(struct trielist));
+    if (tv->strielist == NULL) {
+        fprintf(ERRFILE, "\nError, memory not allocated.\n");
+        exit(1);
+    }
+    tv->strielist->prev = tv->strielist->next = NULL;
+    tv->strielist->triearray = malloc(n*sizeof(searchtrie));
+    if (tv->strielist->triearray == NULL) {
+        fprintf(ERRFILE, "\nError, memory not allocated.\n");
+        exit(1);
+    }
+    tv->strielist->triearray[0].father = tv->strielist->triearray[0].first_child = NULL;
+    tv->strielist->triearray[0].next_sibling = tv->strielist->triearray[0].last_child = NULL;
+    tv->strielist->triearray[0].goes_to = NULL;
+    tv->strielist->triearray[0].index = 1;
+    tv->strielist->triearray[0].name = tv->strielist->triearray[0].level = 0;
+    tv->strielist->triearray[0].vtx = n;
+    
+    tv->strienext = 1;
+    return tv->strielist;
+}
+
+int Select_from_CStack(int *cls, int CStackInd) {
+    int j, k;
+    
+    j = CStackInd;
+    k = CStackInd;
+    while (--j > 0) {
+        if (cls[CStack[j]] < cls[CStack[k]]) {
+            k = j;
+        }
+        if ((cls[CStack[k]] == 1) || (j < CStackInd - 12)) {
+            break;
+        }
+    }
+    return k;
+}
+
+boolean SelectNextLevel(int n, struct TracesVars *tv, struct TracesInfo *ti) {
+    int i, j, val;
+    Candidate *FirstCand;
+    boolean orbitcell;
+    
+    switch (tv->compstage) {
+        case 2:
+            tv->nextlevel = tv->maxtreelevel;
+            while (tv->nextlevel >=0) {
+                if (Spine[tv->nextlevel].liststart) {
+                    break;
+                }
+                tv->nextlevel--;
+            }
+            if (tv->nextlevel < 0) {
+                return FALSE;
+            }
+            break;
+        default:
+            switch (tv->strategy) {
+                case 0:
+                    tv->nextlevel = tv->fromlevel;
+                    while (!Spine[tv->nextlevel].liststart) {
+                        (tv->nextlevel)++;
+                    }
+                    PRINTF2("SelectNextLevel 1?: finalnumcells: %d; ", tv->finalnumcells);
+                    PRINTF2("Spine[tv->nextlevel].part->cells: %d; ", Spine[tv->nextlevel].part->cells);
+                    PRINTF2("tv->maxtreelevel: %d; ", tv->maxtreelevel);
+                    PRINTF2("tv->nextlevel: %d\n", tv->nextlevel);
+                    if ((Spine[tv->nextlevel].part->cells == tv->finalnumcells) || (tv->nextlevel > tv->maxtreelevel)) {
+                        return FALSE;
+                    } else {
+                        /* Check the whole group */
+                        if ((tv->group_level < tv->tolevel) && !ti->first_matching && ti->thegrouphaschanged) {
+                            
+                            FirstCand = Spine[tv->nextlevel].liststart;
+                            val = tv->orbits[FirstCand->lab[Spine[1].tgtcell]];
+                            for (i=Spine[1].tgtcell; i<Spine[1].tgtend; i++) {
+                                if (tv->orbits[FirstCand->lab[i]] != val) {
+                                    break;
+                                }
+                            }
+                            if (i<Spine[1].tgtend) {
+                                orbitcell = FALSE;
+                            } else {
+                                orbitcell = TRUE;
+                            }
+                            if (orbitcell) {
+                                FirstCand = Spine[tv->nextlevel].liststart;
+                                FixBase(fix, tv, FirstCand, 0, tv->firstpathlength);
+                                if (tv->options->verbosity >= 2) tv->schreier1 -= CPUTIME;
+                                getorbitsmin(fix, tv->nfix, gpB, &gensB, &tv->currorbit, NULL, n, n, TRUE);
+                                if (tv->options->verbosity >= 2) tv->schreier1 += CPUTIME;
+                                for (j=2; j<=tv->firstpathlength; j++) {
+                                    tv->currorbit = findcurrorbits(gpB, j-1);
+                                    val = tv->currorbit[FirstCand->lab[Spine[j].tgtcell]];
+                                    for (i=Spine[j].tgtcell; i<Spine[j].tgtend; i++) {
+                                        if (tv->currorbit[FirstCand->lab[i]] != val) {
+                                            break;
+                                        }
+                                    }
+                                    if (i<Spine[j].tgtend) {
+                                        break;
+                                    }
+                                }
+                                tv->group_level = j-1;
+                                if (tv->group_level >= tv->tolevel) {
+                                    ti->thegrouphaschanged = FALSE;
+                                }
+                            }
+                            /* End check the whole group */
+                        }
+                        
+                    }
+                    break;
+                case 1:
+                    tv->nextlevel = tv->maxtreelevel;
+                    PRINTF2("SelectNextLevel 2?: finalnumcells: %d; ", tv->finalnumcells);
+                    PRINTF2("Spine[tv->nextlevel].part->cells: %d; ", Spine[tv->nextlevel].part->cells);
+                    if (Spine[tv->nextlevel].part->cells == tv->finalnumcells) {
+                        (tv->nextlevel)--;
+                    }
+                    while (tv->nextlevel >= 0) {
+                        if (Spine[tv->nextlevel].liststart) {
+                            break;
+                        }
+                        tv->nextlevel--;
+                    }
+                    if (tv->nextlevel < 0) {
+                        return FALSE;
+                    }
+                    break;
+                default:
+                    break;
+            }
+            break;
+    }
+    return TRUE;
+}
+
+void SetAutom(int q, int n, struct TracesVars *tv) {
+    int i;
+    
+    for (i=0; i<q; i++) {
+        AUTPERM[PrmPairs[i].arg] = PrmPairs[i].val;
+    }
+    return;
+}
+
+void ResetAutom(int q, int n, struct TracesVars *tv) {
+    int i;
+    
+    if (n/q < 256) {
+        memcpy(AUTPERM, IDENTITY_PERM, n*sizeof(int));
+    }
+    else {
+        for (i=0; i<q; i++) {
+            AUTPERM[PrmPairs[i].arg] = PrmPairs[i].arg;
+        }
+    }
+    tv->permInd = 0;
+    return;
+}
+
+void sort_Split_Array(int *Array, int Ind){
+    int i, k, value;
+    
+    switch (Ind) {
+        case 0:
+        case 1:
+            break;
+        case 2:
+            if (Array[0] > Array[1]) {
+                value = Array[0];
+                Array[0] = Array[1];
+                Array[1] = value;
+            }
+            break;
+        case 3:
+        case 4:
+        case 5:
+        case 6:
+        case 7:
+        case 8:
+            for (k = 1; k < Ind; ++k) {
+                value = Array[k];
+                i = k - 1;
+                while ((i >= 0) && (value < Array[i])) {
+                    Array[i + 1] = Array[i];
+                    --i;
+                }
+                Array[i + 1] = value;
+            }
+            break;
+        default:
+            quickSort(Array, Ind);
+            break;
+    }
+}
+
+int spinelementorbsize(int *orbits, int *lab, int size, int elem) {
+    int i, j, val;
+    
+    j = 0;
+    val = orbits[elem];
+    for (i = 0; i < size; ++i) {
+        if (orbits[lab[i]] == val) ++j;
+    }
+    return j;
+}
+
+boolean TargetCell(Candidate *TargCand, Partition *Part, int n, struct TracesVars* tv, int Lv) {
+    int TCell = -1, TCSize = 1;
+    int i;
+    
+    if (Part->cells == n) {
+        tv->finalnumcells = n;
+        return FALSE;
+    }
+    if (tv->maxdeg <=2) {
+        return FALSE;
+    }
+    
+    if (Lv < tv->tcellevel) {
+        tv->tcell = Spine[Lv+1].tgtcell;
+        return TRUE;
+    }
+    else {
+        if (Part->cls[0] == n) {
+            tv->tcell = 0;
+            return TRUE;
+        }
+        while (TCell < 0) {
+            for (i = Spine[Lv].tgtcell; i < Spine[Lv].tgtend; i += Part->cls[i]) {
+                if (Part->cls[i] > TCSize) {
+                    if (NonSingDeg(TargCand->lab[i], TargCand, Part) > 2) {
+                        TCSize = Part->cls[i];
+                        TCell = i;
+                    }
+                }
+            }
+            Lv--;
+            if ((Lv < 0) && (TCell < 0)) return FALSE;
+        }
+        tv->tcell = TCell;
+        return TRUE;
+    }
+}
+
+int TargetCellExpPath(Candidate *TargCand, Partition *Part, struct TracesVars* tv) {
+    int Lv, n;
+    
+    n = tv->input_graph->nv;
+    if (Part->cells == n) {
+        return 0;
+    }
+    
+    Lv = tv->tolevel_tl+1;
+    SpineTL_tl = Spine+Lv;
+    if (tv->tolevel_tl < tv->tcellevel) {
+        tv->tcellexpath = Part->inv[SpineTL_tl->tgtcell];
+        tv->tolevel_tl++;
+        if (Part->cls[tv->tcellexpath] == 1) {
+            if (tv->options->verbosity >= 2) {
+                if (tv->tolevel_tl-tv->tolevel == 6) {
+                    fprintf(outfile, "... ");
+                }
+            }
+            return TargetCellExpPath(TargCand, Part, tv);
+        } else {
+            return 1+((Spine[tv->tolevel_tl].tgtcell >= Spine[tv->tolevel_tl-1].tgtcell) && (Spine[tv->tolevel_tl].tgtend <= Spine[tv->tolevel_tl-1].tgtend));
+        }
+    }
+    else {
+        if (TargetCellFirstPath(TargCand, Part, tv)) {
+            return 1+((Spine[tv->tolevel_tl].tgtcell >= Spine[tv->tolevel_tl-1].tgtcell) && (Spine[tv->tolevel_tl].tgtend <= Spine[tv->tolevel_tl-1].tgtend));
+        }
+        else {
+            return 0;
+        }
+    }
+}
+
+boolean TargetCellFirstPath(Candidate *TargCand, Partition *Part, struct TracesVars* tv) {
+    int n, TCell, TCSize, TCell1, TCSize1;
+    int Lv, i, Lev, vtx, vtx_d;
+    int loopstart, loopend;
+    boolean divided;
+    
+    n = tv->input_graph->nv;
+    
+    if (Part->cells == n) {
+        return 0;
+    }
+    
+    Lev = tv->tolevel_tl;
+    Lv = tv->tolevel_tl;
+    
+    TCell = TCell1 = -1;
+    TCSize = TCSize1 = 1;
+    
+    while (TCell < 0) {
+        
+        if (tv->compstage == 2) {
+            loopstart = Spine[Lv].tgtcell;
+            divided = FALSE;
+        } else {
+            loopstart = Part->inv[Spine[Lv].tgtcell];
+            divided = FALSE;
+            
+            if (Lv == tv->lastlev) {
+                loopstart = Part->inv[tv->lastcell];
+                divided = TRUE;
+            }
+        }
+        
+        i = loopstart;
+        loopend = Spine[Lv].tgtend;
+        while (i < loopend) {
+            if (Part->cls[i] > TCSize) {
+                vtx = TargCand->lab[i];
+                vtx_d = TheGraph[vtx].d;
+                if (vtx_d > 2) {
+                    if (NonSingDeg(vtx, TargCand, Part) > 2) {
+                        TCSize = Part->cls[i];
+                        TCell = i;
+                        if (TCSize == WorkArray[Lv]) {
+                            break;
+                        }
+                    }
+                }
+            }
+            i += Part->cls[i];
+            if (divided && (i == loopend)) {
+                i = loopstart = Part->inv[Spine[Lv].tgtcell];
+                loopend = tv->lastcell;
+                divided = FALSE;
+                TCSize1 = TCSize;
+                TCell1 = TCell;
+                TCell = -1;
+                TCSize = 1;
+            }
+        }
+        
+        if (TCSize1 > TCSize) {
+            TCell = TCell1;
+            TCSize = TCSize1;
+        }
+        
+        if (TCell < 0) {
+            if (Lv == 0) {
+                tv->finalnumcells = min(Part->cells,tv->finalnumcells);    /* 160712 */
+                return FALSE;
+            } else {
+                Lv = Spine[Lv].tgtfrom;
+            }
+        }
+    }
+    
+    tv->tcellexpath = tv->lastcell = TCell;
+    tv->tolevel_tl++;
+    
+    Spine[tv->tolevel_tl].tgtfrom = tv->lastlev = Lv;
+    Spine[tv->tolevel_tl].tgtcell = tv->tcellexpath;
+    Spine[tv->tolevel_tl].tgtsize = WorkArray[Lv] = TCSize;
+    Spine[tv->tolevel_tl].tgtend = Spine[tv->tolevel_tl].tgtcell + TCSize;
+    Spine[tv->tolevel_tl].tgtpos = Spine[tv->tolevel_tl].tgtend - 1;
+    tv->tcellevel = tv->tolevel_tl;
+    
+    if (Lv != Lev) {
+        BreakSteps[Lev] = ++tv->brkstpcount;
+        if (Spine[tv->tolevel].liststart) {
+            if (!Spine[tv->tolevel].liststart->firstsingcode) {
+                Spine[tv->tolevel].liststart->firstsingcode = Spine[tv->tolevel].liststart->pathsingcode;
+            }
+        }
+    }
+    return TRUE;
+}
+
+void traces_freedyn(void) {
+    /* Free the static dynamic memory used by Traces */
+#if !MAXN
+    DYNFREE(AUTPERM, AUTPERM_sz);
+    DYNFREE(BreakSteps, BreakSteps_sz);
+    DYNFREE(CStack, CStack_sz);
+    DYNFREE(CurrOrbSize, CurrOrbSize_sz);
+    DYNFREE(CurrRefCells, CurrRefCells_sz);
+    DYNFREE(Diff, Diff_sz);
+    DYNFREE(Factorials, Factorials_sz);
+    DYNFREE(fix, fix_sz);
+    DYNFREE(IDENTITY_PERM, IDENTITY_PERM_sz);
+    DYNFREE(Markers, Markers_sz);
+    DYNFREE(TreeMarkers, TreeMarkers_sz);
+    DYNFREE(AutMarkers, AutMarkers_sz);
+    DYNFREE(MarkHitVtx, MarkHitVtx_sz);
+    DYNFREE(MultRefCells, MultRefCells_sz);
+    DYNFREE(NghCounts, NghCounts_sz);
+    DYNFREE(OrbSize, OrbSize_sz);
+    DYNFREE(OrbList, OrbList_sz);
+    DYNFREE(PrmPairs, PrmPairs_sz);
+    DYNFREE(TempOrbList, TempOrbList_sz);
+    DYNFREE(RefCells, RefCells_sz);
+    DYNFREE(RefPath, RefPath_sz);
+    DYNFREE(Singletons, Singletons_sz);
+    DYNFREE(SplCls, SplCls_sz);
+    DYNFREE(SplCnt, SplCnt_sz);
+    DYNFREE(SplPos, SplPos_sz);
+    DYNFREE(StackMarkers, StackMarkers_sz);
+    DYNFREE(TheTrace, TheTrace_sz);
+    DYNFREE(TheTraceCC, TheTraceCC_sz);
+    DYNFREE(TheTraceSplNum, TheTraceSplNum_sz);
+    DYNFREE(TheTraceSteps, TheTraceSteps_sz);
+    DYNFREE(TEMPLAB, TEMPLAB_sz);
+    DYNFREE(TEMPINVLAB, TEMPINVLAB_sz);
+    DYNFREE(WeightsSeq, WeightsSeq_sz);
+    DYNFREE(WorkArray, WorkArray_sz);
+    DYNFREE(WorkArray0, WorkArray0_sz);
+    DYNFREE(WorkArray1, WorkArray1_sz);
+    DYNFREE(WorkArray2, WorkArray2_sz);
+    DYNFREE(WorkArray3, WorkArray3_sz);
+    DYNFREE(WorkArray4, WorkArray4_sz);
+    DYNFREE(WorkArray5, WorkArray5_sz);
+    DYNFREE(WorkArray6, WorkArray6_sz);
+    DYNFREE(WorkArray7, WorkArray7_sz);
+    DYNFREE(Neighbs1, Neighbs1_sz);
+    DYNFREE(Neighbs2, Neighbs2_sz);
+    DYNFREE(TreeStack, TreeStack_sz);
+    DYNFREE(Spine, Spine_sz);
+    DYNFREE(TrieArray, TrieArray_sz);
+    DYNFREE(TheGraph, TheGraph_sz);
+    DYNFREE(EPCodes, EPCodes_sz);
+#endif
+}
+
+boolean TreeFyTwo(int From, Candidate *Cand1, Candidate *Cand2, Partition *Part, int n,
+                  struct TracesVars* tv, struct TracesInfo *ti) {
+    int i, i1, i2, j1, j2, k;
+    int vtx1, vtx2, ngh1, ngh2, arg, val;
+    int *tgtc1, *tgtc2, *adj1, *adj2;
+    int iend;
+    
+    SETMARK(Markers, tv->mark)
+    
+    i2=0;
+    
+    if (tv->permInd) ResetAutom(tv->permInd, n, tv);
+    i1 = Spine[From].tgtsize;
+    tgtc1 = Cand1->lab+Spine[From].tgtcell;
+    tgtc2 = Cand2->lab+Spine[From].tgtcell;
+    for (i=0; i<i1; i++) {
+        arg = tgtc1[i];
+        val = tgtc2[i];
+        if ((Markers[arg] != tv->mark) && (Markers[val] != tv->mark)) {
+            SETPAIRSAUT(arg, val)
+            SETPAIRSAUT(val, arg)
+            Markers[arg] = tv->mark;
+            Markers[val] = tv->mark;
+        } else {
+            return FALSE;    /*  160715  */
+        }
+    }
+    
+    while (i2 < tv->permInd) {
+        vtx1 = PrmPairs[i2].arg;
+        vtx2 = PrmPairs[i2++].val;
+        adj1 = TheGraph[vtx1].e;
+        adj2 = TheGraph[vtx2].e;
+        iend = TheGraph[vtx1].d;
+        j1 = j2 = 0;
+        for (k=0; k < iend; k++) {
+            ngh1 = adj1[k];
+            if (Markers[ngh1] != tv->mark) {
+                Neighbs1[j1++] = Cand1->invlab[ngh1];
+            }
+            ngh2 = adj2[k];
+            if (Markers[ngh2] != tv->mark) {
+                Neighbs2[j2++] = Cand2->invlab[ngh2];
+            }
+        }
+        
+        k = tv->permInd;
+        if (j1 == j2) {
+            quickSort(Neighbs1, j1);
+            quickSort(Neighbs2, j2);
+            for (i=0; i<j1; i++) {
+                arg = Cand1->lab[Neighbs1[i]];
+                val = Cand2->lab[Neighbs2[i]];
+                if ((Markers[arg] != tv->mark) && (Markers[val] != tv->mark)) {
+                    SETPAIRSAUT(arg, val)
+                    SETPAIRSAUT(val, arg)
+                    Markers[arg] = tv->mark;
+                    Markers[val] = tv->mark;
+                }
+            }
+        }
+    }
+    return TRUE;
+}
+
+/*****************************************************************************
+ *                                                                            *
+ *  trie_class(t,c) classifies vertices according to weights of their edges   *
+ *                                                                            *
+ *****************************************************************************/
+
+void  trie_class(trie *t, int *count) {
+    
+    if (t->first_child == NULL) {
+        WeightsSeq[t->value] = *count;
+        if (t->next_sibling == NULL) (*count)++;
+        return;
+    }
+    else {
+        t = t->first_child;
+        while (t) {
+            trie_class(t,count);
+            t = t->next_sibling;
+        }
+    }
+}
+
+int trie_classify(int n, TracesVars *tv) {
+    
+    int i, j, ord;
+    int *ngh1, *wgh1;
+    
+    trieroot = trie_new(n, tv);
+    ord = 0;
+    
+    for (i=0; i<n; i++) {
+        ngh1 = TheGraph[i].e;
+        wgh1 = TheGraph[i].w;
+        sort2ints(wgh1, ngh1, TheGraph[i].d);
+        
+        trieref = trieroot;
+        for (j=0; j<TheGraph[i].d; j++) {
+            trieref = trie_make(trieref, wgh1[j], n, tv);
+        }
+        trieref = trie_make(trieref, n, n, tv);
+        trie_make(trieref, i, n, tv);
+    }
+    trie_class(trieroot,&ord);
+    
+    for (i=0; i<=tv->triepos; i++) {
+        free(TrieArray[i]);
+    }
+    trieroot = NULL;
+    return ord-1;
+}
+
+struct trie *trie_comp(trie *t, int value) {
+    
+    if (t->first_child) {
+        t = t->first_child;
+        while (t) {
+            if  (value != t->value) {
+                t = t->next_sibling;
+            }
+            else {
+                break;
+            }
+        }
+        return t;
+    }
+    else {
+        return NULL;
+    }
+}
+
+void  trie_dump(trie *t) {
+    if (t->first_child == NULL) return;
+    else {
+        printf("( ");
+        t = t->first_child;
+        while (t) {
+            printf("%d ",t->value);
+            trie_dump(t);
+            t = t->next_sibling;
+        }
+        printf(") ");
+    }
+}
+
+/*****************************************************************************
+ *                                                                            *
+ *  trie_make(t,v,n,tv) places the value v into the trie t                    *
+ *                                                                            *
+ *****************************************************************************/
+
+struct trie *trie_make(trie *t, int value, int n, struct TracesVars* tv) {
+    trie *t1;
+    
+    t1 = t;
+    if (tv->trienext == n) {
+        tv->trienext = 0;
+        tv->triepos++;
+        TrieArray[tv->triepos] = malloc(n*sizeof(trie));
+        if (TrieArray[tv->triepos] == NULL) {
+            fprintf(ERRFILE, "\nError, memory not allocated.\n");
+            exit(1);
+        }
+    }
+    if (t->first_child) {
+        t = t->first_child;
+        if (value < t->value) {
+            t1->first_child = &TrieArray[tv->triepos][tv->trienext++];
+            t1->first_child->next_sibling = t;
+            t1->first_child->first_child = NULL;
+            t = t1->first_child;
+            t->value = value;
+            return t;
+        }
+        while (value > t->value) {
+            t1 = t;
+            if (t->next_sibling) {
+                t = t->next_sibling;
+            }
+            else break;
+        }
+        if (value == t->value) {
+            return t;
+        }
+        t1->next_sibling = &TrieArray[tv->triepos][tv->trienext++];
+        t1->next_sibling->first_child = t1->next_sibling->next_sibling = NULL;
+        if (t != t1) {
+            t1->next_sibling->next_sibling = t;
+        }
+        t = t1->next_sibling;
+    }
+    else {
+        t->first_child = &TrieArray[tv->triepos][tv->trienext++];
+        t = t->first_child;
+        t->first_child = t->next_sibling = NULL;
+    }
+    t->value = value;
+    return t;
+}
+
+struct trie *trie_new(int n, struct TracesVars* tv) {
+    
+    TrieArray[0] = malloc(n*sizeof(trie));
+    if (TrieArray[0] == NULL) {
+        fprintf(ERRFILE, "\nError, memory not allocated.\n");
+        exit(1);
+    }
+    TrieArray[0][0].first_child = TrieArray[0][0].next_sibling = NULL;
+    tv->triepos = 0;
+    tv->trienext = 1;
+    return TrieArray[0];
+}
+
+boolean VerifyCand(Candidate *Cand, int n, int line) {
+    int i, k;
+    
+    for (i=0; i<n; i++) {
+        k=Cand->lab[i];
+        if (Cand->invlab[k] != i) {
+            printf("Cand->invlab wrong at %d (vtx: %d), line %d\n", i, k, line);
+            PrintVect(Cand->lab, 0, n, 0);
+            PrintVect(Cand->invlab, 0, n, 0);
+            return FALSE;
+        }
+    }
+    return TRUE;
+}
+
+boolean VerifyId(int *p, int n) {
+    int i, r;
+    
+    r = TRUE;
+    for (i=0; i<n; i++) {
+        if (p[i] != i) {
+            printf("p[%d] = %d\n", i, p[i]);
+            r = FALSE;
+        }
+    }
+    return r;
+}
+
+boolean VerifyPart(Partition *Part, int start, int end) {
+    int i,j;
+    
+    for (i=start; i<end; i+=Part->cls[i]) {
+        if (Part->cls[i] == 0 || i>=end) {
+            printf("WRONG cls\n");
+            return FALSE;
+        }
+        for (j=0; j<Part->cls[i]; j++) {
+            if (Part->inv[i+j] != i) {
+                printf("WRONG inv\n");
+                return FALSE;
+            }
+        }
+    }
+    printf("OK\n");
+    return TRUE;
+}
+
+int VerifyPerm(int *perm, int n,int where) {
+    int i;
+    
+    memset(Markers, 0, n*sizeof(int));
+    
+    for (i=0; i<n; i++) {
+        if ((perm[i] >= n) || (Markers[perm[i]])) {
+            fprintf(stderr,"wrong permutation @ %d\n",where);
+            PrintVect(perm,0,i+1,labelorg);
+        }
+        Markers[perm[i]] = TRUE;
+    }
+    return TRUE;
+}
+
+/*****************************************************************************
+ *                                                                            *
+ *  WeightCodes(n) transforms the weight w(u,v) of an edge into a new weight  *
+ *  W(u,v) such that W(a,b) = W(c,d) iff w(a,b) = w(c,d) and w(b,a) = w(d,c). *
+ *                                                                            *
+ *****************************************************************************/
+
+void WeightCodes(int n) {
+    int i,j,aux;
+    int sumdegs;
+    int deg, vtx1, vtx2, *ngh1, *ngh2, *wgh1, *wgh2, ord;
+    
+    sumdegs = 0;
+    for (i=0; i<n; i++) {
+        sumdegs += TheGraph[i].d;
+    }
+    
+    DYNALLSTAT(int, VArray, VArray_sz);
+    DYNALLSTAT(weightwhere, WArray, WArray_sz);
+    DYNALLSTAT(grph_strct, TheAuxGraph, TheAuxGraph_sz);
+    
+    DYNALLOC1(int, VArray, VArray_sz, sumdegs, "WeightCodes");
+    DYNALLOC1(weightwhere, WArray, WArray_sz, sumdegs, "WeightCodes");
+    DYNALLOC1(grph_strct, TheAuxGraph, TheAuxGraph_sz, n, "WeightCodes");
+    
+    memcpy(TheAuxGraph,TheGraph,n*sizeof(grph_strct));
+    
+    ord = 0;
+    for (vtx1=0; vtx1<n; vtx1++) {
+        ngh1 = (TheAuxGraph[vtx1].e)++;
+        wgh1 = TheAuxGraph[vtx1].w;
+        deg = TheAuxGraph[vtx1].d;
+        for (i=0; i<deg; i++) {
+            vtx2 = ngh1[i];
+            ngh2 = (TheAuxGraph[vtx2].e)++;
+            wgh2 = (TheAuxGraph[vtx2].w)++;
+            (TheAuxGraph[vtx1].d)--;
+            (TheAuxGraph[vtx2].d)--;
+            VArray[ord] = wgh1[i];
+            WArray[ord].weight = wgh2[0];
+            WArray[ord++].ref = (TheAuxGraph[vtx1].w)++;
+            VArray[ord] = wgh2[0];
+            WArray[ord].weight = wgh1[i];
+            WArray[ord++].ref = wgh2;
+        }
+    }
+    
+    sortweights(VArray,WArray,ord);
+    
+    /* swap VArray and WArray.weight */
+    for (i=0; i<sumdegs; i++) {
+        aux = VArray[i];
+        VArray[i] = WArray[i].weight;
+        WArray[i].weight = aux;
+    }
+    
+    i = j = 0;
+    do {
+        if (WArray[i].weight == WArray[j].weight) {
+            j++;
+        } else {
+            sortweights(VArray+i,WArray+i,j-i);
+            i = j;
+        }
+    } while (j<sumdegs);
+    sortweights(VArray+i,WArray+i,j-i);
+    
+    /* weight class */
+    ord = 0;
+    *(WArray[0].ref) = 0;
+    for (i=1; i<sumdegs; i++) {
+        if ((WArray[i].weight != WArray[i-1].weight) || (VArray[i] != VArray[i-1])) {
+            ord++;
+        }
+        *(WArray[i].ref) = ord;
+    }
+    
+    DYNFREE(VArray, VArray_sz);
+    DYNFREE(WArray, WArray_sz);
+    DYNFREE(TheAuxGraph, TheAuxGraph_sz);
+    
+}
+
+
+
+boolean TargetCellSmall(Candidate *TargCand, Partition *Part, int n, struct TracesVars* tv, int Lv) {
+    int TCell = -1, TCSize = n;
+    int i;
+    
+    if (tv->maxdeg <=2) {
+        return FALSE;
+    }
+    
+    if (Lv < tv->tcellevel) {
+        tv->tcell = Spine[Lv+1].tgtcell;
+        return TRUE;
+    }
+    else {
+        if (Part->cls[0] == n) {
+            tv->tcell = 0;
+            return TRUE;
+        }
+        while (TCell < 0) {
+            for (i = Spine[Lv].tgtcell; i < Spine[Lv].tgtend; i += Part->cls[i]) {
+                if (Part->cls[i] < TCSize) {
+                    if (NonSingDeg(TargCand->lab[i], TargCand, Part) > 2) {
+                        TCSize = Part->cls[i];
+                        TCell = i;
+                    }
+                }
+            }
+            Lv--;
+            if ((Lv < 0) && (TCell < 0)) return FALSE;
+        }
+        tv->tcell = TCell;
+        return TRUE;
+    }
+}
+
+int TargetCellExpPathSmall(Candidate *TargCand, Partition *Part, struct TracesVars* tv) {
+    int Lv, n;
+    
+    n = tv->input_graph->nv;
+    if (Part->cells == n) {
+        return 0;
+    }
+    
+    Lv = tv->tolevel_tl+1;
+    SpineTL_tl = Spine+Lv;
+    if (tv->tolevel_tl < tv->tcellevel) {
+        tv->tcellexpath = Part->inv[SpineTL_tl->tgtcell];
+        tv->tolevel_tl++;
+        if (Part->cls[tv->tcellexpath] == 1) {
+            if (tv->options->verbosity >= 2) {
+                if (tv->tolevel_tl-tv->tolevel == 6) {
+                    fprintf(outfile, "... ");
+                }
+            }
+            return TargetCellExpPath(TargCand, Part, tv);
+        } else {
+            return 1+((Spine[tv->tolevel_tl].tgtcell >= Spine[tv->tolevel_tl-1].tgtcell) && (Spine[tv->tolevel_tl].tgtend <= Spine[tv->tolevel_tl-1].tgtend));
+        }
+    }
+    else {
+        if (TargetCellFirstPath(TargCand, Part, tv)) {
+            return 1+((Spine[tv->tolevel_tl].tgtcell >= Spine[tv->tolevel_tl-1].tgtcell) && (Spine[tv->tolevel_tl].tgtend <= Spine[tv->tolevel_tl-1].tgtend));
+        }
+        else {
+            return 0;
+        }
+    }
+}
+
+boolean TargetCellFirstPathSmall(Candidate *TargCand, Partition *Part, struct TracesVars* tv) {
+    int n, TCell, TCSize, TCell1, TCSize1;
+    int Lv, i, Lev, vtx, vtx_d;
+    int loopstart, loopend;
+    boolean divided;
+    
+    n = tv->input_graph->nv;
+    if (Part->cells == n) {
+        return 0;
+    }
+    Lev = tv->tolevel_tl;
+    Lv = tv->tolevel_tl;
+    TCell = TCell1 = -1;
+    TCSize = TCSize1 = n;
+    
+    while (TCell < 0) {
+        loopstart = Part->inv[Spine[Lv].tgtcell];
+        divided = FALSE;
+        
+        if (Lv == tv->lastlev) {
+            loopstart = Part->inv[tv->lastcell];
+            divided = TRUE;
+        }
+        
+        i = loopstart;
+        loopend = Spine[Lv].tgtend;
+        
+        while (i < loopend) {
+            if ((Part->cls[i] > 1) && (Part->cls[i] < TCSize)) {
+                vtx = TargCand->lab[i];
+                vtx_d = TheGraph[vtx].d;
+                
+                if (vtx_d > 2) {
+                    if (NonSingDeg(vtx, TargCand, Part) > 2) {
+                        TCSize = Part->cls[i];
+                        TCell = i;
+                        if (TCSize == WorkArray[Lv]) {
+                            break;
+                        }
+                    }
+                }
+            }
+            i += Part->cls[i];
+            if (divided && (i == loopend)) {
+                i = loopstart = Spine[Lv].tgtcell;
+                loopend = tv->lastcell;
+                divided = FALSE;
+                TCSize1 = TCSize;
+                TCell1 = TCell;
+                TCell = -1;
+                TCSize = n;
+            }
+        }
+        
+        if (TCSize1 < TCSize) {
+            TCell = TCell1;
+            TCSize = TCSize1;
+        }
+        
+        if (TCell < 0) {
+            if (Lv == 0) {
+                tv->finalnumcells = min(Part->cells,tv->finalnumcells);    /* 160712 */
+                return FALSE;
+            } else {
+                Lv = Spine[Lv].tgtfrom;
+            }
+        }
+    }
+    tv->tcellexpath = tv->lastcell = TCell;
+    tv->tolevel_tl++;
+    
+    Spine[tv->tolevel_tl].tgtfrom = tv->lastlev = Lv;
+    Spine[tv->tolevel_tl].tgtcell = tv->tcellexpath;
+    Spine[tv->tolevel_tl].tgtsize = WorkArray[Lv] = TCSize;
+    Spine[tv->tolevel_tl].tgtend = Spine[tv->tolevel_tl].tgtcell + TCSize;
+    Spine[tv->tolevel_tl].tgtpos = Spine[tv->tolevel_tl].tgtend - 1;
+    tv->tcellevel = tv->tolevel_tl;
+    
+    if (Lv != Lev) {
+        BreakSteps[Lev] = ++tv->brkstpcount;
+        if (Spine[tv->tolevel].liststart) {
+            if (!Spine[tv->tolevel].liststart->firstsingcode) {
+                Spine[tv->tolevel].liststart->firstsingcode = Spine[tv->tolevel].liststart->pathsingcode;
+            }
+        }
+    }
+    return TRUE;
+}
diff --git a/lib/nauty/traces.h b/lib/nauty/traces.h
new file mode 100644
index 0000000..0e7aa97
--- /dev/null
+++ b/lib/nauty/traces.h
@@ -0,0 +1,64 @@
+/******************************************************************************
+ *                                                                            *
+ * This is the header file for traces() version 2.1, which is included into   *
+ *   nauty() version 2.6.                                                     *
+ *                                                                            *
+ *   nauty is Copyright (1984-2016) Brendan McKay.  All rights reserved.      *
+ *   Traces is Copyright Adolfo Piperno, 2008-2016.  All rights reserved.     *
+ *   See the file COPYRIGHT for the details of the software license.          *
+ *                                                                            *
+ *   CHANGE HISTORY                                                           *
+ *       28-Dec-12 : final changes for version 2.0                            *
+ *       20-Jan-13 : add code for ^C catching in Traces                       *
+ *       29-Mar-13 : bug correction in automorphism mode                      *
+ *       02-Apr-13 : add preprocessing                                        *
+ *       21-May-13 : bug correction (coloured lists)                          *
+ *       29-Jun-13 : bug correction (coloured lists and cycles)               *
+ *       07-Dec-13 : bug correction in automorphism mode (wrong group size    *
+ *                   due to randomness in Schreier-Sims orbit computation)    *
+ *                   bug correction (discrete initial partition)              *
+ *       15-Feb-14 : CPUDEFS removed (already declared in gtools.h)           *
+ *       01-Sep-15 : add weighted edges (not active)                          *
+ *       28-Jan-16 : version ready for nauty and Traces v.2.6 distribution    *
+ *       12-Jul-16 : bug correction (reaching degree 2 vertices)              *
+*****************************************************************************/
+
+#include "gtools.h"
+#include "schreier.h" 
+
+typedef struct TracesOptions {
+	boolean getcanon;
+	boolean writeautoms;
+	boolean cartesian;
+	boolean digraph;
+	boolean defaultptn;
+	int linelength;
+	FILE* outfile;
+	int strategy;    /* Only the value 0 is supported in this version. */
+	int verbosity;
+	permnode **generators;
+    void (*userautomproc)(int,int*,int);
+    int  (*usercanonproc)(graph*,int*,graph*,int,int,int,int);
+    boolean weighted;
+} TracesOptions;
+
+#define DEFAULTOPTIONS_TRACES(opts) TracesOptions opts \
+= { FALSE, FALSE, FALSE, FALSE, TRUE, 0, NULL, 0, 0, NULL, NULL, NULL, FALSE }
+
+typedef struct TracesStats {
+	double grpsize1;
+	int grpsize2;
+	int numgenerators;
+	int numorbits;
+	int treedepth;
+	int canupdates;
+	int errstatus;
+	unsigned long numnodes;
+	unsigned long interrupted;
+	unsigned long peaknodes;
+} TracesStats;
+
+extern void Traces(sparsegraph*,int*,int*,int*,TracesOptions*,
+				   TracesStats*,sparsegraph*);									
+extern void refine_tr(sparsegraph*,int*,int*,int*,int*,TracesOptions*);		
+extern void traces_freedyn(void);
diff --git a/lib/nauty/twohamg.c b/lib/nauty/twohamg.c
new file mode 100644
index 0000000..64e1f11
--- /dev/null
+++ b/lib/nauty/twohamg.c
@@ -0,0 +1,1205 @@
+/* twohamg.c  */
+
+#define USAGE "twohamg [-sgvq] [-L#] [infile [outfile]]"
+
+#define HELPTEXT \
+" Partition quartic graphs into two hamiltonian cycles.\n\
+  Output those which cannot be partitioned.\n\
+\n\
+    -s  force output to sparse6 format\n\
+    -g  force output to graph6 format\n\
+        If neither -s or -g are given, the output format is\n\
+        determined by the header or, if there is none, by the\n\
+        format of the first input graph. Also see -S. \n\
+\n\
+    The output file will have a header if and only if the input file does.\n\
+\n\
+    -p  Read a cubic graph and use its prism. Vertex i of the input becomes\n\
+           vertices 2*i,2*i+1 in the prism.\n\
+    -x  Test for decompositions using each 2-path\n\
+    -X  As -x but only output if two 2-paths are missed at some vertex\n\
+    -y  Test for decompositions using each non-triangular 3-path\n\
+    -t# With -x and -X, consider only paths with center #\n\
+        With -y, consider only paths starting at #\n\
+    -Y  With -p, only consider paths whose central edge is vertical\n\
+    -v  Give a partition for those graphs who have one and a message\n\
+        for those which don't. With -x, list exceptional 2-paths.\n\
+    -L# Limit to 1000*# iterations; write with message if timeout.\n\
+        Graphs that time out are written to the output.\n\
+\n\
+    -q  suppress auxiliary information\n"
+
+#define DEBUG 0
+#define FISHTAIL 1   /* Whether to use fish-tail rule */
+
+/*************************************************************************/
+
+#include "gtools.h"
+
+#define WHITE 0  /* unknown colour */
+#define BLUE 1
+#define RED 2
+
+#define NO 0
+#define YES 1
+#define TIMEOUT 2
+#define NOTHING 3
+
+typedef struct addrval_struct
+{
+    int *addr;
+    int value;
+} addrval;
+
+static long seed = 314159265;
+
+/* valstack is a stack to save and restore degrees, farends, and colours */
+DYNALLSTAT(addrval,valstack,valstack_sz);
+static addrval *valstacktop;
+#define SETVAL(ad,val) { valstacktop->addr = &(ad); \
+     valstacktop->value = ad; ++valstacktop; ad = val; }
+#define UNSETVAL { --valstacktop; *(valstacktop->addr) = valstacktop->value; }
+
+typedef struct p4
+{
+    int e1,e2,e3;
+    int v1,v2,v3,v4;
+    boolean ok;
+} p4;
+
+DYNALLSTAT(int,bluefarend,bluefarend_sz);   /* Parallel to sg.v */
+DYNALLSTAT(int,redfarend,redfarend_sz);   /* Parallel to sg.v */
+DYNALLSTAT(int,eno,eno_sz);         /* Edge numbers, parallel to sg.e */
+DYNALLSTAT(int,cross,cross_sz);         /* Parallel to sg.eno */
+DYNALLSTAT(int,colour,colour_sz);   /* indexed by edge number */
+DYNALLSTAT(int,v1,v1_sz); 
+DYNALLSTAT(int,v2,v2_sz); 
+DYNALLSTAT(int,bluedeg,bluedeg_sz); /* Parallel to sg.v */
+DYNALLSTAT(int,reddeg,reddeg_sz);   /* Parallel to sg.v */
+DYNALLSTAT(int,beste,beste_sz);  /* List of possible best edges */
+DYNALLSTAT(p4,p4list,p4list_sz);  /* List of non-triangular p4s */
+
+/* vstack is a stack of interesting vertices; onstack says whether a
+   vertex is on vstack so that we don't put it there twice */
+DYNALLSTAT(int,vstack,vstack_sz);
+DYNALLSTAT(boolean,onstack,onstack_sz);
+static int *top;
+#define PUSH(v) if (!onstack[v]) { *(top++) = (v); onstack[v] = TRUE; }
+#define POP(v) { v = *(--top); onstack[v] = FALSE; }
+#define STACKISEMPTY (top == vstack)
+
+static nauty_counter nodes,limit,totallimit;
+static nauty_counter locallimit[]
+  = {5,7,10,20,30,40,50,60,70,100,200,400,600,1000,2000,4000,8000,
+     20000,50000,100000,200000,5000000,0};
+#define NUMLIMITS (sizeof(locallimit)/sizeof(locallimit[0]))
+static nauty_counter nphases[100];  /* Must be greater than NUMLIMITS */
+static nauty_counter ntimeouts;
+
+/**************************************************************************/
+
+static void
+makeprism_sg(sparsegraph *sg, sparsegraph *sh)
+/* Make the cartesian product sh = sg x K2.
+   sh must be initialized. */
+{
+    size_t *v,*vv,vi,vvi;
+    int *d,*dd,*e,*ee;
+    int i,j,n;
+
+    SG_VDE(sg,v,d,e);
+    n = sg->nv;
+
+    SG_ALLOC(*sh,2*sg->nv,2*(n+sg->nde),"makeprism_sg");
+    sh->nv = 2*n;
+    sh->nde = 2*(n+sg->nde);
+    SG_VDE(sh,vv,dd,ee);
+ 
+    vvi = 0;
+    for (i = 0; i < n; ++i)
+    {
+	vi = v[i];
+	dd[2*i] = dd[2*i+1] = d[i] + 1;
+	vv[2*i] = vvi;
+	for (j = 0; j < d[i]; ++j) ee[vvi++] = 2*e[vi++];
+	ee[vvi++] = 2*i+1;
+	vi = v[i];
+	vv[2*i+1] = vvi;
+	for (j = 0; j < d[i]; ++j) ee[vvi++] = 2*e[vi++]+1;
+	ee[vvi++] = 2*i;
+    }
+}
+
+/**************************************************************************/
+
+static void
+dumpdata(int id, int nblue, int nred, int n)
+{
+    int i,j;
+
+    printf("%d: nblue=%d nred=%d -------------------------\n",id,nblue,nred);
+
+#if DEBUG > 1
+    for (i = 0; i < n; ++i)
+    {
+        printf("%2d: ",i);
+	for (j = 0; j < 4; ++j)
+	    printf(" %2d%c",eno[4*i+j],"wbr"[colour[eno[4*i+j]]]);
+        printf("   b=%d r=%d bfe=%d rfe=%d\n",
+	    bluedeg[i],reddeg[i],bluefarend[i],redfarend[i]);
+    }
+#endif
+}
+
+/**************************************************************************/
+
+static void
+initialise_g(int n, int *e)
+/* Allocate all and initialise eno[],v1[],v2[]
+   e is a vector like sg.e */
+{
+    int ne,i,j,k,l;
+ 
+    DYNALLOC1(addrval,valstack,valstack_sz,10*n,"malloc");
+    DYNALLOC1(int,bluefarend,bluefarend_sz,n,"malloc");
+    DYNALLOC1(int,redfarend,redfarend_sz,n,"malloc");
+    DYNALLOC1(int,eno,eno_sz,4*n,"malloc"); 
+    DYNALLOC1(int,v1,v1_sz,2*n,"malloc");
+    DYNALLOC1(int,v2,v2_sz,2*n,"malloc");
+    DYNALLOC1(int,colour,colour_sz,2*n,"malloc");
+    DYNALLOC1(int,bluedeg,bluedeg_sz,n,"malloc");
+    DYNALLOC1(int,reddeg,reddeg_sz,n,"malloc");
+    DYNALLOC1(int,vstack,vstack_sz,n,"malloc");
+    DYNALLOC1(boolean,onstack,onstack_sz,n,"malloc");
+    DYNALLOC1(int,beste,beste_sz,2*n,"malloc");
+
+  /* Randomize e; seems to be no purpose for this any more. */
+
+    for (i = 0; i < n; ++i)
+    {
+	j = KRAN(4);
+	k = e[4*i+j]; e[4*i+j] = e[4*i+3]; e[4*i+3] = k; 
+	j = KRAN(3);
+	k = e[4*i+j]; e[4*i+j] = e[4*i+2]; e[4*i+2] = k;
+	j = KRAN(2);
+	k = e[4*i+j]; e[4*i+j] = e[4*i+1]; e[4*i+1] = k;
+    }
+
+    ne = 0;
+    for (i = 0; i < n; ++i)
+    {
+	for (j = 0; j < 4; ++j)
+	{
+	    k = e[4*i+j];
+	    if (k > i)
+	    {
+		v1[ne] = i;
+		v2[ne] = k;
+		eno[4*i+j] = ne++;
+            }
+	    else    /* Note: this code assumes a simple graph */
+	    {
+		for (l = 0; l < 4; ++l)
+		    if (e[4*k+l] == i) break;
+		eno[4*i+j] = eno[4*k+l];
+	    }
+	}
+    }
+    if (ne != 2*n) gt_abort(">E ne is incorrect");
+
+#if DEBUG
+    { int ii;
+        printf("===== n=%d === ne=%d ===================\n",n,ne);
+    
+        for (ii = 0; ii < n; ++ii)
+	    printf("%2d: %2d %2d %2d %2d    %2d %2d %2d %2d\n",
+	       ii,e[4*ii],e[4*ii+1],e[4*ii+2],e[4*ii+3],
+                  eno[4*ii],eno[4*ii+1],eno[4*ii+2],eno[4*ii+3]);
+    }
+#endif
+}
+
+/**************************************************************************/
+
+static void
+initialise_colouring(int n)
+/* Make all edges white */
+{
+    int i;
+
+    for (i = 0; i < 2*n; ++i) colour[i] = WHITE;
+
+    for (i = 0; i < n; ++i)
+    {
+        bluefarend[i] = i;
+        redfarend[i] = i;
+        bluedeg[i] = 0;
+        reddeg[i] = 0;
+        onstack[i] = FALSE;
+    }    
+
+    top = vstack;
+    valstacktop = valstack;
+}
+
+/**************************************************************************/
+
+static boolean
+makeblue(int edge, boolean lastok)
+/* Colour WHITE edge BLUE, return success. 
+   lastok indicates if it is ok to add the final blue edge */
+{
+    int w1,w2,f1,f2;
+
+    w1 = v1[edge];
+    w2 = v2[edge];
+    if (bluedeg[w1] == 2 || bluedeg[w2] == 2) return FALSE;
+
+    f1 = bluefarend[w1];
+    f2 = bluefarend[w2];
+    if (f1 == w2 && !lastok) return FALSE;
+
+    SETVAL(colour[edge],BLUE);
+    SETVAL(bluedeg[w1],bluedeg[w1]+1);
+    SETVAL(bluedeg[w2],bluedeg[w2]+1);
+    SETVAL(bluefarend[f1],f2);
+    SETVAL(bluefarend[f2],f1);
+    PUSH(w1);
+    PUSH(w2);
+    PUSH(f1);
+    // PUSH(f2);   not sure this one is needed
+
+    return TRUE;
+}
+
+/**************************************************************************/
+
+static boolean
+makered(int edge, boolean lastok)
+/* Colour WHITE edge RED, return success. 
+   lastok indicates if it is ok to add the final red edge */
+{
+    int w1,w2,f1,f2;
+
+    w1 = v1[edge];
+    w2 = v2[edge];
+    if (reddeg[w1] == 2 || reddeg[w2] == 2) return FALSE;
+
+    f1 = redfarend[w1];
+    f2 = redfarend[w2];
+    if (f1 == w2 && !lastok) return FALSE;
+
+    SETVAL(colour[edge],RED);
+    SETVAL(reddeg[w1],reddeg[w1]+1);
+    SETVAL(reddeg[w2],reddeg[w2]+1);
+    SETVAL(redfarend[f1],f2);
+    SETVAL(redfarend[f2],f1);
+    PUSH(w1);
+    PUSH(w2);
+    PUSH(f1);
+    // PUSH(f2);   not sure this one is needed
+
+    return TRUE;
+}
+
+/**************************************************************************/
+
+static boolean
+propagate(int n, int *e, int *nblue, int *nred)
+/* Look at active vertices and propagate colourings */
+{
+    int i,j,v,w;
+
+    while (!STACKISEMPTY)
+    {
+	POP(v);
+
+        if (reddeg[v] == 2 && bluedeg[v] < 2)
+        {
+	    for (i = 0; i < 4; ++i)
+	    {
+		j = eno[4*v+i];
+		if (colour[j] == WHITE)
+		{
+		    if (!makeblue(j,*nblue==n-1)) return FALSE;
+		    ++*nblue;
+		}
+	    }
+        }
+	else if (bluedeg[v] == 2 && reddeg[v] < 2)
+        {
+	    for (i = 0; i < 4; ++i)
+	    {
+		j = eno[4*v+i];
+		if (colour[j] == WHITE)
+		{
+		    if (!makered(j,*nred==n-1)) return FALSE;
+		    ++*nred;
+		}
+	    }
+        }
+
+	if (bluedeg[v] == 1)
+	{
+	    w = bluefarend[v];
+	    for (i = 0; i < 4; ++i)
+	        if (e[4*v+i] == w) break;
+            if (i < 4)
+	    {
+		j = eno[4*v+i];
+		if (colour[j] == WHITE)
+		{
+		    if (*nblue == n-1)
+		    {
+			if (!makeblue(j,TRUE)) return FALSE;
+			++*nblue;
+		    }
+		    else
+		    {
+		        if (!makered(j,*nred==n-1)) return FALSE;
+		        ++*nred;
+		    }
+		}
+	    }
+	}
+
+	if (reddeg[v] == 1)
+	{
+	    w = redfarend[v];
+	    for (i = 0; i < 4; ++i)
+	        if (e[4*v+i] == w) break;
+            if (i < 4)
+	    {
+		j = eno[4*v+i];
+		if (colour[j] == WHITE)
+		{
+                    if (*nred == n-1)
+                    {
+                        if (!makered(j,TRUE)) return FALSE;
+                        ++*nred;
+                    }    
+                    else
+                    {
+                        if (!makeblue(j,*nblue==n-1)) return FALSE;
+                        ++*nblue;
+                    }
+		}
+	    }
+        }
+    }
+
+    return TRUE;
+}
+
+/**************************************************************************/
+
+static int
+fishtail(int n, int *nblue, int *nred)
+/* Try to colour edges by the fishtail method
+   Return NO (contradiction), YES (did some good), or NOTHING.  */
+{
+    int i,j;
+    int e1,w1,e2,w2,e3,w3;
+    int edge,col;
+    int ans;
+
+    ans = NOTHING;
+
+    for (i = 0; i < n; ++i)
+    {
+	edge = -1;
+
+	if (reddeg[i] == 1 && bluedeg[i] == 0 && *nblue < n-2)
+	{
+	    j = 4*i;
+	    if (colour[eno[j]] != WHITE) ++j;
+	    e1 = eno[j];
+	    w1 = (v1[e1] == i ? v2[e1] : v1[e1]);
+	    ++j;
+	    if (colour[eno[j]] != WHITE) ++j;
+	    e2 = eno[j];
+	    w2 = (v1[e2] == i ? v2[e2] : v1[e2]);
+	    ++j;
+	    if (colour[eno[j]] != WHITE) ++j;
+	    e3 = eno[j];
+	    w3 = (v1[e3] == i ? v2[e3] : v1[e3]);
+
+	    if (bluedeg[w1] == 1 && bluefarend[w1] == w2)
+	    {
+		edge = e3;
+                col = BLUE;
+	    }
+	    else if (bluedeg[w1] == 1 && bluefarend[w1] == w3)
+	    {
+		edge = e2;
+                col = BLUE;
+	    }
+	    else if (bluedeg[w2] == 1 && bluefarend[w2] == w3)
+	    {
+		edge = e1;
+                col = BLUE;
+	    }
+	}
+	else if (reddeg[i] == 0 && bluedeg[i] == 1 && *nred < n-2)
+	{
+	    j = 4*i;
+	    if (colour[eno[j]] != WHITE) ++j;
+	    e1 = eno[j];
+	    w1 = (v1[e1] == i ? v2[e1] : v1[e1]);
+	    ++j;
+	    if (colour[eno[j]] != WHITE) ++j;
+	    e2 = eno[j];
+	    w2 = (v1[e2] == i ? v2[e2] : v1[e2]);
+	    ++j;
+	    if (colour[eno[j]] != WHITE) ++j;
+	    e3 = eno[j];
+	    w3 = (v1[e3] == i ? v2[e3] : v1[e3]);
+
+	    if (reddeg[w1] == 1 && redfarend[w1] == w2)
+	    {
+		edge = e3;
+                col = RED;
+	    }
+	    else if (reddeg[w1] == 1 && redfarend[w1] == w3)
+	    {
+		edge = e2;
+                col = RED;
+	    }
+	    else if (reddeg[w2] == 1 && redfarend[w2] == w3)
+	    {
+		edge = e1;
+                col = RED;
+	    }
+	}
+	if (edge >= 0)
+	{
+	    if (col == BLUE)
+	    {
+		if (!makeblue(edge,*nblue == n-1)) return NO;
+		++*nblue;
+	    }
+	    else
+	    {
+		if (!makered(edge,*nred == n-1)) return NO;
+		++*nred;
+	    }
+	    ans = YES;
+#if DEBUG
+            printf("Fishtail: %d=(%d-%d) -> %c\n",
+                               edge,v1[edge],v2[edge],"wbr"[col]);
+#endif
+        }
+    }
+
+    return ans;
+}
+
+/**************************************************************************/
+
+static int
+searchnode(int level, int n, int *e, int nblue, int nred)
+{
+    boolean ok;
+    int i,status,nbest;
+    addrval *valptr;
+    int best,score,bestscore;
+    int fe,fc;
+    long ran;
+     
+    ok = propagate(n,e,&nblue,&nred);
+
+#if DEBUG
+    if (ok) dumpdata(level,nblue,nred,n);
+    else { printf("FAIL\n"); return NO; }
+#else
+    if (!ok) return NO;
+#endif
+
+    if (nblue == n && nred == n) return YES;
+
+#if FISHTAIL
+    status = fishtail(n,&nblue,&nred);
+    if (status == NO) return NO;
+    if (status == YES) return searchnode(level+1,n,e,nblue,nred);
+#endif
+
+    valptr = valstacktop;
+
+    bestscore = -1;
+    nbest = 0;
+    for (i = 0; i < 2*n; ++i)
+	if (colour[i] == WHITE)
+        {
+	    score = (bluedeg[v1[i]] == 1) + (bluedeg[v2[i]] == 1) +
+                    (reddeg[v1[i]] == 1) + (reddeg[v2[i]] == 1);
+	    if (score > bestscore)
+	    {
+		bestscore = score;
+		beste[0] = i;
+		nbest = 1;
+	    }
+	    else if (score == bestscore)
+	        beste[nbest++] = i;
+        }
+
+    if (bestscore == 0 && nred + nblue > 0)
+	return FALSE;   /* Disconnected */
+
+    ran = KRAN(2*nbest);
+    best = beste[ran/2];
+
+    if ((ran&1))
+    {
+        if (makeblue(best,nblue==n-1))
+        {
+#if DEBUG
+            printf("   setting %d(%d-%d) blue\n",best,v1[best],v2[best]);
+#endif
+	    status = searchnode(level+1,n,e,nblue+1,nred);
+	    if (status != NO) return status;
+	    while (valstacktop > valptr) UNSETVAL;
+        }
+
+        if (++nodes == limit) return TIMEOUT;
+
+        if (makered(best,nred==n-1))
+        {
+#if DEBUG
+            printf("   setting %d(%d-%d) red\n",best,v1[best],v2[best]);
+#endif
+	    status = searchnode(level+1,n,e,nblue,nred+1);
+	    if (status != NO) return status;
+	    while (valstacktop > valptr) UNSETVAL;
+        }
+    }
+    else
+    {
+        if (makered(best,nred==n-1))
+        {
+#if DEBUG
+            printf("   setting %d(%d-%d) red\n",best,v1[best],v2[best]);
+#endif
+	    status = searchnode(level+1,n,e,nblue,nred+1);
+	    if (status != NO) return status;
+	    while (valstacktop > valptr) UNSETVAL;
+        }
+
+        if (++nodes == limit) return TIMEOUT;
+
+        if (makeblue(best,nblue==n-1))
+        {
+#if DEBUG
+            printf("   setting %d(%d-%d) blue\n",best,v1[best],v2[best]);
+#endif
+	    status = searchnode(level+1,n,e,nblue+1,nred);
+	    if (status != NO) return status;
+	    while (valstacktop > valptr) UNSETVAL;
+        }
+    }
+
+    return NO;
+}
+
+/**************************************************************************/
+
+static int
+dispatchsearch(int n, int *e, int nblue, int nred)
+/* Multiple tries at solution */
+{
+    int i,status;
+    addrval *valptr;
+    boolean ok;
+    nauty_counter remaininglimit;
+
+    ok = propagate(n,e,&nblue,&nred);
+
+#if DEBUG
+    if (ok) dumpdata(0,nblue,nred,n);
+    else { printf("FAIL\n"); ++nphases[0]; return NO; }
+#else
+    if (!ok) { ++nphases[0]; return NO; }
+#endif
+
+    valptr = valstacktop;
+
+    remaininglimit = totallimit;
+
+    for (i = 0; i < NUMLIMITS; ++i)
+    {
+	if (totallimit > 0)
+	{
+	    limit = locallimit[i];
+            if (limit == 0 || limit > remaininglimit) limit = remaininglimit;
+	    remaininglimit -= limit;
+            if (limit == 0) limit = 1;
+	}
+	else
+	    limit = locallimit[i];
+
+	nodes = 0;
+
+	status = searchnode(1,n,e,nblue,nred);
+	if (status != TIMEOUT)
+        {
+	    ++nphases[i+1];
+	    return status;
+	}
+	while (valstacktop > valptr) UNSETVAL;
+    }
+    
+    ++ntimeouts;
+    return TIMEOUT;
+}
+
+/**************************************************************************/
+
+static int
+isdecomposable(sparsegraph sg, int *ham1, int *ham2)
+/* Test if sg is decomposable as two hamiltonian cycles */
+{
+    int nblue,nred,n,e0,status;
+    int i0,i,j,lastv,laste;
+
+    n = sg.nv;
+    initialise_g(n,sg.e);
+    initialise_colouring(n);
+
+    e0 = KRAN(2*n);
+
+    nblue = nred = 0;
+    if (!makeblue(e0,nblue==n-1))   /* make edge e0 blue */
+	return NO;
+    ++nblue;
+
+#if DEBUG
+    printf("   setting %d(%d-%d) blue\n",e0,v1[0],v2[0]);
+#endif
+
+    // status = searchnode(1,n,sg.e,nblue,nred);
+    status = dispatchsearch(n,sg.e,nblue,nred);
+
+    if (status != YES) return status;
+
+    if (!ham1 || !ham2) return YES;
+
+    for (i0 = 0; colour[i0] != BLUE; ++i0) {} 
+    ham1[0] = v1[i0];
+    laste = i0;
+    lastv = ham1[1] = v2[i0];
+    for (i = 2; i < n; ++i)
+    {
+	for (j = 0; j < 4; ++j)
+	    if (eno[4*lastv+j] != laste && colour[eno[4*lastv+j]] == BLUE)
+		break;
+	laste = eno[4*lastv+j];
+	lastv = ham1[i] = (v1[laste] == lastv ? v2[laste] : v1[laste]);
+    }
+
+    for (i0 = 0; colour[i0] != RED; ++i0) {}
+    ham2[0] = v1[i0];
+    laste = i0;
+    lastv = ham2[1] = v2[i0];
+    for (i = 2; i < n; ++i)
+    {
+	for (j = 0; j < 4; ++j)
+	    if (eno[4*lastv+j] != laste && colour[eno[4*lastv+j]] == RED)
+		break;
+	laste = eno[4*lastv+j];
+	lastv = ham2[i] = (v1[laste] == lastv ? v2[laste] : v1[laste]);
+    }
+
+    return YES;
+}
+
+/**************************************************************************/
+
+static int
+iscrossdecomposable(sparsegraph sg, int vertex)
+/* Test if sg is decomposable as two hamiltonian cycles
+   in all ways through each vertex (or the given vertex if it
+   is >= 0.  Details left in cross[].
+   Return -1: not decomposable at all
+           0: misses some 2-paths including two at some vertices
+           1: misses some 2-paths but at most one per vertex
+           2: fully decomposable
+           3: timeout
+*/
+{
+    int i,j,k,l,n,c;
+    int ans,status;
+    int imin,imax;
+
+    n = sg.nv;
+    DYNALLOC1(int,cross,cross_sz,4*n,"malloc");
+
+    if (vertex >= n) gt_abort(">E vertex given to -t is too large");
+
+    for (i = 0; i < 4*n; ++i) cross[i] = 0;
+
+    status = isdecomposable(sg,FALSE,FALSE);
+    if (status == NO) return -1;
+    else if (status == TIMEOUT) return 3;
+
+    for (i = 0; i < n; ++i)
+    {
+	c = colour[eno[4*i]];
+	for (j = 1; j < 4; ++j)
+	    if (colour[eno[4*i+j]] == c) cross[4*i+j] = 1;
+    }
+
+    ans = 2;
+
+    if (vertex >= 0) { imin = imax = vertex; }
+    else             { imin = 0; imax = n-1; }
+
+    for (i = imin; i <= imax; ++i)
+    for (j = 1; j < 4; ++j)
+        if (!cross[4*i+j])
+	{
+	    initialise_colouring(n);
+	    if (makeblue(eno[4*i],FALSE) && makeblue(eno[4*i+j],n==2))
+	    {
+		status = dispatchsearch(n,sg.e,2,0);
+		if (status == TIMEOUT) return 3;
+		if (status == YES)
+		{
+    		    for (k = 0; k < n; ++k)
+    		    {
+		        c = colour[eno[4*k]];
+		        for (l = 1; l < 4; ++l)
+	                if (colour[eno[4*k+l]] == c) cross[4*k+l] = 1;
+                    }
+		}
+		else
+		    ans = 1;
+	    }
+	    else
+	        ans = 1;
+	}
+
+    if (ans == 1)
+        for (i = 0; i < n; ++i)
+	{
+	    if (cross[4*i+1] + cross[4*i+2] + cross[4*i+3] <= 1)
+		ans = 0;
+	}
+
+    return ans;
+}
+
+/**************************************************************************/
+
+static int
+p4decomposition(sparsegraph sg, int vertex, boolean vertical)
+/* Test which non-triangular P4s extend to a decomposition.
+   Return -2: timeout
+          -1: not decomposable at all
+          >=0: number of P4s missed
+   If 0 <= vertex < n, only P4s starting at that vertex are considered.
+   If vertical (only for prisms), the central edge must be vertical.
+   The paths missed can be found in p4list[].
+*/
+{
+    int i,j,k,l,n,c;
+    int ans,status;
+    int imin,imax,nump4;
+    int v1,v2,v3,v4,e1,e2,e3,j1,j2,j3;
+
+    n = sg.nv;
+    if (vertex >= n) gt_abort(">E vertex given to -t is too large");
+
+    status = isdecomposable(sg,FALSE,FALSE);
+    if (status == NO) return -1;
+    else if (status == TIMEOUT) return -2;
+
+    if (vertex >= 0)
+    {
+        imin = imax = vertex; 
+        DYNALLOC1(p4,p4list,p4list_sz,36,"malloc");
+    }
+    else
+    {
+	imin = 0; imax = n-1;
+        DYNALLOC1(p4,p4list,p4list_sz,18*n,"malloc");
+    }
+
+    nump4 = 0;
+    for (v1 = imin; v1 <= imax; ++v1)
+    for (j1 = 0; j1 < 4; ++j1)
+    {
+	v2 = sg.e[4*v1+j1];
+	e1 = eno[4*v1+j1];
+	for (j2 = 0; j2 < 4; ++j2)
+	{
+	    v3 = sg.e[4*v2+j2];
+	    if (v3 == v1) continue;
+	    if (vertical && (v2|1) != (v3|1)) continue;
+	    e2 = eno[4*v2+j2];
+	    for (j3 = 0; j3 < 4; ++j3)
+	    {
+		v4 = sg.e[4*v3+j3];
+		if (v4 == v1 || v4 == v2) continue;
+		e3 = eno[4*v3+j3];
+		if (vertex >= 0 || v1 < v4)
+		{
+		    p4list[nump4].v1 = v1;
+		    p4list[nump4].v2 = v2;
+		    p4list[nump4].v3 = v3;
+		    p4list[nump4].v4 = v4;
+		    p4list[nump4].e1 = e1;
+		    p4list[nump4].e2 = e2;
+		    p4list[nump4].e3 = e3;
+		    p4list[nump4].ok = FALSE;
+		    ++nump4;
+		}
+	    }
+	}
+    }
+
+    for (i = 0; i < nump4; ++i)
+        if (colour[p4list[i].e1] == colour[p4list[i].e2] &&
+	    colour[p4list[i].e1] == colour[p4list[i].e3])
+	    p4list[i].ok = TRUE;
+
+    for (i = 0; i < nump4; ++i)
+        if (!p4list[i].ok)
+	{
+	    initialise_colouring(n);
+	    if (makeblue(p4list[i].e1,FALSE) &&
+	        makeblue(p4list[i].e2,n==2) &&
+		makeblue(p4list[i].e3,n==3))
+	    {
+		status = dispatchsearch(n,sg.e,3,0);
+		if (status == TIMEOUT) return -2;
+		if (status == YES)
+		{
+    		    for (k = 0; k < nump4; ++k)
+    		    {
+			if (p4list[k].ok) continue;
+			if (colour[p4list[k].e1] == colour[p4list[k].e2]
+                         && colour[p4list[k].e1] == colour[p4list[k].e3])
+                           p4list[k].ok = TRUE;
+                    }
+		}
+	    }
+	}
+
+    ans = 0;
+    for (i = 0; i < nump4; ++i) if (!p4list[i].ok) ++ans;
+
+    return ans;
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    sparsegraph sg,sh,*this;
+    int n,codetype;
+    int argnum,i,j,outcode;
+    char *arg,sw;
+    boolean badargs;
+    boolean sswitch,gswitch,qswitch,vswitch,xswitch,Xswitch;
+    boolean pswitch,Lswitch,tswitch,yswitch,Yswitch;
+    long Lvalue;
+    double t;
+    char *infilename,*outfilename;
+    FILE *infile,*outfile;
+    nauty_counter nin,nout;
+    int status,xstatus,ystatus,tvalue,imin,imax;
+    DYNALLSTAT(int,ham1,ham1_sz);
+    DYNALLSTAT(int,ham2,ham2_sz);
+
+    HELP; PUTVERSION;
+
+    INITSEED;
+    ran_init(seed);
+
+    sswitch = gswitch = yswitch = qswitch = vswitch = FALSE;
+    tswitch = xswitch = Xswitch = Lswitch = pswitch = FALSE;
+    Yswitch = FALSE;
+    infilename = outfilename = NULL;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWBOOLEAN('s',sswitch)
+                else SWBOOLEAN('g',gswitch)
+                else SWBOOLEAN('q',qswitch)
+                else SWBOOLEAN('x',xswitch)
+                else SWBOOLEAN('y',yswitch)
+                else SWBOOLEAN('Y',Yswitch)
+                else SWBOOLEAN('X',Xswitch)
+                else SWBOOLEAN('v',vswitch)
+		else SWBOOLEAN('p',pswitch)
+		else SWLONG('L',Lswitch,Lvalue,"-L")
+		else SWINT('t',tswitch,tvalue,"-t")
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if (sswitch && gswitch) 
+        gt_abort(">E twohamg: -s and -g are incompatible");
+    if ((xswitch != 0) + (Xswitch != 0)
+               + (yswitch != 0) + (Yswitch != 0) > 1)
+        gt_abort(">E twohamg: -x, -X, -y, -Y are incompatible");
+    if (Yswitch && !pswitch)
+        gt_abort(">E twohang: -Y is not allowed without -p");
+
+    if (!Lswitch) totallimit = 0;
+    else          totallimit = Lvalue * (nauty_counter)1000;
+
+    if (!tswitch) tvalue = -1;
+
+    if (badargs || argnum > 2)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if (!qswitch)
+    {
+        fprintf(stderr,">A twohamg");
+        if (sswitch || gswitch || vswitch || xswitch || Xswitch 
+                || tswitch || pswitch || Lswitch || yswitch || Yswitch)
+            fprintf(stderr," -");
+        if (sswitch) fprintf(stderr,"s");
+        if (gswitch) fprintf(stderr,"g");
+        if (xswitch) fprintf(stderr,"x");
+        if (Xswitch) fprintf(stderr,"X");
+        if (yswitch) fprintf(stderr,"y");
+        if (Yswitch) fprintf(stderr,"Y");
+        if (pswitch) fprintf(stderr,"p");
+        if (vswitch) fprintf(stderr,"v");
+	if (Lswitch) fprintf(stderr,"L%ld",Lvalue);
+	if (tswitch) fprintf(stderr,"t%d",tvalue);
+        if (argnum > 0) fprintf(stderr," %s",infilename);
+        if (argnum > 1) fprintf(stderr," %s",outfilename);
+        fprintf(stderr,"\n");
+        fflush(stderr);
+    }
+
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,FALSE,1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    if (!outfilename || outfilename[0] == '-')
+    {
+        outfilename = "stdout";
+        outfile = stdout;
+    }
+    else if ((outfile = fopen(outfilename,"w")) == NULL)
+    {
+        fprintf(stderr,"Can't open output file %s\n",outfilename);
+        gt_abort(NULL);
+    }
+
+    NODIGRAPHSYET(codetype);
+
+    if (sswitch || (!gswitch && (codetype&SPARSE6)))
+        outcode = SPARSE6;
+    else 
+        outcode = GRAPH6;
+
+    if (codetype&HAS_HEADER)
+    {
+        if (outcode == SPARSE6) writeline(outfile,SPARSE6_HEADER);
+        else                    writeline(outfile,GRAPH6_HEADER);
+    }
+
+    nin = nout = 0;
+    t = CPUTIME;
+    SG_INIT(sg);
+    SG_INIT(sh);
+
+    while (read_sg(infile,&sg) != NULL)
+    {
+        ++nin;
+        if (pswitch)
+	{
+            n = sg.nv;
+            for (i = 0; i < n; ++i)
+                if (sg.d[i] != 3) break;
+            if (i != n)
+            {
+                fprintf(stderr,
+                        ">W input " COUNTER_FMT " is not cubic\n",nin);
+                continue;
+            }
+	    makeprism_sg(&sg,&sh);
+	    n = sh.nv;
+	    this = &sh;
+	}
+	else
+	{
+            n = sg.nv;
+            for (i = 0; i < n; ++i)
+                if (sg.d[i] != 4) break;
+            if (i != n)
+            {
+                fprintf(stderr,
+                        ">W input " COUNTER_FMT " is not quartic\n",nin);
+                continue;
+            }
+            for (i = 0; i < n; ++i)
+                if (sg.v[i] != 4*i) break;
+            if (i != n)
+                gt_abort("readg6_sg() result is not in standard form");
+	    this = &sg;
+	}
+
+	if (xswitch || Xswitch)
+	{
+	    xstatus = iscrossdecomposable(*this,tvalue);
+	    if ((xswitch && xstatus < 2) || (Xswitch && xstatus < 1))
+	    {
+		if (outcode == SPARSE6) writes6_sg(outfile,&sg);   
+                else if (outcode == GRAPH6) writeg6_sg(outfile,&sg);
+                ++nout;
+
+		if (vswitch)
+		{
+		    if (xstatus < 0)
+		    {
+                        fprintf(stderr,">H Graph " COUNTER_FMT
+                                     " is indecomposable\n",nin);
+		    }
+		    else
+		    {
+		        fprintf(stderr,">X" COUNTER_FMT ": ",nin);
+			if (tswitch) { imin = imax = tvalue; }
+			else         { imin = 0; imax = n-1; }
+		        for (i = imin; i <= imax; ++i)
+		        for (j = 1; j < 4; ++j)
+			    if (!cross[4*i+j])
+			    {
+			        fprintf(stderr," %d-%d-%d",
+			            (v1[eno[4*i]] == i
+                                       ? v2[eno[4*i]] : v1[eno[4*i]]),
+			            i,
+			            (v1[eno[4*i+j]] == i
+                                       ? v2[eno[4*i+j]] : v1[eno[4*i+j]]));
+		            }
+		        fprintf(stderr,"\n");
+		    }
+		}
+	    }
+	    else if (xstatus == 3)
+	    {
+		fprintf(stderr,">H Graph " COUNTER_FMT
+                                     " timed out\n",nin);
+		if (outcode == SPARSE6) writes6_sg(outfile,&sg);
+                else if (outcode == GRAPH6) writeg6_sg(outfile,&sg);
+                ++nout;
+	    }
+	}
+	else if (yswitch || Yswitch)
+        {
+	    ystatus = p4decomposition(*this,tvalue,Yswitch);
+	    if (ystatus != 0)
+	    {
+		if (outcode == SPARSE6) writes6_sg(outfile,&sg);   
+                else if (outcode == GRAPH6) writeg6_sg(outfile,&sg);
+                ++nout;
+	    }
+
+	    if (ystatus == -2)
+	    {
+		fprintf(stderr,">H Graph " COUNTER_FMT
+                                     " timed out\n",nin);
+	    }
+	    else if (vswitch)
+	    {
+		if (ystatus == -1)
+		{
+                    fprintf(stderr,">H Graph " COUNTER_FMT
+                                     " is indecomposable\n",nin);
+		}
+		else if (ystatus > 0)
+		{
+		    fprintf(stderr,">X" COUNTER_FMT ": ",nin);
+		    for (i = j = 0; j < ystatus; ++i)
+		        if (!p4list[i].ok)
+			{
+			    ++j;
+			    fprintf(stderr," %d-%d-%d-%d",
+				p4list[i].v1,p4list[i].v2,
+				p4list[i].v3,p4list[i].v4);
+		        }
+		    fprintf(stderr,"\n");
+		}
+	    }
+        }
+	else
+	{
+            if (vswitch)
+            {
+	        DYNALLOC1(int,ham1,ham1_sz,n,"malloc");
+	        DYNALLOC1(int,ham2,ham2_sz,n,"malloc");
+                status = isdecomposable(*this,ham1,ham2);
+            }
+	    else
+	        status = isdecomposable(*this,NULL,NULL);
+    
+            if (status != YES)
+            {
+                if (outcode == SPARSE6) writes6_sg(outfile,&sg);
+                else if (outcode == GRAPH6) writeg6_sg(outfile,&sg);
+
+		if (status == TIMEOUT)
+		    fprintf(stderr,">H Graph " COUNTER_FMT
+                                     " timed out\n",nin);
+                else if (vswitch)
+                    fprintf(stderr,">H Graph " COUNTER_FMT
+                                     " is indecomposable\n",nin);
+	        ++nout;
+            }
+            else if (vswitch)
+            {
+#if DEBUG
+	        dumpdata(0,0,0,n);
+#endif
+                fprintf(stderr,">H" COUNTER_FMT ": ",nin);
+	        for (i = 0; i < n; ++i) fprintf(stderr," %d",ham1[i]);
+	        fprintf(stderr,"\n ");
+	        for (i = 0; i < n; ++i) fprintf(stderr," %d",ham2[i]);
+	        fprintf(stderr,"\n");
+            }
+	}
+    }
+    t = CPUTIME - t;
+
+    if (!qswitch)
+    {
+	fprintf(stderr,">T to=" COUNTER_FMT " phases=",ntimeouts);
+	for (i = 0; i <= NUMLIMITS; ++i)
+	    fprintf(stderr," " COUNTER_FMT,nphases[i]);
+	fprintf(stderr,"\n");
+
+        fprintf(stderr,
+                ">Z " COUNTER_FMT " graphs read from %s, "
+                COUNTER_FMT " written to %s; %3.2f sec.\n",
+                nin,infilename,nout,outfilename,t);
+    }
+
+    exit(0);
+}
diff --git a/lib/nauty/vcolg.c b/lib/nauty/vcolg.c
new file mode 100644
index 0000000..44a947f
--- /dev/null
+++ b/lib/nauty/vcolg.c
@@ -0,0 +1,529 @@
+/* vcolg.c version 1.0; B D McKay, Aug 31, 2013 */
+
+#define USAGE \
+"vcolg [-q] [-u|-T|-G|-A|-B] [-e#|-e#:#] \n" \
+"       [-m#] [-f#] [-D#|-r#|-l#] [infile [outfile]]"
+
+#define HELPTEXT \
+" Read undirected loop-free graphs and colour their vertices in\n\
+  in all possible ways with colours 0,1,2,... .\n\
+  Isomorphic graphs derived from the same input are suppressed.\n\
+  If the input graphs are non-isomorphic then the output graphs are also.\n\
+\n\
+    -e# | -e#:#  specify a value or range of the total value of the colours\n\
+    -m# number of available colours (default 2)\n\
+    -f# Use the group that fixes the first # vertices setwise\n\
+    -T  use a simple text output format (nv ne {col} {v1 v2})\n\
+    -u  no output, just count them\n\
+    -q  suppress auxiliary information\n"
+
+/*************************************************************************/
+
+#include "gtools.h"
+#include "naugroup.h"
+
+nauty_counter vc_nin,vc_nout;
+FILE *outfile;
+
+#define MAXNV 128 
+#define MAXNE 1024
+
+static int col[MAXNV];
+static boolean first;
+static int lastreject[MAXNV];
+static boolean lastrejok;
+static unsigned long groupsize;
+static unsigned long newgroupsize;
+static boolean Tswitch;
+
+static int fail_level;
+
+#define GROUPTEST_NOT 
+#ifdef GROUPTEST
+static long long totallab;
+#endif
+
+/* If OUTPROC is defined at compile time, and -u is not used, the
+ * procedure OUTPROC is called for each graph.  This must be linked
+ * by the compiler.  The arguments are
+ * f = open output file
+ * g = the input graph
+ * col[0..n-1] = the colours
+ * m,n = usual nauty meanings
+ */
+
+/* SUMMARY feature
+ *
+ * If SUMMARY is defined, it must expand as the name of a procedure
+ * with prototype  void SUMMARY(void).  It is called at the end before
+ * the normal summary (which can be suppressed with -q).  The numbers of
+ * graphs read and coloured graphs produced are available in the global
+ * variables vc_nin and vc_nout (type nauty_counter).
+ */
+
+#ifdef OUTPROC
+extern void OUTPROC(FILE*,graph*,int*,int,int);
+#endif
+
+#ifdef SUMMARY
+extern void SUMMARY(void);
+#endif
+
+/**************************************************************************/
+
+static void
+writeautom(int *p, int n)
+/* Called by allgroup. */
+{
+    int i;
+
+    for (i = 0; i < n; ++i) printf(" %2d",p[i]);
+    printf("\n");
+}
+
+/**************************************************************************/
+
+static int
+ismax(int *p, int n)
+/* test if col^p <= col */
+{
+    int i,k;
+    int fail;
+
+    fail = 0;
+    for (i = 0; i < n; ++i)
+    {
+	k = p[i];
+	if (k > fail) fail = k;
+        if (col[k] > col[i])
+        {
+            fail_level = fail;
+            return FALSE;
+        }
+        else if (col[k] < col[i]) return TRUE;
+    }
+
+    ++newgroupsize;
+    return TRUE;
+}
+
+/**************************************************************************/
+
+static void
+testmax(int *p, int n, int *abort)
+/* Called by allgroup2. */
+{
+    int i;
+
+    if (first)
+    {                       /* only the identity */
+        first = FALSE;
+        return;
+    }
+
+    if (!ismax(p,n))
+    {
+        *abort = 1;
+        for (i = 0; i < n; ++i) lastreject[i] = p[i];
+        lastrejok = TRUE;
+    }
+}
+
+/**************************************************************************/
+
+static int
+trythisone(grouprec *group, graph *g, int m, int n)
+/* Try one solution, accept if maximal. */
+/* Return value is level to return to. */
+{
+    int i,j;
+    boolean accept;
+    graph *gi;
+    size_t ne;
+
+    newgroupsize = 1;
+
+    if (!group || groupsize == 1)
+        accept = TRUE;
+    else if (lastrejok && !ismax(lastreject,n))
+        accept = FALSE;
+    else if (lastrejok && groupsize == 2)
+        accept = TRUE;
+    else
+    {
+        newgroupsize = 1;
+        first = TRUE;
+
+        if (allgroup2(group,testmax) == 0)
+            accept = TRUE;
+        else
+            accept = FALSE;
+    }
+
+    if (accept)
+    {
+#ifdef GROUPTEST
+        if (groupsize % newgroupsize != 0)
+                    gt_abort("group size error\n");
+        totallab += groupsize/newgroupsize;
+#endif
+
+        ++vc_nout;
+
+        if (outfile)
+        {
+#ifdef OUTPROC
+            OUTPROC(outfile,g,col,m,n);
+#else
+	    ne = 0;
+	    for (gi = g + m*(size_t)n; --gi >= g; )
+		ne += POPCOUNT(*gi);
+	    ne /= 2;
+            fprintf(outfile,"%d %lu",n,(unsigned long)ne);
+    
+	    for (i = 0; i < n; ++i) fprintf(outfile," %d",col[i]);
+	    fprintf(outfile," ");
+	    for (i = 0, gi = g; i < n; ++i, gi += m)
+	    {
+		for (j = i; (j = nextelement(gi,m,j)) >= 0; )
+                    fprintf(outfile," %d %d",i,j);
+	    }
+            fprintf(outfile,"\n");
+#endif
+        }
+        return n-1;
+    }
+    else
+        return fail_level-1;
+}
+
+/**************************************************************************/
+
+static int
+scan(int level, graph *g, int *prev, long minedges, long maxedges,
+    long sofar, long numcols, grouprec *group, int m, int n)
+/* Recursive scan for default case */
+/* Returned value is level to return to. */
+{
+    int left;
+    long min,max,k,ret;
+
+    if (level == n)
+        return trythisone(group,g,m,n);
+
+    left = n - level - 1;
+    min = minedges - sofar - numcols*left;
+    if (min < 0) min = 0;
+    max = maxedges - sofar;
+    if (max >= numcols) max = numcols - 1;
+    if (prev[level] >= 0 && col[prev[level]] < max)
+	max = col[prev[level]];
+
+    for (k = min; k <= max; ++k)
+    {
+        col[level] = k;
+        ret = scan(level+1,g,prev,minedges,maxedges,sofar+k,numcols,group,m,n);
+	if (ret < level) return ret;
+    }
+
+    return level-1;
+}
+
+/**************************************************************************/
+
+#define SORT_OF_SORT 3
+#define SORT_NAME sortwt
+#define SORT_TYPE1 int
+#define SORT_TYPE2 int
+#include "sorttemplates.c"
+
+static void
+setlab(int *weight, int *lab, int *ptn, int n)
+/* Define (lab,ptn) according to weights. */
+{
+    int i;
+
+    for (i = 0; i < n; ++i) lab[i] = i;
+
+    sortwt(lab,weight,n);
+    for (i = 0; i < n-1; ++i)
+    {
+        if (weight[lab[i]] != weight[lab[i+1]])
+	    ptn[i] = 0;
+	else
+	    ptn[i] = 1;
+    }
+    ptn[n-1] = 0;
+}
+
+/**************************************************************************/
+
+static void
+colourit(graph *g, int nfixed, long minedges, long maxedges,
+         long numcols, int m, int n)
+{
+    static DEFAULTOPTIONS_GRAPH(options);
+    statsblk stats;
+    setword workspace[100];
+    grouprec *group;
+    int i,j,k;
+    set *gi,*gj;
+    int lab[MAXNV],ptn[MAXNV],orbits[MAXNV],deg[MAXNV];
+    int prev[MAXNV]; /* If >= 0, earlier point that must have greater colour */
+    int weight[MAXNV];
+    int last0,lastn,thisdeg,region,start,stop;
+
+    if (n > MAXNV) gt_abort(">E vcolg: MAXNV exceeded\n");
+    nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
+
+    for (region = 0; region < 2; ++region)
+    {
+	if (region == 0)
+	{
+	    if (nfixed == 0) continue;
+	    start = 0;
+	    stop = nfixed;
+	    if (stop > n) stop = n;
+	}
+	else
+	{
+	    if (nfixed >= n) continue;
+	    start = nfixed;
+	    stop = n;
+	}
+	
+	for (i = start, gi = g + m*(size_t)start; i < stop; ++i, gi += m)
+	{
+	    for (j = i-1, gj = gi-m; j >= start; --j, gj -= m)
+	    {
+		for (k = 0; k < m; ++k) if (gi[k] != gj[k]) break;
+		if (k < m)
+		{
+		    FLIPELEMENT(gi,i); FLIPELEMENT(gj,j);
+		    for (k = 0; k < m; ++k) if (gi[k] != gj[k]) break;
+		    FLIPELEMENT(gi,i); FLIPELEMENT(gj,j);
+		}
+		if (k == m) break;
+	    }
+	    if (j >= start)
+	    {
+		prev[i] = j;
+		weight[i] = weight[j] + 1;
+	    }
+	    else
+	    {
+		prev[i] = -1;
+		weight[i] = 0;
+	    }
+	}
+    }
+
+    for (i = nfixed; i < n; ++i) weight[i] += nfixed;
+
+    if (maxedges == NOLIMIT || maxedges > n*numcols) maxedges = n*numcols;
+    if (n*numcols < minedges) return;
+
+    options.userautomproc = groupautomproc;
+    options.userlevelproc = grouplevelproc;
+    options.defaultptn = FALSE;
+
+    setlab(weight,lab,ptn,n);
+ 
+    nauty(g,lab,ptn,NULL,orbits,&options,&stats,workspace,100,m,n,NULL);
+
+    if (stats.grpsize2 == 0)
+        groupsize = stats.grpsize1 + 0.1;
+    else
+        groupsize = 0;
+
+    group = groupptr(FALSE);
+    makecosetreps(group);
+
+    if (stats.numorbits < n)
+    {
+	j = n;
+	for (i = 0; i < n; ++i)
+	    if (orbits[i] < i && orbits[i] < j) j = orbits[i];
+
+	for (i = j + 1; i < n; ++i)
+	    if (orbits[i] == j) prev[i] = j;
+    }
+
+    lastrejok = FALSE;
+    for (i = 0; i < n; ++i) col[i] = 0;
+
+    scan(0,g,prev,minedges,maxedges,0,numcols,group,m,n);
+}
+
+/**************************************************************************/
+
+int
+main(int argc, char *argv[])
+{
+    graph *g;
+    int i,m,n,codetype;
+    int argnum,j,nfixed;
+    char *arg,sw;
+    boolean badargs;
+    boolean fswitch,uswitch,eswitch,qswitch,mswitch;
+    long minedges,maxedges,numcols;
+    double t;
+    char *infilename,*outfilename;
+    FILE *infile;
+    char msg[201];
+    int msglen;
+
+    HELP; PUTVERSION;
+
+    nauty_check(WORDSIZE,1,1,NAUTYVERSIONID);
+
+    fswitch = Tswitch = FALSE;
+    uswitch = eswitch = mswitch = qswitch = FALSE;
+    infilename = outfilename = NULL;
+
+    argnum = 0;
+    badargs = FALSE;
+    for (j = 1; !badargs && j < argc; ++j)
+    {
+        arg = argv[j];
+        if (arg[0] == '-' && arg[1] != '\0')
+        {
+            ++arg;
+            while (*arg != '\0')
+            {
+                sw = *arg++;
+                     SWLONG('m',mswitch,numcols,"vcolg -m")
+                else SWBOOLEAN('q',qswitch)
+                else SWBOOLEAN('u',uswitch)
+                else SWBOOLEAN('T',Tswitch)
+                else SWINT('f',fswitch,nfixed,"vcolg -f")
+                else SWRANGE('e',":-",eswitch,minedges,maxedges,"vcolg -e")
+                else badargs = TRUE;
+            }
+        }
+        else
+        {
+            ++argnum;
+            if      (argnum == 1) infilename = arg;
+            else if (argnum == 2) outfilename = arg;
+            else                  badargs = TRUE;
+        }
+    }
+
+    if (badargs || argnum > 2)
+    {
+        fprintf(stderr,">E Usage: %s\n",USAGE);
+        GETHELP;
+        exit(1);
+    }
+
+    if ((Tswitch!=0) + (uswitch!=0) >= 2)
+        gt_abort(">E vcolg: -T and -u are incompatible\n");
+
+#ifndef OUTPROC
+    if (!Tswitch && !uswitch)
+        gt_abort(">E vcolg: must use -T or -u\n");
+#endif
+
+    if (!mswitch) numcols = 2;
+    if (!eswitch)
+    {
+        minedges = 0;
+        maxedges = NOLIMIT;
+    }
+    if (!fswitch) nfixed = 0;
+
+    if (!qswitch)
+    {
+        msg[0] = '\0';
+        CATMSG0(">A vcolg");
+        if (eswitch || mswitch || uswitch || (fswitch && nfixed > 0)
+              || Tswitch)
+            CATMSG0(" -");
+        if (mswitch) CATMSG1("m%ld",numcols);
+        if (uswitch) CATMSG0("u");
+        if (Tswitch) CATMSG0("T");
+        if (fswitch) CATMSG1("f%d",nfixed);
+        if (eswitch) CATMSG2("e%ld:%ld",minedges,maxedges);
+        msglen = strlen(msg);
+        if (argnum > 0) msglen += strlen(infilename);
+        if (argnum > 1) msglen += strlen(outfilename);
+        if (msglen >= 196)
+        {
+            fputs(msg,stderr);
+            if (argnum > 0) fprintf(stderr," %s",infilename);
+            if (argnum > 1) fprintf(stderr," %s",outfilename);
+            fprintf(stderr,"\n");
+        }
+        else
+        {
+            if (argnum > 0) CATMSG1(" %s",infilename);
+            if (argnum > 1) CATMSG1(" %s",outfilename);
+            CATMSG0("\n");
+            fputs(msg,stderr);
+        }
+        fflush(stderr);
+    }
+
+    if (infilename && infilename[0] == '-') infilename = NULL;
+    infile = opengraphfile(infilename,&codetype,FALSE,1);
+    if (!infile) exit(1);
+    if (!infilename) infilename = "stdin";
+
+    NODIGRAPHSYET(codetype);
+
+    if (uswitch)
+        outfile = NULL;
+    else
+    {
+        if (!outfilename || outfilename[0] == '-')
+        {
+            outfilename = "stdout";
+            outfile = stdout;
+        }
+        else if ((outfile = fopen(outfilename,"w")) == NULL)
+        {
+            fprintf(stderr,"Can't open output file %s\n",outfilename);
+            gt_abort(NULL);
+        }
+    }
+
+    vc_nin = vc_nout = 0;
+
+    t = CPUTIME;
+    while (TRUE)
+    {
+        if ((g = readg(infile,NULL,0,&m,&n)) == NULL) break;
+        ++vc_nin;
+
+        colourit(g,nfixed,minedges,maxedges,numcols,m,n);
+	if (!uswitch && ferror(outfile))
+	    gt_abort(">E vcolg output error\n");
+        FREES(g);
+    }
+    t = CPUTIME - t;
+
+#ifdef SUMMARY
+    SUMMARY();
+#endif
+
+    if (!qswitch)
+    {
+        fprintf(stderr,">Z ");
+        PRINT_COUNTER(stderr,vc_nin);
+        fprintf(stderr," graphs read from %s",infilename);
+        fprintf(stderr,"; ");
+        PRINT_COUNTER(stderr,vc_nout);
+        if (!uswitch)
+            fprintf(stderr," coloured graphs written to %s",outfilename);
+        else
+            fprintf(stderr," coloured graphs generated");
+        fprintf(stderr,"; %.2f sec\n",t);
+    }
+
+#ifdef GROUPTEST
+    fprintf(stderr,"Group test = %lld\n",totallab);
+#endif
+
+    exit(0);
+}
diff --git a/lib/nauty/watercluster2.c b/lib/nauty/watercluster2.c
new file mode 100644
index 0000000..db14b14
--- /dev/null
+++ b/lib/nauty/watercluster2.c
@@ -0,0 +1,4078 @@
+// cc -O4 -o water2 -DWORDSIZE=32 -DMAXN=WORDSIZE nauty.c naugraph.c nautil.c gtools.c schreier.c naurng.c watercluster2.c
+
+/*
+Reads graphs in g6 code or multicode (optional) from stdin and directs them 
+
+options: 
+
+ix  means: the indegree of every vertex may be at most x.
+
+oy  means: the outdegree of every vertex may be at most y.
+
+  S  means: allow that for every pair of vertices x,y at most one of the edges x-->y 
+     and y-->x may be present. By default both of them may be present in the same graph.
+
+
+  T  means: Output directed graphs in T-code. This is a simple ASCII output format. Every line
+     contains one graph. First the number of vertices, then the number of 
+     directed edges and then the list of directed edges with the start first 
+     and the end then. E.g.: 3 2 0 1 2 1 means 3 vertices, 2 directed edges:
+     0-->1 and 2-->1
+
+  B  means: Output the directed graphs in a binary code. Every item of the code is an unsigned
+     char. The first unsigned char is the number nv of vertices. The vertices are numbered 1..nv
+     Then the list of vertices x for which there is a directed edge 1->x follow. This list is
+     ended by a 0. Then the list of outgoing neighbours of 2 follows -- again ended with a 0, etc.
+     The code is complete with the 0 ending the list of outgoing neighbours of nv.
+
+  C  means: Do really construct all the directed graphs in memory, but don't output them. This is not
+     a big difference in case of restricted in- and outdegrees, because all that is done extra is that 
+     edges are directed instead of just keeping track of in- and out-degrees. This option is intended only
+     for testing purposes to test also routines that are normally not used when counting. Things that would 
+     speed up the counting also in some cases of restricted in- and out-degrees -- like multiplying the 
+     possibilities of assigning directions to edges that can be assigned directions independent 
+     of each other (depending on the degrees of the endvertices and overlaps) -- are not included. 
+     In case of not restrictive bounds on the in- and out-degree it not really constructing the graphs
+     can be considerably faster. In cases of restricted in- and out-degrees the only difference is that
+     the graph isn't modified...
+     The fact that in case of no output the graph is not modified is mainly to save time for the one 
+     case of waterclusters, where large numbers were determined. If large numbers (without output)
+     for other cases shall be determined, one should think about adding the multiplication routines.
+
+   m read multicode
+
+This program uses different labelling routines -- all based on the ideas of 
+
+G. Brinkmann, Generating water clusters and other directed graphs,
+Journal of Mathematical Chemistry 46, 1112--1121 (2009)
+
+October 10, 2011: corrected error caused by overflow of 32bit int used as hashvalue.
+
+Sep, 2012: PROCESS feature added by BDM.
+*/
+
+/* PROCESS feature
+ *
+ * If PROCESS is defined, it must expand as the name of a procedure
+ * with prototype like void PROCESS(FILE *f, graph *g, int n). This
+ * procedure will be called for each output graph before it is
+ * output (or before output is suppressed) with f being the output
+ * file (possibly NULL).
+ * It is an error if n > WORDSIZE.
+ * If NOCONVERSE is also defined, the call is only made for one of
+ * each digraph and its converse.
+ */
+
+/* SUMMARY feature
+ *
+ * If SUMMARY is defined, it must expand as the name of a procedure
+ * with prototype  void SUMMARY(void).  It is called at the end after
+ * the normal summary. 
+ */
+
+//#include<stdio.h>
+#include "nauty.h"
+#include<limits.h>
+#include<string.h>
+
+#ifdef PROCESS
+extern void PROCESS(FILE*,graph*,int);
+nauty_counter dg_nin,dg_nout;
+#endif
+#ifdef SUMMARY
+extern void SUMMARY(void);
+#endif
+
+#define MAX_BOGEN ((MAXN*(MAXN-1))/2)
+#define INFTY_UCHAR UCHAR_MAX
+typedef int BOOG[2];
+
+void nontrivlabels(), init_nauty_options();
+
+BOOG edgelist[MAX_BOGEN+1]; /* de lijst van bogen */
+BOOG edgelist_final[MAX_BOGEN+1]; /* de lijst van bogen die nadat er eerst nontriviale automorphismen waren die dan 
+				  verdwenen nog gericht moeten worden.*/
+BOOG *laatstepositie; /* The last position in one of these lists. Global in order not to have to copy it every time */
+
+/* all the next variables must be evaluated immediately when orbits are constructed. They are reused in the next
+   iteration */
+unsigned char *operations=NULL;
+int *root_op=NULL, size_root=0, blocklength, orbitblocklength[MAXN], size_operations=0, number_operations=0;
+/* these arrays will be dynamically allocated and extended. Operations will be an array with "blocks" of length
+   "blocklength=tobedirected[vertex_in_orbit]+3". They represent an operation the following way: the first entry is the central
+   vertex then the list of vertices from which only edges come in -- ended by INFTY_UCHAR, then the list of vertices 
+   to which only outgoing edges go -- ended by INFTY_UCHAR. Then the list of vertices to which incoming AND outgoing 
+   edges go -- ended by INFTY_UCHAR. 
+
+   root has as many entries as there are blocks in operations. root[i]=j means that when computing the orbits of
+   operations and constructing a union-find-tree, block number j is the root of the tree containing vertex i. */
+
+unsigned char *remember_operations[MAXN]; //the nonequivalent operations that are stored for every iteration
+int remember_size[MAXN]; // remember_size[i] is the number of characters allocated for remember_operations[i]
+
+#define COPYBOOG(a,b) { (a)[0]=(b)[0]; (a)[1]=(b)[1]; }
+
+
+/* OPTIONS */
+boolean dummybool;
+int mingerichtdeg;
+int remaining_doubles=0; /* hoeveel bogen kunnen ten hoogste nog in allebei 
+			    richtingen gericht worden ? */
+int watermaxedges; /* what is the theoretical maximum for the number of edges which can
+		      directed in a way that doesn't give a conflict with the in/out-degree
+		      bounds. */
+int watermaxdeg; /* maxindeg+maxoutdeg */
+
+int is_gericht[MAX_BOGEN][MAX_BOGEN]={{0}}; /*  is_gericht[i][j]==1 als {i,j} is al gericht -- anders 0 */
+int virtual_gericht[MAX_BOGEN][MAX_BOGEN]={{0}}; /*  virtual_gericht[i][j]==1 als het al vastgelegd is dat {i,j} 
+						    i->j gericht moet worden, 2 als hij j->i gericht moet worden
+						    en 0 als het nog niet vastgelegd is. Vastgelegd betekent door
+						    de beperkingen van in- en outgraad moet deze boog zo gericht 
+						    worden. */
+int positie[MAXN][MAXN]; /* the value of positie[i][j] is the position of edge {1,j} in edgelist in case of
+			    nontrivial automorphisms of the underlying undirected graph. */
+
+int virtual_indeg[MAXN], virtual_outdeg[MAXN]; 
+                                               /* de graden als de nog niet gerichte maar al vastgelegde 
+						  bogen meegerekend worden -- dat mag niet voor kanoniciteit 
+						  gebruikt worden */
+int nextstep_depth; 
+
+#define SWITCHPAR_ORBSIZE 5 // when does serial orbit labelling switch to parallel -- and stay there
+#define MAXPAR_ORBSIZE 9 // maximum 16, when changing, change following MAXPAROPS too
+#define MAXPAROPS 19683 // set to minimum 3^MAXPAR_ORBSIZE
+unsigned int parops[MAXPAROPS];
+// in the case of no degree restrictions this could in fact be permanently filled in -- only depending
+// on the edge orbit size. But the time for filling it in is so small that it is simply not worth it.
+int number_parops; 
+// an operation is defined as follows: if edge number i in kleinste_orbit must be directed kleinste_orbit[i][0]->kleinste_orbit[i][1],
+// bits 2i and 2i+1 form the number 0 (so are both 0). For kleinste_orbit[i][0]<-kleinste_orbit[i][1] they form 2, for
+// a double edge they form 1 ---- so 2-type is always the inverse
+#define SETOP(op,edge,type) ((op) = ((op) & ~(3<<((edge)<<1))) | (type)<<((edge)<<1))
+#define GETTYPE(op,edge) (((op)>>((edge)<<1))&3)
+
+/* for the following macros global variables _x_ and _y_ are used */
+int _x_, _y_;
+#define BILDBOOG_UNDIR(startboog,bildboog,permnummer) \
+  { _x_=generators[permnummer][(startboog)[0]]; _y_=generators[permnummer][(startboog)[1]]; \
+if (_x_<_y_) { (bildboog)[0]=_x_; (bildboog)[1]=_y_; } else  { (bildboog)[0]=_y_; (bildboog)[1]=_x_; }}
+#define BILDBOOG(startboog,bildboog,permnummer) \
+  { (bildboog)[0]=generators[permnummer][(startboog)[0]]; (bildboog)[1]=generators[permnummer][(startboog)[1]]; }
+#define POSBILD(startboog,permnummer) \
+  (positie[generators[permnummer][(startboog)[0]]][generators[permnummer][(startboog)[1]]])
+
+/* a macro that sets numbers a and b equivalent to a */
+#define SETEQUIV(a,b) { _y_=(b); while ((_x_=number[_y_])!=_y_) { number[_y_]=(a); _y_=_x_; } number[_y_]=(a); } 
+/* zorgt ervoor dat nummer[a] zo is dat nummer[nummer[a]]=nummer[a] */
+#define UPDATENUMBER(a) { _y_=(a); while ((_x_=number[_y_])!=_y_) { number[_y_]=number[_x_]; _y_=number[_y_]; } number[a]=number[_y_]; } 
+
+/* the quality of a directed edge */
+#define QUALITY(a,b) (((saturated[a]+saturated[b])<<6)+colour[nextstep_depth][a])
+// upper bound for the quality if the in- or out-deg of one of the entries is changed by one
+#define QUALITY_P1(a,b) (((saturated[a]+saturated[b]+1)<<6)+colour[nextstep_depth][a])
+// quality if the in- or out-deg of one of the entries are both changed by one
+#define QUALITY_P2(a,b) (((saturated[a]+saturated[b]+2)<<6)+colour[nextstep_depth][a])
+
+int _marks[MAX_BOGEN], _markvalue=INT_MAX;
+#define RESETMARKS { int i; if (_markvalue<INT_MAX) _markvalue++; else { _markvalue=1; \
+                     for (i=0;i<MAX_BOGEN;i++) _marks[i]=0; } }
+#define ISMARKED(i) (_marks[i]==_markvalue)
+#define UNMARKED(i) (_marks[i]!=_markvalue)
+#define MARK(i) {_marks[i]=_markvalue;}
+
+long long int onlevel[MAX_BOGEN]={0};
+
+/* variabelen voor nauty: nvector sounds like a vector but is a typedef for int */
+nvector lab[MAX_BOGEN][MAXN]={{0}}, ptn[MAX_BOGEN][MAXN]={{0}}, orbits[MAX_BOGEN], colour[MAX_BOGEN][MAXN]={{0}};
+/* MAX_BOGEN is zeker te veel -- maar wat zou een goede bovengrens zijn ? */
+/* in the arrays lab[i][] and ptn[i][] the partition is stored after having labelled i orbits 
+   completely. lab[0][] and ptn[0][] are the partitions as computed for the original graph. */
+int rememberorbits[MAXN][MAXN];
+
+nvector bufferlab[MAXN], bufferptn[MAXN];
+graph canong[MAXN];
+/* make sure these are always evaluated at once, because they are reused whenever new
+   edges are directed */
+graph workg[MAXN], staticg[MAXN], canong[MAXN];
+graph bit_orbit[MAXN];
+int deg[MAXN]={0}, outdeg[MAXN]={0}, indeg[MAXN]={0};
+int tobedirected[MAXN]={0}; /* how many edges have still to be directed? This can
+   also be used to detect whether an edge that is in both directions is a double edge or 
+   just not yet directed in the routines for nontrivial symmetry. It is a double edge if 
+   and only if one of the endpoints is ready with ready defines as: */
+#define READY(i) (tobedirected[i]==0)
+#define NOT_READY(i) (tobedirected[i]>0)
+int aantal_toppen, aantal_bogen, aantal_gerichte_bogen;
+int max_doubles;
+int double_free[MAXN]={0}; /* hoeveel dubbele bogen kan top [i] nog krijgen? */
+
+long long int addnumber=0; /* How much must the counter be increased if a graph
+			      is found. Just relevant in case not all are really constructed and coded.
+			      Then this gives a speedup.*/ 
+
+long long int aantal_grafen_met_triv_group=0LL;
+long long int aantal_gerichte_grafen=0LL;
+
+static DEFAULTOPTIONS(options_directed);
+static DEFAULTOPTIONS(options_directed_canon);
+static DEFAULTOPTIONS(options);
+static DEFAULTOPTIONS(options_final);
+static statsblk stats;
+setword workspace[100*MAXN];
+
+permutation generators[MAXN][MAXN];
+int number_of_generators;
+int group_up_to_date=0;
+
+int indeg_free[MAXN]={0}, outdeg_free[MAXN]={0}, saturated[MAXN]={0};
+
+graph all; // the set of all vertices
+
+int orbitchoices[MAXN]={0};
+
+#define CSIZE 32768
+int _colourmarks[CSIZE], _cmark=INT_MAX;
+#define RESETMARKS_COLOUR { int i; \
+                            if (_cmark==INT_MAX)\
+				     { for (i=0;i<CSIZE;i++) _colourmarks[i]=0; _cmark=1; }\
+			    else _cmark++; }
+#define MARK_COLOUR(a) {_colourmarks[a]=_cmark;}
+#define ISMARKED_COLOUR(a) (_colourmarks[a]==_cmark)
+
+void directorbit();
+graph* readg();
+void parallel_orbit_labelling();
+
+//unsigned int waterclusteruse=0UL, water_v_use=0UL;
+
+/****OPTIONS******/
+int maxindeg=MAXN, maxoutdeg=MAXN, maxdirectdeg=MAXN, nodegbound=1;
+int double_allowed=1, direct_output=0;
+
+#define NEXTEL(a,b) (b)=FIRSTBIT((a)& BITMASK(b)) /*(b)++, b=FIRSTBIT((a)<<(b))+(b)*/
+#define FORALLELEMENTS(x,y) for (y= FIRSTBIT(x); y<WORDSIZE; NEXTEL((x),(y)))
+#define FORALLELEMENTS_BOUND(x,y,b) for (y=FIRSTBIT((x)& BITMASK(b)) ; y<WORDSIZE; NEXTEL((x),(y)))
+/* Attention: bound is a lower bound and the first possible value is bound+1 ! */
+
+#define WRITEUP() { aantal_gerichte_grafen+=addnumber; if (direct_output==1) {writeTcode(workg,aantal_toppen);\
+if (addnumber==2) writeTcode_invers(workg,aantal_toppen);} else if (direct_output==3) \
+{writeBcode(workg,aantal_toppen);\
+if (addnumber==2) writeBcode_invers(workg,aantal_toppen);} }
+#define WRITEUP_COUNT() { aantal_gerichte_grafen+=addnumber; }
+
+#ifdef PROCESS
+ void callprocess(graph *g, int aantal_toppen)
+   { int i,j; graph gconv[MAXN];
+
+     dg_nout = aantal_gerichte_grafen+1;
+     PROCESS(stdout,g,aantal_toppen);
+#ifndef NOCONVERSE
+     if (addnumber==2)
+       {
+	  EMPTYSET(gconv,aantal_toppen);
+          for (i=0; i<aantal_toppen;i++)
+            { 
+	       FORALLELEMENTS(g[i],j) ADDELEMENT(gconv+j,i);
+	    }
+            ++dg_nout;
+          PROCESS(stdout,gconv,aantal_toppen);
+       }
+#endif
+   }
+#define MAYBEPROCESS callprocess(workg,aantal_toppen)
+#else
+#define MAYBEPROCESS
+#endif
+
+ void writeTcode(graph *g, int aantal_toppen)
+   { int i,j;
+
+   fprintf(stdout,"%d %d",aantal_toppen,aantal_bogen+max_doubles-remaining_doubles);
+   for (i=0; i<aantal_toppen;i++) 
+     { 
+       FORALLELEMENTS(g[i],j) fprintf(stdout," %d %d",i,j);
+     }
+       fprintf(stdout,"\n");
+   }
+
+ void writeTcode_invers(graph *g, int aantal_toppen)
+   { int i,j;
+
+   fprintf(stdout,"%d %d",aantal_toppen,aantal_bogen+max_doubles-remaining_doubles);
+   for (i=0; i<aantal_toppen;i++) 
+     { 
+       FORALLELEMENTS(g[i],j) fprintf(stdout," %d %d",j,i);
+     }
+
+       fprintf(stdout,"\n");
+   }
+
+ void writeBcode(graph *g, int aantal_toppen)
+   { int i,j;
+   putc(aantal_toppen,stdout);
+   for (i=0; i<aantal_toppen;i++) 
+     { 
+       FORALLELEMENTS(g[i],j) putc(j+1,stdout);
+       putc(0,stdout);
+     }
+   }
+
+ void writeBcode_invers(graph *g, int aantal_toppen)
+   { int i,j;
+     int lijst[MAXN][MAXN], lengte[MAXN];
+     putc(aantal_toppen,stdout);
+
+     for (i=0; i<aantal_toppen;i++) lengte[i]=0;
+     for (i=0; i<aantal_toppen;i++) 
+       { 
+	 FORALLELEMENTS(g[i],j) { lijst[j][lengte[j]]=i+1; lengte[j]++; }
+       }
+     for (i=0; i<aantal_toppen;i++)
+       { for (j=0; j<lengte[i]; j++) putc(lijst[i][j],stdout);
+         putc(0,stdout);
+       }
+   }
+
+void writelab(nvector ptn[], nvector lab[])
+{
+  int i;
+
+  for (i=0; i<aantal_toppen; i++) 
+    { fprintf(stderr," %d ",lab[i]); if (ptn[i]==0) fprintf(stderr,"|| "); }
+  fprintf(stderr,"\n");
+
+  return;
+}
+
+void writeset(graph set)
+{ int i;
+  fprintf(stderr,"The set:\n");
+  FORALLELEMENTS(set,i) fprintf(stderr,"%d ",i);
+  fprintf(stderr,"\n");
+}
+
+void writeoperation(unsigned char op[])
+{ int i,counter;
+
+  fprintf(stderr,"Operation: ");
+  for (i=counter=0; counter<3; i++)
+    {
+      if (op[i]==INFTY_UCHAR) { fprintf(stderr," ||"); counter++; }
+      else fprintf(stderr," %d",op[i]);
+    }
+  fprintf(stderr,"\n");
+}
+
+void writelist(int list[])
+{
+  int i;
+
+  for (i=0;list[i]>=0;i++) fprintf(stderr,"%d ",list[i]); fprintf(stderr,"\n");
+}
+
+ void writegraph(graph *g)
+ // for graphs as they are used in the vertexorbit routines
+   { int i,j;
+     static int counter=0;
+   fprintf(stderr,"---------------------------------------------------------\n");
+   fprintf(stderr,"Graph number %d with %d vertices\n",++counter,aantal_toppen);
+   for (i=0; i<aantal_toppen;i++) 
+     { fprintf(stderr,"%d:",i);
+       FORALLELEMENTS(g[i],j) 
+	 { fprintf(stderr," %d", j);
+	   if (READY(i) || READY(j)) 
+	     { 
+	       if (ISELEMENT(g+j,i)) fprintf(stderr,"[d]"); else fprintf(stderr,"[s]");
+	     }
+	       else fprintf(stderr,"[ng]");
+	 }
+       fprintf(stderr,"\n");
+     }
+   fprintf(stderr,"---------------------------------------------------------\n");
+   }
+
+
+/**********************************************************************************/
+
+void sammle_permutationen(int count, permutation perm[], nvector orbits[],
+                          int numorbits, int stabvertex, int n)
+{
+  memcpy(generators+number_of_generators,perm,sizeof(permutation)*n);
+
+  number_of_generators++;
+}
+
+
+/**********************************************************************************/
+
+void init_nauty_options()
+/* initialises the nauty variables */
+{
+ /* tc_level = 0 is not the default in the most recent
+    editions of nauty.  However, it is better for very small
+    graphs so we set it here. */
+
+options.getcanon=FALSE;
+options.userautomproc = sammle_permutationen;
+options.defaultptn=TRUE;
+options.writeautoms=FALSE;
+options.writemarkers=FALSE;
+options.digraph=FALSE;
+options.tc_level = 0;
+
+
+options_directed.getcanon=FALSE;
+options_directed.userautomproc = sammle_permutationen;
+options_directed.defaultptn=FALSE;
+options_directed.writeautoms=FALSE;
+options_directed.writemarkers=FALSE;
+options_directed.digraph=TRUE;
+options_directed.tc_level = 0;
+
+options_directed_canon.getcanon=TRUE;
+options_directed_canon.userautomproc = sammle_permutationen;
+options_directed_canon.defaultptn=FALSE;
+options_directed_canon.writeautoms=FALSE;
+options_directed_canon.writemarkers=FALSE;
+options_directed_canon.digraph=TRUE;
+options_directed_canon.tc_level = 0;
+
+
+options_final.getcanon=TRUE;
+options_final.defaultptn=TRUE;
+options_final.writeautoms=FALSE;
+options_final.writemarkers=FALSE;
+options_final.digraph=TRUE;
+options_final.tc_level = 0;
+}
+
+/****************************LESE_MULTICODE************************/
+
+int lese_multicode(unsigned char**code, int *codelaenge, FILE *fil)
+
+/* Liest den code und gibt EOF zurueck, wenn das Ende der Datei erreicht
+   ist, 1 sonst. Der Speicher fuer den code wird alloziert, falls noetig,
+   was entschieden wird anhand der lokalen Variablen maxknotenzahl */
+{
+static int maxknotenzahl= -1;
+int codel, gepuffert=0;
+int knotenzahl,a=0,b=0,nuller;
+unsigned char ucharpuffer;
+
+if ((knotenzahl=getc(fil))==EOF) return EOF;
+if (knotenzahl==0) { fprintf(stderr,"Umschaltung auf short noch nicht implementiert.\n");
+                     exit(0);
+                    } 
+nuller=0; codel=1;
+if (knotenzahl=='>') /* koennte ein header sein -- oder 'ne 62, also ausreichend fuer
+			     unsigned char */
+      { gepuffert=1;
+	a=getc(fil);
+	if(a==0) nuller++; 
+	b=getc(fil);
+	if(b==0) nuller++; 
+	/* jetzt wurden 3 Zeichen gelesen */
+	if ((a=='>') && (b=='m')) /*garantiert header*/
+	  { while ((ucharpuffer=getc(fil)) != '<') {}
+	    /* noch zweimal: */ ucharpuffer=getc(fil); 
+	    if (ucharpuffer!='<') { fprintf(stderr,"Problems with header -- single '<'\n"); exit(1); }
+	    if ((knotenzahl=getc(fil))==EOF) return EOF;
+	    /* kein graph drin */
+	  }
+	/* else kein header */
+      }
+
+
+if (knotenzahl > maxknotenzahl)
+  { if (*code) free(*code);
+    *code=(unsigned char *)malloc((knotenzahl*(knotenzahl-1)/2+knotenzahl)*sizeof(unsigned char));
+    if (code==NULL) { fprintf(stderr,"Do not get memory for code\n"); exit(0); }
+    maxknotenzahl=knotenzahl;
+  }
+
+(*code)[0]=knotenzahl; if (gepuffert) { codel=3; (*code)[1]=a; (*code)[2]=b; }
+
+while (nuller<knotenzahl-1)
+  { if (((*code)[codel]=getc(fil))==0) nuller++;
+    codel++; }
+
+*codelaenge=codel;
+return 1;
+}
+
+
+void usage(char name[])
+{
+
+  fprintf(stderr,"usage: %s [ix] [oy] [m] [T] [C] [B] [S] .\n",name);
+  fprintf(stderr,"The option ix restricts the maximum indegree to x.\n");
+  fprintf(stderr,"The option oy restricts the maximum outdegree to y.\n");
+  fprintf(stderr,"The default maximum in- and out-degrees are unlimited. \n");
+  fprintf(stderr,"T means: Output directed graphs in T-code -- for details see header\n");
+  fprintf(stderr,"B means: Output directed graphs in binary code -- for details see header\n");
+  fprintf(stderr,"C means: Do really construct all the directed graphs in memory, but don't output them.\n");
+  fprintf(stderr,"S means that for each edge only one direction must be chosen -- not both.\n");
+  fprintf(stderr,"Default is that both are allowed\n");
+  fprintf(stderr,"  -- so the edge a-b can become a->b AND b->a in the same output graph.\n");
+  fprintf(stderr,"m means: read multicode instead of g6 code \n");
+  exit(1);
+
+}
+
+/**********DECODE_TO_NAUTY****************************************************/
+
+void decode_to_nauty(unsigned char *code, int codelaenge, graph *g, int degree[]) 
+
+
+  /* Dekodiert multicode nach nauty bitcode */
+
+  /* alle knotennamen muessen fuer nauty um 1 nach unten verschoben werden */
+
+{
+
+  int v1,v2;
+  unsigned char *end;
+
+ if (code[0]>32) { fprintf(stderr,"Not prepared for %d>32 vertices.\n",code[0]); exit(2); }
+ aantal_toppen=code[0];
+ aantal_bogen=codelaenge-aantal_toppen;
+ for (v1=0; v1<aantal_toppen; v1++) { EMPTYSET1(g+v1,1); degree[v1]=0; }
+ for (v1=0, end=code+codelaenge, code++; code<end; code++) 
+   { if (*code==0) v1++;
+     else { v2=(*code)-1;
+            ADDELEMENT1(g+v1,v2); ADDELEMENT1(g+v2,v1); 
+	    degree[v1]++; degree[v2]++;
+          }
+   }
+ aantal_gerichte_bogen=0;
+ //for (v1=0; v1<aantal_toppen; v1++) tobedirected[v1]=degree[v1];
+
+ return;
+}
+
+/****************************************INIT_FOR_G6*****************************/
+
+void init_for_g6(graph g[],int aantal_toppen, int degree[])
+{
+  int i;
+
+  if (aantal_toppen>32) { fprintf(stderr,"Not prepared for %d>32 vertices.\n",aantal_toppen); exit(2); }
+  aantal_bogen=0;
+
+  for (i=0; i<aantal_toppen; i++) { degree[i]=POPCOUNT(g[i]); aantal_bogen+=degree[i]; }
+  aantal_bogen = aantal_bogen>>1;
+  aantal_gerichte_bogen=0;
+  return;
+
+}
+
+
+/***************************FILL_EDGELIST**************************/
+
+void fill_edgelist()
+     /* writes the edges in g into the list in a lexicographic way. 
+	Is used if no bounds for in- and out-degree are given
+	or few edges are left. */
+
+{
+  int i,j,end;
+
+  for (i=j=0; i<aantal_toppen; i++) /* j is de positie in edgelist */
+    { indeg_free[i]=maxindeg-indeg[i]; outdeg_free[i]=maxoutdeg-outdeg[i];
+      FORALLELEMENTS_BOUND(workg[i],end,i)
+	{ 
+	  edgelist[j][0]=i; edgelist[j][1]=end; j++;
+	}
+    }
+
+}
+
+/***************************FILL_EDGELIST_ORDER**************************/
+
+
+void fill_edgelist_order()
+  /* writes the edges in gg into the list in a way that for i in 1...numberedges we always have
+     that the starting point of edge i has the minimum degree of all vertices in the graph you get
+     when removing all edges i+1...aantal_bogen from gg.
+     The global variable positie is not assigned any values.
+ */
+{
+  int last_positie,i, buffer, olddeg, newdeg, beste, start, end;
+  int list[MAXN][MAXN], listlen[MAXN]={0}; /* list[i] contains the vertices with degree i at that moment */
+  int toppositie[MAXN], bufferdeg[MAXN]; /* toppositie[i] is de positie van top i in de lijst */
+  int buren[MAXN]; /* de buren van de top waaraan gewerkt wordt */
+  graph dummy[MAXN];
+
+  if (nodegbound) { fill_edgelist(); return; }
+
+  memcpy(dummy,workg,aantal_toppen*sizeof(graph));
+
+    for (i=0; i<aantal_toppen; i++) 
+      { buffer=bufferdeg[i]=deg[i]; list[buffer][listlen[buffer]]=i; 
+	toppositie[i]=listlen[buffer]; (listlen[buffer])++; 
+	indeg_free[i]=maxindeg-indeg[i]; outdeg_free[i]=maxoutdeg-outdeg[i];}
+
+
+    last_positie=aantal_bogen-1;
+    while (last_positie>=0)
+      {
+	for (beste=1;listlen[beste]==0; beste++);
+	(listlen[beste])--; /* zo wordt hij ook verwijderd */
+	start=list[beste][listlen[beste]];
+	for (i=0; i<beste; i++) /* alle buren opslaan*/
+	  { end=buren[i]=FIRSTBIT(dummy[start]); DELELEMENT(dummy+start,end); }
+
+	for (i=0; i<beste; i++) /* alle buren */
+	  { 
+	    end=buren[i];
+	    edgelist[last_positie][0]=start; edgelist[last_positie][1]=end; 
+	    last_positie--;
+	    DELELEMENT(dummy+end,start);
+	    /* de buur verhuizen: */
+	    olddeg=bufferdeg[end];
+	    (bufferdeg[end])--;
+	    newdeg=bufferdeg[end];
+	    /* uit de oude lijst verwijderen */
+	    if (listlen[olddeg]==1) listlen[olddeg]=0;
+	    else { (listlen[olddeg])--;
+	    buffer= list[olddeg][listlen[olddeg]];
+	    list[olddeg][toppositie[end]]=buffer;
+	    toppositie[buffer]=toppositie[end]; }
+	    /* tot de nieuwe toevoegen */
+	    if (newdeg)
+	      { list[newdeg][listlen[newdeg]]=end;
+	        toppositie[end]=listlen[newdeg];
+	        (listlen[newdeg])++;
+	      }
+	  }
+
+      }
+
+}
+
+/**********************************TRIVLABEL_ROUTINES****************************/
+
+ void trivlabels_nowrite_nodouble(BOOG *positie)
+   {
+     int start, end;
+
+     start=(*positie)[0]; end=(*positie)[1];
+
+  if (positie==laatstepositie)
+    {
+     if (indeg_free[start] && outdeg_free[end]) /* bogen kan end->start gericht worden */
+       {
+	 WRITEUP_COUNT();
+       }
+    if (indeg_free[end] && outdeg_free[start]) /* bogen kan start->end gericht worden */
+       { 
+	 WRITEUP_COUNT();
+       }
+
+    return;
+    }
+
+  /* else -- niet op laatste positie */
+
+     if (indeg_free[start] && outdeg_free[end]) /* bogen kan end->start gericht worden */
+       { 
+	 (indeg_free[start])--; (outdeg_free[end])--;
+	 trivlabels_nowrite_nodouble(positie+1);
+	 (indeg_free[start])++; (outdeg_free[end])++;
+       }
+    if (indeg_free[end] && outdeg_free[start]) /* bogen kan start->end gericht worden */
+       {
+	 (indeg_free[end])--; (outdeg_free[start])--;
+	 trivlabels_nowrite_nodouble(positie+1);
+	 (indeg_free[end])++; (outdeg_free[start])++;
+       }
+    return;
+   }
+
+
+
+
+ void trivlabels_nowrite(BOOG *positie)
+   {
+     int start, end, counter;
+
+     if (!remaining_doubles) { trivlabels_nowrite_nodouble(positie); return; }
+
+     start=(*positie)[0]; end=(*positie)[1];
+
+  if (positie==laatstepositie)
+    {
+     if (indeg_free[start] && outdeg_free[end]) /* bogen kan end->start gericht worden */
+       { counter=1;
+	 WRITEUP_COUNT();
+       }
+     else counter=0;
+    if (indeg_free[end] && outdeg_free[start]) /* bogen kan start->end gericht worden */
+       { counter++;
+	 WRITEUP_COUNT();
+       }
+    if (remaining_doubles && (counter==2)) WRITEUP_COUNT();
+
+    return;
+    }
+
+  /* else -- niet op laatste positie */
+
+     if (indeg_free[start] && outdeg_free[end]) /* bogen kan end->start gericht worden */
+       { counter=1;
+	 (indeg_free[start])--; (outdeg_free[end])--;
+	 trivlabels_nowrite(positie+1);
+	 (indeg_free[start])++; (outdeg_free[end])++;
+       }
+     else counter=0;
+    if (indeg_free[end] && outdeg_free[start]) /* bogen kan start->end gericht worden */
+       { counter++;
+	 (indeg_free[end])--; (outdeg_free[start])--;
+	 trivlabels_nowrite(positie+1);
+	 (indeg_free[end])++; (outdeg_free[start])++;
+       }
+    if (remaining_doubles && (counter==2) && double_free[start] && double_free[end])
+      {
+	 (indeg_free[end])--; (outdeg_free[start])--;
+	 (indeg_free[start])--; (outdeg_free[end])--;
+	 double_free[start]--; double_free[end]--;
+	 remaining_doubles--;
+	 trivlabels_nowrite(positie+1);
+	 remaining_doubles++;
+	 double_free[start]++; double_free[end]++;
+	 (indeg_free[end])++; (outdeg_free[start])++;
+	 (indeg_free[start])++; (outdeg_free[end])++;
+      }
+    return;
+   }
+
+
+ void trivlabels(BOOG *positie)
+   {
+     int start, end, counter;
+
+  start=(*positie)[0]; end=(*positie)[1];
+
+  
+
+  if (positie==laatstepositie)
+    {
+     if (indeg_free[start] && outdeg_free[end]) /* bogen kan end->start gericht worden */
+       { counter=1;
+	 //(indeg_free[start])--; (outdeg_free[end])--;
+	 DELELEMENT(workg+start,end);
+	 MAYBEPROCESS;
+	 WRITEUP();
+	 ADDELEMENT(workg+start,end);
+	 //(indeg_free[start])++; (outdeg_free[end])++;
+       }
+     else counter=0;
+    if (indeg_free[end] && outdeg_free[start]) /* bogen kan start->end gericht worden */
+      {  counter++;
+	//(indeg_free[end])--; (outdeg_free[start])--;
+	 DELELEMENT(workg+end,start);
+	 MAYBEPROCESS;
+	 WRITEUP();
+	 ADDELEMENT(workg+end,start);
+	 //(indeg_free[end])++; (outdeg_free[start])++;
+       }
+    if (remaining_doubles && (counter==2)) { remaining_doubles--; MAYBEPROCESS; WRITEUP(); remaining_doubles++; }
+    return;
+    }
+
+  /* else -- niet op laatste positie */
+
+     if (indeg_free[start] && outdeg_free[end]) /* bogen kan end->start gericht worden */
+       { counter=1;
+	 (indeg_free[start])--; (outdeg_free[end])--;
+	 DELELEMENT(workg+start,end);
+	 trivlabels(positie+1);
+	 ADDELEMENT(workg+start,end);
+	 (indeg_free[start])++; (outdeg_free[end])++;
+       }
+     else counter=0;
+    if (indeg_free[end] && outdeg_free[start]) /* bogen kan start->end gericht worden */
+      {  counter++;
+	 (indeg_free[end])--; (outdeg_free[start])--;
+	 DELELEMENT(workg+end,start);
+	 trivlabels(positie+1);
+	 ADDELEMENT(workg+end,start);
+	 (indeg_free[end])++; (outdeg_free[start])++;
+       }
+    if (remaining_doubles && (counter==2) && double_free[start] && double_free[end])
+      {
+	 (indeg_free[end])--; (outdeg_free[start])--;
+	 (indeg_free[start])--; (outdeg_free[end])--;
+	 double_free[start]--; double_free[end]--;
+	 remaining_doubles--;
+	 trivlabels(positie+1);
+	 remaining_doubles++;
+	 double_free[start]++; double_free[end]++;
+	 (indeg_free[end])++; (outdeg_free[start])++;
+	 (indeg_free[start])++; (outdeg_free[end])++;
+      }
+
+    return;
+   }
+
+
+ void trivlabels_init(BOOG *positie)
+   {
+     int remember;
+
+     if (!direct_output) 
+       { if (nodegbound)
+	 { remember=addnumber;
+	   if (remaining_doubles) { for (;positie<=laatstepositie;positie++) addnumber*=3;}
+	   else { for (;positie<=laatstepositie;positie++) addnumber*=2;}
+	   WRITEUP();
+	   addnumber=remember;
+	   return;
+	   }
+       /* else */
+         if (!remaining_doubles) trivlabels_nowrite_nodouble(positie);
+	   else trivlabels_nowrite(positie); 
+	 return; 
+       }
+     /* else */
+     trivlabels(positie); 
+     return;
+   }
+
+
+
+/******************************DIRECT_ALL_TRIV********************************/
+
+void direct_all_triv()
+{
+  int i, start, end;
+
+  aantal_grafen_met_triv_group++; 
+  if (nodegbound) fill_edgelist(); else fill_edgelist_order();
+  for (i=0;i<aantal_toppen;i++) double_free[i]=maxdirectdeg-deg[i];
+  laatstepositie=edgelist+aantal_bogen-1;
+  if (maxoutdeg==maxindeg) /* then every valid graph for one direction is also valid with
+			      the directions reversed */
+    { 
+      addnumber=2;
+      start=edgelist[0][0]; end=edgelist[0][1];
+      /* is_gericht[][] isn't used in the directing routine */
+      (outdeg_free[start])--; (indeg_free[end])--;
+      //virtual_outdeg[start]++; virtual_indeg[end]++;
+      DELELEMENT(workg+end,start);
+      aantal_gerichte_bogen=1;
+      trivlabels_init(edgelist+1);
+      aantal_gerichte_bogen=0;
+      ADDELEMENT(workg+end,start);
+      (outdeg_free[start])++; (indeg_free[end])++;
+      
+      if (remaining_doubles && double_free[start] && double_free[end])
+	{
+	  addnumber=1; 
+	  (outdeg_free[start])--; (indeg_free[end])--;
+	  (outdeg_free[end])--; (indeg_free[start])--;
+	  double_free[start]--; double_free[end]--;
+	  aantal_gerichte_bogen=1;
+	  remaining_doubles--;
+	  trivlabels_init(edgelist+1);
+	  remaining_doubles++;
+	  double_free[start]++; double_free[end]++;
+	  (outdeg_free[start])++; (indeg_free[end])++;
+	  (outdeg_free[end])++; (indeg_free[start])++;
+	  aantal_gerichte_bogen=0;
+	}
+    }
+  else
+    {
+      addnumber=1;
+      aantal_gerichte_bogen=0;
+      trivlabels_init(edgelist);
+      aantal_gerichte_bogen=0;
+    }
+  return;
+
+}
+
+/*********************************SORT_DECREASING**********************************/
+
+#define WISSEL(a,b) { buffer=(a); (a)=(b); (b)=buffer; }
+
+void sort_decreasing(int list[], int number)
+{
+  // only very small numbers have to be sorted, so better simple
+
+  int buffer,i,j;
+
+  if (number==2)
+    { if (list[0]<list[1]) WISSEL(list[0],list[1])
+      return;			     
+    }
+  if (number==3)
+    {
+      if (list[0]<list[1])
+	{ if (list[1]<list[2]) // l0<l1<l2
+	    { WISSEL(list[0],list[2]) }
+	  else // l1>l0 l1>l2
+	    { if (list[0]<list[2]) // l0<l2<l1
+		{ buffer=list[0]; list[0]=list[1]; list[1]=list[2]; list[2]=buffer; }
+	      else // l2<l0<l1
+		{ WISSEL(list[0],list[1]) }
+	    }
+	}
+      else // l1<l0
+	{ if (list[0]<list[2]) // l1<l0<l2
+	    { buffer=list[0]; list[0]=list[2]; list[2]=list[1]; list[1]=buffer; }
+	  else // l1<l0 l2<l0
+	    { if (list[1]<list[2]) // l1<l2<l0
+		{ WISSEL(list[2],list[1]) }
+	      //else // l2<l1<l0 -- OK
+	    }
+	}
+      return;
+    }
+  if (number>3) //should hardly ever happen and then "number" is still small -- bubblesort
+    {
+      for (i=number-1; i ; i--)
+	for (j=0;j<i;j++)
+	  if (list[j]<list[j+1]) WISSEL(list[j],list[j+1])
+    }				   
+
+  return;
+
+}
+
+
+
+/**********************************COMPUTE_IMAGE_OPERATION**************************/
+
+int compute_image_operation(unsigned char image[], unsigned char original[], permutation generator[])
+// returns 1 if image and original differ and 0 otherwise
+{
+  int in_image[MAXN], out_image[MAXN], double_image[MAXN];
+  int run, num_in, num_out, num_double, change;
+
+  change=0;
+
+  image[0]=generator[original[0]];
+
+  if (original[0]!=image[0]) change=1;
+
+  for (run=1, num_in=0; original[run]!=INFTY_UCHAR; run++) 
+    { in_image[num_in]=generator[original[run]]; num_in++; }
+
+  for (run++, num_out=0; original[run]!=INFTY_UCHAR; run++) 
+    { out_image[num_out]=generator[original[run]]; num_out++; }
+
+  for (run++, num_double=0; (run<blocklength) && (original[run]!=INFTY_UCHAR); run++) 
+    { double_image[num_double]=generator[original[run]]; num_double++; }
+
+  if (num_in>1) sort_decreasing(in_image,num_in);
+  if (num_out>1) sort_decreasing(out_image,num_out);
+  if (num_double>1) sort_decreasing(double_image,num_double);
+
+
+  for (run=1 ; num_in; run++) 
+    { num_in--; image[run]=in_image[num_in]; if (original[run]!=image[run]) change=1;}
+  image[run]=INFTY_UCHAR; run++;
+  for ( ; num_out; run++) 
+    { num_out--; image[run]=out_image[num_out]; if (original[run]!=image[run]) change=1;}
+  image[run]=INFTY_UCHAR; run++;
+  for ( ; num_double; run++) 
+    { num_double--; image[run]=double_image[num_double]; if (original[run]!=image[run]) change=1;}
+  image[run]=INFTY_UCHAR;
+  //for ( ;run<blocklength;run++) image[run]=INFTY_UCHAR;
+
+  return change;
+
+}
+
+
+/**********************************CONSTRUCT_OPERATIONS_ONE**************************/
+
+void construct_operations_one(int center, int end, int do_inedge, int do_outedge, int do_double)
+{
+  static unsigned char *buffer;
+  unsigned char *start;
+
+  if (size_operations<=((number_operations+1)*blocklength)) 
+    { buffer=operations;
+      operations=malloc((size_t)(2*size_operations));
+      if (operations==NULL) 
+	{ fprintf(stderr,"Can't allocate %d bytes for operations -- exiting\n",2*size_operations); 
+	  exit(1); }
+      memcpy(operations,buffer,size_operations);
+      free(buffer);
+      size_operations *= 2;
+    }
+
+  if (do_inedge && (indeg[center] < maxindeg) && (outdeg[end]<maxoutdeg))
+    { start=operations+(number_operations*blocklength);
+      start[0]=center; start[1]=end; start[2]=start[3]=start[4]=INFTY_UCHAR;
+      number_operations++;
+    }
+
+  if (do_outedge && (indeg[end] < maxindeg) && (outdeg[center]<maxoutdeg))
+    { start=operations+(number_operations*blocklength);
+      start[0]=center; start[2]=end; start[1]=start[3]=start[4]=INFTY_UCHAR;
+      number_operations++;
+    }
+
+  if (do_double && double_free[center] && 
+      (indeg[end] < maxindeg) && (indeg[center] < maxindeg) &&
+      (outdeg[center]<maxoutdeg) && (outdeg[end]<maxoutdeg))
+    { start=operations+(number_operations*blocklength);
+      start[0]=center; start[3]=end; start[1]=start[2]=start[4]=INFTY_UCHAR;
+      number_operations++;
+    }
+
+  return;
+
+}
+
+
+
+/**********************************CONSTRUCT_OPERATIONS_FINAL**************************/
+
+void construct_operations_final(int list[], int decided[],unsigned char buffer_op[], 
+				int positie, int numberin, int numberout)
+{
+  int i, center;
+  static unsigned char *buffer;
+
+  /* here about position "positie" of the operation is decided. If "positie==blocklength"
+     we are done. 
+
+     This function decides on double edges.
+
+  */
+
+
+  if (size_operations<=((number_operations+1)*blocklength)) 
+    { buffer=operations;
+      operations=malloc((size_t)(2*size_operations));
+      if (operations==NULL) 
+	{ fprintf(stderr,"Can't allocate %d bytes for operations -- exiting\n",2*size_operations); 
+	  exit(1); }
+      memcpy(operations,buffer,size_operations);
+      free(buffer);
+      size_operations *= 2;
+    }
+
+  center=buffer_op[0];
+  // double_free[center] must be tested inside the loop to make sure
+  // that it only leads to rejection if all edges have already been assigned
+  
+  if (double_free[center])// otherwise the rest was filled in in the previous step
+	for (i=0;list[i]>=0;i++)
+	  if (!decided[i])
+	    { 
+	      if ( double_free[center] && double_free[list[i]] &&
+		   ((outdeg[center]+numberout < maxoutdeg) && (indeg[list[i]]<maxindeg)) &&
+		   ((indeg[center]+numberin < maxindeg) && (outdeg[list[i]]<maxoutdeg)))
+		{
+		  buffer_op[positie]=list[i];
+		  positie++; numberout++; numberin++;
+		}
+	      else return;
+	    }
+
+  buffer_op[positie]=INFTY_UCHAR; positie++;
+
+  memcpy(operations+(number_operations*blocklength),buffer_op,positie);
+  number_operations++;
+  return;
+
+}
+
+
+/**********************************CONSTRUCT_OPERATIONS_OUT**************************/
+
+void construct_operations_out(int list[],int liststart, int decided[],unsigned char buffer_op[], 
+			      int positie, int numberin, int numberout, int lowerlimit_outdeg,
+			      int mindouble)
+{
+  int i, center, buffer;
+  static int outdeg_larger;
+
+  /* here about position "positie" of the operation is decided. If "positie==blocklength"
+     we are done. 
+
+     This function decides on outgoing edges.
+
+     liststart ensures that no earlier -- smaller -- entries are written after larger ones
+     unless there has been an INFTY_UCHAR to separate them.
+  */
+
+  center=buffer_op[0];
+
+  if (numberout==0) // just test once
+    { buffer=outdeg[center] + tobedirected[center] -numberin;
+      if (buffer<lowerlimit_outdeg) return;
+      else
+	{ if (buffer>lowerlimit_outdeg) outdeg_larger=1; else outdeg_larger=0; }
+    }
+
+  if (double_free[center]) // then there is still something to decide
+    { if (outdeg[center]+numberout < maxoutdeg)
+	for (i=liststart;list[i]>=0;i++)
+	  if (!decided[i])
+	    { 
+	      if (indeg[list[i]]<maxindeg)
+		{ decided[i]=1;
+		  buffer_op[positie]=list[i];
+		  construct_operations_out(list,i+1,decided,buffer_op,positie+1,
+					     numberin, numberout+1,lowerlimit_outdeg,mindouble);
+		  decided[i]=0;
+		}
+	    }
+      buffer_op[positie]=INFTY_UCHAR;
+      if (outdeg_larger || 
+	  (indeg[center]+outdeg[center]+(tobedirected[center]<<1)-numberin-numberout-deg[center]>=mindouble))
+	  // looks complicated but is just the final number of double edges
+      construct_operations_final(list,decided,buffer_op,positie+1,
+			   numberin, numberout);
+      return;
+    }
+  //else // all the undecided entries have to be outgoing
+  
+    for (i=liststart;list[i]>=0;i++)
+      if (!decided[i])
+	{ 
+	  if ((outdeg[center]+numberout < maxoutdeg) && (indeg[list[i]]<maxindeg))
+	    { 
+	      buffer_op[positie]=list[i];
+	      positie++; numberout++;
+	    }
+	  else return;
+	}
+  buffer_op[positie]=INFTY_UCHAR;
+  construct_operations_final(list,decided,buffer_op,positie+1,
+			     numberin, numberout);
+  return;
+    
+}
+
+
+
+
+
+/**********************************CONSTRUCT_OPERATIONS_IN**************************/
+
+void construct_operations_in(int list[],int liststart, int decided[],unsigned char buffer_op[], 
+			     int positie, int numberin, int numberout, int lowerlimit_outdeg,
+			     int mindouble)
+{
+  int i, center;
+
+  /* here about position "positie" of the operation is decided. If "positie==blocklength"
+     we are done. 
+
+     This function decides on incoming edges.
+
+     liststart ensures that no earlier -- smaller -- entries are written after larger ones
+     unless there has been an INFTY_UCHAR to separate them.
+  */
+
+
+  center=buffer_op[0];
+
+  if(indeg[center]+numberin < maxindeg)
+    for (i=liststart;list[i]>=0;i++)
+      if (!decided[i])
+	{ 
+	  if (outdeg[list[i]]<maxoutdeg)
+	    { decided[i]=1;
+	      buffer_op[positie]=list[i];
+	      construct_operations_in(list,i+1,decided,buffer_op,positie+1,
+				      numberin+1, numberout,lowerlimit_outdeg,mindouble);
+	      decided[i]=0;
+	    }
+	}
+  buffer_op[positie]=INFTY_UCHAR;
+  construct_operations_out(list,0,decided,buffer_op,positie+1,
+			   numberin, numberout,lowerlimit_outdeg,mindouble);
+  return;
+}
+
+
+/**********************************CONSTRUCT_EXTENSIONS**************************/
+
+void construct_extensions(int still_open[], int orbit[], graph touched, int first_in_orbit, graph sameorbit)
+{
+  int top, top2, j, end, list[MAXN], decided[MAXN], error, lowerlimit_outdeg, readylist[MAXN], *readyrun, dummy;
+  int minout, do_double=0, i, mindouble;
+  unsigned char buffer[MAXN+4];
+  graph pre_free, tbd1, bufferg, freevertices; // tbd1 is the set of vertices with exactly one edge to be directed left
+  // decided[i]=0 if and only if about list[i] is already decided //
+
+  tbd1=(graph)0;
+  pre_free= all & ~touched;
+  readyrun=readylist;
+  lowerlimit_outdeg=0;
+
+  // Since either all or no vertices in the orbit have edges going to untouched vertices, one could split
+  // this function to save some tests. But for the moment it should better stay like this
+
+
+  // if a vertex v has at least two edges to be directed and one of them leads to a vertex in the same
+  // orbit that will be ready afterwards, then directing the edges around v would not have a
+  // reverse operation. So these operations must be avoided.
+
+  // if only one edge is left to be directed and the endpoint is in the same orbit is must be directed double
+  // or outgoing.
+
+if (first_in_orbit)
+  {
+    for (number_operations=0; (top=(*still_open))>=0; still_open++)
+      // number_operations is global, so it must not be passed to the next functions
+      //if (NOT_READY(top))
+      { 
+	if (tobedirected[top]==1)
+	  {
+	    for (j= FIRSTBIT(workg[top]); READY(j) ; NEXTEL((workg[top]),(j))); 
+	    if (ISELEMENT(&sameorbit,j) && (tobedirected[j]==1)) construct_operations_one(top, j, 0, 1, double_allowed);
+	    else construct_operations_one(top, j, 1, 1, double_allowed);
+	  }
+	else
+	  if (!(staticg[top] & tbd1))
+	    { 
+	      for (end=0, j= FIRSTBIT(workg[top]); (j<WORDSIZE); NEXTEL((workg[top]),(j))) 
+		{ if (NOT_READY(j)) { list[end]=j; decided[end]=0; end++; }}
+	      // the edge has already been directed if and only if the other top has already been finished
+	      list[end]= -1;
+	      buffer[0]= top;
+	      construct_operations_in(list,0,decided,buffer,1,0,0,0,0);
+	    }
+      }
+    return;
+  }
+
+// else: not first in orbit
+
+ minout=INT_MAX;
+
+ if (staticg[orbit[0]]& ~touched) // all operations will contain edges to free vertices
+   {
+     for (j=0; (top=orbit[j])>=0; j++)
+       { if (NOT_READY(top)) 
+	   { //ADDELEMENT(&sameorbit,top);
+	     if (tobedirected[top]>=2) ADDELEMENT(&pre_free,top); // will stay free unless is chosen top
+	     else ADDELEMENT(&tbd1,top);
+	   }
+	 else // that is: ready
+	   { *readyrun=top; readyrun++; } // minout would not be used 
+       }
+   }
+ else
+   {
+     do_double=double_allowed;
+     for (j=0; (top=orbit[j])>=0; j++)
+       { 
+	 if (NOT_READY(top)) 
+	   { //ADDELEMENT(&sameorbit,top);
+	     if (tobedirected[top]>=2) ADDELEMENT(&pre_free,top); // will stay free unless is chosen top
+	     else ADDELEMENT(&tbd1,top);
+	   }
+	 else // that is: ready
+	   { bufferg=(workg[top]&sameorbit);
+	     *readyrun=top; readyrun++; 
+	     if ((bufferg) && (outdeg[top]<minout)) { minout=outdeg[top]; do_double=double_allowed; }
+	     if (do_double && (outdeg[top]==minout))
+	       { 
+		 FORALLELEMENTS(bufferg,i)
+		   { if (READY(i) && !ISELEMENT(workg+i,top)) // no double edge, so double edges inside the orbit would not be accepted
+		       { do_double=0; i=WORDSIZE; }
+		   }
+	       }
+	   }
+       }
+   }
+ *readyrun= -1;
+
+for (number_operations=0; (top=(*still_open))>=0; still_open++)
+  // number_operations is global, so it must not be passed to the next functions
+  //if (NOT_READY(top))
+  { 
+    if (tobedirected[top]==1) // already ready vertices can't have less...
+      { 
+	for (j= FIRSTBIT(workg[top]); READY(j) ; NEXTEL((workg[top]),(j))); 
+	if (ISELEMENT(&sameorbit,j) && (tobedirected[j]==1)) 
+	  { bufferg=workg[j]&sameorbit; DELELEMENT(&bufferg,top);
+	    if (outdeg[top]<minout)
+	      { if ((bufferg== (graph)0) || (outdeg[j]>outdeg[top])) // otherwise the end would be better 
+		  {
+		    if (outdeg[top]==minout-1) construct_operations_one(top, j, 0, 1, do_double);
+		    else construct_operations_one(top, j, 0, 1, double_allowed);
+		  }
+		else 
+		  if ((outdeg[j]==outdeg[top]) && double_allowed)
+		  {
+		    if (outdeg[top]==minout-1) construct_operations_one(top, j, 0, 0, do_double);
+		    else construct_operations_one(top, j, 0, 0, double_allowed);
+		  }
+	      }
+	  }
+	else construct_operations_one(top, j, 1, 1, double_allowed);
+
+      }
+    else 
+      { 
+	if (!(staticg[top] & tbd1))
+	  {
+	    error=0;
+	    freevertices = pre_free | (tbd1 & ~staticg[top]);
+	    DELELEMENT1(&freevertices,top);
+	    // now freevertices is the set of vertices that will still be free after  the addition of top
+	    for (lowerlimit_outdeg=mindouble=0, readyrun=readylist; !error && (top2= *readyrun)>=0; readyrun++)
+	      { bufferg= freevertices & staticg[top2];
+		if ((dummy=POPCOUNT(bufferg)))// will be a candidate afterwards
+		  { if (dummy < tobedirected[top]) error=1;
+		    else
+		      { if (dummy == tobedirected[top])
+			  {
+			    if (outdeg[top2]>lowerlimit_outdeg) 
+			      { lowerlimit_outdeg=outdeg[top2]; mindouble=indeg[top2]+outdeg[top2]-deg[top2]; }
+			    else 
+			      if (double_allowed && (outdeg[top2]==lowerlimit_outdeg)) 
+				{
+				  if (indeg[top2]+outdeg[top2]-deg[top2]>mindouble) 
+				    mindouble=indeg[top2]+outdeg[top2]-deg[top2];
+				}
+			  }
+		      }
+		  }
+	      }
+	    if (!error)
+	      {
+		for (end=0, j= FIRSTBIT(workg[top]); 
+		     (j<WORDSIZE) ; NEXTEL((workg[top]),(j))) 
+		  if (NOT_READY(j)) { list[end]=j; decided[end]=0; end++; }
+
+		// the edge has already been directed if and only if the other top has already been finished
+		list[end]= -1;
+		buffer[0]= top;
+		if (!error) construct_operations_in(list,0,decided,buffer,1,0,0,lowerlimit_outdeg,mindouble);
+	      }
+	  }
+      }
+  }
+  return; 
+}
+
+int compare_op(unsigned char *op1, unsigned char *op2)
+// returns 0 if operations are the same, something negative if op1
+// is lexicographically smaller and something positive else
+{
+  int counter;
+
+  if (*op1 != *op2) return (*op1 - *op2); // can never be INFTY_UCHAR
+  op1++; op2++;
+  counter=2;
+  while (*op1 == *op2)
+    { if (*op1 == INFTY_UCHAR) { if (!counter) return 0; counter--; }
+      op1++; op2++;
+    }
+  return (*op1 - *op2);
+}
+
+/******************************SEARCH_OP*******************************/
+
+int search_op(unsigned char *op)
+
+/* searches the operation op in the list of operations and returns the index. */
+
+{
+  int min, max, center;
+
+  min=0; max=number_operations-1; center= (min+max)/2;
+
+  while (min<max)
+    { 
+      if (compare_op(op,operations+(blocklength*center))<=0)
+	{ max=center; center= (min+max)/2; }
+      else // op strictly larger 
+	{ min=center+1; center= (min+max)/2; }
+    }
+
+  return min;
+}
+
+/******************************SEARCH_EDGE*******************************/
+
+int search_edge(int start, int end, int edgelist[][2], int length)
+
+/* searches the edge start->end in edgelist and returns the index. */
+
+{
+  int min, max, center;
+
+  min=0; max=length-1; center= (min+max)/2;
+
+  while (min<max)
+    { 
+      if ((start<edgelist[center][0]) || ((end<=edgelist[center][1]) && (start==edgelist[center][0]))) // start->end smaller or equal
+	{ max=center; center= (min+max)/2; }
+      else // start->end strictly larger 
+	{ min=center+1; center= (min+max)/2; }
+    }
+
+  return min;
+}
+
+
+/******************************COMPUTE_ORBITS************************/
+
+int compute_orbits()
+/* compute the orbits of the group described by the global variable generators[][] on
+   the operations described in the global variable operations.
+   Returns the number of orbits.
+*/
+{
+  int i,j,buffer,run, orbits, index;
+  unsigned char image[MAXN+4];
+
+  if (number_operations>size_root)
+    { size_root=number_operations;
+      free(root_op);
+      root_op=malloc((size_t)size_root*sizeof(int));
+    }
+  if (root_op==NULL)  
+    { fprintf(stderr,"Can't allocate %d items for root_op -- exiting.\n",size_root);
+      exit(0); }
+
+  for (i=0; i<number_operations; i++) root_op[i]=i;
+
+  for (i=0, orbits=number_operations; i<number_operations; i++)
+    for (j=0; j<number_of_generators; j++)
+      { 
+	if (compute_image_operation(image, operations+(i*blocklength), generators[j]))
+	  {
+	    index=search_op(image);
+	    //unite:
+	    while ((buffer=root_op[index])!=index) index=buffer; // no path compression here
+	    run=i;
+	    while ((buffer=root_op[run])!=run) { root_op[run]=index; run=buffer; }
+	    if (run!=index) 
+	      { orbits--; // the roots were different -- two trees are united
+		root_op[run]=index; }
+	  }
+      }
+  return orbits;
+}
+
+/******************************COMPUTE_EDGEORBITS****************************/
+
+#define MAKEIMAGE(a,k) {imagex=generators[k][(a)[0]]; imagey=generators[k][(a)[1]];}
+
+void compute_edgeorbits(int edgelist[][2],int orb[], int length)
+
+{
+  int i,j, index, buffer, run;
+  int imagex, imagey;
+
+  for (i=0; i<length; i++)
+    for (j=0; j<number_of_generators; j++)
+      { MAKEIMAGE(edgelist[i],j);
+	index=search_edge(imagex, imagey, edgelist, length);
+	while ((buffer=orb[index])!=index) index=buffer; // no path compression here
+	run=i;
+	while ((buffer=orb[run])!=run) { orb[run]=index; run=buffer; }
+	orb[run]=index;
+      }
+}
+
+
+/******************************CANONICAL****************************/
+
+int canonical(unsigned char operation[], int vertexorbit[], int *newgroup, int orbitid, graph touched)
+
+// checks whether the operation is canonical in vertexorbit. Returns 1 if yes, 0 otherwise.
+// In newgroup it is stored whether a new group has been computed for this (*newgroup=1) or not
+// (*newgroup=0)
+
+// If no edges go to vertices outside the set of vertices in already "finished" orbits or to vertices in
+// this orbit with still undecided edges, the canonical operation is directing one edge {x,y} x->y or x<->y.
+// Edges completely in this orbit and obtained by operations center x end y are chosen as follows: 
+// First the starting point x is chosen with minimum outdegree.
+// For edges with starting points with the same minimal outdegree, edges are preferred which are single. 
+// If the tested operation is double and single operations exist, the operation is rejected.
+// Among the remaining edges those are chosen where y has minimum indegree.
+// Among the remaining those are chosen where x is in the orbit of the one with smallest canonical number
+// (after the operation). y is the neighbour with smallest indegree -- and among those with the same indegree
+// the one with smallest canonical number (in the same given numbering of course).
+
+// Otherwise:
+// Define a vertex to be free if it is not in an orbit that was already chosen (we call that untouched)
+// or it is in such an orbit but not all edges to it are already directed (that can only be in the last orbit).
+// In this case the central vertex of the canonical operation is one that is chosen in steps:
+// Among all with edges to free vertices it is chosen as one with a minimum number of these.
+// Among those one with max outdegree is chosen.
+// Among those one with maximum number of double edges is chosen.
+// Finally a more complicated artificial criterion is tested -- not suitable for a look ahead during the construction
+// of possible operations
+// Among the remaining, one with smallest canonical label is chosen.
+
+{ int i, j, k, min, top, buffer, candidatelist[MAXN], number_candidates, center;
+  graph free, candidates, bufferset, dummy, sameorbit, bit_startlist;
+  int edgelistcounter, edgelist[2*MAXN*MAXN][2], orb[2*MAXN*MAXN], canoncenter, canonend, endvertex=0;
+  int finished[MAXN], finishedptn[MAXN], testoutdeg;
+  int startlist[MAXN], *startrun; // list of possible starts in case of no candidates
+  int numberends, ends[MAXN][MAXN], endin=0, *run;
+  nvector *colour;
+  long long int buffer2, k2;
+
+
+
+  free= all & (~touched); // in fact all ready vertices are candidates if one has a non-empty
+  // intersection with this as they are all in the same orbit -- so have the same number of edges
+  // to this set
+  sameorbit=bit_orbit[orbitid];
+
+  for (run=vertexorbit; (*run)>=0; run++) if (NOT_READY(*run)) ADDELEMENT(&free,(*run));
+
+  center=operation[0];
+
+  candidates= (graph)0;
+  number_candidates=0;
+  min=INFTY_UCHAR;
+  for (i=0; (top=vertexorbit[i])>=0; i++) 
+    if (READY(top) && (bufferset=(staticg[top] & free)))
+      {
+	buffer=POPCOUNT(bufferset);
+	if (buffer<min) { candidates= (graph)0; ADDELEMENT(&candidates,top); 
+	                  candidatelist[0]=top; number_candidates=1; min=buffer; }
+	else
+	  if (buffer==min)
+	    { ADDELEMENT(&candidates,top); candidatelist[number_candidates]=top; number_candidates++; }
+      }
+  if (number_candidates && !ISELEMENT(&candidates,center))
+    { 
+      return 0;
+    }
+
+  if (number_candidates==1) { *newgroup=0; return 1; }
+  
+  testoutdeg=outdeg[center];
+  // First canonicity criterion: maximum outdegree
+  if (number_candidates)
+    {
+      for (i=0; i<number_candidates; ) 
+	{ k= outdeg[candidatelist[i]]-testoutdeg;
+	  if (k>0) 
+	    { return 0;}
+	  else 
+	    { if (k<0) { DELELEMENT(&candidates,candidatelist[i]); 
+		         number_candidates--; 
+			 candidatelist[i]=candidatelist[number_candidates];   }
+	      else i++; // otherwise the new element has to be tested
+	    }
+	}
+      
+      if (number_candidates==1) { *newgroup=0; return 1; }
+    // end number_candidates>0
+
+      if (remaining_doubles != max_doubles) // there are double edges
+	{ buffer=indeg[center]+outdeg[center]-deg[center]; // number of double edges starting at center
+	  for (i=0; i<number_candidates; )
+	    { j=candidatelist[i];
+	      k= indeg[j]+outdeg[j]-deg[j]-buffer; 
+	      if (k>0) 
+		{ return 0;}
+	      else 
+		{ if (k<0) { DELELEMENT(&candidates,candidatelist[i]); 
+		    number_candidates--; 
+		    candidatelist[i]=candidatelist[number_candidates];   }
+		  else i++; // otherwise the new element has to be tested
+		}
+	    }
+	}
+      if (number_candidates==1) { *newgroup=0; return 1; }
+ 
+      //OK-- last try. A colour that can not really be used to avoid unnecessary operation in advance
+      colour=rememberorbits[orbitid];
+      dummy=workg[center]&(free | sameorbit);
+      buffer2=1LL;
+      FORALLELEMENTS(dummy,i) 
+	{ buffer2 *= (tobedirected[i]<<12)+(indeg[i]<<9)+(outdeg[i]<<6)+(colour[i]<<3)+deg[i]+1;
+	  buffer2 = buffer2%63241LL;
+	}
+
+      for (i=0; i<number_candidates; )
+	{ 
+	  dummy=workg[candidatelist[i]]&(free | sameorbit);
+	  k2=1LL;
+	  FORALLELEMENTS(dummy,j) 
+	    { k2 *= (tobedirected[j]<<12)+(indeg[j]<<9)+(outdeg[j]<<6)+(colour[j]<<3)+deg[j]+1;
+	      k2 = k2%63241LL;
+	    }
+	  k2 -= buffer2;
+
+	  if (k2>0LL) 
+	    { return 0;}
+	  else 
+	    { if (k2<0LL) { DELELEMENT(&candidates,candidatelist[i]); 
+		number_candidates--; 
+		candidatelist[i]=candidatelist[number_candidates];   }
+	      else i++; // otherwise the new element has to be tested
+	    }
+	}
+      
+      if (number_candidates==1) { *newgroup=0; return 1; }
+ 
+
+
+   } // end number candidates > 0
+
+
+  // OK -- we have to work. First the canonical form must be computed:
+  // Problem: the difference between double edges and edges that have not yet been directed cannot be 
+  // detected in the datastructure graph. To this end we put "ready" vertices in an extra partition --
+  // this way double edges cannot be mapped on undirected edges. This is only necessary if there are double edges.
+
+  else // (number_candidates==0) // finished vertices in this orbit always have an internal edge!
+    { startrun=startlist;
+      bit_startlist=(graph)0;
+      if (operation[2]==INFTY_UCHAR) // a double edge was added and all single edges starting at same outdeg are better
+	{ endvertex= operation[3];
+	  endin=indeg[endvertex];
+	  for (i=0; (k=vertexorbit[i])>=0; i++)
+	    if (READY(k) && (workg[k] & sameorbit))// has _outgoing_ edge into same orbit
+	      // the end points are automatically ready and all in the same orbit -- otherwise there would have been a candidate
+	      { 
+		if (outdeg[k]<testoutdeg) return 0;
+		if (outdeg[k]==testoutdeg) 
+		  { numberends=0; 
+		    bufferset= workg[k]&sameorbit;
+		    FORALLELEMENTS(bufferset,j) 
+		      { if (!ISELEMENT(workg+j,k)) return 0; // else: also double edge
+			if (indeg[j]<endin) return 0;
+			if (indeg[j]==endin) { ends[k][numberends]=j; numberends++; }
+		      }
+		    if (numberends)
+		      { ends[k][numberends]= -1; 
+			*startrun=k; startrun++; ADDELEMENT(&bit_startlist,k); 
+		      }
+		  }
+	      }
+	}
+      else // het is dus een single edge
+	{ endvertex= operation[2];
+	  endin=indeg[endvertex];
+	  for (i=0; (k=vertexorbit[i])>=0; i++)
+	    if (READY(k) && (workg[k] & sameorbit))// has _outgoing_ edge into same orbit
+	      // the end points are automatically ready and all in the same orbit -- otherwise there would have been a candidate
+	      { 
+		if (outdeg[k]<testoutdeg) return 0;
+		if (outdeg[k]==testoutdeg) 
+		  { numberends=0;
+		    bufferset= workg[k]&sameorbit;
+		    FORALLELEMENTS(bufferset,j) 
+		      { if (!ISELEMENT(workg+j,k)) // also single
+			  {
+			    if (indeg[j]<endin) return 0;
+			    if (indeg[j]==endin) { ends[k][numberends]=j; numberends++; }
+			  }
+		      }
+		    if (numberends)
+		      { ends[k][numberends]= -1;
+			*startrun=k; startrun++; ADDELEMENT(&bit_startlist,k); 
+		      }
+		  }
+	      }
+	}
+      *startrun= -1;
+      dummy=workg[center] & sameorbit;
+      if ((startlist[1]== -1) && (ends[center][1]== -1)) { *newgroup=0; return 1; } // maar 1 boog mogelijk
+    } 
+
+
+  if (double_allowed) // distinguish single and double edges for nauty()
+    {
+      for (i=j=k=0; i<aantal_toppen;i++)
+	{ top=lab[orbitid][i];
+	  if (READY(top)) { finished[k]=top; finishedptn[k]=1; k++; } 
+	  else { bufferlab[j]=top; bufferptn[j]=1; j++; }
+	  if (ptn[orbitid][i]==0)
+	    { if (j) bufferptn[j-1]=0;
+	      if (k) finishedptn[k-1]=0;
+	    }
+	}
+      for (i=0;i<k;i++,j++) { bufferptn[j]=finishedptn[i]; bufferlab[j]=finished[i]; } 
+    }
+  else
+    {
+      memcpy(bufferlab,lab[orbitid],aantal_toppen*sizeof(nvector));
+      memcpy(bufferptn,ptn[orbitid],aantal_toppen*sizeof(nvector));
+    }
+  number_of_generators=0;
+  nauty(workg,bufferlab,bufferptn,NILSET,orbits,&options_directed_canon,&stats,workspace,100*MAXN,1,aantal_toppen,canong);
+  *newgroup=1;
+
+  //nautyuse[number_candidates]++;
+
+  // Being a free vertex is invariant under automorphisms and the set of edges to free vertices depends only
+  // on the central vertex. So the central vertex characterizes the whole operation and orbits of central
+  // vertices uniquely correspond to orbits of operations.
+
+  if (number_candidates>1)
+    {      
+      for (i=0; !ISELEMENT(&candidates,bufferlab[i]); i++); // zoekt candidaat met kleinste kanonische label
+            
+      if (orbits[center]==orbits[bufferlab[i]]) { return 1; }
+      else { return 0; }
+    }
+
+// only remaining case: number_candidates=0 -- that is: only one edge between 2 vertices of vertexorbit was added
+
+  // operation must be outgoing or double edge -- but this is guaranteed by the construction of operations
+
+  //  for (i=0; !(READY(bufferlab[i]) && ISELEMENT(&sameorbit,bufferlab[i]) && (workg[bufferlab[i]] & sameorbit))
+  for (i=0; !ISELEMENT(&bit_startlist,bufferlab[i]); i++);
+  // Now we have the smallest vertex in vertexorbit with an edge to another vertex in vertexorbit
+
+  canoncenter=bufferlab[i];
+
+  if (orbits[center]!=orbits[canoncenter]) { return 0; }
+
+  // Now look for the endvertex:
+
+  min=INFTY_UCHAR;
+  dummy= sameorbit & workg[canoncenter];
+
+  // at this point it is known that none of the possible startvertices has an endvertex that
+  // has smaller indegree than the endvertex of the operation tested (that is: endin)
+
+  // now look for the smallest labelled neighbour:
+
+  if (operation[2]==INFTY_UCHAR) // a double edge was added and any suitable neighbour is double
+    for (i=0;!(ISELEMENT(&dummy,bufferlab[i]) && (indeg[bufferlab[i]]==endin)) && (i<aantal_toppen);i++);
+  else // a single edge was added and only neighbours via single edges may be chosen
+    for (i=0;ISELEMENT(workg+bufferlab[i],canoncenter) ||
+	   !(ISELEMENT(&dummy,bufferlab[i]) && (indeg[bufferlab[i]]==endin)); i++);
+  
+  canonend=bufferlab[i];
+
+  if (orbits[endvertex]!=orbits[canonend]) { return 0; }
+    if ((canoncenter==center) && (canonend==endvertex)) { return 1; }
+
+  // OK -- bad luck. We have to check whether the edges are really in the same orbit
+  // First make a list of all edges that are candidates:
+
+  edgelistcounter=0;
+  for (startrun=startlist; (k= *startrun)>=0;startrun++)
+    if (orbits[k]==orbits[canoncenter])
+      { 
+	for (i=0; (j=ends[k][i])>=0; i++)
+	  { 
+	    if (orbits[j]==orbits[canonend]) 
+	      { edgelist[edgelistcounter][0]=k; edgelist[edgelistcounter][1]=j; 
+		orb[edgelistcounter]=edgelistcounter; edgelistcounter++; }
+	  }
+      }
+
+  compute_edgeorbits(edgelist,orb,edgelistcounter);
+
+  i=search_edge(center,endvertex,edgelist,edgelistcounter);
+  while(i!=orb[i]) i=orb[i];
+  j=search_edge(canoncenter,canonend,edgelist,edgelistcounter);
+  while(j!=orb[j]) j=orb[j];
+
+  if (i==j) { return 1; } // same orbit as canonical edge
+  else { return 0; }
+
+
+}
+
+int all_diff_colours(graph testset, int orbitid)
+// returns 1 if all elements have some different vertex invariant and 0 otherwise
+{
+  nvector *colour;
+  int i,buffer;
+
+  RESETMARKS_COLOUR;
+  colour=rememberorbits[orbitid];
+
+  FORALLELEMENTS(testset,i) 
+    { 
+      buffer = (tobedirected[i]<<12)+(indeg[i]<<9)+(outdeg[i]<<6)+(colour[i]<<3)+deg[i];
+      buffer &= 32767;
+      if (ISMARKED_COLOUR(buffer)) return 0;
+      MARK_COLOUR(buffer);
+    }
+
+  return 1;
+}
+
+
+void fill_edgelist_final(graph g[])
+     /* writes the edges in gg into the list in a lexicographic way and initializes is_gericht 
+        and positie*/
+
+{
+  int i,j,end;
+
+  for (i=0, j=aantal_gerichte_bogen; i<aantal_toppen; i++) /* j is de positie in edgelist */
+    while (g[i])
+      { end=FIRSTBIT(g[i]); DELELEMENT(g+i,end);  DELELEMENT(g+end,i); 
+	edgelist_final[j][0]=i; edgelist_final[j][1]=end;
+	j++; 
+      }
+  return;
+}
+
+
+
+void fill_edgelist_order_final()
+     /* works like fill_edgelist_order -- only that in this case some edges are already assigned a direction.
+      They are not added to the list. The first entry is at position aantal_gerichte_bogen, so that the list
+      can be used like the normal edgelist for directing in the trivial case.
+      The global variable positie is not assigned any values.
+*/
+
+{
+  int last_positie,i, buffer, olddeg, newdeg, beste, start, end;
+  int list[MAXN][MAXN], listlen[MAXN]={0}; /* list[i] contains the vertices with degree i at that moment */
+  int toppositie[MAXN], bufferdeg[MAXN]; /* toppositie[i] is de positie van top i in de lijst */
+  int buren[MAXN]; /* de buren van de top waaraan gewerkt wordt */
+  graph g[MAXN], notready;
+
+  for (i=aantal_gerichte_bogen=0; i<aantal_toppen; i++) 
+    { indeg_free[i]=maxindeg-indeg[i]; outdeg_free[i]=maxoutdeg-outdeg[i];
+      aantal_gerichte_bogen += (deg[i]-tobedirected[i]); }
+  aantal_gerichte_bogen = aantal_gerichte_bogen>>1; // every edge was counted twice
+
+
+  memcpy(g,workg,aantal_toppen*sizeof(graph));
+  EMPTYSET1(&notready,1);
+
+  // make a list of vertices according to the whole degree. Vertices with large degree give stronger restrictions
+    for (i=0; i<aantal_toppen; i++) 
+      if (NOT_READY(i)) { buffer=bufferdeg[i]=deg[i]; list[buffer][listlen[buffer]]=i; 
+	                  toppositie[i]=listlen[buffer]; (listlen[buffer])++; 
+			  ADDELEMENT(&notready,i); }
+    else EMPTYSET1(g+i,1);
+
+    for (i=0; i<aantal_toppen; i++) g[i] &= notready; // now only edges that are still to be directed are in g[]
+
+    if (nodegbound || (aantal_bogen-aantal_gerichte_bogen<7)) { fill_edgelist_final(g); return; }
+
+    last_positie=aantal_bogen-1;
+
+    while (last_positie>=aantal_gerichte_bogen)
+      {
+	for (beste=1;listlen[beste]==0; beste++); // zoek kleinste aanwezige nog toe te voegen graad
+	(listlen[beste])--; /* zo wordt hij ook verwijderd */
+	start=list[beste][listlen[beste]];
+	for (i=0; g[start] != (graph)0; i++) /* alle buren opslaan*/
+	  { end=buren[i]=FIRSTBIT(g[start]); DELELEMENT(g+start,end); }
+	buren[i]= -1;
+	for (i=0; (end=buren[i])>=0; i++) /* alle buren */
+	  { 
+	    edgelist_final[last_positie][0]=start; edgelist_final[last_positie][1]=end; 
+	    last_positie--;
+	    DELELEMENT(g+end,start);
+	    /* de buur verhuizen: */
+	    olddeg=bufferdeg[end];
+	    (bufferdeg[end])--;
+	    newdeg=bufferdeg[end];
+	    /* uit de oude lijst verwijderen */
+	    if (listlen[olddeg]==1) listlen[olddeg]=0;
+	    else { (listlen[olddeg])--;
+	    buffer= list[olddeg][listlen[olddeg]];
+	    list[olddeg][toppositie[end]]=buffer;
+	    toppositie[buffer]=toppositie[end]; }
+	    /* tot de nieuwe toevoegen */
+	    if (newdeg)
+	      { list[newdeg][listlen[newdeg]]=end;
+	        toppositie[end]=listlen[newdeg];
+	        (listlen[newdeg])++;
+	      }
+	  }
+      }
+    return;
+}
+
+/******************************CHOOSEORBIT***************************/
+
+void chooseorbit(graph *touched, int best_orbit[], int orbitid)
+{ int i,j,k, num_in_orbit[MAXN], dummy, inorbit[MAXN][MAXN], best, bestroot=0;
+
+  // the group must be up to date at this point!
+
+     for (i=0;i<aantal_toppen;i++) { num_in_orbit[i]=0; }
+      for (i=0;i<aantal_toppen;i++)
+	{ dummy=orbits[i]; 
+	  inorbit[dummy][num_in_orbit[dummy]]=i;
+	  num_in_orbit[dummy]++;
+	  if (READY(i)) ADDELEMENT(touched,i);
+	}
+
+      
+      best=INT_MAX;
+      for (i=k=0;i<aantal_toppen;i++) 
+	{ 
+	  for (j=0;j<num_in_orbit[i]-1; j++) { ptn[orbitid][k]=1; lab[orbitid][k]=inorbit[i][j]; k++; } 
+	  if (num_in_orbit[i]) { ptn[orbitid][k]=0; lab[orbitid][k]=inorbit[i][j]; k++; }
+	  if ((orbits[i]==i) && NOT_READY(i) && (num_in_orbit[i] + (tobedirected[i]<<1))<best)
+	    { best=num_in_orbit[i] + (tobedirected[i]<<1); bestroot=i; }
+	
+	}
+
+      memcpy(rememberorbits[orbitid],orbits,sizeof(nvector)*aantal_toppen);
+      
+      // here the "best" orbit is chosen by a combination of number of vertices and edges to be directed per vertex
+	
+      orbitchoices[num_in_orbit[bestroot]]++;
+
+      bit_orbit[orbitid]= (graph)0;
+      for (i=j=0;i<aantal_toppen;i++) 
+	if (orbits[i]==bestroot) { best_orbit[j]=i; j++; ADDELEMENT(bit_orbit+orbitid,i); }
+      (*touched) |= bit_orbit[orbitid];
+      best_orbit[j]= -1;  // the sign that the end of the list has been reached
+
+      return;
+}
+
+/******************************CHOOSE_TRIV_ORBIT***************************/
+
+// This routine does not really choose an orbit based on group computations, but
+// just fixes a one vertex orbit detected by having a unique colour.
+// It also updates lab[], ptn[] etc. Orbitid must be at least 1
+
+void choose_triv_orbit(graph *touched, int best_orbit[], int orbitid, int fixed_vertex)
+{ int i,oud;
+
+  oud=orbitid-1;
+
+  // take the old partitition and only move fixed_vertex to its own partition
+  for (i=0;lab[oud][i]!=fixed_vertex; i++) { ptn[orbitid][i]=ptn[oud][i]; lab[orbitid][i]=lab[oud][i]; }
+  if ((ptn[oud][i]==0) && (i>0)) ptn[orbitid][i-1]=0;
+  for ( i++; i<aantal_toppen; i++) { ptn[orbitid][i-1]=ptn[oud][i]; lab[orbitid][i-1]=lab[oud][i]; }
+  lab[orbitid][aantal_toppen-1]=fixed_vertex; ptn[orbitid][aantal_toppen-1]=0;
+
+  memcpy(rememberorbits[orbitid],rememberorbits[orbitid-1],sizeof(nvector)*aantal_toppen);
+
+  bit_orbit[orbitid]= (graph)0;
+  ADDELEMENT(bit_orbit+orbitid,fixed_vertex);
+  ADDELEMENT(touched,fixed_vertex);
+  best_orbit[0]=fixed_vertex; best_orbit[1]= -1;
+
+  return;
+}
+
+void prepare_next_step(int group_uptodate, int orbitid, int iterationdepth, graph touched)
+{
+  int i, j, k, d, end;
+  int local_todolist[MAXN+1];
+  graph not_ready;
+  int colour[MAXN],numbercolour[MAXN], element[MAXN], diffcolours;
+  nvector *orbcolour; 
+
+
+// all vertices were in orbits
+      not_ready= all & ~touched; end=1;
+      FORALLELEMENTS(not_ready,j)
+	{ if (NOT_READY(j)) { end=0; } else DELELEMENT(&not_ready,j); }
+      if (end) { MAYBEPROCESS; WRITEUP(); return; } // no edges left to direct
+      //else 
+
+       
+      if (!group_uptodate)
+	{ end=1;
+	  orbcolour=rememberorbits[orbitid];
+	  diffcolours=0; 
+	  FORALLELEMENTS(not_ready,i)
+	    { numbercolour[diffcolours]=1; element[diffcolours]=i;
+	      colour[diffcolours]= (tobedirected[i]<<12)+(indeg[i]<<9)+(outdeg[i]<<6)+(orbcolour[i]<<3)+deg[i];
+	      for (k=0, d=1; k<diffcolours; k++) if (colour[k]==colour[diffcolours]) { end=d=0; numbercolour[k]++; }
+	      if (d) diffcolours++; // different from all earlier colours
+	    }
+	
+	  if (end) // group acts definitely trivial on rest
+	    { 
+	      fill_edgelist_order_final();
+	      laatstepositie=edgelist_final+aantal_bogen-1;
+	      trivlabels_init(edgelist_final+aantal_gerichte_bogen);
+	      return;
+	    }
+	  
+	  d= -1;
+	  for (i=0; i<diffcolours; i++)
+	    if (numbercolour[i]==1)
+	      { if (tobedirected[element[i]]==1)
+		  { 
+		    choose_triv_orbit(&touched, local_todolist, orbitid+1, element[i]);
+		    directorbit(local_todolist,local_todolist,0,orbitid+1,iterationdepth,touched);
+		    return;
+		  }
+		else
+		  { if (all_diff_colours(workg[element[i]]&not_ready,orbitid)) d=element[i]; }
+	      }
+	  // best is just one to direct, but d is reserve
+
+	  if (d>=0)
+	    { 
+	      choose_triv_orbit(&touched, local_todolist, orbitid+1, d);
+	      directorbit(local_todolist,local_todolist,0,orbitid+1,iterationdepth,touched);
+	      return;
+	    }
+	  
+	  // nieuwe orbit berekenen:
+	  //if (!group_uptodate)
+	  //	{ 
+	  number_of_generators=0;
+	  // since the orbit is complete, we don't NEED to distinguish between ready vertices or not
+	  // to mark double edges. Tests showed that it also doesn't help.
+	  memcpy(bufferlab,lab[orbitid],aantal_toppen*sizeof(nvector));
+	  memcpy(bufferptn,ptn[orbitid],aantal_toppen*sizeof(nvector));
+	  number_of_generators=0;
+	  nauty(workg,bufferlab,bufferptn,NILSET,orbits,&options_directed,&stats,workspace,100*MAXN,1,aantal_toppen,NULL);
+	  //orbitchoose_nauty++;
+	}    
+
+      end=1; // can we end the groupcomputations and switch to trivgroup?
+      if (stats.numorbits<aantal_toppen) FORALLELEMENTS(not_ready,j) if (orbits[j]!=j) end=0;
+
+      if (end)
+	{ 
+	  fill_edgelist_order_final();
+	  laatstepositie=edgelist_final+aantal_bogen-1;
+	  trivlabels_init(edgelist_final+aantal_gerichte_bogen);
+	  return;
+	}
+     
+      // --ELSE--
+      /* Now the colouring for level orbitid can be prepared */
+      
+      chooseorbit(&touched, local_todolist, orbitid+1);
+
+      directorbit(local_todolist,local_todolist,1,orbitid+1,iterationdepth,touched); 
+      // no vertexenvironment directed, so does not need to be increased. Otherwise MAXN would not be an upper bound
+      return;
+}
+
+
+/******************************DIRECTORBIT***************************/
+
+void directorbit(int todo_list[], int vertexorbit[], int group_uptodate, int orbitid, 
+		 int iterationdepth, graph touched)
+
+/* number_done is number of vertices in this orbit that is already directed. The automorphism group
+   does of course not interchange completed vertices from the orbit and uncompleted ones... 
+
+   orbitid is the number of the orbit to be directed. In the beginning you start directing the first orbit (id=1),
+   when that is done the second orbit (id=2), etc...
+*/
+
+{
+
+  int i, j, k, top, localblocklength, number_orbits, remembertobedirected, center, end, group_OK;
+  unsigned char *run, *runoperation;
+  int local_todolist[MAXN+1], local_left_to_do, first_in_orbit, doit;
+  int finished[MAXN], finishedptn[MAXN];
+  graph dummy;
+  // colour stores the different colours, numbercolour[] the number of graphs with that colour and
+  // element an example element with that colour
+
+
+#define START(x) ((x)*localblocklength)
+
+  for (i=local_left_to_do=0;todo_list[i]>=0; i++) 
+     if (NOT_READY(todo_list[i])) 
+       { local_todolist[local_left_to_do]=todo_list[i]; local_left_to_do++; }
+  local_todolist[local_left_to_do]= -1;
+
+  if (local_left_to_do==0) 
+    { if (touched==all) { MAYBEPROCESS; WRITEUP(); return; }
+      else prepare_next_step(group_uptodate, orbitid, iterationdepth, touched);
+      return;
+    }
+
+  // else -- there are still vertices in the orbit
+  if (vertexorbit[local_left_to_do]== -1) first_in_orbit=1; else first_in_orbit=0;
+  if (first_in_orbit) // new orbit to start with
+    orbitblocklength[orbitid]=tobedirected[vertexorbit[0]]+4;
+  localblocklength=blocklength=orbitblocklength[orbitid];
+  /* als een top al afgewerkt is kan de bloklengte voor de  verschillende toppen in wat vroeger
+     een orbit was verschillen. orbitblocklength[orbitid] is altijd een bovengrens */
+
+  construct_extensions(local_todolist,vertexorbit,touched, first_in_orbit, bit_orbit[orbitid]);
+
+  if (number_operations==0) return;
+
+  // in case of one element with tobedirected>1 the group is up to date
+
+  if ((group_uptodate && (stats.numorbits==aantal_toppen))
+      || ((vertexorbit[1]== -1) && (tobedirected[vertexorbit[0]]==1))) doit=0;
+  else doit=1;
+  // doit means: really check the group
+
+  if (doit)
+    {
+      dummy= all & (~touched);
+      for (i=0; (k=local_todolist[i])>=0; i++) ADDELEMENT(&dummy,k);
+      if (all_diff_colours(dummy,orbitid)) doit=0;
+      else
+	{
+	  if (!group_uptodate)
+	    { /* we need only the group -- no canonical numbering */
+	      number_of_generators=0;
+	      if (double_allowed)
+		{
+		  for (i=j=k=0; i<aantal_toppen;i++)
+		    { top=lab[orbitid][i];
+		      if (READY(top)) { finished[k]=top; finishedptn[k]=1; k++; } 
+		      else { bufferlab[j]=top; bufferptn[j]=1; j++; }
+		      if (ptn[orbitid][i]==0)
+			{ if (j) bufferptn[j-1]=0;
+			  if (k) finishedptn[k-1]=0;
+			}
+		    }
+		  for (i=0;i<k;i++,j++) { bufferptn[j]=finishedptn[i]; bufferlab[j]=finished[i]; } 
+		}
+	      else
+		{
+		  memcpy(bufferlab,lab[orbitid],aantal_toppen*sizeof(nvector));
+		  memcpy(bufferptn,ptn[orbitid],aantal_toppen*sizeof(nvector));
+		}
+	      nauty(workg,bufferlab,bufferptn,NILSET,orbits,&options_directed,&stats,workspace,100*MAXN,1,aantal_toppen,NULL);
+	      //orbitcomp_nauty++;
+	    }
+	  
+	  doit=0;
+	  for (i=0; (k=local_todolist[i])>=0; i++) if (orbits[k]!=k) doit=1;
+	  if (!doit)
+	    { dummy= all & (~touched);
+	      FORALLELEMENTS(dummy,j) if (orbits[j]!=j) doit=1;
+	    }
+	}
+    }
+
+  if (doit) number_orbits=compute_orbits(); else number_orbits=number_operations;
+
+  if (remember_size[iterationdepth]<(number_orbits*localblocklength))
+    { free(remember_operations[iterationdepth]);
+      remember_size[iterationdepth] = 2*number_orbits*localblocklength;
+      remember_operations[iterationdepth]=malloc((size_t)remember_size[iterationdepth]);
+      if (remember_operations[iterationdepth]==NULL)
+	{ fprintf(stderr,"Can't allocate %d items to store orbits -- exiting.\n",remember_size[iterationdepth]); 
+	  exit(3); }
+    }
+
+  if (doit)
+    {
+      for (i=j=0; i<number_operations; i++)
+	{ if (root_op[i]==i)
+	    { memcpy(remember_operations[iterationdepth]+START(j),operations+START(i),localblocklength);
+	      j++; 
+	    }
+	}
+    }
+  else // just copy
+    { number_orbits=number_operations;
+      memcpy(remember_operations[iterationdepth],operations,localblocklength*number_operations);
+    }
+
+  // Now each possible nonequivalent extension will be applied exactly once:
+
+  for(i=0;i<number_orbits; i++) // in the loop edges are directed and datatypes updated -- then the next iteration
+    // is called and afterwards things are reset
+    { 
+      runoperation=remember_operations[iterationdepth]+START(i);
+      center=runoperation[0];
+      remembertobedirected=tobedirected[center];
+      for (run=runoperation+1; *run!=INFTY_UCHAR; run++) // first incoming edges
+	{ end= *run;
+	  DELELEMENT(workg+center,end);
+	  indeg[center]++; outdeg[end]++; tobedirected[end]--;
+	}
+      for (run++; *run!=INFTY_UCHAR; run++) // then outgoing edges
+	{ end= *run;
+	  DELELEMENT(workg+end,center);
+	  indeg[end]++; outdeg[center]++; tobedirected[end]--;
+	}
+      for (run++; *run!=INFTY_UCHAR; run++) // then double edges
+	{ end= *run; remaining_doubles--;
+	  indeg[end]++; outdeg[center]++; tobedirected[end]--;
+	  indeg[center]++; outdeg[end]++;
+	}
+      tobedirected[center]=0;
+      // ready for next round
+
+      group_OK=0;
+
+      if ((first_in_orbit) || canonical(runoperation, vertexorbit, &group_OK, orbitid, touched))
+	directorbit(local_todolist, vertexorbit, group_OK, orbitid, iterationdepth+1, touched);
+
+      // now reset everything
+
+     for (run=runoperation+1; *run!=INFTY_UCHAR; run++) // first incoming edges
+	{ end= *run;
+	  ADDELEMENT(workg+center,end);
+	  indeg[center]--; outdeg[end]--; tobedirected[end]++;
+	}
+      for (run++; *run!=INFTY_UCHAR; run++) // then outgoing edges
+	{ end= *run;
+	  ADDELEMENT(workg+end,center);
+	  indeg[end]--; outdeg[center]--; tobedirected[end]++;
+	}
+      for (run++; *run!=INFTY_UCHAR; run++) // then double edges
+	{ end= *run; remaining_doubles++;
+	  indeg[end]--; outdeg[center]--; tobedirected[end]++;
+	  indeg[center]--; outdeg[end]--;
+	}
+      tobedirected[center]=remembertobedirected;
+    }
+
+  return;
+
+}
+
+/******************************DIRECT_ALL_NONTRIV***************************/
+
+void direct_all_nontriv()
+/* this functions starts to direct the edges in case of nontrivial automorphism.
+   nauty() has just been called, so orbit etc are all up to date */
+
+{
+  int i,best_orbit[MAXN+1];
+  int num_in_orbit[MAXN];
+  graph touched;
+
+  addnumber=1;
+  memcpy(rememberorbits[0],orbits,sizeof(nvector)*aantal_toppen);
+
+  all= (graph)0;
+  for (i=0;i<aantal_toppen;i++) { num_in_orbit[i]=0; ADDELEMENT(&all,i); }
+
+  touched= (graph)0;
+  chooseorbit(&touched, best_orbit, 0);
+
+  directorbit(best_orbit,best_orbit,1,0,0,touched);
+
+  return;
+}
+
+
+
+void init_waterplugin(int toppen)
+{ 
+  
+ watermaxdeg=maxindeg+maxoutdeg;
+ //if (watermaxdeg<maxdeg) maxdeg=watermaxdeg; That was for the routine that was a plugin for geng
+ /* grafen met een grotere graad kunnen niet gericht worden zodat ze nog aan de 
+    voorwaarden voldoen */
+ 
+ if (maxindeg<=maxoutdeg) { mingerichtdeg=maxindeg; watermaxedges=toppen*maxindeg; }
+ else { mingerichtdeg=maxoutdeg; watermaxedges=toppen*maxoutdeg; }
+ //if (watermaxedges<maxe) maxe=watermaxedges; That was for the routine that was a plugin for geng
+ /* grafen met meer bogen kunnen niet gericht worden, zodat ze nog aan de 
+    voorwaarden voldoen */
+
+}
+
+
+void writeop(unsigned int op, BOOG orbit[], int length)
+{
+  int i, start, end;
+  fprintf(stderr,"\n");
+  for (i=0;i<length;i++)
+    { start=orbit[i][0]; end=orbit[i][1];
+      if (GETTYPE(op,i)==0) fprintf(stderr,"(%d->%d) ",start, end);
+      else if (GETTYPE(op,i)==1) fprintf(stderr,"(%d<->%d) ",start, end);
+      else fprintf(stderr,"(%d<-%d) ",start, end);
+    }
+  fprintf(stderr,"\n");
+  return;
+}
+
+
+ void writegraph_edgeorb(graph *g, int aantal_toppen,int aantal_bogen, int aantal_gerichte_bogen)
+ // for graphs as they are used in the edgeorbit routines
+   { int i,j;
+   fprintf(stderr,"---------------------------------------------------------\n");
+   fprintf(stderr,"Graph with %d vertices, %d edges, %d already directed\n",aantal_toppen,aantal_bogen, aantal_gerichte_bogen);
+   for (i=0; i<aantal_toppen;i++) 
+     { fprintf(stderr,"%d:",i);
+       FORALLELEMENTS(g[i],j) 
+	 { fprintf(stderr," %d", j);
+	 if (aantal_gerichte_bogen)
+	   {
+	 if (!is_gericht[i][j]) fprintf(stderr," (ng)");
+	 else { if (ISELEMENT(g+j,i)) fprintf(stderr," (D)");
+	        else fprintf(stderr," (S)");
+	      }
+	   }
+	 }
+       fprintf(stderr,"\n");
+     }
+   fprintf(stderr,"---------------------------------------------------------\n");
+   }
+
+
+
+
+void fill_edgelist_edgeorb()
+     /* writes the edges in gg into the list in a lexicographic way and initializes is_gericht 
+        and positie*/
+
+{
+  graph g[MAXN];
+  int i,j,end;
+
+
+  memcpy(g,staticg,aantal_toppen*sizeof(graph));
+
+  for (i=j=0; i<aantal_toppen; i++) /* j is de positie in edgelist */
+    while (g[i])
+      { end=FIRSTBIT(g[i]); DELELEMENT(g+i,end);  DELELEMENT(g+end,i); 
+        edgelist[j][0]=i; edgelist[j][1]=end; 
+	positie[i][end]=positie[end][i]=j;
+	j++;
+      }
+}
+
+
+
+void fill_edgelist_edgeorb_order()
+  /* writes the edges in gg into the list in a way that for i in 1...numberedges we always have
+     that the starting point of edge i has the minimum degree of all vertices in the graph you get
+     when removing all edges i+1...aantal_bogen from gg.
+     The global variable positie is not assigned any values.
+ */
+{
+  int last_positie,i, buffer, olddeg, newdeg, beste, start, end;
+  int list[MAXN][MAXN], listlen[MAXN]={0}; /* list[i] contains the vertices with degree i at that moment */
+  int toppositie[MAXN], bufferdeg[MAXN]; /* toppositie[i] is de positie van top i in de lijst */
+  int buren[MAXN]; /* de buren van de top waaraan gewerkt wordt */
+  graph g[MAXN];
+
+  if (nodegbound) { fill_edgelist_edgeorb(); return; }
+
+  memcpy(g,staticg,aantal_toppen*sizeof(graph));
+
+    for (i=0; i<aantal_toppen; i++) { buffer=bufferdeg[i]=deg[i]; list[buffer][listlen[buffer]]=i; 
+                                      toppositie[i]=listlen[buffer]; (listlen[buffer])++; }
+
+
+    last_positie=aantal_bogen-1;
+    while (last_positie>=0)
+      {
+	for (beste=1;listlen[beste]==0; beste++);
+	(listlen[beste])--; /* zo wordt hij ook verwijderd */
+	start=list[beste][listlen[beste]];
+	for (i=0; i<beste; i++) /* alle buren opslaan*/
+	  { end=buren[i]=FIRSTBIT(g[start]); DELELEMENT(g+start,end); }
+
+	for (i=0; i<beste; i++) /* alle buren */
+	  { 
+	    end=buren[i];
+	    edgelist[last_positie][0]=start; edgelist[last_positie][1]=end; 
+	    last_positie--;
+	    DELELEMENT(g+end,start);
+	    /* de buur verhuizen: */
+	    olddeg=bufferdeg[end];
+	    (bufferdeg[end])--;
+	    newdeg=bufferdeg[end];
+	    /* uit de oude lijst verwijderen */
+	    if (listlen[olddeg]==1) listlen[olddeg]=0;
+	    else { (listlen[olddeg])--;
+	    buffer= list[olddeg][listlen[olddeg]];
+	    list[olddeg][toppositie[end]]=buffer;
+	    toppositie[buffer]=toppositie[end]; }
+	    /* tot de nieuwe toevoegen */
+	    if (newdeg)
+	      { list[newdeg][listlen[newdeg]]=end;
+	        toppositie[end]=listlen[newdeg];
+	        (listlen[newdeg])++;
+	      }
+	  }
+
+      }
+
+}
+
+
+void fill_edgelist_edgeorb_final()
+     /* writes the edges in gg into the list in a lexicographic way and initializes is_gericht 
+        and positie*/
+
+{
+  graph g[MAXN];
+  int i,j,end;
+
+
+  memcpy(g,staticg,aantal_toppen*sizeof(graph));
+
+  for (i=0, j=aantal_gerichte_bogen; i<aantal_toppen; i++) /* j is de positie in edgelist */
+    while (g[i])
+      { end=FIRSTBIT(g[i]); DELELEMENT(g+i,end);  DELELEMENT(g+end,i); 
+      if (!is_gericht[i][end])
+	{ edgelist_final[j][0]=i; edgelist_final[j][1]=end;
+	j++; }
+      }
+}
+
+
+
+void fill_edgelist_edgeorb_order_final()
+     /* works like fill_edgelist_edgeorb_order -- only that in this case some edges are already assigned a direction.
+      They are not added to the list. The first entry is at position aantal_gerichte_bogen, so that the list
+      can be used like the normal edgelist for directing in the trivial case.
+      The global variable positie is not assigned any values.
+*/
+
+{
+  int last_positie,i, buffer, olddeg, newdeg, beste, start, end;
+  int list[MAXN][MAXN], listlen[MAXN]={0}; /* list[i] contains the vertices with degree i at that moment */
+  int toppositie[MAXN], bufferdeg[MAXN]; /* toppositie[i] is de positie van top i in de lijst */
+  int buren[MAXN]; /* de buren van de top waaraan gewerkt wordt */
+  graph g[MAXN];
+
+  if (nodegbound || (aantal_bogen-aantal_gerichte_bogen<7)) { fill_edgelist_edgeorb_final(); return; }
+
+  memcpy(g,staticg,aantal_toppen*sizeof(graph));
+
+    for (i=0; i<aantal_toppen; i++) { buffer=bufferdeg[i]=deg[i]; list[buffer][listlen[buffer]]=i; 
+                                      toppositie[i]=listlen[buffer]; (listlen[buffer])++; }
+
+    last_positie=aantal_bogen-1;
+    while (last_positie>=aantal_gerichte_bogen)
+      {
+	for (beste=1;listlen[beste]==0; beste++);
+	(listlen[beste])--; /* zo wordt hij ook verwijderd */
+	start=list[beste][listlen[beste]];
+	for (i=0; i<beste; i++) /* alle buren opslaan*/
+	  { end=buren[i]=FIRSTBIT(g[start]); DELELEMENT(g+start,end); }
+
+	for (i=0; i<beste; i++) /* alle buren */
+	  if (!is_gericht[start][end=buren[i]])
+	  { 
+	    edgelist_final[last_positie][0]=start; edgelist_final[last_positie][1]=end; 
+	    last_positie--;
+	    DELELEMENT(g+end,start);
+	    /* de buur verhuizen: */
+	    olddeg=bufferdeg[end];
+	    (bufferdeg[end])--;
+	    newdeg=bufferdeg[end];
+	    /* uit de oude lijst verwijderen */
+	    if (listlen[olddeg]==1) listlen[olddeg]=0;
+	    else { (listlen[olddeg])--;
+	    buffer= list[olddeg][listlen[olddeg]];
+	    list[olddeg][toppositie[end]]=buffer;
+	    toppositie[buffer]=toppositie[end]; }
+	    /* tot de nieuwe toevoegen */
+	    if (newdeg)
+	      { list[newdeg][listlen[newdeg]]=end;
+	        toppositie[end]=listlen[newdeg];
+	        (listlen[newdeg])++;
+	      }
+	  }
+
+      }
+
+}
+
+
+
+void  mark_components(int graaf[][MAXN],int adj[],int aantal_toppen,int number[])
+     /* Does a bfs on the vertices of graaf and makes that for every vertex i the
+	value number[i] is the number of the smallest vertex in the component. 
+     */
+{
+  int i,j,min, lijst[MAX_BOGEN], buffer, b;
+  int *run, *end;
+
+  RESETMARKS
+
+  for (i=0;i<aantal_toppen;i++) 
+    if (UNMARKED(i))
+      { number[i]=i;
+      if (adj[i])
+	{ lijst[0]=min=i;
+          MARK(i);
+	  run=lijst; end=lijst+1;
+	  while (run<end)
+	    { buffer= *run;
+	    for (j=0;j<adj[buffer];j++) 
+	      if (UNMARKED(graaf[buffer][j]))
+		{ b=graaf[buffer][j];
+		MARK(b);
+	        *end=b; end++;
+		number[b]=min;
+		}
+	    run++;
+	    }
+	}
+      }
+}
+
+
+#define ADDEDGE(g,ad,a,b) {(g)[a][(ad)[a]]=b; (ad)[a]++; g[b][(ad)[b]]=a; (ad)[b]++; }
+
+void mark_orbitnumbers_edgelist(int number[], int *specialexists)
+     /* Computes the orbits of not yet directed edges by assigning the same number to edges in the 
+	same orbit. If an edge is on position i in the edgelist, number[i] is its orbitnumer.
+	The orbitnumber is always the number of the smallest edge in the orbit -- this is used 
+	in other routines !!
+	If an edge is found that is stabilized by all elements of the group, but the endpoints
+	are not, it's index is written 
+	to specialexists. If no such edge exists, *specialexists = -1;
+	In the first case the numbers in number[] are undefined. 
+	It is assumed that generators and edgelist are up to date and especially that no undirected
+	edges are mapped on directed ones by the given permutations.
+     */
+
+{ int i, j, good_special,pos2;
+  BOOG boog; 
+  int graaf[MAX_BOGEN][MAXN], adj[MAX_BOGEN];
+
+  for (i=0; i<aantal_bogen; i++) { adj[i]=0; }
+
+  for (i=0; i<aantal_bogen; i++)
+    {COPYBOOG(boog,edgelist[i]);
+    if (!is_gericht[boog[0]][boog[1]])
+      { 
+      good_special=1;
+      for (j=0; j<number_of_generators; j++)
+	{ 
+	  pos2=POSBILD(boog,j);
+	  if (i!=pos2) /* het beeld is verschillend */
+	  { good_special=0;
+	    ADDEDGE(graaf,adj,i,pos2);
+	  }
+	else { if (orbits[boog[0]]!=orbits[boog[1]]) good_special=0; }
+	}
+      if (good_special==1) { *specialexists=i; return; }
+      }
+    }
+
+  mark_components(graaf,adj,aantal_bogen,number);
+
+  *specialexists=-1;
+}
+
+
+void mark_orbitnumbers_edgelist_first(int number[], int *specialexists, int *completelyfixededge)
+     /*
+       The same as mark_orbitnumbers_edgelist -- only that *completelyfixededge is also filled in
+       -- comments see get_orbit_first()
+     */
+{ int i, j, good_special,edge_fixed, pos2;
+  BOOG boog; 
+  int graaf[MAX_BOGEN][MAXN], adj[MAX_BOGEN];
+
+  *completelyfixededge = -1;
+
+  for (i=0; i<aantal_bogen; i++) adj[i]=0;
+
+  for (i=0; i<aantal_bogen; i++)
+    {COPYBOOG(boog,edgelist[i]);
+    if (!is_gericht[boog[0]][boog[1]])
+      { 
+      good_special=edge_fixed=1;
+      for (j=0; j<number_of_generators; j++)
+	{ 
+	pos2=POSBILD(boog,j);
+	if (i!=pos2) /* het beeld is verschillend */
+	  { good_special=edge_fixed=0; 
+	    ADDEDGE(graaf,adj,i,pos2);
+	  }
+	else { if (orbits[boog[0]]!=orbits[boog[1]]) good_special=0; }
+	}
+      if (good_special) { *specialexists=i; if (*completelyfixededge >=0) return; }
+      else { if (edge_fixed) *completelyfixededge=i; }
+    }
+    }
+
+  mark_components(graaf,adj,aantal_bogen,number);
+
+  *specialexists=-1;
+}
+
+
+
+
+void mark_orbitnumbers(int number[], BOOG list_of_dir_edges[], int listlength)
+     /* Computes the orbits of the DIRECTED edges in list_of_dir_edges.
+        All edges in list_of_dir_edges[] are interpreted as going from ...[][0] to ...[][1]*/
+
+{ int i, j, pos2;
+  BOOG boog; 
+  int positie[2*MAX_BOGEN][2*MAX_BOGEN];
+  int graaf[MAX_BOGEN][MAXN], adj[MAX_BOGEN];
+
+  for (i=0; i<listlength; i++) 
+    { positie[list_of_dir_edges[i][0]][list_of_dir_edges[i][1]]=i; adj[i]=0; }
+
+  for (i=0; i<listlength; i++)
+    { COPYBOOG(boog,list_of_dir_edges[i]);
+      for (j=0; j<number_of_generators; j++)
+	{ 
+	pos2=POSBILD(boog,j);
+	if (pos2!=i)  /* het beeld is verschillend */
+	  { ADDEDGE(graaf,adj,i,pos2);
+	  }
+	}
+    }
+  mark_components(graaf,adj,listlength,number);
+}
+
+
+void mark_orbitnumbers_only_directed(int number[], BOOG list_of_edges[], int listlength)
+     /* Computes the orbits of those edges in list_of_edges that are already directed --
+	but interprets them as undirected. The subset of already directed edges in the list 
+	must be closed under the automorphisms given in the global variable generators...*/
+
+{ int i, j,a,b,pos2;
+  BOOG boog; 
+  int positie[2*MAX_BOGEN][2*MAX_BOGEN];
+  int graaf[MAX_BOGEN][MAXN], adj[MAX_BOGEN];
+
+  for (i=0; i<listlength; i++)
+    { adj[i]=0;
+      a=list_of_edges[i][0]; b=list_of_edges[i][1];
+      if (is_gericht[a][b])
+	{ positie[a][b]=positie[b][a]=i; number[i]=1; }
+      else number[i]= 0;
+    }
+
+  for (i=0; i<listlength; i++)
+    if (number[i])
+      { 
+      COPYBOOG(boog,list_of_edges[i]);
+      for (j=0; j<number_of_generators; j++)
+	{ 
+	pos2=POSBILD(boog,j);
+	if (pos2!=i)  /* het beeld is verschillend */
+	  { ADDEDGE(graaf,adj,i,pos2);
+	  }
+	}
+    }
+
+  mark_components(graaf,adj,listlength,number);
+
+}
+
+void mark_orbitnumbers_only_candidates(int number[], BOOG list_of_edges[], int listlength, int candidate[])
+     /* Computes the orbits of those edges in list_of_edges that are already directed --
+	but interprets them as undirected. The subset of already directed edges in the list 
+	must be closed under the automorphisms given in the global variable generators...*/
+
+{ int i, j,a,b,pos2;
+  BOOG boog; 
+  int positie[2*MAX_BOGEN][2*MAX_BOGEN];
+  int graaf[MAX_BOGEN][MAXN], adj[MAX_BOGEN];
+
+  for (i=0; i<listlength; i++)
+    { adj[i]=0;
+      if (candidate[i])
+	{ a=list_of_edges[i][0]; b=list_of_edges[i][1];
+	  positie[a][b]=positie[b][a]=i; 
+	}
+    }
+
+  for (i=0; i<listlength; i++)
+    if (candidate[i])
+      { 
+      COPYBOOG(boog,list_of_edges[i]);
+      for (j=0; j<number_of_generators; j++)
+	{ 
+	pos2=POSBILD(boog,j);
+	if (pos2!=i)  /* het beeld is verschillend */
+	  { ADDEDGE(graaf,adj,i,pos2); 
+	  }
+	}
+    }
+  mark_components(graaf,adj,listlength,number);
+
+}
+
+
+
+
+
+void get_orbit(BOOG kleinste_orbit[], int *orbitsize, int *biggest_orbit)
+     /* writes an orbit of still undirected edges of minimal size into kleinste_orbit. It is assumed
+	that generators and edgelist are up to date. 
+	Orbits of size one with the endpoints in different orbits are not considered -- fixing
+	this edge won't help at all, because it is already fixed by every automorphism.
+
+*/
+{
+  /* the numbers of edges are quite small, so it is not necessary to use more difficult union-set-
+     algorithms */
+  int i,j, number[MAX_BOGEN],aantallen[MAX_BOGEN];
+  int orbit_met_een,min,minorb,max;
+
+  mark_orbitnumbers_edgelist(number, &orbit_met_een);
+
+  if (orbit_met_een>=0) { COPYBOOG(kleinste_orbit[0],edgelist[orbit_met_een]); 
+                          *orbitsize=1; return; }
+
+  /* else */
+  //for (i=0; i<aantal_bogen; i++) aantallen[i]=0;
+  // Omdat number[i] altijd de kleinste in zijn orbit is, kan aantallen ook als volgt op 0 gezet worden:
+  for (i=0; i<aantal_bogen; i++)
+    { aantallen[i]=0;
+    // if (!is_gericht[edgelist[i][0]][edgelist[i][1]]) al gerichte bogen hebben hun eigen number en
+    // dus orbitsize aantallen 1 achteraf en worden dus toch al niet gekozen
+    (aantallen[number[i]])++; 
+    }
+
+
+  for (i=max=0, min=INT_MAX, minorb=-1 ; i<aantal_bogen; i++)
+    { 
+      if ((aantallen[i]>1) && (aantallen[i]<min)) /* als er een goede met orbitsize 1 is, kom je hier niet
+						     omdat die al als special is gekozen */
+	{ min=aantallen[i]; minorb=i; }
+      if ((aantallen[i])>max) max=aantallen[i];
+    }
+  *biggest_orbit=max;
+
+  /* it is possible that no orbit was found -- that is: in spite of the fact that the group is NOT
+     trivial, it does act trivially on the set of still undirected edges: */
+
+  if (minorb== -1) { *orbitsize=0; return; }
+
+  /* nu worden de bogen uit de gekozen orbit in de 
+     lijst kleinste_orbit geschreven */
+
+
+   for (i=j=0; i<aantal_bogen; i++) 
+     { if (number[i]==minorb) 
+       { COPYBOOG(kleinste_orbit[j],edgelist[i]); j++; }
+     } 
+   *orbitsize=j;
+}
+
+
+
+void get_orbit_first(BOOG kleinste_orbit[], int *orbitsize, int *fixedgeindex, int *biggest_orbit)
+     /* works like get_orbit(0), but may only be called for the initial still undirected
+	graph. *fixedgeindex is the index of an edge in the global edgelist where both
+	endpoints are fixed under the group (if such an edge exists -- otherwise it is -1.
+     */
+
+{
+  /* the numbers of edges are quite small, so it is not necessary to use more difficult union-set-
+     algorithms */
+  int i,j, number[MAX_BOGEN],aantallen[MAX_BOGEN];
+  int orbit_met_een,min,minorb, max;
+
+  *fixedgeindex= -1;
+
+  mark_orbitnumbers_edgelist_first(number, &orbit_met_een, fixedgeindex);
+
+  if (orbit_met_een>=0) 
+    { COPYBOOG(kleinste_orbit[0],edgelist[orbit_met_een]); 
+      *biggest_orbit=MAXPAR_ORBSIZE+1; *orbitsize=1; return; }
+ 
+  /* else */
+  for (i=0; i<aantal_bogen; i++) aantallen[i]=0;
+  for (i=0; i<aantal_bogen; i++) (aantallen[number[i]])++;
+  //if (!is_gericht[edgelist[i][0]][edgelist[i][1]]) (aantallen[number[i]])++;
+
+
+  for (i=max=0, min=INT_MAX, minorb= -1 ; i<aantal_bogen; i++)
+    { 
+      if ((aantallen[i]) && (aantallen[i]<min) && 
+	  ((aantallen[i]>1) || (orbits[edgelist[i][0]]==orbits[edgelist[i][1]]))) 
+	{ min=aantallen[i]; minorb=i; }
+      if ((aantallen[i])>max) max=aantallen[i];
+    }
+
+  *biggest_orbit=max;
+
+
+  /* it is possible that no orbit was found -- that is: in spite of the fact that the group is NOT
+     trivial, it does act trivially on the set of still undirected edges: */
+
+  if (minorb == -1) { *orbitsize=0; return; }
+  /* the group only permutes isolated vertices */
+
+  /* nu worden de bogen uit de gekozen orbit in de 
+     lijst kleinste_orbit geschreven */
+
+
+   for (i=j=0; i<aantal_bogen; i++) 
+     { if (number[i]==minorb) 
+       { COPYBOOG(kleinste_orbit[j],edgelist[i]); j++; }
+     } 
+   *orbitsize=j;
+}
+
+void trynextstep()
+/* This routine is called when a whole orbit has been labelled and new orbits have to be computed.
+   If orbitsgiven != NULL it contains the actual information about the new orbits. */
+{  int i, orbitsize, dummy, k,j,complete,start,end, biggest_orbit=0;
+  BOOG kleinste_orbit[MAX_BOGEN+1];
+  BOOG al_gericht[MAX_BOGEN+1];
+  int inorbit[MAXN][MAXN], numberinorbit[MAXN];
+  graph buffergraph[MAXN];
+
+  if (aantal_gerichte_bogen==aantal_bogen) { MAYBEPROCESS; WRITEUP(); return; }
+
+  if (!nodegbound)
+    {
+      for (i=0, complete=1; i<aantal_bogen; i++) 
+	{ if (!is_gericht[edgelist[i][0]][edgelist[i][1]] && 
+	      !virtual_gericht[edgelist[i][0]][edgelist[i][1]]) { complete=0; break; }
+	}
+ 
+      if (complete)  
+	{ if (direct_output==0) { WRITEUP(); } 
+	  else
+	    { 
+	      memcpy(buffergraph,workg,aantal_toppen*sizeof(graph));
+              for (i=0; i<aantal_bogen; i++) 
+		{ start=edgelist[i][0]; end=edgelist[i][1];
+		  if (!is_gericht[start][end])
+		  { if (virtual_gericht[start][end]==1) 
+		      DELELEMENT(workg+end,start);
+		    else  DELELEMENT(workg+start,end); 
+		  }
+		}
+	      MAYBEPROCESS;
+	      WRITEUP();
+	      memcpy(workg,buffergraph,aantal_toppen*sizeof(graph));
+	    }
+	return; }
+    }
+
+  if (!group_up_to_date)
+    { /* we need only the group -- no canonical numbering */
+         number_of_generators=0;
+	 memcpy(bufferlab,lab[nextstep_depth],aantal_toppen*sizeof(nvector));
+	 memcpy(bufferptn,ptn[nextstep_depth],aantal_toppen*sizeof(nvector));
+	 nauty(workg,bufferlab,bufferptn,NILSET,orbits,&options_directed,&stats,workspace,100*MAXN,1,aantal_toppen,NULL);
+	 group_up_to_date=1;
+  }
+
+  nextstep_depth++;
+
+  if (stats.numorbits==aantal_toppen) /* triviale groep */
+    { 
+      fill_edgelist_edgeorb_order_final();
+      laatstepositie=edgelist_final+aantal_bogen-1;
+      trivlabels_init(edgelist_final+aantal_gerichte_bogen);
+      nextstep_depth--;
+      return;
+    }
+  /* else: de groep is jammer genoeg niet triviaal */
+  get_orbit(kleinste_orbit,&orbitsize,&biggest_orbit);
+
+
+  if (orbitsize==0) /* group acts trivially on remaining edges */
+    { 
+      fill_edgelist_edgeorb_order_final();
+      laatstepositie=edgelist_final+aantal_bogen-1;
+      trivlabels_init(edgelist_final+aantal_gerichte_bogen);
+      nextstep_depth--;
+      return;
+    }
+  /* else */ 
+
+  memcpy(colour[nextstep_depth],orbits,aantal_toppen*sizeof(nvector));
+  for (i=0;i<aantal_toppen;i++) numberinorbit[i]=0;
+  for (i=0;i<aantal_toppen;i++) { dummy=orbits[i]; 
+                                  inorbit[dummy][numberinorbit[dummy]]=i;
+				  (numberinorbit[dummy])++;
+                                }
+  for (i=k=0;i<aantal_toppen;i++) 
+    { for (j=0;j<numberinorbit[i]-1; j++) { ptn[nextstep_depth][k]=1; lab[nextstep_depth][k]=inorbit[i][j]; k++; } 
+      if (numberinorbit[i]) { ptn[nextstep_depth][k]=0; lab[nextstep_depth][k]=inorbit[i][j]; k++; }
+    }
+
+
+
+  /* maybe at least the whole orbit is forced... */
+  if (!nodegbound)
+    {
+      for (i=0, complete=1; i<orbitsize; i++) 
+	{ if (!virtual_gericht[kleinste_orbit[i][0]][kleinste_orbit[i][1]]) { complete=0; break; }
+	}
+      
+      if (complete) 
+	{ aantal_gerichte_bogen+=orbitsize;
+	  for (i=0; i<orbitsize; i++) 
+		{ start=kleinste_orbit[i][0]; end=kleinste_orbit[i][1];
+		  saturated[start]++; saturated[end]++;
+		  is_gericht[start][end]=is_gericht[end][start]=1;
+		  if (virtual_gericht[start][end]==1) 
+		      { DELELEMENT(workg+end,start);
+			outdeg_free[start]--; indeg_free[end]--;
+		      }
+		    else  
+		      { DELELEMENT(workg+start,end); 
+			outdeg_free[end]--; indeg_free[start]--;
+		      }
+		  }
+	  group_up_to_date=0;
+	  // I guess the group is still correct -- but better write up a formal proof before
+	  // assuming this in the program...
+
+	  trynextstep();
+
+	  aantal_gerichte_bogen-=orbitsize;
+	  for (i=0; i<orbitsize; i++) 
+		{ start=kleinste_orbit[i][0]; end=kleinste_orbit[i][1];
+		  saturated[start]--; saturated[end]--;
+		  is_gericht[start][end]=is_gericht[end][start]=0;
+		  if (virtual_gericht[start][end]==1) 
+		    { ADDELEMENT(workg+end,start);
+		    outdeg_free[start]++; indeg_free[end]++;
+		    }
+		  else  
+		    { ADDELEMENT(workg+start,end); 
+		    outdeg_free[end]++; indeg_free[start]++;
+		    }
+		}
+	  group_up_to_date=0;
+	  nextstep_depth--;
+	return; }
+    }
+
+  nontrivlabels(kleinste_orbit,0,orbitsize,al_gericht,biggest_orbit);
+  nextstep_depth--;
+  return;
+}
+
+void trynextstep_par() 
+/* This routine is called when a whole orbit has been labelled and new orbits have to be computed.
+   If orbitsgiven != NULL it contains the actual information about the new orbits. */
+{  int i, orbitsize, dummy, k,j,biggest_orbit;
+  BOOG kleinste_orbit[MAX_BOGEN+1];
+  int inorbit[MAXN][MAXN], numberinorbit[MAXN];
+
+  if (aantal_gerichte_bogen==aantal_bogen) { MAYBEPROCESS; WRITEUP(); return; }
+
+  if (!group_up_to_date)
+    { /* we need only the group -- no canonical numbering */
+         number_of_generators=0;
+	 memcpy(bufferlab,lab[nextstep_depth],aantal_toppen*sizeof(nvector));
+	 memcpy(bufferptn,ptn[nextstep_depth],aantal_toppen*sizeof(nvector));
+	 nauty(workg,bufferlab,bufferptn,NILSET,orbits,&options_directed,&stats,workspace,100*MAXN,1,aantal_toppen,NULL);
+	 group_up_to_date=1;
+  }
+
+  nextstep_depth++;
+
+  if (stats.numorbits==aantal_toppen) /* triviale groep */
+    { 
+      fill_edgelist_edgeorb_order_final();
+      laatstepositie=edgelist_final+aantal_bogen-1;
+      trivlabels_init(edgelist_final+aantal_gerichte_bogen);
+      nextstep_depth--;
+      return;
+    }
+  /* else: de groep is jammer genoeg niet triviaal */
+  get_orbit(kleinste_orbit,&orbitsize,&biggest_orbit);
+
+
+  if (orbitsize==0) /* group acts trivially on remaining edges */
+    { 
+      fill_edgelist_edgeorb_order_final();
+      laatstepositie=edgelist_final+aantal_bogen-1;
+      trivlabels_init(edgelist_final+aantal_gerichte_bogen);
+      nextstep_depth--;
+      return;
+    }
+  /* else */ 
+
+  memcpy(colour[nextstep_depth],orbits,aantal_toppen*sizeof(nvector));
+  for (i=0;i<aantal_toppen;i++) numberinorbit[i]=0;
+  for (i=0;i<aantal_toppen;i++) { dummy=orbits[i]; 
+                                  inorbit[dummy][numberinorbit[dummy]]=i;
+				  (numberinorbit[dummy])++;
+                                }
+  for (i=k=0;i<aantal_toppen;i++) 
+    { for (j=0;j<numberinorbit[i]-1; j++) { ptn[nextstep_depth][k]=1; lab[nextstep_depth][k]=inorbit[i][j]; k++; } 
+      if (numberinorbit[i]) { ptn[nextstep_depth][k]=0; lab[nextstep_depth][k]=inorbit[i][j]; k++; }
+    }
+
+  parallel_orbit_labelling(kleinste_orbit, orbitsize);
+  nextstep_depth--;
+  return;
+}
+
+
+
+void compute_extensions(BOOG kleinste_orbit[], int orbitsize, BOOG extensionlist[], int *number_of_extensions)
+     /* Computes the number of extensions by computing the orbits on the possibilities to direct the 
+	not yet directed edges in kleinste_orbit. To be precise: First a list of directed versions of the
+	not yet directed edges is made (2 directed for each undirected) and then the orbits are computed
+	and one directed edge for every version is filled in. 
+	Already at this stage indeg and outdeg are considered, so that directed edges that would violate
+	these conditions aren't considered.
+*/
+{
+BOOG bufferlist[2*MAX_BOGEN];
+BOOG candidatelist[MAX_BOGEN];
+int number[2*MAX_BOGEN], number_of_candidates;
+int buffersize,n_ext;
+int i,start,end, problem, sum, maxsum;
+
+
+ /* the last edge should always be one with minimal QUALITY -- good edges early. See Definition of QUALITY
+    in the header. */
+
+
+ maxsum=INT_MAX;
+ number_of_candidates=0;
+
+ for (i=0; i<orbitsize; i++)
+   { start=kleinste_orbit[i][0]; end=kleinste_orbit[i][1];
+   if (!is_gericht[start][end]) { candidatelist[number_of_candidates][0]=start; 
+                                  candidatelist[number_of_candidates][1]=end;
+				  number_of_candidates++; }
+   else /* one that is already directed */
+     { 
+     if (ISELEMENT(workg+start,end)) sum=QUALITY_P1(start,end); else sum=QUALITY_P1(end,start);
+     /* this sum can be increased by one when the new edge is added */
+       if (sum<maxsum) maxsum=sum;
+     }
+   }
+ 
+ for (i=buffersize=0; i<number_of_candidates; i++)
+     { start=candidatelist[i][0]; end=candidatelist[i][1];
+       /* the tests are done in the loop to detect problems with unassignable edges also if they
+	  do not fulfill the canonicity criteria */
+       problem=1; /* maybe the edge cannot be directed at all !! */
+       if (outdeg_free[start] && indeg_free[end]) 
+       { sum=QUALITY_P2(start,end);
+	 if (sum<=maxsum) {bufferlist[buffersize][0]=start; bufferlist[buffersize][1]=end; buffersize++;} 
+         problem=0;}
+     if (outdeg_free[end] && indeg_free[start]) 
+       { sum=QUALITY_P2(end,start);
+	 if (sum<=maxsum) {bufferlist[buffersize][0]=end; bufferlist[buffersize][1]=start; buffersize++;} 
+         problem=0;}
+     if (problem) { *number_of_extensions=0; return; }
+     }
+
+ if (buffersize>1)
+  { 
+    if (!group_up_to_date) 
+      { number_of_generators=0;
+        memcpy(bufferlab,lab[nextstep_depth],aantal_toppen*sizeof(nvector));
+	memcpy(bufferptn,ptn[nextstep_depth],aantal_toppen*sizeof(nvector));
+	nauty(workg,bufferlab,bufferptn,NILSET,orbits,&options_directed_canon,&stats,\
+	      workspace, 100*MAXN,1,aantal_toppen,canong);
+	group_up_to_date=1;
+      }
+     mark_orbitnumbers(number,bufferlist,buffersize);
+     for (i=n_ext=0; i<buffersize; i++) 
+     if (number[i]==i) { COPYBOOG(extensionlist[n_ext],bufferlist[i]);
+                         n_ext++; }
+     *number_of_extensions=n_ext;
+   }
+ else
+   { if (buffersize)
+     { COPYBOOG(extensionlist[0],bufferlist[0]);
+       *number_of_extensions=1; }
+   else *number_of_extensions=0;
+   }
+ return;
+
+}
+
+
+int getexpensivequality(graph x,graph y)
+{
+int j;
+int qual=0;
+
+ FORALLELEMENTS(x,j) qual+=(saturated[j]<<4)-indeg_free[j];
+ qual = qual<<6;
+ FORALLELEMENTS(y,j) qual+=(saturated[j]<<4)-indeg_free[j];
+
+ return qual;
+}
+
+int is_canonical_edge(BOOG list[],int last_positie)
+/* Checks whether the directed edge x->y is canonical -- that is: 
+   choose one with minimal QUALITY 
+   and amongst them one with biggest (deg[end]+maxoutdeg-outdeg_free[end])<<6+indeg_free[start] 
+   the smallest among all lexicographic pairs canon_number(a),canon_number(b)
+   with a->b or b-> a a directed edge in list[]. Then check whether
+   a->b is in the same orbit as the edge of this smallest pair.
+   The group must be up to date.
+ */
+{
+  int i, minx=INT_MAX, miny=INT_MAX, a,b, which=INT_MAX;
+  /* Some of the initializations are not necessary -- just to get rid of warnings
+     if compiled with -Wall */
+  int canonnumber[MAXN],x,y;
+  int number[MAX_BOGEN];
+  int candidate[MAX_BOGEN];
+  int referencesum, sum, gotacandidate, endquality, lq, eq, expensivequality;
+
+  x=list[last_positie][0]; y=list[last_positie][1];
+
+  referencesum=QUALITY(x,y);
+  endquality=((deg[y]+maxoutdeg-outdeg_free[y])<<6)-indeg_free[x];
+  expensivequality= -1;
+  candidate[last_positie]=1;
+
+  gotacandidate=0;
+  for (i=0; i<last_positie; i++)
+    { a=list[i][0]; b=list[i][1];
+      sum=QUALITY(a,b);
+      if (sum<referencesum) return 0;
+      if (sum==referencesum)
+	{ 
+	  
+	  lq=((deg[b]+maxoutdeg-outdeg_free[b])<<6)-indeg_free[a]; 
+	  if (lq>endquality) return 0;
+	  if (lq==endquality) 
+	    { /* OK -- nog een poging */
+	      if (expensivequality== -1) 
+		expensivequality=getexpensivequality(workg[x],workg[y]);
+	      eq=getexpensivequality(workg[a],workg[b]);
+	      if (eq<expensivequality) return 0;
+	      else 
+		if (eq==expensivequality)
+		  { candidate[i]=1; gotacandidate=1; }
+		else candidate[i]=0;
+	    }
+	  else candidate[i]=0;
+	}
+      else candidate[i]=0;
+    }
+   
+  if (!gotacandidate) return 1; /* Only the edge itself */
+
+  number_of_generators=0;
+  memcpy(bufferlab,lab[nextstep_depth],aantal_toppen*sizeof(nvector));
+  memcpy(bufferptn,ptn[nextstep_depth],aantal_toppen*sizeof(nvector));
+  nauty(workg,bufferlab,bufferptn,NILSET,orbits,&options_directed_canon,&stats,\
+	workspace, 100*MAXN,1,aantal_toppen,canong);
+  group_up_to_date=1;
+  
+  for (i=0;i<aantal_toppen;i++) canonnumber[bufferlab[i]]=i;
+
+  for (i=0; i<=last_positie; i++)
+    if (candidate[i])
+    {
+      a=canonnumber[list[i][0]]; b=canonnumber[list[i][1]];
+      if ((a<minx) || ((a==minx) && (b<miny))) { minx=a; miny=b; which=i; }
+    }
+
+  if (which==last_positie) return 1;
+   
+  mark_orbitnumbers_only_candidates(number, list, last_positie+1, candidate);
+
+  if (number[which]==number[last_positie]) return 1; else return 0;
+
+}
+
+
+void force_edges(int top, int all_out, BOOG forcelist[], int *listlen, int *problem)
+     /* directs forced edges, *problem is set to 1 if the partial
+	direction cannot be completed according to the rules 
+
+	all_out==1 betekent dat de bogen naar buiten gericht moeten worden ==0
+	naar binnen.
+
+	This routine assumes that if indeg==maxindeg there is still enough room
+	to force all the rest outgoing (and reverse). So it must be tested in advance
+	that maxindeg+maxoutdeg<=deg[i] for all vertices i!
+
+*/
+
+{ int j,i,end;
+  int list[2*MAXN+2], richting[3*MAXN];
+
+  end=0;
+
+  if (virtual_indeg[top]+virtual_outdeg[top]==deg[top]) return;
+
+  if (all_out) /* all the rest must be directed outwards */
+    { 
+      FORALLELEMENTS(workg[top],j)
+	{
+	  if (!is_gericht[top][j] && !virtual_gericht[top][j]) /* a new edge to be virtually directed */
+	    { if (virtual_indeg[j]==maxindeg) { *problem=1; return; }
+	    virtual_indeg[j]++; virtual_outdeg[top]++;
+	    virtual_gericht[top][j]=1; virtual_gericht[j][top]=2;
+	    forcelist[*listlen][0]=top; forcelist[*listlen][1]=j; (*listlen)++;
+	    if (virtual_indeg[j]==maxindeg) { list[end]=j; richting[end]=1; end++; }
+	    /* top kan maar 1 keer door virtual_indeg[top]==maxindeg toegevoegd worden */
+	    }
+	}
+      if (*problem) return;
+    }
+  else
+    /* all the rest must be directed inwards */
+    { 
+      FORALLELEMENTS(workg[top],j)
+	{
+	  if (!is_gericht[top][j] && !virtual_gericht[top][j]) /* a new edge to be virtually directed */
+	    { if (virtual_outdeg[j]==maxoutdeg) { *problem=1; return; }
+	    virtual_indeg[top]++; virtual_outdeg[j]++;
+	    virtual_gericht[top][j]=2; virtual_gericht[j][top]=1;
+	    forcelist[*listlen][1]=top; forcelist[*listlen][0]=j; (*listlen)++;
+	    if (virtual_outdeg[j]==maxoutdeg) { list[end]=j; richting[end]=0; end++; }
+	    /* top kan maar 1 keer door virtual_outdeg[top]==maxoutdeg toegevoegd worden */
+	    }
+	}
+      
+    }
+
+  
+  for (i=0; i<end; i++)
+    { top=list[i];
+    all_out=richting[i];
+    if (virtual_indeg[top]+virtual_outdeg[top]<deg[top])
+      {
+	if (all_out) /* all the rest must be directed outwards */
+	  { 
+	    FORALLELEMENTS(workg[top],j)
+	      {
+		if (!is_gericht[top][j] && !virtual_gericht[top][j]) /* a new edge to be virtually directed */
+		  { if (virtual_indeg[j]==maxindeg) { *problem=1; return; }
+		  virtual_indeg[j]++; virtual_outdeg[top]++;
+		  virtual_gericht[top][j]=1; virtual_gericht[j][top]=2;
+		  forcelist[*listlen][0]=top; forcelist[*listlen][1]=j; (*listlen)++;
+		  if (virtual_indeg[j]==maxindeg) { list[end]=j; richting[end]=1; end++; }
+		  /* top kan maar 1 keer door virtual_indeg[top]==maxindeg toegevoegd worden */
+		  }
+	      }
+	  if (*problem) return;
+	}
+	else
+       /* all the rest must be directed inwards */
+	{
+	  FORALLELEMENTS(workg[top],j)
+	    { 
+	      if (!is_gericht[top][j] && !virtual_gericht[top][j]) /* a new edge to be virtually directed */
+		{ if (virtual_outdeg[j]==maxoutdeg) { *problem=1; return; }
+		virtual_indeg[top]++; virtual_outdeg[j]++;
+		virtual_gericht[top][j]=2; virtual_gericht[j][top]=1;
+		forcelist[*listlen][1]=top; forcelist[*listlen][0]=j; (*listlen)++;
+		if (virtual_outdeg[j]==maxoutdeg) { list[end]=j; richting[end]=0; end++; }
+		/* top kan maar 1 keer door virtual_outdeg[top]==maxoutdeg toegevoegd worden */
+		}
+	    }
+
+	}
+    }
+    }
+}
+
+int allemaal_doubles_mogelijk(BOOG edgelist[],int orbitsize, int marker[], int *endlist)
+     /* returns 1 if all edges in edgelist that are not yet directed can be made double edges,
+      otherwise 0. marker [i] is 1 if edgelist[i] can be made double and is still to be directed
+      and 0 otherwise.
+
+      The fields fixing that they are directed are also filled in.
+
+      maybe I should rewrite the program in a way to always have the list of undirected 
+      edges available -- unfortunately that takes so little time that it is hardly worth it... */
+{
+  int i, start, end;
+
+  *endlist= -1;
+  for (i=0; i<orbitsize; i++)
+  { start=edgelist[i][0]; end=edgelist[i][1];
+  if (!is_gericht[start][end])
+    {
+      if (!nodegbound)
+	{
+	  if (!(double_free[start] && double_free[end])) { return 0; }
+	  if (!((virtual_indeg[start]<maxindeg) && (virtual_indeg[end]<maxindeg) &&
+		(virtual_outdeg[start]<maxoutdeg) && (virtual_outdeg[end]<maxoutdeg))) { return 0; }
+	  if (virtual_gericht[start][end]) { return 0; } /* dat is altijd in maar een richting... */
+	}
+      /* else -- kann dubbel worden */
+      marker[i]=1;
+      *endlist=i; /* de laatste positie waar er iets veranderd werd */
+      remaining_doubles--;
+      aantal_gerichte_bogen++;
+      is_gericht[start][end]=is_gericht[end][start]=1;
+      /* a double edge can never be forced */
+      virtual_indeg[start]++; virtual_indeg[end]++; 
+      virtual_outdeg[start]++; virtual_outdeg[end]++; 
+      saturated[start]+=2; saturated[end]+=2;
+      /* note that this is only compatible with the symmetry group, because all
+	 edges in the orbit are handled at the same time -- otherwise it would 
+	 destroy symmetry -- not yet handled edges and edges that are decided to stay
+	 double will be different for the quality criterion if they were identic before. */
+      (indeg_free[end])--; (outdeg_free[start])--;
+      (indeg_free[start])--; (outdeg_free[end])--;
+      double_free[start]--; double_free[end]--;
+    }
+  else marker[i]=0;
+  }
+
+  return 1;
+
+}
+
+void reset_doubles(BOOG edgelist[], int marklist[], int marklistend)
+
+{
+  int i, start, end;
+
+  for (i=0; i<=marklistend; i++)
+    if (marklist[i])
+      { start=edgelist[i][0]; end=edgelist[i][1];
+        is_gericht[start][end]=is_gericht[end][start]=0;
+	virtual_indeg[start]--; virtual_indeg[end]--; 
+	virtual_outdeg[start]--; virtual_outdeg[end]--; 
+	saturated[start]-=2; saturated[end]-=2;
+      /* note that this is only compatible with the symmetry group, because all
+	 edges in the orbit are handled at the same time -- otherwise it would 
+	 destroy symmetry -- not yet handled edges and edges that are decided to stay
+	 double will be different for the quality criterion if they were identic before. */
+	remaining_doubles++;
+	(indeg_free[end])++; (outdeg_free[start])++;
+	(indeg_free[start])++; (outdeg_free[end])++;
+	double_free[start]++; double_free[end]++;
+	aantal_gerichte_bogen--;
+    }
+
+  return;
+
+}
+
+/*************************DO_EXTENSIONS_PAR********************************/
+
+void do_extensions_par(BOOG orbit[],int positie,int numberin[],int numberout[], int numberdouble[],unsigned int op)
+{
+  int start, end;
+
+  if (positie<0) { parops[number_parops]=op; number_parops++; return; }
+
+  start=orbit[positie][0]; end=orbit[positie][1];
+
+  if ((indeg_free[start]-numberin[start]>0) && (outdeg_free[end]-numberout[end]>0))
+    // incoming possible
+    { SETOP(op,positie,2); 
+      numberin[start]++; numberout[end]++;
+      do_extensions_par(orbit,positie-1,numberin,numberout,numberdouble,op);
+      numberin[start]--; numberout[end]--;
+    }
+
+  if (double_allowed && (indeg_free[start]-numberin[start]>0) && (indeg_free[end]-numberin[end]>0) &&
+      (outdeg_free[start]-numberout[start]>0) && (outdeg_free[end]-numberout[end]>0) &&
+      (double_free[start]-numberdouble[start]>0) && (double_free[end]-numberdouble[end]>0))
+    // double possible
+    { SETOP(op,positie,1); 
+      numberin[start]++; numberin[end]++; numberout[start]++; numberout[end]++;
+      numberdouble[start]++; numberdouble[end]++;
+      do_extensions_par(orbit,positie-1,numberin,numberout,numberdouble,op);
+      numberin[start]--; numberin[end]--; numberout[start]--; numberout[end]--;
+      numberdouble[start]--; numberdouble[end]--;
+    }
+
+
+  if ((indeg_free[end]-numberin[end]>0) && (outdeg_free[start]-numberout[start]>0))
+    // outgoing possible
+    { SETOP(op,positie,0); 
+      numberin[end]++; numberout[start]++;
+      do_extensions_par(orbit,positie-1,numberin,numberout,numberdouble,op);
+      numberin[end]--; numberout[start]--;
+    }
+
+  return;
+
+
+}
+
+/*************************COMPUTE_PAR_EXTENSIONS********************************/
+
+int compute_par_extensions(BOOG orbit[], int orbitsize)
+// orbitsize must be at least 1
+{
+  int numberin[MAXN], numberout[MAXN], numberdouble[MAXN], i;
+  unsigned int op;
+
+  for (i=0; i<aantal_toppen; i++) numberin[i]=numberout[i]=numberdouble[i]=0;
+
+
+  number_parops=0;
+  op=0U;
+
+  do_extensions_par(orbit,orbitsize-1,numberin,numberout,numberdouble,op);
+
+  return number_parops;
+}
+
+unsigned int par_image(unsigned int orig, permutation aut[], BOOG orbit[], int orbitsize, int inv[][MAXN])
+{
+  int i, type, start, end, positie;
+  unsigned int image;
+
+  image=0U;
+
+  for (i=0;i<orbitsize;i++)
+    { type=GETTYPE(orig,i);
+      start=aut[orbit[i][0]]; end=aut[orbit[i][1]];
+      positie=inv[start][end];
+      if (positie<0)
+	{ positie= -1-positie; type=2-type; }
+      SETOP(image,positie,type);
+    }
+
+  return image;
+
+}
+
+#define FIND_PAROP(op,pos) {int min,max; min=0; max=num_extensions-1; pos=(min+max)/2;\
+    while (min!=max) { if (op<parops[pos]) min=pos+1; else max=pos; pos=(min+max)/2; }}
+
+
+int compute_par_orbits(BOOG edgeorbit[],int orbitsize,int num_extensions, unsigned int nonequivextensions[])
+{
+  int root[MAXPAROPS], i, j, pos1, pos2, orbits, buf;
+  unsigned int buffer;
+  int inv[MAXN][MAXN]; 
+  // inv[i][j] is the position of edge {i,j} in edgeorbit. If inv[i][j]<0 this means that in fact {j,i} is in
+  // edgeorbit -- and that on position -(inv[i][j])-1 -- the one is necessary as -0 = 0
+
+  for (i=0;i<orbitsize;i++) { inv[edgeorbit[i][0]][edgeorbit[i][1]]=i; inv[edgeorbit[i][1]][edgeorbit[i][0]]= -i-1; }
+
+  for (i=0; i<num_extensions; i++) root[i]=i;
+
+  for (i=0; i<num_extensions; i++)
+    for (j=0; j<number_of_generators; j++)
+      { 
+	buffer=par_image(parops[i],generators[j],edgeorbit,orbitsize,inv);
+	FIND_PAROP(buffer,pos1);
+	while (root[pos1]!=pos1) pos1=root[pos1];
+	pos2=i;
+	while ((buf=root[pos2])!=pos2) { root[pos2]=pos1; pos2=buf; }
+	root[pos2]=pos1;
+      }
+
+  for (orbits=i=0; i<num_extensions; i++)
+    { if (root[i]==i) { nonequivextensions[orbits]=parops[i]; orbits++; } }
+
+  return orbits;
+
+}
+
+
+void parallel_orbit_labelling(BOOG edge_orbit[], int orbitsize)
+{
+  int num_extensions, i,j,type, start, end;
+  unsigned int nonequivextensions[MAXPAROPS], buf;
+
+  
+  if (!group_up_to_date) 
+    { number_of_generators=0;
+      memcpy(bufferlab,lab[nextstep_depth],aantal_toppen*sizeof(nvector));
+      memcpy(bufferptn,ptn[nextstep_depth],aantal_toppen*sizeof(nvector));
+      nauty(workg,bufferlab,bufferptn,NILSET,orbits,&options_directed_canon,&stats, \
+	    workspace, 100*MAXN,1,aantal_toppen,canong);
+      group_up_to_date=1;
+      }
+
+  num_extensions=compute_par_extensions(edge_orbit, orbitsize);
+
+  num_extensions=compute_par_orbits(edge_orbit,orbitsize,num_extensions,nonequivextensions);
+
+  
+
+
+  aantal_gerichte_bogen += orbitsize;
+  for (j=0;j<orbitsize;j++) 
+    { start=edge_orbit[j][0]; end=edge_orbit[j][1];
+      saturated[start]++; saturated[end]++; 
+      is_gericht[start][end]=is_gericht[end][start]=1;
+    }
+
+  for (i=0;i<num_extensions;i++)
+    { buf=nonequivextensions[i];
+      for (j=0;j<orbitsize;j++)
+	{ type=GETTYPE(buf,j);
+	  start=edge_orbit[j][0]; end=edge_orbit[j][1];
+	  
+	  if (type==0) // outgoing
+	    { outdeg_free[start]--; indeg_free[end]--;
+	      DELELEMENT(workg+end,start);
+	    }
+	  else
+	  if (type==2) // incoming
+	    { outdeg_free[end]--; indeg_free[start]--;
+	      DELELEMENT(workg+start,end);
+	    }
+	  else // (type==1)
+	    { outdeg_free[end]--; outdeg_free[start]--; remaining_doubles--;
+	      indeg_free[end]--; indeg_free[start]--;
+	    }
+	}
+
+      group_up_to_date=0;
+      trynextstep_par(); 
+      // don't switch back to general routine as some fields are not filled in
+      // properly -- e.g. virtual degrees and saturated
+      
+      for (j=0;j<orbitsize;j++)
+	{ type=GETTYPE(buf,j);
+	  start=edge_orbit[j][0]; end=edge_orbit[j][1];
+	  
+	  if (type==0) // outgoing
+	    { outdeg_free[start]++; indeg_free[end]++;
+	      ADDELEMENT(workg+end,start);
+	    }
+	  else
+	  if (type==2) // incoming
+	    { outdeg_free[end]++; indeg_free[start]++;
+	      ADDELEMENT(workg+start,end);
+	    }
+	  else // (type==1)
+	    { outdeg_free[end]++; outdeg_free[start]++; remaining_doubles++;
+	      indeg_free[end]++; indeg_free[start]++;
+	    }
+	}
+      group_up_to_date=0;
+    }
+  
+  aantal_gerichte_bogen -= orbitsize;
+  for (j=0;j<orbitsize;j++) 
+    { start=edge_orbit[j][0]; end=edge_orbit[j][1];
+      saturated[start]--; saturated[end]--; 
+      is_gericht[start][end]=is_gericht[end][start]=0;
+    }
+  
+  return;
+
+}
+
+
+void nontrivlabels(BOOG kleinste_orbit[], int done_in_orbit, int orbitsize, BOOG al_gericht[],
+		   int maxorbit)
+     /* geeft een richting aan de bogen in het geval van automorphismen */
+{
+  int i,j,start,end, number_of_extensions, problem, forcelistlen;
+  BOOG extensionlist[2*MAX_BOGEN], forcelist[MAX_BOGEN];
+  int marklist[MAX_BOGEN], marklistend;
+
+
+  if ((done_in_orbit==0) && // just to make sure the other tests are just done once for each orbit
+      (orbitsize>1) && (orbitsize<=SWITCHPAR_ORBSIZE) && (maxorbit<=MAXPAR_ORBSIZE))
+    { parallel_orbit_labelling(kleinste_orbit, orbitsize); return; }
+
+ compute_extensions(kleinste_orbit, orbitsize, extensionlist,&number_of_extensions);
+
+ for (i=0; i<number_of_extensions; i++)
+   { 
+       start=extensionlist[i][0]; end=extensionlist[i][1];
+       if (((virtual_outdeg[start]<maxoutdeg) && (virtual_indeg[end]<maxindeg)) || (virtual_gericht[start][end]==1))
+        { problem=forcelistlen=0;
+	  outdeg_free[start]--; indeg_free[end]--;
+	  saturated[start]++; saturated[end]++;
+	  is_gericht[start][end]=is_gericht[end][start]=1;
+	  DELELEMENT(workg+end,start);
+	  group_up_to_date=0;
+	  aantal_gerichte_bogen++;
+	  al_gericht[done_in_orbit][0]=start; al_gericht[done_in_orbit][1]=end;
+	  if (!virtual_gericht[start][end]) 
+	    { 
+	      virtual_outdeg[start]++; virtual_indeg[end]++;
+	      if (virtual_outdeg[start]==maxoutdeg) 
+		force_edges(start, 0, forcelist, &forcelistlen, &problem);
+	      if (!problem && (virtual_indeg[end]==maxindeg) ) 
+		force_edges(end, 1, forcelist, &forcelistlen, &problem); }
+
+	  if (!problem && ((done_in_orbit==0) || is_canonical_edge(al_gericht,done_in_orbit)))
+	 /* if is_canonical_edge() is called, done_in_orbit>0, so nauty was just called and the 
+	    group is up to date */
+	    { 
+	      if (done_in_orbit+1 < orbitsize)
+		nontrivlabels(kleinste_orbit, done_in_orbit+1, orbitsize,al_gericht,maxorbit);
+	    else
+	      trynextstep();
+	    }
+	  outdeg_free[start]++; indeg_free[end]++;
+	  saturated[start]--; saturated[end]--;
+	  is_gericht[start][end]=is_gericht[end][start]=0;
+	  ADDELEMENT(workg+end,start);
+	  group_up_to_date=0;
+	  aantal_gerichte_bogen--;
+	  if (!virtual_gericht[start][end]) 
+	    { virtual_outdeg[start]--; virtual_indeg[end]--;
+	    for (j=0; j<forcelistlen;j++)
+	      {
+		start=forcelist[j][0]; end=forcelist[j][1];
+		virtual_gericht[start][end]=virtual_gericht[end][start]=0;
+		virtual_outdeg[start]--; virtual_indeg[end]--;
+	      }
+	    }
+	}
+   } /* einde for-loop */
+
+ /* conventie: dubbel edges hebben de hoogste prioriteit om verwijdert te worden. Dat betekent 
+    dat ze als laatste in een orbit die opgevuld moet worden toegevoegd worden */
+
+ if ((remaining_doubles >= orbitsize-done_in_orbit) && (orbitsize>done_in_orbit))
+   {
+     if (allemaal_doubles_mogelijk(kleinste_orbit,orbitsize,marklist,&marklistend))
+       { trynextstep(); }
+     reset_doubles(kleinste_orbit,marklist,marklistend);
+   }
+}
+
+int connected(graph g[], int aantal_toppen)
+{
+  int i, list[MAXN], length, j;
+  graph reached, dummy;
+
+  reached=(graph)0;
+  ADDELEMENT(&reached,0);
+
+  list[0]=0; list[1]= -1;
+  length=1;
+
+  for (i=0; i<length; i++)
+    { dummy= g[list[i]] & ~reached;
+      reached |= g[list[i]];
+      FORALLELEMENTS(dummy,j)
+	{ list[length]=j; length++; }
+    }
+
+  if (reached==ALLMASK(aantal_toppen))
+    { return 1; }
+  else 
+    { return 0; }
+}
+
+int test_possible(graph globalg[],int globaldeg[], int n, int m, int min_direct_deg)
+     /* Test of sommige deelgrafen aan |E|<= min_direct_deg*aantal_toppen voldoet.
+
+	Geeft 1 terug als er misschien een manier bestaat om de bogen een richting 
+	toe te kennen en 0 als zo'n manier zeker niet bestaat.
+
+     */
+
+{
+  graph g[MAXN];
+  int deg[MAXN];
+  int i,j, removed, grens, top, m0;
+  int *runp, *endp;
+  int list[2*MAXN]; /* de lijst van toppen. In het begin staan ze er allemaal in. Als er een top al bekeken is
+		       en dan word de graad min_direct_deg word hij er opnieuw toegevoegd -- maar dat kan
+		       maar 1 keer gebeuren. 
+		       Het probleem is te voorkomen dat een top 2 keer in het gedeelte van de lijst staat
+		       waaraan nog gewerkt wordt. Dan kan het gebeuren dat de top 2 keer verwijderd word.
+
+		    */
+
+  grens=n*min_direct_deg;
+
+  if (aantal_bogen>grens) return 0;
+
+  memcpy(g,globalg,n*sizeof(graph));
+  memcpy(deg,globaldeg,n*sizeof(int));
+
+  for (i=0; i<n; i++) list[i]=i;
+
+  removed=0;
+  for (runp=list, endp=list+n; runp<endp; runp++)
+    { top=*runp;
+      if (deg[top]<=min_direct_deg)
+      { 
+	grens-=min_direct_deg;
+	m-=deg[top];
+	deg[top]=0;
+	removed=1;
+	if (m>grens) { return 0; }
+        FORALLELEMENTS(g[top],j)
+	  { 
+	    DELELEMENT(g+j,top);
+	    deg[j]--;
+	    /* top<i betekent: de eerste keer dat hij in de lijst stond was al vroeger. En en tweede keer
+	       kan de top er nog niet staan omdat de volgende voorwaarde deg[j]==min_direct_deg garandeerd 
+	       dat de graad net voldoende gedaald is */
+	    if ((top<(runp-list)) && (deg[j]==min_direct_deg)) { *endp=j; endp++; }
+	  }
+      }
+    }
+
+
+  if (connected(globalg, n) && (!removed)) return 1;
+
+  /* Nu met BFS kijken of er een componente met te veel bogen is: */
+
+  RESETMARKS
+
+  for (i=0;i<n;i++) 
+    if (UNMARKED(i) && deg[i])
+      { m0=deg[i];
+	list[0]=i;
+	MARK(i);
+	for (runp=list, endp=list+1; runp<endp; runp++)
+	  { top=*runp;
+	  FORALLELEMENTS(g[top],j) 
+	    { if (UNMARKED(j))
+	      { MARK(j);
+	        m0+=deg[j];
+		*endp=j;
+		endp++;
+	      }
+	    }
+	  }
+	if (min_direct_deg*(endp-list)*2<m0) { return 0;}
+      }
+
+
+  return 1;
+}
+
+
+
+void waterclusters (graph g[], int n)
+{ 
+  int i, j, k, orbitsize, start, end, fixed_edge, dummy, maxgraphdeg, biggest_orbit;
+  BOOG kleinste_orbit[MAX_BOGEN+1];  /* het is mogelijk dat er maar 1 orbit is */
+  BOOG al_gericht[MAX_BOGEN+1];
+  int inorbit[MAXN][MAXN], numberinorbit[MAXN];
+  //static int counter=0;
+
+  init_waterplugin(n);
+
+  if (n<3) { fprintf(stderr,"Come on -- start with at least 3 vertices! \n"); exit(0); }
+
+  memcpy(workg,g,n*sizeof(graph));
+
+  aantal_toppen=n;
+
+  for (i=0;i<aantal_toppen;i++) {indeg_free[i]=maxindeg; outdeg_free[i]=maxoutdeg;
+                                 virtual_indeg[i]=virtual_outdeg[i]=0; }
+
+  number_of_generators=0;
+  nauty(staticg,bufferlab,bufferptn,NILSET,orbits,&options,&stats,workspace,100*MAXN,1,n,NULL);
+  group_up_to_date=1;
+
+  maxgraphdeg=0;
+  for (i=aantal_bogen=0; i<n ; i++) { deg[i]=POPCOUNT(g[i]); if (deg[i]>maxgraphdeg) maxgraphdeg=deg[i];
+                                      aantal_bogen+=deg[i]; }
+  aantal_bogen /= 2;
+
+   /* als maxindeg==maxoutdeg is gegarandeerd dat voor elke graaf die gegenereerd word ook een manier
+     bestaat om richtingen toe te kennen zonder de voorwaarden te schenden */
+  if (maxgraphdeg>2*mingerichtdeg) 
+    { if (test_possible(g,deg,n,aantal_bogen,mingerichtdeg)==0) return; }
+
+  //if ((maxgraphdeg<=maxindeg) && (maxgraphdeg<=maxoutdeg)) nodegbound=1; else nodegbound=0;
+
+  if (aantal_bogen==0) { addnumber=1; MAYBEPROCESS; WRITEUP(); return; }
+
+  if (double_allowed) 
+    max_doubles=remaining_doubles=watermaxedges-aantal_bogen; else max_doubles=remaining_doubles=0;
+  if (remaining_doubles)
+    { /* deg[i] is altijd <= maxindeg+maxoutdeg */
+      for (i=0;i<aantal_toppen;i++) double_free[i]=watermaxdeg-deg[i];
+    }
+  else 
+    for (i=0;i<aantal_toppen;i++) double_free[i]=0;
+
+  nextstep_depth=0;
+
+  if (stats.numorbits!=n)
+    { fill_edgelist_edgeorb();
+      get_orbit_first(kleinste_orbit,&orbitsize,&fixed_edge,&biggest_orbit); 
+    }
+
+  /* Now is (orbitsize==0) if the group acts trivially on edges 
+     -- only interesting in case of disconnected graphs */
+
+  if ((stats.numorbits==n) || (orbitsize==0)) /* trviale groep */
+    { aantal_grafen_met_triv_group++; 
+      fill_edgelist_edgeorb_order();
+      laatstepositie=edgelist+aantal_bogen-1;
+      if (maxoutdeg==maxindeg) /* then every valid graph for one direction is also valid with
+				  the directions reversed */
+	{
+	  addnumber=2;
+	  start=edgelist[0][0]; end=edgelist[0][1];
+	  /* is_gericht[][] isn't used in the directing routine */
+	  (outdeg_free[start])--; (indeg_free[end])--;
+	  //virtual_outdeg[start]++; virtual_indeg[end]++;
+	  DELELEMENT(workg+end,start);
+	  aantal_gerichte_bogen=1;
+	  trivlabels_init(edgelist+1);
+	  aantal_gerichte_bogen=0;
+	  ADDELEMENT(workg+end,start);
+	  (outdeg_free[start])++; (indeg_free[end])++;
+
+	  if (remaining_doubles && double_free[start] && double_free[end])
+	    {
+	      addnumber=1; 
+	      (outdeg_free[start])--; (indeg_free[end])--;
+	      (outdeg_free[end])--; (indeg_free[start])--;
+	      double_free[start]--; double_free[end]--;
+	      aantal_gerichte_bogen=1;
+	      remaining_doubles--;
+	      trivlabels_init(edgelist+1);
+	      remaining_doubles++;
+	      double_free[start]++; double_free[end]++;
+	      (outdeg_free[start])++; (indeg_free[end])++;
+	      (outdeg_free[end])++; (indeg_free[start])++;
+	      aantal_gerichte_bogen=0;
+	    }
+	}
+      else
+	{
+	  addnumber=1;
+	  aantal_gerichte_bogen=0;
+	  trivlabels_init(edgelist);
+	  aantal_gerichte_bogen=0;
+	}
+      return;
+    }
+  /* else: de groep is jammer genoeg niet triviaal */
+
+
+  /* first: write good beginning colours for nauty */
+  memcpy(colour[0],orbits,aantal_toppen*sizeof(nvector));
+  for (i=0;i<aantal_toppen;i++) numberinorbit[i]=0;
+  for (i=0;i<aantal_toppen;i++) { dummy=orbits[i]; 
+                                  inorbit[dummy][numberinorbit[dummy]]=i;
+				  (numberinorbit[dummy])++;
+                                }
+  for (i=k=0;i<aantal_toppen;i++) 
+    { for (j=0;j<numberinorbit[i]-1; j++) { ptn[0][k]=1; lab[0][k]=inorbit[i][j]; k++; } 
+      if (numberinorbit[i]) { ptn[0][k]=0; lab[0][k]=inorbit[i][j]; k++; }
+    }
+
+  /* else */
+  if ((fixed_edge<0)|| (maxindeg!=maxoutdeg)) 
+    { addnumber=1; nontrivlabels(kleinste_orbit,0,orbitsize,al_gericht, biggest_orbit); return; }
+  /* else */
+  /* one edge can already be directed -- but because it is fixed anyway, the group is still correct. */
+
+  addnumber=2;
+  start=edgelist[fixed_edge][0]; end=edgelist[fixed_edge][1];
+  (outdeg_free[start])--; (indeg_free[end])--;
+  virtual_outdeg[start]++; virtual_indeg[end]++;
+  saturated[start]=saturated[end]=1;
+  is_gericht[start][end]=is_gericht[end][start]=1;
+  DELELEMENT(workg+end,start);
+  aantal_gerichte_bogen=1;
+  nontrivlabels(kleinste_orbit,0,orbitsize,al_gericht, biggest_orbit);
+  aantal_gerichte_bogen=0;
+  ADDELEMENT(workg+end,start);
+  is_gericht[start][end]=is_gericht[end][start]=0;
+  virtual_outdeg[start]--; virtual_indeg[end]--;
+  (outdeg_free[start])++; (indeg_free[end])++;
+  saturated[start]=saturated[end]=0; 
+
+  if (remaining_doubles && double_free[start] && double_free[end])
+    { 
+      addnumber=1;
+      (outdeg_free[start])--; (indeg_free[end])--;
+      (outdeg_free[end])--; (indeg_free[start])--;
+      double_free[start]--; double_free[end]--;
+      virtual_outdeg[start]++; virtual_outdeg[end]++;
+      virtual_indeg[start]++; virtual_indeg[end]++;
+      saturated[start]=saturated[end]=2;
+      is_gericht[start][end]=is_gericht[end][start]=1;
+      aantal_gerichte_bogen=1;
+      remaining_doubles--;
+      nontrivlabels(kleinste_orbit,0,orbitsize,al_gericht, biggest_orbit);
+      remaining_doubles++;
+      aantal_gerichte_bogen=0;
+      is_gericht[start][end]=is_gericht[end][start]=0;
+      double_free[start]++; double_free[end]++;
+      virtual_outdeg[start]--; virtual_outdeg[end]--;
+      virtual_indeg[start]--; virtual_indeg[end]--;
+      (outdeg_free[start])++; (indeg_free[end])++;
+      (outdeg_free[end])++; (indeg_free[start])++;
+      saturated[start]=saturated[end]=0; 
+    }
+
+
+  return;
+}
+
+
+
+
+
+
+
+
+/******************************DIRECT_EDGES********************************/
+
+void direct_edges(void) /* graph workg[] and int aantal_toppen, aantal_bogen are global */
+
+{ int i, maxedges, minrestriction, maxdeg, free_vertices, maxgraphdeg, regular;
+
+  regular=1;
+  for (i=maxgraphdeg=0; i<aantal_toppen; i++)
+    { if (deg[i]>maxgraphdeg) maxgraphdeg=deg[i];
+      if (deg[i]!=deg[0]) regular=0;
+    }
+
+  if ((maxgraphdeg<=maxindeg) && (maxgraphdeg<=maxoutdeg)) nodegbound=1; else nodegbound=0;
+
+  if (maxindeg<=maxoutdeg) { maxedges=aantal_toppen*maxindeg; minrestriction=maxindeg;}
+  else { maxedges=aantal_toppen*maxoutdeg; minrestriction=maxoutdeg; }
+
+  if (maxedges<aantal_bogen) return;
+ /* grafen met meer bogen kunnen niet gericht worden, zodat ze nog aan de 
+    voorwaarden voldoen */
+
+  maxdeg=maxindeg+maxoutdeg;
+  if (!nodegbound)
+    {
+      for (i=free_vertices=0;i<aantal_toppen;i++) 
+	{ if (deg[i]>maxdeg) return;
+	  if (deg[i]<maxdeg) free_vertices++;
+	}
+    }
+  else free_vertices=aantal_toppen;
+
+  group_up_to_date=0;
+
+  // when to use what is just some heuristic -- a more elaborate one could be helpful
+    if ((!regular) &&
+	(nodegbound || (maxindeg<=2 && maxoutdeg<=2) || (free_vertices>((2*aantal_toppen)/3))))
+    { //waterclusteruse++; 
+      waterclusters (staticg, aantal_toppen); return; }
+
+  //water_v_use++;
+
+  memcpy(workg,staticg,sizeof(graph)*aantal_toppen);
+
+  for (i=0; i<aantal_toppen; i++) 
+    { indeg[i]=outdeg[i]=0;
+      if (double_allowed) 
+	{ double_free[i]=maxdirectdeg-deg[i];
+	  if (minrestriction<double_free[i]) double_free[i]=minrestriction;
+	}
+      else double_free[i]=0;
+    }
+
+  aantal_gerichte_bogen=0;
+
+  if (double_allowed) 
+    max_doubles=remaining_doubles=maxedges-aantal_bogen; else max_doubles=remaining_doubles=0;
+
+
+  number_of_generators=0;
+  nauty(workg,bufferlab,bufferptn,NILSET,orbits,&options,&stats,workspace,100*MAXN,1,aantal_toppen,NULL);
+
+  if (stats.numorbits==aantal_toppen) 
+    { 
+      direct_all_triv();
+    }
+  else 
+    { 
+      for (i=0; i<aantal_toppen; i++) { tobedirected[i]=deg[i]; }
+
+      direct_all_nontriv(); }
+
+
+  return;
+
+}
+
+void init_allocated_fields()
+{
+  int i;
+
+  size_root=1000; root_op=malloc((size_t)size_root*sizeof(int)); 
+  if (root_op==NULL) 
+    { fprintf(stderr,"Can't allocate %d items for root_op in the beginning -- exiting.\n",size_root);
+      exit(0); }
+
+
+  operations=malloc((size_t)4096);
+  if (operations==NULL) 
+    { fprintf(stderr,"Can't allocate initial memory for operations -- exiting\n"); 
+      exit(1); }
+  size_operations=4096;
+
+  for (i=0; i<MAXN; i++)
+    {
+      remember_operations[i]=malloc((size_t)4096);
+      if (remember_operations[i]==NULL) 
+	{ fprintf(stderr,"Can't allocate initial memory for operations -- exiting\n"); 
+	  exit(1); }
+      remember_size[i]=4096;
+    }
+  return;
+}
+
+
+
+/******************************MAIN********************************/
+
+int main(int argc, char *argv[])
+
+// reads from stdin 
+{ 
+
+  int i, m, zaehlen=0;
+  unsigned char *code=NULL;
+  int codelaenge;
+  int multicode=0, g6code=1;
+  long long int last=0LL;
+
+  if (sizeof(long long int)<8) 
+    { 
+      fprintf(stderr,"This may cause problems with the hashing function for large degree -- exit().\n");
+      exit(1); 
+    }
+
+  for (i=1; i<argc; i++)
+    {
+      if (argv[i][0]=='i') maxindeg=atoi(argv[i]+1);
+      else  if (argv[i][0]=='o') maxoutdeg=atoi(argv[i]+1);
+      else  if (argv[i][0]=='T') direct_output=1; 
+	else  if (argv[i][0]=='C') direct_output=2;
+	  else  if (argv[i][0]=='B') direct_output=3;
+	    else  if (argv[i][0]=='S') double_allowed=0;
+	      else  if (argv[i][0]=='m') { g6code=0; multicode=1; }
+      else usage(argv[0]);
+    }
+
+#ifdef PROCESS
+  if (direct_output==0) direct_output=2;
+#endif
+
+  init_allocated_fields();
+
+  //if (maxindeg==MAXN && maxoutdeg==MAXN) nodegbound=1; else nodegbound=0;
+  // wordt in direct_edges individueel vastgelegd
+  maxdirectdeg=maxindeg+maxoutdeg;
+
+  init_nauty_options();
+
+  while((g6code && (readg(stdin,staticg,1,&m,&aantal_toppen) != NULL)) ||
+	(multicode && (lese_multicode(&code, &codelaenge, stdin) != EOF)))
+    { 
+      zaehlen++; 
+#ifdef PROCESS
+      dg_nin = zaehlen;
+#endif
+
+      if (aantal_toppen>=MAXN)
+	{ fprintf(stderr,"At most %d vertices possible -- exiting.\n",MAXN-1);
+	  exit(1); }
+
+      if (multicode) decode_to_nauty(code,codelaenge,staticg,deg);
+      else /* g6code */ init_for_g6(staticg,aantal_toppen,deg);
+
+      // direct_edges(staticg, aantal_toppen);
+      direct_edges();   // BDM
+      last=aantal_gerichte_grafen;
+
+
+
+  }
+
+  fprintf(stderr,"Number of directed graphs: %lld \n",aantal_gerichte_grafen);
+#ifdef SUMMARY
+  SUMMARY();
+#endif
+
+  //fprintf(stderr,"Used edge routines %u times.\n",waterclusteruse);
+  //fprintf(stderr,"Used vertex routines %u times.\n",water_v_use);
+
+  return 0;
+}
diff --git a/lib/parallel_hashmap/parallel_hashmap/btree.h b/lib/parallel_hashmap/parallel_hashmap/btree.h
new file mode 100644
index 0000000..7c73162
--- /dev/null
+++ b/lib/parallel_hashmap/parallel_hashmap/btree.h
@@ -0,0 +1,4050 @@
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Includes work from abseil-cpp (https://github.com/abseil/abseil-cpp)
+// with modifications.
+//
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ---------------------------------------------------------------------------
+
+#ifndef PHMAP_BTREE_BTREE_CONTAINER_H_
+#define PHMAP_BTREE_BTREE_CONTAINER_H_
+
+#ifdef _MSC_VER
+    #pragma warning(push)  
+
+    #pragma warning(disable : 4127) // conditional expression is constant
+    #pragma warning(disable : 4324) // structure was padded due to alignment specifier
+    #pragma warning(disable : 4355) // 'this': used in base member initializer list
+    #pragma warning(disable : 4365) // conversion from 'int' to 'const unsigned __int64', signed/unsigned mismatch
+    #pragma warning(disable : 4514) // unreferenced inline function has been removed
+    #pragma warning(disable : 4623) // default constructor was implicitly defined as deleted
+    #pragma warning(disable : 4625) // copy constructor was implicitly defined as deleted
+    #pragma warning(disable : 4626) // assignment operator was implicitly defined as deleted
+    #pragma warning(disable : 4710) // function not inlined
+    #pragma warning(disable : 4711) //  selected for automatic inline expansion
+    #pragma warning(disable : 4820) // '6' bytes padding added after data member
+    #pragma warning(disable : 4868) // compiler may not enforce left-to-right evaluation order in braced initializer list
+    #pragma warning(disable : 5026) // move constructor was implicitly defined as deleted
+    #pragma warning(disable : 5027) // move assignment operator was implicitly defined as deleted
+    #pragma warning(disable : 5045) // Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified
+#endif
+
+
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <limits>
+#include <new>
+
+#include "phmap_fwd_decl.h"
+#include "phmap_base.h"
+
+#if PHMAP_HAVE_STD_STRING_VIEW
+    #include <string_view>
+#endif
+
+// MSVC constructibility traits do not detect destructor properties and so our
+// implementations should not use them as a source-of-truth.
+#if defined(_MSC_VER) && !defined(__clang__) && !defined(__GNUC__)
+    #define PHMAP_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION 1
+#endif
+
+namespace phmap {
+
+    // Defined and documented later on in this file.
+    template <typename T>
+    struct is_trivially_destructible;
+
+    // Defined and documented later on in this file.
+    template <typename T>
+    struct is_trivially_move_assignable;
+
+    namespace type_traits_internal {
+
+        // Silence MSVC warnings about the destructor being defined as deleted.
+#if defined(_MSC_VER) && !defined(__GNUC__)
+    #pragma warning(push)
+    #pragma warning(disable : 4624)
+#endif  // defined(_MSC_VER) && !defined(__GNUC__)
+
+        template <class T>
+        union SingleMemberUnion {
+            T t;
+        };
+
+        // Restore the state of the destructor warning that was silenced above.
+#if defined(_MSC_VER) && !defined(__GNUC__)
+    #pragma warning(pop)
+#endif  // defined(_MSC_VER) && !defined(__GNUC__)
+
+        template <class T>
+        struct IsTriviallyMoveConstructibleObject
+            : std::integral_constant<
+            bool, std::is_move_constructible<
+                      type_traits_internal::SingleMemberUnion<T>>::value &&
+            phmap::is_trivially_destructible<T>::value> {};
+
+        template <class T>
+        struct IsTriviallyCopyConstructibleObject
+            : std::integral_constant<
+            bool, std::is_copy_constructible<
+                      type_traits_internal::SingleMemberUnion<T>>::value &&
+            phmap::is_trivially_destructible<T>::value> {};
+
+        template <class T>
+        struct IsTriviallyMoveAssignableReference : std::false_type {};
+
+        template <class T>
+        struct IsTriviallyMoveAssignableReference<T&>
+            : phmap::is_trivially_move_assignable<T>::type {};
+
+        template <class T>
+        struct IsTriviallyMoveAssignableReference<T&&>
+            : phmap::is_trivially_move_assignable<T>::type {};
+
+    }  // namespace type_traits_internal
+
+
+    template <typename... Ts>
+    using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type;
+
+
+    template <typename T>
+    struct is_function
+        : std::integral_constant<
+        bool, !(std::is_reference<T>::value ||
+                std::is_const<typename std::add_const<T>::type>::value)> {};
+
+
+    namespace type_traits_internal {
+
+        template <typename T>
+        class is_trivially_copyable_impl {
+            using ExtentsRemoved = typename std::remove_all_extents<T>::type;
+            static constexpr bool kIsCopyOrMoveConstructible =
+                std::is_copy_constructible<ExtentsRemoved>::value ||
+                std::is_move_constructible<ExtentsRemoved>::value;
+            static constexpr bool kIsCopyOrMoveAssignable =
+                phmap::is_copy_assignable<ExtentsRemoved>::value ||
+                phmap::is_move_assignable<ExtentsRemoved>::value;
+
+        public:
+            static constexpr bool kValue =
+                (__has_trivial_copy(ExtentsRemoved) || !kIsCopyOrMoveConstructible) &&
+                (__has_trivial_assign(ExtentsRemoved) || !kIsCopyOrMoveAssignable) &&
+                (kIsCopyOrMoveConstructible || kIsCopyOrMoveAssignable) &&
+                is_trivially_destructible<ExtentsRemoved>::value &&
+                // We need to check for this explicitly because otherwise we'll say
+                // references are trivial copyable when compiled by MSVC.
+                !std::is_reference<ExtentsRemoved>::value;
+        };
+
+        template <typename T>
+        struct is_trivially_copyable
+            : std::integral_constant<
+            bool, type_traits_internal::is_trivially_copyable_impl<T>::kValue> {};
+    }  // namespace type_traits_internal
+
+    namespace swap_internal {
+
+        // Necessary for the traits.
+        using std::swap;
+
+        // This declaration prevents global `swap` and `phmap::swap` overloads from being
+        // considered unless ADL picks them up.
+        void swap();
+
+        template <class T>
+        using IsSwappableImpl = decltype(swap(std::declval<T&>(), std::declval<T&>()));
+
+        // NOTE: This dance with the default template parameter is for MSVC.
+        template <class T,
+                  class IsNoexcept = std::integral_constant<
+                      bool, noexcept(swap(std::declval<T&>(), std::declval<T&>()))>>
+            using IsNothrowSwappableImpl = typename std::enable_if<IsNoexcept::value>::type;
+
+        template <class T>
+        struct IsSwappable
+            : phmap::type_traits_internal::is_detected<IsSwappableImpl, T> {};
+
+        template <class T>
+        struct IsNothrowSwappable
+            : phmap::type_traits_internal::is_detected<IsNothrowSwappableImpl, T> {};
+
+        template <class T, phmap::enable_if_t<IsSwappable<T>::value, int> = 0>
+        void Swap(T& lhs, T& rhs) noexcept(IsNothrowSwappable<T>::value) {
+            swap(lhs, rhs);
+        }
+
+       using StdSwapIsUnconstrained = IsSwappable<void()>;
+
+    }  // namespace swap_internal
+
+    namespace type_traits_internal {
+
+        // Make the swap-related traits/function accessible from this namespace.
+        using swap_internal::IsNothrowSwappable;
+        using swap_internal::IsSwappable;
+        using swap_internal::Swap;
+        using swap_internal::StdSwapIsUnconstrained;
+
+    }  // namespace type_traits_internal
+
+    namespace compare_internal {
+
+        using value_type = int8_t;
+
+        template <typename T>
+        struct Fail {
+            static_assert(sizeof(T) < 0, "Only literal `0` is allowed.");
+        };
+
+        template <typename NullPtrT = std::nullptr_t>
+        struct OnlyLiteralZero {
+            constexpr OnlyLiteralZero(NullPtrT) noexcept {}  // NOLINT
+
+            template <
+                typename T,
+                typename = typename std::enable_if<
+                    std::is_same<T, std::nullptr_t>::value ||
+                    (std::is_integral<T>::value && !std::is_same<T, int>::value)>::type,
+                typename = typename Fail<T>::type>
+                OnlyLiteralZero(T);  // NOLINT
+        };
+
+        enum class eq : value_type {
+            equal = 0,
+                equivalent = equal,
+                nonequal = 1,
+                nonequivalent = nonequal,
+                };
+
+        enum class ord : value_type { less = -1, greater = 1 };
+
+        enum class ncmp : value_type { unordered = -127 };
+
+#ifdef __cpp_inline_variables
+
+#define PHMAP_COMPARE_INLINE_BASECLASS_DECL(name)
+
+#define PHMAP_COMPARE_INLINE_SUBCLASS_DECL(type, name)  \
+        static const type name;
+
+#define PHMAP_COMPARE_INLINE_INIT(type, name, init) \
+        inline constexpr type type::name(init)
+
+#else  // __cpp_inline_variables
+
+#define PHMAP_COMPARE_INLINE_BASECLASS_DECL(name)   \
+        static const T name;
+
+#define PHMAP_COMPARE_INLINE_SUBCLASS_DECL(type, name)
+
+#define PHMAP_COMPARE_INLINE_INIT(type, name, init)             \
+        template <typename T>                                   \
+        const T compare_internal::type##_base<T>::name(init)
+
+#endif  // __cpp_inline_variables
+
+        // These template base classes allow for defining the values of the constants
+        // in the header file (for performance) without using inline variables (which
+        // aren't available in C++11).
+        template <typename T>
+        struct weak_equality_base {
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(equivalent)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(nonequivalent)
+        };
+
+        template <typename T>
+        struct strong_equality_base {
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(equal)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(nonequal)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(equivalent)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(nonequivalent)
+        };
+
+        template <typename T>
+        struct partial_ordering_base {
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(less)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(equivalent)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(greater)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(unordered)
+        };
+
+        template <typename T>
+        struct weak_ordering_base {
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(less)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(equivalent)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(greater)
+        };
+
+        template <typename T>
+        struct strong_ordering_base {
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(less)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(equal)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(equivalent)
+            PHMAP_COMPARE_INLINE_BASECLASS_DECL(greater)
+        };
+
+    }  // namespace compare_internal
+
+    class weak_equality
+        : public compare_internal::weak_equality_base<weak_equality> {
+        explicit constexpr weak_equality(compare_internal::eq v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        friend struct compare_internal::weak_equality_base<weak_equality>;
+
+    public:
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(weak_equality, equivalent)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(weak_equality, nonequivalent)
+
+        // Comparisons
+        friend constexpr bool operator==(
+            weak_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ == 0;
+        }
+        friend constexpr bool operator!=(
+            weak_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ != 0;
+        }
+        friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
+                                         weak_equality v) noexcept {
+            return 0 == v.value_;
+        }
+        friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
+                                         weak_equality v) noexcept {
+            return 0 != v.value_;
+        }
+
+    private:
+        compare_internal::value_type value_;
+    };
+    PHMAP_COMPARE_INLINE_INIT(weak_equality, equivalent,
+                              compare_internal::eq::equivalent);
+    PHMAP_COMPARE_INLINE_INIT(weak_equality, nonequivalent,
+                              compare_internal::eq::nonequivalent);
+
+    class strong_equality
+        : public compare_internal::strong_equality_base<strong_equality> {
+        explicit constexpr strong_equality(compare_internal::eq v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        friend struct compare_internal::strong_equality_base<strong_equality>;
+
+    public:
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, equal)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, nonequal)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, equivalent)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, nonequivalent)
+
+        // Conversion
+        constexpr operator weak_equality() const noexcept {  // NOLINT
+            return value_ == 0 ? weak_equality::equivalent
+                : weak_equality::nonequivalent;
+        }
+        // Comparisons
+        friend constexpr bool operator==(
+            strong_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ == 0;
+        }
+        friend constexpr bool operator!=(
+            strong_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ != 0;
+        }
+        friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
+                                         strong_equality v) noexcept {
+            return 0 == v.value_;
+        }
+        friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
+                                         strong_equality v) noexcept {
+            return 0 != v.value_;
+        }
+
+    private:
+        compare_internal::value_type value_;
+    };
+
+    PHMAP_COMPARE_INLINE_INIT(strong_equality, equal, compare_internal::eq::equal);
+    PHMAP_COMPARE_INLINE_INIT(strong_equality, nonequal,
+                              compare_internal::eq::nonequal);
+    PHMAP_COMPARE_INLINE_INIT(strong_equality, equivalent,
+                              compare_internal::eq::equivalent);
+    PHMAP_COMPARE_INLINE_INIT(strong_equality, nonequivalent,
+                              compare_internal::eq::nonequivalent);
+
+    class partial_ordering
+        : public compare_internal::partial_ordering_base<partial_ordering> {
+        explicit constexpr partial_ordering(compare_internal::eq v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        explicit constexpr partial_ordering(compare_internal::ord v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        explicit constexpr partial_ordering(compare_internal::ncmp v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        friend struct compare_internal::partial_ordering_base<partial_ordering>;
+
+        constexpr bool is_ordered() const noexcept {
+            return value_ !=
+                compare_internal::value_type(compare_internal::ncmp::unordered);
+        }
+
+    public:
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, less)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, equivalent)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, greater)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, unordered)
+
+        // Conversion
+        constexpr operator weak_equality() const noexcept {  // NOLINT
+            return value_ == 0 ? weak_equality::equivalent
+                : weak_equality::nonequivalent;
+        }
+        // Comparisons
+        friend constexpr bool operator==(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.is_ordered() && v.value_ == 0;
+        }
+        friend constexpr bool operator!=(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return !v.is_ordered() || v.value_ != 0;
+        }
+        friend constexpr bool operator<(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.is_ordered() && v.value_ < 0;
+        }
+        friend constexpr bool operator<=(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.is_ordered() && v.value_ <= 0;
+        }
+        friend constexpr bool operator>(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.is_ordered() && v.value_ > 0;
+        }
+        friend constexpr bool operator>=(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.is_ordered() && v.value_ >= 0;
+        }
+        friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
+                                         partial_ordering v) noexcept {
+            return v.is_ordered() && 0 == v.value_;
+        }
+        friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
+                                         partial_ordering v) noexcept {
+            return !v.is_ordered() || 0 != v.value_;
+        }
+        friend constexpr bool operator<(compare_internal::OnlyLiteralZero<>,
+                                        partial_ordering v) noexcept {
+            return v.is_ordered() && 0 < v.value_;
+        }
+        friend constexpr bool operator<=(compare_internal::OnlyLiteralZero<>,
+                                         partial_ordering v) noexcept {
+            return v.is_ordered() && 0 <= v.value_;
+        }
+        friend constexpr bool operator>(compare_internal::OnlyLiteralZero<>,
+                                        partial_ordering v) noexcept {
+            return v.is_ordered() && 0 > v.value_;
+        }
+        friend constexpr bool operator>=(compare_internal::OnlyLiteralZero<>,
+                                         partial_ordering v) noexcept {
+            return v.is_ordered() && 0 >= v.value_;
+        }
+
+    private:
+        compare_internal::value_type value_;
+    };
+
+    PHMAP_COMPARE_INLINE_INIT(partial_ordering, less, compare_internal::ord::less);
+    PHMAP_COMPARE_INLINE_INIT(partial_ordering, equivalent,
+                              compare_internal::eq::equivalent);
+    PHMAP_COMPARE_INLINE_INIT(partial_ordering, greater,
+                              compare_internal::ord::greater);
+    PHMAP_COMPARE_INLINE_INIT(partial_ordering, unordered,
+                              compare_internal::ncmp::unordered);
+
+    class weak_ordering
+        : public compare_internal::weak_ordering_base<weak_ordering> {
+        explicit constexpr weak_ordering(compare_internal::eq v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        explicit constexpr weak_ordering(compare_internal::ord v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        friend struct compare_internal::weak_ordering_base<weak_ordering>;
+
+    public:
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, less)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, equivalent)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, greater)
+
+        // Conversions
+        constexpr operator weak_equality() const noexcept {  // NOLINT
+            return value_ == 0 ? weak_equality::equivalent
+                : weak_equality::nonequivalent;
+        }
+        constexpr operator partial_ordering() const noexcept {  // NOLINT
+            return value_ == 0 ? partial_ordering::equivalent
+                : (value_ < 0 ? partial_ordering::less
+                   : partial_ordering::greater);
+        }
+        // Comparisons
+        friend constexpr bool operator==(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ == 0;
+        }
+        friend constexpr bool operator!=(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ != 0;
+        }
+        friend constexpr bool operator<(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ < 0;
+        }
+        friend constexpr bool operator<=(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ <= 0;
+        }
+        friend constexpr bool operator>(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ > 0;
+        }
+        friend constexpr bool operator>=(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ >= 0;
+        }
+        friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
+                                         weak_ordering v) noexcept {
+            return 0 == v.value_;
+        }
+        friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
+                                         weak_ordering v) noexcept {
+            return 0 != v.value_;
+        }
+        friend constexpr bool operator<(compare_internal::OnlyLiteralZero<>,
+                                        weak_ordering v) noexcept {
+            return 0 < v.value_;
+        }
+        friend constexpr bool operator<=(compare_internal::OnlyLiteralZero<>,
+                                         weak_ordering v) noexcept {
+            return 0 <= v.value_;
+        }
+        friend constexpr bool operator>(compare_internal::OnlyLiteralZero<>,
+                                        weak_ordering v) noexcept {
+            return 0 > v.value_;
+        }
+        friend constexpr bool operator>=(compare_internal::OnlyLiteralZero<>,
+                                         weak_ordering v) noexcept {
+            return 0 >= v.value_;
+        }
+
+    private:
+        compare_internal::value_type value_;
+    };
+
+    PHMAP_COMPARE_INLINE_INIT(weak_ordering, less, compare_internal::ord::less);
+    PHMAP_COMPARE_INLINE_INIT(weak_ordering, equivalent,
+                              compare_internal::eq::equivalent);
+    PHMAP_COMPARE_INLINE_INIT(weak_ordering, greater,
+                              compare_internal::ord::greater);
+
+    class strong_ordering
+        : public compare_internal::strong_ordering_base<strong_ordering> {
+        explicit constexpr strong_ordering(compare_internal::eq v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        explicit constexpr strong_ordering(compare_internal::ord v) noexcept
+            : value_(static_cast<compare_internal::value_type>(v)) {}
+        friend struct compare_internal::strong_ordering_base<strong_ordering>;
+
+    public:
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, less)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equal)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equivalent)
+        PHMAP_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, greater)
+
+        // Conversions
+        constexpr operator weak_equality() const noexcept {  // NOLINT
+            return value_ == 0 ? weak_equality::equivalent
+                : weak_equality::nonequivalent;
+        }
+        constexpr operator strong_equality() const noexcept {  // NOLINT
+            return value_ == 0 ? strong_equality::equal : strong_equality::nonequal;
+        }
+        constexpr operator partial_ordering() const noexcept {  // NOLINT
+            return value_ == 0 ? partial_ordering::equivalent
+                : (value_ < 0 ? partial_ordering::less
+                   : partial_ordering::greater);
+        }
+        constexpr operator weak_ordering() const noexcept {  // NOLINT
+            return value_ == 0
+                ? weak_ordering::equivalent
+                : (value_ < 0 ? weak_ordering::less : weak_ordering::greater);
+        }
+        // Comparisons
+        friend constexpr bool operator==(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ == 0;
+        }
+        friend constexpr bool operator!=(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ != 0;
+        }
+        friend constexpr bool operator<(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ < 0;
+        }
+        friend constexpr bool operator<=(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ <= 0;
+        }
+        friend constexpr bool operator>(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ > 0;
+        }
+        friend constexpr bool operator>=(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+            return v.value_ >= 0;
+        }
+        friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
+                                         strong_ordering v) noexcept {
+            return 0 == v.value_;
+        }
+        friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
+                                         strong_ordering v) noexcept {
+            return 0 != v.value_;
+        }
+        friend constexpr bool operator<(compare_internal::OnlyLiteralZero<>,
+                                        strong_ordering v) noexcept {
+            return 0 < v.value_;
+        }
+        friend constexpr bool operator<=(compare_internal::OnlyLiteralZero<>,
+                                         strong_ordering v) noexcept {
+            return 0 <= v.value_;
+        }
+        friend constexpr bool operator>(compare_internal::OnlyLiteralZero<>,
+                                        strong_ordering v) noexcept {
+            return 0 > v.value_;
+        }
+        friend constexpr bool operator>=(compare_internal::OnlyLiteralZero<>,
+                                         strong_ordering v) noexcept {
+            return 0 >= v.value_;
+        }
+
+    private:
+        compare_internal::value_type value_;
+    };
+    PHMAP_COMPARE_INLINE_INIT(strong_ordering, less, compare_internal::ord::less);
+    PHMAP_COMPARE_INLINE_INIT(strong_ordering, equal, compare_internal::eq::equal);
+    PHMAP_COMPARE_INLINE_INIT(strong_ordering, equivalent,
+                              compare_internal::eq::equivalent);
+    PHMAP_COMPARE_INLINE_INIT(strong_ordering, greater,
+                              compare_internal::ord::greater);
+
+#undef PHMAP_COMPARE_INLINE_BASECLASS_DECL
+#undef PHMAP_COMPARE_INLINE_SUBCLASS_DECL
+#undef PHMAP_COMPARE_INLINE_INIT
+
+    namespace compare_internal {
+        // We also provide these comparator adapter functions for internal phmap use.
+
+        // Helper functions to do a boolean comparison of two keys given a boolean
+        // or three-way comparator.
+        // SFINAE prevents implicit conversions to bool (such as from int).
+        template <typename BoolType,
+                  phmap::enable_if_t<std::is_same<bool, BoolType>::value, int> = 0>
+        constexpr bool compare_result_as_less_than(const BoolType r) { return r; }
+        constexpr bool compare_result_as_less_than(const phmap::weak_ordering r) {
+            return r < 0;
+        }
+
+        template <typename Compare, typename K, typename LK>
+        constexpr bool do_less_than_comparison(const Compare &compare, const K &x,
+                                               const LK &y) {
+            return compare_result_as_less_than(compare(x, y));
+        }
+
+        // Helper functions to do a three-way comparison of two keys given a boolean or
+        // three-way comparator.
+        // SFINAE prevents implicit conversions to int (such as from bool).
+        template <typename Int,
+                  phmap::enable_if_t<std::is_same<int, Int>::value, int> = 0>
+        constexpr phmap::weak_ordering compare_result_as_ordering(const Int c) {
+            return c < 0 ? phmap::weak_ordering::less
+                       : c == 0 ? phmap::weak_ordering::equivalent
+                       : phmap::weak_ordering::greater;
+        }
+        constexpr phmap::weak_ordering compare_result_as_ordering(
+            const phmap::weak_ordering c) {
+            return c;
+        }
+
+        template <
+            typename Compare, typename K, typename LK,
+            phmap::enable_if_t<!std::is_same<bool, phmap::invoke_result_t<
+                                                       Compare, const K &, const LK &>>::value,
+                               int> = 0>
+            constexpr phmap::weak_ordering do_three_way_comparison(const Compare &compare,
+                                                                   const K &x, const LK &y) {
+            return compare_result_as_ordering(compare(x, y));
+        }
+        template <
+            typename Compare, typename K, typename LK,
+            phmap::enable_if_t<std::is_same<bool, phmap::invoke_result_t<Compare,
+            const K &, const LK &>>::value,
+                               int> = 0>
+            constexpr phmap::weak_ordering do_three_way_comparison(const Compare &compare,
+                                                                   const K &x, const LK &y) {
+            return compare(x, y) ? phmap::weak_ordering::less
+                : compare(y, x) ? phmap::weak_ordering::greater
+                : phmap::weak_ordering::equivalent;
+        }
+
+    }  // namespace compare_internal
+}
+
+
+namespace phmap {
+
+namespace priv {
+
+    // A helper class that indicates if the Compare parameter is a key-compare-to
+    // comparator.
+    template <typename Compare, typename T>
+    using btree_is_key_compare_to =
+        std::is_convertible<phmap::invoke_result_t<Compare, const T &, const T &>,
+                            phmap::weak_ordering>;
+
+    struct StringBtreeDefaultLess {
+        using is_transparent = void;
+
+        StringBtreeDefaultLess() = default;
+
+        // Compatibility constructor.
+        StringBtreeDefaultLess(std::less<std::string>) {}       // NOLINT
+#if PHMAP_HAVE_STD_STRING_VIEW
+        StringBtreeDefaultLess(std::less<std::string_view>) {}  // NOLINT
+        StringBtreeDefaultLess(phmap::Less<std::string_view>) {}  // NOLINT
+
+        phmap::weak_ordering operator()(std::string_view lhs,
+                                        std::string_view rhs) const {
+            return compare_internal::compare_result_as_ordering(lhs.compare(rhs));
+        }
+#else
+        phmap::weak_ordering operator()(std::string lhs,
+                                        std::string rhs) const {
+            return compare_internal::compare_result_as_ordering(lhs.compare(rhs));
+        }
+#endif
+    };
+
+    struct StringBtreeDefaultGreater {
+        using is_transparent = void;
+
+        StringBtreeDefaultGreater() = default;
+
+        StringBtreeDefaultGreater(std::greater<std::string>) {}       // NOLINT
+#if PHMAP_HAVE_STD_STRING_VIEW
+        StringBtreeDefaultGreater(std::greater<std::string_view>) {}  // NOLINT
+
+        phmap::weak_ordering operator()(std::string_view lhs,
+                                        std::string_view rhs) const {
+            return compare_internal::compare_result_as_ordering(rhs.compare(lhs));
+        }
+#else
+        phmap::weak_ordering operator()(std::string lhs,
+                                        std::string rhs) const {
+            return compare_internal::compare_result_as_ordering(rhs.compare(lhs));
+        }
+#endif
+    };
+
+    // A helper class to convert a boolean comparison into a three-way "compare-to"
+    // comparison that returns a negative value to indicate less-than, zero to
+    // indicate equality and a positive value to indicate greater-than. This helper
+    // class is specialized for less<std::string>, greater<std::string>,
+    // less<std::string_view>, and greater<std::string_view>.
+    //
+    // key_compare_to_adapter is provided so that btree users
+    // automatically get the more efficient compare-to code when using common
+    // google string types with common comparison functors.
+    // These string-like specializations also turn on heterogeneous lookup by
+    // default.
+    template <typename Compare>
+    struct key_compare_to_adapter {
+        using type = Compare;
+    };
+
+    template <>
+    struct key_compare_to_adapter<std::less<std::string>> {
+        using type = StringBtreeDefaultLess;
+    };
+
+    template <>
+    struct key_compare_to_adapter<phmap::Less<std::string>> {
+        using type = StringBtreeDefaultLess;
+    };
+
+    template <>
+    struct key_compare_to_adapter<std::greater<std::string>> {
+        using type = StringBtreeDefaultGreater;
+    };
+
+#if PHMAP_HAVE_STD_STRING_VIEW
+    template <>
+    struct key_compare_to_adapter<std::less<std::string_view>> {
+        using type = StringBtreeDefaultLess;
+    };
+
+    template <>
+    struct key_compare_to_adapter<phmap::Less<std::string_view>> {
+        using type = StringBtreeDefaultLess;
+    };
+
+    template <>
+    struct key_compare_to_adapter<std::greater<std::string_view>> {
+        using type = StringBtreeDefaultGreater;
+    };
+#endif
+
+    template <typename Key, typename Compare, typename Alloc, int TargetNodeSize,
+              bool Multi, typename SlotPolicy>
+    struct common_params {
+        // If Compare is a common comparator for a std::string-like type, then we adapt it
+        // to use heterogeneous lookup and to be a key-compare-to comparator.
+        using key_compare = typename key_compare_to_adapter<Compare>::type;
+        // A type which indicates if we have a key-compare-to functor or a plain old
+        // key-compare functor.
+        using is_key_compare_to = btree_is_key_compare_to<key_compare, Key>;
+
+        using allocator_type = Alloc;
+        using key_type = Key;
+        using size_type = std::make_signed<size_t>::type;
+        using difference_type = ptrdiff_t;
+
+        // True if this is a multiset or multimap.
+        using is_multi_container = std::integral_constant<bool, Multi>;
+
+        using slot_policy = SlotPolicy;
+        using slot_type = typename slot_policy::slot_type;
+        using value_type = typename slot_policy::value_type;
+        using init_type = typename slot_policy::mutable_value_type;
+        using pointer = value_type *;
+        using const_pointer = const value_type *;
+        using reference = value_type &;
+        using const_reference = const value_type &;
+
+        enum {
+            kTargetNodeSize = TargetNodeSize,
+
+            // Upper bound for the available space for values. This is largest for leaf
+            // nodes, which have overhead of at least a pointer + 4 bytes (for storing
+            // 3 field_types and an enum).
+            kNodeValueSpace =
+            TargetNodeSize - /*minimum overhead=*/(sizeof(void *) + 4),
+        };
+
+        // This is an integral type large enough to hold as many
+        // ValueSize-values as will fit a node of TargetNodeSize bytes.
+        using node_count_type =
+            phmap::conditional_t<(kNodeValueSpace / sizeof(value_type) >
+                                   (std::numeric_limits<uint8_t>::max)()),
+            uint16_t, uint8_t>;  // NOLINT
+
+        // The following methods are necessary for passing this struct as PolicyTraits
+        // for node_handle and/or are used within btree.
+        static value_type &element(slot_type *slot) {
+            return slot_policy::element(slot);
+        }
+        static const value_type &element(const slot_type *slot) {
+            return slot_policy::element(slot);
+        }
+        template <class... Args>
+        static void construct(Alloc *alloc, slot_type *slot, Args &&... args) {
+            slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
+        }
+        static void construct(Alloc *alloc, slot_type *slot, slot_type *other) {
+            slot_policy::construct(alloc, slot, other);
+        }
+        static void destroy(Alloc *alloc, slot_type *slot) {
+            slot_policy::destroy(alloc, slot);
+        }
+        static void transfer(Alloc *alloc, slot_type *new_slot, slot_type *old_slot) {
+            construct(alloc, new_slot, old_slot);
+            destroy(alloc, old_slot);
+        }
+        static void swap(Alloc *alloc, slot_type *a, slot_type *b) {
+            slot_policy::swap(alloc, a, b);
+        }
+        static void move(Alloc *alloc, slot_type *src, slot_type *dest) {
+            slot_policy::move(alloc, src, dest);
+        }
+        static void move(Alloc *alloc, slot_type *first, slot_type *last,
+                         slot_type *result) {
+            slot_policy::move(alloc, first, last, result);
+        }
+    };
+
+    // A parameters structure for holding the type parameters for a btree_map.
+    // Compare and Alloc should be nothrow copy-constructible.
+    template <typename Key, typename Data, typename Compare, typename Alloc,
+              int TargetNodeSize, bool Multi>
+    struct map_params : common_params<Key, Compare, Alloc, TargetNodeSize, Multi,
+                                      phmap::priv::map_slot_policy<Key, Data>> {
+        using super_type = typename map_params::common_params;
+        using mapped_type = Data;
+        // This type allows us to move keys when it is safe to do so. It is safe
+        // for maps in which value_type and mutable_value_type are layout compatible.
+        using slot_policy = typename super_type::slot_policy;
+        using slot_type = typename super_type::slot_type;
+        using value_type = typename super_type::value_type;
+        using init_type = typename super_type::init_type;
+
+        using key_compare = typename super_type::key_compare;
+        // Inherit from key_compare for empty base class optimization.
+        struct value_compare : private key_compare {
+            value_compare() = default;
+            explicit value_compare(const key_compare &cmp) : key_compare(cmp) {}
+
+            template <typename T, typename U>
+            auto operator()(const T &left, const U &right) const
+                -> decltype(std::declval<key_compare>()(left.first, right.first)) {
+                return key_compare::operator()(left.first, right.first);
+            }
+        };
+        using is_map_container = std::true_type;
+
+        static const Key &key(const value_type &x) { return x.first; }
+        static const Key &key(const init_type &x) { return x.first; }
+        static const Key &key(const slot_type *x) { return slot_policy::key(x); }
+        static mapped_type &value(value_type *value) { return value->second; }
+    };
+
+    // This type implements the necessary functions from the
+    // btree::priv::slot_type interface.
+    template <typename Key>
+    struct set_slot_policy {
+        using slot_type = Key;
+        using value_type = Key;
+        using mutable_value_type = Key;
+
+        static value_type &element(slot_type *slot) { return *slot; }
+        static const value_type &element(const slot_type *slot) { return *slot; }
+
+        template <typename Alloc, class... Args>
+        static void construct(Alloc *alloc, slot_type *slot, Args &&... args) {
+            phmap::allocator_traits<Alloc>::construct(*alloc, slot,
+                                                       std::forward<Args>(args)...);
+        }
+
+        template <typename Alloc>
+        static void construct(Alloc *alloc, slot_type *slot, slot_type *other) {
+            phmap::allocator_traits<Alloc>::construct(*alloc, slot, std::move(*other));
+        }
+
+        template <typename Alloc>
+        static void destroy(Alloc *alloc, slot_type *slot) {
+            phmap::allocator_traits<Alloc>::destroy(*alloc, slot);
+        }
+
+        template <typename Alloc>
+        static void swap(Alloc * /*alloc*/, slot_type *a, slot_type *b) {
+            using std::swap;
+            swap(*a, *b);
+        }
+
+        template <typename Alloc>
+        static void move(Alloc * /*alloc*/, slot_type *src, slot_type *dest) {
+            *dest = std::move(*src);
+        }
+
+        template <typename Alloc>
+        static void move(Alloc *alloc, slot_type *first, slot_type *last,
+                         slot_type *result) {
+            for (slot_type *src = first, *dest = result; src != last; ++src, ++dest)
+                move(alloc, src, dest);
+        }
+    };
+
+    // A parameters structure for holding the type parameters for a btree_set.
+    // Compare and Alloc should be nothrow copy-constructible.
+    template <typename Key, typename Compare, typename Alloc, int TargetNodeSize,
+              bool Multi>
+    struct set_params : common_params<Key, Compare, Alloc, TargetNodeSize, Multi,
+                                      set_slot_policy<Key>> {
+        using value_type = Key;
+        using slot_type = typename set_params::common_params::slot_type;
+        using value_compare = typename set_params::common_params::key_compare;
+        using is_map_container = std::false_type;
+
+        static const Key &key(const value_type &x) { return x; }
+        static const Key &key(const slot_type *x) { return *x; }
+    };
+
+    // An adapter class that converts a lower-bound compare into an upper-bound
+    // compare. Note: there is no need to make a version of this adapter specialized
+    // for key-compare-to functors because the upper-bound (the first value greater
+    // than the input) is never an exact match.
+    template <typename Compare>
+    struct upper_bound_adapter {
+        explicit upper_bound_adapter(const Compare &c) : comp(c) {}
+        template <typename K, typename LK>
+        bool operator()(const K &a, const LK &b) const {
+            // Returns true when a is not greater than b.
+            return !phmap::compare_internal::compare_result_as_less_than(comp(b, a));
+        }
+
+    private:
+        Compare comp;
+    };
+
+    enum class MatchKind : uint8_t { kEq, kNe };
+
+    template <typename V, bool IsCompareTo>
+    struct SearchResult {
+        V value;
+        MatchKind match;
+
+        static constexpr bool HasMatch() { return true; }
+        bool IsEq() const { return match == MatchKind::kEq; }
+    };
+
+    // When we don't use CompareTo, `match` is not present.
+    // This ensures that callers can't use it accidentally when it provides no
+    // useful information.
+    template <typename V>
+    struct SearchResult<V, false> {
+        V value;
+
+        static constexpr bool HasMatch() { return false; }
+        static constexpr bool IsEq() { return false; }
+    };
+
+    // A node in the btree holding. The same node type is used for both internal
+    // and leaf nodes in the btree, though the nodes are allocated in such a way
+    // that the children array is only valid in internal nodes.
+    template <typename Params>
+    class btree_node {
+        using is_key_compare_to = typename Params::is_key_compare_to;
+        using is_multi_container = typename Params::is_multi_container;
+        using field_type = typename Params::node_count_type;
+        using allocator_type = typename Params::allocator_type;
+        using slot_type = typename Params::slot_type;
+
+    public:
+        using params_type = Params;
+        using key_type = typename Params::key_type;
+        using value_type = typename Params::value_type;
+        using pointer = typename Params::pointer;
+        using const_pointer = typename Params::const_pointer;
+        using reference = typename Params::reference;
+        using const_reference = typename Params::const_reference;
+        using key_compare = typename Params::key_compare;
+        using size_type = typename Params::size_type;
+        using difference_type = typename Params::difference_type;
+
+        // Btree decides whether to use linear node search as follows:
+        //   - If the key is arithmetic and the comparator is std::less or
+        //     std::greater, choose linear.
+        //   - Otherwise, choose binary.
+        // TODO(ezb): Might make sense to add condition(s) based on node-size.
+        using use_linear_search = std::integral_constant<
+            bool,
+            std::is_arithmetic<key_type>::value &&
+            (std::is_same<phmap::Less<key_type>, key_compare>::value ||
+             std::is_same<std::less<key_type>, key_compare>::value ||
+             std::is_same<std::greater<key_type>, key_compare>::value)>;
+
+
+        ~btree_node() = default;
+        btree_node(btree_node const &) = delete;
+        btree_node &operator=(btree_node const &) = delete;
+
+        // Public for EmptyNodeType.
+        constexpr static size_type Alignment() {
+            static_assert(LeafLayout(1).Alignment() == InternalLayout().Alignment(),
+                          "Alignment of all nodes must be equal.");
+            return (size_type)InternalLayout().Alignment();
+        }
+
+    protected:
+        btree_node() = default;
+
+    private:
+        using layout_type = phmap::priv::Layout<btree_node *, field_type,
+                                                               slot_type, btree_node *>;
+        constexpr static size_type SizeWithNValues(size_type n) {
+            return (size_type)layout_type(/*parent*/ 1,
+                               /*position, start, count, max_count*/ 4,
+                               /*values*/ (size_t)n,
+                               /*children*/ 0)
+                .AllocSize();
+        }
+        // A lower bound for the overhead of fields other than values in a leaf node.
+        constexpr static size_type MinimumOverhead() {
+            return (size_type)(SizeWithNValues(1) - sizeof(value_type));
+        }
+
+        // Compute how many values we can fit onto a leaf node taking into account
+        // padding.
+        constexpr static size_type NodeTargetValues(const int begin, const int end) {
+            return begin == end ? begin
+                : SizeWithNValues((begin + end) / 2 + 1) >
+                params_type::kTargetNodeSize
+                ? NodeTargetValues(begin, (begin + end) / 2)
+                : NodeTargetValues((begin + end) / 2 + 1, end);
+        }
+
+        enum {
+            kTargetNodeSize = params_type::kTargetNodeSize,
+            kNodeTargetValues = NodeTargetValues(0, params_type::kTargetNodeSize),
+
+            // We need a minimum of 3 values per internal node in order to perform
+            // splitting (1 value for the two nodes involved in the split and 1 value
+            // propagated to the parent as the delimiter for the split).
+            kNodeValues = kNodeTargetValues >= 3 ? kNodeTargetValues : 3,
+
+            // The node is internal (i.e. is not a leaf node) if and only if `max_count`
+            // has this value.
+            kInternalNodeMaxCount = 0,
+        };
+
+        // Leaves can have less than kNodeValues values.
+        constexpr static layout_type LeafLayout(const int max_values = kNodeValues) {
+            return layout_type(/*parent*/ 1,
+                               /*position, start, count, max_count*/ 4,
+                               /*values*/ (size_t)max_values,
+                               /*children*/ 0);
+        }
+        constexpr static layout_type InternalLayout() {
+            return layout_type(/*parent*/ 1,
+                               /*position, start, count, max_count*/ 4,
+                               /*values*/ kNodeValues,
+                               /*children*/ kNodeValues + 1);
+        }
+        constexpr static size_type LeafSize(const int max_values = kNodeValues) {
+            return (size_type)LeafLayout(max_values).AllocSize();
+        }
+        constexpr static size_type InternalSize() {
+            return (size_type)InternalLayout().AllocSize();
+        }
+
+        // N is the index of the type in the Layout definition.
+        // ElementType<N> is the Nth type in the Layout definition.
+        template <size_type N>
+        inline typename layout_type::template ElementType<N> *GetField() {
+            // We assert that we don't read from values that aren't there.
+            assert(N < 3 || !leaf());
+            return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
+        }
+
+        template <size_type N>
+        inline const typename layout_type::template ElementType<N> *GetField() const {
+            assert(N < 3 || !leaf());
+            return InternalLayout().template Pointer<N>(
+                reinterpret_cast<const char *>(this));
+        }
+
+        void set_parent(btree_node *p)     { *GetField<0>() = p; }
+        field_type &mutable_count()        { return GetField<1>()[2]; }
+        slot_type *slot(size_type i)       { return &GetField<2>()[i]; }
+        const slot_type *slot(size_type i) const { return &GetField<2>()[i]; }
+        void set_position(field_type v)    { GetField<1>()[0] = v; }
+        void set_start(field_type v)       { GetField<1>()[1] = v; }
+        void set_count(field_type v)       { GetField<1>()[2] = v; }
+        void set_max_count(field_type v)   { GetField<1>()[3] = v; }
+
+    public:
+        // Whether this is a leaf node or not. This value doesn't change after the
+        // node is created.
+        bool leaf() const { return GetField<1>()[3] != kInternalNodeMaxCount; }
+
+        // Getter for the position of this node in its parent.
+        field_type position() const { return GetField<1>()[0]; }
+
+        // Getter for the offset of the first value in the `values` array.
+        field_type start() const { return GetField<1>()[1]; }
+
+        // Getters for the number of values stored in this node.
+        field_type count() const { return GetField<1>()[2]; }
+        field_type max_count() const {
+            // Internal nodes have max_count==kInternalNodeMaxCount.
+            // Leaf nodes have max_count in [1, kNodeValues].
+            const field_type max_count = GetField<1>()[3];
+            return max_count == field_type{kInternalNodeMaxCount}
+            ? field_type{kNodeValues}
+            : max_count;
+        }
+
+        // Getter for the parent of this node.
+        btree_node *parent() const { return *GetField<0>(); }
+        // Getter for whether the node is the root of the tree. The parent of the
+        // root of the tree is the leftmost node in the tree which is guaranteed to
+        // be a leaf.
+        bool is_root() const { return parent()->leaf(); }
+        void make_root() {
+            assert(parent()->is_root());
+            set_parent(parent()->parent());
+        }
+
+        // Getters for the key/value at position i in the node.
+        const key_type &key(size_type i) const { return params_type::key(slot(i)); }
+        reference value(size_type i) { return params_type::element(slot(i)); }
+        const_reference value(size_type i) const { return params_type::element(slot(i)); }
+
+        // Getters/setter for the child at position i in the node.
+        btree_node *child(size_type i) const { return GetField<3>()[i]; }
+        btree_node *&mutable_child(size_type i) { return GetField<3>()[i]; }
+        void clear_child(size_type i) {
+            phmap::priv::SanitizerPoisonObject(&mutable_child(i));
+        }
+        void set_child(size_type i, btree_node *c) {
+            phmap::priv::SanitizerUnpoisonObject(&mutable_child(i));
+            mutable_child(i) = c;
+            c->set_position((field_type)i);
+        }
+        void init_child(int i, btree_node *c) {
+            set_child(i, c);
+            c->set_parent(this);
+        }
+
+        // Returns the position of the first value whose key is not less than k.
+        template <typename K>
+        SearchResult<int, is_key_compare_to::value> lower_bound(
+            const K &k, const key_compare &comp) const {
+            return use_linear_search::value ? linear_search(k, comp)
+                : binary_search(k, comp);
+        }
+        // Returns the position of the first value whose key is greater than k.
+        template <typename K>
+        int upper_bound(const K &k, const key_compare &comp) const {
+            auto upper_compare = upper_bound_adapter<key_compare>(comp);
+            return use_linear_search::value ? linear_search(k, upper_compare).value
+                : binary_search(k, upper_compare).value;
+        }
+
+        template <typename K, typename Compare>
+        SearchResult<int, btree_is_key_compare_to<Compare, key_type>::value>
+        linear_search(const K &k, const Compare &comp) const {
+            return linear_search_impl(k, 0, count(), comp,
+                                      btree_is_key_compare_to<Compare, key_type>());
+        }
+
+        template <typename K, typename Compare>
+        SearchResult<int, btree_is_key_compare_to<Compare, key_type>::value>
+        binary_search(const K &k, const Compare &comp) const {
+            return binary_search_impl(k, 0, count(), comp,
+                                      btree_is_key_compare_to<Compare, key_type>());
+        }
+
+        // Returns the position of the first value whose key is not less than k using
+        // linear search performed using plain compare.
+        template <typename K, typename Compare>
+        SearchResult<int, false> linear_search_impl(
+            const K &k, int s, const int e, const Compare &comp,
+            std::false_type /* IsCompareTo */) const {
+            while (s < e) {
+                if (!comp(key(s), k)) {
+                    break;
+                }
+                ++s;
+            }
+            return {s};
+        }
+
+        // Returns the position of the first value whose key is not less than k using
+        // linear search performed using compare-to.
+        template <typename K, typename Compare>
+        SearchResult<int, true> linear_search_impl(
+            const K &k, int s, const int e, const Compare &comp,
+            std::true_type /* IsCompareTo */) const {
+            while (s < e) {
+                const phmap::weak_ordering c = comp(key(s), k);
+                if (c == 0) {
+                    return {s, MatchKind::kEq};
+                } else if (c > 0) {
+                    break;
+                }
+                ++s;
+            }
+            return {s, MatchKind::kNe};
+        }
+
+        // Returns the position of the first value whose key is not less than k using
+        // binary search performed using plain compare.
+        template <typename K, typename Compare>
+        SearchResult<int, false> binary_search_impl(
+            const K &k, int s, int e, const Compare &comp,
+            std::false_type /* IsCompareTo */) const {
+            while (s != e) {
+                const int mid = (s + e) >> 1;
+                if (comp(key(mid), k)) {
+                    s = mid + 1;
+                } else {
+                    e = mid;
+                }
+            }
+            return {s};
+        }
+
+        // Returns the position of the first value whose key is not less than k using
+        // binary search performed using compare-to.
+        template <typename K, typename CompareTo>
+        SearchResult<int, true> binary_search_impl(
+            const K &k, int s, int e, const CompareTo &comp,
+            std::true_type /* IsCompareTo */) const {
+            if (is_multi_container::value) {
+                MatchKind exact_match = MatchKind::kNe;
+                while (s != e) {
+                    const int mid = (s + e) >> 1;
+                    const phmap::weak_ordering c = comp(key(mid), k);
+                    if (c < 0) {
+                        s = mid + 1;
+                    } else {
+                        e = mid;
+                        if (c == 0) {
+                            // Need to return the first value whose key is not less than k,
+                            // which requires continuing the binary search if this is a
+                            // multi-container.
+                            exact_match = MatchKind::kEq;
+                        }
+                    }
+                }
+                return {s, exact_match};
+            } else {  // Not a multi-container.
+                while (s != e) {
+                    const int mid = (s + e) >> 1;
+                    const phmap::weak_ordering c = comp(key(mid), k);
+                    if (c < 0) {
+                        s = mid + 1;
+                    } else if (c > 0) {
+                        e = mid;
+                    } else {
+                        return {mid, MatchKind::kEq};
+                    }
+                }
+                return {s, MatchKind::kNe};
+            }
+        }
+
+        // Emplaces a value at position i, shifting all existing values and
+        // children at positions >= i to the right by 1.
+        template <typename... Args>
+        void emplace_value(size_type i, allocator_type *alloc, Args &&... args);
+
+        // Removes the value at position i, shifting all existing values and children
+        // at positions > i to the left by 1.
+        void remove_value(int i, allocator_type *alloc);
+
+        // Removes the values at positions [i, i + to_erase), shifting all values
+        // after that range to the left by to_erase. Does not change children at all.
+        void remove_values_ignore_children(int i, size_type to_erase,
+                                           allocator_type *alloc);
+
+        // Rebalances a node with its right sibling.
+        void rebalance_right_to_left(int to_move, btree_node *right,
+                                     allocator_type *alloc);
+        void rebalance_left_to_right(int to_move, btree_node *right,
+                                     allocator_type *alloc);
+
+        // Splits a node, moving a portion of the node's values to its right sibling.
+        void split(int insert_position, btree_node *dest, allocator_type *alloc);
+
+        // Merges a node with its right sibling, moving all of the values and the
+        // delimiting key in the parent node onto itself.
+        void merge(btree_node *sibling, allocator_type *alloc);
+
+        // Swap the contents of "this" and "src".
+        void swap(btree_node *src, allocator_type *alloc);
+
+        // Node allocation/deletion routines.
+        static btree_node *init_leaf(btree_node *n, btree_node *parent,
+                                     int max_count) {
+            n->set_parent(parent);
+            n->set_position(0);
+            n->set_start(0);
+            n->set_count(0);
+            n->set_max_count((field_type)max_count);
+            phmap::priv::SanitizerPoisonMemoryRegion(
+                n->slot(0), max_count * sizeof(slot_type));
+            return n;
+        }
+        static btree_node *init_internal(btree_node *n, btree_node *parent) {
+            init_leaf(n, parent, kNodeValues);
+            // Set `max_count` to a sentinel value to indicate that this node is
+            // internal.
+            n->set_max_count(kInternalNodeMaxCount);
+            phmap::priv::SanitizerPoisonMemoryRegion(
+                &n->mutable_child(0), (kNodeValues + 1) * sizeof(btree_node *));
+            return n;
+        }
+        void destroy(allocator_type *alloc) {
+            for (int i = 0; i < count(); ++i) {
+                value_destroy(i, alloc);
+            }
+        }
+
+    public:
+        // Exposed only for tests.
+        static bool testonly_uses_linear_node_search() {
+            return use_linear_search::value;
+        }
+
+    private:
+        template <typename... Args>
+        void value_init(const size_type i, allocator_type *alloc, Args &&... args) {
+            phmap::priv::SanitizerUnpoisonObject(slot(i));
+            params_type::construct(alloc, slot(i), std::forward<Args>(args)...);
+        }
+        void value_destroy(const size_type i, allocator_type *alloc) {
+            params_type::destroy(alloc, slot(i));
+            phmap::priv::SanitizerPoisonObject(slot(i));
+        }
+
+        // Move n values starting at value i in this node into the values starting at
+        // value j in node x.
+        void uninitialized_move_n(const size_type n, const size_type i,
+                                  const size_type j, btree_node *x,
+                                  allocator_type *alloc) {
+            phmap::priv::SanitizerUnpoisonMemoryRegion(
+                x->slot(j), n * sizeof(slot_type));
+            for (slot_type *src = slot(i), *end = src + n, *dest = x->slot(j);
+                 src != end; ++src, ++dest) {
+                params_type::construct(alloc, dest, src);
+            }
+        }
+
+        // Destroys a range of n values, starting at index i.
+        void value_destroy_n(const size_type i, const size_type n,
+                             allocator_type *alloc) {
+            for (int j = 0; j < n; ++j) {
+                value_destroy(i + j, alloc);
+            }
+        }
+
+        template <typename P>
+        friend class btree;
+        template <typename N, typename R, typename P>
+        friend struct btree_iterator;
+        friend class BtreeNodePeer;
+    };
+
+    template <typename Node, typename Reference, typename Pointer>
+    struct btree_iterator {
+    private:
+        using key_type = typename Node::key_type;
+        using size_type = typename Node::size_type;
+        using params_type = typename Node::params_type;
+
+        using node_type = Node;
+        using normal_node = typename std::remove_const<Node>::type;
+        using const_node = const Node;
+        using normal_pointer = typename params_type::pointer;
+        using normal_reference = typename params_type::reference;
+        using const_pointer = typename params_type::const_pointer;
+        using const_reference = typename params_type::const_reference;
+        using slot_type = typename params_type::slot_type;
+
+        using iterator =
+            btree_iterator<normal_node, normal_reference, normal_pointer>;
+        using const_iterator =
+            btree_iterator<const_node, const_reference, const_pointer>;
+
+    public:
+        // These aliases are public for std::iterator_traits.
+        using difference_type = typename Node::difference_type;
+        using value_type = typename params_type::value_type;
+        using pointer = Pointer;
+        using reference = Reference;
+        using iterator_category = std::bidirectional_iterator_tag;
+
+        btree_iterator() : node(nullptr), position(-1) {}
+        btree_iterator(Node *n, int p) : node(n), position(p) {}
+
+        // NOTE: this SFINAE allows for implicit conversions from iterator to
+        // const_iterator, but it specifically avoids defining copy constructors so
+        // that btree_iterator can be trivially copyable. This is for performance and
+        // binary size reasons.
+        template <typename N, typename R, typename P,
+                  phmap::enable_if_t<
+                      std::is_same<btree_iterator<N, R, P>, iterator>::value &&
+                      std::is_same<btree_iterator, const_iterator>::value,
+                      int> = 0>
+            btree_iterator(const btree_iterator<N, R, P> &x)  // NOLINT
+            : node(x.node), position(x.position) {}
+
+    private:
+        // This SFINAE allows explicit conversions from const_iterator to
+        // iterator, but also avoids defining a copy constructor.
+        // NOTE: the const_cast is safe because this constructor is only called by
+        // non-const methods and the container owns the nodes.
+        template <typename N, typename R, typename P,
+                  phmap::enable_if_t<
+                      std::is_same<btree_iterator<N, R, P>, const_iterator>::value &&
+                      std::is_same<btree_iterator, iterator>::value,
+                      int> = 0>
+            explicit btree_iterator(const btree_iterator<N, R, P> &x)
+            : node(const_cast<node_type *>(x.node)), position(x.position) {}
+
+        // Increment/decrement the iterator.
+        void increment() {
+            if (node->leaf() && ++position < node->count()) {
+                return;
+            }
+            increment_slow();
+        }
+        void increment_slow();
+
+        void decrement() {
+            if (node->leaf() && --position >= 0) {
+                return;
+            }
+            decrement_slow();
+        }
+        void decrement_slow();
+
+    public:
+        bool operator==(const const_iterator &x) const {
+            return node == x.node && position == x.position;
+        }
+        bool operator!=(const const_iterator &x) const {
+            return node != x.node || position != x.position;
+        }
+
+        // Accessors for the key/value the iterator is pointing at.
+        reference operator*() const {
+            return node->value(position);
+        }
+        pointer operator->() const {
+            return &node->value(position);
+        }
+
+        btree_iterator& operator++() {
+            increment();
+            return *this;
+        }
+        btree_iterator& operator--() {
+            decrement();
+            return *this;
+        }
+        btree_iterator operator++(int) {
+            btree_iterator tmp = *this;
+            ++*this;
+            return tmp;
+        }
+        btree_iterator operator--(int) {
+            btree_iterator tmp = *this;
+            --*this;
+            return tmp;
+        }
+
+    private:
+        template <typename Params>
+        friend class btree;
+        template <typename Tree>
+        friend class btree_container;
+        template <typename Tree>
+        friend class btree_set_container;
+        template <typename Tree>
+        friend class btree_map_container;
+        template <typename Tree>
+        friend class btree_multiset_container;
+        template <typename N, typename R, typename P>
+        friend struct btree_iterator;
+        template <typename TreeType, typename CheckerType>
+        friend class base_checker;
+
+        const key_type &key() const { return node->key(position); }
+        slot_type *slot() { return node->slot(position); }
+
+        // The node in the tree the iterator is pointing at.
+        Node *node;
+        // The position within the node of the tree the iterator is pointing at.
+        // TODO(ezb): make this a field_type
+        int position;
+    };
+
+    template <typename Params>
+    class btree {
+        using node_type = btree_node<Params>;
+        using is_key_compare_to = typename Params::is_key_compare_to;
+
+        // We use a static empty node for the root/leftmost/rightmost of empty btrees
+        // in order to avoid branching in begin()/end().
+        struct alignas(node_type::Alignment()) EmptyNodeType : node_type {
+            using field_type = typename node_type::field_type;
+            node_type *parent;
+            field_type position = 0;
+            field_type start = 0;
+            field_type count = 0;
+            // max_count must be != kInternalNodeMaxCount (so that this node is regarded
+            // as a leaf node). max_count() is never called when the tree is empty.
+            field_type max_count = node_type::kInternalNodeMaxCount + 1;
+
+#ifdef _MSC_VER
+            // MSVC has constexpr code generations bugs here.
+            EmptyNodeType() : parent(this) {}
+#else
+            constexpr EmptyNodeType(node_type *p) : parent(p) {}
+#endif
+        };
+
+        static node_type *EmptyNode() {
+#ifdef _MSC_VER
+            static EmptyNodeType* empty_node = new EmptyNodeType;
+            // This assert fails on some other construction methods.
+            assert(empty_node->parent == empty_node);
+            return empty_node;
+#else
+            static constexpr EmptyNodeType empty_node(
+                const_cast<EmptyNodeType *>(&empty_node));
+            return const_cast<EmptyNodeType *>(&empty_node);
+#endif
+        }
+
+        enum {
+            kNodeValues = node_type::kNodeValues,
+            kMinNodeValues = kNodeValues / 2,
+        };
+
+        struct node_stats {
+            using size_type = typename Params::size_type;
+
+            node_stats(size_type l, size_type i)
+                : leaf_nodes(l),
+                  internal_nodes(i) {
+            }
+
+            node_stats& operator+=(const node_stats &x) {
+                leaf_nodes += x.leaf_nodes;
+                internal_nodes += x.internal_nodes;
+                return *this;
+            }
+
+            size_type leaf_nodes;
+            size_type internal_nodes;
+        };
+
+    public:
+        using key_type = typename Params::key_type;
+        using value_type = typename Params::value_type;
+        using size_type = typename Params::size_type;
+        using difference_type = typename Params::difference_type;
+        using key_compare = typename Params::key_compare;
+        using value_compare = typename Params::value_compare;
+        using allocator_type = typename Params::allocator_type;
+        using reference = typename Params::reference;
+        using const_reference = typename Params::const_reference;
+        using pointer = typename Params::pointer;
+        using const_pointer = typename Params::const_pointer;
+        using iterator = btree_iterator<node_type, reference, pointer>;
+        using const_iterator = typename iterator::const_iterator;
+        using reverse_iterator = std::reverse_iterator<iterator>;
+        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+        using node_handle_type = node_handle<Params, Params, allocator_type>;
+
+        // Internal types made public for use by btree_container types.
+        using params_type = Params;
+        using slot_type = typename Params::slot_type;
+
+    private:
+        // For use in copy_or_move_values_in_order.
+        const value_type &maybe_move_from_iterator(const_iterator x) { return *x; }
+        value_type &&maybe_move_from_iterator(iterator x) { return std::move(*x); }
+
+        // Copies or moves (depending on the template parameter) the values in
+        // x into this btree in their order in x. This btree must be empty before this
+        // method is called. This method is used in copy construction, copy
+        // assignment, and move assignment.
+        template <typename Btree>
+        void copy_or_move_values_in_order(Btree *x);
+
+        // Validates that various assumptions/requirements are true at compile time.
+        constexpr static bool static_assert_validation();
+
+    public:
+        btree(const key_compare &comp, const allocator_type &alloc);
+
+        btree(const btree &x);
+        btree(btree &&x) noexcept
+            : root_(std::move(x.root_)),
+            rightmost_(phmap::exchange(x.rightmost_, EmptyNode())),
+            size_(phmap::exchange(x.size_, 0)) {
+            x.mutable_root() = EmptyNode();
+        }
+
+        ~btree() {
+            // Put static_asserts in destructor to avoid triggering them before the type
+            // is complete.
+            static_assert(static_assert_validation(), "This call must be elided.");
+            clear();
+        }
+
+        // Assign the contents of x to *this.
+        btree &operator=(const btree &x);
+        btree &operator=(btree &&x) noexcept;
+
+        iterator begin() {
+            return iterator(leftmost(), 0);
+        }
+        const_iterator begin() const {
+            return const_iterator(leftmost(), 0);
+        }
+        iterator end() { return iterator(rightmost_, rightmost_->count()); }
+        const_iterator end() const {
+            return const_iterator(rightmost_, rightmost_->count());
+        }
+        reverse_iterator rbegin() {
+            return reverse_iterator(end());
+        }
+        const_reverse_iterator rbegin() const {
+            return const_reverse_iterator(end());
+        }
+        reverse_iterator rend() {
+            return reverse_iterator(begin());
+        }
+        const_reverse_iterator rend() const {
+            return const_reverse_iterator(begin());
+        }
+
+        // Finds the first element whose key is not less than key.
+        template <typename K>
+        iterator lower_bound(const K &key) {
+            return internal_end(internal_lower_bound(key));
+        }
+        template <typename K>
+        const_iterator lower_bound(const K &key) const {
+            return internal_end(internal_lower_bound(key));
+        }
+
+        // Finds the first element whose key is greater than key.
+        template <typename K>
+        iterator upper_bound(const K &key) {
+            return internal_end(internal_upper_bound(key));
+        }
+        template <typename K>
+        const_iterator upper_bound(const K &key) const {
+            return internal_end(internal_upper_bound(key));
+        }
+
+        // Finds the range of values which compare equal to key. The first member of
+        // the returned pair is equal to lower_bound(key). The second member pair of
+        // the pair is equal to upper_bound(key).
+        template <typename K>
+        std::pair<iterator, iterator> equal_range(const K &key) {
+            return {lower_bound(key), upper_bound(key)};
+        }
+        template <typename K>
+        std::pair<const_iterator, const_iterator> equal_range(const K &key) const {
+            return {lower_bound(key), upper_bound(key)};
+        }
+
+        // Inserts a value into the btree only if it does not already exist. The
+        // boolean return value indicates whether insertion succeeded or failed.
+        // Requirement: if `key` already exists in the btree, does not consume `args`.
+        // Requirement: `key` is never referenced after consuming `args`.
+        template <typename... Args>
+        std::pair<iterator, bool> insert_unique(const key_type &key, Args &&... args);
+
+        // Inserts with hint. Checks to see if the value should be placed immediately
+        // before `position` in the tree. If so, then the insertion will take
+        // amortized constant time. If not, the insertion will take amortized
+        // logarithmic time as if a call to insert_unique() were made.
+        // Requirement: if `key` already exists in the btree, does not consume `args`.
+        // Requirement: `key` is never referenced after consuming `args`.
+        template <typename... Args>
+        std::pair<iterator, bool> insert_hint_unique(iterator position,
+                                                     const key_type &key,
+                                                     Args &&... args);
+
+        // Insert a range of values into the btree.
+        template <typename InputIterator>
+        void insert_iterator_unique(InputIterator b, InputIterator e);
+
+        // Inserts a value into the btree.
+        template <typename ValueType>
+        iterator insert_multi(const key_type &key, ValueType &&v);
+
+        // Inserts a value into the btree.
+        template <typename ValueType>
+        iterator insert_multi(ValueType &&v) {
+            return insert_multi(params_type::key(v), std::forward<ValueType>(v));
+        }
+
+        // Insert with hint. Check to see if the value should be placed immediately
+        // before position in the tree. If it does, then the insertion will take
+        // amortized constant time. If not, the insertion will take amortized
+        // logarithmic time as if a call to insert_multi(v) were made.
+        template <typename ValueType>
+        iterator insert_hint_multi(iterator position, ValueType &&v);
+
+        // Insert a range of values into the btree.
+        template <typename InputIterator>
+        void insert_iterator_multi(InputIterator b, InputIterator e);
+
+        // Erase the specified iterator from the btree. The iterator must be valid
+        // (i.e. not equal to end()).  Return an iterator pointing to the node after
+        // the one that was erased (or end() if none exists).
+        // Requirement: does not read the value at `*iter`.
+        iterator erase(iterator iter);
+
+        // Erases range. Returns the number of keys erased and an iterator pointing
+        // to the element after the last erased element.
+        std::pair<size_type, iterator> erase(iterator begin, iterator end);
+
+        // Erases the specified key from the btree. Returns 1 if an element was
+        // erased and 0 otherwise.
+        template <typename K>
+        size_type erase_unique(const K &key);
+
+        // Erases all of the entries matching the specified key from the
+        // btree. Returns the number of elements erased.
+        template <typename K>
+        size_type erase_multi(const K &key);
+
+        // Finds the iterator corresponding to a key or returns end() if the key is
+        // not present.
+        template <typename K>
+        iterator find(const K &key) {
+            return internal_end(internal_find(key));
+        }
+        template <typename K>
+        const_iterator find(const K &key) const {
+            return internal_end(internal_find(key));
+        }
+
+        // Returns a count of the number of times the key appears in the btree.
+        template <typename K>
+        size_type count_unique(const K &key) const {
+            const iterator begin = internal_find(key);
+            if (begin.node == nullptr) {
+                // The key doesn't exist in the tree.
+                return 0;
+            }
+            return 1;
+        }
+        // Returns a count of the number of times the key appears in the btree.
+        template <typename K>
+        size_type count_multi(const K &key) const {
+            const auto range = equal_range(key);
+            return std::distance(range.first, range.second);
+        }
+
+        // Clear the btree, deleting all of the values it contains.
+        void clear();
+
+        // Swap the contents of *this and x.
+        void swap(btree &x);
+
+        const key_compare &key_comp() const noexcept {
+            return root_.template get<0>();
+        }
+        template <typename K, typename LK>
+        bool compare_keys(const K &x, const LK &y) const {
+            return compare_internal::compare_result_as_less_than(key_comp()(x, y));
+        }
+
+        value_compare value_comp() const { return value_compare(key_comp()); }
+
+        // Verifies the structure of the btree.
+        void verify() const;
+
+        // Size routines.
+        size_type size() const { return size_; }
+        size_type max_size() const { return (std::numeric_limits<size_type>::max)(); }
+        bool empty() const { return size_ == 0; }
+
+        // The height of the btree. An empty tree will have height 0.
+        size_type height() const {
+            size_type h = 0;
+            if (!empty()) {
+                // Count the length of the chain from the leftmost node up to the
+                // root. We actually count from the root back around to the level below
+                // the root, but the calculation is the same because of the circularity
+                // of that traversal.
+                const node_type *n = root();
+                do {
+                    ++h;
+                    n = n->parent();
+                } while (n != root());
+            }
+            return h;
+        }
+
+        // The number of internal, leaf and total nodes used by the btree.
+        size_type leaf_nodes() const {
+            return internal_stats(root()).leaf_nodes;
+        }
+        size_type internal_nodes() const {
+            return internal_stats(root()).internal_nodes;
+        }
+        size_type nodes() const {
+            node_stats stats = internal_stats(root());
+            return stats.leaf_nodes + stats.internal_nodes;
+        }
+
+        // The total number of bytes used by the btree.
+        size_type bytes_used() const {
+            node_stats stats = internal_stats(root());
+            if (stats.leaf_nodes == 1 && stats.internal_nodes == 0) {
+                return sizeof(*this) +
+                    node_type::LeafSize(root()->max_count());
+            } else {
+                return sizeof(*this) +
+                    stats.leaf_nodes * node_type::LeafSize() +
+                    stats.internal_nodes * node_type::InternalSize();
+            }
+        }
+
+        // The average number of bytes used per value stored in the btree.
+        static double average_bytes_per_value() {
+            // Returns the number of bytes per value on a leaf node that is 75%
+            // full. Experimentally, this matches up nicely with the computed number of
+            // bytes per value in trees that had their values inserted in random order.
+            return node_type::LeafSize() / (kNodeValues * 0.75);
+        }
+
+        // The fullness of the btree. Computed as the number of elements in the btree
+        // divided by the maximum number of elements a tree with the current number
+        // of nodes could hold. A value of 1 indicates perfect space
+        // utilization. Smaller values indicate space wastage.
+        // Returns 0 for empty trees.
+        double fullness() const {
+            if (empty()) return 0.0;
+            return static_cast<double>(size()) / (nodes() * kNodeValues);
+        }
+        // The overhead of the btree structure in bytes per node. Computed as the
+        // total number of bytes used by the btree minus the number of bytes used for
+        // storing elements divided by the number of elements.
+        // Returns 0 for empty trees.
+        double overhead() const {
+            if (empty()) return 0.0;
+            return (bytes_used() - size() * sizeof(value_type)) /
+                static_cast<double>(size());
+        }
+
+        // The allocator used by the btree.
+        allocator_type get_allocator() const {
+            return allocator();
+        }
+
+    private:
+        // Internal accessor routines.
+        node_type *root() { return root_.template get<2>(); }
+        const node_type *root() const { return root_.template get<2>(); }
+        node_type *&mutable_root() noexcept { return root_.template get<2>(); }
+        key_compare *mutable_key_comp() noexcept { return &root_.template get<0>(); }
+
+        // The leftmost node is stored as the parent of the root node.
+        node_type *leftmost() { return root()->parent(); }
+        const node_type *leftmost() const { return root()->parent(); }
+
+        // Allocator routines.
+        allocator_type *mutable_allocator() noexcept {
+            return &root_.template get<1>();
+        }
+        const allocator_type &allocator() const noexcept {
+            return root_.template get<1>();
+        }
+
+        // Allocates a correctly aligned node of at least size bytes using the
+        // allocator.
+        node_type *allocate(const size_type size) {
+            return reinterpret_cast<node_type *>(
+                phmap::priv::Allocate<node_type::Alignment()>(
+                    mutable_allocator(), (size_t)size));
+        }
+
+        // Node creation/deletion routines.
+        node_type* new_internal_node(node_type *parent) {
+            node_type *p = allocate(node_type::InternalSize());
+            return node_type::init_internal(p, parent);
+        }
+        node_type* new_leaf_node(node_type *parent) {
+            node_type *p = allocate(node_type::LeafSize());
+            return node_type::init_leaf(p, parent, kNodeValues);
+        }
+        node_type *new_leaf_root_node(const int max_count) {
+            node_type *p = allocate(node_type::LeafSize(max_count));
+            return node_type::init_leaf(p, p, max_count);
+        }
+
+        // Deletion helper routines.
+        void erase_same_node(iterator begin, iterator end);
+        iterator erase_from_leaf_node(iterator begin, size_type to_erase);
+        iterator rebalance_after_delete(iterator iter);
+
+        // Deallocates a node of a certain size in bytes using the allocator.
+        void deallocate(const size_type size, node_type *node) {
+            phmap::priv::Deallocate<node_type::Alignment()>(
+                mutable_allocator(), node, (size_t)size);
+        }
+
+        void delete_internal_node(node_type *node) {
+            node->destroy(mutable_allocator());
+            deallocate(node_type::InternalSize(), node);
+        }
+        void delete_leaf_node(node_type *node) {
+            node->destroy(mutable_allocator());
+            deallocate(node_type::LeafSize(node->max_count()), node);
+        }
+
+        // Rebalances or splits the node iter points to.
+        void rebalance_or_split(iterator *iter);
+
+        // Merges the values of left, right and the delimiting key on their parent
+        // onto left, removing the delimiting key and deleting right.
+        void merge_nodes(node_type *left, node_type *right);
+
+        // Tries to merge node with its left or right sibling, and failing that,
+        // rebalance with its left or right sibling. Returns true if a merge
+        // occurred, at which point it is no longer valid to access node. Returns
+        // false if no merging took place.
+        bool try_merge_or_rebalance(iterator *iter);
+
+        // Tries to shrink the height of the tree by 1.
+        void try_shrink();
+
+        iterator internal_end(iterator iter) {
+            return iter.node != nullptr ? iter : end();
+        }
+        const_iterator internal_end(const_iterator iter) const {
+            return iter.node != nullptr ? iter : end();
+        }
+
+        // Emplaces a value into the btree immediately before iter. Requires that
+        // key(v) <= iter.key() and (--iter).key() <= key(v).
+        template <typename... Args>
+        iterator internal_emplace(iterator iter, Args &&... args);
+
+        // Returns an iterator pointing to the first value >= the value "iter" is
+        // pointing at. Note that "iter" might be pointing to an invalid location as
+        // iter.position == iter.node->count(). This routine simply moves iter up in
+        // the tree to a valid location.
+        // Requires: iter.node is non-null.
+        template <typename IterType>
+        static IterType internal_last(IterType iter);
+
+        // Returns an iterator pointing to the leaf position at which key would
+        // reside in the tree. We provide 2 versions of internal_locate. The first
+        // version uses a less-than comparator and is incapable of distinguishing when
+        // there is an exact match. The second version is for the key-compare-to
+        // specialization and distinguishes exact matches. The key-compare-to
+        // specialization allows the caller to avoid a subsequent comparison to
+        // determine if an exact match was made, which is important for keys with
+        // expensive comparison, such as strings.
+        template <typename K>
+        SearchResult<iterator, is_key_compare_to::value> internal_locate(
+            const K &key) const;
+
+        template <typename K>
+        SearchResult<iterator, false> internal_locate_impl(
+            const K &key, std::false_type /* IsCompareTo */) const;
+
+        template <typename K>
+        SearchResult<iterator, true> internal_locate_impl(
+            const K &key, std::true_type /* IsCompareTo */) const;
+
+        // Internal routine which implements lower_bound().
+        template <typename K>
+        iterator internal_lower_bound(const K &key) const;
+
+        // Internal routine which implements upper_bound().
+        template <typename K>
+        iterator internal_upper_bound(const K &key) const;
+
+        // Internal routine which implements find().
+        template <typename K>
+        iterator internal_find(const K &key) const;
+
+        // Deletes a node and all of its children.
+        void internal_clear(node_type *node);
+
+        // Verifies the tree structure of node.
+        int internal_verify(const node_type *node,
+                            const key_type *lo, const key_type *hi) const;
+
+        node_stats internal_stats(const node_type *node) const {
+            // The root can be a static empty node.
+            if (node == nullptr || (node == root() && empty())) {
+                return node_stats(0, 0);
+            }
+            if (node->leaf()) {
+                return node_stats(1, 0);
+            }
+            node_stats res(0, 1);
+            for (int i = 0; i <= node->count(); ++i) {
+                res += internal_stats(node->child(i));
+            }
+            return res;
+        }
+
+    public:
+        // Exposed only for tests.
+        static bool testonly_uses_linear_node_search() {
+            return node_type::testonly_uses_linear_node_search();
+        }
+
+    private:
+        // We use compressed tuple in order to save space because key_compare and
+        // allocator_type are usually empty.
+        phmap::priv::CompressedTuple<key_compare, allocator_type,
+                                                    node_type *>
+        root_;
+
+        // A pointer to the rightmost node. Note that the leftmost node is stored as
+        // the root's parent.
+        node_type *rightmost_;
+
+        // Number of values.
+        size_type size_;
+    };
+
+    ////
+    // btree_node methods
+    template <typename P>
+    template <typename... Args>
+    inline void btree_node<P>::emplace_value(const size_type i,
+                                             allocator_type *alloc,
+                                             Args &&... args) {
+        assert(i <= count());
+        // Shift old values to create space for new value and then construct it in
+        // place.
+        if (i < count()) {
+            value_init(count(), alloc, slot(count() - 1));
+            for (size_type j = count() - 1; j > i; --j)
+                params_type::move(alloc, slot(j - 1), slot(j));
+            value_destroy(i, alloc);
+        }
+        value_init(i, alloc, std::forward<Args>(args)...);
+        set_count((field_type)(count() + 1));
+
+        if (!leaf() && count() > i + 1) {
+            for (int j = count(); j > i + 1; --j) {
+                set_child(j, child(j - 1));
+            }
+            clear_child(i + 1);
+        }
+    }
+
+    template <typename P>
+    inline void btree_node<P>::remove_value(const int i, allocator_type *alloc) {
+        if (!leaf() && count() > i + 1) {
+            assert(child(i + 1)->count() == 0);
+            for (size_type j = i + 1; j < count(); ++j) {
+                set_child(j, child(j + 1));
+            }
+            clear_child(count());
+        }
+
+        remove_values_ignore_children(i, /*to_erase=*/1, alloc);
+    }
+
+    template <typename P>
+    inline void btree_node<P>::remove_values_ignore_children(
+        int i, size_type to_erase, allocator_type *alloc) {
+        params_type::move(alloc, slot(i + to_erase), slot(count()), slot(i));
+        value_destroy_n(count() - to_erase, to_erase, alloc);
+        set_count((field_type)(count() - to_erase));
+    }
+
+    template <typename P>
+    void btree_node<P>::rebalance_right_to_left(const int to_move,
+                                                btree_node *right,
+                                                allocator_type *alloc) {
+        assert(parent() == right->parent());
+        assert(position() + 1 == right->position());
+        assert(right->count() >= count());
+        assert(to_move >= 1);
+        assert(to_move <= right->count());
+
+        // 1) Move the delimiting value in the parent to the left node.
+        value_init(count(), alloc, parent()->slot(position()));
+
+        // 2) Move the (to_move - 1) values from the right node to the left node.
+        right->uninitialized_move_n(to_move - 1, 0, count() + 1, this, alloc);
+
+        // 3) Move the new delimiting value to the parent from the right node.
+        params_type::move(alloc, right->slot(to_move - 1),
+                          parent()->slot(position()));
+
+        // 4) Shift the values in the right node to their correct position.
+        params_type::move(alloc, right->slot(to_move), right->slot(right->count()),
+                          right->slot(0));
+
+        // 5) Destroy the now-empty to_move entries in the right node.
+        right->value_destroy_n(right->count() - to_move, to_move, alloc);
+
+        if (!leaf()) {
+            // Move the child pointers from the right to the left node.
+            for (int i = 0; i < to_move; ++i) {
+                init_child(count() + i + 1, right->child(i));
+            }
+            for (int i = 0; i <= right->count() - to_move; ++i) {
+                assert(i + to_move <= right->max_count());
+                right->init_child(i, right->child(i + to_move));
+                right->clear_child(i + to_move);
+            }
+        }
+
+        // Fixup the counts on the left and right nodes.
+        set_count((field_type)(count() + to_move));
+        right->set_count((field_type)(right->count() - to_move));
+    }
+
+    template <typename P>
+    void btree_node<P>::rebalance_left_to_right(const int to_move,
+                                                btree_node *right,
+                                                allocator_type *alloc) {
+        assert(parent() == right->parent());
+        assert(position() + 1 == right->position());
+        assert(count() >= right->count());
+        assert(to_move >= 1);
+        assert(to_move <= count());
+
+        // Values in the right node are shifted to the right to make room for the
+        // new to_move values. Then, the delimiting value in the parent and the
+        // other (to_move - 1) values in the left node are moved into the right node.
+        // Lastly, a new delimiting value is moved from the left node into the
+        // parent, and the remaining empty left node entries are destroyed.
+
+        if (right->count() >= to_move) {
+            // The original location of the right->count() values are sufficient to hold
+            // the new to_move entries from the parent and left node.
+
+            // 1) Shift existing values in the right node to their correct positions.
+            right->uninitialized_move_n(to_move, right->count() - to_move,
+                                        right->count(), right, alloc);
+            for (slot_type *src = right->slot(right->count() - to_move - 1),
+                     *dest = right->slot(right->count() - 1),
+                     *end = right->slot(0);
+                 src >= end; --src, --dest) {
+                params_type::move(alloc, src, dest);
+            }
+
+            // 2) Move the delimiting value in the parent to the right node.
+            params_type::move(alloc, parent()->slot(position()),
+                              right->slot(to_move - 1));
+
+            // 3) Move the (to_move - 1) values from the left node to the right node.
+            params_type::move(alloc, slot(count() - (to_move - 1)), slot(count()),
+                              right->slot(0));
+        } else {
+            // The right node does not have enough initialized space to hold the new
+            // to_move entries, so part of them will move to uninitialized space.
+
+            // 1) Shift existing values in the right node to their correct positions.
+            right->uninitialized_move_n(right->count(), 0, to_move, right, alloc);
+
+            // 2) Move the delimiting value in the parent to the right node.
+            right->value_init(to_move - 1, alloc, parent()->slot(position()));
+
+            // 3) Move the (to_move - 1) values from the left node to the right node.
+            const size_type uninitialized_remaining = to_move - right->count() - 1;
+            uninitialized_move_n(uninitialized_remaining,
+                                 count() - uninitialized_remaining, right->count(),
+                                 right, alloc);
+            params_type::move(alloc, slot(count() - (to_move - 1)),
+                              slot(count() - uninitialized_remaining), right->slot(0));
+        }
+
+        // 4) Move the new delimiting value to the parent from the left node.
+        params_type::move(alloc, slot(count() - to_move), parent()->slot(position()));
+
+        // 5) Destroy the now-empty to_move entries in the left node.
+        value_destroy_n(count() - to_move, to_move, alloc);
+
+        if (!leaf()) {
+            // Move the child pointers from the left to the right node.
+            for (int i = right->count(); i >= 0; --i) {
+                right->init_child(i + to_move, right->child(i));
+                right->clear_child(i);
+            }
+            for (int i = 1; i <= to_move; ++i) {
+                right->init_child(i - 1, child(count() - to_move + i));
+                clear_child(count() - to_move + i);
+            }
+        }
+
+        // Fixup the counts on the left and right nodes.
+        set_count((field_type)(count() - to_move));
+        right->set_count((field_type)(right->count() + to_move));
+    }
+
+    template <typename P>
+    void btree_node<P>::split(const int insert_position, btree_node *dest,
+                              allocator_type *alloc) {
+        assert(dest->count() == 0);
+        assert(max_count() == kNodeValues);
+
+        // We bias the split based on the position being inserted. If we're
+        // inserting at the beginning of the left node then bias the split to put
+        // more values on the right node. If we're inserting at the end of the
+        // right node then bias the split to put more values on the left node.
+        if (insert_position == 0) {
+            dest->set_count((field_type)(count() - 1));
+        } else if (insert_position == kNodeValues) {
+            dest->set_count(0);
+        } else {
+            dest->set_count((field_type)(count() / 2));
+        }
+        set_count((field_type)(count() - dest->count()));
+        assert(count() >= 1);
+
+        // Move values from the left sibling to the right sibling.
+        uninitialized_move_n(dest->count(), count(), 0, dest, alloc);
+
+        // Destroy the now-empty entries in the left node.
+        value_destroy_n(count(), dest->count(), alloc);
+
+        // The split key is the largest value in the left sibling.
+        set_count((field_type)(count() - 1));
+        parent()->emplace_value(position(), alloc, slot(count()));
+        value_destroy(count(), alloc);
+        parent()->init_child(position() + 1, dest);
+
+        if (!leaf()) {
+            for (int i = 0; i <= dest->count(); ++i) {
+                assert(child(count() + i + 1) != nullptr);
+                dest->init_child(i, child(count() + i + 1));
+                clear_child(count() + i + 1);
+            }
+        }
+    }
+
+    template <typename P>
+    void btree_node<P>::merge(btree_node *src, allocator_type *alloc) {
+        assert(parent() == src->parent());
+        assert(position() + 1 == src->position());
+
+        // Move the delimiting value to the left node.
+        value_init(count(), alloc, parent()->slot(position()));
+
+        // Move the values from the right to the left node.
+        src->uninitialized_move_n(src->count(), 0, count() + 1, this, alloc);
+
+        // Destroy the now-empty entries in the right node.
+        src->value_destroy_n(0, src->count(), alloc);
+
+        if (!leaf()) {
+            // Move the child pointers from the right to the left node.
+            for (int i = 0; i <= src->count(); ++i) {
+                init_child(count() + i + 1, src->child(i));
+                src->clear_child(i);
+            }
+        }
+
+        // Fixup the counts on the src and dest nodes.
+        set_count((field_type)(1 + count() + src->count()));
+        src->set_count(0);
+
+        // Remove the value on the parent node.
+        parent()->remove_value(position(), alloc);
+    }
+
+    template <typename P>
+    void btree_node<P>::swap(btree_node *x, allocator_type *alloc) {
+        using std::swap;
+        assert(leaf() == x->leaf());
+
+        // Determine which is the smaller/larger node.
+        btree_node *smaller = this, *larger = x;
+        if (smaller->count() > larger->count()) {
+            swap(smaller, larger);
+        }
+
+        // Swap the values.
+        for (slot_type *a = smaller->slot(0), *b = larger->slot(0),
+                 *end = a + smaller->count();
+             a != end; ++a, ++b) {
+            params_type::swap(alloc, a, b);
+        }
+
+        // Move values that can't be swapped.
+        const size_type to_move = larger->count() - smaller->count();
+        larger->uninitialized_move_n(to_move, smaller->count(), smaller->count(),
+                                     smaller, alloc);
+        larger->value_destroy_n(smaller->count(), to_move, alloc);
+
+        if (!leaf()) {
+            // Swap the child pointers.
+            std::swap_ranges(&smaller->mutable_child(0),
+                             &smaller->mutable_child(smaller->count() + 1),
+                             &larger->mutable_child(0));
+            // Update swapped children's parent pointers.
+            int i = 0;
+            for (; i <= smaller->count(); ++i) {
+                smaller->child(i)->set_parent(smaller);
+                larger->child(i)->set_parent(larger);
+            }
+            // Move the child pointers that couldn't be swapped.
+            for (; i <= larger->count(); ++i) {
+                smaller->init_child(i, larger->child(i));
+                larger->clear_child(i);
+            }
+        }
+
+        // Swap the counts.
+        swap(mutable_count(), x->mutable_count());
+    }
+
+    ////
+    // btree_iterator methods
+    template <typename N, typename R, typename P>
+    void btree_iterator<N, R, P>::increment_slow() {
+        if (node->leaf()) {
+            assert(position >= node->count());
+            btree_iterator save(*this);
+            while (position == node->count() && !node->is_root()) {
+                assert(node->parent()->child(node->position()) == node);
+                position = node->position();
+                node = node->parent();
+            }
+            if (position == node->count()) {
+                *this = save;
+            }
+        } else {
+            assert(position < node->count());
+            node = node->child(position + 1);
+            while (!node->leaf()) {
+                node = node->child(0);
+            }
+            position = 0;
+        }
+    }
+
+    template <typename N, typename R, typename P>
+    void btree_iterator<N, R, P>::decrement_slow() {
+        if (node->leaf()) {
+            assert(position <= -1);
+            btree_iterator save(*this);
+            while (position < 0 && !node->is_root()) {
+                assert(node->parent()->child(node->position()) == node);
+                position = node->position() - 1;
+                node = node->parent();
+            }
+            if (position < 0) {
+                *this = save;
+            }
+        } else {
+            assert(position >= 0);
+            node = node->child(position);
+            while (!node->leaf()) {
+                node = node->child(node->count());
+            }
+            position = node->count() - 1;
+        }
+    }
+
+    ////
+    // btree methods
+    template <typename P>
+    template <typename Btree>
+    void btree<P>::copy_or_move_values_in_order(Btree *x) {
+        static_assert(std::is_same<btree, Btree>::value ||
+                      std::is_same<const btree, Btree>::value,
+                      "Btree type must be same or const.");
+        assert(empty());
+
+        // We can avoid key comparisons because we know the order of the
+        // values is the same order we'll store them in.
+        auto iter = x->begin();
+        if (iter == x->end()) return;
+        insert_multi(maybe_move_from_iterator(iter));
+        ++iter;
+        for (; iter != x->end(); ++iter) {
+            // If the btree is not empty, we can just insert the new value at the end
+            // of the tree.
+            internal_emplace(end(), maybe_move_from_iterator(iter));
+        }
+    }
+
+    template <typename P>
+    constexpr bool btree<P>::static_assert_validation() {
+        static_assert(std::is_nothrow_copy_constructible<key_compare>::value,
+                      "Key comparison must be nothrow copy constructible");
+        static_assert(std::is_nothrow_copy_constructible<allocator_type>::value,
+                      "Allocator must be nothrow copy constructible");
+        static_assert(type_traits_internal::is_trivially_copyable<iterator>::value,
+                      "iterator not trivially copyable.");
+
+        // Note: We assert that kTargetValues, which is computed from
+        // Params::kTargetNodeSize, must fit the node_type::field_type.
+        static_assert(
+            kNodeValues < (1 << (8 * sizeof(typename node_type::field_type))),
+            "target node size too large");
+
+        // Verify that key_compare returns an phmap::{weak,strong}_ordering or bool.
+        using compare_result_type =
+            phmap::invoke_result_t<key_compare, key_type, key_type>;
+        static_assert(
+            std::is_same<compare_result_type, bool>::value ||
+            std::is_convertible<compare_result_type, phmap::weak_ordering>::value,
+            "key comparison function must return phmap::{weak,strong}_ordering or "
+            "bool.");
+
+        // Test the assumption made in setting kNodeValueSpace.
+        static_assert(node_type::MinimumOverhead() >= sizeof(void *) + 4,
+                      "node space assumption incorrect");
+
+        return true;
+    }
+
+    template <typename P>
+    btree<P>::btree(const key_compare &comp, const allocator_type &alloc)
+        : root_(comp, alloc, EmptyNode()), rightmost_(EmptyNode()), size_(0) {}
+
+    template <typename P>
+    btree<P>::btree(const btree &x) : btree(x.key_comp(), x.allocator()) {
+        copy_or_move_values_in_order(&x);
+    }
+
+    template <typename P>
+    template <typename... Args>
+    auto btree<P>::insert_unique(const key_type &key, Args &&... args)
+        -> std::pair<iterator, bool> {
+        if (empty()) {
+            mutable_root() = rightmost_ = new_leaf_root_node(1);
+        }
+
+        auto res = internal_locate(key);
+        iterator &iter = res.value;
+
+        if (res.HasMatch()) {
+            if (res.IsEq()) {
+                // The key already exists in the tree, do nothing.
+                return {iter, false};
+            }
+        } else {
+            iterator last = internal_last(iter);
+            if (last.node && !compare_keys(key, last.key())) {
+                // The key already exists in the tree, do nothing.
+                return {last, false};
+            }
+        }
+        return {internal_emplace(iter, std::forward<Args>(args)...), true};
+    }
+
+    template <typename P>
+    template <typename... Args>
+    inline auto btree<P>::insert_hint_unique(iterator position, const key_type &key,
+                                             Args &&... args)
+        -> std::pair<iterator, bool> {
+        if (!empty()) {
+            if (position == end() || compare_keys(key, position.key())) {
+                iterator prev = position;
+                if (position == begin() || compare_keys((--prev).key(), key)) {
+                    // prev.key() < key < position.key()
+                    return {internal_emplace(position, std::forward<Args>(args)...), true};
+                }
+            } else if (compare_keys(position.key(), key)) {
+                ++position;
+                if (position == end() || compare_keys(key, position.key())) {
+                    // {original `position`}.key() < key < {current `position`}.key()
+                    return {internal_emplace(position, std::forward<Args>(args)...), true};
+                }
+            } else {
+                // position.key() == key
+                return {position, false};
+            }
+        }
+        return insert_unique(key, std::forward<Args>(args)...);
+    }
+
+    template <typename P>
+    template <typename InputIterator>
+    void btree<P>::insert_iterator_unique(InputIterator b, InputIterator e) {
+        for (; b != e; ++b) {
+            insert_hint_unique(end(), params_type::key(*b), *b);
+        }
+    }
+
+    template <typename P>
+    template <typename ValueType>
+    auto btree<P>::insert_multi(const key_type &key, ValueType &&v) -> iterator {
+        if (empty()) {
+            mutable_root() = rightmost_ = new_leaf_root_node(1);
+        }
+
+        iterator iter = internal_upper_bound(key);
+        if (iter.node == nullptr) {
+            iter = end();
+        }
+        return internal_emplace(iter, std::forward<ValueType>(v));
+    }
+
+    template <typename P>
+    template <typename ValueType>
+    auto btree<P>::insert_hint_multi(iterator position, ValueType &&v) -> iterator {
+        if (!empty()) {
+            const key_type &key = params_type::key(v);
+            if (position == end() || !compare_keys(position.key(), key)) {
+                iterator prev = position;
+                if (position == begin() || !compare_keys(key, (--prev).key())) {
+                    // prev.key() <= key <= position.key()
+                    return internal_emplace(position, std::forward<ValueType>(v));
+                }
+            } else {
+                iterator next = position;
+                ++next;
+                if (next == end() || !compare_keys(next.key(), key)) {
+                    // position.key() < key <= next.key()
+                    return internal_emplace(next, std::forward<ValueType>(v));
+                }
+            }
+        }
+        return insert_multi(std::forward<ValueType>(v));
+    }
+
+    template <typename P>
+    template <typename InputIterator>
+    void btree<P>::insert_iterator_multi(InputIterator b, InputIterator e) {
+        for (; b != e; ++b) {
+            insert_hint_multi(end(), *b);
+        }
+    }
+
+    template <typename P>
+    auto btree<P>::operator=(const btree &x) -> btree & {
+        if (this != &x) {
+            clear();
+
+            *mutable_key_comp() = x.key_comp();
+            if (phmap::allocator_traits<
+                allocator_type>::propagate_on_container_copy_assignment::value) {
+                *mutable_allocator() = x.allocator();
+            }
+
+            copy_or_move_values_in_order(&x);
+        }
+        return *this;
+    }
+
+    template <typename P>
+    auto btree<P>::operator=(btree &&x) noexcept -> btree & {
+        if (this != &x) {
+            clear();
+
+            using std::swap;
+            if (phmap::allocator_traits<
+                allocator_type>::propagate_on_container_copy_assignment::value) {
+                // Note: `root_` also contains the allocator and the key comparator.
+                swap(root_, x.root_);
+                swap(rightmost_, x.rightmost_);
+                swap(size_, x.size_);
+            } else {
+                if (allocator() == x.allocator()) {
+                    swap(mutable_root(), x.mutable_root());
+                    swap(*mutable_key_comp(), *x.mutable_key_comp());
+                    swap(rightmost_, x.rightmost_);
+                    swap(size_, x.size_);
+                } else {
+                    // We aren't allowed to propagate the allocator and the allocator is
+                    // different so we can't take over its memory. We must move each element
+                    // individually. We need both `x` and `this` to have `x`s key comparator
+                    // while moving the values so we can't swap the key comparators.
+                    *mutable_key_comp() = x.key_comp();
+                    copy_or_move_values_in_order(&x);
+                }
+            }
+        }
+        return *this;
+    }
+
+    template <typename P>
+    auto btree<P>::erase(iterator iter) -> iterator {
+        bool internal_delete = false;
+        if (!iter.node->leaf()) {
+            // Deletion of a value on an internal node. First, move the largest value
+            // from our left child here, then delete that position (in remove_value()
+            // below). We can get to the largest value from our left child by
+            // decrementing iter.
+            iterator internal_iter(iter);
+            --iter;
+            assert(iter.node->leaf());
+            params_type::move(mutable_allocator(), iter.node->slot(iter.position),
+                              internal_iter.node->slot(internal_iter.position));
+            internal_delete = true;
+        }
+
+        // Delete the key from the leaf.
+        iter.node->remove_value(iter.position, mutable_allocator());
+        --size_;
+
+        // We want to return the next value after the one we just erased. If we
+        // erased from an internal node (internal_delete == true), then the next
+        // value is ++(++iter). If we erased from a leaf node (internal_delete ==
+        // false) then the next value is ++iter. Note that ++iter may point to an
+        // internal node and the value in the internal node may move to a leaf node
+        // (iter.node) when rebalancing is performed at the leaf level.
+
+        iterator res = rebalance_after_delete(iter);
+
+        // If we erased from an internal node, advance the iterator.
+        if (internal_delete) {
+            ++res;
+        }
+        return res;
+    }
+
+    template <typename P>
+    auto btree<P>::rebalance_after_delete(iterator iter) -> iterator {
+        // Merge/rebalance as we walk back up the tree.
+        iterator res(iter);
+        bool first_iteration = true;
+        for (;;) {
+            if (iter.node == root()) {
+                try_shrink();
+                if (empty()) {
+                    return end();
+                }
+                break;
+            }
+            if (iter.node->count() >= kMinNodeValues) {
+                break;
+            }
+            bool merged = try_merge_or_rebalance(&iter);
+            // On the first iteration, we should update `res` with `iter` because `res`
+            // may have been invalidated.
+            if (first_iteration) {
+                res = iter;
+                first_iteration = false;
+            }
+            if (!merged) {
+                break;
+            }
+            iter.position = iter.node->position();
+            iter.node = iter.node->parent();
+        }
+
+        // Adjust our return value. If we're pointing at the end of a node, advance
+        // the iterator.
+        if (res.position == res.node->count()) {
+            res.position = res.node->count() - 1;
+            ++res;
+        }
+
+        return res;
+    }
+
+    template <typename P>
+    auto btree<P>::erase(iterator begin, iterator end)
+        -> std::pair<size_type, iterator> {
+        difference_type count = std::distance(begin, end);
+        assert(count >= 0);
+
+        if (count == 0) {
+            return {0, begin};
+        }
+
+        if (count == size_) {
+            clear();
+            return {count, this->end()};
+        }
+
+        if (begin.node == end.node) {
+            erase_same_node(begin, end);
+            size_ -= count;
+            return {count, rebalance_after_delete(begin)};
+        }
+
+        const size_type target_size = size_ - count;
+        while (size_ > target_size) {
+            if (begin.node->leaf()) {
+                const size_type remaining_to_erase = size_ - target_size;
+                const size_type remaining_in_node = begin.node->count() - begin.position;
+                begin = erase_from_leaf_node(
+                    begin, (std::min)(remaining_to_erase, remaining_in_node));
+            } else {
+                begin = erase(begin);
+            }
+        }
+        return {count, begin};
+    }
+
+    template <typename P>
+    void btree<P>::erase_same_node(iterator begin, iterator end) {
+        assert(begin.node == end.node);
+        assert(end.position > begin.position);
+
+        node_type *node = begin.node;
+        size_type to_erase = end.position - begin.position;
+        if (!node->leaf()) {
+            // Delete all children between begin and end.
+            for (size_type i = 0; i < to_erase; ++i) {
+                internal_clear(node->child(begin.position + i + 1));
+            }
+            // Rotate children after end into new positions.
+            for (size_type i = begin.position + to_erase + 1; i <= node->count(); ++i) {
+                node->set_child(i - to_erase, node->child(i));
+                node->clear_child(i);
+            }
+        }
+        node->remove_values_ignore_children(begin.position, to_erase,
+                                            mutable_allocator());
+
+        // Do not need to update rightmost_, because
+        // * either end == this->end(), and therefore node == rightmost_, and still
+        //   exists
+        // * or end != this->end(), and therefore rightmost_ hasn't been erased, since
+        //   it wasn't covered in [begin, end)
+    }
+
+    template <typename P>
+    auto btree<P>::erase_from_leaf_node(iterator begin, size_type to_erase)
+        -> iterator {
+        node_type *node = begin.node;
+        assert(node->leaf());
+        assert(node->count() > begin.position);
+        assert(begin.position + to_erase <= node->count());
+
+        node->remove_values_ignore_children(begin.position, to_erase,
+                                            mutable_allocator());
+
+        size_ -= to_erase;
+
+        return rebalance_after_delete(begin);
+    }
+
+    template <typename P>
+    template <typename K>
+    auto btree<P>::erase_unique(const K &key) -> size_type {
+        const iterator iter = internal_find(key);
+        if (iter.node == nullptr) {
+            // The key doesn't exist in the tree, return nothing done.
+            return 0;
+        }
+        erase(iter);
+        return 1;
+    }
+
+    template <typename P>
+    template <typename K>
+    auto btree<P>::erase_multi(const K &key) -> size_type {
+        const iterator begin = internal_lower_bound(key);
+        if (begin.node == nullptr) {
+            // The key doesn't exist in the tree, return nothing done.
+            return 0;
+        }
+        // Delete all of the keys between begin and upper_bound(key).
+        const iterator end = internal_end(internal_upper_bound(key));
+        return erase(begin, end).first;
+    }
+
+    template <typename P>
+    void btree<P>::clear() {
+        if (!empty()) {
+            internal_clear(root());
+        }
+        mutable_root() = EmptyNode();
+        rightmost_ = EmptyNode();
+        size_ = 0;
+    }
+
+    template <typename P>
+    void btree<P>::swap(btree &x) {
+        using std::swap;
+        if (phmap::allocator_traits<
+            allocator_type>::propagate_on_container_swap::value) {
+            // Note: `root_` also contains the allocator and the key comparator.
+            swap(root_, x.root_);
+        } else {
+            // It's undefined behavior if the allocators are unequal here.
+            assert(allocator() == x.allocator());
+            swap(mutable_root(), x.mutable_root());
+            swap(*mutable_key_comp(), *x.mutable_key_comp());
+        }
+        swap(rightmost_, x.rightmost_);
+        swap(size_, x.size_);
+    }
+
+    template <typename P>
+    void btree<P>::verify() const {
+        assert(root() != nullptr);
+        assert(leftmost() != nullptr);
+        assert(rightmost_ != nullptr);
+        assert(empty() || size() == internal_verify(root(), nullptr, nullptr));
+        assert(leftmost() == (++const_iterator(root(), -1)).node);
+        assert(rightmost_ == (--const_iterator(root(), root()->count())).node);
+        assert(leftmost()->leaf());
+        assert(rightmost_->leaf());
+    }
+
+    template <typename P>
+    void btree<P>::rebalance_or_split(iterator *iter) {
+        node_type *&node = iter->node;
+        int &insert_position = iter->position;
+        assert(node->count() == node->max_count());
+        assert(kNodeValues == node->max_count());
+
+        // First try to make room on the node by rebalancing.
+        node_type *parent = node->parent();
+        if (node != root()) {
+            if (node->position() > 0) {
+                // Try rebalancing with our left sibling.
+                node_type *left = parent->child(node->position() - 1);
+                assert(left->max_count() == kNodeValues);
+                if (left->count() < kNodeValues) {
+                    // We bias rebalancing based on the position being inserted. If we're
+                    // inserting at the end of the right node then we bias rebalancing to
+                    // fill up the left node.
+                    int to_move = (kNodeValues - left->count()) /
+                        (1 + (insert_position < kNodeValues));
+                    to_move = (std::max)(1, to_move);
+
+                    if (((insert_position - to_move) >= 0) ||
+                        ((left->count() + to_move) < kNodeValues)) {
+                        left->rebalance_right_to_left(to_move, node, mutable_allocator());
+
+                        assert(node->max_count() - node->count() == to_move);
+                        insert_position = insert_position - to_move;
+                        if (insert_position < 0) {
+                            insert_position = insert_position + left->count() + 1;
+                            node = left;
+                        }
+
+                        assert(node->count() < node->max_count());
+                        return;
+                    }
+                }
+            }
+
+            if (node->position() < parent->count()) {
+                // Try rebalancing with our right sibling.
+                node_type *right = parent->child(node->position() + 1);
+                assert(right->max_count() == kNodeValues);
+                if (right->count() < kNodeValues) {
+                    // We bias rebalancing based on the position being inserted. If we're
+                    // inserting at the beginning of the left node then we bias rebalancing
+                    // to fill up the right node.
+                    int to_move =
+                        (kNodeValues - right->count()) / (1 + (insert_position > 0));
+                    to_move = (std::max)(1, to_move);
+
+                    if ((insert_position <= (node->count() - to_move)) ||
+                        ((right->count() + to_move) < kNodeValues)) {
+                        node->rebalance_left_to_right(to_move, right, mutable_allocator());
+
+                        if (insert_position > node->count()) {
+                            insert_position = insert_position - node->count() - 1;
+                            node = right;
+                        }
+
+                        assert(node->count() < node->max_count());
+                        return;
+                    }
+                }
+            }
+
+            // Rebalancing failed, make sure there is room on the parent node for a new
+            // value.
+            assert(parent->max_count() == kNodeValues);
+            if (parent->count() == kNodeValues) {
+                iterator parent_iter(node->parent(), node->position());
+                rebalance_or_split(&parent_iter);
+            }
+        } else {
+            // Rebalancing not possible because this is the root node.
+            // Create a new root node and set the current root node as the child of the
+            // new root.
+            parent = new_internal_node(parent);
+            parent->init_child(0, root());
+            mutable_root() = parent;
+            // If the former root was a leaf node, then it's now the rightmost node.
+            assert(!parent->child(0)->leaf() || parent->child(0) == rightmost_);
+        }
+
+        // Split the node.
+        node_type *split_node;
+        if (node->leaf()) {
+            split_node = new_leaf_node(parent);
+            node->split(insert_position, split_node, mutable_allocator());
+            if (rightmost_ == node) rightmost_ = split_node;
+        } else {
+            split_node = new_internal_node(parent);
+            node->split(insert_position, split_node, mutable_allocator());
+        }
+
+        if (insert_position > node->count()) {
+            insert_position = insert_position - node->count() - 1;
+            node = split_node;
+        }
+    }
+
+    template <typename P>
+    void btree<P>::merge_nodes(node_type *left, node_type *right) {
+        left->merge(right, mutable_allocator());
+        if (right->leaf()) {
+            if (rightmost_ == right) rightmost_ = left;
+            delete_leaf_node(right);
+        } else {
+            delete_internal_node(right);
+        }
+    }
+
+    template <typename P>
+    bool btree<P>::try_merge_or_rebalance(iterator *iter) {
+        node_type *parent = iter->node->parent();
+        if (iter->node->position() > 0) {
+            // Try merging with our left sibling.
+            node_type *left = parent->child(iter->node->position() - 1);
+            assert(left->max_count() == kNodeValues);
+            if ((1 + left->count() + iter->node->count()) <= kNodeValues) {
+                iter->position += 1 + left->count();
+                merge_nodes(left, iter->node);
+                iter->node = left;
+                return true;
+            }
+        }
+        if (iter->node->position() < parent->count()) {
+            // Try merging with our right sibling.
+            node_type *right = parent->child(iter->node->position() + 1);
+            assert(right->max_count() == kNodeValues);
+            if ((1 + iter->node->count() + right->count()) <= kNodeValues) {
+                merge_nodes(iter->node, right);
+                return true;
+            }
+            // Try rebalancing with our right sibling. We don't perform rebalancing if
+            // we deleted the first element from iter->node and the node is not
+            // empty. This is a small optimization for the common pattern of deleting
+            // from the front of the tree.
+            if ((right->count() > kMinNodeValues) &&
+                ((iter->node->count() == 0) ||
+                 (iter->position > 0))) {
+                int to_move = (right->count() - iter->node->count()) / 2;
+                to_move = (std::min)(to_move, right->count() - 1);
+                iter->node->rebalance_right_to_left(to_move, right, mutable_allocator());
+                return false;
+            }
+        }
+        if (iter->node->position() > 0) {
+            // Try rebalancing with our left sibling. We don't perform rebalancing if
+            // we deleted the last element from iter->node and the node is not
+            // empty. This is a small optimization for the common pattern of deleting
+            // from the back of the tree.
+            node_type *left = parent->child(iter->node->position() - 1);
+            if ((left->count() > kMinNodeValues) &&
+                ((iter->node->count() == 0) ||
+                 (iter->position < iter->node->count()))) {
+                int to_move = (left->count() - iter->node->count()) / 2;
+                to_move = (std::min)(to_move, left->count() - 1);
+                left->rebalance_left_to_right(to_move, iter->node, mutable_allocator());
+                iter->position += to_move;
+                return false;
+            }
+        }
+        return false;
+    }
+
+    template <typename P>
+    void btree<P>::try_shrink() {
+        if (root()->count() > 0) {
+            return;
+        }
+        // Deleted the last item on the root node, shrink the height of the tree.
+        if (root()->leaf()) {
+            assert(size() == 0);
+            delete_leaf_node(root());
+            mutable_root() = EmptyNode();
+            rightmost_ = EmptyNode();
+        } else {
+            node_type *child = root()->child(0);
+            child->make_root();
+            delete_internal_node(root());
+            mutable_root() = child;
+        }
+    }
+
+    template <typename P>
+    template <typename IterType>
+    inline IterType btree<P>::internal_last(IterType iter) {
+        assert(iter.node != nullptr);
+        while (iter.position == iter.node->count()) {
+            iter.position = iter.node->position();
+            iter.node = iter.node->parent();
+            if (iter.node->leaf()) {
+                iter.node = nullptr;
+                break;
+            }
+        }
+        return iter;
+    }
+
+    template <typename P>
+    template <typename... Args>
+    inline auto btree<P>::internal_emplace(iterator iter, Args &&... args)
+        -> iterator {
+        if (!iter.node->leaf()) {
+            // We can't insert on an internal node. Instead, we'll insert after the
+            // previous value which is guaranteed to be on a leaf node.
+            --iter;
+            ++iter.position;
+        }
+        const int max_count = iter.node->max_count();
+        if (iter.node->count() == max_count) {
+            // Make room in the leaf for the new item.
+            if (max_count < kNodeValues) {
+                // Insertion into the root where the root is smaller than the full node
+                // size. Simply grow the size of the root node.
+                assert(iter.node == root());
+                iter.node =
+                    new_leaf_root_node((std::min<int>)(kNodeValues, 2 * max_count));
+                iter.node->swap(root(), mutable_allocator());
+                delete_leaf_node(root());
+                mutable_root() = iter.node;
+                rightmost_ = iter.node;
+            } else {
+                rebalance_or_split(&iter);
+            }
+        }
+        iter.node->emplace_value(iter.position, mutable_allocator(),
+                                 std::forward<Args>(args)...);
+        ++size_;
+        return iter;
+    }
+
+    template <typename P>
+    template <typename K>
+    inline auto btree<P>::internal_locate(const K &key) const
+        -> SearchResult<iterator, is_key_compare_to::value> {
+        return internal_locate_impl(key, is_key_compare_to());
+    }
+
+    template <typename P>
+    template <typename K>
+    inline auto btree<P>::internal_locate_impl(
+        const K &key, std::false_type /* IsCompareTo */) const
+        -> SearchResult<iterator, false> {
+        iterator iter(const_cast<node_type *>(root()), 0);
+        for (;;) {
+            iter.position = iter.node->lower_bound(key, key_comp()).value;
+            // NOTE: we don't need to walk all the way down the tree if the keys are
+            // equal, but determining equality would require doing an extra comparison
+            // on each node on the way down, and we will need to go all the way to the
+            // leaf node in the expected case.
+            if (iter.node->leaf()) {
+                break;
+            }
+            iter.node = iter.node->child(iter.position);
+        }
+        return {iter};
+    }
+
+    template <typename P>
+    template <typename K>
+    inline auto btree<P>::internal_locate_impl(
+        const K &key, std::true_type /* IsCompareTo */) const
+        -> SearchResult<iterator, true> {
+        iterator iter(const_cast<node_type *>(root()), 0);
+        for (;;) {
+            SearchResult<int, true> res = iter.node->lower_bound(key, key_comp());
+            iter.position = res.value;
+            if (res.match == MatchKind::kEq) {
+                return {iter, MatchKind::kEq};
+            }
+            if (iter.node->leaf()) {
+                break;
+            }
+            iter.node = iter.node->child(iter.position);
+        }
+        return {iter, MatchKind::kNe};
+    }
+
+    template <typename P>
+    template <typename K>
+    auto btree<P>::internal_lower_bound(const K &key) const -> iterator {
+        iterator iter(const_cast<node_type *>(root()), 0);
+        for (;;) {
+            iter.position = iter.node->lower_bound(key, key_comp()).value;
+            if (iter.node->leaf()) {
+                break;
+            }
+            iter.node = iter.node->child(iter.position);
+        }
+        return internal_last(iter);
+    }
+
+    template <typename P>
+    template <typename K>
+    auto btree<P>::internal_upper_bound(const K &key) const -> iterator {
+        iterator iter(const_cast<node_type *>(root()), 0);
+        for (;;) {
+            iter.position = iter.node->upper_bound(key, key_comp());
+            if (iter.node->leaf()) {
+                break;
+            }
+            iter.node = iter.node->child(iter.position);
+        }
+        return internal_last(iter);
+    }
+
+    template <typename P>
+    template <typename K>
+    auto btree<P>::internal_find(const K &key) const -> iterator {
+        auto res = internal_locate(key);
+        if (res.HasMatch()) {
+            if (res.IsEq()) {
+                return res.value;
+            }
+        } else {
+            const iterator iter = internal_last(res.value);
+            if (iter.node != nullptr && !compare_keys(key, iter.key())) {
+                return iter;
+            }
+        }
+        return {nullptr, 0};
+    }
+
+    template <typename P>
+    void btree<P>::internal_clear(node_type *node) {
+        if (!node->leaf()) {
+            for (int i = 0; i <= node->count(); ++i) {
+                internal_clear(node->child(i));
+            }
+            delete_internal_node(node);
+        } else {
+            delete_leaf_node(node);
+        }
+    }
+
+    template <typename P>
+    int btree<P>::internal_verify(
+        const node_type *node, const key_type *lo, const key_type *hi) const {
+        assert(node->count() > 0);
+        assert(node->count() <= node->max_count());
+        if (lo) {
+            assert(!compare_keys(node->key(0), *lo));
+        }
+        if (hi) {
+            assert(!compare_keys(*hi, node->key(node->count() - 1)));
+        }
+        for (int i = 1; i < node->count(); ++i) {
+            assert(!compare_keys(node->key(i), node->key(i - 1)));
+        }
+        int count = node->count();
+        if (!node->leaf()) {
+            for (int i = 0; i <= node->count(); ++i) {
+                assert(node->child(i) != nullptr);
+                assert(node->child(i)->parent() == node);
+                assert(node->child(i)->position() == i);
+                count += internal_verify(
+                    node->child(i),
+                    (i == 0) ? lo : &node->key(i - 1),
+                    (i == node->count()) ? hi : &node->key(i));
+            }
+        }
+        return count;
+    }
+
+    // A common base class for btree_set, btree_map, btree_multiset, and btree_multimap.
+    // ---------------------------------------------------------------------------------
+    template <typename Tree>
+    class btree_container {
+        using params_type = typename Tree::params_type;
+
+    protected:
+        // Alias used for heterogeneous lookup functions.
+        // `key_arg<K>` evaluates to `K` when the functors are transparent and to
+        // `key_type` otherwise. It permits template argument deduction on `K` for the
+        // transparent case.
+        template <class K>
+        using key_arg =
+            typename KeyArg<IsTransparent<typename Tree::key_compare>::value>::
+            template type<K, typename Tree::key_type>;
+
+    public:
+        using key_type = typename Tree::key_type;
+        using value_type = typename Tree::value_type;
+        using size_type = typename Tree::size_type;
+        using difference_type = typename Tree::difference_type;
+        using key_compare = typename Tree::key_compare;
+        using value_compare = typename Tree::value_compare;
+        using allocator_type = typename Tree::allocator_type;
+        using reference = typename Tree::reference;
+        using const_reference = typename Tree::const_reference;
+        using pointer = typename Tree::pointer;
+        using const_pointer = typename Tree::const_pointer;
+        using iterator = typename Tree::iterator;
+        using const_iterator = typename Tree::const_iterator;
+        using reverse_iterator = typename Tree::reverse_iterator;
+        using const_reverse_iterator = typename Tree::const_reverse_iterator;
+        using node_type = typename Tree::node_handle_type;
+
+        // Constructors/assignments.
+        btree_container() : tree_(key_compare(), allocator_type()) {}
+        explicit btree_container(const key_compare &comp,
+                                 const allocator_type &alloc = allocator_type())
+            : tree_(comp, alloc) {}
+        btree_container(const btree_container &x) = default;
+        btree_container(btree_container &&x) noexcept = default;
+        btree_container &operator=(const btree_container &x) = default;
+        btree_container &operator=(btree_container &&x) noexcept(
+            std::is_nothrow_move_assignable<Tree>::value) = default;
+
+        // Iterator routines.
+        iterator begin()                       { return tree_.begin(); }
+        const_iterator begin() const           { return tree_.begin(); }
+        const_iterator cbegin() const          { return tree_.begin(); }
+        iterator end()                         { return tree_.end(); }
+        const_iterator end() const             { return tree_.end(); }
+        const_iterator cend() const            { return tree_.end(); }
+        reverse_iterator rbegin()              { return tree_.rbegin(); }
+        const_reverse_iterator rbegin() const  { return tree_.rbegin(); }
+        const_reverse_iterator crbegin() const { return tree_.rbegin(); }
+        reverse_iterator rend()                { return tree_.rend(); }
+        const_reverse_iterator rend() const    { return tree_.rend(); }
+        const_reverse_iterator crend() const   { return tree_.rend(); }
+
+        // Lookup routines.
+        template <typename K = key_type>
+        iterator find(const key_arg<K> &key) {
+            return tree_.find(key);
+        }
+        template <typename K = key_type>
+        const_iterator find(const key_arg<K> &key) const { return tree_.find(key); }
+
+        template <typename K = key_type>
+        bool contains(const key_arg<K> &key) const { return find(key) != end(); }
+
+        template <typename K = key_type>
+        iterator lower_bound(const key_arg<K> &key) { return tree_.lower_bound(key); }
+
+        template <typename K = key_type>
+        const_iterator lower_bound(const key_arg<K> &key) const { return tree_.lower_bound(key); }
+
+        template <typename K = key_type>
+        iterator upper_bound(const key_arg<K> &key) { return tree_.upper_bound(key); }
+
+        template <typename K = key_type>
+        const_iterator upper_bound(const key_arg<K> &key) const { return tree_.upper_bound(key); }
+
+        template <typename K = key_type>
+        std::pair<iterator, iterator> equal_range(const key_arg<K> &key) { return tree_.equal_range(key); }
+
+        template <typename K = key_type>
+        std::pair<const_iterator, const_iterator> equal_range(
+            const key_arg<K> &key) const {
+            return tree_.equal_range(key);
+        }
+
+        iterator erase(const_iterator iter) { return tree_.erase(iterator(iter)); }
+        iterator erase(iterator iter)       { return tree_.erase(iter); }
+        iterator erase(const_iterator first, const_iterator last) {
+            return tree_.erase(iterator(first), iterator(last)).second;
+        }
+
+        node_type extract(iterator position) {
+            // Use Move instead of Transfer, because the rebalancing code expects to
+            // have a valid object to scribble metadata bits on top of.
+            auto node = CommonAccess::Move<node_type>(get_allocator(), position.slot());
+            erase(position);
+            return node;
+        }
+
+        node_type extract(const_iterator position) {
+            return extract(iterator(position));
+        }
+
+    public:
+        void clear() { tree_.clear(); }
+        void swap(btree_container &x) { tree_.swap(x.tree_); }
+        void verify() const { tree_.verify(); }
+
+        size_type size() const { return tree_.size(); }
+        size_type max_size() const { return tree_.max_size(); }
+        bool empty() const { return tree_.empty(); }
+
+        friend bool operator==(const btree_container &x, const btree_container &y) {
+            if (x.size() != y.size()) return false;
+            return std::equal(x.begin(), x.end(), y.begin());
+        }
+
+        friend bool operator!=(const btree_container &x, const btree_container &y) { return !(x == y); }
+
+        friend bool operator<(const btree_container &x, const btree_container &y) {
+            return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
+        }
+
+        friend bool operator>(const btree_container &x, const btree_container &y) { return y < x; }
+
+        friend bool operator<=(const btree_container &x, const btree_container &y) { return !(y < x); }
+
+        friend bool operator>=(const btree_container &x, const btree_container &y) { return !(x < y); }
+
+        // The allocator used by the btree.
+        allocator_type get_allocator() const { return tree_.get_allocator(); }
+
+        // The key comparator used by the btree.
+        key_compare key_comp() const { return tree_.key_comp(); }
+        value_compare value_comp() const { return tree_.value_comp(); }
+
+        // Support absl::Hash.
+        template <typename State>
+        friend State AbslHashValue(State h, const btree_container &b) {
+            for (const auto &v : b) {
+                h = State::combine(std::move(h), v);
+            }
+            return State::combine(std::move(h), b.size());
+        }
+
+    protected:
+        Tree tree_;
+    };
+
+    // A common base class for btree_set and btree_map.
+    // -----------------------------------------------
+    template <typename Tree>
+    class btree_set_container : public btree_container<Tree> {
+        using super_type = btree_container<Tree>;
+        using params_type = typename Tree::params_type;
+        using init_type = typename params_type::init_type;
+        using is_key_compare_to = typename params_type::is_key_compare_to;
+        friend class BtreeNodePeer;
+
+    protected:
+        template <class K>
+        using key_arg = typename super_type::template key_arg<K>;
+
+    public:
+        using key_type = typename Tree::key_type;
+        using value_type = typename Tree::value_type;
+        using size_type = typename Tree::size_type;
+        using key_compare = typename Tree::key_compare;
+        using allocator_type = typename Tree::allocator_type;
+        using iterator = typename Tree::iterator;
+        using const_iterator = typename Tree::const_iterator;
+        using node_type = typename super_type::node_type;
+        using insert_return_type = InsertReturnType<iterator, node_type>;
+        using super_type::super_type;
+        btree_set_container() {}
+
+        template <class InputIterator>
+        btree_set_container(InputIterator b, InputIterator e,
+                            const key_compare &comp = key_compare(),
+                            const allocator_type &alloc = allocator_type())
+            : super_type(comp, alloc) {
+            insert(b, e);
+        }
+
+        btree_set_container(std::initializer_list<init_type> init,
+                            const key_compare &comp = key_compare(),
+                            const allocator_type &alloc = allocator_type())
+            : btree_set_container(init.begin(), init.end(), comp, alloc) {}
+
+        // Lookup routines.
+        template <typename K = key_type>
+        size_type count(const key_arg<K> &key) const {
+            return this->tree_.count_unique(key);
+        }
+
+        // Insertion routines.
+        std::pair<iterator, bool> insert(const value_type &x) {
+            return this->tree_.insert_unique(params_type::key(x), x);
+        }
+        std::pair<iterator, bool> insert(value_type &&x) {
+            return this->tree_.insert_unique(params_type::key(x), std::move(x));
+        }
+        template <typename... Args>
+        std::pair<iterator, bool> emplace(Args &&... args) {
+            init_type v(std::forward<Args>(args)...);
+            return this->tree_.insert_unique(params_type::key(v), std::move(v));
+        }
+        iterator insert(const_iterator position, const value_type &x) {
+            return this->tree_
+                .insert_hint_unique(iterator(position), params_type::key(x), x)
+                .first;
+        }
+        iterator insert(const_iterator position, value_type &&x) {
+            return this->tree_
+                .insert_hint_unique(iterator(position), params_type::key(x),
+                                    std::move(x))
+                .first;
+        }
+
+        template <typename... Args>
+        iterator emplace_hint(const_iterator position, Args &&... args) {
+            init_type v(std::forward<Args>(args)...);
+            return this->tree_
+                .insert_hint_unique(iterator(position), params_type::key(v),
+                                    std::move(v))
+                .first;
+        }
+
+        template <typename InputIterator>
+        void insert(InputIterator b, InputIterator e) {
+            this->tree_.insert_iterator_unique(b, e);
+        }
+
+        void insert(std::initializer_list<init_type> init) {
+            this->tree_.insert_iterator_unique(init.begin(), init.end());
+        }
+
+        insert_return_type insert(node_type &&node) {
+            if (!node) return {this->end(), false, node_type()};
+            std::pair<iterator, bool> res =
+                this->tree_.insert_unique(params_type::key(CommonAccess::GetSlot(node)),
+                                          CommonAccess::GetSlot(node));
+            if (res.second) {
+                CommonAccess::Destroy(&node);
+                return {res.first, true, node_type()};
+            } else {
+                return {res.first, false, std::move(node)};
+            }
+        }
+
+        iterator insert(const_iterator hint, node_type &&node) {
+            if (!node) return this->end();
+            std::pair<iterator, bool> res = this->tree_.insert_hint_unique(
+                iterator(hint), params_type::key(CommonAccess::GetSlot(node)),
+                CommonAccess::GetSlot(node));
+            if (res.second) CommonAccess::Destroy(&node);
+            return res.first;
+        }
+
+        template <typename K = key_type>
+        size_type erase(const key_arg<K> &key) { return this->tree_.erase_unique(key); }
+        using super_type::erase;
+
+        template <typename K = key_type>
+        node_type extract(const key_arg<K> &key) {
+            auto it = this->find(key);
+            return it == this->end() ? node_type() : extract(it);
+        }
+
+        using super_type::extract;
+
+        // Merge routines.
+        // Moves elements from `src` into `this`. If the element already exists in
+        // `this`, it is left unmodified in `src`.
+        template <
+            typename T,
+            typename phmap::enable_if_t<
+                phmap::conjunction<
+                    std::is_same<value_type, typename T::value_type>,
+                    std::is_same<allocator_type, typename T::allocator_type>,
+                    std::is_same<typename params_type::is_map_container,
+                                 typename T::params_type::is_map_container>>::value,
+                int> = 0>
+            void merge(btree_container<T> &src) {  // NOLINT
+            for (auto src_it = src.begin(); src_it != src.end();) {
+                if (insert(std::move(*src_it)).second) {
+                    src_it = src.erase(src_it);
+                } else {
+                    ++src_it;
+                }
+            }
+        }
+
+        template <
+            typename T,
+            typename phmap::enable_if_t<
+                phmap::conjunction<
+                    std::is_same<value_type, typename T::value_type>,
+                    std::is_same<allocator_type, typename T::allocator_type>,
+                    std::is_same<typename params_type::is_map_container,
+                                 typename T::params_type::is_map_container>>::value,
+                int> = 0>
+            void merge(btree_container<T> &&src) {
+            merge(src);
+        }
+    };
+
+    // Base class for btree_map.
+    // -------------------------
+    template <typename Tree>
+    class btree_map_container : public btree_set_container<Tree> {
+        using super_type = btree_set_container<Tree>;
+        using params_type = typename Tree::params_type;
+
+    protected:
+        template <class K>
+        using key_arg = typename super_type::template key_arg<K>;
+
+    public:
+        using key_type = typename Tree::key_type;
+        using mapped_type = typename params_type::mapped_type;
+        using value_type = typename Tree::value_type;
+        using key_compare = typename Tree::key_compare;
+        using allocator_type = typename Tree::allocator_type;
+        using iterator = typename Tree::iterator;
+        using const_iterator = typename Tree::const_iterator;
+
+        // Inherit constructors.
+        using super_type::super_type;
+        btree_map_container() {}
+
+        // Insertion routines.
+        template <typename... Args>
+        std::pair<iterator, bool> try_emplace(const key_type &k, Args &&... args) {
+            return this->tree_.insert_unique(
+                k, std::piecewise_construct, std::forward_as_tuple(k),
+                std::forward_as_tuple(std::forward<Args>(args)...));
+        }
+        template <typename... Args>
+        std::pair<iterator, bool> try_emplace(key_type &&k, Args &&... args) {
+            // Note: `key_ref` exists to avoid a ClangTidy warning about moving from `k`
+            // and then using `k` unsequenced. This is safe because the move is into a
+            // forwarding reference and insert_unique guarantees that `key` is never
+            // referenced after consuming `args`.
+            const key_type& key_ref = k;
+            return this->tree_.insert_unique(
+                key_ref, std::piecewise_construct, std::forward_as_tuple(std::move(k)),
+                std::forward_as_tuple(std::forward<Args>(args)...));
+        }
+        template <typename... Args>
+        iterator try_emplace(const_iterator hint, const key_type &k,
+                             Args &&... args) {
+            return this->tree_
+                .insert_hint_unique(iterator(hint), k, std::piecewise_construct,
+                                    std::forward_as_tuple(k),
+                                    std::forward_as_tuple(std::forward<Args>(args)...))
+                .first;
+        }
+        template <typename... Args>
+        iterator try_emplace(const_iterator hint, key_type &&k, Args &&... args) {
+            // Note: `key_ref` exists to avoid a ClangTidy warning about moving from `k`
+            // and then using `k` unsequenced. This is safe because the move is into a
+            // forwarding reference and insert_hint_unique guarantees that `key` is
+            // never referenced after consuming `args`.
+            const key_type& key_ref = k;
+            return this->tree_
+                .insert_hint_unique(iterator(hint), key_ref, std::piecewise_construct,
+                                    std::forward_as_tuple(std::move(k)),
+                                    std::forward_as_tuple(std::forward<Args>(args)...))
+                .first;
+        }
+        mapped_type &operator[](const key_type &k) {
+            return try_emplace(k).first->second;
+        }
+        mapped_type &operator[](key_type &&k) {
+            return try_emplace(std::move(k)).first->second;
+        }
+
+        template <typename K = key_type>
+        mapped_type &at(const key_arg<K> &key) {
+            auto it = this->find(key);
+            if (it == this->end())
+                base_internal::ThrowStdOutOfRange("phmap::btree_map::at");
+            return it->second;
+        }
+        template <typename K = key_type>
+        const mapped_type &at(const key_arg<K> &key) const {
+            auto it = this->find(key);
+            if (it == this->end())
+                base_internal::ThrowStdOutOfRange("phmap::btree_map::at");
+            return it->second;
+        }
+    };
+
+    // A common base class for btree_multiset and btree_multimap.
+    template <typename Tree>
+    class btree_multiset_container : public btree_container<Tree> {
+        using super_type = btree_container<Tree>;
+        using params_type = typename Tree::params_type;
+        using init_type = typename params_type::init_type;
+        using is_key_compare_to = typename params_type::is_key_compare_to;
+
+        template <class K>
+        using key_arg = typename super_type::template key_arg<K>;
+
+    public:
+        using key_type = typename Tree::key_type;
+        using value_type = typename Tree::value_type;
+        using size_type = typename Tree::size_type;
+        using key_compare = typename Tree::key_compare;
+        using allocator_type = typename Tree::allocator_type;
+        using iterator = typename Tree::iterator;
+        using const_iterator = typename Tree::const_iterator;
+        using node_type = typename super_type::node_type;
+
+        // Inherit constructors.
+        using super_type::super_type;
+        btree_multiset_container() {}
+
+        // Range constructor.
+        template <class InputIterator>
+        btree_multiset_container(InputIterator b, InputIterator e,
+                                 const key_compare &comp = key_compare(),
+                                 const allocator_type &alloc = allocator_type())
+            : super_type(comp, alloc) {
+            insert(b, e);
+        }
+
+        // Initializer list constructor.
+        btree_multiset_container(std::initializer_list<init_type> init,
+                                 const key_compare &comp = key_compare(),
+                                 const allocator_type &alloc = allocator_type())
+            : btree_multiset_container(init.begin(), init.end(), comp, alloc) {}
+
+        // Lookup routines.
+        template <typename K = key_type>
+        size_type count(const key_arg<K> &key) const {
+            return this->tree_.count_multi(key);
+        }
+
+        // Insertion routines.
+        iterator insert(const value_type &x) { return this->tree_.insert_multi(x); }
+        iterator insert(value_type &&x) {
+            return this->tree_.insert_multi(std::move(x));
+        }
+        iterator insert(const_iterator position, const value_type &x) {
+            return this->tree_.insert_hint_multi(iterator(position), x);
+        }
+        iterator insert(const_iterator position, value_type &&x) {
+            return this->tree_.insert_hint_multi(iterator(position), std::move(x));
+        }
+        template <typename InputIterator>
+        void insert(InputIterator b, InputIterator e) {
+            this->tree_.insert_iterator_multi(b, e);
+        }
+        void insert(std::initializer_list<init_type> init) {
+            this->tree_.insert_iterator_multi(init.begin(), init.end());
+        }
+        template <typename... Args>
+        iterator emplace(Args &&... args) {
+            return this->tree_.insert_multi(init_type(std::forward<Args>(args)...));
+        }
+        template <typename... Args>
+        iterator emplace_hint(const_iterator position, Args &&... args) {
+            return this->tree_.insert_hint_multi(
+                iterator(position), init_type(std::forward<Args>(args)...));
+        }
+        iterator insert(node_type &&node) {
+            if (!node) return this->end();
+            iterator res =
+                this->tree_.insert_multi(params_type::key(CommonAccess::GetSlot(node)),
+                                         CommonAccess::GetSlot(node));
+            CommonAccess::Destroy(&node);
+            return res;
+        }
+        iterator insert(const_iterator hint, node_type &&node) {
+            if (!node) return this->end();
+            iterator res = this->tree_.insert_hint_multi(
+                iterator(hint),
+                std::move(params_type::element(CommonAccess::GetSlot(node))));
+            CommonAccess::Destroy(&node);
+            return res;
+        }
+
+        // Deletion routines.
+        template <typename K = key_type>
+        size_type erase(const key_arg<K> &key) {
+            return this->tree_.erase_multi(key);
+        }
+        using super_type::erase;
+
+        // Node extraction routines.
+        template <typename K = key_type>
+        node_type extract(const key_arg<K> &key) {
+            auto it = this->find(key);
+            return it == this->end() ? node_type() : extract(it);
+        }
+        using super_type::extract;
+
+        // Merge routines.
+        // Moves all elements from `src` into `this`.
+        template <
+            typename T,
+            typename phmap::enable_if_t<
+                phmap::conjunction<
+                    std::is_same<value_type, typename T::value_type>,
+                    std::is_same<allocator_type, typename T::allocator_type>,
+                    std::is_same<typename params_type::is_map_container,
+                                 typename T::params_type::is_map_container>>::value,
+                int> = 0>
+            void merge(btree_container<T> &src) {  // NOLINT
+            insert(std::make_move_iterator(src.begin()),
+                   std::make_move_iterator(src.end()));
+            src.clear();
+        }
+
+        template <
+            typename T,
+            typename phmap::enable_if_t<
+                phmap::conjunction<
+                    std::is_same<value_type, typename T::value_type>,
+                    std::is_same<allocator_type, typename T::allocator_type>,
+                    std::is_same<typename params_type::is_map_container,
+                                 typename T::params_type::is_map_container>>::value,
+                int> = 0>
+            void merge(btree_container<T> &&src) {
+            merge(src);
+        }
+    };
+
+    // A base class for btree_multimap.
+    template <typename Tree>
+    class btree_multimap_container : public btree_multiset_container<Tree> {
+        using super_type = btree_multiset_container<Tree>;
+        using params_type = typename Tree::params_type;
+
+    public:
+        using mapped_type = typename params_type::mapped_type;
+
+        // Inherit constructors.
+        using super_type::super_type;
+        btree_multimap_container() {}
+    };
+
+}  // namespace priv
+
+
+
+    // ----------------------------------------------------------------------
+    //  btree_set - default values in phmap_fwd_decl.h
+    // ----------------------------------------------------------------------
+    template <typename Key, typename Compare, typename Alloc>
+    class btree_set : public priv::btree_set_container<
+        priv::btree<priv::set_params<
+            Key, Compare, Alloc, /*TargetNodeSize=*/ 256, /*Multi=*/ false>>> 
+    {
+        using Base = typename btree_set::btree_set_container;
+
+    public:
+        btree_set() {}
+        using Base::Base;
+        using Base::begin;
+        using Base::cbegin;
+        using Base::end;
+        using Base::cend;
+        using Base::empty;
+        using Base::max_size;
+        using Base::size;
+        using Base::clear;
+        using Base::erase;
+        using Base::insert;
+        using Base::emplace;
+        using Base::emplace_hint;
+        using Base::extract;
+        using Base::merge;
+        using Base::swap;
+        using Base::contains;
+        using Base::count;
+        using Base::equal_range;
+        using Base::find;
+        using Base::get_allocator;
+        using Base::key_comp;
+        using Base::value_comp;
+    };
+
+    // Swaps the contents of two `phmap::btree_set` containers.
+    // -------------------------------------------------------
+    template <typename K, typename C, typename A>
+    void swap(btree_set<K, C, A> &x, btree_set<K, C, A> &y) {
+        return x.swap(y);
+    }
+
+    // Erases all elements that satisfy the predicate pred from the container.
+    // ----------------------------------------------------------------------
+    template <typename K, typename C, typename A, typename Pred>
+    void erase_if(btree_set<K, C, A> &set, Pred pred) {
+        for (auto it = set.begin(); it != set.end();) {
+            if (pred(*it)) {
+                it = set.erase(it);
+            } else {
+                ++it;
+            }
+        }
+    }
+
+    // ----------------------------------------------------------------------
+    //  btree_multiset - default values in phmap_fwd_decl.h
+    // ----------------------------------------------------------------------
+    template <typename Key, typename Compare,  typename Alloc>
+        class btree_multiset : public priv::btree_multiset_container<
+        priv::btree<priv::set_params<
+             Key, Compare, Alloc, /*TargetNodeSize=*/ 256, /*Multi=*/ true>>> 
+    {
+        using Base = typename btree_multiset::btree_multiset_container;
+        
+    public:
+        btree_multiset() {}
+        using Base::Base;
+        using Base::begin;
+        using Base::cbegin;
+        using Base::end;
+        using Base::cend;
+        using Base::empty;
+        using Base::max_size;
+        using Base::size;
+        using Base::clear;
+        using Base::erase;
+        using Base::insert;
+        using Base::emplace;
+        using Base::emplace_hint;
+        using Base::extract;
+        using Base::merge;
+        using Base::swap;
+        using Base::contains;
+        using Base::count;
+        using Base::equal_range;
+        using Base::find;
+        using Base::get_allocator;
+        using Base::key_comp;
+        using Base::value_comp;
+    };
+
+    // Swaps the contents of two `phmap::btree_multiset` containers.
+    // ------------------------------------------------------------
+    template <typename K, typename C, typename A>
+    void swap(btree_multiset<K, C, A> &x, btree_multiset<K, C, A> &y) {
+        return x.swap(y);
+    }
+    
+    // Erases all elements that satisfy the predicate pred from the container.
+    // ----------------------------------------------------------------------
+    template <typename K, typename C, typename A, typename Pred>
+    void erase_if(btree_multiset<K, C, A> &set, Pred pred) {
+        for (auto it = set.begin(); it != set.end();) {
+            if (pred(*it)) {
+                it = set.erase(it);
+            } else {
+                ++it;
+            }
+        }
+    }
+
+
+    // ----------------------------------------------------------------------
+    //  btree_map - default values in phmap_fwd_decl.h
+    // ----------------------------------------------------------------------
+    template <typename Key, typename Value, typename Compare,  typename Alloc>
+        class btree_map : public priv::btree_map_container<
+        priv::btree<priv::map_params<
+             Key, Value, Compare, Alloc, /*TargetNodeSize=*/ 256, /*Multi=*/ false>>> 
+    {
+        using Base = typename btree_map::btree_map_container;
+
+    public:
+        btree_map() {}
+        using Base::Base;
+        using Base::begin;
+        using Base::cbegin;
+        using Base::end;
+        using Base::cend;
+        using Base::empty;
+        using Base::max_size;
+        using Base::size;
+        using Base::clear;
+        using Base::erase;
+        using Base::insert;
+        using Base::emplace;
+        using Base::emplace_hint;
+        using Base::try_emplace;
+        using Base::extract;
+        using Base::merge;
+        using Base::swap;
+        using Base::at;
+        using Base::contains;
+        using Base::count;
+        using Base::equal_range;
+        using Base::find;
+        using Base::operator[];
+        using Base::get_allocator;
+        using Base::key_comp;
+        using Base::value_comp;
+    };
+
+    // Swaps the contents of two `phmap::btree_map` containers.
+    // -------------------------------------------------------
+    template <typename K, typename V, typename C, typename A>
+    void swap(btree_map<K, V, C, A> &x, btree_map<K, V, C, A> &y) {
+        return x.swap(y);
+    }
+
+    // ----------------------------------------------------------------------
+    template <typename K, typename V, typename C, typename A, typename Pred>
+    void erase_if(btree_map<K, V, C, A> &map, Pred pred) {
+        for (auto it = map.begin(); it != map.end();) {
+            if (pred(*it)) {
+                it = map.erase(it);
+            } else {
+                ++it;
+            }
+        }
+    }
+
+    // ----------------------------------------------------------------------
+    //  btree_multimap - default values in phmap_fwd_decl.h
+    // ----------------------------------------------------------------------
+    template <typename Key, typename Value, typename Compare, typename Alloc>
+        class btree_multimap : public priv::btree_multimap_container<
+        priv::btree<priv::map_params<
+              Key, Value, Compare, Alloc, /*TargetNodeSize=*/ 256, /*Multi=*/ true>>> 
+    {
+        using Base = typename btree_multimap::btree_multimap_container;
+
+    public:
+        btree_multimap() {}
+        using Base::Base;
+        using Base::begin;
+        using Base::cbegin;
+        using Base::end;
+        using Base::cend;
+        using Base::empty;
+        using Base::max_size;
+        using Base::size;
+        using Base::clear;
+        using Base::erase;
+        using Base::insert;
+        using Base::emplace;
+        using Base::emplace_hint;
+        using Base::extract;
+        using Base::merge;
+        using Base::swap;
+        using Base::contains;
+        using Base::count;
+        using Base::equal_range;
+        using Base::find;
+        using Base::get_allocator;
+        using Base::key_comp;
+        using Base::value_comp;
+    };
+
+    // Swaps the contents of two `phmap::btree_multimap` containers.
+    // ------------------------------------------------------------
+    template <typename K, typename V, typename C, typename A>
+    void swap(btree_multimap<K, V, C, A> &x, btree_multimap<K, V, C, A> &y) {
+        return x.swap(y);
+    }
+
+    // Erases all elements that satisfy the predicate pred from the container.
+    // ----------------------------------------------------------------------
+    template <typename K, typename V, typename C, typename A, typename Pred>
+    void erase_if(btree_multimap<K, V, C, A> &map, Pred pred) {
+        for (auto it = map.begin(); it != map.end();) {
+            if (pred(*it)) {
+                it = map.erase(it);
+            } else {
+                ++it;
+            }
+        }
+    }
+
+
+}  // namespace btree
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+
+#endif  // PHMAP_BTREE_BTREE_CONTAINER_H_
diff --git a/lib/parallel_hashmap/parallel_hashmap/conanfile.py b/lib/parallel_hashmap/parallel_hashmap/conanfile.py
new file mode 100644
index 0000000..c046377
--- /dev/null
+++ b/lib/parallel_hashmap/parallel_hashmap/conanfile.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from conans import ConanFile, tools
+import os
+
+class SparseppConan(ConanFile):
+    name = "parallel_hashmap"
+    version = "1.27"
+    description = "A header-only, very fast and memory-friendly hash map"
+    
+    # Indicates License type of the packaged library
+    license = "https://github.com/greg7mdp/parallel-hashmap/blob/master/LICENSE"
+    
+    # Packages the license for the conanfile.py
+    exports = ["LICENSE"]
+    
+    # Custom attributes for Bincrafters recipe conventions
+    source_subfolder = "source_subfolder"
+    
+    def source(self):
+        source_url = "https://github.com/greg7mdp/parallel-hashmap"
+        tools.get("{0}/archive/{1}.tar.gz".format(source_url, self.version))
+        extracted_dir = self.name + "-" + self.version
+
+        #Rename to "source_folder" is a convention to simplify later steps
+        os.rename(extracted_dir, self.source_subfolder)
+
+
+    def package(self):
+        include_folder = os.path.join(self.source_subfolder, "parallel_hashmap")
+        self.copy(pattern="LICENSE")
+        self.copy(pattern="*", dst="include/parallel_hashmap", src=include_folder)
+
+    def package_id(self):
+        self.info.header_only()
diff --git a/lib/parallel_hashmap/parallel_hashmap/meminfo.h b/lib/parallel_hashmap/parallel_hashmap/meminfo.h
new file mode 100644
index 0000000..872f3c6
--- /dev/null
+++ b/lib/parallel_hashmap/parallel_hashmap/meminfo.h
@@ -0,0 +1,195 @@
+#if !defined(spp_memory_h_guard)
+#define spp_memory_h_guard
+
+#include <cstdint>
+#include <cstring>
+#include <cstdlib>
+
+#if defined(_WIN32) || defined( __CYGWIN__)
+    #define SPP_WIN
+#endif
+
+#ifdef SPP_WIN
+    #include <windows.h>
+    #include <Psapi.h>
+    #undef min
+    #undef max
+#elif defined(__linux__)
+    #include <sys/types.h>
+    #include <sys/sysinfo.h>
+#elif defined(__FreeBSD__)
+    #include <paths.h>
+    #include <fcntl.h>
+    #include <kvm.h>
+    #include <unistd.h>
+    #include <sys/sysctl.h>
+    #include <sys/user.h>
+#endif
+
+namespace spp
+{
+    uint64_t GetSystemMemory();
+    uint64_t GetTotalMemoryUsed();
+    uint64_t GetProcessMemoryUsed();
+    uint64_t GetPhysicalMemory();
+
+    uint64_t GetSystemMemory()
+    {
+#ifdef SPP_WIN
+        MEMORYSTATUSEX memInfo;
+        memInfo.dwLength = sizeof(MEMORYSTATUSEX);
+        GlobalMemoryStatusEx(&memInfo);
+        return static_cast<uint64_t>(memInfo.ullTotalPageFile);
+#elif defined(__linux__)
+        struct sysinfo memInfo;
+        sysinfo (&memInfo);
+        auto totalVirtualMem = memInfo.totalram;
+
+        totalVirtualMem += memInfo.totalswap;
+        totalVirtualMem *= memInfo.mem_unit;
+        return static_cast<uint64_t>(totalVirtualMem);
+#elif defined(__FreeBSD__)
+        kvm_t *kd;
+        u_int pageCnt;
+        size_t pageCntLen = sizeof(pageCnt);
+        u_int pageSize;
+        struct kvm_swap kswap;
+        uint64_t totalVirtualMem;
+
+        pageSize = static_cast<u_int>(getpagesize());
+
+        sysctlbyname("vm.stats.vm.v_page_count", &pageCnt, &pageCntLen, NULL, 0);
+        totalVirtualMem = pageCnt * pageSize;
+
+        kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open");
+        kvm_getswapinfo(kd, &kswap, 1, 0);
+        kvm_close(kd);
+        totalVirtualMem += kswap.ksw_total * pageSize;
+
+        return totalVirtualMem;
+#else
+        return 0;
+#endif
+    }
+
+    uint64_t GetTotalMemoryUsed()
+    {
+#ifdef SPP_WIN
+        MEMORYSTATUSEX memInfo;
+        memInfo.dwLength = sizeof(MEMORYSTATUSEX);
+        GlobalMemoryStatusEx(&memInfo);
+        return static_cast<uint64_t>(memInfo.ullTotalPageFile - memInfo.ullAvailPageFile);
+#elif defined(__linux__)
+        struct sysinfo memInfo;
+        sysinfo(&memInfo);
+        auto virtualMemUsed = memInfo.totalram - memInfo.freeram;
+
+        virtualMemUsed += memInfo.totalswap - memInfo.freeswap;
+        virtualMemUsed *= memInfo.mem_unit;
+
+        return static_cast<uint64_t>(virtualMemUsed);
+#elif defined(__FreeBSD__)
+        kvm_t *kd;
+        u_int pageSize;
+        u_int pageCnt, freeCnt;
+        size_t pageCntLen = sizeof(pageCnt);
+        size_t freeCntLen = sizeof(freeCnt);
+        struct kvm_swap kswap;
+        uint64_t virtualMemUsed;
+
+        pageSize = static_cast<u_int>(getpagesize());
+
+        sysctlbyname("vm.stats.vm.v_page_count", &pageCnt, &pageCntLen, NULL, 0);
+        sysctlbyname("vm.stats.vm.v_free_count", &freeCnt, &freeCntLen, NULL, 0);
+        virtualMemUsed = (pageCnt - freeCnt) * pageSize;
+
+        kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open");
+        kvm_getswapinfo(kd, &kswap, 1, 0);
+        kvm_close(kd);
+        virtualMemUsed += kswap.ksw_used * pageSize;
+
+        return virtualMemUsed;
+#else
+        return 0;
+#endif
+    }
+
+    uint64_t GetProcessMemoryUsed()
+    {
+#ifdef SPP_WIN
+        PROCESS_MEMORY_COUNTERS_EX pmc;
+        GetProcessMemoryInfo(GetCurrentProcess(), reinterpret_cast<PPROCESS_MEMORY_COUNTERS>(&pmc), sizeof(pmc));
+        return static_cast<uint64_t>(pmc.PrivateUsage);
+#elif defined(__linux__)
+        auto parseLine = 
+            [](char* line)->int
+            {
+                auto i = strlen(line);
+				
+                while(*line < '0' || *line > '9') 
+                {
+                    line++;
+                }
+
+                line[i-3] = '\0';
+                i = atoi(line);
+                return i;
+            };
+
+        auto file = fopen("/proc/self/status", "r");
+        auto result = -1;
+        char line[128];
+
+        while(fgets(line, 128, file) != nullptr)
+        {
+            if(strncmp(line, "VmSize:", 7) == 0)
+            {
+                result = parseLine(line);
+                break;
+            }
+        }
+
+        fclose(file);
+        return static_cast<uint64_t>(result) * 1024;
+#elif defined(__FreeBSD__)
+        struct kinfo_proc info;
+        size_t infoLen = sizeof(info);
+        int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid() };
+
+        sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &infoLen, NULL, 0);
+        return static_cast<uint64_t>(info.ki_rssize * getpagesize());
+#else
+        return 0;
+#endif
+    }
+
+    uint64_t GetPhysicalMemory()
+    {
+#ifdef SPP_WIN
+        MEMORYSTATUSEX memInfo;
+        memInfo.dwLength = sizeof(MEMORYSTATUSEX);
+        GlobalMemoryStatusEx(&memInfo);
+        return static_cast<uint64_t>(memInfo.ullTotalPhys);
+#elif defined(__linux__)
+        struct sysinfo memInfo;
+        sysinfo(&memInfo);
+
+        auto totalPhysMem = memInfo.totalram;
+
+        totalPhysMem *= memInfo.mem_unit;
+        return static_cast<uint64_t>(totalPhysMem);
+#elif defined(__FreeBSD__)
+        u_long physMem;
+        size_t physMemLen = sizeof(physMem);
+        int mib[] = { CTL_HW, HW_PHYSMEM };
+
+        sysctl(mib, sizeof(mib) / sizeof(*mib), &physMem, &physMemLen, NULL, 0);
+        return physMem;
+#else
+        return 0;
+#endif
+    }
+
+}
+
+#endif // spp_memory_h_guard
diff --git a/lib/parallel_hashmap/parallel_hashmap/phmap.h b/lib/parallel_hashmap/parallel_hashmap/phmap.h
new file mode 100644
index 0000000..22b3cc8
--- /dev/null
+++ b/lib/parallel_hashmap/parallel_hashmap/phmap.h
@@ -0,0 +1,4544 @@
+#if !defined(phmap_h_guard_)
+#define phmap_h_guard_
+
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Includes work from abseil-cpp (https://github.com/abseil/abseil-cpp)
+// with modifications.
+// 
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ---------------------------------------------------------------------------
+
+#ifdef _MSC_VER
+    #pragma warning(push)  
+
+    #pragma warning(disable : 4127) // conditional expression is constant
+    #pragma warning(disable : 4324) // structure was padded due to alignment specifier
+    #pragma warning(disable : 4514) // unreferenced inline function has been removed
+    #pragma warning(disable : 4623) // default constructor was implicitly defined as deleted
+    #pragma warning(disable : 4625) // copy constructor was implicitly defined as deleted
+    #pragma warning(disable : 4626) // assignment operator was implicitly defined as deleted
+    #pragma warning(disable : 4710) // function not inlined
+    #pragma warning(disable : 4711) // selected for automatic inline expansion
+    #pragma warning(disable : 4820) // '6' bytes padding added after data member
+    #pragma warning(disable : 4868) // compiler may not enforce left-to-right evaluation order in braced initializer list
+    #pragma warning(disable : 5027) // move assignment operator was implicitly defined as deleted
+    #pragma warning(disable : 5045) // Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified
+#endif
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <array>
+#include <cassert>
+#include <atomic>
+
+#include "phmap_fwd_decl.h"
+#include "phmap_utils.h"
+#include "phmap_base.h"
+
+#if PHMAP_HAVE_STD_STRING_VIEW
+    #include <string_view>
+#endif
+
+namespace phmap {
+
+namespace priv {
+
+// --------------------------------------------------------------------------
+template <size_t Width>
+class probe_seq 
+{
+public:
+    probe_seq(size_t hashval, size_t mask) {
+        assert(((mask + 1) & mask) == 0 && "not a mask");
+        mask_ = mask;
+        offset_ = hashval & mask_;
+    }
+    size_t offset() const { return offset_; }
+    size_t offset(size_t i) const { return (offset_ + i) & mask_; }
+
+    void next() {
+        index_ += Width;
+        offset_ += index_;
+        offset_ &= mask_;
+    }
+    // 0-based probe index. The i-th probe in the probe sequence.
+    size_t getindex() const { return index_; }
+
+private:
+    size_t mask_;
+    size_t offset_;
+    size_t index_ = 0;
+};
+
+// --------------------------------------------------------------------------
+template <class ContainerKey, class Hash, class Eq>
+struct RequireUsableKey 
+{
+    template <class PassedKey, class... Args>
+    std::pair<
+        decltype(std::declval<const Hash&>()(std::declval<const PassedKey&>())),
+        decltype(std::declval<const Eq&>()(std::declval<const ContainerKey&>(),
+                                           std::declval<const PassedKey&>()))>*
+    operator()(const PassedKey&, const Args&...) const;
+};
+
+// --------------------------------------------------------------------------
+template <class E, class Policy, class Hash, class Eq, class... Ts>
+struct IsDecomposable : std::false_type {};
+
+template <class Policy, class Hash, class Eq, class... Ts>
+struct IsDecomposable<
+    phmap::void_t<decltype(
+        Policy::apply(RequireUsableKey<typename Policy::key_type, Hash, Eq>(),
+                      std::declval<Ts>()...))>,
+    Policy, Hash, Eq, Ts...> : std::true_type {};
+
+// TODO(alkis): Switch to std::is_nothrow_swappable when gcc/clang supports it.
+// --------------------------------------------------------------------------
+template <class T>
+constexpr bool IsNoThrowSwappable() {
+    using std::swap;
+    return noexcept(swap(std::declval<T&>(), std::declval<T&>()));
+}
+
+// --------------------------------------------------------------------------
+template <typename T>
+int TrailingZeros(T x) {
+    PHMAP_IF_CONSTEXPR(sizeof(T) == 8)
+        return base_internal::CountTrailingZerosNonZero64(static_cast<uint64_t>(x));
+    else
+        return base_internal::CountTrailingZerosNonZero32(static_cast<uint32_t>(x));
+}
+
+// --------------------------------------------------------------------------
+template <typename T>
+int LeadingZeros(T x) {
+    PHMAP_IF_CONSTEXPR(sizeof(T) == 8)
+        return base_internal::CountLeadingZeros64(static_cast<uint64_t>(x));
+    else
+        return base_internal::CountLeadingZeros32(static_cast<uint32_t>(x));
+}
+
+// --------------------------------------------------------------------------
+// An abstraction over a bitmask. It provides an easy way to iterate through the
+// indexes of the set bits of a bitmask.  When Shift=0 (platforms with SSE),
+// this is a true bitmask.  On non-SSE, platforms the arithematic used to
+// emulate the SSE behavior works in bytes (Shift=3) and leaves each bytes as
+// either 0x00 or 0x80.
+//
+// For example:
+//   for (int i : BitMask<uint32_t, 16>(0x5)) -> yields 0, 2
+//   for (int i : BitMask<uint64_t, 8, 3>(0x0000000080800000)) -> yields 2, 3
+// --------------------------------------------------------------------------
+template <class T, int SignificantBits, int Shift = 0>
+class BitMask 
+{
+    static_assert(std::is_unsigned<T>::value, "");
+    static_assert(Shift == 0 || Shift == 3, "");
+
+public:
+    // These are useful for unit tests (gunit).
+    using value_type = int;
+    using iterator = BitMask;
+    using const_iterator = BitMask;
+
+    explicit BitMask(T mask) : mask_(mask) {}
+    BitMask& operator++() {
+        mask_ &= (mask_ - 1);
+        return *this;
+    }
+    explicit operator bool() const { return mask_ != 0; }
+    int operator*() const { return LowestBitSet(); }
+    int LowestBitSet() const {
+        return priv::TrailingZeros(mask_) >> Shift;
+    }
+    int HighestBitSet() const {
+        return (sizeof(T) * CHAR_BIT - priv::LeadingZeros(mask_) -
+                1) >>
+            Shift;
+    }
+
+    BitMask begin() const { return *this; }
+    BitMask end() const { return BitMask(0); }
+
+    int TrailingZeros() const {
+        return priv::TrailingZeros(mask_) >> Shift;
+    }
+
+    int LeadingZeros() const {
+        constexpr int total_significant_bits = SignificantBits << Shift;
+        constexpr int extra_bits = sizeof(T) * 8 - total_significant_bits;
+        return priv::LeadingZeros(mask_ << extra_bits) >> Shift;
+    }
+
+private:
+    friend bool operator==(const BitMask& a, const BitMask& b) {
+        return a.mask_ == b.mask_;
+    }
+    friend bool operator!=(const BitMask& a, const BitMask& b) {
+        return a.mask_ != b.mask_;
+    }
+
+    T mask_;
+};
+
+// --------------------------------------------------------------------------
+using ctrl_t = signed char;
+using h2_t = uint8_t;
+
+// --------------------------------------------------------------------------
+// The values here are selected for maximum performance. See the static asserts
+// below for details.
+// --------------------------------------------------------------------------
+enum Ctrl : ctrl_t 
+{
+    kEmpty = -128,   // 0b10000000
+    kDeleted = -2,   // 0b11111110
+    kSentinel = -1,  // 0b11111111
+};
+
+static_assert(
+    kEmpty & kDeleted & kSentinel & 0x80,
+    "Special markers need to have the MSB to make checking for them efficient");
+static_assert(kEmpty < kSentinel && kDeleted < kSentinel,
+              "kEmpty and kDeleted must be smaller than kSentinel to make the "
+              "SIMD test of IsEmptyOrDeleted() efficient");
+static_assert(kSentinel == -1,
+              "kSentinel must be -1 to elide loading it from memory into SIMD "
+              "registers (pcmpeqd xmm, xmm)");
+static_assert(kEmpty == -128,
+              "kEmpty must be -128 to make the SIMD check for its "
+              "existence efficient (psignb xmm, xmm)");
+static_assert(~kEmpty & ~kDeleted & kSentinel & 0x7F,
+              "kEmpty and kDeleted must share an unset bit that is not shared "
+              "by kSentinel to make the scalar test for MatchEmptyOrDeleted() "
+              "efficient");
+static_assert(kDeleted == -2,
+              "kDeleted must be -2 to make the implementation of "
+              "ConvertSpecialToEmptyAndFullToDeleted efficient");
+
+// --------------------------------------------------------------------------
+// A single block of empty control bytes for tables without any slots allocated.
+// This enables removing a branch in the hot path of find().
+// --------------------------------------------------------------------------
+inline ctrl_t* EmptyGroup() {
+  alignas(16) static constexpr ctrl_t empty_group[] = {
+      kSentinel, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty,
+      kEmpty,    kEmpty, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty};
+  return const_cast<ctrl_t*>(empty_group);
+}
+
+// --------------------------------------------------------------------------
+inline size_t HashSeed(const ctrl_t* ctrl) {
+  // The low bits of the pointer have little or no entropy because of
+  // alignment. We shift the pointer to try to use higher entropy bits. A
+  // good number seems to be 12 bits, because that aligns with page size.
+  return reinterpret_cast<uintptr_t>(ctrl) >> 12;
+}
+
+#ifdef PHMAP_NON_DETERMINISTIC
+
+inline size_t H1(size_t hashval, const ctrl_t* ctrl) {
+    // use ctrl_ pointer to add entropy to ensure
+    // non-deterministic iteration order.
+    return (hashval >> 7) ^ HashSeed(ctrl);
+}
+
+#else
+
+inline size_t H1(size_t hashval, const ctrl_t* ) {
+    return (hashval >> 7);
+}
+
+#endif
+
+
+inline ctrl_t H2(size_t hashval)       { return (ctrl_t)(hashval & 0x7F); }
+
+inline bool IsEmpty(ctrl_t c)          { return c == kEmpty; }
+inline bool IsFull(ctrl_t c)           { return c >= 0; }
+inline bool IsDeleted(ctrl_t c)        { return c == kDeleted; }
+inline bool IsEmptyOrDeleted(ctrl_t c) { return c < kSentinel; }
+
+#if PHMAP_HAVE_SSE2
+
+#ifdef _MSC_VER
+    #pragma warning(push)  
+    #pragma warning(disable : 4365) // conversion from 'int' to 'T', signed/unsigned mismatch
+#endif
+
+// --------------------------------------------------------------------------
+// https://github.com/abseil/abseil-cpp/issues/209
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87853
+// _mm_cmpgt_epi8 is broken under GCC with -funsigned-char
+// Work around this by using the portable implementation of Group
+// when using -funsigned-char under GCC.
+// --------------------------------------------------------------------------
+inline __m128i _mm_cmpgt_epi8_fixed(__m128i a, __m128i b) {
+#if defined(__GNUC__) && !defined(__clang__)
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Woverflow"
+
+  if (std::is_unsigned<char>::value) {
+    const __m128i mask = _mm_set1_epi8(static_cast<char>(0x80));
+    const __m128i diff = _mm_subs_epi8(b, a);
+    return _mm_cmpeq_epi8(_mm_and_si128(diff, mask), mask);
+  }
+
+  #pragma GCC diagnostic pop
+#endif
+  return _mm_cmpgt_epi8(a, b);
+}
+
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+struct GroupSse2Impl 
+{
+    enum { kWidth = 16 };  // the number of slots per group
+
+    explicit GroupSse2Impl(const ctrl_t* pos) {
+        ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
+    }
+
+    // Returns a bitmask representing the positions of slots that match hash.
+    // ----------------------------------------------------------------------
+    BitMask<uint32_t, kWidth> Match(h2_t hash) const {
+        auto match = _mm_set1_epi8((char)hash);
+        return BitMask<uint32_t, kWidth>(
+            _mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl)));
+    }
+
+    // Returns a bitmask representing the positions of empty slots.
+    // ------------------------------------------------------------
+    BitMask<uint32_t, kWidth> MatchEmpty() const {
+#if PHMAP_HAVE_SSSE3
+        // This only works because kEmpty is -128.
+        return BitMask<uint32_t, kWidth>(
+            _mm_movemask_epi8(_mm_sign_epi8(ctrl, ctrl)));
+#else
+        return Match(static_cast<h2_t>(kEmpty));
+#endif
+    }
+
+    // Returns a bitmask representing the positions of empty or deleted slots.
+    // -----------------------------------------------------------------------
+    BitMask<uint32_t, kWidth> MatchEmptyOrDeleted() const {
+        auto special = _mm_set1_epi8(kSentinel);
+        return BitMask<uint32_t, kWidth>(
+            _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)));
+    }
+
+    // Returns the number of trailing empty or deleted elements in the group.
+    // ----------------------------------------------------------------------
+    uint32_t CountLeadingEmptyOrDeleted() const {
+        auto special = _mm_set1_epi8(kSentinel);
+        return TrailingZeros(
+            _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)) + 1);
+    }
+
+    // ----------------------------------------------------------------------
+    void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
+        auto msbs = _mm_set1_epi8(static_cast<char>(-128));
+        auto x126 = _mm_set1_epi8(126);
+#if PHMAP_HAVE_SSSE3
+        auto res = _mm_or_si128(_mm_shuffle_epi8(x126, ctrl), msbs);
+#else
+        auto zero = _mm_setzero_si128();
+        auto special_mask = _mm_cmpgt_epi8_fixed(zero, ctrl);
+        auto res = _mm_or_si128(msbs, _mm_andnot_si128(special_mask, x126));
+#endif
+        _mm_storeu_si128(reinterpret_cast<__m128i*>(dst), res);
+    }
+
+    __m128i ctrl;
+};
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+#endif  // PHMAP_HAVE_SSE2
+
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+struct GroupPortableImpl 
+{
+    enum { kWidth = 8 };
+
+    explicit GroupPortableImpl(const ctrl_t* pos)
+        : ctrl(little_endian::Load64(pos)) {}
+
+    BitMask<uint64_t, kWidth, 3> Match(h2_t hash) const {
+        // For the technique, see:
+        // http://graphics.stanford.edu/~seander/bithacks.html##ValueInWord
+        // (Determine if a word has a byte equal to n).
+        //
+        // Caveat: there are false positives but:
+        // - they only occur if there is a real match
+        // - they never occur on kEmpty, kDeleted, kSentinel
+        // - they will be handled gracefully by subsequent checks in code
+        //
+        // Example:
+        //   v = 0x1716151413121110
+        //   hash = 0x12
+        //   retval = (v - lsbs) & ~v & msbs = 0x0000000080800000
+        constexpr uint64_t msbs = 0x8080808080808080ULL;
+        constexpr uint64_t lsbs = 0x0101010101010101ULL;
+        auto x = ctrl ^ (lsbs * hash);
+        return BitMask<uint64_t, kWidth, 3>((x - lsbs) & ~x & msbs);
+    }
+
+    BitMask<uint64_t, kWidth, 3> MatchEmpty() const {
+        constexpr uint64_t msbs = 0x8080808080808080ULL;
+        return BitMask<uint64_t, kWidth, 3>((ctrl & (~ctrl << 6)) & msbs);
+    }
+
+    BitMask<uint64_t, kWidth, 3> MatchEmptyOrDeleted() const {
+        constexpr uint64_t msbs = 0x8080808080808080ULL;
+        return BitMask<uint64_t, kWidth, 3>((ctrl & (~ctrl << 7)) & msbs);
+    }
+
+    uint32_t CountLeadingEmptyOrDeleted() const {
+        constexpr uint64_t gaps = 0x00FEFEFEFEFEFEFEULL;
+        return (uint32_t)((TrailingZeros(((~ctrl & (ctrl >> 7)) | gaps) + 1) + 7) >> 3);
+    }
+
+    void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
+        constexpr uint64_t msbs = 0x8080808080808080ULL;
+        constexpr uint64_t lsbs = 0x0101010101010101ULL;
+        auto x = ctrl & msbs;
+        auto res = (~x + (x >> 7)) & ~lsbs;
+        little_endian::Store64(dst, res);
+    }
+
+    uint64_t ctrl;
+};
+
+#if PHMAP_HAVE_SSE2  
+    using Group = GroupSse2Impl;
+#else
+    using Group = GroupPortableImpl;
+#endif
+
+template <class Policy, class Hash, class Eq, class Alloc>
+class raw_hash_set;
+
+inline bool IsValidCapacity(size_t n) { return ((n + 1) & n) == 0 && n > 0; }
+
+// --------------------------------------------------------------------------
+// PRECONDITION:
+//   IsValidCapacity(capacity)
+//   ctrl[capacity] == kSentinel
+//   ctrl[i] != kSentinel for all i < capacity
+// Applies mapping for every byte in ctrl:
+//   DELETED -> EMPTY
+//   EMPTY -> EMPTY
+//   FULL -> DELETED
+// --------------------------------------------------------------------------
+inline void ConvertDeletedToEmptyAndFullToDeleted(
+    ctrl_t* ctrl, size_t capacity) 
+{
+    assert(ctrl[capacity] == kSentinel);
+    assert(IsValidCapacity(capacity));
+    for (ctrl_t* pos = ctrl; pos != ctrl + capacity + 1; pos += Group::kWidth) {
+        Group{pos}.ConvertSpecialToEmptyAndFullToDeleted(pos);
+    }
+    // Copy the cloned ctrl bytes.
+    std::memcpy(ctrl + capacity + 1, ctrl, Group::kWidth);
+    ctrl[capacity] = kSentinel;
+}
+
+// --------------------------------------------------------------------------
+// Rounds up the capacity to the next power of 2 minus 1, with a minimum of 1.
+// --------------------------------------------------------------------------
+inline size_t NormalizeCapacity(size_t n) 
+{
+    return n ? ~size_t{} >> LeadingZeros(n) : 1;
+}
+
+// --------------------------------------------------------------------------
+// We use 7/8th as maximum load factor.
+// For 16-wide groups, that gives an average of two empty slots per group.
+// --------------------------------------------------------------------------
+inline size_t CapacityToGrowth(size_t capacity) 
+{
+    assert(IsValidCapacity(capacity));
+    // `capacity*7/8`
+    PHMAP_IF_CONSTEXPR (Group::kWidth == 8) {
+        if (capacity == 7)
+        {
+            // x-x/8 does not work when x==7.
+            return 6;
+        }
+    }
+    return capacity - capacity / 8;
+}
+
+// --------------------------------------------------------------------------
+// From desired "growth" to a lowerbound of the necessary capacity.
+// Might not be a valid one and required NormalizeCapacity().
+// --------------------------------------------------------------------------
+inline size_t GrowthToLowerboundCapacity(size_t growth) 
+{
+    // `growth*8/7`
+    PHMAP_IF_CONSTEXPR (Group::kWidth == 8) {
+        if (growth == 7)
+        {
+            // x+(x-1)/7 does not work when x==7.
+            return 8;
+        }
+    }
+    return growth + static_cast<size_t>((static_cast<int64_t>(growth) - 1) / 7);
+}
+
+namespace hashtable_debug_internal {
+
+// If it is a map, call get<0>().
+using std::get;
+template <typename T, typename = typename T::mapped_type>
+auto GetKey(const typename T::value_type& pair, int) -> decltype(get<0>(pair)) {
+    return get<0>(pair);
+}
+
+// If it is not a map, return the value directly.
+template <typename T>
+const typename T::key_type& GetKey(const typename T::key_type& key, char) {
+    return key;
+}
+
+// --------------------------------------------------------------------------
+// Containers should specialize this to provide debug information for that
+// container.
+// --------------------------------------------------------------------------
+template <class Container, typename Enabler = void>
+struct HashtableDebugAccess 
+{
+    // Returns the number of probes required to find `key` in `c`.  The "number of
+    // probes" is a concept that can vary by container.  Implementations should
+    // return 0 when `key` was found in the minimum number of operations and
+    // should increment the result for each non-trivial operation required to find
+    // `key`.
+    //
+    // The default implementation uses the bucket api from the standard and thus
+    // works for `std::unordered_*` containers.
+    // --------------------------------------------------------------------------
+    static size_t GetNumProbes(const Container& c,
+                               const typename Container::key_type& key) {
+        if (!c.bucket_count()) return {};
+        size_t num_probes = 0;
+        size_t bucket = c.bucket(key);
+        for (auto it = c.begin(bucket), e = c.end(bucket);; ++it, ++num_probes) {
+            if (it == e) return num_probes;
+            if (c.key_eq()(key, GetKey<Container>(*it, 0))) return num_probes;
+        }
+    }
+};
+
+}  // namespace hashtable_debug_internal
+
+// ----------------------------------------------------------------------------
+//                    I N F O Z   S T U B S
+// ----------------------------------------------------------------------------
+struct HashtablezInfo 
+{
+    void PrepareForSampling() {}
+};
+
+inline void RecordRehashSlow(HashtablezInfo*, size_t ) {}
+
+static inline void RecordInsertSlow(HashtablezInfo* , size_t, size_t ) {}
+
+static inline void RecordEraseSlow(HashtablezInfo*) {}
+
+static inline HashtablezInfo* SampleSlow(int64_t*) { return nullptr; }
+static inline void UnsampleSlow(HashtablezInfo* ) {}
+
+class HashtablezInfoHandle 
+{
+public:
+    inline void RecordStorageChanged(size_t , size_t ) {}
+    inline void RecordRehash(size_t ) {}
+    inline void RecordInsert(size_t , size_t ) {}
+    inline void RecordErase() {}
+    friend inline void swap(HashtablezInfoHandle& ,
+                            HashtablezInfoHandle& ) noexcept {}
+};
+
+static inline HashtablezInfoHandle Sample() { return HashtablezInfoHandle(); }
+
+class HashtablezSampler 
+{
+public:
+    // Returns a global Sampler.
+    static HashtablezSampler& Global() {  static HashtablezSampler hzs; return hzs; }
+    HashtablezInfo* Register() {  static HashtablezInfo info; return &info; }
+    void Unregister(HashtablezInfo* ) {}
+
+    using DisposeCallback = void (*)(const HashtablezInfo&);
+    DisposeCallback SetDisposeCallback(DisposeCallback ) { return nullptr; }
+    int64_t Iterate(const std::function<void(const HashtablezInfo& stack)>& ) { return 0; }
+};
+
+static inline void SetHashtablezEnabled(bool ) {}
+static inline void SetHashtablezSampleParameter(int32_t ) {}
+static inline void SetHashtablezMaxSamples(int32_t ) {}
+
+
+namespace memory_internal {
+
+// Constructs T into uninitialized storage pointed by `ptr` using the args
+// specified in the tuple.
+// ----------------------------------------------------------------------------
+template <class Alloc, class T, class Tuple, size_t... I>
+void ConstructFromTupleImpl(Alloc* alloc, T* ptr, Tuple&& t,
+                            phmap::index_sequence<I...>) {
+    phmap::allocator_traits<Alloc>::construct(
+        *alloc, ptr, std::get<I>(std::forward<Tuple>(t))...);
+}
+
+template <class T, class F>
+struct WithConstructedImplF {
+    template <class... Args>
+    decltype(std::declval<F>()(std::declval<T>())) operator()(
+        Args&&... args) const {
+        return std::forward<F>(f)(T(std::forward<Args>(args)...));
+    }
+    F&& f;
+};
+
+template <class T, class Tuple, size_t... Is, class F>
+decltype(std::declval<F>()(std::declval<T>())) WithConstructedImpl(
+    Tuple&& t, phmap::index_sequence<Is...>, F&& f) {
+    return WithConstructedImplF<T, F>{std::forward<F>(f)}(
+        std::get<Is>(std::forward<Tuple>(t))...);
+}
+
+template <class T, size_t... Is>
+auto TupleRefImpl(T&& t, phmap::index_sequence<Is...>)
+    -> decltype(std::forward_as_tuple(std::get<Is>(std::forward<T>(t))...)) {
+  return std::forward_as_tuple(std::get<Is>(std::forward<T>(t))...);
+}
+
+// Returns a tuple of references to the elements of the input tuple. T must be a
+// tuple.
+// ----------------------------------------------------------------------------
+template <class T>
+auto TupleRef(T&& t) -> decltype(
+    TupleRefImpl(std::forward<T>(t),
+                 phmap::make_index_sequence<
+                     std::tuple_size<typename std::decay<T>::type>::value>())) {
+  return TupleRefImpl(
+      std::forward<T>(t),
+      phmap::make_index_sequence<
+          std::tuple_size<typename std::decay<T>::type>::value>());
+}
+
+template <class F, class K, class V>
+decltype(std::declval<F>()(std::declval<const K&>(), std::piecewise_construct,
+                           std::declval<std::tuple<K>>(), std::declval<V>()))
+DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
+    const auto& key = std::get<0>(p.first);
+    return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
+                              std::move(p.second));
+}
+
+}  // namespace memory_internal
+
+
+// ----------------------------------------------------------------------------
+//                     R A W _ H A S H _ S E T
+// ----------------------------------------------------------------------------
+// An open-addressing
+// hashtable with quadratic probing.
+//
+// This is a low level hashtable on top of which different interfaces can be
+// implemented, like flat_hash_set, node_hash_set, string_hash_set, etc.
+//
+// The table interface is similar to that of std::unordered_set. Notable
+// differences are that most member functions support heterogeneous keys when
+// BOTH the hash and eq functions are marked as transparent. They do so by
+// providing a typedef called `is_transparent`.
+//
+// When heterogeneous lookup is enabled, functions that take key_type act as if
+// they have an overload set like:
+//
+//   iterator find(const key_type& key);
+//   template <class K>
+//   iterator find(const K& key);
+//
+//   size_type erase(const key_type& key);
+//   template <class K>
+//   size_type erase(const K& key);
+//
+//   std::pair<iterator, iterator> equal_range(const key_type& key);
+//   template <class K>
+//   std::pair<iterator, iterator> equal_range(const K& key);
+//
+// When heterogeneous lookup is disabled, only the explicit `key_type` overloads
+// exist.
+//
+// find() also supports passing the hash explicitly:
+//
+//   iterator find(const key_type& key, size_t hash);
+//   template <class U>
+//   iterator find(const U& key, size_t hash);
+//
+// In addition the pointer to element and iterator stability guarantees are
+// weaker: all iterators and pointers are invalidated after a new element is
+// inserted.
+//
+// IMPLEMENTATION DETAILS
+//
+// The table stores elements inline in a slot array. In addition to the slot
+// array the table maintains some control state per slot. The extra state is one
+// byte per slot and stores empty or deleted marks, or alternatively 7 bits from
+// the hash of an occupied slot. The table is split into logical groups of
+// slots, like so:
+//
+//      Group 1         Group 2        Group 3
+// +---------------+---------------+---------------+
+// | | | | | | | | | | | | | | | | | | | | | | | | |
+// +---------------+---------------+---------------+
+//
+// On lookup the hash is split into two parts:
+// - H2: 7 bits (those stored in the control bytes)
+// - H1: the rest of the bits
+// The groups are probed using H1. For each group the slots are matched to H2 in
+// parallel. Because H2 is 7 bits (128 states) and the number of slots per group
+// is low (8 or 16) in almost all cases a match in H2 is also a lookup hit.
+//
+// On insert, once the right group is found (as in lookup), its slots are
+// filled in order.
+//
+// On erase a slot is cleared. In case the group did not have any empty slots
+// before the erase, the erased slot is marked as deleted.
+//
+// Groups without empty slots (but maybe with deleted slots) extend the probe
+// sequence. The probing algorithm is quadratic. Given N the number of groups,
+// the probing function for the i'th probe is:
+//
+//   P(0) = H1 % N
+//
+//   P(i) = (P(i - 1) + i) % N
+//
+// This probing function guarantees that after N probes, all the groups of the
+// table will be probed exactly once.
+// ----------------------------------------------------------------------------
+template <class Policy, class Hash, class Eq, class Alloc>
+class raw_hash_set 
+{
+    using PolicyTraits = hash_policy_traits<Policy>;
+    using KeyArgImpl =
+        KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>;
+
+public:
+    using init_type = typename PolicyTraits::init_type;
+    using key_type = typename PolicyTraits::key_type;
+    // TODO(sbenza): Hide slot_type as it is an implementation detail. Needs user
+    // code fixes!
+    using slot_type = typename PolicyTraits::slot_type;
+    using allocator_type = Alloc;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+    using hasher = Hash;
+    using key_equal = Eq;
+    using policy_type = Policy;
+    using value_type = typename PolicyTraits::value_type;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using pointer = typename phmap::allocator_traits<
+        allocator_type>::template rebind_traits<value_type>::pointer;
+    using const_pointer = typename phmap::allocator_traits<
+        allocator_type>::template rebind_traits<value_type>::const_pointer;
+
+    // Alias used for heterogeneous lookup functions.
+    // `key_arg<K>` evaluates to `K` when the functors are transparent and to
+    // `key_type` otherwise. It permits template argument deduction on `K` for the
+    // transparent case.
+    template <class K>
+    using key_arg = typename KeyArgImpl::template type<K, key_type>;
+
+private:
+    // Give an early error when key_type is not hashable/eq.
+    auto KeyTypeCanBeHashed(const Hash& h, const key_type& k) -> decltype(h(k));
+    auto KeyTypeCanBeEq(const Eq& eq, const key_type& k) -> decltype(eq(k, k));
+
+    using Layout = phmap::priv::Layout<ctrl_t, slot_type>;
+
+    static Layout MakeLayout(size_t capacity) {
+        assert(IsValidCapacity(capacity));
+        return Layout(capacity + Group::kWidth + 1, capacity);
+    }
+
+    using AllocTraits = phmap::allocator_traits<allocator_type>;
+    using SlotAlloc = typename phmap::allocator_traits<
+        allocator_type>::template rebind_alloc<slot_type>;
+    using SlotAllocTraits = typename phmap::allocator_traits<
+        allocator_type>::template rebind_traits<slot_type>;
+
+    static_assert(std::is_lvalue_reference<reference>::value,
+                  "Policy::element() must return a reference");
+
+    template <typename T>
+    struct SameAsElementReference
+        : std::is_same<typename std::remove_cv<
+                           typename std::remove_reference<reference>::type>::type,
+                       typename std::remove_cv<
+                           typename std::remove_reference<T>::type>::type> {};
+
+    // An enabler for insert(T&&): T must be convertible to init_type or be the
+    // same as [cv] value_type [ref].
+    // Note: we separate SameAsElementReference into its own type to avoid using
+    // reference unless we need to. MSVC doesn't seem to like it in some
+    // cases.
+    template <class T>
+    using RequiresInsertable = typename std::enable_if<
+        phmap::disjunction<std::is_convertible<T, init_type>,
+                           SameAsElementReference<T>>::value,
+        int>::type;
+
+    // RequiresNotInit is a workaround for gcc prior to 7.1.
+    // See https://godbolt.org/g/Y4xsUh.
+    template <class T>
+    using RequiresNotInit =
+        typename std::enable_if<!std::is_same<T, init_type>::value, int>::type;
+
+    template <class... Ts>
+    using IsDecomposable = IsDecomposable<void, PolicyTraits, Hash, Eq, Ts...>;
+
+public:
+    static_assert(std::is_same<pointer, value_type*>::value,
+                  "Allocators with custom pointer types are not supported");
+    static_assert(std::is_same<const_pointer, const value_type*>::value,
+                  "Allocators with custom pointer types are not supported");
+
+    class iterator 
+    {
+        friend class raw_hash_set;
+
+    public:
+        using iterator_category = std::forward_iterator_tag;
+        using value_type = typename raw_hash_set::value_type;
+        using reference =
+            phmap::conditional_t<PolicyTraits::constant_iterators::value,
+                                 const value_type&, value_type&>;
+        using pointer = phmap::remove_reference_t<reference>*;
+        using difference_type = typename raw_hash_set::difference_type;
+
+        iterator() {}
+
+        // PRECONDITION: not an end() iterator.
+        reference operator*() const { return PolicyTraits::element(slot_); }
+
+        // PRECONDITION: not an end() iterator.
+        pointer operator->() const { return &operator*(); }
+
+        // PRECONDITION: not an end() iterator.
+        iterator& operator++() {
+            ++ctrl_;
+            ++slot_;
+            skip_empty_or_deleted();
+            return *this;
+        }
+        // PRECONDITION: not an end() iterator.
+        iterator operator++(int) {
+            auto tmp = *this;
+            ++*this;
+            return tmp;
+        }
+
+#if PHMAP_BIDIRECTIONAL
+        // PRECONDITION: not a begin() iterator.
+        iterator& operator--() {
+            assert(ctrl_);
+            do {
+                --ctrl_;
+                --slot_;
+            } while (IsEmptyOrDeleted(*ctrl_));
+            return *this;
+        }
+
+        // PRECONDITION: not a begin() iterator.
+        iterator operator--(int) {
+            auto tmp = *this;
+            --*this;
+            return tmp;
+        }
+#endif
+
+        friend bool operator==(const iterator& a, const iterator& b) {
+            return a.ctrl_ == b.ctrl_;
+        }
+        friend bool operator!=(const iterator& a, const iterator& b) {
+            return !(a == b);
+        }
+
+    private:
+        iterator(ctrl_t* ctrl) : ctrl_(ctrl) {}  // for end()
+        iterator(ctrl_t* ctrl, slot_type* slot) : ctrl_(ctrl), slot_(slot) {}
+
+        void skip_empty_or_deleted() {
+            while (IsEmptyOrDeleted(*ctrl_)) {
+                // ctrl is not necessarily aligned to Group::kWidth. It is also likely
+                // to read past the space for ctrl bytes and into slots. This is ok
+                // because ctrl has sizeof() == 1 and slot has sizeof() >= 1 so there
+                // is no way to read outside the combined slot array.
+                uint32_t shift = Group{ctrl_}.CountLeadingEmptyOrDeleted();
+                ctrl_ += shift;
+                slot_ += shift;
+            }
+        }
+
+        ctrl_t* ctrl_ = nullptr;
+        // To avoid uninitialized member warnings, put slot_ in an anonymous union.
+        // The member is not initialized on singleton and end iterators.
+        union {
+            slot_type* slot_;
+        };
+    };
+
+    class const_iterator 
+    {
+        friend class raw_hash_set;
+
+    public:
+        using iterator_category = typename iterator::iterator_category;
+        using value_type = typename raw_hash_set::value_type;
+        using reference = typename raw_hash_set::const_reference;
+        using pointer = typename raw_hash_set::const_pointer;
+        using difference_type = typename raw_hash_set::difference_type;
+
+        const_iterator() {}
+        // Implicit construction from iterator.
+        const_iterator(iterator i) : inner_(std::move(i)) {}
+
+        reference operator*() const { return *inner_; }
+        pointer operator->() const { return inner_.operator->(); }
+
+        const_iterator& operator++() {
+            ++inner_;
+            return *this;
+        }
+        const_iterator operator++(int) { return inner_++; }
+
+        friend bool operator==(const const_iterator& a, const const_iterator& b) {
+            return a.inner_ == b.inner_;
+        }
+        friend bool operator!=(const const_iterator& a, const const_iterator& b) {
+            return !(a == b);
+        }
+
+    private:
+        const_iterator(const ctrl_t* ctrl, const slot_type* slot)
+            : inner_(const_cast<ctrl_t*>(ctrl), const_cast<slot_type*>(slot)) {}
+
+        iterator inner_;
+    };
+
+    using node_type = node_handle<Policy, hash_policy_traits<Policy>, Alloc>;
+    using insert_return_type = InsertReturnType<iterator, node_type>;
+
+    raw_hash_set() noexcept(
+        std::is_nothrow_default_constructible<hasher>::value&&
+        std::is_nothrow_default_constructible<key_equal>::value&&
+        std::is_nothrow_default_constructible<allocator_type>::value) {}
+
+    explicit raw_hash_set(size_t bucket_count, const hasher& hashfn = hasher(),
+                          const key_equal& eq = key_equal(),
+                          const allocator_type& alloc = allocator_type())
+        : ctrl_(EmptyGroup()), settings_(0, hashfn, eq, alloc) {
+        if (bucket_count) {
+            capacity_ = NormalizeCapacity(bucket_count);
+            reset_growth_left();
+            initialize_slots();
+        }
+    }
+
+    raw_hash_set(size_t bucket_count, const hasher& hashfn,
+                 const allocator_type& alloc)
+        : raw_hash_set(bucket_count, hashfn, key_equal(), alloc) {}
+
+    raw_hash_set(size_t bucket_count, const allocator_type& alloc)
+        : raw_hash_set(bucket_count, hasher(), key_equal(), alloc) {}
+
+    explicit raw_hash_set(const allocator_type& alloc)
+        : raw_hash_set(0, hasher(), key_equal(), alloc) {}
+
+    template <class InputIter>
+    raw_hash_set(InputIter first, InputIter last, size_t bucket_count = 0,
+                 const hasher& hashfn = hasher(), const key_equal& eq = key_equal(),
+                 const allocator_type& alloc = allocator_type())
+        : raw_hash_set(bucket_count, hashfn, eq, alloc) {
+        insert(first, last);
+    }
+
+    template <class InputIter>
+    raw_hash_set(InputIter first, InputIter last, size_t bucket_count,
+                 const hasher& hashfn, const allocator_type& alloc)
+        : raw_hash_set(first, last, bucket_count, hashfn, key_equal(), alloc) {}
+
+    template <class InputIter>
+    raw_hash_set(InputIter first, InputIter last, size_t bucket_count,
+                 const allocator_type& alloc)
+        : raw_hash_set(first, last, bucket_count, hasher(), key_equal(), alloc) {}
+
+    template <class InputIter>
+    raw_hash_set(InputIter first, InputIter last, const allocator_type& alloc)
+        : raw_hash_set(first, last, 0, hasher(), key_equal(), alloc) {}
+
+    // Instead of accepting std::initializer_list<value_type> as the first
+    // argument like std::unordered_set<value_type> does, we have two overloads
+    // that accept std::initializer_list<T> and std::initializer_list<init_type>.
+    // This is advantageous for performance.
+    //
+    //   // Turns {"abc", "def"} into std::initializer_list<std::string>, then
+    //   // copies the strings into the set.
+    //   std::unordered_set<std::string> s = {"abc", "def"};
+    //
+    //   // Turns {"abc", "def"} into std::initializer_list<const char*>, then
+    //   // copies the strings into the set.
+    //   phmap::flat_hash_set<std::string> s = {"abc", "def"};
+    //
+    // The same trick is used in insert().
+    //
+    // The enabler is necessary to prevent this constructor from triggering where
+    // the copy constructor is meant to be called.
+    //
+    //   phmap::flat_hash_set<int> a, b{a};
+    //
+    // RequiresNotInit<T> is a workaround for gcc prior to 7.1.
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+    raw_hash_set(std::initializer_list<T> init, size_t bucket_count = 0,
+                 const hasher& hashfn = hasher(), const key_equal& eq = key_equal(),
+                 const allocator_type& alloc = allocator_type())
+        : raw_hash_set(init.begin(), init.end(), bucket_count, hashfn, eq, alloc) {}
+
+    raw_hash_set(std::initializer_list<init_type> init, size_t bucket_count = 0,
+                 const hasher& hashfn = hasher(), const key_equal& eq = key_equal(),
+                 const allocator_type& alloc = allocator_type())
+        : raw_hash_set(init.begin(), init.end(), bucket_count, hashfn, eq, alloc) {}
+
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+    raw_hash_set(std::initializer_list<T> init, size_t bucket_count,
+                 const hasher& hashfn, const allocator_type& alloc)
+        : raw_hash_set(init, bucket_count, hashfn, key_equal(), alloc) {}
+
+    raw_hash_set(std::initializer_list<init_type> init, size_t bucket_count,
+                 const hasher& hashfn, const allocator_type& alloc)
+        : raw_hash_set(init, bucket_count, hashfn, key_equal(), alloc) {}
+
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+    raw_hash_set(std::initializer_list<T> init, size_t bucket_count,
+                 const allocator_type& alloc)
+        : raw_hash_set(init, bucket_count, hasher(), key_equal(), alloc) {}
+
+    raw_hash_set(std::initializer_list<init_type> init, size_t bucket_count,
+                 const allocator_type& alloc)
+        : raw_hash_set(init, bucket_count, hasher(), key_equal(), alloc) {}
+
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+    raw_hash_set(std::initializer_list<T> init, const allocator_type& alloc)
+        : raw_hash_set(init, 0, hasher(), key_equal(), alloc) {}
+
+    raw_hash_set(std::initializer_list<init_type> init,
+                 const allocator_type& alloc)
+        : raw_hash_set(init, 0, hasher(), key_equal(), alloc) {}
+
+    raw_hash_set(const raw_hash_set& that)
+        : raw_hash_set(that, AllocTraits::select_on_container_copy_construction(
+                           that.alloc_ref())) {}
+
+    raw_hash_set(const raw_hash_set& that, const allocator_type& a)
+        : raw_hash_set(0, that.hash_ref(), that.eq_ref(), a) {
+        reserve(that.size());
+        // Because the table is guaranteed to be empty, we can do something faster
+        // than a full `insert`.
+        for (const auto& v : that) {
+            const size_t hashval = PolicyTraits::apply(HashElement{hash_ref()}, v);
+            auto target = find_first_non_full(hashval);
+            set_ctrl(target.offset, H2(hashval));
+            emplace_at(target.offset, v);
+            infoz_.RecordInsert(hashval, target.probe_length);
+        }
+        size_ = that.size();
+        growth_left() -= that.size();
+    }
+
+    raw_hash_set(raw_hash_set&& that) noexcept(
+        std::is_nothrow_copy_constructible<hasher>::value&&
+        std::is_nothrow_copy_constructible<key_equal>::value&&
+        std::is_nothrow_copy_constructible<allocator_type>::value)
+        : ctrl_(phmap::exchange(that.ctrl_, EmptyGroup())),
+        slots_(phmap::exchange(that.slots_, nullptr)),
+        size_(phmap::exchange(that.size_, 0)),
+        capacity_(phmap::exchange(that.capacity_, 0)),
+        infoz_(phmap::exchange(that.infoz_, HashtablezInfoHandle())),
+    // Hash, equality and allocator are copied instead of moved because
+    // `that` must be left valid. If Hash is std::function<Key>, moving it
+    // would create a nullptr functor that cannot be called.
+        settings_(that.settings_) {
+        // growth_left was copied above, reset the one from `that`.
+        that.growth_left() = 0;
+    }
+
+    raw_hash_set(raw_hash_set&& that, const allocator_type& a)
+        : ctrl_(EmptyGroup()),
+          slots_(nullptr),
+          size_(0),
+          capacity_(0),
+          settings_(0, that.hash_ref(), that.eq_ref(), a) {
+        if (a == that.alloc_ref()) {
+            std::swap(ctrl_, that.ctrl_);
+            std::swap(slots_, that.slots_);
+            std::swap(size_, that.size_);
+            std::swap(capacity_, that.capacity_);
+            std::swap(growth_left(), that.growth_left());
+            std::swap(infoz_, that.infoz_);
+        } else {
+            reserve(that.size());
+            // Note: this will copy elements of dense_set and unordered_set instead of
+            // moving them. This can be fixed if it ever becomes an issue.
+            for (auto& elem : that) insert(std::move(elem));
+        }
+    }
+
+    raw_hash_set& operator=(const raw_hash_set& that) {
+        raw_hash_set tmp(that,
+                         AllocTraits::propagate_on_container_copy_assignment::value
+                         ? that.alloc_ref()
+                         : alloc_ref());
+        swap(tmp);
+        return *this;
+    }
+
+    raw_hash_set& operator=(raw_hash_set&& that) noexcept(
+        phmap::allocator_traits<allocator_type>::is_always_equal::value&&
+        std::is_nothrow_move_assignable<hasher>::value&&
+        std::is_nothrow_move_assignable<key_equal>::value) {
+        // TODO(sbenza): We should only use the operations from the noexcept clause
+        // to make sure we actually adhere to that contract.
+        return move_assign(
+            std::move(that),
+            typename AllocTraits::propagate_on_container_move_assignment());
+    }
+
+    ~raw_hash_set() { destroy_slots(); }
+
+    iterator begin() {
+        auto it = iterator_at(0);
+        it.skip_empty_or_deleted();
+        return it;
+    }
+    iterator end() 
+    {
+#if PHMAP_BIDIRECTIONAL
+        return iterator_at(capacity_); 
+#else
+        return {ctrl_ + capacity_};
+#endif
+    }
+
+    const_iterator begin() const {
+        return const_cast<raw_hash_set*>(this)->begin();
+    }
+    const_iterator end() const { return const_cast<raw_hash_set*>(this)->end(); }
+    const_iterator cbegin() const { return begin(); }
+    const_iterator cend() const { return end(); }
+
+    bool empty() const { return !size(); }
+    size_t size() const { return size_; }
+    size_t capacity() const { return capacity_; }
+    size_t max_size() const { return (std::numeric_limits<size_t>::max)(); }
+
+    PHMAP_ATTRIBUTE_REINITIALIZES void clear() {
+        // Iterating over this container is O(bucket_count()). When bucket_count()
+        // is much greater than size(), iteration becomes prohibitively expensive.
+        // For clear() it is more important to reuse the allocated array when the
+        // container is small because allocation takes comparatively long time
+        // compared to destruction of the elements of the container. So we pick the
+        // largest bucket_count() threshold for which iteration is still fast and
+        // past that we simply deallocate the array.
+        if (empty())
+            return;
+        if (capacity_ > 127) {
+            destroy_slots();
+        } else if (capacity_) {
+            for (size_t i = 0; i != capacity_; ++i) {
+                if (IsFull(ctrl_[i])) {
+                    PolicyTraits::destroy(&alloc_ref(), slots_ + i);
+                }
+            }
+            size_ = 0;
+            reset_ctrl();
+            reset_growth_left();
+        }
+        assert(empty());
+        infoz_.RecordStorageChanged(0, capacity_);
+    }
+
+    // This overload kicks in when the argument is an rvalue of insertable and
+    // decomposable type other than init_type.
+    //
+    //   flat_hash_map<std::string, int> m;
+    //   m.insert(std::make_pair("abc", 42));
+    template <class T, RequiresInsertable<T> = 0,
+              typename std::enable_if<IsDecomposable<T>::value, int>::type = 0,
+              T* = nullptr>
+    std::pair<iterator, bool> insert(T&& value) {
+        return emplace(std::forward<T>(value));
+    }
+
+    // This overload kicks in when the argument is a bitfield or an lvalue of
+    // insertable and decomposable type.
+    //
+    //   union { int n : 1; };
+    //   flat_hash_set<int> s;
+    //   s.insert(n);
+    //
+    //   flat_hash_set<std::string> s;
+    //   const char* p = "hello";
+    //   s.insert(p);
+    //
+    // TODO(romanp): Once we stop supporting gcc 5.1 and below, replace
+    // RequiresInsertable<T> with RequiresInsertable<const T&>.
+    // We are hitting this bug: https://godbolt.org/g/1Vht4f.
+    template <class T, RequiresInsertable<T> = 0,
+              typename std::enable_if<IsDecomposable<const T&>::value, int>::type = 0>
+    std::pair<iterator, bool> insert(const T& value) {
+        return emplace(value);
+    }
+
+    // This overload kicks in when the argument is an rvalue of init_type. Its
+    // purpose is to handle brace-init-list arguments.
+    //
+    //   flat_hash_set<std::string, int> s;
+    //   s.insert({"abc", 42});
+    std::pair<iterator, bool> insert(init_type&& value) {
+        return emplace(std::move(value));
+    }
+
+    template <class T, RequiresInsertable<T> = 0,
+              typename std::enable_if<IsDecomposable<T>::value, int>::type = 0,
+              T* = nullptr>
+    iterator insert(const_iterator, T&& value) {
+        return insert(std::forward<T>(value)).first;
+    }
+
+    // TODO(romanp): Once we stop supporting gcc 5.1 and below, replace
+    // RequiresInsertable<T> with RequiresInsertable<const T&>.
+    // We are hitting this bug: https://godbolt.org/g/1Vht4f.
+    template <class T, RequiresInsertable<T> = 0,
+              typename std::enable_if<IsDecomposable<const T&>::value, int>::type = 0>
+    iterator insert(const_iterator, const T& value) {
+        return insert(value).first;
+    }
+
+    iterator insert(const_iterator, init_type&& value) {
+        return insert(std::move(value)).first;
+    }
+
+    template <typename It>
+    using IsRandomAccess = std::is_same<typename std::iterator_traits<It>::iterator_category,
+                                        std::random_access_iterator_tag>;
+
+
+    template<typename T>
+    struct has_difference_operator
+    {
+    private:
+        using yes = std::true_type;
+        using no  = std::false_type;
+ 
+        template<typename U> static auto test(int) -> decltype(std::declval<U>() - std::declval<U>() == 1, yes());
+        template<typename>   static no   test(...);
+ 
+    public:
+        static constexpr bool value = std::is_same<decltype(test<T>(0)), yes>::value;
+    };
+
+    template <class InputIt, typename phmap::enable_if_t<has_difference_operator<InputIt>::value, int> = 0>
+    void insert(InputIt first, InputIt last) {
+        this->reserve(this->size() + (last - first));
+        for (; first != last; ++first) 
+            insert(*first);
+    }
+
+    template <class InputIt, typename phmap::enable_if_t<!has_difference_operator<InputIt>::value, int> = 0>
+    void insert(InputIt first, InputIt last) {
+        for (; first != last; ++first) 
+            insert(*first);
+    }
+
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<const T&> = 0>
+    void insert(std::initializer_list<T> ilist) {
+        insert(ilist.begin(), ilist.end());
+    }
+
+    void insert(std::initializer_list<init_type> ilist) {
+        insert(ilist.begin(), ilist.end());
+    }
+
+    insert_return_type insert(node_type&& node) {
+        if (!node) return {end(), false, node_type()};
+        const auto& elem = PolicyTraits::element(CommonAccess::GetSlot(node));
+        auto res = PolicyTraits::apply(
+            InsertSlot<false>{*this, std::move(*CommonAccess::GetSlot(node))},
+            elem);
+        if (res.second) {
+            CommonAccess::Reset(&node);
+            return {res.first, true, node_type()};
+        } else {
+            return {res.first, false, std::move(node)};
+        }
+    }
+
+    insert_return_type insert(node_type&& node, size_t hashval) {
+        if (!node) return {end(), false, node_type()};
+        const auto& elem = PolicyTraits::element(CommonAccess::GetSlot(node));
+        auto res = PolicyTraits::apply(
+            InsertSlotWithHash<false>{*this, std::move(*CommonAccess::GetSlot(node)), hashval},
+            elem);
+        if (res.second) {
+            CommonAccess::Reset(&node);
+            return {res.first, true, node_type()};
+        } else {
+            return {res.first, false, std::move(node)};
+        }
+    }
+
+    iterator insert(const_iterator, node_type&& node) {
+        return insert(std::move(node)).first;
+    }
+
+    // This overload kicks in if we can deduce the key from args. This enables us
+    // to avoid constructing value_type if an entry with the same key already
+    // exists.
+    //
+    // For example:
+    //
+    //   flat_hash_map<std::string, std::string> m = {{"abc", "def"}};
+    //   // Creates no std::string copies and makes no heap allocations.
+    //   m.emplace("abc", "xyz");
+    template <class... Args, typename std::enable_if<
+                                 IsDecomposable<Args...>::value, int>::type = 0>
+    std::pair<iterator, bool> emplace(Args&&... args) {
+        return PolicyTraits::apply(EmplaceDecomposable{*this},
+                                   std::forward<Args>(args)...);
+    }
+
+    // This overload kicks in if we cannot deduce the key from args. It constructs
+    // value_type unconditionally and then either moves it into the table or
+    // destroys.
+    template <class... Args, typename std::enable_if<
+                                 !IsDecomposable<Args...>::value, int>::type = 0>
+    std::pair<iterator, bool> emplace(Args&&... args) {
+        typename std::aligned_storage<sizeof(slot_type), alignof(slot_type)>::type
+            raw;
+        slot_type* slot = reinterpret_cast<slot_type*>(&raw);
+
+        PolicyTraits::construct(&alloc_ref(), slot, std::forward<Args>(args)...);
+        const auto& elem = PolicyTraits::element(slot);
+        return PolicyTraits::apply(InsertSlot<true>{*this, std::move(*slot)}, elem);
+    }
+
+    template <class... Args>
+    iterator emplace_hint(const_iterator, Args&&... args) {
+        return emplace(std::forward<Args>(args)...).first;
+    }
+
+    // Extension API: support for lazy emplace.
+    //
+    // Looks up key in the table. If found, returns the iterator to the element.
+    // Otherwise calls f with one argument of type raw_hash_set::constructor. f
+    // MUST call raw_hash_set::constructor with arguments as if a
+    // raw_hash_set::value_type is constructed, otherwise the behavior is
+    // undefined.
+    //
+    // For example:
+    //
+    //   std::unordered_set<ArenaString> s;
+    //   // Makes ArenaStr even if "abc" is in the map.
+    //   s.insert(ArenaString(&arena, "abc"));
+    //
+    //   flat_hash_set<ArenaStr> s;
+    //   // Makes ArenaStr only if "abc" is not in the map.
+    //   s.lazy_emplace("abc", [&](const constructor& ctor) {
+    //     ctor(&arena, "abc");
+    //   });
+    //
+    // WARNING: This API is currently experimental. If there is a way to implement
+    // the same thing with the rest of the API, prefer that.
+    class constructor 
+    {
+        friend class raw_hash_set;
+
+    public:
+        template <class... Args>
+        void operator()(Args&&... args) const {
+            assert(*slot_);
+            PolicyTraits::construct(alloc_, *slot_, std::forward<Args>(args)...);
+            *slot_ = nullptr;
+        }
+
+    private:
+        constructor(allocator_type* a, slot_type** slot) : alloc_(a), slot_(slot) {}
+
+        allocator_type* alloc_;
+        slot_type** slot_;
+    };
+
+    template <class K = key_type, class F>
+    iterator lazy_emplace(const key_arg<K>& key, F&& f) {
+        auto res = find_or_prepare_insert(key);
+        if (res.second) {
+            lazy_emplace_at(res.first, std::forward<F>(f));
+        }
+        return iterator_at(res.first);
+    }
+
+    template <class K = key_type, class F>
+    iterator lazy_emplace_with_hash(const key_arg<K>& key, size_t &hashval, F&& f) {
+        auto res = find_or_prepare_insert(key, hashval);
+        if (res.second) {
+            lazy_emplace_at(res.first, std::forward<F>(f));
+        }
+        return iterator_at(res.first);
+    }
+
+    template <class K = key_type, class F>
+    void lazy_emplace_at(size_t& idx, F&& f) {
+        slot_type* slot = slots_ + idx;
+        std::forward<F>(f)(constructor(&alloc_ref(), &slot));
+        assert(!slot);
+    }
+
+
+    // Extension API: support for heterogeneous keys.
+    //
+    //   std::unordered_set<std::string> s;
+    //   // Turns "abc" into std::string.
+    //   s.erase("abc");
+    //
+    //   flat_hash_set<std::string> s;
+    //   // Uses "abc" directly without copying it into std::string.
+    //   s.erase("abc");
+    template <class K = key_type>
+    size_type erase(const key_arg<K>& key) {
+        auto it = find(key);
+        if (it == end()) return 0;
+        _erase(it);
+        return 1;
+    }
+
+
+    iterator erase(const_iterator cit) { return erase(cit.inner_); }
+    
+    // Erases the element pointed to by `it`.  Unlike `std::unordered_set::erase`,
+    // this method returns void to reduce algorithmic complexity to O(1).  In
+    // order to erase while iterating across a map, use the following idiom (which
+    // also works for standard containers):
+    //
+    // for (auto it = m.begin(), end = m.end(); it != end;) {
+    //   if (<pred>) {
+    //     m._erase(it++);
+    //   } else {
+    //     ++it;
+    //   }
+    // }
+    void _erase(iterator it) {
+        assert(it != end());
+        PolicyTraits::destroy(&alloc_ref(), it.slot_);
+        erase_meta_only(it);
+    }
+    void _erase(const_iterator cit) { _erase(cit.inner_); }
+
+    // This overload is necessary because otherwise erase<K>(const K&) would be
+    // a better match if non-const iterator is passed as an argument.
+    iterator erase(iterator it) {
+        auto res = it;
+        ++res;
+        _erase(it);
+        return res;
+    }
+
+    iterator erase(const_iterator first, const_iterator last) {
+        while (first != last) {
+            _erase(first++);
+        }
+        return last.inner_;
+    }
+
+    // Moves elements from `src` into `this`.
+    // If the element already exists in `this`, it is left unmodified in `src`.
+    template <typename H, typename E>
+    void merge(raw_hash_set<Policy, H, E, Alloc>& src) {  // NOLINT
+        assert(this != &src);
+        for (auto it = src.begin(), e = src.end(); it != e; ++it) {
+            if (PolicyTraits::apply(InsertSlot<false>{*this, std::move(*it.slot_)},
+                                    PolicyTraits::element(it.slot_))
+                .second) {
+                src.erase_meta_only(it);
+            }
+        }
+    }
+
+    template <typename H, typename E>
+    void merge(raw_hash_set<Policy, H, E, Alloc>&& src) {
+        merge(src);
+    }
+
+    node_type extract(const_iterator position) {
+        auto node =
+            CommonAccess::Make<node_type>(alloc_ref(), position.inner_.slot_);
+        erase_meta_only(position);
+        return node;
+    }
+
+    template <
+        class K = key_type,
+        typename std::enable_if<!std::is_same<K, iterator>::value, int>::type = 0>
+    node_type extract(const key_arg<K>& key) {
+        auto it = find(key);
+        return it == end() ? node_type() : extract(const_iterator{it});
+    }
+
+    void swap(raw_hash_set& that) noexcept(
+        IsNoThrowSwappable<hasher>() && IsNoThrowSwappable<key_equal>() &&
+        (!AllocTraits::propagate_on_container_swap::value ||
+         IsNoThrowSwappable<allocator_type>())) {
+        using std::swap;
+        swap(ctrl_, that.ctrl_);
+        swap(slots_, that.slots_);
+        swap(size_, that.size_);
+        swap(capacity_, that.capacity_);
+        swap(growth_left(), that.growth_left());
+        swap(hash_ref(), that.hash_ref());
+        swap(eq_ref(), that.eq_ref());
+        swap(infoz_, that.infoz_);
+        if (AllocTraits::propagate_on_container_swap::value) {
+            swap(alloc_ref(), that.alloc_ref());
+        } else {
+            // If the allocators do not compare equal it is officially undefined
+            // behavior. We choose to do nothing.
+        }
+    }
+
+#ifndef PHMAP_NON_DETERMINISTIC
+    template<typename OutputArchive>
+    bool dump(OutputArchive&) const;
+
+    template<typename InputArchive>
+    bool load(InputArchive&);
+#endif
+
+    void rehash(size_t n) {
+        if (n == 0 && capacity_ == 0) return;
+        if (n == 0 && size_ == 0) {
+            destroy_slots();
+            infoz_.RecordStorageChanged(0, 0);
+            return;
+        }
+        // bitor is a faster way of doing `max` here. We will round up to the next
+        // power-of-2-minus-1, so bitor is good enough.
+        auto m = NormalizeCapacity((std::max)(n, size()));
+        // n == 0 unconditionally rehashes as per the standard.
+        if (n == 0 || m > capacity_) {
+            resize(m);
+        }
+    }
+
+    void reserve(size_t n) { rehash(GrowthToLowerboundCapacity(n)); }
+
+    // Extension API: support for heterogeneous keys.
+    //
+    //   std::unordered_set<std::string> s;
+    //   // Turns "abc" into std::string.
+    //   s.count("abc");
+    //
+    //   ch_set<std::string> s;
+    //   // Uses "abc" directly without copying it into std::string.
+    //   s.count("abc");
+    template <class K = key_type>
+    size_t count(const key_arg<K>& key) const {
+        return find(key) == end() ? size_t(0) : size_t(1);
+    }
+
+    // Issues CPU prefetch instructions for the memory needed to find or insert
+    // a key.  Like all lookup functions, this support heterogeneous keys.
+    //
+    // NOTE: This is a very low level operation and should not be used without
+    // specific benchmarks indicating its importance.
+    void prefetch_hash(size_t hashval) const {
+        (void)hashval;
+#if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86))
+        auto seq = probe(hashval);
+        _mm_prefetch((const char *)(ctrl_ + seq.offset()), _MM_HINT_NTA);
+        _mm_prefetch((const char *)(slots_ + seq.offset()), _MM_HINT_NTA);
+#elif defined(__GNUC__)
+        auto seq = probe(hashval);
+        __builtin_prefetch(static_cast<const void*>(ctrl_ + seq.offset()));
+        __builtin_prefetch(static_cast<const void*>(slots_ + seq.offset()));
+#endif  // __GNUC__
+    }
+
+    template <class K = key_type>
+    void prefetch(const key_arg<K>& key) const {
+        prefetch_hash(this->hash(key));
+    }
+
+    // The API of find() has two extensions.
+    //
+    // 1. The hash can be passed by the user. It must be equal to the hash of the
+    // key.
+    //
+    // 2. The type of the key argument doesn't have to be key_type. This is so
+    // called heterogeneous key support.
+    template <class K = key_type>
+    iterator find(const key_arg<K>& key, size_t hashval) {
+        auto seq = probe(hashval);
+        while (true) {
+            Group g{ctrl_ + seq.offset()};
+            for (int i : g.Match((h2_t)H2(hashval))) {
+                if (PHMAP_PREDICT_TRUE(PolicyTraits::apply(
+                                          EqualElement<K>{key, eq_ref()},
+                                          PolicyTraits::element(slots_ + seq.offset((size_t)i)))))
+                    return iterator_at(seq.offset((size_t)i));
+            }
+            if (PHMAP_PREDICT_TRUE(g.MatchEmpty())) 
+                return end();
+            seq.next();
+        }
+    }
+    template <class K = key_type>
+    iterator find(const key_arg<K>& key) {
+        return find(key, this->hash(key));
+    }
+
+    template <class K = key_type>
+    const_iterator find(const key_arg<K>& key, size_t hashval) const {
+        return const_cast<raw_hash_set*>(this)->find(key, hashval);
+    }
+    template <class K = key_type>
+    const_iterator find(const key_arg<K>& key) const {
+        return find(key, this->hash(key));
+    }
+
+    template <class K = key_type>
+    bool contains(const key_arg<K>& key) const {
+        return find(key) != end();
+    }
+
+    template <class K = key_type>
+    bool contains(const key_arg<K>& key, size_t hashval) const {
+        return find(key, hashval) != end();
+    }
+
+    template <class K = key_type>
+    std::pair<iterator, iterator> equal_range(const key_arg<K>& key) {
+        auto it = find(key);
+        if (it != end()) return {it, std::next(it)};
+        return {it, it};
+    }
+    template <class K = key_type>
+    std::pair<const_iterator, const_iterator> equal_range(
+        const key_arg<K>& key) const {
+        auto it = find(key);
+        if (it != end()) return {it, std::next(it)};
+        return {it, it};
+    }
+
+    size_t bucket_count() const { return capacity_; }
+    float load_factor() const {
+        return capacity_ ? static_cast<double>(size()) / capacity_ : 0.0;
+    }
+    float max_load_factor() const { return 1.0f; }
+    void max_load_factor(float) {
+        // Does nothing.
+    }
+
+    hasher hash_function() const { return hash_ref(); } // warning: doesn't match internal hash - use hash() member function
+    key_equal key_eq() const { return eq_ref(); }
+    allocator_type get_allocator() const { return alloc_ref(); }
+
+    friend bool operator==(const raw_hash_set& a, const raw_hash_set& b) {
+        if (a.size() != b.size()) return false;
+        const raw_hash_set* outer = &a;
+        const raw_hash_set* inner = &b;
+        if (outer->capacity() > inner->capacity()) 
+            std::swap(outer, inner);
+        for (const value_type& elem : *outer)
+            if (!inner->has_element(elem)) return false;
+        return true;
+    }
+
+    friend bool operator!=(const raw_hash_set& a, const raw_hash_set& b) {
+        return !(a == b);
+    }
+
+    friend void swap(raw_hash_set& a,
+                     raw_hash_set& b) noexcept(noexcept(a.swap(b))) {
+        a.swap(b);
+    }
+
+    template <class K>
+    size_t hash(const K& key) const {
+        return HashElement{hash_ref()}(key);
+    }
+
+private:
+    template <class Container, typename Enabler>
+    friend struct phmap::priv::hashtable_debug_internal::HashtableDebugAccess;
+
+    struct FindElement 
+    {
+        template <class K, class... Args>
+        const_iterator operator()(const K& key, Args&&...) const {
+            return s.find(key);
+        }
+        const raw_hash_set& s;
+    };
+
+    struct HashElement 
+    {
+        template <class K, class... Args>
+        size_t operator()(const K& key, Args&&...) const {
+            return phmap_mix<sizeof(size_t)>()(h(key));
+        }
+        const hasher& h;
+    };
+
+    template <class K1>
+    struct EqualElement 
+    {
+        template <class K2, class... Args>
+        bool operator()(const K2& lhs, Args&&...) const {
+            return eq(lhs, rhs);
+        }
+        const K1& rhs;
+        const key_equal& eq;
+    };
+
+    template <class K, class... Args>
+    std::pair<iterator, bool> emplace_decomposable(const K& key, size_t hashval, 
+                                                   Args&&... args)
+    {
+        auto res = find_or_prepare_insert(key, hashval);
+        if (res.second) {
+            emplace_at(res.first, std::forward<Args>(args)...);
+        }
+        return {iterator_at(res.first), res.second};
+    }
+
+    struct EmplaceDecomposable 
+    {
+        template <class K, class... Args>
+        std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
+            return s.emplace_decomposable(key, s.hash(key), std::forward<Args>(args)...);
+        }
+        raw_hash_set& s;
+    };
+
+    template <bool do_destroy>
+    struct InsertSlot 
+    {
+        template <class K, class... Args>
+        std::pair<iterator, bool> operator()(const K& key, Args&&...) && {
+            auto res = s.find_or_prepare_insert(key);
+            if (res.second) {
+                PolicyTraits::transfer(&s.alloc_ref(), s.slots_ + res.first, &slot);
+            } else if (do_destroy) {
+                PolicyTraits::destroy(&s.alloc_ref(), &slot);
+            }
+            return {s.iterator_at(res.first), res.second};
+        }
+        raw_hash_set& s;
+        // Constructed slot. Either moved into place or destroyed.
+        slot_type&& slot;
+    };
+
+    template <bool do_destroy>
+    struct InsertSlotWithHash 
+    {
+        template <class K, class... Args>
+        std::pair<iterator, bool> operator()(const K& key, Args&&...) && {
+            auto res = s.find_or_prepare_insert(key, hashval);
+            if (res.second) {
+                PolicyTraits::transfer(&s.alloc_ref(), s.slots_ + res.first, &slot);
+            } else if (do_destroy) {
+                PolicyTraits::destroy(&s.alloc_ref(), &slot);
+            }
+            return {s.iterator_at(res.first), res.second};
+        }
+        raw_hash_set& s;
+        // Constructed slot. Either moved into place or destroyed.
+        slot_type&& slot;
+        size_t &hashval;
+    };
+
+    // "erases" the object from the container, except that it doesn't actually
+    // destroy the object. It only updates all the metadata of the class.
+    // This can be used in conjunction with Policy::transfer to move the object to
+    // another place.
+    void erase_meta_only(const_iterator it) {
+        assert(IsFull(*it.inner_.ctrl_) && "erasing a dangling iterator");
+        --size_;
+        const size_t index = (size_t)(it.inner_.ctrl_ - ctrl_);
+        const size_t index_before = (index - Group::kWidth) & capacity_;
+        const auto empty_after = Group(it.inner_.ctrl_).MatchEmpty();
+        const auto empty_before = Group(ctrl_ + index_before).MatchEmpty();
+
+        // We count how many consecutive non empties we have to the right and to the
+        // left of `it`. If the sum is >= kWidth then there is at least one probe
+        // window that might have seen a full group.
+        bool was_never_full =
+            empty_before && empty_after &&
+            static_cast<size_t>(empty_after.TrailingZeros() +
+                                empty_before.LeadingZeros()) < Group::kWidth;
+
+        set_ctrl(index, was_never_full ? kEmpty : kDeleted);
+        growth_left() += was_never_full;
+        infoz_.RecordErase();
+    }
+
+    void initialize_slots() {
+        assert(capacity_);
+        if (std::is_same<SlotAlloc, std::allocator<slot_type>>::value && 
+            slots_ == nullptr) {
+            infoz_ = Sample();
+        }
+
+        auto layout = MakeLayout(capacity_);
+        char* mem = static_cast<char*>(
+            Allocate<Layout::Alignment()>(&alloc_ref(), layout.AllocSize()));
+        ctrl_ = reinterpret_cast<ctrl_t*>(layout.template Pointer<0>(mem));
+        slots_ = layout.template Pointer<1>(mem);
+        reset_ctrl();
+        reset_growth_left();
+        infoz_.RecordStorageChanged(size_, capacity_);
+    }
+
+    void destroy_slots() {
+        if (!capacity_) return;
+        for (size_t i = 0; i != capacity_; ++i) {
+            if (IsFull(ctrl_[i])) {
+                PolicyTraits::destroy(&alloc_ref(), slots_ + i);
+            }
+        }
+        auto layout = MakeLayout(capacity_);
+        // Unpoison before returning the memory to the allocator.
+        SanitizerUnpoisonMemoryRegion(slots_, sizeof(slot_type) * capacity_);
+        Deallocate<Layout::Alignment()>(&alloc_ref(), ctrl_, layout.AllocSize());
+        ctrl_ = EmptyGroup();
+        slots_ = nullptr;
+        size_ = 0;
+        capacity_ = 0;
+        growth_left() = 0;
+    }
+
+    void resize(size_t new_capacity) {
+        assert(IsValidCapacity(new_capacity));
+        auto* old_ctrl = ctrl_;
+        auto* old_slots = slots_;
+        const size_t old_capacity = capacity_;
+        capacity_ = new_capacity;
+        initialize_slots();
+
+        for (size_t i = 0; i != old_capacity; ++i) {
+            if (IsFull(old_ctrl[i])) {
+                size_t hashval = PolicyTraits::apply(HashElement{hash_ref()},
+                                                     PolicyTraits::element(old_slots + i));
+                auto target = find_first_non_full(hashval);
+                size_t new_i = target.offset;
+                set_ctrl(new_i, H2(hashval));
+                PolicyTraits::transfer(&alloc_ref(), slots_ + new_i, old_slots + i);
+            }
+        }
+        if (old_capacity) {
+            SanitizerUnpoisonMemoryRegion(old_slots,
+                                          sizeof(slot_type) * old_capacity);
+            auto layout = MakeLayout(old_capacity);
+            Deallocate<Layout::Alignment()>(&alloc_ref(), old_ctrl,
+                                            layout.AllocSize());
+        }
+    }
+
+    void drop_deletes_without_resize() PHMAP_ATTRIBUTE_NOINLINE {
+        assert(IsValidCapacity(capacity_));
+        assert(!is_small());
+        // Algorithm:
+        // - mark all DELETED slots as EMPTY
+        // - mark all FULL slots as DELETED
+        // - for each slot marked as DELETED
+        //     hash = Hash(element)
+        //     target = find_first_non_full(hash)
+        //     if target is in the same group
+        //       mark slot as FULL
+        //     else if target is EMPTY
+        //       transfer element to target
+        //       mark slot as EMPTY
+        //       mark target as FULL
+        //     else if target is DELETED
+        //       swap current element with target element
+        //       mark target as FULL
+        //       repeat procedure for current slot with moved from element (target)
+        ConvertDeletedToEmptyAndFullToDeleted(ctrl_, capacity_);
+        typename std::aligned_storage<sizeof(slot_type), alignof(slot_type)>::type
+            raw;
+        slot_type* slot = reinterpret_cast<slot_type*>(&raw);
+        for (size_t i = 0; i != capacity_; ++i) {
+            if (!IsDeleted(ctrl_[i])) continue;
+            size_t hashval = PolicyTraits::apply(HashElement{hash_ref()},
+                                                 PolicyTraits::element(slots_ + i));
+            auto target = find_first_non_full(hashval);
+            size_t new_i = target.offset;
+
+            // Verify if the old and new i fall within the same group wrt the hashval.
+            // If they do, we don't need to move the object as it falls already in the
+            // best probe we can.
+            const auto probe_index = [&](size_t pos) {
+                return ((pos - probe(hashval).offset()) & capacity_) / Group::kWidth;
+            };
+
+            // Element doesn't move.
+            if (PHMAP_PREDICT_TRUE(probe_index(new_i) == probe_index(i))) {
+                set_ctrl(i, H2(hashval));
+                continue;
+            }
+            if (IsEmpty(ctrl_[new_i])) {
+                // Transfer element to the empty spot.
+                // set_ctrl poisons/unpoisons the slots so we have to call it at the
+                // right time.
+                set_ctrl(new_i, H2(hashval));
+                PolicyTraits::transfer(&alloc_ref(), slots_ + new_i, slots_ + i);
+                set_ctrl(i, kEmpty);
+            } else {
+                assert(IsDeleted(ctrl_[new_i]));
+                set_ctrl(new_i, H2(hashval));
+                // Until we are done rehashing, DELETED marks previously FULL slots.
+                // Swap i and new_i elements.
+                PolicyTraits::transfer(&alloc_ref(), slot, slots_ + i);
+                PolicyTraits::transfer(&alloc_ref(), slots_ + i, slots_ + new_i);
+                PolicyTraits::transfer(&alloc_ref(), slots_ + new_i, slot);
+                --i;  // repeat
+            }
+        }
+        reset_growth_left();
+    }
+
+    void rehash_and_grow_if_necessary() {
+        if (capacity_ == 0) {
+            resize(1);
+        } else if (size() <= CapacityToGrowth(capacity()) / 2) {
+            // Squash DELETED without growing if there is enough capacity.
+            drop_deletes_without_resize();
+        } else {
+            // Otherwise grow the container.
+            resize(capacity_ * 2 + 1);
+        }
+    }
+
+    bool has_element(const value_type& elem, size_t hashval) const {
+        auto seq = probe(hashval);
+        while (true) {
+            Group g{ctrl_ + seq.offset()};
+            for (int i : g.Match((h2_t)H2(hashval))) {
+                if (PHMAP_PREDICT_TRUE(PolicyTraits::element(slots_ + seq.offset((size_t)i)) ==
+                                      elem))
+                    return true;
+            }
+            if (PHMAP_PREDICT_TRUE(g.MatchEmpty())) return false;
+            seq.next();
+            assert(seq.getindex() < capacity_ && "full table!");
+        }
+        return false;
+    }
+
+    bool has_element(const value_type& elem) const {
+        size_t hashval = PolicyTraits::apply(HashElement{hash_ref()}, elem);
+        return has_element(elem, hashval);
+    }
+
+    // Probes the raw_hash_set with the probe sequence for hash and returns the
+    // pointer to the first empty or deleted slot.
+    // NOTE: this function must work with tables having both kEmpty and kDelete
+    // in one group. Such tables appears during drop_deletes_without_resize.
+    //
+    // This function is very useful when insertions happen and:
+    // - the input is already a set
+    // - there are enough slots
+    // - the element with the hash is not in the table
+    struct FindInfo 
+    {
+        size_t offset;
+        size_t probe_length;
+    };
+    FindInfo find_first_non_full(size_t hashval) {
+        auto seq = probe(hashval);
+        while (true) {
+            Group g{ctrl_ + seq.offset()};
+            auto mask = g.MatchEmptyOrDeleted();
+            if (mask) {
+                return {seq.offset((size_t)mask.LowestBitSet()), seq.getindex()};
+            }
+            assert(seq.getindex() < capacity_ && "full table!");
+            seq.next();
+        }
+    }
+
+    // TODO(alkis): Optimize this assuming *this and that don't overlap.
+    raw_hash_set& move_assign(raw_hash_set&& that, std::true_type) {
+        raw_hash_set tmp(std::move(that));
+        swap(tmp);
+        return *this;
+    }
+    raw_hash_set& move_assign(raw_hash_set&& that, std::false_type) {
+        raw_hash_set tmp(std::move(that), alloc_ref());
+        swap(tmp);
+        return *this;
+    }
+
+protected:
+    template <class K>
+    std::pair<size_t, bool> find_or_prepare_insert(const K& key, size_t hashval) {
+        auto seq = probe(hashval);
+        while (true) {
+            Group g{ctrl_ + seq.offset()};
+            for (int i : g.Match((h2_t)H2(hashval))) {
+                if (PHMAP_PREDICT_TRUE(PolicyTraits::apply(
+                                          EqualElement<K>{key, eq_ref()},
+                                          PolicyTraits::element(slots_ + seq.offset((size_t)i)))))
+                    return {seq.offset((size_t)i), false};
+            }
+            if (PHMAP_PREDICT_TRUE(g.MatchEmpty())) break;
+            seq.next();
+        }
+        return {prepare_insert(hashval), true};
+    }
+
+    template <class K>
+    std::pair<size_t, bool> find_or_prepare_insert(const K& key) {
+        return find_or_prepare_insert(key, this->hash(key));
+    }
+
+    size_t prepare_insert(size_t hashval) PHMAP_ATTRIBUTE_NOINLINE {
+        auto target = find_first_non_full(hashval);
+        if (PHMAP_PREDICT_FALSE(growth_left() == 0 &&
+                               !IsDeleted(ctrl_[target.offset]))) {
+            rehash_and_grow_if_necessary();
+            target = find_first_non_full(hashval);
+        }
+        ++size_;
+        growth_left() -= IsEmpty(ctrl_[target.offset]);
+        set_ctrl(target.offset, H2(hashval));
+        infoz_.RecordInsert(hashval, target.probe_length);
+        return target.offset;
+    }
+
+    // Constructs the value in the space pointed by the iterator. This only works
+    // after an unsuccessful find_or_prepare_insert() and before any other
+    // modifications happen in the raw_hash_set.
+    //
+    // PRECONDITION: i is an index returned from find_or_prepare_insert(k), where
+    // k is the key decomposed from `forward<Args>(args)...`, and the bool
+    // returned by find_or_prepare_insert(k) was true.
+    // POSTCONDITION: *m.iterator_at(i) == value_type(forward<Args>(args)...).
+    template <class... Args>
+    void emplace_at(size_t i, Args&&... args) {
+        PolicyTraits::construct(&alloc_ref(), slots_ + i,
+                                std::forward<Args>(args)...);
+
+        assert(PolicyTraits::apply(FindElement{*this}, *iterator_at(i)) ==
+               iterator_at(i) &&
+               "constructed value does not match the lookup key");
+    }
+
+    iterator iterator_at(size_t i) { return {ctrl_ + i, slots_ + i}; }
+    const_iterator iterator_at(size_t i) const { return {ctrl_ + i, slots_ + i}; }
+
+private:
+    friend struct RawHashSetTestOnlyAccess;
+
+    probe_seq<Group::kWidth> probe(size_t hashval) const {
+        return probe_seq<Group::kWidth>(H1(hashval, ctrl_), capacity_);
+    }
+
+    // Reset all ctrl bytes back to kEmpty, except the sentinel.
+    void reset_ctrl() {
+        std::memset(ctrl_, kEmpty, capacity_ + Group::kWidth + 1);
+        ctrl_[capacity_] = kSentinel;
+        SanitizerPoisonMemoryRegion(slots_, sizeof(slot_type) * capacity_);
+    }
+
+    void reset_growth_left() {
+        growth_left() = CapacityToGrowth(capacity()) - size_;
+    }
+
+    // Sets the control byte, and if `i < Group::kWidth`, set the cloned byte at
+    // the end too.
+    void set_ctrl(size_t i, ctrl_t h) {
+        assert(i < capacity_);
+
+        if (IsFull(h)) {
+            SanitizerUnpoisonObject(slots_ + i);
+        } else {
+            SanitizerPoisonObject(slots_ + i);
+        }
+
+        ctrl_[i] = h;
+        ctrl_[((i - Group::kWidth) & capacity_) + 1 +
+              ((Group::kWidth - 1) & capacity_)] = h;
+    }
+
+    size_t& growth_left() { return settings_.template get<0>(); }
+
+    template <size_t N,
+              template <class, class, class, class> class RefSet,
+              class M, class P, class H, class E, class A>
+    friend class parallel_hash_set;
+
+    template <size_t N,
+              template <class, class, class, class> class RefSet,
+              class M, class P, class H, class E, class A>
+    friend class parallel_hash_map;
+
+    // The representation of the object has two modes:
+    //  - small: For capacities < kWidth-1
+    //  - large: For the rest.
+    //
+    // Differences:
+    //  - In small mode we are able to use the whole capacity. The extra control
+    //  bytes give us at least one "empty" control byte to stop the iteration.
+    //  This is important to make 1 a valid capacity.
+    //
+    //  - In small mode only the first `capacity()` control bytes after the
+    //  sentinel are valid. The rest contain dummy kEmpty values that do not
+    //  represent a real slot. This is important to take into account on
+    //  find_first_non_full(), where we never try ShouldInsertBackwards() for
+    //  small tables.
+    bool is_small() const { return capacity_ < Group::kWidth - 1; }
+
+    hasher& hash_ref() { return settings_.template get<1>(); }
+    const hasher& hash_ref() const { return settings_.template get<1>(); }
+    key_equal& eq_ref() { return settings_.template get<2>(); }
+    const key_equal& eq_ref() const { return settings_.template get<2>(); }
+    allocator_type& alloc_ref() { return settings_.template get<3>(); }
+    const allocator_type& alloc_ref() const {
+        return settings_.template get<3>();
+    }
+
+    // TODO(alkis): Investigate removing some of these fields:
+    // - ctrl/slots can be derived from each other
+    // - size can be moved into the slot array
+    ctrl_t* ctrl_ = EmptyGroup();    // [(capacity + 1) * ctrl_t]
+    slot_type* slots_ = nullptr;     // [capacity * slot_type]
+    size_t size_ = 0;                // number of full slots
+    size_t capacity_ = 0;            // total number of slots
+    HashtablezInfoHandle infoz_;
+    phmap::priv::CompressedTuple<size_t /* growth_left */, hasher,
+                                              key_equal, allocator_type>
+    settings_{0, hasher{}, key_equal{}, allocator_type{}};
+};
+
+
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+template <class Policy, class Hash, class Eq, class Alloc>
+class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> 
+{
+    // P is Policy. It's passed as a template argument to support maps that have
+    // incomplete types as values, as in unordered_map<K, IncompleteType>.
+    // MappedReference<> may be a non-reference type.
+    template <class P>
+    using MappedReference = decltype(P::value(
+               std::addressof(std::declval<typename raw_hash_map::reference>())));
+
+    // MappedConstReference<> may be a non-reference type.
+    template <class P>
+    using MappedConstReference = decltype(P::value(
+               std::addressof(std::declval<typename raw_hash_map::const_reference>())));
+
+    using KeyArgImpl =
+        KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>;
+
+    using Base = raw_hash_set<Policy, Hash, Eq, Alloc>;
+
+public:
+    using key_type = typename Policy::key_type;
+    using mapped_type = typename Policy::mapped_type;
+    template <class K>
+    using key_arg = typename KeyArgImpl::template type<K, key_type>;
+
+    static_assert(!std::is_reference<key_type>::value, "");
+    // TODO(alkis): remove this assertion and verify that reference mapped_type is
+    // supported.
+    static_assert(!std::is_reference<mapped_type>::value, "");
+
+    using iterator = typename raw_hash_map::raw_hash_set::iterator;
+    using const_iterator = typename raw_hash_map::raw_hash_set::const_iterator;
+
+    raw_hash_map() {}
+    using Base::raw_hash_set; // use raw_hash_set constructor  
+
+    // The last two template parameters ensure that both arguments are rvalues
+    // (lvalue arguments are handled by the overloads below). This is necessary
+    // for supporting bitfield arguments.
+    //
+    //   union { int n : 1; };
+    //   flat_hash_map<int, int> m;
+    //   m.insert_or_assign(n, n);
+    template <class K = key_type, class V = mapped_type, K* = nullptr,
+              V* = nullptr>
+    std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, V&& v) {
+        return insert_or_assign_impl(std::forward<K>(k), std::forward<V>(v));
+    }
+
+    template <class K = key_type, class V = mapped_type, K* = nullptr>
+    std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, const V& v) {
+        return insert_or_assign_impl(std::forward<K>(k), v);
+    }
+
+    template <class K = key_type, class V = mapped_type, V* = nullptr>
+    std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, V&& v) {
+        return insert_or_assign_impl(k, std::forward<V>(v));
+    }
+
+    template <class K = key_type, class V = mapped_type>
+    std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, const V& v) {
+        return insert_or_assign_impl(k, v);
+    }
+
+    template <class K = key_type, class V = mapped_type, K* = nullptr,
+              V* = nullptr>
+    iterator insert_or_assign(const_iterator, key_arg<K>&& k, V&& v) {
+        return insert_or_assign(std::forward<K>(k), std::forward<V>(v)).first;
+    }
+
+    template <class K = key_type, class V = mapped_type, K* = nullptr>
+    iterator insert_or_assign(const_iterator, key_arg<K>&& k, const V& v) {
+        return insert_or_assign(std::forward<K>(k), v).first;
+    }
+
+    template <class K = key_type, class V = mapped_type, V* = nullptr>
+    iterator insert_or_assign(const_iterator, const key_arg<K>& k, V&& v) {
+        return insert_or_assign(k, std::forward<V>(v)).first;
+    }
+
+    template <class K = key_type, class V = mapped_type>
+    iterator insert_or_assign(const_iterator, const key_arg<K>& k, const V& v) {
+        return insert_or_assign(k, v).first;
+    }
+
+    template <class K = key_type, class... Args,
+              typename std::enable_if<
+                  !std::is_convertible<K, const_iterator>::value, int>::type = 0,
+              K* = nullptr>
+    std::pair<iterator, bool> try_emplace(key_arg<K>&& k, Args&&... args) {
+        return try_emplace_impl(std::forward<K>(k), std::forward<Args>(args)...);
+    }
+
+    template <class K = key_type, class... Args,
+              typename std::enable_if<
+                  !std::is_convertible<K, const_iterator>::value, int>::type = 0>
+    std::pair<iterator, bool> try_emplace(const key_arg<K>& k, Args&&... args) {
+        return try_emplace_impl(k, std::forward<Args>(args)...);
+    }
+
+    template <class K = key_type, class... Args, K* = nullptr>
+    iterator try_emplace(const_iterator, key_arg<K>&& k, Args&&... args) {
+        return try_emplace(std::forward<K>(k), std::forward<Args>(args)...).first;
+    }
+
+    template <class K = key_type, class... Args>
+    iterator try_emplace(const_iterator, const key_arg<K>& k, Args&&... args) {
+        return try_emplace(k, std::forward<Args>(args)...).first;
+    }
+
+    template <class K = key_type, class P = Policy>
+    MappedReference<P> at(const key_arg<K>& key) {
+        auto it = this->find(key);
+        if (it == this->end()) 
+            phmap::base_internal::ThrowStdOutOfRange("phmap at(): lookup non-existent key");
+        return Policy::value(&*it);
+    }
+
+    template <class K = key_type, class P = Policy>
+    MappedConstReference<P> at(const key_arg<K>& key) const {
+        auto it = this->find(key);
+        if (it == this->end())
+            phmap::base_internal::ThrowStdOutOfRange("phmap at(): lookup non-existent key");
+        return Policy::value(&*it);
+    }
+
+    template <class K = key_type, class P = Policy, K* = nullptr>
+    MappedReference<P> operator[](key_arg<K>&& key) {
+        return Policy::value(&*try_emplace(std::forward<K>(key)).first);
+    }
+
+    template <class K = key_type, class P = Policy>
+    MappedReference<P> operator[](const key_arg<K>& key) {
+        return Policy::value(&*try_emplace(key).first);
+    }
+
+private:
+    template <class K, class V>
+    std::pair<iterator, bool> insert_or_assign_impl(K&& k, V&& v) {
+        auto res = this->find_or_prepare_insert(k);
+        if (res.second)
+            this->emplace_at(res.first, std::forward<K>(k), std::forward<V>(v));
+        else
+            Policy::value(&*this->iterator_at(res.first)) = std::forward<V>(v);
+        return {this->iterator_at(res.first), res.second};
+    }
+
+    template <class K = key_type, class... Args>
+    std::pair<iterator, bool> try_emplace_impl(K&& k, Args&&... args) {
+        auto res = this->find_or_prepare_insert(k);
+        if (res.second)
+            this->emplace_at(res.first, std::piecewise_construct,
+                             std::forward_as_tuple(std::forward<K>(k)),
+                             std::forward_as_tuple(std::forward<Args>(args)...));
+        return {this->iterator_at(res.first), res.second};
+    }
+};
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// Returns "random" seed.
+inline size_t RandomSeed() 
+{
+#if PHMAP_HAVE_THREAD_LOCAL
+    static thread_local size_t counter = 0;
+    size_t value = ++counter;
+#else   // PHMAP_HAVE_THREAD_LOCAL
+    static std::atomic<size_t> counter(0);
+    size_t value = counter.fetch_add(1, std::memory_order_relaxed);
+#endif  // PHMAP_HAVE_THREAD_LOCAL
+    return value ^ static_cast<size_t>(reinterpret_cast<uintptr_t>(&counter));
+}
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+template <size_t N,
+          template <class, class, class, class> class RefSet,
+          class Mtx_,
+          class Policy, class Hash, class Eq, class Alloc>
+class parallel_hash_set 
+{
+    using PolicyTraits = hash_policy_traits<Policy>;
+    using KeyArgImpl =
+        KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>;
+
+    static_assert(N <= 12, "N = 12 means 4096 hash tables!");
+    constexpr static size_t num_tables = 1 << N;
+    constexpr static size_t mask = num_tables - 1;
+
+public:
+    using EmbeddedSet     = RefSet<Policy, Hash, Eq, Alloc>;
+    using EmbeddedIterator= typename EmbeddedSet::iterator;
+    using EmbeddedConstIterator= typename EmbeddedSet::const_iterator;
+    using constructor     = typename EmbeddedSet::constructor;
+    using init_type       = typename PolicyTraits::init_type;
+    using key_type        = typename PolicyTraits::key_type;
+    using slot_type       = typename PolicyTraits::slot_type;
+    using allocator_type  = Alloc;
+    using size_type       = size_t;
+    using difference_type = ptrdiff_t;
+    using hasher          = Hash;
+    using key_equal       = Eq;
+    using policy_type     = Policy;
+    using value_type      = typename PolicyTraits::value_type;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+    using pointer         = typename phmap::allocator_traits<
+        allocator_type>::template rebind_traits<value_type>::pointer;
+    using const_pointer   = typename phmap::allocator_traits<
+        allocator_type>::template rebind_traits<value_type>::const_pointer;
+
+    // Alias used for heterogeneous lookup functions.
+    // `key_arg<K>` evaluates to `K` when the functors are transparent and to
+    // `key_type` otherwise. It permits template argument deduction on `K` for the
+    // transparent case.
+    // --------------------------------------------------------------------
+    template <class K>
+    using key_arg         = typename KeyArgImpl::template type<K, key_type>;
+
+protected:
+    using Lockable = phmap::LockableImpl<Mtx_>;
+
+    // --------------------------------------------------------------------
+    struct Inner : public Lockable
+    {
+        bool operator==(const Inner& o) const
+        {
+            typename Lockable::SharedLocks l(const_cast<Inner &>(*this), const_cast<Inner &>(o));
+            return set_ == o.set_;
+        }
+
+        EmbeddedSet set_;
+    };
+
+private:
+    // Give an early error when key_type is not hashable/eq.
+    // --------------------------------------------------------------------
+    auto KeyTypeCanBeHashed(const Hash& h, const key_type& k) -> decltype(h(k));
+    auto KeyTypeCanBeEq(const Eq& eq, const key_type& k)      -> decltype(eq(k, k));
+
+    using AllocTraits     = phmap::allocator_traits<allocator_type>;
+
+    static_assert(std::is_lvalue_reference<reference>::value,
+                  "Policy::element() must return a reference");
+
+    template <typename T>
+    struct SameAsElementReference : std::is_same<
+        typename std::remove_cv<typename std::remove_reference<reference>::type>::type,
+        typename std::remove_cv<typename std::remove_reference<T>::type>::type> {};
+
+    // An enabler for insert(T&&): T must be convertible to init_type or be the
+    // same as [cv] value_type [ref].
+    // Note: we separate SameAsElementReference into its own type to avoid using
+    // reference unless we need to. MSVC doesn't seem to like it in some
+    // cases.
+    // --------------------------------------------------------------------
+    template <class T>
+    using RequiresInsertable = typename std::enable_if<
+        phmap::disjunction<std::is_convertible<T, init_type>,
+                          SameAsElementReference<T>>::value,
+        int>::type;
+
+    // RequiresNotInit is a workaround for gcc prior to 7.1.
+    // See https://godbolt.org/g/Y4xsUh.
+    template <class T>
+    using RequiresNotInit =
+        typename std::enable_if<!std::is_same<T, init_type>::value, int>::type;
+
+    template <class... Ts>
+    using IsDecomposable = IsDecomposable<void, PolicyTraits, Hash, Eq, Ts...>;
+
+public:
+    static_assert(std::is_same<pointer, value_type*>::value,
+                  "Allocators with custom pointer types are not supported");
+    static_assert(std::is_same<const_pointer, const value_type*>::value,
+                  "Allocators with custom pointer types are not supported");
+
+    // --------------------- i t e r a t o r ------------------------------
+    class iterator 
+    {
+        friend class parallel_hash_set;
+
+    public:
+        using iterator_category = std::forward_iterator_tag;
+        using value_type        = typename parallel_hash_set::value_type;
+        using reference         =
+            phmap::conditional_t<PolicyTraits::constant_iterators::value,
+                                const value_type&, value_type&>;
+        using pointer           = phmap::remove_reference_t<reference>*;
+        using difference_type   = typename parallel_hash_set::difference_type;
+        using Inner             = typename parallel_hash_set::Inner;
+        using EmbeddedSet       = typename parallel_hash_set::EmbeddedSet;
+        using EmbeddedIterator  = typename EmbeddedSet::iterator;
+
+        iterator() {}
+
+        reference operator*()  const { return *it_; }
+        pointer   operator->() const { return &operator*(); }
+
+        iterator& operator++() {
+            assert(inner_); // null inner means we are already at the end
+            ++it_;
+            skip_empty();
+            return *this;
+        }
+    
+        iterator operator++(int) {
+            assert(inner_);  // null inner means we are already at the end
+            auto tmp = *this;
+            ++*this;
+            return tmp;
+        }
+
+        friend bool operator==(const iterator& a, const iterator& b) {
+            return a.inner_ == b.inner_ && (!a.inner_ || a.it_ == b.it_);
+        }
+
+        friend bool operator!=(const iterator& a, const iterator& b) {
+            return !(a == b);
+        }
+
+    private:
+        iterator(Inner *inner, Inner *inner_end, const EmbeddedIterator& it) : 
+            inner_(inner), inner_end_(inner_end), it_(it)  {  // for begin() and end()
+            if (inner)
+                it_end_ = inner->set_.end();
+        }
+
+        void skip_empty() {
+            while (it_ == it_end_) {
+                ++inner_;
+                if (inner_ == inner_end_) {
+                    inner_ = nullptr; // marks end()
+                    break;
+                }
+                else {
+                    it_ = inner_->set_.begin();
+                    it_end_ = inner_->set_.end();
+                }
+            }
+        }
+
+        Inner *inner_      = nullptr;
+        Inner *inner_end_  = nullptr;
+        EmbeddedIterator it_, it_end_;
+    };
+
+    // --------------------- c o n s t   i t e r a t o r -----------------
+    class const_iterator 
+    {
+        friend class parallel_hash_set;
+
+    public:
+        using iterator_category = typename iterator::iterator_category;
+        using value_type        = typename parallel_hash_set::value_type;
+        using reference         = typename parallel_hash_set::const_reference;
+        using pointer           = typename parallel_hash_set::const_pointer;
+        using difference_type   = typename parallel_hash_set::difference_type;
+        using Inner             = typename parallel_hash_set::Inner;
+
+        const_iterator() {}
+        // Implicit construction from iterator.
+        const_iterator(iterator i) : iter_(std::move(i)) {}
+
+        reference operator*()  const { return *(iter_); }
+        pointer   operator->() const { return iter_.operator->(); }
+
+        const_iterator& operator++() {
+            ++iter_;
+            return *this;
+        }
+        const_iterator operator++(int) { return iter_++; }
+
+        friend bool operator==(const const_iterator& a, const const_iterator& b) {
+            return a.iter_ == b.iter_;
+        }
+        friend bool operator!=(const const_iterator& a, const const_iterator& b) {
+            return !(a == b);
+        }
+
+    private:
+        const_iterator(const Inner *inner, const Inner *inner_end, const EmbeddedIterator& it)
+            : iter_(const_cast<Inner**>(inner), 
+                    const_cast<Inner**>(inner_end),
+                    const_cast<EmbeddedIterator*>(it)) {}
+
+        iterator iter_;
+    };
+
+    using node_type = node_handle<Policy, hash_policy_traits<Policy>, Alloc>;
+    using insert_return_type = InsertReturnType<iterator, node_type>;
+
+    // ------------------------- c o n s t r u c t o r s ------------------
+
+    parallel_hash_set() noexcept(
+        std::is_nothrow_default_constructible<hasher>::value&&
+        std::is_nothrow_default_constructible<key_equal>::value&&
+        std::is_nothrow_default_constructible<allocator_type>::value) {}
+
+    explicit parallel_hash_set(size_t bucket_count, 
+                               const hasher& hash_param    = hasher(),
+                               const key_equal& eq         = key_equal(),
+                               const allocator_type& alloc = allocator_type()) {
+        for (auto& inner : sets_)
+            inner.set_ = EmbeddedSet(bucket_count / N, hash_param, eq, alloc);
+    }
+
+    parallel_hash_set(size_t bucket_count, 
+                      const hasher& hash_param,
+                      const allocator_type& alloc)
+        : parallel_hash_set(bucket_count, hash_param, key_equal(), alloc) {}
+
+    parallel_hash_set(size_t bucket_count, const allocator_type& alloc)
+        : parallel_hash_set(bucket_count, hasher(), key_equal(), alloc) {}
+
+    explicit parallel_hash_set(const allocator_type& alloc)
+        : parallel_hash_set(0, hasher(), key_equal(), alloc) {}
+
+    template <class InputIter>
+    parallel_hash_set(InputIter first, InputIter last, size_t bucket_count = 0,
+                      const hasher& hash_param = hasher(), const key_equal& eq = key_equal(),
+                      const allocator_type& alloc = allocator_type())
+        : parallel_hash_set(bucket_count, hash_param, eq, alloc) {
+        insert(first, last);
+    }
+
+    template <class InputIter>
+    parallel_hash_set(InputIter first, InputIter last, size_t bucket_count,
+                      const hasher& hash_param, const allocator_type& alloc)
+        : parallel_hash_set(first, last, bucket_count, hash_param, key_equal(), alloc) {}
+
+    template <class InputIter>
+    parallel_hash_set(InputIter first, InputIter last, size_t bucket_count,
+                      const allocator_type& alloc)
+        : parallel_hash_set(first, last, bucket_count, hasher(), key_equal(), alloc) {}
+
+    template <class InputIter>
+    parallel_hash_set(InputIter first, InputIter last, const allocator_type& alloc)
+        : parallel_hash_set(first, last, 0, hasher(), key_equal(), alloc) {}
+
+    // Instead of accepting std::initializer_list<value_type> as the first
+    // argument like std::unordered_set<value_type> does, we have two overloads
+    // that accept std::initializer_list<T> and std::initializer_list<init_type>.
+    // This is advantageous for performance.
+    //
+    //   // Turns {"abc", "def"} into std::initializer_list<std::string>, then copies
+    //   // the strings into the set.
+    //   std::unordered_set<std::string> s = {"abc", "def"};
+    //
+    //   // Turns {"abc", "def"} into std::initializer_list<const char*>, then
+    //   // copies the strings into the set.
+    //   phmap::flat_hash_set<std::string> s = {"abc", "def"};
+    //
+    // The same trick is used in insert().
+    //
+    // The enabler is necessary to prevent this constructor from triggering where
+    // the copy constructor is meant to be called.
+    //
+    //   phmap::flat_hash_set<int> a, b{a};
+    //
+    // RequiresNotInit<T> is a workaround for gcc prior to 7.1.
+    // --------------------------------------------------------------------
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+    parallel_hash_set(std::initializer_list<T> init, size_t bucket_count = 0,
+                      const hasher& hash_param = hasher(), const key_equal& eq = key_equal(),
+                      const allocator_type& alloc = allocator_type())
+        : parallel_hash_set(init.begin(), init.end(), bucket_count, hash_param, eq, alloc) {}
+
+    parallel_hash_set(std::initializer_list<init_type> init, size_t bucket_count = 0,
+                      const hasher& hash_param = hasher(), const key_equal& eq = key_equal(),
+                      const allocator_type& alloc = allocator_type())
+        : parallel_hash_set(init.begin(), init.end(), bucket_count, hash_param, eq, alloc) {}
+
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+    parallel_hash_set(std::initializer_list<T> init, size_t bucket_count,
+                      const hasher& hash_param, const allocator_type& alloc)
+        : parallel_hash_set(init, bucket_count, hash_param, key_equal(), alloc) {}
+
+    parallel_hash_set(std::initializer_list<init_type> init, size_t bucket_count,
+                      const hasher& hash_param, const allocator_type& alloc)
+        : parallel_hash_set(init, bucket_count, hash_param, key_equal(), alloc) {}
+
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+    parallel_hash_set(std::initializer_list<T> init, size_t bucket_count,
+                      const allocator_type& alloc)
+        : parallel_hash_set(init, bucket_count, hasher(), key_equal(), alloc) {}
+
+    parallel_hash_set(std::initializer_list<init_type> init, size_t bucket_count,
+                      const allocator_type& alloc)
+        : parallel_hash_set(init, bucket_count, hasher(), key_equal(), alloc) {}
+
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+    parallel_hash_set(std::initializer_list<T> init, const allocator_type& alloc)
+        : parallel_hash_set(init, 0, hasher(), key_equal(), alloc) {}
+  
+    parallel_hash_set(std::initializer_list<init_type> init,
+                      const allocator_type& alloc)
+        : parallel_hash_set(init, 0, hasher(), key_equal(), alloc) {}
+
+    parallel_hash_set(const parallel_hash_set& that)
+        : parallel_hash_set(that, AllocTraits::select_on_container_copy_construction(
+                                that.alloc_ref())) {}
+
+    parallel_hash_set(const parallel_hash_set& that, const allocator_type& a)
+        : parallel_hash_set(0, that.hash_ref(), that.eq_ref(), a) {
+        for (size_t i=0; i<num_tables; ++i)
+            sets_[i].set_ = { that.sets_[i].set_, a };
+    }
+  
+    parallel_hash_set(parallel_hash_set&& that) noexcept(
+        std::is_nothrow_copy_constructible<hasher>::value&&
+        std::is_nothrow_copy_constructible<key_equal>::value&&
+        std::is_nothrow_copy_constructible<allocator_type>::value)
+        : parallel_hash_set(std::move(that), that.alloc_ref()) {
+    }
+
+    parallel_hash_set(parallel_hash_set&& that, const allocator_type& a)
+    {
+        for (size_t i=0; i<num_tables; ++i)
+            sets_[i].set_ = { std::move(that.sets_[i]).set_, a };
+    }
+
+    parallel_hash_set& operator=(const parallel_hash_set& that) {
+        for (size_t i=0; i<num_tables; ++i)
+            sets_[i].set_ = that.sets_[i].set_;
+        return *this;
+    }
+
+    parallel_hash_set& operator=(parallel_hash_set&& that) noexcept(
+        phmap::allocator_traits<allocator_type>::is_always_equal::value &&
+        std::is_nothrow_move_assignable<hasher>::value &&
+        std::is_nothrow_move_assignable<key_equal>::value) {
+        for (size_t i=0; i<num_tables; ++i)
+            sets_[i].set_ = std::move(that.sets_[i].set_);
+        return *this;
+    }
+
+    ~parallel_hash_set() {}
+
+    iterator begin() {
+        auto it = iterator(&sets_[0], &sets_[0] + num_tables, sets_[0].set_.begin());
+        it.skip_empty();
+        return it;
+    }
+
+    iterator       end()          { return iterator(); }
+    const_iterator begin()  const { return const_cast<parallel_hash_set *>(this)->begin(); }
+    const_iterator end()    const { return const_cast<parallel_hash_set *>(this)->end(); }
+    const_iterator cbegin() const { return begin(); }
+    const_iterator cend()   const { return end(); }
+
+    bool empty() const { return !size(); }
+
+    size_t size() const { 
+        size_t sz = 0;
+        for (const auto& inner : sets_)
+            sz += inner.set_.size();
+        return sz; 
+    }
+  
+    size_t capacity() const { 
+        size_t c = 0;
+        for (const auto& inner : sets_)
+            c += inner.set_.capacity();
+        return c; 
+    }
+
+    size_t max_size() const { return (std::numeric_limits<size_t>::max)(); }
+
+    PHMAP_ATTRIBUTE_REINITIALIZES void clear() {
+        for (auto& inner : sets_)
+            inner.set_.clear();
+    }
+
+    // This overload kicks in when the argument is an rvalue of insertable and
+    // decomposable type other than init_type.
+    //
+    //   flat_hash_map<std::string, int> m;
+    //   m.insert(std::make_pair("abc", 42));
+    // --------------------------------------------------------------------
+    template <class T, RequiresInsertable<T> = 0,
+              typename std::enable_if<IsDecomposable<T>::value, int>::type = 0,
+              T* = nullptr>
+    std::pair<iterator, bool> insert(T&& value) {
+        return emplace(std::forward<T>(value));
+    }
+
+    // This overload kicks in when the argument is a bitfield or an lvalue of
+    // insertable and decomposable type.
+    //
+    //   union { int n : 1; };
+    //   flat_hash_set<int> s;
+    //   s.insert(n);
+    //
+    //   flat_hash_set<std::string> s;
+    //   const char* p = "hello";
+    //   s.insert(p);
+    //
+    // TODO(romanp): Once we stop supporting gcc 5.1 and below, replace
+    // RequiresInsertable<T> with RequiresInsertable<const T&>.
+    // We are hitting this bug: https://godbolt.org/g/1Vht4f.
+    // --------------------------------------------------------------------
+    template <
+        class T, RequiresInsertable<T> = 0,
+        typename std::enable_if<IsDecomposable<const T&>::value, int>::type = 0>
+    std::pair<iterator, bool> insert(const T& value) {
+        return emplace(value);
+    }
+
+    // This overload kicks in when the argument is an rvalue of init_type. Its
+    // purpose is to handle brace-init-list arguments.
+    //
+    //   flat_hash_set<std::pair<std::string, int>> s;
+    //   s.insert({"abc", 42});
+    // --------------------------------------------------------------------
+    std::pair<iterator, bool> insert(init_type&& value) {
+        return emplace(std::move(value));
+    }
+
+    template <class T, RequiresInsertable<T> = 0,
+              typename std::enable_if<IsDecomposable<T>::value, int>::type = 0,
+              T* = nullptr>
+    iterator insert(const_iterator, T&& value) {
+        return insert(std::forward<T>(value)).first;
+    }
+
+    // TODO(romanp): Once we stop supporting gcc 5.1 and below, replace
+    // RequiresInsertable<T> with RequiresInsertable<const T&>.
+    // We are hitting this bug: https://godbolt.org/g/1Vht4f.
+    // --------------------------------------------------------------------
+    template <
+        class T, RequiresInsertable<T> = 0,
+        typename std::enable_if<IsDecomposable<const T&>::value, int>::type = 0>
+    iterator insert(const_iterator, const T& value) {
+        return insert(value).first;
+    }
+
+    iterator insert(const_iterator, init_type&& value) {
+        return insert(std::move(value)).first;
+    }
+
+    template <class InputIt>
+    void insert(InputIt first, InputIt last) {
+        for (; first != last; ++first) insert(*first);
+    }
+
+    template <class T, RequiresNotInit<T> = 0, RequiresInsertable<const T&> = 0>
+    void insert(std::initializer_list<T> ilist) {
+        insert(ilist.begin(), ilist.end());
+    }
+
+    void insert(std::initializer_list<init_type> ilist) {
+        insert(ilist.begin(), ilist.end());
+    }
+
+    insert_return_type insert(node_type&& node) {
+        if (!node) 
+            return {end(), false, node_type()};
+        auto& key      = node.key();
+        size_t hashval = this->hash(key);
+        Inner& inner   = sets_[subidx(hashval)];
+        auto&  set     = inner.set_;
+
+        typename Lockable::UniqueLock m(inner);
+        auto   res  = set.insert(std::move(node), hashval);
+        return { make_iterator(&inner, res.position),
+                res.inserted,
+                res.inserted ? node_type() : std::move(res.node) };
+    }
+
+    iterator insert(const_iterator, node_type&& node) {
+        return insert(std::move(node)).first;
+    }
+
+    struct ReturnKey_ 
+    {
+        template <class Key, class... Args>
+        Key operator()(Key&& k, const Args&...) const {
+            return std::forward<Key>(k);
+        }
+    };
+
+    template <class K, class... Args>
+    std::pair<iterator, bool> emplace_decomposable(const K& key, Args&&... args)
+    {
+        size_t hashval = this->hash(key);
+        Inner& inner   = sets_[subidx(hashval)];
+        auto&  set     = inner.set_;
+        typename Lockable::UniqueLock m(inner);
+        return make_rv(&inner, set.emplace_decomposable(key, hashval, std::forward<Args>(args)...));
+    }
+
+    struct EmplaceDecomposable 
+    {
+        template <class K, class... Args>
+        std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
+            return s.emplace_decomposable(key, std::forward<Args>(args)...);
+        }
+        parallel_hash_set& s;
+    };
+
+    // This overload kicks in if we can deduce the key from args. This enables us
+    // to avoid constructing value_type if an entry with the same key already
+    // exists.
+    //
+    // For example:
+    //
+    //   flat_hash_map<std::string, std::string> m = {{"abc", "def"}};
+    //   // Creates no std::string copies and makes no heap allocations.
+    //   m.emplace("abc", "xyz");
+    // --------------------------------------------------------------------
+    template <class... Args, typename std::enable_if<
+                                 IsDecomposable<Args...>::value, int>::type = 0>
+    std::pair<iterator, bool> emplace(Args&&... args) {
+        return PolicyTraits::apply(EmplaceDecomposable{*this},
+                                   std::forward<Args>(args)...);
+    }
+
+    // This overload kicks in if we cannot deduce the key from args. It constructs
+    // value_type unconditionally and then either moves it into the table or
+    // destroys.
+    // --------------------------------------------------------------------
+    template <class... Args, typename std::enable_if<
+                                 !IsDecomposable<Args...>::value, int>::type = 0>
+    std::pair<iterator, bool> emplace(Args&&... args) {
+        typename std::aligned_storage<sizeof(slot_type), alignof(slot_type)>::type
+            raw;
+        slot_type* slot = reinterpret_cast<slot_type*>(&raw);
+
+        PolicyTraits::construct(&alloc_ref(), slot, std::forward<Args>(args)...);
+        const auto& elem = PolicyTraits::element(slot);
+        size_t hashval  = this->hash(PolicyTraits::key(slot));
+        Inner& inner    = sets_[subidx(hashval)];
+        auto&  set      = inner.set_;
+        typename Lockable::UniqueLock m(inner);
+        typename EmbeddedSet::template InsertSlotWithHash<true> f {
+            inner, std::move(*slot), hashval};
+        return make_rv(PolicyTraits::apply(f, elem));
+    }
+
+    template <class... Args>
+    iterator emplace_hint(const_iterator, Args&&... args) {
+        return emplace(std::forward<Args>(args)...).first;
+    }
+
+    iterator make_iterator(Inner* inner, const EmbeddedIterator it)
+    {
+        if (it == inner->set_.end())
+            return iterator();
+        return iterator(inner, &sets_[0] + num_tables, it);
+    }
+
+    std::pair<iterator, bool> make_rv(Inner* inner, 
+                                      const std::pair<EmbeddedIterator, bool>& res)
+    {
+        return {iterator(inner, &sets_[0] + num_tables, res.first), res.second};
+    }
+
+    template <class K = key_type, class F>
+    iterator lazy_emplace(const key_arg<K>& key, F&& f) {
+        auto hashval = this->hash(key);
+        Inner& inner = sets_[subidx(hashval)];
+        auto&  set   = inner.set_;
+        typename Lockable::UniqueLock m(inner);
+        return make_iterator(&inner, set.lazy_emplace_with_hash(key, hashval, std::forward<F>(f)));
+    }
+
+    template <class K = key_type, class FExists, class FEmplace>
+    bool lazy_emplace_l(const key_arg<K>& key, FExists&& fExists, FEmplace&& fEmplace) {
+        typename Lockable::UniqueLock m;
+        auto res = this->find_or_prepare_insert(key, m);
+        Inner* inner = std::get<0>(res);
+        if (std::get<2>(res))
+            inner->set_.lazy_emplace_at(std::get<1>(res), std::forward<FEmplace>(fEmplace));
+        else {
+            auto it = this->iterator_at(inner, inner->set_.iterator_at(std::get<1>(res)));
+            std::forward<FExists>(fExists)(Policy::value(&*it));
+        }
+        return std::get<2>(res);
+    }
+
+    // Extension API: support for heterogeneous keys.
+    //
+    //   std::unordered_set<std::string> s;
+    //   // Turns "abc" into std::string.
+    //   s.erase("abc");
+    //
+    //   flat_hash_set<std::string> s;
+    //   // Uses "abc" directly without copying it into std::string.
+    //   s.erase("abc");
+    // --------------------------------------------------------------------
+    template <class K = key_type>
+    size_type erase(const key_arg<K>& key) {
+        auto hashval = this->hash(key);
+        Inner& inner = sets_[subidx(hashval)];
+        auto&  set   = inner.set_;
+        typename Lockable::UpgradeLock m(inner);
+        auto it   = set.find(key, hashval);
+        if (it == set.end()) 
+            return 0;
+
+        typename Lockable::UpgradeToUnique unique(m);
+        set._erase(it);
+        return 1;
+    }
+
+    // --------------------------------------------------------------------
+    iterator erase(const_iterator cit) { return erase(cit.iter_); }
+
+    // Erases the element pointed to by `it`.  Unlike `std::unordered_set::erase`,
+    // this method returns void to reduce algorithmic complexity to O(1).  In
+    // order to erase while iterating across a map, use the following idiom (which
+    // also works for standard containers):
+    //
+    // for (auto it = m.begin(), end = m.end(); it != end;) {
+    //   if (<pred>) {
+    //     m._erase(it++);
+    //   } else {
+    //     ++it;
+    //   }
+    // }
+    // --------------------------------------------------------------------
+    void _erase(iterator it) {
+        assert(it.inner_ != nullptr);
+        it.inner_->set_._erase(it.it_);
+    }
+    void _erase(const_iterator cit) { _erase(cit.iter_); }
+
+    // This overload is necessary because otherwise erase<K>(const K&) would be
+    // a better match if non-const iterator is passed as an argument.
+    // --------------------------------------------------------------------
+    iterator erase(iterator it) { _erase(it++); return it; }
+
+    iterator erase(const_iterator first, const_iterator last) {
+        while (first != last) {
+            _erase(first++);
+        }
+        return last.iter_;
+    }
+
+    // Moves elements from `src` into `this`.
+    // If the element already exists in `this`, it is left unmodified in `src`.
+    // --------------------------------------------------------------------
+    template <typename E = Eq>
+    void merge(parallel_hash_set<N, RefSet, Mtx_, Policy, Hash, E, Alloc>& src) {  // NOLINT
+        assert(this != &src);
+        if (this != &src)
+        {
+            for (size_t i=0; i<num_tables; ++i)
+            {
+                typename Lockable::UniqueLocks l(sets_[i], src.sets_[i]);
+                sets_[i].set_.merge(src.sets_[i].set_);
+            }
+        }
+    }
+
+    template <typename E = Eq>
+    void merge(parallel_hash_set<N, RefSet, Mtx_, Policy, Hash, E, Alloc>&& src) {
+        merge(src);
+    }
+
+    node_type extract(const_iterator position) {
+        return position.iter_.inner_->set_.extract(EmbeddedConstIterator(position.iter_.it_));
+    }
+
+    template <
+        class K = key_type,
+        typename std::enable_if<!std::is_same<K, iterator>::value, int>::type = 0>
+    node_type extract(const key_arg<K>& key) {
+        auto it = find(key);
+        return it == end() ? node_type() : extract(const_iterator{it});
+    }
+
+    void swap(parallel_hash_set& that) noexcept(
+        IsNoThrowSwappable<EmbeddedSet>() &&
+        (!AllocTraits::propagate_on_container_swap::value ||
+         IsNoThrowSwappable<allocator_type>())) {
+        using std::swap;
+        for (size_t i=0; i<num_tables; ++i)
+        {
+            typename Lockable::UniqueLocks l(sets_[i], that.sets_[i]);
+            swap(sets_[i].set_, that.sets_[i].set_);
+        }
+    }
+
+    void rehash(size_t n) {
+        size_t nn = n / num_tables;
+        for (auto& inner : sets_)
+        {
+            typename Lockable::UniqueLock m(inner);
+            inner.set_.rehash(nn);
+        }
+    }
+
+    void reserve(size_t n) 
+    {
+        size_t target = GrowthToLowerboundCapacity(n);
+        size_t normalized = 16 * NormalizeCapacity(n / num_tables);
+        rehash(normalized > target ? normalized : target); 
+    }
+
+    // Extension API: support for heterogeneous keys.
+    //
+    //   std::unordered_set<std::string> s;
+    //   // Turns "abc" into std::string.
+    //   s.count("abc");
+    //
+    //   ch_set<std::string> s;
+    //   // Uses "abc" directly without copying it into std::string.
+    //   s.count("abc");
+    // --------------------------------------------------------------------
+    template <class K = key_type>
+    size_t count(const key_arg<K>& key) const {
+        return find(key) == end() ? 0 : 1;
+    }
+
+    // Issues CPU prefetch instructions for the memory needed to find or insert
+    // a key.  Like all lookup functions, this support heterogeneous keys.
+    //
+    // NOTE: This is a very low level operation and should not be used without
+    // specific benchmarks indicating its importance.
+    // --------------------------------------------------------------------
+    template <class K = key_type>
+    void prefetch(const key_arg<K>& key) const {
+        (void)key;
+        size_t hashval     = this->hash(key);
+        const Inner& inner = sets_[subidx(hashval)];
+        const auto&  set   = inner.set_;
+        typename Lockable::SharedLock m(const_cast<Inner&>(inner));
+        set.prefetch_hash(hashval);
+    }
+
+    // The API of find() has two extensions.
+    //
+    // 1. The hash can be passed by the user. It must be equal to the hash of the
+    // key.
+    //
+    // 2. The type of the key argument doesn't have to be key_type. This is so
+    // called heterogeneous key support.
+    // --------------------------------------------------------------------
+    template <class K = key_type>
+    iterator find(const key_arg<K>& key, size_t hashval) {
+        typename Lockable::SharedLock m;
+        return find(key, hashval, m);
+    }
+
+    template <class K = key_type>
+    iterator find(const key_arg<K>& key) {
+        return find(key, this->hash(key));
+    }
+
+    template <class K = key_type>
+    const_iterator find(const key_arg<K>& key, size_t hashval) const {
+        return const_cast<parallel_hash_set*>(this)->find(key, hashval);
+    }
+
+    template <class K = key_type>
+    const_iterator find(const key_arg<K>& key) const {
+        return find(key, this->hash(key));
+    }
+
+    template <class K = key_type>
+    bool contains(const key_arg<K>& key) const {
+        return find(key) != end();
+    }
+
+    template <class K = key_type>
+    bool contains(const key_arg<K>& key, size_t hashval) const {
+        return find(key, hashval) != end();
+    }
+
+    template <class K = key_type>
+    std::pair<iterator, iterator> equal_range(const key_arg<K>& key) {
+        auto it = find(key);
+        if (it != end()) return {it, std::next(it)};
+        return {it, it};
+    }
+
+    template <class K = key_type>
+    std::pair<const_iterator, const_iterator> equal_range(
+        const key_arg<K>& key) const {
+        auto it = find(key);
+        if (it != end()) return {it, std::next(it)};
+        return {it, it};
+    }
+
+    size_t bucket_count() const {
+        size_t sz = 0;
+        for (const auto& inner : sets_)
+        {
+            typename Lockable::SharedLock m(const_cast<Inner&>(inner));
+            sz += inner.set_.bucket_count();
+        }
+        return sz; 
+    }
+
+    float load_factor() const {
+        size_t capacity = bucket_count();
+        return capacity ? static_cast<float>(static_cast<double>(size()) / capacity) : 0;
+    }
+
+    float max_load_factor() const { return 1.0f; }
+    void max_load_factor(float) {
+        // Does nothing.
+    }
+
+    hasher hash_function() const { return hash_ref(); }  // warning: doesn't match internal hash - use hash() member function
+    key_equal key_eq() const { return eq_ref(); }
+    allocator_type get_allocator() const { return alloc_ref(); }
+
+    friend bool operator==(const parallel_hash_set& a, const parallel_hash_set& b) {
+        return std::equal(a.sets_.begin(), a.sets_.end(), b.sets_.begin());
+    }
+
+    friend bool operator!=(const parallel_hash_set& a, const parallel_hash_set& b) {
+        return !(a == b);
+    }
+
+    friend void swap(parallel_hash_set& a,
+                     parallel_hash_set& b) noexcept(noexcept(a.swap(b))) {
+        a.swap(b);
+    }
+
+    template <class K>
+    size_t hash(const K& key) const {
+        return HashElement{hash_ref()}(key);
+    }
+
+#ifndef PHMAP_NON_DETERMINISTIC
+    template<typename OutputArchive>
+    bool dump(OutputArchive& ar) const;
+
+    template<typename InputArchive>
+    bool load(InputArchive& ar);
+#endif
+
+private:
+    template <class Container, typename Enabler>
+    friend struct phmap::priv::hashtable_debug_internal::HashtableDebugAccess;
+
+    struct FindElement 
+    {
+        template <class K, class... Args>
+        const_iterator operator()(const K& key, Args&&...) const {
+            return s.find(key);
+        }
+        const parallel_hash_set& s;
+    };
+
+    struct HashElement 
+    {
+        template <class K, class... Args>
+        size_t operator()(const K& key, Args&&...) const {
+            return phmap_mix<sizeof(size_t)>()(h(key));
+        }
+        const hasher& h;
+    };
+
+    template <class K1>
+    struct EqualElement 
+    {
+        template <class K2, class... Args>
+        bool operator()(const K2& lhs, Args&&...) const {
+            return eq(lhs, rhs);
+        }
+        const K1& rhs;
+        const key_equal& eq;
+    };
+
+    // "erases" the object from the container, except that it doesn't actually
+    // destroy the object. It only updates all the metadata of the class.
+    // This can be used in conjunction with Policy::transfer to move the object to
+    // another place.
+    // --------------------------------------------------------------------
+    void erase_meta_only(const_iterator cit) {
+        auto &it = cit.iter_;
+        assert(it.set_ != nullptr);
+        it.set_.erase_meta_only(const_iterator(it.it_));
+    }
+
+    void drop_deletes_without_resize() PHMAP_ATTRIBUTE_NOINLINE {
+        for (auto& inner : sets_)
+        {
+            typename Lockable::UniqueLock m(inner);
+            inner.set_.drop_deletes_without_resize();
+        }
+    }
+
+    bool has_element(const value_type& elem) const {
+        size_t hashval = PolicyTraits::apply(HashElement{hash_ref()}, elem);
+        Inner& inner   = sets_[subidx(hashval)];
+        auto&  set     = inner.set_;
+        typename Lockable::SharedLock m(const_cast<Inner&>(inner));
+        return set.has_element(elem, hashval);
+    }
+
+    // TODO(alkis): Optimize this assuming *this and that don't overlap.
+    // --------------------------------------------------------------------
+    parallel_hash_set& move_assign(parallel_hash_set&& that, std::true_type) {
+        parallel_hash_set tmp(std::move(that));
+        swap(tmp);
+        return *this;
+    }
+
+    parallel_hash_set& move_assign(parallel_hash_set&& that, std::false_type) {
+        parallel_hash_set tmp(std::move(that), alloc_ref());
+        swap(tmp);
+        return *this;
+    }
+
+protected:
+    template <class K = key_type, class L = typename Lockable::SharedLock>
+    iterator find(const key_arg<K>& key, size_t hashval, L &mutexlock) {
+        Inner& inner = sets_[subidx(hashval)];
+        auto&  set = inner.set_;
+        mutexlock = std::move(L(inner));
+        auto  it = set.find(key, hashval);
+        return make_iterator(&inner, it);
+    }
+
+    template <class K>
+    std::tuple<Inner*, size_t, bool> 
+    find_or_prepare_insert(const K& key, typename Lockable::UniqueLock &mutexlock) {
+        auto hashval = this->hash(key);
+        Inner& inner = sets_[subidx(hashval)];
+        auto&  set   = inner.set_;
+        mutexlock    = std::move(typename Lockable::UniqueLock(inner));
+        auto  p   = set.find_or_prepare_insert(key, hashval); // std::pair<size_t, bool>
+        return std::make_tuple(&inner, p.first, p.second);
+    }
+
+    iterator iterator_at(Inner *inner, 
+                         const EmbeddedIterator& it) { 
+        return {inner, &sets_[0] + num_tables, it}; 
+    }
+    const_iterator iterator_at(Inner *inner, 
+                               const EmbeddedIterator& it) const { 
+        return {inner, &sets_[0] + num_tables, it}; 
+    }
+
+    static size_t subidx(size_t hashval) {
+        return ((hashval >> 8) ^ (hashval >> 16) ^ (hashval >> 24)) & mask;
+    }
+
+    static size_t subcnt() {
+        return num_tables;
+    }
+
+private:
+    friend struct RawHashSetTestOnlyAccess;
+
+    size_t growth_left() { 
+        size_t sz = 0;
+        for (const auto& set : sets_)
+            sz += set.growth_left();
+        return sz; 
+    }
+
+    hasher&       hash_ref()        { return sets_[0].set_.hash_ref(); }
+    const hasher& hash_ref() const  { return sets_[0].set_.hash_ref(); }
+    key_equal&       eq_ref()       { return sets_[0].set_.eq_ref(); }
+    const key_equal& eq_ref() const { return sets_[0].set_.eq_ref(); }
+    allocator_type&  alloc_ref()    { return sets_[0].set_.alloc_ref(); }
+    const allocator_type& alloc_ref() const { 
+        return sets_[0].set_.alloc_ref();
+    }
+
+    std::array<Inner, num_tables> sets_;
+};
+
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+template <size_t N,
+          template <class, class, class, class> class RefSet,
+          class Mtx_,
+          class Policy, class Hash, class Eq, class Alloc>
+class parallel_hash_map : public parallel_hash_set<N, RefSet, Mtx_, Policy, Hash, Eq, Alloc> 
+{
+    // P is Policy. It's passed as a template argument to support maps that have
+    // incomplete types as values, as in unordered_map<K, IncompleteType>.
+    // MappedReference<> may be a non-reference type.
+    template <class P>
+    using MappedReference = decltype(P::value(
+            std::addressof(std::declval<typename parallel_hash_map::reference>())));
+
+    // MappedConstReference<> may be a non-reference type.
+    template <class P>
+    using MappedConstReference = decltype(P::value(
+            std::addressof(std::declval<typename parallel_hash_map::const_reference>())));
+
+    using KeyArgImpl =
+        KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>;
+
+    using Base = typename parallel_hash_map::parallel_hash_set;
+    using Lockable = phmap::LockableImpl<Mtx_>;
+
+public:
+    using key_type = typename Policy::key_type;
+    using mapped_type = typename Policy::mapped_type;
+    template <class K>
+    using key_arg = typename KeyArgImpl::template type<K, key_type>;
+
+    static_assert(!std::is_reference<key_type>::value, "");
+    // TODO(alkis): remove this assertion and verify that reference mapped_type is
+    // supported.
+    static_assert(!std::is_reference<mapped_type>::value, "");
+
+    using iterator = typename parallel_hash_map::parallel_hash_set::iterator;
+    using const_iterator = typename parallel_hash_map::parallel_hash_set::const_iterator;
+
+    parallel_hash_map() {}
+
+#ifdef __INTEL_COMPILER
+    using Base::parallel_hash_set;
+#else
+    using parallel_hash_map::parallel_hash_set::parallel_hash_set;
+#endif
+
+    // The last two template parameters ensure that both arguments are rvalues
+    // (lvalue arguments are handled by the overloads below). This is necessary
+    // for supporting bitfield arguments.
+    //
+    //   union { int n : 1; };
+    //   flat_hash_map<int, int> m;
+    //   m.insert_or_assign(n, n);
+    template <class K = key_type, class V = mapped_type, K* = nullptr,
+              V* = nullptr>
+    std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, V&& v) {
+        return insert_or_assign_impl(std::forward<K>(k), std::forward<V>(v));
+    }
+
+    template <class K = key_type, class V = mapped_type, K* = nullptr>
+    std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, const V& v) {
+        return insert_or_assign_impl(std::forward<K>(k), v);
+    }
+
+    template <class K = key_type, class V = mapped_type, V* = nullptr>
+    std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, V&& v) {
+        return insert_or_assign_impl(k, std::forward<V>(v));
+    }
+
+    template <class K = key_type, class V = mapped_type>
+    std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, const V& v) {
+        return insert_or_assign_impl(k, v);
+    }
+
+    template <class K = key_type, class V = mapped_type, K* = nullptr,
+              V* = nullptr>
+    iterator insert_or_assign(const_iterator, key_arg<K>&& k, V&& v) {
+        return insert_or_assign(std::forward<K>(k), std::forward<V>(v)).first;
+    }
+
+    template <class K = key_type, class V = mapped_type, K* = nullptr>
+    iterator insert_or_assign(const_iterator, key_arg<K>&& k, const V& v) {
+        return insert_or_assign(std::forward<K>(k), v).first;
+    }
+
+    template <class K = key_type, class V = mapped_type, V* = nullptr>
+    iterator insert_or_assign(const_iterator, const key_arg<K>& k, V&& v) {
+        return insert_or_assign(k, std::forward<V>(v)).first;
+    }
+
+    template <class K = key_type, class V = mapped_type>
+    iterator insert_or_assign(const_iterator, const key_arg<K>& k, const V& v) {
+        return insert_or_assign(k, v).first;
+    }
+
+    template <class K = key_type, class... Args,
+              typename std::enable_if<
+                  !std::is_convertible<K, const_iterator>::value, int>::type = 0,
+              K* = nullptr>
+    std::pair<iterator, bool> try_emplace(key_arg<K>&& k, Args&&... args) {
+        return try_emplace_impl(std::forward<K>(k), std::forward<Args>(args)...);
+    }
+
+    template <class K = key_type, class... Args,
+              typename std::enable_if<
+                  !std::is_convertible<K, const_iterator>::value, int>::type = 0>
+    std::pair<iterator, bool> try_emplace(const key_arg<K>& k, Args&&... args) {
+        return try_emplace_impl(k, std::forward<Args>(args)...);
+    }
+
+    template <class K = key_type, class... Args, K* = nullptr>
+    iterator try_emplace(const_iterator, key_arg<K>&& k, Args&&... args) {
+        return try_emplace(std::forward<K>(k), std::forward<Args>(args)...).first;
+    }
+
+    template <class K = key_type, class... Args>
+    iterator try_emplace(const_iterator, const key_arg<K>& k, Args&&... args) {
+        return try_emplace(k, std::forward<Args>(args)...).first;
+    }
+
+    template <class K = key_type, class P = Policy>
+    MappedReference<P> at(const key_arg<K>& key) {
+        auto it = this->find(key);
+        if (it == this->end()) 
+            phmap::base_internal::ThrowStdOutOfRange("phmap at(): lookup non-existent key");
+        return Policy::value(&*it);
+    }
+
+    template <class K = key_type, class P = Policy>
+    MappedConstReference<P> at(const key_arg<K>& key) const {
+        auto it = this->find(key);
+        if (it == this->end()) 
+            phmap::base_internal::ThrowStdOutOfRange("phmap at(): lookup non-existent key");
+        return Policy::value(&*it);
+    }
+
+    // ----------- phmap extensions --------------------------
+
+    // if map contains key, lambda is called with the mapped value (under read lock protection),
+    // and if_contains returns true. This is a const API and lambda should not modify the value
+    // -----------------------------------------------------------------------------------------
+    template <class K = key_type, class F>
+    bool if_contains(const key_arg<K>& key, F&& f) const {
+        return const_cast<parallel_hash_map*>(this)->template 
+            modify_if_impl<K, F, typename Lockable::SharedLock>(key, std::forward<F>(f));
+    }
+
+    // if map contains key, lambda is called with the mapped value  (under write lock protection),
+    // and modify_if returns true. This is a non-const API and lambda is allowed to modify the mapped value
+    // ----------------------------------------------------------------------------------------------------
+    template <class K = key_type, class F>
+    bool modify_if(const key_arg<K>& key, F&& f) {
+        return modify_if_impl<K, F, typename Lockable::UniqueLock>(key, std::forward<F>(f));
+    }
+
+    // if map does not contains key, it is inserted and the mapped value is value-constructed 
+    // with the provided arguments (if any), as with try_emplace. 
+    // Then the lambda is called with the mapped value (under write lock protection) and can 
+    // update the mapped value.
+    // ---------------------------------------------------------------------------------------
+    template <class K = key_type, class F, class... Args>
+    bool try_emplace_l(K&& k, F&& f, Args&&... args) {
+        typename Lockable::UniqueLock m;
+        auto res = this->find_or_prepare_insert(k, m);
+        typename Base::Inner *inner = std::get<0>(res);
+        if (std::get<2>(res))
+            inner->set_.emplace_at(std::get<1>(res), std::piecewise_construct,
+                                   std::forward_as_tuple(std::forward<K>(k)),
+                                   std::forward_as_tuple(std::forward<Args>(args)...));
+        else {
+            auto it = this->iterator_at(inner, inner->set_.iterator_at(std::get<1>(res)));
+            std::forward<F>(f)(Policy::value(&*it));
+        }
+        return std::get<2>(res);
+    }
+
+    // ----------- end of phmap extensions --------------------------
+
+    template <class K = key_type, class P = Policy, K* = nullptr>
+    MappedReference<P> operator[](key_arg<K>&& key) {
+        return Policy::value(&*try_emplace(std::forward<K>(key)).first);
+    }
+
+    template <class K = key_type, class P = Policy>
+    MappedReference<P> operator[](const key_arg<K>& key) {
+        return Policy::value(&*try_emplace(key).first);
+    }
+
+private:
+    template <class K = key_type, class F, class L>
+    bool modify_if_impl(const key_arg<K>& key, F&& f) {
+#if __cplusplus >= 201703L
+        static_assert(std::is_invocable<F, mapped_type&>::value);
+#endif
+        L m;
+        auto it = this->template find<K, L>(key, this->hash(key), m);
+        if (it == this->end())
+            return false;
+        std::forward<F>(f)(Policy::value(&*it));
+        return true;
+    }
+
+    template <class K, class V>
+    std::pair<iterator, bool> insert_or_assign_impl(K&& k, V&& v) {
+        typename Lockable::UniqueLock m;
+        auto res = this->find_or_prepare_insert(k, m);
+        typename Base::Inner *inner = std::get<0>(res);
+        if (std::get<2>(res))
+            inner->set_.emplace_at(std::get<1>(res), std::forward<K>(k), std::forward<V>(v));
+        else
+            Policy::value(&*inner->set_.iterator_at(std::get<1>(res))) = std::forward<V>(v);
+        return {this->iterator_at(inner, inner->set_.iterator_at(std::get<1>(res))), 
+                std::get<2>(res)};
+    }
+
+    template <class K = key_type, class... Args>
+    std::pair<iterator, bool> try_emplace_impl(K&& k, Args&&... args) {
+        typename Lockable::UniqueLock m;
+        auto res = this->find_or_prepare_insert(k, m);
+        typename Base::Inner *inner = std::get<0>(res);
+        if (std::get<2>(res))
+            inner->set_.emplace_at(std::get<1>(res), std::piecewise_construct,
+                                   std::forward_as_tuple(std::forward<K>(k)),
+                                   std::forward_as_tuple(std::forward<Args>(args)...));
+        return {this->iterator_at(inner, inner->set_.iterator_at(std::get<1>(res))), 
+                std::get<2>(res)};
+    }
+};
+
+
+// Constructs T into uninitialized storage pointed by `ptr` using the args
+// specified in the tuple.
+// ----------------------------------------------------------------------------
+template <class Alloc, class T, class Tuple>
+void ConstructFromTuple(Alloc* alloc, T* ptr, Tuple&& t) {
+    memory_internal::ConstructFromTupleImpl(
+        alloc, ptr, std::forward<Tuple>(t),
+        phmap::make_index_sequence<
+        std::tuple_size<typename std::decay<Tuple>::type>::value>());
+}
+
+// Constructs T using the args specified in the tuple and calls F with the
+// constructed value.
+// ----------------------------------------------------------------------------
+template <class T, class Tuple, class F>
+decltype(std::declval<F>()(std::declval<T>())) WithConstructed(
+    Tuple&& t, F&& f) {
+    return memory_internal::WithConstructedImpl<T>(
+        std::forward<Tuple>(t),
+        phmap::make_index_sequence<
+        std::tuple_size<typename std::decay<Tuple>::type>::value>(),
+        std::forward<F>(f));
+}
+
+// ----------------------------------------------------------------------------
+// Given arguments of an std::pair's consructor, PairArgs() returns a pair of
+// tuples with references to the passed arguments. The tuples contain
+// constructor arguments for the first and the second elements of the pair.
+//
+// The following two snippets are equivalent.
+//
+// 1. std::pair<F, S> p(args...);
+//
+// 2. auto a = PairArgs(args...);
+//    std::pair<F, S> p(std::piecewise_construct,
+//                      std::move(p.first), std::move(p.second));
+// ----------------------------------------------------------------------------
+inline std::pair<std::tuple<>, std::tuple<>> PairArgs() { return {}; }
+
+template <class F, class S>
+std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
+  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
+          std::forward_as_tuple(std::forward<S>(s))};
+}
+
+template <class F, class S>
+std::pair<std::tuple<const F&>, std::tuple<const S&>> PairArgs(
+    const std::pair<F, S>& p) {
+    return PairArgs(p.first, p.second);
+}
+
+template <class F, class S>
+std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(std::pair<F, S>&& p) {
+    return PairArgs(std::forward<F>(p.first), std::forward<S>(p.second));
+}
+
+template <class F, class S>
+auto PairArgs(std::piecewise_construct_t, F&& f, S&& s)
+    -> decltype(std::make_pair(memory_internal::TupleRef(std::forward<F>(f)),
+                               memory_internal::TupleRef(std::forward<S>(s)))) {
+    return std::make_pair(memory_internal::TupleRef(std::forward<F>(f)),
+                          memory_internal::TupleRef(std::forward<S>(s)));
+}
+
+// A helper function for implementing apply() in map policies.
+// ----------------------------------------------------------------------------
+template <class F, class... Args>
+auto DecomposePair(F&& f, Args&&... args)
+    -> decltype(memory_internal::DecomposePairImpl(
+        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
+    return memory_internal::DecomposePairImpl(
+        std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
+}
+
+// A helper function for implementing apply() in set policies.
+// ----------------------------------------------------------------------------
+template <class F, class Arg>
+decltype(std::declval<F>()(std::declval<const Arg&>(), std::declval<Arg>()))
+DecomposeValue(F&& f, Arg&& arg) {
+    const auto& key = arg;
+    return std::forward<F>(f)(key, std::forward<Arg>(arg));
+}
+
+
+// --------------------------------------------------------------------------
+// Policy: a policy defines how to perform different operations on
+// the slots of the hashtable (see hash_policy_traits.h for the full interface
+// of policy).
+//
+// Hash: a (possibly polymorphic) functor that hashes keys of the hashtable. The
+// functor should accept a key and return size_t as hash. For best performance
+// it is important that the hash function provides high entropy across all bits
+// of the hash.
+//
+// Eq: a (possibly polymorphic) functor that compares two keys for equality. It
+// should accept two (of possibly different type) keys and return a bool: true
+// if they are equal, false if they are not. If two keys compare equal, then
+// their hash values as defined by Hash MUST be equal.
+//
+// Allocator: an Allocator [https://devdocs.io/cpp/concept/allocator] with which
+// the storage of the hashtable will be allocated and the elements will be
+// constructed and destroyed.
+// --------------------------------------------------------------------------
+template <class T>
+struct FlatHashSetPolicy 
+{
+    using slot_type = T;
+    using key_type = T;
+    using init_type = T;
+    using constant_iterators = std::true_type;
+
+    template <class Allocator, class... Args>
+    static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
+        phmap::allocator_traits<Allocator>::construct(*alloc, slot,
+                                                     std::forward<Args>(args)...);
+    }
+
+    template <class Allocator>
+    static void destroy(Allocator* alloc, slot_type* slot) {
+        phmap::allocator_traits<Allocator>::destroy(*alloc, slot);
+    }
+
+    template <class Allocator>
+    static void transfer(Allocator* alloc, slot_type* new_slot,
+                         slot_type* old_slot) {
+        construct(alloc, new_slot, std::move(*old_slot));
+        destroy(alloc, old_slot);
+    }
+
+    static T& element(slot_type* slot) { return *slot; }
+
+    template <class F, class... Args>
+    static decltype(phmap::priv::DecomposeValue(
+                        std::declval<F>(), std::declval<Args>()...))
+    apply(F&& f, Args&&... args) {
+        return phmap::priv::DecomposeValue(
+            std::forward<F>(f), std::forward<Args>(args)...);
+    }
+
+    static size_t space_used(const T*) { return 0; }
+};
+
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+template <class K, class V>
+struct FlatHashMapPolicy 
+{
+    using slot_policy = priv::map_slot_policy<K, V>;
+    using slot_type = typename slot_policy::slot_type;
+    using key_type = K;
+    using mapped_type = V;
+    using init_type = std::pair</*non const*/ key_type, mapped_type>;
+
+    template <class Allocator, class... Args>
+    static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
+        slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
+    }
+
+    template <class Allocator>
+    static void destroy(Allocator* alloc, slot_type* slot) {
+        slot_policy::destroy(alloc, slot);
+    }
+
+    template <class Allocator>
+    static void transfer(Allocator* alloc, slot_type* new_slot,
+                         slot_type* old_slot) {
+        slot_policy::transfer(alloc, new_slot, old_slot);
+    }
+
+    template <class F, class... Args>
+    static decltype(phmap::priv::DecomposePair(
+                        std::declval<F>(), std::declval<Args>()...))
+    apply(F&& f, Args&&... args) {
+        return phmap::priv::DecomposePair(std::forward<F>(f),
+                                                        std::forward<Args>(args)...);
+    }
+
+    static size_t space_used(const slot_type*) { return 0; }
+
+    static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
+
+    static V& value(std::pair<const K, V>* kv) { return kv->second; }
+    static const V& value(const std::pair<const K, V>* kv) { return kv->second; }
+};
+
+template <class Reference, class Policy>
+struct node_hash_policy {
+    static_assert(std::is_lvalue_reference<Reference>::value, "");
+
+    using slot_type = typename std::remove_cv<
+        typename std::remove_reference<Reference>::type>::type*;
+
+    template <class Alloc, class... Args>
+    static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
+        *slot = Policy::new_element(alloc, std::forward<Args>(args)...);
+    }
+
+    template <class Alloc>
+    static void destroy(Alloc* alloc, slot_type* slot) {
+        Policy::delete_element(alloc, *slot);
+    }
+
+    template <class Alloc>
+    static void transfer(Alloc*, slot_type* new_slot, slot_type* old_slot) {
+        *new_slot = *old_slot;
+    }
+
+    static size_t space_used(const slot_type* slot) {
+        if (slot == nullptr) return Policy::element_space_used(nullptr);
+        return Policy::element_space_used(*slot);
+    }
+
+    static Reference element(slot_type* slot) { return **slot; }
+
+    template <class T, class P = Policy>
+    static auto value(T* elem) -> decltype(P::value(elem)) {
+        return P::value(elem);
+    }
+
+    template <class... Ts, class P = Policy>
+    static auto apply(Ts&&... ts) -> decltype(P::apply(std::forward<Ts>(ts)...)) {
+        return P::apply(std::forward<Ts>(ts)...);
+    }
+};
+
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+template <class T>
+struct NodeHashSetPolicy
+    : phmap::priv::node_hash_policy<T&, NodeHashSetPolicy<T>> 
+{
+    using key_type = T;
+    using init_type = T;
+    using constant_iterators = std::true_type;
+
+    template <class Allocator, class... Args>
+        static T* new_element(Allocator* alloc, Args&&... args) {
+        using ValueAlloc =
+            typename phmap::allocator_traits<Allocator>::template rebind_alloc<T>;
+        ValueAlloc value_alloc(*alloc);
+        T* res = phmap::allocator_traits<ValueAlloc>::allocate(value_alloc, 1);
+        phmap::allocator_traits<ValueAlloc>::construct(value_alloc, res,
+                                                       std::forward<Args>(args)...);
+        return res;
+    }
+
+    template <class Allocator>
+        static void delete_element(Allocator* alloc, T* elem) {
+        using ValueAlloc =
+            typename phmap::allocator_traits<Allocator>::template rebind_alloc<T>;
+        ValueAlloc value_alloc(*alloc);
+        phmap::allocator_traits<ValueAlloc>::destroy(value_alloc, elem);
+        phmap::allocator_traits<ValueAlloc>::deallocate(value_alloc, elem, 1);
+    }
+
+    template <class F, class... Args>
+        static decltype(phmap::priv::DecomposeValue(
+                            std::declval<F>(), std::declval<Args>()...))
+        apply(F&& f, Args&&... args) {
+        return phmap::priv::DecomposeValue(
+            std::forward<F>(f), std::forward<Args>(args)...);
+    }
+
+    static size_t element_space_used(const T*) { return sizeof(T); }
+};
+
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+template <class Key, class Value>
+class NodeHashMapPolicy
+    : public phmap::priv::node_hash_policy<
+          std::pair<const Key, Value>&, NodeHashMapPolicy<Key, Value>> 
+{
+    using value_type = std::pair<const Key, Value>;
+
+public:
+    using key_type = Key;
+    using mapped_type = Value;
+    using init_type = std::pair</*non const*/ key_type, mapped_type>;
+
+    template <class Allocator, class... Args>
+        static value_type* new_element(Allocator* alloc, Args&&... args) {
+        using PairAlloc = typename phmap::allocator_traits<
+            Allocator>::template rebind_alloc<value_type>;
+        PairAlloc pair_alloc(*alloc);
+        value_type* res =
+            phmap::allocator_traits<PairAlloc>::allocate(pair_alloc, 1);
+        phmap::allocator_traits<PairAlloc>::construct(pair_alloc, res,
+                                                      std::forward<Args>(args)...);
+        return res;
+    }
+
+    template <class Allocator>
+        static void delete_element(Allocator* alloc, value_type* pair) {
+        using PairAlloc = typename phmap::allocator_traits<
+            Allocator>::template rebind_alloc<value_type>;
+        PairAlloc pair_alloc(*alloc);
+        phmap::allocator_traits<PairAlloc>::destroy(pair_alloc, pair);
+        phmap::allocator_traits<PairAlloc>::deallocate(pair_alloc, pair, 1);
+    }
+
+    template <class F, class... Args>
+        static decltype(phmap::priv::DecomposePair(
+                            std::declval<F>(), std::declval<Args>()...))
+        apply(F&& f, Args&&... args) {
+        return phmap::priv::DecomposePair(std::forward<F>(f),
+                                                        std::forward<Args>(args)...);
+    }
+
+    static size_t element_space_used(const value_type*) {
+        return sizeof(value_type);
+    }
+
+    static Value& value(value_type* elem) { return elem->second; }
+    static const Value& value(const value_type* elem) { return elem->second; }
+};
+
+
+// --------------------------------------------------------------------------
+//  hash_default
+// --------------------------------------------------------------------------
+
+#if PHMAP_HAVE_STD_STRING_VIEW
+
+// support char16_t wchar_t ....
+template<class CharT> 
+struct StringHashT 
+{
+    using is_transparent = void;
+
+    size_t operator()(std::basic_string_view<CharT> v) const {
+        std::string_view bv{reinterpret_cast<const char*>(v.data()), v.size() * sizeof(CharT)};
+        return std::hash<std::string_view>()(bv);
+    }
+};
+
+// Supports heterogeneous lookup for basic_string<T>-like elements.
+template<class CharT> 
+struct StringHashEqT
+{
+    using Hash = StringHashT<CharT>;
+
+    struct Eq {
+        using is_transparent = void;
+
+        bool operator()(std::basic_string_view<CharT> lhs, std::basic_string_view<CharT> rhs) const {
+            return lhs == rhs;
+        }
+    };
+};
+
+template <>
+struct HashEq<std::string> : StringHashEqT<char> {};
+
+template <>
+struct HashEq<std::string_view> : StringHashEqT<char> {};
+
+// char16_t
+template <>
+struct HashEq<std::u16string> : StringHashEqT<char16_t> {};
+
+template <>
+struct HashEq<std::u16string_view> : StringHashEqT<char16_t> {};
+
+// wchar_t
+template <>
+struct HashEq<std::wstring> : StringHashEqT<wchar_t> {};
+
+template <>
+struct HashEq<std::wstring_view> : StringHashEqT<wchar_t> {};
+
+#endif
+
+// Supports heterogeneous lookup for pointers and smart pointers.
+// -------------------------------------------------------------
+template <class T>
+struct HashEq<T*> 
+{
+    struct Hash {
+        using is_transparent = void;
+        template <class U>
+        size_t operator()(const U& ptr) const {
+            return phmap::Hash<const T*>{}(HashEq::ToPtr(ptr));
+        }
+    };
+
+    struct Eq {
+        using is_transparent = void;
+        template <class A, class B>
+        bool operator()(const A& a, const B& b) const {
+            return HashEq::ToPtr(a) == HashEq::ToPtr(b);
+        }
+    };
+
+private:
+    static const T* ToPtr(const T* ptr) { return ptr; }
+
+    template <class U, class D>
+    static const T* ToPtr(const std::unique_ptr<U, D>& ptr) {
+        return ptr.get();
+    }
+
+    template <class U>
+    static const T* ToPtr(const std::shared_ptr<U>& ptr) {
+        return ptr.get();
+    }
+};
+
+template <class T, class D>
+struct HashEq<std::unique_ptr<T, D>> : HashEq<T*> {};
+
+template <class T>
+struct HashEq<std::shared_ptr<T>> : HashEq<T*> {};
+
+namespace hashtable_debug_internal {
+
+// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------
+template <typename Set>
+struct HashtableDebugAccess<Set, phmap::void_t<typename Set::raw_hash_set>> 
+{
+    using Traits = typename Set::PolicyTraits;
+    using Slot = typename Traits::slot_type;
+
+    static size_t GetNumProbes(const Set& set,
+                               const typename Set::key_type& key) {
+        size_t num_probes = 0;
+        size_t hashval = set.hash(key); 
+        auto seq = set.probe(hashval);
+        while (true) {
+            priv::Group g{set.ctrl_ + seq.offset()};
+            for (int i : g.Match(priv::H2(hashval))) {
+                if (Traits::apply(
+                        typename Set::template EqualElement<typename Set::key_type>{
+                            key, set.eq_ref()},
+                        Traits::element(set.slots_ + seq.offset((size_t)i))))
+                    return num_probes;
+                ++num_probes;
+            }
+            if (g.MatchEmpty()) return num_probes;
+            seq.next();
+            ++num_probes;
+        }
+    }
+
+    static size_t AllocatedByteSize(const Set& c) {
+        size_t capacity = c.capacity_;
+        if (capacity == 0) return 0;
+        auto layout = Set::MakeLayout(capacity);
+        size_t m = layout.AllocSize();
+
+        size_t per_slot = Traits::space_used(static_cast<const Slot*>(nullptr));
+        if (per_slot != ~size_t{}) {
+            m += per_slot * c.size();
+        } else {
+            for (size_t i = 0; i != capacity; ++i) {
+                if (priv::IsFull(c.ctrl_[i])) {
+                    m += Traits::space_used(c.slots_ + i);
+                }
+            }
+        }
+        return m;
+    }
+
+    static size_t LowerBoundAllocatedByteSize(size_t size) {
+        size_t capacity = GrowthToLowerboundCapacity(size);
+        if (capacity == 0) return 0;
+        auto layout = Set::MakeLayout(NormalizeCapacity(capacity));
+        size_t m = layout.AllocSize();
+        size_t per_slot = Traits::space_used(static_cast<const Slot*>(nullptr));
+        if (per_slot != ~size_t{}) {
+            m += per_slot * size;
+        }
+        return m;
+    }
+};
+
+}  // namespace hashtable_debug_internal
+}  // namespace priv
+
+// -----------------------------------------------------------------------------
+// phmap::flat_hash_set
+// -----------------------------------------------------------------------------
+// An `phmap::flat_hash_set<T>` is an unordered associative container which has
+// been optimized for both speed and memory footprint in most common use cases.
+// Its interface is similar to that of `std::unordered_set<T>` with the
+// following notable differences:
+//
+// * Supports heterogeneous lookup, through `find()`, `operator[]()` and
+//   `insert()`, provided that the set is provided a compatible heterogeneous
+//   hashing function and equality operator.
+// * Invalidates any references and pointers to elements within the table after
+//   `rehash()`.
+// * Contains a `capacity()` member function indicating the number of element
+//   slots (open, deleted, and empty) within the hash set.
+// * Returns `void` from the `_erase(iterator)` overload.
+// -----------------------------------------------------------------------------
+template <class T, class Hash, class Eq, class Alloc> // default values in phmap_fwd_decl.h
+class flat_hash_set
+    : public phmap::priv::raw_hash_set<
+          phmap::priv::FlatHashSetPolicy<T>, Hash, Eq, Alloc> 
+{
+    using Base = typename flat_hash_set::raw_hash_set;
+
+public:
+    flat_hash_set() {}
+#ifdef __INTEL_COMPILER
+    using Base::raw_hash_set;
+#else
+    using Base::Base;
+#endif
+    using Base::begin;
+    using Base::cbegin;
+    using Base::cend;
+    using Base::end;
+    using Base::capacity;
+    using Base::empty;
+    using Base::max_size;
+    using Base::size;
+    using Base::clear; // may shrink - To avoid shrinking `erase(begin(), end())`
+    using Base::erase;
+    using Base::insert;
+    using Base::emplace;
+    using Base::emplace_hint; 
+    using Base::extract;
+    using Base::merge;
+    using Base::swap;
+    using Base::rehash;
+    using Base::reserve;
+    using Base::contains;
+    using Base::count;
+    using Base::equal_range;
+    using Base::find;
+    using Base::bucket_count;
+    using Base::load_factor;
+    using Base::max_load_factor;
+    using Base::get_allocator;
+    using Base::hash_function;
+    using Base::hash;
+    using Base::key_eq;
+};
+
+// -----------------------------------------------------------------------------
+// phmap::flat_hash_map
+// -----------------------------------------------------------------------------
+//
+// An `phmap::flat_hash_map<K, V>` is an unordered associative container which
+// has been optimized for both speed and memory footprint in most common use
+// cases. Its interface is similar to that of `std::unordered_map<K, V>` with
+// the following notable differences:
+//
+// * Supports heterogeneous lookup, through `find()`, `operator[]()` and
+//   `insert()`, provided that the map is provided a compatible heterogeneous
+//   hashing function and equality operator.
+// * Invalidates any references and pointers to elements within the table after
+//   `rehash()`.
+// * Contains a `capacity()` member function indicating the number of element
+//   slots (open, deleted, and empty) within the hash map.
+// * Returns `void` from the `_erase(iterator)` overload.
+// -----------------------------------------------------------------------------
+template <class K, class V, class Hash, class Eq, class Alloc> // default values in phmap_fwd_decl.h
+class flat_hash_map : public phmap::priv::raw_hash_map<
+                          phmap::priv::FlatHashMapPolicy<K, V>,
+                          Hash, Eq, Alloc> {
+    using Base = typename flat_hash_map::raw_hash_map;
+
+public:
+    flat_hash_map() {}
+#ifdef __INTEL_COMPILER
+    using Base::raw_hash_map;
+#else
+    using Base::Base;
+#endif
+    using Base::begin;
+    using Base::cbegin;
+    using Base::cend;
+    using Base::end;
+    using Base::capacity;
+    using Base::empty;
+    using Base::max_size;
+    using Base::size;
+    using Base::clear;
+    using Base::erase;
+    using Base::insert;
+    using Base::insert_or_assign;
+    using Base::emplace;
+    using Base::emplace_hint;
+    using Base::try_emplace;
+    using Base::extract;
+    using Base::merge;
+    using Base::swap;
+    using Base::rehash;
+    using Base::reserve;
+    using Base::at;
+    using Base::contains;
+    using Base::count;
+    using Base::equal_range;
+    using Base::find;
+    using Base::operator[];
+    using Base::bucket_count;
+    using Base::load_factor;
+    using Base::max_load_factor;
+    using Base::get_allocator;
+    using Base::hash_function;
+    using Base::hash;
+    using Base::key_eq;
+};
+
+// -----------------------------------------------------------------------------
+// phmap::node_hash_set
+// -----------------------------------------------------------------------------
+// An `phmap::node_hash_set<T>` is an unordered associative container which
+// has been optimized for both speed and memory footprint in most common use
+// cases. Its interface is similar to that of `std::unordered_set<T>` with the
+// following notable differences:
+//
+// * Supports heterogeneous lookup, through `find()`, `operator[]()` and
+//   `insert()`, provided that the map is provided a compatible heterogeneous
+//   hashing function and equality operator.
+// * Contains a `capacity()` member function indicating the number of element
+//   slots (open, deleted, and empty) within the hash set.
+// * Returns `void` from the `erase(iterator)` overload.
+// -----------------------------------------------------------------------------
+template <class T, class Hash, class Eq, class Alloc> // default values in phmap_fwd_decl.h
+class node_hash_set
+    : public phmap::priv::raw_hash_set<
+          phmap::priv::NodeHashSetPolicy<T>, Hash, Eq, Alloc> 
+{
+    using Base = typename node_hash_set::raw_hash_set;
+
+public:
+    node_hash_set() {}
+#ifdef __INTEL_COMPILER
+    using Base::raw_hash_set;
+#else
+    using Base::Base;
+#endif
+    using Base::begin;
+    using Base::cbegin;
+    using Base::cend;
+    using Base::end;
+    using Base::capacity;
+    using Base::empty;
+    using Base::max_size;
+    using Base::size;
+    using Base::clear;
+    using Base::erase;
+    using Base::insert;
+    using Base::emplace;
+    using Base::emplace_hint;
+    using Base::extract;
+    using Base::merge;
+    using Base::swap;
+    using Base::rehash;
+    using Base::reserve;
+    using Base::contains;
+    using Base::count;
+    using Base::equal_range;
+    using Base::find;
+    using Base::bucket_count;
+    using Base::load_factor;
+    using Base::max_load_factor;
+    using Base::get_allocator;
+    using Base::hash_function;
+    using Base::hash;
+    using Base::key_eq;
+    typename Base::hasher hash_funct() { return this->hash_function(); }
+    void resize(typename Base::size_type hint) { this->rehash(hint); }
+};
+
+// -----------------------------------------------------------------------------
+// phmap::node_hash_map
+// -----------------------------------------------------------------------------
+//
+// An `phmap::node_hash_map<K, V>` is an unordered associative container which
+// has been optimized for both speed and memory footprint in most common use
+// cases. Its interface is similar to that of `std::unordered_map<K, V>` with
+// the following notable differences:
+//
+// * Supports heterogeneous lookup, through `find()`, `operator[]()` and
+//   `insert()`, provided that the map is provided a compatible heterogeneous
+//   hashing function and equality operator.
+// * Contains a `capacity()` member function indicating the number of element
+//   slots (open, deleted, and empty) within the hash map.
+// * Returns `void` from the `erase(iterator)` overload.
+// -----------------------------------------------------------------------------
+template <class Key, class Value, class Hash, class Eq, class Alloc>  // default values in phmap_fwd_decl.h
+class node_hash_map
+    : public phmap::priv::raw_hash_map<
+          phmap::priv::NodeHashMapPolicy<Key, Value>, Hash, Eq,
+          Alloc> 
+{
+    using Base = typename node_hash_map::raw_hash_map;
+
+public:
+    node_hash_map() {}
+#ifdef __INTEL_COMPILER
+    using Base::raw_hash_map;
+#else
+    using Base::Base;
+#endif
+    using Base::begin;
+    using Base::cbegin;
+    using Base::cend;
+    using Base::end;
+    using Base::capacity;
+    using Base::empty;
+    using Base::max_size;
+    using Base::size;
+    using Base::clear;
+    using Base::erase;
+    using Base::insert;
+    using Base::insert_or_assign;
+    using Base::emplace;
+    using Base::emplace_hint;
+    using Base::try_emplace;
+    using Base::extract;
+    using Base::merge;
+    using Base::swap;
+    using Base::rehash;
+    using Base::reserve;
+    using Base::at;
+    using Base::contains;
+    using Base::count;
+    using Base::equal_range;
+    using Base::find;
+    using Base::operator[];
+    using Base::bucket_count;
+    using Base::load_factor;
+    using Base::max_load_factor;
+    using Base::get_allocator;
+    using Base::hash_function;
+    using Base::hash;
+    using Base::key_eq;
+    typename Base::hasher hash_funct() { return this->hash_function(); }
+    void resize(typename Base::size_type hint) { this->rehash(hint); }
+};
+
+// -----------------------------------------------------------------------------
+// phmap::parallel_flat_hash_set
+// -----------------------------------------------------------------------------
+template <class T, class Hash, class Eq, class Alloc, size_t N, class Mtx_> // default values in phmap_fwd_decl.h
+class parallel_flat_hash_set
+    : public phmap::priv::parallel_hash_set<
+         N, phmap::priv::raw_hash_set, Mtx_,
+         phmap::priv::FlatHashSetPolicy<T>, 
+         Hash, Eq, Alloc> 
+{
+    using Base = typename parallel_flat_hash_set::parallel_hash_set;
+
+public:
+    parallel_flat_hash_set() {}
+#ifdef __INTEL_COMPILER
+    using Base::parallel_hash_set;
+#else
+    using Base::Base;
+#endif
+    using Base::hash;
+    using Base::subidx;
+    using Base::subcnt;
+    using Base::begin;
+    using Base::cbegin;
+    using Base::cend;
+    using Base::end;
+    using Base::capacity;
+    using Base::empty;
+    using Base::max_size;
+    using Base::size;
+    using Base::clear;
+    using Base::erase;
+    using Base::insert;
+    using Base::emplace;
+    using Base::emplace_hint;
+    using Base::extract;
+    using Base::merge;
+    using Base::swap;
+    using Base::rehash;
+    using Base::reserve;
+    using Base::contains;
+    using Base::count;
+    using Base::equal_range;
+    using Base::find;
+    using Base::bucket_count;
+    using Base::load_factor;
+    using Base::max_load_factor;
+    using Base::get_allocator;
+    using Base::hash_function;
+    using Base::key_eq;
+};
+
+// -----------------------------------------------------------------------------
+// phmap::parallel_flat_hash_map - default values in phmap_fwd_decl.h
+// -----------------------------------------------------------------------------
+template <class K, class V, class Hash, class Eq, class Alloc, size_t N, class Mtx_>
+class parallel_flat_hash_map : public phmap::priv::parallel_hash_map<
+                N, phmap::priv::raw_hash_set, Mtx_,
+                phmap::priv::FlatHashMapPolicy<K, V>,
+                Hash, Eq, Alloc> 
+{
+    using Base = typename parallel_flat_hash_map::parallel_hash_map;
+
+public:
+    parallel_flat_hash_map() {}
+#ifdef __INTEL_COMPILER
+    using Base::parallel_hash_map;
+#else
+    using Base::Base;
+#endif
+    using Base::hash;
+    using Base::subidx;
+    using Base::subcnt;
+    using Base::begin;
+    using Base::cbegin;
+    using Base::cend;
+    using Base::end;
+    using Base::capacity;
+    using Base::empty;
+    using Base::max_size;
+    using Base::size;
+    using Base::clear;
+    using Base::erase;
+    using Base::insert;
+    using Base::insert_or_assign;
+    using Base::emplace;
+    using Base::emplace_hint;
+    using Base::try_emplace;
+    using Base::extract;
+    using Base::merge;
+    using Base::swap;
+    using Base::rehash;
+    using Base::reserve;
+    using Base::at;
+    using Base::contains;
+    using Base::count;
+    using Base::equal_range;
+    using Base::find;
+    using Base::operator[];
+    using Base::bucket_count;
+    using Base::load_factor;
+    using Base::max_load_factor;
+    using Base::get_allocator;
+    using Base::hash_function;
+    using Base::key_eq;
+};
+
+// -----------------------------------------------------------------------------
+// phmap::parallel_node_hash_set
+// -----------------------------------------------------------------------------
+template <class T, class Hash, class Eq, class Alloc, size_t N, class Mtx_>
+class parallel_node_hash_set
+    : public phmap::priv::parallel_hash_set<
+             N, phmap::priv::raw_hash_set, Mtx_,
+             phmap::priv::NodeHashSetPolicy<T>, Hash, Eq, Alloc> 
+{
+    using Base = typename parallel_node_hash_set::parallel_hash_set;
+
+public:
+    parallel_node_hash_set() {}
+#ifdef __INTEL_COMPILER
+    using Base::parallel_hash_set;
+#else
+    using Base::Base;
+#endif
+    using Base::hash;
+    using Base::subidx;
+    using Base::subcnt;
+    using Base::begin;
+    using Base::cbegin;
+    using Base::cend;
+    using Base::end;
+    using Base::capacity;
+    using Base::empty;
+    using Base::max_size;
+    using Base::size;
+    using Base::clear;
+    using Base::erase;
+    using Base::insert;
+    using Base::emplace;
+    using Base::emplace_hint;
+    using Base::extract;
+    using Base::merge;
+    using Base::swap;
+    using Base::rehash;
+    using Base::reserve;
+    using Base::contains;
+    using Base::count;
+    using Base::equal_range;
+    using Base::find;
+    using Base::bucket_count;
+    using Base::load_factor;
+    using Base::max_load_factor;
+    using Base::get_allocator;
+    using Base::hash_function;
+    using Base::key_eq;
+    typename Base::hasher hash_funct() { return this->hash_function(); }
+    void resize(typename Base::size_type hint) { this->rehash(hint); }
+};
+
+// -----------------------------------------------------------------------------
+// phmap::parallel_node_hash_map
+// -----------------------------------------------------------------------------
+template <class Key, class Value, class Hash, class Eq, class Alloc, size_t N, class Mtx_>
+class parallel_node_hash_map
+    : public phmap::priv::parallel_hash_map<
+          N, phmap::priv::raw_hash_set, Mtx_,
+          phmap::priv::NodeHashMapPolicy<Key, Value>, Hash, Eq,
+          Alloc> 
+{
+    using Base = typename parallel_node_hash_map::parallel_hash_map;
+
+public:
+    parallel_node_hash_map() {}
+#ifdef __INTEL_COMPILER
+    using Base::parallel_hash_map;
+#else
+    using Base::Base;
+#endif
+    using Base::hash;
+    using Base::subidx;
+    using Base::subcnt;
+    using Base::begin;
+    using Base::cbegin;
+    using Base::cend;
+    using Base::end;
+    using Base::capacity;
+    using Base::empty;
+    using Base::max_size;
+    using Base::size;
+    using Base::clear;
+    using Base::erase;
+    using Base::insert;
+    using Base::insert_or_assign;
+    using Base::emplace;
+    using Base::emplace_hint;
+    using Base::try_emplace;
+    using Base::extract;
+    using Base::merge;
+    using Base::swap;
+    using Base::rehash;
+    using Base::reserve;
+    using Base::at;
+    using Base::contains;
+    using Base::count;
+    using Base::equal_range;
+    using Base::find;
+    using Base::operator[];
+    using Base::bucket_count;
+    using Base::load_factor;
+    using Base::max_load_factor;
+    using Base::get_allocator;
+    using Base::hash_function;
+    using Base::key_eq;
+    typename Base::hasher hash_funct() { return this->hash_function(); }
+    void resize(typename Base::size_type hint) { this->rehash(hint); }
+};
+
+}  // namespace phmap
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+
+#endif // phmap_h_guard_
diff --git a/lib/parallel_hashmap/parallel_hashmap/phmap_base.h b/lib/parallel_hashmap/parallel_hashmap/phmap_base.h
new file mode 100644
index 0000000..e8f4f83
--- /dev/null
+++ b/lib/parallel_hashmap/parallel_hashmap/phmap_base.h
@@ -0,0 +1,5171 @@
+#if !defined(phmap_base_h_guard_)
+#define phmap_base_h_guard_
+
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Includes work from abseil-cpp (https://github.com/abseil/abseil-cpp)
+// with modifications.
+// 
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ---------------------------------------------------------------------------
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <initializer_list>
+#include <iterator>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <functional>
+#include <tuple>
+#include <utility>
+#include <memory>
+#include <mutex> // for std::lock
+
+#include "phmap_config.h"
+
+#ifdef PHMAP_HAVE_SHARED_MUTEX
+    #include <shared_mutex>  // after "phmap_config.h"
+#endif
+
+#ifdef _MSC_VER
+    #pragma warning(push)
+    #pragma warning(disable : 4514) // unreferenced inline function has been removed
+    #pragma warning(disable : 4582) // constructor is not implicitly called
+    #pragma warning(disable : 4625) // copy constructor was implicitly defined as deleted
+    #pragma warning(disable : 4626) // assignment operator was implicitly defined as deleted
+    #pragma warning(disable : 4710) // function not inlined
+    #pragma warning(disable : 4711) //  selected for automatic inline expansion
+    #pragma warning(disable : 4820) // '6' bytes padding added after data member
+#endif  // _MSC_VER
+
+namespace phmap {
+
+template <class T> using Allocator = typename std::allocator<T>;
+
+template<class T1, class T2> using Pair = typename std::pair<T1, T2>;
+
+template <class T>
+struct EqualTo
+{
+    inline bool operator()(const T& a, const T& b) const
+    {
+        return std::equal_to<T>()(a, b);
+    }
+};
+
+template <class T>
+struct Less
+{
+    inline bool operator()(const T& a, const T& b) const
+    {
+        return std::less<T>()(a, b);
+    }
+};
+
+namespace type_traits_internal {
+
+template <typename... Ts>
+struct VoidTImpl {
+  using type = void;
+};
+
+// This trick to retrieve a default alignment is necessary for our
+// implementation of aligned_storage_t to be consistent with any implementation
+// of std::aligned_storage.
+// ---------------------------------------------------------------------------
+template <size_t Len, typename T = std::aligned_storage<Len>>
+struct default_alignment_of_aligned_storage;
+
+template <size_t Len, size_t Align>
+struct default_alignment_of_aligned_storage<Len,
+                                            std::aligned_storage<Len, Align>> {
+  static constexpr size_t value = Align;
+};
+
+// NOTE: The `is_detected` family of templates here differ from the library
+// fundamentals specification in that for library fundamentals, `Op<Args...>` is
+// evaluated as soon as the type `is_detected<Op, Args...>` undergoes
+// substitution, regardless of whether or not the `::value` is accessed. That
+// is inconsistent with all other standard traits and prevents lazy evaluation
+// in larger contexts (such as if the `is_detected` check is a trailing argument
+// of a `conjunction`. This implementation opts to instead be lazy in the same
+// way that the standard traits are (this "defect" of the detection idiom
+// specifications has been reported).
+// ---------------------------------------------------------------------------
+
+template <class Enabler, template <class...> class Op, class... Args>
+struct is_detected_impl {
+  using type = std::false_type;
+};
+
+template <template <class...> class Op, class... Args>
+struct is_detected_impl<typename VoidTImpl<Op<Args...>>::type, Op, Args...> {
+  using type = std::true_type;
+};
+
+template <template <class...> class Op, class... Args>
+struct is_detected : is_detected_impl<void, Op, Args...>::type {};
+
+template <class Enabler, class To, template <class...> class Op, class... Args>
+struct is_detected_convertible_impl {
+  using type = std::false_type;
+};
+
+template <class To, template <class...> class Op, class... Args>
+struct is_detected_convertible_impl<
+    typename std::enable_if<std::is_convertible<Op<Args...>, To>::value>::type,
+    To, Op, Args...> {
+  using type = std::true_type;
+};
+
+template <class To, template <class...> class Op, class... Args>
+struct is_detected_convertible
+    : is_detected_convertible_impl<void, To, Op, Args...>::type {};
+
+template <typename T>
+using IsCopyAssignableImpl =
+    decltype(std::declval<T&>() = std::declval<const T&>());
+
+template <typename T>
+using IsMoveAssignableImpl = decltype(std::declval<T&>() = std::declval<T&&>());
+
+}  // namespace type_traits_internal
+
+template <typename T>
+struct is_copy_assignable : type_traits_internal::is_detected<
+                                type_traits_internal::IsCopyAssignableImpl, T> {
+};
+
+template <typename T>
+struct is_move_assignable : type_traits_internal::is_detected<
+                                type_traits_internal::IsMoveAssignableImpl, T> {
+};
+
+// ---------------------------------------------------------------------------
+// void_t()
+//
+// Ignores the type of any its arguments and returns `void`. In general, this
+// metafunction allows you to create a general case that maps to `void` while
+// allowing specializations that map to specific types.
+//
+// This metafunction is designed to be a drop-in replacement for the C++17
+// `std::void_t` metafunction.
+//
+// NOTE: `phmap::void_t` does not use the standard-specified implementation so
+// that it can remain compatible with gcc < 5.1. This can introduce slightly
+// different behavior, such as when ordering partial specializations.
+// ---------------------------------------------------------------------------
+template <typename... Ts>
+using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type;
+
+// ---------------------------------------------------------------------------
+// conjunction
+//
+// Performs a compile-time logical AND operation on the passed types (which
+// must have  `::value` members convertible to `bool`. Short-circuits if it
+// encounters any `false` members (and does not compare the `::value` members
+// of any remaining arguments).
+//
+// This metafunction is designed to be a drop-in replacement for the C++17
+// `std::conjunction` metafunction.
+// ---------------------------------------------------------------------------
+template <typename... Ts>
+struct conjunction;
+
+template <typename T, typename... Ts>
+struct conjunction<T, Ts...>
+    : std::conditional<T::value, conjunction<Ts...>, T>::type {};
+
+template <typename T>
+struct conjunction<T> : T {};
+
+template <>
+struct conjunction<> : std::true_type {};
+
+// ---------------------------------------------------------------------------
+// disjunction
+//
+// Performs a compile-time logical OR operation on the passed types (which
+// must have  `::value` members convertible to `bool`. Short-circuits if it
+// encounters any `true` members (and does not compare the `::value` members
+// of any remaining arguments).
+//
+// This metafunction is designed to be a drop-in replacement for the C++17
+// `std::disjunction` metafunction.
+// ---------------------------------------------------------------------------
+template <typename... Ts>
+struct disjunction;
+
+template <typename T, typename... Ts>
+struct disjunction<T, Ts...> :
+      std::conditional<T::value, T, disjunction<Ts...>>::type {};
+
+template <typename T>
+struct disjunction<T> : T {};
+
+template <>
+struct disjunction<> : std::false_type {};
+
+template <typename T>
+struct negation : std::integral_constant<bool, !T::value> {};
+
+template <typename T>
+struct is_trivially_destructible
+    : std::integral_constant<bool, __has_trivial_destructor(T) &&
+      std::is_destructible<T>::value> {};
+
+template <typename T>
+struct is_trivially_default_constructible
+    : std::integral_constant<bool, __has_trivial_constructor(T) &&
+                                   std::is_default_constructible<T>::value &&
+      is_trivially_destructible<T>::value> {};
+
+template <typename T>
+struct is_trivially_copy_constructible
+    : std::integral_constant<bool, __has_trivial_copy(T) &&
+                                   std::is_copy_constructible<T>::value &&
+      is_trivially_destructible<T>::value> {};
+
+template <typename T>
+struct is_trivially_copy_assignable
+    : std::integral_constant<
+          bool, __has_trivial_assign(typename std::remove_reference<T>::type) &&
+      phmap::is_copy_assignable<T>::value> {};
+
+// -----------------------------------------------------------------------------
+// C++14 "_t" trait aliases
+// -----------------------------------------------------------------------------
+
+template <typename T>
+using remove_cv_t = typename std::remove_cv<T>::type;
+
+template <typename T>
+using remove_const_t = typename std::remove_const<T>::type;
+
+template <typename T>
+using remove_volatile_t = typename std::remove_volatile<T>::type;
+
+template <typename T>
+using add_cv_t = typename std::add_cv<T>::type;
+
+template <typename T>
+using add_const_t = typename std::add_const<T>::type;
+
+template <typename T>
+using add_volatile_t = typename std::add_volatile<T>::type;
+
+template <typename T>
+using remove_reference_t = typename std::remove_reference<T>::type;
+
+template <typename T>
+using add_lvalue_reference_t = typename std::add_lvalue_reference<T>::type;
+
+template <typename T>
+using add_rvalue_reference_t = typename std::add_rvalue_reference<T>::type;
+
+template <typename T>
+using remove_pointer_t = typename std::remove_pointer<T>::type;
+
+template <typename T>
+using add_pointer_t = typename std::add_pointer<T>::type;
+
+template <typename T>
+using make_signed_t = typename std::make_signed<T>::type;
+
+template <typename T>
+using make_unsigned_t = typename std::make_unsigned<T>::type;
+
+template <typename T>
+using remove_extent_t = typename std::remove_extent<T>::type;
+
+template <typename T>
+using remove_all_extents_t = typename std::remove_all_extents<T>::type;
+
+template <size_t Len, size_t Align = type_traits_internal::
+                          default_alignment_of_aligned_storage<Len>::value>
+using aligned_storage_t = typename std::aligned_storage<Len, Align>::type;
+
+template <typename T>
+using decay_t = typename std::decay<T>::type;
+
+template <bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+template <bool B, typename T, typename F>
+using conditional_t = typename std::conditional<B, T, F>::type;
+
+
+template <typename... T>
+using common_type_t = typename std::common_type<T...>::type;
+
+template <typename T>
+using underlying_type_t = typename std::underlying_type<T>::type;
+
+template< class F, class... ArgTypes>
+#if PHMAP_HAVE_CC17
+    using invoke_result_t = typename std::invoke_result_t<F, ArgTypes...>;
+#else
+    using invoke_result_t = typename std::result_of<F(ArgTypes...)>::type;
+#endif
+
+namespace type_traits_internal {
+
+// ----------------------------------------------------------------------
+// In MSVC we can't probe std::hash or stdext::hash because it triggers a
+// static_assert instead of failing substitution. Libc++ prior to 4.0
+// also used a static_assert.
+// ----------------------------------------------------------------------
+#if defined(_MSC_VER) || (defined(_LIBCPP_VERSION) && \
+                          _LIBCPP_VERSION < 4000 && _LIBCPP_STD_VER > 11)
+    #define PHMAP_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 0
+#else
+    #define PHMAP_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 1
+#endif
+
+#if !PHMAP_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
+    template <typename Key, typename = size_t>
+    struct IsHashable : std::true_type {};
+#else   // PHMAP_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
+    template <typename Key, typename = void>
+    struct IsHashable : std::false_type {};
+
+    template <typename Key>
+    struct IsHashable<Key,
+        phmap::enable_if_t<std::is_convertible<
+            decltype(std::declval<std::hash<Key>&>()(std::declval<Key const&>())),
+            std::size_t>::value>> : std::true_type {};
+#endif
+
+struct AssertHashEnabledHelper 
+{
+private:
+    static void Sink(...) {}
+    struct NAT {};
+
+    template <class Key>
+    static auto GetReturnType(int)
+        -> decltype(std::declval<std::hash<Key>>()(std::declval<Key const&>()));
+    template <class Key>
+    static NAT GetReturnType(...);
+
+    template <class Key>
+    static std::nullptr_t DoIt() {
+        static_assert(IsHashable<Key>::value,
+                      "std::hash<Key> does not provide a call operator");
+        static_assert(
+            std::is_default_constructible<std::hash<Key>>::value,
+            "std::hash<Key> must be default constructible when it is enabled");
+        static_assert(
+            std::is_copy_constructible<std::hash<Key>>::value,
+            "std::hash<Key> must be copy constructible when it is enabled");
+        static_assert(phmap::is_copy_assignable<std::hash<Key>>::value,
+                      "std::hash<Key> must be copy assignable when it is enabled");
+        // is_destructible is unchecked as it's implied by each of the
+        // is_constructible checks.
+        using ReturnType = decltype(GetReturnType<Key>(0));
+        static_assert(std::is_same<ReturnType, NAT>::value ||
+                      std::is_same<ReturnType, size_t>::value,
+                      "std::hash<Key> must return size_t");
+        return nullptr;
+    }
+
+    template <class... Ts>
+    friend void AssertHashEnabled();
+};
+
+template <class... Ts>
+inline void AssertHashEnabled
+() 
+{
+    using Helper = AssertHashEnabledHelper;
+    Helper::Sink(Helper::DoIt<Ts>()...);
+}
+
+}  // namespace type_traits_internal
+
+}  // namespace phmap
+
+
+// -----------------------------------------------------------------------------
+//          hash_policy_traits
+// -----------------------------------------------------------------------------
+namespace phmap {
+namespace priv {
+
+// Defines how slots are initialized/destroyed/moved.
+template <class Policy, class = void>
+struct hash_policy_traits 
+{
+private:
+    struct ReturnKey 
+    {
+        // We return `Key` here.
+        // When Key=T&, we forward the lvalue reference.
+        // When Key=T, we return by value to avoid a dangling reference.
+        // eg, for string_hash_map.
+        template <class Key, class... Args>
+        Key operator()(Key&& k, const Args&...) const {
+            return std::forward<Key>(k);
+        }
+    };
+
+    template <class P = Policy, class = void>
+    struct ConstantIteratorsImpl : std::false_type {};
+
+    template <class P>
+    struct ConstantIteratorsImpl<P, phmap::void_t<typename P::constant_iterators>>
+        : P::constant_iterators {};
+
+public:
+    // The actual object stored in the hash table.
+    using slot_type  = typename Policy::slot_type;
+
+    // The type of the keys stored in the hashtable.
+    using key_type   = typename Policy::key_type;
+
+    // The argument type for insertions into the hashtable. This is different
+    // from value_type for increased performance. See initializer_list constructor
+    // and insert() member functions for more details.
+    using init_type  = typename Policy::init_type;
+
+    using reference  = decltype(Policy::element(std::declval<slot_type*>()));
+    using pointer    = typename std::remove_reference<reference>::type*;
+    using value_type = typename std::remove_reference<reference>::type;
+
+    // Policies can set this variable to tell raw_hash_set that all iterators
+    // should be constant, even `iterator`. This is useful for set-like
+    // containers.
+    // Defaults to false if not provided by the policy.
+    using constant_iterators = ConstantIteratorsImpl<>;
+
+    // PRECONDITION: `slot` is UNINITIALIZED
+    // POSTCONDITION: `slot` is INITIALIZED
+    template <class Alloc, class... Args>
+    static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
+        Policy::construct(alloc, slot, std::forward<Args>(args)...);
+    }
+
+    // PRECONDITION: `slot` is INITIALIZED
+    // POSTCONDITION: `slot` is UNINITIALIZED
+    template <class Alloc>
+    static void destroy(Alloc* alloc, slot_type* slot) {
+        Policy::destroy(alloc, slot);
+    }
+
+    // Transfers the `old_slot` to `new_slot`. Any memory allocated by the
+    // allocator inside `old_slot` to `new_slot` can be transferred.
+    //
+    // OPTIONAL: defaults to:
+    //
+    //     clone(new_slot, std::move(*old_slot));
+    //     destroy(old_slot);
+    //
+    // PRECONDITION: `new_slot` is UNINITIALIZED and `old_slot` is INITIALIZED
+    // POSTCONDITION: `new_slot` is INITIALIZED and `old_slot` is
+    //                UNINITIALIZED
+    template <class Alloc>
+    static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
+        transfer_impl(alloc, new_slot, old_slot, 0);
+    }
+
+    // PRECONDITION: `slot` is INITIALIZED
+    // POSTCONDITION: `slot` is INITIALIZED
+    template <class P = Policy>
+    static auto element(slot_type* slot) -> decltype(P::element(slot)) {
+        return P::element(slot);
+    }
+
+    // Returns the amount of memory owned by `slot`, exclusive of `sizeof(*slot)`.
+    //
+    // If `slot` is nullptr, returns the constant amount of memory owned by any
+    // full slot or -1 if slots own variable amounts of memory.
+    //
+    // PRECONDITION: `slot` is INITIALIZED or nullptr
+    template <class P = Policy>
+    static size_t space_used(const slot_type* slot) {
+        return P::space_used(slot);
+    }
+
+    // Provides generalized access to the key for elements, both for elements in
+    // the table and for elements that have not yet been inserted (or even
+    // constructed).  We would like an API that allows us to say: `key(args...)`
+    // but we cannot do that for all cases, so we use this more general API that
+    // can be used for many things, including the following:
+    //
+    //   - Given an element in a table, get its key.
+    //   - Given an element initializer, get its key.
+    //   - Given `emplace()` arguments, get the element key.
+    //
+    // Implementations of this must adhere to a very strict technical
+    // specification around aliasing and consuming arguments:
+    //
+    // Let `value_type` be the result type of `element()` without ref- and
+    // cv-qualifiers. The first argument is a functor, the rest are constructor
+    // arguments for `value_type`. Returns `std::forward<F>(f)(k, xs...)`, where
+    // `k` is the element key, and `xs...` are the new constructor arguments for
+    // `value_type`. It's allowed for `k` to alias `xs...`, and for both to alias
+    // `ts...`. The key won't be touched once `xs...` are used to construct an
+    // element; `ts...` won't be touched at all, which allows `apply()` to consume
+    // any rvalues among them.
+    //
+    // If `value_type` is constructible from `Ts&&...`, `Policy::apply()` must not
+    // trigger a hard compile error unless it originates from `f`. In other words,
+    // `Policy::apply()` must be SFINAE-friendly. If `value_type` is not
+    // constructible from `Ts&&...`, either SFINAE or a hard compile error is OK.
+    //
+    // If `Ts...` is `[cv] value_type[&]` or `[cv] init_type[&]`,
+    // `Policy::apply()` must work. A compile error is not allowed, SFINAE or not.
+    template <class F, class... Ts, class P = Policy>
+    static auto apply(F&& f, Ts&&... ts)
+        -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
+        return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
+    }
+
+    // Returns the "key" portion of the slot.
+    // Used for node handle manipulation.
+    template <class P = Policy>
+    static auto key(slot_type* slot)
+        -> decltype(P::apply(ReturnKey(), element(slot))) {
+        return P::apply(ReturnKey(), element(slot));
+    }
+
+    // Returns the "value" (as opposed to the "key") portion of the element. Used
+    // by maps to implement `operator[]`, `at()` and `insert_or_assign()`.
+    template <class T, class P = Policy>
+    static auto value(T* elem) -> decltype(P::value(elem)) {
+        return P::value(elem);
+    }
+
+private:
+
+    // Use auto -> decltype as an enabler.
+    template <class Alloc, class P = Policy>
+    static auto transfer_impl(Alloc* alloc, slot_type* new_slot,
+                              slot_type* old_slot, int)
+        -> decltype((void)P::transfer(alloc, new_slot, old_slot)) {
+        P::transfer(alloc, new_slot, old_slot);
+    }
+
+    template <class Alloc>
+    static void transfer_impl(Alloc* alloc, slot_type* new_slot,
+                              slot_type* old_slot, char) {
+        construct(alloc, new_slot, std::move(element(old_slot)));
+        destroy(alloc, old_slot);
+    }
+};
+
+}  // namespace priv
+}  // namespace phmap
+
+// -----------------------------------------------------------------------------
+// file utility.h
+// -----------------------------------------------------------------------------
+
+// --------- identity.h
+namespace phmap {
+namespace internal {
+
+template <typename T>
+struct identity {
+    typedef T type;
+};
+
+template <typename T>
+using identity_t = typename identity<T>::type;
+
+}  // namespace internal
+}  // namespace phmap
+
+
+// --------- inline_variable.h
+
+#ifdef __cpp_inline_variables
+
+#if defined(__clang__)
+    #define PHMAP_INTERNAL_EXTERN_DECL(type, name) \
+      extern const ::phmap::internal::identity_t<type> name;
+#else  // Otherwise, just define the macro to do nothing.
+    #define PHMAP_INTERNAL_EXTERN_DECL(type, name)
+#endif  // defined(__clang__)
+
+// See above comment at top of file for details.
+#define PHMAP_INTERNAL_INLINE_CONSTEXPR(type, name, init) \
+  PHMAP_INTERNAL_EXTERN_DECL(type, name)                  \
+  inline constexpr ::phmap::internal::identity_t<type> name = init
+
+#else
+
+// See above comment at top of file for details.
+//
+// Note:
+//   identity_t is used here so that the const and name are in the
+//   appropriate place for pointer types, reference types, function pointer
+//   types, etc..
+#define PHMAP_INTERNAL_INLINE_CONSTEXPR(var_type, name, init)                  \
+  template <class /*PhmapInternalDummy*/ = void>                               \
+  struct PhmapInternalInlineVariableHolder##name {                             \
+    static constexpr ::phmap::internal::identity_t<var_type> kInstance = init; \
+  };                                                                          \
+                                                                              \
+  template <class PhmapInternalDummy>                                          \
+  constexpr ::phmap::internal::identity_t<var_type>                            \
+      PhmapInternalInlineVariableHolder##name<PhmapInternalDummy>::kInstance;   \
+                                                                              \
+  static constexpr const ::phmap::internal::identity_t<var_type>&              \
+      name = /* NOLINT */                                                     \
+      PhmapInternalInlineVariableHolder##name<>::kInstance;                    \
+  static_assert(sizeof(void (*)(decltype(name))) != 0,                        \
+                "Silence unused variable warnings.")
+
+#endif  // __cpp_inline_variables
+
+// ----------- throw_delegate
+
+namespace phmap {
+namespace base_internal {
+
+namespace {
+template <typename T>
+#ifdef PHMAP_HAVE_EXCEPTIONS
+[[noreturn]] void Throw(const T& error) {
+    throw error;
+}
+#else
+[[noreturn]] void Throw(const T&) {
+    std::abort();
+}
+#endif
+}  // namespace
+
+static inline void ThrowStdLogicError(const std::string& what_arg) {
+  Throw(std::logic_error(what_arg));
+}
+static inline void ThrowStdLogicError(const char* what_arg) {
+  Throw(std::logic_error(what_arg));
+}
+static inline void ThrowStdInvalidArgument(const std::string& what_arg) {
+  Throw(std::invalid_argument(what_arg));
+}
+static inline void ThrowStdInvalidArgument(const char* what_arg) {
+  Throw(std::invalid_argument(what_arg));
+}
+
+static inline void ThrowStdDomainError(const std::string& what_arg) {
+  Throw(std::domain_error(what_arg));
+}
+static inline void ThrowStdDomainError(const char* what_arg) {
+  Throw(std::domain_error(what_arg));
+}
+
+static inline void ThrowStdLengthError(const std::string& what_arg) {
+  Throw(std::length_error(what_arg));
+}
+static inline void ThrowStdLengthError(const char* what_arg) {
+  Throw(std::length_error(what_arg));
+}
+
+static inline void ThrowStdOutOfRange(const std::string& what_arg) {
+  Throw(std::out_of_range(what_arg));
+}
+static inline void ThrowStdOutOfRange(const char* what_arg) {
+  Throw(std::out_of_range(what_arg));
+}
+
+static inline void ThrowStdRuntimeError(const std::string& what_arg) {
+  Throw(std::runtime_error(what_arg));
+}
+static inline void ThrowStdRuntimeError(const char* what_arg) {
+  Throw(std::runtime_error(what_arg));
+}
+
+static inline void ThrowStdRangeError(const std::string& what_arg) {
+  Throw(std::range_error(what_arg));
+}
+static inline void ThrowStdRangeError(const char* what_arg) {
+  Throw(std::range_error(what_arg));
+}
+
+static inline void ThrowStdOverflowError(const std::string& what_arg) {
+  Throw(std::overflow_error(what_arg));
+}
+static inline void ThrowStdOverflowError(const char* what_arg) {
+  Throw(std::overflow_error(what_arg));
+}
+
+static inline void ThrowStdUnderflowError(const std::string& what_arg) {
+  Throw(std::underflow_error(what_arg));
+}
+static inline void ThrowStdUnderflowError(const char* what_arg) {
+  Throw(std::underflow_error(what_arg));
+}
+
+static inline void ThrowStdBadFunctionCall() { Throw(std::bad_function_call()); }
+
+static inline void ThrowStdBadAlloc() { Throw(std::bad_alloc()); }
+
+}  // namespace base_internal
+}  // namespace phmap
+
+// ----------- invoke.h
+
+namespace phmap {
+namespace base_internal {
+
+template <typename Derived>
+struct StrippedAccept 
+{
+    template <typename... Args>
+    struct Accept : Derived::template AcceptImpl<typename std::remove_cv<
+                                                     typename std::remove_reference<Args>::type>::type...> {};
+};
+
+// (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T
+// and t1 is an object of type T or a reference to an object of type T or a
+// reference to an object of a type derived from T.
+struct MemFunAndRef : StrippedAccept<MemFunAndRef> 
+{
+    template <typename... Args>
+    struct AcceptImpl : std::false_type {};
+
+    template <typename R, typename C, typename... Params, typename Obj,
+              typename... Args>
+    struct AcceptImpl<R (C::*)(Params...), Obj, Args...>
+        : std::is_base_of<C, Obj> {};
+
+    template <typename R, typename C, typename... Params, typename Obj,
+              typename... Args>
+    struct AcceptImpl<R (C::*)(Params...) const, Obj, Args...>
+        : std::is_base_of<C, Obj> {};
+
+    template <typename MemFun, typename Obj, typename... Args>
+    static decltype((std::declval<Obj>().*
+                     std::declval<MemFun>())(std::declval<Args>()...))
+    Invoke(MemFun&& mem_fun, Obj&& obj, Args&&... args) {
+        return (std::forward<Obj>(obj).*
+                std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
+    }
+};
+
+// ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a
+// class T and t1 is not one of the types described in the previous item.
+struct MemFunAndPtr : StrippedAccept<MemFunAndPtr> 
+{
+    template <typename... Args>
+    struct AcceptImpl : std::false_type {};
+
+    template <typename R, typename C, typename... Params, typename Ptr,
+              typename... Args>
+    struct AcceptImpl<R (C::*)(Params...), Ptr, Args...>
+        : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value> {};
+
+    template <typename R, typename C, typename... Params, typename Ptr,
+              typename... Args>
+    struct AcceptImpl<R (C::*)(Params...) const, Ptr, Args...>
+        : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value> {};
+
+    template <typename MemFun, typename Ptr, typename... Args>
+    static decltype(((*std::declval<Ptr>()).*
+                     std::declval<MemFun>())(std::declval<Args>()...))
+    Invoke(MemFun&& mem_fun, Ptr&& ptr, Args&&... args) {
+        return ((*std::forward<Ptr>(ptr)).*
+                std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
+    }
+};
+
+// t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is
+// an object of type T or a reference to an object of type T or a reference
+// to an object of a type derived from T.
+struct DataMemAndRef : StrippedAccept<DataMemAndRef> 
+{
+    template <typename... Args>
+    struct AcceptImpl : std::false_type {};
+
+    template <typename R, typename C, typename Obj>
+    struct AcceptImpl<R C::*, Obj> : std::is_base_of<C, Obj> {};
+
+    template <typename DataMem, typename Ref>
+    static decltype(std::declval<Ref>().*std::declval<DataMem>()) Invoke(
+        DataMem&& data_mem, Ref&& ref) {
+        return std::forward<Ref>(ref).*std::forward<DataMem>(data_mem);
+    }
+};
+
+// (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1
+// is not one of the types described in the previous item.
+struct DataMemAndPtr : StrippedAccept<DataMemAndPtr> 
+{
+    template <typename... Args>
+    struct AcceptImpl : std::false_type {};
+
+    template <typename R, typename C, typename Ptr>
+    struct AcceptImpl<R C::*, Ptr>
+        : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value> {};
+
+    template <typename DataMem, typename Ptr>
+    static decltype((*std::declval<Ptr>()).*std::declval<DataMem>()) Invoke(
+        DataMem&& data_mem, Ptr&& ptr) {
+        return (*std::forward<Ptr>(ptr)).*std::forward<DataMem>(data_mem);
+    }
+};
+
+// f(t1, t2, ..., tN) in all other cases.
+struct Callable
+{
+    // Callable doesn't have Accept because it's the last clause that gets picked
+    // when none of the previous clauses are applicable.
+    template <typename F, typename... Args>
+    static decltype(std::declval<F>()(std::declval<Args>()...)) Invoke(
+        F&& f, Args&&... args) {
+        return std::forward<F>(f)(std::forward<Args>(args)...);
+    }
+};
+
+// Resolves to the first matching clause.
+template <typename... Args>
+struct Invoker 
+{
+    typedef typename std::conditional<
+        MemFunAndRef::Accept<Args...>::value, MemFunAndRef,
+        typename std::conditional<
+            MemFunAndPtr::Accept<Args...>::value, MemFunAndPtr,
+            typename std::conditional<
+                DataMemAndRef::Accept<Args...>::value, DataMemAndRef,
+                typename std::conditional<DataMemAndPtr::Accept<Args...>::value,
+                                          DataMemAndPtr, Callable>::type>::type>::
+        type>::type type;
+};
+
+// The result type of Invoke<F, Args...>.
+template <typename F, typename... Args>
+using InvokeT = decltype(Invoker<F, Args...>::type::Invoke(
+    std::declval<F>(), std::declval<Args>()...));
+
+// Invoke(f, args...) is an implementation of INVOKE(f, args...) from section
+// [func.require] of the C++ standard.
+template <typename F, typename... Args>
+InvokeT<F, Args...> Invoke(F&& f, Args&&... args) {
+  return Invoker<F, Args...>::type::Invoke(std::forward<F>(f),
+                                           std::forward<Args>(args)...);
+}
+}  // namespace base_internal
+}  // namespace phmap
+
+
+// ----------- utility.h
+
+namespace phmap {
+
+// integer_sequence
+//
+// Class template representing a compile-time integer sequence. An instantiation
+// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
+// type through its template arguments (which is a common need when
+// working with C++11 variadic templates). `phmap::integer_sequence` is designed
+// to be a drop-in replacement for C++14's `std::integer_sequence`.
+//
+// Example:
+//
+//   template< class T, T... Ints >
+//   void user_function(integer_sequence<T, Ints...>);
+//
+//   int main()
+//   {
+//     // user_function's `T` will be deduced to `int` and `Ints...`
+//     // will be deduced to `0, 1, 2, 3, 4`.
+//     user_function(make_integer_sequence<int, 5>());
+//   }
+template <typename T, T... Ints>
+struct integer_sequence 
+{
+    using value_type = T;
+    static constexpr size_t size() noexcept { return sizeof...(Ints); }
+};
+
+// index_sequence
+//
+// A helper template for an `integer_sequence` of `size_t`,
+// `phmap::index_sequence` is designed to be a drop-in replacement for C++14's
+// `std::index_sequence`.
+template <size_t... Ints>
+using index_sequence = integer_sequence<size_t, Ints...>;
+
+namespace utility_internal {
+
+template <typename Seq, size_t SeqSize, size_t Rem>
+struct Extend;
+
+// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 0> {
+  using type = integer_sequence<T, Ints..., (Ints + SeqSize)...>;
+};
+
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 1> {
+  using type = integer_sequence<T, Ints..., (Ints + SeqSize)..., 2 * SeqSize>;
+};
+
+// Recursion helper for 'make_integer_sequence<T, N>'.
+// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
+template <typename T, size_t N>
+struct Gen {
+  using type =
+      typename Extend<typename Gen<T, N / 2>::type, N / 2, N % 2>::type;
+};
+
+template <typename T>
+struct Gen<T, 0> {
+  using type = integer_sequence<T>;
+};
+
+}  // namespace utility_internal
+
+// Compile-time sequences of integers
+
+// make_integer_sequence
+//
+// This template alias is equivalent to
+// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
+// replacement for C++14's `std::make_integer_sequence`.
+template <typename T, T N>
+using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
+
+// make_index_sequence
+//
+// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
+// and is designed to be a drop-in replacement for C++14's
+// `std::make_index_sequence`.
+template <size_t N>
+using make_index_sequence = make_integer_sequence<size_t, N>;
+
+// index_sequence_for
+//
+// Converts a typename pack into an index sequence of the same length, and
+// is designed to be a drop-in replacement for C++14's
+// `std::index_sequence_for()`
+template <typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+// Tag types
+
+#ifdef PHMAP_HAVE_STD_OPTIONAL
+
+using std::in_place_t;
+using std::in_place;
+
+#else  // PHMAP_HAVE_STD_OPTIONAL
+
+// in_place_t
+//
+// Tag type used to specify in-place construction, such as with
+// `phmap::optional`, designed to be a drop-in replacement for C++17's
+// `std::in_place_t`.
+struct in_place_t {};
+
+PHMAP_INTERNAL_INLINE_CONSTEXPR(in_place_t, in_place, {});
+
+#endif  // PHMAP_HAVE_STD_OPTIONAL
+
+#if defined(PHMAP_HAVE_STD_ANY) || defined(PHMAP_HAVE_STD_VARIANT)
+using std::in_place_type_t;
+#else
+
+// in_place_type_t
+//
+// Tag type used for in-place construction when the type to construct needs to
+// be specified, such as with `phmap::any`, designed to be a drop-in replacement
+// for C++17's `std::in_place_type_t`.
+template <typename T>
+struct in_place_type_t {};
+#endif  // PHMAP_HAVE_STD_ANY || PHMAP_HAVE_STD_VARIANT
+
+#ifdef PHMAP_HAVE_STD_VARIANT
+using std::in_place_index_t;
+#else
+
+// in_place_index_t
+//
+// Tag type used for in-place construction when the type to construct needs to
+// be specified, such as with `phmap::any`, designed to be a drop-in replacement
+// for C++17's `std::in_place_index_t`.
+template <size_t I>
+struct in_place_index_t {};
+#endif  // PHMAP_HAVE_STD_VARIANT
+
+// Constexpr move and forward
+
+// move()
+//
+// A constexpr version of `std::move()`, designed to be a drop-in replacement
+// for C++14's `std::move()`.
+template <typename T>
+constexpr phmap::remove_reference_t<T>&& move(T&& t) noexcept {
+  return static_cast<phmap::remove_reference_t<T>&&>(t);
+}
+
+// forward()
+//
+// A constexpr version of `std::forward()`, designed to be a drop-in replacement
+// for C++14's `std::forward()`.
+template <typename T>
+constexpr T&& forward(
+    phmap::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
+  return static_cast<T&&>(t);
+}
+
+namespace utility_internal {
+// Helper method for expanding tuple into a called method.
+template <typename Functor, typename Tuple, std::size_t... Indexes>
+auto apply_helper(Functor&& functor, Tuple&& t, index_sequence<Indexes...>)
+    -> decltype(phmap::base_internal::Invoke(
+        phmap::forward<Functor>(functor),
+        std::get<Indexes>(phmap::forward<Tuple>(t))...)) {
+  return phmap::base_internal::Invoke(
+      phmap::forward<Functor>(functor),
+      std::get<Indexes>(phmap::forward<Tuple>(t))...);
+}
+
+}  // namespace utility_internal
+
+// apply
+//
+// Invokes a Callable using elements of a tuple as its arguments.
+// Each element of the tuple corresponds to an argument of the call (in order).
+// Both the Callable argument and the tuple argument are perfect-forwarded.
+// For member-function Callables, the first tuple element acts as the `this`
+// pointer. `phmap::apply` is designed to be a drop-in replacement for C++17's
+// `std::apply`. Unlike C++17's `std::apply`, this is not currently `constexpr`.
+//
+// Example:
+//
+//   class Foo {
+//    public:
+//     void Bar(int);
+//   };
+//   void user_function1(int, std::string);
+//   void user_function2(std::unique_ptr<Foo>);
+//   auto user_lambda = [](int, int) {};
+//
+//   int main()
+//   {
+//       std::tuple<int, std::string> tuple1(42, "bar");
+//       // Invokes the first user function on int, std::string.
+//       phmap::apply(&user_function1, tuple1);
+//
+//       std::tuple<std::unique_ptr<Foo>> tuple2(phmap::make_unique<Foo>());
+//       // Invokes the user function that takes ownership of the unique
+//       // pointer.
+//       phmap::apply(&user_function2, std::move(tuple2));
+//
+//       auto foo = phmap::make_unique<Foo>();
+//       std::tuple<Foo*, int> tuple3(foo.get(), 42);
+//       // Invokes the method Bar on foo with one argument, 42.
+//       phmap::apply(&Foo::Bar, tuple3);
+//
+//       std::tuple<int, int> tuple4(8, 9);
+//       // Invokes a lambda.
+//       phmap::apply(user_lambda, tuple4);
+//   }
+template <typename Functor, typename Tuple>
+auto apply(Functor&& functor, Tuple&& t)
+    -> decltype(utility_internal::apply_helper(
+        phmap::forward<Functor>(functor), phmap::forward<Tuple>(t),
+        phmap::make_index_sequence<std::tuple_size<
+            typename std::remove_reference<Tuple>::type>::value>{})) {
+  return utility_internal::apply_helper(
+      phmap::forward<Functor>(functor), phmap::forward<Tuple>(t),
+      phmap::make_index_sequence<std::tuple_size<
+          typename std::remove_reference<Tuple>::type>::value>{});
+}
+
+#ifdef _MSC_VER
+    #pragma warning(push)
+    #pragma warning(disable : 4365) // '=': conversion from 'T' to 'T', signed/unsigned mismatch
+#endif  // _MSC_VER
+
+// exchange
+//
+// Replaces the value of `obj` with `new_value` and returns the old value of
+// `obj`.  `phmap::exchange` is designed to be a drop-in replacement for C++14's
+// `std::exchange`.
+//
+// Example:
+//
+//   Foo& operator=(Foo&& other) {
+//     ptr1_ = phmap::exchange(other.ptr1_, nullptr);
+//     int1_ = phmap::exchange(other.int1_, -1);
+//     return *this;
+//   }
+template <typename T, typename U = T>
+T exchange(T& obj, U&& new_value)
+{
+    T old_value = phmap::move(obj);
+    obj = phmap::forward<U>(new_value);
+    return old_value;
+}
+
+#ifdef _MSC_VER
+    #pragma warning(pop)
+#endif  // _MSC_VER
+
+
+}  // namespace phmap
+
+// -----------------------------------------------------------------------------
+//          memory.h
+// -----------------------------------------------------------------------------
+
+namespace phmap {
+
+template <typename T>
+std::unique_ptr<T> WrapUnique(T* ptr) 
+{
+    static_assert(!std::is_array<T>::value, "array types are unsupported");
+    static_assert(std::is_object<T>::value, "non-object types are unsupported");
+    return std::unique_ptr<T>(ptr);
+}
+
+namespace memory_internal {
+
+// Traits to select proper overload and return type for `phmap::make_unique<>`.
+template <typename T>
+struct MakeUniqueResult {
+    using scalar = std::unique_ptr<T>;
+};
+template <typename T>
+struct MakeUniqueResult<T[]> {
+    using array = std::unique_ptr<T[]>;
+};
+template <typename T, size_t N>
+struct MakeUniqueResult<T[N]> {
+    using invalid = void;
+};
+
+}  // namespace memory_internal
+
+#if (__cplusplus > 201103L || defined(_MSC_VER)) && \
+    !(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 8) 
+    using std::make_unique;
+#else
+
+    template <typename T, typename... Args>
+    typename memory_internal::MakeUniqueResult<T>::scalar make_unique(
+        Args&&... args) {
+        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+    }
+    
+    template <typename T>
+    typename memory_internal::MakeUniqueResult<T>::array make_unique(size_t n) {
+        return std::unique_ptr<T>(new typename phmap::remove_extent_t<T>[n]());
+    }
+    
+    template <typename T, typename... Args>
+    typename memory_internal::MakeUniqueResult<T>::invalid make_unique(
+        Args&&... /* args */) = delete;
+#endif
+
+template <typename T>
+auto RawPtr(T&& ptr) -> decltype(std::addressof(*ptr))
+{
+    // ptr is a forwarding reference to support Ts with non-const operators.
+    return (ptr != nullptr) ? std::addressof(*ptr) : nullptr;
+}
+
+inline std::nullptr_t RawPtr(std::nullptr_t) { return nullptr; }
+
+template <typename T, typename D>
+std::shared_ptr<T> ShareUniquePtr(std::unique_ptr<T, D>&& ptr) {
+    return ptr ? std::shared_ptr<T>(std::move(ptr)) : std::shared_ptr<T>();
+}
+
+template <typename T>
+std::weak_ptr<T> WeakenPtr(const std::shared_ptr<T>& ptr) {
+    return std::weak_ptr<T>(ptr);
+}
+
+namespace memory_internal {
+
+// ExtractOr<E, O, D>::type evaluates to E<O> if possible. Otherwise, D.
+template <template <typename> class Extract, typename Obj, typename Default,
+          typename>
+struct ExtractOr {
+    using type = Default;
+};
+
+template <template <typename> class Extract, typename Obj, typename Default>
+struct ExtractOr<Extract, Obj, Default, void_t<Extract<Obj>>> {
+    using type = Extract<Obj>;
+};
+
+template <template <typename> class Extract, typename Obj, typename Default>
+using ExtractOrT = typename ExtractOr<Extract, Obj, Default, void>::type;
+
+// Extractors for the features of allocators.
+template <typename T>
+using GetPointer = typename T::pointer;
+
+template <typename T>
+using GetConstPointer = typename T::const_pointer;
+
+template <typename T>
+using GetVoidPointer = typename T::void_pointer;
+
+template <typename T>
+using GetConstVoidPointer = typename T::const_void_pointer;
+
+template <typename T>
+using GetDifferenceType = typename T::difference_type;
+
+template <typename T>
+using GetSizeType = typename T::size_type;
+
+template <typename T>
+using GetPropagateOnContainerCopyAssignment =
+    typename T::propagate_on_container_copy_assignment;
+
+template <typename T>
+using GetPropagateOnContainerMoveAssignment =
+    typename T::propagate_on_container_move_assignment;
+
+template <typename T>
+using GetPropagateOnContainerSwap = typename T::propagate_on_container_swap;
+
+template <typename T>
+using GetIsAlwaysEqual = typename T::is_always_equal;
+
+template <typename T>
+struct GetFirstArg;
+
+template <template <typename...> class Class, typename T, typename... Args>
+struct GetFirstArg<Class<T, Args...>> {
+  using type = T;
+};
+
+template <typename Ptr, typename = void>
+struct ElementType {
+  using type = typename GetFirstArg<Ptr>::type;
+};
+
+template <typename T>
+struct ElementType<T, void_t<typename T::element_type>> {
+  using type = typename T::element_type;
+};
+
+template <typename T, typename U>
+struct RebindFirstArg;
+
+template <template <typename...> class Class, typename T, typename... Args,
+          typename U>
+struct RebindFirstArg<Class<T, Args...>, U> {
+  using type = Class<U, Args...>;
+};
+
+template <typename T, typename U, typename = void>
+struct RebindPtr {
+  using type = typename RebindFirstArg<T, U>::type;
+};
+
+template <typename T, typename U>
+struct RebindPtr<T, U, void_t<typename T::template rebind<U>>> {
+  using type = typename T::template rebind<U>;
+};
+
+template <typename T, typename U>
+constexpr bool HasRebindAlloc(...) {
+  return false;
+}
+
+template <typename T, typename U>
+constexpr bool HasRebindAlloc(typename T::template rebind<U>::other*) {
+  return true;
+}
+
+template <typename T, typename U, bool = HasRebindAlloc<T, U>(nullptr)>
+struct RebindAlloc {
+  using type = typename RebindFirstArg<T, U>::type;
+};
+
+template <typename A, typename U>
+struct RebindAlloc<A, U, true> {
+    using type = typename std::allocator_traits<A>::template rebind_alloc<U>;
+};
+
+
+}  // namespace memory_internal
+
+template <typename Ptr>
+struct pointer_traits 
+{
+    using pointer = Ptr;
+
+    // element_type:
+    // Ptr::element_type if present. Otherwise T if Ptr is a template
+    // instantiation Template<T, Args...>
+    using element_type = typename memory_internal::ElementType<Ptr>::type;
+
+    // difference_type:
+    // Ptr::difference_type if present, otherwise std::ptrdiff_t
+    using difference_type =
+        memory_internal::ExtractOrT<memory_internal::GetDifferenceType, Ptr,
+                                    std::ptrdiff_t>;
+
+    // rebind:
+    // Ptr::rebind<U> if exists, otherwise Template<U, Args...> if Ptr is a
+    // template instantiation Template<T, Args...>
+    template <typename U>
+    using rebind = typename memory_internal::RebindPtr<Ptr, U>::type;
+
+    // pointer_to:
+    // Calls Ptr::pointer_to(r)
+    static pointer pointer_to(element_type& r) {  // NOLINT(runtime/references)
+        return Ptr::pointer_to(r);
+    }
+};
+
+// Specialization for T*.
+template <typename T>
+struct pointer_traits<T*> 
+{
+    using pointer = T*;
+    using element_type = T;
+    using difference_type = std::ptrdiff_t;
+
+    template <typename U>
+    using rebind = U*;
+
+    // pointer_to:
+    // Calls std::addressof(r)
+    static pointer pointer_to(
+        element_type& r) noexcept {  // NOLINT(runtime/references)
+        return std::addressof(r);
+    }
+};
+
+// -----------------------------------------------------------------------------
+// Class Template: allocator_traits
+// -----------------------------------------------------------------------------
+//
+// A C++11 compatible implementation of C++17's std::allocator_traits.
+//
+template <typename Alloc>
+struct allocator_traits 
+{
+    using allocator_type = Alloc;
+
+    // value_type:
+    // Alloc::value_type
+    using value_type = typename Alloc::value_type;
+
+    // pointer:
+    // Alloc::pointer if present, otherwise value_type*
+    using pointer = memory_internal::ExtractOrT<memory_internal::GetPointer,
+                                                Alloc, value_type*>;
+
+    // const_pointer:
+    // Alloc::const_pointer if present, otherwise
+    // phmap::pointer_traits<pointer>::rebind<const value_type>
+    using const_pointer =
+        memory_internal::ExtractOrT<memory_internal::GetConstPointer, Alloc,
+                                    typename phmap::pointer_traits<pointer>::
+                                    template rebind<const value_type>>;
+
+    // void_pointer:
+    // Alloc::void_pointer if present, otherwise
+    // phmap::pointer_traits<pointer>::rebind<void>
+    using void_pointer = memory_internal::ExtractOrT<
+        memory_internal::GetVoidPointer, Alloc,
+        typename phmap::pointer_traits<pointer>::template rebind<void>>;
+
+    // const_void_pointer:
+    // Alloc::const_void_pointer if present, otherwise
+    // phmap::pointer_traits<pointer>::rebind<const void>
+    using const_void_pointer = memory_internal::ExtractOrT<
+        memory_internal::GetConstVoidPointer, Alloc,
+        typename phmap::pointer_traits<pointer>::template rebind<const void>>;
+
+    // difference_type:
+    // Alloc::difference_type if present, otherwise
+    // phmap::pointer_traits<pointer>::difference_type
+    using difference_type = memory_internal::ExtractOrT<
+        memory_internal::GetDifferenceType, Alloc,
+        typename phmap::pointer_traits<pointer>::difference_type>;
+
+    // size_type:
+    // Alloc::size_type if present, otherwise
+    // std::make_unsigned<difference_type>::type
+    using size_type = memory_internal::ExtractOrT<
+        memory_internal::GetSizeType, Alloc,
+        typename std::make_unsigned<difference_type>::type>;
+
+    // propagate_on_container_copy_assignment:
+    // Alloc::propagate_on_container_copy_assignment if present, otherwise
+    // std::false_type
+    using propagate_on_container_copy_assignment = memory_internal::ExtractOrT<
+        memory_internal::GetPropagateOnContainerCopyAssignment, Alloc,
+        std::false_type>;
+
+    // propagate_on_container_move_assignment:
+    // Alloc::propagate_on_container_move_assignment if present, otherwise
+    // std::false_type
+    using propagate_on_container_move_assignment = memory_internal::ExtractOrT<
+        memory_internal::GetPropagateOnContainerMoveAssignment, Alloc,
+        std::false_type>;
+
+    // propagate_on_container_swap:
+    // Alloc::propagate_on_container_swap if present, otherwise std::false_type
+    using propagate_on_container_swap =
+        memory_internal::ExtractOrT<memory_internal::GetPropagateOnContainerSwap,
+                                    Alloc, std::false_type>;
+
+    // is_always_equal:
+    // Alloc::is_always_equal if present, otherwise std::is_empty<Alloc>::type
+    using is_always_equal =
+        memory_internal::ExtractOrT<memory_internal::GetIsAlwaysEqual, Alloc,
+                                    typename std::is_empty<Alloc>::type>;
+
+    // rebind_alloc:
+    // Alloc::rebind<T>::other if present, otherwise Alloc<T, Args> if this Alloc
+    // is Alloc<U, Args>
+    template <typename T>
+    using rebind_alloc = typename memory_internal::RebindAlloc<Alloc, T>::type;
+
+    // rebind_traits:
+    // phmap::allocator_traits<rebind_alloc<T>>
+    template <typename T>
+    using rebind_traits = phmap::allocator_traits<rebind_alloc<T>>;
+
+    // allocate(Alloc& a, size_type n):
+    // Calls a.allocate(n)
+    static pointer allocate(Alloc& a,  // NOLINT(runtime/references)
+                            size_type n) {
+        return a.allocate(n);
+    }
+
+    // allocate(Alloc& a, size_type n, const_void_pointer hint):
+    // Calls a.allocate(n, hint) if possible.
+    // If not possible, calls a.allocate(n)
+    static pointer allocate(Alloc& a, size_type n,  // NOLINT(runtime/references)
+                            const_void_pointer hint) {
+        return allocate_impl(0, a, n, hint);
+    }
+
+    // deallocate(Alloc& a, pointer p, size_type n):
+    // Calls a.deallocate(p, n)
+    static void deallocate(Alloc& a, pointer p,  // NOLINT(runtime/references)
+                           size_type n) {
+        a.deallocate(p, n);
+    }
+
+    // construct(Alloc& a, T* p, Args&&... args):
+    // Calls a.construct(p, std::forward<Args>(args)...) if possible.
+    // If not possible, calls
+    //   ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)
+    template <typename T, typename... Args>
+    static void construct(Alloc& a, T* p,  // NOLINT(runtime/references)
+                          Args&&... args) {
+        construct_impl(0, a, p, std::forward<Args>(args)...);
+    }
+
+    // destroy(Alloc& a, T* p):
+    // Calls a.destroy(p) if possible. If not possible, calls p->~T().
+    template <typename T>
+    static void destroy(Alloc& a, T* p) {  // NOLINT(runtime/references)
+        destroy_impl(0, a, p);
+    }
+
+    // max_size(const Alloc& a):
+    // Returns a.max_size() if possible. If not possible, returns
+    //   std::numeric_limits<size_type>::max() / sizeof(value_type)
+    static size_type max_size(const Alloc& a) { return max_size_impl(0, a); }
+
+    // select_on_container_copy_construction(const Alloc& a):
+    // Returns a.select_on_container_copy_construction() if possible.
+    // If not possible, returns a.
+    static Alloc select_on_container_copy_construction(const Alloc& a) {
+        return select_on_container_copy_construction_impl(0, a);
+    }
+
+private:
+    template <typename A>
+    static auto allocate_impl(int, A& a,  // NOLINT(runtime/references)
+                              size_type n, const_void_pointer hint)
+        -> decltype(a.allocate(n, hint)) {
+        return a.allocate(n, hint);
+    }
+    static pointer allocate_impl(char, Alloc& a,  // NOLINT(runtime/references)
+                                 size_type n, const_void_pointer) {
+        return a.allocate(n);
+    }
+
+    template <typename A, typename... Args>
+    static auto construct_impl(int, A& a,  // NOLINT(runtime/references)
+                               Args&&... args)
+        -> decltype(a.construct(std::forward<Args>(args)...)) {
+        std::allocator_traits<A>::construct(a, std::forward<Args>(args)...);
+    }
+
+    template <typename T, typename... Args>
+    static void construct_impl(char, Alloc&, T* p, Args&&... args) {
+        ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
+    }
+
+    template <typename A, typename T>
+    static auto destroy_impl(int, A& a,  // NOLINT(runtime/references)
+                             T* p) -> decltype(a.destroy(p)) {
+        std::allocator_traits<A>::destroy(a, p);
+    }
+    template <typename T>
+    static void destroy_impl(char, Alloc&, T* p) {
+        p->~T();
+    }
+
+    template <typename A>
+    static auto max_size_impl(int, const A& a) -> decltype(a.max_size()) {
+        return a.max_size();
+    }
+    static size_type max_size_impl(char, const Alloc&) {
+        return (std::numeric_limits<size_type>::max)() / sizeof(value_type);
+    }
+
+    template <typename A>
+    static auto select_on_container_copy_construction_impl(int, const A& a)
+        -> decltype(a.select_on_container_copy_construction()) {
+        return a.select_on_container_copy_construction();
+    }
+    static Alloc select_on_container_copy_construction_impl(char,
+                                                            const Alloc& a) {
+        return a;
+    }
+};
+
+namespace memory_internal {
+
+// This template alias transforms Alloc::is_nothrow into a metafunction with
+// Alloc as a parameter so it can be used with ExtractOrT<>.
+template <typename Alloc>
+using GetIsNothrow = typename Alloc::is_nothrow;
+
+}  // namespace memory_internal
+
+// PHMAP_ALLOCATOR_NOTHROW is a build time configuration macro for user to
+// specify whether the default allocation function can throw or never throws.
+// If the allocation function never throws, user should define it to a non-zero
+// value (e.g. via `-DPHMAP_ALLOCATOR_NOTHROW`).
+// If the allocation function can throw, user should leave it undefined or
+// define it to zero.
+//
+// allocator_is_nothrow<Alloc> is a traits class that derives from
+// Alloc::is_nothrow if present, otherwise std::false_type. It's specialized
+// for Alloc = std::allocator<T> for any type T according to the state of
+// PHMAP_ALLOCATOR_NOTHROW.
+//
+// default_allocator_is_nothrow is a class that derives from std::true_type
+// when the default allocator (global operator new) never throws, and
+// std::false_type when it can throw. It is a convenience shorthand for writing
+// allocator_is_nothrow<std::allocator<T>> (T can be any type).
+// NOTE: allocator_is_nothrow<std::allocator<T>> is guaranteed to derive from
+// the same type for all T, because users should specialize neither
+// allocator_is_nothrow nor std::allocator.
+template <typename Alloc>
+struct allocator_is_nothrow
+    : memory_internal::ExtractOrT<memory_internal::GetIsNothrow, Alloc,
+                                  std::false_type> {};
+
+#if defined(PHMAP_ALLOCATOR_NOTHROW) && PHMAP_ALLOCATOR_NOTHROW
+    template <typename T>
+    struct allocator_is_nothrow<std::allocator<T>> : std::true_type {};
+    struct default_allocator_is_nothrow : std::true_type {};
+#else
+    struct default_allocator_is_nothrow : std::false_type {};
+#endif
+
+namespace memory_internal {
+template <typename Allocator, typename Iterator, typename... Args>
+void ConstructRange(Allocator& alloc, Iterator first, Iterator last,
+                    const Args&... args) 
+{
+    for (Iterator cur = first; cur != last; ++cur) {
+        PHMAP_INTERNAL_TRY {
+            std::allocator_traits<Allocator>::construct(alloc, std::addressof(*cur),
+                                                        args...);
+        }
+        PHMAP_INTERNAL_CATCH_ANY {
+            while (cur != first) {
+                --cur;
+                std::allocator_traits<Allocator>::destroy(alloc, std::addressof(*cur));
+            }
+            PHMAP_INTERNAL_RETHROW;
+        }
+    }
+}
+
+template <typename Allocator, typename Iterator, typename InputIterator>
+void CopyRange(Allocator& alloc, Iterator destination, InputIterator first,
+               InputIterator last) 
+{
+    for (Iterator cur = destination; first != last;
+         static_cast<void>(++cur), static_cast<void>(++first)) {
+        PHMAP_INTERNAL_TRY {
+            std::allocator_traits<Allocator>::construct(alloc, std::addressof(*cur),
+                                                        *first);
+        }
+        PHMAP_INTERNAL_CATCH_ANY {
+            while (cur != destination) {
+                --cur;
+                std::allocator_traits<Allocator>::destroy(alloc, std::addressof(*cur));
+            }
+            PHMAP_INTERNAL_RETHROW;
+        }
+    }
+}
+}  // namespace memory_internal
+}  // namespace phmap
+
+
+// -----------------------------------------------------------------------------
+//          optional.h
+// -----------------------------------------------------------------------------
+#ifdef PHMAP_HAVE_STD_OPTIONAL
+
+#include <optional>  // IWYU pragma: export
+
+namespace phmap {
+using std::bad_optional_access;
+using std::optional;
+using std::make_optional;
+using std::nullopt_t;
+using std::nullopt;
+}  // namespace phmap
+
+#else
+
+#if defined(__clang__)
+    #if __has_feature(cxx_inheriting_constructors)
+        #define PHMAP_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1
+    #endif
+#elif (defined(__GNUC__) &&                                       \
+       (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 8)) || \
+    (__cpp_inheriting_constructors >= 200802) ||                  \
+    (defined(_MSC_VER) && _MSC_VER >= 1910)
+
+    #define PHMAP_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1
+#endif
+
+namespace phmap {
+
+class bad_optional_access : public std::exception 
+{
+public:
+    bad_optional_access() = default;
+    ~bad_optional_access() override;
+    const char* what() const noexcept override;
+};
+
+template <typename T>
+class optional;
+
+// --------------------------------
+struct nullopt_t 
+{
+    struct init_t {};
+    static init_t init;
+
+    explicit constexpr nullopt_t(init_t& /*unused*/) {}
+};
+
+constexpr nullopt_t nullopt(nullopt_t::init);
+
+namespace optional_internal {
+
+// throw delegator
+[[noreturn]] void throw_bad_optional_access();
+
+
+struct empty_struct {};
+
+// This class stores the data in optional<T>.
+// It is specialized based on whether T is trivially destructible.
+// This is the specialization for non trivially destructible type.
+template <typename T, bool unused = std::is_trivially_destructible<T>::value>
+class optional_data_dtor_base 
+{
+    struct dummy_type {
+        static_assert(sizeof(T) % sizeof(empty_struct) == 0, "");
+        // Use an array to avoid GCC 6 placement-new warning.
+        empty_struct data[sizeof(T) / sizeof(empty_struct)];
+    };
+
+protected:
+    // Whether there is data or not.
+    bool engaged_;
+    // Data storage
+    union {
+        dummy_type dummy_;
+        T data_;
+    };
+
+    void destruct() noexcept {
+        if (engaged_) {
+            data_.~T();
+            engaged_ = false;
+        }
+    }
+
+    // dummy_ must be initialized for constexpr constructor.
+    constexpr optional_data_dtor_base() noexcept : engaged_(false), dummy_{{}} {}
+
+    template <typename... Args>
+    constexpr explicit optional_data_dtor_base(in_place_t, Args&&... args)
+        : engaged_(true), data_(phmap::forward<Args>(args)...) {}
+
+    ~optional_data_dtor_base() { destruct(); }
+};
+
+// Specialization for trivially destructible type.
+template <typename T>
+class optional_data_dtor_base<T, true> 
+{
+    struct dummy_type {
+        static_assert(sizeof(T) % sizeof(empty_struct) == 0, "");
+        // Use array to avoid GCC 6 placement-new warning.
+        empty_struct data[sizeof(T) / sizeof(empty_struct)];
+    };
+
+protected:
+    // Whether there is data or not.
+    bool engaged_;
+    // Data storage
+    union {
+        dummy_type dummy_;
+        T data_;
+    };
+    void destruct() noexcept { engaged_ = false; }
+
+    // dummy_ must be initialized for constexpr constructor.
+    constexpr optional_data_dtor_base() noexcept : engaged_(false), dummy_{{}} {}
+
+    template <typename... Args>
+    constexpr explicit optional_data_dtor_base(in_place_t, Args&&... args)
+        : engaged_(true), data_(phmap::forward<Args>(args)...) {}
+};
+
+template <typename T>
+class optional_data_base : public optional_data_dtor_base<T> 
+{
+protected:
+    using base = optional_data_dtor_base<T>;
+#if PHMAP_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+    using base::base;
+#else
+    optional_data_base() = default;
+
+    template <typename... Args>
+    constexpr explicit optional_data_base(in_place_t t, Args&&... args)
+        : base(t, phmap::forward<Args>(args)...) {}
+#endif
+
+    template <typename... Args>
+    void construct(Args&&... args) {
+        // Use dummy_'s address to work around casting cv-qualified T* to void*.
+        ::new (static_cast<void*>(&this->dummy_)) T(std::forward<Args>(args)...);
+        this->engaged_ = true;
+    }
+
+    template <typename U>
+    void assign(U&& u) {
+        if (this->engaged_) {
+            this->data_ = std::forward<U>(u);
+        } else {
+            construct(std::forward<U>(u));
+        }
+    }
+};
+
+// TODO: Add another class using
+// std::is_trivially_move_constructible trait when available to match
+// http://cplusplus.github.io/LWG/lwg-defects.html#2900, for types that
+// have trivial move but nontrivial copy.
+// Also, we should be checking is_trivially_copyable here, which is not
+// supported now, so we use is_trivially_* traits instead.
+template <typename T,
+          bool unused = phmap::is_trivially_copy_constructible<T>::value&&
+              phmap::is_trivially_copy_assignable<typename std::remove_cv<
+                  T>::type>::value&& std::is_trivially_destructible<T>::value>
+class optional_data;
+
+// Trivially copyable types
+template <typename T>
+class optional_data<T, true> : public optional_data_base<T> 
+{
+protected:
+#if PHMAP_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+    using optional_data_base<T>::optional_data_base;
+#else
+    optional_data() = default;
+
+    template <typename... Args>
+    constexpr explicit optional_data(in_place_t t, Args&&... args)
+        : optional_data_base<T>(t, phmap::forward<Args>(args)...) {}
+#endif
+};
+
+template <typename T>
+class optional_data<T, false> : public optional_data_base<T> 
+{
+protected:
+#if PHMAP_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+    using optional_data_base<T>::optional_data_base;
+#else
+    template <typename... Args>
+    constexpr explicit optional_data(in_place_t t, Args&&... args)
+        : optional_data_base<T>(t, phmap::forward<Args>(args)...) {}
+#endif
+
+    optional_data() = default;
+
+    optional_data(const optional_data& rhs) : optional_data_base<T>() {
+        if (rhs.engaged_) {
+            this->construct(rhs.data_);
+        }
+    }
+
+    optional_data(optional_data&& rhs) noexcept(
+        phmap::default_allocator_is_nothrow::value ||
+        std::is_nothrow_move_constructible<T>::value)
+    : optional_data_base<T>() {
+        if (rhs.engaged_) {
+            this->construct(std::move(rhs.data_));
+        }
+    }
+
+    optional_data& operator=(const optional_data& rhs) {
+        if (rhs.engaged_) {
+            this->assign(rhs.data_);
+        } else {
+            this->destruct();
+        }
+        return *this;
+    }
+
+    optional_data& operator=(optional_data&& rhs) noexcept(
+        std::is_nothrow_move_assignable<T>::value&&
+        std::is_nothrow_move_constructible<T>::value) {
+        if (rhs.engaged_) {
+            this->assign(std::move(rhs.data_));
+        } else {
+            this->destruct();
+        }
+        return *this;
+    }
+};
+
+// Ordered by level of restriction, from low to high.
+// Copyable implies movable.
+enum class copy_traits { copyable = 0, movable = 1, non_movable = 2 };
+
+// Base class for enabling/disabling copy/move constructor.
+template <copy_traits>
+class optional_ctor_base;
+
+template <>
+class optional_ctor_base<copy_traits::copyable> 
+{
+public:
+    constexpr optional_ctor_base() = default;
+    optional_ctor_base(const optional_ctor_base&) = default;
+    optional_ctor_base(optional_ctor_base&&) = default;
+    optional_ctor_base& operator=(const optional_ctor_base&) = default;
+    optional_ctor_base& operator=(optional_ctor_base&&) = default;
+};
+
+template <>
+class optional_ctor_base<copy_traits::movable> 
+{
+public:
+    constexpr optional_ctor_base() = default;
+    optional_ctor_base(const optional_ctor_base&) = delete;
+    optional_ctor_base(optional_ctor_base&&) = default;
+    optional_ctor_base& operator=(const optional_ctor_base&) = default;
+    optional_ctor_base& operator=(optional_ctor_base&&) = default;
+};
+
+template <>
+class optional_ctor_base<copy_traits::non_movable> 
+{
+public:
+    constexpr optional_ctor_base() = default;
+    optional_ctor_base(const optional_ctor_base&) = delete;
+    optional_ctor_base(optional_ctor_base&&) = delete;
+    optional_ctor_base& operator=(const optional_ctor_base&) = default;
+    optional_ctor_base& operator=(optional_ctor_base&&) = default;
+};
+
+// Base class for enabling/disabling copy/move assignment.
+template <copy_traits>
+class optional_assign_base;
+
+template <>
+class optional_assign_base<copy_traits::copyable> 
+{
+public:
+    constexpr optional_assign_base() = default;
+    optional_assign_base(const optional_assign_base&) = default;
+    optional_assign_base(optional_assign_base&&) = default;
+    optional_assign_base& operator=(const optional_assign_base&) = default;
+    optional_assign_base& operator=(optional_assign_base&&) = default;
+};
+
+template <>
+class optional_assign_base<copy_traits::movable> 
+{
+public:
+    constexpr optional_assign_base() = default;
+    optional_assign_base(const optional_assign_base&) = default;
+    optional_assign_base(optional_assign_base&&) = default;
+    optional_assign_base& operator=(const optional_assign_base&) = delete;
+    optional_assign_base& operator=(optional_assign_base&&) = default;
+};
+
+template <>
+class optional_assign_base<copy_traits::non_movable> 
+{
+public:
+    constexpr optional_assign_base() = default;
+    optional_assign_base(const optional_assign_base&) = default;
+    optional_assign_base(optional_assign_base&&) = default;
+    optional_assign_base& operator=(const optional_assign_base&) = delete;
+    optional_assign_base& operator=(optional_assign_base&&) = delete;
+};
+
+template <typename T>
+constexpr copy_traits get_ctor_copy_traits() 
+{
+    return std::is_copy_constructible<T>::value
+        ? copy_traits::copyable
+        : std::is_move_constructible<T>::value ? copy_traits::movable
+        : copy_traits::non_movable;
+}
+
+template <typename T>
+constexpr copy_traits get_assign_copy_traits() 
+{
+    return phmap::is_copy_assignable<T>::value &&
+                 std::is_copy_constructible<T>::value
+             ? copy_traits::copyable
+             : phmap::is_move_assignable<T>::value &&
+                       std::is_move_constructible<T>::value
+                   ? copy_traits::movable
+                   : copy_traits::non_movable;
+}
+
+// Whether T is constructible or convertible from optional<U>.
+template <typename T, typename U>
+struct is_constructible_convertible_from_optional
+    : std::integral_constant<
+          bool, std::is_constructible<T, optional<U>&>::value ||
+                    std::is_constructible<T, optional<U>&&>::value ||
+                    std::is_constructible<T, const optional<U>&>::value ||
+                    std::is_constructible<T, const optional<U>&&>::value ||
+                    std::is_convertible<optional<U>&, T>::value ||
+                    std::is_convertible<optional<U>&&, T>::value ||
+                    std::is_convertible<const optional<U>&, T>::value ||
+                    std::is_convertible<const optional<U>&&, T>::value> {};
+
+// Whether T is constructible or convertible or assignable from optional<U>.
+template <typename T, typename U>
+struct is_constructible_convertible_assignable_from_optional
+    : std::integral_constant<
+          bool, is_constructible_convertible_from_optional<T, U>::value ||
+                    std::is_assignable<T&, optional<U>&>::value ||
+                    std::is_assignable<T&, optional<U>&&>::value ||
+                    std::is_assignable<T&, const optional<U>&>::value ||
+                    std::is_assignable<T&, const optional<U>&&>::value> {};
+
+// Helper function used by [optional.relops], [optional.comp_with_t],
+// for checking whether an expression is convertible to bool.
+bool convertible_to_bool(bool);
+
+// Base class for std::hash<phmap::optional<T>>:
+// If std::hash<std::remove_const_t<T>> is enabled, it provides operator() to
+// compute the hash; Otherwise, it is disabled.
+// Reference N4659 23.14.15 [unord.hash].
+template <typename T, typename = size_t>
+struct optional_hash_base 
+{
+    optional_hash_base() = delete;
+    optional_hash_base(const optional_hash_base&) = delete;
+    optional_hash_base(optional_hash_base&&) = delete;
+    optional_hash_base& operator=(const optional_hash_base&) = delete;
+    optional_hash_base& operator=(optional_hash_base&&) = delete;
+};
+
+template <typename T>
+struct optional_hash_base<T, decltype(std::hash<phmap::remove_const_t<T> >()(
+                                 std::declval<phmap::remove_const_t<T> >()))> 
+{
+    using argument_type = phmap::optional<T>;
+    using result_type = size_t;
+    size_t operator()(const phmap::optional<T>& opt) const {
+        phmap::type_traits_internal::AssertHashEnabled<phmap::remove_const_t<T>>();
+        if (opt) {
+            return std::hash<phmap::remove_const_t<T> >()(*opt);
+        } else {
+            return static_cast<size_t>(0x297814aaad196e6dULL);
+        }
+    }
+};
+
+}  // namespace optional_internal
+
+
+// -----------------------------------------------------------------------------
+// phmap::optional class definition
+// -----------------------------------------------------------------------------
+
+template <typename T>
+class optional : private optional_internal::optional_data<T>,
+                 private optional_internal::optional_ctor_base<
+                     optional_internal::get_ctor_copy_traits<T>()>,
+                 private optional_internal::optional_assign_base<
+                     optional_internal::get_assign_copy_traits<T>()> 
+{
+    using data_base = optional_internal::optional_data<T>;
+
+public:
+    typedef T value_type;
+
+    // Constructors
+
+    // Constructs an `optional` holding an empty value, NOT a default constructed
+    // `T`.
+    constexpr optional() noexcept {}
+
+    // Constructs an `optional` initialized with `nullopt` to hold an empty value.
+    constexpr optional(nullopt_t) noexcept {}  // NOLINT(runtime/explicit)
+
+    // Copy constructor, standard semantics
+    optional(const optional& src) = default;
+
+    // Move constructor, standard semantics
+    optional(optional&& src) = default;
+
+    // Constructs a non-empty `optional` direct-initialized value of type `T` from
+    // the arguments `std::forward<Args>(args)...`  within the `optional`.
+    // (The `in_place_t` is a tag used to indicate that the contained object
+    // should be constructed in-place.)
+    template <typename InPlaceT, typename... Args,
+              phmap::enable_if_t<phmap::conjunction<
+                                    std::is_same<InPlaceT, in_place_t>,
+                                    std::is_constructible<T, Args&&...> >::value>* = nullptr>
+        constexpr explicit optional(InPlaceT, Args&&... args)
+        : data_base(in_place_t(), phmap::forward<Args>(args)...) {}
+
+    // Constructs a non-empty `optional` direct-initialized value of type `T` from
+    // the arguments of an initializer_list and `std::forward<Args>(args)...`.
+    // (The `in_place_t` is a tag used to indicate that the contained object
+    // should be constructed in-place.)
+    template <typename U, typename... Args,
+              typename = typename std::enable_if<std::is_constructible<
+                                                     T, std::initializer_list<U>&, Args&&...>::value>::type>
+        constexpr explicit optional(in_place_t, std::initializer_list<U> il,
+                                    Args&&... args)
+        : data_base(in_place_t(), il, phmap::forward<Args>(args)...) {
+    }
+
+    // Value constructor (implicit)
+    template <
+        typename U = T,
+        typename std::enable_if<
+            phmap::conjunction<phmap::negation<std::is_same<
+                                                 in_place_t, typename std::decay<U>::type> >,
+                              phmap::negation<std::is_same<
+                                                 optional<T>, typename std::decay<U>::type> >,
+                              std::is_convertible<U&&, T>,
+                              std::is_constructible<T, U&&> >::value,
+            bool>::type = false>
+        constexpr optional(U&& v) : data_base(in_place_t(), phmap::forward<U>(v)) {}
+
+    // Value constructor (explicit)
+    template <
+        typename U = T,
+        typename std::enable_if<
+            phmap::conjunction<phmap::negation<std::is_same<
+                                                 in_place_t, typename std::decay<U>::type>>,
+                              phmap::negation<std::is_same<
+                                                 optional<T>, typename std::decay<U>::type>>,
+                              phmap::negation<std::is_convertible<U&&, T>>,
+                              std::is_constructible<T, U&&>>::value,
+            bool>::type = false>
+        explicit constexpr optional(U&& v)
+        : data_base(in_place_t(), phmap::forward<U>(v)) {}
+
+    // Converting copy constructor (implicit)
+    template <typename U,
+              typename std::enable_if<
+                  phmap::conjunction<
+                      phmap::negation<std::is_same<T, U> >,
+                      std::is_constructible<T, const U&>,
+                      phmap::negation<
+                          optional_internal::
+                          is_constructible_convertible_from_optional<T, U> >,
+                      std::is_convertible<const U&, T> >::value,
+                  bool>::type = false>
+    optional(const optional<U>& rhs) {
+        if (rhs) {
+            this->construct(*rhs);
+        }
+    }
+
+    // Converting copy constructor (explicit)
+    template <typename U,
+              typename std::enable_if<
+                  phmap::conjunction<
+                      phmap::negation<std::is_same<T, U>>,
+                      std::is_constructible<T, const U&>,
+                      phmap::negation<
+                          optional_internal::
+                          is_constructible_convertible_from_optional<T, U>>,
+                      phmap::negation<std::is_convertible<const U&, T>>>::value,
+                  bool>::type = false>
+        explicit optional(const optional<U>& rhs) {
+        if (rhs) {
+            this->construct(*rhs);
+        }
+    }
+
+    // Converting move constructor (implicit)
+    template <typename U,
+              typename std::enable_if<
+                  phmap::conjunction<
+                      phmap::negation<std::is_same<T, U> >,
+                      std::is_constructible<T, U&&>,
+                      phmap::negation<
+                          optional_internal::
+                          is_constructible_convertible_from_optional<T, U> >,
+                      std::is_convertible<U&&, T> >::value,
+                  bool>::type = false>
+        optional(optional<U>&& rhs) {
+        if (rhs) {
+            this->construct(std::move(*rhs));
+        }
+    }
+
+    // Converting move constructor (explicit)
+    template <
+        typename U,
+        typename std::enable_if<
+            phmap::conjunction<
+                phmap::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
+                phmap::negation<
+                    optional_internal::is_constructible_convertible_from_optional<
+                        T, U>>,
+                phmap::negation<std::is_convertible<U&&, T>>>::value,
+            bool>::type = false>
+        explicit optional(optional<U>&& rhs) {
+        if (rhs) {
+            this->construct(std::move(*rhs));
+        }
+    }
+
+    // Destructor. Trivial if `T` is trivially destructible.
+    ~optional() = default;
+
+    // Assignment Operators
+
+    // Assignment from `nullopt`
+    //
+    // Example:
+    //
+    //   struct S { int value; };
+    //   optional<S> opt = phmap::nullopt;  // Could also use opt = { };
+    optional& operator=(nullopt_t) noexcept {
+        this->destruct();
+        return *this;
+    }
+
+    // Copy assignment operator, standard semantics
+    optional& operator=(const optional& src) = default;
+
+    // Move assignment operator, standard semantics
+    optional& operator=(optional&& src) = default;
+
+    // Value assignment operators
+    template <
+        typename U = T,
+        typename = typename std::enable_if<phmap::conjunction<
+                                               phmap::negation<
+                                                   std::is_same<optional<T>, typename std::decay<U>::type>>,
+                                               phmap::negation<
+                                                   phmap::conjunction<std::is_scalar<T>,
+                                                                     std::is_same<T, typename std::decay<U>::type>>>,
+                                               std::is_constructible<T, U>, std::is_assignable<T&, U>>::value>::type>
+        optional& operator=(U&& v) {
+        this->assign(std::forward<U>(v));
+        return *this;
+    }
+
+    template <
+        typename U,
+        typename = typename std::enable_if<phmap::conjunction<
+                                               phmap::negation<std::is_same<T, U>>,
+                                               std::is_constructible<T, const U&>, std::is_assignable<T&, const U&>,
+                                               phmap::negation<
+                                                   optional_internal::
+                                                   is_constructible_convertible_assignable_from_optional<
+                                                       T, U>>>::value>::type>
+        optional& operator=(const optional<U>& rhs) {
+        if (rhs) {
+            this->assign(*rhs);
+        } else {
+            this->destruct();
+        }
+        return *this;
+    }
+
+    template <typename U,
+              typename = typename std::enable_if<phmap::conjunction<
+                                                     phmap::negation<std::is_same<T, U>>, std::is_constructible<T, U>,
+                                                     std::is_assignable<T&, U>,
+                                                     phmap::negation<
+                                                         optional_internal::
+                                                         is_constructible_convertible_assignable_from_optional<
+                                                             T, U>>>::value>::type>
+        optional& operator=(optional<U>&& rhs) {
+        if (rhs) {
+            this->assign(std::move(*rhs));
+        } else {
+            this->destruct();
+        }
+        return *this;
+    }
+
+    // Modifiers
+
+    // optional::reset()
+    //
+    // Destroys the inner `T` value of an `phmap::optional` if one is present.
+    PHMAP_ATTRIBUTE_REINITIALIZES void reset() noexcept { this->destruct(); }
+
+    // optional::emplace()
+    //
+    // (Re)constructs the underlying `T` in-place with the given forwarded
+    // arguments.
+    //
+    // Example:
+    //
+    //   optional<Foo> opt;
+    //   opt.emplace(arg1,arg2,arg3);  // Constructs Foo(arg1,arg2,arg3)
+    //
+    // If the optional is non-empty, and the `args` refer to subobjects of the
+    // current object, then behaviour is undefined, because the current object
+    // will be destructed before the new object is constructed with `args`.
+    template <typename... Args,
+              typename = typename std::enable_if<
+                  std::is_constructible<T, Args&&...>::value>::type>
+        T& emplace(Args&&... args) {
+        this->destruct();
+        this->construct(std::forward<Args>(args)...);
+        return reference();
+    }
+
+    // Emplace reconstruction overload for an initializer list and the given
+    // forwarded arguments.
+    //
+    // Example:
+    //
+    //   struct Foo {
+    //     Foo(std::initializer_list<int>);
+    //   };
+    //
+    //   optional<Foo> opt;
+    //   opt.emplace({1,2,3});  // Constructs Foo({1,2,3})
+    template <typename U, typename... Args,
+              typename = typename std::enable_if<std::is_constructible<
+                                                     T, std::initializer_list<U>&, Args&&...>::value>::type>
+        T& emplace(std::initializer_list<U> il, Args&&... args) {
+        this->destruct();
+        this->construct(il, std::forward<Args>(args)...);
+        return reference();
+    }
+
+    // Swaps
+
+    // Swap, standard semantics
+    void swap(optional& rhs) noexcept(
+        std::is_nothrow_move_constructible<T>::value&&
+        std::is_trivial<T>::value) {
+        if (*this) {
+            if (rhs) {
+                using std::swap;
+                swap(**this, *rhs);
+            } else {
+                rhs.construct(std::move(**this));
+                this->destruct();
+            }
+        } else {
+            if (rhs) {
+                this->construct(std::move(*rhs));
+                rhs.destruct();
+            } else {
+                // No effect (swap(disengaged, disengaged)).
+            }
+        }
+    }
+
+    // Observers
+
+    // optional::operator->()
+    //
+    // Accesses the underlying `T` value's member `m` of an `optional`. If the
+    // `optional` is empty, behavior is undefined.
+    //
+    // If you need myOpt->foo in constexpr, use (*myOpt).foo instead.
+    const T* operator->() const {
+        assert(this->engaged_);
+        return std::addressof(this->data_);
+    }
+    T* operator->() {
+        assert(this->engaged_);
+        return std::addressof(this->data_);
+    }
+
+    // optional::operator*()
+    //
+    // Accesses the underlying `T` value of an `optional`. If the `optional` is
+    // empty, behavior is undefined.
+    constexpr const T& operator*() const & { return reference(); }
+    T& operator*() & {
+        assert(this->engaged_);
+        return reference();
+    }
+    constexpr const T&& operator*() const && {
+        return phmap::move(reference());
+    }
+    T&& operator*() && {
+        assert(this->engaged_);
+        return std::move(reference());
+    }
+
+    // optional::operator bool()
+    //
+    // Returns false if and only if the `optional` is empty.
+    //
+    //   if (opt) {
+    //     // do something with opt.value();
+    //   } else {
+    //     // opt is empty.
+    //   }
+    //
+    constexpr explicit operator bool() const noexcept { return this->engaged_; }
+
+    // optional::has_value()
+    //
+    // Determines whether the `optional` contains a value. Returns `false` if and
+    // only if `*this` is empty.
+    constexpr bool has_value() const noexcept { return this->engaged_; }
+
+// Suppress bogus warning on MSVC: MSVC complains call to reference() after
+// throw_bad_optional_access() is unreachable.
+#ifdef _MSC_VER
+    #pragma warning(push)
+    #pragma warning(disable : 4702)
+#endif  // _MSC_VER
+    // optional::value()
+    //
+    // Returns a reference to an `optional`s underlying value. The constness
+    // and lvalue/rvalue-ness of the `optional` is preserved to the view of
+    // the `T` sub-object. Throws `phmap::bad_optional_access` when the `optional`
+    // is empty.
+    constexpr const T& value() const & {
+        return static_cast<bool>(*this)
+            ? reference()
+            : (optional_internal::throw_bad_optional_access(), reference());
+    }
+    T& value() & {
+        return static_cast<bool>(*this)
+            ? reference()
+            : (optional_internal::throw_bad_optional_access(), reference());
+    }
+    T&& value() && {  // NOLINT(build/c++11)
+        return std::move(
+            static_cast<bool>(*this)
+            ? reference()
+            : (optional_internal::throw_bad_optional_access(), reference()));
+    }
+    constexpr const T&& value() const && {  // NOLINT(build/c++11)
+        return phmap::move(
+            static_cast<bool>(*this)
+            ? reference()
+            : (optional_internal::throw_bad_optional_access(), reference()));
+    }
+#ifdef _MSC_VER
+    #pragma warning(pop)
+#endif  // _MSC_VER
+
+    // optional::value_or()
+    //
+    // Returns either the value of `T` or a passed default `v` if the `optional`
+    // is empty.
+    template <typename U>
+    constexpr T value_or(U&& v) const& {
+        static_assert(std::is_copy_constructible<value_type>::value,
+                      "optional<T>::value_or: T must by copy constructible");
+        static_assert(std::is_convertible<U&&, value_type>::value,
+                      "optional<T>::value_or: U must be convertible to T");
+        return static_cast<bool>(*this)
+            ? **this
+            : static_cast<T>(phmap::forward<U>(v));
+    }
+    template <typename U>
+    T value_or(U&& v) && {  // NOLINT(build/c++11)
+        static_assert(std::is_move_constructible<value_type>::value,
+                      "optional<T>::value_or: T must by move constructible");
+        static_assert(std::is_convertible<U&&, value_type>::value,
+                      "optional<T>::value_or: U must be convertible to T");
+        return static_cast<bool>(*this) ? std::move(**this)
+            : static_cast<T>(std::forward<U>(v));
+    }
+
+private:
+    // Private accessors for internal storage viewed as reference to T.
+    constexpr const T& reference() const { return this->data_; }
+    T& reference() { return this->data_; }
+
+    // T constraint checks.  You can't have an optional of nullopt_t, in_place_t
+    // or a reference.
+    static_assert(
+        !std::is_same<nullopt_t, typename std::remove_cv<T>::type>::value,
+        "optional<nullopt_t> is not allowed.");
+    static_assert(
+        !std::is_same<in_place_t, typename std::remove_cv<T>::type>::value,
+        "optional<in_place_t> is not allowed.");
+    static_assert(!std::is_reference<T>::value,
+                  "optional<reference> is not allowed.");
+};
+
+// Non-member functions
+
+// swap()
+//
+// Performs a swap between two `phmap::optional` objects, using standard
+// semantics.
+//
+// NOTE: we assume `is_swappable()` is always `true`. A compile error will
+// result if this is not the case.
+template <typename T,
+          typename std::enable_if<std::is_move_constructible<T>::value,
+                                  bool>::type = false>
+void swap(optional<T>& a, optional<T>& b) noexcept(noexcept(a.swap(b))) {
+    a.swap(b);
+}
+
+// make_optional()
+//
+// Creates a non-empty `optional<T>` where the type of `T` is deduced. An
+// `phmap::optional` can also be explicitly instantiated with
+// `make_optional<T>(v)`.
+//
+// Note: `make_optional()` constructions may be declared `constexpr` for
+// trivially copyable types `T`. Non-trivial types require copy elision
+// support in C++17 for `make_optional` to support `constexpr` on such
+// non-trivial types.
+//
+// Example:
+//
+//   constexpr phmap::optional<int> opt = phmap::make_optional(1);
+//   static_assert(opt.value() == 1, "");
+template <typename T>
+constexpr optional<typename std::decay<T>::type> make_optional(T&& v) {
+    return optional<typename std::decay<T>::type>(phmap::forward<T>(v));
+}
+
+template <typename T, typename... Args>
+constexpr optional<T> make_optional(Args&&... args) {
+    return optional<T>(in_place_t(), phmap::forward<Args>(args)...);
+}
+
+template <typename T, typename U, typename... Args>
+constexpr optional<T> make_optional(std::initializer_list<U> il,
+                                    Args&&... args) {
+    return optional<T>(in_place_t(), il,
+                       phmap::forward<Args>(args)...);
+}
+
+// Relational operators [optional.relops]
+
+// Empty optionals are considered equal to each other and less than non-empty
+// optionals. Supports relations between optional<T> and optional<U>, between
+// optional<T> and U, and between optional<T> and nullopt.
+//
+// Note: We're careful to support T having non-bool relationals.
+
+// Requires: The expression, e.g. "*x == *y" shall be well-formed and its result
+// shall be convertible to bool.
+// The C++17 (N4606) "Returns:" statements are translated into
+// code in an obvious way here, and the original text retained as function docs.
+// Returns: If bool(x) != bool(y), false; otherwise if bool(x) == false, true;
+// otherwise *x == *y.
+template <typename T, typename U>
+constexpr auto operator==(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x == *y)) {
+    return static_cast<bool>(x) != static_cast<bool>(y)
+             ? false
+             : static_cast<bool>(x) == false ? true
+                                             : static_cast<bool>(*x == *y);
+}
+
+// Returns: If bool(x) != bool(y), true; otherwise, if bool(x) == false, false;
+// otherwise *x != *y.
+template <typename T, typename U>
+constexpr auto operator!=(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x != *y)) {
+    return static_cast<bool>(x) != static_cast<bool>(y)
+             ? true
+             : static_cast<bool>(x) == false ? false
+                                             : static_cast<bool>(*x != *y);
+}
+// Returns: If !y, false; otherwise, if !x, true; otherwise *x < *y.
+template <typename T, typename U>
+constexpr auto operator<(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x < *y)) {
+    return !y ? false : !x ? true : static_cast<bool>(*x < *y);
+}
+// Returns: If !x, false; otherwise, if !y, true; otherwise *x > *y.
+template <typename T, typename U>
+constexpr auto operator>(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x > *y)) {
+    return !x ? false : !y ? true : static_cast<bool>(*x > *y);
+}
+// Returns: If !x, true; otherwise, if !y, false; otherwise *x <= *y.
+template <typename T, typename U>
+constexpr auto operator<=(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x <= *y)) {
+    return !x ? true : !y ? false : static_cast<bool>(*x <= *y);
+}
+// Returns: If !y, true; otherwise, if !x, false; otherwise *x >= *y.
+template <typename T, typename U>
+constexpr auto operator>=(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x >= *y)) {
+    return !y ? true : !x ? false : static_cast<bool>(*x >= *y);
+}
+
+// Comparison with nullopt [optional.nullops]
+// The C++17 (N4606) "Returns:" statements are used directly here.
+template <typename T>
+constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept {
+    return !x;
+}
+template <typename T>
+constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept {
+    return !x;
+}
+template <typename T>
+constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept {
+    return static_cast<bool>(x);
+}
+template <typename T>
+constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept {
+    return static_cast<bool>(x);
+}
+template <typename T>
+constexpr bool operator<(const optional<T>&, nullopt_t) noexcept {
+    return false;
+}
+template <typename T>
+constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept {
+    return static_cast<bool>(x);
+}
+template <typename T>
+constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept {
+    return !x;
+}
+template <typename T>
+constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept {
+    return true;
+}
+template <typename T>
+constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept {
+    return static_cast<bool>(x);
+}
+template <typename T>
+constexpr bool operator>(nullopt_t, const optional<T>&) noexcept {
+    return false;
+}
+template <typename T>
+constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept {
+    return true;
+}
+template <typename T>
+constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept {
+    return !x;
+}
+
+// Comparison with T [optional.comp_with_t]
+
+// Requires: The expression, e.g. "*x == v" shall be well-formed and its result
+// shall be convertible to bool.
+// The C++17 (N4606) "Equivalent to:" statements are used directly here.
+template <typename T, typename U>
+constexpr auto operator==(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x == v)) {
+    return static_cast<bool>(x) ? static_cast<bool>(*x == v) : false;
+}
+template <typename T, typename U>
+constexpr auto operator==(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v == *x)) {
+    return static_cast<bool>(x) ? static_cast<bool>(v == *x) : false;
+}
+template <typename T, typename U>
+constexpr auto operator!=(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x != v)) {
+    return static_cast<bool>(x) ? static_cast<bool>(*x != v) : true;
+}
+template <typename T, typename U>
+constexpr auto operator!=(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v != *x)) {
+    return static_cast<bool>(x) ? static_cast<bool>(v != *x) : true;
+}
+template <typename T, typename U>
+constexpr auto operator<(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x < v)) {
+    return static_cast<bool>(x) ? static_cast<bool>(*x < v) : true;
+}
+template <typename T, typename U>
+constexpr auto operator<(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v < *x)) {
+    return static_cast<bool>(x) ? static_cast<bool>(v < *x) : false;
+}
+template <typename T, typename U>
+constexpr auto operator<=(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x <= v)) {
+    return static_cast<bool>(x) ? static_cast<bool>(*x <= v) : true;
+}
+template <typename T, typename U>
+constexpr auto operator<=(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v <= *x)) {
+    return static_cast<bool>(x) ? static_cast<bool>(v <= *x) : false;
+}
+template <typename T, typename U>
+constexpr auto operator>(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x > v)) {
+    return static_cast<bool>(x) ? static_cast<bool>(*x > v) : false;
+}
+template <typename T, typename U>
+constexpr auto operator>(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v > *x)) {
+    return static_cast<bool>(x) ? static_cast<bool>(v > *x) : true;
+}
+template <typename T, typename U>
+constexpr auto operator>=(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x >= v)) {
+    return static_cast<bool>(x) ? static_cast<bool>(*x >= v) : false;
+}
+template <typename T, typename U>
+constexpr auto operator>=(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v >= *x)) {
+    return static_cast<bool>(x) ? static_cast<bool>(v >= *x) : true;
+}
+
+}  // namespace phmap
+
+namespace std {
+
+// std::hash specialization for phmap::optional.
+template <typename T>
+struct hash<phmap::optional<T> >
+    : phmap::optional_internal::optional_hash_base<T> {};
+
+}  // namespace std
+
+#endif
+
+// -----------------------------------------------------------------------------
+//          common.h
+// -----------------------------------------------------------------------------
+namespace phmap {
+namespace priv {
+
+template <class, class = void>
+struct IsTransparent : std::false_type {};
+template <class T>
+struct IsTransparent<T, phmap::void_t<typename T::is_transparent>>
+    : std::true_type {};
+
+template <bool is_transparent>
+struct KeyArg 
+{
+    // Transparent. Forward `K`.
+    template <typename K, typename key_type>
+    using type = K;
+};
+
+template <>
+struct KeyArg<false> 
+{
+    // Not transparent. Always use `key_type`.
+    template <typename K, typename key_type>
+    using type = key_type;
+};
+
+#ifdef _MSC_VER
+    #pragma warning(push)  
+    //  warning C4820: '6' bytes padding added after data member
+    #pragma warning(disable : 4820)
+#endif
+
+// The node_handle concept from C++17.
+// We specialize node_handle for sets and maps. node_handle_base holds the
+// common API of both.
+// -----------------------------------------------------------------------
+template <typename PolicyTraits, typename Alloc>
+class node_handle_base 
+{
+protected:
+    using slot_type = typename PolicyTraits::slot_type;
+
+public:
+    using allocator_type = Alloc;
+
+    constexpr node_handle_base() {}
+
+    node_handle_base(node_handle_base&& other) noexcept {
+        *this = std::move(other);
+    }
+
+    ~node_handle_base() { destroy(); }
+
+    node_handle_base& operator=(node_handle_base&& other) noexcept {
+        destroy();
+        if (!other.empty()) {
+            alloc_ = other.alloc_;
+            PolicyTraits::transfer(alloc(), slot(), other.slot());
+            other.reset();
+        }
+        return *this;
+    }
+
+    bool empty() const noexcept { return !alloc_; }
+    explicit operator bool() const noexcept { return !empty(); }
+    allocator_type get_allocator() const { return *alloc_; }
+
+protected:
+    friend struct CommonAccess;
+
+    struct transfer_tag_t {};
+    node_handle_base(transfer_tag_t, const allocator_type& a, slot_type* s)
+        : alloc_(a) {
+        PolicyTraits::transfer(alloc(), slot(), s);
+    }
+    
+    struct move_tag_t {};
+    node_handle_base(move_tag_t, const allocator_type& a, slot_type* s)
+        : alloc_(a) {
+        PolicyTraits::construct(alloc(), slot(), s);
+    }
+
+    node_handle_base(const allocator_type& a, slot_type* s) : alloc_(a) {
+        PolicyTraits::transfer(alloc(), slot(), s);
+    }
+
+    //node_handle_base(const node_handle_base&) = delete;
+    //node_handle_base& operator=(const node_handle_base&) = delete;
+
+    void destroy() {
+        if (!empty()) {
+            PolicyTraits::destroy(alloc(), slot());
+            reset();
+        }
+    }
+
+    void reset() {
+        assert(alloc_.has_value());
+        alloc_ = phmap::nullopt;
+    }
+
+    slot_type* slot() const {
+        assert(!empty());
+        return reinterpret_cast<slot_type*>(std::addressof(slot_space_));
+    }
+
+    allocator_type* alloc() { return std::addressof(*alloc_); }
+
+private:
+    phmap::optional<allocator_type> alloc_;
+    mutable phmap::aligned_storage_t<sizeof(slot_type), alignof(slot_type)> slot_space_;
+};
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+// For sets.
+// ---------
+template <typename Policy, typename PolicyTraits, typename Alloc,
+          typename = void>
+class node_handle : public node_handle_base<PolicyTraits, Alloc> 
+{
+    using Base = node_handle_base<PolicyTraits, Alloc>;
+
+public:
+    using value_type = typename PolicyTraits::value_type;
+
+    constexpr node_handle() {}
+
+    value_type& value() const { return PolicyTraits::element(this->slot()); }
+
+    value_type& key() const { return PolicyTraits::element(this->slot()); }
+
+private:
+    friend struct CommonAccess;
+
+    using Base::Base;
+};
+
+// For maps.
+// ---------
+template <typename Policy, typename PolicyTraits, typename Alloc>
+class node_handle<Policy, PolicyTraits, Alloc,
+                  phmap::void_t<typename Policy::mapped_type>>
+    : public node_handle_base<PolicyTraits, Alloc> 
+{
+    using Base = node_handle_base<PolicyTraits, Alloc>;
+
+public:
+    using key_type = typename Policy::key_type;
+    using mapped_type = typename Policy::mapped_type;
+
+    constexpr node_handle() {}
+
+    auto key() const -> decltype(PolicyTraits::key(this->slot())) {
+        return PolicyTraits::key(this->slot());
+    }
+
+    mapped_type& mapped() const {
+        return PolicyTraits::value(&PolicyTraits::element(this->slot()));
+    }
+
+private:
+    friend struct CommonAccess;
+
+    using Base::Base;
+};
+
+// Provide access to non-public node-handle functions.
+struct CommonAccess 
+{
+    template <typename Node>
+    static auto GetSlot(const Node& node) -> decltype(node.slot()) {
+        return node.slot();
+    }
+
+    template <typename Node>
+    static void Destroy(Node* node) {
+        node->destroy();
+    }
+
+    template <typename Node>
+    static void Reset(Node* node) {
+        node->reset();
+    }
+
+    template <typename T, typename... Args>
+    static T Make(Args&&... args) {
+        return T(std::forward<Args>(args)...);
+    }
+
+    template <typename T, typename... Args>
+    static T Transfer(Args&&... args) {
+        return T(typename T::transfer_tag_t{}, std::forward<Args>(args)...);
+    }
+
+    template <typename T, typename... Args>
+    static T Move(Args&&... args) {
+        return T(typename T::move_tag_t{}, std::forward<Args>(args)...);
+    }
+};
+
+// Implement the insert_return_type<> concept of C++17.
+template <class Iterator, class NodeType>
+struct InsertReturnType 
+{
+    Iterator position;
+    bool inserted;
+    NodeType node;
+};
+
+}  // namespace priv
+}  // namespace phmap
+
+
+#ifdef ADDRESS_SANITIZER
+    #include <sanitizer/asan_interface.h>
+#endif
+
+// ---------------------------------------------------------------------------
+//  span.h
+// ---------------------------------------------------------------------------
+
+namespace phmap {
+
+template <typename T>
+class Span;
+
+namespace span_internal {
+// A constexpr min function
+constexpr size_t Min(size_t a, size_t b) noexcept { return a < b ? a : b; }
+
+// Wrappers for access to container data pointers.
+template <typename C>
+constexpr auto GetDataImpl(C& c, char) noexcept  // NOLINT(runtime/references)
+    -> decltype(c.data()) {
+  return c.data();
+}
+
+// Before C++17, std::string::data returns a const char* in all cases.
+inline char* GetDataImpl(std::string& s,  // NOLINT(runtime/references)
+                         int) noexcept {
+  return &s[0];
+}
+
+template <typename C>
+constexpr auto GetData(C& c) noexcept  // NOLINT(runtime/references)
+    -> decltype(GetDataImpl(c, 0)) {
+  return GetDataImpl(c, 0);
+}
+
+// Detection idioms for size() and data().
+template <typename C>
+using HasSize =
+    std::is_integral<phmap::decay_t<decltype(std::declval<C&>().size())>>;
+
+// We want to enable conversion from vector<T*> to Span<const T* const> but
+// disable conversion from vector<Derived> to Span<Base>. Here we use
+// the fact that U** is convertible to Q* const* if and only if Q is the same
+// type or a more cv-qualified version of U.  We also decay the result type of
+// data() to avoid problems with classes which have a member function data()
+// which returns a reference.
+template <typename T, typename C>
+using HasData =
+    std::is_convertible<phmap::decay_t<decltype(GetData(std::declval<C&>()))>*,
+                        T* const*>;
+
+// Extracts value type from a Container
+template <typename C>
+struct ElementType {
+  using type = typename phmap::remove_reference_t<C>::value_type;
+};
+
+template <typename T, size_t N>
+struct ElementType<T (&)[N]> {
+  using type = T;
+};
+
+template <typename C>
+using ElementT = typename ElementType<C>::type;
+
+template <typename T>
+using EnableIfMutable =
+    typename std::enable_if<!std::is_const<T>::value, int>::type;
+
+template <typename T>
+bool EqualImpl(Span<T> a, Span<T> b) {
+  static_assert(std::is_const<T>::value, "");
+  return std::equal(a.begin(), a.end(), b.begin(), b.end());
+}
+
+template <typename T>
+bool LessThanImpl(Span<T> a, Span<T> b) {
+  static_assert(std::is_const<T>::value, "");
+  return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
+}
+
+// The `IsConvertible` classes here are needed because of the
+// `std::is_convertible` bug in libcxx when compiled with GCC. This build
+// configuration is used by Android NDK toolchain. Reference link:
+// https://bugs.llvm.org/show_bug.cgi?id=27538.
+template <typename From, typename To>
+struct IsConvertibleHelper {
+  static std::true_type testval(To);
+  static std::false_type testval(...);
+
+  using type = decltype(testval(std::declval<From>()));
+};
+
+template <typename From, typename To>
+struct IsConvertible : IsConvertibleHelper<From, To>::type {};
+
+// TODO(zhangxy): replace `IsConvertible` with `std::is_convertible` once the
+// older version of libcxx is not supported.
+template <typename From, typename To>
+using EnableIfConvertibleToSpanConst =
+    typename std::enable_if<IsConvertible<From, Span<const To>>::value>::type;
+}  // namespace span_internal
+
+//------------------------------------------------------------------------------
+// Span
+//------------------------------------------------------------------------------
+//
+// A `Span` is an "array view" type for holding a view of a contiguous data
+// array; the `Span` object does not and cannot own such data itself. A span
+// provides an easy way to provide overloads for anything operating on
+// contiguous sequences without needing to manage pointers and array lengths
+// manually.
+
+// A span is conceptually a pointer (ptr) and a length (size) into an already
+// existing array of contiguous memory; the array it represents references the
+// elements "ptr[0] .. ptr[size-1]". Passing a properly-constructed `Span`
+// instead of raw pointers avoids many issues related to index out of bounds
+// errors.
+//
+// Spans may also be constructed from containers holding contiguous sequences.
+// Such containers must supply `data()` and `size() const` methods (e.g
+// `std::vector<T>`, `phmap::InlinedVector<T, N>`). All implicit conversions to
+// `phmap::Span` from such containers will create spans of type `const T`;
+// spans which can mutate their values (of type `T`) must use explicit
+// constructors.
+//
+// A `Span<T>` is somewhat analogous to an `phmap::string_view`, but for an array
+// of elements of type `T`. A user of `Span` must ensure that the data being
+// pointed to outlives the `Span` itself.
+//
+// You can construct a `Span<T>` in several ways:
+//
+//   * Explicitly from a reference to a container type
+//   * Explicitly from a pointer and size
+//   * Implicitly from a container type (but only for spans of type `const T`)
+//   * Using the `MakeSpan()` or `MakeConstSpan()` factory functions.
+//
+// Examples:
+//
+//   // Construct a Span explicitly from a container:
+//   std::vector<int> v = {1, 2, 3, 4, 5};
+//   auto span = phmap::Span<const int>(v);
+//
+//   // Construct a Span explicitly from a C-style array:
+//   int a[5] =  {1, 2, 3, 4, 5};
+//   auto span = phmap::Span<const int>(a);
+//
+//   // Construct a Span implicitly from a container
+//   void MyRoutine(phmap::Span<const int> a) {
+//     ...
+//   }
+//   std::vector v = {1,2,3,4,5};
+//   MyRoutine(v)                     // convert to Span<const T>
+//
+// Note that `Span` objects, in addition to requiring that the memory they
+// point to remains alive, must also ensure that such memory does not get
+// reallocated. Therefore, to avoid undefined behavior, containers with
+// associated span views should not invoke operations that may reallocate memory
+// (such as resizing) or invalidate iterators into the container.
+//
+// One common use for a `Span` is when passing arguments to a routine that can
+// accept a variety of array types (e.g. a `std::vector`, `phmap::InlinedVector`,
+// a C-style array, etc.). Instead of creating overloads for each case, you
+// can simply specify a `Span` as the argument to such a routine.
+//
+// Example:
+//
+//   void MyRoutine(phmap::Span<const int> a) {
+//     ...
+//   }
+//
+//   std::vector v = {1,2,3,4,5};
+//   MyRoutine(v);
+//
+//   phmap::InlinedVector<int, 4> my_inline_vector;
+//   MyRoutine(my_inline_vector);
+//
+//   // Explicit constructor from pointer,size
+//   int* my_array = new int[10];
+//   MyRoutine(phmap::Span<const int>(my_array, 10));
+template <typename T>
+class Span 
+{
+private:
+    // Used to determine whether a Span can be constructed from a container of
+    // type C.
+    template <typename C>
+    using EnableIfConvertibleFrom =
+        typename std::enable_if<span_internal::HasData<T, C>::value &&
+                                span_internal::HasSize<C>::value>::type;
+
+    // Used to SFINAE-enable a function when the slice elements are const.
+    template <typename U>
+    using EnableIfConstView =
+        typename std::enable_if<std::is_const<T>::value, U>::type;
+
+    // Used to SFINAE-enable a function when the slice elements are mutable.
+    template <typename U>
+    using EnableIfMutableView =
+        typename std::enable_if<!std::is_const<T>::value, U>::type;
+
+public:
+    using value_type = phmap::remove_cv_t<T>;
+    using pointer = T*;
+    using const_pointer = const T*;
+    using reference = T&;
+    using const_reference = const T&;
+    using iterator = pointer;
+    using const_iterator = const_pointer;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+
+    static const size_type npos = ~(size_type(0));
+
+    constexpr Span() noexcept : Span(nullptr, 0) {}
+    constexpr Span(pointer array, size_type length) noexcept
+        : ptr_(array), len_(length) {}
+
+    // Implicit conversion constructors
+    template <size_t N>
+    constexpr Span(T (&a)[N]) noexcept  // NOLINT(runtime/explicit)
+        : Span(a, N) {}
+
+    // Explicit reference constructor for a mutable `Span<T>` type. Can be
+    // replaced with MakeSpan() to infer the type parameter.
+    template <typename V, typename = EnableIfConvertibleFrom<V>,
+              typename = EnableIfMutableView<V>>
+        explicit Span(V& v) noexcept  // NOLINT(runtime/references)
+        : Span(span_internal::GetData(v), v.size()) {}
+
+    // Implicit reference constructor for a read-only `Span<const T>` type
+    template <typename V, typename = EnableIfConvertibleFrom<V>,
+              typename = EnableIfConstView<V>>
+        constexpr Span(const V& v) noexcept  // NOLINT(runtime/explicit)
+        : Span(span_internal::GetData(v), v.size()) {}
+
+    // Implicit constructor from an initializer list, making it possible to pass a
+    // brace-enclosed initializer list to a function expecting a `Span`. Such
+    // spans constructed from an initializer list must be of type `Span<const T>`.
+    //
+    //   void Process(phmap::Span<const int> x);
+    //   Process({1, 2, 3});
+    //
+    // Note that as always the array referenced by the span must outlive the span.
+    // Since an initializer list constructor acts as if it is fed a temporary
+    // array (cf. C++ standard [dcl.init.list]/5), it's safe to use this
+    // constructor only when the `std::initializer_list` itself outlives the span.
+    // In order to meet this requirement it's sufficient to ensure that neither
+    // the span nor a copy of it is used outside of the expression in which it's
+    // created:
+    //
+    //   // Assume that this function uses the array directly, not retaining any
+    //   // copy of the span or pointer to any of its elements.
+    //   void Process(phmap::Span<const int> ints);
+    //
+    //   // Okay: the std::initializer_list<int> will reference a temporary array
+    //   // that isn't destroyed until after the call to Process returns.
+    //   Process({ 17, 19 });
+    //
+    //   // Not okay: the storage used by the std::initializer_list<int> is not
+    //   // allowed to be referenced after the first line.
+    //   phmap::Span<const int> ints = { 17, 19 };
+    //   Process(ints);
+    //
+    //   // Not okay for the same reason as above: even when the elements of the
+    //   // initializer list expression are not temporaries the underlying array
+    //   // is, so the initializer list must still outlive the span.
+    //   const int foo = 17;
+    //   phmap::Span<const int> ints = { foo };
+    //   Process(ints);
+    //
+    template <typename LazyT = T,
+              typename = EnableIfConstView<LazyT>>
+        Span(
+            std::initializer_list<value_type> v) noexcept  // NOLINT(runtime/explicit)
+        : Span(v.begin(), v.size()) {}
+
+    // Accessors
+
+    // Span::data()
+    //
+    // Returns a pointer to the span's underlying array of data (which is held
+    // outside the span).
+    constexpr pointer data() const noexcept { return ptr_; }
+
+    // Span::size()
+    //
+    // Returns the size of this span.
+    constexpr size_type size() const noexcept { return len_; }
+
+    // Span::length()
+    //
+    // Returns the length (size) of this span.
+    constexpr size_type length() const noexcept { return size(); }
+
+    // Span::empty()
+    //
+    // Returns a boolean indicating whether or not this span is considered empty.
+    constexpr bool empty() const noexcept { return size() == 0; }
+
+    // Span::operator[]
+    //
+    // Returns a reference to the i'th element of this span.
+    constexpr reference operator[](size_type i) const noexcept {
+        // MSVC 2015 accepts this as constexpr, but not ptr_[i]
+        return *(data() + i);
+    }
+
+    // Span::at()
+    //
+    // Returns a reference to the i'th element of this span.
+    constexpr reference at(size_type i) const {
+        return PHMAP_PREDICT_TRUE(i < size())  //
+            ? *(data() + i)
+            : (base_internal::ThrowStdOutOfRange(
+                   "Span::at failed bounds check"),
+               *(data() + i));
+    }
+
+    // Span::front()
+    //
+    // Returns a reference to the first element of this span.
+    constexpr reference front() const noexcept {
+        return PHMAP_ASSERT(size() > 0), *data();
+    }
+
+    // Span::back()
+    //
+    // Returns a reference to the last element of this span.
+    constexpr reference back() const noexcept {
+        return PHMAP_ASSERT(size() > 0), *(data() + size() - 1);
+    }
+
+    // Span::begin()
+    //
+    // Returns an iterator to the first element of this span.
+    constexpr iterator begin() const noexcept { return data(); }
+
+    // Span::cbegin()
+    //
+    // Returns a const iterator to the first element of this span.
+    constexpr const_iterator cbegin() const noexcept { return begin(); }
+
+    // Span::end()
+    //
+    // Returns an iterator to the last element of this span.
+    constexpr iterator end() const noexcept { return data() + size(); }
+
+    // Span::cend()
+    //
+    // Returns a const iterator to the last element of this span.
+    constexpr const_iterator cend() const noexcept { return end(); }
+
+    // Span::rbegin()
+    //
+    // Returns a reverse iterator starting at the last element of this span.
+    constexpr reverse_iterator rbegin() const noexcept {
+        return reverse_iterator(end());
+    }
+
+    // Span::crbegin()
+    //
+    // Returns a reverse const iterator starting at the last element of this span.
+    constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); }
+
+    // Span::rend()
+    //
+    // Returns a reverse iterator starting at the first element of this span.
+    constexpr reverse_iterator rend() const noexcept {
+        return reverse_iterator(begin());
+    }
+
+    // Span::crend()
+    //
+    // Returns a reverse iterator starting at the first element of this span.
+    constexpr const_reverse_iterator crend() const noexcept { return rend(); }
+
+    // Span mutations
+
+    // Span::remove_prefix()
+    //
+    // Removes the first `n` elements from the span.
+    void remove_prefix(size_type n) noexcept {
+        assert(size() >= n);
+        ptr_ += n;
+        len_ -= n;
+    }
+
+    // Span::remove_suffix()
+    //
+    // Removes the last `n` elements from the span.
+    void remove_suffix(size_type n) noexcept {
+        assert(size() >= n);
+        len_ -= n;
+    }
+
+    // Span::subspan()
+    //
+    // Returns a `Span` starting at element `pos` and of length `len`. Both `pos`
+    // and `len` are of type `size_type` and thus non-negative. Parameter `pos`
+    // must be <= size(). Any `len` value that points past the end of the span
+    // will be trimmed to at most size() - `pos`. A default `len` value of `npos`
+    // ensures the returned subspan continues until the end of the span.
+    //
+    // Examples:
+    //
+    //   std::vector<int> vec = {10, 11, 12, 13};
+    //   phmap::MakeSpan(vec).subspan(1, 2);  // {11, 12}
+    //   phmap::MakeSpan(vec).subspan(2, 8);  // {12, 13}
+    //   phmap::MakeSpan(vec).subspan(1);     // {11, 12, 13}
+    //   phmap::MakeSpan(vec).subspan(4);     // {}
+    //   phmap::MakeSpan(vec).subspan(5);     // throws std::out_of_range
+    constexpr Span subspan(size_type pos = 0, size_type len = npos) const {
+        return (pos <= size())
+            ? Span(data() + pos, span_internal::Min(size() - pos, len))
+            : (base_internal::ThrowStdOutOfRange("pos > size()"), Span());
+    }
+
+    // Span::first()
+    //
+    // Returns a `Span` containing first `len` elements. Parameter `len` is of
+    // type `size_type` and thus non-negative. `len` value must be <= size().
+    //
+    // Examples:
+    //
+    //   std::vector<int> vec = {10, 11, 12, 13};
+    //   phmap::MakeSpan(vec).first(1);  // {10}
+    //   phmap::MakeSpan(vec).first(3);  // {10, 11, 12}
+    //   phmap::MakeSpan(vec).first(5);  // throws std::out_of_range
+    constexpr Span first(size_type len) const {
+        return (len <= size())
+            ? Span(data(), len)
+            : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
+    }
+
+    // Span::last()
+    //
+    // Returns a `Span` containing last `len` elements. Parameter `len` is of
+    // type `size_type` and thus non-negative. `len` value must be <= size().
+    //
+    // Examples:
+    //
+    //   std::vector<int> vec = {10, 11, 12, 13};
+    //   phmap::MakeSpan(vec).last(1);  // {13}
+    //   phmap::MakeSpan(vec).last(3);  // {11, 12, 13}
+    //   phmap::MakeSpan(vec).last(5);  // throws std::out_of_range
+    constexpr Span last(size_type len) const {
+        return (len <= size())
+            ? Span(size() - len + data(), len)
+            : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
+    }
+
+    // Support for phmap::Hash.
+    template <typename H>
+    friend H AbslHashValue(H h, Span v) {
+        return H::combine(H::combine_contiguous(std::move(h), v.data(), v.size()),
+                          v.size());
+    }
+
+private:
+    pointer ptr_;
+    size_type len_;
+};
+
+template <typename T>
+const typename Span<T>::size_type Span<T>::npos;
+
+// Span relationals
+
+// Equality is compared element-by-element, while ordering is lexicographical.
+// We provide three overloads for each operator to cover any combination on the
+// left or right hand side of mutable Span<T>, read-only Span<const T>, and
+// convertible-to-read-only Span<T>.
+// TODO(zhangxy): Due to MSVC overload resolution bug with partial ordering
+// template functions, 5 overloads per operator is needed as a workaround. We
+// should update them to 3 overloads per operator using non-deduced context like
+// string_view, i.e.
+// - (Span<T>, Span<T>)
+// - (Span<T>, non_deduced<Span<const T>>)
+// - (non_deduced<Span<const T>>, Span<T>)
+
+// operator==
+template <typename T>
+bool operator==(Span<T> a, Span<T> b) {
+  return span_internal::EqualImpl<const T>(a, b);
+}
+
+template <typename T>
+bool operator==(Span<const T> a, Span<T> b) {
+  return span_internal::EqualImpl<const T>(a, b);
+}
+
+template <typename T>
+bool operator==(Span<T> a, Span<const T> b) {
+  return span_internal::EqualImpl<const T>(a, b);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator==(const U& a, Span<T> b) {
+  return span_internal::EqualImpl<const T>(a, b);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator==(Span<T> a, const U& b) {
+  return span_internal::EqualImpl<const T>(a, b);
+}
+
+// operator!=
+template <typename T>
+bool operator!=(Span<T> a, Span<T> b) {
+  return !(a == b);
+}
+
+template <typename T>
+bool operator!=(Span<const T> a, Span<T> b) {
+  return !(a == b);
+}
+
+template <typename T>
+bool operator!=(Span<T> a, Span<const T> b) {
+  return !(a == b);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator!=(const U& a, Span<T> b) {
+  return !(a == b);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator!=(Span<T> a, const U& b) {
+  return !(a == b);
+}
+
+// operator<
+template <typename T>
+bool operator<(Span<T> a, Span<T> b) {
+  return span_internal::LessThanImpl<const T>(a, b);
+}
+
+template <typename T>
+bool operator<(Span<const T> a, Span<T> b) {
+  return span_internal::LessThanImpl<const T>(a, b);
+}
+
+template <typename T>
+bool operator<(Span<T> a, Span<const T> b) {
+  return span_internal::LessThanImpl<const T>(a, b);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator<(const U& a, Span<T> b) {
+  return span_internal::LessThanImpl<const T>(a, b);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator<(Span<T> a, const U& b) {
+  return span_internal::LessThanImpl<const T>(a, b);
+}
+
+// operator>
+template <typename T>
+bool operator>(Span<T> a, Span<T> b) {
+  return b < a;
+}
+
+template <typename T>
+bool operator>(Span<const T> a, Span<T> b) {
+  return b < a;
+}
+
+template <typename T>
+bool operator>(Span<T> a, Span<const T> b) {
+  return b < a;
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator>(const U& a, Span<T> b) {
+  return b < a;
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator>(Span<T> a, const U& b) {
+  return b < a;
+}
+
+// operator<=
+template <typename T>
+bool operator<=(Span<T> a, Span<T> b) {
+  return !(b < a);
+}
+
+template <typename T>
+bool operator<=(Span<const T> a, Span<T> b) {
+  return !(b < a);
+}
+
+template <typename T>
+bool operator<=(Span<T> a, Span<const T> b) {
+  return !(b < a);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator<=(const U& a, Span<T> b) {
+  return !(b < a);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator<=(Span<T> a, const U& b) {
+  return !(b < a);
+}
+
+// operator>=
+template <typename T>
+bool operator>=(Span<T> a, Span<T> b) {
+  return !(a < b);
+}
+
+template <typename T>
+bool operator>=(Span<const T> a, Span<T> b) {
+  return !(a < b);
+}
+
+template <typename T>
+bool operator>=(Span<T> a, Span<const T> b) {
+  return !(a < b);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator>=(const U& a, Span<T> b) {
+  return !(a < b);
+}
+
+template <typename T, typename U,
+          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator>=(Span<T> a, const U& b) {
+  return !(a < b);
+}
+
+// MakeSpan()
+//
+// Constructs a mutable `Span<T>`, deducing `T` automatically from either a
+// container or pointer+size.
+//
+// Because a read-only `Span<const T>` is implicitly constructed from container
+// types regardless of whether the container itself is a const container,
+// constructing mutable spans of type `Span<T>` from containers requires
+// explicit constructors. The container-accepting version of `MakeSpan()`
+// deduces the type of `T` by the constness of the pointer received from the
+// container's `data()` member. Similarly, the pointer-accepting version returns
+// a `Span<const T>` if `T` is `const`, and a `Span<T>` otherwise.
+//
+// Examples:
+//
+//   void MyRoutine(phmap::Span<MyComplicatedType> a) {
+//     ...
+//   };
+//   // my_vector is a container of non-const types
+//   std::vector<MyComplicatedType> my_vector;
+//
+//   // Constructing a Span implicitly attempts to create a Span of type
+//   // `Span<const T>`
+//   MyRoutine(my_vector);                // error, type mismatch
+//
+//   // Explicitly constructing the Span is verbose
+//   MyRoutine(phmap::Span<MyComplicatedType>(my_vector));
+//
+//   // Use MakeSpan() to make an phmap::Span<T>
+//   MyRoutine(phmap::MakeSpan(my_vector));
+//
+//   // Construct a span from an array ptr+size
+//   phmap::Span<T> my_span() {
+//     return phmap::MakeSpan(&array[0], num_elements_);
+//   }
+//
+template <int&... ExplicitArgumentBarrier, typename T>
+constexpr Span<T> MakeSpan(T* ptr, size_t size) noexcept {
+  return Span<T>(ptr, size);
+}
+
+template <int&... ExplicitArgumentBarrier, typename T>
+Span<T> MakeSpan(T* begin, T* end) noexcept {
+  return PHMAP_ASSERT(begin <= end), Span<T>(begin, end - begin);
+}
+
+template <int&... ExplicitArgumentBarrier, typename C>
+constexpr auto MakeSpan(C& c) noexcept  // NOLINT(runtime/references)
+    -> decltype(phmap::MakeSpan(span_internal::GetData(c), c.size())) {
+  return MakeSpan(span_internal::GetData(c), c.size());
+}
+
+template <int&... ExplicitArgumentBarrier, typename T, size_t N>
+constexpr Span<T> MakeSpan(T (&array)[N]) noexcept {
+  return Span<T>(array, N);
+}
+
+// MakeConstSpan()
+//
+// Constructs a `Span<const T>` as with `MakeSpan`, deducing `T` automatically,
+// but always returning a `Span<const T>`.
+//
+// Examples:
+//
+//   void ProcessInts(phmap::Span<const int> some_ints);
+//
+//   // Call with a pointer and size.
+//   int array[3] = { 0, 0, 0 };
+//   ProcessInts(phmap::MakeConstSpan(&array[0], 3));
+//
+//   // Call with a [begin, end) pair.
+//   ProcessInts(phmap::MakeConstSpan(&array[0], &array[3]));
+//
+//   // Call directly with an array.
+//   ProcessInts(phmap::MakeConstSpan(array));
+//
+//   // Call with a contiguous container.
+//   std::vector<int> some_ints = ...;
+//   ProcessInts(phmap::MakeConstSpan(some_ints));
+//   ProcessInts(phmap::MakeConstSpan(std::vector<int>{ 0, 0, 0 }));
+//
+template <int&... ExplicitArgumentBarrier, typename T>
+constexpr Span<const T> MakeConstSpan(T* ptr, size_t size) noexcept {
+  return Span<const T>(ptr, size);
+}
+
+template <int&... ExplicitArgumentBarrier, typename T>
+Span<const T> MakeConstSpan(T* begin, T* end) noexcept {
+  return PHMAP_ASSERT(begin <= end), Span<const T>(begin, end - begin);
+}
+
+template <int&... ExplicitArgumentBarrier, typename C>
+constexpr auto MakeConstSpan(const C& c) noexcept -> decltype(MakeSpan(c)) {
+  return MakeSpan(c);
+}
+
+template <int&... ExplicitArgumentBarrier, typename T, size_t N>
+constexpr Span<const T> MakeConstSpan(const T (&array)[N]) noexcept {
+  return Span<const T>(array, N);
+}
+}  // namespace phmap
+
+// ---------------------------------------------------------------------------
+//  layout.h
+// ---------------------------------------------------------------------------
+#if defined(__GXX_RTTI)
+    #define PHMAP_INTERNAL_HAS_CXA_DEMANGLE
+#endif
+
+#ifdef PHMAP_INTERNAL_HAS_CXA_DEMANGLE
+    #include <cxxabi.h>
+#endif
+
+namespace phmap {
+namespace priv {
+
+// A type wrapper that instructs `Layout` to use the specific alignment for the
+// array. `Layout<..., Aligned<T, N>, ...>` has exactly the same API
+// and behavior as `Layout<..., T, ...>` except that the first element of the
+// array of `T` is aligned to `N` (the rest of the elements follow without
+// padding).
+//
+// Requires: `N >= alignof(T)` and `N` is a power of 2.
+template <class T, size_t N>
+struct Aligned;
+
+namespace internal_layout {
+
+template <class T>
+struct NotAligned {};
+
+template <class T, size_t N>
+struct NotAligned<const Aligned<T, N>> {
+  static_assert(sizeof(T) == 0, "Aligned<T, N> cannot be const-qualified");
+};
+
+template <size_t>
+using IntToSize = size_t;
+
+template <class>
+using TypeToSize = size_t;
+
+template <class T>
+struct Type : NotAligned<T> {
+    using type = T;
+};
+
+template <class T, size_t N>
+struct Type<Aligned<T, N>> {
+    using type = T;
+};
+
+template <class T>
+struct SizeOf : NotAligned<T>, std::integral_constant<size_t, sizeof(T)> {};
+
+template <class T, size_t N>
+struct SizeOf<Aligned<T, N>> : std::integral_constant<size_t, sizeof(T)> {};
+
+// Note: workaround for https://gcc.gnu.org/PR88115
+template <class T>
+struct AlignOf : NotAligned<T> {
+    static constexpr size_t value = alignof(T);
+};
+
+template <class T, size_t N>
+struct AlignOf<Aligned<T, N>> {
+    static_assert(N % alignof(T) == 0,
+                  "Custom alignment can't be lower than the type's alignment");
+    static constexpr size_t value = N;
+};
+
+// Does `Ts...` contain `T`?
+template <class T, class... Ts>
+using Contains = phmap::disjunction<std::is_same<T, Ts>...>;
+
+template <class From, class To>
+using CopyConst =
+    typename std::conditional<std::is_const<From>::value, const To, To>::type;
+
+// Note: We're not qualifying this with phmap:: because it doesn't compile under
+// MSVC.
+template <class T>
+using SliceType = Span<T>;
+
+// This namespace contains no types. It prevents functions defined in it from
+// being found by ADL.
+namespace adl_barrier {
+
+template <class Needle, class... Ts>
+constexpr size_t Find(Needle, Needle, Ts...) {
+    static_assert(!Contains<Needle, Ts...>(), "Duplicate element type");
+    return 0;
+}
+
+template <class Needle, class T, class... Ts>
+constexpr size_t Find(Needle, T, Ts...) {
+  return adl_barrier::Find(Needle(), Ts()...) + 1;
+}
+
+constexpr bool IsPow2(size_t n) { return !(n & (n - 1)); }
+
+// Returns `q * m` for the smallest `q` such that `q * m >= n`.
+// Requires: `m` is a power of two. It's enforced by IsLegalElementType below.
+constexpr size_t Align(size_t n, size_t m) { return (n + m - 1) & ~(m - 1); }
+
+constexpr size_t Min(size_t a, size_t b) { return b < a ? b : a; }
+
+constexpr size_t Max(size_t a) { return a; }
+
+template <class... Ts>
+constexpr size_t Max(size_t a, size_t b, Ts... rest) {
+    return adl_barrier::Max(b < a ? a : b, rest...);
+}
+
+}  // namespace adl_barrier
+
+template <bool C>
+using EnableIf = typename std::enable_if<C, int>::type;
+
+// Can `T` be a template argument of `Layout`?
+// ---------------------------------------------------------------------------
+template <class T>
+using IsLegalElementType = std::integral_constant<
+    bool, !std::is_reference<T>::value && !std::is_volatile<T>::value &&
+              !std::is_reference<typename Type<T>::type>::value &&
+              !std::is_volatile<typename Type<T>::type>::value &&
+              adl_barrier::IsPow2(AlignOf<T>::value)>;
+
+template <class Elements, class SizeSeq, class OffsetSeq>
+class LayoutImpl;
+
+// ---------------------------------------------------------------------------
+// Public base class of `Layout` and the result type of `Layout::Partial()`.
+//
+// `Elements...` contains all template arguments of `Layout` that created this
+// instance.
+//
+// `SizeSeq...` is `[0, NumSizes)` where `NumSizes` is the number of arguments
+// passed to `Layout::Partial()` or `Layout::Layout()`.
+//
+// `OffsetSeq...` is `[0, NumOffsets)` where `NumOffsets` is
+// `Min(sizeof...(Elements), NumSizes + 1)` (the number of arrays for which we
+// can compute offsets).
+// ---------------------------------------------------------------------------
+template <class... Elements, size_t... SizeSeq, size_t... OffsetSeq>
+class LayoutImpl<std::tuple<Elements...>, phmap::index_sequence<SizeSeq...>,
+                 phmap::index_sequence<OffsetSeq...>> 
+{
+private:
+    static_assert(sizeof...(Elements) > 0, "At least one field is required");
+    static_assert(phmap::conjunction<IsLegalElementType<Elements>...>::value,
+                  "Invalid element type (see IsLegalElementType)");
+
+    enum {
+        NumTypes = sizeof...(Elements),
+        NumSizes = sizeof...(SizeSeq),
+        NumOffsets = sizeof...(OffsetSeq),
+    };
+
+    // These are guaranteed by `Layout`.
+    static_assert(NumOffsets == adl_barrier::Min(NumTypes, NumSizes + 1),
+                  "Internal error");
+    static_assert(NumTypes > 0, "Internal error");
+
+    // Returns the index of `T` in `Elements...`. Results in a compilation error
+    // if `Elements...` doesn't contain exactly one instance of `T`.
+    template <class T>
+        static constexpr size_t ElementIndex() {
+        static_assert(Contains<Type<T>, Type<typename Type<Elements>::type>...>(),
+                      "Type not found");
+        return adl_barrier::Find(Type<T>(),
+                                 Type<typename Type<Elements>::type>()...);
+    }
+
+    template <size_t N>
+        using ElementAlignment =
+        AlignOf<typename std::tuple_element<N, std::tuple<Elements...>>::type>;
+
+public:
+    // Element types of all arrays packed in a tuple.
+    using ElementTypes = std::tuple<typename Type<Elements>::type...>;
+
+    // Element type of the Nth array.
+    template <size_t N>
+        using ElementType = typename std::tuple_element<N, ElementTypes>::type;
+
+    constexpr explicit LayoutImpl(IntToSize<SizeSeq>... sizes)
+        : size_{sizes...} {}
+
+    // Alignment of the layout, equal to the strictest alignment of all elements.
+    // All pointers passed to the methods of layout must be aligned to this value.
+    static constexpr size_t Alignment() {
+        return adl_barrier::Max(AlignOf<Elements>::value...);
+    }
+
+    // Offset in bytes of the Nth array.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   assert(x.Offset<0>() == 0);   // The ints starts from 0.
+    //   assert(x.Offset<1>() == 16);  // The doubles starts from 16.
+    //
+    // Requires: `N <= NumSizes && N < sizeof...(Ts)`.
+    template <size_t N, EnableIf<N == 0> = 0>
+        constexpr size_t Offset() const {
+        return 0;
+    }
+
+    template <size_t N, EnableIf<N != 0> = 0>
+        constexpr size_t Offset() const {
+        static_assert(N < NumOffsets, "Index out of bounds");
+        return adl_barrier::Align(
+            Offset<N - 1>() + SizeOf<ElementType<N - 1>>() * size_[N - 1],
+            ElementAlignment<N>::value);
+    }
+
+    // Offset in bytes of the array with the specified element type. There must
+    // be exactly one such array and its zero-based index must be at most
+    // `NumSizes`.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   assert(x.Offset<int>() == 0);      // The ints starts from 0.
+    //   assert(x.Offset<double>() == 16);  // The doubles starts from 16.
+    template <class T>
+        constexpr size_t Offset() const {
+        return Offset<ElementIndex<T>()>();
+    }
+
+    // Offsets in bytes of all arrays for which the offsets are known.
+    constexpr std::array<size_t, NumOffsets> Offsets() const {
+        return {{Offset<OffsetSeq>()...}};
+    }
+
+    // The number of elements in the Nth array. This is the Nth argument of
+    // `Layout::Partial()` or `Layout::Layout()` (zero-based).
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   assert(x.Size<0>() == 3);
+    //   assert(x.Size<1>() == 4);
+    //
+    // Requires: `N < NumSizes`.
+    template <size_t N>
+        constexpr size_t Size() const {
+        static_assert(N < NumSizes, "Index out of bounds");
+        return size_[N];
+    }
+
+    // The number of elements in the array with the specified element type.
+    // There must be exactly one such array and its zero-based index must be
+    // at most `NumSizes`.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   assert(x.Size<int>() == 3);
+    //   assert(x.Size<double>() == 4);
+    template <class T>
+        constexpr size_t Size() const {
+        return Size<ElementIndex<T>()>();
+    }
+
+    // The number of elements of all arrays for which they are known.
+    constexpr std::array<size_t, NumSizes> Sizes() const {
+        return {{Size<SizeSeq>()...}};
+    }
+
+    // Pointer to the beginning of the Nth array.
+    //
+    // `Char` must be `[const] [signed|unsigned] char`.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   unsigned char* p = new unsigned char[x.AllocSize()];
+    //   int* ints = x.Pointer<0>(p);
+    //   double* doubles = x.Pointer<1>(p);
+    //
+    // Requires: `N <= NumSizes && N < sizeof...(Ts)`.
+    // Requires: `p` is aligned to `Alignment()`.
+    template <size_t N, class Char>
+        CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
+        using C = typename std::remove_const<Char>::type;
+        static_assert(
+            std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
+            std::is_same<C, signed char>(),
+            "The argument must be a pointer to [const] [signed|unsigned] char");
+        constexpr size_t alignment = Alignment();
+        (void)alignment;
+        assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
+        return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
+    }
+
+    // Pointer to the beginning of the array with the specified element type.
+    // There must be exactly one such array and its zero-based index must be at
+    // most `NumSizes`.
+    //
+    // `Char` must be `[const] [signed|unsigned] char`.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   unsigned char* p = new unsigned char[x.AllocSize()];
+    //   int* ints = x.Pointer<int>(p);
+    //   double* doubles = x.Pointer<double>(p);
+    //
+    // Requires: `p` is aligned to `Alignment()`.
+    template <class T, class Char>
+        CopyConst<Char, T>* Pointer(Char* p) const {
+        return Pointer<ElementIndex<T>()>(p);
+    }
+
+    // Pointers to all arrays for which pointers are known.
+    //
+    // `Char` must be `[const] [signed|unsigned] char`.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   unsigned char* p = new unsigned char[x.AllocSize()];
+    //
+    //   int* ints;
+    //   double* doubles;
+    //   std::tie(ints, doubles) = x.Pointers(p);
+    //
+    // Requires: `p` is aligned to `Alignment()`.
+    //
+    // Note: We're not using ElementType alias here because it does not compile
+    // under MSVC.
+    template <class Char>
+        std::tuple<CopyConst<
+                       Char, typename std::tuple_element<OffsetSeq, ElementTypes>::type>*...>
+        Pointers(Char* p) const {
+        return std::tuple<CopyConst<Char, ElementType<OffsetSeq>>*...>(
+            Pointer<OffsetSeq>(p)...);
+    }
+
+    // The Nth array.
+    //
+    // `Char` must be `[const] [signed|unsigned] char`.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   unsigned char* p = new unsigned char[x.AllocSize()];
+    //   Span<int> ints = x.Slice<0>(p);
+    //   Span<double> doubles = x.Slice<1>(p);
+    //
+    // Requires: `N < NumSizes`.
+    // Requires: `p` is aligned to `Alignment()`.
+    template <size_t N, class Char>
+        SliceType<CopyConst<Char, ElementType<N>>> Slice(Char* p) const {
+        return SliceType<CopyConst<Char, ElementType<N>>>(Pointer<N>(p), Size<N>());
+    }
+
+    // The array with the specified element type. There must be exactly one
+    // such array and its zero-based index must be less than `NumSizes`.
+    //
+    // `Char` must be `[const] [signed|unsigned] char`.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   unsigned char* p = new unsigned char[x.AllocSize()];
+    //   Span<int> ints = x.Slice<int>(p);
+    //   Span<double> doubles = x.Slice<double>(p);
+    //
+    // Requires: `p` is aligned to `Alignment()`.
+    template <class T, class Char>
+        SliceType<CopyConst<Char, T>> Slice(Char* p) const {
+        return Slice<ElementIndex<T>()>(p);
+    }
+
+    // All arrays with known sizes.
+    //
+    // `Char` must be `[const] [signed|unsigned] char`.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   unsigned char* p = new unsigned char[x.AllocSize()];
+    //
+    //   Span<int> ints;
+    //   Span<double> doubles;
+    //   std::tie(ints, doubles) = x.Slices(p);
+    //
+    // Requires: `p` is aligned to `Alignment()`.
+    //
+    // Note: We're not using ElementType alias here because it does not compile
+    // under MSVC.
+    template <class Char>
+        std::tuple<SliceType<CopyConst<
+                                 Char, typename std::tuple_element<SizeSeq, ElementTypes>::type>>...>
+        Slices(Char* p) const {
+        // Workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63875 (fixed
+        // in 6.1).
+        (void)p;
+        return std::tuple<SliceType<CopyConst<Char, ElementType<SizeSeq>>>...>(
+            Slice<SizeSeq>(p)...);
+    }
+
+    // The size of the allocation that fits all arrays.
+    //
+    //   // int[3], 4 bytes of padding, double[4].
+    //   Layout<int, double> x(3, 4);
+    //   unsigned char* p = new unsigned char[x.AllocSize()];  // 48 bytes
+    //
+    // Requires: `NumSizes == sizeof...(Ts)`.
+    constexpr size_t AllocSize() const {
+        static_assert(NumTypes == NumSizes, "You must specify sizes of all fields");
+        return Offset<NumTypes - 1>() +
+            SizeOf<ElementType<NumTypes - 1>>() * size_[NumTypes - 1];
+    }
+
+    // If built with --config=asan, poisons padding bytes (if any) in the
+    // allocation. The pointer must point to a memory block at least
+    // `AllocSize()` bytes in length.
+    //
+    // `Char` must be `[const] [signed|unsigned] char`.
+    //
+    // Requires: `p` is aligned to `Alignment()`.
+    template <class Char, size_t N = NumOffsets - 1, EnableIf<N == 0> = 0>
+        void PoisonPadding(const Char* p) const {
+        Pointer<0>(p);  // verify the requirements on `Char` and `p`
+    }
+
+    template <class Char, size_t N = NumOffsets - 1, EnableIf<N != 0> = 0>
+        void PoisonPadding(const Char* p) const {
+        static_assert(N < NumOffsets, "Index out of bounds");
+        (void)p;
+#ifdef ADDRESS_SANITIZER
+        PoisonPadding<Char, N - 1>(p);
+        // The `if` is an optimization. It doesn't affect the observable behaviour.
+        if (ElementAlignment<N - 1>::value % ElementAlignment<N>::value) {
+            size_t start =
+                Offset<N - 1>() + SizeOf<ElementType<N - 1>>() * size_[N - 1];
+            ASAN_POISON_MEMORY_REGION(p + start, Offset<N>() - start);
+        }
+#endif
+    }
+
+private:
+    // Arguments of `Layout::Partial()` or `Layout::Layout()`.
+    size_t size_[NumSizes > 0 ? NumSizes : 1];
+};
+
+template <size_t NumSizes, class... Ts>
+using LayoutType = LayoutImpl<
+    std::tuple<Ts...>, phmap::make_index_sequence<NumSizes>,
+    phmap::make_index_sequence<adl_barrier::Min(sizeof...(Ts), NumSizes + 1)>>;
+
+}  // namespace internal_layout
+
+// ---------------------------------------------------------------------------
+// Descriptor of arrays of various types and sizes laid out in memory one after
+// another. See the top of the file for documentation.
+//
+// Check out the public API of internal_layout::LayoutImpl above. The type is
+// internal to the library but its methods are public, and they are inherited
+// by `Layout`.
+// ---------------------------------------------------------------------------
+template <class... Ts>
+class Layout : public internal_layout::LayoutType<sizeof...(Ts), Ts...> 
+{
+public:
+    static_assert(sizeof...(Ts) > 0, "At least one field is required");
+    static_assert(
+        phmap::conjunction<internal_layout::IsLegalElementType<Ts>...>::value,
+        "Invalid element type (see IsLegalElementType)");
+
+    template <size_t NumSizes>
+    using PartialType = internal_layout::LayoutType<NumSizes, Ts...>;
+
+    template <class... Sizes>
+    static constexpr PartialType<sizeof...(Sizes)> Partial(Sizes&&... sizes) {
+        static_assert(sizeof...(Sizes) <= sizeof...(Ts), "");
+        return PartialType<sizeof...(Sizes)>(phmap::forward<Sizes>(sizes)...);
+    }
+
+    // Creates a layout with the sizes of all arrays specified. If you know
+    // only the sizes of the first N arrays (where N can be zero), you can use
+    // `Partial()` defined above. The constructor is essentially equivalent to
+    // calling `Partial()` and passing in all array sizes; the constructor is
+    // provided as a convenient abbreviation.
+    //
+    // Note: The sizes of the arrays must be specified in number of elements,
+    // not in bytes.
+    constexpr explicit Layout(internal_layout::TypeToSize<Ts>... sizes)
+        : internal_layout::LayoutType<sizeof...(Ts), Ts...>(sizes...) {}
+};
+
+}  // namespace priv
+}  // namespace phmap
+
+// ---------------------------------------------------------------------------
+//  compressed_tuple.h
+// ---------------------------------------------------------------------------
+
+#ifdef _MSC_VER
+    // We need to mark these classes with this declspec to ensure that
+    // CompressedTuple happens.
+    #define PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC __declspec(empty_bases)
+#else  // _MSC_VER
+    #define PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
+#endif  // _MSC_VER
+
+namespace phmap {
+namespace priv {
+
+template <typename... Ts>
+class CompressedTuple;
+
+namespace internal_compressed_tuple {
+
+template <typename D, size_t I>
+struct Elem;
+template <typename... B, size_t I>
+struct Elem<CompressedTuple<B...>, I>
+    : std::tuple_element<I, std::tuple<B...>> {};
+template <typename D, size_t I>
+using ElemT = typename Elem<D, I>::type;
+
+// ---------------------------------------------------------------------------
+// Use the __is_final intrinsic if available. Where it's not available, classes
+// declared with the 'final' specifier cannot be used as CompressedTuple
+// elements.
+// TODO(sbenza): Replace this with std::is_final in C++14.
+// ---------------------------------------------------------------------------
+template <typename T>
+constexpr bool IsFinal() {
+#if defined(__clang__) || defined(__GNUC__)
+    return __is_final(T);
+#else
+    return false;
+#endif
+}
+
+template <typename T>
+constexpr bool ShouldUseBase() {
+#ifdef __INTEL_COMPILER
+    // avoid crash in Intel compiler
+    // assertion failed at: "shared/cfe/edgcpfe/lower_init.c", line 7013
+    return false; 
+#else
+    return std::is_class<T>::value && std::is_empty<T>::value && !IsFinal<T>();
+#endif
+}
+
+// The storage class provides two specializations:
+//  - For empty classes, it stores T as a base class.
+//  - For everything else, it stores T as a member.
+// ------------------------------------------------
+template <typename D, size_t I, bool = ShouldUseBase<ElemT<D, I>>()>
+struct Storage 
+{
+    using T = ElemT<D, I>;
+    T value;
+    constexpr Storage() = default;
+    explicit constexpr Storage(T&& v) : value(phmap::forward<T>(v)) {}
+    constexpr const T& get() const& { return value; }
+    T& get() & { return value; }
+    constexpr const T&& get() const&& { return phmap::move(*this).value; }
+    T&& get() && { return std::move(*this).value; }
+};
+
+template <typename D, size_t I>
+struct PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<D, I, true>
+    : ElemT<D, I> 
+{
+    using T = internal_compressed_tuple::ElemT<D, I>;
+    constexpr Storage() = default;
+    explicit constexpr Storage(T&& v) : T(phmap::forward<T>(v)) {}
+    constexpr const T& get() const& { return *this; }
+    T& get() & { return *this; }
+    constexpr const T&& get() const&& { return phmap::move(*this); }
+    T&& get() && { return std::move(*this); }
+};
+
+template <typename D, typename I>
+struct PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl;
+
+template <typename... Ts, size_t... I>
+struct PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
+    CompressedTupleImpl<CompressedTuple<Ts...>, phmap::index_sequence<I...>>
+    // We use the dummy identity function through std::integral_constant to
+    // convince MSVC of accepting and expanding I in that context. Without it
+    // you would get:
+    //   error C3548: 'I': parameter pack cannot be used in this context
+    : Storage<CompressedTuple<Ts...>,
+              std::integral_constant<size_t, I>::value>... 
+{
+    constexpr CompressedTupleImpl() = default;
+    explicit constexpr CompressedTupleImpl(Ts&&... args)
+        : Storage<CompressedTuple<Ts...>, I>(phmap::forward<Ts>(args))... {}
+};
+
+}  // namespace internal_compressed_tuple
+
+// ---------------------------------------------------------------------------
+// Helper class to perform the Empty Base Class Optimization.
+// Ts can contain classes and non-classes, empty or not. For the ones that
+// are empty classes, we perform the CompressedTuple. If all types in Ts are
+// empty classes, then CompressedTuple<Ts...> is itself an empty class.
+//
+// To access the members, use member .get<N>() function.
+//
+// Eg:
+//   phmap::priv::CompressedTuple<int, T1, T2, T3> value(7, t1, t2,
+//                                                                    t3);
+//   assert(value.get<0>() == 7);
+//   T1& t1 = value.get<1>();
+//   const T2& t2 = value.get<2>();
+//   ...
+//
+// https://en.cppreference.com/w/cpp/language/ebo
+// ---------------------------------------------------------------------------
+template <typename... Ts>
+class PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple
+    : private internal_compressed_tuple::CompressedTupleImpl<
+          CompressedTuple<Ts...>, phmap::index_sequence_for<Ts...>> 
+{
+private:
+    template <int I>
+        using ElemT = internal_compressed_tuple::ElemT<CompressedTuple, I>;
+
+public:
+    constexpr CompressedTuple() = default;
+    explicit constexpr CompressedTuple(Ts... base)
+        : CompressedTuple::CompressedTupleImpl(phmap::forward<Ts>(base)...) {}
+
+    template <int I>
+        ElemT<I>& get() & {
+        return internal_compressed_tuple::Storage<CompressedTuple, I>::get();
+    }
+
+    template <int I>
+        constexpr const ElemT<I>& get() const& {
+        return internal_compressed_tuple::Storage<CompressedTuple, I>::get();
+    }
+
+    template <int I>
+        ElemT<I>&& get() && {
+        return std::move(*this)
+            .internal_compressed_tuple::template Storage<CompressedTuple, I>::get();
+    }
+
+    template <int I>
+        constexpr const ElemT<I>&& get() const&& {
+        return phmap::move(*this)
+            .internal_compressed_tuple::template Storage<CompressedTuple, I>::get();
+    }
+};
+
+// Explicit specialization for a zero-element tuple
+// (needed to avoid ambiguous overloads for the default constructor).
+// ---------------------------------------------------------------------------
+template <>
+class PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple<> {};
+
+}  // namespace priv
+}  // namespace phmap
+
+
+namespace phmap {
+namespace priv {
+
+#ifdef _MSC_VER
+    #pragma warning(push)  
+    // warning warning C4324: structure was padded due to alignment specifier
+    #pragma warning(disable : 4324)
+#endif
+
+
+// ----------------------------------------------------------------------------
+// Allocates at least n bytes aligned to the specified alignment.
+// Alignment must be a power of 2. It must be positive.
+//
+// Note that many allocators don't honor alignment requirements above certain
+// threshold (usually either alignof(std::max_align_t) or alignof(void*)).
+// Allocate() doesn't apply alignment corrections. If the underlying allocator
+// returns insufficiently alignment pointer, that's what you are going to get.
+// ----------------------------------------------------------------------------
+template <size_t Alignment, class Alloc>
+void* Allocate(Alloc* alloc, size_t n) {
+  static_assert(Alignment > 0, "");
+  assert(n && "n must be positive");
+  struct alignas(Alignment) M {};
+  using A = typename phmap::allocator_traits<Alloc>::template rebind_alloc<M>;
+  using AT = typename phmap::allocator_traits<Alloc>::template rebind_traits<M>;
+  A mem_alloc(*alloc);
+  void* p = AT::allocate(mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
+  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
+         "allocator does not respect alignment");
+  return p;
+}
+
+// ----------------------------------------------------------------------------
+// The pointer must have been previously obtained by calling
+// Allocate<Alignment>(alloc, n).
+// ----------------------------------------------------------------------------
+template <size_t Alignment, class Alloc>
+void Deallocate(Alloc* alloc, void* p, size_t n) {
+  static_assert(Alignment > 0, "");
+  assert(n && "n must be positive");
+  struct alignas(Alignment) M {};
+  using A = typename phmap::allocator_traits<Alloc>::template rebind_alloc<M>;
+  using AT = typename phmap::allocator_traits<Alloc>::template rebind_traits<M>;
+  A mem_alloc(*alloc);
+  AT::deallocate(mem_alloc, static_cast<M*>(p),
+                 (n + sizeof(M) - 1) / sizeof(M));
+}
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+// Helper functions for asan and msan.
+// ----------------------------------------------------------------------------
+inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
+#ifdef ADDRESS_SANITIZER
+    ASAN_POISON_MEMORY_REGION(m, s);
+#endif
+#ifdef MEMORY_SANITIZER
+    __msan_poison(m, s);
+#endif
+    (void)m;
+    (void)s;
+}
+
+inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s) {
+#ifdef ADDRESS_SANITIZER
+    ASAN_UNPOISON_MEMORY_REGION(m, s);
+#endif
+#ifdef MEMORY_SANITIZER
+    __msan_unpoison(m, s);
+#endif
+    (void)m;
+    (void)s;
+}
+
+template <typename T>
+inline void SanitizerPoisonObject(const T* object) {
+    SanitizerPoisonMemoryRegion(object, sizeof(T));
+}
+
+template <typename T>
+inline void SanitizerUnpoisonObject(const T* object) {
+    SanitizerUnpoisonMemoryRegion(object, sizeof(T));
+}
+
+}  // namespace priv
+}  // namespace phmap
+
+
+// ---------------------------------------------------------------------------
+//  thread_annotations.h
+// ---------------------------------------------------------------------------
+
+#if defined(__clang__)
+    #define PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(x)   __attribute__((x))
+#else
+    #define PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(x)   // no-op
+#endif
+
+#define PHMAP_GUARDED_BY(x) PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
+#define PHMAP_PT_GUARDED_BY(x) PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
+
+#define PHMAP_ACQUIRED_AFTER(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
+
+#define PHMAP_ACQUIRED_BEFORE(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
+
+#define PHMAP_EXCLUSIVE_LOCKS_REQUIRED(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
+
+#define PHMAP_SHARED_LOCKS_REQUIRED(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
+
+#define PHMAP_LOCKS_EXCLUDED(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
+
+#define PHMAP_LOCK_RETURNED(x) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
+
+#define PHMAP_LOCKABLE \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(lockable)
+
+#define PHMAP_SCOPED_LOCKABLE \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
+
+#define PHMAP_EXCLUSIVE_LOCK_FUNCTION(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
+
+#define PHMAP_SHARED_LOCK_FUNCTION(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
+
+#define PHMAP_UNLOCK_FUNCTION(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
+
+#define PHMAP_EXCLUSIVE_TRYLOCK_FUNCTION(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
+
+#define PHMAP_SHARED_TRYLOCK_FUNCTION(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
+
+#define PHMAP_ASSERT_EXCLUSIVE_LOCK(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(assert_exclusive_lock(__VA_ARGS__))
+
+#define PHMAP_ASSERT_SHARED_LOCK(...) \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_lock(__VA_ARGS__))
+
+#define PHMAP_NO_THREAD_SAFETY_ANALYSIS \
+  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
+
+//------------------------------------------------------------------------------
+// Tool-Supplied Annotations
+//------------------------------------------------------------------------------
+
+// TS_UNCHECKED should be placed around lock expressions that are not valid
+// C++ syntax, but which are present for documentation purposes.  These
+// annotations will be ignored by the analysis.
+#define PHMAP_TS_UNCHECKED(x) ""
+
+// TS_FIXME is used to mark lock expressions that are not valid C++ syntax.
+// It is used by automated tools to mark and disable invalid expressions.
+// The annotation should either be fixed, or changed to TS_UNCHECKED.
+#define PHMAP_TS_FIXME(x) ""
+
+// Like NO_THREAD_SAFETY_ANALYSIS, this turns off checking within the body of
+// a particular function.  However, this attribute is used to mark functions
+// that are incorrect and need to be fixed.  It is used by automated tools to
+// avoid breaking the build when the analysis is updated.
+// Code owners are expected to eventually fix the routine.
+#define PHMAP_NO_THREAD_SAFETY_ANALYSIS_FIXME  PHMAP_NO_THREAD_SAFETY_ANALYSIS
+
+// Similar to NO_THREAD_SAFETY_ANALYSIS_FIXME, this macro marks a GUARDED_BY
+// annotation that needs to be fixed, because it is producing thread safety
+// warning.  It disables the GUARDED_BY.
+#define PHMAP_GUARDED_BY_FIXME(x)
+
+// Disables warnings for a single read operation.  This can be used to avoid
+// warnings when it is known that the read is not actually involved in a race,
+// but the compiler cannot confirm that.
+#define PHMAP_TS_UNCHECKED_READ(x) thread_safety_analysis::ts_unchecked_read(x)
+
+
+namespace phmap {
+namespace thread_safety_analysis {
+
+// Takes a reference to a guarded data member, and returns an unguarded
+// reference.
+template <typename T>
+inline const T& ts_unchecked_read(const T& v) PHMAP_NO_THREAD_SAFETY_ANALYSIS {
+    return v;
+}
+
+template <typename T>
+inline T& ts_unchecked_read(T& v) PHMAP_NO_THREAD_SAFETY_ANALYSIS {
+    return v;
+}
+
+}  // namespace thread_safety_analysis
+
+namespace priv {
+
+namespace memory_internal {
+
+// ----------------------------------------------------------------------------
+// If Pair is a standard-layout type, OffsetOf<Pair>::kFirst and
+// OffsetOf<Pair>::kSecond are equivalent to offsetof(Pair, first) and
+// offsetof(Pair, second) respectively. Otherwise they are -1.
+//
+// The purpose of OffsetOf is to avoid calling offsetof() on non-standard-layout
+// type, which is non-portable.
+// ----------------------------------------------------------------------------
+template <class Pair, class = std::true_type>
+struct OffsetOf {
+    static constexpr size_t kFirst = (size_t)-1;
+  static constexpr size_t kSecond = (size_t)-1;
+};
+
+template <class Pair>
+struct OffsetOf<Pair, typename std::is_standard_layout<Pair>::type> 
+{
+    static constexpr size_t kFirst = offsetof(Pair, first);
+    static constexpr size_t kSecond = offsetof(Pair, second);
+};
+
+// ----------------------------------------------------------------------------
+template <class K, class V>
+struct IsLayoutCompatible 
+{
+private:
+    struct Pair {
+        K first;
+        V second;
+    };
+
+    // Is P layout-compatible with Pair?
+    template <class P>
+    static constexpr bool LayoutCompatible() {
+        return std::is_standard_layout<P>() && sizeof(P) == sizeof(Pair) &&
+            alignof(P) == alignof(Pair) &&
+            memory_internal::OffsetOf<P>::kFirst ==
+            memory_internal::OffsetOf<Pair>::kFirst &&
+            memory_internal::OffsetOf<P>::kSecond ==
+            memory_internal::OffsetOf<Pair>::kSecond;
+    }
+
+public:
+    // Whether pair<const K, V> and pair<K, V> are layout-compatible. If they are,
+    // then it is safe to store them in a union and read from either.
+    static constexpr bool value = std::is_standard_layout<K>() &&
+        std::is_standard_layout<Pair>() &&
+        memory_internal::OffsetOf<Pair>::kFirst == 0 &&
+        LayoutCompatible<std::pair<K, V>>() &&
+        LayoutCompatible<std::pair<const K, V>>();
+};
+
+}  // namespace memory_internal
+
+// ----------------------------------------------------------------------------
+// The internal storage type for key-value containers like flat_hash_map.
+//
+// It is convenient for the value_type of a flat_hash_map<K, V> to be
+// pair<const K, V>; the "const K" prevents accidental modification of the key
+// when dealing with the reference returned from find() and similar methods.
+// However, this creates other problems; we want to be able to emplace(K, V)
+// efficiently with move operations, and similarly be able to move a
+// pair<K, V> in insert().
+//
+// The solution is this union, which aliases the const and non-const versions
+// of the pair. This also allows flat_hash_map<const K, V> to work, even though
+// that has the same efficiency issues with move in emplace() and insert() -
+// but people do it anyway.
+//
+// If kMutableKeys is false, only the value member can be accessed.
+//
+// If kMutableKeys is true, key can be accessed through all slots while value
+// and mutable_value must be accessed only via INITIALIZED slots. Slots are
+// created and destroyed via mutable_value so that the key can be moved later.
+//
+// Accessing one of the union fields while the other is active is safe as
+// long as they are layout-compatible, which is guaranteed by the definition of
+// kMutableKeys. For C++11, the relevant section of the standard is
+// https://timsong-cpp.github.io/cppwp/n3337/class.mem#19 (9.2.19)
+// ----------------------------------------------------------------------------
+template <class K, class V>
+union map_slot_type 
+{
+    map_slot_type() {}
+    ~map_slot_type() = delete;
+    map_slot_type(const map_slot_type&) = delete;
+    map_slot_type& operator=(const map_slot_type&) = delete;
+
+    using value_type = std::pair<const K, V>;
+    using mutable_value_type = std::pair<K, V>;
+
+    value_type value;
+    mutable_value_type mutable_value;
+    K key;
+};
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+template <class K, class V>
+struct map_slot_policy 
+{
+    using slot_type = map_slot_type<K, V>;
+    using value_type = std::pair<const K, V>;
+    using mutable_value_type = std::pair<K, V>;
+
+private:
+    static void emplace(slot_type* slot) {
+        // The construction of union doesn't do anything at runtime but it allows us
+        // to access its members without violating aliasing rules.
+        new (slot) slot_type;
+    }
+    // If pair<const K, V> and pair<K, V> are layout-compatible, we can accept one
+    // or the other via slot_type. We are also free to access the key via
+    // slot_type::key in this case.
+    using kMutableKeys = memory_internal::IsLayoutCompatible<K, V>;
+
+public:
+    static value_type& element(slot_type* slot) { return slot->value; }
+    static const value_type& element(const slot_type* slot) {
+        return slot->value;
+    }
+
+    static const K& key(const slot_type* slot) {
+        return kMutableKeys::value ? slot->key : slot->value.first;
+    }
+
+    template <class Allocator, class... Args>
+    static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
+        emplace(slot);
+        if (kMutableKeys::value) {
+            phmap::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
+                                                         std::forward<Args>(args)...);
+        } else {
+            phmap::allocator_traits<Allocator>::construct(*alloc, &slot->value,
+                                                         std::forward<Args>(args)...);
+        }
+    }
+
+    // Construct this slot by moving from another slot.
+    template <class Allocator>
+    static void construct(Allocator* alloc, slot_type* slot, slot_type* other) {
+        emplace(slot);
+        if (kMutableKeys::value) {
+            phmap::allocator_traits<Allocator>::construct(
+                *alloc, &slot->mutable_value, std::move(other->mutable_value));
+        } else {
+            phmap::allocator_traits<Allocator>::construct(*alloc, &slot->value,
+                                                         std::move(other->value));
+        }
+    }
+
+    template <class Allocator>
+    static void destroy(Allocator* alloc, slot_type* slot) {
+        if (kMutableKeys::value) {
+            phmap::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
+        } else {
+            phmap::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
+        }
+    }
+
+    template <class Allocator>
+    static void transfer(Allocator* alloc, slot_type* new_slot,
+                         slot_type* old_slot) {
+        emplace(new_slot);
+        if (kMutableKeys::value) {
+            phmap::allocator_traits<Allocator>::construct(
+                *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
+        } else {
+            phmap::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
+                                                         std::move(old_slot->value));
+        }
+        destroy(alloc, old_slot);
+    }
+
+    template <class Allocator>
+    static void swap(Allocator* alloc, slot_type* a, slot_type* b) {
+        if (kMutableKeys::value) {
+            using std::swap;
+            swap(a->mutable_value, b->mutable_value);
+        } else {
+            value_type tmp = std::move(a->value);
+            phmap::allocator_traits<Allocator>::destroy(*alloc, &a->value);
+            phmap::allocator_traits<Allocator>::construct(*alloc, &a->value,
+                                                         std::move(b->value));
+            phmap::allocator_traits<Allocator>::destroy(*alloc, &b->value);
+            phmap::allocator_traits<Allocator>::construct(*alloc, &b->value,
+                                                         std::move(tmp));
+        }
+    }
+
+    template <class Allocator>
+    static void move(Allocator* alloc, slot_type* src, slot_type* dest) {
+        if (kMutableKeys::value) {
+            dest->mutable_value = std::move(src->mutable_value);
+        } else {
+            phmap::allocator_traits<Allocator>::destroy(*alloc, &dest->value);
+            phmap::allocator_traits<Allocator>::construct(*alloc, &dest->value,
+                                                          std::move(src->value));
+        }
+    }
+
+    template <class Allocator>
+    static void move(Allocator* alloc, slot_type* first, slot_type* last,
+                     slot_type* result) {
+        for (slot_type *src = first, *dest = result; src != last; ++src, ++dest)
+            move(alloc, src, dest);
+    }
+};
+
+}  // namespace priv
+}  // phmap
+
+
+namespace phmap {
+
+#ifdef BOOST_THREAD_LOCK_OPTIONS_HPP
+    using defer_lock_t  = boost::defer_lock_t;
+    using try_to_lock_t = boost::try_to_lock_t;
+    using adopt_lock_t  = boost::adopt_lock_t;
+#else
+    struct adopt_lock_t  { explicit adopt_lock_t() = default; };
+    struct defer_lock_t  { explicit defer_lock_t() = default; };
+    struct try_to_lock_t { explicit try_to_lock_t() = default; };
+#endif
+
+// -----------------------------------------------------------------------------
+// NullMutex
+// -----------------------------------------------------------------------------
+// A class that implements the Mutex interface, but does nothing. This is to be 
+// used as a default template parameters for classes who provide optional 
+// internal locking (like phmap::parallel_flat_hash_map).
+// -----------------------------------------------------------------------------
+class NullMutex {
+public:
+    NullMutex() {}
+    ~NullMutex() {}
+    void lock() {}
+    void unlock() {}
+    bool try_lock() { return true; }
+    void lock_shared() {}
+    void unlock_shared() {}
+    bool try_lock_shared() { return true; }
+};
+
+// ------------------------ lockable object used internally -------------------------
+template <class MutexType>
+class LockableBaseImpl 
+{
+public:
+    // ----------------------------------------------------
+    struct DoNothing
+    {
+        using mutex_type = MutexType;  
+        DoNothing() noexcept {}
+        explicit DoNothing(mutex_type& ) noexcept {}
+        explicit DoNothing(mutex_type& , mutex_type&) noexcept {}
+        DoNothing(mutex_type&, phmap::adopt_lock_t) noexcept {}
+        DoNothing(mutex_type&, phmap::defer_lock_t) noexcept {}
+        DoNothing(mutex_type&, phmap::try_to_lock_t) {}
+        template<class T> explicit DoNothing(T&&) {}
+        DoNothing& operator=(const DoNothing&) { return *this; }
+        DoNothing& operator=(DoNothing&&) { return *this; }
+        void swap(DoNothing &) {}
+        bool owns_lock() const noexcept { return true; }
+    };
+
+    // ----------------------------------------------------
+    class WriteLock
+    {
+    public:
+        using mutex_type = MutexType;
+
+        WriteLock() :  m_(nullptr), locked_(false)  {}
+
+        explicit WriteLock(mutex_type &m) : m_(&m) { 
+            m_->lock(); 
+            locked_ = true; 
+        }
+
+        WriteLock(mutex_type& m, adopt_lock_t) noexcept :
+            m_(&m), locked_(true) 
+        {}
+
+        WriteLock(mutex_type& m, defer_lock_t) noexcept :
+            m_(&m), locked_(false) 
+        {}
+
+        WriteLock(mutex_type& m, try_to_lock_t)  :
+            m_(&m), locked_(false) { 
+            m_->try_lock(); 
+        }
+
+        WriteLock(WriteLock &&o) :
+            m_(std::move(o.m_)), locked_(std::move(o.locked_)) {
+            o.locked_ = false;
+            o.m_      = nullptr;
+        }
+
+        WriteLock& operator=(WriteLock&& other) {
+            WriteLock temp(std::move(other));
+            swap(temp);
+            return *this;
+        }
+
+        ~WriteLock() {
+            if (locked_) 
+                m_->unlock(); 
+        }
+
+        void lock() { 
+            if (!locked_) { 
+                m_->lock(); 
+                locked_ = true; 
+            }
+        }
+
+        void unlock() { 
+            if (locked_) {
+                m_->unlock(); 
+                locked_ = false;
+            }
+        } 
+
+        bool try_lock() { 
+            if (locked_)
+                return true;
+            locked_ = m_->try_lock(); 
+            return locked_;
+        }
+        
+        bool owns_lock() const noexcept { return locked_; }
+
+        void swap(WriteLock &o) noexcept { 
+            std::swap(m_, o.m_);
+            std::swap(locked_, o.locked_);
+        }
+
+        mutex_type *mutex() const noexcept { return m_; }
+
+    private:
+        mutex_type *m_;
+        bool        locked_;
+    };
+
+    // ----------------------------------------------------
+    class ReadLock
+    {
+    public:
+        using mutex_type = MutexType;
+
+        ReadLock() :  m_(nullptr), locked_(false)  {}
+
+        explicit ReadLock(mutex_type &m) : m_(&m) { 
+            m_->lock_shared(); 
+            locked_ = true; 
+        }
+
+        ReadLock(mutex_type& m, adopt_lock_t) noexcept :
+            m_(&m), locked_(true) 
+        {}
+
+        ReadLock(mutex_type& m, defer_lock_t) noexcept :
+            m_(&m), locked_(false) 
+        {}
+
+        ReadLock(mutex_type& m, try_to_lock_t)  :
+            m_(&m), locked_(false) { 
+            m_->try_lock_shared(); 
+        }
+
+        ReadLock(ReadLock &&o) :
+            m_(std::move(o.m_)), locked_(std::move(o.locked_)) {
+            o.locked_ = false;
+            o.m_      = nullptr;
+        }
+
+        ReadLock& operator=(ReadLock&& other) {
+            ReadLock temp(std::move(other));
+            swap(temp);
+            return *this;
+        }
+
+        ~ReadLock() {
+            if (locked_) 
+                m_->unlock_shared(); 
+        }
+
+        void lock() { 
+            if (!locked_) { 
+                m_->lock_shared(); 
+                locked_ = true; 
+            }
+        }
+
+        void unlock() { 
+            if (locked_) {
+                m_->unlock_shared(); 
+                locked_ = false;
+            }
+        } 
+
+        bool try_lock() { 
+            if (locked_)
+                return true;
+            locked_ = m_->try_lock_shared(); 
+            return locked_;
+        }
+        
+        bool owns_lock() const noexcept { return locked_; }
+
+        void swap(ReadLock &o) noexcept { 
+            std::swap(m_, o.m_);
+            std::swap(locked_, o.locked_);
+        }
+
+        mutex_type *mutex() const noexcept { return m_; }
+
+    private:
+        mutex_type *m_;
+        bool        locked_;
+    };
+
+    // ----------------------------------------------------
+    class WriteLocks
+    {
+    public:
+        using mutex_type = MutexType;  
+
+        explicit WriteLocks(mutex_type& m1, mutex_type& m2) : 
+            _m1(m1), _m2(m2)
+        { 
+            std::lock(m1, m2); 
+        }
+
+        WriteLocks(adopt_lock_t, mutex_type& m1, mutex_type& m2) :
+            _m1(m1), _m2(m2)
+        { // adopt means we already own the mutexes
+        }
+
+        ~WriteLocks()
+        {
+            _m1.unlock();
+            _m2.unlock();
+        }
+
+        WriteLocks(WriteLocks const&) = delete;
+        WriteLocks& operator=(WriteLocks const&) = delete;
+    private:
+        mutex_type& _m1;
+        mutex_type& _m2;
+    };
+
+    // ----------------------------------------------------
+    class ReadLocks
+    {
+    public:
+        using mutex_type = MutexType;  
+
+        explicit ReadLocks(mutex_type& m1, mutex_type& m2) : 
+            _m1(m1), _m2(m2)
+        { 
+            _m1.lock_shared(); 
+            _m2.lock_shared(); 
+        }
+
+        ReadLocks(adopt_lock_t, mutex_type& m1, mutex_type& m2) :
+            _m1(m1), _m2(m2)
+        { // adopt means we already own the mutexes
+        }
+
+        ~ReadLocks()
+        {
+            _m1.unlock_shared();
+            _m2.unlock_shared();
+        }
+
+        ReadLocks(ReadLocks const&) = delete;
+        ReadLocks& operator=(ReadLocks const&) = delete;
+    private:
+        mutex_type& _m1;
+        mutex_type& _m2;
+    };
+};
+
+// ------------------------ holds a mutex ------------------------------------
+// Default implementation for Lockable, should work fine for std::mutex 
+// -----------------------------------
+// use as:
+//    using Lockable = phmap::LockableImpl<mutex_type>;
+//    Lockable m;
+//  
+//    Lockable::UpgradeLock read_lock(m); // take a upgradable lock
+//
+//    {
+//        Lockable::UpgradeToUnique unique_lock(read_lock);
+//        // now locked for write
+//    }
+//
+// ---------------------------------------------------------------------------
+//         Generic mutex support (always write locks)
+// --------------------------------------------------------------------------
+template <class Mtx_>
+class LockableImpl : public Mtx_
+{
+public:
+    using mutex_type      = Mtx_;
+    using Base            = LockableBaseImpl<Mtx_>;
+    using SharedLock      = typename Base::WriteLock;
+    using UpgradeLock     = typename Base::WriteLock;
+    using UniqueLock      = typename Base::WriteLock;
+    using SharedLocks     = typename Base::WriteLocks;
+    using UniqueLocks     = typename Base::WriteLocks;
+    using UpgradeToUnique = typename Base::DoNothing;        // we already have unique ownership
+};
+
+// ---------------------------------------------------------------------------
+//          Null mutex (no-op) - when we don't want internal synchronization
+// ---------------------------------------------------------------------------
+template <>
+class  LockableImpl<phmap::NullMutex>: public phmap::NullMutex
+{
+public:
+    using mutex_type      = phmap::NullMutex;
+    using Base            = LockableBaseImpl<phmap::NullMutex>;
+    using SharedLock      = typename Base::DoNothing; 
+    using UpgradeLock     = typename Base::DoNothing; 
+    using UniqueLock      = typename Base::DoNothing; 
+    using UpgradeToUnique = typename Base::DoNothing; 
+    using SharedLocks     = typename Base::DoNothing;
+    using UniqueLocks     = typename Base::DoNothing;
+};
+
+// --------------------------------------------------------------------------
+//         Abseil Mutex support (read and write lock support)
+// --------------------------------------------------------------------------
+#ifdef ABSL_SYNCHRONIZATION_MUTEX_H_
+    
+    struct AbslMutex : protected absl::Mutex
+    {
+        void lock()            { this->Lock(); }
+        void unlock()          { this->Unlock(); }
+        void try_lock()        { this->TryLock(); }
+        void lock_shared()     { this->ReaderLock(); }
+        void unlock_shared()   { this->ReaderUnlock(); }
+        void try_lock_shared() { this->ReaderTryLock(); }
+    };
+    
+    template <>
+    class  LockableImpl<absl::Mutex> : public AbslMutex
+    {
+    public:
+        using mutex_type      = phmap::AbslMutex;
+        using Base            = LockableBaseImpl<phmap::AbslMutex>;
+        using SharedLock      = typename Base::ReadLock;
+        using UpgradeLock     = typename Base::WriteLock;
+        using UniqueLock      = typename Base::WriteLock;
+        using SharedLocks     = typename Base::ReadLocks;
+        using UniqueLocks     = typename Base::WriteLocks;
+        using UpgradeToUnique = typename Base::DoNothing; // we already have unique ownership
+    };
+
+#endif
+
+// --------------------------------------------------------------------------
+//         Boost shared_mutex support (read and write lock support)
+// --------------------------------------------------------------------------
+#ifdef BOOST_THREAD_SHARED_MUTEX_HPP
+
+#if 1
+    // ---------------------------------------------------------------------------
+    template <>
+    class  LockableImpl<boost::shared_mutex> : public boost::shared_mutex
+    {
+    public:
+        using mutex_type      = boost::shared_mutex;
+        using Base            = LockableBaseImpl<boost::shared_mutex>;
+        using SharedLock      = boost::shared_lock<mutex_type>;
+        using UpgradeLock     = boost::unique_lock<mutex_type>; // assume can't upgrade
+        using UniqueLock      = boost::unique_lock<mutex_type>;
+        using SharedLocks     = typename Base::ReadLocks;
+        using UniqueLocks     = typename Base::WriteLocks;
+        using UpgradeToUnique = typename Base::DoNothing;  // we already have unique ownership
+    };
+#else
+    // ---------------------------------------------------------------------------
+    template <>
+    class  LockableImpl<boost::upgrade_mutex> : public boost::upgrade_mutex
+    {
+    public:
+        using mutex_type      = boost::upgrade_mutex;
+        using SharedLock      = boost::shared_lock<mutex_type>;
+        using UpgradeLock     = boost::upgrade_lock<mutex_type>;
+        using UniqueLock      = boost::unique_lock<mutex_type>;
+        using SharedLocks     = typename Base::ReadLocks;
+        using UniqueLocks     = typename Base::WriteLocks;
+        using UpgradeToUnique = boost::upgrade_to_unique_lock<mutex_type>;
+    };
+#endif
+
+// --------------------------------------------------------------------------
+//         std::shared_mutex support (read and write lock support)
+// --------------------------------------------------------------------------
+#ifdef PHMAP_HAVE_SHARED_MUTEX
+
+    // ---------------------------------------------------------------------------
+    template <>
+    class  LockableImpl<std::shared_mutex> : public std::shared_mutex
+    {
+    public:
+        using mutex_type      = std::shared_mutex;
+        using Base            = LockableBaseImpl<std::shared_mutex>;
+        using SharedLock      = std::shared_lock<mutex_type>;
+        using UpgradeLock     = std::unique_lock<mutex_type>; // assume can't upgrade
+        using UniqueLock      = std::unique_lock<mutex_type>;
+        using SharedLocks     = typename Base::ReadLocks;
+        using UniqueLocks     = typename Base::WriteLocks;
+        using UpgradeToUnique = typename Base::DoNothing;  // we already have unique ownership
+    };
+#endif
+
+#endif // PHMAP_HAS_BOOST_THREAD_MUTEXES
+
+
+}  // phmap
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+
+#endif // phmap_base_h_guard_
diff --git a/lib/parallel_hashmap/parallel_hashmap/phmap_bits.h b/lib/parallel_hashmap/parallel_hashmap/phmap_bits.h
new file mode 100644
index 0000000..6b765ff
--- /dev/null
+++ b/lib/parallel_hashmap/parallel_hashmap/phmap_bits.h
@@ -0,0 +1,663 @@
+#if !defined(phmap_bits_h_guard_)
+#define phmap_bits_h_guard_
+
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Includes work from abseil-cpp (https://github.com/abseil/abseil-cpp)
+// with modifications.
+// 
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ---------------------------------------------------------------------------
+
+// The following guarantees declaration of the byte swap functions
+#ifdef _MSC_VER
+    #include <stdlib.h>  // NOLINT(build/include)
+#elif defined(__APPLE__)
+    // Mac OS X / Darwin features
+    #include <libkern/OSByteOrder.h>
+#elif defined(__FreeBSD__)
+    #include <sys/endian.h>
+#elif defined(__GLIBC__)
+    #include <byteswap.h>  // IWYU pragma: export
+#endif
+
+#include <string.h>
+#include <cstdint>
+#include "phmap_config.h"
+
+#ifdef _MSC_VER
+    #pragma warning(push)  
+    #pragma warning(disable : 4514) // unreferenced inline function has been removed
+#endif
+
+// -----------------------------------------------------------------------------
+// unaligned APIs
+// -----------------------------------------------------------------------------
+// Portable handling of unaligned loads, stores, and copies.
+// On some platforms, like ARM, the copy functions can be more efficient
+// then a load and a store.
+// -----------------------------------------------------------------------------
+
+#if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER) ||\
+    defined(MEMORY_SANITIZER)
+#include <stdint.h>
+
+extern "C" {
+    uint16_t __sanitizer_unaligned_load16(const void *p);
+    uint32_t __sanitizer_unaligned_load32(const void *p);
+    uint64_t __sanitizer_unaligned_load64(const void *p);
+    void __sanitizer_unaligned_store16(void *p, uint16_t v);
+    void __sanitizer_unaligned_store32(void *p, uint32_t v);
+    void __sanitizer_unaligned_store64(void *p, uint64_t v);
+}  // extern "C"
+
+namespace phmap {
+namespace bits {
+
+inline uint16_t UnalignedLoad16(const void *p) {
+  return __sanitizer_unaligned_load16(p);
+}
+
+inline uint32_t UnalignedLoad32(const void *p) {
+  return __sanitizer_unaligned_load32(p);
+}
+
+inline uint64_t UnalignedLoad64(const void *p) {
+  return __sanitizer_unaligned_load64(p);
+}
+
+inline void UnalignedStore16(void *p, uint16_t v) {
+  __sanitizer_unaligned_store16(p, v);
+}
+
+inline void UnalignedStore32(void *p, uint32_t v) {
+  __sanitizer_unaligned_store32(p, v);
+}
+
+inline void UnalignedStore64(void *p, uint64_t v) {
+  __sanitizer_unaligned_store64(p, v);
+}
+
+}  // namespace bits
+}  // namespace phmap
+
+#define PHMAP_INTERNAL_UNALIGNED_LOAD16(_p) (phmap::bits::UnalignedLoad16(_p))
+#define PHMAP_INTERNAL_UNALIGNED_LOAD32(_p) (phmap::bits::UnalignedLoad32(_p))
+#define PHMAP_INTERNAL_UNALIGNED_LOAD64(_p) (phmap::bits::UnalignedLoad64(_p))
+
+#define PHMAP_INTERNAL_UNALIGNED_STORE16(_p, _val) (phmap::bits::UnalignedStore16(_p, _val))
+#define PHMAP_INTERNAL_UNALIGNED_STORE32(_p, _val) (phmap::bits::UnalignedStore32(_p, _val))
+#define PHMAP_INTERNAL_UNALIGNED_STORE64(_p, _val) (phmap::bits::UnalignedStore64(_p, _val))
+
+#else
+
+namespace phmap {
+namespace bits {
+
+inline uint16_t UnalignedLoad16(const void *p) {
+  uint16_t t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint32_t UnalignedLoad32(const void *p) {
+  uint32_t t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint64_t UnalignedLoad64(const void *p) {
+  uint64_t t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline void UnalignedStore16(void *p, uint16_t v) { memcpy(p, &v, sizeof v); }
+
+inline void UnalignedStore32(void *p, uint32_t v) { memcpy(p, &v, sizeof v); }
+
+inline void UnalignedStore64(void *p, uint64_t v) { memcpy(p, &v, sizeof v); }
+
+}  // namespace bits
+}  // namespace phmap
+
+#define PHMAP_INTERNAL_UNALIGNED_LOAD16(_p) (phmap::bits::UnalignedLoad16(_p))
+#define PHMAP_INTERNAL_UNALIGNED_LOAD32(_p) (phmap::bits::UnalignedLoad32(_p))
+#define PHMAP_INTERNAL_UNALIGNED_LOAD64(_p) (phmap::bits::UnalignedLoad64(_p))
+
+#define PHMAP_INTERNAL_UNALIGNED_STORE16(_p, _val) (phmap::bits::UnalignedStore16(_p, _val))
+#define PHMAP_INTERNAL_UNALIGNED_STORE32(_p, _val) (phmap::bits::UnalignedStore32(_p, _val))
+#define PHMAP_INTERNAL_UNALIGNED_STORE64(_p, _val) (phmap::bits::UnalignedStore64(_p, _val))
+
+#endif
+
+// -----------------------------------------------------------------------------
+// File: optimization.h
+// -----------------------------------------------------------------------------
+
+#if defined(__pnacl__)
+    #define PHMAP_BLOCK_TAIL_CALL_OPTIMIZATION() if (volatile int x = 0) { (void)x; }
+#elif defined(__clang__)
+    // Clang will not tail call given inline volatile assembly.
+    #define PHMAP_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
+#elif defined(__GNUC__)
+    // GCC will not tail call given inline volatile assembly.
+    #define PHMAP_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
+#elif defined(_MSC_VER)
+    #include <intrin.h>
+    // The __nop() intrinsic blocks the optimisation.
+    #define PHMAP_BLOCK_TAIL_CALL_OPTIMIZATION() __nop()
+#else
+    #define PHMAP_BLOCK_TAIL_CALL_OPTIMIZATION() if (volatile int x = 0) { (void)x; }
+#endif
+
+#if defined(__GNUC__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+
+#ifdef PHMAP_HAVE_INTRINSIC_INT128
+    __extension__ typedef unsigned __int128 phmap_uint128;
+    inline uint64_t umul128(uint64_t a, uint64_t b, uint64_t* high) 
+    {
+        auto result = static_cast<phmap_uint128>(a) * static_cast<phmap_uint128>(b);
+        *high = static_cast<uint64_t>(result >> 64);
+        return static_cast<uint64_t>(result);
+    }
+    #define PHMAP_HAS_UMUL128 1
+#elif (defined(_MSC_VER))
+    #if defined(_M_X64)
+        #pragma intrinsic(_umul128)
+        inline uint64_t umul128(uint64_t a, uint64_t b, uint64_t* high) 
+        {
+            return _umul128(a, b, high);
+        }
+        #define PHMAP_HAS_UMUL128 1
+    #endif
+#endif
+
+#if defined(__GNUC__)
+    #pragma GCC diagnostic pop
+#endif
+
+#if defined(__GNUC__)
+    // Cache line alignment
+    #if defined(__i386__) || defined(__x86_64__)
+        #define PHMAP_CACHELINE_SIZE 64
+    #elif defined(__powerpc64__)
+        #define PHMAP_CACHELINE_SIZE 128
+    #elif defined(__aarch64__)
+        // We would need to read special register ctr_el0 to find out L1 dcache size.
+        // This value is a good estimate based on a real aarch64 machine.
+        #define PHMAP_CACHELINE_SIZE 64
+    #elif defined(__arm__)
+        // Cache line sizes for ARM: These values are not strictly correct since
+        // cache line sizes depend on implementations, not architectures.  There
+        // are even implementations with cache line sizes configurable at boot
+        // time.
+        #if defined(__ARM_ARCH_5T__)
+            #define PHMAP_CACHELINE_SIZE 32
+        #elif defined(__ARM_ARCH_7A__)
+            #define PHMAP_CACHELINE_SIZE 64
+        #endif
+    #endif
+
+    #ifndef PHMAP_CACHELINE_SIZE
+        // A reasonable default guess.  Note that overestimates tend to waste more
+        // space, while underestimates tend to waste more time.
+        #define PHMAP_CACHELINE_SIZE 64
+    #endif
+
+    #define PHMAP_CACHELINE_ALIGNED __attribute__((aligned(PHMAP_CACHELINE_SIZE)))
+#elif defined(_MSC_VER)
+    #define PHMAP_CACHELINE_SIZE 64
+    #define PHMAP_CACHELINE_ALIGNED __declspec(align(PHMAP_CACHELINE_SIZE))
+#else
+    #define PHMAP_CACHELINE_SIZE 64
+    #define PHMAP_CACHELINE_ALIGNED
+#endif
+
+
+#if PHMAP_HAVE_BUILTIN(__builtin_expect) || \
+    (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_PREDICT_FALSE(x) (__builtin_expect(x, 0))
+    #define PHMAP_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
+#else
+    #define PHMAP_PREDICT_FALSE(x) (x)
+    #define PHMAP_PREDICT_TRUE(x) (x)
+#endif
+
+// -----------------------------------------------------------------------------
+// File: bits.h
+// -----------------------------------------------------------------------------
+
+#if defined(_MSC_VER)
+    // We can achieve something similar to attribute((always_inline)) with MSVC by
+    // using the __forceinline keyword, however this is not perfect. MSVC is
+    // much less aggressive about inlining, and even with the __forceinline keyword.
+    #define PHMAP_BASE_INTERNAL_FORCEINLINE __forceinline
+#else
+    // Use default attribute inline.
+    #define PHMAP_BASE_INTERNAL_FORCEINLINE inline PHMAP_ATTRIBUTE_ALWAYS_INLINE
+#endif
+
+
+namespace phmap {
+namespace base_internal {
+
+PHMAP_BASE_INTERNAL_FORCEINLINE int CountLeadingZeros64Slow(uint64_t n) {
+    int zeroes = 60;
+    if (n >> 32) zeroes -= 32, n >>= 32;
+    if (n >> 16) zeroes -= 16, n >>= 16;
+    if (n >> 8) zeroes -= 8, n >>= 8;
+    if (n >> 4) zeroes -= 4, n >>= 4;
+    return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[n] + zeroes;
+}
+
+PHMAP_BASE_INTERNAL_FORCEINLINE int CountLeadingZeros64(uint64_t n) {
+#if defined(_MSC_VER) && defined(_M_X64)
+    // MSVC does not have __buitin_clzll. Use _BitScanReverse64.
+    unsigned long result = 0;  // NOLINT(runtime/int)
+    if (_BitScanReverse64(&result, n)) {
+        return (int)(63 - result);
+    }
+    return 64;
+#elif defined(_MSC_VER) && !defined(__clang__)
+    // MSVC does not have __buitin_clzll. Compose two calls to _BitScanReverse
+    unsigned long result = 0;  // NOLINT(runtime/int)
+    if ((n >> 32) && _BitScanReverse(&result, (unsigned long)(n >> 32))) {
+        return 31 - result;
+    }
+    if (_BitScanReverse(&result, (unsigned long)n)) {
+        return 63 - result;
+    }
+    return 64;
+#elif defined(__GNUC__) || defined(__clang__)
+    // Use __builtin_clzll, which uses the following instructions:
+    //  x86: bsr
+    //  ARM64: clz
+    //  PPC: cntlzd
+    static_assert(sizeof(unsigned long long) == sizeof(n),  // NOLINT(runtime/int)
+                  "__builtin_clzll does not take 64-bit arg");
+
+    // Handle 0 as a special case because __builtin_clzll(0) is undefined.
+    if (n == 0) {
+        return 64;
+    }
+    return __builtin_clzll(n);
+#else
+    return CountLeadingZeros64Slow(n);
+#endif
+}
+
+PHMAP_BASE_INTERNAL_FORCEINLINE int CountLeadingZeros32Slow(uint64_t n) {
+    int zeroes = 28;
+    if (n >> 16) zeroes -= 16, n >>= 16;
+    if (n >> 8) zeroes -= 8, n >>= 8;
+    if (n >> 4) zeroes -= 4, n >>= 4;
+    return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[n] + zeroes;
+}
+
+PHMAP_BASE_INTERNAL_FORCEINLINE int CountLeadingZeros32(uint32_t n) {
+#if defined(_MSC_VER) && !defined(__clang__)
+    unsigned long result = 0;  // NOLINT(runtime/int)
+    if (_BitScanReverse(&result, n)) {
+        return (int)(31 - result);
+    }
+    return 32;
+#elif defined(__GNUC__) || defined(__clang__)
+    // Use __builtin_clz, which uses the following instructions:
+    //  x86: bsr
+    //  ARM64: clz
+    //  PPC: cntlzd
+    static_assert(sizeof(int) == sizeof(n),
+                  "__builtin_clz does not take 32-bit arg");
+
+    // Handle 0 as a special case because __builtin_clz(0) is undefined.
+    if (n == 0) {
+        return 32;
+    }
+    return __builtin_clz(n);
+#else
+    return CountLeadingZeros32Slow(n);
+#endif
+}
+
+PHMAP_BASE_INTERNAL_FORCEINLINE int CountTrailingZerosNonZero64Slow(uint64_t n) {
+    int c = 63;
+    n &= ~n + 1;
+    if (n & 0x00000000FFFFFFFF) c -= 32;
+    if (n & 0x0000FFFF0000FFFF) c -= 16;
+    if (n & 0x00FF00FF00FF00FF) c -= 8;
+    if (n & 0x0F0F0F0F0F0F0F0F) c -= 4;
+    if (n & 0x3333333333333333) c -= 2;
+    if (n & 0x5555555555555555) c -= 1;
+    return c;
+}
+
+PHMAP_BASE_INTERNAL_FORCEINLINE int CountTrailingZerosNonZero64(uint64_t n) {
+#if defined(_MSC_VER) && !defined(__clang__) && defined(_M_X64)
+    unsigned long result = 0;  // NOLINT(runtime/int)
+    _BitScanForward64(&result, n);
+    return (int)result;
+#elif defined(_MSC_VER) && !defined(__clang__)
+    unsigned long result = 0;  // NOLINT(runtime/int)
+    if (static_cast<uint32_t>(n) == 0) {
+        _BitScanForward(&result, (unsigned long)(n >> 32));
+        return result + 32;
+    }
+    _BitScanForward(&result, (unsigned long)n);
+    return result;
+#elif defined(__GNUC__) || defined(__clang__)
+    static_assert(sizeof(unsigned long long) == sizeof(n),  // NOLINT(runtime/int)
+                  "__builtin_ctzll does not take 64-bit arg");
+    return __builtin_ctzll(n);
+#else
+    return CountTrailingZerosNonZero64Slow(n);
+#endif
+}
+
+PHMAP_BASE_INTERNAL_FORCEINLINE int CountTrailingZerosNonZero32Slow(uint32_t n) {
+    int c = 31;
+    n &= ~n + 1;
+    if (n & 0x0000FFFF) c -= 16;
+    if (n & 0x00FF00FF) c -= 8;
+    if (n & 0x0F0F0F0F) c -= 4;
+    if (n & 0x33333333) c -= 2;
+    if (n & 0x55555555) c -= 1;
+    return c;
+}
+
+PHMAP_BASE_INTERNAL_FORCEINLINE int CountTrailingZerosNonZero32(uint32_t n) {
+#if defined(_MSC_VER) && !defined(__clang__)
+    unsigned long result = 0;  // NOLINT(runtime/int)
+    _BitScanForward(&result, n);
+    return (int)result;
+#elif defined(__GNUC__) || defined(__clang__)
+    static_assert(sizeof(int) == sizeof(n),
+                  "__builtin_ctz does not take 32-bit arg");
+    return __builtin_ctz(n);
+#else
+    return CountTrailingZerosNonZero32Slow(n);
+#endif
+}
+
+#undef PHMAP_BASE_INTERNAL_FORCEINLINE
+
+}  // namespace base_internal
+}  // namespace phmap
+
+// -----------------------------------------------------------------------------
+// File: endian.h
+// -----------------------------------------------------------------------------
+
+namespace phmap {
+
+// Use compiler byte-swapping intrinsics if they are available.  32-bit
+// and 64-bit versions are available in Clang and GCC as of GCC 4.3.0.
+// The 16-bit version is available in Clang and GCC only as of GCC 4.8.0.
+// For simplicity, we enable them all only for GCC 4.8.0 or later.
+#if defined(__clang__) || \
+    (defined(__GNUC__) && \
+     ((__GNUC__ == 4 && __GNUC_MINOR__ >= 8) || __GNUC__ >= 5))
+
+    inline uint64_t gbswap_64(uint64_t host_int) {
+        return __builtin_bswap64(host_int);
+    }
+    inline uint32_t gbswap_32(uint32_t host_int) {
+        return __builtin_bswap32(host_int);
+    }
+    inline uint16_t gbswap_16(uint16_t host_int) {
+        return __builtin_bswap16(host_int);
+    }
+
+#elif defined(_MSC_VER)
+
+    inline uint64_t gbswap_64(uint64_t host_int) {
+        return _byteswap_uint64(host_int);
+    }
+    inline uint32_t gbswap_32(uint32_t host_int) {
+        return _byteswap_ulong(host_int);
+    }
+    inline uint16_t gbswap_16(uint16_t host_int) {
+        return _byteswap_ushort(host_int);
+    }
+
+#elif defined(__APPLE__)
+
+    inline uint64_t gbswap_64(uint64_t host_int) { return OSSwapInt16(host_int); }
+    inline uint32_t gbswap_32(uint32_t host_int) { return OSSwapInt32(host_int); }
+    inline uint16_t gbswap_16(uint16_t host_int) { return OSSwapInt64(host_int); }
+
+#else
+
+    inline uint64_t gbswap_64(uint64_t host_int) {
+#if defined(__GNUC__) && defined(__x86_64__) && !defined(__APPLE__)
+        // Adapted from /usr/include/byteswap.h.  Not available on Mac.
+        if (__builtin_constant_p(host_int)) {
+            return __bswap_constant_64(host_int);
+        } else {
+            uint64_t result;
+            __asm__("bswap %0" : "=r"(result) : "0"(host_int));
+            return result;
+        }
+#elif defined(__GLIBC__)
+        return bswap_64(host_int);
+#else
+        return (((host_int & uint64_t{0xFF}) << 56) |
+                ((host_int & uint64_t{0xFF00}) << 40) |
+                ((host_int & uint64_t{0xFF0000}) << 24) |
+                ((host_int & uint64_t{0xFF000000}) << 8) |
+                ((host_int & uint64_t{0xFF00000000}) >> 8) |
+                ((host_int & uint64_t{0xFF0000000000}) >> 24) |
+                ((host_int & uint64_t{0xFF000000000000}) >> 40) |
+                ((host_int & uint64_t{0xFF00000000000000}) >> 56));
+#endif  // bswap_64
+    }
+
+    inline uint32_t gbswap_32(uint32_t host_int) {
+#if defined(__GLIBC__)
+        return bswap_32(host_int);
+#else
+        return (((host_int & uint32_t{0xFF}) << 24) |
+                ((host_int & uint32_t{0xFF00}) << 8) |
+                ((host_int & uint32_t{0xFF0000}) >> 8) |
+                ((host_int & uint32_t{0xFF000000}) >> 24));
+#endif
+    }
+
+    inline uint16_t gbswap_16(uint16_t host_int) {
+#if defined(__GLIBC__)
+        return bswap_16(host_int);
+#else
+        return (((host_int & uint16_t{0xFF}) << 8) |
+                ((host_int & uint16_t{0xFF00}) >> 8));
+#endif
+    }
+
+#endif  // intrinics available
+
+#ifdef PHMAP_IS_LITTLE_ENDIAN
+
+    // Definitions for ntohl etc. that don't require us to include
+    // netinet/in.h. We wrap gbswap_32 and gbswap_16 in functions rather
+    // than just #defining them because in debug mode, gcc doesn't
+    // correctly handle the (rather involved) definitions of bswap_32.
+    // gcc guarantees that inline functions are as fast as macros, so
+    // this isn't a performance hit.
+    inline uint16_t ghtons(uint16_t x) { return gbswap_16(x); }
+    inline uint32_t ghtonl(uint32_t x) { return gbswap_32(x); }
+    inline uint64_t ghtonll(uint64_t x) { return gbswap_64(x); }
+
+#elif defined PHMAP_IS_BIG_ENDIAN
+
+    // These definitions are simpler on big-endian machines
+    // These are functions instead of macros to avoid self-assignment warnings
+    // on calls such as "i = ghtnol(i);".  This also provides type checking.
+    inline uint16_t ghtons(uint16_t x) { return x; }
+    inline uint32_t ghtonl(uint32_t x) { return x; }
+    inline uint64_t ghtonll(uint64_t x) { return x; }
+
+#else
+    #error \
+        "Unsupported byte order: Either PHMAP_IS_BIG_ENDIAN or " \
+           "PHMAP_IS_LITTLE_ENDIAN must be defined"
+#endif  // byte order
+
+inline uint16_t gntohs(uint16_t x) { return ghtons(x); }
+inline uint32_t gntohl(uint32_t x) { return ghtonl(x); }
+inline uint64_t gntohll(uint64_t x) { return ghtonll(x); }
+
+// Utilities to convert numbers between the current hosts's native byte
+// order and little-endian byte order
+//
+// Load/Store methods are alignment safe
+namespace little_endian {
+// Conversion functions.
+#ifdef PHMAP_IS_LITTLE_ENDIAN
+
+    inline uint16_t FromHost16(uint16_t x) { return x; }
+    inline uint16_t ToHost16(uint16_t x) { return x; }
+
+    inline uint32_t FromHost32(uint32_t x) { return x; }
+    inline uint32_t ToHost32(uint32_t x) { return x; }
+
+    inline uint64_t FromHost64(uint64_t x) { return x; }
+    inline uint64_t ToHost64(uint64_t x) { return x; }
+
+    inline constexpr bool IsLittleEndian() { return true; }
+
+#elif defined PHMAP_IS_BIG_ENDIAN
+
+    inline uint16_t FromHost16(uint16_t x) { return gbswap_16(x); }
+    inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
+
+    inline uint32_t FromHost32(uint32_t x) { return gbswap_32(x); }
+    inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
+
+    inline uint64_t FromHost64(uint64_t x) { return gbswap_64(x); }
+    inline uint64_t ToHost64(uint64_t x) { return gbswap_64(x); }
+
+    inline constexpr bool IsLittleEndian() { return false; }
+
+#endif /* ENDIAN */
+
+// Functions to do unaligned loads and stores in little-endian order.
+inline uint16_t Load16(const void *p) {
+  return ToHost16(PHMAP_INTERNAL_UNALIGNED_LOAD16(p));
+}
+
+inline void Store16(void *p, uint16_t v) {
+  PHMAP_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
+}
+
+inline uint32_t Load32(const void *p) {
+  return ToHost32(PHMAP_INTERNAL_UNALIGNED_LOAD32(p));
+}
+
+inline void Store32(void *p, uint32_t v) {
+  PHMAP_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
+}
+
+inline uint64_t Load64(const void *p) {
+  return ToHost64(PHMAP_INTERNAL_UNALIGNED_LOAD64(p));
+}
+
+inline void Store64(void *p, uint64_t v) {
+  PHMAP_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
+}
+
+}  // namespace little_endian
+
+// Utilities to convert numbers between the current hosts's native byte
+// order and big-endian byte order (same as network byte order)
+//
+// Load/Store methods are alignment safe
+namespace big_endian {
+#ifdef PHMAP_IS_LITTLE_ENDIAN
+
+    inline uint16_t FromHost16(uint16_t x) { return gbswap_16(x); }
+    inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
+
+    inline uint32_t FromHost32(uint32_t x) { return gbswap_32(x); }
+    inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
+
+    inline uint64_t FromHost64(uint64_t x) { return gbswap_64(x); }
+    inline uint64_t ToHost64(uint64_t x) { return gbswap_64(x); }
+
+    inline constexpr bool IsLittleEndian() { return true; }
+
+#elif defined PHMAP_IS_BIG_ENDIAN
+
+    inline uint16_t FromHost16(uint16_t x) { return x; }
+    inline uint16_t ToHost16(uint16_t x) { return x; }
+
+    inline uint32_t FromHost32(uint32_t x) { return x; }
+    inline uint32_t ToHost32(uint32_t x) { return x; }
+
+    inline uint64_t FromHost64(uint64_t x) { return x; }
+    inline uint64_t ToHost64(uint64_t x) { return x; }
+
+    inline constexpr bool IsLittleEndian() { return false; }
+
+#endif /* ENDIAN */
+
+// Functions to do unaligned loads and stores in big-endian order.
+inline uint16_t Load16(const void *p) {
+  return ToHost16(PHMAP_INTERNAL_UNALIGNED_LOAD16(p));
+}
+
+inline void Store16(void *p, uint16_t v) {
+  PHMAP_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
+}
+
+inline uint32_t Load32(const void *p) {
+  return ToHost32(PHMAP_INTERNAL_UNALIGNED_LOAD32(p));
+}
+
+inline void Store32(void *p, uint32_t v) {
+  PHMAP_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
+}
+
+inline uint64_t Load64(const void *p) {
+  return ToHost64(PHMAP_INTERNAL_UNALIGNED_LOAD64(p));
+}
+
+inline void Store64(void *p, uint64_t v) {
+  PHMAP_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
+}
+
+}  // namespace big_endian
+
+}  // namespace phmap
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+#endif // phmap_bits_h_guard_
diff --git a/lib/parallel_hashmap/parallel_hashmap/phmap_config.h b/lib/parallel_hashmap/parallel_hashmap/phmap_config.h
new file mode 100644
index 0000000..42b0664
--- /dev/null
+++ b/lib/parallel_hashmap/parallel_hashmap/phmap_config.h
@@ -0,0 +1,764 @@
+#if !defined(phmap_config_h_guard_)
+#define phmap_config_h_guard_
+
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Includes work from abseil-cpp (https://github.com/abseil/abseil-cpp)
+// with modifications.
+// 
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ---------------------------------------------------------------------------
+
+#define PHMAP_VERSION_MAJOR 1
+#define PHMAP_VERSION_MINOR 0
+#define PHMAP_VERSION_PATCH 0
+
+// Included for the __GLIBC__ macro (or similar macros on other systems).
+#include <limits.h>
+
+#ifdef __cplusplus
+    // Included for __GLIBCXX__, _LIBCPP_VERSION
+    #include <cstddef>
+#endif  // __cplusplus
+
+#if defined(__APPLE__)
+    // Included for TARGET_OS_IPHONE, __IPHONE_OS_VERSION_MIN_REQUIRED,
+    // __IPHONE_8_0.
+    #include <Availability.h>
+    #include <TargetConditionals.h>
+#endif
+
+#define PHMAP_XSTR(x) PHMAP_STR(x)
+#define PHMAP_STR(x) #x
+#define PHMAP_VAR_NAME_VALUE(var) #var "="  PHMAP_STR(var)
+
+// -----------------------------------------------------------------------------
+// Some sanity checks
+// -----------------------------------------------------------------------------
+//#if defined(__CYGWIN__)
+//    #error "Cygwin is not supported."
+//#endif
+
+#if defined(_MSC_FULL_VER) && _MSC_FULL_VER < 190023918 && !defined(__clang__)
+    #error "phmap requires Visual Studio 2015 Update 2 or higher."
+#endif
+
+// We support gcc 4.7 and later.
+#if defined(__GNUC__) && !defined(__clang__)
+    #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7)
+        #error "phmap requires gcc 4.7 or higher."
+    #endif
+#endif
+
+// We support Apple Xcode clang 4.2.1 (version 421.11.65) and later.
+// This corresponds to Apple Xcode version 4.5.
+#if defined(__apple_build_version__) && __apple_build_version__ < 4211165
+    #error "phmap requires __apple_build_version__ of 4211165 or higher."
+#endif
+
+// Enforce C++11 as the minimum. 
+#if defined(__cplusplus) && !defined(_MSC_VER)
+    #if __cplusplus < 201103L
+        #error "C++ versions less than C++11 are not supported."
+    #endif
+#endif
+
+// We have chosen glibc 2.12 as the minimum 
+#if defined(__GLIBC__) && defined(__GLIBC_PREREQ)
+    #if !__GLIBC_PREREQ(2, 12)
+        #error "Minimum required version of glibc is 2.12."
+    #endif
+#endif
+
+#if defined(_STLPORT_VERSION)
+    #error "STLPort is not supported."
+#endif
+
+#if CHAR_BIT != 8
+    #error "phmap assumes CHAR_BIT == 8."
+#endif
+
+// phmap currently assumes that an int is 4 bytes. 
+#if INT_MAX < 2147483647
+    #error "phmap assumes that int is at least 4 bytes. "
+#endif
+
+
+
+// -----------------------------------------------------------------------------
+// Compiler Feature Checks
+// -----------------------------------------------------------------------------
+
+#ifdef __has_builtin
+    #define PHMAP_HAVE_BUILTIN(x) __has_builtin(x)
+#else
+    #define PHMAP_HAVE_BUILTIN(x) 0
+#endif
+
+#if (defined(_MSVC_LANG) && _MSVC_LANG >= 201703) || __cplusplus >= 201703
+    #define PHMAP_HAVE_CC17 1
+#else
+    #define PHMAP_HAVE_CC17 0
+#endif
+
+#define PHMAP_BRANCHLESS 1
+
+// ----------------------------------------------------------------
+// Checks whether `std::is_trivially_destructible<T>` is supported.
+// ----------------------------------------------------------------
+#ifdef PHMAP_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
+    #error PHMAP_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE cannot be directly set
+#elif defined(_LIBCPP_VERSION) ||                                        \
+    (!defined(__clang__) && defined(__GNUC__) && defined(__GLIBCXX__) && \
+     (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))) ||        \
+    defined(_MSC_VER)
+    #define PHMAP_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE 1
+#endif
+
+// --------------------------------------------------------------
+// Checks whether `std::is_trivially_default_constructible<T>` is 
+// supported.
+// --------------------------------------------------------------
+#if defined(PHMAP_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE)
+    #error PHMAP_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE cannot be directly set
+#elif defined(PHMAP_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE)
+    #error PHMAP_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE cannot directly set
+#elif (defined(__clang__) && defined(_LIBCPP_VERSION)) ||        \
+    (!defined(__clang__) && defined(__GNUC__) &&                 \
+     (__GNUC__ > 5 || (__GNUC__ == 5 && __GNUC_MINOR__ >= 1)) && \
+     (defined(_LIBCPP_VERSION) || defined(__GLIBCXX__))) ||      \
+    (defined(_MSC_VER) && !defined(__NVCC__))
+    #define PHMAP_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE 1
+    #define PHMAP_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE 1
+#endif
+
+// -------------------------------------------------------------------
+// Checks whether C++11's `thread_local` storage duration specifier is
+// supported.
+// -------------------------------------------------------------------
+#ifdef PHMAP_HAVE_THREAD_LOCAL
+    #error PHMAP_HAVE_THREAD_LOCAL cannot be directly set
+#elif defined(__APPLE__)
+    #if __has_feature(cxx_thread_local) && \
+        !(TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_9_0)
+        #define PHMAP_HAVE_THREAD_LOCAL 1
+    #endif
+#else  // !defined(__APPLE__)
+    #define PHMAP_HAVE_THREAD_LOCAL 1
+#endif
+
+#if defined(__ANDROID__) && defined(__clang__)
+
+    #if __has_include(<android/ndk-version.h>)
+        #include <android/ndk-version.h>
+    #endif  // __has_include(<android/ndk-version.h>)
+
+    #if defined(__ANDROID__) && defined(__clang__) && defined(__NDK_MAJOR__) && \
+        defined(__NDK_MINOR__) &&                                               \
+        ((__NDK_MAJOR__ < 12) || ((__NDK_MAJOR__ == 12) && (__NDK_MINOR__ < 1)))
+        #undef PHMAP_HAVE_TLS
+        #undef PHMAP_HAVE_THREAD_LOCAL
+    #endif
+#endif 
+
+// ------------------------------------------------------------
+// Checks whether the __int128 compiler extension for a 128-bit 
+// integral type is supported.
+// ------------------------------------------------------------
+#ifdef PHMAP_HAVE_INTRINSIC_INT128
+    #error PHMAP_HAVE_INTRINSIC_INT128 cannot be directly set
+#elif defined(__SIZEOF_INT128__)
+    #if (defined(__clang__) && !defined(_WIN32) && !defined(__aarch64__)) || \
+        (defined(__CUDACC__) && __CUDACC_VER_MAJOR__ >= 9) ||                \
+        (defined(__GNUC__) && !defined(__clang__) && !defined(__CUDACC__))
+        #define PHMAP_HAVE_INTRINSIC_INT128 1
+    #elif defined(__CUDACC__)
+        #if __CUDACC_VER__ >= 70000
+            #define PHMAP_HAVE_INTRINSIC_INT128 1
+        #endif  // __CUDACC_VER__ >= 70000
+    #endif  // defined(__CUDACC__)
+#endif
+
+// ------------------------------------------------------------------
+// Checks whether the compiler both supports and enables exceptions. 
+// ------------------------------------------------------------------
+#ifdef PHMAP_HAVE_EXCEPTIONS
+    #error PHMAP_HAVE_EXCEPTIONS cannot be directly set.
+#elif defined(__clang__)
+    #if defined(__EXCEPTIONS) && __has_feature(cxx_exceptions)
+        #define PHMAP_HAVE_EXCEPTIONS 1
+    #endif  // defined(__EXCEPTIONS) && __has_feature(cxx_exceptions)
+#elif !(defined(__GNUC__) && (__GNUC__ < 5) && !defined(__EXCEPTIONS)) &&    \
+    !(defined(__GNUC__) && (__GNUC__ >= 5) && !defined(__cpp_exceptions)) && \
+    !(defined(_MSC_VER) && !defined(_CPPUNWIND))
+    #define PHMAP_HAVE_EXCEPTIONS 1
+#endif
+
+
+// -----------------------------------------------------------------------
+// Checks whether the platform has an mmap(2) implementation as defined in
+// POSIX.1-2001.
+// -----------------------------------------------------------------------
+#ifdef PHMAP_HAVE_MMAP
+    #error PHMAP_HAVE_MMAP cannot be directly set
+#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) ||   \
+    defined(__ros__) || defined(__native_client__) || defined(__asmjs__) || \
+    defined(__wasm__) || defined(__Fuchsia__) || defined(__sun) || \
+    defined(__ASYLO__)
+    #define PHMAP_HAVE_MMAP 1
+#endif
+
+// -----------------------------------------------------------------------
+// Checks the endianness of the platform.
+// -----------------------------------------------------------------------
+#if defined(PHMAP_IS_BIG_ENDIAN)
+    #error "PHMAP_IS_BIG_ENDIAN cannot be directly set."
+#endif
+
+#if defined(PHMAP_IS_LITTLE_ENDIAN)
+    #error "PHMAP_IS_LITTLE_ENDIAN cannot be directly set."
+#endif
+
+#if (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \
+     __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+    #define PHMAP_IS_LITTLE_ENDIAN 1
+#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
+    __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+    #define PHMAP_IS_BIG_ENDIAN 1
+#elif defined(_WIN32)
+    #define PHMAP_IS_LITTLE_ENDIAN 1
+#else
+    #error "phmap endian detection needs to be set up for your compiler"
+#endif
+
+#if defined(__APPLE__) && defined(_LIBCPP_VERSION) && \
+    defined(__MAC_OS_X_VERSION_MIN_REQUIRED__) &&     \
+    __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101400
+    #define PHMAP_INTERNAL_MACOS_CXX17_TYPES_UNAVAILABLE 1
+#else
+    #define PHMAP_INTERNAL_MACOS_CXX17_TYPES_UNAVAILABLE 0
+#endif
+
+// ---------------------------------------------------------------------------
+// Checks whether C++17 std::any is available by checking whether <any> exists.
+// ---------------------------------------------------------------------------
+#ifdef PHMAP_HAVE_STD_ANY
+    #error "PHMAP_HAVE_STD_ANY cannot be directly set."
+#endif
+
+#ifdef __has_include
+    #if __has_include(<any>) && __cplusplus >= 201703L && \
+        !PHMAP_INTERNAL_MACOS_CXX17_TYPES_UNAVAILABLE
+        #define PHMAP_HAVE_STD_ANY 1
+    #endif
+#endif
+
+#ifdef PHMAP_HAVE_STD_OPTIONAL
+    #error "PHMAP_HAVE_STD_OPTIONAL cannot be directly set."
+#endif
+
+#ifdef __has_include
+    #if __has_include(<optional>) && __cplusplus >= 201703L && \
+        !PHMAP_INTERNAL_MACOS_CXX17_TYPES_UNAVAILABLE
+        #define PHMAP_HAVE_STD_OPTIONAL 1
+    #endif
+#endif
+
+#ifdef PHMAP_HAVE_STD_VARIANT
+    #error "PHMAP_HAVE_STD_VARIANT cannot be directly set."
+#endif
+
+#ifdef __has_include
+    #if __has_include(<variant>) && __cplusplus >= 201703L && \
+        !PHMAP_INTERNAL_MACOS_CXX17_TYPES_UNAVAILABLE
+        #define PHMAP_HAVE_STD_VARIANT 1
+    #endif
+#endif
+
+#ifdef PHMAP_HAVE_STD_STRING_VIEW
+    #error "PHMAP_HAVE_STD_STRING_VIEW cannot be directly set."
+#endif
+
+#ifdef __has_include
+    #if __has_include(<string_view>) && __cplusplus >= 201703L && \
+        (!defined(_MSC_VER) || _MSC_VER >= 1920) // vs2019
+        #define PHMAP_HAVE_STD_STRING_VIEW 1
+    #endif
+#endif
+
+// #pragma message(PHMAP_VAR_NAME_VALUE(_MSVC_LANG))
+
+#if defined(_MSC_VER) && _MSC_VER >= 1910 && PHMAP_HAVE_CC17
+    // #define PHMAP_HAVE_STD_ANY 1
+    #define PHMAP_HAVE_STD_OPTIONAL 1
+    #define PHMAP_HAVE_STD_VARIANT 1
+    #if !defined(PHMAP_HAVE_STD_STRING_VIEW) && _MSC_VER >= 1920
+        #define PHMAP_HAVE_STD_STRING_VIEW 1
+    #endif
+#endif
+
+#if PHMAP_HAVE_CC17
+    #define PHMAP_HAVE_SHARED_MUTEX 1
+#endif
+
+#ifndef PHMAP_HAVE_STD_STRING_VIEW
+    #define PHMAP_HAVE_STD_STRING_VIEW 0
+#endif
+
+// In debug mode, MSVC 2017's std::variant throws a EXCEPTION_ACCESS_VIOLATION
+// SEH exception from emplace for variant<SomeStruct> when constructing the
+// struct can throw. This defeats some of variant_test and
+// variant_exception_safety_test.
+#if defined(_MSC_VER) && _MSC_VER >= 1700 && defined(_DEBUG)
+    #define PHMAP_INTERNAL_MSVC_2017_DBG_MODE
+#endif
+
+
+// -----------------------------------------------------------------------------
+// Sanitizer Attributes
+// -----------------------------------------------------------------------------
+//
+// Sanitizer-related attributes are not "defined" in this file (and indeed
+// are not defined as such in any file). To utilize the following
+// sanitizer-related attributes within your builds, define the following macros
+// within your build using a `-D` flag, along with the given value for
+// `-fsanitize`:
+//
+//   * `ADDRESS_SANITIZER` + `-fsanitize=address` (Clang, GCC 4.8)
+//   * `MEMORY_SANITIZER` + `-fsanitize=memory` (Clang-only)
+//   * `THREAD_SANITIZER + `-fsanitize=thread` (Clang, GCC 4.8+)
+//   * `UNDEFINED_BEHAVIOR_SANITIZER` + `-fsanitize=undefined` (Clang, GCC 4.9+)
+//   * `CONTROL_FLOW_INTEGRITY` + -fsanitize=cfi (Clang-only)
+// -----------------------------------------------------------------------------
+
+// -----------------------------------------------------------------------------
+// A function-like feature checking macro that is a wrapper around
+// `__has_attribute`, which is defined by GCC 5+ and Clang and evaluates to a
+// nonzero constant integer if the attribute is supported or 0 if not.
+//
+// It evaluates to zero if `__has_attribute` is not defined by the compiler.
+// -----------------------------------------------------------------------------
+#ifdef __has_attribute
+    #define PHMAP_HAVE_ATTRIBUTE(x) __has_attribute(x)
+#else
+    #define PHMAP_HAVE_ATTRIBUTE(x) 0
+#endif
+
+// -----------------------------------------------------------------------------
+// A function-like feature checking macro that accepts C++11 style attributes.
+// It's a wrapper around `__has_cpp_attribute`, defined by ISO C++ SD-6
+// (https://en.cppreference.com/w/cpp/experimental/feature_test). If we don't
+// find `__has_cpp_attribute`, will evaluate to 0.
+// -----------------------------------------------------------------------------
+#if defined(__cplusplus) && defined(__has_cpp_attribute)
+    #define PHMAP_HAVE_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#else
+    #define PHMAP_HAVE_CPP_ATTRIBUTE(x) 0
+#endif
+
+// -----------------------------------------------------------------------------
+// Function Attributes
+// -----------------------------------------------------------------------------
+#if PHMAP_HAVE_ATTRIBUTE(format) || (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_PRINTF_ATTRIBUTE(string_index, first_to_check) \
+      __attribute__((__format__(__printf__, string_index, first_to_check)))
+    #define PHMAP_SCANF_ATTRIBUTE(string_index, first_to_check) \
+      __attribute__((__format__(__scanf__, string_index, first_to_check)))
+#else
+    #define PHMAP_PRINTF_ATTRIBUTE(string_index, first_to_check)
+    #define PHMAP_SCANF_ATTRIBUTE(string_index, first_to_check)
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(always_inline) || \
+    (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
+    #define PHMAP_HAVE_ATTRIBUTE_ALWAYS_INLINE 1
+#else
+    #define PHMAP_ATTRIBUTE_ALWAYS_INLINE
+#endif
+
+#if !defined(__INTEL_COMPILER) && (PHMAP_HAVE_ATTRIBUTE(noinline) || (defined(__GNUC__) && !defined(__clang__)))
+    #define PHMAP_ATTRIBUTE_NOINLINE __attribute__((noinline))
+    #define PHMAP_HAVE_ATTRIBUTE_NOINLINE 1
+#else
+    #define PHMAP_ATTRIBUTE_NOINLINE
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(disable_tail_calls)
+    #define PHMAP_HAVE_ATTRIBUTE_NO_TAIL_CALL 1
+    #define PHMAP_ATTRIBUTE_NO_TAIL_CALL __attribute__((disable_tail_calls))
+#elif defined(__GNUC__) && !defined(__clang__)
+    #define PHMAP_HAVE_ATTRIBUTE_NO_TAIL_CALL 1
+    #define PHMAP_ATTRIBUTE_NO_TAIL_CALL \
+      __attribute__((optimize("no-optimize-sibling-calls")))
+#else
+    #define PHMAP_ATTRIBUTE_NO_TAIL_CALL
+    #define PHMAP_HAVE_ATTRIBUTE_NO_TAIL_CALL 0
+#endif
+
+#if (PHMAP_HAVE_ATTRIBUTE(weak) || \
+     (defined(__GNUC__) && !defined(__clang__))) && \
+    !(defined(__llvm__) && defined(_WIN32))
+    #undef PHMAP_ATTRIBUTE_WEAK
+    #define PHMAP_ATTRIBUTE_WEAK __attribute__((weak))
+    #define PHMAP_HAVE_ATTRIBUTE_WEAK 1
+#else
+    #define PHMAP_ATTRIBUTE_WEAK
+    #define PHMAP_HAVE_ATTRIBUTE_WEAK 0
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(nonnull) || (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_NONNULL(arg_index) __attribute__((nonnull(arg_index)))
+#else
+    #define PHMAP_ATTRIBUTE_NONNULL(...)
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(noreturn) || (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_NORETURN __attribute__((noreturn))
+#elif defined(_MSC_VER)
+    #define PHMAP_ATTRIBUTE_NORETURN __declspec(noreturn)
+#else
+    #define PHMAP_ATTRIBUTE_NORETURN
+#endif
+
+#if defined(__GNUC__) && defined(ADDRESS_SANITIZER)
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address))
+#else
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_ADDRESS
+#endif
+
+#if defined(__GNUC__) && defined(MEMORY_SANITIZER)
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_MEMORY __attribute__((no_sanitize_memory))
+#else
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_MEMORY
+#endif
+
+#if defined(__GNUC__) && defined(THREAD_SANITIZER)
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_THREAD __attribute__((no_sanitize_thread))
+#else
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_THREAD
+#endif
+
+#if defined(__GNUC__) && \
+    (defined(UNDEFINED_BEHAVIOR_SANITIZER) || defined(ADDRESS_SANITIZER))
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_UNDEFINED \
+      __attribute__((no_sanitize("undefined")))
+#else
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_UNDEFINED
+#endif
+
+#if defined(__GNUC__) && defined(CONTROL_FLOW_INTEGRITY)
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_CFI __attribute__((no_sanitize("cfi")))
+#else
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_CFI
+#endif
+
+#if defined(__GNUC__) && defined(SAFESTACK_SANITIZER)
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_SAFESTACK \
+      __attribute__((no_sanitize("safe-stack")))
+#else
+    #define PHMAP_ATTRIBUTE_NO_SANITIZE_SAFESTACK
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(returns_nonnull) || \
+    (defined(__GNUC__) && \
+     (__GNUC__ > 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9)) && \
+     !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
+#else
+    #define PHMAP_ATTRIBUTE_RETURNS_NONNULL
+#endif
+
+#ifdef PHMAP_HAVE_ATTRIBUTE_SECTION
+    #error PHMAP_HAVE_ATTRIBUTE_SECTION cannot be directly set
+#elif (PHMAP_HAVE_ATTRIBUTE(section) ||                \
+       (defined(__GNUC__) && !defined(__clang__))) && \
+    !defined(__APPLE__) && PHMAP_HAVE_ATTRIBUTE_WEAK
+    #define PHMAP_HAVE_ATTRIBUTE_SECTION 1
+    #ifndef PHMAP_ATTRIBUTE_SECTION
+        #define PHMAP_ATTRIBUTE_SECTION(name) \
+          __attribute__((section(#name))) __attribute__((noinline))
+    #endif
+    #ifndef PHMAP_ATTRIBUTE_SECTION_VARIABLE
+        #define PHMAP_ATTRIBUTE_SECTION_VARIABLE(name) __attribute__((section(#name)))
+    #endif
+    #ifndef PHMAP_DECLARE_ATTRIBUTE_SECTION_VARS
+        #define PHMAP_DECLARE_ATTRIBUTE_SECTION_VARS(name) \
+          extern char __start_##name[] PHMAP_ATTRIBUTE_WEAK;    \
+          extern char __stop_##name[] PHMAP_ATTRIBUTE_WEAK
+    #endif
+    #ifndef PHMAP_DEFINE_ATTRIBUTE_SECTION_VARS
+        #define PHMAP_INIT_ATTRIBUTE_SECTION_VARS(name)
+        #define PHMAP_DEFINE_ATTRIBUTE_SECTION_VARS(name)
+    #endif
+    #define PHMAP_ATTRIBUTE_SECTION_START(name) \
+      (reinterpret_cast<void *>(__start_##name))
+    #define PHMAP_ATTRIBUTE_SECTION_STOP(name) \
+      (reinterpret_cast<void *>(__stop_##name))
+#else  // !PHMAP_HAVE_ATTRIBUTE_SECTION
+    #define PHMAP_HAVE_ATTRIBUTE_SECTION 0
+    #define PHMAP_ATTRIBUTE_SECTION(name)
+    #define PHMAP_ATTRIBUTE_SECTION_VARIABLE(name)
+    #define PHMAP_INIT_ATTRIBUTE_SECTION_VARS(name)
+    #define PHMAP_DEFINE_ATTRIBUTE_SECTION_VARS(name)
+    #define PHMAP_DECLARE_ATTRIBUTE_SECTION_VARS(name)
+    #define PHMAP_ATTRIBUTE_SECTION_START(name) (reinterpret_cast<void *>(0))
+    #define PHMAP_ATTRIBUTE_SECTION_STOP(name) (reinterpret_cast<void *>(0))
+#endif  // PHMAP_ATTRIBUTE_SECTION
+
+#if PHMAP_HAVE_ATTRIBUTE(force_align_arg_pointer) || \
+    (defined(__GNUC__) && !defined(__clang__))
+    #if defined(__i386__)
+        #define PHMAP_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC \
+          __attribute__((force_align_arg_pointer))
+        #define PHMAP_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
+    #elif defined(__x86_64__)
+        #define PHMAP_REQUIRE_STACK_ALIGN_TRAMPOLINE (1)
+        #define PHMAP_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+    #else  // !__i386__ && !__x86_64
+        #define PHMAP_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
+        #define PHMAP_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+    #endif  // __i386__
+#else
+    #define PHMAP_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+    #define PHMAP_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(nodiscard)
+    #define PHMAP_MUST_USE_RESULT [[nodiscard]]
+#elif defined(__clang__) && PHMAP_HAVE_ATTRIBUTE(warn_unused_result)
+    #define PHMAP_MUST_USE_RESULT __attribute__((warn_unused_result))
+#else
+    #define PHMAP_MUST_USE_RESULT
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(hot) || (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_HOT __attribute__((hot))
+#else
+    #define PHMAP_ATTRIBUTE_HOT
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(cold) || (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_COLD __attribute__((cold))
+#else
+    #define PHMAP_ATTRIBUTE_COLD
+#endif
+
+#if defined(__clang__)
+    #if PHMAP_HAVE_CPP_ATTRIBUTE(clang::reinitializes)
+        #define PHMAP_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]]
+    #else
+        #define PHMAP_ATTRIBUTE_REINITIALIZES
+    #endif
+#else
+    #define PHMAP_ATTRIBUTE_REINITIALIZES
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(unused) || (defined(__GNUC__) && !defined(__clang__))
+    #undef PHMAP_ATTRIBUTE_UNUSED
+    #define PHMAP_ATTRIBUTE_UNUSED __attribute__((__unused__))
+#else
+    #define PHMAP_ATTRIBUTE_UNUSED
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(tls_model) || (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_INITIAL_EXEC __attribute__((tls_model("initial-exec")))
+#else
+    #define PHMAP_ATTRIBUTE_INITIAL_EXEC
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(packed) || (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_PACKED __attribute__((__packed__))
+#else
+    #define PHMAP_ATTRIBUTE_PACKED
+#endif
+
+#if PHMAP_HAVE_ATTRIBUTE(aligned) || (defined(__GNUC__) && !defined(__clang__))
+    #define PHMAP_ATTRIBUTE_FUNC_ALIGN(bytes) __attribute__((aligned(bytes)))
+#else
+    #define PHMAP_ATTRIBUTE_FUNC_ALIGN(bytes)
+#endif
+
+// ----------------------------------------------------------------------
+// Figure out SSE support
+// ----------------------------------------------------------------------
+#ifndef PHMAP_HAVE_SSE2
+    #if defined(__SSE2__) ||  \
+        (defined(_MSC_VER) && \
+         (defined(_M_X64) || (defined(_M_IX86) && _M_IX86_FP >= 2)))
+        #define PHMAP_HAVE_SSE2 1
+    #else
+        #define PHMAP_HAVE_SSE2 0
+    #endif
+#endif
+
+#ifndef PHMAP_HAVE_SSSE3
+    #if defined(__SSSE3__) || defined(__AVX2__)
+        #define PHMAP_HAVE_SSSE3 1
+    #else
+        #define PHMAP_HAVE_SSSE3 0
+    #endif
+#endif
+
+#if PHMAP_HAVE_SSSE3 && !PHMAP_HAVE_SSE2
+    #error "Bad configuration!"
+#endif
+
+#if PHMAP_HAVE_SSE2
+    #include <emmintrin.h>
+#endif
+
+#if PHMAP_HAVE_SSSE3
+    #include <tmmintrin.h>
+#endif
+
+
+// ----------------------------------------------------------------------
+// constexpr if
+// ----------------------------------------------------------------------
+#if PHMAP_HAVE_CC17
+    #define PHMAP_IF_CONSTEXPR(expr) if constexpr ((expr))
+#else 
+    #define PHMAP_IF_CONSTEXPR(expr) if ((expr))
+#endif
+
+// ----------------------------------------------------------------------
+// base/macros.h
+// ----------------------------------------------------------------------
+
+// PHMAP_ARRAYSIZE()
+//
+// Returns the number of elements in an array as a compile-time constant, which
+// can be used in defining new arrays. If you use this macro on a pointer by
+// mistake, you will get a compile-time error.
+#define PHMAP_ARRAYSIZE(array) \
+  (sizeof(::phmap::macros_internal::ArraySizeHelper(array)))
+
+namespace phmap {
+namespace macros_internal {
+    // Note: this internal template function declaration is used by PHMAP_ARRAYSIZE.
+    // The function doesn't need a definition, as we only use its type.
+    template <typename T, size_t N>
+    auto ArraySizeHelper(const T (&array)[N]) -> char (&)[N];
+}  // namespace macros_internal
+}  // namespace phmap
+
+// TODO(zhangxy): Use c++17 standard [[fallthrough]] macro, when supported.
+#if defined(__clang__) && defined(__has_warning)
+    #if __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough")
+        #define PHMAP_FALLTHROUGH_INTENDED [[clang::fallthrough]]
+    #endif
+#elif defined(__GNUC__) && __GNUC__ >= 7
+    #define PHMAP_FALLTHROUGH_INTENDED [[gnu::fallthrough]]
+#endif
+
+#ifndef PHMAP_FALLTHROUGH_INTENDED
+    #define PHMAP_FALLTHROUGH_INTENDED \
+      do {  } while (0)
+#endif
+
+// PHMAP_DEPRECATED()
+//
+// Marks a deprecated class, struct, enum, function, method and variable
+// declarations. The macro argument is used as a custom diagnostic message (e.g.
+// suggestion of a better alternative).
+//
+// Example:
+//
+//   class PHMAP_DEPRECATED("Use Bar instead") Foo {...};
+//   PHMAP_DEPRECATED("Use Baz instead") void Bar() {...}
+//
+// Every usage of a deprecated entity will trigger a warning when compiled with
+// clang's `-Wdeprecated-declarations` option. This option is turned off by
+// default, but the warnings will be reported by clang-tidy.
+#if defined(__clang__) && __cplusplus >= 201103L
+    #define PHMAP_DEPRECATED(message) __attribute__((deprecated(message)))
+#endif
+
+#ifndef PHMAP_DEPRECATED
+    #define PHMAP_DEPRECATED(message)
+#endif
+
+// PHMAP_BAD_CALL_IF()
+//
+// Used on a function overload to trap bad calls: any call that matches the
+// overload will cause a compile-time error. This macro uses a clang-specific
+// "enable_if" attribute, as described at
+// http://clang.llvm.org/docs/AttributeReference.html#enable-if
+//
+// Overloads which use this macro should be bracketed by
+// `#ifdef PHMAP_BAD_CALL_IF`.
+//
+// Example:
+//
+//   int isdigit(int c);
+//   #ifdef PHMAP_BAD_CALL_IF
+//   int isdigit(int c)
+//     PHMAP_BAD_CALL_IF(c <= -1 || c > 255,
+//                       "'c' must have the value of an unsigned char or EOF");
+//   #endif // PHMAP_BAD_CALL_IF
+
+#if defined(__clang__)
+    #if __has_attribute(enable_if)
+        #define PHMAP_BAD_CALL_IF(expr, msg) \
+            __attribute__((enable_if(expr, "Bad call trap"), unavailable(msg)))
+    #endif
+#endif
+
+// PHMAP_ASSERT()
+//
+// In C++11, `assert` can't be used portably within constexpr functions.
+// PHMAP_ASSERT functions as a runtime assert but works in C++11 constexpr
+// functions.  Example:
+//
+// constexpr double Divide(double a, double b) {
+//   return PHMAP_ASSERT(b != 0), a / b;
+// }
+//
+// This macro is inspired by
+// https://akrzemi1.wordpress.com/2017/05/18/asserts-in-constexpr-functions/
+#if defined(NDEBUG)
+    #define PHMAP_ASSERT(expr) (false ? (void)(expr) : (void)0)
+#else
+    #define PHMAP_ASSERT(expr)              \
+      (PHMAP_PREDICT_TRUE((expr)) ? (void)0 \
+                                 : [] { assert(false && #expr); }())  // NOLINT
+#endif
+
+#ifdef PHMAP_HAVE_EXCEPTIONS
+    #define PHMAP_INTERNAL_TRY try
+    #define PHMAP_INTERNAL_CATCH_ANY catch (...)
+    #define PHMAP_INTERNAL_RETHROW do { throw; } while (false)
+#else  // PHMAP_HAVE_EXCEPTIONS
+    #define PHMAP_INTERNAL_TRY if (true)
+    #define PHMAP_INTERNAL_CATCH_ANY else if (false)
+    #define PHMAP_INTERNAL_RETHROW do {} while (false)
+#endif  // PHMAP_HAVE_EXCEPTIONS
+
+
+#endif // phmap_config_h_guard_
diff --git a/lib/parallel_hashmap/parallel_hashmap/phmap_dump.h b/lib/parallel_hashmap/parallel_hashmap/phmap_dump.h
new file mode 100644
index 0000000..3f613dc
--- /dev/null
+++ b/lib/parallel_hashmap/parallel_hashmap/phmap_dump.h
@@ -0,0 +1,256 @@
+#if !defined(phmap_dump_h_guard_)
+#define phmap_dump_h_guard_
+
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
+//
+//       providing dump/load/mmap_load
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ---------------------------------------------------------------------------
+
+#include <iostream>
+#include <fstream>
+#include <limits>
+#include <sstream>
+#include "phmap.h"
+namespace phmap
+{
+
+namespace type_traits_internal {
+
+#if defined(__GLIBCXX__) && __GLIBCXX__ < 20150801
+    template<typename T> struct IsTriviallyCopyable : public std::integral_constant<bool, __has_trivial_copy(T)> {};
+#else
+    template<typename T> struct IsTriviallyCopyable : public std::is_trivially_copyable<T> {};
+#endif
+
+template <class T1, class T2>
+struct IsTriviallyCopyable<std::pair<T1, T2>> {
+    static constexpr bool value = IsTriviallyCopyable<T1>::value && IsTriviallyCopyable<T2>::value;
+};
+}
+
+namespace priv {
+
+// ------------------------------------------------------------------------
+// dump/load for raw_hash_set
+// ------------------------------------------------------------------------
+template <class Policy, class Hash, class Eq, class Alloc>
+template<typename OutputArchive>
+bool raw_hash_set<Policy, Hash, Eq, Alloc>::dump(OutputArchive& ar) const {
+    static_assert(type_traits_internal::IsTriviallyCopyable<value_type>::value,
+                    "value_type should be trivially copyable");
+
+    if (!ar.dump(size_)) {
+        std::cerr << "Failed to dump size_" << std::endl;
+        return false;
+    }
+    if (size_ == 0) {
+        return true;
+    }
+    if (!ar.dump(capacity_)) {
+        std::cerr << "Failed to dump capacity_" << std::endl;
+        return false;
+    }
+    if (!ar.dump(reinterpret_cast<char*>(ctrl_),
+        sizeof(ctrl_t) * (capacity_ + Group::kWidth + 1))) {
+
+        std::cerr << "Failed to dump ctrl_" << std::endl;
+        return false;
+    }
+    for (size_t i = 0; i < capacity_; ++i) {
+        if (IsFull(ctrl_[i])) {
+            if (!ar.dump(reinterpret_cast<char*>(slots_) + sizeof(slot_type) * i,
+                            sizeof(slot_type))) {
+                std::cerr << "Failed to dump slot_ " << i << std::endl;
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+template <class Policy, class Hash, class Eq, class Alloc>
+template<typename InputArchive>
+bool raw_hash_set<Policy, Hash, Eq, Alloc>::load(InputArchive& ar) {
+    static_assert(type_traits_internal::IsTriviallyCopyable<value_type>::value,
+                    "value_type should be trivially copyable");
+    raw_hash_set<Policy, Hash, Eq, Alloc>().swap(*this); // clear any existing content
+    if (!ar.load(&size_)) {
+        std::cerr << "Failed to load size_" << std::endl;
+        return false;
+    }
+    if (size_ == 0) {
+        return true;
+    }
+    if (!ar.load(&capacity_)) {
+        std::cerr << "Failed to load capacity_" << std::endl;
+        return false;
+    }
+
+    // allocate memory for ctrl_ and slots_
+    initialize_slots();
+    if (!ar.load(reinterpret_cast<char*>(ctrl_),
+        sizeof(ctrl_t) * (capacity_ + Group::kWidth + 1))) {
+        std::cerr << "Failed to load ctrl" << std::endl;
+        return false;
+    }
+    for (size_t i = 0; i < capacity_; ++i) {
+        if (IsFull(ctrl_[i])) {
+            SanitizerUnpoisonObject(slots_ + i);
+            if (!ar.load(reinterpret_cast<char*>(slots_) + sizeof(slot_type) * i,
+                            sizeof(slot_type))) {
+                std::cerr << "Failed to load slot_ " << i << std::endl;
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+// ------------------------------------------------------------------------
+// dump/load for parallel_hash_set
+// ------------------------------------------------------------------------
+template <size_t N,
+          template <class, class, class, class> class RefSet,
+          class Mtx_,
+          class Policy, class Hash, class Eq, class Alloc>
+template<typename OutputArchive>
+bool parallel_hash_set<N, RefSet, Mtx_, Policy, Hash, Eq, Alloc>::dump(OutputArchive& ar) const {
+    static_assert(type_traits_internal::IsTriviallyCopyable<value_type>::value,
+                    "value_type should be trivially copyable");
+
+    if (! ar.dump(subcnt())) {
+        std::cerr << "Failed to dump meta!" << std::endl;
+        return false;
+    }
+    for (size_t i = 0; i < sets_.size(); ++i) {
+        auto& inner = sets_[i];
+        typename Lockable::UniqueLock m(const_cast<Inner&>(inner));
+        if (!inner.set_.dump(ar)) {
+            std::cerr << "Failed to dump submap " << i << std::endl;
+            return false;
+        }
+    }
+    return true;
+}
+
+template <size_t N,
+          template <class, class, class, class> class RefSet,
+          class Mtx_,
+          class Policy, class Hash, class Eq, class Alloc>
+template<typename InputArchive>
+bool parallel_hash_set<N, RefSet, Mtx_, Policy, Hash, Eq, Alloc>::load(InputArchive& ar) {
+    static_assert(type_traits_internal::IsTriviallyCopyable<value_type>::value,
+                    "value_type should be trivially copyable");
+
+    size_t submap_count = 0;
+    if (!ar.load(&submap_count)) {
+        std::cerr << "Failed to load submap count!" << std::endl;
+        return false;
+    }
+
+    if (submap_count != subcnt()) {
+        std::cerr << "submap count(" << submap_count << ") != N(" << N << ")" << std::endl;
+        return false;
+    }
+
+    for (size_t i = 0; i < submap_count; ++i) {            
+        auto& inner = sets_[i];
+        typename Lockable::UniqueLock m(const_cast<Inner&>(inner));
+        if (!inner.set_.load(ar)) {
+            std::cerr << "Failed to load submap " << i << std::endl;
+            return false;
+        }
+    }
+    return true;
+}
+} // namespace priv
+
+
+
+// ------------------------------------------------------------------------
+// BinaryArchive
+//       File is closed when archive object is destroyed
+// ------------------------------------------------------------------------
+
+// ------------------------------------------------------------------------
+// ------------------------------------------------------------------------
+class BinaryOutputArchive {
+public:
+    BinaryOutputArchive(const char *file_path,
+                        size_t bytes_remaining = std::numeric_limits<size_t>::max())
+        : bytes_remaining_(bytes_remaining) {
+        ofs_.open(file_path, std::ios_base::binary);
+    }
+
+    bool dump(const char *p, size_t sz) {
+        if ( sz > bytes_remaining_ ) {
+            bytes_remaining_ = 0;
+            return false;
+        }
+        bytes_remaining_ -= sz;
+        ofs_.write(p, sz);
+        return ofs_.good();
+    }
+
+    template<typename V>
+    typename std::enable_if<type_traits_internal::IsTriviallyCopyable<V>::value, bool>::type
+    dump(const V& v) {
+        return dump(reinterpret_cast<const char *>(&v), sizeof(V));
+    }
+
+    bool close() {
+        ofs_.close();
+        return ofs_.good();
+    }
+
+private:
+    std::ofstream ofs_;
+    size_t bytes_remaining_;
+};
+
+
+class BinaryInputArchive {
+public:
+    BinaryInputArchive(const char * file_path,
+                       size_t bytes_remaining = std::numeric_limits<size_t>::max())
+        : bytes_remaining_(bytes_remaining) {
+        ifs_.open(file_path, std::ios_base::binary);
+    }
+
+    bool load(char* p, size_t sz) {
+        if ( sz > bytes_remaining_ ) {
+            bytes_remaining_ = 0;
+            return false;
+        }
+        bytes_remaining_ -= sz;
+        ifs_.read(p, sz);
+        return ifs_.good();
+    }
+
+    template<typename V>
+    typename std::enable_if<type_traits_internal::IsTriviallyCopyable<V>::value, bool>::type
+    load(V* v) {
+        return load(reinterpret_cast<char *>(v), sizeof(V));
+    }
+
+private:
+    std::ifstream ifs_;
+    size_t bytes_remaining_;
+};
+
+} // namespace phmap
+
+#endif // phmap_dump_h_guard_
diff --git a/lib/parallel_hashmap/parallel_hashmap/phmap_fwd_decl.h b/lib/parallel_hashmap/parallel_hashmap/phmap_fwd_decl.h
new file mode 100644
index 0000000..a7719c4
--- /dev/null
+++ b/lib/parallel_hashmap/parallel_hashmap/phmap_fwd_decl.h
@@ -0,0 +1,154 @@
+#if !defined(phmap_fwd_decl_h_guard_)
+#define phmap_fwd_decl_h_guard_
+
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+// ---------------------------------------------------------------------------
+
+#ifdef _MSC_VER
+    #pragma warning(push)  
+    #pragma warning(disable : 4514) // unreferenced inline function has been removed
+    #pragma warning(disable : 4710) // function not inlined
+    #pragma warning(disable : 4711) // selected for automatic inline expansion
+#endif
+
+#include <memory>
+#include <utility>
+
+#if defined(PHMAP_USE_ABSL_HASH) && !defined(ABSL_HASH_HASH_H_)
+    namespace absl { template <class T> struct Hash; };
+#endif
+
+namespace phmap {
+
+#if defined(PHMAP_USE_ABSL_HASH)
+    template <class T> using Hash = ::absl::Hash<T>;
+#else
+    template <class T> struct Hash;
+#endif
+
+    template <class T> struct EqualTo;
+    template <class T> struct Less;
+    template <class T> using Allocator      = typename std::allocator<T>;
+    template<class T1, class T2> using Pair = typename std::pair<T1, T2>;
+
+    class NullMutex;
+
+    namespace priv {
+
+        // The hash of an object of type T is computed by using phmap::Hash.
+        template <class T, class E = void>
+        struct HashEq 
+        {
+            using Hash = phmap::Hash<T>;
+            using Eq   = phmap::EqualTo<T>;
+        };
+
+        template <class T>
+        using hash_default_hash = typename priv::HashEq<T>::Hash;
+
+        template <class T>
+        using hash_default_eq = typename priv::HashEq<T>::Eq;
+
+        // type alias for std::allocator so we can forward declare without including other headers
+        template <class T>  
+        using Allocator = typename phmap::Allocator<T>;
+
+        // type alias for std::pair so we can forward declare without including other headers
+        template<class T1, class T2> 
+        using Pair = typename phmap::Pair<T1, T2>;
+
+    }  // namespace priv
+
+    // ------------- forward declarations for hash containers ----------------------------------
+    template <class T, 
+              class Hash  = phmap::priv::hash_default_hash<T>,
+              class Eq    = phmap::priv::hash_default_eq<T>,
+              class Alloc = phmap::priv::Allocator<T>>  // alias for std::allocator
+        class flat_hash_set;
+
+    template <class K, class V,
+              class Hash  = phmap::priv::hash_default_hash<K>,
+              class Eq    = phmap::priv::hash_default_eq<K>,
+              class Alloc = phmap::priv::Allocator<
+                            phmap::priv::Pair<const K, V>>> // alias for std::allocator
+        class flat_hash_map;
+    
+    template <class T, 
+              class Hash  = phmap::priv::hash_default_hash<T>,
+              class Eq    = phmap::priv::hash_default_eq<T>,
+              class Alloc = phmap::priv::Allocator<T>> // alias for std::allocator
+        class node_hash_set;
+
+    template <class Key, class Value,
+              class Hash  = phmap::priv::hash_default_hash<Key>,
+              class Eq    = phmap::priv::hash_default_eq<Key>,
+              class Alloc = phmap::priv::Allocator<
+                            phmap::priv::Pair<const Key, Value>>> // alias for std::allocator
+        class node_hash_map;
+
+    template <class T,
+              class Hash  = phmap::priv::hash_default_hash<T>,
+              class Eq    = phmap::priv::hash_default_eq<T>,
+              class Alloc = phmap::priv::Allocator<T>, // alias for std::allocator
+              size_t N    = 4,                  // 2**N submaps
+              class Mutex = phmap::NullMutex>   // use std::mutex to enable internal locks
+        class parallel_flat_hash_set;
+
+    template <class K, class V,
+              class Hash  = phmap::priv::hash_default_hash<K>,
+              class Eq    = phmap::priv::hash_default_eq<K>,
+              class Alloc = phmap::priv::Allocator<
+                            phmap::priv::Pair<const K, V>>, // alias for std::allocator
+              size_t N    = 4,                  // 2**N submaps
+              class Mutex = phmap::NullMutex>   // use std::mutex to enable internal locks
+        class parallel_flat_hash_map;
+
+    template <class T, 
+              class Hash  = phmap::priv::hash_default_hash<T>,
+              class Eq    = phmap::priv::hash_default_eq<T>,
+              class Alloc = phmap::priv::Allocator<T>, // alias for std::allocator
+              size_t N    = 4,                  // 2**N submaps
+              class Mutex = phmap::NullMutex>   // use std::mutex to enable internal locks
+        class parallel_node_hash_set;
+
+    template <class Key, class Value,
+              class Hash  = phmap::priv::hash_default_hash<Key>,
+              class Eq    = phmap::priv::hash_default_eq<Key>,
+              class Alloc = phmap::priv::Allocator<
+                            phmap::priv::Pair<const Key, Value>>, // alias for std::allocator
+              size_t N    = 4,                  // 2**N submaps
+              class Mutex = phmap::NullMutex>   // use std::mutex to enable internal locks
+        class parallel_node_hash_map;
+
+    // ------------- forward declarations for btree containers ----------------------------------
+    template <typename Key, typename Compare = phmap::Less<Key>,
+              typename Alloc = phmap::Allocator<Key>>
+        class btree_set;
+
+    template <typename Key, typename Compare = phmap::Less<Key>,
+              typename Alloc = phmap::Allocator<Key>>
+        class btree_multiset;
+
+    template <typename Key, typename Value, typename Compare = phmap::Less<Key>,
+              typename Alloc = phmap::Allocator<phmap::priv::Pair<const Key, Value>>>
+        class btree_map;
+    
+    template <typename Key, typename Value, typename Compare = phmap::Less<Key>,
+              typename Alloc = phmap::Allocator<phmap::priv::Pair<const Key, Value>>>
+        class btree_multimap;
+
+}  // namespace phmap
+
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+#endif // phmap_fwd_decl_h_guard_
diff --git a/lib/parallel_hashmap/parallel_hashmap/phmap_utils.h b/lib/parallel_hashmap/parallel_hashmap/phmap_utils.h
new file mode 100644
index 0000000..72d4e71
--- /dev/null
+++ b/lib/parallel_hashmap/parallel_hashmap/phmap_utils.h
@@ -0,0 +1,376 @@
+#if !defined(phmap_utils_h_guard_)
+#define phmap_utils_h_guard_
+
+// ---------------------------------------------------------------------------
+// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
+//
+//       minimal header providing phmap::HashState
+//
+//       use as:  phmap::HashState().combine(0, _first_name, _last_name, _age);
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ---------------------------------------------------------------------------
+
+#ifdef _MSC_VER
+    #pragma warning(push)  
+    #pragma warning(disable : 4514) // unreferenced inline function has been removed
+    #pragma warning(disable : 4710) // function not inlined
+    #pragma warning(disable : 4711) // selected for automatic inline expansion
+#endif
+
+#include <cstdint>
+#include <functional>
+#include <tuple>
+#include "phmap_bits.h"
+
+// ---------------------------------------------------------------
+// Absl forward declaration requires global scope.
+// ---------------------------------------------------------------
+#if defined(PHMAP_USE_ABSL_HASH) && !defined(phmap_fwd_decl_h_guard_) && !defined(ABSL_HASH_HASH_H_)
+    namespace absl { template <class T> struct Hash; };
+#endif
+
+namespace phmap
+{
+
+// ---------------------------------------------------------------
+// ---------------------------------------------------------------
+template<int n> 
+struct phmap_mix
+{
+    inline size_t operator()(size_t) const;
+};
+
+template<>
+struct phmap_mix<4>
+{
+    inline size_t operator()(size_t a) const
+    {
+        static constexpr uint64_t kmul = 0xcc9e2d51UL;
+        // static constexpr uint64_t kmul = 0x3B9ACB93UL; // [greg] my own random prime
+        uint64_t l = a * kmul;
+        return static_cast<size_t>(l ^ (l >> 32));
+    }
+};
+
+#if defined(PHMAP_HAS_UMUL128)
+    template<>
+    struct phmap_mix<8>
+    {
+        // Very fast mixing (similar to Abseil)
+        inline size_t operator()(size_t a) const
+        {
+            static constexpr uint64_t k = 0xde5fb9d2630458e9ULL;
+            // static constexpr uint64_t k = 0x7C9D0BF0567102A5ULL; // [greg] my own random prime
+            uint64_t h;
+            uint64_t l = umul128(a, k, &h);
+            return static_cast<size_t>(h + l);
+        }
+    };
+#else
+    template<>
+    struct phmap_mix<8>
+    {
+        inline size_t operator()(size_t a) const
+        {
+            a = (~a) + (a << 21); // a = (a << 21) - a - 1;
+            a = a ^ (a >> 24);
+            a = (a + (a << 3)) + (a << 8); // a * 265
+            a = a ^ (a >> 14);
+            a = (a + (a << 2)) + (a << 4); // a * 21
+            a = a ^ (a >> 28);
+            a = a + (a << 31);
+            return static_cast<size_t>(a);
+        }
+    };
+#endif
+
+// --------------------------------------------
+template<int n> 
+struct fold_if_needed
+{
+    inline size_t operator()(uint64_t) const;
+};
+
+template<>
+struct fold_if_needed<4>
+{
+    inline size_t operator()(uint64_t a) const
+    {
+        return static_cast<size_t>(a ^ (a >> 32));
+    }
+};
+
+template<>
+struct fold_if_needed<8>
+{
+    inline size_t operator()(uint64_t a) const
+    {
+        return static_cast<size_t>(a);
+    }
+};
+
+// ---------------------------------------------------------------
+// see if class T has a hash_value() friend method
+// ---------------------------------------------------------------
+template<typename T>
+struct has_hash_value
+{
+private:
+    typedef std::true_type yes;
+    typedef std::false_type no;
+
+    template<typename U> static auto test(int) -> decltype(hash_value(std::declval<const U&>()) == 1, yes());
+
+    template<typename> static no test(...);
+
+public:
+    static constexpr bool value = std::is_same<decltype(test<T>(0)), yes>::value;
+};
+
+#if defined(PHMAP_USE_ABSL_HASH) && !defined(phmap_fwd_decl_h_guard_)
+    template <class T> using Hash = ::absl::Hash<T>;
+#elif !defined(PHMAP_USE_ABSL_HASH)
+// ---------------------------------------------------------------
+//               phmap::Hash
+// ---------------------------------------------------------------
+template <class T>
+struct Hash
+{
+    template <class U, typename std::enable_if<has_hash_value<U>::value, int>::type = 0>
+    size_t _hash(const T& val) const
+    {
+        return hash_value(val);
+    }
+ 
+    template <class U, typename std::enable_if<!has_hash_value<U>::value, int>::type = 0>
+    size_t _hash(const T& val) const
+    {
+        return std::hash<T>()(val);
+    }
+ 
+    inline size_t operator()(const T& val) const
+    {
+        return _hash<T>(val);
+    }
+};
+
+template <class T>
+struct Hash<T *>
+{
+    inline size_t operator()(const T *val) const noexcept
+    {
+        return static_cast<size_t>(reinterpret_cast<const uintptr_t>(val)); 
+    }
+};
+
+template<class ArgumentType, class ResultType>
+struct phmap_unary_function
+{
+    typedef ArgumentType argument_type;
+    typedef ResultType result_type;
+};
+
+template <>
+struct Hash<bool> : public phmap_unary_function<bool, size_t>
+{
+    inline size_t operator()(bool val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+template <>
+struct Hash<char> : public phmap_unary_function<char, size_t>
+{
+    inline size_t operator()(char val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+template <>
+struct Hash<signed char> : public phmap_unary_function<signed char, size_t>
+{
+    inline size_t operator()(signed char val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+template <>
+struct Hash<unsigned char> : public phmap_unary_function<unsigned char, size_t>
+{
+    inline size_t operator()(unsigned char val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+template <>
+struct Hash<wchar_t> : public phmap_unary_function<wchar_t, size_t>
+{
+    inline size_t operator()(wchar_t val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+template <>
+struct Hash<int16_t> : public phmap_unary_function<int16_t, size_t>
+{
+    inline size_t operator()(int16_t val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+template <>
+struct Hash<uint16_t> : public phmap_unary_function<uint16_t, size_t>
+{
+    inline size_t operator()(uint16_t val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+template <>
+struct Hash<int32_t> : public phmap_unary_function<int32_t, size_t>
+{
+    inline size_t operator()(int32_t val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+template <>
+struct Hash<uint32_t> : public phmap_unary_function<uint32_t, size_t>
+{
+    inline size_t operator()(uint32_t val) const noexcept
+    { return static_cast<size_t>(val); }
+};
+
+template <>
+struct Hash<int64_t> : public phmap_unary_function<int64_t, size_t>
+{
+    inline size_t operator()(int64_t val) const noexcept
+    { return fold_if_needed<sizeof(size_t)>()(static_cast<uint64_t>(val)); }
+};
+
+template <>
+struct Hash<uint64_t> : public phmap_unary_function<uint64_t, size_t>
+{
+    inline size_t operator()(uint64_t val) const noexcept
+    { return fold_if_needed<sizeof(size_t)>()(val); }
+};
+
+template <>
+struct Hash<float> : public phmap_unary_function<float, size_t>
+{
+    inline size_t operator()(float val) const noexcept
+    {
+        // -0.0 and 0.0 should return same hash
+        uint32_t *as_int = reinterpret_cast<uint32_t *>(&val);
+        return (val == 0) ? static_cast<size_t>(0) : 
+                            static_cast<size_t>(*as_int);
+    }
+};
+
+template <>
+struct Hash<double> : public phmap_unary_function<double, size_t>
+{
+    inline size_t operator()(double val) const noexcept
+    {
+        // -0.0 and 0.0 should return same hash
+        uint64_t *as_int = reinterpret_cast<uint64_t *>(&val);
+        return (val == 0) ? static_cast<size_t>(0) : 
+                            fold_if_needed<sizeof(size_t)>()(*as_int);
+    }
+};
+
+#endif
+
+template <class H, int sz> struct Combiner
+{
+    H operator()(H seed, size_t value);
+};
+
+template <class H> struct Combiner<H, 4>
+{
+    H operator()(H seed, size_t value)
+    {
+        return seed ^ (value + 0x9e3779b9 + (seed << 6) + (seed >> 2));
+    }
+};
+
+template <class H> struct Combiner<H, 8>
+{
+    H operator()(H seed, size_t value)
+    {
+        return seed ^ (value + size_t(0xc6a4a7935bd1e995) + (seed << 6) + (seed >> 2));
+    }
+};
+
+// define HashState to combine member hashes... see example below
+// -----------------------------------------------------------------------------
+template <typename H>
+class HashStateBase {
+public:
+    template <typename T, typename... Ts>
+    static H combine(H state, const T& value, const Ts&... values);
+
+    static H combine(H state) { return state; }
+};
+
+template <typename H>
+template <typename T, typename... Ts>
+H HashStateBase<H>::combine(H seed, const T& v, const Ts&... vs)
+{
+    return HashStateBase<H>::combine(Combiner<H, sizeof(H)>()(
+                                         seed, phmap::Hash<T>()(v)), 
+                                     vs...);
+}
+
+using HashState = HashStateBase<size_t>;
+
+// -----------------------------------------------------------------------------
+
+#if !defined(PHMAP_USE_ABSL_HASH)
+
+// define Hash for std::pair
+// -------------------------
+template<class T1, class T2> 
+struct Hash<std::pair<T1, T2>> {
+    size_t operator()(std::pair<T1, T2> const& p) const noexcept {
+        return phmap::HashState().combine(phmap::Hash<T1>()(p.first), p.second);
+    }
+};
+
+// define Hash for std::tuple
+// --------------------------
+template<class... T> 
+struct Hash<std::tuple<T...>> {
+    size_t operator()(std::tuple<T...> const& t) const noexcept {
+        return _hash_helper(t);
+    }
+
+private:
+    template<size_t I = 0, class ...P>
+        typename std::enable_if<I == sizeof...(P), size_t>::type
+        _hash_helper(const std::tuple<P...> &) const noexcept { return 0; }
+
+    template<size_t I = 0, class ...P>
+    typename std::enable_if<I < sizeof...(P), size_t>::type
+    _hash_helper(const std::tuple<P...> &t) const noexcept {
+        const auto &el = std::get<I>(t);
+        using el_type = typename std::remove_cv<typename std::remove_reference<decltype(el)>::type>::type;
+        return Combiner<size_t, sizeof(size_t)>()(
+            phmap::Hash<el_type>()(el),  _hash_helper<I + 1>(t));
+    }
+};
+
+
+#endif
+
+
+}  // namespace phmap
+
+#ifdef _MSC_VER
+     #pragma warning(pop)  
+#endif
+
+#endif // phmap_utils_h_guard_
diff --git a/lib/percy/percy/chain.hpp b/lib/percy/percy/chain.hpp
new file mode 100644
index 0000000..dc88240
--- /dev/null
+++ b/lib/percy/percy/chain.hpp
@@ -0,0 +1,861 @@
+#pragma once
+
+#include <vector>
+#include <cassert>
+#include <iostream>
+#include <memory>
+
+#include "dag.hpp"
+#include "spec.hpp"
+#include "misc.hpp"
+
+/*******************************************************************************
+    Definition of Boolean chain. A Boolean chain is a sequence of steps. Each
+    step applies a Boolean operator to a fixed number of previous steps. The
+    main objective of this package is to synthesize Boolean chains efficiently.
+*******************************************************************************/
+namespace percy
+{
+	using kitty::dynamic_truth_table;
+	using kitty::create_nth_var;
+
+    class chain
+    {
+        private:
+            int nr_in;
+            int fanin;
+            int op_tt_size; // The truth table size of operands in the chain (depends on fanin)
+            std::vector<dynamic_truth_table> compiled_functions;
+            std::vector<std::vector<int>> steps;
+            std::vector<dynamic_truth_table> operators;
+            std::vector<int> outputs;
+
+        public:
+            chain() 
+            { 
+                reset(0, 0, 0, 0);
+            }
+            chain(const chain& c) 
+            {
+                copy(c);
+            }
+
+            /*
+            chain(chain&& c)
+            {
+                vertices = std::move(c.vertices);
+                operators = std::move(c.operators);
+                outputs = std::move(c.outputs);
+            }
+            */
+
+            void reset(int nr_in, int nr_out, int nr_steps, int fanin)
+            {
+                assert(nr_steps >= 0);
+                assert(fanin <= MAX_FANIN);
+
+                this->nr_in = nr_in;
+                this->fanin = fanin;
+                this->op_tt_size = (1 << fanin);
+                steps.resize(nr_steps);
+                for (auto& step : steps) {
+                    step.resize(fanin);
+                }
+                operators.resize(nr_steps);
+                outputs.resize(nr_out);
+            }
+
+            int get_fanin() const { return fanin; }
+            int get_nr_steps() const { return steps.size(); }
+            int get_nr_inputs() const { return nr_in; }
+            int get_nr_outputs() const { return outputs.size(); }
+            const std::vector<int>& get_step(int i) const { return steps[i]; }
+            const std::vector<int>& get_outputs() const { return outputs; }
+
+            const dynamic_truth_table& get_operator(int i) const
+            {
+              return operators.at(i);
+            }
+
+            std::vector<int>& get_outputs() { return outputs; }
+
+            bool
+            is_output_inverted(int out_idx)
+            {
+                return outputs[out_idx] & 1;
+            }
+
+            void set_compiled_functions( std::vector<dynamic_truth_table> const& fs )
+            {
+              compiled_functions = fs;
+            }
+
+            void
+            set_step(int i, const int* const in, const dynamic_truth_table& op)
+            {
+                for (int j = 0; j < fanin; j++) {
+                    steps[i][j] = in[j];
+                }
+                operators[i] = op;
+            }
+
+            void
+            set_step(int i, int fanin1, int fanin2, const dynamic_truth_table& op)
+            {
+                steps[i][0] = fanin1;
+                steps[i][1] = fanin2;
+                operators[i] = op;
+            }
+
+            void
+            set_step(int i, const std::vector<int>& in, const dynamic_truth_table& op)
+            {
+                for (int j = 0; j < fanin; j++) {
+                    steps[i][j] = in[j];
+                }
+                operators[i] = op;
+            }
+
+            void
+            add_step(const int* const in, const dynamic_truth_table& op)
+            {
+                std::vector<int> step(fanin);
+                for (int j = 0; j < fanin; j++) {
+                    step[j] = in[j];
+                }
+                steps.push_back(step);
+                operators.push_back(op);
+            }
+
+            void
+            add_step(const std::vector<int>& in, const dynamic_truth_table& op)
+            {
+                std::vector<int> step(fanin);
+                for (int j = 0; j < fanin; j++) {
+                    step[j] = in[j];
+                }
+                steps.push_back(step);
+                operators.push_back(op);
+            }
+
+            void
+            set_output(int out_idx, int lit)
+            {
+                outputs[out_idx] = lit;
+            }
+
+            void
+            set_output(int out_idx, int step, bool invert)
+            {
+                outputs[out_idx] = (step << 1) | invert;
+            }
+
+            void 
+            invert() 
+            {
+                for (auto i = 0u; i < outputs.size(); i++) {
+                    outputs[i] = (outputs[i] ^ 1);
+                }
+            }
+            
+            /// De-normalizes a chain, meaning that all outputs will be
+            /// converted to non-complemented edges. This may mean that some
+            /// shared steps have to be duplicated or replaced by NOT gates.
+            /// NOTE: some outputs may point to constants or PIs. These will
+            /// not be changed.
+            void denormalize()
+            {
+                // Does nothing if there are no steps to push inverters into.
+                if (steps.size() == 0) {
+                    return;
+                }
+                
+                if (outputs.size() == 1) {
+                    if (outputs[0] & 1) {
+                        operators[steps.size() - 1] = ~operators[steps.size() - 1];
+                        outputs[0] = (outputs[0] ^ 1);
+                    }
+                    return;
+                }
+
+                std::vector<int> refcount(steps.size());
+                std::vector<dynamic_truth_table> tmps(steps.size());
+                std::vector<dynamic_truth_table> ins;
+                std::vector<dynamic_truth_table> fs(outputs.size());
+
+                for (auto i = 1u; i < steps.size(); i++) {
+                    const auto& v = steps[i];
+                    for (const auto fid : v) {
+                        if (fid > nr_in) {
+                            refcount[fid - nr_in - 1]++;
+                        }
+                    }
+                }
+
+                for (auto i = 0u; i < outputs.size(); i++) {
+                    const auto step_idx = outputs[i] >> 1;
+                    if (step_idx > nr_in) {
+                        refcount[step_idx - nr_in - 1]++;
+                    }
+                }
+
+                for (auto count : refcount) {
+                    assert(count > 0);
+                }
+
+                for (auto i = 0; i < nr_in; ++i) {
+                    auto in_tt = kitty::create<dynamic_truth_table>(nr_in);
+                    ins.push_back(in_tt);
+                }
+
+                auto tt_step = kitty::create<dynamic_truth_table>(nr_in);
+                auto tt_compute = kitty::create<dynamic_truth_table>(nr_in);
+                
+                for (auto i = 0u; i < steps.size(); i++) {
+                    const auto& step = steps[i];
+
+                    for (int j = 0; j < fanin; j++) {
+                        const auto fanin = step[j];
+                        if (fanin < nr_in) {
+                            create_nth_var(ins[j], fanin);
+                        } else {
+                            ins[j] = tmps[fanin - nr_in];
+                        }
+                    }
+
+                    kitty::clear(tt_step);
+                    for (int j = 1; j < op_tt_size; j++) {
+                        kitty::clear(tt_compute);
+                        tt_compute = ~tt_compute;
+                        if (get_bit(operators[i], j)) {
+                            for (int k = 0; k < fanin; k++) {
+                                if ((j >> k) & 1) {
+                                    tt_compute &= ins[k];
+                                } else {
+                                    tt_compute &= ~ins[k];
+                                }
+                            }
+                            tt_step |= tt_compute;
+                        }
+                    }
+                    tmps[i] = tt_step;
+
+                    for (auto h = 0u; h < outputs.size(); h++) {
+                        const auto out = static_cast<unsigned>(outputs[h]);
+                        const auto var = out >> 1u;
+                        const auto inv = out & 1u;
+                        if (var - nr_in - 1u == i) {
+                            fs[h] = inv ? ~tt_step : tt_step;
+                        }
+                    }
+                }
+                
+                for (auto i = 0u; i < outputs.size(); i++) {
+                    auto step_idx = outputs[i] >> 1;
+                    const auto invert = outputs[i] & 1;
+
+                    if (!invert || step_idx <= nr_in) {
+                        continue;
+                    }
+
+                    step_idx -= (nr_in + 1);
+                    assert(refcount[step_idx] >= 1);
+                    if (refcount[step_idx] == 1) {
+                        operators[step_idx] = ~operators[step_idx];
+                    } else {
+                        // This output points to a shared step that needs to
+                        // be inverted. If no inverted version of this step
+                        // exists somewhere in the chain, we need to add a new
+                        // step.
+                        bool inv_step_found = false;
+                        for (auto j = 0u; j < steps.size(); j++) {
+                            if (tmps[j] == fs[i]) {
+                                set_output(i, j + nr_in + 1, false);
+                                inv_step_found = true;
+                            }
+                        }
+                        if (inv_step_found) {
+                            continue;
+                        }
+                        std::vector<int> fanins(fanin);
+                        const auto& v = steps[step_idx];
+                        for (int j = 0; j < fanin; j++) {
+                            fanins[j] = v[j];
+                        };
+
+                        add_step(fanins, ~operators[step_idx]);
+                        set_output(i, nr_in + steps.size(), false);
+                        tmps.push_back(fs[i]);
+
+                        refcount[step_idx]--;
+                    }
+                }
+            }
+
+            /*******************************************************************
+                Derive truth tables from the chain, one for each output.
+            *******************************************************************/
+            std::vector<dynamic_truth_table> simulate() const
+            {
+                std::vector<dynamic_truth_table> fs(outputs.size());
+                std::vector<dynamic_truth_table> tmps(steps.size());
+                std::vector<dynamic_truth_table> ins;
+
+                for ( auto i = 0; i < nr_in; ++i ) {
+                    ins.push_back( kitty::create<dynamic_truth_table>( nr_in ) );
+                }
+
+                auto tt_step = kitty::create<dynamic_truth_table>(nr_in);
+                auto tt_compute = kitty::create<dynamic_truth_table>(nr_in);
+
+                // Some outputs may be simple constants or projections.
+                for (auto h = 0u; h < outputs.size(); h++)
+                {
+                    const auto out = outputs[h];
+                    const auto var = out >> 1;
+                    const auto inv = out & 1;
+                    if (var == 0) {
+                        clear(tt_step);
+                        fs[h] = inv ? ~tt_step : tt_step;
+                    } else if (var <= nr_in) {
+                        create_nth_var(tt_step, var-1, inv);
+                        fs[h] = tt_step;
+                    }
+                }
+
+                for (auto i = 0u; i < steps.size(); i++) {
+                  const auto& step = steps[i];
+
+                  for ( int j = 0; j < fanin; ++j )
+                  {
+                    const auto fanin = step[j];
+                    // std::cout << fanin << ' ';
+                    if ( fanin < nr_in )
+                    {
+                      create_nth_var(ins[j], fanin);
+                    }
+                    else if ( fanin < nr_in + compiled_functions.size() )
+                    {
+                      ins[j] = compiled_functions.at( fanin - nr_in );
+                    }
+                    else
+                    {
+                      ins[j] = tmps[fanin - nr_in - compiled_functions.size()];
+                    }
+                    // kitty::print_binary( ins[j] );
+                    // std::cout << std::endl;
+                  }
+
+                  kitty::clear(tt_step);
+                  for ( int j = 0; j < op_tt_size; ++j )
+                  {
+                    kitty::clear(tt_compute);
+                    tt_compute = ~tt_compute;
+                    if ( get_bit( operators[i], j ) )
+                    {
+                      for ( int k = 0; k < fanin; ++k)
+                      {
+                        if ((j >> k) & 1)
+                        {
+                          tt_compute &= ins[k];
+                        }
+                        else
+                        {
+                          tt_compute &= ~ins[k];
+                        }
+                      }
+                      tt_step |= tt_compute;
+                    }
+                  }
+                  // std::cout << "step = ";
+                  // kitty::print_binary( tt_step );
+                  // std::cout << std::endl;
+                  tmps[i] = tt_step;
+
+                  for ( auto h = 0u; h < outputs.size(); ++h )
+                  {
+                    const auto out = outputs[h];
+                    const auto var = out >> 1;
+                    const auto inv = out & 1;
+                    if (var - nr_in - compiled_functions.size() - 1 == static_cast<int>(i)) {
+                      fs[h] = inv ? ~tt_step : tt_step;
+                    }
+                  }
+                }
+
+                return fs;
+            }
+
+
+            /*******************************************************************
+                Checks if a chain satisfies the given specification. This
+                checks not just if the chain computes the correct function, but
+                also other requirements such as co-lexicographic order (if
+                specified).
+            *******************************************************************/
+            bool
+            satisfies_spec(const spec& spec)
+            {
+                if (spec.nr_triv == spec.get_nr_out()) {
+                    return true;
+                }
+                auto tts = simulate();
+                dynamic_truth_table op_tt(fanin);
+
+                for (auto& step : steps) {
+                    if (step.size() != static_cast<unsigned>(spec.fanin)) {
+                        assert(false);
+                        return false;
+                    }
+                }
+
+                auto nr_nontriv = 0;
+                for (int i = 0; i < spec.nr_nontriv; i++) {
+                    if ((spec.triv_flag >> i) & 1) {
+                        continue;
+                    }
+                    if (tts[nr_nontriv++] != spec[i]) {
+                        assert(false);
+                        return false;
+                    }
+                }
+
+                if (spec.add_nontriv_clauses) {
+                    // Ensure that there are no trivial operators.
+                    for (auto& op : operators) {
+                        clear(op_tt);
+                        if (op == op_tt) {
+                            assert(false);
+                            return false;
+                        }
+                        for (int i = 0; i < fanin; i++) {
+                            create_nth_var(op_tt, i);
+                            if (op == op_tt) {
+                                assert(false);
+                                return false;
+                            }
+                        }
+                    }
+                }
+
+                if ( spec.add_alonce_clauses )
+                {
+                  /* Ensure that each step is used at least once. */
+                  std::vector<int32_t> nr_uses( steps.size() );
+
+                  for ( auto i = 0u; i < steps.size(); ++i )
+                  {
+                    auto const& step = steps[i];
+                    for ( const auto& fid : step )
+                    {
+                      if ( fid >= nr_in + compiled_functions.size() )
+                      {
+                        nr_uses[fid - nr_in - compiled_functions.size()]++;
+                      }
+                    }
+                  }
+
+                  for ( auto const& output : outputs )
+                  {
+                    auto const step_idx = output >> 1;
+                    if ( step_idx > nr_in + compiled_functions.size() )
+                    {
+                      nr_uses[step_idx - nr_in - compiled_functions.size() - 1]++;
+                    }
+                  }
+
+                  for ( auto const& nr : nr_uses )
+                  {
+                    if ( nr == 0 )
+                    {
+                      assert( false );
+                      return false;
+                    }
+                  }
+                }
+
+                if (spec.add_noreapply_clauses) {
+                    // Ensure there is no re-application of operands.
+                    for (auto i = 0u; i < steps.size() - 1; i++) {
+                        const auto & fanins1 = steps[i];
+                        for (auto ip = i + 1; ip < steps.size(); ip++) {
+                            const auto& fanins2 = steps[ip];
+
+                            auto is_subsumed = true;
+                            auto has_fanin_i = false;
+                            for (auto j : fanins2) {
+                                if (static_cast<unsigned>(j) == i + nr_in) {
+                                    has_fanin_i = true;
+                                    continue;
+                                }
+                                auto is_included = false;
+                                for (auto jp : fanins1) {
+                                    if (j == jp) {
+                                        is_included = true;
+                                    }
+                                }
+                                if (!is_included) {
+                                    is_subsumed = false;
+                                }
+                            }
+                            if (is_subsumed && has_fanin_i) {
+                                assert(false);
+                                return false;
+                            }
+                        }
+                    }
+                }
+
+                if (spec.add_colex_clauses) {
+                    // Ensure that steps are in co-lexicographical order.
+                    for (int i = 0; i < spec.nr_steps - 1; i++) {
+                        const auto& v1 = steps[i];
+                        const auto& v2 = steps[i + 1];
+                        
+                        if (colex_compare(v1, v2) == 1) {
+                            assert(false);
+                            return false;
+                        }
+                    }
+                }
+
+                if (spec.add_lex_clauses) {
+                    // Ensure that steps are in lexicographical order.
+                    for (int i = 0; i < spec.nr_steps - 1; i++) {
+                        const auto& v1 = steps[i];
+                        const auto& v2 = steps[i + 1];
+                        
+                        if (lex_compare(v1, v2) == 1) {
+                            assert(false);
+                            return false;
+                        }
+                    }
+                }
+
+                if (spec.add_lex_func_clauses) {
+                    // Ensure that step operators are in lexicographical order.
+                    for (int i = 0; i < spec.nr_steps - 1; i++) {
+                        const auto& v1 = steps[i];
+                        const auto& v2 = steps[i + 1];
+
+                        if (colex_compare(v1, v2) == 0) {
+                            // The operator of step i must be lexicographically
+                            // less than that of i + 1.
+                            const auto& op1 = operators[i];
+                            const auto& op2 = operators[i + 1];
+                            if (op2 < op1) {
+                                assert(false);
+                                return false;
+                            }
+                        }
+                    }
+                }
+
+                if (spec.add_symvar_clauses) {
+                    // Ensure that symmetric variables are ordered.
+                    for (int q = 1; q < spec.get_nr_in(); q++) {
+                        for (int p = 0; p < q; p++) {
+                            auto symm = true;
+                            for (int i = 0; i < spec.get_nr_out(); i++) {
+                                auto outfunc = spec[i];
+                                if (!(swap(outfunc, p, q) == outfunc)) {
+                                    symm = false;
+                                    break;
+                                }
+                            }
+                            if (!symm) {
+                                continue;
+                            }
+                            for (int i = 1; i < spec.nr_steps; i++) {
+                                const auto& v1 = steps[i];
+                                auto has_fanin_p = false;
+                                auto has_fanin_q = false;
+
+                                for (const auto fid : v1) {
+                                    if (fid == p) {
+                                        has_fanin_p = true;
+                                    } else if (fid == q) {
+                                        has_fanin_q = true;
+                                    }
+                                }
+
+                                if (!has_fanin_q || has_fanin_p) {
+                                    continue;
+                                }
+                                auto p_in_prev_step = false;
+                                for (int ip = 0; ip < i; ip++) {
+                                    const auto& v2 = steps[ip];
+                                    has_fanin_p = false;
+
+                                    for (const auto fid : v2) {
+                                        if (fid == p) {
+                                            has_fanin_p = true;
+                                        }
+                                    }
+                                    if (has_fanin_p) {
+                                        p_in_prev_step = true;
+                                    }   
+                                }
+                                if (!p_in_prev_step) {
+                                    assert(false);
+                                    return false;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                return true;
+            }
+
+            bool is_aig()
+            {
+                if (fanin != 2) {
+                    return false;
+                }
+                kitty::dynamic_truth_table in1(2), in2(2);
+                kitty::create_nth_var(in1, 0);
+                kitty::create_nth_var(in2, 1);
+                const auto tt1 = in1 & in2;
+                const auto tt2 = ~in1 & in2;
+                const auto tt3 = in1 & ~in2;
+                const auto tt4 = in1 | in2;
+                for (const auto& op : operators) {
+                    if (op != tt1 && op != tt2 && op != tt3 && op != tt4) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            bool is_mag()
+            {
+                if (fanin != 3) {
+                    return false;
+                }
+                kitty::dynamic_truth_table maj_tt(3);
+                kitty::create_majority(maj_tt);
+
+                for (const auto& op : operators) {
+                    if (op != maj_tt) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            void
+            copy(const chain& c)
+            {
+                nr_in = c.nr_in;
+                fanin = c.fanin;
+                op_tt_size = c.op_tt_size;
+                compiled_functions = c.compiled_functions;
+                steps = c.steps;
+                operators = c.operators;
+                outputs = c.outputs;
+            }
+
+            /*******************************************************************
+                Creates a DAG from the Boolean chain in .dot format, so that
+                it may be rendered using various DAG packages (e.g. graphviz).
+            *******************************************************************/
+            void
+            to_dot(std::ostream& s) /* NOTE: deprecated impl. */
+            {
+                s << "graph {\n";
+                s << "rankdir = BT\n";
+                s << "x0 [shape=none,label=<\u22A5>];\n";
+                for (int i = 0; i < nr_in; i++) {
+                    const auto idx = i + 1;
+                    s << "x" << idx << " [shape=none,label=<x<sub>" << idx
+                        << "</sub>>];\n";
+                }
+
+                s << "node [shape=circle];\n";
+                for (size_t i = 0; i < steps.size(); i++) {
+                    const auto& step = steps[i];
+                    const auto idx = nr_in + i + 1;
+                    s << "x" << idx << " [label=<";
+                    kitty::print_binary(operators[i], s);
+                    s << ">];\n";
+                    for (int j = 0; j < fanin; j++) {
+                        s << "x" << step[j]+1 << " -- x" << idx << ";\n";
+                    }
+                }
+
+                for (size_t h = 0u; h < outputs.size(); h++) {
+                    const auto out = outputs[h];
+                    const auto inv = out & 1;
+                    const auto var = out >> 1;
+                    s << "f" << h << " [shape=none,label=<f<sub>" << h+1
+                        << "</sub>>];\n";
+                    s << "x" << var << " -- f" << h << " [style=" <<
+                        (inv ? "dashed" : "solid") << "];\n";
+                }
+
+                // Group inputs on same level.
+                s << "{rank = same; x0; ";
+                for (int i = 0; i < nr_in; i++) {
+                    s << "x" << i+1 << "; ";
+                }
+                s << "}\n";
+
+                // Group outputs on same level.
+                s << "{rank = same; ";
+                for (size_t h = 0u; h < outputs.size(); h++) {
+                    s << "f" << h << "; ";
+                }
+                s << "}\n";
+
+                // Add invisible edges between PIs and POs to enforce order.
+                s << "edge[style=invisible];\n";
+                for (int i = nr_in; i > 0; i--) {
+                    s << "x" << i-1 << " -- x" << i << ";\n";
+                }
+                for (size_t h = outputs.size(); h > 1; h--) {
+                    s << "f" << h-2 << " -- f" << h-1 << ";\n";
+                }
+
+                s << "}\n";
+
+            }
+
+            void
+            print_dot()
+            {
+                to_dot(std::cout);
+            }
+
+            /*******************************************************************
+                Functions to convert the chain to a parseable expression.
+                Currently only supported for single-output normal chains with
+                2-input operators.
+            *******************************************************************/
+            void
+            step_to_expression(std::ostream& s, int step_idx)
+            {
+                assert(fanin == 2);
+
+                if (step_idx < nr_in) {
+                    s << char(('a' + step_idx));
+                    return;
+                }
+                const auto& step = steps[step_idx - nr_in];
+                auto word = 0;
+                for (int i = 0; i < 4; i++) {
+                    if (kitty::get_bit(operators[step_idx - nr_in], i)) {
+                        word |= (1 << i);
+                    }
+                }
+                assert(word <= 15);
+                switch (word) {
+                    case 2:
+                        s << "(";
+                        step_to_expression(s, step[0]);
+                        s << "!";
+                        step_to_expression(s, step[1]);
+                        s << ")";
+                        break;
+                    case 4:
+                        s << "(";
+                        s << "!";
+                        step_to_expression(s, step[0]);
+                        step_to_expression(s, step[1]);
+                        s << ")";
+                        break;
+                    case 6:
+                        s << "[";
+                        step_to_expression(s, step[0]);
+                        step_to_expression(s, step[1]);
+                        s << "]";
+                        break;
+                    case 8:
+                        s << "(";
+                        step_to_expression(s, step[0]);
+                        step_to_expression(s, step[1]);
+                        s << ")";
+                        break;
+                    case 14:
+                        s << "{";
+                        step_to_expression(s, step[0]);
+                        step_to_expression(s, step[1]);
+                        s << "}";
+                        break;
+                    default:
+                        // Invalid operator detected.
+                        printf("Invalid operator %d\n", word);
+                        assert(0);
+                        break;
+                }
+            }
+
+            void
+            to_expression(std::ostream& s)
+            {
+                assert(outputs.size() == 1 && fanin == 2);
+                const auto outlit = outputs[0];
+                if (outlit & 1) {
+                    s << "!";
+                }
+                const auto outvar = outlit >> 1;
+                if (outvar == 0) { // Special case of constant 0
+                    s << "0";
+                } else {
+                    step_to_expression(s, outvar-1);
+                }
+            }
+
+            void
+            print_expression()
+            {
+                to_expression(std::cout);
+            }
+
+            void step_to_mag_expression(std::ostream& s, int step_idx)
+            {
+                assert(fanin == 3);
+
+                if (step_idx < nr_in) {
+                    s << char(('a' + step_idx));
+                    return;
+                }
+                const auto& step = get_step(step_idx - nr_in);
+                s << "<";
+                step_to_mag_expression(s, step[0]);
+                step_to_mag_expression(s, step[1]);
+                step_to_mag_expression(s, step[2]);
+                s << ">";
+            }
+
+            void to_mag_expression(std::ostream& s)
+            {
+                assert(outputs.size() == 1 && fanin == 3);
+                const auto outlit = outputs[0];
+                const auto outvar = outlit >> 1;
+                if (outvar == 0) { // Special case of constant 0
+                    s << "0";
+                } else {
+                    step_to_mag_expression(s, outvar-1);
+                }
+            }
+
+            void print_mag()
+            {
+                std::cout << steps.size() << "-step MAJ chain\n";
+                to_mag_expression(std::cout);
+                std::cout << "\n";
+            }
+
+            template<int FI>
+            void
+            extract_dag(dag<FI>& g) const
+            {
+                g.copy_dag(*this);
+            }
+
+    };
+
+}
+
+#include "printer.hpp"
diff --git a/lib/percy/percy/cnf.hpp b/lib/percy/percy/cnf.hpp
new file mode 100644
index 0000000..f0ebb31
--- /dev/null
+++ b/lib/percy/percy/cnf.hpp
@@ -0,0 +1,56 @@
+#pragma once
+
+#include <vector>
+#include <abc/satSolver.h>
+#include "solvers.hpp"
+#include <cstdio>
+
+namespace percy
+{
+    class cnf_formula : public solver_wrapper
+    {
+    private:
+        std::vector<std::vector<int>> clauses;
+        int _nr_vars;
+
+    public:
+        void restart() { _nr_vars = 0;  clauses.clear(); }
+        void clear() { restart(); };
+        int nr_vars() { return _nr_vars; }
+        int nr_clauses() { return clauses.size(); }
+        int nr_conflicts() { return 0; }
+        void set_nr_vars(int nr_vars) { _nr_vars = nr_vars; }
+        void add_var() { _nr_vars++; };
+        
+        int var_value(int) { return false; }
+        synth_result solve(int) { return failure; }
+        synth_result solve(pabc::lit*, pabc::lit*, int) { return failure; }
+
+        int add_clause(pabc::lit* begin, pabc::lit* end) 
+        {
+            std::vector<int> clause;
+            while (begin != end) {
+                clause.push_back(*begin);
+                begin++;
+            }
+            clauses.push_back(clause);
+
+            return 1;
+        }
+
+        void to_dimacs(FILE* f) 
+        {
+            fprintf(f, "p cnf %d %d\n", nr_vars(), nr_clauses());
+            for (const auto& clause : clauses) {
+                for (const auto lit : clause) {
+                    // NOTE: variable 0 does not exist in DIMACS format
+                    const auto var = pabc::Abc_Lit2Var(lit) + 1;
+                    const auto is_c = pabc::Abc_LitIsCompl(lit);
+                    fprintf(f, "%d ", is_c ? -var : var);
+                }
+                fprintf(f, "0\n");
+            }
+        }
+
+    };
+}
diff --git a/lib/percy/percy/concurrentqueue.h b/lib/percy/percy/concurrentqueue.h
new file mode 100644
index 0000000..ba6f0ed
--- /dev/null
+++ b/lib/percy/percy/concurrentqueue.h
@@ -0,0 +1,3634 @@
+// Provides a C++11 implementation of a multi-producer, multi-consumer lock-free queue.
+// An overview, including benchmark results, is provided here:
+//     http://moodycamel.com/blog/2014/a-fast-general-purpose-lock-free-queue-for-c++
+// The full design is also described in excruciating detail at:
+//    http://moodycamel.com/blog/2014/detailed-design-of-a-lock-free-queue
+
+// Simplified BSD license:
+// Copyright (c) 2013-2016, Cameron Desrochers.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// - Redistributions of source code must retain the above copyright notice, this list of
+// conditions and the following disclaimer.
+// - 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.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS 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 COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 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.
+
+
+#pragma once
+
+#if defined(__GNUC__)
+// Disable -Wconversion warnings (spuriously triggered when Traits::size_t and
+// Traits::index_t are set to < 32 bits, causing integer promotion, causing warnings
+// upon assigning any computed values)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
+#ifdef MCDBGQ_USE_RELACY
+#pragma GCC diagnostic ignored "-Wint-to-pointer-cast"
+#endif
+#endif
+
+#if defined(__APPLE__)
+#include "TargetConditionals.h"
+#endif
+
+#ifdef MCDBGQ_USE_RELACY
+#include "relacy/relacy_std.hpp"
+#include "relacy_shims.h"
+// We only use malloc/free anyway, and the delete macro messes up `= delete` method declarations.
+// We'll override the default trait malloc ourselves without a macro.
+#undef new
+#undef delete
+#undef malloc
+#undef free
+#else
+#include <atomic>		// Requires C++11. Sorry VS2010.
+#include <cassert>
+#endif
+#include <cstddef>              // for max_align_t
+#include <cstdint>
+#include <cstdlib>
+#include <type_traits>
+#include <algorithm>
+#include <utility>
+#include <limits>
+#include <climits>		// for CHAR_BIT
+#include <array>
+#include <thread>		// partly for __WINPTHREADS_VERSION if on MinGW-w64 w/ POSIX threading
+
+// Platform-specific definitions of a numeric thread ID type and an invalid value
+namespace moodycamel { namespace details {
+	template<typename thread_id_t> struct thread_id_converter {
+		typedef thread_id_t thread_id_numeric_size_t;
+		typedef thread_id_t thread_id_hash_t;
+		static thread_id_hash_t prehash(thread_id_t const& x) { return x; }
+	};
+} }
+#if defined(MCDBGQ_USE_RELACY)
+namespace moodycamel { namespace details {
+	typedef std::uint32_t thread_id_t;
+	static const thread_id_t invalid_thread_id  = 0xFFFFFFFFU;
+	static const thread_id_t invalid_thread_id2 = 0xFFFFFFFEU;
+	static inline thread_id_t thread_id() { return rl::thread_index(); }
+} }
+#elif defined(_WIN32) || defined(__WINDOWS__) || defined(__WIN32__)
+// No sense pulling in windows.h in a header, we'll manually declare the function
+// we use and rely on backwards-compatibility for this not to break
+extern "C" __declspec(dllimport) unsigned long __stdcall GetCurrentThreadId(void);
+namespace moodycamel { namespace details {
+	static_assert(sizeof(unsigned long) == sizeof(std::uint32_t), "Expected size of unsigned long to be 32 bits on Windows");
+	typedef std::uint32_t thread_id_t;
+	static const thread_id_t invalid_thread_id  = 0;			// See http://blogs.msdn.com/b/oldnewthing/archive/2004/02/23/78395.aspx
+	static const thread_id_t invalid_thread_id2 = 0xFFFFFFFFU;	// Not technically guaranteed to be invalid, but is never used in practice. Note that all Win32 thread IDs are presently multiples of 4.
+	static inline thread_id_t thread_id() { return static_cast<thread_id_t>(::GetCurrentThreadId()); }
+} }
+#elif defined(__arm__) || defined(_M_ARM) || defined(__aarch64__) || (defined(__APPLE__) && TARGET_OS_IPHONE)
+namespace moodycamel { namespace details {
+	static_assert(sizeof(std::thread::id) == 4 || sizeof(std::thread::id) == 8, "std::thread::id is expected to be either 4 or 8 bytes");
+	
+	typedef std::thread::id thread_id_t;
+	static const thread_id_t invalid_thread_id;         // Default ctor creates invalid ID
+
+	// Note we don't define a invalid_thread_id2 since std::thread::id doesn't have one; it's
+	// only used if MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED is defined anyway, which it won't
+	// be.
+	static inline thread_id_t thread_id() { return std::this_thread::get_id(); }
+
+	template<std::size_t> struct thread_id_size { };
+	template<> struct thread_id_size<4> { typedef std::uint32_t numeric_t; };
+	template<> struct thread_id_size<8> { typedef std::uint64_t numeric_t; };
+
+	template<> struct thread_id_converter<thread_id_t> {
+		typedef thread_id_size<sizeof(thread_id_t)>::numeric_t thread_id_numeric_size_t;
+#ifndef __APPLE__
+		typedef std::size_t thread_id_hash_t;
+#else
+		typedef thread_id_numeric_size_t thread_id_hash_t;
+#endif
+
+		static thread_id_hash_t prehash(thread_id_t const& x)
+		{
+#ifndef __APPLE__
+			return std::hash<std::thread::id>()(x);
+#else
+			return *reinterpret_cast<thread_id_hash_t const*>(&x);
+#endif
+		}
+	};
+} }
+#else
+// Use a nice trick from this answer: http://stackoverflow.com/a/8438730/21475
+// In order to get a numeric thread ID in a platform-independent way, we use a thread-local
+// static variable's address as a thread identifier :-)
+#if defined(__GNUC__) || defined(__INTEL_COMPILER)
+#define MOODYCAMEL_THREADLOCAL __thread
+#elif defined(_MSC_VER)
+#define MOODYCAMEL_THREADLOCAL __declspec(thread)
+#else
+// Assume C++11 compliant compiler
+#define MOODYCAMEL_THREADLOCAL thread_local
+#endif
+namespace moodycamel { namespace details {
+	typedef std::uintptr_t thread_id_t;
+	static const thread_id_t invalid_thread_id  = 0;		// Address can't be nullptr
+	static const thread_id_t invalid_thread_id2 = 1;		// Member accesses off a null pointer are also generally invalid. Plus it's not aligned.
+	static inline thread_id_t thread_id() { static MOODYCAMEL_THREADLOCAL int x; return reinterpret_cast<thread_id_t>(&x); }
+} }
+#endif
+
+// Exceptions
+#ifndef MOODYCAMEL_EXCEPTIONS_ENABLED
+#if (defined(_MSC_VER) && defined(_CPPUNWIND)) || (defined(__GNUC__) && defined(__EXCEPTIONS)) || (!defined(_MSC_VER) && !defined(__GNUC__))
+#define MOODYCAMEL_EXCEPTIONS_ENABLED
+#endif
+#endif
+#ifdef MOODYCAMEL_EXCEPTIONS_ENABLED
+#define MOODYCAMEL_TRY try
+#define MOODYCAMEL_CATCH(...) catch(__VA_ARGS__)
+#define MOODYCAMEL_RETHROW throw
+#define MOODYCAMEL_THROW(expr) throw (expr)
+#else
+#define MOODYCAMEL_TRY if (true)
+#define MOODYCAMEL_CATCH(...) else if (false)
+#define MOODYCAMEL_RETHROW
+#define MOODYCAMEL_THROW(expr)
+#endif
+
+#ifndef MOODYCAMEL_NOEXCEPT
+#if !defined(MOODYCAMEL_EXCEPTIONS_ENABLED)
+#define MOODYCAMEL_NOEXCEPT
+#define MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr) true
+#define MOODYCAMEL_NOEXCEPT_ASSIGN(type, valueType, expr) true
+#elif defined(_MSC_VER) && defined(_NOEXCEPT) && _MSC_VER < 1800
+// VS2012's std::is_nothrow_[move_]constructible is broken and returns true when it shouldn't :-(
+// We have to assume *all* non-trivial constructors may throw on VS2012!
+#define MOODYCAMEL_NOEXCEPT _NOEXCEPT
+#define MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr) (std::is_rvalue_reference<valueType>::value && std::is_move_constructible<type>::value ? std::is_trivially_move_constructible<type>::value : std::is_trivially_copy_constructible<type>::value)
+#define MOODYCAMEL_NOEXCEPT_ASSIGN(type, valueType, expr) ((std::is_rvalue_reference<valueType>::value && std::is_move_assignable<type>::value ? std::is_trivially_move_assignable<type>::value || std::is_nothrow_move_assignable<type>::value : std::is_trivially_copy_assignable<type>::value || std::is_nothrow_copy_assignable<type>::value) && MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr))
+#elif defined(_MSC_VER) && defined(_NOEXCEPT) && _MSC_VER < 1900
+#define MOODYCAMEL_NOEXCEPT _NOEXCEPT
+#define MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr) (std::is_rvalue_reference<valueType>::value && std::is_move_constructible<type>::value ? std::is_trivially_move_constructible<type>::value || std::is_nothrow_move_constructible<type>::value : std::is_trivially_copy_constructible<type>::value || std::is_nothrow_copy_constructible<type>::value)
+#define MOODYCAMEL_NOEXCEPT_ASSIGN(type, valueType, expr) ((std::is_rvalue_reference<valueType>::value && std::is_move_assignable<type>::value ? std::is_trivially_move_assignable<type>::value || std::is_nothrow_move_assignable<type>::value : std::is_trivially_copy_assignable<type>::value || std::is_nothrow_copy_assignable<type>::value) && MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr))
+#else
+#define MOODYCAMEL_NOEXCEPT noexcept
+#define MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr) noexcept(expr)
+#define MOODYCAMEL_NOEXCEPT_ASSIGN(type, valueType, expr) noexcept(expr)
+#endif
+#endif
+
+#ifndef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
+#ifdef MCDBGQ_USE_RELACY
+#define MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
+#else
+// VS2013 doesn't support `thread_local`, and MinGW-w64 w/ POSIX threading has a crippling bug: http://sourceforge.net/p/mingw-w64/bugs/445
+// g++ <=4.7 doesn't support thread_local either.
+// Finally, iOS/ARM doesn't have support for it either, and g++/ARM allows it to compile but it's unconfirmed to actually work
+#if (!defined(_MSC_VER) || _MSC_VER >= 1900) && (!defined(__MINGW32__) && !defined(__MINGW64__) || !defined(__WINPTHREADS_VERSION)) && (!defined(__GNUC__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)) && (!defined(__APPLE__) || !TARGET_OS_IPHONE) && !defined(__arm__) && !defined(_M_ARM) && !defined(__aarch64__)
+// Assume `thread_local` is fully supported in all other C++11 compilers/platforms
+//#define MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED    // always disabled for now since several users report having problems with it on
+#endif
+#endif
+#endif
+
+// VS2012 doesn't support deleted functions. 
+// In this case, we declare the function normally but don't define it. A link error will be generated if the function is called.
+#ifndef MOODYCAMEL_DELETE_FUNCTION
+#if defined(_MSC_VER) && _MSC_VER < 1800
+#define MOODYCAMEL_DELETE_FUNCTION
+#else
+#define MOODYCAMEL_DELETE_FUNCTION = delete
+#endif
+#endif
+
+// Compiler-specific likely/unlikely hints
+namespace moodycamel { namespace details {
+#if defined(__GNUC__)
+	inline bool likely(bool x) { return __builtin_expect((x), true); }
+	inline bool unlikely(bool x) { return __builtin_expect((x), false); }
+#else
+	inline bool likely(bool x) { return x; }
+	inline bool unlikely(bool x) { return x; }
+#endif
+} }
+
+#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
+#include "internal/concurrentqueue_internal_debug.h"
+#endif
+
+namespace moodycamel {
+namespace details {
+	template<typename T>
+	struct const_numeric_max {
+		static_assert(std::is_integral<T>::value, "const_numeric_max can only be used with integers");
+		static const T value = std::numeric_limits<T>::is_signed
+			? (static_cast<T>(1) << (sizeof(T) * CHAR_BIT - 1)) - static_cast<T>(1)
+			: static_cast<T>(-1);
+	};
+
+#if defined(__GLIBCXX__)
+	typedef ::max_align_t std_max_align_t;      // libstdc++ forgot to add it to std:: for a while
+#else
+	typedef std::max_align_t std_max_align_t;   // Others (e.g. MSVC) insist it can *only* be accessed via std::
+#endif
+
+	// Some platforms have incorrectly set max_align_t to a type with <8 bytes alignment even while supporting
+	// 8-byte aligned scalar values (*cough* 32-bit iOS). Work around this with our own union. See issue #64.
+	typedef union {
+		std_max_align_t x;
+		long long y;
+		void* z;
+	} max_align_t;
+}
+
+// Default traits for the ConcurrentQueue. To change some of the
+// traits without re-implementing all of them, inherit from this
+// struct and shadow the declarations you wish to be different;
+// since the traits are used as a template type parameter, the
+// shadowed declarations will be used where defined, and the defaults
+// otherwise.
+struct ConcurrentQueueDefaultTraits
+{
+	// General-purpose size type. std::size_t is strongly recommended.
+	typedef std::size_t size_t;
+	
+	// The type used for the enqueue and dequeue indices. Must be at least as
+	// large as size_t. Should be significantly larger than the number of elements
+	// you expect to hold at once, especially if you have a high turnover rate;
+	// for example, on 32-bit x86, if you expect to have over a hundred million
+	// elements or pump several million elements through your queue in a very
+	// short space of time, using a 32-bit type *may* trigger a race condition.
+	// A 64-bit int type is recommended in that case, and in practice will
+	// prevent a race condition no matter the usage of the queue. Note that
+	// whether the queue is lock-free with a 64-int type depends on the whether
+	// std::atomic<std::uint64_t> is lock-free, which is platform-specific.
+	typedef std::size_t index_t;
+	
+	// Internally, all elements are enqueued and dequeued from multi-element
+	// blocks; this is the smallest controllable unit. If you expect few elements
+	// but many producers, a smaller block size should be favoured. For few producers
+	// and/or many elements, a larger block size is preferred. A sane default
+	// is provided. Must be a power of 2.
+	static const size_t BLOCK_SIZE = 32;
+	
+	// For explicit producers (i.e. when using a producer token), the block is
+	// checked for being empty by iterating through a list of flags, one per element.
+	// For large block sizes, this is too inefficient, and switching to an atomic
+	// counter-based approach is faster. The switch is made for block sizes strictly
+	// larger than this threshold.
+	static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = 32;
+	
+	// How many full blocks can be expected for a single explicit producer? This should
+	// reflect that number's maximum for optimal performance. Must be a power of 2.
+	static const size_t EXPLICIT_INITIAL_INDEX_SIZE = 32;
+	
+	// How many full blocks can be expected for a single implicit producer? This should
+	// reflect that number's maximum for optimal performance. Must be a power of 2.
+	static const size_t IMPLICIT_INITIAL_INDEX_SIZE = 32;
+	
+	// The initial size of the hash table mapping thread IDs to implicit producers.
+	// Note that the hash is resized every time it becomes half full.
+	// Must be a power of two, and either 0 or at least 1. If 0, implicit production
+	// (using the enqueue methods without an explicit producer token) is disabled.
+	static const size_t INITIAL_IMPLICIT_PRODUCER_HASH_SIZE = 32;
+	
+	// Controls the number of items that an explicit consumer (i.e. one with a token)
+	// must consume before it causes all consumers to rotate and move on to the next
+	// internal queue.
+	static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = 256;
+	
+	// The maximum number of elements (inclusive) that can be enqueued to a sub-queue.
+	// Enqueue operations that would cause this limit to be surpassed will fail. Note
+	// that this limit is enforced at the block level (for performance reasons), i.e.
+	// it's rounded up to the nearest block size.
+	static const size_t MAX_SUBQUEUE_SIZE = details::const_numeric_max<size_t>::value;
+	
+	
+#ifndef MCDBGQ_USE_RELACY
+	// Memory allocation can be customized if needed.
+	// malloc should return nullptr on failure, and handle alignment like std::malloc.
+#if defined(malloc) || defined(free)
+	// Gah, this is 2015, stop defining macros that break standard code already!
+	// Work around malloc/free being special macros:
+	static inline void* WORKAROUND_malloc(size_t size) { return malloc(size); }
+	static inline void WORKAROUND_free(void* ptr) { return free(ptr); }
+	static inline void* (malloc)(size_t size) { return WORKAROUND_malloc(size); }
+	static inline void (free)(void* ptr) { return WORKAROUND_free(ptr); }
+#else
+	static inline void* malloc(size_t size) { return std::malloc(size); }
+	static inline void free(void* ptr) { return std::free(ptr); }
+#endif
+#else
+	// Debug versions when running under the Relacy race detector (ignore
+	// these in user code)
+	static inline void* malloc(size_t size) { return rl::rl_malloc(size, $); }
+	static inline void free(void* ptr) { return rl::rl_free(ptr, $); }
+#endif
+};
+
+
+// When producing or consuming many elements, the most efficient way is to:
+//    1) Use one of the bulk-operation methods of the queue with a token
+//    2) Failing that, use the bulk-operation methods without a token
+//    3) Failing that, create a token and use that with the single-item methods
+//    4) Failing that, use the single-parameter methods of the queue
+// Having said that, don't create tokens willy-nilly -- ideally there should be
+// a maximum of one token per thread (of each kind).
+struct ProducerToken;
+struct ConsumerToken;
+
+template<typename T, typename Traits> class ConcurrentQueue;
+template<typename T, typename Traits> class BlockingConcurrentQueue;
+class ConcurrentQueueTests;
+
+
+namespace details
+{
+	struct ConcurrentQueueProducerTypelessBase
+	{
+		ConcurrentQueueProducerTypelessBase* next;
+		std::atomic<bool> inactive;
+		ProducerToken* token;
+		
+		ConcurrentQueueProducerTypelessBase()
+			: next(nullptr), inactive(false), token(nullptr)
+		{
+		}
+	};
+	
+	template<bool use32> struct _hash_32_or_64 {
+		static inline std::uint32_t hash(std::uint32_t h)
+		{
+			// MurmurHash3 finalizer -- see https://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp
+			// Since the thread ID is already unique, all we really want to do is propagate that
+			// uniqueness evenly across all the bits, so that we can use a subset of the bits while
+			// reducing collisions significantly
+			h ^= h >> 16;
+			h *= 0x85ebca6b;
+			h ^= h >> 13;
+			h *= 0xc2b2ae35;
+			return h ^ (h >> 16);
+		}
+	};
+	template<> struct _hash_32_or_64<1> {
+		static inline std::uint64_t hash(std::uint64_t h)
+		{
+			h ^= h >> 33;
+			h *= 0xff51afd7ed558ccd;
+			h ^= h >> 33;
+			h *= 0xc4ceb9fe1a85ec53;
+			return h ^ (h >> 33);
+		}
+	};
+	template<std::size_t size> struct hash_32_or_64 : public _hash_32_or_64<(size > 4)> {  };
+	
+	static inline size_t hash_thread_id(thread_id_t id)
+	{
+		static_assert(sizeof(thread_id_t) <= 8, "Expected a platform where thread IDs are at most 64-bit values");
+		return static_cast<size_t>(hash_32_or_64<sizeof(thread_id_converter<thread_id_t>::thread_id_hash_t)>::hash(
+			thread_id_converter<thread_id_t>::prehash(id)));
+	}
+	
+	template<typename T>
+	static inline bool circular_less_than(T a, T b)
+	{
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4554)
+#endif
+		static_assert(std::is_integral<T>::value && !std::numeric_limits<T>::is_signed, "circular_less_than is intended to be used only with unsigned integer types");
+		return static_cast<T>(a - b) > static_cast<T>(static_cast<T>(1) << static_cast<T>(sizeof(T) * CHAR_BIT - 1));
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+	}
+	
+	template<typename U>
+	static inline char* align_for(char* ptr)
+	{
+		const std::size_t alignment = std::alignment_of<U>::value;
+		return ptr + (alignment - (reinterpret_cast<std::uintptr_t>(ptr) % alignment)) % alignment;
+	}
+
+	template<typename T>
+	static inline T ceil_to_pow_2(T x)
+	{
+		static_assert(std::is_integral<T>::value && !std::numeric_limits<T>::is_signed, "ceil_to_pow_2 is intended to be used only with unsigned integer types");
+
+		// Adapted from http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+		--x;
+		x |= x >> 1;
+		x |= x >> 2;
+		x |= x >> 4;
+		for (std::size_t i = 1; i < sizeof(T); i <<= 1) {
+			x |= x >> (i << 3);
+		}
+		++x;
+		return x;
+	}
+	
+	template<typename T>
+	static inline void swap_relaxed(std::atomic<T>& left, std::atomic<T>& right)
+	{
+		T temp = std::move(left.load(std::memory_order_relaxed));
+		left.store(std::move(right.load(std::memory_order_relaxed)), std::memory_order_relaxed);
+		right.store(std::move(temp), std::memory_order_relaxed);
+	}
+	
+	template<typename T>
+	static inline T const& nomove(T const& x)
+	{
+		return x;
+	}
+	
+	template<bool Enable>
+	struct nomove_if
+	{
+		template<typename T>
+		static inline T const& eval(T const& x)
+		{
+			return x;
+		}
+	};
+	
+	template<>
+	struct nomove_if<false>
+	{
+		template<typename U>
+		static inline auto eval(U&& x)
+			-> decltype(std::forward<U>(x))
+		{
+			return std::forward<U>(x);
+		}
+	};
+	
+	template<typename It>
+	static inline auto deref_noexcept(It& it) MOODYCAMEL_NOEXCEPT -> decltype(*it)
+	{
+		return *it;
+	}
+	
+#if defined(__clang__) || !defined(__GNUC__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
+	template<typename T> struct is_trivially_destructible : std::is_trivially_destructible<T> { };
+#else
+	template<typename T> struct is_trivially_destructible : std::has_trivial_destructor<T> { };
+#endif
+	
+#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
+#ifdef MCDBGQ_USE_RELACY
+	typedef RelacyThreadExitListener ThreadExitListener;
+	typedef RelacyThreadExitNotifier ThreadExitNotifier;
+#else
+	struct ThreadExitListener
+	{
+		typedef void (*callback_t)(void*);
+		callback_t callback;
+		void* userData;
+		
+		ThreadExitListener* next;		// reserved for use by the ThreadExitNotifier
+	};
+	
+	
+	class ThreadExitNotifier
+	{
+	public:
+		static void subscribe(ThreadExitListener* listener)
+		{
+			auto& tlsInst = instance();
+			listener->next = tlsInst.tail;
+			tlsInst.tail = listener;
+		}
+		
+		static void unsubscribe(ThreadExitListener* listener)
+		{
+			auto& tlsInst = instance();
+			ThreadExitListener** prev = &tlsInst.tail;
+			for (auto ptr = tlsInst.tail; ptr != nullptr; ptr = ptr->next) {
+				if (ptr == listener) {
+					*prev = ptr->next;
+					break;
+				}
+				prev = &ptr->next;
+			}
+		}
+		
+	private:
+		ThreadExitNotifier() : tail(nullptr) { }
+		ThreadExitNotifier(ThreadExitNotifier const&) MOODYCAMEL_DELETE_FUNCTION;
+		ThreadExitNotifier& operator=(ThreadExitNotifier const&) MOODYCAMEL_DELETE_FUNCTION;
+		
+		~ThreadExitNotifier()
+		{
+			// This thread is about to exit, let everyone know!
+			assert(this == &instance() && "If this assert fails, you likely have a buggy compiler! Change the preprocessor conditions such that MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED is no longer defined.");
+			for (auto ptr = tail; ptr != nullptr; ptr = ptr->next) {
+				ptr->callback(ptr->userData);
+			}
+		}
+		
+		// Thread-local
+		static inline ThreadExitNotifier& instance()
+		{
+			static thread_local ThreadExitNotifier notifier;
+			return notifier;
+		}
+		
+	private:
+		ThreadExitListener* tail;
+	};
+#endif
+#endif
+	
+	template<typename T> struct static_is_lock_free_num { enum { value = 0 }; };
+	template<> struct static_is_lock_free_num<signed char> { enum { value = ATOMIC_CHAR_LOCK_FREE }; };
+	template<> struct static_is_lock_free_num<short> { enum { value = ATOMIC_SHORT_LOCK_FREE }; };
+	template<> struct static_is_lock_free_num<int> { enum { value = ATOMIC_INT_LOCK_FREE }; };
+	template<> struct static_is_lock_free_num<long> { enum { value = ATOMIC_LONG_LOCK_FREE }; };
+	template<> struct static_is_lock_free_num<long long> { enum { value = ATOMIC_LLONG_LOCK_FREE }; };
+	template<typename T> struct static_is_lock_free : static_is_lock_free_num<typename std::make_signed<T>::type> {  };
+	template<> struct static_is_lock_free<bool> { enum { value = ATOMIC_BOOL_LOCK_FREE }; };
+	template<typename U> struct static_is_lock_free<U*> { enum { value = ATOMIC_POINTER_LOCK_FREE }; };
+}
+
+
+struct ProducerToken
+{
+	template<typename T, typename Traits>
+	explicit ProducerToken(ConcurrentQueue<T, Traits>& queue);
+	
+	template<typename T, typename Traits>
+	explicit ProducerToken(BlockingConcurrentQueue<T, Traits>& queue);
+	
+	ProducerToken(ProducerToken&& other) MOODYCAMEL_NOEXCEPT
+		: producer(other.producer)
+	{
+		other.producer = nullptr;
+		if (producer != nullptr) {
+			producer->token = this;
+		}
+	}
+	
+	inline ProducerToken& operator=(ProducerToken&& other) MOODYCAMEL_NOEXCEPT
+	{
+		swap(other);
+		return *this;
+	}
+	
+	void swap(ProducerToken& other) MOODYCAMEL_NOEXCEPT
+	{
+		std::swap(producer, other.producer);
+		if (producer != nullptr) {
+			producer->token = this;
+		}
+		if (other.producer != nullptr) {
+			other.producer->token = &other;
+		}
+	}
+	
+	// A token is always valid unless:
+	//     1) Memory allocation failed during construction
+	//     2) It was moved via the move constructor
+	//        (Note: assignment does a swap, leaving both potentially valid)
+	//     3) The associated queue was destroyed
+	// Note that if valid() returns true, that only indicates
+	// that the token is valid for use with a specific queue,
+	// but not which one; that's up to the user to track.
+	inline bool valid() const { return producer != nullptr; }
+	
+	~ProducerToken()
+	{
+		if (producer != nullptr) {
+			producer->token = nullptr;
+			producer->inactive.store(true, std::memory_order_release);
+		}
+	}
+	
+	// Disable copying and assignment
+	ProducerToken(ProducerToken const&) MOODYCAMEL_DELETE_FUNCTION;
+	ProducerToken& operator=(ProducerToken const&) MOODYCAMEL_DELETE_FUNCTION;
+	
+private:
+	template<typename T, typename Traits> friend class ConcurrentQueue;
+	friend class ConcurrentQueueTests;
+	
+protected:
+	details::ConcurrentQueueProducerTypelessBase* producer;
+};
+
+
+struct ConsumerToken
+{
+	template<typename T, typename Traits>
+	explicit ConsumerToken(ConcurrentQueue<T, Traits>& q);
+	
+	template<typename T, typename Traits>
+	explicit ConsumerToken(BlockingConcurrentQueue<T, Traits>& q);
+	
+	ConsumerToken(ConsumerToken&& other) MOODYCAMEL_NOEXCEPT
+		: initialOffset(other.initialOffset), lastKnownGlobalOffset(other.lastKnownGlobalOffset), itemsConsumedFromCurrent(other.itemsConsumedFromCurrent), currentProducer(other.currentProducer), desiredProducer(other.desiredProducer)
+	{
+	}
+	
+	inline ConsumerToken& operator=(ConsumerToken&& other) MOODYCAMEL_NOEXCEPT
+	{
+		swap(other);
+		return *this;
+	}
+	
+	void swap(ConsumerToken& other) MOODYCAMEL_NOEXCEPT
+	{
+		std::swap(initialOffset, other.initialOffset);
+		std::swap(lastKnownGlobalOffset, other.lastKnownGlobalOffset);
+		std::swap(itemsConsumedFromCurrent, other.itemsConsumedFromCurrent);
+		std::swap(currentProducer, other.currentProducer);
+		std::swap(desiredProducer, other.desiredProducer);
+	}
+	
+	// Disable copying and assignment
+	ConsumerToken(ConsumerToken const&) MOODYCAMEL_DELETE_FUNCTION;
+	ConsumerToken& operator=(ConsumerToken const&) MOODYCAMEL_DELETE_FUNCTION;
+
+private:
+	template<typename T, typename Traits> friend class ConcurrentQueue;
+	friend class ConcurrentQueueTests;
+	
+private: // but shared with ConcurrentQueue
+	std::uint32_t initialOffset;
+	std::uint32_t lastKnownGlobalOffset;
+	std::uint32_t itemsConsumedFromCurrent;
+	details::ConcurrentQueueProducerTypelessBase* currentProducer;
+	details::ConcurrentQueueProducerTypelessBase* desiredProducer;
+};
+
+// Need to forward-declare this swap because it's in a namespace.
+// See http://stackoverflow.com/questions/4492062/why-does-a-c-friend-class-need-a-forward-declaration-only-in-other-namespaces
+template<typename T, typename Traits>
+inline void swap(typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP& a, typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP& b) MOODYCAMEL_NOEXCEPT;
+
+
+template<typename T, typename Traits = ConcurrentQueueDefaultTraits>
+class ConcurrentQueue
+{
+public:
+	typedef ::moodycamel::ProducerToken producer_token_t;
+	typedef ::moodycamel::ConsumerToken consumer_token_t;
+	
+	typedef typename Traits::index_t index_t;
+	typedef typename Traits::size_t size_t;
+	
+	static const size_t BLOCK_SIZE = static_cast<size_t>(Traits::BLOCK_SIZE);
+	static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = static_cast<size_t>(Traits::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD);
+	static const size_t EXPLICIT_INITIAL_INDEX_SIZE = static_cast<size_t>(Traits::EXPLICIT_INITIAL_INDEX_SIZE);
+	static const size_t IMPLICIT_INITIAL_INDEX_SIZE = static_cast<size_t>(Traits::IMPLICIT_INITIAL_INDEX_SIZE);
+	static const size_t INITIAL_IMPLICIT_PRODUCER_HASH_SIZE = static_cast<size_t>(Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE);
+	static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = static_cast<std::uint32_t>(Traits::EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE);
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4307)		// + integral constant overflow (that's what the ternary expression is for!)
+#pragma warning(disable: 4309)		// static_cast: Truncation of constant value
+#endif
+	static const size_t MAX_SUBQUEUE_SIZE = (details::const_numeric_max<size_t>::value - static_cast<size_t>(Traits::MAX_SUBQUEUE_SIZE) < BLOCK_SIZE) ? details::const_numeric_max<size_t>::value : ((static_cast<size_t>(Traits::MAX_SUBQUEUE_SIZE) + (BLOCK_SIZE - 1)) / BLOCK_SIZE * BLOCK_SIZE);
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+	static_assert(!std::numeric_limits<size_t>::is_signed && std::is_integral<size_t>::value, "Traits::size_t must be an unsigned integral type");
+	static_assert(!std::numeric_limits<index_t>::is_signed && std::is_integral<index_t>::value, "Traits::index_t must be an unsigned integral type");
+	static_assert(sizeof(index_t) >= sizeof(size_t), "Traits::index_t must be at least as wide as Traits::size_t");
+	static_assert((BLOCK_SIZE > 1) && !(BLOCK_SIZE & (BLOCK_SIZE - 1)), "Traits::BLOCK_SIZE must be a power of 2 (and at least 2)");
+	static_assert((EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD > 1) && !(EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD & (EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD - 1)), "Traits::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD must be a power of 2 (and greater than 1)");
+	static_assert((EXPLICIT_INITIAL_INDEX_SIZE > 1) && !(EXPLICIT_INITIAL_INDEX_SIZE & (EXPLICIT_INITIAL_INDEX_SIZE - 1)), "Traits::EXPLICIT_INITIAL_INDEX_SIZE must be a power of 2 (and greater than 1)");
+	static_assert((IMPLICIT_INITIAL_INDEX_SIZE > 1) && !(IMPLICIT_INITIAL_INDEX_SIZE & (IMPLICIT_INITIAL_INDEX_SIZE - 1)), "Traits::IMPLICIT_INITIAL_INDEX_SIZE must be a power of 2 (and greater than 1)");
+	static_assert((INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) || !(INITIAL_IMPLICIT_PRODUCER_HASH_SIZE & (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE - 1)), "Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE must be a power of 2");
+	static_assert(INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0 || INITIAL_IMPLICIT_PRODUCER_HASH_SIZE >= 1, "Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE must be at least 1 (or 0 to disable implicit enqueueing)");
+
+public:
+	// Creates a queue with at least `capacity` element slots; note that the
+	// actual number of elements that can be inserted without additional memory
+	// allocation depends on the number of producers and the block size (e.g. if
+	// the block size is equal to `capacity`, only a single block will be allocated
+	// up-front, which means only a single producer will be able to enqueue elements
+	// without an extra allocation -- blocks aren't shared between producers).
+	// This method is not thread safe -- it is up to the user to ensure that the
+	// queue is fully constructed before it starts being used by other threads (this
+	// includes making the memory effects of construction visible, possibly with a
+	// memory barrier).
+	explicit ConcurrentQueue(size_t capacity = 6 * BLOCK_SIZE)
+		: producerListTail(nullptr),
+		producerCount(0),
+		initialBlockPoolIndex(0),
+		nextExplicitConsumerId(0),
+		globalExplicitConsumerOffset(0)
+	{
+		implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
+		populate_initial_implicit_producer_hash();
+		populate_initial_block_list(capacity / BLOCK_SIZE + ((capacity & (BLOCK_SIZE - 1)) == 0 ? 0 : 1));
+		
+#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
+		// Track all the producers using a fully-resolved typed list for
+		// each kind; this makes it possible to debug them starting from
+		// the root queue object (otherwise wacky casts are needed that
+		// don't compile in the debugger's expression evaluator).
+		explicitProducers.store(nullptr, std::memory_order_relaxed);
+		implicitProducers.store(nullptr, std::memory_order_relaxed);
+#endif
+	}
+	
+	// Computes the correct amount of pre-allocated blocks for you based
+	// on the minimum number of elements you want available at any given
+	// time, and the maximum concurrent number of each type of producer.
+	ConcurrentQueue(size_t minCapacity, size_t maxExplicitProducers, size_t maxImplicitProducers)
+		: producerListTail(nullptr),
+		producerCount(0),
+		initialBlockPoolIndex(0),
+		nextExplicitConsumerId(0),
+		globalExplicitConsumerOffset(0)
+	{
+		implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
+		populate_initial_implicit_producer_hash();
+		size_t blocks = (((minCapacity + BLOCK_SIZE - 1) / BLOCK_SIZE) - 1) * (maxExplicitProducers + 1) + 2 * (maxExplicitProducers + maxImplicitProducers);
+		populate_initial_block_list(blocks);
+		
+#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
+		explicitProducers.store(nullptr, std::memory_order_relaxed);
+		implicitProducers.store(nullptr, std::memory_order_relaxed);
+#endif
+	}
+	
+	// Note: The queue should not be accessed concurrently while it's
+	// being deleted. It's up to the user to synchronize this.
+	// This method is not thread safe.
+	~ConcurrentQueue()
+	{
+		// Destroy producers
+		auto ptr = producerListTail.load(std::memory_order_relaxed);
+		while (ptr != nullptr) {
+			auto next = ptr->next_prod();
+			if (ptr->token != nullptr) {
+				ptr->token->producer = nullptr;
+			}
+			destroy(ptr);
+			ptr = next;
+		}
+		
+		// Destroy implicit producer hash tables
+		if (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE != 0) {
+			auto hash = implicitProducerHash.load(std::memory_order_relaxed);
+			while (hash != nullptr) {
+				auto prev = hash->prev;
+				if (prev != nullptr) {		// The last hash is part of this object and was not allocated dynamically
+					for (size_t i = 0; i != hash->capacity; ++i) {
+						hash->entries[i].~ImplicitProducerKVP();
+					}
+					hash->~ImplicitProducerHash();
+					(Traits::free)(hash);
+				}
+				hash = prev;
+			}
+		}
+		
+		// Destroy global free list
+		auto block = freeList.head_unsafe();
+		while (block != nullptr) {
+			auto next = block->freeListNext.load(std::memory_order_relaxed);
+			if (block->dynamicallyAllocated) {
+				destroy(block);
+			}
+			block = next;
+		}
+		
+		// Destroy initial free list
+		destroy_array(initialBlockPool, initialBlockPoolSize);
+	}
+
+	// Disable copying and copy assignment
+	ConcurrentQueue(ConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
+	ConcurrentQueue& operator=(ConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
+	
+	// Moving is supported, but note that it is *not* a thread-safe operation.
+	// Nobody can use the queue while it's being moved, and the memory effects
+	// of that move must be propagated to other threads before they can use it.
+	// Note: When a queue is moved, its tokens are still valid but can only be
+	// used with the destination queue (i.e. semantically they are moved along
+	// with the queue itself).
+	ConcurrentQueue(ConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
+		: producerListTail(other.producerListTail.load(std::memory_order_relaxed)),
+		producerCount(other.producerCount.load(std::memory_order_relaxed)),
+		initialBlockPoolIndex(other.initialBlockPoolIndex.load(std::memory_order_relaxed)),
+		initialBlockPool(other.initialBlockPool),
+		initialBlockPoolSize(other.initialBlockPoolSize),
+		freeList(std::move(other.freeList)),
+		nextExplicitConsumerId(other.nextExplicitConsumerId.load(std::memory_order_relaxed)),
+		globalExplicitConsumerOffset(other.globalExplicitConsumerOffset.load(std::memory_order_relaxed))
+	{
+		// Move the other one into this, and leave the other one as an empty queue
+		implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
+		populate_initial_implicit_producer_hash();
+		swap_implicit_producer_hashes(other);
+		
+		other.producerListTail.store(nullptr, std::memory_order_relaxed);
+		other.producerCount.store(0, std::memory_order_relaxed);
+		other.nextExplicitConsumerId.store(0, std::memory_order_relaxed);
+		other.globalExplicitConsumerOffset.store(0, std::memory_order_relaxed);
+		
+#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
+		explicitProducers.store(other.explicitProducers.load(std::memory_order_relaxed), std::memory_order_relaxed);
+		other.explicitProducers.store(nullptr, std::memory_order_relaxed);
+		implicitProducers.store(other.implicitProducers.load(std::memory_order_relaxed), std::memory_order_relaxed);
+		other.implicitProducers.store(nullptr, std::memory_order_relaxed);
+#endif
+		
+		other.initialBlockPoolIndex.store(0, std::memory_order_relaxed);
+		other.initialBlockPoolSize = 0;
+		other.initialBlockPool = nullptr;
+		
+		reown_producers();
+	}
+	
+	inline ConcurrentQueue& operator=(ConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
+	{
+		return swap_internal(other);
+	}
+	
+	// Swaps this queue's state with the other's. Not thread-safe.
+	// Swapping two queues does not invalidate their tokens, however
+	// the tokens that were created for one queue must be used with
+	// only the swapped queue (i.e. the tokens are tied to the
+	// queue's movable state, not the object itself).
+	inline void swap(ConcurrentQueue& other) MOODYCAMEL_NOEXCEPT
+	{
+		swap_internal(other);
+	}
+	
+private:
+	ConcurrentQueue& swap_internal(ConcurrentQueue& other)
+	{
+		if (this == &other) {
+			return *this;
+		}
+		
+		details::swap_relaxed(producerListTail, other.producerListTail);
+		details::swap_relaxed(producerCount, other.producerCount);
+		details::swap_relaxed(initialBlockPoolIndex, other.initialBlockPoolIndex);
+		std::swap(initialBlockPool, other.initialBlockPool);
+		std::swap(initialBlockPoolSize, other.initialBlockPoolSize);
+		freeList.swap(other.freeList);
+		details::swap_relaxed(nextExplicitConsumerId, other.nextExplicitConsumerId);
+		details::swap_relaxed(globalExplicitConsumerOffset, other.globalExplicitConsumerOffset);
+		
+		swap_implicit_producer_hashes(other);
+		
+		reown_producers();
+		other.reown_producers();
+		
+#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
+		details::swap_relaxed(explicitProducers, other.explicitProducers);
+		details::swap_relaxed(implicitProducers, other.implicitProducers);
+#endif
+		
+		return *this;
+	}
+	
+public:
+	// Enqueues a single item (by copying it).
+	// Allocates memory if required. Only fails if memory allocation fails (or implicit
+	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
+	// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+	// Thread-safe.
+	inline bool enqueue(T const& item)
+	{
+		if (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
+		return inner_enqueue<CanAlloc>(item);
+	}
+	
+	// Enqueues a single item (by moving it, if possible).
+	// Allocates memory if required. Only fails if memory allocation fails (or implicit
+	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
+	// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+	// Thread-safe.
+	inline bool enqueue(T&& item)
+	{
+		if (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
+		return inner_enqueue<CanAlloc>(std::move(item));
+	}
+	
+	// Enqueues a single item (by copying it) using an explicit producer token.
+	// Allocates memory if required. Only fails if memory allocation fails (or
+	// Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+	// Thread-safe.
+	inline bool enqueue(producer_token_t const& token, T const& item)
+	{
+		return inner_enqueue<CanAlloc>(token, item);
+	}
+	
+	// Enqueues a single item (by moving it, if possible) using an explicit producer token.
+	// Allocates memory if required. Only fails if memory allocation fails (or
+	// Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+	// Thread-safe.
+	inline bool enqueue(producer_token_t const& token, T&& item)
+	{
+		return inner_enqueue<CanAlloc>(token, std::move(item));
+	}
+	
+	// Enqueues several items.
+	// Allocates memory if required. Only fails if memory allocation fails (or
+	// implicit production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
+	// is 0, or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+	// Note: Use std::make_move_iterator if the elements should be moved instead of copied.
+	// Thread-safe.
+	template<typename It>
+	bool enqueue_bulk(It itemFirst, size_t count)
+	{
+		if (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
+		return inner_enqueue_bulk<CanAlloc>(itemFirst, count);
+	}
+	
+	// Enqueues several items using an explicit producer token.
+	// Allocates memory if required. Only fails if memory allocation fails
+	// (or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+	// Note: Use std::make_move_iterator if the elements should be moved
+	// instead of copied.
+	// Thread-safe.
+	template<typename It>
+	bool enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
+	{
+		return inner_enqueue_bulk<CanAlloc>(token, itemFirst, count);
+	}
+	
+	// Enqueues a single item (by copying it).
+	// Does not allocate memory. Fails if not enough room to enqueue (or implicit
+	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
+	// is 0).
+	// Thread-safe.
+	inline bool try_enqueue(T const& item)
+	{
+		if (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
+		return inner_enqueue<CannotAlloc>(item);
+	}
+	
+	// Enqueues a single item (by moving it, if possible).
+	// Does not allocate memory (except for one-time implicit producer).
+	// Fails if not enough room to enqueue (or implicit production is
+	// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
+	// Thread-safe.
+	inline bool try_enqueue(T&& item)
+	{
+		if (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
+		return inner_enqueue<CannotAlloc>(std::move(item));
+	}
+	
+	// Enqueues a single item (by copying it) using an explicit producer token.
+	// Does not allocate memory. Fails if not enough room to enqueue.
+	// Thread-safe.
+	inline bool try_enqueue(producer_token_t const& token, T const& item)
+	{
+		return inner_enqueue<CannotAlloc>(token, item);
+	}
+	
+	// Enqueues a single item (by moving it, if possible) using an explicit producer token.
+	// Does not allocate memory. Fails if not enough room to enqueue.
+	// Thread-safe.
+	inline bool try_enqueue(producer_token_t const& token, T&& item)
+	{
+		return inner_enqueue<CannotAlloc>(token, std::move(item));
+	}
+	
+	// Enqueues several items.
+	// Does not allocate memory (except for one-time implicit producer).
+	// Fails if not enough room to enqueue (or implicit production is
+	// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
+	// Note: Use std::make_move_iterator if the elements should be moved
+	// instead of copied.
+	// Thread-safe.
+	template<typename It>
+	bool try_enqueue_bulk(It itemFirst, size_t count)
+	{
+		if (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
+		return inner_enqueue_bulk<CannotAlloc>(itemFirst, count);
+	}
+	
+	// Enqueues several items using an explicit producer token.
+	// Does not allocate memory. Fails if not enough room to enqueue.
+	// Note: Use std::make_move_iterator if the elements should be moved
+	// instead of copied.
+	// Thread-safe.
+	template<typename It>
+	bool try_enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
+	{
+		return inner_enqueue_bulk<CannotAlloc>(token, itemFirst, count);
+	}
+	
+	
+	
+	// Attempts to dequeue from the queue.
+	// Returns false if all producer streams appeared empty at the time they
+	// were checked (so, the queue is likely but not guaranteed to be empty).
+	// Never allocates. Thread-safe.
+	template<typename U>
+	bool try_dequeue(U& item)
+	{
+		// Instead of simply trying each producer in turn (which could cause needless contention on the first
+		// producer), we score them heuristically.
+		size_t nonEmptyCount = 0;
+		ProducerBase* best = nullptr;
+		size_t bestSize = 0;
+		for (auto ptr = producerListTail.load(std::memory_order_acquire); nonEmptyCount < 3 && ptr != nullptr; ptr = ptr->next_prod()) {
+			auto size = ptr->size_approx();
+			if (size > 0) {
+				if (size > bestSize) {
+					bestSize = size;
+					best = ptr;
+				}
+				++nonEmptyCount;
+			}
+		}
+		
+		// If there was at least one non-empty queue but it appears empty at the time
+		// we try to dequeue from it, we need to make sure every queue's been tried
+		if (nonEmptyCount > 0) {
+			if (details::likely(best->dequeue(item))) {
+				return true;
+			}
+			for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
+				if (ptr != best && ptr->dequeue(item)) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+	
+	// Attempts to dequeue from the queue.
+	// Returns false if all producer streams appeared empty at the time they
+	// were checked (so, the queue is likely but not guaranteed to be empty).
+	// This differs from the try_dequeue(item) method in that this one does
+	// not attempt to reduce contention by interleaving the order that producer
+	// streams are dequeued from. So, using this method can reduce overall throughput
+	// under contention, but will give more predictable results in single-threaded
+	// consumer scenarios. This is mostly only useful for internal unit tests.
+	// Never allocates. Thread-safe.
+	template<typename U>
+	bool try_dequeue_non_interleaved(U& item)
+	{
+		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
+			if (ptr->dequeue(item)) {
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	// Attempts to dequeue from the queue using an explicit consumer token.
+	// Returns false if all producer streams appeared empty at the time they
+	// were checked (so, the queue is likely but not guaranteed to be empty).
+	// Never allocates. Thread-safe.
+	template<typename U>
+	bool try_dequeue(consumer_token_t& token, U& item)
+	{
+		// The idea is roughly as follows:
+		// Every 256 items from one producer, make everyone rotate (increase the global offset) -> this means the highest efficiency consumer dictates the rotation speed of everyone else, more or less
+		// If you see that the global offset has changed, you must reset your consumption counter and move to your designated place
+		// If there's no items where you're supposed to be, keep moving until you find a producer with some items
+		// If the global offset has not changed but you've run out of items to consume, move over from your current position until you find an producer with something in it
+		
+		if (token.desiredProducer == nullptr || token.lastKnownGlobalOffset != globalExplicitConsumerOffset.load(std::memory_order_relaxed)) {
+			if (!update_current_producer_after_rotation(token)) {
+				return false;
+			}
+		}
+		
+		// If there was at least one non-empty queue but it appears empty at the time
+		// we try to dequeue from it, we need to make sure every queue's been tried
+		if (static_cast<ProducerBase*>(token.currentProducer)->dequeue(item)) {
+			if (++token.itemsConsumedFromCurrent == EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE) {
+				globalExplicitConsumerOffset.fetch_add(1, std::memory_order_relaxed);
+			}
+			return true;
+		}
+		
+		auto tail = producerListTail.load(std::memory_order_acquire);
+		auto ptr = static_cast<ProducerBase*>(token.currentProducer)->next_prod();
+		if (ptr == nullptr) {
+			ptr = tail;
+		}
+		while (ptr != static_cast<ProducerBase*>(token.currentProducer)) {
+			if (ptr->dequeue(item)) {
+				token.currentProducer = ptr;
+				token.itemsConsumedFromCurrent = 1;
+				return true;
+			}
+			ptr = ptr->next_prod();
+			if (ptr == nullptr) {
+				ptr = tail;
+			}
+		}
+		return false;
+	}
+	
+	// Attempts to dequeue several elements from the queue.
+	// Returns the number of items actually dequeued.
+	// Returns 0 if all producer streams appeared empty at the time they
+	// were checked (so, the queue is likely but not guaranteed to be empty).
+	// Never allocates. Thread-safe.
+	template<typename It>
+	size_t try_dequeue_bulk(It itemFirst, size_t max)
+	{
+		size_t count = 0;
+		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
+			count += ptr->dequeue_bulk(itemFirst, max - count);
+			if (count == max) {
+				break;
+			}
+		}
+		return count;
+	}
+	
+	// Attempts to dequeue several elements from the queue using an explicit consumer token.
+	// Returns the number of items actually dequeued.
+	// Returns 0 if all producer streams appeared empty at the time they
+	// were checked (so, the queue is likely but not guaranteed to be empty).
+	// Never allocates. Thread-safe.
+	template<typename It>
+	size_t try_dequeue_bulk(consumer_token_t& token, It itemFirst, size_t max)
+	{
+		if (token.desiredProducer == nullptr || token.lastKnownGlobalOffset != globalExplicitConsumerOffset.load(std::memory_order_relaxed)) {
+			if (!update_current_producer_after_rotation(token)) {
+				return 0;
+			}
+		}
+		
+		size_t count = static_cast<ProducerBase*>(token.currentProducer)->dequeue_bulk(itemFirst, max);
+		if (count == max) {
+			if ((token.itemsConsumedFromCurrent += static_cast<std::uint32_t>(max)) >= EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE) {
+				globalExplicitConsumerOffset.fetch_add(1, std::memory_order_relaxed);
+			}
+			return max;
+		}
+		token.itemsConsumedFromCurrent += static_cast<std::uint32_t>(count);
+		max -= count;
+		
+		auto tail = producerListTail.load(std::memory_order_acquire);
+		auto ptr = static_cast<ProducerBase*>(token.currentProducer)->next_prod();
+		if (ptr == nullptr) {
+			ptr = tail;
+		}
+		while (ptr != static_cast<ProducerBase*>(token.currentProducer)) {
+			auto dequeued = ptr->dequeue_bulk(itemFirst, max);
+			count += dequeued;
+			if (dequeued != 0) {
+				token.currentProducer = ptr;
+				token.itemsConsumedFromCurrent = static_cast<std::uint32_t>(dequeued);
+			}
+			if (dequeued == max) {
+				break;
+			}
+			max -= dequeued;
+			ptr = ptr->next_prod();
+			if (ptr == nullptr) {
+				ptr = tail;
+			}
+		}
+		return count;
+	}
+	
+	
+	
+	// Attempts to dequeue from a specific producer's inner queue.
+	// If you happen to know which producer you want to dequeue from, this
+	// is significantly faster than using the general-case try_dequeue methods.
+	// Returns false if the producer's queue appeared empty at the time it
+	// was checked (so, the queue is likely but not guaranteed to be empty).
+	// Never allocates. Thread-safe.
+	template<typename U>
+	inline bool try_dequeue_from_producer(producer_token_t const& producer, U& item)
+	{
+		return static_cast<ExplicitProducer*>(producer.producer)->dequeue(item);
+	}
+	
+	// Attempts to dequeue several elements from a specific producer's inner queue.
+	// Returns the number of items actually dequeued.
+	// If you happen to know which producer you want to dequeue from, this
+	// is significantly faster than using the general-case try_dequeue methods.
+	// Returns 0 if the producer's queue appeared empty at the time it
+	// was checked (so, the queue is likely but not guaranteed to be empty).
+	// Never allocates. Thread-safe.
+	template<typename It>
+	inline size_t try_dequeue_bulk_from_producer(producer_token_t const& producer, It itemFirst, size_t max)
+	{
+		return static_cast<ExplicitProducer*>(producer.producer)->dequeue_bulk(itemFirst, max);
+	}
+	
+	
+	// Returns an estimate of the total number of elements currently in the queue. This
+	// estimate is only accurate if the queue has completely stabilized before it is called
+	// (i.e. all enqueue and dequeue operations have completed and their memory effects are
+	// visible on the calling thread, and no further operations start while this method is
+	// being called).
+	// Thread-safe.
+	size_t size_approx() const
+	{
+		size_t size = 0;
+		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
+			size += ptr->size_approx();
+		}
+		return size;
+	}
+	
+	
+	// Returns true if the underlying atomic variables used by
+	// the queue are lock-free (they should be on most platforms).
+	// Thread-safe.
+	static bool is_lock_free()
+	{
+		return
+			details::static_is_lock_free<bool>::value == 2 &&
+			details::static_is_lock_free<size_t>::value == 2 &&
+			details::static_is_lock_free<std::uint32_t>::value == 2 &&
+			details::static_is_lock_free<index_t>::value == 2 &&
+			details::static_is_lock_free<void*>::value == 2 &&
+			details::static_is_lock_free<typename details::thread_id_converter<details::thread_id_t>::thread_id_numeric_size_t>::value == 2;
+	}
+
+
+private:
+	friend struct ProducerToken;
+	friend struct ConsumerToken;
+	friend struct ExplicitProducer;
+	friend class ConcurrentQueueTests;
+		
+	enum AllocationMode { CanAlloc, CannotAlloc };
+	
+	
+	///////////////////////////////
+	// Queue methods
+	///////////////////////////////
+	
+	template<AllocationMode canAlloc, typename U>
+	inline bool inner_enqueue(producer_token_t const& token, U&& element)
+	{
+		return static_cast<ExplicitProducer*>(token.producer)->ConcurrentQueue::ExplicitProducer::template enqueue<canAlloc>(std::forward<U>(element));
+	}
+	
+	template<AllocationMode canAlloc, typename U>
+	inline bool inner_enqueue(U&& element)
+	{
+		auto producer = get_or_add_implicit_producer();
+		return producer == nullptr ? false : producer->ConcurrentQueue::ImplicitProducer::template enqueue<canAlloc>(std::forward<U>(element));
+	}
+	
+	template<AllocationMode canAlloc, typename It>
+	inline bool inner_enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
+	{
+		return static_cast<ExplicitProducer*>(token.producer)->ConcurrentQueue::ExplicitProducer::template enqueue_bulk<canAlloc>(itemFirst, count);
+	}
+	
+	template<AllocationMode canAlloc, typename It>
+	inline bool inner_enqueue_bulk(It itemFirst, size_t count)
+	{
+		auto producer = get_or_add_implicit_producer();
+		return producer == nullptr ? false : producer->ConcurrentQueue::ImplicitProducer::template enqueue_bulk<canAlloc>(itemFirst, count);
+	}
+	
+	inline bool update_current_producer_after_rotation(consumer_token_t& token)
+	{
+		// Ah, there's been a rotation, figure out where we should be!
+		auto tail = producerListTail.load(std::memory_order_acquire);
+		if (token.desiredProducer == nullptr && tail == nullptr) {
+			return false;
+		}
+		auto prodCount = producerCount.load(std::memory_order_relaxed);
+		auto globalOffset = globalExplicitConsumerOffset.load(std::memory_order_relaxed);
+		if (details::unlikely(token.desiredProducer == nullptr)) {
+			// Aha, first time we're dequeueing anything.
+			// Figure out our local position
+			// Note: offset is from start, not end, but we're traversing from end -- subtract from count first
+			std::uint32_t offset = prodCount - 1 - (token.initialOffset % prodCount);
+			token.desiredProducer = tail;
+			for (std::uint32_t i = 0; i != offset; ++i) {
+				token.desiredProducer = static_cast<ProducerBase*>(token.desiredProducer)->next_prod();
+				if (token.desiredProducer == nullptr) {
+					token.desiredProducer = tail;
+				}
+			}
+		}
+		
+		std::uint32_t delta = globalOffset - token.lastKnownGlobalOffset;
+		if (delta >= prodCount) {
+			delta = delta % prodCount;
+		}
+		for (std::uint32_t i = 0; i != delta; ++i) {
+			token.desiredProducer = static_cast<ProducerBase*>(token.desiredProducer)->next_prod();
+			if (token.desiredProducer == nullptr) {
+				token.desiredProducer = tail;
+			}
+		}
+		
+		token.lastKnownGlobalOffset = globalOffset;
+		token.currentProducer = token.desiredProducer;
+		token.itemsConsumedFromCurrent = 0;
+		return true;
+	}
+	
+	
+	///////////////////////////
+	// Free list
+	///////////////////////////
+	
+	template <typename N>
+	struct FreeListNode
+	{
+		FreeListNode() : freeListRefs(0), freeListNext(nullptr) { }
+		
+		std::atomic<std::uint32_t> freeListRefs;
+		std::atomic<N*> freeListNext;
+	};
+	
+	// A simple CAS-based lock-free free list. Not the fastest thing in the world under heavy contention, but
+	// simple and correct (assuming nodes are never freed until after the free list is destroyed), and fairly
+	// speedy under low contention.
+	template<typename N>		// N must inherit FreeListNode or have the same fields (and initialization of them)
+	struct FreeList
+	{
+		FreeList() : freeListHead(nullptr) { }
+		FreeList(FreeList&& other) : freeListHead(other.freeListHead.load(std::memory_order_relaxed)) { other.freeListHead.store(nullptr, std::memory_order_relaxed); }
+		void swap(FreeList& other) { details::swap_relaxed(freeListHead, other.freeListHead); }
+		
+		FreeList(FreeList const&) MOODYCAMEL_DELETE_FUNCTION;
+		FreeList& operator=(FreeList const&) MOODYCAMEL_DELETE_FUNCTION;
+		
+		inline void add(N* node)
+		{
+#if MCDBGQ_NOLOCKFREE_FREELIST
+			debug::DebugLock lock(mutex);
+#endif		
+			// We know that the should-be-on-freelist bit is 0 at this point, so it's safe to
+			// set it using a fetch_add
+			if (node->freeListRefs.fetch_add(SHOULD_BE_ON_FREELIST, std::memory_order_acq_rel) == 0) {
+				// Oh look! We were the last ones referencing this node, and we know
+				// we want to add it to the free list, so let's do it!
+		 		add_knowing_refcount_is_zero(node);
+			}
+		}
+		
+		inline N* try_get()
+		{
+#if MCDBGQ_NOLOCKFREE_FREELIST
+			debug::DebugLock lock(mutex);
+#endif		
+			auto head = freeListHead.load(std::memory_order_acquire);
+			while (head != nullptr) {
+				auto prevHead = head;
+				auto refs = head->freeListRefs.load(std::memory_order_relaxed);
+				if ((refs & REFS_MASK) == 0 || !head->freeListRefs.compare_exchange_strong(refs, refs + 1, std::memory_order_acquire, std::memory_order_relaxed)) {
+					head = freeListHead.load(std::memory_order_acquire);
+					continue;
+				}
+				
+				// Good, reference count has been incremented (it wasn't at zero), which means we can read the
+				// next and not worry about it changing between now and the time we do the CAS
+				auto next = head->freeListNext.load(std::memory_order_relaxed);
+				if (freeListHead.compare_exchange_strong(head, next, std::memory_order_acquire, std::memory_order_relaxed)) {
+					// Yay, got the node. This means it was on the list, which means shouldBeOnFreeList must be false no
+					// matter the refcount (because nobody else knows it's been taken off yet, it can't have been put back on).
+					assert((head->freeListRefs.load(std::memory_order_relaxed) & SHOULD_BE_ON_FREELIST) == 0);
+					
+					// Decrease refcount twice, once for our ref, and once for the list's ref
+					head->freeListRefs.fetch_sub(2, std::memory_order_release);
+					return head;
+				}
+				
+				// OK, the head must have changed on us, but we still need to decrease the refcount we increased.
+				// Note that we don't need to release any memory effects, but we do need to ensure that the reference
+				// count decrement happens-after the CAS on the head.
+				refs = prevHead->freeListRefs.fetch_sub(1, std::memory_order_acq_rel);
+				if (refs == SHOULD_BE_ON_FREELIST + 1) {
+					add_knowing_refcount_is_zero(prevHead);
+				}
+			}
+			
+			return nullptr;
+		}
+		
+		// Useful for traversing the list when there's no contention (e.g. to destroy remaining nodes)
+		N* head_unsafe() const { return freeListHead.load(std::memory_order_relaxed); }
+		
+	private:
+		inline void add_knowing_refcount_is_zero(N* node)
+		{
+			// Since the refcount is zero, and nobody can increase it once it's zero (except us, and we run
+			// only one copy of this method per node at a time, i.e. the single thread case), then we know
+			// we can safely change the next pointer of the node; however, once the refcount is back above
+			// zero, then other threads could increase it (happens under heavy contention, when the refcount
+			// goes to zero in between a load and a refcount increment of a node in try_get, then back up to
+			// something non-zero, then the refcount increment is done by the other thread) -- so, if the CAS
+			// to add the node to the actual list fails, decrease the refcount and leave the add operation to
+			// the next thread who puts the refcount back at zero (which could be us, hence the loop).
+			auto head = freeListHead.load(std::memory_order_relaxed);
+			while (true) {
+				node->freeListNext.store(head, std::memory_order_relaxed);
+				node->freeListRefs.store(1, std::memory_order_release);
+				if (!freeListHead.compare_exchange_strong(head, node, std::memory_order_release, std::memory_order_relaxed)) {
+					// Hmm, the add failed, but we can only try again when the refcount goes back to zero
+					if (node->freeListRefs.fetch_add(SHOULD_BE_ON_FREELIST - 1, std::memory_order_release) == 1) {
+						continue;
+					}
+				}
+				return;
+			}
+		}
+		
+	private:
+		// Implemented like a stack, but where node order doesn't matter (nodes are inserted out of order under contention)
+		std::atomic<N*> freeListHead;
+	
+	static const std::uint32_t REFS_MASK = 0x7FFFFFFF;
+	static const std::uint32_t SHOULD_BE_ON_FREELIST = 0x80000000;
+		
+#if MCDBGQ_NOLOCKFREE_FREELIST
+		debug::DebugMutex mutex;
+#endif
+	};
+	
+	
+	///////////////////////////
+	// Block
+	///////////////////////////
+	
+	enum InnerQueueContext { implicit_context = 0, explicit_context = 1 };
+	
+	struct Block
+	{
+		Block()
+			: next(nullptr), elementsCompletelyDequeued(0), freeListRefs(0), freeListNext(nullptr), shouldBeOnFreeList(false), dynamicallyAllocated(true)
+		{
+#if MCDBGQ_TRACKMEM
+			owner = nullptr;
+#endif
+		}
+		
+		template<InnerQueueContext context>
+		inline bool is_empty() const
+		{
+			if (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
+				// Check flags
+				for (size_t i = 0; i < BLOCK_SIZE; ++i) {
+					if (!emptyFlags[i].load(std::memory_order_relaxed)) {
+						return false;
+					}
+				}
+				
+				// Aha, empty; make sure we have all other memory effects that happened before the empty flags were set
+				std::atomic_thread_fence(std::memory_order_acquire);
+				return true;
+			}
+			else {
+				// Check counter
+				if (elementsCompletelyDequeued.load(std::memory_order_relaxed) == BLOCK_SIZE) {
+					std::atomic_thread_fence(std::memory_order_acquire);
+					return true;
+				}
+				assert(elementsCompletelyDequeued.load(std::memory_order_relaxed) <= BLOCK_SIZE);
+				return false;
+			}
+		}
+		
+		// Returns true if the block is now empty (does not apply in explicit context)
+		template<InnerQueueContext context>
+		inline bool set_empty(index_t i)
+		{
+			if (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
+				// Set flag
+				assert(!emptyFlags[BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1))].load(std::memory_order_relaxed));
+				emptyFlags[BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1))].store(true, std::memory_order_release);
+				return false;
+			}
+			else {
+				// Increment counter
+				auto prevVal = elementsCompletelyDequeued.fetch_add(1, std::memory_order_release);
+				assert(prevVal < BLOCK_SIZE);
+				return prevVal == BLOCK_SIZE - 1;
+			}
+		}
+		
+		// Sets multiple contiguous item statuses to 'empty' (assumes no wrapping and count > 0).
+		// Returns true if the block is now empty (does not apply in explicit context).
+		template<InnerQueueContext context>
+		inline bool set_many_empty(index_t i, size_t count)
+		{
+			if (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
+				// Set flags
+				std::atomic_thread_fence(std::memory_order_release);
+				i = BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1)) - count + 1;
+				for (size_t j = 0; j != count; ++j) {
+					assert(!emptyFlags[i + j].load(std::memory_order_relaxed));
+					emptyFlags[i + j].store(true, std::memory_order_relaxed);
+				}
+				return false;
+			}
+			else {
+				// Increment counter
+				auto prevVal = elementsCompletelyDequeued.fetch_add(count, std::memory_order_release);
+				assert(prevVal + count <= BLOCK_SIZE);
+				return prevVal + count == BLOCK_SIZE;
+			}
+		}
+		
+		template<InnerQueueContext context>
+		inline void set_all_empty()
+		{
+			if (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
+				// Set all flags
+				for (size_t i = 0; i != BLOCK_SIZE; ++i) {
+					emptyFlags[i].store(true, std::memory_order_relaxed);
+				}
+			}
+			else {
+				// Reset counter
+				elementsCompletelyDequeued.store(BLOCK_SIZE, std::memory_order_relaxed);
+			}
+		}
+		
+		template<InnerQueueContext context>
+		inline void reset_empty()
+		{
+			if (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
+				// Reset flags
+				for (size_t i = 0; i != BLOCK_SIZE; ++i) {
+					emptyFlags[i].store(false, std::memory_order_relaxed);
+				}
+			}
+			else {
+				// Reset counter
+				elementsCompletelyDequeued.store(0, std::memory_order_relaxed);
+			}
+		}
+		
+		inline T* operator[](index_t idx) MOODYCAMEL_NOEXCEPT { return static_cast<T*>(static_cast<void*>(elements)) + static_cast<size_t>(idx & static_cast<index_t>(BLOCK_SIZE - 1)); }
+		inline T const* operator[](index_t idx) const MOODYCAMEL_NOEXCEPT { return static_cast<T const*>(static_cast<void const*>(elements)) + static_cast<size_t>(idx & static_cast<index_t>(BLOCK_SIZE - 1)); }
+		
+	private:
+		// IMPORTANT: This must be the first member in Block, so that if T depends on the alignment of
+		// addresses returned by malloc, that alignment will be preserved. Apparently clang actually
+		// generates code that uses this assumption for AVX instructions in some cases. Ideally, we
+		// should also align Block to the alignment of T in case it's higher than malloc's 16-byte
+		// alignment, but this is hard to do in a cross-platform way. Assert for this case:
+		static_assert(std::alignment_of<T>::value <= std::alignment_of<details::max_align_t>::value, "The queue does not support super-aligned types at this time");
+		// Additionally, we need the alignment of Block itself to be a multiple of max_align_t since
+		// otherwise the appropriate padding will not be added at the end of Block in order to make
+		// arrays of Blocks all be properly aligned (not just the first one). We use a union to force
+		// this.
+		union {
+			char elements[sizeof(T) * BLOCK_SIZE];
+			details::max_align_t dummy;
+		};
+	public:
+		Block* next;
+		std::atomic<size_t> elementsCompletelyDequeued;
+		std::atomic<bool> emptyFlags[BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD ? BLOCK_SIZE : 1];
+	public:
+		std::atomic<std::uint32_t> freeListRefs;
+		std::atomic<Block*> freeListNext;
+		std::atomic<bool> shouldBeOnFreeList;
+		bool dynamicallyAllocated;		// Perhaps a better name for this would be 'isNotPartOfInitialBlockPool'
+		
+#if MCDBGQ_TRACKMEM
+		void* owner;
+#endif
+	};
+	static_assert(std::alignment_of<Block>::value >= std::alignment_of<details::max_align_t>::value, "Internal error: Blocks must be at least as aligned as the type they are wrapping");
+
+
+#if MCDBGQ_TRACKMEM
+public:
+	struct MemStats;
+private:
+#endif
+	
+	///////////////////////////
+	// Producer base
+	///////////////////////////
+	
+	struct ProducerBase : public details::ConcurrentQueueProducerTypelessBase
+	{
+		ProducerBase(ConcurrentQueue* parent_, bool isExplicit_) :
+			tailIndex(0),
+			headIndex(0),
+			dequeueOptimisticCount(0),
+			dequeueOvercommit(0),
+			tailBlock(nullptr),
+			isExplicit(isExplicit_),
+			parent(parent_)
+		{
+		}
+		
+		virtual ~ProducerBase() { };
+		
+		template<typename U>
+		inline bool dequeue(U& element)
+		{
+			if (isExplicit) {
+				return static_cast<ExplicitProducer*>(this)->dequeue(element);
+			}
+			else {
+				return static_cast<ImplicitProducer*>(this)->dequeue(element);
+			}
+		}
+		
+		template<typename It>
+		inline size_t dequeue_bulk(It& itemFirst, size_t max)
+		{
+			if (isExplicit) {
+				return static_cast<ExplicitProducer*>(this)->dequeue_bulk(itemFirst, max);
+			}
+			else {
+				return static_cast<ImplicitProducer*>(this)->dequeue_bulk(itemFirst, max);
+			}
+		}
+		
+		inline ProducerBase* next_prod() const { return static_cast<ProducerBase*>(next); }
+		
+		inline size_t size_approx() const
+		{
+			auto tail = tailIndex.load(std::memory_order_relaxed);
+			auto head = headIndex.load(std::memory_order_relaxed);
+			return details::circular_less_than(head, tail) ? static_cast<size_t>(tail - head) : 0;
+		}
+		
+		inline index_t getTail() const { return tailIndex.load(std::memory_order_relaxed); }
+	protected:
+		std::atomic<index_t> tailIndex;		// Where to enqueue to next
+		std::atomic<index_t> headIndex;		// Where to dequeue from next
+		
+		std::atomic<index_t> dequeueOptimisticCount;
+		std::atomic<index_t> dequeueOvercommit;
+		
+		Block* tailBlock;
+		
+	public:
+		bool isExplicit;
+		ConcurrentQueue* parent;
+		
+	protected:
+#if MCDBGQ_TRACKMEM
+		friend struct MemStats;
+#endif
+	};
+	
+	
+	///////////////////////////
+	// Explicit queue
+	///////////////////////////
+		
+	struct ExplicitProducer : public ProducerBase
+	{
+		explicit ExplicitProducer(ConcurrentQueue* parent) :
+			ProducerBase(parent, true),
+			blockIndex(nullptr),
+			pr_blockIndexSlotsUsed(0),
+			pr_blockIndexSize(EXPLICIT_INITIAL_INDEX_SIZE >> 1),
+			pr_blockIndexFront(0),
+			pr_blockIndexEntries(nullptr),
+			pr_blockIndexRaw(nullptr)
+		{
+			size_t poolBasedIndexSize = details::ceil_to_pow_2(parent->initialBlockPoolSize) >> 1;
+			if (poolBasedIndexSize > pr_blockIndexSize) {
+				pr_blockIndexSize = poolBasedIndexSize;
+			}
+			
+			new_block_index(0);		// This creates an index with double the number of current entries, i.e. EXPLICIT_INITIAL_INDEX_SIZE
+		}
+		
+		~ExplicitProducer()
+		{
+			// Destruct any elements not yet dequeued.
+			// Since we're in the destructor, we can assume all elements
+			// are either completely dequeued or completely not (no halfways).
+			if (this->tailBlock != nullptr) {		// Note this means there must be a block index too
+				// First find the block that's partially dequeued, if any
+				Block* halfDequeuedBlock = nullptr;
+				if ((this->headIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1)) != 0) {
+					// The head's not on a block boundary, meaning a block somewhere is partially dequeued
+					// (or the head block is the tail block and was fully dequeued, but the head/tail are still not on a boundary)
+					size_t i = (pr_blockIndexFront - pr_blockIndexSlotsUsed) & (pr_blockIndexSize - 1);
+					while (details::circular_less_than<index_t>(pr_blockIndexEntries[i].base + BLOCK_SIZE, this->headIndex.load(std::memory_order_relaxed))) {
+						i = (i + 1) & (pr_blockIndexSize - 1);
+					}
+					assert(details::circular_less_than<index_t>(pr_blockIndexEntries[i].base, this->headIndex.load(std::memory_order_relaxed)));
+					halfDequeuedBlock = pr_blockIndexEntries[i].block;
+				}
+				
+				// Start at the head block (note the first line in the loop gives us the head from the tail on the first iteration)
+				auto block = this->tailBlock;
+				do {
+					block = block->next;
+					if (block->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
+						continue;
+					}
+					
+					size_t i = 0;	// Offset into block
+					if (block == halfDequeuedBlock) {
+						i = static_cast<size_t>(this->headIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1));
+					}
+					
+					// Walk through all the items in the block; if this is the tail block, we need to stop when we reach the tail index
+					auto lastValidIndex = (this->tailIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 ? BLOCK_SIZE : static_cast<size_t>(this->tailIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1));
+					while (i != BLOCK_SIZE && (block != this->tailBlock || i != lastValidIndex)) {
+						(*block)[i++]->~T();
+					}
+				} while (block != this->tailBlock);
+			}
+			
+			// Destroy all blocks that we own
+			if (this->tailBlock != nullptr) {
+				auto block = this->tailBlock;
+				do {
+					auto nextBlock = block->next;
+					if (block->dynamicallyAllocated) {
+						destroy(block);
+					}
+					else {
+						this->parent->add_block_to_free_list(block);
+					}
+					block = nextBlock;
+				} while (block != this->tailBlock);
+			}
+			
+			// Destroy the block indices
+			auto header = static_cast<BlockIndexHeader*>(pr_blockIndexRaw);
+			while (header != nullptr) {
+				auto prev = static_cast<BlockIndexHeader*>(header->prev);
+				header->~BlockIndexHeader();
+				(Traits::free)(header);
+				header = prev;
+			}
+		}
+		
+		template<AllocationMode allocMode, typename U>
+		inline bool enqueue(U&& element)
+		{
+			index_t currentTailIndex = this->tailIndex.load(std::memory_order_relaxed);
+			index_t newTailIndex = 1 + currentTailIndex;
+			if ((currentTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
+				// We reached the end of a block, start a new one
+				auto startBlock = this->tailBlock;
+				auto originalBlockIndexSlotsUsed = pr_blockIndexSlotsUsed;
+				if (this->tailBlock != nullptr && this->tailBlock->next->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
+					// We can re-use the block ahead of us, it's empty!					
+					this->tailBlock = this->tailBlock->next;
+					this->tailBlock->ConcurrentQueue::Block::template reset_empty<explicit_context>();
+					
+					// We'll put the block on the block index (guaranteed to be room since we're conceptually removing the
+					// last block from it first -- except instead of removing then adding, we can just overwrite).
+					// Note that there must be a valid block index here, since even if allocation failed in the ctor,
+					// it would have been re-attempted when adding the first block to the queue; since there is such
+					// a block, a block index must have been successfully allocated.
+				}
+				else {
+					// Whatever head value we see here is >= the last value we saw here (relatively),
+					// and <= its current value. Since we have the most recent tail, the head must be
+					// <= to it.
+					auto head = this->headIndex.load(std::memory_order_relaxed);
+					assert(!details::circular_less_than<index_t>(currentTailIndex, head));
+					if (!details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE)
+						|| (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head))) {
+						// We can't enqueue in another block because there's not enough leeway -- the
+						// tail could surpass the head by the time the block fills up! (Or we'll exceed
+						// the size limit, if the second part of the condition was true.)
+						return false;
+					}
+					// We're going to need a new block; check that the block index has room
+					if (pr_blockIndexRaw == nullptr || pr_blockIndexSlotsUsed == pr_blockIndexSize) {
+						// Hmm, the circular block index is already full -- we'll need
+						// to allocate a new index. Note pr_blockIndexRaw can only be nullptr if
+						// the initial allocation failed in the constructor.
+						
+						if (allocMode == CannotAlloc || !new_block_index(pr_blockIndexSlotsUsed)) {
+							return false;
+						}
+					}
+					
+					// Insert a new block in the circular linked list
+					auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
+					if (newBlock == nullptr) {
+						return false;
+					}
+#if MCDBGQ_TRACKMEM
+					newBlock->owner = this;
+#endif
+					newBlock->ConcurrentQueue::Block::template reset_empty<explicit_context>();
+					if (this->tailBlock == nullptr) {
+						newBlock->next = newBlock;
+					}
+					else {
+						newBlock->next = this->tailBlock->next;
+						this->tailBlock->next = newBlock;
+					}
+					this->tailBlock = newBlock;
+					++pr_blockIndexSlotsUsed;
+				}
+				
+				if (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (nullptr) T(std::forward<U>(element)))) {
+					// The constructor may throw. We want the element not to appear in the queue in
+					// that case (without corrupting the queue):
+					MOODYCAMEL_TRY {
+						new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
+					}
+					MOODYCAMEL_CATCH (...) {
+						// Revert change to the current block, but leave the new block available
+						// for next time
+						pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
+						this->tailBlock = startBlock == nullptr ? this->tailBlock : startBlock;
+						MOODYCAMEL_RETHROW;
+					}
+				}
+				else {
+					(void)startBlock;
+					(void)originalBlockIndexSlotsUsed;
+				}
+				
+				// Add block to block index
+				auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
+				entry.base = currentTailIndex;
+				entry.block = this->tailBlock;
+				blockIndex.load(std::memory_order_relaxed)->front.store(pr_blockIndexFront, std::memory_order_release);
+				pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
+				
+				if (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (nullptr) T(std::forward<U>(element)))) {
+					this->tailIndex.store(newTailIndex, std::memory_order_release);
+					return true;
+				}
+			}
+			
+			// Enqueue
+			new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
+			
+			this->tailIndex.store(newTailIndex, std::memory_order_release);
+			return true;
+		}
+		
+		template<typename U>
+		bool dequeue(U& element)
+		{
+			auto tail = this->tailIndex.load(std::memory_order_relaxed);
+			auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
+			if (details::circular_less_than<index_t>(this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit, tail)) {
+				// Might be something to dequeue, let's give it a try
+				
+				// Note that this if is purely for performance purposes in the common case when the queue is
+				// empty and the values are eventually consistent -- we may enter here spuriously.
+				
+				// Note that whatever the values of overcommit and tail are, they are not going to change (unless we
+				// change them) and must be the same value at this point (inside the if) as when the if condition was
+				// evaluated.
+
+				// We insert an acquire fence here to synchronize-with the release upon incrementing dequeueOvercommit below.
+				// This ensures that whatever the value we got loaded into overcommit, the load of dequeueOptisticCount in
+				// the fetch_add below will result in a value at least as recent as that (and therefore at least as large).
+				// Note that I believe a compiler (signal) fence here would be sufficient due to the nature of fetch_add (all
+				// read-modify-write operations are guaranteed to work on the latest value in the modification order), but
+				// unfortunately that can't be shown to be correct using only the C++11 standard.
+				// See http://stackoverflow.com/questions/18223161/what-are-the-c11-memory-ordering-guarantees-in-this-corner-case
+				std::atomic_thread_fence(std::memory_order_acquire);
+				
+				// Increment optimistic counter, then check if it went over the boundary
+				auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(1, std::memory_order_relaxed);
+				
+				// Note that since dequeueOvercommit must be <= dequeueOptimisticCount (because dequeueOvercommit is only ever
+				// incremented after dequeueOptimisticCount -- this is enforced in the `else` block below), and since we now
+				// have a version of dequeueOptimisticCount that is at least as recent as overcommit (due to the release upon
+				// incrementing dequeueOvercommit and the acquire above that synchronizes with it), overcommit <= myDequeueCount.
+				assert(overcommit <= myDequeueCount);
+				
+				// Note that we reload tail here in case it changed; it will be the same value as before or greater, since
+				// this load is sequenced after (happens after) the earlier load above. This is supported by read-read
+				// coherency (as defined in the standard), explained here: http://en.cppreference.com/w/cpp/atomic/memory_order
+				tail = this->tailIndex.load(std::memory_order_acquire);
+				if (details::likely(details::circular_less_than<index_t>(myDequeueCount - overcommit, tail))) {
+					// Guaranteed to be at least one element to dequeue!
+					
+					// Get the index. Note that since there's guaranteed to be at least one element, this
+					// will never exceed tail. We need to do an acquire-release fence here since it's possible
+					// that whatever condition got us to this point was for an earlier enqueued element (that
+					// we already see the memory effects for), but that by the time we increment somebody else
+					// has incremented it, and we need to see the memory effects for *that* element, which is
+					// in such a case is necessarily visible on the thread that incremented it in the first
+					// place with the more current condition (they must have acquired a tail that is at least
+					// as recent).
+					auto index = this->headIndex.fetch_add(1, std::memory_order_acq_rel);
+					
+					
+					// Determine which block the element is in
+					
+					auto localBlockIndex = blockIndex.load(std::memory_order_acquire);
+					auto localBlockIndexHead = localBlockIndex->front.load(std::memory_order_acquire);
+					
+					// We need to be careful here about subtracting and dividing because of index wrap-around.
+					// When an index wraps, we need to preserve the sign of the offset when dividing it by the
+					// block size (in order to get a correct signed block count offset in all cases):
+					auto headBase = localBlockIndex->entries[localBlockIndexHead].base;
+					auto blockBaseIndex = index & ~static_cast<index_t>(BLOCK_SIZE - 1);
+					auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(blockBaseIndex - headBase) / BLOCK_SIZE);
+					auto block = localBlockIndex->entries[(localBlockIndexHead + offset) & (localBlockIndex->size - 1)].block;
+					
+					// Dequeue
+					auto& el = *((*block)[index]);
+					if (!MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, element = std::move(el))) {
+						// Make sure the element is still fully dequeued and destroyed even if the assignment
+						// throws
+						struct Guard {
+							Block* block;
+							index_t index;
+							
+							~Guard()
+							{
+								(*block)[index]->~T();
+								block->ConcurrentQueue::Block::template set_empty<explicit_context>(index);
+							}
+						} guard = { block, index };
+						
+						element = std::move(el);
+					}
+					else {
+						element = std::move(el);
+						el.~T();
+						block->ConcurrentQueue::Block::template set_empty<explicit_context>(index);
+					}
+					
+					return true;
+				}
+				else {
+					// Wasn't anything to dequeue after all; make the effective dequeue count eventually consistent
+					this->dequeueOvercommit.fetch_add(1, std::memory_order_release);		// Release so that the fetch_add on dequeueOptimisticCount is guaranteed to happen before this write
+				}
+			}
+		
+			return false;
+		}
+		
+		template<AllocationMode allocMode, typename It>
+		bool enqueue_bulk(It itemFirst, size_t count)
+		{
+			// First, we need to make sure we have enough room to enqueue all of the elements;
+			// this means pre-allocating blocks and putting them in the block index (but only if
+			// all the allocations succeeded).
+			index_t startTailIndex = this->tailIndex.load(std::memory_order_relaxed);
+			auto startBlock = this->tailBlock;
+			auto originalBlockIndexFront = pr_blockIndexFront;
+			auto originalBlockIndexSlotsUsed = pr_blockIndexSlotsUsed;
+			
+			Block* firstAllocatedBlock = nullptr;
+			
+			// Figure out how many blocks we'll need to allocate, and do so
+			size_t blockBaseDiff = ((startTailIndex + count - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1)) - ((startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1));
+			index_t currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
+			if (blockBaseDiff > 0) {
+				// Allocate as many blocks as possible from ahead
+				while (blockBaseDiff > 0 && this->tailBlock != nullptr && this->tailBlock->next != firstAllocatedBlock && this->tailBlock->next->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
+					blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
+					currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
+					
+					this->tailBlock = this->tailBlock->next;
+					firstAllocatedBlock = firstAllocatedBlock == nullptr ? this->tailBlock : firstAllocatedBlock;
+					
+					auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
+					entry.base = currentTailIndex;
+					entry.block = this->tailBlock;
+					pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
+				}
+				
+				// Now allocate as many blocks as necessary from the block pool
+				while (blockBaseDiff > 0) {
+					blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
+					currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
+					
+					auto head = this->headIndex.load(std::memory_order_relaxed);
+					assert(!details::circular_less_than<index_t>(currentTailIndex, head));
+					bool full = !details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head));
+					if (pr_blockIndexRaw == nullptr || pr_blockIndexSlotsUsed == pr_blockIndexSize || full) {
+						if (allocMode == CannotAlloc || full || !new_block_index(originalBlockIndexSlotsUsed)) {
+							// Failed to allocate, undo changes (but keep injected blocks)
+							pr_blockIndexFront = originalBlockIndexFront;
+							pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
+							this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
+							return false;
+						}
+						
+						// pr_blockIndexFront is updated inside new_block_index, so we need to
+						// update our fallback value too (since we keep the new index even if we
+						// later fail)
+						originalBlockIndexFront = originalBlockIndexSlotsUsed;
+					}
+					
+					// Insert a new block in the circular linked list
+					auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
+					if (newBlock == nullptr) {
+						pr_blockIndexFront = originalBlockIndexFront;
+						pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
+						this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
+						return false;
+					}
+					
+#if MCDBGQ_TRACKMEM
+					newBlock->owner = this;
+#endif
+					newBlock->ConcurrentQueue::Block::template set_all_empty<explicit_context>();
+					if (this->tailBlock == nullptr) {
+						newBlock->next = newBlock;
+					}
+					else {
+						newBlock->next = this->tailBlock->next;
+						this->tailBlock->next = newBlock;
+					}
+					this->tailBlock = newBlock;
+					firstAllocatedBlock = firstAllocatedBlock == nullptr ? this->tailBlock : firstAllocatedBlock;
+					
+					++pr_blockIndexSlotsUsed;
+					
+					auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
+					entry.base = currentTailIndex;
+					entry.block = this->tailBlock;
+					pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
+				}
+				
+				// Excellent, all allocations succeeded. Reset each block's emptiness before we fill them up, and
+				// publish the new block index front
+				auto block = firstAllocatedBlock;
+				while (true) {
+					block->ConcurrentQueue::Block::template reset_empty<explicit_context>();
+					if (block == this->tailBlock) {
+						break;
+					}
+					block = block->next;
+				}
+				
+				if (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (nullptr) T(details::deref_noexcept(itemFirst)))) {
+					blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);
+				}
+			}
+			
+			// Enqueue, one block at a time
+			index_t newTailIndex = startTailIndex + static_cast<index_t>(count);
+			currentTailIndex = startTailIndex;
+			auto endBlock = this->tailBlock;
+			this->tailBlock = startBlock;
+			assert((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr || count == 0);
+			if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 && firstAllocatedBlock != nullptr) {
+				this->tailBlock = firstAllocatedBlock;
+			}
+			while (true) {
+				auto stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
+				if (details::circular_less_than<index_t>(newTailIndex, stopIndex)) {
+					stopIndex = newTailIndex;
+				}
+				if (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (nullptr) T(details::deref_noexcept(itemFirst)))) {
+					while (currentTailIndex != stopIndex) {
+						new ((*this->tailBlock)[currentTailIndex++]) T(*itemFirst++);
+					}
+				}
+				else {
+					MOODYCAMEL_TRY {
+						while (currentTailIndex != stopIndex) {
+							// Must use copy constructor even if move constructor is available
+							// because we may have to revert if there's an exception.
+							// Sorry about the horrible templated next line, but it was the only way
+							// to disable moving *at compile time*, which is important because a type
+							// may only define a (noexcept) move constructor, and so calls to the
+							// cctor will not compile, even if they are in an if branch that will never
+							// be executed
+							new ((*this->tailBlock)[currentTailIndex]) T(details::nomove_if<(bool)!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (nullptr) T(details::deref_noexcept(itemFirst)))>::eval(*itemFirst));
+							++currentTailIndex;
+							++itemFirst;
+						}
+					}
+					MOODYCAMEL_CATCH (...) {
+						// Oh dear, an exception's been thrown -- destroy the elements that
+						// were enqueued so far and revert the entire bulk operation (we'll keep
+						// any allocated blocks in our linked list for later, though).
+						auto constructedStopIndex = currentTailIndex;
+						auto lastBlockEnqueued = this->tailBlock;
+						
+						pr_blockIndexFront = originalBlockIndexFront;
+						pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
+						this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
+						
+						if (!details::is_trivially_destructible<T>::value) {
+							auto block = startBlock;
+							if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
+								block = firstAllocatedBlock;
+							}
+							currentTailIndex = startTailIndex;
+							while (true) {
+								stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
+								if (details::circular_less_than<index_t>(constructedStopIndex, stopIndex)) {
+									stopIndex = constructedStopIndex;
+								}
+								while (currentTailIndex != stopIndex) {
+									(*block)[currentTailIndex++]->~T();
+								}
+								if (block == lastBlockEnqueued) {
+									break;
+								}
+								block = block->next;
+							}
+						}
+						MOODYCAMEL_RETHROW;
+					}
+				}
+				
+				if (this->tailBlock == endBlock) {
+					assert(currentTailIndex == newTailIndex);
+					break;
+				}
+				this->tailBlock = this->tailBlock->next;
+			}
+			
+			if (!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (nullptr) T(details::deref_noexcept(itemFirst))) && firstAllocatedBlock != nullptr) {
+				blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);
+			}
+			
+			this->tailIndex.store(newTailIndex, std::memory_order_release);
+			return true;
+		}
+		
+		template<typename It>
+		size_t dequeue_bulk(It& itemFirst, size_t max)
+		{
+			auto tail = this->tailIndex.load(std::memory_order_relaxed);
+			auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
+			auto desiredCount = static_cast<size_t>(tail - (this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit));
+			if (details::circular_less_than<size_t>(0, desiredCount)) {
+				desiredCount = desiredCount < max ? desiredCount : max;
+				std::atomic_thread_fence(std::memory_order_acquire);
+				
+				auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(desiredCount, std::memory_order_relaxed);
+				assert(overcommit <= myDequeueCount);
+				
+				tail = this->tailIndex.load(std::memory_order_acquire);
+				auto actualCount = static_cast<size_t>(tail - (myDequeueCount - overcommit));
+				if (details::circular_less_than<size_t>(0, actualCount)) {
+					actualCount = desiredCount < actualCount ? desiredCount : actualCount;
+					if (actualCount < desiredCount) {
+						this->dequeueOvercommit.fetch_add(desiredCount - actualCount, std::memory_order_release);
+					}
+					
+					// Get the first index. Note that since there's guaranteed to be at least actualCount elements, this
+					// will never exceed tail.
+					auto firstIndex = this->headIndex.fetch_add(actualCount, std::memory_order_acq_rel);
+					
+					// Determine which block the first element is in
+					auto localBlockIndex = blockIndex.load(std::memory_order_acquire);
+					auto localBlockIndexHead = localBlockIndex->front.load(std::memory_order_acquire);
+					
+					auto headBase = localBlockIndex->entries[localBlockIndexHead].base;
+					auto firstBlockBaseIndex = firstIndex & ~static_cast<index_t>(BLOCK_SIZE - 1);
+					auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(firstBlockBaseIndex - headBase) / BLOCK_SIZE);
+					auto indexIndex = (localBlockIndexHead + offset) & (localBlockIndex->size - 1);
+					
+					// Iterate the blocks and dequeue
+					auto index = firstIndex;
+					do {
+						auto firstIndexInBlock = index;
+						auto endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
+						endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
+						auto block = localBlockIndex->entries[indexIndex].block;
+						if (MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, details::deref_noexcept(itemFirst) = std::move((*(*block)[index])))) {
+							while (index != endIndex) {
+								auto& el = *((*block)[index]);
+								*itemFirst++ = std::move(el);
+								el.~T();
+								++index;
+							}
+						}
+						else {
+							MOODYCAMEL_TRY {
+								while (index != endIndex) {
+									auto& el = *((*block)[index]);
+									*itemFirst = std::move(el);
+									++itemFirst;
+									el.~T();
+									++index;
+								}
+							}
+							MOODYCAMEL_CATCH (...) {
+								// It's too late to revert the dequeue, but we can make sure that all
+								// the dequeued objects are properly destroyed and the block index
+								// (and empty count) are properly updated before we propagate the exception
+								do {
+									block = localBlockIndex->entries[indexIndex].block;
+									while (index != endIndex) {
+										(*block)[index++]->~T();
+									}
+									block->ConcurrentQueue::Block::template set_many_empty<explicit_context>(firstIndexInBlock, static_cast<size_t>(endIndex - firstIndexInBlock));
+									indexIndex = (indexIndex + 1) & (localBlockIndex->size - 1);
+									
+									firstIndexInBlock = index;
+									endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
+									endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
+								} while (index != firstIndex + actualCount);
+								
+								MOODYCAMEL_RETHROW;
+							}
+						}
+						block->ConcurrentQueue::Block::template set_many_empty<explicit_context>(firstIndexInBlock, static_cast<size_t>(endIndex - firstIndexInBlock));
+						indexIndex = (indexIndex + 1) & (localBlockIndex->size - 1);
+					} while (index != firstIndex + actualCount);
+					
+					return actualCount;
+				}
+				else {
+					// Wasn't anything to dequeue after all; make the effective dequeue count eventually consistent
+					this->dequeueOvercommit.fetch_add(desiredCount, std::memory_order_release);
+				}
+			}
+			
+			return 0;
+		}
+		
+	private:
+		struct BlockIndexEntry
+		{
+			index_t base;
+			Block* block;
+		};
+		
+		struct BlockIndexHeader
+		{
+			size_t size;
+			std::atomic<size_t> front;		// Current slot (not next, like pr_blockIndexFront)
+			BlockIndexEntry* entries;
+			void* prev;
+		};
+		
+		
+		bool new_block_index(size_t numberOfFilledSlotsToExpose)
+		{
+			auto prevBlockSizeMask = pr_blockIndexSize - 1;
+			
+			// Create the new block
+			pr_blockIndexSize <<= 1;
+			auto newRawPtr = static_cast<char*>((Traits::malloc)(sizeof(BlockIndexHeader) + std::alignment_of<BlockIndexEntry>::value - 1 + sizeof(BlockIndexEntry) * pr_blockIndexSize));
+			if (newRawPtr == nullptr) {
+				pr_blockIndexSize >>= 1;		// Reset to allow graceful retry
+				return false;
+			}
+			
+			auto newBlockIndexEntries = reinterpret_cast<BlockIndexEntry*>(details::align_for<BlockIndexEntry>(newRawPtr + sizeof(BlockIndexHeader)));
+			
+			// Copy in all the old indices, if any
+			size_t j = 0;
+			if (pr_blockIndexSlotsUsed != 0) {
+				auto i = (pr_blockIndexFront - pr_blockIndexSlotsUsed) & prevBlockSizeMask;
+				do {
+					newBlockIndexEntries[j++] = pr_blockIndexEntries[i];
+					i = (i + 1) & prevBlockSizeMask;
+				} while (i != pr_blockIndexFront);
+			}
+			
+			// Update everything
+			auto header = new (newRawPtr) BlockIndexHeader;
+			header->size = pr_blockIndexSize;
+			header->front.store(numberOfFilledSlotsToExpose - 1, std::memory_order_relaxed);
+			header->entries = newBlockIndexEntries;
+			header->prev = pr_blockIndexRaw;		// we link the new block to the old one so we can free it later
+			
+			pr_blockIndexFront = j;
+			pr_blockIndexEntries = newBlockIndexEntries;
+			pr_blockIndexRaw = newRawPtr;
+			blockIndex.store(header, std::memory_order_release);
+			
+			return true;
+		}
+		
+	private:
+		std::atomic<BlockIndexHeader*> blockIndex;
+		
+		// To be used by producer only -- consumer must use the ones in referenced by blockIndex
+		size_t pr_blockIndexSlotsUsed;
+		size_t pr_blockIndexSize;
+		size_t pr_blockIndexFront;		// Next slot (not current)
+		BlockIndexEntry* pr_blockIndexEntries;
+		void* pr_blockIndexRaw;
+		
+#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
+	public:
+		ExplicitProducer* nextExplicitProducer;
+	private:
+#endif
+		
+#if MCDBGQ_TRACKMEM
+		friend struct MemStats;
+#endif
+	};
+	
+	
+	//////////////////////////////////
+	// Implicit queue
+	//////////////////////////////////
+	
+	struct ImplicitProducer : public ProducerBase
+	{			
+		ImplicitProducer(ConcurrentQueue* parent) :
+			ProducerBase(parent, false),
+			nextBlockIndexCapacity(IMPLICIT_INITIAL_INDEX_SIZE),
+			blockIndex(nullptr)
+		{
+			new_block_index();
+		}
+		
+		~ImplicitProducer()
+		{
+			// Note that since we're in the destructor we can assume that all enqueue/dequeue operations
+			// completed already; this means that all undequeued elements are placed contiguously across
+			// contiguous blocks, and that only the first and last remaining blocks can be only partially
+			// empty (all other remaining blocks must be completely full).
+			
+#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
+			// Unregister ourselves for thread termination notification
+			if (!this->inactive.load(std::memory_order_relaxed)) {
+				details::ThreadExitNotifier::unsubscribe(&threadExitListener);
+			}
+#endif
+			
+			// Destroy all remaining elements!
+			auto tail = this->tailIndex.load(std::memory_order_relaxed);
+			auto index = this->headIndex.load(std::memory_order_relaxed);
+			Block* block = nullptr;
+			assert(index == tail || details::circular_less_than(index, tail));
+			bool forceFreeLastBlock = index != tail;		// If we enter the loop, then the last (tail) block will not be freed
+			while (index != tail) {
+				if ((index & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 || block == nullptr) {
+					if (block != nullptr) {
+						// Free the old block
+						this->parent->add_block_to_free_list(block);
+					}
+					
+					block = get_block_index_entry_for_index(index)->value.load(std::memory_order_relaxed);
+				}
+				
+				((*block)[index])->~T();
+				++index;
+			}
+			// Even if the queue is empty, there's still one block that's not on the free list
+			// (unless the head index reached the end of it, in which case the tail will be poised
+			// to create a new block).
+			if (this->tailBlock != nullptr && (forceFreeLastBlock || (tail & static_cast<index_t>(BLOCK_SIZE - 1)) != 0)) {
+				this->parent->add_block_to_free_list(this->tailBlock);
+			}
+			
+			// Destroy block index
+			auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);
+			if (localBlockIndex != nullptr) {
+				for (size_t i = 0; i != localBlockIndex->capacity; ++i) {
+					localBlockIndex->index[i]->~BlockIndexEntry();
+				}
+				do {
+					auto prev = localBlockIndex->prev;
+					localBlockIndex->~BlockIndexHeader();
+					(Traits::free)(localBlockIndex);
+					localBlockIndex = prev;
+				} while (localBlockIndex != nullptr);
+			}
+		}
+		
+		template<AllocationMode allocMode, typename U>
+		inline bool enqueue(U&& element)
+		{
+			index_t currentTailIndex = this->tailIndex.load(std::memory_order_relaxed);
+			index_t newTailIndex = 1 + currentTailIndex;
+			if ((currentTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
+				// We reached the end of a block, start a new one
+				auto head = this->headIndex.load(std::memory_order_relaxed);
+				assert(!details::circular_less_than<index_t>(currentTailIndex, head));
+				if (!details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head))) {
+					return false;
+				}
+#if MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
+				debug::DebugLock lock(mutex);
+#endif
+				// Find out where we'll be inserting this block in the block index
+				BlockIndexEntry* idxEntry;
+				if (!insert_block_index_entry<allocMode>(idxEntry, currentTailIndex)) {
+					return false;
+				}
+				
+				// Get ahold of a new block
+				auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
+				if (newBlock == nullptr) {
+					rewind_block_index_tail();
+					idxEntry->value.store(nullptr, std::memory_order_relaxed);
+					return false;
+				}
+#if MCDBGQ_TRACKMEM
+				newBlock->owner = this;
+#endif
+				newBlock->ConcurrentQueue::Block::template reset_empty<implicit_context>();
+				
+				if (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (nullptr) T(std::forward<U>(element)))) {
+					// May throw, try to insert now before we publish the fact that we have this new block
+					MOODYCAMEL_TRY {
+						new ((*newBlock)[currentTailIndex]) T(std::forward<U>(element));
+					}
+					MOODYCAMEL_CATCH (...) {
+						rewind_block_index_tail();
+						idxEntry->value.store(nullptr, std::memory_order_relaxed);
+						this->parent->add_block_to_free_list(newBlock);
+						MOODYCAMEL_RETHROW;
+					}
+				}
+				
+				// Insert the new block into the index
+				idxEntry->value.store(newBlock, std::memory_order_relaxed);
+				
+				this->tailBlock = newBlock;
+				
+				if (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (nullptr) T(std::forward<U>(element)))) {
+					this->tailIndex.store(newTailIndex, std::memory_order_release);
+					return true;
+				}
+			}
+			
+			// Enqueue
+			new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
+			
+			this->tailIndex.store(newTailIndex, std::memory_order_release);
+			return true;
+		}
+		
+		template<typename U>
+		bool dequeue(U& element)
+		{
+			// See ExplicitProducer::dequeue for rationale and explanation
+			index_t tail = this->tailIndex.load(std::memory_order_relaxed);
+			index_t overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
+			if (details::circular_less_than<index_t>(this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit, tail)) {
+				std::atomic_thread_fence(std::memory_order_acquire);
+				
+				index_t myDequeueCount = this->dequeueOptimisticCount.fetch_add(1, std::memory_order_relaxed);
+				assert(overcommit <= myDequeueCount);
+				tail = this->tailIndex.load(std::memory_order_acquire);
+				if (details::likely(details::circular_less_than<index_t>(myDequeueCount - overcommit, tail))) {
+					index_t index = this->headIndex.fetch_add(1, std::memory_order_acq_rel);
+					
+					// Determine which block the element is in
+					auto entry = get_block_index_entry_for_index(index);
+					
+					// Dequeue
+					auto block = entry->value.load(std::memory_order_relaxed);
+					auto& el = *((*block)[index]);
+					
+					if (!MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, element = std::move(el))) {
+#if MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
+						// Note: Acquiring the mutex with every dequeue instead of only when a block
+						// is released is very sub-optimal, but it is, after all, purely debug code.
+						debug::DebugLock lock(producer->mutex);
+#endif
+						struct Guard {
+							Block* block;
+							index_t index;
+							BlockIndexEntry* entry;
+							ConcurrentQueue* parent;
+							
+							~Guard()
+							{
+								(*block)[index]->~T();
+								if (block->ConcurrentQueue::Block::template set_empty<implicit_context>(index)) {
+									entry->value.store(nullptr, std::memory_order_relaxed);
+									parent->add_block_to_free_list(block);
+								}
+							}
+						} guard = { block, index, entry, this->parent };
+						
+						element = std::move(el);
+					}
+					else {
+						element = std::move(el);
+						el.~T();
+					
+						if (block->ConcurrentQueue::Block::template set_empty<implicit_context>(index)) {
+							{
+#if MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
+								debug::DebugLock lock(mutex);
+#endif
+								// Add the block back into the global free pool (and remove from block index)
+								entry->value.store(nullptr, std::memory_order_relaxed);
+							}
+							this->parent->add_block_to_free_list(block);		// releases the above store
+						}
+					}
+					
+					return true;
+				}
+				else {
+					this->dequeueOvercommit.fetch_add(1, std::memory_order_release);
+				}
+			}
+		
+			return false;
+		}
+		
+		template<AllocationMode allocMode, typename It>
+		bool enqueue_bulk(It itemFirst, size_t count)
+		{
+			// First, we need to make sure we have enough room to enqueue all of the elements;
+			// this means pre-allocating blocks and putting them in the block index (but only if
+			// all the allocations succeeded).
+			
+			// Note that the tailBlock we start off with may not be owned by us any more;
+			// this happens if it was filled up exactly to the top (setting tailIndex to
+			// the first index of the next block which is not yet allocated), then dequeued
+			// completely (putting it on the free list) before we enqueue again.
+			
+			index_t startTailIndex = this->tailIndex.load(std::memory_order_relaxed);
+			auto startBlock = this->tailBlock;
+			Block* firstAllocatedBlock = nullptr;
+			auto endBlock = this->tailBlock;
+			
+			// Figure out how many blocks we'll need to allocate, and do so
+			size_t blockBaseDiff = ((startTailIndex + count - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1)) - ((startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1));
+			index_t currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
+			if (blockBaseDiff > 0) {
+#if MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
+				debug::DebugLock lock(mutex);
+#endif
+				do {
+					blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
+					currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
+					
+					// Find out where we'll be inserting this block in the block index
+					BlockIndexEntry* idxEntry = nullptr;  // initialization here unnecessary but compiler can't always tell
+					Block* newBlock;
+					bool indexInserted = false;
+					auto head = this->headIndex.load(std::memory_order_relaxed);
+					assert(!details::circular_less_than<index_t>(currentTailIndex, head));
+					bool full = !details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head));
+					if (full || !(indexInserted = insert_block_index_entry<allocMode>(idxEntry, currentTailIndex)) || (newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>()) == nullptr) {
+						// Index allocation or block allocation failed; revert any other allocations
+						// and index insertions done so far for this operation
+						if (indexInserted) {
+							rewind_block_index_tail();
+							idxEntry->value.store(nullptr, std::memory_order_relaxed);
+						}
+						currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
+						for (auto block = firstAllocatedBlock; block != nullptr; block = block->next) {
+							currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
+							idxEntry = get_block_index_entry_for_index(currentTailIndex);
+							idxEntry->value.store(nullptr, std::memory_order_relaxed);
+							rewind_block_index_tail();
+						}
+						this->parent->add_blocks_to_free_list(firstAllocatedBlock);
+						this->tailBlock = startBlock;
+						
+						return false;
+					}
+					
+#if MCDBGQ_TRACKMEM
+					newBlock->owner = this;
+#endif
+					newBlock->ConcurrentQueue::Block::template reset_empty<implicit_context>();
+					newBlock->next = nullptr;
+					
+					// Insert the new block into the index
+					idxEntry->value.store(newBlock, std::memory_order_relaxed);
+					
+					// Store the chain of blocks so that we can undo if later allocations fail,
+					// and so that we can find the blocks when we do the actual enqueueing
+					if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr) {
+						assert(this->tailBlock != nullptr);
+						this->tailBlock->next = newBlock;
+					}
+					this->tailBlock = newBlock;
+					endBlock = newBlock;
+					firstAllocatedBlock = firstAllocatedBlock == nullptr ? newBlock : firstAllocatedBlock;
+				} while (blockBaseDiff > 0);
+			}
+			
+			// Enqueue, one block at a time
+			index_t newTailIndex = startTailIndex + static_cast<index_t>(count);
+			currentTailIndex = startTailIndex;
+			this->tailBlock = startBlock;
+			assert((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr || count == 0);
+			if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 && firstAllocatedBlock != nullptr) {
+				this->tailBlock = firstAllocatedBlock;
+			}
+			while (true) {
+				auto stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
+				if (details::circular_less_than<index_t>(newTailIndex, stopIndex)) {
+					stopIndex = newTailIndex;
+				}
+				if (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (nullptr) T(details::deref_noexcept(itemFirst)))) {
+					while (currentTailIndex != stopIndex) {
+						new ((*this->tailBlock)[currentTailIndex++]) T(*itemFirst++);
+					}
+				}
+				else {
+					MOODYCAMEL_TRY {
+						while (currentTailIndex != stopIndex) {
+							new ((*this->tailBlock)[currentTailIndex]) T(details::nomove_if<(bool)!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (nullptr) T(details::deref_noexcept(itemFirst)))>::eval(*itemFirst));
+							++currentTailIndex;
+							++itemFirst;
+						}
+					}
+					MOODYCAMEL_CATCH (...) {
+						auto constructedStopIndex = currentTailIndex;
+						auto lastBlockEnqueued = this->tailBlock;
+						
+						if (!details::is_trivially_destructible<T>::value) {
+							auto block = startBlock;
+							if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
+								block = firstAllocatedBlock;
+							}
+							currentTailIndex = startTailIndex;
+							while (true) {
+								stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
+								if (details::circular_less_than<index_t>(constructedStopIndex, stopIndex)) {
+									stopIndex = constructedStopIndex;
+								}
+								while (currentTailIndex != stopIndex) {
+									(*block)[currentTailIndex++]->~T();
+								}
+								if (block == lastBlockEnqueued) {
+									break;
+								}
+								block = block->next;
+							}
+						}
+						
+						currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
+						for (auto block = firstAllocatedBlock; block != nullptr; block = block->next) {
+							currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
+							auto idxEntry = get_block_index_entry_for_index(currentTailIndex);
+							idxEntry->value.store(nullptr, std::memory_order_relaxed);
+							rewind_block_index_tail();
+						}
+						this->parent->add_blocks_to_free_list(firstAllocatedBlock);
+						this->tailBlock = startBlock;
+						MOODYCAMEL_RETHROW;
+					}
+				}
+				
+				if (this->tailBlock == endBlock) {
+					assert(currentTailIndex == newTailIndex);
+					break;
+				}
+				this->tailBlock = this->tailBlock->next;
+			}
+			this->tailIndex.store(newTailIndex, std::memory_order_release);
+			return true;
+		}
+		
+		template<typename It>
+		size_t dequeue_bulk(It& itemFirst, size_t max)
+		{
+			auto tail = this->tailIndex.load(std::memory_order_relaxed);
+			auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
+			auto desiredCount = static_cast<size_t>(tail - (this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit));
+			if (details::circular_less_than<size_t>(0, desiredCount)) {
+				desiredCount = desiredCount < max ? desiredCount : max;
+				std::atomic_thread_fence(std::memory_order_acquire);
+				
+				auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(desiredCount, std::memory_order_relaxed);
+				assert(overcommit <= myDequeueCount);
+				
+				tail = this->tailIndex.load(std::memory_order_acquire);
+				auto actualCount = static_cast<size_t>(tail - (myDequeueCount - overcommit));
+				if (details::circular_less_than<size_t>(0, actualCount)) {
+					actualCount = desiredCount < actualCount ? desiredCount : actualCount;
+					if (actualCount < desiredCount) {
+						this->dequeueOvercommit.fetch_add(desiredCount - actualCount, std::memory_order_release);
+					}
+					
+					// Get the first index. Note that since there's guaranteed to be at least actualCount elements, this
+					// will never exceed tail.
+					auto firstIndex = this->headIndex.fetch_add(actualCount, std::memory_order_acq_rel);
+					
+					// Iterate the blocks and dequeue
+					auto index = firstIndex;
+					BlockIndexHeader* localBlockIndex;
+					auto indexIndex = get_block_index_index_for_index(index, localBlockIndex);
+					do {
+						auto blockStartIndex = index;
+						auto endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
+						endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
+						
+						auto entry = localBlockIndex->index[indexIndex];
+						auto block = entry->value.load(std::memory_order_relaxed);
+						if (MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, details::deref_noexcept(itemFirst) = std::move((*(*block)[index])))) {
+							while (index != endIndex) {
+								auto& el = *((*block)[index]);
+								*itemFirst++ = std::move(el);
+								el.~T();
+								++index;
+							}
+						}
+						else {
+							MOODYCAMEL_TRY {
+								while (index != endIndex) {
+									auto& el = *((*block)[index]);
+									*itemFirst = std::move(el);
+									++itemFirst;
+									el.~T();
+									++index;
+								}
+							}
+							MOODYCAMEL_CATCH (...) {
+								do {
+									entry = localBlockIndex->index[indexIndex];
+									block = entry->value.load(std::memory_order_relaxed);
+									while (index != endIndex) {
+										(*block)[index++]->~T();
+									}
+									
+									if (block->ConcurrentQueue::Block::template set_many_empty<implicit_context>(blockStartIndex, static_cast<size_t>(endIndex - blockStartIndex))) {
+#if MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
+										debug::DebugLock lock(mutex);
+#endif
+										entry->value.store(nullptr, std::memory_order_relaxed);
+										this->parent->add_block_to_free_list(block);
+									}
+									indexIndex = (indexIndex + 1) & (localBlockIndex->capacity - 1);
+									
+									blockStartIndex = index;
+									endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
+									endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
+								} while (index != firstIndex + actualCount);
+								
+								MOODYCAMEL_RETHROW;
+							}
+						}
+						if (block->ConcurrentQueue::Block::template set_many_empty<implicit_context>(blockStartIndex, static_cast<size_t>(endIndex - blockStartIndex))) {
+							{
+#if MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
+								debug::DebugLock lock(mutex);
+#endif
+								// Note that the set_many_empty above did a release, meaning that anybody who acquires the block
+								// we're about to free can use it safely since our writes (and reads!) will have happened-before then.
+								entry->value.store(nullptr, std::memory_order_relaxed);
+							}
+							this->parent->add_block_to_free_list(block);		// releases the above store
+						}
+						indexIndex = (indexIndex + 1) & (localBlockIndex->capacity - 1);
+					} while (index != firstIndex + actualCount);
+					
+					return actualCount;
+				}
+				else {
+					this->dequeueOvercommit.fetch_add(desiredCount, std::memory_order_release);
+				}
+			}
+			
+			return 0;
+		}
+		
+	private:
+		// The block size must be > 1, so any number with the low bit set is an invalid block base index
+		static const index_t INVALID_BLOCK_BASE = 1;
+		
+		struct BlockIndexEntry
+		{
+			std::atomic<index_t> key;
+			std::atomic<Block*> value;
+		};
+		
+		struct BlockIndexHeader
+		{
+			size_t capacity;
+			std::atomic<size_t> tail;
+			BlockIndexEntry* entries;
+			BlockIndexEntry** index;
+			BlockIndexHeader* prev;
+		};
+		
+		template<AllocationMode allocMode>
+		inline bool insert_block_index_entry(BlockIndexEntry*& idxEntry, index_t blockStartIndex)
+		{
+			auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);		// We're the only writer thread, relaxed is OK
+			if (localBlockIndex == nullptr) {
+				return false;  // this can happen if new_block_index failed in the constructor
+			}
+			auto newTail = (localBlockIndex->tail.load(std::memory_order_relaxed) + 1) & (localBlockIndex->capacity - 1);
+			idxEntry = localBlockIndex->index[newTail];
+			if (idxEntry->key.load(std::memory_order_relaxed) == INVALID_BLOCK_BASE ||
+				idxEntry->value.load(std::memory_order_relaxed) == nullptr) {
+				
+				idxEntry->key.store(blockStartIndex, std::memory_order_relaxed);
+				localBlockIndex->tail.store(newTail, std::memory_order_release);
+				return true;
+			}
+			
+			// No room in the old block index, try to allocate another one!
+			if (allocMode == CannotAlloc || !new_block_index()) {
+				return false;
+			}
+			localBlockIndex = blockIndex.load(std::memory_order_relaxed);
+			newTail = (localBlockIndex->tail.load(std::memory_order_relaxed) + 1) & (localBlockIndex->capacity - 1);
+			idxEntry = localBlockIndex->index[newTail];
+			assert(idxEntry->key.load(std::memory_order_relaxed) == INVALID_BLOCK_BASE);
+			idxEntry->key.store(blockStartIndex, std::memory_order_relaxed);
+			localBlockIndex->tail.store(newTail, std::memory_order_release);
+			return true;
+		}
+		
+		inline void rewind_block_index_tail()
+		{
+			auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);
+			localBlockIndex->tail.store((localBlockIndex->tail.load(std::memory_order_relaxed) - 1) & (localBlockIndex->capacity - 1), std::memory_order_relaxed);
+		}
+		
+		inline BlockIndexEntry* get_block_index_entry_for_index(index_t index) const
+		{
+			BlockIndexHeader* localBlockIndex;
+			auto idx = get_block_index_index_for_index(index, localBlockIndex);
+			return localBlockIndex->index[idx];
+		}
+		
+		inline size_t get_block_index_index_for_index(index_t index, BlockIndexHeader*& localBlockIndex) const
+		{
+#if MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
+			debug::DebugLock lock(mutex);
+#endif
+			index &= ~static_cast<index_t>(BLOCK_SIZE - 1);
+			localBlockIndex = blockIndex.load(std::memory_order_acquire);
+			auto tail = localBlockIndex->tail.load(std::memory_order_acquire);
+			auto tailBase = localBlockIndex->index[tail]->key.load(std::memory_order_relaxed);
+			assert(tailBase != INVALID_BLOCK_BASE);
+			// Note: Must use division instead of shift because the index may wrap around, causing a negative
+			// offset, whose negativity we want to preserve
+			auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(index - tailBase) / BLOCK_SIZE);
+			size_t idx = (tail + offset) & (localBlockIndex->capacity - 1);
+			assert(localBlockIndex->index[idx]->key.load(std::memory_order_relaxed) == index && localBlockIndex->index[idx]->value.load(std::memory_order_relaxed) != nullptr);
+			return idx;
+		}
+		
+		bool new_block_index()
+		{
+			auto prev = blockIndex.load(std::memory_order_relaxed);
+			size_t prevCapacity = prev == nullptr ? 0 : prev->capacity;
+			auto entryCount = prev == nullptr ? nextBlockIndexCapacity : prevCapacity;
+			auto raw = static_cast<char*>((Traits::malloc)(
+				sizeof(BlockIndexHeader) +
+				std::alignment_of<BlockIndexEntry>::value - 1 + sizeof(BlockIndexEntry) * entryCount +
+				std::alignment_of<BlockIndexEntry*>::value - 1 + sizeof(BlockIndexEntry*) * nextBlockIndexCapacity));
+			if (raw == nullptr) {
+				return false;
+			}
+			
+			auto header = new (raw) BlockIndexHeader;
+			auto entries = reinterpret_cast<BlockIndexEntry*>(details::align_for<BlockIndexEntry>(raw + sizeof(BlockIndexHeader)));
+			auto index = reinterpret_cast<BlockIndexEntry**>(details::align_for<BlockIndexEntry*>(reinterpret_cast<char*>(entries) + sizeof(BlockIndexEntry) * entryCount));
+			if (prev != nullptr) {
+				auto prevTail = prev->tail.load(std::memory_order_relaxed);
+				auto prevPos = prevTail;
+				size_t i = 0;
+				do {
+					prevPos = (prevPos + 1) & (prev->capacity - 1);
+					index[i++] = prev->index[prevPos];
+				} while (prevPos != prevTail);
+				assert(i == prevCapacity);
+			}
+			for (size_t i = 0; i != entryCount; ++i) {
+				new (entries + i) BlockIndexEntry;
+				entries[i].key.store(INVALID_BLOCK_BASE, std::memory_order_relaxed);
+				index[prevCapacity + i] = entries + i;
+			}
+			header->prev = prev;
+			header->entries = entries;
+			header->index = index;
+			header->capacity = nextBlockIndexCapacity;
+			header->tail.store((prevCapacity - 1) & (nextBlockIndexCapacity - 1), std::memory_order_relaxed);
+			
+			blockIndex.store(header, std::memory_order_release);
+			
+			nextBlockIndexCapacity <<= 1;
+			
+			return true;
+		}
+		
+	private:
+		size_t nextBlockIndexCapacity;
+		std::atomic<BlockIndexHeader*> blockIndex;
+
+#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
+	public:
+		details::ThreadExitListener threadExitListener;
+	private:
+#endif
+		
+#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
+	public:
+		ImplicitProducer* nextImplicitProducer;
+	private:
+#endif
+
+#if MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
+		mutable debug::DebugMutex mutex;
+#endif
+#if MCDBGQ_TRACKMEM
+		friend struct MemStats;
+#endif
+	};
+	
+	
+	//////////////////////////////////
+	// Block pool manipulation
+	//////////////////////////////////
+	
+	void populate_initial_block_list(size_t blockCount)
+	{
+		initialBlockPoolSize = blockCount;
+		if (initialBlockPoolSize == 0) {
+			initialBlockPool = nullptr;
+			return;
+		}
+		
+		initialBlockPool = create_array<Block>(blockCount);
+		if (initialBlockPool == nullptr) {
+			initialBlockPoolSize = 0;
+		}
+		for (size_t i = 0; i < initialBlockPoolSize; ++i) {
+			initialBlockPool[i].dynamicallyAllocated = false;
+		}
+	}
+	
+	inline Block* try_get_block_from_initial_pool()
+	{
+		if (initialBlockPoolIndex.load(std::memory_order_relaxed) >= initialBlockPoolSize) {
+			return nullptr;
+		}
+		
+		auto index = initialBlockPoolIndex.fetch_add(1, std::memory_order_relaxed);
+		
+		return index < initialBlockPoolSize ? (initialBlockPool + index) : nullptr;
+	}
+	
+	inline void add_block_to_free_list(Block* block)
+	{
+#if MCDBGQ_TRACKMEM
+		block->owner = nullptr;
+#endif
+		freeList.add(block);
+	}
+	
+	inline void add_blocks_to_free_list(Block* block)
+	{
+		while (block != nullptr) {
+			auto next = block->next;
+			add_block_to_free_list(block);
+			block = next;
+		}
+	}
+	
+	inline Block* try_get_block_from_free_list()
+	{
+		return freeList.try_get();
+	}
+	
+	// Gets a free block from one of the memory pools, or allocates a new one (if applicable)
+	template<AllocationMode canAlloc>
+	Block* requisition_block()
+	{
+		auto block = try_get_block_from_initial_pool();
+		if (block != nullptr) {
+			return block;
+		}
+		
+		block = try_get_block_from_free_list();
+		if (block != nullptr) {
+			return block;
+		}
+		
+		if (canAlloc == CanAlloc) {
+			return create<Block>();
+		}
+		
+		return nullptr;
+	}
+	
+
+#if MCDBGQ_TRACKMEM
+	public:
+		struct MemStats {
+			size_t allocatedBlocks;
+			size_t usedBlocks;
+			size_t freeBlocks;
+			size_t ownedBlocksExplicit;
+			size_t ownedBlocksImplicit;
+			size_t implicitProducers;
+			size_t explicitProducers;
+			size_t elementsEnqueued;
+			size_t blockClassBytes;
+			size_t queueClassBytes;
+			size_t implicitBlockIndexBytes;
+			size_t explicitBlockIndexBytes;
+			
+			friend class ConcurrentQueue;
+			
+		private:
+			static MemStats getFor(ConcurrentQueue* q)
+			{
+				MemStats stats = { 0 };
+				
+				stats.elementsEnqueued = q->size_approx();
+			
+				auto block = q->freeList.head_unsafe();
+				while (block != nullptr) {
+					++stats.allocatedBlocks;
+					++stats.freeBlocks;
+					block = block->freeListNext.load(std::memory_order_relaxed);
+				}
+				
+				for (auto ptr = q->producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
+					bool implicit = dynamic_cast<ImplicitProducer*>(ptr) != nullptr;
+					stats.implicitProducers += implicit ? 1 : 0;
+					stats.explicitProducers += implicit ? 0 : 1;
+					
+					if (implicit) {
+						auto prod = static_cast<ImplicitProducer*>(ptr);
+						stats.queueClassBytes += sizeof(ImplicitProducer);
+						auto head = prod->headIndex.load(std::memory_order_relaxed);
+						auto tail = prod->tailIndex.load(std::memory_order_relaxed);
+						auto hash = prod->blockIndex.load(std::memory_order_relaxed);
+						if (hash != nullptr) {
+							for (size_t i = 0; i != hash->capacity; ++i) {
+								if (hash->index[i]->key.load(std::memory_order_relaxed) != ImplicitProducer::INVALID_BLOCK_BASE && hash->index[i]->value.load(std::memory_order_relaxed) != nullptr) {
+									++stats.allocatedBlocks;
+									++stats.ownedBlocksImplicit;
+								}
+							}
+							stats.implicitBlockIndexBytes += hash->capacity * sizeof(typename ImplicitProducer::BlockIndexEntry);
+							for (; hash != nullptr; hash = hash->prev) {
+								stats.implicitBlockIndexBytes += sizeof(typename ImplicitProducer::BlockIndexHeader) + hash->capacity * sizeof(typename ImplicitProducer::BlockIndexEntry*);
+							}
+						}
+						for (; details::circular_less_than<index_t>(head, tail); head += BLOCK_SIZE) {
+							//auto block = prod->get_block_index_entry_for_index(head);
+							++stats.usedBlocks;
+						}
+					}
+					else {
+						auto prod = static_cast<ExplicitProducer*>(ptr);
+						stats.queueClassBytes += sizeof(ExplicitProducer);
+						auto tailBlock = prod->tailBlock;
+						bool wasNonEmpty = false;
+						if (tailBlock != nullptr) {
+							auto block = tailBlock;
+							do {
+								++stats.allocatedBlocks;
+								if (!block->ConcurrentQueue::Block::template is_empty<explicit_context>() || wasNonEmpty) {
+									++stats.usedBlocks;
+									wasNonEmpty = wasNonEmpty || block != tailBlock;
+								}
+								++stats.ownedBlocksExplicit;
+								block = block->next;
+							} while (block != tailBlock);
+						}
+						auto index = prod->blockIndex.load(std::memory_order_relaxed);
+						while (index != nullptr) {
+							stats.explicitBlockIndexBytes += sizeof(typename ExplicitProducer::BlockIndexHeader) + index->size * sizeof(typename ExplicitProducer::BlockIndexEntry);
+							index = static_cast<typename ExplicitProducer::BlockIndexHeader*>(index->prev);
+						}
+					}
+				}
+				
+				auto freeOnInitialPool = q->initialBlockPoolIndex.load(std::memory_order_relaxed) >= q->initialBlockPoolSize ? 0 : q->initialBlockPoolSize - q->initialBlockPoolIndex.load(std::memory_order_relaxed);
+				stats.allocatedBlocks += freeOnInitialPool;
+				stats.freeBlocks += freeOnInitialPool;
+				
+				stats.blockClassBytes = sizeof(Block) * stats.allocatedBlocks;
+				stats.queueClassBytes += sizeof(ConcurrentQueue);
+				
+				return stats;
+			}
+		};
+		
+		// For debugging only. Not thread-safe.
+		MemStats getMemStats()
+		{
+			return MemStats::getFor(this);
+		}
+	private:
+		friend struct MemStats;
+#endif
+	
+	
+	//////////////////////////////////
+	// Producer list manipulation
+	//////////////////////////////////	
+	
+	ProducerBase* recycle_or_create_producer(bool isExplicit)
+	{
+		bool recycled;
+		return recycle_or_create_producer(isExplicit, recycled);
+	}
+	
+	ProducerBase* recycle_or_create_producer(bool isExplicit, bool& recycled)
+	{
+#if MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
+		debug::DebugLock lock(implicitProdMutex);
+#endif
+		// Try to re-use one first
+		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
+			if (ptr->inactive.load(std::memory_order_relaxed) && ptr->isExplicit == isExplicit) {
+				bool expected = true;
+				if (ptr->inactive.compare_exchange_strong(expected, /* desired */ false, std::memory_order_acquire, std::memory_order_relaxed)) {
+					// We caught one! It's been marked as activated, the caller can have it
+					recycled = true;
+					return ptr;
+				}
+			}
+		}
+		
+		recycled = false;
+		return add_producer(isExplicit ? static_cast<ProducerBase*>(create<ExplicitProducer>(this)) : create<ImplicitProducer>(this));
+	}
+	
+	ProducerBase* add_producer(ProducerBase* producer)
+	{
+		// Handle failed memory allocation
+		if (producer == nullptr) {
+			return nullptr;
+		}
+		
+		producerCount.fetch_add(1, std::memory_order_relaxed);
+		
+		// Add it to the lock-free list
+		auto prevTail = producerListTail.load(std::memory_order_relaxed);
+		do {
+			producer->next = prevTail;
+		} while (!producerListTail.compare_exchange_weak(prevTail, producer, std::memory_order_release, std::memory_order_relaxed));
+		
+#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
+		if (producer->isExplicit) {
+			auto prevTailExplicit = explicitProducers.load(std::memory_order_relaxed);
+			do {
+				static_cast<ExplicitProducer*>(producer)->nextExplicitProducer = prevTailExplicit;
+			} while (!explicitProducers.compare_exchange_weak(prevTailExplicit, static_cast<ExplicitProducer*>(producer), std::memory_order_release, std::memory_order_relaxed));
+		}
+		else {
+			auto prevTailImplicit = implicitProducers.load(std::memory_order_relaxed);
+			do {
+				static_cast<ImplicitProducer*>(producer)->nextImplicitProducer = prevTailImplicit;
+			} while (!implicitProducers.compare_exchange_weak(prevTailImplicit, static_cast<ImplicitProducer*>(producer), std::memory_order_release, std::memory_order_relaxed));
+		}
+#endif
+		
+		return producer;
+	}
+	
+	void reown_producers()
+	{
+		// After another instance is moved-into/swapped-with this one, all the
+		// producers we stole still think their parents are the other queue.
+		// So fix them up!
+		for (auto ptr = producerListTail.load(std::memory_order_relaxed); ptr != nullptr; ptr = ptr->next_prod()) {
+			ptr->parent = this;
+		}
+	}
+	
+	
+	//////////////////////////////////
+	// Implicit producer hash
+	//////////////////////////////////
+	
+	struct ImplicitProducerKVP
+	{
+		std::atomic<details::thread_id_t> key;
+		ImplicitProducer* value;		// No need for atomicity since it's only read by the thread that sets it in the first place
+		
+		ImplicitProducerKVP() : value(nullptr) { }
+		
+		ImplicitProducerKVP(ImplicitProducerKVP&& other) MOODYCAMEL_NOEXCEPT
+		{
+			key.store(other.key.load(std::memory_order_relaxed), std::memory_order_relaxed);
+			value = other.value;
+		}
+		
+		inline ImplicitProducerKVP& operator=(ImplicitProducerKVP&& other) MOODYCAMEL_NOEXCEPT
+		{
+			swap(other);
+			return *this;
+		}
+		
+		inline void swap(ImplicitProducerKVP& other) MOODYCAMEL_NOEXCEPT
+		{
+			if (this != &other) {
+				details::swap_relaxed(key, other.key);
+				std::swap(value, other.value);
+			}
+		}
+	};
+	
+	template<typename XT, typename XTraits>
+	friend void moodycamel::swap(typename ConcurrentQueue<XT, XTraits>::ImplicitProducerKVP&, typename ConcurrentQueue<XT, XTraits>::ImplicitProducerKVP&) MOODYCAMEL_NOEXCEPT;
+	
+	struct ImplicitProducerHash
+	{
+		size_t capacity;
+		ImplicitProducerKVP* entries;
+		ImplicitProducerHash* prev;
+	};
+	
+	inline void populate_initial_implicit_producer_hash()
+	{
+		if (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return;
+		
+		implicitProducerHashCount.store(0, std::memory_order_relaxed);
+		auto hash = &initialImplicitProducerHash;
+		hash->capacity = INITIAL_IMPLICIT_PRODUCER_HASH_SIZE;
+		hash->entries = &initialImplicitProducerHashEntries[0];
+		for (size_t i = 0; i != INITIAL_IMPLICIT_PRODUCER_HASH_SIZE; ++i) {
+			initialImplicitProducerHashEntries[i].key.store(details::invalid_thread_id, std::memory_order_relaxed);
+		}
+		hash->prev = nullptr;
+		implicitProducerHash.store(hash, std::memory_order_relaxed);
+	}
+	
+	void swap_implicit_producer_hashes(ConcurrentQueue& other)
+	{
+		if (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return;
+		
+		// Swap (assumes our implicit producer hash is initialized)
+		initialImplicitProducerHashEntries.swap(other.initialImplicitProducerHashEntries);
+		initialImplicitProducerHash.entries = &initialImplicitProducerHashEntries[0];
+		other.initialImplicitProducerHash.entries = &other.initialImplicitProducerHashEntries[0];
+		
+		details::swap_relaxed(implicitProducerHashCount, other.implicitProducerHashCount);
+		
+		details::swap_relaxed(implicitProducerHash, other.implicitProducerHash);
+		if (implicitProducerHash.load(std::memory_order_relaxed) == &other.initialImplicitProducerHash) {
+			implicitProducerHash.store(&initialImplicitProducerHash, std::memory_order_relaxed);
+		}
+		else {
+			ImplicitProducerHash* hash;
+			for (hash = implicitProducerHash.load(std::memory_order_relaxed); hash->prev != &other.initialImplicitProducerHash; hash = hash->prev) {
+				continue;
+			}
+			hash->prev = &initialImplicitProducerHash;
+		}
+		if (other.implicitProducerHash.load(std::memory_order_relaxed) == &initialImplicitProducerHash) {
+			other.implicitProducerHash.store(&other.initialImplicitProducerHash, std::memory_order_relaxed);
+		}
+		else {
+			ImplicitProducerHash* hash;
+			for (hash = other.implicitProducerHash.load(std::memory_order_relaxed); hash->prev != &initialImplicitProducerHash; hash = hash->prev) {
+				continue;
+			}
+			hash->prev = &other.initialImplicitProducerHash;
+		}
+	}
+	
+	// Only fails (returns nullptr) if memory allocation fails
+	ImplicitProducer* get_or_add_implicit_producer()
+	{
+		// Note that since the data is essentially thread-local (key is thread ID),
+		// there's a reduced need for fences (memory ordering is already consistent
+		// for any individual thread), except for the current table itself.
+		
+		// Start by looking for the thread ID in the current and all previous hash tables.
+		// If it's not found, it must not be in there yet, since this same thread would
+		// have added it previously to one of the tables that we traversed.
+		
+		// Code and algorithm adapted from http://preshing.com/20130605/the-worlds-simplest-lock-free-hash-table
+		
+#if MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
+		debug::DebugLock lock(implicitProdMutex);
+#endif
+		
+		auto id = details::thread_id();
+		auto hashedId = details::hash_thread_id(id);
+		
+		auto mainHash = implicitProducerHash.load(std::memory_order_acquire);
+		for (auto hash = mainHash; hash != nullptr; hash = hash->prev) {
+			// Look for the id in this hash
+			auto index = hashedId;
+			while (true) {		// Not an infinite loop because at least one slot is free in the hash table
+				index &= hash->capacity - 1;
+				
+				auto probedKey = hash->entries[index].key.load(std::memory_order_relaxed);
+				if (probedKey == id) {
+					// Found it! If we had to search several hashes deep, though, we should lazily add it
+					// to the current main hash table to avoid the extended search next time.
+					// Note there's guaranteed to be room in the current hash table since every subsequent
+					// table implicitly reserves space for all previous tables (there's only one
+					// implicitProducerHashCount).
+					auto value = hash->entries[index].value;
+					if (hash != mainHash) {
+						index = hashedId;
+						while (true) {
+							index &= mainHash->capacity - 1;
+							probedKey = mainHash->entries[index].key.load(std::memory_order_relaxed);
+							auto empty = details::invalid_thread_id;
+#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
+							auto reusable = details::invalid_thread_id2;
+							if ((probedKey == empty    && mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_relaxed, std::memory_order_relaxed)) ||
+								(probedKey == reusable && mainHash->entries[index].key.compare_exchange_strong(reusable, id, std::memory_order_acquire, std::memory_order_acquire))) {
+#else
+							if ((probedKey == empty    && mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_relaxed, std::memory_order_relaxed))) {
+#endif
+								mainHash->entries[index].value = value;
+								break;
+							}
+							++index;
+						}
+					}
+					
+					return value;
+				}
+				if (probedKey == details::invalid_thread_id) {
+					break;		// Not in this hash table
+				}
+				++index;
+			}
+		}
+		
+		// Insert!
+		auto newCount = 1 + implicitProducerHashCount.fetch_add(1, std::memory_order_relaxed);
+		while (true) {
+			if (newCount >= (mainHash->capacity >> 1) && !implicitProducerHashResizeInProgress.test_and_set(std::memory_order_acquire)) {
+				// We've acquired the resize lock, try to allocate a bigger hash table.
+				// Note the acquire fence synchronizes with the release fence at the end of this block, and hence when
+				// we reload implicitProducerHash it must be the most recent version (it only gets changed within this
+				// locked block).
+				mainHash = implicitProducerHash.load(std::memory_order_acquire);
+				if (newCount >= (mainHash->capacity >> 1)) {
+					auto newCapacity = mainHash->capacity << 1;
+					while (newCount >= (newCapacity >> 1)) {
+						newCapacity <<= 1;
+					}
+					auto raw = static_cast<char*>((Traits::malloc)(sizeof(ImplicitProducerHash) + std::alignment_of<ImplicitProducerKVP>::value - 1 + sizeof(ImplicitProducerKVP) * newCapacity));
+					if (raw == nullptr) {
+						// Allocation failed
+						implicitProducerHashCount.fetch_sub(1, std::memory_order_relaxed);
+						implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
+						return nullptr;
+					}
+					
+					auto newHash = new (raw) ImplicitProducerHash;
+					newHash->capacity = newCapacity;
+					newHash->entries = reinterpret_cast<ImplicitProducerKVP*>(details::align_for<ImplicitProducerKVP>(raw + sizeof(ImplicitProducerHash)));
+					for (size_t i = 0; i != newCapacity; ++i) {
+						new (newHash->entries + i) ImplicitProducerKVP;
+						newHash->entries[i].key.store(details::invalid_thread_id, std::memory_order_relaxed);
+					}
+					newHash->prev = mainHash;
+					implicitProducerHash.store(newHash, std::memory_order_release);
+					implicitProducerHashResizeInProgress.clear(std::memory_order_release);
+					mainHash = newHash;
+				}
+				else {
+					implicitProducerHashResizeInProgress.clear(std::memory_order_release);
+				}
+			}
+			
+			// If it's < three-quarters full, add to the old one anyway so that we don't have to wait for the next table
+			// to finish being allocated by another thread (and if we just finished allocating above, the condition will
+			// always be true)
+			if (newCount < (mainHash->capacity >> 1) + (mainHash->capacity >> 2)) {
+				bool recycled;
+				auto producer = static_cast<ImplicitProducer*>(recycle_or_create_producer(false, recycled));
+				if (producer == nullptr) {
+					implicitProducerHashCount.fetch_sub(1, std::memory_order_relaxed);
+					return nullptr;
+				}
+				if (recycled) {
+					implicitProducerHashCount.fetch_sub(1, std::memory_order_relaxed);
+				}
+				
+#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
+				producer->threadExitListener.callback = &ConcurrentQueue::implicit_producer_thread_exited_callback;
+				producer->threadExitListener.userData = producer;
+				details::ThreadExitNotifier::subscribe(&producer->threadExitListener);
+#endif
+				
+				auto index = hashedId;
+				while (true) {
+					index &= mainHash->capacity - 1;
+					auto probedKey = mainHash->entries[index].key.load(std::memory_order_relaxed);
+					
+					auto empty = details::invalid_thread_id;
+#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
+					auto reusable = details::invalid_thread_id2;
+					if ((probedKey == empty    && mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_relaxed, std::memory_order_relaxed)) ||
+						(probedKey == reusable && mainHash->entries[index].key.compare_exchange_strong(reusable, id, std::memory_order_acquire, std::memory_order_acquire))) {
+#else
+					if ((probedKey == empty    && mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_relaxed, std::memory_order_relaxed))) {
+#endif
+						mainHash->entries[index].value = producer;
+						break;
+					}
+					++index;
+				}
+				return producer;
+			}
+			
+			// Hmm, the old hash is quite full and somebody else is busy allocating a new one.
+			// We need to wait for the allocating thread to finish (if it succeeds, we add, if not,
+			// we try to allocate ourselves).
+			mainHash = implicitProducerHash.load(std::memory_order_acquire);
+		}
+	}
+	
+#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
+	void implicit_producer_thread_exited(ImplicitProducer* producer)
+	{
+		// Remove from thread exit listeners
+		details::ThreadExitNotifier::unsubscribe(&producer->threadExitListener);
+		
+		// Remove from hash
+#if MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
+		debug::DebugLock lock(implicitProdMutex);
+#endif
+		auto hash = implicitProducerHash.load(std::memory_order_acquire);
+		assert(hash != nullptr);		// The thread exit listener is only registered if we were added to a hash in the first place
+		auto id = details::thread_id();
+		auto hashedId = details::hash_thread_id(id);
+		details::thread_id_t probedKey;
+		
+		// We need to traverse all the hashes just in case other threads aren't on the current one yet and are
+		// trying to add an entry thinking there's a free slot (because they reused a producer)
+		for (; hash != nullptr; hash = hash->prev) {
+			auto index = hashedId;
+			do {
+				index &= hash->capacity - 1;
+				probedKey = hash->entries[index].key.load(std::memory_order_relaxed);
+				if (probedKey == id) {
+					hash->entries[index].key.store(details::invalid_thread_id2, std::memory_order_release);
+					break;
+				}
+				++index;
+			} while (probedKey != details::invalid_thread_id);		// Can happen if the hash has changed but we weren't put back in it yet, or if we weren't added to this hash in the first place
+		}
+		
+		// Mark the queue as being recyclable
+		producer->inactive.store(true, std::memory_order_release);
+	}
+	
+	static void implicit_producer_thread_exited_callback(void* userData)
+	{
+		auto producer = static_cast<ImplicitProducer*>(userData);
+		auto queue = producer->parent;
+		queue->implicit_producer_thread_exited(producer);
+	}
+#endif
+	
+	//////////////////////////////////
+	// Utility functions
+	//////////////////////////////////
+	
+	template<typename U>
+	static inline U* create_array(size_t count)
+	{
+		assert(count > 0);
+		auto p = static_cast<U*>((Traits::malloc)(sizeof(U) * count));
+		if (p == nullptr) {
+			return nullptr;
+		}
+		
+		for (size_t i = 0; i != count; ++i) {
+			new (p + i) U();
+		}
+		return p;
+	}
+	
+	template<typename U>
+	static inline void destroy_array(U* p, size_t count)
+	{
+		if (p != nullptr) {
+			assert(count > 0);
+			for (size_t i = count; i != 0; ) {
+				(p + --i)->~U();
+			}
+			(Traits::free)(p);
+		}
+	}
+	
+	template<typename U>
+	static inline U* create()
+	{
+		auto p = (Traits::malloc)(sizeof(U));
+		return p != nullptr ? new (p) U : nullptr;
+	}
+	
+	template<typename U, typename A1>
+	static inline U* create(A1&& a1)
+	{
+		auto p = (Traits::malloc)(sizeof(U));
+		return p != nullptr ? new (p) U(std::forward<A1>(a1)) : nullptr;
+	}
+	
+	template<typename U>
+	static inline void destroy(U* p)
+	{
+		if (p != nullptr) {
+			p->~U();
+		}
+		(Traits::free)(p);
+	}
+
+private:
+	std::atomic<ProducerBase*> producerListTail;
+	std::atomic<std::uint32_t> producerCount;
+	
+	std::atomic<size_t> initialBlockPoolIndex;
+	Block* initialBlockPool;
+	size_t initialBlockPoolSize;
+	
+#if !MCDBGQ_USEDEBUGFREELIST
+	FreeList<Block> freeList;
+#else
+	debug::DebugFreeList<Block> freeList;
+#endif
+	
+	std::atomic<ImplicitProducerHash*> implicitProducerHash;
+	std::atomic<size_t> implicitProducerHashCount;		// Number of slots logically used
+	ImplicitProducerHash initialImplicitProducerHash;
+	std::array<ImplicitProducerKVP, INITIAL_IMPLICIT_PRODUCER_HASH_SIZE> initialImplicitProducerHashEntries;
+	std::atomic_flag implicitProducerHashResizeInProgress;
+	
+	std::atomic<std::uint32_t> nextExplicitConsumerId;
+	std::atomic<std::uint32_t> globalExplicitConsumerOffset;
+	
+#if MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
+	debug::DebugMutex implicitProdMutex;
+#endif
+	
+#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
+	std::atomic<ExplicitProducer*> explicitProducers;
+	std::atomic<ImplicitProducer*> implicitProducers;
+#endif
+};
+
+
+template<typename T, typename Traits>
+ProducerToken::ProducerToken(ConcurrentQueue<T, Traits>& queue)
+	: producer(queue.recycle_or_create_producer(true))
+{
+	if (producer != nullptr) {
+		producer->token = this;
+	}
+}
+
+template<typename T, typename Traits>
+ProducerToken::ProducerToken(BlockingConcurrentQueue<T, Traits>& queue)
+	: producer(reinterpret_cast<ConcurrentQueue<T, Traits>*>(&queue)->recycle_or_create_producer(true))
+{
+	if (producer != nullptr) {
+		producer->token = this;
+	}
+}
+
+template<typename T, typename Traits>
+ConsumerToken::ConsumerToken(ConcurrentQueue<T, Traits>& queue)
+	: itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr)
+{
+	initialOffset = queue.nextExplicitConsumerId.fetch_add(1, std::memory_order_release);
+	lastKnownGlobalOffset = -1;
+}
+
+template<typename T, typename Traits>
+ConsumerToken::ConsumerToken(BlockingConcurrentQueue<T, Traits>& queue)
+	: itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr)
+{
+	initialOffset = reinterpret_cast<ConcurrentQueue<T, Traits>*>(&queue)->nextExplicitConsumerId.fetch_add(1, std::memory_order_release);
+	lastKnownGlobalOffset = -1;
+}
+
+template<typename T, typename Traits>
+inline void swap(ConcurrentQueue<T, Traits>& a, ConcurrentQueue<T, Traits>& b) MOODYCAMEL_NOEXCEPT
+{
+	a.swap(b);
+}
+
+inline void swap(ProducerToken& a, ProducerToken& b) MOODYCAMEL_NOEXCEPT
+{
+	a.swap(b);
+}
+
+inline void swap(ConsumerToken& a, ConsumerToken& b) MOODYCAMEL_NOEXCEPT
+{
+	a.swap(b);
+}
+
+template<typename T, typename Traits>
+inline void swap(typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP& a, typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP& b) MOODYCAMEL_NOEXCEPT
+{
+	a.swap(b);
+}
+
+}
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
diff --git a/lib/percy/percy/dag.hpp b/lib/percy/percy/dag.hpp
new file mode 100644
index 0000000..200a066
--- /dev/null
+++ b/lib/percy/percy/dag.hpp
@@ -0,0 +1,619 @@
+#pragma once
+
+#ifndef DISABLE_NAUTY
+#include <nauty.h>
+#endif
+#include <array>
+#include <fstream>
+#include <ostream>
+#include <set>
+#include <vector>
+
+namespace percy
+{
+    template<typename Dag>
+    using fanin = typename Dag::fanin;
+    
+    template<typename Dag>
+    using vertex = typename Dag::vertex;
+
+    template<int FI>
+    class dag
+    {
+        public:
+            using fanin = int;
+            using vertex = std::array<fanin, FI>;
+            static const int NrFanin = FI;
+
+        protected:
+            int nr_inputs;
+            int nr_vertices;
+
+            std::vector<std::array<fanin, FI>> vertices;
+
+            void 
+            copy_dag(const dag& dag)
+            {
+                reset(dag.nr_inputs, dag.nr_vertices);
+                vertices.resize(dag.get_nr_vertices());
+
+                for (int i = 0; i < nr_vertices; i++) {
+                    for (int j = 0; j < FI; j++) {
+                        vertices[i][j] = dag.vertices[i][j];
+                    }
+                }
+            }
+
+        public:
+            dag() { }
+
+            dag(int n)
+            {
+                reset(n, 0);
+            }
+
+            dag(int n, int v)
+            {
+                reset(n, v);
+            }
+
+            dag(dag&& dag)
+            {
+                nr_inputs = dag.nr_inputs;
+                nr_vertices = dag.nr_vertices;
+
+                vertices = std::move(dag.vertices);
+
+                dag.nr_inputs = -1;
+                dag.nr_vertices = -1;
+            }
+
+            dag(const dag& dag)
+            {
+                copy_dag(dag);
+            }
+
+
+            dag& 
+            operator=(const dag& dag) 
+            {
+                copy_dag(dag);
+                return *this;
+            }
+
+            bool 
+            operator==(const dag& g)
+            {
+                if (g.nr_vertices != nr_vertices || g.nr_inputs != nr_inputs) {
+                    return false;
+                }
+                for (int i = 0; i < nr_vertices; i++) {
+                    for (int j = 0; j < FI; j++) {
+                        if (vertices[i][j] != g.vertices[i][j]) {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            }
+
+            bool 
+            operator!=(const dag& g) 
+            {
+                return !(*this ==g);
+            }
+
+            template<typename Fn>
+            void 
+            foreach_input(Fn&& fn) const
+            {
+                for (auto i = 0; i < nr_inputs; i++) {
+                    fn(i);
+                }
+            }
+
+            template<typename Fn>
+            void 
+            foreach_vertex(Fn&& fn) const
+            {
+                for (int i = 0; i < nr_vertices; i++) {
+                    fn(vertices[i], i);
+                }
+            }
+
+            template<typename Fn>
+            void 
+            foreach_fanin(vertex v, Fn&& fn) const
+            {
+                for (auto i = 0; i < FI; i++) {
+                    fn(v[i], i);
+                }
+            }
+
+            void 
+            reset(int n, int v)
+            {
+                nr_inputs = n;
+                nr_vertices = v;
+                vertices.resize(nr_vertices);
+
+                for (int i = 0; i < nr_vertices; i++) {
+                    for (int j = 0; j < FI; j++) {
+                        vertices[i][j] = -1;
+                    }
+                }
+            }
+
+            int get_nr_vertices() const { return nr_vertices; }
+            int get_nr_inputs() const { return nr_inputs; }
+
+            void 
+            set_vertex(int v_idx, const fanin* const fanins)
+            {
+                assert(v_idx < nr_vertices);
+                for (int i = 0; i < FI; i++) {
+                    vertices[v_idx][i] = fanins[i];
+                }
+            }
+
+            void 
+            set_vertex(int v_idx, const std::array<fanin, FI>& fanins)
+            {
+                assert(v_idx < nr_vertices);
+                for (int i = 0; i < FI; i++) {
+                    vertices[v_idx][i] = fanins[i];
+                }
+            }
+
+            void 
+            set_vertex(int v_idx, const std::vector<fanin>& fanins)
+            {
+                assert(v_idx < nr_vertices);
+                for (int i = 0; i < FI; i++) {
+                    vertices[v_idx][i] = fanins[i];
+                }
+            }
+
+            void 
+            add_vertex(const fanin* const fanins)
+            {
+                vertex newv;
+                for (int i = 0; i < FI; i++) {
+                    newv[i] = fanins[i];
+                }
+                vertices.push_back(newv);
+                nr_vertices++;
+            }
+
+            void 
+            add_vertex(const std::vector<fanin>& fanins)
+            {
+                assert(fanins.size() >= FI);
+                
+                vertex newv;
+                for (int i = 0; i < FI; i++) {
+                    newv[i] = fanins[i];
+                }
+                vertices.push_back(newv);
+                nr_vertices++;
+            }
+
+            const vertex& 
+            get_vertex(int v_idx) const
+            {
+                return vertices[v_idx];
+            }
+
+            
+    };
+
+
+    template<>
+    class dag<2>
+    {
+        protected:
+            int nr_inputs;
+            int nr_vertices;
+            int* _js;
+            int* _ks;
+
+        public:
+            using fanin = int;
+            using vertex = std::pair<int,int>;
+            static const int NrFanin = 2;
+
+            dag() : _js(nullptr), _ks(nullptr)
+            {
+            }
+
+            dag(dag&& dag)
+            {
+                nr_inputs = dag.nr_inputs;
+                nr_vertices = dag.nr_vertices;
+
+                _js = dag._js;
+                _ks = dag._ks;
+
+                dag.nr_inputs = -1;
+                dag.nr_vertices = -1;
+                dag._js = nullptr;
+                dag._ks = nullptr;
+            }
+
+            dag(const dag& dag) : _js(nullptr), _ks(nullptr)
+            {
+                copy_dag(dag);
+            }
+
+            ~dag()
+            {
+                if (_js != nullptr) {
+                    delete[] _js;
+                }
+                if (_ks != nullptr) {
+                    delete[] _ks;
+                }
+            }
+
+            void 
+            copy_dag(const dag& dag)
+            {
+                reset(dag.nr_inputs, dag.nr_vertices);
+                
+                for (int i = 0; i < nr_vertices; i++) {
+                    _js[i] = dag._js[i];
+                    _ks[i] = dag._ks[i];
+                }
+            }
+
+            dag& 
+            operator=(const dag& dag) 
+            {
+                copy_dag(dag);
+                return *this;
+            }
+
+            bool 
+            operator==(const dag& g)
+            {
+                if (g.nr_vertices != nr_vertices || g.nr_inputs != nr_inputs) {
+                    return false;
+                }
+                for (int i = 0; i < nr_vertices; i++) {
+                    if (_js[i] != g._js[i] || _ks[i] != g._ks[i]) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            bool 
+            operator!=(const dag& g) {
+                return !(*this == g);
+            }
+
+            void
+            reset(int n, int v)
+            {
+                nr_inputs = n;
+                nr_vertices = v;
+                if (_js != nullptr) {
+                    delete[] _js;
+                }
+                _js = new int[nr_vertices]();
+                if (_ks != nullptr) {
+                    delete[] _ks;
+                }
+                _ks = new int[nr_vertices]();
+            }
+
+            int get_nr_vertices() const { return nr_vertices; }
+            int get_nr_inputs() const { return nr_inputs; }
+
+            void 
+            set_vertex(int v_idx, fanin fanin1, fanin fanin2)
+            {
+                assert(v_idx < nr_vertices);
+                _js[v_idx] = fanin1;
+                _ks[v_idx] = fanin2;
+            }
+
+            void 
+            set_vertex(int v_idx, const fanin* const fanins)
+            {
+                assert(v_idx < nr_vertices);
+                _js[v_idx] = fanins[0];
+                _ks[v_idx] = fanins[1];
+            }
+
+            void 
+            set_vertex(int v_idx, const std::array<fanin, 2>& fanins)
+            {
+                assert(v_idx < nr_vertices);
+                _js[v_idx] = fanins[0];
+                _ks[v_idx] = fanins[1];
+            }
+
+            void 
+            set_vertex(int v_idx, const std::vector<fanin>& fanins)
+            {
+                assert(v_idx < nr_vertices);
+                _js[v_idx] = fanins[0];
+                _ks[v_idx] = fanins[1];
+            }
+
+            void 
+            add_vertex(const fanin* const fanins)
+            {
+                auto new_js = new fanin[nr_vertices + 1];
+                auto new_ks = new fanin[nr_vertices + 1];
+
+                for (int i = 0; i < nr_vertices; i++) {
+                    new_js[i] = _js[i];
+                    new_ks[i] = _ks[i];
+                }
+
+                new_js[nr_vertices] = fanins[0];
+                new_ks[nr_vertices] = fanins[1];
+
+                if (_js != nullptr) {
+                    delete[] _js;
+                }
+
+                if (_ks != nullptr) {
+                    delete[] _ks;
+                }
+
+                _js = new_js;
+                _ks = new_ks;
+
+                nr_vertices++;
+            }
+
+            const std::pair<int,int> get_vertex(int v_idx) const
+            {
+                return std::make_pair(_js[v_idx], _ks[v_idx]);
+            }
+
+            template<typename Fn>
+            void 
+            foreach_input(Fn&& fn) const
+            {
+                for (auto i = 0; i < nr_inputs; i++) {
+                    fn(i);
+                }
+            }
+
+            template<typename Fn>
+            void 
+            foreach_vertex(Fn&& fn) const
+            {
+                for (int i = 0; i < nr_vertices; i++) {
+                    fn(std::make_pair(_js[i], _ks[i]), i);
+                }
+            }
+
+            template<typename Fn>
+            void 
+            foreach_fanin(vertex v, Fn&& fn) const
+            {
+                fn(v.first, 0);
+                fn(v.second, 1);
+            }
+
+            // Swaps input variable pos with variable pos+1.
+            void 
+            swap_adjacent_inplace(int pos)
+            {
+                for (int i = 0; i < nr_vertices; i++) {
+                    if (_js[i] == pos) {
+                        _js[i] = pos+1;
+                    } else if (_js[i] == (pos+1)) {
+                        _js[i] = pos;
+                    }
+                    if (_ks[i] == pos) {
+                        _ks[i] = pos+1;
+                    } else if (_ks[i] == (pos+1)) {
+                        _ks[i] = pos;
+                    }
+                }
+            }
+
+#ifndef DISABLE_NAUTY
+            /*******************************************************************
+                Uses the Nauty package to check for isomorphism beteen DAGs.
+            *******************************************************************/
+            bool
+            is_isomorphic(const dag& g, const int verbosity = 0) const
+            {
+                const auto total_vertices = nr_inputs + nr_vertices;
+                assert(nr_vertices == g.nr_vertices && 
+                        nr_inputs == g.nr_inputs);
+
+                void (*adjacencies)(graph*, int*, int*, int, 
+                        int, int, int*, int, boolean, int, int) = NULL;
+
+                DYNALLSTAT(int,lab1,lab1_sz);
+                DYNALLSTAT(int,lab2,lab2_sz);
+                DYNALLSTAT(int,ptn,ptn_sz);
+                DYNALLSTAT(int,orbits,orbits_sz);
+                DYNALLSTAT(int,map,map_sz);
+                DYNALLSTAT(graph,g1,g1_sz);
+                DYNALLSTAT(graph,g2,g2_sz);
+                DYNALLSTAT(graph,cg1,cg1_sz);
+                DYNALLSTAT(graph,cg2,cg2_sz);
+                DEFAULTOPTIONS_DIGRAPH(options);
+                statsblk stats;
+
+                int m = SETWORDSNEEDED(total_vertices);;
+
+                options.getcanon = TRUE;
+
+                DYNALLOC1(int,lab1,lab1_sz,total_vertices,"malloc");
+                DYNALLOC1(int,lab2,lab2_sz,total_vertices,"malloc");
+                DYNALLOC1(int,ptn,ptn_sz,total_vertices,"malloc");
+                DYNALLOC1(int,orbits,orbits_sz,total_vertices,"malloc");
+                DYNALLOC1(int,map,map_sz,total_vertices,"malloc");
+
+                // Make the first graph
+                DYNALLOC2(graph,g1,g1_sz,total_vertices,m,"malloc");
+                EMPTYGRAPH(g1,m,total_vertices);
+                for (int i = 0; i < nr_vertices; i++) {
+                    const auto vertex = get_vertex(i);
+                    ADDONEARC(g1, vertex.first, nr_inputs+i, m);
+                    ADDONEARC(g1, vertex.second, nr_inputs+i, m);
+                }
+
+                // Make the second graph
+                DYNALLOC2(graph,g2,g2_sz,total_vertices,m,"malloc");
+                EMPTYGRAPH(g2,m,total_vertices);
+                for (int i = 0; i < nr_vertices; i++) {
+                    const auto& vertex = g.get_vertex(i);
+                    ADDONEARC(g2, vertex.first, nr_inputs+i, m);
+                    ADDONEARC(g2, vertex.second, nr_inputs+i, m);
+                }
+
+                // Create canonical graphs
+                DYNALLOC2(graph,cg1,cg1_sz,total_vertices,m,"malloc");
+                DYNALLOC2(graph,cg2,cg2_sz,total_vertices,m,"malloc");
+                densenauty(g1,lab1,ptn,orbits,&options,&stats,m,total_vertices,cg1);
+                densenauty(g2,lab2,ptn,orbits,&options,&stats,m,total_vertices,cg2);
+
+                // Compare the canonical graphs to see if the two graphs are
+                // isomorphic
+                bool isomorphic = true;
+                for (int k = 0; k < m * total_vertices; k++) {
+                    if (cg1[k] != cg2[k]) {
+                        isomorphic = false;
+                        break;;
+                    }
+                }
+                if (isomorphic && verbosity) {
+                    // Print the mapping between graphs for debugging purposes
+                    for (int i = 0; i < total_vertices; ++i) {
+                        map[lab1[i]] = lab2[i];
+                    }
+                    for (int i = 0; i < total_vertices; ++i) {
+                        printf(" %d-%d",i,map[i]);
+                    }
+                    printf("\n");
+                }
+
+                return isomorphic;
+            }
+#endif
+
+            /*******************************************************************
+                Checks a restricted form of graph isomorphism: are two graphs
+                isomorphic if we only allow for permutation of the inputs?
+            *******************************************************************/
+            bool
+            is_perm_isomorphic(const dag& g) const
+            {
+                assert(nr_vertices == g.nr_vertices && 
+                        nr_inputs == g.nr_inputs);
+
+                std::multiset<std::pair<int,int>> g1_vertices;
+                std::multiset<std::pair<int,int>> g2_vertices;
+
+                dag cpy(g);
+                const auto& swaps = kitty::detail::swaps[nr_inputs - 2u];
+                auto swap_counter = 0u;
+                do {
+                    g1_vertices.clear();
+                    g2_vertices.clear();
+                    for (int i = 0; i < nr_vertices; i++) {
+                        const auto& v1 = get_vertex(i);
+                        const auto& v2 = cpy.get_vertex(i);
+                        g1_vertices.insert(v1);
+                        g2_vertices.insert(v2);
+                    }
+
+                    bool isomorphic = true;
+                    for (int i = 0; i < nr_vertices; i++) {
+                        const auto& v1 = get_vertex(i);
+                        const auto& v2 = cpy.get_vertex(i);
+                        if (g1_vertices.count(v1) != g2_vertices.count(v1)) {
+                            isomorphic = false;
+                            break;
+                        }
+                        if (g1_vertices.count(v2) != g2_vertices.count(v2)) {
+                            isomorphic = false;
+                            break;
+                        }
+                    }
+                    if (isomorphic) {
+                        return true;
+                    }
+
+                    if (swap_counter < swaps.size()) {
+                        const auto pos = swaps[swap_counter];
+                        cpy.swap_adjacent_inplace(pos);
+                    }
+                    swap_counter++;
+                } while (swap_counter <= swaps.size());
+                
+                return false;
+            }
+
+    };
+
+    using binary_dag = dag<2>;
+    using ternary_dag = dag<3>;
+
+  /*! \brief Writes DAG in DOT format to output stream
+   *
+   *  Converts a DAG to the GraphViz DOT format and writes it to the
+   *  specified output stream
+   */
+  template<int FI>
+  void to_dot( dag<FI> const& dag, std::ostream& o )
+  {
+    o << "graph{\n";
+    o << "rankdir = BT\n";
+    dag.foreach_input([&o] (int input_idx) {
+        const auto dot_idx = input_idx +1;
+        o << "x" << dot_idx << " [shape=none,label=<x<sub>" << dot_idx
+          << "</sub>>];\n";
+      });
+
+    o << "node [shape=circle];\n";
+    dag.foreach_vertex([&dag, &o] (auto v, int v_idx) {
+        const auto dot_idx = dag.get_nr_inputs() + v_idx + 1;
+        o << "x" << dot_idx << " [label=<x<sub>" << dot_idx
+          << "</sub>>];\n";
+
+        dag.foreach_fanin(v, [&o, dot_idx] (auto f_id, int) {
+            o << "x" << f_id+1 << " -- x" << dot_idx << ";\n";
+          });
+      });
+
+    // Group inputs on same level.
+    o << "{rank = same; ";
+    for (int i = 0; i < dag.get_nr_inputs(); i++) {
+      o << "x" << i+1 << "; ";
+    }
+    o << "}\n";
+
+    // Add invisible edges between PIs to enforce order.
+    o << "edge[style=invisible];\n";
+    for (int i = dag.get_nr_inputs(); i > 1; i--) {
+      o << "x" << i-1 << " -- x" << i << ";\n";
+    }
+
+    o << "}\n";
+  }
+
+  /*! \brief Writes DAG in DOT format into file
+   *
+   *  Converts a DAG to the GraphViz DOT format and writes it to the
+   *  specified file
+   */
+  template<int FI>
+  void to_dot( dag<FI> const& dag, std::string const& filename )
+  {
+    std::ofstream ofs( filename, std::ofstream::out );
+    to_dot( dag, ofs );
+    ofs.close();
+  }
+}
diff --git a/lib/percy/percy/dag_generation.hpp b/lib/percy/percy/dag_generation.hpp
new file mode 100644
index 0000000..bdc7aba
--- /dev/null
+++ b/lib/percy/percy/dag_generation.hpp
@@ -0,0 +1,1628 @@
+#pragma once
+
+#include "dag.hpp"
+#include <thread>
+#include <functional>
+#include <mutex>
+#include "tt_utils.hpp"
+#include "concurrentqueue.h"
+#include "solvers.hpp"
+#include <vector>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#include <abc/vecInt.h>
+#pragma GCC diagnostic pop
+
+namespace percy
+{
+    /*
+    template<typename TT, typename Solver>
+    class old_dag_synthesizer
+    {
+        private:
+            Solver _solver;
+            int _nr_in;
+            int _nr_steps;
+            int _nr_op_vars;
+            int _nr_sim_vars;
+            int _tt_size;
+            int _verbosity = 0;
+
+        public:
+            old_dag_synthesizer()
+            {
+                solver_alloc(&_solver);
+            }
+
+            ~old_dag_synthesizer()
+            {
+                solver_dealloc(&_solver);
+            }
+
+            void set_verbosity(int verbosity) { _verbosity = verbosity; }
+
+            void reset(int nr_in, int nr_steps)
+            {
+                _nr_in = nr_in;
+                _nr_steps = nr_steps;
+                _tt_size = (1 << _nr_in) - 1;
+            }
+
+            void create_variables(const TT& spec)
+            {
+                solver_restart(&_solver);
+
+                _nr_op_vars = _nr_steps * 3;
+                _nr_sim_vars = _nr_steps * _tt_size;
+                if (_verbosity > 1) {
+                    printf("nr_op_vars=%d\n", _nr_op_vars);
+                    printf("nr_sim_vars=%d\n", _nr_sim_vars);
+                }
+                
+                solver_set_nr_vars(_solver, _nr_op_vars + _nr_sim_vars);
+            }
+
+            int
+            dag_get_op_var(int i, int c, int b)
+            {
+                assert(i < _nr_steps);
+                assert(b < 2);
+                assert(c < 2);
+                assert(b > 0 || c > 0);
+
+                return i * 3 + ( c << 1 ) + b - 1;
+            }
+
+            int 
+            dag_get_sim_var(int i, int t)
+            {
+                assert(i < _nr_steps);
+                assert(t < _nr_sim_vars);
+
+                return _nr_op_vars + _tt_size * i + t;
+            }
+
+            bool add_simulation_clause(
+                    int i, int j, int k, 
+                    int t, int a, int b, int c)
+            {
+                int pLits[4], ctr = 0;
+
+                if (j < _nr_in) {
+                    if (( ( ( t + 1 ) & ( 1 << j ) ) ? 1 : 0 ) != b) {
+                        return true;
+                    }
+                } else {
+                    pLits[ctr++] = pabc::Abc_Var2Lit(
+                            dag_get_sim_var(j - _nr_in, t), b);
+                }
+
+                if (k < _nr_in) {
+                    if (( ( ( t + 1 ) & ( 1 << k ) ) ? 1 : 0 ) != c)
+                        return true;
+                } else {
+                    pLits[ctr++] = pabc::Abc_Var2Lit(
+                            dag_get_sim_var(k - _nr_in, t), c);
+                }
+
+                pLits[ctr++] = pabc::Abc_Var2Lit(dag_get_sim_var(i, t), a);
+
+                if (b | c) {
+                    pLits[ctr++] = pabc::Abc_Var2Lit(dag_get_op_var(i, c, b), 1 - a);
+                    //printf("%sf_%d_%d_%d\n", (1-a) ? "!" : "", i+1, c, b);
+                }
+
+                return solver_add_clause(_solver, pLits, pLits + ctr);
+            }
+
+            bool create_tt_clauses(const TT& spec, const dag<2>& dag, int t)
+            {
+                int pLits[2];
+
+                auto ret = true;
+
+                for (int i = 0; i < _nr_steps; i++) {
+                    auto vertex = dag.get_vertex(i);
+                    int j = vertex.first;
+                    int k = vertex.second;
+
+                    ret &= add_simulation_clause(i, j, k, t, 0, 0, 1);
+                    ret &= add_simulation_clause(i, j, k, t, 0, 1, 0);
+                    ret &= add_simulation_clause(i, j, k, t, 0, 1, 1);
+                    ret &= add_simulation_clause(i, j, k, t, 1, 0, 0);
+                    ret &= add_simulation_clause(i, j, k, t, 1, 0, 1);
+                    ret &= add_simulation_clause(i, j, k, t, 1, 1, 0);
+                    ret &= add_simulation_clause(i, j, k, t, 1, 1, 1);
+
+                    // If an output has selected this particular operand, we
+                    // need to ensure that this operand's truth table satisfies
+                    // the specified output function.
+                    if (i == _nr_steps-1) {
+                        if (_verbosity > 1) {
+                            printf("bit %d=%d", t+2, kitty::get_bit(spec, t+1));
+                            printf("\tvar=%d\n", dag_get_sim_var(i, t));
+                        }
+                        auto outbit = kitty::get_bit(spec, t+1);
+                        pLits[0] = pabc::Abc_Var2Lit(dag_get_sim_var(i, t), 
+                                1 - outbit);
+                        ret &= solver_add_clause(_solver,pLits,pLits+1);
+                    }
+                }
+
+                return ret;
+            }
+
+            bool create_main_clauses(const TT& spec, const dag<2>& dag)
+            {
+                bool success = true;
+                for (int t = 0; t < _tt_size; t++) {
+                    success &= create_tt_clauses(spec, dag, t);
+                }
+                return success;
+            }
+
+            bool create_nontriv_clauses()
+            {
+                bool success = true;
+                int pLits[3];
+
+                for (int i = 0; i < _nr_steps; i++) {
+                    pLits[0] = pabc::Abc_Var2Lit(dag_get_op_var(i, 0, 1), 0);
+                    pLits[1] = pabc::Abc_Var2Lit(dag_get_op_var(i, 1, 0), 0);
+                    pLits[2] = pabc::Abc_Var2Lit(dag_get_op_var(i, 1, 1), 0);
+                    success &= solver_add_clause(_solver, pLits, pLits + 3);
+
+                    pLits[0] = pabc::Abc_Var2Lit(dag_get_op_var(i, 0, 1), 0);
+                    pLits[1] = pabc::Abc_Var2Lit(dag_get_op_var(i, 1, 0), 1);
+                    pLits[2] = pabc::Abc_Var2Lit(dag_get_op_var(i, 1, 1), 1);
+                    success &= solver_add_clause(_solver, pLits, pLits + 3);
+
+                    pLits[0] = pabc::Abc_Var2Lit(dag_get_op_var(i, 0, 1), 1);
+                    pLits[1] = pabc::Abc_Var2Lit(dag_get_op_var(i, 1, 0), 0);
+                    pLits[2] = pabc::Abc_Var2Lit(dag_get_op_var(i, 1, 1), 1);
+                    success &= solver_add_clause(_solver, pLits, pLits + 3);
+                }
+                return success;
+            }
+
+            bool add_clauses(const TT& spec, const dag<2>& dag)
+            {
+                bool success = true;
+                create_variables(spec);
+                success &= create_main_clauses(spec, dag);
+            //    success &= create_nontriv_clauses();
+                return success;
+            }
+
+            void 
+            dag_chain_extract(const dag<2>& dag, chain<2>& chain, bool invert)
+            {
+                int op_inputs[2];
+
+                chain.reset(_nr_in, 1, _nr_steps);
+
+                for (int i = 0; i < _nr_steps; i++) {
+                    kitty::static_truth_table<2> op;
+                    if (solver_var_value(_solver, dag_get_op_var(i, 0, 1 )))
+                        kitty::set_bit(op, 1); 
+                    if (solver_var_value(_solver, dag_get_op_var(i, 1, 0)))
+                        kitty::set_bit(op, 2); 
+                    if (solver_var_value(_solver, dag_get_op_var(i, 1, 1)))
+                        kitty::set_bit(op, 3); 
+
+                    if (_verbosity) {
+                        printf("  step x_%d performs operation\n  ",i+_nr_in+1);
+                        kitty::print_binary(op, std::cout);
+                        printf("\n");
+                    }
+
+                    auto vertex = dag.get_vertex(i);
+                    if (_verbosity) {
+                        printf("  with operands x_%d and x_%d", 
+                                vertex.first+1, vertex.second+1);
+                    }
+                    op_inputs[0] = vertex.first;
+                    op_inputs[1] = vertex.second;
+                    chain.set_step(i, op_inputs, op);
+
+                    if (_verbosity) {
+                        printf("\n");
+                    }
+                }
+
+                chain.set_output(0, ((_nr_in + _nr_steps) << 1));
+                if (invert) {
+                    chain.invert();
+                }
+            }
+
+            synth_result 
+            synthesize(const TT& spec, const dag<2>& dag, chain<2>& chain)
+            {
+                TT local_spec = spec;
+
+                bool invert = false;
+                if (!is_normal(spec)) {
+                    local_spec = ~local_spec;
+                    invert = true;
+                }
+                if (!add_clauses(local_spec, dag)) {
+                    return failure;
+                }
+                auto status = solver_solve(_solver, 0, 0, 0);
+                if (status == success) {
+                    dag_chain_extract(dag, chain, invert);
+                }
+                return status;
+            }
+            
+            *******************************************************************
+                Synthesizes while allowing for different input permutations.
+            *******************************************************************
+            synth_result 
+            perm_synthesize(
+                    const TT& spec, 
+                    dag<2>& dag, 
+                    chain<2>& chain, 
+                    std::vector<int>& perm)
+            {
+                const auto num_vars = spec.num_vars();
+                assert(num_vars <= 6 && perm.size() == num_vars);
+
+                if (num_vars <= 2) {
+                    return synthesize(spec, dag, chain);
+                }
+
+                bool invert = false;
+                TT local_spec = spec;
+                if (!is_normal(spec)) {
+                    local_spec = ~local_spec;
+                    invert = true;
+                }
+                        
+                std::iota( perm.begin(), perm.end(), 0u );
+                if (add_clauses(local_spec, dag)) {
+                    auto status = solver_solve(_solver, 0, 0, 0);
+                    if (status == success) {
+                        dag_chain_extract(dag, chain, invert);
+                        return success;
+                    }
+                }
+
+                const auto& swaps = kitty::detail::swaps[num_vars - 2u];
+                for (std::size_t i = 0; i < swaps.size(); i++) {
+                    const auto pos = swaps[i];
+
+                    dag.swap_adjacent_inplace(pos);
+
+                    if (!add_clauses(local_spec, dag)) {
+                        continue;
+                    }
+                    auto status = solver_solve(_solver, 0, 0, 0);
+                    if (status == success) {
+                        dag_chain_extract(dag, chain, invert);
+                        for (auto j = 0; j <= i; j++) {
+                            const auto pos = swaps[i];
+                            std::swap(perm[pos], perm[pos + 1]);
+                        }
+                        return success;
+                    }
+                }
+
+                return failure;
+            }
+
+            void print_solver_state()
+            {
+                printf("\n");
+                printf("========================================"
+                        "========================================\n");
+                printf("  SOLVER STATE\n\n");
+
+                for (int i = 0; i < _nr_steps; i++) {
+                    printf("  f_%d = ", _nr_in+i+1);
+                    printf("%d", solver_var_value(_solver, 
+                                dag_get_op_var(i, 1, 1)));
+                    printf("%d", solver_var_value(_solver, 
+                                dag_get_op_var(i, 1, 0)));
+                    printf("%d", solver_var_value(_solver, 
+                                dag_get_op_var(i, 0, 1)));
+                    printf("0\n");
+                    printf("  tt_%d = ", _nr_in+i+1);
+                    for (int t = _tt_size - 1; t >= 0; t--) {
+                        printf("%d", solver_var_value(_solver, 
+                                    dag_get_sim_var(i, t)));
+                    }
+                    printf("0\n\n");
+                }
+
+                for (int i = 0; i < _nr_steps; i++) {
+                    printf("\n");
+                    printf("f_%d_0_0=0\n", _nr_in+i+1);
+                    printf("f_%d_0_1=%d\n", _nr_in+i+1, solver_var_value(
+                                _solver, dag_get_op_var(i, 0, 1)));
+                    printf("f_%d_1_0=%d\n", _nr_in+i+1, solver_var_value(
+                                _solver, dag_get_op_var(i, 1, 0)));
+                    printf("f_%d_1_1=%d\n", _nr_in+i+1, solver_var_value(
+                                _solver, dag_get_op_var(i, 1, 1)));
+                    printf("\n");
+                    for (int t = _tt_size - 1; t >= 0; t--) {
+                        printf("x_%d_%d=%d\n", _nr_in+i+1, t+1, 
+                                solver_var_value(
+                                    _solver, dag_get_sim_var(i, t)));
+                    }
+                    printf("x_%d_0=0\n", _nr_in+i);
+                    printf("\n");
+                }
+                printf("\n");
+
+                printf("========================================"
+                        "========================================\n");
+            }
+    };
+*/
+
+
+    /***************************************************************************
+        A DAG generator based on a SAT formulation.
+    ***************************************************************************/
+    class sat_dag_generator
+    {
+        private:
+            bsat_wrapper _solver;
+            pabc::Vec_Int_t* _vLits; // Dynamic vector of literals for clauses.
+            int _nr_vars;
+            int _nr_vertices;
+            bool _reset;
+            int _verbosity = 0;
+
+            // If true, the generate will only create DAGs that correspond
+            // to functions with full support.
+            bool _gen_true_dags = false;
+
+            // If true, generates only connected DAGs.
+            bool _gen_connected_dags = true;
+            
+            // If true, generates colexicographically ordered DAGs.
+            bool _gen_colex_dags = true;
+            
+            // If true, generates DAGs without potential reapplication of
+            // operands.
+            bool _gen_noreapply_dags = true;
+
+            int dag_get_sel_var(int i, int j, int k)
+            {
+                int offset = 0;
+
+                assert(i < _nr_vertices);
+                assert(k < _nr_vars + i);
+                assert(j < k);
+
+                for (int a = _nr_vars; a < _nr_vars + i; a++)
+                    offset += a * ( a - 1 ) / 2;
+
+                return offset + ((-j * ( 1 + j - 2 * (_nr_vars + i))) / 2) +
+                    (k - j - 1);
+            }
+
+            void create_variables()
+            {
+                int nr_sel_vars = 0;
+                for (int i = _nr_vars; i < _nr_vars + _nr_vertices; i++) {
+                    nr_sel_vars += ( i * ( i - 1 ) ) / 2;
+                    /*if (_verbosity > 1) {
+                        printf("adding %d svars\n", ( i * ( i - 1 ) ) / 2);
+                    }*/
+                }
+                /*
+                if (_verbosity > 1) {
+                    printf("creating %d svars\n", nr_sel_vars);
+                }
+                */
+                _solver.set_nr_vars(nr_sel_vars);
+                pabc::Vec_IntGrowResize(_vLits, nr_sel_vars);
+            }
+
+            /*******************************************************************
+                Ensures that each vertex has fanin 2.
+            *******************************************************************/
+            void 
+            create_op_clauses()
+            {
+                for (int i = 0; i < _nr_vertices; i++)
+                {
+                    int ctr = 0;
+                    for (int k = 1; k < _nr_vars + i; k++) {
+                        for (int j = 0; j < k; j++) {
+                            pabc::Vec_IntSetEntry(_vLits, ctr++, 
+                                    pabc::Abc_Var2Lit(dag_get_sel_var(i, j, k ), 0 ));
+                        }
+                    }
+                    _solver.add_clause(
+                        pabc::Vec_IntArray(_vLits), 
+                        pabc::Vec_IntArray(_vLits) + ctr);
+                }
+            }
+
+            /*******************************************************************
+              Add clauses which ensure that every vertex is used at least once.
+             ******************************************************************/
+            void 
+            create_alonce_clauses()
+            {
+                // Make sure that all input variables are covered
+                /*
+                if (_gen_true_dags) {
+                    for (int j = 0; j < _nr_vars; j++) {
+                        auto ctr = 0;
+                        for (int i = 0; i < _nr_vertices; i++) {
+                            for (int k = j+1; k < _nr_vars + i; k++) {
+                                Vec_IntSetEntry(_vLits, ctr++, pabc::Abc_Var2Lit(
+                                            dag_get_sel_var(i, j, k), 0));
+                            }
+                            for (int k = 0; k < j; k++) {
+                                pabc::Vec_IntSetEntry(_vLits, ctr++, pabc::Abc_Var2Lit(
+                                            dag_get_sel_var(i, k, j), 0));
+                            }
+                        }
+                        solver_add_clause(_solver, pabc::Vec_IntArray(_vLits),
+                                pabc::Vec_IntArray(_vLits) + ctr);
+                    }
+                }
+                */
+                // Make sure that all internal vertices are covered
+                for (int i = 0; i < _nr_vertices - 1; i++) {
+                    auto ctr = 0;
+                    for (int ip = i + 1; ip < _nr_vertices; ip++) {
+                        for (int j = 0; j < _nr_vars+i; j++) {
+                            pabc::Vec_IntSetEntry(_vLits, ctr++, pabc::Abc_Var2Lit(
+                                        dag_get_sel_var(ip, j, _nr_vars+i), 0));
+                        }
+                        for (int j = _nr_vars+i+1; j < _nr_vars+ip; j++) {
+                            pabc::Vec_IntSetEntry(_vLits, ctr++, pabc::Abc_Var2Lit(
+                                        dag_get_sel_var(ip, _nr_vars+i, j), 0));
+                        }
+                    }
+                    _solver.add_clause(pabc::Vec_IntArray(_vLits), pabc::Vec_IntArray(_vLits) + ctr);
+                }
+            }
+
+            void create_unique_fanin_clauses()             
+            { 
+                int pLits[2];
+
+                for (int i = 0; i < _nr_vertices; i++) {
+                    for (int k = 2; k < _nr_vars+i; k++) {
+                        for (int j = 0; j < k; j++) {
+                            for (int kp = 1; kp <= k; kp++) {
+                                for (int jp = 0; jp < kp; jp++) {
+                                    if (kp == k && jp >= j) {
+                                        break;
+                                    }
+                                    pLits[0] = 
+                                        pabc::Abc_Var2Lit(dag_get_sel_var(i,j,k),1);
+                                    pLits[1] = pabc::Abc_Var2Lit(
+                                            dag_get_sel_var(i,jp,kp),1);
+                                    _solver.add_clause(pLits, pLits+2);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            /*******************************************************************
+                Add clauses which ensure that dag vertices occur in
+                co-lexicographic order. This ensures that we do not generate
+                many symmetric dags.
+            *******************************************************************/
+            void create_colex_clauses()
+            {
+                int pLits[2];
+
+                for (int i = 0; i < _nr_vertices-1; i++) {
+                    for (int k = 2; k < _nr_vars+i; k++) {
+                        for (int j = 1; j < k; j++) {
+                            for (int jp = 0; jp < j; jp++) {
+                                pLits[0] = pabc::Abc_Var2Lit(
+                                        dag_get_sel_var(i, j, k), 1);
+                                pLits[1] = pabc::Abc_Var2Lit(
+                                        dag_get_sel_var(i+1, jp, k), 1);
+                                _solver.add_clause(pLits, pLits+2);
+                            }
+                        }
+                        for (int j = 0; j < k; j++) {
+                            for (int kp = 1; kp < k; kp++) {
+                                for (int jp = 0; jp < kp; jp++) {
+                                    pLits[0] = pabc::Abc_Var2Lit(
+                                            dag_get_sel_var(i, j, k), 1);
+                                    pLits[1] = pabc::Abc_Var2Lit(
+                                            dag_get_sel_var(i+1, jp, kp),1);
+                                    _solver.add_clause(pLits, pLits + 2);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            /*******************************************************************
+                Add clauses which ensure that operands are never re-applied. In
+                other words, (Sijk --> ~Si'ji) & (Sijk --> ~Si'ki)
+                for all (i < i').
+            *******************************************************************/
+            void create_noreapply_clauses()
+            {
+                int pLits[2];
+
+                for (int i = 0; i < _nr_vertices; i++) {
+                    for (int ip = i+1; ip < _nr_vertices; ip++) {
+                        for (int k = 1; k < _nr_vars+i; k++) {
+                            for (int j = 0; j < k; j++) {
+                                pLits[0] = pabc::Abc_Var2Lit(
+                                        dag_get_sel_var(i, j, k), 1);
+                                pLits[1] = pabc::Abc_Var2Lit(
+                                        dag_get_sel_var(ip, j, _nr_vars+i),1);
+                                _solver.add_clause(pLits, pLits + 2);
+                                pLits[1] = pabc::Abc_Var2Lit(
+                                        dag_get_sel_var(ip, k, _nr_vars+i),1);
+                                _solver.add_clause(pLits, pLits+2);
+                            }
+                        }
+                    }
+                }
+            }
+
+            void dag_extract(dag<2>& g)
+            {
+                g.reset(_nr_vars, _nr_vertices);
+
+                for (int i = 0; i < _nr_vertices; i++) {
+                    int found = 0;
+                    for (int k = 1; (k < _nr_vars + i); k++) {
+                        for (int j = 0; j < k; j++) {
+                            if (_solver.var_value(dag_get_sel_var(i, j, k)))
+                            {
+                                g.set_vertex(i, j, k);
+                                found++;
+                            }
+
+                        }
+                    }
+                    assert(found == 1);
+                }
+            }
+
+            bool block_solution()
+            {
+                int ctr = 0;
+                for (int i = 0; i < _nr_vertices; i++) {
+                    int found = 0;
+                    for (int k = 1; (k < (_nr_vars + i)); k++) {
+                        for (int j = 0; j < k; j++) {
+                            if (_solver.var_value(dag_get_sel_var(i, j, k)))
+                            {
+                                pabc::Vec_IntSetEntry(_vLits, ctr++,
+                                        pabc::Abc_Var2Lit(dag_get_sel_var(i, j, k),
+                                            1)); 
+                                found++;
+                            }
+                        }
+                    }
+                    assert(found == 1);
+                }
+                assert(ctr == _nr_vertices);
+
+                auto status = _solver.add_clause(
+                    pabc::Vec_IntArray(_vLits),
+                    pabc::Vec_IntArray(_vLits) + ctr);
+
+                if (_verbosity > 1) {
+                    printf("nr vars=%d, nr clauses=%d\n", _solver.nr_vars(), _solver.nr_clauses());
+                }
+                return status;
+            }
+
+        public:
+            sat_dag_generator()
+            {
+                _vLits = pabc::Vec_IntAlloc(0);
+            }
+
+            ~sat_dag_generator()
+            {
+                pabc::Vec_IntFree(_vLits);
+            }
+
+            int nr_vars() const { return _nr_vars; }
+            int nr_vertices() const { return _nr_vertices; }
+
+            void gen_true_dags(bool gen) { _gen_true_dags = gen; }
+
+            void verbosity(int verbosity) { _verbosity = verbosity; }
+            int verbosity() { return _verbosity; }
+
+            void gen_connected_dags(bool gen_connected_dags)
+            {
+                _gen_connected_dags = gen_connected_dags;
+            }
+
+            bool gen_connected_dags() { return _gen_connected_dags; }
+
+            void gen_colex_dags(bool gen_colex_dags) 
+            { 
+                _gen_colex_dags = gen_colex_dags;
+            }
+
+            bool gen_colex_dags() { return _gen_colex_dags; }
+
+            void gen_noreapply_dags(bool gen_noreapply_dags)
+            {
+                _gen_noreapply_dags = gen_noreapply_dags;
+            }
+
+            bool gen_noreapply_dags() { return _gen_noreapply_dags; }
+
+            void reset(int nr_vars, int nr_vertices)
+            {
+                assert(nr_vars > 0);
+                assert(nr_vertices > 0);
+
+                if (_verbosity) {
+                    printf("setting nr. vars=%d\n", nr_vars);
+                    printf("setting nr. vertices=%d\n", nr_vertices);
+                }
+
+                _reset = true;
+                _nr_vars = nr_vars;
+                _nr_vertices = nr_vertices;
+                _solver.restart();
+                create_variables();
+                create_op_clauses();
+                create_unique_fanin_clauses();
+                if (_gen_connected_dags) {
+                    create_alonce_clauses();
+                }
+                if (_gen_colex_dags) {
+                    create_colex_clauses();
+                }
+                if (_gen_noreapply_dags) {
+                    create_noreapply_clauses();
+                }
+
+
+                if (_verbosity) {
+                    printf("starting with %d vars, %d clauses\n", 
+                            _solver.nr_vars(), 
+                            _solver.nr_clauses());
+                }
+            }
+
+            bool next_dag(dag<2>& g)
+            {
+                if (!_reset) {
+                    // Block current solution
+                    if (!block_solution()) {
+                        return false;
+                    }
+                }
+                _reset = false;
+                auto status = _solver.solve(0, 0, 0);
+                if (status == success) {
+                    dag_extract(g);
+
+                    /*
+                    printf("Found solution: ");
+                    for (auto i = 0; i < g.nr_vertices(); i++) {
+                        const auto& step = g.get_vertex(i);
+                        if (i > 0) {
+                            printf(" - ");
+                        }
+                        printf("(%d, %d)", step.first+1, step.second+1);
+                    }
+                    printf("\n");
+                    */
+                    return true;
+                } else {
+                    return false;
+                }
+            }
+
+            int count_dags() {
+                dag<2> g;
+                int counter = 0;
+                while (next_dag(g)) {
+                    counter++;
+                }
+                return counter;
+            }
+    };
+
+    class unbounded_dag_generator
+    {
+        private:
+            int nr_inputs;
+            sat_dag_generator gen;
+
+        public:
+            unbounded_dag_generator()
+            {
+                nr_inputs = -1;
+            }
+
+            void reset(int n) {
+                assert(n > 0);
+
+                nr_inputs = n;
+                gen.reset(nr_inputs, 1);
+            }
+
+            void gen_true_dags(bool true_dags) { gen.gen_true_dags(true_dags); }
+
+            bool next_dag(dag<2>& g)
+            {
+                if (!gen.next_dag(g)) {
+                    gen.reset(nr_inputs, gen.nr_vertices()+1);
+                    return next_dag(g);
+                }
+                return true;
+            }
+
+    };
+
+#if !defined(DISABLE_NAUTY)
+    class nonisomorphic_dag_generator
+    {
+        private:
+            int _nr_vars;
+            unbounded_dag_generator _gen;
+            std::vector<dag<2>> _dags;
+
+        public:
+            nonisomorphic_dag_generator()
+            {
+                _nr_vars = -1;
+            }
+
+            void reset(int nr_vars) {
+                assert(nr_vars > 0);
+
+                _nr_vars = nr_vars;
+                _gen.reset(nr_vars);
+                _dags.clear();
+            }
+
+            void gen_true_dags(bool gen) { _gen.gen_true_dags(gen); }
+
+            int nr_dags() { return _dags.size(); }
+
+            bool next_dag(dag<2>& g)
+            {
+                while (true) {
+                    bool found_isomorphism = false;
+                    _gen.next_dag(g);
+                    const auto num_vertices = g.get_nr_vertices();
+                    for (int i = (_dags.size()-1); i >= 0; i--) {
+                        const auto& g2 = _dags[i];
+                        if (g2.get_nr_vertices() != num_vertices) {
+                            // We haven't found an isomorphism.
+                            _dags.push_back(g);
+                            return true;
+                        }
+                        if (g.is_isomorphic(g2)) {
+                            // We've found an isomorphism, generate next DAG.
+                            found_isomorphism = true;
+                            break;
+                        }
+                    }
+                    if (!found_isomorphism) {
+                        _dags.push_back(g);
+                        return true;
+                    }
+                }
+            }
+
+    };
+#endif
+    
+    /***************************************************************************
+        Generates DAGs using a recursive backtrack search.
+    ***************************************************************************/
+    class rec_dag_generator
+    {
+        private:
+            int _nr_vars;
+            int _nr_vertices;
+            int _verbosity = 0;
+            bool _initialized;
+            int _level;
+            uint64_t _nr_solutions;
+
+            // Array indicating which steps have been covered. (And how many
+            // times.) 
+            int _covered_steps[18];
+
+            // Array indicating which steps are "disabled", meaning that
+            // selecting them will not result in a valid DAG.
+            int _disabled_matrix[18][18][18];
+
+            // If true, generates only connected DAGs.
+            bool _gen_connected_dags = true;
+
+            // If true, generates colexicographically ordered DAGs.
+            bool _gen_colex_dags = true;
+            
+            // If true, generates DAGs without potential reapplication of
+            // operands.
+            bool _gen_noreapply_dags = true;
+
+            // The index at which backtracking should terminate.
+            int _stop_level = -1;
+
+            // Function to call when a solution is found.
+            std::function<void(rec_dag_generator*)> _callback;
+
+
+        public:
+            rec_dag_generator() : _initialized(false)
+            {
+            }
+
+            // Two arrays that represent the "stack" of selected steps.
+            int _js[18];
+            int _ks[18];
+
+            // The level from which the search is assumed to have started
+            int _start_level = 0;
+
+            int nr_vars() const { return _nr_vars; }
+            int nr_vertices() const { return _nr_vertices; }
+
+            void verbosity(int verbosity) { _verbosity = verbosity; }
+            int verbosity() { return _verbosity; }
+            
+            void gen_connected_dags(bool gen_connected_dags)
+            {
+                _gen_connected_dags = gen_connected_dags;
+            }
+
+            bool gen_connected_dags() { return _gen_connected_dags; }
+
+            void gen_colex_dags(bool gen_colex_dags) 
+            { 
+                _gen_colex_dags = gen_colex_dags;
+            }
+
+            bool gen_colex_dags() { return _gen_colex_dags; }
+
+            void gen_noreapply_dags(bool gen_noreapply_dags)
+            {
+                _gen_noreapply_dags = gen_noreapply_dags;
+            }
+
+            bool gen_noreapply_dags() { return _gen_noreapply_dags; }
+
+            void set_callback(std::function<void(rec_dag_generator*)>& f)
+            {
+                _callback = f;
+            }
+
+            void set_callback(std::function<void(rec_dag_generator*)>&& f)
+            {
+                _callback = std::move(f);
+            }
+
+            void clear_callback()
+            {
+                _callback = 0;
+            }
+
+            void reset(int nr_vars, int nr_vertices)
+            {
+                assert(nr_vars > 0);
+                assert(nr_vertices > 0);
+                
+                if (_verbosity) {
+                    printf("setting nr. vars=%d\n", nr_vars);
+                    printf("setting nr. vertices=%d\n", nr_vertices);
+                }
+                
+                _nr_vars = nr_vars;
+                _nr_vertices = nr_vertices;
+                
+                for (int i = 0; i < 18; i++) {
+                    _covered_steps[i] = 0;
+                }
+
+                for (int i = 0; i < 18; i++) {
+                    for (int j = 0; j < 18; j++) {
+                        for (int k = 0; k < 18; k++) {
+                            _disabled_matrix[i][j][k] = 0;
+                        }
+                    }
+                }
+
+                _js[0] = 0;
+                _ks[0] = 1;
+
+                _nr_solutions = 0;
+                _level = 0;
+                _stop_level = -1;
+                
+                _initialized = true;
+            }
+
+            auto count_tuples()
+            {
+                assert(_initialized);
+                _level = _start_level;
+                _nr_solutions = 0;
+
+                search_tuples();
+
+                return _nr_solutions;
+            }
+
+            void search_tuples()
+            {
+                if (_level == _nr_vertices) {
+                    ++_nr_solutions;
+                    if (_verbosity) {
+                        printf("Found solution: ");
+                        for (int i = 0; i < _nr_vertices; i++) {
+                            const auto j = _js[i];
+                            const auto k = _ks[i];
+                            if (i > 0) {
+                                printf(" - ");
+                            }
+                            printf("(%d, %d)", j+1, k+1);
+                        }
+                        printf("\n");
+                    }
+                    backtrack();
+                } else {
+                    for (int k = 1; k < _nr_vars + _level; k++) {
+                        for (int j = 0; j < k; j++) {
+                            _js[_level] = j;
+                            _ks[_level] = j;
+                            ++_level;
+                            search_tuples();
+                        }
+                    }
+                    backtrack();
+                }
+            }
+
+            auto count_connected_dags()
+            {
+                assert(_initialized);
+                _level = _start_level;
+                _nr_solutions = 0;
+
+                search_connected_dags();
+
+                return _nr_solutions;
+            }
+
+            void search_connected_dags()
+            {
+                if (_level == _nr_vertices) {
+                    for (int i = _nr_vars; i < _nr_vars+_nr_vertices-1; i++) {
+                        if (_covered_steps[i] == 0) {
+                            // There is some uncovered internal step, so the
+                            // graph cannot be connected.
+                            backtrack();
+                            return;
+                        }
+                    }
+                    ++_nr_solutions;
+                    if (_verbosity) {
+                        printf("Found solution: ");
+                        for (int i = 0; i < _nr_vertices; i++) {
+                            const auto j = _js[i];
+                            const auto k = _ks[i];
+                            if (i > 0) {
+                                printf(" - ");
+                            }
+                            printf("(%d, %d)", j+1, k+1);
+                        }
+                        printf("\n");
+                    }
+                    backtrack();
+                } else {
+                    for (int k = 1; k < _nr_vars + _level; k++) {
+                        for (int j = 0; j < k; j++) {
+                            _js[_level] = j;
+                            _ks[_level] = k;
+                            ++_covered_steps[j];
+                            ++_covered_steps[k];
+                            ++_level;
+                            search_connected_dags();
+                        }
+                    }
+                    backtrack();
+                }
+            }
+
+            auto count_colex_dags()
+            {
+                assert(_initialized);
+                _level = _start_level;
+                _nr_solutions = 0;
+
+                search_colex_dags();
+
+                return _nr_solutions;
+            }
+
+            void search_colex_dags()
+            {
+                if (_level == _nr_vertices) {
+                    for (int i = _nr_vars; i < _nr_vars+_nr_vertices-1; i++) {
+                        if (_covered_steps[i] == 0) {
+                            // There is some uncovered internal step, so the
+                            // graph cannot be connected.
+                            backtrack();
+                            return;
+                        }
+                    }
+                    ++_nr_solutions;
+                    if (_verbosity) {
+                        printf("Found solution: ");
+                        for (int i = 1; i <= _nr_vertices; i++) {
+                            const auto j = _js[i];
+                            const auto k = _ks[i];
+                            if (i > 0) {
+                                printf(" - ");
+                            }
+                            printf("(%d, %d)", j+1, k+1);
+                        }
+                        printf("\n");
+                    }
+                    backtrack();
+                } else {
+                    // We are only interested in DAGs that are in
+                    // co-lexicographical order. Look at the previous step
+                    // on the stack, the current step should be greater or
+                    // equal to it.
+                    const auto start_j = _js[_level];
+                    const auto start_k = _ks[_level];
+
+                    _ks[_level] = start_k;
+                    for (int j = start_j; j < start_k; j++) {
+                        ++_covered_steps[j];
+                        ++_covered_steps[start_k];
+                        ++_level;
+                        _js[_level] = j;
+                        search_colex_dags();
+                    }
+                    for (int k = start_k+1; k < _nr_vars + _level; k++) {
+                        for (int j = 0; j < k; j++) {
+                            ++_covered_steps[j];
+                            ++_covered_steps[k];
+                            ++_level;
+                            _js[_level] = j;
+                            _ks[_level] = k;
+                            search_colex_dags();
+                        }
+                    }
+
+                    backtrack();
+                }
+            }
+
+            auto count_noreapply_dags()
+            {
+                assert(_initialized);
+                _nr_solutions = 0;
+
+                search_noreapply_dags();
+
+                return _nr_solutions;
+            }
+
+            void search_noreapply_dags()
+            {
+                if (_level == _nr_vertices) {
+                    ++_nr_solutions;
+                    if (_callback) {
+                        _callback(this);
+                    }
+                    if (_verbosity) {
+                        printf("Found solution: ");
+                        for (int i = 1; i <= _nr_vertices; i++) {
+                            const auto j = _js[i];
+                            const auto k = _ks[i];
+                            if (i > 0) {
+                                printf(" - ");
+                            }
+                            printf("(%d, %d)", j+1, k+1);
+                        }
+                        printf("\n");
+                    }
+                    noreapply_backtrack();
+                } else {
+                    // We are only interested in DAGs that are in
+                    // co-lexicographical order. Look at the previous step
+                    // on the stack, the current step should be greater or
+                    // equal to it.
+                    const auto start_j = _js[_level];
+                    const auto start_k = _ks[_level];
+
+                    _ks[_level+1] = start_k;
+                    for (int j = start_j; j < start_k; j++) {
+                        if (_disabled_matrix[_level][j][start_k]) {
+                            continue;
+                        }
+
+                        // If we choose fanin (j, k), record that j and k
+                        // are covered.
+                        ++_covered_steps[j];
+                        ++_covered_steps[start_k];
+
+                        int uncovered = 0;
+                        for (int i = _nr_vars; i <= _nr_vars+_level; i++) {
+                            if (_covered_steps[i] == 0) {
+                                ++uncovered;
+                            }
+                        }
+                        if (uncovered > _nr_vertices-_level) {
+                            --_covered_steps[j];
+                            --_covered_steps[start_k];
+                            continue;
+                        }
+
+                        // We are adding step (i, j, k). This means that we
+                        // don't have to consider steps (i',j,i) or (i',k,i)
+                        // for i < i' <= n+r. This avoiding reapplying an
+                        // operand.
+                        for (int ip = _level+1; ip < _nr_vertices; ip++) {
+                            ++_disabled_matrix[ip][j][_nr_vars+_level];
+                            ++_disabled_matrix[ip][start_k][_nr_vars+_level];
+                        }
+
+                        ++_level;
+                        _js[_level] = j;
+                        search_noreapply_dags();
+                    }
+                    for (int k = start_k+1; k < _nr_vars + _level; k++) {
+                        for (int j = 0; j < k; j++) {
+                            if (_disabled_matrix[_level][j][k]) {
+                                continue;
+                            }
+                            ++_covered_steps[j];
+                            ++_covered_steps[k];
+
+                            int uncovered = 0;
+                            for (int i = _nr_vars; i <= _nr_vars+_level; i++) {
+                                if (_covered_steps[i] == 0) {
+                                    ++uncovered;
+                                }
+                            }
+                            if (uncovered > _nr_vertices-_level) {
+                                --_covered_steps[j];
+                                --_covered_steps[k];
+                                continue;
+                            }
+
+                            for (int ip = _level+1; ip < _nr_vertices; ip++) {
+                                ++_disabled_matrix[ip][j][_nr_vars+_level];
+                                ++_disabled_matrix[ip][k][_nr_vars+_level];
+                            }
+                            ++_level;
+                            _js[_level] = j;
+                            _ks[_level] = k;
+
+                            search_noreapply_dags();
+                        }
+                    }
+
+                    noreapply_backtrack();
+                }
+            }
+
+            // TODO: fix this function to work with new synthesis API
+            void search_dags(
+                    spec& spec, 
+                    dag<2>& g, 
+                    chain& chain)
+            {
+                // We can terminate early if a solution has already been found.
+                if (_nr_solutions > 0) {
+                    return;
+                } else if (_level == _nr_vertices) {
+                    for (int i = 1; i <= _nr_vertices; i++) {
+                        const auto j = _js[i];
+                        const auto k = _ks[i];
+                        g.set_vertex(i-1, j, k);
+                    }
+                    const auto result = success; // TODO: fix! dag_synthesize(spec, g, chain);
+                    if (result == success) {
+                        ++_nr_solutions;
+                        if (_verbosity) {
+                            printf("Found solution: ");
+                            for (int i = 1; i <= _nr_vertices; i++) {
+                                const auto j = _js[i];
+                                const auto k = _ks[i];
+                                if (i > 0) {
+                                    printf(" - ");
+                                }
+                                printf("(%d, %d)", j+1, k+1);
+                            }
+                            printf("\n");
+                        }
+                    }
+                    noreapply_backtrack();
+                } else {
+                    // We are only interested in DAGs that are in
+                    // co-lexicographical order. Look at the previous step
+                    // on the stack, the current step should be greater or
+                    // equal to it.
+                    const auto start_j = _js[_level];
+                    const auto start_k = _ks[_level];
+
+                    _ks[_level+1] = start_k;
+                    for (int j = start_j; j < start_k && !_nr_solutions; j++) {
+                        if (_disabled_matrix[_level][j][start_k]) {
+                            continue;
+                        }
+
+                        // If we choose fanin (j, k), record that j and k
+                        // are covered.
+                        ++_covered_steps[j];
+                        ++_covered_steps[start_k];
+
+                        int uncovered = 0;
+                        for (int i = _nr_vars; i <= _nr_vars+_level; i++) {
+                            if (_covered_steps[i] == 0) {
+                                ++uncovered;
+                            }
+                        }
+                        if (uncovered > _nr_vertices-_level) {
+                            --_covered_steps[j];
+                            --_covered_steps[start_k];
+                            continue;
+                        }
+
+                        // We are adding step (i, j, k). This means that we
+                        // don't have to consider steps (i',j,i) or (i',k,i)
+                        // for i < i' <= n+r. This avoiding reapplying an
+                        // operand.
+                        for (int ip = _level+1; ip < _nr_vertices; ip++) {
+                            ++_disabled_matrix[ip][j][_nr_vars+_level];
+                            ++_disabled_matrix[ip][start_k][_nr_vars+_level];
+                        }
+
+                        ++_level;
+                        _js[_level] = j;
+                        search_dags(spec, g, chain);
+                    }
+                    for (int k = start_k+1; (k < _nr_vars+_level && 
+                            !_nr_solutions); k++) {
+                        for (int j = 0; j < k && !_nr_solutions; j++) {
+                            if (_disabled_matrix[_level][j][k]) {
+                                continue;
+                            }
+                            ++_covered_steps[j];
+                            ++_covered_steps[k];
+
+                            int uncovered = 0;
+                            for (int i = _nr_vars; i <= _nr_vars+_level; i++) {
+                                if (_covered_steps[i] == 0) {
+                                    ++uncovered;
+                                }
+                            }
+                            if (uncovered > _nr_vertices-_level) {
+                                --_covered_steps[j];
+                                --_covered_steps[k];
+                                continue;
+                            }
+
+                            for (int ip = _level+1; ip < _nr_vertices; ip++) {
+                                ++_disabled_matrix[ip][j][_nr_vars+_level];
+                                ++_disabled_matrix[ip][k][_nr_vars+_level];
+                            }
+                            ++_level;
+                            _js[_level] = j;
+                            _ks[_level] = k;
+
+                            search_dags(spec, g, chain);
+                        }
+                    }
+
+                    noreapply_backtrack();
+                }
+            }
+
+            void 
+            qpsearch_dags(
+                    dag<2>& g, 
+                    moodycamel::ConcurrentQueue<dag<2>>& q, 
+                    bool* found)
+            {
+                if (*found) {
+                    return;
+                } else if (_level == _nr_vertices) {
+                    g.reset(_nr_vars, _nr_vertices);
+                    for (int i = 1; i <= _nr_vertices; i++) {
+                        const auto j = _js[i];
+                        const auto k = _ks[i];
+                        g.set_vertex(i-1, j, k);
+                    }
+                    while (!q.try_enqueue(g)) {
+                        std::this_thread::yield();
+                        // It's possible that a consumer thread finds a
+                        // solution while the queue is full.
+                        if (*found) {
+                            break;
+                        }
+                    }
+                    noreapply_backtrack();
+                } else {
+                    // We are only interested in DAGs that are in
+                    // co-lexicographical order. Look at the previous step
+                    // on the stack, the current step should be greater or
+                    // equal to it.
+                    const auto start_j = _js[_level];
+                    const auto start_k = _ks[_level];
+
+                    _ks[_level+1] = start_k;
+                    for (int j = start_j; j < start_k && !(*found); j++) {
+                        if (_disabled_matrix[_level][j][start_k]) {
+                            continue;
+                        }
+
+                        // If we choose fanin (j, k), record that j and k
+                        // are covered.
+                        ++_covered_steps[j];
+                        ++_covered_steps[start_k];
+
+                        int uncovered = 0;
+                        for (int i = _nr_vars; i <= _nr_vars+_level; i++) {
+                            if (_covered_steps[i] == 0) {
+                                ++uncovered;
+                            }
+                        }
+                        if (uncovered > _nr_vertices-_level) {
+                            --_covered_steps[j];
+                            --_covered_steps[start_k];
+                            continue;
+                        }
+
+                        // We are adding step (i, j, k). This means that we
+                        // don't have to consider steps (i',j,i) or (i',k,i)
+                        // for i < i' <= n+r. This avoiding reapplying an
+                        // operand.
+                        for (int ip = _level+1; ip < _nr_vertices; ip++) {
+                            ++_disabled_matrix[ip][j][_nr_vars+_level];
+                            ++_disabled_matrix[ip][start_k][_nr_vars+_level];
+                        }
+
+                        ++_level;
+                        _js[_level] = j;
+                        qpsearch_dags(g, q, found);
+                    }
+                    for (int k = start_k+1; k < _nr_vars+_level && 
+                            !(*found); k++) {
+                        for (int j = 0; j < k && !(*found); j++) {
+                            if (_disabled_matrix[_level][j][k]) {
+                                continue;
+                            }
+                            ++_covered_steps[j];
+                            ++_covered_steps[k];
+
+                            int uncovered = 0;
+                            for (int i = _nr_vars; i <= _nr_vars+_level; i++) {
+                                if (_covered_steps[i] == 0) {
+                                    ++uncovered;
+                                }
+                            }
+                            if (uncovered > _nr_vertices-_level) {
+                                --_covered_steps[j];
+                                --_covered_steps[k];
+                                continue;
+                            }
+
+                            for (int ip = _level+1; ip < _nr_vertices; ip++) {
+                                ++_disabled_matrix[ip][j][_nr_vars+_level];
+                                ++_disabled_matrix[ip][k][_nr_vars+_level];
+                            }
+                            ++_level;
+                            _js[_level] = j;
+                            _ks[_level] = k;
+
+                            qpsearch_dags(g, q, found);
+                        }
+                    }
+
+                    noreapply_backtrack();
+                }
+            }
+
+            void backtrack() 
+            {
+                --_level;
+                if (_level > _stop_level) {
+                    const auto j = _js[_level];
+                    const auto k = _ks[_level];
+                    --_covered_steps[j];
+                    --_covered_steps[k];
+                }
+            }
+
+            void noreapply_backtrack() 
+            {
+                const auto j = _js[_level];
+                const auto k = _ks[_level];
+                --_level;
+                if (_level > _stop_level) {
+                    --_covered_steps[j];
+                    --_covered_steps[k];
+                    for (int ip = _level+1; ip < _nr_vertices; ip++) {
+                        --_disabled_matrix[ip][j][_nr_vars+_level];
+                        --_disabled_matrix[ip][k][_nr_vars+_level];
+                    }
+                }
+            }
+            
+            auto count_dags()
+            {
+                if (!_gen_connected_dags) {
+                    return count_tuples();
+                } else if (!_gen_colex_dags) {
+                    return count_connected_dags();
+                } else if (!_gen_noreapply_dags) {
+                    return count_colex_dags();
+                } else {
+                    return count_noreapply_dags();
+                }
+            }
+
+            void add_selection(int j, int k)
+            {
+                assert(_level < _nr_vertices);
+                for (int ip = _level+1; ip < _nr_vertices; ip++) {
+                    ++_disabled_matrix[ip][j][_nr_vars+_level];
+                    ++_disabled_matrix[ip][k][_nr_vars+_level];
+                }
+                ++_level;
+                ++_stop_level;
+                _js[_level] = j;
+                _ks[_level] = k;
+                ++_covered_steps[j];
+                ++_covered_steps[k];
+            }
+
+            std::vector<dag<2>> 
+            gen_dags()
+            {
+                assert(_initialized);
+                dag<2> g;
+                std::vector<dag<2>> dags;
+                
+                const auto nr_vars = _nr_vars;
+                const auto nr_vertices = _nr_vertices;
+
+                g.reset(nr_vars, nr_vertices);
+                set_callback([&dags, &g, nr_vertices]
+                        (rec_dag_generator* gen) {
+                            for (int i = 1; i <= nr_vertices; i++) {
+                                g.set_vertex(i-1, gen->_js[i], gen->_ks[i]);
+                            }
+                            dags.push_back(g);
+                        }
+                );
+                count_dags();
+                clear_callback();
+
+                return dags;
+            }
+
+            /*******************************************************************
+                Enumerates DAGs until one is found that can implement the given
+                function. Fails if no DAG of the current size can implement
+                the function.
+            *******************************************************************/
+            synth_result 
+            find_dag(
+                    spec& spec, 
+                    dag<2>& g, 
+                    chain& chain)
+            {
+                assert(_initialized);
+
+                search_dags(spec, g, chain);
+
+                if (_nr_solutions > 0) {
+                    return success;
+                } else {
+                    return failure;
+                }
+            }
+
+            /*******************************************************************
+                Parallel version of find_dag based on putting enumerated DAGs
+                into a concurrent queue.
+            *******************************************************************/
+            void 
+            qpfind_dag(moodycamel::ConcurrentQueue<dag<2>>& q, bool* found)
+            {
+                dag<2> g;
+                assert(_initialized);
+
+                assert(_nr_solutions == 0);
+                qpsearch_dags(g, q, found);
+            }
+
+#ifndef DISABLE_NAUTY
+            uint64_t 
+            count_non_isomorphic_dags()
+            {
+                assert(_initialized);
+                dag<2> g;
+                std::vector<dag<2>> dags;
+                const auto nr_vars = _nr_vars;
+                const auto nr_vertices = _nr_vertices;
+
+                g.reset(nr_vars, nr_vertices);
+                set_callback([&dags, &g, nr_vars, nr_vertices]
+                        (rec_dag_generator* gen) {
+                            for (int i = 1; i <= nr_vertices; i++) {
+                                g.set_vertex(i-1, gen->_js[i], gen->_ks[i]);
+                            }
+                            bool is_isomorphic = false;
+                            for (const auto& dag : dags) {
+                                if (dag.is_isomorphic(g)) {
+                                    is_isomorphic = true;
+                                    break;
+                                }
+                            }
+                            if (!is_isomorphic) {
+                                dags.push_back(g);
+                            }
+                        }
+                );
+                count_dags();
+                clear_callback();
+
+                return uint64_t(dags.size());
+            }
+
+            std::vector<dag<2>> 
+            gen_non_isomorphic_dags()
+            {
+                assert(_initialized);
+                dag<2> g;
+                std::vector<dag<2>> dags;
+                const auto nr_vars = _nr_vars;
+                const auto nr_vertices = _nr_vertices;
+
+                g.reset(nr_vars, nr_vertices);
+                set_callback([&dags, &g, nr_vars, nr_vertices]
+                        (rec_dag_generator* gen) {
+                            for (int i = 1; i <= nr_vertices; i++) {
+                                g.set_vertex(i-1, gen->_js[i], gen->_ks[i]);
+                            }
+                            bool is_isomorphic = false;
+                            for (const auto& dag : dags) {
+                                if (dag.is_isomorphic(g)) {
+                                    is_isomorphic = true;
+                                    break;
+                                }
+                            }
+                            if (!is_isomorphic) {
+                                dags.push_back(g);
+                            }
+                        }
+                );
+                count_dags();
+                clear_callback();
+
+                return dags;
+            }
+#endif
+    };
+    
+}
+
diff --git a/lib/percy/percy/encoders.hpp b/lib/percy/percy/encoders.hpp
new file mode 100644
index 0000000..ed65392
--- /dev/null
+++ b/lib/percy/percy/encoders.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+#include "encoders/ssv_encoder.hpp"
+#include "encoders/ssv_fence_encoder.hpp"
+#include "encoders/ssv_fence2_encoder.hpp"
+#include "encoders/ssv_dag_encoder.hpp"
+#include "encoders/msv_encoder.hpp"
+#include "encoders/ditt_encoder.hpp"
+#include "encoders/partial_dag_encoder.hpp"
+#include "encoders/maj_encoder.hpp"
+#include "encoders/mig_encoder.hpp"
+#include "encoders/ditt_maj_encoder.hpp"
diff --git a/lib/percy/percy/encoders/aig_encoder.hpp b/lib/percy/percy/encoders/aig_encoder.hpp
new file mode 100644
index 0000000..612b073
--- /dev/null
+++ b/lib/percy/percy/encoders/aig_encoder.hpp
@@ -0,0 +1,1696 @@
+#pragma once
+
+#include <vector>
+#include <kitty/kitty.hpp>
+#include "encoder.hpp"
+
+namespace percy
+{
+    class aig_encoder
+    {
+    private:
+        int level_dist[32]; // How many steps are below a certain level
+        int nr_levels; // The number of levels in the Boolean fence
+        int nr_sel_vars;
+        int nr_res_vars;
+        int nr_sim_vars;
+        int total_nr_vars;
+        int sel_offset;
+        int res_offset;
+        int sim_offset;
+        bool dirty = false;
+        pabc::lit pLits[2048];
+        solver_wrapper* solver;
+
+        static const int NR_SIM_TTS = 32;
+        std::vector<kitty::dynamic_truth_table> sim_tts { NR_SIM_TTS };
+
+        int get_sim_var(const spec& spec, int step_idx, int t) const
+        {
+            return sim_offset + spec.tt_size * step_idx + t;
+        }
+
+        bool fix_output_sim_vars(const spec& spec, int t)
+        {
+            const auto ilast_step = spec.nr_steps - 1;
+            auto outbit = kitty::get_bit(
+                spec[spec.synth_func(0)], t + 1);
+            if ((spec.out_inv >> spec.synth_func(0)) & 1) {
+                outbit = 1 - outbit;
+            }
+            const auto sim_var = get_sim_var(spec, ilast_step, t);
+            pabc::lit sim_lit = pabc::Abc_Var2Lit(sim_var, 1 - outbit);
+            return solver->add_clause(&sim_lit, &sim_lit + 1);
+        }
+
+        int get_sel_var(
+            const spec& spec, 
+            const int i, 
+            const int j, 
+            const int k,
+            const int l) const
+        {
+            assert(i < spec.nr_steps);
+
+            int offset = 0;
+            for (int ip = 0; ip < i; ip++) {
+                const auto n = spec.nr_in + ip;
+                offset += (n * (n - 1) * (n - 2)) / 6;
+            }
+
+            int svar_ctr = 0;
+            for (int lp = 2; lp < spec.nr_in + i; lp++) {
+                for (int kp = 1; kp < lp; kp++) {
+                    for (int jp = 0; jp < kp; jp++) {
+                        if (l == lp && k == kp && j == jp) {
+                            return sel_offset + offset + svar_ctr;
+                        }
+                        svar_ctr++;
+                    }
+                }
+            }
+
+            assert(false);
+            return -1;
+        }
+
+        int get_sel_var(const spec& spec, int idx, int var_idx) const
+        {
+            assert(idx < spec.nr_steps);
+            const auto nr_svars_for_idx = nr_svars_for_step(spec, idx);
+            assert(var_idx < nr_svars_for_idx);
+            auto offset = 0;
+            for (int i = 0; i < idx; i++) {
+                offset += nr_svars_for_step(spec, i);
+            }
+            return sel_offset + offset + var_idx;
+        }
+
+        int get_res_var(const spec& spec, int step_idx, int res_var_idx) const
+        {
+            auto offset = 0;
+            for (int i = 0; i < step_idx; i++) {
+                offset += (nr_svars_for_step(spec, i) + 1) * (1 + 2);
+            }
+
+            return res_offset + offset + res_var_idx;
+        }
+
+    public:
+        aig_encoder(solver_wrapper& solver)
+        {
+            this->solver = &solver;
+        }
+
+        ~aig_encoder()
+        {
+        }
+
+        void create_variables(const spec& spec)
+        {
+            nr_sim_vars = spec.nr_steps * spec.tt_size;
+
+            nr_sel_vars = 0;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto n = spec.nr_in + i;
+                nr_sel_vars += (n * (n - 1)) / 2;
+            }
+
+            sel_offset = 0;
+            sim_offset = nr_sel_vars;
+            total_nr_vars = nr_sel_vars + nr_sim_vars;
+
+            if (spec.verbosity) {
+                printf("Creating variables (AIG)\n");
+                printf("nr steps = %d\n", spec.nr_steps);
+                printf("nr_sel_vars=%d\n", nr_sel_vars);
+                printf("nr_sim_vars = %d\n", nr_sim_vars);
+                printf("creating %d total variables\n", total_nr_vars);
+            }
+
+            solver->set_nr_vars(total_nr_vars);
+        }
+
+        void create_variables(const spec& spec, const partial_dag& dag)
+        {
+            nr_sim_vars = spec.nr_steps * spec.tt_size;
+
+            nr_sel_vars = 0;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto nr_svars_for_i = nr_svars_for_step(spec, dag, i);
+                nr_sel_vars += nr_svars_for_i;
+            }
+
+            sel_offset = 0;
+            sim_offset = nr_sel_vars;
+            total_nr_vars = nr_sel_vars + nr_sim_vars;
+
+            if (spec.verbosity) {
+                printf("Creating variables (PD-%d)\n", spec.fanin);
+                printf("nr steps = %d\n", spec.nr_steps);
+                printf("nr_sel_vars=%d\n", nr_sel_vars);
+                printf("nr_sim_vars = %d\n", nr_sim_vars);
+                printf("creating %d total variables\n", total_nr_vars);
+            }
+
+            solver->set_nr_vars(total_nr_vars);
+        }
+
+        int first_step_on_level(int level) const
+        {
+            if (level == 0) { return 0; }
+            return level_dist[level-1];
+        }
+
+        int nr_svars_for_step(const spec& spec, int i) const
+        {
+            // Determine the level of this step.
+            const auto level = get_level(spec, i + spec.nr_in);
+            auto nr_svars_for_i = 0;
+            assert(level > 0);
+            for (auto l = first_step_on_level(level - 1);
+                l < first_step_on_level(level); l++) {
+                // We select l as fanin 3, so have (l choose 2) options 
+                // (j,k in {0,...,(l-1)}) left for fanin 1 and 2.
+                nr_svars_for_i += (l * (l - 1)) / 2;
+            }
+
+            return nr_svars_for_i;
+        }
+
+        int nr_pi_fanins_for_step(const partial_dag& dag, int i) const
+        {
+            const auto& vertex = dag.get_vertex(i);
+            auto nr_pi_fanins = 0;
+            if (vertex[2] == FANIN_PI) {
+                nr_pi_fanins = 3;
+            } else if (vertex[1] == FANIN_PI) {
+                nr_pi_fanins = 2;
+            } else if (vertex[0] == FANIN_PI) {
+                nr_pi_fanins = 1;
+            }
+
+            return nr_pi_fanins;
+        }
+
+        int nr_svars_for_step(
+            const spec& spec, 
+            const partial_dag& dag, 
+            int i) const
+        {
+            const auto& vertex = dag.get_vertex(i);
+            const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, i);
+            switch (nr_pi_fanins) {
+            case 1:
+                return spec.nr_in;
+            case 2:
+                return (spec.nr_in * (spec.nr_in - 1)) / 2;
+            case 3:
+                return (spec.nr_in * (spec.nr_in - 1) * (spec.nr_in - 2)) / 6;
+            default: // No fanin flexibility
+                return 0;
+            }
+        }
+
+        int get_sel_var(
+            const spec& spec,
+            const partial_dag& dag,
+            int step_idx,
+            int var_idx) const
+        {
+            auto offset = 0;
+            for (int i = 0; i < step_idx; i++) {
+                offset += nr_svars_for_step(spec, dag, i);
+            }
+            return sel_offset + offset + var_idx;
+        }
+
+        void fence_create_variables(const spec& spec)
+        {
+            nr_sim_vars = spec.nr_steps * spec.tt_size;
+
+            nr_sel_vars = 0;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                nr_sel_vars += nr_svars_for_step(spec, i);
+            }
+
+            sel_offset = 0;
+            sim_offset = nr_sel_vars;
+            total_nr_vars = nr_sel_vars + nr_sim_vars;
+
+            if (spec.verbosity) {
+                printf("Creating variables (AIG)\n");
+                printf("nr steps = %d\n", spec.nr_steps);
+                printf("nr_sel_vars=%d\n", nr_sel_vars);
+                printf("nr_sim_vars = %d\n", nr_sim_vars);
+                printf("creating %d total variables\n", total_nr_vars);
+            }
+
+            solver->set_nr_vars(total_nr_vars);
+        }
+
+        void cegar_fence_create_variables(const spec& spec)
+        {
+            nr_sim_vars = spec.nr_steps * spec.tt_size;
+
+            nr_sel_vars = 0;
+            nr_res_vars = 0;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto nr_svars_for_i = nr_svars_for_step(spec, i);
+                nr_sel_vars += nr_svars_for_i;
+                nr_res_vars += (nr_svars_for_i + 1) * (1 + 2);
+            }
+
+            sel_offset = 0;
+            res_offset = nr_sel_vars;
+            sim_offset = nr_sel_vars + nr_res_vars;
+            total_nr_vars = nr_sel_vars + nr_res_vars + nr_sim_vars;
+
+            if (spec.verbosity) {
+                printf("Creating variables (AIG)\n");
+                printf("nr steps = %d\n", spec.nr_steps);
+                printf("nr_sel_vars=%d\n", nr_sel_vars);
+                printf("nr_sel_vars=%d\n", nr_res_vars);
+                printf("nr_sim_vars = %d\n", nr_sim_vars);
+                printf("creating %d total variables\n", total_nr_vars);
+            }
+
+            solver->set_nr_vars(total_nr_vars);
+        }
+
+        /// Ensures that each gate has the proper number of fanins.
+        bool create_fanin_clauses(const spec& spec)
+        {
+            auto status = true;
+
+            if (spec.verbosity > 2) {
+                printf("Creating fanin clauses (AIG)\n");
+                printf("Nr. clauses = %d (PRE)\n", solver->nr_clauses());
+            }
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                auto ctr = 0;
+                for (int l = 2; l < spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto svar = get_sel_var(spec, i, j, k, l);
+                            pLits[ctr++] = pabc::Abc_Var2Lit(svar, 0);
+                        }
+                    }
+                }
+                status &= solver->add_clause(pLits, pLits + ctr);
+            }
+
+            if (spec.verbosity > 2) {
+                printf("Nr. clauses = %d (POST)\n", solver->nr_clauses());
+            }
+
+            return status;
+        }
+
+        bool create_fanin_clauses(const spec& spec, const partial_dag& dag)
+        {
+            auto status = true;
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto nr_svars_for_i = nr_svars_for_step(spec, dag, i);
+                if (nr_svars_for_i == 0) {
+                    continue;
+                }
+
+                for (int j = 0; j < nr_svars_for_i; j++) {
+                    pLits[j] = pabc::Abc_Var2Lit(get_sel_var(spec, dag, i, j), 0);
+                }
+
+                status &= solver->add_clause(pLits, pLits + nr_svars_for_i);
+            }
+
+            return status;
+        }
+
+        
+        bool add_simulation_clause(
+            const spec& spec,
+            const int t,
+            const int i,
+            const int j,
+            const int k,
+            const int l,
+            const int c,
+            const int b,
+            const int a,
+            const int sel_var
+            )
+        {
+            int ctr = 0;
+            //assert(j > 0);
+
+            if (j < spec.nr_in) {
+                if ((((t + 1) & (1 << j)) ? 1 : 0) != a) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, j - spec.nr_in, t), a);
+            }
+
+            if (k < spec.nr_in) {
+                if ((((t + 1) & (1 << k)) ? 1 : 0) != b) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, k - spec.nr_in, t), b);
+            }
+
+            if (l < spec.nr_in) {
+                if ((((t + 1) & (1 << l)) ? 1 : 0) != c) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, l - spec.nr_in, t), c);
+            }
+
+            if (sel_var != -1) {
+                pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+            }
+
+            if (maj3(a, b, c)) {
+                pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 0);
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 1);
+            }
+
+            const auto ret = solver->add_clause(pLits, pLits + ctr);
+            assert(ret);
+            return ret;
+        }
+
+        bool create_tt_clauses(const spec& spec, const int t)
+        {
+            bool ret = true;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                for (int l = 2; l < spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, j, k);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 1, sel_var);
+                        }
+                    }
+                }
+                assert(ret);
+            }
+
+            ret &= fix_output_sim_vars(spec, t);
+
+            return ret;
+        }
+
+        bool create_tt_clauses(const spec& spec, const partial_dag& dag, const int t)
+        {
+            auto ret = true;
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto& vertex = dag.get_vertex(i);
+                const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, i);
+                if (nr_pi_fanins == 0) {
+                    // The fanins for this step are fixed
+                    const auto j = vertex[0] + spec.nr_in - 1;
+                    const auto k = vertex[1] + spec.nr_in - 1;
+                    const auto l = vertex[1] + spec.nr_in - 1;
+                    ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 0, -1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 1, -1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 0, -1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 1, -1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 0, -1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 1, -1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 0, -1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 1, -1);
+                } else if (nr_pi_fanins == 1) {
+                    // The first fanin is flexible
+                    const auto k = vertex[1] + spec.nr_in - 1;
+                    const auto l = vertex[2] + spec.nr_in - 1;
+                    for (int j = 0; j < spec.nr_in; j++) {
+                        const auto sel_var = get_sel_var(spec, dag, i, j);
+                        ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 0, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 1, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 0, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 1, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 0, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 1, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 0, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 1, sel_var);
+                    }
+                } else if (nr_pi_fanins == 2) {
+                    const auto l = vertex[2] + spec.nr_in - 1;
+                    int ctr = 0;
+                    for (int k = 1; k < spec.nr_in; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, dag, i, ctr++);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 1, sel_var);
+                        }
+                    }
+                } else {
+                    assert(nr_pi_fanins == 3);
+                    int ctr = 0;
+                    for (int l = 2; l < spec.nr_in; l++) {
+                        for (int k = 1; k < l; k++) {
+                            for (int j = 0; j < k; j++) {
+                                const auto sel_var = get_sel_var(spec, dag, i, ctr++);
+                                ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 0, sel_var);
+                                ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 1, sel_var);
+                                ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 0, sel_var);
+                                ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 1, sel_var);
+                                ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 0, sel_var);
+                                ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 1, sel_var);
+                                ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 0, sel_var);
+                                ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 1, sel_var);
+                            }
+                        }
+                    }
+                }
+            }
+            
+            ret &= fix_output_sim_vars(spec, t);
+
+            return ret;
+        }
+
+        bool fence_create_tt_clauses(const spec& spec, const int t)
+        {
+            bool ret = true;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto level = get_level(spec, i + spec.nr_in);
+                int ctr = 0;
+                for (int l = first_step_on_level(level - 1);
+                    l < first_step_on_level(level); l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, ctr++);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 1, sel_var);
+                        }
+                    }
+                }
+                assert(ret);
+            }
+
+            ret &= fix_output_sim_vars(spec, t);
+
+            return ret;
+        }
+
+        void create_main_clauses(const spec& spec)
+        {
+            for (int t = 0; t < spec.tt_size; t++) {
+                (void)create_tt_clauses(spec, t);
+            }
+        }
+
+        void create_main_clauses(const spec& spec, const partial_dag& dag)
+        {
+            for (int t = 0; t < spec.tt_size; t++) {
+                (void)create_tt_clauses(spec, dag, t);
+            }
+        }
+
+        bool fence_create_main_clauses(const spec& spec)
+        {
+            bool ret = true;
+            for (int t = 0; t < spec.tt_size; t++) {
+                ret &= fence_create_tt_clauses(spec, t);
+            }
+            return ret;
+        }
+
+        void create_alonce_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                int ctr = 0;
+                const auto idx = spec.nr_in + i;
+                for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                    for (int l = spec.nr_in + i; l < spec.nr_in + ip; l++) {
+                        for (int k = 1; k < l; k++) {
+                            for (int j = 0; j < k; j++) {
+                                if (j == idx || k == idx || l == idx) {
+                                    const auto sel_var = get_sel_var(spec, ip, j, k, l);
+                                    pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 0);
+                                }
+                            }
+                        }
+                    }
+                }
+                const auto res = solver->add_clause(pLits, pLits + ctr);
+                assert(res);
+            }
+        }
+
+        void fence_create_alonce_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                auto ctr = 0;
+                const auto idx = spec.nr_in + i;
+                const auto level = get_level(spec, idx);
+                for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                    auto levelp = get_level(spec, ip + spec.nr_in);
+                    assert(levelp >= level);
+                    if (levelp == level) {
+                        continue;
+                    }
+                    auto svctr = 0;
+                    for (int l = first_step_on_level(levelp - 1);
+                        l < first_step_on_level(levelp); l++) {
+                        for (int k = 1; k < l; k++) {
+                            for (int j = 0; j < k; j++) {
+                                if (j == idx || k == idx || l == idx) {
+                                    const auto sel_var = get_sel_var(spec, ip, svctr);
+                                    pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 0);
+                                }
+                                svctr++;
+                            }
+                        }
+                    }
+                    assert(svctr == nr_svars_for_step(spec, ip));
+                }
+                solver->add_clause(pLits, pLits + ctr);
+            }
+        }
+
+        void create_noreapply_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                for (int l = 2; l < spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, j, k, l);
+                            pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                            for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                                for (int kp = 1; kp < spec.nr_steps + i; kp++) {
+                                    for (int jp = 0; jp < kp; jp++) {
+                                        if ((kp == l && jp == k) || 
+                                            (kp == k && jp == j) ||
+                                            (kp == l && jp == k)) {
+                                            const auto sel_varp = get_sel_var(spec, ip, jp, kp, spec.nr_in + i);
+                                            pLits[1] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                            auto status = solver->add_clause(pLits, pLits + 2);
+                                            assert(status);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        bool reapply_helper(
+            const spec& spec,
+            const partial_dag& dag,
+            int *svars,
+            int depth,
+            int i, 
+            int j,
+            int k,
+            int l,
+            int ip,
+            int jp,
+            int kp,
+            int lp)
+        {
+            int pLits[3];
+            if (depth == 2) {
+                if (lp == (spec.nr_in + i) &&
+                    ((kp == l && jp == k) ||
+                    (kp == k && jp == j) ||
+                    (kp == l && jp == k))) {
+                    const auto sel_var = svars[0];
+                    const auto sel_varp = svars[1];
+                    auto ctr = 0;
+                    if (sel_var != -1) {
+                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+                    }
+                    if (sel_varp != -1) {
+                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 1);
+                    }
+                    if (ctr > 1) {
+                        return solver->add_clause(pLits, pLits + ctr);
+                    }
+                }
+            } else if (depth == 1) {
+                for (ip = i + 1; ip < spec.nr_steps; ip++) {
+                    const auto& vertex = dag.get_vertex(ip);
+                    const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, ip);
+                    if (nr_pi_fanins == 0) {
+                        svars[1] = -1;
+                        jp = spec.nr_in + vertex[0] - 1;
+                        kp = spec.nr_in + vertex[1] - 1;
+                        lp = spec.nr_in + vertex[2] - 1;
+                        reapply_helper(spec, dag, svars, 2, i, j, k, l, ip, jp, kp, lp);
+                    } else if (nr_pi_fanins == 1) {
+                        kp = spec.nr_in + vertex[1] - 1;
+                        lp = spec.nr_in + vertex[2] - 1;
+                        for (jp = 0; jp < spec.nr_in; jp++) {
+                            svars[1] = get_sel_var(spec, dag, ip, jp);
+                            reapply_helper(spec, dag, svars, 2, i, j, k, l, ip, jp, kp, lp);
+                        }
+                    } else if (nr_pi_fanins == 2) {
+                        auto svar_ctr = 0;
+                        lp = spec.nr_in + vertex[2] - 1;
+                        for (kp = 1; kp < spec.nr_in; kp++) {
+                            for (jp = 0; jp < kp; jp++) {
+                                const auto sel_var = get_sel_var(spec, dag, ip, svar_ctr++);
+                                svars[1] = sel_var;
+                                reapply_helper(spec, dag, svars, 2, i, j, k, l, ip, jp, kp, lp);
+                            }
+                        }
+                    } else {
+                        auto svar_ctr = 0;
+                        for (lp = 2; lp < spec.nr_in; lp++) {
+                            for (kp = 1; kp < lp; kp++) {
+                                for (jp = 0; jp < kp; jp++) {
+                                    const auto sel_var = get_sel_var(spec, dag, ip, svar_ctr++);
+                                    svars[1] = sel_var;
+                                    reapply_helper(spec, dag, svars, 2, i, j, k, l, ip, jp, kp, lp);
+                                }
+                            }
+                        }
+                    }
+                }
+            } else {
+                for (i = 0; i < spec.nr_steps; i++) {
+                    const auto& vertex = dag.get_vertex(i);
+                    const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, i);
+                    if (nr_pi_fanins == 0) {
+                        svars[0] = -1;
+                        j = spec.nr_in + vertex[0] - 1;
+                        k = spec.nr_in + vertex[1] - 1;
+                        l = spec.nr_in + vertex[2] - 1;
+                        reapply_helper(spec, dag, svars, 1, i, j, k, l, 0, 0, 0, 0);
+                    } else if (nr_pi_fanins == 1) {
+                        k = spec.nr_in + vertex[1] - 1;
+                        l = spec.nr_in + vertex[2] - 1;
+                        for (j = 0; j < spec.nr_in; j++) {
+                            svars[0] = get_sel_var(spec, dag, i, j);
+                            reapply_helper(spec, dag, svars, 1, i, j, k, l, 0, 0, 0, 0);
+                        }
+                    } else if (nr_pi_fanins == 2) {
+                        auto svar_ctr = 0;
+                        l = spec.nr_in + vertex[2] - 1;
+                        for (k = 1; k < spec.nr_in; k++) {
+                            for (j = 0; j < k; j++) {
+                                const auto sel_var = get_sel_var(spec, dag, i, svar_ctr++);
+                                svars[0] = sel_var;
+                                reapply_helper(spec, dag, svars, 1, i, j, k, l, 0, 0, 0, 0);
+                            }
+                        }
+                    } else {
+                        auto svar_ctr = 0;
+                        for (l = 2; l < spec.nr_in; l++) {
+                            for (k = 1; k < l; k++) {
+                                for (j = 0; j < k; j++) {
+                                    const auto sel_var = get_sel_var(spec, dag, i, svar_ctr++);
+                                    svars[0] = sel_var;
+                                    reapply_helper(spec, dag, svars, 1, i, j, k, l, 0, 0, 0, 0);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        bool create_noreapply_clauses(const spec& spec, const partial_dag& dag)
+        {
+            int svars[2];
+            
+            return reapply_helper(spec, dag, svars, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+        }
+
+
+        void fence_create_noreapply_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                const auto level = get_level(spec, spec.nr_in + i);
+                int svar_ctr = 0;
+                for (int l = first_step_on_level(level - 1); 
+                    l < first_step_on_level(level); l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, svar_ctr);
+                            pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                            for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                                const auto levelp = get_level(spec, spec.nr_in + ip);
+                                if (level == levelp) {
+                                    continue;
+                                }
+                                int svar_ctrp = 0;
+                                for (int lp = first_step_on_level(levelp - 1);
+                                    lp < first_step_on_level(levelp); lp++) {
+                                    for (int kp = 1; kp < l; kp++) {
+                                        for (int jp = 0; jp < kp; jp++) {
+                                            if ((lp == spec.nr_in + i) && 
+                                                ((kp == l && jp == k) ||
+                                                (kp == k && jp == j) ||
+                                                (kp == l && jp == k))) {
+                                                const auto sel_varp = get_sel_var(spec, ip, svar_ctrp);
+                                                pLits[1] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                                auto status = solver->add_clause(pLits, pLits + 2);
+                                                assert(status);
+                                            }
+                                            svar_ctrp++;
+                                        }
+                                    }
+                                }
+                            }
+                            svar_ctr++;
+                        }
+                    }
+                }
+            }
+        }
+
+        /// Ensure that all steps are in strict co-lexicographic
+        /// order. Unlike the general Boolean chain case, here we 
+        /// don't want two steps pointing to the same inputs since
+        /// they cannot implement different functions.
+        void create_colex_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                for (int l = 2; l < spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            pLits[0] = pabc::Abc_Var2Lit(get_sel_var(spec, i, j, k, l), 1);
+
+                            // Cannot have lp <= l
+                            for (int lp = 2; lp <= l; lp++) {
+                                for (int kp = 1; kp < lp; kp++) {
+                                    for (int jp = 0; jp < kp; jp++) {
+                                        pLits[1] = pabc::Abc_Var2Lit(get_sel_var(spec, i + 1, jp, kp, lp), 1);
+                                        const auto res = solver->add_clause(pLits, pLits + 2);
+                                        assert(res);
+                                    }
+                                }
+                            }
+
+                            // May have lp == l and kp > k
+                            for (int kp = 1; kp <= k; kp++) {
+                                for (int jp = 0; jp < kp; jp++) {
+                                    pLits[1] = pabc::Abc_Var2Lit(get_sel_var(spec, i + 1, jp, kp, l), 1);
+                                    const auto res = solver->add_clause(pLits, pLits + 2);
+                                    assert(res);
+                                }
+                            }
+                            // OR lp == l and kp == k
+                            for (int jp = 0; jp <= j; jp++) {
+                                pLits[1] = pabc::Abc_Var2Lit(get_sel_var(spec, i + 1, jp, k, l), 1);
+                                const auto res = solver->add_clause(pLits, pLits + 2);
+                                assert(res);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        void colex_helper(
+            const spec& spec,
+            const partial_dag& dag, 
+            int i, 
+            int j, 
+            int k, 
+            int l, 
+            int sel_var) 
+        {
+            int pLits[2];
+
+            const auto& vertex = dag.get_vertex(i + 1);
+            const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, i);
+            if (nr_pi_fanins == 1) {
+                const auto kp = spec.nr_in + vertex[1] - 1;
+                const auto lp = spec.nr_in + vertex[2] - 1;
+                for (int jp = 0; jp < spec.nr_in; jp++) {
+                    if ((kp == k && jp <= j && lp == l) || (kp < k && lp == l) || (lp < l)) {
+                        const auto sel_varp = get_sel_var(spec, dag, i + 1, jp);
+                        int ctr = 0;
+                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 1);
+                        (void)solver->add_clause(pLits, pLits + ctr);
+                    }
+                }
+            } else if (nr_pi_fanins == 2) {
+                auto svar_ctr = 0;
+                const auto lp = spec.nr_in + vertex[2] - 1;
+                for (int kp = 1; kp < spec.nr_in; kp++) {
+                    for (int jp = 0; jp < kp; jp++) {
+                        if ((kp == k && jp <= j && lp == l) || (kp < k && lp == l) || (lp < l)) {
+                            const auto sel_varp = get_sel_var(spec, dag, i + 1, svar_ctr);
+                            int ctr = 0;
+                            pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+                            pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 1);
+                            (void)solver->add_clause(pLits, pLits + ctr);
+                        }
+                        svar_ctr++;
+                    }
+                }
+            } else if (nr_pi_fanins == 3) {
+                auto svar_ctr = 0;
+                for (int lp = 2; lp < spec.nr_in; lp++) {
+                    for (int kp = 1; kp < lp; kp++) {
+                        for (int jp = 0; jp < kp; jp++) {
+                            if ((kp == k && jp <= j && lp == l) || (kp < k && lp == l) || (lp < l)) {
+                                const auto sel_varp = get_sel_var(spec, dag, i + 1, svar_ctr);
+                                int ctr = 0;
+                                pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+                                pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                (void)solver->add_clause(pLits, pLits + ctr);
+                            }
+                            svar_ctr++;
+                        }
+                    }
+                }
+            }
+        }
+
+        void create_colex_clauses(const spec& spec, const partial_dag& dag)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                const auto& vertex = dag.get_vertex(i);
+                const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, i);
+                if (nr_pi_fanins == 0) {
+                    continue;
+                } else if (nr_pi_fanins == 1) {
+                    const auto k = spec.nr_in + vertex[1] - 1;
+                    const auto l = spec.nr_in + vertex[2] - 1;
+                    for (int j = 0; j < spec.nr_in; j++) {
+                        const auto sel_var = get_sel_var(spec, dag, i, j);
+                        colex_helper(spec, dag, i, j, k, l, sel_var);
+                    }
+                } else if (nr_pi_fanins == 2) {
+                    auto svar_ctr = 0;
+                    const auto l = spec.nr_in + vertex[2] - 1;
+                    for (int k = 1; k < spec.nr_in; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, dag, i, svar_ctr++);
+                            colex_helper(spec, dag, i, j, k, l, sel_var);
+                        }
+                    }
+                } else {
+                    auto svar_ctr = 0;
+                    for (int l = 2; l < spec.nr_in; l++) {
+                        for (int k = 1; k < l; k++) {
+                            for (int j = 0; j < k; j++) {
+                                const auto sel_var = get_sel_var(spec, dag, i, svar_ctr++);
+                                colex_helper(spec, dag, i, j, k, l, sel_var);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        void fence_create_colex_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                const auto level = get_level(spec, i + spec.nr_in);
+                const auto levelp = get_level(spec, i + 1 + spec.nr_in);
+                int svar_ctr = 0;
+                for (int l = first_step_on_level(level-1); 
+                        l < first_step_on_level(level); l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            if (l < 3) {
+                                svar_ctr++;
+                                continue;
+                            }
+                            const auto sel_var = get_sel_var(spec, i, svar_ctr);
+                            pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                            int svar_ctrp = 0;
+                            for (int lp = first_step_on_level(levelp - 1);
+                                lp < first_step_on_level(levelp); lp++) {
+                                for (int kp = 1; kp < lp; kp++) {
+                                    for (int jp = 0; jp < kp; jp++) {
+                                        if ((lp == l && kp == k && jp <= j) || 
+                                            (lp == l && kp <= k) || (lp <= l)) {
+                                            const auto sel_varp = get_sel_var(spec, i + 1, svar_ctrp);
+                                            pLits[1] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                            (void)solver->add_clause(pLits, pLits + 2);
+                                        }
+                                        svar_ctrp++;
+                                    }
+                                }
+                            }
+                            svar_ctr++;
+                        }
+                    }
+                }
+            }
+        }
+
+        bool create_symvar_clauses(const spec& spec)
+        {
+            for (int q = 1; q < spec.nr_in; q++) {
+                for (int p = 0; p < q; p++) {
+                    auto symm = true;
+                    for (int i = 0; i < spec.nr_nontriv; i++) {
+                        auto f = spec[spec.synth_func(i)];
+                        if (!(swap(f, p, q) == f)) {
+                            symm = false;
+                            break;
+                        }
+                    }
+                    if (!symm) {
+                        continue;
+                    }
+
+                    for (int i = 1; i < spec.nr_steps; i++) {
+                        for (int l = 2; l < spec.nr_in + i; l++) {
+                            for (int k = 1; k < l; k++) {
+                                for (int j = 0; j < k; j++) {
+                                    if (!(j == q || k == q || l == q) || (j == p || k == p)) {
+                                        continue;
+                                    }
+                                    pLits[0] = pabc::Abc_Var2Lit(get_sel_var(spec, i, j, k, l), 1);
+                                    auto ctr = 1;
+                                    for (int ip = 0; ip < i; ip++) {
+                                        for (int lp = 2; lp < spec.nr_in + ip; lp++) {
+                                            for (int kp = 1; kp < lp; kp++) {
+                                                for (int jp = 0; jp < kp; jp++) {
+                                                    if (jp == p || kp == p || lp == p) {
+                                                        pLits[ctr++] = pabc::Abc_Var2Lit(get_sel_var(spec, ip, jp, kp, lp), 0);
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                    if (!solver->add_clause(pLits, pLits + ctr)) {
+                                        return false;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+
+        bool create_symvar_clauses(const spec& spec, const partial_dag& dag)
+        {
+            for (int q = 1; q < spec.nr_in; q++) {
+                for (int p = 0; p < q; p++) {
+                    auto symm = true;
+                    for (int i = 0; i < spec.nr_nontriv; i++) {
+                        auto f = spec[spec.synth_func(i)];
+                        if (!(swap(f, p, q) == f)) {
+                            symm = false;
+                            break;
+                        }
+                    }
+                    if (!symm) {
+                        continue;
+                    }
+
+                    for (int i = 1; i < spec.nr_steps; i++) {
+                        const auto vertex = dag.get_vertex(i);
+                        const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, i);
+
+                        if (nr_pi_fanins == 0) {
+                            continue;
+                        } else if (nr_pi_fanins == 1) {
+                            const auto sel_var = get_sel_var(spec, dag, i, q);
+                            pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                            auto ctr = 1;
+                            for (int ip = 0; ip < i; ip++) {
+                                const auto vertex2 = dag.get_vertex(ip);
+                                auto nr_pi_fanins2 = nr_pi_fanins_for_step(dag, ip);
+                                if (nr_pi_fanins2 == 0) {
+                                    continue;
+                                } else if (nr_pi_fanins2 == 1) {
+                                    const auto sel_varp = get_sel_var(spec, dag, ip, p);
+                                    pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                } else if (nr_pi_fanins2 == 2) {
+                                    auto svar_ctr = 0;
+                                    for (int k = 1; k < spec.nr_in; k++) {
+                                        for (int j = 0; j < k; j++) {
+                                            if (j == p || k == p) {
+                                                const auto sel_varp = get_sel_var(spec, dag, ip, svar_ctr);
+                                                pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                            }
+                                            svar_ctr++;
+                                        }
+                                    }
+                                } else {
+                                    auto svar_ctr = 0;
+                                    for (int l = 2; l < spec.nr_in; l++) {
+                                        for (int k = 1; k < l; k++) {
+                                            for (int j = 0; j < k; j++) {
+                                                if (j == p || k == p || l == p) {
+                                                    const auto sel_varp = get_sel_var(spec, dag, ip, svar_ctr);
+                                                    pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                                }
+                                                svar_ctr++;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            if (!solver->add_clause(pLits, pLits + ctr)) {
+                                return false;
+                            }
+                        } else if (nr_pi_fanins == 2) {
+                            auto svar_ctr = 0;
+                            for (int k = 1; k < spec.nr_in; k++) {
+                                for (int j = 0; j < k; j++) {
+                                    if (!(j == q || k == q) || j == p) {
+                                        svar_ctr++;
+                                        continue;
+                                    }
+                                    const auto sel_var = get_sel_var(spec, dag, i, svar_ctr);
+                                    pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                                    auto ctr = 1;
+                                    for (int ip = 0; ip < i; ip++) {
+                                        const auto vertex2 = dag.get_vertex(ip);
+                                        const auto nr_pi_fanins2 = nr_pi_fanins_for_step(dag, ip);
+                                        if (nr_pi_fanins2 == 0) {
+                                            continue;
+                                        } else if (nr_pi_fanins2 == 1) {
+                                            const auto sel_varp = get_sel_var(spec, dag, ip, p);
+                                            pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                        } else if (nr_pi_fanins2 == 2) {
+                                            auto svar_ctrp = 0;
+                                            for (int kp = 1; kp < spec.nr_in; kp++) {
+                                                for (int jp = 0; jp < kp; jp++) {
+                                                    if (jp == p || kp == p) {
+                                                        const auto sel_varp = get_sel_var(spec, dag, ip, svar_ctrp);
+                                                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                                    }
+                                                    svar_ctrp++;
+                                                }
+                                            }
+                                        } else {
+                                            auto svar_ctrp = 0;
+                                            for (int lp = 2; lp < spec.nr_in; lp++) {
+                                                for (int kp = 1; kp < lp; kp++) {
+                                                    for (int jp = 0; jp < kp; jp++) {
+                                                        if (jp == p || kp == p || lp == p) {
+                                                            const auto sel_varp = get_sel_var(spec, dag, ip, svar_ctrp);
+                                                            pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                                        }
+                                                        svar_ctrp++;
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                    if (!solver->add_clause(pLits, pLits + ctr)) {
+                                        return false;
+                                    }
+                                    svar_ctr++;
+                                }
+                            }
+                        } else {
+                            auto svar_ctr = 0;
+                            for (int l = 2; l < spec.nr_in; l++) {
+                                for (int k = 1; k < l; k++) {
+                                    for (int j = 0; j < k; j++) {
+                                        if (!(j == q || k == q || l == q) || (j == p || k == p)) {
+                                            svar_ctr++;
+                                            continue;
+                                        }
+                                        const auto sel_var = get_sel_var(spec, dag, i, svar_ctr);
+                                        pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                                        auto ctr = 1;
+                                        for (int ip = 0; ip < i; ip++) {
+                                            const auto vertex2 = dag.get_vertex(ip);
+                                            auto nr_pi_fanins2 = nr_pi_fanins_for_step(dag, ip);
+                                            if (nr_pi_fanins2 == 0) {
+                                                continue;
+                                            } else if (nr_pi_fanins2 == 1) {
+                                                const auto sel_varp = get_sel_var(spec, dag, ip, p);
+                                                pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                            } else if (nr_pi_fanins2 == 2) {
+                                                auto svar_ctrp = 0;
+                                                for (int kp = 1; kp < spec.nr_in; kp++) {
+                                                    for (int jp = 0; jp < kp; jp++) {
+                                                        if (jp == p || kp == p) {
+                                                            const auto sel_varp = get_sel_var(spec, dag, ip, svar_ctrp);
+                                                            pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                                        }
+                                                        svar_ctrp++;
+                                                    }
+                                                }
+                                            } else {
+                                                auto svar_ctrp = 0;
+                                                for (int lp = 2; lp < spec.nr_in; lp++) {
+                                                    for (int kp = 1; kp < lp; kp++) {
+                                                        for (int jp = 0; jp < kp; jp++) {
+                                                            if (jp == p || kp == p || lp == p) {
+                                                                const auto sel_varp = get_sel_var(spec, dag, ip, svar_ctrp);
+                                                                pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                                            }
+                                                            svar_ctrp++;
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        if (!solver->add_clause(pLits, pLits + ctr)) {
+                                            return false;
+                                        }
+                                        svar_ctr++;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+
+        void fence_create_symvar_clauses(const spec& spec)
+        {
+            for (int q = 1; q < spec.nr_in; q++) {
+                for (int p = 0; p < q; p++) {
+                    auto symm = true;
+                    for (int i = 0; i < spec.nr_nontriv; i++) {
+                        auto& f = spec[spec.synth_func(i)];
+                        if (!(swap(f, p, q) == f)) {
+                            symm = false;
+                            break;
+                        }
+                    }
+                    if (!symm) {
+                        continue;
+                    }
+                    for (int i = 1; i < spec.nr_steps; i++) {
+                        const auto level = get_level(spec, i + spec.nr_in);
+                        int svar_ctr = 0;
+                        for (int l = first_step_on_level(level - 1);
+                            l < first_step_on_level(level); l++) {
+                            for (int k = 1; k < l; k++) {
+                                for (int j = 0; j < k; j++) {
+                                    if (!(j == q || k == q || l == q) || (j == p || k == p)) {
+                                        svar_ctr++;
+                                        continue;
+                                    }
+                                    const auto sel_var = get_sel_var(spec, i, svar_ctr);
+                                    pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                                    auto ctr = 1;
+                                    for (int ip = 0; ip < i; ip++) {
+                                        const auto levelp = get_level(spec, spec.nr_in + ip);
+                                        auto svar_ctrp = 0;
+                                        for (int lp = first_step_on_level(levelp - 1);
+                                            lp < first_step_on_level(levelp); lp++) {
+                                            for (int kp = 1; kp < lp; kp++) {
+                                                for (int jp = 0; jp < kp; jp++) {
+                                                    if (jp == p || kp == p || lp == p) {
+                                                        const auto sel_varp = get_sel_var(spec, ip, svar_ctrp);
+                                                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                                    }
+                                                    svar_ctrp++;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    (void)solver->add_clause(pLits, pLits + ctr);
+                                    svar_ctr++;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        void create_cardinality_constraints(const spec& spec)
+        {
+            std::vector<int> svars;
+            std::vector<int> rvars;
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                svars.clear();
+                rvars.clear();
+                const auto level = get_level(spec, spec.nr_in + i);
+                auto svar_ctr = 0;
+                for (int l = first_step_on_level(level - 1);
+                    l < first_step_on_level(level); l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, svar_ctr++);
+                            svars.push_back(sel_var);
+                        }
+                    }
+                }
+                assert(svars.size() == nr_svars_for_step(spec, i));
+                const auto nr_res_vars = (1 + 2) * (svars.size() + 1);
+                for (int j = 0; j < nr_res_vars; j++) {
+                    rvars.push_back(get_res_var(spec, i, j));
+                }
+                create_cardinality_circuit(solver, svars, rvars, 1);
+
+                // Ensure that the fanin cardinality for each step i 
+                // is exactly FI.
+                const auto fi_var =
+                    get_res_var(spec, i, svars.size() * (1 + 2) + 1);
+                auto fi_lit = pabc::Abc_Var2Lit(fi_var, 0);
+                (void)solver->add_clause(&fi_lit, &fi_lit + 1);
+            }
+        }
+
+        void reset_sim_tts(int nr_in)
+        {
+            for (int i = 0; i < NR_SIM_TTS; i++) {
+                sim_tts[i] = kitty::dynamic_truth_table(nr_in);
+                if (i < nr_in) {
+                    kitty::create_nth_var(sim_tts[i], i);
+                }
+            }
+        }
+
+        bool encode(const spec& spec)
+        {
+            assert(spec.nr_in >= 3);
+
+            create_variables(spec);
+            create_main_clauses(spec);
+
+            if (!create_fanin_clauses(spec)) {
+                return false;
+            }
+
+            if (spec.add_alonce_clauses) {
+                create_alonce_clauses(spec);
+            }
+
+            if (spec.add_colex_clauses) {
+                create_colex_clauses(spec);
+            }
+            
+            if (spec.add_noreapply_clauses) {
+                create_noreapply_clauses(spec);
+            }
+            
+            if (spec.add_symvar_clauses && !create_symvar_clauses(spec)) {
+                return false;
+            }
+
+            return true;
+        }
+
+        bool encode(const spec& spec, const partial_dag& dag)
+        {
+            create_variables(spec, dag);
+            create_main_clauses(spec, dag);
+
+            if (!create_fanin_clauses(spec, dag)) {
+                return false;
+            }
+
+            if (spec.add_noreapply_clauses && !create_noreapply_clauses(spec, dag)) {
+                return false;
+            }
+
+            if (spec.add_colex_clauses) {
+                create_colex_clauses(spec, dag);
+            }
+
+            if (spec.add_symvar_clauses && !create_symvar_clauses(spec, dag)) {
+                return false;
+            }
+
+            return true;
+        }
+
+        void update_level_map(const spec& spec, const fence& f)
+        {
+            nr_levels = f.nr_levels();
+            level_dist[0] = spec.nr_in;
+            for (int i = 1; i <= nr_levels; i++) {
+                level_dist[i] = level_dist[i-1] + f.at(i-1);
+            }
+        }
+
+        int get_level(const spec& spec, int step_idx) const
+        {
+            // PIs are considered to be on level zero.
+            if (step_idx < spec.nr_in) {
+                return 0;
+            } else if (step_idx == spec.nr_in) { 
+                // First step is always on level one
+                return 1;
+            }
+            for (int i = 0; i <= nr_levels; i++) {
+                if (level_dist[i] > step_idx) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        bool fence_create_fanin_clauses(const spec& spec)
+        {
+            bool res = true;
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto nr_svars_for_i = nr_svars_for_step(spec, i);
+                for (int j = 0; j < nr_svars_for_i; j++) {
+                    const auto sel_var = get_sel_var(spec, i, j);
+                    pLits[j] = pabc::Abc_Var2Lit(sel_var, 0);
+                }
+
+                res &= solver->add_clause(pLits, pLits + nr_svars_for_i);
+            }
+
+            return res;
+        }
+
+        bool
+        encode(const spec& spec, const fence& f)
+        {
+            assert(spec.nr_in >= 3);
+            assert(spec.nr_steps == f.nr_nodes());
+
+            update_level_map(spec, f);
+            fence_create_variables(spec);
+            if (!fence_create_main_clauses(spec)) {
+                return false;
+            }
+
+            if (!fence_create_fanin_clauses(spec)) {
+                return false;
+            }
+            
+            if (spec.add_alonce_clauses) {
+                fence_create_alonce_clauses(spec);
+            }
+            
+            if (spec.add_colex_clauses) {
+                fence_create_colex_clauses(spec);
+            }
+
+            if (spec.add_noreapply_clauses) {
+                fence_create_noreapply_clauses(spec);
+            }
+
+            if (spec.add_symvar_clauses) {
+                fence_create_symvar_clauses(spec);
+            }
+
+            return true;
+        }
+
+        bool
+        cegar_encode(const spec& spec, const fence& f)
+        {
+            update_level_map(spec, f);
+            cegar_fence_create_variables(spec);
+            for (int i = 0; i < spec.nr_rand_tt_assigns; i++) {
+                const auto t = rand() % spec.get_tt_size();
+                (void)fence_create_tt_clauses(spec, t);
+            }
+
+            if (!fence_create_fanin_clauses(spec)) {
+                return false;
+            }
+            create_cardinality_constraints(spec);
+            
+            if (spec.add_alonce_clauses) {
+                fence_create_alonce_clauses(spec);
+            }
+            
+            if (spec.add_colex_clauses) {
+                fence_create_colex_clauses(spec);
+            }
+
+            if (spec.add_noreapply_clauses) {
+                fence_create_noreapply_clauses(spec);
+            }
+
+            if (spec.add_symvar_clauses) {
+                fence_create_symvar_clauses(spec);
+            }
+
+            return true;
+
+            assert(false);
+            return false;
+        }
+
+        void extract_chain(const spec& spec, chain& chain)
+        {
+            int op_inputs[3] = { 0, 0 };
+
+            chain.reset(spec.nr_in, 1, spec.nr_steps);
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const int op = 0;
+
+                for (int l = 2; l < spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, j, k, l);
+                            if (solver->var_value(sel_var)) {
+                                op_inputs[0] = j;
+                                op_inputs[1] = k;
+                                op_inputs[2] = l;
+                                break;
+                            }
+                        }
+                    }
+                }
+                chain.set_step(i, op_inputs[0], op_inputs[1], op_inputs[2], op);
+            }
+
+            // TODO: support multiple outputs
+            chain.set_output(0,
+                ((spec.nr_steps + spec.nr_in) << 1) +
+                ((spec.out_inv) & 1));
+        }
+
+        void fence_extract_chain(const spec& spec, chain& chain)
+        {
+            int op_inputs[3] = { 0, 0, 0 };
+
+            chain.reset(spec.nr_in, 1, spec.nr_steps);
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const int op = 0;
+
+                int ctr = 0;
+                const auto level = get_level(spec, spec.nr_in + i);
+                for (int l = first_step_on_level(level - 1); 
+                    l < first_step_on_level(level); l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, ctr++);
+                            if (solver->var_value(sel_var)) {
+                                op_inputs[0] = j;
+                                op_inputs[1] = k;
+                                op_inputs[2] = l;
+                                break;
+                            }
+                        }
+                    }
+                }
+                chain.set_step(i, op_inputs[0], op_inputs[1], op_inputs[2], op);
+            }
+
+            // TODO: support multiple outputs
+            chain.set_output(0,
+                ((spec.nr_steps + spec.nr_in) << 1) +
+                ((spec.out_inv) & 1));
+        }
+
+        void print_solver_state(spec& spec)
+        {
+            for (auto i = 0; i < spec.nr_steps; i++) {
+                for (int l = 2; l < spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, j, k, l);
+                            if (solver->var_value(sel_var)) {
+                                printf("s[%d][%d][%d][%d]=1\n", i, j, k, l);
+                            } else {
+                                printf("s[%d][%d][%d][%d]=0\n", i, j, k, l);
+                            }
+                        }
+                    }
+                }
+            }
+
+            for (auto i = 0; i < spec.nr_steps; i++) {
+                printf("tt_%d_0=0\n", i);
+                for (int t = 0; t < spec.tt_size; t++) {
+                    const auto sim_var = get_sim_var(spec, i, t);
+                    if (solver->var_value(sim_var)) {
+                        printf("tt_%d_%d=1\n", i, t + 1);
+                    } else {
+                        printf("tt_%d_%d=0\n", i, t + 1);
+                    }
+                }
+            }
+        }
+
+        void print_solver_state(spec& spec, const partial_dag& dag)
+        {
+            for (auto i = 0; i < spec.nr_steps; i++) {
+                const auto& vertex = dag.get_vertex(i);
+                const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, i);
+                if (nr_pi_fanins == 0) {
+                    continue;
+                } else if (nr_pi_fanins == 1) {
+                    const auto l = vertex[2] + spec.nr_in - 1;
+                    const auto k = vertex[1] + spec.nr_in - 1;
+                    for (int j = 0; j < spec.nr_in; j++) {
+                        const auto sel_var = get_sel_var(spec, dag, i, j);
+                        if (solver->var_value(sel_var)) {
+                            printf("s[%d][%d][%d][%d]=1\n", i, j, k, l);
+                        } else {
+                            printf("s[%d][%d][%d][%d]=0\n", i, j, k, l);
+                        }
+                    }
+                } else if (nr_pi_fanins == 2) {
+                    int ctr = 0;
+                    const auto l = vertex[2] + spec.nr_in - 1;
+                    for (int k = 1; k < spec.nr_in; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, dag, i, ctr++);
+                            if (solver->var_value(sel_var)) {
+                                printf("s[%d][%d][%d][%d]=1\n", i, j, k, l);
+                            } else {
+                                printf("s[%d][%d][%d][%d]=0\n", i, j, k, l);
+                            }
+                        }
+                    }
+                } else if (nr_pi_fanins == 3) {
+                    int ctr = 0;
+                    for (int l = 2; l < spec.nr_in; l++) {
+                        for (int k = 1; k < l; k++) {
+                            for (int j = 0; j < k; j++) {
+                                const auto sel_var = get_sel_var(spec, dag, i, ctr++);
+                                if (solver->var_value(sel_var)) {
+                                    printf("s[%d][%d][%d][%d]=1\n", i, j, k, l);
+                                } else {
+                                    printf("s[%d][%d][%d][%d]=0\n", i, j, k, l);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                for (auto i = 0; i < spec.nr_steps; i++) {
+                    printf("tt_%d_0=0\n", i);
+                    for (int t = 0; t < spec.tt_size; t++) {
+                        const auto sim_var = get_sim_var(spec, i, t);
+                        if (solver->var_value(sim_var)) {
+                            printf("tt_%d_%d=1\n", i, t + 1);
+                        } else {
+                            printf("tt_%d_%d=0\n", i, t + 1);
+                        }
+                    }
+                }
+            }
+        }
+
+        void fence_print_solver_state(spec& spec)
+        {
+            for (auto i = 0; i < spec.nr_steps; i++) {
+                const auto level = get_level(spec, i);
+                for (int l = first_step_on_level(level - 1);
+                    l < first_step_on_level(level); l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, j, k, l);
+                            if (solver->var_value(sel_var)) {
+                                printf("s[%d][%d][%d][%d]=1\n", i, j, k, l);
+                            } else {
+                                printf("s[%d][%d][%d][%d]=0\n", i, j, k, l);
+                            }
+                        }
+                    }
+                }
+            }
+
+            for (auto i = 0; i < spec.nr_steps; i++) {
+                printf("tt_%d_0=0\n", i);
+                for (int t = 0; t < spec.tt_size; t++) {
+                    const auto sim_var = get_sim_var(spec, i, t);
+                    if (solver->var_value(sim_var)) {
+                        printf("tt_%d_%d=1\n", i, t + 1);
+                    } else {
+                        printf("tt_%d_%d=0\n", i, t + 1);
+                    }
+                }
+            }
+        }
+        
+        bool cegar_encode(const spec& spec)
+        {
+            // TODO: implement
+            assert(false);
+            return false;
+        }
+        
+        bool block_solution(const spec& spec)
+        {
+            int ctr = 0;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                for (int l = 2; l < spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, j, k, l);
+                            if (solver->var_value(sel_var)) {
+                                pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            assert(ctr == spec.nr_steps);
+
+            return solver->add_clause(pLits, pLits + ctr);
+        }
+        
+        bool block_struct_solution(const spec& spec)
+        {
+            return block_solution(spec);
+        }
+
+        bool is_dirty() 
+        {
+            return dirty;
+        }
+
+        void set_dirty(bool _dirty)
+        {
+            dirty = _dirty;
+        }
+        
+    };
+}
diff --git a/lib/percy/percy/encoders/ditt_encoder.hpp b/lib/percy/percy/encoders/ditt_encoder.hpp
new file mode 100644
index 0000000..09fb7db
--- /dev/null
+++ b/lib/percy/percy/encoders/ditt_encoder.hpp
@@ -0,0 +1,1205 @@
+#pragma once
+
+#include "encoder.hpp"
+#include "../misc.hpp"
+
+namespace percy
+{
+    class ditt_encoder : public std_cegar_encoder, public enumerating_encoder
+    {
+        private:
+			int nr_op_vars_per_step;
+			int nr_op_vars;
+			int nr_out_vars;
+			int nr_tt_vars;
+			int nr_input_tt_vars;
+			int nr_lex_vars;
+			int nr_sel_vars;
+            int sel_offset;
+            int ops_offset;
+            int out_offset;
+            int tt_offset;
+            int input_tt_offset;
+            int lex_offset;
+            int total_nr_vars;
+            
+            pabc::Vec_Int_t* vLits; // Dynamic vector of literals
+
+        public:
+            ditt_encoder(solver_wrapper& solver)
+            {
+                vLits = pabc::Vec_IntAlloc(128);
+                set_solver(solver);
+            }
+
+            ~ditt_encoder()
+            {
+                pabc::Vec_IntFree(vLits);
+            }
+
+            int
+            get_op_var(const spec& spec, int step_idx, int var_idx)
+            const 
+            {
+                assert(step_idx < spec.nr_steps);
+                assert(var_idx > 0);
+                assert(var_idx <= nr_op_vars_per_step);
+
+                return ops_offset + step_idx * nr_op_vars_per_step + var_idx-1;
+            }
+
+            int
+            get_sel_var(const spec& spec, int i, int j, int k) 
+            const
+            {
+                assert(i < spec.nr_steps);
+                assert(j < spec.get_nr_in() + i);
+                assert(k < spec.fanin);
+
+                auto prev_svars = 0;
+                for (int ip = 0; ip < i; ip++) {
+                    prev_svars += spec.fanin * (spec.get_nr_in() + ip);
+                }
+
+                return sel_offset + prev_svars + k * (spec.get_nr_in() + i) + j;
+            }
+
+            int 
+            get_out_var(const spec& spec, int h, int i) 
+            const
+            {
+                assert(h < spec.nr_nontriv);
+                assert(i < spec.nr_steps);
+
+                return out_offset + spec.nr_steps * h + i;
+            }
+
+            int
+            get_tt_var(const spec& spec, int i, int t) const
+            {
+                assert(i < spec.nr_steps);
+                assert(t < spec.get_tt_size());
+
+                return tt_offset + spec.get_tt_size() * i + t;
+            }
+
+            int
+            get_input_tt_var(const spec& spec, int i, int t, int k)
+            const
+            {
+                assert(k < spec.fanin);
+                assert(t < spec.get_tt_size());
+
+                auto prev_itt_vars = 0;
+                for (int ip = 0; ip < i; ip++) {
+                    prev_itt_vars += spec.fanin * spec.get_tt_size();
+                }
+
+                return input_tt_offset + prev_itt_vars + 
+                    k * spec.get_tt_size() + t;
+            }
+
+            int
+            get_lex_var(const spec& spec, int step_idx, int op_idx) const
+            {
+                assert(step_idx < spec.nr_steps);
+                assert(op_idx < nr_op_vars_per_step);
+
+                return lex_offset + step_idx * (nr_op_vars_per_step - 1) + op_idx;
+            }
+
+            /// Ensures that each gate has spec.fanin operands AND that
+            /// fanins are ordered tuples.
+            bool 
+            create_op_clauses(const spec& spec)
+            {
+                int pLits[2];
+                auto status = true;
+
+                if (spec.verbosity > 2) {
+                    printf("Creating op clauses (DITT-%d)\n", spec.fanin);
+                    printf("Nr. clauses = %d (PRE)\n", solver->nr_clauses());
+                }
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    for (int k = 0; k < spec.fanin; k++) {
+                        int ctr = 0;
+                        const auto max_fanin_idx = spec.get_nr_in() + i - spec.fanin + k;
+                        for (int j = k; j <= max_fanin_idx; j++) {
+                            const auto s_ij_k = get_sel_var(spec, i, j, k);
+                            pabc::Vec_IntSetEntry(vLits, ctr++,
+                                pabc::Abc_Var2Lit(s_ij_k, 0));
+                        }
+                        status &= solver->add_clause(
+                            pabc::Vec_IntArray(vLits),
+                            pabc::Vec_IntArray(vLits) + ctr
+                        );
+                    }
+                }
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    for (int k = 0; k < spec.fanin - 1; k++) {
+                        const auto max_fanin_idx = spec.get_nr_in() + i - spec.fanin + k;
+                        for (int j = k; j <= max_fanin_idx; j++) {
+                            const auto s_ij_k = get_sel_var(spec, i, j, k);
+                            pLits[0] = pabc::Abc_Var2Lit(s_ij_k, 1);
+                            for (int kp = k + 1; kp < spec.fanin; kp++) {
+                                for (int jp = 0; jp <= j; jp++) {
+                                    const auto s_ijp_kp = get_sel_var(spec, i, jp, kp);
+                                    pLits[1] = pabc::Abc_Var2Lit(s_ijp_kp, 1);
+                                    status &= solver->add_clause(pLits, pLits + 2);
+                                    assert(status);
+                                }
+                            }
+                        }
+                    }
+                }
+                if (spec.verbosity > 2) {
+                    printf("Nr. clauses = %d (POST)\n", solver->nr_clauses());
+                }
+
+                return status;
+            }
+
+            bool 
+            create_output_clauses(const spec& spec)
+            {
+                auto status = true;
+
+                if (spec.verbosity > 2) {
+                    printf("Creating output clauses (DITT-%d)\n", spec.fanin);
+                    printf("Nr. clauses = %d (PRE)\n", solver->nr_clauses());
+                }
+                // Every output points to an operand.
+                if (spec.nr_nontriv > 1) {
+                    for (int h = 0; h < spec.nr_nontriv; h++) {
+                        for (int i = 0; i < spec.nr_steps; i++) {
+                            pabc::Vec_IntSetEntry(vLits, i, 
+                                    pabc::Abc_Var2Lit(get_out_var(spec, h, i), 0));
+                        }
+                        status &= solver->add_clause(
+                                pabc::Vec_IntArray(vLits),
+                                pabc::Vec_IntArray(vLits) + spec.nr_steps);
+
+                        if (spec.verbosity > 2) {
+                            printf("creating output clause: ( ");
+                            for (int i = 0; i < spec.nr_steps; i++) {
+                                printf("%sg_%d_%d ", i > 0 ? "\\/ " : "",
+                                        h + 1, spec.get_nr_in() + i + 1);
+                            }
+                            printf(") (status = %d)\n", status);
+                        }
+                    }
+                }
+
+                // At least one of the outputs has to refer to the final
+                // operator, otherwise it may as well not be there.
+                const auto last_op = spec.nr_steps - 1;
+                for (int h = 0; h < spec.nr_nontriv; h++) {
+                    pabc::Vec_IntSetEntry(vLits, h,
+                            pabc::Abc_Var2Lit(get_out_var(spec, h, last_op),0));
+                }
+                status &= solver->add_clause(
+                    pabc::Vec_IntArray(vLits),
+                    pabc::Vec_IntArray(vLits) + spec.nr_nontriv);
+
+                if (spec.verbosity > 2) {
+                    printf("creating output clause: ( ");
+                    for (int h = 0; h < spec.nr_nontriv; h++) {
+                        printf("%sg_%d_%d ", h > 0 ? "\\/ " : "",
+                                h + 1, spec.get_nr_in() + last_op + 1);
+                    }
+                    printf(") (status = %d)\n", status);
+                    printf("Nr. clauses = %d (POST)\n", solver->nr_clauses());
+                }
+
+                return status;
+            }
+
+            void
+            create_variables(const spec& spec)
+            {
+                nr_op_vars_per_step = ((1u << spec.fanin) - 1);
+                nr_op_vars = spec.nr_steps * nr_op_vars_per_step;
+                nr_out_vars = spec.nr_nontriv * spec.nr_steps;
+                nr_tt_vars = spec.nr_steps * spec.get_tt_size();
+                nr_input_tt_vars = spec.fanin * spec.nr_steps * spec.get_tt_size();
+                nr_lex_vars = (spec.nr_steps - 1) * (nr_op_vars_per_step - 1);
+                nr_sel_vars = 0;
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    const auto nr_svars_for_i = spec.fanin * (spec.get_nr_in() + i);
+                    nr_sel_vars += nr_svars_for_i;
+                }
+                sel_offset = 0;
+                ops_offset = nr_sel_vars;
+                out_offset = nr_sel_vars + nr_op_vars;
+                tt_offset = nr_sel_vars + nr_op_vars + nr_out_vars;
+                input_tt_offset = nr_sel_vars + nr_op_vars + nr_out_vars + nr_tt_vars;
+                lex_offset = nr_sel_vars + nr_op_vars + nr_out_vars + nr_tt_vars + nr_input_tt_vars;
+                
+                total_nr_vars = nr_op_vars + nr_out_vars + nr_tt_vars +
+                    nr_input_tt_vars + nr_sel_vars + nr_lex_vars;
+
+                if (spec.verbosity > 2) {
+                    printf("Creating variables (DITT-%d)\n", spec.fanin);
+                    printf("nr steps = %d\n", spec.nr_steps);
+                    printf("nr_sel_vars=%d\n", nr_sel_vars);
+                    printf("nr_op_vars = %d\n", nr_op_vars);
+                    printf("nr_out_vars = %d\n", nr_out_vars);
+                    printf("nr_tt_vars = %d\n", nr_tt_vars);
+                    printf("nr_input_tt_vars = %d\n", nr_input_tt_vars);
+                    printf("nr_lex_vars = %d\n", nr_lex_vars);
+                    printf("creating %d total variables\n", total_nr_vars);
+                }
+
+                solver->set_nr_vars(total_nr_vars);
+            }
+
+            bool
+            add_simulation_clause(
+                    const spec& spec, 
+                    const int t, 
+                    const int i, 
+                    const int output, 
+                    const int opvar_idx,
+                    const std::vector<int>& fanin_asgn)
+            {
+                pabc::Vec_IntSetEntry(vLits, 0,
+                    pabc::Abc_Var2Lit(get_tt_var(spec, i, t), output));
+                
+                int ctr = 1;
+                if (spec.verbosity > 3) {
+                    //printf("assignment: %s\n", fanin_asgn.to_string().c_str());
+                }
+                for (int k = 0; k < spec.fanin; k++) {
+                    const auto x_it_k = get_input_tt_var(spec, i, t, k);
+                    pabc::Vec_IntSetEntry(vLits, ctr++,
+                        pabc::Abc_Var2Lit(x_it_k, fanin_asgn[k]));
+                }
+
+                //printf("opvar_idx=%d\n", opvar_idx);
+                if (opvar_idx > 0) {
+                    pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(
+                                get_op_var(spec, i, opvar_idx), 1 - output));
+                }
+
+                const auto status = solver->add_clause(
+                        pabc::Vec_IntArray(vLits),
+                        pabc::Vec_IntArray(vLits) + ctr); 
+
+                return status;
+            }
+
+            bool 
+            create_tt_clauses(const spec& spec, const int t)
+            {
+                auto ret = true;
+                int pLits[3];
+                std::vector<int> fanin_asign(spec.fanin);
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    // Encode propagation of truth tables:
+                    // if s_ij^k, then x_it^k = x_jt
+                    for (int k = 0; k < spec.fanin; k++) {
+                        for (int j = 0; j < spec.get_nr_in() + i; j++) {
+                            const auto svar = get_sel_var(spec, i, j, k);
+                            const auto x_it_k = get_input_tt_var(spec, i, t, k);
+                            if (j < spec.get_nr_in()) {
+                                // In this case, we know the value of
+                                // x_jt a-priori
+                                const auto val = ((t + 1) & (1 << j)) ? 1 : 0;
+                                pLits[0] = pabc::Abc_Var2Lit(svar, 1);
+                                pLits[1] = pabc::Abc_Var2Lit(x_it_k, 1 - val);
+                                ret &= solver->add_clause(pLits, pLits + 2);
+                            } else {
+                                const auto x_jt = get_tt_var(spec, j - spec.get_nr_in(), t);
+
+                                pLits[0] = pabc::Abc_Var2Lit(svar, 1);
+                                pLits[1] = pabc::Abc_Var2Lit(x_it_k, 1);
+                                pLits[2] = pabc::Abc_Var2Lit(x_jt, 0);
+                                ret &= solver->add_clause(pLits, pLits + 3);
+
+                                pLits[1] = pabc::Abc_Var2Lit(x_it_k, 0);
+                                pLits[2] = pabc::Abc_Var2Lit(x_jt, 1);
+                                ret &= solver->add_clause(pLits, pLits + 3);
+                            }
+                        }
+                    }
+
+                    // Fix the input truth tables if this step has a PI 
+                    // as fanin
+                    for (int k = 0; k < spec.fanin; k++) {
+                        for (int j = 0; j < spec.get_nr_in(); j++) {
+                            const auto s_ij_k = get_sel_var(spec, i, j, k);
+                            const auto x_it_k = get_input_tt_var(spec, i, t, k);
+                            const auto val = ((t + 1) & (1 << j)) ? 1 : 0;
+                            pLits[0] = pabc::Abc_Var2Lit(s_ij_k, 1);
+                            pLits[1] = pabc::Abc_Var2Lit(x_it_k, 1 - val);
+                            ret &= solver->add_clause(pLits, pLits + 2);
+                        }
+                    }
+
+                    // Encode operator/truth table constraints
+                    // First add clauses for all cases where step i
+                    // computes zero.
+                    int opvar_idx = 0;
+                    clear_assignment(fanin_asign);
+                    while (true) {
+                        next_assignment(fanin_asign);
+                        if (is_zero(fanin_asign)) {
+                            break;
+                        }
+                        opvar_idx++;
+                        ret &= add_simulation_clause(spec, t, i, 0, 
+                            opvar_idx, fanin_asign);
+                    }
+
+                    // Next, all the cases where it computes one.
+                    opvar_idx = 0;
+                    ret &= add_simulation_clause(spec, t, i, 1,
+                                opvar_idx, fanin_asign);
+                    while (true) {
+                        next_assignment(fanin_asign);
+                        if (is_zero(fanin_asign)) {
+                            break;
+                        }
+                        opvar_idx++;
+                        ret &= add_simulation_clause(spec, t, i, 1,
+                            opvar_idx, fanin_asign);
+                    }
+                    
+                    // If an output has selected this particular operand, we
+                    // need to ensure that this operand's truth table satisfies
+                    // the specified output function.
+                    for (int h = 0; h < spec.nr_nontriv; h++) {
+                        if (spec.is_dont_care(h, t + 1)) {
+                            continue;
+                        }
+                        auto outbit = kitty::get_bit(
+                                spec[spec.synth_func(h)], t+1);
+                        if ((spec.out_inv >> spec.synth_func(h)) & 1) {
+                            outbit = 1 - outbit;
+                        }
+                        pLits[0] = pabc::Abc_Var2Lit(get_out_var(spec, h, i), 1);
+                        pLits[1] = pabc::Abc_Var2Lit(get_tt_var(spec, i, t), 
+                                1 - outbit);
+                        ret &= solver->add_clause(pLits, pLits+2);
+                        if (spec.verbosity > 2) {
+                            printf("creating oimp clause: ( ");
+                            printf("!g_%d_%d \\/ %sx_%d_%d ) (status=%d)\n", 
+                                    h + 1, 
+                                    spec.get_nr_in() + i + 1, 
+                                    (1 - outbit) ?  "!" : "",
+                                    spec.get_nr_in() + i + 1, 
+                                    t + 2,
+                                    ret);
+                        }
+                    }
+                }
+
+                return ret;
+            }
+
+            bool 
+            create_main_clauses(const spec& spec)
+            {
+                if (spec.verbosity > 2) {
+                    printf("Creating main clauses (DITT-%d)\n", spec.fanin);
+                    printf("Nr. clauses = %d (PRE)\n", solver->nr_clauses());
+                }
+                auto success = true;
+
+                for (int t = 0; t < spec.get_tt_size(); t++) {
+                    success &= create_tt_clauses(spec, t);
+                }
+
+                if (spec.verbosity > 2) {
+                    printf("Nr. clauses = %d (POST)\n", solver->nr_clauses());
+                    printf("success = %d\n", success);
+                }
+
+                return success;
+            }
+
+            /*******************************************************************
+                Add clauses that prevent trivial variable projection and
+                constant operators from being synthesized.
+            *******************************************************************/
+            void 
+            create_nontriv_clauses(const spec& spec)
+            {
+                dynamic_truth_table triv_op(spec.fanin);
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    kitty::clear(triv_op);
+                    
+                    // Dissallow the constant zero operator.
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        pabc::Vec_IntSetEntry(vLits, j-1,
+                                pabc::Abc_Var2Lit(get_op_var(spec, i, j), 0));
+                    }
+                    auto status = solver->add_clause(
+                            pabc::Vec_IntArray(vLits), 
+                            pabc::Vec_IntArray(vLits) + nr_op_vars_per_step);
+                    assert(status);
+                    
+                    // Dissallow all variable projection operators.
+                    for (int n = 0; n < spec.fanin; n++) {
+                        kitty::create_nth_var(triv_op, n);
+                        for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                            pabc::Vec_IntSetEntry(vLits, j-1,
+                                    pabc::Abc_Var2Lit(get_op_var(spec, i, j), 
+                                        kitty::get_bit(triv_op, j)));
+                        }
+                        status = solver->add_clause(
+                                pabc::Vec_IntArray(vLits),
+                                pabc::Vec_IntArray(vLits) + nr_op_vars_per_step);
+                        assert(status);
+                    }
+                }
+            }
+
+            /*******************************************************************
+              Add clauses which ensure that every step is used at least once.
+            *******************************************************************/
+            bool 
+            create_alonce_clauses(const spec& spec)
+            {
+                bool status = true;
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    auto ctr = 0;
+
+                    // Either one of the outputs points to this step.
+                    for (int h = 0; h < spec.nr_nontriv; h++) {
+                        pabc::Vec_IntSetEntry(vLits, ctr++, 
+                                pabc::Abc_Var2Lit(get_out_var(spec, h, i), 0));
+                    }
+
+                    // Or one of the succeeding steps points to this step.
+                    for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                        for (int k = 0; k < spec.fanin; k++) {
+                            const auto sel_var = get_sel_var(spec, ip, spec.get_nr_in() + i, k);
+                            pabc::Vec_IntSetEntry(
+                                vLits, 
+                                ctr++,
+                                pabc::Abc_Var2Lit(sel_var, 0));
+                        }
+                    }
+                        
+                    status &= solver->add_clause(
+                            pabc::Vec_IntArray(vLits),
+                            pabc::Vec_IntArray(vLits) + ctr);
+                }
+
+                return status;
+            }
+
+            /*******************************************************************
+                Add clauses which ensure that operands are never re-applied. In
+                other words, (Sijk --> ~Si'ji) & (Sijk --> ~Si'ki), 
+                for all (i < i').
+            *******************************************************************/
+            void 
+            create_noreapply_clauses(const spec& spec)
+            {
+                std::vector<int> remaining_fanins;
+                std::vector<int> fanins(spec.fanin);
+                for (int i = 0; i < spec.nr_steps - 1; i++) {
+                    const auto max_fanin = spec.get_nr_in() + i - 1;
+                    clear_assignment(fanins);
+                    while (true) {
+                        for (int k = 0; k < spec.fanin; k++) {
+                            const auto s_ij_k = get_sel_var(spec, i, fanins[k], k);
+                            pabc::Vec_IntSetEntry(vLits, k, pabc::Abc_Var2Lit(s_ij_k, 1));
+                        }
+
+                        for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                            remaining_fanins.clear();
+                            for (int l = 0; l <= spec.get_nr_in() + ip - 1; l++) {
+                                if (l == spec.get_nr_in() + i) continue;
+                                if (std::find(fanins.begin(), fanins.end(), l) == fanins.end()) {
+                                    remaining_fanins.push_back(l);
+                                }
+                            }
+                            // (s_i(j1)_1 /\ ... /\ (s_i(jm)_k) --> (s_(ip)i_1) --> (not one of the other fanins)
+                            // the other fanins be subsumed by the current
+                            // ifanin assignment to i.
+                            for (int k = 0; k < spec.fanin; k++) {
+                                auto ctr = spec.fanin;
+                                const auto s_ip_i_k = get_sel_var(spec, ip,
+                                    spec.get_nr_in() + i, k);
+                                pabc::Vec_IntSetEntry(vLits, ctr++, 
+                                    pabc::Abc_Var2Lit(s_ip_i_k, 1));
+
+                                for (int kp = 0; kp < spec.fanin; kp++) {
+                                    if (kp == k) continue;
+                                    for (const auto fanin : remaining_fanins) {
+                                        const auto s_ip_f_kp = get_sel_var(spec, ip, fanin, kp);
+                                        pabc::Vec_IntSetEntry(vLits, ctr++,
+                                            pabc::Abc_Var2Lit(s_ip_f_kp, 0));
+                                    }
+                                }
+                                const auto status = solver->add_clause(
+                                    pabc::Vec_IntArray(vLits),
+                                    pabc::Vec_IntArray(vLits) + ctr
+                                );
+                                assert(status);
+                            }
+
+                            
+                        }
+
+                        inc_assignment(fanins, max_fanin);
+                        if (is_zero(fanins)) {
+                            break;
+                        }
+                    }
+                }
+            }
+
+            /*******************************************************************
+                Add clauses which ensure that steps occur in co-lexicographical
+                order. In other words, we require steps operands to be 
+                co-lexicographically ordered tuples.
+            *******************************************************************/
+            bool 
+            create_colex_clauses(const spec& spec)
+            {
+                bool status = true;
+                std::vector<int> fanins(spec.fanin);
+                std::vector<int> ip_fanins(spec.fanin);
+
+                for (int i = 0; i < spec.nr_steps - 1; i++) {
+                    clear_assignment(fanins);
+                    const auto max_fanin = spec.get_nr_in() + i - 1;
+                    while (true) {
+                        clear_assignment(ip_fanins);
+                        const auto max_ip_fanin = max_fanin + 1;
+                        while (true) {
+                            if (colex_compare(fanins, ip_fanins) < 1) {
+                                inc_assignment(ip_fanins, max_ip_fanin);
+                                if (is_zero(ip_fanins)) {
+                                    break;
+                                } else {
+                                    continue;
+                                }
+                            }
+                            auto ctr = 0;
+                            for (int k = 0; k < spec.fanin; k++) {
+                                pabc::Vec_IntSetEntry(vLits, ctr++,
+                                    pabc::Abc_Var2Lit(get_sel_var(spec, i, fanins[k], k), 1));
+                                pabc::Vec_IntSetEntry(vLits, ctr++,
+                                    pabc::Abc_Var2Lit(get_sel_var(spec, i + 1, ip_fanins[k], k), 1));
+                            }
+
+                            status &= solver->add_clause(
+                                pabc::Vec_IntArray(vLits),
+                                pabc::Vec_IntArray(vLits) + ctr
+                            );
+                            
+                            inc_assignment(ip_fanins, max_ip_fanin);
+                            if (is_zero(ip_fanins)) {
+                                break;
+                            }
+                        }
+
+                        inc_assignment(fanins, max_fanin);
+                        if (is_zero(fanins)) {
+                            break;
+                        }
+                    }
+                }
+                return status;
+            }
+
+            /*******************************************************************
+                Add clauses which ensure that steps occur in lexicographical
+                order. In other words, we require steps operands to be
+                lexicographically ordered tuples.
+            *******************************************************************/
+            bool
+            create_lex_clauses(const spec& spec)
+            {
+                auto status = true;
+                std::vector<int> fanins(spec.fanin);
+                std::vector<int> ip_fanins(spec.fanin);
+
+                for (int i = 0; i < spec.nr_steps - 1; i++) {
+                    clear_assignment(fanins);
+                    const auto max_fanin = spec.get_nr_in() + i - 1;
+                    while (true) {
+                        clear_assignment(ip_fanins);
+                        const auto max_ip_fanin = max_fanin + 1;
+                        while (true) {
+                            if (lex_compare(fanins, ip_fanins) < 1) {
+                                inc_assignment(ip_fanins, max_ip_fanin);
+                                if (is_zero(ip_fanins)) {
+                                    break;
+                                } else {
+                                    continue;
+                                }
+                            }
+                            auto ctr = 0;
+                            for (int k = 0; k < spec.fanin; k++) {
+                                pabc::Vec_IntSetEntry(vLits, ctr++,
+                                    pabc::Abc_Var2Lit(get_sel_var(spec, i, fanins[k], k), 1));
+                                pabc::Vec_IntSetEntry(vLits, ctr++,
+                                    pabc::Abc_Var2Lit(get_sel_var(spec, i + 1, ip_fanins[k], k), 1));
+                            }
+
+                            status &= solver->add_clause(
+                                pabc::Vec_IntArray(vLits),
+                                pabc::Vec_IntArray(vLits) + ctr
+                            );
+                            
+                            inc_assignment(ip_fanins, max_ip_fanin);
+                            if (is_zero(ip_fanins)) {
+                                break;
+                            }
+                        }
+
+                        inc_assignment(fanins, max_fanin);
+                        if (is_zero(fanins)) {
+                            break;
+                        }
+                    }
+                }
+                return status;
+            }
+
+            /*******************************************************************
+                Ensure that Boolean operators are lexicographically ordered:
+                (S_ijk /\ S_(i+1)jk) ==> f_i <= f_(i+1)
+            *******************************************************************/
+            void 
+            create_lex_func_clauses(const spec& spec)
+            {
+                std::vector<int> fanins(spec.fanin);
+                std::vector<int> fvar_asgns(spec.fanin);
+                int lits[3];
+
+                for (int i = 0; i < spec.nr_steps - 1; i++) {
+                    clear_assignment(fanins);
+                    const auto max_fanin = spec.get_nr_in() + i - 1;
+                    while (true) {
+                        auto base_ctr = 0;
+                        for (int k = 0; k < spec.fanin; k++) {
+                            auto sel_var = get_sel_var(spec, i, fanins[k], k);
+                            Vec_IntSetEntry(vLits, base_ctr++, pabc::Abc_Var2Lit(sel_var, 1));
+                            sel_var = get_sel_var(spec, i + 1, fanins[k], k);
+                            Vec_IntSetEntry(vLits, base_ctr++, pabc::Abc_Var2Lit(sel_var, 1));
+                        }
+
+                        // The steps have the same fanin, so enforce lexicographical order.
+                        // We do this by constraining the operator variables of both steps.
+                        // Note: the operator variable with the highest index is used 
+                        // first in the ordering.
+                        for (int op_idx = 0; op_idx < nr_op_vars_per_step; op_idx++) {
+                            // Inequality only has to hold if all previous operator variables
+                            // are equal.
+                            auto ctr = base_ctr;
+                            for (int prev_idx = 0; prev_idx < op_idx; prev_idx++) {
+                                const auto prev_alpha_i = get_lex_var(spec, i, prev_idx);
+                                Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(prev_alpha_i, 1));
+                            }
+
+                            // Ensure that f_i_n <= f_{i+1}_n.
+                            const auto iop_var = get_op_var(spec, i, nr_op_vars_per_step - op_idx);
+                            const auto ipop_var = get_op_var(spec, i + 1, nr_op_vars_per_step - op_idx);
+                            Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(iop_var, 1));
+                            Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(ipop_var, 0));
+                            auto status = solver->add_clause(
+                                pabc::Vec_IntArray(vLits),
+                                pabc::Vec_IntArray(vLits) + ctr);
+                            assert(status);
+                            if (op_idx == (nr_op_vars_per_step - 1)) {
+                                continue;
+                            }
+                            // alpha_i is 1 iff f_j_i == f_{j+1}_i.
+                            auto alpha_i = get_lex_var(spec, i, op_idx);
+                            lits[0] = pabc::Abc_Var2Lit(alpha_i, 1);
+                            lits[1] = pabc::Abc_Var2Lit(iop_var, 0);
+                            lits[2] = pabc::Abc_Var2Lit(ipop_var, 1);
+                            solver->add_clause(lits, lits + 3);
+                            lits[0] = pabc::Abc_Var2Lit(alpha_i, 1);
+                            lits[1] = pabc::Abc_Var2Lit(iop_var, 1);
+                            lits[2] = pabc::Abc_Var2Lit(ipop_var, 0);
+                            solver->add_clause(lits, lits + 3);
+                            lits[0] = pabc::Abc_Var2Lit(alpha_i, 0);
+                            lits[1] = pabc::Abc_Var2Lit(iop_var, 1);
+                            lits[2] = pabc::Abc_Var2Lit(ipop_var, 1);
+                            solver->add_clause(lits, lits + 3);
+                            lits[0] = pabc::Abc_Var2Lit(alpha_i, 0);
+                            lits[1] = pabc::Abc_Var2Lit(iop_var, 0);
+                            lits[2] = pabc::Abc_Var2Lit(ipop_var, 0);
+                            solver->add_clause(lits, lits + 3);
+                        }
+
+                        inc_assignment(fanins, max_fanin);
+                        if (is_zero(fanins)) {
+                            break;
+                        }
+                    }
+                }
+            }
+
+            /*******************************************************************
+                Ensure that symmetric variables occur in order.
+            *******************************************************************/
+            bool
+            create_symvar_clauses(const spec& spec)
+            {
+                for (int q = 1; q < spec.get_nr_in(); q++) {
+                    for (int p = 0; p < q; p++) {
+                        auto symm = true;
+                        for (int i = 0; i < spec.nr_nontriv; i++) {
+                            auto f = spec[spec.synth_func(i)];
+                            if (!(swap(f, p, q) == f)) {
+                                symm = false;
+                                break;
+                            }
+                        }
+                        if (!symm) {
+                            continue;
+                        }
+                        if (spec.verbosity) {
+                            printf("  variables x_%d and x_%d are symmetric\n",
+                                    p+1, q+1);
+                        }
+
+                        for (int i = 0; i < spec.nr_steps; i++) {
+                            // If (has_input(i, q) and !has_input(i, p)) --> (has_input(i-1, p) \/ ... \/ has_input(0, p))
+                            for (int k = 0; k < spec.fanin; k++) {
+                                int ctr = 0;
+                                auto sel_var = get_sel_var(spec, i, q, k);
+                                pabc::Vec_IntSetEntry(vLits, ctr++,
+                                    pabc::Abc_Var2Lit(sel_var, 1));
+
+                                for (int kp = 0; kp < spec.fanin; kp++) {
+                                    if (kp == k) continue;
+                                    sel_var = get_sel_var(spec, i, p, kp);
+                                    pabc::Vec_IntSetEntry(vLits, ctr++,
+                                        pabc::Abc_Var2Lit(sel_var, 0));
+                                }
+
+                                for (int ip = 0; ip < i; ip++) {
+                                    for (int k = 0; k < spec.fanin; k++) {
+                                        sel_var = get_sel_var(spec, ip, p, k);
+                                        pabc::Vec_IntSetEntry(vLits, ctr++,
+                                            pabc::Abc_Var2Lit(sel_var, 0));
+                                    }
+                                }
+
+                                const auto status = solver->add_clause(Vec_IntArray(vLits), Vec_IntArray(vLits) + ctr);
+                                if (!status) {
+                                    return false;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                return true;
+            }
+
+            /// Extracts chain from encoded CNF solution.
+            void extract_chain(const spec& spec, chain& chain)
+            {
+                std::vector<int> fanins(spec.fanin);
+
+                chain.reset(spec.get_nr_in(), spec.get_nr_out(), spec.nr_steps, spec.fanin);
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    dynamic_truth_table op(spec.fanin);
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        if (solver->var_value(get_op_var(spec, i, j))) {
+                            kitty::set_bit(op, j); 
+                        }
+                    }
+
+                    if (spec.verbosity) {
+                        printf("  step x_%d performs operation\n  ", 
+                                i+spec.get_nr_in()+1);
+                        kitty::print_binary(op, std::cout);
+                        printf("\n");
+                    }
+
+                    for (int k = 0; k < spec.fanin; k++) {
+                        for (int j = 0; j < spec.get_nr_in() + i; j++) {
+                            const auto s_ij_k = get_sel_var(spec, i, j, k);
+                            if (solver->var_value(s_ij_k)) {
+                                fanins[k] = j;
+                            }
+                        }
+                    }
+                    if (spec.verbosity) {
+                        printf("  with operands ");
+                        for (int k = 0; k < spec.fanin; k++) {
+                            printf("x_%d ", fanins[k] + 1);
+                        }
+                    }
+                        
+                    chain.set_step(i, fanins, op);
+
+                    if (spec.verbosity) {
+                        printf("\n");
+                    }
+                }
+
+                auto triv_count = 0, nontriv_count = 0;
+                for (int h = 0; h < spec.get_nr_out(); h++) {
+                    if ((spec.triv_flag >> h) & 1) {
+                        chain.set_output(h, 
+                                (spec.triv_func(triv_count++) << 1) +
+                                ((spec.out_inv >> h) & 1));
+                        continue;
+                    }
+                    for (int i = 0; i < spec.nr_steps; i++) {
+                        if (solver->var_value(get_out_var(spec, nontriv_count, i))) {
+                            chain.set_output(h, 
+                                    ((i + spec.get_nr_in() + 1) << 1) +
+                                    ((spec.out_inv >> h) & 1));
+                            nontriv_count++;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            void cegar_extract_chain(const spec& spec, chain& chain)
+            {
+                std::vector<int> fanins(spec.fanin);
+
+                chain.reset(spec.get_nr_in(), spec.get_nr_out(), spec.nr_steps, spec.fanin);
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    dynamic_truth_table op(spec.fanin);
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        if (solver->var_value(get_op_var(spec, i, j))) {
+                            kitty::set_bit(op, j); 
+                        }
+                    }
+
+                    if (spec.verbosity) {
+                        printf("  step x_%d performs operation\n  ", 
+                                i+spec.get_nr_in()+1);
+                        kitty::print_binary(op, std::cout);
+                        printf("\n");
+                    }
+
+                    for (int k = 0; k < spec.fanin; k++) {
+                        for (int j = 0; j < spec.get_nr_in() + i; j++) {
+                            const auto s_ij_k = get_sel_var(spec, i, j, k);
+                            if (solver->var_value(s_ij_k)) {
+                                fanins[k] = j;
+                            }
+                        }
+                    }
+                    if (spec.verbosity) {
+                        printf("  with operands ");
+                        for (int k = 0; k < spec.fanin; k++) {
+                            printf("x_%d ", fanins[k] + 1);
+                        }
+                    }
+                        
+                    chain.set_step(i, fanins, op);
+
+                    if (spec.verbosity) {
+                        printf("\n");
+                    }
+                }
+
+                chain.set_output(0,
+                    ((spec.nr_steps + spec.get_nr_in()) << 1) +
+                    (spec.out_inv & 1));
+            }
+
+            void find_fanin(int i, std::vector<int>& fanins, const spec& spec) const
+            {
+                for (int k = 0; k < spec.fanin; k++) {
+                    for (int j = 0; j < spec.get_nr_in() + i; j++) {
+                        const auto s_ij_k = get_sel_var(spec, i, j, k);
+                        if (solver->var_value(s_ij_k)) {
+                            fanins[k] = j;
+                        }
+                    }
+                }
+            }
+
+            /*******************************************************************
+                Extracts only the underlying DAG structure from a solution.
+            *******************************************************************/
+            template<int FI>
+            void 
+            extract_dag(const spec& spec, dag<FI>& dag)
+            {
+                std::vector<int> fanins;
+                assert(FI == spec.fanin);
+                dag.reset(spec.get_nr_in(), spec.nr_steps);
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    for (int k = 0; k < spec.fanin; k++) {
+                        for (int j = 0; j < spec.get_nr_in() + i; j++) {
+                            const auto s_ij_k = get_sel_var(spec, i, j, k);
+                            if (solver->var_value(s_ij_k)) {
+                                fanins[k] = j;
+                            }
+                        }
+                    }
+                    dag.set_vertex(i, fanins);
+                }
+            }
+
+            void
+            print_solver_state(const spec& spec)
+            {
+                printf("\n");
+                printf("========================================"
+                        "========================================\n");
+                printf("  SOLVER STATE\n\n");
+
+                printf("  Nr. variables = %d\n", solver->nr_vars());
+                printf("  Nr. clauses = %d\n\n", solver->nr_clauses());
+
+                
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    for (int k = 0; k < spec.fanin; k++) {
+                        for (int j = 0; j < spec.get_nr_in() + i; j++) {
+                            const auto s_ij_k_var = get_sel_var(spec, i, j, k);
+                            printf("  s_%d_%d_%d = %d\n", i, j, k,
+                                solver->var_value(s_ij_k_var));
+                        }
+                    }
+
+                    for (int oidx = nr_op_vars_per_step; oidx > 0; oidx--) {
+                        printf("  f_%d_%d=%d\n", 
+                                spec.get_nr_in() + i + 1, 
+                                oidx + 1,
+                                solver->var_value(get_op_var(spec, i, oidx))
+                              );
+                    }
+                    printf("  f_%d_1=0\n", spec.get_nr_in() + i + 1);
+                    printf("\n");
+
+                    for (int t = spec.get_tt_size() - 1; t >= 0; t--) {
+                        printf("  x_%d_%d=%d\n", spec.get_nr_in() + i+1, t + 2, 
+                                solver->var_value(get_tt_var(spec, i, t)));
+                    }
+                    printf("  x_%d_0=0\n", spec.get_nr_in() + i + 1);
+                    printf("\n");
+                }
+                printf("\n");
+
+                printf("========================================"
+                        "========================================\n");
+            }
+
+			/// Encodes specifciation for use in standard synthesis flow.
+            bool 
+            encode(const spec& spec)
+            {
+                assert(spec.nr_steps <= MAX_STEPS);
+
+                create_variables(spec);
+                if (!create_main_clauses(spec)) {
+                    return false;
+                }
+
+                if (!create_output_clauses(spec)) {
+                    return false;
+                }
+
+                if (!create_op_clauses(spec)) {
+                    return false;
+                }
+                
+                //create_cardinality_constraints(spec);
+
+                if (spec.add_nontriv_clauses) {
+                    create_nontriv_clauses(spec);
+                }
+
+                if (spec.add_alonce_clauses) {
+                    create_alonce_clauses(spec);
+                }
+
+                if (spec.add_noreapply_clauses) {
+                    create_noreapply_clauses(spec);
+                }
+
+                if (spec.add_colex_clauses && !create_colex_clauses(spec)) {
+                    return false;
+                }
+
+                if (spec.add_lex_clauses && !create_lex_clauses(spec)) {
+                    return false;
+                }
+                
+                if (spec.add_lex_func_clauses) {
+                    create_lex_func_clauses(spec);
+                }
+                
+                if (spec.add_symvar_clauses && !create_symvar_clauses(spec)) {
+                    return false;
+                }
+
+                return true;
+            }
+
+			/// Encodes specifciation for use in CEGAR based synthesis flow.
+            bool 
+            cegar_encode(const spec& spec)
+            {
+                assert(spec.nr_steps <= MAX_STEPS);
+
+                create_variables(spec);
+                
+                if (!create_op_clauses(spec)) {
+                    return false;
+                }
+                
+                if (spec.add_nontriv_clauses) {
+                    create_nontriv_clauses(spec);
+                }
+
+                if (spec.add_alonce_clauses) {
+                    create_alonce_clauses(spec);
+                }
+                
+                if (spec.add_noreapply_clauses) {
+                    create_noreapply_clauses(spec);
+                }
+                
+                if (spec.add_colex_clauses && !create_colex_clauses(spec)) {
+                    return false;
+                }
+
+                if (spec.add_lex_clauses && !create_lex_clauses(spec)) {
+                    return false;
+                }
+
+                if (spec.add_lex_func_clauses) {
+                    create_lex_func_clauses(spec);
+                }
+
+                if (spec.add_symvar_clauses && !create_symvar_clauses(spec)) {
+                    return false;
+                }
+
+                return true;
+            }
+
+            /// Assumes that a solution has been found by the current encoding.
+            /// Blocks the current solution such that the solver is forced to
+            /// find different ones (if they exist).
+            bool
+            block_solution(const spec& spec)
+            {
+                int ctr = 0;
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        int invert = 0;
+                        const auto op_var = get_op_var(spec, i, j);
+                        if (solver->var_value(op_var)) {
+                            invert = 1;
+                        }
+                        pabc::Vec_IntSetEntry(vLits, ctr++,
+                                pabc::Abc_Var2Lit(get_op_var(spec, i, j),
+                                    invert));
+                    }
+
+                    for (int k = 0; k < spec.fanin; k++) {
+                        for (int j = 0; j < spec.get_nr_in() + i; j++) {
+                            const auto s_ij_k = get_sel_var(spec, i, j, k);
+                            if (solver->var_value(s_ij_k)) {
+                                pabc::Vec_IntSetEntry(vLits, ctr++,
+                                    pabc::Abc_Var2Lit(s_ij_k, 1));
+                                break;
+                            }
+                        }
+                    }
+                }
+                
+                return solver->add_clause(
+                            pabc::Vec_IntArray(vLits), 
+                            pabc::Vec_IntArray(vLits) + ctr);
+            }
+
+
+            /// Similar to block_solution, but blocks all solutions with the
+            /// same structure. This is more restrictive, since the other
+            /// method allows for the same structure but different operators.
+            bool
+            block_struct_solution(const spec& spec)
+            {
+                int ctr = 0;
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    for (int k = 0; k < spec.fanin; k++) {
+                        for (int j = 0; j < spec.get_nr_in() + i; j++) {
+                            const auto s_ij_k = get_sel_var(spec, i, j, k);
+                            if (solver->var_value(s_ij_k)) {
+                                pabc::Vec_IntSetEntry(vLits, ctr++,
+                                    pabc::Abc_Var2Lit(s_ij_k, 1));
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                return solver->add_clause(
+                            pabc::Vec_IntArray(vLits), 
+                            pabc::Vec_IntArray(vLits) + ctr);
+            }
+
+            int simulate(const spec& spec)
+            {
+                std::vector<int> fanins(spec.fanin);
+                auto tt_comp = kitty::create<dynamic_truth_table>(spec.nr_in);
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    find_fanin(i, fanins, spec);
+
+                    kitty::clear(sim_tts[spec.nr_in + i]);
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        kitty::clear(tt_comp);
+                        tt_comp = ~tt_comp;
+                        if (solver->var_value(get_op_var(spec, i, j))) {
+                            //printf("op[%d][%d]=1\n", i, j);
+                            for (int k = 0; k < spec.fanin; k++) {
+                                if ((j >> k) & 1) {
+                                    tt_comp &= sim_tts[fanins[k]];
+                                } else {
+                                    tt_comp &= ~sim_tts[fanins[k]];
+                                }
+                            }
+                            sim_tts[spec.nr_in + i] |= tt_comp;
+                        /*} else {
+                            printf("op[%d][%d]=0\n", i, j);*/
+                        }
+                    }
+
+                    /*
+                    printf("tt[%d]: ", i);
+                    kitty::print_binary(sim_tts[spec.nr_in + i]);
+                    std::cout << std::endl;
+    */
+                }
+
+                /*
+                std::cout << "sim tt: ";
+                kitty::print_binary(sim_tts[spec.nr_in + spec.nr_steps - 1]);
+                std::cout << std::endl;
+                std::cout << "spc tt: ";
+                kitty::print_binary(spec[0]);
+                std::cout << std::endl;
+                */
+
+                const auto iMint = kitty::find_first_bit_difference(sim_tts[spec.nr_in + spec.nr_steps - 1], spec.out_inv ? ~spec[0] : spec[0]);
+                assert(iMint > 0 || iMint == -1);
+                return iMint;
+            }
+    };
+}
+
diff --git a/lib/percy/percy/encoders/ditt_maj_encoder.hpp b/lib/percy/percy/encoders/ditt_maj_encoder.hpp
new file mode 100644
index 0000000..4ff4c5e
--- /dev/null
+++ b/lib/percy/percy/encoders/ditt_maj_encoder.hpp
@@ -0,0 +1,779 @@
+#pragma once
+
+#include <vector>
+#include <kitty/kitty.hpp>
+#include <abc/vecWec.h>
+#include "encoder.hpp"
+
+namespace percy
+{
+    class ditt_maj_encoder
+    {
+    private:
+        static const int MAJ_NOBJS = 32;
+
+        int level_dist[MAJ_NOBJS]; // How many steps are below a certain level
+        int nr_levels; // The number of levels in the Boolean fence
+        pabc::lit pLits[MAJ_NOBJS];
+        pabc::Vec_Wec_t* vOutLits;
+        solver_wrapper* solver;
+
+        int varMarks[MAJ_NOBJS][3][MAJ_NOBJS];
+        int varVals[MAJ_NOBJS]; // values of the PIs
+        int iVar;
+
+        static const int NR_SIM_TTS = 32;
+        std::vector<kitty::dynamic_truth_table> sim_tts { NR_SIM_TTS };
+
+        int find_fanin(const spec& spec, int i, int k)
+        {
+            int count = 0, iVar = -1;
+            for (int j = 0; j < spec.nr_in + spec.nr_steps; j++) {
+                if (varMarks[i][k][j] && solver->var_value(varMarks[i][k][j])) {
+                    iVar = j;
+                    count++;
+                }
+            }
+            assert(count == 1);
+            return iVar;
+        }
+
+    public:
+        ditt_maj_encoder(solver_wrapper& solver)
+        {
+            this->solver = &solver;
+            vOutLits = pabc::Vec_WecStart(MAJ_NOBJS);
+        }
+
+        ~ditt_maj_encoder()
+        {
+            pabc::Vec_WecFree(vOutLits);
+        }
+
+        void update_level_map(const spec& spec, const fence& f)
+        {
+            nr_levels = f.nr_levels();
+            level_dist[0] = spec.get_nr_in();
+            for (int i = 1; i <= nr_levels; i++) {
+                level_dist[i] = level_dist[i - 1] + f.at(i - 1);
+            }
+        }
+
+        int get_level(const spec& spec, int step_idx) const
+        {
+            int i = -1;
+            // PIs are considered to be on level zero.
+            if (step_idx < spec.nr_in) {
+                return 0;
+            } else if (step_idx == spec.nr_in) {
+                // First step is always on level one
+                return 1;
+            }
+            for (i = 0; i <= nr_levels; i++) {
+                if (level_dist[i] > step_idx) {
+                    break;
+                }
+            }
+            return i;
+        }
+
+        int first_step_on_level(int level) const
+        {
+            if (level == 0) { return 0; }
+            return level_dist[level-1];
+        }
+
+        void add_base_variables(const spec& spec)
+        {
+            for (int i = 0; i < MAJ_NOBJS; i++) {
+                pabc::Vec_IntClear(pabc::Vec_WecEntry(vOutLits, i));
+            }
+
+            iVar = 1;
+            for (int k = 0; k < 3; k++) {
+                const auto j = 2 - k;
+                pabc::Vec_WecPush(vOutLits, j, pabc::Abc_Var2Lit(iVar, 0));
+                varMarks[spec.nr_in][k][j] = iVar++;
+            }
+            for (int i = spec.nr_in + 1; i < spec.nr_in + spec.nr_steps; i++) {
+                for (int k = 0; k < 3; k++) {
+                    for (int j = 0; j < i - k; j++) {
+                        pabc::Vec_WecPush(vOutLits, j, pabc::Abc_Var2Lit(iVar, 0));
+                        varMarks[i][k][j] = iVar++;
+                    }
+                }
+            }
+            //printf("The number of structural variables = %d\n", iVar);
+        }
+
+        void add_base_variables(const spec& spec, const fence&)
+        {
+            for (int i = 0; i < MAJ_NOBJS; i++) {
+                pabc::Vec_IntClear(pabc::Vec_WecEntry(vOutLits, i));
+            }
+
+            iVar = 1;
+            for (int k = 0; k < 3; k++) {
+                const auto j = 2 - k;
+                pabc::Vec_WecPush(vOutLits, j, pabc::Abc_Var2Lit(iVar, 0));
+                varMarks[spec.nr_in][k][j] = iVar++;
+            }
+            for (int i = spec.nr_in + 1; i < spec.nr_in + spec.nr_steps; i++) {
+                const auto level = get_level(spec, i);
+                assert(level > 0);
+                const auto first_z = first_step_on_level(level - 1);
+                for (int z = first_z; z < first_step_on_level(level); z++) {
+                    pabc::Vec_WecPush(vOutLits, z, pabc::Abc_Var2Lit(iVar, 0));
+                    varMarks[i][0][z] = iVar++;
+                }
+                for (int k = 1; k < 3; k++) {
+                    for (int j = 0; j < i - k; j++) {
+                        pabc::Vec_WecPush(vOutLits, j, pabc::Abc_Var2Lit(iVar, 0));
+                        varMarks[i][k][j] = iVar++;
+                        //printf("varMarks[%d][%d][%d]=%d\n", i, k, j, iVar - 1);
+                    }
+                }
+            }
+            //printf("The number of structural variables = %d\n", iVar);
+        }
+
+        void add_base_variables(const spec& spec, const partial_dag& pd)
+        {
+            for (int i = 0; i < MAJ_NOBJS; i++) {
+                pabc::Vec_IntClear(pabc::Vec_WecEntry(vOutLits, i));
+            }
+
+            iVar = 1;
+            for (int k = 0; k < 3; k++) {
+                const auto j = 2 - k;
+                pabc::Vec_WecPush(vOutLits, j, pabc::Abc_Var2Lit(iVar, 0));
+                varMarks[spec.nr_in][k][j] = iVar++;
+            }
+            for (int i = spec.nr_in + 1; i < spec.nr_in + spec.nr_steps; i++) {
+                const auto& vertex = pd.get_vertex(i - spec.nr_in);
+
+                for (int k = 0; k < 3; k++) {
+                    const auto fanin = vertex[2 - k];
+                    if (fanin == 0) {
+                        for (int j = 0; j < i - k; j++) {
+                            pabc::Vec_WecPush(vOutLits, j, pabc::Abc_Var2Lit(iVar, 0));
+                            varMarks[i][k][j] = iVar++;
+                        }
+                    } else {
+                        const auto fanin_idx = fanin + spec.nr_in - 1;
+                        pabc::Vec_WecPush(vOutLits, fanin_idx, pabc::Abc_Var2Lit(iVar, 0));
+                        varMarks[i][k][fanin_idx] = iVar++;
+                    }
+                }
+            }
+            //printf("The number of structural variables = %d\n", iVar);
+        }
+
+        bool add_base_cnf(const spec& spec)
+        {
+            int tmpLits[2];
+            for (int i = spec.nr_in; i < spec.nr_in + spec.nr_steps; i++) {
+                for (int k = 0; k < 3; k++) {
+                    int nLits = 0;
+                    for (int j = 0; j < spec.nr_in + spec.nr_steps; j++) {
+                        if (varMarks[i][k][j]) {
+                            pLits[nLits++] = pabc::Abc_Var2Lit(varMarks[i][k][j], 0);
+                        }
+                    }
+                    if (!solver->add_clause(pLits, pLits + nLits))
+                        assert(false);
+                    for (int n = 0; n < nLits; n++) {
+                        for (int m = n + 1; m < nLits; m++) {
+                            tmpLits[0] = pabc::Abc_LitNot(pLits[n]);
+                            tmpLits[1] = pabc::Abc_LitNot(pLits[m]);
+                            if (!solver->add_clause(tmpLits, tmpLits + 2))
+                                assert(false);
+                        }
+                    }
+                    if (k == 2)
+                        break;
+                    // symmetry breaking
+                    for (int j = 0; j < spec.nr_in + spec.nr_steps; j++) {
+                        if (varMarks[i][k][j]) {
+                            for (int n = j; n < spec.nr_in + spec.nr_steps; n++) {
+                                if (varMarks[i][k + 1][n]) {
+                                    tmpLits[0] = pabc::Abc_Var2Lit(varMarks[i][k][j], 1);
+                                    tmpLits[1] = pabc::Abc_Var2Lit(varMarks[i][k + 1][n], 1);
+                                    if (!solver->add_clause(tmpLits, tmpLits + 2))
+                                        assert(false);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            for (int i = 0; i < spec.nr_in + spec.nr_steps - 1; i++) {
+                auto vArray = pabc::Vec_WecEntry(vOutLits, i);
+                if (Vec_IntSize(vArray) == 0) {
+                    // Note that this can happen e.g. if we synthesize a chain
+                    // with 1 step and > 3 variables.
+                    continue;
+                }
+                if (!solver->add_clause(pabc::Vec_IntArray(vArray), pabc::Vec_IntArray(vArray) + pabc::Vec_IntSize(vArray))) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        int Maj_ManValue(int iMint, int nVars)
+        {
+            int k, Count = 0;
+            for (k = 0; k < nVars; k++)
+                Count += (iMint >> k) & 1;
+            return (int)(Count > nVars / 2);
+        }
+
+        bool add_cnf(const spec& spec, int iMint)
+        {
+            // save minterm values
+            int Value = Maj_ManValue(iMint, spec.nr_in);
+            for (int i = 0; i < spec.nr_in; i++)
+                varVals[i] = (iMint >> i) & 1;
+            solver->set_nr_vars(iVar + 4 * spec.nr_steps);
+            //printf( "Adding clauses for minterm %d.\n", iMint );
+            for (int i = spec.nr_in; i < spec.nr_in + spec.nr_steps; i++) {
+                // fanin connectivity
+                const auto iBaseSatVarI = iVar + 4 * (i - spec.nr_in);
+                for (int k = 0; k < 3; k++)
+                {
+                    for (int j = 0; j < spec.nr_in + spec.nr_steps; j++) if (varMarks[i][k][j])
+                    {
+                        int iBaseSatVarJ = iVar + 4 * (j - spec.nr_in);
+                        for (int n = 0; n < 2; n++) {
+                            auto nLits = 0;
+                            pLits[nLits++] = pabc::Abc_Var2Lit(varMarks[i][k][j], 1);
+                            pLits[nLits++] = pabc::Abc_Var2Lit(iBaseSatVarI + k, n);
+                            if (j >= spec.nr_in)
+                                pLits[nLits++] = pabc::Abc_Var2Lit(iBaseSatVarJ + 3, !n);
+                            else if (varVals[j] == n)
+                                continue;
+                            if (!solver->add_clause(pLits, pLits + nLits))
+                                return false;
+                        }
+                    }
+                }
+                // node functionality
+                for (int n = 0; n < 2; n++) {
+                    if (i == (spec.nr_in + spec.nr_steps - 1) && n == Value)
+                        continue;
+                    for (int k = 0; k < 3; k++) {
+                        auto nLits = 0;
+                        if (k != 0) pLits[nLits++] = pabc::Abc_Var2Lit(iBaseSatVarI + 0, n);
+                        if (k != 1) pLits[nLits++] = pabc::Abc_Var2Lit(iBaseSatVarI + 1, n);
+                        if (k != 2) pLits[nLits++] = pabc::Abc_Var2Lit(iBaseSatVarI + 2, n);
+                        if (i != (spec.nr_in + spec.nr_steps - 1)) pLits[nLits++] = pabc::Abc_Var2Lit(iBaseSatVarI + 3, !n);
+                        assert(nLits <= 3);
+                        if (!solver->add_clause(pLits, pLits + nLits))
+                            return false;
+                    }
+                }
+            }
+            iVar += 4 * (spec.nr_steps);
+            return true;
+        }
+        
+        bool cegar_encode(const spec& spec)
+        {
+            memset(varMarks, 0, sizeof(varMarks));
+            for (int i = 0; i < spec.nr_in + spec.nr_steps; i++) {
+                sim_tts[i] = kitty::dynamic_truth_table(spec.nr_in);
+                if (i < spec.nr_in) {
+                    kitty::create_nth_var(sim_tts[i], i);
+                }
+            }
+            add_base_variables(spec);
+            if (!add_base_cnf(spec))
+                return false;
+
+            return true;
+        }
+
+        bool cegar_encode(const spec& spec, const fence& fence)
+        {
+            memset(varMarks, 0, sizeof(varMarks));
+            for (int i = 0; i < spec.nr_in + spec.nr_steps; i++) {
+                sim_tts[i] = kitty::dynamic_truth_table(spec.nr_in);
+                if (i < spec.nr_in) {
+                    kitty::create_nth_var(sim_tts[i], i);
+                }
+            }
+            update_level_map(spec, fence);
+            add_base_variables(spec, fence);
+            if (!add_base_cnf(spec))
+                return false;
+
+            return true;
+        }
+
+        bool cegar_encode(const spec& spec, const partial_dag& pd)
+        {
+            memset(varMarks, 0, sizeof(varMarks));
+            for (int i = 0; i < spec.nr_in + spec.nr_steps; i++) {
+                sim_tts[i] = kitty::dynamic_truth_table(spec.nr_in);
+                if (i < spec.nr_in) {
+                    kitty::create_nth_var(sim_tts[i], i);
+                }
+            }
+            add_base_variables(spec, pd);
+            if (!add_base_cnf(spec))
+                return false;
+
+            return true;
+        }
+        
+        /// Simulates the current state of the encoder and returns an index
+        /// of a minterm which is different from the specified function.
+        /// Returns -1 if no such index exists.
+        int simulate(const spec& spec)
+        {
+            kitty::dynamic_truth_table* pFanins[3];
+
+            for (int i = spec.nr_in; i < spec.nr_in + spec.nr_steps; i++) {
+                for (int k = 0; k < 3; k++)
+                    pFanins[k] = &sim_tts[find_fanin(spec, i, k)];
+                sim_tts[i] = kitty::ternary_majority(*pFanins[0], *pFanins[1], *pFanins[2]);
+            }
+            /*
+            const auto iMint =
+                kitty::find_first_bit_difference(sim_tts[spec.nr_in + spec.nr_steps - 1], spec[0]);
+            */
+            int iMint = -1;
+            kitty::static_truth_table<6> tt;
+            for (int i = 1; i < (1 << spec.nr_in); i++) {
+                kitty::create_from_words(tt, &i, &i + 1);
+                const int nOnes = kitty::count_ones(tt);
+                if (nOnes < spec.nr_in / 2 || nOnes > ((spec.nr_in/2) + 1)) {
+                    continue;
+                }
+                if (kitty::get_bit(sim_tts[spec.nr_in + spec.nr_steps - 1], i)
+                    == kitty::get_bit(spec[0], i)) {
+                    continue;
+                }
+                iMint = i;
+                break;
+            }
+
+            assert(iMint < (1 << spec.nr_in));
+            return iMint;
+        }
+
+        int get_nr_vars() const { return iVar; }
+
+        void extract_chain(const spec& spec, chain& chain)
+        {
+            chain.reset(spec.nr_in, 1, spec.nr_steps, 3);
+            kitty::dynamic_truth_table op(3);
+            kitty::create_majority(op);
+
+            int fanins[3];
+            for (int i = 0; i < spec.nr_steps; i++) {
+                fanins[0] = find_fanin(spec, spec.nr_in + i, 0);
+                fanins[1] = find_fanin(spec, spec.nr_in + i, 1);
+                fanins[2] = find_fanin(spec, spec.nr_in + i, 2);
+                chain.set_step(i, fanins, op);
+            }
+            chain.set_output(0, spec.nr_in + spec.nr_steps, 0);
+        }
+        
+    };
+
+    inline void ditt_maj_synthesize(int nr_in, chain& c)
+    {
+        spec spec;
+        bmcg_wrapper solver;
+        ditt_maj_encoder encoder(solver);
+        kitty::dynamic_truth_table tt(nr_in);
+        kitty::create_majority(tt);
+
+        spec[0] = tt;
+        spec.nr_steps = 1;
+        spec.preprocess();
+
+        while (true) {
+            //printf("nr_steps=%d\n", spec.nr_steps);
+            solver.restart();
+            if (!encoder.cegar_encode(spec)) {
+                spec.nr_steps++;
+                continue;
+            }
+            auto iMint = 0;
+            for (int i = 0; iMint != -1; i++) {
+                if (!encoder.add_cnf(spec, iMint)) {
+                    break;
+                }
+                //printf("Iter %3d : ", i);
+                //printf("Var =%5d  ", encoder.get_nr_vars());
+                //printf("Cla =%6d  ", solver.nr_clauses());
+                //printf("Conf =%9d\n", solver.nr_conflicts());
+                const auto status = solver.solve(0);
+                if (status == failure) {
+                    //printf("The problem has no solution\n");
+                    break;
+                }
+                iMint = encoder.simulate(spec);
+            }
+            if (iMint == -1) {
+                //printf("found solution!\n");
+                encoder.extract_chain(spec, c);
+                break;
+            }
+            spec.nr_steps++;
+        }
+    }
+
+    inline void fence_ditt_maj_synthesize(int nr_in, chain& c)
+    {
+        spec spec;
+        bmcg_wrapper solver;
+        ditt_maj_encoder encoder(solver);
+        kitty::dynamic_truth_table tt(nr_in);
+        kitty::create_majority(tt);
+
+        spec[0] = tt;
+        spec.preprocess();
+
+        fence f;
+        po_filter<unbounded_generator> g(unbounded_generator(spec.initial_steps), 1, 3);
+        while (true) {
+            g.next_fence(f);
+            //printf("next fence:\n"); print_fence(f); printf("\n");
+            spec.nr_steps = f.nr_nodes();
+            solver.restart();
+            if (!encoder.cegar_encode(spec, f)) {
+                continue;
+            }
+            auto iMint = 0;
+            for (int i = 0; iMint != -1; i++) {
+                if (!encoder.add_cnf(spec, iMint)) {
+                    break;
+                }
+                //printf("Iter %3d : ", i);
+                //printf("Var =%5d  ", encoder.get_nr_vars());
+                //printf("Cla =%6d  ", solver.nr_clauses());
+                //printf("Conf =%9d\n", solver.nr_conflicts());
+                const auto status = solver.solve(0);
+                if (status == failure) {
+                    //printf("The problem has no solution\n");
+                    break;
+                }
+                iMint = encoder.simulate(spec);
+            }
+            if (iMint == -1) {
+                //printf("found solution!\n");
+                encoder.extract_chain(spec, c);
+                break;
+            }
+        }
+    }
+
+    inline synth_result pd_ditt_maj_synthesize(int nr_in, const std::vector<partial_dag>& dags, chain& c, bool verbose=false)
+    {
+        spec spec;
+        bmcg_wrapper solver;
+        ditt_maj_encoder encoder(solver);
+        kitty::dynamic_truth_table tt(nr_in);
+        kitty::create_majority(tt);
+
+        spec[0] = tt;
+        spec.preprocess();
+
+        const auto start = std::chrono::steady_clock::now();
+        auto pd_count = 0;
+
+        for (const auto& pd : dags) {
+            spec.nr_steps = pd.nr_vertices();
+            solver.restart();
+            if (!encoder.cegar_encode(spec, pd)) {
+                continue;
+            }
+            auto iMint = 0;
+            for (int i = 0; iMint != -1; i++) {
+                if (!encoder.add_cnf(spec, iMint)) {
+                    break;
+                }
+                //printf("Iter %3d : ", i);
+                //printf("Var =%5d  ", encoder.get_nr_vars());
+                //printf("Cla =%6d  ", solver.nr_clauses());
+                //printf("Conf =%9d\n", solver.nr_conflicts());
+                const auto status = solver.solve(0);
+                if (status == failure) {
+                    //printf("The problem has no solution\n");
+                    break;
+                }
+                iMint = encoder.simulate(spec);
+            }
+            if (iMint == -1) {
+                //printf("found solution!\n");
+                encoder.extract_chain(spec, c);
+                return success;
+            }
+            if (verbose) {
+                ++pd_count;
+                const auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(
+                    std::chrono::steady_clock::now() - start
+                ).count();
+                printf("Processing %.2f PDs/second\r", (pd_count / (elapsed * 1.0)));
+            }
+        }
+        printf("\n");
+
+        return failure;
+    }
+
+    // Same as pd_ditt_maj_synthesize, but enumerates and prints found solutions.
+    inline int pd_ditt_maj_enumerate(int nr_in, const std::vector<partial_dag>& dags, bool verbose=false)
+    {
+        int num_solutions = 0;
+        spec spec;
+        bmcg_wrapper solver;
+        ditt_maj_encoder encoder(solver);
+        kitty::dynamic_truth_table tt(nr_in);
+        kitty::create_majority(tt);
+
+        chain c;
+
+        spec[0] = tt;
+        spec.preprocess();
+
+        const auto start = std::chrono::steady_clock::now();
+        auto pd_count = 0;
+
+        for (const auto& pd : dags) {
+            spec.nr_steps = pd.nr_vertices();
+            solver.restart();
+            if (!encoder.cegar_encode(spec, pd)) {
+                continue;
+            }
+            auto iMint = 0;
+            for (int i = 0; iMint != -1; i++) {
+                if (!encoder.add_cnf(spec, iMint)) {
+                    break;
+                }
+                //printf("Iter %3d : ", i);
+                //printf("Var =%5d  ", encoder.get_nr_vars());
+                //printf("Cla =%6d  ", solver.nr_clauses());
+                //printf("Conf =%9d\n", solver.nr_conflicts());
+                const auto status = solver.solve(0);
+                if (status == failure) {
+                    //printf("The problem has no solution\n");
+                    break;
+                }
+                iMint = encoder.simulate(spec);
+            }
+            if (iMint == -1) {
+                encoder.extract_chain(spec, c);
+                const auto chain_func = c.simulate()[0];
+                assert(chain_func == tt);
+                printf("\nfound chain:\n");
+                c.to_mag_expression(std::cout);
+                printf("\n");
+                num_solutions++;
+            }
+            if (verbose) {
+                ++pd_count;
+                const auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(
+                    std::chrono::steady_clock::now() - start
+                ).count();
+                printf("Processing %.2f PDs/second\r", (pd_count / (elapsed * 1.0)));
+            }
+        }
+        printf("\n");
+
+        return num_solutions;
+    }
+
+    inline synth_result parallel_pd_ditt_maj_synthesize(
+        int nr_in, 
+        const std::vector<partial_dag>& dags, 
+        chain& c,
+        int num_threads = std::thread::hardware_concurrency(),
+        bool verbose = false)
+    {
+        assert(dags.size() > 0);
+        spec spec;
+
+        kitty::dynamic_truth_table tt(nr_in);
+        kitty::create_majority(tt);
+
+        spec[0] = tt;
+        spec.preprocess();
+
+        std::vector<std::thread> threads(num_threads);
+        moodycamel::ConcurrentQueue<partial_dag> q(num_threads * 3);
+
+        bool found = false;
+        bool* pfound = &found;
+        std::mutex found_mutex;
+
+        spec.nr_steps = dags[0].nr_vertices();
+
+        std::atomic<int> nr_processed(0);
+
+        for (int i = 0; i < num_threads; i++) {
+            threads[i] = std::thread([&spec, pfound, &found_mutex, &c, &q, &nr_processed] {
+                bmcg_wrapper solver;
+                ditt_maj_encoder encoder(solver);
+                partial_dag local_pd;
+
+                while (!(*pfound)) {
+                    if (!q.try_dequeue(local_pd)) {
+                        std::this_thread::yield();
+                        if (!q.try_dequeue(local_pd)) {
+                            break;
+                        }
+                    }
+                    solver.restart();
+                    if (!encoder.cegar_encode(spec, local_pd)) {
+                        nr_processed++;
+                        continue;
+                    }
+                    auto iMint = 0;
+                    for (int i = 0; !(*pfound) && iMint != -1; i++) {
+                        if (!encoder.add_cnf(spec, iMint)) {
+                            nr_processed++;
+                            break;
+                        }
+                        synth_result status = timeout;
+                        do {
+                            status = solver.solve(10);
+                            if (*pfound) {
+                                break;
+                            } 
+                        } while (status == timeout);
+                        if (status == failure) {
+                            //printf("The problem has no solution\n");
+                            nr_processed++;
+                            break;
+                        }
+                        iMint = encoder.simulate(spec);
+                    }
+                    if (iMint == -1) {
+                        std::lock_guard<std::mutex> vlock(found_mutex);
+                        if (!(*pfound)) {
+                            encoder.extract_chain(spec, c);
+                            *pfound = true;
+                        }
+                    }
+                }
+            });
+        }
+        for (const auto& pd : dags) {
+            while (!found) {
+                if (!q.try_enqueue(pd)) {
+                    if (!found)
+                        std::this_thread::yield();
+                } else {
+                    break;
+                }
+                if (verbose)
+                    printf("Processed (%d/%zu)\r", nr_processed.load(), dags.size());
+            }
+        }
+        if (verbose)
+            printf("Processed (%d/%zu)\n", nr_processed.load(), dags.size());
+
+        for (auto& thread : threads) {
+            thread.join();
+        }
+
+        return found ? success : failure;
+    }
+
+    inline synth_result pf_ditt_maj_synthesize(
+        int nr_in, 
+        chain& c, 
+        int num_threads = std::thread::hardware_concurrency())
+    {
+        spec spec;
+
+        kitty::dynamic_truth_table tt(nr_in);
+        kitty::create_majority(tt);
+
+        spec[0] = tt;
+        spec.preprocess();
+
+        std::vector<std::thread> threads(num_threads);
+        moodycamel::ConcurrentQueue<fence> q(num_threads * 3);
+
+        bool finished_generating = false;
+        bool* pfinished = &finished_generating;
+        bool found = false;
+        bool* pfound = &found;
+        std::mutex found_mutex;
+
+        spec.nr_steps = spec.initial_steps;
+        while (true) {
+            for (int i = 0; i < num_threads; i++) {
+                threads[i] = std::thread([&spec, pfinished, pfound, &found_mutex, &c, &q] {
+                    bmcg_wrapper solver;
+                    ditt_maj_encoder encoder(solver);
+                    fence local_fence;
+
+                    while (!(*pfound)) {
+                        if (!q.try_dequeue(local_fence)) {
+                            if (*pfinished) {
+                                std::this_thread::yield();
+                                if (!q.try_dequeue(local_fence)) {
+                                    break;
+                                }
+                            } else {
+                                std::this_thread::yield();
+                                continue;
+                            }
+                        }
+                        solver.restart();
+                        if (!encoder.cegar_encode(spec, local_fence)) {
+                            continue;
+                        }
+                        auto iMint = 0;
+                        for (int i = 0; !(*pfound) && iMint != -1; i++) {
+                            if (!encoder.add_cnf(spec, iMint)) {
+                                break;
+                            }
+                            synth_result status = timeout;
+                            do {
+                                status = solver.solve(10);
+                                if (*pfound) {
+                                    break;
+                                } 
+                            } while (status == timeout);
+                            if (status == failure) {
+                                //printf("The problem has no solution\n");
+                                break;
+                            }
+                            iMint = encoder.simulate(spec);
+                        }
+                        if (iMint == -1) {
+                            std::lock_guard<std::mutex> vlock(found_mutex);
+                            if (!(*pfound)) {
+                                //printf("found solution!\n");
+                                encoder.extract_chain(spec, c);
+                                *pfound = true;
+                            }
+                        }
+                    }
+                });
+            }
+            generate_fences(spec, q);
+            finished_generating = true;
+
+            for (auto& thread : threads) {
+                thread.join();
+            }
+            if (found) {
+                break;
+            }
+            finished_generating = false;
+            spec.nr_steps++;
+        }
+
+        return success;
+    }
+}
diff --git a/lib/percy/percy/encoders/encoder.hpp b/lib/percy/percy/encoders/encoder.hpp
new file mode 100644
index 0000000..5682f7e
--- /dev/null
+++ b/lib/percy/percy/encoders/encoder.hpp
@@ -0,0 +1,211 @@
+#pragma once
+
+#include <bitset>
+#include "../spec.hpp"
+#include "../misc.hpp"
+#include "../sat_circuits.hpp"
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wall"
+#include <abc/vecInt.h>
+#pragma GCC diagnostic pop
+
+namespace percy
+{
+    class encoder
+    {
+    protected:
+        solver_wrapper* solver = nullptr;
+
+    public:
+        virtual ~encoder() { }
+        virtual void set_solver(solver_wrapper& s)
+        {
+            solver = &s;
+        }
+    };
+
+    class enumerating_encoder
+    {
+    protected:
+        bool dirty = false;
+
+    public:
+        virtual bool block_solution(const spec& spec) = 0;
+        virtual bool block_struct_solution(const spec& spec) = 0;
+
+        void reset()
+        {
+            dirty = false;
+        }
+
+        bool is_dirty() { return dirty; }
+        void set_dirty(bool dirty) { this->dirty = dirty;  }
+        virtual void extract_chain(const spec& spec, chain& chain) = 0;
+    };
+
+    class std_encoder : public encoder
+    {
+    public:
+        virtual bool encode(const spec& spec) = 0;
+        virtual bool cegar_encode(const spec& spec) = 0;
+        virtual bool create_tt_clauses(const spec& spec, int idx) = 0;
+        virtual void print_solver_state(const spec& spec) = 0;
+        virtual void extract_chain(const spec& spec, chain& chain) = 0;
+    };
+
+    class std_cegar_encoder : public std_encoder
+    {
+    protected:
+        static const int NR_SIM_TTS = 18;
+        std::vector<kitty::dynamic_truth_table> sim_tts{ NR_SIM_TTS };
+
+    public:
+        /// Simulates the current state of the encoder and returns an index
+        /// of a minterm which is different from the specified function.
+        /// Returns -1 if no such index exists.
+        /// Note: we subtract 1 from the actual index, as we encode only
+        /// normal functions.
+        virtual int simulate(const spec& spec) = 0;
+        
+        virtual void cegar_extract_chain(const spec& spec, chain& chain) = 0;
+
+        /// Resets the simulation truth tables, based on the number of PIs.
+        void reset_sim_tts(int nr_in)
+        {
+            for (int i = 0; i < NR_SIM_TTS; i++) {
+                sim_tts[i] = kitty::dynamic_truth_table(nr_in);
+                if (i < nr_in) {
+                    kitty::create_nth_var(sim_tts[i], i);
+                }
+            }
+        }
+    };
+
+    class fence_encoder : public encoder
+    {
+    public:
+        virtual bool encode(const spec& spec, const fence& f) = 0;
+        virtual bool cegar_encode(const spec& spec, const fence& f) = 0;
+        virtual bool create_tt_clauses(const spec& spec, int idx) = 0;
+        virtual kitty::dynamic_truth_table& simulate(const spec& spec) = 0;
+
+        virtual void extract_chain(const spec& spec, chain& chain) = 0;
+        virtual void reset_sim_tts(int) { }
+    };
+
+    template<int FI>
+    class dag_encoder : public encoder
+    {
+    public:
+        virtual bool encode(const spec& spec, const dag<FI>& dag) = 0;
+        virtual bool cegar_encode(const spec& spec, const dag<FI>& dag) = 0;
+        virtual void extract_chain(const spec& spec, const dag<2>& dag, chain& chain) = 0;
+    };
+
+
+    static inline void
+    clear_assignment(std::vector<int>& fanin_asgn)
+    {
+        std::fill(fanin_asgn.begin(), fanin_asgn.end(), 0);
+    }
+
+    static inline void
+    next_assignment(std::vector<int>& asgn)
+    {
+        for (auto i = 0u; i < asgn.size(); i++) {
+            if (asgn[i]) {
+                asgn[i] = 0;
+            } else {
+                asgn[i]++;
+                return;
+            }
+        }
+    }
+    
+    static inline void
+    inc_assignment(std::vector<int>& asgn, int max_val, int i)
+    {
+        if (static_cast<unsigned>(i) >= asgn.size()) return;
+
+        if (asgn[i] == max_val) {
+            asgn[i] = 0;
+            inc_assignment(asgn, max_val, i + 1);
+        } else {
+            assert(asgn[i] < max_val);
+            asgn[i]++;
+        }
+    }
+    
+    static inline void
+    inc_assignment(std::vector<int>& asgn, int max_val)
+    {
+        inc_assignment(asgn, max_val, 0);
+    }
+
+
+    static inline bool
+    is_zero(const std::vector<int>& fanin_asgn)
+    {
+        auto status = true;
+        for (const auto asgn : fanin_asgn) {
+            if (asgn != 0) {
+                status = false;
+            }
+        }
+        return status;
+    }
+
+    inline void fanin_init(std::vector<int>& fanins, int max_fanin_id)
+    {
+        fanins[fanins.size()-1] = max_fanin_id--;
+        for (int i = fanins.size() - 2; i >= 0; i--) {
+            fanins[i] = max_fanin_id--;
+        }
+    }
+
+    inline void fanin_init(std::vector<int>& fanins, int max_fanin_id, int start_idx)
+    {
+        fanins[start_idx] = max_fanin_id--;
+        for (int i = start_idx-1; i >= 0; i--) {
+            fanins[i] = max_fanin_id--;
+        }
+    }
+
+    inline bool fanin_inc(std::vector<int>& fanins, const int max_fanin_id)
+    {
+        for (auto i = 0u; i < fanins.size(); i++) {
+            if (i < fanins.size() - 1) {
+                if (fanins[i] < fanins[i + 1] - 1) {
+                    fanins[i]++;
+                    if (i > 0) {
+                        fanin_init(fanins, i - 1, i - 1);
+                    }
+                    return true;
+                }
+            } else {
+                if (fanins[i] < max_fanin_id) {
+                    fanins[i]++;
+                    fanin_init(fanins, i - 1, i - 1);
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    inline void print_fanin(const std::vector<int>& fanins)
+    {
+        for (auto i = 0u; i < fanins.size(); i++) {
+            printf("%d ", fanins[i] + 1);
+        }
+    }
+
+    inline void print_fanin(const int* const fanins, int nr_fanins)
+    {
+        for (auto i = 0; i < nr_fanins; i++) {
+            printf("%d ", fanins[i] + 1);
+        }
+    }
+}
diff --git a/lib/percy/percy/encoders/maj_encoder.hpp b/lib/percy/percy/encoders/maj_encoder.hpp
new file mode 100644
index 0000000..bcbc842
--- /dev/null
+++ b/lib/percy/percy/encoders/maj_encoder.hpp
@@ -0,0 +1,1941 @@
+#pragma once
+
+#include <vector>
+#include <kitty/kitty.hpp>
+#include "encoder.hpp"
+
+namespace percy
+{
+    class maj_encoder
+    {
+    private:
+        int level_dist[32]; // How many steps are below a certain level
+        int nr_levels; // The number of levels in the Boolean fence
+        int nr_sel_vars;
+        int nr_res_vars;
+        int nr_sim_vars;
+        int total_nr_vars;
+        int sel_offset;
+        int res_offset;
+        int sim_offset;
+        bool dirty = false;
+        pabc::lit pLits[2048];
+        solver_wrapper* solver;
+
+        static const int NR_SIM_TTS = 32;
+        std::vector<kitty::dynamic_truth_table> sim_tts { NR_SIM_TTS };
+
+        int get_sim_var(const spec& spec, int step_idx, int t) const
+        {
+            return sim_offset + spec.tt_size * step_idx + t;
+        }
+
+        bool fix_output_sim_vars(const spec& spec, int t)
+        {
+            const auto ilast_step = spec.nr_steps - 1;
+            auto outbit = kitty::get_bit(
+                spec[spec.synth_func(0)], t + 1);
+            if ((spec.out_inv >> spec.synth_func(0)) & 1) {
+                outbit = 1 - outbit;
+            }
+            const auto sim_var = get_sim_var(spec, ilast_step, t);
+            pabc::lit sim_lit = pabc::Abc_Var2Lit(sim_var, 1 - outbit);
+            return solver->add_clause(&sim_lit, &sim_lit + 1);
+        }
+
+        int get_sel_var(
+            const spec& spec, 
+            const int i, 
+            const int j, 
+            const int k,
+            const int l) const
+        {
+            assert(i < spec.nr_steps);
+
+            int offset = 0;
+            for (int ip = 0; ip < i; ip++) {
+                const auto n = spec.nr_in + ip;
+                offset += (n * (n - 1) * (n - 2)) / 6;
+            }
+
+            int svar_ctr = 0;
+            for (int lp = 2; lp < spec.nr_in + i; lp++) {
+                for (int kp = 1; kp < lp; kp++) {
+                    for (int jp = 0; jp < kp; jp++) {
+                        if (l == lp && k == kp && j == jp) {
+                            return sel_offset + offset + svar_ctr;
+                        }
+                        svar_ctr++;
+                    }
+                }
+            }
+
+            assert(false);
+            return -1;
+        }
+
+        int get_sel_var(const spec& spec, int idx, int var_idx) const
+        {
+            assert(idx < spec.nr_steps);
+            const auto nr_svars_for_idx = nr_svars_for_step(spec, idx);
+            assert(var_idx < nr_svars_for_idx);
+            auto offset = 0;
+            for (int i = 0; i < idx; i++) {
+                offset += nr_svars_for_step(spec, i);
+            }
+            return sel_offset + offset + var_idx;
+        }
+
+        int get_res_var(const spec& spec, int step_idx, int res_var_idx) const
+        {
+            auto offset = 0;
+            for (int i = 0; i < step_idx; i++) {
+                offset += (nr_svars_for_step(spec, i) + 1) * (1 + 2);
+            }
+
+            return res_offset + offset + res_var_idx;
+        }
+
+    public:
+        maj_encoder(solver_wrapper& solver)
+        {
+            this->solver = &solver;
+        }
+
+        ~maj_encoder()
+        {
+        }
+
+        void create_variables(const spec& spec)
+        {
+            nr_sim_vars = spec.nr_steps * spec.tt_size;
+
+            nr_sel_vars = 0;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto n = spec.nr_in + i;
+                nr_sel_vars += (n * (n - 1) * (n - 2)) / 6;
+            }
+
+            sel_offset = 0;
+            sim_offset = nr_sel_vars;
+            total_nr_vars = nr_sel_vars + nr_sim_vars;
+
+            if (spec.verbosity) {
+                printf("Creating variables (MIG)\n");
+                printf("nr steps = %d\n", spec.nr_steps);
+                printf("nr_sel_vars=%d\n", nr_sel_vars);
+                printf("nr_sim_vars = %d\n", nr_sim_vars);
+                printf("creating %d total variables\n", total_nr_vars);
+            }
+
+            solver->set_nr_vars(total_nr_vars);
+        }
+
+        void create_variables(const spec& spec, const partial_dag& dag)
+        {
+            nr_sim_vars = spec.nr_steps * spec.tt_size;
+
+            nr_sel_vars = 0;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto nr_svars_for_i = nr_svars_for_step(spec, dag, i);
+                nr_sel_vars += nr_svars_for_i;
+            }
+
+            sel_offset = 0;
+            sim_offset = nr_sel_vars;
+            total_nr_vars = nr_sel_vars + nr_sim_vars;
+
+            if (spec.verbosity) {
+                printf("Creating variables (PD-%d)\n", spec.fanin);
+                printf("nr steps = %d\n", spec.nr_steps);
+                printf("nr_sel_vars=%d\n", nr_sel_vars);
+                printf("nr_sim_vars = %d\n", nr_sim_vars);
+                printf("creating %d total variables\n", total_nr_vars);
+            }
+
+            solver->set_nr_vars(total_nr_vars);
+        }
+
+        int first_step_on_level(int level) const
+        {
+            if (level == 0) { return 0; }
+            return level_dist[level-1];
+        }
+
+        int nr_svars_for_step(const spec& spec, int i) const
+        {
+            // Determine the level of this step.
+            const auto level = get_level(spec, i + spec.nr_in);
+            auto nr_svars_for_i = 0;
+            assert(level > 0);
+            for (auto l = first_step_on_level(level - 1);
+                l < first_step_on_level(level); l++) {
+                // We select l as fanin 3, so have (l choose 2) options 
+                // (j,k in {0,...,(l-1)}) left for fanin 1 and 2.
+                nr_svars_for_i += (l * (l - 1)) / 2;
+            }
+
+            return nr_svars_for_i;
+        }
+
+        int nr_pi_fanins_for_step(const partial_dag& dag, int i) const
+        {
+            const auto& vertex = dag.get_vertex(i);
+            auto nr_pi_fanins = 0;
+            if (vertex[2] == FANIN_PI) {
+                nr_pi_fanins = 3;
+            } else if (vertex[1] == FANIN_PI) {
+                nr_pi_fanins = 2;
+            } else if (vertex[0] == FANIN_PI) {
+                nr_pi_fanins = 1;
+            }
+
+            return nr_pi_fanins;
+        }
+
+        int nr_svars_for_step(const spec& spec, const partial_dag& dag, int i) const
+        {
+            const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, i);
+            switch (nr_pi_fanins) {
+            case 1:
+                return spec.nr_in;
+            case 2:
+                return (spec.nr_in * (spec.nr_in - 1)) / 2;
+            case 3:
+                return (spec.nr_in * (spec.nr_in - 1) * (spec.nr_in - 2)) / 6;
+            default: // No fanin flexibility
+                return 0;
+            }
+        }
+
+        int get_sel_var(
+            const spec& spec,
+            const partial_dag& dag,
+            int step_idx,
+            int var_idx) const
+        {
+            auto offset = 0;
+            for (int i = 0; i < step_idx; i++) {
+                offset += nr_svars_for_step(spec, dag, i);
+            }
+            return sel_offset + offset + var_idx;
+        }
+
+        void fence_create_variables(const spec& spec)
+        {
+            nr_sim_vars = spec.nr_steps * spec.tt_size;
+
+            nr_sel_vars = 0;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                nr_sel_vars += nr_svars_for_step(spec, i);
+            }
+
+            sel_offset = 0;
+            sim_offset = nr_sel_vars;
+            total_nr_vars = nr_sel_vars + nr_sim_vars;
+
+            if (spec.verbosity) {
+                printf("Creating variables (MIG)\n");
+                printf("nr steps = %d\n", spec.nr_steps);
+                printf("nr_sel_vars=%d\n", nr_sel_vars);
+                printf("nr_sim_vars = %d\n", nr_sim_vars);
+                printf("creating %d total variables\n", total_nr_vars);
+            }
+
+            solver->set_nr_vars(total_nr_vars);
+        }
+
+        void cegar_fence_create_variables(const spec& spec)
+        {
+            nr_sim_vars = spec.nr_steps * spec.tt_size;
+
+            nr_sel_vars = 0;
+            nr_res_vars = 0;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto nr_svars_for_i = nr_svars_for_step(spec, i);
+                nr_sel_vars += nr_svars_for_i;
+                nr_res_vars += (nr_svars_for_i + 1) * (1 + 2);
+            }
+
+            sel_offset = 0;
+            res_offset = nr_sel_vars;
+            sim_offset = nr_sel_vars + nr_res_vars;
+            total_nr_vars = nr_sel_vars + nr_res_vars + nr_sim_vars;
+
+            if (spec.verbosity) {
+                printf("Creating variables (MIG)\n");
+                printf("nr steps = %d\n", spec.nr_steps);
+                printf("nr_sel_vars=%d\n", nr_sel_vars);
+                printf("nr_sel_vars=%d\n", nr_res_vars);
+                printf("nr_sim_vars = %d\n", nr_sim_vars);
+                printf("creating %d total variables\n", total_nr_vars);
+            }
+
+            solver->set_nr_vars(total_nr_vars);
+        }
+
+        /// Ensures that each gate has the proper number of fanins.
+        bool create_fanin_clauses(const spec& spec)
+        {
+            auto status = true;
+
+            if (spec.verbosity > 2) {
+                printf("Creating fanin clauses (MIG)\n");
+                printf("Nr. clauses = %d (PRE)\n", solver->nr_clauses());
+            }
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                auto ctr = 0;
+                for (int l = 2; l < spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto svar = get_sel_var(spec, i, j, k, l);
+                            pLits[ctr++] = pabc::Abc_Var2Lit(svar, 0);
+                        }
+                    }
+                }
+                status &= solver->add_clause(pLits, pLits + ctr);
+            }
+
+            if (spec.verbosity > 2) {
+                printf("Nr. clauses = %d (POST)\n", solver->nr_clauses());
+            }
+
+            return status;
+        }
+
+        bool create_fanin_clauses(const spec& spec, const partial_dag& dag)
+        {
+            auto status = true;
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto nr_svars_for_i = nr_svars_for_step(spec, dag, i);
+                if (nr_svars_for_i == 0) {
+                    continue;
+                }
+
+                for (int j = 0; j < nr_svars_for_i; j++) {
+                    pLits[j] = pabc::Abc_Var2Lit(get_sel_var(spec, dag, i, j), 0);
+                }
+
+                status &= solver->add_clause(pLits, pLits + nr_svars_for_i);
+            }
+
+            return status;
+        }
+
+        ///< We synthesize MIGs with 4 possible operators since all
+        ///< the others are symmetries of these. The operators are:
+        ///< (1) <abc>
+        ///< (2) <!abc>
+        ///< (3) <a!bc>
+        ///< (4) <ab!c>
+        /*
+        bool create_op_clauses(const spec& spec)
+        {
+            auto status = true;
+
+            kitty::static_truth_table<3> in1, in2, in3, arb_tt,
+                maj1, maj2, maj3, maj4;
+            kitty::create_nth_var(in1, 0);
+            kitty::create_nth_var(in2, 1);
+            kitty::create_nth_var(in3, 2);
+
+            maj1 = (in1 & in2) | (in1 & in3) | (in2 & in3);
+            maj2 = (~in1 & in2) | (~in1 & in3) | (in2 & in3);
+            maj3 = (in1 & ~in2) | (in1 & in3) | (~in2 & in3);
+            maj4 = (in1 & in2) | (in1 & ~in3) | (in2 & ~in3);
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                kitty::clear(arb_tt);
+                int nr_block_clauses = 0;
+                do {
+                    if (arb_tt == maj1 || arb_tt == maj2 || 
+                        arb_tt == maj3 || arb_tt == maj4) {
+                        kitty::next_inplace(arb_tt);
+                        continue;
+                    }
+                    if (!is_normal(arb_tt)) {
+                        kitty::next_inplace(arb_tt);
+                        continue;
+                    }
+
+                    pLits[0] = pabc::Abc_Var2Lit(get_op_var(spec, i, 0), 
+                        kitty::get_bit(arb_tt, 1));
+                    pLits[1] = pabc::Abc_Var2Lit(get_op_var(spec, i, 1), 
+                        kitty::get_bit(arb_tt, 2));
+                    pLits[2] = pabc::Abc_Var2Lit(get_op_var(spec, i, 2), 
+                        kitty::get_bit(arb_tt, 3));
+                    pLits[3] = pabc::Abc_Var2Lit(get_op_var(spec, i, 3), 
+                        kitty::get_bit(arb_tt, 4));
+                    pLits[4] = pabc::Abc_Var2Lit(get_op_var(spec, i, 4), 
+                        kitty::get_bit(arb_tt, 5));
+                    pLits[5] = pabc::Abc_Var2Lit(get_op_var(spec, i, 5), 
+                        kitty::get_bit(arb_tt, 6));
+                    pLits[6] = pabc::Abc_Var2Lit(get_op_var(spec, i, 6), 
+                        kitty::get_bit(arb_tt, 7));
+                    status &= solver->add_clause(pLits, pLits + 7);
+                    assert(status);
+
+                    if (nr_block_clauses++ > 256) {
+                        break;
+                    }
+                    kitty::next_inplace(arb_tt);
+                } while (!kitty::is_const0(arb_tt));
+            }
+
+            return status;
+        }
+        */
+
+        int maj3(int a, int b, int c) const
+        {
+            return (a & b) | (a & c) | (b & c);
+        }
+
+        bool add_simulation_clause(
+            const spec& spec,
+            const int t,
+            const int i,
+            const int j,
+            const int k,
+            const int l,
+            const int c,
+            const int b,
+            const int a,
+            const int sel_var
+            )
+        {
+            int ctr = 0;
+            //assert(j > 0);
+
+            if (j < spec.nr_in) {
+                if ((((t + 1) & (1 << j)) ? 1 : 0) != a) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, j - spec.nr_in, t), a);
+            }
+
+            if (k < spec.nr_in) {
+                if ((((t + 1) & (1 << k)) ? 1 : 0) != b) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, k - spec.nr_in, t), b);
+            }
+
+            if (l < spec.nr_in) {
+                if ((((t + 1) & (1 << l)) ? 1 : 0) != c) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, l - spec.nr_in, t), c);
+            }
+
+            if (sel_var != -1) {
+                pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+            }
+
+            if (maj3(a, b, c)) {
+                pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 0);
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 1);
+            }
+
+            const auto ret = solver->add_clause(pLits, pLits + ctr);
+            assert(ret);
+            return ret;
+        }
+
+        bool create_tt_clauses(const spec& spec, const int t)
+        {
+            bool ret = true;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                for (int l = 2; l < spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, j, k, l);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 1, sel_var);
+                        }
+                    }
+                }
+                assert(ret);
+            }
+
+            ret &= fix_output_sim_vars(spec, t);
+
+            return ret;
+        }
+
+        bool create_tt_clauses(const spec& spec, const partial_dag& dag, const int t)
+        {
+            auto ret = true;
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto& vertex = dag.get_vertex(i);
+                const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, i);
+                if (nr_pi_fanins == 0) {
+                    // The fanins for this step are fixed
+                    const auto j = vertex[0] + spec.nr_in - 1;
+                    const auto k = vertex[1] + spec.nr_in - 1;
+                    const auto l = vertex[1] + spec.nr_in - 1;
+                    ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 0, -1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 1, -1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 0, -1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 1, -1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 0, -1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 1, -1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 0, -1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 1, -1);
+                } else if (nr_pi_fanins == 1) {
+                    // The first fanin is flexible
+                    const auto k = vertex[1] + spec.nr_in - 1;
+                    const auto l = vertex[2] + spec.nr_in - 1;
+                    for (int j = 0; j < spec.nr_in; j++) {
+                        const auto sel_var = get_sel_var(spec, dag, i, j);
+                        ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 0, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 1, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 0, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 1, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 0, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 1, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 0, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 1, sel_var);
+                    }
+                } else if (nr_pi_fanins == 2) {
+                    const auto l = vertex[2] + spec.nr_in - 1;
+                    int ctr = 0;
+                    for (int k = 1; k < spec.nr_in; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, dag, i, ctr++);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 1, sel_var);
+                        }
+                    }
+                } else {
+                    assert(nr_pi_fanins == 3);
+                    int ctr = 0;
+                    for (int l = 2; l < spec.nr_in; l++) {
+                        for (int k = 1; k < l; k++) {
+                            for (int j = 0; j < k; j++) {
+                                const auto sel_var = get_sel_var(spec, dag, i, ctr++);
+                                ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 0, sel_var);
+                                ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 1, sel_var);
+                                ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 0, sel_var);
+                                ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 1, sel_var);
+                                ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 0, sel_var);
+                                ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 1, sel_var);
+                                ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 0, sel_var);
+                                ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 1, sel_var);
+                            }
+                        }
+                    }
+                }
+            }
+            
+            ret &= fix_output_sim_vars(spec, t);
+
+            return ret;
+        }
+
+        bool fence_create_tt_clauses(const spec& spec, const int t)
+        {
+            bool ret = true;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto level = get_level(spec, i + spec.nr_in);
+                int ctr = 0;
+                for (int l = first_step_on_level(level - 1);
+                    l < first_step_on_level(level); l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, ctr++);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 0, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 0, 1, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 0, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, l, 1, 1, 1, sel_var);
+                        }
+                    }
+                }
+                assert(ret);
+            }
+
+            ret &= fix_output_sim_vars(spec, t);
+
+            return ret;
+        }
+
+        void create_main_clauses(const spec& spec)
+        {
+            for (int t = 0; t < spec.tt_size; t++) {
+                (void)create_tt_clauses(spec, t);
+            }
+        }
+
+        void create_main_clauses(const spec& spec, const partial_dag& dag)
+        {
+            for (int t = 0; t < spec.tt_size; t++) {
+                (void)create_tt_clauses(spec, dag, t);
+            }
+        }
+
+        bool fence_create_main_clauses(const spec& spec)
+        {
+            bool ret = true;
+            for (int t = 0; t < spec.tt_size; t++) {
+                ret &= fence_create_tt_clauses(spec, t);
+            }
+            return ret;
+        }
+
+        void create_alonce_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                int ctr = 0;
+                const auto idx = spec.nr_in + i;
+                for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                    for (int l = spec.nr_in + i; l < spec.nr_in + ip; l++) {
+                        for (int k = 1; k < l; k++) {
+                            for (int j = 0; j < k; j++) {
+                                if (j == idx || k == idx || l == idx) {
+                                    const auto sel_var = get_sel_var(spec, ip, j, k, l);
+                                    pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 0);
+                                }
+                            }
+                        }
+                    }
+                }
+                const auto res = solver->add_clause(pLits, pLits + ctr);
+                assert(res);
+            }
+        }
+
+        void fence_create_alonce_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                auto ctr = 0;
+                const auto idx = spec.nr_in + i;
+                const auto level = get_level(spec, idx);
+                for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                    auto levelp = get_level(spec, ip + spec.nr_in);
+                    assert(levelp >= level);
+                    if (levelp == level) {
+                        continue;
+                    }
+                    auto svctr = 0;
+                    for (int l = first_step_on_level(levelp - 1);
+                        l < first_step_on_level(levelp); l++) {
+                        for (int k = 1; k < l; k++) {
+                            for (int j = 0; j < k; j++) {
+                                if (j == idx || k == idx || l == idx) {
+                                    const auto sel_var = get_sel_var(spec, ip, svctr);
+                                    pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 0);
+                                }
+                                svctr++;
+                            }
+                        }
+                    }
+                    assert(svctr == nr_svars_for_step(spec, ip));
+                }
+                solver->add_clause(pLits, pLits + ctr);
+            }
+        }
+
+        void create_noreapply_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                for (int l = 2; l < spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, j, k, l);
+                            pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                            for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                                for (int kp = 1; kp < spec.nr_steps + i; kp++) {
+                                    for (int jp = 0; jp < kp; jp++) {
+                                        if ((kp == l && jp == k) || 
+                                            (kp == k && jp == j) ||
+                                            (kp == l && jp == k)) {
+                                            const auto sel_varp = get_sel_var(spec, ip, jp, kp, spec.nr_in + i);
+                                            pLits[1] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                            auto status = solver->add_clause(pLits, pLits + 2);
+                                            assert(status);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        bool reapply_helper(
+            const spec& spec,
+            const partial_dag& dag,
+            int *svars,
+            int depth,
+            int i, 
+            int j,
+            int k,
+            int l,
+            int ip,
+            int jp,
+            int kp,
+            int lp)
+        {
+            int pLits[3];
+            if (depth == 2) {
+                if (lp == (spec.nr_in + i) &&
+                    ((kp == l && jp == k) ||
+                    (kp == k && jp == j) ||
+                    (kp == l && jp == k))) {
+                    const auto sel_var = svars[0];
+                    const auto sel_varp = svars[1];
+                    auto ctr = 0;
+                    if (sel_var != -1) {
+                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+                    }
+                    if (sel_varp != -1) {
+                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 1);
+                    }
+                    if (ctr > 1) {
+                        return solver->add_clause(pLits, pLits + ctr);
+                    }
+                }
+            } else if (depth == 1) {
+                for (ip = i + 1; ip < spec.nr_steps; ip++) {
+                    const auto& vertex = dag.get_vertex(ip);
+                    const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, ip);
+                    if (nr_pi_fanins == 0) {
+                        svars[1] = -1;
+                        jp = spec.nr_in + vertex[0] - 1;
+                        kp = spec.nr_in + vertex[1] - 1;
+                        lp = spec.nr_in + vertex[2] - 1;
+                        reapply_helper(spec, dag, svars, 2, i, j, k, l, ip, jp, kp, lp);
+                    } else if (nr_pi_fanins == 1) {
+                        kp = spec.nr_in + vertex[1] - 1;
+                        lp = spec.nr_in + vertex[2] - 1;
+                        for (jp = 0; jp < spec.nr_in; jp++) {
+                            svars[1] = get_sel_var(spec, dag, ip, jp);
+                            reapply_helper(spec, dag, svars, 2, i, j, k, l, ip, jp, kp, lp);
+                        }
+                    } else if (nr_pi_fanins == 2) {
+                        auto svar_ctr = 0;
+                        lp = spec.nr_in + vertex[2] - 1;
+                        for (kp = 1; kp < spec.nr_in; kp++) {
+                            for (jp = 0; jp < kp; jp++) {
+                                const auto sel_var = get_sel_var(spec, dag, ip, svar_ctr++);
+                                svars[1] = sel_var;
+                                reapply_helper(spec, dag, svars, 2, i, j, k, l, ip, jp, kp, lp);
+                            }
+                        }
+                    } else {
+                        auto svar_ctr = 0;
+                        for (lp = 2; lp < spec.nr_in; lp++) {
+                            for (kp = 1; kp < lp; kp++) {
+                                for (jp = 0; jp < kp; jp++) {
+                                    const auto sel_var = get_sel_var(spec, dag, ip, svar_ctr++);
+                                    svars[1] = sel_var;
+                                    reapply_helper(spec, dag, svars, 2, i, j, k, l, ip, jp, kp, lp);
+                                }
+                            }
+                        }
+                    }
+                }
+            } else {
+                for (i = 0; i < spec.nr_steps; i++) {
+                    const auto& vertex = dag.get_vertex(i);
+                    const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, i);
+                    if (nr_pi_fanins == 0) {
+                        svars[0] = -1;
+                        j = spec.nr_in + vertex[0] - 1;
+                        k = spec.nr_in + vertex[1] - 1;
+                        l = spec.nr_in + vertex[2] - 1;
+                        reapply_helper(spec, dag, svars, 1, i, j, k, l, 0, 0, 0, 0);
+                    } else if (nr_pi_fanins == 1) {
+                        k = spec.nr_in + vertex[1] - 1;
+                        l = spec.nr_in + vertex[2] - 1;
+                        for (j = 0; j < spec.nr_in; j++) {
+                            svars[0] = get_sel_var(spec, dag, i, j);
+                            reapply_helper(spec, dag, svars, 1, i, j, k, l, 0, 0, 0, 0);
+                        }
+                    } else if (nr_pi_fanins == 2) {
+                        auto svar_ctr = 0;
+                        l = spec.nr_in + vertex[2] - 1;
+                        for (k = 1; k < spec.nr_in; k++) {
+                            for (j = 0; j < k; j++) {
+                                const auto sel_var = get_sel_var(spec, dag, i, svar_ctr++);
+                                svars[0] = sel_var;
+                                reapply_helper(spec, dag, svars, 1, i, j, k, l, 0, 0, 0, 0);
+                            }
+                        }
+                    } else {
+                        auto svar_ctr = 0;
+                        for (l = 2; l < spec.nr_in; l++) {
+                            for (k = 1; k < l; k++) {
+                                for (j = 0; j < k; j++) {
+                                    const auto sel_var = get_sel_var(spec, dag, i, svar_ctr++);
+                                    svars[0] = sel_var;
+                                    reapply_helper(spec, dag, svars, 1, i, j, k, l, 0, 0, 0, 0);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        bool create_noreapply_clauses(const spec& spec, const partial_dag& dag)
+        {
+            int svars[2];
+            
+            return reapply_helper(spec, dag, svars, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+        }
+
+
+        void fence_create_noreapply_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                const auto level = get_level(spec, spec.nr_in + i);
+                int svar_ctr = 0;
+                for (int l = first_step_on_level(level - 1); 
+                    l < first_step_on_level(level); l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, svar_ctr);
+                            pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                            for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                                const auto levelp = get_level(spec, spec.nr_in + ip);
+                                if (level == levelp) {
+                                    continue;
+                                }
+                                int svar_ctrp = 0;
+                                for (int lp = first_step_on_level(levelp - 1);
+                                    lp < first_step_on_level(levelp); lp++) {
+                                    for (int kp = 1; kp < l; kp++) {
+                                        for (int jp = 0; jp < kp; jp++) {
+                                            if ((lp == spec.nr_in + i) && 
+                                                ((kp == l && jp == k) ||
+                                                (kp == k && jp == j) ||
+                                                (kp == l && jp == k))) {
+                                                const auto sel_varp = get_sel_var(spec, ip, svar_ctrp);
+                                                pLits[1] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                                auto status = solver->add_clause(pLits, pLits + 2);
+                                                assert(status);
+                                            }
+                                            svar_ctrp++;
+                                        }
+                                    }
+                                }
+                            }
+                            svar_ctr++;
+                        }
+                    }
+                }
+            }
+        }
+
+        /// Ensure that all steps are in strict co-lexicographic
+        /// order. Unlike the general Boolean chain case, here we 
+        /// don't want two steps pointing to the same inputs since
+        /// they cannot implement different functions.
+        void create_colex_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                for (int l = 2; l < spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            pLits[0] = pabc::Abc_Var2Lit(get_sel_var(spec, i, j, k, l), 1);
+
+                            // Cannot have lp <= l
+                            for (int lp = 2; lp <= l; lp++) {
+                                for (int kp = 1; kp < lp; kp++) {
+                                    for (int jp = 0; jp < kp; jp++) {
+                                        pLits[1] = pabc::Abc_Var2Lit(get_sel_var(spec, i + 1, jp, kp, lp), 1);
+                                        const auto res = solver->add_clause(pLits, pLits + 2);
+                                        assert(res);
+                                    }
+                                }
+                            }
+
+                            // May have lp == l and kp > k
+                            for (int kp = 1; kp <= k; kp++) {
+                                for (int jp = 0; jp < kp; jp++) {
+                                    pLits[1] = pabc::Abc_Var2Lit(get_sel_var(spec, i + 1, jp, kp, l), 1);
+                                    const auto res = solver->add_clause(pLits, pLits + 2);
+                                    assert(res);
+                                }
+                            }
+                            // OR lp == l and kp == k
+                            for (int jp = 0; jp <= j; jp++) {
+                                pLits[1] = pabc::Abc_Var2Lit(get_sel_var(spec, i + 1, jp, k, l), 1);
+                                const auto res = solver->add_clause(pLits, pLits + 2);
+                                assert(res);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        void colex_helper(
+            const spec& spec,
+            const partial_dag& dag, 
+            int i, 
+            int j, 
+            int k, 
+            int l, 
+            int sel_var) 
+        {
+            int pLits[2];
+
+            const auto& vertex = dag.get_vertex(i + 1);
+            const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, i);
+            if (nr_pi_fanins == 1) {
+                const auto kp = spec.nr_in + vertex[1] - 1;
+                const auto lp = spec.nr_in + vertex[2] - 1;
+                for (int jp = 0; jp < spec.nr_in; jp++) {
+                    if ((kp == k && jp <= j && lp == l) || (kp < k && lp == l) || (lp < l)) {
+                        const auto sel_varp = get_sel_var(spec, dag, i + 1, jp);
+                        int ctr = 0;
+                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 1);
+                        (void)solver->add_clause(pLits, pLits + ctr);
+                    }
+                }
+            } else if (nr_pi_fanins == 2) {
+                auto svar_ctr = 0;
+                const auto lp = spec.nr_in + vertex[2] - 1;
+                for (int kp = 1; kp < spec.nr_in; kp++) {
+                    for (int jp = 0; jp < kp; jp++) {
+                        if ((kp == k && jp <= j && lp == l) || (kp < k && lp == l) || (lp < l)) {
+                            const auto sel_varp = get_sel_var(spec, dag, i + 1, svar_ctr);
+                            int ctr = 0;
+                            pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+                            pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 1);
+                            (void)solver->add_clause(pLits, pLits + ctr);
+                        }
+                        svar_ctr++;
+                    }
+                }
+            } else if (nr_pi_fanins == 3) {
+                auto svar_ctr = 0;
+                for (int lp = 2; lp < spec.nr_in; lp++) {
+                    for (int kp = 1; kp < lp; kp++) {
+                        for (int jp = 0; jp < kp; jp++) {
+                            if ((kp == k && jp <= j && lp == l) || (kp < k && lp == l) || (lp < l)) {
+                                const auto sel_varp = get_sel_var(spec, dag, i + 1, svar_ctr);
+                                int ctr = 0;
+                                pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+                                pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                (void)solver->add_clause(pLits, pLits + ctr);
+                            }
+                            svar_ctr++;
+                        }
+                    }
+                }
+            }
+        }
+
+        void create_colex_clauses(const spec& spec, const partial_dag& dag)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                const auto& vertex = dag.get_vertex(i);
+                const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, i);
+                if (nr_pi_fanins == 0) {
+                    continue;
+                } else if (nr_pi_fanins == 1) {
+                    const auto k = spec.nr_in + vertex[1] - 1;
+                    const auto l = spec.nr_in + vertex[2] - 1;
+                    for (int j = 0; j < spec.nr_in; j++) {
+                        const auto sel_var = get_sel_var(spec, dag, i, j);
+                        colex_helper(spec, dag, i, j, k, l, sel_var);
+                    }
+                } else if (nr_pi_fanins == 2) {
+                    auto svar_ctr = 0;
+                    const auto l = spec.nr_in + vertex[2] - 1;
+                    for (int k = 1; k < spec.nr_in; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, dag, i, svar_ctr++);
+                            colex_helper(spec, dag, i, j, k, l, sel_var);
+                        }
+                    }
+                } else {
+                    auto svar_ctr = 0;
+                    for (int l = 2; l < spec.nr_in; l++) {
+                        for (int k = 1; k < l; k++) {
+                            for (int j = 0; j < k; j++) {
+                                const auto sel_var = get_sel_var(spec, dag, i, svar_ctr++);
+                                colex_helper(spec, dag, i, j, k, l, sel_var);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        void fence_create_colex_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                const auto level = get_level(spec, i + spec.nr_in);
+                const auto levelp = get_level(spec, i + 1 + spec.nr_in);
+                int svar_ctr = 0;
+                for (int l = first_step_on_level(level-1); 
+                        l < first_step_on_level(level); l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            if (l < 3) {
+                                svar_ctr++;
+                                continue;
+                            }
+                            const auto sel_var = get_sel_var(spec, i, svar_ctr);
+                            pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                            int svar_ctrp = 0;
+                            for (int lp = first_step_on_level(levelp - 1);
+                                lp < first_step_on_level(levelp); lp++) {
+                                for (int kp = 1; kp < lp; kp++) {
+                                    for (int jp = 0; jp < kp; jp++) {
+                                        if ((lp == l && kp == k && jp <= j) || 
+                                            (lp == l && kp <= k) || (lp <= l)) {
+                                            const auto sel_varp = get_sel_var(spec, i + 1, svar_ctrp);
+                                            pLits[1] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                            (void)solver->add_clause(pLits, pLits + 2);
+                                        }
+                                        svar_ctrp++;
+                                    }
+                                }
+                            }
+                            svar_ctr++;
+                        }
+                    }
+                }
+            }
+        }
+
+        bool create_symvar_clauses(const spec& spec)
+        {
+            for (int q = 1; q < spec.nr_in; q++) {
+                for (int p = 0; p < q; p++) {
+                    auto symm = true;
+                    for (int i = 0; i < spec.nr_nontriv; i++) {
+                        auto f = spec[spec.synth_func(i)];
+                        if (!(swap(f, p, q) == f)) {
+                            symm = false;
+                            break;
+                        }
+                    }
+                    if (!symm) {
+                        continue;
+                    }
+
+                    for (int i = 1; i < spec.nr_steps; i++) {
+                        for (int l = 2; l < spec.nr_in + i; l++) {
+                            for (int k = 1; k < l; k++) {
+                                for (int j = 0; j < k; j++) {
+                                    if (!(j == q || k == q || l == q) || (j == p || k == p)) {
+                                        continue;
+                                    }
+                                    pLits[0] = pabc::Abc_Var2Lit(get_sel_var(spec, i, j, k, l), 1);
+                                    auto ctr = 1;
+                                    for (int ip = 0; ip < i; ip++) {
+                                        for (int lp = 2; lp < spec.nr_in + ip; lp++) {
+                                            for (int kp = 1; kp < lp; kp++) {
+                                                for (int jp = 0; jp < kp; jp++) {
+                                                    if (jp == p || kp == p || lp == p) {
+                                                        pLits[ctr++] = pabc::Abc_Var2Lit(get_sel_var(spec, ip, jp, kp, lp), 0);
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                    if (!solver->add_clause(pLits, pLits + ctr)) {
+                                        return false;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+
+        bool create_symvar_clauses(const spec& spec, const partial_dag& dag)
+        {
+            for (int q = 1; q < spec.nr_in; q++) {
+                for (int p = 0; p < q; p++) {
+                    auto symm = true;
+                    for (int i = 0; i < spec.nr_nontriv; i++) {
+                        auto f = spec[spec.synth_func(i)];
+                        if (!(swap(f, p, q) == f)) {
+                            symm = false;
+                            break;
+                        }
+                    }
+                    if (!symm) {
+                        continue;
+                    }
+
+                    for (int i = 1; i < spec.nr_steps; i++) {
+                        const auto vertex = dag.get_vertex(i);
+                        const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, i);
+
+                        if (nr_pi_fanins == 0) {
+                            continue;
+                        } else if (nr_pi_fanins == 1) {
+                            const auto sel_var = get_sel_var(spec, dag, i, q);
+                            pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                            auto ctr = 1;
+                            for (int ip = 0; ip < i; ip++) {
+                                const auto vertex2 = dag.get_vertex(ip);
+                                auto nr_pi_fanins2 = nr_pi_fanins_for_step(dag, ip);
+                                if (nr_pi_fanins2 == 0) {
+                                    continue;
+                                } else if (nr_pi_fanins2 == 1) {
+                                    const auto sel_varp = get_sel_var(spec, dag, ip, p);
+                                    pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                } else if (nr_pi_fanins2 == 2) {
+                                    auto svar_ctr = 0;
+                                    for (int k = 1; k < spec.nr_in; k++) {
+                                        for (int j = 0; j < k; j++) {
+                                            if (j == p || k == p) {
+                                                const auto sel_varp = get_sel_var(spec, dag, ip, svar_ctr);
+                                                pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                            }
+                                            svar_ctr++;
+                                        }
+                                    }
+                                } else {
+                                    auto svar_ctr = 0;
+                                    for (int l = 2; l < spec.nr_in; l++) {
+                                        for (int k = 1; k < l; k++) {
+                                            for (int j = 0; j < k; j++) {
+                                                if (j == p || k == p || l == p) {
+                                                    const auto sel_varp = get_sel_var(spec, dag, ip, svar_ctr);
+                                                    pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                                }
+                                                svar_ctr++;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            if (!solver->add_clause(pLits, pLits + ctr)) {
+                                return false;
+                            }
+                        } else if (nr_pi_fanins == 2) {
+                            auto svar_ctr = 0;
+                            for (int k = 1; k < spec.nr_in; k++) {
+                                for (int j = 0; j < k; j++) {
+                                    if (!(j == q || k == q) || j == p) {
+                                        svar_ctr++;
+                                        continue;
+                                    }
+                                    const auto sel_var = get_sel_var(spec, dag, i, svar_ctr);
+                                    pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                                    auto ctr = 1;
+                                    for (int ip = 0; ip < i; ip++) {
+                                        const auto vertex2 = dag.get_vertex(ip);
+                                        const auto nr_pi_fanins2 = nr_pi_fanins_for_step(dag, ip);
+                                        if (nr_pi_fanins2 == 0) {
+                                            continue;
+                                        } else if (nr_pi_fanins2 == 1) {
+                                            const auto sel_varp = get_sel_var(spec, dag, ip, p);
+                                            pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                        } else if (nr_pi_fanins2 == 2) {
+                                            auto svar_ctrp = 0;
+                                            for (int kp = 1; kp < spec.nr_in; kp++) {
+                                                for (int jp = 0; jp < kp; jp++) {
+                                                    if (jp == p || kp == p) {
+                                                        const auto sel_varp = get_sel_var(spec, dag, ip, svar_ctrp);
+                                                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                                    }
+                                                    svar_ctrp++;
+                                                }
+                                            }
+                                        } else {
+                                            auto svar_ctrp = 0;
+                                            for (int lp = 2; lp < spec.nr_in; lp++) {
+                                                for (int kp = 1; kp < lp; kp++) {
+                                                    for (int jp = 0; jp < kp; jp++) {
+                                                        if (jp == p || kp == p || lp == p) {
+                                                            const auto sel_varp = get_sel_var(spec, dag, ip, svar_ctrp);
+                                                            pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                                        }
+                                                        svar_ctrp++;
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                    if (!solver->add_clause(pLits, pLits + ctr)) {
+                                        return false;
+                                    }
+                                    svar_ctr++;
+                                }
+                            }
+                        } else {
+                            auto svar_ctr = 0;
+                            for (int l = 2; l < spec.nr_in; l++) {
+                                for (int k = 1; k < l; k++) {
+                                    for (int j = 0; j < k; j++) {
+                                        if (!(j == q || k == q || l == q) || (j == p || k == p)) {
+                                            svar_ctr++;
+                                            continue;
+                                        }
+                                        const auto sel_var = get_sel_var(spec, dag, i, svar_ctr);
+                                        pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                                        auto ctr = 1;
+                                        for (int ip = 0; ip < i; ip++) {
+                                            const auto vertex2 = dag.get_vertex(ip);
+                                            auto nr_pi_fanins2 = nr_pi_fanins_for_step(dag, ip);
+                                            if (nr_pi_fanins2 == 0) {
+                                                continue;
+                                            } else if (nr_pi_fanins2 == 1) {
+                                                const auto sel_varp = get_sel_var(spec, dag, ip, p);
+                                                pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                            } else if (nr_pi_fanins2 == 2) {
+                                                auto svar_ctrp = 0;
+                                                for (int kp = 1; kp < spec.nr_in; kp++) {
+                                                    for (int jp = 0; jp < kp; jp++) {
+                                                        if (jp == p || kp == p) {
+                                                            const auto sel_varp = get_sel_var(spec, dag, ip, svar_ctrp);
+                                                            pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                                        }
+                                                        svar_ctrp++;
+                                                    }
+                                                }
+                                            } else {
+                                                auto svar_ctrp = 0;
+                                                for (int lp = 2; lp < spec.nr_in; lp++) {
+                                                    for (int kp = 1; kp < lp; kp++) {
+                                                        for (int jp = 0; jp < kp; jp++) {
+                                                            if (jp == p || kp == p || lp == p) {
+                                                                const auto sel_varp = get_sel_var(spec, dag, ip, svar_ctrp);
+                                                                pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                                            }
+                                                            svar_ctrp++;
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        if (!solver->add_clause(pLits, pLits + ctr)) {
+                                            return false;
+                                        }
+                                        svar_ctr++;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+
+        void fence_create_symvar_clauses(const spec& spec)
+        {
+            for (int q = 1; q < spec.nr_in; q++) {
+                for (int p = 0; p < q; p++) {
+                    auto symm = true;
+                    for (int i = 0; i < spec.nr_nontriv; i++) {
+                        auto& f = spec[spec.synth_func(i)];
+                        if (!(swap(f, p, q) == f)) {
+                            symm = false;
+                            break;
+                        }
+                    }
+                    if (!symm) {
+                        continue;
+                    }
+                    for (int i = 1; i < spec.nr_steps; i++) {
+                        const auto level = get_level(spec, i + spec.nr_in);
+                        int svar_ctr = 0;
+                        for (int l = first_step_on_level(level - 1);
+                            l < first_step_on_level(level); l++) {
+                            for (int k = 1; k < l; k++) {
+                                for (int j = 0; j < k; j++) {
+                                    if (!(j == q || k == q || l == q) || (j == p || k == p)) {
+                                        svar_ctr++;
+                                        continue;
+                                    }
+                                    const auto sel_var = get_sel_var(spec, i, svar_ctr);
+                                    pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                                    auto ctr = 1;
+                                    for (int ip = 0; ip < i; ip++) {
+                                        const auto levelp = get_level(spec, spec.nr_in + ip);
+                                        auto svar_ctrp = 0;
+                                        for (int lp = first_step_on_level(levelp - 1);
+                                            lp < first_step_on_level(levelp); lp++) {
+                                            for (int kp = 1; kp < lp; kp++) {
+                                                for (int jp = 0; jp < kp; jp++) {
+                                                    if (jp == p || kp == p || lp == p) {
+                                                        const auto sel_varp = get_sel_var(spec, ip, svar_ctrp);
+                                                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                                    }
+                                                    svar_ctrp++;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    (void)solver->add_clause(pLits, pLits + ctr);
+                                    svar_ctr++;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        void create_cardinality_constraints(const spec& spec)
+        {
+            std::vector<int> svars;
+            std::vector<int> rvars;
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                svars.clear();
+                rvars.clear();
+                const auto level = get_level(spec, spec.nr_in + i);
+                auto svar_ctr = 0;
+                for (int l = first_step_on_level(level - 1);
+                    l < first_step_on_level(level); l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, svar_ctr++);
+                            svars.push_back(sel_var);
+                        }
+                    }
+                }
+                const int nr_res_vars = (1 + 2) * (svars.size() + 1);
+                for (int j = 0; j < nr_res_vars; j++) {
+                    rvars.push_back(get_res_var(spec, i, j));
+                }
+                create_cardinality_circuit(solver, svars, rvars, 1);
+
+                // Ensure that the fanin cardinality for each step i 
+                // is exactly FI.
+                const auto fi_var =
+                    get_res_var(spec, i, svars.size() * (1 + 2) + 1);
+                auto fi_lit = pabc::Abc_Var2Lit(fi_var, 0);
+                (void)solver->add_clause(&fi_lit, &fi_lit + 1);
+            }
+        }
+
+        void reset_sim_tts(int nr_in)
+        {
+            for (int i = 0; i < NR_SIM_TTS; i++) {
+                sim_tts[i] = kitty::dynamic_truth_table(nr_in);
+                if (i < nr_in) {
+                    kitty::create_nth_var(sim_tts[i], i);
+                }
+            }
+        }
+
+        bool encode(spec& spec)
+        {
+            assert(spec.nr_in >= 3);
+            spec.add_colex_clauses = false;
+
+            create_variables(spec);
+            create_main_clauses(spec);
+
+            if (!create_fanin_clauses(spec)) {
+                return false;
+            }
+
+            if (spec.add_alonce_clauses) {
+                create_alonce_clauses(spec);
+            }
+
+            /*if (spec.add_colex_clauses) {
+                create_colex_clauses(spec);
+            }*/
+            
+            if (spec.add_noreapply_clauses) {
+                create_noreapply_clauses(spec);
+            }
+            
+            if (spec.add_symvar_clauses && !create_symvar_clauses(spec)) {
+                return false;
+            }
+
+            return true;
+        }
+
+        bool encode(const spec& spec, const partial_dag& dag)
+        {
+            create_variables(spec, dag);
+            create_main_clauses(spec, dag);
+
+            if (!create_fanin_clauses(spec, dag)) {
+                return false;
+            }
+
+            if (spec.add_noreapply_clauses && !create_noreapply_clauses(spec, dag)) {
+                return false;
+            }
+
+            if (spec.add_colex_clauses) {
+                create_colex_clauses(spec, dag);
+            }
+
+            if (spec.add_symvar_clauses && !create_symvar_clauses(spec, dag)) {
+                return false;
+            }
+
+            return true;
+        }
+
+        void update_level_map(const spec& spec, const fence& f)
+        {
+            nr_levels = f.nr_levels();
+            level_dist[0] = spec.nr_in;
+            for (int i = 1; i <= nr_levels; i++) {
+                level_dist[i] = level_dist[i-1] + f.at(i-1);
+            }
+        }
+
+        int get_level(const spec& spec, int step_idx) const
+        {
+            // PIs are considered to be on level zero.
+            if (step_idx < spec.nr_in) {
+                return 0;
+            } else if (step_idx == spec.nr_in) { 
+                // First step is always on level one
+                return 1;
+            }
+            for (int i = 0; i <= nr_levels; i++) {
+                if (level_dist[i] > step_idx) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        bool fence_create_fanin_clauses(const spec& spec)
+        {
+            bool res = true;
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto nr_svars_for_i = nr_svars_for_step(spec, i);
+                for (int j = 0; j < nr_svars_for_i; j++) {
+                    const auto sel_var = get_sel_var(spec, i, j);
+                    pLits[j] = pabc::Abc_Var2Lit(sel_var, 0);
+                }
+
+                res &= solver->add_clause(pLits, pLits + nr_svars_for_i);
+            }
+
+            return res;
+        }
+
+        bool
+        encode(const spec& spec, const fence& f)
+        {
+            assert(spec.nr_in >= 3);
+            assert(spec.nr_steps == f.nr_nodes());
+
+            update_level_map(spec, f);
+            fence_create_variables(spec);
+            if (!fence_create_main_clauses(spec)) {
+                return false;
+            }
+
+            if (!fence_create_fanin_clauses(spec)) {
+                return false;
+            }
+            
+            if (spec.add_alonce_clauses) {
+                fence_create_alonce_clauses(spec);
+            }
+            
+            if (spec.add_colex_clauses) {
+                fence_create_colex_clauses(spec);
+            }
+
+            if (spec.add_noreapply_clauses) {
+                fence_create_noreapply_clauses(spec);
+            }
+
+            if (spec.add_symvar_clauses) {
+                fence_create_symvar_clauses(spec);
+            }
+
+            return true;
+        }
+
+        bool cegar_encode(const spec& spec, const fence& f)
+        {
+            update_level_map(spec, f);
+            cegar_fence_create_variables(spec);
+
+            if (!fence_create_fanin_clauses(spec)) {
+                return false;
+            }
+            create_cardinality_constraints(spec);
+            
+            if (spec.add_alonce_clauses) {
+                fence_create_alonce_clauses(spec);
+            }
+            
+            if (spec.add_colex_clauses) {
+                fence_create_colex_clauses(spec);
+            }
+
+            if (spec.add_noreapply_clauses) {
+                fence_create_noreapply_clauses(spec);
+            }
+
+            if (spec.add_symvar_clauses) {
+                fence_create_symvar_clauses(spec);
+            }
+
+            return true;
+        }
+
+        void extract_mig(const spec& spec, mig& chain)
+        {
+            int op_inputs[3] = { 0, 0, 0 };
+
+            chain.reset(spec.nr_in, 1, spec.nr_steps);
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const int op = 0;
+
+                for (int l = 2; l < spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, j, k, l);
+                            if (solver->var_value(sel_var)) {
+                                op_inputs[0] = j;
+                                op_inputs[1] = k;
+                                op_inputs[2] = l;
+                                break;
+                            }
+                        }
+                    }
+                }
+                chain.set_step(i, op_inputs[0]+1, op_inputs[1]+1, op_inputs[2]+1, op);
+            }
+
+            // TODO: support multiple outputs
+            chain.set_output(0,
+                ((spec.nr_steps + spec.nr_in) << 1) +
+                ((spec.out_inv) & 1));
+        }
+
+        void extract_mig(const spec& spec, const partial_dag& dag, mig& mig)
+        {
+            const int op = 0;
+            int op_inputs[3] = { 0, 0, 0 };
+
+            mig.reset(spec.nr_in, 1, spec.nr_steps);
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto& vertex = dag.get_vertex(i);
+                const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, i);
+
+                if (nr_pi_fanins == 0) {
+                    op_inputs[0] = vertex[0] + spec.nr_in - 1;
+                    op_inputs[1] = vertex[1] + spec.nr_in - 1;
+                    op_inputs[2] = vertex[2] + spec.nr_in - 1;
+                } else if (nr_pi_fanins == 1) {
+                    for (int j = 0; j < spec.nr_in; j++) {
+                        const auto sel_var = get_sel_var(spec, dag, i, j);
+                        if (solver->var_value(sel_var)) {
+                            op_inputs[0] = j;
+                            break;
+                        }
+                    }
+                    op_inputs[1] = vertex[1] + spec.nr_in - 1;
+                    op_inputs[2] = vertex[2] + spec.nr_in - 1;
+                } else if (nr_pi_fanins == 2) {
+                    int ctr = 0;
+                    for (int k = 1; k < spec.nr_in; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, dag, i, ctr++);
+                            if (solver->var_value(sel_var)) {
+                                op_inputs[0] = j;
+                                op_inputs[1] = k;
+                                break;
+                            }
+                        }
+                    }
+                    op_inputs[2] = vertex[2] + spec.nr_in - 1;
+                } else {
+                    for (int l = 2; l < spec.nr_in; l++) {
+                        for (int k = 1; k < l; k++) {
+                            for (int j = 0; j < k; j++) {
+                                const auto sel_var = get_sel_var(spec, i, j, k, l);
+                                if (solver->var_value(sel_var)) {
+                                    op_inputs[0] = j;
+                                    op_inputs[1] = k;
+                                    op_inputs[2] = l;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                mig.set_step(i, op_inputs[0]+1, op_inputs[1]+1, op_inputs[2]+1, op);
+            }
+
+            // TODO: support multiple outputs
+            mig.set_output(0,
+                ((spec.nr_steps + spec.nr_in) << 1) +
+                ((spec.out_inv) & 1));
+        }
+
+        void fence_extract_mig(const spec& spec, mig& chain)
+        {
+            int op_inputs[3] = { 0, 0, 0 };
+
+            chain.reset(spec.nr_in, 1, spec.nr_steps);
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const int op = 0;
+
+                int ctr = 0;
+                const auto level = get_level(spec, spec.nr_in + i);
+                for (int l = first_step_on_level(level - 1); 
+                    l < first_step_on_level(level); l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, ctr++);
+                            if (solver->var_value(sel_var)) {
+                                op_inputs[0] = j;
+                                op_inputs[1] = k;
+                                op_inputs[2] = l;
+                                break;
+                            }
+                        }
+                    }
+                }
+                chain.set_step(i, op_inputs[0]+1, op_inputs[1]+1, op_inputs[2]+1, op);
+            }
+
+            // TODO: support multiple outputs
+            chain.set_output(0,
+                ((spec.nr_steps + spec.nr_in) << 1) +
+                ((spec.out_inv) & 1));
+        }
+
+        void print_solver_state(spec& spec)
+        {
+            for (auto i = 0; i < spec.nr_steps; i++) {
+                for (int l = 2; l < spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, j, k, l);
+                            if (solver->var_value(sel_var)) {
+                                printf("s[%d][%d][%d][%d]=1\n", i, j, k, l);
+                            } else {
+                                printf("s[%d][%d][%d][%d]=0\n", i, j, k, l);
+                            }
+                        }
+                    }
+                }
+            }
+
+            for (auto i = 0; i < spec.nr_steps; i++) {
+                printf("tt_%d_0=0\n", i);
+                for (int t = 0; t < spec.tt_size; t++) {
+                    const auto sim_var = get_sim_var(spec, i, t);
+                    if (solver->var_value(sim_var)) {
+                        printf("tt_%d_%d=1\n", i, t + 1);
+                    } else {
+                        printf("tt_%d_%d=0\n", i, t + 1);
+                    }
+                }
+            }
+        }
+
+        void print_solver_state(spec& spec, const partial_dag& dag)
+        {
+            for (auto i = 0; i < spec.nr_steps; i++) {
+                const auto& vertex = dag.get_vertex(i);
+                const auto nr_pi_fanins = nr_pi_fanins_for_step(dag, i);
+                if (nr_pi_fanins == 0) {
+                    continue;
+                } else if (nr_pi_fanins == 1) {
+                    const auto l = vertex[2] + spec.nr_in - 1;
+                    const auto k = vertex[1] + spec.nr_in - 1;
+                    for (int j = 0; j < spec.nr_in; j++) {
+                        const auto sel_var = get_sel_var(spec, dag, i, j);
+                        if (solver->var_value(sel_var)) {
+                            printf("s[%d][%d][%d][%d]=1\n", i, j, k, l);
+                        } else {
+                            printf("s[%d][%d][%d][%d]=0\n", i, j, k, l);
+                        }
+                    }
+                } else if (nr_pi_fanins == 2) {
+                    int ctr = 0;
+                    const auto l = vertex[2] + spec.nr_in - 1;
+                    for (int k = 1; k < spec.nr_in; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, dag, i, ctr++);
+                            if (solver->var_value(sel_var)) {
+                                printf("s[%d][%d][%d][%d]=1\n", i, j, k, l);
+                            } else {
+                                printf("s[%d][%d][%d][%d]=0\n", i, j, k, l);
+                            }
+                        }
+                    }
+                } else if (nr_pi_fanins == 3) {
+                    int ctr = 0;
+                    for (int l = 2; l < spec.nr_in; l++) {
+                        for (int k = 1; k < l; k++) {
+                            for (int j = 0; j < k; j++) {
+                                const auto sel_var = get_sel_var(spec, dag, i, ctr++);
+                                if (solver->var_value(sel_var)) {
+                                    printf("s[%d][%d][%d][%d]=1\n", i, j, k, l);
+                                } else {
+                                    printf("s[%d][%d][%d][%d]=0\n", i, j, k, l);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                for (auto i = 0; i < spec.nr_steps; i++) {
+                    printf("tt_%d_0=0\n", i);
+                    for (int t = 0; t < spec.tt_size; t++) {
+                        const auto sim_var = get_sim_var(spec, i, t);
+                        if (solver->var_value(sim_var)) {
+                            printf("tt_%d_%d=1\n", i, t + 1);
+                        } else {
+                            printf("tt_%d_%d=0\n", i, t + 1);
+                        }
+                    }
+                }
+            }
+        }
+
+        void fence_print_solver_state(spec& spec)
+        {
+            for (auto i = 0; i < spec.nr_steps; i++) {
+                const auto level = get_level(spec, i);
+                for (int l = first_step_on_level(level - 1);
+                    l < first_step_on_level(level); l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, j, k, l);
+                            if (solver->var_value(sel_var)) {
+                                printf("s[%d][%d][%d][%d]=1\n", i, j, k, l);
+                            } else {
+                                printf("s[%d][%d][%d][%d]=0\n", i, j, k, l);
+                            }
+                        }
+                    }
+                }
+            }
+
+            for (auto i = 0; i < spec.nr_steps; i++) {
+                printf("tt_%d_0=0\n", i);
+                for (int t = 0; t < spec.tt_size; t++) {
+                    const auto sim_var = get_sim_var(spec, i, t);
+                    if (solver->var_value(sim_var)) {
+                        printf("tt_%d_%d=1\n", i, t + 1);
+                    } else {
+                        printf("tt_%d_%d=0\n", i, t + 1);
+                    }
+                }
+            }
+        }
+        
+        bool cegar_encode(const spec& spec)
+        {
+            create_variables(spec);
+
+            if (!create_fanin_clauses(spec)) {
+                return false;
+            }
+
+            if (spec.add_alonce_clauses) {
+                create_alonce_clauses(spec);
+            }
+
+            if (spec.add_colex_clauses) {
+                create_colex_clauses(spec);
+            }
+            
+            if (spec.add_noreapply_clauses) {
+                create_noreapply_clauses(spec);
+            }
+            
+            if (spec.add_symvar_clauses && !create_symvar_clauses(spec)) {
+                return false;
+            }
+
+            return true;
+        }
+        
+        bool block_solution(const spec& spec)
+        {
+            int ctr = 0;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                for (int l = 2; l < spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, j, k, l);
+                            if (solver->var_value(sel_var)) {
+                                pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            assert(ctr == spec.nr_steps);
+            return solver->add_clause(pLits, pLits + ctr);
+        }
+        
+        bool block_struct_solution(const spec& spec)
+        {
+            return block_solution(spec);
+        }
+
+        bool is_dirty() 
+        {
+            return dirty;
+        }
+
+        void set_dirty(bool _dirty)
+        {
+            dirty = _dirty;
+        }
+
+        bool find_fanin(const spec& spec, int i, int* fanins)
+        {
+            for (int l = 2; l < spec.nr_in + i; l++) {
+                for (int k = 1; k < l; k++) {
+                    for (int j = 0; j < k; j++) {
+                        const auto sel_var = get_sel_var(spec, i, j, k, l);
+                        if (solver->var_value(sel_var)) {
+                            fanins[0] = j;
+                            fanins[1] = k;
+                            fanins[2] = l;
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+
+        bool fence_find_fanin(const spec& spec, int i, int* fanins)
+        {
+            int ctr = 0;
+            const auto level = get_level(spec, spec.nr_in + i);
+            for (int l = first_step_on_level(level - 1); 
+                    l < first_step_on_level(level); l++) {
+                for (int k = 1; k < l; k++) {
+                    for (int j = 0; j < k; j++) {
+                        const auto sel_var = get_sel_var(spec, i, ctr++);
+                        if (solver->var_value(sel_var)) {
+                            fanins[0] = j;
+                            fanins[1] = k;
+                            fanins[2] = l;
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+
+        /// Simulates the current state of the encoder and returns an index
+        /// of a minterm which is different from the specified function.
+        /// Returns -1 if no such index exists.
+        int simulate(const spec& spec)
+        {
+            int fanins[3];
+            kitty::dynamic_truth_table* pFanins[3];
+
+            for (int i = spec.nr_in; i < spec.nr_in + spec.nr_steps; i++) {
+                const auto found = find_fanin(spec, i - spec.nr_in, fanins);
+                assert(found);
+                for (int k = 0; k < 3; k++)
+                    pFanins[k] = &sim_tts[fanins[k]];
+                sim_tts[i] = kitty::ternary_majority(*pFanins[0], *pFanins[1], *pFanins[2]);
+            }
+
+            int iMint = -1;
+            kitty::static_truth_table<6> tt;
+            for (int i = 1; i < (1 << spec.nr_in); i++) {
+                kitty::create_from_words(tt, &i, &i + 1);
+                const int nOnes = kitty::count_ones(tt);
+                if (nOnes < spec.nr_in / 2 || nOnes > ((spec.nr_in/2) + 1)) {
+                    continue;
+                }
+                if (kitty::get_bit(sim_tts[spec.nr_in + spec.nr_steps - 1], i)
+                    == kitty::get_bit(spec[0], i)) {
+                    continue;
+                }
+                iMint = i;
+                break;
+            }
+
+            assert(iMint < (1 << spec.nr_in));
+            return iMint;
+        }
+
+        int fence_simulate(const spec& spec)
+        {
+            int fanins[3];
+            kitty::dynamic_truth_table* pFanins[3];
+
+            for (int i = spec.nr_in; i < spec.nr_in + spec.nr_steps; i++) {
+                const auto found = fence_find_fanin(spec, i - spec.nr_in, fanins);
+                assert(found);
+                for (int k = 0; k < 3; k++)
+                    pFanins[k] = &sim_tts[fanins[k]];
+                sim_tts[i] = kitty::ternary_majority(*pFanins[0], *pFanins[1], *pFanins[2]);
+            }
+
+            int iMint = -1;
+            kitty::static_truth_table<6> tt;
+            for (int i = 1; i < (1 << spec.nr_in); i++) {
+                kitty::create_from_words(tt, &i, &i + 1);
+                const int nOnes = kitty::count_ones(tt);
+                if (nOnes < spec.nr_in / 2 || nOnes > ((spec.nr_in/2) + 1)) {
+                    continue;
+                }
+                if (kitty::get_bit(sim_tts[spec.nr_in + spec.nr_steps - 1], i)
+                    == kitty::get_bit(spec[0], i)) {
+                    continue;
+                }
+                iMint = i;
+                break;
+            }
+
+            assert(iMint < (1 << spec.nr_in));
+            return iMint;
+        }
+        
+    };
+}
diff --git a/lib/percy/percy/encoders/mig_encoder.hpp b/lib/percy/percy/encoders/mig_encoder.hpp
new file mode 100644
index 0000000..138ee7c
--- /dev/null
+++ b/lib/percy/percy/encoders/mig_encoder.hpp
@@ -0,0 +1,1530 @@
+#pragma once
+
+#include <vector>
+#include <kitty/kitty.hpp>
+#include "encoder.hpp"
+#include "../partial_dag.hpp"
+
+namespace percy
+{
+    class mig_encoder
+    {
+    private:
+        int level_dist[32]; // How many steps are below a certain level
+        int nr_levels; // The number of levels in the Boolean fence
+        int nr_sel_vars;
+        int nr_op_vars;
+        int nr_sim_vars;
+        int total_nr_vars;
+        int sel_offset;
+        int ops_offset;
+        int sim_offset;
+        bool dirty = false;
+        pabc::lit pLits[2048];
+        //pabc::Vec_Int_t* vLits = NULL;
+        solver_wrapper* solver;
+
+        int svars[16][16][16][16];
+
+        // There are 4 possible operators for each MIG node:
+        // <abc>        (0)
+        // <!abc>       (1)
+        // <a!bc>       (2)
+        // <ab!c>       (3)
+        // All other input patterns can be obained from these
+        // by output inversion. Therefore we consider
+        // them symmetries and do not encode them.
+        const int MIG_OP_VARS_PER_STEP = 4;
+
+        const int NR_SIM_TTS = 32;
+        std::vector<kitty::dynamic_truth_table> sim_tts {32};
+
+        int get_sim_var(const spec& spec, int step_idx, int t) const
+        {
+            return sim_offset + spec.tt_size * step_idx + t;
+        }
+
+        int get_op_var(const spec& spec, int step_idx, int var_idx) const
+        {
+            return ops_offset + step_idx * MIG_OP_VARS_PER_STEP + var_idx;
+        }
+
+        bool fix_output_sim_vars(const spec& spec, int t)
+        {
+            const auto ilast_step = spec.nr_steps - 1;
+            auto outbit = kitty::get_bit(
+                spec[spec.synth_func(0)], t + 1);
+            if ((spec.out_inv >> spec.synth_func(0)) & 1) {
+                outbit = 1 - outbit;
+            }
+            const auto sim_var = get_sim_var(spec, ilast_step, t);
+            pabc::lit sim_lit = pabc::Abc_Var2Lit(sim_var, 1 - outbit);
+            return solver->add_clause(&sim_lit, &sim_lit + 1);
+        }
+
+        void vfix_output_sim_vars(const spec& spec, int t)
+        {
+            const auto ilast_step = spec.nr_steps - 1;
+
+            auto outbit = kitty::get_bit(
+                spec[spec.synth_func(0)], t + 1);
+            if ((spec.out_inv >> spec.synth_func(0)) & 1) {
+                outbit = 1 - outbit;
+            }
+            const auto sim_var = get_sim_var(spec, ilast_step, t);
+            pabc::lit sim_lit = pabc::Abc_Var2Lit(sim_var, 1 - outbit);
+            const auto ret = solver->add_clause(&sim_lit, &sim_lit + 1);
+            assert(ret);
+            if (spec.verbosity) {
+                printf("forcing bit %d=%d\n", t + 1, int(outbit));
+            }
+        }
+
+        int get_sel_var(const spec& spec, int idx, int var_idx) const
+        {
+            assert(idx < spec.nr_steps);
+            const auto nr_svars_for_idx = nr_svars_for_step(spec, idx);
+            assert(var_idx < nr_svars_for_idx);
+            auto offset = 0;
+            for (int i = 0; i < idx; i++) {
+                offset += nr_svars_for_step(spec, i);
+            }
+            return sel_offset + offset + var_idx;
+        }
+
+    public:
+        mig_encoder(solver_wrapper& solver)
+        {
+            this->solver = &solver;
+        }
+
+        ~mig_encoder()
+        {
+        }
+
+        void create_variables(const spec& spec)
+        {
+            nr_op_vars = spec.nr_steps * MIG_OP_VARS_PER_STEP;
+            nr_sim_vars = spec.nr_steps * spec.tt_size;
+
+            nr_sel_vars = 0;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                for (int l = 2; l <= spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            svars[i][j][k][l] = nr_sel_vars++;
+                        }
+                    }
+                }
+            }
+
+            sel_offset = 0;
+            ops_offset = nr_sel_vars;
+            sim_offset = nr_sel_vars + nr_op_vars;
+            total_nr_vars = nr_sel_vars + nr_op_vars + nr_sim_vars;
+
+            if (spec.verbosity) {
+                printf("Creating variables (MIG)\n");
+                printf("nr steps = %d\n", spec.nr_steps);
+                printf("nr_sel_vars=%d\n", nr_sel_vars);
+                printf("nr_op_vars = %d\n", nr_op_vars);
+                printf("nr_sim_vars = %d\n", nr_sim_vars);
+                printf("creating %d total variables\n", total_nr_vars);
+            }
+
+            solver->set_nr_vars(total_nr_vars);
+        }
+
+        int first_step_on_level(int level) const
+        {
+            if (level == 0) { return 0; }
+            return level_dist[level-1];
+        }
+
+        int nr_svars_for_step(const spec& spec, int i) const
+        {
+            // Determine the level of this step.
+            const auto level = get_level(spec, i + spec.nr_in + 1);
+            auto nr_svars_for_i = 0;
+            assert(level > 0);
+            for (auto l = first_step_on_level(level - 1);
+                l < first_step_on_level(level); l++) {
+                // We select l as fanin 3, so have (l choose 2) options 
+                // (j,k in {0,...,(l-1)}) left for fanin 1 and 2.
+                nr_svars_for_i += (l * (l - 1)) / 2;
+            }
+
+            return nr_svars_for_i;
+        }
+
+        void fence_create_variables(const spec& spec)
+        {
+            nr_op_vars = spec.nr_steps * MIG_OP_VARS_PER_STEP;
+            nr_sim_vars = spec.nr_steps * spec.tt_size;
+
+            nr_sel_vars = 0;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                nr_sel_vars += nr_svars_for_step(spec, i);
+            }
+
+            sel_offset = 0;
+            ops_offset = nr_sel_vars;
+            sim_offset = nr_sel_vars + nr_op_vars;
+            total_nr_vars = nr_sel_vars + nr_op_vars + nr_sim_vars;
+
+            if (spec.verbosity) {
+                printf("Creating variables (MIG)\n");
+                printf("nr steps = %d\n", spec.nr_steps);
+                printf("nr_sel_vars=%d\n", nr_sel_vars);
+                printf("nr_op_vars = %d\n", nr_op_vars);
+                printf("nr_sim_vars = %d\n", nr_sim_vars);
+                printf("creating %d total variables\n", total_nr_vars);
+            }
+
+            solver->set_nr_vars(total_nr_vars);
+        }
+
+        
+
+        /// Ensures that each gate has the proper number of fanins.
+        bool create_fanin_clauses(const spec& spec)
+        {
+            auto status = true;
+
+            if (spec.verbosity > 2) {
+                printf("Creating fanin clauses (MIG)\n");
+                printf("Nr. clauses = %d (PRE)\n", solver->nr_clauses());
+            }
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                auto ctr = 0;
+                for (int l = 2; l <= spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            pLits[ctr++] = pabc::Abc_Var2Lit(svars[i][j][k][l], 0);
+                        }
+                    }
+                }
+                status &= solver->add_clause(pLits, pLits + ctr);
+            }
+
+            // We need to select one of the possible operators for this step.
+            /*
+            for (int i = 0; i < spec.nr_steps; i++) {
+                pLits[0] = pabc::Abc_Var2Lit(get_op_var(spec, i, 0), 0);
+                pLits[1] = pabc::Abc_Var2Lit(get_op_var(spec, i, 1), 0);
+                pLits[2] = pabc::Abc_Var2Lit(get_op_var(spec, i, 2), 0);
+                pLits[3] = pabc::Abc_Var2Lit(get_op_var(spec, i, 3), 0);
+                status &= solver->add_clause(pLits, pLits + 4);
+            }
+            */
+            
+            if (spec.verbosity > 2) {
+                printf("Nr. clauses = %d (POST)\n", solver->nr_clauses());
+            }
+
+            return status;
+        }
+
+        
+
+        int maj3(int a, int ca, int b, int cb, int c, int cc) const
+        {
+            a = ca ? ~a : a;
+            a = a & 1;
+            b = cb ? ~b : b;
+            b = b & 1;
+            c = cc ? ~c : c;
+            c = c & 1;
+            return (a & b) | (a & c) | (b & c);
+        }
+
+        bool add_simulation_clause(
+            const spec& spec,
+            const int t,
+            const int i,
+            const int j,
+            const int k,
+            const int l,
+            const int a,
+            const int b,
+            const int c,
+            const int d
+            )
+        {
+            int ctr = 0;
+
+            if (j == 0) {
+                // Constant zero input
+                if (k <= spec.nr_in) {
+                    if ((((t + 1) & (1 << (k - 1))) ? 1 : 0) != c) {
+                        return true;
+                    }
+                } else {
+                    pLits[ctr++] = pabc::Abc_Var2Lit(
+                        get_sim_var(spec, k - spec.nr_in - 1, t), c);
+                }
+
+                if (l <= spec.nr_in) {
+                    if ((((t + 1) & (1 << (l - 1))) ? 1 : 0) != d) {
+                        return true;
+                    }
+                } else {
+                    pLits[ctr++] = pabc::Abc_Var2Lit(
+                        get_sim_var(spec, l - spec.nr_in - 1, t), d);
+                }
+
+                pLits[ctr++] = pabc::Abc_Var2Lit(svars[i][j][k][l], 1);
+                pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), a);
+
+                if (c | d) {
+                    if (maj3(0, 0, c, 0, d, 0) == a) {
+                        pLits[ctr++] =
+                            pabc::Abc_Var2Lit(get_op_var(spec, i, 0), 0);
+                    }
+                    if (maj3(0, 1, c, 0, d, 0) == a) {
+                        pLits[ctr++] =
+                            pabc::Abc_Var2Lit(get_op_var(spec, i, 1), 0);
+                    }
+                    if (maj3(0, 0, c, 1, d, 0) == a) {
+                        pLits[ctr++] =
+                            pabc::Abc_Var2Lit(get_op_var(spec, i, 2), 0);
+                    }
+                    if (maj3(0, 0, c, 0, d, 1) == a) {
+                        pLits[ctr++] =
+                            pabc::Abc_Var2Lit(get_op_var(spec, i, 3), 0);
+                    }
+                }
+
+                solver->add_clause(pLits, pLits + ctr);
+                const auto ret = solver->add_clause(pLits, pLits + ctr);
+                assert(ret);
+                return ret;
+            } 
+            
+            if (j <= spec.nr_in) {
+                if ((((t + 1) & (1 << (j - 1))) ? 1 : 0) != b) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, j - spec.nr_in - 1, t), b);
+            }
+
+            if (k <= spec.nr_in) {
+                if ((((t + 1) & (1 << (k - 1))) ? 1 : 0) != c) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, k - spec.nr_in - 1, t), c);
+            }
+
+            if (l <= spec.nr_in) {
+                if ((((t + 1) & (1 << (l - 1))) ? 1 : 0) != d) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, l - spec.nr_in - 1, t), d);
+            }
+
+            pLits[ctr++] = pabc::Abc_Var2Lit(svars[i][j][k][l], 1);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), a);
+
+            if (b | c | d) {
+                if (maj3(b, 0, c, 0, d, 0) == a) {
+                    pLits[ctr++] = 
+                        pabc::Abc_Var2Lit(get_op_var(spec, i, 0), 0);
+                }
+                if (maj3(b, 1, c, 0, d, 0) == a) {
+                    pLits[ctr++] = 
+                        pabc::Abc_Var2Lit(get_op_var(spec, i, 1), 0);
+                }
+                if (maj3(b, 0, c, 1, d, 0) == a) {
+                    pLits[ctr++] = 
+                        pabc::Abc_Var2Lit(get_op_var(spec, i, 2), 0);
+                }
+                if (maj3(b, 0, c, 0, d, 1) == a) {
+                    pLits[ctr++] = 
+                        pabc::Abc_Var2Lit(get_op_var(spec, i, 3), 0);
+                }
+            }
+
+            const auto ret = solver->add_clause(pLits, pLits + ctr);
+            assert(ret);
+            return ret;
+        }
+
+        bool add_consistency_clause(
+            const spec& spec,
+            const int t,
+            const int i,
+            const int j,
+            const int k,
+            const int l,
+            const int d,
+            const int c,
+            const int b,
+            const int true_opvar1,
+            const int true_opvar2,
+            const int false_opvar1,
+            const int false_opvar2
+            )
+        {
+            int ctr = 0;
+            assert(j >= 1);
+
+             
+            if (j <= spec.nr_in) {
+                if ((((t + 1) & (1 << (j - 1))) ? 1 : 0) != b) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, j - spec.nr_in - 1, t), b);
+            }
+
+            if (k <= spec.nr_in) {
+                if ((((t + 1) & (1 << (k - 1))) ? 1 : 0) != c) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, k - spec.nr_in - 1, t), c);
+            }
+
+            if (l <= spec.nr_in) {
+                if ((((t + 1) & (1 << (l - 1))) ? 1 : 0) != d) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, l - spec.nr_in - 1, t), d);
+            }
+
+            pLits[ctr++] = pabc::Abc_Var2Lit(svars[i][j][k][l], 1);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 1);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_op_var(spec, i, true_opvar1), 0);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_op_var(spec, i, true_opvar2), 0);
+            auto ret = solver->add_clause(pLits, pLits + ctr);
+
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, false_opvar1), 1);
+            ret &= solver->add_clause(pLits, pLits + ctr - 1);
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, false_opvar2), 1);
+            ret &= solver->add_clause(pLits, pLits + ctr - 1);
+            
+            pLits[ctr - 3] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 0);
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, false_opvar1), 0);
+            pLits[ctr - 1] = pabc::Abc_Var2Lit(get_op_var(spec, i, false_opvar2), 0);
+            ret &= solver->add_clause(pLits, pLits + ctr);
+            
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, true_opvar1), 1);
+            ret &= solver->add_clause(pLits, pLits + ctr - 1);
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, true_opvar2), 1);
+            ret &= solver->add_clause(pLits, pLits + ctr - 1);
+
+            assert(ret);
+
+
+            
+            return ret;
+        }
+
+        bool fence_add_consistency_clause(
+            const spec& spec,
+            const int t,
+            const int i,
+            const int j,
+            const int k,
+            const int l,
+            const int d,
+            const int c,
+            const int b,
+            const int true_opvar1,
+            const int true_opvar2,
+            const int false_opvar1,
+            const int false_opvar2,
+            const int sel_var)
+        {
+            int ctr = 0;
+            assert(j >= 1);
+
+             
+            if (j <= spec.nr_in) {
+                if ((((t + 1) & (1 << (j - 1))) ? 1 : 0) != b) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, j - spec.nr_in - 1, t), b);
+            }
+
+            if (k <= spec.nr_in) {
+                if ((((t + 1) & (1 << (k - 1))) ? 1 : 0) != c) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, k - spec.nr_in - 1, t), c);
+            }
+
+            if (l <= spec.nr_in) {
+                if ((((t + 1) & (1 << (l - 1))) ? 1 : 0) != d) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, l - spec.nr_in - 1, t), d);
+            }
+
+            pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 1);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_op_var(spec, i, true_opvar1), 0);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_op_var(spec, i, true_opvar2), 0);
+            auto ret = solver->add_clause(pLits, pLits + ctr);
+
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, false_opvar1), 1);
+            ret &= solver->add_clause(pLits, pLits + ctr - 1);
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, false_opvar2), 1);
+            ret &= solver->add_clause(pLits, pLits + ctr - 1);
+            
+            pLits[ctr - 3] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 0);
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, false_opvar1), 0);
+            pLits[ctr - 1] = pabc::Abc_Var2Lit(get_op_var(spec, i, false_opvar2), 0);
+            ret &= solver->add_clause(pLits, pLits + ctr);
+            
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, true_opvar1), 1);
+            ret &= solver->add_clause(pLits, pLits + ctr - 1);
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, true_opvar2), 1);
+            ret &= solver->add_clause(pLits, pLits + ctr - 1);
+
+            assert(ret);
+
+
+            
+            return ret;
+        }
+
+
+        bool add_impossibility_clause(
+            const spec& spec,
+            const int t,
+            const int i,
+            const int j,
+            const int k,
+            const int l,
+            const int d,
+            const int c,
+            const int b,
+            const int a)
+        {
+            int ctr = 0;
+            assert(j >= 1);
+
+             
+            if (j <= spec.nr_in) {
+                if ((((t + 1) & (1 << (j - 1))) ? 1 : 0) != b) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, j - spec.nr_in - 1, t), b);
+            }
+
+            if (k <= spec.nr_in) {
+                if ((((t + 1) & (1 << (k - 1))) ? 1 : 0) != c) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, k - spec.nr_in - 1, t), c);
+            }
+
+            if (l <= spec.nr_in) {
+                if ((((t + 1) & (1 << (l - 1))) ? 1 : 0) != d) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, l - spec.nr_in - 1, t), d);
+            }
+
+            pLits[ctr++] = pabc::Abc_Var2Lit(svars[i][j][k][l], 1);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), a);
+            auto ret = solver->add_clause(pLits, pLits + ctr);
+
+            assert(ret);
+            
+            return ret;
+        }
+
+        bool fence_add_impossibility_clause(
+            const spec& spec,
+            const int t,
+            const int i,
+            const int j,
+            const int k,
+            const int l,
+            const int d,
+            const int c,
+            const int b,
+            const int a,
+            const int sel_var)
+        {
+            int ctr = 0;
+            assert(j >= 1);
+
+             
+            if (j <= spec.nr_in) {
+                if ((((t + 1) & (1 << (j - 1))) ? 1 : 0) != b) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, j - spec.nr_in - 1, t), b);
+            }
+
+            if (k <= spec.nr_in) {
+                if ((((t + 1) & (1 << (k - 1))) ? 1 : 0) != c) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, k - spec.nr_in - 1, t), c);
+            }
+
+            if (l <= spec.nr_in) {
+                if ((((t + 1) & (1 << (l - 1))) ? 1 : 0) != d) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, l - spec.nr_in - 1, t), d);
+            }
+
+            pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), a);
+            auto ret = solver->add_clause(pLits, pLits + ctr);
+
+            assert(ret);
+            
+            return ret;
+        }
+
+        bool add_const_consistency_clause(
+            const spec& spec,
+            const int t,
+            const int i,
+            const int k,
+            const int l,
+            const int d,
+            const int c,
+            const int true_opvar1,
+            const int true_opvar2,
+            const int false_opvar1,
+            const int false_opvar2
+            )
+        {
+            int ctr = 0;
+             
+            if (k <= spec.nr_in) {
+                if ((((t + 1) & (1 << (k - 1))) ? 1 : 0) != c) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, k - spec.nr_in - 1, t), c);
+            }
+
+            if (l <= spec.nr_in) {
+                if ((((t + 1) & (1 << (l - 1))) ? 1 : 0) != d) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, l - spec.nr_in - 1, t), d);
+            }
+
+            pLits[ctr++] = pabc::Abc_Var2Lit(svars[i][0][k][l], 1);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 1);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_op_var(spec, i, true_opvar1), 0);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_op_var(spec, i, true_opvar2), 0);
+            auto ret = solver->add_clause(pLits, pLits + ctr);
+
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, false_opvar1), 1);
+            ret &= solver->add_clause(pLits, pLits + ctr - 1);
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, false_opvar2), 1);
+            ret &= solver->add_clause(pLits, pLits + ctr - 1);
+            
+            pLits[ctr - 3] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 0);
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, false_opvar1), 0);
+            pLits[ctr - 1] = pabc::Abc_Var2Lit(get_op_var(spec, i, false_opvar2), 0);
+            ret &= solver->add_clause(pLits, pLits + ctr);
+            
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, true_opvar1), 1);
+            ret &= solver->add_clause(pLits, pLits + ctr - 1);
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, true_opvar2), 1);
+            ret &= solver->add_clause(pLits, pLits + ctr - 1);
+
+            assert(ret);
+
+            return ret;
+        }
+
+        bool fence_add_const_consistency_clause(
+            const spec& spec,
+            const int t,
+            const int i,
+            const int k,
+            const int l,
+            const int d,
+            const int c,
+            const int true_opvar1,
+            const int true_opvar2,
+            const int false_opvar1,
+            const int false_opvar2,
+            int sel_var)
+        {
+            int ctr = 0;
+             
+            if (k <= spec.nr_in) {
+                if ((((t + 1) & (1 << (k - 1))) ? 1 : 0) != c) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, k - spec.nr_in - 1, t), c);
+            }
+
+            if (l <= spec.nr_in) {
+                if ((((t + 1) & (1 << (l - 1))) ? 1 : 0) != d) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, l - spec.nr_in - 1, t), d);
+            }
+
+            pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 1);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_op_var(spec, i, true_opvar1), 0);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_op_var(spec, i, true_opvar2), 0);
+            auto ret = solver->add_clause(pLits, pLits + ctr);
+
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, false_opvar1), 1);
+            ret &= solver->add_clause(pLits, pLits + ctr - 1);
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, false_opvar2), 1);
+            ret &= solver->add_clause(pLits, pLits + ctr - 1);
+            
+            pLits[ctr - 3] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 0);
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, false_opvar1), 0);
+            pLits[ctr - 1] = pabc::Abc_Var2Lit(get_op_var(spec, i, false_opvar2), 0);
+            ret &= solver->add_clause(pLits, pLits + ctr);
+            
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, true_opvar1), 1);
+            ret &= solver->add_clause(pLits, pLits + ctr - 1);
+            pLits[ctr - 2] = pabc::Abc_Var2Lit(get_op_var(spec, i, true_opvar2), 1);
+            ret &= solver->add_clause(pLits, pLits + ctr - 1);
+
+            assert(ret);
+
+            return ret;
+        }
+
+        bool add_const_impossibility_clause(
+            const spec& spec,
+            const int t,
+            const int i,
+            const int k,
+            const int l,
+            const int d,
+            const int c)
+        {
+            int ctr = 0;
+             
+            if (k <= spec.nr_in) {
+                if ((((t + 1) & (1 << (k - 1))) ? 1 : 0) != c) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, k - spec.nr_in - 1, t), c);
+            }
+
+            if (l <= spec.nr_in) {
+                if ((((t + 1) & (1 << (l - 1))) ? 1 : 0) != d) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, l - spec.nr_in - 1, t), d);
+            }
+
+            pLits[ctr++] = pabc::Abc_Var2Lit(svars[i][0][k][l], 1);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 1);
+            auto ret = solver->add_clause(pLits, pLits + ctr);
+
+            assert(ret);
+
+            return ret;
+        }
+
+        bool fence_add_const_impossibility_clause(
+            const spec& spec,
+            const int t,
+            const int i,
+            const int k,
+            const int l,
+            const int d,
+            const int c,
+            const int sel_var)
+        {
+            int ctr = 0;
+             
+            if (k <= spec.nr_in) {
+                if ((((t + 1) & (1 << (k - 1))) ? 1 : 0) != c) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, k - spec.nr_in - 1, t), c);
+            }
+
+            if (l <= spec.nr_in) {
+                if ((((t + 1) & (1 << (l - 1))) ? 1 : 0) != d) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, l - spec.nr_in - 1, t), d);
+            }
+
+            pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 1);
+            auto ret = solver->add_clause(pLits, pLits + ctr);
+
+            assert(ret);
+
+            return ret;
+        }
+
+        bool create_tt_clauses(const spec& spec, const int t)
+        {
+            bool ret = true;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                for (int l = 2; l <= spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 1; j < k; j++) {
+                            ret &= add_consistency_clause(spec, t, i, j, k, l, 0, 0, 1, 2, 3, 0, 1);
+                            ret &= add_consistency_clause(spec, t, i, j, k, l, 0, 1, 0, 1, 3, 0, 2);
+                            ret &= add_consistency_clause(spec, t, i, j, k, l, 0, 1, 1, 0, 3, 1, 2);
+                            ret &= add_consistency_clause(spec, t, i, j, k, l, 1, 0, 0, 1, 2, 0, 3);
+                            ret &= add_consistency_clause(spec, t, i, j, k, l, 1, 0, 1, 0, 2, 1, 3);
+                            ret &= add_consistency_clause(spec, t, i, j, k, l, 1, 1, 0, 0, 1, 2, 3);
+                            ret &= add_impossibility_clause(spec, t, i, j, k, l, 0, 0, 0, 1);
+                            ret &= add_impossibility_clause(spec, t, i, j, k, l, 1, 1, 1, 0);
+                        }
+                        ret &= add_const_impossibility_clause(spec, t, i, k, l, 0, 0);
+                        ret &= add_const_consistency_clause(spec, t, i, k, l, 0, 1, 1, 3, 0, 2);
+                        ret &= add_const_consistency_clause(spec, t, i, k, l, 1, 0, 1, 2, 0, 3);
+                        ret &= add_const_consistency_clause(spec, t, i, k, l, 1, 1, 0, 1, 2, 3);
+                    }
+                }
+                assert(ret);
+            }
+
+            ret &= fix_output_sim_vars(spec, t);
+
+            return ret;
+        }
+
+        bool fence_create_tt_clauses(const spec& spec, const int t)
+        {
+            bool ret = true;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto level = get_level(spec, i + spec.nr_in + 1);
+                int ctr = 0;
+                for (int l = first_step_on_level(level - 1);
+                    l < first_step_on_level(level); l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, ctr++);
+                            if (j == 0) {
+                                ret &= fence_add_const_impossibility_clause(spec, t, i, k, l, 0, 0, sel_var);
+                                ret &= fence_add_const_consistency_clause(spec, t, i, k, l, 0, 1, 1, 3, 0, 2, sel_var);
+                                ret &= fence_add_const_consistency_clause(spec, t, i, k, l, 1, 0, 1, 2, 0, 3, sel_var);
+                                ret &= fence_add_const_consistency_clause(spec, t, i, k, l, 1, 1, 0, 1, 2, 3, sel_var);
+                            } else {
+                                ret &= fence_add_consistency_clause(spec, t, i, j, k, l, 0, 0, 1, 2, 3, 0, 1, sel_var);
+                                ret &= fence_add_consistency_clause(spec, t, i, j, k, l, 0, 1, 0, 1, 3, 0, 2, sel_var);
+                                ret &= fence_add_consistency_clause(spec, t, i, j, k, l, 0, 1, 1, 0, 3, 1, 2, sel_var);
+                                ret &= fence_add_consistency_clause(spec, t, i, j, k, l, 1, 0, 0, 1, 2, 0, 3, sel_var);
+                                ret &= fence_add_consistency_clause(spec, t, i, j, k, l, 1, 0, 1, 0, 2, 1, 3, sel_var);
+                                ret &= fence_add_consistency_clause(spec, t, i, j, k, l, 1, 1, 0, 0, 1, 2, 3, sel_var);
+                                ret &= fence_add_impossibility_clause(spec, t, i, j, k, l, 0, 0, 0, 1, sel_var);
+                                ret &= fence_add_impossibility_clause(spec, t, i, j, k, l, 1, 1, 1, 0, sel_var);
+                            }
+                        }
+                    }
+                }
+                assert(ret);
+            }
+
+            ret &= fix_output_sim_vars(spec, t);
+
+            return ret;
+        }
+
+        void create_main_clauses(const spec& spec)
+        {
+            for (int t = 0; t < spec.tt_size; t++) {
+                (void)create_tt_clauses(spec, t);
+            }
+        }
+
+        bool fence_create_main_clauses(const spec& spec)
+        {
+            bool ret = true;
+            for (int t = 0; t < spec.tt_size; t++) {
+                ret &= fence_create_tt_clauses(spec, t);
+            }
+            return ret;
+        }
+
+        void create_alonce_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                int ctr = 0;
+                for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                    for (int l = spec.nr_in + i; l <= spec.nr_in + ip; l++) {
+                        for (int k = 1; k < l; k++) {
+                            for (int j = 0; j < k; j++) {
+                                pLits[ctr++] = pabc::Abc_Var2Lit(svars[ip][j][k][l], 0);
+                            }
+                        }
+                    }
+                }
+                const auto res = solver->add_clause(pLits, pLits + ctr);
+                assert(res);
+            }
+        }
+
+        void fence_create_alonce_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                auto ctr = 0;
+                const auto idx = spec.nr_in + i + 1;
+                const auto level = get_level(spec, idx);
+                for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                    auto levelp = get_level(spec, ip + spec.nr_in + 1);
+                    assert(levelp >= level);
+                    if (levelp == level) {
+                        continue;
+                    }
+                    auto svctr = 0;
+                    for (int l = first_step_on_level(levelp - 1);
+                        l < first_step_on_level(levelp); l++) {
+                        for (int k = 1; k < l; k++) {
+                            for (int j = 0; j < k; j++) {
+                                if (j == idx || k == idx || l == idx) {
+                                    const auto sel_var = get_sel_var(spec, ip, svctr);
+                                    pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 0);
+                                }
+                                svctr++;
+                            }
+                        }
+                    }
+                    assert(svctr == nr_svars_for_step(spec, ip));
+                }
+                solver->add_clause(pLits, pLits + ctr);
+            }
+        }
+
+        bool create_noreapply_clauses(const spec& spec)
+        {
+            // There seems to be no good analogy for this in MIGs
+            assert(false);
+            return false;
+        }
+
+        void create_lex_func_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                for (int l = 2; l <= spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            pLits[0] = pabc::Abc_Var2Lit(svars[i][j][k][l], 1);
+                            pLits[1] = pabc::Abc_Var2Lit(svars[i + 1][j][k][l], 1);
+                            pLits[2] = pabc::Abc_Var2Lit(get_op_var(spec, i, 3), 1);
+                            pLits[3] = pabc::Abc_Var2Lit(get_op_var(spec, i + 1, 3), 1);
+                            auto status = solver->add_clause(pLits, pLits + 4);
+                            assert(status);
+                            pLits[2] = pabc::Abc_Var2Lit(get_op_var(spec, i, 2), 1);
+                            pLits[3] = pabc::Abc_Var2Lit(get_op_var(spec, i + 1, 0), 0);
+                            pLits[4] = pabc::Abc_Var2Lit(get_op_var(spec, i + 1, 1), 0);
+                            status = solver->add_clause(pLits, pLits + 5);
+                            assert(status);
+                            pLits[2] = pabc::Abc_Var2Lit(get_op_var(spec, i, 1), 1);
+                            pLits[3] = pabc::Abc_Var2Lit(get_op_var(spec, i + 1, 0), 0);
+                            status = solver->add_clause(pLits, pLits + 4);
+                            assert(status);
+                            pLits[2] = pabc::Abc_Var2Lit(get_op_var(spec, i, 0), 1);
+                            status = solver->add_clause(pLits, pLits + 3);
+                            assert(status);
+                        }
+                    }
+                }
+            }
+        }
+
+        void fence_create_lex_func_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                const auto level = get_level(spec, spec.nr_in + i + 1);
+                const auto levelp = get_level(spec, spec.nr_in + i + 2);
+                int svar_ctr = 0;
+                for (int l = first_step_on_level(level - 1); 
+                    l < first_step_on_level(level); l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, svar_ctr++);
+                            pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+
+                            int svar_ctrp = 0;
+                            for (int lp = first_step_on_level(levelp - 1);
+                                lp < first_step_on_level(levelp); lp++) {
+                                for (int kp = 1; kp < lp; kp++) {
+                                    for (int jp = 0; jp < kp; jp++) {
+                                        const auto sel_varp = get_sel_var(spec, i + 1, svar_ctrp++);
+                                        if (j != jp || k != kp || l != lp) {
+                                            continue;
+                                        }
+                                        pLits[1] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                        pLits[2] = pabc::Abc_Var2Lit(get_op_var(spec, i, 3), 1);
+                                        pLits[3] = pabc::Abc_Var2Lit(get_op_var(spec, i + 1, 3), 1);
+                                        auto status = solver->add_clause(pLits, pLits + 4);
+                                        assert(status);
+                                        pLits[2] = pabc::Abc_Var2Lit(get_op_var(spec, i, 2), 1);
+                                        pLits[3] = pabc::Abc_Var2Lit(get_op_var(spec, i + 1, 0), 0);
+                                        pLits[4] = pabc::Abc_Var2Lit(get_op_var(spec, i + 1, 1), 0);
+                                        status = solver->add_clause(pLits, pLits + 5);
+                                        assert(status);
+                                        pLits[2] = pabc::Abc_Var2Lit(get_op_var(spec, i, 1), 1);
+                                        pLits[3] = pabc::Abc_Var2Lit(get_op_var(spec, i + 1, 0), 0);
+                                        status = solver->add_clause(pLits, pLits + 4);
+                                        assert(status);
+                                        pLits[2] = pabc::Abc_Var2Lit(get_op_var(spec, i, 0), 1);
+                                        status = solver->add_clause(pLits, pLits + 3);
+                                        assert(status);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        void create_colex_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                for (int l = 2; l <= spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            pLits[0] = pabc::Abc_Var2Lit(svars[i][j][k][l], 1);
+
+                            // Cannot have lp < l
+                            for (int lp = 2; lp < l; lp++) {
+                                for (int kp = 1; kp < lp; kp++) {
+                                    for (int jp = 0; jp < kp; jp++) {
+                                        pLits[1] = pabc::Abc_Var2Lit(svars[i + 1][jp][kp][lp], 1);
+                                        const auto res = solver->add_clause(pLits, pLits + 2);
+                                        assert(res);
+                                    }
+                                }
+                            }
+
+                            // May have lp == l and kp > k
+                            for (int kp = 1; kp < k; kp++) {
+                                for (int jp = 0; jp < kp; jp++) {
+                                    pLits[1] = pabc::Abc_Var2Lit(svars[i + 1][jp][kp][l], 1);
+                                    const auto res = solver->add_clause(pLits, pLits + 2);
+                                    assert(res);
+                                }
+                            }
+                            // OR lp == l and kp == k
+                            for (int jp = 0; jp < j; jp++) {
+                                pLits[1] = pabc::Abc_Var2Lit(svars[i + 1][jp][k][l], 1);
+                                const auto res = solver->add_clause(pLits, pLits + 2);
+                                assert(res);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        void fence_create_colex_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                const auto level = get_level(spec, i + spec.nr_in + 1);
+                const auto levelp = get_level(spec, i + 1 + spec.nr_in + 1);
+                int svar_ctr = 0;
+                for (int l = first_step_on_level(level-1); 
+                        l < first_step_on_level(level); l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            if (l < 3) {
+                                svar_ctr++;
+                                continue;
+                            }
+                            const auto sel_var = get_sel_var(spec, i, svar_ctr);
+                            pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                            int svar_ctrp = 0;
+                            for (int lp = first_step_on_level(levelp - 1);
+                                lp < first_step_on_level(levelp); lp++) {
+                                for (int kp = 1; kp < lp; kp++) {
+                                    for (int jp = 0; jp < kp; jp++) {
+                                        if ((lp == l && kp == k && jp < j) || (lp == l && kp < k) || (lp < l)) {
+                                            const auto sel_varp = get_sel_var(spec, i + 1, svar_ctrp);
+                                            pLits[1] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                            (void)solver->add_clause(pLits, pLits + 2);
+                                        }
+                                        svar_ctrp++;
+                                    }
+                                }
+                            }
+                            svar_ctr++;
+                        }
+                    }
+                }
+            }
+        }
+
+        bool create_symvar_clauses(const spec& spec)
+        {
+            for (int q = 2; q <= spec.nr_in; q++) {
+                for (int p = 1; p < q; p++) {
+                    auto symm = true;
+                    for (int i = 0; i < spec.nr_nontriv; i++) {
+                        auto f = spec[spec.synth_func(i)];
+                        if (!(swap(f, p - 1, q - 1) == f)) {
+                            symm = false;
+                            break;
+                        }
+                    }
+                    if (!symm) {
+                        continue;
+                    }
+
+                    for (int i = 1; i < spec.nr_steps; i++) {
+                        for (int l = 2; l <= spec.nr_in + i; l++) {
+                            for (int k = 1; k < l; k++) {
+                                for (int j = 0; j < k; j++) {
+                                    if (!(j == q || k == q || l == q) || (j == p || k == p)) {
+                                        continue;
+                                    }
+                                    pLits[0] = pabc::Abc_Var2Lit(svars[i][j][k][l], 1);
+                                    auto ctr = 1;
+                                    for (int ip = 0; ip < i; ip++) {
+                                        for (int lp = 2; lp <= spec.nr_in + ip; lp++) {
+                                            for (int kp = 1; kp < lp; kp++) {
+                                                for (int jp = 0; jp < kp; jp++) {
+                                                    if (jp == p || kp == p || lp == p) {
+                                                        pLits[ctr++] = pabc::Abc_Var2Lit(svars[ip][jp][kp][lp], 0);
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                    if (!solver->add_clause(pLits, pLits + ctr)) {
+                                        return false;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+
+        void fence_create_symvar_clauses(const spec& spec)
+        {
+            for (int q = 2; q <= spec.nr_in; q++) {
+                for (int p = 1; p < q; p++) {
+                    auto symm = true;
+                    for (int i = 0; i < spec.nr_nontriv; i++) {
+                        auto& f = spec[spec.synth_func(i)];
+                        if (!(swap(f, p - 1, q - 1) == f)) {
+                            symm = false;
+                            break;
+                        }
+                    }
+                    if (!symm) {
+                        continue;
+                    }
+                    for (int i = 1; i < spec.nr_steps; i++) {
+                        const auto level = get_level(spec, i + spec.nr_in + 1);
+                        int svar_ctr = 0;
+                        for (int l = first_step_on_level(level - 1);
+                            l < first_step_on_level(level); l++) {
+                            for (int k = 1; k < l; k++) {
+                                for (int j = 0; j < k; j++) {
+                                    if (!(j == q || k == q || l == q) || (j == p || k == p)) {
+                                        svar_ctr++;
+                                        continue;
+                                    }
+                                    const auto sel_var = get_sel_var(spec, i, svar_ctr);
+                                    pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                                    auto ctr = 1;
+                                    for (int ip = 0; ip < i; ip++) {
+                                        const auto levelp = get_level(spec, spec.nr_in + ip + 1);
+                                        auto svar_ctrp = 0;
+                                        for (int lp = first_step_on_level(levelp - 1);
+                                            lp < first_step_on_level(levelp); lp++) {
+                                            for (int kp = 1; kp < lp; kp++) {
+                                                for (int jp = 0; jp < kp; jp++) {
+                                                    if (jp == p || kp == p || lp == p) {
+                                                        const auto sel_varp = get_sel_var(spec, ip, svar_ctrp);
+                                                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 0);
+                                                    }
+                                                    svar_ctrp++;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    (void)solver->add_clause(pLits, pLits + ctr);
+                                    svar_ctr++;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        void reset_sim_tts(int nr_in)
+        {
+            for (int i = 0; i < NR_SIM_TTS; i++) {
+                sim_tts[i] = kitty::dynamic_truth_table(nr_in);
+                if (i < nr_in) {
+                    kitty::create_nth_var(sim_tts[i], i);
+                }
+            }
+        }
+
+        bool encode(spec& spec)
+        { 
+
+            assert(spec.nr_in >= 3);
+            
+            spec.add_noreapply_clauses = false;
+            spec.add_colex_clauses = false;
+            
+            create_variables(spec);
+            create_main_clauses(spec);
+
+            if (!create_fanin_clauses(spec)) {
+                return false;
+            }
+
+            if (spec.add_alonce_clauses) {
+                create_alonce_clauses(spec);
+            }
+
+            /* if (spec.add_colex_clauses) {
+                create_colex_clauses(spec);
+            }*/
+            
+            if (spec.add_lex_func_clauses) {
+                create_lex_func_clauses(spec);
+            }
+
+            if (spec.add_symvar_clauses && !create_symvar_clauses(spec)) {
+                return false;
+            }
+
+            return true;
+        }
+
+        void update_level_map(const spec& spec, const fence& f)
+        {
+            nr_levels = f.nr_levels();
+            level_dist[0] = spec.nr_in + 1;
+            for (int i = 1; i <= nr_levels; i++) {
+                level_dist[i] = level_dist[i-1] + f.at(i-1);
+            }
+        }
+
+        int get_level(const spec& spec, int step_idx) const
+        {
+            // PIs are considered to be on level zero.
+            if (step_idx <= spec.nr_in) {
+                return 0;
+            } else if (step_idx == spec.nr_in + 1) { 
+                // First step is always on level one
+                return 1;
+            }
+            for (int i = 0; i <= nr_levels; i++) {
+                if (level_dist[i] > step_idx) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        void fence_create_fanin_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto nr_svars_for_i = nr_svars_for_step(spec, i);
+                for (int j = 0; j < nr_svars_for_i; j++) {
+                    const auto sel_var = get_sel_var(spec, i, j);
+                    pLits[j] = pabc::Abc_Var2Lit(sel_var, 0);
+                }
+
+                const auto res = solver->add_clause(pLits, pLits + nr_svars_for_i);
+                assert(res);
+            }
+        }
+
+        bool
+        encode(const spec& spec, const fence& f)
+        {
+            assert(spec.nr_in >= 3);
+            assert(spec.nr_steps == f.nr_nodes());
+
+            bool success = true;
+
+            update_level_map(spec, f);
+            fence_create_variables(spec);
+            if (!fence_create_main_clauses(spec)) {
+                return false;
+            }
+
+            fence_create_fanin_clauses(spec);
+
+            if (spec.add_alonce_clauses) {
+                fence_create_alonce_clauses(spec);
+            }
+            
+            /*if (spec.add_colex_clauses) {
+                fence_create_colex_clauses(spec);
+            }*/
+
+            if (spec.add_lex_func_clauses) {
+                fence_create_lex_func_clauses(spec);
+            }
+
+            if (spec.add_symvar_clauses) {
+                fence_create_symvar_clauses(spec);
+            }
+
+            return true;
+        }
+
+        bool
+        cegar_encode(const spec&, const partial_dag&)
+        {
+            // TODO: implement!
+            assert(false);
+            return false;
+        }
+
+        void extract_mig(const spec& spec, mig& chain)
+        {
+            int op_inputs[3] = { 0, 0, 0 };
+
+            chain.reset(spec.nr_in, 1, spec.nr_steps);
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                int op = 0;
+                for (int j = 0; j < MIG_OP_VARS_PER_STEP; j++) {
+                    if (solver->var_value(get_op_var(spec, i, j))) {
+                        op = j;
+                        break;
+                    }
+                }
+
+                if (spec.verbosity) {
+                    printf("  step x_%d performs operation ",
+                        i + spec.nr_in + 1);
+                    switch (op) {
+                    case 0:
+                        printf("<abc>\n");
+                        break;
+                    case 1:
+                        printf("<!abc>\n");
+                        break;
+                    case 2:
+                        printf("<a!bc>\n");
+                        break;
+                    case 3:
+                        printf("<ab!c>\n");
+                        break;
+                    default:
+                        fprintf(stderr, "Error: unexpected MIG operator\n");
+                        exit(1);
+                        break;
+                    }
+                }
+
+                for (int l = 2; l <= spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = svars[i][j][k][l];
+                            if (solver->var_value(sel_var)) {
+                                op_inputs[0] = j;
+                                op_inputs[1] = k;
+                                op_inputs[2] = l;
+                                break;
+                            }
+                        }
+                    }
+                }
+                chain.set_step(i, op_inputs[0], op_inputs[1], op_inputs[2], op);
+            }
+
+            // TODO: support multiple outputs
+            chain.set_output(0,
+                ((spec.nr_steps + spec.nr_in) << 1) +
+                ((spec.out_inv) & 1));
+        }
+
+        void fence_extract_mig(const spec& spec, mig& chain)
+        {
+            int op_inputs[3] = { 0, 0, 0 };
+
+            chain.reset(spec.nr_in, 1, spec.nr_steps);
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                int op = 0;
+                for (int j = 0; j < MIG_OP_VARS_PER_STEP; j++) {
+                    if (solver->var_value(get_op_var(spec, i, j))) {
+                        op = j;
+                        break;
+                    }
+                }
+
+                if (spec.verbosity) {
+                    printf("  step x_%d performs operation ",
+                        i + spec.nr_in + 1);
+                    switch (op) {
+                    case 0:
+                        printf("<abc>\n");
+                        break;
+                    case 1:
+                        printf("<!abc>\n");
+                        break;
+                    case 2:
+                        printf("<a!bc>\n");
+                        break;
+                    case 3:
+                        printf("<ab!c>\n");
+                        break;
+                    default:
+                        fprintf(stderr, "Error: unexpected MIG operator\n");
+                        exit(1);
+                        break;
+                    }
+                }
+
+                int ctr = 0;
+                const auto level = get_level(spec, spec.nr_in + i + 1);
+                for (int l = first_step_on_level(level - 1); 
+                    l < first_step_on_level(level); l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, ctr++);
+                            if (solver->var_value(sel_var)) {
+                                op_inputs[0] = j;
+                                op_inputs[1] = k;
+                                op_inputs[2] = l;
+                                break;
+                            }
+                        }
+                    }
+                }
+                chain.set_step(i, op_inputs[0], op_inputs[1], op_inputs[2], op);
+            }
+
+            // TODO: support multiple outputs
+            chain.set_output(0,
+                ((spec.nr_steps + spec.nr_in) << 1) +
+                ((spec.out_inv) & 1));
+        }
+
+        void print_solver_state(spec& spec)
+        {
+            for (auto i = 0; i < spec.nr_steps; i++) {
+                for (int l = 2; l <= spec.nr_in + i; l++) {
+                    for (int k = 1; k < l; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = svars[i][j][k][l];
+                            if (solver->var_value(sel_var)) {
+                                printf("s[%d][%d][%d][%d]=1\n", i, j, k, l);
+                            } else {
+                                printf("s[%d][%d][%d][%d]=0\n", i, j, k, l);
+                            }
+                        }
+                    }
+                }
+            }
+
+            for (auto i = 0; i < spec.nr_steps; i++) {
+                for (int j = 0; j < MIG_OP_VARS_PER_STEP; j++) {
+                    if (solver->var_value(get_op_var(spec, i, j))) {
+                        printf("op_%d_%d=1\n", i, j);
+                    } else {
+                        printf("op_%d_%d=0\n", i, j);
+                    }
+                }
+            }
+
+            for (auto i = 0; i < spec.nr_steps; i++) {
+                printf("tt_%d_0=0\n", i);
+                for (int t = 0; t < spec.tt_size; t++) {
+                    const auto sim_var = get_sim_var(spec, i, t);
+                    if (solver->var_value(sim_var)) {
+                        printf("tt_%d_%d=1\n", i, t + 1);
+                    } else {
+                        printf("tt_%d_%d=0\n", i, t + 1);
+                    }
+                }
+            }
+        }
+
+        bool is_dirty() 
+        {
+            return dirty;
+        }
+
+        void set_dirty(bool _dirty)
+        {
+            dirty = _dirty;
+        }
+        
+        bool cegar_encode(const spec& spec)
+        {
+            // TODO: implement
+            assert(false);
+            return false;
+        }
+        
+        bool block_solution(const spec& spec)
+        {
+            // TODO: implement
+            assert(false);
+            return false;
+        }
+        
+        bool block_struct_solution(const spec& spec)
+        {
+            // TODO: implement
+            assert(false);
+            return false;
+        }
+        
+    };
+}
diff --git a/lib/percy/percy/encoders/msv_encoder.hpp b/lib/percy/percy/encoders/msv_encoder.hpp
new file mode 100644
index 0000000..6d457f1
--- /dev/null
+++ b/lib/percy/percy/encoders/msv_encoder.hpp
@@ -0,0 +1,1203 @@
+#pragma once
+
+#include "encoder.hpp"
+
+namespace percy
+{
+
+    class msv_encoder : public std_cegar_encoder, public enumerating_encoder
+    {
+        private:
+			int nr_op_vars_per_step;
+			int nr_op_vars;
+			int nr_out_vars;
+			int nr_sim_vars;
+			int nr_sel_vars;
+			int nr_res_vars;
+			int nr_lex_vars;
+            int sel_offset;
+            int res_offset;
+            int ops_offset;
+            int out_offset;
+            int sim_offset;
+            int lex_offset;
+            int total_nr_vars;
+            
+            pabc::Vec_Int_t* vLits; // Dynamic vector of literals
+
+        public:
+            msv_encoder(solver_wrapper& solver)
+            {
+                vLits = pabc::Vec_IntAlloc(128);
+                set_solver(solver);
+            }
+
+            ~msv_encoder()
+            {
+                pabc::Vec_IntFree(vLits);
+            }
+
+            int
+            get_op_var(const spec& spec, int step_idx, int var_idx)
+            const 
+            {
+                assert(step_idx < spec.nr_steps);
+                assert(var_idx > 0);
+                assert(var_idx <= nr_op_vars_per_step);
+
+                return ops_offset + step_idx * nr_op_vars_per_step + var_idx-1;
+            }
+
+            int
+            get_sel_var(const spec& spec, int step_idx, int svar_idx) const
+            {
+                assert(step_idx < spec.nr_steps);
+                assert(svar_idx < (spec.get_nr_in() + step_idx));
+
+                auto offset = 0;
+                for (int i = 0; i < step_idx; i++) {
+                    offset += (spec.get_nr_in() + i);
+                }
+
+                return sel_offset + offset + svar_idx;
+            }
+
+            int
+            get_res_var(const spec& spec, int step_idx, int res_var_idx) const
+            {
+                assert(step_idx < spec.nr_steps);
+                assert(res_var_idx < (spec.fanin + 2) * (spec.get_nr_in() + step_idx + 1));
+
+                auto offset = 0;
+                for (int i = 0; i < step_idx; i++) {
+                    offset += (spec.get_nr_in() + i + 1) * (spec.fanin + 2);
+                }
+
+                return res_offset + offset + res_var_idx;
+            }
+
+            int 
+            get_out_var(const spec& spec, int h, int i) const
+            {
+                assert(h < spec.nr_nontriv);
+                assert(i < spec.nr_steps);
+
+                return out_offset + spec.nr_steps * h + i;
+            }
+
+            int
+            get_sim_var(const spec& spec, int step_idx, int t) const
+            {
+                assert(step_idx < spec.nr_steps);
+                assert(t < spec.get_tt_size());
+
+                return sim_offset + spec.get_tt_size() * step_idx + t;
+            }
+
+            int
+            get_lex_var(const spec& spec, int step_idx, int op_idx) const
+            {
+                assert(step_idx < spec.nr_steps);
+                assert(op_idx < nr_op_vars_per_step);
+
+                return lex_offset + step_idx * (nr_op_vars_per_step - 1) + op_idx;
+            }
+
+            /*******************************************************************
+                Ensures that each gate has FI operands.
+            *******************************************************************/
+            void create_op_clauses(const spec& spec)
+            {
+                std::vector<int> svars;
+                std::vector<int> res_vars;
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    svars.clear();
+                    res_vars.clear();
+
+                    const auto nr_svars = spec.get_nr_in() + i;
+                    for (int j = 0; j < nr_svars; j++) {
+                        svars.push_back(get_sel_var(spec, i, j));
+                    }
+
+                    const auto nr_res_vars = (spec.fanin + 2) * (nr_svars + 1);
+                    for (int j = 0; j < nr_res_vars; j++) {
+                        res_vars.push_back(get_res_var(spec, i, j));
+                    }
+
+                    create_cardinality_circuit(solver, svars, res_vars, spec.fanin);
+
+                    // Ensure that the fanin cardinality for each step i is
+                    // exactly FI.
+                    const auto fi_var = 
+                        get_res_var(spec, i, (spec.get_nr_in() + i) * (spec.fanin + 2) + spec.fanin);
+                    auto fi_lit = pabc::Abc_Var2Lit(fi_var, 0);
+                    (void)solver->add_clause(&fi_lit, &fi_lit + 1);
+                }
+            }
+
+            bool 
+            create_output_clauses(const spec& spec)
+            {
+                auto status = true;
+
+                if (spec.verbosity > 2) {
+                    printf("Creating output clauses (MSV-%d)\n", spec.fanin);
+                    printf("Nr. clauses = %d (PRE)\n",
+                            solver->nr_clauses());
+                }
+                // Every output points to an operand.
+                if (spec.nr_nontriv > 1) {
+                    for (int h = 0; h < spec.nr_nontriv; h++) {
+                        for (int i = 0; i < spec.nr_steps; i++) {
+                            pabc::Vec_IntSetEntry(vLits, i, 
+                                    pabc::Abc_Var2Lit(get_out_var(spec, h, i), 0));
+                        }
+                        status &= solver->add_clause(
+                                pabc::Vec_IntArray(vLits),
+                                pabc::Vec_IntArray(vLits) + spec.nr_steps);
+
+                        if (spec.verbosity > 2) {
+                            printf("creating output clause: ( ");
+                            for (int i = 0; i < spec.nr_steps; i++) {
+                                printf("%sg_%d_%d ", i > 0 ? "\\/ " : "",
+                                        h + 1, spec.get_nr_in() + i + 1);
+                            }
+                            printf(") (status = %d)\n", status);
+                        }
+                    }
+                }
+
+                // At least one of the outputs has to refer to the final
+                // operator, otherwise it may as well not be there.
+                const auto last_op = spec.nr_steps - 1;
+                for (int h = 0; h < spec.nr_nontriv; h++) {
+                    pabc::Vec_IntSetEntry(vLits, h,
+                            pabc::Abc_Var2Lit(get_out_var(spec, h, last_op),0));
+                }
+                status &= solver->add_clause(
+                    pabc::Vec_IntArray(vLits),
+                    pabc::Vec_IntArray(vLits) + spec.nr_nontriv);
+
+                if (spec.verbosity > 2) {
+                    printf("creating output clause: ( ");
+                    for (int h = 0; h < spec.nr_nontriv; h++) {
+                        printf("%sg_%d_%d ", h > 0 ? "\\/ " : "",
+                                h + 1, spec.get_nr_in() + last_op + 1);
+                    }
+                    printf(") (status = %d)\n", status);
+                    printf("Nr. clauses = %d (POST)\n",
+                            solver->nr_clauses());
+                }
+
+                return status;
+            }
+
+            void
+            create_variables(const spec& spec)
+            {
+                nr_op_vars_per_step = ((1u << spec.fanin) - 1);
+                nr_op_vars = spec.nr_steps * nr_op_vars_per_step;
+                nr_out_vars = spec.nr_nontriv * spec.nr_steps;
+                nr_sim_vars = spec.nr_steps * spec.get_tt_size();
+                nr_lex_vars = (spec.nr_steps - 1) * (nr_op_vars_per_step - 1);
+                nr_sel_vars = 0;
+                nr_res_vars = 0;
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    nr_sel_vars += (spec.get_nr_in() + i);
+                    nr_res_vars += (spec.get_nr_in() + i + 1) * (spec.fanin + 2);
+                }
+                sel_offset = 0;
+                res_offset = nr_sel_vars;
+                ops_offset = nr_res_vars + nr_sel_vars;
+                out_offset = nr_res_vars + nr_sel_vars + nr_op_vars;
+                sim_offset = nr_res_vars + nr_sel_vars + nr_op_vars + nr_out_vars;
+                lex_offset = nr_res_vars + nr_sel_vars + nr_op_vars + nr_out_vars + nr_sim_vars;
+                
+                total_nr_vars = nr_op_vars + nr_out_vars + nr_sim_vars +
+                                nr_sel_vars + nr_res_vars + nr_lex_vars;
+
+                if (spec.verbosity > 2) {
+                    printf("Creating variables (MSV-%d)\n", spec.fanin);
+                    printf("nr steps = %d\n", spec.nr_steps);
+                    printf("nr_sel_vars=%d\n", nr_sel_vars);
+                    printf("nr_res_vars=%d\n", nr_res_vars);
+                    printf("nr_op_vars = %d\n", nr_op_vars);
+                    printf("nr_out_vars = %d\n", nr_out_vars);
+                    printf("nr_sim_vars = %d\n", nr_sim_vars);
+                    printf("nr_lex_vars = %d\n", nr_lex_vars);
+                    printf("creating %d total variables\n", total_nr_vars);
+                }
+
+                solver->set_nr_vars(total_nr_vars);
+            }
+
+            bool
+            create_tt_clauses(const spec& spec, const int t)
+            {
+                auto ret = true;
+                std::vector<int> fanin_asgn(spec.fanin);
+                std::vector<int> fanins(spec.fanin);
+                std::vector<int> fanin_svars(spec.fanin);
+                int pLits[2];
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    // Generate the appropriate constraints for all fanin combinations.
+                    const auto nr_svars_for_i = spec.get_nr_in() + i;
+                    std::string bitmask(spec.fanin, 1);
+                    bitmask.resize(nr_svars_for_i, 0);
+                    do {
+                        auto selected_idx = 0;
+                        for (int svar_idx = 0; svar_idx < nr_svars_for_i; svar_idx++) {
+                            if (bitmask[svar_idx]) {
+                                fanins[selected_idx] = svar_idx;
+                                fanin_svars[selected_idx] = get_sel_var(spec, i, svar_idx);
+                                selected_idx++;
+                            }
+                        }
+                        assert(selected_idx == spec.fanin);
+
+                        // First add clauses for all cases where the
+                        // operator i computes zero.
+                        int opvar_idx = 0;
+                        clear_assignment(fanin_asgn);
+                        while (true) {
+                            next_assignment(fanin_asgn);
+                            if (is_zero(fanin_asgn)) {
+                                break;
+                            }
+                            opvar_idx++;
+                            ret &= add_simulation_clause(spec, t, i, 0,
+                                    opvar_idx, fanins, fanin_svars, fanin_asgn);
+                        }
+
+                        // Next, all cases where operator i computes one.
+                        opvar_idx = 0;
+                        ret &= add_simulation_clause(spec, t, i, 1,
+                                opvar_idx, fanins, fanin_svars, fanin_asgn);
+                        while (true) {
+                            next_assignment(fanin_asgn);
+                            if (is_zero(fanin_asgn)) {
+                                break;
+                            }
+                            opvar_idx++;
+                            ret &= add_simulation_clause(spec, t, i, 1,
+                                    opvar_idx, fanins, fanin_svars, fanin_asgn);
+                        }
+                    } while (std::prev_permutation(bitmask.begin(), bitmask.end()));
+
+                    // If an output has selected this particular operand, we
+                    // need to ensure that this operand's truth table satisfies
+                    // the specified output function.
+                    for (int h = 0; h < spec.nr_nontriv; h++) {
+                        if (spec.is_dont_care(h, t + 1)) {
+                            continue;
+                        }
+                        auto outbit = kitty::get_bit(
+                                spec[spec.synth_func(h)], t+1);
+                        if ((spec.out_inv >> spec.synth_func(h)) & 1) {
+                            outbit = 1 - outbit;
+                        }
+                        pLits[0] = pabc::Abc_Var2Lit(get_out_var(spec, h, i), 1);
+                        pLits[1] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 
+                                1 - outbit);
+                        ret &= solver->add_clause(pLits, pLits+2);
+                        if (spec.verbosity > 2) {
+                            printf("creating oimp clause: ( ");
+                            printf("!g_%d_%d \\/ %sx_%d_%d ) (status=%d)\n", 
+                                    h+1, 
+                                    spec.get_nr_in() + i + 1, 
+                                    (1 - outbit) ?  "!" : "",
+                                    spec.get_nr_in() + i + 1, 
+                                    t + 2,
+                                    ret);
+                        }
+                    }
+                }
+
+                return ret;
+            }
+
+            bool 
+            create_main_clauses(const spec& spec)
+            {
+                if (spec.verbosity > 2) {
+                    printf("Creating main clauses (MSV-%d)\n", spec.fanin);
+                    printf("Nr. clauses = %d (PRE)\n",
+                            solver->nr_clauses());
+                }
+                auto success = true;
+
+                for (int t = 0; t < spec.get_tt_size(); t++) {
+                    success &= create_tt_clauses(spec, t);
+                }
+
+                if (spec.verbosity > 2) {
+                    printf("Nr. clauses = %d (POST)\n",
+                            solver->nr_clauses());
+                }
+
+                return success;
+            }
+
+            bool 
+            add_simulation_clause(
+                    const spec& spec, 
+                    const int t, 
+                    const int i, 
+                    const int output, 
+                    const int opvar_idx,
+                    const std::vector<int>& fanins,
+                    const std::vector<int>& fanin_svars,
+                    const std::vector<int>& fanin_asgn)
+            {
+                int ctr = 0;
+
+                if (spec.verbosity > 3) {
+                    //printf("assignment: %s\n", fanin_asgn.to_string().c_str());
+                }
+
+                for (int j = 0; j < spec.fanin; j++) {
+                    auto child = fanins[j];
+                    auto assign = fanin_asgn[j];
+                    if (child < spec.get_nr_in()) {
+                        if ((((t + 1) & (1 << child) ) ? 1 : 0 ) != assign) {
+                            return true;
+                        }
+                    } else {
+                        pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(
+                                    get_sim_var(spec, child - spec.get_nr_in(),
+                                        t), assign));
+                    }
+                }
+
+                for (const auto svar : fanin_svars) {
+                    pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(svar, 1));
+                }
+
+                pabc::Vec_IntSetEntry(vLits, ctr++,
+                        pabc::Abc_Var2Lit(get_sim_var(spec, i, t), output));
+
+                //printf("opvar_idx=%d\n", opvar_idx);
+                if (opvar_idx > 0) {
+                    pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(
+                                get_op_var(spec, i, opvar_idx), 1 - output));
+                }
+
+                auto status = solver->add_clause(
+                        pabc::Vec_IntArray(vLits),
+                        pabc::Vec_IntArray(vLits) + ctr); 
+
+                if (spec.verbosity > 2) {
+                    printf("creating sim. clause: (");
+                    for (const auto fanin : fanins) {
+                        printf(" !s_%d_%d ", spec.get_nr_in() + i + 1, fanin);
+                    }
+                    printf(" \\/ %sx_%d_%d ", output ? "!" : "", 
+                            spec.get_nr_in() + i + 1, t + 2);
+
+                    for (int j = 0; j < spec.fanin; j++) {
+                        auto child = fanins[j];
+                        auto assign = fanin_asgn[j];
+                        if (child < spec.get_nr_in()) {
+                            continue;
+                        }
+                        printf(" \\/ %sx_%d_%d ",
+                                    assign ? "!" : "", child + 1, t + 2);
+                    }
+                    if (opvar_idx > 0) {
+                        printf(" \\/ %sf_%d_%d ", 
+                                (1-output) ? "!" : "", 
+                                spec.get_nr_in() + i + 1, opvar_idx + 1);
+                    }
+                    printf(") (status=%d)\n", status);
+                }
+
+                return status;
+            }
+
+            /*******************************************************************
+                Add clauses that prevent trivial variable projection and
+                constant operators from being synthesized.
+            *******************************************************************/
+            void 
+            create_nontriv_clauses(const spec& spec)
+            {
+                dynamic_truth_table triv_op(spec.fanin);
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    kitty::clear(triv_op);
+                    
+                    // Dissallow the constant zero operator.
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        pabc::Vec_IntSetEntry(vLits, j-1,
+                                pabc::Abc_Var2Lit(get_op_var(spec, i, j), 0));
+                    }
+                    auto status = solver->add_clause(
+                            pabc::Vec_IntArray(vLits), 
+                            pabc::Vec_IntArray(vLits) + nr_op_vars_per_step);
+                    assert(status);
+                    
+                    // Dissallow all variable projection operators.
+                    for (int n = 0; n < spec.fanin; n++) {
+                        kitty::create_nth_var(triv_op, n);
+                        for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                            pabc::Vec_IntSetEntry(vLits, j-1,
+                                    pabc::Abc_Var2Lit(get_op_var(spec, i, j), 
+                                        kitty::get_bit(triv_op, j)));
+                        }
+                        status = solver->add_clause(
+                                pabc::Vec_IntArray(vLits),
+                                pabc::Vec_IntArray(vLits) + nr_op_vars_per_step);
+                        assert(status);
+                    }
+                }
+            }
+
+            /*******************************************************************
+              Add clauses which ensure that every step is used at least once.
+            *******************************************************************/
+            void 
+            create_alonce_clauses(const spec& spec)
+            {
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    auto ctr = 0;
+
+                    // Either one of the outputs points to this step.
+                    for (int h = 0; h < spec.nr_nontriv; h++) {
+                        pabc::Vec_IntSetEntry(vLits, ctr++, 
+                                pabc::Abc_Var2Lit(get_out_var(spec, h, i), 0));
+                    }
+
+                    // Or one of the succeeding steps points to this step.
+                    for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                        const auto sel_var = get_sel_var(spec, ip, spec.get_nr_in() + i);
+                        pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(sel_var, 0));
+                    }
+                    auto status = solver->add_clause(
+                            pabc::Vec_IntArray(vLits),
+                            pabc::Vec_IntArray(vLits) + ctr);
+                    assert(status);
+                }
+            }
+
+            /*******************************************************************
+                Add clauses which ensure that operands are never re-applied. In
+                other words, (Sijk --> ~Si'ji) & (Sijk --> ~Si'ki), 
+                for all (i < i').
+            *******************************************************************/
+            void 
+            create_noreapply_clauses(const spec& spec)
+            {
+                std::vector<int> fanins(spec.fanin);
+                std::vector<int> fanin_svars(spec.fanin);
+                std::vector<int> pfanin_svars(spec.fanin);
+
+                for (int i = 0; i < spec.nr_steps - 1; i++) {
+                    // Generate the appropriate constraints for all fanin combinations.
+                    const auto nr_svars_for_i = spec.get_nr_in() + i;
+                    std::string bitmask(spec.fanin, 1);
+                    bitmask.resize(nr_svars_for_i, 0);
+                    do {
+                        auto selected_idx = 0;
+                        for (int svar_idx = 0; svar_idx < nr_svars_for_i; svar_idx++) {
+                            if (bitmask[svar_idx]) {
+                                fanins[selected_idx] = svar_idx;
+                                fanin_svars[selected_idx] = get_sel_var(spec, i, svar_idx);
+                                selected_idx++;
+                            }
+                        }
+                        assert(selected_idx == spec.fanin);
+
+                        // Step i' cannot have both fanin i and the remaining FI - 1 fanins from
+                        // the same collection as the fanin of step i.
+                        for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                            pfanin_svars[spec.fanin - 1] = get_sel_var(spec, ip, spec.get_nr_in() + i);
+                            for (int j = 0; j < spec.fanin; j++) {
+                                std::string bitmaskp(spec.fanin - 1, 1);
+                                bitmaskp.resize(spec.fanin, 0);
+                                do {
+                                    selected_idx = 0;
+                                    for (int fi_idx = 0; fi_idx < spec.fanin; fi_idx++) {
+                                        if (bitmaskp[fi_idx]) {
+                                            pfanin_svars[selected_idx++] = get_sel_var(spec, ip, fanins[fi_idx]);
+                                        }
+                                    }
+                                    assert(selected_idx == (spec.fanin - 1));
+
+                                    auto ctr = 0;
+                                    for (const auto svar : fanin_svars) {
+                                        pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(svar, 1));
+                                    }
+                                    for (const auto svar : pfanin_svars) {
+                                        pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(svar, 1));
+                                    }
+                                    auto status = solver->add_clause(
+                                        pabc::Vec_IntArray(vLits),
+                                        pabc::Vec_IntArray(vLits) + ctr);
+                                    assert(status);
+                                } while (std::prev_permutation(bitmaskp.begin(), bitmaskp.end()));
+                            }
+                        }
+                    } while (std::prev_permutation(bitmask.begin(), bitmask.end()));
+
+
+                }
+            }
+
+            /*******************************************************************
+                Add clauses which ensure that steps occur in co-lexicographical
+                order.
+            *******************************************************************/
+            void 
+            create_colex_clauses(const spec& spec)
+            {
+                auto pLits = new int[2 * spec.fanin];
+                std::vector<int> fanins_i(spec.fanin);
+                std::vector<int> fanins_ip(spec.fanin);
+
+                for (int i = 0; i < spec.nr_steps - 1; i++) {
+                    const auto nr_svars_for_i = spec.get_nr_in() + i;
+                    std::string bitmask(spec.fanin, 1);
+                    bitmask.resize(nr_svars_for_i, 0);
+                    do {
+                        auto fanin_ctr = 0;
+                        for (int k = 0; k < nr_svars_for_i; k++) {
+                            if (bitmask[k]) {
+                                pLits[fanin_ctr] = pabc::Abc_Var2Lit(get_sel_var(spec, i, k), 1);
+                                fanins_i[fanin_ctr] = k;
+                                fanin_ctr++;
+                            }
+                        }
+                        assert(fanin_ctr == spec.fanin);
+
+                        const auto nr_svars_for_ip = spec.get_nr_in() + i + 1;
+                        std::string bitmask_ip(spec.fanin, 1);
+                        bitmask_ip.resize(nr_svars_for_ip, 0);
+                        do {
+                            fanin_ctr = 0;
+                            for (int k = 0; k < nr_svars_for_ip; k++) {
+                                if (bitmask_ip[k]) {
+                                    pLits[spec.fanin + fanin_ctr] = pabc::Abc_Var2Lit(get_sel_var(spec, i + 1, k), 1);
+                                    fanins_ip[fanin_ctr] = k;
+                                    fanin_ctr++;
+                                }
+                            }
+                            assert(fanin_ctr == spec.fanin);
+                            if (colex_compare(fanins_i, fanins_ip) == 1) {
+                                auto status = solver->add_clause(pLits, pLits + (spec.fanin * 2));
+                                assert(status);
+                            }
+                        } while (std::prev_permutation(bitmask_ip.begin(), bitmask_ip.end()));
+                    } while (std::prev_permutation(bitmask.begin(), bitmask.end()));
+                }
+
+                delete[] pLits;
+            }
+
+            /*******************************************************************
+                Add clauses which ensure that steps occur in lexicographical
+                order. In other words, we require steps operands to be
+                lexicographically ordered tuples.
+            *******************************************************************/
+            void 
+            create_lex_clauses(const spec& spec)
+            {
+                auto pLits = new int[2 * spec.fanin];
+                std::vector<int> fanins_i(spec.fanin);
+                std::vector<int> fanins_ip(spec.fanin);
+
+                for (int i = 0; i < spec.nr_steps - 1; i++) {
+                    const auto nr_svars_for_i = spec.get_nr_in() + i;
+                    std::string bitmask(spec.fanin, 1);
+                    bitmask.resize(nr_svars_for_i, 0);
+                    do {
+                        auto fanin_ctr = 0;
+                        for (int k = 0; k < nr_svars_for_i; k++) {
+                            if (bitmask[k]) {
+                                pLits[fanin_ctr] = pabc::Abc_Var2Lit(get_sel_var(spec, i, k), 1);
+                                fanins_i[fanin_ctr] = k;
+                                fanin_ctr++;
+                            }
+                        }
+                        assert(fanin_ctr == spec.fanin);
+
+                        const auto nr_svars_for_ip = spec.get_nr_in() + i + 1;
+                        std::string bitmask_ip(spec.fanin, 1);
+                        bitmask_ip.resize(nr_svars_for_ip, 0);
+                        do {
+                            fanin_ctr = 0;
+                            for (int k = 0; k < nr_svars_for_ip; k++) {
+                                if (bitmask_ip[k]) {
+                                    pLits[spec.fanin + fanin_ctr] = pabc::Abc_Var2Lit(get_sel_var(spec, i + 1, k), 1);
+                                    fanins_ip[fanin_ctr] = k;
+                                    fanin_ctr++;
+                                }
+                            }
+                            assert(fanin_ctr == spec.fanin);
+                            if (lex_compare(fanins_i, fanins_ip) == 1) {
+                                auto status = solver->add_clause(pLits, pLits + (spec.fanin * 2));
+                                assert(status);
+                            }
+                        } while (std::prev_permutation(bitmask_ip.begin(), bitmask_ip.end()));
+                    } while (std::prev_permutation(bitmask.begin(), bitmask.end()));
+                }
+            }
+
+            /*******************************************************************
+                Ensure that Boolean operators are lexicographically ordered.
+            *******************************************************************/
+            void 
+            create_lex_func_clauses(const spec& spec)
+            {
+                int lits[3];
+                std::vector<int> fanin(spec.fanin);
+                std::vector<int> fvar_asgns;
+
+                for (int i = 0; i < spec.nr_steps - 1; i++) {
+                    const auto nr_svars_for_i = spec.get_nr_in() + i;
+                    std::string bitmask(spec.fanin, 1);
+                    bitmask.resize(nr_svars_for_i, 0);
+                    do {
+                        auto fanin_ctr = 0;
+                        for (int j = 0; j < nr_svars_for_i; j++) {
+                            if (bitmask[j]) {
+                                fanin[fanin_ctr++] = j;
+                            }
+                        }
+                        assert(fanin_ctr == spec.fanin);
+
+                        auto ctr = 0;
+                        for (int k = 0; k < spec.fanin; k++) {
+                            Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(get_sel_var(spec, i, fanin[k]), 1));
+                            Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(get_sel_var(spec, i + 1, fanin[k]), 1));
+                        }
+                        assert(ctr == spec.fanin * 2);
+                        // The steps have the same fanin, so enforce lexicographical order.
+                        // We do this by constraining the operator variables of both steps.
+                        // Note: the operator variable with the highest index is used 
+                        // first in the ordering.
+                        for (int op_idx = 0; op_idx < nr_op_vars_per_step; op_idx++) {
+                            // Inequality only has to hold if all previous operator variables
+                            // are equal.
+                            ctr = spec.fanin * 2;
+                            for (int prev_idx = 0; prev_idx < op_idx; prev_idx++) {
+                                const auto prev_alpha_i = get_lex_var(spec, i, prev_idx);
+                                Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(prev_alpha_i, 1));
+                            }
+
+                            // Ensure that f_i_n <= f_{i+1}_n.
+                            const auto iop_var = get_op_var(spec, i, nr_op_vars_per_step - op_idx);
+                            const auto ipop_var = get_op_var(spec, i + 1, nr_op_vars_per_step - op_idx);
+                            Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(iop_var, 1));
+                            Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(ipop_var, 0));
+                            auto status = solver->add_clause(
+                                pabc::Vec_IntArray(vLits),
+                                pabc::Vec_IntArray(vLits) + ctr);
+                            assert(status);
+                            if (op_idx == (nr_op_vars_per_step - 1)) {
+                                continue;
+                            }
+                            // alpha_i is 1 iff f_j_i == f_{j+1}_i.
+                            auto alpha_i = get_lex_var(spec, i, op_idx);
+                            lits[0] = pabc::Abc_Var2Lit(alpha_i, 1);
+                            lits[1] = pabc::Abc_Var2Lit(iop_var, 0);
+                            lits[2] = pabc::Abc_Var2Lit(ipop_var, 1);
+                            solver->add_clause(lits, lits + 3);
+                            lits[0] = pabc::Abc_Var2Lit(alpha_i, 1);
+                            lits[1] = pabc::Abc_Var2Lit(iop_var, 1);
+                            lits[2] = pabc::Abc_Var2Lit(ipop_var, 0);
+                            solver->add_clause(lits, lits + 3);
+                            lits[0] = pabc::Abc_Var2Lit(alpha_i, 0);
+                            lits[1] = pabc::Abc_Var2Lit(iop_var, 1);
+                            lits[2] = pabc::Abc_Var2Lit(ipop_var, 1);
+                            solver->add_clause(lits, lits + 3);
+                            lits[0] = pabc::Abc_Var2Lit(alpha_i, 0);
+                            lits[1] = pabc::Abc_Var2Lit(iop_var, 0);
+                            lits[2] = pabc::Abc_Var2Lit(ipop_var, 0);
+                            solver->add_clause(lits, lits + 3);
+                        }
+                    } while (std::prev_permutation(bitmask.begin(), bitmask.end()));
+                }
+            }
+
+            /*******************************************************************
+                Ensure that symmetric variables occur in order.
+            *******************************************************************/
+            bool
+            create_symvar_clauses(const spec& spec)
+            {
+                for (int q = 1; q < spec.get_nr_in(); q++) {
+                    for (int p = 0; p < q; p++) {
+                        auto symm = true;
+                        for (int i = 0; i < spec.nr_nontriv; i++) {
+                            auto f = spec[spec.synth_func(i)];
+                            if (!(swap(f, p, q) == f)) {
+                                symm = false;
+                                break;
+                            }
+                        }
+                        if (!symm) {
+                            continue;
+                        }
+                        if (spec.verbosity > 1) {
+                            printf("  variables x_%d and x_%d are symmetric\n",
+                                    p+1, q+1);
+                        }
+
+                        for (int i = 0; i < spec.nr_steps; i++) {
+                            const auto svar_p = get_sel_var(spec, i, p);
+                            const auto svar_q = get_sel_var(spec, i, q);
+
+                            pabc::Vec_IntSetEntry(vLits, 0, pabc::Abc_Var2Lit(svar_p, 0));
+                            pabc::Vec_IntSetEntry(vLits, 1, pabc::Abc_Var2Lit(svar_q, 1));
+
+                            auto ctr = 2;
+                            for (int ip = 0; ip < i; ip++) {
+                                const auto ip_svar_p = get_sel_var(spec, ip, p);
+                                pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(ip_svar_p, 0));
+                            }
+                            if (!solver->add_clause(Vec_IntArray(vLits), Vec_IntArray(vLits) + ctr)) {
+                                return false;
+                            }
+                        }
+                    }
+                }
+
+                return true;
+            }
+            
+            /// Extracts chain from encoded CNF solution.
+            void extract_chain(const spec& spec, chain& chain)
+            {
+                std::vector<int> fanins(spec.fanin);
+                chain.reset(spec.get_nr_in(), spec.get_nr_out(), spec.nr_steps, spec.fanin);
+
+                if (spec.verbosity > 2) {
+                    print_solver_state(spec);
+                }
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    kitty::dynamic_truth_table op(spec.fanin);
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        if (solver->var_value(get_op_var(spec, i, j))) {
+                            kitty::set_bit(op, j); 
+                        }
+                    }
+
+                    if (spec.verbosity) {
+                        printf("  step x_%d performs operation\n  ", 
+                                i+spec.get_nr_in()+1);
+                        kitty::print_binary(op, std::cout);
+                        printf("\n");
+                    }
+
+                    auto svar_idx = 0;
+                    for (int j = 0; j < spec.get_nr_in() + i; j++) {
+                        const auto sel_var = get_sel_var(spec, i, j);
+                        if (solver->var_value(sel_var)) {
+                            fanins[svar_idx++] = j;
+                        }
+                    }
+                    assert(svar_idx == spec.fanin);
+                    if (spec.verbosity) {
+                        printf("  with operands ");
+                        for (int k = 0; k < spec.fanin; k++) {
+                            printf("x_%d ", fanins[k] + 1);
+                        }
+                    }
+                    chain.set_step(i, fanins, op);
+
+                    if (spec.verbosity) {
+                        printf("\n");
+                    }
+                }
+
+                auto triv_count = 0, nontriv_count = 0;
+                for (int h = 0; h < spec.get_nr_out(); h++) {
+                    if ((spec.triv_flag >> h) & 1) {
+                        chain.set_output(h, 
+                                (spec.triv_func(triv_count++) << 1) +
+                                ((spec.out_inv >> h) & 1));
+                        continue;
+                    }
+                    for (int i = 0; i < spec.nr_steps; i++) {
+                        if (solver->var_value(get_out_var(spec, nontriv_count, i))) {
+                            chain.set_output(h, 
+                                    ((i + spec.get_nr_in() + 1) << 1) +
+                                    ((spec.out_inv >> h) & 1));
+                            nontriv_count++;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            void cegar_extract_chain(const spec& spec, chain& chain)
+            {
+                std::vector<int> fanins(spec.fanin);
+                chain.reset(spec.get_nr_in(), spec.get_nr_out(), spec.nr_steps, spec.fanin);
+
+                if (spec.verbosity > 2) {
+                    print_solver_state(spec);
+                }
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    kitty::dynamic_truth_table op(spec.fanin);
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        if (solver->var_value(get_op_var(spec, i, j))) {
+                            kitty::set_bit(op, j); 
+                        }
+                    }
+
+                    if (spec.verbosity) {
+                        printf("  step x_%d performs operation\n  ", 
+                                i+spec.get_nr_in()+1);
+                        kitty::print_binary(op, std::cout);
+                        printf("\n");
+                    }
+
+                    auto svar_idx = 0;
+                    for (int j = 0; j < spec.get_nr_in() + i; j++) {
+                        const auto sel_var = get_sel_var(spec, i, j);
+                        if (solver->var_value(sel_var)) {
+                            fanins[svar_idx++] = j;
+                        }
+                    }
+                    assert(svar_idx == spec.fanin);
+                    if (spec.verbosity) {
+                        printf("  with operands ");
+                        for (int k = 0; k < spec.fanin; k++) {
+                            printf("x_%d ", fanins[k] + 1);
+                        }
+                    }
+                    chain.set_step(i, fanins, op);
+
+                    if (spec.verbosity) {
+                        printf("\n");
+                    }
+                }
+
+                chain.set_output(0,
+                    ((spec.nr_steps + spec.get_nr_in()) << 1) +
+                    (spec.out_inv & 1));
+            }
+
+            void find_fanin(int i, std::vector<int>& fanins, const spec& spec) const
+            {
+                auto svar_idx = 0;
+                for (int j = 0; j < spec.nr_in + i; j++) {
+                    const auto sel_var = get_sel_var(spec, i, j);
+                    if (solver->var_value(sel_var)) {
+                        fanins[svar_idx++] = j;
+                    }
+                }
+            }
+
+            /*******************************************************************
+                Extracts only the underlying DAG structure from a solution.
+            *******************************************************************/
+            template<int FI>
+            void 
+            extract_dag(spec& spec, dag<FI>& dag)
+            {
+                assert(FI == spec.fanin);
+                dag.reset(spec.get_nr_in(), spec.nr_steps);
+                std::vector<int> fanins(spec.fanin);
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    const auto nr_svars_for_i = spec.get_nr_in() + i;
+                    auto svar_idx = 0;
+                    for (int j = 0; j < nr_svars_for_i; j++) {
+                        const auto sel_var = get_sel_var(spec, i, j);
+                        if (solver->var_value(sel_var)) {
+                            fanins[svar_idx++] = j;
+                        }
+                    }
+                    assert(svar_idx == spec.fanin);
+                    dag.set_vertex(i, fanins);
+                }
+            }
+
+            void
+            print_solver_state(const spec& spec)
+            {
+                std::vector<int> fanins(spec.fanin);
+
+                printf("\n");
+                printf("========================================"
+                        "========================================\n");
+                printf("  SOLVER STATE\n\n");
+
+                printf("  Nr. variables = %d\n", solver->nr_vars());
+                printf("  Nr. clauses = %d\n\n", solver->nr_clauses());
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    bool step_has_fanins = false;
+                    auto svar_idx = 0;
+                    for (int j = 0; j < spec.get_nr_in() + i; j++) {
+                        const auto sel_var = get_sel_var(spec, i, j);
+                        if (solver->var_value(sel_var)) {
+                            fanins[svar_idx++] = j;
+                        }
+                    }
+                    if (svar_idx == spec.fanin) {
+                        printf("  x_%d has inputs ",
+                            spec.get_nr_in() + i + 1);
+                        for (int k = spec.fanin - 1; k >= 0; k--) {
+                            printf("x_%d ", fanins[k] + 1);
+                        }
+                        step_has_fanins = true;
+                    }
+                    if (!step_has_fanins) {
+                        printf("  only %d fanins found for x_%d\n",
+                                svar_idx, spec.get_nr_in() + i + 1);
+                    }
+
+                    printf("  f_%d = ", spec.get_nr_in() + i + 1);
+                    for (int oidx = nr_op_vars_per_step; oidx > 0; oidx--) {
+                        printf("%d", solver->var_value(get_op_var(spec, i, oidx)));
+                    }
+                    printf("0\n");
+
+                    printf("  tt_%d = ", spec.get_nr_in() + i + 1);
+                    for (int t = spec.get_tt_size() - 1; t >= 0; t--) {
+                        printf("%d", solver->var_value(get_sim_var(spec, i, t)));
+                    }
+                    printf("0\n\n");
+                }
+
+                for (int h = 0; h < spec.nr_nontriv; h++) {
+                    for (int i = 0; i < spec.nr_steps; i++) {
+                        printf("  g_%d_%d=%d\n", h + 1, 
+                                spec.get_nr_in() + i + 1,
+                                solver->var_value(get_out_var(spec, h, i)));
+                    }
+                }
+                printf("\n");
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    for (int j = 0; j < spec.get_nr_in() + i; j++) {
+                        printf("  s_%d_%d = %d\n", spec.get_nr_in() + i + 1, j,
+                            solver->var_value(get_sel_var(spec, i, j)));
+                    }
+                    printf("\n");
+
+                    for (int k = 0; k < spec.get_nr_in() + i + 1; k++) {
+                        for (int c = 0; c < spec.fanin + 2; c++) {
+                            printf("res[%d] ", c);
+                        }
+                        printf("\n");
+                        for (int c = 0; c < spec.fanin + 2; c++) {
+                            printf("    %d   ", solver->var_value(
+                                get_res_var(spec, i, k * (spec.fanin + 2) + c)));
+                        }
+                        printf("\n");
+                    }
+
+                    for (int oidx = nr_op_vars_per_step; oidx > 0; oidx--) {
+                        printf("  f_%d_%d=%d\n", 
+                                spec.get_nr_in() + i + 1, 
+                                oidx + 1,
+                                solver->var_value(get_op_var(spec, i, oidx))
+                              );
+                    }
+                    printf("  f_%d_1=0\n", spec.get_nr_in() + i + 1);
+                    printf("\n");
+
+                    for (int t = spec.get_tt_size() - 1; t >= 0; t--) {
+                        printf("  x_%d_%d=%d\n", spec.get_nr_in() + i+1, t + 2, 
+                                solver->var_value( get_sim_var(spec, i, t)));
+                    }
+                    printf("  x_%d_0=0\n", spec.get_nr_in() + i + 1);
+                    printf("\n");
+                }
+                printf("\n");
+
+                printf("========================================"
+                        "========================================\n");
+            }
+
+			/// Encodes specifciation for use in standard synthesis flow.
+            bool 
+            encode(const spec& spec)
+            {
+                assert(spec.nr_steps <= MAX_STEPS);
+
+                create_variables(spec);
+                if (!create_main_clauses(spec)) {
+                    return false;
+                }
+
+                if (!create_output_clauses(spec)) {
+                    return false;
+                }
+
+                create_op_clauses(spec);
+                
+                if (spec.add_nontriv_clauses) {
+                    create_nontriv_clauses(spec);
+                }
+
+                if (spec.add_alonce_clauses) {
+                    create_alonce_clauses(spec);
+                }
+
+                if (spec.add_noreapply_clauses) {
+                    create_noreapply_clauses(spec);
+                }
+
+                if (spec.add_colex_clauses) {
+                    create_colex_clauses(spec);
+                }
+
+                if (spec.add_lex_clauses) {
+                    create_lex_clauses(spec);
+                }
+                
+                if (spec.add_lex_func_clauses) {
+                    create_lex_func_clauses(spec);
+                }
+                
+                if (spec.add_symvar_clauses && !create_symvar_clauses(spec)) {
+                    return false;
+                }
+
+                return true;
+            }
+
+			/// Encodes specifciation for use in CEGAR based synthesis flow.
+            bool 
+            cegar_encode(const spec& spec)
+            {
+                assert(spec.nr_steps <= MAX_STEPS);
+
+                create_variables(spec);
+                
+                if (!create_output_clauses(spec)) {
+                    return false;
+                }
+                
+                create_op_clauses(spec);
+                
+                if (spec.add_nontriv_clauses) {
+                    create_nontriv_clauses(spec);
+                }
+
+                if (spec.add_alonce_clauses) {
+                    create_alonce_clauses(spec);
+                }
+                
+                if (spec.add_noreapply_clauses) {
+                    create_noreapply_clauses(spec);
+                }
+                
+                if (spec.add_colex_clauses) {
+                    create_colex_clauses(spec);
+                }
+                
+                if (spec.add_lex_clauses) {
+                    create_lex_clauses(spec);
+                }
+
+                if (spec.add_lex_func_clauses) {
+                    create_lex_func_clauses(spec);
+                }
+
+                if (spec.add_symvar_clauses && !create_symvar_clauses(spec)) {
+                    return false;
+                }
+
+                return true;
+            }
+
+            /// Assumes that a solution has been found by the current encoding.
+            /// Blocks the current solution such that the solver is forced to
+            /// find different ones (if they exist).
+            bool
+            block_solution(const spec& spec)
+            {
+                int ctr = 0;
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        int invert = 0;
+                        const auto op_var = get_op_var(spec, i, j);
+                        if (solver->var_value(op_var)) {
+                            invert = 1;
+                        }
+                        pabc::Vec_IntSetEntry(vLits, ctr++,
+                                pabc::Abc_Var2Lit(get_op_var(spec, i, j),
+                                    invert));
+                    }
+
+                    for (int j = 0; j < spec.get_nr_in() + i; j++) {
+                        const auto sel_var = get_sel_var(spec, i , j);
+                        if (solver->var_value(sel_var)) {
+                            pabc::Vec_IntSetEntry(vLits, ctr++,
+                                    pabc::Abc_Var2Lit(sel_var, 1));
+                        }
+                    }
+                }
+                return solver->add_clause(
+                            pabc::Vec_IntArray(vLits), 
+                            pabc::Vec_IntArray(vLits) + ctr);
+            }
+
+
+            /// Similar to block_solution, but blocks all solutions with the
+            /// same structure. This is more restrictive, since the other
+            /// method allows for the same structure but different operators.
+            bool
+            block_struct_solution(const spec& spec)
+            {
+                int ctr = 0;
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    for (int j = 0; j < spec.get_nr_in() + i; j++) {
+                        const auto sel_var = get_sel_var(spec, i, j);
+                        if (solver->var_value(sel_var)) {
+                            pabc::Vec_IntSetEntry(vLits, ctr++,
+                                    pabc::Abc_Var2Lit(sel_var, 1));
+                        }
+                    }
+                }
+
+                return solver->add_clause(
+                            pabc::Vec_IntArray(vLits), 
+                            pabc::Vec_IntArray(vLits) + ctr);
+            }
+
+            int simulate(const spec& spec)
+            {
+                std::vector<int> fanins(spec.fanin);
+                auto tt_comp = kitty::create<dynamic_truth_table>(spec.nr_in);
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    find_fanin(i, fanins, spec);
+
+                    kitty::clear(sim_tts[spec.nr_in + i]);
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        kitty::clear(tt_comp);
+                        tt_comp = ~tt_comp;
+                        if (solver->var_value(get_op_var(spec, i, j))) {
+                            for (int k = 0; k < spec.fanin; k++) {
+                                if ((j >> k) & 1) {
+                                    tt_comp &= sim_tts[fanins[k]];
+                                } else {
+                                    tt_comp &= ~sim_tts[fanins[k]];
+                                }
+                            }
+                            sim_tts[spec.nr_in + i] |= tt_comp;
+                        }
+                    }
+                }
+
+                const auto iMint = kitty::find_first_bit_difference(sim_tts[spec.nr_in + spec.nr_steps - 1], spec.out_inv ? ~spec[0] : spec[0]);
+                assert(iMint > 0 || iMint == -1);
+                return iMint;
+            }
+            
+    };
+}
+
diff --git a/lib/percy/percy/encoders/partial_dag_encoder.hpp b/lib/percy/percy/encoders/partial_dag_encoder.hpp
new file mode 100644
index 0000000..5ddfe0a
--- /dev/null
+++ b/lib/percy/percy/encoders/partial_dag_encoder.hpp
@@ -0,0 +1,1145 @@
+#pragma once
+
+#include <vector>
+#include <kitty/kitty.hpp>
+#include "encoder.hpp"
+#include "../partial_dag.hpp"
+
+namespace percy
+{
+    
+
+    class partial_dag_encoder : public encoder
+    {
+    private:
+        int nr_sel_vars;
+        int nr_res_vars;
+        int nr_op_vars;
+        int nr_sim_vars;
+        int total_nr_vars;
+        int sel_offset;
+        int res_offset;
+        int ops_offset;
+        int sim_offset;
+        pabc::Vec_Int_t* vLits = NULL;
+
+        // We only support fanin-2 gates for now,
+        // so this is a constant.
+        const int PD_OP_VARS_PER_STEP = 3;
+
+        static const int NR_SIM_TTS = 32;
+        std::vector<kitty::dynamic_truth_table> sim_tts { NR_SIM_TTS };
+
+        int nr_svars_for_step(
+            const spec& spec, 
+            const partial_dag& dag, 
+            int i) const
+        {
+            const auto& vertex = dag.get_vertex(i);
+            auto nr_pi_fanins = 0;
+            if (vertex[1] == FANIN_PI) {
+                // If the second fanin is a PI, the first one 
+                // certainly is.
+                nr_pi_fanins = 2;
+            } else if (vertex[0] == FANIN_PI) {
+                nr_pi_fanins = 1;
+            }
+            switch (nr_pi_fanins) {
+            case 1:
+                return spec.nr_in;
+            case 2:
+                return (spec.nr_in * (spec.nr_in - 1)) / 2;
+            default: // No fanin flexibility
+                return 0;
+            }
+        }
+
+        int nr_pi_fanins_for_step(const partial_dag& dag, int i) const
+        {
+            const auto& vertex = dag.get_vertex(i);
+            auto nr_pi_fanins = 0;
+            if (vertex[1] == FANIN_PI) {
+                nr_pi_fanins = 2;
+            } else if (vertex[0] == FANIN_PI) {
+                nr_pi_fanins = 1;
+            }
+
+            return nr_pi_fanins;
+        }
+
+        int get_sel_var(
+            const spec& spec,
+            const partial_dag& dag,
+            int step_idx,
+            int var_idx) const
+        {
+            auto offset = 0;
+            for (int i = 0; i < step_idx; i++) {
+                offset += nr_svars_for_step(spec, dag, i);
+            }
+            return offset + var_idx;
+        }
+
+        int get_res_var(
+            const spec& spec, 
+            const partial_dag& dag, 
+            int step_idx, 
+            int res_var_idx) const
+        {
+            auto offset = 0;
+            for (int i = 0; i < step_idx; i++) {
+                offset += (nr_svars_for_step(spec, dag, i) + 1) * (1 + 2);
+            }
+
+            return res_offset + offset + res_var_idx;
+        }
+
+        int get_sim_var(const spec& spec, int step_idx, int t) const
+        {
+            return sim_offset + spec.get_tt_size() * step_idx + t;
+        }
+
+        int get_op_var(int step_idx, int var_idx) const
+        {
+            return ops_offset + step_idx * PD_OP_VARS_PER_STEP + var_idx;
+        }
+
+    public:
+        partial_dag_encoder()
+        {
+            vLits = pabc::Vec_IntAlloc(128);
+        }
+
+        partial_dag_encoder(solver_wrapper& solver)
+        {
+            set_solver(solver);
+            vLits = pabc::Vec_IntAlloc(128);
+        }
+
+        ~partial_dag_encoder()
+        {
+            pabc::Vec_IntFree(vLits);
+        }
+
+        void create_variables(const spec& spec, const partial_dag& dag)
+        {
+            nr_op_vars = spec.nr_steps * PD_OP_VARS_PER_STEP;
+            nr_sim_vars = spec.nr_steps * spec.get_tt_size();
+
+            nr_sel_vars = 0;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto nr_svars_for_i = nr_svars_for_step(spec, dag, i);
+                nr_sel_vars += nr_svars_for_i;
+            }
+
+            sel_offset = 0;
+            ops_offset = nr_sel_vars;
+            sim_offset = nr_sel_vars + nr_op_vars;
+            total_nr_vars = nr_sel_vars + nr_op_vars + nr_sim_vars;
+
+            if (spec.verbosity > 1) {
+                printf("Creating variables (PD-%d)\n", spec.fanin);
+                printf("nr steps = %d\n", spec.nr_steps);
+                printf("nr_sel_vars=%d\n", nr_sel_vars);
+                printf("nr_op_vars = %d\n", nr_op_vars);
+                printf("nr_sim_vars = %d\n", nr_sim_vars);
+                printf("creating %d total variables\n", total_nr_vars);
+            }
+
+            solver->set_nr_vars(total_nr_vars);
+        }
+
+        void cegar_create_variables(const spec& spec, const partial_dag& dag)
+        {
+            nr_op_vars = spec.nr_steps * PD_OP_VARS_PER_STEP;
+            nr_sim_vars = spec.nr_steps * spec.get_tt_size();
+
+            nr_sel_vars = 0;
+            nr_res_vars = 0;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto nr_svars_for_i = nr_svars_for_step(spec, dag, i);
+                nr_sel_vars += nr_svars_for_i;
+                nr_res_vars += (nr_svars_for_i + 1) * (1 + 2);
+            }
+
+            sel_offset = 0;
+            res_offset = nr_sel_vars;
+            ops_offset = nr_sel_vars + nr_res_vars;
+            sim_offset = nr_sel_vars + nr_res_vars + nr_op_vars;
+            total_nr_vars = nr_sel_vars + nr_res_vars + nr_op_vars + nr_sim_vars;
+
+            if (spec.verbosity > 1) {
+                printf("Creating variables (PD-%d)\n", spec.fanin);
+                printf("nr steps = %d\n", spec.nr_steps);
+                printf("nr_sel_vars=%d\n", nr_sel_vars);
+                printf("nr_res_vars=%d\n", nr_res_vars);
+                printf("nr_op_vars = %d\n", nr_op_vars);
+                printf("nr_sim_vars = %d\n", nr_sim_vars);
+                printf("creating %d total variables\n", total_nr_vars);
+            }
+
+            solver->set_nr_vars(total_nr_vars);
+        }
+
+        /// Ensures that each gate has the proper number of fanins.
+        bool create_fanin_clauses(const spec& spec, const partial_dag& dag)
+        {
+            auto status = true;
+
+            if (spec.verbosity > 2) {
+                printf("Creating op clauses (KNUTH-%d)\n", spec.fanin);
+                printf("Nr. clauses = %d (PRE)\n", solver->nr_clauses());
+            }
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto nr_svars_for_i = nr_svars_for_step(spec, dag, i);
+                if (nr_svars_for_i == 0) {
+                    continue;
+                }
+
+                for (int j = 0; j < nr_svars_for_i; j++) {
+                    pabc::Vec_IntSetEntry(vLits, j,
+                        pabc::Abc_Var2Lit(get_sel_var(spec, dag, i, j), 0));
+                }
+
+                status &= solver->add_clause(
+                    pabc::Vec_IntArray(vLits),
+                    pabc::Vec_IntArray(vLits) + nr_svars_for_i);
+            }
+            if (spec.verbosity > 2) {
+                printf("Nr. clauses = %d (POST)\n", solver->nr_clauses());
+            }
+
+            return status;
+        }
+
+        /// The simulation variables of the final step must be equal to
+        /// the function we're trying to synthesize.
+        bool fix_output_sim_vars(const spec& spec)
+        {
+            bool ret = true;
+            auto ilast_step = spec.nr_steps - 1;
+
+            for (int t = 0; t < spec.get_tt_size(); t++) {
+                auto outbit = kitty::get_bit(
+                    spec[spec.synth_func(0)], t + 1);
+                if ((spec.out_inv >> spec.synth_func(0)) & 1) {
+                    outbit = 1 - outbit;
+                }
+                const auto sim_var = get_sim_var(spec, ilast_step, t);
+                pabc::lit sim_lit = pabc::Abc_Var2Lit(sim_var, 1 - outbit);
+                ret &= solver->add_clause(&sim_lit, &sim_lit + 1);
+            }
+
+            return ret;
+        }
+
+        void vfix_output_sim_vars(const spec& spec)
+        {
+            auto ilast_step = spec.nr_steps - 1;
+
+            for (int t = 0; t < spec.get_tt_size(); t++) {
+                auto outbit = kitty::get_bit(
+                    spec[spec.synth_func(0)], t + 1);
+                if ((spec.out_inv >> spec.synth_func(0)) & 1) {
+                    outbit = 1 - outbit;
+                }
+                const auto sim_var = get_sim_var(spec, ilast_step, t);
+                pabc::lit sim_lit = pabc::Abc_Var2Lit(sim_var, 1 - outbit);
+                (void)solver->add_clause(&sim_lit, &sim_lit + 1);
+            }
+        }
+
+
+        bool fix_output_sim_vars(const spec& spec, int t)
+        {
+            const auto ilast_step = spec.nr_steps - 1;
+            auto outbit = kitty::get_bit(
+                spec[spec.synth_func(0)], t + 1);
+            if ((spec.out_inv >> spec.synth_func(0)) & 1) {
+                outbit = 1 - outbit;
+            }
+            const auto sim_var = get_sim_var(spec, ilast_step, t);
+            pabc::lit sim_lit = pabc::Abc_Var2Lit(sim_var, 1 - outbit);
+            return solver->add_clause(&sim_lit, &sim_lit + 1);
+        }
+
+        void vfix_output_sim_vars(const spec& spec, int t)
+        {
+            const auto ilast_step = spec.nr_steps - 1;
+
+            auto outbit = kitty::get_bit(
+                spec[spec.synth_func(0)], t + 1);
+            if ((spec.out_inv >> spec.synth_func(0)) & 1) {
+                outbit = 1 - outbit;
+            }
+            const auto sim_var = get_sim_var(spec, ilast_step, t);
+            pabc::lit sim_lit = pabc::Abc_Var2Lit(sim_var, 1 - outbit);
+            (void)solver->add_clause(&sim_lit, &sim_lit + 1);
+        }
+
+        bool create_nontriv_clauses(const spec& spec)
+        {
+            int pLits[3];
+            bool status = true;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                // Dissallow the constant zero operator.
+                pLits[0] = pabc::Abc_Var2Lit(get_op_var(i, 0), 0);
+                pLits[1] = pabc::Abc_Var2Lit(get_op_var(i, 1), 0);
+                pLits[2] = pabc::Abc_Var2Lit(get_op_var(i, 2), 0);
+                status &= solver->add_clause(pLits, pLits + 3);
+
+                // Dissallow variable projections.
+                pLits[0] = pabc::Abc_Var2Lit(get_op_var(i, 0), 0);
+                pLits[1] = pabc::Abc_Var2Lit(get_op_var(i, 1), 1);
+                pLits[2] = pabc::Abc_Var2Lit(get_op_var(i, 2), 1);
+                status &= solver->add_clause(pLits, pLits + 3);
+
+                pLits[0] = pabc::Abc_Var2Lit(get_op_var(i, 0), 1);
+                pLits[1] = pabc::Abc_Var2Lit(get_op_var(i, 1), 0);
+                pLits[2] = pabc::Abc_Var2Lit(get_op_var(i, 2), 1);
+                status &= solver->add_clause(pLits, pLits + 3);
+            }
+
+            return status;
+        }
+
+        bool add_simulation_clause(
+            const spec& spec,
+            const int t,
+            const int i,
+            const int j,
+            const int k,
+            const int a,
+            const int b,
+            const int c)
+        {
+            int pLits[4];
+            int ctr = 0;
+
+            if (j < spec.nr_in) {
+                if ((((t + 1) & (1 << j)) ? 1 : 0) != b) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, j - spec.nr_in, t), b);
+            }
+
+            if (k < spec.nr_in) {
+                if ((((t + 1) & (1 << k)) ? 1 : 0) != c) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, k - spec.nr_in, t), c);
+            }
+
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), a);
+
+            if (b | c) {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_op_var(i, ((c << 1) | b) - 1), 1 - a);
+            }
+
+            auto status = solver->add_clause(pLits, pLits + ctr);
+
+            return status;
+        }
+
+        bool add_simulation_clause(
+            const spec& spec,
+            const int t,
+            const int i,
+            const int j,
+            const int k,
+            const int a,
+            const int b,
+            const int c,
+            int sel_var)
+        {
+            int pLits[5];
+            int ctr = 0;
+
+            if (j < spec.nr_in) {
+                if ((((t + 1) & (1 << j)) ? 1 : 0) != b) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, j - spec.nr_in, t), b);
+            }
+
+            if (k < spec.nr_in) {
+                if ((((t + 1) & (1 << k)) ? 1 : 0) != c) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, k - spec.nr_in, t), c);
+            }
+
+            pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), a);
+
+            if (b | c) {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_op_var(i, ((c << 1) | b) - 1), 1 - a);
+            }
+
+            return solver->add_clause(pLits, pLits + ctr);
+        }
+
+        bool create_tt_clauses(
+            const spec& spec,
+            const partial_dag& dag,
+            const int t)
+        {
+            auto ret = true;
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto& vertex = dag.get_vertex(i);
+                auto nr_pi_fanins = 0;
+                if (vertex[1] == FANIN_PI) {
+                    // If the second fanin is a PI, the first one 
+                    // certainly is.
+                    nr_pi_fanins = 2;
+                } else if (vertex[0] == FANIN_PI) {
+                    nr_pi_fanins = 1;
+                }
+                if (nr_pi_fanins == 0) {
+                    // The fanins for this step are fixed
+                    const auto j = vertex[0] + spec.nr_in - 1;
+                    const auto k = vertex[1] + spec.nr_in - 1;
+                    ret &= add_simulation_clause(spec, t, i, j, k, 0, 0, 1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, 0, 1, 0);
+                    ret &= add_simulation_clause(spec, t, i, j, k, 0, 1, 1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, 1, 0, 0);
+                    ret &= add_simulation_clause(spec, t, i, j, k, 1, 0, 1);
+                    ret &= add_simulation_clause(spec, t, i, j, k, 1, 1, 0);
+                    ret &= add_simulation_clause(spec, t, i, j, k, 1, 1, 1);
+                } else if (nr_pi_fanins == 1) {
+                    // The first fanin is flexible
+                    const auto k = vertex[1] + spec.nr_in - 1;
+                    auto ctr = 0;
+                    for (int j = 0; j < spec.nr_in; j++) {
+                        const auto sel_var = get_sel_var(spec, dag, i, j);
+                        ret &= add_simulation_clause(spec, t, i, j, k, 0, 0, 1, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, 0, 1, 0, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, 0, 1, 1, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, 1, 0, 0, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, 1, 0, 1, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, 1, 1, 0, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, 1, 1, 1, sel_var);
+                        ctr++;
+                    }
+                } else {
+                    // Both fanins are fully flexible
+                    auto ctr = 0;
+                    for (int k = 1; k < spec.nr_in; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, dag, i, ctr);
+                            ret &= add_simulation_clause(spec, t, i, j, k, 0, 0, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, 0, 1, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, 0, 1, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, 1, 0, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, 1, 0, 1, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, 1, 1, 0, sel_var);
+                            ret &= add_simulation_clause(spec, t, i, j, k, 1, 1, 1, sel_var);
+                            ctr++;
+                        }
+                    }
+                }
+            }
+
+            return ret;
+        }
+
+        // A version that does not compute a return value.
+        void vcreate_tt_clauses(
+            const spec& spec,
+            const partial_dag& dag,
+            const int t)
+        {
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto& vertex = dag.get_vertex(i);
+                auto nr_pi_fanins = 0;
+                if (vertex[1] == FANIN_PI) {
+                    // If the second fanin is a PI, the first one 
+                    // certainly is.
+                    nr_pi_fanins = 2;
+                } else if (vertex[0] == FANIN_PI) {
+                    nr_pi_fanins = 1;
+                }
+                if (nr_pi_fanins == 0) {
+                    // The fanins for this step are fixed
+                    const auto j = vertex[0] + spec.nr_in - 1;
+                    const auto k = vertex[1] + spec.nr_in - 1;
+                    (void)add_simulation_clause(spec, t, i, j, k, 0, 0, 1);
+                    (void)add_simulation_clause(spec, t, i, j, k, 0, 1, 0);
+                    (void)add_simulation_clause(spec, t, i, j, k, 0, 1, 1);
+                    (void)add_simulation_clause(spec, t, i, j, k, 1, 0, 0);
+                    (void)add_simulation_clause(spec, t, i, j, k, 1, 0, 1);
+                    (void)add_simulation_clause(spec, t, i, j, k, 1, 1, 0);
+                    (void)add_simulation_clause(spec, t, i, j, k, 1, 1, 1);
+                } else if (nr_pi_fanins == 1) {
+                    // The first fanin is flexible
+                    const auto k = vertex[1] + spec.nr_in - 1;
+                    auto ctr = 0;
+                    for (int j = 0; j < spec.nr_in; j++) {
+                        const auto sel_var = get_sel_var(spec, dag, i, j);
+                        (void)add_simulation_clause(spec, t, i, j, k, 0, 0, 1, sel_var);
+                        (void)add_simulation_clause(spec, t, i, j, k, 0, 1, 0, sel_var);
+                        (void)add_simulation_clause(spec, t, i, j, k, 0, 1, 1, sel_var);
+                        (void)add_simulation_clause(spec, t, i, j, k, 1, 0, 0, sel_var);
+                        (void)add_simulation_clause(spec, t, i, j, k, 1, 0, 1, sel_var);
+                        (void)add_simulation_clause(spec, t, i, j, k, 1, 1, 0, sel_var);
+                        (void)add_simulation_clause(spec, t, i, j, k, 1, 1, 1, sel_var);
+                        ctr++;
+                    }
+                } else {
+                    // Both fanins are fully flexible
+                    auto ctr = 0;
+                    for (int k = 1; k < spec.nr_in; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, dag, i, ctr);
+                            (void)add_simulation_clause(spec, t, i, j, k, 0, 0, 1, sel_var);
+                            (void)add_simulation_clause(spec, t, i, j, k, 0, 1, 0, sel_var);
+                            (void)add_simulation_clause(spec, t, i, j, k, 0, 1, 1, sel_var);
+                            (void)add_simulation_clause(spec, t, i, j, k, 1, 0, 0, sel_var);
+                            (void)add_simulation_clause(spec, t, i, j, k, 1, 0, 1, sel_var);
+                            (void)add_simulation_clause(spec, t, i, j, k, 1, 1, 0, sel_var);
+                            (void)add_simulation_clause(spec, t, i, j, k, 1, 1, 1, sel_var);
+                            ctr++;
+                        }
+                    }
+                }
+            }
+        }
+
+        void create_main_clauses(const spec& spec, const partial_dag& dag)
+        {
+            for (int t = 0; t < spec.get_tt_size(); t++) {
+                vcreate_tt_clauses(spec, dag, t);
+            }
+        }
+
+        bool reapply_helper(
+            const spec& spec,
+            const partial_dag& dag,
+            int *svars,
+            int depth,
+            int i, 
+            int j,
+            int k,
+            int ip,
+            int jp,
+            int kp,
+            int jpp,
+            int kpp) {
+            int pLits[3];
+            if (depth == 3) {
+                if (j == jp && k == kp &&
+                    (spec.nr_in + i) == jpp
+                    && (spec.nr_in + ip) == kpp) {
+                    const auto sel_var = svars[0];
+                    const auto sel_varp = svars[1];
+                    const auto sel_varpp = svars[2];
+                    auto ctr = 0;
+                    if (sel_var != -1) {
+                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+                    }
+                    if (sel_varp != -1) {
+                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 1);
+                    }
+                    if (sel_varpp != -1) {
+                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_varpp, 1);
+                    }
+                    if (ctr > 1) {
+                        return solver->add_clause(pLits, pLits + ctr);
+                    }
+                }
+            } else if (depth == 2) {
+                if (kp == (spec.nr_in + i) &&
+                    (jp == j || jp == k)) {
+                    const auto sel_var = svars[0];
+                    const auto sel_varp = svars[1];
+                    auto ctr = 0;
+                    if (sel_var != -1) {
+                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+                    }
+                    if (sel_varp != -1) {
+                        pLits[ctr++] = pabc::Abc_Var2Lit(sel_varp, 1);
+                    }
+                    if (ctr > 1) {
+                        return solver->add_clause(pLits, pLits + ctr);
+                    }
+                }
+                for (int ipp = ip + 1; ipp < spec.nr_steps; ipp++) {
+                    const auto& vertex = dag.get_vertex(ipp);
+                    auto nr_pi_fanins = 0;
+                    if (vertex[1] == FANIN_PI) {
+                        nr_pi_fanins = 2;
+                    } else if (vertex[0] == FANIN_PI) {
+                        nr_pi_fanins = 1;
+                    }
+                    if (nr_pi_fanins == 0) {
+                        svars[2] = -1;
+                        jpp = spec.nr_in + vertex[0] - 1;
+                        kpp = spec.nr_in + vertex[1] - 1;
+                        reapply_helper(spec, dag, svars, 3, i, j, k, ip, jp, kp, jpp, kpp);
+                    } else if (nr_pi_fanins == 1) {
+                        kpp = spec.nr_in + vertex[1] - 1;
+                        for (jpp = 0; jpp < spec.nr_in; jpp++) {
+                            svars[2] = get_sel_var(spec, dag, ipp, jpp);
+                            reapply_helper(spec, dag, svars, 3, i, j, k, ip, jp, kp, jpp, kpp);
+                        }
+                    } else {
+                        auto svar_ctr = 0;
+                        for (kpp = 1; kpp < spec.nr_in; kpp++) {
+                            for (jpp = 0; jpp < kpp; jpp++) {
+                                const auto sel_var = get_sel_var(spec, dag, ipp, svar_ctr++);
+                                svars[2] = sel_var;
+                                reapply_helper(spec, dag, svars, 3, i, j, k, ip, jp, kp, jpp, kpp);
+                            }
+                        }
+                    }
+                }
+            } else if (depth == 1) {
+                for (ip = i + 1; ip < spec.nr_steps; ip++) {
+                    const auto& vertex = dag.get_vertex(ip);
+                    auto nr_pi_fanins = 0;
+                    if (vertex[1] == FANIN_PI) {
+                        nr_pi_fanins = 2;
+                    } else if (vertex[0] == FANIN_PI) {
+                        nr_pi_fanins = 1;
+                    }
+                    if (nr_pi_fanins == 0) {
+                        svars[1] = -1;
+                        jp = spec.nr_in + vertex[0] - 1;
+                        kp = spec.nr_in + vertex[1] - 1;
+                        reapply_helper(spec, dag, svars, 2, i, j, k, ip, jp, kp, 0, 0);
+                    } else if (nr_pi_fanins == 1) {
+                        kp = spec.nr_in + vertex[1] - 1;
+                        for (jp = 0; jp < spec.nr_in; jp++) {
+                            svars[1] = get_sel_var(spec, dag, ip, jp);
+                            reapply_helper(spec, dag, svars, 2, i, j, k, ip, jp, kp, 0, 0);
+                        }
+                    } else {
+                        auto svar_ctr = 0;
+                        for (kp = 1; kp < spec.nr_in; kp++) {
+                            for (jp = 0; jp < kp; jp++) {
+                                const auto sel_var = get_sel_var(spec, dag, ip, svar_ctr++);
+                                svars[1] = sel_var;
+                                reapply_helper(spec, dag, svars, 2, i, j, k, ip, jp, kp, 0, 0);
+                            }
+                        }
+                    }
+                }
+            } else {
+                for (i = 0; i < spec.nr_steps; i++) {
+                    const auto& vertex = dag.get_vertex(i);
+                    auto nr_pi_fanins = 0;
+                    if (vertex[1] == FANIN_PI) {
+                        nr_pi_fanins = 2;
+                    } else if (vertex[0] == FANIN_PI) {
+                        nr_pi_fanins = 1;
+                    }
+                    if (nr_pi_fanins == 0) {
+                        svars[0] = -1;
+                        j = spec.nr_in + vertex[0] - 1;
+                        k = spec.nr_in + vertex[1] - 1;
+                        reapply_helper(spec, dag, svars, 1, i, j, k, 0, 0, 0, 0, 0);
+                    } else if (nr_pi_fanins == 1) {
+                        k = spec.nr_in + vertex[1] - 1;
+                        for (j = 0; j < spec.nr_in; j++) {
+                            svars[0] = get_sel_var(spec, dag, i, j);
+                            reapply_helper(spec, dag, svars, 1, i, j, k, 0, 0, 0, 0, 0);
+                        }
+                    } else {
+                        auto svar_ctr = 0;
+                        for (k = 1; k < spec.nr_in; k++) {
+                            for (j = 0; j < k; j++) {
+                                const auto sel_var = get_sel_var(spec, dag, i, svar_ctr++);
+                                svars[0] = sel_var;
+                                reapply_helper(spec, dag, svars, 1, i, j, k, 0, 0, 0, 0, 0);
+                            }
+                        }
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        bool create_noreapply_clauses(const spec& spec, const partial_dag& dag)
+        {
+            int svars[3];
+            
+            return reapply_helper(spec, dag, svars, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+        }
+
+        bool create_symvar_clauses(const spec& spec, const partial_dag& dag)
+        {
+            for (int q = 1; q < spec.nr_in; q++) {
+                for (int p = 0; p < q; p++) {
+                    auto symm = true;
+                    for (int i = 0; i < spec.nr_nontriv; i++) {
+                        auto f = spec[spec.synth_func(i)];
+                        if (!(swap(f, p, q) == f)) {
+                            symm = false;
+                            break;
+                        }
+                    }
+                    if (!symm) {
+                        continue;
+                    }
+
+                    for (int i = 1; i < spec.nr_steps; i++) {
+                        const auto vertex = dag.get_vertex(i);
+                        auto nr_pi_fanins = 0;
+                        if (vertex[1] == FANIN_PI) {
+                            // If the second fanin is a PI, the first one 
+                            // certainly is.
+                            nr_pi_fanins = 2;
+                        } else if (vertex[0] == FANIN_PI) {
+                            nr_pi_fanins = 1;
+                        }
+                        if (nr_pi_fanins == 0) {
+                            continue;
+                        }
+                        if (nr_pi_fanins == 1) {
+                            const auto sel_var = get_sel_var(spec, dag, i, q);
+                            pabc::Vec_IntSetEntry(vLits, 0,
+                                pabc::Abc_Var2Lit(sel_var, 1));
+                            auto ctr = 1;
+                            for (int ip = 0; ip < i; ip++) {
+                                const auto vertex2 = dag.get_vertex(ip);
+                                auto nr_pi_fanins2 = 0;
+                                if (vertex2[1] == FANIN_PI) {
+                                    // If the second fanin is a PI, the first one 
+                                    // certainly is.
+                                    nr_pi_fanins2 = 2;
+                                } else if (vertex2[0] == FANIN_PI) {
+                                    nr_pi_fanins2 = 1;
+                                }
+                                if (nr_pi_fanins2 == 0) {
+                                    continue;
+                                } else if (nr_pi_fanins2 == 1) {
+                                    const auto sel_varp = get_sel_var(spec, dag, ip, p);
+                                    pabc::Vec_IntSetEntry(vLits, ctr++,
+                                        pabc::Abc_Var2Lit(sel_varp, 0));
+                                } else {
+                                    auto svar_ctr = 0;
+                                    for (int k = 1; k < spec.nr_in; k++) {
+                                        for (int j = 0; j < k; j++) {
+                                            if (j == p || k == p) {
+                                                const auto sel_varp = get_sel_var(spec, dag, ip, svar_ctr);
+                                                pabc::Vec_IntSetEntry(vLits, ctr++,
+                                                    pabc::Abc_Var2Lit(sel_varp, 0));
+                                            }
+                                            svar_ctr++;
+                                        }
+                                    }
+                                }
+                            }
+                            if (!solver->add_clause(Vec_IntArray(vLits), Vec_IntArray(vLits) + ctr)) {
+                                return false;
+                            }
+                        } else {
+                            auto svar_ctr = 0;
+                            for (int k = 1; k < spec.nr_in; k++) {
+                                for (int j = 0; j < k; j++) {
+                                    if (!(j == q || k == q) || j == p) {
+                                        svar_ctr++;
+                                        continue;
+                                    }
+                                    const auto sel_var = get_sel_var(spec, dag, i, svar_ctr);
+                                    pabc::Vec_IntSetEntry(vLits, 0, pabc::Abc_Var2Lit(sel_var, 1));
+                                    auto ctr = 1;
+                                    for (int ip = 0; ip < i; ip++) {
+                                        const auto vertex2 = dag.get_vertex(ip);
+                                        auto nr_pi_fanins2 = 0;
+                                        if (vertex2[1] == FANIN_PI) {
+                                            // If the second fanin is a PI, the first one 
+                                            // certainly is.
+                                            nr_pi_fanins2 = 2;
+                                        } else if (vertex2[0] == FANIN_PI) {
+                                            nr_pi_fanins2 = 1;
+                                        }
+                                        if (nr_pi_fanins2 == 0) {
+                                            continue;
+                                        } else if (nr_pi_fanins2 == 1) {
+                                            const auto sel_varp = get_sel_var(spec, dag, ip, p);
+                                            pabc::Vec_IntSetEntry(vLits, ctr++,
+                                                pabc::Abc_Var2Lit(sel_varp, 0));
+                                        } else {
+                                            auto svar_ctrp = 0;
+                                            for (int kp = 1; kp < spec.nr_in; kp++) {
+                                                for (int jp = 0; jp < kp; jp++) {
+                                                    if (jp == p || kp == p) {
+                                                        const auto sel_varp = get_sel_var(spec, dag, ip, svar_ctrp);
+                                                        pabc::Vec_IntSetEntry(vLits, ctr++,
+                                                            pabc::Abc_Var2Lit(sel_varp, 0));
+                                                    }
+                                                    svar_ctrp++;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    if (!solver->add_clause(Vec_IntArray(vLits), Vec_IntArray(vLits) + ctr)) {
+                                        return false;
+                                    }
+                                    svar_ctr++;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+
+        void reset_sim_tts(int nr_in)
+        {
+            for (int i = 0; i < NR_SIM_TTS; i++) {
+                sim_tts[i] = kitty::dynamic_truth_table(nr_in);
+                if (i < nr_in) {
+                    kitty::create_nth_var(sim_tts[i], i);
+                }
+            }
+        }
+
+        bool
+        encode(const spec& spec, const partial_dag& dag)
+        {
+            create_variables(spec, dag);
+            create_main_clauses(spec, dag);
+            vfix_output_sim_vars(spec);
+
+            if (!create_fanin_clauses(spec, dag)) {
+                return false;
+            }
+
+            if (spec.add_nontriv_clauses && !create_nontriv_clauses(spec)) {
+                return false;
+            }
+
+            if (spec.add_noreapply_clauses && !create_noreapply_clauses(spec, dag)) {
+                return false;
+            }
+
+            if (spec.add_symvar_clauses && !create_symvar_clauses(spec, dag)) {
+                return false;
+            }
+
+            return true;
+        }
+
+        /// Allowing multiple selection variables to be true can lead
+        /// to infinite CEGAR loops. Multiple different fanin assignments
+        /// may be consistent with a partial truth table, but it is
+        /// possible that only one of them leads to a complete valid
+        /// chain. If this assignment is never selected when a chain
+        /// is extracted in the CEGAR loop, this leads to trouble.
+        /// For an example, try synthesizing the 4-input function with
+        /// decimal truth table 127.
+        void create_cardinality_constraints(
+            const spec& spec, 
+            const partial_dag& dag)
+        {
+            std::vector<int> svars;
+            std::vector<int> rvars;
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                auto nr_pi_fanins = 0;
+                const auto& vertex = dag.get_vertex(i);
+                if (vertex[1] == FANIN_PI) {
+                    // If the second fanin is a PI, the first one 
+                    // certainly is.
+                    nr_pi_fanins = 2;
+                } else if (vertex[0] == FANIN_PI) {
+                    nr_pi_fanins = 1;
+                }
+                if (nr_pi_fanins == 0) {
+                    continue;
+                } else {
+                    svars.clear();
+                    rvars.clear();
+                    if (nr_pi_fanins == 1) {
+                        for (int j = 0; j < spec.nr_in; j++) {
+                            const auto sel_var = get_sel_var(spec, dag, i, j);
+                            svars.push_back(sel_var);
+                        }
+                    } else {
+                        auto ctr = 0;
+                        for (int k = 1; k < spec.nr_in; k++) {
+                            for (int j = 0; j < k; j++) {
+                                const auto sel_var = get_sel_var(spec, dag, i, ctr++);
+                                svars.push_back(sel_var);
+                            }
+                        }
+                    }
+                    const auto nr_res_vars = (1 + 2) * (svars.size() + 1);
+                    for (auto j = 0u; j < nr_res_vars; j++) {
+                        rvars.push_back(get_res_var(spec, dag, i, j));
+                    }
+                    create_cardinality_circuit(solver, svars, rvars, 1);
+
+                    // Ensure that the fanin cardinality for each step i 
+                    // is exactly FI.
+                    const auto fi_var = 
+                        get_res_var(spec, dag, i, svars.size() * (1 + 2) + 1);
+                    auto fi_lit = pabc::Abc_Var2Lit(fi_var, 0);
+                    (void)solver->add_clause(&fi_lit, &fi_lit + 1);
+                }
+            }
+        }
+
+        bool
+        cegar_encode(const spec& spec, const partial_dag& dag)
+        {
+            cegar_create_variables(spec, dag);
+            /*
+            for (int i = 0; i < spec.nr_rand_tt_assigns; i++) {
+                const auto t = rand() % spec.get_tt_size();
+                //printf("creating tt/IO clause at idx %d\n", t+1);
+                vcreate_tt_clauses(spec, dag, t);
+                vfix_output_sim_vars(spec, t);
+            }
+            */
+
+            create_cardinality_constraints(spec, dag);
+
+            if (!create_fanin_clauses(spec, dag)) {
+                return false;
+            }
+
+            if (!create_nontriv_clauses(spec)) {
+                return false;
+            }
+            
+            if (spec.add_noreapply_clauses && !create_noreapply_clauses(spec, dag)) {
+                return false;
+            }
+            
+            if (spec.add_symvar_clauses && !create_symvar_clauses(spec, dag)) {
+                return false;
+            }
+
+            return true;
+        }
+
+        void extract_chain(
+            const spec& spec,
+            const partial_dag& dag,
+            chain& chain)
+        {
+            int op_inputs[2];
+
+            chain.reset(spec.nr_in, 1, spec.nr_steps, 2);
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                kitty::dynamic_truth_table op(2);
+                for (int j = 0; j < PD_OP_VARS_PER_STEP; j++) {
+                    if (solver->var_value(get_op_var(i, j))) {
+                        kitty::set_bit(op, j + 1);
+                    }
+                }
+
+                if (spec.verbosity) {
+                    printf("  step x_%d performs operation\n  ",
+                        i + spec.nr_in + 1);
+                    kitty::print_binary(op, std::cout);
+                    printf("\n");
+                }
+
+                auto nr_pi_fanins = 0;
+                const auto& vertex = dag.get_vertex(i);
+                if (vertex[1] == FANIN_PI) {
+                    // If the second fanin is a PI, the first one 
+                    // certainly is.
+                    nr_pi_fanins = 2;
+                } else if (vertex[0] == FANIN_PI) {
+                    nr_pi_fanins = 1;
+                }
+                if (nr_pi_fanins == 1) {
+                    for (int j = 0; j < spec.nr_in; j++) {
+                        const auto sel_var = get_sel_var(spec, dag, i, j);
+                        if (solver->var_value(sel_var)) {
+                            op_inputs[0] = j;
+                            break;
+                        }
+                    }
+                    op_inputs[1] = spec.nr_in + vertex[1] - 1;
+                } else if (nr_pi_fanins == 2) {
+                    auto ctr = 0;
+                    for (int k = 1; k < spec.nr_in; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, dag, i, ctr++);
+                            if (solver->var_value(sel_var)) {
+                                op_inputs[0] = j;
+                                op_inputs[1] = k;
+                                break;
+                            }
+                        }
+                    }
+                } else {
+                    op_inputs[0] = vertex[0] + spec.nr_in - 1;
+                    op_inputs[1] = vertex[1] + spec.nr_in - 1;
+                }
+
+                chain.set_step(i, op_inputs, op);
+
+                if (spec.verbosity) {
+                    printf("\n");
+                }
+            }
+
+            // TODO: support multiple outputs
+            chain.set_output(0,
+                ((spec.nr_steps + spec.nr_in) << 1) +
+                ((spec.out_inv) & 1));
+        }
+
+        void print_solver_state(spec& spec, const partial_dag& dag)
+        {
+            for (auto i = 0; i < spec.nr_steps; i++) {
+                auto nr_pi_fanins = 0;
+                const auto& vertex = dag.get_vertex(i);
+                if (vertex[1] == FANIN_PI) {
+                    // If the second fanin is a PI, the first one 
+                    // certainly is.
+                    nr_pi_fanins = 2;
+                } else if (vertex[0] == FANIN_PI) {
+                    nr_pi_fanins = 1;
+                }
+                if (nr_pi_fanins == 1) {
+                    for (int j = 0; j < spec.nr_in; j++) {
+                        const auto sel_var = get_sel_var(spec, dag, i, j);
+                        if (solver->var_value(sel_var)) {
+                            printf("s_%d_%d=1\n", i, j);
+                        } else {
+                            printf("s_%d_%d=0\n", i, j);
+                        }
+                    }
+                } else if (nr_pi_fanins == 2) {
+                    auto ctr = 0;
+                    for (int k = 1; k < spec.nr_in; k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, dag, i, ctr);
+                            if (solver->var_value(sel_var)) {
+                                printf("s_%d_%d=1\n", i, ctr);
+                            } else {
+                                printf("s_%d_%d=0\n", i, ctr);
+                            }
+                            ctr++;
+                        }
+                    }
+                }
+
+                auto res_var_idx = 0;
+                for (int k = 0; k < nr_svars_for_step(spec, dag, i) + 1; k++) {
+                    std::string comma_str;
+                    for (int i = 0; i < k; i++) {
+                        comma_str += "'";
+                    }
+                    for (int i = 0; i < 1 + 2; i++) {
+                        const auto res_var = get_res_var(spec, dag, i, res_var_idx++);
+                        if (solver->var_value(res_var)) {
+                            printf("res%s[%d] = 1\n", comma_str.c_str(), i);
+                        } else {
+                            printf("res%s[%d] = 0\n", comma_str.c_str(), i);
+                        }
+                    }
+                }
+            }
+            for (auto i = 0; i < spec.nr_steps; i++) {
+                printf("tt_%d_0=0\n", i);
+                for (int t = 0; t < spec.get_tt_size(); t++) {
+                    const auto sim_var = get_sim_var(spec, i, t);
+                    if (solver->var_value(sim_var)) {
+                        printf("tt_%d_%d=1\n", i, t + 1);
+                    } else {
+                        printf("tt_%d_%d=0\n", i, t + 1);
+                    }
+                }
+            }
+        }
+
+        kitty::dynamic_truth_table& simulate(const spec& spec, const partial_dag& dag)
+        {
+            int op_inputs[2] = { 0, 0 };
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                char op = 0;
+                for (int j = 0; j < PD_OP_VARS_PER_STEP; j++) {
+                    if (solver->var_value(get_op_var(i, j))) {
+                        op |= (1 << (j + 1));
+                    }
+                }
+
+                auto nr_pi_fanins = 0;
+                const auto& vertex = dag.get_vertex(i);
+                if (vertex[1] == FANIN_PI) {
+                    // If the second fanin is a PI, the first one 
+                    // certainly is.
+                    nr_pi_fanins = 2;
+                } else if (vertex[0] == FANIN_PI) {
+                    nr_pi_fanins = 1;
+                }
+                if (nr_pi_fanins == 1) {
+                    for (int j = 0; j < spec.nr_in; j++) {
+                        const auto sel_var = get_sel_var(spec, dag, i, j);
+                        if (solver->var_value(sel_var)) {
+                            op_inputs[0] = j;
+                            break;
+                        }
+                    }
+                    op_inputs[1] = spec.nr_in + vertex[1] - 1;
+                } else if (nr_pi_fanins == 2) {
+                    auto ctr = 0;
+                    auto brk = false;
+                    for (int k = 1; k < spec.nr_in && !brk; k++) {
+                        for (int j = 0; j < k && !brk; j++) {
+                            const auto sel_var = get_sel_var(spec, dag, i, ctr++);
+                            if (solver->var_value(sel_var)) {
+                                op_inputs[0] = j;
+                                op_inputs[1] = k;
+                                brk = true;
+                            }
+                        }
+                    }
+                } else {
+                    op_inputs[0] = vertex[0] + spec.nr_in - 1;
+                    op_inputs[1] = vertex[1] + spec.nr_in - 1;
+                }
+
+                auto& tt_step = sim_tts[spec.nr_in + i];
+                switch (op) {
+                case 2: // x1^(~x2)
+                    tt_step = sim_tts[op_inputs[0]] & (~sim_tts[op_inputs[1]]);
+                    break;
+                case 4: // (~x1)^x2
+                    tt_step = (~sim_tts[op_inputs[0]]) & sim_tts[op_inputs[1]];
+                    break;
+                case 6: // XOR
+                    tt_step = sim_tts[op_inputs[0]] ^ sim_tts[op_inputs[1]];
+                    break;
+                case 8: // AND
+                    tt_step = sim_tts[op_inputs[0]] & sim_tts[op_inputs[1]];
+                    break;
+                case 14: // OR
+                    tt_step = sim_tts[op_inputs[0]] | sim_tts[op_inputs[1]];
+                    break;
+                default:
+                    fprintf(stderr, "Error: unknown operator\n");
+                    assert(false);
+                    exit(1);
+                }
+            }
+
+            return sim_tts[spec.nr_in + spec.nr_steps - 1];
+        }
+    };
+}
diff --git a/lib/percy/percy/encoders/ssv_dag_encoder.hpp b/lib/percy/percy/encoders/ssv_dag_encoder.hpp
new file mode 100644
index 0000000..ded6a1a
--- /dev/null
+++ b/lib/percy/percy/encoders/ssv_dag_encoder.hpp
@@ -0,0 +1,301 @@
+#pragma once
+
+#include "encoder.hpp"
+#include "../io.hpp"
+
+namespace percy
+{
+    template<int FI>
+    class ssv_dag_encoder : public dag_encoder<FI>
+    {
+        protected:
+            int nr_op_vars;
+            int nr_sim_vars;
+            int nr_op_vars_per_step;
+
+            pabc::Vec_Int_t* vLits; // Dynamic vector of literals
+
+        public:
+            ssv_dag_encoder()
+            {
+                vLits = pabc::Vec_IntAlloc(128);
+            }
+
+            ~ssv_dag_encoder()
+            {
+                pabc::Vec_IntFree(vLits);
+            }
+
+            int
+            get_op_var(const spec& spec, int step_idx, int var_idx)
+            {
+                assert(step_idx < spec.nr_steps);
+                assert(var_idx > 0);
+                assert(var_idx <= nr_op_vars_per_step);
+
+                return step_idx * nr_op_vars_per_step + var_idx - 1;
+            }
+
+            int
+            get_sim_var(const spec& spec, const dag<FI>& dag, int step_idx, int t)
+            {
+                assert(step_idx < dag.get_nr_vertices());
+
+                return nr_op_vars + spec.get_tt_size() * step_idx + t;
+            }
+
+            void
+            create_variables(const spec& spec, const dag<FI>& dag)
+            {
+                nr_op_vars_per_step = ((1u << FI) - 1);
+                nr_op_vars = dag.get_nr_vertices() * nr_op_vars_per_step;
+                nr_sim_vars = dag.get_nr_vertices() * spec.get_tt_size();
+                if (spec.verbosity > 1) {
+                    printf("nr_op_vars_per_step=%d\n", nr_op_vars_per_step);
+                    printf("nr_op_vars=%d\n", nr_op_vars);
+                    printf("nr_sim_vars=%d\n", nr_sim_vars);
+                }
+
+                this->solver->set_nr_vars(nr_op_vars + nr_sim_vars);
+            }
+
+            bool
+            add_simulation_clause(
+                    const spec& spec,
+                    const dag<FI>& dag,
+                    const int t, 
+                    const int i, 
+                    const int output, 
+                    const int opvar_idx,
+                    const int* const fanins,
+                    const std::vector<int>& fanin_asgn)
+            {
+                int ctr = 0;
+
+                for (int j = 0; j < FI; j++) {
+                    auto child = fanins[j];
+                    auto assign = fanin_asgn[j];
+                    if (child < spec.get_nr_in()) {
+                        if (( ( (t + 1) & (1 << child) ) ? 1 : 0 ) != assign) {
+                            return true;
+                        }
+                    } else {
+                        pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(
+                                    get_sim_var(spec, dag, child -
+                                        spec.get_nr_in(), t), assign));
+                    }
+                }
+
+                pabc::Vec_IntSetEntry(vLits, ctr++,
+                        pabc::Abc_Var2Lit(get_sim_var(spec, dag, i, t), output));
+
+                if (opvar_idx > 0) {
+                    pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(
+                                get_op_var(spec, i, opvar_idx), 1 - output));
+                }
+
+                auto status =  this->solver->add_clause(
+                        pabc::Vec_IntArray(vLits), 
+                        pabc::Vec_IntArray(vLits) + ctr); 
+
+                if (spec.verbosity > 2) {
+                    printf("creating sim. clause: (");
+                    printf(" %sx_%d_%d ", output ? "!" : "", 
+                            spec.get_nr_in() + i + 1, t + 2);
+
+                    for (int j = 0; j < FI; j++) {
+                        auto child = fanins[j];
+                        auto assign = fanin_asgn[j];
+                        if (child < spec.get_nr_in()) {
+                            continue;
+                        }
+                        printf(" \\/ %sx_%d_%d ",
+                                    assign ? "!" : "", child + 1, t + 2);
+                    }
+                    if (opvar_idx > 0) {
+                        printf(" \\/ %sf_%d_%d ", 
+                                (1-output) ? "!" : "", 
+                                spec.get_nr_in() + i + 1, opvar_idx + 1);
+                    }
+                    printf(") (status=%d)\n", status);
+                }
+
+                return status;
+            }
+
+            bool
+            create_tt_clauses(const spec& spec, const dag<FI>& dag, int t)
+            {
+                int fanins[FI];
+                std::vector<int> fanin_asgn(FI);
+
+                for (int i = 0; i < dag.get_nr_vertices(); i++) {
+                    auto v = dag.get_vertex(i);
+                    dag.foreach_fanin(v, [&fanins] (auto f_id, int j) {
+                        fanins[j] = f_id;
+                    });
+
+                    // First add clauses for all cases where the operator i
+                    // computes zero.
+                    int opvar_idx = 0;
+                    clear_assignment(fanin_asgn);
+                    while (true) {
+                        next_assignment(fanin_asgn);
+                        if (is_zero(fanin_asgn)) {
+                            break;
+                        }
+                        opvar_idx++;
+                        if (!add_simulation_clause(spec, dag, t, i, 0,
+                                    opvar_idx, fanins, fanin_asgn)) {
+                            return false;
+                        }
+                    }
+
+                    // Next, all cases where operator i computes one.
+                    opvar_idx = 0;
+                    if (!add_simulation_clause(spec, dag, t, i, 1, opvar_idx,
+                                fanins, fanin_asgn)) {
+                        return false;
+                    }
+                    while (true) {
+                        next_assignment(fanin_asgn);
+                        if (is_zero(fanin_asgn)) {
+                            break;
+                        }
+                        opvar_idx++;
+                        if (!add_simulation_clause(spec, dag, t, i, 1, opvar_idx,
+                                fanins, fanin_asgn)) {
+                            return false;
+                        }
+                    }
+
+                    // If an output has selected this particular operand, we
+                    // need to ensure that this operand's truth table satisfies
+                    // the specified output function.
+                    if (i == dag.get_nr_vertices()-1) {
+                        int pLits[1];
+                        auto outbit = kitty::get_bit(spec[0], t+1);
+                        if (spec.out_inv & 1) {
+                            outbit = 1 - outbit;
+                        }
+                        pLits[0] = pabc::Abc_Var2Lit(get_sim_var(spec, dag, i,
+                                    t), 1 - outbit);
+                        if (!this->solver->add_clause(pLits, pLits + 1)) {
+                            return false;
+                        }
+
+                        if (spec.verbosity > 1) {
+                            printf("bit %d=%lu", t+2, outbit);
+                            printf("\tvar=%d\n", get_sim_var(spec, dag, i, t));
+                        }
+                    }
+                }
+
+                return true;
+            }
+
+            bool
+            create_main_clauses(const spec& spec, const dag<FI>& dag)
+            {
+                for (int t = 0; t < spec.get_tt_size(); t++) {
+                    if (!create_tt_clauses(spec, dag, t)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+			/// Encodes specifciation for use in standard synthesis flow.
+            bool 
+            encode(const spec& spec, const dag<FI>& dag)
+            {
+                bool success = true;
+                create_variables(spec, dag);
+                success &= create_main_clauses(spec, dag);
+                // success &= create_nontriv_clauses();
+                return success;
+            }
+
+			/// Encodes specifciation for use in CEGAR based synthesis flow.
+            bool 
+            cegar_encode(const spec& spec, const dag<FI>& dag)
+            {
+                create_variables(spec, dag);
+                return true;
+            }
+
+            /// Extracts chain from encoded CNF solution.
+            void 
+            extract_chain(
+                    const spec& spec, 
+                    const dag<2>& dag, 
+                    chain& chain)
+            {
+                std::vector<int> op_inputs(spec.fanin);
+
+                chain.reset(spec.get_nr_in(), 1, spec.nr_steps, 2);
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    kitty::dynamic_truth_table op(2);
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        if (this->solver->var_value(get_op_var(spec, i, j))) {
+                            kitty::set_bit(op, j); 
+                        }
+                    }
+
+                    if (spec.verbosity) {
+                        printf("  step x_%d performs operation\n  ", 
+                                i+spec.get_nr_in()+1);
+                        kitty::print_binary(op, std::cout);
+                        printf("\n");
+                    }
+
+                    const auto& v = dag.get_vertex(i);
+                    dag.foreach_fanin(v, [&op_inputs](auto f_id, int j) {
+                        op_inputs[j] = f_id;
+                    });
+                    chain.set_step(i, op_inputs, op);
+                        
+                    if (spec.verbosity) {
+                        printf("\n");
+                    }
+                }
+
+
+                // TODO: support multiple outputs
+                chain.set_output(0, 
+                        ((spec.nr_steps + spec.get_nr_in()) << 1) +
+                        ((spec.out_inv) & 1));
+
+                /*
+                auto triv_count = 0, nontriv_count = 0;
+                for (int h = 0; h < spec.get_nr_out(); h++) {
+                    if ((spec.triv_flag >> h) & 1) {
+                        chain.set_output(h, (spec.triv_functions[triv_count++] << 1) +
+                                ((spec.out_inv >> h) & 1));
+                        continue;
+                    }
+                    for (int i = 0; i < spec.nr_steps; i++) {
+                        if (solver_var_value(this->solver, 
+                                    get_out_var(spec, nontriv_count, i))) {
+                            chain.set_output(h, ((i + spec.get_nr_in() + 1) << 1) +
+                                    ((spec.out_inv >> h) & 1));
+                            nontriv_count++;
+                            break;
+                        }
+                    }
+                }
+                */
+            }
+
+            /// Assumes that a solution was found by the synthesizer. In that
+            /// case, we can block the current solution by blocking the current
+            /// assignment to the operator variables.
+            void
+            block_solution()
+            {
+                // TODO: implement
+            }
+    };
+}
+
diff --git a/lib/percy/percy/encoders/ssv_encoder.hpp b/lib/percy/percy/encoders/ssv_encoder.hpp
new file mode 100644
index 0000000..49f2746
--- /dev/null
+++ b/lib/percy/percy/encoders/ssv_encoder.hpp
@@ -0,0 +1,1427 @@
+#pragma once
+
+#include "encoder.hpp"
+#include "../misc.hpp"
+
+namespace percy
+{
+    class ssv_encoder : public std_cegar_encoder, public enumerating_encoder
+    {
+        private:
+			int nr_op_vars_per_step;
+			int nr_op_vars;
+			int nr_out_vars;
+			int nr_sim_vars;
+			int nr_sel_vars;
+			int nr_lex_vars;
+            int sel_offset;
+            int ops_offset;
+            int out_offset;
+            int sim_offset;
+            int lex_offset;
+            int total_nr_vars;
+            
+            pabc::Vec_Int_t* vLits; // Dynamic vector of literals
+            std::vector<std::vector<int>> svar_map;
+            std::vector<int> nr_svar_map;
+
+        public:
+            ssv_encoder(solver_wrapper& solver)
+            {
+                vLits = pabc::Vec_IntAlloc(128);
+                set_solver(solver);
+            }
+
+            ~ssv_encoder()
+            {
+                pabc::Vec_IntFree(vLits);
+            }
+
+            int get_op_var(const spec& spec, int step_idx, int var_idx) const 
+            {
+                assert(step_idx < spec.nr_steps);
+                assert(var_idx > 0);
+                assert(var_idx <= nr_op_vars_per_step);
+
+                return ops_offset + step_idx * nr_op_vars_per_step + var_idx-1;
+            }
+
+            int get_sel_var(int var_idx) const
+            {
+                assert(var_idx < nr_sel_vars);
+
+                return sel_offset + var_idx;
+            }
+
+            int get_out_var(const spec& spec, int h, int i) const
+            {
+                assert(h < spec.nr_nontriv);
+                assert(i < spec.nr_steps);
+
+                return out_offset + spec.nr_steps * h + i;
+            }
+
+            int get_sim_var(const spec& spec, int step_idx, int t) const
+            {
+                assert(step_idx < spec.nr_steps);
+                assert(t < spec.get_tt_size());
+
+                return sim_offset + spec.get_tt_size() * step_idx + t;
+            }
+
+            int get_lex_var(const spec& spec, int step_idx, int op_idx) const
+            {
+                assert(step_idx < spec.nr_steps);
+                assert(op_idx < nr_op_vars_per_step);
+
+                return lex_offset + step_idx * (nr_op_vars_per_step - 1) + op_idx;
+            }
+
+            /*******************************************************************
+                Ensures that each gate has FI operands.
+            *******************************************************************/
+            bool create_op_clauses(const spec& spec)
+            {
+                auto status = true;
+
+                if (spec.verbosity > 2) {
+                    printf("Creating op clauses (SSV-%d)\n", spec.fanin);
+                    printf("Nr. clauses = %d (PRE)\n", solver->nr_clauses());
+                }
+
+                auto svar_offset = 0;
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    const auto nr_svars_for_i = nr_svar_map[i];
+                    
+                    for (int j = 0u; j < nr_svars_for_i; j++) {
+                        pabc::Vec_IntSetEntry(vLits, j, 
+                                pabc::Abc_Var2Lit(get_sel_var(j + svar_offset), 0));
+                    }
+
+                    status &= solver->add_clause(
+                            pabc::Vec_IntArray(vLits), 
+                            pabc::Vec_IntArray(vLits) + nr_svars_for_i);
+
+                    if (spec.verbosity > 2) {
+                        printf("creating op clause: ( ");
+                        for (int j = 0u; j < nr_svars_for_i; j++) {
+                            printf("%ss_%d_%d ", j > 0 ? "\\/ " : "",
+                                    spec.get_nr_in() + i + 1, j + 1);
+                        }
+                        printf(") (status=%d)\n", status);
+                        for (int j = 0u; j < nr_svars_for_i; j++) {
+                            printf("svar(%d) = %d\n", j + svar_offset,
+                                    get_sel_var(j + svar_offset));
+                        }
+                    }
+
+                    svar_offset += nr_svars_for_i;
+                }
+                if (spec.verbosity > 2) {
+                    printf("Nr. clauses = %d (POST)\n", solver->nr_clauses());
+                }
+
+                return status;
+            }
+
+            bool create_output_clauses(const spec& spec)
+            {
+                auto status = true;
+
+                if (spec.verbosity > 2) {
+                    printf("Creating output clauses (SSV-%d)\n", spec.fanin);
+                    printf("Nr. clauses = %d (PRE)\n", solver->nr_clauses());
+                }
+                // Every output points to an operand.
+                if (spec.nr_nontriv > 1) {
+                    for (int h = 0; h < spec.nr_nontriv; h++) {
+                        for (int i = 0; i < spec.nr_steps; i++) {
+                            pabc::Vec_IntSetEntry(vLits, i, 
+                                    pabc::Abc_Var2Lit(get_out_var(spec, h, i), 0));
+                        }
+                        status &= solver->add_clause(
+                                pabc::Vec_IntArray(vLits),
+                                pabc::Vec_IntArray(vLits) + spec.nr_steps);
+
+                        if (spec.verbosity > 2) {
+                            printf("creating output clause: ( ");
+                            for (int i = 0; i < spec.nr_steps; i++) {
+                                printf("%sg_%d_%d ", i > 0 ? "\\/ " : "",
+                                        h + 1, spec.get_nr_in() + i + 1);
+                            }
+                            printf(") (status = %d)\n", status);
+                        }
+                    }
+                }
+
+                // At least one of the outputs has to refer to the final
+                // operator, otherwise it may as well not be there.
+                const auto last_op = spec.nr_steps - 1;
+                for (int h = 0; h < spec.nr_nontriv; h++) {
+                    pabc::Vec_IntSetEntry(vLits, h,
+                            pabc::Abc_Var2Lit(get_out_var(spec, h, last_op),0));
+                }
+                status &= solver->add_clause(
+                    pabc::Vec_IntArray(vLits),
+                    pabc::Vec_IntArray(vLits) + spec.nr_nontriv);
+
+                if (spec.verbosity > 2) {
+                    printf("creating output clause: ( ");
+                    for (int h = 0; h < spec.nr_nontriv; h++) {
+                        printf("%sg_%d_%d ", h > 0 ? "\\/ " : "",
+                                h + 1, spec.get_nr_in() + last_op + 1);
+                    }
+                    printf(") (status = %d)\n", status);
+                    printf("Nr. clauses = %d (POST)\n", solver->nr_clauses());
+                }
+
+                return status;
+            }
+
+            void create_variables( spec const& spec )
+            {
+              std::vector<int> fanins( spec.fanin );
+              nr_op_vars_per_step = ( ( 1u << spec.fanin ) - 1 );
+              nr_op_vars = spec.nr_steps * nr_op_vars_per_step;
+              nr_out_vars = spec.nr_nontriv * spec.nr_steps;
+              nr_sim_vars = spec.nr_steps * spec.get_tt_size();
+              nr_lex_vars = (spec.nr_steps - 1) * (nr_op_vars_per_step - 1);
+              nr_sel_vars = 0;
+              svar_map.clear();
+              nr_svar_map.resize(spec.nr_steps);
+
+              for ( int i = spec.get_nr_in() + spec.get_nr_compiled_functions(); i < spec.get_nr_in() + spec.get_nr_compiled_functions() + spec.nr_steps; i++ )
+              {
+                if ( spec.verbosity > 2 )
+                {
+                  printf("[i] adding sel vars for step #%d\n",
+                         i + 1);
+                }
+
+                // spec.nr_sel_vars += binomial_coeff(i, FI);
+                // ( i * ( i - 1 ) ) / 2;
+
+                auto nr_svars_for_i = 0u;
+                fanin_init( fanins, spec.fanin - 1 );
+                do
+                {
+                  if ( spec.verbosity > 4 )
+                  {
+                    print_fanin( fanins );
+                  }
+                  svar_map.push_back( fanins );
+                  ++nr_svars_for_i;
+                }
+                while ( fanin_inc( fanins, i-1 ) );
+
+                if ( spec.verbosity > 2 )
+                {
+                  printf( "[i] added %u sel vars\n", nr_svars_for_i );
+                }
+
+                nr_sel_vars += nr_svars_for_i;
+                nr_svar_map[ i - spec.get_nr_in() - spec.get_nr_compiled_functions() ] = nr_svars_for_i;
+                assert( nr_svars_for_i == binomial_coeff( i, spec.fanin ) );
+              }
+
+              sel_offset = 0;
+              ops_offset = nr_sel_vars;
+              out_offset = nr_sel_vars + nr_op_vars;
+              sim_offset = nr_sel_vars + nr_op_vars + nr_out_vars;
+              lex_offset = nr_sel_vars + nr_op_vars + nr_out_vars + nr_sim_vars;
+
+              total_nr_vars = nr_op_vars + nr_out_vars + nr_sim_vars +
+                nr_sel_vars + nr_lex_vars;
+
+              if (spec.verbosity > 1)
+              {
+                printf("Creating variables (SSV-%d)\n", spec.fanin);
+                printf("nr steps = %d\n", spec.nr_steps);
+                printf("nr_sel_vars=%d\n", nr_sel_vars);
+                printf("nr_op_vars = %d\n", nr_op_vars);
+                printf("nr_out_vars = %d\n", nr_out_vars);
+                printf("nr_sim_vars = %d\n", nr_sim_vars);
+                printf("nr_lex_vars = %d\n", nr_lex_vars);
+                printf("creating %d total variables\n", total_nr_vars);
+              }
+
+              solver->set_nr_vars(total_nr_vars);
+            }
+
+            bool create_tt_clauses(const spec& spec, const int t)
+            {
+              auto ret = true;
+              std::vector<int> fanin_asgn(spec.fanin);
+              int pLits[2];
+
+              int svar_offset = 0;
+              for (int i = 0; i < spec.nr_steps; i++) {
+                const auto nr_svars_for_i = nr_svar_map[i];
+
+                for (int j = 0; j < nr_svars_for_i; j++) {
+                  const auto svar = j + svar_offset;
+                  const auto& fanins = svar_map[svar];
+
+                  // First add clauses for all cases where the
+                  // operator i computes zero.
+                  int opvar_idx = 0;
+                  clear_assignment(fanin_asgn);
+                  while ( true ) {
+                    next_assignment(fanin_asgn);
+                    if (is_zero(fanin_asgn)) {
+                      break;
+                    }
+                    opvar_idx++;
+                    ret &= add_simulation_clause(spec, t, i, svar, 0,
+                                                 opvar_idx, fanins, fanin_asgn);
+                  }
+
+                  // Next, all cases where operator i computes one.
+                  opvar_idx = 0;
+                  ret &= add_simulation_clause(spec, t, i, svar, 1,
+                                               opvar_idx, fanins, fanin_asgn);
+                  while (true) {
+                    next_assignment(fanin_asgn);
+                    if (is_zero(fanin_asgn)) {
+                      break;
+                    }
+                    opvar_idx++;
+                    ret &= add_simulation_clause(spec, t, i, svar, 1,
+                                                 opvar_idx, fanins, fanin_asgn);
+                  }
+                }
+                svar_offset += nr_svars_for_i;
+
+                    // If an output has selected this particular operand, we
+                    // need to ensure that this operand's truth table satisfies
+                    // the specified output function.
+                    for (int h = 0; h < spec.nr_nontriv; h++) {
+                        if (spec.is_dont_care(h, t + 1)) {
+                            continue;
+                        }
+                        auto outbit = kitty::get_bit(
+                                spec[spec.synth_func(h)], t + 1);
+                        if ((spec.out_inv >> spec.synth_func(h)) & 1) {
+                            outbit = 1 - outbit;
+                        }
+                        pLits[0] = pabc::Abc_Var2Lit(get_out_var(spec, h, i), 1);
+                        pLits[1] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 
+                                1 - outbit);
+                        ret &= solver->add_clause(pLits, pLits+2);
+                        if (spec.verbosity > 2) {
+                            printf("creating oimp clause: ( ");
+                            printf("!g_%d_%d \\/ %sx_%d_%d ) (status=%d)\n", 
+                                    h + 1, 
+                                    spec.get_nr_in() + spec.get_nr_compiled_functions() + i + 1,
+                                    (1 - outbit) ?  "!" : "",
+                                    spec.get_nr_in() + spec.get_nr_compiled_functions() + i + 1,
+                                    t + 2,
+                                    ret);
+                        }
+                    }
+                }
+
+                return ret;
+            }
+
+            bool create_main_clauses(const spec& spec)
+            {
+                if (spec.verbosity > 2) {
+                    printf("Creating main clauses (SSV-%d)\n", spec.fanin);
+                    printf("Nr. clauses = %d (PRE)\n", solver->nr_clauses());
+                }
+                auto success = true;
+
+                for (int t = 0; t < spec.get_tt_size(); t++) {
+                    success &= create_tt_clauses(spec, t);
+                }
+
+                if (spec.verbosity > 2) {
+                    printf("Nr. clauses = %d (POST)\n", solver->nr_clauses());
+                }
+
+                return success;
+            }
+
+            bool add_simulation_clause(
+                    const spec& spec,
+                    const int t,
+                    const int i,
+                    const int svar,
+                    const int output,
+                    const int opvar_idx,
+                    const std::vector<int>& fanins,
+                    const std::vector<int>& fanin_asgn)
+            {
+              int ctr = 0;
+
+              if (spec.verbosity > 3)
+              {
+                // printf("assignment: %s\n", fanin_asgn.to_string().c_str());
+              }
+
+              for (int j = 0; j < spec.fanin; j++)
+              {
+                auto const child = fanins[j];
+                auto const assign = fanin_asgn[j];
+                if ( child < spec.get_nr_in() )
+                {
+                  if ((((t + 1) & (1 << child) ) ? 1 : 0 ) != assign)
+                  {
+                    return true;
+                  }
+                }
+                else if ( child >= spec.get_nr_in() && child < spec.get_nr_in() + spec.get_nr_compiled_functions() )
+                {
+                  auto const func = spec.get_compiled_function( child - spec.get_nr_in() );
+                  auto const bit = kitty::get_bit( func, t + 1 );
+                  if ( bit != assign )
+                    return true;
+                }
+                else
+                {
+                  pabc::Vec_IntSetEntry(vLits, ctr++,
+                    pabc::Abc_Var2Lit( get_sim_var( spec, child - spec.get_nr_in() - spec.get_nr_compiled_functions(), t ), assign ) );
+                }
+              }
+
+              pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(get_sel_var( svar ), 1 ) );
+              pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(get_sim_var( spec, i, t ), output ) );
+
+            //printf("sel_var=%d, sim_var=%d\n", svar, get_sim_var(spec, i, t));
+
+            //printf("opvar_idx=%d\n", opvar_idx);
+            if (opvar_idx > 0) {
+              pabc::Vec_IntSetEntry(vLits, ctr++,
+                pabc::Abc_Var2Lit( get_op_var(spec, i, opvar_idx), 1 - output));
+            }
+
+                auto status = solver->add_clause(
+                        pabc::Vec_IntArray(vLits),
+                        pabc::Vec_IntArray(vLits) + ctr);
+
+                if (spec.verbosity > 3) {
+                    printf("creating sim. clause: (");
+                    printf(" !s_%d_%d ", spec.get_nr_in() + spec.get_nr_compiled_functions() + i + 1, svar + 1);
+                    printf(" \\/ %sx_%d_%d ", output ? "!" : "",
+                            spec.get_nr_in() + spec.get_nr_compiled_functions() + i + 1, t + 2);
+
+                    for (int j = 0; j < spec.fanin; j++) {
+                        auto child = fanins[j];
+                        auto assign = fanin_asgn[j];
+                        if (child < spec.get_nr_in()) {
+                            continue;
+                        }
+                        else if ( child >= spec.get_nr_in() && child < spec.get_nr_in() + spec.get_nr_compiled_functions() )
+                        {
+                            auto const func = spec.get_compiled_function( child - spec.get_nr_in() );
+                            auto const bit = kitty::get_bit( func, t );
+                            if ( bit != assign )
+                              continue;
+                        }
+                        printf(" \\/ %sx_%d_%d ",
+                                    assign ? "!" : "", child + 1, t + 2);
+                    }
+                    if (opvar_idx > 0) {
+                        printf(" \\/ %sf_%d_%d ", 
+                                (1-output) ? "!" : "", 
+                                spec.get_nr_in() + spec.get_nr_compiled_functions() + i + 1, opvar_idx + 1);
+                    }
+                    printf(") (status=%d)\n", status);
+                }
+
+                return status;
+            }
+
+            /*******************************************************************
+                Add clauses that prevent trivial variable projection and
+                constant operators from being synthesized.
+            *******************************************************************/
+            void create_nontriv_clauses(const spec& spec)
+            {
+                dynamic_truth_table triv_op(spec.fanin);
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    kitty::clear(triv_op);
+                    
+                    // Dissallow the constant zero operator.
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        pabc::Vec_IntSetEntry(vLits, j-1,
+                                pabc::Abc_Var2Lit(get_op_var(spec, i, j), 0));
+                    }
+                    auto status = solver->add_clause(
+                            pabc::Vec_IntArray(vLits), 
+                            pabc::Vec_IntArray(vLits) + nr_op_vars_per_step);
+                    assert(status);
+                    
+                    // Dissallow all variable projection operators.
+                    for (int n = 0; n < spec.fanin; n++) {
+                        kitty::create_nth_var(triv_op, n);
+                        for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                            pabc::Vec_IntSetEntry(vLits, j-1,
+                                    pabc::Abc_Var2Lit(get_op_var(spec, i, j), 
+                                        kitty::get_bit(triv_op, j)));
+                        }
+                        status = solver->add_clause(
+                                pabc::Vec_IntArray(vLits),
+                                pabc::Vec_IntArray(vLits) + nr_op_vars_per_step);
+                        assert(status);
+                    }
+                }
+            }
+
+            bool create_primitive_clauses(const spec& spec)
+            {
+                const auto primitives = spec.get_compiled_primitives();
+
+                if (primitives.size() == 1) {
+                    const auto op = primitives[0];
+                    for (int i = 0; i < spec.nr_steps; i++) {
+                        for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                            const auto op_var = get_op_var(spec, i, j);
+                            auto op_lit = pabc::Abc_Var2Lit(op_var, 1 - kitty::get_bit(op, j));
+                            const auto status = solver->add_clause(&op_lit, &op_lit + 1);
+                            if (!status) {
+                                return false;
+                            }
+                        }
+                    }
+                } else {
+                    kitty::dynamic_truth_table tt(spec.fanin);
+                    kitty::clear(tt);
+                    do {
+                        if (!is_normal(tt)) {
+                            kitty::next_inplace(tt);
+                            continue;
+                        }
+                        bool is_primitive_operator = false;
+                        for (const auto& primitive : primitives) {
+                            if (primitive == tt) {
+                                is_primitive_operator = true;
+                            }
+                        }
+                        if (!is_primitive_operator) {
+                            for (int i = 0; i < spec.nr_steps; i++) {
+                                for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                                    pabc::Vec_IntSetEntry(vLits, j - 1,
+                                        pabc::Abc_Var2Lit(get_op_var(spec, i, j),
+                                            kitty::get_bit(tt, j)));
+                                }
+                                const auto status = solver->add_clause(
+                                    pabc::Vec_IntArray(vLits),
+                                    pabc::Vec_IntArray(vLits) + nr_op_vars_per_step);
+                                if (!status) {
+                                    return false;
+                                }
+                            }
+                        }
+                        kitty::next_inplace(tt);
+                    } while (!kitty::is_const0(tt));
+                }
+
+                return true;
+            }
+
+            /*******************************************************************
+              Add clauses which ensure that every step is used at least once.
+            *******************************************************************/
+            void 
+            create_alonce_clauses(const spec& spec)
+            {
+              for ( int i = 0; i < spec.nr_steps; ++i )
+              {
+                auto ctr = 0;
+
+                // Either one of the outputs points to this step.
+                for ( int h = 0; h < spec.nr_nontriv; ++h )
+                {
+                  pabc::Vec_IntSetEntry( vLits, ctr++, pabc::Abc_Var2Lit( get_out_var( spec, h, i ) , 0 ) );
+                }
+
+                auto svar_offset = 0;
+                for (int j = 0; j < i + 1; j++) {
+                  svar_offset += nr_svar_map[j];
+                }
+
+                // Or one of the succeeding steps points to this step.
+                for ( int ip = i + 1; ip < spec.nr_steps; ++ip )
+                {
+                  auto const nr_svars_for_ip = nr_svar_map[ip];
+                  for ( int j = 0; j < nr_svars_for_ip; ++j )
+                  {
+                    auto const sel_var = get_sel_var(svar_offset + j);
+                    auto const& fanins = svar_map[svar_offset + j];
+                    for ( auto const fanin : fanins )
+                    {
+                      if ( fanin == spec.get_nr_in() + spec.get_nr_compiled_functions() + i ) {
+                        pabc::Vec_IntSetEntry( vLits,
+                                               ctr++,
+                                               pabc::Abc_Var2Lit( get_sel_var(sel_var), 0 ) );
+                      }
+                    }
+                  }
+                  svar_offset += nr_svars_for_ip;
+                }
+                auto status = solver->add_clause( pabc::Vec_IntArray(vLits), pabc::Vec_IntArray(vLits) + ctr);
+                assert(status);
+              }
+            }
+
+            /*******************************************************************
+                Add clauses which ensure that operands are never re-applied. In
+                other words, (Sijk --> ~Si'ji) & (Sijk --> ~Si'ki), 
+                for all (i < i').
+            *******************************************************************/
+            void 
+            create_noreapply_clauses(const spec& spec)
+            {
+                int pLits[3];
+                auto svar_offset = 0;
+
+                for (int i = 0; i < spec.nr_steps - 1; i++) {
+                    const auto nr_svars_for_i = nr_svar_map[i];
+                    for (int j = 0; j < nr_svars_for_i; j++) {
+                        const auto sel_var = get_sel_var(svar_offset + j);
+                        const auto& fanins = svar_map[svar_offset + j];
+                        
+                        auto svar_offsetp = 0;
+                        for (int k = 0; k < i + 1; k++) {
+                            svar_offsetp += nr_svar_map[k];
+                        }
+
+                        for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                            const auto nr_svars_for_ip = nr_svar_map[ip];
+                            for (int jp = 0; jp < nr_svars_for_ip; jp++) {
+                                const auto sel_varp = 
+                                    get_sel_var(svar_offsetp + jp);
+                                const auto& faninsp = 
+                                    svar_map[svar_offsetp + jp];
+
+                                auto subsumed = true;
+                                auto has_fanin_i = false;
+                                for (auto faninp : faninsp) {
+                                    if (faninp == i + spec.get_nr_in()) {
+                                        has_fanin_i = true;
+                                    } else {
+                                        auto is_included = false;
+                                        for (auto fanin : fanins) {
+                                            if (fanin == faninp) {
+                                                is_included = true;
+                                            }
+                                        }
+                                        if (!is_included) {
+                                            subsumed = false;
+                                        }
+                                    }
+                                }
+                                if (has_fanin_i && subsumed) {
+                                    pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                                    pLits[1] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                    auto status = solver->add_clause(pLits, pLits + 2);
+                                    assert(status);
+                                }
+
+                                // Disallow:
+                                // x_i  : (j, k)
+                                // x_ip : (j, k)
+                                // x_ipp: (i,ip)
+                                // TODO: implement general case!
+                                if (spec.fanin == 2 && fanins == faninsp) {
+                                    auto svar_offsetpp = svar_offsetp + nr_svar_map[ip];
+                                    for (int ipp = ip + 1; ipp < spec.nr_steps; ipp++) {
+                                        const auto nr_svars_for_ipp = nr_svar_map[ipp];
+                                        for (int jpp = 0; jpp < nr_svars_for_ipp; jpp++) {
+                                            const auto sel_varpp =
+                                                get_sel_var(svar_offsetpp + jpp);
+                                            const auto& faninspp =
+                                                svar_map[svar_offsetpp + jpp];
+                                            if ((faninspp[0] == spec.nr_in + i) && (faninspp[1] == spec.nr_in + ip)) {
+                                                pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                                                pLits[1] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                                pLits[2] = pabc::Abc_Var2Lit(sel_varpp, 1);
+                                                auto status = solver->add_clause(pLits, pLits + 3);
+                                                assert(status);
+                                                break;
+                                            }
+                                        }
+                                        svar_offsetpp += nr_svars_for_ipp;
+                                    }
+                                }
+                            }
+
+                            svar_offsetp += nr_svars_for_ip;
+                        }
+                    }
+                    svar_offset += nr_svars_for_i;
+                }
+            }
+
+            /*******************************************************************
+                Add clauses which ensure that steps occur in co-lexicographical
+                order. In other words, we require steps operands to be 
+                co-lexicographically ordered tuples.
+            *******************************************************************/
+            void 
+            create_colex_clauses(const spec& spec)
+            {
+                int pLits[2];
+                auto svar_offset = 0;
+
+                for (int i = 0; i < spec.nr_steps - 1; i++) {
+                    const auto nr_svars_for_i = nr_svar_map[i];
+                    for (int j = 0; j < nr_svars_for_i; j++) {
+                        const auto sel_var = get_sel_var(svar_offset + j);
+                        const auto& fanins1 = svar_map[svar_offset + j];
+                        pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+
+                        auto svar_offsetp = svar_offset + nr_svars_for_i;
+                        const auto nr_svars_for_ip = nr_svar_map[i + 1];
+                        for (int jp = 0; jp < nr_svars_for_ip; jp++) {
+                            const auto sel_varp = get_sel_var(svar_offsetp+jp);
+                            const auto& fanins2 = svar_map[svar_offsetp + jp];
+
+                            if (colex_compare(fanins1, fanins2) == 1) {
+                                pLits[1] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                auto status = solver->add_clause(pLits, pLits+2);
+                                assert(status);
+                            }
+                        }
+                    }
+
+                    svar_offset += nr_svars_for_i;
+                }
+            }
+
+            /*******************************************************************
+                Add clauses which ensure that steps occur in lexicographical
+                order. In other words, we require steps operands to be
+                lexicographically ordered tuples.
+            *******************************************************************/
+            void 
+            create_lex_clauses(const spec& spec)
+            {
+                int pLits[2];
+                auto svar_offset = 0;
+
+                for (int i = 0; i < spec.nr_steps - 1; i++) {
+                    const auto nr_svars_for_i = nr_svar_map[i];
+                    for (int j = 0; j < nr_svars_for_i; j++) {
+                        const auto sel_var = get_sel_var(svar_offset + j);
+                        const auto& fanins1 = svar_map[svar_offset + j];
+                        pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+
+                        auto svar_offsetp = svar_offset + nr_svars_for_i;
+                        const auto nr_svars_for_ip = nr_svar_map[i + 1];
+                        for (int jp = 0; jp < nr_svars_for_ip; jp++) {
+                            const auto sel_varp = get_sel_var(svar_offsetp+jp);
+                            const auto& fanins2 = svar_map[svar_offsetp + jp];
+
+                            if (lex_compare(fanins1, fanins2) == 1) {
+                                pLits[1] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                auto status = solver->add_clause(pLits, pLits+2);
+                                assert(status);
+                            }
+                        }
+                    }
+
+                    svar_offset += nr_svars_for_i;
+                }
+            }
+
+            /*******************************************************************
+                Ensure that Boolean operators are lexicographically ordered:
+                (S_ijk /\ S_(i+1)jk) ==> f_i <= f_(i+1)
+            *******************************************************************/
+            void 
+            create_lex_func_clauses(const spec& spec)
+            {
+                std::vector<int> fvar_asgns(spec.fanin);
+                int lits[3];
+
+                auto svar_offset = 0;
+                for (int i = 0; i < spec.nr_steps - 1; i++) {
+                    const auto nr_svars_for_i = nr_svar_map[i];
+                    for (int j = 0; j < nr_svars_for_i; j++) {
+                        const auto sel_var = get_sel_var(svar_offset + j);
+                        const auto& fanins1 = svar_map[svar_offset + j];
+                        pabc::Vec_IntSetEntry(vLits, 0, pabc::Abc_Var2Lit(sel_var, 1));
+                        
+                        auto svar_offsetp = svar_offset + nr_svars_for_i;
+                        const auto nr_svars_for_ip = nr_svar_map[i + 1];
+                        for (int jp = 0; jp < nr_svars_for_ip; jp++) {
+                            const auto sel_varp = get_sel_var(svar_offsetp + jp);
+                            const auto& fanins2 = svar_map[svar_offsetp + jp];
+
+                            bool equal_fanin = true;
+                            for (int k = 0; k < spec.fanin; k++) {
+                                if (fanins1[k] != fanins2[k]) {
+                                    equal_fanin = false;
+                                    break;
+                                }
+                            }
+                            if (!equal_fanin) {
+                                continue;
+                            }
+
+                            pabc::Vec_IntSetEntry(vLits, 1, pabc::Abc_Var2Lit(sel_varp, 1));
+                            
+                            // The steps have the same fanin, so enforce lexicographical order.
+                            // We do this by constraining the operator variables of both steps.
+                            // Note: the operator variable with the highest index is used 
+                            // first in the ordering.
+                            for (int op_idx = 0; op_idx < nr_op_vars_per_step; op_idx++) {
+                                // Inequality only has to hold if all previous operator variables
+                                // are equal.
+                                auto ctr = 2;
+                                for (int prev_idx = 0; prev_idx < op_idx; prev_idx++) {
+                                    const auto prev_alpha_i = get_lex_var(spec, i, prev_idx);
+                                    pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(prev_alpha_i, 1));
+                                }
+
+                                // Ensure that f_i_n <= f_{i+1}_n.
+                                const auto iop_var = get_op_var(spec, i, nr_op_vars_per_step - op_idx);
+                                const auto ipop_var = get_op_var(spec, i + 1, nr_op_vars_per_step - op_idx);
+                                pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(iop_var, 1));
+                                pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(ipop_var, 0));
+                                auto status = solver->add_clause(
+                                    pabc::Vec_IntArray(vLits),
+                                    pabc::Vec_IntArray(vLits) + ctr);
+                                assert(status);
+                                if (op_idx == (nr_op_vars_per_step - 1)) {
+                                    continue;
+                                }
+                                // alpha_i is 1 iff f_j_i == f_{j+1}_i.
+                                auto alpha_i = get_lex_var(spec, i, op_idx);
+                                lits[0] = pabc::Abc_Var2Lit(alpha_i, 1);
+                                lits[1] = pabc::Abc_Var2Lit(iop_var, 0);
+                                lits[2] = pabc::Abc_Var2Lit(ipop_var, 1);
+                                solver->add_clause(lits, lits + 3);
+                                lits[0] = pabc::Abc_Var2Lit(alpha_i, 1);
+                                lits[1] = pabc::Abc_Var2Lit(iop_var, 1);
+                                lits[2] = pabc::Abc_Var2Lit(ipop_var, 0);
+                                solver->add_clause(lits, lits + 3);
+                                lits[0] = pabc::Abc_Var2Lit(alpha_i, 0);
+                                lits[1] = pabc::Abc_Var2Lit(iop_var, 1);
+                                lits[2] = pabc::Abc_Var2Lit(ipop_var, 1);
+                                solver->add_clause(lits, lits + 3);
+                                lits[0] = pabc::Abc_Var2Lit(alpha_i, 0);
+                                lits[1] = pabc::Abc_Var2Lit(iop_var, 0);
+                                lits[2] = pabc::Abc_Var2Lit(ipop_var, 0);
+                                solver->add_clause(lits, lits + 3);
+                            }
+                        }
+                    }
+                    svar_offset += nr_svars_for_i;
+                }
+            }
+
+            /*******************************************************************
+                Ensure that symmetric variables occur in order.
+            *******************************************************************/
+            bool
+            create_symvar_clauses(const spec& spec)
+            {
+                for (int q = 1; q < spec.get_nr_in(); q++) {
+                    for (int p = 0; p < q; p++) {
+                        auto symm = true;
+                        for (int i = 0; i < spec.nr_nontriv; i++) {
+                            auto f = spec[spec.synth_func(i)];
+                            if (!(swap(f, p, q) == f)) {
+                                symm = false;
+                                break;
+                            }
+                        }
+                        if (!symm) {
+                            continue;
+                        }
+                        if (spec.verbosity > 3) {
+                            printf("  variables x_%d and x_%d are symmetric\n",
+                                    p+1, q+1);
+                        }
+
+                        auto svar_offset = 0;
+                        for (int i = 0; i < spec.nr_steps; i++) {
+                            const auto nr_svars_for_i = nr_svar_map[i];
+                            for (int j = 0; j < nr_svars_for_i; j++) {
+                                const auto sel_var = get_sel_var(svar_offset+j);
+                                const auto& fanins1 = svar_map[svar_offset+j];
+
+                                auto has_fanin_p = false;
+                                auto has_fanin_q = false;
+                                for (auto fanin : fanins1) {
+                                    if (fanin == q) {
+                                        has_fanin_q = true;
+                                        break;
+                                    } else if (fanin == p) {
+                                        has_fanin_p = true;
+                                    }
+                                }
+                                if (!has_fanin_q || has_fanin_p) {
+                                    continue;
+                                }
+
+                                pabc::Vec_IntSetEntry(vLits, 0, 
+                                        pabc::Abc_Var2Lit(sel_var, 1));
+
+                                auto ctr = 1;
+                                auto svar_offsetp = 0;
+                                for (int ip = 0; ip < i; ip++) {
+                                    const auto nr_svars_for_ip = nr_svar_map[ip];
+                                    for (int jp = 0; jp < nr_svars_for_ip; jp++) {
+                                        const auto sel_varp = 
+                                            get_sel_var(svar_offsetp + jp);
+                                        const auto& fanins2 = 
+                                            svar_map[svar_offsetp + jp];
+
+                                        has_fanin_p = false;
+                                        for (auto fanin : fanins2) {
+                                            if (fanin == p) {
+                                                has_fanin_p = true;
+                                            }
+                                        }
+                                        if (!has_fanin_p) {
+                                            continue;
+                                        }
+                                        pabc::Vec_IntSetEntry(vLits, ctr++, 
+                                                pabc::Abc_Var2Lit(sel_varp, 0));
+                                    }
+                                    svar_offsetp += nr_svars_for_ip;
+                                }
+                                if (!solver->add_clause(Vec_IntArray(vLits), Vec_IntArray(vLits) + ctr)) {
+                                    return false;
+                                }
+                            }
+                            svar_offset += nr_svars_for_i;
+                        }
+                    }
+                }
+
+                return true;
+            }
+
+            /*******************************************************************
+                Ensure that every step has exactly 2 inputs. This may not
+                happen e.g. when we synthesize with more than the minimum
+                number of steps. (Example: synthesizing n-input OR function,
+                with more than the minimum number of steps.)
+            *******************************************************************/
+            void
+            create_cardinality_constraints(const spec& spec)
+            {
+                int pLits[2];
+
+                auto svar_offset = 0;
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    const auto nr_svars_for_i = nr_svar_map[i];
+                    for (int j = 0; j < nr_svars_for_i - 1; j++) {
+                        for (int jp = j + 1; jp < nr_svars_for_i; jp++) {
+                            const auto svar1 = get_sel_var(svar_offset + j);
+                            const auto svar2 = get_sel_var(svar_offset + jp);
+
+                            pLits[0] = pabc::Abc_Var2Lit(svar1, 1);
+                            pLits[1] = pabc::Abc_Var2Lit(svar2, 1);
+
+                            auto status = solver->add_clause(pLits, pLits + 2);
+                            assert(status);
+                        }
+                    }
+                    svar_offset += nr_svars_for_i;
+                }
+                
+                for (int h = 0; h < spec.nr_nontriv; h++) {
+                    for (int i = 0; i < spec.nr_steps - 1; i++) {
+                        for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                            pLits[0] = pabc::Abc_Var2Lit(get_out_var(spec, h, i), 1);
+                            pLits[1] = pabc::Abc_Var2Lit(get_out_var(spec, h, ip), 1);
+                            auto status = solver->add_clause(pLits, pLits + 2);
+                            assert(status);
+                        }
+                    }
+                }
+            }
+
+            /// Extracts chain from encoded CNF solution.
+            void extract_chain(const spec& spec, chain& chain)
+            {
+              // print_solver_state( spec );
+              
+              chain.reset(spec.get_nr_in(), spec.get_nr_out(), spec.nr_steps, spec.fanin);
+
+              chain.set_compiled_functions( spec.get_compiled_functions() );
+
+              if ( spec.verbosity )
+              {
+                for ( int i = 0; i < spec.get_nr_compiled_functions(); ++i )
+                {
+                  std::cout << "  step x_" << ( spec.get_nr_in() + i + 1 ) << " performs dependent function " << std::endl;
+                  std::cout << "  ";
+                  kitty::print_binary( spec.get_compiled_function( i ) );
+                  std::cout << std::endl;
+                }
+              }
+
+              auto svar_offset = 0;
+              for ( int i = 0; i < spec.nr_steps; ++i )
+              {
+                kitty::dynamic_truth_table op( spec.fanin );
+                for ( int j = 1; j <= nr_op_vars_per_step; ++j )
+                {
+                  if ( solver->var_value( get_op_var( spec, i, j ) ) )
+                  {
+                    kitty::set_bit( op, j ); 
+                  }
+                }
+
+                if ( spec.verbosity )
+                {
+                  printf("  step x_%d performs operation\n  ", 
+                         spec.get_nr_in() + spec.get_nr_compiled_functions() + 1 + i );
+                  kitty::print_binary(op, std::cout);
+                  printf("\n");
+                }
+
+                const auto nr_svars_for_i = nr_svar_map[i];
+                for (int j = 0; j < nr_svars_for_i; j++) {
+                  const auto sel_var = get_sel_var(svar_offset + j);
+                  if ( solver->var_value( sel_var ) ) {
+                    const auto& fanins = svar_map[svar_offset + j];
+                    if ( spec.verbosity ) {
+                      printf("  with operands ");
+                      for (int k = 0; k < spec.fanin; k++) {
+                        printf("x_%d ", fanins[k] + 1);
+                      }
+                    }
+                    chain.set_step(i, fanins, op);
+                  }
+                }
+
+                svar_offset += nr_svars_for_i;
+
+                if (spec.verbosity) {
+                  printf("\n");
+                }
+              }
+                
+              auto triv_count = 0, nontriv_count = 0;
+              for (int h = 0; h < spec.get_nr_out(); h++) {
+                if ((spec.triv_flag >> h) & 1) {
+                  chain.set_output(h, 
+                                   (spec.triv_func(triv_count++) << 1) +
+                                   ((spec.out_inv >> h) & 1));
+                  continue;
+                }
+                for (int i = 0; i < spec.nr_steps; i++) {
+                  if (solver->var_value(get_out_var(spec, nontriv_count, i))) {
+                    chain.set_output(h, 
+                                     ((i + spec.get_nr_in() + spec.get_nr_compiled_functions() + 1) << 1) +
+                                     ((spec.out_inv >> h) & 1));
+                    nontriv_count++;
+                    break;
+                  }
+                }
+              }
+            }
+
+            void cegar_extract_chain(const spec& spec, chain& chain)
+            {
+                chain.reset(spec.get_nr_in(), spec.get_nr_out(), spec.nr_steps, spec.fanin);
+
+                auto svar_offset = 0;
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    dynamic_truth_table op(spec.fanin);
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        if (solver->var_value(get_op_var(spec, i, j))) {
+                            kitty::set_bit(op, j); 
+                        }
+                    }
+
+                    if (spec.verbosity) {
+                        printf("  step x_%d performs operation\n  ", 
+                                i+spec.get_nr_in()+1);
+                        kitty::print_binary(op, std::cout);
+                        printf("\n");
+                    }
+
+                    const auto nr_svars_for_i = nr_svar_map[i];
+                    for (int j = 0; j < nr_svars_for_i; j++) {
+                        const auto sel_var = get_sel_var(svar_offset + j);
+                        if (solver->var_value(sel_var)) {
+                            const auto& fanins = svar_map[svar_offset + j];
+                            if (spec.verbosity) {
+                                printf("  with operands ");
+                                for (int k = 0; k < spec.fanin; k++) {
+                                    printf("x_%d ", fanins[k] + 1);
+                                }
+                            }
+                            chain.set_step(i, fanins, op);
+                        }
+                    }
+
+                    svar_offset += nr_svars_for_i;
+
+                    if (spec.verbosity) {
+                        printf("\n");
+                    }
+                }
+
+                chain.set_output(0,
+                    ((spec.nr_steps + spec.get_nr_in()) << 1) +
+                    (spec.out_inv & 1));
+            }
+
+            void find_fanin(int i, std::vector<int>& fanins, const spec& spec) const
+            {
+                auto svar_offset = 0;
+                for (int j = 0; j < i; j++) {
+                    svar_offset += nr_svar_map[j];
+                }
+                const auto nr_svars_for_i = nr_svar_map[i];
+                for (int j = 0; j < nr_svars_for_i; j++) {
+                    const auto sel_var = get_sel_var(svar_offset + j);
+                    if (solver->var_value(sel_var)) {
+                        const auto& sim_fanins = svar_map[svar_offset + j];
+                        for (int k = 0; k < spec.fanin; k++) {
+                            fanins[k] = sim_fanins[k];
+                        }
+                        return;
+                    }
+                }
+                assert(false);
+            }
+
+            int simulate( const spec& spec )
+            {
+                std::vector<int> fanins(spec.fanin);
+                auto tt_comp = kitty::create<dynamic_truth_table>( spec.nr_in );
+
+                for ( int i = 0; i < spec.nr_steps; ++i )
+                {
+                  find_fanin( i, fanins, spec );
+
+                  kitty::clear(sim_tts[spec.nr_in + i]);
+                  for ( int j = 1; j <= nr_op_vars_per_step; ++j )
+                  {
+                    kitty::clear( tt_comp );
+                    tt_comp = ~tt_comp;
+                    if ( solver->var_value( get_op_var( spec, i, j ) ) )
+                    {
+                      for ( int k = 0; k < spec.fanin; ++k )
+                      {
+                        if ( (j >> k) & 1 )
+                        {
+                          tt_comp &= sim_tts[fanins[k]];
+                        }
+                        else
+                        {
+                          tt_comp &= ~sim_tts[fanins[k]];
+                        }
+                      }
+                      sim_tts[spec.nr_in + i] |= tt_comp;
+                    }
+                  }
+                }
+
+                const auto iMint = kitty::find_first_bit_difference(sim_tts[spec.nr_in + spec.nr_steps - 1], spec.out_inv ? ~spec[0] : spec[0]);
+                assert(iMint > 0 || iMint == -1);
+                return iMint;
+            }
+
+            /*******************************************************************
+                Extracts only the underlying DAG structure from a solution.
+            *******************************************************************/
+            template<int FI>
+            void 
+            extract_dag(const spec& spec, dag<FI>& dag)
+            {
+                assert(FI == spec.fanin);
+                dag.reset(spec.get_nr_in(), spec.nr_steps);
+
+                auto svar_offset = 0;
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    const auto nr_svars_for_i = nr_svar_map[i];
+                    for (int j = 0; j < nr_svars_for_i; j++) {
+                        const auto sel_var = get_sel_var(svar_offset + j);
+                        if (solver->var_value(sel_var)) {
+                            const auto& fanins = svar_map[svar_offset + j];
+                            if (spec.verbosity) {
+                                printf("  with operands ");
+                                for (int k = 0; k < spec.fanin; k++) {
+                                    printf("x_%d ", fanins[k] + 1);
+                                }
+                            }
+                            dag.set_vertex(i, fanins);
+                        }
+                    }
+                    svar_offset += nr_svars_for_i;
+                }
+            }
+
+            void
+            print_solver_state(const spec& spec)
+            {
+                printf("\n");
+                printf("========================================"
+                        "========================================\n");
+                printf("  SOLVER STATE\n\n");
+
+                printf("  Nr. variables = %d\n", solver->nr_vars());
+                printf("  Nr. clauses = %d\n\n", solver->nr_clauses());
+
+                auto svar_offset = 0;
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    bool step_has_fanins = false;
+                    const auto nr_svars_for_i = nr_svar_map[i];
+                    for (int j = 0; j < nr_svars_for_i; j++) {
+                        const auto sel_var = get_sel_var(svar_offset + j);
+                        if (solver->var_value(sel_var)) {
+                            const auto& fanins = svar_map[svar_offset + j];
+                            printf("  x_%d has inputs ", 
+                                   spec.get_nr_in() + spec.get_nr_compiled_functions() + i + 1);
+                            for (int k = spec.fanin-1; k >= 0; k--) {
+                                printf("x_%d ", fanins[k] + 1);
+                            }
+                            step_has_fanins = true;
+                        }
+                    }
+                    svar_offset += nr_svars_for_i;
+                    if (!step_has_fanins) {
+                        printf("  no fanins found for x_%d\n",
+                                spec.get_nr_in() + spec.get_nr_compiled_functions() + i + 1);
+                    }
+
+                    printf("  f_%d = ", spec.get_nr_in() + spec.get_nr_compiled_functions() + i + 1);
+                    for (int oidx = nr_op_vars_per_step; oidx > 0; oidx--) {
+                        printf("%d", solver->var_value(get_op_var(spec, i, oidx)));
+                    }
+                    printf("0\n");
+
+                    printf("  tt_%d = ", spec.get_nr_in() + spec.get_nr_compiled_functions() + i + 1);
+                    for (int t = spec.get_tt_size() - 1; t >= 0; t--) {
+                        printf("%d", solver->var_value(get_sim_var(spec, i, t)));
+                    }
+                    printf("0\n\n");
+                }
+
+                for (int h = 0; h < spec.nr_nontriv; h++) {
+                    for (int i = 0; i < spec.nr_steps; i++) {
+                        printf("  g_%d_%d=%d\n", h + 1, 
+                                spec.get_nr_in() + spec.get_nr_compiled_functions() + i + 1,
+                                solver->var_value(get_out_var(spec, h, i)));
+                    }
+                }
+                printf("\n");
+
+                svar_offset = 0;
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    const auto nr_svars_for_i = nr_svar_map[i];
+                    for (int j = 0; j < nr_svars_for_i; j++) {
+                        printf("  s_%d", spec.get_nr_in() + spec.get_nr_compiled_functions() + i + 1);
+                        const auto& fanins = svar_map[j + svar_offset];
+                        for (auto fi : fanins) {
+                            printf("_%d", fi + 1);
+                        }
+                        printf("=%d\n", solver->var_value(get_sel_var(j + svar_offset)));
+                    }
+                    printf("\n");
+
+                    for (int oidx = nr_op_vars_per_step; oidx > 0; oidx--) {
+                        printf("  f_%d_%d=%d\n", 
+                                spec.get_nr_in() + spec.get_nr_compiled_functions() + i + 1, 
+                                oidx + 1,
+                                solver->var_value(get_op_var(spec, i, oidx))
+                              );
+                    }
+                    printf("  f_%d_1=0\n", spec.get_nr_in() + spec.get_nr_compiled_functions() + i + 1);
+                    printf("\n");
+
+                    for (int t = spec.get_tt_size() - 1; t >= 0; t--) {
+                        printf("  x_%d_%d=%d\n", spec.get_nr_in() + spec.get_nr_compiled_functions() + i+1, t + 2, 
+                                solver->var_value(get_sim_var(spec, i, t)));
+                    }
+                    printf("  x_%d_0=0\n", spec.get_nr_in() + spec.get_nr_compiled_functions() + i + 1);
+                    printf("\n");
+
+                    svar_offset += nr_svars_for_i;
+                }
+                printf("\n");
+
+                printf("========================================"
+                        "========================================\n");
+            }
+
+			/// Encodes specifciation for use in standard synthesis flow.
+            bool encode(const spec& spec)
+            {
+                assert(spec.nr_steps <= MAX_STEPS);
+
+                create_variables(spec);
+                if (!create_main_clauses(spec)) {
+                    return false;
+                }
+
+                if (!create_output_clauses(spec)) {
+                    return false;
+                }
+
+                if (!create_op_clauses(spec)) {
+                    return false;
+                }
+                
+                create_cardinality_constraints(spec);
+
+                if (spec.is_primitive_set()) {
+                    if (!create_primitive_clauses(spec))
+                        return false;
+                } else if (spec.add_nontriv_clauses) {
+                    create_nontriv_clauses(spec);
+                }
+
+                if (spec.add_alonce_clauses) {
+                    create_alonce_clauses(spec);
+                }
+
+                if (!spec.is_primitive_set() &&
+                    spec.add_noreapply_clauses) {
+                    create_noreapply_clauses(spec);
+                }
+
+                if (spec.add_colex_clauses) {
+                    create_colex_clauses(spec);
+                }
+
+                if (spec.add_lex_clauses) {
+                    create_lex_clauses(spec);
+                }
+                
+                if (spec.add_lex_func_clauses) {
+                    create_lex_func_clauses(spec);
+                }
+                
+                if (spec.add_symvar_clauses && !create_symvar_clauses(spec)) {
+                    return false;
+                }
+
+                return true;
+            }
+
+			/// Encodes specifciation for use in CEGAR based synthesis flow.
+            bool cegar_encode(const spec& spec)
+            {
+                assert(spec.nr_steps <= MAX_STEPS);
+
+                create_variables(spec);
+                
+                if (!create_output_clauses(spec)) {
+                    return false;
+                }
+                
+                if (!create_op_clauses(spec)) {
+                    return false;
+                }
+                
+                create_cardinality_constraints(spec);
+
+                if (spec.is_primitive_set()) {
+                    if (!create_primitive_clauses(spec))
+                        return false;
+                } else if (spec.add_nontriv_clauses) {
+                    create_nontriv_clauses(spec);
+                }
+
+                if (spec.add_alonce_clauses) {
+                    create_alonce_clauses(spec);
+                }
+                
+                if (!spec.is_primitive_set() && spec.add_noreapply_clauses) {
+                    create_noreapply_clauses(spec);
+                }
+                
+                if (spec.add_colex_clauses) {
+                    create_colex_clauses(spec);
+                }
+                
+                if (spec.add_lex_clauses) {
+                    create_lex_clauses(spec);
+                }
+
+                if (spec.add_lex_func_clauses) {
+                    create_lex_func_clauses(spec);
+                }
+
+                if (spec.add_symvar_clauses && !create_symvar_clauses(spec)) {
+                    return false;
+                }
+
+                return true;
+            }
+
+            /// Assumes that a solution has been found by the current encoding.
+            /// Blocks the current solution such that the solver is forced to
+            /// find different ones (if they exist).
+            bool
+            block_solution(const spec& spec)
+            {
+                int ctr = 0;
+                int svar_offset = 0;
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        int invert = 0;
+                        const auto op_var = get_op_var(spec, i, j);
+                        if (solver->var_value(op_var)) {
+                            invert = 1;
+                        }
+                        pabc::Vec_IntSetEntry(vLits, ctr++,
+                                pabc::Abc_Var2Lit(get_op_var(spec, i, j),
+                                    invert));
+                    }
+
+                    const auto nr_svars_for_i = nr_svar_map[i];
+                    for (int j = 0; j < nr_svars_for_i; j++) {
+                        const auto sel_var = get_sel_var(svar_offset + j);
+                        if (solver->var_value(sel_var)) {
+                            pabc::Vec_IntSetEntry(vLits, ctr++,
+                                    pabc::Abc_Var2Lit(sel_var, 1));
+                            break;
+                        }
+                    }
+
+                    svar_offset += nr_svars_for_i;
+                }
+                
+                return solver->add_clause(
+                            pabc::Vec_IntArray(vLits), 
+                            pabc::Vec_IntArray(vLits) + ctr);
+            }
+
+
+            /// Similar to block_solution, but blocks all solutions with the
+            /// same structure. This is more restrictive, since the other
+            /// method allows for the same structure but different operators.
+            bool
+            block_struct_solution(const spec& spec)
+            {
+                int ctr = 0;
+                int svar_offset = 0;
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    const auto nr_svars_for_i = nr_svar_map[i];
+                    for (int j = 0; j < nr_svars_for_i; j++) {
+                        const auto sel_var = get_sel_var(svar_offset + j);
+                        if (solver->var_value(sel_var)) {
+                            pabc::Vec_IntSetEntry(vLits, ctr++,
+                                    pabc::Abc_Var2Lit(sel_var, 1));
+                            break;
+                        }
+                    }
+
+                    svar_offset += nr_svars_for_i;
+                }
+
+                return solver->add_clause(
+                            pabc::Vec_IntArray(vLits), 
+                            pabc::Vec_IntArray(vLits) + ctr);
+            }
+    };
+}
+
diff --git a/lib/percy/percy/encoders/ssv_fence2_encoder.hpp b/lib/percy/percy/encoders/ssv_fence2_encoder.hpp
new file mode 100644
index 0000000..ea7954f
--- /dev/null
+++ b/lib/percy/percy/encoders/ssv_fence2_encoder.hpp
@@ -0,0 +1,894 @@
+#pragma once
+
+#include "encoder.hpp"
+#include "../fence.hpp"
+
+namespace percy
+{
+    class ssv_fence2_encoder : public fence_encoder
+    {
+    private:
+        int level_dist[32]; // How many steps are below a certain level
+        int nr_levels; // The number of levels in the Boolean fence
+        int nr_op_vars;
+        int nr_sim_vars;
+        int nr_sel_vars;
+        int nr_res_vars;
+        int total_nr_vars;
+        int sel_offset;
+        int res_offset;
+        int ops_offset;
+        int sim_offset;
+
+        pabc::Vec_Int_t* vLits; // Dynamic vector of literals
+
+        static const int NR_SIM_TTS = 32;
+        std::vector<kitty::dynamic_truth_table> sim_tts { NR_SIM_TTS };
+
+        bool fix_output_sim_vars(const spec& spec, int  t)
+        {
+            if (spec.is_dont_care(0, t + 1)) {
+                return true;
+            }
+            auto ilast_step = spec.nr_steps - 1;
+            auto outbit = kitty::get_bit(
+                spec[spec.synth_func(0)], t + 1);
+            if ((spec.out_inv >> spec.synth_func(0)) & 1) {
+                outbit = 1 - outbit;
+            }
+            const auto sim_var = get_sim_var(spec, ilast_step, t);
+            pabc::lit sim_lit = pabc::Abc_Var2Lit(sim_var, 1 - outbit);
+            return solver->add_clause(&sim_lit, &sim_lit + 1);
+        }
+
+        void vfix_output_sim_vars(const spec& spec, int  t)
+        {
+            auto ilast_step = spec.nr_steps - 1;
+
+            auto outbit = kitty::get_bit(
+                spec[spec.synth_func(0)], t + 1);
+            if ((spec.out_inv >> spec.synth_func(0)) & 1) {
+                outbit = 1 - outbit;
+            }
+            const auto sim_var = get_sim_var(spec, ilast_step, t);
+            pabc::lit sim_lit = pabc::Abc_Var2Lit(sim_var, 1 - outbit);
+            (void)solver->add_clause(&sim_lit, &sim_lit + 1);
+        }
+
+
+
+    public:
+        const int OP_VARS_PER_STEP = 3;
+
+        ssv_fence2_encoder(solver_wrapper& solver)
+        {
+            // TODO: compute better upper bound on number of literals
+            vLits = pabc::Vec_IntAlloc(128);
+            set_solver(solver);
+        }
+
+        ~ssv_fence2_encoder()
+        {
+            pabc::Vec_IntFree(vLits);
+        }
+
+        int nr_svars_for_step(const spec& spec, int i) const
+        {
+            // Determine the level of this step.
+            const auto level = get_level(spec, i + spec.nr_in);
+            auto nr_svars_for_i = 0;
+            assert(level > 0);
+            for (auto k = first_step_on_level(level - 1);
+                k < first_step_on_level(level); k++) {
+                // We select k as fanin 2, so have k options 
+                // (j={0,...,(k-1)}) left for fanin 1.
+                nr_svars_for_i += k;
+            }
+
+            return nr_svars_for_i;
+        }
+
+        void 
+        update_level_map(const spec& spec, const fence& f)
+        {
+            nr_levels = f.nr_levels();
+            level_dist[0] = spec.nr_in;
+            for (int i = 1; i <= nr_levels; i++) {
+                level_dist[i] = level_dist[i-1] + f.at(i-1);
+            }
+        }
+
+        /*******************************************************************
+            Returns the level (in the Boolean chain) of the specified step.
+        *******************************************************************/
+        int 
+        get_level(const spec& spec, int step_idx) const
+        {
+            // PIs are considered to be on level zero.
+            if (step_idx < spec.nr_in) {
+                return 0;
+            } else if (step_idx == spec.nr_in) { 
+                // First step is always on level one
+                return 1;
+            }
+            for (int i = 0; i <= nr_levels; i++) {
+                if (level_dist[i] > step_idx) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        /*******************************************************************
+            Returns the index of the first step on the specified level.
+        *******************************************************************/
+        int 
+        first_step_on_level(int level) const
+        {
+            if (level == 0) { return 0; }
+            return level_dist[level-1];
+        }
+
+        int 
+        last_step_on_level(int level) const
+        {
+            return first_step_on_level(level + 1) - 1;
+        }
+
+        int
+        get_op_var(const spec& spec, int step_idx, int var_idx) const
+        {
+            assert(step_idx < spec.nr_steps);
+            assert(var_idx < OP_VARS_PER_STEP);
+
+            return ops_offset + step_idx * OP_VARS_PER_STEP + var_idx;
+        }
+
+        int get_sel_var(const spec& spec, int idx, int var_idx) const
+        {
+            assert(idx < spec.nr_steps);
+            assert(var_idx < nr_svars_for_step(spec, idx));
+            auto offset = 0;
+            for (int i = 0; i < idx; i++) {
+                offset += nr_svars_for_step(spec, i);
+            }
+            return sel_offset + offset + var_idx;
+        }
+
+        int get_res_var(const spec& spec, int step_idx, int res_var_idx) const
+        {
+            auto offset = 0;
+            for (int i = 0; i < step_idx; i++) {
+                offset += (nr_svars_for_step(spec, i) + 1) * (1 + 2);
+            }
+
+            return res_offset + offset + res_var_idx;
+        }
+
+        int get_sim_var(const spec& spec, int step_idx, int t) const
+        {
+            assert(step_idx < spec.nr_steps);
+            assert(t < spec.get_tt_size());
+
+            return sim_offset + spec.get_tt_size() * step_idx + t;
+        }
+
+        void create_variables(const spec& spec)
+        {
+            nr_op_vars = spec.nr_steps * OP_VARS_PER_STEP;
+            nr_sim_vars = spec.nr_steps * spec.get_tt_size();
+
+            // Ensure that steps are constrained to the proper level.
+            nr_sel_vars = 0;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                nr_sel_vars += nr_svars_for_step(spec, i);
+            }
+
+            sel_offset = 0;
+            ops_offset = nr_sel_vars;
+            sim_offset = nr_sel_vars + nr_op_vars;
+            total_nr_vars = nr_sel_vars + nr_op_vars + nr_sim_vars;
+
+            if (spec.verbosity) {
+                printf("creating %d sel_vars\n", nr_sel_vars);
+                printf("creating %d op_vars\n", nr_op_vars);
+                printf("creating %d sim_vars\n", nr_sim_vars);
+            }
+
+            solver->set_nr_vars(total_nr_vars);
+        }
+
+        void cegar_create_variables(const spec& spec)
+        {
+            nr_op_vars = spec.nr_steps * OP_VARS_PER_STEP;
+            nr_sim_vars = spec.nr_steps * spec.get_tt_size();
+
+            // Ensure that steps are constrained to the proper level.
+            nr_sel_vars = 0;
+            nr_res_vars = 0;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto nr_svars_for_i = nr_svars_for_step(spec, i);
+                nr_sel_vars += nr_svars_for_i;
+                nr_res_vars += (nr_svars_for_i + 1) * (1 + 2);
+            }
+
+            sel_offset = 0;
+            res_offset = nr_sel_vars;
+            ops_offset = nr_sel_vars + nr_res_vars;
+            sim_offset = nr_sel_vars + nr_res_vars + nr_op_vars;
+            total_nr_vars = nr_sel_vars + nr_res_vars + nr_op_vars + nr_sim_vars;
+
+            if (spec.verbosity) {
+                printf("creating %d sel_vars\n", nr_sel_vars);
+                printf("creating %d res_vars\n", nr_res_vars);
+                printf("creating %d op_vars\n", nr_op_vars);
+                printf("creating %d sim_vars\n", nr_sim_vars);
+            }
+
+            solver->set_nr_vars(total_nr_vars);
+        }
+
+        bool create_main_clauses(const spec& spec)
+        {
+            for (int t = 0; t < spec.get_tt_size(); t++) {
+                if (!create_tt_clauses(spec, t)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        
+
+        /*******************************************************************
+            Add clauses that prevent trivial variable projection and
+            constant operators from being synthesized.
+        *******************************************************************/
+
+        bool create_nontriv_clauses(const spec& spec)
+        {
+            int pLits[3];
+            bool status = true;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                // Dissallow the constant zero operator.
+                pLits[0] = pabc::Abc_Var2Lit(get_op_var(spec, i, 0), 0);
+                pLits[1] = pabc::Abc_Var2Lit(get_op_var(spec, i, 1), 0);
+                pLits[2] = pabc::Abc_Var2Lit(get_op_var(spec, i, 2), 0);
+                status &= solver->add_clause(pLits, pLits + 3);
+
+                // Dissallow variable projections.
+                pLits[0] = pabc::Abc_Var2Lit(get_op_var(spec, i, 0), 0);
+                pLits[1] = pabc::Abc_Var2Lit(get_op_var(spec, i, 1), 1);
+                pLits[2] = pabc::Abc_Var2Lit(get_op_var(spec, i, 2), 1);
+                status &= solver->add_clause(pLits, pLits + 3);
+
+                pLits[0] = pabc::Abc_Var2Lit(get_op_var(spec, i, 0), 1);
+                pLits[1] = pabc::Abc_Var2Lit(get_op_var(spec, i, 1), 0);
+                pLits[2] = pabc::Abc_Var2Lit(get_op_var(spec, i, 2), 1);
+                status &= solver->add_clause(pLits, pLits + 3);
+            }
+
+            return status;
+        }
+
+        bool create_tt_clauses(const spec& spec, int t) override
+        {
+            auto ret = true;
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                auto level = get_level(spec, i + spec.nr_in);
+                assert(level > 0);
+                auto ctr = 0;
+                for (int k = first_step_on_level(level - 1);
+                    k < first_step_on_level(level); k++) {
+                    for (int j = 0; j < k; j++) {
+                        const auto sel_var = get_sel_var(spec, i, ctr++);
+                        ret &= add_simulation_clause(spec, t, i, j, k, 0, 0, 1, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, 0, 1, 0, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, 0, 1, 1, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, 1, 0, 0, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, 1, 0, 1, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, 1, 1, 0, sel_var);
+                        ret &= add_simulation_clause(spec, t, i, j, k, 1, 1, 1, sel_var);
+                    }
+                }
+            }
+
+            ret &= fix_output_sim_vars(spec, t);
+
+            return ret;
+        }
+
+        void vcreate_tt_clauses(const spec& spec, int t)
+        {
+            for (int i = 0; i < spec.nr_steps; i++) {
+                auto level = get_level(spec, i + spec.nr_in);
+                assert(level > 0);
+                auto ctr = 0;
+                for (int k = first_step_on_level(level - 1);
+                    k < first_step_on_level(level); k++) {
+                    for (int j = 0; j < k; j++) {
+                        const auto sel_var = get_sel_var(spec, i, ctr++);
+                        add_simulation_clause(spec, t, i, j, k, 0, 0, 1, sel_var);
+                        add_simulation_clause(spec, t, i, j, k, 0, 1, 0, sel_var);
+                        add_simulation_clause(spec, t, i, j, k, 0, 1, 1, sel_var);
+                        add_simulation_clause(spec, t, i, j, k, 1, 0, 0, sel_var);
+                        add_simulation_clause(spec, t, i, j, k, 1, 0, 1, sel_var);
+                        add_simulation_clause(spec, t, i, j, k, 1, 1, 0, sel_var);
+                        add_simulation_clause(spec, t, i, j, k, 1, 1, 1, sel_var);
+                    }
+                }
+            }
+            fix_output_sim_vars(spec, t);
+        }
+
+        void create_cardinality_constraints(const spec& spec)
+        {
+            std::vector<int> svars;
+            std::vector<int> rvars;
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                svars.clear();
+                rvars.clear();
+                const auto level = get_level(spec, spec.nr_in + i);
+                auto svar_ctr = 0;
+                for (int k = first_step_on_level(level - 1);
+                    k < first_step_on_level(level); k++) {
+                    for (int j = 0; j < k; j++) {
+                        const auto sel_var = get_sel_var(spec, i, svar_ctr++);
+                        svars.push_back(sel_var);
+                    }
+                }
+                const int nr_res_vars = (1 + 2) * (svars.size() + 1);
+                for (int j = 0; j < nr_res_vars; j++) {
+                    rvars.push_back(get_res_var(spec, i, j));
+                }
+                create_cardinality_circuit(solver, svars, rvars, 1);
+
+                // Ensure that the fanin cardinality for each step i 
+                // is exactly FI.
+                const auto fi_var =
+                    get_res_var(spec, i, svars.size() * (1 + 2) + 1);
+                auto fi_lit = pabc::Abc_Var2Lit(fi_var, 0);
+                (void)solver->add_clause(&fi_lit, &fi_lit + 1);
+            }
+        }
+
+        /// Ensure that each gate has 2 operands.
+        bool create_fanin_clauses(const spec& spec)
+        {
+            bool res = true;
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto nr_svars_for_i = nr_svars_for_step(spec, i);
+                for (int j = 0; j < nr_svars_for_i; j++) {
+                    const auto sel_var = get_sel_var(spec, i, j);
+                    pabc::Vec_IntSetEntry(vLits, j, pabc::Abc_Var2Lit(sel_var, 0));
+                }
+                res &= solver->add_clause(pabc::Vec_IntArray(vLits), 
+                        pabc::Vec_IntArray(vLits) + nr_svars_for_i);
+            }
+            return res;
+        }
+
+        /// Add clauses which ensure that every step is used at least once.
+        void create_alonce_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                auto ctr = 0;
+                const auto level = get_level(spec, i + spec.nr_in);
+                const auto idx = spec.nr_in + i;
+                for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                    auto levelp = get_level(spec, ip + spec.nr_in);
+                    assert(levelp >= level);
+                    if (levelp == level) {
+                        continue;
+                    }
+                    auto svctr = 0;
+                    for (int k = first_step_on_level(levelp - 1);
+                        k < first_step_on_level(levelp); k++) {
+                        for (int j = 0; j < k; j++) {
+                            if (j != idx && k != idx) {
+                                svctr++;
+                                continue;
+                            }
+                            const auto sel_var = get_sel_var(spec, ip, svctr++);
+                            pabc::Vec_IntSetEntry(
+                                vLits,
+                                ctr++,
+                                pabc::Abc_Var2Lit(sel_var, 0));
+                        }
+                    }
+                }
+                solver->add_clause(pabc::Vec_IntArray(vLits), pabc::Vec_IntArray(vLits) + ctr);
+            }
+        }
+
+        bool add_simulation_clause(
+            const spec& spec,
+            const int t,
+            const int i,
+            const int j,
+            const int k,
+            const int a,
+            const int b,
+            const int c,
+            int sel_var)
+        {
+            int pLits[5];
+            int ctr = 0;
+
+            if (j < spec.nr_in) {
+                if ((((t + 1) & (1 << j)) ? 1 : 0) != b) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, j - spec.nr_in, t), b);
+            }
+
+            if (k < spec.nr_in) {
+                if ((((t + 1) & (1 << k)) ? 1 : 0) != c) {
+                    return true;
+                }
+            } else {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_sim_var(spec, k - spec.nr_in, t), c);
+            }
+
+            pLits[ctr++] = pabc::Abc_Var2Lit(sel_var, 1);
+            pLits[ctr++] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), a);
+
+            if (b | c) {
+                pLits[ctr++] = pabc::Abc_Var2Lit(
+                    get_op_var(spec, i, ((c << 1) | b) - 1), 1 - a);
+            }
+
+            return solver->add_clause(pLits, pLits + ctr);
+        }
+
+        void create_noreapply_clauses(const spec& spec)
+        {
+            int pLits[3];
+
+            // Disallow:
+            // x_i : (j, k)
+            // x_ip: (j, i) OR (k, i)
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto idx = spec.nr_in + i;
+                const auto level = get_level(spec, idx);
+
+                for (int ip = i+1; ip < spec.nr_steps; ip++) {
+                    const auto levelp = get_level(spec, ip +
+                            spec.nr_in);
+                    if (levelp == level) { 
+                        // A node cannot have a node on the same level in
+                        // its fanin.
+                        continue;
+                    }
+
+                    auto svar_ctr = 0;
+                    for (int k = first_step_on_level(level-1); 
+                        k < first_step_on_level(level); k++) {
+                        for (int j = 0; j < k; j++) {
+                            const auto sel_var = get_sel_var(spec, i, svar_ctr++);
+                            pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+
+                            // Note that it's possible for node ip to never have
+                            // i as its second fanin.
+                            auto svar_ctrp = 0;
+                            for (int kp = first_step_on_level(levelp-1); 
+                                    kp < first_step_on_level(levelp); kp++) {
+                                for (int jp = 0; jp < kp; jp++) {
+                                    if (kp == idx && (jp == j || jp == k)) {
+                                        const auto sel_varp = get_sel_var(spec, ip, svar_ctrp);
+                                        pLits[1] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                        auto status = solver->add_clause(pLits, pLits + 2);
+                                        assert(status);
+                                    }
+                                    svar_ctrp++;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Disallow:
+            // x_i  : (j, k)
+            // x_ip : (j, k)
+            // x_ipp: (i,ip)
+            for (int i = 0; i < spec.nr_steps; i++) {
+                const auto level = get_level(spec, spec.nr_in + i);
+
+                for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                    const auto levelp = get_level(spec, ip + spec.nr_in);
+                    if (levelp != level) {
+                        // If they are not on the same level they 
+                        // cannot have the same fanin
+                        continue;
+                    }
+
+                    for (int ipp = ip + 1; ipp < spec.nr_steps; ipp++) {
+                        const auto levelpp = get_level(spec, ipp + spec.nr_in);
+                        if (levelpp == level) {
+                            continue;
+                        }
+
+                        auto svar_ctr = 0;
+                        for (int k = first_step_on_level(level - 1);
+                            k < first_step_on_level(level); k++) {
+                            for (int j = 0; j < k; j++) {
+                                auto svar_ctrpp = 0;
+                                for (int kpp = first_step_on_level(levelpp - 1);
+                                    kpp < first_step_on_level(levelpp); kpp++) {
+                                    for (int jpp = 0; jpp < kpp; jpp++) {
+                                        if ((jpp == spec.nr_in + i) && (kpp == spec.nr_in + ip)) {
+                                            const auto sel_var = get_sel_var(spec, i, svar_ctr);
+                                            const auto sel_varp = get_sel_var(spec, ip, svar_ctr);
+                                            const auto sel_varpp = get_sel_var(spec, ipp, svar_ctrpp);
+                                            pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                                            pLits[1] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                            pLits[2] = pabc::Abc_Var2Lit(sel_varpp, 1);
+                                            (void)solver->add_clause(pLits, pLits + 3);
+                                        }
+                                        svar_ctrpp++;
+                                    }
+                                }
+                                svar_ctr++;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        /// Extracts chain from encoded CNF solution.
+        void extract_chain(const spec& spec, chain& chain) override
+        {
+            chain.reset(spec.nr_in, 1, spec.nr_steps, 2);
+
+            kitty::dynamic_truth_table op(2);
+            for (int i = 0; i < spec.nr_steps; i++) {
+                for (int j = 0; j < OP_VARS_PER_STEP; j++) {
+                    if (solver->var_value(get_op_var(spec, i, j)))
+                        kitty::set_bit(op, j + 1); 
+                    else
+                        kitty::clear_bit(op, j + 1); 
+                }
+
+                if (spec.verbosity) {
+                    printf("  step x_%d performs operation\n  ", 
+                            i+spec.nr_in+1);
+                    kitty::print_binary(op, std::cout);
+                    printf("\n");
+                }
+
+                auto ctr = 0;
+                const auto level = get_level(spec, spec.nr_in + i);
+                for (int k = first_step_on_level(level - 1);
+                    k < first_step_on_level(level); k++) {
+                    for (int j = 0; j < k; j++) {
+                        const auto sel_var = get_sel_var(spec, i, ctr++);
+                        if (solver->var_value(sel_var)) {
+                            if (spec.verbosity) {
+                                printf("  with operands ");
+                                printf("x_%d ", j + 1);
+                                printf("x_%d ", k + 1);
+                            }
+                            chain.set_step(i, j, k, op);
+                            break;
+                        }
+                    }
+                }
+
+                if (spec.verbosity) {
+                    printf("\n");
+                }
+            }
+
+            // TODO: support multiple outputs
+            chain.set_output(0,
+                ((spec.nr_steps + spec.nr_in) << 1) +
+                ((spec.out_inv) & 1));
+        }
+
+        void create_colex_clauses(const spec& spec)
+        {
+            int pLits[2];
+
+            for (int i = 0; i < spec.nr_steps - 1; i++) {
+                const auto level = get_level(spec, i + spec.nr_in);
+                const auto levelp = get_level(spec, i + 1 + spec.nr_in);
+                int svar_ctr = 0;
+                for (int k = first_step_on_level(level-1); 
+                        k < first_step_on_level(level); k++) {
+                    for (int j = 0; j < k; j++) {
+                        if (k < 2) {
+                            svar_ctr++;
+                            continue;
+                        }
+                        const auto sel_var = get_sel_var(spec, i, svar_ctr);
+                        pLits[0] = pabc::Abc_Var2Lit(sel_var, 1);
+                        int svar_ctrp = 0;
+                        for (int kp = first_step_on_level(levelp - 1);
+                            kp < first_step_on_level(levelp); kp++) {
+                            for (int jp = 0; jp < kp; jp++) {
+                                if ((kp == k && jp < j) || (kp < k)) {
+                                    const auto sel_varp = get_sel_var(spec, i + 1, svar_ctrp);
+                                    pLits[1] = pabc::Abc_Var2Lit(sel_varp, 1);
+                                    (void)solver->add_clause(pLits, pLits + 2);
+                                }
+                                svar_ctrp++;
+                            }
+                        }
+                        svar_ctr++;
+                    }
+                }
+            }
+        }
+
+/*
+        void 
+        create_colex_func_clauses(const spec& spec)
+        {
+            for (int i = 0; i < spec.nr_steps-1; i++) {
+                for (int k = 1; k < spec.nr_in+i; k++) {
+                    for (int j = 0; j < k; j++) {
+                        pLits[0] = pabc::Abc_Var2Lit(spec.selection_vars[i][j][k], 1);
+                        pLits[1] = pabc::Abc_Var2Lit(spec.selection_vars[i+1][j][k], 1);
+
+                        pLits[2] = 
+                            pabc::Abc_Var2Lit(get_op_var(spec, i, 1, 1), 1);
+                        pLits[3] = 
+                            pabc::Abc_Var2Lit(get_op_var(spec, i+1, 1, 1), 0);
+                        solver_add_clause(this->solver, pLits, pLits+4);
+
+                        pLits[3] = 
+                            pabc::Abc_Var2Lit(get_op_var(spec, i, 1, 0), 1);
+                        pLits[4] = 
+                            pabc::Abc_Var2Lit(get_op_var(spec, i+1, 1, 1), 0);
+                        solver_add_clause(this->solver, pLits, pLits+5);
+                        pLits[4] = 
+                            pabc::Abc_Var2Lit(get_op_var(spec, i+1, 1, 0), 0);
+                        solver_add_clause(this->solver, pLits, pLits+5);
+
+                        pLits[4] = 
+                            pabc::Abc_Var2Lit(get_op_var(spec, i, 0, 1), 1);
+                        pLits[5] = 
+                            pabc::Abc_Var2Lit(get_op_var(spec, i+1, 1, 1), 0);
+                        solver_add_clause(this->solver, pLits, pLits+6);
+                        pLits[5] = 
+                            pabc::Abc_Var2Lit(get_op_var(spec, i+1, 1, 0), 0);
+                        solver_add_clause(this->solver, pLits, pLits+6);
+                        pLits[5] = 
+                            pabc::Abc_Var2Lit(get_op_var(spec, i+1, 0, 1), 0);
+                        solver_add_clause(this->solver, pLits, pLits+6);
+                    }
+                }
+            }
+        }
+        */
+
+        void create_symvar_clauses(const spec& spec)
+        {
+            for (int q = 1; q < spec.nr_in; q++) {
+                for (int p = 0; p < q; p++) {
+                    auto symm = true;
+                    for (int i = 0; i < spec.nr_nontriv; i++) {
+                        auto& f = spec[spec.synth_func(i)];
+                        if (!(swap(f, p, q) == f)) {
+                            symm = false;
+                            break;
+                        }
+                    }
+                    if (!symm) {
+                        continue;
+                    }
+                    for (int i = 1; i < spec.nr_steps; i++) {
+                        const auto level = get_level(spec, i + spec.nr_in);
+                        int svar_ctr = 0;
+                        for (int k = first_step_on_level(level - 1);
+                            k < first_step_on_level(level); k++) {
+                            for (int j = 0; j < k; j++) {
+                                if (!(j == q || k == q) || j == p) {
+                                    svar_ctr++;
+                                    continue;
+                                }
+                                const auto sel_var = get_sel_var(spec, i, svar_ctr);
+                                pabc::Vec_IntSetEntry(vLits, 0, pabc::Abc_Var2Lit(sel_var, 1));
+                                auto ctr = 1;
+                                for (int ip = 0; ip < i; ip++) {
+                                    const auto levelp = get_level(spec, spec.nr_in + ip);
+                                    auto svar_ctrp = 0;
+                                    for (int kp = first_step_on_level(levelp - 1);
+                                        kp < first_step_on_level(levelp); kp++) {
+                                        for (int jp = 0; jp < kp; jp++) {
+                                            if (jp == p || kp == p) {
+                                                const auto sel_varp = get_sel_var(spec, ip, svar_ctrp);
+                                                pabc::Vec_IntSetEntry(vLits, ctr++,
+                                                    pabc::Abc_Var2Lit(sel_varp, 0));
+                                            }
+                                            svar_ctrp++;
+                                        }
+                                    }
+                                }
+                                (void)solver->add_clause(Vec_IntArray(vLits), Vec_IntArray(vLits) + ctr);
+                                svar_ctr++;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        /// Encodes specifciation for use in fence-based synthesis flow.
+        bool encode(const spec& spec, const fence& f) override
+        {
+            assert(spec.nr_steps == f.nr_nodes());
+
+            bool success = true;
+
+            update_level_map(spec, f);
+            create_variables(spec);
+            success = create_main_clauses(spec);
+            if (!success) {
+                return false;
+            }
+
+            if (!create_fanin_clauses(spec)) {
+                return false;
+            }
+
+            if (spec.add_nontriv_clauses) {
+                create_nontriv_clauses(spec);
+            }
+
+            if (spec.add_alonce_clauses) {
+                create_alonce_clauses(spec);
+            }
+            if (spec.add_noreapply_clauses) {
+                create_noreapply_clauses(spec);
+            }
+            if (spec.add_colex_clauses) {
+                create_colex_clauses(spec);
+            }
+            /*
+            if (spec.add_colex_func_clauses) {
+                create_colex_func_clauses(spec);
+            }
+*/
+            if (spec.add_symvar_clauses) {
+                create_symvar_clauses(spec);
+            }
+
+            return true;
+        }
+
+        /// Encodes specifciation for use in CEGAR based synthesis flow.
+        bool cegar_encode(const spec& spec, const fence& f) override
+        {
+            assert(spec.nr_steps == f.nr_nodes());
+
+            update_level_map(spec, f);
+            cegar_create_variables(spec);
+            
+            if (!create_fanin_clauses(spec)) {
+                return false;
+            }
+            create_cardinality_constraints(spec);
+
+            if (spec.add_nontriv_clauses) {
+                create_nontriv_clauses(spec);
+            }
+            if (spec.add_alonce_clauses) {
+                create_alonce_clauses(spec);
+            }
+            if (spec.add_noreapply_clauses) {
+                create_noreapply_clauses(spec);
+            }
+            if (spec.add_colex_clauses) {
+                create_colex_clauses(spec);
+            }
+            /*
+            if (spec.add_colex_func_clauses) {
+                create_colex_func_clauses(spec);
+            }
+            */
+            if (spec.add_symvar_clauses) {
+                create_symvar_clauses(spec);
+            }
+
+            return true;
+        }
+
+        /// Assumes that a solution has been found by the current encoding.
+        /// Blocks the current solution such that the solver is forced to
+        /// find different ones (if they exist).
+        /*
+        bool block_solution(const spec& spec)
+        {
+            // TODO: implement!
+            return false;
+        }
+
+
+        /// Similar to block_solution, but blocks all solutions with the
+        /// same structure. This is more restrictive, since the other
+        /// method allows for the same structure but different operators.
+        bool block_struct_solution(const spec& spec)
+        {
+            // TODO: implement!
+            return false;
+        }
+        */
+
+        kitty::dynamic_truth_table& simulate(const spec& spec) override
+        {
+            int op_inputs[2] = { 0, 0 };
+
+            for (int i = 0; i < spec.nr_steps; i++) {
+                char op = 0;
+                if (solver->var_value(get_op_var(spec, i, 0))) {
+                    op |= (1 << 1);
+                }
+                if (solver->var_value(get_op_var(spec, i, 1))) {
+                    op |= (1 << 2);
+                }
+                if (solver->var_value(get_op_var(spec, i, 2))) {
+                    op |= (1 << 3);
+                }
+
+                auto ctr = 0;
+                auto brk = false;
+                const auto level = get_level(spec, spec.nr_in + i);
+                for (int k = first_step_on_level(level - 1); 
+                    k < first_step_on_level(level) && !brk; k++) {
+                    for (int j = 0; j < k && !brk; j++) {
+                        const auto sel_var = get_sel_var(spec, i, ctr++);
+                        if (solver->var_value(sel_var)) {
+                            op_inputs[0] = j;
+                            op_inputs[1] = k;
+                            brk = true;
+                        }
+                    }
+                }
+
+                auto& tt_step = sim_tts[spec.nr_in + i];
+                switch (op) {
+                case 2: // x1^(~x2)
+                    tt_step = sim_tts[op_inputs[0]] & (~sim_tts[op_inputs[1]]);
+                    break;
+                case 4: // (~x1)^x2
+                    tt_step = (~sim_tts[op_inputs[0]]) & sim_tts[op_inputs[1]];
+                    break;
+                case 6: // XOR
+                    tt_step = sim_tts[op_inputs[0]] ^ sim_tts[op_inputs[1]];
+                    break;
+                case 8: // AND
+                    tt_step = sim_tts[op_inputs[0]] & sim_tts[op_inputs[1]];
+                    break;
+                case 14: // OR
+                    tt_step = sim_tts[op_inputs[0]] | sim_tts[op_inputs[1]];
+                    break;
+                default:
+                    fprintf(stderr, "Error: unknown operator\n");
+                    assert(false);
+                    exit(1);
+                }
+            }
+
+            return sim_tts[spec.nr_in + spec.nr_steps - 1];
+        }
+
+        void reset_sim_tts(int nr_in) override 
+        {
+            for (int i = 0; i < NR_SIM_TTS; i++) {
+                sim_tts[i] = kitty::dynamic_truth_table(nr_in);
+                if (i < nr_in) {
+                    kitty::create_nth_var(sim_tts[i], i);
+                }
+            }
+        }
+    };
+}
+
diff --git a/lib/percy/percy/encoders/ssv_fence_encoder.hpp b/lib/percy/percy/encoders/ssv_fence_encoder.hpp
new file mode 100644
index 0000000..ff25d85
--- /dev/null
+++ b/lib/percy/percy/encoders/ssv_fence_encoder.hpp
@@ -0,0 +1,845 @@
+#pragma once
+
+#include "encoder.hpp"
+#include "../fence.hpp"
+
+namespace percy
+{
+    class ssv_fence_encoder : public fence_encoder, public enumerating_encoder
+    {
+        private:
+            int level_dist[65]; // How many steps are below a certain level
+            int nr_levels; // The number of levels in the Boolean fence
+            int nr_op_vars_per_step;
+            int nr_op_vars;
+            int nr_out_vars;
+            int nr_sim_vars;
+            int nr_sel_vars;
+            int sel_offset;
+            int ops_offset;
+            int out_offset;
+            int sim_offset;
+            int fence_offset;
+
+            pabc::Vec_Int_t* vLits; // Dynamic vector of literals
+            std::vector<std::vector<int>> svar_map;
+            std::vector<int> nr_svar_map;
+
+            static const int NR_SIM_TTS = 32;
+            std::vector<kitty::dynamic_truth_table> sim_tts{ NR_SIM_TTS };
+
+        public:
+            ssv_fence_encoder(solver_wrapper& solver)
+            {
+                // TODO: compute better upper bound on number of literals
+                vLits = pabc::Vec_IntAlloc(128);
+                set_solver(solver);
+            }
+
+            ~ssv_fence_encoder()
+            {
+                pabc::Vec_IntFree(vLits);
+            }
+
+            void 
+            update_level_map(const spec& spec, const fence& f)
+            {
+                nr_levels = f.nr_levels();
+                level_dist[0] = spec.get_nr_in();
+                for (int i = 1; i <= nr_levels; i++) {
+                    level_dist[i] = level_dist[i-1] + f.at(i-1);
+                }
+            }
+
+            /*******************************************************************
+                Returns the level (in the Boolean chain) of the specified step.
+            *******************************************************************/
+            int 
+            get_level(const spec& spec, int step_idx) const
+            {
+                // PIs are considered to be on level zero.
+                if (step_idx < spec.get_nr_in()) {
+                    return 0;
+                } else if (step_idx == spec.get_nr_in()) { 
+                    // First step is always on level one
+                    return 1;
+                }
+                for (int i = 0; i <= nr_levels; i++) {
+                    if (level_dist[i] > step_idx) {
+                        return i;
+                    }
+                }
+                return -1;
+            }
+
+            /*******************************************************************
+                Returns the index of the first step on the specified level.
+            *******************************************************************/
+            int 
+            first_step_on_level(int level) const
+            {
+                if (level == 0) { return 0; }
+                return level_dist[level-1];
+            }
+
+            int 
+            last_step_on_level(int level) const
+            {
+                return first_step_on_level(level + 1) - 1;
+            }
+
+            int
+            get_op_var(const spec& spec, int step_idx, int var_idx) const
+            {
+                assert(step_idx < spec.nr_steps);
+                assert(var_idx > 0);
+                assert(var_idx <= nr_op_vars_per_step);
+
+                return ops_offset + step_idx * nr_op_vars_per_step + var_idx-1;
+            }
+
+            int
+            get_sel_var(int var_idx) const
+            {
+                assert(var_idx < nr_sel_vars);
+
+                return sel_offset + var_idx;
+            }
+
+            int
+            get_sim_var(const spec& spec, int step_idx, int t) const
+            {
+                assert(step_idx < spec.nr_steps);
+                assert(t < spec.get_tt_size());
+
+                return sim_offset + spec.get_tt_size() * step_idx + t;
+            }
+
+            int 
+            get_out_var(const spec& spec, int h, int i) const
+            {
+                assert(h < spec.nr_nontriv);
+                assert(i < spec.nr_steps);
+
+                return out_offset + spec.nr_steps * h + i;
+            }
+
+            void 
+            create_variables(const spec& spec)
+            {
+                std::vector<int> fanins(spec.fanin);
+
+                nr_op_vars_per_step = ((1u << spec.fanin) - 1);
+                nr_op_vars = spec.nr_steps * nr_op_vars_per_step;
+                nr_out_vars = spec.nr_nontriv * spec.nr_steps;
+                nr_sim_vars = spec.nr_steps * spec.get_tt_size();
+
+                // Ensure that steps are constrained to the proper level.
+                nr_sel_vars = 0;
+                svar_map.clear();
+                nr_svar_map.resize(spec.nr_steps);
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    // Determine the level of this step.
+                    auto level = get_level(spec, i + spec.get_nr_in());
+                    auto nr_svars_for_i = 0;
+                    assert(level > 0);
+                    for (auto z = first_step_on_level(level-1); 
+                            z < first_step_on_level(level); z++) {
+                        fanin_init(fanins, spec.fanin - 1);
+                        do  {
+                            svar_map.push_back(fanins);
+                            nr_svars_for_i++;
+                        } while (fanin_inc(fanins, z));
+                    }
+                    nr_sel_vars += nr_svars_for_i;
+                    nr_svar_map[i] = nr_svars_for_i;
+                }
+
+                sel_offset = 0;
+                ops_offset = nr_sel_vars;
+                out_offset = nr_sel_vars + nr_op_vars;
+                sim_offset = nr_sel_vars + nr_op_vars + nr_out_vars;
+                fence_offset = nr_sel_vars + nr_op_vars + nr_out_vars +
+                    nr_sim_vars;
+
+                solver->set_nr_vars(nr_op_vars + nr_out_vars + nr_sim_vars + nr_sel_vars);
+            }
+
+            bool
+            create_main_clauses(const spec& spec)
+            {
+                for (int t = 0; t < spec.get_tt_size(); t++) {
+                    if (!create_tt_clauses(spec, t)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            void
+            create_output_clauses(const spec& spec)
+            {
+                // Every output points to an operand.
+                if (spec.nr_nontriv > 1) {
+                    for (int h = 0; h < spec.nr_nontriv; h++) {
+                        for (int i = 0; i < spec.nr_steps; i++) {
+                            pabc::Vec_IntSetEntry(vLits, i, 
+                                    pabc::Abc_Var2Lit(get_out_var(spec, h, i), 0));
+                            if (spec.verbosity) {
+                                printf("  output %d may point to step %d\n", 
+                                        h+1, spec.get_nr_in()+i+1);
+                            }
+                        }
+                        solver->add_clause(pabc::Vec_IntArray(vLits), 
+                                pabc::Vec_IntArray(vLits) + spec.nr_steps);
+                    }
+                }
+
+                // At least one of the outputs has to refer to the final
+                // operator, otherwise it may as well not be there.
+                const auto last_op = spec.nr_steps - 1;
+                for (int h = 0; h < spec.nr_nontriv; h++) {
+                    pabc::Vec_IntSetEntry(vLits, h, 
+                            pabc::Abc_Var2Lit(get_out_var(spec, h, last_op), 0));
+                }
+                solver->add_clause(pabc::Vec_IntArray(vLits), 
+                        pabc::Vec_IntArray(vLits) + spec.nr_nontriv);
+            }
+
+            /*******************************************************************
+                Add clauses that prevent trivial variable projection and
+                constant operators from being synthesized.
+            *******************************************************************/
+            void 
+            create_nontriv_clauses(const spec& spec)
+            {
+                percy::dynamic_truth_table triv_op(spec.fanin);
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    kitty::clear(triv_op);
+                    
+                    // Dissallow the constant zero operator.
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        pabc::Vec_IntSetEntry(vLits, j-1,
+                                pabc::Abc_Var2Lit(get_op_var(spec, i, j), 0));
+                    }
+                    solver->add_clause(pabc::Vec_IntArray(vLits),
+                            pabc::Vec_IntArray(vLits) + nr_op_vars_per_step);
+                    
+                    // Dissallow all variable projection operators.
+                    for (int n = 0; n < spec.fanin; n++) {
+                        kitty::create_nth_var(triv_op, n);
+                        for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                            pabc::Vec_IntSetEntry(vLits, j-1,
+                                    pabc::Abc_Var2Lit(get_op_var(spec, i, j), 
+                                        kitty::get_bit(triv_op, j)));
+                        }
+                        solver->add_clause(pabc::Vec_IntArray(vLits),
+                                pabc::Vec_IntArray(vLits) + nr_op_vars_per_step);
+                    }
+                }
+            }
+
+            bool 
+            create_tt_clauses(const spec& spec, int t)
+            {
+                auto ret = true;
+                std::vector<int> fanin_asgn(spec.fanin);
+                int pLits[2];
+
+                int svar_offset = 0;
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    auto level = get_level(spec, i + spec.get_nr_in());
+                    assert(level > 0);
+                    
+                    const auto nr_svars_for_i = nr_svar_map[i];
+
+                    for (int j = 0; j < nr_svars_for_i; j++) {
+                        const auto svar = j + svar_offset;
+                        const auto& fanins = svar_map[svar];
+                        // First add clauses 
+                        // operator i computes zero.
+                        int opvar_idx = 0;
+                        clear_assignment(fanin_asgn);
+                        while (true) {
+                            next_assignment(fanin_asgn);
+                            if (is_zero(fanin_asgn)) {
+                                break;
+                            }
+                            opvar_idx++;
+                            ret &= add_simulation_clause(spec, t, i, svar, 0,
+                                    opvar_idx, fanins, fanin_asgn);
+                        }
+
+                        // Next, all cases where operator i computes one.
+                        opvar_idx = 0;
+                        ret &= add_simulation_clause(spec, t, i, svar, 1,
+                                opvar_idx, fanins, fanin_asgn);
+                        while (true) {
+                            next_assignment(fanin_asgn);
+                            if (is_zero(fanin_asgn)) {
+                                break;
+                            }
+                            opvar_idx++;
+                            ret &= add_simulation_clause(spec, t, i, svar, 1,
+                                    opvar_idx, fanins, fanin_asgn);
+                        }
+                    }
+                    svar_offset += nr_svars_for_i;
+
+                    // If an output has selected this particular operand, we
+                    // need to ensure that this operand's truth table satisfies
+                    // the specified output function.
+                    for (int h = 0; h < spec.nr_nontriv; h++) {
+                        if (spec.is_dont_care(h, t + 1)) {
+                            continue;
+                        }
+                        auto outbit = kitty::get_bit(
+                                spec[spec.synth_func(h)], t+1);
+                        if ((spec.out_inv >> spec.synth_func(h)) & 1) {
+                            outbit = 1 - outbit;
+                        }
+                        pLits[0] = pabc::Abc_Var2Lit(get_out_var(spec, h, i), 1);
+                        pLits[1] = pabc::Abc_Var2Lit(get_sim_var(spec, i, t), 
+                                1 - outbit);
+                        ret &= solver->add_clause(pLits, pLits+2);
+                        if (spec.verbosity > 1) {
+                            printf("  (g_%d_%d --> %sx_%d_%d)\n", h+1, 
+                                    spec.get_nr_in()+i+1, 
+                                    (1 - outbit) ?  "!" : "",
+                                    spec.get_nr_in()+i+1, t+1);
+                        }
+                    }
+                }
+
+                return ret;
+            }
+
+            /*******************************************************************
+                Ensure that each gate has FI operands.
+            *******************************************************************/
+            void
+            create_op_clauses(const spec& spec)
+            {
+                auto svar_offset = 0;
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    auto level = get_level(spec, i + spec.get_nr_in());
+                    assert(level > 0);
+
+                    const auto nr_svars_for_i = nr_svar_map[i];
+                    
+                    for (int j = 0; j < nr_svars_for_i; j++) {
+                        pabc::Vec_IntSetEntry(vLits, j,
+                                pabc::Abc_Var2Lit(get_sel_var(j + svar_offset),
+                                    0));
+                    }
+
+                    solver->add_clause(pabc::Vec_IntArray(vLits), 
+                            pabc::Vec_IntArray(vLits) + nr_svars_for_i);
+
+                    svar_offset += nr_svars_for_i;
+                }
+            }
+
+            /*******************************************************************
+              Add clauses which ensure that every step is used at least once.
+            *******************************************************************/
+            void 
+            create_alonce_clauses(const spec& spec)
+            {
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    auto ctr = 0;
+                    for (int h = 0; h < spec.nr_nontriv; h++) {
+                        pabc::Vec_IntSetEntry(vLits, ctr++, 
+                                pabc::Abc_Var2Lit(get_out_var(spec, h, i), 0));
+                    }
+
+                    const auto level = get_level(spec, i + spec.get_nr_in());
+                    const auto idx = spec.get_nr_in()+i;
+                    for (int ip = i + 1; ip < spec.nr_steps; ip++) {
+                        auto svar_offset = 0;
+                        for (auto svi = 0; svi < ip; svi++) {
+                            svar_offset += nr_svar_map[svi];
+                        }
+
+                        auto levelp = get_level(spec, ip + spec.get_nr_in());
+                        assert(levelp >= level);
+                        if (levelp == level) {
+                            continue;
+                        }
+
+                        const auto nr_svars_for_ip = nr_svar_map[ip];
+                        for (int j = 0; j < nr_svars_for_ip; j++) {
+                            const auto svar = j + svar_offset;
+                            const auto& fanins = svar_map[svar];
+                            for (const auto fanin : fanins) {
+                                if (fanin == idx) {
+                                    pabc::Vec_IntSetEntry(
+                                            vLits, 
+                                            ctr++, 
+                                            pabc::Abc_Var2Lit(svar, 0));
+                                    break;
+                                }
+                            }
+                        }
+
+                    }
+                    solver->add_clause(pabc::Vec_IntArray(vLits), pabc::Vec_IntArray(vLits) + ctr);
+                }
+            }
+
+            bool 
+            add_simulation_clause(
+                    const spec& spec, 
+                    const int t, 
+                    const int i, 
+                    const int svar, 
+                    const int output, 
+                    const int opvar_idx,
+                    const std::vector<int>& fanins,
+                    const std::vector<int>& fanin_asgn)
+            {
+                int ctr = 0;
+
+                for (int j = 0; j < spec.fanin; j++) {
+                    auto child = fanins[j];
+                    auto assign = fanin_asgn[j];
+                    if (child < spec.get_nr_in()) {
+                        if ((((t + 1) & (1 << child) ) ? 1 : 0 ) != assign) {
+                            return true;
+                        }
+                    } else {
+                        pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(
+                                    get_sim_var(spec, child - spec.get_nr_in(),
+                                        t), assign));
+                    }
+                }
+
+                pabc::Vec_IntSetEntry(vLits, ctr++,
+                        pabc::Abc_Var2Lit(get_sel_var(svar), 1));
+                pabc::Vec_IntSetEntry(vLits, ctr++,
+                        pabc::Abc_Var2Lit(get_sim_var(spec, i, t), output));
+
+                if (opvar_idx > 0) {
+                    pabc::Vec_IntSetEntry(vLits, ctr++, pabc::Abc_Var2Lit(
+                                get_op_var(spec, i, opvar_idx), 1 - output));
+                }
+
+                return solver->add_clause(pabc::Vec_IntArray(vLits), pabc::Vec_IntArray(vLits) + ctr); 
+            }
+
+/*
+            void 
+            create_noreapply_clauses(const spec& spec)
+            {
+                int pLits[2];
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    const auto level = get_level(spec, i + spec.get_nr_in());
+                    const auto idx = spec.get_nr_in()+i;
+
+                    for (int ip = i+1; ip < spec.nr_steps; ip++) {
+                        const auto levelp = get_level(spec, ip +
+                                spec.get_nr_in());
+                        if (levelp == level) { 
+                            // A node cannot have a node on the same level in
+                            // its fanin.
+                            continue;
+                        }
+
+                        for (auto k = first_step_on_level(level-1); 
+                                k < first_step_on_level(level); k++) {
+                            for (int j = 0; j < k; j++) {
+                                pLits[0] = pabc::Abc_Var2Lit(
+                                        spec.selection_vars[i][j][k], 1);
+
+                                // Note that it's possible for node ip to never have
+                                // i as its second fanin.
+                                for (auto kp = first_step_on_level(levelp-1); 
+                                        kp < first_step_on_level(levelp); kp++) {
+                                    if (kp == idx) {
+                                        pLits[1] = pabc::Abc_Var2Lit(
+                                                spec.selection_vars[ip][j][kp],1);
+                                        solver_add_clause(this->solver,
+                                                pLits, pLits+2);
+                                        pLits[1] = pabc::Abc_Var2Lit(
+                                                spec.selection_vars[ip][k][kp], 1);
+                                        solver_add_clause(this->solver,
+                                                pLits, pLits+2);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+*/
+
+            /// Extracts chain from encoded CNF solution.
+            void 
+            extract_chain(const spec& spec, chain& chain)
+            {
+                std::vector<int> op_inputs(spec.fanin);
+
+                chain.reset(spec.get_nr_in(), spec.get_nr_out(), spec.nr_steps, spec.fanin);
+
+                auto svar_offset = 0;
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    kitty::dynamic_truth_table op(spec.fanin);
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        if (solver->var_value(get_op_var(spec, i, j))) {
+                            kitty::set_bit(op, j); 
+                        }
+                    }
+
+                    if (spec.verbosity) {
+                        printf("  step x_%d performs operation\n  ", 
+                                i+spec.get_nr_in()+1);
+                        kitty::print_binary(op, std::cout);
+                        printf("\n");
+                    }
+
+                    const auto nr_svars_for_i = nr_svar_map[i];
+                    for (int j = 0; j < nr_svars_for_i; j++) {
+                        const auto sel_var = get_sel_var(svar_offset + j);
+                        if (solver->var_value(sel_var)) {
+                            const auto& fanins = svar_map[svar_offset + j];
+                            if (spec.verbosity) {
+                                printf("  with operands ");
+                                for (int k = 0; k < spec.fanin; k++) {
+                                    printf("x_%d ", fanins[k] + 1);
+                                }
+                            }
+                            chain.set_step(i, fanins, op);
+                            break;
+                        }
+                    }
+
+                    svar_offset += nr_svars_for_i;
+                        
+                    if (spec.verbosity) {
+                        printf("\n");
+                    }
+                }
+
+                auto triv_count = 0, nontriv_count = 0;
+                for (int h = 0; h < spec.get_nr_out(); h++) {
+                    if ((spec.triv_flag >> h) & 1) {
+                        chain.set_output(h, (spec.triv_func(triv_count++) << 1) +
+                                ((spec.out_inv >> h) & 1));
+                        continue;
+                    }
+                    for (int i = 0; i < spec.nr_steps; i++) {
+                        if (solver->var_value(get_out_var(spec, nontriv_count, i))) {
+                            chain.set_output(h, ((i + spec.get_nr_in() + 1) << 1) +
+                                    ((spec.out_inv >> h) & 1));
+                            nontriv_count++;
+                            break;
+                        }
+                    }
+                }
+            }
+
+/*
+            void 
+            create_colex_clauses(const spec& spec)
+            {
+                int pLits[2];
+
+                for (int i = 0; i < spec.nr_steps-1; i++) {
+                    const auto level = get_level(spec, i + spec.get_nr_in());
+                    const auto levelp = get_level(spec, i + 1 +
+                            spec.get_nr_in());
+                    for (auto k = first_step_on_level(level-1); 
+                            k < first_step_on_level(level); k++) {
+                        if (k < 2) continue;
+                        for (auto kp = first_step_on_level(levelp-1); 
+                                kp < first_step_on_level(levelp); kp++) {
+                            if (kp != k) {
+                                continue;
+                            }
+                            for (int j = 1; j < k; j++) {
+                                for (int jp = 0; jp < j; jp++) {
+                                    pLits[0] = pabc::Abc_Var2Lit(spec.selection_vars[i][j][k], 1);
+                                    pLits[1] = pabc::Abc_Var2Lit(
+                                            spec.selection_vars[i+1][jp][k], 1);
+                                    solver_add_clause(
+                                            this->solver, pLits, pLits+2);
+                                }
+                            }
+                        }
+                        const auto min_kp = first_step_on_level(levelp-1);
+                        const auto max_kp = first_step_on_level(levelp);
+                        for (int j = 0; j < k; j++) {
+                            for (int kp = 1; kp < k; kp++) {
+                                if (kp < min_kp || kp >= max_kp) {
+                                    // Node ip would never select these j and kp
+                                    // anyway.
+                                    continue;
+                                }
+                                for (int jp = 0; jp < kp; jp++) {
+                                    pLits[0] = pabc::Abc_Var2Lit(
+                                            spec.selection_vars[i][j][k], 1);
+                                    pLits[1] = pabc::Abc_Var2Lit(
+                                            spec.selection_vars[i+1][jp][kp],1);
+                                    solver_add_clause(
+                                            this->solver, pLits, pLits+2);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            void 
+            create_colex_func_clauses(const spec& spec)
+            {
+                for (int i = 0; i < spec.nr_steps-1; i++) {
+                    for (int k = 1; k < spec.get_nr_in()+i; k++) {
+                        for (int j = 0; j < k; j++) {
+                            pLits[0] = pabc::Abc_Var2Lit(spec.selection_vars[i][j][k], 1);
+                            pLits[1] = pabc::Abc_Var2Lit(spec.selection_vars[i+1][j][k], 1);
+
+                            pLits[2] = 
+                                pabc::Abc_Var2Lit(get_op_var(spec, i, 1, 1), 1);
+                            pLits[3] = 
+                                pabc::Abc_Var2Lit(get_op_var(spec, i+1, 1, 1), 0);
+                            solver_add_clause(this->solver, pLits, pLits+4);
+
+                            pLits[3] = 
+                                pabc::Abc_Var2Lit(get_op_var(spec, i, 1, 0), 1);
+                            pLits[4] = 
+                                pabc::Abc_Var2Lit(get_op_var(spec, i+1, 1, 1), 0);
+                            solver_add_clause(this->solver, pLits, pLits+5);
+                            pLits[4] = 
+                                pabc::Abc_Var2Lit(get_op_var(spec, i+1, 1, 0), 0);
+                            solver_add_clause(this->solver, pLits, pLits+5);
+
+                            pLits[4] = 
+                                pabc::Abc_Var2Lit(get_op_var(spec, i, 0, 1), 1);
+                            pLits[5] = 
+                                pabc::Abc_Var2Lit(get_op_var(spec, i+1, 1, 1), 0);
+                            solver_add_clause(this->solver, pLits, pLits+6);
+                            pLits[5] = 
+                                pabc::Abc_Var2Lit(get_op_var(spec, i+1, 1, 0), 0);
+                            solver_add_clause(this->solver, pLits, pLits+6);
+                            pLits[5] = 
+                                pabc::Abc_Var2Lit(get_op_var(spec, i+1, 0, 1), 0);
+                            solver_add_clause(this->solver, pLits, pLits+6);
+                        }
+                    }
+                }
+            }
+
+            void 
+            create_symvar_clauses(const spec& spec)
+            {
+                for (int q = 1; q < spec.get_nr_in(); q++) {
+                    for (int p = 0; p < q; p++) {
+                        auto symm = true;
+                        for (int i = 0; i < spec.get_nr_out(); i++) {
+                            auto outfunc = spec.functions[i];
+                            if (!(swap(*outfunc, p, q) == *outfunc)) {
+                                symm = false;
+                                break;
+                            }
+                        }
+                        if (!symm) {
+                            continue;
+                        }
+                        if (spec.verbosity) {
+                            printf("  variables x_%d and x_%d are symmetric\n",
+                                    p+1, q+1);
+                        }
+                        for (int i = 0; i < spec.nr_steps; i++) {
+                            const auto level = get_level(spec,
+                                    i+spec.get_nr_in());
+                            if (level > 1) {
+                                // Any node on level 2 or higher could never
+                                // refer to variable q as its second input.
+                                continue;
+                            }
+                            for (int j = 0; j < q; j++) {
+                                if (j == p) continue;
+
+                                auto slit = pabc::Abc_Var2Lit(spec.selection_vars[i][j][q], 1);
+                                pabc::Vec_IntSetEntry(vLits, 0, slit);
+
+                                int ctr = 1;
+                                for (int ip = 0; ip < i; ip++) {
+                                    const auto levelp = get_level(spec, ip+spec.get_nr_in());
+                                    for (auto kp = first_step_on_level(levelp-1); 
+                                            kp < first_step_on_level(levelp); kp++) {
+                                        for (int jp = 0; jp < kp; jp++) {
+                                            if (jp == p || kp == p) {
+                                                slit = pabc::Abc_Var2Lit(
+                                                    spec.selection_vars[ip][jp][kp], 0);
+                                                pabc::Vec_IntSetEntry(vLits, ctr++, slit);
+                                                solver_add_clause(
+                                                    this->solver,
+                                                    pabc::Vec_IntArray(vLits),
+                                                    pabc::Vec_IntArray(vLits)
+                                                    + ctr);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+*/
+
+			/// Encodes specifciation for use in fence-based synthesis flow.
+            bool 
+            encode(const spec& spec, const fence& f)
+            {
+                assert(spec.nr_steps == f.nr_nodes());
+
+                bool success = true;
+
+                update_level_map(spec, f);
+                create_variables(spec);
+                success = create_main_clauses(spec);
+                if (!success) {
+                    return false;
+                }
+
+                create_output_clauses(spec);
+                create_op_clauses(spec);
+
+                if (spec.add_nontriv_clauses) {
+                    create_nontriv_clauses(spec);
+                }
+
+                if (spec.add_alonce_clauses) {
+                    create_alonce_clauses(spec);
+                }
+                /*
+                if (spec.add_noreapply_clauses) {
+                    create_noreapply_clauses(spec);
+                }
+                if (spec.add_colex_clauses) {
+                    create_colex_clauses(spec);
+                }
+                if (spec.add_colex_func_clauses) {
+                    create_colex_func_clauses(spec);
+                }
+                if (spec.add_symvar_clauses) {
+                    create_symvar_clauses(spec);
+                }
+*/
+
+                return true;
+            }
+
+			/// Encodes specifciation for use in CEGAR based synthesis flow.
+            bool 
+            cegar_encode(const spec& spec, const fence& f)
+            {
+                assert(spec.nr_steps == f.nr_nodes());
+
+                update_level_map(spec, f);
+                create_variables(spec);
+                
+                create_output_clauses(spec);
+                create_op_clauses(spec);
+
+                if (spec.add_nontriv_clauses) {
+                    create_nontriv_clauses(spec);
+                }
+                if (spec.add_alonce_clauses) {
+                    create_alonce_clauses(spec);
+                }
+                /*
+                if (spec.add_noreapply_clauses) {
+                    create_noreapply_clauses(spec);
+                }
+                if (spec.add_colex_clauses) {
+                    create_colex_clauses(spec);
+                }
+                if (spec.add_colex_func_clauses) {
+                    create_colex_func_clauses(spec);
+                }
+                if (spec.add_symvar_clauses) {
+                    create_symvar_clauses(spec);
+                }
+                */
+
+                return true;
+            }
+
+            /// Assumes that a solution has been found by the current encoding.
+            /// Blocks the current solution such that the solver is forced to
+            /// find different ones (if they exist).
+            bool
+            block_solution(const spec& spec)
+            {
+                int ctr = 0;
+                int svar_offset = 0;
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    for (int j = 1; j <= nr_op_vars_per_step; j++) {
+                        int invert = 0;
+                        const auto op_var = get_op_var(spec, i, j);
+                        if (solver->var_value(op_var)) {
+                            invert = 1;
+                        }
+                        pabc::Vec_IntSetEntry(vLits, ctr++,
+                                pabc::Abc_Var2Lit(get_op_var(spec, i, j),
+                                    invert));
+                    }
+
+                    const auto nr_svars_for_i = nr_svar_map[i];
+                    for (int j = 0; j < nr_svars_for_i; j++) {
+                        const auto sel_var = get_sel_var(svar_offset + j);
+                        if (solver->var_value(sel_var)) {
+                            pabc::Vec_IntSetEntry(vLits, ctr++,
+                                    pabc::Abc_Var2Lit(sel_var, 1));
+                            break;
+                        }
+                    }
+
+                    svar_offset += nr_svars_for_i;
+                }
+                
+                return solver->add_clause(pabc::Vec_IntArray(vLits), pabc::Vec_IntArray(vLits) + ctr);
+            }
+
+
+            /// Similar to block_solution, but blocks all solutions with the
+            /// same structure. This is more restrictive, since the other
+            /// method allows for the same structure but different operators.
+            bool
+            block_struct_solution(const spec& spec)
+            {
+                int ctr = 0;
+                int svar_offset = 0;
+
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    const auto nr_svars_for_i = nr_svar_map[i];
+                    for (int j = 0; j < nr_svars_for_i; j++) {
+                        const auto sel_var = get_sel_var(svar_offset + j);
+                        if (solver->var_value(sel_var)) {
+                            pabc::Vec_IntSetEntry(vLits, ctr++,
+                                    pabc::Abc_Var2Lit(sel_var, 1));
+                            break;
+                        }
+                    }
+
+                    svar_offset += nr_svars_for_i;
+                }
+
+                return solver->add_clause(pabc::Vec_IntArray(vLits), pabc::Vec_IntArray(vLits) + ctr);
+            }
+
+            kitty::dynamic_truth_table& simulate(const spec&)
+            {
+                // TODO: implement
+                assert(false);
+                return sim_tts[0];
+            }
+    };
+}
+
diff --git a/lib/percy/percy/fence.hpp b/lib/percy/percy/fence.hpp
new file mode 100644
index 0000000..77f2f05
--- /dev/null
+++ b/lib/percy/percy/fence.hpp
@@ -0,0 +1,658 @@
+#pragma once
+
+#include <vector>
+#include <cstdio>
+#include <algorithm>
+#include <cassert>
+#include <memory>
+#include <functional>
+#include "concurrentqueue.h"
+#include <cmath>
+#include <thread>
+#include <percy/spec.hpp>
+
+/*******************************************************************************
+    Definitions of Boolean fences and fence filters and generators.
+
+    A fence generator creates a stream of Boolean fences based on some set of
+    specifictions (e.g. the number of nodes and levels). A fence filter is a
+    special type of generator that is given a fence stream and creates a new
+    stream out of it (i.e. by altering the existing stream). By chaining
+    different generators/filters together, we can create customized fence
+    streams for our particular synthesis demands.
+*******************************************************************************/
+namespace percy
+{
+    class fence
+    {
+        private:
+            std::vector<int> _fence;
+            int _nr_nodes;
+            int _nr_levels;
+
+        public:
+            fence() { reset(0, 0); }
+
+            fence(const fence& f) 
+            {
+                reset(f._nr_nodes, f._nr_levels);
+                for (int i = 0; i < _nr_levels; i++) {
+                    _fence[i] = f._fence[i];
+                }
+            }
+
+            fence& operator=(const fence& f)
+            {
+                reset(f._nr_nodes, f._nr_levels);
+                for (int i = 0; i < _nr_levels; i++) {
+                    _fence[i] = f._fence[i];
+                }
+
+                return *this;
+            }
+
+            fence(fence&& f) 
+            {
+                _nr_nodes = f._nr_nodes;
+                _nr_levels = f._nr_levels;
+                _fence = std::move(f._fence);
+            }
+            
+            fence(int k, int l) { reset(k, l); }
+
+            void reset(int nr_nodes, int nr_levels)
+            { 
+                _nr_nodes = nr_nodes;
+                _nr_levels = nr_levels;
+                _fence.resize(nr_levels);
+            }
+            
+            int nr_nodes() const
+            { 
+                return _nr_nodes;
+            }
+
+            int nr_levels() const
+            { 
+                return _nr_levels;
+            }
+
+            int& operator[] (const int index)
+            {
+                return _fence[index];
+            }
+
+            int at(const int index) const
+            {
+                return _fence[index];
+            }
+    };
+
+    class fence_generator
+    {
+        public:
+            virtual bool next_fence(fence& f) = 0;
+    };
+
+    /***************************************************************************
+        Generates Boolean fences based on an integer partition algorithm. This
+        implementation  is based on a Python implementation at
+        http://www.ics.uci.edu/~eppstein/PADS/IntegerPartitions.py, which
+        itself was adapted from Knuth v4 fasc3 p38. Knuth credits it to
+        Hindenburg, 1779.
+    ***************************************************************************/
+    class partition_generator : public fence_generator
+    {
+        private:
+            int _nnodes, _nlevels;
+            std::vector<int> _partition;
+            std::vector<int> _fence;
+            bool _partitions_finished;
+            bool _fences_finished;
+
+            bool next_partition(std::vector<int>& f)
+            {
+                if (_partitions_finished) {
+                    return false;
+                }
+                if (_nlevels == 1) {
+                    f[0] = _nnodes;
+                    this->_partitions_finished = true;
+                    return true;
+                }
+                for (int i = 0; i < _nlevels; i++) {
+                    f[i] = this->_partition[i];
+                }
+                if (_partition[0] - 1 > _partition[1]) {
+                    _partition[0] -= 1;
+                    _partition[1] += 1;
+                    return true;
+                }
+                int j = 2;
+                int s = _partition[0] + _partition[1] - 1;
+                while (j < _nlevels && _partition[j] >= _partition[0] - 1) {
+                    s += _partition[j];
+                    j += 1;
+                }
+                if (j >= _nlevels) {
+                    _partitions_finished = true;
+                    return true;
+                }
+                int x = _partition[j] = _partition[j] + 1;
+                j -= 1;
+                while (j > 0) {
+                    _partition[j] = x;
+                    s -= x;
+                    j -= 1;
+                    _partition[0] = s;
+                }
+                return true;
+            }
+
+        public:
+            partition_generator()
+            {
+                _nnodes = 0;
+                _nlevels = 0;
+                _partitions_finished = false;
+                _fences_finished = false;
+            }
+
+            partition_generator(partition_generator&& g)
+            {
+                _nnodes = g._nnodes;
+                _nlevels = g._nlevels;
+                _partitions_finished = g._partitions_finished;
+                _fences_finished = g._fences_finished;
+                _partition = std::move(g._partition);
+                _fence = std::move(g._fence);
+            }
+
+            partition_generator(const int nnodes, const int nlevels)
+            {
+                assert(nlevels <= nnodes && nlevels > 0);
+                reset(nnodes, nlevels);
+            }
+
+            int get_nnodes() { return _nnodes; }
+            int get_nlevels() { return _nlevels; }
+
+            bool next_fence(fence& f)
+            {
+                if (_fences_finished) {
+                    return false;
+                }
+                f.reset(_nnodes, _nlevels);
+                // Reverse the order of the nodes in the fence. This ensures
+                // that the sequence of fences will be in "bottom up" order.
+                // In other words, we first generate fences with more nodes at
+                // the bottom than at the top.
+                for (int i = 1; i <= _nlevels; i++) {
+                    f[_nlevels - i] = _fence[i-1];
+                }
+                if (!std::next_permutation(_fence.begin(), _fence.end())) {
+                    if (next_partition(_fence)) {
+                        std::stable_sort(_fence.begin(), _fence.end());
+                    } else {
+                        _fences_finished = true;
+                    }
+                }
+                return true;
+            }
+
+            void reset(const int nnodes, const int nlevels)
+            {
+                assert(nnodes >= nlevels);
+
+                _nnodes = nnodes;
+                _nlevels = nlevels;
+
+                _partition.resize(nlevels);
+                _partition[0] = nnodes - nlevels + 1;
+                for (int i = 1; i < nlevels; i++) {
+                    _partition[i] = 1;
+                }
+                _fences_finished = _partitions_finished = (nnodes < nlevels);
+
+                _fence.resize(nlevels);
+                if (next_partition(_fence)) {
+                    std::stable_sort(_fence.begin(), _fence.end());
+                } else {
+                    _fences_finished = true;
+                }
+            }
+
+            
+
+            partition_generator& operator=(const partition_generator&) = delete;
+            partition_generator& operator=(const partition_generator&& g)
+            {
+                _nnodes = g._nnodes;
+                _nlevels = g._nlevels;
+                _partition = g._partition;
+                _fence = g._fence;
+                _partitions_finished = g._partitions_finished;
+                _fences_finished = g._fences_finished;
+
+                return *this;
+            }
+    };
+
+
+    /***************************************************************************
+        Generates all Boolean fences for the fence family of a specified
+        size. Uses the partition generator to generate fences of varying
+        levels.
+    ***************************************************************************/
+    class family_generator : public fence_generator
+    {
+        private:
+            partition_generator _gen;
+
+        public:
+            family_generator() { }
+
+            family_generator(family_generator&& gen)
+            {
+                _gen = std::move(gen._gen);
+            }
+
+            family_generator(int nnodes)
+            {
+                _gen.reset(nnodes, nnodes);
+            }
+
+            family_generator& operator=(const family_generator&) = delete;
+            family_generator& operator=(const family_generator&& g)
+            {
+                _gen = std::move(g._gen);
+
+                return *this;
+            }
+
+            void reset(int nnodes)
+            {
+                _gen.reset(nnodes, nnodes);
+            }
+            
+            int get_nnodes() { return _gen.get_nnodes(); }
+            int get_nlevels() { return _gen.get_nlevels(); }
+
+            bool next_fence(fence& f)
+            {
+                if (_gen.next_fence(f)) {
+                    return true;
+                }
+                if (_gen.get_nlevels() == 1) {
+                    return false;
+                }
+                _gen.reset(_gen.get_nnodes(), _gen.get_nlevels()-1);
+                return _gen.next_fence(f);
+            }
+    };
+
+
+    /***************************************************************************
+        Continually generates fences of increasing size.
+    ***************************************************************************/
+    class unbounded_generator : public fence_generator
+    {
+        private:
+            family_generator _gen;
+
+        public:
+            unbounded_generator(const int initial_nr_nodes = 1) 
+            {
+                _gen.reset(initial_nr_nodes);
+            }
+
+            unbounded_generator(unbounded_generator&& gen)
+            {
+                _gen = std::move(gen._gen);
+            }
+
+            int get_nnodes() { return _gen.get_nnodes(); }
+            int get_nlevels() { return _gen.get_nlevels(); }
+
+            bool next_fence(fence& f)
+            {
+                if (_gen.next_fence(f)) {
+                    return true;
+                }
+                _gen.reset(_gen.get_nnodes() + 1);
+                return _gen.next_fence(f);
+            }
+    };
+        
+
+    template<class T> 
+    class fence_filter : public fence_generator
+    {
+        protected:
+            T _gen;
+
+        public:
+            fence_filter(T gen) : _gen(std::move(gen)) { }
+    };
+
+    
+    /***************************************************************************
+        Filters out fences based on the number of POs and maximum operator
+        fanin. This is useful in a concrete synthesis context, as not all
+        Boolean fences are relevant when trying to synthesize optimum Boolean
+        chains.
+    ***************************************************************************/
+    template <class T> 
+        class po_filter : protected fence_filter<T>
+    {
+        private:
+            int _nout;
+            int _max_fanin;
+
+        public:
+            po_filter(po_filter&& f)
+            {
+                this->_gen = std::move(f._gen);
+                _nout = f._nout;
+                _max_fanin = f._max_fanin;
+            }
+
+            po_filter(T gen, int nout, int max_fanin) : fence_filter<T>(std::move(gen)) 
+            {
+                _nout = nout;
+                _max_fanin = max_fanin;
+            }
+
+            int get_nlevels() { return this->_gen.get_nlevels(); }
+            int get_nnodes() { return this->_gen.get_nnodes(); }
+
+            bool next_fence(fence& f)
+            {
+                while (true) {
+                    if (this->_gen.next_fence(f)) {
+                        bool is_valid = true;
+                        const int nlevels = f.nr_levels();
+						auto max_in_use = std::min(_nout, f[nlevels-1]);
+                        auto nnodes = f[nlevels-1];
+                        if (max_in_use < nnodes) {
+                            continue;
+                        }
+                        max_in_use *= _max_fanin;
+                        for (int i = 1; i < nlevels; i++) {
+                            auto nnodes = f[nlevels-1-i];
+                            if (max_in_use < nnodes) 
+                            {
+                                is_valid = false;
+                                break;
+                            }
+                            max_in_use *= _max_fanin;
+                        }
+                        if (is_valid) {
+                            return true;
+                        } else {
+                            continue;
+                        }
+                    } else {
+                        return false;
+                    }
+                }
+            }
+    };
+
+    void print_fence(const fence& f);
+
+
+    static inline int nr_fences(int nr_steps) {
+        assert(nr_steps > 0);
+        return 1 << (nr_steps-1);
+    }
+
+    /***************************************************************************
+        A fence generator based on a recursive backtracking algorithm.
+    ***************************************************************************/
+    class rec_fence_generator
+    {
+        private:
+            int _nr_levels;
+            int _nr_nodes;
+            int _nr_outputs;
+            // The budget is the number of nodes we can distribute over any
+            // of the levels.
+            int _budget;
+            bool _initialized = false;
+
+            // If true, this filters out all fences that are guaranteed to be
+            // suboptimal with the given number of outputs.
+            bool _po_filter = true;
+
+            int _max_fanin;
+
+            int _level;
+
+            uint64_t _nr_solutions;
+
+            // Keeps track of how many nodes we spent at each level.
+            int *_nodes_spent = nullptr;
+
+            // Function to call when a solution is found.
+            std::function<void(rec_fence_generator*)> _callback;
+
+        public:
+            rec_fence_generator() { }
+
+            rec_fence_generator(bool po_filter) : _po_filter(po_filter) { }
+
+            ~rec_fence_generator()
+            {
+                if (_nodes_spent != nullptr) {
+                    delete[] _nodes_spent;
+                }
+            }
+
+            uint64_t nr_solutions() const { return _nr_solutions; }
+
+            int nr_levels() const { return _nr_levels; }
+            int nr_nodes() const { return _nr_nodes; }
+            int nodes_on_level(int i) const { return _nodes_spent[i]+1; }
+            bool po_filter() const { return _po_filter; }
+            void set_po_filter(bool po_filter) { _po_filter = po_filter; }
+
+            void 
+            reset(
+                    int nr_nodes, 
+                    int nr_levels, 
+                    int nr_outputs=1, 
+                    int max_fanin=2)
+            {
+                assert(nr_levels >= 1);
+                assert(nr_nodes >= nr_levels);
+            
+                if (_nodes_spent != nullptr) {
+                    delete[] _nodes_spent;
+                }
+                _nodes_spent = new int[nr_levels];
+                for (int i = 0; i < nr_levels; i++) {
+                    _nodes_spent[i] = 0;
+                }
+
+                _nr_nodes = nr_nodes;
+                _nr_levels = nr_levels;
+                _nr_outputs = nr_outputs;
+                _max_fanin = max_fanin;
+
+                _budget = _nr_nodes - _nr_levels;
+                _nr_solutions = 0;
+                _level = 0;
+
+                _initialized = true;
+            }
+
+            int max_nodes_on_level(int level) 
+            {
+                assert(level >= 0);
+                if (level == 0) {
+                    return _nr_outputs;
+                }
+                const auto nr_out_nodes = _nodes_spent[0] + 1;
+                int nr_allowed = nr_out_nodes;
+                for (int i = 0; i < level; i++) {
+                    nr_allowed *= _max_fanin;
+                }
+                return nr_allowed;
+            }
+
+            void search_fences()
+            {
+                if (_budget == 0) {
+                    ++_nr_solutions;
+                    if (_callback) {
+                        _callback(this);
+                    }
+                    backtrack();
+                } else {
+                    // At the current level, we can spend at most "budget"
+                    // number of nodes. However, at the final level we have
+                    // to spend the remaining budget, or we may end up in
+                    // an infinite search branch.
+                    auto start_budget = 0;
+                    if (_level == _nr_levels-1) {
+                        start_budget = _budget;
+                    }
+                    int max_budget;
+                    if (_po_filter) {
+                        // At the highest level, we need at most as many nodes
+                        // as we have outputs. For lower levels we have similar
+                        // bounds.
+                        max_budget = std::min((max_nodes_on_level(_level)-1), _budget);
+                    } else {
+                        max_budget = _budget;
+                    }
+
+                    for (int i = start_budget; i <= max_budget; i++) {
+                        _budget -= i;
+                        _nodes_spent[_level] = i;
+                        ++_level;
+                        search_fences();
+                    }
+                    backtrack();
+                }
+            }
+
+            void backtrack()
+            {
+                if (--_level > -1) {
+                    const auto nodes_spent = _nodes_spent[_level];
+                    _budget += nodes_spent;
+                    _nodes_spent[_level] = 0;
+                }
+            }
+
+            uint64_t count_fences()
+            {
+                assert(_initialized);
+                search_fences();
+                _initialized = false;
+                return _nr_solutions;
+            }
+
+            void generate_fences(std::vector<fence>& fences)
+            {
+                assert(_initialized);
+                _callback = [&fences](rec_fence_generator* gen) {
+                    const auto nr_levels = gen->nr_levels();
+                    fence f(gen->nr_nodes(), nr_levels);
+                    for (int i = 0; i < nr_levels; i++) {
+                        f[i] = gen->nodes_on_level(nr_levels-1-i);
+                    }
+                    fences.push_back(f);
+                };
+                search_fences();
+                _callback = 0;
+                _initialized = false;
+            }
+
+            void 
+            generate_fences(moodycamel::ConcurrentQueue<fence>& q)
+            {
+                assert(_initialized);
+                _callback = [&q](rec_fence_generator* gen) {
+                    const auto nr_levels = gen->nr_levels();
+                    fence f(gen->nr_nodes(), nr_levels);
+                    for (int i = 0; i < nr_levels; i++) {
+                        f[i] = gen->nodes_on_level(nr_levels-1-i);
+                    }
+                    while (!q.try_enqueue(f)) {
+                        std::this_thread::yield();
+                    }
+                };
+                search_fences();
+                _callback = 0;
+                _initialized = false;
+            }
+
+    };
+
+    /***************************************************************************
+        Generates all fences of k nodes.
+    ***************************************************************************/
+    inline std::vector<fence>
+    generate_fences(int k, bool po_filter=true, int nr_outputs=1)
+    {
+        std::vector<fence> fences;
+        rec_fence_generator gen(po_filter);
+
+        for (int l = 1; l <= k; l++) {
+            gen.reset(k, l, nr_outputs);
+            gen.generate_fences(fences);
+        }
+
+        return fences;
+    }
+
+    /***************************************************************************
+        Overloaded version that appends generated fences to existing vector.
+    ***************************************************************************/
+    inline void
+    generate_fences(
+            std::vector<fence>& fences, 
+            int k, 
+            bool po_filter=true, 
+            int nr_outputs=1)
+    {
+        rec_fence_generator gen(po_filter);
+
+        for (int l = 1; l <= k; l++) {
+            gen.reset(k, l, nr_outputs);
+            gen.generate_fences(fences);
+        }
+    }
+    
+    /***************************************************************************
+        Generates all fences of k nodes and puts them into a concurrent queue
+        to be consumed by other threads.
+    ***************************************************************************/
+    inline void
+    generate_fences(spec& spec, moodycamel::ConcurrentQueue<fence>& q)
+    {
+        rec_fence_generator gen;
+
+        for (int l = 1; l <= spec.nr_steps; l++) {
+            gen.reset(spec.nr_steps, l, spec.get_nr_out(), spec.fanin);
+            gen.generate_fences(q);
+        }
+    }
+    
+    inline void print_fence(const fence& f)
+    {
+        for (int i = f.nr_levels()-1; i >= 0; i--) {
+            printf("  ");
+            for (int j = 0; j < f.at(i); j++) {
+                printf("\u25CB ");
+            }
+            printf("\n");
+        }
+    }
+
+
+}
+
diff --git a/lib/percy/percy/generators/partial_dag3_generator.hpp b/lib/percy/percy/generators/partial_dag3_generator.hpp
new file mode 100644
index 0000000..0314e81
--- /dev/null
+++ b/lib/percy/percy/generators/partial_dag3_generator.hpp
@@ -0,0 +1,675 @@
+/* percy
+ * Copyright (C) 2018-2019  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file partial_dag_generator.hpp
+  \brief Generator for partial DAGs with fanin size 3
+  \author Winston Haaswijk
+*/
+
+#include <percy/partial_dag.hpp>
+
+namespace percy
+{
+
+class partial_dag3_generator
+{
+private:
+    int _nr_vertices;
+    int _verbosity = 0;
+    bool _initialized;
+    int _level;
+    uint64_t _nr_solutions;
+
+    // Array indicating which steps have been covered. (And how many
+    // times.) 
+    int _covered_steps[18];
+
+    // Array indicating which steps are "disabled", meaning that
+    // selecting them will not result in a valid DAG.
+    int _disabled_matrix[18][18][18][18];
+
+    partial_gen_type _gen_type = GEN_NOREAPPLY;
+
+    // The index at which backtracking should terminate.
+    int _stop_level = -1;
+
+    // Function to call when a solution is found.
+    std::function<void(partial_dag3_generator*)> _callback;
+
+public:
+    partial_dag3_generator() : _initialized(false) { }
+
+    partial_dag3_generator(int nr_vertices)
+    {
+        reset(nr_vertices);
+    }
+
+    int _js[18];
+    int _ks[18];
+    int _ls[18];
+
+    // The level from which the search is assumed to have started
+    int _start_level = 1;
+
+    int nr_vertices() const { return _nr_vertices; }
+
+    void verbosity(int verbosity) { _verbosity = verbosity; }
+    int verbosity() { return _verbosity; }
+
+    partial_gen_type gen_type() const { return _gen_type; }
+    void gen_type(partial_gen_type gen_type) { _gen_type = gen_type; }
+
+    void set_callback(std::function<void(partial_dag3_generator*)>& f)
+    {
+        _callback = f;
+    }
+
+    void set_callback(std::function<void(partial_dag3_generator*)>&& f)
+    {
+        _callback = std::move(f);
+    }
+
+    void clear_callback()
+    {
+        _callback = 0;
+    }
+
+    void reset(int nr_vertices)
+    {
+        assert(nr_vertices > 0);
+
+        if (_verbosity) {
+            printf("setting nr. vertices=%d\n", nr_vertices);
+        }
+
+        _nr_vertices = nr_vertices;
+
+        for (int i = 0; i < 18; i++) {
+            _covered_steps[i] = 0;
+        }
+
+        for (int i = 0; i < 18; i++) {
+            for (int l = 2; l < 18; l++) {
+                for (int k = 1; k < l; k++) {
+                    for (int j = 0; j < k; j++) {
+                        _disabled_matrix[i][j][k][l] = 0;
+                    }
+                }
+            }
+
+            // The first vertex can only point to PIs
+            _js[0] = 0;
+            _ks[0] = 0;
+            _ls[0] = 0;
+
+            _nr_solutions = 0;
+            _level = 0;
+            _stop_level = -1;
+
+            _initialized = true;
+        }
+    }
+
+    auto count_tuples()
+    {
+        assert(_initialized);
+        _level = _start_level;
+        _nr_solutions = 0;
+
+        search_tuples();
+
+        return _nr_solutions;
+    }
+
+    void search_tuples()
+    {
+        if (_level == _nr_vertices) {
+            ++_nr_solutions;
+            if (_verbosity) {
+                printf("Found solution: ");
+                for (int i = 0; i < _nr_vertices; i++) {
+                    const auto j = _js[i];
+                    const auto k = _ks[i];
+                    const auto l = _ls[i];
+                    if (i > 0) {
+                        printf(" - ");
+                    }
+                    printf("(%d, %d, %d)", j, k, l);
+                }
+                printf("\n");
+            }
+            backtrack();
+        } else {
+            // It's always possible that this node is only connected to PIs
+            _js[_level] = 0;
+            _ks[_level] = 0;
+            _ls[_level] = 0;
+            ++_level;
+            search_tuples();
+
+            // It may also just have one internal connection
+            for (int l = 1; l <= _level; l++) {
+                _ls[_level] = l;
+                ++_level;
+                search_tuples();
+            }
+
+            // Or at least two internal connections
+            for (int l = 2; l <= _level; l++) {
+                for (int k = 1; k < l; k++) {
+                    for (int j = 0; j < k; j++) {
+                        _js[_level] = j;
+                        _ks[_level] = k;
+                        _ls[_level] = l;
+                        ++_level;
+                        search_tuples();
+                    }
+                }
+            }
+            backtrack();
+        }
+    }
+
+    auto count_connected_dags()
+    {
+        assert(_initialized);
+        _level = _start_level;
+        _nr_solutions = 0;
+
+        search_connected_dags();
+
+        return _nr_solutions;
+    }
+
+    void search_connected_dags()
+    {
+        if (_level == _nr_vertices) {
+            for (int i = 1; i <= _nr_vertices - 1; i++) {
+                if (_covered_steps[i] == 0) {
+                    // There is some uncovered internal step, so the
+                    // graph cannot be connected.
+                    backtrack();
+                    return;
+                }
+            }
+            ++_nr_solutions;
+            if (_verbosity) {
+                printf("Found solution: ");
+                for (int i = 0; i < _nr_vertices; i++) {
+                    const auto j = _js[i];
+                    const auto k = _ks[i];
+                    const auto l = _ls[i];
+                    if (i > 0) {
+                        printf(" - ");
+                    }
+                    printf("(%d, %d, %d)", j, k, l);
+                }
+                printf("\n");
+            }
+            backtrack();
+        } else {
+            // It's always possible that this node is only connected to PIs
+            _js[_level] = 0;
+            _ks[_level] = 0;
+            _ls[_level] = 0;
+            ++_level;
+            search_connected_dags();
+
+            // It may also just have one internal connection
+            for (int l = 1; l <= _level; l++) {
+                _ls[_level] = l;
+                ++_covered_steps[l];
+                ++_level;
+                search_connected_dags();
+            }
+
+            // Or at least two internal connections
+            for (int l = 2; l <= _level; l++) {
+                for (int k = 1; k < l; k++) {
+                    for (int j = 0; j < k; j++) {
+                        _js[_level] = j;
+                        _ks[_level] = k;
+                        _ls[_level] = l;
+                        ++_covered_steps[j];
+                        ++_covered_steps[k];
+                        ++_covered_steps[l];
+                        ++_level;
+                        search_connected_dags();
+                    }
+                }
+            }
+            backtrack();
+        }
+    }
+
+    auto count_colex_dags()
+    {
+        assert(_initialized);
+        _level = 1;
+        _nr_solutions = 0;
+
+        search_colex_dags();
+
+        return _nr_solutions;
+    }
+
+    void search_colex_dags()
+    {
+        if (_level == _nr_vertices) {
+            for (int i = 1; i <= _nr_vertices - 1; i++) {
+                if (_covered_steps[i] == 0) {
+                    // There is some uncovered internal step, so the
+                    // graph cannot be connected.
+                    backtrack();
+                    return;
+                }
+            }
+            ++_nr_solutions;
+            if (_verbosity) {
+                printf("Found solution: ");
+                for (int i = 0; i < _nr_vertices; i++) {
+                    const auto j = _js[i];
+                    const auto k = _ks[i];
+                    const auto l = _ls[i];
+                    if (i > 0) {
+                        printf(" - ");
+                    }
+                    printf("(%d, %d, %d)", j, k, l);
+                }
+                printf("\n");
+            }
+            backtrack();
+        } else {
+            // We are only interested in DAGs that are in
+            // co-lexicographical order. Look at the previous step
+            // on the stack, the current step should be greater or
+            // equal to it.
+            const auto start_j = _js[_level - 1];
+            const auto start_k = _ks[_level - 1];
+            const auto start_l = _ls[_level - 1];
+
+            _js[_level] = start_j;
+            _ks[_level] = start_k;
+            _ls[_level] = start_l;
+            ++_covered_steps[start_j];
+            ++_covered_steps[start_k];
+            ++_covered_steps[start_l];
+            ++_level;
+            search_colex_dags();
+            
+            // One internal connection
+            if (start_j == 0 && start_k == 0) {
+                for (int l = start_l + 1; l <= _level; l++) {
+                    _ls[_level] = l;
+                    ++_covered_steps[l];
+                    ++_level;
+                    search_colex_dags();
+                }
+            }
+
+            for (int l = start_l; l <= _level; l++) {
+                for (int k = start_k; k < l; k++) {
+                    for (int j = start_j; j < k; j++) {
+                        ++_covered_steps[j];
+                        ++_covered_steps[k];
+                        ++_covered_steps[l];
+                        _js[_level] = j;
+                        _ks[_level] = k;
+                        _ls[_level] = l;
+                        ++_level;
+                        search_colex_dags();
+                    }
+                }
+            }
+            
+            backtrack();
+        }
+    }
+
+    auto count_noreapply_dags()
+    {
+        assert(_initialized);
+        _nr_solutions = 0;
+        _level = 1;
+
+        search_noreapply_dags();
+
+        return _nr_solutions;
+    }
+
+    void search_noreapply_dags()
+    {
+        if (_level == _nr_vertices) {
+            for (int i = 1; i <= _nr_vertices - 1; i++) {
+                if (_covered_steps[i] == 0) {
+                    // There is some uncovered internal step, so the
+                    // graph cannot be connected.
+                    noreapply_backtrack();
+                    return;
+                }
+            }
+            ++_nr_solutions;
+            if (_verbosity) {
+                printf("Found solution: ");
+                for (int i = 0; i < _nr_vertices; i++) {
+                    const auto j = _js[i];
+                    const auto k = _ks[i];
+                    const auto l = _ls[i];
+                    if (i > 0) {
+                        printf(" - ");
+                    }
+                    printf("(%d, %d, %d)", j, k, l);
+                }
+                printf("\n");
+            }
+            if (_callback) {
+                _callback(this);
+            }
+            noreapply_backtrack();
+        } else {
+            const auto start_j = _js[_level - 1];
+            const auto start_k = _ks[_level - 1];
+            const auto start_l = _ls[_level - 1];
+
+            _js[_level] = start_j;
+            _ks[_level] = start_k;
+            _ls[_level] = start_l;
+            ++_covered_steps[start_j];
+            ++_covered_steps[start_k];
+            ++_covered_steps[start_l];
+            ++_level;
+            search_noreapply_dags();
+
+            // One internal connection
+            if (start_j == 0 && start_k == 0) {
+                for (int l = start_l + 1; l <= _level; l++) {
+                    _ls[_level] = l;
+                    ++_covered_steps[l];
+                    ++_level;
+                    search_noreapply_dags();
+                }
+            }
+            
+            for (int l = start_l; l <= _level; l++) {
+                for (int k = start_k; k < l; k++) {
+                    for (int j = start_j; j < k; j++) {
+                        if (_disabled_matrix[_level][j][k][l]) {
+                            continue;
+                        }
+                        ++_covered_steps[j];
+                        ++_covered_steps[k];
+                        ++_covered_steps[l];
+
+                        if (k > 0) {
+                            for (int ip = _level + 1; ip < _nr_vertices; ip++) {
+                                if (j > 0) {
+                                    ++_disabled_matrix[ip][j][k][_level + 1];
+                                    ++_disabled_matrix[ip][j][l][_level + 1];
+                                }
+                                ++_disabled_matrix[ip][k][l][_level + 1];
+                            }
+                        }
+                        _js[_level] = j;
+                        _ks[_level] = k;
+                        _ls[_level] = l;
+                        ++_level;
+                        search_noreapply_dags();
+                    }
+                }
+            }
+
+            noreapply_backtrack();
+        }
+    }
+
+    void backtrack()
+    {
+        --_level;
+        if (_level > _stop_level) {
+            const auto j = _js[_level];
+            const auto k = _ks[_level];
+            const auto l = _ls[_level];
+            --_covered_steps[j];
+            --_covered_steps[k];
+            --_covered_steps[l];
+        }
+    }
+
+    void noreapply_backtrack()
+    {
+        --_level;
+        if (_level > _stop_level) {
+            const auto j = _js[_level];
+            const auto k = _ks[_level];
+            const auto l = _ls[_level];
+            --_covered_steps[j];
+            --_covered_steps[k];
+            --_covered_steps[l];
+            if (k > 0) {
+                for (int ip = _level + 1; ip < _nr_vertices; ip++) {
+                    if (j > 0) {
+                        --_disabled_matrix[ip][j][k][_level + 1];
+                        --_disabled_matrix[ip][j][l][_level + 1];
+                    }
+                    --_disabled_matrix[ip][k][l][_level + 1];
+                }
+            }
+        }
+    }
+
+    auto count_dags()
+    {
+        switch (_gen_type) {
+        case GEN_TUPLES:
+            return count_tuples();
+        case GEN_CONNECTED:
+            return count_connected_dags();
+        case GEN_COLEX:
+            return count_colex_dags();
+        default:
+            return count_noreapply_dags();
+        }
+    }
+};
+
+inline void pd3_write_nonisomorphic(int nr_vertices, const char* const filename, int nr_in = -1)
+{
+    partial_dag g;
+    partial_dag3_generator gen;
+    auto fhandle = fopen(filename, "wb");
+    if (fhandle == NULL) {
+        fprintf(stderr, "Error: unable to open PD file\n");
+        exit(1);
+    }
+    uint64_t ctr = 0;
+#ifndef DISABLE_NAUTY
+    std::set<std::vector<graph>> can_reprs;
+    pd_iso_checker checker(nr_vertices);
+ 
+    gen.set_callback([&g, fhandle, &can_reprs, &checker, nr_in, &ctr]
+    (partial_dag3_generator* gen) {
+        for (int i = 0; i < gen->nr_vertices(); i++) {
+            g.set_vertex(i, gen->_js[i], gen->_ks[i], gen->_ls[i]);
+        }
+        const auto can_repr = checker.crepr(g);
+        const auto res = can_reprs.insert(can_repr);
+        printf("%zu\r", ++ctr);
+        if (res.second) {
+            if (nr_in != -1 && g.nr_pi_fanins() >= nr_in)
+                write_partial_dag(g, fhandle);
+            else if (nr_in == -1)
+                write_partial_dag(g, fhandle);
+        }
+    });
+#else
+    gen.set_callback([&g, fhandle, &ctr]
+    (partial_dag3_generator* gen) {
+        for (int i = 0; i < gen->nr_vertices(); i++) {
+            g.set_vertex(i, gen->_js[i], gen->_ks[i], gen->_ls[i]);
+        }
+        printf("%zu\r", ++ctr);
+        write_partial_dag(g, fhandle);
+    });
+#endif
+    g.reset(3, nr_vertices);
+    gen.reset(nr_vertices);
+    gen.count_dags();
+    printf("\n");
+
+    fclose(fhandle);
+}
+
+inline std::vector<partial_dag> pd3_generate_max(int max_vertices, int nr_in)
+{
+    partial_dag g;
+    partial_dag3_generator gen;
+    std::vector<partial_dag> dags;
+
+    gen.set_callback([&g, &dags, nr_in]
+    (partial_dag3_generator* gen) {
+        for (int i = 0; i < gen->nr_vertices(); i++) {
+            g.set_vertex(i, gen->_js[i], gen->_ks[i], gen->_ls[i]);
+        }
+        if (g.nr_pi_fanins() >= nr_in) {
+            dags.push_back(g);
+        }
+    });
+
+    for (int i = 1; i <= max_vertices; i++) {
+        g.reset(3, i);
+        gen.reset(i);
+        gen.count_dags();
+    }
+
+    return dags;
+}
+
+inline std::vector<partial_dag> pd3_generate_filtered(int max_vertices, int nr_in)
+{
+    partial_dag g;
+    partial_dag3_generator gen;
+    std::vector<partial_dag> dags;
+
+    gen.set_callback([&g, &dags, nr_in]
+    (partial_dag3_generator* gen) {
+        for (int i = 0; i < gen->nr_vertices(); i++) {
+            g.set_vertex(i, gen->_js[i], gen->_ks[i], gen->_ls[i]);
+        }
+        if (g.nr_pi_fanins() >= nr_in) {
+            dags.push_back(g);
+        }
+    });
+
+    for (int i = 1; i <= max_vertices; i++) {
+        g.reset(3, i);
+        gen.reset(i);
+        gen.count_dags();
+    }
+
+    return dags;
+}
+
+// Same as pd_generate_filtered, but generates only those PDs with the
+// exact number of specified vertices.
+inline std::vector<partial_dag> pd3_exact_generate_filtered(int nr_vertices, int nr_in)
+{
+    partial_dag g;
+    partial_dag3_generator gen;
+    std::vector<partial_dag> dags;
+
+    gen.set_callback([&g, &dags, nr_in]
+    (partial_dag3_generator* gen) {
+        for (int i = 0; i < gen->nr_vertices(); i++) {
+            g.set_vertex(i, gen->_js[i], gen->_ks[i], gen->_ls[i]);
+        }
+        if (g.nr_pi_fanins() >= nr_in) {
+            dags.push_back(g);
+        }
+    });
+
+    g.reset(3, nr_vertices);
+    gen.reset(nr_vertices);
+    gen.count_dags();
+
+    return dags;
+}
+
+inline size_t count_partial_dag3s(FILE* fhandle)
+{
+    size_t nr_dags = 0;
+    int buf;
+    while (fread(&buf, sizeof(int), 1, fhandle) != 0) {
+        auto nr_vertices = buf;
+        for (int i = 0; i < nr_vertices; i++) {
+            auto stat = fread(&buf, sizeof(int), 1, fhandle);
+            assert(stat == 1);
+            stat = fread(&buf, sizeof(int), 1, fhandle);
+            assert(stat == 1);
+            stat = fread(&buf, sizeof(int), 1, fhandle);
+            assert(stat == 1);
+        }
+        nr_dags++;
+    }
+
+    return nr_dags;
+}
+
+inline std::vector<partial_dag> read_partial_dag3s(const char* const filename)
+{
+    std::vector<partial_dag> dags;
+
+    auto fhandle = fopen(filename, "rb");
+    if (fhandle == NULL) {
+        fprintf(stderr, "Error: unable to open output file\n");
+        exit(1);
+    }
+
+    partial_dag g;
+    int buf;
+    while (fread(&buf, sizeof(int), 1, fhandle) != 0) {
+        auto nr_vertices = buf;
+        g.reset(3, nr_vertices);
+        for (int i = 0; i < nr_vertices; i++) {
+            auto stat = fread(&buf, sizeof(int), 1, fhandle);
+            assert(stat == 1);
+            auto fanin1 = buf;
+            stat = fread(&buf, sizeof(int), 1, fhandle);
+            assert(stat == 1);
+            auto fanin2 = buf;
+            stat = fread(&buf, sizeof(int), 1, fhandle);
+            assert(stat == 1);
+            auto fanin3 = buf;
+            g.set_vertex(i, fanin1, fanin2, fanin3);
+        }
+        dags.push_back(g);
+    }
+
+    fclose(fhandle);
+
+    return dags;
+}
+
+} /* namespace percy */
diff --git a/lib/percy/percy/generators/partial_dag_generator.hpp b/lib/percy/percy/generators/partial_dag_generator.hpp
new file mode 100644
index 0000000..72c1219
--- /dev/null
+++ b/lib/percy/percy/generators/partial_dag_generator.hpp
@@ -0,0 +1,727 @@
+/* percy
+ * Copyright (C) 2018-2019  EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file partial_dag_generator.hpp
+  \brief Generator for partial DAGs with fanin size 2
+  \author Winston Haaswijk
+*/
+
+#include <percy/partial_dag.hpp>
+
+namespace percy
+{
+
+class partial_dag_generator
+{
+private:
+    int _nr_vertices;
+    int _verbosity = 0;
+    bool _initialized;
+    int _level;
+    uint64_t _nr_solutions;
+
+    // Array indicating which steps have been covered. (And how many
+    // times.) 
+    int _covered_steps[18];
+
+    // Array indicating which steps are "disabled", meaning that
+    // selecting them will not result in a valid DAG.
+    int _disabled_matrix[18][18][18];
+
+    partial_gen_type _gen_type = GEN_NOREAPPLY;
+
+    // The index at which backtracking should terminate.
+    int _stop_level = -1;
+
+    // Function to call when a solution is found.
+    std::function<void(partial_dag_generator*)> _callback;
+
+public:
+    partial_dag_generator() : _initialized(false) { }
+
+    partial_dag_generator(int nr_vertices)
+    {
+        reset(nr_vertices);
+    }
+
+    // Two arrays that represent the "stack" of selected steps.
+    int _js[18];
+    int _ks[18];
+
+    // The level from which the search is assumed to have started
+    int _start_level = 1;
+
+    int nr_vertices() const { return _nr_vertices; }
+
+    void verbosity(int verbosity) { _verbosity = verbosity; }
+    int verbosity() { return _verbosity; }
+
+    partial_gen_type gen_type() const { return _gen_type; }
+    void gen_type(partial_gen_type gen_type) { _gen_type = gen_type; }
+
+    void set_callback(std::function<void(partial_dag_generator*)>& f)
+    {
+        _callback = f;
+    }
+
+    void set_callback(std::function<void(partial_dag_generator*)>&& f)
+    {
+        _callback = std::move(f);
+    }
+
+    void clear_callback()
+    {
+        _callback = 0;
+    }
+
+    void reset(int nr_vertices)
+    {
+        assert(nr_vertices > 0);
+
+        if (_verbosity) {
+            printf("setting nr. vertices=%d\n", nr_vertices);
+        }
+
+        _nr_vertices = nr_vertices;
+
+        for (int i = 0; i < 18; i++) {
+            _covered_steps[i] = 0;
+        }
+
+        for (int i = 0; i < 18; i++) {
+            for (int j = 0; j < 18; j++) {
+                for (int k = 0; k < 18; k++) {
+                    _disabled_matrix[i][j][k] = 0;
+                }
+            }
+        }
+
+        // The first vertex can only point to PIs
+        _js[0] = 0;
+        _ks[0] = 0;
+
+        _nr_solutions = 0;
+        _level = 0;
+        _stop_level = -1;
+
+        _initialized = true;
+    }
+
+    auto count_tuples()
+    {
+        assert(_initialized);
+        _level = _start_level;
+        _nr_solutions = 0;
+
+        search_tuples();
+
+        return _nr_solutions;
+    }
+
+    void search_tuples()
+    {
+        if (_level == _nr_vertices) {
+            ++_nr_solutions;
+            if (_verbosity) {
+                printf("Found solution: ");
+                for (int i = 0; i < _nr_vertices; i++) {
+                    const auto j = _js[i];
+                    const auto k = _ks[i];
+                    if (i > 0) {
+                        printf(" - ");
+                    }
+                    printf("(%d, %d)", j, k);
+                }
+                printf("\n");
+            }
+            if (_callback) {
+                _callback(this);
+            }
+            backtrack();
+        } else {
+            // It's always possible that this node is only connected to PIs
+            _js[_level] = 0;
+            _ks[_level] = 0;
+            ++_level;
+            search_tuples();
+            for (int k = 1; k <= _level; k++) {
+                for (int j = 0; j < k; j++) {
+                    _js[_level] = j;
+                    _ks[_level] = k;
+                    ++_level;
+                    search_tuples();
+                }
+            }
+            backtrack();
+        }
+    }
+
+    auto count_connected_dags()
+    {
+        assert(_initialized);
+        _level = _start_level;
+        _nr_solutions = 0;
+
+        search_connected_dags();
+
+        return _nr_solutions;
+    }
+
+    void search_connected_dags()
+    {
+        if (_level == _nr_vertices) {
+            for (int i = 1; i <= _nr_vertices - 1; i++) {
+                if (_covered_steps[i] == 0) {
+                    // There is some uncovered internal step, so the
+                    // graph cannot be connected.
+                    backtrack();
+                    return;
+                }
+            }
+            ++_nr_solutions;
+            if (_verbosity) {
+                printf("Found solution: ");
+                for (int i = 0; i < _nr_vertices; i++) {
+                    const auto j = _js[i];
+                    const auto k = _ks[i];
+                    if (i > 0) {
+                        printf(" - ");
+                    }
+                    printf("(%d, %d)", j, k);
+                }
+                printf("\n");
+            }
+            if (_callback) {
+                _callback(this);
+            }
+            backtrack();
+        } else {
+            _js[_level] = 0;
+            _ks[_level] = 0;
+            ++_level;
+            search_connected_dags();
+            for (int k = 1; k <= _level; k++) {
+                for (int j = 0; j < k; j++) {
+                    _js[_level] = j;
+                    _ks[_level] = k;
+                    ++_covered_steps[j];
+                    ++_covered_steps[k];
+                    ++_level;
+                    search_connected_dags();
+                }
+            }
+            backtrack();
+        }
+    }
+
+    auto count_colex_dags()
+    {
+        assert(_initialized);
+        _level = 1;
+        _nr_solutions = 0;
+
+        search_colex_dags();
+
+        return _nr_solutions;
+    }
+
+    void search_colex_dags()
+    {
+        if (_level == _nr_vertices) {
+            for (int i = 1; i <= _nr_vertices - 1; i++) {
+                if (_covered_steps[i] == 0) {
+                    // There is some uncovered internal step, so the
+                    // graph cannot be connected.
+                    backtrack();
+                    return;
+                }
+            }
+            ++_nr_solutions;
+            if (_verbosity) {
+                printf("Found solution: ");
+                for (int i = 0; i < _nr_vertices; i++) {
+                    const auto j = _js[i];
+                    const auto k = _ks[i];
+                    if (i > 0) {
+                        printf(" - ");
+                    }
+                    printf("(%d, %d)", j, k);
+                }
+                printf("\n");
+            }
+            if (_callback) {
+                _callback(this);
+            }
+            backtrack();
+        } else {
+            // Check if this step can have pure PI fanins
+            _js[_level] = 0;
+            _ks[_level] = 0;
+            ++_level;
+            search_colex_dags();
+
+            // We are only interested in DAGs that are in
+            // co-lexicographical order. Look at the previous step
+            // on the stack, the current step should be greater or
+            // equal to it.
+            const auto start_j = _js[_level - 1];
+            auto start_k = _ks[_level - 1];
+
+            if (start_j == start_k) { // Previous input has two PI inputs
+                ++start_k;
+            }
+
+            _ks[_level] = start_k;
+            for (int j = start_j; j < start_k; j++) {
+                ++_covered_steps[j];
+                ++_covered_steps[start_k];
+                _js[_level] = j;
+                ++_level;
+                search_colex_dags();
+            }
+            for (int k = start_k + 1; k <= _level; k++) {
+                for (int j = 0; j < k; j++) {
+                    ++_covered_steps[j];
+                    ++_covered_steps[k];
+                    _js[_level] = j;
+                    _ks[_level] = k;
+                    ++_level;
+                    search_colex_dags();
+                }
+            }
+
+            backtrack();
+        }
+    }
+
+    auto count_noreapply_dags()
+    {
+        assert(_initialized);
+        _nr_solutions = 0;
+        _level = 1;
+
+        search_noreapply_dags();
+
+        return _nr_solutions;
+    }
+
+    void search_noreapply_dags()
+    {
+        if (_level == _nr_vertices) {
+            for (int i = 1; i <= _nr_vertices - 1; i++) {
+                if (_covered_steps[i] == 0) {
+                    // There is some uncovered internal step, so the
+                    // graph cannot be connected.
+                    noreapply_backtrack();
+                    return;
+                }
+            }
+            ++_nr_solutions;
+            if (_verbosity) {
+                printf("Found solution: ");
+                for (int i = 0; i < _nr_vertices; i++) {
+                    const auto j = _js[i];
+                    const auto k = _ks[i];
+                    if (i > 0) {
+                        printf(" - ");
+                    }
+                    printf("(%d, %d)", j, k);
+                }
+                printf("\n");
+            }
+            if (_callback) {
+                _callback(this);
+            }
+            noreapply_backtrack();
+        } else {
+            // Check if this step can have pure PI fanins
+            _js[_level] = 0;
+            _ks[_level] = 0;
+            ++_level;
+            search_noreapply_dags();
+
+            // We are only interested in DAGs that are in
+            // co-lexicographical order. Look at the previous step
+            // on the stack, the current step should be greater or
+            // equal to it.
+            const auto start_j = _js[_level - 1];
+            auto start_k = _ks[_level - 1];
+
+            if (start_j == start_k) { // Previous input has two PI inputs
+                ++start_k;
+            }
+
+            _ks[_level] = start_k;
+            for (int j = start_j; j < start_k; j++) {
+                if (_disabled_matrix[_level][j][start_k]) {
+                    continue;
+                }
+
+                // If we choose fanin (j, k), record that j and k
+                // are covered.
+                ++_covered_steps[j];
+                ++_covered_steps[start_k];
+
+                // We are adding step (i, j, k). This means that we
+                // don't have to consider steps (i',j,i) or (i',k,i)
+                // for i < i' <= n+r. This avoiding reapplying an
+                // operand.
+                for (int ip = _level + 1; ip < _nr_vertices; ip++) {
+                    ++_disabled_matrix[ip][j][_level];
+                    ++_disabled_matrix[ip][start_k][_level];
+                }
+
+                _js[_level] = j;
+                ++_level;
+                search_noreapply_dags();
+            }
+            for (int k = start_k + 1; k <= _level; k++) {
+                for (int j = 0; j < k; j++) {
+                    if (_disabled_matrix[_level][j][k]) {
+                        continue;
+                    }
+                    ++_covered_steps[j];
+                    ++_covered_steps[k];
+
+                    for (int ip = _level + 1; ip < _nr_vertices; ip++) {
+                        ++_disabled_matrix[ip][j][_level];
+                        ++_disabled_matrix[ip][k][_level];
+                    }
+                    _js[_level] = j;
+                    _ks[_level] = k;
+                    ++_level;
+                    search_noreapply_dags();
+                }
+            }
+
+            noreapply_backtrack();
+        }
+    }
+
+    void backtrack()
+    {
+        --_level;
+        if (_level > _stop_level) {
+            const auto j = _js[_level];
+            const auto k = _ks[_level];
+            --_covered_steps[j];
+            --_covered_steps[k];
+        }
+    }
+
+    void noreapply_backtrack()
+    {
+        --_level;
+        const auto j = _js[_level];
+        const auto k = _ks[_level];
+        if (_level > _stop_level) {
+            --_covered_steps[j];
+            --_covered_steps[k];
+            for (int ip = _level + 1; ip < _nr_vertices; ip++) {
+                --_disabled_matrix[ip][j][_level];
+                --_disabled_matrix[ip][k][_level];
+            }
+        }
+    }
+
+    auto count_dags()
+    {
+        switch (_gen_type) {
+        case GEN_TUPLES:
+            return count_tuples();
+        case GEN_CONNECTED:
+            return count_connected_dags();
+        case GEN_COLEX:
+            return count_colex_dags();
+        default:
+            return count_noreapply_dags();
+        }
+    }
+
+    bool search_operator(
+        spec& spec,
+        chain& chain,
+        const partial_dag& dag,
+        int idx) {
+        kitty::dynamic_truth_table tt(2);
+        do {
+            if (is_normal(tt) && !is_trivial(tt)) {
+                chain.set_step(idx, _js[idx], _ks[idx], tt);
+                const auto found = search_sol(spec, chain, dag, idx + 1);
+                if (found) {
+                    return true;
+                }
+            }
+            kitty::next_inplace(tt);
+        } while (!kitty::is_const0(tt));
+
+        return false;
+    }
+
+    bool search_sol(
+        spec& spec,
+        chain& chain,
+        const partial_dag& dag,
+        int idx) {
+        if (idx == dag.nr_vertices()) {
+            const auto tts = chain.simulate();
+            if (tts[0] == (spec.out_inv ? ~spec[0] : spec[0])) {
+                if (spec.out_inv) {
+                    chain.invert();
+                }
+                return true;
+            } else {
+                return false;
+            }
+        }
+        const auto& vertex = dag.get_vertex(idx);
+        auto nr_pi_fanins = 0;
+        if (vertex[1] == FANIN_PI) {
+            nr_pi_fanins = 2;
+        } else if (vertex[0] == FANIN_PI) {
+            nr_pi_fanins = 1;
+        }
+        if (nr_pi_fanins == 0) {
+            _js[idx] = vertex[0] + spec.get_nr_in() - 1;
+            _ks[idx] = vertex[1] + spec.get_nr_in() - 1;
+            const auto found = search_operator(spec, chain, dag, idx);
+            if (found) {
+                return true;
+            }
+        } else if (nr_pi_fanins == 1) {
+            for (auto j = 0; j < spec.get_nr_in(); j++) {
+                _js[idx] = j;
+                _ks[idx] = vertex[1] + spec.get_nr_in() - 1;
+                const auto found = search_operator(spec, chain, dag, idx);
+                if (found) {
+                    return true;
+                }
+            }
+        } else {
+            for (auto k = 1; k < spec.get_nr_in(); k++) {
+                for (auto j = 0; j < k; j++) {
+                    _js[idx] = j;
+                    _ks[idx] = k;
+                    const auto found = search_operator(spec, chain, dag, idx);
+                    if (found) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+};
+
+/// Generate all partial DAGs of the specified number
+/// of vertices.
+inline std::vector<partial_dag> pd_generate(int nr_vertices)
+{
+    partial_dag g;
+    partial_dag_generator gen;
+    std::vector<partial_dag> dags;
+
+    gen.set_callback([&g, &dags]
+    (partial_dag_generator* gen) {
+        for (int i = 0; i < gen->nr_vertices(); i++) {
+            g.set_vertex(i, gen->_js[i], gen->_ks[i]);
+        }
+        dags.push_back(g);
+    });
+
+    g.reset(2, nr_vertices);
+    gen.reset(nr_vertices);
+    gen.count_dags();
+
+    return dags;
+}
+
+#ifndef DISABLE_NAUTY
+inline std::vector<partial_dag> pd_generate_nonisomorphic(int nr_vertices)
+{
+    partial_dag g;
+    partial_dag_generator gen;
+    std::vector<partial_dag> dags;
+    std::set<std::vector<graph>> can_reprs;
+    pd_iso_checker checker(nr_vertices);
+
+    gen.set_callback([&g, &dags, &can_reprs, &checker]
+    (partial_dag_generator* gen) {
+        for (int i = 0; i < gen->nr_vertices(); i++) {
+            g.set_vertex(i, gen->_js[i], gen->_ks[i]);
+        }
+        const auto can_repr = checker.crepr(g);
+        const auto res = can_reprs.insert(can_repr);
+        if (res.second)
+            dags.push_back(g);
+    });
+
+    g.reset(2, nr_vertices);
+    gen.reset(nr_vertices);
+    gen.count_dags();
+
+    return dags;
+}
+#endif
+
+inline void pd_write_nonisomorphic(int nr_vertices, const char* const filename)
+{
+    partial_dag g;
+    partial_dag_generator gen;
+    auto fhandle = fopen(filename, "wb");
+#ifndef DISABLE_NAUTY
+    std::set<std::vector<graph>> can_reprs;
+    pd_iso_checker checker(nr_vertices);
+ 
+    gen.set_callback([&g, fhandle, &can_reprs, &checker]
+    (partial_dag_generator* gen) {
+        for (int i = 0; i < gen->nr_vertices(); i++) {
+            g.set_vertex(i, gen->_js[i], gen->_ks[i]);
+        }
+        const auto can_repr = checker.crepr(g);
+        const auto res = can_reprs.insert(can_repr);
+        if (res.second)
+            write_partial_dag(g, fhandle);
+    });
+#else
+    gen.set_callback([&g, fhandle]
+    (partial_dag_generator* gen) {
+        for (int i = 0; i < gen->nr_vertices(); i++) {
+            g.set_vertex(i, gen->_js[i], gen->_ks[i]);
+        }
+        write_partial_dag(g, fhandle);
+    });
+#endif
+    g.reset(2, nr_vertices);
+    gen.reset(nr_vertices);
+    gen.count_dags();
+
+    fclose(fhandle);
+}
+
+/// Generate all partial DAGs up to the specified number
+/// of vertices.
+inline std::vector<partial_dag> pd_generate_max(int max_vertices)
+{
+    partial_dag g;
+    partial_dag_generator gen;
+    std::vector<partial_dag> dags;
+
+    gen.set_callback([&g, &dags]
+    (partial_dag_generator* gen) {
+        for (int i = 0; i < gen->nr_vertices(); i++) {
+            g.set_vertex(i, gen->_js[i], gen->_ks[i]);
+        }
+        dags.push_back(g);
+    });
+
+    for (int i = 1; i <= max_vertices; i++) {
+        g.reset(2, i);
+        gen.reset(i);
+        gen.count_dags();
+    }
+
+    return dags;
+}
+
+inline std::vector<partial_dag> pd_generate_filtered(int max_vertices, int nr_in)
+{
+    partial_dag g;
+    partial_dag_generator gen;
+    std::vector<partial_dag> dags;
+
+    gen.set_callback([&g, &dags, nr_in]
+    (partial_dag_generator* gen) {
+        for (int i = 0; i < gen->nr_vertices(); i++) {
+            g.set_vertex(i, gen->_js[i], gen->_ks[i]);
+        }
+        if (g.nr_pi_fanins() >= nr_in) {
+            dags.push_back(g);
+        }
+    });
+
+    for (int i = 1; i <= max_vertices; i++) {
+        g.reset(2, i);
+        gen.reset(i);
+        gen.count_dags();
+    }
+
+    return dags;
+}
+
+inline size_t count_partial_dags(FILE* fhandle)
+{
+    size_t nr_dags = 0;
+    int buf;
+    while (fread(&buf, sizeof(int), 1, fhandle) != 0) {
+        auto nr_vertices = buf;
+        for (int i = 0; i < nr_vertices; i++) {
+            auto stat = fread(&buf, sizeof(int), 1, fhandle);
+            assert(stat == 1);
+            stat = fread(&buf, sizeof(int), 1, fhandle);
+            assert(stat == 1);
+        }
+        nr_dags++;
+    }
+
+    return nr_dags;
+}
+
+/// Reads serialized partial DAGs from file
+inline std::vector<partial_dag> read_partial_dags(const char* const filename)
+{
+    std::vector<partial_dag> dags;
+
+    auto fhandle = fopen(filename, "rb");
+    if (fhandle == NULL) {
+        fprintf(stderr, "Error: unable to open output file\n");
+        exit(1);
+    }
+
+    partial_dag g;
+    int buf;
+    while (fread(&buf, sizeof(int), 1, fhandle) != 0) {
+        auto nr_vertices = buf;
+        g.reset(2, nr_vertices);
+        for (int i = 0; i < nr_vertices; i++) {
+            auto stat = fread(&buf, sizeof(int), 1, fhandle);
+            assert(stat == 1);
+            auto fanin1 = buf;
+            stat = fread(&buf, sizeof(int), 1, fhandle);
+            assert(stat == 1);
+            auto fanin2 = buf;
+            g.set_vertex(i, fanin1, fanin2);
+        }
+        dags.push_back(g);
+    }
+
+    fclose(fhandle);
+
+    return dags;
+}
+
+} /* namespace percy */
diff --git a/lib/percy/percy/io.hpp b/lib/percy/percy/io.hpp
new file mode 100644
index 0000000..3e5bb68
--- /dev/null
+++ b/lib/percy/percy/io.hpp
@@ -0,0 +1,49 @@
+#pragma once
+
+namespace percy
+{
+
+    /***************************************************************************
+        Converts a DAG to the folling string format:
+        "n,r,j_1,k_1,j_2,k_2,...,j_r,k_r", where
+        n is the number of input variables
+        r is the number of internal nodes (or steps)
+        the r pairs (j_i, k_i) represent the internal nodes and their incoming
+        arcs.
+        The resulting string is written to the supplied character buffer and
+        will be null terminated.
+        NOTE: the function assumes that enough memory has been allocated in
+        the buffer.
+    ***************************************************************************/
+    template<class Dag=dag<2>>
+    void dag_to_string(const Dag& g, char* buf)
+    {
+        buf[0] = char(g.nr_vars() + '0');
+        buf[1] = ',';
+        buf[2] = char(g.nr_vertices() + '0');
+        buf[3] = ',';
+        int i = 0;
+        for (i = 0; i < g.nr_vertices(); i++) {
+            const auto& vertex = g.get_vertex(i);
+            buf[i*4+4] = char(vertex.first + '0');
+            buf[i*4+5] = ',';
+            buf[i*4+6] = char(vertex.second + '0');
+            if (i != g.nr_vertices() - 1) {
+                buf[i*4+7] = ',';
+            }
+        }
+        buf[i*4+3] = '\0';
+    }
+
+
+    /***************************************************************************
+        Parses a DAG string into a DAG object.
+    ***************************************************************************/
+    template<class Dag=dag<2>>
+    void dag_read_string(Dag&, char*)
+    {
+    }
+
+    
+}
+
diff --git a/lib/percy/percy/majority_chain.hpp b/lib/percy/percy/majority_chain.hpp
new file mode 100644
index 0000000..25428e6
--- /dev/null
+++ b/lib/percy/percy/majority_chain.hpp
@@ -0,0 +1,499 @@
+/* percy: C++ exact synthesis library
+ * Copyright (C) 2018-2019  EPFL EPFL
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*!
+  \file majority_chain.hpp
+  \brief Chain of majority-of-three steps
+
+  \author Winston Haaswijk
+  \author Heinz Riener
+*/
+
+#pragma once
+#include <array>
+
+namespace percy
+{
+
+class majority_chain;
+
+namespace detail
+{
+inline void to_expression( majority_chain const& chain, std::ostream& os, bool write_newline = false );
+} /* detail */
+
+/*! \brief Majority chain
+
+  Majority chain is a specialized chain of majority-of-three steps.
+*/
+class majority_chain
+{
+public:
+  using step = std::array<int32_t, 3u>;
+
+public:
+  majority_chain()
+  {
+    reset( 0, 0, 0 );
+  }
+
+  void reset( int32_t new_nr_in, int32_t new_nr_out, int32_t new_nr_steps )
+  {
+    assert( new_nr_out >= 0 );
+    assert( new_nr_steps >= 0 );
+
+    nr_in = new_nr_in;
+    steps.resize( new_nr_steps );
+    operators.resize( new_nr_steps );
+    outputs.resize( new_nr_out );
+  }
+
+  /* getter */
+  int32_t get_nr_inputs() const
+  {
+    return nr_in;
+  }
+
+  int32_t get_nr_steps() const
+  {
+    return steps.size();
+  }
+
+  /* setter */
+  void set_step( int32_t index, int32_t fanin1, int32_t fanin2, int32_t fanin3, int32_t op )
+  {
+    assert( index >= 0 );
+    assert( index < int32_t( steps.size() ) );
+    assert( index < int32_t( operators.size() ) );
+    steps[index][0] = fanin1;
+    steps[index][1] = fanin2;
+    steps[index][2] = fanin3;
+    operators[index] = op;
+  }
+
+  void set_output( int32_t out_index, int32_t lit )
+  {
+    outputs[out_index] = lit;
+  }
+
+  /*! \brief Derive truth tables from the chain, one for each output. */
+  std::vector<kitty::dynamic_truth_table> simulate() const
+  {
+    /* output truth tables */
+    std::vector<kitty::dynamic_truth_table> output_tts( outputs.size() );
+
+    /* step truth tables */
+    std::vector<kitty::dynamic_truth_table> step_tts( steps.size() );
+
+    /* temporary truth tables of current step's children */
+    std::array<kitty::dynamic_truth_table, 3u> child_tts =
+      { kitty::dynamic_truth_table{uint32_t(nr_in)}, kitty::dynamic_truth_table{uint32_t(nr_in)}, kitty::dynamic_truth_table{uint32_t(nr_in)} };
+
+    kitty::dynamic_truth_table step_tt{uint32_t(nr_in)};
+
+    /* some outputs may be simple constants or projections */
+    for ( auto h = 0u; h < outputs.size(); ++h )
+    {
+      auto const out = outputs[h];
+      auto const var = out >> 1;
+      auto const inv = out & 1;
+      if ( var == 0 )
+      {
+        kitty::clear( step_tt );
+        output_tts[h] = inv ? ~step_tt : step_tt;
+      }
+      else if ( var <= nr_in )
+      {
+        kitty::create_nth_var( step_tt, var - 1, inv );
+        output_tts[h] = step_tt;
+      }
+    }
+
+    /* build the truth tables for each step */
+    for ( auto i = 0u; i < steps.size(); ++i )
+    {
+      auto const& step = steps[i];
+
+      for ( auto j = 0u; j < 3; ++j )
+      {
+        if ( step[j] <= nr_in )
+        {
+          kitty::create_nth_var( child_tts[j], step[j] - 1 );
+        }
+        else
+        {
+          assert( step_tts[step[j] - nr_in - 1].num_vars() == nr_in );
+          child_tts[j] = step_tts[step[j] - nr_in - 1];
+        }
+      }
+
+      kitty::clear( step_tt );
+      switch ( operators[i] )
+      {
+      case 0:
+        step_tt = kitty::ternary_majority(  child_tts.at( 0 ),  child_tts.at( 1 ),  child_tts.at( 2 ) );
+        break;
+      case 1:
+        step_tt = kitty::ternary_majority( ~child_tts.at( 0 ),  child_tts.at( 1 ),  child_tts.at( 2 ) );
+        break;
+      case 2:
+        step_tt = kitty::ternary_majority(  child_tts.at( 0 ), ~child_tts.at( 1 ),  child_tts.at( 2 ) );
+        break;
+      case 3:
+        step_tt = kitty::ternary_majority(  child_tts.at( 0 ),  child_tts.at( 1 ), ~child_tts.at( 2 ) );
+        break;
+      }
+
+      step_tts[i] = step_tt;
+
+      for ( auto h = 0u; h < outputs.size(); ++h )
+      {
+        const auto out = outputs[h];
+        const auto var = out >> 1;
+        const auto inv = out & 1;
+        if ( var - nr_in - 1 == static_cast<int>(i) ) {
+          output_tts[h] = inv ? ~step_tt : step_tt;
+        }
+      }
+    }
+
+    return output_tts;
+  }
+
+  /*! \brief Checks if the chain satisfies its specification.
+   *
+   * This method checks not just if the chain computes the correct
+   * function, but also other requirements such as co-lexicographic
+   * order (if specified).
+   */
+  bool satisfies_spec( spec const& spec )
+  {
+    /* If all functions are trivial, nothing needs to be checked */
+    if ( spec.nr_triv == spec.get_nr_out() )
+      return true;
+
+    /* Ensure that all non-trivial are correct (wrt. spec) when simulated */
+    auto const tts = simulate();
+    auto nr_nontriv = 0;
+    for ( int32_t i = 0u; i < spec.nr_nontriv; ++i )
+    {
+      if ( ( spec.triv_flag >> i ) & 1 )
+        continue;
+
+      if ( tts[nr_nontriv++] != spec[i] )
+      {
+        assert( false );
+        return false;
+      }
+    }
+
+    if ( spec.add_alonce_clauses )
+    {
+      /* Ensure that each step is used at least once */
+      std::vector<int32_t> nr_uses( steps.size() );
+
+      for ( auto i = 0u; i < steps.size(); ++i )
+      {
+        auto const& step = steps.at( i );
+        for ( auto const& fid : step )
+        {
+          if ( fid > nr_in )
+          {
+            ++nr_uses[fid - nr_in - 1u];
+          }
+        }
+      }
+
+      for ( auto output : outputs )
+      {
+        auto const step_index = output >> 1;
+        if ( step_index > nr_in )
+        {
+          ++nr_uses[step_index - nr_in - 1u];
+        }
+      }
+
+      for ( auto const nr : nr_uses )
+      {
+        if ( nr == 0 )
+        {
+          assert( false );
+          return( false );
+        }
+      }
+    }
+
+    if ( spec.add_noreapply_clauses )
+    {
+      /* Ensure that there is no re-application of operands */
+      for ( auto i = 0u; i < steps.size(); ++i )
+      {
+        auto const& step1 = steps.at( i );
+
+        for ( auto j = i + 1u; j < steps.size(); ++j )
+        {
+          auto const& step2 = steps.at( j );
+
+          auto has_fanin_i = false;
+          auto is_subsumed = true;
+
+          for ( auto const& k : step2 )
+          {
+            if ( static_cast<uint32_t>( k ) == i + nr_in + 1 )
+            {
+              has_fanin_i = true;
+              //std::cout << "step " << j << " has step " << i << " as a fanin" << std::endl;
+              continue;
+            }
+
+            auto is_included = false;
+            for ( auto l : step1 )
+            {
+              if ( k == l )
+              {
+                is_included = true;
+                //std::cout << "fanin " << l << " of step " << i << " also appears in step " << j << std::endl; 
+                break;
+              }
+            }
+
+            if ( !is_included )
+            {
+              is_subsumed = false;
+            }
+          }
+
+          if ( is_subsumed && has_fanin_i )
+          {
+            assert( false );
+            return false;
+          }
+        }
+      }
+    }
+
+    if ( spec.add_colex_clauses )
+    {
+      /* Ensure that steps are in STRICT co-lexicographical order. */
+      for ( int32_t i = 0; i < spec.nr_steps - 1; ++i )
+      {
+        auto const& v1 = steps[i];
+        auto const& v2 = steps[i + 1];
+
+        if ( colex_compare( v1, v2 ) != -1 )
+        {
+          assert( false );
+          return false;
+        }
+      }
+    }
+
+    if ( spec.add_lex_clauses )
+    {
+      /* Ensure that the steps are in lexicographical order. */
+      for ( int32_t i = 0; i < spec.nr_steps - 1; ++i )
+      {
+        auto const& v1 = steps[i];
+        auto const& v2 = steps[i + 1];
+
+        if ( lex_compare( v1, v2 ) == 1 )
+        {
+          assert( false );
+          return false;
+        }
+      }
+    }
+
+    if ( spec.add_lex_func_clauses )
+    {
+      /* Ensure that the step operator sare in lexicographical order. */
+      for ( int32_t i = 0; i < spec.nr_steps - 1; ++i )
+      {
+        auto const& v1 = steps[i];
+        auto const& v2 = steps[i + 1];
+
+        if ( colex_compare( v1, v2 ) == 0 )
+        {
+          /* The operator of step i must be lexicographically less than that of i + 1. */
+          auto const& op1 = operators[i];
+          auto const& op2 = operators[i + 1];
+          if ( op2 > op1 )
+          {
+            assert( false );
+            return false;
+          }
+        }
+      }
+    }
+
+    if ( spec.add_symvar_clauses )
+    {
+      /* Ensure that the symmetric variables are ordered. */
+      for ( int32_t q = 1; q < spec.get_nr_in(); ++q )
+      {
+        for ( int32_t p = 1; p < q; ++p )
+        {
+          auto symm = true;
+
+          for ( int32_t i = 0u; i < spec.get_nr_out(); ++i )
+          {
+            auto out_function = spec[i];
+            if ( !( swap( out_function, p, q ) == out_function ) )
+            {
+              symm = false;
+              break;
+            }
+          }
+
+          if ( !symm )
+          {
+            continue;
+          }
+
+          for ( int32_t i = 1; i < spec.nr_steps; ++i )
+          {
+            auto const& v1 = steps[i];
+
+            auto has_fanin_p = false;
+            auto has_fanin_q = false;
+
+            for ( auto const fid : v1 )
+            {
+              if ( fid == p )
+              {
+                has_fanin_p = true;
+              }
+              else if ( fid == q )
+              {
+                has_fanin_q = true;
+              }
+            }
+
+            if ( has_fanin_p || !has_fanin_q )
+            {
+              continue;
+            }
+
+            auto p_in_prev_step = false;
+            for ( int j = 0; j < i; ++j )
+            {
+              auto const& v2 = steps[j];
+              has_fanin_p = false;
+
+              for ( auto const fid : v2 )
+              {
+                if ( fid == p )
+                {
+                  has_fanin_p = true;
+                }
+              }
+              if ( has_fanin_p )
+              {
+                p_in_prev_step = true;
+              }
+            }
+            if (!p_in_prev_step)
+            {
+              assert( false );
+              return false;
+            }
+          }
+        }
+      }
+    }
+
+    return true;
+  }
+
+  /*! \brief Converts the chain to a parseable expression.
+   *
+   * Currently only supported for single-output chains.
+   */
+  void to_expression( std::ostream& os, bool write_newline = false ) const
+  {
+    assert( outputs.size() == 1u );
+    detail::to_expression( *this, os, write_newline );
+  }
+
+  /*! \brief Converts the chain to a parseable expression.
+   *
+   * Currently only supported for single-output chains.
+   */
+  std::string to_expression() const
+  {
+    assert( outputs.size() == 1u );
+    std::stringstream ss;
+    detail::to_expression( *this, ss, false );
+    return ss.str();
+  }
+
+public:
+  int nr_in;
+  std::vector<int> outputs;
+  std::vector<step> steps;
+  std::vector<int> operators;
+}; /* majority_chain */
+
+namespace detail
+{
+
+inline void to_expression_recur( majority_chain const& chain, int32_t const index, std::ostream& os )
+{
+  int32_t const num_inputs = chain.get_nr_inputs();
+  if ( index == 0 )
+  {
+    os << '0';
+  }
+  else if ( index <= num_inputs )
+  {
+    os << static_cast<char>( 'a' + index - 1u );
+  }
+  else
+  {
+    auto const& step = chain.steps[ index - num_inputs - 1u ];
+    auto const op = chain.operators[ index - num_inputs - 1u ];
+    os << "<";
+    if ( op == 1 )
+      os << "~";
+    to_expression_recur( chain, step.at( 0 ), os );
+    if ( op == 2 )
+      os << "~";
+    to_expression_recur( chain, step.at( 1 ), os );
+    if ( op == 3 )
+      os << "~";
+    to_expression_recur( chain, step.at( 2 ), os );
+    os << ">";
+  }
+}
+
+inline void to_expression( majority_chain const& chain, std::ostream& os, bool write_newline )
+{
+  to_expression_recur( chain, chain.get_nr_inputs() + chain.get_nr_steps(), os );
+  if ( write_newline )
+    os << '\n';
+}
+} /* detail */
+
+} /* percy */
diff --git a/lib/percy/percy/mig.hpp b/lib/percy/percy/mig.hpp
new file mode 100644
index 0000000..2c61f7a
--- /dev/null
+++ b/lib/percy/percy/mig.hpp
@@ -0,0 +1,9 @@
+#pragma once
+#include "majority_chain.hpp"
+
+namespace percy
+{
+
+using mig = majority_chain;
+
+}
diff --git a/lib/percy/percy/misc.hpp b/lib/percy/percy/misc.hpp
new file mode 100644
index 0000000..93c8c36
--- /dev/null
+++ b/lib/percy/percy/misc.hpp
@@ -0,0 +1,179 @@
+#pragma once
+
+#include <algorithm>
+
+namespace percy
+{
+
+	inline unsigned binomial_coeff(int n, int k)
+	{
+		auto C = new unsigned*[n + 1];
+		for (int i = 0; i < n + 1; i++) {
+			C[i] = new unsigned[k + 1];
+		}
+
+		for (int i = 0; i <= n; i++) {
+			for (int j = 0; j <= (std::min)(i, k); j++)
+			{
+				if (j == 0 || j == i) {
+					C[i][j] = 1;
+				} else {
+					C[i][j] = C[i-1][j-1] + C[i-1][j];
+				}
+			}
+		}
+		const auto result = C[n][k];
+
+		for (int i = 0; i < n + 1; i++) {
+			delete[] C[i];
+		}
+		delete[] C;
+
+		return result;
+	}
+
+    /***************************************************************************
+            Returns 1 if fanins1 > fanins2, -1 if fanins1 < fanins2, and 0
+            otherwise. (In co-lexicographical order.)
+    ***************************************************************************/
+    template<typename fanin, int FI>
+    int colex_compare(
+            const std::array<fanin, FI>& fanins1,
+            const std::array<fanin, FI>& fanins2)
+    {
+        for (int i = FI-1; i >= 0; i--) {
+            if (fanins1[i] < fanins2[i]) {
+                return -1;
+            } else if (fanins1[i] > fanins2[i]) {
+                return 1;
+            }
+        }
+
+        // All fanins are equal
+        return 0;
+    }
+
+    inline int colex_compare(const int* const fanins1, const int* const fanins2, int fanin)
+    {
+        for (int i = fanin-1; i >= 0; i--) {
+            if (fanins1[i] < fanins2[i]) {
+                return -1;
+            } else if (fanins1[i] > fanins2[i]) {
+                return 1;
+            }
+        }
+
+        // All fanins are equal
+        return 0;
+    }
+
+    inline int colex_compare(const std::vector<int>& fanins1, const std::vector<int>& fanins2)
+    {
+        assert(fanins1.size() == fanins2.size());
+        for (int i = fanins1.size() - 1; i >= 0; i--) {
+            if (fanins1[i] < fanins2[i]) {
+                return -1;
+            } else if (fanins1[i] > fanins2[i]) {
+                return 1;
+            }
+        }
+
+        // All fanins are equal
+        return 0;
+    }
+
+    /***************************************************************************
+            Returns 1 if fanins1 > fanins2, -1 if fanins1 < fanins2, and 0
+            otherwise. (In lexicographical order.)
+    ***************************************************************************/
+    template<typename fanin, int FI>
+    int lex_compare(
+            const std::array<fanin, FI>& fanins1,
+            const std::array<fanin, FI>& fanins2)
+    {
+        for (int i = 0; i < FI; i++) {
+            if (fanins1[i] < fanins2[i]) {
+                return -1;
+            } else if (fanins1[i] > fanins2[i]) {
+                return 1;
+            }
+        }
+
+        // All fanins are equal
+        return 0;
+    }
+
+    template<typename fanin, int FI>
+    int lex_compare(const fanin* const fanins1, const fanin* const fanins2)
+    {
+        for (int i = 0; i < FI; i++) {
+            if (fanins1[i] < fanins2[i]) {
+                return -1;
+            } else if (fanins1[i] > fanins2[i]) {
+                return 1;
+            }
+        }
+
+        // All fanins are equal
+        return 0;
+    }
+
+    inline int lex_compare(const std::vector<int>& fanins1, const std::vector<int>& fanins2)
+    {
+        assert(fanins1.size() == fanins2.size());
+
+        for (auto i = 0u; i < fanins1.size(); i++) {
+            if (fanins1[i] < fanins2[i]) {
+                return -1;
+            } else if (fanins1[i] > fanins2[i]) {
+                return 1;
+            }
+        }
+
+        // All fanins are equal
+        return 0;
+    }
+
+    inline int lex_compare(const std::array<int, 3>& fanins1, const std::array<int, 3>& fanins2)
+    {
+        if (fanins1[0] < fanins2[0]) {
+            return -1;
+        } else if (fanins1[0] > fanins2[0]) {
+            return 1;
+        }
+        if (fanins1[1] < fanins2[1]) {
+            return -1;
+        } else if (fanins1[1] > fanins2[1]) {
+            return 1;
+        }
+        if (fanins1[2] < fanins2[2]) {
+            return -1;
+        } else if (fanins1[2] > fanins2[2]) {
+            return 1;
+        }
+
+        return 0;
+    }
+
+    inline int colex_compare(const std::array<int, 3>& fanins1, const std::array<int, 3>& fanins2)
+    {
+        if (fanins1[2] < fanins2[2]) {
+            return -1;
+        } else if (fanins1[2] > fanins2[2]) {
+            return 1;
+        }
+        if (fanins1[1] < fanins2[1]) {
+            return -1;
+        } else if (fanins1[1] > fanins2[1]) {
+            return 1;
+        }
+        if (fanins1[0] < fanins2[0]) {
+            return -1;
+        } else if (fanins1[0] > fanins2[0]) {
+            return 1;
+        }
+
+        return 0;
+    }
+}
+
diff --git a/lib/percy/percy/partial_dag.hpp b/lib/percy/percy/partial_dag.hpp
new file mode 100644
index 0000000..74da51e
--- /dev/null
+++ b/lib/percy/percy/partial_dag.hpp
@@ -0,0 +1,648 @@
+#pragma once
+
+#ifndef DISABLE_NAUTY
+#include <nauty.h>
+#endif
+#include <vector>
+#include <ostream>
+#include <set>
+#include "tt_utils.hpp"
+
+namespace percy
+{
+    /// Convention: the zero fanin keeps a node's fanin "free". This fanin will not
+    /// be connected to any of the other nodes in the partial DAG but rather may
+    /// be connected to any one of the PIs.
+    const int FANIN_PI = 0;
+
+    class partial_dag
+    {
+        private:
+            int fanin; /// The in-degree of vertices in the DAG
+            std::vector<std::vector<int>> vertices;
+
+        public:
+            partial_dag() : fanin(0) { }
+
+            partial_dag(int fanin, int nr_vertices = 0)
+            {
+                reset(fanin, nr_vertices);
+            }
+
+            partial_dag(const partial_dag& dag)
+            {
+                fanin = dag.fanin;
+                vertices = dag.vertices;
+            }
+
+            partial_dag& operator=(const partial_dag& dag)
+            {
+                fanin = dag.fanin;
+                vertices = dag.vertices;
+                return *this;
+            }
+
+            partial_dag(partial_dag&& dag)
+            {
+                fanin = dag.fanin;
+                vertices = std::move(dag.vertices);
+            }
+
+            int nr_pi_fanins()
+            {
+                int count = 0;
+                for (const auto& v : vertices) {
+                    for (auto fanin : v) {
+                        if (fanin == FANIN_PI) {
+                            count++;
+                        }
+                    }
+                }
+                return count;
+            }
+
+            template<typename Fn>
+            void 
+            foreach_vertex(Fn&& fn) const
+            {
+                for (int i = 0; i < nr_vertices(); i++) {
+                    fn(vertices[i], i);
+                }
+            }
+
+            template<typename Fn>
+            void 
+            foreach_fanin(std::vector<int>& v, Fn&& fn) const
+            {
+                for (auto i = 0; i < fanin; i++) {
+                    fn(v[i], i);
+                }
+            }
+
+            void 
+            reset(int fanin, int nr_vertices)
+            {
+                this->fanin = fanin;
+                vertices.resize(nr_vertices);
+                for (auto& vertex : vertices) {
+                    vertex.resize(fanin);
+                }
+            }
+
+            void 
+            set_vertex(int v_idx, const std::vector<int>& fanins)
+            {
+                assert(v_idx < nr_vertices());
+                assert(fanins.size() == static_cast<unsigned>(fanin));
+                for (int i = 0; i < fanin; i++) {
+                    vertices[v_idx][i] = fanins[i];
+                }
+            }
+
+            void
+            set_vertex(int v_idx, int fi1, int fi2)
+            {
+                assert(v_idx < nr_vertices());
+                vertices[v_idx][0] = fi1;
+                vertices[v_idx][1] = fi2;
+            }
+            
+            void
+            set_vertex(int v_idx, int fi1, int fi2, int fi3)
+            {
+                assert(v_idx < nr_vertices());
+                vertices[v_idx][0] = fi1;
+                vertices[v_idx][1] = fi2;
+                vertices[v_idx][2] = fi3;
+            }
+
+            void 
+            add_vertex(const std::vector<int>& fanins)
+            {
+                assert(fanins.size() == static_cast<unsigned>(fanin));
+                vertices.push_back(fanins);
+            }
+
+            const std::vector<int>& 
+            get_vertex(int v_idx) const
+            {
+                return vertices[v_idx];
+            }
+
+            const std::vector<std::vector<int>>& get_vertices() const 
+            {
+                return vertices;
+            }
+
+            int nr_vertices() const
+            {
+                return vertices.size();
+            }
+
+#ifndef DISABLE_NAUTY
+            bool is_isomorphic(const partial_dag& g) const
+            {
+                const auto total_vertices = nr_vertices();
+                assert(total_vertices == g.nr_vertices());
+
+                void (*adjacencies)(graph*, int*, int*, int, 
+                        int, int, int*, int, boolean, int, int) = NULL;
+
+                DYNALLSTAT(int,lab1,lab1_sz);
+                DYNALLSTAT(int,lab2,lab2_sz);
+                DYNALLSTAT(int,ptn,ptn_sz);
+                DYNALLSTAT(int,orbits,orbits_sz);
+                DYNALLSTAT(int,map,map_sz);
+                DYNALLSTAT(graph,g1,g1_sz);
+                DYNALLSTAT(graph,g2,g2_sz);
+                DYNALLSTAT(graph,cg1,cg1_sz);
+                DYNALLSTAT(graph,cg2,cg2_sz);
+                DEFAULTOPTIONS_DIGRAPH(options);
+                statsblk stats;
+
+                int m = SETWORDSNEEDED(total_vertices);;
+
+                options.getcanon = TRUE;
+
+                DYNALLOC1(int,lab1,lab1_sz,total_vertices,"malloc");
+                DYNALLOC1(int,lab2,lab2_sz,total_vertices,"malloc");
+                DYNALLOC1(int,ptn,ptn_sz,total_vertices,"malloc");
+                DYNALLOC1(int,orbits,orbits_sz,total_vertices,"malloc");
+                DYNALLOC1(int,map,map_sz,total_vertices,"malloc");
+
+                // Make the first graph
+                DYNALLOC2(graph,g1,g1_sz,total_vertices,m,"malloc");
+                EMPTYGRAPH(g1,m,total_vertices);
+                for (int i = 1; i < total_vertices; i++) {
+                    const auto& vertex = get_vertex(i);
+                    for (const auto fanin : vertex) {
+                        if (fanin != FANIN_PI) {
+                            ADDONEARC(g1, fanin - 1, i, m);
+                        }
+                    }
+                }
+
+                // Make the second graph
+                DYNALLOC2(graph,g2,g2_sz,total_vertices,m,"malloc");
+                EMPTYGRAPH(g2,m,total_vertices);
+                for (int i = 0; i < total_vertices; i++) {
+                    const auto& vertex = g.get_vertex(i);
+                    for (const auto fanin : vertex) {
+                        if (fanin != FANIN_PI) {
+                            ADDONEARC(g2, fanin - 1, i, m);
+                        }
+                    }
+                }
+
+                // Create canonical graphs
+                DYNALLOC2(graph,cg1,cg1_sz,total_vertices,m,"malloc");
+                DYNALLOC2(graph,cg2,cg2_sz,total_vertices,m,"malloc");
+                densenauty(g1,lab1,ptn,orbits,&options,&stats,m,total_vertices,cg1);
+                densenauty(g2,lab2,ptn,orbits,&options,&stats,m,total_vertices,cg2);
+
+                // Compare the canonical graphs to see if the two graphs are
+                // isomorphic
+                bool isomorphic = true;
+                for (int k = 0; k < m*total_vertices; k++) {
+                    if (cg1[k] != cg2[k]) {
+                        isomorphic = false;
+                        break;
+                    }
+                }
+                if (false) {
+                    // Print the mapping between graphs for debugging purposes
+                    for (int i = 0; i < total_vertices; ++i) {
+                        map[lab1[i]] = lab2[i];
+                    }
+                    for (int i = 0; i < total_vertices; ++i) {
+                        printf(" %d-%d",i,map[i]);
+                    }
+                    printf("\n");
+                }
+
+                return isomorphic;
+            }
+#endif
+            
+    };
+
+    enum partial_gen_type
+    {
+        GEN_TUPLES, /// No restrictions besides acyclicity
+        GEN_CONNECTED, /// Generated graphs must be connected
+        GEN_COLEX, /// Graph inputs must be co-lexicographically ordered
+        GEN_NOREAPPLY, /// Graph inputs must not allow re-application of operators
+    };
+
+#ifndef DISABLE_NAUTY
+        class pd_iso_checker
+        {
+        private:
+            int total_vertices;
+            int *lab1;
+            size_t lab1_sz = 0;
+            int *lab2;
+            size_t lab2_sz = 0;
+            int *ptn;
+            size_t ptn_sz = 0;
+            int *orbits;
+            size_t orbits_sz = 0;
+            int *map;
+            size_t map_sz = 0;
+            graph *g1 = NULL;
+            size_t g1_sz = 0;
+            graph *g2 = NULL;
+            size_t g2_sz = 0;
+            graph *cg1 = NULL;
+            size_t cg1_sz = 0;
+            graph *cg2 = NULL;
+            size_t cg2_sz = 0;
+            statsblk stats;
+            int m;
+
+            void initialize()
+            {
+                m = SETWORDSNEEDED(total_vertices);;
+
+                DYNALLOC1(int, lab1, lab1_sz, total_vertices, "malloc");
+                DYNALLOC1(int, lab2, lab2_sz, total_vertices, "malloc");
+                DYNALLOC1(int, ptn, ptn_sz, total_vertices, "malloc");
+                DYNALLOC1(int, orbits, orbits_sz, total_vertices, "malloc");
+                DYNALLOC1(int, map, map_sz, total_vertices, "malloc");
+
+                DYNALLOC2(graph, g1, g1_sz, total_vertices, m, "malloc");
+                DYNALLOC2(graph, g2, g2_sz, total_vertices, m, "malloc");
+
+                DYNALLOC2(graph, cg1, cg1_sz, total_vertices, m, "malloc");
+                DYNALLOC2(graph, cg2, cg2_sz, total_vertices, m, "malloc");
+            }
+
+        public:
+            pd_iso_checker(int _total_vertices)
+            {
+                total_vertices = _total_vertices;
+                initialize();
+            }
+
+            ~pd_iso_checker()
+            {
+                DYNFREE(lab1, lab1_sz);
+                DYNFREE(lab2, lab2_sz);
+                DYNFREE(ptn, ptn_sz);
+                DYNFREE(orbits, orbits_sz);
+                DYNFREE(map, map_sz);
+
+                DYNFREE(g1, g1_sz);
+                DYNFREE(g2, g2_sz);
+
+                DYNFREE(cg1, cg1_sz);
+                DYNFREE(cg2, cg2_sz);
+            }
+
+            bool isomorphic(const partial_dag& dag1, const partial_dag& dag2)
+            {
+                void(*adjacencies)(graph*, int*, int*, int,
+                    int, int, int*, int, boolean, int, int) = NULL;
+
+                DEFAULTOPTIONS_DIGRAPH(options);
+                options.getcanon = TRUE;
+
+                const auto nr_vertices = dag1.nr_vertices();
+
+                EMPTYGRAPH(g1, m, nr_vertices);
+                EMPTYGRAPH(g2, m, nr_vertices);
+
+                for (int i = 1; i < nr_vertices; i++) {
+                    const auto& vertex = dag1.get_vertex(i);
+                    for (const auto fanin : vertex) {
+                        if (fanin != FANIN_PI) {
+                            ADDONEARC(g1, fanin - 1, i, m);
+                        }
+                    }
+                }
+
+                for (int i = 0; i < nr_vertices; i++) {
+                    const auto& vertex = dag2.get_vertex(i);
+                    for (const auto fanin : vertex) {
+                        if (fanin != FANIN_PI) {
+                            ADDONEARC(g2, fanin - 1, i, m);
+                        }
+                    }
+                }
+
+                densenauty(g1, lab1, ptn, orbits, &options, &stats, m, nr_vertices, cg1);
+                densenauty(g2, lab2, ptn, orbits, &options, &stats, m, nr_vertices, cg2);
+
+                bool isomorphic = true;
+                for (int k = 0; k < m*nr_vertices; k++) {
+                    if (cg1[k] != cg2[k]) {
+                        isomorphic = false;
+                        break;
+                    }
+                }
+                return isomorphic;
+            }
+
+            /// Computes the canonical representation of the given DAG 
+            /// and returns it as a vector of numbers.
+            std::vector<graph> crepr(const partial_dag& dag)
+            {
+                void(*adjacencies)(graph*, int*, int*, int,
+                    int, int, int*, int, boolean, int, int) = NULL;
+
+                DEFAULTOPTIONS_DIGRAPH(options);
+                options.getcanon = TRUE;
+
+                const auto nr_vertices = dag.nr_vertices();
+                std::vector<graph> repr(m*dag.nr_vertices());
+
+                EMPTYGRAPH(g1, m, nr_vertices);
+
+                for (int i = 1; i < nr_vertices; i++) {
+                    const auto& vertex = dag.get_vertex(i);
+                    for (const auto fanin : vertex) {
+                        if (fanin != FANIN_PI)
+                            ADDONEARC(g1, fanin - 1, i, m);
+                    }
+                }
+
+                densenauty(g1, lab1, ptn, orbits, &options, &stats, m, nr_vertices, cg1);
+
+                for (int k = 0; k < m * nr_vertices; k++) {
+                    repr[k] = cg1[k];
+                }
+
+                return repr;
+            }
+
+        };
+#endif
+
+        inline void write_partial_dag(const partial_dag& dag, FILE* fhandle)
+        {
+            int buf = dag.nr_vertices();
+            fwrite(&buf, sizeof(int), 1, fhandle);
+            for (int i = 0; i < dag.nr_vertices(); i++) {
+                auto& v = dag.get_vertex(i);
+                for (const auto fanin : v) {
+                    buf = fanin;
+                    auto stat = fwrite(&buf, sizeof(int), 1, fhandle);
+                    assert(stat == 1);
+                }
+            }
+        }
+
+        /// Writes a collection of partial DAGs to the specified filename
+        inline void write_partial_dags(const std::vector<partial_dag>& dags, const char* const filename)
+        {
+            auto fhandle = fopen(filename, "wb");
+            if (fhandle == NULL) {
+                fprintf(stderr, "Error: unable to open output file\n");
+                exit(1);
+            }
+
+            for (auto& dag : dags) {
+                write_partial_dag(dag, fhandle);
+            }
+
+            fclose(fhandle);
+        }
+
+    /// Isomorphism check using set containinment (hashing)
+    inline void pd_filter_isomorphic_sfast(
+        const std::vector<partial_dag>& dags, 
+        std::vector<partial_dag>& ni_dags,
+        bool show_progress = false)
+    {
+#ifndef DISABLE_NAUTY
+        if (dags.size() == 0) {
+            return;
+        }
+
+        const auto nr_vertices = dags[0].nr_vertices();
+        pd_iso_checker checker(nr_vertices);
+        std::vector<std::vector<graph>> reprs(dags.size());
+        auto ctr = 0u;
+        if (show_progress)
+            printf("computing canonical representations\n");
+        for (auto i = 0u; i < dags.size(); i++) {
+            const auto& dag = dags[i];
+            reprs[i] = checker.crepr(dag);
+            if (show_progress)
+                printf("(%u,%zu)\r", ++ctr, dags.size());
+        }
+        if (show_progress)
+            printf("\n");
+
+        std::vector<int> is_iso(dags.size());
+        for (auto i = 0u; i < dags.size(); i++) {
+            is_iso[i] = 0;
+        }
+
+        std::set<std::vector<graph>> can_reps;
+        
+        ctr = 0u;
+        if (show_progress)
+            printf("checking isomorphisms\n");
+        for (auto i = 0u; i < dags.size(); i++) {
+            auto repr = reprs[i];
+            const auto res = can_reps.insert(repr);
+            if (!res.second) { // Already have an isomorphic representative
+                is_iso[i] = 1;
+            }
+            if (show_progress)
+                printf("(%u,%zu)\r", ++ctr, dags.size());
+        }
+        if (show_progress)
+            printf("\n");
+
+        for (auto i = 0u; i < dags.size(); i++) {
+            if (!is_iso[i]) {
+                ni_dags.push_back(dags[i]);
+            }
+        }
+#else
+        for (auto& dag : dags) {
+            ni_dags.push_back(dag);
+        }
+#endif
+    }
+
+
+#ifndef DISABLE_NAUTY
+    inline std::vector<partial_dag> pd_filter_isomorphic(
+        const std::vector<partial_dag>& dags, 
+        std::vector<partial_dag>& ni_dags,
+        bool show_progress = false)
+    {
+        size_t ctr = 0;
+        for (const auto& g1 : dags) {
+            bool iso_found = false;
+            for (const auto& g2 : ni_dags) {
+                if (g2.nr_vertices() == g1.nr_vertices()) {
+                    if (g1.is_isomorphic(g2)) {
+                        iso_found = true;
+                        break;
+                    }
+                }
+            }
+            if (!iso_found) {
+                ni_dags.push_back(g1);
+            }
+            if (show_progress)
+                printf("(%zu, %zu)\r", ++ctr, dags.size());
+        }
+        if (show_progress)
+            printf("\n");
+
+        return ni_dags;
+    }
+
+    inline std::vector<partial_dag> pd_filter_isomorphic(
+        const std::vector<partial_dag>& dags,
+        bool show_progress = false)
+    {
+        std::vector<partial_dag> ni_dags;
+        pd_filter_isomorphic(dags, ni_dags, show_progress);
+        return ni_dags;
+    }
+
+    /// Filters out isomorphic DAGs. NOTE: assumes that
+    /// all gven DAGs have the same number of vertices.
+    inline void pd_filter_isomorphic_fast(
+        const std::vector<partial_dag>& dags, 
+        std::vector<partial_dag>& ni_dags,
+        bool show_progress = false)
+    {
+        if (dags.size() == 0) {
+            return;
+        }
+
+        const auto nr_vertices = dags[0].nr_vertices();
+        pd_iso_checker checker(nr_vertices);
+        std::vector<std::vector<graph>> reprs(dags.size());
+        auto ctr = 0u;
+        if (show_progress)
+            printf("computing canonical representations\n");
+        for (auto i = 0u; i < dags.size(); i++) {
+            const auto& dag = dags[i];
+            reprs[i] = checker.crepr(dag);
+            if (show_progress)
+                printf("(%u,%zu)\r", ++ctr, dags.size());
+        }
+        if (show_progress)
+            printf("\n");
+
+        std::vector<int> is_iso(dags.size());
+        for (auto i = 0u; i < dags.size(); i++) {
+            is_iso[i] = 0;
+        }
+        
+        ctr = 0u;
+        if (show_progress)
+            printf("checking isomorphisms\n");
+        for (auto i = 1u; i < dags.size(); i++) {
+            for (auto j = 0u; j < i; j++) {
+                if (reprs[i] == reprs[j]) {
+                    is_iso[i] = 1;
+                    break;
+                }
+            }
+            if (show_progress)
+                printf("(%u,%zu)\r", ++ctr, dags.size());
+        }
+        if (show_progress)
+            printf("\n");
+
+        for (auto i = 0u; i < dags.size(); i++) {
+            if (!is_iso[i]) {
+                ni_dags.push_back(dags[i]);
+            }
+        }
+    }
+
+    
+    inline void pd_filter_isomorphic(
+        const std::vector<partial_dag>& dags, 
+        int max_size, 
+        std::vector<partial_dag>& ni_dags,
+        bool show_progress = false)
+    {
+        size_t ctr = 0;
+        pd_iso_checker checker(max_size);
+        for (const auto& g1 : dags) {
+            bool iso_found = false;
+            for (const auto& g2 : ni_dags) {
+                if (g2.nr_vertices() == g1.nr_vertices()) {
+                    if (checker.isomorphic(g1, g2)) {
+                        iso_found = true;
+                        break;
+                    }
+                }
+            }
+            if (!iso_found) {
+                ni_dags.push_back(g1);
+            }
+            if (show_progress)
+                printf("(%zu,%zu)\r", ++ctr, dags.size());
+        }
+        if (show_progress)
+            printf("\n");
+        ni_dags = dags;
+    }
+
+    inline std::vector<partial_dag> pd_filter_isomorphic(
+        const std::vector<partial_dag>& dags, 
+        int max_size,
+        bool show_progress = false)
+    {
+        std::vector<partial_dag> ni_dags;
+        pd_filter_isomorphic(dags, max_size, ni_dags, show_progress);
+        return ni_dags;
+    }
+#endif
+
+  /*! \brief Writes a partial DAG in DOT format to output stream
+   *
+   *  Converts a partial DAG to the GraphViz DOT format and writes it
+   *  to the specified output stream
+   */
+  inline void to_dot( partial_dag const& pdag, std::ostream& os )
+  {
+    os << "graph{\n";
+    os << "rankdir = BT;\n";
+
+    pdag.foreach_vertex( [&pdag, &os]( auto const& v, int index ){
+        std::string label = "(";
+        for ( auto i = 0; i < v.size(); ++i )
+        {
+          label += std::to_string( v.at( i ) );
+          if ( i+1 < v.size() )
+            label += ',';
+        }
+        label += ")";
+
+        auto const dot_index = index + 1;
+        os << "n" << dot_index << " [label=<<sub>" << dot_index << "</sub> " << label << ">];\n";
+
+        for ( const auto& child : v )
+        {
+          if ( child != 0u )
+            os << "n" << child << " -- n" << dot_index << ";\n";
+        }
+      });
+    os << "}\n";
+  }
+
+  /*! \brief Writes partial DAG in DOT format into file
+   *
+   *  Converts a partial DAG to the GraphViz DOT format and writes it
+   *  to the specified file
+   */
+  inline void to_dot( partial_dag const& pdag, std::string const& filename )
+  {
+    std::ofstream ofs( filename, std::ofstream::out );
+    to_dot( pdag, ofs );
+    ofs.close();
+  }
+}
diff --git a/lib/percy/percy/percy.hpp b/lib/percy/percy/percy.hpp
new file mode 100644
index 0000000..35bb316
--- /dev/null
+++ b/lib/percy/percy/percy.hpp
@@ -0,0 +1,1939 @@
+#pragma once
+
+#include <chrono>
+#include <memory>
+#include <thread>
+#include <mutex>
+#include "spec.hpp"
+#include "fence.hpp"
+#include "chain.hpp"
+#include "mig.hpp"
+#include "dag_generation.hpp"
+#include "tt_utils.hpp"
+#include "concurrentqueue.h"
+#include "partial_dag.hpp"
+#include "generators/partial_dag_generator.hpp"
+#include "generators/partial_dag3_generator.hpp"
+#include "solvers.hpp"
+#include "encoders.hpp"
+#include "cnf.hpp"
+#include <limits>
+
+/*******************************************************************************
+    This module defines the interface to synthesize Boolean chains from
+    specifications. The inspiration for this module is taken from Mathias
+    Soeken's earlier exact synthesis algorithm, which has been integrated in
+    the ABC synthesis package. That implementation is itself based on earlier
+    work by Éen[1] and Knuth[2].
+    [1] Niklas Éen, "Practical SAT – a tutorial on applied satisfiability
+    solving," 2007, slides of invited talk at FMCAD.
+    [2] Donald Ervin Knuth, "The Art of Computer Programming, Volume 4,
+    Fascicle 6: Satisfiability," 2015
+*******************************************************************************/
+namespace percy
+{
+	using std::chrono::high_resolution_clock;
+	using std::chrono::duration;
+	using std::chrono::time_point;
+
+    const int PD_SIZE_CONST = 1000; // Some "impossibly large" number
+
+    inline synth_result 
+    std_synthesize(
+        spec& spec, 
+        chain& chain, 
+        solver_wrapper& solver, 
+        std_encoder& encoder,
+        synth_stats* stats = NULL)
+    {
+        assert(spec.get_nr_in() >= spec.fanin);
+        spec.preprocess();
+
+        if (stats) {
+            stats->synth_time = 0;
+            stats->sat_time = 0;
+            stats->unsat_time = 0;
+            stats->nr_vars = 0;
+            stats->nr_clauses = 0;
+        }
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            chain.reset(spec.get_nr_in(), spec.get_nr_out(), 0, spec.fanin);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                chain.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        spec.nr_steps = spec.initial_steps;
+        while (spec.nr_steps <= spec.max_nr_steps) {
+            solver.restart();
+            if (!encoder.encode(spec)) {
+                spec.nr_steps++;
+                continue;
+            }
+            if (stats) {
+                stats->nr_vars = solver.nr_vars();
+                stats->nr_clauses = solver.nr_clauses();
+            }
+
+            auto begin = std::chrono::steady_clock::now();
+            const auto status = solver.solve(spec.conflict_limit);
+            auto end = std::chrono::steady_clock::now();
+            auto elapsed_time =
+                std::chrono::duration_cast<std::chrono::microseconds>(
+                    end - begin
+                    ).count();
+
+            if (stats) {
+                stats->synth_time += elapsed_time;
+            }
+
+            if (status == success) {
+                encoder.extract_chain(spec, chain);
+                if (spec.verbosity > 2) {
+                    //    encoder.print_solver_state(spec);
+                }
+                if (stats) {
+                    stats->sat_time += elapsed_time;
+                }
+                return success;
+            } else if (status == failure) {
+                if (stats) {
+                    stats->unsat_time += elapsed_time;
+                }
+                spec.nr_steps++;
+            } else {
+                return timeout;
+            }
+        }
+        return timeout;
+    }
+
+    inline synth_result
+    std_cegar_synthesize(
+        spec& spec, 
+        chain& chain, 
+        solver_wrapper& solver, 
+        std_cegar_encoder& encoder,
+        synth_stats* stats = NULL)
+    {
+        assert(spec.get_nr_in() >= spec.fanin);
+        spec.preprocess();
+
+        if (stats) {
+            stats->synth_time = 0;
+            stats->sat_time = 0;
+            stats->unsat_time = 0;
+        }
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            chain.reset(spec.get_nr_in(), spec.get_nr_out(), 0, spec.fanin);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                chain.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        encoder.reset_sim_tts(spec.nr_in);
+        spec.nr_steps = spec.initial_steps;
+        while (true) {
+            solver.restart();
+            if (!encoder.cegar_encode(spec)) {
+                spec.nr_steps++;
+                continue;
+            }
+            auto iMint = 1;
+            for (int i = 0; iMint != -1; i++) {
+                if (!encoder.create_tt_clauses(spec, iMint - 1)) {
+                    break;
+                }
+                auto begin = std::chrono::steady_clock::now();
+                auto stat = solver.solve(spec.conflict_limit);
+                auto end = std::chrono::steady_clock::now();
+                auto elapsed_time =
+                    std::chrono::duration_cast<std::chrono::microseconds>(
+                        end - begin
+                        ).count();
+                if (stats) {
+                    stats->synth_time += elapsed_time;
+                }
+                if (stat == failure) {
+                    if (stats) {
+                        stats->unsat_time += elapsed_time;
+                    }
+                    break;
+                } else {
+                    if (stats) {
+                        stats->sat_time += elapsed_time;
+                    }
+                }
+                iMint = encoder.simulate(spec);
+            }
+            if (iMint == -1) {
+                encoder.cegar_extract_chain(spec, chain);
+                break;
+            }
+            spec.nr_steps++;
+        }
+
+        return synth_result::success;
+    }
+
+    inline std::unique_ptr<solver_wrapper>
+    get_solver(SolverType type = SLV_BSAT2)
+    {
+        solver_wrapper * solver = nullptr;
+        std::unique_ptr<solver_wrapper> res;
+
+        switch (type) {
+        case SLV_BSAT2:
+            solver = new bsat_wrapper;
+            break;
+#ifdef USE_CMS
+        case SLV_CMSAT:
+            solver = new cmsat_wrapper;
+            break;
+#endif
+#if defined(USE_GLUCOSE) || defined(USE_SYRUP)
+        case SLV_GLUCOSE:
+            solver = new glucose_wrapper;
+            break;
+#endif
+#ifdef USE_SATOKO
+        case SLV_SATOKO:
+            solver = new satoko_wrapper;
+            break;
+#endif
+        default:
+            fprintf(stderr, "Error: solver type %d not found", type);
+            exit(1);
+        }
+
+        res.reset(solver);
+        return res;
+    }
+
+    inline std::unique_ptr<encoder>
+    get_encoder(solver_wrapper& solver, EncoderType enc_type = ENC_SSV)
+    {
+        encoder * enc = nullptr;
+        std::unique_ptr<encoder> res;
+
+        switch (enc_type) {
+        case ENC_SSV:
+            enc = new ssv_encoder(solver);
+            break;
+        case ENC_MSV:
+            enc = new msv_encoder(solver);
+            break;
+        case ENC_DITT:
+            enc = new ditt_encoder(solver);
+            break;
+        case ENC_FENCE:
+            enc = new ssv_fence_encoder(solver);
+            break;
+        case ENC_DAG:
+            enc = new ssv_dag_encoder<2>();
+            break;
+        default:
+            fprintf(stderr, "Error: encoder type %d not found\n", enc_type);
+            exit(1);
+        }
+
+        res.reset(enc);
+        return res;
+    }
+
+    inline synth_result 
+    fence_synthesize(spec& spec, chain& chain, solver_wrapper& solver, fence_encoder& encoder)
+    {
+        assert(spec.get_nr_in() >= spec.fanin);
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            chain.reset(spec.get_nr_in(), spec.get_nr_out(), 0, spec.fanin);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                chain.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        // As the topological synthesizer decomposes the synthesis
+        // problem, to fairly count the total number of conflicts we
+        // should keep track of all conflicts in existence checks.
+        fence f;
+        po_filter<unbounded_generator> g(
+            unbounded_generator(spec.initial_steps),
+            spec.get_nr_out(), spec.fanin);
+        int old_nnodes = 1;
+        auto total_conflicts = 0;
+        while (true) {
+            g.next_fence(f);
+            spec.nr_steps = f.nr_nodes();
+
+            if (spec.nr_steps > old_nnodes) {
+                // Reset conflict count, since this is where other
+                // synthesizers reset it.
+                total_conflicts = 0;
+                old_nnodes = spec.nr_steps;
+            }
+
+            solver.restart();
+            if (!encoder.encode(spec, f)) {
+                continue;
+            }
+
+            if (spec.verbosity) {
+                printf("  next fence:\n");
+                print_fence(f);
+                printf("\n");
+                printf("nr_nodes=%d, nr_levels=%d\n", f.nr_nodes(),
+                    f.nr_levels());
+                for (int i = 0; i < f.nr_levels(); i++) {
+                    printf("f[%d] = %d\n", i, f[i]);
+                }
+            }
+            auto status = solver.solve(spec.conflict_limit);
+            if (status == success) {
+                encoder.extract_chain(spec, chain);
+                return success;
+            } else if (status == failure) {
+                total_conflicts += solver.nr_conflicts();
+                if (spec.conflict_limit &&
+                    total_conflicts > spec.conflict_limit) {
+                    return timeout;
+                }
+                continue;
+            } else {
+                return timeout;
+            }
+        }
+    }
+
+    inline synth_result
+    fence_synthesize(
+        spec& spec, 
+        chain& chain, 
+        solver_wrapper& solver, 
+        fence_encoder& encoder, 
+        fence& fence)
+    {
+        solver.restart();
+        if (!encoder.encode(spec, fence)) {
+            return failure;
+        }
+        auto status = solver.solve(spec.conflict_limit);
+        if (status == success) {
+            encoder.extract_chain(spec, chain);
+        }
+        return status;
+    }
+
+    inline synth_result
+    fence_cegar_synthesize(
+        spec& spec, 
+        chain& chain, 
+        solver_wrapper& solver, 
+        fence_encoder& encoder, 
+        fence& fence)
+    {
+        solver.restart();
+        if (!encoder.cegar_encode(spec, fence)) {
+            return failure;
+        }
+        
+        while (true) {
+            auto status = solver.solve(spec.conflict_limit);
+            if (status == success) {
+                auto sim_tt = encoder.simulate(spec);
+                if (spec.out_inv) {
+                    sim_tt = ~sim_tt;
+                }
+                auto xor_tt = sim_tt ^ (spec[0]);
+                auto first_one = kitty::find_first_one_bit(xor_tt);
+                if (first_one == -1) {
+                    encoder.extract_chain(spec, chain);
+                    return success;
+                }
+                // Add additional constraint.
+                if (spec.verbosity) {
+                    printf("  CEGAR difference at tt index %ld\n",
+                        first_one);
+                }
+                if (!encoder.create_tt_clauses(spec, first_one - 1)) {
+                    return failure;
+                }
+            } else {
+                return status;
+            }
+        }
+    }
+    
+    inline synth_result 
+    fence_cegar_synthesize(spec& spec, chain& chain, solver_wrapper& solver, fence_encoder& encoder)
+    {
+        assert(spec.get_nr_in() >= spec.fanin);
+
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            chain.reset(spec.get_nr_in(), spec.get_nr_out(), 0, spec.fanin);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                chain.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        encoder.reset_sim_tts(spec.nr_in);
+
+        fence f;
+        po_filter<unbounded_generator> g(
+            unbounded_generator(spec.initial_steps),
+            spec.get_nr_out(), spec.fanin);
+        while (true) {
+            g.next_fence(f);
+            spec.nr_steps = f.nr_nodes();
+
+            if (spec.verbosity) {
+                printf("  next fence:\n");
+                print_fence(f);
+                printf("\n");
+                printf("nr_nodes=%d, nr_levels=%d\n", f.nr_nodes(),
+                    f.nr_levels());
+                for (int i = 0; i < f.nr_levels(); i++) {
+                    printf("f[%d] = %d\n", i, f[i]);
+                }
+            }
+
+            solver.restart();
+            if (!encoder.cegar_encode(spec, f)) {
+                continue;
+            }
+            while (true) {
+                auto status = solver.solve(spec.conflict_limit);
+                if (status == success) {
+                    auto sim_tt = encoder.simulate(spec);
+                    if (spec.out_inv) {
+                        sim_tt = ~sim_tt;
+                    }
+                    auto xor_tt = sim_tt ^ (spec[0]);
+                    if (spec.has_dc_mask(0)) {
+                        xor_tt &= ~spec.get_dc_mask(0);
+                    }
+                    auto first_one = kitty::find_first_one_bit(xor_tt);
+                    if (first_one == -1) {
+                        encoder.extract_chain(spec, chain);
+                        return success;
+                    }
+                    if (!encoder.create_tt_clauses(spec, first_one - 1)) {
+                        break;
+                    }
+                } else if (status == failure) {
+                    break;
+                } else {
+                    return timeout;
+                }
+            }
+        }
+    }
+
+    ///< TODO: implement
+    /*
+    inline synth_result
+    dag_synthesize(spec& spec, chain& chain, solver_wrapper& solver, dag_encoder<2>& encoder)
+    {
+        return failure;
+    }
+    */
+
+    inline synth_result 
+    synthesize(
+        spec& spec, 
+        chain& chain, 
+        solver_wrapper& solver, 
+        encoder& encoder, 
+        SynthMethod synth_method = SYNTH_STD,
+        synth_stats * stats = NULL)
+    {
+        switch (synth_method) {
+        case SYNTH_STD:
+            return std_synthesize(spec, chain, solver, static_cast<std_encoder&>(encoder), stats);
+        case SYNTH_STD_CEGAR:
+            return std_cegar_synthesize(spec, chain, solver, static_cast<std_cegar_encoder&>(encoder), stats);
+        case SYNTH_FENCE:
+            return fence_synthesize(spec, chain, solver, static_cast<fence_encoder&>(encoder));
+        case SYNTH_FENCE_CEGAR:
+            return fence_cegar_synthesize(spec, chain, solver, static_cast<fence_encoder&>(encoder));
+     //   case SYNTH_DAG:
+      //      return dag_synthesize(spec, chain, solver, static_cast<dag_encoder<2>&>(encoder));
+        default:
+            fprintf(stderr, "Error: synthesis method %d not supported\n", synth_method);
+            exit(1);
+        }
+    }
+
+    inline synth_result
+    pd_synthesize(
+        spec& spec, 
+        chain& chain, 
+        const partial_dag& dag,
+        solver_wrapper& solver, 
+        partial_dag_encoder& encoder)
+    {
+        spec.nr_steps = dag.nr_vertices();
+        solver.restart();
+        if (!encoder.encode(spec, dag)) {
+            return failure;
+        }
+
+        synth_result status;
+        status = solver.solve(0);
+
+        if (status == success) {
+            encoder.extract_chain(spec, dag, chain);
+            if (spec.verbosity > 2) {
+                //    encoder.print_solver_state(spec);
+            }
+            return success;
+        } else if (status == failure) {
+            return failure;
+        } else {
+            return percy::synth_result::timeout;
+        }
+    }
+
+    inline synth_result pd_cegar_synthesize(
+        spec& spec, 
+        chain& chain, 
+        const partial_dag& dag,
+        solver_wrapper& solver, 
+        partial_dag_encoder& encoder)
+    {
+        spec.nr_steps = dag.nr_vertices();
+        solver.restart();
+        if (!encoder.cegar_encode(spec, dag)) {
+            return failure;
+        }
+        while (true) {
+            auto stat = solver.solve(0);
+
+            if (stat == success) {
+                auto sim_tt = encoder.simulate(spec, dag);
+                if (spec.out_inv) {
+                    sim_tt = ~sim_tt;
+                }
+                auto xor_tt = sim_tt ^ (spec[0]);
+                auto first_one = kitty::find_first_one_bit(xor_tt);
+                if (first_one == -1) {
+                    encoder.extract_chain(spec, dag, chain);
+                    return success;
+                }
+                // Add additional constraint.
+                if (spec.verbosity) {
+                    printf("  CEGAR difference at tt index %ld\n",
+                        first_one);
+                }
+                if (!encoder.create_tt_clauses(spec, dag, first_one - 1)) {
+                    return failure;
+                } else if (!encoder.fix_output_sim_vars(spec, first_one - 1)) {
+                    return failure;
+                }
+            } else {
+                return failure;
+            }
+        }
+    }
+
+    inline synth_result
+    pd_synthesize_enum(
+        spec& spec, 
+        chain& chain, 
+        const partial_dag& dag)
+    {
+        partial_dag_generator gen;
+        chain.reset(spec.get_nr_in(), 1, dag.nr_vertices(), 2);
+        chain.set_output(0, (spec.get_nr_in() + dag.nr_vertices()) << 1);
+
+        const auto found_sol = gen.search_sol(spec, chain, dag, 0);
+        if (found_sol) {
+            return success;
+        } else {
+            return failure;
+        }
+    }
+
+    inline synth_result
+    pd_synthesize_enum(
+        spec& spec, 
+        chain& chain, 
+        const std::vector<partial_dag>& dags)
+    {
+        partial_dag_generator gen;
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            chain.reset(spec.get_nr_in(), spec.get_nr_out(), 0, spec.fanin);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                chain.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        for (const auto& dag : dags) {
+            const auto result = 
+                pd_synthesize_enum(spec, chain, dag);
+            if (result == success) {
+                return success;
+            }
+        }
+
+        return failure;
+    }
+
+    inline synth_result pd_synthesize(
+        spec& spec,
+        chain& chain,
+        const std::vector<partial_dag>& dags,
+        solver_wrapper& solver,
+        partial_dag_encoder& encoder,
+        SynthMethod synth_method = SYNTH_STD)
+    {
+        assert(spec.get_nr_in() >= spec.fanin);
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            chain.reset(spec.get_nr_in(), spec.get_nr_out(), 0, spec.fanin);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                chain.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        for (auto& dag : dags) {
+            synth_result status;
+            switch (synth_method) {
+            case SYNTH_STD_CEGAR:
+                status = pd_cegar_synthesize(spec, chain, dag, solver, encoder);
+                break;
+            default:
+                status = pd_synthesize(spec, chain, dag, solver, encoder);
+                break;
+            }
+            if (status == success) {
+                return success;
+            }
+        }
+        return failure;
+    }
+
+    inline synth_result
+    pd_synthesize_parallel(
+        spec& spec, 
+        chain& c, 
+        const std::vector<partial_dag>& dags,
+        int num_threads = std::thread::hardware_concurrency())
+    {
+        assert(spec.get_nr_in() >= spec.fanin);
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            c.reset(spec.get_nr_in(), spec.get_nr_out(), 0, spec.fanin);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                c.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        std::vector<std::thread> threads(num_threads);
+
+        moodycamel::ConcurrentQueue<partial_dag> q(num_threads * 3);
+
+        bool finished_generating = false;
+        bool* pfinished = &finished_generating;
+        int size_found = PD_SIZE_CONST;
+        int* psize_found = &size_found;
+        std::mutex found_mutex;
+
+        for (int i = 0; i < num_threads; i++) {
+            threads[i] = std::thread([&spec, psize_found, pfinished, &found_mutex, &c, &q] {
+                percy::spec local_spec = spec;
+                bsat_wrapper solver;
+                partial_dag_encoder encoder(solver);
+                partial_dag dag;
+                local_spec.nr_steps = 0;
+
+                while (*psize_found > local_spec.nr_steps) {
+                    if (!q.try_dequeue(dag)) {
+                        if (*pfinished) {
+                            std::this_thread::yield();
+                            if (!q.try_dequeue(dag)) {
+                                break;
+                            }
+                        } else {
+                            std::this_thread::yield();
+                            continue;
+                        }
+                    }
+                    local_spec.nr_steps = dag.nr_vertices();
+                    synth_result status;
+                    solver.restart();
+                    if (!encoder.encode(local_spec, dag)) {
+                        continue;
+                    }
+                    while (true) {
+                        status = solver.solve(10);
+                        if (status == failure) {
+                            break;
+                        } else if (status == success) {
+                            std::lock_guard<std::mutex> vlock(found_mutex);
+                            if (*psize_found > local_spec.nr_steps) {
+                                encoder.extract_chain(local_spec, dag, c);
+                                *psize_found = local_spec.nr_steps;
+                            }
+                            break;
+                        } else if (*psize_found <= local_spec.nr_steps) {
+                            // Another thread found a solution that's
+                            // better or equal to this one.
+                            break;
+                        }
+
+                    }
+                }
+            });
+        }
+        size_t dag_idx = 0;
+        while (size_found == PD_SIZE_CONST) {
+            while (!q.try_enqueue(dags.at(dag_idx))) {
+                if (size_found == PD_SIZE_CONST) {
+                    std::this_thread::yield();
+                } else {
+                    break;
+                }
+            }
+            dag_idx++;
+        }
+        finished_generating = true;
+        for (auto& thread : threads) {
+            thread.join();
+        }
+
+        return success;
+    }
+
+
+    /// Synthesizes a chain using a set of serialized partial DAGs.
+    inline synth_result pd_ser_synthesize(
+        spec& spec,
+        chain& chain,
+        solver_wrapper& solver,
+        partial_dag_encoder& encoder,
+        std::string file_prefix = "",
+        int max_time = std::numeric_limits<int>::max()) // Timeout in seconds
+    {
+        assert(spec.get_nr_in() >= spec.fanin);
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            chain.reset(spec.get_nr_in(), spec.get_nr_out(), 0, spec.fanin);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                chain.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        partial_dag g;
+        spec.nr_steps = spec.initial_steps;
+        auto begin = std::chrono::steady_clock::now();
+        while (true) {
+            g.reset(2, spec.nr_steps);
+            const auto filename = file_prefix + "pd" + std::to_string(spec.nr_steps) + ".bin";
+            auto fhandle = fopen(filename.c_str(), "rb");
+            if (fhandle == NULL) {
+                fprintf(stderr, "Error: unable to open file %s\n", filename.c_str());
+                break;
+            }
+
+            int buf;
+            while (fread(&buf, sizeof(int), 1, fhandle) != 0) {
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    auto read = fread(&buf, sizeof(int), 1, fhandle);
+                    assert(read > 0);
+                    auto fanin1 = buf;
+                    read = fread(&buf, sizeof(int), 1, fhandle);
+                    assert(read > 0);
+                    auto fanin2 = buf;
+                    g.set_vertex(i, fanin1, fanin2);
+                }
+                solver.restart();
+                if (!encoder.encode(spec, g)) {
+                    continue;
+                }
+                const auto status = solver.solve(0);
+                auto end = std::chrono::steady_clock::now();
+                auto elapsed_time =
+                    std::chrono::duration_cast<std::chrono::seconds>(
+                        end - begin
+                        ).count();
+                if (elapsed_time > max_time) {
+                    return timeout;
+                }
+                if (status == success) {
+                    encoder.extract_chain(spec, g, chain);
+                    fclose(fhandle);
+                    return success;
+                }
+            }
+            fclose(fhandle);
+            spec.nr_steps++;
+        }
+
+        return failure;
+    }
+
+    /// Same as pd_ser_synthesize, but parallel.  
+    inline synth_result pd_ser_synthesize_parallel(
+        spec& spec,
+        chain& c,
+        int num_threads = std::thread::hardware_concurrency(),
+        std::string file_prefix ="")
+    {
+        assert(spec.get_nr_in() >= spec.fanin);
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            c.reset(spec.get_nr_in(), spec.get_nr_out(), 0, spec.fanin);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                c.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        std::vector<std::thread> threads(num_threads);
+        moodycamel::ConcurrentQueue<partial_dag> q(num_threads * 3);
+        bool finished_generating = false;
+        bool* pfinished = &finished_generating;
+        int size_found = PD_SIZE_CONST;
+        int* psize_found = &size_found;
+        std::mutex found_mutex;
+
+        for (int i = 0; i < num_threads; i++) {
+            threads[i] = std::thread([&spec, psize_found, pfinished, &found_mutex, &c, &q] {
+                percy::spec local_spec = spec;
+                bsat_wrapper solver;
+                partial_dag_encoder encoder(solver);
+                partial_dag dag;
+
+                while (*psize_found > local_spec.nr_steps) {
+                    if (!q.try_dequeue(dag)) {
+                        if (*pfinished) {
+                            std::this_thread::yield();
+                            if (!q.try_dequeue(dag)) {
+                                break;
+                            }
+                        } else {
+                            std::this_thread::yield();
+                            continue;
+                        }
+                    }
+                    local_spec.nr_steps = dag.nr_vertices();
+                    synth_result status;
+                    solver.restart();
+                    if (!encoder.encode(local_spec, dag)) {
+                        continue;
+                    }
+                    while (true) {
+                        status = solver.solve(10);
+                        if (status == failure) {
+                            break;
+                        } else if (status == success) {
+                            std::lock_guard<std::mutex> vlock(found_mutex);
+                            if (*psize_found > local_spec.nr_steps) {
+                                encoder.extract_chain(local_spec, dag, c);
+                                *psize_found = local_spec.nr_steps;
+                            }
+                            break;
+                        } else if (*psize_found <= local_spec.nr_steps) {
+                            // Another thread found a solution that's
+                            // better or equal to this one.
+                            break;
+                        }
+                    }
+                }
+            });
+        }
+
+        partial_dag g;
+        spec.nr_steps = spec.initial_steps;
+        while (size_found == PD_SIZE_CONST) {
+            g.reset(2, spec.nr_steps);
+            const auto filename = file_prefix + "pd" + std::to_string(spec.nr_steps) + ".bin";
+            auto fhandle = fopen(filename.c_str(), "rb");
+            if (fhandle == NULL) {
+                fprintf(stderr, "Error: unable to open PD file\n");
+                break;
+            }
+
+            int buf;
+            while (fread(&buf, sizeof(int), 1, fhandle) != 0) {
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    auto read = fread(&buf, sizeof(int), 1, fhandle);
+                    assert(read > 0);
+                    auto fanin1 = buf;
+                    read = fread(&buf, sizeof(int), 1, fhandle);
+                    assert(read > 0);
+                    auto fanin2 = buf;
+                    g.set_vertex(i, fanin1, fanin2);
+                }
+                while (!q.try_enqueue(g)) {
+                    if (size_found == PD_SIZE_CONST) {
+                        std::this_thread::yield();
+                    } else {
+                        break;
+                    }
+                }
+                if (size_found != PD_SIZE_CONST) {
+                    break;
+                }
+            }
+            fclose(fhandle);
+            spec.nr_steps++;
+        }
+        finished_generating = true;
+        for (auto& thread : threads) {
+            thread.join();
+        }
+        spec.nr_steps = size_found;
+
+        return size_found == PD_SIZE_CONST ? failure : success;
+    }
+            
+    inline synth_result
+    pf_fence_synthesize(
+        spec& spec, 
+        chain& c, 
+        int num_threads = std::thread::hardware_concurrency())
+    {
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            c.reset(spec.get_nr_in(), spec.get_nr_out(), 0, spec.fanin);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                c.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        std::vector<std::thread> threads(num_threads);
+
+        moodycamel::ConcurrentQueue<fence> q(num_threads * 3);
+
+        bool finished_generating = false;
+        bool* pfinished = &finished_generating;
+        bool found = false;
+        bool* pfound = &found;
+        std::mutex found_mutex;
+
+        spec.nr_steps = spec.initial_steps;
+        while (true) {
+            for (int i = 0; i < num_threads; i++) {
+                threads[i] = std::thread([&spec, pfinished, pfound, &found_mutex, &c, &q] {
+                    bsat_wrapper solver;
+                    ssv_fence2_encoder encoder(solver);
+                    fence local_fence;
+
+                    while (!(*pfound)) {
+                        if (!q.try_dequeue(local_fence)) {
+                            if (*pfinished) {
+                                std::this_thread::yield();
+                                if (!q.try_dequeue(local_fence)) {
+                                    break;
+                                }
+                            } else {
+                                std::this_thread::yield();
+                                continue;
+                            }
+                        }
+                        synth_result status;
+                        solver.restart();
+                        if (!encoder.encode(spec, local_fence)) {
+                            continue;
+                        }
+                        do {
+                            status = solver.solve(10);
+                            if (*pfound) {
+                                break;
+                            } else if (status == success) {
+                                std::lock_guard<std::mutex> vlock(found_mutex);
+                                if (!(*pfound)) {
+                                    encoder.extract_chain(spec, c);
+                                    *pfound = true;
+                                }
+                            }
+                        } while (status == timeout);
+                    }
+                });
+            }
+            generate_fences(spec, q);
+            finished_generating = true;
+
+            for (auto& thread : threads) {
+                thread.join();
+            }
+            if (found) {
+                break;
+            }
+            finished_generating = false;
+            spec.nr_steps++;
+        }
+
+        return success;
+    }
+    
+    /// Performs fence-based parallel synthesis.
+    /// One thread generates fences and places them on a concurrent
+    /// queue. The remaining threads dequeue fences and try to
+    /// synthesize chains with them.
+    inline synth_result
+    pf_synthesize(
+        spec& spec, 
+        chain&  chain, 
+        SynthMethod synth_method = SYNTH_FENCE)
+    {
+        switch (synth_method) {
+        case SYNTH_FENCE:
+            return pf_fence_synthesize(spec, chain);
+//        case SYNTH_FENCE_CEGAR:
+//            return pf_fence_cegar_synthesize(spec, chain, solver, encoder);
+        default:
+            fprintf(stderr, "Error: synthesis method %d not supported\n", synth_method);
+            exit(1);
+        }
+    }
+
+    inline synth_result
+    synthesize(
+        spec& spec, 
+        chain& chain, 
+        SolverType slv_type = SLV_BSAT2, 
+        EncoderType enc_type = ENC_SSV, 
+        SynthMethod method = SYNTH_STD)
+    {
+        auto solver = get_solver(slv_type);
+        auto encoder = get_encoder(*solver, enc_type);
+        return synthesize(spec, chain, *solver, *encoder, method);
+    }
+
+    inline synth_result
+    next_solution(
+        spec& spec, 
+        chain& chain, 
+        solver_wrapper& solver, 
+        enumerating_encoder& encoder, 
+        SynthMethod synth_method = SYNTH_STD)
+    {
+        if (!encoder.is_dirty()) {
+            encoder.set_dirty(true);
+            switch (synth_method) {
+            case SYNTH_STD:
+            case SYNTH_STD_CEGAR:
+                return std_synthesize(spec, chain, solver, dynamic_cast<std_encoder&>(encoder));
+            case SYNTH_FENCE:
+                return fence_synthesize(spec, chain, solver, dynamic_cast<fence_encoder&>(encoder));
+            default:
+                fprintf(stderr, "Error: solution enumeration not supported for synth method %d\n", synth_method);
+                exit(1);
+            }
+        }
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        // In this case, only one solution exists.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            return failure;
+        }
+
+        if (encoder.block_solution(spec)) {
+            const auto status = solver.solve(spec.conflict_limit);
+
+            if (status == success) {
+                encoder.extract_chain(spec, chain);
+                return success;
+            } else {
+                return status;
+            }
+        }
+
+        return failure;
+    }
+
+    inline synth_result
+    next_struct_solution(
+        spec& spec, 
+        chain& chain, 
+        solver_wrapper& solver, 
+        enumerating_encoder& encoder,
+        SynthMethod synth_method = SYNTH_STD)
+    {
+        if (!encoder.is_dirty()) {
+            encoder.set_dirty(true);
+            switch (synth_method) {
+            case SYNTH_STD:
+            case SYNTH_STD_CEGAR:
+                return std_synthesize(spec, chain, solver, dynamic_cast<std_encoder&>(encoder));
+            case SYNTH_FENCE:
+                return fence_synthesize(spec, chain, solver, dynamic_cast<fence_encoder&>(encoder));
+            default:
+                fprintf(stderr, "Error: solution enumeration not supported for synth method %d\n", synth_method);
+                exit(1);
+            }
+        }
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        // In this case, only one solution exists.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            return failure;
+        }
+
+        if (encoder.block_solution(spec)) {
+            const auto status = solver.solve(spec.conflict_limit);
+
+            if (status == success) {
+                encoder.extract_chain(spec, chain);
+                return success;
+            } else {
+                return status;
+            }
+        }
+
+        return failure;
+    }
+
+    inline synth_result
+    maj_synthesize(
+        spec& spec, 
+        mig& mig, 
+        solver_wrapper& solver, 
+        maj_encoder& encoder)
+    {
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            mig.reset(spec.get_nr_in(), spec.get_nr_out(), 0);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                mig.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        spec.nr_steps = spec.initial_steps;
+        while (true) {
+            solver.restart();
+            if (!encoder.encode(spec)) {
+              if ( spec.nr_steps < MAX_STEPS )
+              {
+                spec.nr_steps++;
+                continue;
+              }
+              else
+              {
+                return failure;
+              }
+            }
+
+            const auto status = solver.solve(spec.conflict_limit);
+
+            if (status == success) {
+                //encoder.print_solver_state(spec);
+                encoder.extract_mig(spec, mig);
+                return success;
+            } else if (status == failure) {
+              if ( spec.nr_steps < MAX_STEPS )
+              {
+                spec.nr_steps++;
+                continue;
+              }
+              else
+              {
+                return failure;
+              }
+            } else {
+                return timeout;
+            }
+        }
+    }
+
+    inline synth_result
+    mig_synthesize(
+        spec& spec, 
+        mig& mig, 
+        solver_wrapper& solver, 
+        mig_encoder& encoder)
+    {
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            mig.reset(spec.get_nr_in(), spec.get_nr_out(), 0);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                mig.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        spec.nr_steps = spec.initial_steps;
+        while (true) {
+            solver.restart();
+            if (!encoder.encode(spec)) {
+              if ( spec.nr_steps < MAX_STEPS )
+              {
+                spec.nr_steps++;
+                continue;
+              }
+              else
+              {
+                return failure;
+              }
+            }
+
+            const auto status = solver.solve(spec.conflict_limit);
+
+            if (status == success) {
+                //encoder.print_solver_state(spec);
+                encoder.extract_mig(spec, mig);
+                return success;
+            } else if (status == failure) {
+              if ( spec.nr_steps < MAX_STEPS )
+              {
+                spec.nr_steps++;
+                continue;
+              }
+              else
+              {
+                return failure;
+              }
+            } else {
+                return timeout;
+            }
+        }
+    }
+
+
+    inline int get_init_imint(const spec& spec)
+    {
+        int iMint = -1;
+        kitty::static_truth_table<6> tt;
+        for (int i = 1; i < (1 << spec.nr_in); i++) {
+            kitty::create_from_words(tt, &i, &i + 1);
+            const int nOnes = kitty::count_ones(tt);
+            if (nOnes < (spec.nr_in / 2) + 1) {
+                continue;
+            }
+            iMint = i;
+            break;
+        }
+
+        return iMint;
+    }
+
+    inline synth_result
+    maj_cegar_synthesize(
+        spec& spec, 
+        mig& mig, 
+        solver_wrapper& solver, 
+        maj_encoder& encoder)
+    {
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            mig.reset(spec.get_nr_in(), spec.get_nr_out(), 0);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                mig.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        encoder.reset_sim_tts(spec.nr_in);
+        spec.nr_steps = spec.initial_steps;
+        while (true) {
+            solver.restart();
+            if (!encoder.cegar_encode(spec)) {
+                spec.nr_steps++;
+                continue;
+            }
+            auto iMint = get_init_imint(spec);
+            //printf("initial iMint: %d\n", iMint);
+            for (int i = 0; iMint != -1; i++) {
+                if (!encoder.create_tt_clauses(spec, iMint - 1)) {
+                    spec.nr_steps++;
+                    break;
+                }
+
+                printf("Iter %3d : ", i);
+                printf("Var =%5d  ", solver.nr_vars());
+                printf("Cla =%6d  ", solver.nr_clauses());
+                printf("Conf =%9d\n", solver.nr_conflicts());
+
+                const auto status = solver.solve(spec.conflict_limit);
+                if (status == success) {
+                    iMint = encoder.simulate(spec);
+                } else if (status == failure) {
+                    spec.nr_steps++;
+                    break;
+                } else {
+                    return timeout;
+                }
+            }
+            if (iMint == -1) {
+                encoder.extract_mig(spec, mig);
+                return success;
+            }
+        }
+    }
+
+    inline synth_result
+    maj_fence_synthesize(spec& spec, mig& mig, solver_wrapper& solver, maj_encoder& encoder)
+    {
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            mig.reset(spec.get_nr_in(), spec.get_nr_out(), 0);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                mig.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        // As the topological synthesizer decomposes the synthesis
+        // problem, to fairly count the total number of conflicts we
+        // should keep track of all conflicts in existence checks.
+        fence f;
+        po_filter<unbounded_generator> g(
+            unbounded_generator(spec.initial_steps),
+            spec.get_nr_out(), 3);
+        auto fence_ctr = 0;
+        while (true) {
+            ++fence_ctr;
+            g.next_fence(f);
+            spec.nr_steps = f.nr_nodes();
+            solver.restart();
+            if (!encoder.encode(spec, f)) {
+                continue;
+            }
+
+            if (spec.verbosity) {
+                printf("next fence (%d):\n", fence_ctr);
+                print_fence(f);
+                printf("\n");
+                printf("nr_nodes=%d, nr_levels=%d\n", f.nr_nodes(),
+                    f.nr_levels());
+                for (int i = 0; i < f.nr_levels(); i++) {
+                    printf("f[%d] = %d\n", i, f[i]);
+                }
+            }
+            auto status = solver.solve(spec.conflict_limit);
+            if (status == success) {
+                encoder.fence_extract_mig(spec, mig);
+                //encoder.fence_print_solver_state(spec);
+                return success;
+            } else if (status == failure) {
+                continue;
+            } else {
+                return timeout;
+            }
+        }
+    }
+
+    inline synth_result maj_fence_cegar_synthesize(
+        spec& spec, 
+        mig& mig, 
+        solver_wrapper& solver, 
+        maj_encoder& encoder)
+    {
+        assert(spec.get_nr_in() >= spec.fanin);
+
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            mig.reset(spec.get_nr_in(), spec.get_nr_out(), 0);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                mig.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+
+        fence f;
+        po_filter<unbounded_generator> g(
+            unbounded_generator(spec.initial_steps),
+            spec.get_nr_out(), 3);
+        int fence_ctr = 0;
+        while (true) {
+            ++fence_ctr;
+            g.next_fence(f);
+            spec.nr_steps = f.nr_nodes();
+
+            if (spec.verbosity) {
+                printf("  next fence (%d):\n", fence_ctr);
+                print_fence(f);
+                printf("\n");
+                printf("nr_nodes=%d, nr_levels=%d\n", f.nr_nodes(),
+                    f.nr_levels());
+                for (int i = 0; i < f.nr_levels(); i++) {
+                    printf("f[%d] = %d\n", i, f[i]);
+                }
+            }
+
+            solver.restart();
+            if (!encoder.cegar_encode(spec, f)) {
+                continue;
+            }
+            while (true) {
+                auto status = solver.solve(spec.conflict_limit);
+                if (status == success) {
+                    encoder.fence_extract_mig(spec, mig);
+                    auto sim_tt = mig.simulate()[0];
+                    //auto sim_tt = encoder.simulate(spec);
+                    //if (spec.out_inv) {
+                    //    sim_tt = ~sim_tt;
+                    //}
+                    auto xor_tt = sim_tt ^ (spec[0]);
+                    auto first_one = kitty::find_first_one_bit(xor_tt);
+                    if (first_one == -1) {
+                        return success;
+                    }
+                    if (!encoder.fence_create_tt_clauses(spec, first_one - 1)) {
+                        break;
+                    }
+                } else if (status == failure) {
+                    break;
+                } else {
+                    return timeout;
+                }
+            }
+        }
+    }
+
+    inline synth_result 
+    parallel_maj_synthesize(
+        spec& spec,
+        mig& mig,
+        int num_threads = std::thread::hardware_concurrency())
+    {
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            mig.reset(spec.get_nr_in(), spec.get_nr_out(), 0);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                mig.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        std::vector<std::thread> threads(num_threads);
+        moodycamel::ConcurrentQueue<fence> q(num_threads * 3);
+
+        bool finished_generating = false;
+        bool* pfinished = &finished_generating;
+        bool found = false;
+        bool* pfound = &found;
+        std::mutex found_mutex;
+
+        spec.fanin = 3;
+        spec.nr_steps = spec.initial_steps;
+        while (true) {
+            for (int i = 0; i < num_threads; i++) {
+                threads[i] = std::thread([&spec, pfinished, pfound, &found_mutex, &mig, &q] {
+                    bmcg_wrapper solver;
+                    maj_encoder encoder(solver);
+                    fence local_fence;
+                    encoder.reset_sim_tts(spec.nr_in);
+
+                    while (!(*pfound)) {
+                        if (!q.try_dequeue(local_fence)) {
+                            if (*pfinished) {
+                                std::this_thread::yield();
+                                if (!q.try_dequeue(local_fence)) {
+                                    break;
+                                }
+                            } else {
+                                std::this_thread::yield();
+                                continue;
+                            }
+                        }
+
+                        /*
+                        if (spec.verbosity)
+                        {
+                            std::lock_guard<std::mutex> vlock(found_mutex);
+                            printf("  next fence:\n");
+                            print_fence(local_fence);
+                            printf("\n");
+                            printf("nr_nodes=%d, nr_levels=%d\n",
+                                local_fence.nr_nodes(),
+                                local_fence.nr_levels());
+                        }
+                        */
+
+                        synth_result status;
+                        solver.restart();
+                        if (!encoder.cegar_encode(spec, local_fence)) {
+                            continue;
+                        }
+                        auto iMint = get_init_imint(spec);
+                        for (int i = 0; !(*pfound) && iMint != -1; i++) {
+                            if (!encoder.fence_create_tt_clauses(spec, iMint - 1)) {
+                                break;
+                            }
+                            do {
+                                status = solver.solve(10);
+                                if (*pfound) {
+                                    break;
+                                }
+                            } while (status == timeout);
+
+                            if (status == failure) {
+                                break;
+                            }
+                            iMint = encoder.fence_simulate(spec);
+                        }
+                        if (iMint == -1) {
+                            std::lock_guard<std::mutex> vlock(found_mutex);
+                            if (!(*pfound)) {
+                                encoder.fence_extract_mig(spec, mig);
+                                *pfound = true;
+                            }
+                        }
+                    }
+                });
+            }
+            generate_fences(spec, q);
+            finished_generating = true;
+
+            for (auto& thread : threads) {
+                thread.join();
+            }
+            if (found) {
+                break;
+            }
+            finished_generating = false;
+            spec.nr_steps++;
+        }
+
+        return success;
+    }
+
+    inline synth_result
+    parallel_nocegar_maj_synthesize(
+        spec& spec, 
+        mig& mig, 
+        int num_threads = std::thread::hardware_concurrency())
+    {
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            mig.reset(spec.get_nr_in(), spec.get_nr_out(), 0);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                mig.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        std::vector<std::thread> threads(num_threads);
+        moodycamel::ConcurrentQueue<fence> q(num_threads * 3);
+
+        bool finished_generating = false;
+        bool* pfinished = &finished_generating;
+        bool found = false;
+        bool* pfound = &found;
+        std::mutex found_mutex;
+
+        spec.fanin = 3;
+        spec.nr_steps = spec.initial_steps;
+        while (true) {
+            for (int i = 0; i < num_threads; i++) {
+                threads[i] = std::thread([&spec, pfinished, pfound, &found_mutex, &mig, &q] {
+                    bmcg_wrapper solver;
+                    maj_encoder encoder(solver);
+                    fence local_fence;
+
+                    while (!(*pfound)) {
+                        if (!q.try_dequeue(local_fence)) {
+                            if (*pfinished) {
+                                std::this_thread::yield();
+                                if (!q.try_dequeue(local_fence)) {
+                                    break;
+                                }
+                            } else {
+                                std::this_thread::yield();
+                                continue;
+                            }
+                        }
+
+                        if (spec.verbosity)
+                        {
+                            std::lock_guard<std::mutex> vlock(found_mutex);
+                            printf("  next fence:\n");
+                            print_fence(local_fence);
+                            printf("\n");
+                            printf("nr_nodes=%d, nr_levels=%d\n",
+                                local_fence.nr_nodes(),
+                                local_fence.nr_levels());
+                        }
+
+                        synth_result status;
+                        solver.restart();
+                        if (!encoder.encode(spec, local_fence)) {
+                            continue;
+                        }
+                        do {
+                            status = solver.solve(10);
+                            if (*pfound) {
+                                break;
+                            } else if (status == success) {
+                                std::lock_guard<std::mutex> vlock(found_mutex);
+                                if (!(*pfound)) {
+                                    encoder.fence_extract_mig(spec, mig);
+                                    *pfound = true;
+                                }
+                            }
+                        } while (status == timeout);
+                    }
+                });
+            }
+            generate_fences(spec, q);
+            finished_generating = true;
+
+            for (auto& thread : threads) {
+                thread.join();
+            }
+            if (found) {
+                break;
+            }
+            finished_generating = false;
+            spec.nr_steps++;
+        }
+
+        return success;
+    }
+
+    inline synth_result
+    next_solution(
+        spec& spec,
+        mig& mig,
+        solver_wrapper& solver,
+        maj_encoder& encoder)
+    {
+        if (!encoder.is_dirty()) {
+            encoder.set_dirty(true);
+            return maj_synthesize(spec, mig, solver, encoder);
+        }
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        // In this case, only one solution exists.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            return failure;
+        }
+
+        if (encoder.block_solution(spec)) {
+            const auto status = solver.solve(spec.conflict_limit);
+
+            if (status == success) {
+                encoder.extract_mig(spec, mig);
+                return success;
+            } else {
+                return status;
+            }
+        }
+
+        return failure;
+    }
+
+    inline synth_result maj_pd_synthesize(
+        spec& spec,
+        mig& mig,
+        const std::vector<partial_dag>& dags,
+        solver_wrapper& solver,
+        maj_encoder& encoder)
+    {
+        assert(spec.get_nr_in() >= 3);
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            mig.reset(spec.get_nr_in(), spec.get_nr_out(), 0);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                mig.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        for (auto& dag : dags) {
+            spec.nr_steps = dag.nr_vertices();
+            solver.restart();
+            if (!encoder.encode(spec, dag)) {
+                continue;
+            }
+
+            const auto status = solver.solve(0);
+
+            if (status == success) {
+                encoder.extract_mig(spec, dag, mig);
+                //encoder.print_solver_state(spec, dag);
+                return success;
+            }
+        }
+        return failure;
+    }
+
+    inline synth_result maj_ser_synthesize(
+        spec& spec,
+        mig& mig,
+        solver_wrapper& solver,
+        maj_encoder& encoder,
+        std::string file_prefix = "",
+        int max_time = std::numeric_limits<int>::max()) // Timeout in seconds
+    {
+        assert(spec.get_nr_in() >= spec.fanin);
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            mig.reset(spec.get_nr_in(), spec.get_nr_out(), 0);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                mig.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        partial_dag g;
+        spec.nr_steps = spec.initial_steps;
+        auto begin = std::chrono::steady_clock::now();
+        while (true) {
+            g.reset(3, spec.nr_steps);
+            const auto filename = file_prefix + "pd" + std::to_string(spec.nr_steps) + ".bin";
+            auto fhandle = fopen(filename.c_str(), "rb");
+            if (fhandle == NULL) {
+                fprintf(stderr, "Error: unable to open file %s\n", filename.c_str());
+                break;
+            }
+
+            int buf;
+            while (fread(&buf, sizeof(int), 1, fhandle) != 0) {
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    auto read = fread(&buf, sizeof(int), 1, fhandle);
+                    assert(read > 0);
+                    auto fanin1 = buf;
+                    read = fread(&buf, sizeof(int), 1, fhandle);
+                    assert(read > 0);
+                    auto fanin2 = buf;
+                    read = fread(&buf, sizeof(int), 1, fhandle);
+                    assert(read > 0);
+                    auto fanin3 = buf;
+                    g.set_vertex(i, fanin1, fanin2, fanin3);
+                }
+                solver.restart();
+                if (!encoder.encode(spec, g)) {
+                    continue;
+                }
+                const auto status = solver.solve(0);
+                auto end = std::chrono::steady_clock::now();
+                auto elapsed_time =
+                    std::chrono::duration_cast<std::chrono::seconds>(
+                        end - begin
+                        ).count();
+                if (elapsed_time > max_time) {
+                    return timeout;
+                }
+                if (status == success) {
+                    encoder.extract_mig(spec, g, mig);
+                    fclose(fhandle);
+                    return success;
+                }
+            }
+            fclose(fhandle);
+            spec.nr_steps++;
+        }
+
+        return failure;
+    }
+
+    inline synth_result maj_ser_synthesize_parallel(
+        spec& spec,
+        mig& m,
+        int num_threads = std::thread::hardware_concurrency(),
+        std::string file_prefix ="")
+    {
+        assert(spec.get_nr_in() >= spec.fanin);
+        spec.preprocess();
+
+        // The special case when the Boolean chain to be synthesized
+        // consists entirely of trivial functions.
+        if (spec.nr_triv == spec.get_nr_out()) {
+            m.reset(spec.get_nr_in(), spec.get_nr_out(), 0);
+            for (int h = 0; h < spec.get_nr_out(); h++) {
+                m.set_output(h, (spec.triv_func(h) << 1) +
+                    ((spec.out_inv >> h) & 1));
+            }
+            return success;
+        }
+
+        std::vector<std::thread> threads(num_threads);
+        moodycamel::ConcurrentQueue<partial_dag> q(num_threads * 3);
+        bool finished_generating = false;
+        bool* pfinished = &finished_generating;
+        int size_found = PD_SIZE_CONST;
+        int* psize_found = &size_found;
+        std::mutex found_mutex;
+
+        for (int i = 0; i < num_threads; i++) {
+            threads[i] = std::thread([&spec, psize_found, pfinished, &found_mutex, &m, &q] {
+                percy::spec local_spec = spec;
+                bsat_wrapper solver;
+                maj_encoder encoder(solver);
+                partial_dag dag;
+
+                while (*psize_found > local_spec.nr_steps) {
+                    if (!q.try_dequeue(dag)) {
+                        if (*pfinished) {
+                            std::this_thread::yield();
+                            if (!q.try_dequeue(dag)) {
+                                break;
+                            }
+                        } else {
+                            std::this_thread::yield();
+                            continue;
+                        }
+                    }
+                    local_spec.nr_steps = dag.nr_vertices();
+                    synth_result status;
+                    solver.restart();
+                    if (!encoder.encode(local_spec, dag)) {
+                        continue;
+                    }
+                    while (true) {
+                        status = solver.solve(10);
+                        if (status == failure) {
+                            break;
+                        } else if (status == success) {
+                            std::lock_guard<std::mutex> vlock(found_mutex);
+                            if (*psize_found > local_spec.nr_steps) {
+                                encoder.extract_mig(local_spec, dag, m);
+                                *psize_found = local_spec.nr_steps;
+                            }
+                            break;
+                        } else if (*psize_found <= local_spec.nr_steps) {
+                            // Another thread found a solution that's
+                            // better or equal to this one.
+                            break;
+                        }
+                    }
+                }
+            });
+        }
+
+        partial_dag g;
+        spec.nr_steps = spec.initial_steps;
+        while (size_found == PD_SIZE_CONST) {
+            g.reset(3, spec.nr_steps);
+            const auto filename = file_prefix + "pd" + std::to_string(spec.nr_steps) + ".bin";
+            auto fhandle = fopen(filename.c_str(), "rb");
+            if (fhandle == NULL) {
+                fprintf(stderr, "Error: unable to open PD file\n");
+                break;
+            }
+
+            int buf;
+            while (fread(&buf, sizeof(int), 1, fhandle) != 0) {
+                for (int i = 0; i < spec.nr_steps; i++) {
+                    auto read = fread(&buf, sizeof(int), 1, fhandle);
+                    assert(read > 0);
+                    auto fanin1 = buf;
+                    read = fread(&buf, sizeof(int), 1, fhandle);
+                    assert(read > 0);
+                    auto fanin2 = buf;
+                    read = fread(&buf, sizeof(int), 1, fhandle);
+                    assert(read > 0);
+                    auto fanin3 = buf;
+                    g.set_vertex(i, fanin1, fanin2, fanin3);
+                }
+                while (!q.try_enqueue(g)) {
+                    if (size_found == PD_SIZE_CONST) {
+                        std::this_thread::yield();
+                    } else {
+                        break;
+                    }
+                }
+                if (size_found != PD_SIZE_CONST) {
+                    break;
+                }
+            }
+            fclose(fhandle);
+            spec.nr_steps++;
+        }
+        finished_generating = true;
+        for (auto& thread : threads) {
+            thread.join();
+        }
+        spec.nr_steps = size_found;
+
+        return size_found == PD_SIZE_CONST ? failure : success;
+    }
+}
+
diff --git a/lib/percy/percy/printer.hpp b/lib/percy/percy/printer.hpp
new file mode 100644
index 0000000..492ec95
--- /dev/null
+++ b/lib/percy/percy/printer.hpp
@@ -0,0 +1,129 @@
+#pragma once
+
+#include <kitty/dynamic_truth_table.hpp>
+
+#include <fmt/format.h>
+
+#include <string>
+#include <utility>
+#include <unordered_map>
+#include <map>
+
+namespace percy
+{
+
+template<typename ResultType>
+class printer
+{
+public:
+  explicit printer( chain const& c );
+
+  ResultType operator()() const;
+};
+
+template<>
+class printer<std::string>
+{
+public:
+  explicit printer( chain const& c )
+    : c( c )
+  {
+  }
+
+  std::string operator()() const
+  {    
+    assert( c.get_nr_outputs() == 1u );
+
+    std::string result;
+    auto const output_literal = c.get_outputs()[0u];
+    if ( output_literal & 1 )
+      result += "!";
+
+    auto const output_variable = output_literal >> 1u;
+    if ( output_variable == 0u )
+    {
+      /* special ase of constant 0 */
+      result += "0";
+    }
+    else
+    {
+      result += step_to_expression( output_variable - 1u );
+    }
+
+    return result;
+  }
+
+  std::string step_to_expression( uint32_t index ) const
+  {
+    auto const nr_in = c.get_nr_inputs();
+    if ( index < nr_in )
+    {
+      return std::string( 1u, 'a' + index );
+    }
+
+    const auto& step = c.get_step( index - nr_in );
+    auto const word = word_from_tt( c.get_operator( index - nr_in ) );
+    auto const it = masks.find( word );
+    if ( it == masks.end() )
+    {
+      assert( false );
+      return "error";
+    }
+
+    auto const mask = it->second;    
+    
+    std::string result;
+    switch ( c.get_fanin() )
+    {
+    case 2u:
+      return fmt::format( mask,
+                          step_to_expression( step.at( 0 ) ),
+                          step_to_expression( step.at( 1 ) ) );
+    case 3u:
+      return fmt::format( mask,
+                          step_to_expression( step.at( 0 ) ),
+                          step_to_expression( step.at( 1 ) ),
+                          step_to_expression( step.at( 2 ) ) );
+    case 4u:
+      return fmt::format( mask,
+                          step_to_expression( step.at( 0 ) ),
+                          step_to_expression( step.at( 1 ) ),
+                          step_to_expression( step.at( 2 ) ),
+                          step_to_expression( step.at( 3 ) ) );
+    case 5u:
+      return fmt::format( mask,
+                          step_to_expression( step.at( 0 ) ),
+                          step_to_expression( step.at( 1 ) ),
+                          step_to_expression( step.at( 2 ) ),
+                          step_to_expression( step.at( 3 ) ),
+                          step_to_expression( step.at( 4 ) ) );
+    default:
+      return mask;
+    }
+  }
+  
+  void add_function( kitty::dynamic_truth_table const& tt, std::string const& mask )
+  {
+    masks[word_from_tt( tt )] = mask;
+  }
+
+protected:
+  static inline uint32_t word_from_tt( kitty::dynamic_truth_table const& tt )
+  {
+    auto word = 0;
+    for ( int i = 0; i < tt.num_vars(); ++i )
+    {
+      if ( kitty::get_bit( tt, i ) )
+        word |= ( 1 << i );
+    }
+    return word;
+  }
+  
+protected:
+  chain const& c;
+
+  /* maps the function to their string representation, e.g.,  2 --> "(%s%s)" */
+  std::map<uint32_t,std::string> masks;
+}; /* printer */
+
+} // namespace printer
diff --git a/lib/percy/percy/sat_circuits.hpp b/lib/percy/percy/sat_circuits.hpp
new file mode 100644
index 0000000..085aad5
--- /dev/null
+++ b/lib/percy/percy/sat_circuits.hpp
@@ -0,0 +1,97 @@
+#pragma once
+
+#include <vector>
+#include <percy/solvers.hpp>
+
+namespace percy
+{
+    /// Given a solver, a list of variables, and a cardinality C, encodes a circuit in the solver which
+    /// can be used to check if the binary sum of the variables is less than, equal to, or greater
+    /// than C.
+    /// This encoding is due to Andrey Mokhov.
+    inline void create_cardinality_circuit(
+        solver_wrapper * solver,
+        const std::vector<int>& sum_vars,
+        const std::vector<int>& res_vars,
+        const int C)
+    {
+        int lits[3];
+
+        // We have C + 2 result variables per addition step: (res[0], res[1], ..., res[C], res[C+1]).
+        assert(res_vars.size() == ((C + 2) * (sum_vars.size() + 1)));
+
+        // Initialize res[0] = 1, res[1] == res[2] == ... == res[C+1] == 0.
+        for (int i = 0; i < C + 2; i++) {
+            if (i == 0) {
+                lits[0] = pabc::Abc_Var2Lit(res_vars[i], 0);
+            } else {
+                lits[0] = pabc::Abc_Var2Lit(res_vars[i], 1);
+            }
+            (void)solver->add_clause(lits, lits + 1);
+        }
+
+        for (auto i = 0u; i < sum_vars.size(); i++) {
+            const auto x_k = sum_vars[i];
+            for (int j = 0; j < C + 2; j++) {
+                const auto res_j = res_vars[i * (C + 2) + j];
+                const auto res_jp = res_vars[(i + 1) * (C + 2) + j];
+                if (j == 0) {
+                    // res'[0] = MUX(x[k], res[0], 0) = ~x[k] /\ res[0]
+                    // Tseytin encoding:
+                    // (x[k] \/ ~res[0] \/ res'[0]) /\ (~x[k] \/ ~res'[0]) /\ (res[0] \/ ~res'[0])
+                    lits[0] = pabc::Abc_Var2Lit(x_k, 0);
+                    lits[1] = pabc::Abc_Var2Lit(res_j, 1);
+                    lits[2] = pabc::Abc_Var2Lit(res_jp, 0);
+                    (void)solver->add_clause(lits, lits + 3);
+                    lits[0] = pabc::Abc_Var2Lit(x_k, 1);
+                    lits[1] = pabc::Abc_Var2Lit(res_jp, 1);
+                    (void)solver->add_clause(lits, lits + 2);
+                    lits[0] = pabc::Abc_Var2Lit(res_j, 0);
+                    lits[1] = pabc::Abc_Var2Lit(res_jp, 1);
+                    (void)solver->add_clause(lits, lits + 2);
+                } else if (j == C + 1) {
+                    // res'[C+2] = MUX(x[k], res[C+2], res[C+1] \/ res[C+1]) = 
+                    // (~x[k] /\ res[C+2]) \/ (x[k] /\ res[C+1]) \/ (x[k] /\ res[C+2]) =
+                    // (res[C+1] \/ res[C+2]) /\ (x[k] \/ res[C+2])
+                    // Tseytin encoding:
+                    // (~res'[C+2] \/ res[C+1] \/ res[C+2]) /\ (~res'[C+2] \/ x[k] \/ res[C+2]) /\ (res'[C+2] \/ ~x[k] \/ ~res[C+1]) /\ (res'[C+2] \/ ~res[C+2])
+                    lits[0] = pabc::Abc_Var2Lit(res_jp, 1);
+                    lits[1] = pabc::Abc_Var2Lit(res_j - 1, 0);
+                    lits[2] = pabc::Abc_Var2Lit(res_j, 0);
+                    (void)solver->add_clause(lits, lits + 3);
+                    lits[0] = pabc::Abc_Var2Lit(res_jp, 1);
+                    lits[1] = pabc::Abc_Var2Lit(x_k, 0);
+                    lits[2] = pabc::Abc_Var2Lit(res_j, 0);
+                    (void)solver->add_clause(lits, lits + 3);
+                    lits[0] = pabc::Abc_Var2Lit(res_jp, 0);
+                    lits[1] = pabc::Abc_Var2Lit(x_k, 1);
+                    lits[2] = pabc::Abc_Var2Lit(res_j - 1, 1);
+                    (void)solver->add_clause(lits, lits + 3);
+                    lits[0] = pabc::Abc_Var2Lit(res_jp, 0);
+                    lits[1] = pabc::Abc_Var2Lit(res_j, 1);
+                    (void)solver->add_clause(lits, lits + 2);
+                } else {
+                    // res'[i] = MUX(x[k], res[i], res[i-1]).
+                    // Tseytin encoding:
+                    // ((~Z OR A OR S) AND (~Z OR B OR ~S)) AND (Z OR ~A OR S) AND (Z OR ~B OR ~S))) 
+                    lits[0] = pabc::Abc_Var2Lit(res_jp, 1);
+                    lits[1] = pabc::Abc_Var2Lit(res_j, 0);
+                    lits[2] = pabc::Abc_Var2Lit(x_k, 0);
+                    (void)solver->add_clause(lits, lits + 3);
+                    lits[0] = pabc::Abc_Var2Lit(res_jp, 1);
+                    lits[1] = pabc::Abc_Var2Lit(res_j - 1, 0);
+                    lits[2] = pabc::Abc_Var2Lit(x_k, 1);
+                    (void)solver->add_clause(lits, lits + 3);
+                    lits[0] = pabc::Abc_Var2Lit(res_jp, 0);
+                    lits[1] = pabc::Abc_Var2Lit(res_j, 1);
+                    lits[2] = pabc::Abc_Var2Lit(x_k, 0);
+                    (void)solver->add_clause(lits, lits + 3);
+                    lits[0] = pabc::Abc_Var2Lit(res_jp, 0);
+                    lits[1] = pabc::Abc_Var2Lit(res_j - 1, 1);
+                    lits[2] = pabc::Abc_Var2Lit(x_k, 1);
+                    (void)solver->add_clause(lits, lits + 3);
+                }
+            }
+        }
+    }
+}
diff --git a/lib/percy/percy/solvers.hpp b/lib/percy/percy/solvers.hpp
new file mode 100644
index 0000000..59271f8
--- /dev/null
+++ b/lib/percy/percy/solvers.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "solvers/bsat2.hpp"
+#include "solvers/bmcg_sat.hpp"
+#ifdef USE_CMS
+#include "solvers/cmsat.hpp"
+#endif
+#if defined(USE_GLUCOSE) || defined(USE_SYRUP)
+#include "solvers/glucose.hpp"
+#endif
+#ifdef USE_SATOKO
+#include "solvers/satoko.hpp"
+#endif
\ No newline at end of file
diff --git a/lib/percy/percy/solvers/bmcg_sat.hpp b/lib/percy/percy/solvers/bmcg_sat.hpp
new file mode 100644
index 0000000..f0e702c
--- /dev/null
+++ b/lib/percy/percy/solvers/bmcg_sat.hpp
@@ -0,0 +1,99 @@
+#pragma once
+
+#include "solver_wrapper.hpp"
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wall"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wpedantic"
+#include <abc/AbcGlucose.h>
+#pragma GCC diagnostic pop
+
+namespace percy
+{
+    class bmcg_wrapper : public solver_wrapper
+    {
+    private:
+        pabc::bmcg_sat_solver * solver = NULL;
+
+    public:
+        bmcg_wrapper()
+        {
+            solver = pabc::bmcg_sat_solver_start();
+        }
+
+        ~bmcg_wrapper()
+        {
+            pabc::bmcg_sat_solver_stop(solver);
+            solver = NULL;
+        }
+
+        void restart()
+        {
+            pabc::bmcg_sat_solver_reset(solver);
+        }
+
+        void set_nr_vars(int nr_vars)
+        {
+            pabc::bmcg_sat_solver_set_nvars(solver, nr_vars);
+        }
+
+        int nr_vars()
+        {
+            // Not currently supported
+            return -1;
+        }
+
+        int nr_clauses()
+        {
+            return pabc::bmcg_sat_solver_clausenum(solver);
+        }
+
+        int nr_conflicts()
+        {
+            return pabc::bmcg_sat_solver_conflictnum(solver);
+        }
+
+        int add_clause(pabc::lit* begin, pabc::lit* end)
+        {
+            return pabc::bmcg_sat_solver_addclause(solver, begin, end - begin);
+        }
+
+        void add_var()
+        {
+            pabc::bmcg_sat_solver_addvar(solver);
+        }
+
+        int var_value(int var)
+        {
+            return pabc::bmcg_sat_solver_read_cex_varvalue(solver, var);
+        }
+
+        synth_result solve(int cl)
+        {
+            pabc::bmcg_sat_solver_set_conflict_budget(solver, cl);
+            auto res = pabc::bmcg_sat_solver_solve(solver, 0, 0);
+            if (res == 1) {
+                return success;
+            } else if (res == -1) {
+                return failure;
+            } else {
+                return timeout;
+            }
+        }
+
+        synth_result solve(pabc::lit* begin, pabc::lit* end, int cl)
+        {
+            pabc::bmcg_sat_solver_set_conflict_budget(solver, cl);
+            auto res = pabc::bmcg_sat_solver_solve(solver, begin, end - begin);
+            if (res == 1) {
+                return success;
+            } else if (res == -1) {
+                return failure;
+            } else {
+                return timeout;
+            }
+        }
+
+    };
+}
diff --git a/lib/percy/percy/solvers/bsat2.hpp b/lib/percy/percy/solvers/bsat2.hpp
new file mode 100644
index 0000000..200da8f
--- /dev/null
+++ b/lib/percy/percy/solvers/bsat2.hpp
@@ -0,0 +1,146 @@
+#pragma once
+
+#include "solver_wrapper.hpp"
+
+namespace percy
+{
+    class bsat_wrapper : public solver_wrapper
+    {
+    private:
+        pabc::sat_solver * solver = NULL;
+
+    public:
+        bsat_wrapper()
+        {
+            solver = pabc::sat_solver_new();
+        }
+
+        ~bsat_wrapper()
+        {
+            pabc::sat_solver_delete(solver);
+            solver = NULL;
+        }
+
+        void restart()
+        {
+            pabc::sat_solver_restart(solver);
+        }
+
+        void set_nr_vars(int nr_vars)
+        {
+            pabc::sat_solver_setnvars(solver, nr_vars);
+        }
+
+        int nr_vars()
+        {
+            return pabc::sat_solver_nvars(solver);
+        }
+
+        int nr_clauses()
+        {
+            return pabc::sat_solver_nclauses(solver);
+        }
+
+        int nr_conflicts()
+        {
+            return pabc::sat_solver_nconflicts(solver);
+        }
+
+        int add_clause(pabc::lit* begin, pabc::lit* end)
+        {
+            return pabc::sat_solver_addclause(solver, begin, end);
+        }
+
+        /* mockturtle style clause */
+        int add_clause(std::vector<uint32_t> const& clause)
+        {
+            auto lits = (int*)(const_cast<uint32_t*>(clause.data()));
+            return pabc::sat_solver_addclause(solver, lits, lits + clause.size());
+        }
+
+        void add_var()
+        {
+            pabc::sat_solver_addvar(solver);
+        }
+
+        int var_value(int var)
+        {
+            return pabc::sat_solver_var_value(solver, var);
+        }
+
+        synth_result solve(int cl)
+        {
+            auto res = pabc::sat_solver_solve(solver, 0, 0, cl, 0, 0, 0);
+            if (res == 1) {
+                return success;
+            } else if (res == -1) {
+                return failure;
+            } else {
+                return timeout;
+            }
+        }
+
+        synth_result solve(pabc::lit* begin, pabc::lit* end, int cl)
+        {
+            auto res = pabc::sat_solver_solve(solver, begin, end, cl, 0, 0, 0);
+            if (res == 1) {
+                return success;
+            } else if (res == -1) {
+                return failure;
+            } else {
+                return timeout;
+            }
+        }
+
+        void set_nLearntMax(int nLearntMax)
+        {
+            solver->nLearntMax = nLearntMax;
+        }
+
+        void set_nLearntStart(int nLearntStart)
+        {
+            solver->nLearntStart = nLearntStart;
+        }
+
+        void set_nLearntDelta(int nLearntDelta)
+        {
+            solver->nLearntDelta = nLearntDelta;
+        }
+
+        void set_nLearntRatio(int nLearntRatio)
+        {
+            solver->nLearntRatio = nLearntRatio;
+        }
+
+        void set_random_seed(int random_seed)
+        {
+            solver->random_seed = random_seed;
+        }
+
+        void set_fSkipSimplify(int fSkipSimplify)
+        {
+            solver->fSkipSimplify = fSkipSimplify;
+        }
+
+        void set_fNoRestarts(int fNoRestarts)
+        {
+            solver->fNoRestarts = fNoRestarts;
+        }
+
+        void set_VarActType(int VarActType)
+        {
+            solver->VarActType = VarActType;
+        }
+
+        void set_ClaActType(int ClaActType)
+        {
+            solver->ClaActType = ClaActType;
+        }
+
+        void init_activities()
+        {
+            solver_init_activities(solver);
+        }
+
+    };
+}
diff --git a/lib/percy/percy/solvers/cmsat.hpp b/lib/percy/percy/solvers/cmsat.hpp
new file mode 100644
index 0000000..8c7ac1a
--- /dev/null
+++ b/lib/percy/percy/solvers/cmsat.hpp
@@ -0,0 +1,131 @@
+#pragma once
+
+#include "solver_wrapper.hpp"
+
+#ifdef USE_CMS
+
+#pragma GCC diagnostic push
+
+#pragma GCC diagnostic ignored "-Wall"
+
+#include <cryptominisat5/cryptominisat.h>
+
+#pragma GCC diagnostic pop
+
+// A hack to undefine the CryptoMiniSat lbool definitions, 
+// as they conflict with those defined by ABC.
+#undef l_True
+#undef l_False
+#undef l_Undef
+
+namespace percy
+{
+    class cmsat_wrapper : public solver_wrapper
+    {
+    private:
+        CMSat::SATSolver * solver = NULL;
+
+    public:
+        cmsat_wrapper()
+        {
+            solver = new CMSat::SATSolver;
+            auto nr_threads = std::thread::hardware_concurrency();
+            solver->set_num_threads(nr_threads);
+        }
+
+        ~cmsat_wrapper()
+        {
+            delete solver;
+            solver = NULL;
+        }
+
+        void restart()
+        {
+            delete solver;
+            solver = new CMSat::SATSolver;
+            auto nr_threads = std::thread::hardware_concurrency();
+            solver->set_num_threads(nr_threads);
+        }
+
+        void set_nr_vars(int nr_vars)
+        {
+            solver->new_vars(nr_vars);
+        }
+
+        int add_clause(pabc::lit* begin, pabc::lit* end)
+        {
+            static std::vector<CMSat::Lit> clause;
+            clause.clear();
+            for (auto i = begin; i < end; i++) {
+                clause.push_back(CMSat::Lit(pabc::Abc_Lit2Var(*i), pabc::Abc_LitIsCompl(*i)));
+            }
+            return solver->add_clause(clause);
+        }
+
+        int var_value(int var)
+        {
+            return solver->get_model()[var] == CMSat::boolToLBool(true);
+        }
+
+        synth_result solve(int cl) 
+        {
+            std::vector<CMSat::Lit> assumps;
+            if (cl > 0) {
+                solver->set_max_confl(cl);
+            }
+            auto res = solver->solve(&assumps);
+            if (res == CMSat::boolToLBool(true)) {
+                return success;
+            } else if (res == CMSat::boolToLBool(false)) {
+                return failure;
+            } else {
+                return timeout;
+            }
+        }
+
+        synth_result solve(pabc::lit* begin, pabc::lit* end, int cl)
+        {
+            static std::vector<CMSat::Lit> assumps;
+            assumps.clear();
+            for (auto i = begin; i < end; i++) {
+                assumps.push_back(CMSat::Lit(pabc::Abc_Lit2Var(*i), pabc::Abc_LitIsCompl(*i)));
+            }
+            if (cl > 0) {
+                solver->set_max_confl(cl);
+            }
+            auto res = solver->solve(&assumps);
+            if (res == CMSat::boolToLBool(true)) {
+                return success;
+            } else if (res == CMSat::boolToLBool(false)) {
+                return failure;
+            } else {
+                return timeout;
+            }
+        }
+
+        int nr_conflicts()
+        {
+            // TODO: check if we can now do this with CMSat.
+            return 0u;
+        }
+        
+        int nr_clauses()
+        {
+            // TODO: fix implementation.
+            return 0;
+        }
+
+        int nr_vars()
+        {
+            return solver->nVars();
+        }
+
+        void add_var()
+        {
+            solver->new_var();
+        }
+
+    };
+}
+
+#endif
diff --git a/lib/percy/percy/solvers/glucose.hpp b/lib/percy/percy/solvers/glucose.hpp
new file mode 100644
index 0000000..24c630b
--- /dev/null
+++ b/lib/percy/percy/solvers/glucose.hpp
@@ -0,0 +1,193 @@
+#pragma once
+
+#if !defined(_WIN32) && !defined(_WIN64)
+
+#undef var_Undef
+
+#pragma GCC diagnostic push
+
+#pragma GCC diagnostic ignored "-Wall"
+#pragma GCC diagnostic ignored "-Wparentheses"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wpedantic"
+
+
+#ifndef USE_GLUCOSE
+#include <syrup/parallel/MultiSolvers.h>
+#define GWType Glucose::MultiSolvers
+#else
+#include <glucose/core/Solver.h>
+#define GWType Glucose::Solver
+#endif
+
+#pragma GCC diagnostic pop
+
+#undef var_Undef
+
+#define var_Undef (0xffffffffU >> 4)
+
+
+namespace percy
+{
+
+    class glucose_wrapper : public solver_wrapper
+    {
+    private:
+        GWType* solver;
+        int nr_threads = 0;
+        
+    public:
+        glucose_wrapper()
+        {
+            solver = new GWType;
+        }
+
+        ~glucose_wrapper()
+        {
+            delete solver;
+            solver = NULL;
+        }
+
+        void restart()
+        {
+            delete solver;
+#ifdef USE_SYRUP
+            if (nr_threads > 0) {
+                solver = new GWType(nr_threads);
+            } else {
+                solver = new GWType;
+            }
+#else
+            solver = new GWType;
+#endif
+        }
+
+
+        void set_nr_vars(int nr_vars)
+        {
+            while (nr_vars-- > 0) {
+                solver->newVar();
+            }
+        }
+
+        int nr_vars()
+        {
+            return solver->nVars();
+        }
+
+        int nr_clauses()
+        {
+            return solver->nClauses();
+        }
+
+        int nr_conflicts()
+        {
+#ifdef USE_GLUCOSE
+            return solver->conflicts;
+#else
+            // Currently not supported by Glucose::MultiSolvers
+            return 0;
+#endif
+        }
+
+        int add_clause(pabc::lit* begin, pabc::lit* end)
+        {
+            Glucose::vec<Glucose::Lit> litvec;
+            for (auto i = begin; i != end; i++) {
+                litvec.push(Glucose::mkLit((*i >> 1), (*i & 1)));
+            }
+            return solver->addClause(litvec);
+        }
+
+        void add_var()
+        {
+            solver->newVar();
+        }
+
+        int var_value(int var)
+        {
+#ifdef USE_GLUCOSE
+            return solver->modelValue(var) == l_True;
+#else
+            return solver->model[var] == l_True;
+#endif
+        }
+
+        synth_result solve(int cl)
+        {
+#ifdef USE_GLUCOSE
+            Glucose::vec<Glucose::Lit> litvec;
+            if (cl) {
+                solver->setConfBudget(cl);
+            }
+            auto res = solver->solveLimited(litvec);
+            if (res == l_True) {
+                return success;
+            } else if (res == l_False) {
+                return failure;
+            } else {
+                return timeout;
+            }
+#else
+            int ret2 = solver->simplify();
+            solver->use_simplification = false;
+            if (ret2) {
+                solver->eliminate();
+            }
+
+            if (!ret2 || !solver->okay()) {
+                return failure;
+            }
+
+            // Conflict limits are currently not supported by 
+            // Glucose::MultiSolvers.   
+            auto res = solver->solve();
+            if (res == l_True) {
+                return success;
+            } else if (res == l_False) {
+                return failure;
+            } else {
+                return timeout;
+            }
+#endif
+        }
+
+
+#ifdef USE_GLUCOSE
+        synth_result solve(pabc::lit* begin, pabc::lit* end, int cl)
+        {
+            Glucose::vec<Glucose::Lit> litvec;
+            for (auto i = begin; i != end; i++) {
+                litvec.push(Glucose::mkLit((*i >> 1), (*i & 1)));
+            }
+            if (cl) {
+                solver->setConfBudget(cl);
+            }
+            auto res = solver->solveLimited(litvec);
+            if (res == l_True) {
+                return success;
+            } else if (res == l_False) {
+                return failure;
+            } else {
+                return timeout;
+            }
+        }
+#else
+        synth_result solve(pabc::lit*, pabc::lit*, int cl)
+        {
+            return solve(cl);
+        }
+#endif
+
+#ifdef USE_SYRUP
+        void set_nr_threads(int nr_threads)
+        {
+            delete solver;
+            this->nr_threads = nr_threads;
+            solver = new Glucose::MultiSolvers(nr_threads);
+        }
+#endif
+    };
+}
+
+#endif
diff --git a/lib/percy/percy/solvers/satoko.hpp b/lib/percy/percy/solvers/satoko.hpp
new file mode 100644
index 0000000..81ed867
--- /dev/null
+++ b/lib/percy/percy/solvers/satoko.hpp
@@ -0,0 +1,190 @@
+#pragma once
+
+#ifndef DISABLE_SATOKO
+
+#include "solver_wrapper.hpp"
+
+#pragma GCC diagnostic push
+
+#pragma GCC diagnostic ignored "-Wtype-limits"
+#pragma GCC diagnostic ignored "-Wpedantic"
+#include <satoko/satoko.h>
+#include <satoko/solver.h>
+#pragma GCC diagnostic pop
+
+namespace percy
+{
+    class satoko_wrapper : public solver_wrapper
+    {
+    private:
+        satoko::satoko_t * solver = NULL;
+
+    public:
+        satoko_wrapper()
+        {
+            solver = satoko::satoko_create();
+        }
+
+        ~satoko_wrapper()
+        {
+            satoko::satoko_destroy(solver);
+            solver = NULL;
+        }
+
+        void restart()
+        {
+            satoko::satoko_reset(solver);
+        }
+
+        void set_nr_vars(int nr_vars)
+        {
+            satoko::satoko_setnvars(solver, nr_vars);
+        }
+
+        int nr_vars()
+        {
+            return satoko::satoko_varnum(solver);
+        }
+
+        int nr_clauses()
+        {
+            return satoko::satoko_clausenum(solver);
+        }
+
+        int nr_conflicts()
+        {
+            return satoko::satoko_conflictnum(solver);
+        }
+
+        int add_clause(pabc::lit* begin, pabc::lit* end)
+        {
+            return satoko::satoko_add_clause(solver, begin, end - begin);
+        }
+
+        void add_var()
+        {
+            satoko::satoko_add_variable(solver, 0);
+        }
+
+        int var_value(int var)
+        {
+            return satoko::satoko_read_cex_varvalue(solver, var);
+        }
+
+        synth_result solve(int cl)
+        {
+            auto res = satoko::satoko_solve_assumptions_limit(solver, 0, 0, cl);
+            if (res == satoko::SATOKO_SAT) {
+                return success;
+            } else if (res == satoko::SATOKO_UNSAT) {
+                return failure;
+            } else {
+                return timeout;
+            }
+        }
+
+        synth_result solve(pabc::lit* begin, pabc::lit* end, int cl)
+        {
+            auto res = satoko::satoko_solve_assumptions_limit(solver, begin, end - begin, cl);
+            if (res == satoko::SATOKO_SAT) {
+                return success;
+            } else if (res == satoko::SATOKO_UNSAT) {
+                return failure;
+            } else {
+                return timeout;
+            }
+        }
+
+        void set_no_simplify(char no_simplify)
+        {
+            solver->opts.no_simplify = no_simplify;
+        }
+
+        void set_f_rst(double f_rst)
+        {
+            solver->opts.f_rst = f_rst;
+        }
+
+        void set_b_rst(double b_rst)
+        {
+            solver->opts.b_rst = b_rst;
+        }
+
+        void set_fst_block_rst(unsigned fst_block_rst)
+        {
+            solver->opts.fst_block_rst = fst_block_rst;
+        }
+
+        void set_sz_lbd_bqueue(unsigned sz_lbd_bqueue)
+        {
+            solver->opts.sz_lbd_bqueue = sz_lbd_bqueue;
+        }
+
+        void set_sz_trail_bqueue(unsigned sz_trail_bqueue)
+        {
+            solver->opts.sz_trail_bqueue = sz_trail_bqueue;
+        }
+
+        void set_n_conf_fst_reduce(unsigned n_conf_fst_reduce)
+        {
+            solver->opts.n_conf_fst_reduce = n_conf_fst_reduce;
+        }
+
+        void set_inc_reduce(unsigned inc_reduce)
+        {
+            solver->opts.inc_reduce = inc_reduce;
+        }
+
+        void set_inc_special_reduce(unsigned inc_special_reduce)
+        {
+            solver->opts.inc_special_reduce = inc_special_reduce;
+        }
+
+        void set_lbd_freeze_clause(unsigned lbd_freeze_clause)
+        {
+            solver->opts.lbd_freeze_clause = lbd_freeze_clause;
+        }
+
+        void set_learnt_ratio(float learnt_ratio)
+        {
+            solver->opts.learnt_ratio = learnt_ratio;
+        }
+
+        void set_var_decay(double var_decay)
+        {
+            solver->opts.var_decay = var_decay;
+        }
+
+        void set_clause_decay(float clause_decay)
+        {
+            solver->opts.clause_decay = clause_decay;
+        }
+
+        void set_var_act_rescale(unsigned var_act_rescale)
+        {
+            solver->opts.var_act_rescale = var_act_rescale;
+        }
+
+        void set_var_act_limit(satoko::act_t var_act_limit)
+        {
+            solver->opts.var_act_limit = var_act_limit;
+        }
+
+        void set_clause_max_sz_bin_resol(unsigned clause_max_sz_bin_resol)
+        {
+            solver->opts.clause_max_sz_bin_resol = clause_max_sz_bin_resol;
+        }
+
+        void set_clause_min_lbd_bin_resol(unsigned clause_min_lbd_bin_resol)
+        {
+            solver->opts.clause_min_lbd_bin_resol = clause_min_lbd_bin_resol;
+        }
+
+        void set_garbage_max_ratio(float garbage_max_ratio)
+        {
+            solver->opts.garbage_max_ratio = garbage_max_ratio;
+        }
+    };
+}
+
+#endif // !DISABLE_SATOKO
diff --git a/lib/percy/percy/solvers/solver_wrapper.hpp b/lib/percy/percy/solvers/solver_wrapper.hpp
new file mode 100644
index 0000000..63a89b8
--- /dev/null
+++ b/lib/percy/percy/solvers/solver_wrapper.hpp
@@ -0,0 +1,41 @@
+#pragma once
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wall"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wpedantic"
+//#pragma GCC diagnostic ignored "-Wzero-length-array"
+#include <abc/satSolver.h>
+#pragma GCC diagnostic pop
+
+#include <thread>
+
+namespace percy
+{
+    enum synth_result
+    {
+        success,
+        failure,
+        timeout
+    };
+
+    class solver_wrapper
+    {
+    public:
+        virtual ~solver_wrapper() ///< Virtual constructor allows for cleanup in derived class destructors
+        {
+
+        }
+        virtual void restart() = 0;
+        virtual void set_nr_vars(int nr_vars) = 0;
+        virtual int  nr_vars() = 0;
+        virtual int  nr_clauses() = 0;
+        virtual int  nr_conflicts() = 0;
+        virtual void add_var() = 0;
+        virtual int  add_clause(pabc::lit* begin, pabc::lit* end) = 0;
+        virtual int  var_value(int var) = 0;
+        virtual synth_result solve(int conflict_limit = 0) = 0;
+        virtual synth_result solve(pabc::lit* begin, pabc::lit* end, int conflict_limit = 0) = 0;
+    };
+	
+}
diff --git a/lib/percy/percy/spec.hpp b/lib/percy/percy/spec.hpp
new file mode 100644
index 0000000..8280d75
--- /dev/null
+++ b/lib/percy/percy/spec.hpp
@@ -0,0 +1,403 @@
+#pragma once
+
+#include <chrono>
+#include <vector>
+#include "tt_utils.hpp"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+#include <kitty/kitty.hpp>
+#include <kitty/print.hpp>
+#pragma GCC diagnostic pop
+
+namespace percy
+{
+    const int MAX_STEPS = 20; /// The maximum number of steps we'll synthesize
+    const int MAX_FANIN =  5; /// The maximum number of fanins per step we'll synthesize
+
+    /// The various methods types of synthesis supported by percy.
+    enum SynthMethod
+    {
+        SYNTH_STD,
+        SYNTH_STD_CEGAR,
+        SYNTH_FENCE,
+        SYNTH_FENCE_CEGAR,
+        SYNTH_DAG,
+        SYNTH_FDAG,
+        SYNTH_TOTAL
+    };
+
+    const char * const SynthMethodToString[SYNTH_TOTAL] =
+    {
+        "SYNTH_STD",
+        "SYNTH_STD_CEGAR",
+        "SYNTH_FENCE",
+        "SYNTH_FENCE_CEGAR",
+        "SYNTH_DAG",
+        "SYNTH_FDAG",
+    };
+
+    enum EncoderType
+    {
+        ENC_SSV,
+        ENC_MSV,
+        ENC_DITT,
+        ENC_FENCE,
+        ENC_DAG,
+        ENC_TOTAL
+    };
+
+    const char* const EncoderTypeToString[ENC_TOTAL] = 
+    {
+        "ENC_SSV",
+        "ENC_MSV",
+        "ENC_DITT",
+        "ENC_FENCE",
+        "ENC_DAG",
+    };
+
+    enum SolverType
+    {
+        SLV_BSAT2,
+        SLV_CMSAT,
+        SLV_GLUCOSE,
+        SLV_SATOKO,
+        SLV_TOTAL,
+    };
+
+    const char * const SolverTypeToString[SLV_TOTAL] = 
+    {
+        "SLV_BSAT2",
+        "SLV_CMSAT",
+        "SLV_GLUCOSE",
+        "SLV_SATOKO",
+    };
+
+    enum Primitive
+    {
+        MAJ,
+        AIG
+    };
+
+    /// Used to gather data on synthesis experiments.
+    struct synth_stats
+    {
+        double overhead = 0;
+        double total_synth_time = 0;
+        double time_to_first_synth = 0;
+        int nr_success = 0;
+        int nr_timeouts = 0;
+        int64_t sat_time = 0;   ///< How much time was spent on UNSAT formulae (in us)
+        int64_t unsat_time = 0; ///< How much time was spent on SAT formulae (in us)
+        int64_t synth_time = 0; ///< How much time was spent on SAT formulae (in us)
+        int nr_vars = 0;
+        int nr_clauses = 0;
+    }; 
+
+    class spec
+    {
+        protected:
+            int capacity; ///< Maximum number of output functions this specification can support
+            std::vector<kitty::dynamic_truth_table> functions; ///< Functions to synthesize
+            std::vector<kitty::dynamic_truth_table> dc_masks; ///< Indicates which input combinations we don't care about
+            std::vector<char> dc_functions; ///< Determines for which functions we look at the DC mask
+            std::vector<int> triv_functions; ///< Trivial outputs
+            std::vector<int> synth_functions; ///< Nontrivial outputs
+            std::vector<kitty::dynamic_truth_table> compiled_primitives; ///< Collection of concrete truth tables induced by primitives
+            std::vector<kitty::dynamic_truth_table> compiled_functions;
+
+        public:
+            int fanin = 2; ///< The fanin of the Boolean chain steps
+            int nr_in; ///< The inputs of the chain we want to synthesize
+            int tt_size; ///< Size of the truth tables to synthesize (in nr. of bits)
+            int nr_steps; ///< The number of Boolean operators to use
+            int initial_steps = 1; ///< The number of steps from which to start synthesis
+            int max_nr_steps = 100; ///< The maximum number of steps to try
+            int verbosity = 0; ///< Verbosity level for debugging purposes
+            uint64_t out_inv; ///< Is 1 at index i if output i must be inverted
+            uint64_t triv_flag; ///< Is 1 at index i if output i is constant zero or one or a projection.
+            int nr_triv; ///< Number of trivial output functions
+            int nr_nontriv; ///< Number of non-trivial output functions
+
+            bool add_nontriv_clauses = true; ///< Symmetry break: do not allow trivial operators
+            bool add_alonce_clauses = true; ///< Symmetry break: all steps must be used at least once
+            bool add_noreapply_clauses = true; ///< Symmetry break: no re-application of operators
+            bool add_colex_clauses = true; ///< Symmetry break: order step fanins co-lexicographically
+            bool add_lex_func_clauses = true; ///< Symmetry break: order step operators co-lexicographically
+            bool add_symvar_clauses = true; ///< Symmetry break: impose order on symmetric variables
+            bool add_lex_clauses = false; ///< Symmetry break: order step fanins lexicographically
+
+            /// Limit on the number of SAT conflicts. Zero means no limit.
+            int conflict_limit = 0;
+            
+            /// Constructs a spec with one output
+            spec()
+            {
+                set_nr_out(1);
+            }
+
+            /// Constructs a spec with nr_out outputs.
+            spec(int nr_out)
+            {
+                set_nr_out(nr_out);
+            }
+
+            void
+            set_nr_out(int n)
+            {
+                capacity = n;
+                functions.resize(n);
+                dc_masks.resize(n);
+                dc_functions.resize(n);
+                triv_functions.resize(n);
+                synth_functions.resize(n);
+            }
+
+            int get_nr_in() const { return functions[0].num_vars(); }
+            int get_tt_size() const { return tt_size; }
+            int get_nr_out() const { return capacity; }
+
+            /// Normalizes outputs by converting them to normal functions. Also
+            /// checks for trivial outputs, such as constant functions or
+            /// projections. This determines which of the specified functions
+            /// need to be synthesized.  This function expects the following
+            /// invariants to hold:
+            /// 1. The number of input variables has been set.
+            /// 2. The number of output variables has been set.
+            /// 3. The functions requested to be synthesized have been set.
+            void 
+            preprocess(void)
+            {
+                assert(!add_colex_clauses || !add_lex_clauses);
+
+                // Verify that all functions have the same number of variables
+                const auto num_vars = functions[0].num_vars();
+                for (int i = 1; i < capacity; i++) {
+                    if (functions[i].num_vars() != num_vars) {
+                        assert(false);
+                        exit(1);
+                    }
+                }
+
+                nr_in = functions[0].num_vars();
+                tt_size = (1 << functions[0].num_vars()) - 1;
+
+                if (verbosity) {
+                    printf("\n");
+                    printf("========================================"
+                           "========================================\n");
+                    printf("  Pre-processing for %s:\n", capacity > 1 ? 
+                            "functions" : "function");
+                    for (int h = 0; h < capacity; h++) {
+                        printf("  ");
+                        kitty::print_binary(functions[h], std::cout);
+                        printf("\n");
+                    }
+                    printf("========================================"
+                            "========================================\n");
+                    printf("  SPEC:\n");
+                    printf("\tnr_in=%d\n", functions[0].num_vars());
+                    printf("\tnr_out=%d\n", capacity);
+                    printf("\ttt_size=%d\n", tt_size);
+                }
+
+                assert((!add_colex_clauses && !add_lex_clauses) ||
+                        (add_colex_clauses != add_lex_clauses));
+
+                // Detect any trivial outputs.
+                nr_triv = 0;
+                nr_nontriv = 0;
+                out_inv = 0;
+                triv_flag = 0;
+                for (int h = 0; h < capacity; h++) {
+                    if (is_const0(functions[h])) {
+                        triv_flag |= (1 << h);
+                        triv_functions[nr_triv++] = 0;
+                    } else if (is_const0(~(functions[h]))) {
+                        triv_flag |= (1 << h);
+                        triv_functions[nr_triv++] = 0;
+                        out_inv |= (1 << h);
+                    } else {
+                        auto tt_var = functions[0].construct();
+                        for (int i = 0; i < get_nr_in(); i++) {
+                            create_nth_var(tt_var, i);
+                            if (functions[h] == tt_var) {
+                                triv_flag |= (1 << h);
+                                triv_functions[nr_triv++] = i+1;
+                                break;
+                            } else if (functions[h] == ~(tt_var)) {
+                                triv_flag |= (1 << h);
+                                triv_functions[nr_triv++] = i+1;
+                                out_inv |= (1 << h);
+                                break;
+                            }
+                        }
+                        // Even when the output is not trivial, we still need
+                        // to ensure that it's normal.
+                        if (!((triv_flag >> h) & 1)) {
+                            if (!is_normal(functions[h])) {
+                                out_inv |= (1 << h);
+                            }
+                            synth_functions[nr_nontriv++] = h;
+                        }
+                    }
+                }
+
+                if (verbosity) {
+                    for (int h = 0; h < capacity; h++) {
+                        if ((triv_flag >> h) & 1) {
+                            printf("  Output %d is trivial\n", h+1);
+                        }
+                        if ((out_inv >> h) & 1) {
+                            printf("  Inverting output %d\n", h+1);
+                        }
+                    }
+                    printf("  Trivial outputs=%d\n", nr_triv);
+                    printf("  Non-trivial outputs=%d\n", capacity - nr_triv);
+                    printf("========================================"
+                            "========================================\n");
+                    printf("\n");
+                }
+            }
+
+            kitty::dynamic_truth_table& 
+            operator[](std::size_t idx)
+            {
+                if (static_cast<int>(idx) >= capacity) {
+                    set_nr_out(idx + 1);
+                }
+                return functions[idx];
+            }
+
+            const kitty::dynamic_truth_table& 
+            operator[](std::size_t idx) const
+            {
+                assert (static_cast<int>(idx) < capacity);
+                return functions[idx];
+            }
+
+            template<class TT>
+            void set_output(int i, const TT& tt)
+            {
+                assert(i < capacity);
+                functions[i] = tt;
+            }
+
+            void set_dont_care(std::size_t f_idx, kitty::dynamic_truth_table dc_mask)
+            {
+                dc_functions[f_idx] = 1;
+                dc_masks[f_idx] = dc_mask;
+            }
+
+            void clear_dont_care(std::size_t f_idx)
+            {
+                dc_functions[f_idx] = 0;
+            }
+
+            bool is_dont_care(std::size_t f_idx, int dc_idx) const
+            {
+                return dc_functions[f_idx] && kitty::get_bit(dc_masks[f_idx], dc_idx);
+            }
+
+            bool has_dc_mask(std::size_t f_idx) const
+            {
+                return dc_functions[f_idx];
+            }
+
+            const kitty::dynamic_truth_table& get_dc_mask(std::size_t f_idx) const
+            {
+                return dc_masks[f_idx];
+            }
+
+            int
+            triv_func(int i) const
+            {
+                assert(i < capacity);
+                return triv_functions[i];
+            }
+
+            int
+            synth_func(int i) const
+            {
+                assert(i < capacity);
+                return synth_functions[i];
+            }
+
+            void add_function( kitty::dynamic_truth_table const& tt )
+            {
+              /* a function is an internal function */
+              // assert( tt.num_vars() == nr_in );
+
+              /* the function must be normal */
+              assert( kitty::get_bit( tt, 0 ) == false );
+
+              compiled_functions.emplace_back( tt );
+            }
+
+            uint32_t get_nr_compiled_functions() const
+            {
+              return compiled_functions.size();
+            }
+
+            kitty::dynamic_truth_table get_compiled_function( uint32_t index ) const
+            {
+              assert( index < compiled_functions.size() );
+              return compiled_functions.at( index );
+            }
+
+            void set_primitive(Primitive primitive)
+            {
+                compiled_primitives.clear();
+                kitty::dynamic_truth_table tt(fanin);
+                std::vector<kitty::dynamic_truth_table> inputs;
+                for (int i = 0; i < fanin; i++) {
+                    inputs.push_back(kitty::create<kitty::dynamic_truth_table>(fanin));
+                    kitty::create_nth_var(inputs[i], i);
+                }
+                switch (primitive) {
+                case AIG:
+                    tt = inputs[0] & inputs[1];
+                    compiled_primitives.push_back(tt);
+                    tt = ~inputs[0] & inputs[1];
+                    compiled_primitives.push_back(tt);
+                    tt = inputs[0] & ~inputs[1];
+                    compiled_primitives.push_back(tt);
+                    tt = inputs[0] | inputs[1];
+                    compiled_primitives.push_back(tt);
+                    break;
+                case MAJ:
+                    kitty::create_majority(tt);
+                    compiled_primitives.push_back(tt);
+                    break;
+                }
+            }
+
+            void add_primitive( kitty::dynamic_truth_table const& tt )
+            {
+              compiled_primitives.push_back( tt );
+            }
+
+            bool is_primitive_set() const
+            {
+                return compiled_primitives.size() > 0;
+            }
+
+            const std::vector<kitty::dynamic_truth_table>&
+            get_compiled_primitives() const
+            {
+                return compiled_primitives;
+            }
+
+            const std::vector<kitty::dynamic_truth_table>&
+            get_compiled_functions() const
+            {
+              return compiled_functions;
+            }
+
+            void clear_primitive()
+            {
+                compiled_primitives.clear();
+            }
+    };
+
+}
+
diff --git a/lib/percy/percy/tt_utils.hpp b/lib/percy/percy/tt_utils.hpp
new file mode 100644
index 0000000..6021a9a
--- /dev/null
+++ b/lib/percy/percy/tt_utils.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+#include <kitty/kitty.hpp>
+#include <unordered_set>
+#pragma GCC diagnostic pop
+
+namespace percy
+{
+    template<int nr_in>
+    static inline std::unordered_set<kitty::static_truth_table<nr_in>, kitty::hash<kitty::static_truth_table<nr_in>>> generate_npn_classes()
+    {
+        using truth_table = kitty::static_truth_table<nr_in>;
+        
+        kitty::dynamic_truth_table map(truth_table::NumBits);
+        std::transform( map.cbegin(), map.cend(), map.begin(), []( auto word ) { return ~word; } );
+        std::unordered_set<truth_table, kitty::hash<truth_table>> classes;
+
+        int64_t index = 0;
+        truth_table tt;
+        while (index != -1) {
+            kitty::create_from_words( tt, &index, &index + 1 );
+            const auto res = kitty::exact_npn_canonization( tt, [&map]( const auto& tt ) { kitty::clear_bit( map, *tt.cbegin() ); } );
+            classes.insert( std::get<0>( res ) );
+            index = find_first_one_bit( map );
+        }
+
+        return classes;
+    }
+
+}
diff --git a/lib/rang/rang/rang.hpp b/lib/rang/rang/rang.hpp
new file mode 100644
index 0000000..831eda4
--- /dev/null
+++ b/lib/rang/rang/rang.hpp
@@ -0,0 +1,502 @@
+#ifndef RANG_DOT_HPP
+#define RANG_DOT_HPP
+
+#if defined(__unix__) || defined(__unix) || defined(__linux__)
+#define OS_LINUX
+#elif defined(WIN32) || defined(_WIN32) || defined(_WIN64)
+#define OS_WIN
+#elif defined(__APPLE__) || defined(__MACH__)
+#define OS_MAC
+#else
+#error Unknown Platform
+#endif
+
+#if defined(OS_LINUX) || defined(OS_MAC)
+#include <unistd.h>
+
+#elif defined(OS_WIN)
+
+#if defined(_WIN32_WINNT) && (_WIN32_WINNT < 0x0600)
+#error                                                                         \
+  "Please include rang.hpp before any windows system headers or set _WIN32_WINNT at least to _WIN32_WINNT_VISTA"
+#elif !defined(_WIN32_WINNT)
+#define _WIN32_WINNT _WIN32_WINNT_VISTA
+#endif
+
+#include <windows.h>
+#include <io.h>
+#include <memory>
+
+// Only defined in windows 10 onwards, redefining in lower windows since it
+// doesn't gets used in lower versions
+// https://docs.microsoft.com/en-us/windows/console/getconsolemode
+#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
+#define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
+#endif
+
+#endif
+
+#include <algorithm>
+#include <atomic>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+
+namespace rang {
+
+/* For better compability with most of terminals do not use any style settings
+ * except of reset, bold and reversed.
+ * Note that on Windows terminals bold style is same as fgB color.
+ */
+enum class style {
+    reset     = 0,
+    bold      = 1,
+    dim       = 2,
+    italic    = 3,
+    underline = 4,
+    blink     = 5,
+    rblink    = 6,
+    reversed  = 7,
+    conceal   = 8,
+    crossed   = 9
+};
+
+enum class fg {
+    black   = 30,
+    red     = 31,
+    green   = 32,
+    yellow  = 33,
+    blue    = 34,
+    magenta = 35,
+    cyan    = 36,
+    gray    = 37,
+    reset   = 39
+};
+
+enum class bg {
+    black   = 40,
+    red     = 41,
+    green   = 42,
+    yellow  = 43,
+    blue    = 44,
+    magenta = 45,
+    cyan    = 46,
+    gray    = 47,
+    reset   = 49
+};
+
+enum class fgB {
+    black   = 90,
+    red     = 91,
+    green   = 92,
+    yellow  = 93,
+    blue    = 94,
+    magenta = 95,
+    cyan    = 96,
+    gray    = 97
+};
+
+enum class bgB {
+    black   = 100,
+    red     = 101,
+    green   = 102,
+    yellow  = 103,
+    blue    = 104,
+    magenta = 105,
+    cyan    = 106,
+    gray    = 107
+};
+
+enum class control {  // Behaviour of rang function calls
+    Off   = 0,  // toggle off rang style/color calls
+    Auto  = 1,  // (Default) autodect terminal and colorize if needed
+    Force = 2  // force ansi color output to non terminal streams
+};
+// Use rang::setControlMode to set rang control mode
+
+enum class winTerm {  // Windows Terminal Mode
+    Auto   = 0,  // (Default) automatically detects wheter Ansi or Native API
+    Ansi   = 1,  // Force use Ansi API
+    Native = 2  // Force use Native API
+};
+// Use rang::setWinTermMode to explicitly set terminal API for Windows
+// Calling rang::setWinTermMode have no effect on other OS
+
+namespace rang_implementation {
+
+    inline std::atomic<control> &controlMode() noexcept
+    {
+        static std::atomic<control> value(control::Auto);
+        return value;
+    }
+
+    inline std::atomic<winTerm> &winTermMode() noexcept
+    {
+        static std::atomic<winTerm> termMode(winTerm::Auto);
+        return termMode;
+    }
+
+    inline bool supportsColor() noexcept
+    {
+#if defined(OS_LINUX) || defined(OS_MAC)
+
+        static const bool result = [] {
+            const char *Terms[]
+              = { "ansi",    "color",  "console", "cygwin", "gnome",
+                  "konsole", "kterm",  "linux",   "msys",   "putty",
+                  "rxvt",    "screen", "vt100",   "xterm" };
+
+            const char *env_p = std::getenv("TERM");
+            if (env_p == nullptr) {
+                return false;
+            }
+            return std::any_of(std::begin(Terms), std::end(Terms),
+                               [&](const char *term) {
+                                   return std::strstr(env_p, term) != nullptr;
+                               });
+        }();
+
+#elif defined(OS_WIN)
+        // All windows versions support colors through native console methods
+        static constexpr bool result = true;
+#endif
+        return result;
+    }
+
+#ifdef OS_WIN
+
+
+    inline bool isMsysPty(int fd) noexcept
+    {
+        // Dynamic load for binary compability with old Windows
+        const auto ptrGetFileInformationByHandleEx
+          = reinterpret_cast<decltype(&GetFileInformationByHandleEx)>(
+            GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")),
+                           "GetFileInformationByHandleEx"));
+        if (!ptrGetFileInformationByHandleEx) {
+            return false;
+        }
+
+        HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
+        if (h == INVALID_HANDLE_VALUE) {
+            return false;
+        }
+
+        // Check that it's a pipe:
+        if (GetFileType(h) != FILE_TYPE_PIPE) {
+            return false;
+        }
+
+        // POD type is binary compatible with FILE_NAME_INFO from WinBase.h
+        // It have the same alignment and used to avoid UB in caller code
+        struct MY_FILE_NAME_INFO {
+            DWORD FileNameLength;
+            WCHAR FileName[MAX_PATH];
+        };
+
+        auto pNameInfo = std::unique_ptr<MY_FILE_NAME_INFO>(
+          new (std::nothrow) MY_FILE_NAME_INFO());
+        if (!pNameInfo) {
+            return false;
+        }
+
+        // Check pipe name is template of
+        // {"cygwin-","msys-"}XXXXXXXXXXXXXXX-ptyX-XX
+        if (!ptrGetFileInformationByHandleEx(h, FileNameInfo, pNameInfo.get(),
+                                             sizeof(MY_FILE_NAME_INFO))) {
+            return false;
+        }
+        std::wstring name(pNameInfo->FileName, pNameInfo->FileNameLength / sizeof(WCHAR));
+        if ((name.find(L"msys-") == std::wstring::npos
+             && name.find(L"cygwin-") == std::wstring::npos)
+            || name.find(L"-pty") == std::wstring::npos) {
+            return false;
+        }
+
+        return true;
+    }
+
+#endif
+
+    inline bool isTerminal(const std::streambuf *osbuf) noexcept
+    {
+        using std::cerr;
+        using std::clog;
+        using std::cout;
+#if defined(OS_LINUX) || defined(OS_MAC)
+        if (osbuf == cout.rdbuf()) {
+            static const bool cout_term = isatty(fileno(stdout)) != 0;
+            return cout_term;
+        } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
+            static const bool cerr_term = isatty(fileno(stderr)) != 0;
+            return cerr_term;
+        }
+#elif defined(OS_WIN)
+        if (osbuf == cout.rdbuf()) {
+            static const bool cout_term
+              = (_isatty(_fileno(stdout)) || isMsysPty(_fileno(stdout)));
+            return cout_term;
+        } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
+            static const bool cerr_term
+              = (_isatty(_fileno(stderr)) || isMsysPty(_fileno(stderr)));
+            return cerr_term;
+        }
+#endif
+        return false;
+    }
+
+    template <typename T>
+    using enableStd = typename std::enable_if<
+      std::is_same<T, rang::style>::value || std::is_same<T, rang::fg>::value
+        || std::is_same<T, rang::bg>::value || std::is_same<T, rang::fgB>::value
+        || std::is_same<T, rang::bgB>::value,
+      std::ostream &>::type;
+
+
+#ifdef OS_WIN
+
+    struct SGR {  // Select Graphic Rendition parameters for Windows console
+        BYTE fgColor;  // foreground color (0-15) lower 3 rgb bits + intense bit
+        BYTE bgColor;  // background color (0-15) lower 3 rgb bits + intense bit
+        BYTE bold;  // emulated as FOREGROUND_INTENSITY bit
+        BYTE underline;  // emulated as BACKGROUND_INTENSITY bit
+        BOOLEAN inverse;  // swap foreground/bold & background/underline
+        BOOLEAN conceal;  // set foreground/bold to background/underline
+    };
+
+    enum class AttrColor : BYTE {  // Color attributes for console screen buffer
+        black   = 0,
+        red     = 4,
+        green   = 2,
+        yellow  = 6,
+        blue    = 1,
+        magenta = 5,
+        cyan    = 3,
+        gray    = 7
+    };
+
+    inline HANDLE getConsoleHandle(const std::streambuf *osbuf) noexcept
+    {
+        if (osbuf == std::cout.rdbuf()) {
+            static const HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
+            return hStdout;
+        } else if (osbuf == std::cerr.rdbuf() || osbuf == std::clog.rdbuf()) {
+            static const HANDLE hStderr = GetStdHandle(STD_ERROR_HANDLE);
+            return hStderr;
+        }
+        return INVALID_HANDLE_VALUE;
+    }
+
+    inline bool setWinTermAnsiColors(const std::streambuf *osbuf) noexcept
+    {
+        HANDLE h = getConsoleHandle(osbuf);
+        if (h == INVALID_HANDLE_VALUE) {
+            return false;
+        }
+        DWORD dwMode = 0;
+        if (!GetConsoleMode(h, &dwMode)) {
+            return false;
+        }
+        dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+        if (!SetConsoleMode(h, dwMode)) {
+            return false;
+        }
+        return true;
+    }
+
+    inline bool supportsAnsi(const std::streambuf *osbuf) noexcept
+    {
+        using std::cerr;
+        using std::clog;
+        using std::cout;
+        if (osbuf == cout.rdbuf()) {
+            static const bool cout_ansi
+              = (isMsysPty(_fileno(stdout)) || setWinTermAnsiColors(osbuf));
+            return cout_ansi;
+        } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
+            static const bool cerr_ansi
+              = (isMsysPty(_fileno(stderr)) || setWinTermAnsiColors(osbuf));
+            return cerr_ansi;
+        }
+        return false;
+    }
+
+    inline const SGR &defaultState() noexcept
+    {
+        static const SGR defaultSgr = []() -> SGR {
+            CONSOLE_SCREEN_BUFFER_INFO info;
+            WORD attrib = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
+            if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE),
+                                           &info)
+                || GetConsoleScreenBufferInfo(GetStdHandle(STD_ERROR_HANDLE),
+                                              &info)) {
+                attrib = info.wAttributes;
+            }
+            SGR sgr     = { 0, 0, 0, 0, FALSE, FALSE };
+            sgr.fgColor = attrib & 0x0F;
+            sgr.bgColor = (attrib & 0xF0) >> 4;
+            return sgr;
+        }();
+        return defaultSgr;
+    }
+
+    inline BYTE ansi2attr(BYTE rgb) noexcept
+    {
+        static const AttrColor rev[8]
+          = { AttrColor::black,  AttrColor::red,  AttrColor::green,
+              AttrColor::yellow, AttrColor::blue, AttrColor::magenta,
+              AttrColor::cyan,   AttrColor::gray };
+        return static_cast<BYTE>(rev[rgb]);
+    }
+
+    inline void setWinSGR(rang::bg col, SGR &state) noexcept
+    {
+        if (col != rang::bg::reset) {
+            state.bgColor = ansi2attr(static_cast<BYTE>(col) - 40);
+        } else {
+            state.bgColor = defaultState().bgColor;
+        }
+    }
+
+    inline void setWinSGR(rang::fg col, SGR &state) noexcept
+    {
+        if (col != rang::fg::reset) {
+            state.fgColor = ansi2attr(static_cast<BYTE>(col) - 30);
+        } else {
+            state.fgColor = defaultState().fgColor;
+        }
+    }
+
+    inline void setWinSGR(rang::bgB col, SGR &state) noexcept
+    {
+        state.bgColor = (BACKGROUND_INTENSITY >> 4)
+          | ansi2attr(static_cast<BYTE>(col) - 100);
+    }
+
+    inline void setWinSGR(rang::fgB col, SGR &state) noexcept
+    {
+        state.fgColor
+          = FOREGROUND_INTENSITY | ansi2attr(static_cast<BYTE>(col) - 90);
+    }
+
+    inline void setWinSGR(rang::style style, SGR &state) noexcept
+    {
+        switch (style) {
+            case rang::style::reset: state = defaultState(); break;
+            case rang::style::bold: state.bold = FOREGROUND_INTENSITY; break;
+            case rang::style::underline:
+            case rang::style::blink:
+                state.underline = BACKGROUND_INTENSITY;
+                break;
+            case rang::style::reversed: state.inverse = TRUE; break;
+            case rang::style::conceal: state.conceal = TRUE; break;
+            default: break;
+        }
+    }
+
+    inline SGR &current_state() noexcept
+    {
+        static SGR state = defaultState();
+        return state;
+    }
+
+    inline WORD SGR2Attr(const SGR &state) noexcept
+    {
+        WORD attrib = 0;
+        if (state.conceal) {
+            if (state.inverse) {
+                attrib = (state.fgColor << 4) | state.fgColor;
+                if (state.bold)
+                    attrib |= FOREGROUND_INTENSITY | BACKGROUND_INTENSITY;
+            } else {
+                attrib = (state.bgColor << 4) | state.bgColor;
+                if (state.underline)
+                    attrib |= FOREGROUND_INTENSITY | BACKGROUND_INTENSITY;
+            }
+        } else if (state.inverse) {
+            attrib = (state.fgColor << 4) | state.bgColor;
+            if (state.bold) attrib |= BACKGROUND_INTENSITY;
+            if (state.underline) attrib |= FOREGROUND_INTENSITY;
+        } else {
+            attrib = state.fgColor | (state.bgColor << 4) | state.bold
+              | state.underline;
+        }
+        return attrib;
+    }
+
+    template <typename T>
+    inline void setWinColorAnsi(std::ostream &os, T const value)
+    {
+        os << "\033[" << static_cast<int>(value) << "m";
+    }
+
+    template <typename T>
+    inline void setWinColorNative(std::ostream &os, T const value)
+    {
+        const HANDLE h = getConsoleHandle(os.rdbuf());
+        if (h != INVALID_HANDLE_VALUE) {
+            setWinSGR(value, current_state());
+            // Out all buffered text to console with previous settings:
+            os.flush();
+            SetConsoleTextAttribute(h, SGR2Attr(current_state()));
+        }
+    }
+
+    template <typename T>
+    inline enableStd<T> setColor(std::ostream &os, T const value)
+    {
+        if (winTermMode() == winTerm::Auto) {
+            if (supportsAnsi(os.rdbuf())) {
+                setWinColorAnsi(os, value);
+            } else {
+                setWinColorNative(os, value);
+            }
+        } else if (winTermMode() == winTerm::Ansi) {
+            setWinColorAnsi(os, value);
+        } else {
+            setWinColorNative(os, value);
+        }
+        return os;
+    }
+#else
+    template <typename T>
+    inline enableStd<T> setColor(std::ostream &os, T const value)
+    {
+        return os << "\033[" << static_cast<int>(value) << "m";
+    }
+#endif
+}  // namespace rang_implementation
+
+template <typename T>
+inline rang_implementation::enableStd<T> operator<<(std::ostream &os,
+                                                    const T value)
+{
+    const control option = rang_implementation::controlMode();
+    switch (option) {
+        case control::Auto:
+            return rang_implementation::supportsColor()
+                && rang_implementation::isTerminal(os.rdbuf())
+              ? rang_implementation::setColor(os, value)
+              : os;
+        case control::Force: return rang_implementation::setColor(os, value);
+        default: return os;
+    }
+}
+
+inline void setWinTermMode(const rang::winTerm value) noexcept
+{
+    rang_implementation::winTermMode() = value;
+}
+
+inline void setControlMode(const control value) noexcept
+{
+    rang_implementation::controlMode() = value;
+}
+
+}  // namespace rang
+
+#undef OS_LINUX
+#undef OS_WIN
+#undef OS_MAC
+
+#endif /* ifndef RANG_DOT_HPP */
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
new file mode 100644
index 0000000..f89ac7c
--- /dev/null
+++ b/src/CMakeLists.txt
@@ -0,0 +1,24 @@
+file(GLOB FILENAMES *.cpp)
+
+find_library(BDD_LIBRARY NAMES bdd PATHS /usr/local/lib)
+if (BDD_LIBRARY)
+    message(STATUS "Found BDD: ${BDD_LIBRARY}")
+    #target_link_libraries(convert_bdd ${BDD_LIBRARY})
+    #target_include_directories(convert_bdd PRIVATE /usr/local/include)
+else()
+    message(FATAL_ERROR "bdd library not found!")
+endif()
+
+foreach(filename ${FILENAMES})
+  get_filename_component(basename ${filename} NAME_WE)
+  add_executable(${basename} ${filename})
+  target_link_libraries(${basename} PUBLIC mockturtle bdd)
+  if(ENABLE_CACHE_STATS)
+    add_definitions(-DCACHE_STATS)
+  endif()
+
+  if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${basename}.cmake")
+    include(${basename}.cmake)
+  endif()
+endforeach()
+
diff --git a/src/convert_bbdd.cpp b/src/convert_bbdd.cpp
new file mode 100644
index 0000000..39d1501
--- /dev/null
+++ b/src/convert_bbdd.cpp
@@ -0,0 +1,163 @@
+#include <cstdlib>
+#include <filesystem>
+#include <iostream>
+#include <string>
+#include <unistd.h>
+
+#include <lorina/diagnostics.hpp>
+#include <lorina/lorina.hpp>
+#include <mockturtle/algorithms/cover_to_graph.hpp>
+#include <mockturtle/mockturtle.hpp>
+
+#include "bbdd/include/bbdd.hpp"
+#include "bbdd/include/unique_table.hpp"
+#include "util/cover_to_bbdd.hpp"
+
+int main(int argc, char *argv[]) {
+  bool vis = false;
+  bool use_height = false;
+  bool use_order_input = false;
+  std::string order_output_dir;
+  int sifting_repetitions = 1;
+  int table_size = 20000000;
+  int opt;
+
+  while ((opt = getopt(argc, argv, "i:vhr:t:")) != -1) {
+    switch (opt) {
+    case 'i':
+      use_order_input = true;
+      order_output_dir = optarg;
+      break;
+    case 'v':
+      vis = true;
+      break;
+    case 'h':
+      use_height = true;
+      break;
+    case 't': {
+      char *endptr = nullptr;
+      table_size = std::strtol(optarg, &endptr, 10);
+      if (*endptr != '\0') {
+        std::cerr << "[ERROR] Invalid integer for option -t: " << optarg << std::endl;
+        return EXIT_FAILURE;
+      }
+      if (table_size < 0 || table_size > pow(2, 31)){
+        std::cerr << "[ERROR] Invalid integer: " << optarg << std::endl;
+        return EXIT_FAILURE;
+      }
+      break;
+    }
+    case 'r': {
+      char *endptr = nullptr;
+      sifting_repetitions = std::strtol(optarg, &endptr, 10);
+      if (*endptr != '\0') {
+        std::cerr << "[ERROR] Invalid integer for option -r: " << optarg << std::endl;
+        return EXIT_FAILURE;
+      }
+      break;
+    }
+    default:
+      std::cerr << "Usage: " << argv[0]
+                << " [-v] [-r ordering_output_file] <blif-file>" << std::endl;
+      return EXIT_FAILURE;
+    }
+  }
+
+  if (optind >= argc) {
+    std::cout << "[ERROR] input file in blif format is missing\n";
+    std::cerr << "[INFO] Usage: " << argv[0] << " [-v] <blif-file>"
+              << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  std::string benchmark(argv[optind]);
+  if (!std::filesystem::exists(benchmark)) {
+    std::cout << "[ERROR] File does not exist\n";
+    return EXIT_FAILURE;
+  }
+
+  std::filesystem::path path(benchmark);
+  std::string base_name = path.stem().string();
+
+  mockturtle::cover_network cover;
+
+  if (lorina::read_blif(benchmark, mockturtle::blif_reader(cover)) !=
+      lorina::return_code::success) {
+    std::cout << "[ERROR] While Lorina tried to read in file\n";
+    return EXIT_FAILURE;
+  }
+
+  std::vector<node_index_t> cvo_input_v;
+  if (use_order_input) {
+    std::string line;
+    std::cout << "Enter variable ordering separated by spaces (leave empty for "
+                 "default ordering): ";
+    std::getline(std::cin, line);
+    std::stringstream str_s(line);
+    int num;
+    while (str_s >> num) {
+      cvo_input_v.push_back(num);
+    }
+    if (cover._storage->inputs.size() != cvo_input_v.size() &&
+        !cvo_input_v.empty()) {
+      std::cerr << "[ERROR] Number of variables in ordering does not match "
+                   "number of inputs\n";
+      return EXIT_FAILURE;
+    }
+  }
+  use_order_input = true;
+  cvo_input_v = {};
+
+  printf("[INFO] cover with %zu nodes\n", cover._storage->nodes.size());
+  Unique_table table;
+  table.init_table(table_size, cover.get_module_name());
+  if (use_order_input && !cvo_input_v.empty()) {
+    table.init_cvo(cover._storage->inputs, cvo_input, cvo_input_v);
+  } else {
+    table.init_cvo(cover._storage->inputs, cvo_none);
+  }
+  std::filesystem::path order_output_dir_path;
+  std::filesystem::path base_name_path;
+  std::filesystem::path order_file_path;
+  std::ofstream order_file;
+  if (use_order_input) {
+    order_output_dir_path = order_output_dir;
+    base_name_path = base_name;
+    base_name_path.replace_extension(".csv");
+    order_file_path = order_output_dir_path / base_name_path;
+    bool order_file_exitsts = std::filesystem::exists(order_file_path);
+    order_file.open(order_file_path, std::ios::app);
+    if (!order_file_exitsts) {
+      order_file << "order_in;order_pos;height;nodes\n";
+    }
+  }
+  cover_to_bbdd(&table, cover, use_height, sifting_repetitions, order_file);
+  std::cout << "[INFO] BBDD created\n";
+  if (vis) {
+    std::cout << "[INFO] dumping result into .dot file\n";
+    table.dump_table();
+    table.dump_dot("temp/" + base_name + ".dot", cover.signal_map);
+    system(
+        ("dot -Tpng temp/" + base_name + ".dot -o temp/" + base_name + ".png")
+            .c_str());
+  }
+#ifdef CACHE_STATS
+  table.print_cache_stats();
+  table.dump_cache_stats("temp/" + base_name + "_cache_stats.csv");
+#endif
+  if (use_order_input) {
+    std::cout
+        << "[INFO] Writing ordering, total height, total number of nodes to "
+        << order_file_path << "\n";
+    dump_ordering(table.cvo, order_file);
+    order_file << ";" << table.get_total_height() << ";"
+               << table.get_total_number_nodes() << "\n";
+    order_file.close();
+  }
+  std::cout << "[INFO] Writing bbdd into blif file\n";
+  table.write_blif("temp/" + base_name + "_bbdd" +
+                       (use_height ? "_height" : "") + ".blif",
+                   cover.get_module_name(), cover.signal_map, cover._storage->inputs.size());
+  table.free_table();
+  return EXIT_SUCCESS;
+}
diff --git a/src/convert_bdd.cpp b/src/convert_bdd.cpp
new file mode 100644
index 0000000..9f1c308
--- /dev/null
+++ b/src/convert_bdd.cpp
@@ -0,0 +1,148 @@
+#include <algorithm>
+#include <cstdlib>
+#include <filesystem>
+#include <iostream>
+#include <string>
+#include <unistd.h>
+
+#include <lorina/diagnostics.hpp>
+#include <lorina/lorina.hpp>
+#include <mockturtle/algorithms/cover_to_graph.hpp>
+#include <mockturtle/mockturtle.hpp>
+
+#include "util/cover_to_bdd.hpp"
+#include "bdd.h"
+#include "mockturtle/io/write_blif.hpp"
+#include "mockturtle/networks/cover.hpp"
+
+int write_blif_recursive(std::ofstream &blif_file, cover_network cover,
+                         const BDD &node, int next_index, bool output) {
+  if (node < 2) {
+    return node;
+  }
+  int low_out =
+      write_blif_recursive(blif_file, cover, bdd_low(node), next_index, false);
+  int high_out = write_blif_recursive(blif_file, cover, bdd_high(node),
+                                      next_index++, false);
+  blif_file << ".names " << cover.signal_map[bdd_var(node)] << " ";
+  if (IS_TERM(low_out)) {
+    if (low_out == 0) {
+      blif_file << "$false ";
+    } else {
+      blif_file << "$true ";
+    }
+  } else {
+    blif_file << std::to_string(low_out);
+  }
+  blif_file << " ";
+  if (IS_TERM(high_out)) {
+    if (high_out == 0) {
+      blif_file << "$false ";
+    } else {
+      blif_file << "$true ";
+    }
+  } else {
+    blif_file << std::to_string(high_out) << " ";
+  }
+  /*blif_file << std::format(
+      ".names {} {} {} {}", cover.signal_map[bdd_var(node)],
+      IS_TERM(low_out) ? (low_out == 0 ? "$false" : "$true")
+                       : std::to_string(low_out),
+      IS_TERM(high_out) ? (high_out == 0 ? "$false" : "$true")
+                        : std::to_string(high_out),
+      !output ? std::to_string(node) : "");*/
+  if (!output) {
+    blif_file << std::to_string(node);
+    blif_file << "\n0-1 1\n11- 1\n";
+  }
+  return node;
+}
+
+void write_blif(std::string filename, mockturtle::cover_network cover,
+                std::vector<std::pair<bdd, std::string>> output_map) {
+  std::ofstream blif_file(filename);
+  blif_file << ".model " + cover.get_module_name() + "\n";
+  blif_file << ".inputs";
+  for (unsigned int i = 0; i < cover.signal_map.size(); i++) {
+    blif_file << " " << cover.signal_map[i];
+    if (i + 1 == cover._storage->inputs.size()) {
+      blif_file << "\n.outputs";
+    }
+  }
+  blif_file << "\n.names $true\n1\n";
+  blif_file << ".names $false\n";
+  int next_index = cover._storage->inputs.size() + 1;
+  for (std::pair<bdd, std::string> out_map : output_map) {
+    if (out_map.first == bdd_true()) {
+      blif_file << ".names " << out_map.second << "\n1\n";
+    } else if (out_map.first == bdd_false()) {
+      blif_file << ".names " << out_map.second << "\n0\n";
+    } else {
+      write_blif_recursive(blif_file, cover, out_map.first.id(), next_index,
+                           true);
+      blif_file << out_map.second << "\n0-1 1\n11- 1\n";
+    }
+  }
+  blif_file << ".end\n";
+}
+
+int get_bdd_height(BDD node) {
+  if (node < 2) {
+    return 0;
+  }
+  int low_height = get_bdd_height(bdd_low(node));
+  int high_height = get_bdd_height(bdd_high(node));
+  return std::max(low_height, high_height) + 1;
+}
+
+int get_total_height(std::vector<std::pair<bdd, std::string>> output_map) {
+  int max_height = -1;
+  for (std::pair<bdd, std::string> out_map : output_map) {
+    int current_height = get_bdd_height(out_map.first.id());
+    if (current_height > max_height) {
+      max_height = current_height;
+    }
+  }
+  return max_height;
+}
+
+int main(int argc, char *argv[]) {
+  if (optind >= argc) {
+    std::cout << "[ERROR] input file in blif format is missing\n";
+    std::cerr << "[INFO] Usage: " << argv[0] << " <blif-file>"
+              << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  std::string benchmark(argv[optind]);
+  if (!std::filesystem::exists(benchmark)) {
+    std::cout << "[ERROR] File does not exist\n";
+    return EXIT_FAILURE;
+  }
+
+  std::filesystem::path path(benchmark);
+  std::string base_name = path.stem().string();
+
+  mockturtle::cover_network cover;
+  // lorina::diagnostic_engine diag;
+
+  if (lorina::read_blif(benchmark, mockturtle::blif_reader(cover)) !=
+      lorina::return_code::success) {
+    std::cout << "[ERROR] While Lorina tried to read in file\n";
+    return EXIT_FAILURE;
+  }
+
+  std::vector<std::pair<bdd, std::string>> output_map;
+
+  bdd_init(300000, 10000);
+  bdd_setvarnum(cover._storage->inputs.size());
+  bdd_autoreorder(BDD_REORDER_SIFT);
+  printf("[INFO] init with %zu variables\n", cover._storage->inputs.size());
+  cover_to_bdd(cover, output_map);
+  // printf("height before: %d\n", get_total_height(output_map));
+  bdd_reorder(BDD_REORDER_SIFT); //bdd_reorder_siftite is the same but repeats until no more progress is done
+  printf("height after: %d\n", get_total_height(output_map));
+  write_blif("temp/" + base_name + "_bdd.blif", cover, output_map);
+  bdd_done();
+  return EXIT_SUCCESS;
+}
diff --git a/src/convert_muxig.cpp b/src/convert_muxig.cpp
new file mode 100644
index 0000000..5c30f41
--- /dev/null
+++ b/src/convert_muxig.cpp
@@ -0,0 +1,94 @@
+#include <filesystem>
+#include <iostream>
+#include <lorina/verilog.hpp>
+#include <mockturtle/algorithms/cleanup.hpp>
+#include <mockturtle/io/verilog_reader.hpp>
+#include <mockturtle/properties/migcost.hpp>
+#include <mockturtle/utils/stopwatch.hpp>
+#include <string>
+
+#include "lorina/blif.hpp"
+#include "mockturtle/algorithms/cover_to_graph.hpp"
+#include "mockturtle/networks/cover.hpp"
+#include "mockturtle/networks/muxig.hpp"
+
+#include "mockturtle/algorithms/sim_resub.hpp"
+#include "mockturtle/io/blif_reader.hpp"
+#include "mockturtle/io/write_blif.hpp"
+
+int main(int argc, char *argv[]) {
+  // Default values
+  int max_pis = 10; // 8;
+  int max_divisors = 150;
+  int max_inserts = 20; // 2;
+
+  int opt;
+  while ((opt = getopt(argc, argv, "o:p:d:i:")) != -1) {
+    switch (opt) {
+    case 'p':
+      max_pis = std::atoi(optarg);
+      break;
+    case 'o':
+      break;
+    case 'd':
+      max_divisors = std::atoi(optarg);
+      break;
+    case 'i':
+      max_inserts = std::atoi(optarg);
+      break;
+    default:
+      std::cerr << "Usage: " << argv[0]
+                << " [-p max_pi] [-d max_divisors] [-i max_inserts] "
+                   "<benchmark_file>\n";
+      return 1;
+    }
+  }
+
+  std::string benchmark;
+  if (optind < argc) {
+    benchmark = argv[optind];
+  } else {
+    std::cerr << "Error: Missing required positional argument.\n";
+    std::cerr
+        << "Usage: " << argv[0]
+        << " [-p max_pi] [-d max_divisors] [-i max_inserts] <benchmark_file>\n";
+    return 1;
+  }
+
+  if (!std::filesystem::exists(benchmark)) {
+    std::cout << "[ERROR] File does not exist\n";
+    return EXIT_FAILURE;
+  }
+
+  std::filesystem::path path(benchmark);
+  std::string base_name = path.stem().string();
+
+  mockturtle::cover_network cover;
+
+  if (lorina::read_blif(benchmark, mockturtle::blif_reader(cover)) !=
+      lorina::return_code::success) {
+    std::cout << "[ERROR] While Lorina tried to read in file\n";
+    return EXIT_FAILURE;
+  }
+
+  mockturtle::muxig_network muxig_original =
+      mockturtle::convert_cover_to_graph<mockturtle::muxig_network>(cover);
+
+  mockturtle::resubstitution_params ps;
+  mockturtle::resubstitution_stats st;
+
+  ps.max_inserts = max_inserts;
+  ps.max_pis = max_pis;
+  ps.max_divisors = max_divisors;
+  ps.progress = false;
+  ps.verbose = false;
+
+  mockturtle::sim_resubstitution(muxig_original, ps, &st);
+
+  muxig_original = mockturtle::cleanup_dangling(muxig_original);
+
+  mockturtle::write_blif(muxig_original,
+                         "temp/" + base_name + "_muxig_temp.blif");
+
+  return EXIT_SUCCESS;
+}
diff --git a/src/convert_muxig_opt.cpp b/src/convert_muxig_opt.cpp
new file mode 100644
index 0000000..a740992
--- /dev/null
+++ b/src/convert_muxig_opt.cpp
@@ -0,0 +1,258 @@
+#include <filesystem>
+#include <iostream>
+#include <lorina/verilog.hpp>
+#include <mockturtle/algorithms/cleanup.hpp>
+#include <mockturtle/io/verilog_reader.hpp>
+#include <mockturtle/properties/migcost.hpp>
+#include <mockturtle/utils/stopwatch.hpp>
+#include <string>
+
+#include "lorina/blif.hpp"
+#include "mockturtle/algorithms/cover_to_graph.hpp"
+#include "mockturtle/networks/cover.hpp"
+#include "mockturtle/networks/muxig.hpp"
+
+#include "mockturtle/algorithms/sim_resub.hpp"
+#include "mockturtle/io/blif_reader.hpp"
+#include "mockturtle/io/write_blif.hpp"
+
+#define SEL_INDEX 0
+#define IN0_INDEX 2
+#define IN1_INDEX 1
+
+#define SEL(ntk, node) ntk._storage->nodes[node].children[SEL_INDEX]
+#define IN0(ntk, node) ntk._storage->nodes[node].children[IN0_INDEX]
+#define IN1(ntk, node) ntk._storage->nodes[node].children[IN1_INDEX]
+
+int main(int argc, char *argv[]) {
+  // Default values
+  int max_pis = 10; // 8;
+  int max_divisors = 150;
+  int max_inserts = 20; // 2;
+
+  bool output_path_given = false;
+  std::string output_dir;
+
+  int opt;
+  while ((opt = getopt(argc, argv, "o:p:d:i:")) != -1) {
+    switch (opt) {
+    case 'o':
+      output_path_given = true;
+      output_dir = optarg;
+      break;
+    case 'p':
+      max_pis = std::atoi(optarg);
+      break;
+    case 'd':
+      max_divisors = std::atoi(optarg);
+      break;
+    case 'i':
+      max_inserts = std::atoi(optarg);
+      break;
+    default:
+      std::cerr << "Usage: " << argv[0]
+                << " [-p max_pi] [-d max_divisors] [-i max_inserts] [-o "
+                   "output_file for performance statistics]"
+                   "<positional_arg>\n";
+      return 1;
+    }
+  }
+
+  std::string benchmark;
+  if (optind < argc) {
+    benchmark = argv[optind];
+  } else {
+    std::cerr << "Error: Missing required positional argument.\n";
+    std::cerr
+        << "Usage: " << argv[0]
+        << " [-p max_pi] [-d max_divisors] [-i max_inserts] <benchmark_file>\n";
+    return 1;
+  }
+
+  if (!std::filesystem::exists(benchmark)) {
+    std::cout << "[ERROR] File does not exist\n";
+    return EXIT_FAILURE;
+  }
+
+  std::filesystem::path path(benchmark);
+  std::string base_name = path.stem().string();
+
+  mockturtle::cover_network cover;
+
+  if (lorina::read_blif(benchmark, mockturtle::blif_reader(cover)) !=
+      lorina::return_code::success) {
+    std::cout << "[ERROR] While Lorina tried to read in file\n";
+    return EXIT_FAILURE;
+  }
+
+  std::filesystem::path order_output_dir_path;
+  std::filesystem::path base_name_path;
+  std::filesystem::path order_file_path;
+  std::ofstream order_file;
+
+  mockturtle::muxig_network muxig_original =
+      mockturtle::convert_cover_to_graph<mockturtle::muxig_network>(cover);
+
+  mockturtle::resubstitution_params ps;
+  mockturtle::resubstitution_stats st;
+
+  ps.max_inserts = max_inserts;
+  ps.max_pis = max_pis;
+  ps.max_divisors = max_divisors;
+  ps.progress = false;
+  ps.verbose = false;
+
+  int size_before = muxig_original.num_gates();
+
+  mockturtle::sim_resubstitution(muxig_original, ps, &st);
+
+  muxig_original = mockturtle::cleanup_dangling(muxig_original);
+
+  int size_after = muxig_original.num_gates();
+  /*mockturtle::muxig_network muxig_sel = muxig_original.clone();
+  mockturtle::muxig_network muxig_and = muxig_original.clone();
+  mockturtle::muxig_network muxig_or = muxig_original.clone();
+  mockturtle::muxig_network muxig_all = muxig_original.clone();*/
+  mockturtle::muxig_network muxig = muxig_original.clone(); // jaspers
+  /*printf("before: %d, after: %d, sel: %d, and: %d, or: %d, all: %d\n",
+         size_before, muxig_original.num_gates(), muxig_sel.num_gates(),
+         muxig_and.num_gates(), muxig_or.num_gates(), muxig_all.num_gates());*/
+
+  // Info from mockturtle library
+  /* mux(a b c) = a b + a' c */
+  muxig.foreach_node([&](auto node) {
+    if (muxig.is_mux(node) && (muxig.fanin_size(node) == 3)) {
+      // if a and b are inverted push inverter to output
+      if (muxig.is_complemented(IN0(muxig, node)) &&
+          muxig.is_complemented(IN1(muxig, node))) {
+        muxig.substitute_node(
+            node, muxig.create_not(muxig.create_gate(
+                      SEL(muxig, node), muxig.create_not(IN1(muxig, node)),
+                      muxig.create_not(IN0(muxig, node)))));
+      }
+
+      if (IN0(muxig, node).index == IN1(muxig, node).index){
+        assert(muxig.is_complemented(IN0(muxig, node)) || muxig.is_complemented(IN1(muxig, node)));
+        printf("xor possibly\n");
+      }
+    }
+  });
+
+  mockturtle::fanout_view fnntk(muxig);
+  muxig.foreach_node([&](auto node) {
+    if (muxig.is_mux(node) && (muxig.fanin_size(node) == 3)) {
+      uint32_t inv = muxig.fanout_size(node);
+      std::vector<std::pair<int32_t, int32_t>> fanout_stack;
+      fnntk.foreach_fanout(node, [&](auto fan_out) {
+        int i = 0;
+        muxig.foreach_fanin(fan_out, [&](auto signal) {
+          if (muxig.get_node(signal) == node) {
+            if (signal.complement) {
+              inv--;
+            }
+            fanout_stack.emplace_back(fan_out, i);
+          }
+          i++;
+        });
+      });
+
+      int output_count = 0;
+
+      muxig.foreach_po([&](auto po) {
+        if (muxig.get_node(po) == node && muxig.is_complemented(po)) {
+          inv--;
+          fanout_stack.emplace_back(output_count, -1);
+        }
+        output_count++;
+      });
+
+      // if all fanouts are inverted
+      if (inv == 0 && muxig.fanout_size(node) != 0) {
+        if (IN1(muxig, node) == 0 && IN0(muxig, node) != 0 &&
+            !muxig.is_complemented(IN1(muxig, node))) {
+          // 0 is represented as 0 and 1 as !0
+          // switching not(not a and b) to (a or not b)
+          // this gets rid of all inverters at the output
+          std::swap(SEL(muxig, node), IN0(muxig, node));
+          std::swap(IN1(muxig, node), IN0(muxig, node));
+          IN0(muxig, node) = muxig.get_constant(true);
+          for (const auto &[node, child] : fanout_stack) {
+            if (child >= 0) {
+              muxig._storage->nodes[node].children[child] =
+                  muxig.create_not(muxig._storage->nodes[node].children[child]);
+            } else {
+              muxig._storage->outputs[node] =
+                  muxig.create_not(muxig._storage->outputs[node]);
+            }
+          }
+        } else if (IN0(muxig, node) == 0 && IN1(muxig, node) != 0 &&
+                   muxig.is_complemented(IN0(muxig, node))) {
+          // switching not(not a or b) to (a and not b)
+          std::swap(SEL(muxig, node), IN1(muxig, node));
+          std::swap(IN1(muxig, node), IN0(muxig, node));
+          IN1(muxig, node) = muxig.get_constant(false);
+          for (const auto &[node, child] : fanout_stack) {
+            if (child >= 0) {
+              muxig._storage->nodes[node].children[child] =
+                  muxig.create_not(muxig._storage->nodes[node].children[child]);
+            } else {
+              muxig._storage->outputs[node] =
+                  muxig.create_not(muxig._storage->outputs[node]);
+            }
+          }
+        }
+      }
+    }
+  });
+
+  muxig.foreach_node([&](auto node) {
+    if (muxig.is_mux(node) && (muxig.fanin_size(node) == 3)) {
+      if (muxig.is_complemented(SEL(muxig, node))) {
+        std::swap(IN0(muxig, node), IN1(muxig, node));
+        SEL(muxig, node) = muxig.create_not(SEL(muxig, node));
+        assert(!muxig.is_complemented(SEL(muxig, node)));
+      }
+      // and not
+      if (IN0(muxig, node) == 0 && !muxig.is_complemented(IN0(muxig, node))) {
+        if (muxig.is_complemented(IN1(muxig, node))) {
+          // (sel, IN1, IN0)
+          std::swap(IN1(muxig, node), SEL(muxig, node));
+          std::swap(IN0(muxig, node), IN1(muxig, node));
+          SEL(muxig, node) = muxig.create_not(SEL(muxig, node));
+        }
+      }
+      // or not
+      if (IN1(muxig, node) == 1) {
+        if (muxig.is_complemented(IN0(muxig, node))) {
+          std::swap(IN0(muxig, node), SEL(muxig, node));
+          std::swap(IN0(muxig, node), IN1(muxig, node));
+          SEL(muxig, node) = muxig.create_not(SEL(muxig, node));
+        }
+      }
+    }
+  });
+  if (output_path_given) {
+    order_output_dir_path = output_dir;
+    base_name_path = base_name;
+    base_name_path.replace_extension(".csv");
+    order_file_path = order_output_dir_path / base_name_path;
+    printf("Writing stats to %s\n", order_file_path.c_str());
+    order_file.open(order_file_path);
+    order_file << "before;after;inv_before;inv_all\n";
+    order_file << size_before << ";" << size_after << ";"
+               << mockturtle::num_inverters(muxig_original) << ";"
+               << mockturtle::num_inverters(muxig) << "\n";
+  }
+  printf("inverter before: %d after: %d\n",
+         mockturtle::num_inverters(muxig_original),
+         mockturtle::num_inverters(muxig));
+  /*printf("removed by sel: %d\n", mockturtle::num_inverters(muxig_original) -
+                                     mockturtle::num_inverters(muxig_sel));
+  printf("removed by and not: %d\n", mockturtle::num_inverters(muxig_original) -
+                                         mockturtle::num_inverters(muxig_and));
+  printf("removed by or not: %d\n", mockturtle::num_inverters(muxig_original) -
+                                        mockturtle::num_inverters(muxig_or));*/
+  mockturtle::write_blif(muxig, "temp/" + base_name + "_muxig_temp.blif");
+
+  return EXIT_SUCCESS;
+}
diff --git a/synth.sh b/synth.sh
new file mode 100755
index 0000000..f3f7523
--- /dev/null
+++ b/synth.sh
@@ -0,0 +1,199 @@
+#!/bin/bash
+
+BBDD_SCRIPT="yosys/bbdd_synth_muxxor.ys"
+BDD_SCRIPT="yosys/bdd_synth.ys"
+NEM_SCRIPT="yosys/nem_synth.ys"
+MUXIG_SCRIPT="yosys/muxig_synth.ys"
+SIFTING_SCRIPT="yosys/bbdd_sifting.ys"
+NO_FLATTEN_SCRIPT="yosys/no_flatten.ys"
+TEMP_DIR="temp"
+DATA_DIR="data"
+LIBERTY_FILE="liberty/nem_thesis.lib"
+TIMEOUT="2m" #1 minute timeout for now
+TECHMAP_BBDD="yosys/techmap_bbdd.v"
+
+print_options(){
+  echo "(1) Synthesis Verilog file with bbdd optimization"
+  echo "(2) Synthesis Verilog file with bdd optimization"
+  echo "(3) Synthesis Verilog file with muxig optimization"
+  echo "(4) Synthesis all optimization"
+  echo "(5) Test sifting function"
+  echo "(6) No flatten pass"
+  echo "(7) Check equality of two .blif files"
+  echo "(e) Exit"
+}
+
+safe_path() {
+  local unsafe_path="$1"
+  echo "$(printf '%s\n' "$unsafe_path" | sed 's/[&/\]/\\&/g')"
+}
+
+process_input() {
+  file_name=$(basename "$file_path") # with extension
+  file_base="${file_name%.*}" # without
+
+  # get top module name
+  read -p "top module [default=${file_base}] " top_module
+  top_module=${top_module:-${file_base}}
+
+  #safe_file_path=$(printf '%s\n' "$file_path" | sed 's/[&/\]/\\&/g')
+  safe_file_path=$(safe_path "$file_path")
+  #safe_techmap_path=$(printf '%s\n' "$TECHMAP_BBDD" | sed 's/[&/\]/\\&/g')
+}
+
+run_yosys() {
+  # Run yosys
+  if $nosat; then
+    sat_replacement="#"   # comment out {{SAT}}
+  else
+    sat_replacement=""    # replace {{SAT}} with nothing
+  fi
+  echo "Synthesising $file_base"
+  sed -e "s/{{VERILOG_FILE}}/$safe_file_path/g" \
+      -e "s/{{TEMP_DIR}}/$TEMP_DIR/g" \
+      -e "s/{{TOP_MODULE}}/$top_module/g" \
+      -e "s/{{BASE_NAME}}/$file_base/g" \
+      -e "s/{{TECHMAP_BBDD}}/$safe_techmap_path/g" \
+      -e "s/{{LIBERTY_FILE}}/$safe_liberty_path/g" \
+      -e "s/{{OUT_DIR}}/$safe_out_path/g" \
+      -e "s/{{TIMEOUT}}/$TIMEOUT/g" \
+      -e "s/{{SAT}}/$sat_replacement/g" \
+      "$yosys_script" > "$TEMP_DIR/${file_base}_synth.ys"
+  mkdir -p ${out_dir}/${file_base}/
+  /usr/bin/time -f "Time: %E\nCPU: %P\nMemory: %M KB" -o ${out_dir}/${file_base}/yosys_${opt_name}_time.txt yosys${yosys_flags} ${TEMP_DIR}/${file_base}_synth.ys
+  if [ -e ${out_dir}/${file_base} ]; then
+    python ./yosys/print_summary.py ${out_dir}/${file_base}
+  else
+    echo "${file_base} did not finish in time"
+  fi 
+}
+
+synth_verilog() {
+  local yosys_script="$1"
+  local opt_name="$2"
+  if ! $verbose; then
+    yosys_flags=" -q" # is quite mode
+  else
+    yosys_flags=""
+  fi
+  safe_techmap_path=$(safe_path "$TECHMAP_BBDD")
+  safe_liberty_path=$(safe_path "$LIBERTY_FILE")
+  echo "Using script: $yosys_script"
+  read -e -p 'Input file path: ' file_path 
+  # Get Output Dir
+  read -e -p 'Output directory: ' out_dir
+  safe_out_path=$(safe_path "$out_dir")
+  out_dir="${out_dir%/}/"
+  if [ -f "$file_path" ]; then 
+    process_input
+    run_yosys
+    if ! $nocleanup; then
+      rm ${TEMP_DIR}/${file_base}_synth.ys
+      rm ${TEMP_DIR}/${file_base}.blif
+      rm -f ${TEMP_DIR}/${file_base}_bbdd.blif
+      rm -f ${TEMP_DIR}/${file_base}_bdd.blif
+    fi
+    exit
+  elif [ -d "$file_path" ]; then
+    # extend / if not present
+    file_path="${file_path%/}/"
+    for file in "$file_path"*.v; do
+      if [ -e "$file" ]; then
+        safe_file_path=$(safe_path "$file")
+        file_name=$(basename "$file") # with extension
+        file_base="${file_name%.*}" # without
+        top_module="$file_base"
+        yosys_flags=" -q"
+        run_yosys
+        if ! $nocleanup; then
+          rm ${TEMP_DIR}/${file_base}_synth.ys
+          rm ${TEMP_DIR}/${file_base}.blif
+          rm -f ${TEMP_DIR}/${file_base}_bbdd.blif
+          rm -f ${TEMP_DIR}/${file_base}_bdd.blif
+        fi
+      fi
+    done
+    exit
+  else
+    echo "[ERROR] File ${file_path} does not exist"
+  fi 
+}
+
+compare_blif() {
+  read -e -p 'Golden model: ' golden_path 
+  read -e -p 'File to check: ' bbdd_path 
+  if [ -e "$golden_path" ] && [ -e "$bbdd_path" ]; then 
+
+    file_name=$(basename "$golden_path") # with extension
+    file_base="${file_name%.*}" # without extension
+
+    # get top module name
+    read -p "top module [default=${file_base}] " top_module
+    top_module=${top_module:-${file_base}}
+    
+    safe_golden_path=$(printf '%s\n' "$golden_path" | sed 's/[&/\]/\\&/g')
+    safe_bbdd_path=$(printf '%s\n' "$bbdd_path" | sed 's/[&/\]/\\&/g')
+    safe_techmap_path=$(printf '%s\n' "$TECHMAP_BBDD" | sed 's/[&/\]/\\&/g')
+    sed -e "s/{{TOP_MODULE}}/$top_module/g" -e "s/{{GOLDEN_MODULE}}/$safe_golden_path/g" -e "s/{{BBDD_MODULE}}/$safe_bbdd_path/g"  -e "s/{{TECHMAP_BBDD}}/$safe_techmap_path/g" "yosys/sat.ys" > "$TEMP_DIR/${file_base}_sat.ys"
+
+    yosys ${TEMP_DIR}/${file_base}_sat.ys
+    rm ${TEMP_DIR}/${file_base}_sat.ys
+    exit
+  else
+    echo "[ERROR] File ${file_path} does not exist"
+  fi 
+}
+
+handle_selection() {
+    case "$1" in
+        1) synth_verilog $BBDD_SCRIPT "bbdd";;
+        2) synth_verilog $BDD_SCRIPT "bdd";;
+        3) synth_verilog $MUXIG_SCRIPT "muxig";;
+        4) synth_verilog $NEM_SCRIPT "nem";;
+        5) synth_verilog $SIFTING_SCRIPT "bbdd";;
+        6) synth_verilog $NO_FLATTEN_SCRIPT "bbdd";;
+        7) compare_blif;;
+        e) echo "Exiting..."; exit 0 ;;
+        *) echo "Invalid option. Please try again." ;;
+    esac
+}
+
+# Initialize booleans as false
+nocleanup=false
+nosat=false
+verbose=false
+
+# Parse flags
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -nocleanup)
+      nocleanup=true
+      shift
+      ;;
+    -nosat)
+      nosat=true
+      shift
+      ;;
+    -v)
+      verbose=true
+      shift
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+      ;;
+  esac
+done
+
+# get input file
+mkdir -p $TEMP_DIR 
+
+while true; do
+  if [ "$nosat" = false ]; then
+    echo "Satisfiability check is enabled"
+  fi
+  print_options
+  read -p "Enter your choice [1-6]: " choice
+  handle_selection "$choice"
+  echo ""
+done
diff --git a/yosys/bbdd_synth_muxxor.ys b/yosys/bbdd_synth_muxxor.ys
new file mode 100644
index 0000000..b52f11f
--- /dev/null
+++ b/yosys/bbdd_synth_muxxor.ys
@@ -0,0 +1,71 @@
+######################### preprocessing ###########################################################################
+read_verilog {{VERILOG_FILE}}
+hierarchy -top {{TOP_MODULE}}
+proc;;
+opt;;;
+flatten -noscopeinfo;;
+opt;;;
+techmap;;
+opt;;;
+splitnets -ports;;
+opt;;;
+
+########################## write design to a blif file and delete empty line because mockturtle cannot handle that #
+write_blif {{TEMP_DIR}}/{{BASE_NAME}}.blif
+rename {{TOP_MODULE}} {{TOP_MODULE}}_golden
+exec -- sed -i '/^$/d' {{TEMP_DIR}}/{{BASE_NAME}}.blif
+
+########################## execute bbdd pass map the result back to yosys names and rename the module #############
+exec -- timeout {{TIMEOUT}} time -f "\nTime: %E\nCPU: %P\nMemory: %M KB" -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bbdd_time.txt ./build/src/convert_bbdd -t 300000 {{TEMP_DIR}}/{{BASE_NAME}}.blif
+read_blif {{TEMP_DIR}}/{{BASE_NAME}}_bbdd.blif
+rename {{TOP_MODULE}} {{TOP_MODULE}}_bbdd
+stat {{TOP_MODULE}}_bbdd
+techmap -map {{TECHMAP_BBDD}}
+copy {{TOP_MODULE}}_bbdd {{TOP_MODULE}}_sat
+techmap -map yosys/muxxor_inv_map.v {{TOP_MODULE}}_bbdd
+techmap -map yosys/muxxor_inv_sat.v {{TOP_MODULE}}_sat
+opt -full {{TOP_MODULE}}_bbdd
+opt -full {{TOP_MODULE}}_golden
+
+########################### check equality of the optimization ######################################################
+{{SAT}}miter -equiv -make_assert {{TOP_MODULE}}_golden {{TOP_MODULE}}_sat equal
+{{SAT}}flatten equal
+{{SAT}}clean equal
+{{SAT}}opt -full equal;;
+{{SAT}}techmap equal
+{{SAT}}sat -prove-asserts -set-init-zero -tempinduct -verify -show-regs -show-inputs -show-outputs -dump_vcd trace.vcd equal
+
+########################### write data without abc pass #############################################################
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bbdd.json stat -json {{TOP_MODULE}}_bbdd
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden.json stat -json {{TOP_MODULE}}_golden
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bbdd_ltp.txt ltp {{TOP_MODULE}}_sat
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden_ltp.txt ltp {{TOP_MODULE}}_golden
+
+########################### abc pass for the golden solution ########################################################
+copy {{TOP_MODULE}}_golden {{TOP_MODULE}}_golden_abc
+abc -liberty {{LIBERTY_FILE}} {{TOP_MODULE}}_golden_abc
+
+########################### abc pass for the optimization solution #################################################
+copy {{TOP_MODULE}}_bbdd {{TOP_MODULE}}_bbdd_abc
+abc -D 100 -liberty {{LIBERTY_FILE}} {{TOP_MODULE}}_bbdd_abc
+
+#print stats to file
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bbdd.json stat -json {{TOP_MODULE}}_bbdd
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bbdd_abc.json stat -json {{TOP_MODULE}}_bbdd_abc
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden.json stat -json {{TOP_MODULE}}_golden
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden_abc.json stat -json {{TOP_MODULE}}_golden_abc
+
+########################### write abc blif and verilog #############################################################
+write_blif -top {{TOP_MODULE}}_bbdd_abc {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bbdd_abc.blif
+write_blif -top {{TOP_MODULE}}_bbdd {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bbdd.blif
+write_blif -top {{TOP_MODULE}}_golden_abc {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden_abc.blif
+write_blif -top {{TOP_MODULE}}_golden {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden.blif
+select {{TOP_MODULE}}_bbdd_abc
+write_verilog -selected {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bbdd_abc.v
+select {{TOP_MODULE}}_bbdd
+write_verilog -selected {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bbdd.v
+select {{TOP_MODULE}}_golden_abc
+write_verilog -selected {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden_abc.v
+select {{TOP_MODULE}}_golden
+write_verilog -selected {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden.v
+
diff --git a/yosys/bdd_synth.ys b/yosys/bdd_synth.ys
new file mode 100644
index 0000000..e263356
--- /dev/null
+++ b/yosys/bdd_synth.ys
@@ -0,0 +1,66 @@
+######################### preprocessing ###########################################################################
+read_verilog {{VERILOG_FILE}}
+hierarchy -top {{TOP_MODULE}}
+proc;;
+opt;;;
+flatten -noscopeinfo;;
+opt;;;
+techmap;;
+opt;;;
+splitnets -ports;;
+opt;;;
+
+########################## write design to a blif file and delete empty line because mockturtle cannot handle that #
+write_blif {{TEMP_DIR}}/{{BASE_NAME}}.blif
+exec -- sed -i '/^$/d' {{TEMP_DIR}}/{{BASE_NAME}}.blif
+rename {{TOP_MODULE}} {{TOP_MODULE}}_golden
+
+########################## execute bdd pass map the result back to yosys names and rename the module #############
+exec -- timeout {{TIMEOUT}} time -f "\nTime: %E\nCPU: %P\nMemory: %M KB" -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bdd_time.txt ./build/src/convert_bdd {{TEMP_DIR}}/{{BASE_NAME}}.blif
+read_blif {{TEMP_DIR}}/{{BASE_NAME}}_bdd.blif
+rename {{TOP_MODULE}} {{TOP_MODULE}}_bdd
+techmap -map {{TECHMAP_BBDD}} {{BASE_NAME}}_bdd
+stat {{BASE_NAME}}_bdd
+opt {{TOP_MODULE}}_bdd
+stat {{BASE_NAME}}_bdd
+opt -full {{TOP_MODULE}}_golden
+
+########################### check equality of the optimization ######################################################
+{{SAT}}miter -equiv -make_assert {{TOP_MODULE}}_golden {{TOP_MODULE}}_bdd equal
+{{SAT}}flatten equal
+{{SAT}}clean equal
+{{SAT}}opt -full equal;;
+{{SAT}}techmap equal
+{{SAT}}sat -prove-asserts -set-init-zero -tempinduct -verify -show-regs -show-inputs -show-outputs -dump_vcd trace.vcd equal
+
+########################### write stats without abc pass #############################################################
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bdd.json stat -json {{TOP_MODULE}}_bdd
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden.json stat -json {{TOP_MODULE}}_golden
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bdd_ltp.txt ltp {{TOP_MODULE}}_bdd
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden_ltp.txt ltp {{TOP_MODULE}}_golden
+
+########################### write netlists without abc pass #############################################################
+write_blif -top {{TOP_MODULE}}_bdd {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bdd.blif
+write_blif -top {{TOP_MODULE}}_golden {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden.blif
+select {{TOP_MODULE}}_bdd
+write_verilog -selected {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bdd.v
+select {{TOP_MODULE}}_golden
+write_verilog -selected {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden.v
+
+########################### abc pass for the golden solution ########################################################
+copy {{TOP_MODULE}}_golden {{TOP_MODULE}}_golden_abc
+abc -liberty {{LIBERTY_FILE}} {{TOP_MODULE}}_golden_abc
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden_abc.json stat -json {{TOP_MODULE}}_golden_abc
+
+########################### abc pass for the optimization solution #################################################
+copy {{TOP_MODULE}}_bdd {{TOP_MODULE}}_bdd_abc
+abc -liberty {{LIBERTY_FILE}} -script "+attach"
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bdd_abc.json stat -json {{TOP_MODULE}}_bdd_abc
+
+########################### write abc blif and verilog #############################################################
+write_blif -top {{TOP_MODULE}}_bdd_abc {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bdd_abc.blif
+write_blif -top {{TOP_MODULE}}_golden_abc {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden_abc.blif
+select {{TOP_MODULE}}_bdd_abc
+write_verilog -selected {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_bdd_abc.v
+select {{TOP_MODULE}}_golden_abc
+write_verilog -selected {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden_abc.v
diff --git a/yosys/device_count.yaml b/yosys/device_count.yaml
new file mode 100644
index 0000000..2d677da
--- /dev/null
+++ b/yosys/device_count.yaml
@@ -0,0 +1,79 @@
+# NEMS device type
+$mux:
+  4T: 2
+  3T: 0
+$xor: 
+  4T: 4
+  3T: 0
+$and: 
+  4T: 0
+  3T: 6
+$not: 
+  4T: 0
+  3T: 2
+$or: 
+  4T: 0
+  3T: 6
+# YOSYS types
+$_XOR_: 
+  4T: 4
+  3T: 0
+$_XNOR_: 
+  4T: 4
+  3T: 0
+$_AND_:
+  4T: 0
+  3T: 6
+$_NOT_:
+  4T: 0
+  3T: 2
+$_OR_:
+  4T: 0
+  3T: 6
+$_MUX_:
+  4T: 2
+  3T: 0
+# liberty files specifics
+inv_3T:
+  4T: 0
+  3T: 2
+nand_3T:
+  4T: 0
+  3T: 4
+and_3T:
+  4T: 0
+  3T: 6
+and_4T:
+  4T: 0
+  3T: 6
+nor_3T:
+  4T: 0
+  3T: 4
+or_3T:
+  4T: 0
+  3T: 6
+xor_3T:
+  4T: 0
+  3T: 12
+xnor_3T:
+  4T: 0
+  3T: 12
+xor_4T:
+  4T: 4
+  3T: 0
+xnor_4T:
+  4T: 4
+  3T: 0
+mux_3T:
+  4T: 0
+  3T: 12
+mux_4T:
+  4T: 2
+  3T: 0
+# custom mapping
+xor_mux:
+  4T: 0
+  3T: 2
+muxxor_4T:
+  4T: 0
+  3T: 2
diff --git a/yosys/map_ports.py b/yosys/map_ports.py
new file mode 100644
index 0000000..8bef49a
--- /dev/null
+++ b/yosys/map_ports.py
@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+import re
+import sys
+import os
+from pathlib import Path
+
+if(len(sys.argv)!=3):
+        sys.exit("[ERROR] Usage: map_ports YOSYS_BLIF_FILE MOCKTURTLE_BLIF_FILE")
+
+yosys_file = sys.argv[1]
+mockturtle_file = sys.argv[2]
+
+print("mapping: " + mockturtle_file + " to " + yosys_file)
+
+os.system('pwd')
+
+inputVariables = []
+outputVariables = []
+
+with open(yosys_file, 'r') as infile:
+    lines = infile.readlines()
+
+
+for line in lines:
+    if line.startswith(".inputs"):
+        inputs = line.split()
+        inputVariables = inputs[1:]
+
+    if line.startswith(".outputs"):
+        outputs = line.split()
+        outputVariables = outputs[1:]
+
+#print('input variables',inputVariables)
+#print('ouput variables',outputVariables)
+
+replacementList = {}
+
+for x in range(len(inputVariables)):
+    inputReplaceVar = "pi" + str(x + 1)
+    replacementList.update({inputReplaceVar:inputVariables[x]})
+
+for x in range(len(outputVariables)):
+    inputReplaceVar = "po" + str(x)
+    replacementList.update({inputReplaceVar:outputVariables[x]})
+
+#print('replacement list:',replacementList)
+
+#construct mapped path
+#mapped_file_parts = mockturtle_file.split('/')
+#mapped_file_parts[-1] = "muxig" + mapped_file_parts[-1]
+#mapped_file = "/".join(mapped_file_parts)
+mapped_path = Path(mockturtle_file)
+mapped_name = mapped_path.name.replace("_temp", "")
+mapped_file = mapped_path.with_name(mapped_name)
+
+#replace the replacement items in the blif Mockturtle file back to yosys input and outputs
+with open(mockturtle_file, 'r') as mockfile:
+    with open(mapped_file, 'w') as outfile:
+        for line in mockfile:
+            for src, target in replacementList.items():
+                line = line.replace(src + " ", target + " ")
+                if line.endswith(src+'\n'):
+                    line = line[:-len(src)-1] + target + '\n'
+            outfile.write(line)
+
+#print("Output written to ", mapped_file)
diff --git a/yosys/mockturtle_map.v b/yosys/mockturtle_map.v
new file mode 100644
index 0000000..ffa88af
--- /dev/null
+++ b/yosys/mockturtle_map.v
@@ -0,0 +1,86 @@
+// Jaspers work
+//Inverted Select
+(* techmap_celltype = "$lut" *)
+module \$lut_1 (A, Y);
+    parameter LUT = 0;
+    parameter WIDTH = 3;
+
+    wire _TECHMAP_FAIL_ = (WIDTH != 3) || LUT != 8'b11100100;
+
+    input [WIDTH-1:0] A;
+    output Y;
+    
+    $mux #(.WIDTH(1)) switch_mux_1 (.A(A[2]),.B(A[1]),.S(~A[0]),.Y(Y));
+endmodule
+
+//Inverted Select and inverted A input.
+(* techmap_celltype = "$lut" *)
+module \$lut_2 (A, Y);
+    parameter LUT = 0;
+    parameter WIDTH = 3;
+
+    wire _TECHMAP_FAIL_ = (WIDTH != 3) || LUT != 8'b01001110; 
+
+    input [WIDTH-1:0] A;
+    output Y;
+
+    $mux #(.WIDTH(1)) switch_mux_2 (.A(~A[2]),.B(A[1]),.S(~A[0]),.Y(Y));
+endmodule
+
+//Only Inverted A input
+(* techmap_celltype = "$lut" *)
+module \$lut_3 (A, Y);
+    parameter LUT = 0;
+    parameter WIDTH = 3;
+
+    wire _TECHMAP_FAIL_ = (WIDTH != 3) || LUT != 8'b10001101;
+
+    input [WIDTH-1:0] A;
+    output Y;
+
+    $mux #(.WIDTH(1)) switch_mux_3 (.A(~A[2]),.B(A[1]),.S(A[0]),.Y(Y));
+endmodule
+
+//normal mux maped to the yosys known
+(* techmap_celltype = "$lut" *)
+module \$lut_4 (A, Y);
+    parameter LUT = 0;
+    parameter WIDTH = 3;
+
+    wire _TECHMAP_FAIL_ = (WIDTH != 3) || LUT != 8'b11011000; 
+
+    input [WIDTH-1:0] A;
+    output Y;
+
+    $mux #(.WIDTH(1)) switch_mux_2 (.A(A[2]),.B(A[1]),.S(A[0]),.Y(Y));
+endmodule
+
+//Inverter
+(* techmap_celltype = "$lut" *)
+module \$lut_5 (A, Y);
+    parameter LUT = 0;
+    parameter WIDTH = 3;
+
+    wire _TECHMAP_FAIL_ = (WIDTH != 1) || LUT != 2'b01;
+
+    input [WIDTH-1:0] A;
+    output Y;
+
+    assign Y = ~A;
+endmodule
+
+
+//THIS IS ADDED RECENTENLY DELETE IF CREATES A FAULT
+// Inverter but by having 0 and 1 mapped to its inputs
+//(* techmap_celltype = "$lut" *)
+//module \$lut_6 (A, Y);
+//    parameter LUT = 0;
+//    parameter WIDTH = 3;
+//
+//    wire _TECHMAP_FAIL_ = (WIDTH != 3) || LUT != 8'b01110010;
+//
+//    input [WIDTH-1:0] A;
+//    output Y;
+//
+//    $mux #(.WIDTH(1)) switch_mux_1 (.A(~A[2]),.B(A[1]),.S(A[0]),.Y(Y));
+//endmodule
diff --git a/yosys/muxig_synth.ys b/yosys/muxig_synth.ys
new file mode 100644
index 0000000..89236f6
--- /dev/null
+++ b/yosys/muxig_synth.ys
@@ -0,0 +1,65 @@
+######################### preprocessing ###########################################################################
+read_verilog {{VERILOG_FILE}}
+hierarchy -top {{TOP_MODULE}}
+proc;;
+opt;;;
+flatten -noscopeinfo;;
+opt;;;
+techmap;;
+opt;;;
+splitnets -ports;;
+opt;;;
+
+########################## write design to a blif file and delete empty line because mockturtle cannot handle that #
+write_blif {{TEMP_DIR}}/{{BASE_NAME}}.blif
+exec -- sed -i '/^$/d' {{TEMP_DIR}}/{{BASE_NAME}}.blif
+rename {{TOP_MODULE}} {{TOP_MODULE}}_golden
+
+########################## execute muxig pass map the result back to yosys names and rename the module #############
+exec -- time -f "\nTime: %E\nCPU: %P\nMemory: %M KB" -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_muxig_time.txt ./build/src/convert_muxig_opt -o {{OUT_DIR}}/{{BASE_NAME}} {{TEMP_DIR}}/{{BASE_NAME}}.blif
+exec -- python ./yosys/map_ports.py {{TEMP_DIR}}/{{BASE_NAME}}.blif {{TEMP_DIR}}/{{BASE_NAME}}_muxig_temp.blif
+read_blif {{TEMP_DIR}}/{{BASE_NAME}}_muxig.blif
+rename top {{TOP_MODULE}}_muxig
+copy {{TOP_MODULE}}_muxig {{TOP_MODULE}}_muxig_sat
+
+########################## read back the optimization and map it back to yosys internal gates #######################
+techmap -map yosys/mockturtle_map.v {{TOP_MODULE}}_muxig
+techmap {{TOP_MODULE}}_muxig
+opt {{TOP_MODULE}}_muxig
+
+########################### check equality of the optimization ######################################################
+{{SAT}}techmap -map yosys/mockturtle_map.v {{BASE_NAME}}_muxig_sat
+{{SAT}}techmap {{BASE_NAME}}_muxig_sat
+{{SAT}}miter -equiv -make_assert {{TOP_MODULE}}_golden {{TOP_MODULE}}_muxig_sat equal
+{{SAT}}flatten equal
+{{SAT}}clean equal
+{{SAT}}opt -full equal
+{{SAT}}techmap equal
+{{SAT}}sat -prove-asserts -set-init-zero -tempinduct -verify -show-regs -show-inputs -show-outputs -dump_vcd trace.vcd equal
+
+########################### write data without abc pass #############################################################
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_muxig.json stat -json {{TOP_MODULE}}_muxig
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden.json stat -json {{TOP_MODULE}}_golden
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_muxig_ltp.txt ltp {{TOP_MODULE}}_muxig
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden_ltp.txt ltp {{TOP_MODULE}}_golden
+
+########################### abc pass for the golden solution ########################################################
+copy {{TOP_MODULE}}_golden {{TOP_MODULE}}_golden_abc
+abc -liberty {{LIBERTY_FILE}} {{TOP_MODULE}}_golden_abc
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden_abc.json stat -json {{TOP_MODULE}}_golden_abc
+
+########################### abc pass for the optimization solution #################################################
+copy {{TOP_MODULE}}_muxig {{TOP_MODULE}}_muxig_abc
+abc -liberty {{LIBERTY_FILE}} -script "+attach"
+tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_muxig_abc.json stat -json {{TOP_MODULE}}_muxig_abc
+
+########################### write abc blif and verilog #############################################################
+write_blif -top {{TOP_MODULE}}_muxig_abc {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_muxig_abc.blif
+write_blif -top {{TOP_MODULE}}_golden_abc {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden_abc.blif
+select {{TOP_MODULE}}_muxig_abc
+write_verilog -selected {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_muxig_abc.v
+select {{TOP_MODULE}}_golden_abc
+write_verilog -selected {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_golden_abc.v
+
+### this does not work for now so it is not considered
+#tee -o {{OUT_DIR}}/{{BASE_NAME}}/{{BASE_NAME}}_muxig_abc_ltp.txt ltp {{TOP_MODULE}}_muxig_abc
diff --git a/yosys/muxxor_4T.v b/yosys/muxxor_4T.v
new file mode 100644
index 0000000..e4cdc8c
--- /dev/null
+++ b/yosys/muxxor_4T.v
@@ -0,0 +1,6 @@
+module muxxor_4T (
+    input a_i,b_i,not_b_i,in0_i,in1_i,
+    output o
+);
+  assign o = a_i ^ b_i ? in0_i : in1_i;
+endmodule
diff --git a/yosys/muxxor_inv_map.v b/yosys/muxxor_inv_map.v
new file mode 100644
index 0000000..66409c0
--- /dev/null
+++ b/yosys/muxxor_inv_map.v
@@ -0,0 +1,14 @@
+// not needed is treated as blackbox
+/*module muxxor_4T (
+  input a_i,b_i,not_b_i,in0_i,in1_i,
+  output out
+);
+endmodule*/
+
+// needed to rename ports outerwise they are optimized away
+module muxxor_inv (
+    input a,b,in0,in1,
+    output o
+);
+  muxxor_4T s_xor (.a_i(a), .b_i(b), .not_b_i(~b), .in0_i(in0), .in1_i(in1), .out_i(o));
+endmodule
diff --git a/yosys/muxxor_inv_sat.v b/yosys/muxxor_inv_sat.v
new file mode 100644
index 0000000..e307af3
--- /dev/null
+++ b/yosys/muxxor_inv_sat.v
@@ -0,0 +1,6 @@
+module muxxor_inv (
+    input a,b,in0,in1,
+    output o
+);
+  assign o = a ^ b ? in0 : in1;
+endmodule
diff --git a/yosys/print_summary.py b/yosys/print_summary.py
new file mode 100644
index 0000000..2ac5827
--- /dev/null
+++ b/yosys/print_summary.py
@@ -0,0 +1,117 @@
+import os
+import sys
+import json
+import yaml
+import matplotlib.pyplot as plt
+import numpy as np
+import re
+
+# Load device weights from YAML
+with open("yosys/device_count.yaml") as f:
+    device_weights = yaml.safe_load(f)
+
+type_map = {
+    "_muxig.json": "muxig",
+    "_muxig_abc.json": "muxig abc",
+    "_bbdd.json": "bbdd",
+    "_bbdd_abc.json": "bbdd abc",
+    "_bdd.json": "bdd",
+    "_bdd_abc.json": "bdd abc",
+    "_golden.json": "golden",
+    "_golden_abc.json": "golden abc"
+}
+
+
+data_dir = sys.argv[1]
+device_counts = dict()
+time_data = dict()
+memory_data = dict()
+print("Collecting summary from ", data_dir)
+#for variant in ["muxig","muxig_abc", "bdd", "bbdd", "bbdd_abc", "golden_abc", "golden"]:
+for filename in os.listdir(data_dir):
+    file_path = os.path.join(data_dir, filename)
+    if not os.path.isfile(file_path):
+        continue
+    
+    for suffix, type_name in type_map.items():
+        if filename.endswith(suffix):
+            with open(file_path) as f:
+                json_data = json.load(f)
+            # Assumes single module
+            module_data = list(json_data["modules"].values())[0]
+            num_cells = module_data["num_cells_by_type"]
+            device_sum = 0;
+            for cell_type in num_cells:
+                device_sum = device_sum + (num_cells[cell_type] * device_weights[cell_type]["4T"])
+                device_sum = device_sum + (num_cells[cell_type] * device_weights[cell_type]["3T"])
+            device_counts[type_name] = device_sum
+
+    if filename.endswith("_time.txt"):
+        time_path = os.path.join(data_dir, filename)
+        #get extension name
+        basename = filename.rsplit('.', 1)[0]  # e.g. "xx_bdd_time"
+        parts = basename.split('_')
+        opt_name = parts[-2]  # second last part is the middle part
+        time_data.setdefault(opt_name, dict())
+        memory_data.setdefault(opt_name, dict())
+        with open(time_path, 'r') as file:
+            for line in file:
+                if line.startswith("Time:"):
+                    time_str = line.split()[1]  # e.g. "0:00.03"
+                    minutes, seconds = time_str.split(':')
+                    if (filename.startswith("yosys")):
+                        yosys_seconds = int(minutes) * 60 + float(seconds)
+                        time_data[opt_name]["yosys"] = yosys_seconds * 1000
+                    else:
+                        opt_seconds = int(minutes) * 60 + float(seconds)
+                        time_data[opt_name]["opt"] = opt_seconds * 1000
+                match = re.search(r'(\d+)', line)
+                if match:
+                    if (filename.startswith("yosys")):
+                        memory_data[opt_name]["yosys"] = int(match.group(1))
+                    else:
+                        memory_data[opt_name]["opt"] = int(match.group(1))
+
+#print(device_counts)
+title = "SUMMARY"
+types = [str(v) for v in list(device_counts.keys())]
+data = [str(v) for v in list(device_counts.values())]
+cell_width = max(len(s) for s in types)
+
+# Calculate width based on the data row
+formatted_data = [s.center(cell_width) for s in data]
+formatted_types = [s.center(cell_width) for s in types]
+data_row = f"| {' | '.join(formatted_data)} |"
+types_row = f"| {' | '.join(formatted_types)} |"
+
+box_width = len(types_row)
+
+# Print the box
+print("-" * box_width)
+print(f"| {title.center(box_width - 4)} |")
+print("-" * box_width)
+print(types_row)
+print("-" * box_width)
+print(data_row)
+print("-" * box_width)
+
+print("Runtime Summary")
+for opt in time_data.keys():
+    t_data = time_data[opt]
+    m_data = memory_data[opt]
+
+    # Time calculation
+    t_num = t_data["opt"] / t_data["yosys"] * 100
+    print("Optimization", opt, 
+          "Time yosys:", t_data["yosys"], 
+          "Time opt:", t_data["opt"], 
+          "Overhead in %:", f"{t_num:.2f}")
+    #print(f"{t_data['yosys']},{t_data['opt']},{t_num:.2f}")
+
+    # Memory calculation
+    m_num = m_data["opt"] / m_data["yosys"] * 100
+    print("Optimization", opt, 
+          "Memory yosys:", m_data["yosys"], 
+          "Memory opt:", m_data["opt"], 
+          "Overhead in %:", f"{m_num:.2f}")
+    print(f"{t_data['yosys']},{t_data['opt']},{t_num:.2f},{m_data['yosys']},{m_data['opt']},{m_num:.2f}")
diff --git a/yosys/techmap_bbdd.v b/yosys/techmap_bbdd.v
new file mode 100644
index 0000000..bc68873
--- /dev/null
+++ b/yosys/techmap_bbdd.v
@@ -0,0 +1,42 @@
+//Mux
+(* techmap_celltype = "$lut" *)
+module \$lut_1 (A, Y);
+    parameter LUT = 0;
+    parameter WIDTH = 3;
+
+    wire _TECHMAP_FAIL_ = (WIDTH != 3) || LUT != 8'b11011000; 
+
+    input [WIDTH-1:0] A;
+    output Y;
+
+    //$mux #(.WIDTH(1)) switch_mux_2 (.A(A[2]),.B(A[1]),.S(A[0]),.Y(Y));
+    assign Y = A[0] ? A[2] : A[1];
+endmodule
+
+//Xnor
+(* techmap_celltype = "$lut" *)
+module \$lut_2 (A, Y);
+    parameter LUT = 0;
+    parameter WIDTH = 2;
+
+    wire _TECHMAP_FAIL_ = (WIDTH != 2) || LUT != 4'b1001; 
+
+    input [WIDTH-1:0] A;
+    output Y;
+
+    assign Y = A[0] ^ A[1];
+endmodule
+
+//MUXXOR
+(* techmap_celltype = "$lut" *)
+module \$lut_3 (A, Y);
+    parameter LUT = 0;
+    parameter WIDTH = 4;
+
+    wire _TECHMAP_FAIL_ = (WIDTH != 4) || LUT != 16'b1111100101100000; 
+
+    input [WIDTH-1:0] A;
+    output Y;
+
+    muxxor_inv muxxor1 (.a(A[0]), .b(A[1]), .in0(A[2]), .in1(A[3]), .o(Y));
+endmodule
diff --git a/yosys/techmap_nems.v b/yosys/techmap_nems.v
new file mode 100644
index 0000000..0f4f5bd
--- /dev/null
+++ b/yosys/techmap_nems.v
@@ -0,0 +1,85 @@
+//Mux
+(* techmap_celltype = "$lut" *)
+module \$lut_1 (A, Y);
+    parameter LUT = 0;
+    parameter WIDTH = 3;
+
+    wire _TECHMAP_FAIL_ = (WIDTH != 3) || LUT != 8'b11011000; 
+
+    input [WIDTH-1:0] A;
+    output Y;
+
+    //$mux #(.WIDTH(1)) switch_mux_2 (.A(A[2]),.B(A[1]),.S(A[0]),.Y(Y));
+    assign Y = A[0] ? A[2] : A[1];
+endmodule
+
+//Xnor
+(* techmap_celltype = "$lut" *)
+module \$lut_2 (A, Y);
+    parameter LUT = 0;
+    parameter WIDTH = 2;
+
+    wire _TECHMAP_FAIL_ = (WIDTH != 2) || LUT != 4'b1001; 
+
+    input [WIDTH-1:0] A;
+    output Y;
+
+    assign Y = A[0] ^ A[1];
+endmodule
+
+//Inverter
+(* techmap_celltype = "$lut" *)
+module \$lut_3 (A, Y);
+    parameter LUT = 0;
+    parameter WIDTH = 3;
+
+    wire _TECHMAP_FAIL_ = (WIDTH != 1) || LUT != 2'b01;
+
+    input [WIDTH-1:0] A;
+    output Y;
+
+    assign Y = ~A;
+endmodule
+
+//Inverted Select
+(* techmap_celltype = "$lut" *)
+module \$lut_4 (A, Y);
+    parameter LUT = 0;
+    parameter WIDTH = 3;
+
+    wire _TECHMAP_FAIL_ = (WIDTH != 3) || LUT != 8'b11100100;
+
+    input [WIDTH-1:0] A;
+    output Y;
+    
+    $mux #(.WIDTH(1)) switch_mux_1 (.A(A[2]),.B(A[1]),.S(~A[0]),.Y(Y));
+endmodule
+
+//Inverted Select and inverted A input.
+(* techmap_celltype = "$lut" *)
+module \$lut_5 (A, Y);
+    parameter LUT = 0;
+    parameter WIDTH = 3;
+
+    wire _TECHMAP_FAIL_ = (WIDTH != 3) || LUT != 8'b01001110; 
+
+    input [WIDTH-1:0] A;
+    output Y;
+
+    $mux #(.WIDTH(1)) switch_mux_2 (.A(~A[2]),.B(A[1]),.S(~A[0]),.Y(Y));
+endmodule
+
+//Only Inverted A input
+(* techmap_celltype = "$lut" *)
+module \$lut_6 (A, Y);
+    parameter LUT = 0;
+    parameter WIDTH = 3;
+
+    wire _TECHMAP_FAIL_ = (WIDTH != 3) || LUT != 8'b10001101;
+
+    input [WIDTH-1:0] A;
+    output Y;
+
+    $mux #(.WIDTH(1)) switch_mux_3 (.A(~A[2]),.B(A[1]),.S(A[0]),.Y(Y));
+endmodule
+
diff --git a/yosys/xor_mux.v b/yosys/xor_mux.v
new file mode 100644
index 0000000..650a533
--- /dev/null
+++ b/yosys/xor_mux.v
@@ -0,0 +1,7 @@
+// this file is used to extract xor gates from the muxig
+module xor_mux(
+  input in0,in1,s,
+  output out
+);
+  assign out = s ? in1 : in0;
+endmodule